projects / deliverable / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
sim: cr16/d10v: drop redundant call to sim_create_inferior
[deliverable/binutils-gdb.git] / bfd / elf64-ppc.c
1 /* PowerPC64-specific support for 64-bit ELF.
2 Copyright (C) 1999-2015 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
177 #define ADDIS_R12_R2 0x3d820000 /* addis %r12,%r2,xxx@ha */
178 #define ADDIS_R12_R12 0x3d8c0000 /* addis %r12,%r12,xxx@ha */
179 #define LD_R12_0R12 0xe98c0000 /* ld %r12,xxx@l(%r12) */
180
181 /* glink call stub instructions. We enter with the index in R0. */
182 #define GLINK_CALL_STUB_SIZE (16*4)
183 /* 0: */
184 /* .quad plt0-1f */
185 /* __glink: */
186 #define MFLR_R12 0x7d8802a6 /* mflr %12 */
187 #define BCL_20_31 0x429f0005 /* bcl 20,31,1f */
188 /* 1: */
189 #define MFLR_R11 0x7d6802a6 /* mflr %11 */
190 /* ld %2,(0b-1b)(%11) */
191 #define MTLR_R12 0x7d8803a6 /* mtlr %12 */
192 #define ADD_R11_R2_R11 0x7d625a14 /* add %11,%2,%11 */
193 /* ld %12,0(%11) */
194 /* ld %2,8(%11) */
195 /* mtctr %12 */
196 /* ld %11,16(%11) */
197 /* bctr */
198 #define MFLR_R0 0x7c0802a6 /* mflr %r0 */
199 #define MTLR_R0 0x7c0803a6 /* mtlr %r0 */
200 #define SUB_R12_R12_R11 0x7d8b6050 /* subf %r12,%r11,%r12 */
201 #define ADDI_R0_R12 0x380c0000 /* addi %r0,%r12,0 */
202 #define SRDI_R0_R0_2 0x7800f082 /* rldicl %r0,%r0,62,2 */
203
204 /* Pad with this. */
205 #define NOP 0x60000000
206
207 /* Some other nops. */
208 #define CROR_151515 0x4def7b82
209 #define CROR_313131 0x4ffffb82
210
211 /* .glink entries for the first 32k functions are two instructions. */
212 #define LI_R0_0 0x38000000 /* li %r0,0 */
213 #define B_DOT 0x48000000 /* b . */
214
215 /* After that, we need two instructions to load the index, followed by
216 a branch. */
217 #define LIS_R0_0 0x3c000000 /* lis %r0,0 */
218 #define ORI_R0_R0_0 0x60000000 /* ori %r0,%r0,0 */
219
220 /* Instructions used by the save and restore reg functions. */
221 #define STD_R0_0R1 0xf8010000 /* std %r0,0(%r1) */
222 #define STD_R0_0R12 0xf80c0000 /* std %r0,0(%r12) */
223 #define LD_R0_0R1 0xe8010000 /* ld %r0,0(%r1) */
224 #define LD_R0_0R12 0xe80c0000 /* ld %r0,0(%r12) */
225 #define STFD_FR0_0R1 0xd8010000 /* stfd %fr0,0(%r1) */
226 #define LFD_FR0_0R1 0xc8010000 /* lfd %fr0,0(%r1) */
227 #define LI_R12_0 0x39800000 /* li %r12,0 */
228 #define STVX_VR0_R12_R0 0x7c0c01ce /* stvx %v0,%r12,%r0 */
229 #define LVX_VR0_R12_R0 0x7c0c00ce /* lvx %v0,%r12,%r0 */
230 #define MTLR_R0 0x7c0803a6 /* mtlr %r0 */
231 #define BLR 0x4e800020 /* blr */
232
233 /* Since .opd is an array of descriptors and each entry will end up
234 with identical R_PPC64_RELATIVE relocs, there is really no need to
235 propagate .opd relocs; The dynamic linker should be taught to
236 relocate .opd without reloc entries. */
237 #ifndef NO_OPD_RELOCS
238 #define NO_OPD_RELOCS 0
239 #endif
240
241 #ifndef ARRAY_SIZE
242 #define ARRAY_SIZE(a) (sizeof (a) / sizeof ((a)[0]))
243 #endif
244
245 static inline int
246 abiversion (bfd *abfd)
247 {
248 return elf_elfheader (abfd)->e_flags & EF_PPC64_ABI;
249 }
250
251 static inline void
252 set_abiversion (bfd *abfd, int ver)
253 {
254 elf_elfheader (abfd)->e_flags &= ~EF_PPC64_ABI;
255 elf_elfheader (abfd)->e_flags |= ver & EF_PPC64_ABI;
256 }
257 \f
258 #define ONES(n) (((bfd_vma) 1 << ((n) - 1) << 1) - 1)
259
260 /* Relocation HOWTO's. */
261 static reloc_howto_type *ppc64_elf_howto_table[(int) R_PPC64_max];
262
263 static reloc_howto_type ppc64_elf_howto_raw[] = {
264 /* This reloc does nothing. */
265 HOWTO (R_PPC64_NONE, /* type */
266 0, /* rightshift */
267 3, /* size (0 = byte, 1 = short, 2 = long) */
268 0, /* bitsize */
269 FALSE, /* pc_relative */
270 0, /* bitpos */
271 complain_overflow_dont, /* complain_on_overflow */
272 bfd_elf_generic_reloc, /* special_function */
273 "R_PPC64_NONE", /* name */
274 FALSE, /* partial_inplace */
275 0, /* src_mask */
276 0, /* dst_mask */
277 FALSE), /* pcrel_offset */
278
279 /* A standard 32 bit relocation. */
280 HOWTO (R_PPC64_ADDR32, /* type */
281 0, /* rightshift */
282 2, /* size (0 = byte, 1 = short, 2 = long) */
283 32, /* bitsize */
284 FALSE, /* pc_relative */
285 0, /* bitpos */
286 complain_overflow_bitfield, /* complain_on_overflow */
287 bfd_elf_generic_reloc, /* special_function */
288 "R_PPC64_ADDR32", /* name */
289 FALSE, /* partial_inplace */
290 0, /* src_mask */
291 0xffffffff, /* dst_mask */
292 FALSE), /* pcrel_offset */
293
294 /* An absolute 26 bit branch; the lower two bits must be zero.
295 FIXME: we don't check that, we just clear them. */
296 HOWTO (R_PPC64_ADDR24, /* type */
297 0, /* rightshift */
298 2, /* size (0 = byte, 1 = short, 2 = long) */
299 26, /* bitsize */
300 FALSE, /* pc_relative */
301 0, /* bitpos */
302 complain_overflow_bitfield, /* complain_on_overflow */
303 bfd_elf_generic_reloc, /* special_function */
304 "R_PPC64_ADDR24", /* name */
305 FALSE, /* partial_inplace */
306 0, /* src_mask */
307 0x03fffffc, /* dst_mask */
308 FALSE), /* pcrel_offset */
309
310 /* A standard 16 bit relocation. */
311 HOWTO (R_PPC64_ADDR16, /* type */
312 0, /* rightshift */
313 1, /* size (0 = byte, 1 = short, 2 = long) */
314 16, /* bitsize */
315 FALSE, /* pc_relative */
316 0, /* bitpos */
317 complain_overflow_bitfield, /* complain_on_overflow */
318 bfd_elf_generic_reloc, /* special_function */
319 "R_PPC64_ADDR16", /* name */
320 FALSE, /* partial_inplace */
321 0, /* src_mask */
322 0xffff, /* dst_mask */
323 FALSE), /* pcrel_offset */
324
325 /* A 16 bit relocation without overflow. */
326 HOWTO (R_PPC64_ADDR16_LO, /* type */
327 0, /* rightshift */
328 1, /* size (0 = byte, 1 = short, 2 = long) */
329 16, /* bitsize */
330 FALSE, /* pc_relative */
331 0, /* bitpos */
332 complain_overflow_dont,/* complain_on_overflow */
333 bfd_elf_generic_reloc, /* special_function */
334 "R_PPC64_ADDR16_LO", /* name */
335 FALSE, /* partial_inplace */
336 0, /* src_mask */
337 0xffff, /* dst_mask */
338 FALSE), /* pcrel_offset */
339
340 /* Bits 16-31 of an address. */
341 HOWTO (R_PPC64_ADDR16_HI, /* type */
342 16, /* rightshift */
343 1, /* size (0 = byte, 1 = short, 2 = long) */
344 16, /* bitsize */
345 FALSE, /* pc_relative */
346 0, /* bitpos */
347 complain_overflow_signed, /* complain_on_overflow */
348 bfd_elf_generic_reloc, /* special_function */
349 "R_PPC64_ADDR16_HI", /* name */
350 FALSE, /* partial_inplace */
351 0, /* src_mask */
352 0xffff, /* dst_mask */
353 FALSE), /* pcrel_offset */
354
355 /* Bits 16-31 of an address, plus 1 if the contents of the low 16
356 bits, treated as a signed number, is negative. */
357 HOWTO (R_PPC64_ADDR16_HA, /* type */
358 16, /* rightshift */
359 1, /* size (0 = byte, 1 = short, 2 = long) */
360 16, /* bitsize */
361 FALSE, /* pc_relative */
362 0, /* bitpos */
363 complain_overflow_signed, /* complain_on_overflow */
364 ppc64_elf_ha_reloc, /* special_function */
365 "R_PPC64_ADDR16_HA", /* name */
366 FALSE, /* partial_inplace */
367 0, /* src_mask */
368 0xffff, /* dst_mask */
369 FALSE), /* pcrel_offset */
370
371 /* An absolute 16 bit branch; the lower two bits must be zero.
372 FIXME: we don't check that, we just clear them. */
373 HOWTO (R_PPC64_ADDR14, /* type */
374 0, /* rightshift */
375 2, /* size (0 = byte, 1 = short, 2 = long) */
376 16, /* bitsize */
377 FALSE, /* pc_relative */
378 0, /* bitpos */
379 complain_overflow_signed, /* complain_on_overflow */
380 ppc64_elf_branch_reloc, /* special_function */
381 "R_PPC64_ADDR14", /* name */
382 FALSE, /* partial_inplace */
383 0, /* src_mask */
384 0x0000fffc, /* dst_mask */
385 FALSE), /* pcrel_offset */
386
387 /* An absolute 16 bit branch, for which bit 10 should be set to
388 indicate that the branch is expected to be taken. The lower two
389 bits must be zero. */
390 HOWTO (R_PPC64_ADDR14_BRTAKEN, /* type */
391 0, /* rightshift */
392 2, /* size (0 = byte, 1 = short, 2 = long) */
393 16, /* bitsize */
394 FALSE, /* pc_relative */
395 0, /* bitpos */
396 complain_overflow_signed, /* complain_on_overflow */
397 ppc64_elf_brtaken_reloc, /* special_function */
398 "R_PPC64_ADDR14_BRTAKEN",/* name */
399 FALSE, /* partial_inplace */
400 0, /* src_mask */
401 0x0000fffc, /* dst_mask */
402 FALSE), /* pcrel_offset */
403
404 /* An absolute 16 bit branch, for which bit 10 should be set to
405 indicate that the branch is not expected to be taken. The lower
406 two bits must be zero. */
407 HOWTO (R_PPC64_ADDR14_BRNTAKEN, /* type */
408 0, /* rightshift */
409 2, /* size (0 = byte, 1 = short, 2 = long) */
410 16, /* bitsize */
411 FALSE, /* pc_relative */
412 0, /* bitpos */
413 complain_overflow_signed, /* complain_on_overflow */
414 ppc64_elf_brtaken_reloc, /* special_function */
415 "R_PPC64_ADDR14_BRNTAKEN",/* name */
416 FALSE, /* partial_inplace */
417 0, /* src_mask */
418 0x0000fffc, /* dst_mask */
419 FALSE), /* pcrel_offset */
420
421 /* A relative 26 bit branch; the lower two bits must be zero. */
422 HOWTO (R_PPC64_REL24, /* type */
423 0, /* rightshift */
424 2, /* size (0 = byte, 1 = short, 2 = long) */
425 26, /* bitsize */
426 TRUE, /* pc_relative */
427 0, /* bitpos */
428 complain_overflow_signed, /* complain_on_overflow */
429 ppc64_elf_branch_reloc, /* special_function */
430 "R_PPC64_REL24", /* name */
431 FALSE, /* partial_inplace */
432 0, /* src_mask */
433 0x03fffffc, /* dst_mask */
434 TRUE), /* pcrel_offset */
435
436 /* A relative 16 bit branch; the lower two bits must be zero. */
437 HOWTO (R_PPC64_REL14, /* type */
438 0, /* rightshift */
439 2, /* size (0 = byte, 1 = short, 2 = long) */
440 16, /* bitsize */
441 TRUE, /* pc_relative */
442 0, /* bitpos */
443 complain_overflow_signed, /* complain_on_overflow */
444 ppc64_elf_branch_reloc, /* special_function */
445 "R_PPC64_REL14", /* name */
446 FALSE, /* partial_inplace */
447 0, /* src_mask */
448 0x0000fffc, /* dst_mask */
449 TRUE), /* pcrel_offset */
450
451 /* A relative 16 bit branch. Bit 10 should be set to indicate that
452 the branch is expected to be taken. The lower two bits must be
453 zero. */
454 HOWTO (R_PPC64_REL14_BRTAKEN, /* type */
455 0, /* rightshift */
456 2, /* size (0 = byte, 1 = short, 2 = long) */
457 16, /* bitsize */
458 TRUE, /* pc_relative */
459 0, /* bitpos */
460 complain_overflow_signed, /* complain_on_overflow */
461 ppc64_elf_brtaken_reloc, /* special_function */
462 "R_PPC64_REL14_BRTAKEN", /* name */
463 FALSE, /* partial_inplace */
464 0, /* src_mask */
465 0x0000fffc, /* dst_mask */
466 TRUE), /* pcrel_offset */
467
468 /* A relative 16 bit branch. Bit 10 should be set to indicate that
469 the branch is not expected to be taken. The lower two bits must
470 be zero. */
471 HOWTO (R_PPC64_REL14_BRNTAKEN, /* type */
472 0, /* rightshift */
473 2, /* size (0 = byte, 1 = short, 2 = long) */
474 16, /* bitsize */
475 TRUE, /* pc_relative */
476 0, /* bitpos */
477 complain_overflow_signed, /* complain_on_overflow */
478 ppc64_elf_brtaken_reloc, /* special_function */
479 "R_PPC64_REL14_BRNTAKEN",/* name */
480 FALSE, /* partial_inplace */
481 0, /* src_mask */
482 0x0000fffc, /* dst_mask */
483 TRUE), /* pcrel_offset */
484
485 /* Like R_PPC64_ADDR16, but referring to the GOT table entry for the
486 symbol. */
487 HOWTO (R_PPC64_GOT16, /* type */
488 0, /* rightshift */
489 1, /* size (0 = byte, 1 = short, 2 = long) */
490 16, /* bitsize */
491 FALSE, /* pc_relative */
492 0, /* bitpos */
493 complain_overflow_signed, /* complain_on_overflow */
494 ppc64_elf_unhandled_reloc, /* special_function */
495 "R_PPC64_GOT16", /* name */
496 FALSE, /* partial_inplace */
497 0, /* src_mask */
498 0xffff, /* dst_mask */
499 FALSE), /* pcrel_offset */
500
501 /* Like R_PPC64_ADDR16_LO, but referring to the GOT table entry for
502 the symbol. */
503 HOWTO (R_PPC64_GOT16_LO, /* type */
504 0, /* rightshift */
505 1, /* size (0 = byte, 1 = short, 2 = long) */
506 16, /* bitsize */
507 FALSE, /* pc_relative */
508 0, /* bitpos */
509 complain_overflow_dont, /* complain_on_overflow */
510 ppc64_elf_unhandled_reloc, /* special_function */
511 "R_PPC64_GOT16_LO", /* name */
512 FALSE, /* partial_inplace */
513 0, /* src_mask */
514 0xffff, /* dst_mask */
515 FALSE), /* pcrel_offset */
516
517 /* Like R_PPC64_ADDR16_HI, but referring to the GOT table entry for
518 the symbol. */
519 HOWTO (R_PPC64_GOT16_HI, /* type */
520 16, /* rightshift */
521 1, /* size (0 = byte, 1 = short, 2 = long) */
522 16, /* bitsize */
523 FALSE, /* pc_relative */
524 0, /* bitpos */
525 complain_overflow_signed,/* complain_on_overflow */
526 ppc64_elf_unhandled_reloc, /* special_function */
527 "R_PPC64_GOT16_HI", /* name */
528 FALSE, /* partial_inplace */
529 0, /* src_mask */
530 0xffff, /* dst_mask */
531 FALSE), /* pcrel_offset */
532
533 /* Like R_PPC64_ADDR16_HA, but referring to the GOT table entry for
534 the symbol. */
535 HOWTO (R_PPC64_GOT16_HA, /* type */
536 16, /* rightshift */
537 1, /* size (0 = byte, 1 = short, 2 = long) */
538 16, /* bitsize */
539 FALSE, /* pc_relative */
540 0, /* bitpos */
541 complain_overflow_signed,/* complain_on_overflow */
542 ppc64_elf_unhandled_reloc, /* special_function */
543 "R_PPC64_GOT16_HA", /* name */
544 FALSE, /* partial_inplace */
545 0, /* src_mask */
546 0xffff, /* dst_mask */
547 FALSE), /* pcrel_offset */
548
549 /* This is used only by the dynamic linker. The symbol should exist
550 both in the object being run and in some shared library. The
551 dynamic linker copies the data addressed by the symbol from the
552 shared library into the object, because the object being
553 run has to have the data at some particular address. */
554 HOWTO (R_PPC64_COPY, /* type */
555 0, /* rightshift */
556 0, /* this one is variable size */
557 0, /* bitsize */
558 FALSE, /* pc_relative */
559 0, /* bitpos */
560 complain_overflow_dont, /* complain_on_overflow */
561 ppc64_elf_unhandled_reloc, /* special_function */
562 "R_PPC64_COPY", /* name */
563 FALSE, /* partial_inplace */
564 0, /* src_mask */
565 0, /* dst_mask */
566 FALSE), /* pcrel_offset */
567
568 /* Like R_PPC64_ADDR64, but used when setting global offset table
569 entries. */
570 HOWTO (R_PPC64_GLOB_DAT, /* type */
571 0, /* rightshift */
572 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
573 64, /* bitsize */
574 FALSE, /* pc_relative */
575 0, /* bitpos */
576 complain_overflow_dont, /* complain_on_overflow */
577 ppc64_elf_unhandled_reloc, /* special_function */
578 "R_PPC64_GLOB_DAT", /* name */
579 FALSE, /* partial_inplace */
580 0, /* src_mask */
581 ONES (64), /* dst_mask */
582 FALSE), /* pcrel_offset */
583
584 /* Created by the link editor. Marks a procedure linkage table
585 entry for a symbol. */
586 HOWTO (R_PPC64_JMP_SLOT, /* type */
587 0, /* rightshift */
588 0, /* size (0 = byte, 1 = short, 2 = long) */
589 0, /* bitsize */
590 FALSE, /* pc_relative */
591 0, /* bitpos */
592 complain_overflow_dont, /* complain_on_overflow */
593 ppc64_elf_unhandled_reloc, /* special_function */
594 "R_PPC64_JMP_SLOT", /* name */
595 FALSE, /* partial_inplace */
596 0, /* src_mask */
597 0, /* dst_mask */
598 FALSE), /* pcrel_offset */
599
600 /* Used only by the dynamic linker. When the object is run, this
601 doubleword64 is set to the load address of the object, plus the
602 addend. */
603 HOWTO (R_PPC64_RELATIVE, /* type */
604 0, /* rightshift */
605 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
606 64, /* bitsize */
607 FALSE, /* pc_relative */
608 0, /* bitpos */
609 complain_overflow_dont, /* complain_on_overflow */
610 bfd_elf_generic_reloc, /* special_function */
611 "R_PPC64_RELATIVE", /* name */
612 FALSE, /* partial_inplace */
613 0, /* src_mask */
614 ONES (64), /* dst_mask */
615 FALSE), /* pcrel_offset */
616
617 /* Like R_PPC64_ADDR32, but may be unaligned. */
618 HOWTO (R_PPC64_UADDR32, /* type */
619 0, /* rightshift */
620 2, /* size (0 = byte, 1 = short, 2 = long) */
621 32, /* bitsize */
622 FALSE, /* pc_relative */
623 0, /* bitpos */
624 complain_overflow_bitfield, /* complain_on_overflow */
625 bfd_elf_generic_reloc, /* special_function */
626 "R_PPC64_UADDR32", /* name */
627 FALSE, /* partial_inplace */
628 0, /* src_mask */
629 0xffffffff, /* dst_mask */
630 FALSE), /* pcrel_offset */
631
632 /* Like R_PPC64_ADDR16, but may be unaligned. */
633 HOWTO (R_PPC64_UADDR16, /* type */
634 0, /* rightshift */
635 1, /* size (0 = byte, 1 = short, 2 = long) */
636 16, /* bitsize */
637 FALSE, /* pc_relative */
638 0, /* bitpos */
639 complain_overflow_bitfield, /* complain_on_overflow */
640 bfd_elf_generic_reloc, /* special_function */
641 "R_PPC64_UADDR16", /* name */
642 FALSE, /* partial_inplace */
643 0, /* src_mask */
644 0xffff, /* dst_mask */
645 FALSE), /* pcrel_offset */
646
647 /* 32-bit PC relative. */
648 HOWTO (R_PPC64_REL32, /* type */
649 0, /* rightshift */
650 2, /* size (0 = byte, 1 = short, 2 = long) */
651 32, /* bitsize */
652 TRUE, /* pc_relative */
653 0, /* bitpos */
654 complain_overflow_signed, /* complain_on_overflow */
655 bfd_elf_generic_reloc, /* special_function */
656 "R_PPC64_REL32", /* name */
657 FALSE, /* partial_inplace */
658 0, /* src_mask */
659 0xffffffff, /* dst_mask */
660 TRUE), /* pcrel_offset */
661
662 /* 32-bit relocation to the symbol's procedure linkage table. */
663 HOWTO (R_PPC64_PLT32, /* type */
664 0, /* rightshift */
665 2, /* size (0 = byte, 1 = short, 2 = long) */
666 32, /* bitsize */
667 FALSE, /* pc_relative */
668 0, /* bitpos */
669 complain_overflow_bitfield, /* complain_on_overflow */
670 ppc64_elf_unhandled_reloc, /* special_function */
671 "R_PPC64_PLT32", /* name */
672 FALSE, /* partial_inplace */
673 0, /* src_mask */
674 0xffffffff, /* dst_mask */
675 FALSE), /* pcrel_offset */
676
677 /* 32-bit PC relative relocation to the symbol's procedure linkage table.
678 FIXME: R_PPC64_PLTREL32 not supported. */
679 HOWTO (R_PPC64_PLTREL32, /* type */
680 0, /* rightshift */
681 2, /* size (0 = byte, 1 = short, 2 = long) */
682 32, /* bitsize */
683 TRUE, /* pc_relative */
684 0, /* bitpos */
685 complain_overflow_signed, /* complain_on_overflow */
686 bfd_elf_generic_reloc, /* special_function */
687 "R_PPC64_PLTREL32", /* name */
688 FALSE, /* partial_inplace */
689 0, /* src_mask */
690 0xffffffff, /* dst_mask */
691 TRUE), /* pcrel_offset */
692
693 /* Like R_PPC64_ADDR16_LO, but referring to the PLT table entry for
694 the symbol. */
695 HOWTO (R_PPC64_PLT16_LO, /* type */
696 0, /* rightshift */
697 1, /* size (0 = byte, 1 = short, 2 = long) */
698 16, /* bitsize */
699 FALSE, /* pc_relative */
700 0, /* bitpos */
701 complain_overflow_dont, /* complain_on_overflow */
702 ppc64_elf_unhandled_reloc, /* special_function */
703 "R_PPC64_PLT16_LO", /* name */
704 FALSE, /* partial_inplace */
705 0, /* src_mask */
706 0xffff, /* dst_mask */
707 FALSE), /* pcrel_offset */
708
709 /* Like R_PPC64_ADDR16_HI, but referring to the PLT table entry for
710 the symbol. */
711 HOWTO (R_PPC64_PLT16_HI, /* type */
712 16, /* rightshift */
713 1, /* size (0 = byte, 1 = short, 2 = long) */
714 16, /* bitsize */
715 FALSE, /* pc_relative */
716 0, /* bitpos */
717 complain_overflow_signed, /* complain_on_overflow */
718 ppc64_elf_unhandled_reloc, /* special_function */
719 "R_PPC64_PLT16_HI", /* name */
720 FALSE, /* partial_inplace */
721 0, /* src_mask */
722 0xffff, /* dst_mask */
723 FALSE), /* pcrel_offset */
724
725 /* Like R_PPC64_ADDR16_HA, but referring to the PLT table entry for
726 the symbol. */
727 HOWTO (R_PPC64_PLT16_HA, /* type */
728 16, /* rightshift */
729 1, /* size (0 = byte, 1 = short, 2 = long) */
730 16, /* bitsize */
731 FALSE, /* pc_relative */
732 0, /* bitpos */
733 complain_overflow_signed, /* complain_on_overflow */
734 ppc64_elf_unhandled_reloc, /* special_function */
735 "R_PPC64_PLT16_HA", /* name */
736 FALSE, /* partial_inplace */
737 0, /* src_mask */
738 0xffff, /* dst_mask */
739 FALSE), /* pcrel_offset */
740
741 /* 16-bit section relative relocation. */
742 HOWTO (R_PPC64_SECTOFF, /* type */
743 0, /* rightshift */
744 1, /* size (0 = byte, 1 = short, 2 = long) */
745 16, /* bitsize */
746 FALSE, /* pc_relative */
747 0, /* bitpos */
748 complain_overflow_signed, /* complain_on_overflow */
749 ppc64_elf_sectoff_reloc, /* special_function */
750 "R_PPC64_SECTOFF", /* name */
751 FALSE, /* partial_inplace */
752 0, /* src_mask */
753 0xffff, /* dst_mask */
754 FALSE), /* pcrel_offset */
755
756 /* Like R_PPC64_SECTOFF, but no overflow warning. */
757 HOWTO (R_PPC64_SECTOFF_LO, /* type */
758 0, /* rightshift */
759 1, /* size (0 = byte, 1 = short, 2 = long) */
760 16, /* bitsize */
761 FALSE, /* pc_relative */
762 0, /* bitpos */
763 complain_overflow_dont, /* complain_on_overflow */
764 ppc64_elf_sectoff_reloc, /* special_function */
765 "R_PPC64_SECTOFF_LO", /* name */
766 FALSE, /* partial_inplace */
767 0, /* src_mask */
768 0xffff, /* dst_mask */
769 FALSE), /* pcrel_offset */
770
771 /* 16-bit upper half section relative relocation. */
772 HOWTO (R_PPC64_SECTOFF_HI, /* type */
773 16, /* rightshift */
774 1, /* size (0 = byte, 1 = short, 2 = long) */
775 16, /* bitsize */
776 FALSE, /* pc_relative */
777 0, /* bitpos */
778 complain_overflow_signed, /* complain_on_overflow */
779 ppc64_elf_sectoff_reloc, /* special_function */
780 "R_PPC64_SECTOFF_HI", /* name */
781 FALSE, /* partial_inplace */
782 0, /* src_mask */
783 0xffff, /* dst_mask */
784 FALSE), /* pcrel_offset */
785
786 /* 16-bit upper half adjusted section relative relocation. */
787 HOWTO (R_PPC64_SECTOFF_HA, /* type */
788 16, /* rightshift */
789 1, /* size (0 = byte, 1 = short, 2 = long) */
790 16, /* bitsize */
791 FALSE, /* pc_relative */
792 0, /* bitpos */
793 complain_overflow_signed, /* complain_on_overflow */
794 ppc64_elf_sectoff_ha_reloc, /* special_function */
795 "R_PPC64_SECTOFF_HA", /* name */
796 FALSE, /* partial_inplace */
797 0, /* src_mask */
798 0xffff, /* dst_mask */
799 FALSE), /* pcrel_offset */
800
801 /* Like R_PPC64_REL24 without touching the two least significant bits. */
802 HOWTO (R_PPC64_REL30, /* type */
803 2, /* rightshift */
804 2, /* size (0 = byte, 1 = short, 2 = long) */
805 30, /* bitsize */
806 TRUE, /* pc_relative */
807 0, /* bitpos */
808 complain_overflow_dont, /* complain_on_overflow */
809 bfd_elf_generic_reloc, /* special_function */
810 "R_PPC64_REL30", /* name */
811 FALSE, /* partial_inplace */
812 0, /* src_mask */
813 0xfffffffc, /* dst_mask */
814 TRUE), /* pcrel_offset */
815
816 /* Relocs in the 64-bit PowerPC ELF ABI, not in the 32-bit ABI. */
817
818 /* A standard 64-bit relocation. */
819 HOWTO (R_PPC64_ADDR64, /* type */
820 0, /* rightshift */
821 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
822 64, /* bitsize */
823 FALSE, /* pc_relative */
824 0, /* bitpos */
825 complain_overflow_dont, /* complain_on_overflow */
826 bfd_elf_generic_reloc, /* special_function */
827 "R_PPC64_ADDR64", /* name */
828 FALSE, /* partial_inplace */
829 0, /* src_mask */
830 ONES (64), /* dst_mask */
831 FALSE), /* pcrel_offset */
832
833 /* The bits 32-47 of an address. */
834 HOWTO (R_PPC64_ADDR16_HIGHER, /* type */
835 32, /* rightshift */
836 1, /* size (0 = byte, 1 = short, 2 = long) */
837 16, /* bitsize */
838 FALSE, /* pc_relative */
839 0, /* bitpos */
840 complain_overflow_dont, /* complain_on_overflow */
841 bfd_elf_generic_reloc, /* special_function */
842 "R_PPC64_ADDR16_HIGHER", /* name */
843 FALSE, /* partial_inplace */
844 0, /* src_mask */
845 0xffff, /* dst_mask */
846 FALSE), /* pcrel_offset */
847
848 /* The bits 32-47 of an address, plus 1 if the contents of the low
849 16 bits, treated as a signed number, is negative. */
850 HOWTO (R_PPC64_ADDR16_HIGHERA, /* type */
851 32, /* rightshift */
852 1, /* size (0 = byte, 1 = short, 2 = long) */
853 16, /* bitsize */
854 FALSE, /* pc_relative */
855 0, /* bitpos */
856 complain_overflow_dont, /* complain_on_overflow */
857 ppc64_elf_ha_reloc, /* special_function */
858 "R_PPC64_ADDR16_HIGHERA", /* name */
859 FALSE, /* partial_inplace */
860 0, /* src_mask */
861 0xffff, /* dst_mask */
862 FALSE), /* pcrel_offset */
863
864 /* The bits 48-63 of an address. */
865 HOWTO (R_PPC64_ADDR16_HIGHEST,/* type */
866 48, /* rightshift */
867 1, /* size (0 = byte, 1 = short, 2 = long) */
868 16, /* bitsize */
869 FALSE, /* pc_relative */
870 0, /* bitpos */
871 complain_overflow_dont, /* complain_on_overflow */
872 bfd_elf_generic_reloc, /* special_function */
873 "R_PPC64_ADDR16_HIGHEST", /* name */
874 FALSE, /* partial_inplace */
875 0, /* src_mask */
876 0xffff, /* dst_mask */
877 FALSE), /* pcrel_offset */
878
879 /* The bits 48-63 of an address, plus 1 if the contents of the low
880 16 bits, treated as a signed number, is negative. */
881 HOWTO (R_PPC64_ADDR16_HIGHESTA,/* type */
882 48, /* rightshift */
883 1, /* size (0 = byte, 1 = short, 2 = long) */
884 16, /* bitsize */
885 FALSE, /* pc_relative */
886 0, /* bitpos */
887 complain_overflow_dont, /* complain_on_overflow */
888 ppc64_elf_ha_reloc, /* special_function */
889 "R_PPC64_ADDR16_HIGHESTA", /* name */
890 FALSE, /* partial_inplace */
891 0, /* src_mask */
892 0xffff, /* dst_mask */
893 FALSE), /* pcrel_offset */
894
895 /* Like ADDR64, but may be unaligned. */
896 HOWTO (R_PPC64_UADDR64, /* type */
897 0, /* rightshift */
898 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
899 64, /* bitsize */
900 FALSE, /* pc_relative */
901 0, /* bitpos */
902 complain_overflow_dont, /* complain_on_overflow */
903 bfd_elf_generic_reloc, /* special_function */
904 "R_PPC64_UADDR64", /* name */
905 FALSE, /* partial_inplace */
906 0, /* src_mask */
907 ONES (64), /* dst_mask */
908 FALSE), /* pcrel_offset */
909
910 /* 64-bit relative relocation. */
911 HOWTO (R_PPC64_REL64, /* type */
912 0, /* rightshift */
913 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
914 64, /* bitsize */
915 TRUE, /* pc_relative */
916 0, /* bitpos */
917 complain_overflow_dont, /* complain_on_overflow */
918 bfd_elf_generic_reloc, /* special_function */
919 "R_PPC64_REL64", /* name */
920 FALSE, /* partial_inplace */
921 0, /* src_mask */
922 ONES (64), /* dst_mask */
923 TRUE), /* pcrel_offset */
924
925 /* 64-bit relocation to the symbol's procedure linkage table. */
926 HOWTO (R_PPC64_PLT64, /* type */
927 0, /* rightshift */
928 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
929 64, /* bitsize */
930 FALSE, /* pc_relative */
931 0, /* bitpos */
932 complain_overflow_dont, /* complain_on_overflow */
933 ppc64_elf_unhandled_reloc, /* special_function */
934 "R_PPC64_PLT64", /* name */
935 FALSE, /* partial_inplace */
936 0, /* src_mask */
937 ONES (64), /* dst_mask */
938 FALSE), /* pcrel_offset */
939
940 /* 64-bit PC relative relocation to the symbol's procedure linkage
941 table. */
942 /* FIXME: R_PPC64_PLTREL64 not supported. */
943 HOWTO (R_PPC64_PLTREL64, /* type */
944 0, /* rightshift */
945 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
946 64, /* bitsize */
947 TRUE, /* pc_relative */
948 0, /* bitpos */
949 complain_overflow_dont, /* complain_on_overflow */
950 ppc64_elf_unhandled_reloc, /* special_function */
951 "R_PPC64_PLTREL64", /* name */
952 FALSE, /* partial_inplace */
953 0, /* src_mask */
954 ONES (64), /* dst_mask */
955 TRUE), /* pcrel_offset */
956
957 /* 16 bit TOC-relative relocation. */
958
959 /* R_PPC64_TOC16 47 half16* S + A - .TOC. */
960 HOWTO (R_PPC64_TOC16, /* type */
961 0, /* rightshift */
962 1, /* size (0 = byte, 1 = short, 2 = long) */
963 16, /* bitsize */
964 FALSE, /* pc_relative */
965 0, /* bitpos */
966 complain_overflow_signed, /* complain_on_overflow */
967 ppc64_elf_toc_reloc, /* special_function */
968 "R_PPC64_TOC16", /* name */
969 FALSE, /* partial_inplace */
970 0, /* src_mask */
971 0xffff, /* dst_mask */
972 FALSE), /* pcrel_offset */
973
974 /* 16 bit TOC-relative relocation without overflow. */
975
976 /* R_PPC64_TOC16_LO 48 half16 #lo (S + A - .TOC.) */
977 HOWTO (R_PPC64_TOC16_LO, /* type */
978 0, /* rightshift */
979 1, /* size (0 = byte, 1 = short, 2 = long) */
980 16, /* bitsize */
981 FALSE, /* pc_relative */
982 0, /* bitpos */
983 complain_overflow_dont, /* complain_on_overflow */
984 ppc64_elf_toc_reloc, /* special_function */
985 "R_PPC64_TOC16_LO", /* name */
986 FALSE, /* partial_inplace */
987 0, /* src_mask */
988 0xffff, /* dst_mask */
989 FALSE), /* pcrel_offset */
990
991 /* 16 bit TOC-relative relocation, high 16 bits. */
992
993 /* R_PPC64_TOC16_HI 49 half16 #hi (S + A - .TOC.) */
994 HOWTO (R_PPC64_TOC16_HI, /* type */
995 16, /* rightshift */
996 1, /* size (0 = byte, 1 = short, 2 = long) */
997 16, /* bitsize */
998 FALSE, /* pc_relative */
999 0, /* bitpos */
1000 complain_overflow_signed, /* complain_on_overflow */
1001 ppc64_elf_toc_reloc, /* special_function */
1002 "R_PPC64_TOC16_HI", /* name */
1003 FALSE, /* partial_inplace */
1004 0, /* src_mask */
1005 0xffff, /* dst_mask */
1006 FALSE), /* pcrel_offset */
1007
1008 /* 16 bit TOC-relative relocation, high 16 bits, plus 1 if the
1009 contents of the low 16 bits, treated as a signed number, is
1010 negative. */
1011
1012 /* R_PPC64_TOC16_HA 50 half16 #ha (S + A - .TOC.) */
1013 HOWTO (R_PPC64_TOC16_HA, /* type */
1014 16, /* rightshift */
1015 1, /* size (0 = byte, 1 = short, 2 = long) */
1016 16, /* bitsize */
1017 FALSE, /* pc_relative */
1018 0, /* bitpos */
1019 complain_overflow_signed, /* complain_on_overflow */
1020 ppc64_elf_toc_ha_reloc, /* special_function */
1021 "R_PPC64_TOC16_HA", /* name */
1022 FALSE, /* partial_inplace */
1023 0, /* src_mask */
1024 0xffff, /* dst_mask */
1025 FALSE), /* pcrel_offset */
1026
1027 /* 64-bit relocation; insert value of TOC base (.TOC.). */
1028
1029 /* R_PPC64_TOC 51 doubleword64 .TOC. */
1030 HOWTO (R_PPC64_TOC, /* type */
1031 0, /* rightshift */
1032 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1033 64, /* bitsize */
1034 FALSE, /* pc_relative */
1035 0, /* bitpos */
1036 complain_overflow_dont, /* complain_on_overflow */
1037 ppc64_elf_toc64_reloc, /* special_function */
1038 "R_PPC64_TOC", /* name */
1039 FALSE, /* partial_inplace */
1040 0, /* src_mask */
1041 ONES (64), /* dst_mask */
1042 FALSE), /* pcrel_offset */
1043
1044 /* Like R_PPC64_GOT16, but also informs the link editor that the
1045 value to relocate may (!) refer to a PLT entry which the link
1046 editor (a) may replace with the symbol value. If the link editor
1047 is unable to fully resolve the symbol, it may (b) create a PLT
1048 entry and store the address to the new PLT entry in the GOT.
1049 This permits lazy resolution of function symbols at run time.
1050 The link editor may also skip all of this and just (c) emit a
1051 R_PPC64_GLOB_DAT to tie the symbol to the GOT entry. */
1052 /* FIXME: R_PPC64_PLTGOT16 not implemented. */
1053 HOWTO (R_PPC64_PLTGOT16, /* type */
1054 0, /* rightshift */
1055 1, /* size (0 = byte, 1 = short, 2 = long) */
1056 16, /* bitsize */
1057 FALSE, /* pc_relative */
1058 0, /* bitpos */
1059 complain_overflow_signed, /* complain_on_overflow */
1060 ppc64_elf_unhandled_reloc, /* special_function */
1061 "R_PPC64_PLTGOT16", /* name */
1062 FALSE, /* partial_inplace */
1063 0, /* src_mask */
1064 0xffff, /* dst_mask */
1065 FALSE), /* pcrel_offset */
1066
1067 /* Like R_PPC64_PLTGOT16, but without overflow. */
1068 /* FIXME: R_PPC64_PLTGOT16_LO not implemented. */
1069 HOWTO (R_PPC64_PLTGOT16_LO, /* type */
1070 0, /* rightshift */
1071 1, /* size (0 = byte, 1 = short, 2 = long) */
1072 16, /* bitsize */
1073 FALSE, /* pc_relative */
1074 0, /* bitpos */
1075 complain_overflow_dont, /* complain_on_overflow */
1076 ppc64_elf_unhandled_reloc, /* special_function */
1077 "R_PPC64_PLTGOT16_LO", /* name */
1078 FALSE, /* partial_inplace */
1079 0, /* src_mask */
1080 0xffff, /* dst_mask */
1081 FALSE), /* pcrel_offset */
1082
1083 /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address. */
1084 /* FIXME: R_PPC64_PLTGOT16_HI not implemented. */
1085 HOWTO (R_PPC64_PLTGOT16_HI, /* type */
1086 16, /* rightshift */
1087 1, /* size (0 = byte, 1 = short, 2 = long) */
1088 16, /* bitsize */
1089 FALSE, /* pc_relative */
1090 0, /* bitpos */
1091 complain_overflow_signed, /* complain_on_overflow */
1092 ppc64_elf_unhandled_reloc, /* special_function */
1093 "R_PPC64_PLTGOT16_HI", /* name */
1094 FALSE, /* partial_inplace */
1095 0, /* src_mask */
1096 0xffff, /* dst_mask */
1097 FALSE), /* pcrel_offset */
1098
1099 /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address, plus
1100 1 if the contents of the low 16 bits, treated as a signed number,
1101 is negative. */
1102 /* FIXME: R_PPC64_PLTGOT16_HA not implemented. */
1103 HOWTO (R_PPC64_PLTGOT16_HA, /* type */
1104 16, /* rightshift */
1105 1, /* size (0 = byte, 1 = short, 2 = long) */
1106 16, /* bitsize */
1107 FALSE, /* pc_relative */
1108 0, /* bitpos */
1109 complain_overflow_signed, /* complain_on_overflow */
1110 ppc64_elf_unhandled_reloc, /* special_function */
1111 "R_PPC64_PLTGOT16_HA", /* name */
1112 FALSE, /* partial_inplace */
1113 0, /* src_mask */
1114 0xffff, /* dst_mask */
1115 FALSE), /* pcrel_offset */
1116
1117 /* Like R_PPC64_ADDR16, but for instructions with a DS field. */
1118 HOWTO (R_PPC64_ADDR16_DS, /* type */
1119 0, /* rightshift */
1120 1, /* size (0 = byte, 1 = short, 2 = long) */
1121 16, /* bitsize */
1122 FALSE, /* pc_relative */
1123 0, /* bitpos */
1124 complain_overflow_signed, /* complain_on_overflow */
1125 bfd_elf_generic_reloc, /* special_function */
1126 "R_PPC64_ADDR16_DS", /* name */
1127 FALSE, /* partial_inplace */
1128 0, /* src_mask */
1129 0xfffc, /* dst_mask */
1130 FALSE), /* pcrel_offset */
1131
1132 /* Like R_PPC64_ADDR16_LO, but for instructions with a DS field. */
1133 HOWTO (R_PPC64_ADDR16_LO_DS, /* type */
1134 0, /* rightshift */
1135 1, /* size (0 = byte, 1 = short, 2 = long) */
1136 16, /* bitsize */
1137 FALSE, /* pc_relative */
1138 0, /* bitpos */
1139 complain_overflow_dont,/* complain_on_overflow */
1140 bfd_elf_generic_reloc, /* special_function */
1141 "R_PPC64_ADDR16_LO_DS",/* name */
1142 FALSE, /* partial_inplace */
1143 0, /* src_mask */
1144 0xfffc, /* dst_mask */
1145 FALSE), /* pcrel_offset */
1146
1147 /* Like R_PPC64_GOT16, but for instructions with a DS field. */
1148 HOWTO (R_PPC64_GOT16_DS, /* type */
1149 0, /* rightshift */
1150 1, /* size (0 = byte, 1 = short, 2 = long) */
1151 16, /* bitsize */
1152 FALSE, /* pc_relative */
1153 0, /* bitpos */
1154 complain_overflow_signed, /* complain_on_overflow */
1155 ppc64_elf_unhandled_reloc, /* special_function */
1156 "R_PPC64_GOT16_DS", /* name */
1157 FALSE, /* partial_inplace */
1158 0, /* src_mask */
1159 0xfffc, /* dst_mask */
1160 FALSE), /* pcrel_offset */
1161
1162 /* Like R_PPC64_GOT16_LO, but for instructions with a DS field. */
1163 HOWTO (R_PPC64_GOT16_LO_DS, /* type */
1164 0, /* rightshift */
1165 1, /* size (0 = byte, 1 = short, 2 = long) */
1166 16, /* bitsize */
1167 FALSE, /* pc_relative */
1168 0, /* bitpos */
1169 complain_overflow_dont, /* complain_on_overflow */
1170 ppc64_elf_unhandled_reloc, /* special_function */
1171 "R_PPC64_GOT16_LO_DS", /* name */
1172 FALSE, /* partial_inplace */
1173 0, /* src_mask */
1174 0xfffc, /* dst_mask */
1175 FALSE), /* pcrel_offset */
1176
1177 /* Like R_PPC64_PLT16_LO, but for instructions with a DS field. */
1178 HOWTO (R_PPC64_PLT16_LO_DS, /* type */
1179 0, /* rightshift */
1180 1, /* size (0 = byte, 1 = short, 2 = long) */
1181 16, /* bitsize */
1182 FALSE, /* pc_relative */
1183 0, /* bitpos */
1184 complain_overflow_dont, /* complain_on_overflow */
1185 ppc64_elf_unhandled_reloc, /* special_function */
1186 "R_PPC64_PLT16_LO_DS", /* name */
1187 FALSE, /* partial_inplace */
1188 0, /* src_mask */
1189 0xfffc, /* dst_mask */
1190 FALSE), /* pcrel_offset */
1191
1192 /* Like R_PPC64_SECTOFF, but for instructions with a DS field. */
1193 HOWTO (R_PPC64_SECTOFF_DS, /* type */
1194 0, /* rightshift */
1195 1, /* size (0 = byte, 1 = short, 2 = long) */
1196 16, /* bitsize */
1197 FALSE, /* pc_relative */
1198 0, /* bitpos */
1199 complain_overflow_signed, /* complain_on_overflow */
1200 ppc64_elf_sectoff_reloc, /* special_function */
1201 "R_PPC64_SECTOFF_DS", /* name */
1202 FALSE, /* partial_inplace */
1203 0, /* src_mask */
1204 0xfffc, /* dst_mask */
1205 FALSE), /* pcrel_offset */
1206
1207 /* Like R_PPC64_SECTOFF_LO, but for instructions with a DS field. */
1208 HOWTO (R_PPC64_SECTOFF_LO_DS, /* type */
1209 0, /* rightshift */
1210 1, /* size (0 = byte, 1 = short, 2 = long) */
1211 16, /* bitsize */
1212 FALSE, /* pc_relative */
1213 0, /* bitpos */
1214 complain_overflow_dont, /* complain_on_overflow */
1215 ppc64_elf_sectoff_reloc, /* special_function */
1216 "R_PPC64_SECTOFF_LO_DS",/* name */
1217 FALSE, /* partial_inplace */
1218 0, /* src_mask */
1219 0xfffc, /* dst_mask */
1220 FALSE), /* pcrel_offset */
1221
1222 /* Like R_PPC64_TOC16, but for instructions with a DS field. */
1223 HOWTO (R_PPC64_TOC16_DS, /* type */
1224 0, /* rightshift */
1225 1, /* size (0 = byte, 1 = short, 2 = long) */
1226 16, /* bitsize */
1227 FALSE, /* pc_relative */
1228 0, /* bitpos */
1229 complain_overflow_signed, /* complain_on_overflow */
1230 ppc64_elf_toc_reloc, /* special_function */
1231 "R_PPC64_TOC16_DS", /* name */
1232 FALSE, /* partial_inplace */
1233 0, /* src_mask */
1234 0xfffc, /* dst_mask */
1235 FALSE), /* pcrel_offset */
1236
1237 /* Like R_PPC64_TOC16_LO, but for instructions with a DS field. */
1238 HOWTO (R_PPC64_TOC16_LO_DS, /* type */
1239 0, /* rightshift */
1240 1, /* size (0 = byte, 1 = short, 2 = long) */
1241 16, /* bitsize */
1242 FALSE, /* pc_relative */
1243 0, /* bitpos */
1244 complain_overflow_dont, /* complain_on_overflow */
1245 ppc64_elf_toc_reloc, /* special_function */
1246 "R_PPC64_TOC16_LO_DS", /* name */
1247 FALSE, /* partial_inplace */
1248 0, /* src_mask */
1249 0xfffc, /* dst_mask */
1250 FALSE), /* pcrel_offset */
1251
1252 /* Like R_PPC64_PLTGOT16, but for instructions with a DS field. */
1253 /* FIXME: R_PPC64_PLTGOT16_DS not implemented. */
1254 HOWTO (R_PPC64_PLTGOT16_DS, /* type */
1255 0, /* rightshift */
1256 1, /* size (0 = byte, 1 = short, 2 = long) */
1257 16, /* bitsize */
1258 FALSE, /* pc_relative */
1259 0, /* bitpos */
1260 complain_overflow_signed, /* complain_on_overflow */
1261 ppc64_elf_unhandled_reloc, /* special_function */
1262 "R_PPC64_PLTGOT16_DS", /* name */
1263 FALSE, /* partial_inplace */
1264 0, /* src_mask */
1265 0xfffc, /* dst_mask */
1266 FALSE), /* pcrel_offset */
1267
1268 /* Like R_PPC64_PLTGOT16_LO, but for instructions with a DS field. */
1269 /* FIXME: R_PPC64_PLTGOT16_LO not implemented. */
1270 HOWTO (R_PPC64_PLTGOT16_LO_DS,/* type */
1271 0, /* rightshift */
1272 1, /* size (0 = byte, 1 = short, 2 = long) */
1273 16, /* bitsize */
1274 FALSE, /* pc_relative */
1275 0, /* bitpos */
1276 complain_overflow_dont, /* complain_on_overflow */
1277 ppc64_elf_unhandled_reloc, /* special_function */
1278 "R_PPC64_PLTGOT16_LO_DS",/* name */
1279 FALSE, /* partial_inplace */
1280 0, /* src_mask */
1281 0xfffc, /* dst_mask */
1282 FALSE), /* pcrel_offset */
1283
1284 /* Marker relocs for TLS. */
1285 HOWTO (R_PPC64_TLS,
1286 0, /* rightshift */
1287 2, /* size (0 = byte, 1 = short, 2 = long) */
1288 32, /* bitsize */
1289 FALSE, /* pc_relative */
1290 0, /* bitpos */
1291 complain_overflow_dont, /* complain_on_overflow */
1292 bfd_elf_generic_reloc, /* special_function */
1293 "R_PPC64_TLS", /* name */
1294 FALSE, /* partial_inplace */
1295 0, /* src_mask */
1296 0, /* dst_mask */
1297 FALSE), /* pcrel_offset */
1298
1299 HOWTO (R_PPC64_TLSGD,
1300 0, /* rightshift */
1301 2, /* size (0 = byte, 1 = short, 2 = long) */
1302 32, /* bitsize */
1303 FALSE, /* pc_relative */
1304 0, /* bitpos */
1305 complain_overflow_dont, /* complain_on_overflow */
1306 bfd_elf_generic_reloc, /* special_function */
1307 "R_PPC64_TLSGD", /* name */
1308 FALSE, /* partial_inplace */
1309 0, /* src_mask */
1310 0, /* dst_mask */
1311 FALSE), /* pcrel_offset */
1312
1313 HOWTO (R_PPC64_TLSLD,
1314 0, /* rightshift */
1315 2, /* size (0 = byte, 1 = short, 2 = long) */
1316 32, /* bitsize */
1317 FALSE, /* pc_relative */
1318 0, /* bitpos */
1319 complain_overflow_dont, /* complain_on_overflow */
1320 bfd_elf_generic_reloc, /* special_function */
1321 "R_PPC64_TLSLD", /* name */
1322 FALSE, /* partial_inplace */
1323 0, /* src_mask */
1324 0, /* dst_mask */
1325 FALSE), /* pcrel_offset */
1326
1327 HOWTO (R_PPC64_TOCSAVE,
1328 0, /* rightshift */
1329 2, /* size (0 = byte, 1 = short, 2 = long) */
1330 32, /* bitsize */
1331 FALSE, /* pc_relative */
1332 0, /* bitpos */
1333 complain_overflow_dont, /* complain_on_overflow */
1334 bfd_elf_generic_reloc, /* special_function */
1335 "R_PPC64_TOCSAVE", /* name */
1336 FALSE, /* partial_inplace */
1337 0, /* src_mask */
1338 0, /* dst_mask */
1339 FALSE), /* pcrel_offset */
1340
1341 /* Computes the load module index of the load module that contains the
1342 definition of its TLS sym. */
1343 HOWTO (R_PPC64_DTPMOD64,
1344 0, /* rightshift */
1345 4, /* size (0 = byte, 1 = short, 2 = long) */
1346 64, /* bitsize */
1347 FALSE, /* pc_relative */
1348 0, /* bitpos */
1349 complain_overflow_dont, /* complain_on_overflow */
1350 ppc64_elf_unhandled_reloc, /* special_function */
1351 "R_PPC64_DTPMOD64", /* name */
1352 FALSE, /* partial_inplace */
1353 0, /* src_mask */
1354 ONES (64), /* dst_mask */
1355 FALSE), /* pcrel_offset */
1356
1357 /* Computes a dtv-relative displacement, the difference between the value
1358 of sym+add and the base address of the thread-local storage block that
1359 contains the definition of sym, minus 0x8000. */
1360 HOWTO (R_PPC64_DTPREL64,
1361 0, /* rightshift */
1362 4, /* size (0 = byte, 1 = short, 2 = long) */
1363 64, /* bitsize */
1364 FALSE, /* pc_relative */
1365 0, /* bitpos */
1366 complain_overflow_dont, /* complain_on_overflow */
1367 ppc64_elf_unhandled_reloc, /* special_function */
1368 "R_PPC64_DTPREL64", /* name */
1369 FALSE, /* partial_inplace */
1370 0, /* src_mask */
1371 ONES (64), /* dst_mask */
1372 FALSE), /* pcrel_offset */
1373
1374 /* A 16 bit dtprel reloc. */
1375 HOWTO (R_PPC64_DTPREL16,
1376 0, /* rightshift */
1377 1, /* size (0 = byte, 1 = short, 2 = long) */
1378 16, /* bitsize */
1379 FALSE, /* pc_relative */
1380 0, /* bitpos */
1381 complain_overflow_signed, /* complain_on_overflow */
1382 ppc64_elf_unhandled_reloc, /* special_function */
1383 "R_PPC64_DTPREL16", /* name */
1384 FALSE, /* partial_inplace */
1385 0, /* src_mask */
1386 0xffff, /* dst_mask */
1387 FALSE), /* pcrel_offset */
1388
1389 /* Like DTPREL16, but no overflow. */
1390 HOWTO (R_PPC64_DTPREL16_LO,
1391 0, /* rightshift */
1392 1, /* size (0 = byte, 1 = short, 2 = long) */
1393 16, /* bitsize */
1394 FALSE, /* pc_relative */
1395 0, /* bitpos */
1396 complain_overflow_dont, /* complain_on_overflow */
1397 ppc64_elf_unhandled_reloc, /* special_function */
1398 "R_PPC64_DTPREL16_LO", /* name */
1399 FALSE, /* partial_inplace */
1400 0, /* src_mask */
1401 0xffff, /* dst_mask */
1402 FALSE), /* pcrel_offset */
1403
1404 /* Like DTPREL16_LO, but next higher group of 16 bits. */
1405 HOWTO (R_PPC64_DTPREL16_HI,
1406 16, /* rightshift */
1407 1, /* size (0 = byte, 1 = short, 2 = long) */
1408 16, /* bitsize */
1409 FALSE, /* pc_relative */
1410 0, /* bitpos */
1411 complain_overflow_signed, /* complain_on_overflow */
1412 ppc64_elf_unhandled_reloc, /* special_function */
1413 "R_PPC64_DTPREL16_HI", /* name */
1414 FALSE, /* partial_inplace */
1415 0, /* src_mask */
1416 0xffff, /* dst_mask */
1417 FALSE), /* pcrel_offset */
1418
1419 /* Like DTPREL16_HI, but adjust for low 16 bits. */
1420 HOWTO (R_PPC64_DTPREL16_HA,
1421 16, /* rightshift */
1422 1, /* size (0 = byte, 1 = short, 2 = long) */
1423 16, /* bitsize */
1424 FALSE, /* pc_relative */
1425 0, /* bitpos */
1426 complain_overflow_signed, /* complain_on_overflow */
1427 ppc64_elf_unhandled_reloc, /* special_function */
1428 "R_PPC64_DTPREL16_HA", /* name */
1429 FALSE, /* partial_inplace */
1430 0, /* src_mask */
1431 0xffff, /* dst_mask */
1432 FALSE), /* pcrel_offset */
1433
1434 /* Like DTPREL16_HI, but next higher group of 16 bits. */
1435 HOWTO (R_PPC64_DTPREL16_HIGHER,
1436 32, /* rightshift */
1437 1, /* size (0 = byte, 1 = short, 2 = long) */
1438 16, /* bitsize */
1439 FALSE, /* pc_relative */
1440 0, /* bitpos */
1441 complain_overflow_dont, /* complain_on_overflow */
1442 ppc64_elf_unhandled_reloc, /* special_function */
1443 "R_PPC64_DTPREL16_HIGHER", /* name */
1444 FALSE, /* partial_inplace */
1445 0, /* src_mask */
1446 0xffff, /* dst_mask */
1447 FALSE), /* pcrel_offset */
1448
1449 /* Like DTPREL16_HIGHER, but adjust for low 16 bits. */
1450 HOWTO (R_PPC64_DTPREL16_HIGHERA,
1451 32, /* rightshift */
1452 1, /* size (0 = byte, 1 = short, 2 = long) */
1453 16, /* bitsize */
1454 FALSE, /* pc_relative */
1455 0, /* bitpos */
1456 complain_overflow_dont, /* complain_on_overflow */
1457 ppc64_elf_unhandled_reloc, /* special_function */
1458 "R_PPC64_DTPREL16_HIGHERA", /* name */
1459 FALSE, /* partial_inplace */
1460 0, /* src_mask */
1461 0xffff, /* dst_mask */
1462 FALSE), /* pcrel_offset */
1463
1464 /* Like DTPREL16_HIGHER, but next higher group of 16 bits. */
1465 HOWTO (R_PPC64_DTPREL16_HIGHEST,
1466 48, /* rightshift */
1467 1, /* size (0 = byte, 1 = short, 2 = long) */
1468 16, /* bitsize */
1469 FALSE, /* pc_relative */
1470 0, /* bitpos */
1471 complain_overflow_dont, /* complain_on_overflow */
1472 ppc64_elf_unhandled_reloc, /* special_function */
1473 "R_PPC64_DTPREL16_HIGHEST", /* name */
1474 FALSE, /* partial_inplace */
1475 0, /* src_mask */
1476 0xffff, /* dst_mask */
1477 FALSE), /* pcrel_offset */
1478
1479 /* Like DTPREL16_HIGHEST, but adjust for low 16 bits. */
1480 HOWTO (R_PPC64_DTPREL16_HIGHESTA,
1481 48, /* rightshift */
1482 1, /* size (0 = byte, 1 = short, 2 = long) */
1483 16, /* bitsize */
1484 FALSE, /* pc_relative */
1485 0, /* bitpos */
1486 complain_overflow_dont, /* complain_on_overflow */
1487 ppc64_elf_unhandled_reloc, /* special_function */
1488 "R_PPC64_DTPREL16_HIGHESTA", /* name */
1489 FALSE, /* partial_inplace */
1490 0, /* src_mask */
1491 0xffff, /* dst_mask */
1492 FALSE), /* pcrel_offset */
1493
1494 /* Like DTPREL16, but for insns with a DS field. */
1495 HOWTO (R_PPC64_DTPREL16_DS,
1496 0, /* rightshift */
1497 1, /* size (0 = byte, 1 = short, 2 = long) */
1498 16, /* bitsize */
1499 FALSE, /* pc_relative */
1500 0, /* bitpos */
1501 complain_overflow_signed, /* complain_on_overflow */
1502 ppc64_elf_unhandled_reloc, /* special_function */
1503 "R_PPC64_DTPREL16_DS", /* name */
1504 FALSE, /* partial_inplace */
1505 0, /* src_mask */
1506 0xfffc, /* dst_mask */
1507 FALSE), /* pcrel_offset */
1508
1509 /* Like DTPREL16_DS, but no overflow. */
1510 HOWTO (R_PPC64_DTPREL16_LO_DS,
1511 0, /* rightshift */
1512 1, /* size (0 = byte, 1 = short, 2 = long) */
1513 16, /* bitsize */
1514 FALSE, /* pc_relative */
1515 0, /* bitpos */
1516 complain_overflow_dont, /* complain_on_overflow */
1517 ppc64_elf_unhandled_reloc, /* special_function */
1518 "R_PPC64_DTPREL16_LO_DS", /* name */
1519 FALSE, /* partial_inplace */
1520 0, /* src_mask */
1521 0xfffc, /* dst_mask */
1522 FALSE), /* pcrel_offset */
1523
1524 /* Computes a tp-relative displacement, the difference between the value of
1525 sym+add and the value of the thread pointer (r13). */
1526 HOWTO (R_PPC64_TPREL64,
1527 0, /* rightshift */
1528 4, /* size (0 = byte, 1 = short, 2 = long) */
1529 64, /* bitsize */
1530 FALSE, /* pc_relative */
1531 0, /* bitpos */
1532 complain_overflow_dont, /* complain_on_overflow */
1533 ppc64_elf_unhandled_reloc, /* special_function */
1534 "R_PPC64_TPREL64", /* name */
1535 FALSE, /* partial_inplace */
1536 0, /* src_mask */
1537 ONES (64), /* dst_mask */
1538 FALSE), /* pcrel_offset */
1539
1540 /* A 16 bit tprel reloc. */
1541 HOWTO (R_PPC64_TPREL16,
1542 0, /* rightshift */
1543 1, /* size (0 = byte, 1 = short, 2 = long) */
1544 16, /* bitsize */
1545 FALSE, /* pc_relative */
1546 0, /* bitpos */
1547 complain_overflow_signed, /* complain_on_overflow */
1548 ppc64_elf_unhandled_reloc, /* special_function */
1549 "R_PPC64_TPREL16", /* name */
1550 FALSE, /* partial_inplace */
1551 0, /* src_mask */
1552 0xffff, /* dst_mask */
1553 FALSE), /* pcrel_offset */
1554
1555 /* Like TPREL16, but no overflow. */
1556 HOWTO (R_PPC64_TPREL16_LO,
1557 0, /* rightshift */
1558 1, /* size (0 = byte, 1 = short, 2 = long) */
1559 16, /* bitsize */
1560 FALSE, /* pc_relative */
1561 0, /* bitpos */
1562 complain_overflow_dont, /* complain_on_overflow */
1563 ppc64_elf_unhandled_reloc, /* special_function */
1564 "R_PPC64_TPREL16_LO", /* name */
1565 FALSE, /* partial_inplace */
1566 0, /* src_mask */
1567 0xffff, /* dst_mask */
1568 FALSE), /* pcrel_offset */
1569
1570 /* Like TPREL16_LO, but next higher group of 16 bits. */
1571 HOWTO (R_PPC64_TPREL16_HI,
1572 16, /* rightshift */
1573 1, /* size (0 = byte, 1 = short, 2 = long) */
1574 16, /* bitsize */
1575 FALSE, /* pc_relative */
1576 0, /* bitpos */
1577 complain_overflow_signed, /* complain_on_overflow */
1578 ppc64_elf_unhandled_reloc, /* special_function */
1579 "R_PPC64_TPREL16_HI", /* name */
1580 FALSE, /* partial_inplace */
1581 0, /* src_mask */
1582 0xffff, /* dst_mask */
1583 FALSE), /* pcrel_offset */
1584
1585 /* Like TPREL16_HI, but adjust for low 16 bits. */
1586 HOWTO (R_PPC64_TPREL16_HA,
1587 16, /* rightshift */
1588 1, /* size (0 = byte, 1 = short, 2 = long) */
1589 16, /* bitsize */
1590 FALSE, /* pc_relative */
1591 0, /* bitpos */
1592 complain_overflow_signed, /* complain_on_overflow */
1593 ppc64_elf_unhandled_reloc, /* special_function */
1594 "R_PPC64_TPREL16_HA", /* name */
1595 FALSE, /* partial_inplace */
1596 0, /* src_mask */
1597 0xffff, /* dst_mask */
1598 FALSE), /* pcrel_offset */
1599
1600 /* Like TPREL16_HI, but next higher group of 16 bits. */
1601 HOWTO (R_PPC64_TPREL16_HIGHER,
1602 32, /* rightshift */
1603 1, /* size (0 = byte, 1 = short, 2 = long) */
1604 16, /* bitsize */
1605 FALSE, /* pc_relative */
1606 0, /* bitpos */
1607 complain_overflow_dont, /* complain_on_overflow */
1608 ppc64_elf_unhandled_reloc, /* special_function */
1609 "R_PPC64_TPREL16_HIGHER", /* name */
1610 FALSE, /* partial_inplace */
1611 0, /* src_mask */
1612 0xffff, /* dst_mask */
1613 FALSE), /* pcrel_offset */
1614
1615 /* Like TPREL16_HIGHER, but adjust for low 16 bits. */
1616 HOWTO (R_PPC64_TPREL16_HIGHERA,
1617 32, /* rightshift */
1618 1, /* size (0 = byte, 1 = short, 2 = long) */
1619 16, /* bitsize */
1620 FALSE, /* pc_relative */
1621 0, /* bitpos */
1622 complain_overflow_dont, /* complain_on_overflow */
1623 ppc64_elf_unhandled_reloc, /* special_function */
1624 "R_PPC64_TPREL16_HIGHERA", /* name */
1625 FALSE, /* partial_inplace */
1626 0, /* src_mask */
1627 0xffff, /* dst_mask */
1628 FALSE), /* pcrel_offset */
1629
1630 /* Like TPREL16_HIGHER, but next higher group of 16 bits. */
1631 HOWTO (R_PPC64_TPREL16_HIGHEST,
1632 48, /* rightshift */
1633 1, /* size (0 = byte, 1 = short, 2 = long) */
1634 16, /* bitsize */
1635 FALSE, /* pc_relative */
1636 0, /* bitpos */
1637 complain_overflow_dont, /* complain_on_overflow */
1638 ppc64_elf_unhandled_reloc, /* special_function */
1639 "R_PPC64_TPREL16_HIGHEST", /* name */
1640 FALSE, /* partial_inplace */
1641 0, /* src_mask */
1642 0xffff, /* dst_mask */
1643 FALSE), /* pcrel_offset */
1644
1645 /* Like TPREL16_HIGHEST, but adjust for low 16 bits. */
1646 HOWTO (R_PPC64_TPREL16_HIGHESTA,
1647 48, /* rightshift */
1648 1, /* size (0 = byte, 1 = short, 2 = long) */
1649 16, /* bitsize */
1650 FALSE, /* pc_relative */
1651 0, /* bitpos */
1652 complain_overflow_dont, /* complain_on_overflow */
1653 ppc64_elf_unhandled_reloc, /* special_function */
1654 "R_PPC64_TPREL16_HIGHESTA", /* name */
1655 FALSE, /* partial_inplace */
1656 0, /* src_mask */
1657 0xffff, /* dst_mask */
1658 FALSE), /* pcrel_offset */
1659
1660 /* Like TPREL16, but for insns with a DS field. */
1661 HOWTO (R_PPC64_TPREL16_DS,
1662 0, /* rightshift */
1663 1, /* size (0 = byte, 1 = short, 2 = long) */
1664 16, /* bitsize */
1665 FALSE, /* pc_relative */
1666 0, /* bitpos */
1667 complain_overflow_signed, /* complain_on_overflow */
1668 ppc64_elf_unhandled_reloc, /* special_function */
1669 "R_PPC64_TPREL16_DS", /* name */
1670 FALSE, /* partial_inplace */
1671 0, /* src_mask */
1672 0xfffc, /* dst_mask */
1673 FALSE), /* pcrel_offset */
1674
1675 /* Like TPREL16_DS, but no overflow. */
1676 HOWTO (R_PPC64_TPREL16_LO_DS,
1677 0, /* rightshift */
1678 1, /* size (0 = byte, 1 = short, 2 = long) */
1679 16, /* bitsize */
1680 FALSE, /* pc_relative */
1681 0, /* bitpos */
1682 complain_overflow_dont, /* complain_on_overflow */
1683 ppc64_elf_unhandled_reloc, /* special_function */
1684 "R_PPC64_TPREL16_LO_DS", /* name */
1685 FALSE, /* partial_inplace */
1686 0, /* src_mask */
1687 0xfffc, /* dst_mask */
1688 FALSE), /* pcrel_offset */
1689
1690 /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1691 with values (sym+add)@dtpmod and (sym+add)@dtprel, and computes the offset
1692 to the first entry relative to the TOC base (r2). */
1693 HOWTO (R_PPC64_GOT_TLSGD16,
1694 0, /* rightshift */
1695 1, /* size (0 = byte, 1 = short, 2 = long) */
1696 16, /* bitsize */
1697 FALSE, /* pc_relative */
1698 0, /* bitpos */
1699 complain_overflow_signed, /* complain_on_overflow */
1700 ppc64_elf_unhandled_reloc, /* special_function */
1701 "R_PPC64_GOT_TLSGD16", /* name */
1702 FALSE, /* partial_inplace */
1703 0, /* src_mask */
1704 0xffff, /* dst_mask */
1705 FALSE), /* pcrel_offset */
1706
1707 /* Like GOT_TLSGD16, but no overflow. */
1708 HOWTO (R_PPC64_GOT_TLSGD16_LO,
1709 0, /* rightshift */
1710 1, /* size (0 = byte, 1 = short, 2 = long) */
1711 16, /* bitsize */
1712 FALSE, /* pc_relative */
1713 0, /* bitpos */
1714 complain_overflow_dont, /* complain_on_overflow */
1715 ppc64_elf_unhandled_reloc, /* special_function */
1716 "R_PPC64_GOT_TLSGD16_LO", /* name */
1717 FALSE, /* partial_inplace */
1718 0, /* src_mask */
1719 0xffff, /* dst_mask */
1720 FALSE), /* pcrel_offset */
1721
1722 /* Like GOT_TLSGD16_LO, but next higher group of 16 bits. */
1723 HOWTO (R_PPC64_GOT_TLSGD16_HI,
1724 16, /* rightshift */
1725 1, /* size (0 = byte, 1 = short, 2 = long) */
1726 16, /* bitsize */
1727 FALSE, /* pc_relative */
1728 0, /* bitpos */
1729 complain_overflow_signed, /* complain_on_overflow */
1730 ppc64_elf_unhandled_reloc, /* special_function */
1731 "R_PPC64_GOT_TLSGD16_HI", /* name */
1732 FALSE, /* partial_inplace */
1733 0, /* src_mask */
1734 0xffff, /* dst_mask */
1735 FALSE), /* pcrel_offset */
1736
1737 /* Like GOT_TLSGD16_HI, but adjust for low 16 bits. */
1738 HOWTO (R_PPC64_GOT_TLSGD16_HA,
1739 16, /* rightshift */
1740 1, /* size (0 = byte, 1 = short, 2 = long) */
1741 16, /* bitsize */
1742 FALSE, /* pc_relative */
1743 0, /* bitpos */
1744 complain_overflow_signed, /* complain_on_overflow */
1745 ppc64_elf_unhandled_reloc, /* special_function */
1746 "R_PPC64_GOT_TLSGD16_HA", /* name */
1747 FALSE, /* partial_inplace */
1748 0, /* src_mask */
1749 0xffff, /* dst_mask */
1750 FALSE), /* pcrel_offset */
1751
1752 /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1753 with values (sym+add)@dtpmod and zero, and computes the offset to the
1754 first entry relative to the TOC base (r2). */
1755 HOWTO (R_PPC64_GOT_TLSLD16,
1756 0, /* rightshift */
1757 1, /* size (0 = byte, 1 = short, 2 = long) */
1758 16, /* bitsize */
1759 FALSE, /* pc_relative */
1760 0, /* bitpos */
1761 complain_overflow_signed, /* complain_on_overflow */
1762 ppc64_elf_unhandled_reloc, /* special_function */
1763 "R_PPC64_GOT_TLSLD16", /* name */
1764 FALSE, /* partial_inplace */
1765 0, /* src_mask */
1766 0xffff, /* dst_mask */
1767 FALSE), /* pcrel_offset */
1768
1769 /* Like GOT_TLSLD16, but no overflow. */
1770 HOWTO (R_PPC64_GOT_TLSLD16_LO,
1771 0, /* rightshift */
1772 1, /* size (0 = byte, 1 = short, 2 = long) */
1773 16, /* bitsize */
1774 FALSE, /* pc_relative */
1775 0, /* bitpos */
1776 complain_overflow_dont, /* complain_on_overflow */
1777 ppc64_elf_unhandled_reloc, /* special_function */
1778 "R_PPC64_GOT_TLSLD16_LO", /* name */
1779 FALSE, /* partial_inplace */
1780 0, /* src_mask */
1781 0xffff, /* dst_mask */
1782 FALSE), /* pcrel_offset */
1783
1784 /* Like GOT_TLSLD16_LO, but next higher group of 16 bits. */
1785 HOWTO (R_PPC64_GOT_TLSLD16_HI,
1786 16, /* rightshift */
1787 1, /* size (0 = byte, 1 = short, 2 = long) */
1788 16, /* bitsize */
1789 FALSE, /* pc_relative */
1790 0, /* bitpos */
1791 complain_overflow_signed, /* complain_on_overflow */
1792 ppc64_elf_unhandled_reloc, /* special_function */
1793 "R_PPC64_GOT_TLSLD16_HI", /* name */
1794 FALSE, /* partial_inplace */
1795 0, /* src_mask */
1796 0xffff, /* dst_mask */
1797 FALSE), /* pcrel_offset */
1798
1799 /* Like GOT_TLSLD16_HI, but adjust for low 16 bits. */
1800 HOWTO (R_PPC64_GOT_TLSLD16_HA,
1801 16, /* rightshift */
1802 1, /* size (0 = byte, 1 = short, 2 = long) */
1803 16, /* bitsize */
1804 FALSE, /* pc_relative */
1805 0, /* bitpos */
1806 complain_overflow_signed, /* complain_on_overflow */
1807 ppc64_elf_unhandled_reloc, /* special_function */
1808 "R_PPC64_GOT_TLSLD16_HA", /* name */
1809 FALSE, /* partial_inplace */
1810 0, /* src_mask */
1811 0xffff, /* dst_mask */
1812 FALSE), /* pcrel_offset */
1813
1814 /* Allocates an entry in the GOT with value (sym+add)@dtprel, and computes
1815 the offset to the entry relative to the TOC base (r2). */
1816 HOWTO (R_PPC64_GOT_DTPREL16_DS,
1817 0, /* rightshift */
1818 1, /* size (0 = byte, 1 = short, 2 = long) */
1819 16, /* bitsize */
1820 FALSE, /* pc_relative */
1821 0, /* bitpos */
1822 complain_overflow_signed, /* complain_on_overflow */
1823 ppc64_elf_unhandled_reloc, /* special_function */
1824 "R_PPC64_GOT_DTPREL16_DS", /* name */
1825 FALSE, /* partial_inplace */
1826 0, /* src_mask */
1827 0xfffc, /* dst_mask */
1828 FALSE), /* pcrel_offset */
1829
1830 /* Like GOT_DTPREL16_DS, but no overflow. */
1831 HOWTO (R_PPC64_GOT_DTPREL16_LO_DS,
1832 0, /* rightshift */
1833 1, /* size (0 = byte, 1 = short, 2 = long) */
1834 16, /* bitsize */
1835 FALSE, /* pc_relative */
1836 0, /* bitpos */
1837 complain_overflow_dont, /* complain_on_overflow */
1838 ppc64_elf_unhandled_reloc, /* special_function */
1839 "R_PPC64_GOT_DTPREL16_LO_DS", /* name */
1840 FALSE, /* partial_inplace */
1841 0, /* src_mask */
1842 0xfffc, /* dst_mask */
1843 FALSE), /* pcrel_offset */
1844
1845 /* Like GOT_DTPREL16_LO_DS, but next higher group of 16 bits. */
1846 HOWTO (R_PPC64_GOT_DTPREL16_HI,
1847 16, /* rightshift */
1848 1, /* size (0 = byte, 1 = short, 2 = long) */
1849 16, /* bitsize */
1850 FALSE, /* pc_relative */
1851 0, /* bitpos */
1852 complain_overflow_signed, /* complain_on_overflow */
1853 ppc64_elf_unhandled_reloc, /* special_function */
1854 "R_PPC64_GOT_DTPREL16_HI", /* name */
1855 FALSE, /* partial_inplace */
1856 0, /* src_mask */
1857 0xffff, /* dst_mask */
1858 FALSE), /* pcrel_offset */
1859
1860 /* Like GOT_DTPREL16_HI, but adjust for low 16 bits. */
1861 HOWTO (R_PPC64_GOT_DTPREL16_HA,
1862 16, /* rightshift */
1863 1, /* size (0 = byte, 1 = short, 2 = long) */
1864 16, /* bitsize */
1865 FALSE, /* pc_relative */
1866 0, /* bitpos */
1867 complain_overflow_signed, /* complain_on_overflow */
1868 ppc64_elf_unhandled_reloc, /* special_function */
1869 "R_PPC64_GOT_DTPREL16_HA", /* name */
1870 FALSE, /* partial_inplace */
1871 0, /* src_mask */
1872 0xffff, /* dst_mask */
1873 FALSE), /* pcrel_offset */
1874
1875 /* Allocates an entry in the GOT with value (sym+add)@tprel, and computes the
1876 offset to the entry relative to the TOC base (r2). */
1877 HOWTO (R_PPC64_GOT_TPREL16_DS,
1878 0, /* rightshift */
1879 1, /* size (0 = byte, 1 = short, 2 = long) */
1880 16, /* bitsize */
1881 FALSE, /* pc_relative */
1882 0, /* bitpos */
1883 complain_overflow_signed, /* complain_on_overflow */
1884 ppc64_elf_unhandled_reloc, /* special_function */
1885 "R_PPC64_GOT_TPREL16_DS", /* name */
1886 FALSE, /* partial_inplace */
1887 0, /* src_mask */
1888 0xfffc, /* dst_mask */
1889 FALSE), /* pcrel_offset */
1890
1891 /* Like GOT_TPREL16_DS, but no overflow. */
1892 HOWTO (R_PPC64_GOT_TPREL16_LO_DS,
1893 0, /* rightshift */
1894 1, /* size (0 = byte, 1 = short, 2 = long) */
1895 16, /* bitsize */
1896 FALSE, /* pc_relative */
1897 0, /* bitpos */
1898 complain_overflow_dont, /* complain_on_overflow */
1899 ppc64_elf_unhandled_reloc, /* special_function */
1900 "R_PPC64_GOT_TPREL16_LO_DS", /* name */
1901 FALSE, /* partial_inplace */
1902 0, /* src_mask */
1903 0xfffc, /* dst_mask */
1904 FALSE), /* pcrel_offset */
1905
1906 /* Like GOT_TPREL16_LO_DS, but next higher group of 16 bits. */
1907 HOWTO (R_PPC64_GOT_TPREL16_HI,
1908 16, /* rightshift */
1909 1, /* size (0 = byte, 1 = short, 2 = long) */
1910 16, /* bitsize */
1911 FALSE, /* pc_relative */
1912 0, /* bitpos */
1913 complain_overflow_signed, /* complain_on_overflow */
1914 ppc64_elf_unhandled_reloc, /* special_function */
1915 "R_PPC64_GOT_TPREL16_HI", /* name */
1916 FALSE, /* partial_inplace */
1917 0, /* src_mask */
1918 0xffff, /* dst_mask */
1919 FALSE), /* pcrel_offset */
1920
1921 /* Like GOT_TPREL16_HI, but adjust for low 16 bits. */
1922 HOWTO (R_PPC64_GOT_TPREL16_HA,
1923 16, /* rightshift */
1924 1, /* size (0 = byte, 1 = short, 2 = long) */
1925 16, /* bitsize */
1926 FALSE, /* pc_relative */
1927 0, /* bitpos */
1928 complain_overflow_signed, /* complain_on_overflow */
1929 ppc64_elf_unhandled_reloc, /* special_function */
1930 "R_PPC64_GOT_TPREL16_HA", /* name */
1931 FALSE, /* partial_inplace */
1932 0, /* src_mask */
1933 0xffff, /* dst_mask */
1934 FALSE), /* pcrel_offset */
1935
1936 HOWTO (R_PPC64_JMP_IREL, /* type */
1937 0, /* rightshift */
1938 0, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1939 0, /* bitsize */
1940 FALSE, /* pc_relative */
1941 0, /* bitpos */
1942 complain_overflow_dont, /* complain_on_overflow */
1943 ppc64_elf_unhandled_reloc, /* special_function */
1944 "R_PPC64_JMP_IREL", /* name */
1945 FALSE, /* partial_inplace */
1946 0, /* src_mask */
1947 0, /* dst_mask */
1948 FALSE), /* pcrel_offset */
1949
1950 HOWTO (R_PPC64_IRELATIVE, /* type */
1951 0, /* rightshift */
1952 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1953 64, /* bitsize */
1954 FALSE, /* pc_relative */
1955 0, /* bitpos */
1956 complain_overflow_dont, /* complain_on_overflow */
1957 bfd_elf_generic_reloc, /* special_function */
1958 "R_PPC64_IRELATIVE", /* name */
1959 FALSE, /* partial_inplace */
1960 0, /* src_mask */
1961 ONES (64), /* dst_mask */
1962 FALSE), /* pcrel_offset */
1963
1964 /* A 16 bit relative relocation. */
1965 HOWTO (R_PPC64_REL16, /* type */
1966 0, /* rightshift */
1967 1, /* size (0 = byte, 1 = short, 2 = long) */
1968 16, /* bitsize */
1969 TRUE, /* pc_relative */
1970 0, /* bitpos */
1971 complain_overflow_signed, /* complain_on_overflow */
1972 bfd_elf_generic_reloc, /* special_function */
1973 "R_PPC64_REL16", /* name */
1974 FALSE, /* partial_inplace */
1975 0, /* src_mask */
1976 0xffff, /* dst_mask */
1977 TRUE), /* pcrel_offset */
1978
1979 /* A 16 bit relative relocation without overflow. */
1980 HOWTO (R_PPC64_REL16_LO, /* type */
1981 0, /* rightshift */
1982 1, /* size (0 = byte, 1 = short, 2 = long) */
1983 16, /* bitsize */
1984 TRUE, /* pc_relative */
1985 0, /* bitpos */
1986 complain_overflow_dont,/* complain_on_overflow */
1987 bfd_elf_generic_reloc, /* special_function */
1988 "R_PPC64_REL16_LO", /* name */
1989 FALSE, /* partial_inplace */
1990 0, /* src_mask */
1991 0xffff, /* dst_mask */
1992 TRUE), /* pcrel_offset */
1993
1994 /* The high order 16 bits of a relative address. */
1995 HOWTO (R_PPC64_REL16_HI, /* type */
1996 16, /* rightshift */
1997 1, /* size (0 = byte, 1 = short, 2 = long) */
1998 16, /* bitsize */
1999 TRUE, /* pc_relative */
2000 0, /* bitpos */
2001 complain_overflow_signed, /* complain_on_overflow */
2002 bfd_elf_generic_reloc, /* special_function */
2003 "R_PPC64_REL16_HI", /* name */
2004 FALSE, /* partial_inplace */
2005 0, /* src_mask */
2006 0xffff, /* dst_mask */
2007 TRUE), /* pcrel_offset */
2008
2009 /* The high order 16 bits of a relative address, plus 1 if the contents of
2010 the low 16 bits, treated as a signed number, is negative. */
2011 HOWTO (R_PPC64_REL16_HA, /* type */
2012 16, /* rightshift */
2013 1, /* size (0 = byte, 1 = short, 2 = long) */
2014 16, /* bitsize */
2015 TRUE, /* pc_relative */
2016 0, /* bitpos */
2017 complain_overflow_signed, /* complain_on_overflow */
2018 ppc64_elf_ha_reloc, /* special_function */
2019 "R_PPC64_REL16_HA", /* name */
2020 FALSE, /* partial_inplace */
2021 0, /* src_mask */
2022 0xffff, /* dst_mask */
2023 TRUE), /* pcrel_offset */
2024
2025 /* Like R_PPC64_REL16_HA but for split field in addpcis. */
2026 HOWTO (R_PPC64_REL16DX_HA, /* type */
2027 16, /* rightshift */
2028 2, /* size (0 = byte, 1 = short, 2 = long) */
2029 16, /* bitsize */
2030 TRUE, /* pc_relative */
2031 0, /* bitpos */
2032 complain_overflow_signed, /* complain_on_overflow */
2033 ppc64_elf_ha_reloc, /* special_function */
2034 "R_PPC64_REL16DX_HA", /* name */
2035 FALSE, /* partial_inplace */
2036 0, /* src_mask */
2037 0x1fffc1, /* dst_mask */
2038 TRUE), /* pcrel_offset */
2039
2040 /* Like R_PPC64_ADDR16_HI, but no overflow. */
2041 HOWTO (R_PPC64_ADDR16_HIGH, /* type */
2042 16, /* rightshift */
2043 1, /* size (0 = byte, 1 = short, 2 = long) */
2044 16, /* bitsize */
2045 FALSE, /* pc_relative */
2046 0, /* bitpos */
2047 complain_overflow_dont, /* complain_on_overflow */
2048 bfd_elf_generic_reloc, /* special_function */
2049 "R_PPC64_ADDR16_HIGH", /* name */
2050 FALSE, /* partial_inplace */
2051 0, /* src_mask */
2052 0xffff, /* dst_mask */
2053 FALSE), /* pcrel_offset */
2054
2055 /* Like R_PPC64_ADDR16_HA, but no overflow. */
2056 HOWTO (R_PPC64_ADDR16_HIGHA, /* type */
2057 16, /* rightshift */
2058 1, /* size (0 = byte, 1 = short, 2 = long) */
2059 16, /* bitsize */
2060 FALSE, /* pc_relative */
2061 0, /* bitpos */
2062 complain_overflow_dont, /* complain_on_overflow */
2063 ppc64_elf_ha_reloc, /* special_function */
2064 "R_PPC64_ADDR16_HIGHA", /* name */
2065 FALSE, /* partial_inplace */
2066 0, /* src_mask */
2067 0xffff, /* dst_mask */
2068 FALSE), /* pcrel_offset */
2069
2070 /* Like R_PPC64_DTPREL16_HI, but no overflow. */
2071 HOWTO (R_PPC64_DTPREL16_HIGH,
2072 16, /* rightshift */
2073 1, /* size (0 = byte, 1 = short, 2 = long) */
2074 16, /* bitsize */
2075 FALSE, /* pc_relative */
2076 0, /* bitpos */
2077 complain_overflow_dont, /* complain_on_overflow */
2078 ppc64_elf_unhandled_reloc, /* special_function */
2079 "R_PPC64_DTPREL16_HIGH", /* name */
2080 FALSE, /* partial_inplace */
2081 0, /* src_mask */
2082 0xffff, /* dst_mask */
2083 FALSE), /* pcrel_offset */
2084
2085 /* Like R_PPC64_DTPREL16_HA, but no overflow. */
2086 HOWTO (R_PPC64_DTPREL16_HIGHA,
2087 16, /* rightshift */
2088 1, /* size (0 = byte, 1 = short, 2 = long) */
2089 16, /* bitsize */
2090 FALSE, /* pc_relative */
2091 0, /* bitpos */
2092 complain_overflow_dont, /* complain_on_overflow */
2093 ppc64_elf_unhandled_reloc, /* special_function */
2094 "R_PPC64_DTPREL16_HIGHA", /* name */
2095 FALSE, /* partial_inplace */
2096 0, /* src_mask */
2097 0xffff, /* dst_mask */
2098 FALSE), /* pcrel_offset */
2099
2100 /* Like R_PPC64_TPREL16_HI, but no overflow. */
2101 HOWTO (R_PPC64_TPREL16_HIGH,
2102 16, /* rightshift */
2103 1, /* size (0 = byte, 1 = short, 2 = long) */
2104 16, /* bitsize */
2105 FALSE, /* pc_relative */
2106 0, /* bitpos */
2107 complain_overflow_dont, /* complain_on_overflow */
2108 ppc64_elf_unhandled_reloc, /* special_function */
2109 "R_PPC64_TPREL16_HIGH", /* name */
2110 FALSE, /* partial_inplace */
2111 0, /* src_mask */
2112 0xffff, /* dst_mask */
2113 FALSE), /* pcrel_offset */
2114
2115 /* Like R_PPC64_TPREL16_HA, but no overflow. */
2116 HOWTO (R_PPC64_TPREL16_HIGHA,
2117 16, /* rightshift */
2118 1, /* size (0 = byte, 1 = short, 2 = long) */
2119 16, /* bitsize */
2120 FALSE, /* pc_relative */
2121 0, /* bitpos */
2122 complain_overflow_dont, /* complain_on_overflow */
2123 ppc64_elf_unhandled_reloc, /* special_function */
2124 "R_PPC64_TPREL16_HIGHA", /* name */
2125 FALSE, /* partial_inplace */
2126 0, /* src_mask */
2127 0xffff, /* dst_mask */
2128 FALSE), /* pcrel_offset */
2129
2130 /* Like ADDR64, but use local entry point of function. */
2131 HOWTO (R_PPC64_ADDR64_LOCAL, /* type */
2132 0, /* rightshift */
2133 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
2134 64, /* bitsize */
2135 FALSE, /* pc_relative */
2136 0, /* bitpos */
2137 complain_overflow_dont, /* complain_on_overflow */
2138 bfd_elf_generic_reloc, /* special_function */
2139 "R_PPC64_ADDR64_LOCAL", /* name */
2140 FALSE, /* partial_inplace */
2141 0, /* src_mask */
2142 ONES (64), /* dst_mask */
2143 FALSE), /* pcrel_offset */
2144
2145 /* GNU extension to record C++ vtable hierarchy. */
2146 HOWTO (R_PPC64_GNU_VTINHERIT, /* type */
2147 0, /* rightshift */
2148 0, /* size (0 = byte, 1 = short, 2 = long) */
2149 0, /* bitsize */
2150 FALSE, /* pc_relative */
2151 0, /* bitpos */
2152 complain_overflow_dont, /* complain_on_overflow */
2153 NULL, /* special_function */
2154 "R_PPC64_GNU_VTINHERIT", /* name */
2155 FALSE, /* partial_inplace */
2156 0, /* src_mask */
2157 0, /* dst_mask */
2158 FALSE), /* pcrel_offset */
2159
2160 /* GNU extension to record C++ vtable member usage. */
2161 HOWTO (R_PPC64_GNU_VTENTRY, /* type */
2162 0, /* rightshift */
2163 0, /* size (0 = byte, 1 = short, 2 = long) */
2164 0, /* bitsize */
2165 FALSE, /* pc_relative */
2166 0, /* bitpos */
2167 complain_overflow_dont, /* complain_on_overflow */
2168 NULL, /* special_function */
2169 "R_PPC64_GNU_VTENTRY", /* name */
2170 FALSE, /* partial_inplace */
2171 0, /* src_mask */
2172 0, /* dst_mask */
2173 FALSE), /* pcrel_offset */
2174 };
2175
2176 \f
2177 /* Initialize the ppc64_elf_howto_table, so that linear accesses can
2178 be done. */
2179
2180 static void
2181 ppc_howto_init (void)
2182 {
2183 unsigned int i, type;
2184
2185 for (i = 0; i < ARRAY_SIZE (ppc64_elf_howto_raw); i++)
2186 {
2187 type = ppc64_elf_howto_raw[i].type;
2188 BFD_ASSERT (type < ARRAY_SIZE (ppc64_elf_howto_table));
2189 ppc64_elf_howto_table[type] = &ppc64_elf_howto_raw[i];
2190 }
2191 }
2192
2193 static reloc_howto_type *
2194 ppc64_elf_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2195 bfd_reloc_code_real_type code)
2196 {
2197 enum elf_ppc64_reloc_type r = R_PPC64_NONE;
2198
2199 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2200 /* Initialize howto table if needed. */
2201 ppc_howto_init ();
2202
2203 switch (code)
2204 {
2205 default:
2206 return NULL;
2207
2208 case BFD_RELOC_NONE: r = R_PPC64_NONE;
2209 break;
2210 case BFD_RELOC_32: r = R_PPC64_ADDR32;
2211 break;
2212 case BFD_RELOC_PPC_BA26: r = R_PPC64_ADDR24;
2213 break;
2214 case BFD_RELOC_16: r = R_PPC64_ADDR16;
2215 break;
2216 case BFD_RELOC_LO16: r = R_PPC64_ADDR16_LO;
2217 break;
2218 case BFD_RELOC_HI16: r = R_PPC64_ADDR16_HI;
2219 break;
2220 case BFD_RELOC_PPC64_ADDR16_HIGH: r = R_PPC64_ADDR16_HIGH;
2221 break;
2222 case BFD_RELOC_HI16_S: r = R_PPC64_ADDR16_HA;
2223 break;
2224 case BFD_RELOC_PPC64_ADDR16_HIGHA: r = R_PPC64_ADDR16_HIGHA;
2225 break;
2226 case BFD_RELOC_PPC_BA16: r = R_PPC64_ADDR14;
2227 break;
2228 case BFD_RELOC_PPC_BA16_BRTAKEN: r = R_PPC64_ADDR14_BRTAKEN;
2229 break;
2230 case BFD_RELOC_PPC_BA16_BRNTAKEN: r = R_PPC64_ADDR14_BRNTAKEN;
2231 break;
2232 case BFD_RELOC_PPC_B26: r = R_PPC64_REL24;
2233 break;
2234 case BFD_RELOC_PPC_B16: r = R_PPC64_REL14;
2235 break;
2236 case BFD_RELOC_PPC_B16_BRTAKEN: r = R_PPC64_REL14_BRTAKEN;
2237 break;
2238 case BFD_RELOC_PPC_B16_BRNTAKEN: r = R_PPC64_REL14_BRNTAKEN;
2239 break;
2240 case BFD_RELOC_16_GOTOFF: r = R_PPC64_GOT16;
2241 break;
2242 case BFD_RELOC_LO16_GOTOFF: r = R_PPC64_GOT16_LO;
2243 break;
2244 case BFD_RELOC_HI16_GOTOFF: r = R_PPC64_GOT16_HI;
2245 break;
2246 case BFD_RELOC_HI16_S_GOTOFF: r = R_PPC64_GOT16_HA;
2247 break;
2248 case BFD_RELOC_PPC_COPY: r = R_PPC64_COPY;
2249 break;
2250 case BFD_RELOC_PPC_GLOB_DAT: r = R_PPC64_GLOB_DAT;
2251 break;
2252 case BFD_RELOC_32_PCREL: r = R_PPC64_REL32;
2253 break;
2254 case BFD_RELOC_32_PLTOFF: r = R_PPC64_PLT32;
2255 break;
2256 case BFD_RELOC_32_PLT_PCREL: r = R_PPC64_PLTREL32;
2257 break;
2258 case BFD_RELOC_LO16_PLTOFF: r = R_PPC64_PLT16_LO;
2259 break;
2260 case BFD_RELOC_HI16_PLTOFF: r = R_PPC64_PLT16_HI;
2261 break;
2262 case BFD_RELOC_HI16_S_PLTOFF: r = R_PPC64_PLT16_HA;
2263 break;
2264 case BFD_RELOC_16_BASEREL: r = R_PPC64_SECTOFF;
2265 break;
2266 case BFD_RELOC_LO16_BASEREL: r = R_PPC64_SECTOFF_LO;
2267 break;
2268 case BFD_RELOC_HI16_BASEREL: r = R_PPC64_SECTOFF_HI;
2269 break;
2270 case BFD_RELOC_HI16_S_BASEREL: r = R_PPC64_SECTOFF_HA;
2271 break;
2272 case BFD_RELOC_CTOR: r = R_PPC64_ADDR64;
2273 break;
2274 case BFD_RELOC_64: r = R_PPC64_ADDR64;
2275 break;
2276 case BFD_RELOC_PPC64_HIGHER: r = R_PPC64_ADDR16_HIGHER;
2277 break;
2278 case BFD_RELOC_PPC64_HIGHER_S: r = R_PPC64_ADDR16_HIGHERA;
2279 break;
2280 case BFD_RELOC_PPC64_HIGHEST: r = R_PPC64_ADDR16_HIGHEST;
2281 break;
2282 case BFD_RELOC_PPC64_HIGHEST_S: r = R_PPC64_ADDR16_HIGHESTA;
2283 break;
2284 case BFD_RELOC_64_PCREL: r = R_PPC64_REL64;
2285 break;
2286 case BFD_RELOC_64_PLTOFF: r = R_PPC64_PLT64;
2287 break;
2288 case BFD_RELOC_64_PLT_PCREL: r = R_PPC64_PLTREL64;
2289 break;
2290 case BFD_RELOC_PPC_TOC16: r = R_PPC64_TOC16;
2291 break;
2292 case BFD_RELOC_PPC64_TOC16_LO: r = R_PPC64_TOC16_LO;
2293 break;
2294 case BFD_RELOC_PPC64_TOC16_HI: r = R_PPC64_TOC16_HI;
2295 break;
2296 case BFD_RELOC_PPC64_TOC16_HA: r = R_PPC64_TOC16_HA;
2297 break;
2298 case BFD_RELOC_PPC64_TOC: r = R_PPC64_TOC;
2299 break;
2300 case BFD_RELOC_PPC64_PLTGOT16: r = R_PPC64_PLTGOT16;
2301 break;
2302 case BFD_RELOC_PPC64_PLTGOT16_LO: r = R_PPC64_PLTGOT16_LO;
2303 break;
2304 case BFD_RELOC_PPC64_PLTGOT16_HI: r = R_PPC64_PLTGOT16_HI;
2305 break;
2306 case BFD_RELOC_PPC64_PLTGOT16_HA: r = R_PPC64_PLTGOT16_HA;
2307 break;
2308 case BFD_RELOC_PPC64_ADDR16_DS: r = R_PPC64_ADDR16_DS;
2309 break;
2310 case BFD_RELOC_PPC64_ADDR16_LO_DS: r = R_PPC64_ADDR16_LO_DS;
2311 break;
2312 case BFD_RELOC_PPC64_GOT16_DS: r = R_PPC64_GOT16_DS;
2313 break;
2314 case BFD_RELOC_PPC64_GOT16_LO_DS: r = R_PPC64_GOT16_LO_DS;
2315 break;
2316 case BFD_RELOC_PPC64_PLT16_LO_DS: r = R_PPC64_PLT16_LO_DS;
2317 break;
2318 case BFD_RELOC_PPC64_SECTOFF_DS: r = R_PPC64_SECTOFF_DS;
2319 break;
2320 case BFD_RELOC_PPC64_SECTOFF_LO_DS: r = R_PPC64_SECTOFF_LO_DS;
2321 break;
2322 case BFD_RELOC_PPC64_TOC16_DS: r = R_PPC64_TOC16_DS;
2323 break;
2324 case BFD_RELOC_PPC64_TOC16_LO_DS: r = R_PPC64_TOC16_LO_DS;
2325 break;
2326 case BFD_RELOC_PPC64_PLTGOT16_DS: r = R_PPC64_PLTGOT16_DS;
2327 break;
2328 case BFD_RELOC_PPC64_PLTGOT16_LO_DS: r = R_PPC64_PLTGOT16_LO_DS;
2329 break;
2330 case BFD_RELOC_PPC_TLS: r = R_PPC64_TLS;
2331 break;
2332 case BFD_RELOC_PPC_TLSGD: r = R_PPC64_TLSGD;
2333 break;
2334 case BFD_RELOC_PPC_TLSLD: r = R_PPC64_TLSLD;
2335 break;
2336 case BFD_RELOC_PPC_DTPMOD: r = R_PPC64_DTPMOD64;
2337 break;
2338 case BFD_RELOC_PPC_TPREL16: r = R_PPC64_TPREL16;
2339 break;
2340 case BFD_RELOC_PPC_TPREL16_LO: r = R_PPC64_TPREL16_LO;
2341 break;
2342 case BFD_RELOC_PPC_TPREL16_HI: r = R_PPC64_TPREL16_HI;
2343 break;
2344 case BFD_RELOC_PPC64_TPREL16_HIGH: r = R_PPC64_TPREL16_HIGH;
2345 break;
2346 case BFD_RELOC_PPC_TPREL16_HA: r = R_PPC64_TPREL16_HA;
2347 break;
2348 case BFD_RELOC_PPC64_TPREL16_HIGHA: r = R_PPC64_TPREL16_HIGHA;
2349 break;
2350 case BFD_RELOC_PPC_TPREL: r = R_PPC64_TPREL64;
2351 break;
2352 case BFD_RELOC_PPC_DTPREL16: r = R_PPC64_DTPREL16;
2353 break;
2354 case BFD_RELOC_PPC_DTPREL16_LO: r = R_PPC64_DTPREL16_LO;
2355 break;
2356 case BFD_RELOC_PPC_DTPREL16_HI: r = R_PPC64_DTPREL16_HI;
2357 break;
2358 case BFD_RELOC_PPC64_DTPREL16_HIGH: r = R_PPC64_DTPREL16_HIGH;
2359 break;
2360 case BFD_RELOC_PPC_DTPREL16_HA: r = R_PPC64_DTPREL16_HA;
2361 break;
2362 case BFD_RELOC_PPC64_DTPREL16_HIGHA: r = R_PPC64_DTPREL16_HIGHA;
2363 break;
2364 case BFD_RELOC_PPC_DTPREL: r = R_PPC64_DTPREL64;
2365 break;
2366 case BFD_RELOC_PPC_GOT_TLSGD16: r = R_PPC64_GOT_TLSGD16;
2367 break;
2368 case BFD_RELOC_PPC_GOT_TLSGD16_LO: r = R_PPC64_GOT_TLSGD16_LO;
2369 break;
2370 case BFD_RELOC_PPC_GOT_TLSGD16_HI: r = R_PPC64_GOT_TLSGD16_HI;
2371 break;
2372 case BFD_RELOC_PPC_GOT_TLSGD16_HA: r = R_PPC64_GOT_TLSGD16_HA;
2373 break;
2374 case BFD_RELOC_PPC_GOT_TLSLD16: r = R_PPC64_GOT_TLSLD16;
2375 break;
2376 case BFD_RELOC_PPC_GOT_TLSLD16_LO: r = R_PPC64_GOT_TLSLD16_LO;
2377 break;
2378 case BFD_RELOC_PPC_GOT_TLSLD16_HI: r = R_PPC64_GOT_TLSLD16_HI;
2379 break;
2380 case BFD_RELOC_PPC_GOT_TLSLD16_HA: r = R_PPC64_GOT_TLSLD16_HA;
2381 break;
2382 case BFD_RELOC_PPC_GOT_TPREL16: r = R_PPC64_GOT_TPREL16_DS;
2383 break;
2384 case BFD_RELOC_PPC_GOT_TPREL16_LO: r = R_PPC64_GOT_TPREL16_LO_DS;
2385 break;
2386 case BFD_RELOC_PPC_GOT_TPREL16_HI: r = R_PPC64_GOT_TPREL16_HI;
2387 break;
2388 case BFD_RELOC_PPC_GOT_TPREL16_HA: r = R_PPC64_GOT_TPREL16_HA;
2389 break;
2390 case BFD_RELOC_PPC_GOT_DTPREL16: r = R_PPC64_GOT_DTPREL16_DS;
2391 break;
2392 case BFD_RELOC_PPC_GOT_DTPREL16_LO: r = R_PPC64_GOT_DTPREL16_LO_DS;
2393 break;
2394 case BFD_RELOC_PPC_GOT_DTPREL16_HI: r = R_PPC64_GOT_DTPREL16_HI;
2395 break;
2396 case BFD_RELOC_PPC_GOT_DTPREL16_HA: r = R_PPC64_GOT_DTPREL16_HA;
2397 break;
2398 case BFD_RELOC_PPC64_TPREL16_DS: r = R_PPC64_TPREL16_DS;
2399 break;
2400 case BFD_RELOC_PPC64_TPREL16_LO_DS: r = R_PPC64_TPREL16_LO_DS;
2401 break;
2402 case BFD_RELOC_PPC64_TPREL16_HIGHER: r = R_PPC64_TPREL16_HIGHER;
2403 break;
2404 case BFD_RELOC_PPC64_TPREL16_HIGHERA: r = R_PPC64_TPREL16_HIGHERA;
2405 break;
2406 case BFD_RELOC_PPC64_TPREL16_HIGHEST: r = R_PPC64_TPREL16_HIGHEST;
2407 break;
2408 case BFD_RELOC_PPC64_TPREL16_HIGHESTA: r = R_PPC64_TPREL16_HIGHESTA;
2409 break;
2410 case BFD_RELOC_PPC64_DTPREL16_DS: r = R_PPC64_DTPREL16_DS;
2411 break;
2412 case BFD_RELOC_PPC64_DTPREL16_LO_DS: r = R_PPC64_DTPREL16_LO_DS;
2413 break;
2414 case BFD_RELOC_PPC64_DTPREL16_HIGHER: r = R_PPC64_DTPREL16_HIGHER;
2415 break;
2416 case BFD_RELOC_PPC64_DTPREL16_HIGHERA: r = R_PPC64_DTPREL16_HIGHERA;
2417 break;
2418 case BFD_RELOC_PPC64_DTPREL16_HIGHEST: r = R_PPC64_DTPREL16_HIGHEST;
2419 break;
2420 case BFD_RELOC_PPC64_DTPREL16_HIGHESTA: r = R_PPC64_DTPREL16_HIGHESTA;
2421 break;
2422 case BFD_RELOC_16_PCREL: r = R_PPC64_REL16;
2423 break;
2424 case BFD_RELOC_LO16_PCREL: r = R_PPC64_REL16_LO;
2425 break;
2426 case BFD_RELOC_HI16_PCREL: r = R_PPC64_REL16_HI;
2427 break;
2428 case BFD_RELOC_HI16_S_PCREL: r = R_PPC64_REL16_HA;
2429 break;
2430 case BFD_RELOC_PPC_REL16DX_HA: r = R_PPC64_REL16DX_HA;
2431 break;
2432 case BFD_RELOC_PPC64_ADDR64_LOCAL: r = R_PPC64_ADDR64_LOCAL;
2433 break;
2434 case BFD_RELOC_VTABLE_INHERIT: r = R_PPC64_GNU_VTINHERIT;
2435 break;
2436 case BFD_RELOC_VTABLE_ENTRY: r = R_PPC64_GNU_VTENTRY;
2437 break;
2438 }
2439
2440 return ppc64_elf_howto_table[r];
2441 };
2442
2443 static reloc_howto_type *
2444 ppc64_elf_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2445 const char *r_name)
2446 {
2447 unsigned int i;
2448
2449 for (i = 0; i < ARRAY_SIZE (ppc64_elf_howto_raw); i++)
2450 if (ppc64_elf_howto_raw[i].name != NULL
2451 && strcasecmp (ppc64_elf_howto_raw[i].name, r_name) == 0)
2452 return &ppc64_elf_howto_raw[i];
2453
2454 return NULL;
2455 }
2456
2457 /* Set the howto pointer for a PowerPC ELF reloc. */
2458
2459 static void
2460 ppc64_elf_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr,
2461 Elf_Internal_Rela *dst)
2462 {
2463 unsigned int type;
2464
2465 /* Initialize howto table if needed. */
2466 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2467 ppc_howto_init ();
2468
2469 type = ELF64_R_TYPE (dst->r_info);
2470 if (type >= ARRAY_SIZE (ppc64_elf_howto_table))
2471 {
2472 (*_bfd_error_handler) (_("%B: invalid relocation type %d"),
2473 abfd, (int) type);
2474 type = R_PPC64_NONE;
2475 }
2476 cache_ptr->howto = ppc64_elf_howto_table[type];
2477 }
2478
2479 /* Handle the R_PPC64_ADDR16_HA and similar relocs. */
2480
2481 static bfd_reloc_status_type
2482 ppc64_elf_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2483 void *data, asection *input_section,
2484 bfd *output_bfd, char **error_message)
2485 {
2486 enum elf_ppc64_reloc_type r_type;
2487 long insn;
2488 bfd_size_type octets;
2489 bfd_vma value;
2490
2491 /* If this is a relocatable link (output_bfd test tells us), just
2492 call the generic function. Any adjustment will be done at final
2493 link time. */
2494 if (output_bfd != NULL)
2495 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2496 input_section, output_bfd, error_message);
2497
2498 /* Adjust the addend for sign extension of the low 16 bits.
2499 We won't actually be using the low 16 bits, so trashing them
2500 doesn't matter. */
2501 reloc_entry->addend += 0x8000;
2502 r_type = reloc_entry->howto->type;
2503 if (r_type != R_PPC64_REL16DX_HA)
2504 return bfd_reloc_continue;
2505
2506 value = 0;
2507 if (!bfd_is_com_section (symbol->section))
2508 value = symbol->value;
2509 value += (reloc_entry->addend
2510 + symbol->section->output_offset
2511 + symbol->section->output_section->vma);
2512 value -= (reloc_entry->address
2513 + input_section->output_offset
2514 + input_section->output_section->vma);
2515 value = (bfd_signed_vma) value >> 16;
2516
2517 octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2518 insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
2519 insn &= ~0x1fffc1;
2520 insn |= (value & 0xffc1) | ((value & 0x3e) << 15);
2521 bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
2522 if (value + 0x8000 > 0xffff)
2523 return bfd_reloc_overflow;
2524 return bfd_reloc_ok;
2525 }
2526
2527 static bfd_reloc_status_type
2528 ppc64_elf_branch_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2529 void *data, asection *input_section,
2530 bfd *output_bfd, char **error_message)
2531 {
2532 if (output_bfd != NULL)
2533 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2534 input_section, output_bfd, error_message);
2535
2536 if (strcmp (symbol->section->name, ".opd") == 0
2537 && (symbol->section->owner->flags & DYNAMIC) == 0)
2538 {
2539 bfd_vma dest = opd_entry_value (symbol->section,
2540 symbol->value + reloc_entry->addend,
2541 NULL, NULL, FALSE);
2542 if (dest != (bfd_vma) -1)
2543 reloc_entry->addend = dest - (symbol->value
2544 + symbol->section->output_section->vma
2545 + symbol->section->output_offset);
2546 }
2547 else
2548 {
2549 elf_symbol_type *elfsym = (elf_symbol_type *) symbol;
2550
2551 if (symbol->section->owner != abfd
2552 && abiversion (symbol->section->owner) >= 2)
2553 {
2554 unsigned int i;
2555
2556 for (i = 0; i < symbol->section->owner->symcount; ++i)
2557 {
2558 asymbol *symdef = symbol->section->owner->outsymbols[i];
2559
2560 if (strcmp (symdef->name, symbol->name) == 0)
2561 {
2562 elfsym = (elf_symbol_type *) symdef;
2563 break;
2564 }
2565 }
2566 }
2567 reloc_entry->addend
2568 += PPC64_LOCAL_ENTRY_OFFSET (elfsym->internal_elf_sym.st_other);
2569 }
2570 return bfd_reloc_continue;
2571 }
2572
2573 static bfd_reloc_status_type
2574 ppc64_elf_brtaken_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2575 void *data, asection *input_section,
2576 bfd *output_bfd, char **error_message)
2577 {
2578 long insn;
2579 enum elf_ppc64_reloc_type r_type;
2580 bfd_size_type octets;
2581 /* Assume 'at' branch hints. */
2582 bfd_boolean is_isa_v2 = TRUE;
2583
2584 /* If this is a relocatable link (output_bfd test tells us), just
2585 call the generic function. Any adjustment will be done at final
2586 link time. */
2587 if (output_bfd != NULL)
2588 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2589 input_section, output_bfd, error_message);
2590
2591 octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2592 insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
2593 insn &= ~(0x01 << 21);
2594 r_type = reloc_entry->howto->type;
2595 if (r_type == R_PPC64_ADDR14_BRTAKEN
2596 || r_type == R_PPC64_REL14_BRTAKEN)
2597 insn |= 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field. */
2598
2599 if (is_isa_v2)
2600 {
2601 /* Set 'a' bit. This is 0b00010 in BO field for branch
2602 on CR(BI) insns (BO == 001at or 011at), and 0b01000
2603 for branch on CTR insns (BO == 1a00t or 1a01t). */
2604 if ((insn & (0x14 << 21)) == (0x04 << 21))
2605 insn |= 0x02 << 21;
2606 else if ((insn & (0x14 << 21)) == (0x10 << 21))
2607 insn |= 0x08 << 21;
2608 else
2609 goto out;
2610 }
2611 else
2612 {
2613 bfd_vma target = 0;
2614 bfd_vma from;
2615
2616 if (!bfd_is_com_section (symbol->section))
2617 target = symbol->value;
2618 target += symbol->section->output_section->vma;
2619 target += symbol->section->output_offset;
2620 target += reloc_entry->addend;
2621
2622 from = (reloc_entry->address
2623 + input_section->output_offset
2624 + input_section->output_section->vma);
2625
2626 /* Invert 'y' bit if not the default. */
2627 if ((bfd_signed_vma) (target - from) < 0)
2628 insn ^= 0x01 << 21;
2629 }
2630 bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
2631 out:
2632 return ppc64_elf_branch_reloc (abfd, reloc_entry, symbol, data,
2633 input_section, output_bfd, error_message);
2634 }
2635
2636 static bfd_reloc_status_type
2637 ppc64_elf_sectoff_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2638 void *data, asection *input_section,
2639 bfd *output_bfd, char **error_message)
2640 {
2641 /* If this is a relocatable link (output_bfd test tells us), just
2642 call the generic function. Any adjustment will be done at final
2643 link time. */
2644 if (output_bfd != NULL)
2645 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2646 input_section, output_bfd, error_message);
2647
2648 /* Subtract the symbol section base address. */
2649 reloc_entry->addend -= symbol->section->output_section->vma;
2650 return bfd_reloc_continue;
2651 }
2652
2653 static bfd_reloc_status_type
2654 ppc64_elf_sectoff_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2655 void *data, asection *input_section,
2656 bfd *output_bfd, char **error_message)
2657 {
2658 /* If this is a relocatable link (output_bfd test tells us), just
2659 call the generic function. Any adjustment will be done at final
2660 link time. */
2661 if (output_bfd != NULL)
2662 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2663 input_section, output_bfd, error_message);
2664
2665 /* Subtract the symbol section base address. */
2666 reloc_entry->addend -= symbol->section->output_section->vma;
2667
2668 /* Adjust the addend for sign extension of the low 16 bits. */
2669 reloc_entry->addend += 0x8000;
2670 return bfd_reloc_continue;
2671 }
2672
2673 static bfd_reloc_status_type
2674 ppc64_elf_toc_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2675 void *data, asection *input_section,
2676 bfd *output_bfd, char **error_message)
2677 {
2678 bfd_vma TOCstart;
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 TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2688 if (TOCstart == 0)
2689 TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2690
2691 /* Subtract the TOC base address. */
2692 reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2693 return bfd_reloc_continue;
2694 }
2695
2696 static bfd_reloc_status_type
2697 ppc64_elf_toc_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2698 void *data, asection *input_section,
2699 bfd *output_bfd, char **error_message)
2700 {
2701 bfd_vma TOCstart;
2702
2703 /* If this is a relocatable link (output_bfd test tells us), just
2704 call the generic function. Any adjustment will be done at final
2705 link time. */
2706 if (output_bfd != NULL)
2707 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2708 input_section, output_bfd, error_message);
2709
2710 TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2711 if (TOCstart == 0)
2712 TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2713
2714 /* Subtract the TOC base address. */
2715 reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2716
2717 /* Adjust the addend for sign extension of the low 16 bits. */
2718 reloc_entry->addend += 0x8000;
2719 return bfd_reloc_continue;
2720 }
2721
2722 static bfd_reloc_status_type
2723 ppc64_elf_toc64_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2724 void *data, asection *input_section,
2725 bfd *output_bfd, char **error_message)
2726 {
2727 bfd_vma TOCstart;
2728 bfd_size_type octets;
2729
2730 /* If this is a relocatable link (output_bfd test tells us), just
2731 call the generic function. Any adjustment will be done at final
2732 link time. */
2733 if (output_bfd != NULL)
2734 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2735 input_section, output_bfd, error_message);
2736
2737 TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2738 if (TOCstart == 0)
2739 TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2740
2741 octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2742 bfd_put_64 (abfd, TOCstart + TOC_BASE_OFF, (bfd_byte *) data + octets);
2743 return bfd_reloc_ok;
2744 }
2745
2746 static bfd_reloc_status_type
2747 ppc64_elf_unhandled_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2748 void *data, asection *input_section,
2749 bfd *output_bfd, char **error_message)
2750 {
2751 /* If this is a relocatable link (output_bfd test tells us), just
2752 call the generic function. Any adjustment will be done at final
2753 link time. */
2754 if (output_bfd != NULL)
2755 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2756 input_section, output_bfd, error_message);
2757
2758 if (error_message != NULL)
2759 {
2760 static char buf[60];
2761 sprintf (buf, "generic linker can't handle %s",
2762 reloc_entry->howto->name);
2763 *error_message = buf;
2764 }
2765 return bfd_reloc_dangerous;
2766 }
2767
2768 /* Track GOT entries needed for a given symbol. We might need more
2769 than one got entry per symbol. */
2770 struct got_entry
2771 {
2772 struct got_entry *next;
2773
2774 /* The symbol addend that we'll be placing in the GOT. */
2775 bfd_vma addend;
2776
2777 /* Unlike other ELF targets, we use separate GOT entries for the same
2778 symbol referenced from different input files. This is to support
2779 automatic multiple TOC/GOT sections, where the TOC base can vary
2780 from one input file to another. After partitioning into TOC groups
2781 we merge entries within the group.
2782
2783 Point to the BFD owning this GOT entry. */
2784 bfd *owner;
2785
2786 /* Zero for non-tls entries, or TLS_TLS and one of TLS_GD, TLS_LD,
2787 TLS_TPREL or TLS_DTPREL for tls entries. */
2788 unsigned char tls_type;
2789
2790 /* Non-zero if got.ent points to real entry. */
2791 unsigned char is_indirect;
2792
2793 /* Reference count until size_dynamic_sections, GOT offset thereafter. */
2794 union
2795 {
2796 bfd_signed_vma refcount;
2797 bfd_vma offset;
2798 struct got_entry *ent;
2799 } got;
2800 };
2801
2802 /* The same for PLT. */
2803 struct plt_entry
2804 {
2805 struct plt_entry *next;
2806
2807 bfd_vma addend;
2808
2809 union
2810 {
2811 bfd_signed_vma refcount;
2812 bfd_vma offset;
2813 } plt;
2814 };
2815
2816 struct ppc64_elf_obj_tdata
2817 {
2818 struct elf_obj_tdata elf;
2819
2820 /* Shortcuts to dynamic linker sections. */
2821 asection *got;
2822 asection *relgot;
2823
2824 /* Used during garbage collection. We attach global symbols defined
2825 on removed .opd entries to this section so that the sym is removed. */
2826 asection *deleted_section;
2827
2828 /* TLS local dynamic got entry handling. Support for multiple GOT
2829 sections means we potentially need one of these for each input bfd. */
2830 struct got_entry tlsld_got;
2831
2832 union {
2833 /* A copy of relocs before they are modified for --emit-relocs. */
2834 Elf_Internal_Rela *relocs;
2835
2836 /* Section contents. */
2837 bfd_byte *contents;
2838 } opd;
2839
2840 /* Nonzero if this bfd has small toc/got relocs, ie. that expect
2841 the reloc to be in the range -32768 to 32767. */
2842 unsigned int has_small_toc_reloc : 1;
2843
2844 /* Set if toc/got ha relocs detected not using r2, or lo reloc
2845 instruction not one we handle. */
2846 unsigned int unexpected_toc_insn : 1;
2847 };
2848
2849 #define ppc64_elf_tdata(bfd) \
2850 ((struct ppc64_elf_obj_tdata *) (bfd)->tdata.any)
2851
2852 #define ppc64_tlsld_got(bfd) \
2853 (&ppc64_elf_tdata (bfd)->tlsld_got)
2854
2855 #define is_ppc64_elf(bfd) \
2856 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
2857 && elf_object_id (bfd) == PPC64_ELF_DATA)
2858
2859 /* Override the generic function because we store some extras. */
2860
2861 static bfd_boolean
2862 ppc64_elf_mkobject (bfd *abfd)
2863 {
2864 return bfd_elf_allocate_object (abfd, sizeof (struct ppc64_elf_obj_tdata),
2865 PPC64_ELF_DATA);
2866 }
2867
2868 /* Fix bad default arch selected for a 64 bit input bfd when the
2869 default is 32 bit. */
2870
2871 static bfd_boolean
2872 ppc64_elf_object_p (bfd *abfd)
2873 {
2874 if (abfd->arch_info->the_default && abfd->arch_info->bits_per_word == 32)
2875 {
2876 Elf_Internal_Ehdr *i_ehdr = elf_elfheader (abfd);
2877
2878 if (i_ehdr->e_ident[EI_CLASS] == ELFCLASS64)
2879 {
2880 /* Relies on arch after 32 bit default being 64 bit default. */
2881 abfd->arch_info = abfd->arch_info->next;
2882 BFD_ASSERT (abfd->arch_info->bits_per_word == 64);
2883 }
2884 }
2885 return TRUE;
2886 }
2887
2888 /* Support for core dump NOTE sections. */
2889
2890 static bfd_boolean
2891 ppc64_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
2892 {
2893 size_t offset, size;
2894
2895 if (note->descsz != 504)
2896 return FALSE;
2897
2898 /* pr_cursig */
2899 elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
2900
2901 /* pr_pid */
2902 elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 32);
2903
2904 /* pr_reg */
2905 offset = 112;
2906 size = 384;
2907
2908 /* Make a ".reg/999" section. */
2909 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
2910 size, note->descpos + offset);
2911 }
2912
2913 static bfd_boolean
2914 ppc64_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
2915 {
2916 if (note->descsz != 136)
2917 return FALSE;
2918
2919 elf_tdata (abfd)->core->pid
2920 = bfd_get_32 (abfd, note->descdata + 24);
2921 elf_tdata (abfd)->core->program
2922 = _bfd_elfcore_strndup (abfd, note->descdata + 40, 16);
2923 elf_tdata (abfd)->core->command
2924 = _bfd_elfcore_strndup (abfd, note->descdata + 56, 80);
2925
2926 return TRUE;
2927 }
2928
2929 static char *
2930 ppc64_elf_write_core_note (bfd *abfd, char *buf, int *bufsiz, int note_type,
2931 ...)
2932 {
2933 switch (note_type)
2934 {
2935 default:
2936 return NULL;
2937
2938 case NT_PRPSINFO:
2939 {
2940 char data[136];
2941 va_list ap;
2942
2943 va_start (ap, note_type);
2944 memset (data, 0, sizeof (data));
2945 strncpy (data + 40, va_arg (ap, const char *), 16);
2946 strncpy (data + 56, va_arg (ap, const char *), 80);
2947 va_end (ap);
2948 return elfcore_write_note (abfd, buf, bufsiz,
2949 "CORE", note_type, data, sizeof (data));
2950 }
2951
2952 case NT_PRSTATUS:
2953 {
2954 char data[504];
2955 va_list ap;
2956 long pid;
2957 int cursig;
2958 const void *greg;
2959
2960 va_start (ap, note_type);
2961 memset (data, 0, 112);
2962 pid = va_arg (ap, long);
2963 bfd_put_32 (abfd, pid, data + 32);
2964 cursig = va_arg (ap, int);
2965 bfd_put_16 (abfd, cursig, data + 12);
2966 greg = va_arg (ap, const void *);
2967 memcpy (data + 112, greg, 384);
2968 memset (data + 496, 0, 8);
2969 va_end (ap);
2970 return elfcore_write_note (abfd, buf, bufsiz,
2971 "CORE", note_type, data, sizeof (data));
2972 }
2973 }
2974 }
2975
2976 /* Add extra PPC sections. */
2977
2978 static const struct bfd_elf_special_section ppc64_elf_special_sections[]=
2979 {
2980 { STRING_COMMA_LEN (".plt"), 0, SHT_NOBITS, 0 },
2981 { STRING_COMMA_LEN (".sbss"), -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE },
2982 { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2983 { STRING_COMMA_LEN (".toc"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2984 { STRING_COMMA_LEN (".toc1"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2985 { STRING_COMMA_LEN (".tocbss"), 0, SHT_NOBITS, SHF_ALLOC + SHF_WRITE },
2986 { NULL, 0, 0, 0, 0 }
2987 };
2988
2989 enum _ppc64_sec_type {
2990 sec_normal = 0,
2991 sec_opd = 1,
2992 sec_toc = 2
2993 };
2994
2995 struct _ppc64_elf_section_data
2996 {
2997 struct bfd_elf_section_data elf;
2998
2999 union
3000 {
3001 /* An array with one entry for each opd function descriptor,
3002 and some spares since opd entries may be either 16 or 24 bytes. */
3003 #define OPD_NDX(OFF) ((OFF) >> 4)
3004 struct _opd_sec_data
3005 {
3006 /* Points to the function code section for local opd entries. */
3007 asection **func_sec;
3008
3009 /* After editing .opd, adjust references to opd local syms. */
3010 long *adjust;
3011 } opd;
3012
3013 /* An array for toc sections, indexed by offset/8. */
3014 struct _toc_sec_data
3015 {
3016 /* Specifies the relocation symbol index used at a given toc offset. */
3017 unsigned *symndx;
3018
3019 /* And the relocation addend. */
3020 bfd_vma *add;
3021 } toc;
3022 } u;
3023
3024 enum _ppc64_sec_type sec_type:2;
3025
3026 /* Flag set when small branches are detected. Used to
3027 select suitable defaults for the stub group size. */
3028 unsigned int has_14bit_branch:1;
3029 };
3030
3031 #define ppc64_elf_section_data(sec) \
3032 ((struct _ppc64_elf_section_data *) elf_section_data (sec))
3033
3034 static bfd_boolean
3035 ppc64_elf_new_section_hook (bfd *abfd, asection *sec)
3036 {
3037 if (!sec->used_by_bfd)
3038 {
3039 struct _ppc64_elf_section_data *sdata;
3040 bfd_size_type amt = sizeof (*sdata);
3041
3042 sdata = bfd_zalloc (abfd, amt);
3043 if (sdata == NULL)
3044 return FALSE;
3045 sec->used_by_bfd = sdata;
3046 }
3047
3048 return _bfd_elf_new_section_hook (abfd, sec);
3049 }
3050
3051 static struct _opd_sec_data *
3052 get_opd_info (asection * sec)
3053 {
3054 if (sec != NULL
3055 && ppc64_elf_section_data (sec) != NULL
3056 && ppc64_elf_section_data (sec)->sec_type == sec_opd)
3057 return &ppc64_elf_section_data (sec)->u.opd;
3058 return NULL;
3059 }
3060 \f
3061 /* Parameters for the qsort hook. */
3062 static bfd_boolean synthetic_relocatable;
3063
3064 /* qsort comparison function for ppc64_elf_get_synthetic_symtab. */
3065
3066 static int
3067 compare_symbols (const void *ap, const void *bp)
3068 {
3069 const asymbol *a = * (const asymbol **) ap;
3070 const asymbol *b = * (const asymbol **) bp;
3071
3072 /* Section symbols first. */
3073 if ((a->flags & BSF_SECTION_SYM) && !(b->flags & BSF_SECTION_SYM))
3074 return -1;
3075 if (!(a->flags & BSF_SECTION_SYM) && (b->flags & BSF_SECTION_SYM))
3076 return 1;
3077
3078 /* then .opd symbols. */
3079 if (strcmp (a->section->name, ".opd") == 0
3080 && strcmp (b->section->name, ".opd") != 0)
3081 return -1;
3082 if (strcmp (a->section->name, ".opd") != 0
3083 && strcmp (b->section->name, ".opd") == 0)
3084 return 1;
3085
3086 /* then other code symbols. */
3087 if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3088 == (SEC_CODE | SEC_ALLOC)
3089 && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3090 != (SEC_CODE | SEC_ALLOC))
3091 return -1;
3092
3093 if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3094 != (SEC_CODE | SEC_ALLOC)
3095 && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3096 == (SEC_CODE | SEC_ALLOC))
3097 return 1;
3098
3099 if (synthetic_relocatable)
3100 {
3101 if (a->section->id < b->section->id)
3102 return -1;
3103
3104 if (a->section->id > b->section->id)
3105 return 1;
3106 }
3107
3108 if (a->value + a->section->vma < b->value + b->section->vma)
3109 return -1;
3110
3111 if (a->value + a->section->vma > b->value + b->section->vma)
3112 return 1;
3113
3114 /* For syms with the same value, prefer strong dynamic global function
3115 syms over other syms. */
3116 if ((a->flags & BSF_GLOBAL) != 0 && (b->flags & BSF_GLOBAL) == 0)
3117 return -1;
3118
3119 if ((a->flags & BSF_GLOBAL) == 0 && (b->flags & BSF_GLOBAL) != 0)
3120 return 1;
3121
3122 if ((a->flags & BSF_FUNCTION) != 0 && (b->flags & BSF_FUNCTION) == 0)
3123 return -1;
3124
3125 if ((a->flags & BSF_FUNCTION) == 0 && (b->flags & BSF_FUNCTION) != 0)
3126 return 1;
3127
3128 if ((a->flags & BSF_WEAK) == 0 && (b->flags & BSF_WEAK) != 0)
3129 return -1;
3130
3131 if ((a->flags & BSF_WEAK) != 0 && (b->flags & BSF_WEAK) == 0)
3132 return 1;
3133
3134 if ((a->flags & BSF_DYNAMIC) != 0 && (b->flags & BSF_DYNAMIC) == 0)
3135 return -1;
3136
3137 if ((a->flags & BSF_DYNAMIC) == 0 && (b->flags & BSF_DYNAMIC) != 0)
3138 return 1;
3139
3140 return 0;
3141 }
3142
3143 /* Search SYMS for a symbol of the given VALUE. */
3144
3145 static asymbol *
3146 sym_exists_at (asymbol **syms, long lo, long hi, unsigned int id, bfd_vma value)
3147 {
3148 long mid;
3149
3150 if (id == (unsigned) -1)
3151 {
3152 while (lo < hi)
3153 {
3154 mid = (lo + hi) >> 1;
3155 if (syms[mid]->value + syms[mid]->section->vma < value)
3156 lo = mid + 1;
3157 else if (syms[mid]->value + syms[mid]->section->vma > value)
3158 hi = mid;
3159 else
3160 return syms[mid];
3161 }
3162 }
3163 else
3164 {
3165 while (lo < hi)
3166 {
3167 mid = (lo + hi) >> 1;
3168 if (syms[mid]->section->id < id)
3169 lo = mid + 1;
3170 else if (syms[mid]->section->id > id)
3171 hi = mid;
3172 else if (syms[mid]->value < value)
3173 lo = mid + 1;
3174 else if (syms[mid]->value > value)
3175 hi = mid;
3176 else
3177 return syms[mid];
3178 }
3179 }
3180 return NULL;
3181 }
3182
3183 static bfd_boolean
3184 section_covers_vma (bfd *abfd ATTRIBUTE_UNUSED, asection *section, void *ptr)
3185 {
3186 bfd_vma vma = *(bfd_vma *) ptr;
3187 return ((section->flags & SEC_ALLOC) != 0
3188 && section->vma <= vma
3189 && vma < section->vma + section->size);
3190 }
3191
3192 /* Create synthetic symbols, effectively restoring "dot-symbol" function
3193 entry syms. Also generate @plt symbols for the glink branch table.
3194 Returns count of synthetic symbols in RET or -1 on error. */
3195
3196 static long
3197 ppc64_elf_get_synthetic_symtab (bfd *abfd,
3198 long static_count, asymbol **static_syms,
3199 long dyn_count, asymbol **dyn_syms,
3200 asymbol **ret)
3201 {
3202 asymbol *s;
3203 long i;
3204 long count;
3205 char *names;
3206 long symcount, codesecsym, codesecsymend, secsymend, opdsymend;
3207 asection *opd = NULL;
3208 bfd_boolean relocatable = (abfd->flags & (EXEC_P | DYNAMIC)) == 0;
3209 asymbol **syms;
3210 int abi = abiversion (abfd);
3211
3212 *ret = NULL;
3213
3214 if (abi < 2)
3215 {
3216 opd = bfd_get_section_by_name (abfd, ".opd");
3217 if (opd == NULL && abi == 1)
3218 return 0;
3219 }
3220
3221 symcount = static_count;
3222 if (!relocatable)
3223 symcount += dyn_count;
3224 if (symcount == 0)
3225 return 0;
3226
3227 syms = bfd_malloc ((symcount + 1) * sizeof (*syms));
3228 if (syms == NULL)
3229 return -1;
3230
3231 if (!relocatable && static_count != 0 && dyn_count != 0)
3232 {
3233 /* Use both symbol tables. */
3234 memcpy (syms, static_syms, static_count * sizeof (*syms));
3235 memcpy (syms + static_count, dyn_syms, (dyn_count + 1) * sizeof (*syms));
3236 }
3237 else if (!relocatable && static_count == 0)
3238 memcpy (syms, dyn_syms, (symcount + 1) * sizeof (*syms));
3239 else
3240 memcpy (syms, static_syms, (symcount + 1) * sizeof (*syms));
3241
3242 synthetic_relocatable = relocatable;
3243 qsort (syms, symcount, sizeof (*syms), compare_symbols);
3244
3245 if (!relocatable && symcount > 1)
3246 {
3247 long j;
3248 /* Trim duplicate syms, since we may have merged the normal and
3249 dynamic symbols. Actually, we only care about syms that have
3250 different values, so trim any with the same value. */
3251 for (i = 1, j = 1; i < symcount; ++i)
3252 if (syms[i - 1]->value + syms[i - 1]->section->vma
3253 != syms[i]->value + syms[i]->section->vma)
3254 syms[j++] = syms[i];
3255 symcount = j;
3256 }
3257
3258 i = 0;
3259 if (strcmp (syms[i]->section->name, ".opd") == 0)
3260 ++i;
3261 codesecsym = i;
3262
3263 for (; i < symcount; ++i)
3264 if (((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3265 != (SEC_CODE | SEC_ALLOC))
3266 || (syms[i]->flags & BSF_SECTION_SYM) == 0)
3267 break;
3268 codesecsymend = i;
3269
3270 for (; i < symcount; ++i)
3271 if ((syms[i]->flags & BSF_SECTION_SYM) == 0)
3272 break;
3273 secsymend = i;
3274
3275 for (; i < symcount; ++i)
3276 if (strcmp (syms[i]->section->name, ".opd") != 0)
3277 break;
3278 opdsymend = i;
3279
3280 for (; i < symcount; ++i)
3281 if ((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3282 != (SEC_CODE | SEC_ALLOC))
3283 break;
3284 symcount = i;
3285
3286 count = 0;
3287
3288 if (relocatable)
3289 {
3290 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3291 arelent *r;
3292 size_t size;
3293 long relcount;
3294
3295 if (opdsymend == secsymend)
3296 goto done;
3297
3298 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3299 relcount = (opd->flags & SEC_RELOC) ? opd->reloc_count : 0;
3300 if (relcount == 0)
3301 goto done;
3302
3303 if (!(*slurp_relocs) (abfd, opd, static_syms, FALSE))
3304 {
3305 count = -1;
3306 goto done;
3307 }
3308
3309 size = 0;
3310 for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3311 {
3312 asymbol *sym;
3313
3314 while (r < opd->relocation + relcount
3315 && r->address < syms[i]->value + opd->vma)
3316 ++r;
3317
3318 if (r == opd->relocation + relcount)
3319 break;
3320
3321 if (r->address != syms[i]->value + opd->vma)
3322 continue;
3323
3324 if (r->howto->type != R_PPC64_ADDR64)
3325 continue;
3326
3327 sym = *r->sym_ptr_ptr;
3328 if (!sym_exists_at (syms, opdsymend, symcount,
3329 sym->section->id, sym->value + r->addend))
3330 {
3331 ++count;
3332 size += sizeof (asymbol);
3333 size += strlen (syms[i]->name) + 2;
3334 }
3335 }
3336
3337 if (size == 0)
3338 goto done;
3339 s = *ret = bfd_malloc (size);
3340 if (s == NULL)
3341 {
3342 count = -1;
3343 goto done;
3344 }
3345
3346 names = (char *) (s + count);
3347
3348 for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3349 {
3350 asymbol *sym;
3351
3352 while (r < opd->relocation + relcount
3353 && r->address < syms[i]->value + opd->vma)
3354 ++r;
3355
3356 if (r == opd->relocation + relcount)
3357 break;
3358
3359 if (r->address != syms[i]->value + opd->vma)
3360 continue;
3361
3362 if (r->howto->type != R_PPC64_ADDR64)
3363 continue;
3364
3365 sym = *r->sym_ptr_ptr;
3366 if (!sym_exists_at (syms, opdsymend, symcount,
3367 sym->section->id, sym->value + r->addend))
3368 {
3369 size_t len;
3370
3371 *s = *syms[i];
3372 s->flags |= BSF_SYNTHETIC;
3373 s->section = sym->section;
3374 s->value = sym->value + r->addend;
3375 s->name = names;
3376 *names++ = '.';
3377 len = strlen (syms[i]->name);
3378 memcpy (names, syms[i]->name, len + 1);
3379 names += len + 1;
3380 /* Have udata.p point back to the original symbol this
3381 synthetic symbol was derived from. */
3382 s->udata.p = syms[i];
3383 s++;
3384 }
3385 }
3386 }
3387 else
3388 {
3389 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3390 bfd_byte *contents = NULL;
3391 size_t size;
3392 long plt_count = 0;
3393 bfd_vma glink_vma = 0, resolv_vma = 0;
3394 asection *dynamic, *glink = NULL, *relplt = NULL;
3395 arelent *p;
3396
3397 if (opd != NULL && !bfd_malloc_and_get_section (abfd, opd, &contents))
3398 {
3399 free_contents_and_exit_err:
3400 count = -1;
3401 free_contents_and_exit:
3402 if (contents)
3403 free (contents);
3404 goto done;
3405 }
3406
3407 size = 0;
3408 for (i = secsymend; i < opdsymend; ++i)
3409 {
3410 bfd_vma ent;
3411
3412 /* Ignore bogus symbols. */
3413 if (syms[i]->value > opd->size - 8)
3414 continue;
3415
3416 ent = bfd_get_64 (abfd, contents + syms[i]->value);
3417 if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3418 {
3419 ++count;
3420 size += sizeof (asymbol);
3421 size += strlen (syms[i]->name) + 2;
3422 }
3423 }
3424
3425 /* Get start of .glink stubs from DT_PPC64_GLINK. */
3426 if (dyn_count != 0
3427 && (dynamic = bfd_get_section_by_name (abfd, ".dynamic")) != NULL)
3428 {
3429 bfd_byte *dynbuf, *extdyn, *extdynend;
3430 size_t extdynsize;
3431 void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *);
3432
3433 if (!bfd_malloc_and_get_section (abfd, dynamic, &dynbuf))
3434 goto free_contents_and_exit_err;
3435
3436 extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
3437 swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
3438
3439 extdyn = dynbuf;
3440 extdynend = extdyn + dynamic->size;
3441 for (; extdyn < extdynend; extdyn += extdynsize)
3442 {
3443 Elf_Internal_Dyn dyn;
3444 (*swap_dyn_in) (abfd, extdyn, &dyn);
3445
3446 if (dyn.d_tag == DT_NULL)
3447 break;
3448
3449 if (dyn.d_tag == DT_PPC64_GLINK)
3450 {
3451 /* The first glink stub starts at offset 32; see
3452 comment in ppc64_elf_finish_dynamic_sections. */
3453 glink_vma = dyn.d_un.d_val + GLINK_CALL_STUB_SIZE - 8 * 4;
3454 /* The .glink section usually does not survive the final
3455 link; search for the section (usually .text) where the
3456 glink stubs now reside. */
3457 glink = bfd_sections_find_if (abfd, section_covers_vma,
3458 &glink_vma);
3459 break;
3460 }
3461 }
3462
3463 free (dynbuf);
3464 }
3465
3466 if (glink != NULL)
3467 {
3468 /* Determine __glink trampoline by reading the relative branch
3469 from the first glink stub. */
3470 bfd_byte buf[4];
3471 unsigned int off = 0;
3472
3473 while (bfd_get_section_contents (abfd, glink, buf,
3474 glink_vma + off - glink->vma, 4))
3475 {
3476 unsigned int insn = bfd_get_32 (abfd, buf);
3477 insn ^= B_DOT;
3478 if ((insn & ~0x3fffffc) == 0)
3479 {
3480 resolv_vma = glink_vma + off + (insn ^ 0x2000000) - 0x2000000;
3481 break;
3482 }
3483 off += 4;
3484 if (off > 4)
3485 break;
3486 }
3487
3488 if (resolv_vma)
3489 size += sizeof (asymbol) + sizeof ("__glink_PLTresolve");
3490
3491 relplt = bfd_get_section_by_name (abfd, ".rela.plt");
3492 if (relplt != NULL)
3493 {
3494 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3495 if (! (*slurp_relocs) (abfd, relplt, dyn_syms, TRUE))
3496 goto free_contents_and_exit_err;
3497
3498 plt_count = relplt->size / sizeof (Elf64_External_Rela);
3499 size += plt_count * sizeof (asymbol);
3500
3501 p = relplt->relocation;
3502 for (i = 0; i < plt_count; i++, p++)
3503 {
3504 size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
3505 if (p->addend != 0)
3506 size += sizeof ("+0x") - 1 + 16;
3507 }
3508 }
3509 }
3510
3511 if (size == 0)
3512 goto free_contents_and_exit;
3513 s = *ret = bfd_malloc (size);
3514 if (s == NULL)
3515 goto free_contents_and_exit_err;
3516
3517 names = (char *) (s + count + plt_count + (resolv_vma != 0));
3518
3519 for (i = secsymend; i < opdsymend; ++i)
3520 {
3521 bfd_vma ent;
3522
3523 if (syms[i]->value > opd->size - 8)
3524 continue;
3525
3526 ent = bfd_get_64 (abfd, contents + syms[i]->value);
3527 if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3528 {
3529 long lo, hi;
3530 size_t len;
3531 asection *sec = abfd->sections;
3532
3533 *s = *syms[i];
3534 lo = codesecsym;
3535 hi = codesecsymend;
3536 while (lo < hi)
3537 {
3538 long mid = (lo + hi) >> 1;
3539 if (syms[mid]->section->vma < ent)
3540 lo = mid + 1;
3541 else if (syms[mid]->section->vma > ent)
3542 hi = mid;
3543 else
3544 {
3545 sec = syms[mid]->section;
3546 break;
3547 }
3548 }
3549
3550 if (lo >= hi && lo > codesecsym)
3551 sec = syms[lo - 1]->section;
3552
3553 for (; sec != NULL; sec = sec->next)
3554 {
3555 if (sec->vma > ent)
3556 break;
3557 /* SEC_LOAD may not be set if SEC is from a separate debug
3558 info file. */
3559 if ((sec->flags & SEC_ALLOC) == 0)
3560 break;
3561 if ((sec->flags & SEC_CODE) != 0)
3562 s->section = sec;
3563 }
3564 s->flags |= BSF_SYNTHETIC;
3565 s->value = ent - s->section->vma;
3566 s->name = names;
3567 *names++ = '.';
3568 len = strlen (syms[i]->name);
3569 memcpy (names, syms[i]->name, len + 1);
3570 names += len + 1;
3571 /* Have udata.p point back to the original symbol this
3572 synthetic symbol was derived from. */
3573 s->udata.p = syms[i];
3574 s++;
3575 }
3576 }
3577 free (contents);
3578
3579 if (glink != NULL && relplt != NULL)
3580 {
3581 if (resolv_vma)
3582 {
3583 /* Add a symbol for the main glink trampoline. */
3584 memset (s, 0, sizeof *s);
3585 s->the_bfd = abfd;
3586 s->flags = BSF_GLOBAL | BSF_SYNTHETIC;
3587 s->section = glink;
3588 s->value = resolv_vma - glink->vma;
3589 s->name = names;
3590 memcpy (names, "__glink_PLTresolve", sizeof ("__glink_PLTresolve"));
3591 names += sizeof ("__glink_PLTresolve");
3592 s++;
3593 count++;
3594 }
3595
3596 /* FIXME: It would be very much nicer to put sym@plt on the
3597 stub rather than on the glink branch table entry. The
3598 objdump disassembler would then use a sensible symbol
3599 name on plt calls. The difficulty in doing so is
3600 a) finding the stubs, and,
3601 b) matching stubs against plt entries, and,
3602 c) there can be multiple stubs for a given plt entry.
3603
3604 Solving (a) could be done by code scanning, but older
3605 ppc64 binaries used different stubs to current code.
3606 (b) is the tricky one since you need to known the toc
3607 pointer for at least one function that uses a pic stub to
3608 be able to calculate the plt address referenced.
3609 (c) means gdb would need to set multiple breakpoints (or
3610 find the glink branch itself) when setting breakpoints
3611 for pending shared library loads. */
3612 p = relplt->relocation;
3613 for (i = 0; i < plt_count; i++, p++)
3614 {
3615 size_t len;
3616
3617 *s = **p->sym_ptr_ptr;
3618 /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set. Since
3619 we are defining a symbol, ensure one of them is set. */
3620 if ((s->flags & BSF_LOCAL) == 0)
3621 s->flags |= BSF_GLOBAL;
3622 s->flags |= BSF_SYNTHETIC;
3623 s->section = glink;
3624 s->value = glink_vma - glink->vma;
3625 s->name = names;
3626 s->udata.p = NULL;
3627 len = strlen ((*p->sym_ptr_ptr)->name);
3628 memcpy (names, (*p->sym_ptr_ptr)->name, len);
3629 names += len;
3630 if (p->addend != 0)
3631 {
3632 memcpy (names, "+0x", sizeof ("+0x") - 1);
3633 names += sizeof ("+0x") - 1;
3634 bfd_sprintf_vma (abfd, names, p->addend);
3635 names += strlen (names);
3636 }
3637 memcpy (names, "@plt", sizeof ("@plt"));
3638 names += sizeof ("@plt");
3639 s++;
3640 if (abi < 2)
3641 {
3642 glink_vma += 8;
3643 if (i >= 0x8000)
3644 glink_vma += 4;
3645 }
3646 else
3647 glink_vma += 4;
3648 }
3649 count += plt_count;
3650 }
3651 }
3652
3653 done:
3654 free (syms);
3655 return count;
3656 }
3657 \f
3658 /* The following functions are specific to the ELF linker, while
3659 functions above are used generally. Those named ppc64_elf_* are
3660 called by the main ELF linker code. They appear in this file more
3661 or less in the order in which they are called. eg.
3662 ppc64_elf_check_relocs is called early in the link process,
3663 ppc64_elf_finish_dynamic_sections is one of the last functions
3664 called.
3665
3666 PowerPC64-ELF uses a similar scheme to PowerPC64-XCOFF in that
3667 functions have both a function code symbol and a function descriptor
3668 symbol. A call to foo in a relocatable object file looks like:
3669
3670 . .text
3671 . x:
3672 . bl .foo
3673 . nop
3674
3675 The function definition in another object file might be:
3676
3677 . .section .opd
3678 . foo: .quad .foo
3679 . .quad .TOC.@tocbase
3680 . .quad 0
3681 .
3682 . .text
3683 . .foo: blr
3684
3685 When the linker resolves the call during a static link, the branch
3686 unsurprisingly just goes to .foo and the .opd information is unused.
3687 If the function definition is in a shared library, things are a little
3688 different: The call goes via a plt call stub, the opd information gets
3689 copied to the plt, and the linker patches the nop.
3690
3691 . x:
3692 . bl .foo_stub
3693 . ld 2,40(1)
3694 .
3695 .
3696 . .foo_stub:
3697 . std 2,40(1) # in practice, the call stub
3698 . addis 11,2,Lfoo@toc@ha # is slightly optimized, but
3699 . addi 11,11,Lfoo@toc@l # this is the general idea
3700 . ld 12,0(11)
3701 . ld 2,8(11)
3702 . mtctr 12
3703 . ld 11,16(11)
3704 . bctr
3705 .
3706 . .section .plt
3707 . Lfoo: reloc (R_PPC64_JMP_SLOT, foo)
3708
3709 The "reloc ()" notation is supposed to indicate that the linker emits
3710 an R_PPC64_JMP_SLOT reloc against foo. The dynamic linker does the opd
3711 copying.
3712
3713 What are the difficulties here? Well, firstly, the relocations
3714 examined by the linker in check_relocs are against the function code
3715 sym .foo, while the dynamic relocation in the plt is emitted against
3716 the function descriptor symbol, foo. Somewhere along the line, we need
3717 to carefully copy dynamic link information from one symbol to the other.
3718 Secondly, the generic part of the elf linker will make .foo a dynamic
3719 symbol as is normal for most other backends. We need foo dynamic
3720 instead, at least for an application final link. However, when
3721 creating a shared library containing foo, we need to have both symbols
3722 dynamic so that references to .foo are satisfied during the early
3723 stages of linking. Otherwise the linker might decide to pull in a
3724 definition from some other object, eg. a static library.
3725
3726 Update: As of August 2004, we support a new convention. Function
3727 calls may use the function descriptor symbol, ie. "bl foo". This
3728 behaves exactly as "bl .foo". */
3729
3730 /* Of those relocs that might be copied as dynamic relocs, this function
3731 selects those that must be copied when linking a shared library,
3732 even when the symbol is local. */
3733
3734 static int
3735 must_be_dyn_reloc (struct bfd_link_info *info,
3736 enum elf_ppc64_reloc_type r_type)
3737 {
3738 switch (r_type)
3739 {
3740 default:
3741 return 1;
3742
3743 case R_PPC64_REL32:
3744 case R_PPC64_REL64:
3745 case R_PPC64_REL30:
3746 return 0;
3747
3748 case R_PPC64_TPREL16:
3749 case R_PPC64_TPREL16_LO:
3750 case R_PPC64_TPREL16_HI:
3751 case R_PPC64_TPREL16_HA:
3752 case R_PPC64_TPREL16_DS:
3753 case R_PPC64_TPREL16_LO_DS:
3754 case R_PPC64_TPREL16_HIGH:
3755 case R_PPC64_TPREL16_HIGHA:
3756 case R_PPC64_TPREL16_HIGHER:
3757 case R_PPC64_TPREL16_HIGHERA:
3758 case R_PPC64_TPREL16_HIGHEST:
3759 case R_PPC64_TPREL16_HIGHESTA:
3760 case R_PPC64_TPREL64:
3761 return !bfd_link_executable (info);
3762 }
3763 }
3764
3765 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
3766 copying dynamic variables from a shared lib into an app's dynbss
3767 section, and instead use a dynamic relocation to point into the
3768 shared lib. With code that gcc generates, it's vital that this be
3769 enabled; In the PowerPC64 ABI, the address of a function is actually
3770 the address of a function descriptor, which resides in the .opd
3771 section. gcc uses the descriptor directly rather than going via the
3772 GOT as some other ABI's do, which means that initialized function
3773 pointers must reference the descriptor. Thus, a function pointer
3774 initialized to the address of a function in a shared library will
3775 either require a copy reloc, or a dynamic reloc. Using a copy reloc
3776 redefines the function descriptor symbol to point to the copy. This
3777 presents a problem as a plt entry for that function is also
3778 initialized from the function descriptor symbol and the copy reloc
3779 may not be initialized first. */
3780 #define ELIMINATE_COPY_RELOCS 1
3781
3782 /* Section name for stubs is the associated section name plus this
3783 string. */
3784 #define STUB_SUFFIX ".stub"
3785
3786 /* Linker stubs.
3787 ppc_stub_long_branch:
3788 Used when a 14 bit branch (or even a 24 bit branch) can't reach its
3789 destination, but a 24 bit branch in a stub section will reach.
3790 . b dest
3791
3792 ppc_stub_plt_branch:
3793 Similar to the above, but a 24 bit branch in the stub section won't
3794 reach its destination.
3795 . addis %r11,%r2,xxx@toc@ha
3796 . ld %r12,xxx@toc@l(%r11)
3797 . mtctr %r12
3798 . bctr
3799
3800 ppc_stub_plt_call:
3801 Used to call a function in a shared library. If it so happens that
3802 the plt entry referenced crosses a 64k boundary, then an extra
3803 "addi %r11,%r11,xxx@toc@l" will be inserted before the "mtctr".
3804 . std %r2,40(%r1)
3805 . addis %r11,%r2,xxx@toc@ha
3806 . ld %r12,xxx+0@toc@l(%r11)
3807 . mtctr %r12
3808 . ld %r2,xxx+8@toc@l(%r11)
3809 . ld %r11,xxx+16@toc@l(%r11)
3810 . bctr
3811
3812 ppc_stub_long_branch and ppc_stub_plt_branch may also have additional
3813 code to adjust the value and save r2 to support multiple toc sections.
3814 A ppc_stub_long_branch with an r2 offset looks like:
3815 . std %r2,40(%r1)
3816 . addis %r2,%r2,off@ha
3817 . addi %r2,%r2,off@l
3818 . b dest
3819
3820 A ppc_stub_plt_branch with an r2 offset looks like:
3821 . std %r2,40(%r1)
3822 . addis %r11,%r2,xxx@toc@ha
3823 . ld %r12,xxx@toc@l(%r11)
3824 . addis %r2,%r2,off@ha
3825 . addi %r2,%r2,off@l
3826 . mtctr %r12
3827 . bctr
3828
3829 In cases where the "addis" instruction would add zero, the "addis" is
3830 omitted and following instructions modified slightly in some cases.
3831 */
3832
3833 enum ppc_stub_type {
3834 ppc_stub_none,
3835 ppc_stub_long_branch,
3836 ppc_stub_long_branch_r2off,
3837 ppc_stub_plt_branch,
3838 ppc_stub_plt_branch_r2off,
3839 ppc_stub_plt_call,
3840 ppc_stub_plt_call_r2save,
3841 ppc_stub_global_entry,
3842 ppc_stub_save_res
3843 };
3844
3845 /* Information on stub grouping. */
3846 struct map_stub
3847 {
3848 /* The stub section. */
3849 asection *stub_sec;
3850 /* This is the section to which stubs in the group will be attached. */
3851 asection *link_sec;
3852 /* Next group. */
3853 struct map_stub *next;
3854 /* Whether to emit a copy of register save/restore functions in this
3855 group. */
3856 int needs_save_res;
3857 };
3858
3859 struct ppc_stub_hash_entry {
3860
3861 /* Base hash table entry structure. */
3862 struct bfd_hash_entry root;
3863
3864 enum ppc_stub_type stub_type;
3865
3866 /* Group information. */
3867 struct map_stub *group;
3868
3869 /* Offset within stub_sec of the beginning of this stub. */
3870 bfd_vma stub_offset;
3871
3872 /* Given the symbol's value and its section we can determine its final
3873 value when building the stubs (so the stub knows where to jump. */
3874 bfd_vma target_value;
3875 asection *target_section;
3876
3877 /* The symbol table entry, if any, that this was derived from. */
3878 struct ppc_link_hash_entry *h;
3879 struct plt_entry *plt_ent;
3880
3881 /* Symbol st_other. */
3882 unsigned char other;
3883 };
3884
3885 struct ppc_branch_hash_entry {
3886
3887 /* Base hash table entry structure. */
3888 struct bfd_hash_entry root;
3889
3890 /* Offset within branch lookup table. */
3891 unsigned int offset;
3892
3893 /* Generation marker. */
3894 unsigned int iter;
3895 };
3896
3897 /* Used to track dynamic relocations for local symbols. */
3898 struct ppc_dyn_relocs
3899 {
3900 struct ppc_dyn_relocs *next;
3901
3902 /* The input section of the reloc. */
3903 asection *sec;
3904
3905 /* Total number of relocs copied for the input section. */
3906 unsigned int count : 31;
3907
3908 /* Whether this entry is for STT_GNU_IFUNC symbols. */
3909 unsigned int ifunc : 1;
3910 };
3911
3912 struct ppc_link_hash_entry
3913 {
3914 struct elf_link_hash_entry elf;
3915
3916 union {
3917 /* A pointer to the most recently used stub hash entry against this
3918 symbol. */
3919 struct ppc_stub_hash_entry *stub_cache;
3920
3921 /* A pointer to the next symbol starting with a '.' */
3922 struct ppc_link_hash_entry *next_dot_sym;
3923 } u;
3924
3925 /* Track dynamic relocs copied for this symbol. */
3926 struct elf_dyn_relocs *dyn_relocs;
3927
3928 /* Link between function code and descriptor symbols. */
3929 struct ppc_link_hash_entry *oh;
3930
3931 /* Flag function code and descriptor symbols. */
3932 unsigned int is_func:1;
3933 unsigned int is_func_descriptor:1;
3934 unsigned int fake:1;
3935
3936 /* Whether global opd/toc sym has been adjusted or not.
3937 After ppc64_elf_edit_opd/ppc64_elf_edit_toc has run, this flag
3938 should be set for all globals defined in any opd/toc section. */
3939 unsigned int adjust_done:1;
3940
3941 /* Set if we twiddled this symbol to weak at some stage. */
3942 unsigned int was_undefined:1;
3943
3944 /* Set if this is an out-of-line register save/restore function,
3945 with non-standard calling convention. */
3946 unsigned int save_res:1;
3947
3948 /* Contexts in which symbol is used in the GOT (or TOC).
3949 TLS_GD .. TLS_EXPLICIT bits are or'd into the mask as the
3950 corresponding relocs are encountered during check_relocs.
3951 tls_optimize clears TLS_GD .. TLS_TPREL when optimizing to
3952 indicate the corresponding GOT entry type is not needed.
3953 tls_optimize may also set TLS_TPRELGD when a GD reloc turns into
3954 a TPREL one. We use a separate flag rather than setting TPREL
3955 just for convenience in distinguishing the two cases. */
3956 #define TLS_GD 1 /* GD reloc. */
3957 #define TLS_LD 2 /* LD reloc. */
3958 #define TLS_TPREL 4 /* TPREL reloc, => IE. */
3959 #define TLS_DTPREL 8 /* DTPREL reloc, => LD. */
3960 #define TLS_TLS 16 /* Any TLS reloc. */
3961 #define TLS_EXPLICIT 32 /* Marks TOC section TLS relocs. */
3962 #define TLS_TPRELGD 64 /* TPREL reloc resulting from GD->IE. */
3963 #define PLT_IFUNC 128 /* STT_GNU_IFUNC. */
3964 unsigned char tls_mask;
3965 };
3966
3967 /* ppc64 ELF linker hash table. */
3968
3969 struct ppc_link_hash_table
3970 {
3971 struct elf_link_hash_table elf;
3972
3973 /* The stub hash table. */
3974 struct bfd_hash_table stub_hash_table;
3975
3976 /* Another hash table for plt_branch stubs. */
3977 struct bfd_hash_table branch_hash_table;
3978
3979 /* Hash table for function prologue tocsave. */
3980 htab_t tocsave_htab;
3981
3982 /* Various options and other info passed from the linker. */
3983 struct ppc64_elf_params *params;
3984
3985 /* The size of sec_info below. */
3986 unsigned int sec_info_arr_size;
3987
3988 /* Per-section array of extra section info. Done this way rather
3989 than as part of ppc64_elf_section_data so we have the info for
3990 non-ppc64 sections. */
3991 struct
3992 {
3993 /* Along with elf_gp, specifies the TOC pointer used by this section. */
3994 bfd_vma toc_off;
3995
3996 union
3997 {
3998 /* The section group that this section belongs to. */
3999 struct map_stub *group;
4000 /* A temp section list pointer. */
4001 asection *list;
4002 } u;
4003 } *sec_info;
4004
4005 /* Linked list of groups. */
4006 struct map_stub *group;
4007
4008 /* Temp used when calculating TOC pointers. */
4009 bfd_vma toc_curr;
4010 bfd *toc_bfd;
4011 asection *toc_first_sec;
4012
4013 /* Used when adding symbols. */
4014 struct ppc_link_hash_entry *dot_syms;
4015
4016 /* Shortcuts to get to dynamic linker sections. */
4017 asection *dynbss;
4018 asection *relbss;
4019 asection *glink;
4020 asection *sfpr;
4021 asection *brlt;
4022 asection *relbrlt;
4023 asection *glink_eh_frame;
4024
4025 /* Shortcut to .__tls_get_addr and __tls_get_addr. */
4026 struct ppc_link_hash_entry *tls_get_addr;
4027 struct ppc_link_hash_entry *tls_get_addr_fd;
4028
4029 /* The size of reliplt used by got entry relocs. */
4030 bfd_size_type got_reli_size;
4031
4032 /* Statistics. */
4033 unsigned long stub_count[ppc_stub_global_entry];
4034
4035 /* Number of stubs against global syms. */
4036 unsigned long stub_globals;
4037
4038 /* Set if we're linking code with function descriptors. */
4039 unsigned int opd_abi:1;
4040
4041 /* Support for multiple toc sections. */
4042 unsigned int do_multi_toc:1;
4043 unsigned int multi_toc_needed:1;
4044 unsigned int second_toc_pass:1;
4045 unsigned int do_toc_opt:1;
4046
4047 /* Set on error. */
4048 unsigned int stub_error:1;
4049
4050 /* Temp used by ppc64_elf_before_check_relocs. */
4051 unsigned int twiddled_syms:1;
4052
4053 /* Incremented every time we size stubs. */
4054 unsigned int stub_iteration;
4055
4056 /* Small local sym cache. */
4057 struct sym_cache sym_cache;
4058 };
4059
4060 /* Rename some of the generic section flags to better document how they
4061 are used here. */
4062
4063 /* Nonzero if this section has TLS related relocations. */
4064 #define has_tls_reloc sec_flg0
4065
4066 /* Nonzero if this section has a call to __tls_get_addr. */
4067 #define has_tls_get_addr_call sec_flg1
4068
4069 /* Nonzero if this section has any toc or got relocs. */
4070 #define has_toc_reloc sec_flg2
4071
4072 /* Nonzero if this section has a call to another section that uses
4073 the toc or got. */
4074 #define makes_toc_func_call sec_flg3
4075
4076 /* Recursion protection when determining above flag. */
4077 #define call_check_in_progress sec_flg4
4078 #define call_check_done sec_flg5
4079
4080 /* Get the ppc64 ELF linker hash table from a link_info structure. */
4081
4082 #define ppc_hash_table(p) \
4083 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
4084 == PPC64_ELF_DATA ? ((struct ppc_link_hash_table *) ((p)->hash)) : NULL)
4085
4086 #define ppc_stub_hash_lookup(table, string, create, copy) \
4087 ((struct ppc_stub_hash_entry *) \
4088 bfd_hash_lookup ((table), (string), (create), (copy)))
4089
4090 #define ppc_branch_hash_lookup(table, string, create, copy) \
4091 ((struct ppc_branch_hash_entry *) \
4092 bfd_hash_lookup ((table), (string), (create), (copy)))
4093
4094 /* Create an entry in the stub hash table. */
4095
4096 static struct bfd_hash_entry *
4097 stub_hash_newfunc (struct bfd_hash_entry *entry,
4098 struct bfd_hash_table *table,
4099 const char *string)
4100 {
4101 /* Allocate the structure if it has not already been allocated by a
4102 subclass. */
4103 if (entry == NULL)
4104 {
4105 entry = bfd_hash_allocate (table, sizeof (struct ppc_stub_hash_entry));
4106 if (entry == NULL)
4107 return entry;
4108 }
4109
4110 /* Call the allocation method of the superclass. */
4111 entry = bfd_hash_newfunc (entry, table, string);
4112 if (entry != NULL)
4113 {
4114 struct ppc_stub_hash_entry *eh;
4115
4116 /* Initialize the local fields. */
4117 eh = (struct ppc_stub_hash_entry *) entry;
4118 eh->stub_type = ppc_stub_none;
4119 eh->group = NULL;
4120 eh->stub_offset = 0;
4121 eh->target_value = 0;
4122 eh->target_section = NULL;
4123 eh->h = NULL;
4124 eh->plt_ent = NULL;
4125 eh->other = 0;
4126 }
4127
4128 return entry;
4129 }
4130
4131 /* Create an entry in the branch hash table. */
4132
4133 static struct bfd_hash_entry *
4134 branch_hash_newfunc (struct bfd_hash_entry *entry,
4135 struct bfd_hash_table *table,
4136 const char *string)
4137 {
4138 /* Allocate the structure if it has not already been allocated by a
4139 subclass. */
4140 if (entry == NULL)
4141 {
4142 entry = bfd_hash_allocate (table, sizeof (struct ppc_branch_hash_entry));
4143 if (entry == NULL)
4144 return entry;
4145 }
4146
4147 /* Call the allocation method of the superclass. */
4148 entry = bfd_hash_newfunc (entry, table, string);
4149 if (entry != NULL)
4150 {
4151 struct ppc_branch_hash_entry *eh;
4152
4153 /* Initialize the local fields. */
4154 eh = (struct ppc_branch_hash_entry *) entry;
4155 eh->offset = 0;
4156 eh->iter = 0;
4157 }
4158
4159 return entry;
4160 }
4161
4162 /* Create an entry in a ppc64 ELF linker hash table. */
4163
4164 static struct bfd_hash_entry *
4165 link_hash_newfunc (struct bfd_hash_entry *entry,
4166 struct bfd_hash_table *table,
4167 const char *string)
4168 {
4169 /* Allocate the structure if it has not already been allocated by a
4170 subclass. */
4171 if (entry == NULL)
4172 {
4173 entry = bfd_hash_allocate (table, sizeof (struct ppc_link_hash_entry));
4174 if (entry == NULL)
4175 return entry;
4176 }
4177
4178 /* Call the allocation method of the superclass. */
4179 entry = _bfd_elf_link_hash_newfunc (entry, table, string);
4180 if (entry != NULL)
4181 {
4182 struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) entry;
4183
4184 memset (&eh->u.stub_cache, 0,
4185 (sizeof (struct ppc_link_hash_entry)
4186 - offsetof (struct ppc_link_hash_entry, u.stub_cache)));
4187
4188 /* When making function calls, old ABI code references function entry
4189 points (dot symbols), while new ABI code references the function
4190 descriptor symbol. We need to make any combination of reference and
4191 definition work together, without breaking archive linking.
4192
4193 For a defined function "foo" and an undefined call to "bar":
4194 An old object defines "foo" and ".foo", references ".bar" (possibly
4195 "bar" too).
4196 A new object defines "foo" and references "bar".
4197
4198 A new object thus has no problem with its undefined symbols being
4199 satisfied by definitions in an old object. On the other hand, the
4200 old object won't have ".bar" satisfied by a new object.
4201
4202 Keep a list of newly added dot-symbols. */
4203
4204 if (string[0] == '.')
4205 {
4206 struct ppc_link_hash_table *htab;
4207
4208 htab = (struct ppc_link_hash_table *) table;
4209 eh->u.next_dot_sym = htab->dot_syms;
4210 htab->dot_syms = eh;
4211 }
4212 }
4213
4214 return entry;
4215 }
4216
4217 struct tocsave_entry {
4218 asection *sec;
4219 bfd_vma offset;
4220 };
4221
4222 static hashval_t
4223 tocsave_htab_hash (const void *p)
4224 {
4225 const struct tocsave_entry *e = (const struct tocsave_entry *) p;
4226 return ((bfd_vma)(intptr_t) e->sec ^ e->offset) >> 3;
4227 }
4228
4229 static int
4230 tocsave_htab_eq (const void *p1, const void *p2)
4231 {
4232 const struct tocsave_entry *e1 = (const struct tocsave_entry *) p1;
4233 const struct tocsave_entry *e2 = (const struct tocsave_entry *) p2;
4234 return e1->sec == e2->sec && e1->offset == e2->offset;
4235 }
4236
4237 /* Destroy a ppc64 ELF linker hash table. */
4238
4239 static void
4240 ppc64_elf_link_hash_table_free (bfd *obfd)
4241 {
4242 struct ppc_link_hash_table *htab;
4243
4244 htab = (struct ppc_link_hash_table *) obfd->link.hash;
4245 if (htab->tocsave_htab)
4246 htab_delete (htab->tocsave_htab);
4247 bfd_hash_table_free (&htab->branch_hash_table);
4248 bfd_hash_table_free (&htab->stub_hash_table);
4249 _bfd_elf_link_hash_table_free (obfd);
4250 }
4251
4252 /* Create a ppc64 ELF linker hash table. */
4253
4254 static struct bfd_link_hash_table *
4255 ppc64_elf_link_hash_table_create (bfd *abfd)
4256 {
4257 struct ppc_link_hash_table *htab;
4258 bfd_size_type amt = sizeof (struct ppc_link_hash_table);
4259
4260 htab = bfd_zmalloc (amt);
4261 if (htab == NULL)
4262 return NULL;
4263
4264 if (!_bfd_elf_link_hash_table_init (&htab->elf, abfd, link_hash_newfunc,
4265 sizeof (struct ppc_link_hash_entry),
4266 PPC64_ELF_DATA))
4267 {
4268 free (htab);
4269 return NULL;
4270 }
4271
4272 /* Init the stub hash table too. */
4273 if (!bfd_hash_table_init (&htab->stub_hash_table, stub_hash_newfunc,
4274 sizeof (struct ppc_stub_hash_entry)))
4275 {
4276 _bfd_elf_link_hash_table_free (abfd);
4277 return NULL;
4278 }
4279
4280 /* And the branch hash table. */
4281 if (!bfd_hash_table_init (&htab->branch_hash_table, branch_hash_newfunc,
4282 sizeof (struct ppc_branch_hash_entry)))
4283 {
4284 bfd_hash_table_free (&htab->stub_hash_table);
4285 _bfd_elf_link_hash_table_free (abfd);
4286 return NULL;
4287 }
4288
4289 htab->tocsave_htab = htab_try_create (1024,
4290 tocsave_htab_hash,
4291 tocsave_htab_eq,
4292 NULL);
4293 if (htab->tocsave_htab == NULL)
4294 {
4295 ppc64_elf_link_hash_table_free (abfd);
4296 return NULL;
4297 }
4298 htab->elf.root.hash_table_free = ppc64_elf_link_hash_table_free;
4299
4300 /* Initializing two fields of the union is just cosmetic. We really
4301 only care about glist, but when compiled on a 32-bit host the
4302 bfd_vma fields are larger. Setting the bfd_vma to zero makes
4303 debugger inspection of these fields look nicer. */
4304 htab->elf.init_got_refcount.refcount = 0;
4305 htab->elf.init_got_refcount.glist = NULL;
4306 htab->elf.init_plt_refcount.refcount = 0;
4307 htab->elf.init_plt_refcount.glist = NULL;
4308 htab->elf.init_got_offset.offset = 0;
4309 htab->elf.init_got_offset.glist = NULL;
4310 htab->elf.init_plt_offset.offset = 0;
4311 htab->elf.init_plt_offset.glist = NULL;
4312
4313 return &htab->elf.root;
4314 }
4315
4316 /* Create sections for linker generated code. */
4317
4318 static bfd_boolean
4319 create_linkage_sections (bfd *dynobj, struct bfd_link_info *info)
4320 {
4321 struct ppc_link_hash_table *htab;
4322 flagword flags;
4323
4324 htab = ppc_hash_table (info);
4325
4326 /* Create .sfpr for code to save and restore fp regs. */
4327 flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY
4328 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4329 htab->sfpr = bfd_make_section_anyway_with_flags (dynobj, ".sfpr",
4330 flags);
4331 if (htab->sfpr == NULL
4332 || ! bfd_set_section_alignment (dynobj, htab->sfpr, 2))
4333 return FALSE;
4334
4335 /* Create .glink for lazy dynamic linking support. */
4336 htab->glink = bfd_make_section_anyway_with_flags (dynobj, ".glink",
4337 flags);
4338 if (htab->glink == NULL
4339 || ! bfd_set_section_alignment (dynobj, htab->glink, 3))
4340 return FALSE;
4341
4342 if (!info->no_ld_generated_unwind_info)
4343 {
4344 flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_HAS_CONTENTS
4345 | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4346 htab->glink_eh_frame = bfd_make_section_anyway_with_flags (dynobj,
4347 ".eh_frame",
4348 flags);
4349 if (htab->glink_eh_frame == NULL
4350 || !bfd_set_section_alignment (dynobj, htab->glink_eh_frame, 2))
4351 return FALSE;
4352 }
4353
4354 flags = SEC_ALLOC | SEC_LINKER_CREATED;
4355 htab->elf.iplt = bfd_make_section_anyway_with_flags (dynobj, ".iplt", flags);
4356 if (htab->elf.iplt == NULL
4357 || ! bfd_set_section_alignment (dynobj, htab->elf.iplt, 3))
4358 return FALSE;
4359
4360 flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4361 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4362 htab->elf.irelplt
4363 = bfd_make_section_anyway_with_flags (dynobj, ".rela.iplt", flags);
4364 if (htab->elf.irelplt == NULL
4365 || ! bfd_set_section_alignment (dynobj, htab->elf.irelplt, 3))
4366 return FALSE;
4367
4368 /* Create branch lookup table for plt_branch stubs. */
4369 flags = (SEC_ALLOC | SEC_LOAD
4370 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4371 htab->brlt = bfd_make_section_anyway_with_flags (dynobj, ".branch_lt",
4372 flags);
4373 if (htab->brlt == NULL
4374 || ! bfd_set_section_alignment (dynobj, htab->brlt, 3))
4375 return FALSE;
4376
4377 if (!bfd_link_pic (info))
4378 return TRUE;
4379
4380 flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4381 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4382 htab->relbrlt = bfd_make_section_anyway_with_flags (dynobj,
4383 ".rela.branch_lt",
4384 flags);
4385 if (htab->relbrlt == NULL
4386 || ! bfd_set_section_alignment (dynobj, htab->relbrlt, 3))
4387 return FALSE;
4388
4389 return TRUE;
4390 }
4391
4392 /* Satisfy the ELF linker by filling in some fields in our fake bfd. */
4393
4394 bfd_boolean
4395 ppc64_elf_init_stub_bfd (struct bfd_link_info *info,
4396 struct ppc64_elf_params *params)
4397 {
4398 struct ppc_link_hash_table *htab;
4399
4400 elf_elfheader (params->stub_bfd)->e_ident[EI_CLASS] = ELFCLASS64;
4401
4402 /* Always hook our dynamic sections into the first bfd, which is the
4403 linker created stub bfd. This ensures that the GOT header is at
4404 the start of the output TOC section. */
4405 htab = ppc_hash_table (info);
4406 if (htab == NULL)
4407 return FALSE;
4408 htab->elf.dynobj = params->stub_bfd;
4409 htab->params = params;
4410
4411 if (bfd_link_relocatable (info))
4412 return TRUE;
4413
4414 return create_linkage_sections (htab->elf.dynobj, info);
4415 }
4416
4417 /* Build a name for an entry in the stub hash table. */
4418
4419 static char *
4420 ppc_stub_name (const asection *input_section,
4421 const asection *sym_sec,
4422 const struct ppc_link_hash_entry *h,
4423 const Elf_Internal_Rela *rel)
4424 {
4425 char *stub_name;
4426 ssize_t len;
4427
4428 /* rel->r_addend is actually 64 bit, but who uses more than +/- 2^31
4429 offsets from a sym as a branch target? In fact, we could
4430 probably assume the addend is always zero. */
4431 BFD_ASSERT (((int) rel->r_addend & 0xffffffff) == rel->r_addend);
4432
4433 if (h)
4434 {
4435 len = 8 + 1 + strlen (h->elf.root.root.string) + 1 + 8 + 1;
4436 stub_name = bfd_malloc (len);
4437 if (stub_name == NULL)
4438 return stub_name;
4439
4440 len = sprintf (stub_name, "%08x.%s+%x",
4441 input_section->id & 0xffffffff,
4442 h->elf.root.root.string,
4443 (int) rel->r_addend & 0xffffffff);
4444 }
4445 else
4446 {
4447 len = 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1;
4448 stub_name = bfd_malloc (len);
4449 if (stub_name == NULL)
4450 return stub_name;
4451
4452 len = sprintf (stub_name, "%08x.%x:%x+%x",
4453 input_section->id & 0xffffffff,
4454 sym_sec->id & 0xffffffff,
4455 (int) ELF64_R_SYM (rel->r_info) & 0xffffffff,
4456 (int) rel->r_addend & 0xffffffff);
4457 }
4458 if (len > 2 && stub_name[len - 2] == '+' && stub_name[len - 1] == '0')
4459 stub_name[len - 2] = 0;
4460 return stub_name;
4461 }
4462
4463 /* Look up an entry in the stub hash. Stub entries are cached because
4464 creating the stub name takes a bit of time. */
4465
4466 static struct ppc_stub_hash_entry *
4467 ppc_get_stub_entry (const asection *input_section,
4468 const asection *sym_sec,
4469 struct ppc_link_hash_entry *h,
4470 const Elf_Internal_Rela *rel,
4471 struct ppc_link_hash_table *htab)
4472 {
4473 struct ppc_stub_hash_entry *stub_entry;
4474 struct map_stub *group;
4475
4476 /* If this input section is part of a group of sections sharing one
4477 stub section, then use the id of the first section in the group.
4478 Stub names need to include a section id, as there may well be
4479 more than one stub used to reach say, printf, and we need to
4480 distinguish between them. */
4481 group = htab->sec_info[input_section->id].u.group;
4482
4483 if (h != NULL && h->u.stub_cache != NULL
4484 && h->u.stub_cache->h == h
4485 && h->u.stub_cache->group == group)
4486 {
4487 stub_entry = h->u.stub_cache;
4488 }
4489 else
4490 {
4491 char *stub_name;
4492
4493 stub_name = ppc_stub_name (group->link_sec, sym_sec, h, rel);
4494 if (stub_name == NULL)
4495 return NULL;
4496
4497 stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
4498 stub_name, FALSE, FALSE);
4499 if (h != NULL)
4500 h->u.stub_cache = stub_entry;
4501
4502 free (stub_name);
4503 }
4504
4505 return stub_entry;
4506 }
4507
4508 /* Add a new stub entry to the stub hash. Not all fields of the new
4509 stub entry are initialised. */
4510
4511 static struct ppc_stub_hash_entry *
4512 ppc_add_stub (const char *stub_name,
4513 asection *section,
4514 struct bfd_link_info *info)
4515 {
4516 struct ppc_link_hash_table *htab = ppc_hash_table (info);
4517 struct map_stub *group;
4518 asection *link_sec;
4519 asection *stub_sec;
4520 struct ppc_stub_hash_entry *stub_entry;
4521
4522 group = htab->sec_info[section->id].u.group;
4523 link_sec = group->link_sec;
4524 stub_sec = group->stub_sec;
4525 if (stub_sec == NULL)
4526 {
4527 size_t namelen;
4528 bfd_size_type len;
4529 char *s_name;
4530
4531 namelen = strlen (link_sec->name);
4532 len = namelen + sizeof (STUB_SUFFIX);
4533 s_name = bfd_alloc (htab->params->stub_bfd, len);
4534 if (s_name == NULL)
4535 return NULL;
4536
4537 memcpy (s_name, link_sec->name, namelen);
4538 memcpy (s_name + namelen, STUB_SUFFIX, sizeof (STUB_SUFFIX));
4539 stub_sec = (*htab->params->add_stub_section) (s_name, link_sec);
4540 if (stub_sec == NULL)
4541 return NULL;
4542 group->stub_sec = stub_sec;
4543 }
4544
4545 /* Enter this entry into the linker stub hash table. */
4546 stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table, stub_name,
4547 TRUE, FALSE);
4548 if (stub_entry == NULL)
4549 {
4550 info->callbacks->einfo (_("%P: %B: cannot create stub entry %s\n"),
4551 section->owner, stub_name);
4552 return NULL;
4553 }
4554
4555 stub_entry->group = group;
4556 stub_entry->stub_offset = 0;
4557 return stub_entry;
4558 }
4559
4560 /* Create .got and .rela.got sections in ABFD, and .got in dynobj if
4561 not already done. */
4562
4563 static bfd_boolean
4564 create_got_section (bfd *abfd, struct bfd_link_info *info)
4565 {
4566 asection *got, *relgot;
4567 flagword flags;
4568 struct ppc_link_hash_table *htab = ppc_hash_table (info);
4569
4570 if (!is_ppc64_elf (abfd))
4571 return FALSE;
4572 if (htab == NULL)
4573 return FALSE;
4574
4575 if (!htab->elf.sgot
4576 && !_bfd_elf_create_got_section (htab->elf.dynobj, info))
4577 return FALSE;
4578
4579 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
4580 | SEC_LINKER_CREATED);
4581
4582 got = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
4583 if (!got
4584 || !bfd_set_section_alignment (abfd, got, 3))
4585 return FALSE;
4586
4587 relgot = bfd_make_section_anyway_with_flags (abfd, ".rela.got",
4588 flags | SEC_READONLY);
4589 if (!relgot
4590 || ! bfd_set_section_alignment (abfd, relgot, 3))
4591 return FALSE;
4592
4593 ppc64_elf_tdata (abfd)->got = got;
4594 ppc64_elf_tdata (abfd)->relgot = relgot;
4595 return TRUE;
4596 }
4597
4598 /* Create the dynamic sections, and set up shortcuts. */
4599
4600 static bfd_boolean
4601 ppc64_elf_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
4602 {
4603 struct ppc_link_hash_table *htab;
4604
4605 if (!_bfd_elf_create_dynamic_sections (dynobj, info))
4606 return FALSE;
4607
4608 htab = ppc_hash_table (info);
4609 if (htab == NULL)
4610 return FALSE;
4611
4612 htab->dynbss = bfd_get_linker_section (dynobj, ".dynbss");
4613 if (!bfd_link_pic (info))
4614 htab->relbss = bfd_get_linker_section (dynobj, ".rela.bss");
4615
4616 if (!htab->elf.sgot || !htab->elf.splt || !htab->elf.srelplt || !htab->dynbss
4617 || (!bfd_link_pic (info) && !htab->relbss))
4618 abort ();
4619
4620 return TRUE;
4621 }
4622
4623 /* Follow indirect and warning symbol links. */
4624
4625 static inline struct bfd_link_hash_entry *
4626 follow_link (struct bfd_link_hash_entry *h)
4627 {
4628 while (h->type == bfd_link_hash_indirect
4629 || h->type == bfd_link_hash_warning)
4630 h = h->u.i.link;
4631 return h;
4632 }
4633
4634 static inline struct elf_link_hash_entry *
4635 elf_follow_link (struct elf_link_hash_entry *h)
4636 {
4637 return (struct elf_link_hash_entry *) follow_link (&h->root);
4638 }
4639
4640 static inline struct ppc_link_hash_entry *
4641 ppc_follow_link (struct ppc_link_hash_entry *h)
4642 {
4643 return (struct ppc_link_hash_entry *) follow_link (&h->elf.root);
4644 }
4645
4646 /* Merge PLT info on FROM with that on TO. */
4647
4648 static void
4649 move_plt_plist (struct ppc_link_hash_entry *from,
4650 struct ppc_link_hash_entry *to)
4651 {
4652 if (from->elf.plt.plist != NULL)
4653 {
4654 if (to->elf.plt.plist != NULL)
4655 {
4656 struct plt_entry **entp;
4657 struct plt_entry *ent;
4658
4659 for (entp = &from->elf.plt.plist; (ent = *entp) != NULL; )
4660 {
4661 struct plt_entry *dent;
4662
4663 for (dent = to->elf.plt.plist; dent != NULL; dent = dent->next)
4664 if (dent->addend == ent->addend)
4665 {
4666 dent->plt.refcount += ent->plt.refcount;
4667 *entp = ent->next;
4668 break;
4669 }
4670 if (dent == NULL)
4671 entp = &ent->next;
4672 }
4673 *entp = to->elf.plt.plist;
4674 }
4675
4676 to->elf.plt.plist = from->elf.plt.plist;
4677 from->elf.plt.plist = NULL;
4678 }
4679 }
4680
4681 /* Copy the extra info we tack onto an elf_link_hash_entry. */
4682
4683 static void
4684 ppc64_elf_copy_indirect_symbol (struct bfd_link_info *info,
4685 struct elf_link_hash_entry *dir,
4686 struct elf_link_hash_entry *ind)
4687 {
4688 struct ppc_link_hash_entry *edir, *eind;
4689
4690 edir = (struct ppc_link_hash_entry *) dir;
4691 eind = (struct ppc_link_hash_entry *) ind;
4692
4693 edir->is_func |= eind->is_func;
4694 edir->is_func_descriptor |= eind->is_func_descriptor;
4695 edir->tls_mask |= eind->tls_mask;
4696 if (eind->oh != NULL)
4697 edir->oh = ppc_follow_link (eind->oh);
4698
4699 /* If called to transfer flags for a weakdef during processing
4700 of elf_adjust_dynamic_symbol, don't copy NON_GOT_REF.
4701 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
4702 if (!(ELIMINATE_COPY_RELOCS
4703 && eind->elf.root.type != bfd_link_hash_indirect
4704 && edir->elf.dynamic_adjusted))
4705 edir->elf.non_got_ref |= eind->elf.non_got_ref;
4706
4707 edir->elf.ref_dynamic |= eind->elf.ref_dynamic;
4708 edir->elf.ref_regular |= eind->elf.ref_regular;
4709 edir->elf.ref_regular_nonweak |= eind->elf.ref_regular_nonweak;
4710 edir->elf.needs_plt |= eind->elf.needs_plt;
4711 edir->elf.pointer_equality_needed |= eind->elf.pointer_equality_needed;
4712
4713 /* Copy over any dynamic relocs we may have on the indirect sym. */
4714 if (eind->dyn_relocs != NULL)
4715 {
4716 if (edir->dyn_relocs != NULL)
4717 {
4718 struct elf_dyn_relocs **pp;
4719 struct elf_dyn_relocs *p;
4720
4721 /* Add reloc counts against the indirect sym to the direct sym
4722 list. Merge any entries against the same section. */
4723 for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
4724 {
4725 struct elf_dyn_relocs *q;
4726
4727 for (q = edir->dyn_relocs; q != NULL; q = q->next)
4728 if (q->sec == p->sec)
4729 {
4730 q->pc_count += p->pc_count;
4731 q->count += p->count;
4732 *pp = p->next;
4733 break;
4734 }
4735 if (q == NULL)
4736 pp = &p->next;
4737 }
4738 *pp = edir->dyn_relocs;
4739 }
4740
4741 edir->dyn_relocs = eind->dyn_relocs;
4742 eind->dyn_relocs = NULL;
4743 }
4744
4745 /* If we were called to copy over info for a weak sym, that's all.
4746 You might think dyn_relocs need not be copied over; After all,
4747 both syms will be dynamic or both non-dynamic so we're just
4748 moving reloc accounting around. However, ELIMINATE_COPY_RELOCS
4749 code in ppc64_elf_adjust_dynamic_symbol needs to check for
4750 dyn_relocs in read-only sections, and it does so on what is the
4751 DIR sym here. */
4752 if (eind->elf.root.type != bfd_link_hash_indirect)
4753 return;
4754
4755 /* Copy over got entries that we may have already seen to the
4756 symbol which just became indirect. */
4757 if (eind->elf.got.glist != NULL)
4758 {
4759 if (edir->elf.got.glist != NULL)
4760 {
4761 struct got_entry **entp;
4762 struct got_entry *ent;
4763
4764 for (entp = &eind->elf.got.glist; (ent = *entp) != NULL; )
4765 {
4766 struct got_entry *dent;
4767
4768 for (dent = edir->elf.got.glist; dent != NULL; dent = dent->next)
4769 if (dent->addend == ent->addend
4770 && dent->owner == ent->owner
4771 && dent->tls_type == ent->tls_type)
4772 {
4773 dent->got.refcount += ent->got.refcount;
4774 *entp = ent->next;
4775 break;
4776 }
4777 if (dent == NULL)
4778 entp = &ent->next;
4779 }
4780 *entp = edir->elf.got.glist;
4781 }
4782
4783 edir->elf.got.glist = eind->elf.got.glist;
4784 eind->elf.got.glist = NULL;
4785 }
4786
4787 /* And plt entries. */
4788 move_plt_plist (eind, edir);
4789
4790 if (eind->elf.dynindx != -1)
4791 {
4792 if (edir->elf.dynindx != -1)
4793 _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
4794 edir->elf.dynstr_index);
4795 edir->elf.dynindx = eind->elf.dynindx;
4796 edir->elf.dynstr_index = eind->elf.dynstr_index;
4797 eind->elf.dynindx = -1;
4798 eind->elf.dynstr_index = 0;
4799 }
4800 }
4801
4802 /* Find the function descriptor hash entry from the given function code
4803 hash entry FH. Link the entries via their OH fields. */
4804
4805 static struct ppc_link_hash_entry *
4806 lookup_fdh (struct ppc_link_hash_entry *fh, struct ppc_link_hash_table *htab)
4807 {
4808 struct ppc_link_hash_entry *fdh = fh->oh;
4809
4810 if (fdh == NULL)
4811 {
4812 const char *fd_name = fh->elf.root.root.string + 1;
4813
4814 fdh = (struct ppc_link_hash_entry *)
4815 elf_link_hash_lookup (&htab->elf, fd_name, FALSE, FALSE, FALSE);
4816 if (fdh == NULL)
4817 return fdh;
4818
4819 fdh->is_func_descriptor = 1;
4820 fdh->oh = fh;
4821 fh->is_func = 1;
4822 fh->oh = fdh;
4823 }
4824
4825 return ppc_follow_link (fdh);
4826 }
4827
4828 /* Make a fake function descriptor sym for the code sym FH. */
4829
4830 static struct ppc_link_hash_entry *
4831 make_fdh (struct bfd_link_info *info,
4832 struct ppc_link_hash_entry *fh)
4833 {
4834 bfd *abfd;
4835 asymbol *newsym;
4836 struct bfd_link_hash_entry *bh;
4837 struct ppc_link_hash_entry *fdh;
4838
4839 abfd = fh->elf.root.u.undef.abfd;
4840 newsym = bfd_make_empty_symbol (abfd);
4841 newsym->name = fh->elf.root.root.string + 1;
4842 newsym->section = bfd_und_section_ptr;
4843 newsym->value = 0;
4844 newsym->flags = BSF_WEAK;
4845
4846 bh = NULL;
4847 if (!_bfd_generic_link_add_one_symbol (info, abfd, newsym->name,
4848 newsym->flags, newsym->section,
4849 newsym->value, NULL, FALSE, FALSE,
4850 &bh))
4851 return NULL;
4852
4853 fdh = (struct ppc_link_hash_entry *) bh;
4854 fdh->elf.non_elf = 0;
4855 fdh->fake = 1;
4856 fdh->is_func_descriptor = 1;
4857 fdh->oh = fh;
4858 fh->is_func = 1;
4859 fh->oh = fdh;
4860 return fdh;
4861 }
4862
4863 /* Fix function descriptor symbols defined in .opd sections to be
4864 function type. */
4865
4866 static bfd_boolean
4867 ppc64_elf_add_symbol_hook (bfd *ibfd,
4868 struct bfd_link_info *info,
4869 Elf_Internal_Sym *isym,
4870 const char **name,
4871 flagword *flags ATTRIBUTE_UNUSED,
4872 asection **sec,
4873 bfd_vma *value)
4874 {
4875 if ((ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC
4876 || ELF_ST_BIND (isym->st_info) == STB_GNU_UNIQUE)
4877 && (ibfd->flags & DYNAMIC) == 0
4878 && bfd_get_flavour (info->output_bfd) == bfd_target_elf_flavour)
4879 elf_tdata (info->output_bfd)->has_gnu_symbols = elf_gnu_symbol_any;
4880
4881 if (*sec != NULL
4882 && strcmp ((*sec)->name, ".opd") == 0)
4883 {
4884 asection *code_sec;
4885
4886 if (!(ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC
4887 || ELF_ST_TYPE (isym->st_info) == STT_FUNC))
4888 isym->st_info = ELF_ST_INFO (ELF_ST_BIND (isym->st_info), STT_FUNC);
4889
4890 /* If the symbol is a function defined in .opd, and the function
4891 code is in a discarded group, let it appear to be undefined. */
4892 if (!bfd_link_relocatable (info)
4893 && (*sec)->reloc_count != 0
4894 && opd_entry_value (*sec, *value, &code_sec, NULL,
4895 FALSE) != (bfd_vma) -1
4896 && discarded_section (code_sec))
4897 {
4898 *sec = bfd_und_section_ptr;
4899 isym->st_shndx = SHN_UNDEF;
4900 }
4901 }
4902 else if (*sec != NULL
4903 && strcmp ((*sec)->name, ".toc") == 0
4904 && ELF_ST_TYPE (isym->st_info) == STT_OBJECT)
4905 {
4906 struct ppc_link_hash_table *htab = ppc_hash_table (info);
4907 if (htab != NULL)
4908 htab->params->object_in_toc = 1;
4909 }
4910
4911 if ((STO_PPC64_LOCAL_MASK & isym->st_other) != 0)
4912 {
4913 if (abiversion (ibfd) == 0)
4914 set_abiversion (ibfd, 2);
4915 else if (abiversion (ibfd) == 1)
4916 {
4917 info->callbacks->einfo (_("%P: symbol '%s' has invalid st_other"
4918 " for ABI version 1\n"), name);
4919 bfd_set_error (bfd_error_bad_value);
4920 return FALSE;
4921 }
4922 }
4923
4924 return TRUE;
4925 }
4926
4927 /* Merge non-visibility st_other attributes: local entry point. */
4928
4929 static void
4930 ppc64_elf_merge_symbol_attribute (struct elf_link_hash_entry *h,
4931 const Elf_Internal_Sym *isym,
4932 bfd_boolean definition,
4933 bfd_boolean dynamic)
4934 {
4935 if (definition && !dynamic)
4936 h->other = ((isym->st_other & ~ELF_ST_VISIBILITY (-1))
4937 | ELF_ST_VISIBILITY (h->other));
4938 }
4939
4940 /* This function makes an old ABI object reference to ".bar" cause the
4941 inclusion of a new ABI object archive that defines "bar".
4942 NAME is a symbol defined in an archive. Return a symbol in the hash
4943 table that might be satisfied by the archive symbols. */
4944
4945 static struct elf_link_hash_entry *
4946 ppc64_elf_archive_symbol_lookup (bfd *abfd,
4947 struct bfd_link_info *info,
4948 const char *name)
4949 {
4950 struct elf_link_hash_entry *h;
4951 char *dot_name;
4952 size_t len;
4953
4954 h = _bfd_elf_archive_symbol_lookup (abfd, info, name);
4955 if (h != NULL
4956 /* Don't return this sym if it is a fake function descriptor
4957 created by add_symbol_adjust. */
4958 && !(h->root.type == bfd_link_hash_undefweak
4959 && ((struct ppc_link_hash_entry *) h)->fake))
4960 return h;
4961
4962 if (name[0] == '.')
4963 return h;
4964
4965 len = strlen (name);
4966 dot_name = bfd_alloc (abfd, len + 2);
4967 if (dot_name == NULL)
4968 return (struct elf_link_hash_entry *) 0 - 1;
4969 dot_name[0] = '.';
4970 memcpy (dot_name + 1, name, len + 1);
4971 h = _bfd_elf_archive_symbol_lookup (abfd, info, dot_name);
4972 bfd_release (abfd, dot_name);
4973 return h;
4974 }
4975
4976 /* This function satisfies all old ABI object references to ".bar" if a
4977 new ABI object defines "bar". Well, at least, undefined dot symbols
4978 are made weak. This stops later archive searches from including an
4979 object if we already have a function descriptor definition. It also
4980 prevents the linker complaining about undefined symbols.
4981 We also check and correct mismatched symbol visibility here. The
4982 most restrictive visibility of the function descriptor and the
4983 function entry symbol is used. */
4984
4985 static bfd_boolean
4986 add_symbol_adjust (struct ppc_link_hash_entry *eh, struct bfd_link_info *info)
4987 {
4988 struct ppc_link_hash_table *htab;
4989 struct ppc_link_hash_entry *fdh;
4990
4991 if (eh->elf.root.type == bfd_link_hash_indirect)
4992 return TRUE;
4993
4994 if (eh->elf.root.type == bfd_link_hash_warning)
4995 eh = (struct ppc_link_hash_entry *) eh->elf.root.u.i.link;
4996
4997 if (eh->elf.root.root.string[0] != '.')
4998 abort ();
4999
5000 htab = ppc_hash_table (info);
5001 if (htab == NULL)
5002 return FALSE;
5003
5004 fdh = lookup_fdh (eh, htab);
5005 if (fdh == NULL)
5006 {
5007 if (!bfd_link_relocatable (info)
5008 && (eh->elf.root.type == bfd_link_hash_undefined
5009 || eh->elf.root.type == bfd_link_hash_undefweak)
5010 && eh->elf.ref_regular)
5011 {
5012 /* Make an undefweak function descriptor sym, which is enough to
5013 pull in an --as-needed shared lib, but won't cause link
5014 errors. Archives are handled elsewhere. */
5015 fdh = make_fdh (info, eh);
5016 if (fdh == NULL)
5017 return FALSE;
5018 fdh->elf.ref_regular = 1;
5019 }
5020 }
5021 else
5022 {
5023 unsigned entry_vis = ELF_ST_VISIBILITY (eh->elf.other) - 1;
5024 unsigned descr_vis = ELF_ST_VISIBILITY (fdh->elf.other) - 1;
5025 if (entry_vis < descr_vis)
5026 fdh->elf.other += entry_vis - descr_vis;
5027 else if (entry_vis > descr_vis)
5028 eh->elf.other += descr_vis - entry_vis;
5029
5030 if ((fdh->elf.root.type == bfd_link_hash_defined
5031 || fdh->elf.root.type == bfd_link_hash_defweak)
5032 && eh->elf.root.type == bfd_link_hash_undefined)
5033 {
5034 eh->elf.root.type = bfd_link_hash_undefweak;
5035 eh->was_undefined = 1;
5036 htab->twiddled_syms = 1;
5037 }
5038 }
5039
5040 return TRUE;
5041 }
5042
5043 /* Set up opd section info and abiversion for IBFD, and process list
5044 of dot-symbols we made in link_hash_newfunc. */
5045
5046 static bfd_boolean
5047 ppc64_elf_before_check_relocs (bfd *ibfd, struct bfd_link_info *info)
5048 {
5049 struct ppc_link_hash_table *htab;
5050 struct ppc_link_hash_entry **p, *eh;
5051 asection *opd = bfd_get_section_by_name (ibfd, ".opd");
5052
5053 if (opd != NULL && opd->size != 0)
5054 {
5055 if (abiversion (ibfd) == 0)
5056 set_abiversion (ibfd, 1);
5057 else if (abiversion (ibfd) == 2)
5058 {
5059 info->callbacks->einfo (_("%P: %B .opd not allowed in ABI"
5060 " version %d\n"),
5061 ibfd, abiversion (ibfd));
5062 bfd_set_error (bfd_error_bad_value);
5063 return FALSE;
5064 }
5065
5066 if ((ibfd->flags & DYNAMIC) == 0
5067 && (opd->flags & SEC_RELOC) != 0
5068 && opd->reloc_count != 0
5069 && !bfd_is_abs_section (opd->output_section))
5070 {
5071 /* Garbage collection needs some extra help with .opd sections.
5072 We don't want to necessarily keep everything referenced by
5073 relocs in .opd, as that would keep all functions. Instead,
5074 if we reference an .opd symbol (a function descriptor), we
5075 want to keep the function code symbol's section. This is
5076 easy for global symbols, but for local syms we need to keep
5077 information about the associated function section. */
5078 bfd_size_type amt;
5079 asection **opd_sym_map;
5080
5081 amt = OPD_NDX (opd->size) * sizeof (*opd_sym_map);
5082 opd_sym_map = bfd_zalloc (ibfd, amt);
5083 if (opd_sym_map == NULL)
5084 return FALSE;
5085 ppc64_elf_section_data (opd)->u.opd.func_sec = opd_sym_map;
5086 BFD_ASSERT (ppc64_elf_section_data (opd)->sec_type == sec_normal);
5087 ppc64_elf_section_data (opd)->sec_type = sec_opd;
5088 }
5089 }
5090
5091 if (!is_ppc64_elf (info->output_bfd))
5092 return TRUE;
5093 htab = ppc_hash_table (info);
5094 if (htab == NULL)
5095 return FALSE;
5096
5097 /* For input files without an explicit abiversion in e_flags
5098 we should have flagged any with symbol st_other bits set
5099 as ELFv1 and above flagged those with .opd as ELFv2.
5100 Set the output abiversion if not yet set, and for any input
5101 still ambiguous, take its abiversion from the output.
5102 Differences in ABI are reported later. */
5103 if (abiversion (info->output_bfd) == 0)
5104 set_abiversion (info->output_bfd, abiversion (ibfd));
5105 else if (abiversion (ibfd) == 0)
5106 set_abiversion (ibfd, abiversion (info->output_bfd));
5107
5108 p = &htab->dot_syms;
5109 while ((eh = *p) != NULL)
5110 {
5111 *p = NULL;
5112 if (&eh->elf == htab->elf.hgot)
5113 ;
5114 else if (htab->elf.hgot == NULL
5115 && strcmp (eh->elf.root.root.string, ".TOC.") == 0)
5116 htab->elf.hgot = &eh->elf;
5117 else if (!add_symbol_adjust (eh, info))
5118 return FALSE;
5119 p = &eh->u.next_dot_sym;
5120 }
5121
5122 /* Clear the list for non-ppc64 input files. */
5123 p = &htab->dot_syms;
5124 while ((eh = *p) != NULL)
5125 {
5126 *p = NULL;
5127 p = &eh->u.next_dot_sym;
5128 }
5129
5130 /* We need to fix the undefs list for any syms we have twiddled to
5131 undef_weak. */
5132 if (htab->twiddled_syms)
5133 {
5134 bfd_link_repair_undef_list (&htab->elf.root);
5135 htab->twiddled_syms = 0;
5136 }
5137 return TRUE;
5138 }
5139
5140 /* Undo hash table changes when an --as-needed input file is determined
5141 not to be needed. */
5142
5143 static bfd_boolean
5144 ppc64_elf_notice_as_needed (bfd *ibfd,
5145 struct bfd_link_info *info,
5146 enum notice_asneeded_action act)
5147 {
5148 if (act == notice_not_needed)
5149 {
5150 struct ppc_link_hash_table *htab = ppc_hash_table (info);
5151
5152 if (htab == NULL)
5153 return FALSE;
5154
5155 htab->dot_syms = NULL;
5156 }
5157 return _bfd_elf_notice_as_needed (ibfd, info, act);
5158 }
5159
5160 /* If --just-symbols against a final linked binary, then assume we need
5161 toc adjusting stubs when calling functions defined there. */
5162
5163 static void
5164 ppc64_elf_link_just_syms (asection *sec, struct bfd_link_info *info)
5165 {
5166 if ((sec->flags & SEC_CODE) != 0
5167 && (sec->owner->flags & (EXEC_P | DYNAMIC)) != 0
5168 && is_ppc64_elf (sec->owner))
5169 {
5170 if (abiversion (sec->owner) >= 2
5171 || bfd_get_section_by_name (sec->owner, ".opd") != NULL)
5172 sec->has_toc_reloc = 1;
5173 }
5174 _bfd_elf_link_just_syms (sec, info);
5175 }
5176
5177 static struct plt_entry **
5178 update_local_sym_info (bfd *abfd, Elf_Internal_Shdr *symtab_hdr,
5179 unsigned long r_symndx, bfd_vma r_addend, int tls_type)
5180 {
5181 struct got_entry **local_got_ents = elf_local_got_ents (abfd);
5182 struct plt_entry **local_plt;
5183 unsigned char *local_got_tls_masks;
5184
5185 if (local_got_ents == NULL)
5186 {
5187 bfd_size_type size = symtab_hdr->sh_info;
5188
5189 size *= (sizeof (*local_got_ents)
5190 + sizeof (*local_plt)
5191 + sizeof (*local_got_tls_masks));
5192 local_got_ents = bfd_zalloc (abfd, size);
5193 if (local_got_ents == NULL)
5194 return NULL;
5195 elf_local_got_ents (abfd) = local_got_ents;
5196 }
5197
5198 if ((tls_type & (PLT_IFUNC | TLS_EXPLICIT)) == 0)
5199 {
5200 struct got_entry *ent;
5201
5202 for (ent = local_got_ents[r_symndx]; ent != NULL; ent = ent->next)
5203 if (ent->addend == r_addend
5204 && ent->owner == abfd
5205 && ent->tls_type == tls_type)
5206 break;
5207 if (ent == NULL)
5208 {
5209 bfd_size_type amt = sizeof (*ent);
5210 ent = bfd_alloc (abfd, amt);
5211 if (ent == NULL)
5212 return FALSE;
5213 ent->next = local_got_ents[r_symndx];
5214 ent->addend = r_addend;
5215 ent->owner = abfd;
5216 ent->tls_type = tls_type;
5217 ent->is_indirect = FALSE;
5218 ent->got.refcount = 0;
5219 local_got_ents[r_symndx] = ent;
5220 }
5221 ent->got.refcount += 1;
5222 }
5223
5224 local_plt = (struct plt_entry **) (local_got_ents + symtab_hdr->sh_info);
5225 local_got_tls_masks = (unsigned char *) (local_plt + symtab_hdr->sh_info);
5226 local_got_tls_masks[r_symndx] |= tls_type;
5227
5228 return local_plt + r_symndx;
5229 }
5230
5231 static bfd_boolean
5232 update_plt_info (bfd *abfd, struct plt_entry **plist, bfd_vma addend)
5233 {
5234 struct plt_entry *ent;
5235
5236 for (ent = *plist; ent != NULL; ent = ent->next)
5237 if (ent->addend == addend)
5238 break;
5239 if (ent == NULL)
5240 {
5241 bfd_size_type amt = sizeof (*ent);
5242 ent = bfd_alloc (abfd, amt);
5243 if (ent == NULL)
5244 return FALSE;
5245 ent->next = *plist;
5246 ent->addend = addend;
5247 ent->plt.refcount = 0;
5248 *plist = ent;
5249 }
5250 ent->plt.refcount += 1;
5251 return TRUE;
5252 }
5253
5254 static bfd_boolean
5255 is_branch_reloc (enum elf_ppc64_reloc_type r_type)
5256 {
5257 return (r_type == R_PPC64_REL24
5258 || r_type == R_PPC64_REL14
5259 || r_type == R_PPC64_REL14_BRTAKEN
5260 || r_type == R_PPC64_REL14_BRNTAKEN
5261 || r_type == R_PPC64_ADDR24
5262 || r_type == R_PPC64_ADDR14
5263 || r_type == R_PPC64_ADDR14_BRTAKEN
5264 || r_type == R_PPC64_ADDR14_BRNTAKEN);
5265 }
5266
5267 /* Look through the relocs for a section during the first phase, and
5268 calculate needed space in the global offset table, procedure
5269 linkage table, and dynamic reloc sections. */
5270
5271 static bfd_boolean
5272 ppc64_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
5273 asection *sec, const Elf_Internal_Rela *relocs)
5274 {
5275 struct ppc_link_hash_table *htab;
5276 Elf_Internal_Shdr *symtab_hdr;
5277 struct elf_link_hash_entry **sym_hashes;
5278 const Elf_Internal_Rela *rel;
5279 const Elf_Internal_Rela *rel_end;
5280 asection *sreloc;
5281 asection **opd_sym_map;
5282 struct elf_link_hash_entry *tga, *dottga;
5283
5284 if (bfd_link_relocatable (info))
5285 return TRUE;
5286
5287 /* Don't do anything special with non-loaded, non-alloced sections.
5288 In particular, any relocs in such sections should not affect GOT
5289 and PLT reference counting (ie. we don't allow them to create GOT
5290 or PLT entries), there's no possibility or desire to optimize TLS
5291 relocs, and there's not much point in propagating relocs to shared
5292 libs that the dynamic linker won't relocate. */
5293 if ((sec->flags & SEC_ALLOC) == 0)
5294 return TRUE;
5295
5296 BFD_ASSERT (is_ppc64_elf (abfd));
5297
5298 htab = ppc_hash_table (info);
5299 if (htab == NULL)
5300 return FALSE;
5301
5302 tga = elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
5303 FALSE, FALSE, TRUE);
5304 dottga = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
5305 FALSE, FALSE, TRUE);
5306 symtab_hdr = &elf_symtab_hdr (abfd);
5307 sym_hashes = elf_sym_hashes (abfd);
5308 sreloc = NULL;
5309 opd_sym_map = NULL;
5310 if (ppc64_elf_section_data (sec) != NULL
5311 && ppc64_elf_section_data (sec)->sec_type == sec_opd)
5312 opd_sym_map = ppc64_elf_section_data (sec)->u.opd.func_sec;
5313
5314 rel_end = relocs + sec->reloc_count;
5315 for (rel = relocs; rel < rel_end; rel++)
5316 {
5317 unsigned long r_symndx;
5318 struct elf_link_hash_entry *h;
5319 enum elf_ppc64_reloc_type r_type;
5320 int tls_type;
5321 struct _ppc64_elf_section_data *ppc64_sec;
5322 struct plt_entry **ifunc;
5323
5324 r_symndx = ELF64_R_SYM (rel->r_info);
5325 if (r_symndx < symtab_hdr->sh_info)
5326 h = NULL;
5327 else
5328 {
5329 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
5330 h = elf_follow_link (h);
5331
5332 /* PR15323, ref flags aren't set for references in the same
5333 object. */
5334 h->root.non_ir_ref = 1;
5335
5336 if (h == htab->elf.hgot)
5337 sec->has_toc_reloc = 1;
5338 }
5339
5340 tls_type = 0;
5341 ifunc = NULL;
5342 if (h != NULL)
5343 {
5344 if (h->type == STT_GNU_IFUNC)
5345 {
5346 h->needs_plt = 1;
5347 ifunc = &h->plt.plist;
5348 }
5349 }
5350 else
5351 {
5352 Elf_Internal_Sym *isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5353 abfd, r_symndx);
5354 if (isym == NULL)
5355 return FALSE;
5356
5357 if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
5358 {
5359 ifunc = update_local_sym_info (abfd, symtab_hdr, r_symndx,
5360 rel->r_addend, PLT_IFUNC);
5361 if (ifunc == NULL)
5362 return FALSE;
5363 }
5364 }
5365 r_type = ELF64_R_TYPE (rel->r_info);
5366 if (is_branch_reloc (r_type))
5367 {
5368 if (h != NULL && (h == tga || h == dottga))
5369 {
5370 if (rel != relocs
5371 && (ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSGD
5372 || ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSLD))
5373 /* We have a new-style __tls_get_addr call with a marker
5374 reloc. */
5375 ;
5376 else
5377 /* Mark this section as having an old-style call. */
5378 sec->has_tls_get_addr_call = 1;
5379 }
5380
5381 /* STT_GNU_IFUNC symbols must have a PLT entry. */
5382 if (ifunc != NULL
5383 && !update_plt_info (abfd, ifunc, rel->r_addend))
5384 return FALSE;
5385 }
5386
5387 switch (r_type)
5388 {
5389 case R_PPC64_TLSGD:
5390 case R_PPC64_TLSLD:
5391 /* These special tls relocs tie a call to __tls_get_addr with
5392 its parameter symbol. */
5393 break;
5394
5395 case R_PPC64_GOT_TLSLD16:
5396 case R_PPC64_GOT_TLSLD16_LO:
5397 case R_PPC64_GOT_TLSLD16_HI:
5398 case R_PPC64_GOT_TLSLD16_HA:
5399 tls_type = TLS_TLS | TLS_LD;
5400 goto dogottls;
5401
5402 case R_PPC64_GOT_TLSGD16:
5403 case R_PPC64_GOT_TLSGD16_LO:
5404 case R_PPC64_GOT_TLSGD16_HI:
5405 case R_PPC64_GOT_TLSGD16_HA:
5406 tls_type = TLS_TLS | TLS_GD;
5407 goto dogottls;
5408
5409 case R_PPC64_GOT_TPREL16_DS:
5410 case R_PPC64_GOT_TPREL16_LO_DS:
5411 case R_PPC64_GOT_TPREL16_HI:
5412 case R_PPC64_GOT_TPREL16_HA:
5413 if (bfd_link_pic (info))
5414 info->flags |= DF_STATIC_TLS;
5415 tls_type = TLS_TLS | TLS_TPREL;
5416 goto dogottls;
5417
5418 case R_PPC64_GOT_DTPREL16_DS:
5419 case R_PPC64_GOT_DTPREL16_LO_DS:
5420 case R_PPC64_GOT_DTPREL16_HI:
5421 case R_PPC64_GOT_DTPREL16_HA:
5422 tls_type = TLS_TLS | TLS_DTPREL;
5423 dogottls:
5424 sec->has_tls_reloc = 1;
5425 /* Fall thru */
5426
5427 case R_PPC64_GOT16:
5428 case R_PPC64_GOT16_DS:
5429 case R_PPC64_GOT16_HA:
5430 case R_PPC64_GOT16_HI:
5431 case R_PPC64_GOT16_LO:
5432 case R_PPC64_GOT16_LO_DS:
5433 /* This symbol requires a global offset table entry. */
5434 sec->has_toc_reloc = 1;
5435 if (r_type == R_PPC64_GOT_TLSLD16
5436 || r_type == R_PPC64_GOT_TLSGD16
5437 || r_type == R_PPC64_GOT_TPREL16_DS
5438 || r_type == R_PPC64_GOT_DTPREL16_DS
5439 || r_type == R_PPC64_GOT16
5440 || r_type == R_PPC64_GOT16_DS)
5441 {
5442 htab->do_multi_toc = 1;
5443 ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5444 }
5445
5446 if (ppc64_elf_tdata (abfd)->got == NULL
5447 && !create_got_section (abfd, info))
5448 return FALSE;
5449
5450 if (h != NULL)
5451 {
5452 struct ppc_link_hash_entry *eh;
5453 struct got_entry *ent;
5454
5455 eh = (struct ppc_link_hash_entry *) h;
5456 for (ent = eh->elf.got.glist; ent != NULL; ent = ent->next)
5457 if (ent->addend == rel->r_addend
5458 && ent->owner == abfd
5459 && ent->tls_type == tls_type)
5460 break;
5461 if (ent == NULL)
5462 {
5463 bfd_size_type amt = sizeof (*ent);
5464 ent = bfd_alloc (abfd, amt);
5465 if (ent == NULL)
5466 return FALSE;
5467 ent->next = eh->elf.got.glist;
5468 ent->addend = rel->r_addend;
5469 ent->owner = abfd;
5470 ent->tls_type = tls_type;
5471 ent->is_indirect = FALSE;
5472 ent->got.refcount = 0;
5473 eh->elf.got.glist = ent;
5474 }
5475 ent->got.refcount += 1;
5476 eh->tls_mask |= tls_type;
5477 }
5478 else
5479 /* This is a global offset table entry for a local symbol. */
5480 if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5481 rel->r_addend, tls_type))
5482 return FALSE;
5483
5484 /* We may also need a plt entry if the symbol turns out to be
5485 an ifunc. */
5486 if (h != NULL && !bfd_link_pic (info) && abiversion (abfd) != 1)
5487 {
5488 if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5489 return FALSE;
5490 }
5491 break;
5492
5493 case R_PPC64_PLT16_HA:
5494 case R_PPC64_PLT16_HI:
5495 case R_PPC64_PLT16_LO:
5496 case R_PPC64_PLT32:
5497 case R_PPC64_PLT64:
5498 /* This symbol requires a procedure linkage table entry. We
5499 actually build the entry in adjust_dynamic_symbol,
5500 because this might be a case of linking PIC code without
5501 linking in any dynamic objects, in which case we don't
5502 need to generate a procedure linkage table after all. */
5503 if (h == NULL)
5504 {
5505 /* It does not make sense to have a procedure linkage
5506 table entry for a local symbol. */
5507 bfd_set_error (bfd_error_bad_value);
5508 return FALSE;
5509 }
5510 else
5511 {
5512 if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5513 return FALSE;
5514 h->needs_plt = 1;
5515 if (h->root.root.string[0] == '.'
5516 && h->root.root.string[1] != '\0')
5517 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5518 }
5519 break;
5520
5521 /* The following relocations don't need to propagate the
5522 relocation if linking a shared object since they are
5523 section relative. */
5524 case R_PPC64_SECTOFF:
5525 case R_PPC64_SECTOFF_LO:
5526 case R_PPC64_SECTOFF_HI:
5527 case R_PPC64_SECTOFF_HA:
5528 case R_PPC64_SECTOFF_DS:
5529 case R_PPC64_SECTOFF_LO_DS:
5530 case R_PPC64_DTPREL16:
5531 case R_PPC64_DTPREL16_LO:
5532 case R_PPC64_DTPREL16_HI:
5533 case R_PPC64_DTPREL16_HA:
5534 case R_PPC64_DTPREL16_DS:
5535 case R_PPC64_DTPREL16_LO_DS:
5536 case R_PPC64_DTPREL16_HIGH:
5537 case R_PPC64_DTPREL16_HIGHA:
5538 case R_PPC64_DTPREL16_HIGHER:
5539 case R_PPC64_DTPREL16_HIGHERA:
5540 case R_PPC64_DTPREL16_HIGHEST:
5541 case R_PPC64_DTPREL16_HIGHESTA:
5542 break;
5543
5544 /* Nor do these. */
5545 case R_PPC64_REL16:
5546 case R_PPC64_REL16_LO:
5547 case R_PPC64_REL16_HI:
5548 case R_PPC64_REL16_HA:
5549 case R_PPC64_REL16DX_HA:
5550 break;
5551
5552 /* Not supported as a dynamic relocation. */
5553 case R_PPC64_ADDR64_LOCAL:
5554 if (bfd_link_pic (info))
5555 {
5556 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
5557 ppc_howto_init ();
5558 info->callbacks->einfo (_("%P: %H: %s reloc unsupported "
5559 "in shared libraries and PIEs.\n"),
5560 abfd, sec, rel->r_offset,
5561 ppc64_elf_howto_table[r_type]->name);
5562 bfd_set_error (bfd_error_bad_value);
5563 return FALSE;
5564 }
5565 break;
5566
5567 case R_PPC64_TOC16:
5568 case R_PPC64_TOC16_DS:
5569 htab->do_multi_toc = 1;
5570 ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5571 case R_PPC64_TOC16_LO:
5572 case R_PPC64_TOC16_HI:
5573 case R_PPC64_TOC16_HA:
5574 case R_PPC64_TOC16_LO_DS:
5575 sec->has_toc_reloc = 1;
5576 break;
5577
5578 /* This relocation describes the C++ object vtable hierarchy.
5579 Reconstruct it for later use during GC. */
5580 case R_PPC64_GNU_VTINHERIT:
5581 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
5582 return FALSE;
5583 break;
5584
5585 /* This relocation describes which C++ vtable entries are actually
5586 used. Record for later use during GC. */
5587 case R_PPC64_GNU_VTENTRY:
5588 BFD_ASSERT (h != NULL);
5589 if (h != NULL
5590 && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
5591 return FALSE;
5592 break;
5593
5594 case R_PPC64_REL14:
5595 case R_PPC64_REL14_BRTAKEN:
5596 case R_PPC64_REL14_BRNTAKEN:
5597 {
5598 asection *dest = NULL;
5599
5600 /* Heuristic: If jumping outside our section, chances are
5601 we are going to need a stub. */
5602 if (h != NULL)
5603 {
5604 /* If the sym is weak it may be overridden later, so
5605 don't assume we know where a weak sym lives. */
5606 if (h->root.type == bfd_link_hash_defined)
5607 dest = h->root.u.def.section;
5608 }
5609 else
5610 {
5611 Elf_Internal_Sym *isym;
5612
5613 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5614 abfd, r_symndx);
5615 if (isym == NULL)
5616 return FALSE;
5617
5618 dest = bfd_section_from_elf_index (abfd, isym->st_shndx);
5619 }
5620
5621 if (dest != sec)
5622 ppc64_elf_section_data (sec)->has_14bit_branch = 1;
5623 }
5624 /* Fall through. */
5625
5626 case R_PPC64_REL24:
5627 if (h != NULL && ifunc == NULL)
5628 {
5629 /* We may need a .plt entry if the function this reloc
5630 refers to is in a shared lib. */
5631 if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5632 return FALSE;
5633 h->needs_plt = 1;
5634 if (h->root.root.string[0] == '.'
5635 && h->root.root.string[1] != '\0')
5636 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5637 if (h == tga || h == dottga)
5638 sec->has_tls_reloc = 1;
5639 }
5640 break;
5641
5642 case R_PPC64_TPREL64:
5643 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_TPREL;
5644 if (bfd_link_pic (info))
5645 info->flags |= DF_STATIC_TLS;
5646 goto dotlstoc;
5647
5648 case R_PPC64_DTPMOD64:
5649 if (rel + 1 < rel_end
5650 && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
5651 && rel[1].r_offset == rel->r_offset + 8)
5652 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_GD;
5653 else
5654 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_LD;
5655 goto dotlstoc;
5656
5657 case R_PPC64_DTPREL64:
5658 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_DTPREL;
5659 if (rel != relocs
5660 && rel[-1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPMOD64)
5661 && rel[-1].r_offset == rel->r_offset - 8)
5662 /* This is the second reloc of a dtpmod, dtprel pair.
5663 Don't mark with TLS_DTPREL. */
5664 goto dodyn;
5665
5666 dotlstoc:
5667 sec->has_tls_reloc = 1;
5668 if (h != NULL)
5669 {
5670 struct ppc_link_hash_entry *eh;
5671 eh = (struct ppc_link_hash_entry *) h;
5672 eh->tls_mask |= tls_type;
5673 }
5674 else
5675 if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5676 rel->r_addend, tls_type))
5677 return FALSE;
5678
5679 ppc64_sec = ppc64_elf_section_data (sec);
5680 if (ppc64_sec->sec_type != sec_toc)
5681 {
5682 bfd_size_type amt;
5683
5684 /* One extra to simplify get_tls_mask. */
5685 amt = sec->size * sizeof (unsigned) / 8 + sizeof (unsigned);
5686 ppc64_sec->u.toc.symndx = bfd_zalloc (abfd, amt);
5687 if (ppc64_sec->u.toc.symndx == NULL)
5688 return FALSE;
5689 amt = sec->size * sizeof (bfd_vma) / 8;
5690 ppc64_sec->u.toc.add = bfd_zalloc (abfd, amt);
5691 if (ppc64_sec->u.toc.add == NULL)
5692 return FALSE;
5693 BFD_ASSERT (ppc64_sec->sec_type == sec_normal);
5694 ppc64_sec->sec_type = sec_toc;
5695 }
5696 BFD_ASSERT (rel->r_offset % 8 == 0);
5697 ppc64_sec->u.toc.symndx[rel->r_offset / 8] = r_symndx;
5698 ppc64_sec->u.toc.add[rel->r_offset / 8] = rel->r_addend;
5699
5700 /* Mark the second slot of a GD or LD entry.
5701 -1 to indicate GD and -2 to indicate LD. */
5702 if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_GD))
5703 ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -1;
5704 else if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_LD))
5705 ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -2;
5706 goto dodyn;
5707
5708 case R_PPC64_TPREL16:
5709 case R_PPC64_TPREL16_LO:
5710 case R_PPC64_TPREL16_HI:
5711 case R_PPC64_TPREL16_HA:
5712 case R_PPC64_TPREL16_DS:
5713 case R_PPC64_TPREL16_LO_DS:
5714 case R_PPC64_TPREL16_HIGH:
5715 case R_PPC64_TPREL16_HIGHA:
5716 case R_PPC64_TPREL16_HIGHER:
5717 case R_PPC64_TPREL16_HIGHERA:
5718 case R_PPC64_TPREL16_HIGHEST:
5719 case R_PPC64_TPREL16_HIGHESTA:
5720 if (bfd_link_pic (info))
5721 {
5722 info->flags |= DF_STATIC_TLS;
5723 goto dodyn;
5724 }
5725 break;
5726
5727 case R_PPC64_ADDR64:
5728 if (opd_sym_map != NULL
5729 && rel + 1 < rel_end
5730 && ELF64_R_TYPE ((rel + 1)->r_info) == R_PPC64_TOC)
5731 {
5732 if (h != NULL)
5733 {
5734 if (h->root.root.string[0] == '.'
5735 && h->root.root.string[1] != 0
5736 && lookup_fdh ((struct ppc_link_hash_entry *) h, htab))
5737 ;
5738 else
5739 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5740 }
5741 else
5742 {
5743 asection *s;
5744 Elf_Internal_Sym *isym;
5745
5746 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5747 abfd, r_symndx);
5748 if (isym == NULL)
5749 return FALSE;
5750
5751 s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5752 if (s != NULL && s != sec)
5753 opd_sym_map[OPD_NDX (rel->r_offset)] = s;
5754 }
5755 }
5756 /* Fall through. */
5757
5758 case R_PPC64_ADDR16:
5759 case R_PPC64_ADDR16_DS:
5760 case R_PPC64_ADDR16_HA:
5761 case R_PPC64_ADDR16_HI:
5762 case R_PPC64_ADDR16_HIGH:
5763 case R_PPC64_ADDR16_HIGHA:
5764 case R_PPC64_ADDR16_HIGHER:
5765 case R_PPC64_ADDR16_HIGHERA:
5766 case R_PPC64_ADDR16_HIGHEST:
5767 case R_PPC64_ADDR16_HIGHESTA:
5768 case R_PPC64_ADDR16_LO:
5769 case R_PPC64_ADDR16_LO_DS:
5770 if (h != NULL && !bfd_link_pic (info) && abiversion (abfd) != 1
5771 && rel->r_addend == 0)
5772 {
5773 /* We may need a .plt entry if this reloc refers to a
5774 function in a shared lib. */
5775 if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5776 return FALSE;
5777 h->pointer_equality_needed = 1;
5778 }
5779 /* Fall through. */
5780
5781 case R_PPC64_REL30:
5782 case R_PPC64_REL32:
5783 case R_PPC64_REL64:
5784 case R_PPC64_ADDR14:
5785 case R_PPC64_ADDR14_BRNTAKEN:
5786 case R_PPC64_ADDR14_BRTAKEN:
5787 case R_PPC64_ADDR24:
5788 case R_PPC64_ADDR32:
5789 case R_PPC64_UADDR16:
5790 case R_PPC64_UADDR32:
5791 case R_PPC64_UADDR64:
5792 case R_PPC64_TOC:
5793 if (h != NULL && !bfd_link_pic (info))
5794 /* We may need a copy reloc. */
5795 h->non_got_ref = 1;
5796
5797 /* Don't propagate .opd relocs. */
5798 if (NO_OPD_RELOCS && opd_sym_map != NULL)
5799 break;
5800
5801 /* If we are creating a shared library, and this is a reloc
5802 against a global symbol, or a non PC relative reloc
5803 against a local symbol, then we need to copy the reloc
5804 into the shared library. However, if we are linking with
5805 -Bsymbolic, we do not need to copy a reloc against a
5806 global symbol which is defined in an object we are
5807 including in the link (i.e., DEF_REGULAR is set). At
5808 this point we have not seen all the input files, so it is
5809 possible that DEF_REGULAR is not set now but will be set
5810 later (it is never cleared). In case of a weak definition,
5811 DEF_REGULAR may be cleared later by a strong definition in
5812 a shared library. We account for that possibility below by
5813 storing information in the dyn_relocs field of the hash
5814 table entry. A similar situation occurs when creating
5815 shared libraries and symbol visibility changes render the
5816 symbol local.
5817
5818 If on the other hand, we are creating an executable, we
5819 may need to keep relocations for symbols satisfied by a
5820 dynamic library if we manage to avoid copy relocs for the
5821 symbol. */
5822 dodyn:
5823 if ((bfd_link_pic (info)
5824 && (must_be_dyn_reloc (info, r_type)
5825 || (h != NULL
5826 && (!SYMBOLIC_BIND (info, h)
5827 || h->root.type == bfd_link_hash_defweak
5828 || !h->def_regular))))
5829 || (ELIMINATE_COPY_RELOCS
5830 && !bfd_link_pic (info)
5831 && h != NULL
5832 && (h->root.type == bfd_link_hash_defweak
5833 || !h->def_regular))
5834 || (!bfd_link_pic (info)
5835 && ifunc != NULL))
5836 {
5837 /* We must copy these reloc types into the output file.
5838 Create a reloc section in dynobj and make room for
5839 this reloc. */
5840 if (sreloc == NULL)
5841 {
5842 sreloc = _bfd_elf_make_dynamic_reloc_section
5843 (sec, htab->elf.dynobj, 3, abfd, /*rela?*/ TRUE);
5844
5845 if (sreloc == NULL)
5846 return FALSE;
5847 }
5848
5849 /* If this is a global symbol, we count the number of
5850 relocations we need for this symbol. */
5851 if (h != NULL)
5852 {
5853 struct elf_dyn_relocs *p;
5854 struct elf_dyn_relocs **head;
5855
5856 head = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
5857 p = *head;
5858 if (p == NULL || p->sec != sec)
5859 {
5860 p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5861 if (p == NULL)
5862 return FALSE;
5863 p->next = *head;
5864 *head = p;
5865 p->sec = sec;
5866 p->count = 0;
5867 p->pc_count = 0;
5868 }
5869 p->count += 1;
5870 if (!must_be_dyn_reloc (info, r_type))
5871 p->pc_count += 1;
5872 }
5873 else
5874 {
5875 /* Track dynamic relocs needed for local syms too.
5876 We really need local syms available to do this
5877 easily. Oh well. */
5878 struct ppc_dyn_relocs *p;
5879 struct ppc_dyn_relocs **head;
5880 bfd_boolean is_ifunc;
5881 asection *s;
5882 void *vpp;
5883 Elf_Internal_Sym *isym;
5884
5885 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5886 abfd, r_symndx);
5887 if (isym == NULL)
5888 return FALSE;
5889
5890 s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5891 if (s == NULL)
5892 s = sec;
5893
5894 vpp = &elf_section_data (s)->local_dynrel;
5895 head = (struct ppc_dyn_relocs **) vpp;
5896 is_ifunc = ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC;
5897 p = *head;
5898 if (p != NULL && p->sec == sec && p->ifunc != is_ifunc)
5899 p = p->next;
5900 if (p == NULL || p->sec != sec || p->ifunc != is_ifunc)
5901 {
5902 p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5903 if (p == NULL)
5904 return FALSE;
5905 p->next = *head;
5906 *head = p;
5907 p->sec = sec;
5908 p->ifunc = is_ifunc;
5909 p->count = 0;
5910 }
5911 p->count += 1;
5912 }
5913 }
5914 break;
5915
5916 default:
5917 break;
5918 }
5919 }
5920
5921 return TRUE;
5922 }
5923
5924 /* Merge backend specific data from an object file to the output
5925 object file when linking. */
5926
5927 static bfd_boolean
5928 ppc64_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
5929 {
5930 unsigned long iflags, oflags;
5931
5932 if ((ibfd->flags & BFD_LINKER_CREATED) != 0)
5933 return TRUE;
5934
5935 if (!is_ppc64_elf (ibfd) || !is_ppc64_elf (obfd))
5936 return TRUE;
5937
5938 if (!_bfd_generic_verify_endian_match (ibfd, obfd))
5939 return FALSE;
5940
5941 iflags = elf_elfheader (ibfd)->e_flags;
5942 oflags = elf_elfheader (obfd)->e_flags;
5943
5944 if (iflags & ~EF_PPC64_ABI)
5945 {
5946 (*_bfd_error_handler)
5947 (_("%B uses unknown e_flags 0x%lx"), ibfd, iflags);
5948 bfd_set_error (bfd_error_bad_value);
5949 return FALSE;
5950 }
5951 else if (iflags != oflags && iflags != 0)
5952 {
5953 (*_bfd_error_handler)
5954 (_("%B: ABI version %ld is not compatible with ABI version %ld output"),
5955 ibfd, iflags, oflags);
5956 bfd_set_error (bfd_error_bad_value);
5957 return FALSE;
5958 }
5959
5960 /* Merge Tag_compatibility attributes and any common GNU ones. */
5961 _bfd_elf_merge_object_attributes (ibfd, obfd);
5962
5963 return TRUE;
5964 }
5965
5966 static bfd_boolean
5967 ppc64_elf_print_private_bfd_data (bfd *abfd, void *ptr)
5968 {
5969 /* Print normal ELF private data. */
5970 _bfd_elf_print_private_bfd_data (abfd, ptr);
5971
5972 if (elf_elfheader (abfd)->e_flags != 0)
5973 {
5974 FILE *file = ptr;
5975
5976 /* xgettext:c-format */
5977 fprintf (file, _("private flags = 0x%lx:"),
5978 elf_elfheader (abfd)->e_flags);
5979
5980 if ((elf_elfheader (abfd)->e_flags & EF_PPC64_ABI) != 0)
5981 fprintf (file, _(" [abiv%ld]"),
5982 elf_elfheader (abfd)->e_flags & EF_PPC64_ABI);
5983 fputc ('\n', file);
5984 }
5985
5986 return TRUE;
5987 }
5988
5989 /* OFFSET in OPD_SEC specifies a function descriptor. Return the address
5990 of the code entry point, and its section, which must be in the same
5991 object as OPD_SEC. Returns (bfd_vma) -1 on error. */
5992
5993 static bfd_vma
5994 opd_entry_value (asection *opd_sec,
5995 bfd_vma offset,
5996 asection **code_sec,
5997 bfd_vma *code_off,
5998 bfd_boolean in_code_sec)
5999 {
6000 bfd *opd_bfd = opd_sec->owner;
6001 Elf_Internal_Rela *relocs;
6002 Elf_Internal_Rela *lo, *hi, *look;
6003 bfd_vma val;
6004
6005 /* No relocs implies we are linking a --just-symbols object, or looking
6006 at a final linked executable with addr2line or somesuch. */
6007 if (opd_sec->reloc_count == 0)
6008 {
6009 bfd_byte *contents = ppc64_elf_tdata (opd_bfd)->opd.contents;
6010
6011 if (contents == NULL)
6012 {
6013 if (!bfd_malloc_and_get_section (opd_bfd, opd_sec, &contents))
6014 return (bfd_vma) -1;
6015 ppc64_elf_tdata (opd_bfd)->opd.contents = contents;
6016 }
6017
6018 /* PR 17512: file: 64b9dfbb. */
6019 if (offset + 7 >= opd_sec->size || offset + 7 < offset)
6020 return (bfd_vma) -1;
6021
6022 val = bfd_get_64 (opd_bfd, contents + offset);
6023 if (code_sec != NULL)
6024 {
6025 asection *sec, *likely = NULL;
6026
6027 if (in_code_sec)
6028 {
6029 sec = *code_sec;
6030 if (sec->vma <= val
6031 && val < sec->vma + sec->size)
6032 likely = sec;
6033 else
6034 val = -1;
6035 }
6036 else
6037 for (sec = opd_bfd->sections; sec != NULL; sec = sec->next)
6038 if (sec->vma <= val
6039 && (sec->flags & SEC_LOAD) != 0
6040 && (sec->flags & SEC_ALLOC) != 0)
6041 likely = sec;
6042 if (likely != NULL)
6043 {
6044 *code_sec = likely;
6045 if (code_off != NULL)
6046 *code_off = val - likely->vma;
6047 }
6048 }
6049 return val;
6050 }
6051
6052 BFD_ASSERT (is_ppc64_elf (opd_bfd));
6053
6054 relocs = ppc64_elf_tdata (opd_bfd)->opd.relocs;
6055 if (relocs == NULL)
6056 relocs = _bfd_elf_link_read_relocs (opd_bfd, opd_sec, NULL, NULL, TRUE);
6057 /* PR 17512: file: df8e1fd6. */
6058 if (relocs == NULL)
6059 return (bfd_vma) -1;
6060
6061 /* Go find the opd reloc at the sym address. */
6062 lo = relocs;
6063 hi = lo + opd_sec->reloc_count - 1; /* ignore last reloc */
6064 val = (bfd_vma) -1;
6065 while (lo < hi)
6066 {
6067 look = lo + (hi - lo) / 2;
6068 if (look->r_offset < offset)
6069 lo = look + 1;
6070 else if (look->r_offset > offset)
6071 hi = look;
6072 else
6073 {
6074 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (opd_bfd);
6075
6076 if (ELF64_R_TYPE (look->r_info) == R_PPC64_ADDR64
6077 && ELF64_R_TYPE ((look + 1)->r_info) == R_PPC64_TOC)
6078 {
6079 unsigned long symndx = ELF64_R_SYM (look->r_info);
6080 asection *sec = NULL;
6081
6082 if (symndx >= symtab_hdr->sh_info
6083 && elf_sym_hashes (opd_bfd) != NULL)
6084 {
6085 struct elf_link_hash_entry **sym_hashes;
6086 struct elf_link_hash_entry *rh;
6087
6088 sym_hashes = elf_sym_hashes (opd_bfd);
6089 rh = sym_hashes[symndx - symtab_hdr->sh_info];
6090 if (rh != NULL)
6091 {
6092 rh = elf_follow_link (rh);
6093 if (rh->root.type != bfd_link_hash_defined
6094 && rh->root.type != bfd_link_hash_defweak)
6095 break;
6096 if (rh->root.u.def.section->owner == opd_bfd)
6097 {
6098 val = rh->root.u.def.value;
6099 sec = rh->root.u.def.section;
6100 }
6101 }
6102 }
6103
6104 if (sec == NULL)
6105 {
6106 Elf_Internal_Sym *sym;
6107
6108 if (symndx < symtab_hdr->sh_info)
6109 {
6110 sym = (Elf_Internal_Sym *) symtab_hdr->contents;
6111 if (sym == NULL)
6112 {
6113 size_t symcnt = symtab_hdr->sh_info;
6114 sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr,
6115 symcnt, 0,
6116 NULL, NULL, NULL);
6117 if (sym == NULL)
6118 break;
6119 symtab_hdr->contents = (bfd_byte *) sym;
6120 }
6121 sym += symndx;
6122 }
6123 else
6124 {
6125 sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr,
6126 1, symndx,
6127 NULL, NULL, NULL);
6128 if (sym == NULL)
6129 break;
6130 }
6131 sec = bfd_section_from_elf_index (opd_bfd, sym->st_shndx);
6132 if (sec == NULL)
6133 break;
6134 BFD_ASSERT ((sec->flags & SEC_MERGE) == 0);
6135 val = sym->st_value;
6136 }
6137
6138 val += look->r_addend;
6139 if (code_off != NULL)
6140 *code_off = val;
6141 if (code_sec != NULL)
6142 {
6143 if (in_code_sec && *code_sec != sec)
6144 return -1;
6145 else
6146 *code_sec = sec;
6147 }
6148 if (sec->output_section != NULL)
6149 val += sec->output_section->vma + sec->output_offset;
6150 }
6151 break;
6152 }
6153 }
6154
6155 return val;
6156 }
6157
6158 /* If the ELF symbol SYM might be a function in SEC, return the
6159 function size and set *CODE_OFF to the function's entry point,
6160 otherwise return zero. */
6161
6162 static bfd_size_type
6163 ppc64_elf_maybe_function_sym (const asymbol *sym, asection *sec,
6164 bfd_vma *code_off)
6165 {
6166 bfd_size_type size;
6167
6168 if ((sym->flags & (BSF_SECTION_SYM | BSF_FILE | BSF_OBJECT
6169 | BSF_THREAD_LOCAL | BSF_RELC | BSF_SRELC)) != 0)
6170 return 0;
6171
6172 size = 0;
6173 if (!(sym->flags & BSF_SYNTHETIC))
6174 size = ((elf_symbol_type *) sym)->internal_elf_sym.st_size;
6175
6176 if (strcmp (sym->section->name, ".opd") == 0)
6177 {
6178 struct _opd_sec_data *opd = get_opd_info (sym->section);
6179 bfd_vma symval = sym->value;
6180
6181 if (opd != NULL
6182 && opd->adjust != NULL
6183 && elf_section_data (sym->section)->relocs != NULL)
6184 {
6185 /* opd_entry_value will use cached relocs that have been
6186 adjusted, but with raw symbols. That means both local
6187 and global symbols need adjusting. */
6188 long adjust = opd->adjust[OPD_NDX (symval)];
6189 if (adjust == -1)
6190 return 0;
6191 symval += adjust;
6192 }
6193
6194 if (opd_entry_value (sym->section, symval,
6195 &sec, code_off, TRUE) == (bfd_vma) -1)
6196 return 0;
6197 /* An old ABI binary with dot-syms has a size of 24 on the .opd
6198 symbol. This size has nothing to do with the code size of the
6199 function, which is what we're supposed to return, but the
6200 code size isn't available without looking up the dot-sym.
6201 However, doing that would be a waste of time particularly
6202 since elf_find_function will look at the dot-sym anyway.
6203 Now, elf_find_function will keep the largest size of any
6204 function sym found at the code address of interest, so return
6205 1 here to avoid it incorrectly caching a larger function size
6206 for a small function. This does mean we return the wrong
6207 size for a new-ABI function of size 24, but all that does is
6208 disable caching for such functions. */
6209 if (size == 24)
6210 size = 1;
6211 }
6212 else
6213 {
6214 if (sym->section != sec)
6215 return 0;
6216 *code_off = sym->value;
6217 }
6218 if (size == 0)
6219 size = 1;
6220 return size;
6221 }
6222
6223 /* Return true if symbol is defined in a regular object file. */
6224
6225 static bfd_boolean
6226 is_static_defined (struct elf_link_hash_entry *h)
6227 {
6228 return ((h->root.type == bfd_link_hash_defined
6229 || h->root.type == bfd_link_hash_defweak)
6230 && h->root.u.def.section != NULL
6231 && h->root.u.def.section->output_section != NULL);
6232 }
6233
6234 /* If FDH is a function descriptor symbol, return the associated code
6235 entry symbol if it is defined. Return NULL otherwise. */
6236
6237 static struct ppc_link_hash_entry *
6238 defined_code_entry (struct ppc_link_hash_entry *fdh)
6239 {
6240 if (fdh->is_func_descriptor)
6241 {
6242 struct ppc_link_hash_entry *fh = ppc_follow_link (fdh->oh);
6243 if (fh->elf.root.type == bfd_link_hash_defined
6244 || fh->elf.root.type == bfd_link_hash_defweak)
6245 return fh;
6246 }
6247 return NULL;
6248 }
6249
6250 /* If FH is a function code entry symbol, return the associated
6251 function descriptor symbol if it is defined. Return NULL otherwise. */
6252
6253 static struct ppc_link_hash_entry *
6254 defined_func_desc (struct ppc_link_hash_entry *fh)
6255 {
6256 if (fh->oh != NULL
6257 && fh->oh->is_func_descriptor)
6258 {
6259 struct ppc_link_hash_entry *fdh = ppc_follow_link (fh->oh);
6260 if (fdh->elf.root.type == bfd_link_hash_defined
6261 || fdh->elf.root.type == bfd_link_hash_defweak)
6262 return fdh;
6263 }
6264 return NULL;
6265 }
6266
6267 /* Mark all our entry sym sections, both opd and code section. */
6268
6269 static void
6270 ppc64_elf_gc_keep (struct bfd_link_info *info)
6271 {
6272 struct ppc_link_hash_table *htab = ppc_hash_table (info);
6273 struct bfd_sym_chain *sym;
6274
6275 if (htab == NULL)
6276 return;
6277
6278 for (sym = info->gc_sym_list; sym != NULL; sym = sym->next)
6279 {
6280 struct ppc_link_hash_entry *eh, *fh;
6281 asection *sec;
6282
6283 eh = (struct ppc_link_hash_entry *)
6284 elf_link_hash_lookup (&htab->elf, sym->name, FALSE, FALSE, TRUE);
6285 if (eh == NULL)
6286 continue;
6287 if (eh->elf.root.type != bfd_link_hash_defined
6288 && eh->elf.root.type != bfd_link_hash_defweak)
6289 continue;
6290
6291 fh = defined_code_entry (eh);
6292 if (fh != NULL)
6293 {
6294 sec = fh->elf.root.u.def.section;
6295 sec->flags |= SEC_KEEP;
6296 }
6297 else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6298 && opd_entry_value (eh->elf.root.u.def.section,
6299 eh->elf.root.u.def.value,
6300 &sec, NULL, FALSE) != (bfd_vma) -1)
6301 sec->flags |= SEC_KEEP;
6302
6303 sec = eh->elf.root.u.def.section;
6304 sec->flags |= SEC_KEEP;
6305 }
6306 }
6307
6308 /* Mark sections containing dynamically referenced symbols. When
6309 building shared libraries, we must assume that any visible symbol is
6310 referenced. */
6311
6312 static bfd_boolean
6313 ppc64_elf_gc_mark_dynamic_ref (struct elf_link_hash_entry *h, void *inf)
6314 {
6315 struct bfd_link_info *info = (struct bfd_link_info *) inf;
6316 struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
6317 struct ppc_link_hash_entry *fdh;
6318 struct bfd_elf_dynamic_list *d = info->dynamic_list;
6319
6320 /* Dynamic linking info is on the func descriptor sym. */
6321 fdh = defined_func_desc (eh);
6322 if (fdh != NULL)
6323 eh = fdh;
6324
6325 if ((eh->elf.root.type == bfd_link_hash_defined
6326 || eh->elf.root.type == bfd_link_hash_defweak)
6327 && (eh->elf.ref_dynamic
6328 || ((eh->elf.def_regular || ELF_COMMON_DEF_P (&eh->elf))
6329 && ELF_ST_VISIBILITY (eh->elf.other) != STV_INTERNAL
6330 && ELF_ST_VISIBILITY (eh->elf.other) != STV_HIDDEN
6331 && (!bfd_link_executable (info)
6332 || info->export_dynamic
6333 || (eh->elf.dynamic
6334 && d != NULL
6335 && (*d->match) (&d->head, NULL, eh->elf.root.root.string)))
6336 && (strchr (eh->elf.root.root.string, ELF_VER_CHR) != NULL
6337 || !bfd_hide_sym_by_version (info->version_info,
6338 eh->elf.root.root.string)))))
6339 {
6340 asection *code_sec;
6341 struct ppc_link_hash_entry *fh;
6342
6343 eh->elf.root.u.def.section->flags |= SEC_KEEP;
6344
6345 /* Function descriptor syms cause the associated
6346 function code sym section to be marked. */
6347 fh = defined_code_entry (eh);
6348 if (fh != NULL)
6349 {
6350 code_sec = fh->elf.root.u.def.section;
6351 code_sec->flags |= SEC_KEEP;
6352 }
6353 else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6354 && opd_entry_value (eh->elf.root.u.def.section,
6355 eh->elf.root.u.def.value,
6356 &code_sec, NULL, FALSE) != (bfd_vma) -1)
6357 code_sec->flags |= SEC_KEEP;
6358 }
6359
6360 return TRUE;
6361 }
6362
6363 /* Return the section that should be marked against GC for a given
6364 relocation. */
6365
6366 static asection *
6367 ppc64_elf_gc_mark_hook (asection *sec,
6368 struct bfd_link_info *info,
6369 Elf_Internal_Rela *rel,
6370 struct elf_link_hash_entry *h,
6371 Elf_Internal_Sym *sym)
6372 {
6373 asection *rsec;
6374
6375 /* Syms return NULL if we're marking .opd, so we avoid marking all
6376 function sections, as all functions are referenced in .opd. */
6377 rsec = NULL;
6378 if (get_opd_info (sec) != NULL)
6379 return rsec;
6380
6381 if (h != NULL)
6382 {
6383 enum elf_ppc64_reloc_type r_type;
6384 struct ppc_link_hash_entry *eh, *fh, *fdh;
6385
6386 r_type = ELF64_R_TYPE (rel->r_info);
6387 switch (r_type)
6388 {
6389 case R_PPC64_GNU_VTINHERIT:
6390 case R_PPC64_GNU_VTENTRY:
6391 break;
6392
6393 default:
6394 switch (h->root.type)
6395 {
6396 case bfd_link_hash_defined:
6397 case bfd_link_hash_defweak:
6398 eh = (struct ppc_link_hash_entry *) h;
6399 fdh = defined_func_desc (eh);
6400 if (fdh != NULL)
6401 eh = fdh;
6402
6403 /* Function descriptor syms cause the associated
6404 function code sym section to be marked. */
6405 fh = defined_code_entry (eh);
6406 if (fh != NULL)
6407 {
6408 /* They also mark their opd section. */
6409 eh->elf.root.u.def.section->gc_mark = 1;
6410
6411 rsec = fh->elf.root.u.def.section;
6412 }
6413 else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6414 && opd_entry_value (eh->elf.root.u.def.section,
6415 eh->elf.root.u.def.value,
6416 &rsec, NULL, FALSE) != (bfd_vma) -1)
6417 eh->elf.root.u.def.section->gc_mark = 1;
6418 else
6419 rsec = h->root.u.def.section;
6420 break;
6421
6422 case bfd_link_hash_common:
6423 rsec = h->root.u.c.p->section;
6424 break;
6425
6426 default:
6427 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
6428 }
6429 }
6430 }
6431 else
6432 {
6433 struct _opd_sec_data *opd;
6434
6435 rsec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
6436 opd = get_opd_info (rsec);
6437 if (opd != NULL && opd->func_sec != NULL)
6438 {
6439 rsec->gc_mark = 1;
6440
6441 rsec = opd->func_sec[OPD_NDX (sym->st_value + rel->r_addend)];
6442 }
6443 }
6444
6445 return rsec;
6446 }
6447
6448 /* Update the .got, .plt. and dynamic reloc reference counts for the
6449 section being removed. */
6450
6451 static bfd_boolean
6452 ppc64_elf_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info,
6453 asection *sec, const Elf_Internal_Rela *relocs)
6454 {
6455 struct ppc_link_hash_table *htab;
6456 Elf_Internal_Shdr *symtab_hdr;
6457 struct elf_link_hash_entry **sym_hashes;
6458 struct got_entry **local_got_ents;
6459 const Elf_Internal_Rela *rel, *relend;
6460
6461 if (bfd_link_relocatable (info))
6462 return TRUE;
6463
6464 if ((sec->flags & SEC_ALLOC) == 0)
6465 return TRUE;
6466
6467 elf_section_data (sec)->local_dynrel = NULL;
6468
6469 htab = ppc_hash_table (info);
6470 if (htab == NULL)
6471 return FALSE;
6472
6473 symtab_hdr = &elf_symtab_hdr (abfd);
6474 sym_hashes = elf_sym_hashes (abfd);
6475 local_got_ents = elf_local_got_ents (abfd);
6476
6477 relend = relocs + sec->reloc_count;
6478 for (rel = relocs; rel < relend; rel++)
6479 {
6480 unsigned long r_symndx;
6481 enum elf_ppc64_reloc_type r_type;
6482 struct elf_link_hash_entry *h = NULL;
6483 unsigned char tls_type = 0;
6484
6485 r_symndx = ELF64_R_SYM (rel->r_info);
6486 r_type = ELF64_R_TYPE (rel->r_info);
6487 if (r_symndx >= symtab_hdr->sh_info)
6488 {
6489 struct ppc_link_hash_entry *eh;
6490 struct elf_dyn_relocs **pp;
6491 struct elf_dyn_relocs *p;
6492
6493 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
6494 h = elf_follow_link (h);
6495 eh = (struct ppc_link_hash_entry *) h;
6496
6497 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
6498 if (p->sec == sec)
6499 {
6500 /* Everything must go for SEC. */
6501 *pp = p->next;
6502 break;
6503 }
6504 }
6505
6506 if (is_branch_reloc (r_type))
6507 {
6508 struct plt_entry **ifunc = NULL;
6509 if (h != NULL)
6510 {
6511 if (h->type == STT_GNU_IFUNC)
6512 ifunc = &h->plt.plist;
6513 }
6514 else if (local_got_ents != NULL)
6515 {
6516 struct plt_entry **local_plt = (struct plt_entry **)
6517 (local_got_ents + symtab_hdr->sh_info);
6518 unsigned char *local_got_tls_masks = (unsigned char *)
6519 (local_plt + symtab_hdr->sh_info);
6520 if ((local_got_tls_masks[r_symndx] & PLT_IFUNC) != 0)
6521 ifunc = local_plt + r_symndx;
6522 }
6523 if (ifunc != NULL)
6524 {
6525 struct plt_entry *ent;
6526
6527 for (ent = *ifunc; ent != NULL; ent = ent->next)
6528 if (ent->addend == rel->r_addend)
6529 break;
6530 if (ent == NULL)
6531 abort ();
6532 if (ent->plt.refcount > 0)
6533 ent->plt.refcount -= 1;
6534 continue;
6535 }
6536 }
6537
6538 switch (r_type)
6539 {
6540 case R_PPC64_GOT_TLSLD16:
6541 case R_PPC64_GOT_TLSLD16_LO:
6542 case R_PPC64_GOT_TLSLD16_HI:
6543 case R_PPC64_GOT_TLSLD16_HA:
6544 tls_type = TLS_TLS | TLS_LD;
6545 goto dogot;
6546
6547 case R_PPC64_GOT_TLSGD16:
6548 case R_PPC64_GOT_TLSGD16_LO:
6549 case R_PPC64_GOT_TLSGD16_HI:
6550 case R_PPC64_GOT_TLSGD16_HA:
6551 tls_type = TLS_TLS | TLS_GD;
6552 goto dogot;
6553
6554 case R_PPC64_GOT_TPREL16_DS:
6555 case R_PPC64_GOT_TPREL16_LO_DS:
6556 case R_PPC64_GOT_TPREL16_HI:
6557 case R_PPC64_GOT_TPREL16_HA:
6558 tls_type = TLS_TLS | TLS_TPREL;
6559 goto dogot;
6560
6561 case R_PPC64_GOT_DTPREL16_DS:
6562 case R_PPC64_GOT_DTPREL16_LO_DS:
6563 case R_PPC64_GOT_DTPREL16_HI:
6564 case R_PPC64_GOT_DTPREL16_HA:
6565 tls_type = TLS_TLS | TLS_DTPREL;
6566 goto dogot;
6567
6568 case R_PPC64_GOT16:
6569 case R_PPC64_GOT16_DS:
6570 case R_PPC64_GOT16_HA:
6571 case R_PPC64_GOT16_HI:
6572 case R_PPC64_GOT16_LO:
6573 case R_PPC64_GOT16_LO_DS:
6574 dogot:
6575 {
6576 struct got_entry *ent;
6577
6578 if (h != NULL)
6579 ent = h->got.glist;
6580 else
6581 ent = local_got_ents[r_symndx];
6582
6583 for (; ent != NULL; ent = ent->next)
6584 if (ent->addend == rel->r_addend
6585 && ent->owner == abfd
6586 && ent->tls_type == tls_type)
6587 break;
6588 if (ent == NULL)
6589 abort ();
6590 if (ent->got.refcount > 0)
6591 ent->got.refcount -= 1;
6592 }
6593 break;
6594
6595 case R_PPC64_PLT16_HA:
6596 case R_PPC64_PLT16_HI:
6597 case R_PPC64_PLT16_LO:
6598 case R_PPC64_PLT32:
6599 case R_PPC64_PLT64:
6600 case R_PPC64_REL14:
6601 case R_PPC64_REL14_BRNTAKEN:
6602 case R_PPC64_REL14_BRTAKEN:
6603 case R_PPC64_REL24:
6604 if (h != NULL)
6605 {
6606 struct plt_entry *ent;
6607
6608 for (ent = h->plt.plist; ent != NULL; ent = ent->next)
6609 if (ent->addend == rel->r_addend)
6610 break;
6611 if (ent != NULL && ent->plt.refcount > 0)
6612 ent->plt.refcount -= 1;
6613 }
6614 break;
6615
6616 default:
6617 break;
6618 }
6619 }
6620 return TRUE;
6621 }
6622
6623 /* The maximum size of .sfpr. */
6624 #define SFPR_MAX (218*4)
6625
6626 struct sfpr_def_parms
6627 {
6628 const char name[12];
6629 unsigned char lo, hi;
6630 bfd_byte * (*write_ent) (bfd *, bfd_byte *, int);
6631 bfd_byte * (*write_tail) (bfd *, bfd_byte *, int);
6632 };
6633
6634 /* Auto-generate _save*, _rest* functions in .sfpr.
6635 If STUB_SEC is non-null, define alias symbols in STUB_SEC
6636 instead. */
6637
6638 static bfd_boolean
6639 sfpr_define (struct bfd_link_info *info,
6640 const struct sfpr_def_parms *parm,
6641 asection *stub_sec)
6642 {
6643 struct ppc_link_hash_table *htab = ppc_hash_table (info);
6644 unsigned int i;
6645 size_t len = strlen (parm->name);
6646 bfd_boolean writing = FALSE;
6647 char sym[16];
6648
6649 if (htab == NULL)
6650 return FALSE;
6651
6652 memcpy (sym, parm->name, len);
6653 sym[len + 2] = 0;
6654
6655 for (i = parm->lo; i <= parm->hi; i++)
6656 {
6657 struct ppc_link_hash_entry *h;
6658
6659 sym[len + 0] = i / 10 + '0';
6660 sym[len + 1] = i % 10 + '0';
6661 h = (struct ppc_link_hash_entry *)
6662 elf_link_hash_lookup (&htab->elf, sym, FALSE, FALSE, TRUE);
6663 if (stub_sec != NULL)
6664 {
6665 if (h != NULL
6666 && h->elf.root.type == bfd_link_hash_defined
6667 && h->elf.root.u.def.section == htab->sfpr)
6668 {
6669 struct elf_link_hash_entry *s;
6670 char buf[32];
6671 sprintf (buf, "%08x.%s", stub_sec->id & 0xffffffff, sym);
6672 s = elf_link_hash_lookup (&htab->elf, buf, TRUE, TRUE, FALSE);
6673 if (s == NULL)
6674 return FALSE;
6675 if (s->root.type == bfd_link_hash_new
6676 || (s->root.type = bfd_link_hash_defined
6677 && s->root.u.def.section == stub_sec))
6678 {
6679 s->root.type = bfd_link_hash_defined;
6680 s->root.u.def.section = stub_sec;
6681 s->root.u.def.value = (stub_sec->size
6682 + h->elf.root.u.def.value);
6683 s->ref_regular = 1;
6684 s->def_regular = 1;
6685 s->ref_regular_nonweak = 1;
6686 s->forced_local = 1;
6687 s->non_elf = 0;
6688 s->root.linker_def = 1;
6689 }
6690 }
6691 continue;
6692 }
6693 if (h != NULL)
6694 {
6695 h->save_res = 1;
6696 if (!h->elf.def_regular)
6697 {
6698 h->elf.root.type = bfd_link_hash_defined;
6699 h->elf.root.u.def.section = htab->sfpr;
6700 h->elf.root.u.def.value = htab->sfpr->size;
6701 h->elf.type = STT_FUNC;
6702 h->elf.def_regular = 1;
6703 _bfd_elf_link_hash_hide_symbol (info, &h->elf, TRUE);
6704 writing = TRUE;
6705 if (htab->sfpr->contents == NULL)
6706 {
6707 htab->sfpr->contents = bfd_alloc (htab->elf.dynobj, SFPR_MAX);
6708 if (htab->sfpr->contents == NULL)
6709 return FALSE;
6710 }
6711 }
6712 }
6713 if (writing)
6714 {
6715 bfd_byte *p = htab->sfpr->contents + htab->sfpr->size;
6716 if (i != parm->hi)
6717 p = (*parm->write_ent) (htab->elf.dynobj, p, i);
6718 else
6719 p = (*parm->write_tail) (htab->elf.dynobj, p, i);
6720 htab->sfpr->size = p - htab->sfpr->contents;
6721 }
6722 }
6723
6724 return TRUE;
6725 }
6726
6727 static bfd_byte *
6728 savegpr0 (bfd *abfd, bfd_byte *p, int r)
6729 {
6730 bfd_put_32 (abfd, STD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6731 return p + 4;
6732 }
6733
6734 static bfd_byte *
6735 savegpr0_tail (bfd *abfd, bfd_byte *p, int r)
6736 {
6737 p = savegpr0 (abfd, p, r);
6738 bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
6739 p = p + 4;
6740 bfd_put_32 (abfd, BLR, p);
6741 return p + 4;
6742 }
6743
6744 static bfd_byte *
6745 restgpr0 (bfd *abfd, bfd_byte *p, int r)
6746 {
6747 bfd_put_32 (abfd, LD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6748 return p + 4;
6749 }
6750
6751 static bfd_byte *
6752 restgpr0_tail (bfd *abfd, bfd_byte *p, int r)
6753 {
6754 bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
6755 p = p + 4;
6756 p = restgpr0 (abfd, p, r);
6757 bfd_put_32 (abfd, MTLR_R0, p);
6758 p = p + 4;
6759 if (r == 29)
6760 {
6761 p = restgpr0 (abfd, p, 30);
6762 p = restgpr0 (abfd, p, 31);
6763 }
6764 bfd_put_32 (abfd, BLR, p);
6765 return p + 4;
6766 }
6767
6768 static bfd_byte *
6769 savegpr1 (bfd *abfd, bfd_byte *p, int r)
6770 {
6771 bfd_put_32 (abfd, STD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6772 return p + 4;
6773 }
6774
6775 static bfd_byte *
6776 savegpr1_tail (bfd *abfd, bfd_byte *p, int r)
6777 {
6778 p = savegpr1 (abfd, p, r);
6779 bfd_put_32 (abfd, BLR, p);
6780 return p + 4;
6781 }
6782
6783 static bfd_byte *
6784 restgpr1 (bfd *abfd, bfd_byte *p, int r)
6785 {
6786 bfd_put_32 (abfd, LD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6787 return p + 4;
6788 }
6789
6790 static bfd_byte *
6791 restgpr1_tail (bfd *abfd, bfd_byte *p, int r)
6792 {
6793 p = restgpr1 (abfd, p, r);
6794 bfd_put_32 (abfd, BLR, p);
6795 return p + 4;
6796 }
6797
6798 static bfd_byte *
6799 savefpr (bfd *abfd, bfd_byte *p, int r)
6800 {
6801 bfd_put_32 (abfd, STFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6802 return p + 4;
6803 }
6804
6805 static bfd_byte *
6806 savefpr0_tail (bfd *abfd, bfd_byte *p, int r)
6807 {
6808 p = savefpr (abfd, p, r);
6809 bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
6810 p = p + 4;
6811 bfd_put_32 (abfd, BLR, p);
6812 return p + 4;
6813 }
6814
6815 static bfd_byte *
6816 restfpr (bfd *abfd, bfd_byte *p, int r)
6817 {
6818 bfd_put_32 (abfd, LFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6819 return p + 4;
6820 }
6821
6822 static bfd_byte *
6823 restfpr0_tail (bfd *abfd, bfd_byte *p, int r)
6824 {
6825 bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
6826 p = p + 4;
6827 p = restfpr (abfd, p, r);
6828 bfd_put_32 (abfd, MTLR_R0, p);
6829 p = p + 4;
6830 if (r == 29)
6831 {
6832 p = restfpr (abfd, p, 30);
6833 p = restfpr (abfd, p, 31);
6834 }
6835 bfd_put_32 (abfd, BLR, p);
6836 return p + 4;
6837 }
6838
6839 static bfd_byte *
6840 savefpr1_tail (bfd *abfd, bfd_byte *p, int r)
6841 {
6842 p = savefpr (abfd, p, r);
6843 bfd_put_32 (abfd, BLR, p);
6844 return p + 4;
6845 }
6846
6847 static bfd_byte *
6848 restfpr1_tail (bfd *abfd, bfd_byte *p, int r)
6849 {
6850 p = restfpr (abfd, p, r);
6851 bfd_put_32 (abfd, BLR, p);
6852 return p + 4;
6853 }
6854
6855 static bfd_byte *
6856 savevr (bfd *abfd, bfd_byte *p, int r)
6857 {
6858 bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6859 p = p + 4;
6860 bfd_put_32 (abfd, STVX_VR0_R12_R0 + (r << 21), p);
6861 return p + 4;
6862 }
6863
6864 static bfd_byte *
6865 savevr_tail (bfd *abfd, bfd_byte *p, int r)
6866 {
6867 p = savevr (abfd, p, r);
6868 bfd_put_32 (abfd, BLR, p);
6869 return p + 4;
6870 }
6871
6872 static bfd_byte *
6873 restvr (bfd *abfd, bfd_byte *p, int r)
6874 {
6875 bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6876 p = p + 4;
6877 bfd_put_32 (abfd, LVX_VR0_R12_R0 + (r << 21), p);
6878 return p + 4;
6879 }
6880
6881 static bfd_byte *
6882 restvr_tail (bfd *abfd, bfd_byte *p, int r)
6883 {
6884 p = restvr (abfd, p, r);
6885 bfd_put_32 (abfd, BLR, p);
6886 return p + 4;
6887 }
6888
6889 /* Called via elf_link_hash_traverse to transfer dynamic linking
6890 information on function code symbol entries to their corresponding
6891 function descriptor symbol entries. */
6892
6893 static bfd_boolean
6894 func_desc_adjust (struct elf_link_hash_entry *h, void *inf)
6895 {
6896 struct bfd_link_info *info;
6897 struct ppc_link_hash_table *htab;
6898 struct plt_entry *ent;
6899 struct ppc_link_hash_entry *fh;
6900 struct ppc_link_hash_entry *fdh;
6901 bfd_boolean force_local;
6902
6903 fh = (struct ppc_link_hash_entry *) h;
6904 if (fh->elf.root.type == bfd_link_hash_indirect)
6905 return TRUE;
6906
6907 info = inf;
6908 htab = ppc_hash_table (info);
6909 if (htab == NULL)
6910 return FALSE;
6911
6912 /* Resolve undefined references to dot-symbols as the value
6913 in the function descriptor, if we have one in a regular object.
6914 This is to satisfy cases like ".quad .foo". Calls to functions
6915 in dynamic objects are handled elsewhere. */
6916 if (fh->elf.root.type == bfd_link_hash_undefweak
6917 && fh->was_undefined
6918 && (fdh = defined_func_desc (fh)) != NULL
6919 && get_opd_info (fdh->elf.root.u.def.section) != NULL
6920 && opd_entry_value (fdh->elf.root.u.def.section,
6921 fdh->elf.root.u.def.value,
6922 &fh->elf.root.u.def.section,
6923 &fh->elf.root.u.def.value, FALSE) != (bfd_vma) -1)
6924 {
6925 fh->elf.root.type = fdh->elf.root.type;
6926 fh->elf.forced_local = 1;
6927 fh->elf.def_regular = fdh->elf.def_regular;
6928 fh->elf.def_dynamic = fdh->elf.def_dynamic;
6929 }
6930
6931 /* If this is a function code symbol, transfer dynamic linking
6932 information to the function descriptor symbol. */
6933 if (!fh->is_func)
6934 return TRUE;
6935
6936 for (ent = fh->elf.plt.plist; ent != NULL; ent = ent->next)
6937 if (ent->plt.refcount > 0)
6938 break;
6939 if (ent == NULL
6940 || fh->elf.root.root.string[0] != '.'
6941 || fh->elf.root.root.string[1] == '\0')
6942 return TRUE;
6943
6944 /* Find the corresponding function descriptor symbol. Create it
6945 as undefined if necessary. */
6946
6947 fdh = lookup_fdh (fh, htab);
6948 if (fdh == NULL
6949 && !bfd_link_executable (info)
6950 && (fh->elf.root.type == bfd_link_hash_undefined
6951 || fh->elf.root.type == bfd_link_hash_undefweak))
6952 {
6953 fdh = make_fdh (info, fh);
6954 if (fdh == NULL)
6955 return FALSE;
6956 }
6957
6958 /* Fake function descriptors are made undefweak. If the function
6959 code symbol is strong undefined, make the fake sym the same.
6960 If the function code symbol is defined, then force the fake
6961 descriptor local; We can't support overriding of symbols in a
6962 shared library on a fake descriptor. */
6963
6964 if (fdh != NULL
6965 && fdh->fake
6966 && fdh->elf.root.type == bfd_link_hash_undefweak)
6967 {
6968 if (fh->elf.root.type == bfd_link_hash_undefined)
6969 {
6970 fdh->elf.root.type = bfd_link_hash_undefined;
6971 bfd_link_add_undef (&htab->elf.root, &fdh->elf.root);
6972 }
6973 else if (fh->elf.root.type == bfd_link_hash_defined
6974 || fh->elf.root.type == bfd_link_hash_defweak)
6975 {
6976 _bfd_elf_link_hash_hide_symbol (info, &fdh->elf, TRUE);
6977 }
6978 }
6979
6980 if (fdh != NULL
6981 && !fdh->elf.forced_local
6982 && (!bfd_link_executable (info)
6983 || fdh->elf.def_dynamic
6984 || fdh->elf.ref_dynamic
6985 || (fdh->elf.root.type == bfd_link_hash_undefweak
6986 && ELF_ST_VISIBILITY (fdh->elf.other) == STV_DEFAULT)))
6987 {
6988 if (fdh->elf.dynindx == -1)
6989 if (! bfd_elf_link_record_dynamic_symbol (info, &fdh->elf))
6990 return FALSE;
6991 fdh->elf.ref_regular |= fh->elf.ref_regular;
6992 fdh->elf.ref_dynamic |= fh->elf.ref_dynamic;
6993 fdh->elf.ref_regular_nonweak |= fh->elf.ref_regular_nonweak;
6994 fdh->elf.non_got_ref |= fh->elf.non_got_ref;
6995 if (ELF_ST_VISIBILITY (fh->elf.other) == STV_DEFAULT)
6996 {
6997 move_plt_plist (fh, fdh);
6998 fdh->elf.needs_plt = 1;
6999 }
7000 fdh->is_func_descriptor = 1;
7001 fdh->oh = fh;
7002 fh->oh = fdh;
7003 }
7004
7005 /* Now that the info is on the function descriptor, clear the
7006 function code sym info. Any function code syms for which we
7007 don't have a definition in a regular file, we force local.
7008 This prevents a shared library from exporting syms that have
7009 been imported from another library. Function code syms that
7010 are really in the library we must leave global to prevent the
7011 linker dragging in a definition from a static library. */
7012 force_local = (!fh->elf.def_regular
7013 || fdh == NULL
7014 || !fdh->elf.def_regular
7015 || fdh->elf.forced_local);
7016 _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
7017
7018 return TRUE;
7019 }
7020
7021 static const struct sfpr_def_parms save_res_funcs[] =
7022 {
7023 { "_savegpr0_", 14, 31, savegpr0, savegpr0_tail },
7024 { "_restgpr0_", 14, 29, restgpr0, restgpr0_tail },
7025 { "_restgpr0_", 30, 31, restgpr0, restgpr0_tail },
7026 { "_savegpr1_", 14, 31, savegpr1, savegpr1_tail },
7027 { "_restgpr1_", 14, 31, restgpr1, restgpr1_tail },
7028 { "_savefpr_", 14, 31, savefpr, savefpr0_tail },
7029 { "_restfpr_", 14, 29, restfpr, restfpr0_tail },
7030 { "_restfpr_", 30, 31, restfpr, restfpr0_tail },
7031 { "._savef", 14, 31, savefpr, savefpr1_tail },
7032 { "._restf", 14, 31, restfpr, restfpr1_tail },
7033 { "_savevr_", 20, 31, savevr, savevr_tail },
7034 { "_restvr_", 20, 31, restvr, restvr_tail }
7035 };
7036
7037 /* Called near the start of bfd_elf_size_dynamic_sections. We use
7038 this hook to a) provide some gcc support functions, and b) transfer
7039 dynamic linking information gathered so far on function code symbol
7040 entries, to their corresponding function descriptor symbol entries. */
7041
7042 static bfd_boolean
7043 ppc64_elf_func_desc_adjust (bfd *obfd ATTRIBUTE_UNUSED,
7044 struct bfd_link_info *info)
7045 {
7046 struct ppc_link_hash_table *htab;
7047 unsigned int i;
7048
7049 htab = ppc_hash_table (info);
7050 if (htab == NULL)
7051 return FALSE;
7052
7053 if (!bfd_link_relocatable (info)
7054 && htab->elf.hgot != NULL)
7055 {
7056 _bfd_elf_link_hash_hide_symbol (info, htab->elf.hgot, TRUE);
7057 /* Make .TOC. defined so as to prevent it being made dynamic.
7058 The wrong value here is fixed later in ppc64_elf_set_toc. */
7059 if (!htab->elf.hgot->def_regular
7060 || htab->elf.hgot->root.type != bfd_link_hash_defined)
7061 {
7062 htab->elf.hgot->root.type = bfd_link_hash_defined;
7063 htab->elf.hgot->root.u.def.value = 0;
7064 htab->elf.hgot->root.u.def.section = bfd_abs_section_ptr;
7065 htab->elf.hgot->def_regular = 1;
7066 htab->elf.hgot->root.linker_def = 1;
7067 }
7068 htab->elf.hgot->type = STT_OBJECT;
7069 htab->elf.hgot->other = ((htab->elf.hgot->other & ~ELF_ST_VISIBILITY (-1))
7070 | STV_HIDDEN);
7071 }
7072
7073 if (htab->sfpr == NULL)
7074 /* We don't have any relocs. */
7075 return TRUE;
7076
7077 /* Provide any missing _save* and _rest* functions. */
7078 htab->sfpr->size = 0;
7079 if (htab->params->save_restore_funcs)
7080 for (i = 0; i < ARRAY_SIZE (save_res_funcs); i++)
7081 if (!sfpr_define (info, &save_res_funcs[i], NULL))
7082 return FALSE;
7083
7084 elf_link_hash_traverse (&htab->elf, func_desc_adjust, info);
7085
7086 if (htab->sfpr->size == 0)
7087 htab->sfpr->flags |= SEC_EXCLUDE;
7088
7089 return TRUE;
7090 }
7091
7092 /* Return true if we have dynamic relocs that apply to read-only sections. */
7093
7094 static bfd_boolean
7095 readonly_dynrelocs (struct elf_link_hash_entry *h)
7096 {
7097 struct ppc_link_hash_entry *eh;
7098 struct elf_dyn_relocs *p;
7099
7100 eh = (struct ppc_link_hash_entry *) h;
7101 for (p = eh->dyn_relocs; p != NULL; p = p->next)
7102 {
7103 asection *s = p->sec->output_section;
7104
7105 if (s != NULL && (s->flags & SEC_READONLY) != 0)
7106 return TRUE;
7107 }
7108 return FALSE;
7109 }
7110
7111 /* Adjust a symbol defined by a dynamic object and referenced by a
7112 regular object. The current definition is in some section of the
7113 dynamic object, but we're not including those sections. We have to
7114 change the definition to something the rest of the link can
7115 understand. */
7116
7117 static bfd_boolean
7118 ppc64_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
7119 struct elf_link_hash_entry *h)
7120 {
7121 struct ppc_link_hash_table *htab;
7122 asection *s;
7123
7124 htab = ppc_hash_table (info);
7125 if (htab == NULL)
7126 return FALSE;
7127
7128 /* Deal with function syms. */
7129 if (h->type == STT_FUNC
7130 || h->type == STT_GNU_IFUNC
7131 || h->needs_plt)
7132 {
7133 /* Clear procedure linkage table information for any symbol that
7134 won't need a .plt entry. */
7135 struct plt_entry *ent;
7136 for (ent = h->plt.plist; ent != NULL; ent = ent->next)
7137 if (ent->plt.refcount > 0)
7138 break;
7139 if (ent == NULL
7140 || (h->type != STT_GNU_IFUNC
7141 && (SYMBOL_CALLS_LOCAL (info, h)
7142 || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
7143 && h->root.type == bfd_link_hash_undefweak)))
7144 || ((struct ppc_link_hash_entry *) h)->save_res)
7145 {
7146 h->plt.plist = NULL;
7147 h->needs_plt = 0;
7148 h->pointer_equality_needed = 0;
7149 }
7150 else if (abiversion (info->output_bfd) == 2)
7151 {
7152 /* Taking a function's address in a read/write section
7153 doesn't require us to define the function symbol in the
7154 executable on a global entry stub. A dynamic reloc can
7155 be used instead. */
7156 if (h->pointer_equality_needed
7157 && h->type != STT_GNU_IFUNC
7158 && !readonly_dynrelocs (h))
7159 {
7160 h->pointer_equality_needed = 0;
7161 h->non_got_ref = 0;
7162 }
7163
7164 /* After adjust_dynamic_symbol, non_got_ref set in the
7165 non-shared case means that we have allocated space in
7166 .dynbss for the symbol and thus dyn_relocs for this
7167 symbol should be discarded.
7168 If we get here we know we are making a PLT entry for this
7169 symbol, and in an executable we'd normally resolve
7170 relocations against this symbol to the PLT entry. Allow
7171 dynamic relocs if the reference is weak, and the dynamic
7172 relocs will not cause text relocation. */
7173 else if (!h->ref_regular_nonweak
7174 && h->non_got_ref
7175 && h->type != STT_GNU_IFUNC
7176 && !readonly_dynrelocs (h))
7177 h->non_got_ref = 0;
7178
7179 /* If making a plt entry, then we don't need copy relocs. */
7180 return TRUE;
7181 }
7182 }
7183 else
7184 h->plt.plist = NULL;
7185
7186 /* If this is a weak symbol, and there is a real definition, the
7187 processor independent code will have arranged for us to see the
7188 real definition first, and we can just use the same value. */
7189 if (h->u.weakdef != NULL)
7190 {
7191 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
7192 || h->u.weakdef->root.type == bfd_link_hash_defweak);
7193 h->root.u.def.section = h->u.weakdef->root.u.def.section;
7194 h->root.u.def.value = h->u.weakdef->root.u.def.value;
7195 if (ELIMINATE_COPY_RELOCS)
7196 h->non_got_ref = h->u.weakdef->non_got_ref;
7197 return TRUE;
7198 }
7199
7200 /* If we are creating a shared library, we must presume that the
7201 only references to the symbol are via the global offset table.
7202 For such cases we need not do anything here; the relocations will
7203 be handled correctly by relocate_section. */
7204 if (bfd_link_pic (info))
7205 return TRUE;
7206
7207 /* If there are no references to this symbol that do not use the
7208 GOT, we don't need to generate a copy reloc. */
7209 if (!h->non_got_ref)
7210 return TRUE;
7211
7212 /* Don't generate a copy reloc for symbols defined in the executable. */
7213 if (!h->def_dynamic || !h->ref_regular || h->def_regular)
7214 return TRUE;
7215
7216 /* If -z nocopyreloc was given, don't generate them either. */
7217 if (info->nocopyreloc)
7218 {
7219 h->non_got_ref = 0;
7220 return TRUE;
7221 }
7222
7223 /* If we didn't find any dynamic relocs in read-only sections, then
7224 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
7225 if (ELIMINATE_COPY_RELOCS && !readonly_dynrelocs (h))
7226 {
7227 h->non_got_ref = 0;
7228 return TRUE;
7229 }
7230
7231 /* Protected variables do not work with .dynbss. The copy in
7232 .dynbss won't be used by the shared library with the protected
7233 definition for the variable. Text relocations are preferable
7234 to an incorrect program. */
7235 if (h->protected_def)
7236 {
7237 h->non_got_ref = 0;
7238 return TRUE;
7239 }
7240
7241 if (h->plt.plist != NULL)
7242 {
7243 /* We should never get here, but unfortunately there are versions
7244 of gcc out there that improperly (for this ABI) put initialized
7245 function pointers, vtable refs and suchlike in read-only
7246 sections. Allow them to proceed, but warn that this might
7247 break at runtime. */
7248 info->callbacks->einfo
7249 (_("%P: copy reloc against `%T' requires lazy plt linking; "
7250 "avoid setting LD_BIND_NOW=1 or upgrade gcc\n"),
7251 h->root.root.string);
7252 }
7253
7254 /* This is a reference to a symbol defined by a dynamic object which
7255 is not a function. */
7256
7257 /* We must allocate the symbol in our .dynbss section, which will
7258 become part of the .bss section of the executable. There will be
7259 an entry for this symbol in the .dynsym section. The dynamic
7260 object will contain position independent code, so all references
7261 from the dynamic object to this symbol will go through the global
7262 offset table. The dynamic linker will use the .dynsym entry to
7263 determine the address it must put in the global offset table, so
7264 both the dynamic object and the regular object will refer to the
7265 same memory location for the variable. */
7266
7267 /* We must generate a R_PPC64_COPY reloc to tell the dynamic linker
7268 to copy the initial value out of the dynamic object and into the
7269 runtime process image. We need to remember the offset into the
7270 .rela.bss section we are going to use. */
7271 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
7272 {
7273 htab->relbss->size += sizeof (Elf64_External_Rela);
7274 h->needs_copy = 1;
7275 }
7276
7277 s = htab->dynbss;
7278
7279 return _bfd_elf_adjust_dynamic_copy (info, h, s);
7280 }
7281
7282 /* If given a function descriptor symbol, hide both the function code
7283 sym and the descriptor. */
7284 static void
7285 ppc64_elf_hide_symbol (struct bfd_link_info *info,
7286 struct elf_link_hash_entry *h,
7287 bfd_boolean force_local)
7288 {
7289 struct ppc_link_hash_entry *eh;
7290 _bfd_elf_link_hash_hide_symbol (info, h, force_local);
7291
7292 eh = (struct ppc_link_hash_entry *) h;
7293 if (eh->is_func_descriptor)
7294 {
7295 struct ppc_link_hash_entry *fh = eh->oh;
7296
7297 if (fh == NULL)
7298 {
7299 const char *p, *q;
7300 struct ppc_link_hash_table *htab;
7301 char save;
7302
7303 /* We aren't supposed to use alloca in BFD because on
7304 systems which do not have alloca the version in libiberty
7305 calls xmalloc, which might cause the program to crash
7306 when it runs out of memory. This function doesn't have a
7307 return status, so there's no way to gracefully return an
7308 error. So cheat. We know that string[-1] can be safely
7309 accessed; It's either a string in an ELF string table,
7310 or allocated in an objalloc structure. */
7311
7312 p = eh->elf.root.root.string - 1;
7313 save = *p;
7314 *(char *) p = '.';
7315 htab = ppc_hash_table (info);
7316 if (htab == NULL)
7317 return;
7318
7319 fh = (struct ppc_link_hash_entry *)
7320 elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
7321 *(char *) p = save;
7322
7323 /* Unfortunately, if it so happens that the string we were
7324 looking for was allocated immediately before this string,
7325 then we overwrote the string terminator. That's the only
7326 reason the lookup should fail. */
7327 if (fh == NULL)
7328 {
7329 q = eh->elf.root.root.string + strlen (eh->elf.root.root.string);
7330 while (q >= eh->elf.root.root.string && *q == *p)
7331 --q, --p;
7332 if (q < eh->elf.root.root.string && *p == '.')
7333 fh = (struct ppc_link_hash_entry *)
7334 elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
7335 }
7336 if (fh != NULL)
7337 {
7338 eh->oh = fh;
7339 fh->oh = eh;
7340 }
7341 }
7342 if (fh != NULL)
7343 _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
7344 }
7345 }
7346
7347 static bfd_boolean
7348 get_sym_h (struct elf_link_hash_entry **hp,
7349 Elf_Internal_Sym **symp,
7350 asection **symsecp,
7351 unsigned char **tls_maskp,
7352 Elf_Internal_Sym **locsymsp,
7353 unsigned long r_symndx,
7354 bfd *ibfd)
7355 {
7356 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
7357
7358 if (r_symndx >= symtab_hdr->sh_info)
7359 {
7360 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
7361 struct elf_link_hash_entry *h;
7362
7363 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
7364 h = elf_follow_link (h);
7365
7366 if (hp != NULL)
7367 *hp = h;
7368
7369 if (symp != NULL)
7370 *symp = NULL;
7371
7372 if (symsecp != NULL)
7373 {
7374 asection *symsec = NULL;
7375 if (h->root.type == bfd_link_hash_defined
7376 || h->root.type == bfd_link_hash_defweak)
7377 symsec = h->root.u.def.section;
7378 *symsecp = symsec;
7379 }
7380
7381 if (tls_maskp != NULL)
7382 {
7383 struct ppc_link_hash_entry *eh;
7384
7385 eh = (struct ppc_link_hash_entry *) h;
7386 *tls_maskp = &eh->tls_mask;
7387 }
7388 }
7389 else
7390 {
7391 Elf_Internal_Sym *sym;
7392 Elf_Internal_Sym *locsyms = *locsymsp;
7393
7394 if (locsyms == NULL)
7395 {
7396 locsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
7397 if (locsyms == NULL)
7398 locsyms = bfd_elf_get_elf_syms (ibfd, symtab_hdr,
7399 symtab_hdr->sh_info,
7400 0, NULL, NULL, NULL);
7401 if (locsyms == NULL)
7402 return FALSE;
7403 *locsymsp = locsyms;
7404 }
7405 sym = locsyms + r_symndx;
7406
7407 if (hp != NULL)
7408 *hp = NULL;
7409
7410 if (symp != NULL)
7411 *symp = sym;
7412
7413 if (symsecp != NULL)
7414 *symsecp = bfd_section_from_elf_index (ibfd, sym->st_shndx);
7415
7416 if (tls_maskp != NULL)
7417 {
7418 struct got_entry **lgot_ents;
7419 unsigned char *tls_mask;
7420
7421 tls_mask = NULL;
7422 lgot_ents = elf_local_got_ents (ibfd);
7423 if (lgot_ents != NULL)
7424 {
7425 struct plt_entry **local_plt = (struct plt_entry **)
7426 (lgot_ents + symtab_hdr->sh_info);
7427 unsigned char *lgot_masks = (unsigned char *)
7428 (local_plt + symtab_hdr->sh_info);
7429 tls_mask = &lgot_masks[r_symndx];
7430 }
7431 *tls_maskp = tls_mask;
7432 }
7433 }
7434 return TRUE;
7435 }
7436
7437 /* Returns TLS_MASKP for the given REL symbol. Function return is 0 on
7438 error, 2 on a toc GD type suitable for optimization, 3 on a toc LD
7439 type suitable for optimization, and 1 otherwise. */
7440
7441 static int
7442 get_tls_mask (unsigned char **tls_maskp,
7443 unsigned long *toc_symndx,
7444 bfd_vma *toc_addend,
7445 Elf_Internal_Sym **locsymsp,
7446 const Elf_Internal_Rela *rel,
7447 bfd *ibfd)
7448 {
7449 unsigned long r_symndx;
7450 int next_r;
7451 struct elf_link_hash_entry *h;
7452 Elf_Internal_Sym *sym;
7453 asection *sec;
7454 bfd_vma off;
7455
7456 r_symndx = ELF64_R_SYM (rel->r_info);
7457 if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7458 return 0;
7459
7460 if ((*tls_maskp != NULL && **tls_maskp != 0)
7461 || sec == NULL
7462 || ppc64_elf_section_data (sec) == NULL
7463 || ppc64_elf_section_data (sec)->sec_type != sec_toc)
7464 return 1;
7465
7466 /* Look inside a TOC section too. */
7467 if (h != NULL)
7468 {
7469 BFD_ASSERT (h->root.type == bfd_link_hash_defined);
7470 off = h->root.u.def.value;
7471 }
7472 else
7473 off = sym->st_value;
7474 off += rel->r_addend;
7475 BFD_ASSERT (off % 8 == 0);
7476 r_symndx = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8];
7477 next_r = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8 + 1];
7478 if (toc_symndx != NULL)
7479 *toc_symndx = r_symndx;
7480 if (toc_addend != NULL)
7481 *toc_addend = ppc64_elf_section_data (sec)->u.toc.add[off / 8];
7482 if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7483 return 0;
7484 if ((h == NULL || is_static_defined (h))
7485 && (next_r == -1 || next_r == -2))
7486 return 1 - next_r;
7487 return 1;
7488 }
7489
7490 /* Find (or create) an entry in the tocsave hash table. */
7491
7492 static struct tocsave_entry *
7493 tocsave_find (struct ppc_link_hash_table *htab,
7494 enum insert_option insert,
7495 Elf_Internal_Sym **local_syms,
7496 const Elf_Internal_Rela *irela,
7497 bfd *ibfd)
7498 {
7499 unsigned long r_indx;
7500 struct elf_link_hash_entry *h;
7501 Elf_Internal_Sym *sym;
7502 struct tocsave_entry ent, *p;
7503 hashval_t hash;
7504 struct tocsave_entry **slot;
7505
7506 r_indx = ELF64_R_SYM (irela->r_info);
7507 if (!get_sym_h (&h, &sym, &ent.sec, NULL, local_syms, r_indx, ibfd))
7508 return NULL;
7509 if (ent.sec == NULL || ent.sec->output_section == NULL)
7510 {
7511 (*_bfd_error_handler)
7512 (_("%B: undefined symbol on R_PPC64_TOCSAVE relocation"));
7513 return NULL;
7514 }
7515
7516 if (h != NULL)
7517 ent.offset = h->root.u.def.value;
7518 else
7519 ent.offset = sym->st_value;
7520 ent.offset += irela->r_addend;
7521
7522 hash = tocsave_htab_hash (&ent);
7523 slot = ((struct tocsave_entry **)
7524 htab_find_slot_with_hash (htab->tocsave_htab, &ent, hash, insert));
7525 if (slot == NULL)
7526 return NULL;
7527
7528 if (*slot == NULL)
7529 {
7530 p = (struct tocsave_entry *) bfd_alloc (ibfd, sizeof (*p));
7531 if (p == NULL)
7532 return NULL;
7533 *p = ent;
7534 *slot = p;
7535 }
7536 return *slot;
7537 }
7538
7539 /* Adjust all global syms defined in opd sections. In gcc generated
7540 code for the old ABI, these will already have been done. */
7541
7542 static bfd_boolean
7543 adjust_opd_syms (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
7544 {
7545 struct ppc_link_hash_entry *eh;
7546 asection *sym_sec;
7547 struct _opd_sec_data *opd;
7548
7549 if (h->root.type == bfd_link_hash_indirect)
7550 return TRUE;
7551
7552 if (h->root.type != bfd_link_hash_defined
7553 && h->root.type != bfd_link_hash_defweak)
7554 return TRUE;
7555
7556 eh = (struct ppc_link_hash_entry *) h;
7557 if (eh->adjust_done)
7558 return TRUE;
7559
7560 sym_sec = eh->elf.root.u.def.section;
7561 opd = get_opd_info (sym_sec);
7562 if (opd != NULL && opd->adjust != NULL)
7563 {
7564 long adjust = opd->adjust[OPD_NDX (eh->elf.root.u.def.value)];
7565 if (adjust == -1)
7566 {
7567 /* This entry has been deleted. */
7568 asection *dsec = ppc64_elf_tdata (sym_sec->owner)->deleted_section;
7569 if (dsec == NULL)
7570 {
7571 for (dsec = sym_sec->owner->sections; dsec; dsec = dsec->next)
7572 if (discarded_section (dsec))
7573 {
7574 ppc64_elf_tdata (sym_sec->owner)->deleted_section = dsec;
7575 break;
7576 }
7577 }
7578 eh->elf.root.u.def.value = 0;
7579 eh->elf.root.u.def.section = dsec;
7580 }
7581 else
7582 eh->elf.root.u.def.value += adjust;
7583 eh->adjust_done = 1;
7584 }
7585 return TRUE;
7586 }
7587
7588 /* Handles decrementing dynamic reloc counts for the reloc specified by
7589 R_INFO in section SEC. If LOCAL_SYMS is NULL, then H and SYM
7590 have already been determined. */
7591
7592 static bfd_boolean
7593 dec_dynrel_count (bfd_vma r_info,
7594 asection *sec,
7595 struct bfd_link_info *info,
7596 Elf_Internal_Sym **local_syms,
7597 struct elf_link_hash_entry *h,
7598 Elf_Internal_Sym *sym)
7599 {
7600 enum elf_ppc64_reloc_type r_type;
7601 asection *sym_sec = NULL;
7602
7603 /* Can this reloc be dynamic? This switch, and later tests here
7604 should be kept in sync with the code in check_relocs. */
7605 r_type = ELF64_R_TYPE (r_info);
7606 switch (r_type)
7607 {
7608 default:
7609 return TRUE;
7610
7611 case R_PPC64_TPREL16:
7612 case R_PPC64_TPREL16_LO:
7613 case R_PPC64_TPREL16_HI:
7614 case R_PPC64_TPREL16_HA:
7615 case R_PPC64_TPREL16_DS:
7616 case R_PPC64_TPREL16_LO_DS:
7617 case R_PPC64_TPREL16_HIGH:
7618 case R_PPC64_TPREL16_HIGHA:
7619 case R_PPC64_TPREL16_HIGHER:
7620 case R_PPC64_TPREL16_HIGHERA:
7621 case R_PPC64_TPREL16_HIGHEST:
7622 case R_PPC64_TPREL16_HIGHESTA:
7623 if (!bfd_link_pic (info))
7624 return TRUE;
7625
7626 case R_PPC64_TPREL64:
7627 case R_PPC64_DTPMOD64:
7628 case R_PPC64_DTPREL64:
7629 case R_PPC64_ADDR64:
7630 case R_PPC64_REL30:
7631 case R_PPC64_REL32:
7632 case R_PPC64_REL64:
7633 case R_PPC64_ADDR14:
7634 case R_PPC64_ADDR14_BRNTAKEN:
7635 case R_PPC64_ADDR14_BRTAKEN:
7636 case R_PPC64_ADDR16:
7637 case R_PPC64_ADDR16_DS:
7638 case R_PPC64_ADDR16_HA:
7639 case R_PPC64_ADDR16_HI:
7640 case R_PPC64_ADDR16_HIGH:
7641 case R_PPC64_ADDR16_HIGHA:
7642 case R_PPC64_ADDR16_HIGHER:
7643 case R_PPC64_ADDR16_HIGHERA:
7644 case R_PPC64_ADDR16_HIGHEST:
7645 case R_PPC64_ADDR16_HIGHESTA:
7646 case R_PPC64_ADDR16_LO:
7647 case R_PPC64_ADDR16_LO_DS:
7648 case R_PPC64_ADDR24:
7649 case R_PPC64_ADDR32:
7650 case R_PPC64_UADDR16:
7651 case R_PPC64_UADDR32:
7652 case R_PPC64_UADDR64:
7653 case R_PPC64_TOC:
7654 break;
7655 }
7656
7657 if (local_syms != NULL)
7658 {
7659 unsigned long r_symndx;
7660 bfd *ibfd = sec->owner;
7661
7662 r_symndx = ELF64_R_SYM (r_info);
7663 if (!get_sym_h (&h, &sym, &sym_sec, NULL, local_syms, r_symndx, ibfd))
7664 return FALSE;
7665 }
7666
7667 if ((bfd_link_pic (info)
7668 && (must_be_dyn_reloc (info, r_type)
7669 || (h != NULL
7670 && (!SYMBOLIC_BIND (info, h)
7671 || h->root.type == bfd_link_hash_defweak
7672 || !h->def_regular))))
7673 || (ELIMINATE_COPY_RELOCS
7674 && !bfd_link_pic (info)
7675 && h != NULL
7676 && (h->root.type == bfd_link_hash_defweak
7677 || !h->def_regular)))
7678 ;
7679 else
7680 return TRUE;
7681
7682 if (h != NULL)
7683 {
7684 struct elf_dyn_relocs *p;
7685 struct elf_dyn_relocs **pp;
7686 pp = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
7687
7688 /* elf_gc_sweep may have already removed all dyn relocs associated
7689 with local syms for a given section. Also, symbol flags are
7690 changed by elf_gc_sweep_symbol, confusing the test above. Don't
7691 report a dynreloc miscount. */
7692 if (*pp == NULL && info->gc_sections)
7693 return TRUE;
7694
7695 while ((p = *pp) != NULL)
7696 {
7697 if (p->sec == sec)
7698 {
7699 if (!must_be_dyn_reloc (info, r_type))
7700 p->pc_count -= 1;
7701 p->count -= 1;
7702 if (p->count == 0)
7703 *pp = p->next;
7704 return TRUE;
7705 }
7706 pp = &p->next;
7707 }
7708 }
7709 else
7710 {
7711 struct ppc_dyn_relocs *p;
7712 struct ppc_dyn_relocs **pp;
7713 void *vpp;
7714 bfd_boolean is_ifunc;
7715
7716 if (local_syms == NULL)
7717 sym_sec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
7718 if (sym_sec == NULL)
7719 sym_sec = sec;
7720
7721 vpp = &elf_section_data (sym_sec)->local_dynrel;
7722 pp = (struct ppc_dyn_relocs **) vpp;
7723
7724 if (*pp == NULL && info->gc_sections)
7725 return TRUE;
7726
7727 is_ifunc = ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC;
7728 while ((p = *pp) != NULL)
7729 {
7730 if (p->sec == sec && p->ifunc == is_ifunc)
7731 {
7732 p->count -= 1;
7733 if (p->count == 0)
7734 *pp = p->next;
7735 return TRUE;
7736 }
7737 pp = &p->next;
7738 }
7739 }
7740
7741 info->callbacks->einfo (_("%P: dynreloc miscount for %B, section %A\n"),
7742 sec->owner, sec);
7743 bfd_set_error (bfd_error_bad_value);
7744 return FALSE;
7745 }
7746
7747 /* Remove unused Official Procedure Descriptor entries. Currently we
7748 only remove those associated with functions in discarded link-once
7749 sections, or weakly defined functions that have been overridden. It
7750 would be possible to remove many more entries for statically linked
7751 applications. */
7752
7753 bfd_boolean
7754 ppc64_elf_edit_opd (struct bfd_link_info *info)
7755 {
7756 bfd *ibfd;
7757 bfd_boolean some_edited = FALSE;
7758 asection *need_pad = NULL;
7759 struct ppc_link_hash_table *htab;
7760
7761 htab = ppc_hash_table (info);
7762 if (htab == NULL)
7763 return FALSE;
7764
7765 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
7766 {
7767 asection *sec;
7768 Elf_Internal_Rela *relstart, *rel, *relend;
7769 Elf_Internal_Shdr *symtab_hdr;
7770 Elf_Internal_Sym *local_syms;
7771 struct _opd_sec_data *opd;
7772 bfd_boolean need_edit, add_aux_fields, broken;
7773 bfd_size_type cnt_16b = 0;
7774
7775 if (!is_ppc64_elf (ibfd))
7776 continue;
7777
7778 sec = bfd_get_section_by_name (ibfd, ".opd");
7779 if (sec == NULL || sec->size == 0)
7780 continue;
7781
7782 if (sec->sec_info_type == SEC_INFO_TYPE_JUST_SYMS)
7783 continue;
7784
7785 if (sec->output_section == bfd_abs_section_ptr)
7786 continue;
7787
7788 /* Look through the section relocs. */
7789 if ((sec->flags & SEC_RELOC) == 0 || sec->reloc_count == 0)
7790 continue;
7791
7792 local_syms = NULL;
7793 symtab_hdr = &elf_symtab_hdr (ibfd);
7794
7795 /* Read the relocations. */
7796 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
7797 info->keep_memory);
7798 if (relstart == NULL)
7799 return FALSE;
7800
7801 /* First run through the relocs to check they are sane, and to
7802 determine whether we need to edit this opd section. */
7803 need_edit = FALSE;
7804 broken = FALSE;
7805 need_pad = sec;
7806 relend = relstart + sec->reloc_count;
7807 for (rel = relstart; rel < relend; )
7808 {
7809 enum elf_ppc64_reloc_type r_type;
7810 unsigned long r_symndx;
7811 asection *sym_sec;
7812 struct elf_link_hash_entry *h;
7813 Elf_Internal_Sym *sym;
7814 bfd_vma offset;
7815
7816 /* .opd contains an array of 16 or 24 byte entries. We're
7817 only interested in the reloc pointing to a function entry
7818 point. */
7819 offset = rel->r_offset;
7820 if (rel + 1 == relend
7821 || rel[1].r_offset != offset + 8)
7822 {
7823 /* If someone messes with .opd alignment then after a
7824 "ld -r" we might have padding in the middle of .opd.
7825 Also, there's nothing to prevent someone putting
7826 something silly in .opd with the assembler. No .opd
7827 optimization for them! */
7828 broken_opd:
7829 (*_bfd_error_handler)
7830 (_("%B: .opd is not a regular array of opd entries"), ibfd);
7831 broken = TRUE;
7832 break;
7833 }
7834
7835 if ((r_type = ELF64_R_TYPE (rel->r_info)) != R_PPC64_ADDR64
7836 || (r_type = ELF64_R_TYPE ((rel + 1)->r_info)) != R_PPC64_TOC)
7837 {
7838 (*_bfd_error_handler)
7839 (_("%B: unexpected reloc type %u in .opd section"),
7840 ibfd, r_type);
7841 broken = TRUE;
7842 break;
7843 }
7844
7845 r_symndx = ELF64_R_SYM (rel->r_info);
7846 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7847 r_symndx, ibfd))
7848 goto error_ret;
7849
7850 if (sym_sec == NULL || sym_sec->owner == NULL)
7851 {
7852 const char *sym_name;
7853 if (h != NULL)
7854 sym_name = h->root.root.string;
7855 else
7856 sym_name = bfd_elf_sym_name (ibfd, symtab_hdr, sym,
7857 sym_sec);
7858
7859 (*_bfd_error_handler)
7860 (_("%B: undefined sym `%s' in .opd section"),
7861 ibfd, sym_name);
7862 broken = TRUE;
7863 break;
7864 }
7865
7866 /* opd entries are always for functions defined in the
7867 current input bfd. If the symbol isn't defined in the
7868 input bfd, then we won't be using the function in this
7869 bfd; It must be defined in a linkonce section in another
7870 bfd, or is weak. It's also possible that we are
7871 discarding the function due to a linker script /DISCARD/,
7872 which we test for via the output_section. */
7873 if (sym_sec->owner != ibfd
7874 || sym_sec->output_section == bfd_abs_section_ptr)
7875 need_edit = TRUE;
7876
7877 rel += 2;
7878 if (rel + 1 == relend
7879 || (rel + 2 < relend
7880 && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_TOC))
7881 ++rel;
7882
7883 if (rel == relend)
7884 {
7885 if (sec->size == offset + 24)
7886 {
7887 need_pad = NULL;
7888 break;
7889 }
7890 if (sec->size == offset + 16)
7891 {
7892 cnt_16b++;
7893 break;
7894 }
7895 goto broken_opd;
7896 }
7897 else if (rel + 1 < relend
7898 && ELF64_R_TYPE (rel[0].r_info) == R_PPC64_ADDR64
7899 && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOC)
7900 {
7901 if (rel[0].r_offset == offset + 16)
7902 cnt_16b++;
7903 else if (rel[0].r_offset != offset + 24)
7904 goto broken_opd;
7905 }
7906 else
7907 goto broken_opd;
7908 }
7909
7910 add_aux_fields = htab->params->non_overlapping_opd && cnt_16b > 0;
7911
7912 if (!broken && (need_edit || add_aux_fields))
7913 {
7914 Elf_Internal_Rela *write_rel;
7915 Elf_Internal_Shdr *rel_hdr;
7916 bfd_byte *rptr, *wptr;
7917 bfd_byte *new_contents;
7918 bfd_size_type amt;
7919
7920 new_contents = NULL;
7921 amt = OPD_NDX (sec->size) * sizeof (long);
7922 opd = &ppc64_elf_section_data (sec)->u.opd;
7923 opd->adjust = bfd_zalloc (sec->owner, amt);
7924 if (opd->adjust == NULL)
7925 return FALSE;
7926 ppc64_elf_section_data (sec)->sec_type = sec_opd;
7927
7928 /* This seems a waste of time as input .opd sections are all
7929 zeros as generated by gcc, but I suppose there's no reason
7930 this will always be so. We might start putting something in
7931 the third word of .opd entries. */
7932 if ((sec->flags & SEC_IN_MEMORY) == 0)
7933 {
7934 bfd_byte *loc;
7935 if (!bfd_malloc_and_get_section (ibfd, sec, &loc))
7936 {
7937 if (loc != NULL)
7938 free (loc);
7939 error_ret:
7940 if (local_syms != NULL
7941 && symtab_hdr->contents != (unsigned char *) local_syms)
7942 free (local_syms);
7943 if (elf_section_data (sec)->relocs != relstart)
7944 free (relstart);
7945 return FALSE;
7946 }
7947 sec->contents = loc;
7948 sec->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
7949 }
7950
7951 elf_section_data (sec)->relocs = relstart;
7952
7953 new_contents = sec->contents;
7954 if (add_aux_fields)
7955 {
7956 new_contents = bfd_malloc (sec->size + cnt_16b * 8);
7957 if (new_contents == NULL)
7958 return FALSE;
7959 need_pad = NULL;
7960 }
7961 wptr = new_contents;
7962 rptr = sec->contents;
7963 write_rel = relstart;
7964 for (rel = relstart; rel < relend; )
7965 {
7966 unsigned long r_symndx;
7967 asection *sym_sec;
7968 struct elf_link_hash_entry *h;
7969 struct ppc_link_hash_entry *fdh = NULL;
7970 Elf_Internal_Sym *sym;
7971 long opd_ent_size;
7972 Elf_Internal_Rela *next_rel;
7973 bfd_boolean skip;
7974
7975 r_symndx = ELF64_R_SYM (rel->r_info);
7976 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7977 r_symndx, ibfd))
7978 goto error_ret;
7979
7980 next_rel = rel + 2;
7981 if (next_rel + 1 == relend
7982 || (next_rel + 2 < relend
7983 && ELF64_R_TYPE (next_rel[2].r_info) == R_PPC64_TOC))
7984 ++next_rel;
7985
7986 /* See if the .opd entry is full 24 byte or
7987 16 byte (with fd_aux entry overlapped with next
7988 fd_func). */
7989 opd_ent_size = 24;
7990 if (next_rel == relend)
7991 {
7992 if (sec->size == rel->r_offset + 16)
7993 opd_ent_size = 16;
7994 }
7995 else if (next_rel->r_offset == rel->r_offset + 16)
7996 opd_ent_size = 16;
7997
7998 if (h != NULL
7999 && h->root.root.string[0] == '.')
8000 {
8001 fdh = lookup_fdh ((struct ppc_link_hash_entry *) h, htab);
8002 if (fdh != NULL
8003 && fdh->elf.root.type != bfd_link_hash_defined
8004 && fdh->elf.root.type != bfd_link_hash_defweak)
8005 fdh = NULL;
8006 }
8007
8008 skip = (sym_sec->owner != ibfd
8009 || sym_sec->output_section == bfd_abs_section_ptr);
8010 if (skip)
8011 {
8012 if (fdh != NULL && sym_sec->owner == ibfd)
8013 {
8014 /* Arrange for the function descriptor sym
8015 to be dropped. */
8016 fdh->elf.root.u.def.value = 0;
8017 fdh->elf.root.u.def.section = sym_sec;
8018 }
8019 opd->adjust[OPD_NDX (rel->r_offset)] = -1;
8020
8021 if (NO_OPD_RELOCS || bfd_link_relocatable (info))
8022 rel = next_rel;
8023 else
8024 while (1)
8025 {
8026 if (!dec_dynrel_count (rel->r_info, sec, info,
8027 NULL, h, sym))
8028 goto error_ret;
8029
8030 if (++rel == next_rel)
8031 break;
8032
8033 r_symndx = ELF64_R_SYM (rel->r_info);
8034 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8035 r_symndx, ibfd))
8036 goto error_ret;
8037 }
8038 }
8039 else
8040 {
8041 /* We'll be keeping this opd entry. */
8042 long adjust;
8043
8044 if (fdh != NULL)
8045 {
8046 /* Redefine the function descriptor symbol to
8047 this location in the opd section. It is
8048 necessary to update the value here rather
8049 than using an array of adjustments as we do
8050 for local symbols, because various places
8051 in the generic ELF code use the value
8052 stored in u.def.value. */
8053 fdh->elf.root.u.def.value = wptr - new_contents;
8054 fdh->adjust_done = 1;
8055 }
8056
8057 /* Local syms are a bit tricky. We could
8058 tweak them as they can be cached, but
8059 we'd need to look through the local syms
8060 for the function descriptor sym which we
8061 don't have at the moment. So keep an
8062 array of adjustments. */
8063 adjust = (wptr - new_contents) - (rptr - sec->contents);
8064 opd->adjust[OPD_NDX (rel->r_offset)] = adjust;
8065
8066 if (wptr != rptr)
8067 memcpy (wptr, rptr, opd_ent_size);
8068 wptr += opd_ent_size;
8069 if (add_aux_fields && opd_ent_size == 16)
8070 {
8071 memset (wptr, '\0', 8);
8072 wptr += 8;
8073 }
8074
8075 /* We need to adjust any reloc offsets to point to the
8076 new opd entries. */
8077 for ( ; rel != next_rel; ++rel)
8078 {
8079 rel->r_offset += adjust;
8080 if (write_rel != rel)
8081 memcpy (write_rel, rel, sizeof (*rel));
8082 ++write_rel;
8083 }
8084 }
8085
8086 rptr += opd_ent_size;
8087 }
8088
8089 sec->size = wptr - new_contents;
8090 sec->reloc_count = write_rel - relstart;
8091 if (add_aux_fields)
8092 {
8093 free (sec->contents);
8094 sec->contents = new_contents;
8095 }
8096
8097 /* Fudge the header size too, as this is used later in
8098 elf_bfd_final_link if we are emitting relocs. */
8099 rel_hdr = _bfd_elf_single_rel_hdr (sec);
8100 rel_hdr->sh_size = sec->reloc_count * rel_hdr->sh_entsize;
8101 some_edited = TRUE;
8102 }
8103 else if (elf_section_data (sec)->relocs != relstart)
8104 free (relstart);
8105
8106 if (local_syms != NULL
8107 && symtab_hdr->contents != (unsigned char *) local_syms)
8108 {
8109 if (!info->keep_memory)
8110 free (local_syms);
8111 else
8112 symtab_hdr->contents = (unsigned char *) local_syms;
8113 }
8114 }
8115
8116 if (some_edited)
8117 elf_link_hash_traverse (elf_hash_table (info), adjust_opd_syms, NULL);
8118
8119 /* If we are doing a final link and the last .opd entry is just 16 byte
8120 long, add a 8 byte padding after it. */
8121 if (need_pad != NULL && !bfd_link_relocatable (info))
8122 {
8123 bfd_byte *p;
8124
8125 if ((need_pad->flags & SEC_IN_MEMORY) == 0)
8126 {
8127 BFD_ASSERT (need_pad->size > 0);
8128
8129 p = bfd_malloc (need_pad->size + 8);
8130 if (p == NULL)
8131 return FALSE;
8132
8133 if (! bfd_get_section_contents (need_pad->owner, need_pad,
8134 p, 0, need_pad->size))
8135 return FALSE;
8136
8137 need_pad->contents = p;
8138 need_pad->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
8139 }
8140 else
8141 {
8142 p = bfd_realloc (need_pad->contents, need_pad->size + 8);
8143 if (p == NULL)
8144 return FALSE;
8145
8146 need_pad->contents = p;
8147 }
8148
8149 memset (need_pad->contents + need_pad->size, 0, 8);
8150 need_pad->size += 8;
8151 }
8152
8153 return TRUE;
8154 }
8155
8156 /* Set htab->tls_get_addr and call the generic ELF tls_setup function. */
8157
8158 asection *
8159 ppc64_elf_tls_setup (struct bfd_link_info *info)
8160 {
8161 struct ppc_link_hash_table *htab;
8162
8163 htab = ppc_hash_table (info);
8164 if (htab == NULL)
8165 return NULL;
8166
8167 if (abiversion (info->output_bfd) == 1)
8168 htab->opd_abi = 1;
8169
8170 if (htab->params->no_multi_toc)
8171 htab->do_multi_toc = 0;
8172 else if (!htab->do_multi_toc)
8173 htab->params->no_multi_toc = 1;
8174
8175 htab->tls_get_addr = ((struct ppc_link_hash_entry *)
8176 elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
8177 FALSE, FALSE, TRUE));
8178 /* Move dynamic linking info to the function descriptor sym. */
8179 if (htab->tls_get_addr != NULL)
8180 func_desc_adjust (&htab->tls_get_addr->elf, info);
8181 htab->tls_get_addr_fd = ((struct ppc_link_hash_entry *)
8182 elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
8183 FALSE, FALSE, TRUE));
8184 if (htab->params->tls_get_addr_opt)
8185 {
8186 struct elf_link_hash_entry *opt, *opt_fd, *tga, *tga_fd;
8187
8188 opt = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr_opt",
8189 FALSE, FALSE, TRUE);
8190 if (opt != NULL)
8191 func_desc_adjust (opt, info);
8192 opt_fd = elf_link_hash_lookup (&htab->elf, "__tls_get_addr_opt",
8193 FALSE, FALSE, TRUE);
8194 if (opt_fd != NULL
8195 && (opt_fd->root.type == bfd_link_hash_defined
8196 || opt_fd->root.type == bfd_link_hash_defweak))
8197 {
8198 /* If glibc supports an optimized __tls_get_addr call stub,
8199 signalled by the presence of __tls_get_addr_opt, and we'll
8200 be calling __tls_get_addr via a plt call stub, then
8201 make __tls_get_addr point to __tls_get_addr_opt. */
8202 tga_fd = &htab->tls_get_addr_fd->elf;
8203 if (htab->elf.dynamic_sections_created
8204 && tga_fd != NULL
8205 && (tga_fd->type == STT_FUNC
8206 || tga_fd->needs_plt)
8207 && !(SYMBOL_CALLS_LOCAL (info, tga_fd)
8208 || (ELF_ST_VISIBILITY (tga_fd->other) != STV_DEFAULT
8209 && tga_fd->root.type == bfd_link_hash_undefweak)))
8210 {
8211 struct plt_entry *ent;
8212
8213 for (ent = tga_fd->plt.plist; ent != NULL; ent = ent->next)
8214 if (ent->plt.refcount > 0)
8215 break;
8216 if (ent != NULL)
8217 {
8218 tga_fd->root.type = bfd_link_hash_indirect;
8219 tga_fd->root.u.i.link = &opt_fd->root;
8220 ppc64_elf_copy_indirect_symbol (info, opt_fd, tga_fd);
8221 if (opt_fd->dynindx != -1)
8222 {
8223 /* Use __tls_get_addr_opt in dynamic relocations. */
8224 opt_fd->dynindx = -1;
8225 _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
8226 opt_fd->dynstr_index);
8227 if (!bfd_elf_link_record_dynamic_symbol (info, opt_fd))
8228 return NULL;
8229 }
8230 htab->tls_get_addr_fd = (struct ppc_link_hash_entry *) opt_fd;
8231 tga = &htab->tls_get_addr->elf;
8232 if (opt != NULL && tga != NULL)
8233 {
8234 tga->root.type = bfd_link_hash_indirect;
8235 tga->root.u.i.link = &opt->root;
8236 ppc64_elf_copy_indirect_symbol (info, opt, tga);
8237 _bfd_elf_link_hash_hide_symbol (info, opt,
8238 tga->forced_local);
8239 htab->tls_get_addr = (struct ppc_link_hash_entry *) opt;
8240 }
8241 htab->tls_get_addr_fd->oh = htab->tls_get_addr;
8242 htab->tls_get_addr_fd->is_func_descriptor = 1;
8243 if (htab->tls_get_addr != NULL)
8244 {
8245 htab->tls_get_addr->oh = htab->tls_get_addr_fd;
8246 htab->tls_get_addr->is_func = 1;
8247 }
8248 }
8249 }
8250 }
8251 else if (htab->params->tls_get_addr_opt < 0)
8252 htab->params->tls_get_addr_opt = 0;
8253 }
8254 return _bfd_elf_tls_setup (info->output_bfd, info);
8255 }
8256
8257 /* Return TRUE iff REL is a branch reloc with a global symbol matching
8258 HASH1 or HASH2. */
8259
8260 static bfd_boolean
8261 branch_reloc_hash_match (const bfd *ibfd,
8262 const Elf_Internal_Rela *rel,
8263 const struct ppc_link_hash_entry *hash1,
8264 const struct ppc_link_hash_entry *hash2)
8265 {
8266 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
8267 enum elf_ppc64_reloc_type r_type = ELF64_R_TYPE (rel->r_info);
8268 unsigned int r_symndx = ELF64_R_SYM (rel->r_info);
8269
8270 if (r_symndx >= symtab_hdr->sh_info && is_branch_reloc (r_type))
8271 {
8272 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
8273 struct elf_link_hash_entry *h;
8274
8275 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
8276 h = elf_follow_link (h);
8277 if (h == &hash1->elf || h == &hash2->elf)
8278 return TRUE;
8279 }
8280 return FALSE;
8281 }
8282
8283 /* Run through all the TLS relocs looking for optimization
8284 opportunities. The linker has been hacked (see ppc64elf.em) to do
8285 a preliminary section layout so that we know the TLS segment
8286 offsets. We can't optimize earlier because some optimizations need
8287 to know the tp offset, and we need to optimize before allocating
8288 dynamic relocations. */
8289
8290 bfd_boolean
8291 ppc64_elf_tls_optimize (struct bfd_link_info *info)
8292 {
8293 bfd *ibfd;
8294 asection *sec;
8295 struct ppc_link_hash_table *htab;
8296 unsigned char *toc_ref;
8297 int pass;
8298
8299 if (!bfd_link_executable (info))
8300 return TRUE;
8301
8302 htab = ppc_hash_table (info);
8303 if (htab == NULL)
8304 return FALSE;
8305
8306 /* Make two passes over the relocs. On the first pass, mark toc
8307 entries involved with tls relocs, and check that tls relocs
8308 involved in setting up a tls_get_addr call are indeed followed by
8309 such a call. If they are not, we can't do any tls optimization.
8310 On the second pass twiddle tls_mask flags to notify
8311 relocate_section that optimization can be done, and adjust got
8312 and plt refcounts. */
8313 toc_ref = NULL;
8314 for (pass = 0; pass < 2; ++pass)
8315 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
8316 {
8317 Elf_Internal_Sym *locsyms = NULL;
8318 asection *toc = bfd_get_section_by_name (ibfd, ".toc");
8319
8320 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8321 if (sec->has_tls_reloc && !bfd_is_abs_section (sec->output_section))
8322 {
8323 Elf_Internal_Rela *relstart, *rel, *relend;
8324 bfd_boolean found_tls_get_addr_arg = 0;
8325
8326 /* Read the relocations. */
8327 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8328 info->keep_memory);
8329 if (relstart == NULL)
8330 {
8331 free (toc_ref);
8332 return FALSE;
8333 }
8334
8335 relend = relstart + sec->reloc_count;
8336 for (rel = relstart; rel < relend; rel++)
8337 {
8338 enum elf_ppc64_reloc_type r_type;
8339 unsigned long r_symndx;
8340 struct elf_link_hash_entry *h;
8341 Elf_Internal_Sym *sym;
8342 asection *sym_sec;
8343 unsigned char *tls_mask;
8344 unsigned char tls_set, tls_clear, tls_type = 0;
8345 bfd_vma value;
8346 bfd_boolean ok_tprel, is_local;
8347 long toc_ref_index = 0;
8348 int expecting_tls_get_addr = 0;
8349 bfd_boolean ret = FALSE;
8350
8351 r_symndx = ELF64_R_SYM (rel->r_info);
8352 if (!get_sym_h (&h, &sym, &sym_sec, &tls_mask, &locsyms,
8353 r_symndx, ibfd))
8354 {
8355 err_free_rel:
8356 if (elf_section_data (sec)->relocs != relstart)
8357 free (relstart);
8358 if (toc_ref != NULL)
8359 free (toc_ref);
8360 if (locsyms != NULL
8361 && (elf_symtab_hdr (ibfd).contents
8362 != (unsigned char *) locsyms))
8363 free (locsyms);
8364 return ret;
8365 }
8366
8367 if (h != NULL)
8368 {
8369 if (h->root.type == bfd_link_hash_defined
8370 || h->root.type == bfd_link_hash_defweak)
8371 value = h->root.u.def.value;
8372 else if (h->root.type == bfd_link_hash_undefweak)
8373 value = 0;
8374 else
8375 {
8376 found_tls_get_addr_arg = 0;
8377 continue;
8378 }
8379 }
8380 else
8381 /* Symbols referenced by TLS relocs must be of type
8382 STT_TLS. So no need for .opd local sym adjust. */
8383 value = sym->st_value;
8384
8385 ok_tprel = FALSE;
8386 is_local = FALSE;
8387 if (h == NULL
8388 || !h->def_dynamic)
8389 {
8390 is_local = TRUE;
8391 if (h != NULL
8392 && h->root.type == bfd_link_hash_undefweak)
8393 ok_tprel = TRUE;
8394 else
8395 {
8396 value += sym_sec->output_offset;
8397 value += sym_sec->output_section->vma;
8398 value -= htab->elf.tls_sec->vma;
8399 ok_tprel = (value + TP_OFFSET + ((bfd_vma) 1 << 31)
8400 < (bfd_vma) 1 << 32);
8401 }
8402 }
8403
8404 r_type = ELF64_R_TYPE (rel->r_info);
8405 /* If this section has old-style __tls_get_addr calls
8406 without marker relocs, then check that each
8407 __tls_get_addr call reloc is preceded by a reloc
8408 that conceivably belongs to the __tls_get_addr arg
8409 setup insn. If we don't find matching arg setup
8410 relocs, don't do any tls optimization. */
8411 if (pass == 0
8412 && sec->has_tls_get_addr_call
8413 && h != NULL
8414 && (h == &htab->tls_get_addr->elf
8415 || h == &htab->tls_get_addr_fd->elf)
8416 && !found_tls_get_addr_arg
8417 && is_branch_reloc (r_type))
8418 {
8419 info->callbacks->minfo (_("%H __tls_get_addr lost arg, "
8420 "TLS optimization disabled\n"),
8421 ibfd, sec, rel->r_offset);
8422 ret = TRUE;
8423 goto err_free_rel;
8424 }
8425
8426 found_tls_get_addr_arg = 0;
8427 switch (r_type)
8428 {
8429 case R_PPC64_GOT_TLSLD16:
8430 case R_PPC64_GOT_TLSLD16_LO:
8431 expecting_tls_get_addr = 1;
8432 found_tls_get_addr_arg = 1;
8433 /* Fall thru */
8434
8435 case R_PPC64_GOT_TLSLD16_HI:
8436 case R_PPC64_GOT_TLSLD16_HA:
8437 /* These relocs should never be against a symbol
8438 defined in a shared lib. Leave them alone if
8439 that turns out to be the case. */
8440 if (!is_local)
8441 continue;
8442
8443 /* LD -> LE */
8444 tls_set = 0;
8445 tls_clear = TLS_LD;
8446 tls_type = TLS_TLS | TLS_LD;
8447 break;
8448
8449 case R_PPC64_GOT_TLSGD16:
8450 case R_PPC64_GOT_TLSGD16_LO:
8451 expecting_tls_get_addr = 1;
8452 found_tls_get_addr_arg = 1;
8453 /* Fall thru */
8454
8455 case R_PPC64_GOT_TLSGD16_HI:
8456 case R_PPC64_GOT_TLSGD16_HA:
8457 if (ok_tprel)
8458 /* GD -> LE */
8459 tls_set = 0;
8460 else
8461 /* GD -> IE */
8462 tls_set = TLS_TLS | TLS_TPRELGD;
8463 tls_clear = TLS_GD;
8464 tls_type = TLS_TLS | TLS_GD;
8465 break;
8466
8467 case R_PPC64_GOT_TPREL16_DS:
8468 case R_PPC64_GOT_TPREL16_LO_DS:
8469 case R_PPC64_GOT_TPREL16_HI:
8470 case R_PPC64_GOT_TPREL16_HA:
8471 if (ok_tprel)
8472 {
8473 /* IE -> LE */
8474 tls_set = 0;
8475 tls_clear = TLS_TPREL;
8476 tls_type = TLS_TLS | TLS_TPREL;
8477 break;
8478 }
8479 continue;
8480
8481 case R_PPC64_TLSGD:
8482 case R_PPC64_TLSLD:
8483 found_tls_get_addr_arg = 1;
8484 /* Fall thru */
8485
8486 case R_PPC64_TLS:
8487 case R_PPC64_TOC16:
8488 case R_PPC64_TOC16_LO:
8489 if (sym_sec == NULL || sym_sec != toc)
8490 continue;
8491
8492 /* Mark this toc entry as referenced by a TLS
8493 code sequence. We can do that now in the
8494 case of R_PPC64_TLS, and after checking for
8495 tls_get_addr for the TOC16 relocs. */
8496 if (toc_ref == NULL)
8497 toc_ref = bfd_zmalloc (toc->output_section->rawsize / 8);
8498 if (toc_ref == NULL)
8499 goto err_free_rel;
8500
8501 if (h != NULL)
8502 value = h->root.u.def.value;
8503 else
8504 value = sym->st_value;
8505 value += rel->r_addend;
8506 if (value % 8 != 0)
8507 continue;
8508 BFD_ASSERT (value < toc->size
8509 && toc->output_offset % 8 == 0);
8510 toc_ref_index = (value + toc->output_offset) / 8;
8511 if (r_type == R_PPC64_TLS
8512 || r_type == R_PPC64_TLSGD
8513 || r_type == R_PPC64_TLSLD)
8514 {
8515 toc_ref[toc_ref_index] = 1;
8516 continue;
8517 }
8518
8519 if (pass != 0 && toc_ref[toc_ref_index] == 0)
8520 continue;
8521
8522 tls_set = 0;
8523 tls_clear = 0;
8524 expecting_tls_get_addr = 2;
8525 break;
8526
8527 case R_PPC64_TPREL64:
8528 if (pass == 0
8529 || sec != toc
8530 || toc_ref == NULL
8531 || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
8532 continue;
8533 if (ok_tprel)
8534 {
8535 /* IE -> LE */
8536 tls_set = TLS_EXPLICIT;
8537 tls_clear = TLS_TPREL;
8538 break;
8539 }
8540 continue;
8541
8542 case R_PPC64_DTPMOD64:
8543 if (pass == 0
8544 || sec != toc
8545 || toc_ref == NULL
8546 || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
8547 continue;
8548 if (rel + 1 < relend
8549 && (rel[1].r_info
8550 == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64))
8551 && rel[1].r_offset == rel->r_offset + 8)
8552 {
8553 if (ok_tprel)
8554 /* GD -> LE */
8555 tls_set = TLS_EXPLICIT | TLS_GD;
8556 else
8557 /* GD -> IE */
8558 tls_set = TLS_EXPLICIT | TLS_GD | TLS_TPRELGD;
8559 tls_clear = TLS_GD;
8560 }
8561 else
8562 {
8563 if (!is_local)
8564 continue;
8565
8566 /* LD -> LE */
8567 tls_set = TLS_EXPLICIT;
8568 tls_clear = TLS_LD;
8569 }
8570 break;
8571
8572 default:
8573 continue;
8574 }
8575
8576 if (pass == 0)
8577 {
8578 if (!expecting_tls_get_addr
8579 || !sec->has_tls_get_addr_call)
8580 continue;
8581
8582 if (rel + 1 < relend
8583 && branch_reloc_hash_match (ibfd, rel + 1,
8584 htab->tls_get_addr,
8585 htab->tls_get_addr_fd))
8586 {
8587 if (expecting_tls_get_addr == 2)
8588 {
8589 /* Check for toc tls entries. */
8590 unsigned char *toc_tls;
8591 int retval;
8592
8593 retval = get_tls_mask (&toc_tls, NULL, NULL,
8594 &locsyms,
8595 rel, ibfd);
8596 if (retval == 0)
8597 goto err_free_rel;
8598 if (toc_tls != NULL)
8599 {
8600 if ((*toc_tls & (TLS_GD | TLS_LD)) != 0)
8601 found_tls_get_addr_arg = 1;
8602 if (retval > 1)
8603 toc_ref[toc_ref_index] = 1;
8604 }
8605 }
8606 continue;
8607 }
8608
8609 if (expecting_tls_get_addr != 1)
8610 continue;
8611
8612 /* Uh oh, we didn't find the expected call. We
8613 could just mark this symbol to exclude it
8614 from tls optimization but it's safer to skip
8615 the entire optimization. */
8616 info->callbacks->minfo (_("%H arg lost __tls_get_addr, "
8617 "TLS optimization disabled\n"),
8618 ibfd, sec, rel->r_offset);
8619 ret = TRUE;
8620 goto err_free_rel;
8621 }
8622
8623 if (expecting_tls_get_addr && htab->tls_get_addr != NULL)
8624 {
8625 struct plt_entry *ent;
8626 for (ent = htab->tls_get_addr->elf.plt.plist;
8627 ent != NULL;
8628 ent = ent->next)
8629 if (ent->addend == 0)
8630 {
8631 if (ent->plt.refcount > 0)
8632 {
8633 ent->plt.refcount -= 1;
8634 expecting_tls_get_addr = 0;
8635 }
8636 break;
8637 }
8638 }
8639
8640 if (expecting_tls_get_addr && htab->tls_get_addr_fd != NULL)
8641 {
8642 struct plt_entry *ent;
8643 for (ent = htab->tls_get_addr_fd->elf.plt.plist;
8644 ent != NULL;
8645 ent = ent->next)
8646 if (ent->addend == 0)
8647 {
8648 if (ent->plt.refcount > 0)
8649 ent->plt.refcount -= 1;
8650 break;
8651 }
8652 }
8653
8654 if (tls_clear == 0)
8655 continue;
8656
8657 if ((tls_set & TLS_EXPLICIT) == 0)
8658 {
8659 struct got_entry *ent;
8660
8661 /* Adjust got entry for this reloc. */
8662 if (h != NULL)
8663 ent = h->got.glist;
8664 else
8665 ent = elf_local_got_ents (ibfd)[r_symndx];
8666
8667 for (; ent != NULL; ent = ent->next)
8668 if (ent->addend == rel->r_addend
8669 && ent->owner == ibfd
8670 && ent->tls_type == tls_type)
8671 break;
8672 if (ent == NULL)
8673 abort ();
8674
8675 if (tls_set == 0)
8676 {
8677 /* We managed to get rid of a got entry. */
8678 if (ent->got.refcount > 0)
8679 ent->got.refcount -= 1;
8680 }
8681 }
8682 else
8683 {
8684 /* If we got rid of a DTPMOD/DTPREL reloc pair then
8685 we'll lose one or two dyn relocs. */
8686 if (!dec_dynrel_count (rel->r_info, sec, info,
8687 NULL, h, sym))
8688 return FALSE;
8689
8690 if (tls_set == (TLS_EXPLICIT | TLS_GD))
8691 {
8692 if (!dec_dynrel_count ((rel + 1)->r_info, sec, info,
8693 NULL, h, sym))
8694 return FALSE;
8695 }
8696 }
8697
8698 *tls_mask |= tls_set;
8699 *tls_mask &= ~tls_clear;
8700 }
8701
8702 if (elf_section_data (sec)->relocs != relstart)
8703 free (relstart);
8704 }
8705
8706 if (locsyms != NULL
8707 && (elf_symtab_hdr (ibfd).contents != (unsigned char *) locsyms))
8708 {
8709 if (!info->keep_memory)
8710 free (locsyms);
8711 else
8712 elf_symtab_hdr (ibfd).contents = (unsigned char *) locsyms;
8713 }
8714 }
8715
8716 if (toc_ref != NULL)
8717 free (toc_ref);
8718 return TRUE;
8719 }
8720
8721 /* Called via elf_link_hash_traverse from ppc64_elf_edit_toc to adjust
8722 the values of any global symbols in a toc section that has been
8723 edited. Globals in toc sections should be a rarity, so this function
8724 sets a flag if any are found in toc sections other than the one just
8725 edited, so that futher hash table traversals can be avoided. */
8726
8727 struct adjust_toc_info
8728 {
8729 asection *toc;
8730 unsigned long *skip;
8731 bfd_boolean global_toc_syms;
8732 };
8733
8734 enum toc_skip_enum { ref_from_discarded = 1, can_optimize = 2 };
8735
8736 static bfd_boolean
8737 adjust_toc_syms (struct elf_link_hash_entry *h, void *inf)
8738 {
8739 struct ppc_link_hash_entry *eh;
8740 struct adjust_toc_info *toc_inf = (struct adjust_toc_info *) inf;
8741 unsigned long i;
8742
8743 if (h->root.type != bfd_link_hash_defined
8744 && h->root.type != bfd_link_hash_defweak)
8745 return TRUE;
8746
8747 eh = (struct ppc_link_hash_entry *) h;
8748 if (eh->adjust_done)
8749 return TRUE;
8750
8751 if (eh->elf.root.u.def.section == toc_inf->toc)
8752 {
8753 if (eh->elf.root.u.def.value > toc_inf->toc->rawsize)
8754 i = toc_inf->toc->rawsize >> 3;
8755 else
8756 i = eh->elf.root.u.def.value >> 3;
8757
8758 if ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0)
8759 {
8760 (*_bfd_error_handler)
8761 (_("%s defined on removed toc entry"), eh->elf.root.root.string);
8762 do
8763 ++i;
8764 while ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0);
8765 eh->elf.root.u.def.value = (bfd_vma) i << 3;
8766 }
8767
8768 eh->elf.root.u.def.value -= toc_inf->skip[i];
8769 eh->adjust_done = 1;
8770 }
8771 else if (strcmp (eh->elf.root.u.def.section->name, ".toc") == 0)
8772 toc_inf->global_toc_syms = TRUE;
8773
8774 return TRUE;
8775 }
8776
8777 /* Return TRUE iff INSN is one we expect on a _LO variety toc/got reloc. */
8778
8779 static bfd_boolean
8780 ok_lo_toc_insn (unsigned int insn)
8781 {
8782 return ((insn & (0x3f << 26)) == 14u << 26 /* addi */
8783 || (insn & (0x3f << 26)) == 32u << 26 /* lwz */
8784 || (insn & (0x3f << 26)) == 34u << 26 /* lbz */
8785 || (insn & (0x3f << 26)) == 36u << 26 /* stw */
8786 || (insn & (0x3f << 26)) == 38u << 26 /* stb */
8787 || (insn & (0x3f << 26)) == 40u << 26 /* lhz */
8788 || (insn & (0x3f << 26)) == 42u << 26 /* lha */
8789 || (insn & (0x3f << 26)) == 44u << 26 /* sth */
8790 || (insn & (0x3f << 26)) == 46u << 26 /* lmw */
8791 || (insn & (0x3f << 26)) == 47u << 26 /* stmw */
8792 || (insn & (0x3f << 26)) == 48u << 26 /* lfs */
8793 || (insn & (0x3f << 26)) == 50u << 26 /* lfd */
8794 || (insn & (0x3f << 26)) == 52u << 26 /* stfs */
8795 || (insn & (0x3f << 26)) == 54u << 26 /* stfd */
8796 || ((insn & (0x3f << 26)) == 58u << 26 /* lwa,ld,lmd */
8797 && (insn & 3) != 1)
8798 || ((insn & (0x3f << 26)) == 62u << 26 /* std, stmd */
8799 && ((insn & 3) == 0 || (insn & 3) == 3))
8800 || (insn & (0x3f << 26)) == 12u << 26 /* addic */);
8801 }
8802
8803 /* Examine all relocs referencing .toc sections in order to remove
8804 unused .toc entries. */
8805
8806 bfd_boolean
8807 ppc64_elf_edit_toc (struct bfd_link_info *info)
8808 {
8809 bfd *ibfd;
8810 struct adjust_toc_info toc_inf;
8811 struct ppc_link_hash_table *htab = ppc_hash_table (info);
8812
8813 htab->do_toc_opt = 1;
8814 toc_inf.global_toc_syms = TRUE;
8815 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
8816 {
8817 asection *toc, *sec;
8818 Elf_Internal_Shdr *symtab_hdr;
8819 Elf_Internal_Sym *local_syms;
8820 Elf_Internal_Rela *relstart, *rel, *toc_relocs;
8821 unsigned long *skip, *drop;
8822 unsigned char *used;
8823 unsigned char *keep, last, some_unused;
8824
8825 if (!is_ppc64_elf (ibfd))
8826 continue;
8827
8828 toc = bfd_get_section_by_name (ibfd, ".toc");
8829 if (toc == NULL
8830 || toc->size == 0
8831 || toc->sec_info_type == SEC_INFO_TYPE_JUST_SYMS
8832 || discarded_section (toc))
8833 continue;
8834
8835 toc_relocs = NULL;
8836 local_syms = NULL;
8837 symtab_hdr = &elf_symtab_hdr (ibfd);
8838
8839 /* Look at sections dropped from the final link. */
8840 skip = NULL;
8841 relstart = NULL;
8842 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8843 {
8844 if (sec->reloc_count == 0
8845 || !discarded_section (sec)
8846 || get_opd_info (sec)
8847 || (sec->flags & SEC_ALLOC) == 0
8848 || (sec->flags & SEC_DEBUGGING) != 0)
8849 continue;
8850
8851 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL, FALSE);
8852 if (relstart == NULL)
8853 goto error_ret;
8854
8855 /* Run through the relocs to see which toc entries might be
8856 unused. */
8857 for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
8858 {
8859 enum elf_ppc64_reloc_type r_type;
8860 unsigned long r_symndx;
8861 asection *sym_sec;
8862 struct elf_link_hash_entry *h;
8863 Elf_Internal_Sym *sym;
8864 bfd_vma val;
8865
8866 r_type = ELF64_R_TYPE (rel->r_info);
8867 switch (r_type)
8868 {
8869 default:
8870 continue;
8871
8872 case R_PPC64_TOC16:
8873 case R_PPC64_TOC16_LO:
8874 case R_PPC64_TOC16_HI:
8875 case R_PPC64_TOC16_HA:
8876 case R_PPC64_TOC16_DS:
8877 case R_PPC64_TOC16_LO_DS:
8878 break;
8879 }
8880
8881 r_symndx = ELF64_R_SYM (rel->r_info);
8882 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8883 r_symndx, ibfd))
8884 goto error_ret;
8885
8886 if (sym_sec != toc)
8887 continue;
8888
8889 if (h != NULL)
8890 val = h->root.u.def.value;
8891 else
8892 val = sym->st_value;
8893 val += rel->r_addend;
8894
8895 if (val >= toc->size)
8896 continue;
8897
8898 /* Anything in the toc ought to be aligned to 8 bytes.
8899 If not, don't mark as unused. */
8900 if (val & 7)
8901 continue;
8902
8903 if (skip == NULL)
8904 {
8905 skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
8906 if (skip == NULL)
8907 goto error_ret;
8908 }
8909
8910 skip[val >> 3] = ref_from_discarded;
8911 }
8912
8913 if (elf_section_data (sec)->relocs != relstart)
8914 free (relstart);
8915 }
8916
8917 /* For largetoc loads of address constants, we can convert
8918 . addis rx,2,addr@got@ha
8919 . ld ry,addr@got@l(rx)
8920 to
8921 . addis rx,2,addr@toc@ha
8922 . addi ry,rx,addr@toc@l
8923 when addr is within 2G of the toc pointer. This then means
8924 that the word storing "addr" in the toc is no longer needed. */
8925
8926 if (!ppc64_elf_tdata (ibfd)->has_small_toc_reloc
8927 && toc->output_section->rawsize < (bfd_vma) 1 << 31
8928 && toc->reloc_count != 0)
8929 {
8930 /* Read toc relocs. */
8931 toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
8932 info->keep_memory);
8933 if (toc_relocs == NULL)
8934 goto error_ret;
8935
8936 for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
8937 {
8938 enum elf_ppc64_reloc_type r_type;
8939 unsigned long r_symndx;
8940 asection *sym_sec;
8941 struct elf_link_hash_entry *h;
8942 Elf_Internal_Sym *sym;
8943 bfd_vma val, addr;
8944
8945 r_type = ELF64_R_TYPE (rel->r_info);
8946 if (r_type != R_PPC64_ADDR64)
8947 continue;
8948
8949 r_symndx = ELF64_R_SYM (rel->r_info);
8950 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8951 r_symndx, ibfd))
8952 goto error_ret;
8953
8954 if (sym_sec == NULL
8955 || discarded_section (sym_sec))
8956 continue;
8957
8958 if (!SYMBOL_REFERENCES_LOCAL (info, h))
8959 continue;
8960
8961 if (h != NULL)
8962 {
8963 if (h->type == STT_GNU_IFUNC)
8964 continue;
8965 val = h->root.u.def.value;
8966 }
8967 else
8968 {
8969 if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
8970 continue;
8971 val = sym->st_value;
8972 }
8973 val += rel->r_addend;
8974 val += sym_sec->output_section->vma + sym_sec->output_offset;
8975
8976 /* We don't yet know the exact toc pointer value, but we
8977 know it will be somewhere in the toc section. Don't
8978 optimize if the difference from any possible toc
8979 pointer is outside [ff..f80008000, 7fff7fff]. */
8980 addr = toc->output_section->vma + TOC_BASE_OFF;
8981 if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
8982 continue;
8983
8984 addr = toc->output_section->vma + toc->output_section->rawsize;
8985 if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
8986 continue;
8987
8988 if (skip == NULL)
8989 {
8990 skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
8991 if (skip == NULL)
8992 goto error_ret;
8993 }
8994
8995 skip[rel->r_offset >> 3]
8996 |= can_optimize | ((rel - toc_relocs) << 2);
8997 }
8998 }
8999
9000 if (skip == NULL)
9001 continue;
9002
9003 used = bfd_zmalloc (sizeof (*used) * (toc->size + 7) / 8);
9004 if (used == NULL)
9005 {
9006 error_ret:
9007 if (local_syms != NULL
9008 && symtab_hdr->contents != (unsigned char *) local_syms)
9009 free (local_syms);
9010 if (sec != NULL
9011 && relstart != NULL
9012 && elf_section_data (sec)->relocs != relstart)
9013 free (relstart);
9014 if (toc_relocs != NULL
9015 && elf_section_data (toc)->relocs != toc_relocs)
9016 free (toc_relocs);
9017 if (skip != NULL)
9018 free (skip);
9019 return FALSE;
9020 }
9021
9022 /* Now check all kept sections that might reference the toc.
9023 Check the toc itself last. */
9024 for (sec = (ibfd->sections == toc && toc->next ? toc->next
9025 : ibfd->sections);
9026 sec != NULL;
9027 sec = (sec == toc ? NULL
9028 : sec->next == NULL ? toc
9029 : sec->next == toc && toc->next ? toc->next
9030 : sec->next))
9031 {
9032 int repeat;
9033
9034 if (sec->reloc_count == 0
9035 || discarded_section (sec)
9036 || get_opd_info (sec)
9037 || (sec->flags & SEC_ALLOC) == 0
9038 || (sec->flags & SEC_DEBUGGING) != 0)
9039 continue;
9040
9041 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
9042 info->keep_memory);
9043 if (relstart == NULL)
9044 {
9045 free (used);
9046 goto error_ret;
9047 }
9048
9049 /* Mark toc entries referenced as used. */
9050 do
9051 {
9052 repeat = 0;
9053 for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9054 {
9055 enum elf_ppc64_reloc_type r_type;
9056 unsigned long r_symndx;
9057 asection *sym_sec;
9058 struct elf_link_hash_entry *h;
9059 Elf_Internal_Sym *sym;
9060 bfd_vma val;
9061 enum {no_check, check_lo, check_ha} insn_check;
9062
9063 r_type = ELF64_R_TYPE (rel->r_info);
9064 switch (r_type)
9065 {
9066 default:
9067 insn_check = no_check;
9068 break;
9069
9070 case R_PPC64_GOT_TLSLD16_HA:
9071 case R_PPC64_GOT_TLSGD16_HA:
9072 case R_PPC64_GOT_TPREL16_HA:
9073 case R_PPC64_GOT_DTPREL16_HA:
9074 case R_PPC64_GOT16_HA:
9075 case R_PPC64_TOC16_HA:
9076 insn_check = check_ha;
9077 break;
9078
9079 case R_PPC64_GOT_TLSLD16_LO:
9080 case R_PPC64_GOT_TLSGD16_LO:
9081 case R_PPC64_GOT_TPREL16_LO_DS:
9082 case R_PPC64_GOT_DTPREL16_LO_DS:
9083 case R_PPC64_GOT16_LO:
9084 case R_PPC64_GOT16_LO_DS:
9085 case R_PPC64_TOC16_LO:
9086 case R_PPC64_TOC16_LO_DS:
9087 insn_check = check_lo;
9088 break;
9089 }
9090
9091 if (insn_check != no_check)
9092 {
9093 bfd_vma off = rel->r_offset & ~3;
9094 unsigned char buf[4];
9095 unsigned int insn;
9096
9097 if (!bfd_get_section_contents (ibfd, sec, buf, off, 4))
9098 {
9099 free (used);
9100 goto error_ret;
9101 }
9102 insn = bfd_get_32 (ibfd, buf);
9103 if (insn_check == check_lo
9104 ? !ok_lo_toc_insn (insn)
9105 : ((insn & ((0x3f << 26) | 0x1f << 16))
9106 != ((15u << 26) | (2 << 16)) /* addis rt,2,imm */))
9107 {
9108 char str[12];
9109
9110 ppc64_elf_tdata (ibfd)->unexpected_toc_insn = 1;
9111 sprintf (str, "%#08x", insn);
9112 info->callbacks->einfo
9113 (_("%P: %H: toc optimization is not supported for"
9114 " %s instruction.\n"),
9115 ibfd, sec, rel->r_offset & ~3, str);
9116 }
9117 }
9118
9119 switch (r_type)
9120 {
9121 case R_PPC64_TOC16:
9122 case R_PPC64_TOC16_LO:
9123 case R_PPC64_TOC16_HI:
9124 case R_PPC64_TOC16_HA:
9125 case R_PPC64_TOC16_DS:
9126 case R_PPC64_TOC16_LO_DS:
9127 /* In case we're taking addresses of toc entries. */
9128 case R_PPC64_ADDR64:
9129 break;
9130
9131 default:
9132 continue;
9133 }
9134
9135 r_symndx = ELF64_R_SYM (rel->r_info);
9136 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9137 r_symndx, ibfd))
9138 {
9139 free (used);
9140 goto error_ret;
9141 }
9142
9143 if (sym_sec != toc)
9144 continue;
9145
9146 if (h != NULL)
9147 val = h->root.u.def.value;
9148 else
9149 val = sym->st_value;
9150 val += rel->r_addend;
9151
9152 if (val >= toc->size)
9153 continue;
9154
9155 if ((skip[val >> 3] & can_optimize) != 0)
9156 {
9157 bfd_vma off;
9158 unsigned char opc;
9159
9160 switch (r_type)
9161 {
9162 case R_PPC64_TOC16_HA:
9163 break;
9164
9165 case R_PPC64_TOC16_LO_DS:
9166 off = rel->r_offset;
9167 off += (bfd_big_endian (ibfd) ? -2 : 3);
9168 if (!bfd_get_section_contents (ibfd, sec, &opc,
9169 off, 1))
9170 {
9171 free (used);
9172 goto error_ret;
9173 }
9174 if ((opc & (0x3f << 2)) == (58u << 2))
9175 break;
9176 /* Fall thru */
9177
9178 default:
9179 /* Wrong sort of reloc, or not a ld. We may
9180 as well clear ref_from_discarded too. */
9181 skip[val >> 3] = 0;
9182 }
9183 }
9184
9185 if (sec != toc)
9186 used[val >> 3] = 1;
9187 /* For the toc section, we only mark as used if this
9188 entry itself isn't unused. */
9189 else if ((used[rel->r_offset >> 3]
9190 || !(skip[rel->r_offset >> 3] & ref_from_discarded))
9191 && !used[val >> 3])
9192 {
9193 /* Do all the relocs again, to catch reference
9194 chains. */
9195 repeat = 1;
9196 used[val >> 3] = 1;
9197 }
9198 }
9199 }
9200 while (repeat);
9201
9202 if (elf_section_data (sec)->relocs != relstart)
9203 free (relstart);
9204 }
9205
9206 /* Merge the used and skip arrays. Assume that TOC
9207 doublewords not appearing as either used or unused belong
9208 to to an entry more than one doubleword in size. */
9209 for (drop = skip, keep = used, last = 0, some_unused = 0;
9210 drop < skip + (toc->size + 7) / 8;
9211 ++drop, ++keep)
9212 {
9213 if (*keep)
9214 {
9215 *drop &= ~ref_from_discarded;
9216 if ((*drop & can_optimize) != 0)
9217 some_unused = 1;
9218 last = 0;
9219 }
9220 else if ((*drop & ref_from_discarded) != 0)
9221 {
9222 some_unused = 1;
9223 last = ref_from_discarded;
9224 }
9225 else
9226 *drop = last;
9227 }
9228
9229 free (used);
9230
9231 if (some_unused)
9232 {
9233 bfd_byte *contents, *src;
9234 unsigned long off;
9235 Elf_Internal_Sym *sym;
9236 bfd_boolean local_toc_syms = FALSE;
9237
9238 /* Shuffle the toc contents, and at the same time convert the
9239 skip array from booleans into offsets. */
9240 if (!bfd_malloc_and_get_section (ibfd, toc, &contents))
9241 goto error_ret;
9242
9243 elf_section_data (toc)->this_hdr.contents = contents;
9244
9245 for (src = contents, off = 0, drop = skip;
9246 src < contents + toc->size;
9247 src += 8, ++drop)
9248 {
9249 if ((*drop & (can_optimize | ref_from_discarded)) != 0)
9250 off += 8;
9251 else if (off != 0)
9252 {
9253 *drop = off;
9254 memcpy (src - off, src, 8);
9255 }
9256 }
9257 *drop = off;
9258 toc->rawsize = toc->size;
9259 toc->size = src - contents - off;
9260
9261 /* Adjust addends for relocs against the toc section sym,
9262 and optimize any accesses we can. */
9263 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
9264 {
9265 if (sec->reloc_count == 0
9266 || discarded_section (sec))
9267 continue;
9268
9269 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
9270 info->keep_memory);
9271 if (relstart == NULL)
9272 goto error_ret;
9273
9274 for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9275 {
9276 enum elf_ppc64_reloc_type r_type;
9277 unsigned long r_symndx;
9278 asection *sym_sec;
9279 struct elf_link_hash_entry *h;
9280 bfd_vma val;
9281
9282 r_type = ELF64_R_TYPE (rel->r_info);
9283 switch (r_type)
9284 {
9285 default:
9286 continue;
9287
9288 case R_PPC64_TOC16:
9289 case R_PPC64_TOC16_LO:
9290 case R_PPC64_TOC16_HI:
9291 case R_PPC64_TOC16_HA:
9292 case R_PPC64_TOC16_DS:
9293 case R_PPC64_TOC16_LO_DS:
9294 case R_PPC64_ADDR64:
9295 break;
9296 }
9297
9298 r_symndx = ELF64_R_SYM (rel->r_info);
9299 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9300 r_symndx, ibfd))
9301 goto error_ret;
9302
9303 if (sym_sec != toc)
9304 continue;
9305
9306 if (h != NULL)
9307 val = h->root.u.def.value;
9308 else
9309 {
9310 val = sym->st_value;
9311 if (val != 0)
9312 local_toc_syms = TRUE;
9313 }
9314
9315 val += rel->r_addend;
9316
9317 if (val > toc->rawsize)
9318 val = toc->rawsize;
9319 else if ((skip[val >> 3] & ref_from_discarded) != 0)
9320 continue;
9321 else if ((skip[val >> 3] & can_optimize) != 0)
9322 {
9323 Elf_Internal_Rela *tocrel
9324 = toc_relocs + (skip[val >> 3] >> 2);
9325 unsigned long tsym = ELF64_R_SYM (tocrel->r_info);
9326
9327 switch (r_type)
9328 {
9329 case R_PPC64_TOC16_HA:
9330 rel->r_info = ELF64_R_INFO (tsym, R_PPC64_TOC16_HA);
9331 break;
9332
9333 case R_PPC64_TOC16_LO_DS:
9334 rel->r_info = ELF64_R_INFO (tsym, R_PPC64_LO_DS_OPT);
9335 break;
9336
9337 default:
9338 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
9339 ppc_howto_init ();
9340 info->callbacks->einfo
9341 (_("%P: %H: %s references "
9342 "optimized away TOC entry\n"),
9343 ibfd, sec, rel->r_offset,
9344 ppc64_elf_howto_table[r_type]->name);
9345 bfd_set_error (bfd_error_bad_value);
9346 goto error_ret;
9347 }
9348 rel->r_addend = tocrel->r_addend;
9349 elf_section_data (sec)->relocs = relstart;
9350 continue;
9351 }
9352
9353 if (h != NULL || sym->st_value != 0)
9354 continue;
9355
9356 rel->r_addend -= skip[val >> 3];
9357 elf_section_data (sec)->relocs = relstart;
9358 }
9359
9360 if (elf_section_data (sec)->relocs != relstart)
9361 free (relstart);
9362 }
9363
9364 /* We shouldn't have local or global symbols defined in the TOC,
9365 but handle them anyway. */
9366 if (local_syms != NULL)
9367 for (sym = local_syms;
9368 sym < local_syms + symtab_hdr->sh_info;
9369 ++sym)
9370 if (sym->st_value != 0
9371 && bfd_section_from_elf_index (ibfd, sym->st_shndx) == toc)
9372 {
9373 unsigned long i;
9374
9375 if (sym->st_value > toc->rawsize)
9376 i = toc->rawsize >> 3;
9377 else
9378 i = sym->st_value >> 3;
9379
9380 if ((skip[i] & (ref_from_discarded | can_optimize)) != 0)
9381 {
9382 if (local_toc_syms)
9383 (*_bfd_error_handler)
9384 (_("%s defined on removed toc entry"),
9385 bfd_elf_sym_name (ibfd, symtab_hdr, sym, NULL));
9386 do
9387 ++i;
9388 while ((skip[i] & (ref_from_discarded | can_optimize)));
9389 sym->st_value = (bfd_vma) i << 3;
9390 }
9391
9392 sym->st_value -= skip[i];
9393 symtab_hdr->contents = (unsigned char *) local_syms;
9394 }
9395
9396 /* Adjust any global syms defined in this toc input section. */
9397 if (toc_inf.global_toc_syms)
9398 {
9399 toc_inf.toc = toc;
9400 toc_inf.skip = skip;
9401 toc_inf.global_toc_syms = FALSE;
9402 elf_link_hash_traverse (elf_hash_table (info), adjust_toc_syms,
9403 &toc_inf);
9404 }
9405
9406 if (toc->reloc_count != 0)
9407 {
9408 Elf_Internal_Shdr *rel_hdr;
9409 Elf_Internal_Rela *wrel;
9410 bfd_size_type sz;
9411
9412 /* Remove unused toc relocs, and adjust those we keep. */
9413 if (toc_relocs == NULL)
9414 toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
9415 info->keep_memory);
9416 if (toc_relocs == NULL)
9417 goto error_ret;
9418
9419 wrel = toc_relocs;
9420 for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
9421 if ((skip[rel->r_offset >> 3]
9422 & (ref_from_discarded | can_optimize)) == 0)
9423 {
9424 wrel->r_offset = rel->r_offset - skip[rel->r_offset >> 3];
9425 wrel->r_info = rel->r_info;
9426 wrel->r_addend = rel->r_addend;
9427 ++wrel;
9428 }
9429 else if (!dec_dynrel_count (rel->r_info, toc, info,
9430 &local_syms, NULL, NULL))
9431 goto error_ret;
9432
9433 elf_section_data (toc)->relocs = toc_relocs;
9434 toc->reloc_count = wrel - toc_relocs;
9435 rel_hdr = _bfd_elf_single_rel_hdr (toc);
9436 sz = rel_hdr->sh_entsize;
9437 rel_hdr->sh_size = toc->reloc_count * sz;
9438 }
9439 }
9440 else if (toc_relocs != NULL
9441 && elf_section_data (toc)->relocs != toc_relocs)
9442 free (toc_relocs);
9443
9444 if (local_syms != NULL
9445 && symtab_hdr->contents != (unsigned char *) local_syms)
9446 {
9447 if (!info->keep_memory)
9448 free (local_syms);
9449 else
9450 symtab_hdr->contents = (unsigned char *) local_syms;
9451 }
9452 free (skip);
9453 }
9454
9455 return TRUE;
9456 }
9457
9458 /* Return true iff input section I references the TOC using
9459 instructions limited to +/-32k offsets. */
9460
9461 bfd_boolean
9462 ppc64_elf_has_small_toc_reloc (asection *i)
9463 {
9464 return (is_ppc64_elf (i->owner)
9465 && ppc64_elf_tdata (i->owner)->has_small_toc_reloc);
9466 }
9467
9468 /* Allocate space for one GOT entry. */
9469
9470 static void
9471 allocate_got (struct elf_link_hash_entry *h,
9472 struct bfd_link_info *info,
9473 struct got_entry *gent)
9474 {
9475 struct ppc_link_hash_table *htab = ppc_hash_table (info);
9476 bfd_boolean dyn;
9477 struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
9478 int entsize = (gent->tls_type & eh->tls_mask & (TLS_GD | TLS_LD)
9479 ? 16 : 8);
9480 int rentsize = (gent->tls_type & eh->tls_mask & TLS_GD
9481 ? 2 : 1) * sizeof (Elf64_External_Rela);
9482 asection *got = ppc64_elf_tdata (gent->owner)->got;
9483
9484 gent->got.offset = got->size;
9485 got->size += entsize;
9486
9487 dyn = htab->elf.dynamic_sections_created;
9488 if (h->type == STT_GNU_IFUNC)
9489 {
9490 htab->elf.irelplt->size += rentsize;
9491 htab->got_reli_size += rentsize;
9492 }
9493 else if ((bfd_link_pic (info)
9494 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h))
9495 && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
9496 || h->root.type != bfd_link_hash_undefweak))
9497 {
9498 asection *relgot = ppc64_elf_tdata (gent->owner)->relgot;
9499 relgot->size += rentsize;
9500 }
9501 }
9502
9503 /* This function merges got entries in the same toc group. */
9504
9505 static void
9506 merge_got_entries (struct got_entry **pent)
9507 {
9508 struct got_entry *ent, *ent2;
9509
9510 for (ent = *pent; ent != NULL; ent = ent->next)
9511 if (!ent->is_indirect)
9512 for (ent2 = ent->next; ent2 != NULL; ent2 = ent2->next)
9513 if (!ent2->is_indirect
9514 && ent2->addend == ent->addend
9515 && ent2->tls_type == ent->tls_type
9516 && elf_gp (ent2->owner) == elf_gp (ent->owner))
9517 {
9518 ent2->is_indirect = TRUE;
9519 ent2->got.ent = ent;
9520 }
9521 }
9522
9523 /* Allocate space in .plt, .got and associated reloc sections for
9524 dynamic relocs. */
9525
9526 static bfd_boolean
9527 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
9528 {
9529 struct bfd_link_info *info;
9530 struct ppc_link_hash_table *htab;
9531 asection *s;
9532 struct ppc_link_hash_entry *eh;
9533 struct elf_dyn_relocs *p;
9534 struct got_entry **pgent, *gent;
9535
9536 if (h->root.type == bfd_link_hash_indirect)
9537 return TRUE;
9538
9539 info = (struct bfd_link_info *) inf;
9540 htab = ppc_hash_table (info);
9541 if (htab == NULL)
9542 return FALSE;
9543
9544 if ((htab->elf.dynamic_sections_created
9545 && h->dynindx != -1
9546 && WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, bfd_link_pic (info), h))
9547 || h->type == STT_GNU_IFUNC)
9548 {
9549 struct plt_entry *pent;
9550 bfd_boolean doneone = FALSE;
9551 for (pent = h->plt.plist; pent != NULL; pent = pent->next)
9552 if (pent->plt.refcount > 0)
9553 {
9554 if (!htab->elf.dynamic_sections_created
9555 || h->dynindx == -1)
9556 {
9557 s = htab->elf.iplt;
9558 pent->plt.offset = s->size;
9559 s->size += PLT_ENTRY_SIZE (htab);
9560 s = htab->elf.irelplt;
9561 }
9562 else
9563 {
9564 /* If this is the first .plt entry, make room for the special
9565 first entry. */
9566 s = htab->elf.splt;
9567 if (s->size == 0)
9568 s->size += PLT_INITIAL_ENTRY_SIZE (htab);
9569
9570 pent->plt.offset = s->size;
9571
9572 /* Make room for this entry. */
9573 s->size += PLT_ENTRY_SIZE (htab);
9574
9575 /* Make room for the .glink code. */
9576 s = htab->glink;
9577 if (s->size == 0)
9578 s->size += GLINK_CALL_STUB_SIZE;
9579 if (htab->opd_abi)
9580 {
9581 /* We need bigger stubs past index 32767. */
9582 if (s->size >= GLINK_CALL_STUB_SIZE + 32768*2*4)
9583 s->size += 4;
9584 s->size += 2*4;
9585 }
9586 else
9587 s->size += 4;
9588
9589 /* We also need to make an entry in the .rela.plt section. */
9590 s = htab->elf.srelplt;
9591 }
9592 s->size += sizeof (Elf64_External_Rela);
9593 doneone = TRUE;
9594 }
9595 else
9596 pent->plt.offset = (bfd_vma) -1;
9597 if (!doneone)
9598 {
9599 h->plt.plist = NULL;
9600 h->needs_plt = 0;
9601 }
9602 }
9603 else
9604 {
9605 h->plt.plist = NULL;
9606 h->needs_plt = 0;
9607 }
9608
9609 eh = (struct ppc_link_hash_entry *) h;
9610 /* Run through the TLS GD got entries first if we're changing them
9611 to TPREL. */
9612 if ((eh->tls_mask & TLS_TPRELGD) != 0)
9613 for (gent = h->got.glist; gent != NULL; gent = gent->next)
9614 if (gent->got.refcount > 0
9615 && (gent->tls_type & TLS_GD) != 0)
9616 {
9617 /* This was a GD entry that has been converted to TPREL. If
9618 there happens to be a TPREL entry we can use that one. */
9619 struct got_entry *ent;
9620 for (ent = h->got.glist; ent != NULL; ent = ent->next)
9621 if (ent->got.refcount > 0
9622 && (ent->tls_type & TLS_TPREL) != 0
9623 && ent->addend == gent->addend
9624 && ent->owner == gent->owner)
9625 {
9626 gent->got.refcount = 0;
9627 break;
9628 }
9629
9630 /* If not, then we'll be using our own TPREL entry. */
9631 if (gent->got.refcount != 0)
9632 gent->tls_type = TLS_TLS | TLS_TPREL;
9633 }
9634
9635 /* Remove any list entry that won't generate a word in the GOT before
9636 we call merge_got_entries. Otherwise we risk merging to empty
9637 entries. */
9638 pgent = &h->got.glist;
9639 while ((gent = *pgent) != NULL)
9640 if (gent->got.refcount > 0)
9641 {
9642 if ((gent->tls_type & TLS_LD) != 0
9643 && !h->def_dynamic)
9644 {
9645 ppc64_tlsld_got (gent->owner)->got.refcount += 1;
9646 *pgent = gent->next;
9647 }
9648 else
9649 pgent = &gent->next;
9650 }
9651 else
9652 *pgent = gent->next;
9653
9654 if (!htab->do_multi_toc)
9655 merge_got_entries (&h->got.glist);
9656
9657 for (gent = h->got.glist; gent != NULL; gent = gent->next)
9658 if (!gent->is_indirect)
9659 {
9660 /* Make sure this symbol is output as a dynamic symbol.
9661 Undefined weak syms won't yet be marked as dynamic,
9662 nor will all TLS symbols. */
9663 if (h->dynindx == -1
9664 && !h->forced_local
9665 && h->type != STT_GNU_IFUNC
9666 && htab->elf.dynamic_sections_created)
9667 {
9668 if (! bfd_elf_link_record_dynamic_symbol (info, h))
9669 return FALSE;
9670 }
9671
9672 if (!is_ppc64_elf (gent->owner))
9673 abort ();
9674
9675 allocate_got (h, info, gent);
9676 }
9677
9678 if (eh->dyn_relocs == NULL
9679 || (!htab->elf.dynamic_sections_created
9680 && h->type != STT_GNU_IFUNC))
9681 return TRUE;
9682
9683 /* In the shared -Bsymbolic case, discard space allocated for
9684 dynamic pc-relative relocs against symbols which turn out to be
9685 defined in regular objects. For the normal shared case, discard
9686 space for relocs that have become local due to symbol visibility
9687 changes. */
9688
9689 if (bfd_link_pic (info))
9690 {
9691 /* Relocs that use pc_count are those that appear on a call insn,
9692 or certain REL relocs (see must_be_dyn_reloc) that can be
9693 generated via assembly. We want calls to protected symbols to
9694 resolve directly to the function rather than going via the plt.
9695 If people want function pointer comparisons to work as expected
9696 then they should avoid writing weird assembly. */
9697 if (SYMBOL_CALLS_LOCAL (info, h))
9698 {
9699 struct elf_dyn_relocs **pp;
9700
9701 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
9702 {
9703 p->count -= p->pc_count;
9704 p->pc_count = 0;
9705 if (p->count == 0)
9706 *pp = p->next;
9707 else
9708 pp = &p->next;
9709 }
9710 }
9711
9712 /* Also discard relocs on undefined weak syms with non-default
9713 visibility. */
9714 if (eh->dyn_relocs != NULL
9715 && h->root.type == bfd_link_hash_undefweak)
9716 {
9717 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
9718 eh->dyn_relocs = NULL;
9719
9720 /* Make sure this symbol is output as a dynamic symbol.
9721 Undefined weak syms won't yet be marked as dynamic. */
9722 else if (h->dynindx == -1
9723 && !h->forced_local)
9724 {
9725 if (! bfd_elf_link_record_dynamic_symbol (info, h))
9726 return FALSE;
9727 }
9728 }
9729 }
9730 else if (h->type == STT_GNU_IFUNC)
9731 {
9732 if (!h->non_got_ref)
9733 eh->dyn_relocs = NULL;
9734 }
9735 else if (ELIMINATE_COPY_RELOCS)
9736 {
9737 /* For the non-shared case, discard space for relocs against
9738 symbols which turn out to need copy relocs or are not
9739 dynamic. */
9740
9741 if (!h->non_got_ref
9742 && !h->def_regular)
9743 {
9744 /* Make sure this symbol is output as a dynamic symbol.
9745 Undefined weak syms won't yet be marked as dynamic. */
9746 if (h->dynindx == -1
9747 && !h->forced_local)
9748 {
9749 if (! bfd_elf_link_record_dynamic_symbol (info, h))
9750 return FALSE;
9751 }
9752
9753 /* If that succeeded, we know we'll be keeping all the
9754 relocs. */
9755 if (h->dynindx != -1)
9756 goto keep;
9757 }
9758
9759 eh->dyn_relocs = NULL;
9760
9761 keep: ;
9762 }
9763
9764 /* Finally, allocate space. */
9765 for (p = eh->dyn_relocs; p != NULL; p = p->next)
9766 {
9767 asection *sreloc = elf_section_data (p->sec)->sreloc;
9768 if (eh->elf.type == STT_GNU_IFUNC)
9769 sreloc = htab->elf.irelplt;
9770 sreloc->size += p->count * sizeof (Elf64_External_Rela);
9771 }
9772
9773 return TRUE;
9774 }
9775
9776 /* Called via elf_link_hash_traverse from ppc64_elf_size_dynamic_sections
9777 to set up space for global entry stubs. These are put in glink,
9778 after the branch table. */
9779
9780 static bfd_boolean
9781 size_global_entry_stubs (struct elf_link_hash_entry *h, void *inf)
9782 {
9783 struct bfd_link_info *info;
9784 struct ppc_link_hash_table *htab;
9785 struct plt_entry *pent;
9786 asection *s;
9787
9788 if (h->root.type == bfd_link_hash_indirect)
9789 return TRUE;
9790
9791 if (!h->pointer_equality_needed)
9792 return TRUE;
9793
9794 if (h->def_regular)
9795 return TRUE;
9796
9797 info = inf;
9798 htab = ppc_hash_table (info);
9799 if (htab == NULL)
9800 return FALSE;
9801
9802 s = htab->glink;
9803 for (pent = h->plt.plist; pent != NULL; pent = pent->next)
9804 if (pent->plt.offset != (bfd_vma) -1
9805 && pent->addend == 0)
9806 {
9807 /* For ELFv2, if this symbol is not defined in a regular file
9808 and we are not generating a shared library or pie, then we
9809 need to define the symbol in the executable on a call stub.
9810 This is to avoid text relocations. */
9811 s->size = (s->size + 15) & -16;
9812 h->root.u.def.section = s;
9813 h->root.u.def.value = s->size;
9814 s->size += 16;
9815 break;
9816 }
9817 return TRUE;
9818 }
9819
9820 /* Set DF_TEXTREL if we find any dynamic relocs that apply to
9821 read-only sections. */
9822
9823 static bfd_boolean
9824 maybe_set_textrel (struct elf_link_hash_entry *h, void *info)
9825 {
9826 if (h->root.type == bfd_link_hash_indirect)
9827 return TRUE;
9828
9829 if (readonly_dynrelocs (h))
9830 {
9831 ((struct bfd_link_info *) info)->flags |= DF_TEXTREL;
9832
9833 /* Not an error, just cut short the traversal. */
9834 return FALSE;
9835 }
9836 return TRUE;
9837 }
9838
9839 /* Set the sizes of the dynamic sections. */
9840
9841 static bfd_boolean
9842 ppc64_elf_size_dynamic_sections (bfd *output_bfd,
9843 struct bfd_link_info *info)
9844 {
9845 struct ppc_link_hash_table *htab;
9846 bfd *dynobj;
9847 asection *s;
9848 bfd_boolean relocs;
9849 bfd *ibfd;
9850 struct got_entry *first_tlsld;
9851
9852 htab = ppc_hash_table (info);
9853 if (htab == NULL)
9854 return FALSE;
9855
9856 dynobj = htab->elf.dynobj;
9857 if (dynobj == NULL)
9858 abort ();
9859
9860 if (htab->elf.dynamic_sections_created)
9861 {
9862 /* Set the contents of the .interp section to the interpreter. */
9863 if (bfd_link_executable (info) && !info->nointerp)
9864 {
9865 s = bfd_get_linker_section (dynobj, ".interp");
9866 if (s == NULL)
9867 abort ();
9868 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
9869 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
9870 }
9871 }
9872
9873 /* Set up .got offsets for local syms, and space for local dynamic
9874 relocs. */
9875 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
9876 {
9877 struct got_entry **lgot_ents;
9878 struct got_entry **end_lgot_ents;
9879 struct plt_entry **local_plt;
9880 struct plt_entry **end_local_plt;
9881 unsigned char *lgot_masks;
9882 bfd_size_type locsymcount;
9883 Elf_Internal_Shdr *symtab_hdr;
9884
9885 if (!is_ppc64_elf (ibfd))
9886 continue;
9887
9888 for (s = ibfd->sections; s != NULL; s = s->next)
9889 {
9890 struct ppc_dyn_relocs *p;
9891
9892 for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
9893 {
9894 if (!bfd_is_abs_section (p->sec)
9895 && bfd_is_abs_section (p->sec->output_section))
9896 {
9897 /* Input section has been discarded, either because
9898 it is a copy of a linkonce section or due to
9899 linker script /DISCARD/, so we'll be discarding
9900 the relocs too. */
9901 }
9902 else if (p->count != 0)
9903 {
9904 asection *srel = elf_section_data (p->sec)->sreloc;
9905 if (p->ifunc)
9906 srel = htab->elf.irelplt;
9907 srel->size += p->count * sizeof (Elf64_External_Rela);
9908 if ((p->sec->output_section->flags & SEC_READONLY) != 0)
9909 info->flags |= DF_TEXTREL;
9910 }
9911 }
9912 }
9913
9914 lgot_ents = elf_local_got_ents (ibfd);
9915 if (!lgot_ents)
9916 continue;
9917
9918 symtab_hdr = &elf_symtab_hdr (ibfd);
9919 locsymcount = symtab_hdr->sh_info;
9920 end_lgot_ents = lgot_ents + locsymcount;
9921 local_plt = (struct plt_entry **) end_lgot_ents;
9922 end_local_plt = local_plt + locsymcount;
9923 lgot_masks = (unsigned char *) end_local_plt;
9924 s = ppc64_elf_tdata (ibfd)->got;
9925 for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
9926 {
9927 struct got_entry **pent, *ent;
9928
9929 pent = lgot_ents;
9930 while ((ent = *pent) != NULL)
9931 if (ent->got.refcount > 0)
9932 {
9933 if ((ent->tls_type & *lgot_masks & TLS_LD) != 0)
9934 {
9935 ppc64_tlsld_got (ibfd)->got.refcount += 1;
9936 *pent = ent->next;
9937 }
9938 else
9939 {
9940 unsigned int ent_size = 8;
9941 unsigned int rel_size = sizeof (Elf64_External_Rela);
9942
9943 ent->got.offset = s->size;
9944 if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
9945 {
9946 ent_size *= 2;
9947 rel_size *= 2;
9948 }
9949 s->size += ent_size;
9950 if ((*lgot_masks & PLT_IFUNC) != 0)
9951 {
9952 htab->elf.irelplt->size += rel_size;
9953 htab->got_reli_size += rel_size;
9954 }
9955 else if (bfd_link_pic (info))
9956 {
9957 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
9958 srel->size += rel_size;
9959 }
9960 pent = &ent->next;
9961 }
9962 }
9963 else
9964 *pent = ent->next;
9965 }
9966
9967 /* Allocate space for calls to local STT_GNU_IFUNC syms in .iplt. */
9968 for (; local_plt < end_local_plt; ++local_plt)
9969 {
9970 struct plt_entry *ent;
9971
9972 for (ent = *local_plt; ent != NULL; ent = ent->next)
9973 if (ent->plt.refcount > 0)
9974 {
9975 s = htab->elf.iplt;
9976 ent->plt.offset = s->size;
9977 s->size += PLT_ENTRY_SIZE (htab);
9978
9979 htab->elf.irelplt->size += sizeof (Elf64_External_Rela);
9980 }
9981 else
9982 ent->plt.offset = (bfd_vma) -1;
9983 }
9984 }
9985
9986 /* Allocate global sym .plt and .got entries, and space for global
9987 sym dynamic relocs. */
9988 elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, info);
9989 /* Stash the end of glink branch table. */
9990 if (htab->glink != NULL)
9991 htab->glink->rawsize = htab->glink->size;
9992
9993 if (!htab->opd_abi && !bfd_link_pic (info))
9994 elf_link_hash_traverse (&htab->elf, size_global_entry_stubs, info);
9995
9996 first_tlsld = NULL;
9997 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
9998 {
9999 struct got_entry *ent;
10000
10001 if (!is_ppc64_elf (ibfd))
10002 continue;
10003
10004 ent = ppc64_tlsld_got (ibfd);
10005 if (ent->got.refcount > 0)
10006 {
10007 if (!htab->do_multi_toc && first_tlsld != NULL)
10008 {
10009 ent->is_indirect = TRUE;
10010 ent->got.ent = first_tlsld;
10011 }
10012 else
10013 {
10014 if (first_tlsld == NULL)
10015 first_tlsld = ent;
10016 s = ppc64_elf_tdata (ibfd)->got;
10017 ent->got.offset = s->size;
10018 ent->owner = ibfd;
10019 s->size += 16;
10020 if (bfd_link_pic (info))
10021 {
10022 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
10023 srel->size += sizeof (Elf64_External_Rela);
10024 }
10025 }
10026 }
10027 else
10028 ent->got.offset = (bfd_vma) -1;
10029 }
10030
10031 /* We now have determined the sizes of the various dynamic sections.
10032 Allocate memory for them. */
10033 relocs = FALSE;
10034 for (s = dynobj->sections; s != NULL; s = s->next)
10035 {
10036 if ((s->flags & SEC_LINKER_CREATED) == 0)
10037 continue;
10038
10039 if (s == htab->brlt || s == htab->relbrlt)
10040 /* These haven't been allocated yet; don't strip. */
10041 continue;
10042 else if (s == htab->elf.sgot
10043 || s == htab->elf.splt
10044 || s == htab->elf.iplt
10045 || s == htab->glink
10046 || s == htab->dynbss)
10047 {
10048 /* Strip this section if we don't need it; see the
10049 comment below. */
10050 }
10051 else if (s == htab->glink_eh_frame)
10052 {
10053 if (!bfd_is_abs_section (s->output_section))
10054 /* Not sized yet. */
10055 continue;
10056 }
10057 else if (CONST_STRNEQ (s->name, ".rela"))
10058 {
10059 if (s->size != 0)
10060 {
10061 if (s != htab->elf.srelplt)
10062 relocs = TRUE;
10063
10064 /* We use the reloc_count field as a counter if we need
10065 to copy relocs into the output file. */
10066 s->reloc_count = 0;
10067 }
10068 }
10069 else
10070 {
10071 /* It's not one of our sections, so don't allocate space. */
10072 continue;
10073 }
10074
10075 if (s->size == 0)
10076 {
10077 /* If we don't need this section, strip it from the
10078 output file. This is mostly to handle .rela.bss and
10079 .rela.plt. We must create both sections in
10080 create_dynamic_sections, because they must be created
10081 before the linker maps input sections to output
10082 sections. The linker does that before
10083 adjust_dynamic_symbol is called, and it is that
10084 function which decides whether anything needs to go
10085 into these sections. */
10086 s->flags |= SEC_EXCLUDE;
10087 continue;
10088 }
10089
10090 if ((s->flags & SEC_HAS_CONTENTS) == 0)
10091 continue;
10092
10093 /* Allocate memory for the section contents. We use bfd_zalloc
10094 here in case unused entries are not reclaimed before the
10095 section's contents are written out. This should not happen,
10096 but this way if it does we get a R_PPC64_NONE reloc in .rela
10097 sections instead of garbage.
10098 We also rely on the section contents being zero when writing
10099 the GOT. */
10100 s->contents = bfd_zalloc (dynobj, s->size);
10101 if (s->contents == NULL)
10102 return FALSE;
10103 }
10104
10105 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
10106 {
10107 if (!is_ppc64_elf (ibfd))
10108 continue;
10109
10110 s = ppc64_elf_tdata (ibfd)->got;
10111 if (s != NULL && s != htab->elf.sgot)
10112 {
10113 if (s->size == 0)
10114 s->flags |= SEC_EXCLUDE;
10115 else
10116 {
10117 s->contents = bfd_zalloc (ibfd, s->size);
10118 if (s->contents == NULL)
10119 return FALSE;
10120 }
10121 }
10122 s = ppc64_elf_tdata (ibfd)->relgot;
10123 if (s != NULL)
10124 {
10125 if (s->size == 0)
10126 s->flags |= SEC_EXCLUDE;
10127 else
10128 {
10129 s->contents = bfd_zalloc (ibfd, s->size);
10130 if (s->contents == NULL)
10131 return FALSE;
10132 relocs = TRUE;
10133 s->reloc_count = 0;
10134 }
10135 }
10136 }
10137
10138 if (htab->elf.dynamic_sections_created)
10139 {
10140 bfd_boolean tls_opt;
10141
10142 /* Add some entries to the .dynamic section. We fill in the
10143 values later, in ppc64_elf_finish_dynamic_sections, but we
10144 must add the entries now so that we get the correct size for
10145 the .dynamic section. The DT_DEBUG entry is filled in by the
10146 dynamic linker and used by the debugger. */
10147 #define add_dynamic_entry(TAG, VAL) \
10148 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
10149
10150 if (bfd_link_executable (info))
10151 {
10152 if (!add_dynamic_entry (DT_DEBUG, 0))
10153 return FALSE;
10154 }
10155
10156 if (htab->elf.splt != NULL && htab->elf.splt->size != 0)
10157 {
10158 if (!add_dynamic_entry (DT_PLTGOT, 0)
10159 || !add_dynamic_entry (DT_PLTRELSZ, 0)
10160 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
10161 || !add_dynamic_entry (DT_JMPREL, 0)
10162 || !add_dynamic_entry (DT_PPC64_GLINK, 0))
10163 return FALSE;
10164 }
10165
10166 if (NO_OPD_RELOCS && abiversion (output_bfd) <= 1)
10167 {
10168 if (!add_dynamic_entry (DT_PPC64_OPD, 0)
10169 || !add_dynamic_entry (DT_PPC64_OPDSZ, 0))
10170 return FALSE;
10171 }
10172
10173 tls_opt = (htab->params->tls_get_addr_opt
10174 && htab->tls_get_addr_fd != NULL
10175 && htab->tls_get_addr_fd->elf.plt.plist != NULL);
10176 if (tls_opt || !htab->opd_abi)
10177 {
10178 if (!add_dynamic_entry (DT_PPC64_OPT, tls_opt ? PPC64_OPT_TLS : 0))
10179 return FALSE;
10180 }
10181
10182 if (relocs)
10183 {
10184 if (!add_dynamic_entry (DT_RELA, 0)
10185 || !add_dynamic_entry (DT_RELASZ, 0)
10186 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
10187 return FALSE;
10188
10189 /* If any dynamic relocs apply to a read-only section,
10190 then we need a DT_TEXTREL entry. */
10191 if ((info->flags & DF_TEXTREL) == 0)
10192 elf_link_hash_traverse (&htab->elf, maybe_set_textrel, info);
10193
10194 if ((info->flags & DF_TEXTREL) != 0)
10195 {
10196 if (!add_dynamic_entry (DT_TEXTREL, 0))
10197 return FALSE;
10198 }
10199 }
10200 }
10201 #undef add_dynamic_entry
10202
10203 return TRUE;
10204 }
10205
10206 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
10207
10208 static bfd_boolean
10209 ppc64_elf_hash_symbol (struct elf_link_hash_entry *h)
10210 {
10211 if (h->plt.plist != NULL
10212 && !h->def_regular
10213 && !h->pointer_equality_needed)
10214 return FALSE;
10215
10216 return _bfd_elf_hash_symbol (h);
10217 }
10218
10219 /* Determine the type of stub needed, if any, for a call. */
10220
10221 static inline enum ppc_stub_type
10222 ppc_type_of_stub (asection *input_sec,
10223 const Elf_Internal_Rela *rel,
10224 struct ppc_link_hash_entry **hash,
10225 struct plt_entry **plt_ent,
10226 bfd_vma destination,
10227 unsigned long local_off)
10228 {
10229 struct ppc_link_hash_entry *h = *hash;
10230 bfd_vma location;
10231 bfd_vma branch_offset;
10232 bfd_vma max_branch_offset;
10233 enum elf_ppc64_reloc_type r_type;
10234
10235 if (h != NULL)
10236 {
10237 struct plt_entry *ent;
10238 struct ppc_link_hash_entry *fdh = h;
10239 if (h->oh != NULL
10240 && h->oh->is_func_descriptor)
10241 {
10242 fdh = ppc_follow_link (h->oh);
10243 *hash = fdh;
10244 }
10245
10246 for (ent = fdh->elf.plt.plist; ent != NULL; ent = ent->next)
10247 if (ent->addend == rel->r_addend
10248 && ent->plt.offset != (bfd_vma) -1)
10249 {
10250 *plt_ent = ent;
10251 return ppc_stub_plt_call;
10252 }
10253
10254 /* Here, we know we don't have a plt entry. If we don't have a
10255 either a defined function descriptor or a defined entry symbol
10256 in a regular object file, then it is pointless trying to make
10257 any other type of stub. */
10258 if (!is_static_defined (&fdh->elf)
10259 && !is_static_defined (&h->elf))
10260 return ppc_stub_none;
10261 }
10262 else if (elf_local_got_ents (input_sec->owner) != NULL)
10263 {
10264 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (input_sec->owner);
10265 struct plt_entry **local_plt = (struct plt_entry **)
10266 elf_local_got_ents (input_sec->owner) + symtab_hdr->sh_info;
10267 unsigned long r_symndx = ELF64_R_SYM (rel->r_info);
10268
10269 if (local_plt[r_symndx] != NULL)
10270 {
10271 struct plt_entry *ent;
10272
10273 for (ent = local_plt[r_symndx]; ent != NULL; ent = ent->next)
10274 if (ent->addend == rel->r_addend
10275 && ent->plt.offset != (bfd_vma) -1)
10276 {
10277 *plt_ent = ent;
10278 return ppc_stub_plt_call;
10279 }
10280 }
10281 }
10282
10283 /* Determine where the call point is. */
10284 location = (input_sec->output_offset
10285 + input_sec->output_section->vma
10286 + rel->r_offset);
10287
10288 branch_offset = destination - location;
10289 r_type = ELF64_R_TYPE (rel->r_info);
10290
10291 /* Determine if a long branch stub is needed. */
10292 max_branch_offset = 1 << 25;
10293 if (r_type != R_PPC64_REL24)
10294 max_branch_offset = 1 << 15;
10295
10296 if (branch_offset + max_branch_offset >= 2 * max_branch_offset - local_off)
10297 /* We need a stub. Figure out whether a long_branch or plt_branch
10298 is needed later. */
10299 return ppc_stub_long_branch;
10300
10301 return ppc_stub_none;
10302 }
10303
10304 /* With power7 weakly ordered memory model, it is possible for ld.so
10305 to update a plt entry in one thread and have another thread see a
10306 stale zero toc entry. To avoid this we need some sort of acquire
10307 barrier in the call stub. One solution is to make the load of the
10308 toc word seem to appear to depend on the load of the function entry
10309 word. Another solution is to test for r2 being zero, and branch to
10310 the appropriate glink entry if so.
10311
10312 . fake dep barrier compare
10313 . ld 12,xxx(2) ld 12,xxx(2)
10314 . mtctr 12 mtctr 12
10315 . xor 11,12,12 ld 2,xxx+8(2)
10316 . add 2,2,11 cmpldi 2,0
10317 . ld 2,xxx+8(2) bnectr+
10318 . bctr b <glink_entry>
10319
10320 The solution involving the compare turns out to be faster, so
10321 that's what we use unless the branch won't reach. */
10322
10323 #define ALWAYS_USE_FAKE_DEP 0
10324 #define ALWAYS_EMIT_R2SAVE 0
10325
10326 #define PPC_LO(v) ((v) & 0xffff)
10327 #define PPC_HI(v) (((v) >> 16) & 0xffff)
10328 #define PPC_HA(v) PPC_HI ((v) + 0x8000)
10329
10330 static inline unsigned int
10331 plt_stub_size (struct ppc_link_hash_table *htab,
10332 struct ppc_stub_hash_entry *stub_entry,
10333 bfd_vma off)
10334 {
10335 unsigned size = 12;
10336
10337 if (ALWAYS_EMIT_R2SAVE
10338 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10339 size += 4;
10340 if (PPC_HA (off) != 0)
10341 size += 4;
10342 if (htab->opd_abi)
10343 {
10344 size += 4;
10345 if (htab->params->plt_static_chain)
10346 size += 4;
10347 if (htab->params->plt_thread_safe
10348 && htab->elf.dynamic_sections_created
10349 && stub_entry->h != NULL
10350 && stub_entry->h->elf.dynindx != -1)
10351 size += 8;
10352 if (PPC_HA (off + 8 + 8 * htab->params->plt_static_chain) != PPC_HA (off))
10353 size += 4;
10354 }
10355 if (stub_entry->h != NULL
10356 && (stub_entry->h == htab->tls_get_addr_fd
10357 || stub_entry->h == htab->tls_get_addr)
10358 && htab->params->tls_get_addr_opt)
10359 size += 13 * 4;
10360 return size;
10361 }
10362
10363 /* If this stub would cross fewer 2**plt_stub_align boundaries if we align,
10364 then return the padding needed to do so. */
10365 static inline unsigned int
10366 plt_stub_pad (struct ppc_link_hash_table *htab,
10367 struct ppc_stub_hash_entry *stub_entry,
10368 bfd_vma plt_off)
10369 {
10370 int stub_align = 1 << htab->params->plt_stub_align;
10371 unsigned stub_size = plt_stub_size (htab, stub_entry, plt_off);
10372 bfd_vma stub_off = stub_entry->group->stub_sec->size;
10373
10374 if (((stub_off + stub_size - 1) & -stub_align) - (stub_off & -stub_align)
10375 > ((stub_size - 1) & -stub_align))
10376 return stub_align - (stub_off & (stub_align - 1));
10377 return 0;
10378 }
10379
10380 /* Build a .plt call stub. */
10381
10382 static inline bfd_byte *
10383 build_plt_stub (struct ppc_link_hash_table *htab,
10384 struct ppc_stub_hash_entry *stub_entry,
10385 bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
10386 {
10387 bfd *obfd = htab->params->stub_bfd;
10388 bfd_boolean plt_load_toc = htab->opd_abi;
10389 bfd_boolean plt_static_chain = htab->params->plt_static_chain;
10390 bfd_boolean plt_thread_safe = (htab->params->plt_thread_safe
10391 && htab->elf.dynamic_sections_created
10392 && stub_entry->h != NULL
10393 && stub_entry->h->elf.dynindx != -1);
10394 bfd_boolean use_fake_dep = plt_thread_safe;
10395 bfd_vma cmp_branch_off = 0;
10396
10397 if (!ALWAYS_USE_FAKE_DEP
10398 && plt_load_toc
10399 && plt_thread_safe
10400 && !((stub_entry->h == htab->tls_get_addr_fd
10401 || stub_entry->h == htab->tls_get_addr)
10402 && htab->params->tls_get_addr_opt))
10403 {
10404 bfd_vma pltoff = stub_entry->plt_ent->plt.offset & ~1;
10405 bfd_vma pltindex = ((pltoff - PLT_INITIAL_ENTRY_SIZE (htab))
10406 / PLT_ENTRY_SIZE (htab));
10407 bfd_vma glinkoff = GLINK_CALL_STUB_SIZE + pltindex * 8;
10408 bfd_vma to, from;
10409
10410 if (pltindex > 32768)
10411 glinkoff += (pltindex - 32768) * 4;
10412 to = (glinkoff
10413 + htab->glink->output_offset
10414 + htab->glink->output_section->vma);
10415 from = (p - stub_entry->group->stub_sec->contents
10416 + 4 * (ALWAYS_EMIT_R2SAVE
10417 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10418 + 4 * (PPC_HA (offset) != 0)
10419 + 4 * (PPC_HA (offset + 8 + 8 * plt_static_chain)
10420 != PPC_HA (offset))
10421 + 4 * (plt_static_chain != 0)
10422 + 20
10423 + stub_entry->group->stub_sec->output_offset
10424 + stub_entry->group->stub_sec->output_section->vma);
10425 cmp_branch_off = to - from;
10426 use_fake_dep = cmp_branch_off + (1 << 25) >= (1 << 26);
10427 }
10428
10429 if (PPC_HA (offset) != 0)
10430 {
10431 if (r != NULL)
10432 {
10433 if (ALWAYS_EMIT_R2SAVE
10434 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10435 r[0].r_offset += 4;
10436 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
10437 r[1].r_offset = r[0].r_offset + 4;
10438 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10439 r[1].r_addend = r[0].r_addend;
10440 if (plt_load_toc)
10441 {
10442 if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10443 {
10444 r[2].r_offset = r[1].r_offset + 4;
10445 r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO);
10446 r[2].r_addend = r[0].r_addend;
10447 }
10448 else
10449 {
10450 r[2].r_offset = r[1].r_offset + 8 + 8 * use_fake_dep;
10451 r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10452 r[2].r_addend = r[0].r_addend + 8;
10453 if (plt_static_chain)
10454 {
10455 r[3].r_offset = r[2].r_offset + 4;
10456 r[3].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10457 r[3].r_addend = r[0].r_addend + 16;
10458 }
10459 }
10460 }
10461 }
10462 if (ALWAYS_EMIT_R2SAVE
10463 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10464 bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p), p += 4;
10465 if (plt_load_toc)
10466 {
10467 bfd_put_32 (obfd, ADDIS_R11_R2 | PPC_HA (offset), p), p += 4;
10468 bfd_put_32 (obfd, LD_R12_0R11 | PPC_LO (offset), p), p += 4;
10469 }
10470 else
10471 {
10472 bfd_put_32 (obfd, ADDIS_R12_R2 | PPC_HA (offset), p), p += 4;
10473 bfd_put_32 (obfd, LD_R12_0R12 | PPC_LO (offset), p), p += 4;
10474 }
10475 if (plt_load_toc
10476 && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10477 {
10478 bfd_put_32 (obfd, ADDI_R11_R11 | PPC_LO (offset), p), p += 4;
10479 offset = 0;
10480 }
10481 bfd_put_32 (obfd, MTCTR_R12, p), p += 4;
10482 if (plt_load_toc)
10483 {
10484 if (use_fake_dep)
10485 {
10486 bfd_put_32 (obfd, XOR_R2_R12_R12, p), p += 4;
10487 bfd_put_32 (obfd, ADD_R11_R11_R2, p), p += 4;
10488 }
10489 bfd_put_32 (obfd, LD_R2_0R11 | PPC_LO (offset + 8), p), p += 4;
10490 if (plt_static_chain)
10491 bfd_put_32 (obfd, LD_R11_0R11 | PPC_LO (offset + 16), p), p += 4;
10492 }
10493 }
10494 else
10495 {
10496 if (r != NULL)
10497 {
10498 if (ALWAYS_EMIT_R2SAVE
10499 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10500 r[0].r_offset += 4;
10501 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10502 if (plt_load_toc)
10503 {
10504 if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10505 {
10506 r[1].r_offset = r[0].r_offset + 4;
10507 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16);
10508 r[1].r_addend = r[0].r_addend;
10509 }
10510 else
10511 {
10512 r[1].r_offset = r[0].r_offset + 8 + 8 * use_fake_dep;
10513 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10514 r[1].r_addend = r[0].r_addend + 8 + 8 * plt_static_chain;
10515 if (plt_static_chain)
10516 {
10517 r[2].r_offset = r[1].r_offset + 4;
10518 r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10519 r[2].r_addend = r[0].r_addend + 8;
10520 }
10521 }
10522 }
10523 }
10524 if (ALWAYS_EMIT_R2SAVE
10525 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10526 bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p), p += 4;
10527 bfd_put_32 (obfd, LD_R12_0R2 | PPC_LO (offset), p), p += 4;
10528 if (plt_load_toc
10529 && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10530 {
10531 bfd_put_32 (obfd, ADDI_R2_R2 | PPC_LO (offset), p), p += 4;
10532 offset = 0;
10533 }
10534 bfd_put_32 (obfd, MTCTR_R12, p), p += 4;
10535 if (plt_load_toc)
10536 {
10537 if (use_fake_dep)
10538 {
10539 bfd_put_32 (obfd, XOR_R11_R12_R12, p), p += 4;
10540 bfd_put_32 (obfd, ADD_R2_R2_R11, p), p += 4;
10541 }
10542 if (plt_static_chain)
10543 bfd_put_32 (obfd, LD_R11_0R2 | PPC_LO (offset + 16), p), p += 4;
10544 bfd_put_32 (obfd, LD_R2_0R2 | PPC_LO (offset + 8), p), p += 4;
10545 }
10546 }
10547 if (plt_load_toc && plt_thread_safe && !use_fake_dep)
10548 {
10549 bfd_put_32 (obfd, CMPLDI_R2_0, p), p += 4;
10550 bfd_put_32 (obfd, BNECTR_P4, p), p += 4;
10551 bfd_put_32 (obfd, B_DOT | (cmp_branch_off & 0x3fffffc), p), p += 4;
10552 }
10553 else
10554 bfd_put_32 (obfd, BCTR, p), p += 4;
10555 return p;
10556 }
10557
10558 /* Build a special .plt call stub for __tls_get_addr. */
10559
10560 #define LD_R11_0R3 0xe9630000
10561 #define LD_R12_0R3 0xe9830000
10562 #define MR_R0_R3 0x7c601b78
10563 #define CMPDI_R11_0 0x2c2b0000
10564 #define ADD_R3_R12_R13 0x7c6c6a14
10565 #define BEQLR 0x4d820020
10566 #define MR_R3_R0 0x7c030378
10567 #define STD_R11_0R1 0xf9610000
10568 #define BCTRL 0x4e800421
10569 #define LD_R11_0R1 0xe9610000
10570 #define MTLR_R11 0x7d6803a6
10571
10572 static inline bfd_byte *
10573 build_tls_get_addr_stub (struct ppc_link_hash_table *htab,
10574 struct ppc_stub_hash_entry *stub_entry,
10575 bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
10576 {
10577 bfd *obfd = htab->params->stub_bfd;
10578
10579 bfd_put_32 (obfd, LD_R11_0R3 + 0, p), p += 4;
10580 bfd_put_32 (obfd, LD_R12_0R3 + 8, p), p += 4;
10581 bfd_put_32 (obfd, MR_R0_R3, p), p += 4;
10582 bfd_put_32 (obfd, CMPDI_R11_0, p), p += 4;
10583 bfd_put_32 (obfd, ADD_R3_R12_R13, p), p += 4;
10584 bfd_put_32 (obfd, BEQLR, p), p += 4;
10585 bfd_put_32 (obfd, MR_R3_R0, p), p += 4;
10586 bfd_put_32 (obfd, MFLR_R11, p), p += 4;
10587 bfd_put_32 (obfd, STD_R11_0R1 + STK_LINKER (htab), p), p += 4;
10588
10589 if (r != NULL)
10590 r[0].r_offset += 9 * 4;
10591 p = build_plt_stub (htab, stub_entry, p, offset, r);
10592 bfd_put_32 (obfd, BCTRL, p - 4);
10593
10594 bfd_put_32 (obfd, LD_R2_0R1 + STK_TOC (htab), p), p += 4;
10595 bfd_put_32 (obfd, LD_R11_0R1 + STK_LINKER (htab), p), p += 4;
10596 bfd_put_32 (obfd, MTLR_R11, p), p += 4;
10597 bfd_put_32 (obfd, BLR, p), p += 4;
10598
10599 return p;
10600 }
10601
10602 static Elf_Internal_Rela *
10603 get_relocs (asection *sec, int count)
10604 {
10605 Elf_Internal_Rela *relocs;
10606 struct bfd_elf_section_data *elfsec_data;
10607
10608 elfsec_data = elf_section_data (sec);
10609 relocs = elfsec_data->relocs;
10610 if (relocs == NULL)
10611 {
10612 bfd_size_type relsize;
10613 relsize = sec->reloc_count * sizeof (*relocs);
10614 relocs = bfd_alloc (sec->owner, relsize);
10615 if (relocs == NULL)
10616 return NULL;
10617 elfsec_data->relocs = relocs;
10618 elfsec_data->rela.hdr = bfd_zalloc (sec->owner,
10619 sizeof (Elf_Internal_Shdr));
10620 if (elfsec_data->rela.hdr == NULL)
10621 return NULL;
10622 elfsec_data->rela.hdr->sh_size = (sec->reloc_count
10623 * sizeof (Elf64_External_Rela));
10624 elfsec_data->rela.hdr->sh_entsize = sizeof (Elf64_External_Rela);
10625 sec->reloc_count = 0;
10626 }
10627 relocs += sec->reloc_count;
10628 sec->reloc_count += count;
10629 return relocs;
10630 }
10631
10632 static bfd_vma
10633 get_r2off (struct bfd_link_info *info,
10634 struct ppc_stub_hash_entry *stub_entry)
10635 {
10636 struct ppc_link_hash_table *htab = ppc_hash_table (info);
10637 bfd_vma r2off = htab->sec_info[stub_entry->target_section->id].toc_off;
10638
10639 if (r2off == 0)
10640 {
10641 /* Support linking -R objects. Get the toc pointer from the
10642 opd entry. */
10643 char buf[8];
10644 if (!htab->opd_abi)
10645 return r2off;
10646 asection *opd = stub_entry->h->elf.root.u.def.section;
10647 bfd_vma opd_off = stub_entry->h->elf.root.u.def.value;
10648
10649 if (strcmp (opd->name, ".opd") != 0
10650 || opd->reloc_count != 0)
10651 {
10652 info->callbacks->einfo (_("%P: cannot find opd entry toc for `%T'\n"),
10653 stub_entry->h->elf.root.root.string);
10654 bfd_set_error (bfd_error_bad_value);
10655 return (bfd_vma) -1;
10656 }
10657 if (!bfd_get_section_contents (opd->owner, opd, buf, opd_off + 8, 8))
10658 return (bfd_vma) -1;
10659 r2off = bfd_get_64 (opd->owner, buf);
10660 r2off -= elf_gp (info->output_bfd);
10661 }
10662 r2off -= htab->sec_info[stub_entry->group->link_sec->id].toc_off;
10663 return r2off;
10664 }
10665
10666 static bfd_boolean
10667 ppc_build_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
10668 {
10669 struct ppc_stub_hash_entry *stub_entry;
10670 struct ppc_branch_hash_entry *br_entry;
10671 struct bfd_link_info *info;
10672 struct ppc_link_hash_table *htab;
10673 bfd_byte *loc;
10674 bfd_byte *p;
10675 bfd_vma dest, off;
10676 int size;
10677 Elf_Internal_Rela *r;
10678 asection *plt;
10679
10680 /* Massage our args to the form they really have. */
10681 stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
10682 info = in_arg;
10683
10684 htab = ppc_hash_table (info);
10685 if (htab == NULL)
10686 return FALSE;
10687
10688 /* Make a note of the offset within the stubs for this entry. */
10689 stub_entry->stub_offset = stub_entry->group->stub_sec->size;
10690 loc = stub_entry->group->stub_sec->contents + stub_entry->stub_offset;
10691
10692 htab->stub_count[stub_entry->stub_type - 1] += 1;
10693 switch (stub_entry->stub_type)
10694 {
10695 case ppc_stub_long_branch:
10696 case ppc_stub_long_branch_r2off:
10697 /* Branches are relative. This is where we are going to. */
10698 dest = (stub_entry->target_value
10699 + stub_entry->target_section->output_offset
10700 + stub_entry->target_section->output_section->vma);
10701 dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
10702 off = dest;
10703
10704 /* And this is where we are coming from. */
10705 off -= (stub_entry->stub_offset
10706 + stub_entry->group->stub_sec->output_offset
10707 + stub_entry->group->stub_sec->output_section->vma);
10708
10709 size = 4;
10710 if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
10711 {
10712 bfd_vma r2off = get_r2off (info, stub_entry);
10713
10714 if (r2off == (bfd_vma) -1)
10715 {
10716 htab->stub_error = TRUE;
10717 return FALSE;
10718 }
10719 bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), loc);
10720 loc += 4;
10721 size = 8;
10722 if (PPC_HA (r2off) != 0)
10723 {
10724 bfd_put_32 (htab->params->stub_bfd,
10725 ADDIS_R2_R2 | PPC_HA (r2off), loc);
10726 loc += 4;
10727 size += 4;
10728 }
10729 if (PPC_LO (r2off) != 0)
10730 {
10731 bfd_put_32 (htab->params->stub_bfd,
10732 ADDI_R2_R2 | PPC_LO (r2off), loc);
10733 loc += 4;
10734 size += 4;
10735 }
10736 off -= size - 4;
10737 }
10738 bfd_put_32 (htab->params->stub_bfd, B_DOT | (off & 0x3fffffc), loc);
10739
10740 if (off + (1 << 25) >= (bfd_vma) (1 << 26))
10741 {
10742 info->callbacks->einfo
10743 (_("%P: long branch stub `%s' offset overflow\n"),
10744 stub_entry->root.string);
10745 htab->stub_error = TRUE;
10746 return FALSE;
10747 }
10748
10749 if (info->emitrelocations)
10750 {
10751 r = get_relocs (stub_entry->group->stub_sec, 1);
10752 if (r == NULL)
10753 return FALSE;
10754 r->r_offset = loc - stub_entry->group->stub_sec->contents;
10755 r->r_info = ELF64_R_INFO (0, R_PPC64_REL24);
10756 r->r_addend = dest;
10757 if (stub_entry->h != NULL)
10758 {
10759 struct elf_link_hash_entry **hashes;
10760 unsigned long symndx;
10761 struct ppc_link_hash_entry *h;
10762
10763 hashes = elf_sym_hashes (htab->params->stub_bfd);
10764 if (hashes == NULL)
10765 {
10766 bfd_size_type hsize;
10767
10768 hsize = (htab->stub_globals + 1) * sizeof (*hashes);
10769 hashes = bfd_zalloc (htab->params->stub_bfd, hsize);
10770 if (hashes == NULL)
10771 return FALSE;
10772 elf_sym_hashes (htab->params->stub_bfd) = hashes;
10773 htab->stub_globals = 1;
10774 }
10775 symndx = htab->stub_globals++;
10776 h = stub_entry->h;
10777 hashes[symndx] = &h->elf;
10778 r->r_info = ELF64_R_INFO (symndx, R_PPC64_REL24);
10779 if (h->oh != NULL && h->oh->is_func)
10780 h = ppc_follow_link (h->oh);
10781 if (h->elf.root.u.def.section != stub_entry->target_section)
10782 /* H is an opd symbol. The addend must be zero. */
10783 r->r_addend = 0;
10784 else
10785 {
10786 off = (h->elf.root.u.def.value
10787 + h->elf.root.u.def.section->output_offset
10788 + h->elf.root.u.def.section->output_section->vma);
10789 r->r_addend -= off;
10790 }
10791 }
10792 }
10793 break;
10794
10795 case ppc_stub_plt_branch:
10796 case ppc_stub_plt_branch_r2off:
10797 br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
10798 stub_entry->root.string + 9,
10799 FALSE, FALSE);
10800 if (br_entry == NULL)
10801 {
10802 info->callbacks->einfo (_("%P: can't find branch stub `%s'\n"),
10803 stub_entry->root.string);
10804 htab->stub_error = TRUE;
10805 return FALSE;
10806 }
10807
10808 dest = (stub_entry->target_value
10809 + stub_entry->target_section->output_offset
10810 + stub_entry->target_section->output_section->vma);
10811 if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
10812 dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
10813
10814 bfd_put_64 (htab->brlt->owner, dest,
10815 htab->brlt->contents + br_entry->offset);
10816
10817 if (br_entry->iter == htab->stub_iteration)
10818 {
10819 br_entry->iter = 0;
10820
10821 if (htab->relbrlt != NULL)
10822 {
10823 /* Create a reloc for the branch lookup table entry. */
10824 Elf_Internal_Rela rela;
10825 bfd_byte *rl;
10826
10827 rela.r_offset = (br_entry->offset
10828 + htab->brlt->output_offset
10829 + htab->brlt->output_section->vma);
10830 rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
10831 rela.r_addend = dest;
10832
10833 rl = htab->relbrlt->contents;
10834 rl += (htab->relbrlt->reloc_count++
10835 * sizeof (Elf64_External_Rela));
10836 bfd_elf64_swap_reloca_out (htab->relbrlt->owner, &rela, rl);
10837 }
10838 else if (info->emitrelocations)
10839 {
10840 r = get_relocs (htab->brlt, 1);
10841 if (r == NULL)
10842 return FALSE;
10843 /* brlt, being SEC_LINKER_CREATED does not go through the
10844 normal reloc processing. Symbols and offsets are not
10845 translated from input file to output file form, so
10846 set up the offset per the output file. */
10847 r->r_offset = (br_entry->offset
10848 + htab->brlt->output_offset
10849 + htab->brlt->output_section->vma);
10850 r->r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
10851 r->r_addend = dest;
10852 }
10853 }
10854
10855 dest = (br_entry->offset
10856 + htab->brlt->output_offset
10857 + htab->brlt->output_section->vma);
10858
10859 off = (dest
10860 - elf_gp (htab->brlt->output_section->owner)
10861 - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
10862
10863 if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
10864 {
10865 info->callbacks->einfo
10866 (_("%P: linkage table error against `%T'\n"),
10867 stub_entry->root.string);
10868 bfd_set_error (bfd_error_bad_value);
10869 htab->stub_error = TRUE;
10870 return FALSE;
10871 }
10872
10873 if (info->emitrelocations)
10874 {
10875 r = get_relocs (stub_entry->group->stub_sec, 1 + (PPC_HA (off) != 0));
10876 if (r == NULL)
10877 return FALSE;
10878 r[0].r_offset = loc - stub_entry->group->stub_sec->contents;
10879 if (bfd_big_endian (info->output_bfd))
10880 r[0].r_offset += 2;
10881 if (stub_entry->stub_type == ppc_stub_plt_branch_r2off)
10882 r[0].r_offset += 4;
10883 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10884 r[0].r_addend = dest;
10885 if (PPC_HA (off) != 0)
10886 {
10887 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
10888 r[1].r_offset = r[0].r_offset + 4;
10889 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10890 r[1].r_addend = r[0].r_addend;
10891 }
10892 }
10893
10894 if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
10895 {
10896 if (PPC_HA (off) != 0)
10897 {
10898 size = 16;
10899 bfd_put_32 (htab->params->stub_bfd,
10900 ADDIS_R12_R2 | PPC_HA (off), loc);
10901 loc += 4;
10902 bfd_put_32 (htab->params->stub_bfd,
10903 LD_R12_0R12 | PPC_LO (off), loc);
10904 }
10905 else
10906 {
10907 size = 12;
10908 bfd_put_32 (htab->params->stub_bfd,
10909 LD_R12_0R2 | PPC_LO (off), loc);
10910 }
10911 }
10912 else
10913 {
10914 bfd_vma r2off = get_r2off (info, stub_entry);
10915
10916 if (r2off == (bfd_vma) -1)
10917 {
10918 htab->stub_error = TRUE;
10919 return FALSE;
10920 }
10921
10922 bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), loc);
10923 loc += 4;
10924 size = 16;
10925 if (PPC_HA (off) != 0)
10926 {
10927 size += 4;
10928 bfd_put_32 (htab->params->stub_bfd,
10929 ADDIS_R12_R2 | PPC_HA (off), loc);
10930 loc += 4;
10931 bfd_put_32 (htab->params->stub_bfd,
10932 LD_R12_0R12 | PPC_LO (off), loc);
10933 }
10934 else
10935 bfd_put_32 (htab->params->stub_bfd, LD_R12_0R2 | PPC_LO (off), loc);
10936
10937 if (PPC_HA (r2off) != 0)
10938 {
10939 size += 4;
10940 loc += 4;
10941 bfd_put_32 (htab->params->stub_bfd,
10942 ADDIS_R2_R2 | PPC_HA (r2off), loc);
10943 }
10944 if (PPC_LO (r2off) != 0)
10945 {
10946 size += 4;
10947 loc += 4;
10948 bfd_put_32 (htab->params->stub_bfd,
10949 ADDI_R2_R2 | PPC_LO (r2off), loc);
10950 }
10951 }
10952 loc += 4;
10953 bfd_put_32 (htab->params->stub_bfd, MTCTR_R12, loc);
10954 loc += 4;
10955 bfd_put_32 (htab->params->stub_bfd, BCTR, loc);
10956 break;
10957
10958 case ppc_stub_plt_call:
10959 case ppc_stub_plt_call_r2save:
10960 if (stub_entry->h != NULL
10961 && stub_entry->h->is_func_descriptor
10962 && stub_entry->h->oh != NULL)
10963 {
10964 struct ppc_link_hash_entry *fh = ppc_follow_link (stub_entry->h->oh);
10965
10966 /* If the old-ABI "dot-symbol" is undefined make it weak so
10967 we don't get a link error from RELOC_FOR_GLOBAL_SYMBOL. */
10968 if (fh->elf.root.type == bfd_link_hash_undefined)
10969 fh->elf.root.type = bfd_link_hash_undefweak;
10970 /* Stop undo_symbol_twiddle changing it back to undefined. */
10971 fh->was_undefined = 0;
10972 }
10973
10974 /* Now build the stub. */
10975 dest = stub_entry->plt_ent->plt.offset & ~1;
10976 if (dest >= (bfd_vma) -2)
10977 abort ();
10978
10979 plt = htab->elf.splt;
10980 if (!htab->elf.dynamic_sections_created
10981 || stub_entry->h == NULL
10982 || stub_entry->h->elf.dynindx == -1)
10983 plt = htab->elf.iplt;
10984
10985 dest += plt->output_offset + plt->output_section->vma;
10986
10987 if (stub_entry->h == NULL
10988 && (stub_entry->plt_ent->plt.offset & 1) == 0)
10989 {
10990 Elf_Internal_Rela rela;
10991 bfd_byte *rl;
10992
10993 rela.r_offset = dest;
10994 if (htab->opd_abi)
10995 rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
10996 else
10997 rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
10998 rela.r_addend = (stub_entry->target_value
10999 + stub_entry->target_section->output_offset
11000 + stub_entry->target_section->output_section->vma);
11001
11002 rl = (htab->elf.irelplt->contents
11003 + (htab->elf.irelplt->reloc_count++
11004 * sizeof (Elf64_External_Rela)));
11005 bfd_elf64_swap_reloca_out (info->output_bfd, &rela, rl);
11006 stub_entry->plt_ent->plt.offset |= 1;
11007 }
11008
11009 off = (dest
11010 - elf_gp (plt->output_section->owner)
11011 - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11012
11013 if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
11014 {
11015 info->callbacks->einfo
11016 (_("%P: linkage table error against `%T'\n"),
11017 stub_entry->h != NULL
11018 ? stub_entry->h->elf.root.root.string
11019 : "<local sym>");
11020 bfd_set_error (bfd_error_bad_value);
11021 htab->stub_error = TRUE;
11022 return FALSE;
11023 }
11024
11025 if (htab->params->plt_stub_align != 0)
11026 {
11027 unsigned pad = plt_stub_pad (htab, stub_entry, off);
11028
11029 stub_entry->group->stub_sec->size += pad;
11030 stub_entry->stub_offset = stub_entry->group->stub_sec->size;
11031 loc += pad;
11032 }
11033
11034 r = NULL;
11035 if (info->emitrelocations)
11036 {
11037 r = get_relocs (stub_entry->group->stub_sec,
11038 ((PPC_HA (off) != 0)
11039 + (htab->opd_abi
11040 ? 2 + (htab->params->plt_static_chain
11041 && PPC_HA (off + 16) == PPC_HA (off))
11042 : 1)));
11043 if (r == NULL)
11044 return FALSE;
11045 r[0].r_offset = loc - stub_entry->group->stub_sec->contents;
11046 if (bfd_big_endian (info->output_bfd))
11047 r[0].r_offset += 2;
11048 r[0].r_addend = dest;
11049 }
11050 if (stub_entry->h != NULL
11051 && (stub_entry->h == htab->tls_get_addr_fd
11052 || stub_entry->h == htab->tls_get_addr)
11053 && htab->params->tls_get_addr_opt)
11054 p = build_tls_get_addr_stub (htab, stub_entry, loc, off, r);
11055 else
11056 p = build_plt_stub (htab, stub_entry, loc, off, r);
11057 size = p - loc;
11058 break;
11059
11060 case ppc_stub_save_res:
11061 return TRUE;
11062
11063 default:
11064 BFD_FAIL ();
11065 return FALSE;
11066 }
11067
11068 stub_entry->group->stub_sec->size += size;
11069
11070 if (htab->params->emit_stub_syms)
11071 {
11072 struct elf_link_hash_entry *h;
11073 size_t len1, len2;
11074 char *name;
11075 const char *const stub_str[] = { "long_branch",
11076 "long_branch_r2off",
11077 "plt_branch",
11078 "plt_branch_r2off",
11079 "plt_call",
11080 "plt_call" };
11081
11082 len1 = strlen (stub_str[stub_entry->stub_type - 1]);
11083 len2 = strlen (stub_entry->root.string);
11084 name = bfd_malloc (len1 + len2 + 2);
11085 if (name == NULL)
11086 return FALSE;
11087 memcpy (name, stub_entry->root.string, 9);
11088 memcpy (name + 9, stub_str[stub_entry->stub_type - 1], len1);
11089 memcpy (name + len1 + 9, stub_entry->root.string + 8, len2 - 8 + 1);
11090 h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
11091 if (h == NULL)
11092 return FALSE;
11093 if (h->root.type == bfd_link_hash_new)
11094 {
11095 h->root.type = bfd_link_hash_defined;
11096 h->root.u.def.section = stub_entry->group->stub_sec;
11097 h->root.u.def.value = stub_entry->stub_offset;
11098 h->ref_regular = 1;
11099 h->def_regular = 1;
11100 h->ref_regular_nonweak = 1;
11101 h->forced_local = 1;
11102 h->non_elf = 0;
11103 h->root.linker_def = 1;
11104 }
11105 }
11106
11107 return TRUE;
11108 }
11109
11110 /* As above, but don't actually build the stub. Just bump offset so
11111 we know stub section sizes, and select plt_branch stubs where
11112 long_branch stubs won't do. */
11113
11114 static bfd_boolean
11115 ppc_size_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
11116 {
11117 struct ppc_stub_hash_entry *stub_entry;
11118 struct bfd_link_info *info;
11119 struct ppc_link_hash_table *htab;
11120 bfd_vma off;
11121 int size;
11122
11123 /* Massage our args to the form they really have. */
11124 stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
11125 info = in_arg;
11126
11127 htab = ppc_hash_table (info);
11128 if (htab == NULL)
11129 return FALSE;
11130
11131 if (stub_entry->h != NULL
11132 && stub_entry->h->save_res
11133 && stub_entry->h->elf.root.type == bfd_link_hash_defined
11134 && stub_entry->h->elf.root.u.def.section == htab->sfpr)
11135 {
11136 /* Don't make stubs to out-of-line register save/restore
11137 functions. Instead, emit copies of the functions. */
11138 stub_entry->group->needs_save_res = 1;
11139 stub_entry->stub_type = ppc_stub_save_res;
11140 return TRUE;
11141 }
11142
11143 if (stub_entry->stub_type == ppc_stub_plt_call
11144 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
11145 {
11146 asection *plt;
11147 off = stub_entry->plt_ent->plt.offset & ~(bfd_vma) 1;
11148 if (off >= (bfd_vma) -2)
11149 abort ();
11150 plt = htab->elf.splt;
11151 if (!htab->elf.dynamic_sections_created
11152 || stub_entry->h == NULL
11153 || stub_entry->h->elf.dynindx == -1)
11154 plt = htab->elf.iplt;
11155 off += (plt->output_offset
11156 + plt->output_section->vma
11157 - elf_gp (plt->output_section->owner)
11158 - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11159
11160 size = plt_stub_size (htab, stub_entry, off);
11161 if (htab->params->plt_stub_align)
11162 size += plt_stub_pad (htab, stub_entry, off);
11163 if (info->emitrelocations)
11164 {
11165 stub_entry->group->stub_sec->reloc_count
11166 += ((PPC_HA (off) != 0)
11167 + (htab->opd_abi
11168 ? 2 + (htab->params->plt_static_chain
11169 && PPC_HA (off + 16) == PPC_HA (off))
11170 : 1));
11171 stub_entry->group->stub_sec->flags |= SEC_RELOC;
11172 }
11173 }
11174 else
11175 {
11176 /* ppc_stub_long_branch or ppc_stub_plt_branch, or their r2off
11177 variants. */
11178 bfd_vma r2off = 0;
11179 bfd_vma local_off = 0;
11180
11181 off = (stub_entry->target_value
11182 + stub_entry->target_section->output_offset
11183 + stub_entry->target_section->output_section->vma);
11184 off -= (stub_entry->group->stub_sec->size
11185 + stub_entry->group->stub_sec->output_offset
11186 + stub_entry->group->stub_sec->output_section->vma);
11187
11188 /* Reset the stub type from the plt variant in case we now
11189 can reach with a shorter stub. */
11190 if (stub_entry->stub_type >= ppc_stub_plt_branch)
11191 stub_entry->stub_type += ppc_stub_long_branch - ppc_stub_plt_branch;
11192
11193 size = 4;
11194 if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
11195 {
11196 r2off = get_r2off (info, stub_entry);
11197 if (r2off == (bfd_vma) -1)
11198 {
11199 htab->stub_error = TRUE;
11200 return FALSE;
11201 }
11202 size = 8;
11203 if (PPC_HA (r2off) != 0)
11204 size += 4;
11205 if (PPC_LO (r2off) != 0)
11206 size += 4;
11207 off -= size - 4;
11208 }
11209
11210 local_off = PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
11211
11212 /* If the branch offset if too big, use a ppc_stub_plt_branch.
11213 Do the same for -R objects without function descriptors. */
11214 if (off + (1 << 25) >= (bfd_vma) (1 << 26) - local_off
11215 || (stub_entry->stub_type == ppc_stub_long_branch_r2off
11216 && r2off == 0
11217 && htab->sec_info[stub_entry->target_section->id].toc_off == 0))
11218 {
11219 struct ppc_branch_hash_entry *br_entry;
11220
11221 br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
11222 stub_entry->root.string + 9,
11223 TRUE, FALSE);
11224 if (br_entry == NULL)
11225 {
11226 info->callbacks->einfo (_("%P: can't build branch stub `%s'\n"),
11227 stub_entry->root.string);
11228 htab->stub_error = TRUE;
11229 return FALSE;
11230 }
11231
11232 if (br_entry->iter != htab->stub_iteration)
11233 {
11234 br_entry->iter = htab->stub_iteration;
11235 br_entry->offset = htab->brlt->size;
11236 htab->brlt->size += 8;
11237
11238 if (htab->relbrlt != NULL)
11239 htab->relbrlt->size += sizeof (Elf64_External_Rela);
11240 else if (info->emitrelocations)
11241 {
11242 htab->brlt->reloc_count += 1;
11243 htab->brlt->flags |= SEC_RELOC;
11244 }
11245 }
11246
11247 stub_entry->stub_type += ppc_stub_plt_branch - ppc_stub_long_branch;
11248 off = (br_entry->offset
11249 + htab->brlt->output_offset
11250 + htab->brlt->output_section->vma
11251 - elf_gp (htab->brlt->output_section->owner)
11252 - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11253
11254 if (info->emitrelocations)
11255 {
11256 stub_entry->group->stub_sec->reloc_count
11257 += 1 + (PPC_HA (off) != 0);
11258 stub_entry->group->stub_sec->flags |= SEC_RELOC;
11259 }
11260
11261 if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
11262 {
11263 size = 12;
11264 if (PPC_HA (off) != 0)
11265 size = 16;
11266 }
11267 else
11268 {
11269 size = 16;
11270 if (PPC_HA (off) != 0)
11271 size += 4;
11272
11273 if (PPC_HA (r2off) != 0)
11274 size += 4;
11275 if (PPC_LO (r2off) != 0)
11276 size += 4;
11277 }
11278 }
11279 else if (info->emitrelocations)
11280 {
11281 stub_entry->group->stub_sec->reloc_count += 1;
11282 stub_entry->group->stub_sec->flags |= SEC_RELOC;
11283 }
11284 }
11285
11286 stub_entry->group->stub_sec->size += size;
11287 return TRUE;
11288 }
11289
11290 /* Set up various things so that we can make a list of input sections
11291 for each output section included in the link. Returns -1 on error,
11292 0 when no stubs will be needed, and 1 on success. */
11293
11294 int
11295 ppc64_elf_setup_section_lists (struct bfd_link_info *info)
11296 {
11297 unsigned int id;
11298 bfd_size_type amt;
11299 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11300
11301 if (htab == NULL)
11302 return -1;
11303
11304 htab->sec_info_arr_size = bfd_get_next_section_id ();
11305 amt = sizeof (*htab->sec_info) * (htab->sec_info_arr_size);
11306 htab->sec_info = bfd_zmalloc (amt);
11307 if (htab->sec_info == NULL)
11308 return -1;
11309
11310 /* Set toc_off for com, und, abs and ind sections. */
11311 for (id = 0; id < 3; id++)
11312 htab->sec_info[id].toc_off = TOC_BASE_OFF;
11313
11314 return 1;
11315 }
11316
11317 /* Set up for first pass at multitoc partitioning. */
11318
11319 void
11320 ppc64_elf_start_multitoc_partition (struct bfd_link_info *info)
11321 {
11322 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11323
11324 htab->toc_curr = ppc64_elf_set_toc (info, info->output_bfd);
11325 htab->toc_bfd = NULL;
11326 htab->toc_first_sec = NULL;
11327 }
11328
11329 /* The linker repeatedly calls this function for each TOC input section
11330 and linker generated GOT section. Group input bfds such that the toc
11331 within a group is less than 64k in size. */
11332
11333 bfd_boolean
11334 ppc64_elf_next_toc_section (struct bfd_link_info *info, asection *isec)
11335 {
11336 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11337 bfd_vma addr, off, limit;
11338
11339 if (htab == NULL)
11340 return FALSE;
11341
11342 if (!htab->second_toc_pass)
11343 {
11344 /* Keep track of the first .toc or .got section for this input bfd. */
11345 bfd_boolean new_bfd = htab->toc_bfd != isec->owner;
11346
11347 if (new_bfd)
11348 {
11349 htab->toc_bfd = isec->owner;
11350 htab->toc_first_sec = isec;
11351 }
11352
11353 addr = isec->output_offset + isec->output_section->vma;
11354 off = addr - htab->toc_curr;
11355 limit = 0x80008000;
11356 if (ppc64_elf_tdata (isec->owner)->has_small_toc_reloc)
11357 limit = 0x10000;
11358 if (off + isec->size > limit)
11359 {
11360 addr = (htab->toc_first_sec->output_offset
11361 + htab->toc_first_sec->output_section->vma);
11362 htab->toc_curr = addr;
11363 htab->toc_curr &= -TOC_BASE_ALIGN;
11364 }
11365
11366 /* toc_curr is the base address of this toc group. Set elf_gp
11367 for the input section to be the offset relative to the
11368 output toc base plus 0x8000. Making the input elf_gp an
11369 offset allows us to move the toc as a whole without
11370 recalculating input elf_gp. */
11371 off = htab->toc_curr - elf_gp (isec->output_section->owner);
11372 off += TOC_BASE_OFF;
11373
11374 /* Die if someone uses a linker script that doesn't keep input
11375 file .toc and .got together. */
11376 if (new_bfd
11377 && elf_gp (isec->owner) != 0
11378 && elf_gp (isec->owner) != off)
11379 return FALSE;
11380
11381 elf_gp (isec->owner) = off;
11382 return TRUE;
11383 }
11384
11385 /* During the second pass toc_first_sec points to the start of
11386 a toc group, and toc_curr is used to track the old elf_gp.
11387 We use toc_bfd to ensure we only look at each bfd once. */
11388 if (htab->toc_bfd == isec->owner)
11389 return TRUE;
11390 htab->toc_bfd = isec->owner;
11391
11392 if (htab->toc_first_sec == NULL
11393 || htab->toc_curr != elf_gp (isec->owner))
11394 {
11395 htab->toc_curr = elf_gp (isec->owner);
11396 htab->toc_first_sec = isec;
11397 }
11398 addr = (htab->toc_first_sec->output_offset
11399 + htab->toc_first_sec->output_section->vma);
11400 off = addr - elf_gp (isec->output_section->owner) + TOC_BASE_OFF;
11401 elf_gp (isec->owner) = off;
11402
11403 return TRUE;
11404 }
11405
11406 /* Called via elf_link_hash_traverse to merge GOT entries for global
11407 symbol H. */
11408
11409 static bfd_boolean
11410 merge_global_got (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
11411 {
11412 if (h->root.type == bfd_link_hash_indirect)
11413 return TRUE;
11414
11415 merge_got_entries (&h->got.glist);
11416
11417 return TRUE;
11418 }
11419
11420 /* Called via elf_link_hash_traverse to allocate GOT entries for global
11421 symbol H. */
11422
11423 static bfd_boolean
11424 reallocate_got (struct elf_link_hash_entry *h, void *inf)
11425 {
11426 struct got_entry *gent;
11427
11428 if (h->root.type == bfd_link_hash_indirect)
11429 return TRUE;
11430
11431 for (gent = h->got.glist; gent != NULL; gent = gent->next)
11432 if (!gent->is_indirect)
11433 allocate_got (h, (struct bfd_link_info *) inf, gent);
11434 return TRUE;
11435 }
11436
11437 /* Called on the first multitoc pass after the last call to
11438 ppc64_elf_next_toc_section. This function removes duplicate GOT
11439 entries. */
11440
11441 bfd_boolean
11442 ppc64_elf_layout_multitoc (struct bfd_link_info *info)
11443 {
11444 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11445 struct bfd *ibfd, *ibfd2;
11446 bfd_boolean done_something;
11447
11448 htab->multi_toc_needed = htab->toc_curr != elf_gp (info->output_bfd);
11449
11450 if (!htab->do_multi_toc)
11451 return FALSE;
11452
11453 /* Merge global sym got entries within a toc group. */
11454 elf_link_hash_traverse (&htab->elf, merge_global_got, info);
11455
11456 /* And tlsld_got. */
11457 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11458 {
11459 struct got_entry *ent, *ent2;
11460
11461 if (!is_ppc64_elf (ibfd))
11462 continue;
11463
11464 ent = ppc64_tlsld_got (ibfd);
11465 if (!ent->is_indirect
11466 && ent->got.offset != (bfd_vma) -1)
11467 {
11468 for (ibfd2 = ibfd->link.next; ibfd2 != NULL; ibfd2 = ibfd2->link.next)
11469 {
11470 if (!is_ppc64_elf (ibfd2))
11471 continue;
11472
11473 ent2 = ppc64_tlsld_got (ibfd2);
11474 if (!ent2->is_indirect
11475 && ent2->got.offset != (bfd_vma) -1
11476 && elf_gp (ibfd2) == elf_gp (ibfd))
11477 {
11478 ent2->is_indirect = TRUE;
11479 ent2->got.ent = ent;
11480 }
11481 }
11482 }
11483 }
11484
11485 /* Zap sizes of got sections. */
11486 htab->elf.irelplt->rawsize = htab->elf.irelplt->size;
11487 htab->elf.irelplt->size -= htab->got_reli_size;
11488 htab->got_reli_size = 0;
11489
11490 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11491 {
11492 asection *got, *relgot;
11493
11494 if (!is_ppc64_elf (ibfd))
11495 continue;
11496
11497 got = ppc64_elf_tdata (ibfd)->got;
11498 if (got != NULL)
11499 {
11500 got->rawsize = got->size;
11501 got->size = 0;
11502 relgot = ppc64_elf_tdata (ibfd)->relgot;
11503 relgot->rawsize = relgot->size;
11504 relgot->size = 0;
11505 }
11506 }
11507
11508 /* Now reallocate the got, local syms first. We don't need to
11509 allocate section contents again since we never increase size. */
11510 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11511 {
11512 struct got_entry **lgot_ents;
11513 struct got_entry **end_lgot_ents;
11514 struct plt_entry **local_plt;
11515 struct plt_entry **end_local_plt;
11516 unsigned char *lgot_masks;
11517 bfd_size_type locsymcount;
11518 Elf_Internal_Shdr *symtab_hdr;
11519 asection *s;
11520
11521 if (!is_ppc64_elf (ibfd))
11522 continue;
11523
11524 lgot_ents = elf_local_got_ents (ibfd);
11525 if (!lgot_ents)
11526 continue;
11527
11528 symtab_hdr = &elf_symtab_hdr (ibfd);
11529 locsymcount = symtab_hdr->sh_info;
11530 end_lgot_ents = lgot_ents + locsymcount;
11531 local_plt = (struct plt_entry **) end_lgot_ents;
11532 end_local_plt = local_plt + locsymcount;
11533 lgot_masks = (unsigned char *) end_local_plt;
11534 s = ppc64_elf_tdata (ibfd)->got;
11535 for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
11536 {
11537 struct got_entry *ent;
11538
11539 for (ent = *lgot_ents; ent != NULL; ent = ent->next)
11540 {
11541 unsigned int ent_size = 8;
11542 unsigned int rel_size = sizeof (Elf64_External_Rela);
11543
11544 ent->got.offset = s->size;
11545 if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
11546 {
11547 ent_size *= 2;
11548 rel_size *= 2;
11549 }
11550 s->size += ent_size;
11551 if ((*lgot_masks & PLT_IFUNC) != 0)
11552 {
11553 htab->elf.irelplt->size += rel_size;
11554 htab->got_reli_size += rel_size;
11555 }
11556 else if (bfd_link_pic (info))
11557 {
11558 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
11559 srel->size += rel_size;
11560 }
11561 }
11562 }
11563 }
11564
11565 elf_link_hash_traverse (&htab->elf, reallocate_got, info);
11566
11567 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11568 {
11569 struct got_entry *ent;
11570
11571 if (!is_ppc64_elf (ibfd))
11572 continue;
11573
11574 ent = ppc64_tlsld_got (ibfd);
11575 if (!ent->is_indirect
11576 && ent->got.offset != (bfd_vma) -1)
11577 {
11578 asection *s = ppc64_elf_tdata (ibfd)->got;
11579 ent->got.offset = s->size;
11580 s->size += 16;
11581 if (bfd_link_pic (info))
11582 {
11583 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
11584 srel->size += sizeof (Elf64_External_Rela);
11585 }
11586 }
11587 }
11588
11589 done_something = htab->elf.irelplt->rawsize != htab->elf.irelplt->size;
11590 if (!done_something)
11591 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11592 {
11593 asection *got;
11594
11595 if (!is_ppc64_elf (ibfd))
11596 continue;
11597
11598 got = ppc64_elf_tdata (ibfd)->got;
11599 if (got != NULL)
11600 {
11601 done_something = got->rawsize != got->size;
11602 if (done_something)
11603 break;
11604 }
11605 }
11606
11607 if (done_something)
11608 (*htab->params->layout_sections_again) ();
11609
11610 /* Set up for second pass over toc sections to recalculate elf_gp
11611 on input sections. */
11612 htab->toc_bfd = NULL;
11613 htab->toc_first_sec = NULL;
11614 htab->second_toc_pass = TRUE;
11615 return done_something;
11616 }
11617
11618 /* Called after second pass of multitoc partitioning. */
11619
11620 void
11621 ppc64_elf_finish_multitoc_partition (struct bfd_link_info *info)
11622 {
11623 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11624
11625 /* After the second pass, toc_curr tracks the TOC offset used
11626 for code sections below in ppc64_elf_next_input_section. */
11627 htab->toc_curr = TOC_BASE_OFF;
11628 }
11629
11630 /* No toc references were found in ISEC. If the code in ISEC makes no
11631 calls, then there's no need to use toc adjusting stubs when branching
11632 into ISEC. Actually, indirect calls from ISEC are OK as they will
11633 load r2. Returns -1 on error, 0 for no stub needed, 1 for stub
11634 needed, and 2 if a cyclical call-graph was found but no other reason
11635 for a stub was detected. If called from the top level, a return of
11636 2 means the same as a return of 0. */
11637
11638 static int
11639 toc_adjusting_stub_needed (struct bfd_link_info *info, asection *isec)
11640 {
11641 int ret;
11642
11643 /* Mark this section as checked. */
11644 isec->call_check_done = 1;
11645
11646 /* We know none of our code bearing sections will need toc stubs. */
11647 if ((isec->flags & SEC_LINKER_CREATED) != 0)
11648 return 0;
11649
11650 if (isec->size == 0)
11651 return 0;
11652
11653 if (isec->output_section == NULL)
11654 return 0;
11655
11656 ret = 0;
11657 if (isec->reloc_count != 0)
11658 {
11659 Elf_Internal_Rela *relstart, *rel;
11660 Elf_Internal_Sym *local_syms;
11661 struct ppc_link_hash_table *htab;
11662
11663 relstart = _bfd_elf_link_read_relocs (isec->owner, isec, NULL, NULL,
11664 info->keep_memory);
11665 if (relstart == NULL)
11666 return -1;
11667
11668 /* Look for branches to outside of this section. */
11669 local_syms = NULL;
11670 htab = ppc_hash_table (info);
11671 if (htab == NULL)
11672 return -1;
11673
11674 for (rel = relstart; rel < relstart + isec->reloc_count; ++rel)
11675 {
11676 enum elf_ppc64_reloc_type r_type;
11677 unsigned long r_symndx;
11678 struct elf_link_hash_entry *h;
11679 struct ppc_link_hash_entry *eh;
11680 Elf_Internal_Sym *sym;
11681 asection *sym_sec;
11682 struct _opd_sec_data *opd;
11683 bfd_vma sym_value;
11684 bfd_vma dest;
11685
11686 r_type = ELF64_R_TYPE (rel->r_info);
11687 if (r_type != R_PPC64_REL24
11688 && r_type != R_PPC64_REL14
11689 && r_type != R_PPC64_REL14_BRTAKEN
11690 && r_type != R_PPC64_REL14_BRNTAKEN)
11691 continue;
11692
11693 r_symndx = ELF64_R_SYM (rel->r_info);
11694 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms, r_symndx,
11695 isec->owner))
11696 {
11697 ret = -1;
11698 break;
11699 }
11700
11701 /* Calls to dynamic lib functions go through a plt call stub
11702 that uses r2. */
11703 eh = (struct ppc_link_hash_entry *) h;
11704 if (eh != NULL
11705 && (eh->elf.plt.plist != NULL
11706 || (eh->oh != NULL
11707 && ppc_follow_link (eh->oh)->elf.plt.plist != NULL)))
11708 {
11709 ret = 1;
11710 break;
11711 }
11712
11713 if (sym_sec == NULL)
11714 /* Ignore other undefined symbols. */
11715 continue;
11716
11717 /* Assume branches to other sections not included in the
11718 link need stubs too, to cover -R and absolute syms. */
11719 if (sym_sec->output_section == NULL)
11720 {
11721 ret = 1;
11722 break;
11723 }
11724
11725 if (h == NULL)
11726 sym_value = sym->st_value;
11727 else
11728 {
11729 if (h->root.type != bfd_link_hash_defined
11730 && h->root.type != bfd_link_hash_defweak)
11731 abort ();
11732 sym_value = h->root.u.def.value;
11733 }
11734 sym_value += rel->r_addend;
11735
11736 /* If this branch reloc uses an opd sym, find the code section. */
11737 opd = get_opd_info (sym_sec);
11738 if (opd != NULL)
11739 {
11740 if (h == NULL && opd->adjust != NULL)
11741 {
11742 long adjust;
11743
11744 adjust = opd->adjust[OPD_NDX (sym_value)];
11745 if (adjust == -1)
11746 /* Assume deleted functions won't ever be called. */
11747 continue;
11748 sym_value += adjust;
11749 }
11750
11751 dest = opd_entry_value (sym_sec, sym_value,
11752 &sym_sec, NULL, FALSE);
11753 if (dest == (bfd_vma) -1)
11754 continue;
11755 }
11756 else
11757 dest = (sym_value
11758 + sym_sec->output_offset
11759 + sym_sec->output_section->vma);
11760
11761 /* Ignore branch to self. */
11762 if (sym_sec == isec)
11763 continue;
11764
11765 /* If the called function uses the toc, we need a stub. */
11766 if (sym_sec->has_toc_reloc
11767 || sym_sec->makes_toc_func_call)
11768 {
11769 ret = 1;
11770 break;
11771 }
11772
11773 /* Assume any branch that needs a long branch stub might in fact
11774 need a plt_branch stub. A plt_branch stub uses r2. */
11775 else if (dest - (isec->output_offset
11776 + isec->output_section->vma
11777 + rel->r_offset) + (1 << 25)
11778 >= (2u << 25) - PPC64_LOCAL_ENTRY_OFFSET (h
11779 ? h->other
11780 : sym->st_other))
11781 {
11782 ret = 1;
11783 break;
11784 }
11785
11786 /* If calling back to a section in the process of being
11787 tested, we can't say for sure that no toc adjusting stubs
11788 are needed, so don't return zero. */
11789 else if (sym_sec->call_check_in_progress)
11790 ret = 2;
11791
11792 /* Branches to another section that itself doesn't have any TOC
11793 references are OK. Recursively call ourselves to check. */
11794 else if (!sym_sec->call_check_done)
11795 {
11796 int recur;
11797
11798 /* Mark current section as indeterminate, so that other
11799 sections that call back to current won't be marked as
11800 known. */
11801 isec->call_check_in_progress = 1;
11802 recur = toc_adjusting_stub_needed (info, sym_sec);
11803 isec->call_check_in_progress = 0;
11804
11805 if (recur != 0)
11806 {
11807 ret = recur;
11808 if (recur != 2)
11809 break;
11810 }
11811 }
11812 }
11813
11814 if (local_syms != NULL
11815 && (elf_symtab_hdr (isec->owner).contents
11816 != (unsigned char *) local_syms))
11817 free (local_syms);
11818 if (elf_section_data (isec)->relocs != relstart)
11819 free (relstart);
11820 }
11821
11822 if ((ret & 1) == 0
11823 && isec->map_head.s != NULL
11824 && (strcmp (isec->output_section->name, ".init") == 0
11825 || strcmp (isec->output_section->name, ".fini") == 0))
11826 {
11827 if (isec->map_head.s->has_toc_reloc
11828 || isec->map_head.s->makes_toc_func_call)
11829 ret = 1;
11830 else if (!isec->map_head.s->call_check_done)
11831 {
11832 int recur;
11833 isec->call_check_in_progress = 1;
11834 recur = toc_adjusting_stub_needed (info, isec->map_head.s);
11835 isec->call_check_in_progress = 0;
11836 if (recur != 0)
11837 ret = recur;
11838 }
11839 }
11840
11841 if (ret == 1)
11842 isec->makes_toc_func_call = 1;
11843
11844 return ret;
11845 }
11846
11847 /* The linker repeatedly calls this function for each input section,
11848 in the order that input sections are linked into output sections.
11849 Build lists of input sections to determine groupings between which
11850 we may insert linker stubs. */
11851
11852 bfd_boolean
11853 ppc64_elf_next_input_section (struct bfd_link_info *info, asection *isec)
11854 {
11855 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11856
11857 if (htab == NULL)
11858 return FALSE;
11859
11860 if ((isec->output_section->flags & SEC_CODE) != 0
11861 && isec->output_section->id < htab->sec_info_arr_size)
11862 {
11863 /* This happens to make the list in reverse order,
11864 which is what we want. */
11865 htab->sec_info[isec->id].u.list
11866 = htab->sec_info[isec->output_section->id].u.list;
11867 htab->sec_info[isec->output_section->id].u.list = isec;
11868 }
11869
11870 if (htab->multi_toc_needed)
11871 {
11872 /* Analyse sections that aren't already flagged as needing a
11873 valid toc pointer. Exclude .fixup for the linux kernel.
11874 .fixup contains branches, but only back to the function that
11875 hit an exception. */
11876 if (!(isec->has_toc_reloc
11877 || (isec->flags & SEC_CODE) == 0
11878 || strcmp (isec->name, ".fixup") == 0
11879 || isec->call_check_done))
11880 {
11881 if (toc_adjusting_stub_needed (info, isec) < 0)
11882 return FALSE;
11883 }
11884 /* Make all sections use the TOC assigned for this object file.
11885 This will be wrong for pasted sections; We fix that in
11886 check_pasted_section(). */
11887 if (elf_gp (isec->owner) != 0)
11888 htab->toc_curr = elf_gp (isec->owner);
11889 }
11890
11891 htab->sec_info[isec->id].toc_off = htab->toc_curr;
11892 return TRUE;
11893 }
11894
11895 /* Check that all .init and .fini sections use the same toc, if they
11896 have toc relocs. */
11897
11898 static bfd_boolean
11899 check_pasted_section (struct bfd_link_info *info, const char *name)
11900 {
11901 asection *o = bfd_get_section_by_name (info->output_bfd, name);
11902
11903 if (o != NULL)
11904 {
11905 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11906 bfd_vma toc_off = 0;
11907 asection *i;
11908
11909 for (i = o->map_head.s; i != NULL; i = i->map_head.s)
11910 if (i->has_toc_reloc)
11911 {
11912 if (toc_off == 0)
11913 toc_off = htab->sec_info[i->id].toc_off;
11914 else if (toc_off != htab->sec_info[i->id].toc_off)
11915 return FALSE;
11916 }
11917
11918 if (toc_off == 0)
11919 for (i = o->map_head.s; i != NULL; i = i->map_head.s)
11920 if (i->makes_toc_func_call)
11921 {
11922 toc_off = htab->sec_info[i->id].toc_off;
11923 break;
11924 }
11925
11926 /* Make sure the whole pasted function uses the same toc offset. */
11927 if (toc_off != 0)
11928 for (i = o->map_head.s; i != NULL; i = i->map_head.s)
11929 htab->sec_info[i->id].toc_off = toc_off;
11930 }
11931 return TRUE;
11932 }
11933
11934 bfd_boolean
11935 ppc64_elf_check_init_fini (struct bfd_link_info *info)
11936 {
11937 return (check_pasted_section (info, ".init")
11938 & check_pasted_section (info, ".fini"));
11939 }
11940
11941 /* See whether we can group stub sections together. Grouping stub
11942 sections may result in fewer stubs. More importantly, we need to
11943 put all .init* and .fini* stubs at the beginning of the .init or
11944 .fini output sections respectively, because glibc splits the
11945 _init and _fini functions into multiple parts. Putting a stub in
11946 the middle of a function is not a good idea. */
11947
11948 static bfd_boolean
11949 group_sections (struct bfd_link_info *info,
11950 bfd_size_type stub_group_size,
11951 bfd_boolean stubs_always_before_branch)
11952 {
11953 struct ppc_link_hash_table *htab;
11954 asection *osec;
11955 bfd_size_type stub14_group_size;
11956 bfd_boolean suppress_size_errors;
11957
11958 htab = ppc_hash_table (info);
11959 if (htab == NULL)
11960 return FALSE;
11961
11962 suppress_size_errors = FALSE;
11963 stub14_group_size = stub_group_size >> 10;
11964 if (stub_group_size == 1)
11965 {
11966 /* Default values. */
11967 if (stubs_always_before_branch)
11968 {
11969 stub_group_size = 0x1e00000;
11970 stub14_group_size = 0x7800;
11971 }
11972 else
11973 {
11974 stub_group_size = 0x1c00000;
11975 stub14_group_size = 0x7000;
11976 }
11977 suppress_size_errors = TRUE;
11978 }
11979
11980 for (osec = info->output_bfd->sections; osec != NULL; osec = osec->next)
11981 {
11982 asection *tail;
11983
11984 if (osec->id >= htab->sec_info_arr_size)
11985 continue;
11986
11987 tail = htab->sec_info[osec->id].u.list;
11988 while (tail != NULL)
11989 {
11990 asection *curr;
11991 asection *prev;
11992 bfd_size_type total;
11993 bfd_boolean big_sec;
11994 bfd_vma curr_toc;
11995 struct map_stub *group;
11996
11997 curr = tail;
11998 total = tail->size;
11999 big_sec = total > (ppc64_elf_section_data (tail) != NULL
12000 && ppc64_elf_section_data (tail)->has_14bit_branch
12001 ? stub14_group_size : stub_group_size);
12002 if (big_sec && !suppress_size_errors)
12003 (*_bfd_error_handler) (_("%B section %A exceeds stub group size"),
12004 tail->owner, tail);
12005 curr_toc = htab->sec_info[tail->id].toc_off;
12006
12007 while ((prev = htab->sec_info[curr->id].u.list) != NULL
12008 && ((total += curr->output_offset - prev->output_offset)
12009 < (ppc64_elf_section_data (prev) != NULL
12010 && ppc64_elf_section_data (prev)->has_14bit_branch
12011 ? stub14_group_size : stub_group_size))
12012 && htab->sec_info[prev->id].toc_off == curr_toc)
12013 curr = prev;
12014
12015 /* OK, the size from the start of CURR to the end is less
12016 than stub_group_size and thus can be handled by one stub
12017 section. (or the tail section is itself larger than
12018 stub_group_size, in which case we may be toast.) We
12019 should really be keeping track of the total size of stubs
12020 added here, as stubs contribute to the final output
12021 section size. That's a little tricky, and this way will
12022 only break if stubs added make the total size more than
12023 2^25, ie. for the default stub_group_size, if stubs total
12024 more than 2097152 bytes, or nearly 75000 plt call stubs. */
12025 group = bfd_alloc (curr->owner, sizeof (*group));
12026 if (group == NULL)
12027 return FALSE;
12028 group->link_sec = curr;
12029 group->stub_sec = NULL;
12030 group->needs_save_res = 0;
12031 group->next = htab->group;
12032 htab->group = group;
12033 do
12034 {
12035 prev = htab->sec_info[tail->id].u.list;
12036 /* Set up this stub group. */
12037 htab->sec_info[tail->id].u.group = group;
12038 }
12039 while (tail != curr && (tail = prev) != NULL);
12040
12041 /* But wait, there's more! Input sections up to stub_group_size
12042 bytes before the stub section can be handled by it too.
12043 Don't do this if we have a really large section after the
12044 stubs, as adding more stubs increases the chance that
12045 branches may not reach into the stub section. */
12046 if (!stubs_always_before_branch && !big_sec)
12047 {
12048 total = 0;
12049 while (prev != NULL
12050 && ((total += tail->output_offset - prev->output_offset)
12051 < (ppc64_elf_section_data (prev) != NULL
12052 && ppc64_elf_section_data (prev)->has_14bit_branch
12053 ? stub14_group_size : stub_group_size))
12054 && htab->sec_info[prev->id].toc_off == curr_toc)
12055 {
12056 tail = prev;
12057 prev = htab->sec_info[tail->id].u.list;
12058 htab->sec_info[tail->id].u.group = group;
12059 }
12060 }
12061 tail = prev;
12062 }
12063 }
12064 return TRUE;
12065 }
12066
12067 static const unsigned char glink_eh_frame_cie[] =
12068 {
12069 0, 0, 0, 16, /* length. */
12070 0, 0, 0, 0, /* id. */
12071 1, /* CIE version. */
12072 'z', 'R', 0, /* Augmentation string. */
12073 4, /* Code alignment. */
12074 0x78, /* Data alignment. */
12075 65, /* RA reg. */
12076 1, /* Augmentation size. */
12077 DW_EH_PE_pcrel | DW_EH_PE_sdata4, /* FDE encoding. */
12078 DW_CFA_def_cfa, 1, 0, /* def_cfa: r1 offset 0. */
12079 0, 0, 0, 0
12080 };
12081
12082 /* Stripping output sections is normally done before dynamic section
12083 symbols have been allocated. This function is called later, and
12084 handles cases like htab->brlt which is mapped to its own output
12085 section. */
12086
12087 static void
12088 maybe_strip_output (struct bfd_link_info *info, asection *isec)
12089 {
12090 if (isec->size == 0
12091 && isec->output_section->size == 0
12092 && !(isec->output_section->flags & SEC_KEEP)
12093 && !bfd_section_removed_from_list (info->output_bfd,
12094 isec->output_section)
12095 && elf_section_data (isec->output_section)->dynindx == 0)
12096 {
12097 isec->output_section->flags |= SEC_EXCLUDE;
12098 bfd_section_list_remove (info->output_bfd, isec->output_section);
12099 info->output_bfd->section_count--;
12100 }
12101 }
12102
12103 /* Determine and set the size of the stub section for a final link.
12104
12105 The basic idea here is to examine all the relocations looking for
12106 PC-relative calls to a target that is unreachable with a "bl"
12107 instruction. */
12108
12109 bfd_boolean
12110 ppc64_elf_size_stubs (struct bfd_link_info *info)
12111 {
12112 bfd_size_type stub_group_size;
12113 bfd_boolean stubs_always_before_branch;
12114 struct ppc_link_hash_table *htab = ppc_hash_table (info);
12115
12116 if (htab == NULL)
12117 return FALSE;
12118
12119 if (htab->params->plt_thread_safe == -1 && !bfd_link_executable (info))
12120 htab->params->plt_thread_safe = 1;
12121 if (!htab->opd_abi)
12122 htab->params->plt_thread_safe = 0;
12123 else if (htab->params->plt_thread_safe == -1)
12124 {
12125 static const char *const thread_starter[] =
12126 {
12127 "pthread_create",
12128 /* libstdc++ */
12129 "_ZNSt6thread15_M_start_threadESt10shared_ptrINS_10_Impl_baseEE",
12130 /* librt */
12131 "aio_init", "aio_read", "aio_write", "aio_fsync", "lio_listio",
12132 "mq_notify", "create_timer",
12133 /* libanl */
12134 "getaddrinfo_a",
12135 /* libgomp */
12136 "GOMP_parallel",
12137 "GOMP_parallel_start",
12138 "GOMP_parallel_loop_static",
12139 "GOMP_parallel_loop_static_start",
12140 "GOMP_parallel_loop_dynamic",
12141 "GOMP_parallel_loop_dynamic_start",
12142 "GOMP_parallel_loop_guided",
12143 "GOMP_parallel_loop_guided_start",
12144 "GOMP_parallel_loop_runtime",
12145 "GOMP_parallel_loop_runtime_start",
12146 "GOMP_parallel_sections",
12147 "GOMP_parallel_sections_start",
12148 /* libgo */
12149 "__go_go",
12150 };
12151 unsigned i;
12152
12153 for (i = 0; i < ARRAY_SIZE (thread_starter); i++)
12154 {
12155 struct elf_link_hash_entry *h;
12156 h = elf_link_hash_lookup (&htab->elf, thread_starter[i],
12157 FALSE, FALSE, TRUE);
12158 htab->params->plt_thread_safe = h != NULL && h->ref_regular;
12159 if (htab->params->plt_thread_safe)
12160 break;
12161 }
12162 }
12163 stubs_always_before_branch = htab->params->group_size < 0;
12164 if (htab->params->group_size < 0)
12165 stub_group_size = -htab->params->group_size;
12166 else
12167 stub_group_size = htab->params->group_size;
12168
12169 if (!group_sections (info, stub_group_size, stubs_always_before_branch))
12170 return FALSE;
12171
12172 while (1)
12173 {
12174 bfd *input_bfd;
12175 unsigned int bfd_indx;
12176 struct map_stub *group;
12177 asection *stub_sec;
12178
12179 htab->stub_iteration += 1;
12180
12181 for (input_bfd = info->input_bfds, bfd_indx = 0;
12182 input_bfd != NULL;
12183 input_bfd = input_bfd->link.next, bfd_indx++)
12184 {
12185 Elf_Internal_Shdr *symtab_hdr;
12186 asection *section;
12187 Elf_Internal_Sym *local_syms = NULL;
12188
12189 if (!is_ppc64_elf (input_bfd))
12190 continue;
12191
12192 /* We'll need the symbol table in a second. */
12193 symtab_hdr = &elf_symtab_hdr (input_bfd);
12194 if (symtab_hdr->sh_info == 0)
12195 continue;
12196
12197 /* Walk over each section attached to the input bfd. */
12198 for (section = input_bfd->sections;
12199 section != NULL;
12200 section = section->next)
12201 {
12202 Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
12203
12204 /* If there aren't any relocs, then there's nothing more
12205 to do. */
12206 if ((section->flags & SEC_RELOC) == 0
12207 || (section->flags & SEC_ALLOC) == 0
12208 || (section->flags & SEC_LOAD) == 0
12209 || (section->flags & SEC_CODE) == 0
12210 || section->reloc_count == 0)
12211 continue;
12212
12213 /* If this section is a link-once section that will be
12214 discarded, then don't create any stubs. */
12215 if (section->output_section == NULL
12216 || section->output_section->owner != info->output_bfd)
12217 continue;
12218
12219 /* Get the relocs. */
12220 internal_relocs
12221 = _bfd_elf_link_read_relocs (input_bfd, section, NULL, NULL,
12222 info->keep_memory);
12223 if (internal_relocs == NULL)
12224 goto error_ret_free_local;
12225
12226 /* Now examine each relocation. */
12227 irela = internal_relocs;
12228 irelaend = irela + section->reloc_count;
12229 for (; irela < irelaend; irela++)
12230 {
12231 enum elf_ppc64_reloc_type r_type;
12232 unsigned int r_indx;
12233 enum ppc_stub_type stub_type;
12234 struct ppc_stub_hash_entry *stub_entry;
12235 asection *sym_sec, *code_sec;
12236 bfd_vma sym_value, code_value;
12237 bfd_vma destination;
12238 unsigned long local_off;
12239 bfd_boolean ok_dest;
12240 struct ppc_link_hash_entry *hash;
12241 struct ppc_link_hash_entry *fdh;
12242 struct elf_link_hash_entry *h;
12243 Elf_Internal_Sym *sym;
12244 char *stub_name;
12245 const asection *id_sec;
12246 struct _opd_sec_data *opd;
12247 struct plt_entry *plt_ent;
12248
12249 r_type = ELF64_R_TYPE (irela->r_info);
12250 r_indx = ELF64_R_SYM (irela->r_info);
12251
12252 if (r_type >= R_PPC64_max)
12253 {
12254 bfd_set_error (bfd_error_bad_value);
12255 goto error_ret_free_internal;
12256 }
12257
12258 /* Only look for stubs on branch instructions. */
12259 if (r_type != R_PPC64_REL24
12260 && r_type != R_PPC64_REL14
12261 && r_type != R_PPC64_REL14_BRTAKEN
12262 && r_type != R_PPC64_REL14_BRNTAKEN)
12263 continue;
12264
12265 /* Now determine the call target, its name, value,
12266 section. */
12267 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
12268 r_indx, input_bfd))
12269 goto error_ret_free_internal;
12270 hash = (struct ppc_link_hash_entry *) h;
12271
12272 ok_dest = FALSE;
12273 fdh = NULL;
12274 sym_value = 0;
12275 if (hash == NULL)
12276 {
12277 sym_value = sym->st_value;
12278 ok_dest = TRUE;
12279 }
12280 else if (hash->elf.root.type == bfd_link_hash_defined
12281 || hash->elf.root.type == bfd_link_hash_defweak)
12282 {
12283 sym_value = hash->elf.root.u.def.value;
12284 if (sym_sec->output_section != NULL)
12285 ok_dest = TRUE;
12286 }
12287 else if (hash->elf.root.type == bfd_link_hash_undefweak
12288 || hash->elf.root.type == bfd_link_hash_undefined)
12289 {
12290 /* Recognise an old ABI func code entry sym, and
12291 use the func descriptor sym instead if it is
12292 defined. */
12293 if (hash->elf.root.root.string[0] == '.'
12294 && (fdh = lookup_fdh (hash, htab)) != NULL)
12295 {
12296 if (fdh->elf.root.type == bfd_link_hash_defined
12297 || fdh->elf.root.type == bfd_link_hash_defweak)
12298 {
12299 sym_sec = fdh->elf.root.u.def.section;
12300 sym_value = fdh->elf.root.u.def.value;
12301 if (sym_sec->output_section != NULL)
12302 ok_dest = TRUE;
12303 }
12304 else
12305 fdh = NULL;
12306 }
12307 }
12308 else
12309 {
12310 bfd_set_error (bfd_error_bad_value);
12311 goto error_ret_free_internal;
12312 }
12313
12314 destination = 0;
12315 local_off = 0;
12316 if (ok_dest)
12317 {
12318 sym_value += irela->r_addend;
12319 destination = (sym_value
12320 + sym_sec->output_offset
12321 + sym_sec->output_section->vma);
12322 local_off = PPC64_LOCAL_ENTRY_OFFSET (hash
12323 ? hash->elf.other
12324 : sym->st_other);
12325 }
12326
12327 code_sec = sym_sec;
12328 code_value = sym_value;
12329 opd = get_opd_info (sym_sec);
12330 if (opd != NULL)
12331 {
12332 bfd_vma dest;
12333
12334 if (hash == NULL && opd->adjust != NULL)
12335 {
12336 long adjust = opd->adjust[OPD_NDX (sym_value)];
12337 if (adjust == -1)
12338 continue;
12339 code_value += adjust;
12340 sym_value += adjust;
12341 }
12342 dest = opd_entry_value (sym_sec, sym_value,
12343 &code_sec, &code_value, FALSE);
12344 if (dest != (bfd_vma) -1)
12345 {
12346 destination = dest;
12347 if (fdh != NULL)
12348 {
12349 /* Fixup old ABI sym to point at code
12350 entry. */
12351 hash->elf.root.type = bfd_link_hash_defweak;
12352 hash->elf.root.u.def.section = code_sec;
12353 hash->elf.root.u.def.value = code_value;
12354 }
12355 }
12356 }
12357
12358 /* Determine what (if any) linker stub is needed. */
12359 plt_ent = NULL;
12360 stub_type = ppc_type_of_stub (section, irela, &hash,
12361 &plt_ent, destination,
12362 local_off);
12363
12364 if (stub_type != ppc_stub_plt_call)
12365 {
12366 /* Check whether we need a TOC adjusting stub.
12367 Since the linker pastes together pieces from
12368 different object files when creating the
12369 _init and _fini functions, it may be that a
12370 call to what looks like a local sym is in
12371 fact a call needing a TOC adjustment. */
12372 if (code_sec != NULL
12373 && code_sec->output_section != NULL
12374 && (htab->sec_info[code_sec->id].toc_off
12375 != htab->sec_info[section->id].toc_off)
12376 && (code_sec->has_toc_reloc
12377 || code_sec->makes_toc_func_call))
12378 stub_type = ppc_stub_long_branch_r2off;
12379 }
12380
12381 if (stub_type == ppc_stub_none)
12382 continue;
12383
12384 /* __tls_get_addr calls might be eliminated. */
12385 if (stub_type != ppc_stub_plt_call
12386 && hash != NULL
12387 && (hash == htab->tls_get_addr
12388 || hash == htab->tls_get_addr_fd)
12389 && section->has_tls_reloc
12390 && irela != internal_relocs)
12391 {
12392 /* Get tls info. */
12393 unsigned char *tls_mask;
12394
12395 if (!get_tls_mask (&tls_mask, NULL, NULL, &local_syms,
12396 irela - 1, input_bfd))
12397 goto error_ret_free_internal;
12398 if (*tls_mask != 0)
12399 continue;
12400 }
12401
12402 if (stub_type == ppc_stub_plt_call
12403 && irela + 1 < irelaend
12404 && irela[1].r_offset == irela->r_offset + 4
12405 && ELF64_R_TYPE (irela[1].r_info) == R_PPC64_TOCSAVE)
12406 {
12407 if (!tocsave_find (htab, INSERT,
12408 &local_syms, irela + 1, input_bfd))
12409 goto error_ret_free_internal;
12410 }
12411 else if (stub_type == ppc_stub_plt_call)
12412 stub_type = ppc_stub_plt_call_r2save;
12413
12414 /* Support for grouping stub sections. */
12415 id_sec = htab->sec_info[section->id].u.group->link_sec;
12416
12417 /* Get the name of this stub. */
12418 stub_name = ppc_stub_name (id_sec, sym_sec, hash, irela);
12419 if (!stub_name)
12420 goto error_ret_free_internal;
12421
12422 stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
12423 stub_name, FALSE, FALSE);
12424 if (stub_entry != NULL)
12425 {
12426 /* The proper stub has already been created. */
12427 free (stub_name);
12428 if (stub_type == ppc_stub_plt_call_r2save)
12429 stub_entry->stub_type = stub_type;
12430 continue;
12431 }
12432
12433 stub_entry = ppc_add_stub (stub_name, section, info);
12434 if (stub_entry == NULL)
12435 {
12436 free (stub_name);
12437 error_ret_free_internal:
12438 if (elf_section_data (section)->relocs == NULL)
12439 free (internal_relocs);
12440 error_ret_free_local:
12441 if (local_syms != NULL
12442 && (symtab_hdr->contents
12443 != (unsigned char *) local_syms))
12444 free (local_syms);
12445 return FALSE;
12446 }
12447
12448 stub_entry->stub_type = stub_type;
12449 if (stub_type != ppc_stub_plt_call
12450 && stub_type != ppc_stub_plt_call_r2save)
12451 {
12452 stub_entry->target_value = code_value;
12453 stub_entry->target_section = code_sec;
12454 }
12455 else
12456 {
12457 stub_entry->target_value = sym_value;
12458 stub_entry->target_section = sym_sec;
12459 }
12460 stub_entry->h = hash;
12461 stub_entry->plt_ent = plt_ent;
12462 stub_entry->other = hash ? hash->elf.other : sym->st_other;
12463
12464 if (stub_entry->h != NULL)
12465 htab->stub_globals += 1;
12466 }
12467
12468 /* We're done with the internal relocs, free them. */
12469 if (elf_section_data (section)->relocs != internal_relocs)
12470 free (internal_relocs);
12471 }
12472
12473 if (local_syms != NULL
12474 && symtab_hdr->contents != (unsigned char *) local_syms)
12475 {
12476 if (!info->keep_memory)
12477 free (local_syms);
12478 else
12479 symtab_hdr->contents = (unsigned char *) local_syms;
12480 }
12481 }
12482
12483 /* We may have added some stubs. Find out the new size of the
12484 stub sections. */
12485 for (stub_sec = htab->params->stub_bfd->sections;
12486 stub_sec != NULL;
12487 stub_sec = stub_sec->next)
12488 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12489 {
12490 stub_sec->rawsize = stub_sec->size;
12491 stub_sec->size = 0;
12492 stub_sec->reloc_count = 0;
12493 stub_sec->flags &= ~SEC_RELOC;
12494 }
12495
12496 htab->brlt->size = 0;
12497 htab->brlt->reloc_count = 0;
12498 htab->brlt->flags &= ~SEC_RELOC;
12499 if (htab->relbrlt != NULL)
12500 htab->relbrlt->size = 0;
12501
12502 bfd_hash_traverse (&htab->stub_hash_table, ppc_size_one_stub, info);
12503
12504 for (group = htab->group; group != NULL; group = group->next)
12505 if (group->needs_save_res)
12506 group->stub_sec->size += htab->sfpr->size;
12507
12508 if (info->emitrelocations
12509 && htab->glink != NULL && htab->glink->size != 0)
12510 {
12511 htab->glink->reloc_count = 1;
12512 htab->glink->flags |= SEC_RELOC;
12513 }
12514
12515 if (htab->glink_eh_frame != NULL
12516 && !bfd_is_abs_section (htab->glink_eh_frame->output_section)
12517 && htab->glink_eh_frame->output_section->size != 0)
12518 {
12519 size_t size = 0, align;
12520
12521 for (stub_sec = htab->params->stub_bfd->sections;
12522 stub_sec != NULL;
12523 stub_sec = stub_sec->next)
12524 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12525 size += 24;
12526 if (htab->glink != NULL && htab->glink->size != 0)
12527 size += 24;
12528 if (size != 0)
12529 size += sizeof (glink_eh_frame_cie);
12530 align = 1;
12531 align <<= htab->glink_eh_frame->output_section->alignment_power;
12532 align -= 1;
12533 size = (size + align) & ~align;
12534 htab->glink_eh_frame->rawsize = htab->glink_eh_frame->size;
12535 htab->glink_eh_frame->size = size;
12536 }
12537
12538 if (htab->params->plt_stub_align != 0)
12539 for (stub_sec = htab->params->stub_bfd->sections;
12540 stub_sec != NULL;
12541 stub_sec = stub_sec->next)
12542 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12543 stub_sec->size = ((stub_sec->size
12544 + (1 << htab->params->plt_stub_align) - 1)
12545 & -(1 << htab->params->plt_stub_align));
12546
12547 for (stub_sec = htab->params->stub_bfd->sections;
12548 stub_sec != NULL;
12549 stub_sec = stub_sec->next)
12550 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
12551 && stub_sec->rawsize != stub_sec->size)
12552 break;
12553
12554 /* Exit from this loop when no stubs have been added, and no stubs
12555 have changed size. */
12556 if (stub_sec == NULL
12557 && (htab->glink_eh_frame == NULL
12558 || htab->glink_eh_frame->rawsize == htab->glink_eh_frame->size))
12559 break;
12560
12561 /* Ask the linker to do its stuff. */
12562 (*htab->params->layout_sections_again) ();
12563 }
12564
12565 if (htab->glink_eh_frame != NULL
12566 && htab->glink_eh_frame->size != 0)
12567 {
12568 bfd_vma val;
12569 bfd_byte *p, *last_fde;
12570 size_t last_fde_len, size, align, pad;
12571 asection *stub_sec;
12572
12573 p = bfd_zalloc (htab->glink_eh_frame->owner, htab->glink_eh_frame->size);
12574 if (p == NULL)
12575 return FALSE;
12576 htab->glink_eh_frame->contents = p;
12577 last_fde = p;
12578
12579 memcpy (p, glink_eh_frame_cie, sizeof (glink_eh_frame_cie));
12580 /* CIE length (rewrite in case little-endian). */
12581 last_fde_len = sizeof (glink_eh_frame_cie) - 4;
12582 bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
12583 p += sizeof (glink_eh_frame_cie);
12584
12585 for (stub_sec = htab->params->stub_bfd->sections;
12586 stub_sec != NULL;
12587 stub_sec = stub_sec->next)
12588 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12589 {
12590 last_fde = p;
12591 last_fde_len = 20;
12592 /* FDE length. */
12593 bfd_put_32 (htab->elf.dynobj, 20, p);
12594 p += 4;
12595 /* CIE pointer. */
12596 val = p - htab->glink_eh_frame->contents;
12597 bfd_put_32 (htab->elf.dynobj, val, p);
12598 p += 4;
12599 /* Offset to stub section, written later. */
12600 p += 4;
12601 /* stub section size. */
12602 bfd_put_32 (htab->elf.dynobj, stub_sec->size, p);
12603 p += 4;
12604 /* Augmentation. */
12605 p += 1;
12606 /* Pad. */
12607 p += 7;
12608 }
12609 if (htab->glink != NULL && htab->glink->size != 0)
12610 {
12611 last_fde = p;
12612 last_fde_len = 20;
12613 /* FDE length. */
12614 bfd_put_32 (htab->elf.dynobj, 20, p);
12615 p += 4;
12616 /* CIE pointer. */
12617 val = p - htab->glink_eh_frame->contents;
12618 bfd_put_32 (htab->elf.dynobj, val, p);
12619 p += 4;
12620 /* Offset to .glink, written later. */
12621 p += 4;
12622 /* .glink size. */
12623 bfd_put_32 (htab->elf.dynobj, htab->glink->size - 8, p);
12624 p += 4;
12625 /* Augmentation. */
12626 p += 1;
12627
12628 *p++ = DW_CFA_advance_loc + 1;
12629 *p++ = DW_CFA_register;
12630 *p++ = 65;
12631 *p++ = htab->opd_abi ? 12 : 0;
12632 *p++ = DW_CFA_advance_loc + 4;
12633 *p++ = DW_CFA_restore_extended;
12634 *p++ = 65;
12635 }
12636 /* Subsume any padding into the last FDE if user .eh_frame
12637 sections are aligned more than glink_eh_frame. Otherwise any
12638 zero padding will be seen as a terminator. */
12639 size = p - htab->glink_eh_frame->contents;
12640 align = 1;
12641 align <<= htab->glink_eh_frame->output_section->alignment_power;
12642 align -= 1;
12643 pad = ((size + align) & ~align) - size;
12644 htab->glink_eh_frame->size = size + pad;
12645 bfd_put_32 (htab->elf.dynobj, last_fde_len + pad, last_fde);
12646 }
12647
12648 maybe_strip_output (info, htab->brlt);
12649 if (htab->glink_eh_frame != NULL)
12650 maybe_strip_output (info, htab->glink_eh_frame);
12651
12652 return TRUE;
12653 }
12654
12655 /* Called after we have determined section placement. If sections
12656 move, we'll be called again. Provide a value for TOCstart. */
12657
12658 bfd_vma
12659 ppc64_elf_set_toc (struct bfd_link_info *info, bfd *obfd)
12660 {
12661 asection *s;
12662 bfd_vma TOCstart, adjust;
12663
12664 if (info != NULL)
12665 {
12666 struct elf_link_hash_entry *h;
12667 struct elf_link_hash_table *htab = elf_hash_table (info);
12668
12669 if (is_elf_hash_table (htab)
12670 && htab->hgot != NULL)
12671 h = htab->hgot;
12672 else
12673 {
12674 h = elf_link_hash_lookup (htab, ".TOC.", FALSE, FALSE, TRUE);
12675 if (is_elf_hash_table (htab))
12676 htab->hgot = h;
12677 }
12678 if (h != NULL
12679 && h->root.type == bfd_link_hash_defined
12680 && !h->root.linker_def
12681 && (!is_elf_hash_table (htab)
12682 || h->def_regular))
12683 {
12684 TOCstart = (h->root.u.def.value - TOC_BASE_OFF
12685 + h->root.u.def.section->output_offset
12686 + h->root.u.def.section->output_section->vma);
12687 _bfd_set_gp_value (obfd, TOCstart);
12688 return TOCstart;
12689 }
12690 }
12691
12692 /* The TOC consists of sections .got, .toc, .tocbss, .plt in that
12693 order. The TOC starts where the first of these sections starts. */
12694 s = bfd_get_section_by_name (obfd, ".got");
12695 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12696 s = bfd_get_section_by_name (obfd, ".toc");
12697 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12698 s = bfd_get_section_by_name (obfd, ".tocbss");
12699 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12700 s = bfd_get_section_by_name (obfd, ".plt");
12701 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12702 {
12703 /* This may happen for
12704 o references to TOC base (SYM@toc / TOC[tc0]) without a
12705 .toc directive
12706 o bad linker script
12707 o --gc-sections and empty TOC sections
12708
12709 FIXME: Warn user? */
12710
12711 /* Look for a likely section. We probably won't even be
12712 using TOCstart. */
12713 for (s = obfd->sections; s != NULL; s = s->next)
12714 if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_READONLY
12715 | SEC_EXCLUDE))
12716 == (SEC_ALLOC | SEC_SMALL_DATA))
12717 break;
12718 if (s == NULL)
12719 for (s = obfd->sections; s != NULL; s = s->next)
12720 if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_EXCLUDE))
12721 == (SEC_ALLOC | SEC_SMALL_DATA))
12722 break;
12723 if (s == NULL)
12724 for (s = obfd->sections; s != NULL; s = s->next)
12725 if ((s->flags & (SEC_ALLOC | SEC_READONLY | SEC_EXCLUDE))
12726 == SEC_ALLOC)
12727 break;
12728 if (s == NULL)
12729 for (s = obfd->sections; s != NULL; s = s->next)
12730 if ((s->flags & (SEC_ALLOC | SEC_EXCLUDE)) == SEC_ALLOC)
12731 break;
12732 }
12733
12734 TOCstart = 0;
12735 if (s != NULL)
12736 TOCstart = s->output_section->vma + s->output_offset;
12737
12738 /* Force alignment. */
12739 adjust = TOCstart & (TOC_BASE_ALIGN - 1);
12740 TOCstart -= adjust;
12741 _bfd_set_gp_value (obfd, TOCstart);
12742
12743 if (info != NULL && s != NULL)
12744 {
12745 struct ppc_link_hash_table *htab = ppc_hash_table (info);
12746
12747 if (htab != NULL)
12748 {
12749 if (htab->elf.hgot != NULL)
12750 {
12751 htab->elf.hgot->root.u.def.value = TOC_BASE_OFF - adjust;
12752 htab->elf.hgot->root.u.def.section = s;
12753 }
12754 }
12755 else
12756 {
12757 struct bfd_link_hash_entry *bh = NULL;
12758 _bfd_generic_link_add_one_symbol (info, obfd, ".TOC.", BSF_GLOBAL,
12759 s, TOC_BASE_OFF - adjust,
12760 NULL, FALSE, FALSE, &bh);
12761 }
12762 }
12763 return TOCstart;
12764 }
12765
12766 /* Called via elf_link_hash_traverse from ppc64_elf_build_stubs to
12767 write out any global entry stubs. */
12768
12769 static bfd_boolean
12770 build_global_entry_stubs (struct elf_link_hash_entry *h, void *inf)
12771 {
12772 struct bfd_link_info *info;
12773 struct ppc_link_hash_table *htab;
12774 struct plt_entry *pent;
12775 asection *s;
12776
12777 if (h->root.type == bfd_link_hash_indirect)
12778 return TRUE;
12779
12780 if (!h->pointer_equality_needed)
12781 return TRUE;
12782
12783 if (h->def_regular)
12784 return TRUE;
12785
12786 info = inf;
12787 htab = ppc_hash_table (info);
12788 if (htab == NULL)
12789 return FALSE;
12790
12791 s = htab->glink;
12792 for (pent = h->plt.plist; pent != NULL; pent = pent->next)
12793 if (pent->plt.offset != (bfd_vma) -1
12794 && pent->addend == 0)
12795 {
12796 bfd_byte *p;
12797 asection *plt;
12798 bfd_vma off;
12799
12800 p = s->contents + h->root.u.def.value;
12801 plt = htab->elf.splt;
12802 if (!htab->elf.dynamic_sections_created
12803 || h->dynindx == -1)
12804 plt = htab->elf.iplt;
12805 off = pent->plt.offset + plt->output_offset + plt->output_section->vma;
12806 off -= h->root.u.def.value + s->output_offset + s->output_section->vma;
12807
12808 if (off + 0x80008000 > 0xffffffff || (off & 3) != 0)
12809 {
12810 info->callbacks->einfo
12811 (_("%P: linkage table error against `%T'\n"),
12812 h->root.root.string);
12813 bfd_set_error (bfd_error_bad_value);
12814 htab->stub_error = TRUE;
12815 }
12816
12817 htab->stub_count[ppc_stub_global_entry - 1] += 1;
12818 if (htab->params->emit_stub_syms)
12819 {
12820 size_t len = strlen (h->root.root.string);
12821 char *name = bfd_malloc (sizeof "12345678.global_entry." + len);
12822
12823 if (name == NULL)
12824 return FALSE;
12825
12826 sprintf (name, "%08x.global_entry.%s", s->id, h->root.root.string);
12827 h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
12828 if (h == NULL)
12829 return FALSE;
12830 if (h->root.type == bfd_link_hash_new)
12831 {
12832 h->root.type = bfd_link_hash_defined;
12833 h->root.u.def.section = s;
12834 h->root.u.def.value = p - s->contents;
12835 h->ref_regular = 1;
12836 h->def_regular = 1;
12837 h->ref_regular_nonweak = 1;
12838 h->forced_local = 1;
12839 h->non_elf = 0;
12840 h->root.linker_def = 1;
12841 }
12842 }
12843
12844 if (PPC_HA (off) != 0)
12845 {
12846 bfd_put_32 (s->owner, ADDIS_R12_R12 | PPC_HA (off), p);
12847 p += 4;
12848 }
12849 bfd_put_32 (s->owner, LD_R12_0R12 | PPC_LO (off), p);
12850 p += 4;
12851 bfd_put_32 (s->owner, MTCTR_R12, p);
12852 p += 4;
12853 bfd_put_32 (s->owner, BCTR, p);
12854 break;
12855 }
12856 return TRUE;
12857 }
12858
12859 /* Build all the stubs associated with the current output file.
12860 The stubs are kept in a hash table attached to the main linker
12861 hash table. This function is called via gldelf64ppc_finish. */
12862
12863 bfd_boolean
12864 ppc64_elf_build_stubs (struct bfd_link_info *info,
12865 char **stats)
12866 {
12867 struct ppc_link_hash_table *htab = ppc_hash_table (info);
12868 struct map_stub *group;
12869 asection *stub_sec;
12870 bfd_byte *p;
12871 int stub_sec_count = 0;
12872
12873 if (htab == NULL)
12874 return FALSE;
12875
12876 /* Allocate memory to hold the linker stubs. */
12877 for (stub_sec = htab->params->stub_bfd->sections;
12878 stub_sec != NULL;
12879 stub_sec = stub_sec->next)
12880 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
12881 && stub_sec->size != 0)
12882 {
12883 stub_sec->contents = bfd_zalloc (htab->params->stub_bfd, stub_sec->size);
12884 if (stub_sec->contents == NULL)
12885 return FALSE;
12886 /* We want to check that built size is the same as calculated
12887 size. rawsize is a convenient location to use. */
12888 stub_sec->rawsize = stub_sec->size;
12889 stub_sec->size = 0;
12890 }
12891
12892 if (htab->glink != NULL && htab->glink->size != 0)
12893 {
12894 unsigned int indx;
12895 bfd_vma plt0;
12896
12897 /* Build the .glink plt call stub. */
12898 if (htab->params->emit_stub_syms)
12899 {
12900 struct elf_link_hash_entry *h;
12901 h = elf_link_hash_lookup (&htab->elf, "__glink_PLTresolve",
12902 TRUE, FALSE, FALSE);
12903 if (h == NULL)
12904 return FALSE;
12905 if (h->root.type == bfd_link_hash_new)
12906 {
12907 h->root.type = bfd_link_hash_defined;
12908 h->root.u.def.section = htab->glink;
12909 h->root.u.def.value = 8;
12910 h->ref_regular = 1;
12911 h->def_regular = 1;
12912 h->ref_regular_nonweak = 1;
12913 h->forced_local = 1;
12914 h->non_elf = 0;
12915 h->root.linker_def = 1;
12916 }
12917 }
12918 plt0 = (htab->elf.splt->output_section->vma
12919 + htab->elf.splt->output_offset
12920 - 16);
12921 if (info->emitrelocations)
12922 {
12923 Elf_Internal_Rela *r = get_relocs (htab->glink, 1);
12924 if (r == NULL)
12925 return FALSE;
12926 r->r_offset = (htab->glink->output_offset
12927 + htab->glink->output_section->vma);
12928 r->r_info = ELF64_R_INFO (0, R_PPC64_REL64);
12929 r->r_addend = plt0;
12930 }
12931 p = htab->glink->contents;
12932 plt0 -= htab->glink->output_section->vma + htab->glink->output_offset;
12933 bfd_put_64 (htab->glink->owner, plt0, p);
12934 p += 8;
12935 if (htab->opd_abi)
12936 {
12937 bfd_put_32 (htab->glink->owner, MFLR_R12, p);
12938 p += 4;
12939 bfd_put_32 (htab->glink->owner, BCL_20_31, p);
12940 p += 4;
12941 bfd_put_32 (htab->glink->owner, MFLR_R11, p);
12942 p += 4;
12943 bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
12944 p += 4;
12945 bfd_put_32 (htab->glink->owner, MTLR_R12, p);
12946 p += 4;
12947 bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
12948 p += 4;
12949 bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
12950 p += 4;
12951 bfd_put_32 (htab->glink->owner, LD_R2_0R11 | 8, p);
12952 p += 4;
12953 bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
12954 p += 4;
12955 bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 16, p);
12956 p += 4;
12957 }
12958 else
12959 {
12960 bfd_put_32 (htab->glink->owner, MFLR_R0, p);
12961 p += 4;
12962 bfd_put_32 (htab->glink->owner, BCL_20_31, p);
12963 p += 4;
12964 bfd_put_32 (htab->glink->owner, MFLR_R11, p);
12965 p += 4;
12966 bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
12967 p += 4;
12968 bfd_put_32 (htab->glink->owner, MTLR_R0, p);
12969 p += 4;
12970 bfd_put_32 (htab->glink->owner, SUB_R12_R12_R11, p);
12971 p += 4;
12972 bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
12973 p += 4;
12974 bfd_put_32 (htab->glink->owner, ADDI_R0_R12 | (-48 & 0xffff), p);
12975 p += 4;
12976 bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
12977 p += 4;
12978 bfd_put_32 (htab->glink->owner, SRDI_R0_R0_2, p);
12979 p += 4;
12980 bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
12981 p += 4;
12982 bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 8, p);
12983 p += 4;
12984 }
12985 bfd_put_32 (htab->glink->owner, BCTR, p);
12986 p += 4;
12987 while (p - htab->glink->contents < GLINK_CALL_STUB_SIZE)
12988 {
12989 bfd_put_32 (htab->glink->owner, NOP, p);
12990 p += 4;
12991 }
12992
12993 /* Build the .glink lazy link call stubs. */
12994 indx = 0;
12995 while (p < htab->glink->contents + htab->glink->rawsize)
12996 {
12997 if (htab->opd_abi)
12998 {
12999 if (indx < 0x8000)
13000 {
13001 bfd_put_32 (htab->glink->owner, LI_R0_0 | indx, p);
13002 p += 4;
13003 }
13004 else
13005 {
13006 bfd_put_32 (htab->glink->owner, LIS_R0_0 | PPC_HI (indx), p);
13007 p += 4;
13008 bfd_put_32 (htab->glink->owner, ORI_R0_R0_0 | PPC_LO (indx),
13009 p);
13010 p += 4;
13011 }
13012 }
13013 bfd_put_32 (htab->glink->owner,
13014 B_DOT | ((htab->glink->contents - p + 8) & 0x3fffffc), p);
13015 indx++;
13016 p += 4;
13017 }
13018
13019 /* Build .glink global entry stubs. */
13020 if (htab->glink->size > htab->glink->rawsize)
13021 elf_link_hash_traverse (&htab->elf, build_global_entry_stubs, info);
13022 }
13023
13024 if (htab->brlt != NULL && htab->brlt->size != 0)
13025 {
13026 htab->brlt->contents = bfd_zalloc (htab->brlt->owner,
13027 htab->brlt->size);
13028 if (htab->brlt->contents == NULL)
13029 return FALSE;
13030 }
13031 if (htab->relbrlt != NULL && htab->relbrlt->size != 0)
13032 {
13033 htab->relbrlt->contents = bfd_zalloc (htab->relbrlt->owner,
13034 htab->relbrlt->size);
13035 if (htab->relbrlt->contents == NULL)
13036 return FALSE;
13037 }
13038
13039 /* Build the stubs as directed by the stub hash table. */
13040 bfd_hash_traverse (&htab->stub_hash_table, ppc_build_one_stub, info);
13041
13042 for (group = htab->group; group != NULL; group = group->next)
13043 if (group->needs_save_res)
13044 {
13045 stub_sec = group->stub_sec;
13046 memcpy (stub_sec->contents + stub_sec->size, htab->sfpr->contents,
13047 htab->sfpr->size);
13048 if (htab->params->emit_stub_syms)
13049 {
13050 unsigned int i;
13051
13052 for (i = 0; i < ARRAY_SIZE (save_res_funcs); i++)
13053 if (!sfpr_define (info, &save_res_funcs[i], stub_sec))
13054 return FALSE;
13055 }
13056 stub_sec->size += htab->sfpr->size;
13057 }
13058
13059 if (htab->relbrlt != NULL)
13060 htab->relbrlt->reloc_count = 0;
13061
13062 if (htab->params->plt_stub_align != 0)
13063 for (stub_sec = htab->params->stub_bfd->sections;
13064 stub_sec != NULL;
13065 stub_sec = stub_sec->next)
13066 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
13067 stub_sec->size = ((stub_sec->size
13068 + (1 << htab->params->plt_stub_align) - 1)
13069 & -(1 << htab->params->plt_stub_align));
13070
13071 for (stub_sec = htab->params->stub_bfd->sections;
13072 stub_sec != NULL;
13073 stub_sec = stub_sec->next)
13074 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
13075 {
13076 stub_sec_count += 1;
13077 if (stub_sec->rawsize != stub_sec->size)
13078 break;
13079 }
13080
13081 /* Note that the glink_eh_frame check here is not only testing that
13082 the generated size matched the calculated size but also that
13083 bfd_elf_discard_info didn't make any changes to the section. */
13084 if (stub_sec != NULL
13085 || (htab->glink_eh_frame != NULL
13086 && htab->glink_eh_frame->rawsize != htab->glink_eh_frame->size))
13087 {
13088 htab->stub_error = TRUE;
13089 info->callbacks->einfo (_("%P: stubs don't match calculated size\n"));
13090 }
13091
13092 if (htab->stub_error)
13093 return FALSE;
13094
13095 if (stats != NULL)
13096 {
13097 *stats = bfd_malloc (500);
13098 if (*stats == NULL)
13099 return FALSE;
13100
13101 sprintf (*stats, _("linker stubs in %u group%s\n"
13102 " branch %lu\n"
13103 " toc adjust %lu\n"
13104 " long branch %lu\n"
13105 " long toc adj %lu\n"
13106 " plt call %lu\n"
13107 " plt call toc %lu\n"
13108 " global entry %lu"),
13109 stub_sec_count,
13110 stub_sec_count == 1 ? "" : "s",
13111 htab->stub_count[ppc_stub_long_branch - 1],
13112 htab->stub_count[ppc_stub_long_branch_r2off - 1],
13113 htab->stub_count[ppc_stub_plt_branch - 1],
13114 htab->stub_count[ppc_stub_plt_branch_r2off - 1],
13115 htab->stub_count[ppc_stub_plt_call - 1],
13116 htab->stub_count[ppc_stub_plt_call_r2save - 1],
13117 htab->stub_count[ppc_stub_global_entry - 1]);
13118 }
13119 return TRUE;
13120 }
13121
13122 /* This function undoes the changes made by add_symbol_adjust. */
13123
13124 static bfd_boolean
13125 undo_symbol_twiddle (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
13126 {
13127 struct ppc_link_hash_entry *eh;
13128
13129 if (h->root.type == bfd_link_hash_indirect)
13130 return TRUE;
13131
13132 eh = (struct ppc_link_hash_entry *) h;
13133 if (eh->elf.root.type != bfd_link_hash_undefweak || !eh->was_undefined)
13134 return TRUE;
13135
13136 eh->elf.root.type = bfd_link_hash_undefined;
13137 return TRUE;
13138 }
13139
13140 void
13141 ppc64_elf_restore_symbols (struct bfd_link_info *info)
13142 {
13143 struct ppc_link_hash_table *htab = ppc_hash_table (info);
13144
13145 if (htab != NULL)
13146 elf_link_hash_traverse (&htab->elf, undo_symbol_twiddle, info);
13147 }
13148
13149 /* What to do when ld finds relocations against symbols defined in
13150 discarded sections. */
13151
13152 static unsigned int
13153 ppc64_elf_action_discarded (asection *sec)
13154 {
13155 if (strcmp (".opd", sec->name) == 0)
13156 return 0;
13157
13158 if (strcmp (".toc", sec->name) == 0)
13159 return 0;
13160
13161 if (strcmp (".toc1", sec->name) == 0)
13162 return 0;
13163
13164 return _bfd_elf_default_action_discarded (sec);
13165 }
13166
13167 /* The RELOCATE_SECTION function is called by the ELF backend linker
13168 to handle the relocations for a section.
13169
13170 The relocs are always passed as Rela structures; if the section
13171 actually uses Rel structures, the r_addend field will always be
13172 zero.
13173
13174 This function is responsible for adjust the section contents as
13175 necessary, and (if using Rela relocs and generating a
13176 relocatable output file) adjusting the reloc addend as
13177 necessary.
13178
13179 This function does not have to worry about setting the reloc
13180 address or the reloc symbol index.
13181
13182 LOCAL_SYMS is a pointer to the swapped in local symbols.
13183
13184 LOCAL_SECTIONS is an array giving the section in the input file
13185 corresponding to the st_shndx field of each local symbol.
13186
13187 The global hash table entry for the global symbols can be found
13188 via elf_sym_hashes (input_bfd).
13189
13190 When generating relocatable output, this function must handle
13191 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
13192 going to be the section symbol corresponding to the output
13193 section, which means that the addend must be adjusted
13194 accordingly. */
13195
13196 static bfd_boolean
13197 ppc64_elf_relocate_section (bfd *output_bfd,
13198 struct bfd_link_info *info,
13199 bfd *input_bfd,
13200 asection *input_section,
13201 bfd_byte *contents,
13202 Elf_Internal_Rela *relocs,
13203 Elf_Internal_Sym *local_syms,
13204 asection **local_sections)
13205 {
13206 struct ppc_link_hash_table *htab;
13207 Elf_Internal_Shdr *symtab_hdr;
13208 struct elf_link_hash_entry **sym_hashes;
13209 Elf_Internal_Rela *rel;
13210 Elf_Internal_Rela *wrel;
13211 Elf_Internal_Rela *relend;
13212 Elf_Internal_Rela outrel;
13213 bfd_byte *loc;
13214 struct got_entry **local_got_ents;
13215 bfd_vma TOCstart;
13216 bfd_boolean ret = TRUE;
13217 bfd_boolean is_opd;
13218 /* Assume 'at' branch hints. */
13219 bfd_boolean is_isa_v2 = TRUE;
13220 bfd_vma d_offset = (bfd_big_endian (output_bfd) ? 2 : 0);
13221
13222 /* Initialize howto table if needed. */
13223 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
13224 ppc_howto_init ();
13225
13226 htab = ppc_hash_table (info);
13227 if (htab == NULL)
13228 return FALSE;
13229
13230 /* Don't relocate stub sections. */
13231 if (input_section->owner == htab->params->stub_bfd)
13232 return TRUE;
13233
13234 BFD_ASSERT (is_ppc64_elf (input_bfd));
13235
13236 local_got_ents = elf_local_got_ents (input_bfd);
13237 TOCstart = elf_gp (output_bfd);
13238 symtab_hdr = &elf_symtab_hdr (input_bfd);
13239 sym_hashes = elf_sym_hashes (input_bfd);
13240 is_opd = ppc64_elf_section_data (input_section)->sec_type == sec_opd;
13241
13242 rel = wrel = relocs;
13243 relend = relocs + input_section->reloc_count;
13244 for (; rel < relend; wrel++, rel++)
13245 {
13246 enum elf_ppc64_reloc_type r_type;
13247 bfd_vma addend;
13248 bfd_reloc_status_type r;
13249 Elf_Internal_Sym *sym;
13250 asection *sec;
13251 struct elf_link_hash_entry *h_elf;
13252 struct ppc_link_hash_entry *h;
13253 struct ppc_link_hash_entry *fdh;
13254 const char *sym_name;
13255 unsigned long r_symndx, toc_symndx;
13256 bfd_vma toc_addend;
13257 unsigned char tls_mask, tls_gd, tls_type;
13258 unsigned char sym_type;
13259 bfd_vma relocation;
13260 bfd_boolean unresolved_reloc;
13261 bfd_boolean warned;
13262 enum { DEST_NORMAL, DEST_OPD, DEST_STUB } reloc_dest;
13263 unsigned int insn;
13264 unsigned int mask;
13265 struct ppc_stub_hash_entry *stub_entry;
13266 bfd_vma max_br_offset;
13267 bfd_vma from;
13268 Elf_Internal_Rela orig_rel;
13269 reloc_howto_type *howto;
13270 struct reloc_howto_struct alt_howto;
13271
13272 again:
13273 orig_rel = *rel;
13274
13275 r_type = ELF64_R_TYPE (rel->r_info);
13276 r_symndx = ELF64_R_SYM (rel->r_info);
13277
13278 /* For old style R_PPC64_TOC relocs with a zero symbol, use the
13279 symbol of the previous ADDR64 reloc. The symbol gives us the
13280 proper TOC base to use. */
13281 if (rel->r_info == ELF64_R_INFO (0, R_PPC64_TOC)
13282 && wrel != relocs
13283 && ELF64_R_TYPE (wrel[-1].r_info) == R_PPC64_ADDR64
13284 && is_opd)
13285 r_symndx = ELF64_R_SYM (wrel[-1].r_info);
13286
13287 sym = NULL;
13288 sec = NULL;
13289 h_elf = NULL;
13290 sym_name = NULL;
13291 unresolved_reloc = FALSE;
13292 warned = FALSE;
13293
13294 if (r_symndx < symtab_hdr->sh_info)
13295 {
13296 /* It's a local symbol. */
13297 struct _opd_sec_data *opd;
13298
13299 sym = local_syms + r_symndx;
13300 sec = local_sections[r_symndx];
13301 sym_name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym, sec);
13302 sym_type = ELF64_ST_TYPE (sym->st_info);
13303 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
13304 opd = get_opd_info (sec);
13305 if (opd != NULL && opd->adjust != NULL)
13306 {
13307 long adjust = opd->adjust[OPD_NDX (sym->st_value
13308 + rel->r_addend)];
13309 if (adjust == -1)
13310 relocation = 0;
13311 else
13312 {
13313 /* If this is a relocation against the opd section sym
13314 and we have edited .opd, adjust the reloc addend so
13315 that ld -r and ld --emit-relocs output is correct.
13316 If it is a reloc against some other .opd symbol,
13317 then the symbol value will be adjusted later. */
13318 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
13319 rel->r_addend += adjust;
13320 else
13321 relocation += adjust;
13322 }
13323 }
13324 }
13325 else
13326 {
13327 bfd_boolean ignored;
13328
13329 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
13330 r_symndx, symtab_hdr, sym_hashes,
13331 h_elf, sec, relocation,
13332 unresolved_reloc, warned, ignored);
13333 sym_name = h_elf->root.root.string;
13334 sym_type = h_elf->type;
13335 if (sec != NULL
13336 && sec->owner == output_bfd
13337 && strcmp (sec->name, ".opd") == 0)
13338 {
13339 /* This is a symbol defined in a linker script. All
13340 such are defined in output sections, even those
13341 defined by simple assignment from a symbol defined in
13342 an input section. Transfer the symbol to an
13343 appropriate input .opd section, so that a branch to
13344 this symbol will be mapped to the location specified
13345 by the opd entry. */
13346 struct bfd_link_order *lo;
13347 for (lo = sec->map_head.link_order; lo != NULL; lo = lo->next)
13348 if (lo->type == bfd_indirect_link_order)
13349 {
13350 asection *isec = lo->u.indirect.section;
13351 if (h_elf->root.u.def.value >= isec->output_offset
13352 && h_elf->root.u.def.value < (isec->output_offset
13353 + isec->size))
13354 {
13355 h_elf->root.u.def.value -= isec->output_offset;
13356 h_elf->root.u.def.section = isec;
13357 sec = isec;
13358 break;
13359 }
13360 }
13361 }
13362 }
13363 h = (struct ppc_link_hash_entry *) h_elf;
13364
13365 if (sec != NULL && discarded_section (sec))
13366 {
13367 _bfd_clear_contents (ppc64_elf_howto_table[r_type],
13368 input_bfd, input_section,
13369 contents + rel->r_offset);
13370 wrel->r_offset = rel->r_offset;
13371 wrel->r_info = 0;
13372 wrel->r_addend = 0;
13373
13374 /* For ld -r, remove relocations in debug sections against
13375 sections defined in discarded sections. Not done for
13376 non-debug to preserve relocs in .eh_frame which the
13377 eh_frame editing code expects to be present. */
13378 if (bfd_link_relocatable (info)
13379 && (input_section->flags & SEC_DEBUGGING))
13380 wrel--;
13381
13382 continue;
13383 }
13384
13385 if (bfd_link_relocatable (info))
13386 goto copy_reloc;
13387
13388 if (h != NULL && &h->elf == htab->elf.hgot)
13389 {
13390 relocation = TOCstart + htab->sec_info[input_section->id].toc_off;
13391 sec = bfd_abs_section_ptr;
13392 unresolved_reloc = FALSE;
13393 }
13394
13395 /* TLS optimizations. Replace instruction sequences and relocs
13396 based on information we collected in tls_optimize. We edit
13397 RELOCS so that --emit-relocs will output something sensible
13398 for the final instruction stream. */
13399 tls_mask = 0;
13400 tls_gd = 0;
13401 toc_symndx = 0;
13402 if (h != NULL)
13403 tls_mask = h->tls_mask;
13404 else if (local_got_ents != NULL)
13405 {
13406 struct plt_entry **local_plt = (struct plt_entry **)
13407 (local_got_ents + symtab_hdr->sh_info);
13408 unsigned char *lgot_masks = (unsigned char *)
13409 (local_plt + symtab_hdr->sh_info);
13410 tls_mask = lgot_masks[r_symndx];
13411 }
13412 if (tls_mask == 0
13413 && (r_type == R_PPC64_TLS
13414 || r_type == R_PPC64_TLSGD
13415 || r_type == R_PPC64_TLSLD))
13416 {
13417 /* Check for toc tls entries. */
13418 unsigned char *toc_tls;
13419
13420 if (!get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
13421 &local_syms, rel, input_bfd))
13422 return FALSE;
13423
13424 if (toc_tls)
13425 tls_mask = *toc_tls;
13426 }
13427
13428 /* Check that tls relocs are used with tls syms, and non-tls
13429 relocs are used with non-tls syms. */
13430 if (r_symndx != STN_UNDEF
13431 && r_type != R_PPC64_NONE
13432 && (h == NULL
13433 || h->elf.root.type == bfd_link_hash_defined
13434 || h->elf.root.type == bfd_link_hash_defweak)
13435 && (IS_PPC64_TLS_RELOC (r_type)
13436 != (sym_type == STT_TLS
13437 || (sym_type == STT_SECTION
13438 && (sec->flags & SEC_THREAD_LOCAL) != 0))))
13439 {
13440 if (tls_mask != 0
13441 && (r_type == R_PPC64_TLS
13442 || r_type == R_PPC64_TLSGD
13443 || r_type == R_PPC64_TLSLD))
13444 /* R_PPC64_TLS is OK against a symbol in the TOC. */
13445 ;
13446 else
13447 info->callbacks->einfo
13448 (!IS_PPC64_TLS_RELOC (r_type)
13449 ? _("%P: %H: %s used with TLS symbol `%T'\n")
13450 : _("%P: %H: %s used with non-TLS symbol `%T'\n"),
13451 input_bfd, input_section, rel->r_offset,
13452 ppc64_elf_howto_table[r_type]->name,
13453 sym_name);
13454 }
13455
13456 /* Ensure reloc mapping code below stays sane. */
13457 if (R_PPC64_TOC16_LO_DS != R_PPC64_TOC16_DS + 1
13458 || R_PPC64_TOC16_LO != R_PPC64_TOC16 + 1
13459 || (R_PPC64_GOT_TLSLD16 & 3) != (R_PPC64_GOT_TLSGD16 & 3)
13460 || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TLSGD16_LO & 3)
13461 || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TLSGD16_HI & 3)
13462 || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TLSGD16_HA & 3)
13463 || (R_PPC64_GOT_TLSLD16 & 3) != (R_PPC64_GOT_TPREL16_DS & 3)
13464 || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TPREL16_LO_DS & 3)
13465 || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TPREL16_HI & 3)
13466 || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TPREL16_HA & 3))
13467 abort ();
13468
13469 switch (r_type)
13470 {
13471 default:
13472 break;
13473
13474 case R_PPC64_LO_DS_OPT:
13475 insn = bfd_get_32 (output_bfd, contents + rel->r_offset - d_offset);
13476 if ((insn & (0x3f << 26)) != 58u << 26)
13477 abort ();
13478 insn += (14u << 26) - (58u << 26);
13479 bfd_put_32 (output_bfd, insn, contents + rel->r_offset - d_offset);
13480 r_type = R_PPC64_TOC16_LO;
13481 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13482 break;
13483
13484 case R_PPC64_TOC16:
13485 case R_PPC64_TOC16_LO:
13486 case R_PPC64_TOC16_DS:
13487 case R_PPC64_TOC16_LO_DS:
13488 {
13489 /* Check for toc tls entries. */
13490 unsigned char *toc_tls;
13491 int retval;
13492
13493 retval = get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
13494 &local_syms, rel, input_bfd);
13495 if (retval == 0)
13496 return FALSE;
13497
13498 if (toc_tls)
13499 {
13500 tls_mask = *toc_tls;
13501 if (r_type == R_PPC64_TOC16_DS
13502 || r_type == R_PPC64_TOC16_LO_DS)
13503 {
13504 if (tls_mask != 0
13505 && (tls_mask & (TLS_DTPREL | TLS_TPREL)) == 0)
13506 goto toctprel;
13507 }
13508 else
13509 {
13510 /* If we found a GD reloc pair, then we might be
13511 doing a GD->IE transition. */
13512 if (retval == 2)
13513 {
13514 tls_gd = TLS_TPRELGD;
13515 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13516 goto tls_ldgd_opt;
13517 }
13518 else if (retval == 3)
13519 {
13520 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13521 goto tls_ldgd_opt;
13522 }
13523 }
13524 }
13525 }
13526 break;
13527
13528 case R_PPC64_GOT_TPREL16_HI:
13529 case R_PPC64_GOT_TPREL16_HA:
13530 if (tls_mask != 0
13531 && (tls_mask & TLS_TPREL) == 0)
13532 {
13533 rel->r_offset -= d_offset;
13534 bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
13535 r_type = R_PPC64_NONE;
13536 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13537 }
13538 break;
13539
13540 case R_PPC64_GOT_TPREL16_DS:
13541 case R_PPC64_GOT_TPREL16_LO_DS:
13542 if (tls_mask != 0
13543 && (tls_mask & TLS_TPREL) == 0)
13544 {
13545 toctprel:
13546 insn = bfd_get_32 (output_bfd,
13547 contents + rel->r_offset - d_offset);
13548 insn &= 31 << 21;
13549 insn |= 0x3c0d0000; /* addis 0,13,0 */
13550 bfd_put_32 (output_bfd, insn,
13551 contents + rel->r_offset - d_offset);
13552 r_type = R_PPC64_TPREL16_HA;
13553 if (toc_symndx != 0)
13554 {
13555 rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
13556 rel->r_addend = toc_addend;
13557 /* We changed the symbol. Start over in order to
13558 get h, sym, sec etc. right. */
13559 goto again;
13560 }
13561 else
13562 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13563 }
13564 break;
13565
13566 case R_PPC64_TLS:
13567 if (tls_mask != 0
13568 && (tls_mask & TLS_TPREL) == 0)
13569 {
13570 insn = bfd_get_32 (output_bfd, contents + rel->r_offset);
13571 insn = _bfd_elf_ppc_at_tls_transform (insn, 13);
13572 if (insn == 0)
13573 abort ();
13574 bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
13575 /* Was PPC64_TLS which sits on insn boundary, now
13576 PPC64_TPREL16_LO which is at low-order half-word. */
13577 rel->r_offset += d_offset;
13578 r_type = R_PPC64_TPREL16_LO;
13579 if (toc_symndx != 0)
13580 {
13581 rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
13582 rel->r_addend = toc_addend;
13583 /* We changed the symbol. Start over in order to
13584 get h, sym, sec etc. right. */
13585 goto again;
13586 }
13587 else
13588 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13589 }
13590 break;
13591
13592 case R_PPC64_GOT_TLSGD16_HI:
13593 case R_PPC64_GOT_TLSGD16_HA:
13594 tls_gd = TLS_TPRELGD;
13595 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13596 goto tls_gdld_hi;
13597 break;
13598
13599 case R_PPC64_GOT_TLSLD16_HI:
13600 case R_PPC64_GOT_TLSLD16_HA:
13601 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13602 {
13603 tls_gdld_hi:
13604 if ((tls_mask & tls_gd) != 0)
13605 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
13606 + R_PPC64_GOT_TPREL16_DS);
13607 else
13608 {
13609 rel->r_offset -= d_offset;
13610 bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
13611 r_type = R_PPC64_NONE;
13612 }
13613 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13614 }
13615 break;
13616
13617 case R_PPC64_GOT_TLSGD16:
13618 case R_PPC64_GOT_TLSGD16_LO:
13619 tls_gd = TLS_TPRELGD;
13620 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13621 goto tls_ldgd_opt;
13622 break;
13623
13624 case R_PPC64_GOT_TLSLD16:
13625 case R_PPC64_GOT_TLSLD16_LO:
13626 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13627 {
13628 unsigned int insn1, insn2, insn3;
13629 bfd_vma offset;
13630
13631 tls_ldgd_opt:
13632 offset = (bfd_vma) -1;
13633 /* If not using the newer R_PPC64_TLSGD/LD to mark
13634 __tls_get_addr calls, we must trust that the call
13635 stays with its arg setup insns, ie. that the next
13636 reloc is the __tls_get_addr call associated with
13637 the current reloc. Edit both insns. */
13638 if (input_section->has_tls_get_addr_call
13639 && rel + 1 < relend
13640 && branch_reloc_hash_match (input_bfd, rel + 1,
13641 htab->tls_get_addr,
13642 htab->tls_get_addr_fd))
13643 offset = rel[1].r_offset;
13644 /* We read the low GOT_TLS (or TOC16) insn because we
13645 need to keep the destination reg. It may be
13646 something other than the usual r3, and moved to r3
13647 before the call by intervening code. */
13648 insn1 = bfd_get_32 (output_bfd,
13649 contents + rel->r_offset - d_offset);
13650 if ((tls_mask & tls_gd) != 0)
13651 {
13652 /* IE */
13653 insn1 &= (0x1f << 21) | (0x1f << 16);
13654 insn1 |= 58 << 26; /* ld */
13655 insn2 = 0x7c636a14; /* add 3,3,13 */
13656 if (offset != (bfd_vma) -1)
13657 rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13658 if ((tls_mask & TLS_EXPLICIT) == 0)
13659 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
13660 + R_PPC64_GOT_TPREL16_DS);
13661 else
13662 r_type += R_PPC64_TOC16_DS - R_PPC64_TOC16;
13663 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13664 }
13665 else
13666 {
13667 /* LE */
13668 insn1 &= 0x1f << 21;
13669 insn1 |= 0x3c0d0000; /* addis r,13,0 */
13670 insn2 = 0x38630000; /* addi 3,3,0 */
13671 if (tls_gd == 0)
13672 {
13673 /* Was an LD reloc. */
13674 if (toc_symndx)
13675 sec = local_sections[toc_symndx];
13676 for (r_symndx = 0;
13677 r_symndx < symtab_hdr->sh_info;
13678 r_symndx++)
13679 if (local_sections[r_symndx] == sec)
13680 break;
13681 if (r_symndx >= symtab_hdr->sh_info)
13682 r_symndx = STN_UNDEF;
13683 rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
13684 if (r_symndx != STN_UNDEF)
13685 rel->r_addend -= (local_syms[r_symndx].st_value
13686 + sec->output_offset
13687 + sec->output_section->vma);
13688 }
13689 else if (toc_symndx != 0)
13690 {
13691 r_symndx = toc_symndx;
13692 rel->r_addend = toc_addend;
13693 }
13694 r_type = R_PPC64_TPREL16_HA;
13695 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13696 if (offset != (bfd_vma) -1)
13697 {
13698 rel[1].r_info = ELF64_R_INFO (r_symndx,
13699 R_PPC64_TPREL16_LO);
13700 rel[1].r_offset = offset + d_offset;
13701 rel[1].r_addend = rel->r_addend;
13702 }
13703 }
13704 bfd_put_32 (output_bfd, insn1,
13705 contents + rel->r_offset - d_offset);
13706 if (offset != (bfd_vma) -1)
13707 {
13708 insn3 = bfd_get_32 (output_bfd,
13709 contents + offset + 4);
13710 if (insn3 == NOP
13711 || insn3 == CROR_151515 || insn3 == CROR_313131)
13712 {
13713 rel[1].r_offset += 4;
13714 bfd_put_32 (output_bfd, insn2, contents + offset + 4);
13715 insn2 = NOP;
13716 }
13717 bfd_put_32 (output_bfd, insn2, contents + offset);
13718 }
13719 if ((tls_mask & tls_gd) == 0
13720 && (tls_gd == 0 || toc_symndx != 0))
13721 {
13722 /* We changed the symbol. Start over in order
13723 to get h, sym, sec etc. right. */
13724 goto again;
13725 }
13726 }
13727 break;
13728
13729 case R_PPC64_TLSGD:
13730 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13731 {
13732 unsigned int insn2, insn3;
13733 bfd_vma offset = rel->r_offset;
13734
13735 if ((tls_mask & TLS_TPRELGD) != 0)
13736 {
13737 /* IE */
13738 r_type = R_PPC64_NONE;
13739 insn2 = 0x7c636a14; /* add 3,3,13 */
13740 }
13741 else
13742 {
13743 /* LE */
13744 if (toc_symndx != 0)
13745 {
13746 r_symndx = toc_symndx;
13747 rel->r_addend = toc_addend;
13748 }
13749 r_type = R_PPC64_TPREL16_LO;
13750 rel->r_offset = offset + d_offset;
13751 insn2 = 0x38630000; /* addi 3,3,0 */
13752 }
13753 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13754 /* Zap the reloc on the _tls_get_addr call too. */
13755 BFD_ASSERT (offset == rel[1].r_offset);
13756 rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13757 insn3 = bfd_get_32 (output_bfd,
13758 contents + offset + 4);
13759 if (insn3 == NOP
13760 || insn3 == CROR_151515 || insn3 == CROR_313131)
13761 {
13762 rel->r_offset += 4;
13763 bfd_put_32 (output_bfd, insn2, contents + offset + 4);
13764 insn2 = NOP;
13765 }
13766 bfd_put_32 (output_bfd, insn2, contents + offset);
13767 if ((tls_mask & TLS_TPRELGD) == 0 && toc_symndx != 0)
13768 goto again;
13769 }
13770 break;
13771
13772 case R_PPC64_TLSLD:
13773 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13774 {
13775 unsigned int insn2, insn3;
13776 bfd_vma offset = rel->r_offset;
13777
13778 if (toc_symndx)
13779 sec = local_sections[toc_symndx];
13780 for (r_symndx = 0;
13781 r_symndx < symtab_hdr->sh_info;
13782 r_symndx++)
13783 if (local_sections[r_symndx] == sec)
13784 break;
13785 if (r_symndx >= symtab_hdr->sh_info)
13786 r_symndx = STN_UNDEF;
13787 rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
13788 if (r_symndx != STN_UNDEF)
13789 rel->r_addend -= (local_syms[r_symndx].st_value
13790 + sec->output_offset
13791 + sec->output_section->vma);
13792
13793 r_type = R_PPC64_TPREL16_LO;
13794 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13795 rel->r_offset = offset + d_offset;
13796 /* Zap the reloc on the _tls_get_addr call too. */
13797 BFD_ASSERT (offset == rel[1].r_offset);
13798 rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13799 insn2 = 0x38630000; /* addi 3,3,0 */
13800 insn3 = bfd_get_32 (output_bfd,
13801 contents + offset + 4);
13802 if (insn3 == NOP
13803 || insn3 == CROR_151515 || insn3 == CROR_313131)
13804 {
13805 rel->r_offset += 4;
13806 bfd_put_32 (output_bfd, insn2, contents + offset + 4);
13807 insn2 = NOP;
13808 }
13809 bfd_put_32 (output_bfd, insn2, contents + offset);
13810 goto again;
13811 }
13812 break;
13813
13814 case R_PPC64_DTPMOD64:
13815 if (rel + 1 < relend
13816 && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
13817 && rel[1].r_offset == rel->r_offset + 8)
13818 {
13819 if ((tls_mask & TLS_GD) == 0)
13820 {
13821 rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_NONE);
13822 if ((tls_mask & TLS_TPRELGD) != 0)
13823 r_type = R_PPC64_TPREL64;
13824 else
13825 {
13826 bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
13827 r_type = R_PPC64_NONE;
13828 }
13829 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13830 }
13831 }
13832 else
13833 {
13834 if ((tls_mask & TLS_LD) == 0)
13835 {
13836 bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
13837 r_type = R_PPC64_NONE;
13838 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13839 }
13840 }
13841 break;
13842
13843 case R_PPC64_TPREL64:
13844 if ((tls_mask & TLS_TPREL) == 0)
13845 {
13846 r_type = R_PPC64_NONE;
13847 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13848 }
13849 break;
13850
13851 case R_PPC64_REL16_HA:
13852 /* If we are generating a non-PIC executable, edit
13853 . 0: addis 2,12,.TOC.-0b@ha
13854 . addi 2,2,.TOC.-0b@l
13855 used by ELFv2 global entry points to set up r2, to
13856 . lis 2,.TOC.@ha
13857 . addi 2,2,.TOC.@l
13858 if .TOC. is in range. */
13859 if (!bfd_link_pic (info)
13860 && !info->traditional_format
13861 && h != NULL && &h->elf == htab->elf.hgot
13862 && rel + 1 < relend
13863 && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_REL16_LO)
13864 && rel[1].r_offset == rel->r_offset + 4
13865 && rel[1].r_addend == rel->r_addend + 4
13866 && relocation + 0x80008000 <= 0xffffffff)
13867 {
13868 unsigned int insn1, insn2;
13869 bfd_vma offset = rel->r_offset - d_offset;
13870 insn1 = bfd_get_32 (output_bfd, contents + offset);
13871 insn2 = bfd_get_32 (output_bfd, contents + offset + 4);
13872 if ((insn1 & 0xffff0000) == 0x3c4c0000 /* addis 2,12 */
13873 && (insn2 & 0xffff0000) == 0x38420000 /* addi 2,2 */)
13874 {
13875 r_type = R_PPC64_ADDR16_HA;
13876 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13877 rel->r_addend -= d_offset;
13878 rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_ADDR16_LO);
13879 rel[1].r_addend -= d_offset + 4;
13880 bfd_put_32 (output_bfd, 0x3c400000, contents + offset);
13881 }
13882 }
13883 break;
13884 }
13885
13886 /* Handle other relocations that tweak non-addend part of insn. */
13887 insn = 0;
13888 max_br_offset = 1 << 25;
13889 addend = rel->r_addend;
13890 reloc_dest = DEST_NORMAL;
13891 switch (r_type)
13892 {
13893 default:
13894 break;
13895
13896 case R_PPC64_TOCSAVE:
13897 if (relocation + addend == (rel->r_offset
13898 + input_section->output_offset
13899 + input_section->output_section->vma)
13900 && tocsave_find (htab, NO_INSERT,
13901 &local_syms, rel, input_bfd))
13902 {
13903 insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
13904 if (insn == NOP
13905 || insn == CROR_151515 || insn == CROR_313131)
13906 bfd_put_32 (input_bfd,
13907 STD_R2_0R1 + STK_TOC (htab),
13908 contents + rel->r_offset);
13909 }
13910 break;
13911
13912 /* Branch taken prediction relocations. */
13913 case R_PPC64_ADDR14_BRTAKEN:
13914 case R_PPC64_REL14_BRTAKEN:
13915 insn = 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field. */
13916 /* Fall thru. */
13917
13918 /* Branch not taken prediction relocations. */
13919 case R_PPC64_ADDR14_BRNTAKEN:
13920 case R_PPC64_REL14_BRNTAKEN:
13921 insn |= bfd_get_32 (output_bfd,
13922 contents + rel->r_offset) & ~(0x01 << 21);
13923 /* Fall thru. */
13924
13925 case R_PPC64_REL14:
13926 max_br_offset = 1 << 15;
13927 /* Fall thru. */
13928
13929 case R_PPC64_REL24:
13930 /* Calls to functions with a different TOC, such as calls to
13931 shared objects, need to alter the TOC pointer. This is
13932 done using a linkage stub. A REL24 branching to these
13933 linkage stubs needs to be followed by a nop, as the nop
13934 will be replaced with an instruction to restore the TOC
13935 base pointer. */
13936 fdh = h;
13937 if (h != NULL
13938 && h->oh != NULL
13939 && h->oh->is_func_descriptor)
13940 fdh = ppc_follow_link (h->oh);
13941 stub_entry = ppc_get_stub_entry (input_section, sec, fdh, &orig_rel,
13942 htab);
13943 if (stub_entry != NULL
13944 && (stub_entry->stub_type == ppc_stub_plt_call
13945 || stub_entry->stub_type == ppc_stub_plt_call_r2save
13946 || stub_entry->stub_type == ppc_stub_plt_branch_r2off
13947 || stub_entry->stub_type == ppc_stub_long_branch_r2off))
13948 {
13949 bfd_boolean can_plt_call = FALSE;
13950
13951 /* All of these stubs will modify r2, so there must be a
13952 branch and link followed by a nop. The nop is
13953 replaced by an insn to restore r2. */
13954 if (rel->r_offset + 8 <= input_section->size)
13955 {
13956 unsigned long br;
13957
13958 br = bfd_get_32 (input_bfd,
13959 contents + rel->r_offset);
13960 if ((br & 1) != 0)
13961 {
13962 unsigned long nop;
13963
13964 nop = bfd_get_32 (input_bfd,
13965 contents + rel->r_offset + 4);
13966 if (nop == NOP
13967 || nop == CROR_151515 || nop == CROR_313131)
13968 {
13969 if (h != NULL
13970 && (h == htab->tls_get_addr_fd
13971 || h == htab->tls_get_addr)
13972 && htab->params->tls_get_addr_opt)
13973 {
13974 /* Special stub used, leave nop alone. */
13975 }
13976 else
13977 bfd_put_32 (input_bfd,
13978 LD_R2_0R1 + STK_TOC (htab),
13979 contents + rel->r_offset + 4);
13980 can_plt_call = TRUE;
13981 }
13982 }
13983 }
13984
13985 if (!can_plt_call && h != NULL)
13986 {
13987 const char *name = h->elf.root.root.string;
13988
13989 if (*name == '.')
13990 ++name;
13991
13992 if (strncmp (name, "__libc_start_main", 17) == 0
13993 && (name[17] == 0 || name[17] == '@'))
13994 {
13995 /* Allow crt1 branch to go via a toc adjusting
13996 stub. Other calls that never return could do
13997 the same, if we could detect such. */
13998 can_plt_call = TRUE;
13999 }
14000 }
14001
14002 if (!can_plt_call)
14003 {
14004 /* g++ as of 20130507 emits self-calls without a
14005 following nop. This is arguably wrong since we
14006 have conflicting information. On the one hand a
14007 global symbol and on the other a local call
14008 sequence, but don't error for this special case.
14009 It isn't possible to cheaply verify we have
14010 exactly such a call. Allow all calls to the same
14011 section. */
14012 asection *code_sec = sec;
14013
14014 if (get_opd_info (sec) != NULL)
14015 {
14016 bfd_vma off = (relocation + addend
14017 - sec->output_section->vma
14018 - sec->output_offset);
14019
14020 opd_entry_value (sec, off, &code_sec, NULL, FALSE);
14021 }
14022 if (code_sec == input_section)
14023 can_plt_call = TRUE;
14024 }
14025
14026 if (!can_plt_call)
14027 {
14028 if (stub_entry->stub_type == ppc_stub_plt_call
14029 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
14030 info->callbacks->einfo
14031 (_("%P: %H: call to `%T' lacks nop, can't restore toc; "
14032 "recompile with -fPIC\n"),
14033 input_bfd, input_section, rel->r_offset, sym_name);
14034 else
14035 info->callbacks->einfo
14036 (_("%P: %H: call to `%T' lacks nop, can't restore toc; "
14037 "(-mcmodel=small toc adjust stub)\n"),
14038 input_bfd, input_section, rel->r_offset, sym_name);
14039
14040 bfd_set_error (bfd_error_bad_value);
14041 ret = FALSE;
14042 }
14043
14044 if (can_plt_call
14045 && (stub_entry->stub_type == ppc_stub_plt_call
14046 || stub_entry->stub_type == ppc_stub_plt_call_r2save))
14047 unresolved_reloc = FALSE;
14048 }
14049
14050 if ((stub_entry == NULL
14051 || stub_entry->stub_type == ppc_stub_long_branch
14052 || stub_entry->stub_type == ppc_stub_plt_branch)
14053 && get_opd_info (sec) != NULL)
14054 {
14055 /* The branch destination is the value of the opd entry. */
14056 bfd_vma off = (relocation + addend
14057 - sec->output_section->vma
14058 - sec->output_offset);
14059 bfd_vma dest = opd_entry_value (sec, off, NULL, NULL, FALSE);
14060 if (dest != (bfd_vma) -1)
14061 {
14062 relocation = dest;
14063 addend = 0;
14064 reloc_dest = DEST_OPD;
14065 }
14066 }
14067
14068 /* If the branch is out of reach we ought to have a long
14069 branch stub. */
14070 from = (rel->r_offset
14071 + input_section->output_offset
14072 + input_section->output_section->vma);
14073
14074 relocation += PPC64_LOCAL_ENTRY_OFFSET (fdh
14075 ? fdh->elf.other
14076 : sym->st_other);
14077
14078 if (stub_entry != NULL
14079 && (stub_entry->stub_type == ppc_stub_long_branch
14080 || stub_entry->stub_type == ppc_stub_plt_branch)
14081 && (r_type == R_PPC64_ADDR14_BRTAKEN
14082 || r_type == R_PPC64_ADDR14_BRNTAKEN
14083 || (relocation + addend - from + max_br_offset
14084 < 2 * max_br_offset)))
14085 /* Don't use the stub if this branch is in range. */
14086 stub_entry = NULL;
14087
14088 if (stub_entry != NULL)
14089 {
14090 /* Munge up the value and addend so that we call the stub
14091 rather than the procedure directly. */
14092 asection *stub_sec = stub_entry->group->stub_sec;
14093
14094 if (stub_entry->stub_type == ppc_stub_save_res)
14095 relocation += (stub_sec->output_offset
14096 + stub_sec->output_section->vma
14097 + stub_sec->size - htab->sfpr->size
14098 - htab->sfpr->output_offset
14099 - htab->sfpr->output_section->vma);
14100 else
14101 relocation = (stub_entry->stub_offset
14102 + stub_sec->output_offset
14103 + stub_sec->output_section->vma);
14104 addend = 0;
14105 reloc_dest = DEST_STUB;
14106
14107 if ((stub_entry->stub_type == ppc_stub_plt_call
14108 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
14109 && (ALWAYS_EMIT_R2SAVE
14110 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
14111 && rel + 1 < relend
14112 && rel[1].r_offset == rel->r_offset + 4
14113 && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOCSAVE)
14114 relocation += 4;
14115 }
14116
14117 if (insn != 0)
14118 {
14119 if (is_isa_v2)
14120 {
14121 /* Set 'a' bit. This is 0b00010 in BO field for branch
14122 on CR(BI) insns (BO == 001at or 011at), and 0b01000
14123 for branch on CTR insns (BO == 1a00t or 1a01t). */
14124 if ((insn & (0x14 << 21)) == (0x04 << 21))
14125 insn |= 0x02 << 21;
14126 else if ((insn & (0x14 << 21)) == (0x10 << 21))
14127 insn |= 0x08 << 21;
14128 else
14129 break;
14130 }
14131 else
14132 {
14133 /* Invert 'y' bit if not the default. */
14134 if ((bfd_signed_vma) (relocation + addend - from) < 0)
14135 insn ^= 0x01 << 21;
14136 }
14137
14138 bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
14139 }
14140
14141 /* NOP out calls to undefined weak functions.
14142 We can thus call a weak function without first
14143 checking whether the function is defined. */
14144 else if (h != NULL
14145 && h->elf.root.type == bfd_link_hash_undefweak
14146 && h->elf.dynindx == -1
14147 && r_type == R_PPC64_REL24
14148 && relocation == 0
14149 && addend == 0)
14150 {
14151 bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
14152 goto copy_reloc;
14153 }
14154 break;
14155 }
14156
14157 /* Set `addend'. */
14158 tls_type = 0;
14159 switch (r_type)
14160 {
14161 default:
14162 info->callbacks->einfo
14163 (_("%P: %B: unknown relocation type %d for `%T'\n"),
14164 input_bfd, (int) r_type, sym_name);
14165
14166 bfd_set_error (bfd_error_bad_value);
14167 ret = FALSE;
14168 goto copy_reloc;
14169
14170 case R_PPC64_NONE:
14171 case R_PPC64_TLS:
14172 case R_PPC64_TLSGD:
14173 case R_PPC64_TLSLD:
14174 case R_PPC64_TOCSAVE:
14175 case R_PPC64_GNU_VTINHERIT:
14176 case R_PPC64_GNU_VTENTRY:
14177 goto copy_reloc;
14178
14179 /* GOT16 relocations. Like an ADDR16 using the symbol's
14180 address in the GOT as relocation value instead of the
14181 symbol's value itself. Also, create a GOT entry for the
14182 symbol and put the symbol value there. */
14183 case R_PPC64_GOT_TLSGD16:
14184 case R_PPC64_GOT_TLSGD16_LO:
14185 case R_PPC64_GOT_TLSGD16_HI:
14186 case R_PPC64_GOT_TLSGD16_HA:
14187 tls_type = TLS_TLS | TLS_GD;
14188 goto dogot;
14189
14190 case R_PPC64_GOT_TLSLD16:
14191 case R_PPC64_GOT_TLSLD16_LO:
14192 case R_PPC64_GOT_TLSLD16_HI:
14193 case R_PPC64_GOT_TLSLD16_HA:
14194 tls_type = TLS_TLS | TLS_LD;
14195 goto dogot;
14196
14197 case R_PPC64_GOT_TPREL16_DS:
14198 case R_PPC64_GOT_TPREL16_LO_DS:
14199 case R_PPC64_GOT_TPREL16_HI:
14200 case R_PPC64_GOT_TPREL16_HA:
14201 tls_type = TLS_TLS | TLS_TPREL;
14202 goto dogot;
14203
14204 case R_PPC64_GOT_DTPREL16_DS:
14205 case R_PPC64_GOT_DTPREL16_LO_DS:
14206 case R_PPC64_GOT_DTPREL16_HI:
14207 case R_PPC64_GOT_DTPREL16_HA:
14208 tls_type = TLS_TLS | TLS_DTPREL;
14209 goto dogot;
14210
14211 case R_PPC64_GOT16:
14212 case R_PPC64_GOT16_LO:
14213 case R_PPC64_GOT16_HI:
14214 case R_PPC64_GOT16_HA:
14215 case R_PPC64_GOT16_DS:
14216 case R_PPC64_GOT16_LO_DS:
14217 dogot:
14218 {
14219 /* Relocation is to the entry for this symbol in the global
14220 offset table. */
14221 asection *got;
14222 bfd_vma *offp;
14223 bfd_vma off;
14224 unsigned long indx = 0;
14225 struct got_entry *ent;
14226
14227 if (tls_type == (TLS_TLS | TLS_LD)
14228 && (h == NULL
14229 || !h->elf.def_dynamic))
14230 ent = ppc64_tlsld_got (input_bfd);
14231 else
14232 {
14233
14234 if (h != NULL)
14235 {
14236 bfd_boolean dyn = htab->elf.dynamic_sections_created;
14237 if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, bfd_link_pic (info),
14238 &h->elf)
14239 || (bfd_link_pic (info)
14240 && SYMBOL_REFERENCES_LOCAL (info, &h->elf)))
14241 /* This is actually a static link, or it is a
14242 -Bsymbolic link and the symbol is defined
14243 locally, or the symbol was forced to be local
14244 because of a version file. */
14245 ;
14246 else
14247 {
14248 BFD_ASSERT (h->elf.dynindx != -1);
14249 indx = h->elf.dynindx;
14250 unresolved_reloc = FALSE;
14251 }
14252 ent = h->elf.got.glist;
14253 }
14254 else
14255 {
14256 if (local_got_ents == NULL)
14257 abort ();
14258 ent = local_got_ents[r_symndx];
14259 }
14260
14261 for (; ent != NULL; ent = ent->next)
14262 if (ent->addend == orig_rel.r_addend
14263 && ent->owner == input_bfd
14264 && ent->tls_type == tls_type)
14265 break;
14266 }
14267
14268 if (ent == NULL)
14269 abort ();
14270 if (ent->is_indirect)
14271 ent = ent->got.ent;
14272 offp = &ent->got.offset;
14273 got = ppc64_elf_tdata (ent->owner)->got;
14274 if (got == NULL)
14275 abort ();
14276
14277 /* The offset must always be a multiple of 8. We use the
14278 least significant bit to record whether we have already
14279 processed this entry. */
14280 off = *offp;
14281 if ((off & 1) != 0)
14282 off &= ~1;
14283 else
14284 {
14285 /* Generate relocs for the dynamic linker, except in
14286 the case of TLSLD where we'll use one entry per
14287 module. */
14288 asection *relgot;
14289 bfd_boolean ifunc;
14290
14291 *offp = off | 1;
14292 relgot = NULL;
14293 ifunc = (h != NULL
14294 ? h->elf.type == STT_GNU_IFUNC
14295 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC);
14296 if (ifunc)
14297 relgot = htab->elf.irelplt;
14298 else if ((bfd_link_pic (info) || indx != 0)
14299 && (h == NULL
14300 || (tls_type == (TLS_TLS | TLS_LD)
14301 && !h->elf.def_dynamic)
14302 || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
14303 || h->elf.root.type != bfd_link_hash_undefweak))
14304 relgot = ppc64_elf_tdata (ent->owner)->relgot;
14305 if (relgot != NULL)
14306 {
14307 outrel.r_offset = (got->output_section->vma
14308 + got->output_offset
14309 + off);
14310 outrel.r_addend = addend;
14311 if (tls_type & (TLS_LD | TLS_GD))
14312 {
14313 outrel.r_addend = 0;
14314 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPMOD64);
14315 if (tls_type == (TLS_TLS | TLS_GD))
14316 {
14317 loc = relgot->contents;
14318 loc += (relgot->reloc_count++
14319 * sizeof (Elf64_External_Rela));
14320 bfd_elf64_swap_reloca_out (output_bfd,
14321 &outrel, loc);
14322 outrel.r_offset += 8;
14323 outrel.r_addend = addend;
14324 outrel.r_info
14325 = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
14326 }
14327 }
14328 else if (tls_type == (TLS_TLS | TLS_DTPREL))
14329 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
14330 else if (tls_type == (TLS_TLS | TLS_TPREL))
14331 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_TPREL64);
14332 else if (indx != 0)
14333 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_GLOB_DAT);
14334 else
14335 {
14336 if (ifunc)
14337 outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
14338 else
14339 outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
14340
14341 /* Write the .got section contents for the sake
14342 of prelink. */
14343 loc = got->contents + off;
14344 bfd_put_64 (output_bfd, outrel.r_addend + relocation,
14345 loc);
14346 }
14347
14348 if (indx == 0 && tls_type != (TLS_TLS | TLS_LD))
14349 {
14350 outrel.r_addend += relocation;
14351 if (tls_type & (TLS_GD | TLS_DTPREL | TLS_TPREL))
14352 {
14353 if (htab->elf.tls_sec == NULL)
14354 outrel.r_addend = 0;
14355 else
14356 outrel.r_addend -= htab->elf.tls_sec->vma;
14357 }
14358 }
14359 loc = relgot->contents;
14360 loc += (relgot->reloc_count++
14361 * sizeof (Elf64_External_Rela));
14362 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
14363 }
14364
14365 /* Init the .got section contents here if we're not
14366 emitting a reloc. */
14367 else
14368 {
14369 relocation += addend;
14370 if (tls_type == (TLS_TLS | TLS_LD))
14371 relocation = 1;
14372 else if (tls_type != 0)
14373 {
14374 if (htab->elf.tls_sec == NULL)
14375 relocation = 0;
14376 else
14377 {
14378 relocation -= htab->elf.tls_sec->vma + DTP_OFFSET;
14379 if (tls_type == (TLS_TLS | TLS_TPREL))
14380 relocation += DTP_OFFSET - TP_OFFSET;
14381 }
14382
14383 if (tls_type == (TLS_TLS | TLS_GD))
14384 {
14385 bfd_put_64 (output_bfd, relocation,
14386 got->contents + off + 8);
14387 relocation = 1;
14388 }
14389 }
14390
14391 bfd_put_64 (output_bfd, relocation,
14392 got->contents + off);
14393 }
14394 }
14395
14396 if (off >= (bfd_vma) -2)
14397 abort ();
14398
14399 relocation = got->output_section->vma + got->output_offset + off;
14400 addend = -(TOCstart + htab->sec_info[input_section->id].toc_off);
14401 }
14402 break;
14403
14404 case R_PPC64_PLT16_HA:
14405 case R_PPC64_PLT16_HI:
14406 case R_PPC64_PLT16_LO:
14407 case R_PPC64_PLT32:
14408 case R_PPC64_PLT64:
14409 /* Relocation is to the entry for this symbol in the
14410 procedure linkage table. */
14411
14412 /* Resolve a PLT reloc against a local symbol directly,
14413 without using the procedure linkage table. */
14414 if (h == NULL)
14415 break;
14416
14417 /* It's possible that we didn't make a PLT entry for this
14418 symbol. This happens when statically linking PIC code,
14419 or when using -Bsymbolic. Go find a match if there is a
14420 PLT entry. */
14421 if (htab->elf.splt != NULL)
14422 {
14423 struct plt_entry *ent;
14424 for (ent = h->elf.plt.plist; ent != NULL; ent = ent->next)
14425 if (ent->plt.offset != (bfd_vma) -1
14426 && ent->addend == orig_rel.r_addend)
14427 {
14428 relocation = (htab->elf.splt->output_section->vma
14429 + htab->elf.splt->output_offset
14430 + ent->plt.offset);
14431 unresolved_reloc = FALSE;
14432 break;
14433 }
14434 }
14435 break;
14436
14437 case R_PPC64_TOC:
14438 /* Relocation value is TOC base. */
14439 relocation = TOCstart;
14440 if (r_symndx == STN_UNDEF)
14441 relocation += htab->sec_info[input_section->id].toc_off;
14442 else if (unresolved_reloc)
14443 ;
14444 else if (sec != NULL && sec->id < htab->sec_info_arr_size)
14445 relocation += htab->sec_info[sec->id].toc_off;
14446 else
14447 unresolved_reloc = TRUE;
14448 goto dodyn;
14449
14450 /* TOC16 relocs. We want the offset relative to the TOC base,
14451 which is the address of the start of the TOC plus 0x8000.
14452 The TOC consists of sections .got, .toc, .tocbss, and .plt,
14453 in this order. */
14454 case R_PPC64_TOC16:
14455 case R_PPC64_TOC16_LO:
14456 case R_PPC64_TOC16_HI:
14457 case R_PPC64_TOC16_DS:
14458 case R_PPC64_TOC16_LO_DS:
14459 case R_PPC64_TOC16_HA:
14460 addend -= TOCstart + htab->sec_info[input_section->id].toc_off;
14461 break;
14462
14463 /* Relocate against the beginning of the section. */
14464 case R_PPC64_SECTOFF:
14465 case R_PPC64_SECTOFF_LO:
14466 case R_PPC64_SECTOFF_HI:
14467 case R_PPC64_SECTOFF_DS:
14468 case R_PPC64_SECTOFF_LO_DS:
14469 case R_PPC64_SECTOFF_HA:
14470 if (sec != NULL)
14471 addend -= sec->output_section->vma;
14472 break;
14473
14474 case R_PPC64_REL16:
14475 case R_PPC64_REL16_LO:
14476 case R_PPC64_REL16_HI:
14477 case R_PPC64_REL16_HA:
14478 case R_PPC64_REL16DX_HA:
14479 break;
14480
14481 case R_PPC64_REL14:
14482 case R_PPC64_REL14_BRNTAKEN:
14483 case R_PPC64_REL14_BRTAKEN:
14484 case R_PPC64_REL24:
14485 break;
14486
14487 case R_PPC64_TPREL16:
14488 case R_PPC64_TPREL16_LO:
14489 case R_PPC64_TPREL16_HI:
14490 case R_PPC64_TPREL16_HA:
14491 case R_PPC64_TPREL16_DS:
14492 case R_PPC64_TPREL16_LO_DS:
14493 case R_PPC64_TPREL16_HIGH:
14494 case R_PPC64_TPREL16_HIGHA:
14495 case R_PPC64_TPREL16_HIGHER:
14496 case R_PPC64_TPREL16_HIGHERA:
14497 case R_PPC64_TPREL16_HIGHEST:
14498 case R_PPC64_TPREL16_HIGHESTA:
14499 if (h != NULL
14500 && h->elf.root.type == bfd_link_hash_undefweak
14501 && h->elf.dynindx == -1)
14502 {
14503 /* Make this relocation against an undefined weak symbol
14504 resolve to zero. This is really just a tweak, since
14505 code using weak externs ought to check that they are
14506 defined before using them. */
14507 bfd_byte *p = contents + rel->r_offset - d_offset;
14508
14509 insn = bfd_get_32 (output_bfd, p);
14510 insn = _bfd_elf_ppc_at_tprel_transform (insn, 13);
14511 if (insn != 0)
14512 bfd_put_32 (output_bfd, insn, p);
14513 break;
14514 }
14515 if (htab->elf.tls_sec != NULL)
14516 addend -= htab->elf.tls_sec->vma + TP_OFFSET;
14517 if (bfd_link_pic (info))
14518 /* The TPREL16 relocs shouldn't really be used in shared
14519 libs as they will result in DT_TEXTREL being set, but
14520 support them anyway. */
14521 goto dodyn;
14522 break;
14523
14524 case R_PPC64_DTPREL16:
14525 case R_PPC64_DTPREL16_LO:
14526 case R_PPC64_DTPREL16_HI:
14527 case R_PPC64_DTPREL16_HA:
14528 case R_PPC64_DTPREL16_DS:
14529 case R_PPC64_DTPREL16_LO_DS:
14530 case R_PPC64_DTPREL16_HIGH:
14531 case R_PPC64_DTPREL16_HIGHA:
14532 case R_PPC64_DTPREL16_HIGHER:
14533 case R_PPC64_DTPREL16_HIGHERA:
14534 case R_PPC64_DTPREL16_HIGHEST:
14535 case R_PPC64_DTPREL16_HIGHESTA:
14536 if (htab->elf.tls_sec != NULL)
14537 addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
14538 break;
14539
14540 case R_PPC64_ADDR64_LOCAL:
14541 addend += PPC64_LOCAL_ENTRY_OFFSET (h != NULL
14542 ? h->elf.other
14543 : sym->st_other);
14544 break;
14545
14546 case R_PPC64_DTPMOD64:
14547 relocation = 1;
14548 addend = 0;
14549 goto dodyn;
14550
14551 case R_PPC64_TPREL64:
14552 if (htab->elf.tls_sec != NULL)
14553 addend -= htab->elf.tls_sec->vma + TP_OFFSET;
14554 goto dodyn;
14555
14556 case R_PPC64_DTPREL64:
14557 if (htab->elf.tls_sec != NULL)
14558 addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
14559 /* Fall thru */
14560
14561 /* Relocations that may need to be propagated if this is a
14562 dynamic object. */
14563 case R_PPC64_REL30:
14564 case R_PPC64_REL32:
14565 case R_PPC64_REL64:
14566 case R_PPC64_ADDR14:
14567 case R_PPC64_ADDR14_BRNTAKEN:
14568 case R_PPC64_ADDR14_BRTAKEN:
14569 case R_PPC64_ADDR16:
14570 case R_PPC64_ADDR16_DS:
14571 case R_PPC64_ADDR16_HA:
14572 case R_PPC64_ADDR16_HI:
14573 case R_PPC64_ADDR16_HIGH:
14574 case R_PPC64_ADDR16_HIGHA:
14575 case R_PPC64_ADDR16_HIGHER:
14576 case R_PPC64_ADDR16_HIGHERA:
14577 case R_PPC64_ADDR16_HIGHEST:
14578 case R_PPC64_ADDR16_HIGHESTA:
14579 case R_PPC64_ADDR16_LO:
14580 case R_PPC64_ADDR16_LO_DS:
14581 case R_PPC64_ADDR24:
14582 case R_PPC64_ADDR32:
14583 case R_PPC64_ADDR64:
14584 case R_PPC64_UADDR16:
14585 case R_PPC64_UADDR32:
14586 case R_PPC64_UADDR64:
14587 dodyn:
14588 if ((input_section->flags & SEC_ALLOC) == 0)
14589 break;
14590
14591 if (NO_OPD_RELOCS && is_opd)
14592 break;
14593
14594 if ((bfd_link_pic (info)
14595 && (h == NULL
14596 || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
14597 || h->elf.root.type != bfd_link_hash_undefweak)
14598 && (must_be_dyn_reloc (info, r_type)
14599 || !SYMBOL_CALLS_LOCAL (info, &h->elf)))
14600 || (ELIMINATE_COPY_RELOCS
14601 && !bfd_link_pic (info)
14602 && h != NULL
14603 && h->elf.dynindx != -1
14604 && !h->elf.non_got_ref
14605 && !h->elf.def_regular)
14606 || (!bfd_link_pic (info)
14607 && (h != NULL
14608 ? h->elf.type == STT_GNU_IFUNC
14609 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)))
14610 {
14611 bfd_boolean skip, relocate;
14612 asection *sreloc;
14613 bfd_vma out_off;
14614
14615 /* When generating a dynamic object, these relocations
14616 are copied into the output file to be resolved at run
14617 time. */
14618
14619 skip = FALSE;
14620 relocate = FALSE;
14621
14622 out_off = _bfd_elf_section_offset (output_bfd, info,
14623 input_section, rel->r_offset);
14624 if (out_off == (bfd_vma) -1)
14625 skip = TRUE;
14626 else if (out_off == (bfd_vma) -2)
14627 skip = TRUE, relocate = TRUE;
14628 out_off += (input_section->output_section->vma
14629 + input_section->output_offset);
14630 outrel.r_offset = out_off;
14631 outrel.r_addend = rel->r_addend;
14632
14633 /* Optimize unaligned reloc use. */
14634 if ((r_type == R_PPC64_ADDR64 && (out_off & 7) != 0)
14635 || (r_type == R_PPC64_UADDR64 && (out_off & 7) == 0))
14636 r_type ^= R_PPC64_ADDR64 ^ R_PPC64_UADDR64;
14637 else if ((r_type == R_PPC64_ADDR32 && (out_off & 3) != 0)
14638 || (r_type == R_PPC64_UADDR32 && (out_off & 3) == 0))
14639 r_type ^= R_PPC64_ADDR32 ^ R_PPC64_UADDR32;
14640 else if ((r_type == R_PPC64_ADDR16 && (out_off & 1) != 0)
14641 || (r_type == R_PPC64_UADDR16 && (out_off & 1) == 0))
14642 r_type ^= R_PPC64_ADDR16 ^ R_PPC64_UADDR16;
14643
14644 if (skip)
14645 memset (&outrel, 0, sizeof outrel);
14646 else if (!SYMBOL_REFERENCES_LOCAL (info, &h->elf)
14647 && !is_opd
14648 && r_type != R_PPC64_TOC)
14649 {
14650 BFD_ASSERT (h->elf.dynindx != -1);
14651 outrel.r_info = ELF64_R_INFO (h->elf.dynindx, r_type);
14652 }
14653 else
14654 {
14655 /* This symbol is local, or marked to become local,
14656 or this is an opd section reloc which must point
14657 at a local function. */
14658 outrel.r_addend += relocation;
14659 if (r_type == R_PPC64_ADDR64 || r_type == R_PPC64_TOC)
14660 {
14661 if (is_opd && h != NULL)
14662 {
14663 /* Lie about opd entries. This case occurs
14664 when building shared libraries and we
14665 reference a function in another shared
14666 lib. The same thing happens for a weak
14667 definition in an application that's
14668 overridden by a strong definition in a
14669 shared lib. (I believe this is a generic
14670 bug in binutils handling of weak syms.)
14671 In these cases we won't use the opd
14672 entry in this lib. */
14673 unresolved_reloc = FALSE;
14674 }
14675 if (!is_opd
14676 && r_type == R_PPC64_ADDR64
14677 && (h != NULL
14678 ? h->elf.type == STT_GNU_IFUNC
14679 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
14680 outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
14681 else
14682 {
14683 outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
14684
14685 /* We need to relocate .opd contents for ld.so.
14686 Prelink also wants simple and consistent rules
14687 for relocs. This make all RELATIVE relocs have
14688 *r_offset equal to r_addend. */
14689 relocate = TRUE;
14690 }
14691 }
14692 else
14693 {
14694 long indx = 0;
14695
14696 if (h != NULL
14697 ? h->elf.type == STT_GNU_IFUNC
14698 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
14699 {
14700 info->callbacks->einfo
14701 (_("%P: %H: %s for indirect "
14702 "function `%T' unsupported\n"),
14703 input_bfd, input_section, rel->r_offset,
14704 ppc64_elf_howto_table[r_type]->name,
14705 sym_name);
14706 ret = FALSE;
14707 }
14708 else if (r_symndx == STN_UNDEF || bfd_is_abs_section (sec))
14709 ;
14710 else if (sec == NULL || sec->owner == NULL)
14711 {
14712 bfd_set_error (bfd_error_bad_value);
14713 return FALSE;
14714 }
14715 else
14716 {
14717 asection *osec;
14718
14719 osec = sec->output_section;
14720 indx = elf_section_data (osec)->dynindx;
14721
14722 if (indx == 0)
14723 {
14724 if ((osec->flags & SEC_READONLY) == 0
14725 && htab->elf.data_index_section != NULL)
14726 osec = htab->elf.data_index_section;
14727 else
14728 osec = htab->elf.text_index_section;
14729 indx = elf_section_data (osec)->dynindx;
14730 }
14731 BFD_ASSERT (indx != 0);
14732
14733 /* We are turning this relocation into one
14734 against a section symbol, so subtract out
14735 the output section's address but not the
14736 offset of the input section in the output
14737 section. */
14738 outrel.r_addend -= osec->vma;
14739 }
14740
14741 outrel.r_info = ELF64_R_INFO (indx, r_type);
14742 }
14743 }
14744
14745 sreloc = elf_section_data (input_section)->sreloc;
14746 if (h != NULL
14747 ? h->elf.type == STT_GNU_IFUNC
14748 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
14749 sreloc = htab->elf.irelplt;
14750 if (sreloc == NULL)
14751 abort ();
14752
14753 if (sreloc->reloc_count * sizeof (Elf64_External_Rela)
14754 >= sreloc->size)
14755 abort ();
14756 loc = sreloc->contents;
14757 loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
14758 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
14759
14760 /* If this reloc is against an external symbol, it will
14761 be computed at runtime, so there's no need to do
14762 anything now. However, for the sake of prelink ensure
14763 that the section contents are a known value. */
14764 if (! relocate)
14765 {
14766 unresolved_reloc = FALSE;
14767 /* The value chosen here is quite arbitrary as ld.so
14768 ignores section contents except for the special
14769 case of .opd where the contents might be accessed
14770 before relocation. Choose zero, as that won't
14771 cause reloc overflow. */
14772 relocation = 0;
14773 addend = 0;
14774 /* Use *r_offset == r_addend for R_PPC64_ADDR64 relocs
14775 to improve backward compatibility with older
14776 versions of ld. */
14777 if (r_type == R_PPC64_ADDR64)
14778 addend = outrel.r_addend;
14779 /* Adjust pc_relative relocs to have zero in *r_offset. */
14780 else if (ppc64_elf_howto_table[r_type]->pc_relative)
14781 addend = (input_section->output_section->vma
14782 + input_section->output_offset
14783 + rel->r_offset);
14784 }
14785 }
14786 break;
14787
14788 case R_PPC64_COPY:
14789 case R_PPC64_GLOB_DAT:
14790 case R_PPC64_JMP_SLOT:
14791 case R_PPC64_JMP_IREL:
14792 case R_PPC64_RELATIVE:
14793 /* We shouldn't ever see these dynamic relocs in relocatable
14794 files. */
14795 /* Fall through. */
14796
14797 case R_PPC64_PLTGOT16:
14798 case R_PPC64_PLTGOT16_DS:
14799 case R_PPC64_PLTGOT16_HA:
14800 case R_PPC64_PLTGOT16_HI:
14801 case R_PPC64_PLTGOT16_LO:
14802 case R_PPC64_PLTGOT16_LO_DS:
14803 case R_PPC64_PLTREL32:
14804 case R_PPC64_PLTREL64:
14805 /* These ones haven't been implemented yet. */
14806
14807 info->callbacks->einfo
14808 (_("%P: %B: %s is not supported for `%T'\n"),
14809 input_bfd,
14810 ppc64_elf_howto_table[r_type]->name, sym_name);
14811
14812 bfd_set_error (bfd_error_invalid_operation);
14813 ret = FALSE;
14814 goto copy_reloc;
14815 }
14816
14817 /* Multi-instruction sequences that access the TOC can be
14818 optimized, eg. addis ra,r2,0; addi rb,ra,x;
14819 to nop; addi rb,r2,x; */
14820 switch (r_type)
14821 {
14822 default:
14823 break;
14824
14825 case R_PPC64_GOT_TLSLD16_HI:
14826 case R_PPC64_GOT_TLSGD16_HI:
14827 case R_PPC64_GOT_TPREL16_HI:
14828 case R_PPC64_GOT_DTPREL16_HI:
14829 case R_PPC64_GOT16_HI:
14830 case R_PPC64_TOC16_HI:
14831 /* These relocs would only be useful if building up an
14832 offset to later add to r2, perhaps in an indexed
14833 addressing mode instruction. Don't try to optimize.
14834 Unfortunately, the possibility of someone building up an
14835 offset like this or even with the HA relocs, means that
14836 we need to check the high insn when optimizing the low
14837 insn. */
14838 break;
14839
14840 case R_PPC64_GOT_TLSLD16_HA:
14841 case R_PPC64_GOT_TLSGD16_HA:
14842 case R_PPC64_GOT_TPREL16_HA:
14843 case R_PPC64_GOT_DTPREL16_HA:
14844 case R_PPC64_GOT16_HA:
14845 case R_PPC64_TOC16_HA:
14846 if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
14847 && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
14848 {
14849 bfd_byte *p = contents + (rel->r_offset & ~3);
14850 bfd_put_32 (input_bfd, NOP, p);
14851 }
14852 break;
14853
14854 case R_PPC64_GOT_TLSLD16_LO:
14855 case R_PPC64_GOT_TLSGD16_LO:
14856 case R_PPC64_GOT_TPREL16_LO_DS:
14857 case R_PPC64_GOT_DTPREL16_LO_DS:
14858 case R_PPC64_GOT16_LO:
14859 case R_PPC64_GOT16_LO_DS:
14860 case R_PPC64_TOC16_LO:
14861 case R_PPC64_TOC16_LO_DS:
14862 if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
14863 && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
14864 {
14865 bfd_byte *p = contents + (rel->r_offset & ~3);
14866 insn = bfd_get_32 (input_bfd, p);
14867 if ((insn & (0x3f << 26)) == 12u << 26 /* addic */)
14868 {
14869 /* Transform addic to addi when we change reg. */
14870 insn &= ~((0x3f << 26) | (0x1f << 16));
14871 insn |= (14u << 26) | (2 << 16);
14872 }
14873 else
14874 {
14875 insn &= ~(0x1f << 16);
14876 insn |= 2 << 16;
14877 }
14878 bfd_put_32 (input_bfd, insn, p);
14879 }
14880 break;
14881 }
14882
14883 /* Do any further special processing. */
14884 howto = ppc64_elf_howto_table[(int) r_type];
14885 switch (r_type)
14886 {
14887 default:
14888 break;
14889
14890 case R_PPC64_REL16_HA:
14891 case R_PPC64_REL16DX_HA:
14892 case R_PPC64_ADDR16_HA:
14893 case R_PPC64_ADDR16_HIGHA:
14894 case R_PPC64_ADDR16_HIGHERA:
14895 case R_PPC64_ADDR16_HIGHESTA:
14896 case R_PPC64_TOC16_HA:
14897 case R_PPC64_SECTOFF_HA:
14898 case R_PPC64_TPREL16_HA:
14899 case R_PPC64_TPREL16_HIGHA:
14900 case R_PPC64_TPREL16_HIGHERA:
14901 case R_PPC64_TPREL16_HIGHESTA:
14902 case R_PPC64_DTPREL16_HA:
14903 case R_PPC64_DTPREL16_HIGHA:
14904 case R_PPC64_DTPREL16_HIGHERA:
14905 case R_PPC64_DTPREL16_HIGHESTA:
14906 /* It's just possible that this symbol is a weak symbol
14907 that's not actually defined anywhere. In that case,
14908 'sec' would be NULL, and we should leave the symbol
14909 alone (it will be set to zero elsewhere in the link). */
14910 if (sec == NULL)
14911 break;
14912 /* Fall thru */
14913
14914 case R_PPC64_GOT16_HA:
14915 case R_PPC64_PLTGOT16_HA:
14916 case R_PPC64_PLT16_HA:
14917 case R_PPC64_GOT_TLSGD16_HA:
14918 case R_PPC64_GOT_TLSLD16_HA:
14919 case R_PPC64_GOT_TPREL16_HA:
14920 case R_PPC64_GOT_DTPREL16_HA:
14921 /* Add 0x10000 if sign bit in 0:15 is set.
14922 Bits 0:15 are not used. */
14923 addend += 0x8000;
14924 break;
14925
14926 case R_PPC64_ADDR16_DS:
14927 case R_PPC64_ADDR16_LO_DS:
14928 case R_PPC64_GOT16_DS:
14929 case R_PPC64_GOT16_LO_DS:
14930 case R_PPC64_PLT16_LO_DS:
14931 case R_PPC64_SECTOFF_DS:
14932 case R_PPC64_SECTOFF_LO_DS:
14933 case R_PPC64_TOC16_DS:
14934 case R_PPC64_TOC16_LO_DS:
14935 case R_PPC64_PLTGOT16_DS:
14936 case R_PPC64_PLTGOT16_LO_DS:
14937 case R_PPC64_GOT_TPREL16_DS:
14938 case R_PPC64_GOT_TPREL16_LO_DS:
14939 case R_PPC64_GOT_DTPREL16_DS:
14940 case R_PPC64_GOT_DTPREL16_LO_DS:
14941 case R_PPC64_TPREL16_DS:
14942 case R_PPC64_TPREL16_LO_DS:
14943 case R_PPC64_DTPREL16_DS:
14944 case R_PPC64_DTPREL16_LO_DS:
14945 insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
14946 mask = 3;
14947 /* If this reloc is against an lq, lxv, or stxv insn, then
14948 the value must be a multiple of 16. This is somewhat of
14949 a hack, but the "correct" way to do this by defining _DQ
14950 forms of all the _DS relocs bloats all reloc switches in
14951 this file. It doesn't make much sense to use these
14952 relocs in data, so testing the insn should be safe. */
14953 if ((insn & (0x3f << 26)) == (56u << 26)
14954 || ((insn & (0x3f << 26)) == (61u << 26) && (insn & 3) == 1))
14955 mask = 15;
14956 relocation += addend;
14957 addend = insn & (mask ^ 3);
14958 if ((relocation & mask) != 0)
14959 {
14960 relocation ^= relocation & mask;
14961 info->callbacks->einfo
14962 (_("%P: %H: error: %s not a multiple of %u\n"),
14963 input_bfd, input_section, rel->r_offset,
14964 howto->name,
14965 mask + 1);
14966 bfd_set_error (bfd_error_bad_value);
14967 ret = FALSE;
14968 goto copy_reloc;
14969 }
14970 break;
14971 }
14972
14973 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
14974 because such sections are not SEC_ALLOC and thus ld.so will
14975 not process them. */
14976 if (unresolved_reloc
14977 && !((input_section->flags & SEC_DEBUGGING) != 0
14978 && h->elf.def_dynamic)
14979 && _bfd_elf_section_offset (output_bfd, info, input_section,
14980 rel->r_offset) != (bfd_vma) -1)
14981 {
14982 info->callbacks->einfo
14983 (_("%P: %H: unresolvable %s against `%T'\n"),
14984 input_bfd, input_section, rel->r_offset,
14985 howto->name,
14986 h->elf.root.root.string);
14987 ret = FALSE;
14988 }
14989
14990 /* 16-bit fields in insns mostly have signed values, but a
14991 few insns have 16-bit unsigned values. Really, we should
14992 have different reloc types. */
14993 if (howto->complain_on_overflow != complain_overflow_dont
14994 && howto->dst_mask == 0xffff
14995 && (input_section->flags & SEC_CODE) != 0)
14996 {
14997 enum complain_overflow complain = complain_overflow_signed;
14998
14999 insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
15000 if ((insn & (0x3f << 26)) == 10u << 26 /* cmpli */)
15001 complain = complain_overflow_bitfield;
15002 else if (howto->rightshift == 0
15003 ? ((insn & (0x3f << 26)) == 28u << 26 /* andi */
15004 || (insn & (0x3f << 26)) == 24u << 26 /* ori */
15005 || (insn & (0x3f << 26)) == 26u << 26 /* xori */)
15006 : ((insn & (0x3f << 26)) == 29u << 26 /* andis */
15007 || (insn & (0x3f << 26)) == 25u << 26 /* oris */
15008 || (insn & (0x3f << 26)) == 27u << 26 /* xoris */))
15009 complain = complain_overflow_unsigned;
15010 if (howto->complain_on_overflow != complain)
15011 {
15012 alt_howto = *howto;
15013 alt_howto.complain_on_overflow = complain;
15014 howto = &alt_howto;
15015 }
15016 }
15017
15018 if (r_type == R_PPC64_REL16DX_HA)
15019 {
15020 /* Split field reloc isn't handled by _bfd_final_link_relocate. */
15021 if (rel->r_offset + 4 > input_section->size)
15022 r = bfd_reloc_outofrange;
15023 else
15024 {
15025 relocation += addend;
15026 relocation -= (rel->r_offset
15027 + input_section->output_offset
15028 + input_section->output_section->vma);
15029 relocation = (bfd_signed_vma) relocation >> 16;
15030 insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
15031 insn &= ~0x1fffc1;
15032 insn |= (relocation & 0xffc1) | ((relocation & 0x3e) << 15);
15033 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
15034 r = bfd_reloc_ok;
15035 if (relocation + 0x8000 > 0xffff)
15036 r = bfd_reloc_overflow;
15037 }
15038 }
15039 else
15040 r = _bfd_final_link_relocate (howto, input_bfd, input_section, contents,
15041 rel->r_offset, relocation, addend);
15042
15043 if (r != bfd_reloc_ok)
15044 {
15045 char *more_info = NULL;
15046 const char *reloc_name = howto->name;
15047
15048 if (reloc_dest != DEST_NORMAL)
15049 {
15050 more_info = bfd_malloc (strlen (reloc_name) + 8);
15051 if (more_info != NULL)
15052 {
15053 strcpy (more_info, reloc_name);
15054 strcat (more_info, (reloc_dest == DEST_OPD
15055 ? " (OPD)" : " (stub)"));
15056 reloc_name = more_info;
15057 }
15058 }
15059
15060 if (r == bfd_reloc_overflow)
15061 {
15062 /* On code like "if (foo) foo();" don't report overflow
15063 on a branch to zero when foo is undefined. */
15064 if (!warned
15065 && (reloc_dest == DEST_STUB
15066 || !(h != NULL
15067 && (h->elf.root.type == bfd_link_hash_undefweak
15068 || h->elf.root.type == bfd_link_hash_undefined)
15069 && is_branch_reloc (r_type))))
15070 {
15071 if (!((*info->callbacks->reloc_overflow)
15072 (info, &h->elf.root, sym_name,
15073 reloc_name, orig_rel.r_addend,
15074 input_bfd, input_section, rel->r_offset)))
15075 return FALSE;
15076 }
15077 }
15078 else
15079 {
15080 info->callbacks->einfo
15081 (_("%P: %H: %s against `%T': error %d\n"),
15082 input_bfd, input_section, rel->r_offset,
15083 reloc_name, sym_name, (int) r);
15084 ret = FALSE;
15085 }
15086 if (more_info != NULL)
15087 free (more_info);
15088 }
15089 copy_reloc:
15090 if (wrel != rel)
15091 *wrel = *rel;
15092 }
15093
15094 if (wrel != rel)
15095 {
15096 Elf_Internal_Shdr *rel_hdr;
15097 size_t deleted = rel - wrel;
15098
15099 rel_hdr = _bfd_elf_single_rel_hdr (input_section->output_section);
15100 rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
15101 if (rel_hdr->sh_size == 0)
15102 {
15103 /* It is too late to remove an empty reloc section. Leave
15104 one NONE reloc.
15105 ??? What is wrong with an empty section??? */
15106 rel_hdr->sh_size = rel_hdr->sh_entsize;
15107 deleted -= 1;
15108 }
15109 rel_hdr = _bfd_elf_single_rel_hdr (input_section);
15110 rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
15111 input_section->reloc_count -= deleted;
15112 }
15113
15114 /* If we're emitting relocations, then shortly after this function
15115 returns, reloc offsets and addends for this section will be
15116 adjusted. Worse, reloc symbol indices will be for the output
15117 file rather than the input. Save a copy of the relocs for
15118 opd_entry_value. */
15119 if (is_opd && (info->emitrelocations || bfd_link_relocatable (info)))
15120 {
15121 bfd_size_type amt;
15122 amt = input_section->reloc_count * sizeof (Elf_Internal_Rela);
15123 rel = bfd_alloc (input_bfd, amt);
15124 BFD_ASSERT (ppc64_elf_tdata (input_bfd)->opd.relocs == NULL);
15125 ppc64_elf_tdata (input_bfd)->opd.relocs = rel;
15126 if (rel == NULL)
15127 return FALSE;
15128 memcpy (rel, relocs, amt);
15129 }
15130 return ret;
15131 }
15132
15133 /* Adjust the value of any local symbols in opd sections. */
15134
15135 static int
15136 ppc64_elf_output_symbol_hook (struct bfd_link_info *info,
15137 const char *name ATTRIBUTE_UNUSED,
15138 Elf_Internal_Sym *elfsym,
15139 asection *input_sec,
15140 struct elf_link_hash_entry *h)
15141 {
15142 struct _opd_sec_data *opd;
15143 long adjust;
15144 bfd_vma value;
15145
15146 if (h != NULL)
15147 return 1;
15148
15149 opd = get_opd_info (input_sec);
15150 if (opd == NULL || opd->adjust == NULL)
15151 return 1;
15152
15153 value = elfsym->st_value - input_sec->output_offset;
15154 if (!bfd_link_relocatable (info))
15155 value -= input_sec->output_section->vma;
15156
15157 adjust = opd->adjust[OPD_NDX (value)];
15158 if (adjust == -1)
15159 return 2;
15160
15161 elfsym->st_value += adjust;
15162 return 1;
15163 }
15164
15165 /* Finish up dynamic symbol handling. We set the contents of various
15166 dynamic sections here. */
15167
15168 static bfd_boolean
15169 ppc64_elf_finish_dynamic_symbol (bfd *output_bfd,
15170 struct bfd_link_info *info,
15171 struct elf_link_hash_entry *h,
15172 Elf_Internal_Sym *sym ATTRIBUTE_UNUSED)
15173 {
15174 struct ppc_link_hash_table *htab;
15175 struct plt_entry *ent;
15176 Elf_Internal_Rela rela;
15177 bfd_byte *loc;
15178
15179 htab = ppc_hash_table (info);
15180 if (htab == NULL)
15181 return FALSE;
15182
15183 for (ent = h->plt.plist; ent != NULL; ent = ent->next)
15184 if (ent->plt.offset != (bfd_vma) -1)
15185 {
15186 /* This symbol has an entry in the procedure linkage
15187 table. Set it up. */
15188 if (!htab->elf.dynamic_sections_created
15189 || h->dynindx == -1)
15190 {
15191 BFD_ASSERT (h->type == STT_GNU_IFUNC
15192 && h->def_regular
15193 && (h->root.type == bfd_link_hash_defined
15194 || h->root.type == bfd_link_hash_defweak));
15195 rela.r_offset = (htab->elf.iplt->output_section->vma
15196 + htab->elf.iplt->output_offset
15197 + ent->plt.offset);
15198 if (htab->opd_abi)
15199 rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
15200 else
15201 rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
15202 rela.r_addend = (h->root.u.def.value
15203 + h->root.u.def.section->output_offset
15204 + h->root.u.def.section->output_section->vma
15205 + ent->addend);
15206 loc = (htab->elf.irelplt->contents
15207 + (htab->elf.irelplt->reloc_count++
15208 * sizeof (Elf64_External_Rela)));
15209 }
15210 else
15211 {
15212 rela.r_offset = (htab->elf.splt->output_section->vma
15213 + htab->elf.splt->output_offset
15214 + ent->plt.offset);
15215 rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_JMP_SLOT);
15216 rela.r_addend = ent->addend;
15217 loc = (htab->elf.srelplt->contents
15218 + ((ent->plt.offset - PLT_INITIAL_ENTRY_SIZE (htab))
15219 / PLT_ENTRY_SIZE (htab) * sizeof (Elf64_External_Rela)));
15220 }
15221 bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
15222
15223 if (!htab->opd_abi)
15224 {
15225 if (!h->def_regular)
15226 {
15227 /* Mark the symbol as undefined, rather than as
15228 defined in glink. Leave the value if there were
15229 any relocations where pointer equality matters
15230 (this is a clue for the dynamic linker, to make
15231 function pointer comparisons work between an
15232 application and shared library), otherwise set it
15233 to zero. */
15234 sym->st_shndx = SHN_UNDEF;
15235 if (!h->pointer_equality_needed)
15236 sym->st_value = 0;
15237 else if (!h->ref_regular_nonweak)
15238 {
15239 /* This breaks function pointer comparisons, but
15240 that is better than breaking tests for a NULL
15241 function pointer. */
15242 sym->st_value = 0;
15243 }
15244 }
15245 }
15246 }
15247
15248 if (h->needs_copy)
15249 {
15250 /* This symbol needs a copy reloc. Set it up. */
15251
15252 if (h->dynindx == -1
15253 || (h->root.type != bfd_link_hash_defined
15254 && h->root.type != bfd_link_hash_defweak)
15255 || htab->relbss == NULL)
15256 abort ();
15257
15258 rela.r_offset = (h->root.u.def.value
15259 + h->root.u.def.section->output_section->vma
15260 + h->root.u.def.section->output_offset);
15261 rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_COPY);
15262 rela.r_addend = 0;
15263 loc = htab->relbss->contents;
15264 loc += htab->relbss->reloc_count++ * sizeof (Elf64_External_Rela);
15265 bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
15266 }
15267
15268 return TRUE;
15269 }
15270
15271 /* Used to decide how to sort relocs in an optimal manner for the
15272 dynamic linker, before writing them out. */
15273
15274 static enum elf_reloc_type_class
15275 ppc64_elf_reloc_type_class (const struct bfd_link_info *info,
15276 const asection *rel_sec,
15277 const Elf_Internal_Rela *rela)
15278 {
15279 enum elf_ppc64_reloc_type r_type;
15280 struct ppc_link_hash_table *htab = ppc_hash_table (info);
15281
15282 if (rel_sec == htab->elf.irelplt)
15283 return reloc_class_ifunc;
15284
15285 r_type = ELF64_R_TYPE (rela->r_info);
15286 switch (r_type)
15287 {
15288 case R_PPC64_RELATIVE:
15289 return reloc_class_relative;
15290 case R_PPC64_JMP_SLOT:
15291 return reloc_class_plt;
15292 case R_PPC64_COPY:
15293 return reloc_class_copy;
15294 default:
15295 return reloc_class_normal;
15296 }
15297 }
15298
15299 /* Finish up the dynamic sections. */
15300
15301 static bfd_boolean
15302 ppc64_elf_finish_dynamic_sections (bfd *output_bfd,
15303 struct bfd_link_info *info)
15304 {
15305 struct ppc_link_hash_table *htab;
15306 bfd *dynobj;
15307 asection *sdyn;
15308
15309 htab = ppc_hash_table (info);
15310 if (htab == NULL)
15311 return FALSE;
15312
15313 dynobj = htab->elf.dynobj;
15314 sdyn = bfd_get_linker_section (dynobj, ".dynamic");
15315
15316 if (htab->elf.dynamic_sections_created)
15317 {
15318 Elf64_External_Dyn *dyncon, *dynconend;
15319
15320 if (sdyn == NULL || htab->elf.sgot == NULL)
15321 abort ();
15322
15323 dyncon = (Elf64_External_Dyn *) sdyn->contents;
15324 dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
15325 for (; dyncon < dynconend; dyncon++)
15326 {
15327 Elf_Internal_Dyn dyn;
15328 asection *s;
15329
15330 bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
15331
15332 switch (dyn.d_tag)
15333 {
15334 default:
15335 continue;
15336
15337 case DT_PPC64_GLINK:
15338 s = htab->glink;
15339 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
15340 /* We stupidly defined DT_PPC64_GLINK to be the start
15341 of glink rather than the first entry point, which is
15342 what ld.so needs, and now have a bigger stub to
15343 support automatic multiple TOCs. */
15344 dyn.d_un.d_ptr += GLINK_CALL_STUB_SIZE - 8 * 4;
15345 break;
15346
15347 case DT_PPC64_OPD:
15348 s = bfd_get_section_by_name (output_bfd, ".opd");
15349 if (s == NULL)
15350 continue;
15351 dyn.d_un.d_ptr = s->vma;
15352 break;
15353
15354 case DT_PPC64_OPT:
15355 if (htab->do_multi_toc && htab->multi_toc_needed)
15356 dyn.d_un.d_val |= PPC64_OPT_MULTI_TOC;
15357 break;
15358
15359 case DT_PPC64_OPDSZ:
15360 s = bfd_get_section_by_name (output_bfd, ".opd");
15361 if (s == NULL)
15362 continue;
15363 dyn.d_un.d_val = s->size;
15364 break;
15365
15366 case DT_PLTGOT:
15367 s = htab->elf.splt;
15368 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
15369 break;
15370
15371 case DT_JMPREL:
15372 s = htab->elf.srelplt;
15373 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
15374 break;
15375
15376 case DT_PLTRELSZ:
15377 dyn.d_un.d_val = htab->elf.srelplt->size;
15378 break;
15379
15380 case DT_RELASZ:
15381 /* Don't count procedure linkage table relocs in the
15382 overall reloc count. */
15383 s = htab->elf.srelplt;
15384 if (s == NULL)
15385 continue;
15386 dyn.d_un.d_val -= s->size;
15387 break;
15388
15389 case DT_RELA:
15390 /* We may not be using the standard ELF linker script.
15391 If .rela.plt is the first .rela section, we adjust
15392 DT_RELA to not include it. */
15393 s = htab->elf.srelplt;
15394 if (s == NULL)
15395 continue;
15396 if (dyn.d_un.d_ptr != s->output_section->vma + s->output_offset)
15397 continue;
15398 dyn.d_un.d_ptr += s->size;
15399 break;
15400 }
15401
15402 bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
15403 }
15404 }
15405
15406 if (htab->elf.sgot != NULL && htab->elf.sgot->size != 0)
15407 {
15408 /* Fill in the first entry in the global offset table.
15409 We use it to hold the link-time TOCbase. */
15410 bfd_put_64 (output_bfd,
15411 elf_gp (output_bfd) + TOC_BASE_OFF,
15412 htab->elf.sgot->contents);
15413
15414 /* Set .got entry size. */
15415 elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize = 8;
15416 }
15417
15418 if (htab->elf.splt != NULL && htab->elf.splt->size != 0)
15419 {
15420 /* Set .plt entry size. */
15421 elf_section_data (htab->elf.splt->output_section)->this_hdr.sh_entsize
15422 = PLT_ENTRY_SIZE (htab);
15423 }
15424
15425 /* brlt is SEC_LINKER_CREATED, so we need to write out relocs for
15426 brlt ourselves if emitrelocations. */
15427 if (htab->brlt != NULL
15428 && htab->brlt->reloc_count != 0
15429 && !_bfd_elf_link_output_relocs (output_bfd,
15430 htab->brlt,
15431 elf_section_data (htab->brlt)->rela.hdr,
15432 elf_section_data (htab->brlt)->relocs,
15433 NULL))
15434 return FALSE;
15435
15436 if (htab->glink != NULL
15437 && htab->glink->reloc_count != 0
15438 && !_bfd_elf_link_output_relocs (output_bfd,
15439 htab->glink,
15440 elf_section_data (htab->glink)->rela.hdr,
15441 elf_section_data (htab->glink)->relocs,
15442 NULL))
15443 return FALSE;
15444
15445 if (htab->glink_eh_frame != NULL
15446 && htab->glink_eh_frame->size != 0)
15447 {
15448 bfd_vma val;
15449 bfd_byte *p;
15450 asection *stub_sec;
15451
15452 p = htab->glink_eh_frame->contents + sizeof (glink_eh_frame_cie);
15453 for (stub_sec = htab->params->stub_bfd->sections;
15454 stub_sec != NULL;
15455 stub_sec = stub_sec->next)
15456 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
15457 {
15458 /* FDE length. */
15459 p += 4;
15460 /* CIE pointer. */
15461 p += 4;
15462 /* Offset to stub section. */
15463 val = (stub_sec->output_section->vma
15464 + stub_sec->output_offset);
15465 val -= (htab->glink_eh_frame->output_section->vma
15466 + htab->glink_eh_frame->output_offset
15467 + (p - htab->glink_eh_frame->contents));
15468 if (val + 0x80000000 > 0xffffffff)
15469 {
15470 info->callbacks->einfo
15471 (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
15472 stub_sec->name);
15473 return FALSE;
15474 }
15475 bfd_put_32 (dynobj, val, p);
15476 p += 4;
15477 /* stub section size. */
15478 p += 4;
15479 /* Augmentation. */
15480 p += 1;
15481 /* Pad. */
15482 p += 7;
15483 }
15484 if (htab->glink != NULL && htab->glink->size != 0)
15485 {
15486 /* FDE length. */
15487 p += 4;
15488 /* CIE pointer. */
15489 p += 4;
15490 /* Offset to .glink. */
15491 val = (htab->glink->output_section->vma
15492 + htab->glink->output_offset
15493 + 8);
15494 val -= (htab->glink_eh_frame->output_section->vma
15495 + htab->glink_eh_frame->output_offset
15496 + (p - htab->glink_eh_frame->contents));
15497 if (val + 0x80000000 > 0xffffffff)
15498 {
15499 info->callbacks->einfo
15500 (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
15501 htab->glink->name);
15502 return FALSE;
15503 }
15504 bfd_put_32 (dynobj, val, p);
15505 p += 4;
15506 /* .glink size. */
15507 p += 4;
15508 /* Augmentation. */
15509 p += 1;
15510 /* Ops. */
15511 p += 7;
15512 }
15513
15514 if (htab->glink_eh_frame->sec_info_type == SEC_INFO_TYPE_EH_FRAME
15515 && !_bfd_elf_write_section_eh_frame (output_bfd, info,
15516 htab->glink_eh_frame,
15517 htab->glink_eh_frame->contents))
15518 return FALSE;
15519 }
15520
15521 /* We need to handle writing out multiple GOT sections ourselves,
15522 since we didn't add them to DYNOBJ. We know dynobj is the first
15523 bfd. */
15524 while ((dynobj = dynobj->link.next) != NULL)
15525 {
15526 asection *s;
15527
15528 if (!is_ppc64_elf (dynobj))
15529 continue;
15530
15531 s = ppc64_elf_tdata (dynobj)->got;
15532 if (s != NULL
15533 && s->size != 0
15534 && s->output_section != bfd_abs_section_ptr
15535 && !bfd_set_section_contents (output_bfd, s->output_section,
15536 s->contents, s->output_offset,
15537 s->size))
15538 return FALSE;
15539 s = ppc64_elf_tdata (dynobj)->relgot;
15540 if (s != NULL
15541 && s->size != 0
15542 && s->output_section != bfd_abs_section_ptr
15543 && !bfd_set_section_contents (output_bfd, s->output_section,
15544 s->contents, s->output_offset,
15545 s->size))
15546 return FALSE;
15547 }
15548
15549 return TRUE;
15550 }
15551
15552 #include "elf64-target.h"
15553
15554 /* FreeBSD support */
15555
15556 #undef TARGET_LITTLE_SYM
15557 #undef TARGET_LITTLE_NAME
15558
15559 #undef TARGET_BIG_SYM
15560 #define TARGET_BIG_SYM powerpc_elf64_fbsd_vec
15561 #undef TARGET_BIG_NAME
15562 #define TARGET_BIG_NAME "elf64-powerpc-freebsd"
15563
15564 #undef ELF_OSABI
15565 #define ELF_OSABI ELFOSABI_FREEBSD
15566
15567 #undef elf64_bed
15568 #define elf64_bed elf64_powerpc_fbsd_bed
15569
15570 #include "elf64-target.h"
15571
GDB Binutils - Deliverables
This page took 0.349132 seconds and 4 git commands to generate.