projects / deliverable / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
PowerPC64 EH info for _notoc linkage stubs
[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 0x1000
68 #define ELF_RELROPAGESIZE ELF_MAXPAGESIZE
69 #define elf_info_to_howto ppc64_elf_info_to_howto
70
71 #define elf_backend_want_got_sym 0
72 #define elf_backend_want_plt_sym 0
73 #define elf_backend_plt_alignment 3
74 #define elf_backend_plt_not_loaded 1
75 #define elf_backend_got_header_size 8
76 #define elf_backend_want_dynrelro 1
77 #define elf_backend_can_gc_sections 1
78 #define elf_backend_can_refcount 1
79 #define elf_backend_rela_normal 1
80 #define elf_backend_dtrel_excludes_plt 1
81 #define elf_backend_default_execstack 0
82
83 #define bfd_elf64_mkobject ppc64_elf_mkobject
84 #define bfd_elf64_bfd_reloc_type_lookup ppc64_elf_reloc_type_lookup
85 #define bfd_elf64_bfd_reloc_name_lookup ppc64_elf_reloc_name_lookup
86 #define bfd_elf64_bfd_merge_private_bfd_data ppc64_elf_merge_private_bfd_data
87 #define bfd_elf64_bfd_print_private_bfd_data ppc64_elf_print_private_bfd_data
88 #define bfd_elf64_new_section_hook ppc64_elf_new_section_hook
89 #define bfd_elf64_bfd_link_hash_table_create ppc64_elf_link_hash_table_create
90 #define bfd_elf64_get_synthetic_symtab ppc64_elf_get_synthetic_symtab
91 #define bfd_elf64_bfd_link_just_syms ppc64_elf_link_just_syms
92 #define bfd_elf64_bfd_gc_sections ppc64_elf_gc_sections
93
94 #define elf_backend_object_p ppc64_elf_object_p
95 #define elf_backend_grok_prstatus ppc64_elf_grok_prstatus
96 #define elf_backend_grok_psinfo ppc64_elf_grok_psinfo
97 #define elf_backend_write_core_note ppc64_elf_write_core_note
98 #define elf_backend_create_dynamic_sections _bfd_elf_create_dynamic_sections
99 #define elf_backend_copy_indirect_symbol ppc64_elf_copy_indirect_symbol
100 #define elf_backend_add_symbol_hook ppc64_elf_add_symbol_hook
101 #define elf_backend_check_directives ppc64_elf_before_check_relocs
102 #define elf_backend_notice_as_needed ppc64_elf_notice_as_needed
103 #define elf_backend_archive_symbol_lookup ppc64_elf_archive_symbol_lookup
104 #define elf_backend_check_relocs ppc64_elf_check_relocs
105 #define elf_backend_relocs_compatible _bfd_elf_relocs_compatible
106 #define elf_backend_gc_keep ppc64_elf_gc_keep
107 #define elf_backend_gc_mark_dynamic_ref ppc64_elf_gc_mark_dynamic_ref
108 #define elf_backend_gc_mark_hook ppc64_elf_gc_mark_hook
109 #define elf_backend_adjust_dynamic_symbol ppc64_elf_adjust_dynamic_symbol
110 #define elf_backend_hide_symbol ppc64_elf_hide_symbol
111 #define elf_backend_maybe_function_sym ppc64_elf_maybe_function_sym
112 #define elf_backend_always_size_sections ppc64_elf_func_desc_adjust
113 #define elf_backend_size_dynamic_sections ppc64_elf_size_dynamic_sections
114 #define elf_backend_hash_symbol ppc64_elf_hash_symbol
115 #define elf_backend_init_index_section _bfd_elf_init_2_index_sections
116 #define elf_backend_action_discarded ppc64_elf_action_discarded
117 #define elf_backend_relocate_section ppc64_elf_relocate_section
118 #define elf_backend_finish_dynamic_symbol ppc64_elf_finish_dynamic_symbol
119 #define elf_backend_reloc_type_class ppc64_elf_reloc_type_class
120 #define elf_backend_finish_dynamic_sections ppc64_elf_finish_dynamic_sections
121 #define elf_backend_link_output_symbol_hook ppc64_elf_output_symbol_hook
122 #define elf_backend_special_sections ppc64_elf_special_sections
123 #define elf_backend_merge_symbol_attribute ppc64_elf_merge_symbol_attribute
124 #define elf_backend_merge_symbol ppc64_elf_merge_symbol
125 #define elf_backend_get_reloc_section bfd_get_section_by_name
126
127 /* The name of the dynamic interpreter. This is put in the .interp
128 section. */
129 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
130
131 /* The size in bytes of an entry in the procedure linkage table. */
132 #define PLT_ENTRY_SIZE(htab) (htab->opd_abi ? 24 : 8)
133 #define LOCAL_PLT_ENTRY_SIZE(htab) (htab->opd_abi ? 16 : 8)
134
135 /* The initial size of the plt reserved for the dynamic linker. */
136 #define PLT_INITIAL_ENTRY_SIZE(htab) (htab->opd_abi ? 24 : 16)
137
138 /* Offsets to some stack save slots. */
139 #define STK_LR 16
140 #define STK_TOC(htab) (htab->opd_abi ? 40 : 24)
141 /* This one is dodgy. ELFv2 does not have a linker word, so use the
142 CR save slot. Used only by optimised __tls_get_addr call stub,
143 relying on __tls_get_addr_opt not saving CR.. */
144 #define STK_LINKER(htab) (htab->opd_abi ? 32 : 8)
145
146 /* TOC base pointers offset from start of TOC. */
147 #define TOC_BASE_OFF 0x8000
148 /* TOC base alignment. */
149 #define TOC_BASE_ALIGN 256
150
151 /* Offset of tp and dtp pointers from start of TLS block. */
152 #define TP_OFFSET 0x7000
153 #define DTP_OFFSET 0x8000
154
155 /* .plt call stub instructions. The normal stub is like this, but
156 sometimes the .plt entry crosses a 64k boundary and we need to
157 insert an addi to adjust r11. */
158 #define STD_R2_0R1 0xf8410000 /* std %r2,0+40(%r1) */
159 #define ADDIS_R11_R2 0x3d620000 /* addis %r11,%r2,xxx@ha */
160 #define LD_R12_0R11 0xe98b0000 /* ld %r12,xxx+0@l(%r11) */
161 #define MTCTR_R12 0x7d8903a6 /* mtctr %r12 */
162 #define LD_R2_0R11 0xe84b0000 /* ld %r2,xxx+8@l(%r11) */
163 #define LD_R11_0R11 0xe96b0000 /* ld %r11,xxx+16@l(%r11) */
164 #define BCTR 0x4e800420 /* bctr */
165
166 #define ADDI_R11_R11 0x396b0000 /* addi %r11,%r11,off@l */
167 #define ADDI_R12_R11 0x398b0000 /* addi %r12,%r11,off@l */
168 #define ADDI_R12_R12 0x398c0000 /* addi %r12,%r12,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 LIS_R12 0x3d800000 /* lis %r12,xxx@ha */
190 #define ADDIS_R2_R12 0x3c4c0000 /* addis %r2,%r12,xxx@ha */
191 #define ADDIS_R12_R2 0x3d820000 /* addis %r12,%r2,xxx@ha */
192 #define ADDIS_R12_R11 0x3d8b0000 /* addis %r12,%r11,xxx@ha */
193 #define ADDIS_R12_R12 0x3d8c0000 /* addis %r12,%r12,xxx@ha */
194 #define ORIS_R12_R12_0 0x658c0000 /* oris %r12,%r12,xxx@hi */
195 #define ORI_R12_R12_0 0x618c0000 /* ori %r12,%r12,xxx@l */
196 #define LD_R12_0R12 0xe98c0000 /* ld %r12,xxx@l(%r12) */
197 #define SLDI_R12_R12_32 0x799c07c6 /* sldi %r12,%r12,32 */
198 #define LDX_R12_R11_R12 0x7d8b602a /* ldx %r12,%r11,%r12 */
199 #define ADD_R12_R11_R12 0x7d8b6214 /* add %r12,%r11,%r12 */
200
201 /* __glink_PLTresolve stub instructions. We enter with the index in R0. */
202 #define GLINK_PLTRESOLVE_SIZE(htab) \
203 (8u + (htab->opd_abi ? 11 * 4 : 14 * 4))
204 /* 0: */
205 /* .quad plt0-1f */
206 /* __glink: */
207 #define MFLR_R12 0x7d8802a6 /* mflr %12 */
208 #define BCL_20_31 0x429f0005 /* bcl 20,31,1f */
209 /* 1: */
210 #define MFLR_R11 0x7d6802a6 /* mflr %11 */
211 /* ld %2,(0b-1b)(%11) */
212 #define MTLR_R12 0x7d8803a6 /* mtlr %12 */
213 #define ADD_R11_R2_R11 0x7d625a14 /* add %11,%2,%11 */
214 /* ld %12,0(%11) */
215 /* ld %2,8(%11) */
216 /* mtctr %12 */
217 /* ld %11,16(%11) */
218 /* bctr */
219 #define MFLR_R0 0x7c0802a6 /* mflr %r0 */
220 #define MTLR_R0 0x7c0803a6 /* mtlr %r0 */
221 #define SUB_R12_R12_R11 0x7d8b6050 /* subf %r12,%r11,%r12 */
222 #define ADDI_R0_R12 0x380c0000 /* addi %r0,%r12,0 */
223 #define SRDI_R0_R0_2 0x7800f082 /* rldicl %r0,%r0,62,2 */
224
225 /* Pad with this. */
226 #define NOP 0x60000000
227
228 /* Some other nops. */
229 #define CROR_151515 0x4def7b82
230 #define CROR_313131 0x4ffffb82
231
232 /* .glink entries for the first 32k functions are two instructions. */
233 #define LI_R0_0 0x38000000 /* li %r0,0 */
234 #define B_DOT 0x48000000 /* b . */
235
236 /* After that, we need two instructions to load the index, followed by
237 a branch. */
238 #define LIS_R0_0 0x3c000000 /* lis %r0,0 */
239 #define ORI_R0_R0_0 0x60000000 /* ori %r0,%r0,0 */
240
241 /* Instructions used by the save and restore reg functions. */
242 #define STD_R0_0R1 0xf8010000 /* std %r0,0(%r1) */
243 #define STD_R0_0R12 0xf80c0000 /* std %r0,0(%r12) */
244 #define LD_R0_0R1 0xe8010000 /* ld %r0,0(%r1) */
245 #define LD_R0_0R12 0xe80c0000 /* ld %r0,0(%r12) */
246 #define STFD_FR0_0R1 0xd8010000 /* stfd %fr0,0(%r1) */
247 #define LFD_FR0_0R1 0xc8010000 /* lfd %fr0,0(%r1) */
248 #define LI_R12_0 0x39800000 /* li %r12,0 */
249 #define STVX_VR0_R12_R0 0x7c0c01ce /* stvx %v0,%r12,%r0 */
250 #define LVX_VR0_R12_R0 0x7c0c00ce /* lvx %v0,%r12,%r0 */
251 #define MTLR_R0 0x7c0803a6 /* mtlr %r0 */
252 #define BLR 0x4e800020 /* blr */
253
254 /* Since .opd is an array of descriptors and each entry will end up
255 with identical R_PPC64_RELATIVE relocs, there is really no need to
256 propagate .opd relocs; The dynamic linker should be taught to
257 relocate .opd without reloc entries. */
258 #ifndef NO_OPD_RELOCS
259 #define NO_OPD_RELOCS 0
260 #endif
261
262 #ifndef ARRAY_SIZE
263 #define ARRAY_SIZE(a) (sizeof (a) / sizeof ((a)[0]))
264 #endif
265
266 static inline int
267 abiversion (bfd *abfd)
268 {
269 return elf_elfheader (abfd)->e_flags & EF_PPC64_ABI;
270 }
271
272 static inline void
273 set_abiversion (bfd *abfd, int ver)
274 {
275 elf_elfheader (abfd)->e_flags &= ~EF_PPC64_ABI;
276 elf_elfheader (abfd)->e_flags |= ver & EF_PPC64_ABI;
277 }
278 \f
279 #define ONES(n) (((bfd_vma) 1 << ((n) - 1) << 1) - 1)
280
281 /* Relocation HOWTO's. */
282 static reloc_howto_type *ppc64_elf_howto_table[(int) R_PPC64_max];
283
284 static reloc_howto_type ppc64_elf_howto_raw[] =
285 {
286 /* This reloc does nothing. */
287 HOWTO (R_PPC64_NONE, /* type */
288 0, /* rightshift */
289 3, /* size (0 = byte, 1 = short, 2 = long) */
290 0, /* bitsize */
291 FALSE, /* pc_relative */
292 0, /* bitpos */
293 complain_overflow_dont, /* complain_on_overflow */
294 bfd_elf_generic_reloc, /* special_function */
295 "R_PPC64_NONE", /* name */
296 FALSE, /* partial_inplace */
297 0, /* src_mask */
298 0, /* dst_mask */
299 FALSE), /* pcrel_offset */
300
301 /* A standard 32 bit relocation. */
302 HOWTO (R_PPC64_ADDR32, /* type */
303 0, /* rightshift */
304 2, /* size (0 = byte, 1 = short, 2 = long) */
305 32, /* bitsize */
306 FALSE, /* pc_relative */
307 0, /* bitpos */
308 complain_overflow_bitfield, /* complain_on_overflow */
309 bfd_elf_generic_reloc, /* special_function */
310 "R_PPC64_ADDR32", /* name */
311 FALSE, /* partial_inplace */
312 0, /* src_mask */
313 0xffffffff, /* dst_mask */
314 FALSE), /* pcrel_offset */
315
316 /* An absolute 26 bit branch; the lower two bits must be zero.
317 FIXME: we don't check that, we just clear them. */
318 HOWTO (R_PPC64_ADDR24, /* type */
319 0, /* rightshift */
320 2, /* size (0 = byte, 1 = short, 2 = long) */
321 26, /* bitsize */
322 FALSE, /* pc_relative */
323 0, /* bitpos */
324 complain_overflow_bitfield, /* complain_on_overflow */
325 bfd_elf_generic_reloc, /* special_function */
326 "R_PPC64_ADDR24", /* name */
327 FALSE, /* partial_inplace */
328 0, /* src_mask */
329 0x03fffffc, /* dst_mask */
330 FALSE), /* pcrel_offset */
331
332 /* A standard 16 bit relocation. */
333 HOWTO (R_PPC64_ADDR16, /* type */
334 0, /* rightshift */
335 1, /* size (0 = byte, 1 = short, 2 = long) */
336 16, /* bitsize */
337 FALSE, /* pc_relative */
338 0, /* bitpos */
339 complain_overflow_bitfield, /* complain_on_overflow */
340 bfd_elf_generic_reloc, /* special_function */
341 "R_PPC64_ADDR16", /* name */
342 FALSE, /* partial_inplace */
343 0, /* src_mask */
344 0xffff, /* dst_mask */
345 FALSE), /* pcrel_offset */
346
347 /* A 16 bit relocation without overflow. */
348 HOWTO (R_PPC64_ADDR16_LO, /* type */
349 0, /* rightshift */
350 1, /* size (0 = byte, 1 = short, 2 = long) */
351 16, /* bitsize */
352 FALSE, /* pc_relative */
353 0, /* bitpos */
354 complain_overflow_dont,/* complain_on_overflow */
355 bfd_elf_generic_reloc, /* special_function */
356 "R_PPC64_ADDR16_LO", /* name */
357 FALSE, /* partial_inplace */
358 0, /* src_mask */
359 0xffff, /* dst_mask */
360 FALSE), /* pcrel_offset */
361
362 /* Bits 16-31 of an address. */
363 HOWTO (R_PPC64_ADDR16_HI, /* type */
364 16, /* rightshift */
365 1, /* size (0 = byte, 1 = short, 2 = long) */
366 16, /* bitsize */
367 FALSE, /* pc_relative */
368 0, /* bitpos */
369 complain_overflow_signed, /* complain_on_overflow */
370 bfd_elf_generic_reloc, /* special_function */
371 "R_PPC64_ADDR16_HI", /* name */
372 FALSE, /* partial_inplace */
373 0, /* src_mask */
374 0xffff, /* dst_mask */
375 FALSE), /* pcrel_offset */
376
377 /* Bits 16-31 of an address, plus 1 if the contents of the low 16
378 bits, treated as a signed number, is negative. */
379 HOWTO (R_PPC64_ADDR16_HA, /* type */
380 16, /* rightshift */
381 1, /* size (0 = byte, 1 = short, 2 = long) */
382 16, /* bitsize */
383 FALSE, /* pc_relative */
384 0, /* bitpos */
385 complain_overflow_signed, /* complain_on_overflow */
386 ppc64_elf_ha_reloc, /* special_function */
387 "R_PPC64_ADDR16_HA", /* name */
388 FALSE, /* partial_inplace */
389 0, /* src_mask */
390 0xffff, /* dst_mask */
391 FALSE), /* pcrel_offset */
392
393 /* An absolute 16 bit branch; the lower two bits must be zero.
394 FIXME: we don't check that, we just clear them. */
395 HOWTO (R_PPC64_ADDR14, /* type */
396 0, /* rightshift */
397 2, /* size (0 = byte, 1 = short, 2 = long) */
398 16, /* bitsize */
399 FALSE, /* pc_relative */
400 0, /* bitpos */
401 complain_overflow_signed, /* complain_on_overflow */
402 ppc64_elf_branch_reloc, /* special_function */
403 "R_PPC64_ADDR14", /* name */
404 FALSE, /* partial_inplace */
405 0, /* src_mask */
406 0x0000fffc, /* dst_mask */
407 FALSE), /* pcrel_offset */
408
409 /* An absolute 16 bit branch, for which bit 10 should be set to
410 indicate that the branch is expected to be taken. The lower two
411 bits must be zero. */
412 HOWTO (R_PPC64_ADDR14_BRTAKEN, /* type */
413 0, /* rightshift */
414 2, /* size (0 = byte, 1 = short, 2 = long) */
415 16, /* bitsize */
416 FALSE, /* pc_relative */
417 0, /* bitpos */
418 complain_overflow_signed, /* complain_on_overflow */
419 ppc64_elf_brtaken_reloc, /* special_function */
420 "R_PPC64_ADDR14_BRTAKEN",/* name */
421 FALSE, /* partial_inplace */
422 0, /* src_mask */
423 0x0000fffc, /* dst_mask */
424 FALSE), /* pcrel_offset */
425
426 /* An absolute 16 bit branch, for which bit 10 should be set to
427 indicate that the branch is not expected to be taken. The lower
428 two bits must be zero. */
429 HOWTO (R_PPC64_ADDR14_BRNTAKEN, /* type */
430 0, /* rightshift */
431 2, /* size (0 = byte, 1 = short, 2 = long) */
432 16, /* bitsize */
433 FALSE, /* pc_relative */
434 0, /* bitpos */
435 complain_overflow_signed, /* complain_on_overflow */
436 ppc64_elf_brtaken_reloc, /* special_function */
437 "R_PPC64_ADDR14_BRNTAKEN",/* name */
438 FALSE, /* partial_inplace */
439 0, /* src_mask */
440 0x0000fffc, /* dst_mask */
441 FALSE), /* pcrel_offset */
442
443 /* A relative 26 bit branch; the lower two bits must be zero. */
444 HOWTO (R_PPC64_REL24, /* type */
445 0, /* rightshift */
446 2, /* size (0 = byte, 1 = short, 2 = long) */
447 26, /* bitsize */
448 TRUE, /* pc_relative */
449 0, /* bitpos */
450 complain_overflow_signed, /* complain_on_overflow */
451 ppc64_elf_branch_reloc, /* special_function */
452 "R_PPC64_REL24", /* name */
453 FALSE, /* partial_inplace */
454 0, /* src_mask */
455 0x03fffffc, /* dst_mask */
456 TRUE), /* pcrel_offset */
457
458 /* A variant of R_PPC64_REL24, used when r2 is not the toc pointer. */
459 HOWTO (R_PPC64_REL24_NOTOC, /* type */
460 0, /* rightshift */
461 2, /* size (0 = byte, 1 = short, 2 = long) */
462 26, /* bitsize */
463 TRUE, /* pc_relative */
464 0, /* bitpos */
465 complain_overflow_signed, /* complain_on_overflow */
466 ppc64_elf_branch_reloc, /* special_function */
467 "R_PPC64_REL24_NOTOC", /* name */
468 FALSE, /* partial_inplace */
469 0, /* src_mask */
470 0x03fffffc, /* dst_mask */
471 TRUE), /* pcrel_offset */
472
473 /* A relative 16 bit branch; the lower two bits must be zero. */
474 HOWTO (R_PPC64_REL14, /* type */
475 0, /* rightshift */
476 2, /* size (0 = byte, 1 = short, 2 = long) */
477 16, /* bitsize */
478 TRUE, /* pc_relative */
479 0, /* bitpos */
480 complain_overflow_signed, /* complain_on_overflow */
481 ppc64_elf_branch_reloc, /* special_function */
482 "R_PPC64_REL14", /* name */
483 FALSE, /* partial_inplace */
484 0, /* src_mask */
485 0x0000fffc, /* dst_mask */
486 TRUE), /* pcrel_offset */
487
488 /* A relative 16 bit branch. Bit 10 should be set to indicate that
489 the branch is expected to be taken. The lower two bits must be
490 zero. */
491 HOWTO (R_PPC64_REL14_BRTAKEN, /* type */
492 0, /* rightshift */
493 2, /* size (0 = byte, 1 = short, 2 = long) */
494 16, /* bitsize */
495 TRUE, /* pc_relative */
496 0, /* bitpos */
497 complain_overflow_signed, /* complain_on_overflow */
498 ppc64_elf_brtaken_reloc, /* special_function */
499 "R_PPC64_REL14_BRTAKEN", /* name */
500 FALSE, /* partial_inplace */
501 0, /* src_mask */
502 0x0000fffc, /* dst_mask */
503 TRUE), /* pcrel_offset */
504
505 /* A relative 16 bit branch. Bit 10 should be set to indicate that
506 the branch is not expected to be taken. The lower two bits must
507 be zero. */
508 HOWTO (R_PPC64_REL14_BRNTAKEN, /* type */
509 0, /* rightshift */
510 2, /* size (0 = byte, 1 = short, 2 = long) */
511 16, /* bitsize */
512 TRUE, /* pc_relative */
513 0, /* bitpos */
514 complain_overflow_signed, /* complain_on_overflow */
515 ppc64_elf_brtaken_reloc, /* special_function */
516 "R_PPC64_REL14_BRNTAKEN",/* name */
517 FALSE, /* partial_inplace */
518 0, /* src_mask */
519 0x0000fffc, /* dst_mask */
520 TRUE), /* pcrel_offset */
521
522 /* Like R_PPC64_ADDR16, but referring to the GOT table entry for the
523 symbol. */
524 HOWTO (R_PPC64_GOT16, /* type */
525 0, /* rightshift */
526 1, /* size (0 = byte, 1 = short, 2 = long) */
527 16, /* bitsize */
528 FALSE, /* pc_relative */
529 0, /* bitpos */
530 complain_overflow_signed, /* complain_on_overflow */
531 ppc64_elf_unhandled_reloc, /* special_function */
532 "R_PPC64_GOT16", /* name */
533 FALSE, /* partial_inplace */
534 0, /* src_mask */
535 0xffff, /* dst_mask */
536 FALSE), /* pcrel_offset */
537
538 /* Like R_PPC64_ADDR16_LO, but referring to the GOT table entry for
539 the symbol. */
540 HOWTO (R_PPC64_GOT16_LO, /* type */
541 0, /* rightshift */
542 1, /* size (0 = byte, 1 = short, 2 = long) */
543 16, /* bitsize */
544 FALSE, /* pc_relative */
545 0, /* bitpos */
546 complain_overflow_dont, /* complain_on_overflow */
547 ppc64_elf_unhandled_reloc, /* special_function */
548 "R_PPC64_GOT16_LO", /* name */
549 FALSE, /* partial_inplace */
550 0, /* src_mask */
551 0xffff, /* dst_mask */
552 FALSE), /* pcrel_offset */
553
554 /* Like R_PPC64_ADDR16_HI, but referring to the GOT table entry for
555 the symbol. */
556 HOWTO (R_PPC64_GOT16_HI, /* type */
557 16, /* rightshift */
558 1, /* size (0 = byte, 1 = short, 2 = long) */
559 16, /* bitsize */
560 FALSE, /* pc_relative */
561 0, /* bitpos */
562 complain_overflow_signed,/* complain_on_overflow */
563 ppc64_elf_unhandled_reloc, /* special_function */
564 "R_PPC64_GOT16_HI", /* name */
565 FALSE, /* partial_inplace */
566 0, /* src_mask */
567 0xffff, /* dst_mask */
568 FALSE), /* pcrel_offset */
569
570 /* Like R_PPC64_ADDR16_HA, but referring to the GOT table entry for
571 the symbol. */
572 HOWTO (R_PPC64_GOT16_HA, /* type */
573 16, /* rightshift */
574 1, /* size (0 = byte, 1 = short, 2 = long) */
575 16, /* bitsize */
576 FALSE, /* pc_relative */
577 0, /* bitpos */
578 complain_overflow_signed,/* complain_on_overflow */
579 ppc64_elf_unhandled_reloc, /* special_function */
580 "R_PPC64_GOT16_HA", /* name */
581 FALSE, /* partial_inplace */
582 0, /* src_mask */
583 0xffff, /* dst_mask */
584 FALSE), /* pcrel_offset */
585
586 /* This is used only by the dynamic linker. The symbol should exist
587 both in the object being run and in some shared library. The
588 dynamic linker copies the data addressed by the symbol from the
589 shared library into the object, because the object being
590 run has to have the data at some particular address. */
591 HOWTO (R_PPC64_COPY, /* type */
592 0, /* rightshift */
593 0, /* this one is variable size */
594 0, /* bitsize */
595 FALSE, /* pc_relative */
596 0, /* bitpos */
597 complain_overflow_dont, /* complain_on_overflow */
598 ppc64_elf_unhandled_reloc, /* special_function */
599 "R_PPC64_COPY", /* name */
600 FALSE, /* partial_inplace */
601 0, /* src_mask */
602 0, /* dst_mask */
603 FALSE), /* pcrel_offset */
604
605 /* Like R_PPC64_ADDR64, but used when setting global offset table
606 entries. */
607 HOWTO (R_PPC64_GLOB_DAT, /* type */
608 0, /* rightshift */
609 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
610 64, /* bitsize */
611 FALSE, /* pc_relative */
612 0, /* bitpos */
613 complain_overflow_dont, /* complain_on_overflow */
614 ppc64_elf_unhandled_reloc, /* special_function */
615 "R_PPC64_GLOB_DAT", /* name */
616 FALSE, /* partial_inplace */
617 0, /* src_mask */
618 ONES (64), /* dst_mask */
619 FALSE), /* pcrel_offset */
620
621 /* Created by the link editor. Marks a procedure linkage table
622 entry for a symbol. */
623 HOWTO (R_PPC64_JMP_SLOT, /* type */
624 0, /* rightshift */
625 0, /* size (0 = byte, 1 = short, 2 = long) */
626 0, /* bitsize */
627 FALSE, /* pc_relative */
628 0, /* bitpos */
629 complain_overflow_dont, /* complain_on_overflow */
630 ppc64_elf_unhandled_reloc, /* special_function */
631 "R_PPC64_JMP_SLOT", /* name */
632 FALSE, /* partial_inplace */
633 0, /* src_mask */
634 0, /* dst_mask */
635 FALSE), /* pcrel_offset */
636
637 /* Used only by the dynamic linker. When the object is run, this
638 doubleword64 is set to the load address of the object, plus the
639 addend. */
640 HOWTO (R_PPC64_RELATIVE, /* type */
641 0, /* rightshift */
642 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
643 64, /* bitsize */
644 FALSE, /* pc_relative */
645 0, /* bitpos */
646 complain_overflow_dont, /* complain_on_overflow */
647 bfd_elf_generic_reloc, /* special_function */
648 "R_PPC64_RELATIVE", /* name */
649 FALSE, /* partial_inplace */
650 0, /* src_mask */
651 ONES (64), /* dst_mask */
652 FALSE), /* pcrel_offset */
653
654 /* Like R_PPC64_ADDR32, but may be unaligned. */
655 HOWTO (R_PPC64_UADDR32, /* type */
656 0, /* rightshift */
657 2, /* size (0 = byte, 1 = short, 2 = long) */
658 32, /* bitsize */
659 FALSE, /* pc_relative */
660 0, /* bitpos */
661 complain_overflow_bitfield, /* complain_on_overflow */
662 bfd_elf_generic_reloc, /* special_function */
663 "R_PPC64_UADDR32", /* name */
664 FALSE, /* partial_inplace */
665 0, /* src_mask */
666 0xffffffff, /* dst_mask */
667 FALSE), /* pcrel_offset */
668
669 /* Like R_PPC64_ADDR16, but may be unaligned. */
670 HOWTO (R_PPC64_UADDR16, /* type */
671 0, /* rightshift */
672 1, /* size (0 = byte, 1 = short, 2 = long) */
673 16, /* bitsize */
674 FALSE, /* pc_relative */
675 0, /* bitpos */
676 complain_overflow_bitfield, /* complain_on_overflow */
677 bfd_elf_generic_reloc, /* special_function */
678 "R_PPC64_UADDR16", /* name */
679 FALSE, /* partial_inplace */
680 0, /* src_mask */
681 0xffff, /* dst_mask */
682 FALSE), /* pcrel_offset */
683
684 /* 32-bit PC relative. */
685 HOWTO (R_PPC64_REL32, /* type */
686 0, /* rightshift */
687 2, /* size (0 = byte, 1 = short, 2 = long) */
688 32, /* bitsize */
689 TRUE, /* pc_relative */
690 0, /* bitpos */
691 complain_overflow_signed, /* complain_on_overflow */
692 bfd_elf_generic_reloc, /* special_function */
693 "R_PPC64_REL32", /* name */
694 FALSE, /* partial_inplace */
695 0, /* src_mask */
696 0xffffffff, /* dst_mask */
697 TRUE), /* pcrel_offset */
698
699 /* 32-bit relocation to the symbol's procedure linkage table. */
700 HOWTO (R_PPC64_PLT32, /* type */
701 0, /* rightshift */
702 2, /* size (0 = byte, 1 = short, 2 = long) */
703 32, /* bitsize */
704 FALSE, /* pc_relative */
705 0, /* bitpos */
706 complain_overflow_bitfield, /* complain_on_overflow */
707 ppc64_elf_unhandled_reloc, /* special_function */
708 "R_PPC64_PLT32", /* name */
709 FALSE, /* partial_inplace */
710 0, /* src_mask */
711 0xffffffff, /* dst_mask */
712 FALSE), /* pcrel_offset */
713
714 /* 32-bit PC relative relocation to the symbol's procedure linkage table.
715 FIXME: R_PPC64_PLTREL32 not supported. */
716 HOWTO (R_PPC64_PLTREL32, /* type */
717 0, /* rightshift */
718 2, /* size (0 = byte, 1 = short, 2 = long) */
719 32, /* bitsize */
720 TRUE, /* pc_relative */
721 0, /* bitpos */
722 complain_overflow_signed, /* complain_on_overflow */
723 ppc64_elf_unhandled_reloc, /* special_function */
724 "R_PPC64_PLTREL32", /* name */
725 FALSE, /* partial_inplace */
726 0, /* src_mask */
727 0xffffffff, /* dst_mask */
728 TRUE), /* pcrel_offset */
729
730 /* Like R_PPC64_ADDR16_LO, but referring to the PLT table entry for
731 the symbol. */
732 HOWTO (R_PPC64_PLT16_LO, /* type */
733 0, /* rightshift */
734 1, /* size (0 = byte, 1 = short, 2 = long) */
735 16, /* bitsize */
736 FALSE, /* pc_relative */
737 0, /* bitpos */
738 complain_overflow_dont, /* complain_on_overflow */
739 ppc64_elf_unhandled_reloc, /* special_function */
740 "R_PPC64_PLT16_LO", /* name */
741 FALSE, /* partial_inplace */
742 0, /* src_mask */
743 0xffff, /* dst_mask */
744 FALSE), /* pcrel_offset */
745
746 /* Like R_PPC64_ADDR16_HI, but referring to the PLT table entry for
747 the symbol. */
748 HOWTO (R_PPC64_PLT16_HI, /* type */
749 16, /* rightshift */
750 1, /* size (0 = byte, 1 = short, 2 = long) */
751 16, /* bitsize */
752 FALSE, /* pc_relative */
753 0, /* bitpos */
754 complain_overflow_signed, /* complain_on_overflow */
755 ppc64_elf_unhandled_reloc, /* special_function */
756 "R_PPC64_PLT16_HI", /* name */
757 FALSE, /* partial_inplace */
758 0, /* src_mask */
759 0xffff, /* dst_mask */
760 FALSE), /* pcrel_offset */
761
762 /* Like R_PPC64_ADDR16_HA, but referring to the PLT table entry for
763 the symbol. */
764 HOWTO (R_PPC64_PLT16_HA, /* type */
765 16, /* rightshift */
766 1, /* size (0 = byte, 1 = short, 2 = long) */
767 16, /* bitsize */
768 FALSE, /* pc_relative */
769 0, /* bitpos */
770 complain_overflow_signed, /* complain_on_overflow */
771 ppc64_elf_unhandled_reloc, /* special_function */
772 "R_PPC64_PLT16_HA", /* name */
773 FALSE, /* partial_inplace */
774 0, /* src_mask */
775 0xffff, /* dst_mask */
776 FALSE), /* pcrel_offset */
777
778 /* 16-bit section relative relocation. */
779 HOWTO (R_PPC64_SECTOFF, /* type */
780 0, /* rightshift */
781 1, /* size (0 = byte, 1 = short, 2 = long) */
782 16, /* bitsize */
783 FALSE, /* pc_relative */
784 0, /* bitpos */
785 complain_overflow_signed, /* complain_on_overflow */
786 ppc64_elf_sectoff_reloc, /* special_function */
787 "R_PPC64_SECTOFF", /* name */
788 FALSE, /* partial_inplace */
789 0, /* src_mask */
790 0xffff, /* dst_mask */
791 FALSE), /* pcrel_offset */
792
793 /* Like R_PPC64_SECTOFF, but no overflow warning. */
794 HOWTO (R_PPC64_SECTOFF_LO, /* type */
795 0, /* rightshift */
796 1, /* size (0 = byte, 1 = short, 2 = long) */
797 16, /* bitsize */
798 FALSE, /* pc_relative */
799 0, /* bitpos */
800 complain_overflow_dont, /* complain_on_overflow */
801 ppc64_elf_sectoff_reloc, /* special_function */
802 "R_PPC64_SECTOFF_LO", /* name */
803 FALSE, /* partial_inplace */
804 0, /* src_mask */
805 0xffff, /* dst_mask */
806 FALSE), /* pcrel_offset */
807
808 /* 16-bit upper half section relative relocation. */
809 HOWTO (R_PPC64_SECTOFF_HI, /* type */
810 16, /* rightshift */
811 1, /* size (0 = byte, 1 = short, 2 = long) */
812 16, /* bitsize */
813 FALSE, /* pc_relative */
814 0, /* bitpos */
815 complain_overflow_signed, /* complain_on_overflow */
816 ppc64_elf_sectoff_reloc, /* special_function */
817 "R_PPC64_SECTOFF_HI", /* name */
818 FALSE, /* partial_inplace */
819 0, /* src_mask */
820 0xffff, /* dst_mask */
821 FALSE), /* pcrel_offset */
822
823 /* 16-bit upper half adjusted section relative relocation. */
824 HOWTO (R_PPC64_SECTOFF_HA, /* type */
825 16, /* rightshift */
826 1, /* size (0 = byte, 1 = short, 2 = long) */
827 16, /* bitsize */
828 FALSE, /* pc_relative */
829 0, /* bitpos */
830 complain_overflow_signed, /* complain_on_overflow */
831 ppc64_elf_sectoff_ha_reloc, /* special_function */
832 "R_PPC64_SECTOFF_HA", /* name */
833 FALSE, /* partial_inplace */
834 0, /* src_mask */
835 0xffff, /* dst_mask */
836 FALSE), /* pcrel_offset */
837
838 /* Like R_PPC64_REL24 without touching the two least significant bits. */
839 HOWTO (R_PPC64_REL30, /* type */
840 2, /* rightshift */
841 2, /* size (0 = byte, 1 = short, 2 = long) */
842 30, /* bitsize */
843 TRUE, /* pc_relative */
844 0, /* bitpos */
845 complain_overflow_dont, /* complain_on_overflow */
846 bfd_elf_generic_reloc, /* special_function */
847 "R_PPC64_REL30", /* name */
848 FALSE, /* partial_inplace */
849 0, /* src_mask */
850 0xfffffffc, /* dst_mask */
851 TRUE), /* pcrel_offset */
852
853 /* Relocs in the 64-bit PowerPC ELF ABI, not in the 32-bit ABI. */
854
855 /* A standard 64-bit relocation. */
856 HOWTO (R_PPC64_ADDR64, /* type */
857 0, /* rightshift */
858 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
859 64, /* bitsize */
860 FALSE, /* pc_relative */
861 0, /* bitpos */
862 complain_overflow_dont, /* complain_on_overflow */
863 bfd_elf_generic_reloc, /* special_function */
864 "R_PPC64_ADDR64", /* name */
865 FALSE, /* partial_inplace */
866 0, /* src_mask */
867 ONES (64), /* dst_mask */
868 FALSE), /* pcrel_offset */
869
870 /* The bits 32-47 of an address. */
871 HOWTO (R_PPC64_ADDR16_HIGHER, /* type */
872 32, /* rightshift */
873 1, /* size (0 = byte, 1 = short, 2 = long) */
874 16, /* bitsize */
875 FALSE, /* pc_relative */
876 0, /* bitpos */
877 complain_overflow_dont, /* complain_on_overflow */
878 bfd_elf_generic_reloc, /* special_function */
879 "R_PPC64_ADDR16_HIGHER", /* name */
880 FALSE, /* partial_inplace */
881 0, /* src_mask */
882 0xffff, /* dst_mask */
883 FALSE), /* pcrel_offset */
884
885 /* The bits 32-47 of an address, plus 1 if the contents of the low
886 16 bits, treated as a signed number, is negative. */
887 HOWTO (R_PPC64_ADDR16_HIGHERA, /* type */
888 32, /* rightshift */
889 1, /* size (0 = byte, 1 = short, 2 = long) */
890 16, /* bitsize */
891 FALSE, /* pc_relative */
892 0, /* bitpos */
893 complain_overflow_dont, /* complain_on_overflow */
894 ppc64_elf_ha_reloc, /* special_function */
895 "R_PPC64_ADDR16_HIGHERA", /* name */
896 FALSE, /* partial_inplace */
897 0, /* src_mask */
898 0xffff, /* dst_mask */
899 FALSE), /* pcrel_offset */
900
901 /* The bits 48-63 of an address. */
902 HOWTO (R_PPC64_ADDR16_HIGHEST,/* type */
903 48, /* rightshift */
904 1, /* size (0 = byte, 1 = short, 2 = long) */
905 16, /* bitsize */
906 FALSE, /* pc_relative */
907 0, /* bitpos */
908 complain_overflow_dont, /* complain_on_overflow */
909 bfd_elf_generic_reloc, /* special_function */
910 "R_PPC64_ADDR16_HIGHEST", /* name */
911 FALSE, /* partial_inplace */
912 0, /* src_mask */
913 0xffff, /* dst_mask */
914 FALSE), /* pcrel_offset */
915
916 /* The bits 48-63 of an address, plus 1 if the contents of the low
917 16 bits, treated as a signed number, is negative. */
918 HOWTO (R_PPC64_ADDR16_HIGHESTA,/* type */
919 48, /* rightshift */
920 1, /* size (0 = byte, 1 = short, 2 = long) */
921 16, /* bitsize */
922 FALSE, /* pc_relative */
923 0, /* bitpos */
924 complain_overflow_dont, /* complain_on_overflow */
925 ppc64_elf_ha_reloc, /* special_function */
926 "R_PPC64_ADDR16_HIGHESTA", /* name */
927 FALSE, /* partial_inplace */
928 0, /* src_mask */
929 0xffff, /* dst_mask */
930 FALSE), /* pcrel_offset */
931
932 /* Like ADDR64, but may be unaligned. */
933 HOWTO (R_PPC64_UADDR64, /* type */
934 0, /* rightshift */
935 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
936 64, /* bitsize */
937 FALSE, /* pc_relative */
938 0, /* bitpos */
939 complain_overflow_dont, /* complain_on_overflow */
940 bfd_elf_generic_reloc, /* special_function */
941 "R_PPC64_UADDR64", /* name */
942 FALSE, /* partial_inplace */
943 0, /* src_mask */
944 ONES (64), /* dst_mask */
945 FALSE), /* pcrel_offset */
946
947 /* 64-bit relative relocation. */
948 HOWTO (R_PPC64_REL64, /* type */
949 0, /* rightshift */
950 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
951 64, /* bitsize */
952 TRUE, /* pc_relative */
953 0, /* bitpos */
954 complain_overflow_dont, /* complain_on_overflow */
955 bfd_elf_generic_reloc, /* special_function */
956 "R_PPC64_REL64", /* name */
957 FALSE, /* partial_inplace */
958 0, /* src_mask */
959 ONES (64), /* dst_mask */
960 TRUE), /* pcrel_offset */
961
962 /* 64-bit relocation to the symbol's procedure linkage table. */
963 HOWTO (R_PPC64_PLT64, /* type */
964 0, /* rightshift */
965 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
966 64, /* bitsize */
967 FALSE, /* pc_relative */
968 0, /* bitpos */
969 complain_overflow_dont, /* complain_on_overflow */
970 ppc64_elf_unhandled_reloc, /* special_function */
971 "R_PPC64_PLT64", /* name */
972 FALSE, /* partial_inplace */
973 0, /* src_mask */
974 ONES (64), /* dst_mask */
975 FALSE), /* pcrel_offset */
976
977 /* 64-bit PC relative relocation to the symbol's procedure linkage
978 table. */
979 /* FIXME: R_PPC64_PLTREL64 not supported. */
980 HOWTO (R_PPC64_PLTREL64, /* type */
981 0, /* rightshift */
982 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
983 64, /* bitsize */
984 TRUE, /* pc_relative */
985 0, /* bitpos */
986 complain_overflow_dont, /* complain_on_overflow */
987 ppc64_elf_unhandled_reloc, /* special_function */
988 "R_PPC64_PLTREL64", /* name */
989 FALSE, /* partial_inplace */
990 0, /* src_mask */
991 ONES (64), /* dst_mask */
992 TRUE), /* pcrel_offset */
993
994 /* 16 bit TOC-relative relocation. */
995
996 /* R_PPC64_TOC16 47 half16* S + A - .TOC. */
997 HOWTO (R_PPC64_TOC16, /* type */
998 0, /* rightshift */
999 1, /* size (0 = byte, 1 = short, 2 = long) */
1000 16, /* bitsize */
1001 FALSE, /* pc_relative */
1002 0, /* bitpos */
1003 complain_overflow_signed, /* complain_on_overflow */
1004 ppc64_elf_toc_reloc, /* special_function */
1005 "R_PPC64_TOC16", /* name */
1006 FALSE, /* partial_inplace */
1007 0, /* src_mask */
1008 0xffff, /* dst_mask */
1009 FALSE), /* pcrel_offset */
1010
1011 /* 16 bit TOC-relative relocation without overflow. */
1012
1013 /* R_PPC64_TOC16_LO 48 half16 #lo (S + A - .TOC.) */
1014 HOWTO (R_PPC64_TOC16_LO, /* type */
1015 0, /* rightshift */
1016 1, /* size (0 = byte, 1 = short, 2 = long) */
1017 16, /* bitsize */
1018 FALSE, /* pc_relative */
1019 0, /* bitpos */
1020 complain_overflow_dont, /* complain_on_overflow */
1021 ppc64_elf_toc_reloc, /* special_function */
1022 "R_PPC64_TOC16_LO", /* name */
1023 FALSE, /* partial_inplace */
1024 0, /* src_mask */
1025 0xffff, /* dst_mask */
1026 FALSE), /* pcrel_offset */
1027
1028 /* 16 bit TOC-relative relocation, high 16 bits. */
1029
1030 /* R_PPC64_TOC16_HI 49 half16 #hi (S + A - .TOC.) */
1031 HOWTO (R_PPC64_TOC16_HI, /* type */
1032 16, /* rightshift */
1033 1, /* size (0 = byte, 1 = short, 2 = long) */
1034 16, /* bitsize */
1035 FALSE, /* pc_relative */
1036 0, /* bitpos */
1037 complain_overflow_signed, /* complain_on_overflow */
1038 ppc64_elf_toc_reloc, /* special_function */
1039 "R_PPC64_TOC16_HI", /* name */
1040 FALSE, /* partial_inplace */
1041 0, /* src_mask */
1042 0xffff, /* dst_mask */
1043 FALSE), /* pcrel_offset */
1044
1045 /* 16 bit TOC-relative relocation, high 16 bits, plus 1 if the
1046 contents of the low 16 bits, treated as a signed number, is
1047 negative. */
1048
1049 /* R_PPC64_TOC16_HA 50 half16 #ha (S + A - .TOC.) */
1050 HOWTO (R_PPC64_TOC16_HA, /* type */
1051 16, /* rightshift */
1052 1, /* size (0 = byte, 1 = short, 2 = long) */
1053 16, /* bitsize */
1054 FALSE, /* pc_relative */
1055 0, /* bitpos */
1056 complain_overflow_signed, /* complain_on_overflow */
1057 ppc64_elf_toc_ha_reloc, /* special_function */
1058 "R_PPC64_TOC16_HA", /* name */
1059 FALSE, /* partial_inplace */
1060 0, /* src_mask */
1061 0xffff, /* dst_mask */
1062 FALSE), /* pcrel_offset */
1063
1064 /* 64-bit relocation; insert value of TOC base (.TOC.). */
1065
1066 /* R_PPC64_TOC 51 doubleword64 .TOC. */
1067 HOWTO (R_PPC64_TOC, /* type */
1068 0, /* rightshift */
1069 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1070 64, /* bitsize */
1071 FALSE, /* pc_relative */
1072 0, /* bitpos */
1073 complain_overflow_dont, /* complain_on_overflow */
1074 ppc64_elf_toc64_reloc, /* special_function */
1075 "R_PPC64_TOC", /* name */
1076 FALSE, /* partial_inplace */
1077 0, /* src_mask */
1078 ONES (64), /* dst_mask */
1079 FALSE), /* pcrel_offset */
1080
1081 /* Like R_PPC64_GOT16, but also informs the link editor that the
1082 value to relocate may (!) refer to a PLT entry which the link
1083 editor (a) may replace with the symbol value. If the link editor
1084 is unable to fully resolve the symbol, it may (b) create a PLT
1085 entry and store the address to the new PLT entry in the GOT.
1086 This permits lazy resolution of function symbols at run time.
1087 The link editor may also skip all of this and just (c) emit a
1088 R_PPC64_GLOB_DAT to tie the symbol to the GOT entry. */
1089 /* FIXME: R_PPC64_PLTGOT16 not implemented. */
1090 HOWTO (R_PPC64_PLTGOT16, /* type */
1091 0, /* rightshift */
1092 1, /* size (0 = byte, 1 = short, 2 = long) */
1093 16, /* bitsize */
1094 FALSE, /* pc_relative */
1095 0, /* bitpos */
1096 complain_overflow_signed, /* complain_on_overflow */
1097 ppc64_elf_unhandled_reloc, /* special_function */
1098 "R_PPC64_PLTGOT16", /* name */
1099 FALSE, /* partial_inplace */
1100 0, /* src_mask */
1101 0xffff, /* dst_mask */
1102 FALSE), /* pcrel_offset */
1103
1104 /* Like R_PPC64_PLTGOT16, but without overflow. */
1105 /* FIXME: R_PPC64_PLTGOT16_LO not implemented. */
1106 HOWTO (R_PPC64_PLTGOT16_LO, /* type */
1107 0, /* rightshift */
1108 1, /* size (0 = byte, 1 = short, 2 = long) */
1109 16, /* bitsize */
1110 FALSE, /* pc_relative */
1111 0, /* bitpos */
1112 complain_overflow_dont, /* complain_on_overflow */
1113 ppc64_elf_unhandled_reloc, /* special_function */
1114 "R_PPC64_PLTGOT16_LO", /* name */
1115 FALSE, /* partial_inplace */
1116 0, /* src_mask */
1117 0xffff, /* dst_mask */
1118 FALSE), /* pcrel_offset */
1119
1120 /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address. */
1121 /* FIXME: R_PPC64_PLTGOT16_HI not implemented. */
1122 HOWTO (R_PPC64_PLTGOT16_HI, /* type */
1123 16, /* rightshift */
1124 1, /* size (0 = byte, 1 = short, 2 = long) */
1125 16, /* bitsize */
1126 FALSE, /* pc_relative */
1127 0, /* bitpos */
1128 complain_overflow_signed, /* complain_on_overflow */
1129 ppc64_elf_unhandled_reloc, /* special_function */
1130 "R_PPC64_PLTGOT16_HI", /* name */
1131 FALSE, /* partial_inplace */
1132 0, /* src_mask */
1133 0xffff, /* dst_mask */
1134 FALSE), /* pcrel_offset */
1135
1136 /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address, plus
1137 1 if the contents of the low 16 bits, treated as a signed number,
1138 is negative. */
1139 /* FIXME: R_PPC64_PLTGOT16_HA not implemented. */
1140 HOWTO (R_PPC64_PLTGOT16_HA, /* type */
1141 16, /* rightshift */
1142 1, /* size (0 = byte, 1 = short, 2 = long) */
1143 16, /* bitsize */
1144 FALSE, /* pc_relative */
1145 0, /* bitpos */
1146 complain_overflow_signed, /* complain_on_overflow */
1147 ppc64_elf_unhandled_reloc, /* special_function */
1148 "R_PPC64_PLTGOT16_HA", /* name */
1149 FALSE, /* partial_inplace */
1150 0, /* src_mask */
1151 0xffff, /* dst_mask */
1152 FALSE), /* pcrel_offset */
1153
1154 /* Like R_PPC64_ADDR16, but for instructions with a DS field. */
1155 HOWTO (R_PPC64_ADDR16_DS, /* type */
1156 0, /* rightshift */
1157 1, /* size (0 = byte, 1 = short, 2 = long) */
1158 16, /* bitsize */
1159 FALSE, /* pc_relative */
1160 0, /* bitpos */
1161 complain_overflow_signed, /* complain_on_overflow */
1162 bfd_elf_generic_reloc, /* special_function */
1163 "R_PPC64_ADDR16_DS", /* name */
1164 FALSE, /* partial_inplace */
1165 0, /* src_mask */
1166 0xfffc, /* dst_mask */
1167 FALSE), /* pcrel_offset */
1168
1169 /* Like R_PPC64_ADDR16_LO, but for instructions with a DS field. */
1170 HOWTO (R_PPC64_ADDR16_LO_DS, /* type */
1171 0, /* rightshift */
1172 1, /* size (0 = byte, 1 = short, 2 = long) */
1173 16, /* bitsize */
1174 FALSE, /* pc_relative */
1175 0, /* bitpos */
1176 complain_overflow_dont,/* complain_on_overflow */
1177 bfd_elf_generic_reloc, /* special_function */
1178 "R_PPC64_ADDR16_LO_DS",/* name */
1179 FALSE, /* partial_inplace */
1180 0, /* src_mask */
1181 0xfffc, /* dst_mask */
1182 FALSE), /* pcrel_offset */
1183
1184 /* Like R_PPC64_GOT16, but for instructions with a DS field. */
1185 HOWTO (R_PPC64_GOT16_DS, /* type */
1186 0, /* rightshift */
1187 1, /* size (0 = byte, 1 = short, 2 = long) */
1188 16, /* bitsize */
1189 FALSE, /* pc_relative */
1190 0, /* bitpos */
1191 complain_overflow_signed, /* complain_on_overflow */
1192 ppc64_elf_unhandled_reloc, /* special_function */
1193 "R_PPC64_GOT16_DS", /* name */
1194 FALSE, /* partial_inplace */
1195 0, /* src_mask */
1196 0xfffc, /* dst_mask */
1197 FALSE), /* pcrel_offset */
1198
1199 /* Like R_PPC64_GOT16_LO, but for instructions with a DS field. */
1200 HOWTO (R_PPC64_GOT16_LO_DS, /* type */
1201 0, /* rightshift */
1202 1, /* size (0 = byte, 1 = short, 2 = long) */
1203 16, /* bitsize */
1204 FALSE, /* pc_relative */
1205 0, /* bitpos */
1206 complain_overflow_dont, /* complain_on_overflow */
1207 ppc64_elf_unhandled_reloc, /* special_function */
1208 "R_PPC64_GOT16_LO_DS", /* name */
1209 FALSE, /* partial_inplace */
1210 0, /* src_mask */
1211 0xfffc, /* dst_mask */
1212 FALSE), /* pcrel_offset */
1213
1214 /* Like R_PPC64_PLT16_LO, but for instructions with a DS field. */
1215 HOWTO (R_PPC64_PLT16_LO_DS, /* type */
1216 0, /* rightshift */
1217 1, /* size (0 = byte, 1 = short, 2 = long) */
1218 16, /* bitsize */
1219 FALSE, /* pc_relative */
1220 0, /* bitpos */
1221 complain_overflow_dont, /* complain_on_overflow */
1222 ppc64_elf_unhandled_reloc, /* special_function */
1223 "R_PPC64_PLT16_LO_DS", /* name */
1224 FALSE, /* partial_inplace */
1225 0, /* src_mask */
1226 0xfffc, /* dst_mask */
1227 FALSE), /* pcrel_offset */
1228
1229 /* Like R_PPC64_SECTOFF, but for instructions with a DS field. */
1230 HOWTO (R_PPC64_SECTOFF_DS, /* type */
1231 0, /* rightshift */
1232 1, /* size (0 = byte, 1 = short, 2 = long) */
1233 16, /* bitsize */
1234 FALSE, /* pc_relative */
1235 0, /* bitpos */
1236 complain_overflow_signed, /* complain_on_overflow */
1237 ppc64_elf_sectoff_reloc, /* special_function */
1238 "R_PPC64_SECTOFF_DS", /* name */
1239 FALSE, /* partial_inplace */
1240 0, /* src_mask */
1241 0xfffc, /* dst_mask */
1242 FALSE), /* pcrel_offset */
1243
1244 /* Like R_PPC64_SECTOFF_LO, but for instructions with a DS field. */
1245 HOWTO (R_PPC64_SECTOFF_LO_DS, /* type */
1246 0, /* rightshift */
1247 1, /* size (0 = byte, 1 = short, 2 = long) */
1248 16, /* bitsize */
1249 FALSE, /* pc_relative */
1250 0, /* bitpos */
1251 complain_overflow_dont, /* complain_on_overflow */
1252 ppc64_elf_sectoff_reloc, /* special_function */
1253 "R_PPC64_SECTOFF_LO_DS",/* name */
1254 FALSE, /* partial_inplace */
1255 0, /* src_mask */
1256 0xfffc, /* dst_mask */
1257 FALSE), /* pcrel_offset */
1258
1259 /* Like R_PPC64_TOC16, but for instructions with a DS field. */
1260 HOWTO (R_PPC64_TOC16_DS, /* type */
1261 0, /* rightshift */
1262 1, /* size (0 = byte, 1 = short, 2 = long) */
1263 16, /* bitsize */
1264 FALSE, /* pc_relative */
1265 0, /* bitpos */
1266 complain_overflow_signed, /* complain_on_overflow */
1267 ppc64_elf_toc_reloc, /* special_function */
1268 "R_PPC64_TOC16_DS", /* name */
1269 FALSE, /* partial_inplace */
1270 0, /* src_mask */
1271 0xfffc, /* dst_mask */
1272 FALSE), /* pcrel_offset */
1273
1274 /* Like R_PPC64_TOC16_LO, but for instructions with a DS field. */
1275 HOWTO (R_PPC64_TOC16_LO_DS, /* type */
1276 0, /* rightshift */
1277 1, /* size (0 = byte, 1 = short, 2 = long) */
1278 16, /* bitsize */
1279 FALSE, /* pc_relative */
1280 0, /* bitpos */
1281 complain_overflow_dont, /* complain_on_overflow */
1282 ppc64_elf_toc_reloc, /* special_function */
1283 "R_PPC64_TOC16_LO_DS", /* name */
1284 FALSE, /* partial_inplace */
1285 0, /* src_mask */
1286 0xfffc, /* dst_mask */
1287 FALSE), /* pcrel_offset */
1288
1289 /* Like R_PPC64_PLTGOT16, but for instructions with a DS field. */
1290 /* FIXME: R_PPC64_PLTGOT16_DS not implemented. */
1291 HOWTO (R_PPC64_PLTGOT16_DS, /* type */
1292 0, /* rightshift */
1293 1, /* size (0 = byte, 1 = short, 2 = long) */
1294 16, /* bitsize */
1295 FALSE, /* pc_relative */
1296 0, /* bitpos */
1297 complain_overflow_signed, /* complain_on_overflow */
1298 ppc64_elf_unhandled_reloc, /* special_function */
1299 "R_PPC64_PLTGOT16_DS", /* name */
1300 FALSE, /* partial_inplace */
1301 0, /* src_mask */
1302 0xfffc, /* dst_mask */
1303 FALSE), /* pcrel_offset */
1304
1305 /* Like R_PPC64_PLTGOT16_LO, but for instructions with a DS field. */
1306 /* FIXME: R_PPC64_PLTGOT16_LO not implemented. */
1307 HOWTO (R_PPC64_PLTGOT16_LO_DS,/* type */
1308 0, /* rightshift */
1309 1, /* size (0 = byte, 1 = short, 2 = long) */
1310 16, /* bitsize */
1311 FALSE, /* pc_relative */
1312 0, /* bitpos */
1313 complain_overflow_dont, /* complain_on_overflow */
1314 ppc64_elf_unhandled_reloc, /* special_function */
1315 "R_PPC64_PLTGOT16_LO_DS",/* name */
1316 FALSE, /* partial_inplace */
1317 0, /* src_mask */
1318 0xfffc, /* dst_mask */
1319 FALSE), /* pcrel_offset */
1320
1321 /* Marker relocs for TLS. */
1322 HOWTO (R_PPC64_TLS,
1323 0, /* rightshift */
1324 2, /* size (0 = byte, 1 = short, 2 = long) */
1325 32, /* bitsize */
1326 FALSE, /* pc_relative */
1327 0, /* bitpos */
1328 complain_overflow_dont, /* complain_on_overflow */
1329 bfd_elf_generic_reloc, /* special_function */
1330 "R_PPC64_TLS", /* name */
1331 FALSE, /* partial_inplace */
1332 0, /* src_mask */
1333 0, /* dst_mask */
1334 FALSE), /* pcrel_offset */
1335
1336 HOWTO (R_PPC64_TLSGD,
1337 0, /* rightshift */
1338 2, /* size (0 = byte, 1 = short, 2 = long) */
1339 32, /* bitsize */
1340 FALSE, /* pc_relative */
1341 0, /* bitpos */
1342 complain_overflow_dont, /* complain_on_overflow */
1343 bfd_elf_generic_reloc, /* special_function */
1344 "R_PPC64_TLSGD", /* name */
1345 FALSE, /* partial_inplace */
1346 0, /* src_mask */
1347 0, /* dst_mask */
1348 FALSE), /* pcrel_offset */
1349
1350 HOWTO (R_PPC64_TLSLD,
1351 0, /* rightshift */
1352 2, /* size (0 = byte, 1 = short, 2 = long) */
1353 32, /* bitsize */
1354 FALSE, /* pc_relative */
1355 0, /* bitpos */
1356 complain_overflow_dont, /* complain_on_overflow */
1357 bfd_elf_generic_reloc, /* special_function */
1358 "R_PPC64_TLSLD", /* name */
1359 FALSE, /* partial_inplace */
1360 0, /* src_mask */
1361 0, /* dst_mask */
1362 FALSE), /* pcrel_offset */
1363
1364 /* Marker reloc for optimizing r2 save in prologue rather than on
1365 each plt call stub. */
1366 HOWTO (R_PPC64_TOCSAVE,
1367 0, /* rightshift */
1368 2, /* size (0 = byte, 1 = short, 2 = long) */
1369 32, /* bitsize */
1370 FALSE, /* pc_relative */
1371 0, /* bitpos */
1372 complain_overflow_dont, /* complain_on_overflow */
1373 bfd_elf_generic_reloc, /* special_function */
1374 "R_PPC64_TOCSAVE", /* name */
1375 FALSE, /* partial_inplace */
1376 0, /* src_mask */
1377 0, /* dst_mask */
1378 FALSE), /* pcrel_offset */
1379
1380 /* Marker relocs on inline plt call instructions. */
1381 HOWTO (R_PPC64_PLTSEQ,
1382 0, /* rightshift */
1383 2, /* size (0 = byte, 1 = short, 2 = long) */
1384 32, /* bitsize */
1385 FALSE, /* pc_relative */
1386 0, /* bitpos */
1387 complain_overflow_dont, /* complain_on_overflow */
1388 bfd_elf_generic_reloc, /* special_function */
1389 "R_PPC64_PLTSEQ", /* name */
1390 FALSE, /* partial_inplace */
1391 0, /* src_mask */
1392 0, /* dst_mask */
1393 FALSE), /* pcrel_offset */
1394
1395 HOWTO (R_PPC64_PLTCALL,
1396 0, /* rightshift */
1397 2, /* size (0 = byte, 1 = short, 2 = long) */
1398 32, /* bitsize */
1399 FALSE, /* pc_relative */
1400 0, /* bitpos */
1401 complain_overflow_dont, /* complain_on_overflow */
1402 bfd_elf_generic_reloc, /* special_function */
1403 "R_PPC64_PLTCALL", /* name */
1404 FALSE, /* partial_inplace */
1405 0, /* src_mask */
1406 0, /* dst_mask */
1407 FALSE), /* pcrel_offset */
1408
1409 /* Computes the load module index of the load module that contains the
1410 definition of its TLS sym. */
1411 HOWTO (R_PPC64_DTPMOD64,
1412 0, /* rightshift */
1413 4, /* size (0 = byte, 1 = short, 2 = long) */
1414 64, /* bitsize */
1415 FALSE, /* pc_relative */
1416 0, /* bitpos */
1417 complain_overflow_dont, /* complain_on_overflow */
1418 ppc64_elf_unhandled_reloc, /* special_function */
1419 "R_PPC64_DTPMOD64", /* name */
1420 FALSE, /* partial_inplace */
1421 0, /* src_mask */
1422 ONES (64), /* dst_mask */
1423 FALSE), /* pcrel_offset */
1424
1425 /* Computes a dtv-relative displacement, the difference between the value
1426 of sym+add and the base address of the thread-local storage block that
1427 contains the definition of sym, minus 0x8000. */
1428 HOWTO (R_PPC64_DTPREL64,
1429 0, /* rightshift */
1430 4, /* size (0 = byte, 1 = short, 2 = long) */
1431 64, /* bitsize */
1432 FALSE, /* pc_relative */
1433 0, /* bitpos */
1434 complain_overflow_dont, /* complain_on_overflow */
1435 ppc64_elf_unhandled_reloc, /* special_function */
1436 "R_PPC64_DTPREL64", /* name */
1437 FALSE, /* partial_inplace */
1438 0, /* src_mask */
1439 ONES (64), /* dst_mask */
1440 FALSE), /* pcrel_offset */
1441
1442 /* A 16 bit dtprel reloc. */
1443 HOWTO (R_PPC64_DTPREL16,
1444 0, /* rightshift */
1445 1, /* size (0 = byte, 1 = short, 2 = long) */
1446 16, /* bitsize */
1447 FALSE, /* pc_relative */
1448 0, /* bitpos */
1449 complain_overflow_signed, /* complain_on_overflow */
1450 ppc64_elf_unhandled_reloc, /* special_function */
1451 "R_PPC64_DTPREL16", /* name */
1452 FALSE, /* partial_inplace */
1453 0, /* src_mask */
1454 0xffff, /* dst_mask */
1455 FALSE), /* pcrel_offset */
1456
1457 /* Like DTPREL16, but no overflow. */
1458 HOWTO (R_PPC64_DTPREL16_LO,
1459 0, /* rightshift */
1460 1, /* size (0 = byte, 1 = short, 2 = long) */
1461 16, /* bitsize */
1462 FALSE, /* pc_relative */
1463 0, /* bitpos */
1464 complain_overflow_dont, /* complain_on_overflow */
1465 ppc64_elf_unhandled_reloc, /* special_function */
1466 "R_PPC64_DTPREL16_LO", /* name */
1467 FALSE, /* partial_inplace */
1468 0, /* src_mask */
1469 0xffff, /* dst_mask */
1470 FALSE), /* pcrel_offset */
1471
1472 /* Like DTPREL16_LO, but next higher group of 16 bits. */
1473 HOWTO (R_PPC64_DTPREL16_HI,
1474 16, /* rightshift */
1475 1, /* size (0 = byte, 1 = short, 2 = long) */
1476 16, /* bitsize */
1477 FALSE, /* pc_relative */
1478 0, /* bitpos */
1479 complain_overflow_signed, /* complain_on_overflow */
1480 ppc64_elf_unhandled_reloc, /* special_function */
1481 "R_PPC64_DTPREL16_HI", /* name */
1482 FALSE, /* partial_inplace */
1483 0, /* src_mask */
1484 0xffff, /* dst_mask */
1485 FALSE), /* pcrel_offset */
1486
1487 /* Like DTPREL16_HI, but adjust for low 16 bits. */
1488 HOWTO (R_PPC64_DTPREL16_HA,
1489 16, /* rightshift */
1490 1, /* size (0 = byte, 1 = short, 2 = long) */
1491 16, /* bitsize */
1492 FALSE, /* pc_relative */
1493 0, /* bitpos */
1494 complain_overflow_signed, /* complain_on_overflow */
1495 ppc64_elf_unhandled_reloc, /* special_function */
1496 "R_PPC64_DTPREL16_HA", /* name */
1497 FALSE, /* partial_inplace */
1498 0, /* src_mask */
1499 0xffff, /* dst_mask */
1500 FALSE), /* pcrel_offset */
1501
1502 /* Like DTPREL16_HI, but next higher group of 16 bits. */
1503 HOWTO (R_PPC64_DTPREL16_HIGHER,
1504 32, /* rightshift */
1505 1, /* size (0 = byte, 1 = short, 2 = long) */
1506 16, /* bitsize */
1507 FALSE, /* pc_relative */
1508 0, /* bitpos */
1509 complain_overflow_dont, /* complain_on_overflow */
1510 ppc64_elf_unhandled_reloc, /* special_function */
1511 "R_PPC64_DTPREL16_HIGHER", /* name */
1512 FALSE, /* partial_inplace */
1513 0, /* src_mask */
1514 0xffff, /* dst_mask */
1515 FALSE), /* pcrel_offset */
1516
1517 /* Like DTPREL16_HIGHER, but adjust for low 16 bits. */
1518 HOWTO (R_PPC64_DTPREL16_HIGHERA,
1519 32, /* rightshift */
1520 1, /* size (0 = byte, 1 = short, 2 = long) */
1521 16, /* bitsize */
1522 FALSE, /* pc_relative */
1523 0, /* bitpos */
1524 complain_overflow_dont, /* complain_on_overflow */
1525 ppc64_elf_unhandled_reloc, /* special_function */
1526 "R_PPC64_DTPREL16_HIGHERA", /* name */
1527 FALSE, /* partial_inplace */
1528 0, /* src_mask */
1529 0xffff, /* dst_mask */
1530 FALSE), /* pcrel_offset */
1531
1532 /* Like DTPREL16_HIGHER, but next higher group of 16 bits. */
1533 HOWTO (R_PPC64_DTPREL16_HIGHEST,
1534 48, /* rightshift */
1535 1, /* size (0 = byte, 1 = short, 2 = long) */
1536 16, /* bitsize */
1537 FALSE, /* pc_relative */
1538 0, /* bitpos */
1539 complain_overflow_dont, /* complain_on_overflow */
1540 ppc64_elf_unhandled_reloc, /* special_function */
1541 "R_PPC64_DTPREL16_HIGHEST", /* name */
1542 FALSE, /* partial_inplace */
1543 0, /* src_mask */
1544 0xffff, /* dst_mask */
1545 FALSE), /* pcrel_offset */
1546
1547 /* Like DTPREL16_HIGHEST, but adjust for low 16 bits. */
1548 HOWTO (R_PPC64_DTPREL16_HIGHESTA,
1549 48, /* rightshift */
1550 1, /* size (0 = byte, 1 = short, 2 = long) */
1551 16, /* bitsize */
1552 FALSE, /* pc_relative */
1553 0, /* bitpos */
1554 complain_overflow_dont, /* complain_on_overflow */
1555 ppc64_elf_unhandled_reloc, /* special_function */
1556 "R_PPC64_DTPREL16_HIGHESTA", /* name */
1557 FALSE, /* partial_inplace */
1558 0, /* src_mask */
1559 0xffff, /* dst_mask */
1560 FALSE), /* pcrel_offset */
1561
1562 /* Like DTPREL16, but for insns with a DS field. */
1563 HOWTO (R_PPC64_DTPREL16_DS,
1564 0, /* rightshift */
1565 1, /* size (0 = byte, 1 = short, 2 = long) */
1566 16, /* bitsize */
1567 FALSE, /* pc_relative */
1568 0, /* bitpos */
1569 complain_overflow_signed, /* complain_on_overflow */
1570 ppc64_elf_unhandled_reloc, /* special_function */
1571 "R_PPC64_DTPREL16_DS", /* name */
1572 FALSE, /* partial_inplace */
1573 0, /* src_mask */
1574 0xfffc, /* dst_mask */
1575 FALSE), /* pcrel_offset */
1576
1577 /* Like DTPREL16_DS, but no overflow. */
1578 HOWTO (R_PPC64_DTPREL16_LO_DS,
1579 0, /* rightshift */
1580 1, /* size (0 = byte, 1 = short, 2 = long) */
1581 16, /* bitsize */
1582 FALSE, /* pc_relative */
1583 0, /* bitpos */
1584 complain_overflow_dont, /* complain_on_overflow */
1585 ppc64_elf_unhandled_reloc, /* special_function */
1586 "R_PPC64_DTPREL16_LO_DS", /* name */
1587 FALSE, /* partial_inplace */
1588 0, /* src_mask */
1589 0xfffc, /* dst_mask */
1590 FALSE), /* pcrel_offset */
1591
1592 /* Computes a tp-relative displacement, the difference between the value of
1593 sym+add and the value of the thread pointer (r13). */
1594 HOWTO (R_PPC64_TPREL64,
1595 0, /* rightshift */
1596 4, /* size (0 = byte, 1 = short, 2 = long) */
1597 64, /* bitsize */
1598 FALSE, /* pc_relative */
1599 0, /* bitpos */
1600 complain_overflow_dont, /* complain_on_overflow */
1601 ppc64_elf_unhandled_reloc, /* special_function */
1602 "R_PPC64_TPREL64", /* name */
1603 FALSE, /* partial_inplace */
1604 0, /* src_mask */
1605 ONES (64), /* dst_mask */
1606 FALSE), /* pcrel_offset */
1607
1608 /* A 16 bit tprel reloc. */
1609 HOWTO (R_PPC64_TPREL16,
1610 0, /* rightshift */
1611 1, /* size (0 = byte, 1 = short, 2 = long) */
1612 16, /* bitsize */
1613 FALSE, /* pc_relative */
1614 0, /* bitpos */
1615 complain_overflow_signed, /* complain_on_overflow */
1616 ppc64_elf_unhandled_reloc, /* special_function */
1617 "R_PPC64_TPREL16", /* name */
1618 FALSE, /* partial_inplace */
1619 0, /* src_mask */
1620 0xffff, /* dst_mask */
1621 FALSE), /* pcrel_offset */
1622
1623 /* Like TPREL16, but no overflow. */
1624 HOWTO (R_PPC64_TPREL16_LO,
1625 0, /* rightshift */
1626 1, /* size (0 = byte, 1 = short, 2 = long) */
1627 16, /* bitsize */
1628 FALSE, /* pc_relative */
1629 0, /* bitpos */
1630 complain_overflow_dont, /* complain_on_overflow */
1631 ppc64_elf_unhandled_reloc, /* special_function */
1632 "R_PPC64_TPREL16_LO", /* name */
1633 FALSE, /* partial_inplace */
1634 0, /* src_mask */
1635 0xffff, /* dst_mask */
1636 FALSE), /* pcrel_offset */
1637
1638 /* Like TPREL16_LO, but next higher group of 16 bits. */
1639 HOWTO (R_PPC64_TPREL16_HI,
1640 16, /* rightshift */
1641 1, /* size (0 = byte, 1 = short, 2 = long) */
1642 16, /* bitsize */
1643 FALSE, /* pc_relative */
1644 0, /* bitpos */
1645 complain_overflow_signed, /* complain_on_overflow */
1646 ppc64_elf_unhandled_reloc, /* special_function */
1647 "R_PPC64_TPREL16_HI", /* name */
1648 FALSE, /* partial_inplace */
1649 0, /* src_mask */
1650 0xffff, /* dst_mask */
1651 FALSE), /* pcrel_offset */
1652
1653 /* Like TPREL16_HI, but adjust for low 16 bits. */
1654 HOWTO (R_PPC64_TPREL16_HA,
1655 16, /* rightshift */
1656 1, /* size (0 = byte, 1 = short, 2 = long) */
1657 16, /* bitsize */
1658 FALSE, /* pc_relative */
1659 0, /* bitpos */
1660 complain_overflow_signed, /* complain_on_overflow */
1661 ppc64_elf_unhandled_reloc, /* special_function */
1662 "R_PPC64_TPREL16_HA", /* name */
1663 FALSE, /* partial_inplace */
1664 0, /* src_mask */
1665 0xffff, /* dst_mask */
1666 FALSE), /* pcrel_offset */
1667
1668 /* Like TPREL16_HI, but next higher group of 16 bits. */
1669 HOWTO (R_PPC64_TPREL16_HIGHER,
1670 32, /* rightshift */
1671 1, /* size (0 = byte, 1 = short, 2 = long) */
1672 16, /* bitsize */
1673 FALSE, /* pc_relative */
1674 0, /* bitpos */
1675 complain_overflow_dont, /* complain_on_overflow */
1676 ppc64_elf_unhandled_reloc, /* special_function */
1677 "R_PPC64_TPREL16_HIGHER", /* name */
1678 FALSE, /* partial_inplace */
1679 0, /* src_mask */
1680 0xffff, /* dst_mask */
1681 FALSE), /* pcrel_offset */
1682
1683 /* Like TPREL16_HIGHER, but adjust for low 16 bits. */
1684 HOWTO (R_PPC64_TPREL16_HIGHERA,
1685 32, /* rightshift */
1686 1, /* size (0 = byte, 1 = short, 2 = long) */
1687 16, /* bitsize */
1688 FALSE, /* pc_relative */
1689 0, /* bitpos */
1690 complain_overflow_dont, /* complain_on_overflow */
1691 ppc64_elf_unhandled_reloc, /* special_function */
1692 "R_PPC64_TPREL16_HIGHERA", /* name */
1693 FALSE, /* partial_inplace */
1694 0, /* src_mask */
1695 0xffff, /* dst_mask */
1696 FALSE), /* pcrel_offset */
1697
1698 /* Like TPREL16_HIGHER, but next higher group of 16 bits. */
1699 HOWTO (R_PPC64_TPREL16_HIGHEST,
1700 48, /* rightshift */
1701 1, /* size (0 = byte, 1 = short, 2 = long) */
1702 16, /* bitsize */
1703 FALSE, /* pc_relative */
1704 0, /* bitpos */
1705 complain_overflow_dont, /* complain_on_overflow */
1706 ppc64_elf_unhandled_reloc, /* special_function */
1707 "R_PPC64_TPREL16_HIGHEST", /* name */
1708 FALSE, /* partial_inplace */
1709 0, /* src_mask */
1710 0xffff, /* dst_mask */
1711 FALSE), /* pcrel_offset */
1712
1713 /* Like TPREL16_HIGHEST, but adjust for low 16 bits. */
1714 HOWTO (R_PPC64_TPREL16_HIGHESTA,
1715 48, /* rightshift */
1716 1, /* size (0 = byte, 1 = short, 2 = long) */
1717 16, /* bitsize */
1718 FALSE, /* pc_relative */
1719 0, /* bitpos */
1720 complain_overflow_dont, /* complain_on_overflow */
1721 ppc64_elf_unhandled_reloc, /* special_function */
1722 "R_PPC64_TPREL16_HIGHESTA", /* name */
1723 FALSE, /* partial_inplace */
1724 0, /* src_mask */
1725 0xffff, /* dst_mask */
1726 FALSE), /* pcrel_offset */
1727
1728 /* Like TPREL16, but for insns with a DS field. */
1729 HOWTO (R_PPC64_TPREL16_DS,
1730 0, /* rightshift */
1731 1, /* size (0 = byte, 1 = short, 2 = long) */
1732 16, /* bitsize */
1733 FALSE, /* pc_relative */
1734 0, /* bitpos */
1735 complain_overflow_signed, /* complain_on_overflow */
1736 ppc64_elf_unhandled_reloc, /* special_function */
1737 "R_PPC64_TPREL16_DS", /* name */
1738 FALSE, /* partial_inplace */
1739 0, /* src_mask */
1740 0xfffc, /* dst_mask */
1741 FALSE), /* pcrel_offset */
1742
1743 /* Like TPREL16_DS, but no overflow. */
1744 HOWTO (R_PPC64_TPREL16_LO_DS,
1745 0, /* rightshift */
1746 1, /* size (0 = byte, 1 = short, 2 = long) */
1747 16, /* bitsize */
1748 FALSE, /* pc_relative */
1749 0, /* bitpos */
1750 complain_overflow_dont, /* complain_on_overflow */
1751 ppc64_elf_unhandled_reloc, /* special_function */
1752 "R_PPC64_TPREL16_LO_DS", /* name */
1753 FALSE, /* partial_inplace */
1754 0, /* src_mask */
1755 0xfffc, /* dst_mask */
1756 FALSE), /* pcrel_offset */
1757
1758 /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1759 with values (sym+add)@dtpmod and (sym+add)@dtprel, and computes the offset
1760 to the first entry relative to the TOC base (r2). */
1761 HOWTO (R_PPC64_GOT_TLSGD16,
1762 0, /* rightshift */
1763 1, /* size (0 = byte, 1 = short, 2 = long) */
1764 16, /* bitsize */
1765 FALSE, /* pc_relative */
1766 0, /* bitpos */
1767 complain_overflow_signed, /* complain_on_overflow */
1768 ppc64_elf_unhandled_reloc, /* special_function */
1769 "R_PPC64_GOT_TLSGD16", /* name */
1770 FALSE, /* partial_inplace */
1771 0, /* src_mask */
1772 0xffff, /* dst_mask */
1773 FALSE), /* pcrel_offset */
1774
1775 /* Like GOT_TLSGD16, but no overflow. */
1776 HOWTO (R_PPC64_GOT_TLSGD16_LO,
1777 0, /* rightshift */
1778 1, /* size (0 = byte, 1 = short, 2 = long) */
1779 16, /* bitsize */
1780 FALSE, /* pc_relative */
1781 0, /* bitpos */
1782 complain_overflow_dont, /* complain_on_overflow */
1783 ppc64_elf_unhandled_reloc, /* special_function */
1784 "R_PPC64_GOT_TLSGD16_LO", /* name */
1785 FALSE, /* partial_inplace */
1786 0, /* src_mask */
1787 0xffff, /* dst_mask */
1788 FALSE), /* pcrel_offset */
1789
1790 /* Like GOT_TLSGD16_LO, but next higher group of 16 bits. */
1791 HOWTO (R_PPC64_GOT_TLSGD16_HI,
1792 16, /* rightshift */
1793 1, /* size (0 = byte, 1 = short, 2 = long) */
1794 16, /* bitsize */
1795 FALSE, /* pc_relative */
1796 0, /* bitpos */
1797 complain_overflow_signed, /* complain_on_overflow */
1798 ppc64_elf_unhandled_reloc, /* special_function */
1799 "R_PPC64_GOT_TLSGD16_HI", /* name */
1800 FALSE, /* partial_inplace */
1801 0, /* src_mask */
1802 0xffff, /* dst_mask */
1803 FALSE), /* pcrel_offset */
1804
1805 /* Like GOT_TLSGD16_HI, but adjust for low 16 bits. */
1806 HOWTO (R_PPC64_GOT_TLSGD16_HA,
1807 16, /* rightshift */
1808 1, /* size (0 = byte, 1 = short, 2 = long) */
1809 16, /* bitsize */
1810 FALSE, /* pc_relative */
1811 0, /* bitpos */
1812 complain_overflow_signed, /* complain_on_overflow */
1813 ppc64_elf_unhandled_reloc, /* special_function */
1814 "R_PPC64_GOT_TLSGD16_HA", /* name */
1815 FALSE, /* partial_inplace */
1816 0, /* src_mask */
1817 0xffff, /* dst_mask */
1818 FALSE), /* pcrel_offset */
1819
1820 /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1821 with values (sym+add)@dtpmod and zero, and computes the offset to the
1822 first entry relative to the TOC base (r2). */
1823 HOWTO (R_PPC64_GOT_TLSLD16,
1824 0, /* rightshift */
1825 1, /* size (0 = byte, 1 = short, 2 = long) */
1826 16, /* bitsize */
1827 FALSE, /* pc_relative */
1828 0, /* bitpos */
1829 complain_overflow_signed, /* complain_on_overflow */
1830 ppc64_elf_unhandled_reloc, /* special_function */
1831 "R_PPC64_GOT_TLSLD16", /* name */
1832 FALSE, /* partial_inplace */
1833 0, /* src_mask */
1834 0xffff, /* dst_mask */
1835 FALSE), /* pcrel_offset */
1836
1837 /* Like GOT_TLSLD16, but no overflow. */
1838 HOWTO (R_PPC64_GOT_TLSLD16_LO,
1839 0, /* rightshift */
1840 1, /* size (0 = byte, 1 = short, 2 = long) */
1841 16, /* bitsize */
1842 FALSE, /* pc_relative */
1843 0, /* bitpos */
1844 complain_overflow_dont, /* complain_on_overflow */
1845 ppc64_elf_unhandled_reloc, /* special_function */
1846 "R_PPC64_GOT_TLSLD16_LO", /* name */
1847 FALSE, /* partial_inplace */
1848 0, /* src_mask */
1849 0xffff, /* dst_mask */
1850 FALSE), /* pcrel_offset */
1851
1852 /* Like GOT_TLSLD16_LO, but next higher group of 16 bits. */
1853 HOWTO (R_PPC64_GOT_TLSLD16_HI,
1854 16, /* rightshift */
1855 1, /* size (0 = byte, 1 = short, 2 = long) */
1856 16, /* bitsize */
1857 FALSE, /* pc_relative */
1858 0, /* bitpos */
1859 complain_overflow_signed, /* complain_on_overflow */
1860 ppc64_elf_unhandled_reloc, /* special_function */
1861 "R_PPC64_GOT_TLSLD16_HI", /* name */
1862 FALSE, /* partial_inplace */
1863 0, /* src_mask */
1864 0xffff, /* dst_mask */
1865 FALSE), /* pcrel_offset */
1866
1867 /* Like GOT_TLSLD16_HI, but adjust for low 16 bits. */
1868 HOWTO (R_PPC64_GOT_TLSLD16_HA,
1869 16, /* rightshift */
1870 1, /* size (0 = byte, 1 = short, 2 = long) */
1871 16, /* bitsize */
1872 FALSE, /* pc_relative */
1873 0, /* bitpos */
1874 complain_overflow_signed, /* complain_on_overflow */
1875 ppc64_elf_unhandled_reloc, /* special_function */
1876 "R_PPC64_GOT_TLSLD16_HA", /* name */
1877 FALSE, /* partial_inplace */
1878 0, /* src_mask */
1879 0xffff, /* dst_mask */
1880 FALSE), /* pcrel_offset */
1881
1882 /* Allocates an entry in the GOT with value (sym+add)@dtprel, and computes
1883 the offset to the entry relative to the TOC base (r2). */
1884 HOWTO (R_PPC64_GOT_DTPREL16_DS,
1885 0, /* rightshift */
1886 1, /* size (0 = byte, 1 = short, 2 = long) */
1887 16, /* bitsize */
1888 FALSE, /* pc_relative */
1889 0, /* bitpos */
1890 complain_overflow_signed, /* complain_on_overflow */
1891 ppc64_elf_unhandled_reloc, /* special_function */
1892 "R_PPC64_GOT_DTPREL16_DS", /* name */
1893 FALSE, /* partial_inplace */
1894 0, /* src_mask */
1895 0xfffc, /* dst_mask */
1896 FALSE), /* pcrel_offset */
1897
1898 /* Like GOT_DTPREL16_DS, but no overflow. */
1899 HOWTO (R_PPC64_GOT_DTPREL16_LO_DS,
1900 0, /* rightshift */
1901 1, /* size (0 = byte, 1 = short, 2 = long) */
1902 16, /* bitsize */
1903 FALSE, /* pc_relative */
1904 0, /* bitpos */
1905 complain_overflow_dont, /* complain_on_overflow */
1906 ppc64_elf_unhandled_reloc, /* special_function */
1907 "R_PPC64_GOT_DTPREL16_LO_DS", /* name */
1908 FALSE, /* partial_inplace */
1909 0, /* src_mask */
1910 0xfffc, /* dst_mask */
1911 FALSE), /* pcrel_offset */
1912
1913 /* Like GOT_DTPREL16_LO_DS, but next higher group of 16 bits. */
1914 HOWTO (R_PPC64_GOT_DTPREL16_HI,
1915 16, /* rightshift */
1916 1, /* size (0 = byte, 1 = short, 2 = long) */
1917 16, /* bitsize */
1918 FALSE, /* pc_relative */
1919 0, /* bitpos */
1920 complain_overflow_signed, /* complain_on_overflow */
1921 ppc64_elf_unhandled_reloc, /* special_function */
1922 "R_PPC64_GOT_DTPREL16_HI", /* name */
1923 FALSE, /* partial_inplace */
1924 0, /* src_mask */
1925 0xffff, /* dst_mask */
1926 FALSE), /* pcrel_offset */
1927
1928 /* Like GOT_DTPREL16_HI, but adjust for low 16 bits. */
1929 HOWTO (R_PPC64_GOT_DTPREL16_HA,
1930 16, /* rightshift */
1931 1, /* size (0 = byte, 1 = short, 2 = long) */
1932 16, /* bitsize */
1933 FALSE, /* pc_relative */
1934 0, /* bitpos */
1935 complain_overflow_signed, /* complain_on_overflow */
1936 ppc64_elf_unhandled_reloc, /* special_function */
1937 "R_PPC64_GOT_DTPREL16_HA", /* name */
1938 FALSE, /* partial_inplace */
1939 0, /* src_mask */
1940 0xffff, /* dst_mask */
1941 FALSE), /* pcrel_offset */
1942
1943 /* Allocates an entry in the GOT with value (sym+add)@tprel, and computes the
1944 offset to the entry relative to the TOC base (r2). */
1945 HOWTO (R_PPC64_GOT_TPREL16_DS,
1946 0, /* rightshift */
1947 1, /* size (0 = byte, 1 = short, 2 = long) */
1948 16, /* bitsize */
1949 FALSE, /* pc_relative */
1950 0, /* bitpos */
1951 complain_overflow_signed, /* complain_on_overflow */
1952 ppc64_elf_unhandled_reloc, /* special_function */
1953 "R_PPC64_GOT_TPREL16_DS", /* name */
1954 FALSE, /* partial_inplace */
1955 0, /* src_mask */
1956 0xfffc, /* dst_mask */
1957 FALSE), /* pcrel_offset */
1958
1959 /* Like GOT_TPREL16_DS, but no overflow. */
1960 HOWTO (R_PPC64_GOT_TPREL16_LO_DS,
1961 0, /* rightshift */
1962 1, /* size (0 = byte, 1 = short, 2 = long) */
1963 16, /* bitsize */
1964 FALSE, /* pc_relative */
1965 0, /* bitpos */
1966 complain_overflow_dont, /* complain_on_overflow */
1967 ppc64_elf_unhandled_reloc, /* special_function */
1968 "R_PPC64_GOT_TPREL16_LO_DS", /* name */
1969 FALSE, /* partial_inplace */
1970 0, /* src_mask */
1971 0xfffc, /* dst_mask */
1972 FALSE), /* pcrel_offset */
1973
1974 /* Like GOT_TPREL16_LO_DS, but next higher group of 16 bits. */
1975 HOWTO (R_PPC64_GOT_TPREL16_HI,
1976 16, /* rightshift */
1977 1, /* size (0 = byte, 1 = short, 2 = long) */
1978 16, /* bitsize */
1979 FALSE, /* pc_relative */
1980 0, /* bitpos */
1981 complain_overflow_signed, /* complain_on_overflow */
1982 ppc64_elf_unhandled_reloc, /* special_function */
1983 "R_PPC64_GOT_TPREL16_HI", /* name */
1984 FALSE, /* partial_inplace */
1985 0, /* src_mask */
1986 0xffff, /* dst_mask */
1987 FALSE), /* pcrel_offset */
1988
1989 /* Like GOT_TPREL16_HI, but adjust for low 16 bits. */
1990 HOWTO (R_PPC64_GOT_TPREL16_HA,
1991 16, /* rightshift */
1992 1, /* size (0 = byte, 1 = short, 2 = long) */
1993 16, /* bitsize */
1994 FALSE, /* pc_relative */
1995 0, /* bitpos */
1996 complain_overflow_signed, /* complain_on_overflow */
1997 ppc64_elf_unhandled_reloc, /* special_function */
1998 "R_PPC64_GOT_TPREL16_HA", /* name */
1999 FALSE, /* partial_inplace */
2000 0, /* src_mask */
2001 0xffff, /* dst_mask */
2002 FALSE), /* pcrel_offset */
2003
2004 HOWTO (R_PPC64_JMP_IREL, /* type */
2005 0, /* rightshift */
2006 0, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
2007 0, /* bitsize */
2008 FALSE, /* pc_relative */
2009 0, /* bitpos */
2010 complain_overflow_dont, /* complain_on_overflow */
2011 ppc64_elf_unhandled_reloc, /* special_function */
2012 "R_PPC64_JMP_IREL", /* name */
2013 FALSE, /* partial_inplace */
2014 0, /* src_mask */
2015 0, /* dst_mask */
2016 FALSE), /* pcrel_offset */
2017
2018 HOWTO (R_PPC64_IRELATIVE, /* type */
2019 0, /* rightshift */
2020 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
2021 64, /* bitsize */
2022 FALSE, /* pc_relative */
2023 0, /* bitpos */
2024 complain_overflow_dont, /* complain_on_overflow */
2025 bfd_elf_generic_reloc, /* special_function */
2026 "R_PPC64_IRELATIVE", /* name */
2027 FALSE, /* partial_inplace */
2028 0, /* src_mask */
2029 ONES (64), /* dst_mask */
2030 FALSE), /* pcrel_offset */
2031
2032 /* A 16 bit relative relocation. */
2033 HOWTO (R_PPC64_REL16, /* type */
2034 0, /* rightshift */
2035 1, /* size (0 = byte, 1 = short, 2 = long) */
2036 16, /* bitsize */
2037 TRUE, /* pc_relative */
2038 0, /* bitpos */
2039 complain_overflow_signed, /* complain_on_overflow */
2040 bfd_elf_generic_reloc, /* special_function */
2041 "R_PPC64_REL16", /* name */
2042 FALSE, /* partial_inplace */
2043 0, /* src_mask */
2044 0xffff, /* dst_mask */
2045 TRUE), /* pcrel_offset */
2046
2047 /* A 16 bit relative relocation without overflow. */
2048 HOWTO (R_PPC64_REL16_LO, /* type */
2049 0, /* rightshift */
2050 1, /* size (0 = byte, 1 = short, 2 = long) */
2051 16, /* bitsize */
2052 TRUE, /* pc_relative */
2053 0, /* bitpos */
2054 complain_overflow_dont,/* complain_on_overflow */
2055 bfd_elf_generic_reloc, /* special_function */
2056 "R_PPC64_REL16_LO", /* name */
2057 FALSE, /* partial_inplace */
2058 0, /* src_mask */
2059 0xffff, /* dst_mask */
2060 TRUE), /* pcrel_offset */
2061
2062 /* The high order 16 bits of a relative address. */
2063 HOWTO (R_PPC64_REL16_HI, /* type */
2064 16, /* rightshift */
2065 1, /* size (0 = byte, 1 = short, 2 = long) */
2066 16, /* bitsize */
2067 TRUE, /* pc_relative */
2068 0, /* bitpos */
2069 complain_overflow_signed, /* complain_on_overflow */
2070 bfd_elf_generic_reloc, /* special_function */
2071 "R_PPC64_REL16_HI", /* name */
2072 FALSE, /* partial_inplace */
2073 0, /* src_mask */
2074 0xffff, /* dst_mask */
2075 TRUE), /* pcrel_offset */
2076
2077 /* The high order 16 bits of a relative address, plus 1 if the contents of
2078 the low 16 bits, treated as a signed number, is negative. */
2079 HOWTO (R_PPC64_REL16_HA, /* type */
2080 16, /* rightshift */
2081 1, /* size (0 = byte, 1 = short, 2 = long) */
2082 16, /* bitsize */
2083 TRUE, /* pc_relative */
2084 0, /* bitpos */
2085 complain_overflow_signed, /* complain_on_overflow */
2086 ppc64_elf_ha_reloc, /* special_function */
2087 "R_PPC64_REL16_HA", /* name */
2088 FALSE, /* partial_inplace */
2089 0, /* src_mask */
2090 0xffff, /* dst_mask */
2091 TRUE), /* pcrel_offset */
2092
2093 /* Like R_PPC64_REL16_HA but for split field in addpcis. */
2094 HOWTO (R_PPC64_REL16DX_HA, /* type */
2095 16, /* rightshift */
2096 2, /* size (0 = byte, 1 = short, 2 = long) */
2097 16, /* bitsize */
2098 TRUE, /* pc_relative */
2099 0, /* bitpos */
2100 complain_overflow_signed, /* complain_on_overflow */
2101 ppc64_elf_ha_reloc, /* special_function */
2102 "R_PPC64_REL16DX_HA", /* name */
2103 FALSE, /* partial_inplace */
2104 0, /* src_mask */
2105 0x1fffc1, /* dst_mask */
2106 TRUE), /* pcrel_offset */
2107
2108 /* A split-field reloc for addpcis, non-relative (gas internal use only). */
2109 HOWTO (R_PPC64_16DX_HA, /* type */
2110 16, /* rightshift */
2111 2, /* size (0 = byte, 1 = short, 2 = long) */
2112 16, /* bitsize */
2113 FALSE, /* pc_relative */
2114 0, /* bitpos */
2115 complain_overflow_signed, /* complain_on_overflow */
2116 ppc64_elf_ha_reloc, /* special_function */
2117 "R_PPC64_16DX_HA", /* name */
2118 FALSE, /* partial_inplace */
2119 0, /* src_mask */
2120 0x1fffc1, /* dst_mask */
2121 FALSE), /* pcrel_offset */
2122
2123 /* Like R_PPC64_ADDR16_HI, but no overflow. */
2124 HOWTO (R_PPC64_ADDR16_HIGH, /* type */
2125 16, /* rightshift */
2126 1, /* size (0 = byte, 1 = short, 2 = long) */
2127 16, /* bitsize */
2128 FALSE, /* pc_relative */
2129 0, /* bitpos */
2130 complain_overflow_dont, /* complain_on_overflow */
2131 bfd_elf_generic_reloc, /* special_function */
2132 "R_PPC64_ADDR16_HIGH", /* name */
2133 FALSE, /* partial_inplace */
2134 0, /* src_mask */
2135 0xffff, /* dst_mask */
2136 FALSE), /* pcrel_offset */
2137
2138 /* Like R_PPC64_ADDR16_HA, but no overflow. */
2139 HOWTO (R_PPC64_ADDR16_HIGHA, /* type */
2140 16, /* rightshift */
2141 1, /* size (0 = byte, 1 = short, 2 = long) */
2142 16, /* bitsize */
2143 FALSE, /* pc_relative */
2144 0, /* bitpos */
2145 complain_overflow_dont, /* complain_on_overflow */
2146 ppc64_elf_ha_reloc, /* special_function */
2147 "R_PPC64_ADDR16_HIGHA", /* name */
2148 FALSE, /* partial_inplace */
2149 0, /* src_mask */
2150 0xffff, /* dst_mask */
2151 FALSE), /* pcrel_offset */
2152
2153 /* Like R_PPC64_DTPREL16_HI, but no overflow. */
2154 HOWTO (R_PPC64_DTPREL16_HIGH,
2155 16, /* rightshift */
2156 1, /* size (0 = byte, 1 = short, 2 = long) */
2157 16, /* bitsize */
2158 FALSE, /* pc_relative */
2159 0, /* bitpos */
2160 complain_overflow_dont, /* complain_on_overflow */
2161 ppc64_elf_unhandled_reloc, /* special_function */
2162 "R_PPC64_DTPREL16_HIGH", /* name */
2163 FALSE, /* partial_inplace */
2164 0, /* src_mask */
2165 0xffff, /* dst_mask */
2166 FALSE), /* pcrel_offset */
2167
2168 /* Like R_PPC64_DTPREL16_HA, but no overflow. */
2169 HOWTO (R_PPC64_DTPREL16_HIGHA,
2170 16, /* rightshift */
2171 1, /* size (0 = byte, 1 = short, 2 = long) */
2172 16, /* bitsize */
2173 FALSE, /* pc_relative */
2174 0, /* bitpos */
2175 complain_overflow_dont, /* complain_on_overflow */
2176 ppc64_elf_unhandled_reloc, /* special_function */
2177 "R_PPC64_DTPREL16_HIGHA", /* name */
2178 FALSE, /* partial_inplace */
2179 0, /* src_mask */
2180 0xffff, /* dst_mask */
2181 FALSE), /* pcrel_offset */
2182
2183 /* Like R_PPC64_TPREL16_HI, but no overflow. */
2184 HOWTO (R_PPC64_TPREL16_HIGH,
2185 16, /* rightshift */
2186 1, /* size (0 = byte, 1 = short, 2 = long) */
2187 16, /* bitsize */
2188 FALSE, /* pc_relative */
2189 0, /* bitpos */
2190 complain_overflow_dont, /* complain_on_overflow */
2191 ppc64_elf_unhandled_reloc, /* special_function */
2192 "R_PPC64_TPREL16_HIGH", /* name */
2193 FALSE, /* partial_inplace */
2194 0, /* src_mask */
2195 0xffff, /* dst_mask */
2196 FALSE), /* pcrel_offset */
2197
2198 /* Like R_PPC64_TPREL16_HA, but no overflow. */
2199 HOWTO (R_PPC64_TPREL16_HIGHA,
2200 16, /* rightshift */
2201 1, /* size (0 = byte, 1 = short, 2 = long) */
2202 16, /* bitsize */
2203 FALSE, /* pc_relative */
2204 0, /* bitpos */
2205 complain_overflow_dont, /* complain_on_overflow */
2206 ppc64_elf_unhandled_reloc, /* special_function */
2207 "R_PPC64_TPREL16_HIGHA", /* name */
2208 FALSE, /* partial_inplace */
2209 0, /* src_mask */
2210 0xffff, /* dst_mask */
2211 FALSE), /* pcrel_offset */
2212
2213 /* Marker reloc on ELFv2 large-model function entry. */
2214 HOWTO (R_PPC64_ENTRY,
2215 0, /* rightshift */
2216 2, /* size (0 = byte, 1 = short, 2 = long) */
2217 32, /* bitsize */
2218 FALSE, /* pc_relative */
2219 0, /* bitpos */
2220 complain_overflow_dont, /* complain_on_overflow */
2221 bfd_elf_generic_reloc, /* special_function */
2222 "R_PPC64_ENTRY", /* name */
2223 FALSE, /* partial_inplace */
2224 0, /* src_mask */
2225 0, /* dst_mask */
2226 FALSE), /* pcrel_offset */
2227
2228 /* Like ADDR64, but use local entry point of function. */
2229 HOWTO (R_PPC64_ADDR64_LOCAL, /* type */
2230 0, /* rightshift */
2231 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
2232 64, /* bitsize */
2233 FALSE, /* pc_relative */
2234 0, /* bitpos */
2235 complain_overflow_dont, /* complain_on_overflow */
2236 bfd_elf_generic_reloc, /* special_function */
2237 "R_PPC64_ADDR64_LOCAL", /* name */
2238 FALSE, /* partial_inplace */
2239 0, /* src_mask */
2240 ONES (64), /* dst_mask */
2241 FALSE), /* pcrel_offset */
2242
2243 /* GNU extension to record C++ vtable hierarchy. */
2244 HOWTO (R_PPC64_GNU_VTINHERIT, /* type */
2245 0, /* rightshift */
2246 0, /* size (0 = byte, 1 = short, 2 = long) */
2247 0, /* bitsize */
2248 FALSE, /* pc_relative */
2249 0, /* bitpos */
2250 complain_overflow_dont, /* complain_on_overflow */
2251 NULL, /* special_function */
2252 "R_PPC64_GNU_VTINHERIT", /* name */
2253 FALSE, /* partial_inplace */
2254 0, /* src_mask */
2255 0, /* dst_mask */
2256 FALSE), /* pcrel_offset */
2257
2258 /* GNU extension to record C++ vtable member usage. */
2259 HOWTO (R_PPC64_GNU_VTENTRY, /* type */
2260 0, /* rightshift */
2261 0, /* size (0 = byte, 1 = short, 2 = long) */
2262 0, /* bitsize */
2263 FALSE, /* pc_relative */
2264 0, /* bitpos */
2265 complain_overflow_dont, /* complain_on_overflow */
2266 NULL, /* special_function */
2267 "R_PPC64_GNU_VTENTRY", /* name */
2268 FALSE, /* partial_inplace */
2269 0, /* src_mask */
2270 0, /* dst_mask */
2271 FALSE), /* pcrel_offset */
2272 };
2273
2274 \f
2275 /* Initialize the ppc64_elf_howto_table, so that linear accesses can
2276 be done. */
2277
2278 static void
2279 ppc_howto_init (void)
2280 {
2281 unsigned int i, type;
2282
2283 for (i = 0; i < ARRAY_SIZE (ppc64_elf_howto_raw); i++)
2284 {
2285 type = ppc64_elf_howto_raw[i].type;
2286 BFD_ASSERT (type < ARRAY_SIZE (ppc64_elf_howto_table));
2287 ppc64_elf_howto_table[type] = &ppc64_elf_howto_raw[i];
2288 }
2289 }
2290
2291 static reloc_howto_type *
2292 ppc64_elf_reloc_type_lookup (bfd *abfd,
2293 bfd_reloc_code_real_type code)
2294 {
2295 enum elf_ppc64_reloc_type r = R_PPC64_NONE;
2296
2297 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2298 /* Initialize howto table if needed. */
2299 ppc_howto_init ();
2300
2301 switch (code)
2302 {
2303 default:
2304 /* xgettext:c-format */
2305 _bfd_error_handler (_("%pB: unsupported relocation type %#x"), abfd, (int) code);
2306 bfd_set_error (bfd_error_bad_value);
2307 return NULL;
2308
2309 case BFD_RELOC_NONE: r = R_PPC64_NONE;
2310 break;
2311 case BFD_RELOC_32: r = R_PPC64_ADDR32;
2312 break;
2313 case BFD_RELOC_PPC_BA26: r = R_PPC64_ADDR24;
2314 break;
2315 case BFD_RELOC_16: r = R_PPC64_ADDR16;
2316 break;
2317 case BFD_RELOC_LO16: r = R_PPC64_ADDR16_LO;
2318 break;
2319 case BFD_RELOC_HI16: r = R_PPC64_ADDR16_HI;
2320 break;
2321 case BFD_RELOC_PPC64_ADDR16_HIGH: r = R_PPC64_ADDR16_HIGH;
2322 break;
2323 case BFD_RELOC_HI16_S: r = R_PPC64_ADDR16_HA;
2324 break;
2325 case BFD_RELOC_PPC64_ADDR16_HIGHA: r = R_PPC64_ADDR16_HIGHA;
2326 break;
2327 case BFD_RELOC_PPC_BA16: r = R_PPC64_ADDR14;
2328 break;
2329 case BFD_RELOC_PPC_BA16_BRTAKEN: r = R_PPC64_ADDR14_BRTAKEN;
2330 break;
2331 case BFD_RELOC_PPC_BA16_BRNTAKEN: r = R_PPC64_ADDR14_BRNTAKEN;
2332 break;
2333 case BFD_RELOC_PPC_B26: r = R_PPC64_REL24;
2334 break;
2335 case BFD_RELOC_PPC64_REL24_NOTOC: r = R_PPC64_REL24_NOTOC;
2336 break;
2337 case BFD_RELOC_PPC_B16: r = R_PPC64_REL14;
2338 break;
2339 case BFD_RELOC_PPC_B16_BRTAKEN: r = R_PPC64_REL14_BRTAKEN;
2340 break;
2341 case BFD_RELOC_PPC_B16_BRNTAKEN: r = R_PPC64_REL14_BRNTAKEN;
2342 break;
2343 case BFD_RELOC_16_GOTOFF: r = R_PPC64_GOT16;
2344 break;
2345 case BFD_RELOC_LO16_GOTOFF: r = R_PPC64_GOT16_LO;
2346 break;
2347 case BFD_RELOC_HI16_GOTOFF: r = R_PPC64_GOT16_HI;
2348 break;
2349 case BFD_RELOC_HI16_S_GOTOFF: r = R_PPC64_GOT16_HA;
2350 break;
2351 case BFD_RELOC_PPC_COPY: r = R_PPC64_COPY;
2352 break;
2353 case BFD_RELOC_PPC_GLOB_DAT: r = R_PPC64_GLOB_DAT;
2354 break;
2355 case BFD_RELOC_32_PCREL: r = R_PPC64_REL32;
2356 break;
2357 case BFD_RELOC_32_PLTOFF: r = R_PPC64_PLT32;
2358 break;
2359 case BFD_RELOC_32_PLT_PCREL: r = R_PPC64_PLTREL32;
2360 break;
2361 case BFD_RELOC_LO16_PLTOFF: r = R_PPC64_PLT16_LO;
2362 break;
2363 case BFD_RELOC_HI16_PLTOFF: r = R_PPC64_PLT16_HI;
2364 break;
2365 case BFD_RELOC_HI16_S_PLTOFF: r = R_PPC64_PLT16_HA;
2366 break;
2367 case BFD_RELOC_16_BASEREL: r = R_PPC64_SECTOFF;
2368 break;
2369 case BFD_RELOC_LO16_BASEREL: r = R_PPC64_SECTOFF_LO;
2370 break;
2371 case BFD_RELOC_HI16_BASEREL: r = R_PPC64_SECTOFF_HI;
2372 break;
2373 case BFD_RELOC_HI16_S_BASEREL: r = R_PPC64_SECTOFF_HA;
2374 break;
2375 case BFD_RELOC_CTOR: r = R_PPC64_ADDR64;
2376 break;
2377 case BFD_RELOC_64: r = R_PPC64_ADDR64;
2378 break;
2379 case BFD_RELOC_PPC64_HIGHER: r = R_PPC64_ADDR16_HIGHER;
2380 break;
2381 case BFD_RELOC_PPC64_HIGHER_S: r = R_PPC64_ADDR16_HIGHERA;
2382 break;
2383 case BFD_RELOC_PPC64_HIGHEST: r = R_PPC64_ADDR16_HIGHEST;
2384 break;
2385 case BFD_RELOC_PPC64_HIGHEST_S: r = R_PPC64_ADDR16_HIGHESTA;
2386 break;
2387 case BFD_RELOC_64_PCREL: r = R_PPC64_REL64;
2388 break;
2389 case BFD_RELOC_64_PLTOFF: r = R_PPC64_PLT64;
2390 break;
2391 case BFD_RELOC_64_PLT_PCREL: r = R_PPC64_PLTREL64;
2392 break;
2393 case BFD_RELOC_PPC_TOC16: r = R_PPC64_TOC16;
2394 break;
2395 case BFD_RELOC_PPC64_TOC16_LO: r = R_PPC64_TOC16_LO;
2396 break;
2397 case BFD_RELOC_PPC64_TOC16_HI: r = R_PPC64_TOC16_HI;
2398 break;
2399 case BFD_RELOC_PPC64_TOC16_HA: r = R_PPC64_TOC16_HA;
2400 break;
2401 case BFD_RELOC_PPC64_TOC: r = R_PPC64_TOC;
2402 break;
2403 case BFD_RELOC_PPC64_PLTGOT16: r = R_PPC64_PLTGOT16;
2404 break;
2405 case BFD_RELOC_PPC64_PLTGOT16_LO: r = R_PPC64_PLTGOT16_LO;
2406 break;
2407 case BFD_RELOC_PPC64_PLTGOT16_HI: r = R_PPC64_PLTGOT16_HI;
2408 break;
2409 case BFD_RELOC_PPC64_PLTGOT16_HA: r = R_PPC64_PLTGOT16_HA;
2410 break;
2411 case BFD_RELOC_PPC64_ADDR16_DS: r = R_PPC64_ADDR16_DS;
2412 break;
2413 case BFD_RELOC_PPC64_ADDR16_LO_DS: r = R_PPC64_ADDR16_LO_DS;
2414 break;
2415 case BFD_RELOC_PPC64_GOT16_DS: r = R_PPC64_GOT16_DS;
2416 break;
2417 case BFD_RELOC_PPC64_GOT16_LO_DS: r = R_PPC64_GOT16_LO_DS;
2418 break;
2419 case BFD_RELOC_PPC64_PLT16_LO_DS: r = R_PPC64_PLT16_LO_DS;
2420 break;
2421 case BFD_RELOC_PPC64_SECTOFF_DS: r = R_PPC64_SECTOFF_DS;
2422 break;
2423 case BFD_RELOC_PPC64_SECTOFF_LO_DS: r = R_PPC64_SECTOFF_LO_DS;
2424 break;
2425 case BFD_RELOC_PPC64_TOC16_DS: r = R_PPC64_TOC16_DS;
2426 break;
2427 case BFD_RELOC_PPC64_TOC16_LO_DS: r = R_PPC64_TOC16_LO_DS;
2428 break;
2429 case BFD_RELOC_PPC64_PLTGOT16_DS: r = R_PPC64_PLTGOT16_DS;
2430 break;
2431 case BFD_RELOC_PPC64_PLTGOT16_LO_DS: r = R_PPC64_PLTGOT16_LO_DS;
2432 break;
2433 case BFD_RELOC_PPC_TLS: r = R_PPC64_TLS;
2434 break;
2435 case BFD_RELOC_PPC_TLSGD: r = R_PPC64_TLSGD;
2436 break;
2437 case BFD_RELOC_PPC_TLSLD: r = R_PPC64_TLSLD;
2438 break;
2439 case BFD_RELOC_PPC_DTPMOD: r = R_PPC64_DTPMOD64;
2440 break;
2441 case BFD_RELOC_PPC_TPREL16: r = R_PPC64_TPREL16;
2442 break;
2443 case BFD_RELOC_PPC_TPREL16_LO: r = R_PPC64_TPREL16_LO;
2444 break;
2445 case BFD_RELOC_PPC_TPREL16_HI: r = R_PPC64_TPREL16_HI;
2446 break;
2447 case BFD_RELOC_PPC64_TPREL16_HIGH: r = R_PPC64_TPREL16_HIGH;
2448 break;
2449 case BFD_RELOC_PPC_TPREL16_HA: r = R_PPC64_TPREL16_HA;
2450 break;
2451 case BFD_RELOC_PPC64_TPREL16_HIGHA: r = R_PPC64_TPREL16_HIGHA;
2452 break;
2453 case BFD_RELOC_PPC_TPREL: r = R_PPC64_TPREL64;
2454 break;
2455 case BFD_RELOC_PPC_DTPREL16: r = R_PPC64_DTPREL16;
2456 break;
2457 case BFD_RELOC_PPC_DTPREL16_LO: r = R_PPC64_DTPREL16_LO;
2458 break;
2459 case BFD_RELOC_PPC_DTPREL16_HI: r = R_PPC64_DTPREL16_HI;
2460 break;
2461 case BFD_RELOC_PPC64_DTPREL16_HIGH: r = R_PPC64_DTPREL16_HIGH;
2462 break;
2463 case BFD_RELOC_PPC_DTPREL16_HA: r = R_PPC64_DTPREL16_HA;
2464 break;
2465 case BFD_RELOC_PPC64_DTPREL16_HIGHA: r = R_PPC64_DTPREL16_HIGHA;
2466 break;
2467 case BFD_RELOC_PPC_DTPREL: r = R_PPC64_DTPREL64;
2468 break;
2469 case BFD_RELOC_PPC_GOT_TLSGD16: r = R_PPC64_GOT_TLSGD16;
2470 break;
2471 case BFD_RELOC_PPC_GOT_TLSGD16_LO: r = R_PPC64_GOT_TLSGD16_LO;
2472 break;
2473 case BFD_RELOC_PPC_GOT_TLSGD16_HI: r = R_PPC64_GOT_TLSGD16_HI;
2474 break;
2475 case BFD_RELOC_PPC_GOT_TLSGD16_HA: r = R_PPC64_GOT_TLSGD16_HA;
2476 break;
2477 case BFD_RELOC_PPC_GOT_TLSLD16: r = R_PPC64_GOT_TLSLD16;
2478 break;
2479 case BFD_RELOC_PPC_GOT_TLSLD16_LO: r = R_PPC64_GOT_TLSLD16_LO;
2480 break;
2481 case BFD_RELOC_PPC_GOT_TLSLD16_HI: r = R_PPC64_GOT_TLSLD16_HI;
2482 break;
2483 case BFD_RELOC_PPC_GOT_TLSLD16_HA: r = R_PPC64_GOT_TLSLD16_HA;
2484 break;
2485 case BFD_RELOC_PPC_GOT_TPREL16: r = R_PPC64_GOT_TPREL16_DS;
2486 break;
2487 case BFD_RELOC_PPC_GOT_TPREL16_LO: r = R_PPC64_GOT_TPREL16_LO_DS;
2488 break;
2489 case BFD_RELOC_PPC_GOT_TPREL16_HI: r = R_PPC64_GOT_TPREL16_HI;
2490 break;
2491 case BFD_RELOC_PPC_GOT_TPREL16_HA: r = R_PPC64_GOT_TPREL16_HA;
2492 break;
2493 case BFD_RELOC_PPC_GOT_DTPREL16: r = R_PPC64_GOT_DTPREL16_DS;
2494 break;
2495 case BFD_RELOC_PPC_GOT_DTPREL16_LO: r = R_PPC64_GOT_DTPREL16_LO_DS;
2496 break;
2497 case BFD_RELOC_PPC_GOT_DTPREL16_HI: r = R_PPC64_GOT_DTPREL16_HI;
2498 break;
2499 case BFD_RELOC_PPC_GOT_DTPREL16_HA: r = R_PPC64_GOT_DTPREL16_HA;
2500 break;
2501 case BFD_RELOC_PPC64_TPREL16_DS: r = R_PPC64_TPREL16_DS;
2502 break;
2503 case BFD_RELOC_PPC64_TPREL16_LO_DS: r = R_PPC64_TPREL16_LO_DS;
2504 break;
2505 case BFD_RELOC_PPC64_TPREL16_HIGHER: r = R_PPC64_TPREL16_HIGHER;
2506 break;
2507 case BFD_RELOC_PPC64_TPREL16_HIGHERA: r = R_PPC64_TPREL16_HIGHERA;
2508 break;
2509 case BFD_RELOC_PPC64_TPREL16_HIGHEST: r = R_PPC64_TPREL16_HIGHEST;
2510 break;
2511 case BFD_RELOC_PPC64_TPREL16_HIGHESTA: r = R_PPC64_TPREL16_HIGHESTA;
2512 break;
2513 case BFD_RELOC_PPC64_DTPREL16_DS: r = R_PPC64_DTPREL16_DS;
2514 break;
2515 case BFD_RELOC_PPC64_DTPREL16_LO_DS: r = R_PPC64_DTPREL16_LO_DS;
2516 break;
2517 case BFD_RELOC_PPC64_DTPREL16_HIGHER: r = R_PPC64_DTPREL16_HIGHER;
2518 break;
2519 case BFD_RELOC_PPC64_DTPREL16_HIGHERA: r = R_PPC64_DTPREL16_HIGHERA;
2520 break;
2521 case BFD_RELOC_PPC64_DTPREL16_HIGHEST: r = R_PPC64_DTPREL16_HIGHEST;
2522 break;
2523 case BFD_RELOC_PPC64_DTPREL16_HIGHESTA: r = R_PPC64_DTPREL16_HIGHESTA;
2524 break;
2525 case BFD_RELOC_16_PCREL: r = R_PPC64_REL16;
2526 break;
2527 case BFD_RELOC_LO16_PCREL: r = R_PPC64_REL16_LO;
2528 break;
2529 case BFD_RELOC_HI16_PCREL: r = R_PPC64_REL16_HI;
2530 break;
2531 case BFD_RELOC_HI16_S_PCREL: r = R_PPC64_REL16_HA;
2532 break;
2533 case BFD_RELOC_PPC_16DX_HA: r = R_PPC64_16DX_HA;
2534 break;
2535 case BFD_RELOC_PPC_REL16DX_HA: r = R_PPC64_REL16DX_HA;
2536 break;
2537 case BFD_RELOC_PPC64_ENTRY: r = R_PPC64_ENTRY;
2538 break;
2539 case BFD_RELOC_PPC64_ADDR64_LOCAL: r = R_PPC64_ADDR64_LOCAL;
2540 break;
2541 case BFD_RELOC_VTABLE_INHERIT: r = R_PPC64_GNU_VTINHERIT;
2542 break;
2543 case BFD_RELOC_VTABLE_ENTRY: r = R_PPC64_GNU_VTENTRY;
2544 break;
2545 }
2546
2547 return ppc64_elf_howto_table[r];
2548 };
2549
2550 static reloc_howto_type *
2551 ppc64_elf_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2552 const char *r_name)
2553 {
2554 unsigned int i;
2555
2556 for (i = 0; i < ARRAY_SIZE (ppc64_elf_howto_raw); i++)
2557 if (ppc64_elf_howto_raw[i].name != NULL
2558 && strcasecmp (ppc64_elf_howto_raw[i].name, r_name) == 0)
2559 return &ppc64_elf_howto_raw[i];
2560
2561
2562 return NULL;
2563 }
2564
2565 /* Set the howto pointer for a PowerPC ELF reloc. */
2566
2567 static bfd_boolean
2568 ppc64_elf_info_to_howto (bfd *abfd, arelent *cache_ptr,
2569 Elf_Internal_Rela *dst)
2570 {
2571 unsigned int type;
2572
2573 /* Initialize howto table if needed. */
2574 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2575 ppc_howto_init ();
2576
2577 type = ELF64_R_TYPE (dst->r_info);
2578 if (type >= ARRAY_SIZE (ppc64_elf_howto_table))
2579 {
2580 /* xgettext:c-format */
2581 _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
2582 abfd, type);
2583 bfd_set_error (bfd_error_bad_value);
2584 return FALSE;
2585 }
2586 cache_ptr->howto = ppc64_elf_howto_table[type];
2587 if (cache_ptr->howto == NULL || cache_ptr->howto->name == NULL)
2588 {
2589 /* xgettext:c-format */
2590 _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
2591 abfd, type);
2592 bfd_set_error (bfd_error_bad_value);
2593 return FALSE;
2594 }
2595
2596 return TRUE;
2597 }
2598
2599 /* Handle the R_PPC64_ADDR16_HA and similar relocs. */
2600
2601 static bfd_reloc_status_type
2602 ppc64_elf_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2603 void *data, asection *input_section,
2604 bfd *output_bfd, char **error_message)
2605 {
2606 enum elf_ppc64_reloc_type r_type;
2607 long insn;
2608 bfd_size_type octets;
2609 bfd_vma value;
2610
2611 /* If this is a relocatable link (output_bfd test tells us), just
2612 call the generic function. Any adjustment will be done at final
2613 link time. */
2614 if (output_bfd != NULL)
2615 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2616 input_section, output_bfd, error_message);
2617
2618 /* Adjust the addend for sign extension of the low 16 bits.
2619 We won't actually be using the low 16 bits, so trashing them
2620 doesn't matter. */
2621 reloc_entry->addend += 0x8000;
2622 r_type = reloc_entry->howto->type;
2623 if (r_type != R_PPC64_REL16DX_HA)
2624 return bfd_reloc_continue;
2625
2626 value = 0;
2627 if (!bfd_is_com_section (symbol->section))
2628 value = symbol->value;
2629 value += (reloc_entry->addend
2630 + symbol->section->output_offset
2631 + symbol->section->output_section->vma);
2632 value -= (reloc_entry->address
2633 + input_section->output_offset
2634 + input_section->output_section->vma);
2635 value = (bfd_signed_vma) value >> 16;
2636
2637 octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2638 insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
2639 insn &= ~0x1fffc1;
2640 insn |= (value & 0xffc1) | ((value & 0x3e) << 15);
2641 bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
2642 if (value + 0x8000 > 0xffff)
2643 return bfd_reloc_overflow;
2644 return bfd_reloc_ok;
2645 }
2646
2647 static bfd_reloc_status_type
2648 ppc64_elf_branch_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2649 void *data, asection *input_section,
2650 bfd *output_bfd, char **error_message)
2651 {
2652 if (output_bfd != NULL)
2653 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2654 input_section, output_bfd, error_message);
2655
2656 if (strcmp (symbol->section->name, ".opd") == 0
2657 && (symbol->section->owner->flags & DYNAMIC) == 0)
2658 {
2659 bfd_vma dest = opd_entry_value (symbol->section,
2660 symbol->value + reloc_entry->addend,
2661 NULL, NULL, FALSE);
2662 if (dest != (bfd_vma) -1)
2663 reloc_entry->addend = dest - (symbol->value
2664 + symbol->section->output_section->vma
2665 + symbol->section->output_offset);
2666 }
2667 else
2668 {
2669 elf_symbol_type *elfsym = (elf_symbol_type *) symbol;
2670
2671 if (symbol->section->owner != abfd
2672 && symbol->section->owner != NULL
2673 && abiversion (symbol->section->owner) >= 2)
2674 {
2675 unsigned int i;
2676
2677 for (i = 0; i < symbol->section->owner->symcount; ++i)
2678 {
2679 asymbol *symdef = symbol->section->owner->outsymbols[i];
2680
2681 if (strcmp (symdef->name, symbol->name) == 0)
2682 {
2683 elfsym = (elf_symbol_type *) symdef;
2684 break;
2685 }
2686 }
2687 }
2688 reloc_entry->addend
2689 += PPC64_LOCAL_ENTRY_OFFSET (elfsym->internal_elf_sym.st_other);
2690 }
2691 return bfd_reloc_continue;
2692 }
2693
2694 static bfd_reloc_status_type
2695 ppc64_elf_brtaken_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2696 void *data, asection *input_section,
2697 bfd *output_bfd, char **error_message)
2698 {
2699 long insn;
2700 enum elf_ppc64_reloc_type r_type;
2701 bfd_size_type octets;
2702 /* Assume 'at' branch hints. */
2703 bfd_boolean is_isa_v2 = TRUE;
2704
2705 /* If this is a relocatable link (output_bfd test tells us), just
2706 call the generic function. Any adjustment will be done at final
2707 link time. */
2708 if (output_bfd != NULL)
2709 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2710 input_section, output_bfd, error_message);
2711
2712 octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2713 insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
2714 insn &= ~(0x01 << 21);
2715 r_type = reloc_entry->howto->type;
2716 if (r_type == R_PPC64_ADDR14_BRTAKEN
2717 || r_type == R_PPC64_REL14_BRTAKEN)
2718 insn |= 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field. */
2719
2720 if (is_isa_v2)
2721 {
2722 /* Set 'a' bit. This is 0b00010 in BO field for branch
2723 on CR(BI) insns (BO == 001at or 011at), and 0b01000
2724 for branch on CTR insns (BO == 1a00t or 1a01t). */
2725 if ((insn & (0x14 << 21)) == (0x04 << 21))
2726 insn |= 0x02 << 21;
2727 else if ((insn & (0x14 << 21)) == (0x10 << 21))
2728 insn |= 0x08 << 21;
2729 else
2730 goto out;
2731 }
2732 else
2733 {
2734 bfd_vma target = 0;
2735 bfd_vma from;
2736
2737 if (!bfd_is_com_section (symbol->section))
2738 target = symbol->value;
2739 target += symbol->section->output_section->vma;
2740 target += symbol->section->output_offset;
2741 target += reloc_entry->addend;
2742
2743 from = (reloc_entry->address
2744 + input_section->output_offset
2745 + input_section->output_section->vma);
2746
2747 /* Invert 'y' bit if not the default. */
2748 if ((bfd_signed_vma) (target - from) < 0)
2749 insn ^= 0x01 << 21;
2750 }
2751 bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
2752 out:
2753 return ppc64_elf_branch_reloc (abfd, reloc_entry, symbol, data,
2754 input_section, output_bfd, error_message);
2755 }
2756
2757 static bfd_reloc_status_type
2758 ppc64_elf_sectoff_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2759 void *data, asection *input_section,
2760 bfd *output_bfd, char **error_message)
2761 {
2762 /* If this is a relocatable link (output_bfd test tells us), just
2763 call the generic function. Any adjustment will be done at final
2764 link time. */
2765 if (output_bfd != NULL)
2766 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2767 input_section, output_bfd, error_message);
2768
2769 /* Subtract the symbol section base address. */
2770 reloc_entry->addend -= symbol->section->output_section->vma;
2771 return bfd_reloc_continue;
2772 }
2773
2774 static bfd_reloc_status_type
2775 ppc64_elf_sectoff_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2776 void *data, asection *input_section,
2777 bfd *output_bfd, char **error_message)
2778 {
2779 /* If this is a relocatable link (output_bfd test tells us), just
2780 call the generic function. Any adjustment will be done at final
2781 link time. */
2782 if (output_bfd != NULL)
2783 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2784 input_section, output_bfd, error_message);
2785
2786 /* Subtract the symbol section base address. */
2787 reloc_entry->addend -= symbol->section->output_section->vma;
2788
2789 /* Adjust the addend for sign extension of the low 16 bits. */
2790 reloc_entry->addend += 0x8000;
2791 return bfd_reloc_continue;
2792 }
2793
2794 static bfd_reloc_status_type
2795 ppc64_elf_toc_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2796 void *data, asection *input_section,
2797 bfd *output_bfd, char **error_message)
2798 {
2799 bfd_vma TOCstart;
2800
2801 /* If this is a relocatable link (output_bfd test tells us), just
2802 call the generic function. Any adjustment will be done at final
2803 link time. */
2804 if (output_bfd != NULL)
2805 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2806 input_section, output_bfd, error_message);
2807
2808 TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2809 if (TOCstart == 0)
2810 TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2811
2812 /* Subtract the TOC base address. */
2813 reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2814 return bfd_reloc_continue;
2815 }
2816
2817 static bfd_reloc_status_type
2818 ppc64_elf_toc_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2819 void *data, asection *input_section,
2820 bfd *output_bfd, char **error_message)
2821 {
2822 bfd_vma TOCstart;
2823
2824 /* If this is a relocatable link (output_bfd test tells us), just
2825 call the generic function. Any adjustment will be done at final
2826 link time. */
2827 if (output_bfd != NULL)
2828 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2829 input_section, output_bfd, error_message);
2830
2831 TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2832 if (TOCstart == 0)
2833 TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2834
2835 /* Subtract the TOC base address. */
2836 reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2837
2838 /* Adjust the addend for sign extension of the low 16 bits. */
2839 reloc_entry->addend += 0x8000;
2840 return bfd_reloc_continue;
2841 }
2842
2843 static bfd_reloc_status_type
2844 ppc64_elf_toc64_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2845 void *data, asection *input_section,
2846 bfd *output_bfd, char **error_message)
2847 {
2848 bfd_vma TOCstart;
2849 bfd_size_type octets;
2850
2851 /* If this is a relocatable link (output_bfd test tells us), just
2852 call the generic function. Any adjustment will be done at final
2853 link time. */
2854 if (output_bfd != NULL)
2855 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2856 input_section, output_bfd, error_message);
2857
2858 TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2859 if (TOCstart == 0)
2860 TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2861
2862 octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2863 bfd_put_64 (abfd, TOCstart + TOC_BASE_OFF, (bfd_byte *) data + octets);
2864 return bfd_reloc_ok;
2865 }
2866
2867 static bfd_reloc_status_type
2868 ppc64_elf_unhandled_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2869 void *data, asection *input_section,
2870 bfd *output_bfd, char **error_message)
2871 {
2872 /* If this is a relocatable link (output_bfd test tells us), just
2873 call the generic function. Any adjustment will be done at final
2874 link time. */
2875 if (output_bfd != NULL)
2876 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2877 input_section, output_bfd, error_message);
2878
2879 if (error_message != NULL)
2880 {
2881 static char buf[60];
2882 sprintf (buf, "generic linker can't handle %s",
2883 reloc_entry->howto->name);
2884 *error_message = buf;
2885 }
2886 return bfd_reloc_dangerous;
2887 }
2888
2889 /* Track GOT entries needed for a given symbol. We might need more
2890 than one got entry per symbol. */
2891 struct got_entry
2892 {
2893 struct got_entry *next;
2894
2895 /* The symbol addend that we'll be placing in the GOT. */
2896 bfd_vma addend;
2897
2898 /* Unlike other ELF targets, we use separate GOT entries for the same
2899 symbol referenced from different input files. This is to support
2900 automatic multiple TOC/GOT sections, where the TOC base can vary
2901 from one input file to another. After partitioning into TOC groups
2902 we merge entries within the group.
2903
2904 Point to the BFD owning this GOT entry. */
2905 bfd *owner;
2906
2907 /* Zero for non-tls entries, or TLS_TLS and one of TLS_GD, TLS_LD,
2908 TLS_TPREL or TLS_DTPREL for tls entries. */
2909 unsigned char tls_type;
2910
2911 /* Non-zero if got.ent points to real entry. */
2912 unsigned char is_indirect;
2913
2914 /* Reference count until size_dynamic_sections, GOT offset thereafter. */
2915 union
2916 {
2917 bfd_signed_vma refcount;
2918 bfd_vma offset;
2919 struct got_entry *ent;
2920 } got;
2921 };
2922
2923 /* The same for PLT. */
2924 struct plt_entry
2925 {
2926 struct plt_entry *next;
2927
2928 bfd_vma addend;
2929
2930 union
2931 {
2932 bfd_signed_vma refcount;
2933 bfd_vma offset;
2934 } plt;
2935 };
2936
2937 struct ppc64_elf_obj_tdata
2938 {
2939 struct elf_obj_tdata elf;
2940
2941 /* Shortcuts to dynamic linker sections. */
2942 asection *got;
2943 asection *relgot;
2944
2945 /* Used during garbage collection. We attach global symbols defined
2946 on removed .opd entries to this section so that the sym is removed. */
2947 asection *deleted_section;
2948
2949 /* TLS local dynamic got entry handling. Support for multiple GOT
2950 sections means we potentially need one of these for each input bfd. */
2951 struct got_entry tlsld_got;
2952
2953 union {
2954 /* A copy of relocs before they are modified for --emit-relocs. */
2955 Elf_Internal_Rela *relocs;
2956
2957 /* Section contents. */
2958 bfd_byte *contents;
2959 } opd;
2960
2961 /* Nonzero if this bfd has small toc/got relocs, ie. that expect
2962 the reloc to be in the range -32768 to 32767. */
2963 unsigned int has_small_toc_reloc : 1;
2964
2965 /* Set if toc/got ha relocs detected not using r2, or lo reloc
2966 instruction not one we handle. */
2967 unsigned int unexpected_toc_insn : 1;
2968 };
2969
2970 #define ppc64_elf_tdata(bfd) \
2971 ((struct ppc64_elf_obj_tdata *) (bfd)->tdata.any)
2972
2973 #define ppc64_tlsld_got(bfd) \
2974 (&ppc64_elf_tdata (bfd)->tlsld_got)
2975
2976 #define is_ppc64_elf(bfd) \
2977 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
2978 && elf_object_id (bfd) == PPC64_ELF_DATA)
2979
2980 /* Override the generic function because we store some extras. */
2981
2982 static bfd_boolean
2983 ppc64_elf_mkobject (bfd *abfd)
2984 {
2985 return bfd_elf_allocate_object (abfd, sizeof (struct ppc64_elf_obj_tdata),
2986 PPC64_ELF_DATA);
2987 }
2988
2989 /* Fix bad default arch selected for a 64 bit input bfd when the
2990 default is 32 bit. Also select arch based on apuinfo. */
2991
2992 static bfd_boolean
2993 ppc64_elf_object_p (bfd *abfd)
2994 {
2995 if (!abfd->arch_info->the_default)
2996 return TRUE;
2997
2998 if (abfd->arch_info->bits_per_word == 32)
2999 {
3000 Elf_Internal_Ehdr *i_ehdr = elf_elfheader (abfd);
3001
3002 if (i_ehdr->e_ident[EI_CLASS] == ELFCLASS64)
3003 {
3004 /* Relies on arch after 32 bit default being 64 bit default. */
3005 abfd->arch_info = abfd->arch_info->next;
3006 BFD_ASSERT (abfd->arch_info->bits_per_word == 64);
3007 }
3008 }
3009 return _bfd_elf_ppc_set_arch (abfd);
3010 }
3011
3012 /* Support for core dump NOTE sections. */
3013
3014 static bfd_boolean
3015 ppc64_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
3016 {
3017 size_t offset, size;
3018
3019 if (note->descsz != 504)
3020 return FALSE;
3021
3022 /* pr_cursig */
3023 elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
3024
3025 /* pr_pid */
3026 elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 32);
3027
3028 /* pr_reg */
3029 offset = 112;
3030 size = 384;
3031
3032 /* Make a ".reg/999" section. */
3033 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
3034 size, note->descpos + offset);
3035 }
3036
3037 static bfd_boolean
3038 ppc64_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
3039 {
3040 if (note->descsz != 136)
3041 return FALSE;
3042
3043 elf_tdata (abfd)->core->pid
3044 = bfd_get_32 (abfd, note->descdata + 24);
3045 elf_tdata (abfd)->core->program
3046 = _bfd_elfcore_strndup (abfd, note->descdata + 40, 16);
3047 elf_tdata (abfd)->core->command
3048 = _bfd_elfcore_strndup (abfd, note->descdata + 56, 80);
3049
3050 return TRUE;
3051 }
3052
3053 static char *
3054 ppc64_elf_write_core_note (bfd *abfd, char *buf, int *bufsiz, int note_type,
3055 ...)
3056 {
3057 switch (note_type)
3058 {
3059 default:
3060 return NULL;
3061
3062 case NT_PRPSINFO:
3063 {
3064 char data[136] ATTRIBUTE_NONSTRING;
3065 va_list ap;
3066
3067 va_start (ap, note_type);
3068 memset (data, 0, sizeof (data));
3069 strncpy (data + 40, va_arg (ap, const char *), 16);
3070 #if GCC_VERSION == 8000 || GCC_VERSION == 8001
3071 DIAGNOSTIC_PUSH;
3072 /* GCC 8.0 and 8.1 warn about 80 equals destination size with
3073 -Wstringop-truncation:
3074 https://gcc.gnu.org/bugzilla/show_bug.cgi?id=85643
3075 */
3076 DIAGNOSTIC_IGNORE_STRINGOP_TRUNCATION;
3077 #endif
3078 strncpy (data + 56, va_arg (ap, const char *), 80);
3079 #if GCC_VERSION == 8000 || GCC_VERSION == 8001
3080 DIAGNOSTIC_POP;
3081 #endif
3082 va_end (ap);
3083 return elfcore_write_note (abfd, buf, bufsiz,
3084 "CORE", note_type, data, sizeof (data));
3085 }
3086
3087 case NT_PRSTATUS:
3088 {
3089 char data[504];
3090 va_list ap;
3091 long pid;
3092 int cursig;
3093 const void *greg;
3094
3095 va_start (ap, note_type);
3096 memset (data, 0, 112);
3097 pid = va_arg (ap, long);
3098 bfd_put_32 (abfd, pid, data + 32);
3099 cursig = va_arg (ap, int);
3100 bfd_put_16 (abfd, cursig, data + 12);
3101 greg = va_arg (ap, const void *);
3102 memcpy (data + 112, greg, 384);
3103 memset (data + 496, 0, 8);
3104 va_end (ap);
3105 return elfcore_write_note (abfd, buf, bufsiz,
3106 "CORE", note_type, data, sizeof (data));
3107 }
3108 }
3109 }
3110
3111 /* Add extra PPC sections. */
3112
3113 static const struct bfd_elf_special_section ppc64_elf_special_sections[]=
3114 {
3115 { STRING_COMMA_LEN (".plt"), 0, SHT_NOBITS, 0 },
3116 { STRING_COMMA_LEN (".sbss"), -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE },
3117 { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
3118 { STRING_COMMA_LEN (".toc"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
3119 { STRING_COMMA_LEN (".toc1"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
3120 { STRING_COMMA_LEN (".tocbss"), 0, SHT_NOBITS, SHF_ALLOC + SHF_WRITE },
3121 { NULL, 0, 0, 0, 0 }
3122 };
3123
3124 enum _ppc64_sec_type {
3125 sec_normal = 0,
3126 sec_opd = 1,
3127 sec_toc = 2
3128 };
3129
3130 struct _ppc64_elf_section_data
3131 {
3132 struct bfd_elf_section_data elf;
3133
3134 union
3135 {
3136 /* An array with one entry for each opd function descriptor,
3137 and some spares since opd entries may be either 16 or 24 bytes. */
3138 #define OPD_NDX(OFF) ((OFF) >> 4)
3139 struct _opd_sec_data
3140 {
3141 /* Points to the function code section for local opd entries. */
3142 asection **func_sec;
3143
3144 /* After editing .opd, adjust references to opd local syms. */
3145 long *adjust;
3146 } opd;
3147
3148 /* An array for toc sections, indexed by offset/8. */
3149 struct _toc_sec_data
3150 {
3151 /* Specifies the relocation symbol index used at a given toc offset. */
3152 unsigned *symndx;
3153
3154 /* And the relocation addend. */
3155 bfd_vma *add;
3156 } toc;
3157 } u;
3158
3159 enum _ppc64_sec_type sec_type:2;
3160
3161 /* Flag set when small branches are detected. Used to
3162 select suitable defaults for the stub group size. */
3163 unsigned int has_14bit_branch:1;
3164
3165 /* Flag set when PLTCALL relocs are detected. */
3166 unsigned int has_pltcall:1;
3167 };
3168
3169 #define ppc64_elf_section_data(sec) \
3170 ((struct _ppc64_elf_section_data *) elf_section_data (sec))
3171
3172 static bfd_boolean
3173 ppc64_elf_new_section_hook (bfd *abfd, asection *sec)
3174 {
3175 if (!sec->used_by_bfd)
3176 {
3177 struct _ppc64_elf_section_data *sdata;
3178 bfd_size_type amt = sizeof (*sdata);
3179
3180 sdata = bfd_zalloc (abfd, amt);
3181 if (sdata == NULL)
3182 return FALSE;
3183 sec->used_by_bfd = sdata;
3184 }
3185
3186 return _bfd_elf_new_section_hook (abfd, sec);
3187 }
3188
3189 static struct _opd_sec_data *
3190 get_opd_info (asection * sec)
3191 {
3192 if (sec != NULL
3193 && ppc64_elf_section_data (sec) != NULL
3194 && ppc64_elf_section_data (sec)->sec_type == sec_opd)
3195 return &ppc64_elf_section_data (sec)->u.opd;
3196 return NULL;
3197 }
3198 \f
3199 /* Parameters for the qsort hook. */
3200 static bfd_boolean synthetic_relocatable;
3201 static asection *synthetic_opd;
3202
3203 /* qsort comparison function for ppc64_elf_get_synthetic_symtab. */
3204
3205 static int
3206 compare_symbols (const void *ap, const void *bp)
3207 {
3208 const asymbol *a = * (const asymbol **) ap;
3209 const asymbol *b = * (const asymbol **) bp;
3210
3211 /* Section symbols first. */
3212 if ((a->flags & BSF_SECTION_SYM) && !(b->flags & BSF_SECTION_SYM))
3213 return -1;
3214 if (!(a->flags & BSF_SECTION_SYM) && (b->flags & BSF_SECTION_SYM))
3215 return 1;
3216
3217 /* then .opd symbols. */
3218 if (synthetic_opd != NULL)
3219 {
3220 if (strcmp (a->section->name, ".opd") == 0
3221 && strcmp (b->section->name, ".opd") != 0)
3222 return -1;
3223 if (strcmp (a->section->name, ".opd") != 0
3224 && strcmp (b->section->name, ".opd") == 0)
3225 return 1;
3226 }
3227
3228 /* then other code symbols. */
3229 if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3230 == (SEC_CODE | SEC_ALLOC)
3231 && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3232 != (SEC_CODE | SEC_ALLOC))
3233 return -1;
3234
3235 if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3236 != (SEC_CODE | SEC_ALLOC)
3237 && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3238 == (SEC_CODE | SEC_ALLOC))
3239 return 1;
3240
3241 if (synthetic_relocatable)
3242 {
3243 if (a->section->id < b->section->id)
3244 return -1;
3245
3246 if (a->section->id > b->section->id)
3247 return 1;
3248 }
3249
3250 if (a->value + a->section->vma < b->value + b->section->vma)
3251 return -1;
3252
3253 if (a->value + a->section->vma > b->value + b->section->vma)
3254 return 1;
3255
3256 /* For syms with the same value, prefer strong dynamic global function
3257 syms over other syms. */
3258 if ((a->flags & BSF_GLOBAL) != 0 && (b->flags & BSF_GLOBAL) == 0)
3259 return -1;
3260
3261 if ((a->flags & BSF_GLOBAL) == 0 && (b->flags & BSF_GLOBAL) != 0)
3262 return 1;
3263
3264 if ((a->flags & BSF_FUNCTION) != 0 && (b->flags & BSF_FUNCTION) == 0)
3265 return -1;
3266
3267 if ((a->flags & BSF_FUNCTION) == 0 && (b->flags & BSF_FUNCTION) != 0)
3268 return 1;
3269
3270 if ((a->flags & BSF_WEAK) == 0 && (b->flags & BSF_WEAK) != 0)
3271 return -1;
3272
3273 if ((a->flags & BSF_WEAK) != 0 && (b->flags & BSF_WEAK) == 0)
3274 return 1;
3275
3276 if ((a->flags & BSF_DYNAMIC) != 0 && (b->flags & BSF_DYNAMIC) == 0)
3277 return -1;
3278
3279 if ((a->flags & BSF_DYNAMIC) == 0 && (b->flags & BSF_DYNAMIC) != 0)
3280 return 1;
3281
3282 return a > b;
3283 }
3284
3285 /* Search SYMS for a symbol of the given VALUE. */
3286
3287 static asymbol *
3288 sym_exists_at (asymbol **syms, long lo, long hi, unsigned int id, bfd_vma value)
3289 {
3290 long mid;
3291
3292 if (id == (unsigned) -1)
3293 {
3294 while (lo < hi)
3295 {
3296 mid = (lo + hi) >> 1;
3297 if (syms[mid]->value + syms[mid]->section->vma < value)
3298 lo = mid + 1;
3299 else if (syms[mid]->value + syms[mid]->section->vma > value)
3300 hi = mid;
3301 else
3302 return syms[mid];
3303 }
3304 }
3305 else
3306 {
3307 while (lo < hi)
3308 {
3309 mid = (lo + hi) >> 1;
3310 if (syms[mid]->section->id < id)
3311 lo = mid + 1;
3312 else if (syms[mid]->section->id > id)
3313 hi = mid;
3314 else if (syms[mid]->value < value)
3315 lo = mid + 1;
3316 else if (syms[mid]->value > value)
3317 hi = mid;
3318 else
3319 return syms[mid];
3320 }
3321 }
3322 return NULL;
3323 }
3324
3325 static bfd_boolean
3326 section_covers_vma (bfd *abfd ATTRIBUTE_UNUSED, asection *section, void *ptr)
3327 {
3328 bfd_vma vma = *(bfd_vma *) ptr;
3329 return ((section->flags & SEC_ALLOC) != 0
3330 && section->vma <= vma
3331 && vma < section->vma + section->size);
3332 }
3333
3334 /* Create synthetic symbols, effectively restoring "dot-symbol" function
3335 entry syms. Also generate @plt symbols for the glink branch table.
3336 Returns count of synthetic symbols in RET or -1 on error. */
3337
3338 static long
3339 ppc64_elf_get_synthetic_symtab (bfd *abfd,
3340 long static_count, asymbol **static_syms,
3341 long dyn_count, asymbol **dyn_syms,
3342 asymbol **ret)
3343 {
3344 asymbol *s;
3345 size_t i, j, count;
3346 char *names;
3347 size_t symcount, codesecsym, codesecsymend, secsymend, opdsymend;
3348 asection *opd = NULL;
3349 bfd_boolean relocatable = (abfd->flags & (EXEC_P | DYNAMIC)) == 0;
3350 asymbol **syms;
3351 int abi = abiversion (abfd);
3352
3353 *ret = NULL;
3354
3355 if (abi < 2)
3356 {
3357 opd = bfd_get_section_by_name (abfd, ".opd");
3358 if (opd == NULL && abi == 1)
3359 return 0;
3360 }
3361
3362 syms = NULL;
3363 codesecsym = 0;
3364 codesecsymend = 0;
3365 secsymend = 0;
3366 opdsymend = 0;
3367 symcount = 0;
3368 if (opd != NULL)
3369 {
3370 symcount = static_count;
3371 if (!relocatable)
3372 symcount += dyn_count;
3373 if (symcount == 0)
3374 return 0;
3375
3376 syms = bfd_malloc ((symcount + 1) * sizeof (*syms));
3377 if (syms == NULL)
3378 return -1;
3379
3380 if (!relocatable && static_count != 0 && dyn_count != 0)
3381 {
3382 /* Use both symbol tables. */
3383 memcpy (syms, static_syms, static_count * sizeof (*syms));
3384 memcpy (syms + static_count, dyn_syms,
3385 (dyn_count + 1) * sizeof (*syms));
3386 }
3387 else if (!relocatable && static_count == 0)
3388 memcpy (syms, dyn_syms, (symcount + 1) * sizeof (*syms));
3389 else
3390 memcpy (syms, static_syms, (symcount + 1) * sizeof (*syms));
3391
3392 /* Trim uninteresting symbols. Interesting symbols are section,
3393 function, and notype symbols. */
3394 for (i = 0, j = 0; i < symcount; ++i)
3395 if ((syms[i]->flags & (BSF_FILE | BSF_OBJECT | BSF_THREAD_LOCAL
3396 | BSF_RELC | BSF_SRELC)) == 0)
3397 syms[j++] = syms[i];
3398 symcount = j;
3399
3400 synthetic_relocatable = relocatable;
3401 synthetic_opd = opd;
3402 qsort (syms, symcount, sizeof (*syms), compare_symbols);
3403
3404 if (!relocatable && symcount > 1)
3405 {
3406 /* Trim duplicate syms, since we may have merged the normal
3407 and dynamic symbols. Actually, we only care about syms
3408 that have different values, so trim any with the same
3409 value. Don't consider ifunc and ifunc resolver symbols
3410 duplicates however, because GDB wants to know whether a
3411 text symbol is an ifunc resolver. */
3412 for (i = 1, j = 1; i < symcount; ++i)
3413 {
3414 const asymbol *s0 = syms[i - 1];
3415 const asymbol *s1 = syms[i];
3416
3417 if ((s0->value + s0->section->vma
3418 != s1->value + s1->section->vma)
3419 || ((s0->flags & BSF_GNU_INDIRECT_FUNCTION)
3420 != (s1->flags & BSF_GNU_INDIRECT_FUNCTION)))
3421 syms[j++] = syms[i];
3422 }
3423 symcount = j;
3424 }
3425
3426 i = 0;
3427 /* Note that here and in compare_symbols we can't compare opd and
3428 sym->section directly. With separate debug info files, the
3429 symbols will be extracted from the debug file while abfd passed
3430 to this function is the real binary. */
3431 if (strcmp (syms[i]->section->name, ".opd") == 0)
3432 ++i;
3433 codesecsym = i;
3434
3435 for (; i < symcount; ++i)
3436 if (((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC
3437 | SEC_THREAD_LOCAL))
3438 != (SEC_CODE | SEC_ALLOC))
3439 || (syms[i]->flags & BSF_SECTION_SYM) == 0)
3440 break;
3441 codesecsymend = i;
3442
3443 for (; i < symcount; ++i)
3444 if ((syms[i]->flags & BSF_SECTION_SYM) == 0)
3445 break;
3446 secsymend = i;
3447
3448 for (; i < symcount; ++i)
3449 if (strcmp (syms[i]->section->name, ".opd") != 0)
3450 break;
3451 opdsymend = i;
3452
3453 for (; i < symcount; ++i)
3454 if ((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3455 != (SEC_CODE | SEC_ALLOC))
3456 break;
3457 symcount = i;
3458 }
3459 count = 0;
3460
3461 if (relocatable)
3462 {
3463 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3464 arelent *r;
3465 size_t size;
3466 size_t relcount;
3467
3468 if (opdsymend == secsymend)
3469 goto done;
3470
3471 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3472 relcount = (opd->flags & SEC_RELOC) ? opd->reloc_count : 0;
3473 if (relcount == 0)
3474 goto done;
3475
3476 if (!(*slurp_relocs) (abfd, opd, static_syms, FALSE))
3477 {
3478 count = -1;
3479 goto done;
3480 }
3481
3482 size = 0;
3483 for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3484 {
3485 asymbol *sym;
3486
3487 while (r < opd->relocation + relcount
3488 && r->address < syms[i]->value + opd->vma)
3489 ++r;
3490
3491 if (r == opd->relocation + relcount)
3492 break;
3493
3494 if (r->address != syms[i]->value + opd->vma)
3495 continue;
3496
3497 if (r->howto->type != R_PPC64_ADDR64)
3498 continue;
3499
3500 sym = *r->sym_ptr_ptr;
3501 if (!sym_exists_at (syms, opdsymend, symcount,
3502 sym->section->id, sym->value + r->addend))
3503 {
3504 ++count;
3505 size += sizeof (asymbol);
3506 size += strlen (syms[i]->name) + 2;
3507 }
3508 }
3509
3510 if (size == 0)
3511 goto done;
3512 s = *ret = bfd_malloc (size);
3513 if (s == NULL)
3514 {
3515 count = -1;
3516 goto done;
3517 }
3518
3519 names = (char *) (s + count);
3520
3521 for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3522 {
3523 asymbol *sym;
3524
3525 while (r < opd->relocation + relcount
3526 && r->address < syms[i]->value + opd->vma)
3527 ++r;
3528
3529 if (r == opd->relocation + relcount)
3530 break;
3531
3532 if (r->address != syms[i]->value + opd->vma)
3533 continue;
3534
3535 if (r->howto->type != R_PPC64_ADDR64)
3536 continue;
3537
3538 sym = *r->sym_ptr_ptr;
3539 if (!sym_exists_at (syms, opdsymend, symcount,
3540 sym->section->id, sym->value + r->addend))
3541 {
3542 size_t len;
3543
3544 *s = *syms[i];
3545 s->flags |= BSF_SYNTHETIC;
3546 s->section = sym->section;
3547 s->value = sym->value + r->addend;
3548 s->name = names;
3549 *names++ = '.';
3550 len = strlen (syms[i]->name);
3551 memcpy (names, syms[i]->name, len + 1);
3552 names += len + 1;
3553 /* Have udata.p point back to the original symbol this
3554 synthetic symbol was derived from. */
3555 s->udata.p = syms[i];
3556 s++;
3557 }
3558 }
3559 }
3560 else
3561 {
3562 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3563 bfd_byte *contents = NULL;
3564 size_t size;
3565 size_t plt_count = 0;
3566 bfd_vma glink_vma = 0, resolv_vma = 0;
3567 asection *dynamic, *glink = NULL, *relplt = NULL;
3568 arelent *p;
3569
3570 if (opd != NULL && !bfd_malloc_and_get_section (abfd, opd, &contents))
3571 {
3572 free_contents_and_exit_err:
3573 count = -1;
3574 free_contents_and_exit:
3575 if (contents)
3576 free (contents);
3577 goto done;
3578 }
3579
3580 size = 0;
3581 for (i = secsymend; i < opdsymend; ++i)
3582 {
3583 bfd_vma ent;
3584
3585 /* Ignore bogus symbols. */
3586 if (syms[i]->value > opd->size - 8)
3587 continue;
3588
3589 ent = bfd_get_64 (abfd, contents + syms[i]->value);
3590 if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3591 {
3592 ++count;
3593 size += sizeof (asymbol);
3594 size += strlen (syms[i]->name) + 2;
3595 }
3596 }
3597
3598 /* Get start of .glink stubs from DT_PPC64_GLINK. */
3599 if (dyn_count != 0
3600 && (dynamic = bfd_get_section_by_name (abfd, ".dynamic")) != NULL)
3601 {
3602 bfd_byte *dynbuf, *extdyn, *extdynend;
3603 size_t extdynsize;
3604 void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *);
3605
3606 if (!bfd_malloc_and_get_section (abfd, dynamic, &dynbuf))
3607 goto free_contents_and_exit_err;
3608
3609 extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
3610 swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
3611
3612 extdyn = dynbuf;
3613 extdynend = extdyn + dynamic->size;
3614 for (; extdyn < extdynend; extdyn += extdynsize)
3615 {
3616 Elf_Internal_Dyn dyn;
3617 (*swap_dyn_in) (abfd, extdyn, &dyn);
3618
3619 if (dyn.d_tag == DT_NULL)
3620 break;
3621
3622 if (dyn.d_tag == DT_PPC64_GLINK)
3623 {
3624 /* The first glink stub starts at DT_PPC64_GLINK plus 32.
3625 See comment in ppc64_elf_finish_dynamic_sections. */
3626 glink_vma = dyn.d_un.d_val + 8 * 4;
3627 /* The .glink section usually does not survive the final
3628 link; search for the section (usually .text) where the
3629 glink stubs now reside. */
3630 glink = bfd_sections_find_if (abfd, section_covers_vma,
3631 &glink_vma);
3632 break;
3633 }
3634 }
3635
3636 free (dynbuf);
3637 }
3638
3639 if (glink != NULL)
3640 {
3641 /* Determine __glink trampoline by reading the relative branch
3642 from the first glink stub. */
3643 bfd_byte buf[4];
3644 unsigned int off = 0;
3645
3646 while (bfd_get_section_contents (abfd, glink, buf,
3647 glink_vma + off - glink->vma, 4))
3648 {
3649 unsigned int insn = bfd_get_32 (abfd, buf);
3650 insn ^= B_DOT;
3651 if ((insn & ~0x3fffffc) == 0)
3652 {
3653 resolv_vma = glink_vma + off + (insn ^ 0x2000000) - 0x2000000;
3654 break;
3655 }
3656 off += 4;
3657 if (off > 4)
3658 break;
3659 }
3660
3661 if (resolv_vma)
3662 size += sizeof (asymbol) + sizeof ("__glink_PLTresolve");
3663
3664 relplt = bfd_get_section_by_name (abfd, ".rela.plt");
3665 if (relplt != NULL)
3666 {
3667 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3668 if (! (*slurp_relocs) (abfd, relplt, dyn_syms, TRUE))
3669 goto free_contents_and_exit_err;
3670
3671 plt_count = relplt->size / sizeof (Elf64_External_Rela);
3672 size += plt_count * sizeof (asymbol);
3673
3674 p = relplt->relocation;
3675 for (i = 0; i < plt_count; i++, p++)
3676 {
3677 size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
3678 if (p->addend != 0)
3679 size += sizeof ("+0x") - 1 + 16;
3680 }
3681 }
3682 }
3683
3684 if (size == 0)
3685 goto free_contents_and_exit;
3686 s = *ret = bfd_malloc (size);
3687 if (s == NULL)
3688 goto free_contents_and_exit_err;
3689
3690 names = (char *) (s + count + plt_count + (resolv_vma != 0));
3691
3692 for (i = secsymend; i < opdsymend; ++i)
3693 {
3694 bfd_vma ent;
3695
3696 if (syms[i]->value > opd->size - 8)
3697 continue;
3698
3699 ent = bfd_get_64 (abfd, contents + syms[i]->value);
3700 if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3701 {
3702 size_t lo, hi;
3703 size_t len;
3704 asection *sec = abfd->sections;
3705
3706 *s = *syms[i];
3707 lo = codesecsym;
3708 hi = codesecsymend;
3709 while (lo < hi)
3710 {
3711 size_t mid = (lo + hi) >> 1;
3712 if (syms[mid]->section->vma < ent)
3713 lo = mid + 1;
3714 else if (syms[mid]->section->vma > ent)
3715 hi = mid;
3716 else
3717 {
3718 sec = syms[mid]->section;
3719 break;
3720 }
3721 }
3722
3723 if (lo >= hi && lo > codesecsym)
3724 sec = syms[lo - 1]->section;
3725
3726 for (; sec != NULL; sec = sec->next)
3727 {
3728 if (sec->vma > ent)
3729 break;
3730 /* SEC_LOAD may not be set if SEC is from a separate debug
3731 info file. */
3732 if ((sec->flags & SEC_ALLOC) == 0)
3733 break;
3734 if ((sec->flags & SEC_CODE) != 0)
3735 s->section = sec;
3736 }
3737 s->flags |= BSF_SYNTHETIC;
3738 s->value = ent - s->section->vma;
3739 s->name = names;
3740 *names++ = '.';
3741 len = strlen (syms[i]->name);
3742 memcpy (names, syms[i]->name, len + 1);
3743 names += len + 1;
3744 /* Have udata.p point back to the original symbol this
3745 synthetic symbol was derived from. */
3746 s->udata.p = syms[i];
3747 s++;
3748 }
3749 }
3750 free (contents);
3751
3752 if (glink != NULL && relplt != NULL)
3753 {
3754 if (resolv_vma)
3755 {
3756 /* Add a symbol for the main glink trampoline. */
3757 memset (s, 0, sizeof *s);
3758 s->the_bfd = abfd;
3759 s->flags = BSF_GLOBAL | BSF_SYNTHETIC;
3760 s->section = glink;
3761 s->value = resolv_vma - glink->vma;
3762 s->name = names;
3763 memcpy (names, "__glink_PLTresolve", sizeof ("__glink_PLTresolve"));
3764 names += sizeof ("__glink_PLTresolve");
3765 s++;
3766 count++;
3767 }
3768
3769 /* FIXME: It would be very much nicer to put sym@plt on the
3770 stub rather than on the glink branch table entry. The
3771 objdump disassembler would then use a sensible symbol
3772 name on plt calls. The difficulty in doing so is
3773 a) finding the stubs, and,
3774 b) matching stubs against plt entries, and,
3775 c) there can be multiple stubs for a given plt entry.
3776
3777 Solving (a) could be done by code scanning, but older
3778 ppc64 binaries used different stubs to current code.
3779 (b) is the tricky one since you need to known the toc
3780 pointer for at least one function that uses a pic stub to
3781 be able to calculate the plt address referenced.
3782 (c) means gdb would need to set multiple breakpoints (or
3783 find the glink branch itself) when setting breakpoints
3784 for pending shared library loads. */
3785 p = relplt->relocation;
3786 for (i = 0; i < plt_count; i++, p++)
3787 {
3788 size_t len;
3789
3790 *s = **p->sym_ptr_ptr;
3791 /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set. Since
3792 we are defining a symbol, ensure one of them is set. */
3793 if ((s->flags & BSF_LOCAL) == 0)
3794 s->flags |= BSF_GLOBAL;
3795 s->flags |= BSF_SYNTHETIC;
3796 s->section = glink;
3797 s->value = glink_vma - glink->vma;
3798 s->name = names;
3799 s->udata.p = NULL;
3800 len = strlen ((*p->sym_ptr_ptr)->name);
3801 memcpy (names, (*p->sym_ptr_ptr)->name, len);
3802 names += len;
3803 if (p->addend != 0)
3804 {
3805 memcpy (names, "+0x", sizeof ("+0x") - 1);
3806 names += sizeof ("+0x") - 1;
3807 bfd_sprintf_vma (abfd, names, p->addend);
3808 names += strlen (names);
3809 }
3810 memcpy (names, "@plt", sizeof ("@plt"));
3811 names += sizeof ("@plt");
3812 s++;
3813 if (abi < 2)
3814 {
3815 glink_vma += 8;
3816 if (i >= 0x8000)
3817 glink_vma += 4;
3818 }
3819 else
3820 glink_vma += 4;
3821 }
3822 count += plt_count;
3823 }
3824 }
3825
3826 done:
3827 free (syms);
3828 return count;
3829 }
3830 \f
3831 /* The following functions are specific to the ELF linker, while
3832 functions above are used generally. Those named ppc64_elf_* are
3833 called by the main ELF linker code. They appear in this file more
3834 or less in the order in which they are called. eg.
3835 ppc64_elf_check_relocs is called early in the link process,
3836 ppc64_elf_finish_dynamic_sections is one of the last functions
3837 called.
3838
3839 PowerPC64-ELF uses a similar scheme to PowerPC64-XCOFF in that
3840 functions have both a function code symbol and a function descriptor
3841 symbol. A call to foo in a relocatable object file looks like:
3842
3843 . .text
3844 . x:
3845 . bl .foo
3846 . nop
3847
3848 The function definition in another object file might be:
3849
3850 . .section .opd
3851 . foo: .quad .foo
3852 . .quad .TOC.@tocbase
3853 . .quad 0
3854 .
3855 . .text
3856 . .foo: blr
3857
3858 When the linker resolves the call during a static link, the branch
3859 unsurprisingly just goes to .foo and the .opd information is unused.
3860 If the function definition is in a shared library, things are a little
3861 different: The call goes via a plt call stub, the opd information gets
3862 copied to the plt, and the linker patches the nop.
3863
3864 . x:
3865 . bl .foo_stub
3866 . ld 2,40(1)
3867 .
3868 .
3869 . .foo_stub:
3870 . std 2,40(1) # in practice, the call stub
3871 . addis 11,2,Lfoo@toc@ha # is slightly optimized, but
3872 . addi 11,11,Lfoo@toc@l # this is the general idea
3873 . ld 12,0(11)
3874 . ld 2,8(11)
3875 . mtctr 12
3876 . ld 11,16(11)
3877 . bctr
3878 .
3879 . .section .plt
3880 . Lfoo: reloc (R_PPC64_JMP_SLOT, foo)
3881
3882 The "reloc ()" notation is supposed to indicate that the linker emits
3883 an R_PPC64_JMP_SLOT reloc against foo. The dynamic linker does the opd
3884 copying.
3885
3886 What are the difficulties here? Well, firstly, the relocations
3887 examined by the linker in check_relocs are against the function code
3888 sym .foo, while the dynamic relocation in the plt is emitted against
3889 the function descriptor symbol, foo. Somewhere along the line, we need
3890 to carefully copy dynamic link information from one symbol to the other.
3891 Secondly, the generic part of the elf linker will make .foo a dynamic
3892 symbol as is normal for most other backends. We need foo dynamic
3893 instead, at least for an application final link. However, when
3894 creating a shared library containing foo, we need to have both symbols
3895 dynamic so that references to .foo are satisfied during the early
3896 stages of linking. Otherwise the linker might decide to pull in a
3897 definition from some other object, eg. a static library.
3898
3899 Update: As of August 2004, we support a new convention. Function
3900 calls may use the function descriptor symbol, ie. "bl foo". This
3901 behaves exactly as "bl .foo". */
3902
3903 /* Of those relocs that might be copied as dynamic relocs, this
3904 function selects those that must be copied when linking a shared
3905 library or PIE, even when the symbol is local. */
3906
3907 static int
3908 must_be_dyn_reloc (struct bfd_link_info *info,
3909 enum elf_ppc64_reloc_type r_type)
3910 {
3911 switch (r_type)
3912 {
3913 default:
3914 /* Only relative relocs can be resolved when the object load
3915 address isn't fixed. DTPREL64 is excluded because the
3916 dynamic linker needs to differentiate global dynamic from
3917 local dynamic __tls_index pairs when PPC64_OPT_TLS is set. */
3918 return 1;
3919
3920 case R_PPC64_REL32:
3921 case R_PPC64_REL64:
3922 case R_PPC64_REL30:
3923 return 0;
3924
3925 case R_PPC64_TPREL16:
3926 case R_PPC64_TPREL16_LO:
3927 case R_PPC64_TPREL16_HI:
3928 case R_PPC64_TPREL16_HA:
3929 case R_PPC64_TPREL16_DS:
3930 case R_PPC64_TPREL16_LO_DS:
3931 case R_PPC64_TPREL16_HIGH:
3932 case R_PPC64_TPREL16_HIGHA:
3933 case R_PPC64_TPREL16_HIGHER:
3934 case R_PPC64_TPREL16_HIGHERA:
3935 case R_PPC64_TPREL16_HIGHEST:
3936 case R_PPC64_TPREL16_HIGHESTA:
3937 case R_PPC64_TPREL64:
3938 /* These relocations are relative but in a shared library the
3939 linker doesn't know the thread pointer base. */
3940 return bfd_link_dll (info);
3941 }
3942 }
3943
3944 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
3945 copying dynamic variables from a shared lib into an app's dynbss
3946 section, and instead use a dynamic relocation to point into the
3947 shared lib. With code that gcc generates, it's vital that this be
3948 enabled; In the PowerPC64 ABI, the address of a function is actually
3949 the address of a function descriptor, which resides in the .opd
3950 section. gcc uses the descriptor directly rather than going via the
3951 GOT as some other ABI's do, which means that initialized function
3952 pointers must reference the descriptor. Thus, a function pointer
3953 initialized to the address of a function in a shared library will
3954 either require a copy reloc, or a dynamic reloc. Using a copy reloc
3955 redefines the function descriptor symbol to point to the copy. This
3956 presents a problem as a plt entry for that function is also
3957 initialized from the function descriptor symbol and the copy reloc
3958 may not be initialized first. */
3959 #define ELIMINATE_COPY_RELOCS 1
3960
3961 /* Section name for stubs is the associated section name plus this
3962 string. */
3963 #define STUB_SUFFIX ".stub"
3964
3965 /* Linker stubs.
3966 ppc_stub_long_branch:
3967 Used when a 14 bit branch (or even a 24 bit branch) can't reach its
3968 destination, but a 24 bit branch in a stub section will reach.
3969 . b dest
3970
3971 ppc_stub_plt_branch:
3972 Similar to the above, but a 24 bit branch in the stub section won't
3973 reach its destination.
3974 . addis %r11,%r2,xxx@toc@ha
3975 . ld %r12,xxx@toc@l(%r11)
3976 . mtctr %r12
3977 . bctr
3978
3979 ppc_stub_plt_call:
3980 Used to call a function in a shared library. If it so happens that
3981 the plt entry referenced crosses a 64k boundary, then an extra
3982 "addi %r11,%r11,xxx@toc@l" will be inserted before the "mtctr".
3983 ppc_stub_plt_call_r2save starts with "std %r2,40(%r1)".
3984 . addis %r11,%r2,xxx@toc@ha
3985 . ld %r12,xxx+0@toc@l(%r11)
3986 . mtctr %r12
3987 . ld %r2,xxx+8@toc@l(%r11)
3988 . ld %r11,xxx+16@toc@l(%r11)
3989 . bctr
3990
3991 ppc_stub_long_branch and ppc_stub_plt_branch may also have additional
3992 code to adjust the value and save r2 to support multiple toc sections.
3993 A ppc_stub_long_branch with an r2 offset looks like:
3994 . std %r2,40(%r1)
3995 . addis %r2,%r2,off@ha
3996 . addi %r2,%r2,off@l
3997 . b dest
3998
3999 A ppc_stub_plt_branch with an r2 offset looks like:
4000 . std %r2,40(%r1)
4001 . addis %r11,%r2,xxx@toc@ha
4002 . ld %r12,xxx@toc@l(%r11)
4003 . addis %r2,%r2,off@ha
4004 . addi %r2,%r2,off@l
4005 . mtctr %r12
4006 . bctr
4007
4008 All of the above stubs are shown as their ELFv1 variants. ELFv2
4009 variants exist too, simpler for plt calls since a new toc pointer
4010 and static chain are not loaded by the stub. In addition, ELFv2
4011 has some more complex stubs to handle calls marked with NOTOC
4012 relocs from functions where r2 is not a valid toc pointer. These
4013 come in two flavours, the ones shown below, and _both variants that
4014 start with "std %r2,24(%r1)" to save r2 in the unlikely event that
4015 one call is from a function where r2 is used as the toc pointer but
4016 needs a toc adjusting stub for small-model multi-toc, and another
4017 call is from a function where r2 is not valid.
4018 ppc_stub_long_branch_notoc:
4019 . mflr %r12
4020 . bcl 20,31,1f
4021 . 1:
4022 . mflr %r11
4023 . mtlr %r12
4024 . lis %r12,xxx-1b@highest
4025 . ori %r12,xxx-1b@higher
4026 . sldi %r12,%r12,32
4027 . oris %r12,%r12,xxx-1b@hi
4028 . ori %r12,%r12,xxx-1b@l
4029 . add %r12,%r11,%r12
4030 . b dest
4031
4032 ppc_stub_plt_branch_notoc:
4033 . mflr %r12
4034 . bcl 20,31,1f
4035 . 1:
4036 . mflr %r11
4037 . mtlr %r12
4038 . lis %r12,xxx-1b@highest
4039 . ori %r12,xxx-1b@higher
4040 . sldi %r12,%r12,32
4041 . oris %r12,%r12,xxx-1b@hi
4042 . ori %r12,%r12,xxx-1b@l
4043 . add %r12,%r11,%r12
4044 . mtctr %r12
4045 . bctr
4046
4047 ppc_stub_plt_call_notoc:
4048 . mflr %r12
4049 . bcl 20,31,1f
4050 . 1:
4051 . mflr %r11
4052 . mtlr %r12
4053 . lis %r12,xxx-1b@highest
4054 . ori %r12,xxx-1b@higher
4055 . sldi %r12,%r12,32
4056 . oris %r12,%r12,xxx-1b@hi
4057 . ori %r12,%r12,xxx-1b@l
4058 . ldx %r12,%r11,%r12
4059 . mtctr %r12
4060 . bctr
4061
4062 In cases where the high instructions would add zero, they are
4063 omitted and following instructions modified in some cases.
4064
4065 For a given stub group (a set of sections all using the same toc
4066 pointer value) there will be just one stub type used for any
4067 particular function symbol. For example, if printf is called from
4068 code with the tocsave optimization (ie. r2 saved in function
4069 prologue) and therefore calls use a ppc_stub_plt_call linkage stub,
4070 and from other code without the tocsave optimization requiring a
4071 ppc_stub_plt_call_r2save linkage stub, a single stub of the latter
4072 type will be created. Calls with the tocsave optimization will
4073 enter this stub after the instruction saving r2. A similar
4074 situation exists when calls are marked with R_PPC64_REL24_NOTOC
4075 relocations. These require a ppc_stub_plt_call_notoc linkage stub
4076 to call an external function like printf. If other calls to printf
4077 require a ppc_stub_plt_call linkage stub then a single
4078 ppc_stub_plt_call_notoc linkage stub will be used for both types of
4079 call. If other calls to printf require a ppc_stub_plt_call_r2save
4080 linkage stub then a single ppc_stub_plt_call_both linkage stub will
4081 be created and calls not requiring r2 to be saved will enter the
4082 stub after the r2 save instruction. There is an analogous
4083 hierarchy of long branch and plt branch stubs for local call
4084 linkage. */
4085
4086 enum ppc_stub_type {
4087 ppc_stub_none,
4088 ppc_stub_long_branch,
4089 ppc_stub_long_branch_r2off,
4090 ppc_stub_long_branch_notoc,
4091 ppc_stub_long_branch_both, /* r2off and notoc variants both needed. */
4092 ppc_stub_plt_branch,
4093 ppc_stub_plt_branch_r2off,
4094 ppc_stub_plt_branch_notoc,
4095 ppc_stub_plt_branch_both,
4096 ppc_stub_plt_call,
4097 ppc_stub_plt_call_r2save,
4098 ppc_stub_plt_call_notoc,
4099 ppc_stub_plt_call_both,
4100 ppc_stub_global_entry,
4101 ppc_stub_save_res
4102 };
4103
4104 /* Information on stub grouping. */
4105 struct map_stub
4106 {
4107 /* The stub section. */
4108 asection *stub_sec;
4109 /* This is the section to which stubs in the group will be attached. */
4110 asection *link_sec;
4111 /* Next group. */
4112 struct map_stub *next;
4113 /* Whether to emit a copy of register save/restore functions in this
4114 group. */
4115 int needs_save_res;
4116 /* Current offset within stubs after the insn restoring lr in a
4117 _notoc or _both stub using bcl for pc-relative addressing, or
4118 after the insn restoring lr in a __tls_get_addr_opt plt stub. */
4119 unsigned int lr_restore;
4120 /* Accumulated size of EH info emitted to describe return address
4121 if stubs modify lr. Does not include 17 byte FDE header. */
4122 unsigned int eh_size;
4123 /* Offset in glink_eh_frame to the start of EH info for this group. */
4124 unsigned int eh_base;
4125 };
4126
4127 struct ppc_stub_hash_entry {
4128
4129 /* Base hash table entry structure. */
4130 struct bfd_hash_entry root;
4131
4132 enum ppc_stub_type stub_type;
4133
4134 /* Group information. */
4135 struct map_stub *group;
4136
4137 /* Offset within stub_sec of the beginning of this stub. */
4138 bfd_vma stub_offset;
4139
4140 /* Given the symbol's value and its section we can determine its final
4141 value when building the stubs (so the stub knows where to jump. */
4142 bfd_vma target_value;
4143 asection *target_section;
4144
4145 /* The symbol table entry, if any, that this was derived from. */
4146 struct ppc_link_hash_entry *h;
4147 struct plt_entry *plt_ent;
4148
4149 /* Symbol type. */
4150 unsigned char symtype;
4151
4152 /* Symbol st_other. */
4153 unsigned char other;
4154 };
4155
4156 struct ppc_branch_hash_entry {
4157
4158 /* Base hash table entry structure. */
4159 struct bfd_hash_entry root;
4160
4161 /* Offset within branch lookup table. */
4162 unsigned int offset;
4163
4164 /* Generation marker. */
4165 unsigned int iter;
4166 };
4167
4168 /* Used to track dynamic relocations for local symbols. */
4169 struct ppc_dyn_relocs
4170 {
4171 struct ppc_dyn_relocs *next;
4172
4173 /* The input section of the reloc. */
4174 asection *sec;
4175
4176 /* Total number of relocs copied for the input section. */
4177 unsigned int count : 31;
4178
4179 /* Whether this entry is for STT_GNU_IFUNC symbols. */
4180 unsigned int ifunc : 1;
4181 };
4182
4183 struct ppc_link_hash_entry
4184 {
4185 struct elf_link_hash_entry elf;
4186
4187 union {
4188 /* A pointer to the most recently used stub hash entry against this
4189 symbol. */
4190 struct ppc_stub_hash_entry *stub_cache;
4191
4192 /* A pointer to the next symbol starting with a '.' */
4193 struct ppc_link_hash_entry *next_dot_sym;
4194 } u;
4195
4196 /* Track dynamic relocs copied for this symbol. */
4197 struct elf_dyn_relocs *dyn_relocs;
4198
4199 /* Link between function code and descriptor symbols. */
4200 struct ppc_link_hash_entry *oh;
4201
4202 /* Flag function code and descriptor symbols. */
4203 unsigned int is_func:1;
4204 unsigned int is_func_descriptor:1;
4205 unsigned int fake:1;
4206
4207 /* Whether global opd/toc sym has been adjusted or not.
4208 After ppc64_elf_edit_opd/ppc64_elf_edit_toc has run, this flag
4209 should be set for all globals defined in any opd/toc section. */
4210 unsigned int adjust_done:1;
4211
4212 /* Set if this is an out-of-line register save/restore function,
4213 with non-standard calling convention. */
4214 unsigned int save_res:1;
4215
4216 /* Set if a duplicate symbol with non-zero localentry is detected,
4217 even when the duplicate symbol does not provide a definition. */
4218 unsigned int non_zero_localentry:1;
4219
4220 /* Contexts in which symbol is used in the GOT (or TOC).
4221 Bits are or'd into the mask as the corresponding relocs are
4222 encountered during check_relocs, with TLS_TLS being set when any
4223 of the other TLS bits are set. tls_optimize clears bits when
4224 optimizing to indicate the corresponding GOT entry type is not
4225 needed. If set, TLS_TLS is never cleared. tls_optimize may also
4226 set TLS_TPRELGD when a GD reloc turns into a TPREL one. We use a
4227 separate flag rather than setting TPREL just for convenience in
4228 distinguishing the two cases.
4229 These flags are also kept for local symbols. */
4230 #define TLS_TLS 1 /* Any TLS reloc. */
4231 #define TLS_GD 2 /* GD reloc. */
4232 #define TLS_LD 4 /* LD reloc. */
4233 #define TLS_TPREL 8 /* TPREL reloc, => IE. */
4234 #define TLS_DTPREL 16 /* DTPREL reloc, => LD. */
4235 #define TLS_MARK 32 /* __tls_get_addr call marked. */
4236 #define TLS_TPRELGD 64 /* TPREL reloc resulting from GD->IE. */
4237 #define TLS_EXPLICIT 128 /* Marks TOC section TLS relocs. */
4238 unsigned char tls_mask;
4239
4240 /* The above field is also used to mark function symbols. In which
4241 case TLS_TLS will be 0. */
4242 #define PLT_IFUNC 2 /* STT_GNU_IFUNC. */
4243 #define PLT_KEEP 4 /* inline plt call requires plt entry. */
4244 #define NON_GOT 256 /* local symbol plt, not stored. */
4245 };
4246
4247 /* ppc64 ELF linker hash table. */
4248
4249 struct ppc_link_hash_table
4250 {
4251 struct elf_link_hash_table elf;
4252
4253 /* The stub hash table. */
4254 struct bfd_hash_table stub_hash_table;
4255
4256 /* Another hash table for plt_branch stubs. */
4257 struct bfd_hash_table branch_hash_table;
4258
4259 /* Hash table for function prologue tocsave. */
4260 htab_t tocsave_htab;
4261
4262 /* Various options and other info passed from the linker. */
4263 struct ppc64_elf_params *params;
4264
4265 /* The size of sec_info below. */
4266 unsigned int sec_info_arr_size;
4267
4268 /* Per-section array of extra section info. Done this way rather
4269 than as part of ppc64_elf_section_data so we have the info for
4270 non-ppc64 sections. */
4271 struct
4272 {
4273 /* Along with elf_gp, specifies the TOC pointer used by this section. */
4274 bfd_vma toc_off;
4275
4276 union
4277 {
4278 /* The section group that this section belongs to. */
4279 struct map_stub *group;
4280 /* A temp section list pointer. */
4281 asection *list;
4282 } u;
4283 } *sec_info;
4284
4285 /* Linked list of groups. */
4286 struct map_stub *group;
4287
4288 /* Temp used when calculating TOC pointers. */
4289 bfd_vma toc_curr;
4290 bfd *toc_bfd;
4291 asection *toc_first_sec;
4292
4293 /* Used when adding symbols. */
4294 struct ppc_link_hash_entry *dot_syms;
4295
4296 /* Shortcuts to get to dynamic linker sections. */
4297 asection *glink;
4298 asection *global_entry;
4299 asection *sfpr;
4300 asection *pltlocal;
4301 asection *relpltlocal;
4302 asection *brlt;
4303 asection *relbrlt;
4304 asection *glink_eh_frame;
4305
4306 /* Shortcut to .__tls_get_addr and __tls_get_addr. */
4307 struct ppc_link_hash_entry *tls_get_addr;
4308 struct ppc_link_hash_entry *tls_get_addr_fd;
4309
4310 /* The size of reliplt used by got entry relocs. */
4311 bfd_size_type got_reli_size;
4312
4313 /* Statistics. */
4314 unsigned long stub_count[ppc_stub_global_entry];
4315
4316 /* Number of stubs against global syms. */
4317 unsigned long stub_globals;
4318
4319 /* Set if we're linking code with function descriptors. */
4320 unsigned int opd_abi:1;
4321
4322 /* Support for multiple toc sections. */
4323 unsigned int do_multi_toc:1;
4324 unsigned int multi_toc_needed:1;
4325 unsigned int second_toc_pass:1;
4326 unsigned int do_toc_opt:1;
4327
4328 /* Set if tls optimization is enabled. */
4329 unsigned int do_tls_opt:1;
4330
4331 /* Set if inline plt calls should be converted to direct calls. */
4332 unsigned int can_convert_all_inline_plt:1;
4333
4334 /* Set on error. */
4335 unsigned int stub_error:1;
4336
4337 /* Whether func_desc_adjust needs to be run over symbols. */
4338 unsigned int need_func_desc_adj:1;
4339
4340 /* Whether there exist local gnu indirect function resolvers,
4341 referenced by dynamic relocations. */
4342 unsigned int local_ifunc_resolver:1;
4343 unsigned int maybe_local_ifunc_resolver:1;
4344
4345 /* Whether plt calls for ELFv2 localentry:0 funcs have been optimized. */
4346 unsigned int has_plt_localentry0:1;
4347
4348 /* Incremented every time we size stubs. */
4349 unsigned int stub_iteration;
4350
4351 /* Small local sym cache. */
4352 struct sym_cache sym_cache;
4353 };
4354
4355 /* Rename some of the generic section flags to better document how they
4356 are used here. */
4357
4358 /* Nonzero if this section has TLS related relocations. */
4359 #define has_tls_reloc sec_flg0
4360
4361 /* Nonzero if this section has an old-style call to __tls_get_addr. */
4362 #define has_tls_get_addr_call sec_flg1
4363
4364 /* Nonzero if this section has any toc or got relocs. */
4365 #define has_toc_reloc sec_flg2
4366
4367 /* Nonzero if this section has a call to another section that uses
4368 the toc or got. */
4369 #define makes_toc_func_call sec_flg3
4370
4371 /* Recursion protection when determining above flag. */
4372 #define call_check_in_progress sec_flg4
4373 #define call_check_done sec_flg5
4374
4375 /* Get the ppc64 ELF linker hash table from a link_info structure. */
4376
4377 #define ppc_hash_table(p) \
4378 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
4379 == PPC64_ELF_DATA ? ((struct ppc_link_hash_table *) ((p)->hash)) : NULL)
4380
4381 #define ppc_stub_hash_lookup(table, string, create, copy) \
4382 ((struct ppc_stub_hash_entry *) \
4383 bfd_hash_lookup ((table), (string), (create), (copy)))
4384
4385 #define ppc_branch_hash_lookup(table, string, create, copy) \
4386 ((struct ppc_branch_hash_entry *) \
4387 bfd_hash_lookup ((table), (string), (create), (copy)))
4388
4389 /* Create an entry in the stub hash table. */
4390
4391 static struct bfd_hash_entry *
4392 stub_hash_newfunc (struct bfd_hash_entry *entry,
4393 struct bfd_hash_table *table,
4394 const char *string)
4395 {
4396 /* Allocate the structure if it has not already been allocated by a
4397 subclass. */
4398 if (entry == NULL)
4399 {
4400 entry = bfd_hash_allocate (table, sizeof (struct ppc_stub_hash_entry));
4401 if (entry == NULL)
4402 return entry;
4403 }
4404
4405 /* Call the allocation method of the superclass. */
4406 entry = bfd_hash_newfunc (entry, table, string);
4407 if (entry != NULL)
4408 {
4409 struct ppc_stub_hash_entry *eh;
4410
4411 /* Initialize the local fields. */
4412 eh = (struct ppc_stub_hash_entry *) entry;
4413 eh->stub_type = ppc_stub_none;
4414 eh->group = NULL;
4415 eh->stub_offset = 0;
4416 eh->target_value = 0;
4417 eh->target_section = NULL;
4418 eh->h = NULL;
4419 eh->plt_ent = NULL;
4420 eh->other = 0;
4421 }
4422
4423 return entry;
4424 }
4425
4426 /* Create an entry in the branch hash table. */
4427
4428 static struct bfd_hash_entry *
4429 branch_hash_newfunc (struct bfd_hash_entry *entry,
4430 struct bfd_hash_table *table,
4431 const char *string)
4432 {
4433 /* Allocate the structure if it has not already been allocated by a
4434 subclass. */
4435 if (entry == NULL)
4436 {
4437 entry = bfd_hash_allocate (table, sizeof (struct ppc_branch_hash_entry));
4438 if (entry == NULL)
4439 return entry;
4440 }
4441
4442 /* Call the allocation method of the superclass. */
4443 entry = bfd_hash_newfunc (entry, table, string);
4444 if (entry != NULL)
4445 {
4446 struct ppc_branch_hash_entry *eh;
4447
4448 /* Initialize the local fields. */
4449 eh = (struct ppc_branch_hash_entry *) entry;
4450 eh->offset = 0;
4451 eh->iter = 0;
4452 }
4453
4454 return entry;
4455 }
4456
4457 /* Create an entry in a ppc64 ELF linker hash table. */
4458
4459 static struct bfd_hash_entry *
4460 link_hash_newfunc (struct bfd_hash_entry *entry,
4461 struct bfd_hash_table *table,
4462 const char *string)
4463 {
4464 /* Allocate the structure if it has not already been allocated by a
4465 subclass. */
4466 if (entry == NULL)
4467 {
4468 entry = bfd_hash_allocate (table, sizeof (struct ppc_link_hash_entry));
4469 if (entry == NULL)
4470 return entry;
4471 }
4472
4473 /* Call the allocation method of the superclass. */
4474 entry = _bfd_elf_link_hash_newfunc (entry, table, string);
4475 if (entry != NULL)
4476 {
4477 struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) entry;
4478
4479 memset (&eh->u.stub_cache, 0,
4480 (sizeof (struct ppc_link_hash_entry)
4481 - offsetof (struct ppc_link_hash_entry, u.stub_cache)));
4482
4483 /* When making function calls, old ABI code references function entry
4484 points (dot symbols), while new ABI code references the function
4485 descriptor symbol. We need to make any combination of reference and
4486 definition work together, without breaking archive linking.
4487
4488 For a defined function "foo" and an undefined call to "bar":
4489 An old object defines "foo" and ".foo", references ".bar" (possibly
4490 "bar" too).
4491 A new object defines "foo" and references "bar".
4492
4493 A new object thus has no problem with its undefined symbols being
4494 satisfied by definitions in an old object. On the other hand, the
4495 old object won't have ".bar" satisfied by a new object.
4496
4497 Keep a list of newly added dot-symbols. */
4498
4499 if (string[0] == '.')
4500 {
4501 struct ppc_link_hash_table *htab;
4502
4503 htab = (struct ppc_link_hash_table *) table;
4504 eh->u.next_dot_sym = htab->dot_syms;
4505 htab->dot_syms = eh;
4506 }
4507 }
4508
4509 return entry;
4510 }
4511
4512 struct tocsave_entry {
4513 asection *sec;
4514 bfd_vma offset;
4515 };
4516
4517 static hashval_t
4518 tocsave_htab_hash (const void *p)
4519 {
4520 const struct tocsave_entry *e = (const struct tocsave_entry *) p;
4521 return ((bfd_vma) (intptr_t) e->sec ^ e->offset) >> 3;
4522 }
4523
4524 static int
4525 tocsave_htab_eq (const void *p1, const void *p2)
4526 {
4527 const struct tocsave_entry *e1 = (const struct tocsave_entry *) p1;
4528 const struct tocsave_entry *e2 = (const struct tocsave_entry *) p2;
4529 return e1->sec == e2->sec && e1->offset == e2->offset;
4530 }
4531
4532 /* Destroy a ppc64 ELF linker hash table. */
4533
4534 static void
4535 ppc64_elf_link_hash_table_free (bfd *obfd)
4536 {
4537 struct ppc_link_hash_table *htab;
4538
4539 htab = (struct ppc_link_hash_table *) obfd->link.hash;
4540 if (htab->tocsave_htab)
4541 htab_delete (htab->tocsave_htab);
4542 bfd_hash_table_free (&htab->branch_hash_table);
4543 bfd_hash_table_free (&htab->stub_hash_table);
4544 _bfd_elf_link_hash_table_free (obfd);
4545 }
4546
4547 /* Create a ppc64 ELF linker hash table. */
4548
4549 static struct bfd_link_hash_table *
4550 ppc64_elf_link_hash_table_create (bfd *abfd)
4551 {
4552 struct ppc_link_hash_table *htab;
4553 bfd_size_type amt = sizeof (struct ppc_link_hash_table);
4554
4555 htab = bfd_zmalloc (amt);
4556 if (htab == NULL)
4557 return NULL;
4558
4559 if (!_bfd_elf_link_hash_table_init (&htab->elf, abfd, link_hash_newfunc,
4560 sizeof (struct ppc_link_hash_entry),
4561 PPC64_ELF_DATA))
4562 {
4563 free (htab);
4564 return NULL;
4565 }
4566
4567 /* Init the stub hash table too. */
4568 if (!bfd_hash_table_init (&htab->stub_hash_table, stub_hash_newfunc,
4569 sizeof (struct ppc_stub_hash_entry)))
4570 {
4571 _bfd_elf_link_hash_table_free (abfd);
4572 return NULL;
4573 }
4574
4575 /* And the branch hash table. */
4576 if (!bfd_hash_table_init (&htab->branch_hash_table, branch_hash_newfunc,
4577 sizeof (struct ppc_branch_hash_entry)))
4578 {
4579 bfd_hash_table_free (&htab->stub_hash_table);
4580 _bfd_elf_link_hash_table_free (abfd);
4581 return NULL;
4582 }
4583
4584 htab->tocsave_htab = htab_try_create (1024,
4585 tocsave_htab_hash,
4586 tocsave_htab_eq,
4587 NULL);
4588 if (htab->tocsave_htab == NULL)
4589 {
4590 ppc64_elf_link_hash_table_free (abfd);
4591 return NULL;
4592 }
4593 htab->elf.root.hash_table_free = ppc64_elf_link_hash_table_free;
4594
4595 /* Initializing two fields of the union is just cosmetic. We really
4596 only care about glist, but when compiled on a 32-bit host the
4597 bfd_vma fields are larger. Setting the bfd_vma to zero makes
4598 debugger inspection of these fields look nicer. */
4599 htab->elf.init_got_refcount.refcount = 0;
4600 htab->elf.init_got_refcount.glist = NULL;
4601 htab->elf.init_plt_refcount.refcount = 0;
4602 htab->elf.init_plt_refcount.glist = NULL;
4603 htab->elf.init_got_offset.offset = 0;
4604 htab->elf.init_got_offset.glist = NULL;
4605 htab->elf.init_plt_offset.offset = 0;
4606 htab->elf.init_plt_offset.glist = NULL;
4607
4608 return &htab->elf.root;
4609 }
4610
4611 /* Create sections for linker generated code. */
4612
4613 static bfd_boolean
4614 create_linkage_sections (bfd *dynobj, struct bfd_link_info *info)
4615 {
4616 struct ppc_link_hash_table *htab;
4617 flagword flags;
4618
4619 htab = ppc_hash_table (info);
4620
4621 flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY
4622 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4623 if (htab->params->save_restore_funcs)
4624 {
4625 /* Create .sfpr for code to save and restore fp regs. */
4626 htab->sfpr = bfd_make_section_anyway_with_flags (dynobj, ".sfpr",
4627 flags);
4628 if (htab->sfpr == NULL
4629 || ! bfd_set_section_alignment (dynobj, htab->sfpr, 2))
4630 return FALSE;
4631 }
4632
4633 if (bfd_link_relocatable (info))
4634 return TRUE;
4635
4636 /* Create .glink for lazy dynamic linking support. */
4637 htab->glink = bfd_make_section_anyway_with_flags (dynobj, ".glink",
4638 flags);
4639 if (htab->glink == NULL
4640 || ! bfd_set_section_alignment (dynobj, htab->glink, 3))
4641 return FALSE;
4642
4643 /* The part of .glink used by global entry stubs, separate so that
4644 it can be aligned appropriately without affecting htab->glink. */
4645 htab->global_entry = bfd_make_section_anyway_with_flags (dynobj, ".glink",
4646 flags);
4647 if (htab->global_entry == NULL
4648 || ! bfd_set_section_alignment (dynobj, htab->global_entry, 2))
4649 return FALSE;
4650
4651 if (!info->no_ld_generated_unwind_info)
4652 {
4653 flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_HAS_CONTENTS
4654 | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4655 htab->glink_eh_frame = bfd_make_section_anyway_with_flags (dynobj,
4656 ".eh_frame",
4657 flags);
4658 if (htab->glink_eh_frame == NULL
4659 || !bfd_set_section_alignment (dynobj, htab->glink_eh_frame, 2))
4660 return FALSE;
4661 }
4662
4663 flags = SEC_ALLOC | SEC_LINKER_CREATED;
4664 htab->elf.iplt = bfd_make_section_anyway_with_flags (dynobj, ".iplt", flags);
4665 if (htab->elf.iplt == NULL
4666 || ! bfd_set_section_alignment (dynobj, htab->elf.iplt, 3))
4667 return FALSE;
4668
4669 flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4670 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4671 htab->elf.irelplt
4672 = bfd_make_section_anyway_with_flags (dynobj, ".rela.iplt", flags);
4673 if (htab->elf.irelplt == NULL
4674 || ! bfd_set_section_alignment (dynobj, htab->elf.irelplt, 3))
4675 return FALSE;
4676
4677 /* Create branch lookup table for plt_branch stubs. */
4678 flags = (SEC_ALLOC | SEC_LOAD
4679 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4680 htab->brlt = bfd_make_section_anyway_with_flags (dynobj, ".branch_lt",
4681 flags);
4682 if (htab->brlt == NULL
4683 || ! bfd_set_section_alignment (dynobj, htab->brlt, 3))
4684 return FALSE;
4685
4686 /* Local plt entries, put in .branch_lt but a separate section for
4687 convenience. */
4688 htab->pltlocal = bfd_make_section_anyway_with_flags (dynobj, ".branch_lt",
4689 flags);
4690 if (htab->pltlocal == NULL
4691 || ! bfd_set_section_alignment (dynobj, htab->pltlocal, 3))
4692 return FALSE;
4693
4694 if (!bfd_link_pic (info))
4695 return TRUE;
4696
4697 flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4698 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4699 htab->relbrlt
4700 = bfd_make_section_anyway_with_flags (dynobj, ".rela.branch_lt", flags);
4701 if (htab->relbrlt == NULL
4702 || ! bfd_set_section_alignment (dynobj, htab->relbrlt, 3))
4703 return FALSE;
4704
4705 htab->relpltlocal
4706 = bfd_make_section_anyway_with_flags (dynobj, ".rela.branch_lt", flags);
4707 if (htab->relpltlocal == NULL
4708 || ! bfd_set_section_alignment (dynobj, htab->relpltlocal, 3))
4709 return FALSE;
4710
4711 return TRUE;
4712 }
4713
4714 /* Satisfy the ELF linker by filling in some fields in our fake bfd. */
4715
4716 bfd_boolean
4717 ppc64_elf_init_stub_bfd (struct bfd_link_info *info,
4718 struct ppc64_elf_params *params)
4719 {
4720 struct ppc_link_hash_table *htab;
4721
4722 elf_elfheader (params->stub_bfd)->e_ident[EI_CLASS] = ELFCLASS64;
4723
4724 /* Always hook our dynamic sections into the first bfd, which is the
4725 linker created stub bfd. This ensures that the GOT header is at
4726 the start of the output TOC section. */
4727 htab = ppc_hash_table (info);
4728 htab->elf.dynobj = params->stub_bfd;
4729 htab->params = params;
4730
4731 return create_linkage_sections (htab->elf.dynobj, info);
4732 }
4733
4734 /* Build a name for an entry in the stub hash table. */
4735
4736 static char *
4737 ppc_stub_name (const asection *input_section,
4738 const asection *sym_sec,
4739 const struct ppc_link_hash_entry *h,
4740 const Elf_Internal_Rela *rel)
4741 {
4742 char *stub_name;
4743 ssize_t len;
4744
4745 /* rel->r_addend is actually 64 bit, but who uses more than +/- 2^31
4746 offsets from a sym as a branch target? In fact, we could
4747 probably assume the addend is always zero. */
4748 BFD_ASSERT (((int) rel->r_addend & 0xffffffff) == rel->r_addend);
4749
4750 if (h)
4751 {
4752 len = 8 + 1 + strlen (h->elf.root.root.string) + 1 + 8 + 1;
4753 stub_name = bfd_malloc (len);
4754 if (stub_name == NULL)
4755 return stub_name;
4756
4757 len = sprintf (stub_name, "%08x.%s+%x",
4758 input_section->id & 0xffffffff,
4759 h->elf.root.root.string,
4760 (int) rel->r_addend & 0xffffffff);
4761 }
4762 else
4763 {
4764 len = 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1;
4765 stub_name = bfd_malloc (len);
4766 if (stub_name == NULL)
4767 return stub_name;
4768
4769 len = sprintf (stub_name, "%08x.%x:%x+%x",
4770 input_section->id & 0xffffffff,
4771 sym_sec->id & 0xffffffff,
4772 (int) ELF64_R_SYM (rel->r_info) & 0xffffffff,
4773 (int) rel->r_addend & 0xffffffff);
4774 }
4775 if (len > 2 && stub_name[len - 2] == '+' && stub_name[len - 1] == '0')
4776 stub_name[len - 2] = 0;
4777 return stub_name;
4778 }
4779
4780 /* Look up an entry in the stub hash. Stub entries are cached because
4781 creating the stub name takes a bit of time. */
4782
4783 static struct ppc_stub_hash_entry *
4784 ppc_get_stub_entry (const asection *input_section,
4785 const asection *sym_sec,
4786 struct ppc_link_hash_entry *h,
4787 const Elf_Internal_Rela *rel,
4788 struct ppc_link_hash_table *htab)
4789 {
4790 struct ppc_stub_hash_entry *stub_entry;
4791 struct map_stub *group;
4792
4793 /* If this input section is part of a group of sections sharing one
4794 stub section, then use the id of the first section in the group.
4795 Stub names need to include a section id, as there may well be
4796 more than one stub used to reach say, printf, and we need to
4797 distinguish between them. */
4798 group = htab->sec_info[input_section->id].u.group;
4799 if (group == NULL)
4800 return NULL;
4801
4802 if (h != NULL && h->u.stub_cache != NULL
4803 && h->u.stub_cache->h == h
4804 && h->u.stub_cache->group == group)
4805 {
4806 stub_entry = h->u.stub_cache;
4807 }
4808 else
4809 {
4810 char *stub_name;
4811
4812 stub_name = ppc_stub_name (group->link_sec, sym_sec, h, rel);
4813 if (stub_name == NULL)
4814 return NULL;
4815
4816 stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
4817 stub_name, FALSE, FALSE);
4818 if (h != NULL)
4819 h->u.stub_cache = stub_entry;
4820
4821 free (stub_name);
4822 }
4823
4824 return stub_entry;
4825 }
4826
4827 /* Add a new stub entry to the stub hash. Not all fields of the new
4828 stub entry are initialised. */
4829
4830 static struct ppc_stub_hash_entry *
4831 ppc_add_stub (const char *stub_name,
4832 asection *section,
4833 struct bfd_link_info *info)
4834 {
4835 struct ppc_link_hash_table *htab = ppc_hash_table (info);
4836 struct map_stub *group;
4837 asection *link_sec;
4838 asection *stub_sec;
4839 struct ppc_stub_hash_entry *stub_entry;
4840
4841 group = htab->sec_info[section->id].u.group;
4842 link_sec = group->link_sec;
4843 stub_sec = group->stub_sec;
4844 if (stub_sec == NULL)
4845 {
4846 size_t namelen;
4847 bfd_size_type len;
4848 char *s_name;
4849
4850 namelen = strlen (link_sec->name);
4851 len = namelen + sizeof (STUB_SUFFIX);
4852 s_name = bfd_alloc (htab->params->stub_bfd, len);
4853 if (s_name == NULL)
4854 return NULL;
4855
4856 memcpy (s_name, link_sec->name, namelen);
4857 memcpy (s_name + namelen, STUB_SUFFIX, sizeof (STUB_SUFFIX));
4858 stub_sec = (*htab->params->add_stub_section) (s_name, link_sec);
4859 if (stub_sec == NULL)
4860 return NULL;
4861 group->stub_sec = stub_sec;
4862 }
4863
4864 /* Enter this entry into the linker stub hash table. */
4865 stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table, stub_name,
4866 TRUE, FALSE);
4867 if (stub_entry == NULL)
4868 {
4869 /* xgettext:c-format */
4870 _bfd_error_handler (_("%pB: cannot create stub entry %s"),
4871 section->owner, stub_name);
4872 return NULL;
4873 }
4874
4875 stub_entry->group = group;
4876 stub_entry->stub_offset = 0;
4877 return stub_entry;
4878 }
4879
4880 /* Create .got and .rela.got sections in ABFD, and .got in dynobj if
4881 not already done. */
4882
4883 static bfd_boolean
4884 create_got_section (bfd *abfd, struct bfd_link_info *info)
4885 {
4886 asection *got, *relgot;
4887 flagword flags;
4888 struct ppc_link_hash_table *htab = ppc_hash_table (info);
4889
4890 if (!is_ppc64_elf (abfd))
4891 return FALSE;
4892 if (htab == NULL)
4893 return FALSE;
4894
4895 if (!htab->elf.sgot
4896 && !_bfd_elf_create_got_section (htab->elf.dynobj, info))
4897 return FALSE;
4898
4899 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
4900 | SEC_LINKER_CREATED);
4901
4902 got = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
4903 if (!got
4904 || !bfd_set_section_alignment (abfd, got, 3))
4905 return FALSE;
4906
4907 relgot = bfd_make_section_anyway_with_flags (abfd, ".rela.got",
4908 flags | SEC_READONLY);
4909 if (!relgot
4910 || ! bfd_set_section_alignment (abfd, relgot, 3))
4911 return FALSE;
4912
4913 ppc64_elf_tdata (abfd)->got = got;
4914 ppc64_elf_tdata (abfd)->relgot = relgot;
4915 return TRUE;
4916 }
4917
4918 /* Follow indirect and warning symbol links. */
4919
4920 static inline struct bfd_link_hash_entry *
4921 follow_link (struct bfd_link_hash_entry *h)
4922 {
4923 while (h->type == bfd_link_hash_indirect
4924 || h->type == bfd_link_hash_warning)
4925 h = h->u.i.link;
4926 return h;
4927 }
4928
4929 static inline struct elf_link_hash_entry *
4930 elf_follow_link (struct elf_link_hash_entry *h)
4931 {
4932 return (struct elf_link_hash_entry *) follow_link (&h->root);
4933 }
4934
4935 static inline struct ppc_link_hash_entry *
4936 ppc_follow_link (struct ppc_link_hash_entry *h)
4937 {
4938 return (struct ppc_link_hash_entry *) follow_link (&h->elf.root);
4939 }
4940
4941 /* Merge PLT info on FROM with that on TO. */
4942
4943 static void
4944 move_plt_plist (struct ppc_link_hash_entry *from,
4945 struct ppc_link_hash_entry *to)
4946 {
4947 if (from->elf.plt.plist != NULL)
4948 {
4949 if (to->elf.plt.plist != NULL)
4950 {
4951 struct plt_entry **entp;
4952 struct plt_entry *ent;
4953
4954 for (entp = &from->elf.plt.plist; (ent = *entp) != NULL; )
4955 {
4956 struct plt_entry *dent;
4957
4958 for (dent = to->elf.plt.plist; dent != NULL; dent = dent->next)
4959 if (dent->addend == ent->addend)
4960 {
4961 dent->plt.refcount += ent->plt.refcount;
4962 *entp = ent->next;
4963 break;
4964 }
4965 if (dent == NULL)
4966 entp = &ent->next;
4967 }
4968 *entp = to->elf.plt.plist;
4969 }
4970
4971 to->elf.plt.plist = from->elf.plt.plist;
4972 from->elf.plt.plist = NULL;
4973 }
4974 }
4975
4976 /* Copy the extra info we tack onto an elf_link_hash_entry. */
4977
4978 static void
4979 ppc64_elf_copy_indirect_symbol (struct bfd_link_info *info,
4980 struct elf_link_hash_entry *dir,
4981 struct elf_link_hash_entry *ind)
4982 {
4983 struct ppc_link_hash_entry *edir, *eind;
4984
4985 edir = (struct ppc_link_hash_entry *) dir;
4986 eind = (struct ppc_link_hash_entry *) ind;
4987
4988 edir->is_func |= eind->is_func;
4989 edir->is_func_descriptor |= eind->is_func_descriptor;
4990 edir->tls_mask |= eind->tls_mask;
4991 if (eind->oh != NULL)
4992 edir->oh = ppc_follow_link (eind->oh);
4993
4994 if (edir->elf.versioned != versioned_hidden)
4995 edir->elf.ref_dynamic |= eind->elf.ref_dynamic;
4996 edir->elf.ref_regular |= eind->elf.ref_regular;
4997 edir->elf.ref_regular_nonweak |= eind->elf.ref_regular_nonweak;
4998 edir->elf.non_got_ref |= eind->elf.non_got_ref;
4999 edir->elf.needs_plt |= eind->elf.needs_plt;
5000 edir->elf.pointer_equality_needed |= eind->elf.pointer_equality_needed;
5001
5002 /* If we were called to copy over info for a weak sym, don't copy
5003 dyn_relocs, plt/got info, or dynindx. We used to copy dyn_relocs
5004 in order to simplify readonly_dynrelocs and save a field in the
5005 symbol hash entry, but that means dyn_relocs can't be used in any
5006 tests about a specific symbol, or affect other symbol flags which
5007 are then tested. */
5008 if (eind->elf.root.type != bfd_link_hash_indirect)
5009 return;
5010
5011 /* Copy over any dynamic relocs we may have on the indirect sym. */
5012 if (eind->dyn_relocs != NULL)
5013 {
5014 if (edir->dyn_relocs != NULL)
5015 {
5016 struct elf_dyn_relocs **pp;
5017 struct elf_dyn_relocs *p;
5018
5019 /* Add reloc counts against the indirect sym to the direct sym
5020 list. Merge any entries against the same section. */
5021 for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
5022 {
5023 struct elf_dyn_relocs *q;
5024
5025 for (q = edir->dyn_relocs; q != NULL; q = q->next)
5026 if (q->sec == p->sec)
5027 {
5028 q->pc_count += p->pc_count;
5029 q->count += p->count;
5030 *pp = p->next;
5031 break;
5032 }
5033 if (q == NULL)
5034 pp = &p->next;
5035 }
5036 *pp = edir->dyn_relocs;
5037 }
5038
5039 edir->dyn_relocs = eind->dyn_relocs;
5040 eind->dyn_relocs = NULL;
5041 }
5042
5043 /* Copy over got entries that we may have already seen to the
5044 symbol which just became indirect. */
5045 if (eind->elf.got.glist != NULL)
5046 {
5047 if (edir->elf.got.glist != NULL)
5048 {
5049 struct got_entry **entp;
5050 struct got_entry *ent;
5051
5052 for (entp = &eind->elf.got.glist; (ent = *entp) != NULL; )
5053 {
5054 struct got_entry *dent;
5055
5056 for (dent = edir->elf.got.glist; dent != NULL; dent = dent->next)
5057 if (dent->addend == ent->addend
5058 && dent->owner == ent->owner
5059 && dent->tls_type == ent->tls_type)
5060 {
5061 dent->got.refcount += ent->got.refcount;
5062 *entp = ent->next;
5063 break;
5064 }
5065 if (dent == NULL)
5066 entp = &ent->next;
5067 }
5068 *entp = edir->elf.got.glist;
5069 }
5070
5071 edir->elf.got.glist = eind->elf.got.glist;
5072 eind->elf.got.glist = NULL;
5073 }
5074
5075 /* And plt entries. */
5076 move_plt_plist (eind, edir);
5077
5078 if (eind->elf.dynindx != -1)
5079 {
5080 if (edir->elf.dynindx != -1)
5081 _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
5082 edir->elf.dynstr_index);
5083 edir->elf.dynindx = eind->elf.dynindx;
5084 edir->elf.dynstr_index = eind->elf.dynstr_index;
5085 eind->elf.dynindx = -1;
5086 eind->elf.dynstr_index = 0;
5087 }
5088 }
5089
5090 /* Find the function descriptor hash entry from the given function code
5091 hash entry FH. Link the entries via their OH fields. */
5092
5093 static struct ppc_link_hash_entry *
5094 lookup_fdh (struct ppc_link_hash_entry *fh, struct ppc_link_hash_table *htab)
5095 {
5096 struct ppc_link_hash_entry *fdh = fh->oh;
5097
5098 if (fdh == NULL)
5099 {
5100 const char *fd_name = fh->elf.root.root.string + 1;
5101
5102 fdh = (struct ppc_link_hash_entry *)
5103 elf_link_hash_lookup (&htab->elf, fd_name, FALSE, FALSE, FALSE);
5104 if (fdh == NULL)
5105 return fdh;
5106
5107 fdh->is_func_descriptor = 1;
5108 fdh->oh = fh;
5109 fh->is_func = 1;
5110 fh->oh = fdh;
5111 }
5112
5113 fdh = ppc_follow_link (fdh);
5114 fdh->is_func_descriptor = 1;
5115 fdh->oh = fh;
5116 return fdh;
5117 }
5118
5119 /* Make a fake function descriptor sym for the undefined code sym FH. */
5120
5121 static struct ppc_link_hash_entry *
5122 make_fdh (struct bfd_link_info *info,
5123 struct ppc_link_hash_entry *fh)
5124 {
5125 bfd *abfd = fh->elf.root.u.undef.abfd;
5126 struct bfd_link_hash_entry *bh = NULL;
5127 struct ppc_link_hash_entry *fdh;
5128 flagword flags = (fh->elf.root.type == bfd_link_hash_undefweak
5129 ? BSF_WEAK
5130 : BSF_GLOBAL);
5131
5132 if (!_bfd_generic_link_add_one_symbol (info, abfd,
5133 fh->elf.root.root.string + 1,
5134 flags, bfd_und_section_ptr, 0,
5135 NULL, FALSE, FALSE, &bh))
5136 return NULL;
5137
5138 fdh = (struct ppc_link_hash_entry *) bh;
5139 fdh->elf.non_elf = 0;
5140 fdh->fake = 1;
5141 fdh->is_func_descriptor = 1;
5142 fdh->oh = fh;
5143 fh->is_func = 1;
5144 fh->oh = fdh;
5145 return fdh;
5146 }
5147
5148 /* Fix function descriptor symbols defined in .opd sections to be
5149 function type. */
5150
5151 static bfd_boolean
5152 ppc64_elf_add_symbol_hook (bfd *ibfd,
5153 struct bfd_link_info *info,
5154 Elf_Internal_Sym *isym,
5155 const char **name,
5156 flagword *flags ATTRIBUTE_UNUSED,
5157 asection **sec,
5158 bfd_vma *value)
5159 {
5160 if (*sec != NULL
5161 && strcmp ((*sec)->name, ".opd") == 0)
5162 {
5163 asection *code_sec;
5164
5165 if (!(ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC
5166 || ELF_ST_TYPE (isym->st_info) == STT_FUNC))
5167 isym->st_info = ELF_ST_INFO (ELF_ST_BIND (isym->st_info), STT_FUNC);
5168
5169 /* If the symbol is a function defined in .opd, and the function
5170 code is in a discarded group, let it appear to be undefined. */
5171 if (!bfd_link_relocatable (info)
5172 && (*sec)->reloc_count != 0
5173 && opd_entry_value (*sec, *value, &code_sec, NULL,
5174 FALSE) != (bfd_vma) -1
5175 && discarded_section (code_sec))
5176 {
5177 *sec = bfd_und_section_ptr;
5178 isym->st_shndx = SHN_UNDEF;
5179 }
5180 }
5181 else if (*sec != NULL
5182 && strcmp ((*sec)->name, ".toc") == 0
5183 && ELF_ST_TYPE (isym->st_info) == STT_OBJECT)
5184 {
5185 struct ppc_link_hash_table *htab = ppc_hash_table (info);
5186 if (htab != NULL)
5187 htab->params->object_in_toc = 1;
5188 }
5189
5190 if ((STO_PPC64_LOCAL_MASK & isym->st_other) != 0)
5191 {
5192 if (abiversion (ibfd) == 0)
5193 set_abiversion (ibfd, 2);
5194 else if (abiversion (ibfd) == 1)
5195 {
5196 _bfd_error_handler (_("symbol '%s' has invalid st_other"
5197 " for ABI version 1"), *name);
5198 bfd_set_error (bfd_error_bad_value);
5199 return FALSE;
5200 }
5201 }
5202
5203 return TRUE;
5204 }
5205
5206 /* Merge non-visibility st_other attributes: local entry point. */
5207
5208 static void
5209 ppc64_elf_merge_symbol_attribute (struct elf_link_hash_entry *h,
5210 const Elf_Internal_Sym *isym,
5211 bfd_boolean definition,
5212 bfd_boolean dynamic)
5213 {
5214 if (definition && (!dynamic || !h->def_regular))
5215 h->other = ((isym->st_other & ~ELF_ST_VISIBILITY (-1))
5216 | ELF_ST_VISIBILITY (h->other));
5217 }
5218
5219 /* Hook called on merging a symbol. We use this to clear "fake" since
5220 we now have a real symbol. */
5221
5222 static bfd_boolean
5223 ppc64_elf_merge_symbol (struct elf_link_hash_entry *h,
5224 const Elf_Internal_Sym *isym,
5225 asection **psec ATTRIBUTE_UNUSED,
5226 bfd_boolean newdef ATTRIBUTE_UNUSED,
5227 bfd_boolean olddef ATTRIBUTE_UNUSED,
5228 bfd *oldbfd ATTRIBUTE_UNUSED,
5229 const asection *oldsec ATTRIBUTE_UNUSED)
5230 {
5231 ((struct ppc_link_hash_entry *) h)->fake = 0;
5232 if ((STO_PPC64_LOCAL_MASK & isym->st_other) != 0)
5233 ((struct ppc_link_hash_entry *) h)->non_zero_localentry = 1;
5234 return TRUE;
5235 }
5236
5237 /* This function makes an old ABI object reference to ".bar" cause the
5238 inclusion of a new ABI object archive that defines "bar".
5239 NAME is a symbol defined in an archive. Return a symbol in the hash
5240 table that might be satisfied by the archive symbols. */
5241
5242 static struct elf_link_hash_entry *
5243 ppc64_elf_archive_symbol_lookup (bfd *abfd,
5244 struct bfd_link_info *info,
5245 const char *name)
5246 {
5247 struct elf_link_hash_entry *h;
5248 char *dot_name;
5249 size_t len;
5250
5251 h = _bfd_elf_archive_symbol_lookup (abfd, info, name);
5252 if (h != NULL
5253 /* Don't return this sym if it is a fake function descriptor
5254 created by add_symbol_adjust. */
5255 && !((struct ppc_link_hash_entry *) h)->fake)
5256 return h;
5257
5258 if (name[0] == '.')
5259 return h;
5260
5261 len = strlen (name);
5262 dot_name = bfd_alloc (abfd, len + 2);
5263 if (dot_name == NULL)
5264 return (struct elf_link_hash_entry *) -1;
5265 dot_name[0] = '.';
5266 memcpy (dot_name + 1, name, len + 1);
5267 h = _bfd_elf_archive_symbol_lookup (abfd, info, dot_name);
5268 bfd_release (abfd, dot_name);
5269 return h;
5270 }
5271
5272 /* This function satisfies all old ABI object references to ".bar" if a
5273 new ABI object defines "bar". Well, at least, undefined dot symbols
5274 are made weak. This stops later archive searches from including an
5275 object if we already have a function descriptor definition. It also
5276 prevents the linker complaining about undefined symbols.
5277 We also check and correct mismatched symbol visibility here. The
5278 most restrictive visibility of the function descriptor and the
5279 function entry symbol is used. */
5280
5281 static bfd_boolean
5282 add_symbol_adjust (struct ppc_link_hash_entry *eh, struct bfd_link_info *info)
5283 {
5284 struct ppc_link_hash_table *htab;
5285 struct ppc_link_hash_entry *fdh;
5286
5287 if (eh->elf.root.type == bfd_link_hash_warning)
5288 eh = (struct ppc_link_hash_entry *) eh->elf.root.u.i.link;
5289
5290 if (eh->elf.root.type == bfd_link_hash_indirect)
5291 return TRUE;
5292
5293 if (eh->elf.root.root.string[0] != '.')
5294 abort ();
5295
5296 htab = ppc_hash_table (info);
5297 if (htab == NULL)
5298 return FALSE;
5299
5300 fdh = lookup_fdh (eh, htab);
5301 if (fdh == NULL
5302 && !bfd_link_relocatable (info)
5303 && (eh->elf.root.type == bfd_link_hash_undefined
5304 || eh->elf.root.type == bfd_link_hash_undefweak)
5305 && eh->elf.ref_regular)
5306 {
5307 /* Make an undefined function descriptor sym, in order to
5308 pull in an --as-needed shared lib. Archives are handled
5309 elsewhere. */
5310 fdh = make_fdh (info, eh);
5311 if (fdh == NULL)
5312 return FALSE;
5313 }
5314
5315 if (fdh != NULL)
5316 {
5317 unsigned entry_vis = ELF_ST_VISIBILITY (eh->elf.other) - 1;
5318 unsigned descr_vis = ELF_ST_VISIBILITY (fdh->elf.other) - 1;
5319
5320 /* Make both descriptor and entry symbol have the most
5321 constraining visibility of either symbol. */
5322 if (entry_vis < descr_vis)
5323 fdh->elf.other += entry_vis - descr_vis;
5324 else if (entry_vis > descr_vis)
5325 eh->elf.other += descr_vis - entry_vis;
5326
5327 /* Propagate reference flags from entry symbol to function
5328 descriptor symbol. */
5329 fdh->elf.root.non_ir_ref_regular |= eh->elf.root.non_ir_ref_regular;
5330 fdh->elf.root.non_ir_ref_dynamic |= eh->elf.root.non_ir_ref_dynamic;
5331 fdh->elf.ref_regular |= eh->elf.ref_regular;
5332 fdh->elf.ref_regular_nonweak |= eh->elf.ref_regular_nonweak;
5333
5334 if (!fdh->elf.forced_local
5335 && fdh->elf.dynindx == -1
5336 && fdh->elf.versioned != versioned_hidden
5337 && (bfd_link_dll (info)
5338 || fdh->elf.def_dynamic
5339 || fdh->elf.ref_dynamic)
5340 && (eh->elf.ref_regular
5341 || eh->elf.def_regular))
5342 {
5343 if (! bfd_elf_link_record_dynamic_symbol (info, &fdh->elf))
5344 return FALSE;
5345 }
5346 }
5347
5348 return TRUE;
5349 }
5350
5351 /* Set up opd section info and abiversion for IBFD, and process list
5352 of dot-symbols we made in link_hash_newfunc. */
5353
5354 static bfd_boolean
5355 ppc64_elf_before_check_relocs (bfd *ibfd, struct bfd_link_info *info)
5356 {
5357 struct ppc_link_hash_table *htab;
5358 struct ppc_link_hash_entry **p, *eh;
5359 asection *opd = bfd_get_section_by_name (ibfd, ".opd");
5360
5361 if (opd != NULL && opd->size != 0)
5362 {
5363 BFD_ASSERT (ppc64_elf_section_data (opd)->sec_type == sec_normal);
5364 ppc64_elf_section_data (opd)->sec_type = sec_opd;
5365
5366 if (abiversion (ibfd) == 0)
5367 set_abiversion (ibfd, 1);
5368 else if (abiversion (ibfd) >= 2)
5369 {
5370 /* xgettext:c-format */
5371 _bfd_error_handler (_("%pB .opd not allowed in ABI version %d"),
5372 ibfd, abiversion (ibfd));
5373 bfd_set_error (bfd_error_bad_value);
5374 return FALSE;
5375 }
5376 }
5377
5378 if (is_ppc64_elf (info->output_bfd))
5379 {
5380 /* For input files without an explicit abiversion in e_flags
5381 we should have flagged any with symbol st_other bits set
5382 as ELFv1 and above flagged those with .opd as ELFv2.
5383 Set the output abiversion if not yet set, and for any input
5384 still ambiguous, take its abiversion from the output.
5385 Differences in ABI are reported later. */
5386 if (abiversion (info->output_bfd) == 0)
5387 set_abiversion (info->output_bfd, abiversion (ibfd));
5388 else if (abiversion (ibfd) == 0)
5389 set_abiversion (ibfd, abiversion (info->output_bfd));
5390 }
5391
5392 htab = ppc_hash_table (info);
5393 if (htab == NULL)
5394 return TRUE;
5395
5396 if (opd != NULL && opd->size != 0
5397 && (ibfd->flags & DYNAMIC) == 0
5398 && (opd->flags & SEC_RELOC) != 0
5399 && opd->reloc_count != 0
5400 && !bfd_is_abs_section (opd->output_section)
5401 && info->gc_sections)
5402 {
5403 /* Garbage collection needs some extra help with .opd sections.
5404 We don't want to necessarily keep everything referenced by
5405 relocs in .opd, as that would keep all functions. Instead,
5406 if we reference an .opd symbol (a function descriptor), we
5407 want to keep the function code symbol's section. This is
5408 easy for global symbols, but for local syms we need to keep
5409 information about the associated function section. */
5410 bfd_size_type amt;
5411 asection **opd_sym_map;
5412 Elf_Internal_Shdr *symtab_hdr;
5413 Elf_Internal_Rela *relocs, *rel_end, *rel;
5414
5415 amt = OPD_NDX (opd->size) * sizeof (*opd_sym_map);
5416 opd_sym_map = bfd_zalloc (ibfd, amt);
5417 if (opd_sym_map == NULL)
5418 return FALSE;
5419 ppc64_elf_section_data (opd)->u.opd.func_sec = opd_sym_map;
5420 relocs = _bfd_elf_link_read_relocs (ibfd, opd, NULL, NULL,
5421 info->keep_memory);
5422 if (relocs == NULL)
5423 return FALSE;
5424 symtab_hdr = &elf_symtab_hdr (ibfd);
5425 rel_end = relocs + opd->reloc_count - 1;
5426 for (rel = relocs; rel < rel_end; rel++)
5427 {
5428 enum elf_ppc64_reloc_type r_type = ELF64_R_TYPE (rel->r_info);
5429 unsigned long r_symndx = ELF64_R_SYM (rel->r_info);
5430
5431 if (r_type == R_PPC64_ADDR64
5432 && ELF64_R_TYPE ((rel + 1)->r_info) == R_PPC64_TOC
5433 && r_symndx < symtab_hdr->sh_info)
5434 {
5435 Elf_Internal_Sym *isym;
5436 asection *s;
5437
5438 isym = bfd_sym_from_r_symndx (&htab->sym_cache, ibfd, r_symndx);
5439 if (isym == NULL)
5440 {
5441 if (elf_section_data (opd)->relocs != relocs)
5442 free (relocs);
5443 return FALSE;
5444 }
5445
5446 s = bfd_section_from_elf_index (ibfd, isym->st_shndx);
5447 if (s != NULL && s != opd)
5448 opd_sym_map[OPD_NDX (rel->r_offset)] = s;
5449 }
5450 }
5451 if (elf_section_data (opd)->relocs != relocs)
5452 free (relocs);
5453 }
5454
5455 p = &htab->dot_syms;
5456 while ((eh = *p) != NULL)
5457 {
5458 *p = NULL;
5459 if (&eh->elf == htab->elf.hgot)
5460 ;
5461 else if (htab->elf.hgot == NULL
5462 && strcmp (eh->elf.root.root.string, ".TOC.") == 0)
5463 htab->elf.hgot = &eh->elf;
5464 else if (abiversion (ibfd) <= 1)
5465 {
5466 htab->need_func_desc_adj = 1;
5467 if (!add_symbol_adjust (eh, info))
5468 return FALSE;
5469 }
5470 p = &eh->u.next_dot_sym;
5471 }
5472 return TRUE;
5473 }
5474
5475 /* Undo hash table changes when an --as-needed input file is determined
5476 not to be needed. */
5477
5478 static bfd_boolean
5479 ppc64_elf_notice_as_needed (bfd *ibfd,
5480 struct bfd_link_info *info,
5481 enum notice_asneeded_action act)
5482 {
5483 if (act == notice_not_needed)
5484 {
5485 struct ppc_link_hash_table *htab = ppc_hash_table (info);
5486
5487 if (htab == NULL)
5488 return FALSE;
5489
5490 htab->dot_syms = NULL;
5491 }
5492 return _bfd_elf_notice_as_needed (ibfd, info, act);
5493 }
5494
5495 /* If --just-symbols against a final linked binary, then assume we need
5496 toc adjusting stubs when calling functions defined there. */
5497
5498 static void
5499 ppc64_elf_link_just_syms (asection *sec, struct bfd_link_info *info)
5500 {
5501 if ((sec->flags & SEC_CODE) != 0
5502 && (sec->owner->flags & (EXEC_P | DYNAMIC)) != 0
5503 && is_ppc64_elf (sec->owner))
5504 {
5505 if (abiversion (sec->owner) >= 2
5506 || bfd_get_section_by_name (sec->owner, ".opd") != NULL)
5507 sec->has_toc_reloc = 1;
5508 }
5509 _bfd_elf_link_just_syms (sec, info);
5510 }
5511
5512 static struct plt_entry **
5513 update_local_sym_info (bfd *abfd, Elf_Internal_Shdr *symtab_hdr,
5514 unsigned long r_symndx, bfd_vma r_addend, int tls_type)
5515 {
5516 struct got_entry **local_got_ents = elf_local_got_ents (abfd);
5517 struct plt_entry **local_plt;
5518 unsigned char *local_got_tls_masks;
5519
5520 if (local_got_ents == NULL)
5521 {
5522 bfd_size_type size = symtab_hdr->sh_info;
5523
5524 size *= (sizeof (*local_got_ents)
5525 + sizeof (*local_plt)
5526 + sizeof (*local_got_tls_masks));
5527 local_got_ents = bfd_zalloc (abfd, size);
5528 if (local_got_ents == NULL)
5529 return NULL;
5530 elf_local_got_ents (abfd) = local_got_ents;
5531 }
5532
5533 if ((tls_type & (NON_GOT | TLS_EXPLICIT)) == 0)
5534 {
5535 struct got_entry *ent;
5536
5537 for (ent = local_got_ents[r_symndx]; ent != NULL; ent = ent->next)
5538 if (ent->addend == r_addend
5539 && ent->owner == abfd
5540 && ent->tls_type == tls_type)
5541 break;
5542 if (ent == NULL)
5543 {
5544 bfd_size_type amt = sizeof (*ent);
5545 ent = bfd_alloc (abfd, amt);
5546 if (ent == NULL)
5547 return FALSE;
5548 ent->next = local_got_ents[r_symndx];
5549 ent->addend = r_addend;
5550 ent->owner = abfd;
5551 ent->tls_type = tls_type;
5552 ent->is_indirect = FALSE;
5553 ent->got.refcount = 0;
5554 local_got_ents[r_symndx] = ent;
5555 }
5556 ent->got.refcount += 1;
5557 }
5558
5559 local_plt = (struct plt_entry **) (local_got_ents + symtab_hdr->sh_info);
5560 local_got_tls_masks = (unsigned char *) (local_plt + symtab_hdr->sh_info);
5561 local_got_tls_masks[r_symndx] |= tls_type & 0xff;
5562
5563 return local_plt + r_symndx;
5564 }
5565
5566 static bfd_boolean
5567 update_plt_info (bfd *abfd, struct plt_entry **plist, bfd_vma addend)
5568 {
5569 struct plt_entry *ent;
5570
5571 for (ent = *plist; ent != NULL; ent = ent->next)
5572 if (ent->addend == addend)
5573 break;
5574 if (ent == NULL)
5575 {
5576 bfd_size_type amt = sizeof (*ent);
5577 ent = bfd_alloc (abfd, amt);
5578 if (ent == NULL)
5579 return FALSE;
5580 ent->next = *plist;
5581 ent->addend = addend;
5582 ent->plt.refcount = 0;
5583 *plist = ent;
5584 }
5585 ent->plt.refcount += 1;
5586 return TRUE;
5587 }
5588
5589 static bfd_boolean
5590 is_branch_reloc (enum elf_ppc64_reloc_type r_type)
5591 {
5592 return (r_type == R_PPC64_REL24
5593 || r_type == R_PPC64_REL24_NOTOC
5594 || r_type == R_PPC64_REL14
5595 || r_type == R_PPC64_REL14_BRTAKEN
5596 || r_type == R_PPC64_REL14_BRNTAKEN
5597 || r_type == R_PPC64_ADDR24
5598 || r_type == R_PPC64_ADDR14
5599 || r_type == R_PPC64_ADDR14_BRTAKEN
5600 || r_type == R_PPC64_ADDR14_BRNTAKEN
5601 || r_type == R_PPC64_PLTCALL);
5602 }
5603
5604 /* Relocs on inline plt call sequence insns prior to the call. */
5605
5606 static bfd_boolean
5607 is_plt_seq_reloc (enum elf_ppc64_reloc_type r_type)
5608 {
5609 return (r_type == R_PPC64_PLT16_HA
5610 || r_type == R_PPC64_PLT16_HI
5611 || r_type == R_PPC64_PLT16_LO
5612 || r_type == R_PPC64_PLT16_LO_DS
5613 || r_type == R_PPC64_PLTSEQ);
5614 }
5615
5616 /* Look through the relocs for a section during the first phase, and
5617 calculate needed space in the global offset table, procedure
5618 linkage table, and dynamic reloc sections. */
5619
5620 static bfd_boolean
5621 ppc64_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
5622 asection *sec, const Elf_Internal_Rela *relocs)
5623 {
5624 struct ppc_link_hash_table *htab;
5625 Elf_Internal_Shdr *symtab_hdr;
5626 struct elf_link_hash_entry **sym_hashes;
5627 const Elf_Internal_Rela *rel;
5628 const Elf_Internal_Rela *rel_end;
5629 asection *sreloc;
5630 struct elf_link_hash_entry *tga, *dottga;
5631 bfd_boolean is_opd;
5632
5633 if (bfd_link_relocatable (info))
5634 return TRUE;
5635
5636 /* Don't do anything special with non-loaded, non-alloced sections.
5637 In particular, any relocs in such sections should not affect GOT
5638 and PLT reference counting (ie. we don't allow them to create GOT
5639 or PLT entries), there's no possibility or desire to optimize TLS
5640 relocs, and there's not much point in propagating relocs to shared
5641 libs that the dynamic linker won't relocate. */
5642 if ((sec->flags & SEC_ALLOC) == 0)
5643 return TRUE;
5644
5645 BFD_ASSERT (is_ppc64_elf (abfd));
5646
5647 htab = ppc_hash_table (info);
5648 if (htab == NULL)
5649 return FALSE;
5650
5651 tga = elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
5652 FALSE, FALSE, TRUE);
5653 dottga = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
5654 FALSE, FALSE, TRUE);
5655 symtab_hdr = &elf_symtab_hdr (abfd);
5656 sym_hashes = elf_sym_hashes (abfd);
5657 sreloc = NULL;
5658 is_opd = ppc64_elf_section_data (sec)->sec_type == sec_opd;
5659 rel_end = relocs + sec->reloc_count;
5660 for (rel = relocs; rel < rel_end; rel++)
5661 {
5662 unsigned long r_symndx;
5663 struct elf_link_hash_entry *h;
5664 enum elf_ppc64_reloc_type r_type;
5665 int tls_type;
5666 struct _ppc64_elf_section_data *ppc64_sec;
5667 struct plt_entry **ifunc, **plt_list;
5668
5669 r_symndx = ELF64_R_SYM (rel->r_info);
5670 if (r_symndx < symtab_hdr->sh_info)
5671 h = NULL;
5672 else
5673 {
5674 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
5675 h = elf_follow_link (h);
5676
5677 if (h == htab->elf.hgot)
5678 sec->has_toc_reloc = 1;
5679 }
5680
5681 tls_type = 0;
5682 ifunc = NULL;
5683 if (h != NULL)
5684 {
5685 if (h->type == STT_GNU_IFUNC)
5686 {
5687 h->needs_plt = 1;
5688 ifunc = &h->plt.plist;
5689 }
5690 }
5691 else
5692 {
5693 Elf_Internal_Sym *isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5694 abfd, r_symndx);
5695 if (isym == NULL)
5696 return FALSE;
5697
5698 if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
5699 {
5700 ifunc = update_local_sym_info (abfd, symtab_hdr, r_symndx,
5701 rel->r_addend,
5702 NON_GOT | PLT_IFUNC);
5703 if (ifunc == NULL)
5704 return FALSE;
5705 }
5706 }
5707
5708 r_type = ELF64_R_TYPE (rel->r_info);
5709 switch (r_type)
5710 {
5711 case R_PPC64_TLSGD:
5712 case R_PPC64_TLSLD:
5713 /* These special tls relocs tie a call to __tls_get_addr with
5714 its parameter symbol. */
5715 if (h != NULL)
5716 ((struct ppc_link_hash_entry *) h)->tls_mask |= TLS_TLS | TLS_MARK;
5717 else
5718 if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5719 rel->r_addend,
5720 NON_GOT | TLS_TLS | TLS_MARK))
5721 return FALSE;
5722 sec->has_tls_reloc = 1;
5723 break;
5724
5725 case R_PPC64_GOT_TLSLD16:
5726 case R_PPC64_GOT_TLSLD16_LO:
5727 case R_PPC64_GOT_TLSLD16_HI:
5728 case R_PPC64_GOT_TLSLD16_HA:
5729 tls_type = TLS_TLS | TLS_LD;
5730 goto dogottls;
5731
5732 case R_PPC64_GOT_TLSGD16:
5733 case R_PPC64_GOT_TLSGD16_LO:
5734 case R_PPC64_GOT_TLSGD16_HI:
5735 case R_PPC64_GOT_TLSGD16_HA:
5736 tls_type = TLS_TLS | TLS_GD;
5737 goto dogottls;
5738
5739 case R_PPC64_GOT_TPREL16_DS:
5740 case R_PPC64_GOT_TPREL16_LO_DS:
5741 case R_PPC64_GOT_TPREL16_HI:
5742 case R_PPC64_GOT_TPREL16_HA:
5743 if (bfd_link_dll (info))
5744 info->flags |= DF_STATIC_TLS;
5745 tls_type = TLS_TLS | TLS_TPREL;
5746 goto dogottls;
5747
5748 case R_PPC64_GOT_DTPREL16_DS:
5749 case R_PPC64_GOT_DTPREL16_LO_DS:
5750 case R_PPC64_GOT_DTPREL16_HI:
5751 case R_PPC64_GOT_DTPREL16_HA:
5752 tls_type = TLS_TLS | TLS_DTPREL;
5753 dogottls:
5754 sec->has_tls_reloc = 1;
5755 /* Fall through */
5756
5757 case R_PPC64_GOT16:
5758 case R_PPC64_GOT16_DS:
5759 case R_PPC64_GOT16_HA:
5760 case R_PPC64_GOT16_HI:
5761 case R_PPC64_GOT16_LO:
5762 case R_PPC64_GOT16_LO_DS:
5763 /* This symbol requires a global offset table entry. */
5764 sec->has_toc_reloc = 1;
5765 if (r_type == R_PPC64_GOT_TLSLD16
5766 || r_type == R_PPC64_GOT_TLSGD16
5767 || r_type == R_PPC64_GOT_TPREL16_DS
5768 || r_type == R_PPC64_GOT_DTPREL16_DS
5769 || r_type == R_PPC64_GOT16
5770 || r_type == R_PPC64_GOT16_DS)
5771 {
5772 htab->do_multi_toc = 1;
5773 ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5774 }
5775
5776 if (ppc64_elf_tdata (abfd)->got == NULL
5777 && !create_got_section (abfd, info))
5778 return FALSE;
5779
5780 if (h != NULL)
5781 {
5782 struct ppc_link_hash_entry *eh;
5783 struct got_entry *ent;
5784
5785 eh = (struct ppc_link_hash_entry *) h;
5786 for (ent = eh->elf.got.glist; ent != NULL; ent = ent->next)
5787 if (ent->addend == rel->r_addend
5788 && ent->owner == abfd
5789 && ent->tls_type == tls_type)
5790 break;
5791 if (ent == NULL)
5792 {
5793 bfd_size_type amt = sizeof (*ent);
5794 ent = bfd_alloc (abfd, amt);
5795 if (ent == NULL)
5796 return FALSE;
5797 ent->next = eh->elf.got.glist;
5798 ent->addend = rel->r_addend;
5799 ent->owner = abfd;
5800 ent->tls_type = tls_type;
5801 ent->is_indirect = FALSE;
5802 ent->got.refcount = 0;
5803 eh->elf.got.glist = ent;
5804 }
5805 ent->got.refcount += 1;
5806 eh->tls_mask |= tls_type;
5807 }
5808 else
5809 /* This is a global offset table entry for a local symbol. */
5810 if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5811 rel->r_addend, tls_type))
5812 return FALSE;
5813
5814 /* We may also need a plt entry if the symbol turns out to be
5815 an ifunc. */
5816 if (h != NULL && !bfd_link_pic (info) && abiversion (abfd) != 1)
5817 {
5818 if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5819 return FALSE;
5820 }
5821 break;
5822
5823 case R_PPC64_PLT16_HA:
5824 case R_PPC64_PLT16_HI:
5825 case R_PPC64_PLT16_LO:
5826 case R_PPC64_PLT16_LO_DS:
5827 case R_PPC64_PLT32:
5828 case R_PPC64_PLT64:
5829 /* This symbol requires a procedure linkage table entry. */
5830 plt_list = ifunc;
5831 if (h != NULL)
5832 {
5833 h->needs_plt = 1;
5834 if (h->root.root.string[0] == '.'
5835 && h->root.root.string[1] != '\0')
5836 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5837 ((struct ppc_link_hash_entry *) h)->tls_mask |= PLT_KEEP;
5838 plt_list = &h->plt.plist;
5839 }
5840 if (plt_list == NULL)
5841 plt_list = update_local_sym_info (abfd, symtab_hdr, r_symndx,
5842 rel->r_addend,
5843 NON_GOT | PLT_KEEP);
5844 if (!update_plt_info (abfd, plt_list, rel->r_addend))
5845 return FALSE;
5846 break;
5847
5848 /* The following relocations don't need to propagate the
5849 relocation if linking a shared object since they are
5850 section relative. */
5851 case R_PPC64_SECTOFF:
5852 case R_PPC64_SECTOFF_LO:
5853 case R_PPC64_SECTOFF_HI:
5854 case R_PPC64_SECTOFF_HA:
5855 case R_PPC64_SECTOFF_DS:
5856 case R_PPC64_SECTOFF_LO_DS:
5857 case R_PPC64_DTPREL16:
5858 case R_PPC64_DTPREL16_LO:
5859 case R_PPC64_DTPREL16_HI:
5860 case R_PPC64_DTPREL16_HA:
5861 case R_PPC64_DTPREL16_DS:
5862 case R_PPC64_DTPREL16_LO_DS:
5863 case R_PPC64_DTPREL16_HIGH:
5864 case R_PPC64_DTPREL16_HIGHA:
5865 case R_PPC64_DTPREL16_HIGHER:
5866 case R_PPC64_DTPREL16_HIGHERA:
5867 case R_PPC64_DTPREL16_HIGHEST:
5868 case R_PPC64_DTPREL16_HIGHESTA:
5869 break;
5870
5871 /* Nor do these. */
5872 case R_PPC64_REL16:
5873 case R_PPC64_REL16_LO:
5874 case R_PPC64_REL16_HI:
5875 case R_PPC64_REL16_HA:
5876 case R_PPC64_REL16DX_HA:
5877 break;
5878
5879 /* Not supported as a dynamic relocation. */
5880 case R_PPC64_ADDR64_LOCAL:
5881 if (bfd_link_pic (info))
5882 {
5883 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
5884 ppc_howto_init ();
5885 /* xgettext:c-format */
5886 info->callbacks->einfo (_("%H: %s reloc unsupported "
5887 "in shared libraries and PIEs\n"),
5888 abfd, sec, rel->r_offset,
5889 ppc64_elf_howto_table[r_type]->name);
5890 bfd_set_error (bfd_error_bad_value);
5891 return FALSE;
5892 }
5893 break;
5894
5895 case R_PPC64_TOC16:
5896 case R_PPC64_TOC16_DS:
5897 htab->do_multi_toc = 1;
5898 ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5899 /* Fall through. */
5900 case R_PPC64_TOC16_LO:
5901 case R_PPC64_TOC16_HI:
5902 case R_PPC64_TOC16_HA:
5903 case R_PPC64_TOC16_LO_DS:
5904 sec->has_toc_reloc = 1;
5905 break;
5906
5907 /* Marker reloc. */
5908 case R_PPC64_ENTRY:
5909 break;
5910
5911 /* This relocation describes the C++ object vtable hierarchy.
5912 Reconstruct it for later use during GC. */
5913 case R_PPC64_GNU_VTINHERIT:
5914 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
5915 return FALSE;
5916 break;
5917
5918 /* This relocation describes which C++ vtable entries are actually
5919 used. Record for later use during GC. */
5920 case R_PPC64_GNU_VTENTRY:
5921 BFD_ASSERT (h != NULL);
5922 if (h != NULL
5923 && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
5924 return FALSE;
5925 break;
5926
5927 case R_PPC64_REL14:
5928 case R_PPC64_REL14_BRTAKEN:
5929 case R_PPC64_REL14_BRNTAKEN:
5930 {
5931 asection *dest = NULL;
5932
5933 /* Heuristic: If jumping outside our section, chances are
5934 we are going to need a stub. */
5935 if (h != NULL)
5936 {
5937 /* If the sym is weak it may be overridden later, so
5938 don't assume we know where a weak sym lives. */
5939 if (h->root.type == bfd_link_hash_defined)
5940 dest = h->root.u.def.section;
5941 }
5942 else
5943 {
5944 Elf_Internal_Sym *isym;
5945
5946 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5947 abfd, r_symndx);
5948 if (isym == NULL)
5949 return FALSE;
5950
5951 dest = bfd_section_from_elf_index (abfd, isym->st_shndx);
5952 }
5953
5954 if (dest != sec)
5955 ppc64_elf_section_data (sec)->has_14bit_branch = 1;
5956 }
5957 goto rel24;
5958
5959 case R_PPC64_PLTCALL:
5960 ppc64_elf_section_data (sec)->has_pltcall = 1;
5961 /* Fall through. */
5962
5963 case R_PPC64_REL24:
5964 case R_PPC64_REL24_NOTOC:
5965 rel24:
5966 plt_list = ifunc;
5967 if (h != NULL)
5968 {
5969 h->needs_plt = 1;
5970 if (h->root.root.string[0] == '.'
5971 && h->root.root.string[1] != '\0')
5972 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5973
5974 if (h == tga || h == dottga)
5975 {
5976 sec->has_tls_reloc = 1;
5977 if (rel != relocs
5978 && (ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSGD
5979 || ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSLD))
5980 /* We have a new-style __tls_get_addr call with
5981 a marker reloc. */
5982 ;
5983 else
5984 /* Mark this section as having an old-style call. */
5985 sec->has_tls_get_addr_call = 1;
5986 }
5987 plt_list = &h->plt.plist;
5988 }
5989
5990 /* We may need a .plt entry if the function this reloc
5991 refers to is in a shared lib. */
5992 if (plt_list
5993 && !update_plt_info (abfd, plt_list, rel->r_addend))
5994 return FALSE;
5995 break;
5996
5997 case R_PPC64_ADDR14:
5998 case R_PPC64_ADDR14_BRNTAKEN:
5999 case R_PPC64_ADDR14_BRTAKEN:
6000 case R_PPC64_ADDR24:
6001 goto dodyn;
6002
6003 case R_PPC64_TPREL64:
6004 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_TPREL;
6005 if (bfd_link_dll (info))
6006 info->flags |= DF_STATIC_TLS;
6007 goto dotlstoc;
6008
6009 case R_PPC64_DTPMOD64:
6010 if (rel + 1 < rel_end
6011 && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
6012 && rel[1].r_offset == rel->r_offset + 8)
6013 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_GD;
6014 else
6015 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_LD;
6016 goto dotlstoc;
6017
6018 case R_PPC64_DTPREL64:
6019 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_DTPREL;
6020 if (rel != relocs
6021 && rel[-1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPMOD64)
6022 && rel[-1].r_offset == rel->r_offset - 8)
6023 /* This is the second reloc of a dtpmod, dtprel pair.
6024 Don't mark with TLS_DTPREL. */
6025 goto dodyn;
6026
6027 dotlstoc:
6028 sec->has_tls_reloc = 1;
6029 if (h != NULL)
6030 {
6031 struct ppc_link_hash_entry *eh;
6032 eh = (struct ppc_link_hash_entry *) h;
6033 eh->tls_mask |= tls_type;
6034 }
6035 else
6036 if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
6037 rel->r_addend, tls_type))
6038 return FALSE;
6039
6040 ppc64_sec = ppc64_elf_section_data (sec);
6041 if (ppc64_sec->sec_type != sec_toc)
6042 {
6043 bfd_size_type amt;
6044
6045 /* One extra to simplify get_tls_mask. */
6046 amt = sec->size * sizeof (unsigned) / 8 + sizeof (unsigned);
6047 ppc64_sec->u.toc.symndx = bfd_zalloc (abfd, amt);
6048 if (ppc64_sec->u.toc.symndx == NULL)
6049 return FALSE;
6050 amt = sec->size * sizeof (bfd_vma) / 8;
6051 ppc64_sec->u.toc.add = bfd_zalloc (abfd, amt);
6052 if (ppc64_sec->u.toc.add == NULL)
6053 return FALSE;
6054 BFD_ASSERT (ppc64_sec->sec_type == sec_normal);
6055 ppc64_sec->sec_type = sec_toc;
6056 }
6057 BFD_ASSERT (rel->r_offset % 8 == 0);
6058 ppc64_sec->u.toc.symndx[rel->r_offset / 8] = r_symndx;
6059 ppc64_sec->u.toc.add[rel->r_offset / 8] = rel->r_addend;
6060
6061 /* Mark the second slot of a GD or LD entry.
6062 -1 to indicate GD and -2 to indicate LD. */
6063 if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_GD))
6064 ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -1;
6065 else if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_LD))
6066 ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -2;
6067 goto dodyn;
6068
6069 case R_PPC64_TPREL16:
6070 case R_PPC64_TPREL16_LO:
6071 case R_PPC64_TPREL16_HI:
6072 case R_PPC64_TPREL16_HA:
6073 case R_PPC64_TPREL16_DS:
6074 case R_PPC64_TPREL16_LO_DS:
6075 case R_PPC64_TPREL16_HIGH:
6076 case R_PPC64_TPREL16_HIGHA:
6077 case R_PPC64_TPREL16_HIGHER:
6078 case R_PPC64_TPREL16_HIGHERA:
6079 case R_PPC64_TPREL16_HIGHEST:
6080 case R_PPC64_TPREL16_HIGHESTA:
6081 if (bfd_link_dll (info))
6082 info->flags |= DF_STATIC_TLS;
6083 goto dodyn;
6084
6085 case R_PPC64_ADDR64:
6086 if (is_opd
6087 && rel + 1 < rel_end
6088 && ELF64_R_TYPE ((rel + 1)->r_info) == R_PPC64_TOC)
6089 {
6090 if (h != NULL)
6091 ((struct ppc_link_hash_entry *) h)->is_func = 1;
6092 }
6093 /* Fall through. */
6094
6095 case R_PPC64_ADDR16:
6096 case R_PPC64_ADDR16_DS:
6097 case R_PPC64_ADDR16_HA:
6098 case R_PPC64_ADDR16_HI:
6099 case R_PPC64_ADDR16_HIGH:
6100 case R_PPC64_ADDR16_HIGHA:
6101 case R_PPC64_ADDR16_HIGHER:
6102 case R_PPC64_ADDR16_HIGHERA:
6103 case R_PPC64_ADDR16_HIGHEST:
6104 case R_PPC64_ADDR16_HIGHESTA:
6105 case R_PPC64_ADDR16_LO:
6106 case R_PPC64_ADDR16_LO_DS:
6107 if (h != NULL && !bfd_link_pic (info) && abiversion (abfd) != 1
6108 && rel->r_addend == 0)
6109 {
6110 /* We may need a .plt entry if this reloc refers to a
6111 function in a shared lib. */
6112 if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
6113 return FALSE;
6114 h->pointer_equality_needed = 1;
6115 }
6116 /* Fall through. */
6117
6118 case R_PPC64_REL30:
6119 case R_PPC64_REL32:
6120 case R_PPC64_REL64:
6121 case R_PPC64_ADDR32:
6122 case R_PPC64_UADDR16:
6123 case R_PPC64_UADDR32:
6124 case R_PPC64_UADDR64:
6125 case R_PPC64_TOC:
6126 if (h != NULL && !bfd_link_pic (info))
6127 /* We may need a copy reloc. */
6128 h->non_got_ref = 1;
6129
6130 /* Don't propagate .opd relocs. */
6131 if (NO_OPD_RELOCS && is_opd)
6132 break;
6133
6134 /* If we are creating a shared library, and this is a reloc
6135 against a global symbol, or a non PC relative reloc
6136 against a local symbol, then we need to copy the reloc
6137 into the shared library. However, if we are linking with
6138 -Bsymbolic, we do not need to copy a reloc against a
6139 global symbol which is defined in an object we are
6140 including in the link (i.e., DEF_REGULAR is set). At
6141 this point we have not seen all the input files, so it is
6142 possible that DEF_REGULAR is not set now but will be set
6143 later (it is never cleared). In case of a weak definition,
6144 DEF_REGULAR may be cleared later by a strong definition in
6145 a shared library. We account for that possibility below by
6146 storing information in the dyn_relocs field of the hash
6147 table entry. A similar situation occurs when creating
6148 shared libraries and symbol visibility changes render the
6149 symbol local.
6150
6151 If on the other hand, we are creating an executable, we
6152 may need to keep relocations for symbols satisfied by a
6153 dynamic library if we manage to avoid copy relocs for the
6154 symbol. */
6155 dodyn:
6156 if ((bfd_link_pic (info)
6157 && (must_be_dyn_reloc (info, r_type)
6158 || (h != NULL
6159 && (!SYMBOLIC_BIND (info, h)
6160 || h->root.type == bfd_link_hash_defweak
6161 || !h->def_regular))))
6162 || (ELIMINATE_COPY_RELOCS
6163 && !bfd_link_pic (info)
6164 && h != NULL
6165 && (h->root.type == bfd_link_hash_defweak
6166 || !h->def_regular))
6167 || (!bfd_link_pic (info)
6168 && ifunc != NULL))
6169 {
6170 /* We must copy these reloc types into the output file.
6171 Create a reloc section in dynobj and make room for
6172 this reloc. */
6173 if (sreloc == NULL)
6174 {
6175 sreloc = _bfd_elf_make_dynamic_reloc_section
6176 (sec, htab->elf.dynobj, 3, abfd, /*rela?*/ TRUE);
6177
6178 if (sreloc == NULL)
6179 return FALSE;
6180 }
6181
6182 /* If this is a global symbol, we count the number of
6183 relocations we need for this symbol. */
6184 if (h != NULL)
6185 {
6186 struct elf_dyn_relocs *p;
6187 struct elf_dyn_relocs **head;
6188
6189 head = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
6190 p = *head;
6191 if (p == NULL || p->sec != sec)
6192 {
6193 p = bfd_alloc (htab->elf.dynobj, sizeof *p);
6194 if (p == NULL)
6195 return FALSE;
6196 p->next = *head;
6197 *head = p;
6198 p->sec = sec;
6199 p->count = 0;
6200 p->pc_count = 0;
6201 }
6202 p->count += 1;
6203 if (!must_be_dyn_reloc (info, r_type))
6204 p->pc_count += 1;
6205 }
6206 else
6207 {
6208 /* Track dynamic relocs needed for local syms too.
6209 We really need local syms available to do this
6210 easily. Oh well. */
6211 struct ppc_dyn_relocs *p;
6212 struct ppc_dyn_relocs **head;
6213 bfd_boolean is_ifunc;
6214 asection *s;
6215 void *vpp;
6216 Elf_Internal_Sym *isym;
6217
6218 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
6219 abfd, r_symndx);
6220 if (isym == NULL)
6221 return FALSE;
6222
6223 s = bfd_section_from_elf_index (abfd, isym->st_shndx);
6224 if (s == NULL)
6225 s = sec;
6226
6227 vpp = &elf_section_data (s)->local_dynrel;
6228 head = (struct ppc_dyn_relocs **) vpp;
6229 is_ifunc = ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC;
6230 p = *head;
6231 if (p != NULL && p->sec == sec && p->ifunc != is_ifunc)
6232 p = p->next;
6233 if (p == NULL || p->sec != sec || p->ifunc != is_ifunc)
6234 {
6235 p = bfd_alloc (htab->elf.dynobj, sizeof *p);
6236 if (p == NULL)
6237 return FALSE;
6238 p->next = *head;
6239 *head = p;
6240 p->sec = sec;
6241 p->ifunc = is_ifunc;
6242 p->count = 0;
6243 }
6244 p->count += 1;
6245 }
6246 }
6247 break;
6248
6249 default:
6250 break;
6251 }
6252 }
6253
6254 return TRUE;
6255 }
6256
6257 /* Merge backend specific data from an object file to the output
6258 object file when linking. */
6259
6260 static bfd_boolean
6261 ppc64_elf_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info)
6262 {
6263 bfd *obfd = info->output_bfd;
6264 unsigned long iflags, oflags;
6265
6266 if ((ibfd->flags & BFD_LINKER_CREATED) != 0)
6267 return TRUE;
6268
6269 if (!is_ppc64_elf (ibfd) || !is_ppc64_elf (obfd))
6270 return TRUE;
6271
6272 if (!_bfd_generic_verify_endian_match (ibfd, info))
6273 return FALSE;
6274
6275 iflags = elf_elfheader (ibfd)->e_flags;
6276 oflags = elf_elfheader (obfd)->e_flags;
6277
6278 if (iflags & ~EF_PPC64_ABI)
6279 {
6280 _bfd_error_handler
6281 /* xgettext:c-format */
6282 (_("%pB uses unknown e_flags 0x%lx"), ibfd, iflags);
6283 bfd_set_error (bfd_error_bad_value);
6284 return FALSE;
6285 }
6286 else if (iflags != oflags && iflags != 0)
6287 {
6288 _bfd_error_handler
6289 /* xgettext:c-format */
6290 (_("%pB: ABI version %ld is not compatible with ABI version %ld output"),
6291 ibfd, iflags, oflags);
6292 bfd_set_error (bfd_error_bad_value);
6293 return FALSE;
6294 }
6295
6296 if (!_bfd_elf_ppc_merge_fp_attributes (ibfd, info))
6297 return FALSE;
6298
6299 /* Merge Tag_compatibility attributes and any common GNU ones. */
6300 return _bfd_elf_merge_object_attributes (ibfd, info);
6301 }
6302
6303 static bfd_boolean
6304 ppc64_elf_print_private_bfd_data (bfd *abfd, void *ptr)
6305 {
6306 /* Print normal ELF private data. */
6307 _bfd_elf_print_private_bfd_data (abfd, ptr);
6308
6309 if (elf_elfheader (abfd)->e_flags != 0)
6310 {
6311 FILE *file = ptr;
6312
6313 fprintf (file, _("private flags = 0x%lx:"),
6314 elf_elfheader (abfd)->e_flags);
6315
6316 if ((elf_elfheader (abfd)->e_flags & EF_PPC64_ABI) != 0)
6317 fprintf (file, _(" [abiv%ld]"),
6318 elf_elfheader (abfd)->e_flags & EF_PPC64_ABI);
6319 fputc ('\n', file);
6320 }
6321
6322 return TRUE;
6323 }
6324
6325 /* OFFSET in OPD_SEC specifies a function descriptor. Return the address
6326 of the code entry point, and its section, which must be in the same
6327 object as OPD_SEC. Returns (bfd_vma) -1 on error. */
6328
6329 static bfd_vma
6330 opd_entry_value (asection *opd_sec,
6331 bfd_vma offset,
6332 asection **code_sec,
6333 bfd_vma *code_off,
6334 bfd_boolean in_code_sec)
6335 {
6336 bfd *opd_bfd = opd_sec->owner;
6337 Elf_Internal_Rela *relocs;
6338 Elf_Internal_Rela *lo, *hi, *look;
6339 bfd_vma val;
6340
6341 /* No relocs implies we are linking a --just-symbols object, or looking
6342 at a final linked executable with addr2line or somesuch. */
6343 if (opd_sec->reloc_count == 0)
6344 {
6345 bfd_byte *contents = ppc64_elf_tdata (opd_bfd)->opd.contents;
6346
6347 if (contents == NULL)
6348 {
6349 if (!bfd_malloc_and_get_section (opd_bfd, opd_sec, &contents))
6350 return (bfd_vma) -1;
6351 ppc64_elf_tdata (opd_bfd)->opd.contents = contents;
6352 }
6353
6354 /* PR 17512: file: 64b9dfbb. */
6355 if (offset + 7 >= opd_sec->size || offset + 7 < offset)
6356 return (bfd_vma) -1;
6357
6358 val = bfd_get_64 (opd_bfd, contents + offset);
6359 if (code_sec != NULL)
6360 {
6361 asection *sec, *likely = NULL;
6362
6363 if (in_code_sec)
6364 {
6365 sec = *code_sec;
6366 if (sec->vma <= val
6367 && val < sec->vma + sec->size)
6368 likely = sec;
6369 else
6370 val = -1;
6371 }
6372 else
6373 for (sec = opd_bfd->sections; sec != NULL; sec = sec->next)
6374 if (sec->vma <= val
6375 && (sec->flags & SEC_LOAD) != 0
6376 && (sec->flags & SEC_ALLOC) != 0)
6377 likely = sec;
6378 if (likely != NULL)
6379 {
6380 *code_sec = likely;
6381 if (code_off != NULL)
6382 *code_off = val - likely->vma;
6383 }
6384 }
6385 return val;
6386 }
6387
6388 BFD_ASSERT (is_ppc64_elf (opd_bfd));
6389
6390 relocs = ppc64_elf_tdata (opd_bfd)->opd.relocs;
6391 if (relocs == NULL)
6392 relocs = _bfd_elf_link_read_relocs (opd_bfd, opd_sec, NULL, NULL, TRUE);
6393 /* PR 17512: file: df8e1fd6. */
6394 if (relocs == NULL)
6395 return (bfd_vma) -1;
6396
6397 /* Go find the opd reloc at the sym address. */
6398 lo = relocs;
6399 hi = lo + opd_sec->reloc_count - 1; /* ignore last reloc */
6400 val = (bfd_vma) -1;
6401 while (lo < hi)
6402 {
6403 look = lo + (hi - lo) / 2;
6404 if (look->r_offset < offset)
6405 lo = look + 1;
6406 else if (look->r_offset > offset)
6407 hi = look;
6408 else
6409 {
6410 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (opd_bfd);
6411
6412 if (ELF64_R_TYPE (look->r_info) == R_PPC64_ADDR64
6413 && ELF64_R_TYPE ((look + 1)->r_info) == R_PPC64_TOC)
6414 {
6415 unsigned long symndx = ELF64_R_SYM (look->r_info);
6416 asection *sec = NULL;
6417
6418 if (symndx >= symtab_hdr->sh_info
6419 && elf_sym_hashes (opd_bfd) != NULL)
6420 {
6421 struct elf_link_hash_entry **sym_hashes;
6422 struct elf_link_hash_entry *rh;
6423
6424 sym_hashes = elf_sym_hashes (opd_bfd);
6425 rh = sym_hashes[symndx - symtab_hdr->sh_info];
6426 if (rh != NULL)
6427 {
6428 rh = elf_follow_link (rh);
6429 if (rh->root.type != bfd_link_hash_defined
6430 && rh->root.type != bfd_link_hash_defweak)
6431 break;
6432 if (rh->root.u.def.section->owner == opd_bfd)
6433 {
6434 val = rh->root.u.def.value;
6435 sec = rh->root.u.def.section;
6436 }
6437 }
6438 }
6439
6440 if (sec == NULL)
6441 {
6442 Elf_Internal_Sym *sym;
6443
6444 if (symndx < symtab_hdr->sh_info)
6445 {
6446 sym = (Elf_Internal_Sym *) symtab_hdr->contents;
6447 if (sym == NULL)
6448 {
6449 size_t symcnt = symtab_hdr->sh_info;
6450 sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr,
6451 symcnt, 0,
6452 NULL, NULL, NULL);
6453 if (sym == NULL)
6454 break;
6455 symtab_hdr->contents = (bfd_byte *) sym;
6456 }
6457 sym += symndx;
6458 }
6459 else
6460 {
6461 sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr,
6462 1, symndx,
6463 NULL, NULL, NULL);
6464 if (sym == NULL)
6465 break;
6466 }
6467 sec = bfd_section_from_elf_index (opd_bfd, sym->st_shndx);
6468 if (sec == NULL)
6469 break;
6470 BFD_ASSERT ((sec->flags & SEC_MERGE) == 0);
6471 val = sym->st_value;
6472 }
6473
6474 val += look->r_addend;
6475 if (code_off != NULL)
6476 *code_off = val;
6477 if (code_sec != NULL)
6478 {
6479 if (in_code_sec && *code_sec != sec)
6480 return -1;
6481 else
6482 *code_sec = sec;
6483 }
6484 if (sec->output_section != NULL)
6485 val += sec->output_section->vma + sec->output_offset;
6486 }
6487 break;
6488 }
6489 }
6490
6491 return val;
6492 }
6493
6494 /* If the ELF symbol SYM might be a function in SEC, return the
6495 function size and set *CODE_OFF to the function's entry point,
6496 otherwise return zero. */
6497
6498 static bfd_size_type
6499 ppc64_elf_maybe_function_sym (const asymbol *sym, asection *sec,
6500 bfd_vma *code_off)
6501 {
6502 bfd_size_type size;
6503
6504 if ((sym->flags & (BSF_SECTION_SYM | BSF_FILE | BSF_OBJECT
6505 | BSF_THREAD_LOCAL | BSF_RELC | BSF_SRELC)) != 0)
6506 return 0;
6507
6508 size = 0;
6509 if (!(sym->flags & BSF_SYNTHETIC))
6510 size = ((elf_symbol_type *) sym)->internal_elf_sym.st_size;
6511
6512 if (strcmp (sym->section->name, ".opd") == 0)
6513 {
6514 struct _opd_sec_data *opd = get_opd_info (sym->section);
6515 bfd_vma symval = sym->value;
6516
6517 if (opd != NULL
6518 && opd->adjust != NULL
6519 && elf_section_data (sym->section)->relocs != NULL)
6520 {
6521 /* opd_entry_value will use cached relocs that have been
6522 adjusted, but with raw symbols. That means both local
6523 and global symbols need adjusting. */
6524 long adjust = opd->adjust[OPD_NDX (symval)];
6525 if (adjust == -1)
6526 return 0;
6527 symval += adjust;
6528 }
6529
6530 if (opd_entry_value (sym->section, symval,
6531 &sec, code_off, TRUE) == (bfd_vma) -1)
6532 return 0;
6533 /* An old ABI binary with dot-syms has a size of 24 on the .opd
6534 symbol. This size has nothing to do with the code size of the
6535 function, which is what we're supposed to return, but the
6536 code size isn't available without looking up the dot-sym.
6537 However, doing that would be a waste of time particularly
6538 since elf_find_function will look at the dot-sym anyway.
6539 Now, elf_find_function will keep the largest size of any
6540 function sym found at the code address of interest, so return
6541 1 here to avoid it incorrectly caching a larger function size
6542 for a small function. This does mean we return the wrong
6543 size for a new-ABI function of size 24, but all that does is
6544 disable caching for such functions. */
6545 if (size == 24)
6546 size = 1;
6547 }
6548 else
6549 {
6550 if (sym->section != sec)
6551 return 0;
6552 *code_off = sym->value;
6553 }
6554 if (size == 0)
6555 size = 1;
6556 return size;
6557 }
6558
6559 /* Return true if symbol is a strong function defined in an ELFv2
6560 object with st_other localentry bits of zero, ie. its local entry
6561 point coincides with its global entry point. */
6562
6563 static bfd_boolean
6564 is_elfv2_localentry0 (struct elf_link_hash_entry *h)
6565 {
6566 return (h != NULL
6567 && h->type == STT_FUNC
6568 && h->root.type == bfd_link_hash_defined
6569 && (STO_PPC64_LOCAL_MASK & h->other) == 0
6570 && !((struct ppc_link_hash_entry *) h)->non_zero_localentry
6571 && is_ppc64_elf (h->root.u.def.section->owner)
6572 && abiversion (h->root.u.def.section->owner) >= 2);
6573 }
6574
6575 /* Return true if symbol is defined in a regular object file. */
6576
6577 static bfd_boolean
6578 is_static_defined (struct elf_link_hash_entry *h)
6579 {
6580 return ((h->root.type == bfd_link_hash_defined
6581 || h->root.type == bfd_link_hash_defweak)
6582 && h->root.u.def.section != NULL
6583 && h->root.u.def.section->output_section != NULL);
6584 }
6585
6586 /* If FDH is a function descriptor symbol, return the associated code
6587 entry symbol if it is defined. Return NULL otherwise. */
6588
6589 static struct ppc_link_hash_entry *
6590 defined_code_entry (struct ppc_link_hash_entry *fdh)
6591 {
6592 if (fdh->is_func_descriptor)
6593 {
6594 struct ppc_link_hash_entry *fh = ppc_follow_link (fdh->oh);
6595 if (fh->elf.root.type == bfd_link_hash_defined
6596 || fh->elf.root.type == bfd_link_hash_defweak)
6597 return fh;
6598 }
6599 return NULL;
6600 }
6601
6602 /* If FH is a function code entry symbol, return the associated
6603 function descriptor symbol if it is defined. Return NULL otherwise. */
6604
6605 static struct ppc_link_hash_entry *
6606 defined_func_desc (struct ppc_link_hash_entry *fh)
6607 {
6608 if (fh->oh != NULL
6609 && fh->oh->is_func_descriptor)
6610 {
6611 struct ppc_link_hash_entry *fdh = ppc_follow_link (fh->oh);
6612 if (fdh->elf.root.type == bfd_link_hash_defined
6613 || fdh->elf.root.type == bfd_link_hash_defweak)
6614 return fdh;
6615 }
6616 return NULL;
6617 }
6618
6619 static bfd_boolean func_desc_adjust (struct elf_link_hash_entry *, void *);
6620
6621 /* Garbage collect sections, after first dealing with dot-symbols. */
6622
6623 static bfd_boolean
6624 ppc64_elf_gc_sections (bfd *abfd, struct bfd_link_info *info)
6625 {
6626 struct ppc_link_hash_table *htab = ppc_hash_table (info);
6627
6628 if (htab != NULL && htab->need_func_desc_adj)
6629 {
6630 elf_link_hash_traverse (&htab->elf, func_desc_adjust, info);
6631 htab->need_func_desc_adj = 0;
6632 }
6633 return bfd_elf_gc_sections (abfd, info);
6634 }
6635
6636 /* Mark all our entry sym sections, both opd and code section. */
6637
6638 static void
6639 ppc64_elf_gc_keep (struct bfd_link_info *info)
6640 {
6641 struct ppc_link_hash_table *htab = ppc_hash_table (info);
6642 struct bfd_sym_chain *sym;
6643
6644 if (htab == NULL)
6645 return;
6646
6647 for (sym = info->gc_sym_list; sym != NULL; sym = sym->next)
6648 {
6649 struct ppc_link_hash_entry *eh, *fh;
6650 asection *sec;
6651
6652 eh = (struct ppc_link_hash_entry *)
6653 elf_link_hash_lookup (&htab->elf, sym->name, FALSE, FALSE, TRUE);
6654 if (eh == NULL)
6655 continue;
6656 if (eh->elf.root.type != bfd_link_hash_defined
6657 && eh->elf.root.type != bfd_link_hash_defweak)
6658 continue;
6659
6660 fh = defined_code_entry (eh);
6661 if (fh != NULL)
6662 {
6663 sec = fh->elf.root.u.def.section;
6664 sec->flags |= SEC_KEEP;
6665 }
6666 else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6667 && opd_entry_value (eh->elf.root.u.def.section,
6668 eh->elf.root.u.def.value,
6669 &sec, NULL, FALSE) != (bfd_vma) -1)
6670 sec->flags |= SEC_KEEP;
6671
6672 sec = eh->elf.root.u.def.section;
6673 sec->flags |= SEC_KEEP;
6674 }
6675 }
6676
6677 /* Mark sections containing dynamically referenced symbols. When
6678 building shared libraries, we must assume that any visible symbol is
6679 referenced. */
6680
6681 static bfd_boolean
6682 ppc64_elf_gc_mark_dynamic_ref (struct elf_link_hash_entry *h, void *inf)
6683 {
6684 struct bfd_link_info *info = (struct bfd_link_info *) inf;
6685 struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
6686 struct ppc_link_hash_entry *fdh;
6687 struct bfd_elf_dynamic_list *d = info->dynamic_list;
6688
6689 /* Dynamic linking info is on the func descriptor sym. */
6690 fdh = defined_func_desc (eh);
6691 if (fdh != NULL)
6692 eh = fdh;
6693
6694 if ((eh->elf.root.type == bfd_link_hash_defined
6695 || eh->elf.root.type == bfd_link_hash_defweak)
6696 && ((eh->elf.ref_dynamic && !eh->elf.forced_local)
6697 || ((eh->elf.def_regular || ELF_COMMON_DEF_P (&eh->elf))
6698 && ELF_ST_VISIBILITY (eh->elf.other) != STV_INTERNAL
6699 && ELF_ST_VISIBILITY (eh->elf.other) != STV_HIDDEN
6700 && (!bfd_link_executable (info)
6701 || info->gc_keep_exported
6702 || info->export_dynamic
6703 || (eh->elf.dynamic
6704 && d != NULL
6705 && (*d->match) (&d->head, NULL, eh->elf.root.root.string)))
6706 && (eh->elf.versioned >= versioned
6707 || !bfd_hide_sym_by_version (info->version_info,
6708 eh->elf.root.root.string)))))
6709 {
6710 asection *code_sec;
6711 struct ppc_link_hash_entry *fh;
6712
6713 eh->elf.root.u.def.section->flags |= SEC_KEEP;
6714
6715 /* Function descriptor syms cause the associated
6716 function code sym section to be marked. */
6717 fh = defined_code_entry (eh);
6718 if (fh != NULL)
6719 {
6720 code_sec = fh->elf.root.u.def.section;
6721 code_sec->flags |= SEC_KEEP;
6722 }
6723 else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6724 && opd_entry_value (eh->elf.root.u.def.section,
6725 eh->elf.root.u.def.value,
6726 &code_sec, NULL, FALSE) != (bfd_vma) -1)
6727 code_sec->flags |= SEC_KEEP;
6728 }
6729
6730 return TRUE;
6731 }
6732
6733 /* Return the section that should be marked against GC for a given
6734 relocation. */
6735
6736 static asection *
6737 ppc64_elf_gc_mark_hook (asection *sec,
6738 struct bfd_link_info *info,
6739 Elf_Internal_Rela *rel,
6740 struct elf_link_hash_entry *h,
6741 Elf_Internal_Sym *sym)
6742 {
6743 asection *rsec;
6744
6745 /* Syms return NULL if we're marking .opd, so we avoid marking all
6746 function sections, as all functions are referenced in .opd. */
6747 rsec = NULL;
6748 if (get_opd_info (sec) != NULL)
6749 return rsec;
6750
6751 if (h != NULL)
6752 {
6753 enum elf_ppc64_reloc_type r_type;
6754 struct ppc_link_hash_entry *eh, *fh, *fdh;
6755
6756 r_type = ELF64_R_TYPE (rel->r_info);
6757 switch (r_type)
6758 {
6759 case R_PPC64_GNU_VTINHERIT:
6760 case R_PPC64_GNU_VTENTRY:
6761 break;
6762
6763 default:
6764 switch (h->root.type)
6765 {
6766 case bfd_link_hash_defined:
6767 case bfd_link_hash_defweak:
6768 eh = (struct ppc_link_hash_entry *) h;
6769 fdh = defined_func_desc (eh);
6770 if (fdh != NULL)
6771 {
6772 /* -mcall-aixdesc code references the dot-symbol on
6773 a call reloc. Mark the function descriptor too
6774 against garbage collection. */
6775 fdh->elf.mark = 1;
6776 if (fdh->elf.is_weakalias)
6777 weakdef (&fdh->elf)->mark = 1;
6778 eh = fdh;
6779 }
6780
6781 /* Function descriptor syms cause the associated
6782 function code sym section to be marked. */
6783 fh = defined_code_entry (eh);
6784 if (fh != NULL)
6785 {
6786 /* They also mark their opd section. */
6787 eh->elf.root.u.def.section->gc_mark = 1;
6788
6789 rsec = fh->elf.root.u.def.section;
6790 }
6791 else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6792 && opd_entry_value (eh->elf.root.u.def.section,
6793 eh->elf.root.u.def.value,
6794 &rsec, NULL, FALSE) != (bfd_vma) -1)
6795 eh->elf.root.u.def.section->gc_mark = 1;
6796 else
6797 rsec = h->root.u.def.section;
6798 break;
6799
6800 case bfd_link_hash_common:
6801 rsec = h->root.u.c.p->section;
6802 break;
6803
6804 default:
6805 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
6806 }
6807 }
6808 }
6809 else
6810 {
6811 struct _opd_sec_data *opd;
6812
6813 rsec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
6814 opd = get_opd_info (rsec);
6815 if (opd != NULL && opd->func_sec != NULL)
6816 {
6817 rsec->gc_mark = 1;
6818
6819 rsec = opd->func_sec[OPD_NDX (sym->st_value + rel->r_addend)];
6820 }
6821 }
6822
6823 return rsec;
6824 }
6825
6826 /* The maximum size of .sfpr. */
6827 #define SFPR_MAX (218*4)
6828
6829 struct sfpr_def_parms
6830 {
6831 const char name[12];
6832 unsigned char lo, hi;
6833 bfd_byte * (*write_ent) (bfd *, bfd_byte *, int);
6834 bfd_byte * (*write_tail) (bfd *, bfd_byte *, int);
6835 };
6836
6837 /* Auto-generate _save*, _rest* functions in .sfpr.
6838 If STUB_SEC is non-null, define alias symbols in STUB_SEC
6839 instead. */
6840
6841 static bfd_boolean
6842 sfpr_define (struct bfd_link_info *info,
6843 const struct sfpr_def_parms *parm,
6844 asection *stub_sec)
6845 {
6846 struct ppc_link_hash_table *htab = ppc_hash_table (info);
6847 unsigned int i;
6848 size_t len = strlen (parm->name);
6849 bfd_boolean writing = FALSE;
6850 char sym[16];
6851
6852 if (htab == NULL)
6853 return FALSE;
6854
6855 memcpy (sym, parm->name, len);
6856 sym[len + 2] = 0;
6857
6858 for (i = parm->lo; i <= parm->hi; i++)
6859 {
6860 struct ppc_link_hash_entry *h;
6861
6862 sym[len + 0] = i / 10 + '0';
6863 sym[len + 1] = i % 10 + '0';
6864 h = (struct ppc_link_hash_entry *)
6865 elf_link_hash_lookup (&htab->elf, sym, writing, TRUE, TRUE);
6866 if (stub_sec != NULL)
6867 {
6868 if (h != NULL
6869 && h->elf.root.type == bfd_link_hash_defined
6870 && h->elf.root.u.def.section == htab->sfpr)
6871 {
6872 struct elf_link_hash_entry *s;
6873 char buf[32];
6874 sprintf (buf, "%08x.%s", stub_sec->id & 0xffffffff, sym);
6875 s = elf_link_hash_lookup (&htab->elf, buf, TRUE, TRUE, FALSE);
6876 if (s == NULL)
6877 return FALSE;
6878 if (s->root.type == bfd_link_hash_new
6879 || (s->root.type = bfd_link_hash_defined
6880 && s->root.u.def.section == stub_sec))
6881 {
6882 s->root.type = bfd_link_hash_defined;
6883 s->root.u.def.section = stub_sec;
6884 s->root.u.def.value = (stub_sec->size - htab->sfpr->size
6885 + h->elf.root.u.def.value);
6886 s->ref_regular = 1;
6887 s->def_regular = 1;
6888 s->ref_regular_nonweak = 1;
6889 s->forced_local = 1;
6890 s->non_elf = 0;
6891 s->root.linker_def = 1;
6892 }
6893 }
6894 continue;
6895 }
6896 if (h != NULL)
6897 {
6898 h->save_res = 1;
6899 if (!h->elf.def_regular)
6900 {
6901 h->elf.root.type = bfd_link_hash_defined;
6902 h->elf.root.u.def.section = htab->sfpr;
6903 h->elf.root.u.def.value = htab->sfpr->size;
6904 h->elf.type = STT_FUNC;
6905 h->elf.def_regular = 1;
6906 h->elf.non_elf = 0;
6907 _bfd_elf_link_hash_hide_symbol (info, &h->elf, TRUE);
6908 writing = TRUE;
6909 if (htab->sfpr->contents == NULL)
6910 {
6911 htab->sfpr->contents = bfd_alloc (htab->elf.dynobj, SFPR_MAX);
6912 if (htab->sfpr->contents == NULL)
6913 return FALSE;
6914 }
6915 }
6916 }
6917 if (writing)
6918 {
6919 bfd_byte *p = htab->sfpr->contents + htab->sfpr->size;
6920 if (i != parm->hi)
6921 p = (*parm->write_ent) (htab->elf.dynobj, p, i);
6922 else
6923 p = (*parm->write_tail) (htab->elf.dynobj, p, i);
6924 htab->sfpr->size = p - htab->sfpr->contents;
6925 }
6926 }
6927
6928 return TRUE;
6929 }
6930
6931 static bfd_byte *
6932 savegpr0 (bfd *abfd, bfd_byte *p, int r)
6933 {
6934 bfd_put_32 (abfd, STD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6935 return p + 4;
6936 }
6937
6938 static bfd_byte *
6939 savegpr0_tail (bfd *abfd, bfd_byte *p, int r)
6940 {
6941 p = savegpr0 (abfd, p, r);
6942 bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
6943 p = p + 4;
6944 bfd_put_32 (abfd, BLR, p);
6945 return p + 4;
6946 }
6947
6948 static bfd_byte *
6949 restgpr0 (bfd *abfd, bfd_byte *p, int r)
6950 {
6951 bfd_put_32 (abfd, LD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6952 return p + 4;
6953 }
6954
6955 static bfd_byte *
6956 restgpr0_tail (bfd *abfd, bfd_byte *p, int r)
6957 {
6958 bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
6959 p = p + 4;
6960 p = restgpr0 (abfd, p, r);
6961 bfd_put_32 (abfd, MTLR_R0, p);
6962 p = p + 4;
6963 if (r == 29)
6964 {
6965 p = restgpr0 (abfd, p, 30);
6966 p = restgpr0 (abfd, p, 31);
6967 }
6968 bfd_put_32 (abfd, BLR, p);
6969 return p + 4;
6970 }
6971
6972 static bfd_byte *
6973 savegpr1 (bfd *abfd, bfd_byte *p, int r)
6974 {
6975 bfd_put_32 (abfd, STD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6976 return p + 4;
6977 }
6978
6979 static bfd_byte *
6980 savegpr1_tail (bfd *abfd, bfd_byte *p, int r)
6981 {
6982 p = savegpr1 (abfd, p, r);
6983 bfd_put_32 (abfd, BLR, p);
6984 return p + 4;
6985 }
6986
6987 static bfd_byte *
6988 restgpr1 (bfd *abfd, bfd_byte *p, int r)
6989 {
6990 bfd_put_32 (abfd, LD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6991 return p + 4;
6992 }
6993
6994 static bfd_byte *
6995 restgpr1_tail (bfd *abfd, bfd_byte *p, int r)
6996 {
6997 p = restgpr1 (abfd, p, r);
6998 bfd_put_32 (abfd, BLR, p);
6999 return p + 4;
7000 }
7001
7002 static bfd_byte *
7003 savefpr (bfd *abfd, bfd_byte *p, int r)
7004 {
7005 bfd_put_32 (abfd, STFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
7006 return p + 4;
7007 }
7008
7009 static bfd_byte *
7010 savefpr0_tail (bfd *abfd, bfd_byte *p, int r)
7011 {
7012 p = savefpr (abfd, p, r);
7013 bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
7014 p = p + 4;
7015 bfd_put_32 (abfd, BLR, p);
7016 return p + 4;
7017 }
7018
7019 static bfd_byte *
7020 restfpr (bfd *abfd, bfd_byte *p, int r)
7021 {
7022 bfd_put_32 (abfd, LFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
7023 return p + 4;
7024 }
7025
7026 static bfd_byte *
7027 restfpr0_tail (bfd *abfd, bfd_byte *p, int r)
7028 {
7029 bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
7030 p = p + 4;
7031 p = restfpr (abfd, p, r);
7032 bfd_put_32 (abfd, MTLR_R0, p);
7033 p = p + 4;
7034 if (r == 29)
7035 {
7036 p = restfpr (abfd, p, 30);
7037 p = restfpr (abfd, p, 31);
7038 }
7039 bfd_put_32 (abfd, BLR, p);
7040 return p + 4;
7041 }
7042
7043 static bfd_byte *
7044 savefpr1_tail (bfd *abfd, bfd_byte *p, int r)
7045 {
7046 p = savefpr (abfd, p, r);
7047 bfd_put_32 (abfd, BLR, p);
7048 return p + 4;
7049 }
7050
7051 static bfd_byte *
7052 restfpr1_tail (bfd *abfd, bfd_byte *p, int r)
7053 {
7054 p = restfpr (abfd, p, r);
7055 bfd_put_32 (abfd, BLR, p);
7056 return p + 4;
7057 }
7058
7059 static bfd_byte *
7060 savevr (bfd *abfd, bfd_byte *p, int r)
7061 {
7062 bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
7063 p = p + 4;
7064 bfd_put_32 (abfd, STVX_VR0_R12_R0 + (r << 21), p);
7065 return p + 4;
7066 }
7067
7068 static bfd_byte *
7069 savevr_tail (bfd *abfd, bfd_byte *p, int r)
7070 {
7071 p = savevr (abfd, p, r);
7072 bfd_put_32 (abfd, BLR, p);
7073 return p + 4;
7074 }
7075
7076 static bfd_byte *
7077 restvr (bfd *abfd, bfd_byte *p, int r)
7078 {
7079 bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
7080 p = p + 4;
7081 bfd_put_32 (abfd, LVX_VR0_R12_R0 + (r << 21), p);
7082 return p + 4;
7083 }
7084
7085 static bfd_byte *
7086 restvr_tail (bfd *abfd, bfd_byte *p, int r)
7087 {
7088 p = restvr (abfd, p, r);
7089 bfd_put_32 (abfd, BLR, p);
7090 return p + 4;
7091 }
7092
7093 /* Called via elf_link_hash_traverse to transfer dynamic linking
7094 information on function code symbol entries to their corresponding
7095 function descriptor symbol entries. */
7096
7097 static bfd_boolean
7098 func_desc_adjust (struct elf_link_hash_entry *h, void *inf)
7099 {
7100 struct bfd_link_info *info;
7101 struct ppc_link_hash_table *htab;
7102 struct ppc_link_hash_entry *fh;
7103 struct ppc_link_hash_entry *fdh;
7104 bfd_boolean force_local;
7105
7106 fh = (struct ppc_link_hash_entry *) h;
7107 if (fh->elf.root.type == bfd_link_hash_indirect)
7108 return TRUE;
7109
7110 if (!fh->is_func)
7111 return TRUE;
7112
7113 if (fh->elf.root.root.string[0] != '.'
7114 || fh->elf.root.root.string[1] == '\0')
7115 return TRUE;
7116
7117 info = inf;
7118 htab = ppc_hash_table (info);
7119 if (htab == NULL)
7120 return FALSE;
7121
7122 /* Find the corresponding function descriptor symbol. */
7123 fdh = lookup_fdh (fh, htab);
7124
7125 /* Resolve undefined references to dot-symbols as the value
7126 in the function descriptor, if we have one in a regular object.
7127 This is to satisfy cases like ".quad .foo". Calls to functions
7128 in dynamic objects are handled elsewhere. */
7129 if ((fh->elf.root.type == bfd_link_hash_undefined
7130 || fh->elf.root.type == bfd_link_hash_undefweak)
7131 && (fdh->elf.root.type == bfd_link_hash_defined
7132 || fdh->elf.root.type == bfd_link_hash_defweak)
7133 && get_opd_info (fdh->elf.root.u.def.section) != NULL
7134 && opd_entry_value (fdh->elf.root.u.def.section,
7135 fdh->elf.root.u.def.value,
7136 &fh->elf.root.u.def.section,
7137 &fh->elf.root.u.def.value, FALSE) != (bfd_vma) -1)
7138 {
7139 fh->elf.root.type = fdh->elf.root.type;
7140 fh->elf.forced_local = 1;
7141 fh->elf.def_regular = fdh->elf.def_regular;
7142 fh->elf.def_dynamic = fdh->elf.def_dynamic;
7143 }
7144
7145 if (!fh->elf.dynamic)
7146 {
7147 struct plt_entry *ent;
7148
7149 for (ent = fh->elf.plt.plist; ent != NULL; ent = ent->next)
7150 if (ent->plt.refcount > 0)
7151 break;
7152 if (ent == NULL)
7153 return TRUE;
7154 }
7155
7156 /* Create a descriptor as undefined if necessary. */
7157 if (fdh == NULL
7158 && !bfd_link_executable (info)
7159 && (fh->elf.root.type == bfd_link_hash_undefined
7160 || fh->elf.root.type == bfd_link_hash_undefweak))
7161 {
7162 fdh = make_fdh (info, fh);
7163 if (fdh == NULL)
7164 return FALSE;
7165 }
7166
7167 /* We can't support overriding of symbols on a fake descriptor. */
7168 if (fdh != NULL
7169 && fdh->fake
7170 && (fh->elf.root.type == bfd_link_hash_defined
7171 || fh->elf.root.type == bfd_link_hash_defweak))
7172 _bfd_elf_link_hash_hide_symbol (info, &fdh->elf, TRUE);
7173
7174 /* Transfer dynamic linking information to the function descriptor. */
7175 if (fdh != NULL)
7176 {
7177 fdh->elf.ref_regular |= fh->elf.ref_regular;
7178 fdh->elf.ref_dynamic |= fh->elf.ref_dynamic;
7179 fdh->elf.ref_regular_nonweak |= fh->elf.ref_regular_nonweak;
7180 fdh->elf.non_got_ref |= fh->elf.non_got_ref;
7181 fdh->elf.dynamic |= fh->elf.dynamic;
7182 fdh->elf.needs_plt |= (fh->elf.needs_plt
7183 || fh->elf.type == STT_FUNC
7184 || fh->elf.type == STT_GNU_IFUNC);
7185 move_plt_plist (fh, fdh);
7186
7187 if (!fdh->elf.forced_local
7188 && fh->elf.dynindx != -1)
7189 if (!bfd_elf_link_record_dynamic_symbol (info, &fdh->elf))
7190 return FALSE;
7191 }
7192
7193 /* Now that the info is on the function descriptor, clear the
7194 function code sym info. Any function code syms for which we
7195 don't have a definition in a regular file, we force local.
7196 This prevents a shared library from exporting syms that have
7197 been imported from another library. Function code syms that
7198 are really in the library we must leave global to prevent the
7199 linker dragging in a definition from a static library. */
7200 force_local = (!fh->elf.def_regular
7201 || fdh == NULL
7202 || !fdh->elf.def_regular
7203 || fdh->elf.forced_local);
7204 _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
7205
7206 return TRUE;
7207 }
7208
7209 static const struct sfpr_def_parms save_res_funcs[] =
7210 {
7211 { "_savegpr0_", 14, 31, savegpr0, savegpr0_tail },
7212 { "_restgpr0_", 14, 29, restgpr0, restgpr0_tail },
7213 { "_restgpr0_", 30, 31, restgpr0, restgpr0_tail },
7214 { "_savegpr1_", 14, 31, savegpr1, savegpr1_tail },
7215 { "_restgpr1_", 14, 31, restgpr1, restgpr1_tail },
7216 { "_savefpr_", 14, 31, savefpr, savefpr0_tail },
7217 { "_restfpr_", 14, 29, restfpr, restfpr0_tail },
7218 { "_restfpr_", 30, 31, restfpr, restfpr0_tail },
7219 { "._savef", 14, 31, savefpr, savefpr1_tail },
7220 { "._restf", 14, 31, restfpr, restfpr1_tail },
7221 { "_savevr_", 20, 31, savevr, savevr_tail },
7222 { "_restvr_", 20, 31, restvr, restvr_tail }
7223 };
7224
7225 /* Called near the start of bfd_elf_size_dynamic_sections. We use
7226 this hook to a) provide some gcc support functions, and b) transfer
7227 dynamic linking information gathered so far on function code symbol
7228 entries, to their corresponding function descriptor symbol entries. */
7229
7230 static bfd_boolean
7231 ppc64_elf_func_desc_adjust (bfd *obfd ATTRIBUTE_UNUSED,
7232 struct bfd_link_info *info)
7233 {
7234 struct ppc_link_hash_table *htab;
7235
7236 htab = ppc_hash_table (info);
7237 if (htab == NULL)
7238 return FALSE;
7239
7240 /* Provide any missing _save* and _rest* functions. */
7241 if (htab->sfpr != NULL)
7242 {
7243 unsigned int i;
7244
7245 htab->sfpr->size = 0;
7246 for (i = 0; i < ARRAY_SIZE (save_res_funcs); i++)
7247 if (!sfpr_define (info, &save_res_funcs[i], NULL))
7248 return FALSE;
7249 if (htab->sfpr->size == 0)
7250 htab->sfpr->flags |= SEC_EXCLUDE;
7251 }
7252
7253 if (bfd_link_relocatable (info))
7254 return TRUE;
7255
7256 if (htab->elf.hgot != NULL)
7257 {
7258 _bfd_elf_link_hash_hide_symbol (info, htab->elf.hgot, TRUE);
7259 /* Make .TOC. defined so as to prevent it being made dynamic.
7260 The wrong value here is fixed later in ppc64_elf_set_toc. */
7261 if (!htab->elf.hgot->def_regular
7262 || htab->elf.hgot->root.type != bfd_link_hash_defined)
7263 {
7264 htab->elf.hgot->root.type = bfd_link_hash_defined;
7265 htab->elf.hgot->root.u.def.value = 0;
7266 htab->elf.hgot->root.u.def.section = bfd_abs_section_ptr;
7267 htab->elf.hgot->def_regular = 1;
7268 htab->elf.hgot->root.linker_def = 1;
7269 }
7270 htab->elf.hgot->type = STT_OBJECT;
7271 htab->elf.hgot->other = ((htab->elf.hgot->other & ~ELF_ST_VISIBILITY (-1))
7272 | STV_HIDDEN);
7273 }
7274
7275 if (htab->need_func_desc_adj)
7276 {
7277 elf_link_hash_traverse (&htab->elf, func_desc_adjust, info);
7278 htab->need_func_desc_adj = 0;
7279 }
7280
7281 return TRUE;
7282 }
7283
7284 /* Find dynamic relocs for H that apply to read-only sections. */
7285
7286 static asection *
7287 readonly_dynrelocs (struct elf_link_hash_entry *h)
7288 {
7289 struct ppc_link_hash_entry *eh;
7290 struct elf_dyn_relocs *p;
7291
7292 eh = (struct ppc_link_hash_entry *) h;
7293 for (p = eh->dyn_relocs; p != NULL; p = p->next)
7294 {
7295 asection *s = p->sec->output_section;
7296
7297 if (s != NULL && (s->flags & SEC_READONLY) != 0)
7298 return p->sec;
7299 }
7300 return NULL;
7301 }
7302
7303 /* Return true if we have dynamic relocs against H or any of its weak
7304 aliases, that apply to read-only sections. Cannot be used after
7305 size_dynamic_sections. */
7306
7307 static bfd_boolean
7308 alias_readonly_dynrelocs (struct elf_link_hash_entry *h)
7309 {
7310 struct ppc_link_hash_entry *eh;
7311
7312 eh = (struct ppc_link_hash_entry *) h;
7313 do
7314 {
7315 if (readonly_dynrelocs (&eh->elf))
7316 return TRUE;
7317 eh = (struct ppc_link_hash_entry *) eh->elf.u.alias;
7318 } while (eh != NULL && &eh->elf != h);
7319
7320 return FALSE;
7321 }
7322
7323 /* Return whether EH has pc-relative dynamic relocs. */
7324
7325 static bfd_boolean
7326 pc_dynrelocs (struct ppc_link_hash_entry *eh)
7327 {
7328 struct elf_dyn_relocs *p;
7329
7330 for (p = eh->dyn_relocs; p != NULL; p = p->next)
7331 if (p->pc_count != 0)
7332 return TRUE;
7333 return FALSE;
7334 }
7335
7336 /* Return true if a global entry stub will be created for H. Valid
7337 for ELFv2 before plt entries have been allocated. */
7338
7339 static bfd_boolean
7340 global_entry_stub (struct elf_link_hash_entry *h)
7341 {
7342 struct plt_entry *pent;
7343
7344 if (!h->pointer_equality_needed
7345 || h->def_regular)
7346 return FALSE;
7347
7348 for (pent = h->plt.plist; pent != NULL; pent = pent->next)
7349 if (pent->plt.refcount > 0
7350 && pent->addend == 0)
7351 return TRUE;
7352
7353 return FALSE;
7354 }
7355
7356 /* Adjust a symbol defined by a dynamic object and referenced by a
7357 regular object. The current definition is in some section of the
7358 dynamic object, but we're not including those sections. We have to
7359 change the definition to something the rest of the link can
7360 understand. */
7361
7362 static bfd_boolean
7363 ppc64_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
7364 struct elf_link_hash_entry *h)
7365 {
7366 struct ppc_link_hash_table *htab;
7367 asection *s, *srel;
7368
7369 htab = ppc_hash_table (info);
7370 if (htab == NULL)
7371 return FALSE;
7372
7373 /* Deal with function syms. */
7374 if (h->type == STT_FUNC
7375 || h->type == STT_GNU_IFUNC
7376 || h->needs_plt)
7377 {
7378 bfd_boolean local = (((struct ppc_link_hash_entry *) h)->save_res
7379 || SYMBOL_CALLS_LOCAL (info, h)
7380 || UNDEFWEAK_NO_DYNAMIC_RELOC (info, h));
7381 /* Discard dyn_relocs when non-pic if we've decided that a
7382 function symbol is local and not an ifunc. We keep dynamic
7383 relocs for ifuncs when local rather than always emitting a
7384 plt call stub for them and defining the symbol on the call
7385 stub. We can't do that for ELFv1 anyway (a function symbol
7386 is defined on a descriptor, not code) and it can be faster at
7387 run-time due to not needing to bounce through a stub. The
7388 dyn_relocs for ifuncs will be applied even in a static
7389 executable. */
7390 if (!bfd_link_pic (info)
7391 && h->type != STT_GNU_IFUNC
7392 && local)
7393 ((struct ppc_link_hash_entry *) h)->dyn_relocs = NULL;
7394
7395 /* Clear procedure linkage table information for any symbol that
7396 won't need a .plt entry. */
7397 struct plt_entry *ent;
7398 for (ent = h->plt.plist; ent != NULL; ent = ent->next)
7399 if (ent->plt.refcount > 0)
7400 break;
7401 if (ent == NULL
7402 || (h->type != STT_GNU_IFUNC
7403 && local
7404 && (htab->can_convert_all_inline_plt
7405 || (((struct ppc_link_hash_entry *) h)->tls_mask
7406 & (TLS_TLS | PLT_KEEP)) != PLT_KEEP)))
7407 {
7408 h->plt.plist = NULL;
7409 h->needs_plt = 0;
7410 h->pointer_equality_needed = 0;
7411 }
7412 else if (abiversion (info->output_bfd) >= 2)
7413 {
7414 /* Taking a function's address in a read/write section
7415 doesn't require us to define the function symbol in the
7416 executable on a global entry stub. A dynamic reloc can
7417 be used instead. The reason we prefer a few more dynamic
7418 relocs is that calling via a global entry stub costs a
7419 few more instructions, and pointer_equality_needed causes
7420 extra work in ld.so when resolving these symbols. */
7421 if (global_entry_stub (h))
7422 {
7423 if (!readonly_dynrelocs (h))
7424 {
7425 h->pointer_equality_needed = 0;
7426 /* If we haven't seen a branch reloc and the symbol
7427 isn't an ifunc then we don't need a plt entry. */
7428 if (!h->needs_plt)
7429 h->plt.plist = NULL;
7430 }
7431 else if (!bfd_link_pic (info))
7432 /* We are going to be defining the function symbol on the
7433 plt stub, so no dyn_relocs needed when non-pic. */
7434 ((struct ppc_link_hash_entry *) h)->dyn_relocs = NULL;
7435 }
7436
7437 /* ELFv2 function symbols can't have copy relocs. */
7438 return TRUE;
7439 }
7440 else if (!h->needs_plt
7441 && !readonly_dynrelocs (h))
7442 {
7443 /* If we haven't seen a branch reloc and the symbol isn't an
7444 ifunc then we don't need a plt entry. */
7445 h->plt.plist = NULL;
7446 h->pointer_equality_needed = 0;
7447 return TRUE;
7448 }
7449 }
7450 else
7451 h->plt.plist = NULL;
7452
7453 /* If this is a weak symbol, and there is a real definition, the
7454 processor independent code will have arranged for us to see the
7455 real definition first, and we can just use the same value. */
7456 if (h->is_weakalias)
7457 {
7458 struct elf_link_hash_entry *def = weakdef (h);
7459 BFD_ASSERT (def->root.type == bfd_link_hash_defined);
7460 h->root.u.def.section = def->root.u.def.section;
7461 h->root.u.def.value = def->root.u.def.value;
7462 if (def->root.u.def.section == htab->elf.sdynbss
7463 || def->root.u.def.section == htab->elf.sdynrelro)
7464 ((struct ppc_link_hash_entry *) h)->dyn_relocs = NULL;
7465 return TRUE;
7466 }
7467
7468 /* If we are creating a shared library, we must presume that the
7469 only references to the symbol are via the global offset table.
7470 For such cases we need not do anything here; the relocations will
7471 be handled correctly by relocate_section. */
7472 if (bfd_link_pic (info))
7473 return TRUE;
7474
7475 /* If there are no references to this symbol that do not use the
7476 GOT, we don't need to generate a copy reloc. */
7477 if (!h->non_got_ref)
7478 return TRUE;
7479
7480 /* Don't generate a copy reloc for symbols defined in the executable. */
7481 if (!h->def_dynamic || !h->ref_regular || h->def_regular
7482
7483 /* If -z nocopyreloc was given, don't generate them either. */
7484 || info->nocopyreloc
7485
7486 /* If we don't find any dynamic relocs in read-only sections, then
7487 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
7488 || (ELIMINATE_COPY_RELOCS && !alias_readonly_dynrelocs (h))
7489
7490 /* Protected variables do not work with .dynbss. The copy in
7491 .dynbss won't be used by the shared library with the protected
7492 definition for the variable. Text relocations are preferable
7493 to an incorrect program. */
7494 || h->protected_def)
7495 return TRUE;
7496
7497 if (h->plt.plist != NULL)
7498 {
7499 /* We should never get here, but unfortunately there are versions
7500 of gcc out there that improperly (for this ABI) put initialized
7501 function pointers, vtable refs and suchlike in read-only
7502 sections. Allow them to proceed, but warn that this might
7503 break at runtime. */
7504 info->callbacks->einfo
7505 (_("%P: copy reloc against `%pT' requires lazy plt linking; "
7506 "avoid setting LD_BIND_NOW=1 or upgrade gcc\n"),
7507 h->root.root.string);
7508 }
7509
7510 /* This is a reference to a symbol defined by a dynamic object which
7511 is not a function. */
7512
7513 /* We must allocate the symbol in our .dynbss section, which will
7514 become part of the .bss section of the executable. There will be
7515 an entry for this symbol in the .dynsym section. The dynamic
7516 object will contain position independent code, so all references
7517 from the dynamic object to this symbol will go through the global
7518 offset table. The dynamic linker will use the .dynsym entry to
7519 determine the address it must put in the global offset table, so
7520 both the dynamic object and the regular object will refer to the
7521 same memory location for the variable. */
7522 if ((h->root.u.def.section->flags & SEC_READONLY) != 0)
7523 {
7524 s = htab->elf.sdynrelro;
7525 srel = htab->elf.sreldynrelro;
7526 }
7527 else
7528 {
7529 s = htab->elf.sdynbss;
7530 srel = htab->elf.srelbss;
7531 }
7532 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
7533 {
7534 /* We must generate a R_PPC64_COPY reloc to tell the dynamic
7535 linker to copy the initial value out of the dynamic object
7536 and into the runtime process image. */
7537 srel->size += sizeof (Elf64_External_Rela);
7538 h->needs_copy = 1;
7539 }
7540
7541 /* We no longer want dyn_relocs. */
7542 ((struct ppc_link_hash_entry *) h)->dyn_relocs = NULL;
7543 return _bfd_elf_adjust_dynamic_copy (info, h, s);
7544 }
7545
7546 /* If given a function descriptor symbol, hide both the function code
7547 sym and the descriptor. */
7548 static void
7549 ppc64_elf_hide_symbol (struct bfd_link_info *info,
7550 struct elf_link_hash_entry *h,
7551 bfd_boolean force_local)
7552 {
7553 struct ppc_link_hash_entry *eh;
7554 _bfd_elf_link_hash_hide_symbol (info, h, force_local);
7555
7556 eh = (struct ppc_link_hash_entry *) h;
7557 if (eh->is_func_descriptor)
7558 {
7559 struct ppc_link_hash_entry *fh = eh->oh;
7560
7561 if (fh == NULL)
7562 {
7563 const char *p, *q;
7564 struct elf_link_hash_table *htab = elf_hash_table (info);
7565 char save;
7566
7567 /* We aren't supposed to use alloca in BFD because on
7568 systems which do not have alloca the version in libiberty
7569 calls xmalloc, which might cause the program to crash
7570 when it runs out of memory. This function doesn't have a
7571 return status, so there's no way to gracefully return an
7572 error. So cheat. We know that string[-1] can be safely
7573 accessed; It's either a string in an ELF string table,
7574 or allocated in an objalloc structure. */
7575
7576 p = eh->elf.root.root.string - 1;
7577 save = *p;
7578 *(char *) p = '.';
7579 fh = (struct ppc_link_hash_entry *)
7580 elf_link_hash_lookup (htab, p, FALSE, FALSE, FALSE);
7581 *(char *) p = save;
7582
7583 /* Unfortunately, if it so happens that the string we were
7584 looking for was allocated immediately before this string,
7585 then we overwrote the string terminator. That's the only
7586 reason the lookup should fail. */
7587 if (fh == NULL)
7588 {
7589 q = eh->elf.root.root.string + strlen (eh->elf.root.root.string);
7590 while (q >= eh->elf.root.root.string && *q == *p)
7591 --q, --p;
7592 if (q < eh->elf.root.root.string && *p == '.')
7593 fh = (struct ppc_link_hash_entry *)
7594 elf_link_hash_lookup (htab, p, FALSE, FALSE, FALSE);
7595 }
7596 if (fh != NULL)
7597 {
7598 eh->oh = fh;
7599 fh->oh = eh;
7600 }
7601 }
7602 if (fh != NULL)
7603 _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
7604 }
7605 }
7606
7607 static bfd_boolean
7608 get_sym_h (struct elf_link_hash_entry **hp,
7609 Elf_Internal_Sym **symp,
7610 asection **symsecp,
7611 unsigned char **tls_maskp,
7612 Elf_Internal_Sym **locsymsp,
7613 unsigned long r_symndx,
7614 bfd *ibfd)
7615 {
7616 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
7617
7618 if (r_symndx >= symtab_hdr->sh_info)
7619 {
7620 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
7621 struct elf_link_hash_entry *h;
7622
7623 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
7624 h = elf_follow_link (h);
7625
7626 if (hp != NULL)
7627 *hp = h;
7628
7629 if (symp != NULL)
7630 *symp = NULL;
7631
7632 if (symsecp != NULL)
7633 {
7634 asection *symsec = NULL;
7635 if (h->root.type == bfd_link_hash_defined
7636 || h->root.type == bfd_link_hash_defweak)
7637 symsec = h->root.u.def.section;
7638 *symsecp = symsec;
7639 }
7640
7641 if (tls_maskp != NULL)
7642 {
7643 struct ppc_link_hash_entry *eh;
7644
7645 eh = (struct ppc_link_hash_entry *) h;
7646 *tls_maskp = &eh->tls_mask;
7647 }
7648 }
7649 else
7650 {
7651 Elf_Internal_Sym *sym;
7652 Elf_Internal_Sym *locsyms = *locsymsp;
7653
7654 if (locsyms == NULL)
7655 {
7656 locsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
7657 if (locsyms == NULL)
7658 locsyms = bfd_elf_get_elf_syms (ibfd, symtab_hdr,
7659 symtab_hdr->sh_info,
7660 0, NULL, NULL, NULL);
7661 if (locsyms == NULL)
7662 return FALSE;
7663 *locsymsp = locsyms;
7664 }
7665 sym = locsyms + r_symndx;
7666
7667 if (hp != NULL)
7668 *hp = NULL;
7669
7670 if (symp != NULL)
7671 *symp = sym;
7672
7673 if (symsecp != NULL)
7674 *symsecp = bfd_section_from_elf_index (ibfd, sym->st_shndx);
7675
7676 if (tls_maskp != NULL)
7677 {
7678 struct got_entry **lgot_ents;
7679 unsigned char *tls_mask;
7680
7681 tls_mask = NULL;
7682 lgot_ents = elf_local_got_ents (ibfd);
7683 if (lgot_ents != NULL)
7684 {
7685 struct plt_entry **local_plt = (struct plt_entry **)
7686 (lgot_ents + symtab_hdr->sh_info);
7687 unsigned char *lgot_masks = (unsigned char *)
7688 (local_plt + symtab_hdr->sh_info);
7689 tls_mask = &lgot_masks[r_symndx];
7690 }
7691 *tls_maskp = tls_mask;
7692 }
7693 }
7694 return TRUE;
7695 }
7696
7697 /* Returns TLS_MASKP for the given REL symbol. Function return is 0 on
7698 error, 2 on a toc GD type suitable for optimization, 3 on a toc LD
7699 type suitable for optimization, and 1 otherwise. */
7700
7701 static int
7702 get_tls_mask (unsigned char **tls_maskp,
7703 unsigned long *toc_symndx,
7704 bfd_vma *toc_addend,
7705 Elf_Internal_Sym **locsymsp,
7706 const Elf_Internal_Rela *rel,
7707 bfd *ibfd)
7708 {
7709 unsigned long r_symndx;
7710 int next_r;
7711 struct elf_link_hash_entry *h;
7712 Elf_Internal_Sym *sym;
7713 asection *sec;
7714 bfd_vma off;
7715
7716 r_symndx = ELF64_R_SYM (rel->r_info);
7717 if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7718 return 0;
7719
7720 if ((*tls_maskp != NULL
7721 && (**tls_maskp & TLS_TLS) != 0
7722 && **tls_maskp != (TLS_TLS | TLS_MARK))
7723 || sec == NULL
7724 || ppc64_elf_section_data (sec) == NULL
7725 || ppc64_elf_section_data (sec)->sec_type != sec_toc)
7726 return 1;
7727
7728 /* Look inside a TOC section too. */
7729 if (h != NULL)
7730 {
7731 BFD_ASSERT (h->root.type == bfd_link_hash_defined);
7732 off = h->root.u.def.value;
7733 }
7734 else
7735 off = sym->st_value;
7736 off += rel->r_addend;
7737 BFD_ASSERT (off % 8 == 0);
7738 r_symndx = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8];
7739 next_r = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8 + 1];
7740 if (toc_symndx != NULL)
7741 *toc_symndx = r_symndx;
7742 if (toc_addend != NULL)
7743 *toc_addend = ppc64_elf_section_data (sec)->u.toc.add[off / 8];
7744 if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7745 return 0;
7746 if ((h == NULL || is_static_defined (h))
7747 && (next_r == -1 || next_r == -2))
7748 return 1 - next_r;
7749 return 1;
7750 }
7751
7752 /* Find (or create) an entry in the tocsave hash table. */
7753
7754 static struct tocsave_entry *
7755 tocsave_find (struct ppc_link_hash_table *htab,
7756 enum insert_option insert,
7757 Elf_Internal_Sym **local_syms,
7758 const Elf_Internal_Rela *irela,
7759 bfd *ibfd)
7760 {
7761 unsigned long r_indx;
7762 struct elf_link_hash_entry *h;
7763 Elf_Internal_Sym *sym;
7764 struct tocsave_entry ent, *p;
7765 hashval_t hash;
7766 struct tocsave_entry **slot;
7767
7768 r_indx = ELF64_R_SYM (irela->r_info);
7769 if (!get_sym_h (&h, &sym, &ent.sec, NULL, local_syms, r_indx, ibfd))
7770 return NULL;
7771 if (ent.sec == NULL || ent.sec->output_section == NULL)
7772 {
7773 _bfd_error_handler
7774 (_("%pB: undefined symbol on R_PPC64_TOCSAVE relocation"), ibfd);
7775 return NULL;
7776 }
7777
7778 if (h != NULL)
7779 ent.offset = h->root.u.def.value;
7780 else
7781 ent.offset = sym->st_value;
7782 ent.offset += irela->r_addend;
7783
7784 hash = tocsave_htab_hash (&ent);
7785 slot = ((struct tocsave_entry **)
7786 htab_find_slot_with_hash (htab->tocsave_htab, &ent, hash, insert));
7787 if (slot == NULL)
7788 return NULL;
7789
7790 if (*slot == NULL)
7791 {
7792 p = (struct tocsave_entry *) bfd_alloc (ibfd, sizeof (*p));
7793 if (p == NULL)
7794 return NULL;
7795 *p = ent;
7796 *slot = p;
7797 }
7798 return *slot;
7799 }
7800
7801 /* Adjust all global syms defined in opd sections. In gcc generated
7802 code for the old ABI, these will already have been done. */
7803
7804 static bfd_boolean
7805 adjust_opd_syms (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
7806 {
7807 struct ppc_link_hash_entry *eh;
7808 asection *sym_sec;
7809 struct _opd_sec_data *opd;
7810
7811 if (h->root.type == bfd_link_hash_indirect)
7812 return TRUE;
7813
7814 if (h->root.type != bfd_link_hash_defined
7815 && h->root.type != bfd_link_hash_defweak)
7816 return TRUE;
7817
7818 eh = (struct ppc_link_hash_entry *) h;
7819 if (eh->adjust_done)
7820 return TRUE;
7821
7822 sym_sec = eh->elf.root.u.def.section;
7823 opd = get_opd_info (sym_sec);
7824 if (opd != NULL && opd->adjust != NULL)
7825 {
7826 long adjust = opd->adjust[OPD_NDX (eh->elf.root.u.def.value)];
7827 if (adjust == -1)
7828 {
7829 /* This entry has been deleted. */
7830 asection *dsec = ppc64_elf_tdata (sym_sec->owner)->deleted_section;
7831 if (dsec == NULL)
7832 {
7833 for (dsec = sym_sec->owner->sections; dsec; dsec = dsec->next)
7834 if (discarded_section (dsec))
7835 {
7836 ppc64_elf_tdata (sym_sec->owner)->deleted_section = dsec;
7837 break;
7838 }
7839 }
7840 eh->elf.root.u.def.value = 0;
7841 eh->elf.root.u.def.section = dsec;
7842 }
7843 else
7844 eh->elf.root.u.def.value += adjust;
7845 eh->adjust_done = 1;
7846 }
7847 return TRUE;
7848 }
7849
7850 /* Handles decrementing dynamic reloc counts for the reloc specified by
7851 R_INFO in section SEC. If LOCAL_SYMS is NULL, then H and SYM
7852 have already been determined. */
7853
7854 static bfd_boolean
7855 dec_dynrel_count (bfd_vma r_info,
7856 asection *sec,
7857 struct bfd_link_info *info,
7858 Elf_Internal_Sym **local_syms,
7859 struct elf_link_hash_entry *h,
7860 Elf_Internal_Sym *sym)
7861 {
7862 enum elf_ppc64_reloc_type r_type;
7863 asection *sym_sec = NULL;
7864
7865 /* Can this reloc be dynamic? This switch, and later tests here
7866 should be kept in sync with the code in check_relocs. */
7867 r_type = ELF64_R_TYPE (r_info);
7868 switch (r_type)
7869 {
7870 default:
7871 return TRUE;
7872
7873 case R_PPC64_TPREL16:
7874 case R_PPC64_TPREL16_LO:
7875 case R_PPC64_TPREL16_HI:
7876 case R_PPC64_TPREL16_HA:
7877 case R_PPC64_TPREL16_DS:
7878 case R_PPC64_TPREL16_LO_DS:
7879 case R_PPC64_TPREL16_HIGH:
7880 case R_PPC64_TPREL16_HIGHA:
7881 case R_PPC64_TPREL16_HIGHER:
7882 case R_PPC64_TPREL16_HIGHERA:
7883 case R_PPC64_TPREL16_HIGHEST:
7884 case R_PPC64_TPREL16_HIGHESTA:
7885 case R_PPC64_TPREL64:
7886 case R_PPC64_DTPMOD64:
7887 case R_PPC64_DTPREL64:
7888 case R_PPC64_ADDR64:
7889 case R_PPC64_REL30:
7890 case R_PPC64_REL32:
7891 case R_PPC64_REL64:
7892 case R_PPC64_ADDR14:
7893 case R_PPC64_ADDR14_BRNTAKEN:
7894 case R_PPC64_ADDR14_BRTAKEN:
7895 case R_PPC64_ADDR16:
7896 case R_PPC64_ADDR16_DS:
7897 case R_PPC64_ADDR16_HA:
7898 case R_PPC64_ADDR16_HI:
7899 case R_PPC64_ADDR16_HIGH:
7900 case R_PPC64_ADDR16_HIGHA:
7901 case R_PPC64_ADDR16_HIGHER:
7902 case R_PPC64_ADDR16_HIGHERA:
7903 case R_PPC64_ADDR16_HIGHEST:
7904 case R_PPC64_ADDR16_HIGHESTA:
7905 case R_PPC64_ADDR16_LO:
7906 case R_PPC64_ADDR16_LO_DS:
7907 case R_PPC64_ADDR24:
7908 case R_PPC64_ADDR32:
7909 case R_PPC64_UADDR16:
7910 case R_PPC64_UADDR32:
7911 case R_PPC64_UADDR64:
7912 case R_PPC64_TOC:
7913 break;
7914 }
7915
7916 if (local_syms != NULL)
7917 {
7918 unsigned long r_symndx;
7919 bfd *ibfd = sec->owner;
7920
7921 r_symndx = ELF64_R_SYM (r_info);
7922 if (!get_sym_h (&h, &sym, &sym_sec, NULL, local_syms, r_symndx, ibfd))
7923 return FALSE;
7924 }
7925
7926 if ((bfd_link_pic (info)
7927 && (must_be_dyn_reloc (info, r_type)
7928 || (h != NULL
7929 && (!SYMBOLIC_BIND (info, h)
7930 || h->root.type == bfd_link_hash_defweak
7931 || !h->def_regular))))
7932 || (ELIMINATE_COPY_RELOCS
7933 && !bfd_link_pic (info)
7934 && h != NULL
7935 && (h->root.type == bfd_link_hash_defweak
7936 || !h->def_regular)))
7937 ;
7938 else
7939 return TRUE;
7940
7941 if (h != NULL)
7942 {
7943 struct elf_dyn_relocs *p;
7944 struct elf_dyn_relocs **pp;
7945 pp = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
7946
7947 /* elf_gc_sweep may have already removed all dyn relocs associated
7948 with local syms for a given section. Also, symbol flags are
7949 changed by elf_gc_sweep_symbol, confusing the test above. Don't
7950 report a dynreloc miscount. */
7951 if (*pp == NULL && info->gc_sections)
7952 return TRUE;
7953
7954 while ((p = *pp) != NULL)
7955 {
7956 if (p->sec == sec)
7957 {
7958 if (!must_be_dyn_reloc (info, r_type))
7959 p->pc_count -= 1;
7960 p->count -= 1;
7961 if (p->count == 0)
7962 *pp = p->next;
7963 return TRUE;
7964 }
7965 pp = &p->next;
7966 }
7967 }
7968 else
7969 {
7970 struct ppc_dyn_relocs *p;
7971 struct ppc_dyn_relocs **pp;
7972 void *vpp;
7973 bfd_boolean is_ifunc;
7974
7975 if (local_syms == NULL)
7976 sym_sec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
7977 if (sym_sec == NULL)
7978 sym_sec = sec;
7979
7980 vpp = &elf_section_data (sym_sec)->local_dynrel;
7981 pp = (struct ppc_dyn_relocs **) vpp;
7982
7983 if (*pp == NULL && info->gc_sections)
7984 return TRUE;
7985
7986 is_ifunc = ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC;
7987 while ((p = *pp) != NULL)
7988 {
7989 if (p->sec == sec && p->ifunc == is_ifunc)
7990 {
7991 p->count -= 1;
7992 if (p->count == 0)
7993 *pp = p->next;
7994 return TRUE;
7995 }
7996 pp = &p->next;
7997 }
7998 }
7999
8000 /* xgettext:c-format */
8001 _bfd_error_handler (_("dynreloc miscount for %pB, section %pA"),
8002 sec->owner, sec);
8003 bfd_set_error (bfd_error_bad_value);
8004 return FALSE;
8005 }
8006
8007 /* Remove unused Official Procedure Descriptor entries. Currently we
8008 only remove those associated with functions in discarded link-once
8009 sections, or weakly defined functions that have been overridden. It
8010 would be possible to remove many more entries for statically linked
8011 applications. */
8012
8013 bfd_boolean
8014 ppc64_elf_edit_opd (struct bfd_link_info *info)
8015 {
8016 bfd *ibfd;
8017 bfd_boolean some_edited = FALSE;
8018 asection *need_pad = NULL;
8019 struct ppc_link_hash_table *htab;
8020
8021 htab = ppc_hash_table (info);
8022 if (htab == NULL)
8023 return FALSE;
8024
8025 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
8026 {
8027 asection *sec;
8028 Elf_Internal_Rela *relstart, *rel, *relend;
8029 Elf_Internal_Shdr *symtab_hdr;
8030 Elf_Internal_Sym *local_syms;
8031 struct _opd_sec_data *opd;
8032 bfd_boolean need_edit, add_aux_fields, broken;
8033 bfd_size_type cnt_16b = 0;
8034
8035 if (!is_ppc64_elf (ibfd))
8036 continue;
8037
8038 sec = bfd_get_section_by_name (ibfd, ".opd");
8039 if (sec == NULL || sec->size == 0)
8040 continue;
8041
8042 if (sec->sec_info_type == SEC_INFO_TYPE_JUST_SYMS)
8043 continue;
8044
8045 if (sec->output_section == bfd_abs_section_ptr)
8046 continue;
8047
8048 /* Look through the section relocs. */
8049 if ((sec->flags & SEC_RELOC) == 0 || sec->reloc_count == 0)
8050 continue;
8051
8052 local_syms = NULL;
8053 symtab_hdr = &elf_symtab_hdr (ibfd);
8054
8055 /* Read the relocations. */
8056 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8057 info->keep_memory);
8058 if (relstart == NULL)
8059 return FALSE;
8060
8061 /* First run through the relocs to check they are sane, and to
8062 determine whether we need to edit this opd section. */
8063 need_edit = FALSE;
8064 broken = FALSE;
8065 need_pad = sec;
8066 relend = relstart + sec->reloc_count;
8067 for (rel = relstart; rel < relend; )
8068 {
8069 enum elf_ppc64_reloc_type r_type;
8070 unsigned long r_symndx;
8071 asection *sym_sec;
8072 struct elf_link_hash_entry *h;
8073 Elf_Internal_Sym *sym;
8074 bfd_vma offset;
8075
8076 /* .opd contains an array of 16 or 24 byte entries. We're
8077 only interested in the reloc pointing to a function entry
8078 point. */
8079 offset = rel->r_offset;
8080 if (rel + 1 == relend
8081 || rel[1].r_offset != offset + 8)
8082 {
8083 /* If someone messes with .opd alignment then after a
8084 "ld -r" we might have padding in the middle of .opd.
8085 Also, there's nothing to prevent someone putting
8086 something silly in .opd with the assembler. No .opd
8087 optimization for them! */
8088 broken_opd:
8089 _bfd_error_handler
8090 (_("%pB: .opd is not a regular array of opd entries"), ibfd);
8091 broken = TRUE;
8092 break;
8093 }
8094
8095 if ((r_type = ELF64_R_TYPE (rel->r_info)) != R_PPC64_ADDR64
8096 || (r_type = ELF64_R_TYPE ((rel + 1)->r_info)) != R_PPC64_TOC)
8097 {
8098 _bfd_error_handler
8099 /* xgettext:c-format */
8100 (_("%pB: unexpected reloc type %u in .opd section"),
8101 ibfd, r_type);
8102 broken = TRUE;
8103 break;
8104 }
8105
8106 r_symndx = ELF64_R_SYM (rel->r_info);
8107 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8108 r_symndx, ibfd))
8109 goto error_ret;
8110
8111 if (sym_sec == NULL || sym_sec->owner == NULL)
8112 {
8113 const char *sym_name;
8114 if (h != NULL)
8115 sym_name = h->root.root.string;
8116 else
8117 sym_name = bfd_elf_sym_name (ibfd, symtab_hdr, sym,
8118 sym_sec);
8119
8120 _bfd_error_handler
8121 /* xgettext:c-format */
8122 (_("%pB: undefined sym `%s' in .opd section"),
8123 ibfd, sym_name);
8124 broken = TRUE;
8125 break;
8126 }
8127
8128 /* opd entries are always for functions defined in the
8129 current input bfd. If the symbol isn't defined in the
8130 input bfd, then we won't be using the function in this
8131 bfd; It must be defined in a linkonce section in another
8132 bfd, or is weak. It's also possible that we are
8133 discarding the function due to a linker script /DISCARD/,
8134 which we test for via the output_section. */
8135 if (sym_sec->owner != ibfd
8136 || sym_sec->output_section == bfd_abs_section_ptr)
8137 need_edit = TRUE;
8138
8139 rel += 2;
8140 if (rel + 1 == relend
8141 || (rel + 2 < relend
8142 && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_TOC))
8143 ++rel;
8144
8145 if (rel == relend)
8146 {
8147 if (sec->size == offset + 24)
8148 {
8149 need_pad = NULL;
8150 break;
8151 }
8152 if (sec->size == offset + 16)
8153 {
8154 cnt_16b++;
8155 break;
8156 }
8157 goto broken_opd;
8158 }
8159 else if (rel + 1 < relend
8160 && ELF64_R_TYPE (rel[0].r_info) == R_PPC64_ADDR64
8161 && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOC)
8162 {
8163 if (rel[0].r_offset == offset + 16)
8164 cnt_16b++;
8165 else if (rel[0].r_offset != offset + 24)
8166 goto broken_opd;
8167 }
8168 else
8169 goto broken_opd;
8170 }
8171
8172 add_aux_fields = htab->params->non_overlapping_opd && cnt_16b > 0;
8173
8174 if (!broken && (need_edit || add_aux_fields))
8175 {
8176 Elf_Internal_Rela *write_rel;
8177 Elf_Internal_Shdr *rel_hdr;
8178 bfd_byte *rptr, *wptr;
8179 bfd_byte *new_contents;
8180 bfd_size_type amt;
8181
8182 new_contents = NULL;
8183 amt = OPD_NDX (sec->size) * sizeof (long);
8184 opd = &ppc64_elf_section_data (sec)->u.opd;
8185 opd->adjust = bfd_zalloc (sec->owner, amt);
8186 if (opd->adjust == NULL)
8187 return FALSE;
8188
8189 /* This seems a waste of time as input .opd sections are all
8190 zeros as generated by gcc, but I suppose there's no reason
8191 this will always be so. We might start putting something in
8192 the third word of .opd entries. */
8193 if ((sec->flags & SEC_IN_MEMORY) == 0)
8194 {
8195 bfd_byte *loc;
8196 if (!bfd_malloc_and_get_section (ibfd, sec, &loc))
8197 {
8198 if (loc != NULL)
8199 free (loc);
8200 error_ret:
8201 if (local_syms != NULL
8202 && symtab_hdr->contents != (unsigned char *) local_syms)
8203 free (local_syms);
8204 if (elf_section_data (sec)->relocs != relstart)
8205 free (relstart);
8206 return FALSE;
8207 }
8208 sec->contents = loc;
8209 sec->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
8210 }
8211
8212 elf_section_data (sec)->relocs = relstart;
8213
8214 new_contents = sec->contents;
8215 if (add_aux_fields)
8216 {
8217 new_contents = bfd_malloc (sec->size + cnt_16b * 8);
8218 if (new_contents == NULL)
8219 return FALSE;
8220 need_pad = NULL;
8221 }
8222 wptr = new_contents;
8223 rptr = sec->contents;
8224 write_rel = relstart;
8225 for (rel = relstart; rel < relend; )
8226 {
8227 unsigned long r_symndx;
8228 asection *sym_sec;
8229 struct elf_link_hash_entry *h;
8230 struct ppc_link_hash_entry *fdh = NULL;
8231 Elf_Internal_Sym *sym;
8232 long opd_ent_size;
8233 Elf_Internal_Rela *next_rel;
8234 bfd_boolean skip;
8235
8236 r_symndx = ELF64_R_SYM (rel->r_info);
8237 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8238 r_symndx, ibfd))
8239 goto error_ret;
8240
8241 next_rel = rel + 2;
8242 if (next_rel + 1 == relend
8243 || (next_rel + 2 < relend
8244 && ELF64_R_TYPE (next_rel[2].r_info) == R_PPC64_TOC))
8245 ++next_rel;
8246
8247 /* See if the .opd entry is full 24 byte or
8248 16 byte (with fd_aux entry overlapped with next
8249 fd_func). */
8250 opd_ent_size = 24;
8251 if (next_rel == relend)
8252 {
8253 if (sec->size == rel->r_offset + 16)
8254 opd_ent_size = 16;
8255 }
8256 else if (next_rel->r_offset == rel->r_offset + 16)
8257 opd_ent_size = 16;
8258
8259 if (h != NULL
8260 && h->root.root.string[0] == '.')
8261 {
8262 fdh = ((struct ppc_link_hash_entry *) h)->oh;
8263 if (fdh != NULL)
8264 {
8265 fdh = ppc_follow_link (fdh);
8266 if (fdh->elf.root.type != bfd_link_hash_defined
8267 && fdh->elf.root.type != bfd_link_hash_defweak)
8268 fdh = NULL;
8269 }
8270 }
8271
8272 skip = (sym_sec->owner != ibfd
8273 || sym_sec->output_section == bfd_abs_section_ptr);
8274 if (skip)
8275 {
8276 if (fdh != NULL && sym_sec->owner == ibfd)
8277 {
8278 /* Arrange for the function descriptor sym
8279 to be dropped. */
8280 fdh->elf.root.u.def.value = 0;
8281 fdh->elf.root.u.def.section = sym_sec;
8282 }
8283 opd->adjust[OPD_NDX (rel->r_offset)] = -1;
8284
8285 if (NO_OPD_RELOCS || bfd_link_relocatable (info))
8286 rel = next_rel;
8287 else
8288 while (1)
8289 {
8290 if (!dec_dynrel_count (rel->r_info, sec, info,
8291 NULL, h, sym))
8292 goto error_ret;
8293
8294 if (++rel == next_rel)
8295 break;
8296
8297 r_symndx = ELF64_R_SYM (rel->r_info);
8298 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8299 r_symndx, ibfd))
8300 goto error_ret;
8301 }
8302 }
8303 else
8304 {
8305 /* We'll be keeping this opd entry. */
8306 long adjust;
8307
8308 if (fdh != NULL)
8309 {
8310 /* Redefine the function descriptor symbol to
8311 this location in the opd section. It is
8312 necessary to update the value here rather
8313 than using an array of adjustments as we do
8314 for local symbols, because various places
8315 in the generic ELF code use the value
8316 stored in u.def.value. */
8317 fdh->elf.root.u.def.value = wptr - new_contents;
8318 fdh->adjust_done = 1;
8319 }
8320
8321 /* Local syms are a bit tricky. We could
8322 tweak them as they can be cached, but
8323 we'd need to look through the local syms
8324 for the function descriptor sym which we
8325 don't have at the moment. So keep an
8326 array of adjustments. */
8327 adjust = (wptr - new_contents) - (rptr - sec->contents);
8328 opd->adjust[OPD_NDX (rel->r_offset)] = adjust;
8329
8330 if (wptr != rptr)
8331 memcpy (wptr, rptr, opd_ent_size);
8332 wptr += opd_ent_size;
8333 if (add_aux_fields && opd_ent_size == 16)
8334 {
8335 memset (wptr, '\0', 8);
8336 wptr += 8;
8337 }
8338
8339 /* We need to adjust any reloc offsets to point to the
8340 new opd entries. */
8341 for ( ; rel != next_rel; ++rel)
8342 {
8343 rel->r_offset += adjust;
8344 if (write_rel != rel)
8345 memcpy (write_rel, rel, sizeof (*rel));
8346 ++write_rel;
8347 }
8348 }
8349
8350 rptr += opd_ent_size;
8351 }
8352
8353 sec->size = wptr - new_contents;
8354 sec->reloc_count = write_rel - relstart;
8355 if (add_aux_fields)
8356 {
8357 free (sec->contents);
8358 sec->contents = new_contents;
8359 }
8360
8361 /* Fudge the header size too, as this is used later in
8362 elf_bfd_final_link if we are emitting relocs. */
8363 rel_hdr = _bfd_elf_single_rel_hdr (sec);
8364 rel_hdr->sh_size = sec->reloc_count * rel_hdr->sh_entsize;
8365 some_edited = TRUE;
8366 }
8367 else if (elf_section_data (sec)->relocs != relstart)
8368 free (relstart);
8369
8370 if (local_syms != NULL
8371 && symtab_hdr->contents != (unsigned char *) local_syms)
8372 {
8373 if (!info->keep_memory)
8374 free (local_syms);
8375 else
8376 symtab_hdr->contents = (unsigned char *) local_syms;
8377 }
8378 }
8379
8380 if (some_edited)
8381 elf_link_hash_traverse (elf_hash_table (info), adjust_opd_syms, NULL);
8382
8383 /* If we are doing a final link and the last .opd entry is just 16 byte
8384 long, add a 8 byte padding after it. */
8385 if (need_pad != NULL && !bfd_link_relocatable (info))
8386 {
8387 bfd_byte *p;
8388
8389 if ((need_pad->flags & SEC_IN_MEMORY) == 0)
8390 {
8391 BFD_ASSERT (need_pad->size > 0);
8392
8393 p = bfd_malloc (need_pad->size + 8);
8394 if (p == NULL)
8395 return FALSE;
8396
8397 if (! bfd_get_section_contents (need_pad->owner, need_pad,
8398 p, 0, need_pad->size))
8399 return FALSE;
8400
8401 need_pad->contents = p;
8402 need_pad->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
8403 }
8404 else
8405 {
8406 p = bfd_realloc (need_pad->contents, need_pad->size + 8);
8407 if (p == NULL)
8408 return FALSE;
8409
8410 need_pad->contents = p;
8411 }
8412
8413 memset (need_pad->contents + need_pad->size, 0, 8);
8414 need_pad->size += 8;
8415 }
8416
8417 return TRUE;
8418 }
8419
8420 /* Analyze inline PLT call relocations to see whether calls to locally
8421 defined functions can be converted to direct calls. */
8422
8423 bfd_boolean
8424 ppc64_elf_inline_plt (struct bfd_link_info *info)
8425 {
8426 struct ppc_link_hash_table *htab;
8427 bfd *ibfd;
8428 asection *sec;
8429 bfd_vma low_vma, high_vma, limit;
8430
8431 htab = ppc_hash_table (info);
8432 if (htab == NULL)
8433 return FALSE;
8434
8435 /* A bl insn can reach -0x2000000 to 0x1fffffc. The limit is
8436 reduced somewhat to cater for possible stubs that might be added
8437 between the call and its destination. */
8438 if (htab->params->group_size < 0)
8439 {
8440 limit = -htab->params->group_size;
8441 if (limit == 1)
8442 limit = 0x1e00000;
8443 }
8444 else
8445 {
8446 limit = htab->params->group_size;
8447 if (limit == 1)
8448 limit = 0x1c00000;
8449 }
8450
8451 low_vma = -1;
8452 high_vma = 0;
8453 for (sec = info->output_bfd->sections; sec != NULL; sec = sec->next)
8454 if ((sec->flags & (SEC_ALLOC | SEC_CODE)) == (SEC_ALLOC | SEC_CODE))
8455 {
8456 if (low_vma > sec->vma)
8457 low_vma = sec->vma;
8458 if (high_vma < sec->vma + sec->size)
8459 high_vma = sec->vma + sec->size;
8460 }
8461
8462 /* If a "bl" can reach anywhere in local code sections, then we can
8463 convert all inline PLT sequences to direct calls when the symbol
8464 is local. */
8465 if (high_vma - low_vma < limit)
8466 {
8467 htab->can_convert_all_inline_plt = 1;
8468 return TRUE;
8469 }
8470
8471 /* Otherwise, go looking through relocs for cases where a direct
8472 call won't reach. Mark the symbol on any such reloc to disable
8473 the optimization and keep the PLT entry as it seems likely that
8474 this will be better than creating trampolines. Note that this
8475 will disable the optimization for all inline PLT calls to a
8476 particular symbol, not just those that won't reach. The
8477 difficulty in doing a more precise optimization is that the
8478 linker needs to make a decision depending on whether a
8479 particular R_PPC64_PLTCALL insn can be turned into a direct
8480 call, for each of the R_PPC64_PLTSEQ and R_PPC64_PLT16* insns in
8481 the sequence, and there is nothing that ties those relocs
8482 together except their symbol. */
8483
8484 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
8485 {
8486 Elf_Internal_Shdr *symtab_hdr;
8487 Elf_Internal_Sym *local_syms;
8488
8489 if (!is_ppc64_elf (ibfd))
8490 continue;
8491
8492 local_syms = NULL;
8493 symtab_hdr = &elf_symtab_hdr (ibfd);
8494
8495 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8496 if (ppc64_elf_section_data (sec)->has_pltcall
8497 && !bfd_is_abs_section (sec->output_section))
8498 {
8499 Elf_Internal_Rela *relstart, *rel, *relend;
8500
8501 /* Read the relocations. */
8502 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8503 info->keep_memory);
8504 if (relstart == NULL)
8505 return FALSE;
8506
8507 relend = relstart + sec->reloc_count;
8508 for (rel = relstart; rel < relend; )
8509 {
8510 enum elf_ppc64_reloc_type r_type;
8511 unsigned long r_symndx;
8512 asection *sym_sec;
8513 struct elf_link_hash_entry *h;
8514 Elf_Internal_Sym *sym;
8515 unsigned char *tls_maskp;
8516
8517 r_type = ELF64_R_TYPE (rel->r_info);
8518 if (r_type != R_PPC64_PLTCALL)
8519 continue;
8520
8521 r_symndx = ELF64_R_SYM (rel->r_info);
8522 if (!get_sym_h (&h, &sym, &sym_sec, &tls_maskp, &local_syms,
8523 r_symndx, ibfd))
8524 {
8525 if (elf_section_data (sec)->relocs != relstart)
8526 free (relstart);
8527 if (local_syms != NULL
8528 && symtab_hdr->contents != (unsigned char *) local_syms)
8529 free (local_syms);
8530 return FALSE;
8531 }
8532
8533 if (sym_sec != NULL && sym_sec->output_section != NULL)
8534 {
8535 bfd_vma from, to;
8536 if (h != NULL)
8537 to = h->root.u.def.value;
8538 else
8539 to = sym->st_value;
8540 to += (rel->r_addend
8541 + sym_sec->output_offset
8542 + sym_sec->output_section->vma);
8543 from = (rel->r_offset
8544 + sec->output_offset
8545 + sec->output_section->vma);
8546 if (to - from + limit < 2 * limit)
8547 *tls_maskp &= ~PLT_KEEP;
8548 }
8549 }
8550 if (elf_section_data (sec)->relocs != relstart)
8551 free (relstart);
8552 }
8553
8554 if (local_syms != NULL
8555 && symtab_hdr->contents != (unsigned char *) local_syms)
8556 {
8557 if (!info->keep_memory)
8558 free (local_syms);
8559 else
8560 symtab_hdr->contents = (unsigned char *) local_syms;
8561 }
8562 }
8563
8564 return TRUE;
8565 }
8566
8567 /* Set htab->tls_get_addr and call the generic ELF tls_setup function. */
8568
8569 asection *
8570 ppc64_elf_tls_setup (struct bfd_link_info *info)
8571 {
8572 struct ppc_link_hash_table *htab;
8573
8574 htab = ppc_hash_table (info);
8575 if (htab == NULL)
8576 return NULL;
8577
8578 if (abiversion (info->output_bfd) == 1)
8579 htab->opd_abi = 1;
8580
8581 if (htab->params->no_multi_toc)
8582 htab->do_multi_toc = 0;
8583 else if (!htab->do_multi_toc)
8584 htab->params->no_multi_toc = 1;
8585
8586 /* Default to --no-plt-localentry, as this option can cause problems
8587 with symbol interposition. For example, glibc libpthread.so and
8588 libc.so duplicate many pthread symbols, with a fallback
8589 implementation in libc.so. In some cases the fallback does more
8590 work than the pthread implementation. __pthread_condattr_destroy
8591 is one such symbol: the libpthread.so implementation is
8592 localentry:0 while the libc.so implementation is localentry:8.
8593 An app that "cleverly" uses dlopen to only load necessary
8594 libraries at runtime may omit loading libpthread.so when not
8595 running multi-threaded, which then results in the libc.so
8596 fallback symbols being used and ld.so complaining. Now there
8597 are workarounds in ld (see non_zero_localentry) to detect the
8598 pthread situation, but that may not be the only case where
8599 --plt-localentry can cause trouble. */
8600 if (htab->params->plt_localentry0 < 0)
8601 htab->params->plt_localentry0 = 0;
8602 if (htab->params->plt_localentry0
8603 && elf_link_hash_lookup (&htab->elf, "GLIBC_2.26",
8604 FALSE, FALSE, FALSE) == NULL)
8605 _bfd_error_handler
8606 (_("warning: --plt-localentry is especially dangerous without "
8607 "ld.so support to detect ABI violations"));
8608
8609 htab->tls_get_addr = ((struct ppc_link_hash_entry *)
8610 elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
8611 FALSE, FALSE, TRUE));
8612 /* Move dynamic linking info to the function descriptor sym. */
8613 if (htab->tls_get_addr != NULL)
8614 func_desc_adjust (&htab->tls_get_addr->elf, info);
8615 htab->tls_get_addr_fd = ((struct ppc_link_hash_entry *)
8616 elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
8617 FALSE, FALSE, TRUE));
8618 if (htab->params->tls_get_addr_opt)
8619 {
8620 struct elf_link_hash_entry *opt, *opt_fd, *tga, *tga_fd;
8621
8622 opt = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr_opt",
8623 FALSE, FALSE, TRUE);
8624 if (opt != NULL)
8625 func_desc_adjust (opt, info);
8626 opt_fd = elf_link_hash_lookup (&htab->elf, "__tls_get_addr_opt",
8627 FALSE, FALSE, TRUE);
8628 if (opt_fd != NULL
8629 && (opt_fd->root.type == bfd_link_hash_defined
8630 || opt_fd->root.type == bfd_link_hash_defweak))
8631 {
8632 /* If glibc supports an optimized __tls_get_addr call stub,
8633 signalled by the presence of __tls_get_addr_opt, and we'll
8634 be calling __tls_get_addr via a plt call stub, then
8635 make __tls_get_addr point to __tls_get_addr_opt. */
8636 tga_fd = &htab->tls_get_addr_fd->elf;
8637 if (htab->elf.dynamic_sections_created
8638 && tga_fd != NULL
8639 && (tga_fd->type == STT_FUNC
8640 || tga_fd->needs_plt)
8641 && !(SYMBOL_CALLS_LOCAL (info, tga_fd)
8642 || UNDEFWEAK_NO_DYNAMIC_RELOC (info, tga_fd)))
8643 {
8644 struct plt_entry *ent;
8645
8646 for (ent = tga_fd->plt.plist; ent != NULL; ent = ent->next)
8647 if (ent->plt.refcount > 0)
8648 break;
8649 if (ent != NULL)
8650 {
8651 tga_fd->root.type = bfd_link_hash_indirect;
8652 tga_fd->root.u.i.link = &opt_fd->root;
8653 ppc64_elf_copy_indirect_symbol (info, opt_fd, tga_fd);
8654 opt_fd->mark = 1;
8655 if (opt_fd->dynindx != -1)
8656 {
8657 /* Use __tls_get_addr_opt in dynamic relocations. */
8658 opt_fd->dynindx = -1;
8659 _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
8660 opt_fd->dynstr_index);
8661 if (!bfd_elf_link_record_dynamic_symbol (info, opt_fd))
8662 return NULL;
8663 }
8664 htab->tls_get_addr_fd = (struct ppc_link_hash_entry *) opt_fd;
8665 tga = &htab->tls_get_addr->elf;
8666 if (opt != NULL && tga != NULL)
8667 {
8668 tga->root.type = bfd_link_hash_indirect;
8669 tga->root.u.i.link = &opt->root;
8670 ppc64_elf_copy_indirect_symbol (info, opt, tga);
8671 opt->mark = 1;
8672 _bfd_elf_link_hash_hide_symbol (info, opt,
8673 tga->forced_local);
8674 htab->tls_get_addr = (struct ppc_link_hash_entry *) opt;
8675 }
8676 htab->tls_get_addr_fd->oh = htab->tls_get_addr;
8677 htab->tls_get_addr_fd->is_func_descriptor = 1;
8678 if (htab->tls_get_addr != NULL)
8679 {
8680 htab->tls_get_addr->oh = htab->tls_get_addr_fd;
8681 htab->tls_get_addr->is_func = 1;
8682 }
8683 }
8684 }
8685 }
8686 else if (htab->params->tls_get_addr_opt < 0)
8687 htab->params->tls_get_addr_opt = 0;
8688 }
8689 return _bfd_elf_tls_setup (info->output_bfd, info);
8690 }
8691
8692 /* Return TRUE iff REL is a branch reloc with a global symbol matching
8693 HASH1 or HASH2. */
8694
8695 static bfd_boolean
8696 branch_reloc_hash_match (const bfd *ibfd,
8697 const Elf_Internal_Rela *rel,
8698 const struct ppc_link_hash_entry *hash1,
8699 const struct ppc_link_hash_entry *hash2)
8700 {
8701 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
8702 enum elf_ppc64_reloc_type r_type = ELF64_R_TYPE (rel->r_info);
8703 unsigned int r_symndx = ELF64_R_SYM (rel->r_info);
8704
8705 if (r_symndx >= symtab_hdr->sh_info && is_branch_reloc (r_type))
8706 {
8707 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
8708 struct elf_link_hash_entry *h;
8709
8710 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
8711 h = elf_follow_link (h);
8712 if (h == &hash1->elf || h == &hash2->elf)
8713 return TRUE;
8714 }
8715 return FALSE;
8716 }
8717
8718 /* Run through all the TLS relocs looking for optimization
8719 opportunities. The linker has been hacked (see ppc64elf.em) to do
8720 a preliminary section layout so that we know the TLS segment
8721 offsets. We can't optimize earlier because some optimizations need
8722 to know the tp offset, and we need to optimize before allocating
8723 dynamic relocations. */
8724
8725 bfd_boolean
8726 ppc64_elf_tls_optimize (struct bfd_link_info *info)
8727 {
8728 bfd *ibfd;
8729 asection *sec;
8730 struct ppc_link_hash_table *htab;
8731 unsigned char *toc_ref;
8732 int pass;
8733
8734 if (!bfd_link_executable (info))
8735 return TRUE;
8736
8737 htab = ppc_hash_table (info);
8738 if (htab == NULL)
8739 return FALSE;
8740
8741 /* Make two passes over the relocs. On the first pass, mark toc
8742 entries involved with tls relocs, and check that tls relocs
8743 involved in setting up a tls_get_addr call are indeed followed by
8744 such a call. If they are not, we can't do any tls optimization.
8745 On the second pass twiddle tls_mask flags to notify
8746 relocate_section that optimization can be done, and adjust got
8747 and plt refcounts. */
8748 toc_ref = NULL;
8749 for (pass = 0; pass < 2; ++pass)
8750 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
8751 {
8752 Elf_Internal_Sym *locsyms = NULL;
8753 asection *toc = bfd_get_section_by_name (ibfd, ".toc");
8754
8755 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8756 if (sec->has_tls_reloc && !bfd_is_abs_section (sec->output_section))
8757 {
8758 Elf_Internal_Rela *relstart, *rel, *relend;
8759 bfd_boolean found_tls_get_addr_arg = 0;
8760
8761 /* Read the relocations. */
8762 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8763 info->keep_memory);
8764 if (relstart == NULL)
8765 {
8766 free (toc_ref);
8767 return FALSE;
8768 }
8769
8770 relend = relstart + sec->reloc_count;
8771 for (rel = relstart; rel < relend; rel++)
8772 {
8773 enum elf_ppc64_reloc_type r_type;
8774 unsigned long r_symndx;
8775 struct elf_link_hash_entry *h;
8776 Elf_Internal_Sym *sym;
8777 asection *sym_sec;
8778 unsigned char *tls_mask;
8779 unsigned char tls_set, tls_clear, tls_type = 0;
8780 bfd_vma value;
8781 bfd_boolean ok_tprel, is_local;
8782 long toc_ref_index = 0;
8783 int expecting_tls_get_addr = 0;
8784 bfd_boolean ret = FALSE;
8785
8786 r_symndx = ELF64_R_SYM (rel->r_info);
8787 if (!get_sym_h (&h, &sym, &sym_sec, &tls_mask, &locsyms,
8788 r_symndx, ibfd))
8789 {
8790 err_free_rel:
8791 if (elf_section_data (sec)->relocs != relstart)
8792 free (relstart);
8793 if (toc_ref != NULL)
8794 free (toc_ref);
8795 if (locsyms != NULL
8796 && (elf_symtab_hdr (ibfd).contents
8797 != (unsigned char *) locsyms))
8798 free (locsyms);
8799 return ret;
8800 }
8801
8802 if (h != NULL)
8803 {
8804 if (h->root.type == bfd_link_hash_defined
8805 || h->root.type == bfd_link_hash_defweak)
8806 value = h->root.u.def.value;
8807 else if (h->root.type == bfd_link_hash_undefweak)
8808 value = 0;
8809 else
8810 {
8811 found_tls_get_addr_arg = 0;
8812 continue;
8813 }
8814 }
8815 else
8816 /* Symbols referenced by TLS relocs must be of type
8817 STT_TLS. So no need for .opd local sym adjust. */
8818 value = sym->st_value;
8819
8820 ok_tprel = FALSE;
8821 is_local = FALSE;
8822 if (h == NULL
8823 || !h->def_dynamic)
8824 {
8825 is_local = TRUE;
8826 if (h != NULL
8827 && h->root.type == bfd_link_hash_undefweak)
8828 ok_tprel = TRUE;
8829 else if (sym_sec != NULL
8830 && sym_sec->output_section != NULL)
8831 {
8832 value += sym_sec->output_offset;
8833 value += sym_sec->output_section->vma;
8834 value -= htab->elf.tls_sec->vma;
8835 ok_tprel = (value + TP_OFFSET + ((bfd_vma) 1 << 31)
8836 < (bfd_vma) 1 << 32);
8837 }
8838 }
8839
8840 r_type = ELF64_R_TYPE (rel->r_info);
8841 /* If this section has old-style __tls_get_addr calls
8842 without marker relocs, then check that each
8843 __tls_get_addr call reloc is preceded by a reloc
8844 that conceivably belongs to the __tls_get_addr arg
8845 setup insn. If we don't find matching arg setup
8846 relocs, don't do any tls optimization. */
8847 if (pass == 0
8848 && sec->has_tls_get_addr_call
8849 && h != NULL
8850 && (h == &htab->tls_get_addr->elf
8851 || h == &htab->tls_get_addr_fd->elf)
8852 && !found_tls_get_addr_arg
8853 && is_branch_reloc (r_type))
8854 {
8855 info->callbacks->minfo (_("%H __tls_get_addr lost arg, "
8856 "TLS optimization disabled\n"),
8857 ibfd, sec, rel->r_offset);
8858 ret = TRUE;
8859 goto err_free_rel;
8860 }
8861
8862 found_tls_get_addr_arg = 0;
8863 switch (r_type)
8864 {
8865 case R_PPC64_GOT_TLSLD16:
8866 case R_PPC64_GOT_TLSLD16_LO:
8867 expecting_tls_get_addr = 1;
8868 found_tls_get_addr_arg = 1;
8869 /* Fall through. */
8870
8871 case R_PPC64_GOT_TLSLD16_HI:
8872 case R_PPC64_GOT_TLSLD16_HA:
8873 /* These relocs should never be against a symbol
8874 defined in a shared lib. Leave them alone if
8875 that turns out to be the case. */
8876 if (!is_local)
8877 continue;
8878
8879 /* LD -> LE */
8880 tls_set = 0;
8881 tls_clear = TLS_LD;
8882 tls_type = TLS_TLS | TLS_LD;
8883 break;
8884
8885 case R_PPC64_GOT_TLSGD16:
8886 case R_PPC64_GOT_TLSGD16_LO:
8887 expecting_tls_get_addr = 1;
8888 found_tls_get_addr_arg = 1;
8889 /* Fall through. */
8890
8891 case R_PPC64_GOT_TLSGD16_HI:
8892 case R_PPC64_GOT_TLSGD16_HA:
8893 if (ok_tprel)
8894 /* GD -> LE */
8895 tls_set = 0;
8896 else
8897 /* GD -> IE */
8898 tls_set = TLS_TLS | TLS_TPRELGD;
8899 tls_clear = TLS_GD;
8900 tls_type = TLS_TLS | TLS_GD;
8901 break;
8902
8903 case R_PPC64_GOT_TPREL16_DS:
8904 case R_PPC64_GOT_TPREL16_LO_DS:
8905 case R_PPC64_GOT_TPREL16_HI:
8906 case R_PPC64_GOT_TPREL16_HA:
8907 if (ok_tprel)
8908 {
8909 /* IE -> LE */
8910 tls_set = 0;
8911 tls_clear = TLS_TPREL;
8912 tls_type = TLS_TLS | TLS_TPREL;
8913 break;
8914 }
8915 continue;
8916
8917 case R_PPC64_TLSGD:
8918 case R_PPC64_TLSLD:
8919 if (rel + 1 < relend
8920 && is_plt_seq_reloc (ELF64_R_TYPE (rel[1].r_info)))
8921 {
8922 if (pass != 0
8923 && ELF64_R_TYPE (rel[1].r_info) != R_PPC64_PLTSEQ)
8924 {
8925 r_symndx = ELF64_R_SYM (rel[1].r_info);
8926 if (!get_sym_h (&h, NULL, NULL, NULL, &locsyms,
8927 r_symndx, ibfd))
8928 goto err_free_rel;
8929 if (h != NULL)
8930 {
8931 struct plt_entry *ent = NULL;
8932
8933 for (ent = h->plt.plist;
8934 ent != NULL;
8935 ent = ent->next)
8936 if (ent->addend == rel[1].r_addend)
8937 break;
8938
8939 if (ent != NULL
8940 && ent->plt.refcount > 0)
8941 ent->plt.refcount -= 1;
8942 }
8943 }
8944 continue;
8945 }
8946 found_tls_get_addr_arg = 1;
8947 /* Fall through. */
8948
8949 case R_PPC64_TLS:
8950 case R_PPC64_TOC16:
8951 case R_PPC64_TOC16_LO:
8952 if (sym_sec == NULL || sym_sec != toc)
8953 continue;
8954
8955 /* Mark this toc entry as referenced by a TLS
8956 code sequence. We can do that now in the
8957 case of R_PPC64_TLS, and after checking for
8958 tls_get_addr for the TOC16 relocs. */
8959 if (toc_ref == NULL)
8960 toc_ref = bfd_zmalloc (toc->output_section->rawsize / 8);
8961 if (toc_ref == NULL)
8962 goto err_free_rel;
8963
8964 if (h != NULL)
8965 value = h->root.u.def.value;
8966 else
8967 value = sym->st_value;
8968 value += rel->r_addend;
8969 if (value % 8 != 0)
8970 continue;
8971 BFD_ASSERT (value < toc->size
8972 && toc->output_offset % 8 == 0);
8973 toc_ref_index = (value + toc->output_offset) / 8;
8974 if (r_type == R_PPC64_TLS
8975 || r_type == R_PPC64_TLSGD
8976 || r_type == R_PPC64_TLSLD)
8977 {
8978 toc_ref[toc_ref_index] = 1;
8979 continue;
8980 }
8981
8982 if (pass != 0 && toc_ref[toc_ref_index] == 0)
8983 continue;
8984
8985 tls_set = 0;
8986 tls_clear = 0;
8987 expecting_tls_get_addr = 2;
8988 break;
8989
8990 case R_PPC64_TPREL64:
8991 if (pass == 0
8992 || sec != toc
8993 || toc_ref == NULL
8994 || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
8995 continue;
8996 if (ok_tprel)
8997 {
8998 /* IE -> LE */
8999 tls_set = TLS_EXPLICIT;
9000 tls_clear = TLS_TPREL;
9001 break;
9002 }
9003 continue;
9004
9005 case R_PPC64_DTPMOD64:
9006 if (pass == 0
9007 || sec != toc
9008 || toc_ref == NULL
9009 || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
9010 continue;
9011 if (rel + 1 < relend
9012 && (rel[1].r_info
9013 == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64))
9014 && rel[1].r_offset == rel->r_offset + 8)
9015 {
9016 if (ok_tprel)
9017 /* GD -> LE */
9018 tls_set = TLS_EXPLICIT | TLS_GD;
9019 else
9020 /* GD -> IE */
9021 tls_set = TLS_EXPLICIT | TLS_GD | TLS_TPRELGD;
9022 tls_clear = TLS_GD;
9023 }
9024 else
9025 {
9026 if (!is_local)
9027 continue;
9028
9029 /* LD -> LE */
9030 tls_set = TLS_EXPLICIT;
9031 tls_clear = TLS_LD;
9032 }
9033 break;
9034
9035 default:
9036 continue;
9037 }
9038
9039 if (pass == 0)
9040 {
9041 if (!expecting_tls_get_addr
9042 || !sec->has_tls_get_addr_call)
9043 continue;
9044
9045 if (rel + 1 < relend
9046 && branch_reloc_hash_match (ibfd, rel + 1,
9047 htab->tls_get_addr,
9048 htab->tls_get_addr_fd))
9049 {
9050 if (expecting_tls_get_addr == 2)
9051 {
9052 /* Check for toc tls entries. */
9053 unsigned char *toc_tls;
9054 int retval;
9055
9056 retval = get_tls_mask (&toc_tls, NULL, NULL,
9057 &locsyms,
9058 rel, ibfd);
9059 if (retval == 0)
9060 goto err_free_rel;
9061 if (toc_tls != NULL)
9062 {
9063 if ((*toc_tls & TLS_TLS) != 0
9064 && ((*toc_tls & (TLS_GD | TLS_LD)) != 0))
9065 found_tls_get_addr_arg = 1;
9066 if (retval > 1)
9067 toc_ref[toc_ref_index] = 1;
9068 }
9069 }
9070 continue;
9071 }
9072
9073 /* Uh oh, we didn't find the expected call. We
9074 could just mark this symbol to exclude it
9075 from tls optimization but it's safer to skip
9076 the entire optimization. */
9077 /* xgettext:c-format */
9078 info->callbacks->minfo (_("%H arg lost __tls_get_addr, "
9079 "TLS optimization disabled\n"),
9080 ibfd, sec, rel->r_offset);
9081 ret = TRUE;
9082 goto err_free_rel;
9083 }
9084
9085 /* If we don't have old-style __tls_get_addr calls
9086 without TLSGD/TLSLD marker relocs, and we haven't
9087 found a new-style __tls_get_addr call with a
9088 marker for this symbol, then we either have a
9089 broken object file or an -mlongcall style
9090 indirect call to __tls_get_addr without a marker.
9091 Disable optimization in this case. */
9092 if ((tls_clear & (TLS_GD | TLS_LD)) != 0
9093 && (tls_set & TLS_EXPLICIT) == 0
9094 && !sec->has_tls_get_addr_call
9095 && ((*tls_mask & (TLS_TLS | TLS_MARK))
9096 != (TLS_TLS | TLS_MARK)))
9097 continue;
9098
9099 if (expecting_tls_get_addr)
9100 {
9101 struct plt_entry *ent = NULL;
9102
9103 if (htab->tls_get_addr != NULL)
9104 for (ent = htab->tls_get_addr->elf.plt.plist;
9105 ent != NULL;
9106 ent = ent->next)
9107 if (ent->addend == 0)
9108 break;
9109
9110 if (ent == NULL && htab->tls_get_addr_fd != NULL)
9111 for (ent = htab->tls_get_addr_fd->elf.plt.plist;
9112 ent != NULL;
9113 ent = ent->next)
9114 if (ent->addend == 0)
9115 break;
9116
9117 if (ent != NULL
9118 && ent->plt.refcount > 0)
9119 ent->plt.refcount -= 1;
9120 }
9121
9122 if (tls_clear == 0)
9123 continue;
9124
9125 if ((tls_set & TLS_EXPLICIT) == 0)
9126 {
9127 struct got_entry *ent;
9128
9129 /* Adjust got entry for this reloc. */
9130 if (h != NULL)
9131 ent = h->got.glist;
9132 else
9133 ent = elf_local_got_ents (ibfd)[r_symndx];
9134
9135 for (; ent != NULL; ent = ent->next)
9136 if (ent->addend == rel->r_addend
9137 && ent->owner == ibfd
9138 && ent->tls_type == tls_type)
9139 break;
9140 if (ent == NULL)
9141 abort ();
9142
9143 if (tls_set == 0)
9144 {
9145 /* We managed to get rid of a got entry. */
9146 if (ent->got.refcount > 0)
9147 ent->got.refcount -= 1;
9148 }
9149 }
9150 else
9151 {
9152 /* If we got rid of a DTPMOD/DTPREL reloc pair then
9153 we'll lose one or two dyn relocs. */
9154 if (!dec_dynrel_count (rel->r_info, sec, info,
9155 NULL, h, sym))
9156 return FALSE;
9157
9158 if (tls_set == (TLS_EXPLICIT | TLS_GD))
9159 {
9160 if (!dec_dynrel_count ((rel + 1)->r_info, sec, info,
9161 NULL, h, sym))
9162 return FALSE;
9163 }
9164 }
9165
9166 *tls_mask |= tls_set;
9167 *tls_mask &= ~tls_clear;
9168 }
9169
9170 if (elf_section_data (sec)->relocs != relstart)
9171 free (relstart);
9172 }
9173
9174 if (locsyms != NULL
9175 && (elf_symtab_hdr (ibfd).contents != (unsigned char *) locsyms))
9176 {
9177 if (!info->keep_memory)
9178 free (locsyms);
9179 else
9180 elf_symtab_hdr (ibfd).contents = (unsigned char *) locsyms;
9181 }
9182 }
9183
9184 if (toc_ref != NULL)
9185 free (toc_ref);
9186 htab->do_tls_opt = 1;
9187 return TRUE;
9188 }
9189
9190 /* Called via elf_link_hash_traverse from ppc64_elf_edit_toc to adjust
9191 the values of any global symbols in a toc section that has been
9192 edited. Globals in toc sections should be a rarity, so this function
9193 sets a flag if any are found in toc sections other than the one just
9194 edited, so that further hash table traversals can be avoided. */
9195
9196 struct adjust_toc_info
9197 {
9198 asection *toc;
9199 unsigned long *skip;
9200 bfd_boolean global_toc_syms;
9201 };
9202
9203 enum toc_skip_enum { ref_from_discarded = 1, can_optimize = 2 };
9204
9205 static bfd_boolean
9206 adjust_toc_syms (struct elf_link_hash_entry *h, void *inf)
9207 {
9208 struct ppc_link_hash_entry *eh;
9209 struct adjust_toc_info *toc_inf = (struct adjust_toc_info *) inf;
9210 unsigned long i;
9211
9212 if (h->root.type != bfd_link_hash_defined
9213 && h->root.type != bfd_link_hash_defweak)
9214 return TRUE;
9215
9216 eh = (struct ppc_link_hash_entry *) h;
9217 if (eh->adjust_done)
9218 return TRUE;
9219
9220 if (eh->elf.root.u.def.section == toc_inf->toc)
9221 {
9222 if (eh->elf.root.u.def.value > toc_inf->toc->rawsize)
9223 i = toc_inf->toc->rawsize >> 3;
9224 else
9225 i = eh->elf.root.u.def.value >> 3;
9226
9227 if ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0)
9228 {
9229 _bfd_error_handler
9230 (_("%s defined on removed toc entry"), eh->elf.root.root.string);
9231 do
9232 ++i;
9233 while ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0);
9234 eh->elf.root.u.def.value = (bfd_vma) i << 3;
9235 }
9236
9237 eh->elf.root.u.def.value -= toc_inf->skip[i];
9238 eh->adjust_done = 1;
9239 }
9240 else if (strcmp (eh->elf.root.u.def.section->name, ".toc") == 0)
9241 toc_inf->global_toc_syms = TRUE;
9242
9243 return TRUE;
9244 }
9245
9246 /* Return TRUE iff INSN with a relocation of R_TYPE is one we expect
9247 on a _LO variety toc/got reloc. */
9248
9249 static bfd_boolean
9250 ok_lo_toc_insn (unsigned int insn, enum elf_ppc64_reloc_type r_type)
9251 {
9252 return ((insn & (0x3f << 26)) == 12u << 26 /* addic */
9253 || (insn & (0x3f << 26)) == 14u << 26 /* addi */
9254 || (insn & (0x3f << 26)) == 32u << 26 /* lwz */
9255 || (insn & (0x3f << 26)) == 34u << 26 /* lbz */
9256 || (insn & (0x3f << 26)) == 36u << 26 /* stw */
9257 || (insn & (0x3f << 26)) == 38u << 26 /* stb */
9258 || (insn & (0x3f << 26)) == 40u << 26 /* lhz */
9259 || (insn & (0x3f << 26)) == 42u << 26 /* lha */
9260 || (insn & (0x3f << 26)) == 44u << 26 /* sth */
9261 || (insn & (0x3f << 26)) == 46u << 26 /* lmw */
9262 || (insn & (0x3f << 26)) == 47u << 26 /* stmw */
9263 || (insn & (0x3f << 26)) == 48u << 26 /* lfs */
9264 || (insn & (0x3f << 26)) == 50u << 26 /* lfd */
9265 || (insn & (0x3f << 26)) == 52u << 26 /* stfs */
9266 || (insn & (0x3f << 26)) == 54u << 26 /* stfd */
9267 || (insn & (0x3f << 26)) == 56u << 26 /* lq,lfq */
9268 || ((insn & (0x3f << 26)) == 57u << 26 /* lxsd,lxssp,lfdp */
9269 /* Exclude lfqu by testing reloc. If relocs are ever
9270 defined for the reduced D field in psq_lu then those
9271 will need testing too. */
9272 && r_type != R_PPC64_TOC16_LO && r_type != R_PPC64_GOT16_LO)
9273 || ((insn & (0x3f << 26)) == 58u << 26 /* ld,lwa */
9274 && (insn & 1) == 0)
9275 || (insn & (0x3f << 26)) == 60u << 26 /* stfq */
9276 || ((insn & (0x3f << 26)) == 61u << 26 /* lxv,stx{v,sd,ssp},stfdp */
9277 /* Exclude stfqu. psq_stu as above for psq_lu. */
9278 && r_type != R_PPC64_TOC16_LO && r_type != R_PPC64_GOT16_LO)
9279 || ((insn & (0x3f << 26)) == 62u << 26 /* std,stq */
9280 && (insn & 1) == 0));
9281 }
9282
9283 /* Examine all relocs referencing .toc sections in order to remove
9284 unused .toc entries. */
9285
9286 bfd_boolean
9287 ppc64_elf_edit_toc (struct bfd_link_info *info)
9288 {
9289 bfd *ibfd;
9290 struct adjust_toc_info toc_inf;
9291 struct ppc_link_hash_table *htab = ppc_hash_table (info);
9292
9293 htab->do_toc_opt = 1;
9294 toc_inf.global_toc_syms = TRUE;
9295 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
9296 {
9297 asection *toc, *sec;
9298 Elf_Internal_Shdr *symtab_hdr;
9299 Elf_Internal_Sym *local_syms;
9300 Elf_Internal_Rela *relstart, *rel, *toc_relocs;
9301 unsigned long *skip, *drop;
9302 unsigned char *used;
9303 unsigned char *keep, last, some_unused;
9304
9305 if (!is_ppc64_elf (ibfd))
9306 continue;
9307
9308 toc = bfd_get_section_by_name (ibfd, ".toc");
9309 if (toc == NULL
9310 || toc->size == 0
9311 || toc->sec_info_type == SEC_INFO_TYPE_JUST_SYMS
9312 || discarded_section (toc))
9313 continue;
9314
9315 toc_relocs = NULL;
9316 local_syms = NULL;
9317 symtab_hdr = &elf_symtab_hdr (ibfd);
9318
9319 /* Look at sections dropped from the final link. */
9320 skip = NULL;
9321 relstart = NULL;
9322 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
9323 {
9324 if (sec->reloc_count == 0
9325 || !discarded_section (sec)
9326 || get_opd_info (sec)
9327 || (sec->flags & SEC_ALLOC) == 0
9328 || (sec->flags & SEC_DEBUGGING) != 0)
9329 continue;
9330
9331 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL, FALSE);
9332 if (relstart == NULL)
9333 goto error_ret;
9334
9335 /* Run through the relocs to see which toc entries might be
9336 unused. */
9337 for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9338 {
9339 enum elf_ppc64_reloc_type r_type;
9340 unsigned long r_symndx;
9341 asection *sym_sec;
9342 struct elf_link_hash_entry *h;
9343 Elf_Internal_Sym *sym;
9344 bfd_vma val;
9345
9346 r_type = ELF64_R_TYPE (rel->r_info);
9347 switch (r_type)
9348 {
9349 default:
9350 continue;
9351
9352 case R_PPC64_TOC16:
9353 case R_PPC64_TOC16_LO:
9354 case R_PPC64_TOC16_HI:
9355 case R_PPC64_TOC16_HA:
9356 case R_PPC64_TOC16_DS:
9357 case R_PPC64_TOC16_LO_DS:
9358 break;
9359 }
9360
9361 r_symndx = ELF64_R_SYM (rel->r_info);
9362 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9363 r_symndx, ibfd))
9364 goto error_ret;
9365
9366 if (sym_sec != toc)
9367 continue;
9368
9369 if (h != NULL)
9370 val = h->root.u.def.value;
9371 else
9372 val = sym->st_value;
9373 val += rel->r_addend;
9374
9375 if (val >= toc->size)
9376 continue;
9377
9378 /* Anything in the toc ought to be aligned to 8 bytes.
9379 If not, don't mark as unused. */
9380 if (val & 7)
9381 continue;
9382
9383 if (skip == NULL)
9384 {
9385 skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
9386 if (skip == NULL)
9387 goto error_ret;
9388 }
9389
9390 skip[val >> 3] = ref_from_discarded;
9391 }
9392
9393 if (elf_section_data (sec)->relocs != relstart)
9394 free (relstart);
9395 }
9396
9397 /* For largetoc loads of address constants, we can convert
9398 . addis rx,2,addr@got@ha
9399 . ld ry,addr@got@l(rx)
9400 to
9401 . addis rx,2,addr@toc@ha
9402 . addi ry,rx,addr@toc@l
9403 when addr is within 2G of the toc pointer. This then means
9404 that the word storing "addr" in the toc is no longer needed. */
9405
9406 if (!ppc64_elf_tdata (ibfd)->has_small_toc_reloc
9407 && toc->output_section->rawsize < (bfd_vma) 1 << 31
9408 && toc->reloc_count != 0)
9409 {
9410 /* Read toc relocs. */
9411 toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
9412 info->keep_memory);
9413 if (toc_relocs == NULL)
9414 goto error_ret;
9415
9416 for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
9417 {
9418 enum elf_ppc64_reloc_type r_type;
9419 unsigned long r_symndx;
9420 asection *sym_sec;
9421 struct elf_link_hash_entry *h;
9422 Elf_Internal_Sym *sym;
9423 bfd_vma val, addr;
9424
9425 r_type = ELF64_R_TYPE (rel->r_info);
9426 if (r_type != R_PPC64_ADDR64)
9427 continue;
9428
9429 r_symndx = ELF64_R_SYM (rel->r_info);
9430 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9431 r_symndx, ibfd))
9432 goto error_ret;
9433
9434 if (sym_sec == NULL
9435 || sym_sec->output_section == NULL
9436 || discarded_section (sym_sec))
9437 continue;
9438
9439 if (!SYMBOL_REFERENCES_LOCAL (info, h))
9440 continue;
9441
9442 if (h != NULL)
9443 {
9444 if (h->type == STT_GNU_IFUNC)
9445 continue;
9446 val = h->root.u.def.value;
9447 }
9448 else
9449 {
9450 if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
9451 continue;
9452 val = sym->st_value;
9453 }
9454 val += rel->r_addend;
9455 val += sym_sec->output_section->vma + sym_sec->output_offset;
9456
9457 /* We don't yet know the exact toc pointer value, but we
9458 know it will be somewhere in the toc section. Don't
9459 optimize if the difference from any possible toc
9460 pointer is outside [ff..f80008000, 7fff7fff]. */
9461 addr = toc->output_section->vma + TOC_BASE_OFF;
9462 if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
9463 continue;
9464
9465 addr = toc->output_section->vma + toc->output_section->rawsize;
9466 if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
9467 continue;
9468
9469 if (skip == NULL)
9470 {
9471 skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
9472 if (skip == NULL)
9473 goto error_ret;
9474 }
9475
9476 skip[rel->r_offset >> 3]
9477 |= can_optimize | ((rel - toc_relocs) << 2);
9478 }
9479 }
9480
9481 if (skip == NULL)
9482 continue;
9483
9484 used = bfd_zmalloc (sizeof (*used) * (toc->size + 7) / 8);
9485 if (used == NULL)
9486 {
9487 error_ret:
9488 if (local_syms != NULL
9489 && symtab_hdr->contents != (unsigned char *) local_syms)
9490 free (local_syms);
9491 if (sec != NULL
9492 && relstart != NULL
9493 && elf_section_data (sec)->relocs != relstart)
9494 free (relstart);
9495 if (toc_relocs != NULL
9496 && elf_section_data (toc)->relocs != toc_relocs)
9497 free (toc_relocs);
9498 if (skip != NULL)
9499 free (skip);
9500 return FALSE;
9501 }
9502
9503 /* Now check all kept sections that might reference the toc.
9504 Check the toc itself last. */
9505 for (sec = (ibfd->sections == toc && toc->next ? toc->next
9506 : ibfd->sections);
9507 sec != NULL;
9508 sec = (sec == toc ? NULL
9509 : sec->next == NULL ? toc
9510 : sec->next == toc && toc->next ? toc->next
9511 : sec->next))
9512 {
9513 int repeat;
9514
9515 if (sec->reloc_count == 0
9516 || discarded_section (sec)
9517 || get_opd_info (sec)
9518 || (sec->flags & SEC_ALLOC) == 0
9519 || (sec->flags & SEC_DEBUGGING) != 0)
9520 continue;
9521
9522 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
9523 info->keep_memory);
9524 if (relstart == NULL)
9525 {
9526 free (used);
9527 goto error_ret;
9528 }
9529
9530 /* Mark toc entries referenced as used. */
9531 do
9532 {
9533 repeat = 0;
9534 for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9535 {
9536 enum elf_ppc64_reloc_type r_type;
9537 unsigned long r_symndx;
9538 asection *sym_sec;
9539 struct elf_link_hash_entry *h;
9540 Elf_Internal_Sym *sym;
9541 bfd_vma val;
9542 enum {no_check, check_lo, check_ha} insn_check;
9543
9544 r_type = ELF64_R_TYPE (rel->r_info);
9545 switch (r_type)
9546 {
9547 default:
9548 insn_check = no_check;
9549 break;
9550
9551 case R_PPC64_GOT_TLSLD16_HA:
9552 case R_PPC64_GOT_TLSGD16_HA:
9553 case R_PPC64_GOT_TPREL16_HA:
9554 case R_PPC64_GOT_DTPREL16_HA:
9555 case R_PPC64_GOT16_HA:
9556 case R_PPC64_TOC16_HA:
9557 insn_check = check_ha;
9558 break;
9559
9560 case R_PPC64_GOT_TLSLD16_LO:
9561 case R_PPC64_GOT_TLSGD16_LO:
9562 case R_PPC64_GOT_TPREL16_LO_DS:
9563 case R_PPC64_GOT_DTPREL16_LO_DS:
9564 case R_PPC64_GOT16_LO:
9565 case R_PPC64_GOT16_LO_DS:
9566 case R_PPC64_TOC16_LO:
9567 case R_PPC64_TOC16_LO_DS:
9568 insn_check = check_lo;
9569 break;
9570 }
9571
9572 if (insn_check != no_check)
9573 {
9574 bfd_vma off = rel->r_offset & ~3;
9575 unsigned char buf[4];
9576 unsigned int insn;
9577
9578 if (!bfd_get_section_contents (ibfd, sec, buf, off, 4))
9579 {
9580 free (used);
9581 goto error_ret;
9582 }
9583 insn = bfd_get_32 (ibfd, buf);
9584 if (insn_check == check_lo
9585 ? !ok_lo_toc_insn (insn, r_type)
9586 : ((insn & ((0x3f << 26) | 0x1f << 16))
9587 != ((15u << 26) | (2 << 16)) /* addis rt,2,imm */))
9588 {
9589 char str[12];
9590
9591 ppc64_elf_tdata (ibfd)->unexpected_toc_insn = 1;
9592 sprintf (str, "%#08x", insn);
9593 info->callbacks->einfo
9594 /* xgettext:c-format */
9595 (_("%H: toc optimization is not supported for"
9596 " %s instruction\n"),
9597 ibfd, sec, rel->r_offset & ~3, str);
9598 }
9599 }
9600
9601 switch (r_type)
9602 {
9603 case R_PPC64_TOC16:
9604 case R_PPC64_TOC16_LO:
9605 case R_PPC64_TOC16_HI:
9606 case R_PPC64_TOC16_HA:
9607 case R_PPC64_TOC16_DS:
9608 case R_PPC64_TOC16_LO_DS:
9609 /* In case we're taking addresses of toc entries. */
9610 case R_PPC64_ADDR64:
9611 break;
9612
9613 default:
9614 continue;
9615 }
9616
9617 r_symndx = ELF64_R_SYM (rel->r_info);
9618 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9619 r_symndx, ibfd))
9620 {
9621 free (used);
9622 goto error_ret;
9623 }
9624
9625 if (sym_sec != toc)
9626 continue;
9627
9628 if (h != NULL)
9629 val = h->root.u.def.value;
9630 else
9631 val = sym->st_value;
9632 val += rel->r_addend;
9633
9634 if (val >= toc->size)
9635 continue;
9636
9637 if ((skip[val >> 3] & can_optimize) != 0)
9638 {
9639 bfd_vma off;
9640 unsigned char opc;
9641
9642 switch (r_type)
9643 {
9644 case R_PPC64_TOC16_HA:
9645 break;
9646
9647 case R_PPC64_TOC16_LO_DS:
9648 off = rel->r_offset;
9649 off += (bfd_big_endian (ibfd) ? -2 : 3);
9650 if (!bfd_get_section_contents (ibfd, sec, &opc,
9651 off, 1))
9652 {
9653 free (used);
9654 goto error_ret;
9655 }
9656 if ((opc & (0x3f << 2)) == (58u << 2))
9657 break;
9658 /* Fall through. */
9659
9660 default:
9661 /* Wrong sort of reloc, or not a ld. We may
9662 as well clear ref_from_discarded too. */
9663 skip[val >> 3] = 0;
9664 }
9665 }
9666
9667 if (sec != toc)
9668 used[val >> 3] = 1;
9669 /* For the toc section, we only mark as used if this
9670 entry itself isn't unused. */
9671 else if ((used[rel->r_offset >> 3]
9672 || !(skip[rel->r_offset >> 3] & ref_from_discarded))
9673 && !used[val >> 3])
9674 {
9675 /* Do all the relocs again, to catch reference
9676 chains. */
9677 repeat = 1;
9678 used[val >> 3] = 1;
9679 }
9680 }
9681 }
9682 while (repeat);
9683
9684 if (elf_section_data (sec)->relocs != relstart)
9685 free (relstart);
9686 }
9687
9688 /* Merge the used and skip arrays. Assume that TOC
9689 doublewords not appearing as either used or unused belong
9690 to an entry more than one doubleword in size. */
9691 for (drop = skip, keep = used, last = 0, some_unused = 0;
9692 drop < skip + (toc->size + 7) / 8;
9693 ++drop, ++keep)
9694 {
9695 if (*keep)
9696 {
9697 *drop &= ~ref_from_discarded;
9698 if ((*drop & can_optimize) != 0)
9699 some_unused = 1;
9700 last = 0;
9701 }
9702 else if ((*drop & ref_from_discarded) != 0)
9703 {
9704 some_unused = 1;
9705 last = ref_from_discarded;
9706 }
9707 else
9708 *drop = last;
9709 }
9710
9711 free (used);
9712
9713 if (some_unused)
9714 {
9715 bfd_byte *contents, *src;
9716 unsigned long off;
9717 Elf_Internal_Sym *sym;
9718 bfd_boolean local_toc_syms = FALSE;
9719
9720 /* Shuffle the toc contents, and at the same time convert the
9721 skip array from booleans into offsets. */
9722 if (!bfd_malloc_and_get_section (ibfd, toc, &contents))
9723 goto error_ret;
9724
9725 elf_section_data (toc)->this_hdr.contents = contents;
9726
9727 for (src = contents, off = 0, drop = skip;
9728 src < contents + toc->size;
9729 src += 8, ++drop)
9730 {
9731 if ((*drop & (can_optimize | ref_from_discarded)) != 0)
9732 off += 8;
9733 else if (off != 0)
9734 {
9735 *drop = off;
9736 memcpy (src - off, src, 8);
9737 }
9738 }
9739 *drop = off;
9740 toc->rawsize = toc->size;
9741 toc->size = src - contents - off;
9742
9743 /* Adjust addends for relocs against the toc section sym,
9744 and optimize any accesses we can. */
9745 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
9746 {
9747 if (sec->reloc_count == 0
9748 || discarded_section (sec))
9749 continue;
9750
9751 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
9752 info->keep_memory);
9753 if (relstart == NULL)
9754 goto error_ret;
9755
9756 for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9757 {
9758 enum elf_ppc64_reloc_type r_type;
9759 unsigned long r_symndx;
9760 asection *sym_sec;
9761 struct elf_link_hash_entry *h;
9762 bfd_vma val;
9763
9764 r_type = ELF64_R_TYPE (rel->r_info);
9765 switch (r_type)
9766 {
9767 default:
9768 continue;
9769
9770 case R_PPC64_TOC16:
9771 case R_PPC64_TOC16_LO:
9772 case R_PPC64_TOC16_HI:
9773 case R_PPC64_TOC16_HA:
9774 case R_PPC64_TOC16_DS:
9775 case R_PPC64_TOC16_LO_DS:
9776 case R_PPC64_ADDR64:
9777 break;
9778 }
9779
9780 r_symndx = ELF64_R_SYM (rel->r_info);
9781 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9782 r_symndx, ibfd))
9783 goto error_ret;
9784
9785 if (sym_sec != toc)
9786 continue;
9787
9788 if (h != NULL)
9789 val = h->root.u.def.value;
9790 else
9791 {
9792 val = sym->st_value;
9793 if (val != 0)
9794 local_toc_syms = TRUE;
9795 }
9796
9797 val += rel->r_addend;
9798
9799 if (val > toc->rawsize)
9800 val = toc->rawsize;
9801 else if ((skip[val >> 3] & ref_from_discarded) != 0)
9802 continue;
9803 else if ((skip[val >> 3] & can_optimize) != 0)
9804 {
9805 Elf_Internal_Rela *tocrel
9806 = toc_relocs + (skip[val >> 3] >> 2);
9807 unsigned long tsym = ELF64_R_SYM (tocrel->r_info);
9808
9809 switch (r_type)
9810 {
9811 case R_PPC64_TOC16_HA:
9812 rel->r_info = ELF64_R_INFO (tsym, R_PPC64_TOC16_HA);
9813 break;
9814
9815 case R_PPC64_TOC16_LO_DS:
9816 rel->r_info = ELF64_R_INFO (tsym, R_PPC64_LO_DS_OPT);
9817 break;
9818
9819 default:
9820 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
9821 ppc_howto_init ();
9822 info->callbacks->einfo
9823 /* xgettext:c-format */
9824 (_("%H: %s references "
9825 "optimized away TOC entry\n"),
9826 ibfd, sec, rel->r_offset,
9827 ppc64_elf_howto_table[r_type]->name);
9828 bfd_set_error (bfd_error_bad_value);
9829 goto error_ret;
9830 }
9831 rel->r_addend = tocrel->r_addend;
9832 elf_section_data (sec)->relocs = relstart;
9833 continue;
9834 }
9835
9836 if (h != NULL || sym->st_value != 0)
9837 continue;
9838
9839 rel->r_addend -= skip[val >> 3];
9840 elf_section_data (sec)->relocs = relstart;
9841 }
9842
9843 if (elf_section_data (sec)->relocs != relstart)
9844 free (relstart);
9845 }
9846
9847 /* We shouldn't have local or global symbols defined in the TOC,
9848 but handle them anyway. */
9849 if (local_syms != NULL)
9850 for (sym = local_syms;
9851 sym < local_syms + symtab_hdr->sh_info;
9852 ++sym)
9853 if (sym->st_value != 0
9854 && bfd_section_from_elf_index (ibfd, sym->st_shndx) == toc)
9855 {
9856 unsigned long i;
9857
9858 if (sym->st_value > toc->rawsize)
9859 i = toc->rawsize >> 3;
9860 else
9861 i = sym->st_value >> 3;
9862
9863 if ((skip[i] & (ref_from_discarded | can_optimize)) != 0)
9864 {
9865 if (local_toc_syms)
9866 _bfd_error_handler
9867 (_("%s defined on removed toc entry"),
9868 bfd_elf_sym_name (ibfd, symtab_hdr, sym, NULL));
9869 do
9870 ++i;
9871 while ((skip[i] & (ref_from_discarded | can_optimize)));
9872 sym->st_value = (bfd_vma) i << 3;
9873 }
9874
9875 sym->st_value -= skip[i];
9876 symtab_hdr->contents = (unsigned char *) local_syms;
9877 }
9878
9879 /* Adjust any global syms defined in this toc input section. */
9880 if (toc_inf.global_toc_syms)
9881 {
9882 toc_inf.toc = toc;
9883 toc_inf.skip = skip;
9884 toc_inf.global_toc_syms = FALSE;
9885 elf_link_hash_traverse (elf_hash_table (info), adjust_toc_syms,
9886 &toc_inf);
9887 }
9888
9889 if (toc->reloc_count != 0)
9890 {
9891 Elf_Internal_Shdr *rel_hdr;
9892 Elf_Internal_Rela *wrel;
9893 bfd_size_type sz;
9894
9895 /* Remove unused toc relocs, and adjust those we keep. */
9896 if (toc_relocs == NULL)
9897 toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
9898 info->keep_memory);
9899 if (toc_relocs == NULL)
9900 goto error_ret;
9901
9902 wrel = toc_relocs;
9903 for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
9904 if ((skip[rel->r_offset >> 3]
9905 & (ref_from_discarded | can_optimize)) == 0)
9906 {
9907 wrel->r_offset = rel->r_offset - skip[rel->r_offset >> 3];
9908 wrel->r_info = rel->r_info;
9909 wrel->r_addend = rel->r_addend;
9910 ++wrel;
9911 }
9912 else if (!dec_dynrel_count (rel->r_info, toc, info,
9913 &local_syms, NULL, NULL))
9914 goto error_ret;
9915
9916 elf_section_data (toc)->relocs = toc_relocs;
9917 toc->reloc_count = wrel - toc_relocs;
9918 rel_hdr = _bfd_elf_single_rel_hdr (toc);
9919 sz = rel_hdr->sh_entsize;
9920 rel_hdr->sh_size = toc->reloc_count * sz;
9921 }
9922 }
9923 else if (toc_relocs != NULL
9924 && elf_section_data (toc)->relocs != toc_relocs)
9925 free (toc_relocs);
9926
9927 if (local_syms != NULL
9928 && symtab_hdr->contents != (unsigned char *) local_syms)
9929 {
9930 if (!info->keep_memory)
9931 free (local_syms);
9932 else
9933 symtab_hdr->contents = (unsigned char *) local_syms;
9934 }
9935 free (skip);
9936 }
9937
9938 return TRUE;
9939 }
9940
9941 /* Return true iff input section I references the TOC using
9942 instructions limited to +/-32k offsets. */
9943
9944 bfd_boolean
9945 ppc64_elf_has_small_toc_reloc (asection *i)
9946 {
9947 return (is_ppc64_elf (i->owner)
9948 && ppc64_elf_tdata (i->owner)->has_small_toc_reloc);
9949 }
9950
9951 /* Allocate space for one GOT entry. */
9952
9953 static void
9954 allocate_got (struct elf_link_hash_entry *h,
9955 struct bfd_link_info *info,
9956 struct got_entry *gent)
9957 {
9958 struct ppc_link_hash_table *htab = ppc_hash_table (info);
9959 struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
9960 int entsize = (gent->tls_type & eh->tls_mask & (TLS_GD | TLS_LD)
9961 ? 16 : 8);
9962 int rentsize = (gent->tls_type & eh->tls_mask & TLS_GD
9963 ? 2 : 1) * sizeof (Elf64_External_Rela);
9964 asection *got = ppc64_elf_tdata (gent->owner)->got;
9965
9966 gent->got.offset = got->size;
9967 got->size += entsize;
9968
9969 if (h->type == STT_GNU_IFUNC)
9970 {
9971 htab->elf.irelplt->size += rentsize;
9972 htab->got_reli_size += rentsize;
9973 }
9974 else if (((bfd_link_pic (info)
9975 && !((gent->tls_type & TLS_TPREL) != 0
9976 && bfd_link_executable (info)
9977 && SYMBOL_REFERENCES_LOCAL (info, h)))
9978 || (htab->elf.dynamic_sections_created
9979 && h->dynindx != -1
9980 && !SYMBOL_REFERENCES_LOCAL (info, h)))
9981 && !UNDEFWEAK_NO_DYNAMIC_RELOC (info, h))
9982 {
9983 asection *relgot = ppc64_elf_tdata (gent->owner)->relgot;
9984 relgot->size += rentsize;
9985 }
9986 }
9987
9988 /* This function merges got entries in the same toc group. */
9989
9990 static void
9991 merge_got_entries (struct got_entry **pent)
9992 {
9993 struct got_entry *ent, *ent2;
9994
9995 for (ent = *pent; ent != NULL; ent = ent->next)
9996 if (!ent->is_indirect)
9997 for (ent2 = ent->next; ent2 != NULL; ent2 = ent2->next)
9998 if (!ent2->is_indirect
9999 && ent2->addend == ent->addend
10000 && ent2->tls_type == ent->tls_type
10001 && elf_gp (ent2->owner) == elf_gp (ent->owner))
10002 {
10003 ent2->is_indirect = TRUE;
10004 ent2->got.ent = ent;
10005 }
10006 }
10007
10008 /* If H is undefined, make it dynamic if that makes sense. */
10009
10010 static bfd_boolean
10011 ensure_undef_dynamic (struct bfd_link_info *info,
10012 struct elf_link_hash_entry *h)
10013 {
10014 struct elf_link_hash_table *htab = elf_hash_table (info);
10015
10016 if (htab->dynamic_sections_created
10017 && ((info->dynamic_undefined_weak != 0
10018 && h->root.type == bfd_link_hash_undefweak)
10019 || h->root.type == bfd_link_hash_undefined)
10020 && h->dynindx == -1
10021 && !h->forced_local
10022 && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
10023 return bfd_elf_link_record_dynamic_symbol (info, h);
10024 return TRUE;
10025 }
10026
10027 /* Allocate space in .plt, .got and associated reloc sections for
10028 dynamic relocs. */
10029
10030 static bfd_boolean
10031 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
10032 {
10033 struct bfd_link_info *info;
10034 struct ppc_link_hash_table *htab;
10035 asection *s;
10036 struct ppc_link_hash_entry *eh;
10037 struct got_entry **pgent, *gent;
10038
10039 if (h->root.type == bfd_link_hash_indirect)
10040 return TRUE;
10041
10042 info = (struct bfd_link_info *) inf;
10043 htab = ppc_hash_table (info);
10044 if (htab == NULL)
10045 return FALSE;
10046
10047 eh = (struct ppc_link_hash_entry *) h;
10048 /* Run through the TLS GD got entries first if we're changing them
10049 to TPREL. */
10050 if ((eh->tls_mask & (TLS_TLS | TLS_TPRELGD)) == (TLS_TLS | TLS_TPRELGD))
10051 for (gent = h->got.glist; gent != NULL; gent = gent->next)
10052 if (gent->got.refcount > 0
10053 && (gent->tls_type & TLS_GD) != 0)
10054 {
10055 /* This was a GD entry that has been converted to TPREL. If
10056 there happens to be a TPREL entry we can use that one. */
10057 struct got_entry *ent;
10058 for (ent = h->got.glist; ent != NULL; ent = ent->next)
10059 if (ent->got.refcount > 0
10060 && (ent->tls_type & TLS_TPREL) != 0
10061 && ent->addend == gent->addend
10062 && ent->owner == gent->owner)
10063 {
10064 gent->got.refcount = 0;
10065 break;
10066 }
10067
10068 /* If not, then we'll be using our own TPREL entry. */
10069 if (gent->got.refcount != 0)
10070 gent->tls_type = TLS_TLS | TLS_TPREL;
10071 }
10072
10073 /* Remove any list entry that won't generate a word in the GOT before
10074 we call merge_got_entries. Otherwise we risk merging to empty
10075 entries. */
10076 pgent = &h->got.glist;
10077 while ((gent = *pgent) != NULL)
10078 if (gent->got.refcount > 0)
10079 {
10080 if ((gent->tls_type & TLS_LD) != 0
10081 && !h->def_dynamic)
10082 {
10083 ppc64_tlsld_got (gent->owner)->got.refcount += 1;
10084 *pgent = gent->next;
10085 }
10086 else
10087 pgent = &gent->next;
10088 }
10089 else
10090 *pgent = gent->next;
10091
10092 if (!htab->do_multi_toc)
10093 merge_got_entries (&h->got.glist);
10094
10095 for (gent = h->got.glist; gent != NULL; gent = gent->next)
10096 if (!gent->is_indirect)
10097 {
10098 /* Make sure this symbol is output as a dynamic symbol. */
10099 if (!ensure_undef_dynamic (info, h))
10100 return FALSE;
10101
10102 if (!is_ppc64_elf (gent->owner))
10103 abort ();
10104
10105 allocate_got (h, info, gent);
10106 }
10107
10108 /* If no dynamic sections we can't have dynamic relocs, except for
10109 IFUNCs which are handled even in static executables. */
10110 if (!htab->elf.dynamic_sections_created
10111 && h->type != STT_GNU_IFUNC)
10112 eh->dyn_relocs = NULL;
10113
10114 /* Discard relocs on undefined symbols that must be local. */
10115 else if (h->root.type == bfd_link_hash_undefined
10116 && ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
10117 eh->dyn_relocs = NULL;
10118
10119 /* Also discard relocs on undefined weak syms with non-default
10120 visibility, or when dynamic_undefined_weak says so. */
10121 else if (UNDEFWEAK_NO_DYNAMIC_RELOC (info, h))
10122 eh->dyn_relocs = NULL;
10123
10124 if (eh->dyn_relocs != NULL)
10125 {
10126 struct elf_dyn_relocs *p, **pp;
10127
10128 /* In the shared -Bsymbolic case, discard space allocated for
10129 dynamic pc-relative relocs against symbols which turn out to
10130 be defined in regular objects. For the normal shared case,
10131 discard space for relocs that have become local due to symbol
10132 visibility changes. */
10133
10134 if (bfd_link_pic (info))
10135 {
10136 /* Relocs that use pc_count are those that appear on a call
10137 insn, or certain REL relocs (see must_be_dyn_reloc) that
10138 can be generated via assembly. We want calls to
10139 protected symbols to resolve directly to the function
10140 rather than going via the plt. If people want function
10141 pointer comparisons to work as expected then they should
10142 avoid writing weird assembly. */
10143 if (SYMBOL_CALLS_LOCAL (info, h))
10144 {
10145 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
10146 {
10147 p->count -= p->pc_count;
10148 p->pc_count = 0;
10149 if (p->count == 0)
10150 *pp = p->next;
10151 else
10152 pp = &p->next;
10153 }
10154 }
10155
10156 if (eh->dyn_relocs != NULL)
10157 {
10158 /* Make sure this symbol is output as a dynamic symbol. */
10159 if (!ensure_undef_dynamic (info, h))
10160 return FALSE;
10161 }
10162 }
10163 else if (ELIMINATE_COPY_RELOCS && h->type != STT_GNU_IFUNC)
10164 {
10165 /* For the non-pic case, discard space for relocs against
10166 symbols which turn out to need copy relocs or are not
10167 dynamic. */
10168 if (h->dynamic_adjusted
10169 && !h->def_regular
10170 && !ELF_COMMON_DEF_P (h))
10171 {
10172 /* Make sure this symbol is output as a dynamic symbol. */
10173 if (!ensure_undef_dynamic (info, h))
10174 return FALSE;
10175
10176 if (h->dynindx == -1)
10177 eh->dyn_relocs = NULL;
10178 }
10179 else
10180 eh->dyn_relocs = NULL;
10181 }
10182
10183 /* Finally, allocate space. */
10184 for (p = eh->dyn_relocs; p != NULL; p = p->next)
10185 {
10186 asection *sreloc = elf_section_data (p->sec)->sreloc;
10187 if (eh->elf.type == STT_GNU_IFUNC)
10188 sreloc = htab->elf.irelplt;
10189 sreloc->size += p->count * sizeof (Elf64_External_Rela);
10190 }
10191 }
10192
10193 /* We might need a PLT entry when the symbol
10194 a) is dynamic, or
10195 b) is an ifunc, or
10196 c) has plt16 relocs and has been processed by adjust_dynamic_symbol, or
10197 d) has plt16 relocs and we are linking statically. */
10198 if ((htab->elf.dynamic_sections_created && h->dynindx != -1)
10199 || h->type == STT_GNU_IFUNC
10200 || (h->needs_plt && h->dynamic_adjusted)
10201 || (h->needs_plt
10202 && h->def_regular
10203 && !htab->elf.dynamic_sections_created
10204 && !htab->can_convert_all_inline_plt
10205 && (((struct ppc_link_hash_entry *) h)->tls_mask
10206 & (TLS_TLS | PLT_KEEP)) == PLT_KEEP))
10207 {
10208 struct plt_entry *pent;
10209 bfd_boolean doneone = FALSE;
10210 for (pent = h->plt.plist; pent != NULL; pent = pent->next)
10211 if (pent->plt.refcount > 0)
10212 {
10213 if (!htab->elf.dynamic_sections_created
10214 || h->dynindx == -1)
10215 {
10216 if (h->type == STT_GNU_IFUNC)
10217 {
10218 s = htab->elf.iplt;
10219 pent->plt.offset = s->size;
10220 s->size += PLT_ENTRY_SIZE (htab);
10221 s = htab->elf.irelplt;
10222 }
10223 else
10224 {
10225 s = htab->pltlocal;
10226 pent->plt.offset = s->size;
10227 s->size += LOCAL_PLT_ENTRY_SIZE (htab);
10228 s = bfd_link_pic (info) ? htab->relpltlocal : NULL;
10229 }
10230 }
10231 else
10232 {
10233 /* If this is the first .plt entry, make room for the special
10234 first entry. */
10235 s = htab->elf.splt;
10236 if (s->size == 0)
10237 s->size += PLT_INITIAL_ENTRY_SIZE (htab);
10238
10239 pent->plt.offset = s->size;
10240
10241 /* Make room for this entry. */
10242 s->size += PLT_ENTRY_SIZE (htab);
10243
10244 /* Make room for the .glink code. */
10245 s = htab->glink;
10246 if (s->size == 0)
10247 s->size += GLINK_PLTRESOLVE_SIZE (htab);
10248 if (htab->opd_abi)
10249 {
10250 /* We need bigger stubs past index 32767. */
10251 if (s->size >= GLINK_PLTRESOLVE_SIZE (htab) + 32768*2*4)
10252 s->size += 4;
10253 s->size += 2*4;
10254 }
10255 else
10256 s->size += 4;
10257
10258 /* We also need to make an entry in the .rela.plt section. */
10259 s = htab->elf.srelplt;
10260 }
10261 if (s != NULL)
10262 s->size += sizeof (Elf64_External_Rela);
10263 doneone = TRUE;
10264 }
10265 else
10266 pent->plt.offset = (bfd_vma) -1;
10267 if (!doneone)
10268 {
10269 h->plt.plist = NULL;
10270 h->needs_plt = 0;
10271 }
10272 }
10273 else
10274 {
10275 h->plt.plist = NULL;
10276 h->needs_plt = 0;
10277 }
10278
10279 return TRUE;
10280 }
10281
10282 #define PPC_LO(v) ((v) & 0xffff)
10283 #define PPC_HI(v) (((v) >> 16) & 0xffff)
10284 #define PPC_HA(v) PPC_HI ((v) + 0x8000)
10285
10286 /* Called via elf_link_hash_traverse from ppc64_elf_size_dynamic_sections
10287 to set up space for global entry stubs. These are put in glink,
10288 after the branch table. */
10289
10290 static bfd_boolean
10291 size_global_entry_stubs (struct elf_link_hash_entry *h, void *inf)
10292 {
10293 struct bfd_link_info *info;
10294 struct ppc_link_hash_table *htab;
10295 struct plt_entry *pent;
10296 asection *s, *plt;
10297
10298 if (h->root.type == bfd_link_hash_indirect)
10299 return TRUE;
10300
10301 if (!h->pointer_equality_needed)
10302 return TRUE;
10303
10304 if (h->def_regular)
10305 return TRUE;
10306
10307 info = inf;
10308 htab = ppc_hash_table (info);
10309 if (htab == NULL)
10310 return FALSE;
10311
10312 s = htab->global_entry;
10313 plt = htab->elf.splt;
10314 for (pent = h->plt.plist; pent != NULL; pent = pent->next)
10315 if (pent->plt.offset != (bfd_vma) -1
10316 && pent->addend == 0)
10317 {
10318 /* For ELFv2, if this symbol is not defined in a regular file
10319 and we are not generating a shared library or pie, then we
10320 need to define the symbol in the executable on a call stub.
10321 This is to avoid text relocations. */
10322 bfd_vma off, stub_align, stub_off, stub_size;
10323 unsigned int align_power;
10324
10325 stub_size = 16;
10326 stub_off = s->size;
10327 if (htab->params->plt_stub_align >= 0)
10328 align_power = htab->params->plt_stub_align;
10329 else
10330 align_power = -htab->params->plt_stub_align;
10331 /* Setting section alignment is delayed until we know it is
10332 non-empty. Otherwise the .text output section will be
10333 aligned at least to plt_stub_align even when no global
10334 entry stubs are needed. */
10335 if (s->alignment_power < align_power)
10336 s->alignment_power = align_power;
10337 stub_align = (bfd_vma) 1 << align_power;
10338 if (htab->params->plt_stub_align >= 0
10339 || ((((stub_off + stub_size - 1) & -stub_align)
10340 - (stub_off & -stub_align))
10341 > ((stub_size - 1) & -stub_align)))
10342 stub_off = (stub_off + stub_align - 1) & -stub_align;
10343 off = pent->plt.offset + plt->output_offset + plt->output_section->vma;
10344 off -= stub_off + s->output_offset + s->output_section->vma;
10345 /* Note that for --plt-stub-align negative we have a possible
10346 dependency between stub offset and size. Break that
10347 dependency by assuming the max stub size when calculating
10348 the stub offset. */
10349 if (PPC_HA (off) == 0)
10350 stub_size -= 4;
10351 h->root.type = bfd_link_hash_defined;
10352 h->root.u.def.section = s;
10353 h->root.u.def.value = stub_off;
10354 s->size = stub_off + stub_size;
10355 break;
10356 }
10357 return TRUE;
10358 }
10359
10360 /* Set DF_TEXTREL if we find any dynamic relocs that apply to
10361 read-only sections. */
10362
10363 static bfd_boolean
10364 maybe_set_textrel (struct elf_link_hash_entry *h, void *inf)
10365 {
10366 asection *sec;
10367
10368 if (h->root.type == bfd_link_hash_indirect)
10369 return TRUE;
10370
10371 sec = readonly_dynrelocs (h);
10372 if (sec != NULL)
10373 {
10374 struct bfd_link_info *info = (struct bfd_link_info *) inf;
10375
10376 info->flags |= DF_TEXTREL;
10377 info->callbacks->minfo
10378 (_("%pB: dynamic relocation against `%pT' in read-only section `%pA'\n"),
10379 sec->owner, h->root.root.string, sec);
10380
10381 /* Not an error, just cut short the traversal. */
10382 return FALSE;
10383 }
10384 return TRUE;
10385 }
10386
10387 /* Set the sizes of the dynamic sections. */
10388
10389 static bfd_boolean
10390 ppc64_elf_size_dynamic_sections (bfd *output_bfd,
10391 struct bfd_link_info *info)
10392 {
10393 struct ppc_link_hash_table *htab;
10394 bfd *dynobj;
10395 asection *s;
10396 bfd_boolean relocs;
10397 bfd *ibfd;
10398 struct got_entry *first_tlsld;
10399
10400 htab = ppc_hash_table (info);
10401 if (htab == NULL)
10402 return FALSE;
10403
10404 dynobj = htab->elf.dynobj;
10405 if (dynobj == NULL)
10406 abort ();
10407
10408 if (htab->elf.dynamic_sections_created)
10409 {
10410 /* Set the contents of the .interp section to the interpreter. */
10411 if (bfd_link_executable (info) && !info->nointerp)
10412 {
10413 s = bfd_get_linker_section (dynobj, ".interp");
10414 if (s == NULL)
10415 abort ();
10416 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
10417 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
10418 }
10419 }
10420
10421 /* Set up .got offsets for local syms, and space for local dynamic
10422 relocs. */
10423 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
10424 {
10425 struct got_entry **lgot_ents;
10426 struct got_entry **end_lgot_ents;
10427 struct plt_entry **local_plt;
10428 struct plt_entry **end_local_plt;
10429 unsigned char *lgot_masks;
10430 bfd_size_type locsymcount;
10431 Elf_Internal_Shdr *symtab_hdr;
10432
10433 if (!is_ppc64_elf (ibfd))
10434 continue;
10435
10436 for (s = ibfd->sections; s != NULL; s = s->next)
10437 {
10438 struct ppc_dyn_relocs *p;
10439
10440 for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
10441 {
10442 if (!bfd_is_abs_section (p->sec)
10443 && bfd_is_abs_section (p->sec->output_section))
10444 {
10445 /* Input section has been discarded, either because
10446 it is a copy of a linkonce section or due to
10447 linker script /DISCARD/, so we'll be discarding
10448 the relocs too. */
10449 }
10450 else if (p->count != 0)
10451 {
10452 asection *srel = elf_section_data (p->sec)->sreloc;
10453 if (p->ifunc)
10454 srel = htab->elf.irelplt;
10455 srel->size += p->count * sizeof (Elf64_External_Rela);
10456 if ((p->sec->output_section->flags & SEC_READONLY) != 0)
10457 info->flags |= DF_TEXTREL;
10458 }
10459 }
10460 }
10461
10462 lgot_ents = elf_local_got_ents (ibfd);
10463 if (!lgot_ents)
10464 continue;
10465
10466 symtab_hdr = &elf_symtab_hdr (ibfd);
10467 locsymcount = symtab_hdr->sh_info;
10468 end_lgot_ents = lgot_ents + locsymcount;
10469 local_plt = (struct plt_entry **) end_lgot_ents;
10470 end_local_plt = local_plt + locsymcount;
10471 lgot_masks = (unsigned char *) end_local_plt;
10472 s = ppc64_elf_tdata (ibfd)->got;
10473 for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
10474 {
10475 struct got_entry **pent, *ent;
10476
10477 pent = lgot_ents;
10478 while ((ent = *pent) != NULL)
10479 if (ent->got.refcount > 0)
10480 {
10481 if ((ent->tls_type & *lgot_masks & TLS_LD) != 0)
10482 {
10483 ppc64_tlsld_got (ibfd)->got.refcount += 1;
10484 *pent = ent->next;
10485 }
10486 else
10487 {
10488 unsigned int ent_size = 8;
10489 unsigned int rel_size = sizeof (Elf64_External_Rela);
10490
10491 ent->got.offset = s->size;
10492 if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
10493 {
10494 ent_size *= 2;
10495 rel_size *= 2;
10496 }
10497 s->size += ent_size;
10498 if ((*lgot_masks & (TLS_TLS | PLT_IFUNC)) == PLT_IFUNC)
10499 {
10500 htab->elf.irelplt->size += rel_size;
10501 htab->got_reli_size += rel_size;
10502 }
10503 else if (bfd_link_pic (info)
10504 && !((ent->tls_type & TLS_TPREL) != 0
10505 && bfd_link_executable (info)))
10506 {
10507 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
10508 srel->size += rel_size;
10509 }
10510 pent = &ent->next;
10511 }
10512 }
10513 else
10514 *pent = ent->next;
10515 }
10516
10517 /* Allocate space for plt calls to local syms. */
10518 lgot_masks = (unsigned char *) end_local_plt;
10519 for (; local_plt < end_local_plt; ++local_plt, ++lgot_masks)
10520 {
10521 struct plt_entry *ent;
10522
10523 for (ent = *local_plt; ent != NULL; ent = ent->next)
10524 if (ent->plt.refcount > 0)
10525 {
10526 if ((*lgot_masks & (TLS_TLS | PLT_IFUNC)) == PLT_IFUNC)
10527 {
10528 s = htab->elf.iplt;
10529 ent->plt.offset = s->size;
10530 s->size += PLT_ENTRY_SIZE (htab);
10531 htab->elf.irelplt->size += sizeof (Elf64_External_Rela);
10532 }
10533 else if (htab->can_convert_all_inline_plt
10534 || (*lgot_masks & (TLS_TLS | PLT_KEEP)) != PLT_KEEP)
10535 ent->plt.offset = (bfd_vma) -1;
10536 else
10537 {
10538 s = htab->pltlocal;
10539 ent->plt.offset = s->size;
10540 s->size += LOCAL_PLT_ENTRY_SIZE (htab);
10541 if (bfd_link_pic (info))
10542 htab->relpltlocal->size += sizeof (Elf64_External_Rela);
10543 }
10544 }
10545 else
10546 ent->plt.offset = (bfd_vma) -1;
10547 }
10548 }
10549
10550 /* Allocate global sym .plt and .got entries, and space for global
10551 sym dynamic relocs. */
10552 elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, info);
10553
10554 if (!htab->opd_abi && !bfd_link_pic (info))
10555 elf_link_hash_traverse (&htab->elf, size_global_entry_stubs, info);
10556
10557 first_tlsld = NULL;
10558 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
10559 {
10560 struct got_entry *ent;
10561
10562 if (!is_ppc64_elf (ibfd))
10563 continue;
10564
10565 ent = ppc64_tlsld_got (ibfd);
10566 if (ent->got.refcount > 0)
10567 {
10568 if (!htab->do_multi_toc && first_tlsld != NULL)
10569 {
10570 ent->is_indirect = TRUE;
10571 ent->got.ent = first_tlsld;
10572 }
10573 else
10574 {
10575 if (first_tlsld == NULL)
10576 first_tlsld = ent;
10577 s = ppc64_elf_tdata (ibfd)->got;
10578 ent->got.offset = s->size;
10579 ent->owner = ibfd;
10580 s->size += 16;
10581 if (bfd_link_pic (info))
10582 {
10583 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
10584 srel->size += sizeof (Elf64_External_Rela);
10585 }
10586 }
10587 }
10588 else
10589 ent->got.offset = (bfd_vma) -1;
10590 }
10591
10592 /* We now have determined the sizes of the various dynamic sections.
10593 Allocate memory for them. */
10594 relocs = FALSE;
10595 for (s = dynobj->sections; s != NULL; s = s->next)
10596 {
10597 if ((s->flags & SEC_LINKER_CREATED) == 0)
10598 continue;
10599
10600 if (s == htab->brlt || s == htab->relbrlt)
10601 /* These haven't been allocated yet; don't strip. */
10602 continue;
10603 else if (s == htab->elf.sgot
10604 || s == htab->elf.splt
10605 || s == htab->elf.iplt
10606 || s == htab->pltlocal
10607 || s == htab->glink
10608 || s == htab->global_entry
10609 || s == htab->elf.sdynbss
10610 || s == htab->elf.sdynrelro)
10611 {
10612 /* Strip this section if we don't need it; see the
10613 comment below. */
10614 }
10615 else if (s == htab->glink_eh_frame)
10616 {
10617 if (!bfd_is_abs_section (s->output_section))
10618 /* Not sized yet. */
10619 continue;
10620 }
10621 else if (CONST_STRNEQ (s->name, ".rela"))
10622 {
10623 if (s->size != 0)
10624 {
10625 if (s != htab->elf.srelplt)
10626 relocs = TRUE;
10627
10628 /* We use the reloc_count field as a counter if we need
10629 to copy relocs into the output file. */
10630 s->reloc_count = 0;
10631 }
10632 }
10633 else
10634 {
10635 /* It's not one of our sections, so don't allocate space. */
10636 continue;
10637 }
10638
10639 if (s->size == 0)
10640 {
10641 /* If we don't need this section, strip it from the
10642 output file. This is mostly to handle .rela.bss and
10643 .rela.plt. We must create both sections in
10644 create_dynamic_sections, because they must be created
10645 before the linker maps input sections to output
10646 sections. The linker does that before
10647 adjust_dynamic_symbol is called, and it is that
10648 function which decides whether anything needs to go
10649 into these sections. */
10650 s->flags |= SEC_EXCLUDE;
10651 continue;
10652 }
10653
10654 if (bfd_is_abs_section (s->output_section))
10655 _bfd_error_handler (_("warning: discarding dynamic section %s"),
10656 s->name);
10657
10658 if ((s->flags & SEC_HAS_CONTENTS) == 0)
10659 continue;
10660
10661 /* Allocate memory for the section contents. We use bfd_zalloc
10662 here in case unused entries are not reclaimed before the
10663 section's contents are written out. This should not happen,
10664 but this way if it does we get a R_PPC64_NONE reloc in .rela
10665 sections instead of garbage.
10666 We also rely on the section contents being zero when writing
10667 the GOT and .dynrelro. */
10668 s->contents = bfd_zalloc (dynobj, s->size);
10669 if (s->contents == NULL)
10670 return FALSE;
10671 }
10672
10673 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
10674 {
10675 if (!is_ppc64_elf (ibfd))
10676 continue;
10677
10678 s = ppc64_elf_tdata (ibfd)->got;
10679 if (s != NULL && s != htab->elf.sgot)
10680 {
10681 if (s->size == 0)
10682 s->flags |= SEC_EXCLUDE;
10683 else
10684 {
10685 s->contents = bfd_zalloc (ibfd, s->size);
10686 if (s->contents == NULL)
10687 return FALSE;
10688 }
10689 }
10690 s = ppc64_elf_tdata (ibfd)->relgot;
10691 if (s != NULL)
10692 {
10693 if (s->size == 0)
10694 s->flags |= SEC_EXCLUDE;
10695 else
10696 {
10697 s->contents = bfd_zalloc (ibfd, s->size);
10698 if (s->contents == NULL)
10699 return FALSE;
10700 relocs = TRUE;
10701 s->reloc_count = 0;
10702 }
10703 }
10704 }
10705
10706 if (htab->elf.dynamic_sections_created)
10707 {
10708 bfd_boolean tls_opt;
10709
10710 /* Add some entries to the .dynamic section. We fill in the
10711 values later, in ppc64_elf_finish_dynamic_sections, but we
10712 must add the entries now so that we get the correct size for
10713 the .dynamic section. The DT_DEBUG entry is filled in by the
10714 dynamic linker and used by the debugger. */
10715 #define add_dynamic_entry(TAG, VAL) \
10716 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
10717
10718 if (bfd_link_executable (info))
10719 {
10720 if (!add_dynamic_entry (DT_DEBUG, 0))
10721 return FALSE;
10722 }
10723
10724 if (htab->elf.splt != NULL && htab->elf.splt->size != 0)
10725 {
10726 if (!add_dynamic_entry (DT_PLTGOT, 0)
10727 || !add_dynamic_entry (DT_PLTRELSZ, 0)
10728 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
10729 || !add_dynamic_entry (DT_JMPREL, 0)
10730 || !add_dynamic_entry (DT_PPC64_GLINK, 0))
10731 return FALSE;
10732 }
10733
10734 if (NO_OPD_RELOCS && abiversion (output_bfd) <= 1)
10735 {
10736 if (!add_dynamic_entry (DT_PPC64_OPD, 0)
10737 || !add_dynamic_entry (DT_PPC64_OPDSZ, 0))
10738 return FALSE;
10739 }
10740
10741 tls_opt = (htab->params->tls_get_addr_opt
10742 && htab->tls_get_addr_fd != NULL
10743 && htab->tls_get_addr_fd->elf.plt.plist != NULL);
10744 if (tls_opt || !htab->opd_abi)
10745 {
10746 if (!add_dynamic_entry (DT_PPC64_OPT, tls_opt ? PPC64_OPT_TLS : 0))
10747 return FALSE;
10748 }
10749
10750 if (relocs)
10751 {
10752 if (!add_dynamic_entry (DT_RELA, 0)
10753 || !add_dynamic_entry (DT_RELASZ, 0)
10754 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
10755 return FALSE;
10756
10757 /* If any dynamic relocs apply to a read-only section,
10758 then we need a DT_TEXTREL entry. */
10759 if ((info->flags & DF_TEXTREL) == 0)
10760 elf_link_hash_traverse (&htab->elf, maybe_set_textrel, info);
10761
10762 if ((info->flags & DF_TEXTREL) != 0)
10763 {
10764 if (!add_dynamic_entry (DT_TEXTREL, 0))
10765 return FALSE;
10766 }
10767 }
10768 }
10769 #undef add_dynamic_entry
10770
10771 return TRUE;
10772 }
10773
10774 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
10775
10776 static bfd_boolean
10777 ppc64_elf_hash_symbol (struct elf_link_hash_entry *h)
10778 {
10779 if (h->plt.plist != NULL
10780 && !h->def_regular
10781 && !h->pointer_equality_needed)
10782 return FALSE;
10783
10784 return _bfd_elf_hash_symbol (h);
10785 }
10786
10787 /* Determine the type of stub needed, if any, for a call. */
10788
10789 static inline enum ppc_stub_type
10790 ppc_type_of_stub (asection *input_sec,
10791 const Elf_Internal_Rela *rel,
10792 struct ppc_link_hash_entry **hash,
10793 struct plt_entry **plt_ent,
10794 bfd_vma destination,
10795 unsigned long local_off)
10796 {
10797 struct ppc_link_hash_entry *h = *hash;
10798 bfd_vma location;
10799 bfd_vma branch_offset;
10800 bfd_vma max_branch_offset;
10801 enum elf_ppc64_reloc_type r_type;
10802
10803 if (h != NULL)
10804 {
10805 struct plt_entry *ent;
10806 struct ppc_link_hash_entry *fdh = h;
10807 if (h->oh != NULL
10808 && h->oh->is_func_descriptor)
10809 {
10810 fdh = ppc_follow_link (h->oh);
10811 *hash = fdh;
10812 }
10813
10814 for (ent = fdh->elf.plt.plist; ent != NULL; ent = ent->next)
10815 if (ent->addend == rel->r_addend
10816 && ent->plt.offset != (bfd_vma) -1)
10817 {
10818 *plt_ent = ent;
10819 return ppc_stub_plt_call;
10820 }
10821
10822 /* Here, we know we don't have a plt entry. If we don't have a
10823 either a defined function descriptor or a defined entry symbol
10824 in a regular object file, then it is pointless trying to make
10825 any other type of stub. */
10826 if (!is_static_defined (&fdh->elf)
10827 && !is_static_defined (&h->elf))
10828 return ppc_stub_none;
10829 }
10830 else if (elf_local_got_ents (input_sec->owner) != NULL)
10831 {
10832 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (input_sec->owner);
10833 struct plt_entry **local_plt = (struct plt_entry **)
10834 elf_local_got_ents (input_sec->owner) + symtab_hdr->sh_info;
10835 unsigned long r_symndx = ELF64_R_SYM (rel->r_info);
10836
10837 if (local_plt[r_symndx] != NULL)
10838 {
10839 struct plt_entry *ent;
10840
10841 for (ent = local_plt[r_symndx]; ent != NULL; ent = ent->next)
10842 if (ent->addend == rel->r_addend
10843 && ent->plt.offset != (bfd_vma) -1)
10844 {
10845 *plt_ent = ent;
10846 return ppc_stub_plt_call;
10847 }
10848 }
10849 }
10850
10851 /* Determine where the call point is. */
10852 location = (input_sec->output_offset
10853 + input_sec->output_section->vma
10854 + rel->r_offset);
10855
10856 branch_offset = destination - location;
10857 r_type = ELF64_R_TYPE (rel->r_info);
10858
10859 /* Determine if a long branch stub is needed. */
10860 max_branch_offset = 1 << 25;
10861 if (r_type == R_PPC64_REL14
10862 || r_type == R_PPC64_REL14_BRTAKEN
10863 || r_type == R_PPC64_REL14_BRNTAKEN)
10864 max_branch_offset = 1 << 15;
10865
10866 if (branch_offset + max_branch_offset >= 2 * max_branch_offset - local_off)
10867 /* We need a stub. Figure out whether a long_branch or plt_branch
10868 is needed later. */
10869 return ppc_stub_long_branch;
10870
10871 return ppc_stub_none;
10872 }
10873
10874 /* Builds a 64-bit offset in r12 then adds it to r11 (LOAD false) or
10875 loads r12 from r11+r12 (LOAD true).
10876 . lis %r12,xxx-1b@highest
10877 . ori %r12,xxx-1b@higher
10878 . sldi %r12,%r12,32
10879 . oris %r12,%r12,xxx-1b@hi
10880 . ori %r12,%r12,xxx-1b@l
10881 . add %r12,%r11,%r12 */
10882
10883 static bfd_byte *
10884 build_offset (bfd *abfd, bfd_byte *p, bfd_vma off, bfd_boolean load)
10885 {
10886 if (off + 0x8000 < 0x10000)
10887 {
10888 if (load)
10889 bfd_put_32 (abfd, LD_R12_0R11 + PPC_LO (off), p);
10890 else
10891 bfd_put_32 (abfd, ADDI_R12_R11 + PPC_LO (off), p);
10892 p += 4;
10893 }
10894 else if (off + 0x80008000ULL < 0x100000000ULL)
10895 {
10896 bfd_put_32 (abfd, ADDIS_R12_R11 + PPC_HA (off), p);
10897 p += 4;
10898 if (load)
10899 bfd_put_32 (abfd, LD_R12_0R12 + PPC_LO (off), p);
10900 else
10901 bfd_put_32 (abfd, ADDI_R12_R12 + PPC_LO (off), p);
10902 p += 4;
10903 }
10904 else
10905 {
10906 if (off + 0x800000000000ULL < 0x1000000000000ULL)
10907 {
10908 bfd_put_32 (abfd, LI_R12_0 + ((off >> 32) & 0xffff), p);
10909 p += 4;
10910 }
10911 else
10912 {
10913 bfd_put_32 (abfd, LIS_R12 + ((off >> 48) & 0xffff), p);
10914 p += 4;
10915 if (((off >> 32) & 0xffff) != 0)
10916 {
10917 bfd_put_32 (abfd, ORI_R12_R12_0 + ((off >> 32) & 0xffff), p);
10918 p += 4;
10919 }
10920 }
10921 if (((off >> 32) & 0xffffffffULL) != 0)
10922 {
10923 bfd_put_32 (abfd, SLDI_R12_R12_32, p);
10924 p += 4;
10925 }
10926 if (PPC_HI (off) != 0)
10927 {
10928 bfd_put_32 (abfd, ORIS_R12_R12_0 + PPC_HI (off), p);
10929 p += 4;
10930 }
10931 if (PPC_LO (off) != 0)
10932 {
10933 bfd_put_32 (abfd, ORI_R12_R12_0 + PPC_LO (off), p);
10934 p += 4;
10935 }
10936 if (load)
10937 bfd_put_32 (abfd, LDX_R12_R11_R12, p);
10938 else
10939 bfd_put_32 (abfd, ADD_R12_R11_R12, p);
10940 p += 4;
10941 }
10942 return p;
10943 }
10944
10945 static unsigned int
10946 size_offset (bfd_vma off)
10947 {
10948 unsigned int size;
10949 if (off + 0x8000 < 0x10000)
10950 size = 4;
10951 else if (off + 0x80008000ULL < 0x100000000ULL)
10952 size = 8;
10953 else
10954 {
10955 if (off + 0x800000000000ULL < 0x1000000000000ULL)
10956 size = 4;
10957 else
10958 {
10959 size = 4;
10960 if (((off >> 32) & 0xffff) != 0)
10961 size += 4;
10962 }
10963 if (((off >> 32) & 0xffffffffULL) != 0)
10964 size += 4;
10965 if (PPC_HI (off) != 0)
10966 size += 4;
10967 if (PPC_LO (off) != 0)
10968 size += 4;
10969 size += 4;
10970 }
10971 return size;
10972 }
10973
10974 /* Emit .eh_frame opcode to advance pc by DELTA. */
10975
10976 static bfd_byte *
10977 eh_advance (bfd *abfd, bfd_byte *eh, unsigned int delta)
10978 {
10979 delta /= 4;
10980 if (delta < 64)
10981 *eh++ = DW_CFA_advance_loc + delta;
10982 else if (delta < 256)
10983 {
10984 *eh++ = DW_CFA_advance_loc1;
10985 *eh++ = delta;
10986 }
10987 else if (delta < 65536)
10988 {
10989 *eh++ = DW_CFA_advance_loc2;
10990 bfd_put_16 (abfd, delta, eh);
10991 eh += 2;
10992 }
10993 else
10994 {
10995 *eh++ = DW_CFA_advance_loc4;
10996 bfd_put_32 (abfd, delta, eh);
10997 eh += 4;
10998 }
10999 return eh;
11000 }
11001
11002 /* Size of required .eh_frame opcode to advance pc by DELTA. */
11003
11004 static unsigned int
11005 eh_advance_size (unsigned int delta)
11006 {
11007 if (delta < 64 * 4)
11008 /* DW_CFA_advance_loc+[1..63]. */
11009 return 1;
11010 if (delta < 256 * 4)
11011 /* DW_CFA_advance_loc1, byte. */
11012 return 2;
11013 if (delta < 65536 * 4)
11014 /* DW_CFA_advance_loc2, 2 bytes. */
11015 return 3;
11016 /* DW_CFA_advance_loc4, 4 bytes. */
11017 return 5;
11018 }
11019
11020 /* With power7 weakly ordered memory model, it is possible for ld.so
11021 to update a plt entry in one thread and have another thread see a
11022 stale zero toc entry. To avoid this we need some sort of acquire
11023 barrier in the call stub. One solution is to make the load of the
11024 toc word seem to appear to depend on the load of the function entry
11025 word. Another solution is to test for r2 being zero, and branch to
11026 the appropriate glink entry if so.
11027
11028 . fake dep barrier compare
11029 . ld 12,xxx(2) ld 12,xxx(2)
11030 . mtctr 12 mtctr 12
11031 . xor 11,12,12 ld 2,xxx+8(2)
11032 . add 2,2,11 cmpldi 2,0
11033 . ld 2,xxx+8(2) bnectr+
11034 . bctr b <glink_entry>
11035
11036 The solution involving the compare turns out to be faster, so
11037 that's what we use unless the branch won't reach. */
11038
11039 #define ALWAYS_USE_FAKE_DEP 0
11040 #define ALWAYS_EMIT_R2SAVE 0
11041
11042 static inline unsigned int
11043 plt_stub_size (struct ppc_link_hash_table *htab,
11044 struct ppc_stub_hash_entry *stub_entry,
11045 bfd_vma off)
11046 {
11047 unsigned size;
11048
11049 if (stub_entry->stub_type >= ppc_stub_plt_call_notoc)
11050 {
11051 size = 24 + size_offset (off);
11052 if (stub_entry->stub_type > ppc_stub_plt_call_notoc)
11053 size += 4;
11054 return size;
11055 }
11056
11057 size = 12;
11058 if (ALWAYS_EMIT_R2SAVE
11059 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
11060 size += 4;
11061 if (PPC_HA (off) != 0)
11062 size += 4;
11063 if (htab->opd_abi)
11064 {
11065 size += 4;
11066 if (htab->params->plt_static_chain)
11067 size += 4;
11068 if (htab->params->plt_thread_safe
11069 && htab->elf.dynamic_sections_created
11070 && stub_entry->h != NULL
11071 && stub_entry->h->elf.dynindx != -1)
11072 size += 8;
11073 if (PPC_HA (off + 8 + 8 * htab->params->plt_static_chain) != PPC_HA (off))
11074 size += 4;
11075 }
11076 if (stub_entry->h != NULL
11077 && (stub_entry->h == htab->tls_get_addr_fd
11078 || stub_entry->h == htab->tls_get_addr)
11079 && htab->params->tls_get_addr_opt)
11080 {
11081 size += 7 * 4;
11082 if (stub_entry->stub_type == ppc_stub_plt_call_r2save)
11083 size += 6 * 4;
11084 }
11085 return size;
11086 }
11087
11088 /* Depending on the sign of plt_stub_align:
11089 If positive, return the padding to align to a 2**plt_stub_align
11090 boundary.
11091 If negative, if this stub would cross fewer 2**plt_stub_align
11092 boundaries if we align, then return the padding needed to do so. */
11093
11094 static inline unsigned int
11095 plt_stub_pad (struct ppc_link_hash_table *htab,
11096 struct ppc_stub_hash_entry *stub_entry,
11097 bfd_vma plt_off)
11098 {
11099 int stub_align;
11100 unsigned stub_size;
11101 bfd_vma stub_off = stub_entry->group->stub_sec->size;
11102
11103 if (htab->params->plt_stub_align >= 0)
11104 {
11105 stub_align = 1 << htab->params->plt_stub_align;
11106 if ((stub_off & (stub_align - 1)) != 0)
11107 return stub_align - (stub_off & (stub_align - 1));
11108 return 0;
11109 }
11110
11111 stub_align = 1 << -htab->params->plt_stub_align;
11112 stub_size = plt_stub_size (htab, stub_entry, plt_off);
11113 if (((stub_off + stub_size - 1) & -stub_align) - (stub_off & -stub_align)
11114 > ((stub_size - 1) & -stub_align))
11115 return stub_align - (stub_off & (stub_align - 1));
11116 return 0;
11117 }
11118
11119 /* Build a .plt call stub. */
11120
11121 static inline bfd_byte *
11122 build_plt_stub (struct ppc_link_hash_table *htab,
11123 struct ppc_stub_hash_entry *stub_entry,
11124 bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
11125 {
11126 bfd *obfd = htab->params->stub_bfd;
11127 bfd_boolean plt_load_toc = htab->opd_abi;
11128 bfd_boolean plt_static_chain = htab->params->plt_static_chain;
11129 bfd_boolean plt_thread_safe = (htab->params->plt_thread_safe
11130 && htab->elf.dynamic_sections_created
11131 && stub_entry->h != NULL
11132 && stub_entry->h->elf.dynindx != -1);
11133 bfd_boolean use_fake_dep = plt_thread_safe;
11134 bfd_vma cmp_branch_off = 0;
11135
11136 if (!ALWAYS_USE_FAKE_DEP
11137 && plt_load_toc
11138 && plt_thread_safe
11139 && !((stub_entry->h == htab->tls_get_addr_fd
11140 || stub_entry->h == htab->tls_get_addr)
11141 && htab->params->tls_get_addr_opt))
11142 {
11143 bfd_vma pltoff = stub_entry->plt_ent->plt.offset & ~1;
11144 bfd_vma pltindex = ((pltoff - PLT_INITIAL_ENTRY_SIZE (htab))
11145 / PLT_ENTRY_SIZE (htab));
11146 bfd_vma glinkoff = GLINK_PLTRESOLVE_SIZE (htab) + pltindex * 8;
11147 bfd_vma to, from;
11148
11149 if (pltindex > 32768)
11150 glinkoff += (pltindex - 32768) * 4;
11151 to = (glinkoff
11152 + htab->glink->output_offset
11153 + htab->glink->output_section->vma);
11154 from = (p - stub_entry->group->stub_sec->contents
11155 + 4 * (ALWAYS_EMIT_R2SAVE
11156 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
11157 + 4 * (PPC_HA (offset) != 0)
11158 + 4 * (PPC_HA (offset + 8 + 8 * plt_static_chain)
11159 != PPC_HA (offset))
11160 + 4 * (plt_static_chain != 0)
11161 + 20
11162 + stub_entry->group->stub_sec->output_offset
11163 + stub_entry->group->stub_sec->output_section->vma);
11164 cmp_branch_off = to - from;
11165 use_fake_dep = cmp_branch_off + (1 << 25) >= (1 << 26);
11166 }
11167
11168 if (PPC_HA (offset) != 0)
11169 {
11170 if (r != NULL)
11171 {
11172 if (ALWAYS_EMIT_R2SAVE
11173 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
11174 r[0].r_offset += 4;
11175 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
11176 r[1].r_offset = r[0].r_offset + 4;
11177 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
11178 r[1].r_addend = r[0].r_addend;
11179 if (plt_load_toc)
11180 {
11181 if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
11182 {
11183 r[2].r_offset = r[1].r_offset + 4;
11184 r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO);
11185 r[2].r_addend = r[0].r_addend;
11186 }
11187 else
11188 {
11189 r[2].r_offset = r[1].r_offset + 8 + 8 * use_fake_dep;
11190 r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
11191 r[2].r_addend = r[0].r_addend + 8;
11192 if (plt_static_chain)
11193 {
11194 r[3].r_offset = r[2].r_offset + 4;
11195 r[3].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
11196 r[3].r_addend = r[0].r_addend + 16;
11197 }
11198 }
11199 }
11200 }
11201 if (ALWAYS_EMIT_R2SAVE
11202 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
11203 bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p), p += 4;
11204 if (plt_load_toc)
11205 {
11206 bfd_put_32 (obfd, ADDIS_R11_R2 | PPC_HA (offset), p), p += 4;
11207 bfd_put_32 (obfd, LD_R12_0R11 | PPC_LO (offset), p), p += 4;
11208 }
11209 else
11210 {
11211 bfd_put_32 (obfd, ADDIS_R12_R2 | PPC_HA (offset), p), p += 4;
11212 bfd_put_32 (obfd, LD_R12_0R12 | PPC_LO (offset), p), p += 4;
11213 }
11214 if (plt_load_toc
11215 && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
11216 {
11217 bfd_put_32 (obfd, ADDI_R11_R11 | PPC_LO (offset), p), p += 4;
11218 offset = 0;
11219 }
11220 bfd_put_32 (obfd, MTCTR_R12, p), p += 4;
11221 if (plt_load_toc)
11222 {
11223 if (use_fake_dep)
11224 {
11225 bfd_put_32 (obfd, XOR_R2_R12_R12, p), p += 4;
11226 bfd_put_32 (obfd, ADD_R11_R11_R2, p), p += 4;
11227 }
11228 bfd_put_32 (obfd, LD_R2_0R11 | PPC_LO (offset + 8), p), p += 4;
11229 if (plt_static_chain)
11230 bfd_put_32 (obfd, LD_R11_0R11 | PPC_LO (offset + 16), p), p += 4;
11231 }
11232 }
11233 else
11234 {
11235 if (r != NULL)
11236 {
11237 if (ALWAYS_EMIT_R2SAVE
11238 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
11239 r[0].r_offset += 4;
11240 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
11241 if (plt_load_toc)
11242 {
11243 if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
11244 {
11245 r[1].r_offset = r[0].r_offset + 4;
11246 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16);
11247 r[1].r_addend = r[0].r_addend;
11248 }
11249 else
11250 {
11251 r[1].r_offset = r[0].r_offset + 8 + 8 * use_fake_dep;
11252 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
11253 r[1].r_addend = r[0].r_addend + 8 + 8 * plt_static_chain;
11254 if (plt_static_chain)
11255 {
11256 r[2].r_offset = r[1].r_offset + 4;
11257 r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
11258 r[2].r_addend = r[0].r_addend + 8;
11259 }
11260 }
11261 }
11262 }
11263 if (ALWAYS_EMIT_R2SAVE
11264 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
11265 bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p), p += 4;
11266 bfd_put_32 (obfd, LD_R12_0R2 | PPC_LO (offset), p), p += 4;
11267 if (plt_load_toc
11268 && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
11269 {
11270 bfd_put_32 (obfd, ADDI_R2_R2 | PPC_LO (offset), p), p += 4;
11271 offset = 0;
11272 }
11273 bfd_put_32 (obfd, MTCTR_R12, p), p += 4;
11274 if (plt_load_toc)
11275 {
11276 if (use_fake_dep)
11277 {
11278 bfd_put_32 (obfd, XOR_R11_R12_R12, p), p += 4;
11279 bfd_put_32 (obfd, ADD_R2_R2_R11, p), p += 4;
11280 }
11281 if (plt_static_chain)
11282 bfd_put_32 (obfd, LD_R11_0R2 | PPC_LO (offset + 16), p), p += 4;
11283 bfd_put_32 (obfd, LD_R2_0R2 | PPC_LO (offset + 8), p), p += 4;
11284 }
11285 }
11286 if (plt_load_toc && plt_thread_safe && !use_fake_dep)
11287 {
11288 bfd_put_32 (obfd, CMPLDI_R2_0, p), p += 4;
11289 bfd_put_32 (obfd, BNECTR_P4, p), p += 4;
11290 bfd_put_32 (obfd, B_DOT | (cmp_branch_off & 0x3fffffc), p), p += 4;
11291 }
11292 else
11293 bfd_put_32 (obfd, BCTR, p), p += 4;
11294 return p;
11295 }
11296
11297 /* Build a special .plt call stub for __tls_get_addr. */
11298
11299 #define LD_R11_0R3 0xe9630000
11300 #define LD_R12_0R3 0xe9830000
11301 #define MR_R0_R3 0x7c601b78
11302 #define CMPDI_R11_0 0x2c2b0000
11303 #define ADD_R3_R12_R13 0x7c6c6a14
11304 #define BEQLR 0x4d820020
11305 #define MR_R3_R0 0x7c030378
11306 #define STD_R11_0R1 0xf9610000
11307 #define BCTRL 0x4e800421
11308 #define LD_R11_0R1 0xe9610000
11309 #define MTLR_R11 0x7d6803a6
11310
11311 static inline bfd_byte *
11312 build_tls_get_addr_stub (struct ppc_link_hash_table *htab,
11313 struct ppc_stub_hash_entry *stub_entry,
11314 bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
11315 {
11316 bfd *obfd = htab->params->stub_bfd;
11317 bfd_byte *loc = p;
11318
11319 bfd_put_32 (obfd, LD_R11_0R3 + 0, p), p += 4;
11320 bfd_put_32 (obfd, LD_R12_0R3 + 8, p), p += 4;
11321 bfd_put_32 (obfd, MR_R0_R3, p), p += 4;
11322 bfd_put_32 (obfd, CMPDI_R11_0, p), p += 4;
11323 bfd_put_32 (obfd, ADD_R3_R12_R13, p), p += 4;
11324 bfd_put_32 (obfd, BEQLR, p), p += 4;
11325 bfd_put_32 (obfd, MR_R3_R0, p), p += 4;
11326 if (r != NULL)
11327 r[0].r_offset += 7 * 4;
11328 if (stub_entry->stub_type != ppc_stub_plt_call_r2save)
11329 return build_plt_stub (htab, stub_entry, p, offset, r);
11330
11331 bfd_put_32 (obfd, MFLR_R11, p), p += 4;
11332 bfd_put_32 (obfd, STD_R11_0R1 + STK_LINKER (htab), p), p += 4;
11333
11334 if (r != NULL)
11335 r[0].r_offset += 2 * 4;
11336 p = build_plt_stub (htab, stub_entry, p, offset, r);
11337 bfd_put_32 (obfd, BCTRL, p - 4);
11338
11339 bfd_put_32 (obfd, LD_R2_0R1 + STK_TOC (htab), p), p += 4;
11340 bfd_put_32 (obfd, LD_R11_0R1 + STK_LINKER (htab), p), p += 4;
11341 bfd_put_32 (obfd, MTLR_R11, p), p += 4;
11342 bfd_put_32 (obfd, BLR, p), p += 4;
11343
11344 if (htab->glink_eh_frame != NULL
11345 && htab->glink_eh_frame->size != 0)
11346 {
11347 bfd_byte *base, *eh;
11348 unsigned int lr_used, delta;
11349
11350 base = htab->glink_eh_frame->contents + stub_entry->group->eh_base + 17;
11351 eh = base + stub_entry->group->eh_size;
11352 lr_used = stub_entry->stub_offset + (p - 20 - loc);
11353 delta = lr_used - stub_entry->group->lr_restore;
11354 stub_entry->group->lr_restore = lr_used + 16;
11355 eh = eh_advance (htab->elf.dynobj, eh, delta);
11356 *eh++ = DW_CFA_offset_extended_sf;
11357 *eh++ = 65;
11358 *eh++ = -(STK_LINKER (htab) / 8) & 0x7f;
11359 *eh++ = DW_CFA_advance_loc + 4;
11360 *eh++ = DW_CFA_restore_extended;
11361 *eh++ = 65;
11362 stub_entry->group->eh_size = eh - base;
11363 }
11364 return p;
11365 }
11366
11367 static Elf_Internal_Rela *
11368 get_relocs (asection *sec, int count)
11369 {
11370 Elf_Internal_Rela *relocs;
11371 struct bfd_elf_section_data *elfsec_data;
11372
11373 elfsec_data = elf_section_data (sec);
11374 relocs = elfsec_data->relocs;
11375 if (relocs == NULL)
11376 {
11377 bfd_size_type relsize;
11378 relsize = sec->reloc_count * sizeof (*relocs);
11379 relocs = bfd_alloc (sec->owner, relsize);
11380 if (relocs == NULL)
11381 return NULL;
11382 elfsec_data->relocs = relocs;
11383 elfsec_data->rela.hdr = bfd_zalloc (sec->owner,
11384 sizeof (Elf_Internal_Shdr));
11385 if (elfsec_data->rela.hdr == NULL)
11386 return NULL;
11387 elfsec_data->rela.hdr->sh_size = (sec->reloc_count
11388 * sizeof (Elf64_External_Rela));
11389 elfsec_data->rela.hdr->sh_entsize = sizeof (Elf64_External_Rela);
11390 sec->reloc_count = 0;
11391 }
11392 relocs += sec->reloc_count;
11393 sec->reloc_count += count;
11394 return relocs;
11395 }
11396
11397 static bfd_vma
11398 get_r2off (struct bfd_link_info *info,
11399 struct ppc_stub_hash_entry *stub_entry)
11400 {
11401 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11402 bfd_vma r2off = htab->sec_info[stub_entry->target_section->id].toc_off;
11403
11404 if (r2off == 0)
11405 {
11406 /* Support linking -R objects. Get the toc pointer from the
11407 opd entry. */
11408 char buf[8];
11409 if (!htab->opd_abi)
11410 return r2off;
11411 asection *opd = stub_entry->h->elf.root.u.def.section;
11412 bfd_vma opd_off = stub_entry->h->elf.root.u.def.value;
11413
11414 if (strcmp (opd->name, ".opd") != 0
11415 || opd->reloc_count != 0)
11416 {
11417 info->callbacks->einfo (_("%P: cannot find opd entry toc for `%pT'\n"),
11418 stub_entry->h->elf.root.root.string);
11419 bfd_set_error (bfd_error_bad_value);
11420 return (bfd_vma) -1;
11421 }
11422 if (!bfd_get_section_contents (opd->owner, opd, buf, opd_off + 8, 8))
11423 return (bfd_vma) -1;
11424 r2off = bfd_get_64 (opd->owner, buf);
11425 r2off -= elf_gp (info->output_bfd);
11426 }
11427 r2off -= htab->sec_info[stub_entry->group->link_sec->id].toc_off;
11428 return r2off;
11429 }
11430
11431 static bfd_boolean
11432 ppc_build_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
11433 {
11434 struct ppc_stub_hash_entry *stub_entry;
11435 struct ppc_branch_hash_entry *br_entry;
11436 struct bfd_link_info *info;
11437 struct ppc_link_hash_table *htab;
11438 bfd_byte *loc;
11439 bfd_byte *p;
11440 bfd_vma targ, off;
11441 Elf_Internal_Rela *r;
11442 asection *plt;
11443
11444 /* Massage our args to the form they really have. */
11445 stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
11446 info = in_arg;
11447
11448 htab = ppc_hash_table (info);
11449 if (htab == NULL)
11450 return FALSE;
11451
11452 BFD_ASSERT (stub_entry->stub_offset >= stub_entry->group->stub_sec->size);
11453 loc = stub_entry->group->stub_sec->contents + stub_entry->stub_offset;
11454
11455 htab->stub_count[stub_entry->stub_type - 1] += 1;
11456 switch (stub_entry->stub_type)
11457 {
11458 case ppc_stub_long_branch:
11459 case ppc_stub_long_branch_r2off:
11460 /* Branches are relative. This is where we are going to. */
11461 targ = (stub_entry->target_value
11462 + stub_entry->target_section->output_offset
11463 + stub_entry->target_section->output_section->vma);
11464 targ += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
11465
11466 /* And this is where we are coming from. */
11467 off = (stub_entry->stub_offset
11468 + stub_entry->group->stub_sec->output_offset
11469 + stub_entry->group->stub_sec->output_section->vma);
11470 off = targ - off;
11471
11472 p = loc;
11473 if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
11474 {
11475 bfd_vma r2off = get_r2off (info, stub_entry);
11476
11477 if (r2off == (bfd_vma) -1)
11478 {
11479 htab->stub_error = TRUE;
11480 return FALSE;
11481 }
11482 bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), p);
11483 p += 4;
11484 if (PPC_HA (r2off) != 0)
11485 {
11486 bfd_put_32 (htab->params->stub_bfd,
11487 ADDIS_R2_R2 | PPC_HA (r2off), p);
11488 p += 4;
11489 }
11490 if (PPC_LO (r2off) != 0)
11491 {
11492 bfd_put_32 (htab->params->stub_bfd,
11493 ADDI_R2_R2 | PPC_LO (r2off), p);
11494 p += 4;
11495 }
11496 off -= p - loc;
11497 }
11498 bfd_put_32 (htab->params->stub_bfd, B_DOT | (off & 0x3fffffc), p);
11499 p += 4;
11500
11501 if (off + (1 << 25) >= (bfd_vma) (1 << 26))
11502 {
11503 _bfd_error_handler
11504 (_("long branch stub `%s' offset overflow"),
11505 stub_entry->root.string);
11506 htab->stub_error = TRUE;
11507 return FALSE;
11508 }
11509
11510 if (info->emitrelocations)
11511 {
11512 r = get_relocs (stub_entry->group->stub_sec, 1);
11513 if (r == NULL)
11514 return FALSE;
11515 r->r_offset = p - 4 - stub_entry->group->stub_sec->contents;
11516 r->r_info = ELF64_R_INFO (0, R_PPC64_REL24);
11517 r->r_addend = targ;
11518 if (stub_entry->h != NULL)
11519 {
11520 struct elf_link_hash_entry **hashes;
11521 unsigned long symndx;
11522 struct ppc_link_hash_entry *h;
11523
11524 hashes = elf_sym_hashes (htab->params->stub_bfd);
11525 if (hashes == NULL)
11526 {
11527 bfd_size_type hsize;
11528
11529 hsize = (htab->stub_globals + 1) * sizeof (*hashes);
11530 hashes = bfd_zalloc (htab->params->stub_bfd, hsize);
11531 if (hashes == NULL)
11532 return FALSE;
11533 elf_sym_hashes (htab->params->stub_bfd) = hashes;
11534 htab->stub_globals = 1;
11535 }
11536 symndx = htab->stub_globals++;
11537 h = stub_entry->h;
11538 hashes[symndx] = &h->elf;
11539 r->r_info = ELF64_R_INFO (symndx, R_PPC64_REL24);
11540 if (h->oh != NULL && h->oh->is_func)
11541 h = ppc_follow_link (h->oh);
11542 if (h->elf.root.u.def.section != stub_entry->target_section)
11543 /* H is an opd symbol. The addend must be zero. */
11544 r->r_addend = 0;
11545 else
11546 {
11547 off = (h->elf.root.u.def.value
11548 + h->elf.root.u.def.section->output_offset
11549 + h->elf.root.u.def.section->output_section->vma);
11550 r->r_addend -= off;
11551 }
11552 }
11553 }
11554 break;
11555
11556 case ppc_stub_plt_branch:
11557 case ppc_stub_plt_branch_r2off:
11558 br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
11559 stub_entry->root.string + 9,
11560 FALSE, FALSE);
11561 if (br_entry == NULL)
11562 {
11563 _bfd_error_handler (_("can't find branch stub `%s'"),
11564 stub_entry->root.string);
11565 htab->stub_error = TRUE;
11566 return FALSE;
11567 }
11568
11569 targ = (stub_entry->target_value
11570 + stub_entry->target_section->output_offset
11571 + stub_entry->target_section->output_section->vma);
11572 if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
11573 targ += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
11574
11575 bfd_put_64 (htab->brlt->owner, targ,
11576 htab->brlt->contents + br_entry->offset);
11577
11578 if (br_entry->iter == htab->stub_iteration)
11579 {
11580 br_entry->iter = 0;
11581
11582 if (htab->relbrlt != NULL)
11583 {
11584 /* Create a reloc for the branch lookup table entry. */
11585 Elf_Internal_Rela rela;
11586 bfd_byte *rl;
11587
11588 rela.r_offset = (br_entry->offset
11589 + htab->brlt->output_offset
11590 + htab->brlt->output_section->vma);
11591 rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
11592 rela.r_addend = targ;
11593
11594 rl = htab->relbrlt->contents;
11595 rl += (htab->relbrlt->reloc_count++
11596 * sizeof (Elf64_External_Rela));
11597 bfd_elf64_swap_reloca_out (htab->relbrlt->owner, &rela, rl);
11598 }
11599 else if (info->emitrelocations)
11600 {
11601 r = get_relocs (htab->brlt, 1);
11602 if (r == NULL)
11603 return FALSE;
11604 /* brlt, being SEC_LINKER_CREATED does not go through the
11605 normal reloc processing. Symbols and offsets are not
11606 translated from input file to output file form, so
11607 set up the offset per the output file. */
11608 r->r_offset = (br_entry->offset
11609 + htab->brlt->output_offset
11610 + htab->brlt->output_section->vma);
11611 r->r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
11612 r->r_addend = targ;
11613 }
11614 }
11615
11616 targ = (br_entry->offset
11617 + htab->brlt->output_offset
11618 + htab->brlt->output_section->vma);
11619
11620 off = (elf_gp (info->output_bfd)
11621 + htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11622 off = targ - off;
11623
11624 if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
11625 {
11626 info->callbacks->einfo
11627 (_("%P: linkage table error against `%pT'\n"),
11628 stub_entry->root.string);
11629 bfd_set_error (bfd_error_bad_value);
11630 htab->stub_error = TRUE;
11631 return FALSE;
11632 }
11633
11634 if (info->emitrelocations)
11635 {
11636 r = get_relocs (stub_entry->group->stub_sec, 1 + (PPC_HA (off) != 0));
11637 if (r == NULL)
11638 return FALSE;
11639 r[0].r_offset = loc - stub_entry->group->stub_sec->contents;
11640 if (bfd_big_endian (info->output_bfd))
11641 r[0].r_offset += 2;
11642 if (stub_entry->stub_type == ppc_stub_plt_branch_r2off)
11643 r[0].r_offset += 4;
11644 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
11645 r[0].r_addend = targ;
11646 if (PPC_HA (off) != 0)
11647 {
11648 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
11649 r[1].r_offset = r[0].r_offset + 4;
11650 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
11651 r[1].r_addend = r[0].r_addend;
11652 }
11653 }
11654
11655 p = loc;
11656 if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
11657 {
11658 if (PPC_HA (off) != 0)
11659 {
11660 bfd_put_32 (htab->params->stub_bfd,
11661 ADDIS_R12_R2 | PPC_HA (off), p);
11662 p += 4;
11663 bfd_put_32 (htab->params->stub_bfd,
11664 LD_R12_0R12 | PPC_LO (off), p);
11665 }
11666 else
11667 bfd_put_32 (htab->params->stub_bfd,
11668 LD_R12_0R2 | PPC_LO (off), p);
11669 }
11670 else
11671 {
11672 bfd_vma r2off = get_r2off (info, stub_entry);
11673
11674 if (r2off == (bfd_vma) -1)
11675 {
11676 htab->stub_error = TRUE;
11677 return FALSE;
11678 }
11679
11680 bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), p);
11681 p += 4;
11682 if (PPC_HA (off) != 0)
11683 {
11684 bfd_put_32 (htab->params->stub_bfd,
11685 ADDIS_R12_R2 | PPC_HA (off), p);
11686 p += 4;
11687 bfd_put_32 (htab->params->stub_bfd,
11688 LD_R12_0R12 | PPC_LO (off), p);
11689 }
11690 else
11691 bfd_put_32 (htab->params->stub_bfd, LD_R12_0R2 | PPC_LO (off), p);
11692
11693 if (PPC_HA (r2off) != 0)
11694 {
11695 p += 4;
11696 bfd_put_32 (htab->params->stub_bfd,
11697 ADDIS_R2_R2 | PPC_HA (r2off), p);
11698 }
11699 if (PPC_LO (r2off) != 0)
11700 {
11701 p += 4;
11702 bfd_put_32 (htab->params->stub_bfd,
11703 ADDI_R2_R2 | PPC_LO (r2off), p);
11704 }
11705 }
11706 p += 4;
11707 bfd_put_32 (htab->params->stub_bfd, MTCTR_R12, p);
11708 p += 4;
11709 bfd_put_32 (htab->params->stub_bfd, BCTR, p);
11710 p += 4;
11711 break;
11712
11713 case ppc_stub_long_branch_notoc:
11714 case ppc_stub_long_branch_both:
11715 case ppc_stub_plt_branch_notoc:
11716 case ppc_stub_plt_branch_both:
11717 case ppc_stub_plt_call_notoc:
11718 case ppc_stub_plt_call_both:
11719 p = loc;
11720 off = (8 + stub_entry->stub_offset
11721 + stub_entry->group->stub_sec->output_offset
11722 + stub_entry->group->stub_sec->output_section->vma);
11723 if (stub_entry->stub_type == ppc_stub_long_branch_both
11724 || stub_entry->stub_type == ppc_stub_plt_branch_both
11725 || stub_entry->stub_type == ppc_stub_plt_call_both)
11726 {
11727 off += 4;
11728 bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), p);
11729 p += 4;
11730 }
11731 if (stub_entry->stub_type >= ppc_stub_plt_call_notoc)
11732 {
11733 targ = stub_entry->plt_ent->plt.offset & ~1;
11734 if (targ >= (bfd_vma) -2)
11735 abort ();
11736
11737 plt = htab->elf.splt;
11738 if (!htab->elf.dynamic_sections_created
11739 || stub_entry->h == NULL
11740 || stub_entry->h->elf.dynindx == -1)
11741 {
11742 if (stub_entry->symtype == STT_GNU_IFUNC)
11743 plt = htab->elf.iplt;
11744 else
11745 plt = htab->pltlocal;
11746 }
11747 targ += plt->output_offset + plt->output_section->vma;
11748 }
11749 else
11750 targ = (stub_entry->target_value
11751 + stub_entry->target_section->output_offset
11752 + stub_entry->target_section->output_section->vma);
11753 off = targ - off;
11754 bfd_put_32 (htab->params->stub_bfd, MFLR_R12, p);
11755 p += 4;
11756 bfd_put_32 (htab->params->stub_bfd, BCL_20_31, p);
11757 p += 4;
11758 bfd_put_32 (htab->params->stub_bfd, MFLR_R11, p);
11759 p += 4;
11760 bfd_put_32 (htab->params->stub_bfd, MTLR_R12, p);
11761 p += 4;
11762 p = build_offset (htab->params->stub_bfd, p, off,
11763 stub_entry->stub_type >= ppc_stub_plt_call_notoc);
11764 if (stub_entry->stub_type == ppc_stub_long_branch_notoc)
11765 {
11766 off += 8;
11767 bfd_put_32 (htab->params->stub_bfd,
11768 B_DOT | ((off - (p - loc)) & 0x3fffffc), p);
11769 }
11770 else if (stub_entry->stub_type == ppc_stub_long_branch_both)
11771 {
11772 off += 12;
11773 bfd_put_32 (htab->params->stub_bfd,
11774 B_DOT | ((off - (p - loc)) & 0x3fffffc), p);
11775 }
11776 else
11777 {
11778 bfd_put_32 (htab->params->stub_bfd, MTCTR_R12, p);
11779 p += 4;
11780 bfd_put_32 (htab->params->stub_bfd, BCTR, p);
11781 }
11782 p += 4;
11783
11784 if (htab->glink_eh_frame != NULL
11785 && htab->glink_eh_frame->size != 0)
11786 {
11787 bfd_byte *base, *eh;
11788 unsigned int lr_used, delta;
11789
11790 base = (htab->glink_eh_frame->contents
11791 + stub_entry->group->eh_base + 17);
11792 eh = base + stub_entry->group->eh_size;
11793 lr_used = stub_entry->stub_offset + 8;
11794 if (stub_entry->stub_type == ppc_stub_long_branch_both
11795 || stub_entry->stub_type == ppc_stub_plt_branch_both
11796 || stub_entry->stub_type == ppc_stub_plt_call_both)
11797 lr_used += 4;
11798 delta = lr_used - stub_entry->group->lr_restore;
11799 stub_entry->group->lr_restore = lr_used + 8;
11800 eh = eh_advance (htab->elf.dynobj, eh, delta);
11801 *eh++ = DW_CFA_register;
11802 *eh++ = 65;
11803 *eh++ = 12;
11804 *eh++ = DW_CFA_advance_loc + 2;
11805 *eh++ = DW_CFA_restore_extended;
11806 *eh++ = 65;
11807 stub_entry->group->eh_size = eh - base;
11808 }
11809 break;
11810
11811 case ppc_stub_plt_call:
11812 case ppc_stub_plt_call_r2save:
11813 if (stub_entry->h != NULL
11814 && stub_entry->h->is_func_descriptor
11815 && stub_entry->h->oh != NULL)
11816 {
11817 struct ppc_link_hash_entry *fh = ppc_follow_link (stub_entry->h->oh);
11818
11819 /* If the old-ABI "dot-symbol" is undefined make it weak so
11820 we don't get a link error from RELOC_FOR_GLOBAL_SYMBOL. */
11821 if (fh->elf.root.type == bfd_link_hash_undefined
11822 && (stub_entry->h->elf.root.type == bfd_link_hash_defined
11823 || stub_entry->h->elf.root.type == bfd_link_hash_defweak))
11824 fh->elf.root.type = bfd_link_hash_undefweak;
11825 }
11826
11827 /* Now build the stub. */
11828 targ = stub_entry->plt_ent->plt.offset & ~1;
11829 if (targ >= (bfd_vma) -2)
11830 abort ();
11831
11832 plt = htab->elf.splt;
11833 if (!htab->elf.dynamic_sections_created
11834 || stub_entry->h == NULL
11835 || stub_entry->h->elf.dynindx == -1)
11836 {
11837 if (stub_entry->symtype == STT_GNU_IFUNC)
11838 plt = htab->elf.iplt;
11839 else
11840 plt = htab->pltlocal;
11841 }
11842 targ += plt->output_offset + plt->output_section->vma;
11843
11844 off = (elf_gp (info->output_bfd)
11845 + htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11846 off = targ - off;
11847
11848 if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
11849 {
11850 info->callbacks->einfo
11851 /* xgettext:c-format */
11852 (_("%P: linkage table error against `%pT'\n"),
11853 stub_entry->h != NULL
11854 ? stub_entry->h->elf.root.root.string
11855 : "<local sym>");
11856 bfd_set_error (bfd_error_bad_value);
11857 htab->stub_error = TRUE;
11858 return FALSE;
11859 }
11860
11861 r = NULL;
11862 if (info->emitrelocations)
11863 {
11864 r = get_relocs (stub_entry->group->stub_sec,
11865 ((PPC_HA (off) != 0)
11866 + (htab->opd_abi
11867 ? 2 + (htab->params->plt_static_chain
11868 && PPC_HA (off + 16) == PPC_HA (off))
11869 : 1)));
11870 if (r == NULL)
11871 return FALSE;
11872 r[0].r_offset = loc - stub_entry->group->stub_sec->contents;
11873 if (bfd_big_endian (info->output_bfd))
11874 r[0].r_offset += 2;
11875 r[0].r_addend = targ;
11876 }
11877 if (stub_entry->h != NULL
11878 && (stub_entry->h == htab->tls_get_addr_fd
11879 || stub_entry->h == htab->tls_get_addr)
11880 && htab->params->tls_get_addr_opt)
11881 p = build_tls_get_addr_stub (htab, stub_entry, loc, off, r);
11882 else
11883 p = build_plt_stub (htab, stub_entry, loc, off, r);
11884 break;
11885
11886 case ppc_stub_save_res:
11887 return TRUE;
11888
11889 default:
11890 BFD_FAIL ();
11891 return FALSE;
11892 }
11893
11894 stub_entry->group->stub_sec->size = stub_entry->stub_offset + (p - loc);
11895
11896 if (htab->params->emit_stub_syms)
11897 {
11898 struct elf_link_hash_entry *h;
11899 size_t len1, len2;
11900 char *name;
11901 const char *const stub_str[] = { "long_branch",
11902 "long_branch",
11903 "long_branch",
11904 "long_branch",
11905 "plt_branch",
11906 "plt_branch",
11907 "plt_branch",
11908 "plt_branch",
11909 "plt_call",
11910 "plt_call",
11911 "plt_call",
11912 "plt_call" };
11913
11914 len1 = strlen (stub_str[stub_entry->stub_type - 1]);
11915 len2 = strlen (stub_entry->root.string);
11916 name = bfd_malloc (len1 + len2 + 2);
11917 if (name == NULL)
11918 return FALSE;
11919 memcpy (name, stub_entry->root.string, 9);
11920 memcpy (name + 9, stub_str[stub_entry->stub_type - 1], len1);
11921 memcpy (name + len1 + 9, stub_entry->root.string + 8, len2 - 8 + 1);
11922 h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
11923 if (h == NULL)
11924 return FALSE;
11925 if (h->root.type == bfd_link_hash_new)
11926 {
11927 h->root.type = bfd_link_hash_defined;
11928 h->root.u.def.section = stub_entry->group->stub_sec;
11929 h->root.u.def.value = stub_entry->stub_offset;
11930 h->ref_regular = 1;
11931 h->def_regular = 1;
11932 h->ref_regular_nonweak = 1;
11933 h->forced_local = 1;
11934 h->non_elf = 0;
11935 h->root.linker_def = 1;
11936 }
11937 }
11938
11939 return TRUE;
11940 }
11941
11942 /* As above, but don't actually build the stub. Just bump offset so
11943 we know stub section sizes, and select plt_branch stubs where
11944 long_branch stubs won't do. */
11945
11946 static bfd_boolean
11947 ppc_size_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
11948 {
11949 struct ppc_stub_hash_entry *stub_entry;
11950 struct bfd_link_info *info;
11951 struct ppc_link_hash_table *htab;
11952 bfd_vma targ, off;
11953 int size;
11954
11955 /* Massage our args to the form they really have. */
11956 stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
11957 info = in_arg;
11958
11959 htab = ppc_hash_table (info);
11960 if (htab == NULL)
11961 return FALSE;
11962
11963 /* Make a note of the offset within the stubs for this entry. */
11964 stub_entry->stub_offset = stub_entry->group->stub_sec->size;
11965
11966 if (stub_entry->h != NULL
11967 && stub_entry->h->save_res
11968 && stub_entry->h->elf.root.type == bfd_link_hash_defined
11969 && stub_entry->h->elf.root.u.def.section == htab->sfpr)
11970 {
11971 /* Don't make stubs to out-of-line register save/restore
11972 functions. Instead, emit copies of the functions. */
11973 stub_entry->group->needs_save_res = 1;
11974 stub_entry->stub_type = ppc_stub_save_res;
11975 return TRUE;
11976 }
11977
11978 if (stub_entry->stub_type >= ppc_stub_plt_call
11979 && stub_entry->stub_type <= ppc_stub_plt_call_both)
11980 {
11981 asection *plt;
11982 targ = stub_entry->plt_ent->plt.offset & ~(bfd_vma) 1;
11983 if (targ >= (bfd_vma) -2)
11984 abort ();
11985 plt = htab->elf.splt;
11986 if (!htab->elf.dynamic_sections_created
11987 || stub_entry->h == NULL
11988 || stub_entry->h->elf.dynindx == -1)
11989 {
11990 if (stub_entry->symtype == STT_GNU_IFUNC)
11991 plt = htab->elf.iplt;
11992 else
11993 plt = htab->pltlocal;
11994 }
11995 targ += plt->output_offset + plt->output_section->vma;
11996
11997 if (stub_entry->stub_type >= ppc_stub_plt_call_notoc)
11998 {
11999 off = (8 + stub_entry->stub_offset
12000 + stub_entry->group->stub_sec->output_offset
12001 + stub_entry->group->stub_sec->output_section->vma);
12002 if (stub_entry->stub_type > ppc_stub_plt_call_notoc)
12003 off += 4;
12004 }
12005 else
12006 off = (elf_gp (info->output_bfd)
12007 + htab->sec_info[stub_entry->group->link_sec->id].toc_off);
12008
12009 if (htab->params->plt_stub_align != 0)
12010 {
12011 unsigned pad = plt_stub_pad (htab, stub_entry, targ - off);
12012
12013 stub_entry->group->stub_sec->size += pad;
12014 stub_entry->stub_offset = stub_entry->group->stub_sec->size;
12015 if (stub_entry->stub_type >= ppc_stub_plt_call_notoc)
12016 off += pad;
12017 }
12018
12019 off = targ - off;
12020 size = plt_stub_size (htab, stub_entry, off);
12021
12022 if (stub_entry->stub_type >= ppc_stub_plt_call_notoc)
12023 {
12024 /* After the bcl, lr has been modified so we need to emit
12025 .eh_frame info saying the return address is in r12. */
12026 unsigned int lr_used = stub_entry->stub_offset + 8;
12027 unsigned int delta;
12028 if (stub_entry->stub_type > ppc_stub_plt_call_notoc)
12029 lr_used += 4;
12030 /* The eh_frame info will consist of a DW_CFA_advance_loc or
12031 variant, DW_CFA_register, 65, 12, DW_CFA_advance_loc+2,
12032 DW_CFA_restore_extended 65. */
12033 delta = lr_used - stub_entry->group->lr_restore;
12034 stub_entry->group->eh_size += eh_advance_size (delta) + 6;
12035 stub_entry->group->lr_restore = lr_used + 8;
12036 }
12037 else
12038 {
12039 if (stub_entry->h != NULL
12040 && (stub_entry->h == htab->tls_get_addr_fd
12041 || stub_entry->h == htab->tls_get_addr)
12042 && htab->params->tls_get_addr_opt
12043 && stub_entry->stub_type == ppc_stub_plt_call_r2save)
12044 {
12045 /* After the bctrl, lr has been modified so we need to
12046 emit .eh_frame info saying the return address is
12047 on the stack. In fact we put the EH info specifying
12048 that the return address is on the stack *at* the
12049 call rather than after it, because the EH info for a
12050 call needs to be specified by that point.
12051 See libgcc/unwind-dw2.c execute_cfa_program. */
12052 unsigned int lr_used = stub_entry->stub_offset + size - 20;
12053 unsigned int delta;
12054 /* The eh_frame info will consist of a DW_CFA_advance_loc
12055 or variant, DW_CFA_offset_externed_sf, 65, -stackoff,
12056 DW_CFA_advance_loc+4, DW_CFA_restore_extended, 65. */
12057 delta = lr_used - stub_entry->group->lr_restore;
12058 stub_entry->group->eh_size += eh_advance_size (delta) + 6;
12059 stub_entry->group->lr_restore = size - 4;
12060 }
12061
12062 if (info->emitrelocations)
12063 {
12064 stub_entry->group->stub_sec->reloc_count
12065 += ((PPC_HA (off) != 0)
12066 + (htab->opd_abi
12067 ? 2 + (htab->params->plt_static_chain
12068 && PPC_HA (off + 16) == PPC_HA (off))
12069 : 1));
12070 stub_entry->group->stub_sec->flags |= SEC_RELOC;
12071 }
12072 }
12073 }
12074 else
12075 {
12076 /* ppc_stub_long_branch or ppc_stub_plt_branch, or their r2off
12077 variants. */
12078 bfd_vma r2off = 0;
12079 bfd_vma local_off = 0;
12080
12081 targ = (stub_entry->target_value
12082 + stub_entry->target_section->output_offset
12083 + stub_entry->target_section->output_section->vma);
12084 off = (stub_entry->stub_offset
12085 + stub_entry->group->stub_sec->output_offset
12086 + stub_entry->group->stub_sec->output_section->vma);
12087
12088 /* Reset the stub type from the plt variant in case we now
12089 can reach with a shorter stub. */
12090 if (stub_entry->stub_type >= ppc_stub_plt_branch)
12091 stub_entry->stub_type += ppc_stub_long_branch - ppc_stub_plt_branch;
12092
12093 size = 4;
12094 if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
12095 {
12096 r2off = get_r2off (info, stub_entry);
12097 if (r2off == (bfd_vma) -1)
12098 {
12099 htab->stub_error = TRUE;
12100 return FALSE;
12101 }
12102 size = 8;
12103 if (PPC_HA (r2off) != 0)
12104 size += 4;
12105 if (PPC_LO (r2off) != 0)
12106 size += 4;
12107 off += size - 4;
12108 }
12109 else if (stub_entry->stub_type >= ppc_stub_long_branch_notoc)
12110 {
12111 size = 20 + size_offset (targ - (off + 8));
12112 if (stub_entry->stub_type > ppc_stub_long_branch_notoc)
12113 size += 4;
12114 off += size - 4;
12115 }
12116 off = targ - off;
12117
12118 if (stub_entry->stub_type >= ppc_stub_long_branch_notoc)
12119 {
12120 /* After the bcl, lr has been modified so we need to emit
12121 .eh_frame info saying the return address is in r12. */
12122 unsigned int lr_used = stub_entry->stub_offset + 8;
12123 unsigned int delta;
12124 if (stub_entry->stub_type > ppc_stub_long_branch_notoc)
12125 lr_used += 4;
12126 /* The eh_frame info will consist of a DW_CFA_advance_loc or
12127 variant, DW_CFA_register, 65, 12, DW_CFA_advance_loc+2,
12128 DW_CFA_restore_extended 65. */
12129 delta = lr_used - stub_entry->group->lr_restore;
12130 stub_entry->group->eh_size += eh_advance_size (delta) + 6;
12131 stub_entry->group->lr_restore = lr_used + 8;
12132
12133 if (off + (1 << 25) >= (bfd_vma) (1 << 26))
12134 {
12135 stub_entry->stub_type += (ppc_stub_plt_branch_notoc
12136 - ppc_stub_long_branch_notoc);
12137 size += 4;
12138 }
12139 }
12140 else
12141 {
12142 local_off = PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
12143
12144 /* If the branch offset is too big, use a ppc_stub_plt_branch.
12145 Do the same for -R objects without function descriptors. */
12146 if ((stub_entry->stub_type == ppc_stub_long_branch_r2off
12147 && r2off == 0
12148 && htab->sec_info[stub_entry->target_section->id].toc_off == 0)
12149 || off + (1 << 25) >= (bfd_vma) (1 << 26) - local_off)
12150 {
12151 struct ppc_branch_hash_entry *br_entry;
12152
12153 br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
12154 stub_entry->root.string + 9,
12155 TRUE, FALSE);
12156 if (br_entry == NULL)
12157 {
12158 _bfd_error_handler (_("can't build branch stub `%s'"),
12159 stub_entry->root.string);
12160 htab->stub_error = TRUE;
12161 return FALSE;
12162 }
12163
12164 if (br_entry->iter != htab->stub_iteration)
12165 {
12166 br_entry->iter = htab->stub_iteration;
12167 br_entry->offset = htab->brlt->size;
12168 htab->brlt->size += 8;
12169
12170 if (htab->relbrlt != NULL)
12171 htab->relbrlt->size += sizeof (Elf64_External_Rela);
12172 else if (info->emitrelocations)
12173 {
12174 htab->brlt->reloc_count += 1;
12175 htab->brlt->flags |= SEC_RELOC;
12176 }
12177 }
12178
12179 targ = (br_entry->offset
12180 + htab->brlt->output_offset
12181 + htab->brlt->output_section->vma);
12182 off = (elf_gp (info->output_bfd)
12183 + htab->sec_info[stub_entry->group->link_sec->id].toc_off);
12184 off = targ - off;
12185
12186 if (info->emitrelocations)
12187 {
12188 stub_entry->group->stub_sec->reloc_count
12189 += 1 + (PPC_HA (off) != 0);
12190 stub_entry->group->stub_sec->flags |= SEC_RELOC;
12191 }
12192
12193 stub_entry->stub_type
12194 += ppc_stub_plt_branch - ppc_stub_long_branch;
12195 if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
12196 {
12197 size = 12;
12198 if (PPC_HA (off) != 0)
12199 size = 16;
12200 }
12201 else
12202 {
12203 size = 16;
12204 if (PPC_HA (off) != 0)
12205 size += 4;
12206
12207 if (PPC_HA (r2off) != 0)
12208 size += 4;
12209 if (PPC_LO (r2off) != 0)
12210 size += 4;
12211 }
12212 }
12213 else if (info->emitrelocations)
12214 {
12215 stub_entry->group->stub_sec->reloc_count += 1;
12216 stub_entry->group->stub_sec->flags |= SEC_RELOC;
12217 }
12218 }
12219 }
12220
12221 stub_entry->group->stub_sec->size += size;
12222 return TRUE;
12223 }
12224
12225 /* Set up various things so that we can make a list of input sections
12226 for each output section included in the link. Returns -1 on error,
12227 0 when no stubs will be needed, and 1 on success. */
12228
12229 int
12230 ppc64_elf_setup_section_lists (struct bfd_link_info *info)
12231 {
12232 unsigned int id;
12233 bfd_size_type amt;
12234 struct ppc_link_hash_table *htab = ppc_hash_table (info);
12235
12236 if (htab == NULL)
12237 return -1;
12238
12239 htab->sec_info_arr_size = _bfd_section_id;
12240 amt = sizeof (*htab->sec_info) * (htab->sec_info_arr_size);
12241 htab->sec_info = bfd_zmalloc (amt);
12242 if (htab->sec_info == NULL)
12243 return -1;
12244
12245 /* Set toc_off for com, und, abs and ind sections. */
12246 for (id = 0; id < 3; id++)
12247 htab->sec_info[id].toc_off = TOC_BASE_OFF;
12248
12249 return 1;
12250 }
12251
12252 /* Set up for first pass at multitoc partitioning. */
12253
12254 void
12255 ppc64_elf_start_multitoc_partition (struct bfd_link_info *info)
12256 {
12257 struct ppc_link_hash_table *htab = ppc_hash_table (info);
12258
12259 htab->toc_curr = ppc64_elf_set_toc (info, info->output_bfd);
12260 htab->toc_bfd = NULL;
12261 htab->toc_first_sec = NULL;
12262 }
12263
12264 /* The linker repeatedly calls this function for each TOC input section
12265 and linker generated GOT section. Group input bfds such that the toc
12266 within a group is less than 64k in size. */
12267
12268 bfd_boolean
12269 ppc64_elf_next_toc_section (struct bfd_link_info *info, asection *isec)
12270 {
12271 struct ppc_link_hash_table *htab = ppc_hash_table (info);
12272 bfd_vma addr, off, limit;
12273
12274 if (htab == NULL)
12275 return FALSE;
12276
12277 if (!htab->second_toc_pass)
12278 {
12279 /* Keep track of the first .toc or .got section for this input bfd. */
12280 bfd_boolean new_bfd = htab->toc_bfd != isec->owner;
12281
12282 if (new_bfd)
12283 {
12284 htab->toc_bfd = isec->owner;
12285 htab->toc_first_sec = isec;
12286 }
12287
12288 addr = isec->output_offset + isec->output_section->vma;
12289 off = addr - htab->toc_curr;
12290 limit = 0x80008000;
12291 if (ppc64_elf_tdata (isec->owner)->has_small_toc_reloc)
12292 limit = 0x10000;
12293 if (off + isec->size > limit)
12294 {
12295 addr = (htab->toc_first_sec->output_offset
12296 + htab->toc_first_sec->output_section->vma);
12297 htab->toc_curr = addr;
12298 htab->toc_curr &= -TOC_BASE_ALIGN;
12299 }
12300
12301 /* toc_curr is the base address of this toc group. Set elf_gp
12302 for the input section to be the offset relative to the
12303 output toc base plus 0x8000. Making the input elf_gp an
12304 offset allows us to move the toc as a whole without
12305 recalculating input elf_gp. */
12306 off = htab->toc_curr - elf_gp (info->output_bfd);
12307 off += TOC_BASE_OFF;
12308
12309 /* Die if someone uses a linker script that doesn't keep input
12310 file .toc and .got together. */
12311 if (new_bfd
12312 && elf_gp (isec->owner) != 0
12313 && elf_gp (isec->owner) != off)
12314 return FALSE;
12315
12316 elf_gp (isec->owner) = off;
12317 return TRUE;
12318 }
12319
12320 /* During the second pass toc_first_sec points to the start of
12321 a toc group, and toc_curr is used to track the old elf_gp.
12322 We use toc_bfd to ensure we only look at each bfd once. */
12323 if (htab->toc_bfd == isec->owner)
12324 return TRUE;
12325 htab->toc_bfd = isec->owner;
12326
12327 if (htab->toc_first_sec == NULL
12328 || htab->toc_curr != elf_gp (isec->owner))
12329 {
12330 htab->toc_curr = elf_gp (isec->owner);
12331 htab->toc_first_sec = isec;
12332 }
12333 addr = (htab->toc_first_sec->output_offset
12334 + htab->toc_first_sec->output_section->vma);
12335 off = addr - elf_gp (info->output_bfd) + TOC_BASE_OFF;
12336 elf_gp (isec->owner) = off;
12337
12338 return TRUE;
12339 }
12340
12341 /* Called via elf_link_hash_traverse to merge GOT entries for global
12342 symbol H. */
12343
12344 static bfd_boolean
12345 merge_global_got (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
12346 {
12347 if (h->root.type == bfd_link_hash_indirect)
12348 return TRUE;
12349
12350 merge_got_entries (&h->got.glist);
12351
12352 return TRUE;
12353 }
12354
12355 /* Called via elf_link_hash_traverse to allocate GOT entries for global
12356 symbol H. */
12357
12358 static bfd_boolean
12359 reallocate_got (struct elf_link_hash_entry *h, void *inf)
12360 {
12361 struct got_entry *gent;
12362
12363 if (h->root.type == bfd_link_hash_indirect)
12364 return TRUE;
12365
12366 for (gent = h->got.glist; gent != NULL; gent = gent->next)
12367 if (!gent->is_indirect)
12368 allocate_got (h, (struct bfd_link_info *) inf, gent);
12369 return TRUE;
12370 }
12371
12372 /* Called on the first multitoc pass after the last call to
12373 ppc64_elf_next_toc_section. This function removes duplicate GOT
12374 entries. */
12375
12376 bfd_boolean
12377 ppc64_elf_layout_multitoc (struct bfd_link_info *info)
12378 {
12379 struct ppc_link_hash_table *htab = ppc_hash_table (info);
12380 struct bfd *ibfd, *ibfd2;
12381 bfd_boolean done_something;
12382
12383 htab->multi_toc_needed = htab->toc_curr != elf_gp (info->output_bfd);
12384
12385 if (!htab->do_multi_toc)
12386 return FALSE;
12387
12388 /* Merge global sym got entries within a toc group. */
12389 elf_link_hash_traverse (&htab->elf, merge_global_got, info);
12390
12391 /* And tlsld_got. */
12392 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
12393 {
12394 struct got_entry *ent, *ent2;
12395
12396 if (!is_ppc64_elf (ibfd))
12397 continue;
12398
12399 ent = ppc64_tlsld_got (ibfd);
12400 if (!ent->is_indirect
12401 && ent->got.offset != (bfd_vma) -1)
12402 {
12403 for (ibfd2 = ibfd->link.next; ibfd2 != NULL; ibfd2 = ibfd2->link.next)
12404 {
12405 if (!is_ppc64_elf (ibfd2))
12406 continue;
12407
12408 ent2 = ppc64_tlsld_got (ibfd2);
12409 if (!ent2->is_indirect
12410 && ent2->got.offset != (bfd_vma) -1
12411 && elf_gp (ibfd2) == elf_gp (ibfd))
12412 {
12413 ent2->is_indirect = TRUE;
12414 ent2->got.ent = ent;
12415 }
12416 }
12417 }
12418 }
12419
12420 /* Zap sizes of got sections. */
12421 htab->elf.irelplt->rawsize = htab->elf.irelplt->size;
12422 htab->elf.irelplt->size -= htab->got_reli_size;
12423 htab->got_reli_size = 0;
12424
12425 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
12426 {
12427 asection *got, *relgot;
12428
12429 if (!is_ppc64_elf (ibfd))
12430 continue;
12431
12432 got = ppc64_elf_tdata (ibfd)->got;
12433 if (got != NULL)
12434 {
12435 got->rawsize = got->size;
12436 got->size = 0;
12437 relgot = ppc64_elf_tdata (ibfd)->relgot;
12438 relgot->rawsize = relgot->size;
12439 relgot->size = 0;
12440 }
12441 }
12442
12443 /* Now reallocate the got, local syms first. We don't need to
12444 allocate section contents again since we never increase size. */
12445 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
12446 {
12447 struct got_entry **lgot_ents;
12448 struct got_entry **end_lgot_ents;
12449 struct plt_entry **local_plt;
12450 struct plt_entry **end_local_plt;
12451 unsigned char *lgot_masks;
12452 bfd_size_type locsymcount;
12453 Elf_Internal_Shdr *symtab_hdr;
12454 asection *s;
12455
12456 if (!is_ppc64_elf (ibfd))
12457 continue;
12458
12459 lgot_ents = elf_local_got_ents (ibfd);
12460 if (!lgot_ents)
12461 continue;
12462
12463 symtab_hdr = &elf_symtab_hdr (ibfd);
12464 locsymcount = symtab_hdr->sh_info;
12465 end_lgot_ents = lgot_ents + locsymcount;
12466 local_plt = (struct plt_entry **) end_lgot_ents;
12467 end_local_plt = local_plt + locsymcount;
12468 lgot_masks = (unsigned char *) end_local_plt;
12469 s = ppc64_elf_tdata (ibfd)->got;
12470 for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
12471 {
12472 struct got_entry *ent;
12473
12474 for (ent = *lgot_ents; ent != NULL; ent = ent->next)
12475 {
12476 unsigned int ent_size = 8;
12477 unsigned int rel_size = sizeof (Elf64_External_Rela);
12478
12479 ent->got.offset = s->size;
12480 if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
12481 {
12482 ent_size *= 2;
12483 rel_size *= 2;
12484 }
12485 s->size += ent_size;
12486 if ((*lgot_masks & (TLS_TLS | PLT_IFUNC)) == PLT_IFUNC)
12487 {
12488 htab->elf.irelplt->size += rel_size;
12489 htab->got_reli_size += rel_size;
12490 }
12491 else if (bfd_link_pic (info)
12492 && !((ent->tls_type & TLS_TPREL) != 0
12493 && bfd_link_executable (info)))
12494 {
12495 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
12496 srel->size += rel_size;
12497 }
12498 }
12499 }
12500 }
12501
12502 elf_link_hash_traverse (&htab->elf, reallocate_got, info);
12503
12504 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
12505 {
12506 struct got_entry *ent;
12507
12508 if (!is_ppc64_elf (ibfd))
12509 continue;
12510
12511 ent = ppc64_tlsld_got (ibfd);
12512 if (!ent->is_indirect
12513 && ent->got.offset != (bfd_vma) -1)
12514 {
12515 asection *s = ppc64_elf_tdata (ibfd)->got;
12516 ent->got.offset = s->size;
12517 s->size += 16;
12518 if (bfd_link_pic (info))
12519 {
12520 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
12521 srel->size += sizeof (Elf64_External_Rela);
12522 }
12523 }
12524 }
12525
12526 done_something = htab->elf.irelplt->rawsize != htab->elf.irelplt->size;
12527 if (!done_something)
12528 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
12529 {
12530 asection *got;
12531
12532 if (!is_ppc64_elf (ibfd))
12533 continue;
12534
12535 got = ppc64_elf_tdata (ibfd)->got;
12536 if (got != NULL)
12537 {
12538 done_something = got->rawsize != got->size;
12539 if (done_something)
12540 break;
12541 }
12542 }
12543
12544 if (done_something)
12545 (*htab->params->layout_sections_again) ();
12546
12547 /* Set up for second pass over toc sections to recalculate elf_gp
12548 on input sections. */
12549 htab->toc_bfd = NULL;
12550 htab->toc_first_sec = NULL;
12551 htab->second_toc_pass = TRUE;
12552 return done_something;
12553 }
12554
12555 /* Called after second pass of multitoc partitioning. */
12556
12557 void
12558 ppc64_elf_finish_multitoc_partition (struct bfd_link_info *info)
12559 {
12560 struct ppc_link_hash_table *htab = ppc_hash_table (info);
12561
12562 /* After the second pass, toc_curr tracks the TOC offset used
12563 for code sections below in ppc64_elf_next_input_section. */
12564 htab->toc_curr = TOC_BASE_OFF;
12565 }
12566
12567 /* No toc references were found in ISEC. If the code in ISEC makes no
12568 calls, then there's no need to use toc adjusting stubs when branching
12569 into ISEC. Actually, indirect calls from ISEC are OK as they will
12570 load r2. Returns -1 on error, 0 for no stub needed, 1 for stub
12571 needed, and 2 if a cyclical call-graph was found but no other reason
12572 for a stub was detected. If called from the top level, a return of
12573 2 means the same as a return of 0. */
12574
12575 static int
12576 toc_adjusting_stub_needed (struct bfd_link_info *info, asection *isec)
12577 {
12578 int ret;
12579
12580 /* Mark this section as checked. */
12581 isec->call_check_done = 1;
12582
12583 /* We know none of our code bearing sections will need toc stubs. */
12584 if ((isec->flags & SEC_LINKER_CREATED) != 0)
12585 return 0;
12586
12587 if (isec->size == 0)
12588 return 0;
12589
12590 if (isec->output_section == NULL)
12591 return 0;
12592
12593 ret = 0;
12594 if (isec->reloc_count != 0)
12595 {
12596 Elf_Internal_Rela *relstart, *rel;
12597 Elf_Internal_Sym *local_syms;
12598 struct ppc_link_hash_table *htab;
12599
12600 relstart = _bfd_elf_link_read_relocs (isec->owner, isec, NULL, NULL,
12601 info->keep_memory);
12602 if (relstart == NULL)
12603 return -1;
12604
12605 /* Look for branches to outside of this section. */
12606 local_syms = NULL;
12607 htab = ppc_hash_table (info);
12608 if (htab == NULL)
12609 return -1;
12610
12611 for (rel = relstart; rel < relstart + isec->reloc_count; ++rel)
12612 {
12613 enum elf_ppc64_reloc_type r_type;
12614 unsigned long r_symndx;
12615 struct elf_link_hash_entry *h;
12616 struct ppc_link_hash_entry *eh;
12617 Elf_Internal_Sym *sym;
12618 asection *sym_sec;
12619 struct _opd_sec_data *opd;
12620 bfd_vma sym_value;
12621 bfd_vma dest;
12622
12623 r_type = ELF64_R_TYPE (rel->r_info);
12624 if (r_type != R_PPC64_REL24
12625 && r_type != R_PPC64_REL24_NOTOC
12626 && r_type != R_PPC64_REL14
12627 && r_type != R_PPC64_REL14_BRTAKEN
12628 && r_type != R_PPC64_REL14_BRNTAKEN
12629 && r_type != R_PPC64_PLTCALL)
12630 continue;
12631
12632 r_symndx = ELF64_R_SYM (rel->r_info);
12633 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms, r_symndx,
12634 isec->owner))
12635 {
12636 ret = -1;
12637 break;
12638 }
12639
12640 /* Calls to dynamic lib functions go through a plt call stub
12641 that uses r2. */
12642 eh = (struct ppc_link_hash_entry *) h;
12643 if (eh != NULL
12644 && (eh->elf.plt.plist != NULL
12645 || (eh->oh != NULL
12646 && ppc_follow_link (eh->oh)->elf.plt.plist != NULL)))
12647 {
12648 ret = 1;
12649 break;
12650 }
12651
12652 if (sym_sec == NULL)
12653 /* Ignore other undefined symbols. */
12654 continue;
12655
12656 /* Assume branches to other sections not included in the
12657 link need stubs too, to cover -R and absolute syms. */
12658 if (sym_sec->output_section == NULL)
12659 {
12660 ret = 1;
12661 break;
12662 }
12663
12664 if (h == NULL)
12665 sym_value = sym->st_value;
12666 else
12667 {
12668 if (h->root.type != bfd_link_hash_defined
12669 && h->root.type != bfd_link_hash_defweak)
12670 abort ();
12671 sym_value = h->root.u.def.value;
12672 }
12673 sym_value += rel->r_addend;
12674
12675 /* If this branch reloc uses an opd sym, find the code section. */
12676 opd = get_opd_info (sym_sec);
12677 if (opd != NULL)
12678 {
12679 if (h == NULL && opd->adjust != NULL)
12680 {
12681 long adjust;
12682
12683 adjust = opd->adjust[OPD_NDX (sym_value)];
12684 if (adjust == -1)
12685 /* Assume deleted functions won't ever be called. */
12686 continue;
12687 sym_value += adjust;
12688 }
12689
12690 dest = opd_entry_value (sym_sec, sym_value,
12691 &sym_sec, NULL, FALSE);
12692 if (dest == (bfd_vma) -1)
12693 continue;
12694 }
12695 else
12696 dest = (sym_value
12697 + sym_sec->output_offset
12698 + sym_sec->output_section->vma);
12699
12700 /* Ignore branch to self. */
12701 if (sym_sec == isec)
12702 continue;
12703
12704 /* If the called function uses the toc, we need a stub. */
12705 if (sym_sec->has_toc_reloc
12706 || sym_sec->makes_toc_func_call)
12707 {
12708 ret = 1;
12709 break;
12710 }
12711
12712 /* Assume any branch that needs a long branch stub might in fact
12713 need a plt_branch stub. A plt_branch stub uses r2. */
12714 else if (dest - (isec->output_offset
12715 + isec->output_section->vma
12716 + rel->r_offset) + (1 << 25)
12717 >= (2u << 25) - PPC64_LOCAL_ENTRY_OFFSET (h
12718 ? h->other
12719 : sym->st_other))
12720 {
12721 ret = 1;
12722 break;
12723 }
12724
12725 /* If calling back to a section in the process of being
12726 tested, we can't say for sure that no toc adjusting stubs
12727 are needed, so don't return zero. */
12728 else if (sym_sec->call_check_in_progress)
12729 ret = 2;
12730
12731 /* Branches to another section that itself doesn't have any TOC
12732 references are OK. Recursively call ourselves to check. */
12733 else if (!sym_sec->call_check_done)
12734 {
12735 int recur;
12736
12737 /* Mark current section as indeterminate, so that other
12738 sections that call back to current won't be marked as
12739 known. */
12740 isec->call_check_in_progress = 1;
12741 recur = toc_adjusting_stub_needed (info, sym_sec);
12742 isec->call_check_in_progress = 0;
12743
12744 if (recur != 0)
12745 {
12746 ret = recur;
12747 if (recur != 2)
12748 break;
12749 }
12750 }
12751 }
12752
12753 if (local_syms != NULL
12754 && (elf_symtab_hdr (isec->owner).contents
12755 != (unsigned char *) local_syms))
12756 free (local_syms);
12757 if (elf_section_data (isec)->relocs != relstart)
12758 free (relstart);
12759 }
12760
12761 if ((ret & 1) == 0
12762 && isec->map_head.s != NULL
12763 && (strcmp (isec->output_section->name, ".init") == 0
12764 || strcmp (isec->output_section->name, ".fini") == 0))
12765 {
12766 if (isec->map_head.s->has_toc_reloc
12767 || isec->map_head.s->makes_toc_func_call)
12768 ret = 1;
12769 else if (!isec->map_head.s->call_check_done)
12770 {
12771 int recur;
12772 isec->call_check_in_progress = 1;
12773 recur = toc_adjusting_stub_needed (info, isec->map_head.s);
12774 isec->call_check_in_progress = 0;
12775 if (recur != 0)
12776 ret = recur;
12777 }
12778 }
12779
12780 if (ret == 1)
12781 isec->makes_toc_func_call = 1;
12782
12783 return ret;
12784 }
12785
12786 /* The linker repeatedly calls this function for each input section,
12787 in the order that input sections are linked into output sections.
12788 Build lists of input sections to determine groupings between which
12789 we may insert linker stubs. */
12790
12791 bfd_boolean
12792 ppc64_elf_next_input_section (struct bfd_link_info *info, asection *isec)
12793 {
12794 struct ppc_link_hash_table *htab = ppc_hash_table (info);
12795
12796 if (htab == NULL)
12797 return FALSE;
12798
12799 if ((isec->output_section->flags & SEC_CODE) != 0
12800 && isec->output_section->id < htab->sec_info_arr_size)
12801 {
12802 /* This happens to make the list in reverse order,
12803 which is what we want. */
12804 htab->sec_info[isec->id].u.list
12805 = htab->sec_info[isec->output_section->id].u.list;
12806 htab->sec_info[isec->output_section->id].u.list = isec;
12807 }
12808
12809 if (htab->multi_toc_needed)
12810 {
12811 /* Analyse sections that aren't already flagged as needing a
12812 valid toc pointer. Exclude .fixup for the linux kernel.
12813 .fixup contains branches, but only back to the function that
12814 hit an exception. */
12815 if (!(isec->has_toc_reloc
12816 || (isec->flags & SEC_CODE) == 0
12817 || strcmp (isec->name, ".fixup") == 0
12818 || isec->call_check_done))
12819 {
12820 if (toc_adjusting_stub_needed (info, isec) < 0)
12821 return FALSE;
12822 }
12823 /* Make all sections use the TOC assigned for this object file.
12824 This will be wrong for pasted sections; We fix that in
12825 check_pasted_section(). */
12826 if (elf_gp (isec->owner) != 0)
12827 htab->toc_curr = elf_gp (isec->owner);
12828 }
12829
12830 htab->sec_info[isec->id].toc_off = htab->toc_curr;
12831 return TRUE;
12832 }
12833
12834 /* Check that all .init and .fini sections use the same toc, if they
12835 have toc relocs. */
12836
12837 static bfd_boolean
12838 check_pasted_section (struct bfd_link_info *info, const char *name)
12839 {
12840 asection *o = bfd_get_section_by_name (info->output_bfd, name);
12841
12842 if (o != NULL)
12843 {
12844 struct ppc_link_hash_table *htab = ppc_hash_table (info);
12845 bfd_vma toc_off = 0;
12846 asection *i;
12847
12848 for (i = o->map_head.s; i != NULL; i = i->map_head.s)
12849 if (i->has_toc_reloc)
12850 {
12851 if (toc_off == 0)
12852 toc_off = htab->sec_info[i->id].toc_off;
12853 else if (toc_off != htab->sec_info[i->id].toc_off)
12854 return FALSE;
12855 }
12856
12857 if (toc_off == 0)
12858 for (i = o->map_head.s; i != NULL; i = i->map_head.s)
12859 if (i->makes_toc_func_call)
12860 {
12861 toc_off = htab->sec_info[i->id].toc_off;
12862 break;
12863 }
12864
12865 /* Make sure the whole pasted function uses the same toc offset. */
12866 if (toc_off != 0)
12867 for (i = o->map_head.s; i != NULL; i = i->map_head.s)
12868 htab->sec_info[i->id].toc_off = toc_off;
12869 }
12870 return TRUE;
12871 }
12872
12873 bfd_boolean
12874 ppc64_elf_check_init_fini (struct bfd_link_info *info)
12875 {
12876 return (check_pasted_section (info, ".init")
12877 & check_pasted_section (info, ".fini"));
12878 }
12879
12880 /* See whether we can group stub sections together. Grouping stub
12881 sections may result in fewer stubs. More importantly, we need to
12882 put all .init* and .fini* stubs at the beginning of the .init or
12883 .fini output sections respectively, because glibc splits the
12884 _init and _fini functions into multiple parts. Putting a stub in
12885 the middle of a function is not a good idea. */
12886
12887 static bfd_boolean
12888 group_sections (struct bfd_link_info *info,
12889 bfd_size_type stub_group_size,
12890 bfd_boolean stubs_always_before_branch)
12891 {
12892 struct ppc_link_hash_table *htab;
12893 asection *osec;
12894 bfd_boolean suppress_size_errors;
12895
12896 htab = ppc_hash_table (info);
12897 if (htab == NULL)
12898 return FALSE;
12899
12900 suppress_size_errors = FALSE;
12901 if (stub_group_size == 1)
12902 {
12903 /* Default values. */
12904 if (stubs_always_before_branch)
12905 stub_group_size = 0x1e00000;
12906 else
12907 stub_group_size = 0x1c00000;
12908 suppress_size_errors = TRUE;
12909 }
12910
12911 for (osec = info->output_bfd->sections; osec != NULL; osec = osec->next)
12912 {
12913 asection *tail;
12914
12915 if (osec->id >= htab->sec_info_arr_size)
12916 continue;
12917
12918 tail = htab->sec_info[osec->id].u.list;
12919 while (tail != NULL)
12920 {
12921 asection *curr;
12922 asection *prev;
12923 bfd_size_type total;
12924 bfd_boolean big_sec;
12925 bfd_vma curr_toc;
12926 struct map_stub *group;
12927 bfd_size_type group_size;
12928
12929 curr = tail;
12930 total = tail->size;
12931 group_size = (ppc64_elf_section_data (tail) != NULL
12932 && ppc64_elf_section_data (tail)->has_14bit_branch
12933 ? stub_group_size >> 10 : stub_group_size);
12934
12935 big_sec = total > group_size;
12936 if (big_sec && !suppress_size_errors)
12937 /* xgettext:c-format */
12938 _bfd_error_handler (_("%pB section %pA exceeds stub group size"),
12939 tail->owner, tail);
12940 curr_toc = htab->sec_info[tail->id].toc_off;
12941
12942 while ((prev = htab->sec_info[curr->id].u.list) != NULL
12943 && ((total += curr->output_offset - prev->output_offset)
12944 < (ppc64_elf_section_data (prev) != NULL
12945 && ppc64_elf_section_data (prev)->has_14bit_branch
12946 ? (group_size = stub_group_size >> 10) : group_size))
12947 && htab->sec_info[prev->id].toc_off == curr_toc)
12948 curr = prev;
12949
12950 /* OK, the size from the start of CURR to the end is less
12951 than group_size and thus can be handled by one stub
12952 section. (or the tail section is itself larger than
12953 group_size, in which case we may be toast.) We should
12954 really be keeping track of the total size of stubs added
12955 here, as stubs contribute to the final output section
12956 size. That's a little tricky, and this way will only
12957 break if stubs added make the total size more than 2^25,
12958 ie. for the default stub_group_size, if stubs total more
12959 than 2097152 bytes, or nearly 75000 plt call stubs. */
12960 group = bfd_alloc (curr->owner, sizeof (*group));
12961 if (group == NULL)
12962 return FALSE;
12963 group->link_sec = curr;
12964 group->stub_sec = NULL;
12965 group->needs_save_res = 0;
12966 group->lr_restore = 0;
12967 group->eh_size = 0;
12968 group->eh_base = 0;
12969 group->next = htab->group;
12970 htab->group = group;
12971 do
12972 {
12973 prev = htab->sec_info[tail->id].u.list;
12974 /* Set up this stub group. */
12975 htab->sec_info[tail->id].u.group = group;
12976 }
12977 while (tail != curr && (tail = prev) != NULL);
12978
12979 /* But wait, there's more! Input sections up to group_size
12980 bytes before the stub section can be handled by it too.
12981 Don't do this if we have a really large section after the
12982 stubs, as adding more stubs increases the chance that
12983 branches may not reach into the stub section. */
12984 if (!stubs_always_before_branch && !big_sec)
12985 {
12986 total = 0;
12987 while (prev != NULL
12988 && ((total += tail->output_offset - prev->output_offset)
12989 < (ppc64_elf_section_data (prev) != NULL
12990 && ppc64_elf_section_data (prev)->has_14bit_branch
12991 ? (group_size = stub_group_size >> 10) : group_size))
12992 && htab->sec_info[prev->id].toc_off == curr_toc)
12993 {
12994 tail = prev;
12995 prev = htab->sec_info[tail->id].u.list;
12996 htab->sec_info[tail->id].u.group = group;
12997 }
12998 }
12999 tail = prev;
13000 }
13001 }
13002 return TRUE;
13003 }
13004
13005 static const unsigned char glink_eh_frame_cie[] =
13006 {
13007 0, 0, 0, 16, /* length. */
13008 0, 0, 0, 0, /* id. */
13009 1, /* CIE version. */
13010 'z', 'R', 0, /* Augmentation string. */
13011 4, /* Code alignment. */
13012 0x78, /* Data alignment. */
13013 65, /* RA reg. */
13014 1, /* Augmentation size. */
13015 DW_EH_PE_pcrel | DW_EH_PE_sdata4, /* FDE encoding. */
13016 DW_CFA_def_cfa, 1, 0 /* def_cfa: r1 offset 0. */
13017 };
13018
13019 /* Stripping output sections is normally done before dynamic section
13020 symbols have been allocated. This function is called later, and
13021 handles cases like htab->brlt which is mapped to its own output
13022 section. */
13023
13024 static void
13025 maybe_strip_output (struct bfd_link_info *info, asection *isec)
13026 {
13027 if (isec->size == 0
13028 && isec->output_section->size == 0
13029 && !(isec->output_section->flags & SEC_KEEP)
13030 && !bfd_section_removed_from_list (info->output_bfd,
13031 isec->output_section)
13032 && elf_section_data (isec->output_section)->dynindx == 0)
13033 {
13034 isec->output_section->flags |= SEC_EXCLUDE;
13035 bfd_section_list_remove (info->output_bfd, isec->output_section);
13036 info->output_bfd->section_count--;
13037 }
13038 }
13039
13040 /* Determine and set the size of the stub section for a final link.
13041
13042 The basic idea here is to examine all the relocations looking for
13043 PC-relative calls to a target that is unreachable with a "bl"
13044 instruction. */
13045
13046 bfd_boolean
13047 ppc64_elf_size_stubs (struct bfd_link_info *info)
13048 {
13049 bfd_size_type stub_group_size;
13050 bfd_boolean stubs_always_before_branch;
13051 struct ppc_link_hash_table *htab = ppc_hash_table (info);
13052
13053 if (htab == NULL)
13054 return FALSE;
13055
13056 if (htab->params->plt_thread_safe == -1 && !bfd_link_executable (info))
13057 htab->params->plt_thread_safe = 1;
13058 if (!htab->opd_abi)
13059 htab->params->plt_thread_safe = 0;
13060 else if (htab->params->plt_thread_safe == -1)
13061 {
13062 static const char *const thread_starter[] =
13063 {
13064 "pthread_create",
13065 /* libstdc++ */
13066 "_ZNSt6thread15_M_start_threadESt10shared_ptrINS_10_Impl_baseEE",
13067 /* librt */
13068 "aio_init", "aio_read", "aio_write", "aio_fsync", "lio_listio",
13069 "mq_notify", "create_timer",
13070 /* libanl */
13071 "getaddrinfo_a",
13072 /* libgomp */
13073 "GOMP_parallel",
13074 "GOMP_parallel_start",
13075 "GOMP_parallel_loop_static",
13076 "GOMP_parallel_loop_static_start",
13077 "GOMP_parallel_loop_dynamic",
13078 "GOMP_parallel_loop_dynamic_start",
13079 "GOMP_parallel_loop_guided",
13080 "GOMP_parallel_loop_guided_start",
13081 "GOMP_parallel_loop_runtime",
13082 "GOMP_parallel_loop_runtime_start",
13083 "GOMP_parallel_sections",
13084 "GOMP_parallel_sections_start",
13085 /* libgo */
13086 "__go_go",
13087 };
13088 unsigned i;
13089
13090 for (i = 0; i < ARRAY_SIZE (thread_starter); i++)
13091 {
13092 struct elf_link_hash_entry *h;
13093 h = elf_link_hash_lookup (&htab->elf, thread_starter[i],
13094 FALSE, FALSE, TRUE);
13095 htab->params->plt_thread_safe = h != NULL && h->ref_regular;
13096 if (htab->params->plt_thread_safe)
13097 break;
13098 }
13099 }
13100 stubs_always_before_branch = htab->params->group_size < 0;
13101 if (htab->params->group_size < 0)
13102 stub_group_size = -htab->params->group_size;
13103 else
13104 stub_group_size = htab->params->group_size;
13105
13106 if (!group_sections (info, stub_group_size, stubs_always_before_branch))
13107 return FALSE;
13108
13109 #define STUB_SHRINK_ITER 20
13110 /* Loop until no stubs added. After iteration 20 of this loop we may
13111 exit on a stub section shrinking. This is to break out of a
13112 pathological case where adding stubs on one iteration decreases
13113 section gaps (perhaps due to alignment), which then requires
13114 fewer or smaller stubs on the next iteration. */
13115
13116 while (1)
13117 {
13118 bfd *input_bfd;
13119 unsigned int bfd_indx;
13120 struct map_stub *group;
13121
13122 htab->stub_iteration += 1;
13123
13124 for (input_bfd = info->input_bfds, bfd_indx = 0;
13125 input_bfd != NULL;
13126 input_bfd = input_bfd->link.next, bfd_indx++)
13127 {
13128 Elf_Internal_Shdr *symtab_hdr;
13129 asection *section;
13130 Elf_Internal_Sym *local_syms = NULL;
13131
13132 if (!is_ppc64_elf (input_bfd))
13133 continue;
13134
13135 /* We'll need the symbol table in a second. */
13136 symtab_hdr = &elf_symtab_hdr (input_bfd);
13137 if (symtab_hdr->sh_info == 0)
13138 continue;
13139
13140 /* Walk over each section attached to the input bfd. */
13141 for (section = input_bfd->sections;
13142 section != NULL;
13143 section = section->next)
13144 {
13145 Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
13146
13147 /* If there aren't any relocs, then there's nothing more
13148 to do. */
13149 if ((section->flags & SEC_RELOC) == 0
13150 || (section->flags & SEC_ALLOC) == 0
13151 || (section->flags & SEC_LOAD) == 0
13152 || (section->flags & SEC_CODE) == 0
13153 || section->reloc_count == 0)
13154 continue;
13155
13156 /* If this section is a link-once section that will be
13157 discarded, then don't create any stubs. */
13158 if (section->output_section == NULL
13159 || section->output_section->owner != info->output_bfd)
13160 continue;
13161
13162 /* Get the relocs. */
13163 internal_relocs
13164 = _bfd_elf_link_read_relocs (input_bfd, section, NULL, NULL,
13165 info->keep_memory);
13166 if (internal_relocs == NULL)
13167 goto error_ret_free_local;
13168
13169 /* Now examine each relocation. */
13170 irela = internal_relocs;
13171 irelaend = irela + section->reloc_count;
13172 for (; irela < irelaend; irela++)
13173 {
13174 enum elf_ppc64_reloc_type r_type;
13175 unsigned int r_indx;
13176 enum ppc_stub_type stub_type;
13177 struct ppc_stub_hash_entry *stub_entry;
13178 asection *sym_sec, *code_sec;
13179 bfd_vma sym_value, code_value;
13180 bfd_vma destination;
13181 unsigned long local_off;
13182 bfd_boolean ok_dest;
13183 struct ppc_link_hash_entry *hash;
13184 struct ppc_link_hash_entry *fdh;
13185 struct elf_link_hash_entry *h;
13186 Elf_Internal_Sym *sym;
13187 char *stub_name;
13188 const asection *id_sec;
13189 struct _opd_sec_data *opd;
13190 struct plt_entry *plt_ent;
13191
13192 r_type = ELF64_R_TYPE (irela->r_info);
13193 r_indx = ELF64_R_SYM (irela->r_info);
13194
13195 if (r_type >= R_PPC64_max)
13196 {
13197 bfd_set_error (bfd_error_bad_value);
13198 goto error_ret_free_internal;
13199 }
13200
13201 /* Only look for stubs on branch instructions. */
13202 if (r_type != R_PPC64_REL24
13203 && r_type != R_PPC64_REL24_NOTOC
13204 && r_type != R_PPC64_REL14
13205 && r_type != R_PPC64_REL14_BRTAKEN
13206 && r_type != R_PPC64_REL14_BRNTAKEN)
13207 continue;
13208
13209 /* Now determine the call target, its name, value,
13210 section. */
13211 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
13212 r_indx, input_bfd))
13213 goto error_ret_free_internal;
13214 hash = (struct ppc_link_hash_entry *) h;
13215
13216 ok_dest = FALSE;
13217 fdh = NULL;
13218 sym_value = 0;
13219 if (hash == NULL)
13220 {
13221 sym_value = sym->st_value;
13222 if (sym_sec != NULL
13223 && sym_sec->output_section != NULL)
13224 ok_dest = TRUE;
13225 }
13226 else if (hash->elf.root.type == bfd_link_hash_defined
13227 || hash->elf.root.type == bfd_link_hash_defweak)
13228 {
13229 sym_value = hash->elf.root.u.def.value;
13230 if (sym_sec->output_section != NULL)
13231 ok_dest = TRUE;
13232 }
13233 else if (hash->elf.root.type == bfd_link_hash_undefweak
13234 || hash->elf.root.type == bfd_link_hash_undefined)
13235 {
13236 /* Recognise an old ABI func code entry sym, and
13237 use the func descriptor sym instead if it is
13238 defined. */
13239 if (hash->elf.root.root.string[0] == '.'
13240 && hash->oh != NULL)
13241 {
13242 fdh = ppc_follow_link (hash->oh);
13243 if (fdh->elf.root.type == bfd_link_hash_defined
13244 || fdh->elf.root.type == bfd_link_hash_defweak)
13245 {
13246 sym_sec = fdh->elf.root.u.def.section;
13247 sym_value = fdh->elf.root.u.def.value;
13248 if (sym_sec->output_section != NULL)
13249 ok_dest = TRUE;
13250 }
13251 else
13252 fdh = NULL;
13253 }
13254 }
13255 else
13256 {
13257 bfd_set_error (bfd_error_bad_value);
13258 goto error_ret_free_internal;
13259 }
13260
13261 destination = 0;
13262 local_off = 0;
13263 if (ok_dest)
13264 {
13265 sym_value += irela->r_addend;
13266 destination = (sym_value
13267 + sym_sec->output_offset
13268 + sym_sec->output_section->vma);
13269 local_off = PPC64_LOCAL_ENTRY_OFFSET (hash
13270 ? hash->elf.other
13271 : sym->st_other);
13272 }
13273
13274 code_sec = sym_sec;
13275 code_value = sym_value;
13276 opd = get_opd_info (sym_sec);
13277 if (opd != NULL)
13278 {
13279 bfd_vma dest;
13280
13281 if (hash == NULL && opd->adjust != NULL)
13282 {
13283 long adjust = opd->adjust[OPD_NDX (sym_value)];
13284 if (adjust == -1)
13285 continue;
13286 code_value += adjust;
13287 sym_value += adjust;
13288 }
13289 dest = opd_entry_value (sym_sec, sym_value,
13290 &code_sec, &code_value, FALSE);
13291 if (dest != (bfd_vma) -1)
13292 {
13293 destination = dest;
13294 if (fdh != NULL)
13295 {
13296 /* Fixup old ABI sym to point at code
13297 entry. */
13298 hash->elf.root.type = bfd_link_hash_defweak;
13299 hash->elf.root.u.def.section = code_sec;
13300 hash->elf.root.u.def.value = code_value;
13301 }
13302 }
13303 }
13304
13305 /* Determine what (if any) linker stub is needed. */
13306 plt_ent = NULL;
13307 stub_type = ppc_type_of_stub (section, irela, &hash,
13308 &plt_ent, destination,
13309 local_off);
13310
13311 if (r_type == R_PPC64_REL24_NOTOC)
13312 {
13313 if (stub_type == ppc_stub_plt_call)
13314 stub_type = ppc_stub_plt_call_notoc;
13315 else if (stub_type == ppc_stub_long_branch
13316 || (code_sec != NULL
13317 && code_sec->output_section != NULL
13318 && (((hash ? hash->elf.other : sym->st_other)
13319 & STO_PPC64_LOCAL_MASK)
13320 != 1 << STO_PPC64_LOCAL_BIT)))
13321 stub_type = ppc_stub_long_branch_notoc;
13322 }
13323 else if (stub_type != ppc_stub_plt_call)
13324 {
13325 /* Check whether we need a TOC adjusting stub.
13326 Since the linker pastes together pieces from
13327 different object files when creating the
13328 _init and _fini functions, it may be that a
13329 call to what looks like a local sym is in
13330 fact a call needing a TOC adjustment. */
13331 if ((code_sec != NULL
13332 && code_sec->output_section != NULL
13333 && (htab->sec_info[code_sec->id].toc_off
13334 != htab->sec_info[section->id].toc_off)
13335 && (code_sec->has_toc_reloc
13336 || code_sec->makes_toc_func_call))
13337 || (((hash ? hash->elf.other : sym->st_other)
13338 & STO_PPC64_LOCAL_MASK)
13339 == 1 << STO_PPC64_LOCAL_BIT))
13340 stub_type = ppc_stub_long_branch_r2off;
13341 }
13342
13343 if (stub_type == ppc_stub_none)
13344 continue;
13345
13346 /* __tls_get_addr calls might be eliminated. */
13347 if (stub_type != ppc_stub_plt_call
13348 && stub_type != ppc_stub_plt_call_notoc
13349 && hash != NULL
13350 && (hash == htab->tls_get_addr
13351 || hash == htab->tls_get_addr_fd)
13352 && section->has_tls_reloc
13353 && irela != internal_relocs)
13354 {
13355 /* Get tls info. */
13356 unsigned char *tls_mask;
13357
13358 if (!get_tls_mask (&tls_mask, NULL, NULL, &local_syms,
13359 irela - 1, input_bfd))
13360 goto error_ret_free_internal;
13361 if ((*tls_mask & TLS_TLS) != 0)
13362 continue;
13363 }
13364
13365 if (stub_type == ppc_stub_plt_call)
13366 {
13367 if (!htab->opd_abi
13368 && htab->params->plt_localentry0 != 0
13369 && is_elfv2_localentry0 (&hash->elf))
13370 htab->has_plt_localentry0 = 1;
13371 else if (irela + 1 < irelaend
13372 && irela[1].r_offset == irela->r_offset + 4
13373 && (ELF64_R_TYPE (irela[1].r_info)
13374 == R_PPC64_TOCSAVE))
13375 {
13376 if (!tocsave_find (htab, INSERT,
13377 &local_syms, irela + 1, input_bfd))
13378 goto error_ret_free_internal;
13379 }
13380 else
13381 stub_type = ppc_stub_plt_call_r2save;
13382 }
13383
13384 /* Support for grouping stub sections. */
13385 id_sec = htab->sec_info[section->id].u.group->link_sec;
13386
13387 /* Get the name of this stub. */
13388 stub_name = ppc_stub_name (id_sec, sym_sec, hash, irela);
13389 if (!stub_name)
13390 goto error_ret_free_internal;
13391
13392 stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
13393 stub_name, FALSE, FALSE);
13394 if (stub_entry != NULL)
13395 {
13396 enum ppc_stub_type old_type;
13397 /* A stub has already been created, but it may
13398 not be the required type. We shouldn't be
13399 transitioning from plt_call to long_branch
13400 stubs or vice versa, but we might be
13401 upgrading from plt_call to plt_call_r2save or
13402 from long_branch to long_branch_r2off. */
13403 free (stub_name);
13404 old_type = stub_entry->stub_type;
13405 switch (old_type)
13406 {
13407 default:
13408 abort ();
13409
13410 case ppc_stub_save_res:
13411 continue;
13412
13413 case ppc_stub_plt_call:
13414 case ppc_stub_plt_call_r2save:
13415 case ppc_stub_plt_call_notoc:
13416 case ppc_stub_plt_call_both:
13417 if (stub_type == ppc_stub_plt_call)
13418 continue;
13419 else if (stub_type == ppc_stub_plt_call_r2save)
13420 {
13421 if (old_type == ppc_stub_plt_call_notoc)
13422 stub_type = ppc_stub_plt_call_both;
13423 }
13424 else if (stub_type == ppc_stub_plt_call_notoc)
13425 {
13426 if (old_type == ppc_stub_plt_call_r2save)
13427 stub_type = ppc_stub_plt_call_both;
13428 }
13429 else
13430 abort ();
13431 break;
13432
13433 case ppc_stub_plt_branch:
13434 case ppc_stub_plt_branch_r2off:
13435 case ppc_stub_plt_branch_notoc:
13436 case ppc_stub_plt_branch_both:
13437 old_type += (ppc_stub_long_branch
13438 - ppc_stub_plt_branch);
13439 /* Fall through. */
13440 case ppc_stub_long_branch:
13441 case ppc_stub_long_branch_r2off:
13442 case ppc_stub_long_branch_notoc:
13443 case ppc_stub_long_branch_both:
13444 if (stub_type == ppc_stub_long_branch)
13445 continue;
13446 else if (stub_type == ppc_stub_long_branch_r2off)
13447 {
13448 if (old_type == ppc_stub_long_branch_notoc)
13449 stub_type = ppc_stub_long_branch_both;
13450 }
13451 else if (stub_type == ppc_stub_long_branch_notoc)
13452 {
13453 if (old_type == ppc_stub_long_branch_r2off)
13454 stub_type = ppc_stub_long_branch_both;
13455 }
13456 else
13457 abort ();
13458 break;
13459 }
13460 if (old_type < stub_type)
13461 stub_entry->stub_type = stub_type;
13462 continue;
13463 }
13464
13465 stub_entry = ppc_add_stub (stub_name, section, info);
13466 if (stub_entry == NULL)
13467 {
13468 free (stub_name);
13469 error_ret_free_internal:
13470 if (elf_section_data (section)->relocs == NULL)
13471 free (internal_relocs);
13472 error_ret_free_local:
13473 if (local_syms != NULL
13474 && (symtab_hdr->contents
13475 != (unsigned char *) local_syms))
13476 free (local_syms);
13477 return FALSE;
13478 }
13479
13480 stub_entry->stub_type = stub_type;
13481 if (stub_type >= ppc_stub_plt_call
13482 && stub_type <= ppc_stub_plt_call_both)
13483 {
13484 stub_entry->target_value = sym_value;
13485 stub_entry->target_section = sym_sec;
13486 }
13487 else
13488 {
13489 stub_entry->target_value = code_value;
13490 stub_entry->target_section = code_sec;
13491 }
13492 stub_entry->h = hash;
13493 stub_entry->plt_ent = plt_ent;
13494 stub_entry->symtype
13495 = hash ? hash->elf.type : ELF_ST_TYPE (sym->st_info);
13496 stub_entry->other = hash ? hash->elf.other : sym->st_other;
13497
13498 if (stub_entry->h != NULL)
13499 htab->stub_globals += 1;
13500 }
13501
13502 /* We're done with the internal relocs, free them. */
13503 if (elf_section_data (section)->relocs != internal_relocs)
13504 free (internal_relocs);
13505 }
13506
13507 if (local_syms != NULL
13508 && symtab_hdr->contents != (unsigned char *) local_syms)
13509 {
13510 if (!info->keep_memory)
13511 free (local_syms);
13512 else
13513 symtab_hdr->contents = (unsigned char *) local_syms;
13514 }
13515 }
13516
13517 /* We may have added some stubs. Find out the new size of the
13518 stub sections. */
13519 for (group = htab->group; group != NULL; group = group->next)
13520 {
13521 group->lr_restore = 0;
13522 group->eh_size = 0;
13523 if (group->stub_sec != NULL)
13524 {
13525 asection *stub_sec = group->stub_sec;
13526
13527 if (htab->stub_iteration <= STUB_SHRINK_ITER
13528 || stub_sec->rawsize < stub_sec->size)
13529 /* Past STUB_SHRINK_ITER, rawsize is the max size seen. */
13530 stub_sec->rawsize = stub_sec->size;
13531 stub_sec->size = 0;
13532 stub_sec->reloc_count = 0;
13533 stub_sec->flags &= ~SEC_RELOC;
13534 }
13535 }
13536
13537 if (htab->stub_iteration <= STUB_SHRINK_ITER
13538 || htab->brlt->rawsize < htab->brlt->size)
13539 htab->brlt->rawsize = htab->brlt->size;
13540 htab->brlt->size = 0;
13541 htab->brlt->reloc_count = 0;
13542 htab->brlt->flags &= ~SEC_RELOC;
13543 if (htab->relbrlt != NULL)
13544 htab->relbrlt->size = 0;
13545
13546 bfd_hash_traverse (&htab->stub_hash_table, ppc_size_one_stub, info);
13547
13548 for (group = htab->group; group != NULL; group = group->next)
13549 if (group->needs_save_res)
13550 group->stub_sec->size += htab->sfpr->size;
13551
13552 if (info->emitrelocations
13553 && htab->glink != NULL && htab->glink->size != 0)
13554 {
13555 htab->glink->reloc_count = 1;
13556 htab->glink->flags |= SEC_RELOC;
13557 }
13558
13559 if (htab->glink_eh_frame != NULL
13560 && !bfd_is_abs_section (htab->glink_eh_frame->output_section)
13561 && htab->glink_eh_frame->output_section->size > 8)
13562 {
13563 size_t size = 0, align = 4;
13564
13565 for (group = htab->group; group != NULL; group = group->next)
13566 if (group->eh_size != 0)
13567 size += (group->eh_size + 17 + align - 1) & -align;
13568 if (htab->glink != NULL && htab->glink->size != 0)
13569 size += (24 + align - 1) & -align;
13570 if (size != 0)
13571 size += (sizeof (glink_eh_frame_cie) + align - 1) & -align;
13572 align = 1ul << htab->glink_eh_frame->output_section->alignment_power;
13573 size = (size + align - 1) & -align;
13574 htab->glink_eh_frame->rawsize = htab->glink_eh_frame->size;
13575 htab->glink_eh_frame->size = size;
13576 }
13577
13578 if (htab->params->plt_stub_align != 0)
13579 for (group = htab->group; group != NULL; group = group->next)
13580 if (group->stub_sec != NULL)
13581 {
13582 int align = abs (htab->params->plt_stub_align);
13583 group->stub_sec->size
13584 = (group->stub_sec->size + (1 << align) - 1) & -(1 << align);
13585 }
13586
13587 for (group = htab->group; group != NULL; group = group->next)
13588 if (group->stub_sec != NULL
13589 && group->stub_sec->rawsize != group->stub_sec->size
13590 && (htab->stub_iteration <= STUB_SHRINK_ITER
13591 || group->stub_sec->rawsize < group->stub_sec->size))
13592 break;
13593
13594 if (group == NULL
13595 && (htab->brlt->rawsize == htab->brlt->size
13596 || (htab->stub_iteration > STUB_SHRINK_ITER
13597 && htab->brlt->rawsize > htab->brlt->size))
13598 && (htab->glink_eh_frame == NULL
13599 || htab->glink_eh_frame->rawsize == htab->glink_eh_frame->size))
13600 break;
13601
13602 /* Ask the linker to do its stuff. */
13603 (*htab->params->layout_sections_again) ();
13604 }
13605
13606 if (htab->glink_eh_frame != NULL
13607 && htab->glink_eh_frame->size != 0)
13608 {
13609 bfd_vma val;
13610 bfd_byte *p, *last_fde;
13611 size_t last_fde_len, size, align, pad;
13612 struct map_stub *group;
13613
13614 /* It is necessary to at least have a rough outline of the
13615 linker generated CIEs and FDEs written before
13616 bfd_elf_discard_info is run, in order for these FDEs to be
13617 indexed in .eh_frame_hdr. */
13618 p = bfd_zalloc (htab->glink_eh_frame->owner, htab->glink_eh_frame->size);
13619 if (p == NULL)
13620 return FALSE;
13621 htab->glink_eh_frame->contents = p;
13622 last_fde = p;
13623 align = 4;
13624
13625 memcpy (p, glink_eh_frame_cie, sizeof (glink_eh_frame_cie));
13626 /* CIE length (rewrite in case little-endian). */
13627 last_fde_len = ((sizeof (glink_eh_frame_cie) + align - 1) & -align) - 4;
13628 bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
13629 p += last_fde_len + 4;
13630
13631 for (group = htab->group; group != NULL; group = group->next)
13632 if (group->eh_size != 0)
13633 {
13634 group->eh_base = p - htab->glink_eh_frame->contents;
13635 last_fde = p;
13636 last_fde_len = ((group->eh_size + 17 + align - 1) & -align) - 4;
13637 /* FDE length. */
13638 bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
13639 p += 4;
13640 /* CIE pointer. */
13641 val = p - htab->glink_eh_frame->contents;
13642 bfd_put_32 (htab->elf.dynobj, val, p);
13643 p += 4;
13644 /* Offset to stub section, written later. */
13645 p += 4;
13646 /* stub section size. */
13647 bfd_put_32 (htab->elf.dynobj, group->stub_sec->size, p);
13648 p += 4;
13649 /* Augmentation. */
13650 p += 1;
13651 /* Make sure we don't have all nops. This is enough for
13652 elf-eh-frame.c to detect the last non-nop opcode. */
13653 p[group->eh_size - 1] = DW_CFA_advance_loc + 1;
13654 p = last_fde + last_fde_len + 4;
13655 }
13656 if (htab->glink != NULL && htab->glink->size != 0)
13657 {
13658 last_fde = p;
13659 last_fde_len = ((24 + align - 1) & -align) - 4;
13660 /* FDE length. */
13661 bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
13662 p += 4;
13663 /* CIE pointer. */
13664 val = p - htab->glink_eh_frame->contents;
13665 bfd_put_32 (htab->elf.dynobj, val, p);
13666 p += 4;
13667 /* Offset to .glink, written later. */
13668 p += 4;
13669 /* .glink size. */
13670 bfd_put_32 (htab->elf.dynobj, htab->glink->size - 8, p);
13671 p += 4;
13672 /* Augmentation. */
13673 p += 1;
13674
13675 *p++ = DW_CFA_advance_loc + 1;
13676 *p++ = DW_CFA_register;
13677 *p++ = 65;
13678 *p++ = htab->opd_abi ? 12 : 0;
13679 *p++ = DW_CFA_advance_loc + (htab->opd_abi ? 5 : 7);
13680 *p++ = DW_CFA_restore_extended;
13681 *p++ = 65;
13682 p += ((24 + align - 1) & -align) - 24;
13683 }
13684 /* Subsume any padding into the last FDE if user .eh_frame
13685 sections are aligned more than glink_eh_frame. Otherwise any
13686 zero padding will be seen as a terminator. */
13687 align = 1ul << htab->glink_eh_frame->output_section->alignment_power;
13688 size = p - htab->glink_eh_frame->contents;
13689 pad = ((size + align - 1) & -align) - size;
13690 htab->glink_eh_frame->size = size + pad;
13691 bfd_put_32 (htab->elf.dynobj, last_fde_len + pad, last_fde);
13692 }
13693
13694 maybe_strip_output (info, htab->brlt);
13695 if (htab->glink_eh_frame != NULL)
13696 maybe_strip_output (info, htab->glink_eh_frame);
13697
13698 return TRUE;
13699 }
13700
13701 /* Called after we have determined section placement. If sections
13702 move, we'll be called again. Provide a value for TOCstart. */
13703
13704 bfd_vma
13705 ppc64_elf_set_toc (struct bfd_link_info *info, bfd *obfd)
13706 {
13707 asection *s;
13708 bfd_vma TOCstart, adjust;
13709
13710 if (info != NULL)
13711 {
13712 struct elf_link_hash_entry *h;
13713 struct elf_link_hash_table *htab = elf_hash_table (info);
13714
13715 if (is_elf_hash_table (htab)
13716 && htab->hgot != NULL)
13717 h = htab->hgot;
13718 else
13719 {
13720 h = elf_link_hash_lookup (htab, ".TOC.", FALSE, FALSE, TRUE);
13721 if (is_elf_hash_table (htab))
13722 htab->hgot = h;
13723 }
13724 if (h != NULL
13725 && h->root.type == bfd_link_hash_defined
13726 && !h->root.linker_def
13727 && (!is_elf_hash_table (htab)
13728 || h->def_regular))
13729 {
13730 TOCstart = (h->root.u.def.value - TOC_BASE_OFF
13731 + h->root.u.def.section->output_offset
13732 + h->root.u.def.section->output_section->vma);
13733 _bfd_set_gp_value (obfd, TOCstart);
13734 return TOCstart;
13735 }
13736 }
13737
13738 /* The TOC consists of sections .got, .toc, .tocbss, .plt in that
13739 order. The TOC starts where the first of these sections starts. */
13740 s = bfd_get_section_by_name (obfd, ".got");
13741 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
13742 s = bfd_get_section_by_name (obfd, ".toc");
13743 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
13744 s = bfd_get_section_by_name (obfd, ".tocbss");
13745 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
13746 s = bfd_get_section_by_name (obfd, ".plt");
13747 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
13748 {
13749 /* This may happen for
13750 o references to TOC base (SYM@toc / TOC[tc0]) without a
13751 .toc directive
13752 o bad linker script
13753 o --gc-sections and empty TOC sections
13754
13755 FIXME: Warn user? */
13756
13757 /* Look for a likely section. We probably won't even be
13758 using TOCstart. */
13759 for (s = obfd->sections; s != NULL; s = s->next)
13760 if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_READONLY
13761 | SEC_EXCLUDE))
13762 == (SEC_ALLOC | SEC_SMALL_DATA))
13763 break;
13764 if (s == NULL)
13765 for (s = obfd->sections; s != NULL; s = s->next)
13766 if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_EXCLUDE))
13767 == (SEC_ALLOC | SEC_SMALL_DATA))
13768 break;
13769 if (s == NULL)
13770 for (s = obfd->sections; s != NULL; s = s->next)
13771 if ((s->flags & (SEC_ALLOC | SEC_READONLY | SEC_EXCLUDE))
13772 == SEC_ALLOC)
13773 break;
13774 if (s == NULL)
13775 for (s = obfd->sections; s != NULL; s = s->next)
13776 if ((s->flags & (SEC_ALLOC | SEC_EXCLUDE)) == SEC_ALLOC)
13777 break;
13778 }
13779
13780 TOCstart = 0;
13781 if (s != NULL)
13782 TOCstart = s->output_section->vma + s->output_offset;
13783
13784 /* Force alignment. */
13785 adjust = TOCstart & (TOC_BASE_ALIGN - 1);
13786 TOCstart -= adjust;
13787 _bfd_set_gp_value (obfd, TOCstart);
13788
13789 if (info != NULL && s != NULL)
13790 {
13791 struct ppc_link_hash_table *htab = ppc_hash_table (info);
13792
13793 if (htab != NULL)
13794 {
13795 if (htab->elf.hgot != NULL)
13796 {
13797 htab->elf.hgot->root.u.def.value = TOC_BASE_OFF - adjust;
13798 htab->elf.hgot->root.u.def.section = s;
13799 }
13800 }
13801 else
13802 {
13803 struct bfd_link_hash_entry *bh = NULL;
13804 _bfd_generic_link_add_one_symbol (info, obfd, ".TOC.", BSF_GLOBAL,
13805 s, TOC_BASE_OFF - adjust,
13806 NULL, FALSE, FALSE, &bh);
13807 }
13808 }
13809 return TOCstart;
13810 }
13811
13812 /* Called via elf_link_hash_traverse from ppc64_elf_build_stubs to
13813 write out any global entry stubs, and PLT relocations. */
13814
13815 static bfd_boolean
13816 build_global_entry_stubs_and_plt (struct elf_link_hash_entry *h, void *inf)
13817 {
13818 struct bfd_link_info *info;
13819 struct ppc_link_hash_table *htab;
13820 struct plt_entry *ent;
13821 asection *s;
13822
13823 if (h->root.type == bfd_link_hash_indirect)
13824 return TRUE;
13825
13826 info = inf;
13827 htab = ppc_hash_table (info);
13828 if (htab == NULL)
13829 return FALSE;
13830
13831 for (ent = h->plt.plist; ent != NULL; ent = ent->next)
13832 if (ent->plt.offset != (bfd_vma) -1)
13833 {
13834 /* This symbol has an entry in the procedure linkage
13835 table. Set it up. */
13836 Elf_Internal_Rela rela;
13837 asection *plt, *relplt;
13838 bfd_byte *loc;
13839
13840 if (!htab->elf.dynamic_sections_created
13841 || h->dynindx == -1)
13842 {
13843 if (!(h->def_regular
13844 && (h->root.type == bfd_link_hash_defined
13845 || h->root.type == bfd_link_hash_defweak)))
13846 continue;
13847 if (h->type == STT_GNU_IFUNC)
13848 {
13849 plt = htab->elf.iplt;
13850 relplt = htab->elf.irelplt;
13851 htab->local_ifunc_resolver = 1;
13852 if (htab->opd_abi)
13853 rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
13854 else
13855 rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
13856 }
13857 else
13858 {
13859 plt = htab->pltlocal;
13860 if (bfd_link_pic (info))
13861 {
13862 relplt = htab->relpltlocal;
13863 if (htab->opd_abi)
13864 rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_SLOT);
13865 else
13866 rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
13867 }
13868 else
13869 relplt = NULL;
13870 }
13871 rela.r_addend = (h->root.u.def.value
13872 + h->root.u.def.section->output_offset
13873 + h->root.u.def.section->output_section->vma
13874 + ent->addend);
13875
13876 if (relplt == NULL)
13877 {
13878 loc = plt->contents + ent->plt.offset;
13879 bfd_put_64 (info->output_bfd, rela.r_addend, loc);
13880 if (htab->opd_abi)
13881 {
13882 bfd_vma toc = elf_gp (info->output_bfd);
13883 toc += htab->sec_info[h->root.u.def.section->id].toc_off;
13884 bfd_put_64 (info->output_bfd, toc, loc + 8);
13885 }
13886 }
13887 else
13888 {
13889 rela.r_offset = (plt->output_section->vma
13890 + plt->output_offset
13891 + ent->plt.offset);
13892 loc = relplt->contents + (relplt->reloc_count++
13893 * sizeof (Elf64_External_Rela));
13894 bfd_elf64_swap_reloca_out (info->output_bfd, &rela, loc);
13895 }
13896 }
13897 else
13898 {
13899 rela.r_offset = (htab->elf.splt->output_section->vma
13900 + htab->elf.splt->output_offset
13901 + ent->plt.offset);
13902 rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_JMP_SLOT);
13903 rela.r_addend = ent->addend;
13904 loc = (htab->elf.srelplt->contents
13905 + ((ent->plt.offset - PLT_INITIAL_ENTRY_SIZE (htab))
13906 / PLT_ENTRY_SIZE (htab) * sizeof (Elf64_External_Rela)));
13907 if (h->type == STT_GNU_IFUNC && is_static_defined (h))
13908 htab->maybe_local_ifunc_resolver = 1;
13909 bfd_elf64_swap_reloca_out (info->output_bfd, &rela, loc);
13910 }
13911 }
13912
13913 if (!h->pointer_equality_needed)
13914 return TRUE;
13915
13916 if (h->def_regular)
13917 return TRUE;
13918
13919 s = htab->global_entry;
13920 if (s == NULL || s->size == 0)
13921 return TRUE;
13922
13923 for (ent = h->plt.plist; ent != NULL; ent = ent->next)
13924 if (ent->plt.offset != (bfd_vma) -1
13925 && ent->addend == 0)
13926 {
13927 bfd_byte *p;
13928 asection *plt;
13929 bfd_vma off;
13930
13931 p = s->contents + h->root.u.def.value;
13932 plt = htab->elf.splt;
13933 if (!htab->elf.dynamic_sections_created
13934 || h->dynindx == -1)
13935 {
13936 if (h->type == STT_GNU_IFUNC)
13937 plt = htab->elf.iplt;
13938 else
13939 plt = htab->pltlocal;
13940 }
13941 off = ent->plt.offset + plt->output_offset + plt->output_section->vma;
13942 off -= h->root.u.def.value + s->output_offset + s->output_section->vma;
13943
13944 if (off + 0x80008000 > 0xffffffff || (off & 3) != 0)
13945 {
13946 info->callbacks->einfo
13947 (_("%P: linkage table error against `%pT'\n"),
13948 h->root.root.string);
13949 bfd_set_error (bfd_error_bad_value);
13950 htab->stub_error = TRUE;
13951 }
13952
13953 htab->stub_count[ppc_stub_global_entry - 1] += 1;
13954 if (htab->params->emit_stub_syms)
13955 {
13956 size_t len = strlen (h->root.root.string);
13957 char *name = bfd_malloc (sizeof "12345678.global_entry." + len);
13958
13959 if (name == NULL)
13960 return FALSE;
13961
13962 sprintf (name, "%08x.global_entry.%s", s->id, h->root.root.string);
13963 h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
13964 if (h == NULL)
13965 return FALSE;
13966 if (h->root.type == bfd_link_hash_new)
13967 {
13968 h->root.type = bfd_link_hash_defined;
13969 h->root.u.def.section = s;
13970 h->root.u.def.value = p - s->contents;
13971 h->ref_regular = 1;
13972 h->def_regular = 1;
13973 h->ref_regular_nonweak = 1;
13974 h->forced_local = 1;
13975 h->non_elf = 0;
13976 h->root.linker_def = 1;
13977 }
13978 }
13979
13980 if (PPC_HA (off) != 0)
13981 {
13982 bfd_put_32 (s->owner, ADDIS_R12_R12 | PPC_HA (off), p);
13983 p += 4;
13984 }
13985 bfd_put_32 (s->owner, LD_R12_0R12 | PPC_LO (off), p);
13986 p += 4;
13987 bfd_put_32 (s->owner, MTCTR_R12, p);
13988 p += 4;
13989 bfd_put_32 (s->owner, BCTR, p);
13990 break;
13991 }
13992 return TRUE;
13993 }
13994
13995 /* Write PLT relocs for locals. */
13996
13997 static bfd_boolean
13998 write_plt_relocs_for_local_syms (struct bfd_link_info *info)
13999 {
14000 struct ppc_link_hash_table *htab = ppc_hash_table (info);
14001 bfd *ibfd;
14002
14003 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
14004 {
14005 struct got_entry **lgot_ents, **end_lgot_ents;
14006 struct plt_entry **local_plt, **lplt, **end_local_plt;
14007 Elf_Internal_Shdr *symtab_hdr;
14008 bfd_size_type locsymcount;
14009 Elf_Internal_Sym *local_syms = NULL;
14010 struct plt_entry *ent;
14011
14012 if (!is_ppc64_elf (ibfd))
14013 continue;
14014
14015 lgot_ents = elf_local_got_ents (ibfd);
14016 if (!lgot_ents)
14017 continue;
14018
14019 symtab_hdr = &elf_symtab_hdr (ibfd);
14020 locsymcount = symtab_hdr->sh_info;
14021 end_lgot_ents = lgot_ents + locsymcount;
14022 local_plt = (struct plt_entry **) end_lgot_ents;
14023 end_local_plt = local_plt + locsymcount;
14024 for (lplt = local_plt; lplt < end_local_plt; ++lplt)
14025 for (ent = *lplt; ent != NULL; ent = ent->next)
14026 if (ent->plt.offset != (bfd_vma) -1)
14027 {
14028 Elf_Internal_Sym *sym;
14029 asection *sym_sec;
14030 asection *plt, *relplt;
14031 bfd_byte *loc;
14032 bfd_vma val;
14033
14034 if (!get_sym_h (NULL, &sym, &sym_sec, NULL, &local_syms,
14035 lplt - local_plt, ibfd))
14036 {
14037 if (local_syms != NULL
14038 && symtab_hdr->contents != (unsigned char *) local_syms)
14039 free (local_syms);
14040 return FALSE;
14041 }
14042
14043 val = sym->st_value + ent->addend;
14044 val += PPC64_LOCAL_ENTRY_OFFSET (sym->st_other);
14045 if (sym_sec != NULL && sym_sec->output_section != NULL)
14046 val += sym_sec->output_offset + sym_sec->output_section->vma;
14047
14048 if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
14049 {
14050 htab->local_ifunc_resolver = 1;
14051 plt = htab->elf.iplt;
14052 relplt = htab->elf.irelplt;
14053 }
14054 else
14055 {
14056 plt = htab->pltlocal;
14057 relplt = bfd_link_pic (info) ? htab->relpltlocal : NULL;
14058 }
14059
14060 if (relplt == NULL)
14061 {
14062 loc = plt->contents + ent->plt.offset;
14063 bfd_put_64 (info->output_bfd, val, loc);
14064 if (htab->opd_abi)
14065 {
14066 bfd_vma toc = elf_gp (ibfd);
14067 bfd_put_64 (info->output_bfd, toc, loc + 8);
14068 }
14069 }
14070 else
14071 {
14072 Elf_Internal_Rela rela;
14073 rela.r_offset = (ent->plt.offset
14074 + plt->output_offset
14075 + plt->output_section->vma);
14076 if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
14077 {
14078 if (htab->opd_abi)
14079 rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
14080 else
14081 rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
14082 }
14083 else
14084 {
14085 if (htab->opd_abi)
14086 rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_SLOT);
14087 else
14088 rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
14089 }
14090 rela.r_addend = val;
14091 loc = relplt->contents + (relplt->reloc_count++
14092 * sizeof (Elf64_External_Rela));
14093 bfd_elf64_swap_reloca_out (info->output_bfd, &rela, loc);
14094 }
14095 }
14096
14097 if (local_syms != NULL
14098 && symtab_hdr->contents != (unsigned char *) local_syms)
14099 {
14100 if (!info->keep_memory)
14101 free (local_syms);
14102 else
14103 symtab_hdr->contents = (unsigned char *) local_syms;
14104 }
14105 }
14106 return TRUE;
14107 }
14108
14109 /* Build all the stubs associated with the current output file.
14110 The stubs are kept in a hash table attached to the main linker
14111 hash table. This function is called via gldelf64ppc_finish. */
14112
14113 bfd_boolean
14114 ppc64_elf_build_stubs (struct bfd_link_info *info,
14115 char **stats)
14116 {
14117 struct ppc_link_hash_table *htab = ppc_hash_table (info);
14118 struct map_stub *group;
14119 asection *stub_sec;
14120 bfd_byte *p;
14121 int stub_sec_count = 0;
14122
14123 if (htab == NULL)
14124 return FALSE;
14125
14126 /* Allocate memory to hold the linker stubs. */
14127 for (group = htab->group; group != NULL; group = group->next)
14128 {
14129 group->eh_size = 0;
14130 group->lr_restore = 0;
14131 if ((stub_sec = group->stub_sec) != NULL
14132 && stub_sec->size != 0)
14133 {
14134 stub_sec->contents = bfd_zalloc (htab->params->stub_bfd,
14135 stub_sec->size);
14136 if (stub_sec->contents == NULL)
14137 return FALSE;
14138 stub_sec->size = 0;
14139 }
14140 }
14141
14142 if (htab->glink != NULL && htab->glink->size != 0)
14143 {
14144 unsigned int indx;
14145 bfd_vma plt0;
14146
14147 /* Build the .glink plt call stub. */
14148 if (htab->params->emit_stub_syms)
14149 {
14150 struct elf_link_hash_entry *h;
14151 h = elf_link_hash_lookup (&htab->elf, "__glink_PLTresolve",
14152 TRUE, FALSE, FALSE);
14153 if (h == NULL)
14154 return FALSE;
14155 if (h->root.type == bfd_link_hash_new)
14156 {
14157 h->root.type = bfd_link_hash_defined;
14158 h->root.u.def.section = htab->glink;
14159 h->root.u.def.value = 8;
14160 h->ref_regular = 1;
14161 h->def_regular = 1;
14162 h->ref_regular_nonweak = 1;
14163 h->forced_local = 1;
14164 h->non_elf = 0;
14165 h->root.linker_def = 1;
14166 }
14167 }
14168 plt0 = (htab->elf.splt->output_section->vma
14169 + htab->elf.splt->output_offset
14170 - 16);
14171 if (info->emitrelocations)
14172 {
14173 Elf_Internal_Rela *r = get_relocs (htab->glink, 1);
14174 if (r == NULL)
14175 return FALSE;
14176 r->r_offset = (htab->glink->output_offset
14177 + htab->glink->output_section->vma);
14178 r->r_info = ELF64_R_INFO (0, R_PPC64_REL64);
14179 r->r_addend = plt0;
14180 }
14181 p = htab->glink->contents;
14182 plt0 -= htab->glink->output_section->vma + htab->glink->output_offset;
14183 bfd_put_64 (htab->glink->owner, plt0, p);
14184 p += 8;
14185 if (htab->opd_abi)
14186 {
14187 bfd_put_32 (htab->glink->owner, MFLR_R12, p);
14188 p += 4;
14189 bfd_put_32 (htab->glink->owner, BCL_20_31, p);
14190 p += 4;
14191 bfd_put_32 (htab->glink->owner, MFLR_R11, p);
14192 p += 4;
14193 bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
14194 p += 4;
14195 bfd_put_32 (htab->glink->owner, MTLR_R12, p);
14196 p += 4;
14197 bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
14198 p += 4;
14199 bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
14200 p += 4;
14201 bfd_put_32 (htab->glink->owner, LD_R2_0R11 | 8, p);
14202 p += 4;
14203 bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
14204 p += 4;
14205 bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 16, p);
14206 p += 4;
14207 }
14208 else
14209 {
14210 bfd_put_32 (htab->glink->owner, MFLR_R0, p);
14211 p += 4;
14212 bfd_put_32 (htab->glink->owner, BCL_20_31, p);
14213 p += 4;
14214 bfd_put_32 (htab->glink->owner, MFLR_R11, p);
14215 p += 4;
14216 bfd_put_32 (htab->glink->owner, STD_R2_0R1 + 24, p);
14217 p += 4;
14218 bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
14219 p += 4;
14220 bfd_put_32 (htab->glink->owner, MTLR_R0, p);
14221 p += 4;
14222 bfd_put_32 (htab->glink->owner, SUB_R12_R12_R11, p);
14223 p += 4;
14224 bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
14225 p += 4;
14226 bfd_put_32 (htab->glink->owner, ADDI_R0_R12 | (-48 & 0xffff), p);
14227 p += 4;
14228 bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
14229 p += 4;
14230 bfd_put_32 (htab->glink->owner, SRDI_R0_R0_2, p);
14231 p += 4;
14232 bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
14233 p += 4;
14234 bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 8, p);
14235 p += 4;
14236 }
14237 bfd_put_32 (htab->glink->owner, BCTR, p);
14238 p += 4;
14239 BFD_ASSERT (p == htab->glink->contents + GLINK_PLTRESOLVE_SIZE (htab));
14240
14241 /* Build the .glink lazy link call stubs. */
14242 indx = 0;
14243 while (p < htab->glink->contents + htab->glink->size)
14244 {
14245 if (htab->opd_abi)
14246 {
14247 if (indx < 0x8000)
14248 {
14249 bfd_put_32 (htab->glink->owner, LI_R0_0 | indx, p);
14250 p += 4;
14251 }
14252 else
14253 {
14254 bfd_put_32 (htab->glink->owner, LIS_R0_0 | PPC_HI (indx), p);
14255 p += 4;
14256 bfd_put_32 (htab->glink->owner, ORI_R0_R0_0 | PPC_LO (indx),
14257 p);
14258 p += 4;
14259 }
14260 }
14261 bfd_put_32 (htab->glink->owner,
14262 B_DOT | ((htab->glink->contents - p + 8) & 0x3fffffc), p);
14263 indx++;
14264 p += 4;
14265 }
14266 }
14267
14268 /* Build .glink global entry stubs, and PLT relocs for globals. */
14269 elf_link_hash_traverse (&htab->elf, build_global_entry_stubs_and_plt, info);
14270
14271 if (!write_plt_relocs_for_local_syms (info))
14272 return FALSE;
14273
14274 if (htab->brlt != NULL && htab->brlt->size != 0)
14275 {
14276 htab->brlt->contents = bfd_zalloc (htab->brlt->owner,
14277 htab->brlt->size);
14278 if (htab->brlt->contents == NULL)
14279 return FALSE;
14280 }
14281 if (htab->relbrlt != NULL && htab->relbrlt->size != 0)
14282 {
14283 htab->relbrlt->contents = bfd_zalloc (htab->relbrlt->owner,
14284 htab->relbrlt->size);
14285 if (htab->relbrlt->contents == NULL)
14286 return FALSE;
14287 }
14288
14289 /* Build the stubs as directed by the stub hash table. */
14290 bfd_hash_traverse (&htab->stub_hash_table, ppc_build_one_stub, info);
14291
14292 for (group = htab->group; group != NULL; group = group->next)
14293 if (group->needs_save_res)
14294 group->stub_sec->size += htab->sfpr->size;
14295
14296 if (htab->relbrlt != NULL)
14297 htab->relbrlt->reloc_count = 0;
14298
14299 if (htab->params->plt_stub_align != 0)
14300 for (group = htab->group; group != NULL; group = group->next)
14301 if ((stub_sec = group->stub_sec) != NULL)
14302 {
14303 int align = abs (htab->params->plt_stub_align);
14304 stub_sec->size = (stub_sec->size + (1 << align) - 1) & -(1 << align);
14305 }
14306
14307 for (group = htab->group; group != NULL; group = group->next)
14308 if (group->needs_save_res)
14309 {
14310 stub_sec = group->stub_sec;
14311 memcpy (stub_sec->contents + stub_sec->size - htab->sfpr->size,
14312 htab->sfpr->contents, htab->sfpr->size);
14313 if (htab->params->emit_stub_syms)
14314 {
14315 unsigned int i;
14316
14317 for (i = 0; i < ARRAY_SIZE (save_res_funcs); i++)
14318 if (!sfpr_define (info, &save_res_funcs[i], stub_sec))
14319 return FALSE;
14320 }
14321 }
14322
14323 if (htab->glink_eh_frame != NULL
14324 && htab->glink_eh_frame->size != 0)
14325 {
14326 bfd_vma val;
14327 size_t align = 4;
14328
14329 p = htab->glink_eh_frame->contents;
14330 p += (sizeof (glink_eh_frame_cie) + align - 1) & -align;
14331
14332 for (group = htab->group; group != NULL; group = group->next)
14333 if (group->eh_size != 0)
14334 {
14335 /* Offset to stub section. */
14336 val = (group->stub_sec->output_section->vma
14337 + group->stub_sec->output_offset);
14338 val -= (htab->glink_eh_frame->output_section->vma
14339 + htab->glink_eh_frame->output_offset
14340 + (p + 8 - htab->glink_eh_frame->contents));
14341 if (val + 0x80000000 > 0xffffffff)
14342 {
14343 _bfd_error_handler
14344 (_("%s offset too large for .eh_frame sdata4 encoding"),
14345 group->stub_sec->name);
14346 return FALSE;
14347 }
14348 bfd_put_32 (htab->elf.dynobj, val, p + 8);
14349 p += (group->eh_size + 17 + 3) & -4;
14350 }
14351 if (htab->glink != NULL && htab->glink->size != 0)
14352 {
14353 /* Offset to .glink. */
14354 val = (htab->glink->output_section->vma
14355 + htab->glink->output_offset
14356 + 8);
14357 val -= (htab->glink_eh_frame->output_section->vma
14358 + htab->glink_eh_frame->output_offset
14359 + (p + 8 - htab->glink_eh_frame->contents));
14360 if (val + 0x80000000 > 0xffffffff)
14361 {
14362 _bfd_error_handler
14363 (_("%s offset too large for .eh_frame sdata4 encoding"),
14364 htab->glink->name);
14365 return FALSE;
14366 }
14367 bfd_put_32 (htab->elf.dynobj, val, p + 8);
14368 p += (24 + align - 1) & -align;
14369 }
14370 }
14371
14372 for (group = htab->group; group != NULL; group = group->next)
14373 if ((stub_sec = group->stub_sec) != NULL)
14374 {
14375 stub_sec_count += 1;
14376 if (stub_sec->rawsize != stub_sec->size
14377 && (htab->stub_iteration <= STUB_SHRINK_ITER
14378 || stub_sec->rawsize < stub_sec->size))
14379 break;
14380 }
14381
14382 if (group != NULL)
14383 {
14384 htab->stub_error = TRUE;
14385 _bfd_error_handler (_("stubs don't match calculated size"));
14386 }
14387
14388 if (htab->stub_error)
14389 return FALSE;
14390
14391 if (stats != NULL)
14392 {
14393 size_t len;
14394 *stats = bfd_malloc (500);
14395 if (*stats == NULL)
14396 return FALSE;
14397
14398 len = sprintf (*stats,
14399 ngettext ("linker stubs in %u group\n",
14400 "linker stubs in %u groups\n",
14401 stub_sec_count),
14402 stub_sec_count);
14403 sprintf (*stats + len, _(" branch %lu\n"
14404 " branch toc adj %lu\n"
14405 " branch notoc %lu\n"
14406 " branch both %lu\n"
14407 " long branch %lu\n"
14408 " long toc adj %lu\n"
14409 " long notoc %lu\n"
14410 " long both %lu\n"
14411 " plt call %lu\n"
14412 " plt call save %lu\n"
14413 " plt call notoc %lu\n"
14414 " plt call both %lu\n"
14415 " global entry %lu"),
14416 htab->stub_count[ppc_stub_long_branch - 1],
14417 htab->stub_count[ppc_stub_long_branch_r2off - 1],
14418 htab->stub_count[ppc_stub_long_branch_notoc - 1],
14419 htab->stub_count[ppc_stub_long_branch_both - 1],
14420 htab->stub_count[ppc_stub_plt_branch - 1],
14421 htab->stub_count[ppc_stub_plt_branch_r2off - 1],
14422 htab->stub_count[ppc_stub_plt_branch_notoc - 1],
14423 htab->stub_count[ppc_stub_plt_branch_both - 1],
14424 htab->stub_count[ppc_stub_plt_call - 1],
14425 htab->stub_count[ppc_stub_plt_call_r2save - 1],
14426 htab->stub_count[ppc_stub_plt_call_notoc - 1],
14427 htab->stub_count[ppc_stub_plt_call_both - 1],
14428 htab->stub_count[ppc_stub_global_entry - 1]);
14429 }
14430 return TRUE;
14431 }
14432
14433 /* What to do when ld finds relocations against symbols defined in
14434 discarded sections. */
14435
14436 static unsigned int
14437 ppc64_elf_action_discarded (asection *sec)
14438 {
14439 if (strcmp (".opd", sec->name) == 0)
14440 return 0;
14441
14442 if (strcmp (".toc", sec->name) == 0)
14443 return 0;
14444
14445 if (strcmp (".toc1", sec->name) == 0)
14446 return 0;
14447
14448 return _bfd_elf_default_action_discarded (sec);
14449 }
14450
14451 /* The RELOCATE_SECTION function is called by the ELF backend linker
14452 to handle the relocations for a section.
14453
14454 The relocs are always passed as Rela structures; if the section
14455 actually uses Rel structures, the r_addend field will always be
14456 zero.
14457
14458 This function is responsible for adjust the section contents as
14459 necessary, and (if using Rela relocs and generating a
14460 relocatable output file) adjusting the reloc addend as
14461 necessary.
14462
14463 This function does not have to worry about setting the reloc
14464 address or the reloc symbol index.
14465
14466 LOCAL_SYMS is a pointer to the swapped in local symbols.
14467
14468 LOCAL_SECTIONS is an array giving the section in the input file
14469 corresponding to the st_shndx field of each local symbol.
14470
14471 The global hash table entry for the global symbols can be found
14472 via elf_sym_hashes (input_bfd).
14473
14474 When generating relocatable output, this function must handle
14475 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
14476 going to be the section symbol corresponding to the output
14477 section, which means that the addend must be adjusted
14478 accordingly. */
14479
14480 static bfd_boolean
14481 ppc64_elf_relocate_section (bfd *output_bfd,
14482 struct bfd_link_info *info,
14483 bfd *input_bfd,
14484 asection *input_section,
14485 bfd_byte *contents,
14486 Elf_Internal_Rela *relocs,
14487 Elf_Internal_Sym *local_syms,
14488 asection **local_sections)
14489 {
14490 struct ppc_link_hash_table *htab;
14491 Elf_Internal_Shdr *symtab_hdr;
14492 struct elf_link_hash_entry **sym_hashes;
14493 Elf_Internal_Rela *rel;
14494 Elf_Internal_Rela *wrel;
14495 Elf_Internal_Rela *relend;
14496 Elf_Internal_Rela outrel;
14497 bfd_byte *loc;
14498 struct got_entry **local_got_ents;
14499 bfd_vma TOCstart;
14500 bfd_boolean ret = TRUE;
14501 bfd_boolean is_opd;
14502 /* Assume 'at' branch hints. */
14503 bfd_boolean is_isa_v2 = TRUE;
14504 bfd_vma d_offset = (bfd_big_endian (input_bfd) ? 2 : 0);
14505
14506 /* Initialize howto table if needed. */
14507 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
14508 ppc_howto_init ();
14509
14510 htab = ppc_hash_table (info);
14511 if (htab == NULL)
14512 return FALSE;
14513
14514 /* Don't relocate stub sections. */
14515 if (input_section->owner == htab->params->stub_bfd)
14516 return TRUE;
14517
14518 BFD_ASSERT (is_ppc64_elf (input_bfd));
14519
14520 local_got_ents = elf_local_got_ents (input_bfd);
14521 TOCstart = elf_gp (output_bfd);
14522 symtab_hdr = &elf_symtab_hdr (input_bfd);
14523 sym_hashes = elf_sym_hashes (input_bfd);
14524 is_opd = ppc64_elf_section_data (input_section)->sec_type == sec_opd;
14525
14526 rel = wrel = relocs;
14527 relend = relocs + input_section->reloc_count;
14528 for (; rel < relend; wrel++, rel++)
14529 {
14530 enum elf_ppc64_reloc_type r_type;
14531 bfd_vma addend;
14532 bfd_reloc_status_type r;
14533 Elf_Internal_Sym *sym;
14534 asection *sec;
14535 struct elf_link_hash_entry *h_elf;
14536 struct ppc_link_hash_entry *h;
14537 struct ppc_link_hash_entry *fdh;
14538 const char *sym_name;
14539 unsigned long r_symndx, toc_symndx;
14540 bfd_vma toc_addend;
14541 unsigned char tls_mask, tls_gd, tls_type;
14542 unsigned char sym_type;
14543 bfd_vma relocation;
14544 bfd_boolean unresolved_reloc, save_unresolved_reloc;
14545 bfd_boolean warned;
14546 enum { DEST_NORMAL, DEST_OPD, DEST_STUB } reloc_dest;
14547 unsigned int insn;
14548 unsigned int mask;
14549 struct ppc_stub_hash_entry *stub_entry;
14550 bfd_vma max_br_offset;
14551 bfd_vma from;
14552 Elf_Internal_Rela orig_rel;
14553 reloc_howto_type *howto;
14554 struct reloc_howto_struct alt_howto;
14555
14556 again:
14557 orig_rel = *rel;
14558
14559 r_type = ELF64_R_TYPE (rel->r_info);
14560 r_symndx = ELF64_R_SYM (rel->r_info);
14561
14562 /* For old style R_PPC64_TOC relocs with a zero symbol, use the
14563 symbol of the previous ADDR64 reloc. The symbol gives us the
14564 proper TOC base to use. */
14565 if (rel->r_info == ELF64_R_INFO (0, R_PPC64_TOC)
14566 && wrel != relocs
14567 && ELF64_R_TYPE (wrel[-1].r_info) == R_PPC64_ADDR64
14568 && is_opd)
14569 r_symndx = ELF64_R_SYM (wrel[-1].r_info);
14570
14571 sym = NULL;
14572 sec = NULL;
14573 h_elf = NULL;
14574 sym_name = NULL;
14575 unresolved_reloc = FALSE;
14576 warned = FALSE;
14577
14578 if (r_symndx < symtab_hdr->sh_info)
14579 {
14580 /* It's a local symbol. */
14581 struct _opd_sec_data *opd;
14582
14583 sym = local_syms + r_symndx;
14584 sec = local_sections[r_symndx];
14585 sym_name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym, sec);
14586 sym_type = ELF64_ST_TYPE (sym->st_info);
14587 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
14588 opd = get_opd_info (sec);
14589 if (opd != NULL && opd->adjust != NULL)
14590 {
14591 long adjust = opd->adjust[OPD_NDX (sym->st_value
14592 + rel->r_addend)];
14593 if (adjust == -1)
14594 relocation = 0;
14595 else
14596 {
14597 /* If this is a relocation against the opd section sym
14598 and we have edited .opd, adjust the reloc addend so
14599 that ld -r and ld --emit-relocs output is correct.
14600 If it is a reloc against some other .opd symbol,
14601 then the symbol value will be adjusted later. */
14602 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
14603 rel->r_addend += adjust;
14604 else
14605 relocation += adjust;
14606 }
14607 }
14608 }
14609 else
14610 {
14611 bfd_boolean ignored;
14612
14613 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
14614 r_symndx, symtab_hdr, sym_hashes,
14615 h_elf, sec, relocation,
14616 unresolved_reloc, warned, ignored);
14617 sym_name = h_elf->root.root.string;
14618 sym_type = h_elf->type;
14619 if (sec != NULL
14620 && sec->owner == output_bfd
14621 && strcmp (sec->name, ".opd") == 0)
14622 {
14623 /* This is a symbol defined in a linker script. All
14624 such are defined in output sections, even those
14625 defined by simple assignment from a symbol defined in
14626 an input section. Transfer the symbol to an
14627 appropriate input .opd section, so that a branch to
14628 this symbol will be mapped to the location specified
14629 by the opd entry. */
14630 struct bfd_link_order *lo;
14631 for (lo = sec->map_head.link_order; lo != NULL; lo = lo->next)
14632 if (lo->type == bfd_indirect_link_order)
14633 {
14634 asection *isec = lo->u.indirect.section;
14635 if (h_elf->root.u.def.value >= isec->output_offset
14636 && h_elf->root.u.def.value < (isec->output_offset
14637 + isec->size))
14638 {
14639 h_elf->root.u.def.value -= isec->output_offset;
14640 h_elf->root.u.def.section = isec;
14641 sec = isec;
14642 break;
14643 }
14644 }
14645 }
14646 }
14647 h = (struct ppc_link_hash_entry *) h_elf;
14648
14649 if (sec != NULL && discarded_section (sec))
14650 {
14651 _bfd_clear_contents (ppc64_elf_howto_table[r_type],
14652 input_bfd, input_section,
14653 contents + rel->r_offset);
14654 wrel->r_offset = rel->r_offset;
14655 wrel->r_info = 0;
14656 wrel->r_addend = 0;
14657
14658 /* For ld -r, remove relocations in debug sections against
14659 symbols defined in discarded sections. Not done for
14660 non-debug to preserve relocs in .eh_frame which the
14661 eh_frame editing code expects to be present. */
14662 if (bfd_link_relocatable (info)
14663 && (input_section->flags & SEC_DEBUGGING))
14664 wrel--;
14665
14666 continue;
14667 }
14668
14669 if (bfd_link_relocatable (info))
14670 goto copy_reloc;
14671
14672 if (h != NULL && &h->elf == htab->elf.hgot)
14673 {
14674 relocation = TOCstart + htab->sec_info[input_section->id].toc_off;
14675 sec = bfd_abs_section_ptr;
14676 unresolved_reloc = FALSE;
14677 }
14678
14679 /* TLS optimizations. Replace instruction sequences and relocs
14680 based on information we collected in tls_optimize. We edit
14681 RELOCS so that --emit-relocs will output something sensible
14682 for the final instruction stream. */
14683 tls_mask = 0;
14684 tls_gd = 0;
14685 toc_symndx = 0;
14686 if (h != NULL)
14687 tls_mask = h->tls_mask;
14688 else if (local_got_ents != NULL)
14689 {
14690 struct plt_entry **local_plt = (struct plt_entry **)
14691 (local_got_ents + symtab_hdr->sh_info);
14692 unsigned char *lgot_masks = (unsigned char *)
14693 (local_plt + symtab_hdr->sh_info);
14694 tls_mask = lgot_masks[r_symndx];
14695 }
14696 if (((tls_mask & TLS_TLS) == 0 || tls_mask == (TLS_TLS | TLS_MARK))
14697 && (r_type == R_PPC64_TLS
14698 || r_type == R_PPC64_TLSGD
14699 || r_type == R_PPC64_TLSLD))
14700 {
14701 /* Check for toc tls entries. */
14702 unsigned char *toc_tls;
14703
14704 if (!get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
14705 &local_syms, rel, input_bfd))
14706 return FALSE;
14707
14708 if (toc_tls)
14709 tls_mask = *toc_tls;
14710 }
14711
14712 /* Check that tls relocs are used with tls syms, and non-tls
14713 relocs are used with non-tls syms. */
14714 if (r_symndx != STN_UNDEF
14715 && r_type != R_PPC64_NONE
14716 && (h == NULL
14717 || h->elf.root.type == bfd_link_hash_defined
14718 || h->elf.root.type == bfd_link_hash_defweak)
14719 && (IS_PPC64_TLS_RELOC (r_type)
14720 != (sym_type == STT_TLS
14721 || (sym_type == STT_SECTION
14722 && (sec->flags & SEC_THREAD_LOCAL) != 0))))
14723 {
14724 if ((tls_mask & TLS_TLS) != 0
14725 && (r_type == R_PPC64_TLS
14726 || r_type == R_PPC64_TLSGD
14727 || r_type == R_PPC64_TLSLD))
14728 /* R_PPC64_TLS is OK against a symbol in the TOC. */
14729 ;
14730 else
14731 info->callbacks->einfo
14732 (!IS_PPC64_TLS_RELOC (r_type)
14733 /* xgettext:c-format */
14734 ? _("%H: %s used with TLS symbol `%pT'\n")
14735 /* xgettext:c-format */
14736 : _("%H: %s used with non-TLS symbol `%pT'\n"),
14737 input_bfd, input_section, rel->r_offset,
14738 ppc64_elf_howto_table[r_type]->name,
14739 sym_name);
14740 }
14741
14742 /* Ensure reloc mapping code below stays sane. */
14743 if (R_PPC64_TOC16_LO_DS != R_PPC64_TOC16_DS + 1
14744 || R_PPC64_TOC16_LO != R_PPC64_TOC16 + 1
14745 || (R_PPC64_GOT_TLSLD16 & 3) != (R_PPC64_GOT_TLSGD16 & 3)
14746 || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TLSGD16_LO & 3)
14747 || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TLSGD16_HI & 3)
14748 || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TLSGD16_HA & 3)
14749 || (R_PPC64_GOT_TLSLD16 & 3) != (R_PPC64_GOT_TPREL16_DS & 3)
14750 || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TPREL16_LO_DS & 3)
14751 || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TPREL16_HI & 3)
14752 || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TPREL16_HA & 3))
14753 abort ();
14754
14755 switch (r_type)
14756 {
14757 default:
14758 break;
14759
14760 case R_PPC64_LO_DS_OPT:
14761 insn = bfd_get_32 (input_bfd, contents + rel->r_offset - d_offset);
14762 if ((insn & (0x3f << 26)) != 58u << 26)
14763 abort ();
14764 insn += (14u << 26) - (58u << 26);
14765 bfd_put_32 (input_bfd, insn, contents + rel->r_offset - d_offset);
14766 r_type = R_PPC64_TOC16_LO;
14767 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14768 break;
14769
14770 case R_PPC64_TOC16:
14771 case R_PPC64_TOC16_LO:
14772 case R_PPC64_TOC16_DS:
14773 case R_PPC64_TOC16_LO_DS:
14774 {
14775 /* Check for toc tls entries. */
14776 unsigned char *toc_tls;
14777 int retval;
14778
14779 retval = get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
14780 &local_syms, rel, input_bfd);
14781 if (retval == 0)
14782 return FALSE;
14783
14784 if (toc_tls)
14785 {
14786 tls_mask = *toc_tls;
14787 if (r_type == R_PPC64_TOC16_DS
14788 || r_type == R_PPC64_TOC16_LO_DS)
14789 {
14790 if ((tls_mask & TLS_TLS) != 0
14791 && (tls_mask & (TLS_DTPREL | TLS_TPREL)) == 0)
14792 goto toctprel;
14793 }
14794 else
14795 {
14796 /* If we found a GD reloc pair, then we might be
14797 doing a GD->IE transition. */
14798 if (retval == 2)
14799 {
14800 tls_gd = TLS_TPRELGD;
14801 if ((tls_mask & TLS_TLS) != 0
14802 && (tls_mask & TLS_GD) == 0)
14803 goto tls_ldgd_opt;
14804 }
14805 else if (retval == 3)
14806 {
14807 if ((tls_mask & TLS_TLS) != 0
14808 && (tls_mask & TLS_LD) == 0)
14809 goto tls_ldgd_opt;
14810 }
14811 }
14812 }
14813 }
14814 break;
14815
14816 case R_PPC64_GOT_TPREL16_HI:
14817 case R_PPC64_GOT_TPREL16_HA:
14818 if ((tls_mask & TLS_TLS) != 0
14819 && (tls_mask & TLS_TPREL) == 0)
14820 {
14821 rel->r_offset -= d_offset;
14822 bfd_put_32 (input_bfd, NOP, contents + rel->r_offset);
14823 r_type = R_PPC64_NONE;
14824 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14825 }
14826 break;
14827
14828 case R_PPC64_GOT_TPREL16_DS:
14829 case R_PPC64_GOT_TPREL16_LO_DS:
14830 if ((tls_mask & TLS_TLS) != 0
14831 && (tls_mask & TLS_TPREL) == 0)
14832 {
14833 toctprel:
14834 insn = bfd_get_32 (input_bfd,
14835 contents + rel->r_offset - d_offset);
14836 insn &= 31 << 21;
14837 insn |= 0x3c0d0000; /* addis 0,13,0 */
14838 bfd_put_32 (input_bfd, insn,
14839 contents + rel->r_offset - d_offset);
14840 r_type = R_PPC64_TPREL16_HA;
14841 if (toc_symndx != 0)
14842 {
14843 rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
14844 rel->r_addend = toc_addend;
14845 /* We changed the symbol. Start over in order to
14846 get h, sym, sec etc. right. */
14847 goto again;
14848 }
14849 else
14850 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14851 }
14852 break;
14853
14854 case R_PPC64_TLS:
14855 if ((tls_mask & TLS_TLS) != 0
14856 && (tls_mask & TLS_TPREL) == 0)
14857 {
14858 insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
14859 insn = _bfd_elf_ppc_at_tls_transform (insn, 13);
14860 if (insn == 0)
14861 abort ();
14862 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
14863 /* Was PPC64_TLS which sits on insn boundary, now
14864 PPC64_TPREL16_LO which is at low-order half-word. */
14865 rel->r_offset += d_offset;
14866 r_type = R_PPC64_TPREL16_LO;
14867 if (toc_symndx != 0)
14868 {
14869 rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
14870 rel->r_addend = toc_addend;
14871 /* We changed the symbol. Start over in order to
14872 get h, sym, sec etc. right. */
14873 goto again;
14874 }
14875 else
14876 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14877 }
14878 break;
14879
14880 case R_PPC64_GOT_TLSGD16_HI:
14881 case R_PPC64_GOT_TLSGD16_HA:
14882 tls_gd = TLS_TPRELGD;
14883 if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_GD) == 0)
14884 goto tls_gdld_hi;
14885 break;
14886
14887 case R_PPC64_GOT_TLSLD16_HI:
14888 case R_PPC64_GOT_TLSLD16_HA:
14889 if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_LD) == 0)
14890 {
14891 tls_gdld_hi:
14892 if ((tls_mask & tls_gd) != 0)
14893 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
14894 + R_PPC64_GOT_TPREL16_DS);
14895 else
14896 {
14897 rel->r_offset -= d_offset;
14898 bfd_put_32 (input_bfd, NOP, contents + rel->r_offset);
14899 r_type = R_PPC64_NONE;
14900 }
14901 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14902 }
14903 break;
14904
14905 case R_PPC64_GOT_TLSGD16:
14906 case R_PPC64_GOT_TLSGD16_LO:
14907 tls_gd = TLS_TPRELGD;
14908 if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_GD) == 0)
14909 goto tls_ldgd_opt;
14910 break;
14911
14912 case R_PPC64_GOT_TLSLD16:
14913 case R_PPC64_GOT_TLSLD16_LO:
14914 if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_LD) == 0)
14915 {
14916 unsigned int insn1, insn2;
14917 bfd_vma offset;
14918
14919 tls_ldgd_opt:
14920 offset = (bfd_vma) -1;
14921 /* If not using the newer R_PPC64_TLSGD/LD to mark
14922 __tls_get_addr calls, we must trust that the call
14923 stays with its arg setup insns, ie. that the next
14924 reloc is the __tls_get_addr call associated with
14925 the current reloc. Edit both insns. */
14926 if (input_section->has_tls_get_addr_call
14927 && rel + 1 < relend
14928 && branch_reloc_hash_match (input_bfd, rel + 1,
14929 htab->tls_get_addr,
14930 htab->tls_get_addr_fd))
14931 offset = rel[1].r_offset;
14932 /* We read the low GOT_TLS (or TOC16) insn because we
14933 need to keep the destination reg. It may be
14934 something other than the usual r3, and moved to r3
14935 before the call by intervening code. */
14936 insn1 = bfd_get_32 (input_bfd,
14937 contents + rel->r_offset - d_offset);
14938 if ((tls_mask & tls_gd) != 0)
14939 {
14940 /* IE */
14941 insn1 &= (0x1f << 21) | (0x1f << 16);
14942 insn1 |= 58 << 26; /* ld */
14943 insn2 = 0x7c636a14; /* add 3,3,13 */
14944 if (offset != (bfd_vma) -1)
14945 rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
14946 if ((tls_mask & TLS_EXPLICIT) == 0)
14947 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
14948 + R_PPC64_GOT_TPREL16_DS);
14949 else
14950 r_type += R_PPC64_TOC16_DS - R_PPC64_TOC16;
14951 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14952 }
14953 else
14954 {
14955 /* LE */
14956 insn1 &= 0x1f << 21;
14957 insn1 |= 0x3c0d0000; /* addis r,13,0 */
14958 insn2 = 0x38630000; /* addi 3,3,0 */
14959 if (tls_gd == 0)
14960 {
14961 /* Was an LD reloc. */
14962 if (toc_symndx)
14963 sec = local_sections[toc_symndx];
14964 for (r_symndx = 0;
14965 r_symndx < symtab_hdr->sh_info;
14966 r_symndx++)
14967 if (local_sections[r_symndx] == sec)
14968 break;
14969 if (r_symndx >= symtab_hdr->sh_info)
14970 r_symndx = STN_UNDEF;
14971 rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
14972 if (r_symndx != STN_UNDEF)
14973 rel->r_addend -= (local_syms[r_symndx].st_value
14974 + sec->output_offset
14975 + sec->output_section->vma);
14976 }
14977 else if (toc_symndx != 0)
14978 {
14979 r_symndx = toc_symndx;
14980 rel->r_addend = toc_addend;
14981 }
14982 r_type = R_PPC64_TPREL16_HA;
14983 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14984 if (offset != (bfd_vma) -1)
14985 {
14986 rel[1].r_info = ELF64_R_INFO (r_symndx,
14987 R_PPC64_TPREL16_LO);
14988 rel[1].r_offset = offset + d_offset;
14989 rel[1].r_addend = rel->r_addend;
14990 }
14991 }
14992 bfd_put_32 (input_bfd, insn1,
14993 contents + rel->r_offset - d_offset);
14994 if (offset != (bfd_vma) -1)
14995 bfd_put_32 (input_bfd, insn2, contents + offset);
14996 if ((tls_mask & tls_gd) == 0
14997 && (tls_gd == 0 || toc_symndx != 0))
14998 {
14999 /* We changed the symbol. Start over in order
15000 to get h, sym, sec etc. right. */
15001 goto again;
15002 }
15003 }
15004 break;
15005
15006 case R_PPC64_TLSGD:
15007 if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_GD) == 0
15008 && rel + 1 < relend)
15009 {
15010 unsigned int insn2;
15011 bfd_vma offset = rel->r_offset;
15012
15013 if (is_plt_seq_reloc (ELF64_R_TYPE (rel[1].r_info)))
15014 {
15015 bfd_put_32 (output_bfd, NOP, contents + offset);
15016 rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
15017 break;
15018 }
15019
15020 if (ELF64_R_TYPE (rel[1].r_info) == R_PPC64_PLTCALL)
15021 bfd_put_32 (output_bfd, NOP, contents + offset + 4);
15022
15023 if ((tls_mask & TLS_TPRELGD) != 0)
15024 {
15025 /* IE */
15026 r_type = R_PPC64_NONE;
15027 insn2 = 0x7c636a14; /* add 3,3,13 */
15028 }
15029 else
15030 {
15031 /* LE */
15032 if (toc_symndx != 0)
15033 {
15034 r_symndx = toc_symndx;
15035 rel->r_addend = toc_addend;
15036 }
15037 r_type = R_PPC64_TPREL16_LO;
15038 rel->r_offset = offset + d_offset;
15039 insn2 = 0x38630000; /* addi 3,3,0 */
15040 }
15041 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
15042 /* Zap the reloc on the _tls_get_addr call too. */
15043 BFD_ASSERT (offset == rel[1].r_offset);
15044 rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
15045 bfd_put_32 (input_bfd, insn2, contents + offset);
15046 if ((tls_mask & TLS_TPRELGD) == 0 && toc_symndx != 0)
15047 goto again;
15048 }
15049 break;
15050
15051 case R_PPC64_TLSLD:
15052 if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_LD) == 0
15053 && rel + 1 < relend)
15054 {
15055 unsigned int insn2;
15056 bfd_vma offset = rel->r_offset;
15057
15058 if (is_plt_seq_reloc (ELF64_R_TYPE (rel[1].r_info)))
15059 {
15060 bfd_put_32 (output_bfd, NOP, contents + offset);
15061 rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
15062 break;
15063 }
15064
15065 if (ELF64_R_TYPE (rel[1].r_info) == R_PPC64_PLTCALL)
15066 bfd_put_32 (output_bfd, NOP, contents + offset + 4);
15067
15068 if (toc_symndx)
15069 sec = local_sections[toc_symndx];
15070 for (r_symndx = 0;
15071 r_symndx < symtab_hdr->sh_info;
15072 r_symndx++)
15073 if (local_sections[r_symndx] == sec)
15074 break;
15075 if (r_symndx >= symtab_hdr->sh_info)
15076 r_symndx = STN_UNDEF;
15077 rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
15078 if (r_symndx != STN_UNDEF)
15079 rel->r_addend -= (local_syms[r_symndx].st_value
15080 + sec->output_offset
15081 + sec->output_section->vma);
15082
15083 r_type = R_PPC64_TPREL16_LO;
15084 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
15085 rel->r_offset = offset + d_offset;
15086 /* Zap the reloc on the _tls_get_addr call too. */
15087 BFD_ASSERT (offset == rel[1].r_offset);
15088 rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
15089 insn2 = 0x38630000; /* addi 3,3,0 */
15090 bfd_put_32 (input_bfd, insn2, contents + offset);
15091 goto again;
15092 }
15093 break;
15094
15095 case R_PPC64_DTPMOD64:
15096 if (rel + 1 < relend
15097 && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
15098 && rel[1].r_offset == rel->r_offset + 8)
15099 {
15100 if ((tls_mask & TLS_GD) == 0)
15101 {
15102 rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_NONE);
15103 if ((tls_mask & TLS_TPRELGD) != 0)
15104 r_type = R_PPC64_TPREL64;
15105 else
15106 {
15107 bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
15108 r_type = R_PPC64_NONE;
15109 }
15110 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
15111 }
15112 }
15113 else
15114 {
15115 if ((tls_mask & TLS_LD) == 0)
15116 {
15117 bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
15118 r_type = R_PPC64_NONE;
15119 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
15120 }
15121 }
15122 break;
15123
15124 case R_PPC64_TPREL64:
15125 if ((tls_mask & TLS_TPREL) == 0)
15126 {
15127 r_type = R_PPC64_NONE;
15128 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
15129 }
15130 break;
15131
15132 case R_PPC64_ENTRY:
15133 relocation = TOCstart + htab->sec_info[input_section->id].toc_off;
15134 if (!bfd_link_pic (info)
15135 && !info->traditional_format
15136 && relocation + 0x80008000 <= 0xffffffff)
15137 {
15138 unsigned int insn1, insn2;
15139
15140 insn1 = bfd_get_32 (input_bfd, contents + rel->r_offset);
15141 insn2 = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
15142 if ((insn1 & ~0xfffc) == LD_R2_0R12
15143 && insn2 == ADD_R2_R2_R12)
15144 {
15145 bfd_put_32 (input_bfd,
15146 LIS_R2 + PPC_HA (relocation),
15147 contents + rel->r_offset);
15148 bfd_put_32 (input_bfd,
15149 ADDI_R2_R2 + PPC_LO (relocation),
15150 contents + rel->r_offset + 4);
15151 }
15152 }
15153 else
15154 {
15155 relocation -= (rel->r_offset
15156 + input_section->output_offset
15157 + input_section->output_section->vma);
15158 if (relocation + 0x80008000 <= 0xffffffff)
15159 {
15160 unsigned int insn1, insn2;
15161
15162 insn1 = bfd_get_32 (input_bfd, contents + rel->r_offset);
15163 insn2 = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
15164 if ((insn1 & ~0xfffc) == LD_R2_0R12
15165 && insn2 == ADD_R2_R2_R12)
15166 {
15167 bfd_put_32 (input_bfd,
15168 ADDIS_R2_R12 + PPC_HA (relocation),
15169 contents + rel->r_offset);
15170 bfd_put_32 (input_bfd,
15171 ADDI_R2_R2 + PPC_LO (relocation),
15172 contents + rel->r_offset + 4);
15173 }
15174 }
15175 }
15176 break;
15177
15178 case R_PPC64_REL16_HA:
15179 /* If we are generating a non-PIC executable, edit
15180 . 0: addis 2,12,.TOC.-0b@ha
15181 . addi 2,2,.TOC.-0b@l
15182 used by ELFv2 global entry points to set up r2, to
15183 . lis 2,.TOC.@ha
15184 . addi 2,2,.TOC.@l
15185 if .TOC. is in range. */
15186 if (!bfd_link_pic (info)
15187 && !info->traditional_format
15188 && !htab->opd_abi
15189 && rel->r_addend == d_offset
15190 && h != NULL && &h->elf == htab->elf.hgot
15191 && rel + 1 < relend
15192 && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_REL16_LO)
15193 && rel[1].r_offset == rel->r_offset + 4
15194 && rel[1].r_addend == rel->r_addend + 4
15195 && relocation + 0x80008000 <= 0xffffffff)
15196 {
15197 unsigned int insn1, insn2;
15198 bfd_vma offset = rel->r_offset - d_offset;
15199 insn1 = bfd_get_32 (input_bfd, contents + offset);
15200 insn2 = bfd_get_32 (input_bfd, contents + offset + 4);
15201 if ((insn1 & 0xffff0000) == ADDIS_R2_R12
15202 && (insn2 & 0xffff0000) == ADDI_R2_R2)
15203 {
15204 r_type = R_PPC64_ADDR16_HA;
15205 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
15206 rel->r_addend -= d_offset;
15207 rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_ADDR16_LO);
15208 rel[1].r_addend -= d_offset + 4;
15209 bfd_put_32 (input_bfd, LIS_R2, contents + offset);
15210 }
15211 }
15212 break;
15213 }
15214
15215 /* Handle other relocations that tweak non-addend part of insn. */
15216 insn = 0;
15217 max_br_offset = 1 << 25;
15218 addend = rel->r_addend;
15219 reloc_dest = DEST_NORMAL;
15220 switch (r_type)
15221 {
15222 default:
15223 break;
15224
15225 case R_PPC64_TOCSAVE:
15226 if (relocation + addend == (rel->r_offset
15227 + input_section->output_offset
15228 + input_section->output_section->vma)
15229 && tocsave_find (htab, NO_INSERT,
15230 &local_syms, rel, input_bfd))
15231 {
15232 insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
15233 if (insn == NOP
15234 || insn == CROR_151515 || insn == CROR_313131)
15235 bfd_put_32 (input_bfd,
15236 STD_R2_0R1 + STK_TOC (htab),
15237 contents + rel->r_offset);
15238 }
15239 break;
15240
15241 /* Branch taken prediction relocations. */
15242 case R_PPC64_ADDR14_BRTAKEN:
15243 case R_PPC64_REL14_BRTAKEN:
15244 insn = 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field. */
15245 /* Fall through. */
15246
15247 /* Branch not taken prediction relocations. */
15248 case R_PPC64_ADDR14_BRNTAKEN:
15249 case R_PPC64_REL14_BRNTAKEN:
15250 insn |= bfd_get_32 (input_bfd,
15251 contents + rel->r_offset) & ~(0x01 << 21);
15252 /* Fall through. */
15253
15254 case R_PPC64_REL14:
15255 max_br_offset = 1 << 15;
15256 /* Fall through. */
15257
15258 case R_PPC64_REL24:
15259 case R_PPC64_REL24_NOTOC:
15260 case R_PPC64_PLTCALL:
15261 /* Calls to functions with a different TOC, such as calls to
15262 shared objects, need to alter the TOC pointer. This is
15263 done using a linkage stub. A REL24 branching to these
15264 linkage stubs needs to be followed by a nop, as the nop
15265 will be replaced with an instruction to restore the TOC
15266 base pointer. */
15267 fdh = h;
15268 if (h != NULL
15269 && h->oh != NULL
15270 && h->oh->is_func_descriptor)
15271 fdh = ppc_follow_link (h->oh);
15272 stub_entry = ppc_get_stub_entry (input_section, sec, fdh, &orig_rel,
15273 htab);
15274 if (r_type == R_PPC64_PLTCALL
15275 && stub_entry != NULL
15276 && stub_entry->stub_type >= ppc_stub_plt_call
15277 && stub_entry->stub_type <= ppc_stub_plt_call_both)
15278 stub_entry = NULL;
15279
15280 if (stub_entry != NULL
15281 && (stub_entry->stub_type == ppc_stub_plt_call
15282 || stub_entry->stub_type == ppc_stub_plt_call_r2save
15283 || stub_entry->stub_type == ppc_stub_plt_call_both
15284 || stub_entry->stub_type == ppc_stub_plt_branch_r2off
15285 || stub_entry->stub_type == ppc_stub_plt_branch_both
15286 || stub_entry->stub_type == ppc_stub_long_branch_r2off
15287 || stub_entry->stub_type == ppc_stub_long_branch_both))
15288 {
15289 bfd_boolean can_plt_call = FALSE;
15290
15291 if (stub_entry->stub_type == ppc_stub_plt_call
15292 && !htab->opd_abi
15293 && htab->params->plt_localentry0 != 0
15294 && is_elfv2_localentry0 (&h->elf))
15295 {
15296 /* The function doesn't use or change r2. */
15297 can_plt_call = TRUE;
15298 }
15299 else if (r_type == R_PPC64_REL24_NOTOC)
15300 {
15301 /* NOTOC calls don't need to restore r2. */
15302 can_plt_call = TRUE;
15303 }
15304
15305 /* All of these stubs may modify r2, so there must be a
15306 branch and link followed by a nop. The nop is
15307 replaced by an insn to restore r2. */
15308 else if (rel->r_offset + 8 <= input_section->size)
15309 {
15310 unsigned long br;
15311
15312 br = bfd_get_32 (input_bfd,
15313 contents + rel->r_offset);
15314 if ((br & 1) != 0)
15315 {
15316 unsigned long nop;
15317
15318 nop = bfd_get_32 (input_bfd,
15319 contents + rel->r_offset + 4);
15320 if (nop == LD_R2_0R1 + STK_TOC (htab))
15321 can_plt_call = TRUE;
15322 else if (nop == NOP
15323 || nop == CROR_151515
15324 || nop == CROR_313131)
15325 {
15326 if (h != NULL
15327 && (h == htab->tls_get_addr_fd
15328 || h == htab->tls_get_addr)
15329 && htab->params->tls_get_addr_opt)
15330 {
15331 /* Special stub used, leave nop alone. */
15332 }
15333 else
15334 bfd_put_32 (input_bfd,
15335 LD_R2_0R1 + STK_TOC (htab),
15336 contents + rel->r_offset + 4);
15337 can_plt_call = TRUE;
15338 }
15339 }
15340 }
15341
15342 if (!can_plt_call && h != NULL)
15343 {
15344 const char *name = h->elf.root.root.string;
15345
15346 if (*name == '.')
15347 ++name;
15348
15349 if (strncmp (name, "__libc_start_main", 17) == 0
15350 && (name[17] == 0 || name[17] == '@'))
15351 {
15352 /* Allow crt1 branch to go via a toc adjusting
15353 stub. Other calls that never return could do
15354 the same, if we could detect such. */
15355 can_plt_call = TRUE;
15356 }
15357 }
15358
15359 if (!can_plt_call)
15360 {
15361 /* g++ as of 20130507 emits self-calls without a
15362 following nop. This is arguably wrong since we
15363 have conflicting information. On the one hand a
15364 global symbol and on the other a local call
15365 sequence, but don't error for this special case.
15366 It isn't possible to cheaply verify we have
15367 exactly such a call. Allow all calls to the same
15368 section. */
15369 asection *code_sec = sec;
15370
15371 if (get_opd_info (sec) != NULL)
15372 {
15373 bfd_vma off = (relocation + addend
15374 - sec->output_section->vma
15375 - sec->output_offset);
15376
15377 opd_entry_value (sec, off, &code_sec, NULL, FALSE);
15378 }
15379 if (code_sec == input_section)
15380 can_plt_call = TRUE;
15381 }
15382
15383 if (!can_plt_call)
15384 {
15385 if (stub_entry->stub_type >= ppc_stub_plt_call
15386 && stub_entry->stub_type <= ppc_stub_plt_call_both)
15387 info->callbacks->einfo
15388 /* xgettext:c-format */
15389 (_("%H: call to `%pT' lacks nop, can't restore toc; "
15390 "recompile with -fPIC\n"),
15391 input_bfd, input_section, rel->r_offset, sym_name);
15392 else
15393 info->callbacks->einfo
15394 /* xgettext:c-format */
15395 (_("%H: call to `%pT' lacks nop, can't restore toc; "
15396 "(-mcmodel=small toc adjust stub)\n"),
15397 input_bfd, input_section, rel->r_offset, sym_name);
15398
15399 bfd_set_error (bfd_error_bad_value);
15400 ret = FALSE;
15401 }
15402
15403 if (can_plt_call
15404 && stub_entry->stub_type >= ppc_stub_plt_call
15405 && stub_entry->stub_type <= ppc_stub_plt_call_both)
15406 unresolved_reloc = FALSE;
15407 }
15408
15409 if ((stub_entry == NULL
15410 || stub_entry->stub_type == ppc_stub_long_branch
15411 || stub_entry->stub_type == ppc_stub_plt_branch)
15412 && get_opd_info (sec) != NULL)
15413 {
15414 /* The branch destination is the value of the opd entry. */
15415 bfd_vma off = (relocation + addend
15416 - sec->output_section->vma
15417 - sec->output_offset);
15418 bfd_vma dest = opd_entry_value (sec, off, NULL, NULL, FALSE);
15419 if (dest != (bfd_vma) -1)
15420 {
15421 relocation = dest;
15422 addend = 0;
15423 reloc_dest = DEST_OPD;
15424 }
15425 }
15426
15427 /* If the branch is out of reach we ought to have a long
15428 branch stub. */
15429 from = (rel->r_offset
15430 + input_section->output_offset
15431 + input_section->output_section->vma);
15432
15433 relocation += PPC64_LOCAL_ENTRY_OFFSET (fdh
15434 ? fdh->elf.other
15435 : sym->st_other);
15436
15437 if (stub_entry != NULL
15438 && (stub_entry->stub_type == ppc_stub_long_branch
15439 || stub_entry->stub_type == ppc_stub_plt_branch)
15440 && (r_type == R_PPC64_ADDR14_BRTAKEN
15441 || r_type == R_PPC64_ADDR14_BRNTAKEN
15442 || (relocation + addend - from + max_br_offset
15443 < 2 * max_br_offset)))
15444 /* Don't use the stub if this branch is in range. */
15445 stub_entry = NULL;
15446
15447 if (stub_entry != NULL
15448 && (stub_entry->stub_type == ppc_stub_long_branch_notoc
15449 || stub_entry->stub_type == ppc_stub_long_branch_both
15450 || stub_entry->stub_type == ppc_stub_plt_branch_notoc
15451 || stub_entry->stub_type == ppc_stub_plt_branch_both)
15452 && (r_type != R_PPC64_REL24_NOTOC
15453 || ((fdh ? fdh->elf.other : sym->st_other)
15454 & STO_PPC64_LOCAL_MASK) == 1 << STO_PPC64_LOCAL_BIT)
15455 && (relocation + addend - from + max_br_offset
15456 < 2 * max_br_offset))
15457 stub_entry = NULL;
15458
15459 if (stub_entry != NULL
15460 && (stub_entry->stub_type == ppc_stub_long_branch_r2off
15461 || stub_entry->stub_type == ppc_stub_long_branch_both
15462 || stub_entry->stub_type == ppc_stub_plt_branch_r2off
15463 || stub_entry->stub_type == ppc_stub_plt_branch_both)
15464 && r_type == R_PPC64_REL24_NOTOC
15465 && (relocation + addend - from + max_br_offset
15466 < 2 * max_br_offset))
15467 stub_entry = NULL;
15468
15469 if (stub_entry != NULL)
15470 {
15471 /* Munge up the value and addend so that we call the stub
15472 rather than the procedure directly. */
15473 asection *stub_sec = stub_entry->group->stub_sec;
15474
15475 if (stub_entry->stub_type == ppc_stub_save_res)
15476 relocation += (stub_sec->output_offset
15477 + stub_sec->output_section->vma
15478 + stub_sec->size - htab->sfpr->size
15479 - htab->sfpr->output_offset
15480 - htab->sfpr->output_section->vma);
15481 else
15482 relocation = (stub_entry->stub_offset
15483 + stub_sec->output_offset
15484 + stub_sec->output_section->vma);
15485 addend = 0;
15486 reloc_dest = DEST_STUB;
15487
15488 if (((stub_entry->stub_type == ppc_stub_plt_call
15489 && ALWAYS_EMIT_R2SAVE)
15490 || stub_entry->stub_type == ppc_stub_plt_call_r2save
15491 || stub_entry->stub_type == ppc_stub_plt_call_both)
15492 && !(h != NULL
15493 && (h == htab->tls_get_addr_fd
15494 || h == htab->tls_get_addr)
15495 && htab->params->tls_get_addr_opt)
15496 && rel + 1 < relend
15497 && rel[1].r_offset == rel->r_offset + 4
15498 && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOCSAVE)
15499 relocation += 4;
15500 else if ((stub_entry->stub_type == ppc_stub_long_branch_both
15501 || stub_entry->stub_type == ppc_stub_plt_branch_both
15502 || stub_entry->stub_type == ppc_stub_plt_call_both)
15503 && r_type == R_PPC64_REL24_NOTOC)
15504 relocation += 4;
15505 }
15506
15507 if (insn != 0)
15508 {
15509 if (is_isa_v2)
15510 {
15511 /* Set 'a' bit. This is 0b00010 in BO field for branch
15512 on CR(BI) insns (BO == 001at or 011at), and 0b01000
15513 for branch on CTR insns (BO == 1a00t or 1a01t). */
15514 if ((insn & (0x14 << 21)) == (0x04 << 21))
15515 insn |= 0x02 << 21;
15516 else if ((insn & (0x14 << 21)) == (0x10 << 21))
15517 insn |= 0x08 << 21;
15518 else
15519 break;
15520 }
15521 else
15522 {
15523 /* Invert 'y' bit if not the default. */
15524 if ((bfd_signed_vma) (relocation + addend - from) < 0)
15525 insn ^= 0x01 << 21;
15526 }
15527
15528 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
15529 }
15530
15531 /* NOP out calls to undefined weak functions.
15532 We can thus call a weak function without first
15533 checking whether the function is defined. */
15534 else if (h != NULL
15535 && h->elf.root.type == bfd_link_hash_undefweak
15536 && h->elf.dynindx == -1
15537 && (r_type == R_PPC64_REL24
15538 || r_type == R_PPC64_REL24_NOTOC)
15539 && relocation == 0
15540 && addend == 0)
15541 {
15542 bfd_put_32 (input_bfd, NOP, contents + rel->r_offset);
15543 goto copy_reloc;
15544 }
15545 break;
15546 }
15547
15548 /* Set `addend'. */
15549 tls_type = 0;
15550 save_unresolved_reloc = unresolved_reloc;
15551 switch (r_type)
15552 {
15553 default:
15554 /* xgettext:c-format */
15555 _bfd_error_handler (_("%pB: %s unsupported"),
15556 input_bfd, ppc64_elf_howto_table[r_type]->name);
15557
15558 bfd_set_error (bfd_error_bad_value);
15559 ret = FALSE;
15560 goto copy_reloc;
15561
15562 case R_PPC64_NONE:
15563 case R_PPC64_TLS:
15564 case R_PPC64_TLSGD:
15565 case R_PPC64_TLSLD:
15566 case R_PPC64_TOCSAVE:
15567 case R_PPC64_GNU_VTINHERIT:
15568 case R_PPC64_GNU_VTENTRY:
15569 case R_PPC64_ENTRY:
15570 goto copy_reloc;
15571
15572 /* GOT16 relocations. Like an ADDR16 using the symbol's
15573 address in the GOT as relocation value instead of the
15574 symbol's value itself. Also, create a GOT entry for the
15575 symbol and put the symbol value there. */
15576 case R_PPC64_GOT_TLSGD16:
15577 case R_PPC64_GOT_TLSGD16_LO:
15578 case R_PPC64_GOT_TLSGD16_HI:
15579 case R_PPC64_GOT_TLSGD16_HA:
15580 tls_type = TLS_TLS | TLS_GD;
15581 goto dogot;
15582
15583 case R_PPC64_GOT_TLSLD16:
15584 case R_PPC64_GOT_TLSLD16_LO:
15585 case R_PPC64_GOT_TLSLD16_HI:
15586 case R_PPC64_GOT_TLSLD16_HA:
15587 tls_type = TLS_TLS | TLS_LD;
15588 goto dogot;
15589
15590 case R_PPC64_GOT_TPREL16_DS:
15591 case R_PPC64_GOT_TPREL16_LO_DS:
15592 case R_PPC64_GOT_TPREL16_HI:
15593 case R_PPC64_GOT_TPREL16_HA:
15594 tls_type = TLS_TLS | TLS_TPREL;
15595 goto dogot;
15596
15597 case R_PPC64_GOT_DTPREL16_DS:
15598 case R_PPC64_GOT_DTPREL16_LO_DS:
15599 case R_PPC64_GOT_DTPREL16_HI:
15600 case R_PPC64_GOT_DTPREL16_HA:
15601 tls_type = TLS_TLS | TLS_DTPREL;
15602 goto dogot;
15603
15604 case R_PPC64_GOT16:
15605 case R_PPC64_GOT16_LO:
15606 case R_PPC64_GOT16_HI:
15607 case R_PPC64_GOT16_HA:
15608 case R_PPC64_GOT16_DS:
15609 case R_PPC64_GOT16_LO_DS:
15610 dogot:
15611 {
15612 /* Relocation is to the entry for this symbol in the global
15613 offset table. */
15614 asection *got;
15615 bfd_vma *offp;
15616 bfd_vma off;
15617 unsigned long indx = 0;
15618 struct got_entry *ent;
15619
15620 if (tls_type == (TLS_TLS | TLS_LD)
15621 && (h == NULL
15622 || !h->elf.def_dynamic))
15623 ent = ppc64_tlsld_got (input_bfd);
15624 else
15625 {
15626 if (h != NULL)
15627 {
15628 if (!htab->elf.dynamic_sections_created
15629 || h->elf.dynindx == -1
15630 || SYMBOL_REFERENCES_LOCAL (info, &h->elf)
15631 || UNDEFWEAK_NO_DYNAMIC_RELOC (info, &h->elf))
15632 /* This is actually a static link, or it is a
15633 -Bsymbolic link and the symbol is defined
15634 locally, or the symbol was forced to be local
15635 because of a version file. */
15636 ;
15637 else
15638 {
15639 indx = h->elf.dynindx;
15640 unresolved_reloc = FALSE;
15641 }
15642 ent = h->elf.got.glist;
15643 }
15644 else
15645 {
15646 if (local_got_ents == NULL)
15647 abort ();
15648 ent = local_got_ents[r_symndx];
15649 }
15650
15651 for (; ent != NULL; ent = ent->next)
15652 if (ent->addend == orig_rel.r_addend
15653 && ent->owner == input_bfd
15654 && ent->tls_type == tls_type)
15655 break;
15656 }
15657
15658 if (ent == NULL)
15659 abort ();
15660 if (ent->is_indirect)
15661 ent = ent->got.ent;
15662 offp = &ent->got.offset;
15663 got = ppc64_elf_tdata (ent->owner)->got;
15664 if (got == NULL)
15665 abort ();
15666
15667 /* The offset must always be a multiple of 8. We use the
15668 least significant bit to record whether we have already
15669 processed this entry. */
15670 off = *offp;
15671 if ((off & 1) != 0)
15672 off &= ~1;
15673 else
15674 {
15675 /* Generate relocs for the dynamic linker, except in
15676 the case of TLSLD where we'll use one entry per
15677 module. */
15678 asection *relgot;
15679 bfd_boolean ifunc;
15680
15681 *offp = off | 1;
15682 relgot = NULL;
15683 ifunc = (h != NULL
15684 ? h->elf.type == STT_GNU_IFUNC
15685 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC);
15686 if (ifunc)
15687 {
15688 relgot = htab->elf.irelplt;
15689 if (indx == 0)
15690 htab->local_ifunc_resolver = 1;
15691 else if (is_static_defined (&h->elf))
15692 htab->maybe_local_ifunc_resolver = 1;
15693 }
15694 else if (indx != 0
15695 || (bfd_link_pic (info)
15696 && (h == NULL
15697 || !UNDEFWEAK_NO_DYNAMIC_RELOC (info, &h->elf)
15698 || (tls_type == (TLS_TLS | TLS_LD)
15699 && !h->elf.def_dynamic))
15700 && !(tls_type == (TLS_TLS | TLS_TPREL)
15701 && bfd_link_executable (info)
15702 && SYMBOL_REFERENCES_LOCAL (info, &h->elf))))
15703 relgot = ppc64_elf_tdata (ent->owner)->relgot;
15704 if (relgot != NULL)
15705 {
15706 outrel.r_offset = (got->output_section->vma
15707 + got->output_offset
15708 + off);
15709 outrel.r_addend = addend;
15710 if (tls_type & (TLS_LD | TLS_GD))
15711 {
15712 outrel.r_addend = 0;
15713 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPMOD64);
15714 if (tls_type == (TLS_TLS | TLS_GD))
15715 {
15716 loc = relgot->contents;
15717 loc += (relgot->reloc_count++
15718 * sizeof (Elf64_External_Rela));
15719 bfd_elf64_swap_reloca_out (output_bfd,
15720 &outrel, loc);
15721 outrel.r_offset += 8;
15722 outrel.r_addend = addend;
15723 outrel.r_info
15724 = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
15725 }
15726 }
15727 else if (tls_type == (TLS_TLS | TLS_DTPREL))
15728 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
15729 else if (tls_type == (TLS_TLS | TLS_TPREL))
15730 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_TPREL64);
15731 else if (indx != 0)
15732 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_GLOB_DAT);
15733 else
15734 {
15735 if (ifunc)
15736 outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
15737 else
15738 outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
15739
15740 /* Write the .got section contents for the sake
15741 of prelink. */
15742 loc = got->contents + off;
15743 bfd_put_64 (output_bfd, outrel.r_addend + relocation,
15744 loc);
15745 }
15746
15747 if (indx == 0 && tls_type != (TLS_TLS | TLS_LD))
15748 {
15749 outrel.r_addend += relocation;
15750 if (tls_type & (TLS_GD | TLS_DTPREL | TLS_TPREL))
15751 {
15752 if (htab->elf.tls_sec == NULL)
15753 outrel.r_addend = 0;
15754 else
15755 outrel.r_addend -= htab->elf.tls_sec->vma;
15756 }
15757 }
15758 loc = relgot->contents;
15759 loc += (relgot->reloc_count++
15760 * sizeof (Elf64_External_Rela));
15761 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
15762 }
15763
15764 /* Init the .got section contents here if we're not
15765 emitting a reloc. */
15766 else
15767 {
15768 relocation += addend;
15769 if (tls_type != 0)
15770 {
15771 if (htab->elf.tls_sec == NULL)
15772 relocation = 0;
15773 else
15774 {
15775 if (tls_type & TLS_LD)
15776 relocation = 0;
15777 else
15778 relocation -= htab->elf.tls_sec->vma + DTP_OFFSET;
15779 if (tls_type & TLS_TPREL)
15780 relocation += DTP_OFFSET - TP_OFFSET;
15781 }
15782
15783 if (tls_type & (TLS_GD | TLS_LD))
15784 {
15785 bfd_put_64 (output_bfd, relocation,
15786 got->contents + off + 8);
15787 relocation = 1;
15788 }
15789 }
15790 bfd_put_64 (output_bfd, relocation,
15791 got->contents + off);
15792 }
15793 }
15794
15795 if (off >= (bfd_vma) -2)
15796 abort ();
15797
15798 relocation = got->output_section->vma + got->output_offset + off;
15799 addend = -(TOCstart + htab->sec_info[input_section->id].toc_off);
15800 }
15801 break;
15802
15803 case R_PPC64_PLT16_HA:
15804 case R_PPC64_PLT16_HI:
15805 case R_PPC64_PLT16_LO:
15806 case R_PPC64_PLT16_LO_DS:
15807 case R_PPC64_PLT32:
15808 case R_PPC64_PLT64:
15809 case R_PPC64_PLTSEQ:
15810 case R_PPC64_PLTCALL:
15811 /* Relocation is to the entry for this symbol in the
15812 procedure linkage table. */
15813 unresolved_reloc = TRUE;
15814 {
15815 struct plt_entry **plt_list = NULL;
15816 if (h != NULL)
15817 plt_list = &h->elf.plt.plist;
15818 else if (local_got_ents != NULL)
15819 {
15820 struct plt_entry **local_plt = (struct plt_entry **)
15821 (local_got_ents + symtab_hdr->sh_info);
15822 plt_list = local_plt + r_symndx;
15823 }
15824 if (plt_list)
15825 {
15826 struct plt_entry *ent;
15827
15828 for (ent = *plt_list; ent != NULL; ent = ent->next)
15829 if (ent->plt.offset != (bfd_vma) -1
15830 && ent->addend == orig_rel.r_addend)
15831 {
15832 asection *plt;
15833 bfd_vma got;
15834
15835 plt = htab->elf.splt;
15836 if (!htab->elf.dynamic_sections_created
15837 || h == NULL
15838 || h->elf.dynindx == -1)
15839 {
15840 if (h != NULL
15841 ? h->elf.type == STT_GNU_IFUNC
15842 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
15843 plt = htab->elf.iplt;
15844 else
15845 plt = htab->pltlocal;
15846 }
15847 relocation = (plt->output_section->vma
15848 + plt->output_offset
15849 + ent->plt.offset);
15850 if (r_type == R_PPC64_PLT16_HA
15851 || r_type ==R_PPC64_PLT16_HI
15852 || r_type ==R_PPC64_PLT16_LO
15853 || r_type ==R_PPC64_PLT16_LO_DS)
15854 {
15855 got = (elf_gp (output_bfd)
15856 + htab->sec_info[input_section->id].toc_off);
15857 relocation -= got;
15858 }
15859 addend = 0;
15860 unresolved_reloc = FALSE;
15861 break;
15862 }
15863 }
15864 }
15865 break;
15866
15867 case R_PPC64_TOC:
15868 /* Relocation value is TOC base. */
15869 relocation = TOCstart;
15870 if (r_symndx == STN_UNDEF)
15871 relocation += htab->sec_info[input_section->id].toc_off;
15872 else if (unresolved_reloc)
15873 ;
15874 else if (sec != NULL && sec->id < htab->sec_info_arr_size)
15875 relocation += htab->sec_info[sec->id].toc_off;
15876 else
15877 unresolved_reloc = TRUE;
15878 goto dodyn;
15879
15880 /* TOC16 relocs. We want the offset relative to the TOC base,
15881 which is the address of the start of the TOC plus 0x8000.
15882 The TOC consists of sections .got, .toc, .tocbss, and .plt,
15883 in this order. */
15884 case R_PPC64_TOC16:
15885 case R_PPC64_TOC16_LO:
15886 case R_PPC64_TOC16_HI:
15887 case R_PPC64_TOC16_DS:
15888 case R_PPC64_TOC16_LO_DS:
15889 case R_PPC64_TOC16_HA:
15890 addend -= TOCstart + htab->sec_info[input_section->id].toc_off;
15891 break;
15892
15893 /* Relocate against the beginning of the section. */
15894 case R_PPC64_SECTOFF:
15895 case R_PPC64_SECTOFF_LO:
15896 case R_PPC64_SECTOFF_HI:
15897 case R_PPC64_SECTOFF_DS:
15898 case R_PPC64_SECTOFF_LO_DS:
15899 case R_PPC64_SECTOFF_HA:
15900 if (sec != NULL)
15901 addend -= sec->output_section->vma;
15902 break;
15903
15904 case R_PPC64_REL16:
15905 case R_PPC64_REL16_LO:
15906 case R_PPC64_REL16_HI:
15907 case R_PPC64_REL16_HA:
15908 case R_PPC64_REL16DX_HA:
15909 break;
15910
15911 case R_PPC64_REL14:
15912 case R_PPC64_REL14_BRNTAKEN:
15913 case R_PPC64_REL14_BRTAKEN:
15914 case R_PPC64_REL24:
15915 case R_PPC64_REL24_NOTOC:
15916 break;
15917
15918 case R_PPC64_TPREL16:
15919 case R_PPC64_TPREL16_LO:
15920 case R_PPC64_TPREL16_HI:
15921 case R_PPC64_TPREL16_HA:
15922 case R_PPC64_TPREL16_DS:
15923 case R_PPC64_TPREL16_LO_DS:
15924 case R_PPC64_TPREL16_HIGH:
15925 case R_PPC64_TPREL16_HIGHA:
15926 case R_PPC64_TPREL16_HIGHER:
15927 case R_PPC64_TPREL16_HIGHERA:
15928 case R_PPC64_TPREL16_HIGHEST:
15929 case R_PPC64_TPREL16_HIGHESTA:
15930 if (h != NULL
15931 && h->elf.root.type == bfd_link_hash_undefweak
15932 && h->elf.dynindx == -1)
15933 {
15934 /* Make this relocation against an undefined weak symbol
15935 resolve to zero. This is really just a tweak, since
15936 code using weak externs ought to check that they are
15937 defined before using them. */
15938 bfd_byte *p = contents + rel->r_offset - d_offset;
15939
15940 insn = bfd_get_32 (input_bfd, p);
15941 insn = _bfd_elf_ppc_at_tprel_transform (insn, 13);
15942 if (insn != 0)
15943 bfd_put_32 (input_bfd, insn, p);
15944 break;
15945 }
15946 if (htab->elf.tls_sec != NULL)
15947 addend -= htab->elf.tls_sec->vma + TP_OFFSET;
15948 /* The TPREL16 relocs shouldn't really be used in shared
15949 libs or with non-local symbols as that will result in
15950 DT_TEXTREL being set, but support them anyway. */
15951 goto dodyn;
15952
15953 case R_PPC64_DTPREL16:
15954 case R_PPC64_DTPREL16_LO:
15955 case R_PPC64_DTPREL16_HI:
15956 case R_PPC64_DTPREL16_HA:
15957 case R_PPC64_DTPREL16_DS:
15958 case R_PPC64_DTPREL16_LO_DS:
15959 case R_PPC64_DTPREL16_HIGH:
15960 case R_PPC64_DTPREL16_HIGHA:
15961 case R_PPC64_DTPREL16_HIGHER:
15962 case R_PPC64_DTPREL16_HIGHERA:
15963 case R_PPC64_DTPREL16_HIGHEST:
15964 case R_PPC64_DTPREL16_HIGHESTA:
15965 if (htab->elf.tls_sec != NULL)
15966 addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
15967 break;
15968
15969 case R_PPC64_ADDR64_LOCAL:
15970 addend += PPC64_LOCAL_ENTRY_OFFSET (h != NULL
15971 ? h->elf.other
15972 : sym->st_other);
15973 break;
15974
15975 case R_PPC64_DTPMOD64:
15976 relocation = 1;
15977 addend = 0;
15978 goto dodyn;
15979
15980 case R_PPC64_TPREL64:
15981 if (htab->elf.tls_sec != NULL)
15982 addend -= htab->elf.tls_sec->vma + TP_OFFSET;
15983 goto dodyn;
15984
15985 case R_PPC64_DTPREL64:
15986 if (htab->elf.tls_sec != NULL)
15987 addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
15988 /* Fall through. */
15989
15990 /* Relocations that may need to be propagated if this is a
15991 dynamic object. */
15992 case R_PPC64_REL30:
15993 case R_PPC64_REL32:
15994 case R_PPC64_REL64:
15995 case R_PPC64_ADDR14:
15996 case R_PPC64_ADDR14_BRNTAKEN:
15997 case R_PPC64_ADDR14_BRTAKEN:
15998 case R_PPC64_ADDR16:
15999 case R_PPC64_ADDR16_DS:
16000 case R_PPC64_ADDR16_HA:
16001 case R_PPC64_ADDR16_HI:
16002 case R_PPC64_ADDR16_HIGH:
16003 case R_PPC64_ADDR16_HIGHA:
16004 case R_PPC64_ADDR16_HIGHER:
16005 case R_PPC64_ADDR16_HIGHERA:
16006 case R_PPC64_ADDR16_HIGHEST:
16007 case R_PPC64_ADDR16_HIGHESTA:
16008 case R_PPC64_ADDR16_LO:
16009 case R_PPC64_ADDR16_LO_DS:
16010 case R_PPC64_ADDR24:
16011 case R_PPC64_ADDR32:
16012 case R_PPC64_ADDR64:
16013 case R_PPC64_UADDR16:
16014 case R_PPC64_UADDR32:
16015 case R_PPC64_UADDR64:
16016 dodyn:
16017 if ((input_section->flags & SEC_ALLOC) == 0)
16018 break;
16019
16020 if (NO_OPD_RELOCS && is_opd)
16021 break;
16022
16023 if (bfd_link_pic (info)
16024 ? ((h == NULL
16025 || h->dyn_relocs != NULL)
16026 && ((h != NULL && pc_dynrelocs (h))
16027 || must_be_dyn_reloc (info, r_type)))
16028 : (h != NULL
16029 ? h->dyn_relocs != NULL
16030 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
16031 {
16032 bfd_boolean skip, relocate;
16033 asection *sreloc;
16034 bfd_vma out_off;
16035 long indx = 0;
16036
16037 /* When generating a dynamic object, these relocations
16038 are copied into the output file to be resolved at run
16039 time. */
16040
16041 skip = FALSE;
16042 relocate = FALSE;
16043
16044 out_off = _bfd_elf_section_offset (output_bfd, info,
16045 input_section, rel->r_offset);
16046 if (out_off == (bfd_vma) -1)
16047 skip = TRUE;
16048 else if (out_off == (bfd_vma) -2)
16049 skip = TRUE, relocate = TRUE;
16050 out_off += (input_section->output_section->vma
16051 + input_section->output_offset);
16052 outrel.r_offset = out_off;
16053 outrel.r_addend = rel->r_addend;
16054
16055 /* Optimize unaligned reloc use. */
16056 if ((r_type == R_PPC64_ADDR64 && (out_off & 7) != 0)
16057 || (r_type == R_PPC64_UADDR64 && (out_off & 7) == 0))
16058 r_type ^= R_PPC64_ADDR64 ^ R_PPC64_UADDR64;
16059 else if ((r_type == R_PPC64_ADDR32 && (out_off & 3) != 0)
16060 || (r_type == R_PPC64_UADDR32 && (out_off & 3) == 0))
16061 r_type ^= R_PPC64_ADDR32 ^ R_PPC64_UADDR32;
16062 else if ((r_type == R_PPC64_ADDR16 && (out_off & 1) != 0)
16063 || (r_type == R_PPC64_UADDR16 && (out_off & 1) == 0))
16064 r_type ^= R_PPC64_ADDR16 ^ R_PPC64_UADDR16;
16065
16066 if (skip)
16067 memset (&outrel, 0, sizeof outrel);
16068 else if (!SYMBOL_REFERENCES_LOCAL (info, &h->elf)
16069 && !is_opd
16070 && r_type != R_PPC64_TOC)
16071 {
16072 indx = h->elf.dynindx;
16073 BFD_ASSERT (indx != -1);
16074 outrel.r_info = ELF64_R_INFO (indx, r_type);
16075 }
16076 else
16077 {
16078 /* This symbol is local, or marked to become local,
16079 or this is an opd section reloc which must point
16080 at a local function. */
16081 outrel.r_addend += relocation;
16082 if (r_type == R_PPC64_ADDR64 || r_type == R_PPC64_TOC)
16083 {
16084 if (is_opd && h != NULL)
16085 {
16086 /* Lie about opd entries. This case occurs
16087 when building shared libraries and we
16088 reference a function in another shared
16089 lib. The same thing happens for a weak
16090 definition in an application that's
16091 overridden by a strong definition in a
16092 shared lib. (I believe this is a generic
16093 bug in binutils handling of weak syms.)
16094 In these cases we won't use the opd
16095 entry in this lib. */
16096 unresolved_reloc = FALSE;
16097 }
16098 if (!is_opd
16099 && r_type == R_PPC64_ADDR64
16100 && (h != NULL
16101 ? h->elf.type == STT_GNU_IFUNC
16102 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
16103 outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
16104 else
16105 {
16106 outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
16107
16108 /* We need to relocate .opd contents for ld.so.
16109 Prelink also wants simple and consistent rules
16110 for relocs. This make all RELATIVE relocs have
16111 *r_offset equal to r_addend. */
16112 relocate = TRUE;
16113 }
16114 }
16115 else
16116 {
16117 if (h != NULL
16118 ? h->elf.type == STT_GNU_IFUNC
16119 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
16120 {
16121 info->callbacks->einfo
16122 /* xgettext:c-format */
16123 (_("%H: %s for indirect "
16124 "function `%pT' unsupported\n"),
16125 input_bfd, input_section, rel->r_offset,
16126 ppc64_elf_howto_table[r_type]->name,
16127 sym_name);
16128 ret = FALSE;
16129 }
16130 else if (r_symndx == STN_UNDEF || bfd_is_abs_section (sec))
16131 ;
16132 else if (sec == NULL || sec->owner == NULL)
16133 {
16134 bfd_set_error (bfd_error_bad_value);
16135 return FALSE;
16136 }
16137 else
16138 {
16139 asection *osec;
16140
16141 osec = sec->output_section;
16142 indx = elf_section_data (osec)->dynindx;
16143
16144 if (indx == 0)
16145 {
16146 if ((osec->flags & SEC_READONLY) == 0
16147 && htab->elf.data_index_section != NULL)
16148 osec = htab->elf.data_index_section;
16149 else
16150 osec = htab->elf.text_index_section;
16151 indx = elf_section_data (osec)->dynindx;
16152 }
16153 BFD_ASSERT (indx != 0);
16154
16155 /* We are turning this relocation into one
16156 against a section symbol, so subtract out
16157 the output section's address but not the
16158 offset of the input section in the output
16159 section. */
16160 outrel.r_addend -= osec->vma;
16161 }
16162
16163 outrel.r_info = ELF64_R_INFO (indx, r_type);
16164 }
16165 }
16166
16167 sreloc = elf_section_data (input_section)->sreloc;
16168 if (h != NULL
16169 ? h->elf.type == STT_GNU_IFUNC
16170 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
16171 {
16172 sreloc = htab->elf.irelplt;
16173 if (indx == 0)
16174 htab->local_ifunc_resolver = 1;
16175 else if (is_static_defined (&h->elf))
16176 htab->maybe_local_ifunc_resolver = 1;
16177 }
16178 if (sreloc == NULL)
16179 abort ();
16180
16181 if (sreloc->reloc_count * sizeof (Elf64_External_Rela)
16182 >= sreloc->size)
16183 abort ();
16184 loc = sreloc->contents;
16185 loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
16186 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
16187
16188 /* If this reloc is against an external symbol, it will
16189 be computed at runtime, so there's no need to do
16190 anything now. However, for the sake of prelink ensure
16191 that the section contents are a known value. */
16192 if (! relocate)
16193 {
16194 unresolved_reloc = FALSE;
16195 /* The value chosen here is quite arbitrary as ld.so
16196 ignores section contents except for the special
16197 case of .opd where the contents might be accessed
16198 before relocation. Choose zero, as that won't
16199 cause reloc overflow. */
16200 relocation = 0;
16201 addend = 0;
16202 /* Use *r_offset == r_addend for R_PPC64_ADDR64 relocs
16203 to improve backward compatibility with older
16204 versions of ld. */
16205 if (r_type == R_PPC64_ADDR64)
16206 addend = outrel.r_addend;
16207 /* Adjust pc_relative relocs to have zero in *r_offset. */
16208 else if (ppc64_elf_howto_table[r_type]->pc_relative)
16209 addend = outrel.r_offset;
16210 }
16211 }
16212 break;
16213
16214 case R_PPC64_COPY:
16215 case R_PPC64_GLOB_DAT:
16216 case R_PPC64_JMP_SLOT:
16217 case R_PPC64_JMP_IREL:
16218 case R_PPC64_RELATIVE:
16219 /* We shouldn't ever see these dynamic relocs in relocatable
16220 files. */
16221 /* Fall through. */
16222
16223 case R_PPC64_PLTGOT16:
16224 case R_PPC64_PLTGOT16_DS:
16225 case R_PPC64_PLTGOT16_HA:
16226 case R_PPC64_PLTGOT16_HI:
16227 case R_PPC64_PLTGOT16_LO:
16228 case R_PPC64_PLTGOT16_LO_DS:
16229 case R_PPC64_PLTREL32:
16230 case R_PPC64_PLTREL64:
16231 /* These ones haven't been implemented yet. */
16232
16233 info->callbacks->einfo
16234 /* xgettext:c-format */
16235 (_("%P: %pB: %s is not supported for `%pT'\n"),
16236 input_bfd,
16237 ppc64_elf_howto_table[r_type]->name, sym_name);
16238
16239 bfd_set_error (bfd_error_invalid_operation);
16240 ret = FALSE;
16241 goto copy_reloc;
16242 }
16243
16244 /* Multi-instruction sequences that access the TOC can be
16245 optimized, eg. addis ra,r2,0; addi rb,ra,x;
16246 to nop; addi rb,r2,x; */
16247 switch (r_type)
16248 {
16249 default:
16250 break;
16251
16252 case R_PPC64_GOT_TLSLD16_HI:
16253 case R_PPC64_GOT_TLSGD16_HI:
16254 case R_PPC64_GOT_TPREL16_HI:
16255 case R_PPC64_GOT_DTPREL16_HI:
16256 case R_PPC64_GOT16_HI:
16257 case R_PPC64_TOC16_HI:
16258 /* These relocs would only be useful if building up an
16259 offset to later add to r2, perhaps in an indexed
16260 addressing mode instruction. Don't try to optimize.
16261 Unfortunately, the possibility of someone building up an
16262 offset like this or even with the HA relocs, means that
16263 we need to check the high insn when optimizing the low
16264 insn. */
16265 break;
16266
16267 case R_PPC64_PLTCALL:
16268 if (unresolved_reloc)
16269 {
16270 /* No plt entry. Make this into a direct call. */
16271 bfd_byte *p = contents + rel->r_offset;
16272 insn = bfd_get_32 (input_bfd, p);
16273 insn &= 1;
16274 bfd_put_32 (input_bfd, B_DOT | insn, p);
16275 bfd_put_32 (input_bfd, NOP, p + 4);
16276 unresolved_reloc = save_unresolved_reloc;
16277 r_type = R_PPC64_REL24;
16278 }
16279 break;
16280
16281 case R_PPC64_PLTSEQ:
16282 if (unresolved_reloc)
16283 {
16284 unresolved_reloc = FALSE;
16285 goto nop_it;
16286 }
16287 break;
16288
16289 case R_PPC64_PLT16_HA:
16290 if (unresolved_reloc)
16291 {
16292 unresolved_reloc = FALSE;
16293 goto nop_it;
16294 }
16295 /* Fall through. */
16296 case R_PPC64_GOT_TLSLD16_HA:
16297 case R_PPC64_GOT_TLSGD16_HA:
16298 case R_PPC64_GOT_TPREL16_HA:
16299 case R_PPC64_GOT_DTPREL16_HA:
16300 case R_PPC64_GOT16_HA:
16301 case R_PPC64_TOC16_HA:
16302 if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
16303 && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
16304 {
16305 bfd_byte *p;
16306 nop_it:
16307 p = contents + (rel->r_offset & ~3);
16308 bfd_put_32 (input_bfd, NOP, p);
16309 goto copy_reloc;
16310 }
16311 break;
16312
16313 case R_PPC64_PLT16_LO:
16314 case R_PPC64_PLT16_LO_DS:
16315 if (unresolved_reloc)
16316 {
16317 unresolved_reloc = FALSE;
16318 goto nop_it;
16319 }
16320 /* Fall through. */
16321 case R_PPC64_GOT_TLSLD16_LO:
16322 case R_PPC64_GOT_TLSGD16_LO:
16323 case R_PPC64_GOT_TPREL16_LO_DS:
16324 case R_PPC64_GOT_DTPREL16_LO_DS:
16325 case R_PPC64_GOT16_LO:
16326 case R_PPC64_GOT16_LO_DS:
16327 case R_PPC64_TOC16_LO:
16328 case R_PPC64_TOC16_LO_DS:
16329 if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
16330 && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
16331 {
16332 bfd_byte *p = contents + (rel->r_offset & ~3);
16333 insn = bfd_get_32 (input_bfd, p);
16334 if ((insn & (0x3f << 26)) == 12u << 26 /* addic */)
16335 {
16336 /* Transform addic to addi when we change reg. */
16337 insn &= ~((0x3f << 26) | (0x1f << 16));
16338 insn |= (14u << 26) | (2 << 16);
16339 }
16340 else
16341 {
16342 insn &= ~(0x1f << 16);
16343 insn |= 2 << 16;
16344 }
16345 bfd_put_32 (input_bfd, insn, p);
16346 }
16347 break;
16348
16349 case R_PPC64_TPREL16_HA:
16350 if (htab->do_tls_opt && relocation + addend + 0x8000 < 0x10000)
16351 {
16352 bfd_byte *p = contents + (rel->r_offset & ~3);
16353 insn = bfd_get_32 (input_bfd, p);
16354 if ((insn & ((0x3f << 26) | 0x1f << 16))
16355 != ((15u << 26) | (13 << 16)) /* addis rt,13,imm */)
16356 /* xgettext:c-format */
16357 info->callbacks->minfo
16358 (_("%H: warning: %s unexpected insn %#x.\n"),
16359 input_bfd, input_section, rel->r_offset,
16360 ppc64_elf_howto_table[r_type]->name, insn);
16361 else
16362 {
16363 bfd_put_32 (input_bfd, NOP, p);
16364 goto copy_reloc;
16365 }
16366 }
16367 break;
16368
16369 case R_PPC64_TPREL16_LO:
16370 case R_PPC64_TPREL16_LO_DS:
16371 if (htab->do_tls_opt && relocation + addend + 0x8000 < 0x10000)
16372 {
16373 bfd_byte *p = contents + (rel->r_offset & ~3);
16374 insn = bfd_get_32 (input_bfd, p);
16375 insn &= ~(0x1f << 16);
16376 insn |= 13 << 16;
16377 bfd_put_32 (input_bfd, insn, p);
16378 }
16379 break;
16380 }
16381
16382 /* Do any further special processing. */
16383 switch (r_type)
16384 {
16385 default:
16386 break;
16387
16388 case R_PPC64_REL16_HA:
16389 case R_PPC64_REL16DX_HA:
16390 case R_PPC64_ADDR16_HA:
16391 case R_PPC64_ADDR16_HIGHA:
16392 case R_PPC64_ADDR16_HIGHERA:
16393 case R_PPC64_ADDR16_HIGHESTA:
16394 case R_PPC64_TOC16_HA:
16395 case R_PPC64_SECTOFF_HA:
16396 case R_PPC64_TPREL16_HA:
16397 case R_PPC64_TPREL16_HIGHA:
16398 case R_PPC64_TPREL16_HIGHERA:
16399 case R_PPC64_TPREL16_HIGHESTA:
16400 case R_PPC64_DTPREL16_HA:
16401 case R_PPC64_DTPREL16_HIGHA:
16402 case R_PPC64_DTPREL16_HIGHERA:
16403 case R_PPC64_DTPREL16_HIGHESTA:
16404 /* It's just possible that this symbol is a weak symbol
16405 that's not actually defined anywhere. In that case,
16406 'sec' would be NULL, and we should leave the symbol
16407 alone (it will be set to zero elsewhere in the link). */
16408 if (sec == NULL)
16409 break;
16410 /* Fall through. */
16411
16412 case R_PPC64_GOT16_HA:
16413 case R_PPC64_PLTGOT16_HA:
16414 case R_PPC64_PLT16_HA:
16415 case R_PPC64_GOT_TLSGD16_HA:
16416 case R_PPC64_GOT_TLSLD16_HA:
16417 case R_PPC64_GOT_TPREL16_HA:
16418 case R_PPC64_GOT_DTPREL16_HA:
16419 /* Add 0x10000 if sign bit in 0:15 is set.
16420 Bits 0:15 are not used. */
16421 addend += 0x8000;
16422 break;
16423
16424 case R_PPC64_ADDR16_DS:
16425 case R_PPC64_ADDR16_LO_DS:
16426 case R_PPC64_GOT16_DS:
16427 case R_PPC64_GOT16_LO_DS:
16428 case R_PPC64_PLT16_LO_DS:
16429 case R_PPC64_SECTOFF_DS:
16430 case R_PPC64_SECTOFF_LO_DS:
16431 case R_PPC64_TOC16_DS:
16432 case R_PPC64_TOC16_LO_DS:
16433 case R_PPC64_PLTGOT16_DS:
16434 case R_PPC64_PLTGOT16_LO_DS:
16435 case R_PPC64_GOT_TPREL16_DS:
16436 case R_PPC64_GOT_TPREL16_LO_DS:
16437 case R_PPC64_GOT_DTPREL16_DS:
16438 case R_PPC64_GOT_DTPREL16_LO_DS:
16439 case R_PPC64_TPREL16_DS:
16440 case R_PPC64_TPREL16_LO_DS:
16441 case R_PPC64_DTPREL16_DS:
16442 case R_PPC64_DTPREL16_LO_DS:
16443 insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
16444 mask = 3;
16445 /* If this reloc is against an lq, lxv, or stxv insn, then
16446 the value must be a multiple of 16. This is somewhat of
16447 a hack, but the "correct" way to do this by defining _DQ
16448 forms of all the _DS relocs bloats all reloc switches in
16449 this file. It doesn't make much sense to use these
16450 relocs in data, so testing the insn should be safe. */
16451 if ((insn & (0x3f << 26)) == (56u << 26)
16452 || ((insn & (0x3f << 26)) == (61u << 26) && (insn & 3) == 1))
16453 mask = 15;
16454 relocation += addend;
16455 addend = insn & (mask ^ 3);
16456 if ((relocation & mask) != 0)
16457 {
16458 relocation ^= relocation & mask;
16459 info->callbacks->einfo
16460 /* xgettext:c-format */
16461 (_("%H: error: %s not a multiple of %u\n"),
16462 input_bfd, input_section, rel->r_offset,
16463 ppc64_elf_howto_table[r_type]->name,
16464 mask + 1);
16465 bfd_set_error (bfd_error_bad_value);
16466 ret = FALSE;
16467 goto copy_reloc;
16468 }
16469 break;
16470 }
16471
16472 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
16473 because such sections are not SEC_ALLOC and thus ld.so will
16474 not process them. */
16475 howto = ppc64_elf_howto_table[(int) r_type];
16476 if (unresolved_reloc
16477 && !((input_section->flags & SEC_DEBUGGING) != 0
16478 && h->elf.def_dynamic)
16479 && _bfd_elf_section_offset (output_bfd, info, input_section,
16480 rel->r_offset) != (bfd_vma) -1)
16481 {
16482 info->callbacks->einfo
16483 /* xgettext:c-format */
16484 (_("%H: unresolvable %s against `%pT'\n"),
16485 input_bfd, input_section, rel->r_offset,
16486 howto->name,
16487 h->elf.root.root.string);
16488 ret = FALSE;
16489 }
16490
16491 /* 16-bit fields in insns mostly have signed values, but a
16492 few insns have 16-bit unsigned values. Really, we should
16493 have different reloc types. */
16494 if (howto->complain_on_overflow != complain_overflow_dont
16495 && howto->dst_mask == 0xffff
16496 && (input_section->flags & SEC_CODE) != 0)
16497 {
16498 enum complain_overflow complain = complain_overflow_signed;
16499
16500 insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
16501 if ((insn & (0x3f << 26)) == 10u << 26 /* cmpli */)
16502 complain = complain_overflow_bitfield;
16503 else if (howto->rightshift == 0
16504 ? ((insn & (0x3f << 26)) == 28u << 26 /* andi */
16505 || (insn & (0x3f << 26)) == 24u << 26 /* ori */
16506 || (insn & (0x3f << 26)) == 26u << 26 /* xori */)
16507 : ((insn & (0x3f << 26)) == 29u << 26 /* andis */
16508 || (insn & (0x3f << 26)) == 25u << 26 /* oris */
16509 || (insn & (0x3f << 26)) == 27u << 26 /* xoris */))
16510 complain = complain_overflow_unsigned;
16511 if (howto->complain_on_overflow != complain)
16512 {
16513 alt_howto = *howto;
16514 alt_howto.complain_on_overflow = complain;
16515 howto = &alt_howto;
16516 }
16517 }
16518
16519 if (r_type == R_PPC64_REL16DX_HA)
16520 {
16521 /* Split field reloc isn't handled by _bfd_final_link_relocate. */
16522 if (rel->r_offset + 4 > input_section->size)
16523 r = bfd_reloc_outofrange;
16524 else
16525 {
16526 relocation += addend;
16527 relocation -= (rel->r_offset
16528 + input_section->output_offset
16529 + input_section->output_section->vma);
16530 relocation = (bfd_signed_vma) relocation >> 16;
16531 insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
16532 insn &= ~0x1fffc1;
16533 insn |= (relocation & 0xffc1) | ((relocation & 0x3e) << 15);
16534 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
16535 r = bfd_reloc_ok;
16536 if (relocation + 0x8000 > 0xffff)
16537 r = bfd_reloc_overflow;
16538 }
16539 }
16540 else
16541 r = _bfd_final_link_relocate (howto, input_bfd, input_section, contents,
16542 rel->r_offset, relocation, addend);
16543
16544 if (r != bfd_reloc_ok)
16545 {
16546 char *more_info = NULL;
16547 const char *reloc_name = howto->name;
16548
16549 if (reloc_dest != DEST_NORMAL)
16550 {
16551 more_info = bfd_malloc (strlen (reloc_name) + 8);
16552 if (more_info != NULL)
16553 {
16554 strcpy (more_info, reloc_name);
16555 strcat (more_info, (reloc_dest == DEST_OPD
16556 ? " (OPD)" : " (stub)"));
16557 reloc_name = more_info;
16558 }
16559 }
16560
16561 if (r == bfd_reloc_overflow)
16562 {
16563 /* On code like "if (foo) foo();" don't report overflow
16564 on a branch to zero when foo is undefined. */
16565 if (!warned
16566 && (reloc_dest == DEST_STUB
16567 || !(h != NULL
16568 && (h->elf.root.type == bfd_link_hash_undefweak
16569 || h->elf.root.type == bfd_link_hash_undefined)
16570 && is_branch_reloc (r_type))))
16571 info->callbacks->reloc_overflow (info, &h->elf.root,
16572 sym_name, reloc_name,
16573 orig_rel.r_addend,
16574 input_bfd, input_section,
16575 rel->r_offset);
16576 }
16577 else
16578 {
16579 info->callbacks->einfo
16580 /* xgettext:c-format */
16581 (_("%H: %s against `%pT': error %d\n"),
16582 input_bfd, input_section, rel->r_offset,
16583 reloc_name, sym_name, (int) r);
16584 ret = FALSE;
16585 }
16586 if (more_info != NULL)
16587 free (more_info);
16588 }
16589 copy_reloc:
16590 if (wrel != rel)
16591 *wrel = *rel;
16592 }
16593
16594 if (wrel != rel)
16595 {
16596 Elf_Internal_Shdr *rel_hdr;
16597 size_t deleted = rel - wrel;
16598
16599 rel_hdr = _bfd_elf_single_rel_hdr (input_section->output_section);
16600 rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
16601 if (rel_hdr->sh_size == 0)
16602 {
16603 /* It is too late to remove an empty reloc section. Leave
16604 one NONE reloc.
16605 ??? What is wrong with an empty section??? */
16606 rel_hdr->sh_size = rel_hdr->sh_entsize;
16607 deleted -= 1;
16608 }
16609 rel_hdr = _bfd_elf_single_rel_hdr (input_section);
16610 rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
16611 input_section->reloc_count -= deleted;
16612 }
16613
16614 /* If we're emitting relocations, then shortly after this function
16615 returns, reloc offsets and addends for this section will be
16616 adjusted. Worse, reloc symbol indices will be for the output
16617 file rather than the input. Save a copy of the relocs for
16618 opd_entry_value. */
16619 if (is_opd && (info->emitrelocations || bfd_link_relocatable (info)))
16620 {
16621 bfd_size_type amt;
16622 amt = input_section->reloc_count * sizeof (Elf_Internal_Rela);
16623 rel = bfd_alloc (input_bfd, amt);
16624 BFD_ASSERT (ppc64_elf_tdata (input_bfd)->opd.relocs == NULL);
16625 ppc64_elf_tdata (input_bfd)->opd.relocs = rel;
16626 if (rel == NULL)
16627 return FALSE;
16628 memcpy (rel, relocs, amt);
16629 }
16630 return ret;
16631 }
16632
16633 /* Adjust the value of any local symbols in opd sections. */
16634
16635 static int
16636 ppc64_elf_output_symbol_hook (struct bfd_link_info *info,
16637 const char *name ATTRIBUTE_UNUSED,
16638 Elf_Internal_Sym *elfsym,
16639 asection *input_sec,
16640 struct elf_link_hash_entry *h)
16641 {
16642 struct _opd_sec_data *opd;
16643 long adjust;
16644 bfd_vma value;
16645
16646 if (h != NULL)
16647 return 1;
16648
16649 opd = get_opd_info (input_sec);
16650 if (opd == NULL || opd->adjust == NULL)
16651 return 1;
16652
16653 value = elfsym->st_value - input_sec->output_offset;
16654 if (!bfd_link_relocatable (info))
16655 value -= input_sec->output_section->vma;
16656
16657 adjust = opd->adjust[OPD_NDX (value)];
16658 if (adjust == -1)
16659 return 2;
16660
16661 elfsym->st_value += adjust;
16662 return 1;
16663 }
16664
16665 /* Finish up dynamic symbol handling. We set the contents of various
16666 dynamic sections here. */
16667
16668 static bfd_boolean
16669 ppc64_elf_finish_dynamic_symbol (bfd *output_bfd,
16670 struct bfd_link_info *info,
16671 struct elf_link_hash_entry *h,
16672 Elf_Internal_Sym *sym)
16673 {
16674 struct ppc_link_hash_table *htab;
16675 struct plt_entry *ent;
16676
16677 htab = ppc_hash_table (info);
16678 if (htab == NULL)
16679 return FALSE;
16680
16681 if (!htab->opd_abi && !h->def_regular)
16682 for (ent = h->plt.plist; ent != NULL; ent = ent->next)
16683 if (ent->plt.offset != (bfd_vma) -1)
16684 {
16685 /* Mark the symbol as undefined, rather than as
16686 defined in glink. Leave the value if there were
16687 any relocations where pointer equality matters
16688 (this is a clue for the dynamic linker, to make
16689 function pointer comparisons work between an
16690 application and shared library), otherwise set it
16691 to zero. */
16692 sym->st_shndx = SHN_UNDEF;
16693 if (!h->pointer_equality_needed)
16694 sym->st_value = 0;
16695 else if (!h->ref_regular_nonweak)
16696 {
16697 /* This breaks function pointer comparisons, but
16698 that is better than breaking tests for a NULL
16699 function pointer. */
16700 sym->st_value = 0;
16701 }
16702 break;
16703 }
16704
16705 if (h->needs_copy)
16706 {
16707 /* This symbol needs a copy reloc. Set it up. */
16708 Elf_Internal_Rela rela;
16709 asection *srel;
16710 bfd_byte *loc;
16711
16712 if (h->dynindx == -1
16713 || (h->root.type != bfd_link_hash_defined
16714 && h->root.type != bfd_link_hash_defweak)
16715 || htab->elf.srelbss == NULL
16716 || htab->elf.sreldynrelro == NULL)
16717 abort ();
16718
16719 rela.r_offset = (h->root.u.def.value
16720 + h->root.u.def.section->output_section->vma
16721 + h->root.u.def.section->output_offset);
16722 rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_COPY);
16723 rela.r_addend = 0;
16724 if (h->root.u.def.section == htab->elf.sdynrelro)
16725 srel = htab->elf.sreldynrelro;
16726 else
16727 srel = htab->elf.srelbss;
16728 loc = srel->contents;
16729 loc += srel->reloc_count++ * sizeof (Elf64_External_Rela);
16730 bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
16731 }
16732
16733 return TRUE;
16734 }
16735
16736 /* Used to decide how to sort relocs in an optimal manner for the
16737 dynamic linker, before writing them out. */
16738
16739 static enum elf_reloc_type_class
16740 ppc64_elf_reloc_type_class (const struct bfd_link_info *info,
16741 const asection *rel_sec,
16742 const Elf_Internal_Rela *rela)
16743 {
16744 enum elf_ppc64_reloc_type r_type;
16745 struct ppc_link_hash_table *htab = ppc_hash_table (info);
16746
16747 if (rel_sec == htab->elf.irelplt)
16748 return reloc_class_ifunc;
16749
16750 r_type = ELF64_R_TYPE (rela->r_info);
16751 switch (r_type)
16752 {
16753 case R_PPC64_RELATIVE:
16754 return reloc_class_relative;
16755 case R_PPC64_JMP_SLOT:
16756 return reloc_class_plt;
16757 case R_PPC64_COPY:
16758 return reloc_class_copy;
16759 default:
16760 return reloc_class_normal;
16761 }
16762 }
16763
16764 /* Finish up the dynamic sections. */
16765
16766 static bfd_boolean
16767 ppc64_elf_finish_dynamic_sections (bfd *output_bfd,
16768 struct bfd_link_info *info)
16769 {
16770 struct ppc_link_hash_table *htab;
16771 bfd *dynobj;
16772 asection *sdyn;
16773
16774 htab = ppc_hash_table (info);
16775 if (htab == NULL)
16776 return FALSE;
16777
16778 dynobj = htab->elf.dynobj;
16779 sdyn = bfd_get_linker_section (dynobj, ".dynamic");
16780
16781 if (htab->elf.dynamic_sections_created)
16782 {
16783 Elf64_External_Dyn *dyncon, *dynconend;
16784
16785 if (sdyn == NULL || htab->elf.sgot == NULL)
16786 abort ();
16787
16788 dyncon = (Elf64_External_Dyn *) sdyn->contents;
16789 dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
16790 for (; dyncon < dynconend; dyncon++)
16791 {
16792 Elf_Internal_Dyn dyn;
16793 asection *s;
16794
16795 bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
16796
16797 switch (dyn.d_tag)
16798 {
16799 default:
16800 continue;
16801
16802 case DT_PPC64_GLINK:
16803 s = htab->glink;
16804 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
16805 /* We stupidly defined DT_PPC64_GLINK to be the start
16806 of glink rather than the first entry point, which is
16807 what ld.so needs, and now have a bigger stub to
16808 support automatic multiple TOCs. */
16809 dyn.d_un.d_ptr += GLINK_PLTRESOLVE_SIZE (htab) - 8 * 4;
16810 break;
16811
16812 case DT_PPC64_OPD:
16813 s = bfd_get_section_by_name (output_bfd, ".opd");
16814 if (s == NULL)
16815 continue;
16816 dyn.d_un.d_ptr = s->vma;
16817 break;
16818
16819 case DT_PPC64_OPT:
16820 if (htab->do_multi_toc && htab->multi_toc_needed)
16821 dyn.d_un.d_val |= PPC64_OPT_MULTI_TOC;
16822 if (htab->has_plt_localentry0)
16823 dyn.d_un.d_val |= PPC64_OPT_LOCALENTRY;
16824 break;
16825
16826 case DT_PPC64_OPDSZ:
16827 s = bfd_get_section_by_name (output_bfd, ".opd");
16828 if (s == NULL)
16829 continue;
16830 dyn.d_un.d_val = s->size;
16831 break;
16832
16833 case DT_PLTGOT:
16834 s = htab->elf.splt;
16835 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
16836 break;
16837
16838 case DT_JMPREL:
16839 s = htab->elf.srelplt;
16840 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
16841 break;
16842
16843 case DT_PLTRELSZ:
16844 dyn.d_un.d_val = htab->elf.srelplt->size;
16845 break;
16846
16847 case DT_TEXTREL:
16848 if (htab->local_ifunc_resolver)
16849 info->callbacks->einfo
16850 (_("%X%P: text relocations and GNU indirect "
16851 "functions will result in a segfault at runtime\n"));
16852 else if (htab->maybe_local_ifunc_resolver)
16853 info->callbacks->einfo
16854 (_("%P: warning: text relocations and GNU indirect "
16855 "functions may result in a segfault at runtime\n"));
16856 continue;
16857 }
16858
16859 bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
16860 }
16861 }
16862
16863 if (htab->elf.sgot != NULL && htab->elf.sgot->size != 0
16864 && htab->elf.sgot->output_section != bfd_abs_section_ptr)
16865 {
16866 /* Fill in the first entry in the global offset table.
16867 We use it to hold the link-time TOCbase. */
16868 bfd_put_64 (output_bfd,
16869 elf_gp (output_bfd) + TOC_BASE_OFF,
16870 htab->elf.sgot->contents);
16871
16872 /* Set .got entry size. */
16873 elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize = 8;
16874 }
16875
16876 if (htab->elf.splt != NULL && htab->elf.splt->size != 0
16877 && htab->elf.splt->output_section != bfd_abs_section_ptr)
16878 {
16879 /* Set .plt entry size. */
16880 elf_section_data (htab->elf.splt->output_section)->this_hdr.sh_entsize
16881 = PLT_ENTRY_SIZE (htab);
16882 }
16883
16884 /* brlt is SEC_LINKER_CREATED, so we need to write out relocs for
16885 brlt ourselves if emitrelocations. */
16886 if (htab->brlt != NULL
16887 && htab->brlt->reloc_count != 0
16888 && !_bfd_elf_link_output_relocs (output_bfd,
16889 htab->brlt,
16890 elf_section_data (htab->brlt)->rela.hdr,
16891 elf_section_data (htab->brlt)->relocs,
16892 NULL))
16893 return FALSE;
16894
16895 if (htab->glink != NULL
16896 && htab->glink->reloc_count != 0
16897 && !_bfd_elf_link_output_relocs (output_bfd,
16898 htab->glink,
16899 elf_section_data (htab->glink)->rela.hdr,
16900 elf_section_data (htab->glink)->relocs,
16901 NULL))
16902 return FALSE;
16903
16904
16905 if (htab->glink_eh_frame != NULL
16906 && htab->glink_eh_frame->size != 0
16907 && htab->glink_eh_frame->sec_info_type == SEC_INFO_TYPE_EH_FRAME
16908 && !_bfd_elf_write_section_eh_frame (output_bfd, info,
16909 htab->glink_eh_frame,
16910 htab->glink_eh_frame->contents))
16911 return FALSE;
16912
16913 /* We need to handle writing out multiple GOT sections ourselves,
16914 since we didn't add them to DYNOBJ. We know dynobj is the first
16915 bfd. */
16916 while ((dynobj = dynobj->link.next) != NULL)
16917 {
16918 asection *s;
16919
16920 if (!is_ppc64_elf (dynobj))
16921 continue;
16922
16923 s = ppc64_elf_tdata (dynobj)->got;
16924 if (s != NULL
16925 && s->size != 0
16926 && s->output_section != bfd_abs_section_ptr
16927 && !bfd_set_section_contents (output_bfd, s->output_section,
16928 s->contents, s->output_offset,
16929 s->size))
16930 return FALSE;
16931 s = ppc64_elf_tdata (dynobj)->relgot;
16932 if (s != NULL
16933 && s->size != 0
16934 && s->output_section != bfd_abs_section_ptr
16935 && !bfd_set_section_contents (output_bfd, s->output_section,
16936 s->contents, s->output_offset,
16937 s->size))
16938 return FALSE;
16939 }
16940
16941 return TRUE;
16942 }
16943
16944 #include "elf64-target.h"
16945
16946 /* FreeBSD support */
16947
16948 #undef TARGET_LITTLE_SYM
16949 #undef TARGET_LITTLE_NAME
16950
16951 #undef TARGET_BIG_SYM
16952 #define TARGET_BIG_SYM powerpc_elf64_fbsd_vec
16953 #undef TARGET_BIG_NAME
16954 #define TARGET_BIG_NAME "elf64-powerpc-freebsd"
16955
16956 #undef ELF_OSABI
16957 #define ELF_OSABI ELFOSABI_FREEBSD
16958
16959 #undef elf64_bed
16960 #define elf64_bed elf64_powerpc_fbsd_bed
16961
16962 #include "elf64-target.h"
GDB Binutils - Deliverables
This page took 0.400847 seconds and 4 git commands to generate.