1 /* PowerPC64-specific support for 64-bit ELF.
2 Copyright (C) 1999-2016 Free Software Foundation, Inc.
3 Written by Linus Nordberg, Swox AB <info@swox.com>,
4 based on elf32-ppc.c by Ian Lance Taylor.
5 Largely rewritten by Alan Modra.
6
7 This file is part of BFD, the Binary File Descriptor library.
8
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
13
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
18
19 You should have received a copy of the GNU General Public License along
20 with this program; if not, write to the Free Software Foundation, Inc.,
21 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */
22
23
24 /* The 64-bit PowerPC ELF ABI may be found at
25 http://www.linuxbase.org/spec/ELF/ppc64/PPC-elf64abi.txt, and
26 http://www.linuxbase.org/spec/ELF/ppc64/spec/book1.html */
27
28 #include "sysdep.h"
29 #include <stdarg.h>
30 #include "bfd.h"
31 #include "bfdlink.h"
32 #include "libbfd.h"
33 #include "elf-bfd.h"
34 #include "elf/ppc64.h"
35 #include "elf64-ppc.h"
36 #include "dwarf2.h"
37
38 static bfd_reloc_status_type ppc64_elf_ha_reloc
39 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
40 static bfd_reloc_status_type ppc64_elf_branch_reloc
41 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
42 static bfd_reloc_status_type ppc64_elf_brtaken_reloc
43 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
44 static bfd_reloc_status_type ppc64_elf_sectoff_reloc
45 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
46 static bfd_reloc_status_type ppc64_elf_sectoff_ha_reloc
47 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
48 static bfd_reloc_status_type ppc64_elf_toc_reloc
49 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
50 static bfd_reloc_status_type ppc64_elf_toc_ha_reloc
51 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
52 static bfd_reloc_status_type ppc64_elf_toc64_reloc
53 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
54 static bfd_reloc_status_type ppc64_elf_unhandled_reloc
55 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
56 static bfd_vma opd_entry_value
57 (asection *, bfd_vma, asection **, bfd_vma *, bfd_boolean);
58
59 #define TARGET_LITTLE_SYM powerpc_elf64_le_vec
60 #define TARGET_LITTLE_NAME "elf64-powerpcle"
61 #define TARGET_BIG_SYM powerpc_elf64_vec
62 #define TARGET_BIG_NAME "elf64-powerpc"
63 #define ELF_ARCH bfd_arch_powerpc
64 #define ELF_TARGET_ID PPC64_ELF_DATA
65 #define ELF_MACHINE_CODE EM_PPC64
66 #define ELF_MAXPAGESIZE 0x10000
67 #define ELF_COMMONPAGESIZE 0x10000
68 #define elf_info_to_howto ppc64_elf_info_to_howto
69
70 #define elf_backend_want_got_sym 0
71 #define elf_backend_want_plt_sym 0
72 #define elf_backend_plt_alignment 3
73 #define elf_backend_plt_not_loaded 1
74 #define elf_backend_got_header_size 8
75 #define elf_backend_can_gc_sections 1
76 #define elf_backend_can_refcount 1
77 #define elf_backend_rela_normal 1
78 #define elf_backend_default_execstack 0
79
80 #define bfd_elf64_mkobject ppc64_elf_mkobject
81 #define bfd_elf64_bfd_reloc_type_lookup ppc64_elf_reloc_type_lookup
82 #define bfd_elf64_bfd_reloc_name_lookup ppc64_elf_reloc_name_lookup
83 #define bfd_elf64_bfd_merge_private_bfd_data ppc64_elf_merge_private_bfd_data
84 #define bfd_elf64_bfd_print_private_bfd_data ppc64_elf_print_private_bfd_data
85 #define bfd_elf64_new_section_hook ppc64_elf_new_section_hook
86 #define bfd_elf64_bfd_link_hash_table_create ppc64_elf_link_hash_table_create
87 #define bfd_elf64_get_synthetic_symtab ppc64_elf_get_synthetic_symtab
88 #define bfd_elf64_bfd_link_just_syms ppc64_elf_link_just_syms
89
90 #define elf_backend_object_p ppc64_elf_object_p
91 #define elf_backend_grok_prstatus ppc64_elf_grok_prstatus
92 #define elf_backend_grok_psinfo ppc64_elf_grok_psinfo
93 #define elf_backend_write_core_note ppc64_elf_write_core_note
94 #define elf_backend_create_dynamic_sections ppc64_elf_create_dynamic_sections
95 #define elf_backend_copy_indirect_symbol ppc64_elf_copy_indirect_symbol
96 #define elf_backend_add_symbol_hook ppc64_elf_add_symbol_hook
97 #define elf_backend_check_directives ppc64_elf_before_check_relocs
98 #define elf_backend_notice_as_needed ppc64_elf_notice_as_needed
99 #define elf_backend_archive_symbol_lookup ppc64_elf_archive_symbol_lookup
100 #define elf_backend_check_relocs ppc64_elf_check_relocs
101 #define elf_backend_gc_keep ppc64_elf_gc_keep
102 #define elf_backend_gc_mark_dynamic_ref ppc64_elf_gc_mark_dynamic_ref
103 #define elf_backend_gc_mark_hook ppc64_elf_gc_mark_hook
104 #define elf_backend_gc_sweep_hook ppc64_elf_gc_sweep_hook
105 #define elf_backend_adjust_dynamic_symbol ppc64_elf_adjust_dynamic_symbol
106 #define elf_backend_hide_symbol ppc64_elf_hide_symbol
107 #define elf_backend_maybe_function_sym ppc64_elf_maybe_function_sym
108 #define elf_backend_always_size_sections ppc64_elf_func_desc_adjust
109 #define elf_backend_size_dynamic_sections ppc64_elf_size_dynamic_sections
110 #define elf_backend_hash_symbol ppc64_elf_hash_symbol
111 #define elf_backend_init_index_section _bfd_elf_init_2_index_sections
112 #define elf_backend_action_discarded ppc64_elf_action_discarded
113 #define elf_backend_relocate_section ppc64_elf_relocate_section
114 #define elf_backend_finish_dynamic_symbol ppc64_elf_finish_dynamic_symbol
115 #define elf_backend_reloc_type_class ppc64_elf_reloc_type_class
116 #define elf_backend_finish_dynamic_sections ppc64_elf_finish_dynamic_sections
117 #define elf_backend_link_output_symbol_hook ppc64_elf_output_symbol_hook
118 #define elf_backend_special_sections ppc64_elf_special_sections
119 #define elf_backend_merge_symbol_attribute ppc64_elf_merge_symbol_attribute
120
121 /* The name of the dynamic interpreter. This is put in the .interp
122 section. */
123 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
124
125 /* The size in bytes of an entry in the procedure linkage table. */
126 #define PLT_ENTRY_SIZE(htab) (htab->opd_abi ? 24 : 8)
127
128 /* The initial size of the plt reserved for the dynamic linker. */
129 #define PLT_INITIAL_ENTRY_SIZE(htab) (htab->opd_abi ? 24 : 16)
130
131 /* Offsets to some stack save slots. */
132 #define STK_LR 16
133 #define STK_TOC(htab) (htab->opd_abi ? 40 : 24)
134 /* This one is dodgy. ELFv2 does not have a linker word, so use the
135 CR save slot. Used only by optimised __tls_get_addr call stub,
136 relying on __tls_get_addr_opt not saving CR.. */
137 #define STK_LINKER(htab) (htab->opd_abi ? 32 : 8)
138
139 /* TOC base pointers offset from start of TOC. */
140 #define TOC_BASE_OFF 0x8000
141 /* TOC base alignment. */
142 #define TOC_BASE_ALIGN 256
143
144 /* Offset of tp and dtp pointers from start of TLS block. */
145 #define TP_OFFSET 0x7000
146 #define DTP_OFFSET 0x8000
147
148 /* .plt call stub instructions. The normal stub is like this, but
149 sometimes the .plt entry crosses a 64k boundary and we need to
150 insert an addi to adjust r11. */
151 #define STD_R2_0R1 0xf8410000 /* std %r2,0+40(%r1) */
152 #define ADDIS_R11_R2 0x3d620000 /* addis %r11,%r2,xxx@ha */
153 #define LD_R12_0R11 0xe98b0000 /* ld %r12,xxx+0@l(%r11) */
154 #define MTCTR_R12 0x7d8903a6 /* mtctr %r12 */
155 #define LD_R2_0R11 0xe84b0000 /* ld %r2,xxx+8@l(%r11) */
156 #define LD_R11_0R11 0xe96b0000 /* ld %r11,xxx+16@l(%r11) */
157 #define BCTR 0x4e800420 /* bctr */
158
159 #define ADDI_R11_R11 0x396b0000 /* addi %r11,%r11,off@l */
160 #define ADDIS_R2_R2 0x3c420000 /* addis %r2,%r2,off@ha */
161 #define ADDI_R2_R2 0x38420000 /* addi %r2,%r2,off@l */
162
163 #define XOR_R2_R12_R12 0x7d826278 /* xor %r2,%r12,%r12 */
164 #define ADD_R11_R11_R2 0x7d6b1214 /* add %r11,%r11,%r2 */
165 #define XOR_R11_R12_R12 0x7d8b6278 /* xor %r11,%r12,%r12 */
166 #define ADD_R2_R2_R11 0x7c425a14 /* add %r2,%r2,%r11 */
167 #define CMPLDI_R2_0 0x28220000 /* cmpldi %r2,0 */
168 #define BNECTR 0x4ca20420 /* bnectr+ */
169 #define BNECTR_P4 0x4ce20420 /* bnectr+ */
170
171 #define LD_R12_0R2 0xe9820000 /* ld %r12,xxx+0(%r2) */
172 #define LD_R11_0R2 0xe9620000 /* ld %r11,xxx+0(%r2) */
173 #define LD_R2_0R2 0xe8420000 /* ld %r2,xxx+0(%r2) */
174
175 #define LD_R2_0R1 0xe8410000 /* ld %r2,0(%r1) */
176 #define LD_R2_0R12 0xe84c0000 /* ld %r2,0(%r12) */
177 #define ADD_R2_R2_R12 0x7c426214 /* add %r2,%r2,%r12 */
178
179 #define LIS_R2 0x3c400000 /* lis %r2,xxx@ha */
180 #define ADDIS_R2_R12 0x3c4c0000 /* addis %r2,%r12,xxx@ha */
181 #define ADDIS_R12_R2 0x3d820000 /* addis %r12,%r2,xxx@ha */
182 #define ADDIS_R12_R12 0x3d8c0000 /* addis %r12,%r12,xxx@ha */
183 #define LD_R12_0R12 0xe98c0000 /* ld %r12,xxx@l(%r12) */
184
185 /* glink call stub instructions. We enter with the index in R0. */
186 #define GLINK_CALL_STUB_SIZE (16*4)
187 /* 0: */
188 /* .quad plt0-1f */
189 /* __glink: */
190 #define MFLR_R12 0x7d8802a6 /* mflr %12 */
191 #define BCL_20_31 0x429f0005 /* bcl 20,31,1f */
192 /* 1: */
193 #define MFLR_R11 0x7d6802a6 /* mflr %11 */
194 /* ld %2,(0b-1b)(%11) */
195 #define MTLR_R12 0x7d8803a6 /* mtlr %12 */
196 #define ADD_R11_R2_R11 0x7d625a14 /* add %11,%2,%11 */
197 /* ld %12,0(%11) */
198 /* ld %2,8(%11) */
199 /* mtctr %12 */
200 /* ld %11,16(%11) */
201 /* bctr */
202 #define MFLR_R0 0x7c0802a6 /* mflr %r0 */
203 #define MTLR_R0 0x7c0803a6 /* mtlr %r0 */
204 #define SUB_R12_R12_R11 0x7d8b6050 /* subf %r12,%r11,%r12 */
205 #define ADDI_R0_R12 0x380c0000 /* addi %r0,%r12,0 */
206 #define SRDI_R0_R0_2 0x7800f082 /* rldicl %r0,%r0,62,2 */
207
208 /* Pad with this. */
209 #define NOP 0x60000000
210
211 /* Some other nops. */
212 #define CROR_151515 0x4def7b82
213 #define CROR_313131 0x4ffffb82
214
215 /* .glink entries for the first 32k functions are two instructions. */
216 #define LI_R0_0 0x38000000 /* li %r0,0 */
217 #define B_DOT 0x48000000 /* b . */
218
219 /* After that, we need two instructions to load the index, followed by
220 a branch. */
221 #define LIS_R0_0 0x3c000000 /* lis %r0,0 */
222 #define ORI_R0_R0_0 0x60000000 /* ori %r0,%r0,0 */
223
224 /* Instructions used by the save and restore reg functions. */
225 #define STD_R0_0R1 0xf8010000 /* std %r0,0(%r1) */
226 #define STD_R0_0R12 0xf80c0000 /* std %r0,0(%r12) */
227 #define LD_R0_0R1 0xe8010000 /* ld %r0,0(%r1) */
228 #define LD_R0_0R12 0xe80c0000 /* ld %r0,0(%r12) */
229 #define STFD_FR0_0R1 0xd8010000 /* stfd %fr0,0(%r1) */
230 #define LFD_FR0_0R1 0xc8010000 /* lfd %fr0,0(%r1) */
231 #define LI_R12_0 0x39800000 /* li %r12,0 */
232 #define STVX_VR0_R12_R0 0x7c0c01ce /* stvx %v0,%r12,%r0 */
233 #define LVX_VR0_R12_R0 0x7c0c00ce /* lvx %v0,%r12,%r0 */
234 #define MTLR_R0 0x7c0803a6 /* mtlr %r0 */
235 #define BLR 0x4e800020 /* blr */
236
237 /* Since .opd is an array of descriptors and each entry will end up
238 with identical R_PPC64_RELATIVE relocs, there is really no need to
239 propagate .opd relocs; The dynamic linker should be taught to
240 relocate .opd without reloc entries. */
241 #ifndef NO_OPD_RELOCS
242 #define NO_OPD_RELOCS 0
243 #endif
244
245 #ifndef ARRAY_SIZE
246 #define ARRAY_SIZE(a) (sizeof (a) / sizeof ((a)[0]))
247 #endif
248
249 static inline int
abiversion(bfd * abfd)250 abiversion (bfd *abfd)
251 {
252 return elf_elfheader (abfd)->e_flags & EF_PPC64_ABI;
253 }
254
255 static inline void
set_abiversion(bfd * abfd,int ver)256 set_abiversion (bfd *abfd, int ver)
257 {
258 elf_elfheader (abfd)->e_flags &= ~EF_PPC64_ABI;
259 elf_elfheader (abfd)->e_flags |= ver & EF_PPC64_ABI;
260 }
261
262 #define ONES(n) (((bfd_vma) 1 << ((n) - 1) << 1) - 1)
263
264 /* Relocation HOWTO's. */
265 static reloc_howto_type *ppc64_elf_howto_table[(int) R_PPC64_max];
266
267 static reloc_howto_type ppc64_elf_howto_raw[] = {
268 /* This reloc does nothing. */
269 HOWTO (R_PPC64_NONE, /* type */
270 0, /* rightshift */
271 3, /* size (0 = byte, 1 = short, 2 = long) */
272 0, /* bitsize */
273 FALSE, /* pc_relative */
274 0, /* bitpos */
275 complain_overflow_dont, /* complain_on_overflow */
276 bfd_elf_generic_reloc, /* special_function */
277 "R_PPC64_NONE", /* name */
278 FALSE, /* partial_inplace */
279 0, /* src_mask */
280 0, /* dst_mask */
281 FALSE), /* pcrel_offset */
282
283 /* A standard 32 bit relocation. */
284 HOWTO (R_PPC64_ADDR32, /* type */
285 0, /* rightshift */
286 2, /* size (0 = byte, 1 = short, 2 = long) */
287 32, /* bitsize */
288 FALSE, /* pc_relative */
289 0, /* bitpos */
290 complain_overflow_bitfield, /* complain_on_overflow */
291 bfd_elf_generic_reloc, /* special_function */
292 "R_PPC64_ADDR32", /* name */
293 FALSE, /* partial_inplace */
294 0, /* src_mask */
295 0xffffffff, /* dst_mask */
296 FALSE), /* pcrel_offset */
297
298 /* An absolute 26 bit branch; the lower two bits must be zero.
299 FIXME: we don't check that, we just clear them. */
300 HOWTO (R_PPC64_ADDR24, /* type */
301 0, /* rightshift */
302 2, /* size (0 = byte, 1 = short, 2 = long) */
303 26, /* bitsize */
304 FALSE, /* pc_relative */
305 0, /* bitpos */
306 complain_overflow_bitfield, /* complain_on_overflow */
307 bfd_elf_generic_reloc, /* special_function */
308 "R_PPC64_ADDR24", /* name */
309 FALSE, /* partial_inplace */
310 0, /* src_mask */
311 0x03fffffc, /* dst_mask */
312 FALSE), /* pcrel_offset */
313
314 /* A standard 16 bit relocation. */
315 HOWTO (R_PPC64_ADDR16, /* type */
316 0, /* rightshift */
317 1, /* size (0 = byte, 1 = short, 2 = long) */
318 16, /* bitsize */
319 FALSE, /* pc_relative */
320 0, /* bitpos */
321 complain_overflow_bitfield, /* complain_on_overflow */
322 bfd_elf_generic_reloc, /* special_function */
323 "R_PPC64_ADDR16", /* name */
324 FALSE, /* partial_inplace */
325 0, /* src_mask */
326 0xffff, /* dst_mask */
327 FALSE), /* pcrel_offset */
328
329 /* A 16 bit relocation without overflow. */
330 HOWTO (R_PPC64_ADDR16_LO, /* type */
331 0, /* rightshift */
332 1, /* size (0 = byte, 1 = short, 2 = long) */
333 16, /* bitsize */
334 FALSE, /* pc_relative */
335 0, /* bitpos */
336 complain_overflow_dont,/* complain_on_overflow */
337 bfd_elf_generic_reloc, /* special_function */
338 "R_PPC64_ADDR16_LO", /* name */
339 FALSE, /* partial_inplace */
340 0, /* src_mask */
341 0xffff, /* dst_mask */
342 FALSE), /* pcrel_offset */
343
344 /* Bits 16-31 of an address. */
345 HOWTO (R_PPC64_ADDR16_HI, /* type */
346 16, /* rightshift */
347 1, /* size (0 = byte, 1 = short, 2 = long) */
348 16, /* bitsize */
349 FALSE, /* pc_relative */
350 0, /* bitpos */
351 complain_overflow_signed, /* complain_on_overflow */
352 bfd_elf_generic_reloc, /* special_function */
353 "R_PPC64_ADDR16_HI", /* name */
354 FALSE, /* partial_inplace */
355 0, /* src_mask */
356 0xffff, /* dst_mask */
357 FALSE), /* pcrel_offset */
358
359 /* Bits 16-31 of an address, plus 1 if the contents of the low 16
360 bits, treated as a signed number, is negative. */
361 HOWTO (R_PPC64_ADDR16_HA, /* type */
362 16, /* rightshift */
363 1, /* size (0 = byte, 1 = short, 2 = long) */
364 16, /* bitsize */
365 FALSE, /* pc_relative */
366 0, /* bitpos */
367 complain_overflow_signed, /* complain_on_overflow */
368 ppc64_elf_ha_reloc, /* special_function */
369 "R_PPC64_ADDR16_HA", /* name */
370 FALSE, /* partial_inplace */
371 0, /* src_mask */
372 0xffff, /* dst_mask */
373 FALSE), /* pcrel_offset */
374
375 /* An absolute 16 bit branch; the lower two bits must be zero.
376 FIXME: we don't check that, we just clear them. */
377 HOWTO (R_PPC64_ADDR14, /* type */
378 0, /* rightshift */
379 2, /* size (0 = byte, 1 = short, 2 = long) */
380 16, /* bitsize */
381 FALSE, /* pc_relative */
382 0, /* bitpos */
383 complain_overflow_signed, /* complain_on_overflow */
384 ppc64_elf_branch_reloc, /* special_function */
385 "R_PPC64_ADDR14", /* name */
386 FALSE, /* partial_inplace */
387 0, /* src_mask */
388 0x0000fffc, /* dst_mask */
389 FALSE), /* pcrel_offset */
390
391 /* An absolute 16 bit branch, for which bit 10 should be set to
392 indicate that the branch is expected to be taken. The lower two
393 bits must be zero. */
394 HOWTO (R_PPC64_ADDR14_BRTAKEN, /* type */
395 0, /* rightshift */
396 2, /* size (0 = byte, 1 = short, 2 = long) */
397 16, /* bitsize */
398 FALSE, /* pc_relative */
399 0, /* bitpos */
400 complain_overflow_signed, /* complain_on_overflow */
401 ppc64_elf_brtaken_reloc, /* special_function */
402 "R_PPC64_ADDR14_BRTAKEN",/* name */
403 FALSE, /* partial_inplace */
404 0, /* src_mask */
405 0x0000fffc, /* dst_mask */
406 FALSE), /* pcrel_offset */
407
408 /* An absolute 16 bit branch, for which bit 10 should be set to
409 indicate that the branch is not expected to be taken. The lower
410 two bits must be zero. */
411 HOWTO (R_PPC64_ADDR14_BRNTAKEN, /* type */
412 0, /* rightshift */
413 2, /* size (0 = byte, 1 = short, 2 = long) */
414 16, /* bitsize */
415 FALSE, /* pc_relative */
416 0, /* bitpos */
417 complain_overflow_signed, /* complain_on_overflow */
418 ppc64_elf_brtaken_reloc, /* special_function */
419 "R_PPC64_ADDR14_BRNTAKEN",/* name */
420 FALSE, /* partial_inplace */
421 0, /* src_mask */
422 0x0000fffc, /* dst_mask */
423 FALSE), /* pcrel_offset */
424
425 /* A relative 26 bit branch; the lower two bits must be zero. */
426 HOWTO (R_PPC64_REL24, /* type */
427 0, /* rightshift */
428 2, /* size (0 = byte, 1 = short, 2 = long) */
429 26, /* bitsize */
430 TRUE, /* pc_relative */
431 0, /* bitpos */
432 complain_overflow_signed, /* complain_on_overflow */
433 ppc64_elf_branch_reloc, /* special_function */
434 "R_PPC64_REL24", /* name */
435 FALSE, /* partial_inplace */
436 0, /* src_mask */
437 0x03fffffc, /* dst_mask */
438 TRUE), /* pcrel_offset */
439
440 /* A relative 16 bit branch; the lower two bits must be zero. */
441 HOWTO (R_PPC64_REL14, /* type */
442 0, /* rightshift */
443 2, /* size (0 = byte, 1 = short, 2 = long) */
444 16, /* bitsize */
445 TRUE, /* pc_relative */
446 0, /* bitpos */
447 complain_overflow_signed, /* complain_on_overflow */
448 ppc64_elf_branch_reloc, /* special_function */
449 "R_PPC64_REL14", /* name */
450 FALSE, /* partial_inplace */
451 0, /* src_mask */
452 0x0000fffc, /* dst_mask */
453 TRUE), /* pcrel_offset */
454
455 /* A relative 16 bit branch. Bit 10 should be set to indicate that
456 the branch is expected to be taken. The lower two bits must be
457 zero. */
458 HOWTO (R_PPC64_REL14_BRTAKEN, /* type */
459 0, /* rightshift */
460 2, /* size (0 = byte, 1 = short, 2 = long) */
461 16, /* bitsize */
462 TRUE, /* pc_relative */
463 0, /* bitpos */
464 complain_overflow_signed, /* complain_on_overflow */
465 ppc64_elf_brtaken_reloc, /* special_function */
466 "R_PPC64_REL14_BRTAKEN", /* name */
467 FALSE, /* partial_inplace */
468 0, /* src_mask */
469 0x0000fffc, /* dst_mask */
470 TRUE), /* pcrel_offset */
471
472 /* A relative 16 bit branch. Bit 10 should be set to indicate that
473 the branch is not expected to be taken. The lower two bits must
474 be zero. */
475 HOWTO (R_PPC64_REL14_BRNTAKEN, /* type */
476 0, /* rightshift */
477 2, /* size (0 = byte, 1 = short, 2 = long) */
478 16, /* bitsize */
479 TRUE, /* pc_relative */
480 0, /* bitpos */
481 complain_overflow_signed, /* complain_on_overflow */
482 ppc64_elf_brtaken_reloc, /* special_function */
483 "R_PPC64_REL14_BRNTAKEN",/* name */
484 FALSE, /* partial_inplace */
485 0, /* src_mask */
486 0x0000fffc, /* dst_mask */
487 TRUE), /* pcrel_offset */
488
489 /* Like R_PPC64_ADDR16, but referring to the GOT table entry for the
490 symbol. */
491 HOWTO (R_PPC64_GOT16, /* type */
492 0, /* rightshift */
493 1, /* size (0 = byte, 1 = short, 2 = long) */
494 16, /* bitsize */
495 FALSE, /* pc_relative */
496 0, /* bitpos */
497 complain_overflow_signed, /* complain_on_overflow */
498 ppc64_elf_unhandled_reloc, /* special_function */
499 "R_PPC64_GOT16", /* name */
500 FALSE, /* partial_inplace */
501 0, /* src_mask */
502 0xffff, /* dst_mask */
503 FALSE), /* pcrel_offset */
504
505 /* Like R_PPC64_ADDR16_LO, but referring to the GOT table entry for
506 the symbol. */
507 HOWTO (R_PPC64_GOT16_LO, /* type */
508 0, /* rightshift */
509 1, /* size (0 = byte, 1 = short, 2 = long) */
510 16, /* bitsize */
511 FALSE, /* pc_relative */
512 0, /* bitpos */
513 complain_overflow_dont, /* complain_on_overflow */
514 ppc64_elf_unhandled_reloc, /* special_function */
515 "R_PPC64_GOT16_LO", /* name */
516 FALSE, /* partial_inplace */
517 0, /* src_mask */
518 0xffff, /* dst_mask */
519 FALSE), /* pcrel_offset */
520
521 /* Like R_PPC64_ADDR16_HI, but referring to the GOT table entry for
522 the symbol. */
523 HOWTO (R_PPC64_GOT16_HI, /* type */
524 16, /* rightshift */
525 1, /* size (0 = byte, 1 = short, 2 = long) */
526 16, /* bitsize */
527 FALSE, /* pc_relative */
528 0, /* bitpos */
529 complain_overflow_signed,/* complain_on_overflow */
530 ppc64_elf_unhandled_reloc, /* special_function */
531 "R_PPC64_GOT16_HI", /* name */
532 FALSE, /* partial_inplace */
533 0, /* src_mask */
534 0xffff, /* dst_mask */
535 FALSE), /* pcrel_offset */
536
537 /* Like R_PPC64_ADDR16_HA, but referring to the GOT table entry for
538 the symbol. */
539 HOWTO (R_PPC64_GOT16_HA, /* type */
540 16, /* rightshift */
541 1, /* size (0 = byte, 1 = short, 2 = long) */
542 16, /* bitsize */
543 FALSE, /* pc_relative */
544 0, /* bitpos */
545 complain_overflow_signed,/* complain_on_overflow */
546 ppc64_elf_unhandled_reloc, /* special_function */
547 "R_PPC64_GOT16_HA", /* name */
548 FALSE, /* partial_inplace */
549 0, /* src_mask */
550 0xffff, /* dst_mask */
551 FALSE), /* pcrel_offset */
552
553 /* This is used only by the dynamic linker. The symbol should exist
554 both in the object being run and in some shared library. The
555 dynamic linker copies the data addressed by the symbol from the
556 shared library into the object, because the object being
557 run has to have the data at some particular address. */
558 HOWTO (R_PPC64_COPY, /* type */
559 0, /* rightshift */
560 0, /* this one is variable size */
561 0, /* bitsize */
562 FALSE, /* pc_relative */
563 0, /* bitpos */
564 complain_overflow_dont, /* complain_on_overflow */
565 ppc64_elf_unhandled_reloc, /* special_function */
566 "R_PPC64_COPY", /* name */
567 FALSE, /* partial_inplace */
568 0, /* src_mask */
569 0, /* dst_mask */
570 FALSE), /* pcrel_offset */
571
572 /* Like R_PPC64_ADDR64, but used when setting global offset table
573 entries. */
574 HOWTO (R_PPC64_GLOB_DAT, /* type */
575 0, /* rightshift */
576 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
577 64, /* bitsize */
578 FALSE, /* pc_relative */
579 0, /* bitpos */
580 complain_overflow_dont, /* complain_on_overflow */
581 ppc64_elf_unhandled_reloc, /* special_function */
582 "R_PPC64_GLOB_DAT", /* name */
583 FALSE, /* partial_inplace */
584 0, /* src_mask */
585 ONES (64), /* dst_mask */
586 FALSE), /* pcrel_offset */
587
588 /* Created by the link editor. Marks a procedure linkage table
589 entry for a symbol. */
590 HOWTO (R_PPC64_JMP_SLOT, /* type */
591 0, /* rightshift */
592 0, /* size (0 = byte, 1 = short, 2 = long) */
593 0, /* bitsize */
594 FALSE, /* pc_relative */
595 0, /* bitpos */
596 complain_overflow_dont, /* complain_on_overflow */
597 ppc64_elf_unhandled_reloc, /* special_function */
598 "R_PPC64_JMP_SLOT", /* name */
599 FALSE, /* partial_inplace */
600 0, /* src_mask */
601 0, /* dst_mask */
602 FALSE), /* pcrel_offset */
603
604 /* Used only by the dynamic linker. When the object is run, this
605 doubleword64 is set to the load address of the object, plus the
606 addend. */
607 HOWTO (R_PPC64_RELATIVE, /* type */
608 0, /* rightshift */
609 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
610 64, /* bitsize */
611 FALSE, /* pc_relative */
612 0, /* bitpos */
613 complain_overflow_dont, /* complain_on_overflow */
614 bfd_elf_generic_reloc, /* special_function */
615 "R_PPC64_RELATIVE", /* name */
616 FALSE, /* partial_inplace */
617 0, /* src_mask */
618 ONES (64), /* dst_mask */
619 FALSE), /* pcrel_offset */
620
621 /* Like R_PPC64_ADDR32, but may be unaligned. */
622 HOWTO (R_PPC64_UADDR32, /* type */
623 0, /* rightshift */
624 2, /* size (0 = byte, 1 = short, 2 = long) */
625 32, /* bitsize */
626 FALSE, /* pc_relative */
627 0, /* bitpos */
628 complain_overflow_bitfield, /* complain_on_overflow */
629 bfd_elf_generic_reloc, /* special_function */
630 "R_PPC64_UADDR32", /* name */
631 FALSE, /* partial_inplace */
632 0, /* src_mask */
633 0xffffffff, /* dst_mask */
634 FALSE), /* pcrel_offset */
635
636 /* Like R_PPC64_ADDR16, but may be unaligned. */
637 HOWTO (R_PPC64_UADDR16, /* type */
638 0, /* rightshift */
639 1, /* size (0 = byte, 1 = short, 2 = long) */
640 16, /* bitsize */
641 FALSE, /* pc_relative */
642 0, /* bitpos */
643 complain_overflow_bitfield, /* complain_on_overflow */
644 bfd_elf_generic_reloc, /* special_function */
645 "R_PPC64_UADDR16", /* name */
646 FALSE, /* partial_inplace */
647 0, /* src_mask */
648 0xffff, /* dst_mask */
649 FALSE), /* pcrel_offset */
650
651 /* 32-bit PC relative. */
652 HOWTO (R_PPC64_REL32, /* type */
653 0, /* rightshift */
654 2, /* size (0 = byte, 1 = short, 2 = long) */
655 32, /* bitsize */
656 TRUE, /* pc_relative */
657 0, /* bitpos */
658 complain_overflow_signed, /* complain_on_overflow */
659 bfd_elf_generic_reloc, /* special_function */
660 "R_PPC64_REL32", /* name */
661 FALSE, /* partial_inplace */
662 0, /* src_mask */
663 0xffffffff, /* dst_mask */
664 TRUE), /* pcrel_offset */
665
666 /* 32-bit relocation to the symbol's procedure linkage table. */
667 HOWTO (R_PPC64_PLT32, /* type */
668 0, /* rightshift */
669 2, /* size (0 = byte, 1 = short, 2 = long) */
670 32, /* bitsize */
671 FALSE, /* pc_relative */
672 0, /* bitpos */
673 complain_overflow_bitfield, /* complain_on_overflow */
674 ppc64_elf_unhandled_reloc, /* special_function */
675 "R_PPC64_PLT32", /* name */
676 FALSE, /* partial_inplace */
677 0, /* src_mask */
678 0xffffffff, /* dst_mask */
679 FALSE), /* pcrel_offset */
680
681 /* 32-bit PC relative relocation to the symbol's procedure linkage table.
682 FIXME: R_PPC64_PLTREL32 not supported. */
683 HOWTO (R_PPC64_PLTREL32, /* type */
684 0, /* rightshift */
685 2, /* size (0 = byte, 1 = short, 2 = long) */
686 32, /* bitsize */
687 TRUE, /* pc_relative */
688 0, /* bitpos */
689 complain_overflow_signed, /* complain_on_overflow */
690 bfd_elf_generic_reloc, /* special_function */
691 "R_PPC64_PLTREL32", /* name */
692 FALSE, /* partial_inplace */
693 0, /* src_mask */
694 0xffffffff, /* dst_mask */
695 TRUE), /* pcrel_offset */
696
697 /* Like R_PPC64_ADDR16_LO, but referring to the PLT table entry for
698 the symbol. */
699 HOWTO (R_PPC64_PLT16_LO, /* type */
700 0, /* rightshift */
701 1, /* size (0 = byte, 1 = short, 2 = long) */
702 16, /* bitsize */
703 FALSE, /* pc_relative */
704 0, /* bitpos */
705 complain_overflow_dont, /* complain_on_overflow */
706 ppc64_elf_unhandled_reloc, /* special_function */
707 "R_PPC64_PLT16_LO", /* name */
708 FALSE, /* partial_inplace */
709 0, /* src_mask */
710 0xffff, /* dst_mask */
711 FALSE), /* pcrel_offset */
712
713 /* Like R_PPC64_ADDR16_HI, but referring to the PLT table entry for
714 the symbol. */
715 HOWTO (R_PPC64_PLT16_HI, /* type */
716 16, /* rightshift */
717 1, /* size (0 = byte, 1 = short, 2 = long) */
718 16, /* bitsize */
719 FALSE, /* pc_relative */
720 0, /* bitpos */
721 complain_overflow_signed, /* complain_on_overflow */
722 ppc64_elf_unhandled_reloc, /* special_function */
723 "R_PPC64_PLT16_HI", /* name */
724 FALSE, /* partial_inplace */
725 0, /* src_mask */
726 0xffff, /* dst_mask */
727 FALSE), /* pcrel_offset */
728
729 /* Like R_PPC64_ADDR16_HA, but referring to the PLT table entry for
730 the symbol. */
731 HOWTO (R_PPC64_PLT16_HA, /* type */
732 16, /* rightshift */
733 1, /* size (0 = byte, 1 = short, 2 = long) */
734 16, /* bitsize */
735 FALSE, /* pc_relative */
736 0, /* bitpos */
737 complain_overflow_signed, /* complain_on_overflow */
738 ppc64_elf_unhandled_reloc, /* special_function */
739 "R_PPC64_PLT16_HA", /* name */
740 FALSE, /* partial_inplace */
741 0, /* src_mask */
742 0xffff, /* dst_mask */
743 FALSE), /* pcrel_offset */
744
745 /* 16-bit section relative relocation. */
746 HOWTO (R_PPC64_SECTOFF, /* type */
747 0, /* rightshift */
748 1, /* size (0 = byte, 1 = short, 2 = long) */
749 16, /* bitsize */
750 FALSE, /* pc_relative */
751 0, /* bitpos */
752 complain_overflow_signed, /* complain_on_overflow */
753 ppc64_elf_sectoff_reloc, /* special_function */
754 "R_PPC64_SECTOFF", /* name */
755 FALSE, /* partial_inplace */
756 0, /* src_mask */
757 0xffff, /* dst_mask */
758 FALSE), /* pcrel_offset */
759
760 /* Like R_PPC64_SECTOFF, but no overflow warning. */
761 HOWTO (R_PPC64_SECTOFF_LO, /* type */
762 0, /* rightshift */
763 1, /* size (0 = byte, 1 = short, 2 = long) */
764 16, /* bitsize */
765 FALSE, /* pc_relative */
766 0, /* bitpos */
767 complain_overflow_dont, /* complain_on_overflow */
768 ppc64_elf_sectoff_reloc, /* special_function */
769 "R_PPC64_SECTOFF_LO", /* name */
770 FALSE, /* partial_inplace */
771 0, /* src_mask */
772 0xffff, /* dst_mask */
773 FALSE), /* pcrel_offset */
774
775 /* 16-bit upper half section relative relocation. */
776 HOWTO (R_PPC64_SECTOFF_HI, /* type */
777 16, /* rightshift */
778 1, /* size (0 = byte, 1 = short, 2 = long) */
779 16, /* bitsize */
780 FALSE, /* pc_relative */
781 0, /* bitpos */
782 complain_overflow_signed, /* complain_on_overflow */
783 ppc64_elf_sectoff_reloc, /* special_function */
784 "R_PPC64_SECTOFF_HI", /* name */
785 FALSE, /* partial_inplace */
786 0, /* src_mask */
787 0xffff, /* dst_mask */
788 FALSE), /* pcrel_offset */
789
790 /* 16-bit upper half adjusted section relative relocation. */
791 HOWTO (R_PPC64_SECTOFF_HA, /* type */
792 16, /* rightshift */
793 1, /* size (0 = byte, 1 = short, 2 = long) */
794 16, /* bitsize */
795 FALSE, /* pc_relative */
796 0, /* bitpos */
797 complain_overflow_signed, /* complain_on_overflow */
798 ppc64_elf_sectoff_ha_reloc, /* special_function */
799 "R_PPC64_SECTOFF_HA", /* name */
800 FALSE, /* partial_inplace */
801 0, /* src_mask */
802 0xffff, /* dst_mask */
803 FALSE), /* pcrel_offset */
804
805 /* Like R_PPC64_REL24 without touching the two least significant bits. */
806 HOWTO (R_PPC64_REL30, /* type */
807 2, /* rightshift */
808 2, /* size (0 = byte, 1 = short, 2 = long) */
809 30, /* bitsize */
810 TRUE, /* pc_relative */
811 0, /* bitpos */
812 complain_overflow_dont, /* complain_on_overflow */
813 bfd_elf_generic_reloc, /* special_function */
814 "R_PPC64_REL30", /* name */
815 FALSE, /* partial_inplace */
816 0, /* src_mask */
817 0xfffffffc, /* dst_mask */
818 TRUE), /* pcrel_offset */
819
820 /* Relocs in the 64-bit PowerPC ELF ABI, not in the 32-bit ABI. */
821
822 /* A standard 64-bit relocation. */
823 HOWTO (R_PPC64_ADDR64, /* type */
824 0, /* rightshift */
825 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
826 64, /* bitsize */
827 FALSE, /* pc_relative */
828 0, /* bitpos */
829 complain_overflow_dont, /* complain_on_overflow */
830 bfd_elf_generic_reloc, /* special_function */
831 "R_PPC64_ADDR64", /* name */
832 FALSE, /* partial_inplace */
833 0, /* src_mask */
834 ONES (64), /* dst_mask */
835 FALSE), /* pcrel_offset */
836
837 /* The bits 32-47 of an address. */
838 HOWTO (R_PPC64_ADDR16_HIGHER, /* type */
839 32, /* rightshift */
840 1, /* size (0 = byte, 1 = short, 2 = long) */
841 16, /* bitsize */
842 FALSE, /* pc_relative */
843 0, /* bitpos */
844 complain_overflow_dont, /* complain_on_overflow */
845 bfd_elf_generic_reloc, /* special_function */
846 "R_PPC64_ADDR16_HIGHER", /* name */
847 FALSE, /* partial_inplace */
848 0, /* src_mask */
849 0xffff, /* dst_mask */
850 FALSE), /* pcrel_offset */
851
852 /* The bits 32-47 of an address, plus 1 if the contents of the low
853 16 bits, treated as a signed number, is negative. */
854 HOWTO (R_PPC64_ADDR16_HIGHERA, /* type */
855 32, /* rightshift */
856 1, /* size (0 = byte, 1 = short, 2 = long) */
857 16, /* bitsize */
858 FALSE, /* pc_relative */
859 0, /* bitpos */
860 complain_overflow_dont, /* complain_on_overflow */
861 ppc64_elf_ha_reloc, /* special_function */
862 "R_PPC64_ADDR16_HIGHERA", /* name */
863 FALSE, /* partial_inplace */
864 0, /* src_mask */
865 0xffff, /* dst_mask */
866 FALSE), /* pcrel_offset */
867
868 /* The bits 48-63 of an address. */
869 HOWTO (R_PPC64_ADDR16_HIGHEST,/* type */
870 48, /* rightshift */
871 1, /* size (0 = byte, 1 = short, 2 = long) */
872 16, /* bitsize */
873 FALSE, /* pc_relative */
874 0, /* bitpos */
875 complain_overflow_dont, /* complain_on_overflow */
876 bfd_elf_generic_reloc, /* special_function */
877 "R_PPC64_ADDR16_HIGHEST", /* name */
878 FALSE, /* partial_inplace */
879 0, /* src_mask */
880 0xffff, /* dst_mask */
881 FALSE), /* pcrel_offset */
882
883 /* The bits 48-63 of an address, plus 1 if the contents of the low
884 16 bits, treated as a signed number, is negative. */
885 HOWTO (R_PPC64_ADDR16_HIGHESTA,/* type */
886 48, /* rightshift */
887 1, /* size (0 = byte, 1 = short, 2 = long) */
888 16, /* bitsize */
889 FALSE, /* pc_relative */
890 0, /* bitpos */
891 complain_overflow_dont, /* complain_on_overflow */
892 ppc64_elf_ha_reloc, /* special_function */
893 "R_PPC64_ADDR16_HIGHESTA", /* name */
894 FALSE, /* partial_inplace */
895 0, /* src_mask */
896 0xffff, /* dst_mask */
897 FALSE), /* pcrel_offset */
898
899 /* Like ADDR64, but may be unaligned. */
900 HOWTO (R_PPC64_UADDR64, /* type */
901 0, /* rightshift */
902 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
903 64, /* bitsize */
904 FALSE, /* pc_relative */
905 0, /* bitpos */
906 complain_overflow_dont, /* complain_on_overflow */
907 bfd_elf_generic_reloc, /* special_function */
908 "R_PPC64_UADDR64", /* name */
909 FALSE, /* partial_inplace */
910 0, /* src_mask */
911 ONES (64), /* dst_mask */
912 FALSE), /* pcrel_offset */
913
914 /* 64-bit relative relocation. */
915 HOWTO (R_PPC64_REL64, /* type */
916 0, /* rightshift */
917 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
918 64, /* bitsize */
919 TRUE, /* pc_relative */
920 0, /* bitpos */
921 complain_overflow_dont, /* complain_on_overflow */
922 bfd_elf_generic_reloc, /* special_function */
923 "R_PPC64_REL64", /* name */
924 FALSE, /* partial_inplace */
925 0, /* src_mask */
926 ONES (64), /* dst_mask */
927 TRUE), /* pcrel_offset */
928
929 /* 64-bit relocation to the symbol's procedure linkage table. */
930 HOWTO (R_PPC64_PLT64, /* type */
931 0, /* rightshift */
932 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
933 64, /* bitsize */
934 FALSE, /* pc_relative */
935 0, /* bitpos */
936 complain_overflow_dont, /* complain_on_overflow */
937 ppc64_elf_unhandled_reloc, /* special_function */
938 "R_PPC64_PLT64", /* name */
939 FALSE, /* partial_inplace */
940 0, /* src_mask */
941 ONES (64), /* dst_mask */
942 FALSE), /* pcrel_offset */
943
944 /* 64-bit PC relative relocation to the symbol's procedure linkage
945 table. */
946 /* FIXME: R_PPC64_PLTREL64 not supported. */
947 HOWTO (R_PPC64_PLTREL64, /* type */
948 0, /* rightshift */
949 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
950 64, /* bitsize */
951 TRUE, /* pc_relative */
952 0, /* bitpos */
953 complain_overflow_dont, /* complain_on_overflow */
954 ppc64_elf_unhandled_reloc, /* special_function */
955 "R_PPC64_PLTREL64", /* name */
956 FALSE, /* partial_inplace */
957 0, /* src_mask */
958 ONES (64), /* dst_mask */
959 TRUE), /* pcrel_offset */
960
961 /* 16 bit TOC-relative relocation. */
962
963 /* R_PPC64_TOC16 47 half16* S + A - .TOC. */
964 HOWTO (R_PPC64_TOC16, /* type */
965 0, /* rightshift */
966 1, /* size (0 = byte, 1 = short, 2 = long) */
967 16, /* bitsize */
968 FALSE, /* pc_relative */
969 0, /* bitpos */
970 complain_overflow_signed, /* complain_on_overflow */
971 ppc64_elf_toc_reloc, /* special_function */
972 "R_PPC64_TOC16", /* name */
973 FALSE, /* partial_inplace */
974 0, /* src_mask */
975 0xffff, /* dst_mask */
976 FALSE), /* pcrel_offset */
977
978 /* 16 bit TOC-relative relocation without overflow. */
979
980 /* R_PPC64_TOC16_LO 48 half16 #lo (S + A - .TOC.) */
981 HOWTO (R_PPC64_TOC16_LO, /* type */
982 0, /* rightshift */
983 1, /* size (0 = byte, 1 = short, 2 = long) */
984 16, /* bitsize */
985 FALSE, /* pc_relative */
986 0, /* bitpos */
987 complain_overflow_dont, /* complain_on_overflow */
988 ppc64_elf_toc_reloc, /* special_function */
989 "R_PPC64_TOC16_LO", /* name */
990 FALSE, /* partial_inplace */
991 0, /* src_mask */
992 0xffff, /* dst_mask */
993 FALSE), /* pcrel_offset */
994
995 /* 16 bit TOC-relative relocation, high 16 bits. */
996
997 /* R_PPC64_TOC16_HI 49 half16 #hi (S + A - .TOC.) */
998 HOWTO (R_PPC64_TOC16_HI, /* type */
999 16, /* rightshift */
1000 1, /* size (0 = byte, 1 = short, 2 = long) */
1001 16, /* bitsize */
1002 FALSE, /* pc_relative */
1003 0, /* bitpos */
1004 complain_overflow_signed, /* complain_on_overflow */
1005 ppc64_elf_toc_reloc, /* special_function */
1006 "R_PPC64_TOC16_HI", /* name */
1007 FALSE, /* partial_inplace */
1008 0, /* src_mask */
1009 0xffff, /* dst_mask */
1010 FALSE), /* pcrel_offset */
1011
1012 /* 16 bit TOC-relative relocation, high 16 bits, plus 1 if the
1013 contents of the low 16 bits, treated as a signed number, is
1014 negative. */
1015
1016 /* R_PPC64_TOC16_HA 50 half16 #ha (S + A - .TOC.) */
1017 HOWTO (R_PPC64_TOC16_HA, /* type */
1018 16, /* rightshift */
1019 1, /* size (0 = byte, 1 = short, 2 = long) */
1020 16, /* bitsize */
1021 FALSE, /* pc_relative */
1022 0, /* bitpos */
1023 complain_overflow_signed, /* complain_on_overflow */
1024 ppc64_elf_toc_ha_reloc, /* special_function */
1025 "R_PPC64_TOC16_HA", /* name */
1026 FALSE, /* partial_inplace */
1027 0, /* src_mask */
1028 0xffff, /* dst_mask */
1029 FALSE), /* pcrel_offset */
1030
1031 /* 64-bit relocation; insert value of TOC base (.TOC.). */
1032
1033 /* R_PPC64_TOC 51 doubleword64 .TOC. */
1034 HOWTO (R_PPC64_TOC, /* type */
1035 0, /* rightshift */
1036 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1037 64, /* bitsize */
1038 FALSE, /* pc_relative */
1039 0, /* bitpos */
1040 complain_overflow_dont, /* complain_on_overflow */
1041 ppc64_elf_toc64_reloc, /* special_function */
1042 "R_PPC64_TOC", /* name */
1043 FALSE, /* partial_inplace */
1044 0, /* src_mask */
1045 ONES (64), /* dst_mask */
1046 FALSE), /* pcrel_offset */
1047
1048 /* Like R_PPC64_GOT16, but also informs the link editor that the
1049 value to relocate may (!) refer to a PLT entry which the link
1050 editor (a) may replace with the symbol value. If the link editor
1051 is unable to fully resolve the symbol, it may (b) create a PLT
1052 entry and store the address to the new PLT entry in the GOT.
1053 This permits lazy resolution of function symbols at run time.
1054 The link editor may also skip all of this and just (c) emit a
1055 R_PPC64_GLOB_DAT to tie the symbol to the GOT entry. */
1056 /* FIXME: R_PPC64_PLTGOT16 not implemented. */
1057 HOWTO (R_PPC64_PLTGOT16, /* type */
1058 0, /* rightshift */
1059 1, /* size (0 = byte, 1 = short, 2 = long) */
1060 16, /* bitsize */
1061 FALSE, /* pc_relative */
1062 0, /* bitpos */
1063 complain_overflow_signed, /* complain_on_overflow */
1064 ppc64_elf_unhandled_reloc, /* special_function */
1065 "R_PPC64_PLTGOT16", /* name */
1066 FALSE, /* partial_inplace */
1067 0, /* src_mask */
1068 0xffff, /* dst_mask */
1069 FALSE), /* pcrel_offset */
1070
1071 /* Like R_PPC64_PLTGOT16, but without overflow. */
1072 /* FIXME: R_PPC64_PLTGOT16_LO not implemented. */
1073 HOWTO (R_PPC64_PLTGOT16_LO, /* type */
1074 0, /* rightshift */
1075 1, /* size (0 = byte, 1 = short, 2 = long) */
1076 16, /* bitsize */
1077 FALSE, /* pc_relative */
1078 0, /* bitpos */
1079 complain_overflow_dont, /* complain_on_overflow */
1080 ppc64_elf_unhandled_reloc, /* special_function */
1081 "R_PPC64_PLTGOT16_LO", /* name */
1082 FALSE, /* partial_inplace */
1083 0, /* src_mask */
1084 0xffff, /* dst_mask */
1085 FALSE), /* pcrel_offset */
1086
1087 /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address. */
1088 /* FIXME: R_PPC64_PLTGOT16_HI not implemented. */
1089 HOWTO (R_PPC64_PLTGOT16_HI, /* type */
1090 16, /* rightshift */
1091 1, /* size (0 = byte, 1 = short, 2 = long) */
1092 16, /* bitsize */
1093 FALSE, /* pc_relative */
1094 0, /* bitpos */
1095 complain_overflow_signed, /* complain_on_overflow */
1096 ppc64_elf_unhandled_reloc, /* special_function */
1097 "R_PPC64_PLTGOT16_HI", /* name */
1098 FALSE, /* partial_inplace */
1099 0, /* src_mask */
1100 0xffff, /* dst_mask */
1101 FALSE), /* pcrel_offset */
1102
1103 /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address, plus
1104 1 if the contents of the low 16 bits, treated as a signed number,
1105 is negative. */
1106 /* FIXME: R_PPC64_PLTGOT16_HA not implemented. */
1107 HOWTO (R_PPC64_PLTGOT16_HA, /* type */
1108 16, /* rightshift */
1109 1, /* size (0 = byte, 1 = short, 2 = long) */
1110 16, /* bitsize */
1111 FALSE, /* pc_relative */
1112 0, /* bitpos */
1113 complain_overflow_signed, /* complain_on_overflow */
1114 ppc64_elf_unhandled_reloc, /* special_function */
1115 "R_PPC64_PLTGOT16_HA", /* name */
1116 FALSE, /* partial_inplace */
1117 0, /* src_mask */
1118 0xffff, /* dst_mask */
1119 FALSE), /* pcrel_offset */
1120
1121 /* Like R_PPC64_ADDR16, but for instructions with a DS field. */
1122 HOWTO (R_PPC64_ADDR16_DS, /* type */
1123 0, /* rightshift */
1124 1, /* size (0 = byte, 1 = short, 2 = long) */
1125 16, /* bitsize */
1126 FALSE, /* pc_relative */
1127 0, /* bitpos */
1128 complain_overflow_signed, /* complain_on_overflow */
1129 bfd_elf_generic_reloc, /* special_function */
1130 "R_PPC64_ADDR16_DS", /* name */
1131 FALSE, /* partial_inplace */
1132 0, /* src_mask */
1133 0xfffc, /* dst_mask */
1134 FALSE), /* pcrel_offset */
1135
1136 /* Like R_PPC64_ADDR16_LO, but for instructions with a DS field. */
1137 HOWTO (R_PPC64_ADDR16_LO_DS, /* type */
1138 0, /* rightshift */
1139 1, /* size (0 = byte, 1 = short, 2 = long) */
1140 16, /* bitsize */
1141 FALSE, /* pc_relative */
1142 0, /* bitpos */
1143 complain_overflow_dont,/* complain_on_overflow */
1144 bfd_elf_generic_reloc, /* special_function */
1145 "R_PPC64_ADDR16_LO_DS",/* name */
1146 FALSE, /* partial_inplace */
1147 0, /* src_mask */
1148 0xfffc, /* dst_mask */
1149 FALSE), /* pcrel_offset */
1150
1151 /* Like R_PPC64_GOT16, but for instructions with a DS field. */
1152 HOWTO (R_PPC64_GOT16_DS, /* type */
1153 0, /* rightshift */
1154 1, /* size (0 = byte, 1 = short, 2 = long) */
1155 16, /* bitsize */
1156 FALSE, /* pc_relative */
1157 0, /* bitpos */
1158 complain_overflow_signed, /* complain_on_overflow */
1159 ppc64_elf_unhandled_reloc, /* special_function */
1160 "R_PPC64_GOT16_DS", /* name */
1161 FALSE, /* partial_inplace */
1162 0, /* src_mask */
1163 0xfffc, /* dst_mask */
1164 FALSE), /* pcrel_offset */
1165
1166 /* Like R_PPC64_GOT16_LO, but for instructions with a DS field. */
1167 HOWTO (R_PPC64_GOT16_LO_DS, /* type */
1168 0, /* rightshift */
1169 1, /* size (0 = byte, 1 = short, 2 = long) */
1170 16, /* bitsize */
1171 FALSE, /* pc_relative */
1172 0, /* bitpos */
1173 complain_overflow_dont, /* complain_on_overflow */
1174 ppc64_elf_unhandled_reloc, /* special_function */
1175 "R_PPC64_GOT16_LO_DS", /* name */
1176 FALSE, /* partial_inplace */
1177 0, /* src_mask */
1178 0xfffc, /* dst_mask */
1179 FALSE), /* pcrel_offset */
1180
1181 /* Like R_PPC64_PLT16_LO, but for instructions with a DS field. */
1182 HOWTO (R_PPC64_PLT16_LO_DS, /* type */
1183 0, /* rightshift */
1184 1, /* size (0 = byte, 1 = short, 2 = long) */
1185 16, /* bitsize */
1186 FALSE, /* pc_relative */
1187 0, /* bitpos */
1188 complain_overflow_dont, /* complain_on_overflow */
1189 ppc64_elf_unhandled_reloc, /* special_function */
1190 "R_PPC64_PLT16_LO_DS", /* name */
1191 FALSE, /* partial_inplace */
1192 0, /* src_mask */
1193 0xfffc, /* dst_mask */
1194 FALSE), /* pcrel_offset */
1195
1196 /* Like R_PPC64_SECTOFF, but for instructions with a DS field. */
1197 HOWTO (R_PPC64_SECTOFF_DS, /* type */
1198 0, /* rightshift */
1199 1, /* size (0 = byte, 1 = short, 2 = long) */
1200 16, /* bitsize */
1201 FALSE, /* pc_relative */
1202 0, /* bitpos */
1203 complain_overflow_signed, /* complain_on_overflow */
1204 ppc64_elf_sectoff_reloc, /* special_function */
1205 "R_PPC64_SECTOFF_DS", /* name */
1206 FALSE, /* partial_inplace */
1207 0, /* src_mask */
1208 0xfffc, /* dst_mask */
1209 FALSE), /* pcrel_offset */
1210
1211 /* Like R_PPC64_SECTOFF_LO, but for instructions with a DS field. */
1212 HOWTO (R_PPC64_SECTOFF_LO_DS, /* type */
1213 0, /* rightshift */
1214 1, /* size (0 = byte, 1 = short, 2 = long) */
1215 16, /* bitsize */
1216 FALSE, /* pc_relative */
1217 0, /* bitpos */
1218 complain_overflow_dont, /* complain_on_overflow */
1219 ppc64_elf_sectoff_reloc, /* special_function */
1220 "R_PPC64_SECTOFF_LO_DS",/* name */
1221 FALSE, /* partial_inplace */
1222 0, /* src_mask */
1223 0xfffc, /* dst_mask */
1224 FALSE), /* pcrel_offset */
1225
1226 /* Like R_PPC64_TOC16, but for instructions with a DS field. */
1227 HOWTO (R_PPC64_TOC16_DS, /* type */
1228 0, /* rightshift */
1229 1, /* size (0 = byte, 1 = short, 2 = long) */
1230 16, /* bitsize */
1231 FALSE, /* pc_relative */
1232 0, /* bitpos */
1233 complain_overflow_signed, /* complain_on_overflow */
1234 ppc64_elf_toc_reloc, /* special_function */
1235 "R_PPC64_TOC16_DS", /* name */
1236 FALSE, /* partial_inplace */
1237 0, /* src_mask */
1238 0xfffc, /* dst_mask */
1239 FALSE), /* pcrel_offset */
1240
1241 /* Like R_PPC64_TOC16_LO, but for instructions with a DS field. */
1242 HOWTO (R_PPC64_TOC16_LO_DS, /* type */
1243 0, /* rightshift */
1244 1, /* size (0 = byte, 1 = short, 2 = long) */
1245 16, /* bitsize */
1246 FALSE, /* pc_relative */
1247 0, /* bitpos */
1248 complain_overflow_dont, /* complain_on_overflow */
1249 ppc64_elf_toc_reloc, /* special_function */
1250 "R_PPC64_TOC16_LO_DS", /* name */
1251 FALSE, /* partial_inplace */
1252 0, /* src_mask */
1253 0xfffc, /* dst_mask */
1254 FALSE), /* pcrel_offset */
1255
1256 /* Like R_PPC64_PLTGOT16, but for instructions with a DS field. */
1257 /* FIXME: R_PPC64_PLTGOT16_DS not implemented. */
1258 HOWTO (R_PPC64_PLTGOT16_DS, /* type */
1259 0, /* rightshift */
1260 1, /* size (0 = byte, 1 = short, 2 = long) */
1261 16, /* bitsize */
1262 FALSE, /* pc_relative */
1263 0, /* bitpos */
1264 complain_overflow_signed, /* complain_on_overflow */
1265 ppc64_elf_unhandled_reloc, /* special_function */
1266 "R_PPC64_PLTGOT16_DS", /* name */
1267 FALSE, /* partial_inplace */
1268 0, /* src_mask */
1269 0xfffc, /* dst_mask */
1270 FALSE), /* pcrel_offset */
1271
1272 /* Like R_PPC64_PLTGOT16_LO, but for instructions with a DS field. */
1273 /* FIXME: R_PPC64_PLTGOT16_LO not implemented. */
1274 HOWTO (R_PPC64_PLTGOT16_LO_DS,/* type */
1275 0, /* rightshift */
1276 1, /* size (0 = byte, 1 = short, 2 = long) */
1277 16, /* bitsize */
1278 FALSE, /* pc_relative */
1279 0, /* bitpos */
1280 complain_overflow_dont, /* complain_on_overflow */
1281 ppc64_elf_unhandled_reloc, /* special_function */
1282 "R_PPC64_PLTGOT16_LO_DS",/* name */
1283 FALSE, /* partial_inplace */
1284 0, /* src_mask */
1285 0xfffc, /* dst_mask */
1286 FALSE), /* pcrel_offset */
1287
1288 /* Marker relocs for TLS. */
1289 HOWTO (R_PPC64_TLS,
1290 0, /* rightshift */
1291 2, /* size (0 = byte, 1 = short, 2 = long) */
1292 32, /* bitsize */
1293 FALSE, /* pc_relative */
1294 0, /* bitpos */
1295 complain_overflow_dont, /* complain_on_overflow */
1296 bfd_elf_generic_reloc, /* special_function */
1297 "R_PPC64_TLS", /* name */
1298 FALSE, /* partial_inplace */
1299 0, /* src_mask */
1300 0, /* dst_mask */
1301 FALSE), /* pcrel_offset */
1302
1303 HOWTO (R_PPC64_TLSGD,
1304 0, /* rightshift */
1305 2, /* size (0 = byte, 1 = short, 2 = long) */
1306 32, /* bitsize */
1307 FALSE, /* pc_relative */
1308 0, /* bitpos */
1309 complain_overflow_dont, /* complain_on_overflow */
1310 bfd_elf_generic_reloc, /* special_function */
1311 "R_PPC64_TLSGD", /* name */
1312 FALSE, /* partial_inplace */
1313 0, /* src_mask */
1314 0, /* dst_mask */
1315 FALSE), /* pcrel_offset */
1316
1317 HOWTO (R_PPC64_TLSLD,
1318 0, /* rightshift */
1319 2, /* size (0 = byte, 1 = short, 2 = long) */
1320 32, /* bitsize */
1321 FALSE, /* pc_relative */
1322 0, /* bitpos */
1323 complain_overflow_dont, /* complain_on_overflow */
1324 bfd_elf_generic_reloc, /* special_function */
1325 "R_PPC64_TLSLD", /* name */
1326 FALSE, /* partial_inplace */
1327 0, /* src_mask */
1328 0, /* dst_mask */
1329 FALSE), /* pcrel_offset */
1330
1331 HOWTO (R_PPC64_TOCSAVE,
1332 0, /* rightshift */
1333 2, /* size (0 = byte, 1 = short, 2 = long) */
1334 32, /* bitsize */
1335 FALSE, /* pc_relative */
1336 0, /* bitpos */
1337 complain_overflow_dont, /* complain_on_overflow */
1338 bfd_elf_generic_reloc, /* special_function */
1339 "R_PPC64_TOCSAVE", /* name */
1340 FALSE, /* partial_inplace */
1341 0, /* src_mask */
1342 0, /* dst_mask */
1343 FALSE), /* pcrel_offset */
1344
1345 /* Computes the load module index of the load module that contains the
1346 definition of its TLS sym. */
1347 HOWTO (R_PPC64_DTPMOD64,
1348 0, /* rightshift */
1349 4, /* size (0 = byte, 1 = short, 2 = long) */
1350 64, /* bitsize */
1351 FALSE, /* pc_relative */
1352 0, /* bitpos */
1353 complain_overflow_dont, /* complain_on_overflow */
1354 ppc64_elf_unhandled_reloc, /* special_function */
1355 "R_PPC64_DTPMOD64", /* name */
1356 FALSE, /* partial_inplace */
1357 0, /* src_mask */
1358 ONES (64), /* dst_mask */
1359 FALSE), /* pcrel_offset */
1360
1361 /* Computes a dtv-relative displacement, the difference between the value
1362 of sym+add and the base address of the thread-local storage block that
1363 contains the definition of sym, minus 0x8000. */
1364 HOWTO (R_PPC64_DTPREL64,
1365 0, /* rightshift */
1366 4, /* size (0 = byte, 1 = short, 2 = long) */
1367 64, /* bitsize */
1368 FALSE, /* pc_relative */
1369 0, /* bitpos */
1370 complain_overflow_dont, /* complain_on_overflow */
1371 ppc64_elf_unhandled_reloc, /* special_function */
1372 "R_PPC64_DTPREL64", /* name */
1373 FALSE, /* partial_inplace */
1374 0, /* src_mask */
1375 ONES (64), /* dst_mask */
1376 FALSE), /* pcrel_offset */
1377
1378 /* A 16 bit dtprel reloc. */
1379 HOWTO (R_PPC64_DTPREL16,
1380 0, /* rightshift */
1381 1, /* size (0 = byte, 1 = short, 2 = long) */
1382 16, /* bitsize */
1383 FALSE, /* pc_relative */
1384 0, /* bitpos */
1385 complain_overflow_signed, /* complain_on_overflow */
1386 ppc64_elf_unhandled_reloc, /* special_function */
1387 "R_PPC64_DTPREL16", /* name */
1388 FALSE, /* partial_inplace */
1389 0, /* src_mask */
1390 0xffff, /* dst_mask */
1391 FALSE), /* pcrel_offset */
1392
1393 /* Like DTPREL16, but no overflow. */
1394 HOWTO (R_PPC64_DTPREL16_LO,
1395 0, /* rightshift */
1396 1, /* size (0 = byte, 1 = short, 2 = long) */
1397 16, /* bitsize */
1398 FALSE, /* pc_relative */
1399 0, /* bitpos */
1400 complain_overflow_dont, /* complain_on_overflow */
1401 ppc64_elf_unhandled_reloc, /* special_function */
1402 "R_PPC64_DTPREL16_LO", /* name */
1403 FALSE, /* partial_inplace */
1404 0, /* src_mask */
1405 0xffff, /* dst_mask */
1406 FALSE), /* pcrel_offset */
1407
1408 /* Like DTPREL16_LO, but next higher group of 16 bits. */
1409 HOWTO (R_PPC64_DTPREL16_HI,
1410 16, /* rightshift */
1411 1, /* size (0 = byte, 1 = short, 2 = long) */
1412 16, /* bitsize */
1413 FALSE, /* pc_relative */
1414 0, /* bitpos */
1415 complain_overflow_signed, /* complain_on_overflow */
1416 ppc64_elf_unhandled_reloc, /* special_function */
1417 "R_PPC64_DTPREL16_HI", /* name */
1418 FALSE, /* partial_inplace */
1419 0, /* src_mask */
1420 0xffff, /* dst_mask */
1421 FALSE), /* pcrel_offset */
1422
1423 /* Like DTPREL16_HI, but adjust for low 16 bits. */
1424 HOWTO (R_PPC64_DTPREL16_HA,
1425 16, /* rightshift */
1426 1, /* size (0 = byte, 1 = short, 2 = long) */
1427 16, /* bitsize */
1428 FALSE, /* pc_relative */
1429 0, /* bitpos */
1430 complain_overflow_signed, /* complain_on_overflow */
1431 ppc64_elf_unhandled_reloc, /* special_function */
1432 "R_PPC64_DTPREL16_HA", /* name */
1433 FALSE, /* partial_inplace */
1434 0, /* src_mask */
1435 0xffff, /* dst_mask */
1436 FALSE), /* pcrel_offset */
1437
1438 /* Like DTPREL16_HI, but next higher group of 16 bits. */
1439 HOWTO (R_PPC64_DTPREL16_HIGHER,
1440 32, /* rightshift */
1441 1, /* size (0 = byte, 1 = short, 2 = long) */
1442 16, /* bitsize */
1443 FALSE, /* pc_relative */
1444 0, /* bitpos */
1445 complain_overflow_dont, /* complain_on_overflow */
1446 ppc64_elf_unhandled_reloc, /* special_function */
1447 "R_PPC64_DTPREL16_HIGHER", /* name */
1448 FALSE, /* partial_inplace */
1449 0, /* src_mask */
1450 0xffff, /* dst_mask */
1451 FALSE), /* pcrel_offset */
1452
1453 /* Like DTPREL16_HIGHER, but adjust for low 16 bits. */
1454 HOWTO (R_PPC64_DTPREL16_HIGHERA,
1455 32, /* rightshift */
1456 1, /* size (0 = byte, 1 = short, 2 = long) */
1457 16, /* bitsize */
1458 FALSE, /* pc_relative */
1459 0, /* bitpos */
1460 complain_overflow_dont, /* complain_on_overflow */
1461 ppc64_elf_unhandled_reloc, /* special_function */
1462 "R_PPC64_DTPREL16_HIGHERA", /* name */
1463 FALSE, /* partial_inplace */
1464 0, /* src_mask */
1465 0xffff, /* dst_mask */
1466 FALSE), /* pcrel_offset */
1467
1468 /* Like DTPREL16_HIGHER, but next higher group of 16 bits. */
1469 HOWTO (R_PPC64_DTPREL16_HIGHEST,
1470 48, /* rightshift */
1471 1, /* size (0 = byte, 1 = short, 2 = long) */
1472 16, /* bitsize */
1473 FALSE, /* pc_relative */
1474 0, /* bitpos */
1475 complain_overflow_dont, /* complain_on_overflow */
1476 ppc64_elf_unhandled_reloc, /* special_function */
1477 "R_PPC64_DTPREL16_HIGHEST", /* name */
1478 FALSE, /* partial_inplace */
1479 0, /* src_mask */
1480 0xffff, /* dst_mask */
1481 FALSE), /* pcrel_offset */
1482
1483 /* Like DTPREL16_HIGHEST, but adjust for low 16 bits. */
1484 HOWTO (R_PPC64_DTPREL16_HIGHESTA,
1485 48, /* rightshift */
1486 1, /* size (0 = byte, 1 = short, 2 = long) */
1487 16, /* bitsize */
1488 FALSE, /* pc_relative */
1489 0, /* bitpos */
1490 complain_overflow_dont, /* complain_on_overflow */
1491 ppc64_elf_unhandled_reloc, /* special_function */
1492 "R_PPC64_DTPREL16_HIGHESTA", /* name */
1493 FALSE, /* partial_inplace */
1494 0, /* src_mask */
1495 0xffff, /* dst_mask */
1496 FALSE), /* pcrel_offset */
1497
1498 /* Like DTPREL16, but for insns with a DS field. */
1499 HOWTO (R_PPC64_DTPREL16_DS,
1500 0, /* rightshift */
1501 1, /* size (0 = byte, 1 = short, 2 = long) */
1502 16, /* bitsize */
1503 FALSE, /* pc_relative */
1504 0, /* bitpos */
1505 complain_overflow_signed, /* complain_on_overflow */
1506 ppc64_elf_unhandled_reloc, /* special_function */
1507 "R_PPC64_DTPREL16_DS", /* name */
1508 FALSE, /* partial_inplace */
1509 0, /* src_mask */
1510 0xfffc, /* dst_mask */
1511 FALSE), /* pcrel_offset */
1512
1513 /* Like DTPREL16_DS, but no overflow. */
1514 HOWTO (R_PPC64_DTPREL16_LO_DS,
1515 0, /* rightshift */
1516 1, /* size (0 = byte, 1 = short, 2 = long) */
1517 16, /* bitsize */
1518 FALSE, /* pc_relative */
1519 0, /* bitpos */
1520 complain_overflow_dont, /* complain_on_overflow */
1521 ppc64_elf_unhandled_reloc, /* special_function */
1522 "R_PPC64_DTPREL16_LO_DS", /* name */
1523 FALSE, /* partial_inplace */
1524 0, /* src_mask */
1525 0xfffc, /* dst_mask */
1526 FALSE), /* pcrel_offset */
1527
1528 /* Computes a tp-relative displacement, the difference between the value of
1529 sym+add and the value of the thread pointer (r13). */
1530 HOWTO (R_PPC64_TPREL64,
1531 0, /* rightshift */
1532 4, /* size (0 = byte, 1 = short, 2 = long) */
1533 64, /* bitsize */
1534 FALSE, /* pc_relative */
1535 0, /* bitpos */
1536 complain_overflow_dont, /* complain_on_overflow */
1537 ppc64_elf_unhandled_reloc, /* special_function */
1538 "R_PPC64_TPREL64", /* name */
1539 FALSE, /* partial_inplace */
1540 0, /* src_mask */
1541 ONES (64), /* dst_mask */
1542 FALSE), /* pcrel_offset */
1543
1544 /* A 16 bit tprel reloc. */
1545 HOWTO (R_PPC64_TPREL16,
1546 0, /* rightshift */
1547 1, /* size (0 = byte, 1 = short, 2 = long) */
1548 16, /* bitsize */
1549 FALSE, /* pc_relative */
1550 0, /* bitpos */
1551 complain_overflow_signed, /* complain_on_overflow */
1552 ppc64_elf_unhandled_reloc, /* special_function */
1553 "R_PPC64_TPREL16", /* name */
1554 FALSE, /* partial_inplace */
1555 0, /* src_mask */
1556 0xffff, /* dst_mask */
1557 FALSE), /* pcrel_offset */
1558
1559 /* Like TPREL16, but no overflow. */
1560 HOWTO (R_PPC64_TPREL16_LO,
1561 0, /* rightshift */
1562 1, /* size (0 = byte, 1 = short, 2 = long) */
1563 16, /* bitsize */
1564 FALSE, /* pc_relative */
1565 0, /* bitpos */
1566 complain_overflow_dont, /* complain_on_overflow */
1567 ppc64_elf_unhandled_reloc, /* special_function */
1568 "R_PPC64_TPREL16_LO", /* name */
1569 FALSE, /* partial_inplace */
1570 0, /* src_mask */
1571 0xffff, /* dst_mask */
1572 FALSE), /* pcrel_offset */
1573
1574 /* Like TPREL16_LO, but next higher group of 16 bits. */
1575 HOWTO (R_PPC64_TPREL16_HI,
1576 16, /* rightshift */
1577 1, /* size (0 = byte, 1 = short, 2 = long) */
1578 16, /* bitsize */
1579 FALSE, /* pc_relative */
1580 0, /* bitpos */
1581 complain_overflow_signed, /* complain_on_overflow */
1582 ppc64_elf_unhandled_reloc, /* special_function */
1583 "R_PPC64_TPREL16_HI", /* name */
1584 FALSE, /* partial_inplace */
1585 0, /* src_mask */
1586 0xffff, /* dst_mask */
1587 FALSE), /* pcrel_offset */
1588
1589 /* Like TPREL16_HI, but adjust for low 16 bits. */
1590 HOWTO (R_PPC64_TPREL16_HA,
1591 16, /* rightshift */
1592 1, /* size (0 = byte, 1 = short, 2 = long) */
1593 16, /* bitsize */
1594 FALSE, /* pc_relative */
1595 0, /* bitpos */
1596 complain_overflow_signed, /* complain_on_overflow */
1597 ppc64_elf_unhandled_reloc, /* special_function */
1598 "R_PPC64_TPREL16_HA", /* name */
1599 FALSE, /* partial_inplace */
1600 0, /* src_mask */
1601 0xffff, /* dst_mask */
1602 FALSE), /* pcrel_offset */
1603
1604 /* Like TPREL16_HI, but next higher group of 16 bits. */
1605 HOWTO (R_PPC64_TPREL16_HIGHER,
1606 32, /* rightshift */
1607 1, /* size (0 = byte, 1 = short, 2 = long) */
1608 16, /* bitsize */
1609 FALSE, /* pc_relative */
1610 0, /* bitpos */
1611 complain_overflow_dont, /* complain_on_overflow */
1612 ppc64_elf_unhandled_reloc, /* special_function */
1613 "R_PPC64_TPREL16_HIGHER", /* name */
1614 FALSE, /* partial_inplace */
1615 0, /* src_mask */
1616 0xffff, /* dst_mask */
1617 FALSE), /* pcrel_offset */
1618
1619 /* Like TPREL16_HIGHER, but adjust for low 16 bits. */
1620 HOWTO (R_PPC64_TPREL16_HIGHERA,
1621 32, /* rightshift */
1622 1, /* size (0 = byte, 1 = short, 2 = long) */
1623 16, /* bitsize */
1624 FALSE, /* pc_relative */
1625 0, /* bitpos */
1626 complain_overflow_dont, /* complain_on_overflow */
1627 ppc64_elf_unhandled_reloc, /* special_function */
1628 "R_PPC64_TPREL16_HIGHERA", /* name */
1629 FALSE, /* partial_inplace */
1630 0, /* src_mask */
1631 0xffff, /* dst_mask */
1632 FALSE), /* pcrel_offset */
1633
1634 /* Like TPREL16_HIGHER, but next higher group of 16 bits. */
1635 HOWTO (R_PPC64_TPREL16_HIGHEST,
1636 48, /* rightshift */
1637 1, /* size (0 = byte, 1 = short, 2 = long) */
1638 16, /* bitsize */
1639 FALSE, /* pc_relative */
1640 0, /* bitpos */
1641 complain_overflow_dont, /* complain_on_overflow */
1642 ppc64_elf_unhandled_reloc, /* special_function */
1643 "R_PPC64_TPREL16_HIGHEST", /* name */
1644 FALSE, /* partial_inplace */
1645 0, /* src_mask */
1646 0xffff, /* dst_mask */
1647 FALSE), /* pcrel_offset */
1648
1649 /* Like TPREL16_HIGHEST, but adjust for low 16 bits. */
1650 HOWTO (R_PPC64_TPREL16_HIGHESTA,
1651 48, /* rightshift */
1652 1, /* size (0 = byte, 1 = short, 2 = long) */
1653 16, /* bitsize */
1654 FALSE, /* pc_relative */
1655 0, /* bitpos */
1656 complain_overflow_dont, /* complain_on_overflow */
1657 ppc64_elf_unhandled_reloc, /* special_function */
1658 "R_PPC64_TPREL16_HIGHESTA", /* name */
1659 FALSE, /* partial_inplace */
1660 0, /* src_mask */
1661 0xffff, /* dst_mask */
1662 FALSE), /* pcrel_offset */
1663
1664 /* Like TPREL16, but for insns with a DS field. */
1665 HOWTO (R_PPC64_TPREL16_DS,
1666 0, /* rightshift */
1667 1, /* size (0 = byte, 1 = short, 2 = long) */
1668 16, /* bitsize */
1669 FALSE, /* pc_relative */
1670 0, /* bitpos */
1671 complain_overflow_signed, /* complain_on_overflow */
1672 ppc64_elf_unhandled_reloc, /* special_function */
1673 "R_PPC64_TPREL16_DS", /* name */
1674 FALSE, /* partial_inplace */
1675 0, /* src_mask */
1676 0xfffc, /* dst_mask */
1677 FALSE), /* pcrel_offset */
1678
1679 /* Like TPREL16_DS, but no overflow. */
1680 HOWTO (R_PPC64_TPREL16_LO_DS,
1681 0, /* rightshift */
1682 1, /* size (0 = byte, 1 = short, 2 = long) */
1683 16, /* bitsize */
1684 FALSE, /* pc_relative */
1685 0, /* bitpos */
1686 complain_overflow_dont, /* complain_on_overflow */
1687 ppc64_elf_unhandled_reloc, /* special_function */
1688 "R_PPC64_TPREL16_LO_DS", /* name */
1689 FALSE, /* partial_inplace */
1690 0, /* src_mask */
1691 0xfffc, /* dst_mask */
1692 FALSE), /* pcrel_offset */
1693
1694 /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1695 with values (sym+add)@dtpmod and (sym+add)@dtprel, and computes the offset
1696 to the first entry relative to the TOC base (r2). */
1697 HOWTO (R_PPC64_GOT_TLSGD16,
1698 0, /* rightshift */
1699 1, /* size (0 = byte, 1 = short, 2 = long) */
1700 16, /* bitsize */
1701 FALSE, /* pc_relative */
1702 0, /* bitpos */
1703 complain_overflow_signed, /* complain_on_overflow */
1704 ppc64_elf_unhandled_reloc, /* special_function */
1705 "R_PPC64_GOT_TLSGD16", /* name */
1706 FALSE, /* partial_inplace */
1707 0, /* src_mask */
1708 0xffff, /* dst_mask */
1709 FALSE), /* pcrel_offset */
1710
1711 /* Like GOT_TLSGD16, but no overflow. */
1712 HOWTO (R_PPC64_GOT_TLSGD16_LO,
1713 0, /* rightshift */
1714 1, /* size (0 = byte, 1 = short, 2 = long) */
1715 16, /* bitsize */
1716 FALSE, /* pc_relative */
1717 0, /* bitpos */
1718 complain_overflow_dont, /* complain_on_overflow */
1719 ppc64_elf_unhandled_reloc, /* special_function */
1720 "R_PPC64_GOT_TLSGD16_LO", /* name */
1721 FALSE, /* partial_inplace */
1722 0, /* src_mask */
1723 0xffff, /* dst_mask */
1724 FALSE), /* pcrel_offset */
1725
1726 /* Like GOT_TLSGD16_LO, but next higher group of 16 bits. */
1727 HOWTO (R_PPC64_GOT_TLSGD16_HI,
1728 16, /* rightshift */
1729 1, /* size (0 = byte, 1 = short, 2 = long) */
1730 16, /* bitsize */
1731 FALSE, /* pc_relative */
1732 0, /* bitpos */
1733 complain_overflow_signed, /* complain_on_overflow */
1734 ppc64_elf_unhandled_reloc, /* special_function */
1735 "R_PPC64_GOT_TLSGD16_HI", /* name */
1736 FALSE, /* partial_inplace */
1737 0, /* src_mask */
1738 0xffff, /* dst_mask */
1739 FALSE), /* pcrel_offset */
1740
1741 /* Like GOT_TLSGD16_HI, but adjust for low 16 bits. */
1742 HOWTO (R_PPC64_GOT_TLSGD16_HA,
1743 16, /* rightshift */
1744 1, /* size (0 = byte, 1 = short, 2 = long) */
1745 16, /* bitsize */
1746 FALSE, /* pc_relative */
1747 0, /* bitpos */
1748 complain_overflow_signed, /* complain_on_overflow */
1749 ppc64_elf_unhandled_reloc, /* special_function */
1750 "R_PPC64_GOT_TLSGD16_HA", /* name */
1751 FALSE, /* partial_inplace */
1752 0, /* src_mask */
1753 0xffff, /* dst_mask */
1754 FALSE), /* pcrel_offset */
1755
1756 /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1757 with values (sym+add)@dtpmod and zero, and computes the offset to the
1758 first entry relative to the TOC base (r2). */
1759 HOWTO (R_PPC64_GOT_TLSLD16,
1760 0, /* rightshift */
1761 1, /* size (0 = byte, 1 = short, 2 = long) */
1762 16, /* bitsize */
1763 FALSE, /* pc_relative */
1764 0, /* bitpos */
1765 complain_overflow_signed, /* complain_on_overflow */
1766 ppc64_elf_unhandled_reloc, /* special_function */
1767 "R_PPC64_GOT_TLSLD16", /* name */
1768 FALSE, /* partial_inplace */
1769 0, /* src_mask */
1770 0xffff, /* dst_mask */
1771 FALSE), /* pcrel_offset */
1772
1773 /* Like GOT_TLSLD16, but no overflow. */
1774 HOWTO (R_PPC64_GOT_TLSLD16_LO,
1775 0, /* rightshift */
1776 1, /* size (0 = byte, 1 = short, 2 = long) */
1777 16, /* bitsize */
1778 FALSE, /* pc_relative */
1779 0, /* bitpos */
1780 complain_overflow_dont, /* complain_on_overflow */
1781 ppc64_elf_unhandled_reloc, /* special_function */
1782 "R_PPC64_GOT_TLSLD16_LO", /* name */
1783 FALSE, /* partial_inplace */
1784 0, /* src_mask */
1785 0xffff, /* dst_mask */
1786 FALSE), /* pcrel_offset */
1787
1788 /* Like GOT_TLSLD16_LO, but next higher group of 16 bits. */
1789 HOWTO (R_PPC64_GOT_TLSLD16_HI,
1790 16, /* rightshift */
1791 1, /* size (0 = byte, 1 = short, 2 = long) */
1792 16, /* bitsize */
1793 FALSE, /* pc_relative */
1794 0, /* bitpos */
1795 complain_overflow_signed, /* complain_on_overflow */
1796 ppc64_elf_unhandled_reloc, /* special_function */
1797 "R_PPC64_GOT_TLSLD16_HI", /* name */
1798 FALSE, /* partial_inplace */
1799 0, /* src_mask */
1800 0xffff, /* dst_mask */
1801 FALSE), /* pcrel_offset */
1802
1803 /* Like GOT_TLSLD16_HI, but adjust for low 16 bits. */
1804 HOWTO (R_PPC64_GOT_TLSLD16_HA,
1805 16, /* rightshift */
1806 1, /* size (0 = byte, 1 = short, 2 = long) */
1807 16, /* bitsize */
1808 FALSE, /* pc_relative */
1809 0, /* bitpos */
1810 complain_overflow_signed, /* complain_on_overflow */
1811 ppc64_elf_unhandled_reloc, /* special_function */
1812 "R_PPC64_GOT_TLSLD16_HA", /* name */
1813 FALSE, /* partial_inplace */
1814 0, /* src_mask */
1815 0xffff, /* dst_mask */
1816 FALSE), /* pcrel_offset */
1817
1818 /* Allocates an entry in the GOT with value (sym+add)@dtprel, and computes
1819 the offset to the entry relative to the TOC base (r2). */
1820 HOWTO (R_PPC64_GOT_DTPREL16_DS,
1821 0, /* rightshift */
1822 1, /* size (0 = byte, 1 = short, 2 = long) */
1823 16, /* bitsize */
1824 FALSE, /* pc_relative */
1825 0, /* bitpos */
1826 complain_overflow_signed, /* complain_on_overflow */
1827 ppc64_elf_unhandled_reloc, /* special_function */
1828 "R_PPC64_GOT_DTPREL16_DS", /* name */
1829 FALSE, /* partial_inplace */
1830 0, /* src_mask */
1831 0xfffc, /* dst_mask */
1832 FALSE), /* pcrel_offset */
1833
1834 /* Like GOT_DTPREL16_DS, but no overflow. */
1835 HOWTO (R_PPC64_GOT_DTPREL16_LO_DS,
1836 0, /* rightshift */
1837 1, /* size (0 = byte, 1 = short, 2 = long) */
1838 16, /* bitsize */
1839 FALSE, /* pc_relative */
1840 0, /* bitpos */
1841 complain_overflow_dont, /* complain_on_overflow */
1842 ppc64_elf_unhandled_reloc, /* special_function */
1843 "R_PPC64_GOT_DTPREL16_LO_DS", /* name */
1844 FALSE, /* partial_inplace */
1845 0, /* src_mask */
1846 0xfffc, /* dst_mask */
1847 FALSE), /* pcrel_offset */
1848
1849 /* Like GOT_DTPREL16_LO_DS, but next higher group of 16 bits. */
1850 HOWTO (R_PPC64_GOT_DTPREL16_HI,
1851 16, /* rightshift */
1852 1, /* size (0 = byte, 1 = short, 2 = long) */
1853 16, /* bitsize */
1854 FALSE, /* pc_relative */
1855 0, /* bitpos */
1856 complain_overflow_signed, /* complain_on_overflow */
1857 ppc64_elf_unhandled_reloc, /* special_function */
1858 "R_PPC64_GOT_DTPREL16_HI", /* name */
1859 FALSE, /* partial_inplace */
1860 0, /* src_mask */
1861 0xffff, /* dst_mask */
1862 FALSE), /* pcrel_offset */
1863
1864 /* Like GOT_DTPREL16_HI, but adjust for low 16 bits. */
1865 HOWTO (R_PPC64_GOT_DTPREL16_HA,
1866 16, /* rightshift */
1867 1, /* size (0 = byte, 1 = short, 2 = long) */
1868 16, /* bitsize */
1869 FALSE, /* pc_relative */
1870 0, /* bitpos */
1871 complain_overflow_signed, /* complain_on_overflow */
1872 ppc64_elf_unhandled_reloc, /* special_function */
1873 "R_PPC64_GOT_DTPREL16_HA", /* name */
1874 FALSE, /* partial_inplace */
1875 0, /* src_mask */
1876 0xffff, /* dst_mask */
1877 FALSE), /* pcrel_offset */
1878
1879 /* Allocates an entry in the GOT with value (sym+add)@tprel, and computes the
1880 offset to the entry relative to the TOC base (r2). */
1881 HOWTO (R_PPC64_GOT_TPREL16_DS,
1882 0, /* rightshift */
1883 1, /* size (0 = byte, 1 = short, 2 = long) */
1884 16, /* bitsize */
1885 FALSE, /* pc_relative */
1886 0, /* bitpos */
1887 complain_overflow_signed, /* complain_on_overflow */
1888 ppc64_elf_unhandled_reloc, /* special_function */
1889 "R_PPC64_GOT_TPREL16_DS", /* name */
1890 FALSE, /* partial_inplace */
1891 0, /* src_mask */
1892 0xfffc, /* dst_mask */
1893 FALSE), /* pcrel_offset */
1894
1895 /* Like GOT_TPREL16_DS, but no overflow. */
1896 HOWTO (R_PPC64_GOT_TPREL16_LO_DS,
1897 0, /* rightshift */
1898 1, /* size (0 = byte, 1 = short, 2 = long) */
1899 16, /* bitsize */
1900 FALSE, /* pc_relative */
1901 0, /* bitpos */
1902 complain_overflow_dont, /* complain_on_overflow */
1903 ppc64_elf_unhandled_reloc, /* special_function */
1904 "R_PPC64_GOT_TPREL16_LO_DS", /* name */
1905 FALSE, /* partial_inplace */
1906 0, /* src_mask */
1907 0xfffc, /* dst_mask */
1908 FALSE), /* pcrel_offset */
1909
1910 /* Like GOT_TPREL16_LO_DS, but next higher group of 16 bits. */
1911 HOWTO (R_PPC64_GOT_TPREL16_HI,
1912 16, /* rightshift */
1913 1, /* size (0 = byte, 1 = short, 2 = long) */
1914 16, /* bitsize */
1915 FALSE, /* pc_relative */
1916 0, /* bitpos */
1917 complain_overflow_signed, /* complain_on_overflow */
1918 ppc64_elf_unhandled_reloc, /* special_function */
1919 "R_PPC64_GOT_TPREL16_HI", /* name */
1920 FALSE, /* partial_inplace */
1921 0, /* src_mask */
1922 0xffff, /* dst_mask */
1923 FALSE), /* pcrel_offset */
1924
1925 /* Like GOT_TPREL16_HI, but adjust for low 16 bits. */
1926 HOWTO (R_PPC64_GOT_TPREL16_HA,
1927 16, /* rightshift */
1928 1, /* size (0 = byte, 1 = short, 2 = long) */
1929 16, /* bitsize */
1930 FALSE, /* pc_relative */
1931 0, /* bitpos */
1932 complain_overflow_signed, /* complain_on_overflow */
1933 ppc64_elf_unhandled_reloc, /* special_function */
1934 "R_PPC64_GOT_TPREL16_HA", /* name */
1935 FALSE, /* partial_inplace */
1936 0, /* src_mask */
1937 0xffff, /* dst_mask */
1938 FALSE), /* pcrel_offset */
1939
1940 HOWTO (R_PPC64_JMP_IREL, /* type */
1941 0, /* rightshift */
1942 0, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1943 0, /* bitsize */
1944 FALSE, /* pc_relative */
1945 0, /* bitpos */
1946 complain_overflow_dont, /* complain_on_overflow */
1947 ppc64_elf_unhandled_reloc, /* special_function */
1948 "R_PPC64_JMP_IREL", /* name */
1949 FALSE, /* partial_inplace */
1950 0, /* src_mask */
1951 0, /* dst_mask */
1952 FALSE), /* pcrel_offset */
1953
1954 HOWTO (R_PPC64_IRELATIVE, /* type */
1955 0, /* rightshift */
1956 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1957 64, /* bitsize */
1958 FALSE, /* pc_relative */
1959 0, /* bitpos */
1960 complain_overflow_dont, /* complain_on_overflow */
1961 bfd_elf_generic_reloc, /* special_function */
1962 "R_PPC64_IRELATIVE", /* name */
1963 FALSE, /* partial_inplace */
1964 0, /* src_mask */
1965 ONES (64), /* dst_mask */
1966 FALSE), /* pcrel_offset */
1967
1968 /* A 16 bit relative relocation. */
1969 HOWTO (R_PPC64_REL16, /* type */
1970 0, /* rightshift */
1971 1, /* size (0 = byte, 1 = short, 2 = long) */
1972 16, /* bitsize */
1973 TRUE, /* pc_relative */
1974 0, /* bitpos */
1975 complain_overflow_signed, /* complain_on_overflow */
1976 bfd_elf_generic_reloc, /* special_function */
1977 "R_PPC64_REL16", /* name */
1978 FALSE, /* partial_inplace */
1979 0, /* src_mask */
1980 0xffff, /* dst_mask */
1981 TRUE), /* pcrel_offset */
1982
1983 /* A 16 bit relative relocation without overflow. */
1984 HOWTO (R_PPC64_REL16_LO, /* type */
1985 0, /* rightshift */
1986 1, /* size (0 = byte, 1 = short, 2 = long) */
1987 16, /* bitsize */
1988 TRUE, /* pc_relative */
1989 0, /* bitpos */
1990 complain_overflow_dont,/* complain_on_overflow */
1991 bfd_elf_generic_reloc, /* special_function */
1992 "R_PPC64_REL16_LO", /* name */
1993 FALSE, /* partial_inplace */
1994 0, /* src_mask */
1995 0xffff, /* dst_mask */
1996 TRUE), /* pcrel_offset */
1997
1998 /* The high order 16 bits of a relative address. */
1999 HOWTO (R_PPC64_REL16_HI, /* type */
2000 16, /* rightshift */
2001 1, /* size (0 = byte, 1 = short, 2 = long) */
2002 16, /* bitsize */
2003 TRUE, /* pc_relative */
2004 0, /* bitpos */
2005 complain_overflow_signed, /* complain_on_overflow */
2006 bfd_elf_generic_reloc, /* special_function */
2007 "R_PPC64_REL16_HI", /* name */
2008 FALSE, /* partial_inplace */
2009 0, /* src_mask */
2010 0xffff, /* dst_mask */
2011 TRUE), /* pcrel_offset */
2012
2013 /* The high order 16 bits of a relative address, plus 1 if the contents of
2014 the low 16 bits, treated as a signed number, is negative. */
2015 HOWTO (R_PPC64_REL16_HA, /* type */
2016 16, /* rightshift */
2017 1, /* size (0 = byte, 1 = short, 2 = long) */
2018 16, /* bitsize */
2019 TRUE, /* pc_relative */
2020 0, /* bitpos */
2021 complain_overflow_signed, /* complain_on_overflow */
2022 ppc64_elf_ha_reloc, /* special_function */
2023 "R_PPC64_REL16_HA", /* name */
2024 FALSE, /* partial_inplace */
2025 0, /* src_mask */
2026 0xffff, /* dst_mask */
2027 TRUE), /* pcrel_offset */
2028
2029 /* Like R_PPC64_REL16_HA but for split field in addpcis. */
2030 HOWTO (R_PPC64_REL16DX_HA, /* type */
2031 16, /* rightshift */
2032 2, /* size (0 = byte, 1 = short, 2 = long) */
2033 16, /* bitsize */
2034 TRUE, /* pc_relative */
2035 0, /* bitpos */
2036 complain_overflow_signed, /* complain_on_overflow */
2037 ppc64_elf_ha_reloc, /* special_function */
2038 "R_PPC64_REL16DX_HA", /* name */
2039 FALSE, /* partial_inplace */
2040 0, /* src_mask */
2041 0x1fffc1, /* dst_mask */
2042 TRUE), /* pcrel_offset */
2043
2044 /* Like R_PPC64_ADDR16_HI, but no overflow. */
2045 HOWTO (R_PPC64_ADDR16_HIGH, /* type */
2046 16, /* rightshift */
2047 1, /* size (0 = byte, 1 = short, 2 = long) */
2048 16, /* bitsize */
2049 FALSE, /* pc_relative */
2050 0, /* bitpos */
2051 complain_overflow_dont, /* complain_on_overflow */
2052 bfd_elf_generic_reloc, /* special_function */
2053 "R_PPC64_ADDR16_HIGH", /* name */
2054 FALSE, /* partial_inplace */
2055 0, /* src_mask */
2056 0xffff, /* dst_mask */
2057 FALSE), /* pcrel_offset */
2058
2059 /* Like R_PPC64_ADDR16_HA, but no overflow. */
2060 HOWTO (R_PPC64_ADDR16_HIGHA, /* type */
2061 16, /* rightshift */
2062 1, /* size (0 = byte, 1 = short, 2 = long) */
2063 16, /* bitsize */
2064 FALSE, /* pc_relative */
2065 0, /* bitpos */
2066 complain_overflow_dont, /* complain_on_overflow */
2067 ppc64_elf_ha_reloc, /* special_function */
2068 "R_PPC64_ADDR16_HIGHA", /* name */
2069 FALSE, /* partial_inplace */
2070 0, /* src_mask */
2071 0xffff, /* dst_mask */
2072 FALSE), /* pcrel_offset */
2073
2074 /* Like R_PPC64_DTPREL16_HI, but no overflow. */
2075 HOWTO (R_PPC64_DTPREL16_HIGH,
2076 16, /* rightshift */
2077 1, /* size (0 = byte, 1 = short, 2 = long) */
2078 16, /* bitsize */
2079 FALSE, /* pc_relative */
2080 0, /* bitpos */
2081 complain_overflow_dont, /* complain_on_overflow */
2082 ppc64_elf_unhandled_reloc, /* special_function */
2083 "R_PPC64_DTPREL16_HIGH", /* name */
2084 FALSE, /* partial_inplace */
2085 0, /* src_mask */
2086 0xffff, /* dst_mask */
2087 FALSE), /* pcrel_offset */
2088
2089 /* Like R_PPC64_DTPREL16_HA, but no overflow. */
2090 HOWTO (R_PPC64_DTPREL16_HIGHA,
2091 16, /* rightshift */
2092 1, /* size (0 = byte, 1 = short, 2 = long) */
2093 16, /* bitsize */
2094 FALSE, /* pc_relative */
2095 0, /* bitpos */
2096 complain_overflow_dont, /* complain_on_overflow */
2097 ppc64_elf_unhandled_reloc, /* special_function */
2098 "R_PPC64_DTPREL16_HIGHA", /* name */
2099 FALSE, /* partial_inplace */
2100 0, /* src_mask */
2101 0xffff, /* dst_mask */
2102 FALSE), /* pcrel_offset */
2103
2104 /* Like R_PPC64_TPREL16_HI, but no overflow. */
2105 HOWTO (R_PPC64_TPREL16_HIGH,
2106 16, /* rightshift */
2107 1, /* size (0 = byte, 1 = short, 2 = long) */
2108 16, /* bitsize */
2109 FALSE, /* pc_relative */
2110 0, /* bitpos */
2111 complain_overflow_dont, /* complain_on_overflow */
2112 ppc64_elf_unhandled_reloc, /* special_function */
2113 "R_PPC64_TPREL16_HIGH", /* name */
2114 FALSE, /* partial_inplace */
2115 0, /* src_mask */
2116 0xffff, /* dst_mask */
2117 FALSE), /* pcrel_offset */
2118
2119 /* Like R_PPC64_TPREL16_HA, but no overflow. */
2120 HOWTO (R_PPC64_TPREL16_HIGHA,
2121 16, /* rightshift */
2122 1, /* size (0 = byte, 1 = short, 2 = long) */
2123 16, /* bitsize */
2124 FALSE, /* pc_relative */
2125 0, /* bitpos */
2126 complain_overflow_dont, /* complain_on_overflow */
2127 ppc64_elf_unhandled_reloc, /* special_function */
2128 "R_PPC64_TPREL16_HIGHA", /* name */
2129 FALSE, /* partial_inplace */
2130 0, /* src_mask */
2131 0xffff, /* dst_mask */
2132 FALSE), /* pcrel_offset */
2133
2134 /* Marker reloc on ELFv2 large-model function entry. */
2135 HOWTO (R_PPC64_ENTRY,
2136 0, /* rightshift */
2137 2, /* size (0 = byte, 1 = short, 2 = long) */
2138 32, /* bitsize */
2139 FALSE, /* pc_relative */
2140 0, /* bitpos */
2141 complain_overflow_dont, /* complain_on_overflow */
2142 bfd_elf_generic_reloc, /* special_function */
2143 "R_PPC64_ENTRY", /* name */
2144 FALSE, /* partial_inplace */
2145 0, /* src_mask */
2146 0, /* dst_mask */
2147 FALSE), /* pcrel_offset */
2148
2149 /* Like ADDR64, but use local entry point of function. */
2150 HOWTO (R_PPC64_ADDR64_LOCAL, /* type */
2151 0, /* rightshift */
2152 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
2153 64, /* bitsize */
2154 FALSE, /* pc_relative */
2155 0, /* bitpos */
2156 complain_overflow_dont, /* complain_on_overflow */
2157 bfd_elf_generic_reloc, /* special_function */
2158 "R_PPC64_ADDR64_LOCAL", /* name */
2159 FALSE, /* partial_inplace */
2160 0, /* src_mask */
2161 ONES (64), /* dst_mask */
2162 FALSE), /* pcrel_offset */
2163
2164 /* GNU extension to record C++ vtable hierarchy. */
2165 HOWTO (R_PPC64_GNU_VTINHERIT, /* type */
2166 0, /* rightshift */
2167 0, /* size (0 = byte, 1 = short, 2 = long) */
2168 0, /* bitsize */
2169 FALSE, /* pc_relative */
2170 0, /* bitpos */
2171 complain_overflow_dont, /* complain_on_overflow */
2172 NULL, /* special_function */
2173 "R_PPC64_GNU_VTINHERIT", /* name */
2174 FALSE, /* partial_inplace */
2175 0, /* src_mask */
2176 0, /* dst_mask */
2177 FALSE), /* pcrel_offset */
2178
2179 /* GNU extension to record C++ vtable member usage. */
2180 HOWTO (R_PPC64_GNU_VTENTRY, /* type */
2181 0, /* rightshift */
2182 0, /* size (0 = byte, 1 = short, 2 = long) */
2183 0, /* bitsize */
2184 FALSE, /* pc_relative */
2185 0, /* bitpos */
2186 complain_overflow_dont, /* complain_on_overflow */
2187 NULL, /* special_function */
2188 "R_PPC64_GNU_VTENTRY", /* name */
2189 FALSE, /* partial_inplace */
2190 0, /* src_mask */
2191 0, /* dst_mask */
2192 FALSE), /* pcrel_offset */
2193 };
2194
2195
2196 /* Initialize the ppc64_elf_howto_table, so that linear accesses can
2197 be done. */
2198
2199 static void
ppc_howto_init(void)2200 ppc_howto_init (void)
2201 {
2202 unsigned int i, type;
2203
2204 for (i = 0; i < ARRAY_SIZE (ppc64_elf_howto_raw); i++)
2205 {
2206 type = ppc64_elf_howto_raw[i].type;
2207 BFD_ASSERT (type < ARRAY_SIZE (ppc64_elf_howto_table));
2208 ppc64_elf_howto_table[type] = &ppc64_elf_howto_raw[i];
2209 }
2210 }
2211
2212 static reloc_howto_type *
ppc64_elf_reloc_type_lookup(bfd * abfd ATTRIBUTE_UNUSED,bfd_reloc_code_real_type code)2213 ppc64_elf_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2214 bfd_reloc_code_real_type code)
2215 {
2216 enum elf_ppc64_reloc_type r = R_PPC64_NONE;
2217
2218 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2219 /* Initialize howto table if needed. */
2220 ppc_howto_init ();
2221
2222 switch (code)
2223 {
2224 default:
2225 return NULL;
2226
2227 case BFD_RELOC_NONE: r = R_PPC64_NONE;
2228 break;
2229 case BFD_RELOC_32: r = R_PPC64_ADDR32;
2230 break;
2231 case BFD_RELOC_PPC_BA26: r = R_PPC64_ADDR24;
2232 break;
2233 case BFD_RELOC_16: r = R_PPC64_ADDR16;
2234 break;
2235 case BFD_RELOC_LO16: r = R_PPC64_ADDR16_LO;
2236 break;
2237 case BFD_RELOC_HI16: r = R_PPC64_ADDR16_HI;
2238 break;
2239 case BFD_RELOC_PPC64_ADDR16_HIGH: r = R_PPC64_ADDR16_HIGH;
2240 break;
2241 case BFD_RELOC_HI16_S: r = R_PPC64_ADDR16_HA;
2242 break;
2243 case BFD_RELOC_PPC64_ADDR16_HIGHA: r = R_PPC64_ADDR16_HIGHA;
2244 break;
2245 case BFD_RELOC_PPC_BA16: r = R_PPC64_ADDR14;
2246 break;
2247 case BFD_RELOC_PPC_BA16_BRTAKEN: r = R_PPC64_ADDR14_BRTAKEN;
2248 break;
2249 case BFD_RELOC_PPC_BA16_BRNTAKEN: r = R_PPC64_ADDR14_BRNTAKEN;
2250 break;
2251 case BFD_RELOC_PPC_B26: r = R_PPC64_REL24;
2252 break;
2253 case BFD_RELOC_PPC_B16: r = R_PPC64_REL14;
2254 break;
2255 case BFD_RELOC_PPC_B16_BRTAKEN: r = R_PPC64_REL14_BRTAKEN;
2256 break;
2257 case BFD_RELOC_PPC_B16_BRNTAKEN: r = R_PPC64_REL14_BRNTAKEN;
2258 break;
2259 case BFD_RELOC_16_GOTOFF: r = R_PPC64_GOT16;
2260 break;
2261 case BFD_RELOC_LO16_GOTOFF: r = R_PPC64_GOT16_LO;
2262 break;
2263 case BFD_RELOC_HI16_GOTOFF: r = R_PPC64_GOT16_HI;
2264 break;
2265 case BFD_RELOC_HI16_S_GOTOFF: r = R_PPC64_GOT16_HA;
2266 break;
2267 case BFD_RELOC_PPC_COPY: r = R_PPC64_COPY;
2268 break;
2269 case BFD_RELOC_PPC_GLOB_DAT: r = R_PPC64_GLOB_DAT;
2270 break;
2271 case BFD_RELOC_32_PCREL: r = R_PPC64_REL32;
2272 break;
2273 case BFD_RELOC_32_PLTOFF: r = R_PPC64_PLT32;
2274 break;
2275 case BFD_RELOC_32_PLT_PCREL: r = R_PPC64_PLTREL32;
2276 break;
2277 case BFD_RELOC_LO16_PLTOFF: r = R_PPC64_PLT16_LO;
2278 break;
2279 case BFD_RELOC_HI16_PLTOFF: r = R_PPC64_PLT16_HI;
2280 break;
2281 case BFD_RELOC_HI16_S_PLTOFF: r = R_PPC64_PLT16_HA;
2282 break;
2283 case BFD_RELOC_16_BASEREL: r = R_PPC64_SECTOFF;
2284 break;
2285 case BFD_RELOC_LO16_BASEREL: r = R_PPC64_SECTOFF_LO;
2286 break;
2287 case BFD_RELOC_HI16_BASEREL: r = R_PPC64_SECTOFF_HI;
2288 break;
2289 case BFD_RELOC_HI16_S_BASEREL: r = R_PPC64_SECTOFF_HA;
2290 break;
2291 case BFD_RELOC_CTOR: r = R_PPC64_ADDR64;
2292 break;
2293 case BFD_RELOC_64: r = R_PPC64_ADDR64;
2294 break;
2295 case BFD_RELOC_PPC64_HIGHER: r = R_PPC64_ADDR16_HIGHER;
2296 break;
2297 case BFD_RELOC_PPC64_HIGHER_S: r = R_PPC64_ADDR16_HIGHERA;
2298 break;
2299 case BFD_RELOC_PPC64_HIGHEST: r = R_PPC64_ADDR16_HIGHEST;
2300 break;
2301 case BFD_RELOC_PPC64_HIGHEST_S: r = R_PPC64_ADDR16_HIGHESTA;
2302 break;
2303 case BFD_RELOC_64_PCREL: r = R_PPC64_REL64;
2304 break;
2305 case BFD_RELOC_64_PLTOFF: r = R_PPC64_PLT64;
2306 break;
2307 case BFD_RELOC_64_PLT_PCREL: r = R_PPC64_PLTREL64;
2308 break;
2309 case BFD_RELOC_PPC_TOC16: r = R_PPC64_TOC16;
2310 break;
2311 case BFD_RELOC_PPC64_TOC16_LO: r = R_PPC64_TOC16_LO;
2312 break;
2313 case BFD_RELOC_PPC64_TOC16_HI: r = R_PPC64_TOC16_HI;
2314 break;
2315 case BFD_RELOC_PPC64_TOC16_HA: r = R_PPC64_TOC16_HA;
2316 break;
2317 case BFD_RELOC_PPC64_TOC: r = R_PPC64_TOC;
2318 break;
2319 case BFD_RELOC_PPC64_PLTGOT16: r = R_PPC64_PLTGOT16;
2320 break;
2321 case BFD_RELOC_PPC64_PLTGOT16_LO: r = R_PPC64_PLTGOT16_LO;
2322 break;
2323 case BFD_RELOC_PPC64_PLTGOT16_HI: r = R_PPC64_PLTGOT16_HI;
2324 break;
2325 case BFD_RELOC_PPC64_PLTGOT16_HA: r = R_PPC64_PLTGOT16_HA;
2326 break;
2327 case BFD_RELOC_PPC64_ADDR16_DS: r = R_PPC64_ADDR16_DS;
2328 break;
2329 case BFD_RELOC_PPC64_ADDR16_LO_DS: r = R_PPC64_ADDR16_LO_DS;
2330 break;
2331 case BFD_RELOC_PPC64_GOT16_DS: r = R_PPC64_GOT16_DS;
2332 break;
2333 case BFD_RELOC_PPC64_GOT16_LO_DS: r = R_PPC64_GOT16_LO_DS;
2334 break;
2335 case BFD_RELOC_PPC64_PLT16_LO_DS: r = R_PPC64_PLT16_LO_DS;
2336 break;
2337 case BFD_RELOC_PPC64_SECTOFF_DS: r = R_PPC64_SECTOFF_DS;
2338 break;
2339 case BFD_RELOC_PPC64_SECTOFF_LO_DS: r = R_PPC64_SECTOFF_LO_DS;
2340 break;
2341 case BFD_RELOC_PPC64_TOC16_DS: r = R_PPC64_TOC16_DS;
2342 break;
2343 case BFD_RELOC_PPC64_TOC16_LO_DS: r = R_PPC64_TOC16_LO_DS;
2344 break;
2345 case BFD_RELOC_PPC64_PLTGOT16_DS: r = R_PPC64_PLTGOT16_DS;
2346 break;
2347 case BFD_RELOC_PPC64_PLTGOT16_LO_DS: r = R_PPC64_PLTGOT16_LO_DS;
2348 break;
2349 case BFD_RELOC_PPC_TLS: r = R_PPC64_TLS;
2350 break;
2351 case BFD_RELOC_PPC_TLSGD: r = R_PPC64_TLSGD;
2352 break;
2353 case BFD_RELOC_PPC_TLSLD: r = R_PPC64_TLSLD;
2354 break;
2355 case BFD_RELOC_PPC_DTPMOD: r = R_PPC64_DTPMOD64;
2356 break;
2357 case BFD_RELOC_PPC_TPREL16: r = R_PPC64_TPREL16;
2358 break;
2359 case BFD_RELOC_PPC_TPREL16_LO: r = R_PPC64_TPREL16_LO;
2360 break;
2361 case BFD_RELOC_PPC_TPREL16_HI: r = R_PPC64_TPREL16_HI;
2362 break;
2363 case BFD_RELOC_PPC64_TPREL16_HIGH: r = R_PPC64_TPREL16_HIGH;
2364 break;
2365 case BFD_RELOC_PPC_TPREL16_HA: r = R_PPC64_TPREL16_HA;
2366 break;
2367 case BFD_RELOC_PPC64_TPREL16_HIGHA: r = R_PPC64_TPREL16_HIGHA;
2368 break;
2369 case BFD_RELOC_PPC_TPREL: r = R_PPC64_TPREL64;
2370 break;
2371 case BFD_RELOC_PPC_DTPREL16: r = R_PPC64_DTPREL16;
2372 break;
2373 case BFD_RELOC_PPC_DTPREL16_LO: r = R_PPC64_DTPREL16_LO;
2374 break;
2375 case BFD_RELOC_PPC_DTPREL16_HI: r = R_PPC64_DTPREL16_HI;
2376 break;
2377 case BFD_RELOC_PPC64_DTPREL16_HIGH: r = R_PPC64_DTPREL16_HIGH;
2378 break;
2379 case BFD_RELOC_PPC_DTPREL16_HA: r = R_PPC64_DTPREL16_HA;
2380 break;
2381 case BFD_RELOC_PPC64_DTPREL16_HIGHA: r = R_PPC64_DTPREL16_HIGHA;
2382 break;
2383 case BFD_RELOC_PPC_DTPREL: r = R_PPC64_DTPREL64;
2384 break;
2385 case BFD_RELOC_PPC_GOT_TLSGD16: r = R_PPC64_GOT_TLSGD16;
2386 break;
2387 case BFD_RELOC_PPC_GOT_TLSGD16_LO: r = R_PPC64_GOT_TLSGD16_LO;
2388 break;
2389 case BFD_RELOC_PPC_GOT_TLSGD16_HI: r = R_PPC64_GOT_TLSGD16_HI;
2390 break;
2391 case BFD_RELOC_PPC_GOT_TLSGD16_HA: r = R_PPC64_GOT_TLSGD16_HA;
2392 break;
2393 case BFD_RELOC_PPC_GOT_TLSLD16: r = R_PPC64_GOT_TLSLD16;
2394 break;
2395 case BFD_RELOC_PPC_GOT_TLSLD16_LO: r = R_PPC64_GOT_TLSLD16_LO;
2396 break;
2397 case BFD_RELOC_PPC_GOT_TLSLD16_HI: r = R_PPC64_GOT_TLSLD16_HI;
2398 break;
2399 case BFD_RELOC_PPC_GOT_TLSLD16_HA: r = R_PPC64_GOT_TLSLD16_HA;
2400 break;
2401 case BFD_RELOC_PPC_GOT_TPREL16: r = R_PPC64_GOT_TPREL16_DS;
2402 break;
2403 case BFD_RELOC_PPC_GOT_TPREL16_LO: r = R_PPC64_GOT_TPREL16_LO_DS;
2404 break;
2405 case BFD_RELOC_PPC_GOT_TPREL16_HI: r = R_PPC64_GOT_TPREL16_HI;
2406 break;
2407 case BFD_RELOC_PPC_GOT_TPREL16_HA: r = R_PPC64_GOT_TPREL16_HA;
2408 break;
2409 case BFD_RELOC_PPC_GOT_DTPREL16: r = R_PPC64_GOT_DTPREL16_DS;
2410 break;
2411 case BFD_RELOC_PPC_GOT_DTPREL16_LO: r = R_PPC64_GOT_DTPREL16_LO_DS;
2412 break;
2413 case BFD_RELOC_PPC_GOT_DTPREL16_HI: r = R_PPC64_GOT_DTPREL16_HI;
2414 break;
2415 case BFD_RELOC_PPC_GOT_DTPREL16_HA: r = R_PPC64_GOT_DTPREL16_HA;
2416 break;
2417 case BFD_RELOC_PPC64_TPREL16_DS: r = R_PPC64_TPREL16_DS;
2418 break;
2419 case BFD_RELOC_PPC64_TPREL16_LO_DS: r = R_PPC64_TPREL16_LO_DS;
2420 break;
2421 case BFD_RELOC_PPC64_TPREL16_HIGHER: r = R_PPC64_TPREL16_HIGHER;
2422 break;
2423 case BFD_RELOC_PPC64_TPREL16_HIGHERA: r = R_PPC64_TPREL16_HIGHERA;
2424 break;
2425 case BFD_RELOC_PPC64_TPREL16_HIGHEST: r = R_PPC64_TPREL16_HIGHEST;
2426 break;
2427 case BFD_RELOC_PPC64_TPREL16_HIGHESTA: r = R_PPC64_TPREL16_HIGHESTA;
2428 break;
2429 case BFD_RELOC_PPC64_DTPREL16_DS: r = R_PPC64_DTPREL16_DS;
2430 break;
2431 case BFD_RELOC_PPC64_DTPREL16_LO_DS: r = R_PPC64_DTPREL16_LO_DS;
2432 break;
2433 case BFD_RELOC_PPC64_DTPREL16_HIGHER: r = R_PPC64_DTPREL16_HIGHER;
2434 break;
2435 case BFD_RELOC_PPC64_DTPREL16_HIGHERA: r = R_PPC64_DTPREL16_HIGHERA;
2436 break;
2437 case BFD_RELOC_PPC64_DTPREL16_HIGHEST: r = R_PPC64_DTPREL16_HIGHEST;
2438 break;
2439 case BFD_RELOC_PPC64_DTPREL16_HIGHESTA: r = R_PPC64_DTPREL16_HIGHESTA;
2440 break;
2441 case BFD_RELOC_16_PCREL: r = R_PPC64_REL16;
2442 break;
2443 case BFD_RELOC_LO16_PCREL: r = R_PPC64_REL16_LO;
2444 break;
2445 case BFD_RELOC_HI16_PCREL: r = R_PPC64_REL16_HI;
2446 break;
2447 case BFD_RELOC_HI16_S_PCREL: r = R_PPC64_REL16_HA;
2448 break;
2449 case BFD_RELOC_PPC_REL16DX_HA: r = R_PPC64_REL16DX_HA;
2450 break;
2451 case BFD_RELOC_PPC64_ENTRY: r = R_PPC64_ENTRY;
2452 break;
2453 case BFD_RELOC_PPC64_ADDR64_LOCAL: r = R_PPC64_ADDR64_LOCAL;
2454 break;
2455 case BFD_RELOC_VTABLE_INHERIT: r = R_PPC64_GNU_VTINHERIT;
2456 break;
2457 case BFD_RELOC_VTABLE_ENTRY: r = R_PPC64_GNU_VTENTRY;
2458 break;
2459 }
2460
2461 return ppc64_elf_howto_table[r];
2462 };
2463
2464 static reloc_howto_type *
ppc64_elf_reloc_name_lookup(bfd * abfd ATTRIBUTE_UNUSED,const char * r_name)2465 ppc64_elf_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2466 const char *r_name)
2467 {
2468 unsigned int i;
2469
2470 for (i = 0; i < ARRAY_SIZE (ppc64_elf_howto_raw); i++)
2471 if (ppc64_elf_howto_raw[i].name != NULL
2472 && strcasecmp (ppc64_elf_howto_raw[i].name, r_name) == 0)
2473 return &ppc64_elf_howto_raw[i];
2474
2475 return NULL;
2476 }
2477
2478 /* Set the howto pointer for a PowerPC ELF reloc. */
2479
2480 static void
ppc64_elf_info_to_howto(bfd * abfd ATTRIBUTE_UNUSED,arelent * cache_ptr,Elf_Internal_Rela * dst)2481 ppc64_elf_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr,
2482 Elf_Internal_Rela *dst)
2483 {
2484 unsigned int type;
2485
2486 /* Initialize howto table if needed. */
2487 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2488 ppc_howto_init ();
2489
2490 type = ELF64_R_TYPE (dst->r_info);
2491 if (type >= ARRAY_SIZE (ppc64_elf_howto_table))
2492 {
2493 (*_bfd_error_handler) (_("%B: invalid relocation type %d"),
2494 abfd, (int) type);
2495 type = R_PPC64_NONE;
2496 }
2497 cache_ptr->howto = ppc64_elf_howto_table[type];
2498 }
2499
2500 /* Handle the R_PPC64_ADDR16_HA and similar relocs. */
2501
2502 static bfd_reloc_status_type
ppc64_elf_ha_reloc(bfd * abfd,arelent * reloc_entry,asymbol * symbol,void * data,asection * input_section,bfd * output_bfd,char ** error_message)2503 ppc64_elf_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2504 void *data, asection *input_section,
2505 bfd *output_bfd, char **error_message)
2506 {
2507 enum elf_ppc64_reloc_type r_type;
2508 long insn;
2509 bfd_size_type octets;
2510 bfd_vma value;
2511
2512 /* If this is a relocatable link (output_bfd test tells us), just
2513 call the generic function. Any adjustment will be done at final
2514 link time. */
2515 if (output_bfd != NULL)
2516 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2517 input_section, output_bfd, error_message);
2518
2519 /* Adjust the addend for sign extension of the low 16 bits.
2520 We won't actually be using the low 16 bits, so trashing them
2521 doesn't matter. */
2522 reloc_entry->addend += 0x8000;
2523 r_type = reloc_entry->howto->type;
2524 if (r_type != R_PPC64_REL16DX_HA)
2525 return bfd_reloc_continue;
2526
2527 value = 0;
2528 if (!bfd_is_com_section (symbol->section))
2529 value = symbol->value;
2530 value += (reloc_entry->addend
2531 + symbol->section->output_offset
2532 + symbol->section->output_section->vma);
2533 value -= (reloc_entry->address
2534 + input_section->output_offset
2535 + input_section->output_section->vma);
2536 value = (bfd_signed_vma) value >> 16;
2537
2538 octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2539 insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
2540 insn &= ~0x1fffc1;
2541 insn |= (value & 0xffc1) | ((value & 0x3e) << 15);
2542 bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
2543 if (value + 0x8000 > 0xffff)
2544 return bfd_reloc_overflow;
2545 return bfd_reloc_ok;
2546 }
2547
2548 static bfd_reloc_status_type
ppc64_elf_branch_reloc(bfd * abfd,arelent * reloc_entry,asymbol * symbol,void * data,asection * input_section,bfd * output_bfd,char ** error_message)2549 ppc64_elf_branch_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2550 void *data, asection *input_section,
2551 bfd *output_bfd, char **error_message)
2552 {
2553 if (output_bfd != NULL)
2554 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2555 input_section, output_bfd, error_message);
2556
2557 if (strcmp (symbol->section->name, ".opd") == 0
2558 && (symbol->section->owner->flags & DYNAMIC) == 0)
2559 {
2560 bfd_vma dest = opd_entry_value (symbol->section,
2561 symbol->value + reloc_entry->addend,
2562 NULL, NULL, FALSE);
2563 if (dest != (bfd_vma) -1)
2564 reloc_entry->addend = dest - (symbol->value
2565 + symbol->section->output_section->vma
2566 + symbol->section->output_offset);
2567 }
2568 else
2569 {
2570 elf_symbol_type *elfsym = (elf_symbol_type *) symbol;
2571
2572 if (symbol->section->owner != abfd
2573 && symbol->section->owner != NULL
2574 && abiversion (symbol->section->owner) >= 2)
2575 {
2576 unsigned int i;
2577
2578 for (i = 0; i < symbol->section->owner->symcount; ++i)
2579 {
2580 asymbol *symdef = symbol->section->owner->outsymbols[i];
2581
2582 if (strcmp (symdef->name, symbol->name) == 0)
2583 {
2584 elfsym = (elf_symbol_type *) symdef;
2585 break;
2586 }
2587 }
2588 }
2589 reloc_entry->addend
2590 += PPC64_LOCAL_ENTRY_OFFSET (elfsym->internal_elf_sym.st_other);
2591 }
2592 return bfd_reloc_continue;
2593 }
2594
2595 static bfd_reloc_status_type
ppc64_elf_brtaken_reloc(bfd * abfd,arelent * reloc_entry,asymbol * symbol,void * data,asection * input_section,bfd * output_bfd,char ** error_message)2596 ppc64_elf_brtaken_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2597 void *data, asection *input_section,
2598 bfd *output_bfd, char **error_message)
2599 {
2600 long insn;
2601 enum elf_ppc64_reloc_type r_type;
2602 bfd_size_type octets;
2603 /* Assume 'at' branch hints. */
2604 bfd_boolean is_isa_v2 = TRUE;
2605
2606 /* If this is a relocatable link (output_bfd test tells us), just
2607 call the generic function. Any adjustment will be done at final
2608 link time. */
2609 if (output_bfd != NULL)
2610 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2611 input_section, output_bfd, error_message);
2612
2613 octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2614 insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
2615 insn &= ~(0x01 << 21);
2616 r_type = reloc_entry->howto->type;
2617 if (r_type == R_PPC64_ADDR14_BRTAKEN
2618 || r_type == R_PPC64_REL14_BRTAKEN)
2619 insn |= 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field. */
2620
2621 if (is_isa_v2)
2622 {
2623 /* Set 'a' bit. This is 0b00010 in BO field for branch
2624 on CR(BI) insns (BO == 001at or 011at), and 0b01000
2625 for branch on CTR insns (BO == 1a00t or 1a01t). */
2626 if ((insn & (0x14 << 21)) == (0x04 << 21))
2627 insn |= 0x02 << 21;
2628 else if ((insn & (0x14 << 21)) == (0x10 << 21))
2629 insn |= 0x08 << 21;
2630 else
2631 goto out;
2632 }
2633 else
2634 {
2635 bfd_vma target = 0;
2636 bfd_vma from;
2637
2638 if (!bfd_is_com_section (symbol->section))
2639 target = symbol->value;
2640 target += symbol->section->output_section->vma;
2641 target += symbol->section->output_offset;
2642 target += reloc_entry->addend;
2643
2644 from = (reloc_entry->address
2645 + input_section->output_offset
2646 + input_section->output_section->vma);
2647
2648 /* Invert 'y' bit if not the default. */
2649 if ((bfd_signed_vma) (target - from) < 0)
2650 insn ^= 0x01 << 21;
2651 }
2652 bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
2653 out:
2654 return ppc64_elf_branch_reloc (abfd, reloc_entry, symbol, data,
2655 input_section, output_bfd, error_message);
2656 }
2657
2658 static bfd_reloc_status_type
ppc64_elf_sectoff_reloc(bfd * abfd,arelent * reloc_entry,asymbol * symbol,void * data,asection * input_section,bfd * output_bfd,char ** error_message)2659 ppc64_elf_sectoff_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2660 void *data, asection *input_section,
2661 bfd *output_bfd, char **error_message)
2662 {
2663 /* If this is a relocatable link (output_bfd test tells us), just
2664 call the generic function. Any adjustment will be done at final
2665 link time. */
2666 if (output_bfd != NULL)
2667 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2668 input_section, output_bfd, error_message);
2669
2670 /* Subtract the symbol section base address. */
2671 reloc_entry->addend -= symbol->section->output_section->vma;
2672 return bfd_reloc_continue;
2673 }
2674
2675 static bfd_reloc_status_type
ppc64_elf_sectoff_ha_reloc(bfd * abfd,arelent * reloc_entry,asymbol * symbol,void * data,asection * input_section,bfd * output_bfd,char ** error_message)2676 ppc64_elf_sectoff_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2677 void *data, asection *input_section,
2678 bfd *output_bfd, char **error_message)
2679 {
2680 /* If this is a relocatable link (output_bfd test tells us), just
2681 call the generic function. Any adjustment will be done at final
2682 link time. */
2683 if (output_bfd != NULL)
2684 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2685 input_section, output_bfd, error_message);
2686
2687 /* Subtract the symbol section base address. */
2688 reloc_entry->addend -= symbol->section->output_section->vma;
2689
2690 /* Adjust the addend for sign extension of the low 16 bits. */
2691 reloc_entry->addend += 0x8000;
2692 return bfd_reloc_continue;
2693 }
2694
2695 static bfd_reloc_status_type
ppc64_elf_toc_reloc(bfd * abfd,arelent * reloc_entry,asymbol * symbol,void * data,asection * input_section,bfd * output_bfd,char ** error_message)2696 ppc64_elf_toc_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2697 void *data, asection *input_section,
2698 bfd *output_bfd, char **error_message)
2699 {
2700 bfd_vma TOCstart;
2701
2702 /* If this is a relocatable link (output_bfd test tells us), just
2703 call the generic function. Any adjustment will be done at final
2704 link time. */
2705 if (output_bfd != NULL)
2706 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2707 input_section, output_bfd, error_message);
2708
2709 TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2710 if (TOCstart == 0)
2711 TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2712
2713 /* Subtract the TOC base address. */
2714 reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2715 return bfd_reloc_continue;
2716 }
2717
2718 static bfd_reloc_status_type
ppc64_elf_toc_ha_reloc(bfd * abfd,arelent * reloc_entry,asymbol * symbol,void * data,asection * input_section,bfd * output_bfd,char ** error_message)2719 ppc64_elf_toc_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2720 void *data, asection *input_section,
2721 bfd *output_bfd, char **error_message)
2722 {
2723 bfd_vma TOCstart;
2724
2725 /* If this is a relocatable link (output_bfd test tells us), just
2726 call the generic function. Any adjustment will be done at final
2727 link time. */
2728 if (output_bfd != NULL)
2729 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2730 input_section, output_bfd, error_message);
2731
2732 TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2733 if (TOCstart == 0)
2734 TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2735
2736 /* Subtract the TOC base address. */
2737 reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2738
2739 /* Adjust the addend for sign extension of the low 16 bits. */
2740 reloc_entry->addend += 0x8000;
2741 return bfd_reloc_continue;
2742 }
2743
2744 static bfd_reloc_status_type
ppc64_elf_toc64_reloc(bfd * abfd,arelent * reloc_entry,asymbol * symbol,void * data,asection * input_section,bfd * output_bfd,char ** error_message)2745 ppc64_elf_toc64_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2746 void *data, asection *input_section,
2747 bfd *output_bfd, char **error_message)
2748 {
2749 bfd_vma TOCstart;
2750 bfd_size_type octets;
2751
2752 /* If this is a relocatable link (output_bfd test tells us), just
2753 call the generic function. Any adjustment will be done at final
2754 link time. */
2755 if (output_bfd != NULL)
2756 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2757 input_section, output_bfd, error_message);
2758
2759 TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2760 if (TOCstart == 0)
2761 TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2762
2763 octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2764 bfd_put_64 (abfd, TOCstart + TOC_BASE_OFF, (bfd_byte *) data + octets);
2765 return bfd_reloc_ok;
2766 }
2767
2768 static bfd_reloc_status_type
ppc64_elf_unhandled_reloc(bfd * abfd,arelent * reloc_entry,asymbol * symbol,void * data,asection * input_section,bfd * output_bfd,char ** error_message)2769 ppc64_elf_unhandled_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2770 void *data, asection *input_section,
2771 bfd *output_bfd, char **error_message)
2772 {
2773 /* If this is a relocatable link (output_bfd test tells us), just
2774 call the generic function. Any adjustment will be done at final
2775 link time. */
2776 if (output_bfd != NULL)
2777 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2778 input_section, output_bfd, error_message);
2779
2780 if (error_message != NULL)
2781 {
2782 static char buf[60];
2783 sprintf (buf, "generic linker can't handle %s",
2784 reloc_entry->howto->name);
2785 *error_message = buf;
2786 }
2787 return bfd_reloc_dangerous;
2788 }
2789
2790 /* Track GOT entries needed for a given symbol. We might need more
2791 than one got entry per symbol. */
2792 struct got_entry
2793 {
2794 struct got_entry *next;
2795
2796 /* The symbol addend that we'll be placing in the GOT. */
2797 bfd_vma addend;
2798
2799 /* Unlike other ELF targets, we use separate GOT entries for the same
2800 symbol referenced from different input files. This is to support
2801 automatic multiple TOC/GOT sections, where the TOC base can vary
2802 from one input file to another. After partitioning into TOC groups
2803 we merge entries within the group.
2804
2805 Point to the BFD owning this GOT entry. */
2806 bfd *owner;
2807
2808 /* Zero for non-tls entries, or TLS_TLS and one of TLS_GD, TLS_LD,
2809 TLS_TPREL or TLS_DTPREL for tls entries. */
2810 unsigned char tls_type;
2811
2812 /* Non-zero if got.ent points to real entry. */
2813 unsigned char is_indirect;
2814
2815 /* Reference count until size_dynamic_sections, GOT offset thereafter. */
2816 union
2817 {
2818 bfd_signed_vma refcount;
2819 bfd_vma offset;
2820 struct got_entry *ent;
2821 } got;
2822 };
2823
2824 /* The same for PLT. */
2825 struct plt_entry
2826 {
2827 struct plt_entry *next;
2828
2829 bfd_vma addend;
2830
2831 union
2832 {
2833 bfd_signed_vma refcount;
2834 bfd_vma offset;
2835 } plt;
2836 };
2837
2838 struct ppc64_elf_obj_tdata
2839 {
2840 struct elf_obj_tdata elf;
2841
2842 /* Shortcuts to dynamic linker sections. */
2843 asection *got;
2844 asection *relgot;
2845
2846 /* Used during garbage collection. We attach global symbols defined
2847 on removed .opd entries to this section so that the sym is removed. */
2848 asection *deleted_section;
2849
2850 /* TLS local dynamic got entry handling. Support for multiple GOT
2851 sections means we potentially need one of these for each input bfd. */
2852 struct got_entry tlsld_got;
2853
2854 union {
2855 /* A copy of relocs before they are modified for --emit-relocs. */
2856 Elf_Internal_Rela *relocs;
2857
2858 /* Section contents. */
2859 bfd_byte *contents;
2860 } opd;
2861
2862 /* Nonzero if this bfd has small toc/got relocs, ie. that expect
2863 the reloc to be in the range -32768 to 32767. */
2864 unsigned int has_small_toc_reloc : 1;
2865
2866 /* Set if toc/got ha relocs detected not using r2, or lo reloc
2867 instruction not one we handle. */
2868 unsigned int unexpected_toc_insn : 1;
2869 };
2870
2871 #define ppc64_elf_tdata(bfd) \
2872 ((struct ppc64_elf_obj_tdata *) (bfd)->tdata.any)
2873
2874 #define ppc64_tlsld_got(bfd) \
2875 (&ppc64_elf_tdata (bfd)->tlsld_got)
2876
2877 #define is_ppc64_elf(bfd) \
2878 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
2879 && elf_object_id (bfd) == PPC64_ELF_DATA)
2880
2881 /* Override the generic function because we store some extras. */
2882
2883 static bfd_boolean
ppc64_elf_mkobject(bfd * abfd)2884 ppc64_elf_mkobject (bfd *abfd)
2885 {
2886 return bfd_elf_allocate_object (abfd, sizeof (struct ppc64_elf_obj_tdata),
2887 PPC64_ELF_DATA);
2888 }
2889
2890 /* Fix bad default arch selected for a 64 bit input bfd when the
2891 default is 32 bit. Also select arch based on apuinfo. */
2892
2893 static bfd_boolean
ppc64_elf_object_p(bfd * abfd)2894 ppc64_elf_object_p (bfd *abfd)
2895 {
2896 if (!abfd->arch_info->the_default)
2897 return TRUE;
2898
2899 if (abfd->arch_info->bits_per_word == 32)
2900 {
2901 Elf_Internal_Ehdr *i_ehdr = elf_elfheader (abfd);
2902
2903 if (i_ehdr->e_ident[EI_CLASS] == ELFCLASS64)
2904 {
2905 /* Relies on arch after 32 bit default being 64 bit default. */
2906 abfd->arch_info = abfd->arch_info->next;
2907 BFD_ASSERT (abfd->arch_info->bits_per_word == 64);
2908 }
2909 }
2910 return _bfd_elf_ppc_set_arch (abfd);
2911 }
2912
2913 /* Support for core dump NOTE sections. */
2914
2915 static bfd_boolean
ppc64_elf_grok_prstatus(bfd * abfd,Elf_Internal_Note * note)2916 ppc64_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
2917 {
2918 size_t offset, size;
2919
2920 if (note->descsz != 504)
2921 return FALSE;
2922
2923 /* pr_cursig */
2924 elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
2925
2926 /* pr_pid */
2927 elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 32);
2928
2929 /* pr_reg */
2930 offset = 112;
2931 size = 384;
2932
2933 /* Make a ".reg/999" section. */
2934 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
2935 size, note->descpos + offset);
2936 }
2937
2938 static bfd_boolean
ppc64_elf_grok_psinfo(bfd * abfd,Elf_Internal_Note * note)2939 ppc64_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
2940 {
2941 if (note->descsz != 136)
2942 return FALSE;
2943
2944 elf_tdata (abfd)->core->pid
2945 = bfd_get_32 (abfd, note->descdata + 24);
2946 elf_tdata (abfd)->core->program
2947 = _bfd_elfcore_strndup (abfd, note->descdata + 40, 16);
2948 elf_tdata (abfd)->core->command
2949 = _bfd_elfcore_strndup (abfd, note->descdata + 56, 80);
2950
2951 return TRUE;
2952 }
2953
2954 static char *
ppc64_elf_write_core_note(bfd * abfd,char * buf,int * bufsiz,int note_type,...)2955 ppc64_elf_write_core_note (bfd *abfd, char *buf, int *bufsiz, int note_type,
2956 ...)
2957 {
2958 switch (note_type)
2959 {
2960 default:
2961 return NULL;
2962
2963 case NT_PRPSINFO:
2964 {
2965 char data[136];
2966 va_list ap;
2967
2968 va_start (ap, note_type);
2969 memset (data, 0, sizeof (data));
2970 strncpy (data + 40, va_arg (ap, const char *), 16);
2971 strncpy (data + 56, va_arg (ap, const char *), 80);
2972 va_end (ap);
2973 return elfcore_write_note (abfd, buf, bufsiz,
2974 "CORE", note_type, data, sizeof (data));
2975 }
2976
2977 case NT_PRSTATUS:
2978 {
2979 char data[504];
2980 va_list ap;
2981 long pid;
2982 int cursig;
2983 const void *greg;
2984
2985 va_start (ap, note_type);
2986 memset (data, 0, 112);
2987 pid = va_arg (ap, long);
2988 bfd_put_32 (abfd, pid, data + 32);
2989 cursig = va_arg (ap, int);
2990 bfd_put_16 (abfd, cursig, data + 12);
2991 greg = va_arg (ap, const void *);
2992 memcpy (data + 112, greg, 384);
2993 memset (data + 496, 0, 8);
2994 va_end (ap);
2995 return elfcore_write_note (abfd, buf, bufsiz,
2996 "CORE", note_type, data, sizeof (data));
2997 }
2998 }
2999 }
3000
3001 /* Add extra PPC sections. */
3002
3003 static const struct bfd_elf_special_section ppc64_elf_special_sections[]=
3004 {
3005 { STRING_COMMA_LEN (".plt"), 0, SHT_NOBITS, 0 },
3006 { STRING_COMMA_LEN (".sbss"), -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE },
3007 { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
3008 { STRING_COMMA_LEN (".toc"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
3009 { STRING_COMMA_LEN (".toc1"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
3010 { STRING_COMMA_LEN (".tocbss"), 0, SHT_NOBITS, SHF_ALLOC + SHF_WRITE },
3011 { NULL, 0, 0, 0, 0 }
3012 };
3013
3014 enum _ppc64_sec_type {
3015 sec_normal = 0,
3016 sec_opd = 1,
3017 sec_toc = 2
3018 };
3019
3020 struct _ppc64_elf_section_data
3021 {
3022 struct bfd_elf_section_data elf;
3023
3024 union
3025 {
3026 /* An array with one entry for each opd function descriptor,
3027 and some spares since opd entries may be either 16 or 24 bytes. */
3028 #define OPD_NDX(OFF) ((OFF) >> 4)
3029 struct _opd_sec_data
3030 {
3031 /* Points to the function code section for local opd entries. */
3032 asection **func_sec;
3033
3034 /* After editing .opd, adjust references to opd local syms. */
3035 long *adjust;
3036 } opd;
3037
3038 /* An array for toc sections, indexed by offset/8. */
3039 struct _toc_sec_data
3040 {
3041 /* Specifies the relocation symbol index used at a given toc offset. */
3042 unsigned *symndx;
3043
3044 /* And the relocation addend. */
3045 bfd_vma *add;
3046 } toc;
3047 } u;
3048
3049 enum _ppc64_sec_type sec_type:2;
3050
3051 /* Flag set when small branches are detected. Used to
3052 select suitable defaults for the stub group size. */
3053 unsigned int has_14bit_branch:1;
3054 };
3055
3056 #define ppc64_elf_section_data(sec) \
3057 ((struct _ppc64_elf_section_data *) elf_section_data (sec))
3058
3059 static bfd_boolean
ppc64_elf_new_section_hook(bfd * abfd,asection * sec)3060 ppc64_elf_new_section_hook (bfd *abfd, asection *sec)
3061 {
3062 if (!sec->used_by_bfd)
3063 {
3064 struct _ppc64_elf_section_data *sdata;
3065 bfd_size_type amt = sizeof (*sdata);
3066
3067 sdata = bfd_zalloc (abfd, amt);
3068 if (sdata == NULL)
3069 return FALSE;
3070 sec->used_by_bfd = sdata;
3071 }
3072
3073 return _bfd_elf_new_section_hook (abfd, sec);
3074 }
3075
3076 static struct _opd_sec_data *
get_opd_info(asection * sec)3077 get_opd_info (asection * sec)
3078 {
3079 if (sec != NULL
3080 && ppc64_elf_section_data (sec) != NULL
3081 && ppc64_elf_section_data (sec)->sec_type == sec_opd)
3082 return &ppc64_elf_section_data (sec)->u.opd;
3083 return NULL;
3084 }
3085
3086 /* Parameters for the qsort hook. */
3087 static bfd_boolean synthetic_relocatable;
3088 static asection *synthetic_opd;
3089
3090 /* qsort comparison function for ppc64_elf_get_synthetic_symtab. */
3091
3092 static int
compare_symbols(const void * ap,const void * bp)3093 compare_symbols (const void *ap, const void *bp)
3094 {
3095 const asymbol *a = * (const asymbol **) ap;
3096 const asymbol *b = * (const asymbol **) bp;
3097
3098 /* Section symbols first. */
3099 if ((a->flags & BSF_SECTION_SYM) && !(b->flags & BSF_SECTION_SYM))
3100 return -1;
3101 if (!(a->flags & BSF_SECTION_SYM) && (b->flags & BSF_SECTION_SYM))
3102 return 1;
3103
3104 /* then .opd symbols. */
3105 if (synthetic_opd != NULL)
3106 {
3107 if (strcmp (a->section->name, ".opd") == 0
3108 && strcmp (b->section->name, ".opd") != 0)
3109 return -1;
3110 if (strcmp (a->section->name, ".opd") != 0
3111 && strcmp (b->section->name, ".opd") == 0)
3112 return 1;
3113 }
3114
3115 /* then other code symbols. */
3116 if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3117 == (SEC_CODE | SEC_ALLOC)
3118 && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3119 != (SEC_CODE | SEC_ALLOC))
3120 return -1;
3121
3122 if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3123 != (SEC_CODE | SEC_ALLOC)
3124 && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3125 == (SEC_CODE | SEC_ALLOC))
3126 return 1;
3127
3128 if (synthetic_relocatable)
3129 {
3130 if (a->section->id < b->section->id)
3131 return -1;
3132
3133 if (a->section->id > b->section->id)
3134 return 1;
3135 }
3136
3137 if (a->value + a->section->vma < b->value + b->section->vma)
3138 return -1;
3139
3140 if (a->value + a->section->vma > b->value + b->section->vma)
3141 return 1;
3142
3143 /* For syms with the same value, prefer strong dynamic global function
3144 syms over other syms. */
3145 if ((a->flags & BSF_GLOBAL) != 0 && (b->flags & BSF_GLOBAL) == 0)
3146 return -1;
3147
3148 if ((a->flags & BSF_GLOBAL) == 0 && (b->flags & BSF_GLOBAL) != 0)
3149 return 1;
3150
3151 if ((a->flags & BSF_FUNCTION) != 0 && (b->flags & BSF_FUNCTION) == 0)
3152 return -1;
3153
3154 if ((a->flags & BSF_FUNCTION) == 0 && (b->flags & BSF_FUNCTION) != 0)
3155 return 1;
3156
3157 if ((a->flags & BSF_WEAK) == 0 && (b->flags & BSF_WEAK) != 0)
3158 return -1;
3159
3160 if ((a->flags & BSF_WEAK) != 0 && (b->flags & BSF_WEAK) == 0)
3161 return 1;
3162
3163 if ((a->flags & BSF_DYNAMIC) != 0 && (b->flags & BSF_DYNAMIC) == 0)
3164 return -1;
3165
3166 if ((a->flags & BSF_DYNAMIC) == 0 && (b->flags & BSF_DYNAMIC) != 0)
3167 return 1;
3168
3169 return 0;
3170 }
3171
3172 /* Search SYMS for a symbol of the given VALUE. */
3173
3174 static asymbol *
sym_exists_at(asymbol ** syms,long lo,long hi,unsigned int id,bfd_vma value)3175 sym_exists_at (asymbol **syms, long lo, long hi, unsigned int id, bfd_vma value)
3176 {
3177 long mid;
3178
3179 if (id == (unsigned) -1)
3180 {
3181 while (lo < hi)
3182 {
3183 mid = (lo + hi) >> 1;
3184 if (syms[mid]->value + syms[mid]->section->vma < value)
3185 lo = mid + 1;
3186 else if (syms[mid]->value + syms[mid]->section->vma > value)
3187 hi = mid;
3188 else
3189 return syms[mid];
3190 }
3191 }
3192 else
3193 {
3194 while (lo < hi)
3195 {
3196 mid = (lo + hi) >> 1;
3197 if (syms[mid]->section->id < id)
3198 lo = mid + 1;
3199 else if (syms[mid]->section->id > id)
3200 hi = mid;
3201 else if (syms[mid]->value < value)
3202 lo = mid + 1;
3203 else if (syms[mid]->value > value)
3204 hi = mid;
3205 else
3206 return syms[mid];
3207 }
3208 }
3209 return NULL;
3210 }
3211
3212 static bfd_boolean
section_covers_vma(bfd * abfd ATTRIBUTE_UNUSED,asection * section,void * ptr)3213 section_covers_vma (bfd *abfd ATTRIBUTE_UNUSED, asection *section, void *ptr)
3214 {
3215 bfd_vma vma = *(bfd_vma *) ptr;
3216 return ((section->flags & SEC_ALLOC) != 0
3217 && section->vma <= vma
3218 && vma < section->vma + section->size);
3219 }
3220
3221 /* Create synthetic symbols, effectively restoring "dot-symbol" function
3222 entry syms. Also generate @plt symbols for the glink branch table.
3223 Returns count of synthetic symbols in RET or -1 on error. */
3224
3225 static long
ppc64_elf_get_synthetic_symtab(bfd * abfd,long static_count,asymbol ** static_syms,long dyn_count,asymbol ** dyn_syms,asymbol ** ret)3226 ppc64_elf_get_synthetic_symtab (bfd *abfd,
3227 long static_count, asymbol **static_syms,
3228 long dyn_count, asymbol **dyn_syms,
3229 asymbol **ret)
3230 {
3231 asymbol *s;
3232 long i;
3233 long count;
3234 char *names;
3235 long symcount, codesecsym, codesecsymend, secsymend, opdsymend;
3236 asection *opd = NULL;
3237 bfd_boolean relocatable = (abfd->flags & (EXEC_P | DYNAMIC)) == 0;
3238 asymbol **syms;
3239 int abi = abiversion (abfd);
3240
3241 *ret = NULL;
3242
3243 if (abi < 2)
3244 {
3245 opd = bfd_get_section_by_name (abfd, ".opd");
3246 if (opd == NULL && abi == 1)
3247 return 0;
3248 }
3249
3250 symcount = static_count;
3251 if (!relocatable)
3252 symcount += dyn_count;
3253 if (symcount == 0)
3254 return 0;
3255
3256 syms = bfd_malloc ((symcount + 1) * sizeof (*syms));
3257 if (syms == NULL)
3258 return -1;
3259
3260 if (!relocatable && static_count != 0 && dyn_count != 0)
3261 {
3262 /* Use both symbol tables. */
3263 memcpy (syms, static_syms, static_count * sizeof (*syms));
3264 memcpy (syms + static_count, dyn_syms, (dyn_count + 1) * sizeof (*syms));
3265 }
3266 else if (!relocatable && static_count == 0)
3267 memcpy (syms, dyn_syms, (symcount + 1) * sizeof (*syms));
3268 else
3269 memcpy (syms, static_syms, (symcount + 1) * sizeof (*syms));
3270
3271 synthetic_relocatable = relocatable;
3272 synthetic_opd = opd;
3273 qsort (syms, symcount, sizeof (*syms), compare_symbols);
3274
3275 if (!relocatable && symcount > 1)
3276 {
3277 long j;
3278 /* Trim duplicate syms, since we may have merged the normal and
3279 dynamic symbols. Actually, we only care about syms that have
3280 different values, so trim any with the same value. */
3281 for (i = 1, j = 1; i < symcount; ++i)
3282 if (syms[i - 1]->value + syms[i - 1]->section->vma
3283 != syms[i]->value + syms[i]->section->vma)
3284 syms[j++] = syms[i];
3285 symcount = j;
3286 }
3287
3288 i = 0;
3289 /* Note that here and in compare_symbols we can't compare opd and
3290 sym->section directly. With separate debug info files, the
3291 symbols will be extracted from the debug file while abfd passed
3292 to this function is the real binary. */
3293 if (opd != NULL && strcmp (syms[i]->section->name, ".opd") == 0)
3294 ++i;
3295 codesecsym = i;
3296
3297 for (; i < symcount; ++i)
3298 if (((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3299 != (SEC_CODE | SEC_ALLOC))
3300 || (syms[i]->flags & BSF_SECTION_SYM) == 0)
3301 break;
3302 codesecsymend = i;
3303
3304 for (; i < symcount; ++i)
3305 if ((syms[i]->flags & BSF_SECTION_SYM) == 0)
3306 break;
3307 secsymend = i;
3308
3309 if (opd != NULL)
3310 for (; i < symcount; ++i)
3311 if (strcmp (syms[i]->section->name, ".opd") != 0)
3312 break;
3313 opdsymend = i;
3314
3315 for (; i < symcount; ++i)
3316 if ((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3317 != (SEC_CODE | SEC_ALLOC))
3318 break;
3319 symcount = i;
3320
3321 count = 0;
3322
3323 if (relocatable)
3324 {
3325 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3326 arelent *r;
3327 size_t size;
3328 long relcount;
3329
3330 if (opdsymend == secsymend)
3331 goto done;
3332
3333 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3334 relcount = (opd->flags & SEC_RELOC) ? opd->reloc_count : 0;
3335 if (relcount == 0)
3336 goto done;
3337
3338 if (!(*slurp_relocs) (abfd, opd, static_syms, FALSE))
3339 {
3340 count = -1;
3341 goto done;
3342 }
3343
3344 size = 0;
3345 for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3346 {
3347 asymbol *sym;
3348
3349 while (r < opd->relocation + relcount
3350 && r->address < syms[i]->value + opd->vma)
3351 ++r;
3352
3353 if (r == opd->relocation + relcount)
3354 break;
3355
3356 if (r->address != syms[i]->value + opd->vma)
3357 continue;
3358
3359 if (r->howto->type != R_PPC64_ADDR64)
3360 continue;
3361
3362 sym = *r->sym_ptr_ptr;
3363 if (!sym_exists_at (syms, opdsymend, symcount,
3364 sym->section->id, sym->value + r->addend))
3365 {
3366 ++count;
3367 size += sizeof (asymbol);
3368 size += strlen (syms[i]->name) + 2;
3369 }
3370 }
3371
3372 if (size == 0)
3373 goto done;
3374 s = *ret = bfd_malloc (size);
3375 if (s == NULL)
3376 {
3377 count = -1;
3378 goto done;
3379 }
3380
3381 names = (char *) (s + count);
3382
3383 for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3384 {
3385 asymbol *sym;
3386
3387 while (r < opd->relocation + relcount
3388 && r->address < syms[i]->value + opd->vma)
3389 ++r;
3390
3391 if (r == opd->relocation + relcount)
3392 break;
3393
3394 if (r->address != syms[i]->value + opd->vma)
3395 continue;
3396
3397 if (r->howto->type != R_PPC64_ADDR64)
3398 continue;
3399
3400 sym = *r->sym_ptr_ptr;
3401 if (!sym_exists_at (syms, opdsymend, symcount,
3402 sym->section->id, sym->value + r->addend))
3403 {
3404 size_t len;
3405
3406 *s = *syms[i];
3407 s->flags |= BSF_SYNTHETIC;
3408 s->section = sym->section;
3409 s->value = sym->value + r->addend;
3410 s->name = names;
3411 *names++ = '.';
3412 len = strlen (syms[i]->name);
3413 memcpy (names, syms[i]->name, len + 1);
3414 names += len + 1;
3415 /* Have udata.p point back to the original symbol this
3416 synthetic symbol was derived from. */
3417 s->udata.p = syms[i];
3418 s++;
3419 }
3420 }
3421 }
3422 else
3423 {
3424 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3425 bfd_byte *contents = NULL;
3426 size_t size;
3427 long plt_count = 0;
3428 bfd_vma glink_vma = 0, resolv_vma = 0;
3429 asection *dynamic, *glink = NULL, *relplt = NULL;
3430 arelent *p;
3431
3432 if (opd != NULL && !bfd_malloc_and_get_section (abfd, opd, &contents))
3433 {
3434 free_contents_and_exit_err:
3435 count = -1;
3436 free_contents_and_exit:
3437 if (contents)
3438 free (contents);
3439 goto done;
3440 }
3441
3442 size = 0;
3443 for (i = secsymend; i < opdsymend; ++i)
3444 {
3445 bfd_vma ent;
3446
3447 /* Ignore bogus symbols. */
3448 if (syms[i]->value > opd->size - 8)
3449 continue;
3450
3451 ent = bfd_get_64 (abfd, contents + syms[i]->value);
3452 if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3453 {
3454 ++count;
3455 size += sizeof (asymbol);
3456 size += strlen (syms[i]->name) + 2;
3457 }
3458 }
3459
3460 /* Get start of .glink stubs from DT_PPC64_GLINK. */
3461 if (dyn_count != 0
3462 && (dynamic = bfd_get_section_by_name (abfd, ".dynamic")) != NULL)
3463 {
3464 bfd_byte *dynbuf, *extdyn, *extdynend;
3465 size_t extdynsize;
3466 void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *);
3467
3468 if (!bfd_malloc_and_get_section (abfd, dynamic, &dynbuf))
3469 goto free_contents_and_exit_err;
3470
3471 extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
3472 swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
3473
3474 extdyn = dynbuf;
3475 extdynend = extdyn + dynamic->size;
3476 for (; extdyn < extdynend; extdyn += extdynsize)
3477 {
3478 Elf_Internal_Dyn dyn;
3479 (*swap_dyn_in) (abfd, extdyn, &dyn);
3480
3481 if (dyn.d_tag == DT_NULL)
3482 break;
3483
3484 if (dyn.d_tag == DT_PPC64_GLINK)
3485 {
3486 /* The first glink stub starts at offset 32; see
3487 comment in ppc64_elf_finish_dynamic_sections. */
3488 glink_vma = dyn.d_un.d_val + GLINK_CALL_STUB_SIZE - 8 * 4;
3489 /* The .glink section usually does not survive the final
3490 link; search for the section (usually .text) where the
3491 glink stubs now reside. */
3492 glink = bfd_sections_find_if (abfd, section_covers_vma,
3493 &glink_vma);
3494 break;
3495 }
3496 }
3497
3498 free (dynbuf);
3499 }
3500
3501 if (glink != NULL)
3502 {
3503 /* Determine __glink trampoline by reading the relative branch
3504 from the first glink stub. */
3505 bfd_byte buf[4];
3506 unsigned int off = 0;
3507
3508 while (bfd_get_section_contents (abfd, glink, buf,
3509 glink_vma + off - glink->vma, 4))
3510 {
3511 unsigned int insn = bfd_get_32 (abfd, buf);
3512 insn ^= B_DOT;
3513 if ((insn & ~0x3fffffc) == 0)
3514 {
3515 resolv_vma = glink_vma + off + (insn ^ 0x2000000) - 0x2000000;
3516 break;
3517 }
3518 off += 4;
3519 if (off > 4)
3520 break;
3521 }
3522
3523 if (resolv_vma)
3524 size += sizeof (asymbol) + sizeof ("__glink_PLTresolve");
3525
3526 relplt = bfd_get_section_by_name (abfd, ".rela.plt");
3527 if (relplt != NULL)
3528 {
3529 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3530 if (! (*slurp_relocs) (abfd, relplt, dyn_syms, TRUE))
3531 goto free_contents_and_exit_err;
3532
3533 plt_count = relplt->size / sizeof (Elf64_External_Rela);
3534 size += plt_count * sizeof (asymbol);
3535
3536 p = relplt->relocation;
3537 for (i = 0; i < plt_count; i++, p++)
3538 {
3539 size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
3540 if (p->addend != 0)
3541 size += sizeof ("+0x") - 1 + 16;
3542 }
3543 }
3544 }
3545
3546 if (size == 0)
3547 goto free_contents_and_exit;
3548 s = *ret = bfd_malloc (size);
3549 if (s == NULL)
3550 goto free_contents_and_exit_err;
3551
3552 names = (char *) (s + count + plt_count + (resolv_vma != 0));
3553
3554 for (i = secsymend; i < opdsymend; ++i)
3555 {
3556 bfd_vma ent;
3557
3558 if (syms[i]->value > opd->size - 8)
3559 continue;
3560
3561 ent = bfd_get_64 (abfd, contents + syms[i]->value);
3562 if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3563 {
3564 long lo, hi;
3565 size_t len;
3566 asection *sec = abfd->sections;
3567
3568 *s = *syms[i];
3569 lo = codesecsym;
3570 hi = codesecsymend;
3571 while (lo < hi)
3572 {
3573 long mid = (lo + hi) >> 1;
3574 if (syms[mid]->section->vma < ent)
3575 lo = mid + 1;
3576 else if (syms[mid]->section->vma > ent)
3577 hi = mid;
3578 else
3579 {
3580 sec = syms[mid]->section;
3581 break;
3582 }
3583 }
3584
3585 if (lo >= hi && lo > codesecsym)
3586 sec = syms[lo - 1]->section;
3587
3588 for (; sec != NULL; sec = sec->next)
3589 {
3590 if (sec->vma > ent)
3591 break;
3592 /* SEC_LOAD may not be set if SEC is from a separate debug
3593 info file. */
3594 if ((sec->flags & SEC_ALLOC) == 0)
3595 break;
3596 if ((sec->flags & SEC_CODE) != 0)
3597 s->section = sec;
3598 }
3599 s->flags |= BSF_SYNTHETIC;
3600 s->value = ent - s->section->vma;
3601 s->name = names;
3602 *names++ = '.';
3603 len = strlen (syms[i]->name);
3604 memcpy (names, syms[i]->name, len + 1);
3605 names += len + 1;
3606 /* Have udata.p point back to the original symbol this
3607 synthetic symbol was derived from. */
3608 s->udata.p = syms[i];
3609 s++;
3610 }
3611 }
3612 free (contents);
3613
3614 if (glink != NULL && relplt != NULL)
3615 {
3616 if (resolv_vma)
3617 {
3618 /* Add a symbol for the main glink trampoline. */
3619 memset (s, 0, sizeof *s);
3620 s->the_bfd = abfd;
3621 s->flags = BSF_GLOBAL | BSF_SYNTHETIC;
3622 s->section = glink;
3623 s->value = resolv_vma - glink->vma;
3624 s->name = names;
3625 memcpy (names, "__glink_PLTresolve", sizeof ("__glink_PLTresolve"));
3626 names += sizeof ("__glink_PLTresolve");
3627 s++;
3628 count++;
3629 }
3630
3631 /* FIXME: It would be very much nicer to put sym@plt on the
3632 stub rather than on the glink branch table entry. The
3633 objdump disassembler would then use a sensible symbol
3634 name on plt calls. The difficulty in doing so is
3635 a) finding the stubs, and,
3636 b) matching stubs against plt entries, and,
3637 c) there can be multiple stubs for a given plt entry.
3638
3639 Solving (a) could be done by code scanning, but older
3640 ppc64 binaries used different stubs to current code.
3641 (b) is the tricky one since you need to known the toc
3642 pointer for at least one function that uses a pic stub to
3643 be able to calculate the plt address referenced.
3644 (c) means gdb would need to set multiple breakpoints (or
3645 find the glink branch itself) when setting breakpoints
3646 for pending shared library loads. */
3647 p = relplt->relocation;
3648 for (i = 0; i < plt_count; i++, p++)
3649 {
3650 size_t len;
3651
3652 *s = **p->sym_ptr_ptr;
3653 /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set. Since
3654 we are defining a symbol, ensure one of them is set. */
3655 if ((s->flags & BSF_LOCAL) == 0)
3656 s->flags |= BSF_GLOBAL;
3657 s->flags |= BSF_SYNTHETIC;
3658 s->section = glink;
3659 s->value = glink_vma - glink->vma;
3660 s->name = names;
3661 s->udata.p = NULL;
3662 len = strlen ((*p->sym_ptr_ptr)->name);
3663 memcpy (names, (*p->sym_ptr_ptr)->name, len);
3664 names += len;
3665 if (p->addend != 0)
3666 {
3667 memcpy (names, "+0x", sizeof ("+0x") - 1);
3668 names += sizeof ("+0x") - 1;
3669 bfd_sprintf_vma (abfd, names, p->addend);
3670 names += strlen (names);
3671 }
3672 memcpy (names, "@plt", sizeof ("@plt"));
3673 names += sizeof ("@plt");
3674 s++;
3675 if (abi < 2)
3676 {
3677 glink_vma += 8;
3678 if (i >= 0x8000)
3679 glink_vma += 4;
3680 }
3681 else
3682 glink_vma += 4;
3683 }
3684 count += plt_count;
3685 }
3686 }
3687
3688 done:
3689 free (syms);
3690 return count;
3691 }
3692
3693 /* The following functions are specific to the ELF linker, while
3694 functions above are used generally. Those named ppc64_elf_* are
3695 called by the main ELF linker code. They appear in this file more
3696 or less in the order in which they are called. eg.
3697 ppc64_elf_check_relocs is called early in the link process,
3698 ppc64_elf_finish_dynamic_sections is one of the last functions
3699 called.
3700
3701 PowerPC64-ELF uses a similar scheme to PowerPC64-XCOFF in that
3702 functions have both a function code symbol and a function descriptor
3703 symbol. A call to foo in a relocatable object file looks like:
3704
3705 . .text
3706 . x:
3707 . bl .foo
3708 . nop
3709
3710 The function definition in another object file might be:
3711
3712 . .section .opd
3713 . foo: .quad .foo
3714 . .quad .TOC.@tocbase
3715 . .quad 0
3716 .
3717 . .text
3718 . .foo: blr
3719
3720 When the linker resolves the call during a static link, the branch
3721 unsurprisingly just goes to .foo and the .opd information is unused.
3722 If the function definition is in a shared library, things are a little
3723 different: The call goes via a plt call stub, the opd information gets
3724 copied to the plt, and the linker patches the nop.
3725
3726 . x:
3727 . bl .foo_stub
3728 . ld 2,40(1)
3729 .
3730 .
3731 . .foo_stub:
3732 . std 2,40(1) # in practice, the call stub
3733 . addis 11,2,Lfoo@toc@ha # is slightly optimized, but
3734 . addi 11,11,Lfoo@toc@l # this is the general idea
3735 . ld 12,0(11)
3736 . ld 2,8(11)
3737 . mtctr 12
3738 . ld 11,16(11)
3739 . bctr
3740 .
3741 . .section .plt
3742 . Lfoo: reloc (R_PPC64_JMP_SLOT, foo)
3743
3744 The "reloc ()" notation is supposed to indicate that the linker emits
3745 an R_PPC64_JMP_SLOT reloc against foo. The dynamic linker does the opd
3746 copying.
3747
3748 What are the difficulties here? Well, firstly, the relocations
3749 examined by the linker in check_relocs are against the function code
3750 sym .foo, while the dynamic relocation in the plt is emitted against
3751 the function descriptor symbol, foo. Somewhere along the line, we need
3752 to carefully copy dynamic link information from one symbol to the other.
3753 Secondly, the generic part of the elf linker will make .foo a dynamic
3754 symbol as is normal for most other backends. We need foo dynamic
3755 instead, at least for an application final link. However, when
3756 creating a shared library containing foo, we need to have both symbols
3757 dynamic so that references to .foo are satisfied during the early
3758 stages of linking. Otherwise the linker might decide to pull in a
3759 definition from some other object, eg. a static library.
3760
3761 Update: As of August 2004, we support a new convention. Function
3762 calls may use the function descriptor symbol, ie. "bl foo". This
3763 behaves exactly as "bl .foo". */
3764
3765 /* Of those relocs that might be copied as dynamic relocs, this function
3766 selects those that must be copied when linking a shared library,
3767 even when the symbol is local. */
3768
3769 static int
must_be_dyn_reloc(struct bfd_link_info * info,enum elf_ppc64_reloc_type r_type)3770 must_be_dyn_reloc (struct bfd_link_info *info,
3771 enum elf_ppc64_reloc_type r_type)
3772 {
3773 switch (r_type)
3774 {
3775 default:
3776 return 1;
3777
3778 case R_PPC64_REL32:
3779 case R_PPC64_REL64:
3780 case R_PPC64_REL30:
3781 return 0;
3782
3783 case R_PPC64_TPREL16:
3784 case R_PPC64_TPREL16_LO:
3785 case R_PPC64_TPREL16_HI:
3786 case R_PPC64_TPREL16_HA:
3787 case R_PPC64_TPREL16_DS:
3788 case R_PPC64_TPREL16_LO_DS:
3789 case R_PPC64_TPREL16_HIGH:
3790 case R_PPC64_TPREL16_HIGHA:
3791 case R_PPC64_TPREL16_HIGHER:
3792 case R_PPC64_TPREL16_HIGHERA:
3793 case R_PPC64_TPREL16_HIGHEST:
3794 case R_PPC64_TPREL16_HIGHESTA:
3795 case R_PPC64_TPREL64:
3796 return !bfd_link_executable (info);
3797 }
3798 }
3799
3800 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
3801 copying dynamic variables from a shared lib into an app's dynbss
3802 section, and instead use a dynamic relocation to point into the
3803 shared lib. With code that gcc generates, it's vital that this be
3804 enabled; In the PowerPC64 ABI, the address of a function is actually
3805 the address of a function descriptor, which resides in the .opd
3806 section. gcc uses the descriptor directly rather than going via the
3807 GOT as some other ABI's do, which means that initialized function
3808 pointers must reference the descriptor. Thus, a function pointer
3809 initialized to the address of a function in a shared library will
3810 either require a copy reloc, or a dynamic reloc. Using a copy reloc
3811 redefines the function descriptor symbol to point to the copy. This
3812 presents a problem as a plt entry for that function is also
3813 initialized from the function descriptor symbol and the copy reloc
3814 may not be initialized first. */
3815 #define ELIMINATE_COPY_RELOCS 1
3816
3817 /* Section name for stubs is the associated section name plus this
3818 string. */
3819 #define STUB_SUFFIX ".stub"
3820
3821 /* Linker stubs.
3822 ppc_stub_long_branch:
3823 Used when a 14 bit branch (or even a 24 bit branch) can't reach its
3824 destination, but a 24 bit branch in a stub section will reach.
3825 . b dest
3826
3827 ppc_stub_plt_branch:
3828 Similar to the above, but a 24 bit branch in the stub section won't
3829 reach its destination.
3830 . addis %r11,%r2,xxx@toc@ha
3831 . ld %r12,xxx@toc@l(%r11)
3832 . mtctr %r12
3833 . bctr
3834
3835 ppc_stub_plt_call:
3836 Used to call a function in a shared library. If it so happens that
3837 the plt entry referenced crosses a 64k boundary, then an extra
3838 "addi %r11,%r11,xxx@toc@l" will be inserted before the "mtctr".
3839 . std %r2,40(%r1)
3840 . addis %r11,%r2,xxx@toc@ha
3841 . ld %r12,xxx+0@toc@l(%r11)
3842 . mtctr %r12
3843 . ld %r2,xxx+8@toc@l(%r11)
3844 . ld %r11,xxx+16@toc@l(%r11)
3845 . bctr
3846
3847 ppc_stub_long_branch and ppc_stub_plt_branch may also have additional
3848 code to adjust the value and save r2 to support multiple toc sections.
3849 A ppc_stub_long_branch with an r2 offset looks like:
3850 . std %r2,40(%r1)
3851 . addis %r2,%r2,off@ha
3852 . addi %r2,%r2,off@l
3853 . b dest
3854
3855 A ppc_stub_plt_branch with an r2 offset looks like:
3856 . std %r2,40(%r1)
3857 . addis %r11,%r2,xxx@toc@ha
3858 . ld %r12,xxx@toc@l(%r11)
3859 . addis %r2,%r2,off@ha
3860 . addi %r2,%r2,off@l
3861 . mtctr %r12
3862 . bctr
3863
3864 In cases where the "addis" instruction would add zero, the "addis" is
3865 omitted and following instructions modified slightly in some cases.
3866 */
3867
3868 enum ppc_stub_type {
3869 ppc_stub_none,
3870 ppc_stub_long_branch,
3871 ppc_stub_long_branch_r2off,
3872 ppc_stub_plt_branch,
3873 ppc_stub_plt_branch_r2off,
3874 ppc_stub_plt_call,
3875 ppc_stub_plt_call_r2save,
3876 ppc_stub_global_entry,
3877 ppc_stub_save_res
3878 };
3879
3880 /* Information on stub grouping. */
3881 struct map_stub
3882 {
3883 /* The stub section. */
3884 asection *stub_sec;
3885 /* This is the section to which stubs in the group will be attached. */
3886 asection *link_sec;
3887 /* Next group. */
3888 struct map_stub *next;
3889 /* Whether to emit a copy of register save/restore functions in this
3890 group. */
3891 int needs_save_res;
3892 };
3893
3894 struct ppc_stub_hash_entry {
3895
3896 /* Base hash table entry structure. */
3897 struct bfd_hash_entry root;
3898
3899 enum ppc_stub_type stub_type;
3900
3901 /* Group information. */
3902 struct map_stub *group;
3903
3904 /* Offset within stub_sec of the beginning of this stub. */
3905 bfd_vma stub_offset;
3906
3907 /* Given the symbol's value and its section we can determine its final
3908 value when building the stubs (so the stub knows where to jump. */
3909 bfd_vma target_value;
3910 asection *target_section;
3911
3912 /* The symbol table entry, if any, that this was derived from. */
3913 struct ppc_link_hash_entry *h;
3914 struct plt_entry *plt_ent;
3915
3916 /* Symbol st_other. */
3917 unsigned char other;
3918 };
3919
3920 struct ppc_branch_hash_entry {
3921
3922 /* Base hash table entry structure. */
3923 struct bfd_hash_entry root;
3924
3925 /* Offset within branch lookup table. */
3926 unsigned int offset;
3927
3928 /* Generation marker. */
3929 unsigned int iter;
3930 };
3931
3932 /* Used to track dynamic relocations for local symbols. */
3933 struct ppc_dyn_relocs
3934 {
3935 struct ppc_dyn_relocs *next;
3936
3937 /* The input section of the reloc. */
3938 asection *sec;
3939
3940 /* Total number of relocs copied for the input section. */
3941 unsigned int count : 31;
3942
3943 /* Whether this entry is for STT_GNU_IFUNC symbols. */
3944 unsigned int ifunc : 1;
3945 };
3946
3947 struct ppc_link_hash_entry
3948 {
3949 struct elf_link_hash_entry elf;
3950
3951 union {
3952 /* A pointer to the most recently used stub hash entry against this
3953 symbol. */
3954 struct ppc_stub_hash_entry *stub_cache;
3955
3956 /* A pointer to the next symbol starting with a '.' */
3957 struct ppc_link_hash_entry *next_dot_sym;
3958 } u;
3959
3960 /* Track dynamic relocs copied for this symbol. */
3961 struct elf_dyn_relocs *dyn_relocs;
3962
3963 /* Link between function code and descriptor symbols. */
3964 struct ppc_link_hash_entry *oh;
3965
3966 /* Flag function code and descriptor symbols. */
3967 unsigned int is_func:1;
3968 unsigned int is_func_descriptor:1;
3969 unsigned int fake:1;
3970
3971 /* Whether global opd/toc sym has been adjusted or not.
3972 After ppc64_elf_edit_opd/ppc64_elf_edit_toc has run, this flag
3973 should be set for all globals defined in any opd/toc section. */
3974 unsigned int adjust_done:1;
3975
3976 /* Set if we twiddled this symbol to weak at some stage. */
3977 unsigned int was_undefined:1;
3978
3979 /* Set if this is an out-of-line register save/restore function,
3980 with non-standard calling convention. */
3981 unsigned int save_res:1;
3982
3983 /* Contexts in which symbol is used in the GOT (or TOC).
3984 TLS_GD .. TLS_EXPLICIT bits are or'd into the mask as the
3985 corresponding relocs are encountered during check_relocs.
3986 tls_optimize clears TLS_GD .. TLS_TPREL when optimizing to
3987 indicate the corresponding GOT entry type is not needed.
3988 tls_optimize may also set TLS_TPRELGD when a GD reloc turns into
3989 a TPREL one. We use a separate flag rather than setting TPREL
3990 just for convenience in distinguishing the two cases. */
3991 #define TLS_GD 1 /* GD reloc. */
3992 #define TLS_LD 2 /* LD reloc. */
3993 #define TLS_TPREL 4 /* TPREL reloc, => IE. */
3994 #define TLS_DTPREL 8 /* DTPREL reloc, => LD. */
3995 #define TLS_TLS 16 /* Any TLS reloc. */
3996 #define TLS_EXPLICIT 32 /* Marks TOC section TLS relocs. */
3997 #define TLS_TPRELGD 64 /* TPREL reloc resulting from GD->IE. */
3998 #define PLT_IFUNC 128 /* STT_GNU_IFUNC. */
3999 unsigned char tls_mask;
4000 };
4001
4002 /* ppc64 ELF linker hash table. */
4003
4004 struct ppc_link_hash_table
4005 {
4006 struct elf_link_hash_table elf;
4007
4008 /* The stub hash table. */
4009 struct bfd_hash_table stub_hash_table;
4010
4011 /* Another hash table for plt_branch stubs. */
4012 struct bfd_hash_table branch_hash_table;
4013
4014 /* Hash table for function prologue tocsave. */
4015 htab_t tocsave_htab;
4016
4017 /* Various options and other info passed from the linker. */
4018 struct ppc64_elf_params *params;
4019
4020 /* The size of sec_info below. */
4021 unsigned int sec_info_arr_size;
4022
4023 /* Per-section array of extra section info. Done this way rather
4024 than as part of ppc64_elf_section_data so we have the info for
4025 non-ppc64 sections. */
4026 struct
4027 {
4028 /* Along with elf_gp, specifies the TOC pointer used by this section. */
4029 bfd_vma toc_off;
4030
4031 union
4032 {
4033 /* The section group that this section belongs to. */
4034 struct map_stub *group;
4035 /* A temp section list pointer. */
4036 asection *list;
4037 } u;
4038 } *sec_info;
4039
4040 /* Linked list of groups. */
4041 struct map_stub *group;
4042
4043 /* Temp used when calculating TOC pointers. */
4044 bfd_vma toc_curr;
4045 bfd *toc_bfd;
4046 asection *toc_first_sec;
4047
4048 /* Used when adding symbols. */
4049 struct ppc_link_hash_entry *dot_syms;
4050
4051 /* Shortcuts to get to dynamic linker sections. */
4052 asection *dynbss;
4053 asection *relbss;
4054 asection *glink;
4055 asection *sfpr;
4056 asection *brlt;
4057 asection *relbrlt;
4058 asection *glink_eh_frame;
4059
4060 /* Shortcut to .__tls_get_addr and __tls_get_addr. */
4061 struct ppc_link_hash_entry *tls_get_addr;
4062 struct ppc_link_hash_entry *tls_get_addr_fd;
4063
4064 /* The size of reliplt used by got entry relocs. */
4065 bfd_size_type got_reli_size;
4066
4067 /* Statistics. */
4068 unsigned long stub_count[ppc_stub_global_entry];
4069
4070 /* Number of stubs against global syms. */
4071 unsigned long stub_globals;
4072
4073 /* Set if we're linking code with function descriptors. */
4074 unsigned int opd_abi:1;
4075
4076 /* Support for multiple toc sections. */
4077 unsigned int do_multi_toc:1;
4078 unsigned int multi_toc_needed:1;
4079 unsigned int second_toc_pass:1;
4080 unsigned int do_toc_opt:1;
4081
4082 /* Set on error. */
4083 unsigned int stub_error:1;
4084
4085 /* Temp used by ppc64_elf_before_check_relocs. */
4086 unsigned int twiddled_syms:1;
4087
4088 /* Incremented every time we size stubs. */
4089 unsigned int stub_iteration;
4090
4091 /* Small local sym cache. */
4092 struct sym_cache sym_cache;
4093 };
4094
4095 /* Rename some of the generic section flags to better document how they
4096 are used here. */
4097
4098 /* Nonzero if this section has TLS related relocations. */
4099 #define has_tls_reloc sec_flg0
4100
4101 /* Nonzero if this section has a call to __tls_get_addr. */
4102 #define has_tls_get_addr_call sec_flg1
4103
4104 /* Nonzero if this section has any toc or got relocs. */
4105 #define has_toc_reloc sec_flg2
4106
4107 /* Nonzero if this section has a call to another section that uses
4108 the toc or got. */
4109 #define makes_toc_func_call sec_flg3
4110
4111 /* Recursion protection when determining above flag. */
4112 #define call_check_in_progress sec_flg4
4113 #define call_check_done sec_flg5
4114
4115 /* Get the ppc64 ELF linker hash table from a link_info structure. */
4116
4117 #define ppc_hash_table(p) \
4118 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
4119 == PPC64_ELF_DATA ? ((struct ppc_link_hash_table *) ((p)->hash)) : NULL)
4120
4121 #define ppc_stub_hash_lookup(table, string, create, copy) \
4122 ((struct ppc_stub_hash_entry *) \
4123 bfd_hash_lookup ((table), (string), (create), (copy)))
4124
4125 #define ppc_branch_hash_lookup(table, string, create, copy) \
4126 ((struct ppc_branch_hash_entry *) \
4127 bfd_hash_lookup ((table), (string), (create), (copy)))
4128
4129 /* Create an entry in the stub hash table. */
4130
4131 static struct bfd_hash_entry *
stub_hash_newfunc(struct bfd_hash_entry * entry,struct bfd_hash_table * table,const char * string)4132 stub_hash_newfunc (struct bfd_hash_entry *entry,
4133 struct bfd_hash_table *table,
4134 const char *string)
4135 {
4136 /* Allocate the structure if it has not already been allocated by a
4137 subclass. */
4138 if (entry == NULL)
4139 {
4140 entry = bfd_hash_allocate (table, sizeof (struct ppc_stub_hash_entry));
4141 if (entry == NULL)
4142 return entry;
4143 }
4144
4145 /* Call the allocation method of the superclass. */
4146 entry = bfd_hash_newfunc (entry, table, string);
4147 if (entry != NULL)
4148 {
4149 struct ppc_stub_hash_entry *eh;
4150
4151 /* Initialize the local fields. */
4152 eh = (struct ppc_stub_hash_entry *) entry;
4153 eh->stub_type = ppc_stub_none;
4154 eh->group = NULL;
4155 eh->stub_offset = 0;
4156 eh->target_value = 0;
4157 eh->target_section = NULL;
4158 eh->h = NULL;
4159 eh->plt_ent = NULL;
4160 eh->other = 0;
4161 }
4162
4163 return entry;
4164 }
4165
4166 /* Create an entry in the branch hash table. */
4167
4168 static struct bfd_hash_entry *
branch_hash_newfunc(struct bfd_hash_entry * entry,struct bfd_hash_table * table,const char * string)4169 branch_hash_newfunc (struct bfd_hash_entry *entry,
4170 struct bfd_hash_table *table,
4171 const char *string)
4172 {
4173 /* Allocate the structure if it has not already been allocated by a
4174 subclass. */
4175 if (entry == NULL)
4176 {
4177 entry = bfd_hash_allocate (table, sizeof (struct ppc_branch_hash_entry));
4178 if (entry == NULL)
4179 return entry;
4180 }
4181
4182 /* Call the allocation method of the superclass. */
4183 entry = bfd_hash_newfunc (entry, table, string);
4184 if (entry != NULL)
4185 {
4186 struct ppc_branch_hash_entry *eh;
4187
4188 /* Initialize the local fields. */
4189 eh = (struct ppc_branch_hash_entry *) entry;
4190 eh->offset = 0;
4191 eh->iter = 0;
4192 }
4193
4194 return entry;
4195 }
4196
4197 /* Create an entry in a ppc64 ELF linker hash table. */
4198
4199 static struct bfd_hash_entry *
link_hash_newfunc(struct bfd_hash_entry * entry,struct bfd_hash_table * table,const char * string)4200 link_hash_newfunc (struct bfd_hash_entry *entry,
4201 struct bfd_hash_table *table,
4202 const char *string)
4203 {
4204 /* Allocate the structure if it has not already been allocated by a
4205 subclass. */
4206 if (entry == NULL)
4207 {
4208 entry = bfd_hash_allocate (table, sizeof (struct ppc_link_hash_entry));
4209 if (entry == NULL)
4210 return entry;
4211 }
4212
4213 /* Call the allocation method of the superclass. */
4214 entry = _bfd_elf_link_hash_newfunc (entry, table, string);
4215 if (entry != NULL)
4216 {
4217 struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) entry;
4218
4219 memset (&eh->u.stub_cache, 0,
4220 (sizeof (struct ppc_link_hash_entry)
4221 - offsetof (struct ppc_link_hash_entry, u.stub_cache)));
4222
4223 /* When making function calls, old ABI code references function entry
4224 points (dot symbols), while new ABI code references the function
4225 descriptor symbol. We need to make any combination of reference and
4226 definition work together, without breaking archive linking.
4227
4228 For a defined function "foo" and an undefined call to "bar":
4229 An old object defines "foo" and ".foo", references ".bar" (possibly
4230 "bar" too).
4231 A new object defines "foo" and references "bar".
4232
4233 A new object thus has no problem with its undefined symbols being
4234 satisfied by definitions in an old object. On the other hand, the
4235 old object won't have ".bar" satisfied by a new object.
4236
4237 Keep a list of newly added dot-symbols. */
4238
4239 if (string[0] == '.')
4240 {
4241 struct ppc_link_hash_table *htab;
4242
4243 htab = (struct ppc_link_hash_table *) table;
4244 eh->u.next_dot_sym = htab->dot_syms;
4245 htab->dot_syms = eh;
4246 }
4247 }
4248
4249 return entry;
4250 }
4251
4252 struct tocsave_entry {
4253 asection *sec;
4254 bfd_vma offset;
4255 };
4256
4257 static hashval_t
tocsave_htab_hash(const void * p)4258 tocsave_htab_hash (const void *p)
4259 {
4260 const struct tocsave_entry *e = (const struct tocsave_entry *) p;
4261 return ((bfd_vma)(intptr_t) e->sec ^ e->offset) >> 3;
4262 }
4263
4264 static int
tocsave_htab_eq(const void * p1,const void * p2)4265 tocsave_htab_eq (const void *p1, const void *p2)
4266 {
4267 const struct tocsave_entry *e1 = (const struct tocsave_entry *) p1;
4268 const struct tocsave_entry *e2 = (const struct tocsave_entry *) p2;
4269 return e1->sec == e2->sec && e1->offset == e2->offset;
4270 }
4271
4272 /* Destroy a ppc64 ELF linker hash table. */
4273
4274 static void
ppc64_elf_link_hash_table_free(bfd * obfd)4275 ppc64_elf_link_hash_table_free (bfd *obfd)
4276 {
4277 struct ppc_link_hash_table *htab;
4278
4279 htab = (struct ppc_link_hash_table *) obfd->link.hash;
4280 if (htab->tocsave_htab)
4281 htab_delete (htab->tocsave_htab);
4282 bfd_hash_table_free (&htab->branch_hash_table);
4283 bfd_hash_table_free (&htab->stub_hash_table);
4284 _bfd_elf_link_hash_table_free (obfd);
4285 }
4286
4287 /* Create a ppc64 ELF linker hash table. */
4288
4289 static struct bfd_link_hash_table *
ppc64_elf_link_hash_table_create(bfd * abfd)4290 ppc64_elf_link_hash_table_create (bfd *abfd)
4291 {
4292 struct ppc_link_hash_table *htab;
4293 bfd_size_type amt = sizeof (struct ppc_link_hash_table);
4294
4295 htab = bfd_zmalloc (amt);
4296 if (htab == NULL)
4297 return NULL;
4298
4299 if (!_bfd_elf_link_hash_table_init (&htab->elf, abfd, link_hash_newfunc,
4300 sizeof (struct ppc_link_hash_entry),
4301 PPC64_ELF_DATA))
4302 {
4303 free (htab);
4304 return NULL;
4305 }
4306
4307 /* Init the stub hash table too. */
4308 if (!bfd_hash_table_init (&htab->stub_hash_table, stub_hash_newfunc,
4309 sizeof (struct ppc_stub_hash_entry)))
4310 {
4311 _bfd_elf_link_hash_table_free (abfd);
4312 return NULL;
4313 }
4314
4315 /* And the branch hash table. */
4316 if (!bfd_hash_table_init (&htab->branch_hash_table, branch_hash_newfunc,
4317 sizeof (struct ppc_branch_hash_entry)))
4318 {
4319 bfd_hash_table_free (&htab->stub_hash_table);
4320 _bfd_elf_link_hash_table_free (abfd);
4321 return NULL;
4322 }
4323
4324 htab->tocsave_htab = htab_try_create (1024,
4325 tocsave_htab_hash,
4326 tocsave_htab_eq,
4327 NULL);
4328 if (htab->tocsave_htab == NULL)
4329 {
4330 ppc64_elf_link_hash_table_free (abfd);
4331 return NULL;
4332 }
4333 htab->elf.root.hash_table_free = ppc64_elf_link_hash_table_free;
4334
4335 /* Initializing two fields of the union is just cosmetic. We really
4336 only care about glist, but when compiled on a 32-bit host the
4337 bfd_vma fields are larger. Setting the bfd_vma to zero makes
4338 debugger inspection of these fields look nicer. */
4339 htab->elf.init_got_refcount.refcount = 0;
4340 htab->elf.init_got_refcount.glist = NULL;
4341 htab->elf.init_plt_refcount.refcount = 0;
4342 htab->elf.init_plt_refcount.glist = NULL;
4343 htab->elf.init_got_offset.offset = 0;
4344 htab->elf.init_got_offset.glist = NULL;
4345 htab->elf.init_plt_offset.offset = 0;
4346 htab->elf.init_plt_offset.glist = NULL;
4347
4348 return &htab->elf.root;
4349 }
4350
4351 /* Create sections for linker generated code. */
4352
4353 static bfd_boolean
create_linkage_sections(bfd * dynobj,struct bfd_link_info * info)4354 create_linkage_sections (bfd *dynobj, struct bfd_link_info *info)
4355 {
4356 struct ppc_link_hash_table *htab;
4357 flagword flags;
4358
4359 htab = ppc_hash_table (info);
4360
4361 flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY
4362 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4363 if (htab->params->save_restore_funcs)
4364 {
4365 /* Create .sfpr for code to save and restore fp regs. */
4366 htab->sfpr = bfd_make_section_anyway_with_flags (dynobj, ".sfpr",
4367 flags);
4368 if (htab->sfpr == NULL
4369 || ! bfd_set_section_alignment (dynobj, htab->sfpr, 2))
4370 return FALSE;
4371 }
4372
4373 if (bfd_link_relocatable (info))
4374 return TRUE;
4375
4376 /* Create .glink for lazy dynamic linking support. */
4377 htab->glink = bfd_make_section_anyway_with_flags (dynobj, ".glink",
4378 flags);
4379 if (htab->glink == NULL
4380 || ! bfd_set_section_alignment (dynobj, htab->glink, 3))
4381 return FALSE;
4382
4383 if (!info->no_ld_generated_unwind_info)
4384 {
4385 flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_HAS_CONTENTS
4386 | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4387 htab->glink_eh_frame = bfd_make_section_anyway_with_flags (dynobj,
4388 ".eh_frame",
4389 flags);
4390 if (htab->glink_eh_frame == NULL
4391 || !bfd_set_section_alignment (dynobj, htab->glink_eh_frame, 2))
4392 return FALSE;
4393 }
4394
4395 flags = SEC_ALLOC | SEC_LINKER_CREATED;
4396 htab->elf.iplt = bfd_make_section_anyway_with_flags (dynobj, ".iplt", flags);
4397 if (htab->elf.iplt == NULL
4398 || ! bfd_set_section_alignment (dynobj, htab->elf.iplt, 3))
4399 return FALSE;
4400
4401 flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4402 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4403 htab->elf.irelplt
4404 = bfd_make_section_anyway_with_flags (dynobj, ".rela.iplt", flags);
4405 if (htab->elf.irelplt == NULL
4406 || ! bfd_set_section_alignment (dynobj, htab->elf.irelplt, 3))
4407 return FALSE;
4408
4409 /* Create branch lookup table for plt_branch stubs. */
4410 flags = (SEC_ALLOC | SEC_LOAD
4411 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4412 htab->brlt = bfd_make_section_anyway_with_flags (dynobj, ".branch_lt",
4413 flags);
4414 if (htab->brlt == NULL
4415 || ! bfd_set_section_alignment (dynobj, htab->brlt, 3))
4416 return FALSE;
4417
4418 if (!bfd_link_pic (info))
4419 return TRUE;
4420
4421 flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4422 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4423 htab->relbrlt = bfd_make_section_anyway_with_flags (dynobj,
4424 ".rela.branch_lt",
4425 flags);
4426 if (htab->relbrlt == NULL
4427 || ! bfd_set_section_alignment (dynobj, htab->relbrlt, 3))
4428 return FALSE;
4429
4430 return TRUE;
4431 }
4432
4433 /* Satisfy the ELF linker by filling in some fields in our fake bfd. */
4434
4435 bfd_boolean
ppc64_elf_init_stub_bfd(struct bfd_link_info * info,struct ppc64_elf_params * params)4436 ppc64_elf_init_stub_bfd (struct bfd_link_info *info,
4437 struct ppc64_elf_params *params)
4438 {
4439 struct ppc_link_hash_table *htab;
4440
4441 elf_elfheader (params->stub_bfd)->e_ident[EI_CLASS] = ELFCLASS64;
4442
4443 /* Always hook our dynamic sections into the first bfd, which is the
4444 linker created stub bfd. This ensures that the GOT header is at
4445 the start of the output TOC section. */
4446 htab = ppc_hash_table (info);
4447 htab->elf.dynobj = params->stub_bfd;
4448 htab->params = params;
4449
4450 return create_linkage_sections (htab->elf.dynobj, info);
4451 }
4452
4453 /* Build a name for an entry in the stub hash table. */
4454
4455 static char *
ppc_stub_name(const asection * input_section,const asection * sym_sec,const struct ppc_link_hash_entry * h,const Elf_Internal_Rela * rel)4456 ppc_stub_name (const asection *input_section,
4457 const asection *sym_sec,
4458 const struct ppc_link_hash_entry *h,
4459 const Elf_Internal_Rela *rel)
4460 {
4461 char *stub_name;
4462 ssize_t len;
4463
4464 /* rel->r_addend is actually 64 bit, but who uses more than +/- 2^31
4465 offsets from a sym as a branch target? In fact, we could
4466 probably assume the addend is always zero. */
4467 BFD_ASSERT (((int) rel->r_addend & 0xffffffff) == rel->r_addend);
4468
4469 if (h)
4470 {
4471 len = 8 + 1 + strlen (h->elf.root.root.string) + 1 + 8 + 1;
4472 stub_name = bfd_malloc (len);
4473 if (stub_name == NULL)
4474 return stub_name;
4475
4476 len = sprintf (stub_name, "%08x.%s+%x",
4477 input_section->id & 0xffffffff,
4478 h->elf.root.root.string,
4479 (int) rel->r_addend & 0xffffffff);
4480 }
4481 else
4482 {
4483 len = 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1;
4484 stub_name = bfd_malloc (len);
4485 if (stub_name == NULL)
4486 return stub_name;
4487
4488 len = sprintf (stub_name, "%08x.%x:%x+%x",
4489 input_section->id & 0xffffffff,
4490 sym_sec->id & 0xffffffff,
4491 (int) ELF64_R_SYM (rel->r_info) & 0xffffffff,
4492 (int) rel->r_addend & 0xffffffff);
4493 }
4494 if (len > 2 && stub_name[len - 2] == '+' && stub_name[len - 1] == '0')
4495 stub_name[len - 2] = 0;
4496 return stub_name;
4497 }
4498
4499 /* Look up an entry in the stub hash. Stub entries are cached because
4500 creating the stub name takes a bit of time. */
4501
4502 static struct ppc_stub_hash_entry *
ppc_get_stub_entry(const asection * input_section,const asection * sym_sec,struct ppc_link_hash_entry * h,const Elf_Internal_Rela * rel,struct ppc_link_hash_table * htab)4503 ppc_get_stub_entry (const asection *input_section,
4504 const asection *sym_sec,
4505 struct ppc_link_hash_entry *h,
4506 const Elf_Internal_Rela *rel,
4507 struct ppc_link_hash_table *htab)
4508 {
4509 struct ppc_stub_hash_entry *stub_entry;
4510 struct map_stub *group;
4511
4512 /* If this input section is part of a group of sections sharing one
4513 stub section, then use the id of the first section in the group.
4514 Stub names need to include a section id, as there may well be
4515 more than one stub used to reach say, printf, and we need to
4516 distinguish between them. */
4517 group = htab->sec_info[input_section->id].u.group;
4518 if (group == NULL)
4519 return NULL;
4520
4521 if (h != NULL && h->u.stub_cache != NULL
4522 && h->u.stub_cache->h == h
4523 && h->u.stub_cache->group == group)
4524 {
4525 stub_entry = h->u.stub_cache;
4526 }
4527 else
4528 {
4529 char *stub_name;
4530
4531 stub_name = ppc_stub_name (group->link_sec, sym_sec, h, rel);
4532 if (stub_name == NULL)
4533 return NULL;
4534
4535 stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
4536 stub_name, FALSE, FALSE);
4537 if (h != NULL)
4538 h->u.stub_cache = stub_entry;
4539
4540 free (stub_name);
4541 }
4542
4543 return stub_entry;
4544 }
4545
4546 /* Add a new stub entry to the stub hash. Not all fields of the new
4547 stub entry are initialised. */
4548
4549 static struct ppc_stub_hash_entry *
ppc_add_stub(const char * stub_name,asection * section,struct bfd_link_info * info)4550 ppc_add_stub (const char *stub_name,
4551 asection *section,
4552 struct bfd_link_info *info)
4553 {
4554 struct ppc_link_hash_table *htab = ppc_hash_table (info);
4555 struct map_stub *group;
4556 asection *link_sec;
4557 asection *stub_sec;
4558 struct ppc_stub_hash_entry *stub_entry;
4559
4560 group = htab->sec_info[section->id].u.group;
4561 link_sec = group->link_sec;
4562 stub_sec = group->stub_sec;
4563 if (stub_sec == NULL)
4564 {
4565 size_t namelen;
4566 bfd_size_type len;
4567 char *s_name;
4568
4569 namelen = strlen (link_sec->name);
4570 len = namelen + sizeof (STUB_SUFFIX);
4571 s_name = bfd_alloc (htab->params->stub_bfd, len);
4572 if (s_name == NULL)
4573 return NULL;
4574
4575 memcpy (s_name, link_sec->name, namelen);
4576 memcpy (s_name + namelen, STUB_SUFFIX, sizeof (STUB_SUFFIX));
4577 stub_sec = (*htab->params->add_stub_section) (s_name, link_sec);
4578 if (stub_sec == NULL)
4579 return NULL;
4580 group->stub_sec = stub_sec;
4581 }
4582
4583 /* Enter this entry into the linker stub hash table. */
4584 stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table, stub_name,
4585 TRUE, FALSE);
4586 if (stub_entry == NULL)
4587 {
4588 info->callbacks->einfo (_("%P: %B: cannot create stub entry %s\n"),
4589 section->owner, stub_name);
4590 return NULL;
4591 }
4592
4593 stub_entry->group = group;
4594 stub_entry->stub_offset = 0;
4595 return stub_entry;
4596 }
4597
4598 /* Create .got and .rela.got sections in ABFD, and .got in dynobj if
4599 not already done. */
4600
4601 static bfd_boolean
create_got_section(bfd * abfd,struct bfd_link_info * info)4602 create_got_section (bfd *abfd, struct bfd_link_info *info)
4603 {
4604 asection *got, *relgot;
4605 flagword flags;
4606 struct ppc_link_hash_table *htab = ppc_hash_table (info);
4607
4608 if (!is_ppc64_elf (abfd))
4609 return FALSE;
4610 if (htab == NULL)
4611 return FALSE;
4612
4613 if (!htab->elf.sgot
4614 && !_bfd_elf_create_got_section (htab->elf.dynobj, info))
4615 return FALSE;
4616
4617 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
4618 | SEC_LINKER_CREATED);
4619
4620 got = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
4621 if (!got
4622 || !bfd_set_section_alignment (abfd, got, 3))
4623 return FALSE;
4624
4625 relgot = bfd_make_section_anyway_with_flags (abfd, ".rela.got",
4626 flags | SEC_READONLY);
4627 if (!relgot
4628 || ! bfd_set_section_alignment (abfd, relgot, 3))
4629 return FALSE;
4630
4631 ppc64_elf_tdata (abfd)->got = got;
4632 ppc64_elf_tdata (abfd)->relgot = relgot;
4633 return TRUE;
4634 }
4635
4636 /* Create the dynamic sections, and set up shortcuts. */
4637
4638 static bfd_boolean
ppc64_elf_create_dynamic_sections(bfd * dynobj,struct bfd_link_info * info)4639 ppc64_elf_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
4640 {
4641 struct ppc_link_hash_table *htab;
4642
4643 if (!_bfd_elf_create_dynamic_sections (dynobj, info))
4644 return FALSE;
4645
4646 htab = ppc_hash_table (info);
4647 if (htab == NULL)
4648 return FALSE;
4649
4650 htab->dynbss = bfd_get_linker_section (dynobj, ".dynbss");
4651 if (!bfd_link_pic (info))
4652 htab->relbss = bfd_get_linker_section (dynobj, ".rela.bss");
4653
4654 if (!htab->elf.sgot || !htab->elf.splt || !htab->elf.srelplt || !htab->dynbss
4655 || (!bfd_link_pic (info) && !htab->relbss))
4656 abort ();
4657
4658 return TRUE;
4659 }
4660
4661 /* Follow indirect and warning symbol links. */
4662
4663 static inline struct bfd_link_hash_entry *
follow_link(struct bfd_link_hash_entry * h)4664 follow_link (struct bfd_link_hash_entry *h)
4665 {
4666 while (h->type == bfd_link_hash_indirect
4667 || h->type == bfd_link_hash_warning)
4668 h = h->u.i.link;
4669 return h;
4670 }
4671
4672 static inline struct elf_link_hash_entry *
elf_follow_link(struct elf_link_hash_entry * h)4673 elf_follow_link (struct elf_link_hash_entry *h)
4674 {
4675 return (struct elf_link_hash_entry *) follow_link (&h->root);
4676 }
4677
4678 static inline struct ppc_link_hash_entry *
ppc_follow_link(struct ppc_link_hash_entry * h)4679 ppc_follow_link (struct ppc_link_hash_entry *h)
4680 {
4681 return (struct ppc_link_hash_entry *) follow_link (&h->elf.root);
4682 }
4683
4684 /* Merge PLT info on FROM with that on TO. */
4685
4686 static void
move_plt_plist(struct ppc_link_hash_entry * from,struct ppc_link_hash_entry * to)4687 move_plt_plist (struct ppc_link_hash_entry *from,
4688 struct ppc_link_hash_entry *to)
4689 {
4690 if (from->elf.plt.plist != NULL)
4691 {
4692 if (to->elf.plt.plist != NULL)
4693 {
4694 struct plt_entry **entp;
4695 struct plt_entry *ent;
4696
4697 for (entp = &from->elf.plt.plist; (ent = *entp) != NULL; )
4698 {
4699 struct plt_entry *dent;
4700
4701 for (dent = to->elf.plt.plist; dent != NULL; dent = dent->next)
4702 if (dent->addend == ent->addend)
4703 {
4704 dent->plt.refcount += ent->plt.refcount;
4705 *entp = ent->next;
4706 break;
4707 }
4708 if (dent == NULL)
4709 entp = &ent->next;
4710 }
4711 *entp = to->elf.plt.plist;
4712 }
4713
4714 to->elf.plt.plist = from->elf.plt.plist;
4715 from->elf.plt.plist = NULL;
4716 }
4717 }
4718
4719 /* Copy the extra info we tack onto an elf_link_hash_entry. */
4720
4721 static void
ppc64_elf_copy_indirect_symbol(struct bfd_link_info * info,struct elf_link_hash_entry * dir,struct elf_link_hash_entry * ind)4722 ppc64_elf_copy_indirect_symbol (struct bfd_link_info *info,
4723 struct elf_link_hash_entry *dir,
4724 struct elf_link_hash_entry *ind)
4725 {
4726 struct ppc_link_hash_entry *edir, *eind;
4727
4728 edir = (struct ppc_link_hash_entry *) dir;
4729 eind = (struct ppc_link_hash_entry *) ind;
4730
4731 edir->is_func |= eind->is_func;
4732 edir->is_func_descriptor |= eind->is_func_descriptor;
4733 edir->tls_mask |= eind->tls_mask;
4734 if (eind->oh != NULL)
4735 edir->oh = ppc_follow_link (eind->oh);
4736
4737 /* If called to transfer flags for a weakdef during processing
4738 of elf_adjust_dynamic_symbol, don't copy NON_GOT_REF.
4739 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
4740 if (!(ELIMINATE_COPY_RELOCS
4741 && eind->elf.root.type != bfd_link_hash_indirect
4742 && edir->elf.dynamic_adjusted))
4743 edir->elf.non_got_ref |= eind->elf.non_got_ref;
4744
4745 edir->elf.ref_dynamic |= eind->elf.ref_dynamic;
4746 edir->elf.ref_regular |= eind->elf.ref_regular;
4747 edir->elf.ref_regular_nonweak |= eind->elf.ref_regular_nonweak;
4748 edir->elf.needs_plt |= eind->elf.needs_plt;
4749 edir->elf.pointer_equality_needed |= eind->elf.pointer_equality_needed;
4750
4751 /* Copy over any dynamic relocs we may have on the indirect sym. */
4752 if (eind->dyn_relocs != NULL)
4753 {
4754 if (edir->dyn_relocs != NULL)
4755 {
4756 struct elf_dyn_relocs **pp;
4757 struct elf_dyn_relocs *p;
4758
4759 /* Add reloc counts against the indirect sym to the direct sym
4760 list. Merge any entries against the same section. */
4761 for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
4762 {
4763 struct elf_dyn_relocs *q;
4764
4765 for (q = edir->dyn_relocs; q != NULL; q = q->next)
4766 if (q->sec == p->sec)
4767 {
4768 q->pc_count += p->pc_count;
4769 q->count += p->count;
4770 *pp = p->next;
4771 break;
4772 }
4773 if (q == NULL)
4774 pp = &p->next;
4775 }
4776 *pp = edir->dyn_relocs;
4777 }
4778
4779 edir->dyn_relocs = eind->dyn_relocs;
4780 eind->dyn_relocs = NULL;
4781 }
4782
4783 /* If we were called to copy over info for a weak sym, that's all.
4784 You might think dyn_relocs need not be copied over; After all,
4785 both syms will be dynamic or both non-dynamic so we're just
4786 moving reloc accounting around. However, ELIMINATE_COPY_RELOCS
4787 code in ppc64_elf_adjust_dynamic_symbol needs to check for
4788 dyn_relocs in read-only sections, and it does so on what is the
4789 DIR sym here. */
4790 if (eind->elf.root.type != bfd_link_hash_indirect)
4791 return;
4792
4793 /* Copy over got entries that we may have already seen to the
4794 symbol which just became indirect. */
4795 if (eind->elf.got.glist != NULL)
4796 {
4797 if (edir->elf.got.glist != NULL)
4798 {
4799 struct got_entry **entp;
4800 struct got_entry *ent;
4801
4802 for (entp = &eind->elf.got.glist; (ent = *entp) != NULL; )
4803 {
4804 struct got_entry *dent;
4805
4806 for (dent = edir->elf.got.glist; dent != NULL; dent = dent->next)
4807 if (dent->addend == ent->addend
4808 && dent->owner == ent->owner
4809 && dent->tls_type == ent->tls_type)
4810 {
4811 dent->got.refcount += ent->got.refcount;
4812 *entp = ent->next;
4813 break;
4814 }
4815 if (dent == NULL)
4816 entp = &ent->next;
4817 }
4818 *entp = edir->elf.got.glist;
4819 }
4820
4821 edir->elf.got.glist = eind->elf.got.glist;
4822 eind->elf.got.glist = NULL;
4823 }
4824
4825 /* And plt entries. */
4826 move_plt_plist (eind, edir);
4827
4828 if (eind->elf.dynindx != -1)
4829 {
4830 if (edir->elf.dynindx != -1)
4831 _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
4832 edir->elf.dynstr_index);
4833 edir->elf.dynindx = eind->elf.dynindx;
4834 edir->elf.dynstr_index = eind->elf.dynstr_index;
4835 eind->elf.dynindx = -1;
4836 eind->elf.dynstr_index = 0;
4837 }
4838 }
4839
4840 /* Find the function descriptor hash entry from the given function code
4841 hash entry FH. Link the entries via their OH fields. */
4842
4843 static struct ppc_link_hash_entry *
lookup_fdh(struct ppc_link_hash_entry * fh,struct ppc_link_hash_table * htab)4844 lookup_fdh (struct ppc_link_hash_entry *fh, struct ppc_link_hash_table *htab)
4845 {
4846 struct ppc_link_hash_entry *fdh = fh->oh;
4847
4848 if (fdh == NULL)
4849 {
4850 const char *fd_name = fh->elf.root.root.string + 1;
4851
4852 fdh = (struct ppc_link_hash_entry *)
4853 elf_link_hash_lookup (&htab->elf, fd_name, FALSE, FALSE, FALSE);
4854 if (fdh == NULL)
4855 return fdh;
4856
4857 fdh->is_func_descriptor = 1;
4858 fdh->oh = fh;
4859 fh->is_func = 1;
4860 fh->oh = fdh;
4861 }
4862
4863 return ppc_follow_link (fdh);
4864 }
4865
4866 /* Make a fake function descriptor sym for the code sym FH. */
4867
4868 static struct ppc_link_hash_entry *
make_fdh(struct bfd_link_info * info,struct ppc_link_hash_entry * fh)4869 make_fdh (struct bfd_link_info *info,
4870 struct ppc_link_hash_entry *fh)
4871 {
4872 bfd *abfd;
4873 asymbol *newsym;
4874 struct bfd_link_hash_entry *bh;
4875 struct ppc_link_hash_entry *fdh;
4876
4877 abfd = fh->elf.root.u.undef.abfd;
4878 newsym = bfd_make_empty_symbol (abfd);
4879 newsym->name = fh->elf.root.root.string + 1;
4880 newsym->section = bfd_und_section_ptr;
4881 newsym->value = 0;
4882 newsym->flags = BSF_WEAK;
4883
4884 bh = NULL;
4885 if (!_bfd_generic_link_add_one_symbol (info, abfd, newsym->name,
4886 newsym->flags, newsym->section,
4887 newsym->value, NULL, FALSE, FALSE,
4888 &bh))
4889 return NULL;
4890
4891 fdh = (struct ppc_link_hash_entry *) bh;
4892 fdh->elf.non_elf = 0;
4893 fdh->fake = 1;
4894 fdh->is_func_descriptor = 1;
4895 fdh->oh = fh;
4896 fh->is_func = 1;
4897 fh->oh = fdh;
4898 return fdh;
4899 }
4900
4901 /* Fix function descriptor symbols defined in .opd sections to be
4902 function type. */
4903
4904 static bfd_boolean
ppc64_elf_add_symbol_hook(bfd * ibfd,struct bfd_link_info * info,Elf_Internal_Sym * isym,const char ** name,flagword * flags ATTRIBUTE_UNUSED,asection ** sec,bfd_vma * value)4905 ppc64_elf_add_symbol_hook (bfd *ibfd,
4906 struct bfd_link_info *info,
4907 Elf_Internal_Sym *isym,
4908 const char **name,
4909 flagword *flags ATTRIBUTE_UNUSED,
4910 asection **sec,
4911 bfd_vma *value)
4912 {
4913 if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC
4914 && (ibfd->flags & DYNAMIC) == 0
4915 && bfd_get_flavour (info->output_bfd) == bfd_target_elf_flavour)
4916 elf_tdata (info->output_bfd)->has_gnu_symbols |= elf_gnu_symbol_ifunc;
4917
4918 if (*sec != NULL
4919 && strcmp ((*sec)->name, ".opd") == 0)
4920 {
4921 asection *code_sec;
4922
4923 if (!(ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC
4924 || ELF_ST_TYPE (isym->st_info) == STT_FUNC))
4925 isym->st_info = ELF_ST_INFO (ELF_ST_BIND (isym->st_info), STT_FUNC);
4926
4927 /* If the symbol is a function defined in .opd, and the function
4928 code is in a discarded group, let it appear to be undefined. */
4929 if (!bfd_link_relocatable (info)
4930 && (*sec)->reloc_count != 0
4931 && opd_entry_value (*sec, *value, &code_sec, NULL,
4932 FALSE) != (bfd_vma) -1
4933 && discarded_section (code_sec))
4934 {
4935 *sec = bfd_und_section_ptr;
4936 isym->st_shndx = SHN_UNDEF;
4937 }
4938 }
4939 else if (*sec != NULL
4940 && strcmp ((*sec)->name, ".toc") == 0
4941 && ELF_ST_TYPE (isym->st_info) == STT_OBJECT)
4942 {
4943 struct ppc_link_hash_table *htab = ppc_hash_table (info);
4944 if (htab != NULL)
4945 htab->params->object_in_toc = 1;
4946 }
4947
4948 if ((STO_PPC64_LOCAL_MASK & isym->st_other) != 0)
4949 {
4950 if (abiversion (ibfd) == 0)
4951 set_abiversion (ibfd, 2);
4952 else if (abiversion (ibfd) == 1)
4953 {
4954 info->callbacks->einfo (_("%P: symbol '%s' has invalid st_other"
4955 " for ABI version 1\n"), name);
4956 bfd_set_error (bfd_error_bad_value);
4957 return FALSE;
4958 }
4959 }
4960
4961 return TRUE;
4962 }
4963
4964 /* Merge non-visibility st_other attributes: local entry point. */
4965
4966 static void
ppc64_elf_merge_symbol_attribute(struct elf_link_hash_entry * h,const Elf_Internal_Sym * isym,bfd_boolean definition,bfd_boolean dynamic)4967 ppc64_elf_merge_symbol_attribute (struct elf_link_hash_entry *h,
4968 const Elf_Internal_Sym *isym,
4969 bfd_boolean definition,
4970 bfd_boolean dynamic)
4971 {
4972 if (definition && !dynamic)
4973 h->other = ((isym->st_other & ~ELF_ST_VISIBILITY (-1))
4974 | ELF_ST_VISIBILITY (h->other));
4975 }
4976
4977 /* This function makes an old ABI object reference to ".bar" cause the
4978 inclusion of a new ABI object archive that defines "bar".
4979 NAME is a symbol defined in an archive. Return a symbol in the hash
4980 table that might be satisfied by the archive symbols. */
4981
4982 static struct elf_link_hash_entry *
ppc64_elf_archive_symbol_lookup(bfd * abfd,struct bfd_link_info * info,const char * name)4983 ppc64_elf_archive_symbol_lookup (bfd *abfd,
4984 struct bfd_link_info *info,
4985 const char *name)
4986 {
4987 struct elf_link_hash_entry *h;
4988 char *dot_name;
4989 size_t len;
4990
4991 h = _bfd_elf_archive_symbol_lookup (abfd, info, name);
4992 if (h != NULL
4993 /* Don't return this sym if it is a fake function descriptor
4994 created by add_symbol_adjust. */
4995 && !(h->root.type == bfd_link_hash_undefweak
4996 && ((struct ppc_link_hash_entry *) h)->fake))
4997 return h;
4998
4999 if (name[0] == '.')
5000 return h;
5001
5002 len = strlen (name);
5003 dot_name = bfd_alloc (abfd, len + 2);
5004 if (dot_name == NULL)
5005 return (struct elf_link_hash_entry *) 0 - 1;
5006 dot_name[0] = '.';
5007 memcpy (dot_name + 1, name, len + 1);
5008 h = _bfd_elf_archive_symbol_lookup (abfd, info, dot_name);
5009 bfd_release (abfd, dot_name);
5010 return h;
5011 }
5012
5013 /* This function satisfies all old ABI object references to ".bar" if a
5014 new ABI object defines "bar". Well, at least, undefined dot symbols
5015 are made weak. This stops later archive searches from including an
5016 object if we already have a function descriptor definition. It also
5017 prevents the linker complaining about undefined symbols.
5018 We also check and correct mismatched symbol visibility here. The
5019 most restrictive visibility of the function descriptor and the
5020 function entry symbol is used. */
5021
5022 static bfd_boolean
add_symbol_adjust(struct ppc_link_hash_entry * eh,struct bfd_link_info * info)5023 add_symbol_adjust (struct ppc_link_hash_entry *eh, struct bfd_link_info *info)
5024 {
5025 struct ppc_link_hash_table *htab;
5026 struct ppc_link_hash_entry *fdh;
5027
5028 if (eh->elf.root.type == bfd_link_hash_indirect)
5029 return TRUE;
5030
5031 if (eh->elf.root.type == bfd_link_hash_warning)
5032 eh = (struct ppc_link_hash_entry *) eh->elf.root.u.i.link;
5033
5034 if (eh->elf.root.root.string[0] != '.')
5035 abort ();
5036
5037 htab = ppc_hash_table (info);
5038 if (htab == NULL)
5039 return FALSE;
5040
5041 fdh = lookup_fdh (eh, htab);
5042 if (fdh == NULL)
5043 {
5044 if (!bfd_link_relocatable (info)
5045 && (eh->elf.root.type == bfd_link_hash_undefined
5046 || eh->elf.root.type == bfd_link_hash_undefweak)
5047 && eh->elf.ref_regular)
5048 {
5049 /* Make an undefweak function descriptor sym, which is enough to
5050 pull in an --as-needed shared lib, but won't cause link
5051 errors. Archives are handled elsewhere. */
5052 fdh = make_fdh (info, eh);
5053 if (fdh == NULL)
5054 return FALSE;
5055 fdh->elf.ref_regular = 1;
5056 }
5057 }
5058 else
5059 {
5060 unsigned entry_vis = ELF_ST_VISIBILITY (eh->elf.other) - 1;
5061 unsigned descr_vis = ELF_ST_VISIBILITY (fdh->elf.other) - 1;
5062 if (entry_vis < descr_vis)
5063 fdh->elf.other += entry_vis - descr_vis;
5064 else if (entry_vis > descr_vis)
5065 eh->elf.other += descr_vis - entry_vis;
5066
5067 if ((fdh->elf.root.type == bfd_link_hash_defined
5068 || fdh->elf.root.type == bfd_link_hash_defweak)
5069 && eh->elf.root.type == bfd_link_hash_undefined)
5070 {
5071 eh->elf.root.type = bfd_link_hash_undefweak;
5072 eh->was_undefined = 1;
5073 htab->twiddled_syms = 1;
5074 }
5075 }
5076
5077 return TRUE;
5078 }
5079
5080 /* Set up opd section info and abiversion for IBFD, and process list
5081 of dot-symbols we made in link_hash_newfunc. */
5082
5083 static bfd_boolean
ppc64_elf_before_check_relocs(bfd * ibfd,struct bfd_link_info * info)5084 ppc64_elf_before_check_relocs (bfd *ibfd, struct bfd_link_info *info)
5085 {
5086 struct ppc_link_hash_table *htab;
5087 struct ppc_link_hash_entry **p, *eh;
5088 asection *opd = bfd_get_section_by_name (ibfd, ".opd");
5089
5090 if (opd != NULL && opd->size != 0)
5091 {
5092 if (abiversion (ibfd) == 0)
5093 set_abiversion (ibfd, 1);
5094 else if (abiversion (ibfd) >= 2)
5095 {
5096 info->callbacks->einfo (_("%P: %B .opd not allowed in ABI"
5097 " version %d\n"),
5098 ibfd, abiversion (ibfd));
5099 bfd_set_error (bfd_error_bad_value);
5100 return FALSE;
5101 }
5102
5103 if ((ibfd->flags & DYNAMIC) == 0
5104 && (opd->flags & SEC_RELOC) != 0
5105 && opd->reloc_count != 0
5106 && !bfd_is_abs_section (opd->output_section))
5107 {
5108 /* Garbage collection needs some extra help with .opd sections.
5109 We don't want to necessarily keep everything referenced by
5110 relocs in .opd, as that would keep all functions. Instead,
5111 if we reference an .opd symbol (a function descriptor), we
5112 want to keep the function code symbol's section. This is
5113 easy for global symbols, but for local syms we need to keep
5114 information about the associated function section. */
5115 bfd_size_type amt;
5116 asection **opd_sym_map;
5117
5118 amt = OPD_NDX (opd->size) * sizeof (*opd_sym_map);
5119 opd_sym_map = bfd_zalloc (ibfd, amt);
5120 if (opd_sym_map == NULL)
5121 return FALSE;
5122 ppc64_elf_section_data (opd)->u.opd.func_sec = opd_sym_map;
5123 BFD_ASSERT (ppc64_elf_section_data (opd)->sec_type == sec_normal);
5124 ppc64_elf_section_data (opd)->sec_type = sec_opd;
5125 }
5126 }
5127
5128 if (!is_ppc64_elf (info->output_bfd))
5129 return TRUE;
5130 htab = ppc_hash_table (info);
5131 if (htab == NULL)
5132 return FALSE;
5133
5134 /* For input files without an explicit abiversion in e_flags
5135 we should have flagged any with symbol st_other bits set
5136 as ELFv1 and above flagged those with .opd as ELFv2.
5137 Set the output abiversion if not yet set, and for any input
5138 still ambiguous, take its abiversion from the output.
5139 Differences in ABI are reported later. */
5140 if (abiversion (info->output_bfd) == 0)
5141 set_abiversion (info->output_bfd, abiversion (ibfd));
5142 else if (abiversion (ibfd) == 0)
5143 set_abiversion (ibfd, abiversion (info->output_bfd));
5144
5145 p = &htab->dot_syms;
5146 while ((eh = *p) != NULL)
5147 {
5148 *p = NULL;
5149 if (&eh->elf == htab->elf.hgot)
5150 ;
5151 else if (htab->elf.hgot == NULL
5152 && strcmp (eh->elf.root.root.string, ".TOC.") == 0)
5153 htab->elf.hgot = &eh->elf;
5154 else if (!add_symbol_adjust (eh, info))
5155 return FALSE;
5156 p = &eh->u.next_dot_sym;
5157 }
5158
5159 /* Clear the list for non-ppc64 input files. */
5160 p = &htab->dot_syms;
5161 while ((eh = *p) != NULL)
5162 {
5163 *p = NULL;
5164 p = &eh->u.next_dot_sym;
5165 }
5166
5167 /* We need to fix the undefs list for any syms we have twiddled to
5168 undefweak. */
5169 if (htab->twiddled_syms)
5170 {
5171 bfd_link_repair_undef_list (&htab->elf.root);
5172 htab->twiddled_syms = 0;
5173 }
5174 return TRUE;
5175 }
5176
5177 /* Undo hash table changes when an --as-needed input file is determined
5178 not to be needed. */
5179
5180 static bfd_boolean
ppc64_elf_notice_as_needed(bfd * ibfd,struct bfd_link_info * info,enum notice_asneeded_action act)5181 ppc64_elf_notice_as_needed (bfd *ibfd,
5182 struct bfd_link_info *info,
5183 enum notice_asneeded_action act)
5184 {
5185 if (act == notice_not_needed)
5186 {
5187 struct ppc_link_hash_table *htab = ppc_hash_table (info);
5188
5189 if (htab == NULL)
5190 return FALSE;
5191
5192 htab->dot_syms = NULL;
5193 }
5194 return _bfd_elf_notice_as_needed (ibfd, info, act);
5195 }
5196
5197 /* If --just-symbols against a final linked binary, then assume we need
5198 toc adjusting stubs when calling functions defined there. */
5199
5200 static void
ppc64_elf_link_just_syms(asection * sec,struct bfd_link_info * info)5201 ppc64_elf_link_just_syms (asection *sec, struct bfd_link_info *info)
5202 {
5203 if ((sec->flags & SEC_CODE) != 0
5204 && (sec->owner->flags & (EXEC_P | DYNAMIC)) != 0
5205 && is_ppc64_elf (sec->owner))
5206 {
5207 if (abiversion (sec->owner) >= 2
5208 || bfd_get_section_by_name (sec->owner, ".opd") != NULL)
5209 sec->has_toc_reloc = 1;
5210 }
5211 _bfd_elf_link_just_syms (sec, info);
5212 }
5213
5214 static struct plt_entry **
update_local_sym_info(bfd * abfd,Elf_Internal_Shdr * symtab_hdr,unsigned long r_symndx,bfd_vma r_addend,int tls_type)5215 update_local_sym_info (bfd *abfd, Elf_Internal_Shdr *symtab_hdr,
5216 unsigned long r_symndx, bfd_vma r_addend, int tls_type)
5217 {
5218 struct got_entry **local_got_ents = elf_local_got_ents (abfd);
5219 struct plt_entry **local_plt;
5220 unsigned char *local_got_tls_masks;
5221
5222 if (local_got_ents == NULL)
5223 {
5224 bfd_size_type size = symtab_hdr->sh_info;
5225
5226 size *= (sizeof (*local_got_ents)
5227 + sizeof (*local_plt)
5228 + sizeof (*local_got_tls_masks));
5229 local_got_ents = bfd_zalloc (abfd, size);
5230 if (local_got_ents == NULL)
5231 return NULL;
5232 elf_local_got_ents (abfd) = local_got_ents;
5233 }
5234
5235 if ((tls_type & (PLT_IFUNC | TLS_EXPLICIT)) == 0)
5236 {
5237 struct got_entry *ent;
5238
5239 for (ent = local_got_ents[r_symndx]; ent != NULL; ent = ent->next)
5240 if (ent->addend == r_addend
5241 && ent->owner == abfd
5242 && ent->tls_type == tls_type)
5243 break;
5244 if (ent == NULL)
5245 {
5246 bfd_size_type amt = sizeof (*ent);
5247 ent = bfd_alloc (abfd, amt);
5248 if (ent == NULL)
5249 return FALSE;
5250 ent->next = local_got_ents[r_symndx];
5251 ent->addend = r_addend;
5252 ent->owner = abfd;
5253 ent->tls_type = tls_type;
5254 ent->is_indirect = FALSE;
5255 ent->got.refcount = 0;
5256 local_got_ents[r_symndx] = ent;
5257 }
5258 ent->got.refcount += 1;
5259 }
5260
5261 local_plt = (struct plt_entry **) (local_got_ents + symtab_hdr->sh_info);
5262 local_got_tls_masks = (unsigned char *) (local_plt + symtab_hdr->sh_info);
5263 local_got_tls_masks[r_symndx] |= tls_type;
5264
5265 return local_plt + r_symndx;
5266 }
5267
5268 static bfd_boolean
update_plt_info(bfd * abfd,struct plt_entry ** plist,bfd_vma addend)5269 update_plt_info (bfd *abfd, struct plt_entry **plist, bfd_vma addend)
5270 {
5271 struct plt_entry *ent;
5272
5273 for (ent = *plist; ent != NULL; ent = ent->next)
5274 if (ent->addend == addend)
5275 break;
5276 if (ent == NULL)
5277 {
5278 bfd_size_type amt = sizeof (*ent);
5279 ent = bfd_alloc (abfd, amt);
5280 if (ent == NULL)
5281 return FALSE;
5282 ent->next = *plist;
5283 ent->addend = addend;
5284 ent->plt.refcount = 0;
5285 *plist = ent;
5286 }
5287 ent->plt.refcount += 1;
5288 return TRUE;
5289 }
5290
5291 static bfd_boolean
is_branch_reloc(enum elf_ppc64_reloc_type r_type)5292 is_branch_reloc (enum elf_ppc64_reloc_type r_type)
5293 {
5294 return (r_type == R_PPC64_REL24
5295 || r_type == R_PPC64_REL14
5296 || r_type == R_PPC64_REL14_BRTAKEN
5297 || r_type == R_PPC64_REL14_BRNTAKEN
5298 || r_type == R_PPC64_ADDR24
5299 || r_type == R_PPC64_ADDR14
5300 || r_type == R_PPC64_ADDR14_BRTAKEN
5301 || r_type == R_PPC64_ADDR14_BRNTAKEN);
5302 }
5303
5304 /* Look through the relocs for a section during the first phase, and
5305 calculate needed space in the global offset table, procedure
5306 linkage table, and dynamic reloc sections. */
5307
5308 static bfd_boolean
ppc64_elf_check_relocs(bfd * abfd,struct bfd_link_info * info,asection * sec,const Elf_Internal_Rela * relocs)5309 ppc64_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
5310 asection *sec, const Elf_Internal_Rela *relocs)
5311 {
5312 struct ppc_link_hash_table *htab;
5313 Elf_Internal_Shdr *symtab_hdr;
5314 struct elf_link_hash_entry **sym_hashes;
5315 const Elf_Internal_Rela *rel;
5316 const Elf_Internal_Rela *rel_end;
5317 asection *sreloc;
5318 asection **opd_sym_map;
5319 struct elf_link_hash_entry *tga, *dottga;
5320
5321 if (bfd_link_relocatable (info))
5322 return TRUE;
5323
5324 /* Don't do anything special with non-loaded, non-alloced sections.
5325 In particular, any relocs in such sections should not affect GOT
5326 and PLT reference counting (ie. we don't allow them to create GOT
5327 or PLT entries), there's no possibility or desire to optimize TLS
5328 relocs, and there's not much point in propagating relocs to shared
5329 libs that the dynamic linker won't relocate. */
5330 if ((sec->flags & SEC_ALLOC) == 0)
5331 return TRUE;
5332
5333 BFD_ASSERT (is_ppc64_elf (abfd));
5334
5335 htab = ppc_hash_table (info);
5336 if (htab == NULL)
5337 return FALSE;
5338
5339 tga = elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
5340 FALSE, FALSE, TRUE);
5341 dottga = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
5342 FALSE, FALSE, TRUE);
5343 symtab_hdr = &elf_symtab_hdr (abfd);
5344 sym_hashes = elf_sym_hashes (abfd);
5345 sreloc = NULL;
5346 opd_sym_map = NULL;
5347 if (ppc64_elf_section_data (sec) != NULL
5348 && ppc64_elf_section_data (sec)->sec_type == sec_opd)
5349 opd_sym_map = ppc64_elf_section_data (sec)->u.opd.func_sec;
5350
5351 rel_end = relocs + sec->reloc_count;
5352 for (rel = relocs; rel < rel_end; rel++)
5353 {
5354 unsigned long r_symndx;
5355 struct elf_link_hash_entry *h;
5356 enum elf_ppc64_reloc_type r_type;
5357 int tls_type;
5358 struct _ppc64_elf_section_data *ppc64_sec;
5359 struct plt_entry **ifunc, **plt_list;
5360
5361 r_symndx = ELF64_R_SYM (rel->r_info);
5362 if (r_symndx < symtab_hdr->sh_info)
5363 h = NULL;
5364 else
5365 {
5366 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
5367 h = elf_follow_link (h);
5368
5369 /* PR15323, ref flags aren't set for references in the same
5370 object. */
5371 h->root.non_ir_ref = 1;
5372
5373 if (h == htab->elf.hgot)
5374 sec->has_toc_reloc = 1;
5375 }
5376
5377 tls_type = 0;
5378 ifunc = NULL;
5379 if (h != NULL)
5380 {
5381 if (h->type == STT_GNU_IFUNC)
5382 {
5383 h->needs_plt = 1;
5384 ifunc = &h->plt.plist;
5385 }
5386 }
5387 else
5388 {
5389 Elf_Internal_Sym *isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5390 abfd, r_symndx);
5391 if (isym == NULL)
5392 return FALSE;
5393
5394 if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
5395 {
5396 ifunc = update_local_sym_info (abfd, symtab_hdr, r_symndx,
5397 rel->r_addend, PLT_IFUNC);
5398 if (ifunc == NULL)
5399 return FALSE;
5400 }
5401 }
5402
5403 r_type = ELF64_R_TYPE (rel->r_info);
5404 switch (r_type)
5405 {
5406 case R_PPC64_TLSGD:
5407 case R_PPC64_TLSLD:
5408 /* These special tls relocs tie a call to __tls_get_addr with
5409 its parameter symbol. */
5410 break;
5411
5412 case R_PPC64_GOT_TLSLD16:
5413 case R_PPC64_GOT_TLSLD16_LO:
5414 case R_PPC64_GOT_TLSLD16_HI:
5415 case R_PPC64_GOT_TLSLD16_HA:
5416 tls_type = TLS_TLS | TLS_LD;
5417 goto dogottls;
5418
5419 case R_PPC64_GOT_TLSGD16:
5420 case R_PPC64_GOT_TLSGD16_LO:
5421 case R_PPC64_GOT_TLSGD16_HI:
5422 case R_PPC64_GOT_TLSGD16_HA:
5423 tls_type = TLS_TLS | TLS_GD;
5424 goto dogottls;
5425
5426 case R_PPC64_GOT_TPREL16_DS:
5427 case R_PPC64_GOT_TPREL16_LO_DS:
5428 case R_PPC64_GOT_TPREL16_HI:
5429 case R_PPC64_GOT_TPREL16_HA:
5430 if (bfd_link_pic (info))
5431 info->flags |= DF_STATIC_TLS;
5432 tls_type = TLS_TLS | TLS_TPREL;
5433 goto dogottls;
5434
5435 case R_PPC64_GOT_DTPREL16_DS:
5436 case R_PPC64_GOT_DTPREL16_LO_DS:
5437 case R_PPC64_GOT_DTPREL16_HI:
5438 case R_PPC64_GOT_DTPREL16_HA:
5439 tls_type = TLS_TLS | TLS_DTPREL;
5440 dogottls:
5441 sec->has_tls_reloc = 1;
5442 /* Fall thru */
5443
5444 case R_PPC64_GOT16:
5445 case R_PPC64_GOT16_DS:
5446 case R_PPC64_GOT16_HA:
5447 case R_PPC64_GOT16_HI:
5448 case R_PPC64_GOT16_LO:
5449 case R_PPC64_GOT16_LO_DS:
5450 /* This symbol requires a global offset table entry. */
5451 sec->has_toc_reloc = 1;
5452 if (r_type == R_PPC64_GOT_TLSLD16
5453 || r_type == R_PPC64_GOT_TLSGD16
5454 || r_type == R_PPC64_GOT_TPREL16_DS
5455 || r_type == R_PPC64_GOT_DTPREL16_DS
5456 || r_type == R_PPC64_GOT16
5457 || r_type == R_PPC64_GOT16_DS)
5458 {
5459 htab->do_multi_toc = 1;
5460 ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5461 }
5462
5463 if (ppc64_elf_tdata (abfd)->got == NULL
5464 && !create_got_section (abfd, info))
5465 return FALSE;
5466
5467 if (h != NULL)
5468 {
5469 struct ppc_link_hash_entry *eh;
5470 struct got_entry *ent;
5471
5472 eh = (struct ppc_link_hash_entry *) h;
5473 for (ent = eh->elf.got.glist; ent != NULL; ent = ent->next)
5474 if (ent->addend == rel->r_addend
5475 && ent->owner == abfd
5476 && ent->tls_type == tls_type)
5477 break;
5478 if (ent == NULL)
5479 {
5480 bfd_size_type amt = sizeof (*ent);
5481 ent = bfd_alloc (abfd, amt);
5482 if (ent == NULL)
5483 return FALSE;
5484 ent->next = eh->elf.got.glist;
5485 ent->addend = rel->r_addend;
5486 ent->owner = abfd;
5487 ent->tls_type = tls_type;
5488 ent->is_indirect = FALSE;
5489 ent->got.refcount = 0;
5490 eh->elf.got.glist = ent;
5491 }
5492 ent->got.refcount += 1;
5493 eh->tls_mask |= tls_type;
5494 }
5495 else
5496 /* This is a global offset table entry for a local symbol. */
5497 if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5498 rel->r_addend, tls_type))
5499 return FALSE;
5500
5501 /* We may also need a plt entry if the symbol turns out to be
5502 an ifunc. */
5503 if (h != NULL && !bfd_link_pic (info) && abiversion (abfd) != 1)
5504 {
5505 if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5506 return FALSE;
5507 }
5508 break;
5509
5510 case R_PPC64_PLT16_HA:
5511 case R_PPC64_PLT16_HI:
5512 case R_PPC64_PLT16_LO:
5513 case R_PPC64_PLT32:
5514 case R_PPC64_PLT64:
5515 /* This symbol requires a procedure linkage table entry. */
5516 plt_list = ifunc;
5517 if (h != NULL)
5518 {
5519 h->needs_plt = 1;
5520 if (h->root.root.string[0] == '.'
5521 && h->root.root.string[1] != '\0')
5522 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5523 plt_list = &h->plt.plist;
5524 }
5525 if (plt_list == NULL)
5526 {
5527 /* It does not make sense to have a procedure linkage
5528 table entry for a non-ifunc local symbol. */
5529 info->callbacks->einfo
5530 (_("%P: %H: %s reloc against local symbol\n"),
5531 abfd, sec, rel->r_offset,
5532 ppc64_elf_howto_table[r_type]->name);
5533 bfd_set_error (bfd_error_bad_value);
5534 return FALSE;
5535 }
5536 if (!update_plt_info (abfd, plt_list, rel->r_addend))
5537 return FALSE;
5538 break;
5539
5540 /* The following relocations don't need to propagate the
5541 relocation if linking a shared object since they are
5542 section relative. */
5543 case R_PPC64_SECTOFF:
5544 case R_PPC64_SECTOFF_LO:
5545 case R_PPC64_SECTOFF_HI:
5546 case R_PPC64_SECTOFF_HA:
5547 case R_PPC64_SECTOFF_DS:
5548 case R_PPC64_SECTOFF_LO_DS:
5549 case R_PPC64_DTPREL16:
5550 case R_PPC64_DTPREL16_LO:
5551 case R_PPC64_DTPREL16_HI:
5552 case R_PPC64_DTPREL16_HA:
5553 case R_PPC64_DTPREL16_DS:
5554 case R_PPC64_DTPREL16_LO_DS:
5555 case R_PPC64_DTPREL16_HIGH:
5556 case R_PPC64_DTPREL16_HIGHA:
5557 case R_PPC64_DTPREL16_HIGHER:
5558 case R_PPC64_DTPREL16_HIGHERA:
5559 case R_PPC64_DTPREL16_HIGHEST:
5560 case R_PPC64_DTPREL16_HIGHESTA:
5561 break;
5562
5563 /* Nor do these. */
5564 case R_PPC64_REL16:
5565 case R_PPC64_REL16_LO:
5566 case R_PPC64_REL16_HI:
5567 case R_PPC64_REL16_HA:
5568 case R_PPC64_REL16DX_HA:
5569 break;
5570
5571 /* Not supported as a dynamic relocation. */
5572 case R_PPC64_ADDR64_LOCAL:
5573 if (bfd_link_pic (info))
5574 {
5575 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
5576 ppc_howto_init ();
5577 info->callbacks->einfo (_("%P: %H: %s reloc unsupported "
5578 "in shared libraries and PIEs.\n"),
5579 abfd, sec, rel->r_offset,
5580 ppc64_elf_howto_table[r_type]->name);
5581 bfd_set_error (bfd_error_bad_value);
5582 return FALSE;
5583 }
5584 break;
5585
5586 case R_PPC64_TOC16:
5587 case R_PPC64_TOC16_DS:
5588 htab->do_multi_toc = 1;
5589 ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5590 case R_PPC64_TOC16_LO:
5591 case R_PPC64_TOC16_HI:
5592 case R_PPC64_TOC16_HA:
5593 case R_PPC64_TOC16_LO_DS:
5594 sec->has_toc_reloc = 1;
5595 break;
5596
5597 /* Marker reloc. */
5598 case R_PPC64_ENTRY:
5599 break;
5600
5601 /* This relocation describes the C++ object vtable hierarchy.
5602 Reconstruct it for later use during GC. */
5603 case R_PPC64_GNU_VTINHERIT:
5604 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
5605 return FALSE;
5606 break;
5607
5608 /* This relocation describes which C++ vtable entries are actually
5609 used. Record for later use during GC. */
5610 case R_PPC64_GNU_VTENTRY:
5611 BFD_ASSERT (h != NULL);
5612 if (h != NULL
5613 && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
5614 return FALSE;
5615 break;
5616
5617 case R_PPC64_REL14:
5618 case R_PPC64_REL14_BRTAKEN:
5619 case R_PPC64_REL14_BRNTAKEN:
5620 {
5621 asection *dest = NULL;
5622
5623 /* Heuristic: If jumping outside our section, chances are
5624 we are going to need a stub. */
5625 if (h != NULL)
5626 {
5627 /* If the sym is weak it may be overridden later, so
5628 don't assume we know where a weak sym lives. */
5629 if (h->root.type == bfd_link_hash_defined)
5630 dest = h->root.u.def.section;
5631 }
5632 else
5633 {
5634 Elf_Internal_Sym *isym;
5635
5636 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5637 abfd, r_symndx);
5638 if (isym == NULL)
5639 return FALSE;
5640
5641 dest = bfd_section_from_elf_index (abfd, isym->st_shndx);
5642 }
5643
5644 if (dest != sec)
5645 ppc64_elf_section_data (sec)->has_14bit_branch = 1;
5646 }
5647 /* Fall through. */
5648
5649 case R_PPC64_REL24:
5650 plt_list = ifunc;
5651 if (h != NULL)
5652 {
5653 h->needs_plt = 1;
5654 if (h->root.root.string[0] == '.'
5655 && h->root.root.string[1] != '\0')
5656 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5657
5658 if (h == tga || h == dottga)
5659 {
5660 sec->has_tls_reloc = 1;
5661 if (rel != relocs
5662 && (ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSGD
5663 || ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSLD))
5664 /* We have a new-style __tls_get_addr call with
5665 a marker reloc. */
5666 ;
5667 else
5668 /* Mark this section as having an old-style call. */
5669 sec->has_tls_get_addr_call = 1;
5670 }
5671 plt_list = &h->plt.plist;
5672 }
5673
5674 /* We may need a .plt entry if the function this reloc
5675 refers to is in a shared lib. */
5676 if (plt_list
5677 && !update_plt_info (abfd, plt_list, rel->r_addend))
5678 return FALSE;
5679 break;
5680
5681 case R_PPC64_ADDR14:
5682 case R_PPC64_ADDR14_BRNTAKEN:
5683 case R_PPC64_ADDR14_BRTAKEN:
5684 case R_PPC64_ADDR24:
5685 goto dodyn;
5686
5687 case R_PPC64_TPREL64:
5688 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_TPREL;
5689 if (bfd_link_pic (info))
5690 info->flags |= DF_STATIC_TLS;
5691 goto dotlstoc;
5692
5693 case R_PPC64_DTPMOD64:
5694 if (rel + 1 < rel_end
5695 && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
5696 && rel[1].r_offset == rel->r_offset + 8)
5697 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_GD;
5698 else
5699 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_LD;
5700 goto dotlstoc;
5701
5702 case R_PPC64_DTPREL64:
5703 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_DTPREL;
5704 if (rel != relocs
5705 && rel[-1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPMOD64)
5706 && rel[-1].r_offset == rel->r_offset - 8)
5707 /* This is the second reloc of a dtpmod, dtprel pair.
5708 Don't mark with TLS_DTPREL. */
5709 goto dodyn;
5710
5711 dotlstoc:
5712 sec->has_tls_reloc = 1;
5713 if (h != NULL)
5714 {
5715 struct ppc_link_hash_entry *eh;
5716 eh = (struct ppc_link_hash_entry *) h;
5717 eh->tls_mask |= tls_type;
5718 }
5719 else
5720 if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5721 rel->r_addend, tls_type))
5722 return FALSE;
5723
5724 ppc64_sec = ppc64_elf_section_data (sec);
5725 if (ppc64_sec->sec_type != sec_toc)
5726 {
5727 bfd_size_type amt;
5728
5729 /* One extra to simplify get_tls_mask. */
5730 amt = sec->size * sizeof (unsigned) / 8 + sizeof (unsigned);
5731 ppc64_sec->u.toc.symndx = bfd_zalloc (abfd, amt);
5732 if (ppc64_sec->u.toc.symndx == NULL)
5733 return FALSE;
5734 amt = sec->size * sizeof (bfd_vma) / 8;
5735 ppc64_sec->u.toc.add = bfd_zalloc (abfd, amt);
5736 if (ppc64_sec->u.toc.add == NULL)
5737 return FALSE;
5738 BFD_ASSERT (ppc64_sec->sec_type == sec_normal);
5739 ppc64_sec->sec_type = sec_toc;
5740 }
5741 BFD_ASSERT (rel->r_offset % 8 == 0);
5742 ppc64_sec->u.toc.symndx[rel->r_offset / 8] = r_symndx;
5743 ppc64_sec->u.toc.add[rel->r_offset / 8] = rel->r_addend;
5744
5745 /* Mark the second slot of a GD or LD entry.
5746 -1 to indicate GD and -2 to indicate LD. */
5747 if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_GD))
5748 ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -1;
5749 else if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_LD))
5750 ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -2;
5751 goto dodyn;
5752
5753 case R_PPC64_TPREL16:
5754 case R_PPC64_TPREL16_LO:
5755 case R_PPC64_TPREL16_HI:
5756 case R_PPC64_TPREL16_HA:
5757 case R_PPC64_TPREL16_DS:
5758 case R_PPC64_TPREL16_LO_DS:
5759 case R_PPC64_TPREL16_HIGH:
5760 case R_PPC64_TPREL16_HIGHA:
5761 case R_PPC64_TPREL16_HIGHER:
5762 case R_PPC64_TPREL16_HIGHERA:
5763 case R_PPC64_TPREL16_HIGHEST:
5764 case R_PPC64_TPREL16_HIGHESTA:
5765 if (bfd_link_pic (info))
5766 {
5767 info->flags |= DF_STATIC_TLS;
5768 goto dodyn;
5769 }
5770 break;
5771
5772 case R_PPC64_ADDR64:
5773 if (opd_sym_map != NULL
5774 && rel + 1 < rel_end
5775 && ELF64_R_TYPE ((rel + 1)->r_info) == R_PPC64_TOC)
5776 {
5777 if (h != NULL)
5778 {
5779 if (h->root.root.string[0] == '.'
5780 && h->root.root.string[1] != 0
5781 && lookup_fdh ((struct ppc_link_hash_entry *) h, htab))
5782 ;
5783 else
5784 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5785 }
5786 else
5787 {
5788 asection *s;
5789 Elf_Internal_Sym *isym;
5790
5791 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5792 abfd, r_symndx);
5793 if (isym == NULL)
5794 return FALSE;
5795
5796 s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5797 if (s != NULL && s != sec)
5798 opd_sym_map[OPD_NDX (rel->r_offset)] = s;
5799 }
5800 }
5801 /* Fall through. */
5802
5803 case R_PPC64_ADDR16:
5804 case R_PPC64_ADDR16_DS:
5805 case R_PPC64_ADDR16_HA:
5806 case R_PPC64_ADDR16_HI:
5807 case R_PPC64_ADDR16_HIGH:
5808 case R_PPC64_ADDR16_HIGHA:
5809 case R_PPC64_ADDR16_HIGHER:
5810 case R_PPC64_ADDR16_HIGHERA:
5811 case R_PPC64_ADDR16_HIGHEST:
5812 case R_PPC64_ADDR16_HIGHESTA:
5813 case R_PPC64_ADDR16_LO:
5814 case R_PPC64_ADDR16_LO_DS:
5815 if (h != NULL && !bfd_link_pic (info) && abiversion (abfd) != 1
5816 && rel->r_addend == 0)
5817 {
5818 /* We may need a .plt entry if this reloc refers to a
5819 function in a shared lib. */
5820 if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5821 return FALSE;
5822 h->pointer_equality_needed = 1;
5823 }
5824 /* Fall through. */
5825
5826 case R_PPC64_REL30:
5827 case R_PPC64_REL32:
5828 case R_PPC64_REL64:
5829 case R_PPC64_ADDR32:
5830 case R_PPC64_UADDR16:
5831 case R_PPC64_UADDR32:
5832 case R_PPC64_UADDR64:
5833 case R_PPC64_TOC:
5834 if (h != NULL && !bfd_link_pic (info))
5835 /* We may need a copy reloc. */
5836 h->non_got_ref = 1;
5837
5838 /* Don't propagate .opd relocs. */
5839 if (NO_OPD_RELOCS && opd_sym_map != NULL)
5840 break;
5841
5842 /* If we are creating a shared library, and this is a reloc
5843 against a global symbol, or a non PC relative reloc
5844 against a local symbol, then we need to copy the reloc
5845 into the shared library. However, if we are linking with
5846 -Bsymbolic, we do not need to copy a reloc against a
5847 global symbol which is defined in an object we are
5848 including in the link (i.e., DEF_REGULAR is set). At
5849 this point we have not seen all the input files, so it is
5850 possible that DEF_REGULAR is not set now but will be set
5851 later (it is never cleared). In case of a weak definition,
5852 DEF_REGULAR may be cleared later by a strong definition in
5853 a shared library. We account for that possibility below by
5854 storing information in the dyn_relocs field of the hash
5855 table entry. A similar situation occurs when creating
5856 shared libraries and symbol visibility changes render the
5857 symbol local.
5858
5859 If on the other hand, we are creating an executable, we
5860 may need to keep relocations for symbols satisfied by a
5861 dynamic library if we manage to avoid copy relocs for the
5862 symbol. */
5863 dodyn:
5864 if ((bfd_link_pic (info)
5865 && (must_be_dyn_reloc (info, r_type)
5866 || (h != NULL
5867 && (!SYMBOLIC_BIND (info, h)
5868 || h->root.type == bfd_link_hash_defweak
5869 || !h->def_regular))))
5870 || (ELIMINATE_COPY_RELOCS
5871 && !bfd_link_pic (info)
5872 && h != NULL
5873 && (h->root.type == bfd_link_hash_defweak
5874 || !h->def_regular))
5875 || (!bfd_link_pic (info)
5876 && ifunc != NULL))
5877 {
5878 /* We must copy these reloc types into the output file.
5879 Create a reloc section in dynobj and make room for
5880 this reloc. */
5881 if (sreloc == NULL)
5882 {
5883 sreloc = _bfd_elf_make_dynamic_reloc_section
5884 (sec, htab->elf.dynobj, 3, abfd, /*rela?*/ TRUE);
5885
5886 if (sreloc == NULL)
5887 return FALSE;
5888 }
5889
5890 /* If this is a global symbol, we count the number of
5891 relocations we need for this symbol. */
5892 if (h != NULL)
5893 {
5894 struct elf_dyn_relocs *p;
5895 struct elf_dyn_relocs **head;
5896
5897 head = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
5898 p = *head;
5899 if (p == NULL || p->sec != sec)
5900 {
5901 p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5902 if (p == NULL)
5903 return FALSE;
5904 p->next = *head;
5905 *head = p;
5906 p->sec = sec;
5907 p->count = 0;
5908 p->pc_count = 0;
5909 }
5910 p->count += 1;
5911 if (!must_be_dyn_reloc (info, r_type))
5912 p->pc_count += 1;
5913 }
5914 else
5915 {
5916 /* Track dynamic relocs needed for local syms too.
5917 We really need local syms available to do this
5918 easily. Oh well. */
5919 struct ppc_dyn_relocs *p;
5920 struct ppc_dyn_relocs **head;
5921 bfd_boolean is_ifunc;
5922 asection *s;
5923 void *vpp;
5924 Elf_Internal_Sym *isym;
5925
5926 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5927 abfd, r_symndx);
5928 if (isym == NULL)
5929 return FALSE;
5930
5931 s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5932 if (s == NULL)
5933 s = sec;
5934
5935 vpp = &elf_section_data (s)->local_dynrel;
5936 head = (struct ppc_dyn_relocs **) vpp;
5937 is_ifunc = ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC;
5938 p = *head;
5939 if (p != NULL && p->sec == sec && p->ifunc != is_ifunc)
5940 p = p->next;
5941 if (p == NULL || p->sec != sec || p->ifunc != is_ifunc)
5942 {
5943 p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5944 if (p == NULL)
5945 return FALSE;
5946 p->next = *head;
5947 *head = p;
5948 p->sec = sec;
5949 p->ifunc = is_ifunc;
5950 p->count = 0;
5951 }
5952 p->count += 1;
5953 }
5954 }
5955 break;
5956
5957 default:
5958 break;
5959 }
5960 }
5961
5962 return TRUE;
5963 }
5964
5965 /* Merge backend specific data from an object file to the output
5966 object file when linking. */
5967
5968 static bfd_boolean
ppc64_elf_merge_private_bfd_data(bfd * ibfd,bfd * obfd)5969 ppc64_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
5970 {
5971 unsigned long iflags, oflags;
5972
5973 if ((ibfd->flags & BFD_LINKER_CREATED) != 0)
5974 return TRUE;
5975
5976 if (!is_ppc64_elf (ibfd) || !is_ppc64_elf (obfd))
5977 return TRUE;
5978
5979 if (!_bfd_generic_verify_endian_match (ibfd, obfd))
5980 return FALSE;
5981
5982 iflags = elf_elfheader (ibfd)->e_flags;
5983 oflags = elf_elfheader (obfd)->e_flags;
5984
5985 if (iflags & ~EF_PPC64_ABI)
5986 {
5987 (*_bfd_error_handler)
5988 (_("%B uses unknown e_flags 0x%lx"), ibfd, iflags);
5989 bfd_set_error (bfd_error_bad_value);
5990 return FALSE;
5991 }
5992 else if (iflags != oflags && iflags != 0)
5993 {
5994 (*_bfd_error_handler)
5995 (_("%B: ABI version %ld is not compatible with ABI version %ld output"),
5996 ibfd, iflags, oflags);
5997 bfd_set_error (bfd_error_bad_value);
5998 return FALSE;
5999 }
6000
6001 _bfd_elf_ppc_merge_fp_attributes (ibfd, obfd);
6002
6003 /* Merge Tag_compatibility attributes and any common GNU ones. */
6004 _bfd_elf_merge_object_attributes (ibfd, obfd);
6005
6006 return TRUE;
6007 }
6008
6009 static bfd_boolean
ppc64_elf_print_private_bfd_data(bfd * abfd,void * ptr)6010 ppc64_elf_print_private_bfd_data (bfd *abfd, void *ptr)
6011 {
6012 /* Print normal ELF private data. */
6013 _bfd_elf_print_private_bfd_data (abfd, ptr);
6014
6015 if (elf_elfheader (abfd)->e_flags != 0)
6016 {
6017 FILE *file = ptr;
6018
6019 /* xgettext:c-format */
6020 fprintf (file, _("private flags = 0x%lx:"),
6021 elf_elfheader (abfd)->e_flags);
6022
6023 if ((elf_elfheader (abfd)->e_flags & EF_PPC64_ABI) != 0)
6024 fprintf (file, _(" [abiv%ld]"),
6025 elf_elfheader (abfd)->e_flags & EF_PPC64_ABI);
6026 fputc ('\n', file);
6027 }
6028
6029 return TRUE;
6030 }
6031
6032 /* OFFSET in OPD_SEC specifies a function descriptor. Return the address
6033 of the code entry point, and its section, which must be in the same
6034 object as OPD_SEC. Returns (bfd_vma) -1 on error. */
6035
6036 static bfd_vma
opd_entry_value(asection * opd_sec,bfd_vma offset,asection ** code_sec,bfd_vma * code_off,bfd_boolean in_code_sec)6037 opd_entry_value (asection *opd_sec,
6038 bfd_vma offset,
6039 asection **code_sec,
6040 bfd_vma *code_off,
6041 bfd_boolean in_code_sec)
6042 {
6043 bfd *opd_bfd = opd_sec->owner;
6044 Elf_Internal_Rela *relocs;
6045 Elf_Internal_Rela *lo, *hi, *look;
6046 bfd_vma val;
6047
6048 /* No relocs implies we are linking a --just-symbols object, or looking
6049 at a final linked executable with addr2line or somesuch. */
6050 if (opd_sec->reloc_count == 0)
6051 {
6052 bfd_byte *contents = ppc64_elf_tdata (opd_bfd)->opd.contents;
6053
6054 if (contents == NULL)
6055 {
6056 if (!bfd_malloc_and_get_section (opd_bfd, opd_sec, &contents))
6057 return (bfd_vma) -1;
6058 ppc64_elf_tdata (opd_bfd)->opd.contents = contents;
6059 }
6060
6061 /* PR 17512: file: 64b9dfbb. */
6062 if (offset + 7 >= opd_sec->size || offset + 7 < offset)
6063 return (bfd_vma) -1;
6064
6065 val = bfd_get_64 (opd_bfd, contents + offset);
6066 if (code_sec != NULL)
6067 {
6068 asection *sec, *likely = NULL;
6069
6070 if (in_code_sec)
6071 {
6072 sec = *code_sec;
6073 if (sec->vma <= val
6074 && val < sec->vma + sec->size)
6075 likely = sec;
6076 else
6077 val = -1;
6078 }
6079 else
6080 for (sec = opd_bfd->sections; sec != NULL; sec = sec->next)
6081 if (sec->vma <= val
6082 && (sec->flags & SEC_LOAD) != 0
6083 && (sec->flags & SEC_ALLOC) != 0)
6084 likely = sec;
6085 if (likely != NULL)
6086 {
6087 *code_sec = likely;
6088 if (code_off != NULL)
6089 *code_off = val - likely->vma;
6090 }
6091 }
6092 return val;
6093 }
6094
6095 BFD_ASSERT (is_ppc64_elf (opd_bfd));
6096
6097 relocs = ppc64_elf_tdata (opd_bfd)->opd.relocs;
6098 if (relocs == NULL)
6099 relocs = _bfd_elf_link_read_relocs (opd_bfd, opd_sec, NULL, NULL, TRUE);
6100 /* PR 17512: file: df8e1fd6. */
6101 if (relocs == NULL)
6102 return (bfd_vma) -1;
6103
6104 /* Go find the opd reloc at the sym address. */
6105 lo = relocs;
6106 hi = lo + opd_sec->reloc_count - 1; /* ignore last reloc */
6107 val = (bfd_vma) -1;
6108 while (lo < hi)
6109 {
6110 look = lo + (hi - lo) / 2;
6111 if (look->r_offset < offset)
6112 lo = look + 1;
6113 else if (look->r_offset > offset)
6114 hi = look;
6115 else
6116 {
6117 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (opd_bfd);
6118
6119 if (ELF64_R_TYPE (look->r_info) == R_PPC64_ADDR64
6120 && ELF64_R_TYPE ((look + 1)->r_info) == R_PPC64_TOC)
6121 {
6122 unsigned long symndx = ELF64_R_SYM (look->r_info);
6123 asection *sec = NULL;
6124
6125 if (symndx >= symtab_hdr->sh_info
6126 && elf_sym_hashes (opd_bfd) != NULL)
6127 {
6128 struct elf_link_hash_entry **sym_hashes;
6129 struct elf_link_hash_entry *rh;
6130
6131 sym_hashes = elf_sym_hashes (opd_bfd);
6132 rh = sym_hashes[symndx - symtab_hdr->sh_info];
6133 if (rh != NULL)
6134 {
6135 rh = elf_follow_link (rh);
6136 if (rh->root.type != bfd_link_hash_defined
6137 && rh->root.type != bfd_link_hash_defweak)
6138 break;
6139 if (rh->root.u.def.section->owner == opd_bfd)
6140 {
6141 val = rh->root.u.def.value;
6142 sec = rh->root.u.def.section;
6143 }
6144 }
6145 }
6146
6147 if (sec == NULL)
6148 {
6149 Elf_Internal_Sym *sym;
6150
6151 if (symndx < symtab_hdr->sh_info)
6152 {
6153 sym = (Elf_Internal_Sym *) symtab_hdr->contents;
6154 if (sym == NULL)
6155 {
6156 size_t symcnt = symtab_hdr->sh_info;
6157 sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr,
6158 symcnt, 0,
6159 NULL, NULL, NULL);
6160 if (sym == NULL)
6161 break;
6162 symtab_hdr->contents = (bfd_byte *) sym;
6163 }
6164 sym += symndx;
6165 }
6166 else
6167 {
6168 sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr,
6169 1, symndx,
6170 NULL, NULL, NULL);
6171 if (sym == NULL)
6172 break;
6173 }
6174 sec = bfd_section_from_elf_index (opd_bfd, sym->st_shndx);
6175 if (sec == NULL)
6176 break;
6177 BFD_ASSERT ((sec->flags & SEC_MERGE) == 0);
6178 val = sym->st_value;
6179 }
6180
6181 val += look->r_addend;
6182 if (code_off != NULL)
6183 *code_off = val;
6184 if (code_sec != NULL)
6185 {
6186 if (in_code_sec && *code_sec != sec)
6187 return -1;
6188 else
6189 *code_sec = sec;
6190 }
6191 if (sec->output_section != NULL)
6192 val += sec->output_section->vma + sec->output_offset;
6193 }
6194 break;
6195 }
6196 }
6197
6198 return val;
6199 }
6200
6201 /* If the ELF symbol SYM might be a function in SEC, return the
6202 function size and set *CODE_OFF to the function's entry point,
6203 otherwise return zero. */
6204
6205 static bfd_size_type
ppc64_elf_maybe_function_sym(const asymbol * sym,asection * sec,bfd_vma * code_off)6206 ppc64_elf_maybe_function_sym (const asymbol *sym, asection *sec,
6207 bfd_vma *code_off)
6208 {
6209 bfd_size_type size;
6210
6211 if ((sym->flags & (BSF_SECTION_SYM | BSF_FILE | BSF_OBJECT
6212 | BSF_THREAD_LOCAL | BSF_RELC | BSF_SRELC)) != 0)
6213 return 0;
6214
6215 size = 0;
6216 if (!(sym->flags & BSF_SYNTHETIC))
6217 size = ((elf_symbol_type *) sym)->internal_elf_sym.st_size;
6218
6219 if (strcmp (sym->section->name, ".opd") == 0)
6220 {
6221 struct _opd_sec_data *opd = get_opd_info (sym->section);
6222 bfd_vma symval = sym->value;
6223
6224 if (opd != NULL
6225 && opd->adjust != NULL
6226 && elf_section_data (sym->section)->relocs != NULL)
6227 {
6228 /* opd_entry_value will use cached relocs that have been
6229 adjusted, but with raw symbols. That means both local
6230 and global symbols need adjusting. */
6231 long adjust = opd->adjust[OPD_NDX (symval)];
6232 if (adjust == -1)
6233 return 0;
6234 symval += adjust;
6235 }
6236
6237 if (opd_entry_value (sym->section, symval,
6238 &sec, code_off, TRUE) == (bfd_vma) -1)
6239 return 0;
6240 /* An old ABI binary with dot-syms has a size of 24 on the .opd
6241 symbol. This size has nothing to do with the code size of the
6242 function, which is what we're supposed to return, but the
6243 code size isn't available without looking up the dot-sym.
6244 However, doing that would be a waste of time particularly
6245 since elf_find_function will look at the dot-sym anyway.
6246 Now, elf_find_function will keep the largest size of any
6247 function sym found at the code address of interest, so return
6248 1 here to avoid it incorrectly caching a larger function size
6249 for a small function. This does mean we return the wrong
6250 size for a new-ABI function of size 24, but all that does is
6251 disable caching for such functions. */
6252 if (size == 24)
6253 size = 1;
6254 }
6255 else
6256 {
6257 if (sym->section != sec)
6258 return 0;
6259 *code_off = sym->value;
6260 }
6261 if (size == 0)
6262 size = 1;
6263 return size;
6264 }
6265
6266 /* Return true if symbol is defined in a regular object file. */
6267
6268 static bfd_boolean
is_static_defined(struct elf_link_hash_entry * h)6269 is_static_defined (struct elf_link_hash_entry *h)
6270 {
6271 return ((h->root.type == bfd_link_hash_defined
6272 || h->root.type == bfd_link_hash_defweak)
6273 && h->root.u.def.section != NULL
6274 && h->root.u.def.section->output_section != NULL);
6275 }
6276
6277 /* If FDH is a function descriptor symbol, return the associated code
6278 entry symbol if it is defined. Return NULL otherwise. */
6279
6280 static struct ppc_link_hash_entry *
defined_code_entry(struct ppc_link_hash_entry * fdh)6281 defined_code_entry (struct ppc_link_hash_entry *fdh)
6282 {
6283 if (fdh->is_func_descriptor)
6284 {
6285 struct ppc_link_hash_entry *fh = ppc_follow_link (fdh->oh);
6286 if (fh->elf.root.type == bfd_link_hash_defined
6287 || fh->elf.root.type == bfd_link_hash_defweak)
6288 return fh;
6289 }
6290 return NULL;
6291 }
6292
6293 /* If FH is a function code entry symbol, return the associated
6294 function descriptor symbol if it is defined. Return NULL otherwise. */
6295
6296 static struct ppc_link_hash_entry *
defined_func_desc(struct ppc_link_hash_entry * fh)6297 defined_func_desc (struct ppc_link_hash_entry *fh)
6298 {
6299 if (fh->oh != NULL
6300 && fh->oh->is_func_descriptor)
6301 {
6302 struct ppc_link_hash_entry *fdh = ppc_follow_link (fh->oh);
6303 if (fdh->elf.root.type == bfd_link_hash_defined
6304 || fdh->elf.root.type == bfd_link_hash_defweak)
6305 return fdh;
6306 }
6307 return NULL;
6308 }
6309
6310 /* Mark all our entry sym sections, both opd and code section. */
6311
6312 static void
ppc64_elf_gc_keep(struct bfd_link_info * info)6313 ppc64_elf_gc_keep (struct bfd_link_info *info)
6314 {
6315 struct ppc_link_hash_table *htab = ppc_hash_table (info);
6316 struct bfd_sym_chain *sym;
6317
6318 if (htab == NULL)
6319 return;
6320
6321 for (sym = info->gc_sym_list; sym != NULL; sym = sym->next)
6322 {
6323 struct ppc_link_hash_entry *eh, *fh;
6324 asection *sec;
6325
6326 eh = (struct ppc_link_hash_entry *)
6327 elf_link_hash_lookup (&htab->elf, sym->name, FALSE, FALSE, TRUE);
6328 if (eh == NULL)
6329 continue;
6330 if (eh->elf.root.type != bfd_link_hash_defined
6331 && eh->elf.root.type != bfd_link_hash_defweak)
6332 continue;
6333
6334 fh = defined_code_entry (eh);
6335 if (fh != NULL)
6336 {
6337 sec = fh->elf.root.u.def.section;
6338 sec->flags |= SEC_KEEP;
6339 }
6340 else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6341 && opd_entry_value (eh->elf.root.u.def.section,
6342 eh->elf.root.u.def.value,
6343 &sec, NULL, FALSE) != (bfd_vma) -1)
6344 sec->flags |= SEC_KEEP;
6345
6346 sec = eh->elf.root.u.def.section;
6347 sec->flags |= SEC_KEEP;
6348 }
6349 }
6350
6351 /* Mark sections containing dynamically referenced symbols. When
6352 building shared libraries, we must assume that any visible symbol is
6353 referenced. */
6354
6355 static bfd_boolean
ppc64_elf_gc_mark_dynamic_ref(struct elf_link_hash_entry * h,void * inf)6356 ppc64_elf_gc_mark_dynamic_ref (struct elf_link_hash_entry *h, void *inf)
6357 {
6358 struct bfd_link_info *info = (struct bfd_link_info *) inf;
6359 struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
6360 struct ppc_link_hash_entry *fdh;
6361 struct bfd_elf_dynamic_list *d = info->dynamic_list;
6362
6363 /* Dynamic linking info is on the func descriptor sym. */
6364 fdh = defined_func_desc (eh);
6365 if (fdh != NULL)
6366 eh = fdh;
6367
6368 if ((eh->elf.root.type == bfd_link_hash_defined
6369 || eh->elf.root.type == bfd_link_hash_defweak)
6370 && (eh->elf.ref_dynamic
6371 || ((eh->elf.def_regular || ELF_COMMON_DEF_P (&eh->elf))
6372 && ELF_ST_VISIBILITY (eh->elf.other) != STV_INTERNAL
6373 && ELF_ST_VISIBILITY (eh->elf.other) != STV_HIDDEN
6374 && (!bfd_link_executable (info)
6375 || info->export_dynamic
6376 || (eh->elf.dynamic
6377 && d != NULL
6378 && (*d->match) (&d->head, NULL, eh->elf.root.root.string)))
6379 && (strchr (eh->elf.root.root.string, ELF_VER_CHR) != NULL
6380 || !bfd_hide_sym_by_version (info->version_info,
6381 eh->elf.root.root.string)))))
6382 {
6383 asection *code_sec;
6384 struct ppc_link_hash_entry *fh;
6385
6386 eh->elf.root.u.def.section->flags |= SEC_KEEP;
6387
6388 /* Function descriptor syms cause the associated
6389 function code sym section to be marked. */
6390 fh = defined_code_entry (eh);
6391 if (fh != NULL)
6392 {
6393 code_sec = fh->elf.root.u.def.section;
6394 code_sec->flags |= SEC_KEEP;
6395 }
6396 else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6397 && opd_entry_value (eh->elf.root.u.def.section,
6398 eh->elf.root.u.def.value,
6399 &code_sec, NULL, FALSE) != (bfd_vma) -1)
6400 code_sec->flags |= SEC_KEEP;
6401 }
6402
6403 return TRUE;
6404 }
6405
6406 /* Return the section that should be marked against GC for a given
6407 relocation. */
6408
6409 static asection *
ppc64_elf_gc_mark_hook(asection * sec,struct bfd_link_info * info,Elf_Internal_Rela * rel,struct elf_link_hash_entry * h,Elf_Internal_Sym * sym)6410 ppc64_elf_gc_mark_hook (asection *sec,
6411 struct bfd_link_info *info,
6412 Elf_Internal_Rela *rel,
6413 struct elf_link_hash_entry *h,
6414 Elf_Internal_Sym *sym)
6415 {
6416 asection *rsec;
6417
6418 /* Syms return NULL if we're marking .opd, so we avoid marking all
6419 function sections, as all functions are referenced in .opd. */
6420 rsec = NULL;
6421 if (get_opd_info (sec) != NULL)
6422 return rsec;
6423
6424 if (h != NULL)
6425 {
6426 enum elf_ppc64_reloc_type r_type;
6427 struct ppc_link_hash_entry *eh, *fh, *fdh;
6428
6429 r_type = ELF64_R_TYPE (rel->r_info);
6430 switch (r_type)
6431 {
6432 case R_PPC64_GNU_VTINHERIT:
6433 case R_PPC64_GNU_VTENTRY:
6434 break;
6435
6436 default:
6437 switch (h->root.type)
6438 {
6439 case bfd_link_hash_defined:
6440 case bfd_link_hash_defweak:
6441 eh = (struct ppc_link_hash_entry *) h;
6442 fdh = defined_func_desc (eh);
6443 if (fdh != NULL)
6444 eh = fdh;
6445
6446 /* Function descriptor syms cause the associated
6447 function code sym section to be marked. */
6448 fh = defined_code_entry (eh);
6449 if (fh != NULL)
6450 {
6451 /* They also mark their opd section. */
6452 eh->elf.root.u.def.section->gc_mark = 1;
6453
6454 rsec = fh->elf.root.u.def.section;
6455 }
6456 else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6457 && opd_entry_value (eh->elf.root.u.def.section,
6458 eh->elf.root.u.def.value,
6459 &rsec, NULL, FALSE) != (bfd_vma) -1)
6460 eh->elf.root.u.def.section->gc_mark = 1;
6461 else
6462 rsec = h->root.u.def.section;
6463 break;
6464
6465 case bfd_link_hash_common:
6466 rsec = h->root.u.c.p->section;
6467 break;
6468
6469 default:
6470 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
6471 }
6472 }
6473 }
6474 else
6475 {
6476 struct _opd_sec_data *opd;
6477
6478 rsec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
6479 opd = get_opd_info (rsec);
6480 if (opd != NULL && opd->func_sec != NULL)
6481 {
6482 rsec->gc_mark = 1;
6483
6484 rsec = opd->func_sec[OPD_NDX (sym->st_value + rel->r_addend)];
6485 }
6486 }
6487
6488 return rsec;
6489 }
6490
6491 /* Update the .got, .plt. and dynamic reloc reference counts for the
6492 section being removed. */
6493
6494 static bfd_boolean
ppc64_elf_gc_sweep_hook(bfd * abfd,struct bfd_link_info * info,asection * sec,const Elf_Internal_Rela * relocs)6495 ppc64_elf_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info,
6496 asection *sec, const Elf_Internal_Rela *relocs)
6497 {
6498 struct ppc_link_hash_table *htab;
6499 Elf_Internal_Shdr *symtab_hdr;
6500 struct elf_link_hash_entry **sym_hashes;
6501 struct got_entry **local_got_ents;
6502 const Elf_Internal_Rela *rel, *relend;
6503
6504 if (bfd_link_relocatable (info))
6505 return TRUE;
6506
6507 if ((sec->flags & SEC_ALLOC) == 0)
6508 return TRUE;
6509
6510 elf_section_data (sec)->local_dynrel = NULL;
6511
6512 htab = ppc_hash_table (info);
6513 if (htab == NULL)
6514 return FALSE;
6515
6516 symtab_hdr = &elf_symtab_hdr (abfd);
6517 sym_hashes = elf_sym_hashes (abfd);
6518 local_got_ents = elf_local_got_ents (abfd);
6519
6520 relend = relocs + sec->reloc_count;
6521 for (rel = relocs; rel < relend; rel++)
6522 {
6523 unsigned long r_symndx;
6524 enum elf_ppc64_reloc_type r_type;
6525 struct elf_link_hash_entry *h = NULL;
6526 struct plt_entry **plt_list;
6527 unsigned char tls_type = 0;
6528
6529 r_symndx = ELF64_R_SYM (rel->r_info);
6530 r_type = ELF64_R_TYPE (rel->r_info);
6531 if (r_symndx >= symtab_hdr->sh_info)
6532 {
6533 struct ppc_link_hash_entry *eh;
6534 struct elf_dyn_relocs **pp;
6535 struct elf_dyn_relocs *p;
6536
6537 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
6538 h = elf_follow_link (h);
6539 eh = (struct ppc_link_hash_entry *) h;
6540
6541 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
6542 if (p->sec == sec)
6543 {
6544 /* Everything must go for SEC. */
6545 *pp = p->next;
6546 break;
6547 }
6548 }
6549
6550 switch (r_type)
6551 {
6552 case R_PPC64_GOT_TLSLD16:
6553 case R_PPC64_GOT_TLSLD16_LO:
6554 case R_PPC64_GOT_TLSLD16_HI:
6555 case R_PPC64_GOT_TLSLD16_HA:
6556 tls_type = TLS_TLS | TLS_LD;
6557 goto dogot;
6558
6559 case R_PPC64_GOT_TLSGD16:
6560 case R_PPC64_GOT_TLSGD16_LO:
6561 case R_PPC64_GOT_TLSGD16_HI:
6562 case R_PPC64_GOT_TLSGD16_HA:
6563 tls_type = TLS_TLS | TLS_GD;
6564 goto dogot;
6565
6566 case R_PPC64_GOT_TPREL16_DS:
6567 case R_PPC64_GOT_TPREL16_LO_DS:
6568 case R_PPC64_GOT_TPREL16_HI:
6569 case R_PPC64_GOT_TPREL16_HA:
6570 tls_type = TLS_TLS | TLS_TPREL;
6571 goto dogot;
6572
6573 case R_PPC64_GOT_DTPREL16_DS:
6574 case R_PPC64_GOT_DTPREL16_LO_DS:
6575 case R_PPC64_GOT_DTPREL16_HI:
6576 case R_PPC64_GOT_DTPREL16_HA:
6577 tls_type = TLS_TLS | TLS_DTPREL;
6578 goto dogot;
6579
6580 case R_PPC64_GOT16:
6581 case R_PPC64_GOT16_DS:
6582 case R_PPC64_GOT16_HA:
6583 case R_PPC64_GOT16_HI:
6584 case R_PPC64_GOT16_LO:
6585 case R_PPC64_GOT16_LO_DS:
6586 dogot:
6587 {
6588 struct got_entry *ent;
6589
6590 if (h != NULL)
6591 ent = h->got.glist;
6592 else
6593 ent = local_got_ents[r_symndx];
6594
6595 for (; ent != NULL; ent = ent->next)
6596 if (ent->addend == rel->r_addend
6597 && ent->owner == abfd
6598 && ent->tls_type == tls_type)
6599 break;
6600 if (ent == NULL)
6601 abort ();
6602 if (ent->got.refcount > 0)
6603 ent->got.refcount -= 1;
6604 }
6605 break;
6606
6607 case R_PPC64_PLT16_HA:
6608 case R_PPC64_PLT16_HI:
6609 case R_PPC64_PLT16_LO:
6610 case R_PPC64_PLT32:
6611 case R_PPC64_PLT64:
6612 case R_PPC64_REL14:
6613 case R_PPC64_REL14_BRNTAKEN:
6614 case R_PPC64_REL14_BRTAKEN:
6615 case R_PPC64_REL24:
6616 plt_list = NULL;
6617 if (h != NULL)
6618 plt_list = &h->plt.plist;
6619 else if (local_got_ents != NULL)
6620 {
6621 struct plt_entry **local_plt = (struct plt_entry **)
6622 (local_got_ents + symtab_hdr->sh_info);
6623 unsigned char *local_got_tls_masks = (unsigned char *)
6624 (local_plt + symtab_hdr->sh_info);
6625 if ((local_got_tls_masks[r_symndx] & PLT_IFUNC) != 0)
6626 plt_list = local_plt + r_symndx;
6627 }
6628 if (plt_list)
6629 {
6630 struct plt_entry *ent;
6631
6632 for (ent = *plt_list; ent != NULL; ent = ent->next)
6633 if (ent->addend == rel->r_addend)
6634 break;
6635 if (ent != NULL && ent->plt.refcount > 0)
6636 ent->plt.refcount -= 1;
6637 }
6638 break;
6639
6640 default:
6641 break;
6642 }
6643 }
6644 return TRUE;
6645 }
6646
6647 /* The maximum size of .sfpr. */
6648 #define SFPR_MAX (218*4)
6649
6650 struct sfpr_def_parms
6651 {
6652 const char name[12];
6653 unsigned char lo, hi;
6654 bfd_byte * (*write_ent) (bfd *, bfd_byte *, int);
6655 bfd_byte * (*write_tail) (bfd *, bfd_byte *, int);
6656 };
6657
6658 /* Auto-generate _save*, _rest* functions in .sfpr.
6659 If STUB_SEC is non-null, define alias symbols in STUB_SEC
6660 instead. */
6661
6662 static bfd_boolean
sfpr_define(struct bfd_link_info * info,const struct sfpr_def_parms * parm,asection * stub_sec)6663 sfpr_define (struct bfd_link_info *info,
6664 const struct sfpr_def_parms *parm,
6665 asection *stub_sec)
6666 {
6667 struct ppc_link_hash_table *htab = ppc_hash_table (info);
6668 unsigned int i;
6669 size_t len = strlen (parm->name);
6670 bfd_boolean writing = FALSE;
6671 char sym[16];
6672
6673 if (htab == NULL)
6674 return FALSE;
6675
6676 memcpy (sym, parm->name, len);
6677 sym[len + 2] = 0;
6678
6679 for (i = parm->lo; i <= parm->hi; i++)
6680 {
6681 struct ppc_link_hash_entry *h;
6682
6683 sym[len + 0] = i / 10 + '0';
6684 sym[len + 1] = i % 10 + '0';
6685 h = (struct ppc_link_hash_entry *)
6686 elf_link_hash_lookup (&htab->elf, sym, writing, TRUE, TRUE);
6687 if (stub_sec != NULL)
6688 {
6689 if (h != NULL
6690 && h->elf.root.type == bfd_link_hash_defined
6691 && h->elf.root.u.def.section == htab->sfpr)
6692 {
6693 struct elf_link_hash_entry *s;
6694 char buf[32];
6695 sprintf (buf, "%08x.%s", stub_sec->id & 0xffffffff, sym);
6696 s = elf_link_hash_lookup (&htab->elf, buf, TRUE, TRUE, FALSE);
6697 if (s == NULL)
6698 return FALSE;
6699 if (s->root.type == bfd_link_hash_new
6700 || (s->root.type = bfd_link_hash_defined
6701 && s->root.u.def.section == stub_sec))
6702 {
6703 s->root.type = bfd_link_hash_defined;
6704 s->root.u.def.section = stub_sec;
6705 s->root.u.def.value = (stub_sec->size
6706 + h->elf.root.u.def.value);
6707 s->ref_regular = 1;
6708 s->def_regular = 1;
6709 s->ref_regular_nonweak = 1;
6710 s->forced_local = 1;
6711 s->non_elf = 0;
6712 s->root.linker_def = 1;
6713 }
6714 }
6715 continue;
6716 }
6717 if (h != NULL)
6718 {
6719 h->save_res = 1;
6720 if (!h->elf.def_regular)
6721 {
6722 h->elf.root.type = bfd_link_hash_defined;
6723 h->elf.root.u.def.section = htab->sfpr;
6724 h->elf.root.u.def.value = htab->sfpr->size;
6725 h->elf.type = STT_FUNC;
6726 h->elf.def_regular = 1;
6727 h->elf.non_elf = 0;
6728 _bfd_elf_link_hash_hide_symbol (info, &h->elf, TRUE);
6729 writing = TRUE;
6730 if (htab->sfpr->contents == NULL)
6731 {
6732 htab->sfpr->contents = bfd_alloc (htab->elf.dynobj, SFPR_MAX);
6733 if (htab->sfpr->contents == NULL)
6734 return FALSE;
6735 }
6736 }
6737 }
6738 if (writing)
6739 {
6740 bfd_byte *p = htab->sfpr->contents + htab->sfpr->size;
6741 if (i != parm->hi)
6742 p = (*parm->write_ent) (htab->elf.dynobj, p, i);
6743 else
6744 p = (*parm->write_tail) (htab->elf.dynobj, p, i);
6745 htab->sfpr->size = p - htab->sfpr->contents;
6746 }
6747 }
6748
6749 return TRUE;
6750 }
6751
6752 static bfd_byte *
savegpr0(bfd * abfd,bfd_byte * p,int r)6753 savegpr0 (bfd *abfd, bfd_byte *p, int r)
6754 {
6755 bfd_put_32 (abfd, STD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6756 return p + 4;
6757 }
6758
6759 static bfd_byte *
savegpr0_tail(bfd * abfd,bfd_byte * p,int r)6760 savegpr0_tail (bfd *abfd, bfd_byte *p, int r)
6761 {
6762 p = savegpr0 (abfd, p, r);
6763 bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
6764 p = p + 4;
6765 bfd_put_32 (abfd, BLR, p);
6766 return p + 4;
6767 }
6768
6769 static bfd_byte *
restgpr0(bfd * abfd,bfd_byte * p,int r)6770 restgpr0 (bfd *abfd, bfd_byte *p, int r)
6771 {
6772 bfd_put_32 (abfd, LD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6773 return p + 4;
6774 }
6775
6776 static bfd_byte *
restgpr0_tail(bfd * abfd,bfd_byte * p,int r)6777 restgpr0_tail (bfd *abfd, bfd_byte *p, int r)
6778 {
6779 bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
6780 p = p + 4;
6781 p = restgpr0 (abfd, p, r);
6782 bfd_put_32 (abfd, MTLR_R0, p);
6783 p = p + 4;
6784 if (r == 29)
6785 {
6786 p = restgpr0 (abfd, p, 30);
6787 p = restgpr0 (abfd, p, 31);
6788 }
6789 bfd_put_32 (abfd, BLR, p);
6790 return p + 4;
6791 }
6792
6793 static bfd_byte *
savegpr1(bfd * abfd,bfd_byte * p,int r)6794 savegpr1 (bfd *abfd, bfd_byte *p, int r)
6795 {
6796 bfd_put_32 (abfd, STD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6797 return p + 4;
6798 }
6799
6800 static bfd_byte *
savegpr1_tail(bfd * abfd,bfd_byte * p,int r)6801 savegpr1_tail (bfd *abfd, bfd_byte *p, int r)
6802 {
6803 p = savegpr1 (abfd, p, r);
6804 bfd_put_32 (abfd, BLR, p);
6805 return p + 4;
6806 }
6807
6808 static bfd_byte *
restgpr1(bfd * abfd,bfd_byte * p,int r)6809 restgpr1 (bfd *abfd, bfd_byte *p, int r)
6810 {
6811 bfd_put_32 (abfd, LD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6812 return p + 4;
6813 }
6814
6815 static bfd_byte *
restgpr1_tail(bfd * abfd,bfd_byte * p,int r)6816 restgpr1_tail (bfd *abfd, bfd_byte *p, int r)
6817 {
6818 p = restgpr1 (abfd, p, r);
6819 bfd_put_32 (abfd, BLR, p);
6820 return p + 4;
6821 }
6822
6823 static bfd_byte *
savefpr(bfd * abfd,bfd_byte * p,int r)6824 savefpr (bfd *abfd, bfd_byte *p, int r)
6825 {
6826 bfd_put_32 (abfd, STFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6827 return p + 4;
6828 }
6829
6830 static bfd_byte *
savefpr0_tail(bfd * abfd,bfd_byte * p,int r)6831 savefpr0_tail (bfd *abfd, bfd_byte *p, int r)
6832 {
6833 p = savefpr (abfd, p, r);
6834 bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
6835 p = p + 4;
6836 bfd_put_32 (abfd, BLR, p);
6837 return p + 4;
6838 }
6839
6840 static bfd_byte *
restfpr(bfd * abfd,bfd_byte * p,int r)6841 restfpr (bfd *abfd, bfd_byte *p, int r)
6842 {
6843 bfd_put_32 (abfd, LFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6844 return p + 4;
6845 }
6846
6847 static bfd_byte *
restfpr0_tail(bfd * abfd,bfd_byte * p,int r)6848 restfpr0_tail (bfd *abfd, bfd_byte *p, int r)
6849 {
6850 bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
6851 p = p + 4;
6852 p = restfpr (abfd, p, r);
6853 bfd_put_32 (abfd, MTLR_R0, p);
6854 p = p + 4;
6855 if (r == 29)
6856 {
6857 p = restfpr (abfd, p, 30);
6858 p = restfpr (abfd, p, 31);
6859 }
6860 bfd_put_32 (abfd, BLR, p);
6861 return p + 4;
6862 }
6863
6864 static bfd_byte *
savefpr1_tail(bfd * abfd,bfd_byte * p,int r)6865 savefpr1_tail (bfd *abfd, bfd_byte *p, int r)
6866 {
6867 p = savefpr (abfd, p, r);
6868 bfd_put_32 (abfd, BLR, p);
6869 return p + 4;
6870 }
6871
6872 static bfd_byte *
restfpr1_tail(bfd * abfd,bfd_byte * p,int r)6873 restfpr1_tail (bfd *abfd, bfd_byte *p, int r)
6874 {
6875 p = restfpr (abfd, p, r);
6876 bfd_put_32 (abfd, BLR, p);
6877 return p + 4;
6878 }
6879
6880 static bfd_byte *
savevr(bfd * abfd,bfd_byte * p,int r)6881 savevr (bfd *abfd, bfd_byte *p, int r)
6882 {
6883 bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6884 p = p + 4;
6885 bfd_put_32 (abfd, STVX_VR0_R12_R0 + (r << 21), p);
6886 return p + 4;
6887 }
6888
6889 static bfd_byte *
savevr_tail(bfd * abfd,bfd_byte * p,int r)6890 savevr_tail (bfd *abfd, bfd_byte *p, int r)
6891 {
6892 p = savevr (abfd, p, r);
6893 bfd_put_32 (abfd, BLR, p);
6894 return p + 4;
6895 }
6896
6897 static bfd_byte *
restvr(bfd * abfd,bfd_byte * p,int r)6898 restvr (bfd *abfd, bfd_byte *p, int r)
6899 {
6900 bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6901 p = p + 4;
6902 bfd_put_32 (abfd, LVX_VR0_R12_R0 + (r << 21), p);
6903 return p + 4;
6904 }
6905
6906 static bfd_byte *
restvr_tail(bfd * abfd,bfd_byte * p,int r)6907 restvr_tail (bfd *abfd, bfd_byte *p, int r)
6908 {
6909 p = restvr (abfd, p, r);
6910 bfd_put_32 (abfd, BLR, p);
6911 return p + 4;
6912 }
6913
6914 /* Called via elf_link_hash_traverse to transfer dynamic linking
6915 information on function code symbol entries to their corresponding
6916 function descriptor symbol entries. */
6917
6918 static bfd_boolean
func_desc_adjust(struct elf_link_hash_entry * h,void * inf)6919 func_desc_adjust (struct elf_link_hash_entry *h, void *inf)
6920 {
6921 struct bfd_link_info *info;
6922 struct ppc_link_hash_table *htab;
6923 struct plt_entry *ent;
6924 struct ppc_link_hash_entry *fh;
6925 struct ppc_link_hash_entry *fdh;
6926 bfd_boolean force_local;
6927
6928 fh = (struct ppc_link_hash_entry *) h;
6929 if (fh->elf.root.type == bfd_link_hash_indirect)
6930 return TRUE;
6931
6932 info = inf;
6933 htab = ppc_hash_table (info);
6934 if (htab == NULL)
6935 return FALSE;
6936
6937 /* Resolve undefined references to dot-symbols as the value
6938 in the function descriptor, if we have one in a regular object.
6939 This is to satisfy cases like ".quad .foo". Calls to functions
6940 in dynamic objects are handled elsewhere. */
6941 if (fh->elf.root.type == bfd_link_hash_undefweak
6942 && fh->was_undefined
6943 && (fdh = defined_func_desc (fh)) != NULL
6944 && get_opd_info (fdh->elf.root.u.def.section) != NULL
6945 && opd_entry_value (fdh->elf.root.u.def.section,
6946 fdh->elf.root.u.def.value,
6947 &fh->elf.root.u.def.section,
6948 &fh->elf.root.u.def.value, FALSE) != (bfd_vma) -1)
6949 {
6950 fh->elf.root.type = fdh->elf.root.type;
6951 fh->elf.forced_local = 1;
6952 fh->elf.def_regular = fdh->elf.def_regular;
6953 fh->elf.def_dynamic = fdh->elf.def_dynamic;
6954 }
6955
6956 /* If this is a function code symbol, transfer dynamic linking
6957 information to the function descriptor symbol. */
6958 if (!fh->is_func)
6959 return TRUE;
6960
6961 for (ent = fh->elf.plt.plist; ent != NULL; ent = ent->next)
6962 if (ent->plt.refcount > 0)
6963 break;
6964 if (ent == NULL
6965 || fh->elf.root.root.string[0] != '.'
6966 || fh->elf.root.root.string[1] == '\0')
6967 return TRUE;
6968
6969 /* Find the corresponding function descriptor symbol. Create it
6970 as undefined if necessary. */
6971
6972 fdh = lookup_fdh (fh, htab);
6973 if (fdh == NULL
6974 && !bfd_link_executable (info)
6975 && (fh->elf.root.type == bfd_link_hash_undefined
6976 || fh->elf.root.type == bfd_link_hash_undefweak))
6977 {
6978 fdh = make_fdh (info, fh);
6979 if (fdh == NULL)
6980 return FALSE;
6981 }
6982
6983 /* Fake function descriptors are made undefweak. If the function
6984 code symbol is strong undefined, make the fake sym the same.
6985 If the function code symbol is defined, then force the fake
6986 descriptor local; We can't support overriding of symbols in a
6987 shared library on a fake descriptor. */
6988
6989 if (fdh != NULL
6990 && fdh->fake
6991 && fdh->elf.root.type == bfd_link_hash_undefweak)
6992 {
6993 if (fh->elf.root.type == bfd_link_hash_undefined)
6994 {
6995 fdh->elf.root.type = bfd_link_hash_undefined;
6996 bfd_link_add_undef (&htab->elf.root, &fdh->elf.root);
6997 }
6998 else if (fh->elf.root.type == bfd_link_hash_defined
6999 || fh->elf.root.type == bfd_link_hash_defweak)
7000 {
7001 _bfd_elf_link_hash_hide_symbol (info, &fdh->elf, TRUE);
7002 }
7003 }
7004
7005 if (fdh != NULL
7006 && !fdh->elf.forced_local
7007 && (!bfd_link_executable (info)
7008 || fdh->elf.def_dynamic
7009 || fdh->elf.ref_dynamic
7010 || (fdh->elf.root.type == bfd_link_hash_undefweak
7011 && ELF_ST_VISIBILITY (fdh->elf.other) == STV_DEFAULT)))
7012 {
7013 if (fdh->elf.dynindx == -1)
7014 if (! bfd_elf_link_record_dynamic_symbol (info, &fdh->elf))
7015 return FALSE;
7016 fdh->elf.ref_regular |= fh->elf.ref_regular;
7017 fdh->elf.ref_dynamic |= fh->elf.ref_dynamic;
7018 fdh->elf.ref_regular_nonweak |= fh->elf.ref_regular_nonweak;
7019 fdh->elf.non_got_ref |= fh->elf.non_got_ref;
7020 if (ELF_ST_VISIBILITY (fh->elf.other) == STV_DEFAULT)
7021 {
7022 move_plt_plist (fh, fdh);
7023 fdh->elf.needs_plt = 1;
7024 }
7025 fdh->is_func_descriptor = 1;
7026 fdh->oh = fh;
7027 fh->oh = fdh;
7028 }
7029
7030 /* Now that the info is on the function descriptor, clear the
7031 function code sym info. Any function code syms for which we
7032 don't have a definition in a regular file, we force local.
7033 This prevents a shared library from exporting syms that have
7034 been imported from another library. Function code syms that
7035 are really in the library we must leave global to prevent the
7036 linker dragging in a definition from a static library. */
7037 force_local = (!fh->elf.def_regular
7038 || fdh == NULL
7039 || !fdh->elf.def_regular
7040 || fdh->elf.forced_local);
7041 _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
7042
7043 return TRUE;
7044 }
7045
7046 static const struct sfpr_def_parms save_res_funcs[] =
7047 {
7048 { "_savegpr0_", 14, 31, savegpr0, savegpr0_tail },
7049 { "_restgpr0_", 14, 29, restgpr0, restgpr0_tail },
7050 { "_restgpr0_", 30, 31, restgpr0, restgpr0_tail },
7051 { "_savegpr1_", 14, 31, savegpr1, savegpr1_tail },
7052 { "_restgpr1_", 14, 31, restgpr1, restgpr1_tail },
7053 { "_savefpr_", 14, 31, savefpr, savefpr0_tail },
7054 { "_restfpr_", 14, 29, restfpr, restfpr0_tail },
7055 { "_restfpr_", 30, 31, restfpr, restfpr0_tail },
7056 { "._savef", 14, 31, savefpr, savefpr1_tail },
7057 { "._restf", 14, 31, restfpr, restfpr1_tail },
7058 { "_savevr_", 20, 31, savevr, savevr_tail },
7059 { "_restvr_", 20, 31, restvr, restvr_tail }
7060 };
7061
7062 /* Called near the start of bfd_elf_size_dynamic_sections. We use
7063 this hook to a) provide some gcc support functions, and b) transfer
7064 dynamic linking information gathered so far on function code symbol
7065 entries, to their corresponding function descriptor symbol entries. */
7066
7067 static bfd_boolean
ppc64_elf_func_desc_adjust(bfd * obfd ATTRIBUTE_UNUSED,struct bfd_link_info * info)7068 ppc64_elf_func_desc_adjust (bfd *obfd ATTRIBUTE_UNUSED,
7069 struct bfd_link_info *info)
7070 {
7071 struct ppc_link_hash_table *htab;
7072
7073 htab = ppc_hash_table (info);
7074 if (htab == NULL)
7075 return FALSE;
7076
7077 /* Provide any missing _save* and _rest* functions. */
7078 if (htab->sfpr != NULL)
7079 {
7080 unsigned int i;
7081
7082 htab->sfpr->size = 0;
7083 for (i = 0; i < ARRAY_SIZE (save_res_funcs); i++)
7084 if (!sfpr_define (info, &save_res_funcs[i], NULL))
7085 return FALSE;
7086 if (htab->sfpr->size == 0)
7087 htab->sfpr->flags |= SEC_EXCLUDE;
7088 }
7089
7090 if (bfd_link_relocatable (info))
7091 return TRUE;
7092
7093 if (htab->elf.hgot != NULL)
7094 {
7095 _bfd_elf_link_hash_hide_symbol (info, htab->elf.hgot, TRUE);
7096 /* Make .TOC. defined so as to prevent it being made dynamic.
7097 The wrong value here is fixed later in ppc64_elf_set_toc. */
7098 if (!htab->elf.hgot->def_regular
7099 || htab->elf.hgot->root.type != bfd_link_hash_defined)
7100 {
7101 htab->elf.hgot->root.type = bfd_link_hash_defined;
7102 htab->elf.hgot->root.u.def.value = 0;
7103 htab->elf.hgot->root.u.def.section = bfd_abs_section_ptr;
7104 htab->elf.hgot->def_regular = 1;
7105 htab->elf.hgot->root.linker_def = 1;
7106 }
7107 htab->elf.hgot->type = STT_OBJECT;
7108 htab->elf.hgot->other = ((htab->elf.hgot->other & ~ELF_ST_VISIBILITY (-1))
7109 | STV_HIDDEN);
7110 }
7111
7112 elf_link_hash_traverse (&htab->elf, func_desc_adjust, info);
7113
7114 return TRUE;
7115 }
7116
7117 /* Return true if we have dynamic relocs against H that apply to
7118 read-only sections. */
7119
7120 static bfd_boolean
readonly_dynrelocs(struct elf_link_hash_entry * h)7121 readonly_dynrelocs (struct elf_link_hash_entry *h)
7122 {
7123 struct ppc_link_hash_entry *eh;
7124 struct elf_dyn_relocs *p;
7125
7126 eh = (struct ppc_link_hash_entry *) h;
7127 for (p = eh->dyn_relocs; p != NULL; p = p->next)
7128 {
7129 asection *s = p->sec->output_section;
7130
7131 if (s != NULL && (s->flags & SEC_READONLY) != 0)
7132 return TRUE;
7133 }
7134 return FALSE;
7135 }
7136
7137
7138 /* Return true if a global entry stub will be created for H. Valid
7139 for ELFv2 before plt entries have been allocated. */
7140
7141 static bfd_boolean
global_entry_stub(struct elf_link_hash_entry * h)7142 global_entry_stub (struct elf_link_hash_entry *h)
7143 {
7144 struct plt_entry *pent;
7145
7146 if (!h->pointer_equality_needed
7147 || h->def_regular)
7148 return FALSE;
7149
7150 for (pent = h->plt.plist; pent != NULL; pent = pent->next)
7151 if (pent->plt.refcount > 0
7152 && pent->addend == 0)
7153 return TRUE;
7154
7155 return FALSE;
7156 }
7157
7158 /* Adjust a symbol defined by a dynamic object and referenced by a
7159 regular object. The current definition is in some section of the
7160 dynamic object, but we're not including those sections. We have to
7161 change the definition to something the rest of the link can
7162 understand. */
7163
7164 static bfd_boolean
ppc64_elf_adjust_dynamic_symbol(struct bfd_link_info * info,struct elf_link_hash_entry * h)7165 ppc64_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
7166 struct elf_link_hash_entry *h)
7167 {
7168 struct ppc_link_hash_table *htab;
7169 asection *s;
7170
7171 htab = ppc_hash_table (info);
7172 if (htab == NULL)
7173 return FALSE;
7174
7175 /* Deal with function syms. */
7176 if (h->type == STT_FUNC
7177 || h->type == STT_GNU_IFUNC
7178 || h->needs_plt)
7179 {
7180 /* Clear procedure linkage table information for any symbol that
7181 won't need a .plt entry. */
7182 struct plt_entry *ent;
7183 for (ent = h->plt.plist; ent != NULL; ent = ent->next)
7184 if (ent->plt.refcount > 0)
7185 break;
7186 if (ent == NULL
7187 || (h->type != STT_GNU_IFUNC
7188 && (SYMBOL_CALLS_LOCAL (info, h)
7189 || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
7190 && h->root.type == bfd_link_hash_undefweak)))
7191 || ((struct ppc_link_hash_entry *) h)->save_res)
7192 {
7193 h->plt.plist = NULL;
7194 h->needs_plt = 0;
7195 h->pointer_equality_needed = 0;
7196 }
7197 else if (abiversion (info->output_bfd) >= 2)
7198 {
7199 /* Taking a function's address in a read/write section
7200 doesn't require us to define the function symbol in the
7201 executable on a global entry stub. A dynamic reloc can
7202 be used instead. The reason we prefer a few more dynamic
7203 relocs is that calling via a global entry stub costs a
7204 few more instructions, and pointer_equality_needed causes
7205 extra work in ld.so when resolving these symbols. */
7206 if (global_entry_stub (h)
7207 && !readonly_dynrelocs (h))
7208 {
7209 h->pointer_equality_needed = 0;
7210 /* After adjust_dynamic_symbol, non_got_ref set in
7211 the non-pic case means that dyn_relocs for this
7212 symbol should be discarded. */
7213 h->non_got_ref = 0;
7214 }
7215
7216 /* If making a plt entry, then we don't need copy relocs. */
7217 return TRUE;
7218 }
7219 }
7220 else
7221 h->plt.plist = NULL;
7222
7223 /* If this is a weak symbol, and there is a real definition, the
7224 processor independent code will have arranged for us to see the
7225 real definition first, and we can just use the same value. */
7226 if (h->u.weakdef != NULL)
7227 {
7228 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
7229 || h->u.weakdef->root.type == bfd_link_hash_defweak);
7230 h->root.u.def.section = h->u.weakdef->root.u.def.section;
7231 h->root.u.def.value = h->u.weakdef->root.u.def.value;
7232 if (ELIMINATE_COPY_RELOCS)
7233 h->non_got_ref = h->u.weakdef->non_got_ref;
7234 return TRUE;
7235 }
7236
7237 /* If we are creating a shared library, we must presume that the
7238 only references to the symbol are via the global offset table.
7239 For such cases we need not do anything here; the relocations will
7240 be handled correctly by relocate_section. */
7241 if (bfd_link_pic (info))
7242 return TRUE;
7243
7244 /* If there are no references to this symbol that do not use the
7245 GOT, we don't need to generate a copy reloc. */
7246 if (!h->non_got_ref)
7247 return TRUE;
7248
7249 /* Don't generate a copy reloc for symbols defined in the executable. */
7250 if (!h->def_dynamic || !h->ref_regular || h->def_regular
7251
7252 /* If -z nocopyreloc was given, don't generate them either. */
7253 || info->nocopyreloc
7254
7255 /* If we didn't find any dynamic relocs in read-only sections, then
7256 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
7257 || (ELIMINATE_COPY_RELOCS && !readonly_dynrelocs (h))
7258
7259 /* Protected variables do not work with .dynbss. The copy in
7260 .dynbss won't be used by the shared library with the protected
7261 definition for the variable. Text relocations are preferable
7262 to an incorrect program. */
7263 || h->protected_def)
7264 {
7265 h->non_got_ref = 0;
7266 return TRUE;
7267 }
7268
7269 if (h->plt.plist != NULL)
7270 {
7271 /* We should never get here, but unfortunately there are versions
7272 of gcc out there that improperly (for this ABI) put initialized
7273 function pointers, vtable refs and suchlike in read-only
7274 sections. Allow them to proceed, but warn that this might
7275 break at runtime. */
7276 info->callbacks->einfo
7277 (_("%P: copy reloc against `%T' requires lazy plt linking; "
7278 "avoid setting LD_BIND_NOW=1 or upgrade gcc\n"),
7279 h->root.root.string);
7280 }
7281
7282 /* This is a reference to a symbol defined by a dynamic object which
7283 is not a function. */
7284
7285 /* We must allocate the symbol in our .dynbss section, which will
7286 become part of the .bss section of the executable. There will be
7287 an entry for this symbol in the .dynsym section. The dynamic
7288 object will contain position independent code, so all references
7289 from the dynamic object to this symbol will go through the global
7290 offset table. The dynamic linker will use the .dynsym entry to
7291 determine the address it must put in the global offset table, so
7292 both the dynamic object and the regular object will refer to the
7293 same memory location for the variable. */
7294
7295 /* We must generate a R_PPC64_COPY reloc to tell the dynamic linker
7296 to copy the initial value out of the dynamic object and into the
7297 runtime process image. We need to remember the offset into the
7298 .rela.bss section we are going to use. */
7299 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
7300 {
7301 htab->relbss->size += sizeof (Elf64_External_Rela);
7302 h->needs_copy = 1;
7303 }
7304
7305 s = htab->dynbss;
7306
7307 return _bfd_elf_adjust_dynamic_copy (info, h, s);
7308 }
7309
7310 /* If given a function descriptor symbol, hide both the function code
7311 sym and the descriptor. */
7312 static void
ppc64_elf_hide_symbol(struct bfd_link_info * info,struct elf_link_hash_entry * h,bfd_boolean force_local)7313 ppc64_elf_hide_symbol (struct bfd_link_info *info,
7314 struct elf_link_hash_entry *h,
7315 bfd_boolean force_local)
7316 {
7317 struct ppc_link_hash_entry *eh;
7318 _bfd_elf_link_hash_hide_symbol (info, h, force_local);
7319
7320 eh = (struct ppc_link_hash_entry *) h;
7321 if (eh->is_func_descriptor)
7322 {
7323 struct ppc_link_hash_entry *fh = eh->oh;
7324
7325 if (fh == NULL)
7326 {
7327 const char *p, *q;
7328 struct ppc_link_hash_table *htab;
7329 char save;
7330
7331 /* We aren't supposed to use alloca in BFD because on
7332 systems which do not have alloca the version in libiberty
7333 calls xmalloc, which might cause the program to crash
7334 when it runs out of memory. This function doesn't have a
7335 return status, so there's no way to gracefully return an
7336 error. So cheat. We know that string[-1] can be safely
7337 accessed; It's either a string in an ELF string table,
7338 or allocated in an objalloc structure. */
7339
7340 p = eh->elf.root.root.string - 1;
7341 save = *p;
7342 *(char *) p = '.';
7343 htab = ppc_hash_table (info);
7344 if (htab == NULL)
7345 return;
7346
7347 fh = (struct ppc_link_hash_entry *)
7348 elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
7349 *(char *) p = save;
7350
7351 /* Unfortunately, if it so happens that the string we were
7352 looking for was allocated immediately before this string,
7353 then we overwrote the string terminator. That's the only
7354 reason the lookup should fail. */
7355 if (fh == NULL)
7356 {
7357 q = eh->elf.root.root.string + strlen (eh->elf.root.root.string);
7358 while (q >= eh->elf.root.root.string && *q == *p)
7359 --q, --p;
7360 if (q < eh->elf.root.root.string && *p == '.')
7361 fh = (struct ppc_link_hash_entry *)
7362 elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
7363 }
7364 if (fh != NULL)
7365 {
7366 eh->oh = fh;
7367 fh->oh = eh;
7368 }
7369 }
7370 if (fh != NULL)
7371 _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
7372 }
7373 }
7374
7375 static bfd_boolean
get_sym_h(struct elf_link_hash_entry ** hp,Elf_Internal_Sym ** symp,asection ** symsecp,unsigned char ** tls_maskp,Elf_Internal_Sym ** locsymsp,unsigned long r_symndx,bfd * ibfd)7376 get_sym_h (struct elf_link_hash_entry **hp,
7377 Elf_Internal_Sym **symp,
7378 asection **symsecp,
7379 unsigned char **tls_maskp,
7380 Elf_Internal_Sym **locsymsp,
7381 unsigned long r_symndx,
7382 bfd *ibfd)
7383 {
7384 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
7385
7386 if (r_symndx >= symtab_hdr->sh_info)
7387 {
7388 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
7389 struct elf_link_hash_entry *h;
7390
7391 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
7392 h = elf_follow_link (h);
7393
7394 if (hp != NULL)
7395 *hp = h;
7396
7397 if (symp != NULL)
7398 *symp = NULL;
7399
7400 if (symsecp != NULL)
7401 {
7402 asection *symsec = NULL;
7403 if (h->root.type == bfd_link_hash_defined
7404 || h->root.type == bfd_link_hash_defweak)
7405 symsec = h->root.u.def.section;
7406 *symsecp = symsec;
7407 }
7408
7409 if (tls_maskp != NULL)
7410 {
7411 struct ppc_link_hash_entry *eh;
7412
7413 eh = (struct ppc_link_hash_entry *) h;
7414 *tls_maskp = &eh->tls_mask;
7415 }
7416 }
7417 else
7418 {
7419 Elf_Internal_Sym *sym;
7420 Elf_Internal_Sym *locsyms = *locsymsp;
7421
7422 if (locsyms == NULL)
7423 {
7424 locsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
7425 if (locsyms == NULL)
7426 locsyms = bfd_elf_get_elf_syms (ibfd, symtab_hdr,
7427 symtab_hdr->sh_info,
7428 0, NULL, NULL, NULL);
7429 if (locsyms == NULL)
7430 return FALSE;
7431 *locsymsp = locsyms;
7432 }
7433 sym = locsyms + r_symndx;
7434
7435 if (hp != NULL)
7436 *hp = NULL;
7437
7438 if (symp != NULL)
7439 *symp = sym;
7440
7441 if (symsecp != NULL)
7442 *symsecp = bfd_section_from_elf_index (ibfd, sym->st_shndx);
7443
7444 if (tls_maskp != NULL)
7445 {
7446 struct got_entry **lgot_ents;
7447 unsigned char *tls_mask;
7448
7449 tls_mask = NULL;
7450 lgot_ents = elf_local_got_ents (ibfd);
7451 if (lgot_ents != NULL)
7452 {
7453 struct plt_entry **local_plt = (struct plt_entry **)
7454 (lgot_ents + symtab_hdr->sh_info);
7455 unsigned char *lgot_masks = (unsigned char *)
7456 (local_plt + symtab_hdr->sh_info);
7457 tls_mask = &lgot_masks[r_symndx];
7458 }
7459 *tls_maskp = tls_mask;
7460 }
7461 }
7462 return TRUE;
7463 }
7464
7465 /* Returns TLS_MASKP for the given REL symbol. Function return is 0 on
7466 error, 2 on a toc GD type suitable for optimization, 3 on a toc LD
7467 type suitable for optimization, and 1 otherwise. */
7468
7469 static int
get_tls_mask(unsigned char ** tls_maskp,unsigned long * toc_symndx,bfd_vma * toc_addend,Elf_Internal_Sym ** locsymsp,const Elf_Internal_Rela * rel,bfd * ibfd)7470 get_tls_mask (unsigned char **tls_maskp,
7471 unsigned long *toc_symndx,
7472 bfd_vma *toc_addend,
7473 Elf_Internal_Sym **locsymsp,
7474 const Elf_Internal_Rela *rel,
7475 bfd *ibfd)
7476 {
7477 unsigned long r_symndx;
7478 int next_r;
7479 struct elf_link_hash_entry *h;
7480 Elf_Internal_Sym *sym;
7481 asection *sec;
7482 bfd_vma off;
7483
7484 r_symndx = ELF64_R_SYM (rel->r_info);
7485 if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7486 return 0;
7487
7488 if ((*tls_maskp != NULL && **tls_maskp != 0)
7489 || sec == NULL
7490 || ppc64_elf_section_data (sec) == NULL
7491 || ppc64_elf_section_data (sec)->sec_type != sec_toc)
7492 return 1;
7493
7494 /* Look inside a TOC section too. */
7495 if (h != NULL)
7496 {
7497 BFD_ASSERT (h->root.type == bfd_link_hash_defined);
7498 off = h->root.u.def.value;
7499 }
7500 else
7501 off = sym->st_value;
7502 off += rel->r_addend;
7503 BFD_ASSERT (off % 8 == 0);
7504 r_symndx = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8];
7505 next_r = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8 + 1];
7506 if (toc_symndx != NULL)
7507 *toc_symndx = r_symndx;
7508 if (toc_addend != NULL)
7509 *toc_addend = ppc64_elf_section_data (sec)->u.toc.add[off / 8];
7510 if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7511 return 0;
7512 if ((h == NULL || is_static_defined (h))
7513 && (next_r == -1 || next_r == -2))
7514 return 1 - next_r;
7515 return 1;
7516 }
7517
7518 /* Find (or create) an entry in the tocsave hash table. */
7519
7520 static struct tocsave_entry *
tocsave_find(struct ppc_link_hash_table * htab,enum insert_option insert,Elf_Internal_Sym ** local_syms,const Elf_Internal_Rela * irela,bfd * ibfd)7521 tocsave_find (struct ppc_link_hash_table *htab,
7522 enum insert_option insert,
7523 Elf_Internal_Sym **local_syms,
7524 const Elf_Internal_Rela *irela,
7525 bfd *ibfd)
7526 {
7527 unsigned long r_indx;
7528 struct elf_link_hash_entry *h;
7529 Elf_Internal_Sym *sym;
7530 struct tocsave_entry ent, *p;
7531 hashval_t hash;
7532 struct tocsave_entry **slot;
7533
7534 r_indx = ELF64_R_SYM (irela->r_info);
7535 if (!get_sym_h (&h, &sym, &ent.sec, NULL, local_syms, r_indx, ibfd))
7536 return NULL;
7537 if (ent.sec == NULL || ent.sec->output_section == NULL)
7538 {
7539 (*_bfd_error_handler)
7540 (_("%B: undefined symbol on R_PPC64_TOCSAVE relocation"));
7541 return NULL;
7542 }
7543
7544 if (h != NULL)
7545 ent.offset = h->root.u.def.value;
7546 else
7547 ent.offset = sym->st_value;
7548 ent.offset += irela->r_addend;
7549
7550 hash = tocsave_htab_hash (&ent);
7551 slot = ((struct tocsave_entry **)
7552 htab_find_slot_with_hash (htab->tocsave_htab, &ent, hash, insert));
7553 if (slot == NULL)
7554 return NULL;
7555
7556 if (*slot == NULL)
7557 {
7558 p = (struct tocsave_entry *) bfd_alloc (ibfd, sizeof (*p));
7559 if (p == NULL)
7560 return NULL;
7561 *p = ent;
7562 *slot = p;
7563 }
7564 return *slot;
7565 }
7566
7567 /* Adjust all global syms defined in opd sections. In gcc generated
7568 code for the old ABI, these will already have been done. */
7569
7570 static bfd_boolean
adjust_opd_syms(struct elf_link_hash_entry * h,void * inf ATTRIBUTE_UNUSED)7571 adjust_opd_syms (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
7572 {
7573 struct ppc_link_hash_entry *eh;
7574 asection *sym_sec;
7575 struct _opd_sec_data *opd;
7576
7577 if (h->root.type == bfd_link_hash_indirect)
7578 return TRUE;
7579
7580 if (h->root.type != bfd_link_hash_defined
7581 && h->root.type != bfd_link_hash_defweak)
7582 return TRUE;
7583
7584 eh = (struct ppc_link_hash_entry *) h;
7585 if (eh->adjust_done)
7586 return TRUE;
7587
7588 sym_sec = eh->elf.root.u.def.section;
7589 opd = get_opd_info (sym_sec);
7590 if (opd != NULL && opd->adjust != NULL)
7591 {
7592 long adjust = opd->adjust[OPD_NDX (eh->elf.root.u.def.value)];
7593 if (adjust == -1)
7594 {
7595 /* This entry has been deleted. */
7596 asection *dsec = ppc64_elf_tdata (sym_sec->owner)->deleted_section;
7597 if (dsec == NULL)
7598 {
7599 for (dsec = sym_sec->owner->sections; dsec; dsec = dsec->next)
7600 if (discarded_section (dsec))
7601 {
7602 ppc64_elf_tdata (sym_sec->owner)->deleted_section = dsec;
7603 break;
7604 }
7605 }
7606 eh->elf.root.u.def.value = 0;
7607 eh->elf.root.u.def.section = dsec;
7608 }
7609 else
7610 eh->elf.root.u.def.value += adjust;
7611 eh->adjust_done = 1;
7612 }
7613 return TRUE;
7614 }
7615
7616 /* Handles decrementing dynamic reloc counts for the reloc specified by
7617 R_INFO in section SEC. If LOCAL_SYMS is NULL, then H and SYM
7618 have already been determined. */
7619
7620 static bfd_boolean
dec_dynrel_count(bfd_vma r_info,asection * sec,struct bfd_link_info * info,Elf_Internal_Sym ** local_syms,struct elf_link_hash_entry * h,Elf_Internal_Sym * sym)7621 dec_dynrel_count (bfd_vma r_info,
7622 asection *sec,
7623 struct bfd_link_info *info,
7624 Elf_Internal_Sym **local_syms,
7625 struct elf_link_hash_entry *h,
7626 Elf_Internal_Sym *sym)
7627 {
7628 enum elf_ppc64_reloc_type r_type;
7629 asection *sym_sec = NULL;
7630
7631 /* Can this reloc be dynamic? This switch, and later tests here
7632 should be kept in sync with the code in check_relocs. */
7633 r_type = ELF64_R_TYPE (r_info);
7634 switch (r_type)
7635 {
7636 default:
7637 return TRUE;
7638
7639 case R_PPC64_TPREL16:
7640 case R_PPC64_TPREL16_LO:
7641 case R_PPC64_TPREL16_HI:
7642 case R_PPC64_TPREL16_HA:
7643 case R_PPC64_TPREL16_DS:
7644 case R_PPC64_TPREL16_LO_DS:
7645 case R_PPC64_TPREL16_HIGH:
7646 case R_PPC64_TPREL16_HIGHA:
7647 case R_PPC64_TPREL16_HIGHER:
7648 case R_PPC64_TPREL16_HIGHERA:
7649 case R_PPC64_TPREL16_HIGHEST:
7650 case R_PPC64_TPREL16_HIGHESTA:
7651 if (!bfd_link_pic (info))
7652 return TRUE;
7653
7654 case R_PPC64_TPREL64:
7655 case R_PPC64_DTPMOD64:
7656 case R_PPC64_DTPREL64:
7657 case R_PPC64_ADDR64:
7658 case R_PPC64_REL30:
7659 case R_PPC64_REL32:
7660 case R_PPC64_REL64:
7661 case R_PPC64_ADDR14:
7662 case R_PPC64_ADDR14_BRNTAKEN:
7663 case R_PPC64_ADDR14_BRTAKEN:
7664 case R_PPC64_ADDR16:
7665 case R_PPC64_ADDR16_DS:
7666 case R_PPC64_ADDR16_HA:
7667 case R_PPC64_ADDR16_HI:
7668 case R_PPC64_ADDR16_HIGH:
7669 case R_PPC64_ADDR16_HIGHA:
7670 case R_PPC64_ADDR16_HIGHER:
7671 case R_PPC64_ADDR16_HIGHERA:
7672 case R_PPC64_ADDR16_HIGHEST:
7673 case R_PPC64_ADDR16_HIGHESTA:
7674 case R_PPC64_ADDR16_LO:
7675 case R_PPC64_ADDR16_LO_DS:
7676 case R_PPC64_ADDR24:
7677 case R_PPC64_ADDR32:
7678 case R_PPC64_UADDR16:
7679 case R_PPC64_UADDR32:
7680 case R_PPC64_UADDR64:
7681 case R_PPC64_TOC:
7682 break;
7683 }
7684
7685 if (local_syms != NULL)
7686 {
7687 unsigned long r_symndx;
7688 bfd *ibfd = sec->owner;
7689
7690 r_symndx = ELF64_R_SYM (r_info);
7691 if (!get_sym_h (&h, &sym, &sym_sec, NULL, local_syms, r_symndx, ibfd))
7692 return FALSE;
7693 }
7694
7695 if ((bfd_link_pic (info)
7696 && (must_be_dyn_reloc (info, r_type)
7697 || (h != NULL
7698 && (!SYMBOLIC_BIND (info, h)
7699 || h->root.type == bfd_link_hash_defweak
7700 || !h->def_regular))))
7701 || (ELIMINATE_COPY_RELOCS
7702 && !bfd_link_pic (info)
7703 && h != NULL
7704 && (h->root.type == bfd_link_hash_defweak
7705 || !h->def_regular)))
7706 ;
7707 else
7708 return TRUE;
7709
7710 if (h != NULL)
7711 {
7712 struct elf_dyn_relocs *p;
7713 struct elf_dyn_relocs **pp;
7714 pp = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
7715
7716 /* elf_gc_sweep may have already removed all dyn relocs associated
7717 with local syms for a given section. Also, symbol flags are
7718 changed by elf_gc_sweep_symbol, confusing the test above. Don't
7719 report a dynreloc miscount. */
7720 if (*pp == NULL && info->gc_sections)
7721 return TRUE;
7722
7723 while ((p = *pp) != NULL)
7724 {
7725 if (p->sec == sec)
7726 {
7727 if (!must_be_dyn_reloc (info, r_type))
7728 p->pc_count -= 1;
7729 p->count -= 1;
7730 if (p->count == 0)
7731 *pp = p->next;
7732 return TRUE;
7733 }
7734 pp = &p->next;
7735 }
7736 }
7737 else
7738 {
7739 struct ppc_dyn_relocs *p;
7740 struct ppc_dyn_relocs **pp;
7741 void *vpp;
7742 bfd_boolean is_ifunc;
7743
7744 if (local_syms == NULL)
7745 sym_sec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
7746 if (sym_sec == NULL)
7747 sym_sec = sec;
7748
7749 vpp = &elf_section_data (sym_sec)->local_dynrel;
7750 pp = (struct ppc_dyn_relocs **) vpp;
7751
7752 if (*pp == NULL && info->gc_sections)
7753 return TRUE;
7754
7755 is_ifunc = ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC;
7756 while ((p = *pp) != NULL)
7757 {
7758 if (p->sec == sec && p->ifunc == is_ifunc)
7759 {
7760 p->count -= 1;
7761 if (p->count == 0)
7762 *pp = p->next;
7763 return TRUE;
7764 }
7765 pp = &p->next;
7766 }
7767 }
7768
7769 info->callbacks->einfo (_("%P: dynreloc miscount for %B, section %A\n"),
7770 sec->owner, sec);
7771 bfd_set_error (bfd_error_bad_value);
7772 return FALSE;
7773 }
7774
7775 /* Remove unused Official Procedure Descriptor entries. Currently we
7776 only remove those associated with functions in discarded link-once
7777 sections, or weakly defined functions that have been overridden. It
7778 would be possible to remove many more entries for statically linked
7779 applications. */
7780
7781 bfd_boolean
ppc64_elf_edit_opd(struct bfd_link_info * info)7782 ppc64_elf_edit_opd (struct bfd_link_info *info)
7783 {
7784 bfd *ibfd;
7785 bfd_boolean some_edited = FALSE;
7786 asection *need_pad = NULL;
7787 struct ppc_link_hash_table *htab;
7788
7789 htab = ppc_hash_table (info);
7790 if (htab == NULL)
7791 return FALSE;
7792
7793 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
7794 {
7795 asection *sec;
7796 Elf_Internal_Rela *relstart, *rel, *relend;
7797 Elf_Internal_Shdr *symtab_hdr;
7798 Elf_Internal_Sym *local_syms;
7799 struct _opd_sec_data *opd;
7800 bfd_boolean need_edit, add_aux_fields, broken;
7801 bfd_size_type cnt_16b = 0;
7802
7803 if (!is_ppc64_elf (ibfd))
7804 continue;
7805
7806 sec = bfd_get_section_by_name (ibfd, ".opd");
7807 if (sec == NULL || sec->size == 0)
7808 continue;
7809
7810 if (sec->sec_info_type == SEC_INFO_TYPE_JUST_SYMS)
7811 continue;
7812
7813 if (sec->output_section == bfd_abs_section_ptr)
7814 continue;
7815
7816 /* Look through the section relocs. */
7817 if ((sec->flags & SEC_RELOC) == 0 || sec->reloc_count == 0)
7818 continue;
7819
7820 local_syms = NULL;
7821 symtab_hdr = &elf_symtab_hdr (ibfd);
7822
7823 /* Read the relocations. */
7824 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
7825 info->keep_memory);
7826 if (relstart == NULL)
7827 return FALSE;
7828
7829 /* First run through the relocs to check they are sane, and to
7830 determine whether we need to edit this opd section. */
7831 need_edit = FALSE;
7832 broken = FALSE;
7833 need_pad = sec;
7834 relend = relstart + sec->reloc_count;
7835 for (rel = relstart; rel < relend; )
7836 {
7837 enum elf_ppc64_reloc_type r_type;
7838 unsigned long r_symndx;
7839 asection *sym_sec;
7840 struct elf_link_hash_entry *h;
7841 Elf_Internal_Sym *sym;
7842 bfd_vma offset;
7843
7844 /* .opd contains an array of 16 or 24 byte entries. We're
7845 only interested in the reloc pointing to a function entry
7846 point. */
7847 offset = rel->r_offset;
7848 if (rel + 1 == relend
7849 || rel[1].r_offset != offset + 8)
7850 {
7851 /* If someone messes with .opd alignment then after a
7852 "ld -r" we might have padding in the middle of .opd.
7853 Also, there's nothing to prevent someone putting
7854 something silly in .opd with the assembler. No .opd
7855 optimization for them! */
7856 broken_opd:
7857 (*_bfd_error_handler)
7858 (_("%B: .opd is not a regular array of opd entries"), ibfd);
7859 broken = TRUE;
7860 break;
7861 }
7862
7863 if ((r_type = ELF64_R_TYPE (rel->r_info)) != R_PPC64_ADDR64
7864 || (r_type = ELF64_R_TYPE ((rel + 1)->r_info)) != R_PPC64_TOC)
7865 {
7866 (*_bfd_error_handler)
7867 (_("%B: unexpected reloc type %u in .opd section"),
7868 ibfd, r_type);
7869 broken = TRUE;
7870 break;
7871 }
7872
7873 r_symndx = ELF64_R_SYM (rel->r_info);
7874 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7875 r_symndx, ibfd))
7876 goto error_ret;
7877
7878 if (sym_sec == NULL || sym_sec->owner == NULL)
7879 {
7880 const char *sym_name;
7881 if (h != NULL)
7882 sym_name = h->root.root.string;
7883 else
7884 sym_name = bfd_elf_sym_name (ibfd, symtab_hdr, sym,
7885 sym_sec);
7886
7887 (*_bfd_error_handler)
7888 (_("%B: undefined sym `%s' in .opd section"),
7889 ibfd, sym_name);
7890 broken = TRUE;
7891 break;
7892 }
7893
7894 /* opd entries are always for functions defined in the
7895 current input bfd. If the symbol isn't defined in the
7896 input bfd, then we won't be using the function in this
7897 bfd; It must be defined in a linkonce section in another
7898 bfd, or is weak. It's also possible that we are
7899 discarding the function due to a linker script /DISCARD/,
7900 which we test for via the output_section. */
7901 if (sym_sec->owner != ibfd
7902 || sym_sec->output_section == bfd_abs_section_ptr)
7903 need_edit = TRUE;
7904
7905 rel += 2;
7906 if (rel + 1 == relend
7907 || (rel + 2 < relend
7908 && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_TOC))
7909 ++rel;
7910
7911 if (rel == relend)
7912 {
7913 if (sec->size == offset + 24)
7914 {
7915 need_pad = NULL;
7916 break;
7917 }
7918 if (sec->size == offset + 16)
7919 {
7920 cnt_16b++;
7921 break;
7922 }
7923 goto broken_opd;
7924 }
7925 else if (rel + 1 < relend
7926 && ELF64_R_TYPE (rel[0].r_info) == R_PPC64_ADDR64
7927 && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOC)
7928 {
7929 if (rel[0].r_offset == offset + 16)
7930 cnt_16b++;
7931 else if (rel[0].r_offset != offset + 24)
7932 goto broken_opd;
7933 }
7934 else
7935 goto broken_opd;
7936 }
7937
7938 add_aux_fields = htab->params->non_overlapping_opd && cnt_16b > 0;
7939
7940 if (!broken && (need_edit || add_aux_fields))
7941 {
7942 Elf_Internal_Rela *write_rel;
7943 Elf_Internal_Shdr *rel_hdr;
7944 bfd_byte *rptr, *wptr;
7945 bfd_byte *new_contents;
7946 bfd_size_type amt;
7947
7948 new_contents = NULL;
7949 amt = OPD_NDX (sec->size) * sizeof (long);
7950 opd = &ppc64_elf_section_data (sec)->u.opd;
7951 opd->adjust = bfd_zalloc (sec->owner, amt);
7952 if (opd->adjust == NULL)
7953 return FALSE;
7954 ppc64_elf_section_data (sec)->sec_type = sec_opd;
7955
7956 /* This seems a waste of time as input .opd sections are all
7957 zeros as generated by gcc, but I suppose there's no reason
7958 this will always be so. We might start putting something in
7959 the third word of .opd entries. */
7960 if ((sec->flags & SEC_IN_MEMORY) == 0)
7961 {
7962 bfd_byte *loc;
7963 if (!bfd_malloc_and_get_section (ibfd, sec, &loc))
7964 {
7965 if (loc != NULL)
7966 free (loc);
7967 error_ret:
7968 if (local_syms != NULL
7969 && symtab_hdr->contents != (unsigned char *) local_syms)
7970 free (local_syms);
7971 if (elf_section_data (sec)->relocs != relstart)
7972 free (relstart);
7973 return FALSE;
7974 }
7975 sec->contents = loc;
7976 sec->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
7977 }
7978
7979 elf_section_data (sec)->relocs = relstart;
7980
7981 new_contents = sec->contents;
7982 if (add_aux_fields)
7983 {
7984 new_contents = bfd_malloc (sec->size + cnt_16b * 8);
7985 if (new_contents == NULL)
7986 return FALSE;
7987 need_pad = NULL;
7988 }
7989 wptr = new_contents;
7990 rptr = sec->contents;
7991 write_rel = relstart;
7992 for (rel = relstart; rel < relend; )
7993 {
7994 unsigned long r_symndx;
7995 asection *sym_sec;
7996 struct elf_link_hash_entry *h;
7997 struct ppc_link_hash_entry *fdh = NULL;
7998 Elf_Internal_Sym *sym;
7999 long opd_ent_size;
8000 Elf_Internal_Rela *next_rel;
8001 bfd_boolean skip;
8002
8003 r_symndx = ELF64_R_SYM (rel->r_info);
8004 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8005 r_symndx, ibfd))
8006 goto error_ret;
8007
8008 next_rel = rel + 2;
8009 if (next_rel + 1 == relend
8010 || (next_rel + 2 < relend
8011 && ELF64_R_TYPE (next_rel[2].r_info) == R_PPC64_TOC))
8012 ++next_rel;
8013
8014 /* See if the .opd entry is full 24 byte or
8015 16 byte (with fd_aux entry overlapped with next
8016 fd_func). */
8017 opd_ent_size = 24;
8018 if (next_rel == relend)
8019 {
8020 if (sec->size == rel->r_offset + 16)
8021 opd_ent_size = 16;
8022 }
8023 else if (next_rel->r_offset == rel->r_offset + 16)
8024 opd_ent_size = 16;
8025
8026 if (h != NULL
8027 && h->root.root.string[0] == '.')
8028 {
8029 fdh = lookup_fdh ((struct ppc_link_hash_entry *) h, htab);
8030 if (fdh != NULL
8031 && fdh->elf.root.type != bfd_link_hash_defined
8032 && fdh->elf.root.type != bfd_link_hash_defweak)
8033 fdh = NULL;
8034 }
8035
8036 skip = (sym_sec->owner != ibfd
8037 || sym_sec->output_section == bfd_abs_section_ptr);
8038 if (skip)
8039 {
8040 if (fdh != NULL && sym_sec->owner == ibfd)
8041 {
8042 /* Arrange for the function descriptor sym
8043 to be dropped. */
8044 fdh->elf.root.u.def.value = 0;
8045 fdh->elf.root.u.def.section = sym_sec;
8046 }
8047 opd->adjust[OPD_NDX (rel->r_offset)] = -1;
8048
8049 if (NO_OPD_RELOCS || bfd_link_relocatable (info))
8050 rel = next_rel;
8051 else
8052 while (1)
8053 {
8054 if (!dec_dynrel_count (rel->r_info, sec, info,
8055 NULL, h, sym))
8056 goto error_ret;
8057
8058 if (++rel == next_rel)
8059 break;
8060
8061 r_symndx = ELF64_R_SYM (rel->r_info);
8062 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8063 r_symndx, ibfd))
8064 goto error_ret;
8065 }
8066 }
8067 else
8068 {
8069 /* We'll be keeping this opd entry. */
8070 long adjust;
8071
8072 if (fdh != NULL)
8073 {
8074 /* Redefine the function descriptor symbol to
8075 this location in the opd section. It is
8076 necessary to update the value here rather
8077 than using an array of adjustments as we do
8078 for local symbols, because various places
8079 in the generic ELF code use the value
8080 stored in u.def.value. */
8081 fdh->elf.root.u.def.value = wptr - new_contents;
8082 fdh->adjust_done = 1;
8083 }
8084
8085 /* Local syms are a bit tricky. We could
8086 tweak them as they can be cached, but
8087 we'd need to look through the local syms
8088 for the function descriptor sym which we
8089 don't have at the moment. So keep an
8090 array of adjustments. */
8091 adjust = (wptr - new_contents) - (rptr - sec->contents);
8092 opd->adjust[OPD_NDX (rel->r_offset)] = adjust;
8093
8094 if (wptr != rptr)
8095 memcpy (wptr, rptr, opd_ent_size);
8096 wptr += opd_ent_size;
8097 if (add_aux_fields && opd_ent_size == 16)
8098 {
8099 memset (wptr, '\0', 8);
8100 wptr += 8;
8101 }
8102
8103 /* We need to adjust any reloc offsets to point to the
8104 new opd entries. */
8105 for ( ; rel != next_rel; ++rel)
8106 {
8107 rel->r_offset += adjust;
8108 if (write_rel != rel)
8109 memcpy (write_rel, rel, sizeof (*rel));
8110 ++write_rel;
8111 }
8112 }
8113
8114 rptr += opd_ent_size;
8115 }
8116
8117 sec->size = wptr - new_contents;
8118 sec->reloc_count = write_rel - relstart;
8119 if (add_aux_fields)
8120 {
8121 free (sec->contents);
8122 sec->contents = new_contents;
8123 }
8124
8125 /* Fudge the header size too, as this is used later in
8126 elf_bfd_final_link if we are emitting relocs. */
8127 rel_hdr = _bfd_elf_single_rel_hdr (sec);
8128 rel_hdr->sh_size = sec->reloc_count * rel_hdr->sh_entsize;
8129 some_edited = TRUE;
8130 }
8131 else if (elf_section_data (sec)->relocs != relstart)
8132 free (relstart);
8133
8134 if (local_syms != NULL
8135 && symtab_hdr->contents != (unsigned char *) local_syms)
8136 {
8137 if (!info->keep_memory)
8138 free (local_syms);
8139 else
8140 symtab_hdr->contents = (unsigned char *) local_syms;
8141 }
8142 }
8143
8144 if (some_edited)
8145 elf_link_hash_traverse (elf_hash_table (info), adjust_opd_syms, NULL);
8146
8147 /* If we are doing a final link and the last .opd entry is just 16 byte
8148 long, add a 8 byte padding after it. */
8149 if (need_pad != NULL && !bfd_link_relocatable (info))
8150 {
8151 bfd_byte *p;
8152
8153 if ((need_pad->flags & SEC_IN_MEMORY) == 0)
8154 {
8155 BFD_ASSERT (need_pad->size > 0);
8156
8157 p = bfd_malloc (need_pad->size + 8);
8158 if (p == NULL)
8159 return FALSE;
8160
8161 if (! bfd_get_section_contents (need_pad->owner, need_pad,
8162 p, 0, need_pad->size))
8163 return FALSE;
8164
8165 need_pad->contents = p;
8166 need_pad->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
8167 }
8168 else
8169 {
8170 p = bfd_realloc (need_pad->contents, need_pad->size + 8);
8171 if (p == NULL)
8172 return FALSE;
8173
8174 need_pad->contents = p;
8175 }
8176
8177 memset (need_pad->contents + need_pad->size, 0, 8);
8178 need_pad->size += 8;
8179 }
8180
8181 return TRUE;
8182 }
8183
8184 /* Set htab->tls_get_addr and call the generic ELF tls_setup function. */
8185
8186 asection *
ppc64_elf_tls_setup(struct bfd_link_info * info)8187 ppc64_elf_tls_setup (struct bfd_link_info *info)
8188 {
8189 struct ppc_link_hash_table *htab;
8190
8191 htab = ppc_hash_table (info);
8192 if (htab == NULL)
8193 return NULL;
8194
8195 if (abiversion (info->output_bfd) == 1)
8196 htab->opd_abi = 1;
8197
8198 if (htab->params->no_multi_toc)
8199 htab->do_multi_toc = 0;
8200 else if (!htab->do_multi_toc)
8201 htab->params->no_multi_toc = 1;
8202
8203 htab->tls_get_addr = ((struct ppc_link_hash_entry *)
8204 elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
8205 FALSE, FALSE, TRUE));
8206 /* Move dynamic linking info to the function descriptor sym. */
8207 if (htab->tls_get_addr != NULL)
8208 func_desc_adjust (&htab->tls_get_addr->elf, info);
8209 htab->tls_get_addr_fd = ((struct ppc_link_hash_entry *)
8210 elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
8211 FALSE, FALSE, TRUE));
8212 if (htab->params->tls_get_addr_opt)
8213 {
8214 struct elf_link_hash_entry *opt, *opt_fd, *tga, *tga_fd;
8215
8216 opt = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr_opt",
8217 FALSE, FALSE, TRUE);
8218 if (opt != NULL)
8219 func_desc_adjust (opt, info);
8220 opt_fd = elf_link_hash_lookup (&htab->elf, "__tls_get_addr_opt",
8221 FALSE, FALSE, TRUE);
8222 if (opt_fd != NULL
8223 && (opt_fd->root.type == bfd_link_hash_defined
8224 || opt_fd->root.type == bfd_link_hash_defweak))
8225 {
8226 /* If glibc supports an optimized __tls_get_addr call stub,
8227 signalled by the presence of __tls_get_addr_opt, and we'll
8228 be calling __tls_get_addr via a plt call stub, then
8229 make __tls_get_addr point to __tls_get_addr_opt. */
8230 tga_fd = &htab->tls_get_addr_fd->elf;
8231 if (htab->elf.dynamic_sections_created
8232 && tga_fd != NULL
8233 && (tga_fd->type == STT_FUNC
8234 || tga_fd->needs_plt)
8235 && !(SYMBOL_CALLS_LOCAL (info, tga_fd)
8236 || (ELF_ST_VISIBILITY (tga_fd->other) != STV_DEFAULT
8237 && tga_fd->root.type == bfd_link_hash_undefweak)))
8238 {
8239 struct plt_entry *ent;
8240
8241 for (ent = tga_fd->plt.plist; ent != NULL; ent = ent->next)
8242 if (ent->plt.refcount > 0)
8243 break;
8244 if (ent != NULL)
8245 {
8246 tga_fd->root.type = bfd_link_hash_indirect;
8247 tga_fd->root.u.i.link = &opt_fd->root;
8248 ppc64_elf_copy_indirect_symbol (info, opt_fd, tga_fd);
8249 opt_fd->forced_local = 0;
8250 if (opt_fd->dynindx != -1)
8251 {
8252 /* Use __tls_get_addr_opt in dynamic relocations. */
8253 opt_fd->dynindx = -1;
8254 _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
8255 opt_fd->dynstr_index);
8256 if (!bfd_elf_link_record_dynamic_symbol (info, opt_fd))
8257 return NULL;
8258 }
8259 htab->tls_get_addr_fd = (struct ppc_link_hash_entry *) opt_fd;
8260 tga = &htab->tls_get_addr->elf;
8261 if (opt != NULL && tga != NULL)
8262 {
8263 tga->root.type = bfd_link_hash_indirect;
8264 tga->root.u.i.link = &opt->root;
8265 ppc64_elf_copy_indirect_symbol (info, opt, tga);
8266 opt->forced_local = 0;
8267 _bfd_elf_link_hash_hide_symbol (info, opt,
8268 tga->forced_local);
8269 htab->tls_get_addr = (struct ppc_link_hash_entry *) opt;
8270 }
8271 htab->tls_get_addr_fd->oh = htab->tls_get_addr;
8272 htab->tls_get_addr_fd->is_func_descriptor = 1;
8273 if (htab->tls_get_addr != NULL)
8274 {
8275 htab->tls_get_addr->oh = htab->tls_get_addr_fd;
8276 htab->tls_get_addr->is_func = 1;
8277 }
8278 }
8279 }
8280 }
8281 else if (htab->params->tls_get_addr_opt < 0)
8282 htab->params->tls_get_addr_opt = 0;
8283 }
8284 return _bfd_elf_tls_setup (info->output_bfd, info);
8285 }
8286
8287 /* Return TRUE iff REL is a branch reloc with a global symbol matching
8288 HASH1 or HASH2. */
8289
8290 static bfd_boolean
branch_reloc_hash_match(const bfd * ibfd,const Elf_Internal_Rela * rel,const struct ppc_link_hash_entry * hash1,const struct ppc_link_hash_entry * hash2)8291 branch_reloc_hash_match (const bfd *ibfd,
8292 const Elf_Internal_Rela *rel,
8293 const struct ppc_link_hash_entry *hash1,
8294 const struct ppc_link_hash_entry *hash2)
8295 {
8296 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
8297 enum elf_ppc64_reloc_type r_type = ELF64_R_TYPE (rel->r_info);
8298 unsigned int r_symndx = ELF64_R_SYM (rel->r_info);
8299
8300 if (r_symndx >= symtab_hdr->sh_info && is_branch_reloc (r_type))
8301 {
8302 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
8303 struct elf_link_hash_entry *h;
8304
8305 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
8306 h = elf_follow_link (h);
8307 if (h == &hash1->elf || h == &hash2->elf)
8308 return TRUE;
8309 }
8310 return FALSE;
8311 }
8312
8313 /* Run through all the TLS relocs looking for optimization
8314 opportunities. The linker has been hacked (see ppc64elf.em) to do
8315 a preliminary section layout so that we know the TLS segment
8316 offsets. We can't optimize earlier because some optimizations need
8317 to know the tp offset, and we need to optimize before allocating
8318 dynamic relocations. */
8319
8320 bfd_boolean
ppc64_elf_tls_optimize(struct bfd_link_info * info)8321 ppc64_elf_tls_optimize (struct bfd_link_info *info)
8322 {
8323 bfd *ibfd;
8324 asection *sec;
8325 struct ppc_link_hash_table *htab;
8326 unsigned char *toc_ref;
8327 int pass;
8328
8329 if (!bfd_link_executable (info))
8330 return TRUE;
8331
8332 htab = ppc_hash_table (info);
8333 if (htab == NULL)
8334 return FALSE;
8335
8336 /* Make two passes over the relocs. On the first pass, mark toc
8337 entries involved with tls relocs, and check that tls relocs
8338 involved in setting up a tls_get_addr call are indeed followed by
8339 such a call. If they are not, we can't do any tls optimization.
8340 On the second pass twiddle tls_mask flags to notify
8341 relocate_section that optimization can be done, and adjust got
8342 and plt refcounts. */
8343 toc_ref = NULL;
8344 for (pass = 0; pass < 2; ++pass)
8345 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
8346 {
8347 Elf_Internal_Sym *locsyms = NULL;
8348 asection *toc = bfd_get_section_by_name (ibfd, ".toc");
8349
8350 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8351 if (sec->has_tls_reloc && !bfd_is_abs_section (sec->output_section))
8352 {
8353 Elf_Internal_Rela *relstart, *rel, *relend;
8354 bfd_boolean found_tls_get_addr_arg = 0;
8355
8356 /* Read the relocations. */
8357 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8358 info->keep_memory);
8359 if (relstart == NULL)
8360 {
8361 free (toc_ref);
8362 return FALSE;
8363 }
8364
8365 relend = relstart + sec->reloc_count;
8366 for (rel = relstart; rel < relend; rel++)
8367 {
8368 enum elf_ppc64_reloc_type r_type;
8369 unsigned long r_symndx;
8370 struct elf_link_hash_entry *h;
8371 Elf_Internal_Sym *sym;
8372 asection *sym_sec;
8373 unsigned char *tls_mask;
8374 unsigned char tls_set, tls_clear, tls_type = 0;
8375 bfd_vma value;
8376 bfd_boolean ok_tprel, is_local;
8377 long toc_ref_index = 0;
8378 int expecting_tls_get_addr = 0;
8379 bfd_boolean ret = FALSE;
8380
8381 r_symndx = ELF64_R_SYM (rel->r_info);
8382 if (!get_sym_h (&h, &sym, &sym_sec, &tls_mask, &locsyms,
8383 r_symndx, ibfd))
8384 {
8385 err_free_rel:
8386 if (elf_section_data (sec)->relocs != relstart)
8387 free (relstart);
8388 if (toc_ref != NULL)
8389 free (toc_ref);
8390 if (locsyms != NULL
8391 && (elf_symtab_hdr (ibfd).contents
8392 != (unsigned char *) locsyms))
8393 free (locsyms);
8394 return ret;
8395 }
8396
8397 if (h != NULL)
8398 {
8399 if (h->root.type == bfd_link_hash_defined
8400 || h->root.type == bfd_link_hash_defweak)
8401 value = h->root.u.def.value;
8402 else if (h->root.type == bfd_link_hash_undefweak)
8403 value = 0;
8404 else
8405 {
8406 found_tls_get_addr_arg = 0;
8407 continue;
8408 }
8409 }
8410 else
8411 /* Symbols referenced by TLS relocs must be of type
8412 STT_TLS. So no need for .opd local sym adjust. */
8413 value = sym->st_value;
8414
8415 ok_tprel = FALSE;
8416 is_local = FALSE;
8417 if (h == NULL
8418 || !h->def_dynamic)
8419 {
8420 is_local = TRUE;
8421 if (h != NULL
8422 && h->root.type == bfd_link_hash_undefweak)
8423 ok_tprel = TRUE;
8424 else if (sym_sec != NULL
8425 && sym_sec->output_section != NULL)
8426 {
8427 value += sym_sec->output_offset;
8428 value += sym_sec->output_section->vma;
8429 value -= htab->elf.tls_sec->vma;
8430 ok_tprel = (value + TP_OFFSET + ((bfd_vma) 1 << 31)
8431 < (bfd_vma) 1 << 32);
8432 }
8433 }
8434
8435 r_type = ELF64_R_TYPE (rel->r_info);
8436 /* If this section has old-style __tls_get_addr calls
8437 without marker relocs, then check that each
8438 __tls_get_addr call reloc is preceded by a reloc
8439 that conceivably belongs to the __tls_get_addr arg
8440 setup insn. If we don't find matching arg setup
8441 relocs, don't do any tls optimization. */
8442 if (pass == 0
8443 && sec->has_tls_get_addr_call
8444 && h != NULL
8445 && (h == &htab->tls_get_addr->elf
8446 || h == &htab->tls_get_addr_fd->elf)
8447 && !found_tls_get_addr_arg
8448 && is_branch_reloc (r_type))
8449 {
8450 info->callbacks->minfo (_("%H __tls_get_addr lost arg, "
8451 "TLS optimization disabled\n"),
8452 ibfd, sec, rel->r_offset);
8453 ret = TRUE;
8454 goto err_free_rel;
8455 }
8456
8457 found_tls_get_addr_arg = 0;
8458 switch (r_type)
8459 {
8460 case R_PPC64_GOT_TLSLD16:
8461 case R_PPC64_GOT_TLSLD16_LO:
8462 expecting_tls_get_addr = 1;
8463 found_tls_get_addr_arg = 1;
8464 /* Fall thru */
8465
8466 case R_PPC64_GOT_TLSLD16_HI:
8467 case R_PPC64_GOT_TLSLD16_HA:
8468 /* These relocs should never be against a symbol
8469 defined in a shared lib. Leave them alone if
8470 that turns out to be the case. */
8471 if (!is_local)
8472 continue;
8473
8474 /* LD -> LE */
8475 tls_set = 0;
8476 tls_clear = TLS_LD;
8477 tls_type = TLS_TLS | TLS_LD;
8478 break;
8479
8480 case R_PPC64_GOT_TLSGD16:
8481 case R_PPC64_GOT_TLSGD16_LO:
8482 expecting_tls_get_addr = 1;
8483 found_tls_get_addr_arg = 1;
8484 /* Fall thru */
8485
8486 case R_PPC64_GOT_TLSGD16_HI:
8487 case R_PPC64_GOT_TLSGD16_HA:
8488 if (ok_tprel)
8489 /* GD -> LE */
8490 tls_set = 0;
8491 else
8492 /* GD -> IE */
8493 tls_set = TLS_TLS | TLS_TPRELGD;
8494 tls_clear = TLS_GD;
8495 tls_type = TLS_TLS | TLS_GD;
8496 break;
8497
8498 case R_PPC64_GOT_TPREL16_DS:
8499 case R_PPC64_GOT_TPREL16_LO_DS:
8500 case R_PPC64_GOT_TPREL16_HI:
8501 case R_PPC64_GOT_TPREL16_HA:
8502 if (ok_tprel)
8503 {
8504 /* IE -> LE */
8505 tls_set = 0;
8506 tls_clear = TLS_TPREL;
8507 tls_type = TLS_TLS | TLS_TPREL;
8508 break;
8509 }
8510 continue;
8511
8512 case R_PPC64_TLSGD:
8513 case R_PPC64_TLSLD:
8514 found_tls_get_addr_arg = 1;
8515 /* Fall thru */
8516
8517 case R_PPC64_TLS:
8518 case R_PPC64_TOC16:
8519 case R_PPC64_TOC16_LO:
8520 if (sym_sec == NULL || sym_sec != toc)
8521 continue;
8522
8523 /* Mark this toc entry as referenced by a TLS
8524 code sequence. We can do that now in the
8525 case of R_PPC64_TLS, and after checking for
8526 tls_get_addr for the TOC16 relocs. */
8527 if (toc_ref == NULL)
8528 toc_ref = bfd_zmalloc (toc->output_section->rawsize / 8);
8529 if (toc_ref == NULL)
8530 goto err_free_rel;
8531
8532 if (h != NULL)
8533 value = h->root.u.def.value;
8534 else
8535 value = sym->st_value;
8536 value += rel->r_addend;
8537 if (value % 8 != 0)
8538 continue;
8539 BFD_ASSERT (value < toc->size
8540 && toc->output_offset % 8 == 0);
8541 toc_ref_index = (value + toc->output_offset) / 8;
8542 if (r_type == R_PPC64_TLS
8543 || r_type == R_PPC64_TLSGD
8544 || r_type == R_PPC64_TLSLD)
8545 {
8546 toc_ref[toc_ref_index] = 1;
8547 continue;
8548 }
8549
8550 if (pass != 0 && toc_ref[toc_ref_index] == 0)
8551 continue;
8552
8553 tls_set = 0;
8554 tls_clear = 0;
8555 expecting_tls_get_addr = 2;
8556 break;
8557
8558 case R_PPC64_TPREL64:
8559 if (pass == 0
8560 || sec != toc
8561 || toc_ref == NULL
8562 || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
8563 continue;
8564 if (ok_tprel)
8565 {
8566 /* IE -> LE */
8567 tls_set = TLS_EXPLICIT;
8568 tls_clear = TLS_TPREL;
8569 break;
8570 }
8571 continue;
8572
8573 case R_PPC64_DTPMOD64:
8574 if (pass == 0
8575 || sec != toc
8576 || toc_ref == NULL
8577 || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
8578 continue;
8579 if (rel + 1 < relend
8580 && (rel[1].r_info
8581 == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64))
8582 && rel[1].r_offset == rel->r_offset + 8)
8583 {
8584 if (ok_tprel)
8585 /* GD -> LE */
8586 tls_set = TLS_EXPLICIT | TLS_GD;
8587 else
8588 /* GD -> IE */
8589 tls_set = TLS_EXPLICIT | TLS_GD | TLS_TPRELGD;
8590 tls_clear = TLS_GD;
8591 }
8592 else
8593 {
8594 if (!is_local)
8595 continue;
8596
8597 /* LD -> LE */
8598 tls_set = TLS_EXPLICIT;
8599 tls_clear = TLS_LD;
8600 }
8601 break;
8602
8603 default:
8604 continue;
8605 }
8606
8607 if (pass == 0)
8608 {
8609 if (!expecting_tls_get_addr
8610 || !sec->has_tls_get_addr_call)
8611 continue;
8612
8613 if (rel + 1 < relend
8614 && branch_reloc_hash_match (ibfd, rel + 1,
8615 htab->tls_get_addr,
8616 htab->tls_get_addr_fd))
8617 {
8618 if (expecting_tls_get_addr == 2)
8619 {
8620 /* Check for toc tls entries. */
8621 unsigned char *toc_tls;
8622 int retval;
8623
8624 retval = get_tls_mask (&toc_tls, NULL, NULL,
8625 &locsyms,
8626 rel, ibfd);
8627 if (retval == 0)
8628 goto err_free_rel;
8629 if (toc_tls != NULL)
8630 {
8631 if ((*toc_tls & (TLS_GD | TLS_LD)) != 0)
8632 found_tls_get_addr_arg = 1;
8633 if (retval > 1)
8634 toc_ref[toc_ref_index] = 1;
8635 }
8636 }
8637 continue;
8638 }
8639
8640 if (expecting_tls_get_addr != 1)
8641 continue;
8642
8643 /* Uh oh, we didn't find the expected call. We
8644 could just mark this symbol to exclude it
8645 from tls optimization but it's safer to skip
8646 the entire optimization. */
8647 info->callbacks->minfo (_("%H arg lost __tls_get_addr, "
8648 "TLS optimization disabled\n"),
8649 ibfd, sec, rel->r_offset);
8650 ret = TRUE;
8651 goto err_free_rel;
8652 }
8653
8654 if (expecting_tls_get_addr && htab->tls_get_addr != NULL)
8655 {
8656 struct plt_entry *ent;
8657 for (ent = htab->tls_get_addr->elf.plt.plist;
8658 ent != NULL;
8659 ent = ent->next)
8660 if (ent->addend == 0)
8661 {
8662 if (ent->plt.refcount > 0)
8663 {
8664 ent->plt.refcount -= 1;
8665 expecting_tls_get_addr = 0;
8666 }
8667 break;
8668 }
8669 }
8670
8671 if (expecting_tls_get_addr && htab->tls_get_addr_fd != NULL)
8672 {
8673 struct plt_entry *ent;
8674 for (ent = htab->tls_get_addr_fd->elf.plt.plist;
8675 ent != NULL;
8676 ent = ent->next)
8677 if (ent->addend == 0)
8678 {
8679 if (ent->plt.refcount > 0)
8680 ent->plt.refcount -= 1;
8681 break;
8682 }
8683 }
8684
8685 if (tls_clear == 0)
8686 continue;
8687
8688 if ((tls_set & TLS_EXPLICIT) == 0)
8689 {
8690 struct got_entry *ent;
8691
8692 /* Adjust got entry for this reloc. */
8693 if (h != NULL)
8694 ent = h->got.glist;
8695 else
8696 ent = elf_local_got_ents (ibfd)[r_symndx];
8697
8698 for (; ent != NULL; ent = ent->next)
8699 if (ent->addend == rel->r_addend
8700 && ent->owner == ibfd
8701 && ent->tls_type == tls_type)
8702 break;
8703 if (ent == NULL)
8704 abort ();
8705
8706 if (tls_set == 0)
8707 {
8708 /* We managed to get rid of a got entry. */
8709 if (ent->got.refcount > 0)
8710 ent->got.refcount -= 1;
8711 }
8712 }
8713 else
8714 {
8715 /* If we got rid of a DTPMOD/DTPREL reloc pair then
8716 we'll lose one or two dyn relocs. */
8717 if (!dec_dynrel_count (rel->r_info, sec, info,
8718 NULL, h, sym))
8719 return FALSE;
8720
8721 if (tls_set == (TLS_EXPLICIT | TLS_GD))
8722 {
8723 if (!dec_dynrel_count ((rel + 1)->r_info, sec, info,
8724 NULL, h, sym))
8725 return FALSE;
8726 }
8727 }
8728
8729 *tls_mask |= tls_set;
8730 *tls_mask &= ~tls_clear;
8731 }
8732
8733 if (elf_section_data (sec)->relocs != relstart)
8734 free (relstart);
8735 }
8736
8737 if (locsyms != NULL
8738 && (elf_symtab_hdr (ibfd).contents != (unsigned char *) locsyms))
8739 {
8740 if (!info->keep_memory)
8741 free (locsyms);
8742 else
8743 elf_symtab_hdr (ibfd).contents = (unsigned char *) locsyms;
8744 }
8745 }
8746
8747 if (toc_ref != NULL)
8748 free (toc_ref);
8749 return TRUE;
8750 }
8751
8752 /* Called via elf_link_hash_traverse from ppc64_elf_edit_toc to adjust
8753 the values of any global symbols in a toc section that has been
8754 edited. Globals in toc sections should be a rarity, so this function
8755 sets a flag if any are found in toc sections other than the one just
8756 edited, so that futher hash table traversals can be avoided. */
8757
8758 struct adjust_toc_info
8759 {
8760 asection *toc;
8761 unsigned long *skip;
8762 bfd_boolean global_toc_syms;
8763 };
8764
8765 enum toc_skip_enum { ref_from_discarded = 1, can_optimize = 2 };
8766
8767 static bfd_boolean
adjust_toc_syms(struct elf_link_hash_entry * h,void * inf)8768 adjust_toc_syms (struct elf_link_hash_entry *h, void *inf)
8769 {
8770 struct ppc_link_hash_entry *eh;
8771 struct adjust_toc_info *toc_inf = (struct adjust_toc_info *) inf;
8772 unsigned long i;
8773
8774 if (h->root.type != bfd_link_hash_defined
8775 && h->root.type != bfd_link_hash_defweak)
8776 return TRUE;
8777
8778 eh = (struct ppc_link_hash_entry *) h;
8779 if (eh->adjust_done)
8780 return TRUE;
8781
8782 if (eh->elf.root.u.def.section == toc_inf->toc)
8783 {
8784 if (eh->elf.root.u.def.value > toc_inf->toc->rawsize)
8785 i = toc_inf->toc->rawsize >> 3;
8786 else
8787 i = eh->elf.root.u.def.value >> 3;
8788
8789 if ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0)
8790 {
8791 (*_bfd_error_handler)
8792 (_("%s defined on removed toc entry"), eh->elf.root.root.string);
8793 do
8794 ++i;
8795 while ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0);
8796 eh->elf.root.u.def.value = (bfd_vma) i << 3;
8797 }
8798
8799 eh->elf.root.u.def.value -= toc_inf->skip[i];
8800 eh->adjust_done = 1;
8801 }
8802 else if (strcmp (eh->elf.root.u.def.section->name, ".toc") == 0)
8803 toc_inf->global_toc_syms = TRUE;
8804
8805 return TRUE;
8806 }
8807
8808 /* Return TRUE iff INSN with a relocation of R_TYPE is one we expect
8809 on a _LO variety toc/got reloc. */
8810
8811 static bfd_boolean
ok_lo_toc_insn(unsigned int insn,enum elf_ppc64_reloc_type r_type)8812 ok_lo_toc_insn (unsigned int insn, enum elf_ppc64_reloc_type r_type)
8813 {
8814 return ((insn & (0x3f << 26)) == 12u << 26 /* addic */
8815 || (insn & (0x3f << 26)) == 14u << 26 /* addi */
8816 || (insn & (0x3f << 26)) == 32u << 26 /* lwz */
8817 || (insn & (0x3f << 26)) == 34u << 26 /* lbz */
8818 || (insn & (0x3f << 26)) == 36u << 26 /* stw */
8819 || (insn & (0x3f << 26)) == 38u << 26 /* stb */
8820 || (insn & (0x3f << 26)) == 40u << 26 /* lhz */
8821 || (insn & (0x3f << 26)) == 42u << 26 /* lha */
8822 || (insn & (0x3f << 26)) == 44u << 26 /* sth */
8823 || (insn & (0x3f << 26)) == 46u << 26 /* lmw */
8824 || (insn & (0x3f << 26)) == 47u << 26 /* stmw */
8825 || (insn & (0x3f << 26)) == 48u << 26 /* lfs */
8826 || (insn & (0x3f << 26)) == 50u << 26 /* lfd */
8827 || (insn & (0x3f << 26)) == 52u << 26 /* stfs */
8828 || (insn & (0x3f << 26)) == 54u << 26 /* stfd */
8829 || (insn & (0x3f << 26)) == 56u << 26 /* lq,lfq */
8830 || ((insn & (0x3f << 26)) == 57u << 26 /* lxsd,lxssp,lfdp */
8831 /* Exclude lfqu by testing reloc. If relocs are ever
8832 defined for the reduced D field in psq_lu then those
8833 will need testing too. */
8834 && r_type != R_PPC64_TOC16_LO && r_type != R_PPC64_GOT16_LO)
8835 || ((insn & (0x3f << 26)) == 58u << 26 /* ld,lwa */
8836 && (insn & 1) == 0)
8837 || (insn & (0x3f << 26)) == 60u << 26 /* stfq */
8838 || ((insn & (0x3f << 26)) == 61u << 26 /* lxv,stx{v,sd,ssp},stfdp */
8839 /* Exclude stfqu. psq_stu as above for psq_lu. */
8840 && r_type != R_PPC64_TOC16_LO && r_type != R_PPC64_GOT16_LO)
8841 || ((insn & (0x3f << 26)) == 62u << 26 /* std,stq */
8842 && (insn & 1) == 0));
8843 }
8844
8845 /* Examine all relocs referencing .toc sections in order to remove
8846 unused .toc entries. */
8847
8848 bfd_boolean
ppc64_elf_edit_toc(struct bfd_link_info * info)8849 ppc64_elf_edit_toc (struct bfd_link_info *info)
8850 {
8851 bfd *ibfd;
8852 struct adjust_toc_info toc_inf;
8853 struct ppc_link_hash_table *htab = ppc_hash_table (info);
8854
8855 htab->do_toc_opt = 1;
8856 toc_inf.global_toc_syms = TRUE;
8857 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
8858 {
8859 asection *toc, *sec;
8860 Elf_Internal_Shdr *symtab_hdr;
8861 Elf_Internal_Sym *local_syms;
8862 Elf_Internal_Rela *relstart, *rel, *toc_relocs;
8863 unsigned long *skip, *drop;
8864 unsigned char *used;
8865 unsigned char *keep, last, some_unused;
8866
8867 if (!is_ppc64_elf (ibfd))
8868 continue;
8869
8870 toc = bfd_get_section_by_name (ibfd, ".toc");
8871 if (toc == NULL
8872 || toc->size == 0
8873 || toc->sec_info_type == SEC_INFO_TYPE_JUST_SYMS
8874 || discarded_section (toc))
8875 continue;
8876
8877 toc_relocs = NULL;
8878 local_syms = NULL;
8879 symtab_hdr = &elf_symtab_hdr (ibfd);
8880
8881 /* Look at sections dropped from the final link. */
8882 skip = NULL;
8883 relstart = NULL;
8884 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8885 {
8886 if (sec->reloc_count == 0
8887 || !discarded_section (sec)
8888 || get_opd_info (sec)
8889 || (sec->flags & SEC_ALLOC) == 0
8890 || (sec->flags & SEC_DEBUGGING) != 0)
8891 continue;
8892
8893 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL, FALSE);
8894 if (relstart == NULL)
8895 goto error_ret;
8896
8897 /* Run through the relocs to see which toc entries might be
8898 unused. */
8899 for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
8900 {
8901 enum elf_ppc64_reloc_type r_type;
8902 unsigned long r_symndx;
8903 asection *sym_sec;
8904 struct elf_link_hash_entry *h;
8905 Elf_Internal_Sym *sym;
8906 bfd_vma val;
8907
8908 r_type = ELF64_R_TYPE (rel->r_info);
8909 switch (r_type)
8910 {
8911 default:
8912 continue;
8913
8914 case R_PPC64_TOC16:
8915 case R_PPC64_TOC16_LO:
8916 case R_PPC64_TOC16_HI:
8917 case R_PPC64_TOC16_HA:
8918 case R_PPC64_TOC16_DS:
8919 case R_PPC64_TOC16_LO_DS:
8920 break;
8921 }
8922
8923 r_symndx = ELF64_R_SYM (rel->r_info);
8924 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8925 r_symndx, ibfd))
8926 goto error_ret;
8927
8928 if (sym_sec != toc)
8929 continue;
8930
8931 if (h != NULL)
8932 val = h->root.u.def.value;
8933 else
8934 val = sym->st_value;
8935 val += rel->r_addend;
8936
8937 if (val >= toc->size)
8938 continue;
8939
8940 /* Anything in the toc ought to be aligned to 8 bytes.
8941 If not, don't mark as unused. */
8942 if (val & 7)
8943 continue;
8944
8945 if (skip == NULL)
8946 {
8947 skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
8948 if (skip == NULL)
8949 goto error_ret;
8950 }
8951
8952 skip[val >> 3] = ref_from_discarded;
8953 }
8954
8955 if (elf_section_data (sec)->relocs != relstart)
8956 free (relstart);
8957 }
8958
8959 /* For largetoc loads of address constants, we can convert
8960 . addis rx,2,addr@got@ha
8961 . ld ry,addr@got@l(rx)
8962 to
8963 . addis rx,2,addr@toc@ha
8964 . addi ry,rx,addr@toc@l
8965 when addr is within 2G of the toc pointer. This then means
8966 that the word storing "addr" in the toc is no longer needed. */
8967
8968 if (!ppc64_elf_tdata (ibfd)->has_small_toc_reloc
8969 && toc->output_section->rawsize < (bfd_vma) 1 << 31
8970 && toc->reloc_count != 0)
8971 {
8972 /* Read toc relocs. */
8973 toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
8974 info->keep_memory);
8975 if (toc_relocs == NULL)
8976 goto error_ret;
8977
8978 for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
8979 {
8980 enum elf_ppc64_reloc_type r_type;
8981 unsigned long r_symndx;
8982 asection *sym_sec;
8983 struct elf_link_hash_entry *h;
8984 Elf_Internal_Sym *sym;
8985 bfd_vma val, addr;
8986
8987 r_type = ELF64_R_TYPE (rel->r_info);
8988 if (r_type != R_PPC64_ADDR64)
8989 continue;
8990
8991 r_symndx = ELF64_R_SYM (rel->r_info);
8992 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8993 r_symndx, ibfd))
8994 goto error_ret;
8995
8996 if (sym_sec == NULL
8997 || sym_sec->output_section == NULL
8998 || discarded_section (sym_sec))
8999 continue;
9000
9001 if (!SYMBOL_REFERENCES_LOCAL (info, h))
9002 continue;
9003
9004 if (h != NULL)
9005 {
9006 if (h->type == STT_GNU_IFUNC)
9007 continue;
9008 val = h->root.u.def.value;
9009 }
9010 else
9011 {
9012 if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
9013 continue;
9014 val = sym->st_value;
9015 }
9016 val += rel->r_addend;
9017 val += sym_sec->output_section->vma + sym_sec->output_offset;
9018
9019 /* We don't yet know the exact toc pointer value, but we
9020 know it will be somewhere in the toc section. Don't
9021 optimize if the difference from any possible toc
9022 pointer is outside [ff..f80008000, 7fff7fff]. */
9023 addr = toc->output_section->vma + TOC_BASE_OFF;
9024 if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
9025 continue;
9026
9027 addr = toc->output_section->vma + toc->output_section->rawsize;
9028 if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
9029 continue;
9030
9031 if (skip == NULL)
9032 {
9033 skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
9034 if (skip == NULL)
9035 goto error_ret;
9036 }
9037
9038 skip[rel->r_offset >> 3]
9039 |= can_optimize | ((rel - toc_relocs) << 2);
9040 }
9041 }
9042
9043 if (skip == NULL)
9044 continue;
9045
9046 used = bfd_zmalloc (sizeof (*used) * (toc->size + 7) / 8);
9047 if (used == NULL)
9048 {
9049 error_ret:
9050 if (local_syms != NULL
9051 && symtab_hdr->contents != (unsigned char *) local_syms)
9052 free (local_syms);
9053 if (sec != NULL
9054 && relstart != NULL
9055 && elf_section_data (sec)->relocs != relstart)
9056 free (relstart);
9057 if (toc_relocs != NULL
9058 && elf_section_data (toc)->relocs != toc_relocs)
9059 free (toc_relocs);
9060 if (skip != NULL)
9061 free (skip);
9062 return FALSE;
9063 }
9064
9065 /* Now check all kept sections that might reference the toc.
9066 Check the toc itself last. */
9067 for (sec = (ibfd->sections == toc && toc->next ? toc->next
9068 : ibfd->sections);
9069 sec != NULL;
9070 sec = (sec == toc ? NULL
9071 : sec->next == NULL ? toc
9072 : sec->next == toc && toc->next ? toc->next
9073 : sec->next))
9074 {
9075 int repeat;
9076
9077 if (sec->reloc_count == 0
9078 || discarded_section (sec)
9079 || get_opd_info (sec)
9080 || (sec->flags & SEC_ALLOC) == 0
9081 || (sec->flags & SEC_DEBUGGING) != 0)
9082 continue;
9083
9084 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
9085 info->keep_memory);
9086 if (relstart == NULL)
9087 {
9088 free (used);
9089 goto error_ret;
9090 }
9091
9092 /* Mark toc entries referenced as used. */
9093 do
9094 {
9095 repeat = 0;
9096 for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9097 {
9098 enum elf_ppc64_reloc_type r_type;
9099 unsigned long r_symndx;
9100 asection *sym_sec;
9101 struct elf_link_hash_entry *h;
9102 Elf_Internal_Sym *sym;
9103 bfd_vma val;
9104 enum {no_check, check_lo, check_ha} insn_check;
9105
9106 r_type = ELF64_R_TYPE (rel->r_info);
9107 switch (r_type)
9108 {
9109 default:
9110 insn_check = no_check;
9111 break;
9112
9113 case R_PPC64_GOT_TLSLD16_HA:
9114 case R_PPC64_GOT_TLSGD16_HA:
9115 case R_PPC64_GOT_TPREL16_HA:
9116 case R_PPC64_GOT_DTPREL16_HA:
9117 case R_PPC64_GOT16_HA:
9118 case R_PPC64_TOC16_HA:
9119 insn_check = check_ha;
9120 break;
9121
9122 case R_PPC64_GOT_TLSLD16_LO:
9123 case R_PPC64_GOT_TLSGD16_LO:
9124 case R_PPC64_GOT_TPREL16_LO_DS:
9125 case R_PPC64_GOT_DTPREL16_LO_DS:
9126 case R_PPC64_GOT16_LO:
9127 case R_PPC64_GOT16_LO_DS:
9128 case R_PPC64_TOC16_LO:
9129 case R_PPC64_TOC16_LO_DS:
9130 insn_check = check_lo;
9131 break;
9132 }
9133
9134 if (insn_check != no_check)
9135 {
9136 bfd_vma off = rel->r_offset & ~3;
9137 unsigned char buf[4];
9138 unsigned int insn;
9139
9140 if (!bfd_get_section_contents (ibfd, sec, buf, off, 4))
9141 {
9142 free (used);
9143 goto error_ret;
9144 }
9145 insn = bfd_get_32 (ibfd, buf);
9146 if (insn_check == check_lo
9147 ? !ok_lo_toc_insn (insn, r_type)
9148 : ((insn & ((0x3f << 26) | 0x1f << 16))
9149 != ((15u << 26) | (2 << 16)) /* addis rt,2,imm */))
9150 {
9151 char str[12];
9152
9153 ppc64_elf_tdata (ibfd)->unexpected_toc_insn = 1;
9154 sprintf (str, "%#08x", insn);
9155 info->callbacks->einfo
9156 (_("%P: %H: toc optimization is not supported for"
9157 " %s instruction.\n"),
9158 ibfd, sec, rel->r_offset & ~3, str);
9159 }
9160 }
9161
9162 switch (r_type)
9163 {
9164 case R_PPC64_TOC16:
9165 case R_PPC64_TOC16_LO:
9166 case R_PPC64_TOC16_HI:
9167 case R_PPC64_TOC16_HA:
9168 case R_PPC64_TOC16_DS:
9169 case R_PPC64_TOC16_LO_DS:
9170 /* In case we're taking addresses of toc entries. */
9171 case R_PPC64_ADDR64:
9172 break;
9173
9174 default:
9175 continue;
9176 }
9177
9178 r_symndx = ELF64_R_SYM (rel->r_info);
9179 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9180 r_symndx, ibfd))
9181 {
9182 free (used);
9183 goto error_ret;
9184 }
9185
9186 if (sym_sec != toc)
9187 continue;
9188
9189 if (h != NULL)
9190 val = h->root.u.def.value;
9191 else
9192 val = sym->st_value;
9193 val += rel->r_addend;
9194
9195 if (val >= toc->size)
9196 continue;
9197
9198 if ((skip[val >> 3] & can_optimize) != 0)
9199 {
9200 bfd_vma off;
9201 unsigned char opc;
9202
9203 switch (r_type)
9204 {
9205 case R_PPC64_TOC16_HA:
9206 break;
9207
9208 case R_PPC64_TOC16_LO_DS:
9209 off = rel->r_offset;
9210 off += (bfd_big_endian (ibfd) ? -2 : 3);
9211 if (!bfd_get_section_contents (ibfd, sec, &opc,
9212 off, 1))
9213 {
9214 free (used);
9215 goto error_ret;
9216 }
9217 if ((opc & (0x3f << 2)) == (58u << 2))
9218 break;
9219 /* Fall thru */
9220
9221 default:
9222 /* Wrong sort of reloc, or not a ld. We may
9223 as well clear ref_from_discarded too. */
9224 skip[val >> 3] = 0;
9225 }
9226 }
9227
9228 if (sec != toc)
9229 used[val >> 3] = 1;
9230 /* For the toc section, we only mark as used if this
9231 entry itself isn't unused. */
9232 else if ((used[rel->r_offset >> 3]
9233 || !(skip[rel->r_offset >> 3] & ref_from_discarded))
9234 && !used[val >> 3])
9235 {
9236 /* Do all the relocs again, to catch reference
9237 chains. */
9238 repeat = 1;
9239 used[val >> 3] = 1;
9240 }
9241 }
9242 }
9243 while (repeat);
9244
9245 if (elf_section_data (sec)->relocs != relstart)
9246 free (relstart);
9247 }
9248
9249 /* Merge the used and skip arrays. Assume that TOC
9250 doublewords not appearing as either used or unused belong
9251 to to an entry more than one doubleword in size. */
9252 for (drop = skip, keep = used, last = 0, some_unused = 0;
9253 drop < skip + (toc->size + 7) / 8;
9254 ++drop, ++keep)
9255 {
9256 if (*keep)
9257 {
9258 *drop &= ~ref_from_discarded;
9259 if ((*drop & can_optimize) != 0)
9260 some_unused = 1;
9261 last = 0;
9262 }
9263 else if ((*drop & ref_from_discarded) != 0)
9264 {
9265 some_unused = 1;
9266 last = ref_from_discarded;
9267 }
9268 else
9269 *drop = last;
9270 }
9271
9272 free (used);
9273
9274 if (some_unused)
9275 {
9276 bfd_byte *contents, *src;
9277 unsigned long off;
9278 Elf_Internal_Sym *sym;
9279 bfd_boolean local_toc_syms = FALSE;
9280
9281 /* Shuffle the toc contents, and at the same time convert the
9282 skip array from booleans into offsets. */
9283 if (!bfd_malloc_and_get_section (ibfd, toc, &contents))
9284 goto error_ret;
9285
9286 elf_section_data (toc)->this_hdr.contents = contents;
9287
9288 for (src = contents, off = 0, drop = skip;
9289 src < contents + toc->size;
9290 src += 8, ++drop)
9291 {
9292 if ((*drop & (can_optimize | ref_from_discarded)) != 0)
9293 off += 8;
9294 else if (off != 0)
9295 {
9296 *drop = off;
9297 memcpy (src - off, src, 8);
9298 }
9299 }
9300 *drop = off;
9301 toc->rawsize = toc->size;
9302 toc->size = src - contents - off;
9303
9304 /* Adjust addends for relocs against the toc section sym,
9305 and optimize any accesses we can. */
9306 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
9307 {
9308 if (sec->reloc_count == 0
9309 || discarded_section (sec))
9310 continue;
9311
9312 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
9313 info->keep_memory);
9314 if (relstart == NULL)
9315 goto error_ret;
9316
9317 for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9318 {
9319 enum elf_ppc64_reloc_type r_type;
9320 unsigned long r_symndx;
9321 asection *sym_sec;
9322 struct elf_link_hash_entry *h;
9323 bfd_vma val;
9324
9325 r_type = ELF64_R_TYPE (rel->r_info);
9326 switch (r_type)
9327 {
9328 default:
9329 continue;
9330
9331 case R_PPC64_TOC16:
9332 case R_PPC64_TOC16_LO:
9333 case R_PPC64_TOC16_HI:
9334 case R_PPC64_TOC16_HA:
9335 case R_PPC64_TOC16_DS:
9336 case R_PPC64_TOC16_LO_DS:
9337 case R_PPC64_ADDR64:
9338 break;
9339 }
9340
9341 r_symndx = ELF64_R_SYM (rel->r_info);
9342 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9343 r_symndx, ibfd))
9344 goto error_ret;
9345
9346 if (sym_sec != toc)
9347 continue;
9348
9349 if (h != NULL)
9350 val = h->root.u.def.value;
9351 else
9352 {
9353 val = sym->st_value;
9354 if (val != 0)
9355 local_toc_syms = TRUE;
9356 }
9357
9358 val += rel->r_addend;
9359
9360 if (val > toc->rawsize)
9361 val = toc->rawsize;
9362 else if ((skip[val >> 3] & ref_from_discarded) != 0)
9363 continue;
9364 else if ((skip[val >> 3] & can_optimize) != 0)
9365 {
9366 Elf_Internal_Rela *tocrel
9367 = toc_relocs + (skip[val >> 3] >> 2);
9368 unsigned long tsym = ELF64_R_SYM (tocrel->r_info);
9369
9370 switch (r_type)
9371 {
9372 case R_PPC64_TOC16_HA:
9373 rel->r_info = ELF64_R_INFO (tsym, R_PPC64_TOC16_HA);
9374 break;
9375
9376 case R_PPC64_TOC16_LO_DS:
9377 rel->r_info = ELF64_R_INFO (tsym, R_PPC64_LO_DS_OPT);
9378 break;
9379
9380 default:
9381 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
9382 ppc_howto_init ();
9383 info->callbacks->einfo
9384 (_("%P: %H: %s references "
9385 "optimized away TOC entry\n"),
9386 ibfd, sec, rel->r_offset,
9387 ppc64_elf_howto_table[r_type]->name);
9388 bfd_set_error (bfd_error_bad_value);
9389 goto error_ret;
9390 }
9391 rel->r_addend = tocrel->r_addend;
9392 elf_section_data (sec)->relocs = relstart;
9393 continue;
9394 }
9395
9396 if (h != NULL || sym->st_value != 0)
9397 continue;
9398
9399 rel->r_addend -= skip[val >> 3];
9400 elf_section_data (sec)->relocs = relstart;
9401 }
9402
9403 if (elf_section_data (sec)->relocs != relstart)
9404 free (relstart);
9405 }
9406
9407 /* We shouldn't have local or global symbols defined in the TOC,
9408 but handle them anyway. */
9409 if (local_syms != NULL)
9410 for (sym = local_syms;
9411 sym < local_syms + symtab_hdr->sh_info;
9412 ++sym)
9413 if (sym->st_value != 0
9414 && bfd_section_from_elf_index (ibfd, sym->st_shndx) == toc)
9415 {
9416 unsigned long i;
9417
9418 if (sym->st_value > toc->rawsize)
9419 i = toc->rawsize >> 3;
9420 else
9421 i = sym->st_value >> 3;
9422
9423 if ((skip[i] & (ref_from_discarded | can_optimize)) != 0)
9424 {
9425 if (local_toc_syms)
9426 (*_bfd_error_handler)
9427 (_("%s defined on removed toc entry"),
9428 bfd_elf_sym_name (ibfd, symtab_hdr, sym, NULL));
9429 do
9430 ++i;
9431 while ((skip[i] & (ref_from_discarded | can_optimize)));
9432 sym->st_value = (bfd_vma) i << 3;
9433 }
9434
9435 sym->st_value -= skip[i];
9436 symtab_hdr->contents = (unsigned char *) local_syms;
9437 }
9438
9439 /* Adjust any global syms defined in this toc input section. */
9440 if (toc_inf.global_toc_syms)
9441 {
9442 toc_inf.toc = toc;
9443 toc_inf.skip = skip;
9444 toc_inf.global_toc_syms = FALSE;
9445 elf_link_hash_traverse (elf_hash_table (info), adjust_toc_syms,
9446 &toc_inf);
9447 }
9448
9449 if (toc->reloc_count != 0)
9450 {
9451 Elf_Internal_Shdr *rel_hdr;
9452 Elf_Internal_Rela *wrel;
9453 bfd_size_type sz;
9454
9455 /* Remove unused toc relocs, and adjust those we keep. */
9456 if (toc_relocs == NULL)
9457 toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
9458 info->keep_memory);
9459 if (toc_relocs == NULL)
9460 goto error_ret;
9461
9462 wrel = toc_relocs;
9463 for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
9464 if ((skip[rel->r_offset >> 3]
9465 & (ref_from_discarded | can_optimize)) == 0)
9466 {
9467 wrel->r_offset = rel->r_offset - skip[rel->r_offset >> 3];
9468 wrel->r_info = rel->r_info;
9469 wrel->r_addend = rel->r_addend;
9470 ++wrel;
9471 }
9472 else if (!dec_dynrel_count (rel->r_info, toc, info,
9473 &local_syms, NULL, NULL))
9474 goto error_ret;
9475
9476 elf_section_data (toc)->relocs = toc_relocs;
9477 toc->reloc_count = wrel - toc_relocs;
9478 rel_hdr = _bfd_elf_single_rel_hdr (toc);
9479 sz = rel_hdr->sh_entsize;
9480 rel_hdr->sh_size = toc->reloc_count * sz;
9481 }
9482 }
9483 else if (toc_relocs != NULL
9484 && elf_section_data (toc)->relocs != toc_relocs)
9485 free (toc_relocs);
9486
9487 if (local_syms != NULL
9488 && symtab_hdr->contents != (unsigned char *) local_syms)
9489 {
9490 if (!info->keep_memory)
9491 free (local_syms);
9492 else
9493 symtab_hdr->contents = (unsigned char *) local_syms;
9494 }
9495 free (skip);
9496 }
9497
9498 return TRUE;
9499 }
9500
9501 /* Return true iff input section I references the TOC using
9502 instructions limited to +/-32k offsets. */
9503
9504 bfd_boolean
ppc64_elf_has_small_toc_reloc(asection * i)9505 ppc64_elf_has_small_toc_reloc (asection *i)
9506 {
9507 return (is_ppc64_elf (i->owner)
9508 && ppc64_elf_tdata (i->owner)->has_small_toc_reloc);
9509 }
9510
9511 /* Allocate space for one GOT entry. */
9512
9513 static void
allocate_got(struct elf_link_hash_entry * h,struct bfd_link_info * info,struct got_entry * gent)9514 allocate_got (struct elf_link_hash_entry *h,
9515 struct bfd_link_info *info,
9516 struct got_entry *gent)
9517 {
9518 struct ppc_link_hash_table *htab = ppc_hash_table (info);
9519 bfd_boolean dyn;
9520 struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
9521 int entsize = (gent->tls_type & eh->tls_mask & (TLS_GD | TLS_LD)
9522 ? 16 : 8);
9523 int rentsize = (gent->tls_type & eh->tls_mask & TLS_GD
9524 ? 2 : 1) * sizeof (Elf64_External_Rela);
9525 asection *got = ppc64_elf_tdata (gent->owner)->got;
9526
9527 gent->got.offset = got->size;
9528 got->size += entsize;
9529
9530 dyn = htab->elf.dynamic_sections_created;
9531 if (h->type == STT_GNU_IFUNC)
9532 {
9533 htab->elf.irelplt->size += rentsize;
9534 htab->got_reli_size += rentsize;
9535 }
9536 else if ((bfd_link_pic (info)
9537 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h))
9538 && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
9539 || h->root.type != bfd_link_hash_undefweak))
9540 {
9541 asection *relgot = ppc64_elf_tdata (gent->owner)->relgot;
9542 relgot->size += rentsize;
9543 }
9544 }
9545
9546 /* This function merges got entries in the same toc group. */
9547
9548 static void
merge_got_entries(struct got_entry ** pent)9549 merge_got_entries (struct got_entry **pent)
9550 {
9551 struct got_entry *ent, *ent2;
9552
9553 for (ent = *pent; ent != NULL; ent = ent->next)
9554 if (!ent->is_indirect)
9555 for (ent2 = ent->next; ent2 != NULL; ent2 = ent2->next)
9556 if (!ent2->is_indirect
9557 && ent2->addend == ent->addend
9558 && ent2->tls_type == ent->tls_type
9559 && elf_gp (ent2->owner) == elf_gp (ent->owner))
9560 {
9561 ent2->is_indirect = TRUE;
9562 ent2->got.ent = ent;
9563 }
9564 }
9565
9566 /* Allocate space in .plt, .got and associated reloc sections for
9567 dynamic relocs. */
9568
9569 static bfd_boolean
allocate_dynrelocs(struct elf_link_hash_entry * h,void * inf)9570 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
9571 {
9572 struct bfd_link_info *info;
9573 struct ppc_link_hash_table *htab;
9574 asection *s;
9575 struct ppc_link_hash_entry *eh;
9576 struct got_entry **pgent, *gent;
9577
9578 if (h->root.type == bfd_link_hash_indirect)
9579 return TRUE;
9580
9581 info = (struct bfd_link_info *) inf;
9582 htab = ppc_hash_table (info);
9583 if (htab == NULL)
9584 return FALSE;
9585
9586 eh = (struct ppc_link_hash_entry *) h;
9587 /* Run through the TLS GD got entries first if we're changing them
9588 to TPREL. */
9589 if ((eh->tls_mask & TLS_TPRELGD) != 0)
9590 for (gent = h->got.glist; gent != NULL; gent = gent->next)
9591 if (gent->got.refcount > 0
9592 && (gent->tls_type & TLS_GD) != 0)
9593 {
9594 /* This was a GD entry that has been converted to TPREL. If
9595 there happens to be a TPREL entry we can use that one. */
9596 struct got_entry *ent;
9597 for (ent = h->got.glist; ent != NULL; ent = ent->next)
9598 if (ent->got.refcount > 0
9599 && (ent->tls_type & TLS_TPREL) != 0
9600 && ent->addend == gent->addend
9601 && ent->owner == gent->owner)
9602 {
9603 gent->got.refcount = 0;
9604 break;
9605 }
9606
9607 /* If not, then we'll be using our own TPREL entry. */
9608 if (gent->got.refcount != 0)
9609 gent->tls_type = TLS_TLS | TLS_TPREL;
9610 }
9611
9612 /* Remove any list entry that won't generate a word in the GOT before
9613 we call merge_got_entries. Otherwise we risk merging to empty
9614 entries. */
9615 pgent = &h->got.glist;
9616 while ((gent = *pgent) != NULL)
9617 if (gent->got.refcount > 0)
9618 {
9619 if ((gent->tls_type & TLS_LD) != 0
9620 && !h->def_dynamic)
9621 {
9622 ppc64_tlsld_got (gent->owner)->got.refcount += 1;
9623 *pgent = gent->next;
9624 }
9625 else
9626 pgent = &gent->next;
9627 }
9628 else
9629 *pgent = gent->next;
9630
9631 if (!htab->do_multi_toc)
9632 merge_got_entries (&h->got.glist);
9633
9634 for (gent = h->got.glist; gent != NULL; gent = gent->next)
9635 if (!gent->is_indirect)
9636 {
9637 /* Make sure this symbol is output as a dynamic symbol.
9638 Undefined weak syms won't yet be marked as dynamic,
9639 nor will all TLS symbols. */
9640 if (h->dynindx == -1
9641 && !h->forced_local
9642 && h->type != STT_GNU_IFUNC
9643 && htab->elf.dynamic_sections_created)
9644 {
9645 if (! bfd_elf_link_record_dynamic_symbol (info, h))
9646 return FALSE;
9647 }
9648
9649 if (!is_ppc64_elf (gent->owner))
9650 abort ();
9651
9652 allocate_got (h, info, gent);
9653 }
9654
9655 if (!htab->elf.dynamic_sections_created
9656 && h->type != STT_GNU_IFUNC)
9657 eh->dyn_relocs = NULL;
9658
9659 if (eh->dyn_relocs != NULL)
9660 {
9661 struct elf_dyn_relocs *p, **pp;
9662
9663 /* In the shared -Bsymbolic case, discard space allocated for
9664 dynamic pc-relative relocs against symbols which turn out to
9665 be defined in regular objects. For the normal shared case,
9666 discard space for relocs that have become local due to symbol
9667 visibility changes. */
9668
9669 if (bfd_link_pic (info))
9670 {
9671 /* Relocs that use pc_count are those that appear on a call
9672 insn, or certain REL relocs (see must_be_dyn_reloc) that
9673 can be generated via assembly. We want calls to
9674 protected symbols to resolve directly to the function
9675 rather than going via the plt. If people want function
9676 pointer comparisons to work as expected then they should
9677 avoid writing weird assembly. */
9678 if (SYMBOL_CALLS_LOCAL (info, h))
9679 {
9680 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
9681 {
9682 p->count -= p->pc_count;
9683 p->pc_count = 0;
9684 if (p->count == 0)
9685 *pp = p->next;
9686 else
9687 pp = &p->next;
9688 }
9689 }
9690
9691 /* Also discard relocs on undefined weak syms with
9692 non-default visibility. */
9693 if (eh->dyn_relocs != NULL
9694 && h->root.type == bfd_link_hash_undefweak)
9695 {
9696 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
9697 eh->dyn_relocs = NULL;
9698
9699 /* Make sure this symbol is output as a dynamic symbol.
9700 Undefined weak syms won't yet be marked as dynamic. */
9701 else if (h->dynindx == -1
9702 && !h->forced_local)
9703 {
9704 if (! bfd_elf_link_record_dynamic_symbol (info, h))
9705 return FALSE;
9706 }
9707 }
9708 }
9709 else if (h->type == STT_GNU_IFUNC)
9710 {
9711 /* A plt entry is always created when making direct calls to
9712 an ifunc, even when building a static executable, but
9713 that doesn't cover all cases. We may have only an ifunc
9714 initialised function pointer for a given ifunc symbol.
9715
9716 For ELFv2, dynamic relocations are not required when
9717 generating a global entry PLT stub. */
9718 if (abiversion (info->output_bfd) >= 2)
9719 {
9720 if (global_entry_stub (h))
9721 eh->dyn_relocs = NULL;
9722 }
9723
9724 /* For ELFv1 we have function descriptors. Descriptors need
9725 to be treated like PLT entries and thus have dynamic
9726 relocations. One exception is when the function
9727 descriptor is copied into .dynbss (which should only
9728 happen with ancient versions of gcc). */
9729 else if (h->needs_copy)
9730 eh->dyn_relocs = NULL;
9731 }
9732 else if (ELIMINATE_COPY_RELOCS)
9733 {
9734 /* For the non-pic case, discard space for relocs against
9735 symbols which turn out to need copy relocs or are not
9736 dynamic. */
9737
9738 /* First make sure this symbol is output as a dynamic symbol.
9739 Undefined weak syms won't yet be marked as dynamic. */
9740 if (h->root.type == bfd_link_hash_undefweak
9741 && !h->non_got_ref
9742 && !h->def_regular
9743 && h->dynindx == -1
9744 && !h->forced_local
9745 && !bfd_elf_link_record_dynamic_symbol (info, h))
9746 return FALSE;
9747
9748 if (h->non_got_ref
9749 || h->def_regular
9750 || h->dynindx == -1)
9751 eh->dyn_relocs = NULL;
9752 }
9753
9754 /* Finally, allocate space. */
9755 for (p = eh->dyn_relocs; p != NULL; p = p->next)
9756 {
9757 asection *sreloc = elf_section_data (p->sec)->sreloc;
9758 if (eh->elf.type == STT_GNU_IFUNC)
9759 sreloc = htab->elf.irelplt;
9760 sreloc->size += p->count * sizeof (Elf64_External_Rela);
9761 }
9762 }
9763
9764 if ((htab->elf.dynamic_sections_created
9765 && h->dynindx != -1
9766 && WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, bfd_link_pic (info), h))
9767 || h->type == STT_GNU_IFUNC)
9768 {
9769 struct plt_entry *pent;
9770 bfd_boolean doneone = FALSE;
9771 for (pent = h->plt.plist; pent != NULL; pent = pent->next)
9772 if (pent->plt.refcount > 0)
9773 {
9774 if (!htab->elf.dynamic_sections_created
9775 || h->dynindx == -1)
9776 {
9777 s = htab->elf.iplt;
9778 pent->plt.offset = s->size;
9779 s->size += PLT_ENTRY_SIZE (htab);
9780 s = htab->elf.irelplt;
9781 }
9782 else
9783 {
9784 /* If this is the first .plt entry, make room for the special
9785 first entry. */
9786 s = htab->elf.splt;
9787 if (s->size == 0)
9788 s->size += PLT_INITIAL_ENTRY_SIZE (htab);
9789
9790 pent->plt.offset = s->size;
9791
9792 /* Make room for this entry. */
9793 s->size += PLT_ENTRY_SIZE (htab);
9794
9795 /* Make room for the .glink code. */
9796 s = htab->glink;
9797 if (s->size == 0)
9798 s->size += GLINK_CALL_STUB_SIZE;
9799 if (htab->opd_abi)
9800 {
9801 /* We need bigger stubs past index 32767. */
9802 if (s->size >= GLINK_CALL_STUB_SIZE + 32768*2*4)
9803 s->size += 4;
9804 s->size += 2*4;
9805 }
9806 else
9807 s->size += 4;
9808
9809 /* We also need to make an entry in the .rela.plt section. */
9810 s = htab->elf.srelplt;
9811 }
9812 s->size += sizeof (Elf64_External_Rela);
9813 doneone = TRUE;
9814 }
9815 else
9816 pent->plt.offset = (bfd_vma) -1;
9817 if (!doneone)
9818 {
9819 h->plt.plist = NULL;
9820 h->needs_plt = 0;
9821 }
9822 }
9823 else
9824 {
9825 h->plt.plist = NULL;
9826 h->needs_plt = 0;
9827 }
9828
9829 return TRUE;
9830 }
9831
9832 /* Called via elf_link_hash_traverse from ppc64_elf_size_dynamic_sections
9833 to set up space for global entry stubs. These are put in glink,
9834 after the branch table. */
9835
9836 static bfd_boolean
size_global_entry_stubs(struct elf_link_hash_entry * h,void * inf)9837 size_global_entry_stubs (struct elf_link_hash_entry *h, void *inf)
9838 {
9839 struct bfd_link_info *info;
9840 struct ppc_link_hash_table *htab;
9841 struct plt_entry *pent;
9842 asection *s;
9843
9844 if (h->root.type == bfd_link_hash_indirect)
9845 return TRUE;
9846
9847 if (!h->pointer_equality_needed)
9848 return TRUE;
9849
9850 if (h->def_regular)
9851 return TRUE;
9852
9853 info = inf;
9854 htab = ppc_hash_table (info);
9855 if (htab == NULL)
9856 return FALSE;
9857
9858 s = htab->glink;
9859 for (pent = h->plt.plist; pent != NULL; pent = pent->next)
9860 if (pent->plt.offset != (bfd_vma) -1
9861 && pent->addend == 0)
9862 {
9863 /* For ELFv2, if this symbol is not defined in a regular file
9864 and we are not generating a shared library or pie, then we
9865 need to define the symbol in the executable on a call stub.
9866 This is to avoid text relocations. */
9867 s->size = (s->size + 15) & -16;
9868 h->root.type = bfd_link_hash_defined;
9869 h->root.u.def.section = s;
9870 h->root.u.def.value = s->size;
9871 s->size += 16;
9872 break;
9873 }
9874 return TRUE;
9875 }
9876
9877 /* Set DF_TEXTREL if we find any dynamic relocs that apply to
9878 read-only sections. */
9879
9880 static bfd_boolean
maybe_set_textrel(struct elf_link_hash_entry * h,void * info)9881 maybe_set_textrel (struct elf_link_hash_entry *h, void *info)
9882 {
9883 if (h->root.type == bfd_link_hash_indirect)
9884 return TRUE;
9885
9886 if (readonly_dynrelocs (h))
9887 {
9888 ((struct bfd_link_info *) info)->flags |= DF_TEXTREL;
9889
9890 /* Not an error, just cut short the traversal. */
9891 return FALSE;
9892 }
9893 return TRUE;
9894 }
9895
9896 /* Set the sizes of the dynamic sections. */
9897
9898 static bfd_boolean
ppc64_elf_size_dynamic_sections(bfd * output_bfd,struct bfd_link_info * info)9899 ppc64_elf_size_dynamic_sections (bfd *output_bfd,
9900 struct bfd_link_info *info)
9901 {
9902 struct ppc_link_hash_table *htab;
9903 bfd *dynobj;
9904 asection *s;
9905 bfd_boolean relocs;
9906 bfd *ibfd;
9907 struct got_entry *first_tlsld;
9908
9909 htab = ppc_hash_table (info);
9910 if (htab == NULL)
9911 return FALSE;
9912
9913 dynobj = htab->elf.dynobj;
9914 if (dynobj == NULL)
9915 abort ();
9916
9917 if (htab->elf.dynamic_sections_created)
9918 {
9919 /* Set the contents of the .interp section to the interpreter. */
9920 if (bfd_link_executable (info) && !info->nointerp)
9921 {
9922 s = bfd_get_linker_section (dynobj, ".interp");
9923 if (s == NULL)
9924 abort ();
9925 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
9926 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
9927 }
9928 }
9929
9930 /* Set up .got offsets for local syms, and space for local dynamic
9931 relocs. */
9932 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
9933 {
9934 struct got_entry **lgot_ents;
9935 struct got_entry **end_lgot_ents;
9936 struct plt_entry **local_plt;
9937 struct plt_entry **end_local_plt;
9938 unsigned char *lgot_masks;
9939 bfd_size_type locsymcount;
9940 Elf_Internal_Shdr *symtab_hdr;
9941
9942 if (!is_ppc64_elf (ibfd))
9943 continue;
9944
9945 for (s = ibfd->sections; s != NULL; s = s->next)
9946 {
9947 struct ppc_dyn_relocs *p;
9948
9949 for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
9950 {
9951 if (!bfd_is_abs_section (p->sec)
9952 && bfd_is_abs_section (p->sec->output_section))
9953 {
9954 /* Input section has been discarded, either because
9955 it is a copy of a linkonce section or due to
9956 linker script /DISCARD/, so we'll be discarding
9957 the relocs too. */
9958 }
9959 else if (p->count != 0)
9960 {
9961 asection *srel = elf_section_data (p->sec)->sreloc;
9962 if (p->ifunc)
9963 srel = htab->elf.irelplt;
9964 srel->size += p->count * sizeof (Elf64_External_Rela);
9965 if ((p->sec->output_section->flags & SEC_READONLY) != 0)
9966 info->flags |= DF_TEXTREL;
9967 }
9968 }
9969 }
9970
9971 lgot_ents = elf_local_got_ents (ibfd);
9972 if (!lgot_ents)
9973 continue;
9974
9975 symtab_hdr = &elf_symtab_hdr (ibfd);
9976 locsymcount = symtab_hdr->sh_info;
9977 end_lgot_ents = lgot_ents + locsymcount;
9978 local_plt = (struct plt_entry **) end_lgot_ents;
9979 end_local_plt = local_plt + locsymcount;
9980 lgot_masks = (unsigned char *) end_local_plt;
9981 s = ppc64_elf_tdata (ibfd)->got;
9982 for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
9983 {
9984 struct got_entry **pent, *ent;
9985
9986 pent = lgot_ents;
9987 while ((ent = *pent) != NULL)
9988 if (ent->got.refcount > 0)
9989 {
9990 if ((ent->tls_type & *lgot_masks & TLS_LD) != 0)
9991 {
9992 ppc64_tlsld_got (ibfd)->got.refcount += 1;
9993 *pent = ent->next;
9994 }
9995 else
9996 {
9997 unsigned int ent_size = 8;
9998 unsigned int rel_size = sizeof (Elf64_External_Rela);
9999
10000 ent->got.offset = s->size;
10001 if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
10002 {
10003 ent_size *= 2;
10004 rel_size *= 2;
10005 }
10006 s->size += ent_size;
10007 if ((*lgot_masks & PLT_IFUNC) != 0)
10008 {
10009 htab->elf.irelplt->size += rel_size;
10010 htab->got_reli_size += rel_size;
10011 }
10012 else if (bfd_link_pic (info))
10013 {
10014 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
10015 srel->size += rel_size;
10016 }
10017 pent = &ent->next;
10018 }
10019 }
10020 else
10021 *pent = ent->next;
10022 }
10023
10024 /* Allocate space for calls to local STT_GNU_IFUNC syms in .iplt. */
10025 for (; local_plt < end_local_plt; ++local_plt)
10026 {
10027 struct plt_entry *ent;
10028
10029 for (ent = *local_plt; ent != NULL; ent = ent->next)
10030 if (ent->plt.refcount > 0)
10031 {
10032 s = htab->elf.iplt;
10033 ent->plt.offset = s->size;
10034 s->size += PLT_ENTRY_SIZE (htab);
10035
10036 htab->elf.irelplt->size += sizeof (Elf64_External_Rela);
10037 }
10038 else
10039 ent->plt.offset = (bfd_vma) -1;
10040 }
10041 }
10042
10043 /* Allocate global sym .plt and .got entries, and space for global
10044 sym dynamic relocs. */
10045 elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, info);
10046 /* Stash the end of glink branch table. */
10047 if (htab->glink != NULL)
10048 htab->glink->rawsize = htab->glink->size;
10049
10050 if (!htab->opd_abi && !bfd_link_pic (info))
10051 elf_link_hash_traverse (&htab->elf, size_global_entry_stubs, info);
10052
10053 first_tlsld = NULL;
10054 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
10055 {
10056 struct got_entry *ent;
10057
10058 if (!is_ppc64_elf (ibfd))
10059 continue;
10060
10061 ent = ppc64_tlsld_got (ibfd);
10062 if (ent->got.refcount > 0)
10063 {
10064 if (!htab->do_multi_toc && first_tlsld != NULL)
10065 {
10066 ent->is_indirect = TRUE;
10067 ent->got.ent = first_tlsld;
10068 }
10069 else
10070 {
10071 if (first_tlsld == NULL)
10072 first_tlsld = ent;
10073 s = ppc64_elf_tdata (ibfd)->got;
10074 ent->got.offset = s->size;
10075 ent->owner = ibfd;
10076 s->size += 16;
10077 if (bfd_link_pic (info))
10078 {
10079 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
10080 srel->size += sizeof (Elf64_External_Rela);
10081 }
10082 }
10083 }
10084 else
10085 ent->got.offset = (bfd_vma) -1;
10086 }
10087
10088 /* We now have determined the sizes of the various dynamic sections.
10089 Allocate memory for them. */
10090 relocs = FALSE;
10091 for (s = dynobj->sections; s != NULL; s = s->next)
10092 {
10093 if ((s->flags & SEC_LINKER_CREATED) == 0)
10094 continue;
10095
10096 if (s == htab->brlt || s == htab->relbrlt)
10097 /* These haven't been allocated yet; don't strip. */
10098 continue;
10099 else if (s == htab->elf.sgot
10100 || s == htab->elf.splt
10101 || s == htab->elf.iplt
10102 || s == htab->glink
10103 || s == htab->dynbss)
10104 {
10105 /* Strip this section if we don't need it; see the
10106 comment below. */
10107 }
10108 else if (s == htab->glink_eh_frame)
10109 {
10110 if (!bfd_is_abs_section (s->output_section))
10111 /* Not sized yet. */
10112 continue;
10113 }
10114 else if (CONST_STRNEQ (s->name, ".rela"))
10115 {
10116 if (s->size != 0)
10117 {
10118 if (s != htab->elf.srelplt)
10119 relocs = TRUE;
10120
10121 /* We use the reloc_count field as a counter if we need
10122 to copy relocs into the output file. */
10123 s->reloc_count = 0;
10124 }
10125 }
10126 else
10127 {
10128 /* It's not one of our sections, so don't allocate space. */
10129 continue;
10130 }
10131
10132 if (s->size == 0)
10133 {
10134 /* If we don't need this section, strip it from the
10135 output file. This is mostly to handle .rela.bss and
10136 .rela.plt. We must create both sections in
10137 create_dynamic_sections, because they must be created
10138 before the linker maps input sections to output
10139 sections. The linker does that before
10140 adjust_dynamic_symbol is called, and it is that
10141 function which decides whether anything needs to go
10142 into these sections. */
10143 s->flags |= SEC_EXCLUDE;
10144 continue;
10145 }
10146
10147 if ((s->flags & SEC_HAS_CONTENTS) == 0)
10148 continue;
10149
10150 /* Allocate memory for the section contents. We use bfd_zalloc
10151 here in case unused entries are not reclaimed before the
10152 section's contents are written out. This should not happen,
10153 but this way if it does we get a R_PPC64_NONE reloc in .rela
10154 sections instead of garbage.
10155 We also rely on the section contents being zero when writing
10156 the GOT. */
10157 s->contents = bfd_zalloc (dynobj, s->size);
10158 if (s->contents == NULL)
10159 return FALSE;
10160 }
10161
10162 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
10163 {
10164 if (!is_ppc64_elf (ibfd))
10165 continue;
10166
10167 s = ppc64_elf_tdata (ibfd)->got;
10168 if (s != NULL && s != htab->elf.sgot)
10169 {
10170 if (s->size == 0)
10171 s->flags |= SEC_EXCLUDE;
10172 else
10173 {
10174 s->contents = bfd_zalloc (ibfd, s->size);
10175 if (s->contents == NULL)
10176 return FALSE;
10177 }
10178 }
10179 s = ppc64_elf_tdata (ibfd)->relgot;
10180 if (s != NULL)
10181 {
10182 if (s->size == 0)
10183 s->flags |= SEC_EXCLUDE;
10184 else
10185 {
10186 s->contents = bfd_zalloc (ibfd, s->size);
10187 if (s->contents == NULL)
10188 return FALSE;
10189 relocs = TRUE;
10190 s->reloc_count = 0;
10191 }
10192 }
10193 }
10194
10195 if (htab->elf.dynamic_sections_created)
10196 {
10197 bfd_boolean tls_opt;
10198
10199 /* Add some entries to the .dynamic section. We fill in the
10200 values later, in ppc64_elf_finish_dynamic_sections, but we
10201 must add the entries now so that we get the correct size for
10202 the .dynamic section. The DT_DEBUG entry is filled in by the
10203 dynamic linker and used by the debugger. */
10204 #define add_dynamic_entry(TAG, VAL) \
10205 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
10206
10207 if (bfd_link_executable (info))
10208 {
10209 if (!add_dynamic_entry (DT_DEBUG, 0))
10210 return FALSE;
10211 }
10212
10213 if (htab->elf.splt != NULL && htab->elf.splt->size != 0)
10214 {
10215 if (!add_dynamic_entry (DT_PLTGOT, 0)
10216 || !add_dynamic_entry (DT_PLTRELSZ, 0)
10217 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
10218 || !add_dynamic_entry (DT_JMPREL, 0)
10219 || !add_dynamic_entry (DT_PPC64_GLINK, 0))
10220 return FALSE;
10221 }
10222
10223 if (NO_OPD_RELOCS && abiversion (output_bfd) <= 1)
10224 {
10225 if (!add_dynamic_entry (DT_PPC64_OPD, 0)
10226 || !add_dynamic_entry (DT_PPC64_OPDSZ, 0))
10227 return FALSE;
10228 }
10229
10230 tls_opt = (htab->params->tls_get_addr_opt
10231 && htab->tls_get_addr_fd != NULL
10232 && htab->tls_get_addr_fd->elf.plt.plist != NULL);
10233 if (tls_opt || !htab->opd_abi)
10234 {
10235 if (!add_dynamic_entry (DT_PPC64_OPT, tls_opt ? PPC64_OPT_TLS : 0))
10236 return FALSE;
10237 }
10238
10239 if (relocs)
10240 {
10241 if (!add_dynamic_entry (DT_RELA, 0)
10242 || !add_dynamic_entry (DT_RELASZ, 0)
10243 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
10244 return FALSE;
10245
10246 /* If any dynamic relocs apply to a read-only section,
10247 then we need a DT_TEXTREL entry. */
10248 if ((info->flags & DF_TEXTREL) == 0)
10249 elf_link_hash_traverse (&htab->elf, maybe_set_textrel, info);
10250
10251 if ((info->flags & DF_TEXTREL) != 0)
10252 {
10253 if (!add_dynamic_entry (DT_TEXTREL, 0))
10254 return FALSE;
10255 }
10256 }
10257 }
10258 #undef add_dynamic_entry
10259
10260 return TRUE;
10261 }
10262
10263 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
10264
10265 static bfd_boolean
ppc64_elf_hash_symbol(struct elf_link_hash_entry * h)10266 ppc64_elf_hash_symbol (struct elf_link_hash_entry *h)
10267 {
10268 if (h->plt.plist != NULL
10269 && !h->def_regular
10270 && !h->pointer_equality_needed)
10271 return FALSE;
10272
10273 return _bfd_elf_hash_symbol (h);
10274 }
10275
10276 /* Determine the type of stub needed, if any, for a call. */
10277
10278 static inline enum ppc_stub_type
ppc_type_of_stub(asection * input_sec,const Elf_Internal_Rela * rel,struct ppc_link_hash_entry ** hash,struct plt_entry ** plt_ent,bfd_vma destination,unsigned long local_off)10279 ppc_type_of_stub (asection *input_sec,
10280 const Elf_Internal_Rela *rel,
10281 struct ppc_link_hash_entry **hash,
10282 struct plt_entry **plt_ent,
10283 bfd_vma destination,
10284 unsigned long local_off)
10285 {
10286 struct ppc_link_hash_entry *h = *hash;
10287 bfd_vma location;
10288 bfd_vma branch_offset;
10289 bfd_vma max_branch_offset;
10290 enum elf_ppc64_reloc_type r_type;
10291
10292 if (h != NULL)
10293 {
10294 struct plt_entry *ent;
10295 struct ppc_link_hash_entry *fdh = h;
10296 if (h->oh != NULL
10297 && h->oh->is_func_descriptor)
10298 {
10299 fdh = ppc_follow_link (h->oh);
10300 *hash = fdh;
10301 }
10302
10303 for (ent = fdh->elf.plt.plist; ent != NULL; ent = ent->next)
10304 if (ent->addend == rel->r_addend
10305 && ent->plt.offset != (bfd_vma) -1)
10306 {
10307 *plt_ent = ent;
10308 return ppc_stub_plt_call;
10309 }
10310
10311 /* Here, we know we don't have a plt entry. If we don't have a
10312 either a defined function descriptor or a defined entry symbol
10313 in a regular object file, then it is pointless trying to make
10314 any other type of stub. */
10315 if (!is_static_defined (&fdh->elf)
10316 && !is_static_defined (&h->elf))
10317 return ppc_stub_none;
10318 }
10319 else if (elf_local_got_ents (input_sec->owner) != NULL)
10320 {
10321 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (input_sec->owner);
10322 struct plt_entry **local_plt = (struct plt_entry **)
10323 elf_local_got_ents (input_sec->owner) + symtab_hdr->sh_info;
10324 unsigned long r_symndx = ELF64_R_SYM (rel->r_info);
10325
10326 if (local_plt[r_symndx] != NULL)
10327 {
10328 struct plt_entry *ent;
10329
10330 for (ent = local_plt[r_symndx]; ent != NULL; ent = ent->next)
10331 if (ent->addend == rel->r_addend
10332 && ent->plt.offset != (bfd_vma) -1)
10333 {
10334 *plt_ent = ent;
10335 return ppc_stub_plt_call;
10336 }
10337 }
10338 }
10339
10340 /* Determine where the call point is. */
10341 location = (input_sec->output_offset
10342 + input_sec->output_section->vma
10343 + rel->r_offset);
10344
10345 branch_offset = destination - location;
10346 r_type = ELF64_R_TYPE (rel->r_info);
10347
10348 /* Determine if a long branch stub is needed. */
10349 max_branch_offset = 1 << 25;
10350 if (r_type != R_PPC64_REL24)
10351 max_branch_offset = 1 << 15;
10352
10353 if (branch_offset + max_branch_offset >= 2 * max_branch_offset - local_off)
10354 /* We need a stub. Figure out whether a long_branch or plt_branch
10355 is needed later. */
10356 return ppc_stub_long_branch;
10357
10358 return ppc_stub_none;
10359 }
10360
10361 /* With power7 weakly ordered memory model, it is possible for ld.so
10362 to update a plt entry in one thread and have another thread see a
10363 stale zero toc entry. To avoid this we need some sort of acquire
10364 barrier in the call stub. One solution is to make the load of the
10365 toc word seem to appear to depend on the load of the function entry
10366 word. Another solution is to test for r2 being zero, and branch to
10367 the appropriate glink entry if so.
10368
10369 . fake dep barrier compare
10370 . ld 12,xxx(2) ld 12,xxx(2)
10371 . mtctr 12 mtctr 12
10372 . xor 11,12,12 ld 2,xxx+8(2)
10373 . add 2,2,11 cmpldi 2,0
10374 . ld 2,xxx+8(2) bnectr+
10375 . bctr b <glink_entry>
10376
10377 The solution involving the compare turns out to be faster, so
10378 that's what we use unless the branch won't reach. */
10379
10380 #define ALWAYS_USE_FAKE_DEP 0
10381 #define ALWAYS_EMIT_R2SAVE 0
10382
10383 #define PPC_LO(v) ((v) & 0xffff)
10384 #define PPC_HI(v) (((v) >> 16) & 0xffff)
10385 #define PPC_HA(v) PPC_HI ((v) + 0x8000)
10386
10387 static inline unsigned int
plt_stub_size(struct ppc_link_hash_table * htab,struct ppc_stub_hash_entry * stub_entry,bfd_vma off)10388 plt_stub_size (struct ppc_link_hash_table *htab,
10389 struct ppc_stub_hash_entry *stub_entry,
10390 bfd_vma off)
10391 {
10392 unsigned size = 12;
10393
10394 if (ALWAYS_EMIT_R2SAVE
10395 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10396 size += 4;
10397 if (PPC_HA (off) != 0)
10398 size += 4;
10399 if (htab->opd_abi)
10400 {
10401 size += 4;
10402 if (htab->params->plt_static_chain)
10403 size += 4;
10404 if (htab->params->plt_thread_safe
10405 && htab->elf.dynamic_sections_created
10406 && stub_entry->h != NULL
10407 && stub_entry->h->elf.dynindx != -1)
10408 size += 8;
10409 if (PPC_HA (off + 8 + 8 * htab->params->plt_static_chain) != PPC_HA (off))
10410 size += 4;
10411 }
10412 if (stub_entry->h != NULL
10413 && (stub_entry->h == htab->tls_get_addr_fd
10414 || stub_entry->h == htab->tls_get_addr)
10415 && htab->params->tls_get_addr_opt)
10416 size += 13 * 4;
10417 return size;
10418 }
10419
10420 /* If this stub would cross fewer 2**plt_stub_align boundaries if we align,
10421 then return the padding needed to do so. */
10422 static inline unsigned int
plt_stub_pad(struct ppc_link_hash_table * htab,struct ppc_stub_hash_entry * stub_entry,bfd_vma plt_off)10423 plt_stub_pad (struct ppc_link_hash_table *htab,
10424 struct ppc_stub_hash_entry *stub_entry,
10425 bfd_vma plt_off)
10426 {
10427 int stub_align = 1 << htab->params->plt_stub_align;
10428 unsigned stub_size = plt_stub_size (htab, stub_entry, plt_off);
10429 bfd_vma stub_off = stub_entry->group->stub_sec->size;
10430
10431 if (((stub_off + stub_size - 1) & -stub_align) - (stub_off & -stub_align)
10432 > ((stub_size - 1) & -stub_align))
10433 return stub_align - (stub_off & (stub_align - 1));
10434 return 0;
10435 }
10436
10437 /* Build a .plt call stub. */
10438
10439 static inline bfd_byte *
build_plt_stub(struct ppc_link_hash_table * htab,struct ppc_stub_hash_entry * stub_entry,bfd_byte * p,bfd_vma offset,Elf_Internal_Rela * r)10440 build_plt_stub (struct ppc_link_hash_table *htab,
10441 struct ppc_stub_hash_entry *stub_entry,
10442 bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
10443 {
10444 bfd *obfd = htab->params->stub_bfd;
10445 bfd_boolean plt_load_toc = htab->opd_abi;
10446 bfd_boolean plt_static_chain = htab->params->plt_static_chain;
10447 bfd_boolean plt_thread_safe = (htab->params->plt_thread_safe
10448 && htab->elf.dynamic_sections_created
10449 && stub_entry->h != NULL
10450 && stub_entry->h->elf.dynindx != -1);
10451 bfd_boolean use_fake_dep = plt_thread_safe;
10452 bfd_vma cmp_branch_off = 0;
10453
10454 if (!ALWAYS_USE_FAKE_DEP
10455 && plt_load_toc
10456 && plt_thread_safe
10457 && !((stub_entry->h == htab->tls_get_addr_fd
10458 || stub_entry->h == htab->tls_get_addr)
10459 && htab->params->tls_get_addr_opt))
10460 {
10461 bfd_vma pltoff = stub_entry->plt_ent->plt.offset & ~1;
10462 bfd_vma pltindex = ((pltoff - PLT_INITIAL_ENTRY_SIZE (htab))
10463 / PLT_ENTRY_SIZE (htab));
10464 bfd_vma glinkoff = GLINK_CALL_STUB_SIZE + pltindex * 8;
10465 bfd_vma to, from;
10466
10467 if (pltindex > 32768)
10468 glinkoff += (pltindex - 32768) * 4;
10469 to = (glinkoff
10470 + htab->glink->output_offset
10471 + htab->glink->output_section->vma);
10472 from = (p - stub_entry->group->stub_sec->contents
10473 + 4 * (ALWAYS_EMIT_R2SAVE
10474 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10475 + 4 * (PPC_HA (offset) != 0)
10476 + 4 * (PPC_HA (offset + 8 + 8 * plt_static_chain)
10477 != PPC_HA (offset))
10478 + 4 * (plt_static_chain != 0)
10479 + 20
10480 + stub_entry->group->stub_sec->output_offset
10481 + stub_entry->group->stub_sec->output_section->vma);
10482 cmp_branch_off = to - from;
10483 use_fake_dep = cmp_branch_off + (1 << 25) >= (1 << 26);
10484 }
10485
10486 if (PPC_HA (offset) != 0)
10487 {
10488 if (r != NULL)
10489 {
10490 if (ALWAYS_EMIT_R2SAVE
10491 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10492 r[0].r_offset += 4;
10493 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
10494 r[1].r_offset = r[0].r_offset + 4;
10495 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10496 r[1].r_addend = r[0].r_addend;
10497 if (plt_load_toc)
10498 {
10499 if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10500 {
10501 r[2].r_offset = r[1].r_offset + 4;
10502 r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO);
10503 r[2].r_addend = r[0].r_addend;
10504 }
10505 else
10506 {
10507 r[2].r_offset = r[1].r_offset + 8 + 8 * use_fake_dep;
10508 r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10509 r[2].r_addend = r[0].r_addend + 8;
10510 if (plt_static_chain)
10511 {
10512 r[3].r_offset = r[2].r_offset + 4;
10513 r[3].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10514 r[3].r_addend = r[0].r_addend + 16;
10515 }
10516 }
10517 }
10518 }
10519 if (ALWAYS_EMIT_R2SAVE
10520 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10521 bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p), p += 4;
10522 if (plt_load_toc)
10523 {
10524 bfd_put_32 (obfd, ADDIS_R11_R2 | PPC_HA (offset), p), p += 4;
10525 bfd_put_32 (obfd, LD_R12_0R11 | PPC_LO (offset), p), p += 4;
10526 }
10527 else
10528 {
10529 bfd_put_32 (obfd, ADDIS_R12_R2 | PPC_HA (offset), p), p += 4;
10530 bfd_put_32 (obfd, LD_R12_0R12 | PPC_LO (offset), p), p += 4;
10531 }
10532 if (plt_load_toc
10533 && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10534 {
10535 bfd_put_32 (obfd, ADDI_R11_R11 | PPC_LO (offset), p), p += 4;
10536 offset = 0;
10537 }
10538 bfd_put_32 (obfd, MTCTR_R12, p), p += 4;
10539 if (plt_load_toc)
10540 {
10541 if (use_fake_dep)
10542 {
10543 bfd_put_32 (obfd, XOR_R2_R12_R12, p), p += 4;
10544 bfd_put_32 (obfd, ADD_R11_R11_R2, p), p += 4;
10545 }
10546 bfd_put_32 (obfd, LD_R2_0R11 | PPC_LO (offset + 8), p), p += 4;
10547 if (plt_static_chain)
10548 bfd_put_32 (obfd, LD_R11_0R11 | PPC_LO (offset + 16), p), p += 4;
10549 }
10550 }
10551 else
10552 {
10553 if (r != NULL)
10554 {
10555 if (ALWAYS_EMIT_R2SAVE
10556 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10557 r[0].r_offset += 4;
10558 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10559 if (plt_load_toc)
10560 {
10561 if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10562 {
10563 r[1].r_offset = r[0].r_offset + 4;
10564 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16);
10565 r[1].r_addend = r[0].r_addend;
10566 }
10567 else
10568 {
10569 r[1].r_offset = r[0].r_offset + 8 + 8 * use_fake_dep;
10570 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10571 r[1].r_addend = r[0].r_addend + 8 + 8 * plt_static_chain;
10572 if (plt_static_chain)
10573 {
10574 r[2].r_offset = r[1].r_offset + 4;
10575 r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10576 r[2].r_addend = r[0].r_addend + 8;
10577 }
10578 }
10579 }
10580 }
10581 if (ALWAYS_EMIT_R2SAVE
10582 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10583 bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p), p += 4;
10584 bfd_put_32 (obfd, LD_R12_0R2 | PPC_LO (offset), p), p += 4;
10585 if (plt_load_toc
10586 && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10587 {
10588 bfd_put_32 (obfd, ADDI_R2_R2 | PPC_LO (offset), p), p += 4;
10589 offset = 0;
10590 }
10591 bfd_put_32 (obfd, MTCTR_R12, p), p += 4;
10592 if (plt_load_toc)
10593 {
10594 if (use_fake_dep)
10595 {
10596 bfd_put_32 (obfd, XOR_R11_R12_R12, p), p += 4;
10597 bfd_put_32 (obfd, ADD_R2_R2_R11, p), p += 4;
10598 }
10599 if (plt_static_chain)
10600 bfd_put_32 (obfd, LD_R11_0R2 | PPC_LO (offset + 16), p), p += 4;
10601 bfd_put_32 (obfd, LD_R2_0R2 | PPC_LO (offset + 8), p), p += 4;
10602 }
10603 }
10604 if (plt_load_toc && plt_thread_safe && !use_fake_dep)
10605 {
10606 bfd_put_32 (obfd, CMPLDI_R2_0, p), p += 4;
10607 bfd_put_32 (obfd, BNECTR_P4, p), p += 4;
10608 bfd_put_32 (obfd, B_DOT | (cmp_branch_off & 0x3fffffc), p), p += 4;
10609 }
10610 else
10611 bfd_put_32 (obfd, BCTR, p), p += 4;
10612 return p;
10613 }
10614
10615 /* Build a special .plt call stub for __tls_get_addr. */
10616
10617 #define LD_R11_0R3 0xe9630000
10618 #define LD_R12_0R3 0xe9830000
10619 #define MR_R0_R3 0x7c601b78
10620 #define CMPDI_R11_0 0x2c2b0000
10621 #define ADD_R3_R12_R13 0x7c6c6a14
10622 #define BEQLR 0x4d820020
10623 #define MR_R3_R0 0x7c030378
10624 #define STD_R11_0R1 0xf9610000
10625 #define BCTRL 0x4e800421
10626 #define LD_R11_0R1 0xe9610000
10627 #define MTLR_R11 0x7d6803a6
10628
10629 static inline bfd_byte *
build_tls_get_addr_stub(struct ppc_link_hash_table * htab,struct ppc_stub_hash_entry * stub_entry,bfd_byte * p,bfd_vma offset,Elf_Internal_Rela * r)10630 build_tls_get_addr_stub (struct ppc_link_hash_table *htab,
10631 struct ppc_stub_hash_entry *stub_entry,
10632 bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
10633 {
10634 bfd *obfd = htab->params->stub_bfd;
10635
10636 bfd_put_32 (obfd, LD_R11_0R3 + 0, p), p += 4;
10637 bfd_put_32 (obfd, LD_R12_0R3 + 8, p), p += 4;
10638 bfd_put_32 (obfd, MR_R0_R3, p), p += 4;
10639 bfd_put_32 (obfd, CMPDI_R11_0, p), p += 4;
10640 bfd_put_32 (obfd, ADD_R3_R12_R13, p), p += 4;
10641 bfd_put_32 (obfd, BEQLR, p), p += 4;
10642 bfd_put_32 (obfd, MR_R3_R0, p), p += 4;
10643 bfd_put_32 (obfd, MFLR_R11, p), p += 4;
10644 bfd_put_32 (obfd, STD_R11_0R1 + STK_LINKER (htab), p), p += 4;
10645
10646 if (r != NULL)
10647 r[0].r_offset += 9 * 4;
10648 p = build_plt_stub (htab, stub_entry, p, offset, r);
10649 bfd_put_32 (obfd, BCTRL, p - 4);
10650
10651 bfd_put_32 (obfd, LD_R2_0R1 + STK_TOC (htab), p), p += 4;
10652 bfd_put_32 (obfd, LD_R11_0R1 + STK_LINKER (htab), p), p += 4;
10653 bfd_put_32 (obfd, MTLR_R11, p), p += 4;
10654 bfd_put_32 (obfd, BLR, p), p += 4;
10655
10656 return p;
10657 }
10658
10659 static Elf_Internal_Rela *
get_relocs(asection * sec,int count)10660 get_relocs (asection *sec, int count)
10661 {
10662 Elf_Internal_Rela *relocs;
10663 struct bfd_elf_section_data *elfsec_data;
10664
10665 elfsec_data = elf_section_data (sec);
10666 relocs = elfsec_data->relocs;
10667 if (relocs == NULL)
10668 {
10669 bfd_size_type relsize;
10670 relsize = sec->reloc_count * sizeof (*relocs);
10671 relocs = bfd_alloc (sec->owner, relsize);
10672 if (relocs == NULL)
10673 return NULL;
10674 elfsec_data->relocs = relocs;
10675 elfsec_data->rela.hdr = bfd_zalloc (sec->owner,
10676 sizeof (Elf_Internal_Shdr));
10677 if (elfsec_data->rela.hdr == NULL)
10678 return NULL;
10679 elfsec_data->rela.hdr->sh_size = (sec->reloc_count
10680 * sizeof (Elf64_External_Rela));
10681 elfsec_data->rela.hdr->sh_entsize = sizeof (Elf64_External_Rela);
10682 sec->reloc_count = 0;
10683 }
10684 relocs += sec->reloc_count;
10685 sec->reloc_count += count;
10686 return relocs;
10687 }
10688
10689 static bfd_vma
get_r2off(struct bfd_link_info * info,struct ppc_stub_hash_entry * stub_entry)10690 get_r2off (struct bfd_link_info *info,
10691 struct ppc_stub_hash_entry *stub_entry)
10692 {
10693 struct ppc_link_hash_table *htab = ppc_hash_table (info);
10694 bfd_vma r2off = htab->sec_info[stub_entry->target_section->id].toc_off;
10695
10696 if (r2off == 0)
10697 {
10698 /* Support linking -R objects. Get the toc pointer from the
10699 opd entry. */
10700 char buf[8];
10701 if (!htab->opd_abi)
10702 return r2off;
10703 asection *opd = stub_entry->h->elf.root.u.def.section;
10704 bfd_vma opd_off = stub_entry->h->elf.root.u.def.value;
10705
10706 if (strcmp (opd->name, ".opd") != 0
10707 || opd->reloc_count != 0)
10708 {
10709 info->callbacks->einfo (_("%P: cannot find opd entry toc for `%T'\n"),
10710 stub_entry->h->elf.root.root.string);
10711 bfd_set_error (bfd_error_bad_value);
10712 return (bfd_vma) -1;
10713 }
10714 if (!bfd_get_section_contents (opd->owner, opd, buf, opd_off + 8, 8))
10715 return (bfd_vma) -1;
10716 r2off = bfd_get_64 (opd->owner, buf);
10717 r2off -= elf_gp (info->output_bfd);
10718 }
10719 r2off -= htab->sec_info[stub_entry->group->link_sec->id].toc_off;
10720 return r2off;
10721 }
10722
10723 static bfd_boolean
ppc_build_one_stub(struct bfd_hash_entry * gen_entry,void * in_arg)10724 ppc_build_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
10725 {
10726 struct ppc_stub_hash_entry *stub_entry;
10727 struct ppc_branch_hash_entry *br_entry;
10728 struct bfd_link_info *info;
10729 struct ppc_link_hash_table *htab;
10730 bfd_byte *loc;
10731 bfd_byte *p;
10732 bfd_vma dest, off;
10733 int size;
10734 Elf_Internal_Rela *r;
10735 asection *plt;
10736
10737 /* Massage our args to the form they really have. */
10738 stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
10739 info = in_arg;
10740
10741 htab = ppc_hash_table (info);
10742 if (htab == NULL)
10743 return FALSE;
10744
10745 /* Make a note of the offset within the stubs for this entry. */
10746 stub_entry->stub_offset = stub_entry->group->stub_sec->size;
10747 loc = stub_entry->group->stub_sec->contents + stub_entry->stub_offset;
10748
10749 htab->stub_count[stub_entry->stub_type - 1] += 1;
10750 switch (stub_entry->stub_type)
10751 {
10752 case ppc_stub_long_branch:
10753 case ppc_stub_long_branch_r2off:
10754 /* Branches are relative. This is where we are going to. */
10755 dest = (stub_entry->target_value
10756 + stub_entry->target_section->output_offset
10757 + stub_entry->target_section->output_section->vma);
10758 dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
10759 off = dest;
10760
10761 /* And this is where we are coming from. */
10762 off -= (stub_entry->stub_offset
10763 + stub_entry->group->stub_sec->output_offset
10764 + stub_entry->group->stub_sec->output_section->vma);
10765
10766 size = 4;
10767 if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
10768 {
10769 bfd_vma r2off = get_r2off (info, stub_entry);
10770
10771 if (r2off == (bfd_vma) -1)
10772 {
10773 htab->stub_error = TRUE;
10774 return FALSE;
10775 }
10776 bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), loc);
10777 loc += 4;
10778 size = 8;
10779 if (PPC_HA (r2off) != 0)
10780 {
10781 bfd_put_32 (htab->params->stub_bfd,
10782 ADDIS_R2_R2 | PPC_HA (r2off), loc);
10783 loc += 4;
10784 size += 4;
10785 }
10786 if (PPC_LO (r2off) != 0)
10787 {
10788 bfd_put_32 (htab->params->stub_bfd,
10789 ADDI_R2_R2 | PPC_LO (r2off), loc);
10790 loc += 4;
10791 size += 4;
10792 }
10793 off -= size - 4;
10794 }
10795 bfd_put_32 (htab->params->stub_bfd, B_DOT | (off & 0x3fffffc), loc);
10796
10797 if (off + (1 << 25) >= (bfd_vma) (1 << 26))
10798 {
10799 info->callbacks->einfo
10800 (_("%P: long branch stub `%s' offset overflow\n"),
10801 stub_entry->root.string);
10802 htab->stub_error = TRUE;
10803 return FALSE;
10804 }
10805
10806 if (info->emitrelocations)
10807 {
10808 r = get_relocs (stub_entry->group->stub_sec, 1);
10809 if (r == NULL)
10810 return FALSE;
10811 r->r_offset = loc - stub_entry->group->stub_sec->contents;
10812 r->r_info = ELF64_R_INFO (0, R_PPC64_REL24);
10813 r->r_addend = dest;
10814 if (stub_entry->h != NULL)
10815 {
10816 struct elf_link_hash_entry **hashes;
10817 unsigned long symndx;
10818 struct ppc_link_hash_entry *h;
10819
10820 hashes = elf_sym_hashes (htab->params->stub_bfd);
10821 if (hashes == NULL)
10822 {
10823 bfd_size_type hsize;
10824
10825 hsize = (htab->stub_globals + 1) * sizeof (*hashes);
10826 hashes = bfd_zalloc (htab->params->stub_bfd, hsize);
10827 if (hashes == NULL)
10828 return FALSE;
10829 elf_sym_hashes (htab->params->stub_bfd) = hashes;
10830 htab->stub_globals = 1;
10831 }
10832 symndx = htab->stub_globals++;
10833 h = stub_entry->h;
10834 hashes[symndx] = &h->elf;
10835 r->r_info = ELF64_R_INFO (symndx, R_PPC64_REL24);
10836 if (h->oh != NULL && h->oh->is_func)
10837 h = ppc_follow_link (h->oh);
10838 if (h->elf.root.u.def.section != stub_entry->target_section)
10839 /* H is an opd symbol. The addend must be zero. */
10840 r->r_addend = 0;
10841 else
10842 {
10843 off = (h->elf.root.u.def.value
10844 + h->elf.root.u.def.section->output_offset
10845 + h->elf.root.u.def.section->output_section->vma);
10846 r->r_addend -= off;
10847 }
10848 }
10849 }
10850 break;
10851
10852 case ppc_stub_plt_branch:
10853 case ppc_stub_plt_branch_r2off:
10854 br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
10855 stub_entry->root.string + 9,
10856 FALSE, FALSE);
10857 if (br_entry == NULL)
10858 {
10859 info->callbacks->einfo (_("%P: can't find branch stub `%s'\n"),
10860 stub_entry->root.string);
10861 htab->stub_error = TRUE;
10862 return FALSE;
10863 }
10864
10865 dest = (stub_entry->target_value
10866 + stub_entry->target_section->output_offset
10867 + stub_entry->target_section->output_section->vma);
10868 if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
10869 dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
10870
10871 bfd_put_64 (htab->brlt->owner, dest,
10872 htab->brlt->contents + br_entry->offset);
10873
10874 if (br_entry->iter == htab->stub_iteration)
10875 {
10876 br_entry->iter = 0;
10877
10878 if (htab->relbrlt != NULL)
10879 {
10880 /* Create a reloc for the branch lookup table entry. */
10881 Elf_Internal_Rela rela;
10882 bfd_byte *rl;
10883
10884 rela.r_offset = (br_entry->offset
10885 + htab->brlt->output_offset
10886 + htab->brlt->output_section->vma);
10887 rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
10888 rela.r_addend = dest;
10889
10890 rl = htab->relbrlt->contents;
10891 rl += (htab->relbrlt->reloc_count++
10892 * sizeof (Elf64_External_Rela));
10893 bfd_elf64_swap_reloca_out (htab->relbrlt->owner, &rela, rl);
10894 }
10895 else if (info->emitrelocations)
10896 {
10897 r = get_relocs (htab->brlt, 1);
10898 if (r == NULL)
10899 return FALSE;
10900 /* brlt, being SEC_LINKER_CREATED does not go through the
10901 normal reloc processing. Symbols and offsets are not
10902 translated from input file to output file form, so
10903 set up the offset per the output file. */
10904 r->r_offset = (br_entry->offset
10905 + htab->brlt->output_offset
10906 + htab->brlt->output_section->vma);
10907 r->r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
10908 r->r_addend = dest;
10909 }
10910 }
10911
10912 dest = (br_entry->offset
10913 + htab->brlt->output_offset
10914 + htab->brlt->output_section->vma);
10915
10916 off = (dest
10917 - elf_gp (htab->brlt->output_section->owner)
10918 - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
10919
10920 if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
10921 {
10922 info->callbacks->einfo
10923 (_("%P: linkage table error against `%T'\n"),
10924 stub_entry->root.string);
10925 bfd_set_error (bfd_error_bad_value);
10926 htab->stub_error = TRUE;
10927 return FALSE;
10928 }
10929
10930 if (info->emitrelocations)
10931 {
10932 r = get_relocs (stub_entry->group->stub_sec, 1 + (PPC_HA (off) != 0));
10933 if (r == NULL)
10934 return FALSE;
10935 r[0].r_offset = loc - stub_entry->group->stub_sec->contents;
10936 if (bfd_big_endian (info->output_bfd))
10937 r[0].r_offset += 2;
10938 if (stub_entry->stub_type == ppc_stub_plt_branch_r2off)
10939 r[0].r_offset += 4;
10940 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10941 r[0].r_addend = dest;
10942 if (PPC_HA (off) != 0)
10943 {
10944 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
10945 r[1].r_offset = r[0].r_offset + 4;
10946 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10947 r[1].r_addend = r[0].r_addend;
10948 }
10949 }
10950
10951 if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
10952 {
10953 if (PPC_HA (off) != 0)
10954 {
10955 size = 16;
10956 bfd_put_32 (htab->params->stub_bfd,
10957 ADDIS_R12_R2 | PPC_HA (off), loc);
10958 loc += 4;
10959 bfd_put_32 (htab->params->stub_bfd,
10960 LD_R12_0R12 | PPC_LO (off), loc);
10961 }
10962 else
10963 {
10964 size = 12;
10965 bfd_put_32 (htab->params->stub_bfd,
10966 LD_R12_0R2 | PPC_LO (off), loc);
10967 }
10968 }
10969 else
10970 {
10971 bfd_vma r2off = get_r2off (info, stub_entry);
10972
10973 if (r2off == (bfd_vma) -1)
10974 {
10975 htab->stub_error = TRUE;
10976 return FALSE;
10977 }
10978
10979 bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), loc);
10980 loc += 4;
10981 size = 16;
10982 if (PPC_HA (off) != 0)
10983 {
10984 size += 4;
10985 bfd_put_32 (htab->params->stub_bfd,
10986 ADDIS_R12_R2 | PPC_HA (off), loc);
10987 loc += 4;
10988 bfd_put_32 (htab->params->stub_bfd,
10989 LD_R12_0R12 | PPC_LO (off), loc);
10990 }
10991 else
10992 bfd_put_32 (htab->params->stub_bfd, LD_R12_0R2 | PPC_LO (off), loc);
10993
10994 if (PPC_HA (r2off) != 0)
10995 {
10996 size += 4;
10997 loc += 4;
10998 bfd_put_32 (htab->params->stub_bfd,
10999 ADDIS_R2_R2 | PPC_HA (r2off), loc);
11000 }
11001 if (PPC_LO (r2off) != 0)
11002 {
11003 size += 4;
11004 loc += 4;
11005 bfd_put_32 (htab->params->stub_bfd,
11006 ADDI_R2_R2 | PPC_LO (r2off), loc);
11007 }
11008 }
11009 loc += 4;
11010 bfd_put_32 (htab->params->stub_bfd, MTCTR_R12, loc);
11011 loc += 4;
11012 bfd_put_32 (htab->params->stub_bfd, BCTR, loc);
11013 break;
11014
11015 case ppc_stub_plt_call:
11016 case ppc_stub_plt_call_r2save:
11017 if (stub_entry->h != NULL
11018 && stub_entry->h->is_func_descriptor
11019 && stub_entry->h->oh != NULL)
11020 {
11021 struct ppc_link_hash_entry *fh = ppc_follow_link (stub_entry->h->oh);
11022
11023 /* If the old-ABI "dot-symbol" is undefined make it weak so
11024 we don't get a link error from RELOC_FOR_GLOBAL_SYMBOL. */
11025 if (fh->elf.root.type == bfd_link_hash_undefined)
11026 fh->elf.root.type = bfd_link_hash_undefweak;
11027 /* Stop undo_symbol_twiddle changing it back to undefined. */
11028 fh->was_undefined = 0;
11029 }
11030
11031 /* Now build the stub. */
11032 dest = stub_entry->plt_ent->plt.offset & ~1;
11033 if (dest >= (bfd_vma) -2)
11034 abort ();
11035
11036 plt = htab->elf.splt;
11037 if (!htab->elf.dynamic_sections_created
11038 || stub_entry->h == NULL
11039 || stub_entry->h->elf.dynindx == -1)
11040 plt = htab->elf.iplt;
11041
11042 dest += plt->output_offset + plt->output_section->vma;
11043
11044 if (stub_entry->h == NULL
11045 && (stub_entry->plt_ent->plt.offset & 1) == 0)
11046 {
11047 Elf_Internal_Rela rela;
11048 bfd_byte *rl;
11049
11050 rela.r_offset = dest;
11051 if (htab->opd_abi)
11052 rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
11053 else
11054 rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
11055 rela.r_addend = (stub_entry->target_value
11056 + stub_entry->target_section->output_offset
11057 + stub_entry->target_section->output_section->vma);
11058
11059 rl = (htab->elf.irelplt->contents
11060 + (htab->elf.irelplt->reloc_count++
11061 * sizeof (Elf64_External_Rela)));
11062 bfd_elf64_swap_reloca_out (info->output_bfd, &rela, rl);
11063 stub_entry->plt_ent->plt.offset |= 1;
11064 }
11065
11066 off = (dest
11067 - elf_gp (plt->output_section->owner)
11068 - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11069
11070 if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
11071 {
11072 info->callbacks->einfo
11073 (_("%P: linkage table error against `%T'\n"),
11074 stub_entry->h != NULL
11075 ? stub_entry->h->elf.root.root.string
11076 : "<local sym>");
11077 bfd_set_error (bfd_error_bad_value);
11078 htab->stub_error = TRUE;
11079 return FALSE;
11080 }
11081
11082 if (htab->params->plt_stub_align != 0)
11083 {
11084 unsigned pad = plt_stub_pad (htab, stub_entry, off);
11085
11086 stub_entry->group->stub_sec->size += pad;
11087 stub_entry->stub_offset = stub_entry->group->stub_sec->size;
11088 loc += pad;
11089 }
11090
11091 r = NULL;
11092 if (info->emitrelocations)
11093 {
11094 r = get_relocs (stub_entry->group->stub_sec,
11095 ((PPC_HA (off) != 0)
11096 + (htab->opd_abi
11097 ? 2 + (htab->params->plt_static_chain
11098 && PPC_HA (off + 16) == PPC_HA (off))
11099 : 1)));
11100 if (r == NULL)
11101 return FALSE;
11102 r[0].r_offset = loc - stub_entry->group->stub_sec->contents;
11103 if (bfd_big_endian (info->output_bfd))
11104 r[0].r_offset += 2;
11105 r[0].r_addend = dest;
11106 }
11107 if (stub_entry->h != NULL
11108 && (stub_entry->h == htab->tls_get_addr_fd
11109 || stub_entry->h == htab->tls_get_addr)
11110 && htab->params->tls_get_addr_opt)
11111 p = build_tls_get_addr_stub (htab, stub_entry, loc, off, r);
11112 else
11113 p = build_plt_stub (htab, stub_entry, loc, off, r);
11114 size = p - loc;
11115 break;
11116
11117 case ppc_stub_save_res:
11118 return TRUE;
11119
11120 default:
11121 BFD_FAIL ();
11122 return FALSE;
11123 }
11124
11125 stub_entry->group->stub_sec->size += size;
11126
11127 if (htab->params->emit_stub_syms)
11128 {
11129 struct elf_link_hash_entry *h;
11130 size_t len1, len2;
11131 char *name;
11132 const char *const stub_str[] = { "long_branch",
11133 "long_branch_r2off",
11134 "plt_branch",
11135 "plt_branch_r2off",
11136 "plt_call",
11137 "plt_call" };
11138
11139 len1 = strlen (stub_str[stub_entry->stub_type - 1]);
11140 len2 = strlen (stub_entry->root.string);
11141 name = bfd_malloc (len1 + len2 + 2);
11142 if (name == NULL)
11143 return FALSE;
11144 memcpy (name, stub_entry->root.string, 9);
11145 memcpy (name + 9, stub_str[stub_entry->stub_type - 1], len1);
11146 memcpy (name + len1 + 9, stub_entry->root.string + 8, len2 - 8 + 1);
11147 h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
11148 if (h == NULL)
11149 return FALSE;
11150 if (h->root.type == bfd_link_hash_new)
11151 {
11152 h->root.type = bfd_link_hash_defined;
11153 h->root.u.def.section = stub_entry->group->stub_sec;
11154 h->root.u.def.value = stub_entry->stub_offset;
11155 h->ref_regular = 1;
11156 h->def_regular = 1;
11157 h->ref_regular_nonweak = 1;
11158 h->forced_local = 1;
11159 h->non_elf = 0;
11160 h->root.linker_def = 1;
11161 }
11162 }
11163
11164 return TRUE;
11165 }
11166
11167 /* As above, but don't actually build the stub. Just bump offset so
11168 we know stub section sizes, and select plt_branch stubs where
11169 long_branch stubs won't do. */
11170
11171 static bfd_boolean
ppc_size_one_stub(struct bfd_hash_entry * gen_entry,void * in_arg)11172 ppc_size_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
11173 {
11174 struct ppc_stub_hash_entry *stub_entry;
11175 struct bfd_link_info *info;
11176 struct ppc_link_hash_table *htab;
11177 bfd_vma off;
11178 int size;
11179
11180 /* Massage our args to the form they really have. */
11181 stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
11182 info = in_arg;
11183
11184 htab = ppc_hash_table (info);
11185 if (htab == NULL)
11186 return FALSE;
11187
11188 if (stub_entry->h != NULL
11189 && stub_entry->h->save_res
11190 && stub_entry->h->elf.root.type == bfd_link_hash_defined
11191 && stub_entry->h->elf.root.u.def.section == htab->sfpr)
11192 {
11193 /* Don't make stubs to out-of-line register save/restore
11194 functions. Instead, emit copies of the functions. */
11195 stub_entry->group->needs_save_res = 1;
11196 stub_entry->stub_type = ppc_stub_save_res;
11197 return TRUE;
11198 }
11199
11200 if (stub_entry->stub_type == ppc_stub_plt_call
11201 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
11202 {
11203 asection *plt;
11204 off = stub_entry->plt_ent->plt.offset & ~(bfd_vma) 1;
11205 if (off >= (bfd_vma) -2)
11206 abort ();
11207 plt = htab->elf.splt;
11208 if (!htab->elf.dynamic_sections_created
11209 || stub_entry->h == NULL
11210 || stub_entry->h->elf.dynindx == -1)
11211 plt = htab->elf.iplt;
11212 off += (plt->output_offset
11213 + plt->output_section->vma
11214 - elf_gp (plt->output_section->owner)
11215 - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11216
11217 size = plt_stub_size (htab, stub_entry, off);
11218 if (htab->params->plt_stub_align)
11219 size += plt_stub_pad (htab, stub_entry, off);
11220 if (info->emitrelocations)
11221 {
11222 stub_entry->group->stub_sec->reloc_count
11223 += ((PPC_HA (off) != 0)
11224 + (htab->opd_abi
11225 ? 2 + (htab->params->plt_static_chain
11226 && PPC_HA (off + 16) == PPC_HA (off))
11227 : 1));
11228 stub_entry->group->stub_sec->flags |= SEC_RELOC;
11229 }
11230 }
11231 else
11232 {
11233 /* ppc_stub_long_branch or ppc_stub_plt_branch, or their r2off
11234 variants. */
11235 bfd_vma r2off = 0;
11236 bfd_vma local_off = 0;
11237
11238 off = (stub_entry->target_value
11239 + stub_entry->target_section->output_offset
11240 + stub_entry->target_section->output_section->vma);
11241 off -= (stub_entry->group->stub_sec->size
11242 + stub_entry->group->stub_sec->output_offset
11243 + stub_entry->group->stub_sec->output_section->vma);
11244
11245 /* Reset the stub type from the plt variant in case we now
11246 can reach with a shorter stub. */
11247 if (stub_entry->stub_type >= ppc_stub_plt_branch)
11248 stub_entry->stub_type += ppc_stub_long_branch - ppc_stub_plt_branch;
11249
11250 size = 4;
11251 if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
11252 {
11253 r2off = get_r2off (info, stub_entry);
11254 if (r2off == (bfd_vma) -1)
11255 {
11256 htab->stub_error = TRUE;
11257 return FALSE;
11258 }
11259 size = 8;
11260 if (PPC_HA (r2off) != 0)
11261 size += 4;
11262 if (PPC_LO (r2off) != 0)
11263 size += 4;
11264 off -= size - 4;
11265 }
11266
11267 local_off = PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
11268
11269 /* If the branch offset if too big, use a ppc_stub_plt_branch.
11270 Do the same for -R objects without function descriptors. */
11271 if (off + (1 << 25) >= (bfd_vma) (1 << 26) - local_off
11272 || (stub_entry->stub_type == ppc_stub_long_branch_r2off
11273 && r2off == 0
11274 && htab->sec_info[stub_entry->target_section->id].toc_off == 0))
11275 {
11276 struct ppc_branch_hash_entry *br_entry;
11277
11278 br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
11279 stub_entry->root.string + 9,
11280 TRUE, FALSE);
11281 if (br_entry == NULL)
11282 {
11283 info->callbacks->einfo (_("%P: can't build branch stub `%s'\n"),
11284 stub_entry->root.string);
11285 htab->stub_error = TRUE;
11286 return FALSE;
11287 }
11288
11289 if (br_entry->iter != htab->stub_iteration)
11290 {
11291 br_entry->iter = htab->stub_iteration;
11292 br_entry->offset = htab->brlt->size;
11293 htab->brlt->size += 8;
11294
11295 if (htab->relbrlt != NULL)
11296 htab->relbrlt->size += sizeof (Elf64_External_Rela);
11297 else if (info->emitrelocations)
11298 {
11299 htab->brlt->reloc_count += 1;
11300 htab->brlt->flags |= SEC_RELOC;
11301 }
11302 }
11303
11304 stub_entry->stub_type += ppc_stub_plt_branch - ppc_stub_long_branch;
11305 off = (br_entry->offset
11306 + htab->brlt->output_offset
11307 + htab->brlt->output_section->vma
11308 - elf_gp (htab->brlt->output_section->owner)
11309 - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11310
11311 if (info->emitrelocations)
11312 {
11313 stub_entry->group->stub_sec->reloc_count
11314 += 1 + (PPC_HA (off) != 0);
11315 stub_entry->group->stub_sec->flags |= SEC_RELOC;
11316 }
11317
11318 if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
11319 {
11320 size = 12;
11321 if (PPC_HA (off) != 0)
11322 size = 16;
11323 }
11324 else
11325 {
11326 size = 16;
11327 if (PPC_HA (off) != 0)
11328 size += 4;
11329
11330 if (PPC_HA (r2off) != 0)
11331 size += 4;
11332 if (PPC_LO (r2off) != 0)
11333 size += 4;
11334 }
11335 }
11336 else if (info->emitrelocations)
11337 {
11338 stub_entry->group->stub_sec->reloc_count += 1;
11339 stub_entry->group->stub_sec->flags |= SEC_RELOC;
11340 }
11341 }
11342
11343 stub_entry->group->stub_sec->size += size;
11344 return TRUE;
11345 }
11346
11347 /* Set up various things so that we can make a list of input sections
11348 for each output section included in the link. Returns -1 on error,
11349 0 when no stubs will be needed, and 1 on success. */
11350
11351 int
ppc64_elf_setup_section_lists(struct bfd_link_info * info)11352 ppc64_elf_setup_section_lists (struct bfd_link_info *info)
11353 {
11354 unsigned int id;
11355 bfd_size_type amt;
11356 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11357
11358 if (htab == NULL)
11359 return -1;
11360
11361 htab->sec_info_arr_size = bfd_get_next_section_id ();
11362 amt = sizeof (*htab->sec_info) * (htab->sec_info_arr_size);
11363 htab->sec_info = bfd_zmalloc (amt);
11364 if (htab->sec_info == NULL)
11365 return -1;
11366
11367 /* Set toc_off for com, und, abs and ind sections. */
11368 for (id = 0; id < 3; id++)
11369 htab->sec_info[id].toc_off = TOC_BASE_OFF;
11370
11371 return 1;
11372 }
11373
11374 /* Set up for first pass at multitoc partitioning. */
11375
11376 void
ppc64_elf_start_multitoc_partition(struct bfd_link_info * info)11377 ppc64_elf_start_multitoc_partition (struct bfd_link_info *info)
11378 {
11379 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11380
11381 htab->toc_curr = ppc64_elf_set_toc (info, info->output_bfd);
11382 htab->toc_bfd = NULL;
11383 htab->toc_first_sec = NULL;
11384 }
11385
11386 /* The linker repeatedly calls this function for each TOC input section
11387 and linker generated GOT section. Group input bfds such that the toc
11388 within a group is less than 64k in size. */
11389
11390 bfd_boolean
ppc64_elf_next_toc_section(struct bfd_link_info * info,asection * isec)11391 ppc64_elf_next_toc_section (struct bfd_link_info *info, asection *isec)
11392 {
11393 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11394 bfd_vma addr, off, limit;
11395
11396 if (htab == NULL)
11397 return FALSE;
11398
11399 if (!htab->second_toc_pass)
11400 {
11401 /* Keep track of the first .toc or .got section for this input bfd. */
11402 bfd_boolean new_bfd = htab->toc_bfd != isec->owner;
11403
11404 if (new_bfd)
11405 {
11406 htab->toc_bfd = isec->owner;
11407 htab->toc_first_sec = isec;
11408 }
11409
11410 addr = isec->output_offset + isec->output_section->vma;
11411 off = addr - htab->toc_curr;
11412 limit = 0x80008000;
11413 if (ppc64_elf_tdata (isec->owner)->has_small_toc_reloc)
11414 limit = 0x10000;
11415 if (off + isec->size > limit)
11416 {
11417 addr = (htab->toc_first_sec->output_offset
11418 + htab->toc_first_sec->output_section->vma);
11419 htab->toc_curr = addr;
11420 htab->toc_curr &= -TOC_BASE_ALIGN;
11421 }
11422
11423 /* toc_curr is the base address of this toc group. Set elf_gp
11424 for the input section to be the offset relative to the
11425 output toc base plus 0x8000. Making the input elf_gp an
11426 offset allows us to move the toc as a whole without
11427 recalculating input elf_gp. */
11428 off = htab->toc_curr - elf_gp (isec->output_section->owner);
11429 off += TOC_BASE_OFF;
11430
11431 /* Die if someone uses a linker script that doesn't keep input
11432 file .toc and .got together. */
11433 if (new_bfd
11434 && elf_gp (isec->owner) != 0
11435 && elf_gp (isec->owner) != off)
11436 return FALSE;
11437
11438 elf_gp (isec->owner) = off;
11439 return TRUE;
11440 }
11441
11442 /* During the second pass toc_first_sec points to the start of
11443 a toc group, and toc_curr is used to track the old elf_gp.
11444 We use toc_bfd to ensure we only look at each bfd once. */
11445 if (htab->toc_bfd == isec->owner)
11446 return TRUE;
11447 htab->toc_bfd = isec->owner;
11448
11449 if (htab->toc_first_sec == NULL
11450 || htab->toc_curr != elf_gp (isec->owner))
11451 {
11452 htab->toc_curr = elf_gp (isec->owner);
11453 htab->toc_first_sec = isec;
11454 }
11455 addr = (htab->toc_first_sec->output_offset
11456 + htab->toc_first_sec->output_section->vma);
11457 off = addr - elf_gp (isec->output_section->owner) + TOC_BASE_OFF;
11458 elf_gp (isec->owner) = off;
11459
11460 return TRUE;
11461 }
11462
11463 /* Called via elf_link_hash_traverse to merge GOT entries for global
11464 symbol H. */
11465
11466 static bfd_boolean
merge_global_got(struct elf_link_hash_entry * h,void * inf ATTRIBUTE_UNUSED)11467 merge_global_got (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
11468 {
11469 if (h->root.type == bfd_link_hash_indirect)
11470 return TRUE;
11471
11472 merge_got_entries (&h->got.glist);
11473
11474 return TRUE;
11475 }
11476
11477 /* Called via elf_link_hash_traverse to allocate GOT entries for global
11478 symbol H. */
11479
11480 static bfd_boolean
reallocate_got(struct elf_link_hash_entry * h,void * inf)11481 reallocate_got (struct elf_link_hash_entry *h, void *inf)
11482 {
11483 struct got_entry *gent;
11484
11485 if (h->root.type == bfd_link_hash_indirect)
11486 return TRUE;
11487
11488 for (gent = h->got.glist; gent != NULL; gent = gent->next)
11489 if (!gent->is_indirect)
11490 allocate_got (h, (struct bfd_link_info *) inf, gent);
11491 return TRUE;
11492 }
11493
11494 /* Called on the first multitoc pass after the last call to
11495 ppc64_elf_next_toc_section. This function removes duplicate GOT
11496 entries. */
11497
11498 bfd_boolean
ppc64_elf_layout_multitoc(struct bfd_link_info * info)11499 ppc64_elf_layout_multitoc (struct bfd_link_info *info)
11500 {
11501 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11502 struct bfd *ibfd, *ibfd2;
11503 bfd_boolean done_something;
11504
11505 htab->multi_toc_needed = htab->toc_curr != elf_gp (info->output_bfd);
11506
11507 if (!htab->do_multi_toc)
11508 return FALSE;
11509
11510 /* Merge global sym got entries within a toc group. */
11511 elf_link_hash_traverse (&htab->elf, merge_global_got, info);
11512
11513 /* And tlsld_got. */
11514 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11515 {
11516 struct got_entry *ent, *ent2;
11517
11518 if (!is_ppc64_elf (ibfd))
11519 continue;
11520
11521 ent = ppc64_tlsld_got (ibfd);
11522 if (!ent->is_indirect
11523 && ent->got.offset != (bfd_vma) -1)
11524 {
11525 for (ibfd2 = ibfd->link.next; ibfd2 != NULL; ibfd2 = ibfd2->link.next)
11526 {
11527 if (!is_ppc64_elf (ibfd2))
11528 continue;
11529
11530 ent2 = ppc64_tlsld_got (ibfd2);
11531 if (!ent2->is_indirect
11532 && ent2->got.offset != (bfd_vma) -1
11533 && elf_gp (ibfd2) == elf_gp (ibfd))
11534 {
11535 ent2->is_indirect = TRUE;
11536 ent2->got.ent = ent;
11537 }
11538 }
11539 }
11540 }
11541
11542 /* Zap sizes of got sections. */
11543 htab->elf.irelplt->rawsize = htab->elf.irelplt->size;
11544 htab->elf.irelplt->size -= htab->got_reli_size;
11545 htab->got_reli_size = 0;
11546
11547 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11548 {
11549 asection *got, *relgot;
11550
11551 if (!is_ppc64_elf (ibfd))
11552 continue;
11553
11554 got = ppc64_elf_tdata (ibfd)->got;
11555 if (got != NULL)
11556 {
11557 got->rawsize = got->size;
11558 got->size = 0;
11559 relgot = ppc64_elf_tdata (ibfd)->relgot;
11560 relgot->rawsize = relgot->size;
11561 relgot->size = 0;
11562 }
11563 }
11564
11565 /* Now reallocate the got, local syms first. We don't need to
11566 allocate section contents again since we never increase size. */
11567 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11568 {
11569 struct got_entry **lgot_ents;
11570 struct got_entry **end_lgot_ents;
11571 struct plt_entry **local_plt;
11572 struct plt_entry **end_local_plt;
11573 unsigned char *lgot_masks;
11574 bfd_size_type locsymcount;
11575 Elf_Internal_Shdr *symtab_hdr;
11576 asection *s;
11577
11578 if (!is_ppc64_elf (ibfd))
11579 continue;
11580
11581 lgot_ents = elf_local_got_ents (ibfd);
11582 if (!lgot_ents)
11583 continue;
11584
11585 symtab_hdr = &elf_symtab_hdr (ibfd);
11586 locsymcount = symtab_hdr->sh_info;
11587 end_lgot_ents = lgot_ents + locsymcount;
11588 local_plt = (struct plt_entry **) end_lgot_ents;
11589 end_local_plt = local_plt + locsymcount;
11590 lgot_masks = (unsigned char *) end_local_plt;
11591 s = ppc64_elf_tdata (ibfd)->got;
11592 for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
11593 {
11594 struct got_entry *ent;
11595
11596 for (ent = *lgot_ents; ent != NULL; ent = ent->next)
11597 {
11598 unsigned int ent_size = 8;
11599 unsigned int rel_size = sizeof (Elf64_External_Rela);
11600
11601 ent->got.offset = s->size;
11602 if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
11603 {
11604 ent_size *= 2;
11605 rel_size *= 2;
11606 }
11607 s->size += ent_size;
11608 if ((*lgot_masks & PLT_IFUNC) != 0)
11609 {
11610 htab->elf.irelplt->size += rel_size;
11611 htab->got_reli_size += rel_size;
11612 }
11613 else if (bfd_link_pic (info))
11614 {
11615 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
11616 srel->size += rel_size;
11617 }
11618 }
11619 }
11620 }
11621
11622 elf_link_hash_traverse (&htab->elf, reallocate_got, info);
11623
11624 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11625 {
11626 struct got_entry *ent;
11627
11628 if (!is_ppc64_elf (ibfd))
11629 continue;
11630
11631 ent = ppc64_tlsld_got (ibfd);
11632 if (!ent->is_indirect
11633 && ent->got.offset != (bfd_vma) -1)
11634 {
11635 asection *s = ppc64_elf_tdata (ibfd)->got;
11636 ent->got.offset = s->size;
11637 s->size += 16;
11638 if (bfd_link_pic (info))
11639 {
11640 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
11641 srel->size += sizeof (Elf64_External_Rela);
11642 }
11643 }
11644 }
11645
11646 done_something = htab->elf.irelplt->rawsize != htab->elf.irelplt->size;
11647 if (!done_something)
11648 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11649 {
11650 asection *got;
11651
11652 if (!is_ppc64_elf (ibfd))
11653 continue;
11654
11655 got = ppc64_elf_tdata (ibfd)->got;
11656 if (got != NULL)
11657 {
11658 done_something = got->rawsize != got->size;
11659 if (done_something)
11660 break;
11661 }
11662 }
11663
11664 if (done_something)
11665 (*htab->params->layout_sections_again) ();
11666
11667 /* Set up for second pass over toc sections to recalculate elf_gp
11668 on input sections. */
11669 htab->toc_bfd = NULL;
11670 htab->toc_first_sec = NULL;
11671 htab->second_toc_pass = TRUE;
11672 return done_something;
11673 }
11674
11675 /* Called after second pass of multitoc partitioning. */
11676
11677 void
ppc64_elf_finish_multitoc_partition(struct bfd_link_info * info)11678 ppc64_elf_finish_multitoc_partition (struct bfd_link_info *info)
11679 {
11680 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11681
11682 /* After the second pass, toc_curr tracks the TOC offset used
11683 for code sections below in ppc64_elf_next_input_section. */
11684 htab->toc_curr = TOC_BASE_OFF;
11685 }
11686
11687 /* No toc references were found in ISEC. If the code in ISEC makes no
11688 calls, then there's no need to use toc adjusting stubs when branching
11689 into ISEC. Actually, indirect calls from ISEC are OK as they will
11690 load r2. Returns -1 on error, 0 for no stub needed, 1 for stub
11691 needed, and 2 if a cyclical call-graph was found but no other reason
11692 for a stub was detected. If called from the top level, a return of
11693 2 means the same as a return of 0. */
11694
11695 static int
toc_adjusting_stub_needed(struct bfd_link_info * info,asection * isec)11696 toc_adjusting_stub_needed (struct bfd_link_info *info, asection *isec)
11697 {
11698 int ret;
11699
11700 /* Mark this section as checked. */
11701 isec->call_check_done = 1;
11702
11703 /* We know none of our code bearing sections will need toc stubs. */
11704 if ((isec->flags & SEC_LINKER_CREATED) != 0)
11705 return 0;
11706
11707 if (isec->size == 0)
11708 return 0;
11709
11710 if (isec->output_section == NULL)
11711 return 0;
11712
11713 ret = 0;
11714 if (isec->reloc_count != 0)
11715 {
11716 Elf_Internal_Rela *relstart, *rel;
11717 Elf_Internal_Sym *local_syms;
11718 struct ppc_link_hash_table *htab;
11719
11720 relstart = _bfd_elf_link_read_relocs (isec->owner, isec, NULL, NULL,
11721 info->keep_memory);
11722 if (relstart == NULL)
11723 return -1;
11724
11725 /* Look for branches to outside of this section. */
11726 local_syms = NULL;
11727 htab = ppc_hash_table (info);
11728 if (htab == NULL)
11729 return -1;
11730
11731 for (rel = relstart; rel < relstart + isec->reloc_count; ++rel)
11732 {
11733 enum elf_ppc64_reloc_type r_type;
11734 unsigned long r_symndx;
11735 struct elf_link_hash_entry *h;
11736 struct ppc_link_hash_entry *eh;
11737 Elf_Internal_Sym *sym;
11738 asection *sym_sec;
11739 struct _opd_sec_data *opd;
11740 bfd_vma sym_value;
11741 bfd_vma dest;
11742
11743 r_type = ELF64_R_TYPE (rel->r_info);
11744 if (r_type != R_PPC64_REL24
11745 && r_type != R_PPC64_REL14
11746 && r_type != R_PPC64_REL14_BRTAKEN
11747 && r_type != R_PPC64_REL14_BRNTAKEN)
11748 continue;
11749
11750 r_symndx = ELF64_R_SYM (rel->r_info);
11751 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms, r_symndx,
11752 isec->owner))
11753 {
11754 ret = -1;
11755 break;
11756 }
11757
11758 /* Calls to dynamic lib functions go through a plt call stub
11759 that uses r2. */
11760 eh = (struct ppc_link_hash_entry *) h;
11761 if (eh != NULL
11762 && (eh->elf.plt.plist != NULL
11763 || (eh->oh != NULL
11764 && ppc_follow_link (eh->oh)->elf.plt.plist != NULL)))
11765 {
11766 ret = 1;
11767 break;
11768 }
11769
11770 if (sym_sec == NULL)
11771 /* Ignore other undefined symbols. */
11772 continue;
11773
11774 /* Assume branches to other sections not included in the
11775 link need stubs too, to cover -R and absolute syms. */
11776 if (sym_sec->output_section == NULL)
11777 {
11778 ret = 1;
11779 break;
11780 }
11781
11782 if (h == NULL)
11783 sym_value = sym->st_value;
11784 else
11785 {
11786 if (h->root.type != bfd_link_hash_defined
11787 && h->root.type != bfd_link_hash_defweak)
11788 abort ();
11789 sym_value = h->root.u.def.value;
11790 }
11791 sym_value += rel->r_addend;
11792
11793 /* If this branch reloc uses an opd sym, find the code section. */
11794 opd = get_opd_info (sym_sec);
11795 if (opd != NULL)
11796 {
11797 if (h == NULL && opd->adjust != NULL)
11798 {
11799 long adjust;
11800
11801 adjust = opd->adjust[OPD_NDX (sym_value)];
11802 if (adjust == -1)
11803 /* Assume deleted functions won't ever be called. */
11804 continue;
11805 sym_value += adjust;
11806 }
11807
11808 dest = opd_entry_value (sym_sec, sym_value,
11809 &sym_sec, NULL, FALSE);
11810 if (dest == (bfd_vma) -1)
11811 continue;
11812 }
11813 else
11814 dest = (sym_value
11815 + sym_sec->output_offset
11816 + sym_sec->output_section->vma);
11817
11818 /* Ignore branch to self. */
11819 if (sym_sec == isec)
11820 continue;
11821
11822 /* If the called function uses the toc, we need a stub. */
11823 if (sym_sec->has_toc_reloc
11824 || sym_sec->makes_toc_func_call)
11825 {
11826 ret = 1;
11827 break;
11828 }
11829
11830 /* Assume any branch that needs a long branch stub might in fact
11831 need a plt_branch stub. A plt_branch stub uses r2. */
11832 else if (dest - (isec->output_offset
11833 + isec->output_section->vma
11834 + rel->r_offset) + (1 << 25)
11835 >= (2u << 25) - PPC64_LOCAL_ENTRY_OFFSET (h
11836 ? h->other
11837 : sym->st_other))
11838 {
11839 ret = 1;
11840 break;
11841 }
11842
11843 /* If calling back to a section in the process of being
11844 tested, we can't say for sure that no toc adjusting stubs
11845 are needed, so don't return zero. */
11846 else if (sym_sec->call_check_in_progress)
11847 ret = 2;
11848
11849 /* Branches to another section that itself doesn't have any TOC
11850 references are OK. Recursively call ourselves to check. */
11851 else if (!sym_sec->call_check_done)
11852 {
11853 int recur;
11854
11855 /* Mark current section as indeterminate, so that other
11856 sections that call back to current won't be marked as
11857 known. */
11858 isec->call_check_in_progress = 1;
11859 recur = toc_adjusting_stub_needed (info, sym_sec);
11860 isec->call_check_in_progress = 0;
11861
11862 if (recur != 0)
11863 {
11864 ret = recur;
11865 if (recur != 2)
11866 break;
11867 }
11868 }
11869 }
11870
11871 if (local_syms != NULL
11872 && (elf_symtab_hdr (isec->owner).contents
11873 != (unsigned char *) local_syms))
11874 free (local_syms);
11875 if (elf_section_data (isec)->relocs != relstart)
11876 free (relstart);
11877 }
11878
11879 if ((ret & 1) == 0
11880 && isec->map_head.s != NULL
11881 && (strcmp (isec->output_section->name, ".init") == 0
11882 || strcmp (isec->output_section->name, ".fini") == 0))
11883 {
11884 if (isec->map_head.s->has_toc_reloc
11885 || isec->map_head.s->makes_toc_func_call)
11886 ret = 1;
11887 else if (!isec->map_head.s->call_check_done)
11888 {
11889 int recur;
11890 isec->call_check_in_progress = 1;
11891 recur = toc_adjusting_stub_needed (info, isec->map_head.s);
11892 isec->call_check_in_progress = 0;
11893 if (recur != 0)
11894 ret = recur;
11895 }
11896 }
11897
11898 if (ret == 1)
11899 isec->makes_toc_func_call = 1;
11900
11901 return ret;
11902 }
11903
11904 /* The linker repeatedly calls this function for each input section,
11905 in the order that input sections are linked into output sections.
11906 Build lists of input sections to determine groupings between which
11907 we may insert linker stubs. */
11908
11909 bfd_boolean
ppc64_elf_next_input_section(struct bfd_link_info * info,asection * isec)11910 ppc64_elf_next_input_section (struct bfd_link_info *info, asection *isec)
11911 {
11912 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11913
11914 if (htab == NULL)
11915 return FALSE;
11916
11917 if ((isec->output_section->flags & SEC_CODE) != 0
11918 && isec->output_section->id < htab->sec_info_arr_size)
11919 {
11920 /* This happens to make the list in reverse order,
11921 which is what we want. */
11922 htab->sec_info[isec->id].u.list
11923 = htab->sec_info[isec->output_section->id].u.list;
11924 htab->sec_info[isec->output_section->id].u.list = isec;
11925 }
11926
11927 if (htab->multi_toc_needed)
11928 {
11929 /* Analyse sections that aren't already flagged as needing a
11930 valid toc pointer. Exclude .fixup for the linux kernel.
11931 .fixup contains branches, but only back to the function that
11932 hit an exception. */
11933 if (!(isec->has_toc_reloc
11934 || (isec->flags & SEC_CODE) == 0
11935 || strcmp (isec->name, ".fixup") == 0
11936 || isec->call_check_done))
11937 {
11938 if (toc_adjusting_stub_needed (info, isec) < 0)
11939 return FALSE;
11940 }
11941 /* Make all sections use the TOC assigned for this object file.
11942 This will be wrong for pasted sections; We fix that in
11943 check_pasted_section(). */
11944 if (elf_gp (isec->owner) != 0)
11945 htab->toc_curr = elf_gp (isec->owner);
11946 }
11947
11948 htab->sec_info[isec->id].toc_off = htab->toc_curr;
11949 return TRUE;
11950 }
11951
11952 /* Check that all .init and .fini sections use the same toc, if they
11953 have toc relocs. */
11954
11955 static bfd_boolean
check_pasted_section(struct bfd_link_info * info,const char * name)11956 check_pasted_section (struct bfd_link_info *info, const char *name)
11957 {
11958 asection *o = bfd_get_section_by_name (info->output_bfd, name);
11959
11960 if (o != NULL)
11961 {
11962 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11963 bfd_vma toc_off = 0;
11964 asection *i;
11965
11966 for (i = o->map_head.s; i != NULL; i = i->map_head.s)
11967 if (i->has_toc_reloc)
11968 {
11969 if (toc_off == 0)
11970 toc_off = htab->sec_info[i->id].toc_off;
11971 else if (toc_off != htab->sec_info[i->id].toc_off)
11972 return FALSE;
11973 }
11974
11975 if (toc_off == 0)
11976 for (i = o->map_head.s; i != NULL; i = i->map_head.s)
11977 if (i->makes_toc_func_call)
11978 {
11979 toc_off = htab->sec_info[i->id].toc_off;
11980 break;
11981 }
11982
11983 /* Make sure the whole pasted function uses the same toc offset. */
11984 if (toc_off != 0)
11985 for (i = o->map_head.s; i != NULL; i = i->map_head.s)
11986 htab->sec_info[i->id].toc_off = toc_off;
11987 }
11988 return TRUE;
11989 }
11990
11991 bfd_boolean
ppc64_elf_check_init_fini(struct bfd_link_info * info)11992 ppc64_elf_check_init_fini (struct bfd_link_info *info)
11993 {
11994 return (check_pasted_section (info, ".init")
11995 & check_pasted_section (info, ".fini"));
11996 }
11997
11998 /* See whether we can group stub sections together. Grouping stub
11999 sections may result in fewer stubs. More importantly, we need to
12000 put all .init* and .fini* stubs at the beginning of the .init or
12001 .fini output sections respectively, because glibc splits the
12002 _init and _fini functions into multiple parts. Putting a stub in
12003 the middle of a function is not a good idea. */
12004
12005 static bfd_boolean
group_sections(struct bfd_link_info * info,bfd_size_type stub_group_size,bfd_boolean stubs_always_before_branch)12006 group_sections (struct bfd_link_info *info,
12007 bfd_size_type stub_group_size,
12008 bfd_boolean stubs_always_before_branch)
12009 {
12010 struct ppc_link_hash_table *htab;
12011 asection *osec;
12012 bfd_size_type stub14_group_size;
12013 bfd_boolean suppress_size_errors;
12014
12015 htab = ppc_hash_table (info);
12016 if (htab == NULL)
12017 return FALSE;
12018
12019 suppress_size_errors = FALSE;
12020 stub14_group_size = stub_group_size >> 10;
12021 if (stub_group_size == 1)
12022 {
12023 /* Default values. */
12024 if (stubs_always_before_branch)
12025 {
12026 stub_group_size = 0x1e00000;
12027 stub14_group_size = 0x7800;
12028 }
12029 else
12030 {
12031 stub_group_size = 0x1c00000;
12032 stub14_group_size = 0x7000;
12033 }
12034 suppress_size_errors = TRUE;
12035 }
12036
12037 for (osec = info->output_bfd->sections; osec != NULL; osec = osec->next)
12038 {
12039 asection *tail;
12040
12041 if (osec->id >= htab->sec_info_arr_size)
12042 continue;
12043
12044 tail = htab->sec_info[osec->id].u.list;
12045 while (tail != NULL)
12046 {
12047 asection *curr;
12048 asection *prev;
12049 bfd_size_type total;
12050 bfd_boolean big_sec;
12051 bfd_vma curr_toc;
12052 struct map_stub *group;
12053
12054 curr = tail;
12055 total = tail->size;
12056 big_sec = total > (ppc64_elf_section_data (tail) != NULL
12057 && ppc64_elf_section_data (tail)->has_14bit_branch
12058 ? stub14_group_size : stub_group_size);
12059 if (big_sec && !suppress_size_errors)
12060 (*_bfd_error_handler) (_("%B section %A exceeds stub group size"),
12061 tail->owner, tail);
12062 curr_toc = htab->sec_info[tail->id].toc_off;
12063
12064 while ((prev = htab->sec_info[curr->id].u.list) != NULL
12065 && ((total += curr->output_offset - prev->output_offset)
12066 < (ppc64_elf_section_data (prev) != NULL
12067 && ppc64_elf_section_data (prev)->has_14bit_branch
12068 ? stub14_group_size : stub_group_size))
12069 && htab->sec_info[prev->id].toc_off == curr_toc)
12070 curr = prev;
12071
12072 /* OK, the size from the start of CURR to the end is less
12073 than stub_group_size and thus can be handled by one stub
12074 section. (or the tail section is itself larger than
12075 stub_group_size, in which case we may be toast.) We
12076 should really be keeping track of the total size of stubs
12077 added here, as stubs contribute to the final output
12078 section size. That's a little tricky, and this way will
12079 only break if stubs added make the total size more than
12080 2^25, ie. for the default stub_group_size, if stubs total
12081 more than 2097152 bytes, or nearly 75000 plt call stubs. */
12082 group = bfd_alloc (curr->owner, sizeof (*group));
12083 if (group == NULL)
12084 return FALSE;
12085 group->link_sec = curr;
12086 group->stub_sec = NULL;
12087 group->needs_save_res = 0;
12088 group->next = htab->group;
12089 htab->group = group;
12090 do
12091 {
12092 prev = htab->sec_info[tail->id].u.list;
12093 /* Set up this stub group. */
12094 htab->sec_info[tail->id].u.group = group;
12095 }
12096 while (tail != curr && (tail = prev) != NULL);
12097
12098 /* But wait, there's more! Input sections up to stub_group_size
12099 bytes before the stub section can be handled by it too.
12100 Don't do this if we have a really large section after the
12101 stubs, as adding more stubs increases the chance that
12102 branches may not reach into the stub section. */
12103 if (!stubs_always_before_branch && !big_sec)
12104 {
12105 total = 0;
12106 while (prev != NULL
12107 && ((total += tail->output_offset - prev->output_offset)
12108 < (ppc64_elf_section_data (prev) != NULL
12109 && ppc64_elf_section_data (prev)->has_14bit_branch
12110 ? stub14_group_size : stub_group_size))
12111 && htab->sec_info[prev->id].toc_off == curr_toc)
12112 {
12113 tail = prev;
12114 prev = htab->sec_info[tail->id].u.list;
12115 htab->sec_info[tail->id].u.group = group;
12116 }
12117 }
12118 tail = prev;
12119 }
12120 }
12121 return TRUE;
12122 }
12123
12124 static const unsigned char glink_eh_frame_cie[] =
12125 {
12126 0, 0, 0, 16, /* length. */
12127 0, 0, 0, 0, /* id. */
12128 1, /* CIE version. */
12129 'z', 'R', 0, /* Augmentation string. */
12130 4, /* Code alignment. */
12131 0x78, /* Data alignment. */
12132 65, /* RA reg. */
12133 1, /* Augmentation size. */
12134 DW_EH_PE_pcrel | DW_EH_PE_sdata4, /* FDE encoding. */
12135 DW_CFA_def_cfa, 1, 0, /* def_cfa: r1 offset 0. */
12136 0, 0, 0, 0
12137 };
12138
12139 /* Stripping output sections is normally done before dynamic section
12140 symbols have been allocated. This function is called later, and
12141 handles cases like htab->brlt which is mapped to its own output
12142 section. */
12143
12144 static void
maybe_strip_output(struct bfd_link_info * info,asection * isec)12145 maybe_strip_output (struct bfd_link_info *info, asection *isec)
12146 {
12147 if (isec->size == 0
12148 && isec->output_section->size == 0
12149 && !(isec->output_section->flags & SEC_KEEP)
12150 && !bfd_section_removed_from_list (info->output_bfd,
12151 isec->output_section)
12152 && elf_section_data (isec->output_section)->dynindx == 0)
12153 {
12154 isec->output_section->flags |= SEC_EXCLUDE;
12155 bfd_section_list_remove (info->output_bfd, isec->output_section);
12156 info->output_bfd->section_count--;
12157 }
12158 }
12159
12160 /* Determine and set the size of the stub section for a final link.
12161
12162 The basic idea here is to examine all the relocations looking for
12163 PC-relative calls to a target that is unreachable with a "bl"
12164 instruction. */
12165
12166 bfd_boolean
ppc64_elf_size_stubs(struct bfd_link_info * info)12167 ppc64_elf_size_stubs (struct bfd_link_info *info)
12168 {
12169 bfd_size_type stub_group_size;
12170 bfd_boolean stubs_always_before_branch;
12171 struct ppc_link_hash_table *htab = ppc_hash_table (info);
12172
12173 if (htab == NULL)
12174 return FALSE;
12175
12176 if (htab->params->plt_thread_safe == -1 && !bfd_link_executable (info))
12177 htab->params->plt_thread_safe = 1;
12178 if (!htab->opd_abi)
12179 htab->params->plt_thread_safe = 0;
12180 else if (htab->params->plt_thread_safe == -1)
12181 {
12182 static const char *const thread_starter[] =
12183 {
12184 "pthread_create",
12185 /* libstdc++ */
12186 "_ZNSt6thread15_M_start_threadESt10shared_ptrINS_10_Impl_baseEE",
12187 /* librt */
12188 "aio_init", "aio_read", "aio_write", "aio_fsync", "lio_listio",
12189 "mq_notify", "create_timer",
12190 /* libanl */
12191 "getaddrinfo_a",
12192 /* libgomp */
12193 "GOMP_parallel",
12194 "GOMP_parallel_start",
12195 "GOMP_parallel_loop_static",
12196 "GOMP_parallel_loop_static_start",
12197 "GOMP_parallel_loop_dynamic",
12198 "GOMP_parallel_loop_dynamic_start",
12199 "GOMP_parallel_loop_guided",
12200 "GOMP_parallel_loop_guided_start",
12201 "GOMP_parallel_loop_runtime",
12202 "GOMP_parallel_loop_runtime_start",
12203 "GOMP_parallel_sections",
12204 "GOMP_parallel_sections_start",
12205 /* libgo */
12206 "__go_go",
12207 };
12208 unsigned i;
12209
12210 for (i = 0; i < ARRAY_SIZE (thread_starter); i++)
12211 {
12212 struct elf_link_hash_entry *h;
12213 h = elf_link_hash_lookup (&htab->elf, thread_starter[i],
12214 FALSE, FALSE, TRUE);
12215 htab->params->plt_thread_safe = h != NULL && h->ref_regular;
12216 if (htab->params->plt_thread_safe)
12217 break;
12218 }
12219 }
12220 stubs_always_before_branch = htab->params->group_size < 0;
12221 if (htab->params->group_size < 0)
12222 stub_group_size = -htab->params->group_size;
12223 else
12224 stub_group_size = htab->params->group_size;
12225
12226 if (!group_sections (info, stub_group_size, stubs_always_before_branch))
12227 return FALSE;
12228
12229 #define STUB_SHRINK_ITER 20
12230 /* Loop until no stubs added. After iteration 20 of this loop we may
12231 exit on a stub section shrinking. This is to break out of a
12232 pathological case where adding stubs on one iteration decreases
12233 section gaps (perhaps due to alignment), which then requires
12234 fewer or smaller stubs on the next iteration. */
12235
12236 while (1)
12237 {
12238 bfd *input_bfd;
12239 unsigned int bfd_indx;
12240 struct map_stub *group;
12241 asection *stub_sec;
12242
12243 htab->stub_iteration += 1;
12244
12245 for (input_bfd = info->input_bfds, bfd_indx = 0;
12246 input_bfd != NULL;
12247 input_bfd = input_bfd->link.next, bfd_indx++)
12248 {
12249 Elf_Internal_Shdr *symtab_hdr;
12250 asection *section;
12251 Elf_Internal_Sym *local_syms = NULL;
12252
12253 if (!is_ppc64_elf (input_bfd))
12254 continue;
12255
12256 /* We'll need the symbol table in a second. */
12257 symtab_hdr = &elf_symtab_hdr (input_bfd);
12258 if (symtab_hdr->sh_info == 0)
12259 continue;
12260
12261 /* Walk over each section attached to the input bfd. */
12262 for (section = input_bfd->sections;
12263 section != NULL;
12264 section = section->next)
12265 {
12266 Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
12267
12268 /* If there aren't any relocs, then there's nothing more
12269 to do. */
12270 if ((section->flags & SEC_RELOC) == 0
12271 || (section->flags & SEC_ALLOC) == 0
12272 || (section->flags & SEC_LOAD) == 0
12273 || (section->flags & SEC_CODE) == 0
12274 || section->reloc_count == 0)
12275 continue;
12276
12277 /* If this section is a link-once section that will be
12278 discarded, then don't create any stubs. */
12279 if (section->output_section == NULL
12280 || section->output_section->owner != info->output_bfd)
12281 continue;
12282
12283 /* Get the relocs. */
12284 internal_relocs
12285 = _bfd_elf_link_read_relocs (input_bfd, section, NULL, NULL,
12286 info->keep_memory);
12287 if (internal_relocs == NULL)
12288 goto error_ret_free_local;
12289
12290 /* Now examine each relocation. */
12291 irela = internal_relocs;
12292 irelaend = irela + section->reloc_count;
12293 for (; irela < irelaend; irela++)
12294 {
12295 enum elf_ppc64_reloc_type r_type;
12296 unsigned int r_indx;
12297 enum ppc_stub_type stub_type;
12298 struct ppc_stub_hash_entry *stub_entry;
12299 asection *sym_sec, *code_sec;
12300 bfd_vma sym_value, code_value;
12301 bfd_vma destination;
12302 unsigned long local_off;
12303 bfd_boolean ok_dest;
12304 struct ppc_link_hash_entry *hash;
12305 struct ppc_link_hash_entry *fdh;
12306 struct elf_link_hash_entry *h;
12307 Elf_Internal_Sym *sym;
12308 char *stub_name;
12309 const asection *id_sec;
12310 struct _opd_sec_data *opd;
12311 struct plt_entry *plt_ent;
12312
12313 r_type = ELF64_R_TYPE (irela->r_info);
12314 r_indx = ELF64_R_SYM (irela->r_info);
12315
12316 if (r_type >= R_PPC64_max)
12317 {
12318 bfd_set_error (bfd_error_bad_value);
12319 goto error_ret_free_internal;
12320 }
12321
12322 /* Only look for stubs on branch instructions. */
12323 if (r_type != R_PPC64_REL24
12324 && r_type != R_PPC64_REL14
12325 && r_type != R_PPC64_REL14_BRTAKEN
12326 && r_type != R_PPC64_REL14_BRNTAKEN)
12327 continue;
12328
12329 /* Now determine the call target, its name, value,
12330 section. */
12331 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
12332 r_indx, input_bfd))
12333 goto error_ret_free_internal;
12334 hash = (struct ppc_link_hash_entry *) h;
12335
12336 ok_dest = FALSE;
12337 fdh = NULL;
12338 sym_value = 0;
12339 if (hash == NULL)
12340 {
12341 sym_value = sym->st_value;
12342 if (sym_sec != NULL
12343 && sym_sec->output_section != NULL)
12344 ok_dest = TRUE;
12345 }
12346 else if (hash->elf.root.type == bfd_link_hash_defined
12347 || hash->elf.root.type == bfd_link_hash_defweak)
12348 {
12349 sym_value = hash->elf.root.u.def.value;
12350 if (sym_sec->output_section != NULL)
12351 ok_dest = TRUE;
12352 }
12353 else if (hash->elf.root.type == bfd_link_hash_undefweak
12354 || hash->elf.root.type == bfd_link_hash_undefined)
12355 {
12356 /* Recognise an old ABI func code entry sym, and
12357 use the func descriptor sym instead if it is
12358 defined. */
12359 if (hash->elf.root.root.string[0] == '.'
12360 && (fdh = lookup_fdh (hash, htab)) != NULL)
12361 {
12362 if (fdh->elf.root.type == bfd_link_hash_defined
12363 || fdh->elf.root.type == bfd_link_hash_defweak)
12364 {
12365 sym_sec = fdh->elf.root.u.def.section;
12366 sym_value = fdh->elf.root.u.def.value;
12367 if (sym_sec->output_section != NULL)
12368 ok_dest = TRUE;
12369 }
12370 else
12371 fdh = NULL;
12372 }
12373 }
12374 else
12375 {
12376 bfd_set_error (bfd_error_bad_value);
12377 goto error_ret_free_internal;
12378 }
12379
12380 destination = 0;
12381 local_off = 0;
12382 if (ok_dest)
12383 {
12384 sym_value += irela->r_addend;
12385 destination = (sym_value
12386 + sym_sec->output_offset
12387 + sym_sec->output_section->vma);
12388 local_off = PPC64_LOCAL_ENTRY_OFFSET (hash
12389 ? hash->elf.other
12390 : sym->st_other);
12391 }
12392
12393 code_sec = sym_sec;
12394 code_value = sym_value;
12395 opd = get_opd_info (sym_sec);
12396 if (opd != NULL)
12397 {
12398 bfd_vma dest;
12399
12400 if (hash == NULL && opd->adjust != NULL)
12401 {
12402 long adjust = opd->adjust[OPD_NDX (sym_value)];
12403 if (adjust == -1)
12404 continue;
12405 code_value += adjust;
12406 sym_value += adjust;
12407 }
12408 dest = opd_entry_value (sym_sec, sym_value,
12409 &code_sec, &code_value, FALSE);
12410 if (dest != (bfd_vma) -1)
12411 {
12412 destination = dest;
12413 if (fdh != NULL)
12414 {
12415 /* Fixup old ABI sym to point at code
12416 entry. */
12417 hash->elf.root.type = bfd_link_hash_defweak;
12418 hash->elf.root.u.def.section = code_sec;
12419 hash->elf.root.u.def.value = code_value;
12420 }
12421 }
12422 }
12423
12424 /* Determine what (if any) linker stub is needed. */
12425 plt_ent = NULL;
12426 stub_type = ppc_type_of_stub (section, irela, &hash,
12427 &plt_ent, destination,
12428 local_off);
12429
12430 if (stub_type != ppc_stub_plt_call)
12431 {
12432 /* Check whether we need a TOC adjusting stub.
12433 Since the linker pastes together pieces from
12434 different object files when creating the
12435 _init and _fini functions, it may be that a
12436 call to what looks like a local sym is in
12437 fact a call needing a TOC adjustment. */
12438 if (code_sec != NULL
12439 && code_sec->output_section != NULL
12440 && (htab->sec_info[code_sec->id].toc_off
12441 != htab->sec_info[section->id].toc_off)
12442 && (code_sec->has_toc_reloc
12443 || code_sec->makes_toc_func_call))
12444 stub_type = ppc_stub_long_branch_r2off;
12445 }
12446
12447 if (stub_type == ppc_stub_none)
12448 continue;
12449
12450 /* __tls_get_addr calls might be eliminated. */
12451 if (stub_type != ppc_stub_plt_call
12452 && hash != NULL
12453 && (hash == htab->tls_get_addr
12454 || hash == htab->tls_get_addr_fd)
12455 && section->has_tls_reloc
12456 && irela != internal_relocs)
12457 {
12458 /* Get tls info. */
12459 unsigned char *tls_mask;
12460
12461 if (!get_tls_mask (&tls_mask, NULL, NULL, &local_syms,
12462 irela - 1, input_bfd))
12463 goto error_ret_free_internal;
12464 if (*tls_mask != 0)
12465 continue;
12466 }
12467
12468 if (stub_type == ppc_stub_plt_call
12469 && irela + 1 < irelaend
12470 && irela[1].r_offset == irela->r_offset + 4
12471 && ELF64_R_TYPE (irela[1].r_info) == R_PPC64_TOCSAVE)
12472 {
12473 if (!tocsave_find (htab, INSERT,
12474 &local_syms, irela + 1, input_bfd))
12475 goto error_ret_free_internal;
12476 }
12477 else if (stub_type == ppc_stub_plt_call)
12478 stub_type = ppc_stub_plt_call_r2save;
12479
12480 /* Support for grouping stub sections. */
12481 id_sec = htab->sec_info[section->id].u.group->link_sec;
12482
12483 /* Get the name of this stub. */
12484 stub_name = ppc_stub_name (id_sec, sym_sec, hash, irela);
12485 if (!stub_name)
12486 goto error_ret_free_internal;
12487
12488 stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
12489 stub_name, FALSE, FALSE);
12490 if (stub_entry != NULL)
12491 {
12492 /* The proper stub has already been created. */
12493 free (stub_name);
12494 if (stub_type == ppc_stub_plt_call_r2save)
12495 stub_entry->stub_type = stub_type;
12496 continue;
12497 }
12498
12499 stub_entry = ppc_add_stub (stub_name, section, info);
12500 if (stub_entry == NULL)
12501 {
12502 free (stub_name);
12503 error_ret_free_internal:
12504 if (elf_section_data (section)->relocs == NULL)
12505 free (internal_relocs);
12506 error_ret_free_local:
12507 if (local_syms != NULL
12508 && (symtab_hdr->contents
12509 != (unsigned char *) local_syms))
12510 free (local_syms);
12511 return FALSE;
12512 }
12513
12514 stub_entry->stub_type = stub_type;
12515 if (stub_type != ppc_stub_plt_call
12516 && stub_type != ppc_stub_plt_call_r2save)
12517 {
12518 stub_entry->target_value = code_value;
12519 stub_entry->target_section = code_sec;
12520 }
12521 else
12522 {
12523 stub_entry->target_value = sym_value;
12524 stub_entry->target_section = sym_sec;
12525 }
12526 stub_entry->h = hash;
12527 stub_entry->plt_ent = plt_ent;
12528 stub_entry->other = hash ? hash->elf.other : sym->st_other;
12529
12530 if (stub_entry->h != NULL)
12531 htab->stub_globals += 1;
12532 }
12533
12534 /* We're done with the internal relocs, free them. */
12535 if (elf_section_data (section)->relocs != internal_relocs)
12536 free (internal_relocs);
12537 }
12538
12539 if (local_syms != NULL
12540 && symtab_hdr->contents != (unsigned char *) local_syms)
12541 {
12542 if (!info->keep_memory)
12543 free (local_syms);
12544 else
12545 symtab_hdr->contents = (unsigned char *) local_syms;
12546 }
12547 }
12548
12549 /* We may have added some stubs. Find out the new size of the
12550 stub sections. */
12551 for (stub_sec = htab->params->stub_bfd->sections;
12552 stub_sec != NULL;
12553 stub_sec = stub_sec->next)
12554 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12555 {
12556 if (htab->stub_iteration <= STUB_SHRINK_ITER
12557 || stub_sec->rawsize < stub_sec->size)
12558 /* Past STUB_SHRINK_ITER, rawsize is the max size seen. */
12559 stub_sec->rawsize = stub_sec->size;
12560 stub_sec->size = 0;
12561 stub_sec->reloc_count = 0;
12562 stub_sec->flags &= ~SEC_RELOC;
12563 }
12564
12565 htab->brlt->size = 0;
12566 htab->brlt->reloc_count = 0;
12567 htab->brlt->flags &= ~SEC_RELOC;
12568 if (htab->relbrlt != NULL)
12569 htab->relbrlt->size = 0;
12570
12571 bfd_hash_traverse (&htab->stub_hash_table, ppc_size_one_stub, info);
12572
12573 for (group = htab->group; group != NULL; group = group->next)
12574 if (group->needs_save_res)
12575 group->stub_sec->size += htab->sfpr->size;
12576
12577 if (info->emitrelocations
12578 && htab->glink != NULL && htab->glink->size != 0)
12579 {
12580 htab->glink->reloc_count = 1;
12581 htab->glink->flags |= SEC_RELOC;
12582 }
12583
12584 if (htab->glink_eh_frame != NULL
12585 && !bfd_is_abs_section (htab->glink_eh_frame->output_section)
12586 && htab->glink_eh_frame->output_section->size != 0)
12587 {
12588 size_t size = 0, align;
12589
12590 for (stub_sec = htab->params->stub_bfd->sections;
12591 stub_sec != NULL;
12592 stub_sec = stub_sec->next)
12593 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12594 size += 24;
12595 if (htab->glink != NULL && htab->glink->size != 0)
12596 size += 24;
12597 if (size != 0)
12598 size += sizeof (glink_eh_frame_cie);
12599 align = 1;
12600 align <<= htab->glink_eh_frame->output_section->alignment_power;
12601 align -= 1;
12602 size = (size + align) & ~align;
12603 htab->glink_eh_frame->rawsize = htab->glink_eh_frame->size;
12604 htab->glink_eh_frame->size = size;
12605 }
12606
12607 if (htab->params->plt_stub_align != 0)
12608 for (stub_sec = htab->params->stub_bfd->sections;
12609 stub_sec != NULL;
12610 stub_sec = stub_sec->next)
12611 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12612 stub_sec->size = ((stub_sec->size
12613 + (1 << htab->params->plt_stub_align) - 1)
12614 & -(1 << htab->params->plt_stub_align));
12615
12616 for (stub_sec = htab->params->stub_bfd->sections;
12617 stub_sec != NULL;
12618 stub_sec = stub_sec->next)
12619 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
12620 && stub_sec->rawsize != stub_sec->size
12621 && (htab->stub_iteration <= STUB_SHRINK_ITER
12622 || stub_sec->rawsize < stub_sec->size))
12623 break;
12624
12625 if (stub_sec == NULL
12626 && (htab->glink_eh_frame == NULL
12627 || htab->glink_eh_frame->rawsize == htab->glink_eh_frame->size))
12628 break;
12629
12630 /* Ask the linker to do its stuff. */
12631 (*htab->params->layout_sections_again) ();
12632 }
12633
12634 if (htab->glink_eh_frame != NULL
12635 && htab->glink_eh_frame->size != 0)
12636 {
12637 bfd_vma val;
12638 bfd_byte *p, *last_fde;
12639 size_t last_fde_len, size, align, pad;
12640 asection *stub_sec;
12641
12642 p = bfd_zalloc (htab->glink_eh_frame->owner, htab->glink_eh_frame->size);
12643 if (p == NULL)
12644 return FALSE;
12645 htab->glink_eh_frame->contents = p;
12646 last_fde = p;
12647
12648 memcpy (p, glink_eh_frame_cie, sizeof (glink_eh_frame_cie));
12649 /* CIE length (rewrite in case little-endian). */
12650 last_fde_len = sizeof (glink_eh_frame_cie) - 4;
12651 bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
12652 p += sizeof (glink_eh_frame_cie);
12653
12654 for (stub_sec = htab->params->stub_bfd->sections;
12655 stub_sec != NULL;
12656 stub_sec = stub_sec->next)
12657 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12658 {
12659 last_fde = p;
12660 last_fde_len = 20;
12661 /* FDE length. */
12662 bfd_put_32 (htab->elf.dynobj, 20, p);
12663 p += 4;
12664 /* CIE pointer. */
12665 val = p - htab->glink_eh_frame->contents;
12666 bfd_put_32 (htab->elf.dynobj, val, p);
12667 p += 4;
12668 /* Offset to stub section, written later. */
12669 p += 4;
12670 /* stub section size. */
12671 bfd_put_32 (htab->elf.dynobj, stub_sec->size, p);
12672 p += 4;
12673 /* Augmentation. */
12674 p += 1;
12675 /* Pad. */
12676 p += 7;
12677 }
12678 if (htab->glink != NULL && htab->glink->size != 0)
12679 {
12680 last_fde = p;
12681 last_fde_len = 20;
12682 /* FDE length. */
12683 bfd_put_32 (htab->elf.dynobj, 20, p);
12684 p += 4;
12685 /* CIE pointer. */
12686 val = p - htab->glink_eh_frame->contents;
12687 bfd_put_32 (htab->elf.dynobj, val, p);
12688 p += 4;
12689 /* Offset to .glink, written later. */
12690 p += 4;
12691 /* .glink size. */
12692 bfd_put_32 (htab->elf.dynobj, htab->glink->size - 8, p);
12693 p += 4;
12694 /* Augmentation. */
12695 p += 1;
12696
12697 *p++ = DW_CFA_advance_loc + 1;
12698 *p++ = DW_CFA_register;
12699 *p++ = 65;
12700 *p++ = htab->opd_abi ? 12 : 0;
12701 *p++ = DW_CFA_advance_loc + 4;
12702 *p++ = DW_CFA_restore_extended;
12703 *p++ = 65;
12704 }
12705 /* Subsume any padding into the last FDE if user .eh_frame
12706 sections are aligned more than glink_eh_frame. Otherwise any
12707 zero padding will be seen as a terminator. */
12708 size = p - htab->glink_eh_frame->contents;
12709 align = 1;
12710 align <<= htab->glink_eh_frame->output_section->alignment_power;
12711 align -= 1;
12712 pad = ((size + align) & ~align) - size;
12713 htab->glink_eh_frame->size = size + pad;
12714 bfd_put_32 (htab->elf.dynobj, last_fde_len + pad, last_fde);
12715 }
12716
12717 maybe_strip_output (info, htab->brlt);
12718 if (htab->glink_eh_frame != NULL)
12719 maybe_strip_output (info, htab->glink_eh_frame);
12720
12721 return TRUE;
12722 }
12723
12724 /* Called after we have determined section placement. If sections
12725 move, we'll be called again. Provide a value for TOCstart. */
12726
12727 bfd_vma
ppc64_elf_set_toc(struct bfd_link_info * info,bfd * obfd)12728 ppc64_elf_set_toc (struct bfd_link_info *info, bfd *obfd)
12729 {
12730 asection *s;
12731 bfd_vma TOCstart, adjust;
12732
12733 if (info != NULL)
12734 {
12735 struct elf_link_hash_entry *h;
12736 struct elf_link_hash_table *htab = elf_hash_table (info);
12737
12738 if (is_elf_hash_table (htab)
12739 && htab->hgot != NULL)
12740 h = htab->hgot;
12741 else
12742 {
12743 h = elf_link_hash_lookup (htab, ".TOC.", FALSE, FALSE, TRUE);
12744 if (is_elf_hash_table (htab))
12745 htab->hgot = h;
12746 }
12747 if (h != NULL
12748 && h->root.type == bfd_link_hash_defined
12749 && !h->root.linker_def
12750 && (!is_elf_hash_table (htab)
12751 || h->def_regular))
12752 {
12753 TOCstart = (h->root.u.def.value - TOC_BASE_OFF
12754 + h->root.u.def.section->output_offset
12755 + h->root.u.def.section->output_section->vma);
12756 _bfd_set_gp_value (obfd, TOCstart);
12757 return TOCstart;
12758 }
12759 }
12760
12761 /* The TOC consists of sections .got, .toc, .tocbss, .plt in that
12762 order. The TOC starts where the first of these sections starts. */
12763 s = bfd_get_section_by_name (obfd, ".got");
12764 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12765 s = bfd_get_section_by_name (obfd, ".toc");
12766 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12767 s = bfd_get_section_by_name (obfd, ".tocbss");
12768 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12769 s = bfd_get_section_by_name (obfd, ".plt");
12770 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12771 {
12772 /* This may happen for
12773 o references to TOC base (SYM@toc / TOC[tc0]) without a
12774 .toc directive
12775 o bad linker script
12776 o --gc-sections and empty TOC sections
12777
12778 FIXME: Warn user? */
12779
12780 /* Look for a likely section. We probably won't even be
12781 using TOCstart. */
12782 for (s = obfd->sections; s != NULL; s = s->next)
12783 if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_READONLY
12784 | SEC_EXCLUDE))
12785 == (SEC_ALLOC | SEC_SMALL_DATA))
12786 break;
12787 if (s == NULL)
12788 for (s = obfd->sections; s != NULL; s = s->next)
12789 if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_EXCLUDE))
12790 == (SEC_ALLOC | SEC_SMALL_DATA))
12791 break;
12792 if (s == NULL)
12793 for (s = obfd->sections; s != NULL; s = s->next)
12794 if ((s->flags & (SEC_ALLOC | SEC_READONLY | SEC_EXCLUDE))
12795 == SEC_ALLOC)
12796 break;
12797 if (s == NULL)
12798 for (s = obfd->sections; s != NULL; s = s->next)
12799 if ((s->flags & (SEC_ALLOC | SEC_EXCLUDE)) == SEC_ALLOC)
12800 break;
12801 }
12802
12803 TOCstart = 0;
12804 if (s != NULL)
12805 TOCstart = s->output_section->vma + s->output_offset;
12806
12807 /* Force alignment. */
12808 adjust = TOCstart & (TOC_BASE_ALIGN - 1);
12809 TOCstart -= adjust;
12810 _bfd_set_gp_value (obfd, TOCstart);
12811
12812 if (info != NULL && s != NULL)
12813 {
12814 struct ppc_link_hash_table *htab = ppc_hash_table (info);
12815
12816 if (htab != NULL)
12817 {
12818 if (htab->elf.hgot != NULL)
12819 {
12820 htab->elf.hgot->root.u.def.value = TOC_BASE_OFF - adjust;
12821 htab->elf.hgot->root.u.def.section = s;
12822 }
12823 }
12824 else
12825 {
12826 struct bfd_link_hash_entry *bh = NULL;
12827 _bfd_generic_link_add_one_symbol (info, obfd, ".TOC.", BSF_GLOBAL,
12828 s, TOC_BASE_OFF - adjust,
12829 NULL, FALSE, FALSE, &bh);
12830 }
12831 }
12832 return TOCstart;
12833 }
12834
12835 /* Called via elf_link_hash_traverse from ppc64_elf_build_stubs to
12836 write out any global entry stubs. */
12837
12838 static bfd_boolean
build_global_entry_stubs(struct elf_link_hash_entry * h,void * inf)12839 build_global_entry_stubs (struct elf_link_hash_entry *h, void *inf)
12840 {
12841 struct bfd_link_info *info;
12842 struct ppc_link_hash_table *htab;
12843 struct plt_entry *pent;
12844 asection *s;
12845
12846 if (h->root.type == bfd_link_hash_indirect)
12847 return TRUE;
12848
12849 if (!h->pointer_equality_needed)
12850 return TRUE;
12851
12852 if (h->def_regular)
12853 return TRUE;
12854
12855 info = inf;
12856 htab = ppc_hash_table (info);
12857 if (htab == NULL)
12858 return FALSE;
12859
12860 s = htab->glink;
12861 for (pent = h->plt.plist; pent != NULL; pent = pent->next)
12862 if (pent->plt.offset != (bfd_vma) -1
12863 && pent->addend == 0)
12864 {
12865 bfd_byte *p;
12866 asection *plt;
12867 bfd_vma off;
12868
12869 p = s->contents + h->root.u.def.value;
12870 plt = htab->elf.splt;
12871 if (!htab->elf.dynamic_sections_created
12872 || h->dynindx == -1)
12873 plt = htab->elf.iplt;
12874 off = pent->plt.offset + plt->output_offset + plt->output_section->vma;
12875 off -= h->root.u.def.value + s->output_offset + s->output_section->vma;
12876
12877 if (off + 0x80008000 > 0xffffffff || (off & 3) != 0)
12878 {
12879 info->callbacks->einfo
12880 (_("%P: linkage table error against `%T'\n"),
12881 h->root.root.string);
12882 bfd_set_error (bfd_error_bad_value);
12883 htab->stub_error = TRUE;
12884 }
12885
12886 htab->stub_count[ppc_stub_global_entry - 1] += 1;
12887 if (htab->params->emit_stub_syms)
12888 {
12889 size_t len = strlen (h->root.root.string);
12890 char *name = bfd_malloc (sizeof "12345678.global_entry." + len);
12891
12892 if (name == NULL)
12893 return FALSE;
12894
12895 sprintf (name, "%08x.global_entry.%s", s->id, h->root.root.string);
12896 h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
12897 if (h == NULL)
12898 return FALSE;
12899 if (h->root.type == bfd_link_hash_new)
12900 {
12901 h->root.type = bfd_link_hash_defined;
12902 h->root.u.def.section = s;
12903 h->root.u.def.value = p - s->contents;
12904 h->ref_regular = 1;
12905 h->def_regular = 1;
12906 h->ref_regular_nonweak = 1;
12907 h->forced_local = 1;
12908 h->non_elf = 0;
12909 h->root.linker_def = 1;
12910 }
12911 }
12912
12913 if (PPC_HA (off) != 0)
12914 {
12915 bfd_put_32 (s->owner, ADDIS_R12_R12 | PPC_HA (off), p);
12916 p += 4;
12917 }
12918 bfd_put_32 (s->owner, LD_R12_0R12 | PPC_LO (off), p);
12919 p += 4;
12920 bfd_put_32 (s->owner, MTCTR_R12, p);
12921 p += 4;
12922 bfd_put_32 (s->owner, BCTR, p);
12923 break;
12924 }
12925 return TRUE;
12926 }
12927
12928 /* Build all the stubs associated with the current output file.
12929 The stubs are kept in a hash table attached to the main linker
12930 hash table. This function is called via gldelf64ppc_finish. */
12931
12932 bfd_boolean
ppc64_elf_build_stubs(struct bfd_link_info * info,char ** stats)12933 ppc64_elf_build_stubs (struct bfd_link_info *info,
12934 char **stats)
12935 {
12936 struct ppc_link_hash_table *htab = ppc_hash_table (info);
12937 struct map_stub *group;
12938 asection *stub_sec;
12939 bfd_byte *p;
12940 int stub_sec_count = 0;
12941
12942 if (htab == NULL)
12943 return FALSE;
12944
12945 /* Allocate memory to hold the linker stubs. */
12946 for (stub_sec = htab->params->stub_bfd->sections;
12947 stub_sec != NULL;
12948 stub_sec = stub_sec->next)
12949 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
12950 && stub_sec->size != 0)
12951 {
12952 stub_sec->contents = bfd_zalloc (htab->params->stub_bfd, stub_sec->size);
12953 if (stub_sec->contents == NULL)
12954 return FALSE;
12955 stub_sec->size = 0;
12956 }
12957
12958 if (htab->glink != NULL && htab->glink->size != 0)
12959 {
12960 unsigned int indx;
12961 bfd_vma plt0;
12962
12963 /* Build the .glink plt call stub. */
12964 if (htab->params->emit_stub_syms)
12965 {
12966 struct elf_link_hash_entry *h;
12967 h = elf_link_hash_lookup (&htab->elf, "__glink_PLTresolve",
12968 TRUE, FALSE, FALSE);
12969 if (h == NULL)
12970 return FALSE;
12971 if (h->root.type == bfd_link_hash_new)
12972 {
12973 h->root.type = bfd_link_hash_defined;
12974 h->root.u.def.section = htab->glink;
12975 h->root.u.def.value = 8;
12976 h->ref_regular = 1;
12977 h->def_regular = 1;
12978 h->ref_regular_nonweak = 1;
12979 h->forced_local = 1;
12980 h->non_elf = 0;
12981 h->root.linker_def = 1;
12982 }
12983 }
12984 plt0 = (htab->elf.splt->output_section->vma
12985 + htab->elf.splt->output_offset
12986 - 16);
12987 if (info->emitrelocations)
12988 {
12989 Elf_Internal_Rela *r = get_relocs (htab->glink, 1);
12990 if (r == NULL)
12991 return FALSE;
12992 r->r_offset = (htab->glink->output_offset
12993 + htab->glink->output_section->vma);
12994 r->r_info = ELF64_R_INFO (0, R_PPC64_REL64);
12995 r->r_addend = plt0;
12996 }
12997 p = htab->glink->contents;
12998 plt0 -= htab->glink->output_section->vma + htab->glink->output_offset;
12999 bfd_put_64 (htab->glink->owner, plt0, p);
13000 p += 8;
13001 if (htab->opd_abi)
13002 {
13003 bfd_put_32 (htab->glink->owner, MFLR_R12, p);
13004 p += 4;
13005 bfd_put_32 (htab->glink->owner, BCL_20_31, p);
13006 p += 4;
13007 bfd_put_32 (htab->glink->owner, MFLR_R11, p);
13008 p += 4;
13009 bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
13010 p += 4;
13011 bfd_put_32 (htab->glink->owner, MTLR_R12, p);
13012 p += 4;
13013 bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
13014 p += 4;
13015 bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
13016 p += 4;
13017 bfd_put_32 (htab->glink->owner, LD_R2_0R11 | 8, p);
13018 p += 4;
13019 bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
13020 p += 4;
13021 bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 16, p);
13022 p += 4;
13023 }
13024 else
13025 {
13026 bfd_put_32 (htab->glink->owner, MFLR_R0, p);
13027 p += 4;
13028 bfd_put_32 (htab->glink->owner, BCL_20_31, p);
13029 p += 4;
13030 bfd_put_32 (htab->glink->owner, MFLR_R11, p);
13031 p += 4;
13032 bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
13033 p += 4;
13034 bfd_put_32 (htab->glink->owner, MTLR_R0, p);
13035 p += 4;
13036 bfd_put_32 (htab->glink->owner, SUB_R12_R12_R11, p);
13037 p += 4;
13038 bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
13039 p += 4;
13040 bfd_put_32 (htab->glink->owner, ADDI_R0_R12 | (-48 & 0xffff), p);
13041 p += 4;
13042 bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
13043 p += 4;
13044 bfd_put_32 (htab->glink->owner, SRDI_R0_R0_2, p);
13045 p += 4;
13046 bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
13047 p += 4;
13048 bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 8, p);
13049 p += 4;
13050 }
13051 bfd_put_32 (htab->glink->owner, BCTR, p);
13052 p += 4;
13053 while (p - htab->glink->contents < GLINK_CALL_STUB_SIZE)
13054 {
13055 bfd_put_32 (htab->glink->owner, NOP, p);
13056 p += 4;
13057 }
13058
13059 /* Build the .glink lazy link call stubs. */
13060 indx = 0;
13061 while (p < htab->glink->contents + htab->glink->rawsize)
13062 {
13063 if (htab->opd_abi)
13064 {
13065 if (indx < 0x8000)
13066 {
13067 bfd_put_32 (htab->glink->owner, LI_R0_0 | indx, p);
13068 p += 4;
13069 }
13070 else
13071 {
13072 bfd_put_32 (htab->glink->owner, LIS_R0_0 | PPC_HI (indx), p);
13073 p += 4;
13074 bfd_put_32 (htab->glink->owner, ORI_R0_R0_0 | PPC_LO (indx),
13075 p);
13076 p += 4;
13077 }
13078 }
13079 bfd_put_32 (htab->glink->owner,
13080 B_DOT | ((htab->glink->contents - p + 8) & 0x3fffffc), p);
13081 indx++;
13082 p += 4;
13083 }
13084
13085 /* Build .glink global entry stubs. */
13086 if (htab->glink->size > htab->glink->rawsize)
13087 elf_link_hash_traverse (&htab->elf, build_global_entry_stubs, info);
13088 }
13089
13090 if (htab->brlt != NULL && htab->brlt->size != 0)
13091 {
13092 htab->brlt->contents = bfd_zalloc (htab->brlt->owner,
13093 htab->brlt->size);
13094 if (htab->brlt->contents == NULL)
13095 return FALSE;
13096 }
13097 if (htab->relbrlt != NULL && htab->relbrlt->size != 0)
13098 {
13099 htab->relbrlt->contents = bfd_zalloc (htab->relbrlt->owner,
13100 htab->relbrlt->size);
13101 if (htab->relbrlt->contents == NULL)
13102 return FALSE;
13103 }
13104
13105 /* Build the stubs as directed by the stub hash table. */
13106 bfd_hash_traverse (&htab->stub_hash_table, ppc_build_one_stub, info);
13107
13108 for (group = htab->group; group != NULL; group = group->next)
13109 if (group->needs_save_res)
13110 {
13111 stub_sec = group->stub_sec;
13112 memcpy (stub_sec->contents + stub_sec->size, htab->sfpr->contents,
13113 htab->sfpr->size);
13114 if (htab->params->emit_stub_syms)
13115 {
13116 unsigned int i;
13117
13118 for (i = 0; i < ARRAY_SIZE (save_res_funcs); i++)
13119 if (!sfpr_define (info, &save_res_funcs[i], stub_sec))
13120 return FALSE;
13121 }
13122 stub_sec->size += htab->sfpr->size;
13123 }
13124
13125 if (htab->relbrlt != NULL)
13126 htab->relbrlt->reloc_count = 0;
13127
13128 if (htab->params->plt_stub_align != 0)
13129 for (stub_sec = htab->params->stub_bfd->sections;
13130 stub_sec != NULL;
13131 stub_sec = stub_sec->next)
13132 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
13133 stub_sec->size = ((stub_sec->size
13134 + (1 << htab->params->plt_stub_align) - 1)
13135 & -(1 << htab->params->plt_stub_align));
13136
13137 for (stub_sec = htab->params->stub_bfd->sections;
13138 stub_sec != NULL;
13139 stub_sec = stub_sec->next)
13140 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
13141 {
13142 stub_sec_count += 1;
13143 if (stub_sec->rawsize != stub_sec->size
13144 && (htab->stub_iteration <= STUB_SHRINK_ITER
13145 || stub_sec->rawsize < stub_sec->size))
13146 break;
13147 }
13148
13149 /* Note that the glink_eh_frame check here is not only testing that
13150 the generated size matched the calculated size but also that
13151 bfd_elf_discard_info didn't make any changes to the section. */
13152 if (stub_sec != NULL
13153 || (htab->glink_eh_frame != NULL
13154 && htab->glink_eh_frame->rawsize != htab->glink_eh_frame->size))
13155 {
13156 htab->stub_error = TRUE;
13157 info->callbacks->einfo (_("%P: stubs don't match calculated size\n"));
13158 }
13159
13160 if (htab->stub_error)
13161 return FALSE;
13162
13163 if (stats != NULL)
13164 {
13165 *stats = bfd_malloc (500);
13166 if (*stats == NULL)
13167 return FALSE;
13168
13169 sprintf (*stats, _("linker stubs in %u group%s\n"
13170 " branch %lu\n"
13171 " toc adjust %lu\n"
13172 " long branch %lu\n"
13173 " long toc adj %lu\n"
13174 " plt call %lu\n"
13175 " plt call toc %lu\n"
13176 " global entry %lu"),
13177 stub_sec_count,
13178 stub_sec_count == 1 ? "" : "s",
13179 htab->stub_count[ppc_stub_long_branch - 1],
13180 htab->stub_count[ppc_stub_long_branch_r2off - 1],
13181 htab->stub_count[ppc_stub_plt_branch - 1],
13182 htab->stub_count[ppc_stub_plt_branch_r2off - 1],
13183 htab->stub_count[ppc_stub_plt_call - 1],
13184 htab->stub_count[ppc_stub_plt_call_r2save - 1],
13185 htab->stub_count[ppc_stub_global_entry - 1]);
13186 }
13187 return TRUE;
13188 }
13189
13190 /* This function undoes the changes made by add_symbol_adjust. */
13191
13192 static bfd_boolean
undo_symbol_twiddle(struct elf_link_hash_entry * h,void * inf ATTRIBUTE_UNUSED)13193 undo_symbol_twiddle (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
13194 {
13195 struct ppc_link_hash_entry *eh;
13196
13197 if (h->root.type == bfd_link_hash_indirect)
13198 return TRUE;
13199
13200 eh = (struct ppc_link_hash_entry *) h;
13201 if (eh->elf.root.type != bfd_link_hash_undefweak || !eh->was_undefined)
13202 return TRUE;
13203
13204 eh->elf.root.type = bfd_link_hash_undefined;
13205 return TRUE;
13206 }
13207
13208 void
ppc64_elf_restore_symbols(struct bfd_link_info * info)13209 ppc64_elf_restore_symbols (struct bfd_link_info *info)
13210 {
13211 struct ppc_link_hash_table *htab = ppc_hash_table (info);
13212
13213 if (htab != NULL)
13214 elf_link_hash_traverse (&htab->elf, undo_symbol_twiddle, info);
13215 }
13216
13217 /* What to do when ld finds relocations against symbols defined in
13218 discarded sections. */
13219
13220 static unsigned int
ppc64_elf_action_discarded(asection * sec)13221 ppc64_elf_action_discarded (asection *sec)
13222 {
13223 if (strcmp (".opd", sec->name) == 0)
13224 return 0;
13225
13226 if (strcmp (".toc", sec->name) == 0)
13227 return 0;
13228
13229 if (strcmp (".toc1", sec->name) == 0)
13230 return 0;
13231
13232 return _bfd_elf_default_action_discarded (sec);
13233 }
13234
13235 /* The RELOCATE_SECTION function is called by the ELF backend linker
13236 to handle the relocations for a section.
13237
13238 The relocs are always passed as Rela structures; if the section
13239 actually uses Rel structures, the r_addend field will always be
13240 zero.
13241
13242 This function is responsible for adjust the section contents as
13243 necessary, and (if using Rela relocs and generating a
13244 relocatable output file) adjusting the reloc addend as
13245 necessary.
13246
13247 This function does not have to worry about setting the reloc
13248 address or the reloc symbol index.
13249
13250 LOCAL_SYMS is a pointer to the swapped in local symbols.
13251
13252 LOCAL_SECTIONS is an array giving the section in the input file
13253 corresponding to the st_shndx field of each local symbol.
13254
13255 The global hash table entry for the global symbols can be found
13256 via elf_sym_hashes (input_bfd).
13257
13258 When generating relocatable output, this function must handle
13259 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
13260 going to be the section symbol corresponding to the output
13261 section, which means that the addend must be adjusted
13262 accordingly. */
13263
13264 static bfd_boolean
ppc64_elf_relocate_section(bfd * output_bfd,struct bfd_link_info * info,bfd * input_bfd,asection * input_section,bfd_byte * contents,Elf_Internal_Rela * relocs,Elf_Internal_Sym * local_syms,asection ** local_sections)13265 ppc64_elf_relocate_section (bfd *output_bfd,
13266 struct bfd_link_info *info,
13267 bfd *input_bfd,
13268 asection *input_section,
13269 bfd_byte *contents,
13270 Elf_Internal_Rela *relocs,
13271 Elf_Internal_Sym *local_syms,
13272 asection **local_sections)
13273 {
13274 struct ppc_link_hash_table *htab;
13275 Elf_Internal_Shdr *symtab_hdr;
13276 struct elf_link_hash_entry **sym_hashes;
13277 Elf_Internal_Rela *rel;
13278 Elf_Internal_Rela *wrel;
13279 Elf_Internal_Rela *relend;
13280 Elf_Internal_Rela outrel;
13281 bfd_byte *loc;
13282 struct got_entry **local_got_ents;
13283 bfd_vma TOCstart;
13284 bfd_boolean ret = TRUE;
13285 bfd_boolean is_opd;
13286 /* Assume 'at' branch hints. */
13287 bfd_boolean is_isa_v2 = TRUE;
13288 bfd_vma d_offset = (bfd_big_endian (output_bfd) ? 2 : 0);
13289
13290 /* Initialize howto table if needed. */
13291 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
13292 ppc_howto_init ();
13293
13294 htab = ppc_hash_table (info);
13295 if (htab == NULL)
13296 return FALSE;
13297
13298 /* Don't relocate stub sections. */
13299 if (input_section->owner == htab->params->stub_bfd)
13300 return TRUE;
13301
13302 BFD_ASSERT (is_ppc64_elf (input_bfd));
13303
13304 local_got_ents = elf_local_got_ents (input_bfd);
13305 TOCstart = elf_gp (output_bfd);
13306 symtab_hdr = &elf_symtab_hdr (input_bfd);
13307 sym_hashes = elf_sym_hashes (input_bfd);
13308 is_opd = ppc64_elf_section_data (input_section)->sec_type == sec_opd;
13309
13310 rel = wrel = relocs;
13311 relend = relocs + input_section->reloc_count;
13312 for (; rel < relend; wrel++, rel++)
13313 {
13314 enum elf_ppc64_reloc_type r_type;
13315 bfd_vma addend;
13316 bfd_reloc_status_type r;
13317 Elf_Internal_Sym *sym;
13318 asection *sec;
13319 struct elf_link_hash_entry *h_elf;
13320 struct ppc_link_hash_entry *h;
13321 struct ppc_link_hash_entry *fdh;
13322 const char *sym_name;
13323 unsigned long r_symndx, toc_symndx;
13324 bfd_vma toc_addend;
13325 unsigned char tls_mask, tls_gd, tls_type;
13326 unsigned char sym_type;
13327 bfd_vma relocation;
13328 bfd_boolean unresolved_reloc;
13329 bfd_boolean warned;
13330 enum { DEST_NORMAL, DEST_OPD, DEST_STUB } reloc_dest;
13331 unsigned int insn;
13332 unsigned int mask;
13333 struct ppc_stub_hash_entry *stub_entry;
13334 bfd_vma max_br_offset;
13335 bfd_vma from;
13336 Elf_Internal_Rela orig_rel;
13337 reloc_howto_type *howto;
13338 struct reloc_howto_struct alt_howto;
13339
13340 again:
13341 orig_rel = *rel;
13342
13343 r_type = ELF64_R_TYPE (rel->r_info);
13344 r_symndx = ELF64_R_SYM (rel->r_info);
13345
13346 /* For old style R_PPC64_TOC relocs with a zero symbol, use the
13347 symbol of the previous ADDR64 reloc. The symbol gives us the
13348 proper TOC base to use. */
13349 if (rel->r_info == ELF64_R_INFO (0, R_PPC64_TOC)
13350 && wrel != relocs
13351 && ELF64_R_TYPE (wrel[-1].r_info) == R_PPC64_ADDR64
13352 && is_opd)
13353 r_symndx = ELF64_R_SYM (wrel[-1].r_info);
13354
13355 sym = NULL;
13356 sec = NULL;
13357 h_elf = NULL;
13358 sym_name = NULL;
13359 unresolved_reloc = FALSE;
13360 warned = FALSE;
13361
13362 if (r_symndx < symtab_hdr->sh_info)
13363 {
13364 /* It's a local symbol. */
13365 struct _opd_sec_data *opd;
13366
13367 sym = local_syms + r_symndx;
13368 sec = local_sections[r_symndx];
13369 sym_name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym, sec);
13370 sym_type = ELF64_ST_TYPE (sym->st_info);
13371 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
13372 opd = get_opd_info (sec);
13373 if (opd != NULL && opd->adjust != NULL)
13374 {
13375 long adjust = opd->adjust[OPD_NDX (sym->st_value
13376 + rel->r_addend)];
13377 if (adjust == -1)
13378 relocation = 0;
13379 else
13380 {
13381 /* If this is a relocation against the opd section sym
13382 and we have edited .opd, adjust the reloc addend so
13383 that ld -r and ld --emit-relocs output is correct.
13384 If it is a reloc against some other .opd symbol,
13385 then the symbol value will be adjusted later. */
13386 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
13387 rel->r_addend += adjust;
13388 else
13389 relocation += adjust;
13390 }
13391 }
13392 }
13393 else
13394 {
13395 bfd_boolean ignored;
13396
13397 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
13398 r_symndx, symtab_hdr, sym_hashes,
13399 h_elf, sec, relocation,
13400 unresolved_reloc, warned, ignored);
13401 sym_name = h_elf->root.root.string;
13402 sym_type = h_elf->type;
13403 if (sec != NULL
13404 && sec->owner == output_bfd
13405 && strcmp (sec->name, ".opd") == 0)
13406 {
13407 /* This is a symbol defined in a linker script. All
13408 such are defined in output sections, even those
13409 defined by simple assignment from a symbol defined in
13410 an input section. Transfer the symbol to an
13411 appropriate input .opd section, so that a branch to
13412 this symbol will be mapped to the location specified
13413 by the opd entry. */
13414 struct bfd_link_order *lo;
13415 for (lo = sec->map_head.link_order; lo != NULL; lo = lo->next)
13416 if (lo->type == bfd_indirect_link_order)
13417 {
13418 asection *isec = lo->u.indirect.section;
13419 if (h_elf->root.u.def.value >= isec->output_offset
13420 && h_elf->root.u.def.value < (isec->output_offset
13421 + isec->size))
13422 {
13423 h_elf->root.u.def.value -= isec->output_offset;
13424 h_elf->root.u.def.section = isec;
13425 sec = isec;
13426 break;
13427 }
13428 }
13429 }
13430 }
13431 h = (struct ppc_link_hash_entry *) h_elf;
13432
13433 if (sec != NULL && discarded_section (sec))
13434 {
13435 _bfd_clear_contents (ppc64_elf_howto_table[r_type],
13436 input_bfd, input_section,
13437 contents + rel->r_offset);
13438 wrel->r_offset = rel->r_offset;
13439 wrel->r_info = 0;
13440 wrel->r_addend = 0;
13441
13442 /* For ld -r, remove relocations in debug sections against
13443 sections defined in discarded sections. Not done for
13444 non-debug to preserve relocs in .eh_frame which the
13445 eh_frame editing code expects to be present. */
13446 if (bfd_link_relocatable (info)
13447 && (input_section->flags & SEC_DEBUGGING))
13448 wrel--;
13449
13450 continue;
13451 }
13452
13453 if (bfd_link_relocatable (info))
13454 goto copy_reloc;
13455
13456 if (h != NULL && &h->elf == htab->elf.hgot)
13457 {
13458 relocation = TOCstart + htab->sec_info[input_section->id].toc_off;
13459 sec = bfd_abs_section_ptr;
13460 unresolved_reloc = FALSE;
13461 }
13462
13463 /* TLS optimizations. Replace instruction sequences and relocs
13464 based on information we collected in tls_optimize. We edit
13465 RELOCS so that --emit-relocs will output something sensible
13466 for the final instruction stream. */
13467 tls_mask = 0;
13468 tls_gd = 0;
13469 toc_symndx = 0;
13470 if (h != NULL)
13471 tls_mask = h->tls_mask;
13472 else if (local_got_ents != NULL)
13473 {
13474 struct plt_entry **local_plt = (struct plt_entry **)
13475 (local_got_ents + symtab_hdr->sh_info);
13476 unsigned char *lgot_masks = (unsigned char *)
13477 (local_plt + symtab_hdr->sh_info);
13478 tls_mask = lgot_masks[r_symndx];
13479 }
13480 if (tls_mask == 0
13481 && (r_type == R_PPC64_TLS
13482 || r_type == R_PPC64_TLSGD
13483 || r_type == R_PPC64_TLSLD))
13484 {
13485 /* Check for toc tls entries. */
13486 unsigned char *toc_tls;
13487
13488 if (!get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
13489 &local_syms, rel, input_bfd))
13490 return FALSE;
13491
13492 if (toc_tls)
13493 tls_mask = *toc_tls;
13494 }
13495
13496 /* Check that tls relocs are used with tls syms, and non-tls
13497 relocs are used with non-tls syms. */
13498 if (r_symndx != STN_UNDEF
13499 && r_type != R_PPC64_NONE
13500 && (h == NULL
13501 || h->elf.root.type == bfd_link_hash_defined
13502 || h->elf.root.type == bfd_link_hash_defweak)
13503 && (IS_PPC64_TLS_RELOC (r_type)
13504 != (sym_type == STT_TLS
13505 || (sym_type == STT_SECTION
13506 && (sec->flags & SEC_THREAD_LOCAL) != 0))))
13507 {
13508 if (tls_mask != 0
13509 && (r_type == R_PPC64_TLS
13510 || r_type == R_PPC64_TLSGD
13511 || r_type == R_PPC64_TLSLD))
13512 /* R_PPC64_TLS is OK against a symbol in the TOC. */
13513 ;
13514 else
13515 info->callbacks->einfo
13516 (!IS_PPC64_TLS_RELOC (r_type)
13517 ? _("%P: %H: %s used with TLS symbol `%T'\n")
13518 : _("%P: %H: %s used with non-TLS symbol `%T'\n"),
13519 input_bfd, input_section, rel->r_offset,
13520 ppc64_elf_howto_table[r_type]->name,
13521 sym_name);
13522 }
13523
13524 /* Ensure reloc mapping code below stays sane. */
13525 if (R_PPC64_TOC16_LO_DS != R_PPC64_TOC16_DS + 1
13526 || R_PPC64_TOC16_LO != R_PPC64_TOC16 + 1
13527 || (R_PPC64_GOT_TLSLD16 & 3) != (R_PPC64_GOT_TLSGD16 & 3)
13528 || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TLSGD16_LO & 3)
13529 || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TLSGD16_HI & 3)
13530 || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TLSGD16_HA & 3)
13531 || (R_PPC64_GOT_TLSLD16 & 3) != (R_PPC64_GOT_TPREL16_DS & 3)
13532 || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TPREL16_LO_DS & 3)
13533 || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TPREL16_HI & 3)
13534 || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TPREL16_HA & 3))
13535 abort ();
13536
13537 switch (r_type)
13538 {
13539 default:
13540 break;
13541
13542 case R_PPC64_LO_DS_OPT:
13543 insn = bfd_get_32 (output_bfd, contents + rel->r_offset - d_offset);
13544 if ((insn & (0x3f << 26)) != 58u << 26)
13545 abort ();
13546 insn += (14u << 26) - (58u << 26);
13547 bfd_put_32 (output_bfd, insn, contents + rel->r_offset - d_offset);
13548 r_type = R_PPC64_TOC16_LO;
13549 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13550 break;
13551
13552 case R_PPC64_TOC16:
13553 case R_PPC64_TOC16_LO:
13554 case R_PPC64_TOC16_DS:
13555 case R_PPC64_TOC16_LO_DS:
13556 {
13557 /* Check for toc tls entries. */
13558 unsigned char *toc_tls;
13559 int retval;
13560
13561 retval = get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
13562 &local_syms, rel, input_bfd);
13563 if (retval == 0)
13564 return FALSE;
13565
13566 if (toc_tls)
13567 {
13568 tls_mask = *toc_tls;
13569 if (r_type == R_PPC64_TOC16_DS
13570 || r_type == R_PPC64_TOC16_LO_DS)
13571 {
13572 if (tls_mask != 0
13573 && (tls_mask & (TLS_DTPREL | TLS_TPREL)) == 0)
13574 goto toctprel;
13575 }
13576 else
13577 {
13578 /* If we found a GD reloc pair, then we might be
13579 doing a GD->IE transition. */
13580 if (retval == 2)
13581 {
13582 tls_gd = TLS_TPRELGD;
13583 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13584 goto tls_ldgd_opt;
13585 }
13586 else if (retval == 3)
13587 {
13588 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13589 goto tls_ldgd_opt;
13590 }
13591 }
13592 }
13593 }
13594 break;
13595
13596 case R_PPC64_GOT_TPREL16_HI:
13597 case R_PPC64_GOT_TPREL16_HA:
13598 if (tls_mask != 0
13599 && (tls_mask & TLS_TPREL) == 0)
13600 {
13601 rel->r_offset -= d_offset;
13602 bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
13603 r_type = R_PPC64_NONE;
13604 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13605 }
13606 break;
13607
13608 case R_PPC64_GOT_TPREL16_DS:
13609 case R_PPC64_GOT_TPREL16_LO_DS:
13610 if (tls_mask != 0
13611 && (tls_mask & TLS_TPREL) == 0)
13612 {
13613 toctprel:
13614 insn = bfd_get_32 (output_bfd,
13615 contents + rel->r_offset - d_offset);
13616 insn &= 31 << 21;
13617 insn |= 0x3c0d0000; /* addis 0,13,0 */
13618 bfd_put_32 (output_bfd, insn,
13619 contents + rel->r_offset - d_offset);
13620 r_type = R_PPC64_TPREL16_HA;
13621 if (toc_symndx != 0)
13622 {
13623 rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
13624 rel->r_addend = toc_addend;
13625 /* We changed the symbol. Start over in order to
13626 get h, sym, sec etc. right. */
13627 goto again;
13628 }
13629 else
13630 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13631 }
13632 break;
13633
13634 case R_PPC64_TLS:
13635 if (tls_mask != 0
13636 && (tls_mask & TLS_TPREL) == 0)
13637 {
13638 insn = bfd_get_32 (output_bfd, contents + rel->r_offset);
13639 insn = _bfd_elf_ppc_at_tls_transform (insn, 13);
13640 if (insn == 0)
13641 abort ();
13642 bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
13643 /* Was PPC64_TLS which sits on insn boundary, now
13644 PPC64_TPREL16_LO which is at low-order half-word. */
13645 rel->r_offset += d_offset;
13646 r_type = R_PPC64_TPREL16_LO;
13647 if (toc_symndx != 0)
13648 {
13649 rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
13650 rel->r_addend = toc_addend;
13651 /* We changed the symbol. Start over in order to
13652 get h, sym, sec etc. right. */
13653 goto again;
13654 }
13655 else
13656 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13657 }
13658 break;
13659
13660 case R_PPC64_GOT_TLSGD16_HI:
13661 case R_PPC64_GOT_TLSGD16_HA:
13662 tls_gd = TLS_TPRELGD;
13663 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13664 goto tls_gdld_hi;
13665 break;
13666
13667 case R_PPC64_GOT_TLSLD16_HI:
13668 case R_PPC64_GOT_TLSLD16_HA:
13669 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13670 {
13671 tls_gdld_hi:
13672 if ((tls_mask & tls_gd) != 0)
13673 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
13674 + R_PPC64_GOT_TPREL16_DS);
13675 else
13676 {
13677 rel->r_offset -= d_offset;
13678 bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
13679 r_type = R_PPC64_NONE;
13680 }
13681 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13682 }
13683 break;
13684
13685 case R_PPC64_GOT_TLSGD16:
13686 case R_PPC64_GOT_TLSGD16_LO:
13687 tls_gd = TLS_TPRELGD;
13688 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13689 goto tls_ldgd_opt;
13690 break;
13691
13692 case R_PPC64_GOT_TLSLD16:
13693 case R_PPC64_GOT_TLSLD16_LO:
13694 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13695 {
13696 unsigned int insn1, insn2, insn3;
13697 bfd_vma offset;
13698
13699 tls_ldgd_opt:
13700 offset = (bfd_vma) -1;
13701 /* If not using the newer R_PPC64_TLSGD/LD to mark
13702 __tls_get_addr calls, we must trust that the call
13703 stays with its arg setup insns, ie. that the next
13704 reloc is the __tls_get_addr call associated with
13705 the current reloc. Edit both insns. */
13706 if (input_section->has_tls_get_addr_call
13707 && rel + 1 < relend
13708 && branch_reloc_hash_match (input_bfd, rel + 1,
13709 htab->tls_get_addr,
13710 htab->tls_get_addr_fd))
13711 offset = rel[1].r_offset;
13712 /* We read the low GOT_TLS (or TOC16) insn because we
13713 need to keep the destination reg. It may be
13714 something other than the usual r3, and moved to r3
13715 before the call by intervening code. */
13716 insn1 = bfd_get_32 (output_bfd,
13717 contents + rel->r_offset - d_offset);
13718 if ((tls_mask & tls_gd) != 0)
13719 {
13720 /* IE */
13721 insn1 &= (0x1f << 21) | (0x1f << 16);
13722 insn1 |= 58 << 26; /* ld */
13723 insn2 = 0x7c636a14; /* add 3,3,13 */
13724 if (offset != (bfd_vma) -1)
13725 rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13726 if ((tls_mask & TLS_EXPLICIT) == 0)
13727 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
13728 + R_PPC64_GOT_TPREL16_DS);
13729 else
13730 r_type += R_PPC64_TOC16_DS - R_PPC64_TOC16;
13731 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13732 }
13733 else
13734 {
13735 /* LE */
13736 insn1 &= 0x1f << 21;
13737 insn1 |= 0x3c0d0000; /* addis r,13,0 */
13738 insn2 = 0x38630000; /* addi 3,3,0 */
13739 if (tls_gd == 0)
13740 {
13741 /* Was an LD reloc. */
13742 if (toc_symndx)
13743 sec = local_sections[toc_symndx];
13744 for (r_symndx = 0;
13745 r_symndx < symtab_hdr->sh_info;
13746 r_symndx++)
13747 if (local_sections[r_symndx] == sec)
13748 break;
13749 if (r_symndx >= symtab_hdr->sh_info)
13750 r_symndx = STN_UNDEF;
13751 rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
13752 if (r_symndx != STN_UNDEF)
13753 rel->r_addend -= (local_syms[r_symndx].st_value
13754 + sec->output_offset
13755 + sec->output_section->vma);
13756 }
13757 else if (toc_symndx != 0)
13758 {
13759 r_symndx = toc_symndx;
13760 rel->r_addend = toc_addend;
13761 }
13762 r_type = R_PPC64_TPREL16_HA;
13763 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13764 if (offset != (bfd_vma) -1)
13765 {
13766 rel[1].r_info = ELF64_R_INFO (r_symndx,
13767 R_PPC64_TPREL16_LO);
13768 rel[1].r_offset = offset + d_offset;
13769 rel[1].r_addend = rel->r_addend;
13770 }
13771 }
13772 bfd_put_32 (output_bfd, insn1,
13773 contents + rel->r_offset - d_offset);
13774 if (offset != (bfd_vma) -1)
13775 {
13776 insn3 = bfd_get_32 (output_bfd,
13777 contents + offset + 4);
13778 if (insn3 == NOP
13779 || insn3 == CROR_151515 || insn3 == CROR_313131)
13780 {
13781 rel[1].r_offset += 4;
13782 bfd_put_32 (output_bfd, insn2, contents + offset + 4);
13783 insn2 = NOP;
13784 }
13785 bfd_put_32 (output_bfd, insn2, contents + offset);
13786 }
13787 if ((tls_mask & tls_gd) == 0
13788 && (tls_gd == 0 || toc_symndx != 0))
13789 {
13790 /* We changed the symbol. Start over in order
13791 to get h, sym, sec etc. right. */
13792 goto again;
13793 }
13794 }
13795 break;
13796
13797 case R_PPC64_TLSGD:
13798 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13799 {
13800 unsigned int insn2, insn3;
13801 bfd_vma offset = rel->r_offset;
13802
13803 if ((tls_mask & TLS_TPRELGD) != 0)
13804 {
13805 /* IE */
13806 r_type = R_PPC64_NONE;
13807 insn2 = 0x7c636a14; /* add 3,3,13 */
13808 }
13809 else
13810 {
13811 /* LE */
13812 if (toc_symndx != 0)
13813 {
13814 r_symndx = toc_symndx;
13815 rel->r_addend = toc_addend;
13816 }
13817 r_type = R_PPC64_TPREL16_LO;
13818 rel->r_offset = offset + d_offset;
13819 insn2 = 0x38630000; /* addi 3,3,0 */
13820 }
13821 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13822 /* Zap the reloc on the _tls_get_addr call too. */
13823 BFD_ASSERT (offset == rel[1].r_offset);
13824 rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13825 insn3 = bfd_get_32 (output_bfd,
13826 contents + offset + 4);
13827 if (insn3 == NOP
13828 || insn3 == CROR_151515 || insn3 == CROR_313131)
13829 {
13830 rel->r_offset += 4;
13831 bfd_put_32 (output_bfd, insn2, contents + offset + 4);
13832 insn2 = NOP;
13833 }
13834 bfd_put_32 (output_bfd, insn2, contents + offset);
13835 if ((tls_mask & TLS_TPRELGD) == 0 && toc_symndx != 0)
13836 goto again;
13837 }
13838 break;
13839
13840 case R_PPC64_TLSLD:
13841 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13842 {
13843 unsigned int insn2, insn3;
13844 bfd_vma offset = rel->r_offset;
13845
13846 if (toc_symndx)
13847 sec = local_sections[toc_symndx];
13848 for (r_symndx = 0;
13849 r_symndx < symtab_hdr->sh_info;
13850 r_symndx++)
13851 if (local_sections[r_symndx] == sec)
13852 break;
13853 if (r_symndx >= symtab_hdr->sh_info)
13854 r_symndx = STN_UNDEF;
13855 rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
13856 if (r_symndx != STN_UNDEF)
13857 rel->r_addend -= (local_syms[r_symndx].st_value
13858 + sec->output_offset
13859 + sec->output_section->vma);
13860
13861 r_type = R_PPC64_TPREL16_LO;
13862 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13863 rel->r_offset = offset + d_offset;
13864 /* Zap the reloc on the _tls_get_addr call too. */
13865 BFD_ASSERT (offset == rel[1].r_offset);
13866 rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13867 insn2 = 0x38630000; /* addi 3,3,0 */
13868 insn3 = bfd_get_32 (output_bfd,
13869 contents + offset + 4);
13870 if (insn3 == NOP
13871 || insn3 == CROR_151515 || insn3 == CROR_313131)
13872 {
13873 rel->r_offset += 4;
13874 bfd_put_32 (output_bfd, insn2, contents + offset + 4);
13875 insn2 = NOP;
13876 }
13877 bfd_put_32 (output_bfd, insn2, contents + offset);
13878 goto again;
13879 }
13880 break;
13881
13882 case R_PPC64_DTPMOD64:
13883 if (rel + 1 < relend
13884 && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
13885 && rel[1].r_offset == rel->r_offset + 8)
13886 {
13887 if ((tls_mask & TLS_GD) == 0)
13888 {
13889 rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_NONE);
13890 if ((tls_mask & TLS_TPRELGD) != 0)
13891 r_type = R_PPC64_TPREL64;
13892 else
13893 {
13894 bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
13895 r_type = R_PPC64_NONE;
13896 }
13897 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13898 }
13899 }
13900 else
13901 {
13902 if ((tls_mask & TLS_LD) == 0)
13903 {
13904 bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
13905 r_type = R_PPC64_NONE;
13906 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13907 }
13908 }
13909 break;
13910
13911 case R_PPC64_TPREL64:
13912 if ((tls_mask & TLS_TPREL) == 0)
13913 {
13914 r_type = R_PPC64_NONE;
13915 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13916 }
13917 break;
13918
13919 case R_PPC64_ENTRY:
13920 relocation = TOCstart + htab->sec_info[input_section->id].toc_off;
13921 if (!bfd_link_pic (info)
13922 && !info->traditional_format
13923 && relocation + 0x80008000 <= 0xffffffff)
13924 {
13925 unsigned int insn1, insn2;
13926
13927 insn1 = bfd_get_32 (input_bfd, contents + rel->r_offset);
13928 insn2 = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
13929 if ((insn1 & ~0xfffc) == LD_R2_0R12
13930 && insn2 == ADD_R2_R2_R12)
13931 {
13932 bfd_put_32 (output_bfd,
13933 LIS_R2 + PPC_HA (relocation),
13934 contents + rel->r_offset);
13935 bfd_put_32 (output_bfd,
13936 ADDI_R2_R2 + PPC_LO (relocation),
13937 contents + rel->r_offset + 4);
13938 }
13939 }
13940 else
13941 {
13942 relocation -= (rel->r_offset
13943 + input_section->output_offset
13944 + input_section->output_section->vma);
13945 if (relocation + 0x80008000 <= 0xffffffff)
13946 {
13947 unsigned int insn1, insn2;
13948
13949 insn1 = bfd_get_32 (input_bfd, contents + rel->r_offset);
13950 insn2 = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
13951 if ((insn1 & ~0xfffc) == LD_R2_0R12
13952 && insn2 == ADD_R2_R2_R12)
13953 {
13954 bfd_put_32 (output_bfd,
13955 ADDIS_R2_R12 + PPC_HA (relocation),
13956 contents + rel->r_offset);
13957 bfd_put_32 (output_bfd,
13958 ADDI_R2_R2 + PPC_LO (relocation),
13959 contents + rel->r_offset + 4);
13960 }
13961 }
13962 }
13963 break;
13964
13965 case R_PPC64_REL16_HA:
13966 /* If we are generating a non-PIC executable, edit
13967 . 0: addis 2,12,.TOC.-0b@ha
13968 . addi 2,2,.TOC.-0b@l
13969 used by ELFv2 global entry points to set up r2, to
13970 . lis 2,.TOC.@ha
13971 . addi 2,2,.TOC.@l
13972 if .TOC. is in range. */
13973 if (!bfd_link_pic (info)
13974 && !info->traditional_format
13975 && !htab->opd_abi
13976 && rel->r_addend == d_offset
13977 && h != NULL && &h->elf == htab->elf.hgot
13978 && rel + 1 < relend
13979 && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_REL16_LO)
13980 && rel[1].r_offset == rel->r_offset + 4
13981 && rel[1].r_addend == rel->r_addend + 4
13982 && relocation + 0x80008000 <= 0xffffffff)
13983 {
13984 unsigned int insn1, insn2;
13985 bfd_vma offset = rel->r_offset - d_offset;
13986 insn1 = bfd_get_32 (output_bfd, contents + offset);
13987 insn2 = bfd_get_32 (output_bfd, contents + offset + 4);
13988 if ((insn1 & 0xffff0000) == ADDIS_R2_R12
13989 && (insn2 & 0xffff0000) == ADDI_R2_R2)
13990 {
13991 r_type = R_PPC64_ADDR16_HA;
13992 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13993 rel->r_addend -= d_offset;
13994 rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_ADDR16_LO);
13995 rel[1].r_addend -= d_offset + 4;
13996 bfd_put_32 (output_bfd, LIS_R2, contents + offset);
13997 }
13998 }
13999 break;
14000 }
14001
14002 /* Handle other relocations that tweak non-addend part of insn. */
14003 insn = 0;
14004 max_br_offset = 1 << 25;
14005 addend = rel->r_addend;
14006 reloc_dest = DEST_NORMAL;
14007 switch (r_type)
14008 {
14009 default:
14010 break;
14011
14012 case R_PPC64_TOCSAVE:
14013 if (relocation + addend == (rel->r_offset
14014 + input_section->output_offset
14015 + input_section->output_section->vma)
14016 && tocsave_find (htab, NO_INSERT,
14017 &local_syms, rel, input_bfd))
14018 {
14019 insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
14020 if (insn == NOP
14021 || insn == CROR_151515 || insn == CROR_313131)
14022 bfd_put_32 (input_bfd,
14023 STD_R2_0R1 + STK_TOC (htab),
14024 contents + rel->r_offset);
14025 }
14026 break;
14027
14028 /* Branch taken prediction relocations. */
14029 case R_PPC64_ADDR14_BRTAKEN:
14030 case R_PPC64_REL14_BRTAKEN:
14031 insn = 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field. */
14032 /* Fall thru. */
14033
14034 /* Branch not taken prediction relocations. */
14035 case R_PPC64_ADDR14_BRNTAKEN:
14036 case R_PPC64_REL14_BRNTAKEN:
14037 insn |= bfd_get_32 (output_bfd,
14038 contents + rel->r_offset) & ~(0x01 << 21);
14039 /* Fall thru. */
14040
14041 case R_PPC64_REL14:
14042 max_br_offset = 1 << 15;
14043 /* Fall thru. */
14044
14045 case R_PPC64_REL24:
14046 /* Calls to functions with a different TOC, such as calls to
14047 shared objects, need to alter the TOC pointer. This is
14048 done using a linkage stub. A REL24 branching to these
14049 linkage stubs needs to be followed by a nop, as the nop
14050 will be replaced with an instruction to restore the TOC
14051 base pointer. */
14052 fdh = h;
14053 if (h != NULL
14054 && h->oh != NULL
14055 && h->oh->is_func_descriptor)
14056 fdh = ppc_follow_link (h->oh);
14057 stub_entry = ppc_get_stub_entry (input_section, sec, fdh, &orig_rel,
14058 htab);
14059 if (stub_entry != NULL
14060 && (stub_entry->stub_type == ppc_stub_plt_call
14061 || stub_entry->stub_type == ppc_stub_plt_call_r2save
14062 || stub_entry->stub_type == ppc_stub_plt_branch_r2off
14063 || stub_entry->stub_type == ppc_stub_long_branch_r2off))
14064 {
14065 bfd_boolean can_plt_call = FALSE;
14066
14067 /* All of these stubs will modify r2, so there must be a
14068 branch and link followed by a nop. The nop is
14069 replaced by an insn to restore r2. */
14070 if (rel->r_offset + 8 <= input_section->size)
14071 {
14072 unsigned long br;
14073
14074 br = bfd_get_32 (input_bfd,
14075 contents + rel->r_offset);
14076 if ((br & 1) != 0)
14077 {
14078 unsigned long nop;
14079
14080 nop = bfd_get_32 (input_bfd,
14081 contents + rel->r_offset + 4);
14082 if (nop == NOP
14083 || nop == CROR_151515 || nop == CROR_313131)
14084 {
14085 if (h != NULL
14086 && (h == htab->tls_get_addr_fd
14087 || h == htab->tls_get_addr)
14088 && htab->params->tls_get_addr_opt)
14089 {
14090 /* Special stub used, leave nop alone. */
14091 }
14092 else
14093 bfd_put_32 (input_bfd,
14094 LD_R2_0R1 + STK_TOC (htab),
14095 contents + rel->r_offset + 4);
14096 can_plt_call = TRUE;
14097 }
14098 }
14099 }
14100
14101 if (!can_plt_call && h != NULL)
14102 {
14103 const char *name = h->elf.root.root.string;
14104
14105 if (*name == '.')
14106 ++name;
14107
14108 if (strncmp (name, "__libc_start_main", 17) == 0
14109 && (name[17] == 0 || name[17] == '@'))
14110 {
14111 /* Allow crt1 branch to go via a toc adjusting
14112 stub. Other calls that never return could do
14113 the same, if we could detect such. */
14114 can_plt_call = TRUE;
14115 }
14116 }
14117
14118 if (!can_plt_call)
14119 {
14120 /* g++ as of 20130507 emits self-calls without a
14121 following nop. This is arguably wrong since we
14122 have conflicting information. On the one hand a
14123 global symbol and on the other a local call
14124 sequence, but don't error for this special case.
14125 It isn't possible to cheaply verify we have
14126 exactly such a call. Allow all calls to the same
14127 section. */
14128 asection *code_sec = sec;
14129
14130 if (get_opd_info (sec) != NULL)
14131 {
14132 bfd_vma off = (relocation + addend
14133 - sec->output_section->vma
14134 - sec->output_offset);
14135
14136 opd_entry_value (sec, off, &code_sec, NULL, FALSE);
14137 }
14138 if (code_sec == input_section)
14139 can_plt_call = TRUE;
14140 }
14141
14142 if (!can_plt_call)
14143 {
14144 if (stub_entry->stub_type == ppc_stub_plt_call
14145 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
14146 info->callbacks->einfo
14147 (_("%P: %H: call to `%T' lacks nop, can't restore toc; "
14148 "recompile with -fPIC\n"),
14149 input_bfd, input_section, rel->r_offset, sym_name);
14150 else
14151 info->callbacks->einfo
14152 (_("%P: %H: call to `%T' lacks nop, can't restore toc; "
14153 "(-mcmodel=small toc adjust stub)\n"),
14154 input_bfd, input_section, rel->r_offset, sym_name);
14155
14156 bfd_set_error (bfd_error_bad_value);
14157 ret = FALSE;
14158 }
14159
14160 if (can_plt_call
14161 && (stub_entry->stub_type == ppc_stub_plt_call
14162 || stub_entry->stub_type == ppc_stub_plt_call_r2save))
14163 unresolved_reloc = FALSE;
14164 }
14165
14166 if ((stub_entry == NULL
14167 || stub_entry->stub_type == ppc_stub_long_branch
14168 || stub_entry->stub_type == ppc_stub_plt_branch)
14169 && get_opd_info (sec) != NULL)
14170 {
14171 /* The branch destination is the value of the opd entry. */
14172 bfd_vma off = (relocation + addend
14173 - sec->output_section->vma
14174 - sec->output_offset);
14175 bfd_vma dest = opd_entry_value (sec, off, NULL, NULL, FALSE);
14176 if (dest != (bfd_vma) -1)
14177 {
14178 relocation = dest;
14179 addend = 0;
14180 reloc_dest = DEST_OPD;
14181 }
14182 }
14183
14184 /* If the branch is out of reach we ought to have a long
14185 branch stub. */
14186 from = (rel->r_offset
14187 + input_section->output_offset
14188 + input_section->output_section->vma);
14189
14190 relocation += PPC64_LOCAL_ENTRY_OFFSET (fdh
14191 ? fdh->elf.other
14192 : sym->st_other);
14193
14194 if (stub_entry != NULL
14195 && (stub_entry->stub_type == ppc_stub_long_branch
14196 || stub_entry->stub_type == ppc_stub_plt_branch)
14197 && (r_type == R_PPC64_ADDR14_BRTAKEN
14198 || r_type == R_PPC64_ADDR14_BRNTAKEN
14199 || (relocation + addend - from + max_br_offset
14200 < 2 * max_br_offset)))
14201 /* Don't use the stub if this branch is in range. */
14202 stub_entry = NULL;
14203
14204 if (stub_entry != NULL)
14205 {
14206 /* Munge up the value and addend so that we call the stub
14207 rather than the procedure directly. */
14208 asection *stub_sec = stub_entry->group->stub_sec;
14209
14210 if (stub_entry->stub_type == ppc_stub_save_res)
14211 relocation += (stub_sec->output_offset
14212 + stub_sec->output_section->vma
14213 + stub_sec->size - htab->sfpr->size
14214 - htab->sfpr->output_offset
14215 - htab->sfpr->output_section->vma);
14216 else
14217 relocation = (stub_entry->stub_offset
14218 + stub_sec->output_offset
14219 + stub_sec->output_section->vma);
14220 addend = 0;
14221 reloc_dest = DEST_STUB;
14222
14223 if ((stub_entry->stub_type == ppc_stub_plt_call
14224 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
14225 && (ALWAYS_EMIT_R2SAVE
14226 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
14227 && rel + 1 < relend
14228 && rel[1].r_offset == rel->r_offset + 4
14229 && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOCSAVE)
14230 relocation += 4;
14231 }
14232
14233 if (insn != 0)
14234 {
14235 if (is_isa_v2)
14236 {
14237 /* Set 'a' bit. This is 0b00010 in BO field for branch
14238 on CR(BI) insns (BO == 001at or 011at), and 0b01000
14239 for branch on CTR insns (BO == 1a00t or 1a01t). */
14240 if ((insn & (0x14 << 21)) == (0x04 << 21))
14241 insn |= 0x02 << 21;
14242 else if ((insn & (0x14 << 21)) == (0x10 << 21))
14243 insn |= 0x08 << 21;
14244 else
14245 break;
14246 }
14247 else
14248 {
14249 /* Invert 'y' bit if not the default. */
14250 if ((bfd_signed_vma) (relocation + addend - from) < 0)
14251 insn ^= 0x01 << 21;
14252 }
14253
14254 bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
14255 }
14256
14257 /* NOP out calls to undefined weak functions.
14258 We can thus call a weak function without first
14259 checking whether the function is defined. */
14260 else if (h != NULL
14261 && h->elf.root.type == bfd_link_hash_undefweak
14262 && h->elf.dynindx == -1
14263 && r_type == R_PPC64_REL24
14264 && relocation == 0
14265 && addend == 0)
14266 {
14267 bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
14268 goto copy_reloc;
14269 }
14270 break;
14271 }
14272
14273 /* Set `addend'. */
14274 tls_type = 0;
14275 switch (r_type)
14276 {
14277 default:
14278 info->callbacks->einfo
14279 (_("%P: %B: unknown relocation type %d for `%T'\n"),
14280 input_bfd, (int) r_type, sym_name);
14281
14282 bfd_set_error (bfd_error_bad_value);
14283 ret = FALSE;
14284 goto copy_reloc;
14285
14286 case R_PPC64_NONE:
14287 case R_PPC64_TLS:
14288 case R_PPC64_TLSGD:
14289 case R_PPC64_TLSLD:
14290 case R_PPC64_TOCSAVE:
14291 case R_PPC64_GNU_VTINHERIT:
14292 case R_PPC64_GNU_VTENTRY:
14293 case R_PPC64_ENTRY:
14294 goto copy_reloc;
14295
14296 /* GOT16 relocations. Like an ADDR16 using the symbol's
14297 address in the GOT as relocation value instead of the
14298 symbol's value itself. Also, create a GOT entry for the
14299 symbol and put the symbol value there. */
14300 case R_PPC64_GOT_TLSGD16:
14301 case R_PPC64_GOT_TLSGD16_LO:
14302 case R_PPC64_GOT_TLSGD16_HI:
14303 case R_PPC64_GOT_TLSGD16_HA:
14304 tls_type = TLS_TLS | TLS_GD;
14305 goto dogot;
14306
14307 case R_PPC64_GOT_TLSLD16:
14308 case R_PPC64_GOT_TLSLD16_LO:
14309 case R_PPC64_GOT_TLSLD16_HI:
14310 case R_PPC64_GOT_TLSLD16_HA:
14311 tls_type = TLS_TLS | TLS_LD;
14312 goto dogot;
14313
14314 case R_PPC64_GOT_TPREL16_DS:
14315 case R_PPC64_GOT_TPREL16_LO_DS:
14316 case R_PPC64_GOT_TPREL16_HI:
14317 case R_PPC64_GOT_TPREL16_HA:
14318 tls_type = TLS_TLS | TLS_TPREL;
14319 goto dogot;
14320
14321 case R_PPC64_GOT_DTPREL16_DS:
14322 case R_PPC64_GOT_DTPREL16_LO_DS:
14323 case R_PPC64_GOT_DTPREL16_HI:
14324 case R_PPC64_GOT_DTPREL16_HA:
14325 tls_type = TLS_TLS | TLS_DTPREL;
14326 goto dogot;
14327
14328 case R_PPC64_GOT16:
14329 case R_PPC64_GOT16_LO:
14330 case R_PPC64_GOT16_HI:
14331 case R_PPC64_GOT16_HA:
14332 case R_PPC64_GOT16_DS:
14333 case R_PPC64_GOT16_LO_DS:
14334 dogot:
14335 {
14336 /* Relocation is to the entry for this symbol in the global
14337 offset table. */
14338 asection *got;
14339 bfd_vma *offp;
14340 bfd_vma off;
14341 unsigned long indx = 0;
14342 struct got_entry *ent;
14343
14344 if (tls_type == (TLS_TLS | TLS_LD)
14345 && (h == NULL
14346 || !h->elf.def_dynamic))
14347 ent = ppc64_tlsld_got (input_bfd);
14348 else
14349 {
14350
14351 if (h != NULL)
14352 {
14353 bfd_boolean dyn = htab->elf.dynamic_sections_created;
14354 if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, bfd_link_pic (info),
14355 &h->elf)
14356 || (bfd_link_pic (info)
14357 && SYMBOL_REFERENCES_LOCAL (info, &h->elf)))
14358 /* This is actually a static link, or it is a
14359 -Bsymbolic link and the symbol is defined
14360 locally, or the symbol was forced to be local
14361 because of a version file. */
14362 ;
14363 else
14364 {
14365 BFD_ASSERT (h->elf.dynindx != -1);
14366 indx = h->elf.dynindx;
14367 unresolved_reloc = FALSE;
14368 }
14369 ent = h->elf.got.glist;
14370 }
14371 else
14372 {
14373 if (local_got_ents == NULL)
14374 abort ();
14375 ent = local_got_ents[r_symndx];
14376 }
14377
14378 for (; ent != NULL; ent = ent->next)
14379 if (ent->addend == orig_rel.r_addend
14380 && ent->owner == input_bfd
14381 && ent->tls_type == tls_type)
14382 break;
14383 }
14384
14385 if (ent == NULL)
14386 abort ();
14387 if (ent->is_indirect)
14388 ent = ent->got.ent;
14389 offp = &ent->got.offset;
14390 got = ppc64_elf_tdata (ent->owner)->got;
14391 if (got == NULL)
14392 abort ();
14393
14394 /* The offset must always be a multiple of 8. We use the
14395 least significant bit to record whether we have already
14396 processed this entry. */
14397 off = *offp;
14398 if ((off & 1) != 0)
14399 off &= ~1;
14400 else
14401 {
14402 /* Generate relocs for the dynamic linker, except in
14403 the case of TLSLD where we'll use one entry per
14404 module. */
14405 asection *relgot;
14406 bfd_boolean ifunc;
14407
14408 *offp = off | 1;
14409 relgot = NULL;
14410 ifunc = (h != NULL
14411 ? h->elf.type == STT_GNU_IFUNC
14412 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC);
14413 if (ifunc)
14414 relgot = htab->elf.irelplt;
14415 else if ((bfd_link_pic (info) || indx != 0)
14416 && (h == NULL
14417 || (tls_type == (TLS_TLS | TLS_LD)
14418 && !h->elf.def_dynamic)
14419 || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
14420 || h->elf.root.type != bfd_link_hash_undefweak))
14421 relgot = ppc64_elf_tdata (ent->owner)->relgot;
14422 if (relgot != NULL)
14423 {
14424 outrel.r_offset = (got->output_section->vma
14425 + got->output_offset
14426 + off);
14427 outrel.r_addend = addend;
14428 if (tls_type & (TLS_LD | TLS_GD))
14429 {
14430 outrel.r_addend = 0;
14431 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPMOD64);
14432 if (tls_type == (TLS_TLS | TLS_GD))
14433 {
14434 loc = relgot->contents;
14435 loc += (relgot->reloc_count++
14436 * sizeof (Elf64_External_Rela));
14437 bfd_elf64_swap_reloca_out (output_bfd,
14438 &outrel, loc);
14439 outrel.r_offset += 8;
14440 outrel.r_addend = addend;
14441 outrel.r_info
14442 = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
14443 }
14444 }
14445 else if (tls_type == (TLS_TLS | TLS_DTPREL))
14446 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
14447 else if (tls_type == (TLS_TLS | TLS_TPREL))
14448 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_TPREL64);
14449 else if (indx != 0)
14450 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_GLOB_DAT);
14451 else
14452 {
14453 if (ifunc)
14454 outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
14455 else
14456 outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
14457
14458 /* Write the .got section contents for the sake
14459 of prelink. */
14460 loc = got->contents + off;
14461 bfd_put_64 (output_bfd, outrel.r_addend + relocation,
14462 loc);
14463 }
14464
14465 if (indx == 0 && tls_type != (TLS_TLS | TLS_LD))
14466 {
14467 outrel.r_addend += relocation;
14468 if (tls_type & (TLS_GD | TLS_DTPREL | TLS_TPREL))
14469 {
14470 if (htab->elf.tls_sec == NULL)
14471 outrel.r_addend = 0;
14472 else
14473 outrel.r_addend -= htab->elf.tls_sec->vma;
14474 }
14475 }
14476 loc = relgot->contents;
14477 loc += (relgot->reloc_count++
14478 * sizeof (Elf64_External_Rela));
14479 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
14480 }
14481
14482 /* Init the .got section contents here if we're not
14483 emitting a reloc. */
14484 else
14485 {
14486 relocation += addend;
14487 if (tls_type == (TLS_TLS | TLS_LD))
14488 relocation = 1;
14489 else if (tls_type != 0)
14490 {
14491 if (htab->elf.tls_sec == NULL)
14492 relocation = 0;
14493 else
14494 {
14495 relocation -= htab->elf.tls_sec->vma + DTP_OFFSET;
14496 if (tls_type == (TLS_TLS | TLS_TPREL))
14497 relocation += DTP_OFFSET - TP_OFFSET;
14498 }
14499
14500 if (tls_type == (TLS_TLS | TLS_GD))
14501 {
14502 bfd_put_64 (output_bfd, relocation,
14503 got->contents + off + 8);
14504 relocation = 1;
14505 }
14506 }
14507
14508 bfd_put_64 (output_bfd, relocation,
14509 got->contents + off);
14510 }
14511 }
14512
14513 if (off >= (bfd_vma) -2)
14514 abort ();
14515
14516 relocation = got->output_section->vma + got->output_offset + off;
14517 addend = -(TOCstart + htab->sec_info[input_section->id].toc_off);
14518 }
14519 break;
14520
14521 case R_PPC64_PLT16_HA:
14522 case R_PPC64_PLT16_HI:
14523 case R_PPC64_PLT16_LO:
14524 case R_PPC64_PLT32:
14525 case R_PPC64_PLT64:
14526 /* Relocation is to the entry for this symbol in the
14527 procedure linkage table. */
14528 {
14529 struct plt_entry **plt_list = NULL;
14530 if (h != NULL)
14531 plt_list = &h->elf.plt.plist;
14532 else if (local_got_ents != NULL)
14533 {
14534 struct plt_entry **local_plt = (struct plt_entry **)
14535 (local_got_ents + symtab_hdr->sh_info);
14536 unsigned char *local_got_tls_masks = (unsigned char *)
14537 (local_plt + symtab_hdr->sh_info);
14538 if ((local_got_tls_masks[r_symndx] & PLT_IFUNC) != 0)
14539 plt_list = local_plt + r_symndx;
14540 }
14541 if (plt_list)
14542 {
14543 struct plt_entry *ent;
14544
14545 for (ent = *plt_list; ent != NULL; ent = ent->next)
14546 if (ent->plt.offset != (bfd_vma) -1
14547 && ent->addend == orig_rel.r_addend)
14548 {
14549 asection *plt;
14550
14551 plt = htab->elf.splt;
14552 if (!htab->elf.dynamic_sections_created
14553 || h == NULL
14554 || h->elf.dynindx == -1)
14555 plt = htab->elf.iplt;
14556 relocation = (plt->output_section->vma
14557 + plt->output_offset
14558 + ent->plt.offset);
14559 addend = 0;
14560 unresolved_reloc = FALSE;
14561 break;
14562 }
14563 }
14564 }
14565 break;
14566
14567 case R_PPC64_TOC:
14568 /* Relocation value is TOC base. */
14569 relocation = TOCstart;
14570 if (r_symndx == STN_UNDEF)
14571 relocation += htab->sec_info[input_section->id].toc_off;
14572 else if (unresolved_reloc)
14573 ;
14574 else if (sec != NULL && sec->id < htab->sec_info_arr_size)
14575 relocation += htab->sec_info[sec->id].toc_off;
14576 else
14577 unresolved_reloc = TRUE;
14578 goto dodyn;
14579
14580 /* TOC16 relocs. We want the offset relative to the TOC base,
14581 which is the address of the start of the TOC plus 0x8000.
14582 The TOC consists of sections .got, .toc, .tocbss, and .plt,
14583 in this order. */
14584 case R_PPC64_TOC16:
14585 case R_PPC64_TOC16_LO:
14586 case R_PPC64_TOC16_HI:
14587 case R_PPC64_TOC16_DS:
14588 case R_PPC64_TOC16_LO_DS:
14589 case R_PPC64_TOC16_HA:
14590 addend -= TOCstart + htab->sec_info[input_section->id].toc_off;
14591 break;
14592
14593 /* Relocate against the beginning of the section. */
14594 case R_PPC64_SECTOFF:
14595 case R_PPC64_SECTOFF_LO:
14596 case R_PPC64_SECTOFF_HI:
14597 case R_PPC64_SECTOFF_DS:
14598 case R_PPC64_SECTOFF_LO_DS:
14599 case R_PPC64_SECTOFF_HA:
14600 if (sec != NULL)
14601 addend -= sec->output_section->vma;
14602 break;
14603
14604 case R_PPC64_REL16:
14605 case R_PPC64_REL16_LO:
14606 case R_PPC64_REL16_HI:
14607 case R_PPC64_REL16_HA:
14608 case R_PPC64_REL16DX_HA:
14609 break;
14610
14611 case R_PPC64_REL14:
14612 case R_PPC64_REL14_BRNTAKEN:
14613 case R_PPC64_REL14_BRTAKEN:
14614 case R_PPC64_REL24:
14615 break;
14616
14617 case R_PPC64_TPREL16:
14618 case R_PPC64_TPREL16_LO:
14619 case R_PPC64_TPREL16_HI:
14620 case R_PPC64_TPREL16_HA:
14621 case R_PPC64_TPREL16_DS:
14622 case R_PPC64_TPREL16_LO_DS:
14623 case R_PPC64_TPREL16_HIGH:
14624 case R_PPC64_TPREL16_HIGHA:
14625 case R_PPC64_TPREL16_HIGHER:
14626 case R_PPC64_TPREL16_HIGHERA:
14627 case R_PPC64_TPREL16_HIGHEST:
14628 case R_PPC64_TPREL16_HIGHESTA:
14629 if (h != NULL
14630 && h->elf.root.type == bfd_link_hash_undefweak
14631 && h->elf.dynindx == -1)
14632 {
14633 /* Make this relocation against an undefined weak symbol
14634 resolve to zero. This is really just a tweak, since
14635 code using weak externs ought to check that they are
14636 defined before using them. */
14637 bfd_byte *p = contents + rel->r_offset - d_offset;
14638
14639 insn = bfd_get_32 (output_bfd, p);
14640 insn = _bfd_elf_ppc_at_tprel_transform (insn, 13);
14641 if (insn != 0)
14642 bfd_put_32 (output_bfd, insn, p);
14643 break;
14644 }
14645 if (htab->elf.tls_sec != NULL)
14646 addend -= htab->elf.tls_sec->vma + TP_OFFSET;
14647 if (bfd_link_pic (info))
14648 /* The TPREL16 relocs shouldn't really be used in shared
14649 libs as they will result in DT_TEXTREL being set, but
14650 support them anyway. */
14651 goto dodyn;
14652 break;
14653
14654 case R_PPC64_DTPREL16:
14655 case R_PPC64_DTPREL16_LO:
14656 case R_PPC64_DTPREL16_HI:
14657 case R_PPC64_DTPREL16_HA:
14658 case R_PPC64_DTPREL16_DS:
14659 case R_PPC64_DTPREL16_LO_DS:
14660 case R_PPC64_DTPREL16_HIGH:
14661 case R_PPC64_DTPREL16_HIGHA:
14662 case R_PPC64_DTPREL16_HIGHER:
14663 case R_PPC64_DTPREL16_HIGHERA:
14664 case R_PPC64_DTPREL16_HIGHEST:
14665 case R_PPC64_DTPREL16_HIGHESTA:
14666 if (htab->elf.tls_sec != NULL)
14667 addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
14668 break;
14669
14670 case R_PPC64_ADDR64_LOCAL:
14671 addend += PPC64_LOCAL_ENTRY_OFFSET (h != NULL
14672 ? h->elf.other
14673 : sym->st_other);
14674 break;
14675
14676 case R_PPC64_DTPMOD64:
14677 relocation = 1;
14678 addend = 0;
14679 goto dodyn;
14680
14681 case R_PPC64_TPREL64:
14682 if (htab->elf.tls_sec != NULL)
14683 addend -= htab->elf.tls_sec->vma + TP_OFFSET;
14684 goto dodyn;
14685
14686 case R_PPC64_DTPREL64:
14687 if (htab->elf.tls_sec != NULL)
14688 addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
14689 /* Fall thru */
14690
14691 /* Relocations that may need to be propagated if this is a
14692 dynamic object. */
14693 case R_PPC64_REL30:
14694 case R_PPC64_REL32:
14695 case R_PPC64_REL64:
14696 case R_PPC64_ADDR14:
14697 case R_PPC64_ADDR14_BRNTAKEN:
14698 case R_PPC64_ADDR14_BRTAKEN:
14699 case R_PPC64_ADDR16:
14700 case R_PPC64_ADDR16_DS:
14701 case R_PPC64_ADDR16_HA:
14702 case R_PPC64_ADDR16_HI:
14703 case R_PPC64_ADDR16_HIGH:
14704 case R_PPC64_ADDR16_HIGHA:
14705 case R_PPC64_ADDR16_HIGHER:
14706 case R_PPC64_ADDR16_HIGHERA:
14707 case R_PPC64_ADDR16_HIGHEST:
14708 case R_PPC64_ADDR16_HIGHESTA:
14709 case R_PPC64_ADDR16_LO:
14710 case R_PPC64_ADDR16_LO_DS:
14711 case R_PPC64_ADDR24:
14712 case R_PPC64_ADDR32:
14713 case R_PPC64_ADDR64:
14714 case R_PPC64_UADDR16:
14715 case R_PPC64_UADDR32:
14716 case R_PPC64_UADDR64:
14717 dodyn:
14718 if ((input_section->flags & SEC_ALLOC) == 0)
14719 break;
14720
14721 if (NO_OPD_RELOCS && is_opd)
14722 break;
14723
14724 if (bfd_link_pic (info)
14725 ? ((h == NULL
14726 || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
14727 || h->elf.root.type != bfd_link_hash_undefweak)
14728 && (must_be_dyn_reloc (info, r_type)
14729 || !SYMBOL_CALLS_LOCAL (info, &h->elf)))
14730 : (h == NULL
14731 ? ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC
14732 : (h->elf.type == STT_GNU_IFUNC
14733 ? (abiversion (output_bfd) >= 2
14734 ? !(h->elf.pointer_equality_needed
14735 && !h->elf.def_regular
14736 && h->elf.root.type == bfd_link_hash_defined
14737 && h->elf.root.u.def.section == htab->glink)
14738 : !h->elf.needs_copy)
14739 : (ELIMINATE_COPY_RELOCS
14740 && !(h->elf.non_got_ref
14741 || h->elf.def_regular
14742 || h->elf.dynindx == -1)))))
14743 {
14744 bfd_boolean skip, relocate;
14745 asection *sreloc;
14746 bfd_vma out_off;
14747
14748 /* When generating a dynamic object, these relocations
14749 are copied into the output file to be resolved at run
14750 time. */
14751
14752 skip = FALSE;
14753 relocate = FALSE;
14754
14755 out_off = _bfd_elf_section_offset (output_bfd, info,
14756 input_section, rel->r_offset);
14757 if (out_off == (bfd_vma) -1)
14758 skip = TRUE;
14759 else if (out_off == (bfd_vma) -2)
14760 skip = TRUE, relocate = TRUE;
14761 out_off += (input_section->output_section->vma
14762 + input_section->output_offset);
14763 outrel.r_offset = out_off;
14764 outrel.r_addend = rel->r_addend;
14765
14766 /* Optimize unaligned reloc use. */
14767 if ((r_type == R_PPC64_ADDR64 && (out_off & 7) != 0)
14768 || (r_type == R_PPC64_UADDR64 && (out_off & 7) == 0))
14769 r_type ^= R_PPC64_ADDR64 ^ R_PPC64_UADDR64;
14770 else if ((r_type == R_PPC64_ADDR32 && (out_off & 3) != 0)
14771 || (r_type == R_PPC64_UADDR32 && (out_off & 3) == 0))
14772 r_type ^= R_PPC64_ADDR32 ^ R_PPC64_UADDR32;
14773 else if ((r_type == R_PPC64_ADDR16 && (out_off & 1) != 0)
14774 || (r_type == R_PPC64_UADDR16 && (out_off & 1) == 0))
14775 r_type ^= R_PPC64_ADDR16 ^ R_PPC64_UADDR16;
14776
14777 if (skip)
14778 memset (&outrel, 0, sizeof outrel);
14779 else if (!SYMBOL_REFERENCES_LOCAL (info, &h->elf)
14780 && !is_opd
14781 && r_type != R_PPC64_TOC)
14782 {
14783 BFD_ASSERT (h->elf.dynindx != -1);
14784 outrel.r_info = ELF64_R_INFO (h->elf.dynindx, r_type);
14785 }
14786 else
14787 {
14788 /* This symbol is local, or marked to become local,
14789 or this is an opd section reloc which must point
14790 at a local function. */
14791 outrel.r_addend += relocation;
14792 if (r_type == R_PPC64_ADDR64 || r_type == R_PPC64_TOC)
14793 {
14794 if (is_opd && h != NULL)
14795 {
14796 /* Lie about opd entries. This case occurs
14797 when building shared libraries and we
14798 reference a function in another shared
14799 lib. The same thing happens for a weak
14800 definition in an application that's
14801 overridden by a strong definition in a
14802 shared lib. (I believe this is a generic
14803 bug in binutils handling of weak syms.)
14804 In these cases we won't use the opd
14805 entry in this lib. */
14806 unresolved_reloc = FALSE;
14807 }
14808 if (!is_opd
14809 && r_type == R_PPC64_ADDR64
14810 && (h != NULL
14811 ? h->elf.type == STT_GNU_IFUNC
14812 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
14813 outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
14814 else
14815 {
14816 outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
14817
14818 /* We need to relocate .opd contents for ld.so.
14819 Prelink also wants simple and consistent rules
14820 for relocs. This make all RELATIVE relocs have
14821 *r_offset equal to r_addend. */
14822 relocate = TRUE;
14823 }
14824 }
14825 else
14826 {
14827 long indx = 0;
14828
14829 if (h != NULL
14830 ? h->elf.type == STT_GNU_IFUNC
14831 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
14832 {
14833 info->callbacks->einfo
14834 (_("%P: %H: %s for indirect "
14835 "function `%T' unsupported\n"),
14836 input_bfd, input_section, rel->r_offset,
14837 ppc64_elf_howto_table[r_type]->name,
14838 sym_name);
14839 ret = FALSE;
14840 }
14841 else if (r_symndx == STN_UNDEF || bfd_is_abs_section (sec))
14842 ;
14843 else if (sec == NULL || sec->owner == NULL)
14844 {
14845 bfd_set_error (bfd_error_bad_value);
14846 return FALSE;
14847 }
14848 else
14849 {
14850 asection *osec;
14851
14852 osec = sec->output_section;
14853 indx = elf_section_data (osec)->dynindx;
14854
14855 if (indx == 0)
14856 {
14857 if ((osec->flags & SEC_READONLY) == 0
14858 && htab->elf.data_index_section != NULL)
14859 osec = htab->elf.data_index_section;
14860 else
14861 osec = htab->elf.text_index_section;
14862 indx = elf_section_data (osec)->dynindx;
14863 }
14864 BFD_ASSERT (indx != 0);
14865
14866 /* We are turning this relocation into one
14867 against a section symbol, so subtract out
14868 the output section's address but not the
14869 offset of the input section in the output
14870 section. */
14871 outrel.r_addend -= osec->vma;
14872 }
14873
14874 outrel.r_info = ELF64_R_INFO (indx, r_type);
14875 }
14876 }
14877
14878 sreloc = elf_section_data (input_section)->sreloc;
14879 if (h != NULL
14880 ? h->elf.type == STT_GNU_IFUNC
14881 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
14882 sreloc = htab->elf.irelplt;
14883 if (sreloc == NULL)
14884 abort ();
14885
14886 if (sreloc->reloc_count * sizeof (Elf64_External_Rela)
14887 >= sreloc->size)
14888 abort ();
14889 loc = sreloc->contents;
14890 loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
14891 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
14892
14893 /* If this reloc is against an external symbol, it will
14894 be computed at runtime, so there's no need to do
14895 anything now. However, for the sake of prelink ensure
14896 that the section contents are a known value. */
14897 if (! relocate)
14898 {
14899 unresolved_reloc = FALSE;
14900 /* The value chosen here is quite arbitrary as ld.so
14901 ignores section contents except for the special
14902 case of .opd where the contents might be accessed
14903 before relocation. Choose zero, as that won't
14904 cause reloc overflow. */
14905 relocation = 0;
14906 addend = 0;
14907 /* Use *r_offset == r_addend for R_PPC64_ADDR64 relocs
14908 to improve backward compatibility with older
14909 versions of ld. */
14910 if (r_type == R_PPC64_ADDR64)
14911 addend = outrel.r_addend;
14912 /* Adjust pc_relative relocs to have zero in *r_offset. */
14913 else if (ppc64_elf_howto_table[r_type]->pc_relative)
14914 addend = (input_section->output_section->vma
14915 + input_section->output_offset
14916 + rel->r_offset);
14917 }
14918 }
14919 break;
14920
14921 case R_PPC64_COPY:
14922 case R_PPC64_GLOB_DAT:
14923 case R_PPC64_JMP_SLOT:
14924 case R_PPC64_JMP_IREL:
14925 case R_PPC64_RELATIVE:
14926 /* We shouldn't ever see these dynamic relocs in relocatable
14927 files. */
14928 /* Fall through. */
14929
14930 case R_PPC64_PLTGOT16:
14931 case R_PPC64_PLTGOT16_DS:
14932 case R_PPC64_PLTGOT16_HA:
14933 case R_PPC64_PLTGOT16_HI:
14934 case R_PPC64_PLTGOT16_LO:
14935 case R_PPC64_PLTGOT16_LO_DS:
14936 case R_PPC64_PLTREL32:
14937 case R_PPC64_PLTREL64:
14938 /* These ones haven't been implemented yet. */
14939
14940 info->callbacks->einfo
14941 (_("%P: %B: %s is not supported for `%T'\n"),
14942 input_bfd,
14943 ppc64_elf_howto_table[r_type]->name, sym_name);
14944
14945 bfd_set_error (bfd_error_invalid_operation);
14946 ret = FALSE;
14947 goto copy_reloc;
14948 }
14949
14950 /* Multi-instruction sequences that access the TOC can be
14951 optimized, eg. addis ra,r2,0; addi rb,ra,x;
14952 to nop; addi rb,r2,x; */
14953 switch (r_type)
14954 {
14955 default:
14956 break;
14957
14958 case R_PPC64_GOT_TLSLD16_HI:
14959 case R_PPC64_GOT_TLSGD16_HI:
14960 case R_PPC64_GOT_TPREL16_HI:
14961 case R_PPC64_GOT_DTPREL16_HI:
14962 case R_PPC64_GOT16_HI:
14963 case R_PPC64_TOC16_HI:
14964 /* These relocs would only be useful if building up an
14965 offset to later add to r2, perhaps in an indexed
14966 addressing mode instruction. Don't try to optimize.
14967 Unfortunately, the possibility of someone building up an
14968 offset like this or even with the HA relocs, means that
14969 we need to check the high insn when optimizing the low
14970 insn. */
14971 break;
14972
14973 case R_PPC64_GOT_TLSLD16_HA:
14974 case R_PPC64_GOT_TLSGD16_HA:
14975 case R_PPC64_GOT_TPREL16_HA:
14976 case R_PPC64_GOT_DTPREL16_HA:
14977 case R_PPC64_GOT16_HA:
14978 case R_PPC64_TOC16_HA:
14979 if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
14980 && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
14981 {
14982 bfd_byte *p = contents + (rel->r_offset & ~3);
14983 bfd_put_32 (input_bfd, NOP, p);
14984 }
14985 break;
14986
14987 case R_PPC64_GOT_TLSLD16_LO:
14988 case R_PPC64_GOT_TLSGD16_LO:
14989 case R_PPC64_GOT_TPREL16_LO_DS:
14990 case R_PPC64_GOT_DTPREL16_LO_DS:
14991 case R_PPC64_GOT16_LO:
14992 case R_PPC64_GOT16_LO_DS:
14993 case R_PPC64_TOC16_LO:
14994 case R_PPC64_TOC16_LO_DS:
14995 if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
14996 && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
14997 {
14998 bfd_byte *p = contents + (rel->r_offset & ~3);
14999 insn = bfd_get_32 (input_bfd, p);
15000 if ((insn & (0x3f << 26)) == 12u << 26 /* addic */)
15001 {
15002 /* Transform addic to addi when we change reg. */
15003 insn &= ~((0x3f << 26) | (0x1f << 16));
15004 insn |= (14u << 26) | (2 << 16);
15005 }
15006 else
15007 {
15008 insn &= ~(0x1f << 16);
15009 insn |= 2 << 16;
15010 }
15011 bfd_put_32 (input_bfd, insn, p);
15012 }
15013 break;
15014 }
15015
15016 /* Do any further special processing. */
15017 howto = ppc64_elf_howto_table[(int) r_type];
15018 switch (r_type)
15019 {
15020 default:
15021 break;
15022
15023 case R_PPC64_REL16_HA:
15024 case R_PPC64_REL16DX_HA:
15025 case R_PPC64_ADDR16_HA:
15026 case R_PPC64_ADDR16_HIGHA:
15027 case R_PPC64_ADDR16_HIGHERA:
15028 case R_PPC64_ADDR16_HIGHESTA:
15029 case R_PPC64_TOC16_HA:
15030 case R_PPC64_SECTOFF_HA:
15031 case R_PPC64_TPREL16_HA:
15032 case R_PPC64_TPREL16_HIGHA:
15033 case R_PPC64_TPREL16_HIGHERA:
15034 case R_PPC64_TPREL16_HIGHESTA:
15035 case R_PPC64_DTPREL16_HA:
15036 case R_PPC64_DTPREL16_HIGHA:
15037 case R_PPC64_DTPREL16_HIGHERA:
15038 case R_PPC64_DTPREL16_HIGHESTA:
15039 /* It's just possible that this symbol is a weak symbol
15040 that's not actually defined anywhere. In that case,
15041 'sec' would be NULL, and we should leave the symbol
15042 alone (it will be set to zero elsewhere in the link). */
15043 if (sec == NULL)
15044 break;
15045 /* Fall thru */
15046
15047 case R_PPC64_GOT16_HA:
15048 case R_PPC64_PLTGOT16_HA:
15049 case R_PPC64_PLT16_HA:
15050 case R_PPC64_GOT_TLSGD16_HA:
15051 case R_PPC64_GOT_TLSLD16_HA:
15052 case R_PPC64_GOT_TPREL16_HA:
15053 case R_PPC64_GOT_DTPREL16_HA:
15054 /* Add 0x10000 if sign bit in 0:15 is set.
15055 Bits 0:15 are not used. */
15056 addend += 0x8000;
15057 break;
15058
15059 case R_PPC64_ADDR16_DS:
15060 case R_PPC64_ADDR16_LO_DS:
15061 case R_PPC64_GOT16_DS:
15062 case R_PPC64_GOT16_LO_DS:
15063 case R_PPC64_PLT16_LO_DS:
15064 case R_PPC64_SECTOFF_DS:
15065 case R_PPC64_SECTOFF_LO_DS:
15066 case R_PPC64_TOC16_DS:
15067 case R_PPC64_TOC16_LO_DS:
15068 case R_PPC64_PLTGOT16_DS:
15069 case R_PPC64_PLTGOT16_LO_DS:
15070 case R_PPC64_GOT_TPREL16_DS:
15071 case R_PPC64_GOT_TPREL16_LO_DS:
15072 case R_PPC64_GOT_DTPREL16_DS:
15073 case R_PPC64_GOT_DTPREL16_LO_DS:
15074 case R_PPC64_TPREL16_DS:
15075 case R_PPC64_TPREL16_LO_DS:
15076 case R_PPC64_DTPREL16_DS:
15077 case R_PPC64_DTPREL16_LO_DS:
15078 insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
15079 mask = 3;
15080 /* If this reloc is against an lq, lxv, or stxv insn, then
15081 the value must be a multiple of 16. This is somewhat of
15082 a hack, but the "correct" way to do this by defining _DQ
15083 forms of all the _DS relocs bloats all reloc switches in
15084 this file. It doesn't make much sense to use these
15085 relocs in data, so testing the insn should be safe. */
15086 if ((insn & (0x3f << 26)) == (56u << 26)
15087 || ((insn & (0x3f << 26)) == (61u << 26) && (insn & 3) == 1))
15088 mask = 15;
15089 relocation += addend;
15090 addend = insn & (mask ^ 3);
15091 if ((relocation & mask) != 0)
15092 {
15093 relocation ^= relocation & mask;
15094 info->callbacks->einfo
15095 (_("%P: %H: error: %s not a multiple of %u\n"),
15096 input_bfd, input_section, rel->r_offset,
15097 howto->name,
15098 mask + 1);
15099 bfd_set_error (bfd_error_bad_value);
15100 ret = FALSE;
15101 goto copy_reloc;
15102 }
15103 break;
15104 }
15105
15106 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
15107 because such sections are not SEC_ALLOC and thus ld.so will
15108 not process them. */
15109 if (unresolved_reloc
15110 && !((input_section->flags & SEC_DEBUGGING) != 0
15111 && h->elf.def_dynamic)
15112 && _bfd_elf_section_offset (output_bfd, info, input_section,
15113 rel->r_offset) != (bfd_vma) -1)
15114 {
15115 info->callbacks->einfo
15116 (_("%P: %H: unresolvable %s against `%T'\n"),
15117 input_bfd, input_section, rel->r_offset,
15118 howto->name,
15119 h->elf.root.root.string);
15120 ret = FALSE;
15121 }
15122
15123 /* 16-bit fields in insns mostly have signed values, but a
15124 few insns have 16-bit unsigned values. Really, we should
15125 have different reloc types. */
15126 if (howto->complain_on_overflow != complain_overflow_dont
15127 && howto->dst_mask == 0xffff
15128 && (input_section->flags & SEC_CODE) != 0)
15129 {
15130 enum complain_overflow complain = complain_overflow_signed;
15131
15132 insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
15133 if ((insn & (0x3f << 26)) == 10u << 26 /* cmpli */)
15134 complain = complain_overflow_bitfield;
15135 else if (howto->rightshift == 0
15136 ? ((insn & (0x3f << 26)) == 28u << 26 /* andi */
15137 || (insn & (0x3f << 26)) == 24u << 26 /* ori */
15138 || (insn & (0x3f << 26)) == 26u << 26 /* xori */)
15139 : ((insn & (0x3f << 26)) == 29u << 26 /* andis */
15140 || (insn & (0x3f << 26)) == 25u << 26 /* oris */
15141 || (insn & (0x3f << 26)) == 27u << 26 /* xoris */))
15142 complain = complain_overflow_unsigned;
15143 if (howto->complain_on_overflow != complain)
15144 {
15145 alt_howto = *howto;
15146 alt_howto.complain_on_overflow = complain;
15147 howto = &alt_howto;
15148 }
15149 }
15150
15151 if (r_type == R_PPC64_REL16DX_HA)
15152 {
15153 /* Split field reloc isn't handled by _bfd_final_link_relocate. */
15154 if (rel->r_offset + 4 > input_section->size)
15155 r = bfd_reloc_outofrange;
15156 else
15157 {
15158 relocation += addend;
15159 relocation -= (rel->r_offset
15160 + input_section->output_offset
15161 + input_section->output_section->vma);
15162 relocation = (bfd_signed_vma) relocation >> 16;
15163 insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
15164 insn &= ~0x1fffc1;
15165 insn |= (relocation & 0xffc1) | ((relocation & 0x3e) << 15);
15166 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
15167 r = bfd_reloc_ok;
15168 if (relocation + 0x8000 > 0xffff)
15169 r = bfd_reloc_overflow;
15170 }
15171 }
15172 else
15173 r = _bfd_final_link_relocate (howto, input_bfd, input_section, contents,
15174 rel->r_offset, relocation, addend);
15175
15176 if (r != bfd_reloc_ok)
15177 {
15178 char *more_info = NULL;
15179 const char *reloc_name = howto->name;
15180
15181 if (reloc_dest != DEST_NORMAL)
15182 {
15183 more_info = bfd_malloc (strlen (reloc_name) + 8);
15184 if (more_info != NULL)
15185 {
15186 strcpy (more_info, reloc_name);
15187 strcat (more_info, (reloc_dest == DEST_OPD
15188 ? " (OPD)" : " (stub)"));
15189 reloc_name = more_info;
15190 }
15191 }
15192
15193 if (r == bfd_reloc_overflow)
15194 {
15195 /* On code like "if (foo) foo();" don't report overflow
15196 on a branch to zero when foo is undefined. */
15197 if (!warned
15198 && (reloc_dest == DEST_STUB
15199 || !(h != NULL
15200 && (h->elf.root.type == bfd_link_hash_undefweak
15201 || h->elf.root.type == bfd_link_hash_undefined)
15202 && is_branch_reloc (r_type))))
15203 info->callbacks->reloc_overflow (info, &h->elf.root,
15204 sym_name, reloc_name,
15205 orig_rel.r_addend,
15206 input_bfd, input_section,
15207 rel->r_offset);
15208 }
15209 else
15210 {
15211 info->callbacks->einfo
15212 (_("%P: %H: %s against `%T': error %d\n"),
15213 input_bfd, input_section, rel->r_offset,
15214 reloc_name, sym_name, (int) r);
15215 ret = FALSE;
15216 }
15217 if (more_info != NULL)
15218 free (more_info);
15219 }
15220 copy_reloc:
15221 if (wrel != rel)
15222 *wrel = *rel;
15223 }
15224
15225 if (wrel != rel)
15226 {
15227 Elf_Internal_Shdr *rel_hdr;
15228 size_t deleted = rel - wrel;
15229
15230 rel_hdr = _bfd_elf_single_rel_hdr (input_section->output_section);
15231 rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
15232 if (rel_hdr->sh_size == 0)
15233 {
15234 /* It is too late to remove an empty reloc section. Leave
15235 one NONE reloc.
15236 ??? What is wrong with an empty section??? */
15237 rel_hdr->sh_size = rel_hdr->sh_entsize;
15238 deleted -= 1;
15239 }
15240 rel_hdr = _bfd_elf_single_rel_hdr (input_section);
15241 rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
15242 input_section->reloc_count -= deleted;
15243 }
15244
15245 /* If we're emitting relocations, then shortly after this function
15246 returns, reloc offsets and addends for this section will be
15247 adjusted. Worse, reloc symbol indices will be for the output
15248 file rather than the input. Save a copy of the relocs for
15249 opd_entry_value. */
15250 if (is_opd && (info->emitrelocations || bfd_link_relocatable (info)))
15251 {
15252 bfd_size_type amt;
15253 amt = input_section->reloc_count * sizeof (Elf_Internal_Rela);
15254 rel = bfd_alloc (input_bfd, amt);
15255 BFD_ASSERT (ppc64_elf_tdata (input_bfd)->opd.relocs == NULL);
15256 ppc64_elf_tdata (input_bfd)->opd.relocs = rel;
15257 if (rel == NULL)
15258 return FALSE;
15259 memcpy (rel, relocs, amt);
15260 }
15261 return ret;
15262 }
15263
15264 /* Adjust the value of any local symbols in opd sections. */
15265
15266 static int
ppc64_elf_output_symbol_hook(struct bfd_link_info * info,const char * name ATTRIBUTE_UNUSED,Elf_Internal_Sym * elfsym,asection * input_sec,struct elf_link_hash_entry * h)15267 ppc64_elf_output_symbol_hook (struct bfd_link_info *info,
15268 const char *name ATTRIBUTE_UNUSED,
15269 Elf_Internal_Sym *elfsym,
15270 asection *input_sec,
15271 struct elf_link_hash_entry *h)
15272 {
15273 struct _opd_sec_data *opd;
15274 long adjust;
15275 bfd_vma value;
15276
15277 if (h != NULL)
15278 return 1;
15279
15280 opd = get_opd_info (input_sec);
15281 if (opd == NULL || opd->adjust == NULL)
15282 return 1;
15283
15284 value = elfsym->st_value - input_sec->output_offset;
15285 if (!bfd_link_relocatable (info))
15286 value -= input_sec->output_section->vma;
15287
15288 adjust = opd->adjust[OPD_NDX (value)];
15289 if (adjust == -1)
15290 return 2;
15291
15292 elfsym->st_value += adjust;
15293 return 1;
15294 }
15295
15296 /* Finish up dynamic symbol handling. We set the contents of various
15297 dynamic sections here. */
15298
15299 static bfd_boolean
ppc64_elf_finish_dynamic_symbol(bfd * output_bfd,struct bfd_link_info * info,struct elf_link_hash_entry * h,Elf_Internal_Sym * sym ATTRIBUTE_UNUSED)15300 ppc64_elf_finish_dynamic_symbol (bfd *output_bfd,
15301 struct bfd_link_info *info,
15302 struct elf_link_hash_entry *h,
15303 Elf_Internal_Sym *sym ATTRIBUTE_UNUSED)
15304 {
15305 struct ppc_link_hash_table *htab;
15306 struct plt_entry *ent;
15307 Elf_Internal_Rela rela;
15308 bfd_byte *loc;
15309
15310 htab = ppc_hash_table (info);
15311 if (htab == NULL)
15312 return FALSE;
15313
15314 for (ent = h->plt.plist; ent != NULL; ent = ent->next)
15315 if (ent->plt.offset != (bfd_vma) -1)
15316 {
15317 /* This symbol has an entry in the procedure linkage
15318 table. Set it up. */
15319 if (!htab->elf.dynamic_sections_created
15320 || h->dynindx == -1)
15321 {
15322 BFD_ASSERT (h->type == STT_GNU_IFUNC
15323 && h->def_regular
15324 && (h->root.type == bfd_link_hash_defined
15325 || h->root.type == bfd_link_hash_defweak));
15326 rela.r_offset = (htab->elf.iplt->output_section->vma
15327 + htab->elf.iplt->output_offset
15328 + ent->plt.offset);
15329 if (htab->opd_abi)
15330 rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
15331 else
15332 rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
15333 rela.r_addend = (h->root.u.def.value
15334 + h->root.u.def.section->output_offset
15335 + h->root.u.def.section->output_section->vma
15336 + ent->addend);
15337 loc = (htab->elf.irelplt->contents
15338 + (htab->elf.irelplt->reloc_count++
15339 * sizeof (Elf64_External_Rela)));
15340 }
15341 else
15342 {
15343 rela.r_offset = (htab->elf.splt->output_section->vma
15344 + htab->elf.splt->output_offset
15345 + ent->plt.offset);
15346 rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_JMP_SLOT);
15347 rela.r_addend = ent->addend;
15348 loc = (htab->elf.srelplt->contents
15349 + ((ent->plt.offset - PLT_INITIAL_ENTRY_SIZE (htab))
15350 / PLT_ENTRY_SIZE (htab) * sizeof (Elf64_External_Rela)));
15351 }
15352 bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
15353
15354 if (!htab->opd_abi)
15355 {
15356 if (!h->def_regular)
15357 {
15358 /* Mark the symbol as undefined, rather than as
15359 defined in glink. Leave the value if there were
15360 any relocations where pointer equality matters
15361 (this is a clue for the dynamic linker, to make
15362 function pointer comparisons work between an
15363 application and shared library), otherwise set it
15364 to zero. */
15365 sym->st_shndx = SHN_UNDEF;
15366 if (!h->pointer_equality_needed)
15367 sym->st_value = 0;
15368 else if (!h->ref_regular_nonweak)
15369 {
15370 /* This breaks function pointer comparisons, but
15371 that is better than breaking tests for a NULL
15372 function pointer. */
15373 sym->st_value = 0;
15374 }
15375 }
15376 }
15377 }
15378
15379 if (h->needs_copy)
15380 {
15381 /* This symbol needs a copy reloc. Set it up. */
15382
15383 if (h->dynindx == -1
15384 || (h->root.type != bfd_link_hash_defined
15385 && h->root.type != bfd_link_hash_defweak)
15386 || htab->relbss == NULL)
15387 abort ();
15388
15389 rela.r_offset = (h->root.u.def.value
15390 + h->root.u.def.section->output_section->vma
15391 + h->root.u.def.section->output_offset);
15392 rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_COPY);
15393 rela.r_addend = 0;
15394 loc = htab->relbss->contents;
15395 loc += htab->relbss->reloc_count++ * sizeof (Elf64_External_Rela);
15396 bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
15397 }
15398
15399 return TRUE;
15400 }
15401
15402 /* Used to decide how to sort relocs in an optimal manner for the
15403 dynamic linker, before writing them out. */
15404
15405 static enum elf_reloc_type_class
ppc64_elf_reloc_type_class(const struct bfd_link_info * info,const asection * rel_sec,const Elf_Internal_Rela * rela)15406 ppc64_elf_reloc_type_class (const struct bfd_link_info *info,
15407 const asection *rel_sec,
15408 const Elf_Internal_Rela *rela)
15409 {
15410 enum elf_ppc64_reloc_type r_type;
15411 struct ppc_link_hash_table *htab = ppc_hash_table (info);
15412
15413 if (rel_sec == htab->elf.irelplt)
15414 return reloc_class_ifunc;
15415
15416 r_type = ELF64_R_TYPE (rela->r_info);
15417 switch (r_type)
15418 {
15419 case R_PPC64_RELATIVE:
15420 return reloc_class_relative;
15421 case R_PPC64_JMP_SLOT:
15422 return reloc_class_plt;
15423 case R_PPC64_COPY:
15424 return reloc_class_copy;
15425 default:
15426 return reloc_class_normal;
15427 }
15428 }
15429
15430 /* Finish up the dynamic sections. */
15431
15432 static bfd_boolean
ppc64_elf_finish_dynamic_sections(bfd * output_bfd,struct bfd_link_info * info)15433 ppc64_elf_finish_dynamic_sections (bfd *output_bfd,
15434 struct bfd_link_info *info)
15435 {
15436 struct ppc_link_hash_table *htab;
15437 bfd *dynobj;
15438 asection *sdyn;
15439
15440 htab = ppc_hash_table (info);
15441 if (htab == NULL)
15442 return FALSE;
15443
15444 dynobj = htab->elf.dynobj;
15445 sdyn = bfd_get_linker_section (dynobj, ".dynamic");
15446
15447 if (htab->elf.dynamic_sections_created)
15448 {
15449 Elf64_External_Dyn *dyncon, *dynconend;
15450
15451 if (sdyn == NULL || htab->elf.sgot == NULL)
15452 abort ();
15453
15454 dyncon = (Elf64_External_Dyn *) sdyn->contents;
15455 dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
15456 for (; dyncon < dynconend; dyncon++)
15457 {
15458 Elf_Internal_Dyn dyn;
15459 asection *s;
15460
15461 bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
15462
15463 switch (dyn.d_tag)
15464 {
15465 default:
15466 continue;
15467
15468 case DT_PPC64_GLINK:
15469 s = htab->glink;
15470 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
15471 /* We stupidly defined DT_PPC64_GLINK to be the start
15472 of glink rather than the first entry point, which is
15473 what ld.so needs, and now have a bigger stub to
15474 support automatic multiple TOCs. */
15475 dyn.d_un.d_ptr += GLINK_CALL_STUB_SIZE - 8 * 4;
15476 break;
15477
15478 case DT_PPC64_OPD:
15479 s = bfd_get_section_by_name (output_bfd, ".opd");
15480 if (s == NULL)
15481 continue;
15482 dyn.d_un.d_ptr = s->vma;
15483 break;
15484
15485 case DT_PPC64_OPT:
15486 if (htab->do_multi_toc && htab->multi_toc_needed)
15487 dyn.d_un.d_val |= PPC64_OPT_MULTI_TOC;
15488 break;
15489
15490 case DT_PPC64_OPDSZ:
15491 s = bfd_get_section_by_name (output_bfd, ".opd");
15492 if (s == NULL)
15493 continue;
15494 dyn.d_un.d_val = s->size;
15495 break;
15496
15497 case DT_PLTGOT:
15498 s = htab->elf.splt;
15499 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
15500 break;
15501
15502 case DT_JMPREL:
15503 s = htab->elf.srelplt;
15504 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
15505 break;
15506
15507 case DT_PLTRELSZ:
15508 dyn.d_un.d_val = htab->elf.srelplt->size;
15509 break;
15510
15511 case DT_RELASZ:
15512 /* Don't count procedure linkage table relocs in the
15513 overall reloc count. */
15514 s = htab->elf.srelplt;
15515 if (s == NULL)
15516 continue;
15517 dyn.d_un.d_val -= s->size;
15518 break;
15519
15520 case DT_RELA:
15521 /* We may not be using the standard ELF linker script.
15522 If .rela.plt is the first .rela section, we adjust
15523 DT_RELA to not include it. */
15524 s = htab->elf.srelplt;
15525 if (s == NULL)
15526 continue;
15527 if (dyn.d_un.d_ptr != s->output_section->vma + s->output_offset)
15528 continue;
15529 dyn.d_un.d_ptr += s->size;
15530 break;
15531 }
15532
15533 bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
15534 }
15535 }
15536
15537 if (htab->elf.sgot != NULL && htab->elf.sgot->size != 0
15538 && htab->elf.sgot->output_section != bfd_abs_section_ptr)
15539 {
15540 /* Fill in the first entry in the global offset table.
15541 We use it to hold the link-time TOCbase. */
15542 bfd_put_64 (output_bfd,
15543 elf_gp (output_bfd) + TOC_BASE_OFF,
15544 htab->elf.sgot->contents);
15545
15546 /* Set .got entry size. */
15547 elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize = 8;
15548 }
15549
15550 if (htab->elf.splt != NULL && htab->elf.splt->size != 0
15551 && htab->elf.splt->output_section != bfd_abs_section_ptr)
15552 {
15553 /* Set .plt entry size. */
15554 elf_section_data (htab->elf.splt->output_section)->this_hdr.sh_entsize
15555 = PLT_ENTRY_SIZE (htab);
15556 }
15557
15558 /* brlt is SEC_LINKER_CREATED, so we need to write out relocs for
15559 brlt ourselves if emitrelocations. */
15560 if (htab->brlt != NULL
15561 && htab->brlt->reloc_count != 0
15562 && !_bfd_elf_link_output_relocs (output_bfd,
15563 htab->brlt,
15564 elf_section_data (htab->brlt)->rela.hdr,
15565 elf_section_data (htab->brlt)->relocs,
15566 NULL))
15567 return FALSE;
15568
15569 if (htab->glink != NULL
15570 && htab->glink->reloc_count != 0
15571 && !_bfd_elf_link_output_relocs (output_bfd,
15572 htab->glink,
15573 elf_section_data (htab->glink)->rela.hdr,
15574 elf_section_data (htab->glink)->relocs,
15575 NULL))
15576 return FALSE;
15577
15578 if (htab->glink_eh_frame != NULL
15579 && htab->glink_eh_frame->size != 0)
15580 {
15581 bfd_vma val;
15582 bfd_byte *p;
15583 asection *stub_sec;
15584
15585 p = htab->glink_eh_frame->contents + sizeof (glink_eh_frame_cie);
15586 for (stub_sec = htab->params->stub_bfd->sections;
15587 stub_sec != NULL;
15588 stub_sec = stub_sec->next)
15589 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
15590 {
15591 /* FDE length. */
15592 p += 4;
15593 /* CIE pointer. */
15594 p += 4;
15595 /* Offset to stub section. */
15596 val = (stub_sec->output_section->vma
15597 + stub_sec->output_offset);
15598 val -= (htab->glink_eh_frame->output_section->vma
15599 + htab->glink_eh_frame->output_offset
15600 + (p - htab->glink_eh_frame->contents));
15601 if (val + 0x80000000 > 0xffffffff)
15602 {
15603 info->callbacks->einfo
15604 (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
15605 stub_sec->name);
15606 return FALSE;
15607 }
15608 bfd_put_32 (dynobj, val, p);
15609 p += 4;
15610 /* stub section size. */
15611 p += 4;
15612 /* Augmentation. */
15613 p += 1;
15614 /* Pad. */
15615 p += 7;
15616 }
15617 if (htab->glink != NULL && htab->glink->size != 0)
15618 {
15619 /* FDE length. */
15620 p += 4;
15621 /* CIE pointer. */
15622 p += 4;
15623 /* Offset to .glink. */
15624 val = (htab->glink->output_section->vma
15625 + htab->glink->output_offset
15626 + 8);
15627 val -= (htab->glink_eh_frame->output_section->vma
15628 + htab->glink_eh_frame->output_offset
15629 + (p - htab->glink_eh_frame->contents));
15630 if (val + 0x80000000 > 0xffffffff)
15631 {
15632 info->callbacks->einfo
15633 (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
15634 htab->glink->name);
15635 return FALSE;
15636 }
15637 bfd_put_32 (dynobj, val, p);
15638 p += 4;
15639 /* .glink size. */
15640 p += 4;
15641 /* Augmentation. */
15642 p += 1;
15643 /* Ops. */
15644 p += 7;
15645 }
15646
15647 if (htab->glink_eh_frame->sec_info_type == SEC_INFO_TYPE_EH_FRAME
15648 && !_bfd_elf_write_section_eh_frame (output_bfd, info,
15649 htab->glink_eh_frame,
15650 htab->glink_eh_frame->contents))
15651 return FALSE;
15652 }
15653
15654 /* We need to handle writing out multiple GOT sections ourselves,
15655 since we didn't add them to DYNOBJ. We know dynobj is the first
15656 bfd. */
15657 while ((dynobj = dynobj->link.next) != NULL)
15658 {
15659 asection *s;
15660
15661 if (!is_ppc64_elf (dynobj))
15662 continue;
15663
15664 s = ppc64_elf_tdata (dynobj)->got;
15665 if (s != NULL
15666 && s->size != 0
15667 && s->output_section != bfd_abs_section_ptr
15668 && !bfd_set_section_contents (output_bfd, s->output_section,
15669 s->contents, s->output_offset,
15670 s->size))
15671 return FALSE;
15672 s = ppc64_elf_tdata (dynobj)->relgot;
15673 if (s != NULL
15674 && s->size != 0
15675 && s->output_section != bfd_abs_section_ptr
15676 && !bfd_set_section_contents (output_bfd, s->output_section,
15677 s->contents, s->output_offset,
15678 s->size))
15679 return FALSE;
15680 }
15681
15682 return TRUE;
15683 }
15684
15685 #include "elf64-target.h"
15686
15687 /* FreeBSD support */
15688
15689 #undef TARGET_LITTLE_SYM
15690 #undef TARGET_LITTLE_NAME
15691
15692 #undef TARGET_BIG_SYM
15693 #define TARGET_BIG_SYM powerpc_elf64_fbsd_vec
15694 #undef TARGET_BIG_NAME
15695 #define TARGET_BIG_NAME "elf64-powerpc-freebsd"
15696
15697 #undef ELF_OSABI
15698 #define ELF_OSABI ELFOSABI_FREEBSD
15699
15700 #undef elf64_bed
15701 #define elf64_bed elf64_powerpc_fbsd_bed
15702
15703 #include "elf64-target.h"
15704
15705