projects / deliverable / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Fix compile time warnings building the binutils with clang.
[deliverable/binutils-gdb.git] / bfd / elf64-ppc.c
1 /* PowerPC64-specific support for 64-bit ELF.
2 Copyright (C) 1999-2018 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_want_dynrelro 1
76 #define elf_backend_can_gc_sections 1
77 #define elf_backend_can_refcount 1
78 #define elf_backend_rela_normal 1
79 #define elf_backend_dtrel_excludes_plt 1
80 #define elf_backend_default_execstack 0
81
82 #define bfd_elf64_mkobject ppc64_elf_mkobject
83 #define bfd_elf64_bfd_reloc_type_lookup ppc64_elf_reloc_type_lookup
84 #define bfd_elf64_bfd_reloc_name_lookup ppc64_elf_reloc_name_lookup
85 #define bfd_elf64_bfd_merge_private_bfd_data ppc64_elf_merge_private_bfd_data
86 #define bfd_elf64_bfd_print_private_bfd_data ppc64_elf_print_private_bfd_data
87 #define bfd_elf64_new_section_hook ppc64_elf_new_section_hook
88 #define bfd_elf64_bfd_link_hash_table_create ppc64_elf_link_hash_table_create
89 #define bfd_elf64_get_synthetic_symtab ppc64_elf_get_synthetic_symtab
90 #define bfd_elf64_bfd_link_just_syms ppc64_elf_link_just_syms
91 #define bfd_elf64_bfd_gc_sections ppc64_elf_gc_sections
92
93 #define elf_backend_object_p ppc64_elf_object_p
94 #define elf_backend_grok_prstatus ppc64_elf_grok_prstatus
95 #define elf_backend_grok_psinfo ppc64_elf_grok_psinfo
96 #define elf_backend_write_core_note ppc64_elf_write_core_note
97 #define elf_backend_create_dynamic_sections _bfd_elf_create_dynamic_sections
98 #define elf_backend_copy_indirect_symbol ppc64_elf_copy_indirect_symbol
99 #define elf_backend_add_symbol_hook ppc64_elf_add_symbol_hook
100 #define elf_backend_check_directives ppc64_elf_before_check_relocs
101 #define elf_backend_notice_as_needed ppc64_elf_notice_as_needed
102 #define elf_backend_archive_symbol_lookup ppc64_elf_archive_symbol_lookup
103 #define elf_backend_check_relocs ppc64_elf_check_relocs
104 #define elf_backend_relocs_compatible _bfd_elf_relocs_compatible
105 #define elf_backend_gc_keep ppc64_elf_gc_keep
106 #define elf_backend_gc_mark_dynamic_ref ppc64_elf_gc_mark_dynamic_ref
107 #define elf_backend_gc_mark_hook ppc64_elf_gc_mark_hook
108 #define elf_backend_adjust_dynamic_symbol ppc64_elf_adjust_dynamic_symbol
109 #define elf_backend_hide_symbol ppc64_elf_hide_symbol
110 #define elf_backend_maybe_function_sym ppc64_elf_maybe_function_sym
111 #define elf_backend_always_size_sections ppc64_elf_func_desc_adjust
112 #define elf_backend_size_dynamic_sections ppc64_elf_size_dynamic_sections
113 #define elf_backend_hash_symbol ppc64_elf_hash_symbol
114 #define elf_backend_init_index_section _bfd_elf_init_2_index_sections
115 #define elf_backend_action_discarded ppc64_elf_action_discarded
116 #define elf_backend_relocate_section ppc64_elf_relocate_section
117 #define elf_backend_finish_dynamic_symbol ppc64_elf_finish_dynamic_symbol
118 #define elf_backend_reloc_type_class ppc64_elf_reloc_type_class
119 #define elf_backend_finish_dynamic_sections ppc64_elf_finish_dynamic_sections
120 #define elf_backend_link_output_symbol_hook ppc64_elf_output_symbol_hook
121 #define elf_backend_special_sections ppc64_elf_special_sections
122 #define elf_backend_merge_symbol_attribute ppc64_elf_merge_symbol_attribute
123 #define elf_backend_merge_symbol ppc64_elf_merge_symbol
124 #define elf_backend_get_reloc_section bfd_get_section_by_name
125
126 /* The name of the dynamic interpreter. This is put in the .interp
127 section. */
128 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
129
130 /* The size in bytes of an entry in the procedure linkage table. */
131 #define PLT_ENTRY_SIZE(htab) (htab->opd_abi ? 24 : 8)
132
133 /* The initial size of the plt reserved for the dynamic linker. */
134 #define PLT_INITIAL_ENTRY_SIZE(htab) (htab->opd_abi ? 24 : 16)
135
136 /* Offsets to some stack save slots. */
137 #define STK_LR 16
138 #define STK_TOC(htab) (htab->opd_abi ? 40 : 24)
139 /* This one is dodgy. ELFv2 does not have a linker word, so use the
140 CR save slot. Used only by optimised __tls_get_addr call stub,
141 relying on __tls_get_addr_opt not saving CR.. */
142 #define STK_LINKER(htab) (htab->opd_abi ? 32 : 8)
143
144 /* TOC base pointers offset from start of TOC. */
145 #define TOC_BASE_OFF 0x8000
146 /* TOC base alignment. */
147 #define TOC_BASE_ALIGN 256
148
149 /* Offset of tp and dtp pointers from start of TLS block. */
150 #define TP_OFFSET 0x7000
151 #define DTP_OFFSET 0x8000
152
153 /* .plt call stub instructions. The normal stub is like this, but
154 sometimes the .plt entry crosses a 64k boundary and we need to
155 insert an addi to adjust r11. */
156 #define STD_R2_0R1 0xf8410000 /* std %r2,0+40(%r1) */
157 #define ADDIS_R11_R2 0x3d620000 /* addis %r11,%r2,xxx@ha */
158 #define LD_R12_0R11 0xe98b0000 /* ld %r12,xxx+0@l(%r11) */
159 #define MTCTR_R12 0x7d8903a6 /* mtctr %r12 */
160 #define LD_R2_0R11 0xe84b0000 /* ld %r2,xxx+8@l(%r11) */
161 #define LD_R11_0R11 0xe96b0000 /* ld %r11,xxx+16@l(%r11) */
162 #define BCTR 0x4e800420 /* bctr */
163
164 #define CRSETEQ 0x4c421242 /* crset 4*%cr0+%eq */
165 #define BEQCTRM 0x4dc20420 /* beqctr- */
166 #define BEQCTRLM 0x4dc20421 /* beqctrl- */
167
168 #define ADDI_R11_R11 0x396b0000 /* addi %r11,%r11,off@l */
169 #define ADDIS_R2_R2 0x3c420000 /* addis %r2,%r2,off@ha */
170 #define ADDI_R2_R2 0x38420000 /* addi %r2,%r2,off@l */
171
172 #define XOR_R2_R12_R12 0x7d826278 /* xor %r2,%r12,%r12 */
173 #define ADD_R11_R11_R2 0x7d6b1214 /* add %r11,%r11,%r2 */
174 #define XOR_R11_R12_R12 0x7d8b6278 /* xor %r11,%r12,%r12 */
175 #define ADD_R2_R2_R11 0x7c425a14 /* add %r2,%r2,%r11 */
176 #define CMPLDI_R2_0 0x28220000 /* cmpldi %r2,0 */
177 #define BNECTR 0x4ca20420 /* bnectr+ */
178 #define BNECTR_P4 0x4ce20420 /* bnectr+ */
179
180 #define LD_R12_0R2 0xe9820000 /* ld %r12,xxx+0(%r2) */
181 #define LD_R11_0R2 0xe9620000 /* ld %r11,xxx+0(%r2) */
182 #define LD_R2_0R2 0xe8420000 /* ld %r2,xxx+0(%r2) */
183
184 #define LD_R2_0R1 0xe8410000 /* ld %r2,0(%r1) */
185 #define LD_R2_0R12 0xe84c0000 /* ld %r2,0(%r12) */
186 #define ADD_R2_R2_R12 0x7c426214 /* add %r2,%r2,%r12 */
187
188 #define LIS_R2 0x3c400000 /* lis %r2,xxx@ha */
189 #define ADDIS_R2_R12 0x3c4c0000 /* addis %r2,%r12,xxx@ha */
190 #define ADDIS_R12_R2 0x3d820000 /* addis %r12,%r2,xxx@ha */
191 #define ADDIS_R12_R12 0x3d8c0000 /* addis %r12,%r12,xxx@ha */
192 #define LD_R12_0R12 0xe98c0000 /* ld %r12,xxx@l(%r12) */
193
194 /* __glink_PLTresolve stub instructions. We enter with the index in R0. */
195 #define GLINK_PLTRESOLVE_SIZE(htab) \
196 (8u + (htab->opd_abi ? 11 * 4 : 14 * 4) \
197 + (!htab->params->speculate_indirect_jumps ? 2 * 4 : 0))
198 /* 0: */
199 /* .quad plt0-1f */
200 /* __glink: */
201 #define MFLR_R12 0x7d8802a6 /* mflr %12 */
202 #define BCL_20_31 0x429f0005 /* bcl 20,31,1f */
203 /* 1: */
204 #define MFLR_R11 0x7d6802a6 /* mflr %11 */
205 /* ld %2,(0b-1b)(%11) */
206 #define MTLR_R12 0x7d8803a6 /* mtlr %12 */
207 #define ADD_R11_R2_R11 0x7d625a14 /* add %11,%2,%11 */
208 /* ld %12,0(%11) */
209 /* ld %2,8(%11) */
210 /* mtctr %12 */
211 /* ld %11,16(%11) */
212 /* bctr */
213 #define MFLR_R0 0x7c0802a6 /* mflr %r0 */
214 #define MTLR_R0 0x7c0803a6 /* mtlr %r0 */
215 #define SUB_R12_R12_R11 0x7d8b6050 /* subf %r12,%r11,%r12 */
216 #define ADDI_R0_R12 0x380c0000 /* addi %r0,%r12,0 */
217 #define SRDI_R0_R0_2 0x7800f082 /* rldicl %r0,%r0,62,2 */
218
219 /* Pad with this. */
220 #define NOP 0x60000000
221
222 /* Some other nops. */
223 #define CROR_151515 0x4def7b82
224 #define CROR_313131 0x4ffffb82
225
226 /* .glink entries for the first 32k functions are two instructions. */
227 #define LI_R0_0 0x38000000 /* li %r0,0 */
228 #define B_DOT 0x48000000 /* b . */
229
230 /* After that, we need two instructions to load the index, followed by
231 a branch. */
232 #define LIS_R0_0 0x3c000000 /* lis %r0,0 */
233 #define ORI_R0_R0_0 0x60000000 /* ori %r0,%r0,0 */
234
235 /* Instructions used by the save and restore reg functions. */
236 #define STD_R0_0R1 0xf8010000 /* std %r0,0(%r1) */
237 #define STD_R0_0R12 0xf80c0000 /* std %r0,0(%r12) */
238 #define LD_R0_0R1 0xe8010000 /* ld %r0,0(%r1) */
239 #define LD_R0_0R12 0xe80c0000 /* ld %r0,0(%r12) */
240 #define STFD_FR0_0R1 0xd8010000 /* stfd %fr0,0(%r1) */
241 #define LFD_FR0_0R1 0xc8010000 /* lfd %fr0,0(%r1) */
242 #define LI_R12_0 0x39800000 /* li %r12,0 */
243 #define STVX_VR0_R12_R0 0x7c0c01ce /* stvx %v0,%r12,%r0 */
244 #define LVX_VR0_R12_R0 0x7c0c00ce /* lvx %v0,%r12,%r0 */
245 #define MTLR_R0 0x7c0803a6 /* mtlr %r0 */
246 #define BLR 0x4e800020 /* blr */
247
248 /* Since .opd is an array of descriptors and each entry will end up
249 with identical R_PPC64_RELATIVE relocs, there is really no need to
250 propagate .opd relocs; The dynamic linker should be taught to
251 relocate .opd without reloc entries. */
252 #ifndef NO_OPD_RELOCS
253 #define NO_OPD_RELOCS 0
254 #endif
255
256 #ifndef ARRAY_SIZE
257 #define ARRAY_SIZE(a) (sizeof (a) / sizeof ((a)[0]))
258 #endif
259
260 static inline int
261 abiversion (bfd *abfd)
262 {
263 return elf_elfheader (abfd)->e_flags & EF_PPC64_ABI;
264 }
265
266 static inline void
267 set_abiversion (bfd *abfd, int ver)
268 {
269 elf_elfheader (abfd)->e_flags &= ~EF_PPC64_ABI;
270 elf_elfheader (abfd)->e_flags |= ver & EF_PPC64_ABI;
271 }
272 \f
273 #define ONES(n) (((bfd_vma) 1 << ((n) - 1) << 1) - 1)
274
275 /* Relocation HOWTO's. */
276 static reloc_howto_type *ppc64_elf_howto_table[(int) R_PPC64_max];
277
278 static reloc_howto_type ppc64_elf_howto_raw[] = {
279 /* This reloc does nothing. */
280 HOWTO (R_PPC64_NONE, /* type */
281 0, /* rightshift */
282 3, /* size (0 = byte, 1 = short, 2 = long) */
283 0, /* bitsize */
284 FALSE, /* pc_relative */
285 0, /* bitpos */
286 complain_overflow_dont, /* complain_on_overflow */
287 bfd_elf_generic_reloc, /* special_function */
288 "R_PPC64_NONE", /* name */
289 FALSE, /* partial_inplace */
290 0, /* src_mask */
291 0, /* dst_mask */
292 FALSE), /* pcrel_offset */
293
294 /* A standard 32 bit relocation. */
295 HOWTO (R_PPC64_ADDR32, /* type */
296 0, /* rightshift */
297 2, /* size (0 = byte, 1 = short, 2 = long) */
298 32, /* bitsize */
299 FALSE, /* pc_relative */
300 0, /* bitpos */
301 complain_overflow_bitfield, /* complain_on_overflow */
302 bfd_elf_generic_reloc, /* special_function */
303 "R_PPC64_ADDR32", /* name */
304 FALSE, /* partial_inplace */
305 0, /* src_mask */
306 0xffffffff, /* dst_mask */
307 FALSE), /* pcrel_offset */
308
309 /* An absolute 26 bit branch; the lower two bits must be zero.
310 FIXME: we don't check that, we just clear them. */
311 HOWTO (R_PPC64_ADDR24, /* type */
312 0, /* rightshift */
313 2, /* size (0 = byte, 1 = short, 2 = long) */
314 26, /* bitsize */
315 FALSE, /* pc_relative */
316 0, /* bitpos */
317 complain_overflow_bitfield, /* complain_on_overflow */
318 bfd_elf_generic_reloc, /* special_function */
319 "R_PPC64_ADDR24", /* name */
320 FALSE, /* partial_inplace */
321 0, /* src_mask */
322 0x03fffffc, /* dst_mask */
323 FALSE), /* pcrel_offset */
324
325 /* A standard 16 bit relocation. */
326 HOWTO (R_PPC64_ADDR16, /* type */
327 0, /* rightshift */
328 1, /* size (0 = byte, 1 = short, 2 = long) */
329 16, /* bitsize */
330 FALSE, /* pc_relative */
331 0, /* bitpos */
332 complain_overflow_bitfield, /* complain_on_overflow */
333 bfd_elf_generic_reloc, /* special_function */
334 "R_PPC64_ADDR16", /* name */
335 FALSE, /* partial_inplace */
336 0, /* src_mask */
337 0xffff, /* dst_mask */
338 FALSE), /* pcrel_offset */
339
340 /* A 16 bit relocation without overflow. */
341 HOWTO (R_PPC64_ADDR16_LO, /* type */
342 0, /* rightshift */
343 1, /* size (0 = byte, 1 = short, 2 = long) */
344 16, /* bitsize */
345 FALSE, /* pc_relative */
346 0, /* bitpos */
347 complain_overflow_dont,/* complain_on_overflow */
348 bfd_elf_generic_reloc, /* special_function */
349 "R_PPC64_ADDR16_LO", /* name */
350 FALSE, /* partial_inplace */
351 0, /* src_mask */
352 0xffff, /* dst_mask */
353 FALSE), /* pcrel_offset */
354
355 /* Bits 16-31 of an address. */
356 HOWTO (R_PPC64_ADDR16_HI, /* type */
357 16, /* rightshift */
358 1, /* size (0 = byte, 1 = short, 2 = long) */
359 16, /* bitsize */
360 FALSE, /* pc_relative */
361 0, /* bitpos */
362 complain_overflow_signed, /* complain_on_overflow */
363 bfd_elf_generic_reloc, /* special_function */
364 "R_PPC64_ADDR16_HI", /* name */
365 FALSE, /* partial_inplace */
366 0, /* src_mask */
367 0xffff, /* dst_mask */
368 FALSE), /* pcrel_offset */
369
370 /* Bits 16-31 of an address, plus 1 if the contents of the low 16
371 bits, treated as a signed number, is negative. */
372 HOWTO (R_PPC64_ADDR16_HA, /* type */
373 16, /* rightshift */
374 1, /* size (0 = byte, 1 = short, 2 = long) */
375 16, /* bitsize */
376 FALSE, /* pc_relative */
377 0, /* bitpos */
378 complain_overflow_signed, /* complain_on_overflow */
379 ppc64_elf_ha_reloc, /* special_function */
380 "R_PPC64_ADDR16_HA", /* name */
381 FALSE, /* partial_inplace */
382 0, /* src_mask */
383 0xffff, /* dst_mask */
384 FALSE), /* pcrel_offset */
385
386 /* An absolute 16 bit branch; the lower two bits must be zero.
387 FIXME: we don't check that, we just clear them. */
388 HOWTO (R_PPC64_ADDR14, /* type */
389 0, /* rightshift */
390 2, /* size (0 = byte, 1 = short, 2 = long) */
391 16, /* bitsize */
392 FALSE, /* pc_relative */
393 0, /* bitpos */
394 complain_overflow_signed, /* complain_on_overflow */
395 ppc64_elf_branch_reloc, /* special_function */
396 "R_PPC64_ADDR14", /* name */
397 FALSE, /* partial_inplace */
398 0, /* src_mask */
399 0x0000fffc, /* dst_mask */
400 FALSE), /* pcrel_offset */
401
402 /* An absolute 16 bit branch, for which bit 10 should be set to
403 indicate that the branch is expected to be taken. The lower two
404 bits must be zero. */
405 HOWTO (R_PPC64_ADDR14_BRTAKEN, /* type */
406 0, /* rightshift */
407 2, /* size (0 = byte, 1 = short, 2 = long) */
408 16, /* bitsize */
409 FALSE, /* pc_relative */
410 0, /* bitpos */
411 complain_overflow_signed, /* complain_on_overflow */
412 ppc64_elf_brtaken_reloc, /* special_function */
413 "R_PPC64_ADDR14_BRTAKEN",/* name */
414 FALSE, /* partial_inplace */
415 0, /* src_mask */
416 0x0000fffc, /* dst_mask */
417 FALSE), /* pcrel_offset */
418
419 /* An absolute 16 bit branch, for which bit 10 should be set to
420 indicate that the branch is not expected to be taken. The lower
421 two bits must be zero. */
422 HOWTO (R_PPC64_ADDR14_BRNTAKEN, /* type */
423 0, /* rightshift */
424 2, /* size (0 = byte, 1 = short, 2 = long) */
425 16, /* bitsize */
426 FALSE, /* pc_relative */
427 0, /* bitpos */
428 complain_overflow_signed, /* complain_on_overflow */
429 ppc64_elf_brtaken_reloc, /* special_function */
430 "R_PPC64_ADDR14_BRNTAKEN",/* name */
431 FALSE, /* partial_inplace */
432 0, /* src_mask */
433 0x0000fffc, /* dst_mask */
434 FALSE), /* pcrel_offset */
435
436 /* A relative 26 bit branch; the lower two bits must be zero. */
437 HOWTO (R_PPC64_REL24, /* type */
438 0, /* rightshift */
439 2, /* size (0 = byte, 1 = short, 2 = long) */
440 26, /* bitsize */
441 TRUE, /* pc_relative */
442 0, /* bitpos */
443 complain_overflow_signed, /* complain_on_overflow */
444 ppc64_elf_branch_reloc, /* special_function */
445 "R_PPC64_REL24", /* name */
446 FALSE, /* partial_inplace */
447 0, /* src_mask */
448 0x03fffffc, /* dst_mask */
449 TRUE), /* pcrel_offset */
450
451 /* A relative 16 bit branch; the lower two bits must be zero. */
452 HOWTO (R_PPC64_REL14, /* type */
453 0, /* rightshift */
454 2, /* size (0 = byte, 1 = short, 2 = long) */
455 16, /* bitsize */
456 TRUE, /* pc_relative */
457 0, /* bitpos */
458 complain_overflow_signed, /* complain_on_overflow */
459 ppc64_elf_branch_reloc, /* special_function */
460 "R_PPC64_REL14", /* name */
461 FALSE, /* partial_inplace */
462 0, /* src_mask */
463 0x0000fffc, /* dst_mask */
464 TRUE), /* pcrel_offset */
465
466 /* A relative 16 bit branch. Bit 10 should be set to indicate that
467 the branch is expected to be taken. The lower two bits must be
468 zero. */
469 HOWTO (R_PPC64_REL14_BRTAKEN, /* type */
470 0, /* rightshift */
471 2, /* size (0 = byte, 1 = short, 2 = long) */
472 16, /* bitsize */
473 TRUE, /* pc_relative */
474 0, /* bitpos */
475 complain_overflow_signed, /* complain_on_overflow */
476 ppc64_elf_brtaken_reloc, /* special_function */
477 "R_PPC64_REL14_BRTAKEN", /* name */
478 FALSE, /* partial_inplace */
479 0, /* src_mask */
480 0x0000fffc, /* dst_mask */
481 TRUE), /* pcrel_offset */
482
483 /* A relative 16 bit branch. Bit 10 should be set to indicate that
484 the branch is not expected to be taken. The lower two bits must
485 be zero. */
486 HOWTO (R_PPC64_REL14_BRNTAKEN, /* type */
487 0, /* rightshift */
488 2, /* size (0 = byte, 1 = short, 2 = long) */
489 16, /* bitsize */
490 TRUE, /* pc_relative */
491 0, /* bitpos */
492 complain_overflow_signed, /* complain_on_overflow */
493 ppc64_elf_brtaken_reloc, /* special_function */
494 "R_PPC64_REL14_BRNTAKEN",/* name */
495 FALSE, /* partial_inplace */
496 0, /* src_mask */
497 0x0000fffc, /* dst_mask */
498 TRUE), /* pcrel_offset */
499
500 /* Like R_PPC64_ADDR16, but referring to the GOT table entry for the
501 symbol. */
502 HOWTO (R_PPC64_GOT16, /* type */
503 0, /* rightshift */
504 1, /* size (0 = byte, 1 = short, 2 = long) */
505 16, /* bitsize */
506 FALSE, /* pc_relative */
507 0, /* bitpos */
508 complain_overflow_signed, /* complain_on_overflow */
509 ppc64_elf_unhandled_reloc, /* special_function */
510 "R_PPC64_GOT16", /* name */
511 FALSE, /* partial_inplace */
512 0, /* src_mask */
513 0xffff, /* dst_mask */
514 FALSE), /* pcrel_offset */
515
516 /* Like R_PPC64_ADDR16_LO, but referring to the GOT table entry for
517 the symbol. */
518 HOWTO (R_PPC64_GOT16_LO, /* type */
519 0, /* rightshift */
520 1, /* size (0 = byte, 1 = short, 2 = long) */
521 16, /* bitsize */
522 FALSE, /* pc_relative */
523 0, /* bitpos */
524 complain_overflow_dont, /* complain_on_overflow */
525 ppc64_elf_unhandled_reloc, /* special_function */
526 "R_PPC64_GOT16_LO", /* name */
527 FALSE, /* partial_inplace */
528 0, /* src_mask */
529 0xffff, /* dst_mask */
530 FALSE), /* pcrel_offset */
531
532 /* Like R_PPC64_ADDR16_HI, but referring to the GOT table entry for
533 the symbol. */
534 HOWTO (R_PPC64_GOT16_HI, /* type */
535 16, /* rightshift */
536 1, /* size (0 = byte, 1 = short, 2 = long) */
537 16, /* bitsize */
538 FALSE, /* pc_relative */
539 0, /* bitpos */
540 complain_overflow_signed,/* complain_on_overflow */
541 ppc64_elf_unhandled_reloc, /* special_function */
542 "R_PPC64_GOT16_HI", /* name */
543 FALSE, /* partial_inplace */
544 0, /* src_mask */
545 0xffff, /* dst_mask */
546 FALSE), /* pcrel_offset */
547
548 /* Like R_PPC64_ADDR16_HA, but referring to the GOT table entry for
549 the symbol. */
550 HOWTO (R_PPC64_GOT16_HA, /* type */
551 16, /* rightshift */
552 1, /* size (0 = byte, 1 = short, 2 = long) */
553 16, /* bitsize */
554 FALSE, /* pc_relative */
555 0, /* bitpos */
556 complain_overflow_signed,/* complain_on_overflow */
557 ppc64_elf_unhandled_reloc, /* special_function */
558 "R_PPC64_GOT16_HA", /* name */
559 FALSE, /* partial_inplace */
560 0, /* src_mask */
561 0xffff, /* dst_mask */
562 FALSE), /* pcrel_offset */
563
564 /* This is used only by the dynamic linker. The symbol should exist
565 both in the object being run and in some shared library. The
566 dynamic linker copies the data addressed by the symbol from the
567 shared library into the object, because the object being
568 run has to have the data at some particular address. */
569 HOWTO (R_PPC64_COPY, /* type */
570 0, /* rightshift */
571 0, /* this one is variable size */
572 0, /* bitsize */
573 FALSE, /* pc_relative */
574 0, /* bitpos */
575 complain_overflow_dont, /* complain_on_overflow */
576 ppc64_elf_unhandled_reloc, /* special_function */
577 "R_PPC64_COPY", /* name */
578 FALSE, /* partial_inplace */
579 0, /* src_mask */
580 0, /* dst_mask */
581 FALSE), /* pcrel_offset */
582
583 /* Like R_PPC64_ADDR64, but used when setting global offset table
584 entries. */
585 HOWTO (R_PPC64_GLOB_DAT, /* type */
586 0, /* rightshift */
587 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
588 64, /* bitsize */
589 FALSE, /* pc_relative */
590 0, /* bitpos */
591 complain_overflow_dont, /* complain_on_overflow */
592 ppc64_elf_unhandled_reloc, /* special_function */
593 "R_PPC64_GLOB_DAT", /* name */
594 FALSE, /* partial_inplace */
595 0, /* src_mask */
596 ONES (64), /* dst_mask */
597 FALSE), /* pcrel_offset */
598
599 /* Created by the link editor. Marks a procedure linkage table
600 entry for a symbol. */
601 HOWTO (R_PPC64_JMP_SLOT, /* type */
602 0, /* rightshift */
603 0, /* size (0 = byte, 1 = short, 2 = long) */
604 0, /* bitsize */
605 FALSE, /* pc_relative */
606 0, /* bitpos */
607 complain_overflow_dont, /* complain_on_overflow */
608 ppc64_elf_unhandled_reloc, /* special_function */
609 "R_PPC64_JMP_SLOT", /* name */
610 FALSE, /* partial_inplace */
611 0, /* src_mask */
612 0, /* dst_mask */
613 FALSE), /* pcrel_offset */
614
615 /* Used only by the dynamic linker. When the object is run, this
616 doubleword64 is set to the load address of the object, plus the
617 addend. */
618 HOWTO (R_PPC64_RELATIVE, /* type */
619 0, /* rightshift */
620 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
621 64, /* bitsize */
622 FALSE, /* pc_relative */
623 0, /* bitpos */
624 complain_overflow_dont, /* complain_on_overflow */
625 bfd_elf_generic_reloc, /* special_function */
626 "R_PPC64_RELATIVE", /* name */
627 FALSE, /* partial_inplace */
628 0, /* src_mask */
629 ONES (64), /* dst_mask */
630 FALSE), /* pcrel_offset */
631
632 /* Like R_PPC64_ADDR32, but may be unaligned. */
633 HOWTO (R_PPC64_UADDR32, /* type */
634 0, /* rightshift */
635 2, /* size (0 = byte, 1 = short, 2 = long) */
636 32, /* bitsize */
637 FALSE, /* pc_relative */
638 0, /* bitpos */
639 complain_overflow_bitfield, /* complain_on_overflow */
640 bfd_elf_generic_reloc, /* special_function */
641 "R_PPC64_UADDR32", /* name */
642 FALSE, /* partial_inplace */
643 0, /* src_mask */
644 0xffffffff, /* dst_mask */
645 FALSE), /* pcrel_offset */
646
647 /* Like R_PPC64_ADDR16, but may be unaligned. */
648 HOWTO (R_PPC64_UADDR16, /* type */
649 0, /* rightshift */
650 1, /* size (0 = byte, 1 = short, 2 = long) */
651 16, /* bitsize */
652 FALSE, /* pc_relative */
653 0, /* bitpos */
654 complain_overflow_bitfield, /* complain_on_overflow */
655 bfd_elf_generic_reloc, /* special_function */
656 "R_PPC64_UADDR16", /* name */
657 FALSE, /* partial_inplace */
658 0, /* src_mask */
659 0xffff, /* dst_mask */
660 FALSE), /* pcrel_offset */
661
662 /* 32-bit PC relative. */
663 HOWTO (R_PPC64_REL32, /* type */
664 0, /* rightshift */
665 2, /* size (0 = byte, 1 = short, 2 = long) */
666 32, /* bitsize */
667 TRUE, /* pc_relative */
668 0, /* bitpos */
669 complain_overflow_signed, /* complain_on_overflow */
670 bfd_elf_generic_reloc, /* special_function */
671 "R_PPC64_REL32", /* name */
672 FALSE, /* partial_inplace */
673 0, /* src_mask */
674 0xffffffff, /* dst_mask */
675 TRUE), /* pcrel_offset */
676
677 /* 32-bit relocation to the symbol's procedure linkage table. */
678 HOWTO (R_PPC64_PLT32, /* type */
679 0, /* rightshift */
680 2, /* size (0 = byte, 1 = short, 2 = long) */
681 32, /* bitsize */
682 FALSE, /* pc_relative */
683 0, /* bitpos */
684 complain_overflow_bitfield, /* complain_on_overflow */
685 ppc64_elf_unhandled_reloc, /* special_function */
686 "R_PPC64_PLT32", /* name */
687 FALSE, /* partial_inplace */
688 0, /* src_mask */
689 0xffffffff, /* dst_mask */
690 FALSE), /* pcrel_offset */
691
692 /* 32-bit PC relative relocation to the symbol's procedure linkage table.
693 FIXME: R_PPC64_PLTREL32 not supported. */
694 HOWTO (R_PPC64_PLTREL32, /* type */
695 0, /* rightshift */
696 2, /* size (0 = byte, 1 = short, 2 = long) */
697 32, /* bitsize */
698 TRUE, /* pc_relative */
699 0, /* bitpos */
700 complain_overflow_signed, /* complain_on_overflow */
701 ppc64_elf_unhandled_reloc, /* special_function */
702 "R_PPC64_PLTREL32", /* name */
703 FALSE, /* partial_inplace */
704 0, /* src_mask */
705 0xffffffff, /* dst_mask */
706 TRUE), /* pcrel_offset */
707
708 /* Like R_PPC64_ADDR16_LO, but referring to the PLT table entry for
709 the symbol. */
710 HOWTO (R_PPC64_PLT16_LO, /* type */
711 0, /* rightshift */
712 1, /* size (0 = byte, 1 = short, 2 = long) */
713 16, /* bitsize */
714 FALSE, /* pc_relative */
715 0, /* bitpos */
716 complain_overflow_dont, /* complain_on_overflow */
717 ppc64_elf_unhandled_reloc, /* special_function */
718 "R_PPC64_PLT16_LO", /* name */
719 FALSE, /* partial_inplace */
720 0, /* src_mask */
721 0xffff, /* dst_mask */
722 FALSE), /* pcrel_offset */
723
724 /* Like R_PPC64_ADDR16_HI, but referring to the PLT table entry for
725 the symbol. */
726 HOWTO (R_PPC64_PLT16_HI, /* type */
727 16, /* rightshift */
728 1, /* size (0 = byte, 1 = short, 2 = long) */
729 16, /* bitsize */
730 FALSE, /* pc_relative */
731 0, /* bitpos */
732 complain_overflow_signed, /* complain_on_overflow */
733 ppc64_elf_unhandled_reloc, /* special_function */
734 "R_PPC64_PLT16_HI", /* name */
735 FALSE, /* partial_inplace */
736 0, /* src_mask */
737 0xffff, /* dst_mask */
738 FALSE), /* pcrel_offset */
739
740 /* Like R_PPC64_ADDR16_HA, but referring to the PLT table entry for
741 the symbol. */
742 HOWTO (R_PPC64_PLT16_HA, /* type */
743 16, /* rightshift */
744 1, /* size (0 = byte, 1 = short, 2 = long) */
745 16, /* bitsize */
746 FALSE, /* pc_relative */
747 0, /* bitpos */
748 complain_overflow_signed, /* complain_on_overflow */
749 ppc64_elf_unhandled_reloc, /* special_function */
750 "R_PPC64_PLT16_HA", /* name */
751 FALSE, /* partial_inplace */
752 0, /* src_mask */
753 0xffff, /* dst_mask */
754 FALSE), /* pcrel_offset */
755
756 /* 16-bit section relative relocation. */
757 HOWTO (R_PPC64_SECTOFF, /* type */
758 0, /* rightshift */
759 1, /* size (0 = byte, 1 = short, 2 = long) */
760 16, /* bitsize */
761 FALSE, /* pc_relative */
762 0, /* bitpos */
763 complain_overflow_signed, /* complain_on_overflow */
764 ppc64_elf_sectoff_reloc, /* special_function */
765 "R_PPC64_SECTOFF", /* name */
766 FALSE, /* partial_inplace */
767 0, /* src_mask */
768 0xffff, /* dst_mask */
769 FALSE), /* pcrel_offset */
770
771 /* Like R_PPC64_SECTOFF, but no overflow warning. */
772 HOWTO (R_PPC64_SECTOFF_LO, /* type */
773 0, /* rightshift */
774 1, /* size (0 = byte, 1 = short, 2 = long) */
775 16, /* bitsize */
776 FALSE, /* pc_relative */
777 0, /* bitpos */
778 complain_overflow_dont, /* complain_on_overflow */
779 ppc64_elf_sectoff_reloc, /* special_function */
780 "R_PPC64_SECTOFF_LO", /* name */
781 FALSE, /* partial_inplace */
782 0, /* src_mask */
783 0xffff, /* dst_mask */
784 FALSE), /* pcrel_offset */
785
786 /* 16-bit upper half section relative relocation. */
787 HOWTO (R_PPC64_SECTOFF_HI, /* type */
788 16, /* rightshift */
789 1, /* size (0 = byte, 1 = short, 2 = long) */
790 16, /* bitsize */
791 FALSE, /* pc_relative */
792 0, /* bitpos */
793 complain_overflow_signed, /* complain_on_overflow */
794 ppc64_elf_sectoff_reloc, /* special_function */
795 "R_PPC64_SECTOFF_HI", /* name */
796 FALSE, /* partial_inplace */
797 0, /* src_mask */
798 0xffff, /* dst_mask */
799 FALSE), /* pcrel_offset */
800
801 /* 16-bit upper half adjusted section relative relocation. */
802 HOWTO (R_PPC64_SECTOFF_HA, /* type */
803 16, /* rightshift */
804 1, /* size (0 = byte, 1 = short, 2 = long) */
805 16, /* bitsize */
806 FALSE, /* pc_relative */
807 0, /* bitpos */
808 complain_overflow_signed, /* complain_on_overflow */
809 ppc64_elf_sectoff_ha_reloc, /* special_function */
810 "R_PPC64_SECTOFF_HA", /* name */
811 FALSE, /* partial_inplace */
812 0, /* src_mask */
813 0xffff, /* dst_mask */
814 FALSE), /* pcrel_offset */
815
816 /* Like R_PPC64_REL24 without touching the two least significant bits. */
817 HOWTO (R_PPC64_REL30, /* type */
818 2, /* rightshift */
819 2, /* size (0 = byte, 1 = short, 2 = long) */
820 30, /* bitsize */
821 TRUE, /* pc_relative */
822 0, /* bitpos */
823 complain_overflow_dont, /* complain_on_overflow */
824 bfd_elf_generic_reloc, /* special_function */
825 "R_PPC64_REL30", /* name */
826 FALSE, /* partial_inplace */
827 0, /* src_mask */
828 0xfffffffc, /* dst_mask */
829 TRUE), /* pcrel_offset */
830
831 /* Relocs in the 64-bit PowerPC ELF ABI, not in the 32-bit ABI. */
832
833 /* A standard 64-bit relocation. */
834 HOWTO (R_PPC64_ADDR64, /* type */
835 0, /* rightshift */
836 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
837 64, /* bitsize */
838 FALSE, /* pc_relative */
839 0, /* bitpos */
840 complain_overflow_dont, /* complain_on_overflow */
841 bfd_elf_generic_reloc, /* special_function */
842 "R_PPC64_ADDR64", /* name */
843 FALSE, /* partial_inplace */
844 0, /* src_mask */
845 ONES (64), /* dst_mask */
846 FALSE), /* pcrel_offset */
847
848 /* The bits 32-47 of an address. */
849 HOWTO (R_PPC64_ADDR16_HIGHER, /* type */
850 32, /* rightshift */
851 1, /* size (0 = byte, 1 = short, 2 = long) */
852 16, /* bitsize */
853 FALSE, /* pc_relative */
854 0, /* bitpos */
855 complain_overflow_dont, /* complain_on_overflow */
856 bfd_elf_generic_reloc, /* special_function */
857 "R_PPC64_ADDR16_HIGHER", /* name */
858 FALSE, /* partial_inplace */
859 0, /* src_mask */
860 0xffff, /* dst_mask */
861 FALSE), /* pcrel_offset */
862
863 /* The bits 32-47 of an address, plus 1 if the contents of the low
864 16 bits, treated as a signed number, is negative. */
865 HOWTO (R_PPC64_ADDR16_HIGHERA, /* type */
866 32, /* rightshift */
867 1, /* size (0 = byte, 1 = short, 2 = long) */
868 16, /* bitsize */
869 FALSE, /* pc_relative */
870 0, /* bitpos */
871 complain_overflow_dont, /* complain_on_overflow */
872 ppc64_elf_ha_reloc, /* special_function */
873 "R_PPC64_ADDR16_HIGHERA", /* name */
874 FALSE, /* partial_inplace */
875 0, /* src_mask */
876 0xffff, /* dst_mask */
877 FALSE), /* pcrel_offset */
878
879 /* The bits 48-63 of an address. */
880 HOWTO (R_PPC64_ADDR16_HIGHEST,/* type */
881 48, /* rightshift */
882 1, /* size (0 = byte, 1 = short, 2 = long) */
883 16, /* bitsize */
884 FALSE, /* pc_relative */
885 0, /* bitpos */
886 complain_overflow_dont, /* complain_on_overflow */
887 bfd_elf_generic_reloc, /* special_function */
888 "R_PPC64_ADDR16_HIGHEST", /* name */
889 FALSE, /* partial_inplace */
890 0, /* src_mask */
891 0xffff, /* dst_mask */
892 FALSE), /* pcrel_offset */
893
894 /* The bits 48-63 of an address, plus 1 if the contents of the low
895 16 bits, treated as a signed number, is negative. */
896 HOWTO (R_PPC64_ADDR16_HIGHESTA,/* type */
897 48, /* rightshift */
898 1, /* size (0 = byte, 1 = short, 2 = long) */
899 16, /* bitsize */
900 FALSE, /* pc_relative */
901 0, /* bitpos */
902 complain_overflow_dont, /* complain_on_overflow */
903 ppc64_elf_ha_reloc, /* special_function */
904 "R_PPC64_ADDR16_HIGHESTA", /* name */
905 FALSE, /* partial_inplace */
906 0, /* src_mask */
907 0xffff, /* dst_mask */
908 FALSE), /* pcrel_offset */
909
910 /* Like ADDR64, but may be unaligned. */
911 HOWTO (R_PPC64_UADDR64, /* type */
912 0, /* rightshift */
913 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
914 64, /* bitsize */
915 FALSE, /* pc_relative */
916 0, /* bitpos */
917 complain_overflow_dont, /* complain_on_overflow */
918 bfd_elf_generic_reloc, /* special_function */
919 "R_PPC64_UADDR64", /* name */
920 FALSE, /* partial_inplace */
921 0, /* src_mask */
922 ONES (64), /* dst_mask */
923 FALSE), /* pcrel_offset */
924
925 /* 64-bit relative relocation. */
926 HOWTO (R_PPC64_REL64, /* type */
927 0, /* rightshift */
928 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
929 64, /* bitsize */
930 TRUE, /* pc_relative */
931 0, /* bitpos */
932 complain_overflow_dont, /* complain_on_overflow */
933 bfd_elf_generic_reloc, /* special_function */
934 "R_PPC64_REL64", /* name */
935 FALSE, /* partial_inplace */
936 0, /* src_mask */
937 ONES (64), /* dst_mask */
938 TRUE), /* pcrel_offset */
939
940 /* 64-bit relocation to the symbol's procedure linkage table. */
941 HOWTO (R_PPC64_PLT64, /* type */
942 0, /* rightshift */
943 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
944 64, /* bitsize */
945 FALSE, /* pc_relative */
946 0, /* bitpos */
947 complain_overflow_dont, /* complain_on_overflow */
948 ppc64_elf_unhandled_reloc, /* special_function */
949 "R_PPC64_PLT64", /* name */
950 FALSE, /* partial_inplace */
951 0, /* src_mask */
952 ONES (64), /* dst_mask */
953 FALSE), /* pcrel_offset */
954
955 /* 64-bit PC relative relocation to the symbol's procedure linkage
956 table. */
957 /* FIXME: R_PPC64_PLTREL64 not supported. */
958 HOWTO (R_PPC64_PLTREL64, /* type */
959 0, /* rightshift */
960 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
961 64, /* bitsize */
962 TRUE, /* pc_relative */
963 0, /* bitpos */
964 complain_overflow_dont, /* complain_on_overflow */
965 ppc64_elf_unhandled_reloc, /* special_function */
966 "R_PPC64_PLTREL64", /* name */
967 FALSE, /* partial_inplace */
968 0, /* src_mask */
969 ONES (64), /* dst_mask */
970 TRUE), /* pcrel_offset */
971
972 /* 16 bit TOC-relative relocation. */
973
974 /* R_PPC64_TOC16 47 half16* S + A - .TOC. */
975 HOWTO (R_PPC64_TOC16, /* type */
976 0, /* rightshift */
977 1, /* size (0 = byte, 1 = short, 2 = long) */
978 16, /* bitsize */
979 FALSE, /* pc_relative */
980 0, /* bitpos */
981 complain_overflow_signed, /* complain_on_overflow */
982 ppc64_elf_toc_reloc, /* special_function */
983 "R_PPC64_TOC16", /* name */
984 FALSE, /* partial_inplace */
985 0, /* src_mask */
986 0xffff, /* dst_mask */
987 FALSE), /* pcrel_offset */
988
989 /* 16 bit TOC-relative relocation without overflow. */
990
991 /* R_PPC64_TOC16_LO 48 half16 #lo (S + A - .TOC.) */
992 HOWTO (R_PPC64_TOC16_LO, /* type */
993 0, /* rightshift */
994 1, /* size (0 = byte, 1 = short, 2 = long) */
995 16, /* bitsize */
996 FALSE, /* pc_relative */
997 0, /* bitpos */
998 complain_overflow_dont, /* complain_on_overflow */
999 ppc64_elf_toc_reloc, /* special_function */
1000 "R_PPC64_TOC16_LO", /* name */
1001 FALSE, /* partial_inplace */
1002 0, /* src_mask */
1003 0xffff, /* dst_mask */
1004 FALSE), /* pcrel_offset */
1005
1006 /* 16 bit TOC-relative relocation, high 16 bits. */
1007
1008 /* R_PPC64_TOC16_HI 49 half16 #hi (S + A - .TOC.) */
1009 HOWTO (R_PPC64_TOC16_HI, /* type */
1010 16, /* rightshift */
1011 1, /* size (0 = byte, 1 = short, 2 = long) */
1012 16, /* bitsize */
1013 FALSE, /* pc_relative */
1014 0, /* bitpos */
1015 complain_overflow_signed, /* complain_on_overflow */
1016 ppc64_elf_toc_reloc, /* special_function */
1017 "R_PPC64_TOC16_HI", /* name */
1018 FALSE, /* partial_inplace */
1019 0, /* src_mask */
1020 0xffff, /* dst_mask */
1021 FALSE), /* pcrel_offset */
1022
1023 /* 16 bit TOC-relative relocation, high 16 bits, plus 1 if the
1024 contents of the low 16 bits, treated as a signed number, is
1025 negative. */
1026
1027 /* R_PPC64_TOC16_HA 50 half16 #ha (S + A - .TOC.) */
1028 HOWTO (R_PPC64_TOC16_HA, /* type */
1029 16, /* rightshift */
1030 1, /* size (0 = byte, 1 = short, 2 = long) */
1031 16, /* bitsize */
1032 FALSE, /* pc_relative */
1033 0, /* bitpos */
1034 complain_overflow_signed, /* complain_on_overflow */
1035 ppc64_elf_toc_ha_reloc, /* special_function */
1036 "R_PPC64_TOC16_HA", /* name */
1037 FALSE, /* partial_inplace */
1038 0, /* src_mask */
1039 0xffff, /* dst_mask */
1040 FALSE), /* pcrel_offset */
1041
1042 /* 64-bit relocation; insert value of TOC base (.TOC.). */
1043
1044 /* R_PPC64_TOC 51 doubleword64 .TOC. */
1045 HOWTO (R_PPC64_TOC, /* type */
1046 0, /* rightshift */
1047 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1048 64, /* bitsize */
1049 FALSE, /* pc_relative */
1050 0, /* bitpos */
1051 complain_overflow_dont, /* complain_on_overflow */
1052 ppc64_elf_toc64_reloc, /* special_function */
1053 "R_PPC64_TOC", /* name */
1054 FALSE, /* partial_inplace */
1055 0, /* src_mask */
1056 ONES (64), /* dst_mask */
1057 FALSE), /* pcrel_offset */
1058
1059 /* Like R_PPC64_GOT16, but also informs the link editor that the
1060 value to relocate may (!) refer to a PLT entry which the link
1061 editor (a) may replace with the symbol value. If the link editor
1062 is unable to fully resolve the symbol, it may (b) create a PLT
1063 entry and store the address to the new PLT entry in the GOT.
1064 This permits lazy resolution of function symbols at run time.
1065 The link editor may also skip all of this and just (c) emit a
1066 R_PPC64_GLOB_DAT to tie the symbol to the GOT entry. */
1067 /* FIXME: R_PPC64_PLTGOT16 not implemented. */
1068 HOWTO (R_PPC64_PLTGOT16, /* type */
1069 0, /* rightshift */
1070 1, /* size (0 = byte, 1 = short, 2 = long) */
1071 16, /* bitsize */
1072 FALSE, /* pc_relative */
1073 0, /* bitpos */
1074 complain_overflow_signed, /* complain_on_overflow */
1075 ppc64_elf_unhandled_reloc, /* special_function */
1076 "R_PPC64_PLTGOT16", /* name */
1077 FALSE, /* partial_inplace */
1078 0, /* src_mask */
1079 0xffff, /* dst_mask */
1080 FALSE), /* pcrel_offset */
1081
1082 /* Like R_PPC64_PLTGOT16, but without overflow. */
1083 /* FIXME: R_PPC64_PLTGOT16_LO not implemented. */
1084 HOWTO (R_PPC64_PLTGOT16_LO, /* type */
1085 0, /* rightshift */
1086 1, /* size (0 = byte, 1 = short, 2 = long) */
1087 16, /* bitsize */
1088 FALSE, /* pc_relative */
1089 0, /* bitpos */
1090 complain_overflow_dont, /* complain_on_overflow */
1091 ppc64_elf_unhandled_reloc, /* special_function */
1092 "R_PPC64_PLTGOT16_LO", /* name */
1093 FALSE, /* partial_inplace */
1094 0, /* src_mask */
1095 0xffff, /* dst_mask */
1096 FALSE), /* pcrel_offset */
1097
1098 /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address. */
1099 /* FIXME: R_PPC64_PLTGOT16_HI not implemented. */
1100 HOWTO (R_PPC64_PLTGOT16_HI, /* type */
1101 16, /* rightshift */
1102 1, /* size (0 = byte, 1 = short, 2 = long) */
1103 16, /* bitsize */
1104 FALSE, /* pc_relative */
1105 0, /* bitpos */
1106 complain_overflow_signed, /* complain_on_overflow */
1107 ppc64_elf_unhandled_reloc, /* special_function */
1108 "R_PPC64_PLTGOT16_HI", /* name */
1109 FALSE, /* partial_inplace */
1110 0, /* src_mask */
1111 0xffff, /* dst_mask */
1112 FALSE), /* pcrel_offset */
1113
1114 /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address, plus
1115 1 if the contents of the low 16 bits, treated as a signed number,
1116 is negative. */
1117 /* FIXME: R_PPC64_PLTGOT16_HA not implemented. */
1118 HOWTO (R_PPC64_PLTGOT16_HA, /* type */
1119 16, /* rightshift */
1120 1, /* size (0 = byte, 1 = short, 2 = long) */
1121 16, /* bitsize */
1122 FALSE, /* pc_relative */
1123 0, /* bitpos */
1124 complain_overflow_signed, /* complain_on_overflow */
1125 ppc64_elf_unhandled_reloc, /* special_function */
1126 "R_PPC64_PLTGOT16_HA", /* name */
1127 FALSE, /* partial_inplace */
1128 0, /* src_mask */
1129 0xffff, /* dst_mask */
1130 FALSE), /* pcrel_offset */
1131
1132 /* Like R_PPC64_ADDR16, but for instructions with a DS field. */
1133 HOWTO (R_PPC64_ADDR16_DS, /* type */
1134 0, /* rightshift */
1135 1, /* size (0 = byte, 1 = short, 2 = long) */
1136 16, /* bitsize */
1137 FALSE, /* pc_relative */
1138 0, /* bitpos */
1139 complain_overflow_signed, /* complain_on_overflow */
1140 bfd_elf_generic_reloc, /* special_function */
1141 "R_PPC64_ADDR16_DS", /* name */
1142 FALSE, /* partial_inplace */
1143 0, /* src_mask */
1144 0xfffc, /* dst_mask */
1145 FALSE), /* pcrel_offset */
1146
1147 /* Like R_PPC64_ADDR16_LO, but for instructions with a DS field. */
1148 HOWTO (R_PPC64_ADDR16_LO_DS, /* type */
1149 0, /* rightshift */
1150 1, /* size (0 = byte, 1 = short, 2 = long) */
1151 16, /* bitsize */
1152 FALSE, /* pc_relative */
1153 0, /* bitpos */
1154 complain_overflow_dont,/* complain_on_overflow */
1155 bfd_elf_generic_reloc, /* special_function */
1156 "R_PPC64_ADDR16_LO_DS",/* name */
1157 FALSE, /* partial_inplace */
1158 0, /* src_mask */
1159 0xfffc, /* dst_mask */
1160 FALSE), /* pcrel_offset */
1161
1162 /* Like R_PPC64_GOT16, but for instructions with a DS field. */
1163 HOWTO (R_PPC64_GOT16_DS, /* type */
1164 0, /* rightshift */
1165 1, /* size (0 = byte, 1 = short, 2 = long) */
1166 16, /* bitsize */
1167 FALSE, /* pc_relative */
1168 0, /* bitpos */
1169 complain_overflow_signed, /* complain_on_overflow */
1170 ppc64_elf_unhandled_reloc, /* special_function */
1171 "R_PPC64_GOT16_DS", /* name */
1172 FALSE, /* partial_inplace */
1173 0, /* src_mask */
1174 0xfffc, /* dst_mask */
1175 FALSE), /* pcrel_offset */
1176
1177 /* Like R_PPC64_GOT16_LO, but for instructions with a DS field. */
1178 HOWTO (R_PPC64_GOT16_LO_DS, /* type */
1179 0, /* rightshift */
1180 1, /* size (0 = byte, 1 = short, 2 = long) */
1181 16, /* bitsize */
1182 FALSE, /* pc_relative */
1183 0, /* bitpos */
1184 complain_overflow_dont, /* complain_on_overflow */
1185 ppc64_elf_unhandled_reloc, /* special_function */
1186 "R_PPC64_GOT16_LO_DS", /* name */
1187 FALSE, /* partial_inplace */
1188 0, /* src_mask */
1189 0xfffc, /* dst_mask */
1190 FALSE), /* pcrel_offset */
1191
1192 /* Like R_PPC64_PLT16_LO, but for instructions with a DS field. */
1193 HOWTO (R_PPC64_PLT16_LO_DS, /* type */
1194 0, /* rightshift */
1195 1, /* size (0 = byte, 1 = short, 2 = long) */
1196 16, /* bitsize */
1197 FALSE, /* pc_relative */
1198 0, /* bitpos */
1199 complain_overflow_dont, /* complain_on_overflow */
1200 ppc64_elf_unhandled_reloc, /* special_function */
1201 "R_PPC64_PLT16_LO_DS", /* name */
1202 FALSE, /* partial_inplace */
1203 0, /* src_mask */
1204 0xfffc, /* dst_mask */
1205 FALSE), /* pcrel_offset */
1206
1207 /* Like R_PPC64_SECTOFF, but for instructions with a DS field. */
1208 HOWTO (R_PPC64_SECTOFF_DS, /* type */
1209 0, /* rightshift */
1210 1, /* size (0 = byte, 1 = short, 2 = long) */
1211 16, /* bitsize */
1212 FALSE, /* pc_relative */
1213 0, /* bitpos */
1214 complain_overflow_signed, /* complain_on_overflow */
1215 ppc64_elf_sectoff_reloc, /* special_function */
1216 "R_PPC64_SECTOFF_DS", /* name */
1217 FALSE, /* partial_inplace */
1218 0, /* src_mask */
1219 0xfffc, /* dst_mask */
1220 FALSE), /* pcrel_offset */
1221
1222 /* Like R_PPC64_SECTOFF_LO, but for instructions with a DS field. */
1223 HOWTO (R_PPC64_SECTOFF_LO_DS, /* type */
1224 0, /* rightshift */
1225 1, /* size (0 = byte, 1 = short, 2 = long) */
1226 16, /* bitsize */
1227 FALSE, /* pc_relative */
1228 0, /* bitpos */
1229 complain_overflow_dont, /* complain_on_overflow */
1230 ppc64_elf_sectoff_reloc, /* special_function */
1231 "R_PPC64_SECTOFF_LO_DS",/* name */
1232 FALSE, /* partial_inplace */
1233 0, /* src_mask */
1234 0xfffc, /* dst_mask */
1235 FALSE), /* pcrel_offset */
1236
1237 /* Like R_PPC64_TOC16, but for instructions with a DS field. */
1238 HOWTO (R_PPC64_TOC16_DS, /* type */
1239 0, /* rightshift */
1240 1, /* size (0 = byte, 1 = short, 2 = long) */
1241 16, /* bitsize */
1242 FALSE, /* pc_relative */
1243 0, /* bitpos */
1244 complain_overflow_signed, /* complain_on_overflow */
1245 ppc64_elf_toc_reloc, /* special_function */
1246 "R_PPC64_TOC16_DS", /* name */
1247 FALSE, /* partial_inplace */
1248 0, /* src_mask */
1249 0xfffc, /* dst_mask */
1250 FALSE), /* pcrel_offset */
1251
1252 /* Like R_PPC64_TOC16_LO, but for instructions with a DS field. */
1253 HOWTO (R_PPC64_TOC16_LO_DS, /* type */
1254 0, /* rightshift */
1255 1, /* size (0 = byte, 1 = short, 2 = long) */
1256 16, /* bitsize */
1257 FALSE, /* pc_relative */
1258 0, /* bitpos */
1259 complain_overflow_dont, /* complain_on_overflow */
1260 ppc64_elf_toc_reloc, /* special_function */
1261 "R_PPC64_TOC16_LO_DS", /* name */
1262 FALSE, /* partial_inplace */
1263 0, /* src_mask */
1264 0xfffc, /* dst_mask */
1265 FALSE), /* pcrel_offset */
1266
1267 /* Like R_PPC64_PLTGOT16, but for instructions with a DS field. */
1268 /* FIXME: R_PPC64_PLTGOT16_DS not implemented. */
1269 HOWTO (R_PPC64_PLTGOT16_DS, /* type */
1270 0, /* rightshift */
1271 1, /* size (0 = byte, 1 = short, 2 = long) */
1272 16, /* bitsize */
1273 FALSE, /* pc_relative */
1274 0, /* bitpos */
1275 complain_overflow_signed, /* complain_on_overflow */
1276 ppc64_elf_unhandled_reloc, /* special_function */
1277 "R_PPC64_PLTGOT16_DS", /* name */
1278 FALSE, /* partial_inplace */
1279 0, /* src_mask */
1280 0xfffc, /* dst_mask */
1281 FALSE), /* pcrel_offset */
1282
1283 /* Like R_PPC64_PLTGOT16_LO, but for instructions with a DS field. */
1284 /* FIXME: R_PPC64_PLTGOT16_LO not implemented. */
1285 HOWTO (R_PPC64_PLTGOT16_LO_DS,/* type */
1286 0, /* rightshift */
1287 1, /* size (0 = byte, 1 = short, 2 = long) */
1288 16, /* bitsize */
1289 FALSE, /* pc_relative */
1290 0, /* bitpos */
1291 complain_overflow_dont, /* complain_on_overflow */
1292 ppc64_elf_unhandled_reloc, /* special_function */
1293 "R_PPC64_PLTGOT16_LO_DS",/* name */
1294 FALSE, /* partial_inplace */
1295 0, /* src_mask */
1296 0xfffc, /* dst_mask */
1297 FALSE), /* pcrel_offset */
1298
1299 /* Marker relocs for TLS. */
1300 HOWTO (R_PPC64_TLS,
1301 0, /* rightshift */
1302 2, /* size (0 = byte, 1 = short, 2 = long) */
1303 32, /* bitsize */
1304 FALSE, /* pc_relative */
1305 0, /* bitpos */
1306 complain_overflow_dont, /* complain_on_overflow */
1307 bfd_elf_generic_reloc, /* special_function */
1308 "R_PPC64_TLS", /* name */
1309 FALSE, /* partial_inplace */
1310 0, /* src_mask */
1311 0, /* dst_mask */
1312 FALSE), /* pcrel_offset */
1313
1314 HOWTO (R_PPC64_TLSGD,
1315 0, /* rightshift */
1316 2, /* size (0 = byte, 1 = short, 2 = long) */
1317 32, /* bitsize */
1318 FALSE, /* pc_relative */
1319 0, /* bitpos */
1320 complain_overflow_dont, /* complain_on_overflow */
1321 bfd_elf_generic_reloc, /* special_function */
1322 "R_PPC64_TLSGD", /* name */
1323 FALSE, /* partial_inplace */
1324 0, /* src_mask */
1325 0, /* dst_mask */
1326 FALSE), /* pcrel_offset */
1327
1328 HOWTO (R_PPC64_TLSLD,
1329 0, /* rightshift */
1330 2, /* size (0 = byte, 1 = short, 2 = long) */
1331 32, /* bitsize */
1332 FALSE, /* pc_relative */
1333 0, /* bitpos */
1334 complain_overflow_dont, /* complain_on_overflow */
1335 bfd_elf_generic_reloc, /* special_function */
1336 "R_PPC64_TLSLD", /* name */
1337 FALSE, /* partial_inplace */
1338 0, /* src_mask */
1339 0, /* dst_mask */
1340 FALSE), /* pcrel_offset */
1341
1342 HOWTO (R_PPC64_TOCSAVE,
1343 0, /* rightshift */
1344 2, /* size (0 = byte, 1 = short, 2 = long) */
1345 32, /* bitsize */
1346 FALSE, /* pc_relative */
1347 0, /* bitpos */
1348 complain_overflow_dont, /* complain_on_overflow */
1349 bfd_elf_generic_reloc, /* special_function */
1350 "R_PPC64_TOCSAVE", /* name */
1351 FALSE, /* partial_inplace */
1352 0, /* src_mask */
1353 0, /* dst_mask */
1354 FALSE), /* pcrel_offset */
1355
1356 /* Computes the load module index of the load module that contains the
1357 definition of its TLS sym. */
1358 HOWTO (R_PPC64_DTPMOD64,
1359 0, /* rightshift */
1360 4, /* size (0 = byte, 1 = short, 2 = long) */
1361 64, /* bitsize */
1362 FALSE, /* pc_relative */
1363 0, /* bitpos */
1364 complain_overflow_dont, /* complain_on_overflow */
1365 ppc64_elf_unhandled_reloc, /* special_function */
1366 "R_PPC64_DTPMOD64", /* name */
1367 FALSE, /* partial_inplace */
1368 0, /* src_mask */
1369 ONES (64), /* dst_mask */
1370 FALSE), /* pcrel_offset */
1371
1372 /* Computes a dtv-relative displacement, the difference between the value
1373 of sym+add and the base address of the thread-local storage block that
1374 contains the definition of sym, minus 0x8000. */
1375 HOWTO (R_PPC64_DTPREL64,
1376 0, /* rightshift */
1377 4, /* size (0 = byte, 1 = short, 2 = long) */
1378 64, /* bitsize */
1379 FALSE, /* pc_relative */
1380 0, /* bitpos */
1381 complain_overflow_dont, /* complain_on_overflow */
1382 ppc64_elf_unhandled_reloc, /* special_function */
1383 "R_PPC64_DTPREL64", /* name */
1384 FALSE, /* partial_inplace */
1385 0, /* src_mask */
1386 ONES (64), /* dst_mask */
1387 FALSE), /* pcrel_offset */
1388
1389 /* A 16 bit dtprel reloc. */
1390 HOWTO (R_PPC64_DTPREL16,
1391 0, /* rightshift */
1392 1, /* size (0 = byte, 1 = short, 2 = long) */
1393 16, /* bitsize */
1394 FALSE, /* pc_relative */
1395 0, /* bitpos */
1396 complain_overflow_signed, /* complain_on_overflow */
1397 ppc64_elf_unhandled_reloc, /* special_function */
1398 "R_PPC64_DTPREL16", /* name */
1399 FALSE, /* partial_inplace */
1400 0, /* src_mask */
1401 0xffff, /* dst_mask */
1402 FALSE), /* pcrel_offset */
1403
1404 /* Like DTPREL16, but no overflow. */
1405 HOWTO (R_PPC64_DTPREL16_LO,
1406 0, /* rightshift */
1407 1, /* size (0 = byte, 1 = short, 2 = long) */
1408 16, /* bitsize */
1409 FALSE, /* pc_relative */
1410 0, /* bitpos */
1411 complain_overflow_dont, /* complain_on_overflow */
1412 ppc64_elf_unhandled_reloc, /* special_function */
1413 "R_PPC64_DTPREL16_LO", /* name */
1414 FALSE, /* partial_inplace */
1415 0, /* src_mask */
1416 0xffff, /* dst_mask */
1417 FALSE), /* pcrel_offset */
1418
1419 /* Like DTPREL16_LO, but next higher group of 16 bits. */
1420 HOWTO (R_PPC64_DTPREL16_HI,
1421 16, /* rightshift */
1422 1, /* size (0 = byte, 1 = short, 2 = long) */
1423 16, /* bitsize */
1424 FALSE, /* pc_relative */
1425 0, /* bitpos */
1426 complain_overflow_signed, /* complain_on_overflow */
1427 ppc64_elf_unhandled_reloc, /* special_function */
1428 "R_PPC64_DTPREL16_HI", /* name */
1429 FALSE, /* partial_inplace */
1430 0, /* src_mask */
1431 0xffff, /* dst_mask */
1432 FALSE), /* pcrel_offset */
1433
1434 /* Like DTPREL16_HI, but adjust for low 16 bits. */
1435 HOWTO (R_PPC64_DTPREL16_HA,
1436 16, /* rightshift */
1437 1, /* size (0 = byte, 1 = short, 2 = long) */
1438 16, /* bitsize */
1439 FALSE, /* pc_relative */
1440 0, /* bitpos */
1441 complain_overflow_signed, /* complain_on_overflow */
1442 ppc64_elf_unhandled_reloc, /* special_function */
1443 "R_PPC64_DTPREL16_HA", /* name */
1444 FALSE, /* partial_inplace */
1445 0, /* src_mask */
1446 0xffff, /* dst_mask */
1447 FALSE), /* pcrel_offset */
1448
1449 /* Like DTPREL16_HI, but next higher group of 16 bits. */
1450 HOWTO (R_PPC64_DTPREL16_HIGHER,
1451 32, /* rightshift */
1452 1, /* size (0 = byte, 1 = short, 2 = long) */
1453 16, /* bitsize */
1454 FALSE, /* pc_relative */
1455 0, /* bitpos */
1456 complain_overflow_dont, /* complain_on_overflow */
1457 ppc64_elf_unhandled_reloc, /* special_function */
1458 "R_PPC64_DTPREL16_HIGHER", /* name */
1459 FALSE, /* partial_inplace */
1460 0, /* src_mask */
1461 0xffff, /* dst_mask */
1462 FALSE), /* pcrel_offset */
1463
1464 /* Like DTPREL16_HIGHER, but adjust for low 16 bits. */
1465 HOWTO (R_PPC64_DTPREL16_HIGHERA,
1466 32, /* rightshift */
1467 1, /* size (0 = byte, 1 = short, 2 = long) */
1468 16, /* bitsize */
1469 FALSE, /* pc_relative */
1470 0, /* bitpos */
1471 complain_overflow_dont, /* complain_on_overflow */
1472 ppc64_elf_unhandled_reloc, /* special_function */
1473 "R_PPC64_DTPREL16_HIGHERA", /* name */
1474 FALSE, /* partial_inplace */
1475 0, /* src_mask */
1476 0xffff, /* dst_mask */
1477 FALSE), /* pcrel_offset */
1478
1479 /* Like DTPREL16_HIGHER, but next higher group of 16 bits. */
1480 HOWTO (R_PPC64_DTPREL16_HIGHEST,
1481 48, /* rightshift */
1482 1, /* size (0 = byte, 1 = short, 2 = long) */
1483 16, /* bitsize */
1484 FALSE, /* pc_relative */
1485 0, /* bitpos */
1486 complain_overflow_dont, /* complain_on_overflow */
1487 ppc64_elf_unhandled_reloc, /* special_function */
1488 "R_PPC64_DTPREL16_HIGHEST", /* name */
1489 FALSE, /* partial_inplace */
1490 0, /* src_mask */
1491 0xffff, /* dst_mask */
1492 FALSE), /* pcrel_offset */
1493
1494 /* Like DTPREL16_HIGHEST, but adjust for low 16 bits. */
1495 HOWTO (R_PPC64_DTPREL16_HIGHESTA,
1496 48, /* rightshift */
1497 1, /* size (0 = byte, 1 = short, 2 = long) */
1498 16, /* bitsize */
1499 FALSE, /* pc_relative */
1500 0, /* bitpos */
1501 complain_overflow_dont, /* complain_on_overflow */
1502 ppc64_elf_unhandled_reloc, /* special_function */
1503 "R_PPC64_DTPREL16_HIGHESTA", /* name */
1504 FALSE, /* partial_inplace */
1505 0, /* src_mask */
1506 0xffff, /* dst_mask */
1507 FALSE), /* pcrel_offset */
1508
1509 /* Like DTPREL16, but for insns with a DS field. */
1510 HOWTO (R_PPC64_DTPREL16_DS,
1511 0, /* rightshift */
1512 1, /* size (0 = byte, 1 = short, 2 = long) */
1513 16, /* bitsize */
1514 FALSE, /* pc_relative */
1515 0, /* bitpos */
1516 complain_overflow_signed, /* complain_on_overflow */
1517 ppc64_elf_unhandled_reloc, /* special_function */
1518 "R_PPC64_DTPREL16_DS", /* name */
1519 FALSE, /* partial_inplace */
1520 0, /* src_mask */
1521 0xfffc, /* dst_mask */
1522 FALSE), /* pcrel_offset */
1523
1524 /* Like DTPREL16_DS, but no overflow. */
1525 HOWTO (R_PPC64_DTPREL16_LO_DS,
1526 0, /* rightshift */
1527 1, /* size (0 = byte, 1 = short, 2 = long) */
1528 16, /* bitsize */
1529 FALSE, /* pc_relative */
1530 0, /* bitpos */
1531 complain_overflow_dont, /* complain_on_overflow */
1532 ppc64_elf_unhandled_reloc, /* special_function */
1533 "R_PPC64_DTPREL16_LO_DS", /* name */
1534 FALSE, /* partial_inplace */
1535 0, /* src_mask */
1536 0xfffc, /* dst_mask */
1537 FALSE), /* pcrel_offset */
1538
1539 /* Computes a tp-relative displacement, the difference between the value of
1540 sym+add and the value of the thread pointer (r13). */
1541 HOWTO (R_PPC64_TPREL64,
1542 0, /* rightshift */
1543 4, /* size (0 = byte, 1 = short, 2 = long) */
1544 64, /* bitsize */
1545 FALSE, /* pc_relative */
1546 0, /* bitpos */
1547 complain_overflow_dont, /* complain_on_overflow */
1548 ppc64_elf_unhandled_reloc, /* special_function */
1549 "R_PPC64_TPREL64", /* name */
1550 FALSE, /* partial_inplace */
1551 0, /* src_mask */
1552 ONES (64), /* dst_mask */
1553 FALSE), /* pcrel_offset */
1554
1555 /* A 16 bit tprel reloc. */
1556 HOWTO (R_PPC64_TPREL16,
1557 0, /* rightshift */
1558 1, /* size (0 = byte, 1 = short, 2 = long) */
1559 16, /* bitsize */
1560 FALSE, /* pc_relative */
1561 0, /* bitpos */
1562 complain_overflow_signed, /* complain_on_overflow */
1563 ppc64_elf_unhandled_reloc, /* special_function */
1564 "R_PPC64_TPREL16", /* name */
1565 FALSE, /* partial_inplace */
1566 0, /* src_mask */
1567 0xffff, /* dst_mask */
1568 FALSE), /* pcrel_offset */
1569
1570 /* Like TPREL16, but no overflow. */
1571 HOWTO (R_PPC64_TPREL16_LO,
1572 0, /* rightshift */
1573 1, /* size (0 = byte, 1 = short, 2 = long) */
1574 16, /* bitsize */
1575 FALSE, /* pc_relative */
1576 0, /* bitpos */
1577 complain_overflow_dont, /* complain_on_overflow */
1578 ppc64_elf_unhandled_reloc, /* special_function */
1579 "R_PPC64_TPREL16_LO", /* name */
1580 FALSE, /* partial_inplace */
1581 0, /* src_mask */
1582 0xffff, /* dst_mask */
1583 FALSE), /* pcrel_offset */
1584
1585 /* Like TPREL16_LO, but next higher group of 16 bits. */
1586 HOWTO (R_PPC64_TPREL16_HI,
1587 16, /* rightshift */
1588 1, /* size (0 = byte, 1 = short, 2 = long) */
1589 16, /* bitsize */
1590 FALSE, /* pc_relative */
1591 0, /* bitpos */
1592 complain_overflow_signed, /* complain_on_overflow */
1593 ppc64_elf_unhandled_reloc, /* special_function */
1594 "R_PPC64_TPREL16_HI", /* name */
1595 FALSE, /* partial_inplace */
1596 0, /* src_mask */
1597 0xffff, /* dst_mask */
1598 FALSE), /* pcrel_offset */
1599
1600 /* Like TPREL16_HI, but adjust for low 16 bits. */
1601 HOWTO (R_PPC64_TPREL16_HA,
1602 16, /* rightshift */
1603 1, /* size (0 = byte, 1 = short, 2 = long) */
1604 16, /* bitsize */
1605 FALSE, /* pc_relative */
1606 0, /* bitpos */
1607 complain_overflow_signed, /* complain_on_overflow */
1608 ppc64_elf_unhandled_reloc, /* special_function */
1609 "R_PPC64_TPREL16_HA", /* name */
1610 FALSE, /* partial_inplace */
1611 0, /* src_mask */
1612 0xffff, /* dst_mask */
1613 FALSE), /* pcrel_offset */
1614
1615 /* Like TPREL16_HI, but next higher group of 16 bits. */
1616 HOWTO (R_PPC64_TPREL16_HIGHER,
1617 32, /* rightshift */
1618 1, /* size (0 = byte, 1 = short, 2 = long) */
1619 16, /* bitsize */
1620 FALSE, /* pc_relative */
1621 0, /* bitpos */
1622 complain_overflow_dont, /* complain_on_overflow */
1623 ppc64_elf_unhandled_reloc, /* special_function */
1624 "R_PPC64_TPREL16_HIGHER", /* name */
1625 FALSE, /* partial_inplace */
1626 0, /* src_mask */
1627 0xffff, /* dst_mask */
1628 FALSE), /* pcrel_offset */
1629
1630 /* Like TPREL16_HIGHER, but adjust for low 16 bits. */
1631 HOWTO (R_PPC64_TPREL16_HIGHERA,
1632 32, /* rightshift */
1633 1, /* size (0 = byte, 1 = short, 2 = long) */
1634 16, /* bitsize */
1635 FALSE, /* pc_relative */
1636 0, /* bitpos */
1637 complain_overflow_dont, /* complain_on_overflow */
1638 ppc64_elf_unhandled_reloc, /* special_function */
1639 "R_PPC64_TPREL16_HIGHERA", /* name */
1640 FALSE, /* partial_inplace */
1641 0, /* src_mask */
1642 0xffff, /* dst_mask */
1643 FALSE), /* pcrel_offset */
1644
1645 /* Like TPREL16_HIGHER, but next higher group of 16 bits. */
1646 HOWTO (R_PPC64_TPREL16_HIGHEST,
1647 48, /* rightshift */
1648 1, /* size (0 = byte, 1 = short, 2 = long) */
1649 16, /* bitsize */
1650 FALSE, /* pc_relative */
1651 0, /* bitpos */
1652 complain_overflow_dont, /* complain_on_overflow */
1653 ppc64_elf_unhandled_reloc, /* special_function */
1654 "R_PPC64_TPREL16_HIGHEST", /* name */
1655 FALSE, /* partial_inplace */
1656 0, /* src_mask */
1657 0xffff, /* dst_mask */
1658 FALSE), /* pcrel_offset */
1659
1660 /* Like TPREL16_HIGHEST, but adjust for low 16 bits. */
1661 HOWTO (R_PPC64_TPREL16_HIGHESTA,
1662 48, /* rightshift */
1663 1, /* size (0 = byte, 1 = short, 2 = long) */
1664 16, /* bitsize */
1665 FALSE, /* pc_relative */
1666 0, /* bitpos */
1667 complain_overflow_dont, /* complain_on_overflow */
1668 ppc64_elf_unhandled_reloc, /* special_function */
1669 "R_PPC64_TPREL16_HIGHESTA", /* name */
1670 FALSE, /* partial_inplace */
1671 0, /* src_mask */
1672 0xffff, /* dst_mask */
1673 FALSE), /* pcrel_offset */
1674
1675 /* Like TPREL16, but for insns with a DS field. */
1676 HOWTO (R_PPC64_TPREL16_DS,
1677 0, /* rightshift */
1678 1, /* size (0 = byte, 1 = short, 2 = long) */
1679 16, /* bitsize */
1680 FALSE, /* pc_relative */
1681 0, /* bitpos */
1682 complain_overflow_signed, /* complain_on_overflow */
1683 ppc64_elf_unhandled_reloc, /* special_function */
1684 "R_PPC64_TPREL16_DS", /* name */
1685 FALSE, /* partial_inplace */
1686 0, /* src_mask */
1687 0xfffc, /* dst_mask */
1688 FALSE), /* pcrel_offset */
1689
1690 /* Like TPREL16_DS, but no overflow. */
1691 HOWTO (R_PPC64_TPREL16_LO_DS,
1692 0, /* rightshift */
1693 1, /* size (0 = byte, 1 = short, 2 = long) */
1694 16, /* bitsize */
1695 FALSE, /* pc_relative */
1696 0, /* bitpos */
1697 complain_overflow_dont, /* complain_on_overflow */
1698 ppc64_elf_unhandled_reloc, /* special_function */
1699 "R_PPC64_TPREL16_LO_DS", /* name */
1700 FALSE, /* partial_inplace */
1701 0, /* src_mask */
1702 0xfffc, /* dst_mask */
1703 FALSE), /* pcrel_offset */
1704
1705 /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1706 with values (sym+add)@dtpmod and (sym+add)@dtprel, and computes the offset
1707 to the first entry relative to the TOC base (r2). */
1708 HOWTO (R_PPC64_GOT_TLSGD16,
1709 0, /* rightshift */
1710 1, /* size (0 = byte, 1 = short, 2 = long) */
1711 16, /* bitsize */
1712 FALSE, /* pc_relative */
1713 0, /* bitpos */
1714 complain_overflow_signed, /* complain_on_overflow */
1715 ppc64_elf_unhandled_reloc, /* special_function */
1716 "R_PPC64_GOT_TLSGD16", /* name */
1717 FALSE, /* partial_inplace */
1718 0, /* src_mask */
1719 0xffff, /* dst_mask */
1720 FALSE), /* pcrel_offset */
1721
1722 /* Like GOT_TLSGD16, but no overflow. */
1723 HOWTO (R_PPC64_GOT_TLSGD16_LO,
1724 0, /* rightshift */
1725 1, /* size (0 = byte, 1 = short, 2 = long) */
1726 16, /* bitsize */
1727 FALSE, /* pc_relative */
1728 0, /* bitpos */
1729 complain_overflow_dont, /* complain_on_overflow */
1730 ppc64_elf_unhandled_reloc, /* special_function */
1731 "R_PPC64_GOT_TLSGD16_LO", /* name */
1732 FALSE, /* partial_inplace */
1733 0, /* src_mask */
1734 0xffff, /* dst_mask */
1735 FALSE), /* pcrel_offset */
1736
1737 /* Like GOT_TLSGD16_LO, but next higher group of 16 bits. */
1738 HOWTO (R_PPC64_GOT_TLSGD16_HI,
1739 16, /* rightshift */
1740 1, /* size (0 = byte, 1 = short, 2 = long) */
1741 16, /* bitsize */
1742 FALSE, /* pc_relative */
1743 0, /* bitpos */
1744 complain_overflow_signed, /* complain_on_overflow */
1745 ppc64_elf_unhandled_reloc, /* special_function */
1746 "R_PPC64_GOT_TLSGD16_HI", /* name */
1747 FALSE, /* partial_inplace */
1748 0, /* src_mask */
1749 0xffff, /* dst_mask */
1750 FALSE), /* pcrel_offset */
1751
1752 /* Like GOT_TLSGD16_HI, but adjust for low 16 bits. */
1753 HOWTO (R_PPC64_GOT_TLSGD16_HA,
1754 16, /* rightshift */
1755 1, /* size (0 = byte, 1 = short, 2 = long) */
1756 16, /* bitsize */
1757 FALSE, /* pc_relative */
1758 0, /* bitpos */
1759 complain_overflow_signed, /* complain_on_overflow */
1760 ppc64_elf_unhandled_reloc, /* special_function */
1761 "R_PPC64_GOT_TLSGD16_HA", /* name */
1762 FALSE, /* partial_inplace */
1763 0, /* src_mask */
1764 0xffff, /* dst_mask */
1765 FALSE), /* pcrel_offset */
1766
1767 /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1768 with values (sym+add)@dtpmod and zero, and computes the offset to the
1769 first entry relative to the TOC base (r2). */
1770 HOWTO (R_PPC64_GOT_TLSLD16,
1771 0, /* rightshift */
1772 1, /* size (0 = byte, 1 = short, 2 = long) */
1773 16, /* bitsize */
1774 FALSE, /* pc_relative */
1775 0, /* bitpos */
1776 complain_overflow_signed, /* complain_on_overflow */
1777 ppc64_elf_unhandled_reloc, /* special_function */
1778 "R_PPC64_GOT_TLSLD16", /* name */
1779 FALSE, /* partial_inplace */
1780 0, /* src_mask */
1781 0xffff, /* dst_mask */
1782 FALSE), /* pcrel_offset */
1783
1784 /* Like GOT_TLSLD16, but no overflow. */
1785 HOWTO (R_PPC64_GOT_TLSLD16_LO,
1786 0, /* rightshift */
1787 1, /* size (0 = byte, 1 = short, 2 = long) */
1788 16, /* bitsize */
1789 FALSE, /* pc_relative */
1790 0, /* bitpos */
1791 complain_overflow_dont, /* complain_on_overflow */
1792 ppc64_elf_unhandled_reloc, /* special_function */
1793 "R_PPC64_GOT_TLSLD16_LO", /* name */
1794 FALSE, /* partial_inplace */
1795 0, /* src_mask */
1796 0xffff, /* dst_mask */
1797 FALSE), /* pcrel_offset */
1798
1799 /* Like GOT_TLSLD16_LO, but next higher group of 16 bits. */
1800 HOWTO (R_PPC64_GOT_TLSLD16_HI,
1801 16, /* rightshift */
1802 1, /* size (0 = byte, 1 = short, 2 = long) */
1803 16, /* bitsize */
1804 FALSE, /* pc_relative */
1805 0, /* bitpos */
1806 complain_overflow_signed, /* complain_on_overflow */
1807 ppc64_elf_unhandled_reloc, /* special_function */
1808 "R_PPC64_GOT_TLSLD16_HI", /* name */
1809 FALSE, /* partial_inplace */
1810 0, /* src_mask */
1811 0xffff, /* dst_mask */
1812 FALSE), /* pcrel_offset */
1813
1814 /* Like GOT_TLSLD16_HI, but adjust for low 16 bits. */
1815 HOWTO (R_PPC64_GOT_TLSLD16_HA,
1816 16, /* rightshift */
1817 1, /* size (0 = byte, 1 = short, 2 = long) */
1818 16, /* bitsize */
1819 FALSE, /* pc_relative */
1820 0, /* bitpos */
1821 complain_overflow_signed, /* complain_on_overflow */
1822 ppc64_elf_unhandled_reloc, /* special_function */
1823 "R_PPC64_GOT_TLSLD16_HA", /* name */
1824 FALSE, /* partial_inplace */
1825 0, /* src_mask */
1826 0xffff, /* dst_mask */
1827 FALSE), /* pcrel_offset */
1828
1829 /* Allocates an entry in the GOT with value (sym+add)@dtprel, and computes
1830 the offset to the entry relative to the TOC base (r2). */
1831 HOWTO (R_PPC64_GOT_DTPREL16_DS,
1832 0, /* rightshift */
1833 1, /* size (0 = byte, 1 = short, 2 = long) */
1834 16, /* bitsize */
1835 FALSE, /* pc_relative */
1836 0, /* bitpos */
1837 complain_overflow_signed, /* complain_on_overflow */
1838 ppc64_elf_unhandled_reloc, /* special_function */
1839 "R_PPC64_GOT_DTPREL16_DS", /* name */
1840 FALSE, /* partial_inplace */
1841 0, /* src_mask */
1842 0xfffc, /* dst_mask */
1843 FALSE), /* pcrel_offset */
1844
1845 /* Like GOT_DTPREL16_DS, but no overflow. */
1846 HOWTO (R_PPC64_GOT_DTPREL16_LO_DS,
1847 0, /* rightshift */
1848 1, /* size (0 = byte, 1 = short, 2 = long) */
1849 16, /* bitsize */
1850 FALSE, /* pc_relative */
1851 0, /* bitpos */
1852 complain_overflow_dont, /* complain_on_overflow */
1853 ppc64_elf_unhandled_reloc, /* special_function */
1854 "R_PPC64_GOT_DTPREL16_LO_DS", /* name */
1855 FALSE, /* partial_inplace */
1856 0, /* src_mask */
1857 0xfffc, /* dst_mask */
1858 FALSE), /* pcrel_offset */
1859
1860 /* Like GOT_DTPREL16_LO_DS, but next higher group of 16 bits. */
1861 HOWTO (R_PPC64_GOT_DTPREL16_HI,
1862 16, /* rightshift */
1863 1, /* size (0 = byte, 1 = short, 2 = long) */
1864 16, /* bitsize */
1865 FALSE, /* pc_relative */
1866 0, /* bitpos */
1867 complain_overflow_signed, /* complain_on_overflow */
1868 ppc64_elf_unhandled_reloc, /* special_function */
1869 "R_PPC64_GOT_DTPREL16_HI", /* name */
1870 FALSE, /* partial_inplace */
1871 0, /* src_mask */
1872 0xffff, /* dst_mask */
1873 FALSE), /* pcrel_offset */
1874
1875 /* Like GOT_DTPREL16_HI, but adjust for low 16 bits. */
1876 HOWTO (R_PPC64_GOT_DTPREL16_HA,
1877 16, /* rightshift */
1878 1, /* size (0 = byte, 1 = short, 2 = long) */
1879 16, /* bitsize */
1880 FALSE, /* pc_relative */
1881 0, /* bitpos */
1882 complain_overflow_signed, /* complain_on_overflow */
1883 ppc64_elf_unhandled_reloc, /* special_function */
1884 "R_PPC64_GOT_DTPREL16_HA", /* name */
1885 FALSE, /* partial_inplace */
1886 0, /* src_mask */
1887 0xffff, /* dst_mask */
1888 FALSE), /* pcrel_offset */
1889
1890 /* Allocates an entry in the GOT with value (sym+add)@tprel, and computes the
1891 offset to the entry relative to the TOC base (r2). */
1892 HOWTO (R_PPC64_GOT_TPREL16_DS,
1893 0, /* rightshift */
1894 1, /* size (0 = byte, 1 = short, 2 = long) */
1895 16, /* bitsize */
1896 FALSE, /* pc_relative */
1897 0, /* bitpos */
1898 complain_overflow_signed, /* complain_on_overflow */
1899 ppc64_elf_unhandled_reloc, /* special_function */
1900 "R_PPC64_GOT_TPREL16_DS", /* name */
1901 FALSE, /* partial_inplace */
1902 0, /* src_mask */
1903 0xfffc, /* dst_mask */
1904 FALSE), /* pcrel_offset */
1905
1906 /* Like GOT_TPREL16_DS, but no overflow. */
1907 HOWTO (R_PPC64_GOT_TPREL16_LO_DS,
1908 0, /* rightshift */
1909 1, /* size (0 = byte, 1 = short, 2 = long) */
1910 16, /* bitsize */
1911 FALSE, /* pc_relative */
1912 0, /* bitpos */
1913 complain_overflow_dont, /* complain_on_overflow */
1914 ppc64_elf_unhandled_reloc, /* special_function */
1915 "R_PPC64_GOT_TPREL16_LO_DS", /* name */
1916 FALSE, /* partial_inplace */
1917 0, /* src_mask */
1918 0xfffc, /* dst_mask */
1919 FALSE), /* pcrel_offset */
1920
1921 /* Like GOT_TPREL16_LO_DS, but next higher group of 16 bits. */
1922 HOWTO (R_PPC64_GOT_TPREL16_HI,
1923 16, /* rightshift */
1924 1, /* size (0 = byte, 1 = short, 2 = long) */
1925 16, /* bitsize */
1926 FALSE, /* pc_relative */
1927 0, /* bitpos */
1928 complain_overflow_signed, /* complain_on_overflow */
1929 ppc64_elf_unhandled_reloc, /* special_function */
1930 "R_PPC64_GOT_TPREL16_HI", /* name */
1931 FALSE, /* partial_inplace */
1932 0, /* src_mask */
1933 0xffff, /* dst_mask */
1934 FALSE), /* pcrel_offset */
1935
1936 /* Like GOT_TPREL16_HI, but adjust for low 16 bits. */
1937 HOWTO (R_PPC64_GOT_TPREL16_HA,
1938 16, /* rightshift */
1939 1, /* size (0 = byte, 1 = short, 2 = long) */
1940 16, /* bitsize */
1941 FALSE, /* pc_relative */
1942 0, /* bitpos */
1943 complain_overflow_signed, /* complain_on_overflow */
1944 ppc64_elf_unhandled_reloc, /* special_function */
1945 "R_PPC64_GOT_TPREL16_HA", /* name */
1946 FALSE, /* partial_inplace */
1947 0, /* src_mask */
1948 0xffff, /* dst_mask */
1949 FALSE), /* pcrel_offset */
1950
1951 HOWTO (R_PPC64_JMP_IREL, /* type */
1952 0, /* rightshift */
1953 0, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1954 0, /* bitsize */
1955 FALSE, /* pc_relative */
1956 0, /* bitpos */
1957 complain_overflow_dont, /* complain_on_overflow */
1958 ppc64_elf_unhandled_reloc, /* special_function */
1959 "R_PPC64_JMP_IREL", /* name */
1960 FALSE, /* partial_inplace */
1961 0, /* src_mask */
1962 0, /* dst_mask */
1963 FALSE), /* pcrel_offset */
1964
1965 HOWTO (R_PPC64_IRELATIVE, /* type */
1966 0, /* rightshift */
1967 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1968 64, /* bitsize */
1969 FALSE, /* pc_relative */
1970 0, /* bitpos */
1971 complain_overflow_dont, /* complain_on_overflow */
1972 bfd_elf_generic_reloc, /* special_function */
1973 "R_PPC64_IRELATIVE", /* name */
1974 FALSE, /* partial_inplace */
1975 0, /* src_mask */
1976 ONES (64), /* dst_mask */
1977 FALSE), /* pcrel_offset */
1978
1979 /* A 16 bit relative relocation. */
1980 HOWTO (R_PPC64_REL16, /* type */
1981 0, /* rightshift */
1982 1, /* size (0 = byte, 1 = short, 2 = long) */
1983 16, /* bitsize */
1984 TRUE, /* pc_relative */
1985 0, /* bitpos */
1986 complain_overflow_signed, /* complain_on_overflow */
1987 bfd_elf_generic_reloc, /* special_function */
1988 "R_PPC64_REL16", /* name */
1989 FALSE, /* partial_inplace */
1990 0, /* src_mask */
1991 0xffff, /* dst_mask */
1992 TRUE), /* pcrel_offset */
1993
1994 /* A 16 bit relative relocation without overflow. */
1995 HOWTO (R_PPC64_REL16_LO, /* type */
1996 0, /* rightshift */
1997 1, /* size (0 = byte, 1 = short, 2 = long) */
1998 16, /* bitsize */
1999 TRUE, /* pc_relative */
2000 0, /* bitpos */
2001 complain_overflow_dont,/* complain_on_overflow */
2002 bfd_elf_generic_reloc, /* special_function */
2003 "R_PPC64_REL16_LO", /* name */
2004 FALSE, /* partial_inplace */
2005 0, /* src_mask */
2006 0xffff, /* dst_mask */
2007 TRUE), /* pcrel_offset */
2008
2009 /* The high order 16 bits of a relative address. */
2010 HOWTO (R_PPC64_REL16_HI, /* type */
2011 16, /* rightshift */
2012 1, /* size (0 = byte, 1 = short, 2 = long) */
2013 16, /* bitsize */
2014 TRUE, /* pc_relative */
2015 0, /* bitpos */
2016 complain_overflow_signed, /* complain_on_overflow */
2017 bfd_elf_generic_reloc, /* special_function */
2018 "R_PPC64_REL16_HI", /* name */
2019 FALSE, /* partial_inplace */
2020 0, /* src_mask */
2021 0xffff, /* dst_mask */
2022 TRUE), /* pcrel_offset */
2023
2024 /* The high order 16 bits of a relative address, plus 1 if the contents of
2025 the low 16 bits, treated as a signed number, is negative. */
2026 HOWTO (R_PPC64_REL16_HA, /* type */
2027 16, /* rightshift */
2028 1, /* size (0 = byte, 1 = short, 2 = long) */
2029 16, /* bitsize */
2030 TRUE, /* pc_relative */
2031 0, /* bitpos */
2032 complain_overflow_signed, /* complain_on_overflow */
2033 ppc64_elf_ha_reloc, /* special_function */
2034 "R_PPC64_REL16_HA", /* name */
2035 FALSE, /* partial_inplace */
2036 0, /* src_mask */
2037 0xffff, /* dst_mask */
2038 TRUE), /* pcrel_offset */
2039
2040 /* Like R_PPC64_REL16_HA but for split field in addpcis. */
2041 HOWTO (R_PPC64_REL16DX_HA, /* type */
2042 16, /* rightshift */
2043 2, /* size (0 = byte, 1 = short, 2 = long) */
2044 16, /* bitsize */
2045 TRUE, /* pc_relative */
2046 0, /* bitpos */
2047 complain_overflow_signed, /* complain_on_overflow */
2048 ppc64_elf_ha_reloc, /* special_function */
2049 "R_PPC64_REL16DX_HA", /* name */
2050 FALSE, /* partial_inplace */
2051 0, /* src_mask */
2052 0x1fffc1, /* dst_mask */
2053 TRUE), /* pcrel_offset */
2054
2055 /* A split-field reloc for addpcis, non-relative (gas internal use only). */
2056 HOWTO (R_PPC64_16DX_HA, /* type */
2057 16, /* rightshift */
2058 2, /* size (0 = byte, 1 = short, 2 = long) */
2059 16, /* bitsize */
2060 FALSE, /* pc_relative */
2061 0, /* bitpos */
2062 complain_overflow_signed, /* complain_on_overflow */
2063 ppc64_elf_ha_reloc, /* special_function */
2064 "R_PPC64_16DX_HA", /* name */
2065 FALSE, /* partial_inplace */
2066 0, /* src_mask */
2067 0x1fffc1, /* dst_mask */
2068 FALSE), /* pcrel_offset */
2069
2070 /* Like R_PPC64_ADDR16_HI, but no overflow. */
2071 HOWTO (R_PPC64_ADDR16_HIGH, /* type */
2072 16, /* rightshift */
2073 1, /* size (0 = byte, 1 = short, 2 = long) */
2074 16, /* bitsize */
2075 FALSE, /* pc_relative */
2076 0, /* bitpos */
2077 complain_overflow_dont, /* complain_on_overflow */
2078 bfd_elf_generic_reloc, /* special_function */
2079 "R_PPC64_ADDR16_HIGH", /* name */
2080 FALSE, /* partial_inplace */
2081 0, /* src_mask */
2082 0xffff, /* dst_mask */
2083 FALSE), /* pcrel_offset */
2084
2085 /* Like R_PPC64_ADDR16_HA, but no overflow. */
2086 HOWTO (R_PPC64_ADDR16_HIGHA, /* type */
2087 16, /* rightshift */
2088 1, /* size (0 = byte, 1 = short, 2 = long) */
2089 16, /* bitsize */
2090 FALSE, /* pc_relative */
2091 0, /* bitpos */
2092 complain_overflow_dont, /* complain_on_overflow */
2093 ppc64_elf_ha_reloc, /* special_function */
2094 "R_PPC64_ADDR16_HIGHA", /* name */
2095 FALSE, /* partial_inplace */
2096 0, /* src_mask */
2097 0xffff, /* dst_mask */
2098 FALSE), /* pcrel_offset */
2099
2100 /* Like R_PPC64_DTPREL16_HI, but no overflow. */
2101 HOWTO (R_PPC64_DTPREL16_HIGH,
2102 16, /* rightshift */
2103 1, /* size (0 = byte, 1 = short, 2 = long) */
2104 16, /* bitsize */
2105 FALSE, /* pc_relative */
2106 0, /* bitpos */
2107 complain_overflow_dont, /* complain_on_overflow */
2108 ppc64_elf_unhandled_reloc, /* special_function */
2109 "R_PPC64_DTPREL16_HIGH", /* name */
2110 FALSE, /* partial_inplace */
2111 0, /* src_mask */
2112 0xffff, /* dst_mask */
2113 FALSE), /* pcrel_offset */
2114
2115 /* Like R_PPC64_DTPREL16_HA, but no overflow. */
2116 HOWTO (R_PPC64_DTPREL16_HIGHA,
2117 16, /* rightshift */
2118 1, /* size (0 = byte, 1 = short, 2 = long) */
2119 16, /* bitsize */
2120 FALSE, /* pc_relative */
2121 0, /* bitpos */
2122 complain_overflow_dont, /* complain_on_overflow */
2123 ppc64_elf_unhandled_reloc, /* special_function */
2124 "R_PPC64_DTPREL16_HIGHA", /* name */
2125 FALSE, /* partial_inplace */
2126 0, /* src_mask */
2127 0xffff, /* dst_mask */
2128 FALSE), /* pcrel_offset */
2129
2130 /* Like R_PPC64_TPREL16_HI, but no overflow. */
2131 HOWTO (R_PPC64_TPREL16_HIGH,
2132 16, /* rightshift */
2133 1, /* size (0 = byte, 1 = short, 2 = long) */
2134 16, /* bitsize */
2135 FALSE, /* pc_relative */
2136 0, /* bitpos */
2137 complain_overflow_dont, /* complain_on_overflow */
2138 ppc64_elf_unhandled_reloc, /* special_function */
2139 "R_PPC64_TPREL16_HIGH", /* name */
2140 FALSE, /* partial_inplace */
2141 0, /* src_mask */
2142 0xffff, /* dst_mask */
2143 FALSE), /* pcrel_offset */
2144
2145 /* Like R_PPC64_TPREL16_HA, but no overflow. */
2146 HOWTO (R_PPC64_TPREL16_HIGHA,
2147 16, /* rightshift */
2148 1, /* size (0 = byte, 1 = short, 2 = long) */
2149 16, /* bitsize */
2150 FALSE, /* pc_relative */
2151 0, /* bitpos */
2152 complain_overflow_dont, /* complain_on_overflow */
2153 ppc64_elf_unhandled_reloc, /* special_function */
2154 "R_PPC64_TPREL16_HIGHA", /* name */
2155 FALSE, /* partial_inplace */
2156 0, /* src_mask */
2157 0xffff, /* dst_mask */
2158 FALSE), /* pcrel_offset */
2159
2160 /* Marker reloc on ELFv2 large-model function entry. */
2161 HOWTO (R_PPC64_ENTRY,
2162 0, /* rightshift */
2163 2, /* size (0 = byte, 1 = short, 2 = long) */
2164 32, /* bitsize */
2165 FALSE, /* pc_relative */
2166 0, /* bitpos */
2167 complain_overflow_dont, /* complain_on_overflow */
2168 bfd_elf_generic_reloc, /* special_function */
2169 "R_PPC64_ENTRY", /* name */
2170 FALSE, /* partial_inplace */
2171 0, /* src_mask */
2172 0, /* dst_mask */
2173 FALSE), /* pcrel_offset */
2174
2175 /* Like ADDR64, but use local entry point of function. */
2176 HOWTO (R_PPC64_ADDR64_LOCAL, /* type */
2177 0, /* rightshift */
2178 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
2179 64, /* bitsize */
2180 FALSE, /* pc_relative */
2181 0, /* bitpos */
2182 complain_overflow_dont, /* complain_on_overflow */
2183 bfd_elf_generic_reloc, /* special_function */
2184 "R_PPC64_ADDR64_LOCAL", /* name */
2185 FALSE, /* partial_inplace */
2186 0, /* src_mask */
2187 ONES (64), /* dst_mask */
2188 FALSE), /* pcrel_offset */
2189
2190 /* GNU extension to record C++ vtable hierarchy. */
2191 HOWTO (R_PPC64_GNU_VTINHERIT, /* type */
2192 0, /* rightshift */
2193 0, /* size (0 = byte, 1 = short, 2 = long) */
2194 0, /* bitsize */
2195 FALSE, /* pc_relative */
2196 0, /* bitpos */
2197 complain_overflow_dont, /* complain_on_overflow */
2198 NULL, /* special_function */
2199 "R_PPC64_GNU_VTINHERIT", /* name */
2200 FALSE, /* partial_inplace */
2201 0, /* src_mask */
2202 0, /* dst_mask */
2203 FALSE), /* pcrel_offset */
2204
2205 /* GNU extension to record C++ vtable member usage. */
2206 HOWTO (R_PPC64_GNU_VTENTRY, /* type */
2207 0, /* rightshift */
2208 0, /* size (0 = byte, 1 = short, 2 = long) */
2209 0, /* bitsize */
2210 FALSE, /* pc_relative */
2211 0, /* bitpos */
2212 complain_overflow_dont, /* complain_on_overflow */
2213 NULL, /* special_function */
2214 "R_PPC64_GNU_VTENTRY", /* name */
2215 FALSE, /* partial_inplace */
2216 0, /* src_mask */
2217 0, /* dst_mask */
2218 FALSE), /* pcrel_offset */
2219 };
2220
2221 \f
2222 /* Initialize the ppc64_elf_howto_table, so that linear accesses can
2223 be done. */
2224
2225 static void
2226 ppc_howto_init (void)
2227 {
2228 unsigned int i, type;
2229
2230 for (i = 0; i < ARRAY_SIZE (ppc64_elf_howto_raw); i++)
2231 {
2232 type = ppc64_elf_howto_raw[i].type;
2233 BFD_ASSERT (type < ARRAY_SIZE (ppc64_elf_howto_table));
2234 ppc64_elf_howto_table[type] = &ppc64_elf_howto_raw[i];
2235 }
2236 }
2237
2238 static reloc_howto_type *
2239 ppc64_elf_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2240 bfd_reloc_code_real_type code)
2241 {
2242 enum elf_ppc64_reloc_type r = R_PPC64_NONE;
2243
2244 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2245 /* Initialize howto table if needed. */
2246 ppc_howto_init ();
2247
2248 switch (code)
2249 {
2250 default:
2251 return NULL;
2252
2253 case BFD_RELOC_NONE: r = R_PPC64_NONE;
2254 break;
2255 case BFD_RELOC_32: r = R_PPC64_ADDR32;
2256 break;
2257 case BFD_RELOC_PPC_BA26: r = R_PPC64_ADDR24;
2258 break;
2259 case BFD_RELOC_16: r = R_PPC64_ADDR16;
2260 break;
2261 case BFD_RELOC_LO16: r = R_PPC64_ADDR16_LO;
2262 break;
2263 case BFD_RELOC_HI16: r = R_PPC64_ADDR16_HI;
2264 break;
2265 case BFD_RELOC_PPC64_ADDR16_HIGH: r = R_PPC64_ADDR16_HIGH;
2266 break;
2267 case BFD_RELOC_HI16_S: r = R_PPC64_ADDR16_HA;
2268 break;
2269 case BFD_RELOC_PPC64_ADDR16_HIGHA: r = R_PPC64_ADDR16_HIGHA;
2270 break;
2271 case BFD_RELOC_PPC_BA16: r = R_PPC64_ADDR14;
2272 break;
2273 case BFD_RELOC_PPC_BA16_BRTAKEN: r = R_PPC64_ADDR14_BRTAKEN;
2274 break;
2275 case BFD_RELOC_PPC_BA16_BRNTAKEN: r = R_PPC64_ADDR14_BRNTAKEN;
2276 break;
2277 case BFD_RELOC_PPC_B26: r = R_PPC64_REL24;
2278 break;
2279 case BFD_RELOC_PPC_B16: r = R_PPC64_REL14;
2280 break;
2281 case BFD_RELOC_PPC_B16_BRTAKEN: r = R_PPC64_REL14_BRTAKEN;
2282 break;
2283 case BFD_RELOC_PPC_B16_BRNTAKEN: r = R_PPC64_REL14_BRNTAKEN;
2284 break;
2285 case BFD_RELOC_16_GOTOFF: r = R_PPC64_GOT16;
2286 break;
2287 case BFD_RELOC_LO16_GOTOFF: r = R_PPC64_GOT16_LO;
2288 break;
2289 case BFD_RELOC_HI16_GOTOFF: r = R_PPC64_GOT16_HI;
2290 break;
2291 case BFD_RELOC_HI16_S_GOTOFF: r = R_PPC64_GOT16_HA;
2292 break;
2293 case BFD_RELOC_PPC_COPY: r = R_PPC64_COPY;
2294 break;
2295 case BFD_RELOC_PPC_GLOB_DAT: r = R_PPC64_GLOB_DAT;
2296 break;
2297 case BFD_RELOC_32_PCREL: r = R_PPC64_REL32;
2298 break;
2299 case BFD_RELOC_32_PLTOFF: r = R_PPC64_PLT32;
2300 break;
2301 case BFD_RELOC_32_PLT_PCREL: r = R_PPC64_PLTREL32;
2302 break;
2303 case BFD_RELOC_LO16_PLTOFF: r = R_PPC64_PLT16_LO;
2304 break;
2305 case BFD_RELOC_HI16_PLTOFF: r = R_PPC64_PLT16_HI;
2306 break;
2307 case BFD_RELOC_HI16_S_PLTOFF: r = R_PPC64_PLT16_HA;
2308 break;
2309 case BFD_RELOC_16_BASEREL: r = R_PPC64_SECTOFF;
2310 break;
2311 case BFD_RELOC_LO16_BASEREL: r = R_PPC64_SECTOFF_LO;
2312 break;
2313 case BFD_RELOC_HI16_BASEREL: r = R_PPC64_SECTOFF_HI;
2314 break;
2315 case BFD_RELOC_HI16_S_BASEREL: r = R_PPC64_SECTOFF_HA;
2316 break;
2317 case BFD_RELOC_CTOR: r = R_PPC64_ADDR64;
2318 break;
2319 case BFD_RELOC_64: r = R_PPC64_ADDR64;
2320 break;
2321 case BFD_RELOC_PPC64_HIGHER: r = R_PPC64_ADDR16_HIGHER;
2322 break;
2323 case BFD_RELOC_PPC64_HIGHER_S: r = R_PPC64_ADDR16_HIGHERA;
2324 break;
2325 case BFD_RELOC_PPC64_HIGHEST: r = R_PPC64_ADDR16_HIGHEST;
2326 break;
2327 case BFD_RELOC_PPC64_HIGHEST_S: r = R_PPC64_ADDR16_HIGHESTA;
2328 break;
2329 case BFD_RELOC_64_PCREL: r = R_PPC64_REL64;
2330 break;
2331 case BFD_RELOC_64_PLTOFF: r = R_PPC64_PLT64;
2332 break;
2333 case BFD_RELOC_64_PLT_PCREL: r = R_PPC64_PLTREL64;
2334 break;
2335 case BFD_RELOC_PPC_TOC16: r = R_PPC64_TOC16;
2336 break;
2337 case BFD_RELOC_PPC64_TOC16_LO: r = R_PPC64_TOC16_LO;
2338 break;
2339 case BFD_RELOC_PPC64_TOC16_HI: r = R_PPC64_TOC16_HI;
2340 break;
2341 case BFD_RELOC_PPC64_TOC16_HA: r = R_PPC64_TOC16_HA;
2342 break;
2343 case BFD_RELOC_PPC64_TOC: r = R_PPC64_TOC;
2344 break;
2345 case BFD_RELOC_PPC64_PLTGOT16: r = R_PPC64_PLTGOT16;
2346 break;
2347 case BFD_RELOC_PPC64_PLTGOT16_LO: r = R_PPC64_PLTGOT16_LO;
2348 break;
2349 case BFD_RELOC_PPC64_PLTGOT16_HI: r = R_PPC64_PLTGOT16_HI;
2350 break;
2351 case BFD_RELOC_PPC64_PLTGOT16_HA: r = R_PPC64_PLTGOT16_HA;
2352 break;
2353 case BFD_RELOC_PPC64_ADDR16_DS: r = R_PPC64_ADDR16_DS;
2354 break;
2355 case BFD_RELOC_PPC64_ADDR16_LO_DS: r = R_PPC64_ADDR16_LO_DS;
2356 break;
2357 case BFD_RELOC_PPC64_GOT16_DS: r = R_PPC64_GOT16_DS;
2358 break;
2359 case BFD_RELOC_PPC64_GOT16_LO_DS: r = R_PPC64_GOT16_LO_DS;
2360 break;
2361 case BFD_RELOC_PPC64_PLT16_LO_DS: r = R_PPC64_PLT16_LO_DS;
2362 break;
2363 case BFD_RELOC_PPC64_SECTOFF_DS: r = R_PPC64_SECTOFF_DS;
2364 break;
2365 case BFD_RELOC_PPC64_SECTOFF_LO_DS: r = R_PPC64_SECTOFF_LO_DS;
2366 break;
2367 case BFD_RELOC_PPC64_TOC16_DS: r = R_PPC64_TOC16_DS;
2368 break;
2369 case BFD_RELOC_PPC64_TOC16_LO_DS: r = R_PPC64_TOC16_LO_DS;
2370 break;
2371 case BFD_RELOC_PPC64_PLTGOT16_DS: r = R_PPC64_PLTGOT16_DS;
2372 break;
2373 case BFD_RELOC_PPC64_PLTGOT16_LO_DS: r = R_PPC64_PLTGOT16_LO_DS;
2374 break;
2375 case BFD_RELOC_PPC_TLS: r = R_PPC64_TLS;
2376 break;
2377 case BFD_RELOC_PPC_TLSGD: r = R_PPC64_TLSGD;
2378 break;
2379 case BFD_RELOC_PPC_TLSLD: r = R_PPC64_TLSLD;
2380 break;
2381 case BFD_RELOC_PPC_DTPMOD: r = R_PPC64_DTPMOD64;
2382 break;
2383 case BFD_RELOC_PPC_TPREL16: r = R_PPC64_TPREL16;
2384 break;
2385 case BFD_RELOC_PPC_TPREL16_LO: r = R_PPC64_TPREL16_LO;
2386 break;
2387 case BFD_RELOC_PPC_TPREL16_HI: r = R_PPC64_TPREL16_HI;
2388 break;
2389 case BFD_RELOC_PPC64_TPREL16_HIGH: r = R_PPC64_TPREL16_HIGH;
2390 break;
2391 case BFD_RELOC_PPC_TPREL16_HA: r = R_PPC64_TPREL16_HA;
2392 break;
2393 case BFD_RELOC_PPC64_TPREL16_HIGHA: r = R_PPC64_TPREL16_HIGHA;
2394 break;
2395 case BFD_RELOC_PPC_TPREL: r = R_PPC64_TPREL64;
2396 break;
2397 case BFD_RELOC_PPC_DTPREL16: r = R_PPC64_DTPREL16;
2398 break;
2399 case BFD_RELOC_PPC_DTPREL16_LO: r = R_PPC64_DTPREL16_LO;
2400 break;
2401 case BFD_RELOC_PPC_DTPREL16_HI: r = R_PPC64_DTPREL16_HI;
2402 break;
2403 case BFD_RELOC_PPC64_DTPREL16_HIGH: r = R_PPC64_DTPREL16_HIGH;
2404 break;
2405 case BFD_RELOC_PPC_DTPREL16_HA: r = R_PPC64_DTPREL16_HA;
2406 break;
2407 case BFD_RELOC_PPC64_DTPREL16_HIGHA: r = R_PPC64_DTPREL16_HIGHA;
2408 break;
2409 case BFD_RELOC_PPC_DTPREL: r = R_PPC64_DTPREL64;
2410 break;
2411 case BFD_RELOC_PPC_GOT_TLSGD16: r = R_PPC64_GOT_TLSGD16;
2412 break;
2413 case BFD_RELOC_PPC_GOT_TLSGD16_LO: r = R_PPC64_GOT_TLSGD16_LO;
2414 break;
2415 case BFD_RELOC_PPC_GOT_TLSGD16_HI: r = R_PPC64_GOT_TLSGD16_HI;
2416 break;
2417 case BFD_RELOC_PPC_GOT_TLSGD16_HA: r = R_PPC64_GOT_TLSGD16_HA;
2418 break;
2419 case BFD_RELOC_PPC_GOT_TLSLD16: r = R_PPC64_GOT_TLSLD16;
2420 break;
2421 case BFD_RELOC_PPC_GOT_TLSLD16_LO: r = R_PPC64_GOT_TLSLD16_LO;
2422 break;
2423 case BFD_RELOC_PPC_GOT_TLSLD16_HI: r = R_PPC64_GOT_TLSLD16_HI;
2424 break;
2425 case BFD_RELOC_PPC_GOT_TLSLD16_HA: r = R_PPC64_GOT_TLSLD16_HA;
2426 break;
2427 case BFD_RELOC_PPC_GOT_TPREL16: r = R_PPC64_GOT_TPREL16_DS;
2428 break;
2429 case BFD_RELOC_PPC_GOT_TPREL16_LO: r = R_PPC64_GOT_TPREL16_LO_DS;
2430 break;
2431 case BFD_RELOC_PPC_GOT_TPREL16_HI: r = R_PPC64_GOT_TPREL16_HI;
2432 break;
2433 case BFD_RELOC_PPC_GOT_TPREL16_HA: r = R_PPC64_GOT_TPREL16_HA;
2434 break;
2435 case BFD_RELOC_PPC_GOT_DTPREL16: r = R_PPC64_GOT_DTPREL16_DS;
2436 break;
2437 case BFD_RELOC_PPC_GOT_DTPREL16_LO: r = R_PPC64_GOT_DTPREL16_LO_DS;
2438 break;
2439 case BFD_RELOC_PPC_GOT_DTPREL16_HI: r = R_PPC64_GOT_DTPREL16_HI;
2440 break;
2441 case BFD_RELOC_PPC_GOT_DTPREL16_HA: r = R_PPC64_GOT_DTPREL16_HA;
2442 break;
2443 case BFD_RELOC_PPC64_TPREL16_DS: r = R_PPC64_TPREL16_DS;
2444 break;
2445 case BFD_RELOC_PPC64_TPREL16_LO_DS: r = R_PPC64_TPREL16_LO_DS;
2446 break;
2447 case BFD_RELOC_PPC64_TPREL16_HIGHER: r = R_PPC64_TPREL16_HIGHER;
2448 break;
2449 case BFD_RELOC_PPC64_TPREL16_HIGHERA: r = R_PPC64_TPREL16_HIGHERA;
2450 break;
2451 case BFD_RELOC_PPC64_TPREL16_HIGHEST: r = R_PPC64_TPREL16_HIGHEST;
2452 break;
2453 case BFD_RELOC_PPC64_TPREL16_HIGHESTA: r = R_PPC64_TPREL16_HIGHESTA;
2454 break;
2455 case BFD_RELOC_PPC64_DTPREL16_DS: r = R_PPC64_DTPREL16_DS;
2456 break;
2457 case BFD_RELOC_PPC64_DTPREL16_LO_DS: r = R_PPC64_DTPREL16_LO_DS;
2458 break;
2459 case BFD_RELOC_PPC64_DTPREL16_HIGHER: r = R_PPC64_DTPREL16_HIGHER;
2460 break;
2461 case BFD_RELOC_PPC64_DTPREL16_HIGHERA: r = R_PPC64_DTPREL16_HIGHERA;
2462 break;
2463 case BFD_RELOC_PPC64_DTPREL16_HIGHEST: r = R_PPC64_DTPREL16_HIGHEST;
2464 break;
2465 case BFD_RELOC_PPC64_DTPREL16_HIGHESTA: r = R_PPC64_DTPREL16_HIGHESTA;
2466 break;
2467 case BFD_RELOC_16_PCREL: r = R_PPC64_REL16;
2468 break;
2469 case BFD_RELOC_LO16_PCREL: r = R_PPC64_REL16_LO;
2470 break;
2471 case BFD_RELOC_HI16_PCREL: r = R_PPC64_REL16_HI;
2472 break;
2473 case BFD_RELOC_HI16_S_PCREL: r = R_PPC64_REL16_HA;
2474 break;
2475 case BFD_RELOC_PPC_16DX_HA: r = R_PPC64_16DX_HA;
2476 break;
2477 case BFD_RELOC_PPC_REL16DX_HA: r = R_PPC64_REL16DX_HA;
2478 break;
2479 case BFD_RELOC_PPC64_ENTRY: r = R_PPC64_ENTRY;
2480 break;
2481 case BFD_RELOC_PPC64_ADDR64_LOCAL: r = R_PPC64_ADDR64_LOCAL;
2482 break;
2483 case BFD_RELOC_VTABLE_INHERIT: r = R_PPC64_GNU_VTINHERIT;
2484 break;
2485 case BFD_RELOC_VTABLE_ENTRY: r = R_PPC64_GNU_VTENTRY;
2486 break;
2487 }
2488
2489 return ppc64_elf_howto_table[r];
2490 };
2491
2492 static reloc_howto_type *
2493 ppc64_elf_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2494 const char *r_name)
2495 {
2496 unsigned int i;
2497
2498 for (i = 0; i < ARRAY_SIZE (ppc64_elf_howto_raw); i++)
2499 if (ppc64_elf_howto_raw[i].name != NULL
2500 && strcasecmp (ppc64_elf_howto_raw[i].name, r_name) == 0)
2501 return &ppc64_elf_howto_raw[i];
2502
2503 return NULL;
2504 }
2505
2506 /* Set the howto pointer for a PowerPC ELF reloc. */
2507
2508 static void
2509 ppc64_elf_info_to_howto (bfd *abfd, arelent *cache_ptr,
2510 Elf_Internal_Rela *dst)
2511 {
2512 unsigned int type;
2513
2514 /* Initialize howto table if needed. */
2515 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2516 ppc_howto_init ();
2517
2518 type = ELF64_R_TYPE (dst->r_info);
2519 if (type >= ARRAY_SIZE (ppc64_elf_howto_table))
2520 {
2521 /* xgettext:c-format */
2522 _bfd_error_handler (_("%B: invalid relocation type %d"),
2523 abfd, (int) type);
2524 type = R_PPC64_NONE;
2525 }
2526 cache_ptr->howto = ppc64_elf_howto_table[type];
2527 }
2528
2529 /* Handle the R_PPC64_ADDR16_HA and similar relocs. */
2530
2531 static bfd_reloc_status_type
2532 ppc64_elf_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2533 void *data, asection *input_section,
2534 bfd *output_bfd, char **error_message)
2535 {
2536 enum elf_ppc64_reloc_type r_type;
2537 long insn;
2538 bfd_size_type octets;
2539 bfd_vma value;
2540
2541 /* If this is a relocatable link (output_bfd test tells us), just
2542 call the generic function. Any adjustment will be done at final
2543 link time. */
2544 if (output_bfd != NULL)
2545 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2546 input_section, output_bfd, error_message);
2547
2548 /* Adjust the addend for sign extension of the low 16 bits.
2549 We won't actually be using the low 16 bits, so trashing them
2550 doesn't matter. */
2551 reloc_entry->addend += 0x8000;
2552 r_type = reloc_entry->howto->type;
2553 if (r_type != R_PPC64_REL16DX_HA)
2554 return bfd_reloc_continue;
2555
2556 value = 0;
2557 if (!bfd_is_com_section (symbol->section))
2558 value = symbol->value;
2559 value += (reloc_entry->addend
2560 + symbol->section->output_offset
2561 + symbol->section->output_section->vma);
2562 value -= (reloc_entry->address
2563 + input_section->output_offset
2564 + input_section->output_section->vma);
2565 value = (bfd_signed_vma) value >> 16;
2566
2567 octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2568 insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
2569 insn &= ~0x1fffc1;
2570 insn |= (value & 0xffc1) | ((value & 0x3e) << 15);
2571 bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
2572 if (value + 0x8000 > 0xffff)
2573 return bfd_reloc_overflow;
2574 return bfd_reloc_ok;
2575 }
2576
2577 static bfd_reloc_status_type
2578 ppc64_elf_branch_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2579 void *data, asection *input_section,
2580 bfd *output_bfd, char **error_message)
2581 {
2582 if (output_bfd != NULL)
2583 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2584 input_section, output_bfd, error_message);
2585
2586 if (strcmp (symbol->section->name, ".opd") == 0
2587 && (symbol->section->owner->flags & DYNAMIC) == 0)
2588 {
2589 bfd_vma dest = opd_entry_value (symbol->section,
2590 symbol->value + reloc_entry->addend,
2591 NULL, NULL, FALSE);
2592 if (dest != (bfd_vma) -1)
2593 reloc_entry->addend = dest - (symbol->value
2594 + symbol->section->output_section->vma
2595 + symbol->section->output_offset);
2596 }
2597 else
2598 {
2599 elf_symbol_type *elfsym = (elf_symbol_type *) symbol;
2600
2601 if (symbol->section->owner != abfd
2602 && symbol->section->owner != NULL
2603 && abiversion (symbol->section->owner) >= 2)
2604 {
2605 unsigned int i;
2606
2607 for (i = 0; i < symbol->section->owner->symcount; ++i)
2608 {
2609 asymbol *symdef = symbol->section->owner->outsymbols[i];
2610
2611 if (strcmp (symdef->name, symbol->name) == 0)
2612 {
2613 elfsym = (elf_symbol_type *) symdef;
2614 break;
2615 }
2616 }
2617 }
2618 reloc_entry->addend
2619 += PPC64_LOCAL_ENTRY_OFFSET (elfsym->internal_elf_sym.st_other);
2620 }
2621 return bfd_reloc_continue;
2622 }
2623
2624 static bfd_reloc_status_type
2625 ppc64_elf_brtaken_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2626 void *data, asection *input_section,
2627 bfd *output_bfd, char **error_message)
2628 {
2629 long insn;
2630 enum elf_ppc64_reloc_type r_type;
2631 bfd_size_type octets;
2632 /* Assume 'at' branch hints. */
2633 bfd_boolean is_isa_v2 = TRUE;
2634
2635 /* If this is a relocatable link (output_bfd test tells us), just
2636 call the generic function. Any adjustment will be done at final
2637 link time. */
2638 if (output_bfd != NULL)
2639 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2640 input_section, output_bfd, error_message);
2641
2642 octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2643 insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
2644 insn &= ~(0x01 << 21);
2645 r_type = reloc_entry->howto->type;
2646 if (r_type == R_PPC64_ADDR14_BRTAKEN
2647 || r_type == R_PPC64_REL14_BRTAKEN)
2648 insn |= 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field. */
2649
2650 if (is_isa_v2)
2651 {
2652 /* Set 'a' bit. This is 0b00010 in BO field for branch
2653 on CR(BI) insns (BO == 001at or 011at), and 0b01000
2654 for branch on CTR insns (BO == 1a00t or 1a01t). */
2655 if ((insn & (0x14 << 21)) == (0x04 << 21))
2656 insn |= 0x02 << 21;
2657 else if ((insn & (0x14 << 21)) == (0x10 << 21))
2658 insn |= 0x08 << 21;
2659 else
2660 goto out;
2661 }
2662 else
2663 {
2664 bfd_vma target = 0;
2665 bfd_vma from;
2666
2667 if (!bfd_is_com_section (symbol->section))
2668 target = symbol->value;
2669 target += symbol->section->output_section->vma;
2670 target += symbol->section->output_offset;
2671 target += reloc_entry->addend;
2672
2673 from = (reloc_entry->address
2674 + input_section->output_offset
2675 + input_section->output_section->vma);
2676
2677 /* Invert 'y' bit if not the default. */
2678 if ((bfd_signed_vma) (target - from) < 0)
2679 insn ^= 0x01 << 21;
2680 }
2681 bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
2682 out:
2683 return ppc64_elf_branch_reloc (abfd, reloc_entry, symbol, data,
2684 input_section, output_bfd, error_message);
2685 }
2686
2687 static bfd_reloc_status_type
2688 ppc64_elf_sectoff_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2689 void *data, asection *input_section,
2690 bfd *output_bfd, char **error_message)
2691 {
2692 /* If this is a relocatable link (output_bfd test tells us), just
2693 call the generic function. Any adjustment will be done at final
2694 link time. */
2695 if (output_bfd != NULL)
2696 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2697 input_section, output_bfd, error_message);
2698
2699 /* Subtract the symbol section base address. */
2700 reloc_entry->addend -= symbol->section->output_section->vma;
2701 return bfd_reloc_continue;
2702 }
2703
2704 static bfd_reloc_status_type
2705 ppc64_elf_sectoff_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2706 void *data, asection *input_section,
2707 bfd *output_bfd, char **error_message)
2708 {
2709 /* If this is a relocatable link (output_bfd test tells us), just
2710 call the generic function. Any adjustment will be done at final
2711 link time. */
2712 if (output_bfd != NULL)
2713 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2714 input_section, output_bfd, error_message);
2715
2716 /* Subtract the symbol section base address. */
2717 reloc_entry->addend -= symbol->section->output_section->vma;
2718
2719 /* Adjust the addend for sign extension of the low 16 bits. */
2720 reloc_entry->addend += 0x8000;
2721 return bfd_reloc_continue;
2722 }
2723
2724 static bfd_reloc_status_type
2725 ppc64_elf_toc_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2726 void *data, asection *input_section,
2727 bfd *output_bfd, char **error_message)
2728 {
2729 bfd_vma TOCstart;
2730
2731 /* If this is a relocatable link (output_bfd test tells us), just
2732 call the generic function. Any adjustment will be done at final
2733 link time. */
2734 if (output_bfd != NULL)
2735 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2736 input_section, output_bfd, error_message);
2737
2738 TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2739 if (TOCstart == 0)
2740 TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2741
2742 /* Subtract the TOC base address. */
2743 reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2744 return bfd_reloc_continue;
2745 }
2746
2747 static bfd_reloc_status_type
2748 ppc64_elf_toc_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2749 void *data, asection *input_section,
2750 bfd *output_bfd, char **error_message)
2751 {
2752 bfd_vma TOCstart;
2753
2754 /* If this is a relocatable link (output_bfd test tells us), just
2755 call the generic function. Any adjustment will be done at final
2756 link time. */
2757 if (output_bfd != NULL)
2758 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2759 input_section, output_bfd, error_message);
2760
2761 TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2762 if (TOCstart == 0)
2763 TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2764
2765 /* Subtract the TOC base address. */
2766 reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2767
2768 /* Adjust the addend for sign extension of the low 16 bits. */
2769 reloc_entry->addend += 0x8000;
2770 return bfd_reloc_continue;
2771 }
2772
2773 static bfd_reloc_status_type
2774 ppc64_elf_toc64_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2775 void *data, asection *input_section,
2776 bfd *output_bfd, char **error_message)
2777 {
2778 bfd_vma TOCstart;
2779 bfd_size_type octets;
2780
2781 /* If this is a relocatable link (output_bfd test tells us), just
2782 call the generic function. Any adjustment will be done at final
2783 link time. */
2784 if (output_bfd != NULL)
2785 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2786 input_section, output_bfd, error_message);
2787
2788 TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2789 if (TOCstart == 0)
2790 TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2791
2792 octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2793 bfd_put_64 (abfd, TOCstart + TOC_BASE_OFF, (bfd_byte *) data + octets);
2794 return bfd_reloc_ok;
2795 }
2796
2797 static bfd_reloc_status_type
2798 ppc64_elf_unhandled_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2799 void *data, asection *input_section,
2800 bfd *output_bfd, char **error_message)
2801 {
2802 /* If this is a relocatable link (output_bfd test tells us), just
2803 call the generic function. Any adjustment will be done at final
2804 link time. */
2805 if (output_bfd != NULL)
2806 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2807 input_section, output_bfd, error_message);
2808
2809 if (error_message != NULL)
2810 {
2811 static char buf[60];
2812 sprintf (buf, "generic linker can't handle %s",
2813 reloc_entry->howto->name);
2814 *error_message = buf;
2815 }
2816 return bfd_reloc_dangerous;
2817 }
2818
2819 /* Track GOT entries needed for a given symbol. We might need more
2820 than one got entry per symbol. */
2821 struct got_entry
2822 {
2823 struct got_entry *next;
2824
2825 /* The symbol addend that we'll be placing in the GOT. */
2826 bfd_vma addend;
2827
2828 /* Unlike other ELF targets, we use separate GOT entries for the same
2829 symbol referenced from different input files. This is to support
2830 automatic multiple TOC/GOT sections, where the TOC base can vary
2831 from one input file to another. After partitioning into TOC groups
2832 we merge entries within the group.
2833
2834 Point to the BFD owning this GOT entry. */
2835 bfd *owner;
2836
2837 /* Zero for non-tls entries, or TLS_TLS and one of TLS_GD, TLS_LD,
2838 TLS_TPREL or TLS_DTPREL for tls entries. */
2839 unsigned char tls_type;
2840
2841 /* Non-zero if got.ent points to real entry. */
2842 unsigned char is_indirect;
2843
2844 /* Reference count until size_dynamic_sections, GOT offset thereafter. */
2845 union
2846 {
2847 bfd_signed_vma refcount;
2848 bfd_vma offset;
2849 struct got_entry *ent;
2850 } got;
2851 };
2852
2853 /* The same for PLT. */
2854 struct plt_entry
2855 {
2856 struct plt_entry *next;
2857
2858 bfd_vma addend;
2859
2860 union
2861 {
2862 bfd_signed_vma refcount;
2863 bfd_vma offset;
2864 } plt;
2865 };
2866
2867 struct ppc64_elf_obj_tdata
2868 {
2869 struct elf_obj_tdata elf;
2870
2871 /* Shortcuts to dynamic linker sections. */
2872 asection *got;
2873 asection *relgot;
2874
2875 /* Used during garbage collection. We attach global symbols defined
2876 on removed .opd entries to this section so that the sym is removed. */
2877 asection *deleted_section;
2878
2879 /* TLS local dynamic got entry handling. Support for multiple GOT
2880 sections means we potentially need one of these for each input bfd. */
2881 struct got_entry tlsld_got;
2882
2883 union {
2884 /* A copy of relocs before they are modified for --emit-relocs. */
2885 Elf_Internal_Rela *relocs;
2886
2887 /* Section contents. */
2888 bfd_byte *contents;
2889 } opd;
2890
2891 /* Nonzero if this bfd has small toc/got relocs, ie. that expect
2892 the reloc to be in the range -32768 to 32767. */
2893 unsigned int has_small_toc_reloc : 1;
2894
2895 /* Set if toc/got ha relocs detected not using r2, or lo reloc
2896 instruction not one we handle. */
2897 unsigned int unexpected_toc_insn : 1;
2898 };
2899
2900 #define ppc64_elf_tdata(bfd) \
2901 ((struct ppc64_elf_obj_tdata *) (bfd)->tdata.any)
2902
2903 #define ppc64_tlsld_got(bfd) \
2904 (&ppc64_elf_tdata (bfd)->tlsld_got)
2905
2906 #define is_ppc64_elf(bfd) \
2907 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
2908 && elf_object_id (bfd) == PPC64_ELF_DATA)
2909
2910 /* Override the generic function because we store some extras. */
2911
2912 static bfd_boolean
2913 ppc64_elf_mkobject (bfd *abfd)
2914 {
2915 return bfd_elf_allocate_object (abfd, sizeof (struct ppc64_elf_obj_tdata),
2916 PPC64_ELF_DATA);
2917 }
2918
2919 /* Fix bad default arch selected for a 64 bit input bfd when the
2920 default is 32 bit. Also select arch based on apuinfo. */
2921
2922 static bfd_boolean
2923 ppc64_elf_object_p (bfd *abfd)
2924 {
2925 if (!abfd->arch_info->the_default)
2926 return TRUE;
2927
2928 if (abfd->arch_info->bits_per_word == 32)
2929 {
2930 Elf_Internal_Ehdr *i_ehdr = elf_elfheader (abfd);
2931
2932 if (i_ehdr->e_ident[EI_CLASS] == ELFCLASS64)
2933 {
2934 /* Relies on arch after 32 bit default being 64 bit default. */
2935 abfd->arch_info = abfd->arch_info->next;
2936 BFD_ASSERT (abfd->arch_info->bits_per_word == 64);
2937 }
2938 }
2939 return _bfd_elf_ppc_set_arch (abfd);
2940 }
2941
2942 /* Support for core dump NOTE sections. */
2943
2944 static bfd_boolean
2945 ppc64_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
2946 {
2947 size_t offset, size;
2948
2949 if (note->descsz != 504)
2950 return FALSE;
2951
2952 /* pr_cursig */
2953 elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
2954
2955 /* pr_pid */
2956 elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 32);
2957
2958 /* pr_reg */
2959 offset = 112;
2960 size = 384;
2961
2962 /* Make a ".reg/999" section. */
2963 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
2964 size, note->descpos + offset);
2965 }
2966
2967 static bfd_boolean
2968 ppc64_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
2969 {
2970 if (note->descsz != 136)
2971 return FALSE;
2972
2973 elf_tdata (abfd)->core->pid
2974 = bfd_get_32 (abfd, note->descdata + 24);
2975 elf_tdata (abfd)->core->program
2976 = _bfd_elfcore_strndup (abfd, note->descdata + 40, 16);
2977 elf_tdata (abfd)->core->command
2978 = _bfd_elfcore_strndup (abfd, note->descdata + 56, 80);
2979
2980 return TRUE;
2981 }
2982
2983 static char *
2984 ppc64_elf_write_core_note (bfd *abfd, char *buf, int *bufsiz, int note_type,
2985 ...)
2986 {
2987 switch (note_type)
2988 {
2989 default:
2990 return NULL;
2991
2992 case NT_PRPSINFO:
2993 {
2994 char data[136];
2995 va_list ap;
2996
2997 va_start (ap, note_type);
2998 memset (data, 0, sizeof (data));
2999 strncpy (data + 40, va_arg (ap, const char *), 16);
3000 strncpy (data + 56, va_arg (ap, const char *), 80);
3001 va_end (ap);
3002 return elfcore_write_note (abfd, buf, bufsiz,
3003 "CORE", note_type, data, sizeof (data));
3004 }
3005
3006 case NT_PRSTATUS:
3007 {
3008 char data[504];
3009 va_list ap;
3010 long pid;
3011 int cursig;
3012 const void *greg;
3013
3014 va_start (ap, note_type);
3015 memset (data, 0, 112);
3016 pid = va_arg (ap, long);
3017 bfd_put_32 (abfd, pid, data + 32);
3018 cursig = va_arg (ap, int);
3019 bfd_put_16 (abfd, cursig, data + 12);
3020 greg = va_arg (ap, const void *);
3021 memcpy (data + 112, greg, 384);
3022 memset (data + 496, 0, 8);
3023 va_end (ap);
3024 return elfcore_write_note (abfd, buf, bufsiz,
3025 "CORE", note_type, data, sizeof (data));
3026 }
3027 }
3028 }
3029
3030 /* Add extra PPC sections. */
3031
3032 static const struct bfd_elf_special_section ppc64_elf_special_sections[]=
3033 {
3034 { STRING_COMMA_LEN (".plt"), 0, SHT_NOBITS, 0 },
3035 { STRING_COMMA_LEN (".sbss"), -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE },
3036 { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
3037 { STRING_COMMA_LEN (".toc"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
3038 { STRING_COMMA_LEN (".toc1"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
3039 { STRING_COMMA_LEN (".tocbss"), 0, SHT_NOBITS, SHF_ALLOC + SHF_WRITE },
3040 { NULL, 0, 0, 0, 0 }
3041 };
3042
3043 enum _ppc64_sec_type {
3044 sec_normal = 0,
3045 sec_opd = 1,
3046 sec_toc = 2
3047 };
3048
3049 struct _ppc64_elf_section_data
3050 {
3051 struct bfd_elf_section_data elf;
3052
3053 union
3054 {
3055 /* An array with one entry for each opd function descriptor,
3056 and some spares since opd entries may be either 16 or 24 bytes. */
3057 #define OPD_NDX(OFF) ((OFF) >> 4)
3058 struct _opd_sec_data
3059 {
3060 /* Points to the function code section for local opd entries. */
3061 asection **func_sec;
3062
3063 /* After editing .opd, adjust references to opd local syms. */
3064 long *adjust;
3065 } opd;
3066
3067 /* An array for toc sections, indexed by offset/8. */
3068 struct _toc_sec_data
3069 {
3070 /* Specifies the relocation symbol index used at a given toc offset. */
3071 unsigned *symndx;
3072
3073 /* And the relocation addend. */
3074 bfd_vma *add;
3075 } toc;
3076 } u;
3077
3078 enum _ppc64_sec_type sec_type:2;
3079
3080 /* Flag set when small branches are detected. Used to
3081 select suitable defaults for the stub group size. */
3082 unsigned int has_14bit_branch:1;
3083 };
3084
3085 #define ppc64_elf_section_data(sec) \
3086 ((struct _ppc64_elf_section_data *) elf_section_data (sec))
3087
3088 static bfd_boolean
3089 ppc64_elf_new_section_hook (bfd *abfd, asection *sec)
3090 {
3091 if (!sec->used_by_bfd)
3092 {
3093 struct _ppc64_elf_section_data *sdata;
3094 bfd_size_type amt = sizeof (*sdata);
3095
3096 sdata = bfd_zalloc (abfd, amt);
3097 if (sdata == NULL)
3098 return FALSE;
3099 sec->used_by_bfd = sdata;
3100 }
3101
3102 return _bfd_elf_new_section_hook (abfd, sec);
3103 }
3104
3105 static struct _opd_sec_data *
3106 get_opd_info (asection * sec)
3107 {
3108 if (sec != NULL
3109 && ppc64_elf_section_data (sec) != NULL
3110 && ppc64_elf_section_data (sec)->sec_type == sec_opd)
3111 return &ppc64_elf_section_data (sec)->u.opd;
3112 return NULL;
3113 }
3114 \f
3115 /* Parameters for the qsort hook. */
3116 static bfd_boolean synthetic_relocatable;
3117 static asection *synthetic_opd;
3118
3119 /* qsort comparison function for ppc64_elf_get_synthetic_symtab. */
3120
3121 static int
3122 compare_symbols (const void *ap, const void *bp)
3123 {
3124 const asymbol *a = * (const asymbol **) ap;
3125 const asymbol *b = * (const asymbol **) bp;
3126
3127 /* Section symbols first. */
3128 if ((a->flags & BSF_SECTION_SYM) && !(b->flags & BSF_SECTION_SYM))
3129 return -1;
3130 if (!(a->flags & BSF_SECTION_SYM) && (b->flags & BSF_SECTION_SYM))
3131 return 1;
3132
3133 /* then .opd symbols. */
3134 if (synthetic_opd != NULL)
3135 {
3136 if (strcmp (a->section->name, ".opd") == 0
3137 && strcmp (b->section->name, ".opd") != 0)
3138 return -1;
3139 if (strcmp (a->section->name, ".opd") != 0
3140 && strcmp (b->section->name, ".opd") == 0)
3141 return 1;
3142 }
3143
3144 /* then other code symbols. */
3145 if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3146 == (SEC_CODE | SEC_ALLOC)
3147 && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3148 != (SEC_CODE | SEC_ALLOC))
3149 return -1;
3150
3151 if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3152 != (SEC_CODE | SEC_ALLOC)
3153 && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3154 == (SEC_CODE | SEC_ALLOC))
3155 return 1;
3156
3157 if (synthetic_relocatable)
3158 {
3159 if (a->section->id < b->section->id)
3160 return -1;
3161
3162 if (a->section->id > b->section->id)
3163 return 1;
3164 }
3165
3166 if (a->value + a->section->vma < b->value + b->section->vma)
3167 return -1;
3168
3169 if (a->value + a->section->vma > b->value + b->section->vma)
3170 return 1;
3171
3172 /* For syms with the same value, prefer strong dynamic global function
3173 syms over other syms. */
3174 if ((a->flags & BSF_GLOBAL) != 0 && (b->flags & BSF_GLOBAL) == 0)
3175 return -1;
3176
3177 if ((a->flags & BSF_GLOBAL) == 0 && (b->flags & BSF_GLOBAL) != 0)
3178 return 1;
3179
3180 if ((a->flags & BSF_FUNCTION) != 0 && (b->flags & BSF_FUNCTION) == 0)
3181 return -1;
3182
3183 if ((a->flags & BSF_FUNCTION) == 0 && (b->flags & BSF_FUNCTION) != 0)
3184 return 1;
3185
3186 if ((a->flags & BSF_WEAK) == 0 && (b->flags & BSF_WEAK) != 0)
3187 return -1;
3188
3189 if ((a->flags & BSF_WEAK) != 0 && (b->flags & BSF_WEAK) == 0)
3190 return 1;
3191
3192 if ((a->flags & BSF_DYNAMIC) != 0 && (b->flags & BSF_DYNAMIC) == 0)
3193 return -1;
3194
3195 if ((a->flags & BSF_DYNAMIC) == 0 && (b->flags & BSF_DYNAMIC) != 0)
3196 return 1;
3197
3198 return a > b;
3199 }
3200
3201 /* Search SYMS for a symbol of the given VALUE. */
3202
3203 static asymbol *
3204 sym_exists_at (asymbol **syms, long lo, long hi, unsigned int id, bfd_vma value)
3205 {
3206 long mid;
3207
3208 if (id == (unsigned) -1)
3209 {
3210 while (lo < hi)
3211 {
3212 mid = (lo + hi) >> 1;
3213 if (syms[mid]->value + syms[mid]->section->vma < value)
3214 lo = mid + 1;
3215 else if (syms[mid]->value + syms[mid]->section->vma > value)
3216 hi = mid;
3217 else
3218 return syms[mid];
3219 }
3220 }
3221 else
3222 {
3223 while (lo < hi)
3224 {
3225 mid = (lo + hi) >> 1;
3226 if (syms[mid]->section->id < id)
3227 lo = mid + 1;
3228 else if (syms[mid]->section->id > id)
3229 hi = mid;
3230 else if (syms[mid]->value < value)
3231 lo = mid + 1;
3232 else if (syms[mid]->value > value)
3233 hi = mid;
3234 else
3235 return syms[mid];
3236 }
3237 }
3238 return NULL;
3239 }
3240
3241 static bfd_boolean
3242 section_covers_vma (bfd *abfd ATTRIBUTE_UNUSED, asection *section, void *ptr)
3243 {
3244 bfd_vma vma = *(bfd_vma *) ptr;
3245 return ((section->flags & SEC_ALLOC) != 0
3246 && section->vma <= vma
3247 && vma < section->vma + section->size);
3248 }
3249
3250 /* Create synthetic symbols, effectively restoring "dot-symbol" function
3251 entry syms. Also generate @plt symbols for the glink branch table.
3252 Returns count of synthetic symbols in RET or -1 on error. */
3253
3254 static long
3255 ppc64_elf_get_synthetic_symtab (bfd *abfd,
3256 long static_count, asymbol **static_syms,
3257 long dyn_count, asymbol **dyn_syms,
3258 asymbol **ret)
3259 {
3260 asymbol *s;
3261 long i;
3262 long count;
3263 char *names;
3264 long symcount, codesecsym, codesecsymend, secsymend, opdsymend;
3265 asection *opd = NULL;
3266 bfd_boolean relocatable = (abfd->flags & (EXEC_P | DYNAMIC)) == 0;
3267 asymbol **syms;
3268 int abi = abiversion (abfd);
3269
3270 *ret = NULL;
3271
3272 if (abi < 2)
3273 {
3274 opd = bfd_get_section_by_name (abfd, ".opd");
3275 if (opd == NULL && abi == 1)
3276 return 0;
3277 }
3278
3279 syms = NULL;
3280 codesecsym = 0;
3281 codesecsymend = 0;
3282 secsymend = 0;
3283 opdsymend = 0;
3284 symcount = 0;
3285 if (opd != NULL)
3286 {
3287 symcount = static_count;
3288 if (!relocatable)
3289 symcount += dyn_count;
3290 if (symcount == 0)
3291 return 0;
3292
3293 syms = bfd_malloc ((symcount + 1) * sizeof (*syms));
3294 if (syms == NULL)
3295 return -1;
3296
3297 if (!relocatable && static_count != 0 && dyn_count != 0)
3298 {
3299 /* Use both symbol tables. */
3300 memcpy (syms, static_syms, static_count * sizeof (*syms));
3301 memcpy (syms + static_count, dyn_syms,
3302 (dyn_count + 1) * sizeof (*syms));
3303 }
3304 else if (!relocatable && static_count == 0)
3305 memcpy (syms, dyn_syms, (symcount + 1) * sizeof (*syms));
3306 else
3307 memcpy (syms, static_syms, (symcount + 1) * sizeof (*syms));
3308
3309 synthetic_relocatable = relocatable;
3310 synthetic_opd = opd;
3311 qsort (syms, symcount, sizeof (*syms), compare_symbols);
3312
3313 if (!relocatable && symcount > 1)
3314 {
3315 long j;
3316 /* Trim duplicate syms, since we may have merged the normal and
3317 dynamic symbols. Actually, we only care about syms that have
3318 different values, so trim any with the same value. */
3319 for (i = 1, j = 1; i < symcount; ++i)
3320 if (syms[i - 1]->value + syms[i - 1]->section->vma
3321 != syms[i]->value + syms[i]->section->vma)
3322 syms[j++] = syms[i];
3323 symcount = j;
3324 }
3325
3326 i = 0;
3327 /* Note that here and in compare_symbols we can't compare opd and
3328 sym->section directly. With separate debug info files, the
3329 symbols will be extracted from the debug file while abfd passed
3330 to this function is the real binary. */
3331 if (opd != NULL && strcmp (syms[i]->section->name, ".opd") == 0)
3332 ++i;
3333 codesecsym = i;
3334
3335 for (; i < symcount; ++i)
3336 if (((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC
3337 | SEC_THREAD_LOCAL))
3338 != (SEC_CODE | SEC_ALLOC))
3339 || (syms[i]->flags & BSF_SECTION_SYM) == 0)
3340 break;
3341 codesecsymend = i;
3342
3343 for (; i < symcount; ++i)
3344 if ((syms[i]->flags & BSF_SECTION_SYM) == 0)
3345 break;
3346 secsymend = i;
3347
3348 for (; i < symcount; ++i)
3349 if (strcmp (syms[i]->section->name, ".opd") != 0)
3350 break;
3351 opdsymend = i;
3352
3353 for (; i < symcount; ++i)
3354 if ((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3355 != (SEC_CODE | SEC_ALLOC))
3356 break;
3357 symcount = i;
3358 }
3359 count = 0;
3360
3361 if (relocatable)
3362 {
3363 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3364 arelent *r;
3365 size_t size;
3366 long relcount;
3367
3368 if (opdsymend == secsymend)
3369 goto done;
3370
3371 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3372 relcount = (opd->flags & SEC_RELOC) ? opd->reloc_count : 0;
3373 if (relcount == 0)
3374 goto done;
3375
3376 if (!(*slurp_relocs) (abfd, opd, static_syms, FALSE))
3377 {
3378 count = -1;
3379 goto done;
3380 }
3381
3382 size = 0;
3383 for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3384 {
3385 asymbol *sym;
3386
3387 while (r < opd->relocation + relcount
3388 && r->address < syms[i]->value + opd->vma)
3389 ++r;
3390
3391 if (r == opd->relocation + relcount)
3392 break;
3393
3394 if (r->address != syms[i]->value + opd->vma)
3395 continue;
3396
3397 if (r->howto->type != R_PPC64_ADDR64)
3398 continue;
3399
3400 sym = *r->sym_ptr_ptr;
3401 if (!sym_exists_at (syms, opdsymend, symcount,
3402 sym->section->id, sym->value + r->addend))
3403 {
3404 ++count;
3405 size += sizeof (asymbol);
3406 size += strlen (syms[i]->name) + 2;
3407 }
3408 }
3409
3410 if (size == 0)
3411 goto done;
3412 s = *ret = bfd_malloc (size);
3413 if (s == NULL)
3414 {
3415 count = -1;
3416 goto done;
3417 }
3418
3419 names = (char *) (s + count);
3420
3421 for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3422 {
3423 asymbol *sym;
3424
3425 while (r < opd->relocation + relcount
3426 && r->address < syms[i]->value + opd->vma)
3427 ++r;
3428
3429 if (r == opd->relocation + relcount)
3430 break;
3431
3432 if (r->address != syms[i]->value + opd->vma)
3433 continue;
3434
3435 if (r->howto->type != R_PPC64_ADDR64)
3436 continue;
3437
3438 sym = *r->sym_ptr_ptr;
3439 if (!sym_exists_at (syms, opdsymend, symcount,
3440 sym->section->id, sym->value + r->addend))
3441 {
3442 size_t len;
3443
3444 *s = *syms[i];
3445 s->flags |= BSF_SYNTHETIC;
3446 s->section = sym->section;
3447 s->value = sym->value + r->addend;
3448 s->name = names;
3449 *names++ = '.';
3450 len = strlen (syms[i]->name);
3451 memcpy (names, syms[i]->name, len + 1);
3452 names += len + 1;
3453 /* Have udata.p point back to the original symbol this
3454 synthetic symbol was derived from. */
3455 s->udata.p = syms[i];
3456 s++;
3457 }
3458 }
3459 }
3460 else
3461 {
3462 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3463 bfd_byte *contents = NULL;
3464 size_t size;
3465 long plt_count = 0;
3466 bfd_vma glink_vma = 0, resolv_vma = 0;
3467 asection *dynamic, *glink = NULL, *relplt = NULL;
3468 arelent *p;
3469
3470 if (opd != NULL && !bfd_malloc_and_get_section (abfd, opd, &contents))
3471 {
3472 free_contents_and_exit_err:
3473 count = -1;
3474 free_contents_and_exit:
3475 if (contents)
3476 free (contents);
3477 goto done;
3478 }
3479
3480 size = 0;
3481 for (i = secsymend; i < opdsymend; ++i)
3482 {
3483 bfd_vma ent;
3484
3485 /* Ignore bogus symbols. */
3486 if (syms[i]->value > opd->size - 8)
3487 continue;
3488
3489 ent = bfd_get_64 (abfd, contents + syms[i]->value);
3490 if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3491 {
3492 ++count;
3493 size += sizeof (asymbol);
3494 size += strlen (syms[i]->name) + 2;
3495 }
3496 }
3497
3498 /* Get start of .glink stubs from DT_PPC64_GLINK. */
3499 if (dyn_count != 0
3500 && (dynamic = bfd_get_section_by_name (abfd, ".dynamic")) != NULL)
3501 {
3502 bfd_byte *dynbuf, *extdyn, *extdynend;
3503 size_t extdynsize;
3504 void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *);
3505
3506 if (!bfd_malloc_and_get_section (abfd, dynamic, &dynbuf))
3507 goto free_contents_and_exit_err;
3508
3509 extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
3510 swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
3511
3512 extdyn = dynbuf;
3513 extdynend = extdyn + dynamic->size;
3514 for (; extdyn < extdynend; extdyn += extdynsize)
3515 {
3516 Elf_Internal_Dyn dyn;
3517 (*swap_dyn_in) (abfd, extdyn, &dyn);
3518
3519 if (dyn.d_tag == DT_NULL)
3520 break;
3521
3522 if (dyn.d_tag == DT_PPC64_GLINK)
3523 {
3524 /* The first glink stub starts at DT_PPC64_GLINK plus 32.
3525 See comment in ppc64_elf_finish_dynamic_sections. */
3526 glink_vma = dyn.d_un.d_val + 8 * 4;
3527 /* The .glink section usually does not survive the final
3528 link; search for the section (usually .text) where the
3529 glink stubs now reside. */
3530 glink = bfd_sections_find_if (abfd, section_covers_vma,
3531 &glink_vma);
3532 break;
3533 }
3534 }
3535
3536 free (dynbuf);
3537 }
3538
3539 if (glink != NULL)
3540 {
3541 /* Determine __glink trampoline by reading the relative branch
3542 from the first glink stub. */
3543 bfd_byte buf[4];
3544 unsigned int off = 0;
3545
3546 while (bfd_get_section_contents (abfd, glink, buf,
3547 glink_vma + off - glink->vma, 4))
3548 {
3549 unsigned int insn = bfd_get_32 (abfd, buf);
3550 insn ^= B_DOT;
3551 if ((insn & ~0x3fffffc) == 0)
3552 {
3553 resolv_vma = glink_vma + off + (insn ^ 0x2000000) - 0x2000000;
3554 break;
3555 }
3556 off += 4;
3557 if (off > 4)
3558 break;
3559 }
3560
3561 if (resolv_vma)
3562 size += sizeof (asymbol) + sizeof ("__glink_PLTresolve");
3563
3564 relplt = bfd_get_section_by_name (abfd, ".rela.plt");
3565 if (relplt != NULL)
3566 {
3567 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3568 if (! (*slurp_relocs) (abfd, relplt, dyn_syms, TRUE))
3569 goto free_contents_and_exit_err;
3570
3571 plt_count = relplt->size / sizeof (Elf64_External_Rela);
3572 size += plt_count * sizeof (asymbol);
3573
3574 p = relplt->relocation;
3575 for (i = 0; i < plt_count; i++, p++)
3576 {
3577 size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
3578 if (p->addend != 0)
3579 size += sizeof ("+0x") - 1 + 16;
3580 }
3581 }
3582 }
3583
3584 if (size == 0)
3585 goto free_contents_and_exit;
3586 s = *ret = bfd_malloc (size);
3587 if (s == NULL)
3588 goto free_contents_and_exit_err;
3589
3590 names = (char *) (s + count + plt_count + (resolv_vma != 0));
3591
3592 for (i = secsymend; i < opdsymend; ++i)
3593 {
3594 bfd_vma ent;
3595
3596 if (syms[i]->value > opd->size - 8)
3597 continue;
3598
3599 ent = bfd_get_64 (abfd, contents + syms[i]->value);
3600 if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3601 {
3602 long lo, hi;
3603 size_t len;
3604 asection *sec = abfd->sections;
3605
3606 *s = *syms[i];
3607 lo = codesecsym;
3608 hi = codesecsymend;
3609 while (lo < hi)
3610 {
3611 long mid = (lo + hi) >> 1;
3612 if (syms[mid]->section->vma < ent)
3613 lo = mid + 1;
3614 else if (syms[mid]->section->vma > ent)
3615 hi = mid;
3616 else
3617 {
3618 sec = syms[mid]->section;
3619 break;
3620 }
3621 }
3622
3623 if (lo >= hi && lo > codesecsym)
3624 sec = syms[lo - 1]->section;
3625
3626 for (; sec != NULL; sec = sec->next)
3627 {
3628 if (sec->vma > ent)
3629 break;
3630 /* SEC_LOAD may not be set if SEC is from a separate debug
3631 info file. */
3632 if ((sec->flags & SEC_ALLOC) == 0)
3633 break;
3634 if ((sec->flags & SEC_CODE) != 0)
3635 s->section = sec;
3636 }
3637 s->flags |= BSF_SYNTHETIC;
3638 s->value = ent - s->section->vma;
3639 s->name = names;
3640 *names++ = '.';
3641 len = strlen (syms[i]->name);
3642 memcpy (names, syms[i]->name, len + 1);
3643 names += len + 1;
3644 /* Have udata.p point back to the original symbol this
3645 synthetic symbol was derived from. */
3646 s->udata.p = syms[i];
3647 s++;
3648 }
3649 }
3650 free (contents);
3651
3652 if (glink != NULL && relplt != NULL)
3653 {
3654 if (resolv_vma)
3655 {
3656 /* Add a symbol for the main glink trampoline. */
3657 memset (s, 0, sizeof *s);
3658 s->the_bfd = abfd;
3659 s->flags = BSF_GLOBAL | BSF_SYNTHETIC;
3660 s->section = glink;
3661 s->value = resolv_vma - glink->vma;
3662 s->name = names;
3663 memcpy (names, "__glink_PLTresolve", sizeof ("__glink_PLTresolve"));
3664 names += sizeof ("__glink_PLTresolve");
3665 s++;
3666 count++;
3667 }
3668
3669 /* FIXME: It would be very much nicer to put sym@plt on the
3670 stub rather than on the glink branch table entry. The
3671 objdump disassembler would then use a sensible symbol
3672 name on plt calls. The difficulty in doing so is
3673 a) finding the stubs, and,
3674 b) matching stubs against plt entries, and,
3675 c) there can be multiple stubs for a given plt entry.
3676
3677 Solving (a) could be done by code scanning, but older
3678 ppc64 binaries used different stubs to current code.
3679 (b) is the tricky one since you need to known the toc
3680 pointer for at least one function that uses a pic stub to
3681 be able to calculate the plt address referenced.
3682 (c) means gdb would need to set multiple breakpoints (or
3683 find the glink branch itself) when setting breakpoints
3684 for pending shared library loads. */
3685 p = relplt->relocation;
3686 for (i = 0; i < plt_count; i++, p++)
3687 {
3688 size_t len;
3689
3690 *s = **p->sym_ptr_ptr;
3691 /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set. Since
3692 we are defining a symbol, ensure one of them is set. */
3693 if ((s->flags & BSF_LOCAL) == 0)
3694 s->flags |= BSF_GLOBAL;
3695 s->flags |= BSF_SYNTHETIC;
3696 s->section = glink;
3697 s->value = glink_vma - glink->vma;
3698 s->name = names;
3699 s->udata.p = NULL;
3700 len = strlen ((*p->sym_ptr_ptr)->name);
3701 memcpy (names, (*p->sym_ptr_ptr)->name, len);
3702 names += len;
3703 if (p->addend != 0)
3704 {
3705 memcpy (names, "+0x", sizeof ("+0x") - 1);
3706 names += sizeof ("+0x") - 1;
3707 bfd_sprintf_vma (abfd, names, p->addend);
3708 names += strlen (names);
3709 }
3710 memcpy (names, "@plt", sizeof ("@plt"));
3711 names += sizeof ("@plt");
3712 s++;
3713 if (abi < 2)
3714 {
3715 glink_vma += 8;
3716 if (i >= 0x8000)
3717 glink_vma += 4;
3718 }
3719 else
3720 glink_vma += 4;
3721 }
3722 count += plt_count;
3723 }
3724 }
3725
3726 done:
3727 free (syms);
3728 return count;
3729 }
3730 \f
3731 /* The following functions are specific to the ELF linker, while
3732 functions above are used generally. Those named ppc64_elf_* are
3733 called by the main ELF linker code. They appear in this file more
3734 or less in the order in which they are called. eg.
3735 ppc64_elf_check_relocs is called early in the link process,
3736 ppc64_elf_finish_dynamic_sections is one of the last functions
3737 called.
3738
3739 PowerPC64-ELF uses a similar scheme to PowerPC64-XCOFF in that
3740 functions have both a function code symbol and a function descriptor
3741 symbol. A call to foo in a relocatable object file looks like:
3742
3743 . .text
3744 . x:
3745 . bl .foo
3746 . nop
3747
3748 The function definition in another object file might be:
3749
3750 . .section .opd
3751 . foo: .quad .foo
3752 . .quad .TOC.@tocbase
3753 . .quad 0
3754 .
3755 . .text
3756 . .foo: blr
3757
3758 When the linker resolves the call during a static link, the branch
3759 unsurprisingly just goes to .foo and the .opd information is unused.
3760 If the function definition is in a shared library, things are a little
3761 different: The call goes via a plt call stub, the opd information gets
3762 copied to the plt, and the linker patches the nop.
3763
3764 . x:
3765 . bl .foo_stub
3766 . ld 2,40(1)
3767 .
3768 .
3769 . .foo_stub:
3770 . std 2,40(1) # in practice, the call stub
3771 . addis 11,2,Lfoo@toc@ha # is slightly optimized, but
3772 . addi 11,11,Lfoo@toc@l # this is the general idea
3773 . ld 12,0(11)
3774 . ld 2,8(11)
3775 . mtctr 12
3776 . ld 11,16(11)
3777 . bctr
3778 .
3779 . .section .plt
3780 . Lfoo: reloc (R_PPC64_JMP_SLOT, foo)
3781
3782 The "reloc ()" notation is supposed to indicate that the linker emits
3783 an R_PPC64_JMP_SLOT reloc against foo. The dynamic linker does the opd
3784 copying.
3785
3786 What are the difficulties here? Well, firstly, the relocations
3787 examined by the linker in check_relocs are against the function code
3788 sym .foo, while the dynamic relocation in the plt is emitted against
3789 the function descriptor symbol, foo. Somewhere along the line, we need
3790 to carefully copy dynamic link information from one symbol to the other.
3791 Secondly, the generic part of the elf linker will make .foo a dynamic
3792 symbol as is normal for most other backends. We need foo dynamic
3793 instead, at least for an application final link. However, when
3794 creating a shared library containing foo, we need to have both symbols
3795 dynamic so that references to .foo are satisfied during the early
3796 stages of linking. Otherwise the linker might decide to pull in a
3797 definition from some other object, eg. a static library.
3798
3799 Update: As of August 2004, we support a new convention. Function
3800 calls may use the function descriptor symbol, ie. "bl foo". This
3801 behaves exactly as "bl .foo". */
3802
3803 /* Of those relocs that might be copied as dynamic relocs, this
3804 function selects those that must be copied when linking a shared
3805 library or PIE, even when the symbol is local. */
3806
3807 static int
3808 must_be_dyn_reloc (struct bfd_link_info *info,
3809 enum elf_ppc64_reloc_type r_type)
3810 {
3811 switch (r_type)
3812 {
3813 default:
3814 /* Only relative relocs can be resolved when the object load
3815 address isn't fixed. DTPREL64 is excluded because the
3816 dynamic linker needs to differentiate global dynamic from
3817 local dynamic __tls_index pairs when PPC64_OPT_TLS is set. */
3818 return 1;
3819
3820 case R_PPC64_REL32:
3821 case R_PPC64_REL64:
3822 case R_PPC64_REL30:
3823 return 0;
3824
3825 case R_PPC64_TPREL16:
3826 case R_PPC64_TPREL16_LO:
3827 case R_PPC64_TPREL16_HI:
3828 case R_PPC64_TPREL16_HA:
3829 case R_PPC64_TPREL16_DS:
3830 case R_PPC64_TPREL16_LO_DS:
3831 case R_PPC64_TPREL16_HIGH:
3832 case R_PPC64_TPREL16_HIGHA:
3833 case R_PPC64_TPREL16_HIGHER:
3834 case R_PPC64_TPREL16_HIGHERA:
3835 case R_PPC64_TPREL16_HIGHEST:
3836 case R_PPC64_TPREL16_HIGHESTA:
3837 case R_PPC64_TPREL64:
3838 /* These relocations are relative but in a shared library the
3839 linker doesn't know the thread pointer base. */
3840 return bfd_link_dll (info);
3841 }
3842 }
3843
3844 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
3845 copying dynamic variables from a shared lib into an app's dynbss
3846 section, and instead use a dynamic relocation to point into the
3847 shared lib. With code that gcc generates, it's vital that this be
3848 enabled; In the PowerPC64 ABI, the address of a function is actually
3849 the address of a function descriptor, which resides in the .opd
3850 section. gcc uses the descriptor directly rather than going via the
3851 GOT as some other ABI's do, which means that initialized function
3852 pointers must reference the descriptor. Thus, a function pointer
3853 initialized to the address of a function in a shared library will
3854 either require a copy reloc, or a dynamic reloc. Using a copy reloc
3855 redefines the function descriptor symbol to point to the copy. This
3856 presents a problem as a plt entry for that function is also
3857 initialized from the function descriptor symbol and the copy reloc
3858 may not be initialized first. */
3859 #define ELIMINATE_COPY_RELOCS 1
3860
3861 /* Section name for stubs is the associated section name plus this
3862 string. */
3863 #define STUB_SUFFIX ".stub"
3864
3865 /* Linker stubs.
3866 ppc_stub_long_branch:
3867 Used when a 14 bit branch (or even a 24 bit branch) can't reach its
3868 destination, but a 24 bit branch in a stub section will reach.
3869 . b dest
3870
3871 ppc_stub_plt_branch:
3872 Similar to the above, but a 24 bit branch in the stub section won't
3873 reach its destination.
3874 . addis %r11,%r2,xxx@toc@ha
3875 . ld %r12,xxx@toc@l(%r11)
3876 . mtctr %r12
3877 . bctr
3878
3879 ppc_stub_plt_call:
3880 Used to call a function in a shared library. If it so happens that
3881 the plt entry referenced crosses a 64k boundary, then an extra
3882 "addi %r11,%r11,xxx@toc@l" will be inserted before the "mtctr".
3883 . std %r2,40(%r1)
3884 . addis %r11,%r2,xxx@toc@ha
3885 . ld %r12,xxx+0@toc@l(%r11)
3886 . mtctr %r12
3887 . ld %r2,xxx+8@toc@l(%r11)
3888 . ld %r11,xxx+16@toc@l(%r11)
3889 . bctr
3890
3891 ppc_stub_long_branch and ppc_stub_plt_branch may also have additional
3892 code to adjust the value and save r2 to support multiple toc sections.
3893 A ppc_stub_long_branch with an r2 offset looks like:
3894 . std %r2,40(%r1)
3895 . addis %r2,%r2,off@ha
3896 . addi %r2,%r2,off@l
3897 . b dest
3898
3899 A ppc_stub_plt_branch with an r2 offset looks like:
3900 . std %r2,40(%r1)
3901 . addis %r11,%r2,xxx@toc@ha
3902 . ld %r12,xxx@toc@l(%r11)
3903 . addis %r2,%r2,off@ha
3904 . addi %r2,%r2,off@l
3905 . mtctr %r12
3906 . bctr
3907
3908 In cases where the "addis" instruction would add zero, the "addis" is
3909 omitted and following instructions modified slightly in some cases.
3910 */
3911
3912 enum ppc_stub_type {
3913 ppc_stub_none,
3914 ppc_stub_long_branch,
3915 ppc_stub_long_branch_r2off,
3916 ppc_stub_plt_branch,
3917 ppc_stub_plt_branch_r2off,
3918 ppc_stub_plt_call,
3919 ppc_stub_plt_call_r2save,
3920 ppc_stub_global_entry,
3921 ppc_stub_save_res
3922 };
3923
3924 /* Information on stub grouping. */
3925 struct map_stub
3926 {
3927 /* The stub section. */
3928 asection *stub_sec;
3929 /* This is the section to which stubs in the group will be attached. */
3930 asection *link_sec;
3931 /* Next group. */
3932 struct map_stub *next;
3933 /* Whether to emit a copy of register save/restore functions in this
3934 group. */
3935 int needs_save_res;
3936 /* The offset of the __tls_get_addr_opt plt stub bctrl in this group,
3937 or -1u if no such stub with bctrl exists. */
3938 unsigned int tls_get_addr_opt_bctrl;
3939 };
3940
3941 struct ppc_stub_hash_entry {
3942
3943 /* Base hash table entry structure. */
3944 struct bfd_hash_entry root;
3945
3946 enum ppc_stub_type stub_type;
3947
3948 /* Group information. */
3949 struct map_stub *group;
3950
3951 /* Offset within stub_sec of the beginning of this stub. */
3952 bfd_vma stub_offset;
3953
3954 /* Given the symbol's value and its section we can determine its final
3955 value when building the stubs (so the stub knows where to jump. */
3956 bfd_vma target_value;
3957 asection *target_section;
3958
3959 /* The symbol table entry, if any, that this was derived from. */
3960 struct ppc_link_hash_entry *h;
3961 struct plt_entry *plt_ent;
3962
3963 /* Symbol st_other. */
3964 unsigned char other;
3965 };
3966
3967 struct ppc_branch_hash_entry {
3968
3969 /* Base hash table entry structure. */
3970 struct bfd_hash_entry root;
3971
3972 /* Offset within branch lookup table. */
3973 unsigned int offset;
3974
3975 /* Generation marker. */
3976 unsigned int iter;
3977 };
3978
3979 /* Used to track dynamic relocations for local symbols. */
3980 struct ppc_dyn_relocs
3981 {
3982 struct ppc_dyn_relocs *next;
3983
3984 /* The input section of the reloc. */
3985 asection *sec;
3986
3987 /* Total number of relocs copied for the input section. */
3988 unsigned int count : 31;
3989
3990 /* Whether this entry is for STT_GNU_IFUNC symbols. */
3991 unsigned int ifunc : 1;
3992 };
3993
3994 struct ppc_link_hash_entry
3995 {
3996 struct elf_link_hash_entry elf;
3997
3998 union {
3999 /* A pointer to the most recently used stub hash entry against this
4000 symbol. */
4001 struct ppc_stub_hash_entry *stub_cache;
4002
4003 /* A pointer to the next symbol starting with a '.' */
4004 struct ppc_link_hash_entry *next_dot_sym;
4005 } u;
4006
4007 /* Track dynamic relocs copied for this symbol. */
4008 struct elf_dyn_relocs *dyn_relocs;
4009
4010 /* Link between function code and descriptor symbols. */
4011 struct ppc_link_hash_entry *oh;
4012
4013 /* Flag function code and descriptor symbols. */
4014 unsigned int is_func:1;
4015 unsigned int is_func_descriptor:1;
4016 unsigned int fake:1;
4017
4018 /* Whether global opd/toc sym has been adjusted or not.
4019 After ppc64_elf_edit_opd/ppc64_elf_edit_toc has run, this flag
4020 should be set for all globals defined in any opd/toc section. */
4021 unsigned int adjust_done:1;
4022
4023 /* Set if this is an out-of-line register save/restore function,
4024 with non-standard calling convention. */
4025 unsigned int save_res:1;
4026
4027 /* Set if a duplicate symbol with non-zero localentry is detected,
4028 even when the duplicate symbol does not provide a definition. */
4029 unsigned int non_zero_localentry:1;
4030
4031 /* Contexts in which symbol is used in the GOT (or TOC).
4032 TLS_GD .. TLS_EXPLICIT bits are or'd into the mask as the
4033 corresponding relocs are encountered during check_relocs.
4034 tls_optimize clears TLS_GD .. TLS_TPREL when optimizing to
4035 indicate the corresponding GOT entry type is not needed.
4036 tls_optimize may also set TLS_TPRELGD when a GD reloc turns into
4037 a TPREL one. We use a separate flag rather than setting TPREL
4038 just for convenience in distinguishing the two cases. */
4039 #define TLS_GD 1 /* GD reloc. */
4040 #define TLS_LD 2 /* LD reloc. */
4041 #define TLS_TPREL 4 /* TPREL reloc, => IE. */
4042 #define TLS_DTPREL 8 /* DTPREL reloc, => LD. */
4043 #define TLS_TLS 16 /* Any TLS reloc. */
4044 #define TLS_EXPLICIT 32 /* Marks TOC section TLS relocs. */
4045 #define TLS_TPRELGD 64 /* TPREL reloc resulting from GD->IE. */
4046 #define PLT_IFUNC 128 /* STT_GNU_IFUNC. */
4047 unsigned char tls_mask;
4048 };
4049
4050 /* ppc64 ELF linker hash table. */
4051
4052 struct ppc_link_hash_table
4053 {
4054 struct elf_link_hash_table elf;
4055
4056 /* The stub hash table. */
4057 struct bfd_hash_table stub_hash_table;
4058
4059 /* Another hash table for plt_branch stubs. */
4060 struct bfd_hash_table branch_hash_table;
4061
4062 /* Hash table for function prologue tocsave. */
4063 htab_t tocsave_htab;
4064
4065 /* Various options and other info passed from the linker. */
4066 struct ppc64_elf_params *params;
4067
4068 /* The size of sec_info below. */
4069 unsigned int sec_info_arr_size;
4070
4071 /* Per-section array of extra section info. Done this way rather
4072 than as part of ppc64_elf_section_data so we have the info for
4073 non-ppc64 sections. */
4074 struct
4075 {
4076 /* Along with elf_gp, specifies the TOC pointer used by this section. */
4077 bfd_vma toc_off;
4078
4079 union
4080 {
4081 /* The section group that this section belongs to. */
4082 struct map_stub *group;
4083 /* A temp section list pointer. */
4084 asection *list;
4085 } u;
4086 } *sec_info;
4087
4088 /* Linked list of groups. */
4089 struct map_stub *group;
4090
4091 /* Temp used when calculating TOC pointers. */
4092 bfd_vma toc_curr;
4093 bfd *toc_bfd;
4094 asection *toc_first_sec;
4095
4096 /* Used when adding symbols. */
4097 struct ppc_link_hash_entry *dot_syms;
4098
4099 /* Shortcuts to get to dynamic linker sections. */
4100 asection *glink;
4101 asection *global_entry;
4102 asection *sfpr;
4103 asection *brlt;
4104 asection *relbrlt;
4105 asection *glink_eh_frame;
4106
4107 /* Shortcut to .__tls_get_addr and __tls_get_addr. */
4108 struct ppc_link_hash_entry *tls_get_addr;
4109 struct ppc_link_hash_entry *tls_get_addr_fd;
4110
4111 /* The size of reliplt used by got entry relocs. */
4112 bfd_size_type got_reli_size;
4113
4114 /* Statistics. */
4115 unsigned long stub_count[ppc_stub_global_entry];
4116
4117 /* Number of stubs against global syms. */
4118 unsigned long stub_globals;
4119
4120 /* Set if we're linking code with function descriptors. */
4121 unsigned int opd_abi:1;
4122
4123 /* Support for multiple toc sections. */
4124 unsigned int do_multi_toc:1;
4125 unsigned int multi_toc_needed:1;
4126 unsigned int second_toc_pass:1;
4127 unsigned int do_toc_opt:1;
4128
4129 /* Set if tls optimization is enabled. */
4130 unsigned int do_tls_opt:1;
4131
4132 /* Set on error. */
4133 unsigned int stub_error:1;
4134
4135 /* Whether func_desc_adjust needs to be run over symbols. */
4136 unsigned int need_func_desc_adj:1;
4137
4138 /* Whether there exist local gnu indirect function resolvers,
4139 referenced by dynamic relocations. */
4140 unsigned int local_ifunc_resolver:1;
4141 unsigned int maybe_local_ifunc_resolver:1;
4142
4143 /* Whether plt calls for ELFv2 localentry:0 funcs have been optimized. */
4144 unsigned int has_plt_localentry0:1;
4145
4146 /* Incremented every time we size stubs. */
4147 unsigned int stub_iteration;
4148
4149 /* Small local sym cache. */
4150 struct sym_cache sym_cache;
4151 };
4152
4153 /* Rename some of the generic section flags to better document how they
4154 are used here. */
4155
4156 /* Nonzero if this section has TLS related relocations. */
4157 #define has_tls_reloc sec_flg0
4158
4159 /* Nonzero if this section has a call to __tls_get_addr. */
4160 #define has_tls_get_addr_call sec_flg1
4161
4162 /* Nonzero if this section has any toc or got relocs. */
4163 #define has_toc_reloc sec_flg2
4164
4165 /* Nonzero if this section has a call to another section that uses
4166 the toc or got. */
4167 #define makes_toc_func_call sec_flg3
4168
4169 /* Recursion protection when determining above flag. */
4170 #define call_check_in_progress sec_flg4
4171 #define call_check_done sec_flg5
4172
4173 /* Get the ppc64 ELF linker hash table from a link_info structure. */
4174
4175 #define ppc_hash_table(p) \
4176 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
4177 == PPC64_ELF_DATA ? ((struct ppc_link_hash_table *) ((p)->hash)) : NULL)
4178
4179 #define ppc_stub_hash_lookup(table, string, create, copy) \
4180 ((struct ppc_stub_hash_entry *) \
4181 bfd_hash_lookup ((table), (string), (create), (copy)))
4182
4183 #define ppc_branch_hash_lookup(table, string, create, copy) \
4184 ((struct ppc_branch_hash_entry *) \
4185 bfd_hash_lookup ((table), (string), (create), (copy)))
4186
4187 /* Create an entry in the stub hash table. */
4188
4189 static struct bfd_hash_entry *
4190 stub_hash_newfunc (struct bfd_hash_entry *entry,
4191 struct bfd_hash_table *table,
4192 const char *string)
4193 {
4194 /* Allocate the structure if it has not already been allocated by a
4195 subclass. */
4196 if (entry == NULL)
4197 {
4198 entry = bfd_hash_allocate (table, sizeof (struct ppc_stub_hash_entry));
4199 if (entry == NULL)
4200 return entry;
4201 }
4202
4203 /* Call the allocation method of the superclass. */
4204 entry = bfd_hash_newfunc (entry, table, string);
4205 if (entry != NULL)
4206 {
4207 struct ppc_stub_hash_entry *eh;
4208
4209 /* Initialize the local fields. */
4210 eh = (struct ppc_stub_hash_entry *) entry;
4211 eh->stub_type = ppc_stub_none;
4212 eh->group = NULL;
4213 eh->stub_offset = 0;
4214 eh->target_value = 0;
4215 eh->target_section = NULL;
4216 eh->h = NULL;
4217 eh->plt_ent = NULL;
4218 eh->other = 0;
4219 }
4220
4221 return entry;
4222 }
4223
4224 /* Create an entry in the branch hash table. */
4225
4226 static struct bfd_hash_entry *
4227 branch_hash_newfunc (struct bfd_hash_entry *entry,
4228 struct bfd_hash_table *table,
4229 const char *string)
4230 {
4231 /* Allocate the structure if it has not already been allocated by a
4232 subclass. */
4233 if (entry == NULL)
4234 {
4235 entry = bfd_hash_allocate (table, sizeof (struct ppc_branch_hash_entry));
4236 if (entry == NULL)
4237 return entry;
4238 }
4239
4240 /* Call the allocation method of the superclass. */
4241 entry = bfd_hash_newfunc (entry, table, string);
4242 if (entry != NULL)
4243 {
4244 struct ppc_branch_hash_entry *eh;
4245
4246 /* Initialize the local fields. */
4247 eh = (struct ppc_branch_hash_entry *) entry;
4248 eh->offset = 0;
4249 eh->iter = 0;
4250 }
4251
4252 return entry;
4253 }
4254
4255 /* Create an entry in a ppc64 ELF linker hash table. */
4256
4257 static struct bfd_hash_entry *
4258 link_hash_newfunc (struct bfd_hash_entry *entry,
4259 struct bfd_hash_table *table,
4260 const char *string)
4261 {
4262 /* Allocate the structure if it has not already been allocated by a
4263 subclass. */
4264 if (entry == NULL)
4265 {
4266 entry = bfd_hash_allocate (table, sizeof (struct ppc_link_hash_entry));
4267 if (entry == NULL)
4268 return entry;
4269 }
4270
4271 /* Call the allocation method of the superclass. */
4272 entry = _bfd_elf_link_hash_newfunc (entry, table, string);
4273 if (entry != NULL)
4274 {
4275 struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) entry;
4276
4277 memset (&eh->u.stub_cache, 0,
4278 (sizeof (struct ppc_link_hash_entry)
4279 - offsetof (struct ppc_link_hash_entry, u.stub_cache)));
4280
4281 /* When making function calls, old ABI code references function entry
4282 points (dot symbols), while new ABI code references the function
4283 descriptor symbol. We need to make any combination of reference and
4284 definition work together, without breaking archive linking.
4285
4286 For a defined function "foo" and an undefined call to "bar":
4287 An old object defines "foo" and ".foo", references ".bar" (possibly
4288 "bar" too).
4289 A new object defines "foo" and references "bar".
4290
4291 A new object thus has no problem with its undefined symbols being
4292 satisfied by definitions in an old object. On the other hand, the
4293 old object won't have ".bar" satisfied by a new object.
4294
4295 Keep a list of newly added dot-symbols. */
4296
4297 if (string[0] == '.')
4298 {
4299 struct ppc_link_hash_table *htab;
4300
4301 htab = (struct ppc_link_hash_table *) table;
4302 eh->u.next_dot_sym = htab->dot_syms;
4303 htab->dot_syms = eh;
4304 }
4305 }
4306
4307 return entry;
4308 }
4309
4310 struct tocsave_entry {
4311 asection *sec;
4312 bfd_vma offset;
4313 };
4314
4315 static hashval_t
4316 tocsave_htab_hash (const void *p)
4317 {
4318 const struct tocsave_entry *e = (const struct tocsave_entry *) p;
4319 return ((bfd_vma) (intptr_t) e->sec ^ e->offset) >> 3;
4320 }
4321
4322 static int
4323 tocsave_htab_eq (const void *p1, const void *p2)
4324 {
4325 const struct tocsave_entry *e1 = (const struct tocsave_entry *) p1;
4326 const struct tocsave_entry *e2 = (const struct tocsave_entry *) p2;
4327 return e1->sec == e2->sec && e1->offset == e2->offset;
4328 }
4329
4330 /* Destroy a ppc64 ELF linker hash table. */
4331
4332 static void
4333 ppc64_elf_link_hash_table_free (bfd *obfd)
4334 {
4335 struct ppc_link_hash_table *htab;
4336
4337 htab = (struct ppc_link_hash_table *) obfd->link.hash;
4338 if (htab->tocsave_htab)
4339 htab_delete (htab->tocsave_htab);
4340 bfd_hash_table_free (&htab->branch_hash_table);
4341 bfd_hash_table_free (&htab->stub_hash_table);
4342 _bfd_elf_link_hash_table_free (obfd);
4343 }
4344
4345 /* Create a ppc64 ELF linker hash table. */
4346
4347 static struct bfd_link_hash_table *
4348 ppc64_elf_link_hash_table_create (bfd *abfd)
4349 {
4350 struct ppc_link_hash_table *htab;
4351 bfd_size_type amt = sizeof (struct ppc_link_hash_table);
4352
4353 htab = bfd_zmalloc (amt);
4354 if (htab == NULL)
4355 return NULL;
4356
4357 if (!_bfd_elf_link_hash_table_init (&htab->elf, abfd, link_hash_newfunc,
4358 sizeof (struct ppc_link_hash_entry),
4359 PPC64_ELF_DATA))
4360 {
4361 free (htab);
4362 return NULL;
4363 }
4364
4365 /* Init the stub hash table too. */
4366 if (!bfd_hash_table_init (&htab->stub_hash_table, stub_hash_newfunc,
4367 sizeof (struct ppc_stub_hash_entry)))
4368 {
4369 _bfd_elf_link_hash_table_free (abfd);
4370 return NULL;
4371 }
4372
4373 /* And the branch hash table. */
4374 if (!bfd_hash_table_init (&htab->branch_hash_table, branch_hash_newfunc,
4375 sizeof (struct ppc_branch_hash_entry)))
4376 {
4377 bfd_hash_table_free (&htab->stub_hash_table);
4378 _bfd_elf_link_hash_table_free (abfd);
4379 return NULL;
4380 }
4381
4382 htab->tocsave_htab = htab_try_create (1024,
4383 tocsave_htab_hash,
4384 tocsave_htab_eq,
4385 NULL);
4386 if (htab->tocsave_htab == NULL)
4387 {
4388 ppc64_elf_link_hash_table_free (abfd);
4389 return NULL;
4390 }
4391 htab->elf.root.hash_table_free = ppc64_elf_link_hash_table_free;
4392
4393 /* Initializing two fields of the union is just cosmetic. We really
4394 only care about glist, but when compiled on a 32-bit host the
4395 bfd_vma fields are larger. Setting the bfd_vma to zero makes
4396 debugger inspection of these fields look nicer. */
4397 htab->elf.init_got_refcount.refcount = 0;
4398 htab->elf.init_got_refcount.glist = NULL;
4399 htab->elf.init_plt_refcount.refcount = 0;
4400 htab->elf.init_plt_refcount.glist = NULL;
4401 htab->elf.init_got_offset.offset = 0;
4402 htab->elf.init_got_offset.glist = NULL;
4403 htab->elf.init_plt_offset.offset = 0;
4404 htab->elf.init_plt_offset.glist = NULL;
4405
4406 return &htab->elf.root;
4407 }
4408
4409 /* Create sections for linker generated code. */
4410
4411 static bfd_boolean
4412 create_linkage_sections (bfd *dynobj, struct bfd_link_info *info)
4413 {
4414 struct ppc_link_hash_table *htab;
4415 flagword flags;
4416
4417 htab = ppc_hash_table (info);
4418
4419 flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY
4420 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4421 if (htab->params->save_restore_funcs)
4422 {
4423 /* Create .sfpr for code to save and restore fp regs. */
4424 htab->sfpr = bfd_make_section_anyway_with_flags (dynobj, ".sfpr",
4425 flags);
4426 if (htab->sfpr == NULL
4427 || ! bfd_set_section_alignment (dynobj, htab->sfpr, 2))
4428 return FALSE;
4429 }
4430
4431 if (bfd_link_relocatable (info))
4432 return TRUE;
4433
4434 /* Create .glink for lazy dynamic linking support. */
4435 htab->glink = bfd_make_section_anyway_with_flags (dynobj, ".glink",
4436 flags);
4437 if (htab->glink == NULL
4438 || ! bfd_set_section_alignment (dynobj, htab->glink, 3))
4439 return FALSE;
4440
4441 /* The part of .glink used by global entry stubs, separate so that
4442 it can be aligned appropriately without affecting htab->glink. */
4443 htab->global_entry = bfd_make_section_anyway_with_flags (dynobj, ".glink",
4444 flags);
4445 if (htab->global_entry == NULL
4446 || ! bfd_set_section_alignment (dynobj, htab->global_entry, 2))
4447 return FALSE;
4448
4449 if (!info->no_ld_generated_unwind_info)
4450 {
4451 flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_HAS_CONTENTS
4452 | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4453 htab->glink_eh_frame = bfd_make_section_anyway_with_flags (dynobj,
4454 ".eh_frame",
4455 flags);
4456 if (htab->glink_eh_frame == NULL
4457 || !bfd_set_section_alignment (dynobj, htab->glink_eh_frame, 2))
4458 return FALSE;
4459 }
4460
4461 flags = SEC_ALLOC | SEC_LINKER_CREATED;
4462 htab->elf.iplt = bfd_make_section_anyway_with_flags (dynobj, ".iplt", flags);
4463 if (htab->elf.iplt == NULL
4464 || ! bfd_set_section_alignment (dynobj, htab->elf.iplt, 3))
4465 return FALSE;
4466
4467 flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4468 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4469 htab->elf.irelplt
4470 = bfd_make_section_anyway_with_flags (dynobj, ".rela.iplt", flags);
4471 if (htab->elf.irelplt == NULL
4472 || ! bfd_set_section_alignment (dynobj, htab->elf.irelplt, 3))
4473 return FALSE;
4474
4475 /* Create branch lookup table for plt_branch stubs. */
4476 flags = (SEC_ALLOC | SEC_LOAD
4477 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4478 htab->brlt = bfd_make_section_anyway_with_flags (dynobj, ".branch_lt",
4479 flags);
4480 if (htab->brlt == NULL
4481 || ! bfd_set_section_alignment (dynobj, htab->brlt, 3))
4482 return FALSE;
4483
4484 if (!bfd_link_pic (info))
4485 return TRUE;
4486
4487 flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4488 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4489 htab->relbrlt = bfd_make_section_anyway_with_flags (dynobj,
4490 ".rela.branch_lt",
4491 flags);
4492 if (htab->relbrlt == NULL
4493 || ! bfd_set_section_alignment (dynobj, htab->relbrlt, 3))
4494 return FALSE;
4495
4496 return TRUE;
4497 }
4498
4499 /* Satisfy the ELF linker by filling in some fields in our fake bfd. */
4500
4501 bfd_boolean
4502 ppc64_elf_init_stub_bfd (struct bfd_link_info *info,
4503 struct ppc64_elf_params *params)
4504 {
4505 struct ppc_link_hash_table *htab;
4506
4507 elf_elfheader (params->stub_bfd)->e_ident[EI_CLASS] = ELFCLASS64;
4508
4509 /* Always hook our dynamic sections into the first bfd, which is the
4510 linker created stub bfd. This ensures that the GOT header is at
4511 the start of the output TOC section. */
4512 htab = ppc_hash_table (info);
4513 htab->elf.dynobj = params->stub_bfd;
4514 htab->params = params;
4515
4516 return create_linkage_sections (htab->elf.dynobj, info);
4517 }
4518
4519 /* Build a name for an entry in the stub hash table. */
4520
4521 static char *
4522 ppc_stub_name (const asection *input_section,
4523 const asection *sym_sec,
4524 const struct ppc_link_hash_entry *h,
4525 const Elf_Internal_Rela *rel)
4526 {
4527 char *stub_name;
4528 ssize_t len;
4529
4530 /* rel->r_addend is actually 64 bit, but who uses more than +/- 2^31
4531 offsets from a sym as a branch target? In fact, we could
4532 probably assume the addend is always zero. */
4533 BFD_ASSERT (((int) rel->r_addend & 0xffffffff) == rel->r_addend);
4534
4535 if (h)
4536 {
4537 len = 8 + 1 + strlen (h->elf.root.root.string) + 1 + 8 + 1;
4538 stub_name = bfd_malloc (len);
4539 if (stub_name == NULL)
4540 return stub_name;
4541
4542 len = sprintf (stub_name, "%08x.%s+%x",
4543 input_section->id & 0xffffffff,
4544 h->elf.root.root.string,
4545 (int) rel->r_addend & 0xffffffff);
4546 }
4547 else
4548 {
4549 len = 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1;
4550 stub_name = bfd_malloc (len);
4551 if (stub_name == NULL)
4552 return stub_name;
4553
4554 len = sprintf (stub_name, "%08x.%x:%x+%x",
4555 input_section->id & 0xffffffff,
4556 sym_sec->id & 0xffffffff,
4557 (int) ELF64_R_SYM (rel->r_info) & 0xffffffff,
4558 (int) rel->r_addend & 0xffffffff);
4559 }
4560 if (len > 2 && stub_name[len - 2] == '+' && stub_name[len - 1] == '0')
4561 stub_name[len - 2] = 0;
4562 return stub_name;
4563 }
4564
4565 /* Look up an entry in the stub hash. Stub entries are cached because
4566 creating the stub name takes a bit of time. */
4567
4568 static struct ppc_stub_hash_entry *
4569 ppc_get_stub_entry (const asection *input_section,
4570 const asection *sym_sec,
4571 struct ppc_link_hash_entry *h,
4572 const Elf_Internal_Rela *rel,
4573 struct ppc_link_hash_table *htab)
4574 {
4575 struct ppc_stub_hash_entry *stub_entry;
4576 struct map_stub *group;
4577
4578 /* If this input section is part of a group of sections sharing one
4579 stub section, then use the id of the first section in the group.
4580 Stub names need to include a section id, as there may well be
4581 more than one stub used to reach say, printf, and we need to
4582 distinguish between them. */
4583 group = htab->sec_info[input_section->id].u.group;
4584 if (group == NULL)
4585 return NULL;
4586
4587 if (h != NULL && h->u.stub_cache != NULL
4588 && h->u.stub_cache->h == h
4589 && h->u.stub_cache->group == group)
4590 {
4591 stub_entry = h->u.stub_cache;
4592 }
4593 else
4594 {
4595 char *stub_name;
4596
4597 stub_name = ppc_stub_name (group->link_sec, sym_sec, h, rel);
4598 if (stub_name == NULL)
4599 return NULL;
4600
4601 stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
4602 stub_name, FALSE, FALSE);
4603 if (h != NULL)
4604 h->u.stub_cache = stub_entry;
4605
4606 free (stub_name);
4607 }
4608
4609 return stub_entry;
4610 }
4611
4612 /* Add a new stub entry to the stub hash. Not all fields of the new
4613 stub entry are initialised. */
4614
4615 static struct ppc_stub_hash_entry *
4616 ppc_add_stub (const char *stub_name,
4617 asection *section,
4618 struct bfd_link_info *info)
4619 {
4620 struct ppc_link_hash_table *htab = ppc_hash_table (info);
4621 struct map_stub *group;
4622 asection *link_sec;
4623 asection *stub_sec;
4624 struct ppc_stub_hash_entry *stub_entry;
4625
4626 group = htab->sec_info[section->id].u.group;
4627 link_sec = group->link_sec;
4628 stub_sec = group->stub_sec;
4629 if (stub_sec == NULL)
4630 {
4631 size_t namelen;
4632 bfd_size_type len;
4633 char *s_name;
4634
4635 namelen = strlen (link_sec->name);
4636 len = namelen + sizeof (STUB_SUFFIX);
4637 s_name = bfd_alloc (htab->params->stub_bfd, len);
4638 if (s_name == NULL)
4639 return NULL;
4640
4641 memcpy (s_name, link_sec->name, namelen);
4642 memcpy (s_name + namelen, STUB_SUFFIX, sizeof (STUB_SUFFIX));
4643 stub_sec = (*htab->params->add_stub_section) (s_name, link_sec);
4644 if (stub_sec == NULL)
4645 return NULL;
4646 group->stub_sec = stub_sec;
4647 }
4648
4649 /* Enter this entry into the linker stub hash table. */
4650 stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table, stub_name,
4651 TRUE, FALSE);
4652 if (stub_entry == NULL)
4653 {
4654 /* xgettext:c-format */
4655 info->callbacks->einfo (_("%P: %B: cannot create stub entry %s\n"),
4656 section->owner, stub_name);
4657 return NULL;
4658 }
4659
4660 stub_entry->group = group;
4661 stub_entry->stub_offset = 0;
4662 return stub_entry;
4663 }
4664
4665 /* Create .got and .rela.got sections in ABFD, and .got in dynobj if
4666 not already done. */
4667
4668 static bfd_boolean
4669 create_got_section (bfd *abfd, struct bfd_link_info *info)
4670 {
4671 asection *got, *relgot;
4672 flagword flags;
4673 struct ppc_link_hash_table *htab = ppc_hash_table (info);
4674
4675 if (!is_ppc64_elf (abfd))
4676 return FALSE;
4677 if (htab == NULL)
4678 return FALSE;
4679
4680 if (!htab->elf.sgot
4681 && !_bfd_elf_create_got_section (htab->elf.dynobj, info))
4682 return FALSE;
4683
4684 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
4685 | SEC_LINKER_CREATED);
4686
4687 got = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
4688 if (!got
4689 || !bfd_set_section_alignment (abfd, got, 3))
4690 return FALSE;
4691
4692 relgot = bfd_make_section_anyway_with_flags (abfd, ".rela.got",
4693 flags | SEC_READONLY);
4694 if (!relgot
4695 || ! bfd_set_section_alignment (abfd, relgot, 3))
4696 return FALSE;
4697
4698 ppc64_elf_tdata (abfd)->got = got;
4699 ppc64_elf_tdata (abfd)->relgot = relgot;
4700 return TRUE;
4701 }
4702
4703 /* Follow indirect and warning symbol links. */
4704
4705 static inline struct bfd_link_hash_entry *
4706 follow_link (struct bfd_link_hash_entry *h)
4707 {
4708 while (h->type == bfd_link_hash_indirect
4709 || h->type == bfd_link_hash_warning)
4710 h = h->u.i.link;
4711 return h;
4712 }
4713
4714 static inline struct elf_link_hash_entry *
4715 elf_follow_link (struct elf_link_hash_entry *h)
4716 {
4717 return (struct elf_link_hash_entry *) follow_link (&h->root);
4718 }
4719
4720 static inline struct ppc_link_hash_entry *
4721 ppc_follow_link (struct ppc_link_hash_entry *h)
4722 {
4723 return (struct ppc_link_hash_entry *) follow_link (&h->elf.root);
4724 }
4725
4726 /* Merge PLT info on FROM with that on TO. */
4727
4728 static void
4729 move_plt_plist (struct ppc_link_hash_entry *from,
4730 struct ppc_link_hash_entry *to)
4731 {
4732 if (from->elf.plt.plist != NULL)
4733 {
4734 if (to->elf.plt.plist != NULL)
4735 {
4736 struct plt_entry **entp;
4737 struct plt_entry *ent;
4738
4739 for (entp = &from->elf.plt.plist; (ent = *entp) != NULL; )
4740 {
4741 struct plt_entry *dent;
4742
4743 for (dent = to->elf.plt.plist; dent != NULL; dent = dent->next)
4744 if (dent->addend == ent->addend)
4745 {
4746 dent->plt.refcount += ent->plt.refcount;
4747 *entp = ent->next;
4748 break;
4749 }
4750 if (dent == NULL)
4751 entp = &ent->next;
4752 }
4753 *entp = to->elf.plt.plist;
4754 }
4755
4756 to->elf.plt.plist = from->elf.plt.plist;
4757 from->elf.plt.plist = NULL;
4758 }
4759 }
4760
4761 /* Copy the extra info we tack onto an elf_link_hash_entry. */
4762
4763 static void
4764 ppc64_elf_copy_indirect_symbol (struct bfd_link_info *info,
4765 struct elf_link_hash_entry *dir,
4766 struct elf_link_hash_entry *ind)
4767 {
4768 struct ppc_link_hash_entry *edir, *eind;
4769
4770 edir = (struct ppc_link_hash_entry *) dir;
4771 eind = (struct ppc_link_hash_entry *) ind;
4772
4773 edir->is_func |= eind->is_func;
4774 edir->is_func_descriptor |= eind->is_func_descriptor;
4775 edir->tls_mask |= eind->tls_mask;
4776 if (eind->oh != NULL)
4777 edir->oh = ppc_follow_link (eind->oh);
4778
4779 if (edir->elf.versioned != versioned_hidden)
4780 edir->elf.ref_dynamic |= eind->elf.ref_dynamic;
4781 edir->elf.ref_regular |= eind->elf.ref_regular;
4782 edir->elf.ref_regular_nonweak |= eind->elf.ref_regular_nonweak;
4783 edir->elf.non_got_ref |= eind->elf.non_got_ref;
4784 edir->elf.needs_plt |= eind->elf.needs_plt;
4785 edir->elf.pointer_equality_needed |= eind->elf.pointer_equality_needed;
4786
4787 /* If we were called to copy over info for a weak sym, don't copy
4788 dyn_relocs, plt/got info, or dynindx. We used to copy dyn_relocs
4789 in order to simplify readonly_dynrelocs and save a field in the
4790 symbol hash entry, but that means dyn_relocs can't be used in any
4791 tests about a specific symbol, or affect other symbol flags which
4792 are then tested. */
4793 if (eind->elf.root.type != bfd_link_hash_indirect)
4794 return;
4795
4796 /* Copy over any dynamic relocs we may have on the indirect sym. */
4797 if (eind->dyn_relocs != NULL)
4798 {
4799 if (edir->dyn_relocs != NULL)
4800 {
4801 struct elf_dyn_relocs **pp;
4802 struct elf_dyn_relocs *p;
4803
4804 /* Add reloc counts against the indirect sym to the direct sym
4805 list. Merge any entries against the same section. */
4806 for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
4807 {
4808 struct elf_dyn_relocs *q;
4809
4810 for (q = edir->dyn_relocs; q != NULL; q = q->next)
4811 if (q->sec == p->sec)
4812 {
4813 q->pc_count += p->pc_count;
4814 q->count += p->count;
4815 *pp = p->next;
4816 break;
4817 }
4818 if (q == NULL)
4819 pp = &p->next;
4820 }
4821 *pp = edir->dyn_relocs;
4822 }
4823
4824 edir->dyn_relocs = eind->dyn_relocs;
4825 eind->dyn_relocs = NULL;
4826 }
4827
4828 /* Copy over got entries that we may have already seen to the
4829 symbol which just became indirect. */
4830 if (eind->elf.got.glist != NULL)
4831 {
4832 if (edir->elf.got.glist != NULL)
4833 {
4834 struct got_entry **entp;
4835 struct got_entry *ent;
4836
4837 for (entp = &eind->elf.got.glist; (ent = *entp) != NULL; )
4838 {
4839 struct got_entry *dent;
4840
4841 for (dent = edir->elf.got.glist; dent != NULL; dent = dent->next)
4842 if (dent->addend == ent->addend
4843 && dent->owner == ent->owner
4844 && dent->tls_type == ent->tls_type)
4845 {
4846 dent->got.refcount += ent->got.refcount;
4847 *entp = ent->next;
4848 break;
4849 }
4850 if (dent == NULL)
4851 entp = &ent->next;
4852 }
4853 *entp = edir->elf.got.glist;
4854 }
4855
4856 edir->elf.got.glist = eind->elf.got.glist;
4857 eind->elf.got.glist = NULL;
4858 }
4859
4860 /* And plt entries. */
4861 move_plt_plist (eind, edir);
4862
4863 if (eind->elf.dynindx != -1)
4864 {
4865 if (edir->elf.dynindx != -1)
4866 _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
4867 edir->elf.dynstr_index);
4868 edir->elf.dynindx = eind->elf.dynindx;
4869 edir->elf.dynstr_index = eind->elf.dynstr_index;
4870 eind->elf.dynindx = -1;
4871 eind->elf.dynstr_index = 0;
4872 }
4873 }
4874
4875 /* Find the function descriptor hash entry from the given function code
4876 hash entry FH. Link the entries via their OH fields. */
4877
4878 static struct ppc_link_hash_entry *
4879 lookup_fdh (struct ppc_link_hash_entry *fh, struct ppc_link_hash_table *htab)
4880 {
4881 struct ppc_link_hash_entry *fdh = fh->oh;
4882
4883 if (fdh == NULL)
4884 {
4885 const char *fd_name = fh->elf.root.root.string + 1;
4886
4887 fdh = (struct ppc_link_hash_entry *)
4888 elf_link_hash_lookup (&htab->elf, fd_name, FALSE, FALSE, FALSE);
4889 if (fdh == NULL)
4890 return fdh;
4891
4892 fdh->is_func_descriptor = 1;
4893 fdh->oh = fh;
4894 fh->is_func = 1;
4895 fh->oh = fdh;
4896 }
4897
4898 fdh = ppc_follow_link (fdh);
4899 fdh->is_func_descriptor = 1;
4900 fdh->oh = fh;
4901 return fdh;
4902 }
4903
4904 /* Make a fake function descriptor sym for the undefined code sym FH. */
4905
4906 static struct ppc_link_hash_entry *
4907 make_fdh (struct bfd_link_info *info,
4908 struct ppc_link_hash_entry *fh)
4909 {
4910 bfd *abfd = fh->elf.root.u.undef.abfd;
4911 struct bfd_link_hash_entry *bh = NULL;
4912 struct ppc_link_hash_entry *fdh;
4913 flagword flags = (fh->elf.root.type == bfd_link_hash_undefweak
4914 ? BSF_WEAK
4915 : BSF_GLOBAL);
4916
4917 if (!_bfd_generic_link_add_one_symbol (info, abfd,
4918 fh->elf.root.root.string + 1,
4919 flags, bfd_und_section_ptr, 0,
4920 NULL, FALSE, FALSE, &bh))
4921 return NULL;
4922
4923 fdh = (struct ppc_link_hash_entry *) bh;
4924 fdh->elf.non_elf = 0;
4925 fdh->fake = 1;
4926 fdh->is_func_descriptor = 1;
4927 fdh->oh = fh;
4928 fh->is_func = 1;
4929 fh->oh = fdh;
4930 return fdh;
4931 }
4932
4933 /* Fix function descriptor symbols defined in .opd sections to be
4934 function type. */
4935
4936 static bfd_boolean
4937 ppc64_elf_add_symbol_hook (bfd *ibfd,
4938 struct bfd_link_info *info,
4939 Elf_Internal_Sym *isym,
4940 const char **name,
4941 flagword *flags ATTRIBUTE_UNUSED,
4942 asection **sec,
4943 bfd_vma *value)
4944 {
4945 if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC
4946 && (ibfd->flags & DYNAMIC) == 0
4947 && bfd_get_flavour (info->output_bfd) == bfd_target_elf_flavour)
4948 elf_tdata (info->output_bfd)->has_gnu_symbols |= elf_gnu_symbol_ifunc;
4949
4950 if (*sec != NULL
4951 && strcmp ((*sec)->name, ".opd") == 0)
4952 {
4953 asection *code_sec;
4954
4955 if (!(ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC
4956 || ELF_ST_TYPE (isym->st_info) == STT_FUNC))
4957 isym->st_info = ELF_ST_INFO (ELF_ST_BIND (isym->st_info), STT_FUNC);
4958
4959 /* If the symbol is a function defined in .opd, and the function
4960 code is in a discarded group, let it appear to be undefined. */
4961 if (!bfd_link_relocatable (info)
4962 && (*sec)->reloc_count != 0
4963 && opd_entry_value (*sec, *value, &code_sec, NULL,
4964 FALSE) != (bfd_vma) -1
4965 && discarded_section (code_sec))
4966 {
4967 *sec = bfd_und_section_ptr;
4968 isym->st_shndx = SHN_UNDEF;
4969 }
4970 }
4971 else if (*sec != NULL
4972 && strcmp ((*sec)->name, ".toc") == 0
4973 && ELF_ST_TYPE (isym->st_info) == STT_OBJECT)
4974 {
4975 struct ppc_link_hash_table *htab = ppc_hash_table (info);
4976 if (htab != NULL)
4977 htab->params->object_in_toc = 1;
4978 }
4979
4980 if ((STO_PPC64_LOCAL_MASK & isym->st_other) != 0)
4981 {
4982 if (abiversion (ibfd) == 0)
4983 set_abiversion (ibfd, 2);
4984 else if (abiversion (ibfd) == 1)
4985 {
4986 info->callbacks->einfo (_("%P: symbol '%s' has invalid st_other"
4987 " for ABI version 1\n"), name);
4988 bfd_set_error (bfd_error_bad_value);
4989 return FALSE;
4990 }
4991 }
4992
4993 return TRUE;
4994 }
4995
4996 /* Merge non-visibility st_other attributes: local entry point. */
4997
4998 static void
4999 ppc64_elf_merge_symbol_attribute (struct elf_link_hash_entry *h,
5000 const Elf_Internal_Sym *isym,
5001 bfd_boolean definition,
5002 bfd_boolean dynamic)
5003 {
5004 if (definition && (!dynamic || !h->def_regular))
5005 h->other = ((isym->st_other & ~ELF_ST_VISIBILITY (-1))
5006 | ELF_ST_VISIBILITY (h->other));
5007 }
5008
5009 /* Hook called on merging a symbol. We use this to clear "fake" since
5010 we now have a real symbol. */
5011
5012 static bfd_boolean
5013 ppc64_elf_merge_symbol (struct elf_link_hash_entry *h,
5014 const Elf_Internal_Sym *isym,
5015 asection **psec ATTRIBUTE_UNUSED,
5016 bfd_boolean newdef ATTRIBUTE_UNUSED,
5017 bfd_boolean olddef ATTRIBUTE_UNUSED,
5018 bfd *oldbfd ATTRIBUTE_UNUSED,
5019 const asection *oldsec ATTRIBUTE_UNUSED)
5020 {
5021 ((struct ppc_link_hash_entry *) h)->fake = 0;
5022 if ((STO_PPC64_LOCAL_MASK & isym->st_other) != 0)
5023 ((struct ppc_link_hash_entry *) h)->non_zero_localentry = 1;
5024 return TRUE;
5025 }
5026
5027 /* This function makes an old ABI object reference to ".bar" cause the
5028 inclusion of a new ABI object archive that defines "bar".
5029 NAME is a symbol defined in an archive. Return a symbol in the hash
5030 table that might be satisfied by the archive symbols. */
5031
5032 static struct elf_link_hash_entry *
5033 ppc64_elf_archive_symbol_lookup (bfd *abfd,
5034 struct bfd_link_info *info,
5035 const char *name)
5036 {
5037 struct elf_link_hash_entry *h;
5038 char *dot_name;
5039 size_t len;
5040
5041 h = _bfd_elf_archive_symbol_lookup (abfd, info, name);
5042 if (h != NULL
5043 /* Don't return this sym if it is a fake function descriptor
5044 created by add_symbol_adjust. */
5045 && !((struct ppc_link_hash_entry *) h)->fake)
5046 return h;
5047
5048 if (name[0] == '.')
5049 return h;
5050
5051 len = strlen (name);
5052 dot_name = bfd_alloc (abfd, len + 2);
5053 if (dot_name == NULL)
5054 return (struct elf_link_hash_entry *) -1;
5055 dot_name[0] = '.';
5056 memcpy (dot_name + 1, name, len + 1);
5057 h = _bfd_elf_archive_symbol_lookup (abfd, info, dot_name);
5058 bfd_release (abfd, dot_name);
5059 return h;
5060 }
5061
5062 /* This function satisfies all old ABI object references to ".bar" if a
5063 new ABI object defines "bar". Well, at least, undefined dot symbols
5064 are made weak. This stops later archive searches from including an
5065 object if we already have a function descriptor definition. It also
5066 prevents the linker complaining about undefined symbols.
5067 We also check and correct mismatched symbol visibility here. The
5068 most restrictive visibility of the function descriptor and the
5069 function entry symbol is used. */
5070
5071 static bfd_boolean
5072 add_symbol_adjust (struct ppc_link_hash_entry *eh, struct bfd_link_info *info)
5073 {
5074 struct ppc_link_hash_table *htab;
5075 struct ppc_link_hash_entry *fdh;
5076
5077 if (eh->elf.root.type == bfd_link_hash_warning)
5078 eh = (struct ppc_link_hash_entry *) eh->elf.root.u.i.link;
5079
5080 if (eh->elf.root.type == bfd_link_hash_indirect)
5081 return TRUE;
5082
5083 if (eh->elf.root.root.string[0] != '.')
5084 abort ();
5085
5086 htab = ppc_hash_table (info);
5087 if (htab == NULL)
5088 return FALSE;
5089
5090 fdh = lookup_fdh (eh, htab);
5091 if (fdh == NULL
5092 && !bfd_link_relocatable (info)
5093 && (eh->elf.root.type == bfd_link_hash_undefined
5094 || eh->elf.root.type == bfd_link_hash_undefweak)
5095 && eh->elf.ref_regular)
5096 {
5097 /* Make an undefined function descriptor sym, in order to
5098 pull in an --as-needed shared lib. Archives are handled
5099 elsewhere. */
5100 fdh = make_fdh (info, eh);
5101 if (fdh == NULL)
5102 return FALSE;
5103 }
5104
5105 if (fdh != NULL)
5106 {
5107 unsigned entry_vis = ELF_ST_VISIBILITY (eh->elf.other) - 1;
5108 unsigned descr_vis = ELF_ST_VISIBILITY (fdh->elf.other) - 1;
5109
5110 /* Make both descriptor and entry symbol have the most
5111 constraining visibility of either symbol. */
5112 if (entry_vis < descr_vis)
5113 fdh->elf.other += entry_vis - descr_vis;
5114 else if (entry_vis > descr_vis)
5115 eh->elf.other += descr_vis - entry_vis;
5116
5117 /* Propagate reference flags from entry symbol to function
5118 descriptor symbol. */
5119 fdh->elf.root.non_ir_ref_regular |= eh->elf.root.non_ir_ref_regular;
5120 fdh->elf.root.non_ir_ref_dynamic |= eh->elf.root.non_ir_ref_dynamic;
5121 fdh->elf.ref_regular |= eh->elf.ref_regular;
5122 fdh->elf.ref_regular_nonweak |= eh->elf.ref_regular_nonweak;
5123
5124 if (!fdh->elf.forced_local
5125 && fdh->elf.dynindx == -1
5126 && fdh->elf.versioned != versioned_hidden
5127 && (bfd_link_dll (info)
5128 || fdh->elf.def_dynamic
5129 || fdh->elf.ref_dynamic)
5130 && (eh->elf.ref_regular
5131 || eh->elf.def_regular))
5132 {
5133 if (! bfd_elf_link_record_dynamic_symbol (info, &fdh->elf))
5134 return FALSE;
5135 }
5136 }
5137
5138 return TRUE;
5139 }
5140
5141 /* Set up opd section info and abiversion for IBFD, and process list
5142 of dot-symbols we made in link_hash_newfunc. */
5143
5144 static bfd_boolean
5145 ppc64_elf_before_check_relocs (bfd *ibfd, struct bfd_link_info *info)
5146 {
5147 struct ppc_link_hash_table *htab;
5148 struct ppc_link_hash_entry **p, *eh;
5149 asection *opd = bfd_get_section_by_name (ibfd, ".opd");
5150
5151 if (opd != NULL && opd->size != 0)
5152 {
5153 BFD_ASSERT (ppc64_elf_section_data (opd)->sec_type == sec_normal);
5154 ppc64_elf_section_data (opd)->sec_type = sec_opd;
5155
5156 if (abiversion (ibfd) == 0)
5157 set_abiversion (ibfd, 1);
5158 else if (abiversion (ibfd) >= 2)
5159 {
5160 /* xgettext:c-format */
5161 info->callbacks->einfo (_("%P: %B .opd not allowed in ABI"
5162 " version %d\n"),
5163 ibfd, abiversion (ibfd));
5164 bfd_set_error (bfd_error_bad_value);
5165 return FALSE;
5166 }
5167 }
5168
5169 if (is_ppc64_elf (info->output_bfd))
5170 {
5171 /* For input files without an explicit abiversion in e_flags
5172 we should have flagged any with symbol st_other bits set
5173 as ELFv1 and above flagged those with .opd as ELFv2.
5174 Set the output abiversion if not yet set, and for any input
5175 still ambiguous, take its abiversion from the output.
5176 Differences in ABI are reported later. */
5177 if (abiversion (info->output_bfd) == 0)
5178 set_abiversion (info->output_bfd, abiversion (ibfd));
5179 else if (abiversion (ibfd) == 0)
5180 set_abiversion (ibfd, abiversion (info->output_bfd));
5181 }
5182
5183 htab = ppc_hash_table (info);
5184 if (htab == NULL)
5185 return TRUE;
5186
5187 if (opd != NULL && opd->size != 0
5188 && (ibfd->flags & DYNAMIC) == 0
5189 && (opd->flags & SEC_RELOC) != 0
5190 && opd->reloc_count != 0
5191 && !bfd_is_abs_section (opd->output_section)
5192 && info->gc_sections)
5193 {
5194 /* Garbage collection needs some extra help with .opd sections.
5195 We don't want to necessarily keep everything referenced by
5196 relocs in .opd, as that would keep all functions. Instead,
5197 if we reference an .opd symbol (a function descriptor), we
5198 want to keep the function code symbol's section. This is
5199 easy for global symbols, but for local syms we need to keep
5200 information about the associated function section. */
5201 bfd_size_type amt;
5202 asection **opd_sym_map;
5203 Elf_Internal_Shdr *symtab_hdr;
5204 Elf_Internal_Rela *relocs, *rel_end, *rel;
5205
5206 amt = OPD_NDX (opd->size) * sizeof (*opd_sym_map);
5207 opd_sym_map = bfd_zalloc (ibfd, amt);
5208 if (opd_sym_map == NULL)
5209 return FALSE;
5210 ppc64_elf_section_data (opd)->u.opd.func_sec = opd_sym_map;
5211 relocs = _bfd_elf_link_read_relocs (ibfd, opd, NULL, NULL,
5212 info->keep_memory);
5213 if (relocs == NULL)
5214 return FALSE;
5215 symtab_hdr = &elf_symtab_hdr (ibfd);
5216 rel_end = relocs + opd->reloc_count - 1;
5217 for (rel = relocs; rel < rel_end; rel++)
5218 {
5219 enum elf_ppc64_reloc_type r_type = ELF64_R_TYPE (rel->r_info);
5220 unsigned long r_symndx = ELF64_R_SYM (rel->r_info);
5221
5222 if (r_type == R_PPC64_ADDR64
5223 && ELF64_R_TYPE ((rel + 1)->r_info) == R_PPC64_TOC
5224 && r_symndx < symtab_hdr->sh_info)
5225 {
5226 Elf_Internal_Sym *isym;
5227 asection *s;
5228
5229 isym = bfd_sym_from_r_symndx (&htab->sym_cache, ibfd, r_symndx);
5230 if (isym == NULL)
5231 {
5232 if (elf_section_data (opd)->relocs != relocs)
5233 free (relocs);
5234 return FALSE;
5235 }
5236
5237 s = bfd_section_from_elf_index (ibfd, isym->st_shndx);
5238 if (s != NULL && s != opd)
5239 opd_sym_map[OPD_NDX (rel->r_offset)] = s;
5240 }
5241 }
5242 if (elf_section_data (opd)->relocs != relocs)
5243 free (relocs);
5244 }
5245
5246 p = &htab->dot_syms;
5247 while ((eh = *p) != NULL)
5248 {
5249 *p = NULL;
5250 if (&eh->elf == htab->elf.hgot)
5251 ;
5252 else if (htab->elf.hgot == NULL
5253 && strcmp (eh->elf.root.root.string, ".TOC.") == 0)
5254 htab->elf.hgot = &eh->elf;
5255 else if (abiversion (ibfd) <= 1)
5256 {
5257 htab->need_func_desc_adj = 1;
5258 if (!add_symbol_adjust (eh, info))
5259 return FALSE;
5260 }
5261 p = &eh->u.next_dot_sym;
5262 }
5263 return TRUE;
5264 }
5265
5266 /* Undo hash table changes when an --as-needed input file is determined
5267 not to be needed. */
5268
5269 static bfd_boolean
5270 ppc64_elf_notice_as_needed (bfd *ibfd,
5271 struct bfd_link_info *info,
5272 enum notice_asneeded_action act)
5273 {
5274 if (act == notice_not_needed)
5275 {
5276 struct ppc_link_hash_table *htab = ppc_hash_table (info);
5277
5278 if (htab == NULL)
5279 return FALSE;
5280
5281 htab->dot_syms = NULL;
5282 }
5283 return _bfd_elf_notice_as_needed (ibfd, info, act);
5284 }
5285
5286 /* If --just-symbols against a final linked binary, then assume we need
5287 toc adjusting stubs when calling functions defined there. */
5288
5289 static void
5290 ppc64_elf_link_just_syms (asection *sec, struct bfd_link_info *info)
5291 {
5292 if ((sec->flags & SEC_CODE) != 0
5293 && (sec->owner->flags & (EXEC_P | DYNAMIC)) != 0
5294 && is_ppc64_elf (sec->owner))
5295 {
5296 if (abiversion (sec->owner) >= 2
5297 || bfd_get_section_by_name (sec->owner, ".opd") != NULL)
5298 sec->has_toc_reloc = 1;
5299 }
5300 _bfd_elf_link_just_syms (sec, info);
5301 }
5302
5303 static struct plt_entry **
5304 update_local_sym_info (bfd *abfd, Elf_Internal_Shdr *symtab_hdr,
5305 unsigned long r_symndx, bfd_vma r_addend, int tls_type)
5306 {
5307 struct got_entry **local_got_ents = elf_local_got_ents (abfd);
5308 struct plt_entry **local_plt;
5309 unsigned char *local_got_tls_masks;
5310
5311 if (local_got_ents == NULL)
5312 {
5313 bfd_size_type size = symtab_hdr->sh_info;
5314
5315 size *= (sizeof (*local_got_ents)
5316 + sizeof (*local_plt)
5317 + sizeof (*local_got_tls_masks));
5318 local_got_ents = bfd_zalloc (abfd, size);
5319 if (local_got_ents == NULL)
5320 return NULL;
5321 elf_local_got_ents (abfd) = local_got_ents;
5322 }
5323
5324 if ((tls_type & (PLT_IFUNC | TLS_EXPLICIT)) == 0)
5325 {
5326 struct got_entry *ent;
5327
5328 for (ent = local_got_ents[r_symndx]; ent != NULL; ent = ent->next)
5329 if (ent->addend == r_addend
5330 && ent->owner == abfd
5331 && ent->tls_type == tls_type)
5332 break;
5333 if (ent == NULL)
5334 {
5335 bfd_size_type amt = sizeof (*ent);
5336 ent = bfd_alloc (abfd, amt);
5337 if (ent == NULL)
5338 return FALSE;
5339 ent->next = local_got_ents[r_symndx];
5340 ent->addend = r_addend;
5341 ent->owner = abfd;
5342 ent->tls_type = tls_type;
5343 ent->is_indirect = FALSE;
5344 ent->got.refcount = 0;
5345 local_got_ents[r_symndx] = ent;
5346 }
5347 ent->got.refcount += 1;
5348 }
5349
5350 local_plt = (struct plt_entry **) (local_got_ents + symtab_hdr->sh_info);
5351 local_got_tls_masks = (unsigned char *) (local_plt + symtab_hdr->sh_info);
5352 local_got_tls_masks[r_symndx] |= tls_type;
5353
5354 return local_plt + r_symndx;
5355 }
5356
5357 static bfd_boolean
5358 update_plt_info (bfd *abfd, struct plt_entry **plist, bfd_vma addend)
5359 {
5360 struct plt_entry *ent;
5361
5362 for (ent = *plist; ent != NULL; ent = ent->next)
5363 if (ent->addend == addend)
5364 break;
5365 if (ent == NULL)
5366 {
5367 bfd_size_type amt = sizeof (*ent);
5368 ent = bfd_alloc (abfd, amt);
5369 if (ent == NULL)
5370 return FALSE;
5371 ent->next = *plist;
5372 ent->addend = addend;
5373 ent->plt.refcount = 0;
5374 *plist = ent;
5375 }
5376 ent->plt.refcount += 1;
5377 return TRUE;
5378 }
5379
5380 static bfd_boolean
5381 is_branch_reloc (enum elf_ppc64_reloc_type r_type)
5382 {
5383 return (r_type == R_PPC64_REL24
5384 || r_type == R_PPC64_REL14
5385 || r_type == R_PPC64_REL14_BRTAKEN
5386 || r_type == R_PPC64_REL14_BRNTAKEN
5387 || r_type == R_PPC64_ADDR24
5388 || r_type == R_PPC64_ADDR14
5389 || r_type == R_PPC64_ADDR14_BRTAKEN
5390 || r_type == R_PPC64_ADDR14_BRNTAKEN);
5391 }
5392
5393 /* Look through the relocs for a section during the first phase, and
5394 calculate needed space in the global offset table, procedure
5395 linkage table, and dynamic reloc sections. */
5396
5397 static bfd_boolean
5398 ppc64_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
5399 asection *sec, const Elf_Internal_Rela *relocs)
5400 {
5401 struct ppc_link_hash_table *htab;
5402 Elf_Internal_Shdr *symtab_hdr;
5403 struct elf_link_hash_entry **sym_hashes;
5404 const Elf_Internal_Rela *rel;
5405 const Elf_Internal_Rela *rel_end;
5406 asection *sreloc;
5407 struct elf_link_hash_entry *tga, *dottga;
5408 bfd_boolean is_opd;
5409
5410 if (bfd_link_relocatable (info))
5411 return TRUE;
5412
5413 /* Don't do anything special with non-loaded, non-alloced sections.
5414 In particular, any relocs in such sections should not affect GOT
5415 and PLT reference counting (ie. we don't allow them to create GOT
5416 or PLT entries), there's no possibility or desire to optimize TLS
5417 relocs, and there's not much point in propagating relocs to shared
5418 libs that the dynamic linker won't relocate. */
5419 if ((sec->flags & SEC_ALLOC) == 0)
5420 return TRUE;
5421
5422 BFD_ASSERT (is_ppc64_elf (abfd));
5423
5424 htab = ppc_hash_table (info);
5425 if (htab == NULL)
5426 return FALSE;
5427
5428 tga = elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
5429 FALSE, FALSE, TRUE);
5430 dottga = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
5431 FALSE, FALSE, TRUE);
5432 symtab_hdr = &elf_symtab_hdr (abfd);
5433 sym_hashes = elf_sym_hashes (abfd);
5434 sreloc = NULL;
5435 is_opd = ppc64_elf_section_data (sec)->sec_type == sec_opd;
5436 rel_end = relocs + sec->reloc_count;
5437 for (rel = relocs; rel < rel_end; rel++)
5438 {
5439 unsigned long r_symndx;
5440 struct elf_link_hash_entry *h;
5441 enum elf_ppc64_reloc_type r_type;
5442 int tls_type;
5443 struct _ppc64_elf_section_data *ppc64_sec;
5444 struct plt_entry **ifunc, **plt_list;
5445
5446 r_symndx = ELF64_R_SYM (rel->r_info);
5447 if (r_symndx < symtab_hdr->sh_info)
5448 h = NULL;
5449 else
5450 {
5451 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
5452 h = elf_follow_link (h);
5453
5454 if (h == htab->elf.hgot)
5455 sec->has_toc_reloc = 1;
5456 }
5457
5458 tls_type = 0;
5459 ifunc = NULL;
5460 if (h != NULL)
5461 {
5462 if (h->type == STT_GNU_IFUNC)
5463 {
5464 h->needs_plt = 1;
5465 ifunc = &h->plt.plist;
5466 }
5467 }
5468 else
5469 {
5470 Elf_Internal_Sym *isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5471 abfd, r_symndx);
5472 if (isym == NULL)
5473 return FALSE;
5474
5475 if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
5476 {
5477 ifunc = update_local_sym_info (abfd, symtab_hdr, r_symndx,
5478 rel->r_addend, PLT_IFUNC);
5479 if (ifunc == NULL)
5480 return FALSE;
5481 }
5482 }
5483
5484 r_type = ELF64_R_TYPE (rel->r_info);
5485 switch (r_type)
5486 {
5487 case R_PPC64_TLSGD:
5488 case R_PPC64_TLSLD:
5489 /* These special tls relocs tie a call to __tls_get_addr with
5490 its parameter symbol. */
5491 break;
5492
5493 case R_PPC64_GOT_TLSLD16:
5494 case R_PPC64_GOT_TLSLD16_LO:
5495 case R_PPC64_GOT_TLSLD16_HI:
5496 case R_PPC64_GOT_TLSLD16_HA:
5497 tls_type = TLS_TLS | TLS_LD;
5498 goto dogottls;
5499
5500 case R_PPC64_GOT_TLSGD16:
5501 case R_PPC64_GOT_TLSGD16_LO:
5502 case R_PPC64_GOT_TLSGD16_HI:
5503 case R_PPC64_GOT_TLSGD16_HA:
5504 tls_type = TLS_TLS | TLS_GD;
5505 goto dogottls;
5506
5507 case R_PPC64_GOT_TPREL16_DS:
5508 case R_PPC64_GOT_TPREL16_LO_DS:
5509 case R_PPC64_GOT_TPREL16_HI:
5510 case R_PPC64_GOT_TPREL16_HA:
5511 if (bfd_link_dll (info))
5512 info->flags |= DF_STATIC_TLS;
5513 tls_type = TLS_TLS | TLS_TPREL;
5514 goto dogottls;
5515
5516 case R_PPC64_GOT_DTPREL16_DS:
5517 case R_PPC64_GOT_DTPREL16_LO_DS:
5518 case R_PPC64_GOT_DTPREL16_HI:
5519 case R_PPC64_GOT_DTPREL16_HA:
5520 tls_type = TLS_TLS | TLS_DTPREL;
5521 dogottls:
5522 sec->has_tls_reloc = 1;
5523 /* Fall through */
5524
5525 case R_PPC64_GOT16:
5526 case R_PPC64_GOT16_DS:
5527 case R_PPC64_GOT16_HA:
5528 case R_PPC64_GOT16_HI:
5529 case R_PPC64_GOT16_LO:
5530 case R_PPC64_GOT16_LO_DS:
5531 /* This symbol requires a global offset table entry. */
5532 sec->has_toc_reloc = 1;
5533 if (r_type == R_PPC64_GOT_TLSLD16
5534 || r_type == R_PPC64_GOT_TLSGD16
5535 || r_type == R_PPC64_GOT_TPREL16_DS
5536 || r_type == R_PPC64_GOT_DTPREL16_DS
5537 || r_type == R_PPC64_GOT16
5538 || r_type == R_PPC64_GOT16_DS)
5539 {
5540 htab->do_multi_toc = 1;
5541 ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5542 }
5543
5544 if (ppc64_elf_tdata (abfd)->got == NULL
5545 && !create_got_section (abfd, info))
5546 return FALSE;
5547
5548 if (h != NULL)
5549 {
5550 struct ppc_link_hash_entry *eh;
5551 struct got_entry *ent;
5552
5553 eh = (struct ppc_link_hash_entry *) h;
5554 for (ent = eh->elf.got.glist; ent != NULL; ent = ent->next)
5555 if (ent->addend == rel->r_addend
5556 && ent->owner == abfd
5557 && ent->tls_type == tls_type)
5558 break;
5559 if (ent == NULL)
5560 {
5561 bfd_size_type amt = sizeof (*ent);
5562 ent = bfd_alloc (abfd, amt);
5563 if (ent == NULL)
5564 return FALSE;
5565 ent->next = eh->elf.got.glist;
5566 ent->addend = rel->r_addend;
5567 ent->owner = abfd;
5568 ent->tls_type = tls_type;
5569 ent->is_indirect = FALSE;
5570 ent->got.refcount = 0;
5571 eh->elf.got.glist = ent;
5572 }
5573 ent->got.refcount += 1;
5574 eh->tls_mask |= tls_type;
5575 }
5576 else
5577 /* This is a global offset table entry for a local symbol. */
5578 if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5579 rel->r_addend, tls_type))
5580 return FALSE;
5581
5582 /* We may also need a plt entry if the symbol turns out to be
5583 an ifunc. */
5584 if (h != NULL && !bfd_link_pic (info) && abiversion (abfd) != 1)
5585 {
5586 if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5587 return FALSE;
5588 }
5589 break;
5590
5591 case R_PPC64_PLT16_HA:
5592 case R_PPC64_PLT16_HI:
5593 case R_PPC64_PLT16_LO:
5594 case R_PPC64_PLT32:
5595 case R_PPC64_PLT64:
5596 /* This symbol requires a procedure linkage table entry. */
5597 plt_list = ifunc;
5598 if (h != NULL)
5599 {
5600 h->needs_plt = 1;
5601 if (h->root.root.string[0] == '.'
5602 && h->root.root.string[1] != '\0')
5603 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5604 plt_list = &h->plt.plist;
5605 }
5606 if (plt_list == NULL)
5607 {
5608 /* It does not make sense to have a procedure linkage
5609 table entry for a non-ifunc local symbol. */
5610 info->callbacks->einfo
5611 /* xgettext:c-format */
5612 (_("%H: %s reloc against local symbol\n"),
5613 abfd, sec, rel->r_offset,
5614 ppc64_elf_howto_table[r_type]->name);
5615 bfd_set_error (bfd_error_bad_value);
5616 return FALSE;
5617 }
5618 if (!update_plt_info (abfd, plt_list, rel->r_addend))
5619 return FALSE;
5620 break;
5621
5622 /* The following relocations don't need to propagate the
5623 relocation if linking a shared object since they are
5624 section relative. */
5625 case R_PPC64_SECTOFF:
5626 case R_PPC64_SECTOFF_LO:
5627 case R_PPC64_SECTOFF_HI:
5628 case R_PPC64_SECTOFF_HA:
5629 case R_PPC64_SECTOFF_DS:
5630 case R_PPC64_SECTOFF_LO_DS:
5631 case R_PPC64_DTPREL16:
5632 case R_PPC64_DTPREL16_LO:
5633 case R_PPC64_DTPREL16_HI:
5634 case R_PPC64_DTPREL16_HA:
5635 case R_PPC64_DTPREL16_DS:
5636 case R_PPC64_DTPREL16_LO_DS:
5637 case R_PPC64_DTPREL16_HIGH:
5638 case R_PPC64_DTPREL16_HIGHA:
5639 case R_PPC64_DTPREL16_HIGHER:
5640 case R_PPC64_DTPREL16_HIGHERA:
5641 case R_PPC64_DTPREL16_HIGHEST:
5642 case R_PPC64_DTPREL16_HIGHESTA:
5643 break;
5644
5645 /* Nor do these. */
5646 case R_PPC64_REL16:
5647 case R_PPC64_REL16_LO:
5648 case R_PPC64_REL16_HI:
5649 case R_PPC64_REL16_HA:
5650 case R_PPC64_REL16DX_HA:
5651 break;
5652
5653 /* Not supported as a dynamic relocation. */
5654 case R_PPC64_ADDR64_LOCAL:
5655 if (bfd_link_pic (info))
5656 {
5657 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
5658 ppc_howto_init ();
5659 /* xgettext:c-format */
5660 info->callbacks->einfo (_("%H: %s reloc unsupported "
5661 "in shared libraries and PIEs.\n"),
5662 abfd, sec, rel->r_offset,
5663 ppc64_elf_howto_table[r_type]->name);
5664 bfd_set_error (bfd_error_bad_value);
5665 return FALSE;
5666 }
5667 break;
5668
5669 case R_PPC64_TOC16:
5670 case R_PPC64_TOC16_DS:
5671 htab->do_multi_toc = 1;
5672 ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5673 /* Fall through. */
5674 case R_PPC64_TOC16_LO:
5675 case R_PPC64_TOC16_HI:
5676 case R_PPC64_TOC16_HA:
5677 case R_PPC64_TOC16_LO_DS:
5678 sec->has_toc_reloc = 1;
5679 break;
5680
5681 /* Marker reloc. */
5682 case R_PPC64_ENTRY:
5683 break;
5684
5685 /* This relocation describes the C++ object vtable hierarchy.
5686 Reconstruct it for later use during GC. */
5687 case R_PPC64_GNU_VTINHERIT:
5688 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
5689 return FALSE;
5690 break;
5691
5692 /* This relocation describes which C++ vtable entries are actually
5693 used. Record for later use during GC. */
5694 case R_PPC64_GNU_VTENTRY:
5695 BFD_ASSERT (h != NULL);
5696 if (h != NULL
5697 && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
5698 return FALSE;
5699 break;
5700
5701 case R_PPC64_REL14:
5702 case R_PPC64_REL14_BRTAKEN:
5703 case R_PPC64_REL14_BRNTAKEN:
5704 {
5705 asection *dest = NULL;
5706
5707 /* Heuristic: If jumping outside our section, chances are
5708 we are going to need a stub. */
5709 if (h != NULL)
5710 {
5711 /* If the sym is weak it may be overridden later, so
5712 don't assume we know where a weak sym lives. */
5713 if (h->root.type == bfd_link_hash_defined)
5714 dest = h->root.u.def.section;
5715 }
5716 else
5717 {
5718 Elf_Internal_Sym *isym;
5719
5720 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5721 abfd, r_symndx);
5722 if (isym == NULL)
5723 return FALSE;
5724
5725 dest = bfd_section_from_elf_index (abfd, isym->st_shndx);
5726 }
5727
5728 if (dest != sec)
5729 ppc64_elf_section_data (sec)->has_14bit_branch = 1;
5730 }
5731 /* Fall through. */
5732
5733 case R_PPC64_REL24:
5734 plt_list = ifunc;
5735 if (h != NULL)
5736 {
5737 h->needs_plt = 1;
5738 if (h->root.root.string[0] == '.'
5739 && h->root.root.string[1] != '\0')
5740 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5741
5742 if (h == tga || h == dottga)
5743 {
5744 sec->has_tls_reloc = 1;
5745 if (rel != relocs
5746 && (ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSGD
5747 || ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSLD))
5748 /* We have a new-style __tls_get_addr call with
5749 a marker reloc. */
5750 ;
5751 else
5752 /* Mark this section as having an old-style call. */
5753 sec->has_tls_get_addr_call = 1;
5754 }
5755 plt_list = &h->plt.plist;
5756 }
5757
5758 /* We may need a .plt entry if the function this reloc
5759 refers to is in a shared lib. */
5760 if (plt_list
5761 && !update_plt_info (abfd, plt_list, rel->r_addend))
5762 return FALSE;
5763 break;
5764
5765 case R_PPC64_ADDR14:
5766 case R_PPC64_ADDR14_BRNTAKEN:
5767 case R_PPC64_ADDR14_BRTAKEN:
5768 case R_PPC64_ADDR24:
5769 goto dodyn;
5770
5771 case R_PPC64_TPREL64:
5772 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_TPREL;
5773 if (bfd_link_dll (info))
5774 info->flags |= DF_STATIC_TLS;
5775 goto dotlstoc;
5776
5777 case R_PPC64_DTPMOD64:
5778 if (rel + 1 < rel_end
5779 && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
5780 && rel[1].r_offset == rel->r_offset + 8)
5781 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_GD;
5782 else
5783 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_LD;
5784 goto dotlstoc;
5785
5786 case R_PPC64_DTPREL64:
5787 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_DTPREL;
5788 if (rel != relocs
5789 && rel[-1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPMOD64)
5790 && rel[-1].r_offset == rel->r_offset - 8)
5791 /* This is the second reloc of a dtpmod, dtprel pair.
5792 Don't mark with TLS_DTPREL. */
5793 goto dodyn;
5794
5795 dotlstoc:
5796 sec->has_tls_reloc = 1;
5797 if (h != NULL)
5798 {
5799 struct ppc_link_hash_entry *eh;
5800 eh = (struct ppc_link_hash_entry *) h;
5801 eh->tls_mask |= tls_type;
5802 }
5803 else
5804 if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5805 rel->r_addend, tls_type))
5806 return FALSE;
5807
5808 ppc64_sec = ppc64_elf_section_data (sec);
5809 if (ppc64_sec->sec_type != sec_toc)
5810 {
5811 bfd_size_type amt;
5812
5813 /* One extra to simplify get_tls_mask. */
5814 amt = sec->size * sizeof (unsigned) / 8 + sizeof (unsigned);
5815 ppc64_sec->u.toc.symndx = bfd_zalloc (abfd, amt);
5816 if (ppc64_sec->u.toc.symndx == NULL)
5817 return FALSE;
5818 amt = sec->size * sizeof (bfd_vma) / 8;
5819 ppc64_sec->u.toc.add = bfd_zalloc (abfd, amt);
5820 if (ppc64_sec->u.toc.add == NULL)
5821 return FALSE;
5822 BFD_ASSERT (ppc64_sec->sec_type == sec_normal);
5823 ppc64_sec->sec_type = sec_toc;
5824 }
5825 BFD_ASSERT (rel->r_offset % 8 == 0);
5826 ppc64_sec->u.toc.symndx[rel->r_offset / 8] = r_symndx;
5827 ppc64_sec->u.toc.add[rel->r_offset / 8] = rel->r_addend;
5828
5829 /* Mark the second slot of a GD or LD entry.
5830 -1 to indicate GD and -2 to indicate LD. */
5831 if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_GD))
5832 ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -1;
5833 else if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_LD))
5834 ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -2;
5835 goto dodyn;
5836
5837 case R_PPC64_TPREL16:
5838 case R_PPC64_TPREL16_LO:
5839 case R_PPC64_TPREL16_HI:
5840 case R_PPC64_TPREL16_HA:
5841 case R_PPC64_TPREL16_DS:
5842 case R_PPC64_TPREL16_LO_DS:
5843 case R_PPC64_TPREL16_HIGH:
5844 case R_PPC64_TPREL16_HIGHA:
5845 case R_PPC64_TPREL16_HIGHER:
5846 case R_PPC64_TPREL16_HIGHERA:
5847 case R_PPC64_TPREL16_HIGHEST:
5848 case R_PPC64_TPREL16_HIGHESTA:
5849 if (bfd_link_dll (info))
5850 info->flags |= DF_STATIC_TLS;
5851 goto dodyn;
5852
5853 case R_PPC64_ADDR64:
5854 if (is_opd
5855 && rel + 1 < rel_end
5856 && ELF64_R_TYPE ((rel + 1)->r_info) == R_PPC64_TOC)
5857 {
5858 if (h != NULL)
5859 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5860 }
5861 /* Fall through. */
5862
5863 case R_PPC64_ADDR16:
5864 case R_PPC64_ADDR16_DS:
5865 case R_PPC64_ADDR16_HA:
5866 case R_PPC64_ADDR16_HI:
5867 case R_PPC64_ADDR16_HIGH:
5868 case R_PPC64_ADDR16_HIGHA:
5869 case R_PPC64_ADDR16_HIGHER:
5870 case R_PPC64_ADDR16_HIGHERA:
5871 case R_PPC64_ADDR16_HIGHEST:
5872 case R_PPC64_ADDR16_HIGHESTA:
5873 case R_PPC64_ADDR16_LO:
5874 case R_PPC64_ADDR16_LO_DS:
5875 if (h != NULL && !bfd_link_pic (info) && abiversion (abfd) != 1
5876 && rel->r_addend == 0)
5877 {
5878 /* We may need a .plt entry if this reloc refers to a
5879 function in a shared lib. */
5880 if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5881 return FALSE;
5882 h->pointer_equality_needed = 1;
5883 }
5884 /* Fall through. */
5885
5886 case R_PPC64_REL30:
5887 case R_PPC64_REL32:
5888 case R_PPC64_REL64:
5889 case R_PPC64_ADDR32:
5890 case R_PPC64_UADDR16:
5891 case R_PPC64_UADDR32:
5892 case R_PPC64_UADDR64:
5893 case R_PPC64_TOC:
5894 if (h != NULL && !bfd_link_pic (info))
5895 /* We may need a copy reloc. */
5896 h->non_got_ref = 1;
5897
5898 /* Don't propagate .opd relocs. */
5899 if (NO_OPD_RELOCS && is_opd)
5900 break;
5901
5902 /* If we are creating a shared library, and this is a reloc
5903 against a global symbol, or a non PC relative reloc
5904 against a local symbol, then we need to copy the reloc
5905 into the shared library. However, if we are linking with
5906 -Bsymbolic, we do not need to copy a reloc against a
5907 global symbol which is defined in an object we are
5908 including in the link (i.e., DEF_REGULAR is set). At
5909 this point we have not seen all the input files, so it is
5910 possible that DEF_REGULAR is not set now but will be set
5911 later (it is never cleared). In case of a weak definition,
5912 DEF_REGULAR may be cleared later by a strong definition in
5913 a shared library. We account for that possibility below by
5914 storing information in the dyn_relocs field of the hash
5915 table entry. A similar situation occurs when creating
5916 shared libraries and symbol visibility changes render the
5917 symbol local.
5918
5919 If on the other hand, we are creating an executable, we
5920 may need to keep relocations for symbols satisfied by a
5921 dynamic library if we manage to avoid copy relocs for the
5922 symbol. */
5923 dodyn:
5924 if ((bfd_link_pic (info)
5925 && (must_be_dyn_reloc (info, r_type)
5926 || (h != NULL
5927 && (!SYMBOLIC_BIND (info, h)
5928 || h->root.type == bfd_link_hash_defweak
5929 || !h->def_regular))))
5930 || (ELIMINATE_COPY_RELOCS
5931 && !bfd_link_pic (info)
5932 && h != NULL
5933 && (h->root.type == bfd_link_hash_defweak
5934 || !h->def_regular))
5935 || (!bfd_link_pic (info)
5936 && ifunc != NULL))
5937 {
5938 /* We must copy these reloc types into the output file.
5939 Create a reloc section in dynobj and make room for
5940 this reloc. */
5941 if (sreloc == NULL)
5942 {
5943 sreloc = _bfd_elf_make_dynamic_reloc_section
5944 (sec, htab->elf.dynobj, 3, abfd, /*rela?*/ TRUE);
5945
5946 if (sreloc == NULL)
5947 return FALSE;
5948 }
5949
5950 /* If this is a global symbol, we count the number of
5951 relocations we need for this symbol. */
5952 if (h != NULL)
5953 {
5954 struct elf_dyn_relocs *p;
5955 struct elf_dyn_relocs **head;
5956
5957 head = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
5958 p = *head;
5959 if (p == NULL || p->sec != sec)
5960 {
5961 p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5962 if (p == NULL)
5963 return FALSE;
5964 p->next = *head;
5965 *head = p;
5966 p->sec = sec;
5967 p->count = 0;
5968 p->pc_count = 0;
5969 }
5970 p->count += 1;
5971 if (!must_be_dyn_reloc (info, r_type))
5972 p->pc_count += 1;
5973 }
5974 else
5975 {
5976 /* Track dynamic relocs needed for local syms too.
5977 We really need local syms available to do this
5978 easily. Oh well. */
5979 struct ppc_dyn_relocs *p;
5980 struct ppc_dyn_relocs **head;
5981 bfd_boolean is_ifunc;
5982 asection *s;
5983 void *vpp;
5984 Elf_Internal_Sym *isym;
5985
5986 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5987 abfd, r_symndx);
5988 if (isym == NULL)
5989 return FALSE;
5990
5991 s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5992 if (s == NULL)
5993 s = sec;
5994
5995 vpp = &elf_section_data (s)->local_dynrel;
5996 head = (struct ppc_dyn_relocs **) vpp;
5997 is_ifunc = ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC;
5998 p = *head;
5999 if (p != NULL && p->sec == sec && p->ifunc != is_ifunc)
6000 p = p->next;
6001 if (p == NULL || p->sec != sec || p->ifunc != is_ifunc)
6002 {
6003 p = bfd_alloc (htab->elf.dynobj, sizeof *p);
6004 if (p == NULL)
6005 return FALSE;
6006 p->next = *head;
6007 *head = p;
6008 p->sec = sec;
6009 p->ifunc = is_ifunc;
6010 p->count = 0;
6011 }
6012 p->count += 1;
6013 }
6014 }
6015 break;
6016
6017 default:
6018 break;
6019 }
6020 }
6021
6022 return TRUE;
6023 }
6024
6025 /* Merge backend specific data from an object file to the output
6026 object file when linking. */
6027
6028 static bfd_boolean
6029 ppc64_elf_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info)
6030 {
6031 bfd *obfd = info->output_bfd;
6032 unsigned long iflags, oflags;
6033
6034 if ((ibfd->flags & BFD_LINKER_CREATED) != 0)
6035 return TRUE;
6036
6037 if (!is_ppc64_elf (ibfd) || !is_ppc64_elf (obfd))
6038 return TRUE;
6039
6040 if (!_bfd_generic_verify_endian_match (ibfd, info))
6041 return FALSE;
6042
6043 iflags = elf_elfheader (ibfd)->e_flags;
6044 oflags = elf_elfheader (obfd)->e_flags;
6045
6046 if (iflags & ~EF_PPC64_ABI)
6047 {
6048 _bfd_error_handler
6049 /* xgettext:c-format */
6050 (_("%B uses unknown e_flags 0x%lx"), ibfd, iflags);
6051 bfd_set_error (bfd_error_bad_value);
6052 return FALSE;
6053 }
6054 else if (iflags != oflags && iflags != 0)
6055 {
6056 _bfd_error_handler
6057 /* xgettext:c-format */
6058 (_("%B: ABI version %ld is not compatible with ABI version %ld output"),
6059 ibfd, iflags, oflags);
6060 bfd_set_error (bfd_error_bad_value);
6061 return FALSE;
6062 }
6063
6064 _bfd_elf_ppc_merge_fp_attributes (ibfd, info);
6065
6066 /* Merge Tag_compatibility attributes and any common GNU ones. */
6067 _bfd_elf_merge_object_attributes (ibfd, info);
6068
6069 return TRUE;
6070 }
6071
6072 static bfd_boolean
6073 ppc64_elf_print_private_bfd_data (bfd *abfd, void *ptr)
6074 {
6075 /* Print normal ELF private data. */
6076 _bfd_elf_print_private_bfd_data (abfd, ptr);
6077
6078 if (elf_elfheader (abfd)->e_flags != 0)
6079 {
6080 FILE *file = ptr;
6081
6082 fprintf (file, _("private flags = 0x%lx:"),
6083 elf_elfheader (abfd)->e_flags);
6084
6085 if ((elf_elfheader (abfd)->e_flags & EF_PPC64_ABI) != 0)
6086 fprintf (file, _(" [abiv%ld]"),
6087 elf_elfheader (abfd)->e_flags & EF_PPC64_ABI);
6088 fputc ('\n', file);
6089 }
6090
6091 return TRUE;
6092 }
6093
6094 /* OFFSET in OPD_SEC specifies a function descriptor. Return the address
6095 of the code entry point, and its section, which must be in the same
6096 object as OPD_SEC. Returns (bfd_vma) -1 on error. */
6097
6098 static bfd_vma
6099 opd_entry_value (asection *opd_sec,
6100 bfd_vma offset,
6101 asection **code_sec,
6102 bfd_vma *code_off,
6103 bfd_boolean in_code_sec)
6104 {
6105 bfd *opd_bfd = opd_sec->owner;
6106 Elf_Internal_Rela *relocs;
6107 Elf_Internal_Rela *lo, *hi, *look;
6108 bfd_vma val;
6109
6110 /* No relocs implies we are linking a --just-symbols object, or looking
6111 at a final linked executable with addr2line or somesuch. */
6112 if (opd_sec->reloc_count == 0)
6113 {
6114 bfd_byte *contents = ppc64_elf_tdata (opd_bfd)->opd.contents;
6115
6116 if (contents == NULL)
6117 {
6118 if (!bfd_malloc_and_get_section (opd_bfd, opd_sec, &contents))
6119 return (bfd_vma) -1;
6120 ppc64_elf_tdata (opd_bfd)->opd.contents = contents;
6121 }
6122
6123 /* PR 17512: file: 64b9dfbb. */
6124 if (offset + 7 >= opd_sec->size || offset + 7 < offset)
6125 return (bfd_vma) -1;
6126
6127 val = bfd_get_64 (opd_bfd, contents + offset);
6128 if (code_sec != NULL)
6129 {
6130 asection *sec, *likely = NULL;
6131
6132 if (in_code_sec)
6133 {
6134 sec = *code_sec;
6135 if (sec->vma <= val
6136 && val < sec->vma + sec->size)
6137 likely = sec;
6138 else
6139 val = -1;
6140 }
6141 else
6142 for (sec = opd_bfd->sections; sec != NULL; sec = sec->next)
6143 if (sec->vma <= val
6144 && (sec->flags & SEC_LOAD) != 0
6145 && (sec->flags & SEC_ALLOC) != 0)
6146 likely = sec;
6147 if (likely != NULL)
6148 {
6149 *code_sec = likely;
6150 if (code_off != NULL)
6151 *code_off = val - likely->vma;
6152 }
6153 }
6154 return val;
6155 }
6156
6157 BFD_ASSERT (is_ppc64_elf (opd_bfd));
6158
6159 relocs = ppc64_elf_tdata (opd_bfd)->opd.relocs;
6160 if (relocs == NULL)
6161 relocs = _bfd_elf_link_read_relocs (opd_bfd, opd_sec, NULL, NULL, TRUE);
6162 /* PR 17512: file: df8e1fd6. */
6163 if (relocs == NULL)
6164 return (bfd_vma) -1;
6165
6166 /* Go find the opd reloc at the sym address. */
6167 lo = relocs;
6168 hi = lo + opd_sec->reloc_count - 1; /* ignore last reloc */
6169 val = (bfd_vma) -1;
6170 while (lo < hi)
6171 {
6172 look = lo + (hi - lo) / 2;
6173 if (look->r_offset < offset)
6174 lo = look + 1;
6175 else if (look->r_offset > offset)
6176 hi = look;
6177 else
6178 {
6179 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (opd_bfd);
6180
6181 if (ELF64_R_TYPE (look->r_info) == R_PPC64_ADDR64
6182 && ELF64_R_TYPE ((look + 1)->r_info) == R_PPC64_TOC)
6183 {
6184 unsigned long symndx = ELF64_R_SYM (look->r_info);
6185 asection *sec = NULL;
6186
6187 if (symndx >= symtab_hdr->sh_info
6188 && elf_sym_hashes (opd_bfd) != NULL)
6189 {
6190 struct elf_link_hash_entry **sym_hashes;
6191 struct elf_link_hash_entry *rh;
6192
6193 sym_hashes = elf_sym_hashes (opd_bfd);
6194 rh = sym_hashes[symndx - symtab_hdr->sh_info];
6195 if (rh != NULL)
6196 {
6197 rh = elf_follow_link (rh);
6198 if (rh->root.type != bfd_link_hash_defined
6199 && rh->root.type != bfd_link_hash_defweak)
6200 break;
6201 if (rh->root.u.def.section->owner == opd_bfd)
6202 {
6203 val = rh->root.u.def.value;
6204 sec = rh->root.u.def.section;
6205 }
6206 }
6207 }
6208
6209 if (sec == NULL)
6210 {
6211 Elf_Internal_Sym *sym;
6212
6213 if (symndx < symtab_hdr->sh_info)
6214 {
6215 sym = (Elf_Internal_Sym *) symtab_hdr->contents;
6216 if (sym == NULL)
6217 {
6218 size_t symcnt = symtab_hdr->sh_info;
6219 sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr,
6220 symcnt, 0,
6221 NULL, NULL, NULL);
6222 if (sym == NULL)
6223 break;
6224 symtab_hdr->contents = (bfd_byte *) sym;
6225 }
6226 sym += symndx;
6227 }
6228 else
6229 {
6230 sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr,
6231 1, symndx,
6232 NULL, NULL, NULL);
6233 if (sym == NULL)
6234 break;
6235 }
6236 sec = bfd_section_from_elf_index (opd_bfd, sym->st_shndx);
6237 if (sec == NULL)
6238 break;
6239 BFD_ASSERT ((sec->flags & SEC_MERGE) == 0);
6240 val = sym->st_value;
6241 }
6242
6243 val += look->r_addend;
6244 if (code_off != NULL)
6245 *code_off = val;
6246 if (code_sec != NULL)
6247 {
6248 if (in_code_sec && *code_sec != sec)
6249 return -1;
6250 else
6251 *code_sec = sec;
6252 }
6253 if (sec->output_section != NULL)
6254 val += sec->output_section->vma + sec->output_offset;
6255 }
6256 break;
6257 }
6258 }
6259
6260 return val;
6261 }
6262
6263 /* If the ELF symbol SYM might be a function in SEC, return the
6264 function size and set *CODE_OFF to the function's entry point,
6265 otherwise return zero. */
6266
6267 static bfd_size_type
6268 ppc64_elf_maybe_function_sym (const asymbol *sym, asection *sec,
6269 bfd_vma *code_off)
6270 {
6271 bfd_size_type size;
6272
6273 if ((sym->flags & (BSF_SECTION_SYM | BSF_FILE | BSF_OBJECT
6274 | BSF_THREAD_LOCAL | BSF_RELC | BSF_SRELC)) != 0)
6275 return 0;
6276
6277 size = 0;
6278 if (!(sym->flags & BSF_SYNTHETIC))
6279 size = ((elf_symbol_type *) sym)->internal_elf_sym.st_size;
6280
6281 if (strcmp (sym->section->name, ".opd") == 0)
6282 {
6283 struct _opd_sec_data *opd = get_opd_info (sym->section);
6284 bfd_vma symval = sym->value;
6285
6286 if (opd != NULL
6287 && opd->adjust != NULL
6288 && elf_section_data (sym->section)->relocs != NULL)
6289 {
6290 /* opd_entry_value will use cached relocs that have been
6291 adjusted, but with raw symbols. That means both local
6292 and global symbols need adjusting. */
6293 long adjust = opd->adjust[OPD_NDX (symval)];
6294 if (adjust == -1)
6295 return 0;
6296 symval += adjust;
6297 }
6298
6299 if (opd_entry_value (sym->section, symval,
6300 &sec, code_off, TRUE) == (bfd_vma) -1)
6301 return 0;
6302 /* An old ABI binary with dot-syms has a size of 24 on the .opd
6303 symbol. This size has nothing to do with the code size of the
6304 function, which is what we're supposed to return, but the
6305 code size isn't available without looking up the dot-sym.
6306 However, doing that would be a waste of time particularly
6307 since elf_find_function will look at the dot-sym anyway.
6308 Now, elf_find_function will keep the largest size of any
6309 function sym found at the code address of interest, so return
6310 1 here to avoid it incorrectly caching a larger function size
6311 for a small function. This does mean we return the wrong
6312 size for a new-ABI function of size 24, but all that does is
6313 disable caching for such functions. */
6314 if (size == 24)
6315 size = 1;
6316 }
6317 else
6318 {
6319 if (sym->section != sec)
6320 return 0;
6321 *code_off = sym->value;
6322 }
6323 if (size == 0)
6324 size = 1;
6325 return size;
6326 }
6327
6328 /* Return true if symbol is a strong function defined in an ELFv2
6329 object with st_other localentry bits of zero, ie. its local entry
6330 point coincides with its global entry point. */
6331
6332 static bfd_boolean
6333 is_elfv2_localentry0 (struct elf_link_hash_entry *h)
6334 {
6335 return (h != NULL
6336 && h->type == STT_FUNC
6337 && h->root.type == bfd_link_hash_defined
6338 && (STO_PPC64_LOCAL_MASK & h->other) == 0
6339 && !((struct ppc_link_hash_entry *) h)->non_zero_localentry
6340 && is_ppc64_elf (h->root.u.def.section->owner)
6341 && abiversion (h->root.u.def.section->owner) >= 2);
6342 }
6343
6344 /* Return true if symbol is defined in a regular object file. */
6345
6346 static bfd_boolean
6347 is_static_defined (struct elf_link_hash_entry *h)
6348 {
6349 return ((h->root.type == bfd_link_hash_defined
6350 || h->root.type == bfd_link_hash_defweak)
6351 && h->root.u.def.section != NULL
6352 && h->root.u.def.section->output_section != NULL);
6353 }
6354
6355 /* If FDH is a function descriptor symbol, return the associated code
6356 entry symbol if it is defined. Return NULL otherwise. */
6357
6358 static struct ppc_link_hash_entry *
6359 defined_code_entry (struct ppc_link_hash_entry *fdh)
6360 {
6361 if (fdh->is_func_descriptor)
6362 {
6363 struct ppc_link_hash_entry *fh = ppc_follow_link (fdh->oh);
6364 if (fh->elf.root.type == bfd_link_hash_defined
6365 || fh->elf.root.type == bfd_link_hash_defweak)
6366 return fh;
6367 }
6368 return NULL;
6369 }
6370
6371 /* If FH is a function code entry symbol, return the associated
6372 function descriptor symbol if it is defined. Return NULL otherwise. */
6373
6374 static struct ppc_link_hash_entry *
6375 defined_func_desc (struct ppc_link_hash_entry *fh)
6376 {
6377 if (fh->oh != NULL
6378 && fh->oh->is_func_descriptor)
6379 {
6380 struct ppc_link_hash_entry *fdh = ppc_follow_link (fh->oh);
6381 if (fdh->elf.root.type == bfd_link_hash_defined
6382 || fdh->elf.root.type == bfd_link_hash_defweak)
6383 return fdh;
6384 }
6385 return NULL;
6386 }
6387
6388 static bfd_boolean func_desc_adjust (struct elf_link_hash_entry *, void *);
6389
6390 /* Garbage collect sections, after first dealing with dot-symbols. */
6391
6392 static bfd_boolean
6393 ppc64_elf_gc_sections (bfd *abfd, struct bfd_link_info *info)
6394 {
6395 struct ppc_link_hash_table *htab = ppc_hash_table (info);
6396
6397 if (htab != NULL && htab->need_func_desc_adj)
6398 {
6399 elf_link_hash_traverse (&htab->elf, func_desc_adjust, info);
6400 htab->need_func_desc_adj = 0;
6401 }
6402 return bfd_elf_gc_sections (abfd, info);
6403 }
6404
6405 /* Mark all our entry sym sections, both opd and code section. */
6406
6407 static void
6408 ppc64_elf_gc_keep (struct bfd_link_info *info)
6409 {
6410 struct ppc_link_hash_table *htab = ppc_hash_table (info);
6411 struct bfd_sym_chain *sym;
6412
6413 if (htab == NULL)
6414 return;
6415
6416 for (sym = info->gc_sym_list; sym != NULL; sym = sym->next)
6417 {
6418 struct ppc_link_hash_entry *eh, *fh;
6419 asection *sec;
6420
6421 eh = (struct ppc_link_hash_entry *)
6422 elf_link_hash_lookup (&htab->elf, sym->name, FALSE, FALSE, TRUE);
6423 if (eh == NULL)
6424 continue;
6425 if (eh->elf.root.type != bfd_link_hash_defined
6426 && eh->elf.root.type != bfd_link_hash_defweak)
6427 continue;
6428
6429 fh = defined_code_entry (eh);
6430 if (fh != NULL)
6431 {
6432 sec = fh->elf.root.u.def.section;
6433 sec->flags |= SEC_KEEP;
6434 }
6435 else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6436 && opd_entry_value (eh->elf.root.u.def.section,
6437 eh->elf.root.u.def.value,
6438 &sec, NULL, FALSE) != (bfd_vma) -1)
6439 sec->flags |= SEC_KEEP;
6440
6441 sec = eh->elf.root.u.def.section;
6442 sec->flags |= SEC_KEEP;
6443 }
6444 }
6445
6446 /* Mark sections containing dynamically referenced symbols. When
6447 building shared libraries, we must assume that any visible symbol is
6448 referenced. */
6449
6450 static bfd_boolean
6451 ppc64_elf_gc_mark_dynamic_ref (struct elf_link_hash_entry *h, void *inf)
6452 {
6453 struct bfd_link_info *info = (struct bfd_link_info *) inf;
6454 struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
6455 struct ppc_link_hash_entry *fdh;
6456 struct bfd_elf_dynamic_list *d = info->dynamic_list;
6457
6458 /* Dynamic linking info is on the func descriptor sym. */
6459 fdh = defined_func_desc (eh);
6460 if (fdh != NULL)
6461 eh = fdh;
6462
6463 if ((eh->elf.root.type == bfd_link_hash_defined
6464 || eh->elf.root.type == bfd_link_hash_defweak)
6465 && ((eh->elf.ref_dynamic && !eh->elf.forced_local)
6466 || ((eh->elf.def_regular || ELF_COMMON_DEF_P (&eh->elf))
6467 && ELF_ST_VISIBILITY (eh->elf.other) != STV_INTERNAL
6468 && ELF_ST_VISIBILITY (eh->elf.other) != STV_HIDDEN
6469 && (!bfd_link_executable (info)
6470 || info->gc_keep_exported
6471 || info->export_dynamic
6472 || (eh->elf.dynamic
6473 && d != NULL
6474 && (*d->match) (&d->head, NULL, eh->elf.root.root.string)))
6475 && (eh->elf.versioned >= versioned
6476 || !bfd_hide_sym_by_version (info->version_info,
6477 eh->elf.root.root.string)))))
6478 {
6479 asection *code_sec;
6480 struct ppc_link_hash_entry *fh;
6481
6482 eh->elf.root.u.def.section->flags |= SEC_KEEP;
6483
6484 /* Function descriptor syms cause the associated
6485 function code sym section to be marked. */
6486 fh = defined_code_entry (eh);
6487 if (fh != NULL)
6488 {
6489 code_sec = fh->elf.root.u.def.section;
6490 code_sec->flags |= SEC_KEEP;
6491 }
6492 else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6493 && opd_entry_value (eh->elf.root.u.def.section,
6494 eh->elf.root.u.def.value,
6495 &code_sec, NULL, FALSE) != (bfd_vma) -1)
6496 code_sec->flags |= SEC_KEEP;
6497 }
6498
6499 return TRUE;
6500 }
6501
6502 /* Return the section that should be marked against GC for a given
6503 relocation. */
6504
6505 static asection *
6506 ppc64_elf_gc_mark_hook (asection *sec,
6507 struct bfd_link_info *info,
6508 Elf_Internal_Rela *rel,
6509 struct elf_link_hash_entry *h,
6510 Elf_Internal_Sym *sym)
6511 {
6512 asection *rsec;
6513
6514 /* Syms return NULL if we're marking .opd, so we avoid marking all
6515 function sections, as all functions are referenced in .opd. */
6516 rsec = NULL;
6517 if (get_opd_info (sec) != NULL)
6518 return rsec;
6519
6520 if (h != NULL)
6521 {
6522 enum elf_ppc64_reloc_type r_type;
6523 struct ppc_link_hash_entry *eh, *fh, *fdh;
6524
6525 r_type = ELF64_R_TYPE (rel->r_info);
6526 switch (r_type)
6527 {
6528 case R_PPC64_GNU_VTINHERIT:
6529 case R_PPC64_GNU_VTENTRY:
6530 break;
6531
6532 default:
6533 switch (h->root.type)
6534 {
6535 case bfd_link_hash_defined:
6536 case bfd_link_hash_defweak:
6537 eh = (struct ppc_link_hash_entry *) h;
6538 fdh = defined_func_desc (eh);
6539 if (fdh != NULL)
6540 {
6541 /* -mcall-aixdesc code references the dot-symbol on
6542 a call reloc. Mark the function descriptor too
6543 against garbage collection. */
6544 fdh->elf.mark = 1;
6545 if (fdh->elf.is_weakalias)
6546 weakdef (&fdh->elf)->mark = 1;
6547 eh = fdh;
6548 }
6549
6550 /* Function descriptor syms cause the associated
6551 function code sym section to be marked. */
6552 fh = defined_code_entry (eh);
6553 if (fh != NULL)
6554 {
6555 /* They also mark their opd section. */
6556 eh->elf.root.u.def.section->gc_mark = 1;
6557
6558 rsec = fh->elf.root.u.def.section;
6559 }
6560 else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6561 && opd_entry_value (eh->elf.root.u.def.section,
6562 eh->elf.root.u.def.value,
6563 &rsec, NULL, FALSE) != (bfd_vma) -1)
6564 eh->elf.root.u.def.section->gc_mark = 1;
6565 else
6566 rsec = h->root.u.def.section;
6567 break;
6568
6569 case bfd_link_hash_common:
6570 rsec = h->root.u.c.p->section;
6571 break;
6572
6573 default:
6574 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
6575 }
6576 }
6577 }
6578 else
6579 {
6580 struct _opd_sec_data *opd;
6581
6582 rsec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
6583 opd = get_opd_info (rsec);
6584 if (opd != NULL && opd->func_sec != NULL)
6585 {
6586 rsec->gc_mark = 1;
6587
6588 rsec = opd->func_sec[OPD_NDX (sym->st_value + rel->r_addend)];
6589 }
6590 }
6591
6592 return rsec;
6593 }
6594
6595 /* The maximum size of .sfpr. */
6596 #define SFPR_MAX (218*4)
6597
6598 struct sfpr_def_parms
6599 {
6600 const char name[12];
6601 unsigned char lo, hi;
6602 bfd_byte * (*write_ent) (bfd *, bfd_byte *, int);
6603 bfd_byte * (*write_tail) (bfd *, bfd_byte *, int);
6604 };
6605
6606 /* Auto-generate _save*, _rest* functions in .sfpr.
6607 If STUB_SEC is non-null, define alias symbols in STUB_SEC
6608 instead. */
6609
6610 static bfd_boolean
6611 sfpr_define (struct bfd_link_info *info,
6612 const struct sfpr_def_parms *parm,
6613 asection *stub_sec)
6614 {
6615 struct ppc_link_hash_table *htab = ppc_hash_table (info);
6616 unsigned int i;
6617 size_t len = strlen (parm->name);
6618 bfd_boolean writing = FALSE;
6619 char sym[16];
6620
6621 if (htab == NULL)
6622 return FALSE;
6623
6624 memcpy (sym, parm->name, len);
6625 sym[len + 2] = 0;
6626
6627 for (i = parm->lo; i <= parm->hi; i++)
6628 {
6629 struct ppc_link_hash_entry *h;
6630
6631 sym[len + 0] = i / 10 + '0';
6632 sym[len + 1] = i % 10 + '0';
6633 h = (struct ppc_link_hash_entry *)
6634 elf_link_hash_lookup (&htab->elf, sym, writing, TRUE, TRUE);
6635 if (stub_sec != NULL)
6636 {
6637 if (h != NULL
6638 && h->elf.root.type == bfd_link_hash_defined
6639 && h->elf.root.u.def.section == htab->sfpr)
6640 {
6641 struct elf_link_hash_entry *s;
6642 char buf[32];
6643 sprintf (buf, "%08x.%s", stub_sec->id & 0xffffffff, sym);
6644 s = elf_link_hash_lookup (&htab->elf, buf, TRUE, TRUE, FALSE);
6645 if (s == NULL)
6646 return FALSE;
6647 if (s->root.type == bfd_link_hash_new
6648 || (s->root.type = bfd_link_hash_defined
6649 && s->root.u.def.section == stub_sec))
6650 {
6651 s->root.type = bfd_link_hash_defined;
6652 s->root.u.def.section = stub_sec;
6653 s->root.u.def.value = (stub_sec->size
6654 + h->elf.root.u.def.value);
6655 s->ref_regular = 1;
6656 s->def_regular = 1;
6657 s->ref_regular_nonweak = 1;
6658 s->forced_local = 1;
6659 s->non_elf = 0;
6660 s->root.linker_def = 1;
6661 }
6662 }
6663 continue;
6664 }
6665 if (h != NULL)
6666 {
6667 h->save_res = 1;
6668 if (!h->elf.def_regular)
6669 {
6670 h->elf.root.type = bfd_link_hash_defined;
6671 h->elf.root.u.def.section = htab->sfpr;
6672 h->elf.root.u.def.value = htab->sfpr->size;
6673 h->elf.type = STT_FUNC;
6674 h->elf.def_regular = 1;
6675 h->elf.non_elf = 0;
6676 _bfd_elf_link_hash_hide_symbol (info, &h->elf, TRUE);
6677 writing = TRUE;
6678 if (htab->sfpr->contents == NULL)
6679 {
6680 htab->sfpr->contents = bfd_alloc (htab->elf.dynobj, SFPR_MAX);
6681 if (htab->sfpr->contents == NULL)
6682 return FALSE;
6683 }
6684 }
6685 }
6686 if (writing)
6687 {
6688 bfd_byte *p = htab->sfpr->contents + htab->sfpr->size;
6689 if (i != parm->hi)
6690 p = (*parm->write_ent) (htab->elf.dynobj, p, i);
6691 else
6692 p = (*parm->write_tail) (htab->elf.dynobj, p, i);
6693 htab->sfpr->size = p - htab->sfpr->contents;
6694 }
6695 }
6696
6697 return TRUE;
6698 }
6699
6700 static bfd_byte *
6701 savegpr0 (bfd *abfd, bfd_byte *p, int r)
6702 {
6703 bfd_put_32 (abfd, STD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6704 return p + 4;
6705 }
6706
6707 static bfd_byte *
6708 savegpr0_tail (bfd *abfd, bfd_byte *p, int r)
6709 {
6710 p = savegpr0 (abfd, p, r);
6711 bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
6712 p = p + 4;
6713 bfd_put_32 (abfd, BLR, p);
6714 return p + 4;
6715 }
6716
6717 static bfd_byte *
6718 restgpr0 (bfd *abfd, bfd_byte *p, int r)
6719 {
6720 bfd_put_32 (abfd, LD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6721 return p + 4;
6722 }
6723
6724 static bfd_byte *
6725 restgpr0_tail (bfd *abfd, bfd_byte *p, int r)
6726 {
6727 bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
6728 p = p + 4;
6729 p = restgpr0 (abfd, p, r);
6730 bfd_put_32 (abfd, MTLR_R0, p);
6731 p = p + 4;
6732 if (r == 29)
6733 {
6734 p = restgpr0 (abfd, p, 30);
6735 p = restgpr0 (abfd, p, 31);
6736 }
6737 bfd_put_32 (abfd, BLR, p);
6738 return p + 4;
6739 }
6740
6741 static bfd_byte *
6742 savegpr1 (bfd *abfd, bfd_byte *p, int r)
6743 {
6744 bfd_put_32 (abfd, STD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6745 return p + 4;
6746 }
6747
6748 static bfd_byte *
6749 savegpr1_tail (bfd *abfd, bfd_byte *p, int r)
6750 {
6751 p = savegpr1 (abfd, p, r);
6752 bfd_put_32 (abfd, BLR, p);
6753 return p + 4;
6754 }
6755
6756 static bfd_byte *
6757 restgpr1 (bfd *abfd, bfd_byte *p, int r)
6758 {
6759 bfd_put_32 (abfd, LD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6760 return p + 4;
6761 }
6762
6763 static bfd_byte *
6764 restgpr1_tail (bfd *abfd, bfd_byte *p, int r)
6765 {
6766 p = restgpr1 (abfd, p, r);
6767 bfd_put_32 (abfd, BLR, p);
6768 return p + 4;
6769 }
6770
6771 static bfd_byte *
6772 savefpr (bfd *abfd, bfd_byte *p, int r)
6773 {
6774 bfd_put_32 (abfd, STFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6775 return p + 4;
6776 }
6777
6778 static bfd_byte *
6779 savefpr0_tail (bfd *abfd, bfd_byte *p, int r)
6780 {
6781 p = savefpr (abfd, p, r);
6782 bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
6783 p = p + 4;
6784 bfd_put_32 (abfd, BLR, p);
6785 return p + 4;
6786 }
6787
6788 static bfd_byte *
6789 restfpr (bfd *abfd, bfd_byte *p, int r)
6790 {
6791 bfd_put_32 (abfd, LFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6792 return p + 4;
6793 }
6794
6795 static bfd_byte *
6796 restfpr0_tail (bfd *abfd, bfd_byte *p, int r)
6797 {
6798 bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
6799 p = p + 4;
6800 p = restfpr (abfd, p, r);
6801 bfd_put_32 (abfd, MTLR_R0, p);
6802 p = p + 4;
6803 if (r == 29)
6804 {
6805 p = restfpr (abfd, p, 30);
6806 p = restfpr (abfd, p, 31);
6807 }
6808 bfd_put_32 (abfd, BLR, p);
6809 return p + 4;
6810 }
6811
6812 static bfd_byte *
6813 savefpr1_tail (bfd *abfd, bfd_byte *p, int r)
6814 {
6815 p = savefpr (abfd, p, r);
6816 bfd_put_32 (abfd, BLR, p);
6817 return p + 4;
6818 }
6819
6820 static bfd_byte *
6821 restfpr1_tail (bfd *abfd, bfd_byte *p, int r)
6822 {
6823 p = restfpr (abfd, p, r);
6824 bfd_put_32 (abfd, BLR, p);
6825 return p + 4;
6826 }
6827
6828 static bfd_byte *
6829 savevr (bfd *abfd, bfd_byte *p, int r)
6830 {
6831 bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6832 p = p + 4;
6833 bfd_put_32 (abfd, STVX_VR0_R12_R0 + (r << 21), p);
6834 return p + 4;
6835 }
6836
6837 static bfd_byte *
6838 savevr_tail (bfd *abfd, bfd_byte *p, int r)
6839 {
6840 p = savevr (abfd, p, r);
6841 bfd_put_32 (abfd, BLR, p);
6842 return p + 4;
6843 }
6844
6845 static bfd_byte *
6846 restvr (bfd *abfd, bfd_byte *p, int r)
6847 {
6848 bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6849 p = p + 4;
6850 bfd_put_32 (abfd, LVX_VR0_R12_R0 + (r << 21), p);
6851 return p + 4;
6852 }
6853
6854 static bfd_byte *
6855 restvr_tail (bfd *abfd, bfd_byte *p, int r)
6856 {
6857 p = restvr (abfd, p, r);
6858 bfd_put_32 (abfd, BLR, p);
6859 return p + 4;
6860 }
6861
6862 /* Called via elf_link_hash_traverse to transfer dynamic linking
6863 information on function code symbol entries to their corresponding
6864 function descriptor symbol entries. */
6865
6866 static bfd_boolean
6867 func_desc_adjust (struct elf_link_hash_entry *h, void *inf)
6868 {
6869 struct bfd_link_info *info;
6870 struct ppc_link_hash_table *htab;
6871 struct ppc_link_hash_entry *fh;
6872 struct ppc_link_hash_entry *fdh;
6873 bfd_boolean force_local;
6874
6875 fh = (struct ppc_link_hash_entry *) h;
6876 if (fh->elf.root.type == bfd_link_hash_indirect)
6877 return TRUE;
6878
6879 if (!fh->is_func)
6880 return TRUE;
6881
6882 if (fh->elf.root.root.string[0] != '.'
6883 || fh->elf.root.root.string[1] == '\0')
6884 return TRUE;
6885
6886 info = inf;
6887 htab = ppc_hash_table (info);
6888 if (htab == NULL)
6889 return FALSE;
6890
6891 /* Find the corresponding function descriptor symbol. */
6892 fdh = lookup_fdh (fh, htab);
6893
6894 /* Resolve undefined references to dot-symbols as the value
6895 in the function descriptor, if we have one in a regular object.
6896 This is to satisfy cases like ".quad .foo". Calls to functions
6897 in dynamic objects are handled elsewhere. */
6898 if ((fh->elf.root.type == bfd_link_hash_undefined
6899 || fh->elf.root.type == bfd_link_hash_undefweak)
6900 && (fdh->elf.root.type == bfd_link_hash_defined
6901 || fdh->elf.root.type == bfd_link_hash_defweak)
6902 && get_opd_info (fdh->elf.root.u.def.section) != NULL
6903 && opd_entry_value (fdh->elf.root.u.def.section,
6904 fdh->elf.root.u.def.value,
6905 &fh->elf.root.u.def.section,
6906 &fh->elf.root.u.def.value, FALSE) != (bfd_vma) -1)
6907 {
6908 fh->elf.root.type = fdh->elf.root.type;
6909 fh->elf.forced_local = 1;
6910 fh->elf.def_regular = fdh->elf.def_regular;
6911 fh->elf.def_dynamic = fdh->elf.def_dynamic;
6912 }
6913
6914 if (!fh->elf.dynamic)
6915 {
6916 struct plt_entry *ent;
6917
6918 for (ent = fh->elf.plt.plist; ent != NULL; ent = ent->next)
6919 if (ent->plt.refcount > 0)
6920 break;
6921 if (ent == NULL)
6922 return TRUE;
6923 }
6924
6925 /* Create a descriptor as undefined if necessary. */
6926 if (fdh == NULL
6927 && !bfd_link_executable (info)
6928 && (fh->elf.root.type == bfd_link_hash_undefined
6929 || fh->elf.root.type == bfd_link_hash_undefweak))
6930 {
6931 fdh = make_fdh (info, fh);
6932 if (fdh == NULL)
6933 return FALSE;
6934 }
6935
6936 /* We can't support overriding of symbols on a fake descriptor. */
6937 if (fdh != NULL
6938 && fdh->fake
6939 && (fh->elf.root.type == bfd_link_hash_defined
6940 || fh->elf.root.type == bfd_link_hash_defweak))
6941 _bfd_elf_link_hash_hide_symbol (info, &fdh->elf, TRUE);
6942
6943 /* Transfer dynamic linking information to the function descriptor. */
6944 if (fdh != NULL)
6945 {
6946 fdh->elf.ref_regular |= fh->elf.ref_regular;
6947 fdh->elf.ref_dynamic |= fh->elf.ref_dynamic;
6948 fdh->elf.ref_regular_nonweak |= fh->elf.ref_regular_nonweak;
6949 fdh->elf.non_got_ref |= fh->elf.non_got_ref;
6950 fdh->elf.dynamic |= fh->elf.dynamic;
6951 fdh->elf.needs_plt |= (fh->elf.needs_plt
6952 || fh->elf.type == STT_FUNC
6953 || fh->elf.type == STT_GNU_IFUNC);
6954 move_plt_plist (fh, fdh);
6955
6956 if (!fdh->elf.forced_local
6957 && fh->elf.dynindx != -1)
6958 if (!bfd_elf_link_record_dynamic_symbol (info, &fdh->elf))
6959 return FALSE;
6960 }
6961
6962 /* Now that the info is on the function descriptor, clear the
6963 function code sym info. Any function code syms for which we
6964 don't have a definition in a regular file, we force local.
6965 This prevents a shared library from exporting syms that have
6966 been imported from another library. Function code syms that
6967 are really in the library we must leave global to prevent the
6968 linker dragging in a definition from a static library. */
6969 force_local = (!fh->elf.def_regular
6970 || fdh == NULL
6971 || !fdh->elf.def_regular
6972 || fdh->elf.forced_local);
6973 _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
6974
6975 return TRUE;
6976 }
6977
6978 static const struct sfpr_def_parms save_res_funcs[] =
6979 {
6980 { "_savegpr0_", 14, 31, savegpr0, savegpr0_tail },
6981 { "_restgpr0_", 14, 29, restgpr0, restgpr0_tail },
6982 { "_restgpr0_", 30, 31, restgpr0, restgpr0_tail },
6983 { "_savegpr1_", 14, 31, savegpr1, savegpr1_tail },
6984 { "_restgpr1_", 14, 31, restgpr1, restgpr1_tail },
6985 { "_savefpr_", 14, 31, savefpr, savefpr0_tail },
6986 { "_restfpr_", 14, 29, restfpr, restfpr0_tail },
6987 { "_restfpr_", 30, 31, restfpr, restfpr0_tail },
6988 { "._savef", 14, 31, savefpr, savefpr1_tail },
6989 { "._restf", 14, 31, restfpr, restfpr1_tail },
6990 { "_savevr_", 20, 31, savevr, savevr_tail },
6991 { "_restvr_", 20, 31, restvr, restvr_tail }
6992 };
6993
6994 /* Called near the start of bfd_elf_size_dynamic_sections. We use
6995 this hook to a) provide some gcc support functions, and b) transfer
6996 dynamic linking information gathered so far on function code symbol
6997 entries, to their corresponding function descriptor symbol entries. */
6998
6999 static bfd_boolean
7000 ppc64_elf_func_desc_adjust (bfd *obfd ATTRIBUTE_UNUSED,
7001 struct bfd_link_info *info)
7002 {
7003 struct ppc_link_hash_table *htab;
7004
7005 htab = ppc_hash_table (info);
7006 if (htab == NULL)
7007 return FALSE;
7008
7009 /* Provide any missing _save* and _rest* functions. */
7010 if (htab->sfpr != NULL)
7011 {
7012 unsigned int i;
7013
7014 htab->sfpr->size = 0;
7015 for (i = 0; i < ARRAY_SIZE (save_res_funcs); i++)
7016 if (!sfpr_define (info, &save_res_funcs[i], NULL))
7017 return FALSE;
7018 if (htab->sfpr->size == 0)
7019 htab->sfpr->flags |= SEC_EXCLUDE;
7020 }
7021
7022 if (bfd_link_relocatable (info))
7023 return TRUE;
7024
7025 if (htab->elf.hgot != NULL)
7026 {
7027 _bfd_elf_link_hash_hide_symbol (info, htab->elf.hgot, TRUE);
7028 /* Make .TOC. defined so as to prevent it being made dynamic.
7029 The wrong value here is fixed later in ppc64_elf_set_toc. */
7030 if (!htab->elf.hgot->def_regular
7031 || htab->elf.hgot->root.type != bfd_link_hash_defined)
7032 {
7033 htab->elf.hgot->root.type = bfd_link_hash_defined;
7034 htab->elf.hgot->root.u.def.value = 0;
7035 htab->elf.hgot->root.u.def.section = bfd_abs_section_ptr;
7036 htab->elf.hgot->def_regular = 1;
7037 htab->elf.hgot->root.linker_def = 1;
7038 }
7039 htab->elf.hgot->type = STT_OBJECT;
7040 htab->elf.hgot->other = ((htab->elf.hgot->other & ~ELF_ST_VISIBILITY (-1))
7041 | STV_HIDDEN);
7042 }
7043
7044 if (htab->need_func_desc_adj)
7045 {
7046 elf_link_hash_traverse (&htab->elf, func_desc_adjust, info);
7047 htab->need_func_desc_adj = 0;
7048 }
7049
7050 return TRUE;
7051 }
7052
7053 /* Find dynamic relocs for H that apply to read-only sections. */
7054
7055 static asection *
7056 readonly_dynrelocs (struct elf_link_hash_entry *h)
7057 {
7058 struct ppc_link_hash_entry *eh;
7059 struct elf_dyn_relocs *p;
7060
7061 eh = (struct ppc_link_hash_entry *) h;
7062 for (p = eh->dyn_relocs; p != NULL; p = p->next)
7063 {
7064 asection *s = p->sec->output_section;
7065
7066 if (s != NULL && (s->flags & SEC_READONLY) != 0)
7067 return p->sec;
7068 }
7069 return NULL;
7070 }
7071
7072 /* Return true if we have dynamic relocs against H or any of its weak
7073 aliases, that apply to read-only sections. Cannot be used after
7074 size_dynamic_sections. */
7075
7076 static bfd_boolean
7077 alias_readonly_dynrelocs (struct elf_link_hash_entry *h)
7078 {
7079 struct ppc_link_hash_entry *eh;
7080
7081 eh = (struct ppc_link_hash_entry *) h;
7082 do
7083 {
7084 if (readonly_dynrelocs (&eh->elf))
7085 return TRUE;
7086 eh = (struct ppc_link_hash_entry *) eh->elf.u.alias;
7087 } while (eh != NULL && &eh->elf != h);
7088
7089 return FALSE;
7090 }
7091
7092 /* Return whether EH has pc-relative dynamic relocs. */
7093
7094 static bfd_boolean
7095 pc_dynrelocs (struct ppc_link_hash_entry *eh)
7096 {
7097 struct elf_dyn_relocs *p;
7098
7099 for (p = eh->dyn_relocs; p != NULL; p = p->next)
7100 if (p->pc_count != 0)
7101 return TRUE;
7102 return FALSE;
7103 }
7104
7105 /* Return true if a global entry stub will be created for H. Valid
7106 for ELFv2 before plt entries have been allocated. */
7107
7108 static bfd_boolean
7109 global_entry_stub (struct elf_link_hash_entry *h)
7110 {
7111 struct plt_entry *pent;
7112
7113 if (!h->pointer_equality_needed
7114 || h->def_regular)
7115 return FALSE;
7116
7117 for (pent = h->plt.plist; pent != NULL; pent = pent->next)
7118 if (pent->plt.refcount > 0
7119 && pent->addend == 0)
7120 return TRUE;
7121
7122 return FALSE;
7123 }
7124
7125 /* Adjust a symbol defined by a dynamic object and referenced by a
7126 regular object. The current definition is in some section of the
7127 dynamic object, but we're not including those sections. We have to
7128 change the definition to something the rest of the link can
7129 understand. */
7130
7131 static bfd_boolean
7132 ppc64_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
7133 struct elf_link_hash_entry *h)
7134 {
7135 struct ppc_link_hash_table *htab;
7136 asection *s, *srel;
7137
7138 htab = ppc_hash_table (info);
7139 if (htab == NULL)
7140 return FALSE;
7141
7142 /* Deal with function syms. */
7143 if (h->type == STT_FUNC
7144 || h->type == STT_GNU_IFUNC
7145 || h->needs_plt)
7146 {
7147 bfd_boolean local = (((struct ppc_link_hash_entry *) h)->save_res
7148 || SYMBOL_CALLS_LOCAL (info, h)
7149 || UNDEFWEAK_NO_DYNAMIC_RELOC (info, h));
7150 /* Discard dyn_relocs when non-pic if we've decided that a
7151 function symbol is local and not an ifunc. We keep dynamic
7152 relocs for ifuncs when local rather than always emitting a
7153 plt call stub for them and defining the symbol on the call
7154 stub. We can't do that for ELFv1 anyway (a function symbol
7155 is defined on a descriptor, not code) and it can be faster at
7156 run-time due to not needing to bounce through a stub. The
7157 dyn_relocs for ifuncs will be applied even in a static
7158 executable. */
7159 if (!bfd_link_pic (info)
7160 && h->type != STT_GNU_IFUNC
7161 && local)
7162 ((struct ppc_link_hash_entry *) h)->dyn_relocs = NULL;
7163
7164 /* Clear procedure linkage table information for any symbol that
7165 won't need a .plt entry. */
7166 struct plt_entry *ent;
7167 for (ent = h->plt.plist; ent != NULL; ent = ent->next)
7168 if (ent->plt.refcount > 0)
7169 break;
7170 if (ent == NULL
7171 || (h->type != STT_GNU_IFUNC && local))
7172 {
7173 h->plt.plist = NULL;
7174 h->needs_plt = 0;
7175 h->pointer_equality_needed = 0;
7176 }
7177 else if (abiversion (info->output_bfd) >= 2)
7178 {
7179 /* Taking a function's address in a read/write section
7180 doesn't require us to define the function symbol in the
7181 executable on a global entry stub. A dynamic reloc can
7182 be used instead. The reason we prefer a few more dynamic
7183 relocs is that calling via a global entry stub costs a
7184 few more instructions, and pointer_equality_needed causes
7185 extra work in ld.so when resolving these symbols. */
7186 if (global_entry_stub (h))
7187 {
7188 if (!readonly_dynrelocs (h))
7189 {
7190 h->pointer_equality_needed = 0;
7191 /* If we haven't seen a branch reloc then we don't need
7192 a plt entry. */
7193 if (!h->needs_plt)
7194 h->plt.plist = NULL;
7195 }
7196 else if (!bfd_link_pic (info))
7197 /* We are going to be defining the function symbol on the
7198 plt stub, so no dyn_relocs needed when non-pic. */
7199 ((struct ppc_link_hash_entry *) h)->dyn_relocs = NULL;
7200 }
7201
7202 /* ELFv2 function symbols can't have copy relocs. */
7203 return TRUE;
7204 }
7205 else if (!h->needs_plt
7206 && !readonly_dynrelocs (h))
7207 {
7208 /* If we haven't seen a branch reloc then we don't need a
7209 plt entry. */
7210 h->plt.plist = NULL;
7211 h->pointer_equality_needed = 0;
7212 return TRUE;
7213 }
7214 }
7215 else
7216 h->plt.plist = NULL;
7217
7218 /* If this is a weak symbol, and there is a real definition, the
7219 processor independent code will have arranged for us to see the
7220 real definition first, and we can just use the same value. */
7221 if (h->is_weakalias)
7222 {
7223 struct elf_link_hash_entry *def = weakdef (h);
7224 BFD_ASSERT (def->root.type == bfd_link_hash_defined);
7225 h->root.u.def.section = def->root.u.def.section;
7226 h->root.u.def.value = def->root.u.def.value;
7227 if (def->root.u.def.section == htab->elf.sdynbss
7228 || def->root.u.def.section == htab->elf.sdynrelro)
7229 ((struct ppc_link_hash_entry *) h)->dyn_relocs = NULL;
7230 return TRUE;
7231 }
7232
7233 /* If we are creating a shared library, we must presume that the
7234 only references to the symbol are via the global offset table.
7235 For such cases we need not do anything here; the relocations will
7236 be handled correctly by relocate_section. */
7237 if (bfd_link_pic (info))
7238 return TRUE;
7239
7240 /* If there are no references to this symbol that do not use the
7241 GOT, we don't need to generate a copy reloc. */
7242 if (!h->non_got_ref)
7243 return TRUE;
7244
7245 /* Don't generate a copy reloc for symbols defined in the executable. */
7246 if (!h->def_dynamic || !h->ref_regular || h->def_regular
7247
7248 /* If -z nocopyreloc was given, don't generate them either. */
7249 || info->nocopyreloc
7250
7251 /* If we don't find any dynamic relocs in read-only sections, then
7252 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
7253 || (ELIMINATE_COPY_RELOCS && !alias_readonly_dynrelocs (h))
7254
7255 /* Protected variables do not work with .dynbss. The copy in
7256 .dynbss won't be used by the shared library with the protected
7257 definition for the variable. Text relocations are preferable
7258 to an incorrect program. */
7259 || h->protected_def)
7260 return TRUE;
7261
7262 if (h->plt.plist != NULL)
7263 {
7264 /* We should never get here, but unfortunately there are versions
7265 of gcc out there that improperly (for this ABI) put initialized
7266 function pointers, vtable refs and suchlike in read-only
7267 sections. Allow them to proceed, but warn that this might
7268 break at runtime. */
7269 info->callbacks->einfo
7270 (_("%P: copy reloc against `%T' requires lazy plt linking; "
7271 "avoid setting LD_BIND_NOW=1 or upgrade gcc\n"),
7272 h->root.root.string);
7273 }
7274
7275 /* This is a reference to a symbol defined by a dynamic object which
7276 is not a function. */
7277
7278 /* We must allocate the symbol in our .dynbss section, which will
7279 become part of the .bss section of the executable. There will be
7280 an entry for this symbol in the .dynsym section. The dynamic
7281 object will contain position independent code, so all references
7282 from the dynamic object to this symbol will go through the global
7283 offset table. The dynamic linker will use the .dynsym entry to
7284 determine the address it must put in the global offset table, so
7285 both the dynamic object and the regular object will refer to the
7286 same memory location for the variable. */
7287 if ((h->root.u.def.section->flags & SEC_READONLY) != 0)
7288 {
7289 s = htab->elf.sdynrelro;
7290 srel = htab->elf.sreldynrelro;
7291 }
7292 else
7293 {
7294 s = htab->elf.sdynbss;
7295 srel = htab->elf.srelbss;
7296 }
7297 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
7298 {
7299 /* We must generate a R_PPC64_COPY reloc to tell the dynamic
7300 linker to copy the initial value out of the dynamic object
7301 and into the runtime process image. */
7302 srel->size += sizeof (Elf64_External_Rela);
7303 h->needs_copy = 1;
7304 }
7305
7306 /* We no longer want dyn_relocs. */
7307 ((struct ppc_link_hash_entry *) h)->dyn_relocs = NULL;
7308 return _bfd_elf_adjust_dynamic_copy (info, h, s);
7309 }
7310
7311 /* If given a function descriptor symbol, hide both the function code
7312 sym and the descriptor. */
7313 static void
7314 ppc64_elf_hide_symbol (struct bfd_link_info *info,
7315 struct elf_link_hash_entry *h,
7316 bfd_boolean force_local)
7317 {
7318 struct ppc_link_hash_entry *eh;
7319 _bfd_elf_link_hash_hide_symbol (info, h, force_local);
7320
7321 eh = (struct ppc_link_hash_entry *) h;
7322 if (eh->is_func_descriptor)
7323 {
7324 struct ppc_link_hash_entry *fh = eh->oh;
7325
7326 if (fh == NULL)
7327 {
7328 const char *p, *q;
7329 struct elf_link_hash_table *htab = elf_hash_table (info);
7330 char save;
7331
7332 /* We aren't supposed to use alloca in BFD because on
7333 systems which do not have alloca the version in libiberty
7334 calls xmalloc, which might cause the program to crash
7335 when it runs out of memory. This function doesn't have a
7336 return status, so there's no way to gracefully return an
7337 error. So cheat. We know that string[-1] can be safely
7338 accessed; It's either a string in an ELF string table,
7339 or allocated in an objalloc structure. */
7340
7341 p = eh->elf.root.root.string - 1;
7342 save = *p;
7343 *(char *) p = '.';
7344 fh = (struct ppc_link_hash_entry *)
7345 elf_link_hash_lookup (htab, p, FALSE, FALSE, FALSE);
7346 *(char *) p = save;
7347
7348 /* Unfortunately, if it so happens that the string we were
7349 looking for was allocated immediately before this string,
7350 then we overwrote the string terminator. That's the only
7351 reason the lookup should fail. */
7352 if (fh == NULL)
7353 {
7354 q = eh->elf.root.root.string + strlen (eh->elf.root.root.string);
7355 while (q >= eh->elf.root.root.string && *q == *p)
7356 --q, --p;
7357 if (q < eh->elf.root.root.string && *p == '.')
7358 fh = (struct ppc_link_hash_entry *)
7359 elf_link_hash_lookup (htab, p, FALSE, FALSE, FALSE);
7360 }
7361 if (fh != NULL)
7362 {
7363 eh->oh = fh;
7364 fh->oh = eh;
7365 }
7366 }
7367 if (fh != NULL)
7368 _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
7369 }
7370 }
7371
7372 static bfd_boolean
7373 get_sym_h (struct elf_link_hash_entry **hp,
7374 Elf_Internal_Sym **symp,
7375 asection **symsecp,
7376 unsigned char **tls_maskp,
7377 Elf_Internal_Sym **locsymsp,
7378 unsigned long r_symndx,
7379 bfd *ibfd)
7380 {
7381 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
7382
7383 if (r_symndx >= symtab_hdr->sh_info)
7384 {
7385 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
7386 struct elf_link_hash_entry *h;
7387
7388 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
7389 h = elf_follow_link (h);
7390
7391 if (hp != NULL)
7392 *hp = h;
7393
7394 if (symp != NULL)
7395 *symp = NULL;
7396
7397 if (symsecp != NULL)
7398 {
7399 asection *symsec = NULL;
7400 if (h->root.type == bfd_link_hash_defined
7401 || h->root.type == bfd_link_hash_defweak)
7402 symsec = h->root.u.def.section;
7403 *symsecp = symsec;
7404 }
7405
7406 if (tls_maskp != NULL)
7407 {
7408 struct ppc_link_hash_entry *eh;
7409
7410 eh = (struct ppc_link_hash_entry *) h;
7411 *tls_maskp = &eh->tls_mask;
7412 }
7413 }
7414 else
7415 {
7416 Elf_Internal_Sym *sym;
7417 Elf_Internal_Sym *locsyms = *locsymsp;
7418
7419 if (locsyms == NULL)
7420 {
7421 locsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
7422 if (locsyms == NULL)
7423 locsyms = bfd_elf_get_elf_syms (ibfd, symtab_hdr,
7424 symtab_hdr->sh_info,
7425 0, NULL, NULL, NULL);
7426 if (locsyms == NULL)
7427 return FALSE;
7428 *locsymsp = locsyms;
7429 }
7430 sym = locsyms + r_symndx;
7431
7432 if (hp != NULL)
7433 *hp = NULL;
7434
7435 if (symp != NULL)
7436 *symp = sym;
7437
7438 if (symsecp != NULL)
7439 *symsecp = bfd_section_from_elf_index (ibfd, sym->st_shndx);
7440
7441 if (tls_maskp != NULL)
7442 {
7443 struct got_entry **lgot_ents;
7444 unsigned char *tls_mask;
7445
7446 tls_mask = NULL;
7447 lgot_ents = elf_local_got_ents (ibfd);
7448 if (lgot_ents != NULL)
7449 {
7450 struct plt_entry **local_plt = (struct plt_entry **)
7451 (lgot_ents + symtab_hdr->sh_info);
7452 unsigned char *lgot_masks = (unsigned char *)
7453 (local_plt + symtab_hdr->sh_info);
7454 tls_mask = &lgot_masks[r_symndx];
7455 }
7456 *tls_maskp = tls_mask;
7457 }
7458 }
7459 return TRUE;
7460 }
7461
7462 /* Returns TLS_MASKP for the given REL symbol. Function return is 0 on
7463 error, 2 on a toc GD type suitable for optimization, 3 on a toc LD
7464 type suitable for optimization, and 1 otherwise. */
7465
7466 static int
7467 get_tls_mask (unsigned char **tls_maskp,
7468 unsigned long *toc_symndx,
7469 bfd_vma *toc_addend,
7470 Elf_Internal_Sym **locsymsp,
7471 const Elf_Internal_Rela *rel,
7472 bfd *ibfd)
7473 {
7474 unsigned long r_symndx;
7475 int next_r;
7476 struct elf_link_hash_entry *h;
7477 Elf_Internal_Sym *sym;
7478 asection *sec;
7479 bfd_vma off;
7480
7481 r_symndx = ELF64_R_SYM (rel->r_info);
7482 if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7483 return 0;
7484
7485 if ((*tls_maskp != NULL && **tls_maskp != 0)
7486 || sec == NULL
7487 || ppc64_elf_section_data (sec) == NULL
7488 || ppc64_elf_section_data (sec)->sec_type != sec_toc)
7489 return 1;
7490
7491 /* Look inside a TOC section too. */
7492 if (h != NULL)
7493 {
7494 BFD_ASSERT (h->root.type == bfd_link_hash_defined);
7495 off = h->root.u.def.value;
7496 }
7497 else
7498 off = sym->st_value;
7499 off += rel->r_addend;
7500 BFD_ASSERT (off % 8 == 0);
7501 r_symndx = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8];
7502 next_r = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8 + 1];
7503 if (toc_symndx != NULL)
7504 *toc_symndx = r_symndx;
7505 if (toc_addend != NULL)
7506 *toc_addend = ppc64_elf_section_data (sec)->u.toc.add[off / 8];
7507 if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7508 return 0;
7509 if ((h == NULL || is_static_defined (h))
7510 && (next_r == -1 || next_r == -2))
7511 return 1 - next_r;
7512 return 1;
7513 }
7514
7515 /* Find (or create) an entry in the tocsave hash table. */
7516
7517 static struct tocsave_entry *
7518 tocsave_find (struct ppc_link_hash_table *htab,
7519 enum insert_option insert,
7520 Elf_Internal_Sym **local_syms,
7521 const Elf_Internal_Rela *irela,
7522 bfd *ibfd)
7523 {
7524 unsigned long r_indx;
7525 struct elf_link_hash_entry *h;
7526 Elf_Internal_Sym *sym;
7527 struct tocsave_entry ent, *p;
7528 hashval_t hash;
7529 struct tocsave_entry **slot;
7530
7531 r_indx = ELF64_R_SYM (irela->r_info);
7532 if (!get_sym_h (&h, &sym, &ent.sec, NULL, local_syms, r_indx, ibfd))
7533 return NULL;
7534 if (ent.sec == NULL || ent.sec->output_section == NULL)
7535 {
7536 _bfd_error_handler
7537 (_("%B: undefined symbol on R_PPC64_TOCSAVE relocation"), ibfd);
7538 return NULL;
7539 }
7540
7541 if (h != NULL)
7542 ent.offset = h->root.u.def.value;
7543 else
7544 ent.offset = sym->st_value;
7545 ent.offset += irela->r_addend;
7546
7547 hash = tocsave_htab_hash (&ent);
7548 slot = ((struct tocsave_entry **)
7549 htab_find_slot_with_hash (htab->tocsave_htab, &ent, hash, insert));
7550 if (slot == NULL)
7551 return NULL;
7552
7553 if (*slot == NULL)
7554 {
7555 p = (struct tocsave_entry *) bfd_alloc (ibfd, sizeof (*p));
7556 if (p == NULL)
7557 return NULL;
7558 *p = ent;
7559 *slot = p;
7560 }
7561 return *slot;
7562 }
7563
7564 /* Adjust all global syms defined in opd sections. In gcc generated
7565 code for the old ABI, these will already have been done. */
7566
7567 static bfd_boolean
7568 adjust_opd_syms (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
7569 {
7570 struct ppc_link_hash_entry *eh;
7571 asection *sym_sec;
7572 struct _opd_sec_data *opd;
7573
7574 if (h->root.type == bfd_link_hash_indirect)
7575 return TRUE;
7576
7577 if (h->root.type != bfd_link_hash_defined
7578 && h->root.type != bfd_link_hash_defweak)
7579 return TRUE;
7580
7581 eh = (struct ppc_link_hash_entry *) h;
7582 if (eh->adjust_done)
7583 return TRUE;
7584
7585 sym_sec = eh->elf.root.u.def.section;
7586 opd = get_opd_info (sym_sec);
7587 if (opd != NULL && opd->adjust != NULL)
7588 {
7589 long adjust = opd->adjust[OPD_NDX (eh->elf.root.u.def.value)];
7590 if (adjust == -1)
7591 {
7592 /* This entry has been deleted. */
7593 asection *dsec = ppc64_elf_tdata (sym_sec->owner)->deleted_section;
7594 if (dsec == NULL)
7595 {
7596 for (dsec = sym_sec->owner->sections; dsec; dsec = dsec->next)
7597 if (discarded_section (dsec))
7598 {
7599 ppc64_elf_tdata (sym_sec->owner)->deleted_section = dsec;
7600 break;
7601 }
7602 }
7603 eh->elf.root.u.def.value = 0;
7604 eh->elf.root.u.def.section = dsec;
7605 }
7606 else
7607 eh->elf.root.u.def.value += adjust;
7608 eh->adjust_done = 1;
7609 }
7610 return TRUE;
7611 }
7612
7613 /* Handles decrementing dynamic reloc counts for the reloc specified by
7614 R_INFO in section SEC. If LOCAL_SYMS is NULL, then H and SYM
7615 have already been determined. */
7616
7617 static bfd_boolean
7618 dec_dynrel_count (bfd_vma r_info,
7619 asection *sec,
7620 struct bfd_link_info *info,
7621 Elf_Internal_Sym **local_syms,
7622 struct elf_link_hash_entry *h,
7623 Elf_Internal_Sym *sym)
7624 {
7625 enum elf_ppc64_reloc_type r_type;
7626 asection *sym_sec = NULL;
7627
7628 /* Can this reloc be dynamic? This switch, and later tests here
7629 should be kept in sync with the code in check_relocs. */
7630 r_type = ELF64_R_TYPE (r_info);
7631 switch (r_type)
7632 {
7633 default:
7634 return TRUE;
7635
7636 case R_PPC64_TPREL16:
7637 case R_PPC64_TPREL16_LO:
7638 case R_PPC64_TPREL16_HI:
7639 case R_PPC64_TPREL16_HA:
7640 case R_PPC64_TPREL16_DS:
7641 case R_PPC64_TPREL16_LO_DS:
7642 case R_PPC64_TPREL16_HIGH:
7643 case R_PPC64_TPREL16_HIGHA:
7644 case R_PPC64_TPREL16_HIGHER:
7645 case R_PPC64_TPREL16_HIGHERA:
7646 case R_PPC64_TPREL16_HIGHEST:
7647 case R_PPC64_TPREL16_HIGHESTA:
7648 case R_PPC64_TPREL64:
7649 case R_PPC64_DTPMOD64:
7650 case R_PPC64_DTPREL64:
7651 case R_PPC64_ADDR64:
7652 case R_PPC64_REL30:
7653 case R_PPC64_REL32:
7654 case R_PPC64_REL64:
7655 case R_PPC64_ADDR14:
7656 case R_PPC64_ADDR14_BRNTAKEN:
7657 case R_PPC64_ADDR14_BRTAKEN:
7658 case R_PPC64_ADDR16:
7659 case R_PPC64_ADDR16_DS:
7660 case R_PPC64_ADDR16_HA:
7661 case R_PPC64_ADDR16_HI:
7662 case R_PPC64_ADDR16_HIGH:
7663 case R_PPC64_ADDR16_HIGHA:
7664 case R_PPC64_ADDR16_HIGHER:
7665 case R_PPC64_ADDR16_HIGHERA:
7666 case R_PPC64_ADDR16_HIGHEST:
7667 case R_PPC64_ADDR16_HIGHESTA:
7668 case R_PPC64_ADDR16_LO:
7669 case R_PPC64_ADDR16_LO_DS:
7670 case R_PPC64_ADDR24:
7671 case R_PPC64_ADDR32:
7672 case R_PPC64_UADDR16:
7673 case R_PPC64_UADDR32:
7674 case R_PPC64_UADDR64:
7675 case R_PPC64_TOC:
7676 break;
7677 }
7678
7679 if (local_syms != NULL)
7680 {
7681 unsigned long r_symndx;
7682 bfd *ibfd = sec->owner;
7683
7684 r_symndx = ELF64_R_SYM (r_info);
7685 if (!get_sym_h (&h, &sym, &sym_sec, NULL, local_syms, r_symndx, ibfd))
7686 return FALSE;
7687 }
7688
7689 if ((bfd_link_pic (info)
7690 && (must_be_dyn_reloc (info, r_type)
7691 || (h != NULL
7692 && (!SYMBOLIC_BIND (info, h)
7693 || h->root.type == bfd_link_hash_defweak
7694 || !h->def_regular))))
7695 || (ELIMINATE_COPY_RELOCS
7696 && !bfd_link_pic (info)
7697 && h != NULL
7698 && (h->root.type == bfd_link_hash_defweak
7699 || !h->def_regular)))
7700 ;
7701 else
7702 return TRUE;
7703
7704 if (h != NULL)
7705 {
7706 struct elf_dyn_relocs *p;
7707 struct elf_dyn_relocs **pp;
7708 pp = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
7709
7710 /* elf_gc_sweep may have already removed all dyn relocs associated
7711 with local syms for a given section. Also, symbol flags are
7712 changed by elf_gc_sweep_symbol, confusing the test above. Don't
7713 report a dynreloc miscount. */
7714 if (*pp == NULL && info->gc_sections)
7715 return TRUE;
7716
7717 while ((p = *pp) != NULL)
7718 {
7719 if (p->sec == sec)
7720 {
7721 if (!must_be_dyn_reloc (info, r_type))
7722 p->pc_count -= 1;
7723 p->count -= 1;
7724 if (p->count == 0)
7725 *pp = p->next;
7726 return TRUE;
7727 }
7728 pp = &p->next;
7729 }
7730 }
7731 else
7732 {
7733 struct ppc_dyn_relocs *p;
7734 struct ppc_dyn_relocs **pp;
7735 void *vpp;
7736 bfd_boolean is_ifunc;
7737
7738 if (local_syms == NULL)
7739 sym_sec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
7740 if (sym_sec == NULL)
7741 sym_sec = sec;
7742
7743 vpp = &elf_section_data (sym_sec)->local_dynrel;
7744 pp = (struct ppc_dyn_relocs **) vpp;
7745
7746 if (*pp == NULL && info->gc_sections)
7747 return TRUE;
7748
7749 is_ifunc = ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC;
7750 while ((p = *pp) != NULL)
7751 {
7752 if (p->sec == sec && p->ifunc == is_ifunc)
7753 {
7754 p->count -= 1;
7755 if (p->count == 0)
7756 *pp = p->next;
7757 return TRUE;
7758 }
7759 pp = &p->next;
7760 }
7761 }
7762
7763 /* xgettext:c-format */
7764 info->callbacks->einfo (_("%P: dynreloc miscount for %B, section %A\n"),
7765 sec->owner, sec);
7766 bfd_set_error (bfd_error_bad_value);
7767 return FALSE;
7768 }
7769
7770 /* Remove unused Official Procedure Descriptor entries. Currently we
7771 only remove those associated with functions in discarded link-once
7772 sections, or weakly defined functions that have been overridden. It
7773 would be possible to remove many more entries for statically linked
7774 applications. */
7775
7776 bfd_boolean
7777 ppc64_elf_edit_opd (struct bfd_link_info *info)
7778 {
7779 bfd *ibfd;
7780 bfd_boolean some_edited = FALSE;
7781 asection *need_pad = NULL;
7782 struct ppc_link_hash_table *htab;
7783
7784 htab = ppc_hash_table (info);
7785 if (htab == NULL)
7786 return FALSE;
7787
7788 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
7789 {
7790 asection *sec;
7791 Elf_Internal_Rela *relstart, *rel, *relend;
7792 Elf_Internal_Shdr *symtab_hdr;
7793 Elf_Internal_Sym *local_syms;
7794 struct _opd_sec_data *opd;
7795 bfd_boolean need_edit, add_aux_fields, broken;
7796 bfd_size_type cnt_16b = 0;
7797
7798 if (!is_ppc64_elf (ibfd))
7799 continue;
7800
7801 sec = bfd_get_section_by_name (ibfd, ".opd");
7802 if (sec == NULL || sec->size == 0)
7803 continue;
7804
7805 if (sec->sec_info_type == SEC_INFO_TYPE_JUST_SYMS)
7806 continue;
7807
7808 if (sec->output_section == bfd_abs_section_ptr)
7809 continue;
7810
7811 /* Look through the section relocs. */
7812 if ((sec->flags & SEC_RELOC) == 0 || sec->reloc_count == 0)
7813 continue;
7814
7815 local_syms = NULL;
7816 symtab_hdr = &elf_symtab_hdr (ibfd);
7817
7818 /* Read the relocations. */
7819 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
7820 info->keep_memory);
7821 if (relstart == NULL)
7822 return FALSE;
7823
7824 /* First run through the relocs to check they are sane, and to
7825 determine whether we need to edit this opd section. */
7826 need_edit = FALSE;
7827 broken = FALSE;
7828 need_pad = sec;
7829 relend = relstart + sec->reloc_count;
7830 for (rel = relstart; rel < relend; )
7831 {
7832 enum elf_ppc64_reloc_type r_type;
7833 unsigned long r_symndx;
7834 asection *sym_sec;
7835 struct elf_link_hash_entry *h;
7836 Elf_Internal_Sym *sym;
7837 bfd_vma offset;
7838
7839 /* .opd contains an array of 16 or 24 byte entries. We're
7840 only interested in the reloc pointing to a function entry
7841 point. */
7842 offset = rel->r_offset;
7843 if (rel + 1 == relend
7844 || rel[1].r_offset != offset + 8)
7845 {
7846 /* If someone messes with .opd alignment then after a
7847 "ld -r" we might have padding in the middle of .opd.
7848 Also, there's nothing to prevent someone putting
7849 something silly in .opd with the assembler. No .opd
7850 optimization for them! */
7851 broken_opd:
7852 _bfd_error_handler
7853 (_("%B: .opd is not a regular array of opd entries"), ibfd);
7854 broken = TRUE;
7855 break;
7856 }
7857
7858 if ((r_type = ELF64_R_TYPE (rel->r_info)) != R_PPC64_ADDR64
7859 || (r_type = ELF64_R_TYPE ((rel + 1)->r_info)) != R_PPC64_TOC)
7860 {
7861 _bfd_error_handler
7862 /* xgettext:c-format */
7863 (_("%B: unexpected reloc type %u in .opd section"),
7864 ibfd, r_type);
7865 broken = TRUE;
7866 break;
7867 }
7868
7869 r_symndx = ELF64_R_SYM (rel->r_info);
7870 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7871 r_symndx, ibfd))
7872 goto error_ret;
7873
7874 if (sym_sec == NULL || sym_sec->owner == NULL)
7875 {
7876 const char *sym_name;
7877 if (h != NULL)
7878 sym_name = h->root.root.string;
7879 else
7880 sym_name = bfd_elf_sym_name (ibfd, symtab_hdr, sym,
7881 sym_sec);
7882
7883 _bfd_error_handler
7884 /* xgettext:c-format */
7885 (_("%B: undefined sym `%s' in .opd section"),
7886 ibfd, sym_name);
7887 broken = TRUE;
7888 break;
7889 }
7890
7891 /* opd entries are always for functions defined in the
7892 current input bfd. If the symbol isn't defined in the
7893 input bfd, then we won't be using the function in this
7894 bfd; It must be defined in a linkonce section in another
7895 bfd, or is weak. It's also possible that we are
7896 discarding the function due to a linker script /DISCARD/,
7897 which we test for via the output_section. */
7898 if (sym_sec->owner != ibfd
7899 || sym_sec->output_section == bfd_abs_section_ptr)
7900 need_edit = TRUE;
7901
7902 rel += 2;
7903 if (rel + 1 == relend
7904 || (rel + 2 < relend
7905 && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_TOC))
7906 ++rel;
7907
7908 if (rel == relend)
7909 {
7910 if (sec->size == offset + 24)
7911 {
7912 need_pad = NULL;
7913 break;
7914 }
7915 if (sec->size == offset + 16)
7916 {
7917 cnt_16b++;
7918 break;
7919 }
7920 goto broken_opd;
7921 }
7922 else if (rel + 1 < relend
7923 && ELF64_R_TYPE (rel[0].r_info) == R_PPC64_ADDR64
7924 && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOC)
7925 {
7926 if (rel[0].r_offset == offset + 16)
7927 cnt_16b++;
7928 else if (rel[0].r_offset != offset + 24)
7929 goto broken_opd;
7930 }
7931 else
7932 goto broken_opd;
7933 }
7934
7935 add_aux_fields = htab->params->non_overlapping_opd && cnt_16b > 0;
7936
7937 if (!broken && (need_edit || add_aux_fields))
7938 {
7939 Elf_Internal_Rela *write_rel;
7940 Elf_Internal_Shdr *rel_hdr;
7941 bfd_byte *rptr, *wptr;
7942 bfd_byte *new_contents;
7943 bfd_size_type amt;
7944
7945 new_contents = NULL;
7946 amt = OPD_NDX (sec->size) * sizeof (long);
7947 opd = &ppc64_elf_section_data (sec)->u.opd;
7948 opd->adjust = bfd_zalloc (sec->owner, amt);
7949 if (opd->adjust == NULL)
7950 return FALSE;
7951
7952 /* This seems a waste of time as input .opd sections are all
7953 zeros as generated by gcc, but I suppose there's no reason
7954 this will always be so. We might start putting something in
7955 the third word of .opd entries. */
7956 if ((sec->flags & SEC_IN_MEMORY) == 0)
7957 {
7958 bfd_byte *loc;
7959 if (!bfd_malloc_and_get_section (ibfd, sec, &loc))
7960 {
7961 if (loc != NULL)
7962 free (loc);
7963 error_ret:
7964 if (local_syms != NULL
7965 && symtab_hdr->contents != (unsigned char *) local_syms)
7966 free (local_syms);
7967 if (elf_section_data (sec)->relocs != relstart)
7968 free (relstart);
7969 return FALSE;
7970 }
7971 sec->contents = loc;
7972 sec->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
7973 }
7974
7975 elf_section_data (sec)->relocs = relstart;
7976
7977 new_contents = sec->contents;
7978 if (add_aux_fields)
7979 {
7980 new_contents = bfd_malloc (sec->size + cnt_16b * 8);
7981 if (new_contents == NULL)
7982 return FALSE;
7983 need_pad = NULL;
7984 }
7985 wptr = new_contents;
7986 rptr = sec->contents;
7987 write_rel = relstart;
7988 for (rel = relstart; rel < relend; )
7989 {
7990 unsigned long r_symndx;
7991 asection *sym_sec;
7992 struct elf_link_hash_entry *h;
7993 struct ppc_link_hash_entry *fdh = NULL;
7994 Elf_Internal_Sym *sym;
7995 long opd_ent_size;
7996 Elf_Internal_Rela *next_rel;
7997 bfd_boolean skip;
7998
7999 r_symndx = ELF64_R_SYM (rel->r_info);
8000 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8001 r_symndx, ibfd))
8002 goto error_ret;
8003
8004 next_rel = rel + 2;
8005 if (next_rel + 1 == relend
8006 || (next_rel + 2 < relend
8007 && ELF64_R_TYPE (next_rel[2].r_info) == R_PPC64_TOC))
8008 ++next_rel;
8009
8010 /* See if the .opd entry is full 24 byte or
8011 16 byte (with fd_aux entry overlapped with next
8012 fd_func). */
8013 opd_ent_size = 24;
8014 if (next_rel == relend)
8015 {
8016 if (sec->size == rel->r_offset + 16)
8017 opd_ent_size = 16;
8018 }
8019 else if (next_rel->r_offset == rel->r_offset + 16)
8020 opd_ent_size = 16;
8021
8022 if (h != NULL
8023 && h->root.root.string[0] == '.')
8024 {
8025 fdh = ((struct ppc_link_hash_entry *) h)->oh;
8026 if (fdh != NULL)
8027 {
8028 fdh = ppc_follow_link (fdh);
8029 if (fdh->elf.root.type != bfd_link_hash_defined
8030 && fdh->elf.root.type != bfd_link_hash_defweak)
8031 fdh = NULL;
8032 }
8033 }
8034
8035 skip = (sym_sec->owner != ibfd
8036 || sym_sec->output_section == bfd_abs_section_ptr);
8037 if (skip)
8038 {
8039 if (fdh != NULL && sym_sec->owner == ibfd)
8040 {
8041 /* Arrange for the function descriptor sym
8042 to be dropped. */
8043 fdh->elf.root.u.def.value = 0;
8044 fdh->elf.root.u.def.section = sym_sec;
8045 }
8046 opd->adjust[OPD_NDX (rel->r_offset)] = -1;
8047
8048 if (NO_OPD_RELOCS || bfd_link_relocatable (info))
8049 rel = next_rel;
8050 else
8051 while (1)
8052 {
8053 if (!dec_dynrel_count (rel->r_info, sec, info,
8054 NULL, h, sym))
8055 goto error_ret;
8056
8057 if (++rel == next_rel)
8058 break;
8059
8060 r_symndx = ELF64_R_SYM (rel->r_info);
8061 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8062 r_symndx, ibfd))
8063 goto error_ret;
8064 }
8065 }
8066 else
8067 {
8068 /* We'll be keeping this opd entry. */
8069 long adjust;
8070
8071 if (fdh != NULL)
8072 {
8073 /* Redefine the function descriptor symbol to
8074 this location in the opd section. It is
8075 necessary to update the value here rather
8076 than using an array of adjustments as we do
8077 for local symbols, because various places
8078 in the generic ELF code use the value
8079 stored in u.def.value. */
8080 fdh->elf.root.u.def.value = wptr - new_contents;
8081 fdh->adjust_done = 1;
8082 }
8083
8084 /* Local syms are a bit tricky. We could
8085 tweak them as they can be cached, but
8086 we'd need to look through the local syms
8087 for the function descriptor sym which we
8088 don't have at the moment. So keep an
8089 array of adjustments. */
8090 adjust = (wptr - new_contents) - (rptr - sec->contents);
8091 opd->adjust[OPD_NDX (rel->r_offset)] = adjust;
8092
8093 if (wptr != rptr)
8094 memcpy (wptr, rptr, opd_ent_size);
8095 wptr += opd_ent_size;
8096 if (add_aux_fields && opd_ent_size == 16)
8097 {
8098 memset (wptr, '\0', 8);
8099 wptr += 8;
8100 }
8101
8102 /* We need to adjust any reloc offsets to point to the
8103 new opd entries. */
8104 for ( ; rel != next_rel; ++rel)
8105 {
8106 rel->r_offset += adjust;
8107 if (write_rel != rel)
8108 memcpy (write_rel, rel, sizeof (*rel));
8109 ++write_rel;
8110 }
8111 }
8112
8113 rptr += opd_ent_size;
8114 }
8115
8116 sec->size = wptr - new_contents;
8117 sec->reloc_count = write_rel - relstart;
8118 if (add_aux_fields)
8119 {
8120 free (sec->contents);
8121 sec->contents = new_contents;
8122 }
8123
8124 /* Fudge the header size too, as this is used later in
8125 elf_bfd_final_link if we are emitting relocs. */
8126 rel_hdr = _bfd_elf_single_rel_hdr (sec);
8127 rel_hdr->sh_size = sec->reloc_count * rel_hdr->sh_entsize;
8128 some_edited = TRUE;
8129 }
8130 else if (elf_section_data (sec)->relocs != relstart)
8131 free (relstart);
8132
8133 if (local_syms != NULL
8134 && symtab_hdr->contents != (unsigned char *) local_syms)
8135 {
8136 if (!info->keep_memory)
8137 free (local_syms);
8138 else
8139 symtab_hdr->contents = (unsigned char *) local_syms;
8140 }
8141 }
8142
8143 if (some_edited)
8144 elf_link_hash_traverse (elf_hash_table (info), adjust_opd_syms, NULL);
8145
8146 /* If we are doing a final link and the last .opd entry is just 16 byte
8147 long, add a 8 byte padding after it. */
8148 if (need_pad != NULL && !bfd_link_relocatable (info))
8149 {
8150 bfd_byte *p;
8151
8152 if ((need_pad->flags & SEC_IN_MEMORY) == 0)
8153 {
8154 BFD_ASSERT (need_pad->size > 0);
8155
8156 p = bfd_malloc (need_pad->size + 8);
8157 if (p == NULL)
8158 return FALSE;
8159
8160 if (! bfd_get_section_contents (need_pad->owner, need_pad,
8161 p, 0, need_pad->size))
8162 return FALSE;
8163
8164 need_pad->contents = p;
8165 need_pad->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
8166 }
8167 else
8168 {
8169 p = bfd_realloc (need_pad->contents, need_pad->size + 8);
8170 if (p == NULL)
8171 return FALSE;
8172
8173 need_pad->contents = p;
8174 }
8175
8176 memset (need_pad->contents + need_pad->size, 0, 8);
8177 need_pad->size += 8;
8178 }
8179
8180 return TRUE;
8181 }
8182
8183 /* Set htab->tls_get_addr and call the generic ELF tls_setup function. */
8184
8185 asection *
8186 ppc64_elf_tls_setup (struct bfd_link_info *info)
8187 {
8188 struct ppc_link_hash_table *htab;
8189
8190 htab = ppc_hash_table (info);
8191 if (htab == NULL)
8192 return NULL;
8193
8194 if (abiversion (info->output_bfd) == 1)
8195 htab->opd_abi = 1;
8196
8197 if (htab->params->no_multi_toc)
8198 htab->do_multi_toc = 0;
8199 else if (!htab->do_multi_toc)
8200 htab->params->no_multi_toc = 1;
8201
8202 /* Default to --no-plt-localentry, as this option can cause problems
8203 with symbol interposition. For example, glibc libpthread.so and
8204 libc.so duplicate many pthread symbols, with a fallback
8205 implementation in libc.so. In some cases the fallback does more
8206 work than the pthread implementation. __pthread_condattr_destroy
8207 is one such symbol: the libpthread.so implementation is
8208 localentry:0 while the libc.so implementation is localentry:8.
8209 An app that "cleverly" uses dlopen to only load necessary
8210 libraries at runtime may omit loading libpthread.so when not
8211 running multi-threaded, which then results in the libc.so
8212 fallback symbols being used and ld.so complaining. Now there
8213 are workarounds in ld (see non_zero_localentry) to detect the
8214 pthread situation, but that may not be the only case where
8215 --plt-localentry can cause trouble. */
8216 if (htab->params->plt_localentry0 < 0)
8217 htab->params->plt_localentry0 = 0;
8218 if (htab->params->plt_localentry0
8219 && elf_link_hash_lookup (&htab->elf, "GLIBC_2.26",
8220 FALSE, FALSE, FALSE) == NULL)
8221 info->callbacks->einfo
8222 (_("%P: warning: --plt-localentry is especially dangerous without "
8223 "ld.so support to detect ABI violations.\n"));
8224
8225 htab->tls_get_addr = ((struct ppc_link_hash_entry *)
8226 elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
8227 FALSE, FALSE, TRUE));
8228 /* Move dynamic linking info to the function descriptor sym. */
8229 if (htab->tls_get_addr != NULL)
8230 func_desc_adjust (&htab->tls_get_addr->elf, info);
8231 htab->tls_get_addr_fd = ((struct ppc_link_hash_entry *)
8232 elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
8233 FALSE, FALSE, TRUE));
8234 if (htab->params->tls_get_addr_opt)
8235 {
8236 struct elf_link_hash_entry *opt, *opt_fd, *tga, *tga_fd;
8237
8238 opt = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr_opt",
8239 FALSE, FALSE, TRUE);
8240 if (opt != NULL)
8241 func_desc_adjust (opt, info);
8242 opt_fd = elf_link_hash_lookup (&htab->elf, "__tls_get_addr_opt",
8243 FALSE, FALSE, TRUE);
8244 if (opt_fd != NULL
8245 && (opt_fd->root.type == bfd_link_hash_defined
8246 || opt_fd->root.type == bfd_link_hash_defweak))
8247 {
8248 /* If glibc supports an optimized __tls_get_addr call stub,
8249 signalled by the presence of __tls_get_addr_opt, and we'll
8250 be calling __tls_get_addr via a plt call stub, then
8251 make __tls_get_addr point to __tls_get_addr_opt. */
8252 tga_fd = &htab->tls_get_addr_fd->elf;
8253 if (htab->elf.dynamic_sections_created
8254 && tga_fd != NULL
8255 && (tga_fd->type == STT_FUNC
8256 || tga_fd->needs_plt)
8257 && !(SYMBOL_CALLS_LOCAL (info, tga_fd)
8258 || UNDEFWEAK_NO_DYNAMIC_RELOC (info, tga_fd)))
8259 {
8260 struct plt_entry *ent;
8261
8262 for (ent = tga_fd->plt.plist; ent != NULL; ent = ent->next)
8263 if (ent->plt.refcount > 0)
8264 break;
8265 if (ent != NULL)
8266 {
8267 tga_fd->root.type = bfd_link_hash_indirect;
8268 tga_fd->root.u.i.link = &opt_fd->root;
8269 ppc64_elf_copy_indirect_symbol (info, opt_fd, tga_fd);
8270 opt_fd->mark = 1;
8271 if (opt_fd->dynindx != -1)
8272 {
8273 /* Use __tls_get_addr_opt in dynamic relocations. */
8274 opt_fd->dynindx = -1;
8275 _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
8276 opt_fd->dynstr_index);
8277 if (!bfd_elf_link_record_dynamic_symbol (info, opt_fd))
8278 return NULL;
8279 }
8280 htab->tls_get_addr_fd = (struct ppc_link_hash_entry *) opt_fd;
8281 tga = &htab->tls_get_addr->elf;
8282 if (opt != NULL && tga != NULL)
8283 {
8284 tga->root.type = bfd_link_hash_indirect;
8285 tga->root.u.i.link = &opt->root;
8286 ppc64_elf_copy_indirect_symbol (info, opt, tga);
8287 opt->mark = 1;
8288 _bfd_elf_link_hash_hide_symbol (info, opt,
8289 tga->forced_local);
8290 htab->tls_get_addr = (struct ppc_link_hash_entry *) opt;
8291 }
8292 htab->tls_get_addr_fd->oh = htab->tls_get_addr;
8293 htab->tls_get_addr_fd->is_func_descriptor = 1;
8294 if (htab->tls_get_addr != NULL)
8295 {
8296 htab->tls_get_addr->oh = htab->tls_get_addr_fd;
8297 htab->tls_get_addr->is_func = 1;
8298 }
8299 }
8300 }
8301 }
8302 else if (htab->params->tls_get_addr_opt < 0)
8303 htab->params->tls_get_addr_opt = 0;
8304 }
8305 return _bfd_elf_tls_setup (info->output_bfd, info);
8306 }
8307
8308 /* Return TRUE iff REL is a branch reloc with a global symbol matching
8309 HASH1 or HASH2. */
8310
8311 static bfd_boolean
8312 branch_reloc_hash_match (const bfd *ibfd,
8313 const Elf_Internal_Rela *rel,
8314 const struct ppc_link_hash_entry *hash1,
8315 const struct ppc_link_hash_entry *hash2)
8316 {
8317 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
8318 enum elf_ppc64_reloc_type r_type = ELF64_R_TYPE (rel->r_info);
8319 unsigned int r_symndx = ELF64_R_SYM (rel->r_info);
8320
8321 if (r_symndx >= symtab_hdr->sh_info && is_branch_reloc (r_type))
8322 {
8323 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
8324 struct elf_link_hash_entry *h;
8325
8326 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
8327 h = elf_follow_link (h);
8328 if (h == &hash1->elf || h == &hash2->elf)
8329 return TRUE;
8330 }
8331 return FALSE;
8332 }
8333
8334 /* Run through all the TLS relocs looking for optimization
8335 opportunities. The linker has been hacked (see ppc64elf.em) to do
8336 a preliminary section layout so that we know the TLS segment
8337 offsets. We can't optimize earlier because some optimizations need
8338 to know the tp offset, and we need to optimize before allocating
8339 dynamic relocations. */
8340
8341 bfd_boolean
8342 ppc64_elf_tls_optimize (struct bfd_link_info *info)
8343 {
8344 bfd *ibfd;
8345 asection *sec;
8346 struct ppc_link_hash_table *htab;
8347 unsigned char *toc_ref;
8348 int pass;
8349
8350 if (!bfd_link_executable (info))
8351 return TRUE;
8352
8353 htab = ppc_hash_table (info);
8354 if (htab == NULL)
8355 return FALSE;
8356
8357 /* Make two passes over the relocs. On the first pass, mark toc
8358 entries involved with tls relocs, and check that tls relocs
8359 involved in setting up a tls_get_addr call are indeed followed by
8360 such a call. If they are not, we can't do any tls optimization.
8361 On the second pass twiddle tls_mask flags to notify
8362 relocate_section that optimization can be done, and adjust got
8363 and plt refcounts. */
8364 toc_ref = NULL;
8365 for (pass = 0; pass < 2; ++pass)
8366 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
8367 {
8368 Elf_Internal_Sym *locsyms = NULL;
8369 asection *toc = bfd_get_section_by_name (ibfd, ".toc");
8370
8371 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8372 if (sec->has_tls_reloc && !bfd_is_abs_section (sec->output_section))
8373 {
8374 Elf_Internal_Rela *relstart, *rel, *relend;
8375 bfd_boolean found_tls_get_addr_arg = 0;
8376
8377 /* Read the relocations. */
8378 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8379 info->keep_memory);
8380 if (relstart == NULL)
8381 {
8382 free (toc_ref);
8383 return FALSE;
8384 }
8385
8386 relend = relstart + sec->reloc_count;
8387 for (rel = relstart; rel < relend; rel++)
8388 {
8389 enum elf_ppc64_reloc_type r_type;
8390 unsigned long r_symndx;
8391 struct elf_link_hash_entry *h;
8392 Elf_Internal_Sym *sym;
8393 asection *sym_sec;
8394 unsigned char *tls_mask;
8395 unsigned char tls_set, tls_clear, tls_type = 0;
8396 bfd_vma value;
8397 bfd_boolean ok_tprel, is_local;
8398 long toc_ref_index = 0;
8399 int expecting_tls_get_addr = 0;
8400 bfd_boolean ret = FALSE;
8401
8402 r_symndx = ELF64_R_SYM (rel->r_info);
8403 if (!get_sym_h (&h, &sym, &sym_sec, &tls_mask, &locsyms,
8404 r_symndx, ibfd))
8405 {
8406 err_free_rel:
8407 if (elf_section_data (sec)->relocs != relstart)
8408 free (relstart);
8409 if (toc_ref != NULL)
8410 free (toc_ref);
8411 if (locsyms != NULL
8412 && (elf_symtab_hdr (ibfd).contents
8413 != (unsigned char *) locsyms))
8414 free (locsyms);
8415 return ret;
8416 }
8417
8418 if (h != NULL)
8419 {
8420 if (h->root.type == bfd_link_hash_defined
8421 || h->root.type == bfd_link_hash_defweak)
8422 value = h->root.u.def.value;
8423 else if (h->root.type == bfd_link_hash_undefweak)
8424 value = 0;
8425 else
8426 {
8427 found_tls_get_addr_arg = 0;
8428 continue;
8429 }
8430 }
8431 else
8432 /* Symbols referenced by TLS relocs must be of type
8433 STT_TLS. So no need for .opd local sym adjust. */
8434 value = sym->st_value;
8435
8436 ok_tprel = FALSE;
8437 is_local = FALSE;
8438 if (h == NULL
8439 || !h->def_dynamic)
8440 {
8441 is_local = TRUE;
8442 if (h != NULL
8443 && h->root.type == bfd_link_hash_undefweak)
8444 ok_tprel = TRUE;
8445 else if (sym_sec != NULL
8446 && sym_sec->output_section != NULL)
8447 {
8448 value += sym_sec->output_offset;
8449 value += sym_sec->output_section->vma;
8450 value -= htab->elf.tls_sec->vma;
8451 ok_tprel = (value + TP_OFFSET + ((bfd_vma) 1 << 31)
8452 < (bfd_vma) 1 << 32);
8453 }
8454 }
8455
8456 r_type = ELF64_R_TYPE (rel->r_info);
8457 /* If this section has old-style __tls_get_addr calls
8458 without marker relocs, then check that each
8459 __tls_get_addr call reloc is preceded by a reloc
8460 that conceivably belongs to the __tls_get_addr arg
8461 setup insn. If we don't find matching arg setup
8462 relocs, don't do any tls optimization. */
8463 if (pass == 0
8464 && sec->has_tls_get_addr_call
8465 && h != NULL
8466 && (h == &htab->tls_get_addr->elf
8467 || h == &htab->tls_get_addr_fd->elf)
8468 && !found_tls_get_addr_arg
8469 && is_branch_reloc (r_type))
8470 {
8471 info->callbacks->minfo (_("%H __tls_get_addr lost arg, "
8472 "TLS optimization disabled\n"),
8473 ibfd, sec, rel->r_offset);
8474 ret = TRUE;
8475 goto err_free_rel;
8476 }
8477
8478 found_tls_get_addr_arg = 0;
8479 switch (r_type)
8480 {
8481 case R_PPC64_GOT_TLSLD16:
8482 case R_PPC64_GOT_TLSLD16_LO:
8483 expecting_tls_get_addr = 1;
8484 found_tls_get_addr_arg = 1;
8485 /* Fall through. */
8486
8487 case R_PPC64_GOT_TLSLD16_HI:
8488 case R_PPC64_GOT_TLSLD16_HA:
8489 /* These relocs should never be against a symbol
8490 defined in a shared lib. Leave them alone if
8491 that turns out to be the case. */
8492 if (!is_local)
8493 continue;
8494
8495 /* LD -> LE */
8496 tls_set = 0;
8497 tls_clear = TLS_LD;
8498 tls_type = TLS_TLS | TLS_LD;
8499 break;
8500
8501 case R_PPC64_GOT_TLSGD16:
8502 case R_PPC64_GOT_TLSGD16_LO:
8503 expecting_tls_get_addr = 1;
8504 found_tls_get_addr_arg = 1;
8505 /* Fall through. */
8506
8507 case R_PPC64_GOT_TLSGD16_HI:
8508 case R_PPC64_GOT_TLSGD16_HA:
8509 if (ok_tprel)
8510 /* GD -> LE */
8511 tls_set = 0;
8512 else
8513 /* GD -> IE */
8514 tls_set = TLS_TLS | TLS_TPRELGD;
8515 tls_clear = TLS_GD;
8516 tls_type = TLS_TLS | TLS_GD;
8517 break;
8518
8519 case R_PPC64_GOT_TPREL16_DS:
8520 case R_PPC64_GOT_TPREL16_LO_DS:
8521 case R_PPC64_GOT_TPREL16_HI:
8522 case R_PPC64_GOT_TPREL16_HA:
8523 if (ok_tprel)
8524 {
8525 /* IE -> LE */
8526 tls_set = 0;
8527 tls_clear = TLS_TPREL;
8528 tls_type = TLS_TLS | TLS_TPREL;
8529 break;
8530 }
8531 continue;
8532
8533 case R_PPC64_TLSGD:
8534 case R_PPC64_TLSLD:
8535 found_tls_get_addr_arg = 1;
8536 /* Fall through. */
8537
8538 case R_PPC64_TLS:
8539 case R_PPC64_TOC16:
8540 case R_PPC64_TOC16_LO:
8541 if (sym_sec == NULL || sym_sec != toc)
8542 continue;
8543
8544 /* Mark this toc entry as referenced by a TLS
8545 code sequence. We can do that now in the
8546 case of R_PPC64_TLS, and after checking for
8547 tls_get_addr for the TOC16 relocs. */
8548 if (toc_ref == NULL)
8549 toc_ref = bfd_zmalloc (toc->output_section->rawsize / 8);
8550 if (toc_ref == NULL)
8551 goto err_free_rel;
8552
8553 if (h != NULL)
8554 value = h->root.u.def.value;
8555 else
8556 value = sym->st_value;
8557 value += rel->r_addend;
8558 if (value % 8 != 0)
8559 continue;
8560 BFD_ASSERT (value < toc->size
8561 && toc->output_offset % 8 == 0);
8562 toc_ref_index = (value + toc->output_offset) / 8;
8563 if (r_type == R_PPC64_TLS
8564 || r_type == R_PPC64_TLSGD
8565 || r_type == R_PPC64_TLSLD)
8566 {
8567 toc_ref[toc_ref_index] = 1;
8568 continue;
8569 }
8570
8571 if (pass != 0 && toc_ref[toc_ref_index] == 0)
8572 continue;
8573
8574 tls_set = 0;
8575 tls_clear = 0;
8576 expecting_tls_get_addr = 2;
8577 break;
8578
8579 case R_PPC64_TPREL64:
8580 if (pass == 0
8581 || sec != toc
8582 || toc_ref == NULL
8583 || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
8584 continue;
8585 if (ok_tprel)
8586 {
8587 /* IE -> LE */
8588 tls_set = TLS_EXPLICIT;
8589 tls_clear = TLS_TPREL;
8590 break;
8591 }
8592 continue;
8593
8594 case R_PPC64_DTPMOD64:
8595 if (pass == 0
8596 || sec != toc
8597 || toc_ref == NULL
8598 || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
8599 continue;
8600 if (rel + 1 < relend
8601 && (rel[1].r_info
8602 == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64))
8603 && rel[1].r_offset == rel->r_offset + 8)
8604 {
8605 if (ok_tprel)
8606 /* GD -> LE */
8607 tls_set = TLS_EXPLICIT | TLS_GD;
8608 else
8609 /* GD -> IE */
8610 tls_set = TLS_EXPLICIT | TLS_GD | TLS_TPRELGD;
8611 tls_clear = TLS_GD;
8612 }
8613 else
8614 {
8615 if (!is_local)
8616 continue;
8617
8618 /* LD -> LE */
8619 tls_set = TLS_EXPLICIT;
8620 tls_clear = TLS_LD;
8621 }
8622 break;
8623
8624 default:
8625 continue;
8626 }
8627
8628 if (pass == 0)
8629 {
8630 if (!expecting_tls_get_addr
8631 || !sec->has_tls_get_addr_call)
8632 continue;
8633
8634 if (rel + 1 < relend
8635 && branch_reloc_hash_match (ibfd, rel + 1,
8636 htab->tls_get_addr,
8637 htab->tls_get_addr_fd))
8638 {
8639 if (expecting_tls_get_addr == 2)
8640 {
8641 /* Check for toc tls entries. */
8642 unsigned char *toc_tls;
8643 int retval;
8644
8645 retval = get_tls_mask (&toc_tls, NULL, NULL,
8646 &locsyms,
8647 rel, ibfd);
8648 if (retval == 0)
8649 goto err_free_rel;
8650 if (toc_tls != NULL)
8651 {
8652 if ((*toc_tls & (TLS_GD | TLS_LD)) != 0)
8653 found_tls_get_addr_arg = 1;
8654 if (retval > 1)
8655 toc_ref[toc_ref_index] = 1;
8656 }
8657 }
8658 continue;
8659 }
8660
8661 if (expecting_tls_get_addr != 1)
8662 continue;
8663
8664 /* Uh oh, we didn't find the expected call. We
8665 could just mark this symbol to exclude it
8666 from tls optimization but it's safer to skip
8667 the entire optimization. */
8668 /* xgettext:c-format */
8669 info->callbacks->minfo (_("%H arg lost __tls_get_addr, "
8670 "TLS optimization disabled\n"),
8671 ibfd, sec, rel->r_offset);
8672 ret = TRUE;
8673 goto err_free_rel;
8674 }
8675
8676 if (expecting_tls_get_addr && htab->tls_get_addr != NULL)
8677 {
8678 struct plt_entry *ent;
8679 for (ent = htab->tls_get_addr->elf.plt.plist;
8680 ent != NULL;
8681 ent = ent->next)
8682 if (ent->addend == 0)
8683 {
8684 if (ent->plt.refcount > 0)
8685 {
8686 ent->plt.refcount -= 1;
8687 expecting_tls_get_addr = 0;
8688 }
8689 break;
8690 }
8691 }
8692
8693 if (expecting_tls_get_addr && htab->tls_get_addr_fd != NULL)
8694 {
8695 struct plt_entry *ent;
8696 for (ent = htab->tls_get_addr_fd->elf.plt.plist;
8697 ent != NULL;
8698 ent = ent->next)
8699 if (ent->addend == 0)
8700 {
8701 if (ent->plt.refcount > 0)
8702 ent->plt.refcount -= 1;
8703 break;
8704 }
8705 }
8706
8707 if (tls_clear == 0)
8708 continue;
8709
8710 if ((tls_set & TLS_EXPLICIT) == 0)
8711 {
8712 struct got_entry *ent;
8713
8714 /* Adjust got entry for this reloc. */
8715 if (h != NULL)
8716 ent = h->got.glist;
8717 else
8718 ent = elf_local_got_ents (ibfd)[r_symndx];
8719
8720 for (; ent != NULL; ent = ent->next)
8721 if (ent->addend == rel->r_addend
8722 && ent->owner == ibfd
8723 && ent->tls_type == tls_type)
8724 break;
8725 if (ent == NULL)
8726 abort ();
8727
8728 if (tls_set == 0)
8729 {
8730 /* We managed to get rid of a got entry. */
8731 if (ent->got.refcount > 0)
8732 ent->got.refcount -= 1;
8733 }
8734 }
8735 else
8736 {
8737 /* If we got rid of a DTPMOD/DTPREL reloc pair then
8738 we'll lose one or two dyn relocs. */
8739 if (!dec_dynrel_count (rel->r_info, sec, info,
8740 NULL, h, sym))
8741 return FALSE;
8742
8743 if (tls_set == (TLS_EXPLICIT | TLS_GD))
8744 {
8745 if (!dec_dynrel_count ((rel + 1)->r_info, sec, info,
8746 NULL, h, sym))
8747 return FALSE;
8748 }
8749 }
8750
8751 *tls_mask |= tls_set;
8752 *tls_mask &= ~tls_clear;
8753 }
8754
8755 if (elf_section_data (sec)->relocs != relstart)
8756 free (relstart);
8757 }
8758
8759 if (locsyms != NULL
8760 && (elf_symtab_hdr (ibfd).contents != (unsigned char *) locsyms))
8761 {
8762 if (!info->keep_memory)
8763 free (locsyms);
8764 else
8765 elf_symtab_hdr (ibfd).contents = (unsigned char *) locsyms;
8766 }
8767 }
8768
8769 if (toc_ref != NULL)
8770 free (toc_ref);
8771 htab->do_tls_opt = 1;
8772 return TRUE;
8773 }
8774
8775 /* Called via elf_link_hash_traverse from ppc64_elf_edit_toc to adjust
8776 the values of any global symbols in a toc section that has been
8777 edited. Globals in toc sections should be a rarity, so this function
8778 sets a flag if any are found in toc sections other than the one just
8779 edited, so that further hash table traversals can be avoided. */
8780
8781 struct adjust_toc_info
8782 {
8783 asection *toc;
8784 unsigned long *skip;
8785 bfd_boolean global_toc_syms;
8786 };
8787
8788 enum toc_skip_enum { ref_from_discarded = 1, can_optimize = 2 };
8789
8790 static bfd_boolean
8791 adjust_toc_syms (struct elf_link_hash_entry *h, void *inf)
8792 {
8793 struct ppc_link_hash_entry *eh;
8794 struct adjust_toc_info *toc_inf = (struct adjust_toc_info *) inf;
8795 unsigned long i;
8796
8797 if (h->root.type != bfd_link_hash_defined
8798 && h->root.type != bfd_link_hash_defweak)
8799 return TRUE;
8800
8801 eh = (struct ppc_link_hash_entry *) h;
8802 if (eh->adjust_done)
8803 return TRUE;
8804
8805 if (eh->elf.root.u.def.section == toc_inf->toc)
8806 {
8807 if (eh->elf.root.u.def.value > toc_inf->toc->rawsize)
8808 i = toc_inf->toc->rawsize >> 3;
8809 else
8810 i = eh->elf.root.u.def.value >> 3;
8811
8812 if ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0)
8813 {
8814 _bfd_error_handler
8815 (_("%s defined on removed toc entry"), eh->elf.root.root.string);
8816 do
8817 ++i;
8818 while ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0);
8819 eh->elf.root.u.def.value = (bfd_vma) i << 3;
8820 }
8821
8822 eh->elf.root.u.def.value -= toc_inf->skip[i];
8823 eh->adjust_done = 1;
8824 }
8825 else if (strcmp (eh->elf.root.u.def.section->name, ".toc") == 0)
8826 toc_inf->global_toc_syms = TRUE;
8827
8828 return TRUE;
8829 }
8830
8831 /* Return TRUE iff INSN with a relocation of R_TYPE is one we expect
8832 on a _LO variety toc/got reloc. */
8833
8834 static bfd_boolean
8835 ok_lo_toc_insn (unsigned int insn, enum elf_ppc64_reloc_type r_type)
8836 {
8837 return ((insn & (0x3f << 26)) == 12u << 26 /* addic */
8838 || (insn & (0x3f << 26)) == 14u << 26 /* addi */
8839 || (insn & (0x3f << 26)) == 32u << 26 /* lwz */
8840 || (insn & (0x3f << 26)) == 34u << 26 /* lbz */
8841 || (insn & (0x3f << 26)) == 36u << 26 /* stw */
8842 || (insn & (0x3f << 26)) == 38u << 26 /* stb */
8843 || (insn & (0x3f << 26)) == 40u << 26 /* lhz */
8844 || (insn & (0x3f << 26)) == 42u << 26 /* lha */
8845 || (insn & (0x3f << 26)) == 44u << 26 /* sth */
8846 || (insn & (0x3f << 26)) == 46u << 26 /* lmw */
8847 || (insn & (0x3f << 26)) == 47u << 26 /* stmw */
8848 || (insn & (0x3f << 26)) == 48u << 26 /* lfs */
8849 || (insn & (0x3f << 26)) == 50u << 26 /* lfd */
8850 || (insn & (0x3f << 26)) == 52u << 26 /* stfs */
8851 || (insn & (0x3f << 26)) == 54u << 26 /* stfd */
8852 || (insn & (0x3f << 26)) == 56u << 26 /* lq,lfq */
8853 || ((insn & (0x3f << 26)) == 57u << 26 /* lxsd,lxssp,lfdp */
8854 /* Exclude lfqu by testing reloc. If relocs are ever
8855 defined for the reduced D field in psq_lu then those
8856 will need testing too. */
8857 && r_type != R_PPC64_TOC16_LO && r_type != R_PPC64_GOT16_LO)
8858 || ((insn & (0x3f << 26)) == 58u << 26 /* ld,lwa */
8859 && (insn & 1) == 0)
8860 || (insn & (0x3f << 26)) == 60u << 26 /* stfq */
8861 || ((insn & (0x3f << 26)) == 61u << 26 /* lxv,stx{v,sd,ssp},stfdp */
8862 /* Exclude stfqu. psq_stu as above for psq_lu. */
8863 && r_type != R_PPC64_TOC16_LO && r_type != R_PPC64_GOT16_LO)
8864 || ((insn & (0x3f << 26)) == 62u << 26 /* std,stq */
8865 && (insn & 1) == 0));
8866 }
8867
8868 /* Examine all relocs referencing .toc sections in order to remove
8869 unused .toc entries. */
8870
8871 bfd_boolean
8872 ppc64_elf_edit_toc (struct bfd_link_info *info)
8873 {
8874 bfd *ibfd;
8875 struct adjust_toc_info toc_inf;
8876 struct ppc_link_hash_table *htab = ppc_hash_table (info);
8877
8878 htab->do_toc_opt = 1;
8879 toc_inf.global_toc_syms = TRUE;
8880 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
8881 {
8882 asection *toc, *sec;
8883 Elf_Internal_Shdr *symtab_hdr;
8884 Elf_Internal_Sym *local_syms;
8885 Elf_Internal_Rela *relstart, *rel, *toc_relocs;
8886 unsigned long *skip, *drop;
8887 unsigned char *used;
8888 unsigned char *keep, last, some_unused;
8889
8890 if (!is_ppc64_elf (ibfd))
8891 continue;
8892
8893 toc = bfd_get_section_by_name (ibfd, ".toc");
8894 if (toc == NULL
8895 || toc->size == 0
8896 || toc->sec_info_type == SEC_INFO_TYPE_JUST_SYMS
8897 || discarded_section (toc))
8898 continue;
8899
8900 toc_relocs = NULL;
8901 local_syms = NULL;
8902 symtab_hdr = &elf_symtab_hdr (ibfd);
8903
8904 /* Look at sections dropped from the final link. */
8905 skip = NULL;
8906 relstart = NULL;
8907 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8908 {
8909 if (sec->reloc_count == 0
8910 || !discarded_section (sec)
8911 || get_opd_info (sec)
8912 || (sec->flags & SEC_ALLOC) == 0
8913 || (sec->flags & SEC_DEBUGGING) != 0)
8914 continue;
8915
8916 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL, FALSE);
8917 if (relstart == NULL)
8918 goto error_ret;
8919
8920 /* Run through the relocs to see which toc entries might be
8921 unused. */
8922 for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
8923 {
8924 enum elf_ppc64_reloc_type r_type;
8925 unsigned long r_symndx;
8926 asection *sym_sec;
8927 struct elf_link_hash_entry *h;
8928 Elf_Internal_Sym *sym;
8929 bfd_vma val;
8930
8931 r_type = ELF64_R_TYPE (rel->r_info);
8932 switch (r_type)
8933 {
8934 default:
8935 continue;
8936
8937 case R_PPC64_TOC16:
8938 case R_PPC64_TOC16_LO:
8939 case R_PPC64_TOC16_HI:
8940 case R_PPC64_TOC16_HA:
8941 case R_PPC64_TOC16_DS:
8942 case R_PPC64_TOC16_LO_DS:
8943 break;
8944 }
8945
8946 r_symndx = ELF64_R_SYM (rel->r_info);
8947 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8948 r_symndx, ibfd))
8949 goto error_ret;
8950
8951 if (sym_sec != toc)
8952 continue;
8953
8954 if (h != NULL)
8955 val = h->root.u.def.value;
8956 else
8957 val = sym->st_value;
8958 val += rel->r_addend;
8959
8960 if (val >= toc->size)
8961 continue;
8962
8963 /* Anything in the toc ought to be aligned to 8 bytes.
8964 If not, don't mark as unused. */
8965 if (val & 7)
8966 continue;
8967
8968 if (skip == NULL)
8969 {
8970 skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
8971 if (skip == NULL)
8972 goto error_ret;
8973 }
8974
8975 skip[val >> 3] = ref_from_discarded;
8976 }
8977
8978 if (elf_section_data (sec)->relocs != relstart)
8979 free (relstart);
8980 }
8981
8982 /* For largetoc loads of address constants, we can convert
8983 . addis rx,2,addr@got@ha
8984 . ld ry,addr@got@l(rx)
8985 to
8986 . addis rx,2,addr@toc@ha
8987 . addi ry,rx,addr@toc@l
8988 when addr is within 2G of the toc pointer. This then means
8989 that the word storing "addr" in the toc is no longer needed. */
8990
8991 if (!ppc64_elf_tdata (ibfd)->has_small_toc_reloc
8992 && toc->output_section->rawsize < (bfd_vma) 1 << 31
8993 && toc->reloc_count != 0)
8994 {
8995 /* Read toc relocs. */
8996 toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
8997 info->keep_memory);
8998 if (toc_relocs == NULL)
8999 goto error_ret;
9000
9001 for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
9002 {
9003 enum elf_ppc64_reloc_type r_type;
9004 unsigned long r_symndx;
9005 asection *sym_sec;
9006 struct elf_link_hash_entry *h;
9007 Elf_Internal_Sym *sym;
9008 bfd_vma val, addr;
9009
9010 r_type = ELF64_R_TYPE (rel->r_info);
9011 if (r_type != R_PPC64_ADDR64)
9012 continue;
9013
9014 r_symndx = ELF64_R_SYM (rel->r_info);
9015 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9016 r_symndx, ibfd))
9017 goto error_ret;
9018
9019 if (sym_sec == NULL
9020 || sym_sec->output_section == NULL
9021 || discarded_section (sym_sec))
9022 continue;
9023
9024 if (!SYMBOL_REFERENCES_LOCAL (info, h))
9025 continue;
9026
9027 if (h != NULL)
9028 {
9029 if (h->type == STT_GNU_IFUNC)
9030 continue;
9031 val = h->root.u.def.value;
9032 }
9033 else
9034 {
9035 if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
9036 continue;
9037 val = sym->st_value;
9038 }
9039 val += rel->r_addend;
9040 val += sym_sec->output_section->vma + sym_sec->output_offset;
9041
9042 /* We don't yet know the exact toc pointer value, but we
9043 know it will be somewhere in the toc section. Don't
9044 optimize if the difference from any possible toc
9045 pointer is outside [ff..f80008000, 7fff7fff]. */
9046 addr = toc->output_section->vma + TOC_BASE_OFF;
9047 if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
9048 continue;
9049
9050 addr = toc->output_section->vma + toc->output_section->rawsize;
9051 if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
9052 continue;
9053
9054 if (skip == NULL)
9055 {
9056 skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
9057 if (skip == NULL)
9058 goto error_ret;
9059 }
9060
9061 skip[rel->r_offset >> 3]
9062 |= can_optimize | ((rel - toc_relocs) << 2);
9063 }
9064 }
9065
9066 if (skip == NULL)
9067 continue;
9068
9069 used = bfd_zmalloc (sizeof (*used) * (toc->size + 7) / 8);
9070 if (used == NULL)
9071 {
9072 error_ret:
9073 if (local_syms != NULL
9074 && symtab_hdr->contents != (unsigned char *) local_syms)
9075 free (local_syms);
9076 if (sec != NULL
9077 && relstart != NULL
9078 && elf_section_data (sec)->relocs != relstart)
9079 free (relstart);
9080 if (toc_relocs != NULL
9081 && elf_section_data (toc)->relocs != toc_relocs)
9082 free (toc_relocs);
9083 if (skip != NULL)
9084 free (skip);
9085 return FALSE;
9086 }
9087
9088 /* Now check all kept sections that might reference the toc.
9089 Check the toc itself last. */
9090 for (sec = (ibfd->sections == toc && toc->next ? toc->next
9091 : ibfd->sections);
9092 sec != NULL;
9093 sec = (sec == toc ? NULL
9094 : sec->next == NULL ? toc
9095 : sec->next == toc && toc->next ? toc->next
9096 : sec->next))
9097 {
9098 int repeat;
9099
9100 if (sec->reloc_count == 0
9101 || discarded_section (sec)
9102 || get_opd_info (sec)
9103 || (sec->flags & SEC_ALLOC) == 0
9104 || (sec->flags & SEC_DEBUGGING) != 0)
9105 continue;
9106
9107 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
9108 info->keep_memory);
9109 if (relstart == NULL)
9110 {
9111 free (used);
9112 goto error_ret;
9113 }
9114
9115 /* Mark toc entries referenced as used. */
9116 do
9117 {
9118 repeat = 0;
9119 for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9120 {
9121 enum elf_ppc64_reloc_type r_type;
9122 unsigned long r_symndx;
9123 asection *sym_sec;
9124 struct elf_link_hash_entry *h;
9125 Elf_Internal_Sym *sym;
9126 bfd_vma val;
9127 enum {no_check, check_lo, check_ha} insn_check;
9128
9129 r_type = ELF64_R_TYPE (rel->r_info);
9130 switch (r_type)
9131 {
9132 default:
9133 insn_check = no_check;
9134 break;
9135
9136 case R_PPC64_GOT_TLSLD16_HA:
9137 case R_PPC64_GOT_TLSGD16_HA:
9138 case R_PPC64_GOT_TPREL16_HA:
9139 case R_PPC64_GOT_DTPREL16_HA:
9140 case R_PPC64_GOT16_HA:
9141 case R_PPC64_TOC16_HA:
9142 insn_check = check_ha;
9143 break;
9144
9145 case R_PPC64_GOT_TLSLD16_LO:
9146 case R_PPC64_GOT_TLSGD16_LO:
9147 case R_PPC64_GOT_TPREL16_LO_DS:
9148 case R_PPC64_GOT_DTPREL16_LO_DS:
9149 case R_PPC64_GOT16_LO:
9150 case R_PPC64_GOT16_LO_DS:
9151 case R_PPC64_TOC16_LO:
9152 case R_PPC64_TOC16_LO_DS:
9153 insn_check = check_lo;
9154 break;
9155 }
9156
9157 if (insn_check != no_check)
9158 {
9159 bfd_vma off = rel->r_offset & ~3;
9160 unsigned char buf[4];
9161 unsigned int insn;
9162
9163 if (!bfd_get_section_contents (ibfd, sec, buf, off, 4))
9164 {
9165 free (used);
9166 goto error_ret;
9167 }
9168 insn = bfd_get_32 (ibfd, buf);
9169 if (insn_check == check_lo
9170 ? !ok_lo_toc_insn (insn, r_type)
9171 : ((insn & ((0x3f << 26) | 0x1f << 16))
9172 != ((15u << 26) | (2 << 16)) /* addis rt,2,imm */))
9173 {
9174 char str[12];
9175
9176 ppc64_elf_tdata (ibfd)->unexpected_toc_insn = 1;
9177 sprintf (str, "%#08x", insn);
9178 info->callbacks->einfo
9179 /* xgettext:c-format */
9180 (_("%H: toc optimization is not supported for"
9181 " %s instruction.\n"),
9182 ibfd, sec, rel->r_offset & ~3, str);
9183 }
9184 }
9185
9186 switch (r_type)
9187 {
9188 case R_PPC64_TOC16:
9189 case R_PPC64_TOC16_LO:
9190 case R_PPC64_TOC16_HI:
9191 case R_PPC64_TOC16_HA:
9192 case R_PPC64_TOC16_DS:
9193 case R_PPC64_TOC16_LO_DS:
9194 /* In case we're taking addresses of toc entries. */
9195 case R_PPC64_ADDR64:
9196 break;
9197
9198 default:
9199 continue;
9200 }
9201
9202 r_symndx = ELF64_R_SYM (rel->r_info);
9203 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9204 r_symndx, ibfd))
9205 {
9206 free (used);
9207 goto error_ret;
9208 }
9209
9210 if (sym_sec != toc)
9211 continue;
9212
9213 if (h != NULL)
9214 val = h->root.u.def.value;
9215 else
9216 val = sym->st_value;
9217 val += rel->r_addend;
9218
9219 if (val >= toc->size)
9220 continue;
9221
9222 if ((skip[val >> 3] & can_optimize) != 0)
9223 {
9224 bfd_vma off;
9225 unsigned char opc;
9226
9227 switch (r_type)
9228 {
9229 case R_PPC64_TOC16_HA:
9230 break;
9231
9232 case R_PPC64_TOC16_LO_DS:
9233 off = rel->r_offset;
9234 off += (bfd_big_endian (ibfd) ? -2 : 3);
9235 if (!bfd_get_section_contents (ibfd, sec, &opc,
9236 off, 1))
9237 {
9238 free (used);
9239 goto error_ret;
9240 }
9241 if ((opc & (0x3f << 2)) == (58u << 2))
9242 break;
9243 /* Fall through. */
9244
9245 default:
9246 /* Wrong sort of reloc, or not a ld. We may
9247 as well clear ref_from_discarded too. */
9248 skip[val >> 3] = 0;
9249 }
9250 }
9251
9252 if (sec != toc)
9253 used[val >> 3] = 1;
9254 /* For the toc section, we only mark as used if this
9255 entry itself isn't unused. */
9256 else if ((used[rel->r_offset >> 3]
9257 || !(skip[rel->r_offset >> 3] & ref_from_discarded))
9258 && !used[val >> 3])
9259 {
9260 /* Do all the relocs again, to catch reference
9261 chains. */
9262 repeat = 1;
9263 used[val >> 3] = 1;
9264 }
9265 }
9266 }
9267 while (repeat);
9268
9269 if (elf_section_data (sec)->relocs != relstart)
9270 free (relstart);
9271 }
9272
9273 /* Merge the used and skip arrays. Assume that TOC
9274 doublewords not appearing as either used or unused belong
9275 to an entry more than one doubleword in size. */
9276 for (drop = skip, keep = used, last = 0, some_unused = 0;
9277 drop < skip + (toc->size + 7) / 8;
9278 ++drop, ++keep)
9279 {
9280 if (*keep)
9281 {
9282 *drop &= ~ref_from_discarded;
9283 if ((*drop & can_optimize) != 0)
9284 some_unused = 1;
9285 last = 0;
9286 }
9287 else if ((*drop & ref_from_discarded) != 0)
9288 {
9289 some_unused = 1;
9290 last = ref_from_discarded;
9291 }
9292 else
9293 *drop = last;
9294 }
9295
9296 free (used);
9297
9298 if (some_unused)
9299 {
9300 bfd_byte *contents, *src;
9301 unsigned long off;
9302 Elf_Internal_Sym *sym;
9303 bfd_boolean local_toc_syms = FALSE;
9304
9305 /* Shuffle the toc contents, and at the same time convert the
9306 skip array from booleans into offsets. */
9307 if (!bfd_malloc_and_get_section (ibfd, toc, &contents))
9308 goto error_ret;
9309
9310 elf_section_data (toc)->this_hdr.contents = contents;
9311
9312 for (src = contents, off = 0, drop = skip;
9313 src < contents + toc->size;
9314 src += 8, ++drop)
9315 {
9316 if ((*drop & (can_optimize | ref_from_discarded)) != 0)
9317 off += 8;
9318 else if (off != 0)
9319 {
9320 *drop = off;
9321 memcpy (src - off, src, 8);
9322 }
9323 }
9324 *drop = off;
9325 toc->rawsize = toc->size;
9326 toc->size = src - contents - off;
9327
9328 /* Adjust addends for relocs against the toc section sym,
9329 and optimize any accesses we can. */
9330 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
9331 {
9332 if (sec->reloc_count == 0
9333 || discarded_section (sec))
9334 continue;
9335
9336 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
9337 info->keep_memory);
9338 if (relstart == NULL)
9339 goto error_ret;
9340
9341 for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9342 {
9343 enum elf_ppc64_reloc_type r_type;
9344 unsigned long r_symndx;
9345 asection *sym_sec;
9346 struct elf_link_hash_entry *h;
9347 bfd_vma val;
9348
9349 r_type = ELF64_R_TYPE (rel->r_info);
9350 switch (r_type)
9351 {
9352 default:
9353 continue;
9354
9355 case R_PPC64_TOC16:
9356 case R_PPC64_TOC16_LO:
9357 case R_PPC64_TOC16_HI:
9358 case R_PPC64_TOC16_HA:
9359 case R_PPC64_TOC16_DS:
9360 case R_PPC64_TOC16_LO_DS:
9361 case R_PPC64_ADDR64:
9362 break;
9363 }
9364
9365 r_symndx = ELF64_R_SYM (rel->r_info);
9366 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9367 r_symndx, ibfd))
9368 goto error_ret;
9369
9370 if (sym_sec != toc)
9371 continue;
9372
9373 if (h != NULL)
9374 val = h->root.u.def.value;
9375 else
9376 {
9377 val = sym->st_value;
9378 if (val != 0)
9379 local_toc_syms = TRUE;
9380 }
9381
9382 val += rel->r_addend;
9383
9384 if (val > toc->rawsize)
9385 val = toc->rawsize;
9386 else if ((skip[val >> 3] & ref_from_discarded) != 0)
9387 continue;
9388 else if ((skip[val >> 3] & can_optimize) != 0)
9389 {
9390 Elf_Internal_Rela *tocrel
9391 = toc_relocs + (skip[val >> 3] >> 2);
9392 unsigned long tsym = ELF64_R_SYM (tocrel->r_info);
9393
9394 switch (r_type)
9395 {
9396 case R_PPC64_TOC16_HA:
9397 rel->r_info = ELF64_R_INFO (tsym, R_PPC64_TOC16_HA);
9398 break;
9399
9400 case R_PPC64_TOC16_LO_DS:
9401 rel->r_info = ELF64_R_INFO (tsym, R_PPC64_LO_DS_OPT);
9402 break;
9403
9404 default:
9405 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
9406 ppc_howto_init ();
9407 info->callbacks->einfo
9408 /* xgettext:c-format */
9409 (_("%H: %s references "
9410 "optimized away TOC entry\n"),
9411 ibfd, sec, rel->r_offset,
9412 ppc64_elf_howto_table[r_type]->name);
9413 bfd_set_error (bfd_error_bad_value);
9414 goto error_ret;
9415 }
9416 rel->r_addend = tocrel->r_addend;
9417 elf_section_data (sec)->relocs = relstart;
9418 continue;
9419 }
9420
9421 if (h != NULL || sym->st_value != 0)
9422 continue;
9423
9424 rel->r_addend -= skip[val >> 3];
9425 elf_section_data (sec)->relocs = relstart;
9426 }
9427
9428 if (elf_section_data (sec)->relocs != relstart)
9429 free (relstart);
9430 }
9431
9432 /* We shouldn't have local or global symbols defined in the TOC,
9433 but handle them anyway. */
9434 if (local_syms != NULL)
9435 for (sym = local_syms;
9436 sym < local_syms + symtab_hdr->sh_info;
9437 ++sym)
9438 if (sym->st_value != 0
9439 && bfd_section_from_elf_index (ibfd, sym->st_shndx) == toc)
9440 {
9441 unsigned long i;
9442
9443 if (sym->st_value > toc->rawsize)
9444 i = toc->rawsize >> 3;
9445 else
9446 i = sym->st_value >> 3;
9447
9448 if ((skip[i] & (ref_from_discarded | can_optimize)) != 0)
9449 {
9450 if (local_toc_syms)
9451 _bfd_error_handler
9452 (_("%s defined on removed toc entry"),
9453 bfd_elf_sym_name (ibfd, symtab_hdr, sym, NULL));
9454 do
9455 ++i;
9456 while ((skip[i] & (ref_from_discarded | can_optimize)));
9457 sym->st_value = (bfd_vma) i << 3;
9458 }
9459
9460 sym->st_value -= skip[i];
9461 symtab_hdr->contents = (unsigned char *) local_syms;
9462 }
9463
9464 /* Adjust any global syms defined in this toc input section. */
9465 if (toc_inf.global_toc_syms)
9466 {
9467 toc_inf.toc = toc;
9468 toc_inf.skip = skip;
9469 toc_inf.global_toc_syms = FALSE;
9470 elf_link_hash_traverse (elf_hash_table (info), adjust_toc_syms,
9471 &toc_inf);
9472 }
9473
9474 if (toc->reloc_count != 0)
9475 {
9476 Elf_Internal_Shdr *rel_hdr;
9477 Elf_Internal_Rela *wrel;
9478 bfd_size_type sz;
9479
9480 /* Remove unused toc relocs, and adjust those we keep. */
9481 if (toc_relocs == NULL)
9482 toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
9483 info->keep_memory);
9484 if (toc_relocs == NULL)
9485 goto error_ret;
9486
9487 wrel = toc_relocs;
9488 for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
9489 if ((skip[rel->r_offset >> 3]
9490 & (ref_from_discarded | can_optimize)) == 0)
9491 {
9492 wrel->r_offset = rel->r_offset - skip[rel->r_offset >> 3];
9493 wrel->r_info = rel->r_info;
9494 wrel->r_addend = rel->r_addend;
9495 ++wrel;
9496 }
9497 else if (!dec_dynrel_count (rel->r_info, toc, info,
9498 &local_syms, NULL, NULL))
9499 goto error_ret;
9500
9501 elf_section_data (toc)->relocs = toc_relocs;
9502 toc->reloc_count = wrel - toc_relocs;
9503 rel_hdr = _bfd_elf_single_rel_hdr (toc);
9504 sz = rel_hdr->sh_entsize;
9505 rel_hdr->sh_size = toc->reloc_count * sz;
9506 }
9507 }
9508 else if (toc_relocs != NULL
9509 && elf_section_data (toc)->relocs != toc_relocs)
9510 free (toc_relocs);
9511
9512 if (local_syms != NULL
9513 && symtab_hdr->contents != (unsigned char *) local_syms)
9514 {
9515 if (!info->keep_memory)
9516 free (local_syms);
9517 else
9518 symtab_hdr->contents = (unsigned char *) local_syms;
9519 }
9520 free (skip);
9521 }
9522
9523 return TRUE;
9524 }
9525
9526 /* Return true iff input section I references the TOC using
9527 instructions limited to +/-32k offsets. */
9528
9529 bfd_boolean
9530 ppc64_elf_has_small_toc_reloc (asection *i)
9531 {
9532 return (is_ppc64_elf (i->owner)
9533 && ppc64_elf_tdata (i->owner)->has_small_toc_reloc);
9534 }
9535
9536 /* Allocate space for one GOT entry. */
9537
9538 static void
9539 allocate_got (struct elf_link_hash_entry *h,
9540 struct bfd_link_info *info,
9541 struct got_entry *gent)
9542 {
9543 struct ppc_link_hash_table *htab = ppc_hash_table (info);
9544 struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
9545 int entsize = (gent->tls_type & eh->tls_mask & (TLS_GD | TLS_LD)
9546 ? 16 : 8);
9547 int rentsize = (gent->tls_type & eh->tls_mask & TLS_GD
9548 ? 2 : 1) * sizeof (Elf64_External_Rela);
9549 asection *got = ppc64_elf_tdata (gent->owner)->got;
9550
9551 gent->got.offset = got->size;
9552 got->size += entsize;
9553
9554 if (h->type == STT_GNU_IFUNC)
9555 {
9556 htab->elf.irelplt->size += rentsize;
9557 htab->got_reli_size += rentsize;
9558 }
9559 else if (((bfd_link_pic (info)
9560 && !((gent->tls_type & TLS_TPREL) != 0
9561 && bfd_link_executable (info)
9562 && SYMBOL_REFERENCES_LOCAL (info, h)))
9563 || (htab->elf.dynamic_sections_created
9564 && h->dynindx != -1
9565 && !SYMBOL_REFERENCES_LOCAL (info, h)))
9566 && !UNDEFWEAK_NO_DYNAMIC_RELOC (info, h))
9567 {
9568 asection *relgot = ppc64_elf_tdata (gent->owner)->relgot;
9569 relgot->size += rentsize;
9570 }
9571 }
9572
9573 /* This function merges got entries in the same toc group. */
9574
9575 static void
9576 merge_got_entries (struct got_entry **pent)
9577 {
9578 struct got_entry *ent, *ent2;
9579
9580 for (ent = *pent; ent != NULL; ent = ent->next)
9581 if (!ent->is_indirect)
9582 for (ent2 = ent->next; ent2 != NULL; ent2 = ent2->next)
9583 if (!ent2->is_indirect
9584 && ent2->addend == ent->addend
9585 && ent2->tls_type == ent->tls_type
9586 && elf_gp (ent2->owner) == elf_gp (ent->owner))
9587 {
9588 ent2->is_indirect = TRUE;
9589 ent2->got.ent = ent;
9590 }
9591 }
9592
9593 /* If H is undefined, make it dynamic if that makes sense. */
9594
9595 static bfd_boolean
9596 ensure_undef_dynamic (struct bfd_link_info *info,
9597 struct elf_link_hash_entry *h)
9598 {
9599 struct elf_link_hash_table *htab = elf_hash_table (info);
9600
9601 if (htab->dynamic_sections_created
9602 && ((info->dynamic_undefined_weak != 0
9603 && h->root.type == bfd_link_hash_undefweak)
9604 || h->root.type == bfd_link_hash_undefined)
9605 && h->dynindx == -1
9606 && !h->forced_local
9607 && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
9608 return bfd_elf_link_record_dynamic_symbol (info, h);
9609 return TRUE;
9610 }
9611
9612 /* Allocate space in .plt, .got and associated reloc sections for
9613 dynamic relocs. */
9614
9615 static bfd_boolean
9616 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
9617 {
9618 struct bfd_link_info *info;
9619 struct ppc_link_hash_table *htab;
9620 asection *s;
9621 struct ppc_link_hash_entry *eh;
9622 struct got_entry **pgent, *gent;
9623
9624 if (h->root.type == bfd_link_hash_indirect)
9625 return TRUE;
9626
9627 info = (struct bfd_link_info *) inf;
9628 htab = ppc_hash_table (info);
9629 if (htab == NULL)
9630 return FALSE;
9631
9632 eh = (struct ppc_link_hash_entry *) h;
9633 /* Run through the TLS GD got entries first if we're changing them
9634 to TPREL. */
9635 if ((eh->tls_mask & TLS_TPRELGD) != 0)
9636 for (gent = h->got.glist; gent != NULL; gent = gent->next)
9637 if (gent->got.refcount > 0
9638 && (gent->tls_type & TLS_GD) != 0)
9639 {
9640 /* This was a GD entry that has been converted to TPREL. If
9641 there happens to be a TPREL entry we can use that one. */
9642 struct got_entry *ent;
9643 for (ent = h->got.glist; ent != NULL; ent = ent->next)
9644 if (ent->got.refcount > 0
9645 && (ent->tls_type & TLS_TPREL) != 0
9646 && ent->addend == gent->addend
9647 && ent->owner == gent->owner)
9648 {
9649 gent->got.refcount = 0;
9650 break;
9651 }
9652
9653 /* If not, then we'll be using our own TPREL entry. */
9654 if (gent->got.refcount != 0)
9655 gent->tls_type = TLS_TLS | TLS_TPREL;
9656 }
9657
9658 /* Remove any list entry that won't generate a word in the GOT before
9659 we call merge_got_entries. Otherwise we risk merging to empty
9660 entries. */
9661 pgent = &h->got.glist;
9662 while ((gent = *pgent) != NULL)
9663 if (gent->got.refcount > 0)
9664 {
9665 if ((gent->tls_type & TLS_LD) != 0
9666 && !h->def_dynamic)
9667 {
9668 ppc64_tlsld_got (gent->owner)->got.refcount += 1;
9669 *pgent = gent->next;
9670 }
9671 else
9672 pgent = &gent->next;
9673 }
9674 else
9675 *pgent = gent->next;
9676
9677 if (!htab->do_multi_toc)
9678 merge_got_entries (&h->got.glist);
9679
9680 for (gent = h->got.glist; gent != NULL; gent = gent->next)
9681 if (!gent->is_indirect)
9682 {
9683 /* Make sure this symbol is output as a dynamic symbol. */
9684 if (!ensure_undef_dynamic (info, h))
9685 return FALSE;
9686
9687 if (!is_ppc64_elf (gent->owner))
9688 abort ();
9689
9690 allocate_got (h, info, gent);
9691 }
9692
9693 /* If no dynamic sections we can't have dynamic relocs, except for
9694 IFUNCs which are handled even in static executables. */
9695 if (!htab->elf.dynamic_sections_created
9696 && h->type != STT_GNU_IFUNC)
9697 eh->dyn_relocs = NULL;
9698
9699 /* Discard relocs on undefined symbols that must be local. */
9700 else if (h->root.type == bfd_link_hash_undefined
9701 && ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
9702 eh->dyn_relocs = NULL;
9703
9704 /* Also discard relocs on undefined weak syms with non-default
9705 visibility, or when dynamic_undefined_weak says so. */
9706 else if (UNDEFWEAK_NO_DYNAMIC_RELOC (info, h))
9707 eh->dyn_relocs = NULL;
9708
9709 if (eh->dyn_relocs != NULL)
9710 {
9711 struct elf_dyn_relocs *p, **pp;
9712
9713 /* In the shared -Bsymbolic case, discard space allocated for
9714 dynamic pc-relative relocs against symbols which turn out to
9715 be defined in regular objects. For the normal shared case,
9716 discard space for relocs that have become local due to symbol
9717 visibility changes. */
9718
9719 if (bfd_link_pic (info))
9720 {
9721 /* Relocs that use pc_count are those that appear on a call
9722 insn, or certain REL relocs (see must_be_dyn_reloc) that
9723 can be generated via assembly. We want calls to
9724 protected symbols to resolve directly to the function
9725 rather than going via the plt. If people want function
9726 pointer comparisons to work as expected then they should
9727 avoid writing weird assembly. */
9728 if (SYMBOL_CALLS_LOCAL (info, h))
9729 {
9730 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
9731 {
9732 p->count -= p->pc_count;
9733 p->pc_count = 0;
9734 if (p->count == 0)
9735 *pp = p->next;
9736 else
9737 pp = &p->next;
9738 }
9739 }
9740
9741 if (eh->dyn_relocs != NULL)
9742 {
9743 /* Make sure this symbol is output as a dynamic symbol. */
9744 if (!ensure_undef_dynamic (info, h))
9745 return FALSE;
9746 }
9747 }
9748 else if (ELIMINATE_COPY_RELOCS && h->type != STT_GNU_IFUNC)
9749 {
9750 /* For the non-pic case, discard space for relocs against
9751 symbols which turn out to need copy relocs or are not
9752 dynamic. */
9753 if (h->dynamic_adjusted
9754 && !h->def_regular
9755 && !ELF_COMMON_DEF_P (h))
9756 {
9757 /* Make sure this symbol is output as a dynamic symbol. */
9758 if (!ensure_undef_dynamic (info, h))
9759 return FALSE;
9760
9761 if (h->dynindx == -1)
9762 eh->dyn_relocs = NULL;
9763 }
9764 else
9765 eh->dyn_relocs = NULL;
9766 }
9767
9768 /* Finally, allocate space. */
9769 for (p = eh->dyn_relocs; p != NULL; p = p->next)
9770 {
9771 asection *sreloc = elf_section_data (p->sec)->sreloc;
9772 if (eh->elf.type == STT_GNU_IFUNC)
9773 sreloc = htab->elf.irelplt;
9774 sreloc->size += p->count * sizeof (Elf64_External_Rela);
9775 }
9776 }
9777
9778 if ((htab->elf.dynamic_sections_created
9779 && h->dynindx != -1)
9780 || h->type == STT_GNU_IFUNC)
9781 {
9782 struct plt_entry *pent;
9783 bfd_boolean doneone = FALSE;
9784 for (pent = h->plt.plist; pent != NULL; pent = pent->next)
9785 if (pent->plt.refcount > 0)
9786 {
9787 if (!htab->elf.dynamic_sections_created
9788 || h->dynindx == -1)
9789 {
9790 s = htab->elf.iplt;
9791 pent->plt.offset = s->size;
9792 s->size += PLT_ENTRY_SIZE (htab);
9793 s = htab->elf.irelplt;
9794 }
9795 else
9796 {
9797 /* If this is the first .plt entry, make room for the special
9798 first entry. */
9799 s = htab->elf.splt;
9800 if (s->size == 0)
9801 s->size += PLT_INITIAL_ENTRY_SIZE (htab);
9802
9803 pent->plt.offset = s->size;
9804
9805 /* Make room for this entry. */
9806 s->size += PLT_ENTRY_SIZE (htab);
9807
9808 /* Make room for the .glink code. */
9809 s = htab->glink;
9810 if (s->size == 0)
9811 s->size += GLINK_PLTRESOLVE_SIZE (htab);
9812 if (htab->opd_abi)
9813 {
9814 /* We need bigger stubs past index 32767. */
9815 if (s->size >= GLINK_PLTRESOLVE_SIZE (htab) + 32768*2*4)
9816 s->size += 4;
9817 s->size += 2*4;
9818 }
9819 else
9820 s->size += 4;
9821
9822 /* We also need to make an entry in the .rela.plt section. */
9823 s = htab->elf.srelplt;
9824 }
9825 s->size += sizeof (Elf64_External_Rela);
9826 doneone = TRUE;
9827 }
9828 else
9829 pent->plt.offset = (bfd_vma) -1;
9830 if (!doneone)
9831 {
9832 h->plt.plist = NULL;
9833 h->needs_plt = 0;
9834 }
9835 }
9836 else
9837 {
9838 h->plt.plist = NULL;
9839 h->needs_plt = 0;
9840 }
9841
9842 return TRUE;
9843 }
9844
9845 #define PPC_LO(v) ((v) & 0xffff)
9846 #define PPC_HI(v) (((v) >> 16) & 0xffff)
9847 #define PPC_HA(v) PPC_HI ((v) + 0x8000)
9848
9849 /* Called via elf_link_hash_traverse from ppc64_elf_size_dynamic_sections
9850 to set up space for global entry stubs. These are put in glink,
9851 after the branch table. */
9852
9853 static bfd_boolean
9854 size_global_entry_stubs (struct elf_link_hash_entry *h, void *inf)
9855 {
9856 struct bfd_link_info *info;
9857 struct ppc_link_hash_table *htab;
9858 struct plt_entry *pent;
9859 asection *s, *plt;
9860
9861 if (h->root.type == bfd_link_hash_indirect)
9862 return TRUE;
9863
9864 if (!h->pointer_equality_needed)
9865 return TRUE;
9866
9867 if (h->def_regular)
9868 return TRUE;
9869
9870 info = inf;
9871 htab = ppc_hash_table (info);
9872 if (htab == NULL)
9873 return FALSE;
9874
9875 s = htab->global_entry;
9876 plt = htab->elf.splt;
9877 for (pent = h->plt.plist; pent != NULL; pent = pent->next)
9878 if (pent->plt.offset != (bfd_vma) -1
9879 && pent->addend == 0)
9880 {
9881 /* For ELFv2, if this symbol is not defined in a regular file
9882 and we are not generating a shared library or pie, then we
9883 need to define the symbol in the executable on a call stub.
9884 This is to avoid text relocations. */
9885 bfd_vma off, stub_align, stub_off, stub_size;
9886 unsigned int align_power;
9887
9888 stub_size = 16;
9889 if (!htab->params->speculate_indirect_jumps)
9890 stub_size += 8;
9891 stub_off = s->size;
9892 if (htab->params->plt_stub_align >= 0)
9893 align_power = htab->params->plt_stub_align;
9894 else
9895 align_power = -htab->params->plt_stub_align;
9896 /* Setting section alignment is delayed until we know it is
9897 non-empty. Otherwise the .text output section will be
9898 aligned at least to plt_stub_align even when no global
9899 entry stubs are needed. */
9900 if (s->alignment_power < align_power)
9901 s->alignment_power = align_power;
9902 stub_align = (bfd_vma) 1 << align_power;
9903 if (htab->params->plt_stub_align >= 0
9904 || ((((stub_off + stub_size - 1) & -stub_align)
9905 - (stub_off & -stub_align))
9906 > ((stub_size - 1) & -stub_align)))
9907 stub_off = (stub_off + stub_align - 1) & -stub_align;
9908 off = pent->plt.offset + plt->output_offset + plt->output_section->vma;
9909 off -= stub_off + s->output_offset + s->output_section->vma;
9910 /* Note that for --plt-stub-align negative we have a possible
9911 dependency between stub offset and size. Break that
9912 dependency by assuming the max stub size when calculating
9913 the stub offset. */
9914 if (PPC_HA (off) == 0)
9915 stub_size -= 4;
9916 h->root.type = bfd_link_hash_defined;
9917 h->root.u.def.section = s;
9918 h->root.u.def.value = stub_off;
9919 s->size = stub_off + stub_size;
9920 break;
9921 }
9922 return TRUE;
9923 }
9924
9925 /* Set DF_TEXTREL if we find any dynamic relocs that apply to
9926 read-only sections. */
9927
9928 static bfd_boolean
9929 maybe_set_textrel (struct elf_link_hash_entry *h, void *inf)
9930 {
9931 asection *sec;
9932
9933 if (h->root.type == bfd_link_hash_indirect)
9934 return TRUE;
9935
9936 sec = readonly_dynrelocs (h);
9937 if (sec != NULL)
9938 {
9939 struct bfd_link_info *info = (struct bfd_link_info *) inf;
9940
9941 info->flags |= DF_TEXTREL;
9942 info->callbacks->minfo
9943 (_("%B: dynamic relocation against `%T' in read-only section `%A'\n"),
9944 sec->owner, h->root.root.string, sec);
9945
9946 /* Not an error, just cut short the traversal. */
9947 return FALSE;
9948 }
9949 return TRUE;
9950 }
9951
9952 /* Set the sizes of the dynamic sections. */
9953
9954 static bfd_boolean
9955 ppc64_elf_size_dynamic_sections (bfd *output_bfd,
9956 struct bfd_link_info *info)
9957 {
9958 struct ppc_link_hash_table *htab;
9959 bfd *dynobj;
9960 asection *s;
9961 bfd_boolean relocs;
9962 bfd *ibfd;
9963 struct got_entry *first_tlsld;
9964
9965 htab = ppc_hash_table (info);
9966 if (htab == NULL)
9967 return FALSE;
9968
9969 dynobj = htab->elf.dynobj;
9970 if (dynobj == NULL)
9971 abort ();
9972
9973 if (htab->elf.dynamic_sections_created)
9974 {
9975 /* Set the contents of the .interp section to the interpreter. */
9976 if (bfd_link_executable (info) && !info->nointerp)
9977 {
9978 s = bfd_get_linker_section (dynobj, ".interp");
9979 if (s == NULL)
9980 abort ();
9981 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
9982 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
9983 }
9984 }
9985
9986 /* Set up .got offsets for local syms, and space for local dynamic
9987 relocs. */
9988 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
9989 {
9990 struct got_entry **lgot_ents;
9991 struct got_entry **end_lgot_ents;
9992 struct plt_entry **local_plt;
9993 struct plt_entry **end_local_plt;
9994 unsigned char *lgot_masks;
9995 bfd_size_type locsymcount;
9996 Elf_Internal_Shdr *symtab_hdr;
9997
9998 if (!is_ppc64_elf (ibfd))
9999 continue;
10000
10001 for (s = ibfd->sections; s != NULL; s = s->next)
10002 {
10003 struct ppc_dyn_relocs *p;
10004
10005 for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
10006 {
10007 if (!bfd_is_abs_section (p->sec)
10008 && bfd_is_abs_section (p->sec->output_section))
10009 {
10010 /* Input section has been discarded, either because
10011 it is a copy of a linkonce section or due to
10012 linker script /DISCARD/, so we'll be discarding
10013 the relocs too. */
10014 }
10015 else if (p->count != 0)
10016 {
10017 asection *srel = elf_section_data (p->sec)->sreloc;
10018 if (p->ifunc)
10019 srel = htab->elf.irelplt;
10020 srel->size += p->count * sizeof (Elf64_External_Rela);
10021 if ((p->sec->output_section->flags & SEC_READONLY) != 0)
10022 info->flags |= DF_TEXTREL;
10023 }
10024 }
10025 }
10026
10027 lgot_ents = elf_local_got_ents (ibfd);
10028 if (!lgot_ents)
10029 continue;
10030
10031 symtab_hdr = &elf_symtab_hdr (ibfd);
10032 locsymcount = symtab_hdr->sh_info;
10033 end_lgot_ents = lgot_ents + locsymcount;
10034 local_plt = (struct plt_entry **) end_lgot_ents;
10035 end_local_plt = local_plt + locsymcount;
10036 lgot_masks = (unsigned char *) end_local_plt;
10037 s = ppc64_elf_tdata (ibfd)->got;
10038 for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
10039 {
10040 struct got_entry **pent, *ent;
10041
10042 pent = lgot_ents;
10043 while ((ent = *pent) != NULL)
10044 if (ent->got.refcount > 0)
10045 {
10046 if ((ent->tls_type & *lgot_masks & TLS_LD) != 0)
10047 {
10048 ppc64_tlsld_got (ibfd)->got.refcount += 1;
10049 *pent = ent->next;
10050 }
10051 else
10052 {
10053 unsigned int ent_size = 8;
10054 unsigned int rel_size = sizeof (Elf64_External_Rela);
10055
10056 ent->got.offset = s->size;
10057 if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
10058 {
10059 ent_size *= 2;
10060 rel_size *= 2;
10061 }
10062 s->size += ent_size;
10063 if ((*lgot_masks & PLT_IFUNC) != 0)
10064 {
10065 htab->elf.irelplt->size += rel_size;
10066 htab->got_reli_size += rel_size;
10067 }
10068 else if (bfd_link_pic (info)
10069 && !((ent->tls_type & TLS_TPREL) != 0
10070 && bfd_link_executable (info)))
10071 {
10072 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
10073 srel->size += rel_size;
10074 }
10075 pent = &ent->next;
10076 }
10077 }
10078 else
10079 *pent = ent->next;
10080 }
10081
10082 /* Allocate space for calls to local STT_GNU_IFUNC syms in .iplt. */
10083 for (; local_plt < end_local_plt; ++local_plt)
10084 {
10085 struct plt_entry *ent;
10086
10087 for (ent = *local_plt; ent != NULL; ent = ent->next)
10088 if (ent->plt.refcount > 0)
10089 {
10090 s = htab->elf.iplt;
10091 ent->plt.offset = s->size;
10092 s->size += PLT_ENTRY_SIZE (htab);
10093
10094 htab->elf.irelplt->size += sizeof (Elf64_External_Rela);
10095 }
10096 else
10097 ent->plt.offset = (bfd_vma) -1;
10098 }
10099 }
10100
10101 /* Allocate global sym .plt and .got entries, and space for global
10102 sym dynamic relocs. */
10103 elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, info);
10104
10105 if (!htab->opd_abi && !bfd_link_pic (info))
10106 elf_link_hash_traverse (&htab->elf, size_global_entry_stubs, info);
10107
10108 first_tlsld = NULL;
10109 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
10110 {
10111 struct got_entry *ent;
10112
10113 if (!is_ppc64_elf (ibfd))
10114 continue;
10115
10116 ent = ppc64_tlsld_got (ibfd);
10117 if (ent->got.refcount > 0)
10118 {
10119 if (!htab->do_multi_toc && first_tlsld != NULL)
10120 {
10121 ent->is_indirect = TRUE;
10122 ent->got.ent = first_tlsld;
10123 }
10124 else
10125 {
10126 if (first_tlsld == NULL)
10127 first_tlsld = ent;
10128 s = ppc64_elf_tdata (ibfd)->got;
10129 ent->got.offset = s->size;
10130 ent->owner = ibfd;
10131 s->size += 16;
10132 if (bfd_link_pic (info))
10133 {
10134 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
10135 srel->size += sizeof (Elf64_External_Rela);
10136 }
10137 }
10138 }
10139 else
10140 ent->got.offset = (bfd_vma) -1;
10141 }
10142
10143 /* We now have determined the sizes of the various dynamic sections.
10144 Allocate memory for them. */
10145 relocs = FALSE;
10146 for (s = dynobj->sections; s != NULL; s = s->next)
10147 {
10148 if ((s->flags & SEC_LINKER_CREATED) == 0)
10149 continue;
10150
10151 if (s == htab->brlt || s == htab->relbrlt)
10152 /* These haven't been allocated yet; don't strip. */
10153 continue;
10154 else if (s == htab->elf.sgot
10155 || s == htab->elf.splt
10156 || s == htab->elf.iplt
10157 || s == htab->glink
10158 || s == htab->global_entry
10159 || s == htab->elf.sdynbss
10160 || s == htab->elf.sdynrelro)
10161 {
10162 /* Strip this section if we don't need it; see the
10163 comment below. */
10164 }
10165 else if (s == htab->glink_eh_frame)
10166 {
10167 if (!bfd_is_abs_section (s->output_section))
10168 /* Not sized yet. */
10169 continue;
10170 }
10171 else if (CONST_STRNEQ (s->name, ".rela"))
10172 {
10173 if (s->size != 0)
10174 {
10175 if (s != htab->elf.srelplt)
10176 relocs = TRUE;
10177
10178 /* We use the reloc_count field as a counter if we need
10179 to copy relocs into the output file. */
10180 s->reloc_count = 0;
10181 }
10182 }
10183 else
10184 {
10185 /* It's not one of our sections, so don't allocate space. */
10186 continue;
10187 }
10188
10189 if (s->size == 0)
10190 {
10191 /* If we don't need this section, strip it from the
10192 output file. This is mostly to handle .rela.bss and
10193 .rela.plt. We must create both sections in
10194 create_dynamic_sections, because they must be created
10195 before the linker maps input sections to output
10196 sections. The linker does that before
10197 adjust_dynamic_symbol is called, and it is that
10198 function which decides whether anything needs to go
10199 into these sections. */
10200 s->flags |= SEC_EXCLUDE;
10201 continue;
10202 }
10203
10204 if (bfd_is_abs_section (s->output_section))
10205 _bfd_error_handler (_("warning: discarding dynamic section %s"),
10206 s->name);
10207
10208 if ((s->flags & SEC_HAS_CONTENTS) == 0)
10209 continue;
10210
10211 /* Allocate memory for the section contents. We use bfd_zalloc
10212 here in case unused entries are not reclaimed before the
10213 section's contents are written out. This should not happen,
10214 but this way if it does we get a R_PPC64_NONE reloc in .rela
10215 sections instead of garbage.
10216 We also rely on the section contents being zero when writing
10217 the GOT and .dynrelro. */
10218 s->contents = bfd_zalloc (dynobj, s->size);
10219 if (s->contents == NULL)
10220 return FALSE;
10221 }
10222
10223 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
10224 {
10225 if (!is_ppc64_elf (ibfd))
10226 continue;
10227
10228 s = ppc64_elf_tdata (ibfd)->got;
10229 if (s != NULL && s != htab->elf.sgot)
10230 {
10231 if (s->size == 0)
10232 s->flags |= SEC_EXCLUDE;
10233 else
10234 {
10235 s->contents = bfd_zalloc (ibfd, s->size);
10236 if (s->contents == NULL)
10237 return FALSE;
10238 }
10239 }
10240 s = ppc64_elf_tdata (ibfd)->relgot;
10241 if (s != NULL)
10242 {
10243 if (s->size == 0)
10244 s->flags |= SEC_EXCLUDE;
10245 else
10246 {
10247 s->contents = bfd_zalloc (ibfd, s->size);
10248 if (s->contents == NULL)
10249 return FALSE;
10250 relocs = TRUE;
10251 s->reloc_count = 0;
10252 }
10253 }
10254 }
10255
10256 if (htab->elf.dynamic_sections_created)
10257 {
10258 bfd_boolean tls_opt;
10259
10260 /* Add some entries to the .dynamic section. We fill in the
10261 values later, in ppc64_elf_finish_dynamic_sections, but we
10262 must add the entries now so that we get the correct size for
10263 the .dynamic section. The DT_DEBUG entry is filled in by the
10264 dynamic linker and used by the debugger. */
10265 #define add_dynamic_entry(TAG, VAL) \
10266 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
10267
10268 if (bfd_link_executable (info))
10269 {
10270 if (!add_dynamic_entry (DT_DEBUG, 0))
10271 return FALSE;
10272 }
10273
10274 if (htab->elf.splt != NULL && htab->elf.splt->size != 0)
10275 {
10276 if (!add_dynamic_entry (DT_PLTGOT, 0)
10277 || !add_dynamic_entry (DT_PLTRELSZ, 0)
10278 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
10279 || !add_dynamic_entry (DT_JMPREL, 0)
10280 || !add_dynamic_entry (DT_PPC64_GLINK, 0))
10281 return FALSE;
10282 }
10283
10284 if (NO_OPD_RELOCS && abiversion (output_bfd) <= 1)
10285 {
10286 if (!add_dynamic_entry (DT_PPC64_OPD, 0)
10287 || !add_dynamic_entry (DT_PPC64_OPDSZ, 0))
10288 return FALSE;
10289 }
10290
10291 tls_opt = (htab->params->tls_get_addr_opt
10292 && htab->tls_get_addr_fd != NULL
10293 && htab->tls_get_addr_fd->elf.plt.plist != NULL);
10294 if (tls_opt || !htab->opd_abi)
10295 {
10296 if (!add_dynamic_entry (DT_PPC64_OPT, tls_opt ? PPC64_OPT_TLS : 0))
10297 return FALSE;
10298 }
10299
10300 if (relocs)
10301 {
10302 if (!add_dynamic_entry (DT_RELA, 0)
10303 || !add_dynamic_entry (DT_RELASZ, 0)
10304 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
10305 return FALSE;
10306
10307 /* If any dynamic relocs apply to a read-only section,
10308 then we need a DT_TEXTREL entry. */
10309 if ((info->flags & DF_TEXTREL) == 0)
10310 elf_link_hash_traverse (&htab->elf, maybe_set_textrel, info);
10311
10312 if ((info->flags & DF_TEXTREL) != 0)
10313 {
10314 if (!add_dynamic_entry (DT_TEXTREL, 0))
10315 return FALSE;
10316 }
10317 }
10318 }
10319 #undef add_dynamic_entry
10320
10321 return TRUE;
10322 }
10323
10324 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
10325
10326 static bfd_boolean
10327 ppc64_elf_hash_symbol (struct elf_link_hash_entry *h)
10328 {
10329 if (h->plt.plist != NULL
10330 && !h->def_regular
10331 && !h->pointer_equality_needed)
10332 return FALSE;
10333
10334 return _bfd_elf_hash_symbol (h);
10335 }
10336
10337 /* Determine the type of stub needed, if any, for a call. */
10338
10339 static inline enum ppc_stub_type
10340 ppc_type_of_stub (asection *input_sec,
10341 const Elf_Internal_Rela *rel,
10342 struct ppc_link_hash_entry **hash,
10343 struct plt_entry **plt_ent,
10344 bfd_vma destination,
10345 unsigned long local_off)
10346 {
10347 struct ppc_link_hash_entry *h = *hash;
10348 bfd_vma location;
10349 bfd_vma branch_offset;
10350 bfd_vma max_branch_offset;
10351 enum elf_ppc64_reloc_type r_type;
10352
10353 if (h != NULL)
10354 {
10355 struct plt_entry *ent;
10356 struct ppc_link_hash_entry *fdh = h;
10357 if (h->oh != NULL
10358 && h->oh->is_func_descriptor)
10359 {
10360 fdh = ppc_follow_link (h->oh);
10361 *hash = fdh;
10362 }
10363
10364 for (ent = fdh->elf.plt.plist; ent != NULL; ent = ent->next)
10365 if (ent->addend == rel->r_addend
10366 && ent->plt.offset != (bfd_vma) -1)
10367 {
10368 *plt_ent = ent;
10369 return ppc_stub_plt_call;
10370 }
10371
10372 /* Here, we know we don't have a plt entry. If we don't have a
10373 either a defined function descriptor or a defined entry symbol
10374 in a regular object file, then it is pointless trying to make
10375 any other type of stub. */
10376 if (!is_static_defined (&fdh->elf)
10377 && !is_static_defined (&h->elf))
10378 return ppc_stub_none;
10379 }
10380 else if (elf_local_got_ents (input_sec->owner) != NULL)
10381 {
10382 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (input_sec->owner);
10383 struct plt_entry **local_plt = (struct plt_entry **)
10384 elf_local_got_ents (input_sec->owner) + symtab_hdr->sh_info;
10385 unsigned long r_symndx = ELF64_R_SYM (rel->r_info);
10386
10387 if (local_plt[r_symndx] != NULL)
10388 {
10389 struct plt_entry *ent;
10390
10391 for (ent = local_plt[r_symndx]; ent != NULL; ent = ent->next)
10392 if (ent->addend == rel->r_addend
10393 && ent->plt.offset != (bfd_vma) -1)
10394 {
10395 *plt_ent = ent;
10396 return ppc_stub_plt_call;
10397 }
10398 }
10399 }
10400
10401 /* Determine where the call point is. */
10402 location = (input_sec->output_offset
10403 + input_sec->output_section->vma
10404 + rel->r_offset);
10405
10406 branch_offset = destination - location;
10407 r_type = ELF64_R_TYPE (rel->r_info);
10408
10409 /* Determine if a long branch stub is needed. */
10410 max_branch_offset = 1 << 25;
10411 if (r_type != R_PPC64_REL24)
10412 max_branch_offset = 1 << 15;
10413
10414 if (branch_offset + max_branch_offset >= 2 * max_branch_offset - local_off)
10415 /* We need a stub. Figure out whether a long_branch or plt_branch
10416 is needed later. */
10417 return ppc_stub_long_branch;
10418
10419 return ppc_stub_none;
10420 }
10421
10422 /* With power7 weakly ordered memory model, it is possible for ld.so
10423 to update a plt entry in one thread and have another thread see a
10424 stale zero toc entry. To avoid this we need some sort of acquire
10425 barrier in the call stub. One solution is to make the load of the
10426 toc word seem to appear to depend on the load of the function entry
10427 word. Another solution is to test for r2 being zero, and branch to
10428 the appropriate glink entry if so.
10429
10430 . fake dep barrier compare
10431 . ld 12,xxx(2) ld 12,xxx(2)
10432 . mtctr 12 mtctr 12
10433 . xor 11,12,12 ld 2,xxx+8(2)
10434 . add 2,2,11 cmpldi 2,0
10435 . ld 2,xxx+8(2) bnectr+
10436 . bctr b <glink_entry>
10437
10438 The solution involving the compare turns out to be faster, so
10439 that's what we use unless the branch won't reach. */
10440
10441 #define ALWAYS_USE_FAKE_DEP 0
10442 #define ALWAYS_EMIT_R2SAVE 0
10443
10444 static inline unsigned int
10445 plt_stub_size (struct ppc_link_hash_table *htab,
10446 struct ppc_stub_hash_entry *stub_entry,
10447 bfd_vma off)
10448 {
10449 unsigned size = 12;
10450
10451 if (ALWAYS_EMIT_R2SAVE
10452 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10453 size += 4;
10454 if (PPC_HA (off) != 0)
10455 size += 4;
10456 if (!htab->params->speculate_indirect_jumps)
10457 size += 8;
10458 if (htab->opd_abi)
10459 {
10460 size += 4;
10461 if (htab->params->plt_static_chain)
10462 size += 4;
10463 if (htab->params->plt_thread_safe
10464 && htab->elf.dynamic_sections_created
10465 && stub_entry->h != NULL
10466 && stub_entry->h->elf.dynindx != -1)
10467 size += 8;
10468 if (PPC_HA (off + 8 + 8 * htab->params->plt_static_chain) != PPC_HA (off))
10469 size += 4;
10470 }
10471 if (stub_entry->h != NULL
10472 && (stub_entry->h == htab->tls_get_addr_fd
10473 || stub_entry->h == htab->tls_get_addr)
10474 && htab->params->tls_get_addr_opt)
10475 {
10476 size += 7 * 4;
10477 if (ALWAYS_EMIT_R2SAVE
10478 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10479 {
10480 size += 6 * 4;
10481 if (!htab->params->speculate_indirect_jumps)
10482 size -= 4;
10483 }
10484 }
10485 return size;
10486 }
10487
10488 /* Depending on the sign of plt_stub_align:
10489 If positive, return the padding to align to a 2**plt_stub_align
10490 boundary.
10491 If negative, if this stub would cross fewer 2**plt_stub_align
10492 boundaries if we align, then return the padding needed to do so. */
10493
10494 static inline unsigned int
10495 plt_stub_pad (struct ppc_link_hash_table *htab,
10496 struct ppc_stub_hash_entry *stub_entry,
10497 bfd_vma plt_off)
10498 {
10499 int stub_align;
10500 unsigned stub_size = plt_stub_size (htab, stub_entry, plt_off);
10501 bfd_vma stub_off = stub_entry->group->stub_sec->size;
10502
10503 if (htab->params->plt_stub_align >= 0)
10504 {
10505 stub_align = 1 << htab->params->plt_stub_align;
10506 if ((stub_off & (stub_align - 1)) != 0)
10507 return stub_align - (stub_off & (stub_align - 1));
10508 return 0;
10509 }
10510
10511 stub_align = 1 << -htab->params->plt_stub_align;
10512 if (((stub_off + stub_size - 1) & -stub_align) - (stub_off & -stub_align)
10513 > ((stub_size - 1) & -stub_align))
10514 return stub_align - (stub_off & (stub_align - 1));
10515 return 0;
10516 }
10517
10518 static inline bfd_byte *
10519 output_bctr (struct ppc_link_hash_table *htab, bfd *obfd, bfd_byte *p)
10520 {
10521 if (!htab->params->speculate_indirect_jumps)
10522 {
10523 bfd_put_32 (obfd, CRSETEQ, p);
10524 p += 4;
10525 bfd_put_32 (obfd, BEQCTRM, p);
10526 p += 4;
10527 bfd_put_32 (obfd, B_DOT, p);
10528 p += 4;
10529 }
10530 else
10531 {
10532 bfd_put_32 (obfd, BCTR, p);
10533 p += 4;
10534 }
10535 return p;
10536 }
10537
10538 /* Build a .plt call stub. */
10539
10540 static inline bfd_byte *
10541 build_plt_stub (struct ppc_link_hash_table *htab,
10542 struct ppc_stub_hash_entry *stub_entry,
10543 bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
10544 {
10545 bfd *obfd = htab->params->stub_bfd;
10546 bfd_boolean plt_load_toc = htab->opd_abi;
10547 bfd_boolean plt_static_chain = htab->params->plt_static_chain;
10548 bfd_boolean plt_thread_safe = (htab->params->plt_thread_safe
10549 && htab->elf.dynamic_sections_created
10550 && stub_entry->h != NULL
10551 && stub_entry->h->elf.dynindx != -1);
10552 bfd_boolean use_fake_dep = plt_thread_safe;
10553 bfd_vma cmp_branch_off = 0;
10554
10555 if (!ALWAYS_USE_FAKE_DEP
10556 && plt_load_toc
10557 && plt_thread_safe
10558 && htab->params->speculate_indirect_jumps
10559 && !((stub_entry->h == htab->tls_get_addr_fd
10560 || stub_entry->h == htab->tls_get_addr)
10561 && htab->params->tls_get_addr_opt))
10562 {
10563 bfd_vma pltoff = stub_entry->plt_ent->plt.offset & ~1;
10564 bfd_vma pltindex = ((pltoff - PLT_INITIAL_ENTRY_SIZE (htab))
10565 / PLT_ENTRY_SIZE (htab));
10566 bfd_vma glinkoff = GLINK_PLTRESOLVE_SIZE (htab) + pltindex * 8;
10567 bfd_vma to, from;
10568
10569 if (pltindex > 32768)
10570 glinkoff += (pltindex - 32768) * 4;
10571 to = (glinkoff
10572 + htab->glink->output_offset
10573 + htab->glink->output_section->vma);
10574 from = (p - stub_entry->group->stub_sec->contents
10575 + 4 * (ALWAYS_EMIT_R2SAVE
10576 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10577 + 4 * (PPC_HA (offset) != 0)
10578 + 4 * (PPC_HA (offset + 8 + 8 * plt_static_chain)
10579 != PPC_HA (offset))
10580 + 4 * (plt_static_chain != 0)
10581 + 20
10582 + stub_entry->group->stub_sec->output_offset
10583 + stub_entry->group->stub_sec->output_section->vma);
10584 cmp_branch_off = to - from;
10585 use_fake_dep = cmp_branch_off + (1 << 25) >= (1 << 26);
10586 }
10587
10588 if (PPC_HA (offset) != 0)
10589 {
10590 if (r != NULL)
10591 {
10592 if (ALWAYS_EMIT_R2SAVE
10593 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10594 r[0].r_offset += 4;
10595 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
10596 r[1].r_offset = r[0].r_offset + 4;
10597 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10598 r[1].r_addend = r[0].r_addend;
10599 if (plt_load_toc)
10600 {
10601 if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10602 {
10603 r[2].r_offset = r[1].r_offset + 4;
10604 r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO);
10605 r[2].r_addend = r[0].r_addend;
10606 }
10607 else
10608 {
10609 r[2].r_offset = r[1].r_offset + 8 + 8 * use_fake_dep;
10610 r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10611 r[2].r_addend = r[0].r_addend + 8;
10612 if (plt_static_chain)
10613 {
10614 r[3].r_offset = r[2].r_offset + 4;
10615 r[3].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10616 r[3].r_addend = r[0].r_addend + 16;
10617 }
10618 }
10619 }
10620 }
10621 if (ALWAYS_EMIT_R2SAVE
10622 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10623 bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p), p += 4;
10624 if (plt_load_toc)
10625 {
10626 bfd_put_32 (obfd, ADDIS_R11_R2 | PPC_HA (offset), p), p += 4;
10627 bfd_put_32 (obfd, LD_R12_0R11 | PPC_LO (offset), p), p += 4;
10628 }
10629 else
10630 {
10631 bfd_put_32 (obfd, ADDIS_R12_R2 | PPC_HA (offset), p), p += 4;
10632 bfd_put_32 (obfd, LD_R12_0R12 | PPC_LO (offset), p), p += 4;
10633 }
10634 if (plt_load_toc
10635 && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10636 {
10637 bfd_put_32 (obfd, ADDI_R11_R11 | PPC_LO (offset), p), p += 4;
10638 offset = 0;
10639 }
10640 bfd_put_32 (obfd, MTCTR_R12, p), p += 4;
10641 if (plt_load_toc)
10642 {
10643 if (use_fake_dep)
10644 {
10645 bfd_put_32 (obfd, XOR_R2_R12_R12, p), p += 4;
10646 bfd_put_32 (obfd, ADD_R11_R11_R2, p), p += 4;
10647 }
10648 bfd_put_32 (obfd, LD_R2_0R11 | PPC_LO (offset + 8), p), p += 4;
10649 if (plt_static_chain)
10650 bfd_put_32 (obfd, LD_R11_0R11 | PPC_LO (offset + 16), p), p += 4;
10651 }
10652 }
10653 else
10654 {
10655 if (r != NULL)
10656 {
10657 if (ALWAYS_EMIT_R2SAVE
10658 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10659 r[0].r_offset += 4;
10660 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10661 if (plt_load_toc)
10662 {
10663 if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10664 {
10665 r[1].r_offset = r[0].r_offset + 4;
10666 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16);
10667 r[1].r_addend = r[0].r_addend;
10668 }
10669 else
10670 {
10671 r[1].r_offset = r[0].r_offset + 8 + 8 * use_fake_dep;
10672 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10673 r[1].r_addend = r[0].r_addend + 8 + 8 * plt_static_chain;
10674 if (plt_static_chain)
10675 {
10676 r[2].r_offset = r[1].r_offset + 4;
10677 r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10678 r[2].r_addend = r[0].r_addend + 8;
10679 }
10680 }
10681 }
10682 }
10683 if (ALWAYS_EMIT_R2SAVE
10684 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10685 bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p), p += 4;
10686 bfd_put_32 (obfd, LD_R12_0R2 | PPC_LO (offset), p), p += 4;
10687 if (plt_load_toc
10688 && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10689 {
10690 bfd_put_32 (obfd, ADDI_R2_R2 | PPC_LO (offset), p), p += 4;
10691 offset = 0;
10692 }
10693 bfd_put_32 (obfd, MTCTR_R12, p), p += 4;
10694 if (plt_load_toc)
10695 {
10696 if (use_fake_dep)
10697 {
10698 bfd_put_32 (obfd, XOR_R11_R12_R12, p), p += 4;
10699 bfd_put_32 (obfd, ADD_R2_R2_R11, p), p += 4;
10700 }
10701 if (plt_static_chain)
10702 bfd_put_32 (obfd, LD_R11_0R2 | PPC_LO (offset + 16), p), p += 4;
10703 bfd_put_32 (obfd, LD_R2_0R2 | PPC_LO (offset + 8), p), p += 4;
10704 }
10705 }
10706 if (plt_load_toc && plt_thread_safe && !use_fake_dep)
10707 {
10708 bfd_put_32 (obfd, CMPLDI_R2_0, p), p += 4;
10709 bfd_put_32 (obfd, BNECTR_P4, p), p += 4;
10710 bfd_put_32 (obfd, B_DOT | (cmp_branch_off & 0x3fffffc), p), p += 4;
10711 }
10712 else
10713 p = output_bctr (htab, obfd, p);
10714 return p;
10715 }
10716
10717 /* Build a special .plt call stub for __tls_get_addr. */
10718
10719 #define LD_R11_0R3 0xe9630000
10720 #define LD_R12_0R3 0xe9830000
10721 #define MR_R0_R3 0x7c601b78
10722 #define CMPDI_R11_0 0x2c2b0000
10723 #define ADD_R3_R12_R13 0x7c6c6a14
10724 #define BEQLR 0x4d820020
10725 #define MR_R3_R0 0x7c030378
10726 #define STD_R11_0R1 0xf9610000
10727 #define BCTRL 0x4e800421
10728 #define LD_R11_0R1 0xe9610000
10729 #define MTLR_R11 0x7d6803a6
10730
10731 static inline bfd_byte *
10732 build_tls_get_addr_stub (struct ppc_link_hash_table *htab,
10733 struct ppc_stub_hash_entry *stub_entry,
10734 bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
10735 {
10736 bfd *obfd = htab->params->stub_bfd;
10737
10738 bfd_put_32 (obfd, LD_R11_0R3 + 0, p), p += 4;
10739 bfd_put_32 (obfd, LD_R12_0R3 + 8, p), p += 4;
10740 bfd_put_32 (obfd, MR_R0_R3, p), p += 4;
10741 bfd_put_32 (obfd, CMPDI_R11_0, p), p += 4;
10742 bfd_put_32 (obfd, ADD_R3_R12_R13, p), p += 4;
10743 bfd_put_32 (obfd, BEQLR, p), p += 4;
10744 bfd_put_32 (obfd, MR_R3_R0, p), p += 4;
10745 if (r != NULL)
10746 r[0].r_offset += 7 * 4;
10747 if (!ALWAYS_EMIT_R2SAVE
10748 && stub_entry->stub_type != ppc_stub_plt_call_r2save)
10749 return build_plt_stub (htab, stub_entry, p, offset, r);
10750
10751 bfd_put_32 (obfd, MFLR_R11, p), p += 4;
10752 bfd_put_32 (obfd, STD_R11_0R1 + STK_LINKER (htab), p), p += 4;
10753
10754 if (r != NULL)
10755 r[0].r_offset += 2 * 4;
10756 p = build_plt_stub (htab, stub_entry, p, offset, r);
10757 if (!htab->params->speculate_indirect_jumps)
10758 {
10759 p -= 4;
10760 bfd_put_32 (obfd, BEQCTRLM, p - 4);
10761 }
10762 else
10763 bfd_put_32 (obfd, BCTRL, p - 4);
10764
10765 bfd_put_32 (obfd, LD_R2_0R1 + STK_TOC (htab), p), p += 4;
10766 bfd_put_32 (obfd, LD_R11_0R1 + STK_LINKER (htab), p), p += 4;
10767 bfd_put_32 (obfd, MTLR_R11, p), p += 4;
10768 bfd_put_32 (obfd, BLR, p), p += 4;
10769
10770 return p;
10771 }
10772
10773 static Elf_Internal_Rela *
10774 get_relocs (asection *sec, int count)
10775 {
10776 Elf_Internal_Rela *relocs;
10777 struct bfd_elf_section_data *elfsec_data;
10778
10779 elfsec_data = elf_section_data (sec);
10780 relocs = elfsec_data->relocs;
10781 if (relocs == NULL)
10782 {
10783 bfd_size_type relsize;
10784 relsize = sec->reloc_count * sizeof (*relocs);
10785 relocs = bfd_alloc (sec->owner, relsize);
10786 if (relocs == NULL)
10787 return NULL;
10788 elfsec_data->relocs = relocs;
10789 elfsec_data->rela.hdr = bfd_zalloc (sec->owner,
10790 sizeof (Elf_Internal_Shdr));
10791 if (elfsec_data->rela.hdr == NULL)
10792 return NULL;
10793 elfsec_data->rela.hdr->sh_size = (sec->reloc_count
10794 * sizeof (Elf64_External_Rela));
10795 elfsec_data->rela.hdr->sh_entsize = sizeof (Elf64_External_Rela);
10796 sec->reloc_count = 0;
10797 }
10798 relocs += sec->reloc_count;
10799 sec->reloc_count += count;
10800 return relocs;
10801 }
10802
10803 static bfd_vma
10804 get_r2off (struct bfd_link_info *info,
10805 struct ppc_stub_hash_entry *stub_entry)
10806 {
10807 struct ppc_link_hash_table *htab = ppc_hash_table (info);
10808 bfd_vma r2off = htab->sec_info[stub_entry->target_section->id].toc_off;
10809
10810 if (r2off == 0)
10811 {
10812 /* Support linking -R objects. Get the toc pointer from the
10813 opd entry. */
10814 char buf[8];
10815 if (!htab->opd_abi)
10816 return r2off;
10817 asection *opd = stub_entry->h->elf.root.u.def.section;
10818 bfd_vma opd_off = stub_entry->h->elf.root.u.def.value;
10819
10820 if (strcmp (opd->name, ".opd") != 0
10821 || opd->reloc_count != 0)
10822 {
10823 info->callbacks->einfo (_("%P: cannot find opd entry toc for `%T'\n"),
10824 stub_entry->h->elf.root.root.string);
10825 bfd_set_error (bfd_error_bad_value);
10826 return (bfd_vma) -1;
10827 }
10828 if (!bfd_get_section_contents (opd->owner, opd, buf, opd_off + 8, 8))
10829 return (bfd_vma) -1;
10830 r2off = bfd_get_64 (opd->owner, buf);
10831 r2off -= elf_gp (info->output_bfd);
10832 }
10833 r2off -= htab->sec_info[stub_entry->group->link_sec->id].toc_off;
10834 return r2off;
10835 }
10836
10837 static bfd_boolean
10838 ppc_build_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
10839 {
10840 struct ppc_stub_hash_entry *stub_entry;
10841 struct ppc_branch_hash_entry *br_entry;
10842 struct bfd_link_info *info;
10843 struct ppc_link_hash_table *htab;
10844 bfd_byte *loc;
10845 bfd_byte *p;
10846 bfd_vma dest, off;
10847 Elf_Internal_Rela *r;
10848 asection *plt;
10849
10850 /* Massage our args to the form they really have. */
10851 stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
10852 info = in_arg;
10853
10854 htab = ppc_hash_table (info);
10855 if (htab == NULL)
10856 return FALSE;
10857
10858 /* Make a note of the offset within the stubs for this entry. */
10859 stub_entry->stub_offset = stub_entry->group->stub_sec->size;
10860 loc = stub_entry->group->stub_sec->contents + stub_entry->stub_offset;
10861
10862 htab->stub_count[stub_entry->stub_type - 1] += 1;
10863 switch (stub_entry->stub_type)
10864 {
10865 case ppc_stub_long_branch:
10866 case ppc_stub_long_branch_r2off:
10867 /* Branches are relative. This is where we are going to. */
10868 dest = (stub_entry->target_value
10869 + stub_entry->target_section->output_offset
10870 + stub_entry->target_section->output_section->vma);
10871 dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
10872 off = dest;
10873
10874 /* And this is where we are coming from. */
10875 off -= (stub_entry->stub_offset
10876 + stub_entry->group->stub_sec->output_offset
10877 + stub_entry->group->stub_sec->output_section->vma);
10878
10879 p = loc;
10880 if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
10881 {
10882 bfd_vma r2off = get_r2off (info, stub_entry);
10883
10884 if (r2off == (bfd_vma) -1)
10885 {
10886 htab->stub_error = TRUE;
10887 return FALSE;
10888 }
10889 bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), p);
10890 p += 4;
10891 if (PPC_HA (r2off) != 0)
10892 {
10893 bfd_put_32 (htab->params->stub_bfd,
10894 ADDIS_R2_R2 | PPC_HA (r2off), p);
10895 p += 4;
10896 }
10897 if (PPC_LO (r2off) != 0)
10898 {
10899 bfd_put_32 (htab->params->stub_bfd,
10900 ADDI_R2_R2 | PPC_LO (r2off), p);
10901 p += 4;
10902 }
10903 off -= p - loc;
10904 }
10905 bfd_put_32 (htab->params->stub_bfd, B_DOT | (off & 0x3fffffc), p);
10906 p += 4;
10907
10908 if (off + (1 << 25) >= (bfd_vma) (1 << 26))
10909 {
10910 info->callbacks->einfo
10911 (_("%P: long branch stub `%s' offset overflow\n"),
10912 stub_entry->root.string);
10913 htab->stub_error = TRUE;
10914 return FALSE;
10915 }
10916
10917 if (info->emitrelocations)
10918 {
10919 r = get_relocs (stub_entry->group->stub_sec, 1);
10920 if (r == NULL)
10921 return FALSE;
10922 r->r_offset = p - 4 - stub_entry->group->stub_sec->contents;
10923 r->r_info = ELF64_R_INFO (0, R_PPC64_REL24);
10924 r->r_addend = dest;
10925 if (stub_entry->h != NULL)
10926 {
10927 struct elf_link_hash_entry **hashes;
10928 unsigned long symndx;
10929 struct ppc_link_hash_entry *h;
10930
10931 hashes = elf_sym_hashes (htab->params->stub_bfd);
10932 if (hashes == NULL)
10933 {
10934 bfd_size_type hsize;
10935
10936 hsize = (htab->stub_globals + 1) * sizeof (*hashes);
10937 hashes = bfd_zalloc (htab->params->stub_bfd, hsize);
10938 if (hashes == NULL)
10939 return FALSE;
10940 elf_sym_hashes (htab->params->stub_bfd) = hashes;
10941 htab->stub_globals = 1;
10942 }
10943 symndx = htab->stub_globals++;
10944 h = stub_entry->h;
10945 hashes[symndx] = &h->elf;
10946 r->r_info = ELF64_R_INFO (symndx, R_PPC64_REL24);
10947 if (h->oh != NULL && h->oh->is_func)
10948 h = ppc_follow_link (h->oh);
10949 if (h->elf.root.u.def.section != stub_entry->target_section)
10950 /* H is an opd symbol. The addend must be zero. */
10951 r->r_addend = 0;
10952 else
10953 {
10954 off = (h->elf.root.u.def.value
10955 + h->elf.root.u.def.section->output_offset
10956 + h->elf.root.u.def.section->output_section->vma);
10957 r->r_addend -= off;
10958 }
10959 }
10960 }
10961 break;
10962
10963 case ppc_stub_plt_branch:
10964 case ppc_stub_plt_branch_r2off:
10965 br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
10966 stub_entry->root.string + 9,
10967 FALSE, FALSE);
10968 if (br_entry == NULL)
10969 {
10970 info->callbacks->einfo (_("%P: can't find branch stub `%s'\n"),
10971 stub_entry->root.string);
10972 htab->stub_error = TRUE;
10973 return FALSE;
10974 }
10975
10976 dest = (stub_entry->target_value
10977 + stub_entry->target_section->output_offset
10978 + stub_entry->target_section->output_section->vma);
10979 if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
10980 dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
10981
10982 bfd_put_64 (htab->brlt->owner, dest,
10983 htab->brlt->contents + br_entry->offset);
10984
10985 if (br_entry->iter == htab->stub_iteration)
10986 {
10987 br_entry->iter = 0;
10988
10989 if (htab->relbrlt != NULL)
10990 {
10991 /* Create a reloc for the branch lookup table entry. */
10992 Elf_Internal_Rela rela;
10993 bfd_byte *rl;
10994
10995 rela.r_offset = (br_entry->offset
10996 + htab->brlt->output_offset
10997 + htab->brlt->output_section->vma);
10998 rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
10999 rela.r_addend = dest;
11000
11001 rl = htab->relbrlt->contents;
11002 rl += (htab->relbrlt->reloc_count++
11003 * sizeof (Elf64_External_Rela));
11004 bfd_elf64_swap_reloca_out (htab->relbrlt->owner, &rela, rl);
11005 }
11006 else if (info->emitrelocations)
11007 {
11008 r = get_relocs (htab->brlt, 1);
11009 if (r == NULL)
11010 return FALSE;
11011 /* brlt, being SEC_LINKER_CREATED does not go through the
11012 normal reloc processing. Symbols and offsets are not
11013 translated from input file to output file form, so
11014 set up the offset per the output file. */
11015 r->r_offset = (br_entry->offset
11016 + htab->brlt->output_offset
11017 + htab->brlt->output_section->vma);
11018 r->r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
11019 r->r_addend = dest;
11020 }
11021 }
11022
11023 dest = (br_entry->offset
11024 + htab->brlt->output_offset
11025 + htab->brlt->output_section->vma);
11026
11027 off = (dest
11028 - elf_gp (info->output_bfd)
11029 - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11030
11031 if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
11032 {
11033 info->callbacks->einfo
11034 (_("%P: linkage table error against `%T'\n"),
11035 stub_entry->root.string);
11036 bfd_set_error (bfd_error_bad_value);
11037 htab->stub_error = TRUE;
11038 return FALSE;
11039 }
11040
11041 if (info->emitrelocations)
11042 {
11043 r = get_relocs (stub_entry->group->stub_sec, 1 + (PPC_HA (off) != 0));
11044 if (r == NULL)
11045 return FALSE;
11046 r[0].r_offset = loc - stub_entry->group->stub_sec->contents;
11047 if (bfd_big_endian (info->output_bfd))
11048 r[0].r_offset += 2;
11049 if (stub_entry->stub_type == ppc_stub_plt_branch_r2off)
11050 r[0].r_offset += 4;
11051 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
11052 r[0].r_addend = dest;
11053 if (PPC_HA (off) != 0)
11054 {
11055 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
11056 r[1].r_offset = r[0].r_offset + 4;
11057 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
11058 r[1].r_addend = r[0].r_addend;
11059 }
11060 }
11061
11062 p = loc;
11063 if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
11064 {
11065 if (PPC_HA (off) != 0)
11066 {
11067 bfd_put_32 (htab->params->stub_bfd,
11068 ADDIS_R12_R2 | PPC_HA (off), p);
11069 p += 4;
11070 bfd_put_32 (htab->params->stub_bfd,
11071 LD_R12_0R12 | PPC_LO (off), p);
11072 }
11073 else
11074 bfd_put_32 (htab->params->stub_bfd,
11075 LD_R12_0R2 | PPC_LO (off), p);
11076 }
11077 else
11078 {
11079 bfd_vma r2off = get_r2off (info, stub_entry);
11080
11081 if (r2off == (bfd_vma) -1)
11082 {
11083 htab->stub_error = TRUE;
11084 return FALSE;
11085 }
11086
11087 bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), p);
11088 p += 4;
11089 if (PPC_HA (off) != 0)
11090 {
11091 bfd_put_32 (htab->params->stub_bfd,
11092 ADDIS_R12_R2 | PPC_HA (off), p);
11093 p += 4;
11094 bfd_put_32 (htab->params->stub_bfd,
11095 LD_R12_0R12 | PPC_LO (off), p);
11096 }
11097 else
11098 bfd_put_32 (htab->params->stub_bfd, LD_R12_0R2 | PPC_LO (off), p);
11099
11100 if (PPC_HA (r2off) != 0)
11101 {
11102 p += 4;
11103 bfd_put_32 (htab->params->stub_bfd,
11104 ADDIS_R2_R2 | PPC_HA (r2off), p);
11105 }
11106 if (PPC_LO (r2off) != 0)
11107 {
11108 p += 4;
11109 bfd_put_32 (htab->params->stub_bfd,
11110 ADDI_R2_R2 | PPC_LO (r2off), p);
11111 }
11112 }
11113 p += 4;
11114 bfd_put_32 (htab->params->stub_bfd, MTCTR_R12, p);
11115 p += 4;
11116 p = output_bctr (htab, htab->params->stub_bfd, p);
11117 break;
11118
11119 case ppc_stub_plt_call:
11120 case ppc_stub_plt_call_r2save:
11121 if (stub_entry->h != NULL
11122 && stub_entry->h->is_func_descriptor
11123 && stub_entry->h->oh != NULL)
11124 {
11125 struct ppc_link_hash_entry *fh = ppc_follow_link (stub_entry->h->oh);
11126
11127 /* If the old-ABI "dot-symbol" is undefined make it weak so
11128 we don't get a link error from RELOC_FOR_GLOBAL_SYMBOL. */
11129 if (fh->elf.root.type == bfd_link_hash_undefined
11130 && (stub_entry->h->elf.root.type == bfd_link_hash_defined
11131 || stub_entry->h->elf.root.type == bfd_link_hash_defweak))
11132 fh->elf.root.type = bfd_link_hash_undefweak;
11133 }
11134
11135 /* Now build the stub. */
11136 dest = stub_entry->plt_ent->plt.offset & ~1;
11137 if (dest >= (bfd_vma) -2)
11138 abort ();
11139
11140 plt = htab->elf.splt;
11141 if (!htab->elf.dynamic_sections_created
11142 || stub_entry->h == NULL
11143 || stub_entry->h->elf.dynindx == -1)
11144 plt = htab->elf.iplt;
11145
11146 dest += plt->output_offset + plt->output_section->vma;
11147
11148 if (stub_entry->h == NULL
11149 && (stub_entry->plt_ent->plt.offset & 1) == 0)
11150 {
11151 Elf_Internal_Rela rela;
11152 bfd_byte *rl;
11153
11154 rela.r_offset = dest;
11155 if (htab->opd_abi)
11156 rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
11157 else
11158 rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
11159 rela.r_addend = (stub_entry->target_value
11160 + stub_entry->target_section->output_offset
11161 + stub_entry->target_section->output_section->vma);
11162
11163 rl = (htab->elf.irelplt->contents
11164 + (htab->elf.irelplt->reloc_count++
11165 * sizeof (Elf64_External_Rela)));
11166 bfd_elf64_swap_reloca_out (info->output_bfd, &rela, rl);
11167 stub_entry->plt_ent->plt.offset |= 1;
11168 htab->local_ifunc_resolver = 1;
11169 }
11170
11171 off = (dest
11172 - elf_gp (info->output_bfd)
11173 - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11174
11175 if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
11176 {
11177 info->callbacks->einfo
11178 /* xgettext:c-format */
11179 (_("%P: linkage table error against `%T'\n"),
11180 stub_entry->h != NULL
11181 ? stub_entry->h->elf.root.root.string
11182 : "<local sym>");
11183 bfd_set_error (bfd_error_bad_value);
11184 htab->stub_error = TRUE;
11185 return FALSE;
11186 }
11187
11188 if (htab->params->plt_stub_align != 0)
11189 {
11190 unsigned pad = plt_stub_pad (htab, stub_entry, off);
11191
11192 stub_entry->group->stub_sec->size += pad;
11193 stub_entry->stub_offset = stub_entry->group->stub_sec->size;
11194 loc += pad;
11195 }
11196
11197 r = NULL;
11198 if (info->emitrelocations)
11199 {
11200 r = get_relocs (stub_entry->group->stub_sec,
11201 ((PPC_HA (off) != 0)
11202 + (htab->opd_abi
11203 ? 2 + (htab->params->plt_static_chain
11204 && PPC_HA (off + 16) == PPC_HA (off))
11205 : 1)));
11206 if (r == NULL)
11207 return FALSE;
11208 r[0].r_offset = loc - stub_entry->group->stub_sec->contents;
11209 if (bfd_big_endian (info->output_bfd))
11210 r[0].r_offset += 2;
11211 r[0].r_addend = dest;
11212 }
11213 if (stub_entry->h != NULL
11214 && (stub_entry->h == htab->tls_get_addr_fd
11215 || stub_entry->h == htab->tls_get_addr)
11216 && htab->params->tls_get_addr_opt)
11217 p = build_tls_get_addr_stub (htab, stub_entry, loc, off, r);
11218 else
11219 p = build_plt_stub (htab, stub_entry, loc, off, r);
11220 break;
11221
11222 case ppc_stub_save_res:
11223 return TRUE;
11224
11225 default:
11226 BFD_FAIL ();
11227 return FALSE;
11228 }
11229
11230 stub_entry->group->stub_sec->size += p - loc;
11231
11232 if (htab->params->emit_stub_syms)
11233 {
11234 struct elf_link_hash_entry *h;
11235 size_t len1, len2;
11236 char *name;
11237 const char *const stub_str[] = { "long_branch",
11238 "long_branch_r2off",
11239 "plt_branch",
11240 "plt_branch_r2off",
11241 "plt_call",
11242 "plt_call" };
11243
11244 len1 = strlen (stub_str[stub_entry->stub_type - 1]);
11245 len2 = strlen (stub_entry->root.string);
11246 name = bfd_malloc (len1 + len2 + 2);
11247 if (name == NULL)
11248 return FALSE;
11249 memcpy (name, stub_entry->root.string, 9);
11250 memcpy (name + 9, stub_str[stub_entry->stub_type - 1], len1);
11251 memcpy (name + len1 + 9, stub_entry->root.string + 8, len2 - 8 + 1);
11252 h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
11253 if (h == NULL)
11254 return FALSE;
11255 if (h->root.type == bfd_link_hash_new)
11256 {
11257 h->root.type = bfd_link_hash_defined;
11258 h->root.u.def.section = stub_entry->group->stub_sec;
11259 h->root.u.def.value = stub_entry->stub_offset;
11260 h->ref_regular = 1;
11261 h->def_regular = 1;
11262 h->ref_regular_nonweak = 1;
11263 h->forced_local = 1;
11264 h->non_elf = 0;
11265 h->root.linker_def = 1;
11266 }
11267 }
11268
11269 return TRUE;
11270 }
11271
11272 /* As above, but don't actually build the stub. Just bump offset so
11273 we know stub section sizes, and select plt_branch stubs where
11274 long_branch stubs won't do. */
11275
11276 static bfd_boolean
11277 ppc_size_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
11278 {
11279 struct ppc_stub_hash_entry *stub_entry;
11280 struct bfd_link_info *info;
11281 struct ppc_link_hash_table *htab;
11282 bfd_vma off;
11283 int size;
11284
11285 /* Massage our args to the form they really have. */
11286 stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
11287 info = in_arg;
11288
11289 htab = ppc_hash_table (info);
11290 if (htab == NULL)
11291 return FALSE;
11292
11293 if (stub_entry->h != NULL
11294 && stub_entry->h->save_res
11295 && stub_entry->h->elf.root.type == bfd_link_hash_defined
11296 && stub_entry->h->elf.root.u.def.section == htab->sfpr)
11297 {
11298 /* Don't make stubs to out-of-line register save/restore
11299 functions. Instead, emit copies of the functions. */
11300 stub_entry->group->needs_save_res = 1;
11301 stub_entry->stub_type = ppc_stub_save_res;
11302 return TRUE;
11303 }
11304
11305 if (stub_entry->stub_type == ppc_stub_plt_call
11306 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
11307 {
11308 asection *plt;
11309 off = stub_entry->plt_ent->plt.offset & ~(bfd_vma) 1;
11310 if (off >= (bfd_vma) -2)
11311 abort ();
11312 plt = htab->elf.splt;
11313 if (!htab->elf.dynamic_sections_created
11314 || stub_entry->h == NULL
11315 || stub_entry->h->elf.dynindx == -1)
11316 plt = htab->elf.iplt;
11317 off += (plt->output_offset
11318 + plt->output_section->vma
11319 - elf_gp (info->output_bfd)
11320 - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11321
11322 size = plt_stub_size (htab, stub_entry, off);
11323 if (stub_entry->h != NULL
11324 && (stub_entry->h == htab->tls_get_addr_fd
11325 || stub_entry->h == htab->tls_get_addr)
11326 && htab->params->tls_get_addr_opt
11327 && (ALWAYS_EMIT_R2SAVE
11328 || stub_entry->stub_type == ppc_stub_plt_call_r2save))
11329 stub_entry->group->tls_get_addr_opt_bctrl
11330 = stub_entry->group->stub_sec->size + size - 5 * 4;
11331
11332 if (htab->params->plt_stub_align)
11333 size += plt_stub_pad (htab, stub_entry, off);
11334 if (info->emitrelocations)
11335 {
11336 stub_entry->group->stub_sec->reloc_count
11337 += ((PPC_HA (off) != 0)
11338 + (htab->opd_abi
11339 ? 2 + (htab->params->plt_static_chain
11340 && PPC_HA (off + 16) == PPC_HA (off))
11341 : 1));
11342 stub_entry->group->stub_sec->flags |= SEC_RELOC;
11343 }
11344 }
11345 else
11346 {
11347 /* ppc_stub_long_branch or ppc_stub_plt_branch, or their r2off
11348 variants. */
11349 bfd_vma r2off = 0;
11350 bfd_vma local_off = 0;
11351
11352 off = (stub_entry->target_value
11353 + stub_entry->target_section->output_offset
11354 + stub_entry->target_section->output_section->vma);
11355 off -= (stub_entry->group->stub_sec->size
11356 + stub_entry->group->stub_sec->output_offset
11357 + stub_entry->group->stub_sec->output_section->vma);
11358
11359 /* Reset the stub type from the plt variant in case we now
11360 can reach with a shorter stub. */
11361 if (stub_entry->stub_type >= ppc_stub_plt_branch)
11362 stub_entry->stub_type += ppc_stub_long_branch - ppc_stub_plt_branch;
11363
11364 size = 4;
11365 if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
11366 {
11367 r2off = get_r2off (info, stub_entry);
11368 if (r2off == (bfd_vma) -1)
11369 {
11370 htab->stub_error = TRUE;
11371 return FALSE;
11372 }
11373 size = 8;
11374 if (PPC_HA (r2off) != 0)
11375 size += 4;
11376 if (PPC_LO (r2off) != 0)
11377 size += 4;
11378 off -= size - 4;
11379 }
11380
11381 local_off = PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
11382
11383 /* If the branch offset if too big, use a ppc_stub_plt_branch.
11384 Do the same for -R objects without function descriptors. */
11385 if (off + (1 << 25) >= (bfd_vma) (1 << 26) - local_off
11386 || (stub_entry->stub_type == ppc_stub_long_branch_r2off
11387 && r2off == 0
11388 && htab->sec_info[stub_entry->target_section->id].toc_off == 0))
11389 {
11390 struct ppc_branch_hash_entry *br_entry;
11391
11392 br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
11393 stub_entry->root.string + 9,
11394 TRUE, FALSE);
11395 if (br_entry == NULL)
11396 {
11397 info->callbacks->einfo (_("%P: can't build branch stub `%s'\n"),
11398 stub_entry->root.string);
11399 htab->stub_error = TRUE;
11400 return FALSE;
11401 }
11402
11403 if (br_entry->iter != htab->stub_iteration)
11404 {
11405 br_entry->iter = htab->stub_iteration;
11406 br_entry->offset = htab->brlt->size;
11407 htab->brlt->size += 8;
11408
11409 if (htab->relbrlt != NULL)
11410 htab->relbrlt->size += sizeof (Elf64_External_Rela);
11411 else if (info->emitrelocations)
11412 {
11413 htab->brlt->reloc_count += 1;
11414 htab->brlt->flags |= SEC_RELOC;
11415 }
11416 }
11417
11418 stub_entry->stub_type += ppc_stub_plt_branch - ppc_stub_long_branch;
11419 off = (br_entry->offset
11420 + htab->brlt->output_offset
11421 + htab->brlt->output_section->vma
11422 - elf_gp (info->output_bfd)
11423 - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11424
11425 if (info->emitrelocations)
11426 {
11427 stub_entry->group->stub_sec->reloc_count
11428 += 1 + (PPC_HA (off) != 0);
11429 stub_entry->group->stub_sec->flags |= SEC_RELOC;
11430 }
11431
11432 if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
11433 {
11434 size = 12;
11435 if (PPC_HA (off) != 0)
11436 size = 16;
11437 }
11438 else
11439 {
11440 size = 16;
11441 if (PPC_HA (off) != 0)
11442 size += 4;
11443
11444 if (PPC_HA (r2off) != 0)
11445 size += 4;
11446 if (PPC_LO (r2off) != 0)
11447 size += 4;
11448 }
11449 if (!htab->params->speculate_indirect_jumps)
11450 size += 8;
11451 }
11452 else if (info->emitrelocations)
11453 {
11454 stub_entry->group->stub_sec->reloc_count += 1;
11455 stub_entry->group->stub_sec->flags |= SEC_RELOC;
11456 }
11457 }
11458
11459 stub_entry->group->stub_sec->size += size;
11460 return TRUE;
11461 }
11462
11463 /* Set up various things so that we can make a list of input sections
11464 for each output section included in the link. Returns -1 on error,
11465 0 when no stubs will be needed, and 1 on success. */
11466
11467 int
11468 ppc64_elf_setup_section_lists (struct bfd_link_info *info)
11469 {
11470 unsigned int id;
11471 bfd_size_type amt;
11472 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11473
11474 if (htab == NULL)
11475 return -1;
11476
11477 htab->sec_info_arr_size = bfd_get_next_section_id ();
11478 amt = sizeof (*htab->sec_info) * (htab->sec_info_arr_size);
11479 htab->sec_info = bfd_zmalloc (amt);
11480 if (htab->sec_info == NULL)
11481 return -1;
11482
11483 /* Set toc_off for com, und, abs and ind sections. */
11484 for (id = 0; id < 3; id++)
11485 htab->sec_info[id].toc_off = TOC_BASE_OFF;
11486
11487 return 1;
11488 }
11489
11490 /* Set up for first pass at multitoc partitioning. */
11491
11492 void
11493 ppc64_elf_start_multitoc_partition (struct bfd_link_info *info)
11494 {
11495 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11496
11497 htab->toc_curr = ppc64_elf_set_toc (info, info->output_bfd);
11498 htab->toc_bfd = NULL;
11499 htab->toc_first_sec = NULL;
11500 }
11501
11502 /* The linker repeatedly calls this function for each TOC input section
11503 and linker generated GOT section. Group input bfds such that the toc
11504 within a group is less than 64k in size. */
11505
11506 bfd_boolean
11507 ppc64_elf_next_toc_section (struct bfd_link_info *info, asection *isec)
11508 {
11509 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11510 bfd_vma addr, off, limit;
11511
11512 if (htab == NULL)
11513 return FALSE;
11514
11515 if (!htab->second_toc_pass)
11516 {
11517 /* Keep track of the first .toc or .got section for this input bfd. */
11518 bfd_boolean new_bfd = htab->toc_bfd != isec->owner;
11519
11520 if (new_bfd)
11521 {
11522 htab->toc_bfd = isec->owner;
11523 htab->toc_first_sec = isec;
11524 }
11525
11526 addr = isec->output_offset + isec->output_section->vma;
11527 off = addr - htab->toc_curr;
11528 limit = 0x80008000;
11529 if (ppc64_elf_tdata (isec->owner)->has_small_toc_reloc)
11530 limit = 0x10000;
11531 if (off + isec->size > limit)
11532 {
11533 addr = (htab->toc_first_sec->output_offset
11534 + htab->toc_first_sec->output_section->vma);
11535 htab->toc_curr = addr;
11536 htab->toc_curr &= -TOC_BASE_ALIGN;
11537 }
11538
11539 /* toc_curr is the base address of this toc group. Set elf_gp
11540 for the input section to be the offset relative to the
11541 output toc base plus 0x8000. Making the input elf_gp an
11542 offset allows us to move the toc as a whole without
11543 recalculating input elf_gp. */
11544 off = htab->toc_curr - elf_gp (info->output_bfd);
11545 off += TOC_BASE_OFF;
11546
11547 /* Die if someone uses a linker script that doesn't keep input
11548 file .toc and .got together. */
11549 if (new_bfd
11550 && elf_gp (isec->owner) != 0
11551 && elf_gp (isec->owner) != off)
11552 return FALSE;
11553
11554 elf_gp (isec->owner) = off;
11555 return TRUE;
11556 }
11557
11558 /* During the second pass toc_first_sec points to the start of
11559 a toc group, and toc_curr is used to track the old elf_gp.
11560 We use toc_bfd to ensure we only look at each bfd once. */
11561 if (htab->toc_bfd == isec->owner)
11562 return TRUE;
11563 htab->toc_bfd = isec->owner;
11564
11565 if (htab->toc_first_sec == NULL
11566 || htab->toc_curr != elf_gp (isec->owner))
11567 {
11568 htab->toc_curr = elf_gp (isec->owner);
11569 htab->toc_first_sec = isec;
11570 }
11571 addr = (htab->toc_first_sec->output_offset
11572 + htab->toc_first_sec->output_section->vma);
11573 off = addr - elf_gp (info->output_bfd) + TOC_BASE_OFF;
11574 elf_gp (isec->owner) = off;
11575
11576 return TRUE;
11577 }
11578
11579 /* Called via elf_link_hash_traverse to merge GOT entries for global
11580 symbol H. */
11581
11582 static bfd_boolean
11583 merge_global_got (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
11584 {
11585 if (h->root.type == bfd_link_hash_indirect)
11586 return TRUE;
11587
11588 merge_got_entries (&h->got.glist);
11589
11590 return TRUE;
11591 }
11592
11593 /* Called via elf_link_hash_traverse to allocate GOT entries for global
11594 symbol H. */
11595
11596 static bfd_boolean
11597 reallocate_got (struct elf_link_hash_entry *h, void *inf)
11598 {
11599 struct got_entry *gent;
11600
11601 if (h->root.type == bfd_link_hash_indirect)
11602 return TRUE;
11603
11604 for (gent = h->got.glist; gent != NULL; gent = gent->next)
11605 if (!gent->is_indirect)
11606 allocate_got (h, (struct bfd_link_info *) inf, gent);
11607 return TRUE;
11608 }
11609
11610 /* Called on the first multitoc pass after the last call to
11611 ppc64_elf_next_toc_section. This function removes duplicate GOT
11612 entries. */
11613
11614 bfd_boolean
11615 ppc64_elf_layout_multitoc (struct bfd_link_info *info)
11616 {
11617 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11618 struct bfd *ibfd, *ibfd2;
11619 bfd_boolean done_something;
11620
11621 htab->multi_toc_needed = htab->toc_curr != elf_gp (info->output_bfd);
11622
11623 if (!htab->do_multi_toc)
11624 return FALSE;
11625
11626 /* Merge global sym got entries within a toc group. */
11627 elf_link_hash_traverse (&htab->elf, merge_global_got, info);
11628
11629 /* And tlsld_got. */
11630 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11631 {
11632 struct got_entry *ent, *ent2;
11633
11634 if (!is_ppc64_elf (ibfd))
11635 continue;
11636
11637 ent = ppc64_tlsld_got (ibfd);
11638 if (!ent->is_indirect
11639 && ent->got.offset != (bfd_vma) -1)
11640 {
11641 for (ibfd2 = ibfd->link.next; ibfd2 != NULL; ibfd2 = ibfd2->link.next)
11642 {
11643 if (!is_ppc64_elf (ibfd2))
11644 continue;
11645
11646 ent2 = ppc64_tlsld_got (ibfd2);
11647 if (!ent2->is_indirect
11648 && ent2->got.offset != (bfd_vma) -1
11649 && elf_gp (ibfd2) == elf_gp (ibfd))
11650 {
11651 ent2->is_indirect = TRUE;
11652 ent2->got.ent = ent;
11653 }
11654 }
11655 }
11656 }
11657
11658 /* Zap sizes of got sections. */
11659 htab->elf.irelplt->rawsize = htab->elf.irelplt->size;
11660 htab->elf.irelplt->size -= htab->got_reli_size;
11661 htab->got_reli_size = 0;
11662
11663 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11664 {
11665 asection *got, *relgot;
11666
11667 if (!is_ppc64_elf (ibfd))
11668 continue;
11669
11670 got = ppc64_elf_tdata (ibfd)->got;
11671 if (got != NULL)
11672 {
11673 got->rawsize = got->size;
11674 got->size = 0;
11675 relgot = ppc64_elf_tdata (ibfd)->relgot;
11676 relgot->rawsize = relgot->size;
11677 relgot->size = 0;
11678 }
11679 }
11680
11681 /* Now reallocate the got, local syms first. We don't need to
11682 allocate section contents again since we never increase size. */
11683 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11684 {
11685 struct got_entry **lgot_ents;
11686 struct got_entry **end_lgot_ents;
11687 struct plt_entry **local_plt;
11688 struct plt_entry **end_local_plt;
11689 unsigned char *lgot_masks;
11690 bfd_size_type locsymcount;
11691 Elf_Internal_Shdr *symtab_hdr;
11692 asection *s;
11693
11694 if (!is_ppc64_elf (ibfd))
11695 continue;
11696
11697 lgot_ents = elf_local_got_ents (ibfd);
11698 if (!lgot_ents)
11699 continue;
11700
11701 symtab_hdr = &elf_symtab_hdr (ibfd);
11702 locsymcount = symtab_hdr->sh_info;
11703 end_lgot_ents = lgot_ents + locsymcount;
11704 local_plt = (struct plt_entry **) end_lgot_ents;
11705 end_local_plt = local_plt + locsymcount;
11706 lgot_masks = (unsigned char *) end_local_plt;
11707 s = ppc64_elf_tdata (ibfd)->got;
11708 for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
11709 {
11710 struct got_entry *ent;
11711
11712 for (ent = *lgot_ents; ent != NULL; ent = ent->next)
11713 {
11714 unsigned int ent_size = 8;
11715 unsigned int rel_size = sizeof (Elf64_External_Rela);
11716
11717 ent->got.offset = s->size;
11718 if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
11719 {
11720 ent_size *= 2;
11721 rel_size *= 2;
11722 }
11723 s->size += ent_size;
11724 if ((*lgot_masks & PLT_IFUNC) != 0)
11725 {
11726 htab->elf.irelplt->size += rel_size;
11727 htab->got_reli_size += rel_size;
11728 }
11729 else if (bfd_link_pic (info))
11730 {
11731 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
11732 srel->size += rel_size;
11733 }
11734 }
11735 }
11736 }
11737
11738 elf_link_hash_traverse (&htab->elf, reallocate_got, info);
11739
11740 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11741 {
11742 struct got_entry *ent;
11743
11744 if (!is_ppc64_elf (ibfd))
11745 continue;
11746
11747 ent = ppc64_tlsld_got (ibfd);
11748 if (!ent->is_indirect
11749 && ent->got.offset != (bfd_vma) -1)
11750 {
11751 asection *s = ppc64_elf_tdata (ibfd)->got;
11752 ent->got.offset = s->size;
11753 s->size += 16;
11754 if (bfd_link_pic (info))
11755 {
11756 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
11757 srel->size += sizeof (Elf64_External_Rela);
11758 }
11759 }
11760 }
11761
11762 done_something = htab->elf.irelplt->rawsize != htab->elf.irelplt->size;
11763 if (!done_something)
11764 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11765 {
11766 asection *got;
11767
11768 if (!is_ppc64_elf (ibfd))
11769 continue;
11770
11771 got = ppc64_elf_tdata (ibfd)->got;
11772 if (got != NULL)
11773 {
11774 done_something = got->rawsize != got->size;
11775 if (done_something)
11776 break;
11777 }
11778 }
11779
11780 if (done_something)
11781 (*htab->params->layout_sections_again) ();
11782
11783 /* Set up for second pass over toc sections to recalculate elf_gp
11784 on input sections. */
11785 htab->toc_bfd = NULL;
11786 htab->toc_first_sec = NULL;
11787 htab->second_toc_pass = TRUE;
11788 return done_something;
11789 }
11790
11791 /* Called after second pass of multitoc partitioning. */
11792
11793 void
11794 ppc64_elf_finish_multitoc_partition (struct bfd_link_info *info)
11795 {
11796 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11797
11798 /* After the second pass, toc_curr tracks the TOC offset used
11799 for code sections below in ppc64_elf_next_input_section. */
11800 htab->toc_curr = TOC_BASE_OFF;
11801 }
11802
11803 /* No toc references were found in ISEC. If the code in ISEC makes no
11804 calls, then there's no need to use toc adjusting stubs when branching
11805 into ISEC. Actually, indirect calls from ISEC are OK as they will
11806 load r2. Returns -1 on error, 0 for no stub needed, 1 for stub
11807 needed, and 2 if a cyclical call-graph was found but no other reason
11808 for a stub was detected. If called from the top level, a return of
11809 2 means the same as a return of 0. */
11810
11811 static int
11812 toc_adjusting_stub_needed (struct bfd_link_info *info, asection *isec)
11813 {
11814 int ret;
11815
11816 /* Mark this section as checked. */
11817 isec->call_check_done = 1;
11818
11819 /* We know none of our code bearing sections will need toc stubs. */
11820 if ((isec->flags & SEC_LINKER_CREATED) != 0)
11821 return 0;
11822
11823 if (isec->size == 0)
11824 return 0;
11825
11826 if (isec->output_section == NULL)
11827 return 0;
11828
11829 ret = 0;
11830 if (isec->reloc_count != 0)
11831 {
11832 Elf_Internal_Rela *relstart, *rel;
11833 Elf_Internal_Sym *local_syms;
11834 struct ppc_link_hash_table *htab;
11835
11836 relstart = _bfd_elf_link_read_relocs (isec->owner, isec, NULL, NULL,
11837 info->keep_memory);
11838 if (relstart == NULL)
11839 return -1;
11840
11841 /* Look for branches to outside of this section. */
11842 local_syms = NULL;
11843 htab = ppc_hash_table (info);
11844 if (htab == NULL)
11845 return -1;
11846
11847 for (rel = relstart; rel < relstart + isec->reloc_count; ++rel)
11848 {
11849 enum elf_ppc64_reloc_type r_type;
11850 unsigned long r_symndx;
11851 struct elf_link_hash_entry *h;
11852 struct ppc_link_hash_entry *eh;
11853 Elf_Internal_Sym *sym;
11854 asection *sym_sec;
11855 struct _opd_sec_data *opd;
11856 bfd_vma sym_value;
11857 bfd_vma dest;
11858
11859 r_type = ELF64_R_TYPE (rel->r_info);
11860 if (r_type != R_PPC64_REL24
11861 && r_type != R_PPC64_REL14
11862 && r_type != R_PPC64_REL14_BRTAKEN
11863 && r_type != R_PPC64_REL14_BRNTAKEN)
11864 continue;
11865
11866 r_symndx = ELF64_R_SYM (rel->r_info);
11867 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms, r_symndx,
11868 isec->owner))
11869 {
11870 ret = -1;
11871 break;
11872 }
11873
11874 /* Calls to dynamic lib functions go through a plt call stub
11875 that uses r2. */
11876 eh = (struct ppc_link_hash_entry *) h;
11877 if (eh != NULL
11878 && (eh->elf.plt.plist != NULL
11879 || (eh->oh != NULL
11880 && ppc_follow_link (eh->oh)->elf.plt.plist != NULL)))
11881 {
11882 ret = 1;
11883 break;
11884 }
11885
11886 if (sym_sec == NULL)
11887 /* Ignore other undefined symbols. */
11888 continue;
11889
11890 /* Assume branches to other sections not included in the
11891 link need stubs too, to cover -R and absolute syms. */
11892 if (sym_sec->output_section == NULL)
11893 {
11894 ret = 1;
11895 break;
11896 }
11897
11898 if (h == NULL)
11899 sym_value = sym->st_value;
11900 else
11901 {
11902 if (h->root.type != bfd_link_hash_defined
11903 && h->root.type != bfd_link_hash_defweak)
11904 abort ();
11905 sym_value = h->root.u.def.value;
11906 }
11907 sym_value += rel->r_addend;
11908
11909 /* If this branch reloc uses an opd sym, find the code section. */
11910 opd = get_opd_info (sym_sec);
11911 if (opd != NULL)
11912 {
11913 if (h == NULL && opd->adjust != NULL)
11914 {
11915 long adjust;
11916
11917 adjust = opd->adjust[OPD_NDX (sym_value)];
11918 if (adjust == -1)
11919 /* Assume deleted functions won't ever be called. */
11920 continue;
11921 sym_value += adjust;
11922 }
11923
11924 dest = opd_entry_value (sym_sec, sym_value,
11925 &sym_sec, NULL, FALSE);
11926 if (dest == (bfd_vma) -1)
11927 continue;
11928 }
11929 else
11930 dest = (sym_value
11931 + sym_sec->output_offset
11932 + sym_sec->output_section->vma);
11933
11934 /* Ignore branch to self. */
11935 if (sym_sec == isec)
11936 continue;
11937
11938 /* If the called function uses the toc, we need a stub. */
11939 if (sym_sec->has_toc_reloc
11940 || sym_sec->makes_toc_func_call)
11941 {
11942 ret = 1;
11943 break;
11944 }
11945
11946 /* Assume any branch that needs a long branch stub might in fact
11947 need a plt_branch stub. A plt_branch stub uses r2. */
11948 else if (dest - (isec->output_offset
11949 + isec->output_section->vma
11950 + rel->r_offset) + (1 << 25)
11951 >= (2u << 25) - PPC64_LOCAL_ENTRY_OFFSET (h
11952 ? h->other
11953 : sym->st_other))
11954 {
11955 ret = 1;
11956 break;
11957 }
11958
11959 /* If calling back to a section in the process of being
11960 tested, we can't say for sure that no toc adjusting stubs
11961 are needed, so don't return zero. */
11962 else if (sym_sec->call_check_in_progress)
11963 ret = 2;
11964
11965 /* Branches to another section that itself doesn't have any TOC
11966 references are OK. Recursively call ourselves to check. */
11967 else if (!sym_sec->call_check_done)
11968 {
11969 int recur;
11970
11971 /* Mark current section as indeterminate, so that other
11972 sections that call back to current won't be marked as
11973 known. */
11974 isec->call_check_in_progress = 1;
11975 recur = toc_adjusting_stub_needed (info, sym_sec);
11976 isec->call_check_in_progress = 0;
11977
11978 if (recur != 0)
11979 {
11980 ret = recur;
11981 if (recur != 2)
11982 break;
11983 }
11984 }
11985 }
11986
11987 if (local_syms != NULL
11988 && (elf_symtab_hdr (isec->owner).contents
11989 != (unsigned char *) local_syms))
11990 free (local_syms);
11991 if (elf_section_data (isec)->relocs != relstart)
11992 free (relstart);
11993 }
11994
11995 if ((ret & 1) == 0
11996 && isec->map_head.s != NULL
11997 && (strcmp (isec->output_section->name, ".init") == 0
11998 || strcmp (isec->output_section->name, ".fini") == 0))
11999 {
12000 if (isec->map_head.s->has_toc_reloc
12001 || isec->map_head.s->makes_toc_func_call)
12002 ret = 1;
12003 else if (!isec->map_head.s->call_check_done)
12004 {
12005 int recur;
12006 isec->call_check_in_progress = 1;
12007 recur = toc_adjusting_stub_needed (info, isec->map_head.s);
12008 isec->call_check_in_progress = 0;
12009 if (recur != 0)
12010 ret = recur;
12011 }
12012 }
12013
12014 if (ret == 1)
12015 isec->makes_toc_func_call = 1;
12016
12017 return ret;
12018 }
12019
12020 /* The linker repeatedly calls this function for each input section,
12021 in the order that input sections are linked into output sections.
12022 Build lists of input sections to determine groupings between which
12023 we may insert linker stubs. */
12024
12025 bfd_boolean
12026 ppc64_elf_next_input_section (struct bfd_link_info *info, asection *isec)
12027 {
12028 struct ppc_link_hash_table *htab = ppc_hash_table (info);
12029
12030 if (htab == NULL)
12031 return FALSE;
12032
12033 if ((isec->output_section->flags & SEC_CODE) != 0
12034 && isec->output_section->id < htab->sec_info_arr_size)
12035 {
12036 /* This happens to make the list in reverse order,
12037 which is what we want. */
12038 htab->sec_info[isec->id].u.list
12039 = htab->sec_info[isec->output_section->id].u.list;
12040 htab->sec_info[isec->output_section->id].u.list = isec;
12041 }
12042
12043 if (htab->multi_toc_needed)
12044 {
12045 /* Analyse sections that aren't already flagged as needing a
12046 valid toc pointer. Exclude .fixup for the linux kernel.
12047 .fixup contains branches, but only back to the function that
12048 hit an exception. */
12049 if (!(isec->has_toc_reloc
12050 || (isec->flags & SEC_CODE) == 0
12051 || strcmp (isec->name, ".fixup") == 0
12052 || isec->call_check_done))
12053 {
12054 if (toc_adjusting_stub_needed (info, isec) < 0)
12055 return FALSE;
12056 }
12057 /* Make all sections use the TOC assigned for this object file.
12058 This will be wrong for pasted sections; We fix that in
12059 check_pasted_section(). */
12060 if (elf_gp (isec->owner) != 0)
12061 htab->toc_curr = elf_gp (isec->owner);
12062 }
12063
12064 htab->sec_info[isec->id].toc_off = htab->toc_curr;
12065 return TRUE;
12066 }
12067
12068 /* Check that all .init and .fini sections use the same toc, if they
12069 have toc relocs. */
12070
12071 static bfd_boolean
12072 check_pasted_section (struct bfd_link_info *info, const char *name)
12073 {
12074 asection *o = bfd_get_section_by_name (info->output_bfd, name);
12075
12076 if (o != NULL)
12077 {
12078 struct ppc_link_hash_table *htab = ppc_hash_table (info);
12079 bfd_vma toc_off = 0;
12080 asection *i;
12081
12082 for (i = o->map_head.s; i != NULL; i = i->map_head.s)
12083 if (i->has_toc_reloc)
12084 {
12085 if (toc_off == 0)
12086 toc_off = htab->sec_info[i->id].toc_off;
12087 else if (toc_off != htab->sec_info[i->id].toc_off)
12088 return FALSE;
12089 }
12090
12091 if (toc_off == 0)
12092 for (i = o->map_head.s; i != NULL; i = i->map_head.s)
12093 if (i->makes_toc_func_call)
12094 {
12095 toc_off = htab->sec_info[i->id].toc_off;
12096 break;
12097 }
12098
12099 /* Make sure the whole pasted function uses the same toc offset. */
12100 if (toc_off != 0)
12101 for (i = o->map_head.s; i != NULL; i = i->map_head.s)
12102 htab->sec_info[i->id].toc_off = toc_off;
12103 }
12104 return TRUE;
12105 }
12106
12107 bfd_boolean
12108 ppc64_elf_check_init_fini (struct bfd_link_info *info)
12109 {
12110 return (check_pasted_section (info, ".init")
12111 & check_pasted_section (info, ".fini"));
12112 }
12113
12114 /* See whether we can group stub sections together. Grouping stub
12115 sections may result in fewer stubs. More importantly, we need to
12116 put all .init* and .fini* stubs at the beginning of the .init or
12117 .fini output sections respectively, because glibc splits the
12118 _init and _fini functions into multiple parts. Putting a stub in
12119 the middle of a function is not a good idea. */
12120
12121 static bfd_boolean
12122 group_sections (struct bfd_link_info *info,
12123 bfd_size_type stub_group_size,
12124 bfd_boolean stubs_always_before_branch)
12125 {
12126 struct ppc_link_hash_table *htab;
12127 asection *osec;
12128 bfd_boolean suppress_size_errors;
12129
12130 htab = ppc_hash_table (info);
12131 if (htab == NULL)
12132 return FALSE;
12133
12134 suppress_size_errors = FALSE;
12135 if (stub_group_size == 1)
12136 {
12137 /* Default values. */
12138 if (stubs_always_before_branch)
12139 stub_group_size = 0x1e00000;
12140 else
12141 stub_group_size = 0x1c00000;
12142 suppress_size_errors = TRUE;
12143 }
12144
12145 for (osec = info->output_bfd->sections; osec != NULL; osec = osec->next)
12146 {
12147 asection *tail;
12148
12149 if (osec->id >= htab->sec_info_arr_size)
12150 continue;
12151
12152 tail = htab->sec_info[osec->id].u.list;
12153 while (tail != NULL)
12154 {
12155 asection *curr;
12156 asection *prev;
12157 bfd_size_type total;
12158 bfd_boolean big_sec;
12159 bfd_vma curr_toc;
12160 struct map_stub *group;
12161 bfd_size_type group_size;
12162
12163 curr = tail;
12164 total = tail->size;
12165 group_size = (ppc64_elf_section_data (tail) != NULL
12166 && ppc64_elf_section_data (tail)->has_14bit_branch
12167 ? stub_group_size >> 10 : stub_group_size);
12168
12169 big_sec = total > group_size;
12170 if (big_sec && !suppress_size_errors)
12171 /* xgettext:c-format */
12172 _bfd_error_handler (_("%B section %A exceeds stub group size"),
12173 tail->owner, tail);
12174 curr_toc = htab->sec_info[tail->id].toc_off;
12175
12176 while ((prev = htab->sec_info[curr->id].u.list) != NULL
12177 && ((total += curr->output_offset - prev->output_offset)
12178 < (ppc64_elf_section_data (prev) != NULL
12179 && ppc64_elf_section_data (prev)->has_14bit_branch
12180 ? (group_size = stub_group_size >> 10) : group_size))
12181 && htab->sec_info[prev->id].toc_off == curr_toc)
12182 curr = prev;
12183
12184 /* OK, the size from the start of CURR to the end is less
12185 than group_size and thus can be handled by one stub
12186 section. (or the tail section is itself larger than
12187 group_size, in which case we may be toast.) We should
12188 really be keeping track of the total size of stubs added
12189 here, as stubs contribute to the final output section
12190 size. That's a little tricky, and this way will only
12191 break if stubs added make the total size more than 2^25,
12192 ie. for the default stub_group_size, if stubs total more
12193 than 2097152 bytes, or nearly 75000 plt call stubs. */
12194 group = bfd_alloc (curr->owner, sizeof (*group));
12195 if (group == NULL)
12196 return FALSE;
12197 group->link_sec = curr;
12198 group->stub_sec = NULL;
12199 group->needs_save_res = 0;
12200 group->tls_get_addr_opt_bctrl = -1u;
12201 group->next = htab->group;
12202 htab->group = group;
12203 do
12204 {
12205 prev = htab->sec_info[tail->id].u.list;
12206 /* Set up this stub group. */
12207 htab->sec_info[tail->id].u.group = group;
12208 }
12209 while (tail != curr && (tail = prev) != NULL);
12210
12211 /* But wait, there's more! Input sections up to group_size
12212 bytes before the stub section can be handled by it too.
12213 Don't do this if we have a really large section after the
12214 stubs, as adding more stubs increases the chance that
12215 branches may not reach into the stub section. */
12216 if (!stubs_always_before_branch && !big_sec)
12217 {
12218 total = 0;
12219 while (prev != NULL
12220 && ((total += tail->output_offset - prev->output_offset)
12221 < (ppc64_elf_section_data (prev) != NULL
12222 && ppc64_elf_section_data (prev)->has_14bit_branch
12223 ? (group_size = stub_group_size >> 10) : group_size))
12224 && htab->sec_info[prev->id].toc_off == curr_toc)
12225 {
12226 tail = prev;
12227 prev = htab->sec_info[tail->id].u.list;
12228 htab->sec_info[tail->id].u.group = group;
12229 }
12230 }
12231 tail = prev;
12232 }
12233 }
12234 return TRUE;
12235 }
12236
12237 static const unsigned char glink_eh_frame_cie[] =
12238 {
12239 0, 0, 0, 16, /* length. */
12240 0, 0, 0, 0, /* id. */
12241 1, /* CIE version. */
12242 'z', 'R', 0, /* Augmentation string. */
12243 4, /* Code alignment. */
12244 0x78, /* Data alignment. */
12245 65, /* RA reg. */
12246 1, /* Augmentation size. */
12247 DW_EH_PE_pcrel | DW_EH_PE_sdata4, /* FDE encoding. */
12248 DW_CFA_def_cfa, 1, 0 /* def_cfa: r1 offset 0. */
12249 };
12250
12251 static size_t
12252 stub_eh_frame_size (struct map_stub *group, size_t align)
12253 {
12254 size_t this_size = 17;
12255 if (group->tls_get_addr_opt_bctrl != -1u)
12256 {
12257 unsigned int to_bctrl = group->tls_get_addr_opt_bctrl / 4;
12258 if (to_bctrl < 64)
12259 this_size += 1;
12260 else if (to_bctrl < 256)
12261 this_size += 2;
12262 else if (to_bctrl < 65536)
12263 this_size += 3;
12264 else
12265 this_size += 5;
12266 this_size += 6;
12267 }
12268 this_size = (this_size + align - 1) & -align;
12269 return this_size;
12270 }
12271
12272 /* Stripping output sections is normally done before dynamic section
12273 symbols have been allocated. This function is called later, and
12274 handles cases like htab->brlt which is mapped to its own output
12275 section. */
12276
12277 static void
12278 maybe_strip_output (struct bfd_link_info *info, asection *isec)
12279 {
12280 if (isec->size == 0
12281 && isec->output_section->size == 0
12282 && !(isec->output_section->flags & SEC_KEEP)
12283 && !bfd_section_removed_from_list (info->output_bfd,
12284 isec->output_section)
12285 && elf_section_data (isec->output_section)->dynindx == 0)
12286 {
12287 isec->output_section->flags |= SEC_EXCLUDE;
12288 bfd_section_list_remove (info->output_bfd, isec->output_section);
12289 info->output_bfd->section_count--;
12290 }
12291 }
12292
12293 /* Determine and set the size of the stub section for a final link.
12294
12295 The basic idea here is to examine all the relocations looking for
12296 PC-relative calls to a target that is unreachable with a "bl"
12297 instruction. */
12298
12299 bfd_boolean
12300 ppc64_elf_size_stubs (struct bfd_link_info *info)
12301 {
12302 bfd_size_type stub_group_size;
12303 bfd_boolean stubs_always_before_branch;
12304 struct ppc_link_hash_table *htab = ppc_hash_table (info);
12305
12306 if (htab == NULL)
12307 return FALSE;
12308
12309 if (htab->params->plt_thread_safe == -1 && !bfd_link_executable (info))
12310 htab->params->plt_thread_safe = 1;
12311 if (!htab->opd_abi)
12312 htab->params->plt_thread_safe = 0;
12313 else if (htab->params->plt_thread_safe == -1)
12314 {
12315 static const char *const thread_starter[] =
12316 {
12317 "pthread_create",
12318 /* libstdc++ */
12319 "_ZNSt6thread15_M_start_threadESt10shared_ptrINS_10_Impl_baseEE",
12320 /* librt */
12321 "aio_init", "aio_read", "aio_write", "aio_fsync", "lio_listio",
12322 "mq_notify", "create_timer",
12323 /* libanl */
12324 "getaddrinfo_a",
12325 /* libgomp */
12326 "GOMP_parallel",
12327 "GOMP_parallel_start",
12328 "GOMP_parallel_loop_static",
12329 "GOMP_parallel_loop_static_start",
12330 "GOMP_parallel_loop_dynamic",
12331 "GOMP_parallel_loop_dynamic_start",
12332 "GOMP_parallel_loop_guided",
12333 "GOMP_parallel_loop_guided_start",
12334 "GOMP_parallel_loop_runtime",
12335 "GOMP_parallel_loop_runtime_start",
12336 "GOMP_parallel_sections",
12337 "GOMP_parallel_sections_start",
12338 /* libgo */
12339 "__go_go",
12340 };
12341 unsigned i;
12342
12343 for (i = 0; i < ARRAY_SIZE (thread_starter); i++)
12344 {
12345 struct elf_link_hash_entry *h;
12346 h = elf_link_hash_lookup (&htab->elf, thread_starter[i],
12347 FALSE, FALSE, TRUE);
12348 htab->params->plt_thread_safe = h != NULL && h->ref_regular;
12349 if (htab->params->plt_thread_safe)
12350 break;
12351 }
12352 }
12353 stubs_always_before_branch = htab->params->group_size < 0;
12354 if (htab->params->group_size < 0)
12355 stub_group_size = -htab->params->group_size;
12356 else
12357 stub_group_size = htab->params->group_size;
12358
12359 if (!group_sections (info, stub_group_size, stubs_always_before_branch))
12360 return FALSE;
12361
12362 #define STUB_SHRINK_ITER 20
12363 /* Loop until no stubs added. After iteration 20 of this loop we may
12364 exit on a stub section shrinking. This is to break out of a
12365 pathological case where adding stubs on one iteration decreases
12366 section gaps (perhaps due to alignment), which then requires
12367 fewer or smaller stubs on the next iteration. */
12368
12369 while (1)
12370 {
12371 bfd *input_bfd;
12372 unsigned int bfd_indx;
12373 struct map_stub *group;
12374
12375 htab->stub_iteration += 1;
12376
12377 for (input_bfd = info->input_bfds, bfd_indx = 0;
12378 input_bfd != NULL;
12379 input_bfd = input_bfd->link.next, bfd_indx++)
12380 {
12381 Elf_Internal_Shdr *symtab_hdr;
12382 asection *section;
12383 Elf_Internal_Sym *local_syms = NULL;
12384
12385 if (!is_ppc64_elf (input_bfd))
12386 continue;
12387
12388 /* We'll need the symbol table in a second. */
12389 symtab_hdr = &elf_symtab_hdr (input_bfd);
12390 if (symtab_hdr->sh_info == 0)
12391 continue;
12392
12393 /* Walk over each section attached to the input bfd. */
12394 for (section = input_bfd->sections;
12395 section != NULL;
12396 section = section->next)
12397 {
12398 Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
12399
12400 /* If there aren't any relocs, then there's nothing more
12401 to do. */
12402 if ((section->flags & SEC_RELOC) == 0
12403 || (section->flags & SEC_ALLOC) == 0
12404 || (section->flags & SEC_LOAD) == 0
12405 || (section->flags & SEC_CODE) == 0
12406 || section->reloc_count == 0)
12407 continue;
12408
12409 /* If this section is a link-once section that will be
12410 discarded, then don't create any stubs. */
12411 if (section->output_section == NULL
12412 || section->output_section->owner != info->output_bfd)
12413 continue;
12414
12415 /* Get the relocs. */
12416 internal_relocs
12417 = _bfd_elf_link_read_relocs (input_bfd, section, NULL, NULL,
12418 info->keep_memory);
12419 if (internal_relocs == NULL)
12420 goto error_ret_free_local;
12421
12422 /* Now examine each relocation. */
12423 irela = internal_relocs;
12424 irelaend = irela + section->reloc_count;
12425 for (; irela < irelaend; irela++)
12426 {
12427 enum elf_ppc64_reloc_type r_type;
12428 unsigned int r_indx;
12429 enum ppc_stub_type stub_type;
12430 struct ppc_stub_hash_entry *stub_entry;
12431 asection *sym_sec, *code_sec;
12432 bfd_vma sym_value, code_value;
12433 bfd_vma destination;
12434 unsigned long local_off;
12435 bfd_boolean ok_dest;
12436 struct ppc_link_hash_entry *hash;
12437 struct ppc_link_hash_entry *fdh;
12438 struct elf_link_hash_entry *h;
12439 Elf_Internal_Sym *sym;
12440 char *stub_name;
12441 const asection *id_sec;
12442 struct _opd_sec_data *opd;
12443 struct plt_entry *plt_ent;
12444
12445 r_type = ELF64_R_TYPE (irela->r_info);
12446 r_indx = ELF64_R_SYM (irela->r_info);
12447
12448 if (r_type >= R_PPC64_max)
12449 {
12450 bfd_set_error (bfd_error_bad_value);
12451 goto error_ret_free_internal;
12452 }
12453
12454 /* Only look for stubs on branch instructions. */
12455 if (r_type != R_PPC64_REL24
12456 && r_type != R_PPC64_REL14
12457 && r_type != R_PPC64_REL14_BRTAKEN
12458 && r_type != R_PPC64_REL14_BRNTAKEN)
12459 continue;
12460
12461 /* Now determine the call target, its name, value,
12462 section. */
12463 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
12464 r_indx, input_bfd))
12465 goto error_ret_free_internal;
12466 hash = (struct ppc_link_hash_entry *) h;
12467
12468 ok_dest = FALSE;
12469 fdh = NULL;
12470 sym_value = 0;
12471 if (hash == NULL)
12472 {
12473 sym_value = sym->st_value;
12474 if (sym_sec != NULL
12475 && sym_sec->output_section != NULL)
12476 ok_dest = TRUE;
12477 }
12478 else if (hash->elf.root.type == bfd_link_hash_defined
12479 || hash->elf.root.type == bfd_link_hash_defweak)
12480 {
12481 sym_value = hash->elf.root.u.def.value;
12482 if (sym_sec->output_section != NULL)
12483 ok_dest = TRUE;
12484 }
12485 else if (hash->elf.root.type == bfd_link_hash_undefweak
12486 || hash->elf.root.type == bfd_link_hash_undefined)
12487 {
12488 /* Recognise an old ABI func code entry sym, and
12489 use the func descriptor sym instead if it is
12490 defined. */
12491 if (hash->elf.root.root.string[0] == '.'
12492 && hash->oh != NULL)
12493 {
12494 fdh = ppc_follow_link (hash->oh);
12495 if (fdh->elf.root.type == bfd_link_hash_defined
12496 || fdh->elf.root.type == bfd_link_hash_defweak)
12497 {
12498 sym_sec = fdh->elf.root.u.def.section;
12499 sym_value = fdh->elf.root.u.def.value;
12500 if (sym_sec->output_section != NULL)
12501 ok_dest = TRUE;
12502 }
12503 else
12504 fdh = NULL;
12505 }
12506 }
12507 else
12508 {
12509 bfd_set_error (bfd_error_bad_value);
12510 goto error_ret_free_internal;
12511 }
12512
12513 destination = 0;
12514 local_off = 0;
12515 if (ok_dest)
12516 {
12517 sym_value += irela->r_addend;
12518 destination = (sym_value
12519 + sym_sec->output_offset
12520 + sym_sec->output_section->vma);
12521 local_off = PPC64_LOCAL_ENTRY_OFFSET (hash
12522 ? hash->elf.other
12523 : sym->st_other);
12524 }
12525
12526 code_sec = sym_sec;
12527 code_value = sym_value;
12528 opd = get_opd_info (sym_sec);
12529 if (opd != NULL)
12530 {
12531 bfd_vma dest;
12532
12533 if (hash == NULL && opd->adjust != NULL)
12534 {
12535 long adjust = opd->adjust[OPD_NDX (sym_value)];
12536 if (adjust == -1)
12537 continue;
12538 code_value += adjust;
12539 sym_value += adjust;
12540 }
12541 dest = opd_entry_value (sym_sec, sym_value,
12542 &code_sec, &code_value, FALSE);
12543 if (dest != (bfd_vma) -1)
12544 {
12545 destination = dest;
12546 if (fdh != NULL)
12547 {
12548 /* Fixup old ABI sym to point at code
12549 entry. */
12550 hash->elf.root.type = bfd_link_hash_defweak;
12551 hash->elf.root.u.def.section = code_sec;
12552 hash->elf.root.u.def.value = code_value;
12553 }
12554 }
12555 }
12556
12557 /* Determine what (if any) linker stub is needed. */
12558 plt_ent = NULL;
12559 stub_type = ppc_type_of_stub (section, irela, &hash,
12560 &plt_ent, destination,
12561 local_off);
12562
12563 if (stub_type != ppc_stub_plt_call)
12564 {
12565 /* Check whether we need a TOC adjusting stub.
12566 Since the linker pastes together pieces from
12567 different object files when creating the
12568 _init and _fini functions, it may be that a
12569 call to what looks like a local sym is in
12570 fact a call needing a TOC adjustment. */
12571 if (code_sec != NULL
12572 && code_sec->output_section != NULL
12573 && (htab->sec_info[code_sec->id].toc_off
12574 != htab->sec_info[section->id].toc_off)
12575 && (code_sec->has_toc_reloc
12576 || code_sec->makes_toc_func_call))
12577 stub_type = ppc_stub_long_branch_r2off;
12578 }
12579
12580 if (stub_type == ppc_stub_none)
12581 continue;
12582
12583 /* __tls_get_addr calls might be eliminated. */
12584 if (stub_type != ppc_stub_plt_call
12585 && hash != NULL
12586 && (hash == htab->tls_get_addr
12587 || hash == htab->tls_get_addr_fd)
12588 && section->has_tls_reloc
12589 && irela != internal_relocs)
12590 {
12591 /* Get tls info. */
12592 unsigned char *tls_mask;
12593
12594 if (!get_tls_mask (&tls_mask, NULL, NULL, &local_syms,
12595 irela - 1, input_bfd))
12596 goto error_ret_free_internal;
12597 if (*tls_mask != 0)
12598 continue;
12599 }
12600
12601 if (stub_type == ppc_stub_plt_call)
12602 {
12603 if (!htab->opd_abi
12604 && htab->params->plt_localentry0 != 0
12605 && is_elfv2_localentry0 (&hash->elf))
12606 htab->has_plt_localentry0 = 1;
12607 else if (irela + 1 < irelaend
12608 && irela[1].r_offset == irela->r_offset + 4
12609 && (ELF64_R_TYPE (irela[1].r_info)
12610 == R_PPC64_TOCSAVE))
12611 {
12612 if (!tocsave_find (htab, INSERT,
12613 &local_syms, irela + 1, input_bfd))
12614 goto error_ret_free_internal;
12615 }
12616 else
12617 stub_type = ppc_stub_plt_call_r2save;
12618 }
12619
12620 /* Support for grouping stub sections. */
12621 id_sec = htab->sec_info[section->id].u.group->link_sec;
12622
12623 /* Get the name of this stub. */
12624 stub_name = ppc_stub_name (id_sec, sym_sec, hash, irela);
12625 if (!stub_name)
12626 goto error_ret_free_internal;
12627
12628 stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
12629 stub_name, FALSE, FALSE);
12630 if (stub_entry != NULL)
12631 {
12632 /* The proper stub has already been created. */
12633 free (stub_name);
12634 if (stub_type == ppc_stub_plt_call_r2save)
12635 stub_entry->stub_type = stub_type;
12636 continue;
12637 }
12638
12639 stub_entry = ppc_add_stub (stub_name, section, info);
12640 if (stub_entry == NULL)
12641 {
12642 free (stub_name);
12643 error_ret_free_internal:
12644 if (elf_section_data (section)->relocs == NULL)
12645 free (internal_relocs);
12646 error_ret_free_local:
12647 if (local_syms != NULL
12648 && (symtab_hdr->contents
12649 != (unsigned char *) local_syms))
12650 free (local_syms);
12651 return FALSE;
12652 }
12653
12654 stub_entry->stub_type = stub_type;
12655 if (stub_type != ppc_stub_plt_call
12656 && stub_type != ppc_stub_plt_call_r2save)
12657 {
12658 stub_entry->target_value = code_value;
12659 stub_entry->target_section = code_sec;
12660 }
12661 else
12662 {
12663 stub_entry->target_value = sym_value;
12664 stub_entry->target_section = sym_sec;
12665 }
12666 stub_entry->h = hash;
12667 stub_entry->plt_ent = plt_ent;
12668 stub_entry->other = hash ? hash->elf.other : sym->st_other;
12669
12670 if (stub_entry->h != NULL)
12671 htab->stub_globals += 1;
12672 }
12673
12674 /* We're done with the internal relocs, free them. */
12675 if (elf_section_data (section)->relocs != internal_relocs)
12676 free (internal_relocs);
12677 }
12678
12679 if (local_syms != NULL
12680 && symtab_hdr->contents != (unsigned char *) local_syms)
12681 {
12682 if (!info->keep_memory)
12683 free (local_syms);
12684 else
12685 symtab_hdr->contents = (unsigned char *) local_syms;
12686 }
12687 }
12688
12689 /* We may have added some stubs. Find out the new size of the
12690 stub sections. */
12691 for (group = htab->group; group != NULL; group = group->next)
12692 if (group->stub_sec != NULL)
12693 {
12694 asection *stub_sec = group->stub_sec;
12695
12696 if (htab->stub_iteration <= STUB_SHRINK_ITER
12697 || stub_sec->rawsize < stub_sec->size)
12698 /* Past STUB_SHRINK_ITER, rawsize is the max size seen. */
12699 stub_sec->rawsize = stub_sec->size;
12700 stub_sec->size = 0;
12701 stub_sec->reloc_count = 0;
12702 stub_sec->flags &= ~SEC_RELOC;
12703 }
12704
12705 if (htab->stub_iteration <= STUB_SHRINK_ITER
12706 || htab->brlt->rawsize < htab->brlt->size)
12707 htab->brlt->rawsize = htab->brlt->size;
12708 htab->brlt->size = 0;
12709 htab->brlt->reloc_count = 0;
12710 htab->brlt->flags &= ~SEC_RELOC;
12711 if (htab->relbrlt != NULL)
12712 htab->relbrlt->size = 0;
12713
12714 bfd_hash_traverse (&htab->stub_hash_table, ppc_size_one_stub, info);
12715
12716 for (group = htab->group; group != NULL; group = group->next)
12717 if (group->needs_save_res)
12718 group->stub_sec->size += htab->sfpr->size;
12719
12720 if (info->emitrelocations
12721 && htab->glink != NULL && htab->glink->size != 0)
12722 {
12723 htab->glink->reloc_count = 1;
12724 htab->glink->flags |= SEC_RELOC;
12725 }
12726
12727 if (htab->glink_eh_frame != NULL
12728 && !bfd_is_abs_section (htab->glink_eh_frame->output_section)
12729 && htab->glink_eh_frame->output_section->size > 8)
12730 {
12731 size_t size = 0, align = 4;
12732
12733 for (group = htab->group; group != NULL; group = group->next)
12734 if (group->stub_sec != NULL)
12735 size += stub_eh_frame_size (group, align);
12736 if (htab->glink != NULL && htab->glink->size != 0)
12737 size += (24 + align - 1) & -align;
12738 if (size != 0)
12739 size += (sizeof (glink_eh_frame_cie) + align - 1) & -align;
12740 align = 1ul << htab->glink_eh_frame->output_section->alignment_power;
12741 size = (size + align - 1) & -align;
12742 htab->glink_eh_frame->rawsize = htab->glink_eh_frame->size;
12743 htab->glink_eh_frame->size = size;
12744 }
12745
12746 if (htab->params->plt_stub_align != 0)
12747 for (group = htab->group; group != NULL; group = group->next)
12748 if (group->stub_sec != NULL)
12749 {
12750 int align = abs (htab->params->plt_stub_align);
12751 group->stub_sec->size
12752 = (group->stub_sec->size + (1 << align) - 1) & -(1 << align);
12753 }
12754
12755 for (group = htab->group; group != NULL; group = group->next)
12756 if (group->stub_sec != NULL
12757 && group->stub_sec->rawsize != group->stub_sec->size
12758 && (htab->stub_iteration <= STUB_SHRINK_ITER
12759 || group->stub_sec->rawsize < group->stub_sec->size))
12760 break;
12761
12762 if (group == NULL
12763 && (htab->brlt->rawsize == htab->brlt->size
12764 || (htab->stub_iteration > STUB_SHRINK_ITER
12765 && htab->brlt->rawsize > htab->brlt->size))
12766 && (htab->glink_eh_frame == NULL
12767 || htab->glink_eh_frame->rawsize == htab->glink_eh_frame->size))
12768 break;
12769
12770 /* Ask the linker to do its stuff. */
12771 (*htab->params->layout_sections_again) ();
12772 }
12773
12774 if (htab->glink_eh_frame != NULL
12775 && htab->glink_eh_frame->size != 0)
12776 {
12777 bfd_vma val;
12778 bfd_byte *p, *last_fde;
12779 size_t last_fde_len, size, align, pad;
12780 struct map_stub *group;
12781
12782 p = bfd_zalloc (htab->glink_eh_frame->owner, htab->glink_eh_frame->size);
12783 if (p == NULL)
12784 return FALSE;
12785 htab->glink_eh_frame->contents = p;
12786 last_fde = p;
12787 align = 4;
12788
12789 memcpy (p, glink_eh_frame_cie, sizeof (glink_eh_frame_cie));
12790 /* CIE length (rewrite in case little-endian). */
12791 last_fde_len = ((sizeof (glink_eh_frame_cie) + align - 1) & -align) - 4;
12792 bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
12793 p += last_fde_len + 4;
12794
12795 for (group = htab->group; group != NULL; group = group->next)
12796 if (group->stub_sec != NULL)
12797 {
12798 last_fde = p;
12799 last_fde_len = stub_eh_frame_size (group, align) - 4;
12800 /* FDE length. */
12801 bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
12802 p += 4;
12803 /* CIE pointer. */
12804 val = p - htab->glink_eh_frame->contents;
12805 bfd_put_32 (htab->elf.dynobj, val, p);
12806 p += 4;
12807 /* Offset to stub section, written later. */
12808 p += 4;
12809 /* stub section size. */
12810 bfd_put_32 (htab->elf.dynobj, group->stub_sec->size, p);
12811 p += 4;
12812 /* Augmentation. */
12813 p += 1;
12814 if (group->tls_get_addr_opt_bctrl != -1u)
12815 {
12816 unsigned int to_bctrl = group->tls_get_addr_opt_bctrl / 4;
12817
12818 /* This FDE needs more than just the default.
12819 Describe __tls_get_addr_opt stub LR. */
12820 if (to_bctrl < 64)
12821 *p++ = DW_CFA_advance_loc + to_bctrl;
12822 else if (to_bctrl < 256)
12823 {
12824 *p++ = DW_CFA_advance_loc1;
12825 *p++ = to_bctrl;
12826 }
12827 else if (to_bctrl < 65536)
12828 {
12829 *p++ = DW_CFA_advance_loc2;
12830 bfd_put_16 (htab->elf.dynobj, to_bctrl, p);
12831 p += 2;
12832 }
12833 else
12834 {
12835 *p++ = DW_CFA_advance_loc4;
12836 bfd_put_32 (htab->elf.dynobj, to_bctrl, p);
12837 p += 4;
12838 }
12839 *p++ = DW_CFA_offset_extended_sf;
12840 *p++ = 65;
12841 *p++ = -(STK_LINKER (htab) / 8) & 0x7f;
12842 *p++ = DW_CFA_advance_loc + 4;
12843 *p++ = DW_CFA_restore_extended;
12844 *p++ = 65;
12845 }
12846 /* Pad. */
12847 p = last_fde + last_fde_len + 4;
12848 }
12849 if (htab->glink != NULL && htab->glink->size != 0)
12850 {
12851 last_fde = p;
12852 last_fde_len = ((24 + align - 1) & -align) - 4;
12853 /* FDE length. */
12854 bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
12855 p += 4;
12856 /* CIE pointer. */
12857 val = p - htab->glink_eh_frame->contents;
12858 bfd_put_32 (htab->elf.dynobj, val, p);
12859 p += 4;
12860 /* Offset to .glink, written later. */
12861 p += 4;
12862 /* .glink size. */
12863 bfd_put_32 (htab->elf.dynobj, htab->glink->size - 8, p);
12864 p += 4;
12865 /* Augmentation. */
12866 p += 1;
12867
12868 *p++ = DW_CFA_advance_loc + 1;
12869 *p++ = DW_CFA_register;
12870 *p++ = 65;
12871 *p++ = htab->opd_abi ? 12 : 0;
12872 *p++ = DW_CFA_advance_loc + (htab->opd_abi ? 5 : 7);
12873 *p++ = DW_CFA_restore_extended;
12874 *p++ = 65;
12875 p += ((24 + align - 1) & -align) - 24;
12876 }
12877 /* Subsume any padding into the last FDE if user .eh_frame
12878 sections are aligned more than glink_eh_frame. Otherwise any
12879 zero padding will be seen as a terminator. */
12880 align = 1ul << htab->glink_eh_frame->output_section->alignment_power;
12881 size = p - htab->glink_eh_frame->contents;
12882 pad = ((size + align - 1) & -align) - size;
12883 htab->glink_eh_frame->size = size + pad;
12884 bfd_put_32 (htab->elf.dynobj, last_fde_len + pad, last_fde);
12885 }
12886
12887 maybe_strip_output (info, htab->brlt);
12888 if (htab->glink_eh_frame != NULL)
12889 maybe_strip_output (info, htab->glink_eh_frame);
12890
12891 return TRUE;
12892 }
12893
12894 /* Called after we have determined section placement. If sections
12895 move, we'll be called again. Provide a value for TOCstart. */
12896
12897 bfd_vma
12898 ppc64_elf_set_toc (struct bfd_link_info *info, bfd *obfd)
12899 {
12900 asection *s;
12901 bfd_vma TOCstart, adjust;
12902
12903 if (info != NULL)
12904 {
12905 struct elf_link_hash_entry *h;
12906 struct elf_link_hash_table *htab = elf_hash_table (info);
12907
12908 if (is_elf_hash_table (htab)
12909 && htab->hgot != NULL)
12910 h = htab->hgot;
12911 else
12912 {
12913 h = elf_link_hash_lookup (htab, ".TOC.", FALSE, FALSE, TRUE);
12914 if (is_elf_hash_table (htab))
12915 htab->hgot = h;
12916 }
12917 if (h != NULL
12918 && h->root.type == bfd_link_hash_defined
12919 && !h->root.linker_def
12920 && (!is_elf_hash_table (htab)
12921 || h->def_regular))
12922 {
12923 TOCstart = (h->root.u.def.value - TOC_BASE_OFF
12924 + h->root.u.def.section->output_offset
12925 + h->root.u.def.section->output_section->vma);
12926 _bfd_set_gp_value (obfd, TOCstart);
12927 return TOCstart;
12928 }
12929 }
12930
12931 /* The TOC consists of sections .got, .toc, .tocbss, .plt in that
12932 order. The TOC starts where the first of these sections starts. */
12933 s = bfd_get_section_by_name (obfd, ".got");
12934 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12935 s = bfd_get_section_by_name (obfd, ".toc");
12936 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12937 s = bfd_get_section_by_name (obfd, ".tocbss");
12938 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12939 s = bfd_get_section_by_name (obfd, ".plt");
12940 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12941 {
12942 /* This may happen for
12943 o references to TOC base (SYM@toc / TOC[tc0]) without a
12944 .toc directive
12945 o bad linker script
12946 o --gc-sections and empty TOC sections
12947
12948 FIXME: Warn user? */
12949
12950 /* Look for a likely section. We probably won't even be
12951 using TOCstart. */
12952 for (s = obfd->sections; s != NULL; s = s->next)
12953 if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_READONLY
12954 | SEC_EXCLUDE))
12955 == (SEC_ALLOC | SEC_SMALL_DATA))
12956 break;
12957 if (s == NULL)
12958 for (s = obfd->sections; s != NULL; s = s->next)
12959 if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_EXCLUDE))
12960 == (SEC_ALLOC | SEC_SMALL_DATA))
12961 break;
12962 if (s == NULL)
12963 for (s = obfd->sections; s != NULL; s = s->next)
12964 if ((s->flags & (SEC_ALLOC | SEC_READONLY | SEC_EXCLUDE))
12965 == SEC_ALLOC)
12966 break;
12967 if (s == NULL)
12968 for (s = obfd->sections; s != NULL; s = s->next)
12969 if ((s->flags & (SEC_ALLOC | SEC_EXCLUDE)) == SEC_ALLOC)
12970 break;
12971 }
12972
12973 TOCstart = 0;
12974 if (s != NULL)
12975 TOCstart = s->output_section->vma + s->output_offset;
12976
12977 /* Force alignment. */
12978 adjust = TOCstart & (TOC_BASE_ALIGN - 1);
12979 TOCstart -= adjust;
12980 _bfd_set_gp_value (obfd, TOCstart);
12981
12982 if (info != NULL && s != NULL)
12983 {
12984 struct ppc_link_hash_table *htab = ppc_hash_table (info);
12985
12986 if (htab != NULL)
12987 {
12988 if (htab->elf.hgot != NULL)
12989 {
12990 htab->elf.hgot->root.u.def.value = TOC_BASE_OFF - adjust;
12991 htab->elf.hgot->root.u.def.section = s;
12992 }
12993 }
12994 else
12995 {
12996 struct bfd_link_hash_entry *bh = NULL;
12997 _bfd_generic_link_add_one_symbol (info, obfd, ".TOC.", BSF_GLOBAL,
12998 s, TOC_BASE_OFF - adjust,
12999 NULL, FALSE, FALSE, &bh);
13000 }
13001 }
13002 return TOCstart;
13003 }
13004
13005 /* Called via elf_link_hash_traverse from ppc64_elf_build_stubs to
13006 write out any global entry stubs. */
13007
13008 static bfd_boolean
13009 build_global_entry_stubs (struct elf_link_hash_entry *h, void *inf)
13010 {
13011 struct bfd_link_info *info;
13012 struct ppc_link_hash_table *htab;
13013 struct plt_entry *pent;
13014 asection *s;
13015
13016 if (h->root.type == bfd_link_hash_indirect)
13017 return TRUE;
13018
13019 if (!h->pointer_equality_needed)
13020 return TRUE;
13021
13022 if (h->def_regular)
13023 return TRUE;
13024
13025 info = inf;
13026 htab = ppc_hash_table (info);
13027 if (htab == NULL)
13028 return FALSE;
13029
13030 s = htab->global_entry;
13031 for (pent = h->plt.plist; pent != NULL; pent = pent->next)
13032 if (pent->plt.offset != (bfd_vma) -1
13033 && pent->addend == 0)
13034 {
13035 bfd_byte *p;
13036 asection *plt;
13037 bfd_vma off;
13038
13039 p = s->contents + h->root.u.def.value;
13040 plt = htab->elf.splt;
13041 if (!htab->elf.dynamic_sections_created
13042 || h->dynindx == -1)
13043 plt = htab->elf.iplt;
13044 off = pent->plt.offset + plt->output_offset + plt->output_section->vma;
13045 off -= h->root.u.def.value + s->output_offset + s->output_section->vma;
13046
13047 if (off + 0x80008000 > 0xffffffff || (off & 3) != 0)
13048 {
13049 info->callbacks->einfo
13050 (_("%P: linkage table error against `%T'\n"),
13051 h->root.root.string);
13052 bfd_set_error (bfd_error_bad_value);
13053 htab->stub_error = TRUE;
13054 }
13055
13056 htab->stub_count[ppc_stub_global_entry - 1] += 1;
13057 if (htab->params->emit_stub_syms)
13058 {
13059 size_t len = strlen (h->root.root.string);
13060 char *name = bfd_malloc (sizeof "12345678.global_entry." + len);
13061
13062 if (name == NULL)
13063 return FALSE;
13064
13065 sprintf (name, "%08x.global_entry.%s", s->id, h->root.root.string);
13066 h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
13067 if (h == NULL)
13068 return FALSE;
13069 if (h->root.type == bfd_link_hash_new)
13070 {
13071 h->root.type = bfd_link_hash_defined;
13072 h->root.u.def.section = s;
13073 h->root.u.def.value = p - s->contents;
13074 h->ref_regular = 1;
13075 h->def_regular = 1;
13076 h->ref_regular_nonweak = 1;
13077 h->forced_local = 1;
13078 h->non_elf = 0;
13079 h->root.linker_def = 1;
13080 }
13081 }
13082
13083 if (PPC_HA (off) != 0)
13084 {
13085 bfd_put_32 (s->owner, ADDIS_R12_R12 | PPC_HA (off), p);
13086 p += 4;
13087 }
13088 bfd_put_32 (s->owner, LD_R12_0R12 | PPC_LO (off), p);
13089 p += 4;
13090 bfd_put_32 (s->owner, MTCTR_R12, p);
13091 p += 4;
13092 output_bctr (htab, s->owner, p);
13093 break;
13094 }
13095 return TRUE;
13096 }
13097
13098 /* Build all the stubs associated with the current output file.
13099 The stubs are kept in a hash table attached to the main linker
13100 hash table. This function is called via gldelf64ppc_finish. */
13101
13102 bfd_boolean
13103 ppc64_elf_build_stubs (struct bfd_link_info *info,
13104 char **stats)
13105 {
13106 struct ppc_link_hash_table *htab = ppc_hash_table (info);
13107 struct map_stub *group;
13108 asection *stub_sec;
13109 bfd_byte *p;
13110 int stub_sec_count = 0;
13111
13112 if (htab == NULL)
13113 return FALSE;
13114
13115 /* Allocate memory to hold the linker stubs. */
13116 for (group = htab->group; group != NULL; group = group->next)
13117 if ((stub_sec = group->stub_sec) != NULL
13118 && stub_sec->size != 0)
13119 {
13120 stub_sec->contents = bfd_zalloc (htab->params->stub_bfd, stub_sec->size);
13121 if (stub_sec->contents == NULL)
13122 return FALSE;
13123 stub_sec->size = 0;
13124 }
13125
13126 if (htab->glink != NULL && htab->glink->size != 0)
13127 {
13128 unsigned int indx;
13129 bfd_vma plt0;
13130
13131 /* Build the .glink plt call stub. */
13132 if (htab->params->emit_stub_syms)
13133 {
13134 struct elf_link_hash_entry *h;
13135 h = elf_link_hash_lookup (&htab->elf, "__glink_PLTresolve",
13136 TRUE, FALSE, FALSE);
13137 if (h == NULL)
13138 return FALSE;
13139 if (h->root.type == bfd_link_hash_new)
13140 {
13141 h->root.type = bfd_link_hash_defined;
13142 h->root.u.def.section = htab->glink;
13143 h->root.u.def.value = 8;
13144 h->ref_regular = 1;
13145 h->def_regular = 1;
13146 h->ref_regular_nonweak = 1;
13147 h->forced_local = 1;
13148 h->non_elf = 0;
13149 h->root.linker_def = 1;
13150 }
13151 }
13152 plt0 = (htab->elf.splt->output_section->vma
13153 + htab->elf.splt->output_offset
13154 - 16);
13155 if (info->emitrelocations)
13156 {
13157 Elf_Internal_Rela *r = get_relocs (htab->glink, 1);
13158 if (r == NULL)
13159 return FALSE;
13160 r->r_offset = (htab->glink->output_offset
13161 + htab->glink->output_section->vma);
13162 r->r_info = ELF64_R_INFO (0, R_PPC64_REL64);
13163 r->r_addend = plt0;
13164 }
13165 p = htab->glink->contents;
13166 plt0 -= htab->glink->output_section->vma + htab->glink->output_offset;
13167 bfd_put_64 (htab->glink->owner, plt0, p);
13168 p += 8;
13169 if (htab->opd_abi)
13170 {
13171 bfd_put_32 (htab->glink->owner, MFLR_R12, p);
13172 p += 4;
13173 bfd_put_32 (htab->glink->owner, BCL_20_31, p);
13174 p += 4;
13175 bfd_put_32 (htab->glink->owner, MFLR_R11, p);
13176 p += 4;
13177 bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
13178 p += 4;
13179 bfd_put_32 (htab->glink->owner, MTLR_R12, p);
13180 p += 4;
13181 bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
13182 p += 4;
13183 bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
13184 p += 4;
13185 bfd_put_32 (htab->glink->owner, LD_R2_0R11 | 8, p);
13186 p += 4;
13187 bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
13188 p += 4;
13189 bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 16, p);
13190 p += 4;
13191 }
13192 else
13193 {
13194 bfd_put_32 (htab->glink->owner, MFLR_R0, p);
13195 p += 4;
13196 bfd_put_32 (htab->glink->owner, BCL_20_31, p);
13197 p += 4;
13198 bfd_put_32 (htab->glink->owner, MFLR_R11, p);
13199 p += 4;
13200 bfd_put_32 (htab->glink->owner, STD_R2_0R1 + 24, p);
13201 p += 4;
13202 bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
13203 p += 4;
13204 bfd_put_32 (htab->glink->owner, MTLR_R0, p);
13205 p += 4;
13206 bfd_put_32 (htab->glink->owner, SUB_R12_R12_R11, p);
13207 p += 4;
13208 bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
13209 p += 4;
13210 bfd_put_32 (htab->glink->owner, ADDI_R0_R12 | (-48 & 0xffff), p);
13211 p += 4;
13212 bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
13213 p += 4;
13214 bfd_put_32 (htab->glink->owner, SRDI_R0_R0_2, p);
13215 p += 4;
13216 bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
13217 p += 4;
13218 bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 8, p);
13219 p += 4;
13220 }
13221 p = output_bctr (htab, htab->glink->owner, p);
13222 BFD_ASSERT (p == htab->glink->contents + GLINK_PLTRESOLVE_SIZE (htab));
13223
13224 /* Build the .glink lazy link call stubs. */
13225 indx = 0;
13226 while (p < htab->glink->contents + htab->glink->size)
13227 {
13228 if (htab->opd_abi)
13229 {
13230 if (indx < 0x8000)
13231 {
13232 bfd_put_32 (htab->glink->owner, LI_R0_0 | indx, p);
13233 p += 4;
13234 }
13235 else
13236 {
13237 bfd_put_32 (htab->glink->owner, LIS_R0_0 | PPC_HI (indx), p);
13238 p += 4;
13239 bfd_put_32 (htab->glink->owner, ORI_R0_R0_0 | PPC_LO (indx),
13240 p);
13241 p += 4;
13242 }
13243 }
13244 bfd_put_32 (htab->glink->owner,
13245 B_DOT | ((htab->glink->contents - p + 8) & 0x3fffffc), p);
13246 indx++;
13247 p += 4;
13248 }
13249 }
13250
13251 /* Build .glink global entry stubs. */
13252 if (htab->global_entry != NULL && htab->global_entry->size != 0)
13253 elf_link_hash_traverse (&htab->elf, build_global_entry_stubs, info);
13254
13255 if (htab->brlt != NULL && htab->brlt->size != 0)
13256 {
13257 htab->brlt->contents = bfd_zalloc (htab->brlt->owner,
13258 htab->brlt->size);
13259 if (htab->brlt->contents == NULL)
13260 return FALSE;
13261 }
13262 if (htab->relbrlt != NULL && htab->relbrlt->size != 0)
13263 {
13264 htab->relbrlt->contents = bfd_zalloc (htab->relbrlt->owner,
13265 htab->relbrlt->size);
13266 if (htab->relbrlt->contents == NULL)
13267 return FALSE;
13268 }
13269
13270 /* Build the stubs as directed by the stub hash table. */
13271 bfd_hash_traverse (&htab->stub_hash_table, ppc_build_one_stub, info);
13272
13273 for (group = htab->group; group != NULL; group = group->next)
13274 if (group->needs_save_res)
13275 {
13276 stub_sec = group->stub_sec;
13277 memcpy (stub_sec->contents + stub_sec->size, htab->sfpr->contents,
13278 htab->sfpr->size);
13279 if (htab->params->emit_stub_syms)
13280 {
13281 unsigned int i;
13282
13283 for (i = 0; i < ARRAY_SIZE (save_res_funcs); i++)
13284 if (!sfpr_define (info, &save_res_funcs[i], stub_sec))
13285 return FALSE;
13286 }
13287 stub_sec->size += htab->sfpr->size;
13288 }
13289
13290 if (htab->relbrlt != NULL)
13291 htab->relbrlt->reloc_count = 0;
13292
13293 if (htab->params->plt_stub_align != 0)
13294 for (group = htab->group; group != NULL; group = group->next)
13295 if ((stub_sec = group->stub_sec) != NULL)
13296 {
13297 int align = abs (htab->params->plt_stub_align);
13298 stub_sec->size = (stub_sec->size + (1 << align) - 1) & -(1 << align);
13299 }
13300
13301 for (group = htab->group; group != NULL; group = group->next)
13302 if ((stub_sec = group->stub_sec) != NULL)
13303 {
13304 stub_sec_count += 1;
13305 if (stub_sec->rawsize != stub_sec->size
13306 && (htab->stub_iteration <= STUB_SHRINK_ITER
13307 || stub_sec->rawsize < stub_sec->size))
13308 break;
13309 }
13310
13311 if (group != NULL)
13312 {
13313 htab->stub_error = TRUE;
13314 info->callbacks->einfo (_("%P: stubs don't match calculated size\n"));
13315 }
13316
13317 if (htab->stub_error)
13318 return FALSE;
13319
13320 if (stats != NULL)
13321 {
13322 size_t len;
13323 *stats = bfd_malloc (500);
13324 if (*stats == NULL)
13325 return FALSE;
13326
13327 len = sprintf (*stats,
13328 ngettext ("linker stubs in %u group\n",
13329 "linker stubs in %u groups\n",
13330 stub_sec_count),
13331 stub_sec_count);
13332 sprintf (*stats + len, _(" branch %lu\n"
13333 " toc adjust %lu\n"
13334 " long branch %lu\n"
13335 " long toc adj %lu\n"
13336 " plt call %lu\n"
13337 " plt call toc %lu\n"
13338 " global entry %lu"),
13339 htab->stub_count[ppc_stub_long_branch - 1],
13340 htab->stub_count[ppc_stub_long_branch_r2off - 1],
13341 htab->stub_count[ppc_stub_plt_branch - 1],
13342 htab->stub_count[ppc_stub_plt_branch_r2off - 1],
13343 htab->stub_count[ppc_stub_plt_call - 1],
13344 htab->stub_count[ppc_stub_plt_call_r2save - 1],
13345 htab->stub_count[ppc_stub_global_entry - 1]);
13346 }
13347 return TRUE;
13348 }
13349
13350 /* What to do when ld finds relocations against symbols defined in
13351 discarded sections. */
13352
13353 static unsigned int
13354 ppc64_elf_action_discarded (asection *sec)
13355 {
13356 if (strcmp (".opd", sec->name) == 0)
13357 return 0;
13358
13359 if (strcmp (".toc", sec->name) == 0)
13360 return 0;
13361
13362 if (strcmp (".toc1", sec->name) == 0)
13363 return 0;
13364
13365 return _bfd_elf_default_action_discarded (sec);
13366 }
13367
13368 /* The RELOCATE_SECTION function is called by the ELF backend linker
13369 to handle the relocations for a section.
13370
13371 The relocs are always passed as Rela structures; if the section
13372 actually uses Rel structures, the r_addend field will always be
13373 zero.
13374
13375 This function is responsible for adjust the section contents as
13376 necessary, and (if using Rela relocs and generating a
13377 relocatable output file) adjusting the reloc addend as
13378 necessary.
13379
13380 This function does not have to worry about setting the reloc
13381 address or the reloc symbol index.
13382
13383 LOCAL_SYMS is a pointer to the swapped in local symbols.
13384
13385 LOCAL_SECTIONS is an array giving the section in the input file
13386 corresponding to the st_shndx field of each local symbol.
13387
13388 The global hash table entry for the global symbols can be found
13389 via elf_sym_hashes (input_bfd).
13390
13391 When generating relocatable output, this function must handle
13392 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
13393 going to be the section symbol corresponding to the output
13394 section, which means that the addend must be adjusted
13395 accordingly. */
13396
13397 static bfd_boolean
13398 ppc64_elf_relocate_section (bfd *output_bfd,
13399 struct bfd_link_info *info,
13400 bfd *input_bfd,
13401 asection *input_section,
13402 bfd_byte *contents,
13403 Elf_Internal_Rela *relocs,
13404 Elf_Internal_Sym *local_syms,
13405 asection **local_sections)
13406 {
13407 struct ppc_link_hash_table *htab;
13408 Elf_Internal_Shdr *symtab_hdr;
13409 struct elf_link_hash_entry **sym_hashes;
13410 Elf_Internal_Rela *rel;
13411 Elf_Internal_Rela *wrel;
13412 Elf_Internal_Rela *relend;
13413 Elf_Internal_Rela outrel;
13414 bfd_byte *loc;
13415 struct got_entry **local_got_ents;
13416 bfd_vma TOCstart;
13417 bfd_boolean ret = TRUE;
13418 bfd_boolean is_opd;
13419 /* Assume 'at' branch hints. */
13420 bfd_boolean is_isa_v2 = TRUE;
13421 bfd_vma d_offset = (bfd_big_endian (input_bfd) ? 2 : 0);
13422
13423 /* Initialize howto table if needed. */
13424 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
13425 ppc_howto_init ();
13426
13427 htab = ppc_hash_table (info);
13428 if (htab == NULL)
13429 return FALSE;
13430
13431 /* Don't relocate stub sections. */
13432 if (input_section->owner == htab->params->stub_bfd)
13433 return TRUE;
13434
13435 BFD_ASSERT (is_ppc64_elf (input_bfd));
13436
13437 local_got_ents = elf_local_got_ents (input_bfd);
13438 TOCstart = elf_gp (output_bfd);
13439 symtab_hdr = &elf_symtab_hdr (input_bfd);
13440 sym_hashes = elf_sym_hashes (input_bfd);
13441 is_opd = ppc64_elf_section_data (input_section)->sec_type == sec_opd;
13442
13443 rel = wrel = relocs;
13444 relend = relocs + input_section->reloc_count;
13445 for (; rel < relend; wrel++, rel++)
13446 {
13447 enum elf_ppc64_reloc_type r_type;
13448 bfd_vma addend;
13449 bfd_reloc_status_type r;
13450 Elf_Internal_Sym *sym;
13451 asection *sec;
13452 struct elf_link_hash_entry *h_elf;
13453 struct ppc_link_hash_entry *h;
13454 struct ppc_link_hash_entry *fdh;
13455 const char *sym_name;
13456 unsigned long r_symndx, toc_symndx;
13457 bfd_vma toc_addend;
13458 unsigned char tls_mask, tls_gd, tls_type;
13459 unsigned char sym_type;
13460 bfd_vma relocation;
13461 bfd_boolean unresolved_reloc;
13462 bfd_boolean warned;
13463 enum { DEST_NORMAL, DEST_OPD, DEST_STUB } reloc_dest;
13464 unsigned int insn;
13465 unsigned int mask;
13466 struct ppc_stub_hash_entry *stub_entry;
13467 bfd_vma max_br_offset;
13468 bfd_vma from;
13469 Elf_Internal_Rela orig_rel;
13470 reloc_howto_type *howto;
13471 struct reloc_howto_struct alt_howto;
13472
13473 again:
13474 orig_rel = *rel;
13475
13476 r_type = ELF64_R_TYPE (rel->r_info);
13477 r_symndx = ELF64_R_SYM (rel->r_info);
13478
13479 /* For old style R_PPC64_TOC relocs with a zero symbol, use the
13480 symbol of the previous ADDR64 reloc. The symbol gives us the
13481 proper TOC base to use. */
13482 if (rel->r_info == ELF64_R_INFO (0, R_PPC64_TOC)
13483 && wrel != relocs
13484 && ELF64_R_TYPE (wrel[-1].r_info) == R_PPC64_ADDR64
13485 && is_opd)
13486 r_symndx = ELF64_R_SYM (wrel[-1].r_info);
13487
13488 sym = NULL;
13489 sec = NULL;
13490 h_elf = NULL;
13491 sym_name = NULL;
13492 unresolved_reloc = FALSE;
13493 warned = FALSE;
13494
13495 if (r_symndx < symtab_hdr->sh_info)
13496 {
13497 /* It's a local symbol. */
13498 struct _opd_sec_data *opd;
13499
13500 sym = local_syms + r_symndx;
13501 sec = local_sections[r_symndx];
13502 sym_name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym, sec);
13503 sym_type = ELF64_ST_TYPE (sym->st_info);
13504 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
13505 opd = get_opd_info (sec);
13506 if (opd != NULL && opd->adjust != NULL)
13507 {
13508 long adjust = opd->adjust[OPD_NDX (sym->st_value
13509 + rel->r_addend)];
13510 if (adjust == -1)
13511 relocation = 0;
13512 else
13513 {
13514 /* If this is a relocation against the opd section sym
13515 and we have edited .opd, adjust the reloc addend so
13516 that ld -r and ld --emit-relocs output is correct.
13517 If it is a reloc against some other .opd symbol,
13518 then the symbol value will be adjusted later. */
13519 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
13520 rel->r_addend += adjust;
13521 else
13522 relocation += adjust;
13523 }
13524 }
13525 }
13526 else
13527 {
13528 bfd_boolean ignored;
13529
13530 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
13531 r_symndx, symtab_hdr, sym_hashes,
13532 h_elf, sec, relocation,
13533 unresolved_reloc, warned, ignored);
13534 sym_name = h_elf->root.root.string;
13535 sym_type = h_elf->type;
13536 if (sec != NULL
13537 && sec->owner == output_bfd
13538 && strcmp (sec->name, ".opd") == 0)
13539 {
13540 /* This is a symbol defined in a linker script. All
13541 such are defined in output sections, even those
13542 defined by simple assignment from a symbol defined in
13543 an input section. Transfer the symbol to an
13544 appropriate input .opd section, so that a branch to
13545 this symbol will be mapped to the location specified
13546 by the opd entry. */
13547 struct bfd_link_order *lo;
13548 for (lo = sec->map_head.link_order; lo != NULL; lo = lo->next)
13549 if (lo->type == bfd_indirect_link_order)
13550 {
13551 asection *isec = lo->u.indirect.section;
13552 if (h_elf->root.u.def.value >= isec->output_offset
13553 && h_elf->root.u.def.value < (isec->output_offset
13554 + isec->size))
13555 {
13556 h_elf->root.u.def.value -= isec->output_offset;
13557 h_elf->root.u.def.section = isec;
13558 sec = isec;
13559 break;
13560 }
13561 }
13562 }
13563 }
13564 h = (struct ppc_link_hash_entry *) h_elf;
13565
13566 if (sec != NULL && discarded_section (sec))
13567 {
13568 _bfd_clear_contents (ppc64_elf_howto_table[r_type],
13569 input_bfd, input_section,
13570 contents + rel->r_offset);
13571 wrel->r_offset = rel->r_offset;
13572 wrel->r_info = 0;
13573 wrel->r_addend = 0;
13574
13575 /* For ld -r, remove relocations in debug sections against
13576 symbols defined in discarded sections. Not done for
13577 non-debug to preserve relocs in .eh_frame which the
13578 eh_frame editing code expects to be present. */
13579 if (bfd_link_relocatable (info)
13580 && (input_section->flags & SEC_DEBUGGING))
13581 wrel--;
13582
13583 continue;
13584 }
13585
13586 if (bfd_link_relocatable (info))
13587 goto copy_reloc;
13588
13589 if (h != NULL && &h->elf == htab->elf.hgot)
13590 {
13591 relocation = TOCstart + htab->sec_info[input_section->id].toc_off;
13592 sec = bfd_abs_section_ptr;
13593 unresolved_reloc = FALSE;
13594 }
13595
13596 /* TLS optimizations. Replace instruction sequences and relocs
13597 based on information we collected in tls_optimize. We edit
13598 RELOCS so that --emit-relocs will output something sensible
13599 for the final instruction stream. */
13600 tls_mask = 0;
13601 tls_gd = 0;
13602 toc_symndx = 0;
13603 if (h != NULL)
13604 tls_mask = h->tls_mask;
13605 else if (local_got_ents != NULL)
13606 {
13607 struct plt_entry **local_plt = (struct plt_entry **)
13608 (local_got_ents + symtab_hdr->sh_info);
13609 unsigned char *lgot_masks = (unsigned char *)
13610 (local_plt + symtab_hdr->sh_info);
13611 tls_mask = lgot_masks[r_symndx];
13612 }
13613 if (tls_mask == 0
13614 && (r_type == R_PPC64_TLS
13615 || r_type == R_PPC64_TLSGD
13616 || r_type == R_PPC64_TLSLD))
13617 {
13618 /* Check for toc tls entries. */
13619 unsigned char *toc_tls;
13620
13621 if (!get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
13622 &local_syms, rel, input_bfd))
13623 return FALSE;
13624
13625 if (toc_tls)
13626 tls_mask = *toc_tls;
13627 }
13628
13629 /* Check that tls relocs are used with tls syms, and non-tls
13630 relocs are used with non-tls syms. */
13631 if (r_symndx != STN_UNDEF
13632 && r_type != R_PPC64_NONE
13633 && (h == NULL
13634 || h->elf.root.type == bfd_link_hash_defined
13635 || h->elf.root.type == bfd_link_hash_defweak)
13636 && (IS_PPC64_TLS_RELOC (r_type)
13637 != (sym_type == STT_TLS
13638 || (sym_type == STT_SECTION
13639 && (sec->flags & SEC_THREAD_LOCAL) != 0))))
13640 {
13641 if (tls_mask != 0
13642 && (r_type == R_PPC64_TLS
13643 || r_type == R_PPC64_TLSGD
13644 || r_type == R_PPC64_TLSLD))
13645 /* R_PPC64_TLS is OK against a symbol in the TOC. */
13646 ;
13647 else
13648 info->callbacks->einfo
13649 (!IS_PPC64_TLS_RELOC (r_type)
13650 /* xgettext:c-format */
13651 ? _("%H: %s used with TLS symbol `%T'\n")
13652 /* xgettext:c-format */
13653 : _("%H: %s used with non-TLS symbol `%T'\n"),
13654 input_bfd, input_section, rel->r_offset,
13655 ppc64_elf_howto_table[r_type]->name,
13656 sym_name);
13657 }
13658
13659 /* Ensure reloc mapping code below stays sane. */
13660 if (R_PPC64_TOC16_LO_DS != R_PPC64_TOC16_DS + 1
13661 || R_PPC64_TOC16_LO != R_PPC64_TOC16 + 1
13662 || (R_PPC64_GOT_TLSLD16 & 3) != (R_PPC64_GOT_TLSGD16 & 3)
13663 || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TLSGD16_LO & 3)
13664 || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TLSGD16_HI & 3)
13665 || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TLSGD16_HA & 3)
13666 || (R_PPC64_GOT_TLSLD16 & 3) != (R_PPC64_GOT_TPREL16_DS & 3)
13667 || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TPREL16_LO_DS & 3)
13668 || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TPREL16_HI & 3)
13669 || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TPREL16_HA & 3))
13670 abort ();
13671
13672 switch (r_type)
13673 {
13674 default:
13675 break;
13676
13677 case R_PPC64_LO_DS_OPT:
13678 insn = bfd_get_32 (input_bfd, contents + rel->r_offset - d_offset);
13679 if ((insn & (0x3f << 26)) != 58u << 26)
13680 abort ();
13681 insn += (14u << 26) - (58u << 26);
13682 bfd_put_32 (input_bfd, insn, contents + rel->r_offset - d_offset);
13683 r_type = R_PPC64_TOC16_LO;
13684 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13685 break;
13686
13687 case R_PPC64_TOC16:
13688 case R_PPC64_TOC16_LO:
13689 case R_PPC64_TOC16_DS:
13690 case R_PPC64_TOC16_LO_DS:
13691 {
13692 /* Check for toc tls entries. */
13693 unsigned char *toc_tls;
13694 int retval;
13695
13696 retval = get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
13697 &local_syms, rel, input_bfd);
13698 if (retval == 0)
13699 return FALSE;
13700
13701 if (toc_tls)
13702 {
13703 tls_mask = *toc_tls;
13704 if (r_type == R_PPC64_TOC16_DS
13705 || r_type == R_PPC64_TOC16_LO_DS)
13706 {
13707 if (tls_mask != 0
13708 && (tls_mask & (TLS_DTPREL | TLS_TPREL)) == 0)
13709 goto toctprel;
13710 }
13711 else
13712 {
13713 /* If we found a GD reloc pair, then we might be
13714 doing a GD->IE transition. */
13715 if (retval == 2)
13716 {
13717 tls_gd = TLS_TPRELGD;
13718 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13719 goto tls_ldgd_opt;
13720 }
13721 else if (retval == 3)
13722 {
13723 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13724 goto tls_ldgd_opt;
13725 }
13726 }
13727 }
13728 }
13729 break;
13730
13731 case R_PPC64_GOT_TPREL16_HI:
13732 case R_PPC64_GOT_TPREL16_HA:
13733 if (tls_mask != 0
13734 && (tls_mask & TLS_TPREL) == 0)
13735 {
13736 rel->r_offset -= d_offset;
13737 bfd_put_32 (input_bfd, NOP, contents + rel->r_offset);
13738 r_type = R_PPC64_NONE;
13739 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13740 }
13741 break;
13742
13743 case R_PPC64_GOT_TPREL16_DS:
13744 case R_PPC64_GOT_TPREL16_LO_DS:
13745 if (tls_mask != 0
13746 && (tls_mask & TLS_TPREL) == 0)
13747 {
13748 toctprel:
13749 insn = bfd_get_32 (input_bfd,
13750 contents + rel->r_offset - d_offset);
13751 insn &= 31 << 21;
13752 insn |= 0x3c0d0000; /* addis 0,13,0 */
13753 bfd_put_32 (input_bfd, insn,
13754 contents + rel->r_offset - d_offset);
13755 r_type = R_PPC64_TPREL16_HA;
13756 if (toc_symndx != 0)
13757 {
13758 rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
13759 rel->r_addend = toc_addend;
13760 /* We changed the symbol. Start over in order to
13761 get h, sym, sec etc. right. */
13762 goto again;
13763 }
13764 else
13765 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13766 }
13767 break;
13768
13769 case R_PPC64_TLS:
13770 if (tls_mask != 0
13771 && (tls_mask & TLS_TPREL) == 0)
13772 {
13773 insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
13774 insn = _bfd_elf_ppc_at_tls_transform (insn, 13);
13775 if (insn == 0)
13776 abort ();
13777 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
13778 /* Was PPC64_TLS which sits on insn boundary, now
13779 PPC64_TPREL16_LO which is at low-order half-word. */
13780 rel->r_offset += d_offset;
13781 r_type = R_PPC64_TPREL16_LO;
13782 if (toc_symndx != 0)
13783 {
13784 rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
13785 rel->r_addend = toc_addend;
13786 /* We changed the symbol. Start over in order to
13787 get h, sym, sec etc. right. */
13788 goto again;
13789 }
13790 else
13791 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13792 }
13793 break;
13794
13795 case R_PPC64_GOT_TLSGD16_HI:
13796 case R_PPC64_GOT_TLSGD16_HA:
13797 tls_gd = TLS_TPRELGD;
13798 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13799 goto tls_gdld_hi;
13800 break;
13801
13802 case R_PPC64_GOT_TLSLD16_HI:
13803 case R_PPC64_GOT_TLSLD16_HA:
13804 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13805 {
13806 tls_gdld_hi:
13807 if ((tls_mask & tls_gd) != 0)
13808 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
13809 + R_PPC64_GOT_TPREL16_DS);
13810 else
13811 {
13812 rel->r_offset -= d_offset;
13813 bfd_put_32 (input_bfd, NOP, contents + rel->r_offset);
13814 r_type = R_PPC64_NONE;
13815 }
13816 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13817 }
13818 break;
13819
13820 case R_PPC64_GOT_TLSGD16:
13821 case R_PPC64_GOT_TLSGD16_LO:
13822 tls_gd = TLS_TPRELGD;
13823 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13824 goto tls_ldgd_opt;
13825 break;
13826
13827 case R_PPC64_GOT_TLSLD16:
13828 case R_PPC64_GOT_TLSLD16_LO:
13829 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13830 {
13831 unsigned int insn1, insn2;
13832 bfd_vma offset;
13833
13834 tls_ldgd_opt:
13835 offset = (bfd_vma) -1;
13836 /* If not using the newer R_PPC64_TLSGD/LD to mark
13837 __tls_get_addr calls, we must trust that the call
13838 stays with its arg setup insns, ie. that the next
13839 reloc is the __tls_get_addr call associated with
13840 the current reloc. Edit both insns. */
13841 if (input_section->has_tls_get_addr_call
13842 && rel + 1 < relend
13843 && branch_reloc_hash_match (input_bfd, rel + 1,
13844 htab->tls_get_addr,
13845 htab->tls_get_addr_fd))
13846 offset = rel[1].r_offset;
13847 /* We read the low GOT_TLS (or TOC16) insn because we
13848 need to keep the destination reg. It may be
13849 something other than the usual r3, and moved to r3
13850 before the call by intervening code. */
13851 insn1 = bfd_get_32 (input_bfd,
13852 contents + rel->r_offset - d_offset);
13853 if ((tls_mask & tls_gd) != 0)
13854 {
13855 /* IE */
13856 insn1 &= (0x1f << 21) | (0x1f << 16);
13857 insn1 |= 58 << 26; /* ld */
13858 insn2 = 0x7c636a14; /* add 3,3,13 */
13859 if (offset != (bfd_vma) -1)
13860 rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13861 if ((tls_mask & TLS_EXPLICIT) == 0)
13862 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
13863 + R_PPC64_GOT_TPREL16_DS);
13864 else
13865 r_type += R_PPC64_TOC16_DS - R_PPC64_TOC16;
13866 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13867 }
13868 else
13869 {
13870 /* LE */
13871 insn1 &= 0x1f << 21;
13872 insn1 |= 0x3c0d0000; /* addis r,13,0 */
13873 insn2 = 0x38630000; /* addi 3,3,0 */
13874 if (tls_gd == 0)
13875 {
13876 /* Was an LD reloc. */
13877 if (toc_symndx)
13878 sec = local_sections[toc_symndx];
13879 for (r_symndx = 0;
13880 r_symndx < symtab_hdr->sh_info;
13881 r_symndx++)
13882 if (local_sections[r_symndx] == sec)
13883 break;
13884 if (r_symndx >= symtab_hdr->sh_info)
13885 r_symndx = STN_UNDEF;
13886 rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
13887 if (r_symndx != STN_UNDEF)
13888 rel->r_addend -= (local_syms[r_symndx].st_value
13889 + sec->output_offset
13890 + sec->output_section->vma);
13891 }
13892 else if (toc_symndx != 0)
13893 {
13894 r_symndx = toc_symndx;
13895 rel->r_addend = toc_addend;
13896 }
13897 r_type = R_PPC64_TPREL16_HA;
13898 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13899 if (offset != (bfd_vma) -1)
13900 {
13901 rel[1].r_info = ELF64_R_INFO (r_symndx,
13902 R_PPC64_TPREL16_LO);
13903 rel[1].r_offset = offset + d_offset;
13904 rel[1].r_addend = rel->r_addend;
13905 }
13906 }
13907 bfd_put_32 (input_bfd, insn1,
13908 contents + rel->r_offset - d_offset);
13909 if (offset != (bfd_vma) -1)
13910 bfd_put_32 (input_bfd, insn2, contents + offset);
13911 if ((tls_mask & tls_gd) == 0
13912 && (tls_gd == 0 || toc_symndx != 0))
13913 {
13914 /* We changed the symbol. Start over in order
13915 to get h, sym, sec etc. right. */
13916 goto again;
13917 }
13918 }
13919 break;
13920
13921 case R_PPC64_TLSGD:
13922 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13923 {
13924 unsigned int insn2;
13925 bfd_vma offset = rel->r_offset;
13926
13927 if ((tls_mask & TLS_TPRELGD) != 0)
13928 {
13929 /* IE */
13930 r_type = R_PPC64_NONE;
13931 insn2 = 0x7c636a14; /* add 3,3,13 */
13932 }
13933 else
13934 {
13935 /* LE */
13936 if (toc_symndx != 0)
13937 {
13938 r_symndx = toc_symndx;
13939 rel->r_addend = toc_addend;
13940 }
13941 r_type = R_PPC64_TPREL16_LO;
13942 rel->r_offset = offset + d_offset;
13943 insn2 = 0x38630000; /* addi 3,3,0 */
13944 }
13945 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13946 /* Zap the reloc on the _tls_get_addr call too. */
13947 BFD_ASSERT (offset == rel[1].r_offset);
13948 rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13949 bfd_put_32 (input_bfd, insn2, contents + offset);
13950 if ((tls_mask & TLS_TPRELGD) == 0 && toc_symndx != 0)
13951 goto again;
13952 }
13953 break;
13954
13955 case R_PPC64_TLSLD:
13956 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13957 {
13958 unsigned int insn2;
13959 bfd_vma offset = rel->r_offset;
13960
13961 if (toc_symndx)
13962 sec = local_sections[toc_symndx];
13963 for (r_symndx = 0;
13964 r_symndx < symtab_hdr->sh_info;
13965 r_symndx++)
13966 if (local_sections[r_symndx] == sec)
13967 break;
13968 if (r_symndx >= symtab_hdr->sh_info)
13969 r_symndx = STN_UNDEF;
13970 rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
13971 if (r_symndx != STN_UNDEF)
13972 rel->r_addend -= (local_syms[r_symndx].st_value
13973 + sec->output_offset
13974 + sec->output_section->vma);
13975
13976 r_type = R_PPC64_TPREL16_LO;
13977 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13978 rel->r_offset = offset + d_offset;
13979 /* Zap the reloc on the _tls_get_addr call too. */
13980 BFD_ASSERT (offset == rel[1].r_offset);
13981 rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13982 insn2 = 0x38630000; /* addi 3,3,0 */
13983 bfd_put_32 (input_bfd, insn2, contents + offset);
13984 goto again;
13985 }
13986 break;
13987
13988 case R_PPC64_DTPMOD64:
13989 if (rel + 1 < relend
13990 && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
13991 && rel[1].r_offset == rel->r_offset + 8)
13992 {
13993 if ((tls_mask & TLS_GD) == 0)
13994 {
13995 rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_NONE);
13996 if ((tls_mask & TLS_TPRELGD) != 0)
13997 r_type = R_PPC64_TPREL64;
13998 else
13999 {
14000 bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
14001 r_type = R_PPC64_NONE;
14002 }
14003 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14004 }
14005 }
14006 else
14007 {
14008 if ((tls_mask & TLS_LD) == 0)
14009 {
14010 bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
14011 r_type = R_PPC64_NONE;
14012 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14013 }
14014 }
14015 break;
14016
14017 case R_PPC64_TPREL64:
14018 if ((tls_mask & TLS_TPREL) == 0)
14019 {
14020 r_type = R_PPC64_NONE;
14021 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14022 }
14023 break;
14024
14025 case R_PPC64_ENTRY:
14026 relocation = TOCstart + htab->sec_info[input_section->id].toc_off;
14027 if (!bfd_link_pic (info)
14028 && !info->traditional_format
14029 && relocation + 0x80008000 <= 0xffffffff)
14030 {
14031 unsigned int insn1, insn2;
14032
14033 insn1 = bfd_get_32 (input_bfd, contents + rel->r_offset);
14034 insn2 = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
14035 if ((insn1 & ~0xfffc) == LD_R2_0R12
14036 && insn2 == ADD_R2_R2_R12)
14037 {
14038 bfd_put_32 (input_bfd,
14039 LIS_R2 + PPC_HA (relocation),
14040 contents + rel->r_offset);
14041 bfd_put_32 (input_bfd,
14042 ADDI_R2_R2 + PPC_LO (relocation),
14043 contents + rel->r_offset + 4);
14044 }
14045 }
14046 else
14047 {
14048 relocation -= (rel->r_offset
14049 + input_section->output_offset
14050 + input_section->output_section->vma);
14051 if (relocation + 0x80008000 <= 0xffffffff)
14052 {
14053 unsigned int insn1, insn2;
14054
14055 insn1 = bfd_get_32 (input_bfd, contents + rel->r_offset);
14056 insn2 = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
14057 if ((insn1 & ~0xfffc) == LD_R2_0R12
14058 && insn2 == ADD_R2_R2_R12)
14059 {
14060 bfd_put_32 (input_bfd,
14061 ADDIS_R2_R12 + PPC_HA (relocation),
14062 contents + rel->r_offset);
14063 bfd_put_32 (input_bfd,
14064 ADDI_R2_R2 + PPC_LO (relocation),
14065 contents + rel->r_offset + 4);
14066 }
14067 }
14068 }
14069 break;
14070
14071 case R_PPC64_REL16_HA:
14072 /* If we are generating a non-PIC executable, edit
14073 . 0: addis 2,12,.TOC.-0b@ha
14074 . addi 2,2,.TOC.-0b@l
14075 used by ELFv2 global entry points to set up r2, to
14076 . lis 2,.TOC.@ha
14077 . addi 2,2,.TOC.@l
14078 if .TOC. is in range. */
14079 if (!bfd_link_pic (info)
14080 && !info->traditional_format
14081 && !htab->opd_abi
14082 && rel->r_addend == d_offset
14083 && h != NULL && &h->elf == htab->elf.hgot
14084 && rel + 1 < relend
14085 && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_REL16_LO)
14086 && rel[1].r_offset == rel->r_offset + 4
14087 && rel[1].r_addend == rel->r_addend + 4
14088 && relocation + 0x80008000 <= 0xffffffff)
14089 {
14090 unsigned int insn1, insn2;
14091 bfd_vma offset = rel->r_offset - d_offset;
14092 insn1 = bfd_get_32 (input_bfd, contents + offset);
14093 insn2 = bfd_get_32 (input_bfd, contents + offset + 4);
14094 if ((insn1 & 0xffff0000) == ADDIS_R2_R12
14095 && (insn2 & 0xffff0000) == ADDI_R2_R2)
14096 {
14097 r_type = R_PPC64_ADDR16_HA;
14098 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14099 rel->r_addend -= d_offset;
14100 rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_ADDR16_LO);
14101 rel[1].r_addend -= d_offset + 4;
14102 bfd_put_32 (input_bfd, LIS_R2, contents + offset);
14103 }
14104 }
14105 break;
14106 }
14107
14108 /* Handle other relocations that tweak non-addend part of insn. */
14109 insn = 0;
14110 max_br_offset = 1 << 25;
14111 addend = rel->r_addend;
14112 reloc_dest = DEST_NORMAL;
14113 switch (r_type)
14114 {
14115 default:
14116 break;
14117
14118 case R_PPC64_TOCSAVE:
14119 if (relocation + addend == (rel->r_offset
14120 + input_section->output_offset
14121 + input_section->output_section->vma)
14122 && tocsave_find (htab, NO_INSERT,
14123 &local_syms, rel, input_bfd))
14124 {
14125 insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
14126 if (insn == NOP
14127 || insn == CROR_151515 || insn == CROR_313131)
14128 bfd_put_32 (input_bfd,
14129 STD_R2_0R1 + STK_TOC (htab),
14130 contents + rel->r_offset);
14131 }
14132 break;
14133
14134 /* Branch taken prediction relocations. */
14135 case R_PPC64_ADDR14_BRTAKEN:
14136 case R_PPC64_REL14_BRTAKEN:
14137 insn = 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field. */
14138 /* Fall through. */
14139
14140 /* Branch not taken prediction relocations. */
14141 case R_PPC64_ADDR14_BRNTAKEN:
14142 case R_PPC64_REL14_BRNTAKEN:
14143 insn |= bfd_get_32 (input_bfd,
14144 contents + rel->r_offset) & ~(0x01 << 21);
14145 /* Fall through. */
14146
14147 case R_PPC64_REL14:
14148 max_br_offset = 1 << 15;
14149 /* Fall through. */
14150
14151 case R_PPC64_REL24:
14152 /* Calls to functions with a different TOC, such as calls to
14153 shared objects, need to alter the TOC pointer. This is
14154 done using a linkage stub. A REL24 branching to these
14155 linkage stubs needs to be followed by a nop, as the nop
14156 will be replaced with an instruction to restore the TOC
14157 base pointer. */
14158 fdh = h;
14159 if (h != NULL
14160 && h->oh != NULL
14161 && h->oh->is_func_descriptor)
14162 fdh = ppc_follow_link (h->oh);
14163 stub_entry = ppc_get_stub_entry (input_section, sec, fdh, &orig_rel,
14164 htab);
14165 if (stub_entry != NULL
14166 && (stub_entry->stub_type == ppc_stub_plt_call
14167 || stub_entry->stub_type == ppc_stub_plt_call_r2save
14168 || stub_entry->stub_type == ppc_stub_plt_branch_r2off
14169 || stub_entry->stub_type == ppc_stub_long_branch_r2off))
14170 {
14171 bfd_boolean can_plt_call = FALSE;
14172
14173 if (stub_entry->stub_type == ppc_stub_plt_call
14174 && !htab->opd_abi
14175 && htab->params->plt_localentry0 != 0
14176 && is_elfv2_localentry0 (&h->elf))
14177 {
14178 /* The function doesn't use or change r2. */
14179 can_plt_call = TRUE;
14180 }
14181
14182 /* All of these stubs may modify r2, so there must be a
14183 branch and link followed by a nop. The nop is
14184 replaced by an insn to restore r2. */
14185 else if (rel->r_offset + 8 <= input_section->size)
14186 {
14187 unsigned long br;
14188
14189 br = bfd_get_32 (input_bfd,
14190 contents + rel->r_offset);
14191 if ((br & 1) != 0)
14192 {
14193 unsigned long nop;
14194
14195 nop = bfd_get_32 (input_bfd,
14196 contents + rel->r_offset + 4);
14197 if (nop == NOP
14198 || nop == CROR_151515 || nop == CROR_313131)
14199 {
14200 if (h != NULL
14201 && (h == htab->tls_get_addr_fd
14202 || h == htab->tls_get_addr)
14203 && htab->params->tls_get_addr_opt)
14204 {
14205 /* Special stub used, leave nop alone. */
14206 }
14207 else
14208 bfd_put_32 (input_bfd,
14209 LD_R2_0R1 + STK_TOC (htab),
14210 contents + rel->r_offset + 4);
14211 can_plt_call = TRUE;
14212 }
14213 }
14214 }
14215
14216 if (!can_plt_call && h != NULL)
14217 {
14218 const char *name = h->elf.root.root.string;
14219
14220 if (*name == '.')
14221 ++name;
14222
14223 if (strncmp (name, "__libc_start_main", 17) == 0
14224 && (name[17] == 0 || name[17] == '@'))
14225 {
14226 /* Allow crt1 branch to go via a toc adjusting
14227 stub. Other calls that never return could do
14228 the same, if we could detect such. */
14229 can_plt_call = TRUE;
14230 }
14231 }
14232
14233 if (!can_plt_call)
14234 {
14235 /* g++ as of 20130507 emits self-calls without a
14236 following nop. This is arguably wrong since we
14237 have conflicting information. On the one hand a
14238 global symbol and on the other a local call
14239 sequence, but don't error for this special case.
14240 It isn't possible to cheaply verify we have
14241 exactly such a call. Allow all calls to the same
14242 section. */
14243 asection *code_sec = sec;
14244
14245 if (get_opd_info (sec) != NULL)
14246 {
14247 bfd_vma off = (relocation + addend
14248 - sec->output_section->vma
14249 - sec->output_offset);
14250
14251 opd_entry_value (sec, off, &code_sec, NULL, FALSE);
14252 }
14253 if (code_sec == input_section)
14254 can_plt_call = TRUE;
14255 }
14256
14257 if (!can_plt_call)
14258 {
14259 if (stub_entry->stub_type == ppc_stub_plt_call
14260 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
14261 info->callbacks->einfo
14262 /* xgettext:c-format */
14263 (_("%H: call to `%T' lacks nop, can't restore toc; "
14264 "recompile with -fPIC\n"),
14265 input_bfd, input_section, rel->r_offset, sym_name);
14266 else
14267 info->callbacks->einfo
14268 /* xgettext:c-format */
14269 (_("%H: call to `%T' lacks nop, can't restore toc; "
14270 "(-mcmodel=small toc adjust stub)\n"),
14271 input_bfd, input_section, rel->r_offset, sym_name);
14272
14273 bfd_set_error (bfd_error_bad_value);
14274 ret = FALSE;
14275 }
14276
14277 if (can_plt_call
14278 && (stub_entry->stub_type == ppc_stub_plt_call
14279 || stub_entry->stub_type == ppc_stub_plt_call_r2save))
14280 unresolved_reloc = FALSE;
14281 }
14282
14283 if ((stub_entry == NULL
14284 || stub_entry->stub_type == ppc_stub_long_branch
14285 || stub_entry->stub_type == ppc_stub_plt_branch)
14286 && get_opd_info (sec) != NULL)
14287 {
14288 /* The branch destination is the value of the opd entry. */
14289 bfd_vma off = (relocation + addend
14290 - sec->output_section->vma
14291 - sec->output_offset);
14292 bfd_vma dest = opd_entry_value (sec, off, NULL, NULL, FALSE);
14293 if (dest != (bfd_vma) -1)
14294 {
14295 relocation = dest;
14296 addend = 0;
14297 reloc_dest = DEST_OPD;
14298 }
14299 }
14300
14301 /* If the branch is out of reach we ought to have a long
14302 branch stub. */
14303 from = (rel->r_offset
14304 + input_section->output_offset
14305 + input_section->output_section->vma);
14306
14307 relocation += PPC64_LOCAL_ENTRY_OFFSET (fdh
14308 ? fdh->elf.other
14309 : sym->st_other);
14310
14311 if (stub_entry != NULL
14312 && (stub_entry->stub_type == ppc_stub_long_branch
14313 || stub_entry->stub_type == ppc_stub_plt_branch)
14314 && (r_type == R_PPC64_ADDR14_BRTAKEN
14315 || r_type == R_PPC64_ADDR14_BRNTAKEN
14316 || (relocation + addend - from + max_br_offset
14317 < 2 * max_br_offset)))
14318 /* Don't use the stub if this branch is in range. */
14319 stub_entry = NULL;
14320
14321 if (stub_entry != NULL)
14322 {
14323 /* Munge up the value and addend so that we call the stub
14324 rather than the procedure directly. */
14325 asection *stub_sec = stub_entry->group->stub_sec;
14326
14327 if (stub_entry->stub_type == ppc_stub_save_res)
14328 relocation += (stub_sec->output_offset
14329 + stub_sec->output_section->vma
14330 + stub_sec->size - htab->sfpr->size
14331 - htab->sfpr->output_offset
14332 - htab->sfpr->output_section->vma);
14333 else
14334 relocation = (stub_entry->stub_offset
14335 + stub_sec->output_offset
14336 + stub_sec->output_section->vma);
14337 addend = 0;
14338 reloc_dest = DEST_STUB;
14339
14340 if ((stub_entry->stub_type == ppc_stub_plt_call
14341 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
14342 && (ALWAYS_EMIT_R2SAVE
14343 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
14344 && rel + 1 < relend
14345 && rel[1].r_offset == rel->r_offset + 4
14346 && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOCSAVE)
14347 relocation += 4;
14348 }
14349
14350 if (insn != 0)
14351 {
14352 if (is_isa_v2)
14353 {
14354 /* Set 'a' bit. This is 0b00010 in BO field for branch
14355 on CR(BI) insns (BO == 001at or 011at), and 0b01000
14356 for branch on CTR insns (BO == 1a00t or 1a01t). */
14357 if ((insn & (0x14 << 21)) == (0x04 << 21))
14358 insn |= 0x02 << 21;
14359 else if ((insn & (0x14 << 21)) == (0x10 << 21))
14360 insn |= 0x08 << 21;
14361 else
14362 break;
14363 }
14364 else
14365 {
14366 /* Invert 'y' bit if not the default. */
14367 if ((bfd_signed_vma) (relocation + addend - from) < 0)
14368 insn ^= 0x01 << 21;
14369 }
14370
14371 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
14372 }
14373
14374 /* NOP out calls to undefined weak functions.
14375 We can thus call a weak function without first
14376 checking whether the function is defined. */
14377 else if (h != NULL
14378 && h->elf.root.type == bfd_link_hash_undefweak
14379 && h->elf.dynindx == -1
14380 && r_type == R_PPC64_REL24
14381 && relocation == 0
14382 && addend == 0)
14383 {
14384 bfd_put_32 (input_bfd, NOP, contents + rel->r_offset);
14385 goto copy_reloc;
14386 }
14387 break;
14388 }
14389
14390 /* Set `addend'. */
14391 tls_type = 0;
14392 switch (r_type)
14393 {
14394 default:
14395 info->callbacks->einfo
14396 /* xgettext:c-format */
14397 (_("%P: %B: unknown relocation type %d for `%T'\n"),
14398 input_bfd, (int) r_type, sym_name);
14399
14400 bfd_set_error (bfd_error_bad_value);
14401 ret = FALSE;
14402 goto copy_reloc;
14403
14404 case R_PPC64_NONE:
14405 case R_PPC64_TLS:
14406 case R_PPC64_TLSGD:
14407 case R_PPC64_TLSLD:
14408 case R_PPC64_TOCSAVE:
14409 case R_PPC64_GNU_VTINHERIT:
14410 case R_PPC64_GNU_VTENTRY:
14411 case R_PPC64_ENTRY:
14412 goto copy_reloc;
14413
14414 /* GOT16 relocations. Like an ADDR16 using the symbol's
14415 address in the GOT as relocation value instead of the
14416 symbol's value itself. Also, create a GOT entry for the
14417 symbol and put the symbol value there. */
14418 case R_PPC64_GOT_TLSGD16:
14419 case R_PPC64_GOT_TLSGD16_LO:
14420 case R_PPC64_GOT_TLSGD16_HI:
14421 case R_PPC64_GOT_TLSGD16_HA:
14422 tls_type = TLS_TLS | TLS_GD;
14423 goto dogot;
14424
14425 case R_PPC64_GOT_TLSLD16:
14426 case R_PPC64_GOT_TLSLD16_LO:
14427 case R_PPC64_GOT_TLSLD16_HI:
14428 case R_PPC64_GOT_TLSLD16_HA:
14429 tls_type = TLS_TLS | TLS_LD;
14430 goto dogot;
14431
14432 case R_PPC64_GOT_TPREL16_DS:
14433 case R_PPC64_GOT_TPREL16_LO_DS:
14434 case R_PPC64_GOT_TPREL16_HI:
14435 case R_PPC64_GOT_TPREL16_HA:
14436 tls_type = TLS_TLS | TLS_TPREL;
14437 goto dogot;
14438
14439 case R_PPC64_GOT_DTPREL16_DS:
14440 case R_PPC64_GOT_DTPREL16_LO_DS:
14441 case R_PPC64_GOT_DTPREL16_HI:
14442 case R_PPC64_GOT_DTPREL16_HA:
14443 tls_type = TLS_TLS | TLS_DTPREL;
14444 goto dogot;
14445
14446 case R_PPC64_GOT16:
14447 case R_PPC64_GOT16_LO:
14448 case R_PPC64_GOT16_HI:
14449 case R_PPC64_GOT16_HA:
14450 case R_PPC64_GOT16_DS:
14451 case R_PPC64_GOT16_LO_DS:
14452 dogot:
14453 {
14454 /* Relocation is to the entry for this symbol in the global
14455 offset table. */
14456 asection *got;
14457 bfd_vma *offp;
14458 bfd_vma off;
14459 unsigned long indx = 0;
14460 struct got_entry *ent;
14461
14462 if (tls_type == (TLS_TLS | TLS_LD)
14463 && (h == NULL
14464 || !h->elf.def_dynamic))
14465 ent = ppc64_tlsld_got (input_bfd);
14466 else
14467 {
14468 if (h != NULL)
14469 {
14470 if (!htab->elf.dynamic_sections_created
14471 || h->elf.dynindx == -1
14472 || SYMBOL_REFERENCES_LOCAL (info, &h->elf)
14473 || UNDEFWEAK_NO_DYNAMIC_RELOC (info, &h->elf))
14474 /* This is actually a static link, or it is a
14475 -Bsymbolic link and the symbol is defined
14476 locally, or the symbol was forced to be local
14477 because of a version file. */
14478 ;
14479 else
14480 {
14481 indx = h->elf.dynindx;
14482 unresolved_reloc = FALSE;
14483 }
14484 ent = h->elf.got.glist;
14485 }
14486 else
14487 {
14488 if (local_got_ents == NULL)
14489 abort ();
14490 ent = local_got_ents[r_symndx];
14491 }
14492
14493 for (; ent != NULL; ent = ent->next)
14494 if (ent->addend == orig_rel.r_addend
14495 && ent->owner == input_bfd
14496 && ent->tls_type == tls_type)
14497 break;
14498 }
14499
14500 if (ent == NULL)
14501 abort ();
14502 if (ent->is_indirect)
14503 ent = ent->got.ent;
14504 offp = &ent->got.offset;
14505 got = ppc64_elf_tdata (ent->owner)->got;
14506 if (got == NULL)
14507 abort ();
14508
14509 /* The offset must always be a multiple of 8. We use the
14510 least significant bit to record whether we have already
14511 processed this entry. */
14512 off = *offp;
14513 if ((off & 1) != 0)
14514 off &= ~1;
14515 else
14516 {
14517 /* Generate relocs for the dynamic linker, except in
14518 the case of TLSLD where we'll use one entry per
14519 module. */
14520 asection *relgot;
14521 bfd_boolean ifunc;
14522
14523 *offp = off | 1;
14524 relgot = NULL;
14525 ifunc = (h != NULL
14526 ? h->elf.type == STT_GNU_IFUNC
14527 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC);
14528 if (ifunc)
14529 {
14530 relgot = htab->elf.irelplt;
14531 if (indx == 0)
14532 htab->local_ifunc_resolver = 1;
14533 else if (is_static_defined (&h->elf))
14534 htab->maybe_local_ifunc_resolver = 1;
14535 }
14536 else if (indx != 0
14537 || (bfd_link_pic (info)
14538 && (h == NULL
14539 || !UNDEFWEAK_NO_DYNAMIC_RELOC (info, &h->elf)
14540 || (tls_type == (TLS_TLS | TLS_LD)
14541 && !h->elf.def_dynamic))
14542 && !(tls_type == (TLS_TLS | TLS_TPREL)
14543 && bfd_link_executable (info)
14544 && SYMBOL_REFERENCES_LOCAL (info, &h->elf))))
14545 relgot = ppc64_elf_tdata (ent->owner)->relgot;
14546 if (relgot != NULL)
14547 {
14548 outrel.r_offset = (got->output_section->vma
14549 + got->output_offset
14550 + off);
14551 outrel.r_addend = addend;
14552 if (tls_type & (TLS_LD | TLS_GD))
14553 {
14554 outrel.r_addend = 0;
14555 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPMOD64);
14556 if (tls_type == (TLS_TLS | TLS_GD))
14557 {
14558 loc = relgot->contents;
14559 loc += (relgot->reloc_count++
14560 * sizeof (Elf64_External_Rela));
14561 bfd_elf64_swap_reloca_out (output_bfd,
14562 &outrel, loc);
14563 outrel.r_offset += 8;
14564 outrel.r_addend = addend;
14565 outrel.r_info
14566 = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
14567 }
14568 }
14569 else if (tls_type == (TLS_TLS | TLS_DTPREL))
14570 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
14571 else if (tls_type == (TLS_TLS | TLS_TPREL))
14572 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_TPREL64);
14573 else if (indx != 0)
14574 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_GLOB_DAT);
14575 else
14576 {
14577 if (ifunc)
14578 outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
14579 else
14580 outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
14581
14582 /* Write the .got section contents for the sake
14583 of prelink. */
14584 loc = got->contents + off;
14585 bfd_put_64 (output_bfd, outrel.r_addend + relocation,
14586 loc);
14587 }
14588
14589 if (indx == 0 && tls_type != (TLS_TLS | TLS_LD))
14590 {
14591 outrel.r_addend += relocation;
14592 if (tls_type & (TLS_GD | TLS_DTPREL | TLS_TPREL))
14593 {
14594 if (htab->elf.tls_sec == NULL)
14595 outrel.r_addend = 0;
14596 else
14597 outrel.r_addend -= htab->elf.tls_sec->vma;
14598 }
14599 }
14600 loc = relgot->contents;
14601 loc += (relgot->reloc_count++
14602 * sizeof (Elf64_External_Rela));
14603 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
14604 }
14605
14606 /* Init the .got section contents here if we're not
14607 emitting a reloc. */
14608 else
14609 {
14610 relocation += addend;
14611 if (tls_type != 0)
14612 {
14613 if (htab->elf.tls_sec == NULL)
14614 relocation = 0;
14615 else
14616 {
14617 if (tls_type & TLS_LD)
14618 relocation = 0;
14619 else
14620 relocation -= htab->elf.tls_sec->vma + DTP_OFFSET;
14621 if (tls_type & TLS_TPREL)
14622 relocation += DTP_OFFSET - TP_OFFSET;
14623 }
14624
14625 if (tls_type & (TLS_GD | TLS_LD))
14626 {
14627 bfd_put_64 (output_bfd, relocation,
14628 got->contents + off + 8);
14629 relocation = 1;
14630 }
14631 }
14632 bfd_put_64 (output_bfd, relocation,
14633 got->contents + off);
14634 }
14635 }
14636
14637 if (off >= (bfd_vma) -2)
14638 abort ();
14639
14640 relocation = got->output_section->vma + got->output_offset + off;
14641 addend = -(TOCstart + htab->sec_info[input_section->id].toc_off);
14642 }
14643 break;
14644
14645 case R_PPC64_PLT16_HA:
14646 case R_PPC64_PLT16_HI:
14647 case R_PPC64_PLT16_LO:
14648 case R_PPC64_PLT32:
14649 case R_PPC64_PLT64:
14650 /* Relocation is to the entry for this symbol in the
14651 procedure linkage table. */
14652 {
14653 struct plt_entry **plt_list = NULL;
14654 if (h != NULL)
14655 plt_list = &h->elf.plt.plist;
14656 else if (local_got_ents != NULL)
14657 {
14658 struct plt_entry **local_plt = (struct plt_entry **)
14659 (local_got_ents + symtab_hdr->sh_info);
14660 unsigned char *local_got_tls_masks = (unsigned char *)
14661 (local_plt + symtab_hdr->sh_info);
14662 if ((local_got_tls_masks[r_symndx] & PLT_IFUNC) != 0)
14663 plt_list = local_plt + r_symndx;
14664 }
14665 if (plt_list)
14666 {
14667 struct plt_entry *ent;
14668
14669 for (ent = *plt_list; ent != NULL; ent = ent->next)
14670 if (ent->plt.offset != (bfd_vma) -1
14671 && ent->addend == orig_rel.r_addend)
14672 {
14673 asection *plt;
14674
14675 plt = htab->elf.splt;
14676 if (!htab->elf.dynamic_sections_created
14677 || h == NULL
14678 || h->elf.dynindx == -1)
14679 plt = htab->elf.iplt;
14680 relocation = (plt->output_section->vma
14681 + plt->output_offset
14682 + ent->plt.offset);
14683 addend = 0;
14684 unresolved_reloc = FALSE;
14685 break;
14686 }
14687 }
14688 }
14689 break;
14690
14691 case R_PPC64_TOC:
14692 /* Relocation value is TOC base. */
14693 relocation = TOCstart;
14694 if (r_symndx == STN_UNDEF)
14695 relocation += htab->sec_info[input_section->id].toc_off;
14696 else if (unresolved_reloc)
14697 ;
14698 else if (sec != NULL && sec->id < htab->sec_info_arr_size)
14699 relocation += htab->sec_info[sec->id].toc_off;
14700 else
14701 unresolved_reloc = TRUE;
14702 goto dodyn;
14703
14704 /* TOC16 relocs. We want the offset relative to the TOC base,
14705 which is the address of the start of the TOC plus 0x8000.
14706 The TOC consists of sections .got, .toc, .tocbss, and .plt,
14707 in this order. */
14708 case R_PPC64_TOC16:
14709 case R_PPC64_TOC16_LO:
14710 case R_PPC64_TOC16_HI:
14711 case R_PPC64_TOC16_DS:
14712 case R_PPC64_TOC16_LO_DS:
14713 case R_PPC64_TOC16_HA:
14714 addend -= TOCstart + htab->sec_info[input_section->id].toc_off;
14715 break;
14716
14717 /* Relocate against the beginning of the section. */
14718 case R_PPC64_SECTOFF:
14719 case R_PPC64_SECTOFF_LO:
14720 case R_PPC64_SECTOFF_HI:
14721 case R_PPC64_SECTOFF_DS:
14722 case R_PPC64_SECTOFF_LO_DS:
14723 case R_PPC64_SECTOFF_HA:
14724 if (sec != NULL)
14725 addend -= sec->output_section->vma;
14726 break;
14727
14728 case R_PPC64_REL16:
14729 case R_PPC64_REL16_LO:
14730 case R_PPC64_REL16_HI:
14731 case R_PPC64_REL16_HA:
14732 case R_PPC64_REL16DX_HA:
14733 break;
14734
14735 case R_PPC64_REL14:
14736 case R_PPC64_REL14_BRNTAKEN:
14737 case R_PPC64_REL14_BRTAKEN:
14738 case R_PPC64_REL24:
14739 break;
14740
14741 case R_PPC64_TPREL16:
14742 case R_PPC64_TPREL16_LO:
14743 case R_PPC64_TPREL16_HI:
14744 case R_PPC64_TPREL16_HA:
14745 case R_PPC64_TPREL16_DS:
14746 case R_PPC64_TPREL16_LO_DS:
14747 case R_PPC64_TPREL16_HIGH:
14748 case R_PPC64_TPREL16_HIGHA:
14749 case R_PPC64_TPREL16_HIGHER:
14750 case R_PPC64_TPREL16_HIGHERA:
14751 case R_PPC64_TPREL16_HIGHEST:
14752 case R_PPC64_TPREL16_HIGHESTA:
14753 if (h != NULL
14754 && h->elf.root.type == bfd_link_hash_undefweak
14755 && h->elf.dynindx == -1)
14756 {
14757 /* Make this relocation against an undefined weak symbol
14758 resolve to zero. This is really just a tweak, since
14759 code using weak externs ought to check that they are
14760 defined before using them. */
14761 bfd_byte *p = contents + rel->r_offset - d_offset;
14762
14763 insn = bfd_get_32 (input_bfd, p);
14764 insn = _bfd_elf_ppc_at_tprel_transform (insn, 13);
14765 if (insn != 0)
14766 bfd_put_32 (input_bfd, insn, p);
14767 break;
14768 }
14769 if (htab->elf.tls_sec != NULL)
14770 addend -= htab->elf.tls_sec->vma + TP_OFFSET;
14771 /* The TPREL16 relocs shouldn't really be used in shared
14772 libs or with non-local symbols as that will result in
14773 DT_TEXTREL being set, but support them anyway. */
14774 goto dodyn;
14775
14776 case R_PPC64_DTPREL16:
14777 case R_PPC64_DTPREL16_LO:
14778 case R_PPC64_DTPREL16_HI:
14779 case R_PPC64_DTPREL16_HA:
14780 case R_PPC64_DTPREL16_DS:
14781 case R_PPC64_DTPREL16_LO_DS:
14782 case R_PPC64_DTPREL16_HIGH:
14783 case R_PPC64_DTPREL16_HIGHA:
14784 case R_PPC64_DTPREL16_HIGHER:
14785 case R_PPC64_DTPREL16_HIGHERA:
14786 case R_PPC64_DTPREL16_HIGHEST:
14787 case R_PPC64_DTPREL16_HIGHESTA:
14788 if (htab->elf.tls_sec != NULL)
14789 addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
14790 break;
14791
14792 case R_PPC64_ADDR64_LOCAL:
14793 addend += PPC64_LOCAL_ENTRY_OFFSET (h != NULL
14794 ? h->elf.other
14795 : sym->st_other);
14796 break;
14797
14798 case R_PPC64_DTPMOD64:
14799 relocation = 1;
14800 addend = 0;
14801 goto dodyn;
14802
14803 case R_PPC64_TPREL64:
14804 if (htab->elf.tls_sec != NULL)
14805 addend -= htab->elf.tls_sec->vma + TP_OFFSET;
14806 goto dodyn;
14807
14808 case R_PPC64_DTPREL64:
14809 if (htab->elf.tls_sec != NULL)
14810 addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
14811 /* Fall through. */
14812
14813 /* Relocations that may need to be propagated if this is a
14814 dynamic object. */
14815 case R_PPC64_REL30:
14816 case R_PPC64_REL32:
14817 case R_PPC64_REL64:
14818 case R_PPC64_ADDR14:
14819 case R_PPC64_ADDR14_BRNTAKEN:
14820 case R_PPC64_ADDR14_BRTAKEN:
14821 case R_PPC64_ADDR16:
14822 case R_PPC64_ADDR16_DS:
14823 case R_PPC64_ADDR16_HA:
14824 case R_PPC64_ADDR16_HI:
14825 case R_PPC64_ADDR16_HIGH:
14826 case R_PPC64_ADDR16_HIGHA:
14827 case R_PPC64_ADDR16_HIGHER:
14828 case R_PPC64_ADDR16_HIGHERA:
14829 case R_PPC64_ADDR16_HIGHEST:
14830 case R_PPC64_ADDR16_HIGHESTA:
14831 case R_PPC64_ADDR16_LO:
14832 case R_PPC64_ADDR16_LO_DS:
14833 case R_PPC64_ADDR24:
14834 case R_PPC64_ADDR32:
14835 case R_PPC64_ADDR64:
14836 case R_PPC64_UADDR16:
14837 case R_PPC64_UADDR32:
14838 case R_PPC64_UADDR64:
14839 dodyn:
14840 if ((input_section->flags & SEC_ALLOC) == 0)
14841 break;
14842
14843 if (NO_OPD_RELOCS && is_opd)
14844 break;
14845
14846 if (bfd_link_pic (info)
14847 ? ((h == NULL
14848 || h->dyn_relocs != NULL)
14849 && ((h != NULL && pc_dynrelocs (h))
14850 || must_be_dyn_reloc (info, r_type)))
14851 : (h != NULL
14852 ? h->dyn_relocs != NULL
14853 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
14854 {
14855 bfd_boolean skip, relocate;
14856 asection *sreloc;
14857 bfd_vma out_off;
14858 long indx = 0;
14859
14860 /* When generating a dynamic object, these relocations
14861 are copied into the output file to be resolved at run
14862 time. */
14863
14864 skip = FALSE;
14865 relocate = FALSE;
14866
14867 out_off = _bfd_elf_section_offset (output_bfd, info,
14868 input_section, rel->r_offset);
14869 if (out_off == (bfd_vma) -1)
14870 skip = TRUE;
14871 else if (out_off == (bfd_vma) -2)
14872 skip = TRUE, relocate = TRUE;
14873 out_off += (input_section->output_section->vma
14874 + input_section->output_offset);
14875 outrel.r_offset = out_off;
14876 outrel.r_addend = rel->r_addend;
14877
14878 /* Optimize unaligned reloc use. */
14879 if ((r_type == R_PPC64_ADDR64 && (out_off & 7) != 0)
14880 || (r_type == R_PPC64_UADDR64 && (out_off & 7) == 0))
14881 r_type ^= R_PPC64_ADDR64 ^ R_PPC64_UADDR64;
14882 else if ((r_type == R_PPC64_ADDR32 && (out_off & 3) != 0)
14883 || (r_type == R_PPC64_UADDR32 && (out_off & 3) == 0))
14884 r_type ^= R_PPC64_ADDR32 ^ R_PPC64_UADDR32;
14885 else if ((r_type == R_PPC64_ADDR16 && (out_off & 1) != 0)
14886 || (r_type == R_PPC64_UADDR16 && (out_off & 1) == 0))
14887 r_type ^= R_PPC64_ADDR16 ^ R_PPC64_UADDR16;
14888
14889 if (skip)
14890 memset (&outrel, 0, sizeof outrel);
14891 else if (!SYMBOL_REFERENCES_LOCAL (info, &h->elf)
14892 && !is_opd
14893 && r_type != R_PPC64_TOC)
14894 {
14895 indx = h->elf.dynindx;
14896 BFD_ASSERT (indx != -1);
14897 outrel.r_info = ELF64_R_INFO (indx, r_type);
14898 }
14899 else
14900 {
14901 /* This symbol is local, or marked to become local,
14902 or this is an opd section reloc which must point
14903 at a local function. */
14904 outrel.r_addend += relocation;
14905 if (r_type == R_PPC64_ADDR64 || r_type == R_PPC64_TOC)
14906 {
14907 if (is_opd && h != NULL)
14908 {
14909 /* Lie about opd entries. This case occurs
14910 when building shared libraries and we
14911 reference a function in another shared
14912 lib. The same thing happens for a weak
14913 definition in an application that's
14914 overridden by a strong definition in a
14915 shared lib. (I believe this is a generic
14916 bug in binutils handling of weak syms.)
14917 In these cases we won't use the opd
14918 entry in this lib. */
14919 unresolved_reloc = FALSE;
14920 }
14921 if (!is_opd
14922 && r_type == R_PPC64_ADDR64
14923 && (h != NULL
14924 ? h->elf.type == STT_GNU_IFUNC
14925 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
14926 outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
14927 else
14928 {
14929 outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
14930
14931 /* We need to relocate .opd contents for ld.so.
14932 Prelink also wants simple and consistent rules
14933 for relocs. This make all RELATIVE relocs have
14934 *r_offset equal to r_addend. */
14935 relocate = TRUE;
14936 }
14937 }
14938 else
14939 {
14940 if (h != NULL
14941 ? h->elf.type == STT_GNU_IFUNC
14942 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
14943 {
14944 info->callbacks->einfo
14945 /* xgettext:c-format */
14946 (_("%H: %s for indirect "
14947 "function `%T' unsupported\n"),
14948 input_bfd, input_section, rel->r_offset,
14949 ppc64_elf_howto_table[r_type]->name,
14950 sym_name);
14951 ret = FALSE;
14952 }
14953 else if (r_symndx == STN_UNDEF || bfd_is_abs_section (sec))
14954 ;
14955 else if (sec == NULL || sec->owner == NULL)
14956 {
14957 bfd_set_error (bfd_error_bad_value);
14958 return FALSE;
14959 }
14960 else
14961 {
14962 asection *osec;
14963
14964 osec = sec->output_section;
14965 indx = elf_section_data (osec)->dynindx;
14966
14967 if (indx == 0)
14968 {
14969 if ((osec->flags & SEC_READONLY) == 0
14970 && htab->elf.data_index_section != NULL)
14971 osec = htab->elf.data_index_section;
14972 else
14973 osec = htab->elf.text_index_section;
14974 indx = elf_section_data (osec)->dynindx;
14975 }
14976 BFD_ASSERT (indx != 0);
14977
14978 /* We are turning this relocation into one
14979 against a section symbol, so subtract out
14980 the output section's address but not the
14981 offset of the input section in the output
14982 section. */
14983 outrel.r_addend -= osec->vma;
14984 }
14985
14986 outrel.r_info = ELF64_R_INFO (indx, r_type);
14987 }
14988 }
14989
14990 sreloc = elf_section_data (input_section)->sreloc;
14991 if (h != NULL
14992 ? h->elf.type == STT_GNU_IFUNC
14993 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
14994 {
14995 sreloc = htab->elf.irelplt;
14996 if (indx == 0)
14997 htab->local_ifunc_resolver = 1;
14998 else if (is_static_defined (&h->elf))
14999 htab->maybe_local_ifunc_resolver = 1;
15000 }
15001 if (sreloc == NULL)
15002 abort ();
15003
15004 if (sreloc->reloc_count * sizeof (Elf64_External_Rela)
15005 >= sreloc->size)
15006 abort ();
15007 loc = sreloc->contents;
15008 loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
15009 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
15010
15011 /* If this reloc is against an external symbol, it will
15012 be computed at runtime, so there's no need to do
15013 anything now. However, for the sake of prelink ensure
15014 that the section contents are a known value. */
15015 if (! relocate)
15016 {
15017 unresolved_reloc = FALSE;
15018 /* The value chosen here is quite arbitrary as ld.so
15019 ignores section contents except for the special
15020 case of .opd where the contents might be accessed
15021 before relocation. Choose zero, as that won't
15022 cause reloc overflow. */
15023 relocation = 0;
15024 addend = 0;
15025 /* Use *r_offset == r_addend for R_PPC64_ADDR64 relocs
15026 to improve backward compatibility with older
15027 versions of ld. */
15028 if (r_type == R_PPC64_ADDR64)
15029 addend = outrel.r_addend;
15030 /* Adjust pc_relative relocs to have zero in *r_offset. */
15031 else if (ppc64_elf_howto_table[r_type]->pc_relative)
15032 addend = outrel.r_offset;
15033 }
15034 }
15035 break;
15036
15037 case R_PPC64_COPY:
15038 case R_PPC64_GLOB_DAT:
15039 case R_PPC64_JMP_SLOT:
15040 case R_PPC64_JMP_IREL:
15041 case R_PPC64_RELATIVE:
15042 /* We shouldn't ever see these dynamic relocs in relocatable
15043 files. */
15044 /* Fall through. */
15045
15046 case R_PPC64_PLTGOT16:
15047 case R_PPC64_PLTGOT16_DS:
15048 case R_PPC64_PLTGOT16_HA:
15049 case R_PPC64_PLTGOT16_HI:
15050 case R_PPC64_PLTGOT16_LO:
15051 case R_PPC64_PLTGOT16_LO_DS:
15052 case R_PPC64_PLTREL32:
15053 case R_PPC64_PLTREL64:
15054 /* These ones haven't been implemented yet. */
15055
15056 info->callbacks->einfo
15057 /* xgettext:c-format */
15058 (_("%P: %B: %s is not supported for `%T'\n"),
15059 input_bfd,
15060 ppc64_elf_howto_table[r_type]->name, sym_name);
15061
15062 bfd_set_error (bfd_error_invalid_operation);
15063 ret = FALSE;
15064 goto copy_reloc;
15065 }
15066
15067 /* Multi-instruction sequences that access the TOC can be
15068 optimized, eg. addis ra,r2,0; addi rb,ra,x;
15069 to nop; addi rb,r2,x; */
15070 howto = ppc64_elf_howto_table[(int) r_type];
15071 switch (r_type)
15072 {
15073 default:
15074 break;
15075
15076 case R_PPC64_GOT_TLSLD16_HI:
15077 case R_PPC64_GOT_TLSGD16_HI:
15078 case R_PPC64_GOT_TPREL16_HI:
15079 case R_PPC64_GOT_DTPREL16_HI:
15080 case R_PPC64_GOT16_HI:
15081 case R_PPC64_TOC16_HI:
15082 /* These relocs would only be useful if building up an
15083 offset to later add to r2, perhaps in an indexed
15084 addressing mode instruction. Don't try to optimize.
15085 Unfortunately, the possibility of someone building up an
15086 offset like this or even with the HA relocs, means that
15087 we need to check the high insn when optimizing the low
15088 insn. */
15089 break;
15090
15091 case R_PPC64_GOT_TLSLD16_HA:
15092 case R_PPC64_GOT_TLSGD16_HA:
15093 case R_PPC64_GOT_TPREL16_HA:
15094 case R_PPC64_GOT_DTPREL16_HA:
15095 case R_PPC64_GOT16_HA:
15096 case R_PPC64_TOC16_HA:
15097 if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
15098 && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
15099 {
15100 bfd_byte *p = contents + (rel->r_offset & ~3);
15101 bfd_put_32 (input_bfd, NOP, p);
15102 }
15103 break;
15104
15105 case R_PPC64_GOT_TLSLD16_LO:
15106 case R_PPC64_GOT_TLSGD16_LO:
15107 case R_PPC64_GOT_TPREL16_LO_DS:
15108 case R_PPC64_GOT_DTPREL16_LO_DS:
15109 case R_PPC64_GOT16_LO:
15110 case R_PPC64_GOT16_LO_DS:
15111 case R_PPC64_TOC16_LO:
15112 case R_PPC64_TOC16_LO_DS:
15113 if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
15114 && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
15115 {
15116 bfd_byte *p = contents + (rel->r_offset & ~3);
15117 insn = bfd_get_32 (input_bfd, p);
15118 if ((insn & (0x3f << 26)) == 12u << 26 /* addic */)
15119 {
15120 /* Transform addic to addi when we change reg. */
15121 insn &= ~((0x3f << 26) | (0x1f << 16));
15122 insn |= (14u << 26) | (2 << 16);
15123 }
15124 else
15125 {
15126 insn &= ~(0x1f << 16);
15127 insn |= 2 << 16;
15128 }
15129 bfd_put_32 (input_bfd, insn, p);
15130 }
15131 break;
15132
15133 case R_PPC64_TPREL16_HA:
15134 if (htab->do_tls_opt && relocation + addend + 0x8000 < 0x10000)
15135 {
15136 bfd_byte *p = contents + (rel->r_offset & ~3);
15137 insn = bfd_get_32 (input_bfd, p);
15138 if ((insn & ((0x3f << 26) | 0x1f << 16))
15139 != ((15u << 26) | (13 << 16)) /* addis rt,13,imm */)
15140 /* xgettext:c-format */
15141 info->callbacks->minfo
15142 (_("%H: warning: %s unexpected insn %#x.\n"),
15143 input_bfd, input_section, rel->r_offset, howto->name, insn);
15144 else
15145 bfd_put_32 (input_bfd, NOP, p);
15146 }
15147 break;
15148
15149 case R_PPC64_TPREL16_LO:
15150 case R_PPC64_TPREL16_LO_DS:
15151 if (htab->do_tls_opt && relocation + addend + 0x8000 < 0x10000)
15152 {
15153 bfd_byte *p = contents + (rel->r_offset & ~3);
15154 insn = bfd_get_32 (input_bfd, p);
15155 insn &= ~(0x1f << 16);
15156 insn |= 13 << 16;
15157 bfd_put_32 (input_bfd, insn, p);
15158 }
15159 break;
15160 }
15161
15162 /* Do any further special processing. */
15163 switch (r_type)
15164 {
15165 default:
15166 break;
15167
15168 case R_PPC64_REL16_HA:
15169 case R_PPC64_REL16DX_HA:
15170 case R_PPC64_ADDR16_HA:
15171 case R_PPC64_ADDR16_HIGHA:
15172 case R_PPC64_ADDR16_HIGHERA:
15173 case R_PPC64_ADDR16_HIGHESTA:
15174 case R_PPC64_TOC16_HA:
15175 case R_PPC64_SECTOFF_HA:
15176 case R_PPC64_TPREL16_HA:
15177 case R_PPC64_TPREL16_HIGHA:
15178 case R_PPC64_TPREL16_HIGHERA:
15179 case R_PPC64_TPREL16_HIGHESTA:
15180 case R_PPC64_DTPREL16_HA:
15181 case R_PPC64_DTPREL16_HIGHA:
15182 case R_PPC64_DTPREL16_HIGHERA:
15183 case R_PPC64_DTPREL16_HIGHESTA:
15184 /* It's just possible that this symbol is a weak symbol
15185 that's not actually defined anywhere. In that case,
15186 'sec' would be NULL, and we should leave the symbol
15187 alone (it will be set to zero elsewhere in the link). */
15188 if (sec == NULL)
15189 break;
15190 /* Fall through. */
15191
15192 case R_PPC64_GOT16_HA:
15193 case R_PPC64_PLTGOT16_HA:
15194 case R_PPC64_PLT16_HA:
15195 case R_PPC64_GOT_TLSGD16_HA:
15196 case R_PPC64_GOT_TLSLD16_HA:
15197 case R_PPC64_GOT_TPREL16_HA:
15198 case R_PPC64_GOT_DTPREL16_HA:
15199 /* Add 0x10000 if sign bit in 0:15 is set.
15200 Bits 0:15 are not used. */
15201 addend += 0x8000;
15202 break;
15203
15204 case R_PPC64_ADDR16_DS:
15205 case R_PPC64_ADDR16_LO_DS:
15206 case R_PPC64_GOT16_DS:
15207 case R_PPC64_GOT16_LO_DS:
15208 case R_PPC64_PLT16_LO_DS:
15209 case R_PPC64_SECTOFF_DS:
15210 case R_PPC64_SECTOFF_LO_DS:
15211 case R_PPC64_TOC16_DS:
15212 case R_PPC64_TOC16_LO_DS:
15213 case R_PPC64_PLTGOT16_DS:
15214 case R_PPC64_PLTGOT16_LO_DS:
15215 case R_PPC64_GOT_TPREL16_DS:
15216 case R_PPC64_GOT_TPREL16_LO_DS:
15217 case R_PPC64_GOT_DTPREL16_DS:
15218 case R_PPC64_GOT_DTPREL16_LO_DS:
15219 case R_PPC64_TPREL16_DS:
15220 case R_PPC64_TPREL16_LO_DS:
15221 case R_PPC64_DTPREL16_DS:
15222 case R_PPC64_DTPREL16_LO_DS:
15223 insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
15224 mask = 3;
15225 /* If this reloc is against an lq, lxv, or stxv insn, then
15226 the value must be a multiple of 16. This is somewhat of
15227 a hack, but the "correct" way to do this by defining _DQ
15228 forms of all the _DS relocs bloats all reloc switches in
15229 this file. It doesn't make much sense to use these
15230 relocs in data, so testing the insn should be safe. */
15231 if ((insn & (0x3f << 26)) == (56u << 26)
15232 || ((insn & (0x3f << 26)) == (61u << 26) && (insn & 3) == 1))
15233 mask = 15;
15234 relocation += addend;
15235 addend = insn & (mask ^ 3);
15236 if ((relocation & mask) != 0)
15237 {
15238 relocation ^= relocation & mask;
15239 info->callbacks->einfo
15240 /* xgettext:c-format */
15241 (_("%H: error: %s not a multiple of %u\n"),
15242 input_bfd, input_section, rel->r_offset,
15243 howto->name,
15244 mask + 1);
15245 bfd_set_error (bfd_error_bad_value);
15246 ret = FALSE;
15247 goto copy_reloc;
15248 }
15249 break;
15250 }
15251
15252 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
15253 because such sections are not SEC_ALLOC and thus ld.so will
15254 not process them. */
15255 if (unresolved_reloc
15256 && !((input_section->flags & SEC_DEBUGGING) != 0
15257 && h->elf.def_dynamic)
15258 && _bfd_elf_section_offset (output_bfd, info, input_section,
15259 rel->r_offset) != (bfd_vma) -1)
15260 {
15261 info->callbacks->einfo
15262 /* xgettext:c-format */
15263 (_("%H: unresolvable %s against `%T'\n"),
15264 input_bfd, input_section, rel->r_offset,
15265 howto->name,
15266 h->elf.root.root.string);
15267 ret = FALSE;
15268 }
15269
15270 /* 16-bit fields in insns mostly have signed values, but a
15271 few insns have 16-bit unsigned values. Really, we should
15272 have different reloc types. */
15273 if (howto->complain_on_overflow != complain_overflow_dont
15274 && howto->dst_mask == 0xffff
15275 && (input_section->flags & SEC_CODE) != 0)
15276 {
15277 enum complain_overflow complain = complain_overflow_signed;
15278
15279 insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
15280 if ((insn & (0x3f << 26)) == 10u << 26 /* cmpli */)
15281 complain = complain_overflow_bitfield;
15282 else if (howto->rightshift == 0
15283 ? ((insn & (0x3f << 26)) == 28u << 26 /* andi */
15284 || (insn & (0x3f << 26)) == 24u << 26 /* ori */
15285 || (insn & (0x3f << 26)) == 26u << 26 /* xori */)
15286 : ((insn & (0x3f << 26)) == 29u << 26 /* andis */
15287 || (insn & (0x3f << 26)) == 25u << 26 /* oris */
15288 || (insn & (0x3f << 26)) == 27u << 26 /* xoris */))
15289 complain = complain_overflow_unsigned;
15290 if (howto->complain_on_overflow != complain)
15291 {
15292 alt_howto = *howto;
15293 alt_howto.complain_on_overflow = complain;
15294 howto = &alt_howto;
15295 }
15296 }
15297
15298 if (r_type == R_PPC64_REL16DX_HA)
15299 {
15300 /* Split field reloc isn't handled by _bfd_final_link_relocate. */
15301 if (rel->r_offset + 4 > input_section->size)
15302 r = bfd_reloc_outofrange;
15303 else
15304 {
15305 relocation += addend;
15306 relocation -= (rel->r_offset
15307 + input_section->output_offset
15308 + input_section->output_section->vma);
15309 relocation = (bfd_signed_vma) relocation >> 16;
15310 insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
15311 insn &= ~0x1fffc1;
15312 insn |= (relocation & 0xffc1) | ((relocation & 0x3e) << 15);
15313 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
15314 r = bfd_reloc_ok;
15315 if (relocation + 0x8000 > 0xffff)
15316 r = bfd_reloc_overflow;
15317 }
15318 }
15319 else
15320 r = _bfd_final_link_relocate (howto, input_bfd, input_section, contents,
15321 rel->r_offset, relocation, addend);
15322
15323 if (r != bfd_reloc_ok)
15324 {
15325 char *more_info = NULL;
15326 const char *reloc_name = howto->name;
15327
15328 if (reloc_dest != DEST_NORMAL)
15329 {
15330 more_info = bfd_malloc (strlen (reloc_name) + 8);
15331 if (more_info != NULL)
15332 {
15333 strcpy (more_info, reloc_name);
15334 strcat (more_info, (reloc_dest == DEST_OPD
15335 ? " (OPD)" : " (stub)"));
15336 reloc_name = more_info;
15337 }
15338 }
15339
15340 if (r == bfd_reloc_overflow)
15341 {
15342 /* On code like "if (foo) foo();" don't report overflow
15343 on a branch to zero when foo is undefined. */
15344 if (!warned
15345 && (reloc_dest == DEST_STUB
15346 || !(h != NULL
15347 && (h->elf.root.type == bfd_link_hash_undefweak
15348 || h->elf.root.type == bfd_link_hash_undefined)
15349 && is_branch_reloc (r_type))))
15350 info->callbacks->reloc_overflow (info, &h->elf.root,
15351 sym_name, reloc_name,
15352 orig_rel.r_addend,
15353 input_bfd, input_section,
15354 rel->r_offset);
15355 }
15356 else
15357 {
15358 info->callbacks->einfo
15359 /* xgettext:c-format */
15360 (_("%H: %s against `%T': error %d\n"),
15361 input_bfd, input_section, rel->r_offset,
15362 reloc_name, sym_name, (int) r);
15363 ret = FALSE;
15364 }
15365 if (more_info != NULL)
15366 free (more_info);
15367 }
15368 copy_reloc:
15369 if (wrel != rel)
15370 *wrel = *rel;
15371 }
15372
15373 if (wrel != rel)
15374 {
15375 Elf_Internal_Shdr *rel_hdr;
15376 size_t deleted = rel - wrel;
15377
15378 rel_hdr = _bfd_elf_single_rel_hdr (input_section->output_section);
15379 rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
15380 if (rel_hdr->sh_size == 0)
15381 {
15382 /* It is too late to remove an empty reloc section. Leave
15383 one NONE reloc.
15384 ??? What is wrong with an empty section??? */
15385 rel_hdr->sh_size = rel_hdr->sh_entsize;
15386 deleted -= 1;
15387 }
15388 rel_hdr = _bfd_elf_single_rel_hdr (input_section);
15389 rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
15390 input_section->reloc_count -= deleted;
15391 }
15392
15393 /* If we're emitting relocations, then shortly after this function
15394 returns, reloc offsets and addends for this section will be
15395 adjusted. Worse, reloc symbol indices will be for the output
15396 file rather than the input. Save a copy of the relocs for
15397 opd_entry_value. */
15398 if (is_opd && (info->emitrelocations || bfd_link_relocatable (info)))
15399 {
15400 bfd_size_type amt;
15401 amt = input_section->reloc_count * sizeof (Elf_Internal_Rela);
15402 rel = bfd_alloc (input_bfd, amt);
15403 BFD_ASSERT (ppc64_elf_tdata (input_bfd)->opd.relocs == NULL);
15404 ppc64_elf_tdata (input_bfd)->opd.relocs = rel;
15405 if (rel == NULL)
15406 return FALSE;
15407 memcpy (rel, relocs, amt);
15408 }
15409 return ret;
15410 }
15411
15412 /* Adjust the value of any local symbols in opd sections. */
15413
15414 static int
15415 ppc64_elf_output_symbol_hook (struct bfd_link_info *info,
15416 const char *name ATTRIBUTE_UNUSED,
15417 Elf_Internal_Sym *elfsym,
15418 asection *input_sec,
15419 struct elf_link_hash_entry *h)
15420 {
15421 struct _opd_sec_data *opd;
15422 long adjust;
15423 bfd_vma value;
15424
15425 if (h != NULL)
15426 return 1;
15427
15428 opd = get_opd_info (input_sec);
15429 if (opd == NULL || opd->adjust == NULL)
15430 return 1;
15431
15432 value = elfsym->st_value - input_sec->output_offset;
15433 if (!bfd_link_relocatable (info))
15434 value -= input_sec->output_section->vma;
15435
15436 adjust = opd->adjust[OPD_NDX (value)];
15437 if (adjust == -1)
15438 return 2;
15439
15440 elfsym->st_value += adjust;
15441 return 1;
15442 }
15443
15444 /* Finish up dynamic symbol handling. We set the contents of various
15445 dynamic sections here. */
15446
15447 static bfd_boolean
15448 ppc64_elf_finish_dynamic_symbol (bfd *output_bfd,
15449 struct bfd_link_info *info,
15450 struct elf_link_hash_entry *h,
15451 Elf_Internal_Sym *sym)
15452 {
15453 struct ppc_link_hash_table *htab;
15454 struct plt_entry *ent;
15455 Elf_Internal_Rela rela;
15456 bfd_byte *loc;
15457
15458 htab = ppc_hash_table (info);
15459 if (htab == NULL)
15460 return FALSE;
15461
15462 for (ent = h->plt.plist; ent != NULL; ent = ent->next)
15463 if (ent->plt.offset != (bfd_vma) -1)
15464 {
15465 /* This symbol has an entry in the procedure linkage
15466 table. Set it up. */
15467 if (!htab->elf.dynamic_sections_created
15468 || h->dynindx == -1)
15469 {
15470 BFD_ASSERT (h->type == STT_GNU_IFUNC
15471 && h->def_regular
15472 && (h->root.type == bfd_link_hash_defined
15473 || h->root.type == bfd_link_hash_defweak));
15474 rela.r_offset = (htab->elf.iplt->output_section->vma
15475 + htab->elf.iplt->output_offset
15476 + ent->plt.offset);
15477 if (htab->opd_abi)
15478 rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
15479 else
15480 rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
15481 rela.r_addend = (h->root.u.def.value
15482 + h->root.u.def.section->output_offset
15483 + h->root.u.def.section->output_section->vma
15484 + ent->addend);
15485 loc = (htab->elf.irelplt->contents
15486 + (htab->elf.irelplt->reloc_count++
15487 * sizeof (Elf64_External_Rela)));
15488 htab->local_ifunc_resolver = 1;
15489 }
15490 else
15491 {
15492 rela.r_offset = (htab->elf.splt->output_section->vma
15493 + htab->elf.splt->output_offset
15494 + ent->plt.offset);
15495 rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_JMP_SLOT);
15496 rela.r_addend = ent->addend;
15497 loc = (htab->elf.srelplt->contents
15498 + ((ent->plt.offset - PLT_INITIAL_ENTRY_SIZE (htab))
15499 / PLT_ENTRY_SIZE (htab) * sizeof (Elf64_External_Rela)));
15500 if (h->type == STT_GNU_IFUNC && is_static_defined (h))
15501 htab->maybe_local_ifunc_resolver = 1;
15502 }
15503 bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
15504
15505 if (!htab->opd_abi)
15506 {
15507 if (!h->def_regular)
15508 {
15509 /* Mark the symbol as undefined, rather than as
15510 defined in glink. Leave the value if there were
15511 any relocations where pointer equality matters
15512 (this is a clue for the dynamic linker, to make
15513 function pointer comparisons work between an
15514 application and shared library), otherwise set it
15515 to zero. */
15516 sym->st_shndx = SHN_UNDEF;
15517 if (!h->pointer_equality_needed)
15518 sym->st_value = 0;
15519 else if (!h->ref_regular_nonweak)
15520 {
15521 /* This breaks function pointer comparisons, but
15522 that is better than breaking tests for a NULL
15523 function pointer. */
15524 sym->st_value = 0;
15525 }
15526 }
15527 }
15528 }
15529
15530 if (h->needs_copy)
15531 {
15532 /* This symbol needs a copy reloc. Set it up. */
15533 asection *srel;
15534
15535 if (h->dynindx == -1
15536 || (h->root.type != bfd_link_hash_defined
15537 && h->root.type != bfd_link_hash_defweak)
15538 || htab->elf.srelbss == NULL
15539 || htab->elf.sreldynrelro == NULL)
15540 abort ();
15541
15542 rela.r_offset = (h->root.u.def.value
15543 + h->root.u.def.section->output_section->vma
15544 + h->root.u.def.section->output_offset);
15545 rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_COPY);
15546 rela.r_addend = 0;
15547 if (h->root.u.def.section == htab->elf.sdynrelro)
15548 srel = htab->elf.sreldynrelro;
15549 else
15550 srel = htab->elf.srelbss;
15551 loc = srel->contents;
15552 loc += srel->reloc_count++ * sizeof (Elf64_External_Rela);
15553 bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
15554 }
15555
15556 return TRUE;
15557 }
15558
15559 /* Used to decide how to sort relocs in an optimal manner for the
15560 dynamic linker, before writing them out. */
15561
15562 static enum elf_reloc_type_class
15563 ppc64_elf_reloc_type_class (const struct bfd_link_info *info,
15564 const asection *rel_sec,
15565 const Elf_Internal_Rela *rela)
15566 {
15567 enum elf_ppc64_reloc_type r_type;
15568 struct ppc_link_hash_table *htab = ppc_hash_table (info);
15569
15570 if (rel_sec == htab->elf.irelplt)
15571 return reloc_class_ifunc;
15572
15573 r_type = ELF64_R_TYPE (rela->r_info);
15574 switch (r_type)
15575 {
15576 case R_PPC64_RELATIVE:
15577 return reloc_class_relative;
15578 case R_PPC64_JMP_SLOT:
15579 return reloc_class_plt;
15580 case R_PPC64_COPY:
15581 return reloc_class_copy;
15582 default:
15583 return reloc_class_normal;
15584 }
15585 }
15586
15587 /* Finish up the dynamic sections. */
15588
15589 static bfd_boolean
15590 ppc64_elf_finish_dynamic_sections (bfd *output_bfd,
15591 struct bfd_link_info *info)
15592 {
15593 struct ppc_link_hash_table *htab;
15594 bfd *dynobj;
15595 asection *sdyn;
15596
15597 htab = ppc_hash_table (info);
15598 if (htab == NULL)
15599 return FALSE;
15600
15601 dynobj = htab->elf.dynobj;
15602 sdyn = bfd_get_linker_section (dynobj, ".dynamic");
15603
15604 if (htab->elf.dynamic_sections_created)
15605 {
15606 Elf64_External_Dyn *dyncon, *dynconend;
15607
15608 if (sdyn == NULL || htab->elf.sgot == NULL)
15609 abort ();
15610
15611 dyncon = (Elf64_External_Dyn *) sdyn->contents;
15612 dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
15613 for (; dyncon < dynconend; dyncon++)
15614 {
15615 Elf_Internal_Dyn dyn;
15616 asection *s;
15617
15618 bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
15619
15620 switch (dyn.d_tag)
15621 {
15622 default:
15623 continue;
15624
15625 case DT_PPC64_GLINK:
15626 s = htab->glink;
15627 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
15628 /* We stupidly defined DT_PPC64_GLINK to be the start
15629 of glink rather than the first entry point, which is
15630 what ld.so needs, and now have a bigger stub to
15631 support automatic multiple TOCs. */
15632 dyn.d_un.d_ptr += GLINK_PLTRESOLVE_SIZE (htab) - 8 * 4;
15633 break;
15634
15635 case DT_PPC64_OPD:
15636 s = bfd_get_section_by_name (output_bfd, ".opd");
15637 if (s == NULL)
15638 continue;
15639 dyn.d_un.d_ptr = s->vma;
15640 break;
15641
15642 case DT_PPC64_OPT:
15643 if (htab->do_multi_toc && htab->multi_toc_needed)
15644 dyn.d_un.d_val |= PPC64_OPT_MULTI_TOC;
15645 if (htab->has_plt_localentry0)
15646 dyn.d_un.d_val |= PPC64_OPT_LOCALENTRY;
15647 break;
15648
15649 case DT_PPC64_OPDSZ:
15650 s = bfd_get_section_by_name (output_bfd, ".opd");
15651 if (s == NULL)
15652 continue;
15653 dyn.d_un.d_val = s->size;
15654 break;
15655
15656 case DT_PLTGOT:
15657 s = htab->elf.splt;
15658 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
15659 break;
15660
15661 case DT_JMPREL:
15662 s = htab->elf.srelplt;
15663 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
15664 break;
15665
15666 case DT_PLTRELSZ:
15667 dyn.d_un.d_val = htab->elf.srelplt->size;
15668 break;
15669
15670 case DT_TEXTREL:
15671 if (htab->local_ifunc_resolver)
15672 info->callbacks->einfo
15673 (_("%X%P: text relocations and GNU indirect "
15674 "functions will result in a segfault at runtime\n"));
15675 else if (htab->maybe_local_ifunc_resolver)
15676 info->callbacks->einfo
15677 (_("%P: warning: text relocations and GNU indirect "
15678 "functions may result in a segfault at runtime\n"));
15679 continue;
15680 }
15681
15682 bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
15683 }
15684 }
15685
15686 if (htab->elf.sgot != NULL && htab->elf.sgot->size != 0
15687 && htab->elf.sgot->output_section != bfd_abs_section_ptr)
15688 {
15689 /* Fill in the first entry in the global offset table.
15690 We use it to hold the link-time TOCbase. */
15691 bfd_put_64 (output_bfd,
15692 elf_gp (output_bfd) + TOC_BASE_OFF,
15693 htab->elf.sgot->contents);
15694
15695 /* Set .got entry size. */
15696 elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize = 8;
15697 }
15698
15699 if (htab->elf.splt != NULL && htab->elf.splt->size != 0
15700 && htab->elf.splt->output_section != bfd_abs_section_ptr)
15701 {
15702 /* Set .plt entry size. */
15703 elf_section_data (htab->elf.splt->output_section)->this_hdr.sh_entsize
15704 = PLT_ENTRY_SIZE (htab);
15705 }
15706
15707 /* brlt is SEC_LINKER_CREATED, so we need to write out relocs for
15708 brlt ourselves if emitrelocations. */
15709 if (htab->brlt != NULL
15710 && htab->brlt->reloc_count != 0
15711 && !_bfd_elf_link_output_relocs (output_bfd,
15712 htab->brlt,
15713 elf_section_data (htab->brlt)->rela.hdr,
15714 elf_section_data (htab->brlt)->relocs,
15715 NULL))
15716 return FALSE;
15717
15718 if (htab->glink != NULL
15719 && htab->glink->reloc_count != 0
15720 && !_bfd_elf_link_output_relocs (output_bfd,
15721 htab->glink,
15722 elf_section_data (htab->glink)->rela.hdr,
15723 elf_section_data (htab->glink)->relocs,
15724 NULL))
15725 return FALSE;
15726
15727 if (htab->glink_eh_frame != NULL
15728 && htab->glink_eh_frame->size != 0)
15729 {
15730 bfd_vma val;
15731 bfd_byte *p;
15732 struct map_stub *group;
15733 size_t align = 4;
15734
15735 p = htab->glink_eh_frame->contents;
15736 p += (sizeof (glink_eh_frame_cie) + align - 1) & -align;
15737
15738 for (group = htab->group; group != NULL; group = group->next)
15739 if (group->stub_sec != NULL)
15740 {
15741 /* Offset to stub section. */
15742 val = (group->stub_sec->output_section->vma
15743 + group->stub_sec->output_offset);
15744 val -= (htab->glink_eh_frame->output_section->vma
15745 + htab->glink_eh_frame->output_offset
15746 + (p + 8 - htab->glink_eh_frame->contents));
15747 if (val + 0x80000000 > 0xffffffff)
15748 {
15749 info->callbacks->einfo
15750 (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
15751 group->stub_sec->name);
15752 return FALSE;
15753 }
15754 bfd_put_32 (dynobj, val, p + 8);
15755 p += stub_eh_frame_size (group, align);
15756 }
15757 if (htab->glink != NULL && htab->glink->size != 0)
15758 {
15759 /* Offset to .glink. */
15760 val = (htab->glink->output_section->vma
15761 + htab->glink->output_offset
15762 + 8);
15763 val -= (htab->glink_eh_frame->output_section->vma
15764 + htab->glink_eh_frame->output_offset
15765 + (p + 8 - htab->glink_eh_frame->contents));
15766 if (val + 0x80000000 > 0xffffffff)
15767 {
15768 info->callbacks->einfo
15769 (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
15770 htab->glink->name);
15771 return FALSE;
15772 }
15773 bfd_put_32 (dynobj, val, p + 8);
15774 p += (24 + align - 1) & -align;
15775 }
15776
15777 if (htab->glink_eh_frame->sec_info_type == SEC_INFO_TYPE_EH_FRAME
15778 && !_bfd_elf_write_section_eh_frame (output_bfd, info,
15779 htab->glink_eh_frame,
15780 htab->glink_eh_frame->contents))
15781 return FALSE;
15782 }
15783
15784 /* We need to handle writing out multiple GOT sections ourselves,
15785 since we didn't add them to DYNOBJ. We know dynobj is the first
15786 bfd. */
15787 while ((dynobj = dynobj->link.next) != NULL)
15788 {
15789 asection *s;
15790
15791 if (!is_ppc64_elf (dynobj))
15792 continue;
15793
15794 s = ppc64_elf_tdata (dynobj)->got;
15795 if (s != NULL
15796 && s->size != 0
15797 && s->output_section != bfd_abs_section_ptr
15798 && !bfd_set_section_contents (output_bfd, s->output_section,
15799 s->contents, s->output_offset,
15800 s->size))
15801 return FALSE;
15802 s = ppc64_elf_tdata (dynobj)->relgot;
15803 if (s != NULL
15804 && s->size != 0
15805 && s->output_section != bfd_abs_section_ptr
15806 && !bfd_set_section_contents (output_bfd, s->output_section,
15807 s->contents, s->output_offset,
15808 s->size))
15809 return FALSE;
15810 }
15811
15812 return TRUE;
15813 }
15814
15815 #include "elf64-target.h"
15816
15817 /* FreeBSD support */
15818
15819 #undef TARGET_LITTLE_SYM
15820 #undef TARGET_LITTLE_NAME
15821
15822 #undef TARGET_BIG_SYM
15823 #define TARGET_BIG_SYM powerpc_elf64_fbsd_vec
15824 #undef TARGET_BIG_NAME
15825 #define TARGET_BIG_NAME "elf64-powerpc-freebsd"
15826
15827 #undef ELF_OSABI
15828 #define ELF_OSABI ELFOSABI_FREEBSD
15829
15830 #undef elf64_bed
15831 #define elf64_bed elf64_powerpc_fbsd_bed
15832
15833 #include "elf64-target.h"
GDB Binutils - Deliverables
This page took 0.398559 seconds and 4 git commands to generate.