projects / deliverable / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Add .abiversion related support for ELFv2
[deliverable/binutils-gdb.git] / bfd / elf64-ppc.c
1 /* PowerPC64-specific support for 64-bit ELF.
2 Copyright 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008,
3 2009, 2010, 2011, 2012 Free Software Foundation, Inc.
4 Written by Linus Nordberg, Swox AB <info@swox.com>,
5 based on elf32-ppc.c by Ian Lance Taylor.
6 Largely rewritten by Alan Modra.
7
8 This file is part of BFD, the Binary File Descriptor library.
9
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3 of the License, or
13 (at your option) any later version.
14
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
19
20 You should have received a copy of the GNU General Public License along
21 with this program; if not, write to the Free Software Foundation, Inc.,
22 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */
23
24
25 /* The 64-bit PowerPC ELF ABI may be found at
26 http://www.linuxbase.org/spec/ELF/ppc64/PPC-elf64abi.txt, and
27 http://www.linuxbase.org/spec/ELF/ppc64/spec/book1.html */
28
29 #include "sysdep.h"
30 #include <stdarg.h>
31 #include "bfd.h"
32 #include "bfdlink.h"
33 #include "libbfd.h"
34 #include "elf-bfd.h"
35 #include "elf/ppc64.h"
36 #include "elf64-ppc.h"
37 #include "dwarf2.h"
38
39 static bfd_reloc_status_type ppc64_elf_ha_reloc
40 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
41 static bfd_reloc_status_type ppc64_elf_branch_reloc
42 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
43 static bfd_reloc_status_type ppc64_elf_brtaken_reloc
44 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
45 static bfd_reloc_status_type ppc64_elf_sectoff_reloc
46 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
47 static bfd_reloc_status_type ppc64_elf_sectoff_ha_reloc
48 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
49 static bfd_reloc_status_type ppc64_elf_toc_reloc
50 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
51 static bfd_reloc_status_type ppc64_elf_toc_ha_reloc
52 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
53 static bfd_reloc_status_type ppc64_elf_toc64_reloc
54 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
55 static bfd_reloc_status_type ppc64_elf_unhandled_reloc
56 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
57 static bfd_vma opd_entry_value
58 (asection *, bfd_vma, asection **, bfd_vma *, bfd_boolean);
59
60 #define TARGET_LITTLE_SYM bfd_elf64_powerpcle_vec
61 #define TARGET_LITTLE_NAME "elf64-powerpcle"
62 #define TARGET_BIG_SYM bfd_elf64_powerpc_vec
63 #define TARGET_BIG_NAME "elf64-powerpc"
64 #define ELF_ARCH bfd_arch_powerpc
65 #define ELF_TARGET_ID PPC64_ELF_DATA
66 #define ELF_MACHINE_CODE EM_PPC64
67 #define ELF_MAXPAGESIZE 0x10000
68 #define ELF_COMMONPAGESIZE 0x1000
69 #define elf_info_to_howto ppc64_elf_info_to_howto
70
71 #define elf_backend_want_got_sym 0
72 #define elf_backend_want_plt_sym 0
73 #define elf_backend_plt_alignment 3
74 #define elf_backend_plt_not_loaded 1
75 #define elf_backend_got_header_size 8
76 #define elf_backend_can_gc_sections 1
77 #define elf_backend_can_refcount 1
78 #define elf_backend_rela_normal 1
79 #define elf_backend_default_execstack 0
80
81 #define bfd_elf64_mkobject ppc64_elf_mkobject
82 #define bfd_elf64_bfd_reloc_type_lookup ppc64_elf_reloc_type_lookup
83 #define bfd_elf64_bfd_reloc_name_lookup ppc64_elf_reloc_name_lookup
84 #define bfd_elf64_bfd_merge_private_bfd_data ppc64_elf_merge_private_bfd_data
85 #define bfd_elf64_bfd_print_private_bfd_data ppc64_elf_print_private_bfd_data
86 #define bfd_elf64_new_section_hook ppc64_elf_new_section_hook
87 #define bfd_elf64_bfd_link_hash_table_create ppc64_elf_link_hash_table_create
88 #define bfd_elf64_bfd_link_hash_table_free ppc64_elf_link_hash_table_free
89 #define bfd_elf64_get_synthetic_symtab ppc64_elf_get_synthetic_symtab
90 #define bfd_elf64_bfd_link_just_syms ppc64_elf_link_just_syms
91
92 #define elf_backend_object_p ppc64_elf_object_p
93 #define elf_backend_grok_prstatus ppc64_elf_grok_prstatus
94 #define elf_backend_grok_psinfo ppc64_elf_grok_psinfo
95 #define elf_backend_write_core_note ppc64_elf_write_core_note
96 #define elf_backend_create_dynamic_sections ppc64_elf_create_dynamic_sections
97 #define elf_backend_copy_indirect_symbol ppc64_elf_copy_indirect_symbol
98 #define elf_backend_add_symbol_hook ppc64_elf_add_symbol_hook
99 #define elf_backend_check_directives ppc64_elf_process_dot_syms
100 #define elf_backend_notice_as_needed ppc64_elf_notice_as_needed
101 #define elf_backend_archive_symbol_lookup ppc64_elf_archive_symbol_lookup
102 #define elf_backend_check_relocs ppc64_elf_check_relocs
103 #define elf_backend_gc_keep ppc64_elf_gc_keep
104 #define elf_backend_gc_mark_dynamic_ref ppc64_elf_gc_mark_dynamic_ref
105 #define elf_backend_gc_mark_hook ppc64_elf_gc_mark_hook
106 #define elf_backend_gc_sweep_hook ppc64_elf_gc_sweep_hook
107 #define elf_backend_adjust_dynamic_symbol ppc64_elf_adjust_dynamic_symbol
108 #define elf_backend_hide_symbol ppc64_elf_hide_symbol
109 #define elf_backend_maybe_function_sym ppc64_elf_maybe_function_sym
110 #define elf_backend_always_size_sections ppc64_elf_func_desc_adjust
111 #define elf_backend_size_dynamic_sections ppc64_elf_size_dynamic_sections
112 #define elf_backend_init_index_section _bfd_elf_init_2_index_sections
113 #define elf_backend_action_discarded ppc64_elf_action_discarded
114 #define elf_backend_relocate_section ppc64_elf_relocate_section
115 #define elf_backend_finish_dynamic_symbol ppc64_elf_finish_dynamic_symbol
116 #define elf_backend_reloc_type_class ppc64_elf_reloc_type_class
117 #define elf_backend_finish_dynamic_sections ppc64_elf_finish_dynamic_sections
118 #define elf_backend_link_output_symbol_hook ppc64_elf_output_symbol_hook
119 #define elf_backend_special_sections ppc64_elf_special_sections
120 #define elf_backend_post_process_headers _bfd_elf_set_osabi
121
122 /* The name of the dynamic interpreter. This is put in the .interp
123 section. */
124 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
125
126 /* The size in bytes of an entry in the procedure linkage table. */
127 #define PLT_ENTRY_SIZE 24
128
129 /* The initial size of the plt reserved for the dynamic linker. */
130 #define PLT_INITIAL_ENTRY_SIZE PLT_ENTRY_SIZE
131
132 /* TOC base pointers offset from start of TOC. */
133 #define TOC_BASE_OFF 0x8000
134
135 /* Offset of tp and dtp pointers from start of TLS block. */
136 #define TP_OFFSET 0x7000
137 #define DTP_OFFSET 0x8000
138
139 /* .plt call stub instructions. The normal stub is like this, but
140 sometimes the .plt entry crosses a 64k boundary and we need to
141 insert an addi to adjust r11. */
142 #define PLT_CALL_STUB_SIZE (7*4)
143 #define STD_R2_40R1 0xf8410028 /* std %r2,40(%r1) */
144 #define ADDIS_R11_R2 0x3d620000 /* addis %r11,%r2,xxx@ha */
145 #define LD_R12_0R11 0xe98b0000 /* ld %r12,xxx+0@l(%r11) */
146 #define MTCTR_R12 0x7d8903a6 /* mtctr %r12 */
147 #define LD_R2_0R11 0xe84b0000 /* ld %r2,xxx+8@l(%r11) */
148 #define LD_R11_0R11 0xe96b0000 /* ld %r11,xxx+16@l(%r11) */
149 #define BCTR 0x4e800420 /* bctr */
150
151 #define ADDI_R11_R11 0x396b0000 /* addi %r11,%r11,off@l */
152 #define ADDIS_R2_R2 0x3c420000 /* addis %r2,%r2,off@ha */
153 #define ADDI_R2_R2 0x38420000 /* addi %r2,%r2,off@l */
154
155 #define XOR_R2_R12_R12 0x7d826278 /* xor %r2,%r12,%r12 */
156 #define ADD_R11_R11_R2 0x7d6b1214 /* add %r11,%r11,%r2 */
157 #define XOR_R11_R12_R12 0x7d8b6278 /* xor %r11,%r12,%r12 */
158 #define ADD_R2_R2_R11 0x7c425a14 /* add %r2,%r2,%r11 */
159 #define CMPLDI_R2_0 0x28220000 /* cmpldi %r2,0 */
160 #define BNECTR 0x4ca20420 /* bnectr+ */
161 #define BNECTR_P4 0x4ce20420 /* bnectr+ */
162
163 #define LD_R12_0R2 0xe9820000 /* ld %r12,xxx+0(%r2) */
164 #define LD_R11_0R2 0xe9620000 /* ld %r11,xxx+0(%r2) */
165 #define LD_R2_0R2 0xe8420000 /* ld %r2,xxx+0(%r2) */
166
167 #define LD_R2_40R1 0xe8410028 /* ld %r2,40(%r1) */
168
169 /* glink call stub instructions. We enter with the index in R0. */
170 #define GLINK_CALL_STUB_SIZE (16*4)
171 /* 0: */
172 /* .quad plt0-1f */
173 /* __glink: */
174 #define MFLR_R12 0x7d8802a6 /* mflr %12 */
175 #define BCL_20_31 0x429f0005 /* bcl 20,31,1f */
176 /* 1: */
177 #define MFLR_R11 0x7d6802a6 /* mflr %11 */
178 /* ld %2,(0b-1b)(%11) */
179 #define MTLR_R12 0x7d8803a6 /* mtlr %12 */
180 #define ADD_R11_R2_R11 0x7d625a14 /* add %11,%2,%11 */
181 /* ld %12,0(%11) */
182 /* ld %2,8(%11) */
183 /* mtctr %12 */
184 /* ld %11,16(%11) */
185 /* bctr */
186
187 /* Pad with this. */
188 #define NOP 0x60000000
189
190 /* Some other nops. */
191 #define CROR_151515 0x4def7b82
192 #define CROR_313131 0x4ffffb82
193
194 /* .glink entries for the first 32k functions are two instructions. */
195 #define LI_R0_0 0x38000000 /* li %r0,0 */
196 #define B_DOT 0x48000000 /* b . */
197
198 /* After that, we need two instructions to load the index, followed by
199 a branch. */
200 #define LIS_R0_0 0x3c000000 /* lis %r0,0 */
201 #define ORI_R0_R0_0 0x60000000 /* ori %r0,%r0,0 */
202
203 /* Instructions used by the save and restore reg functions. */
204 #define STD_R0_0R1 0xf8010000 /* std %r0,0(%r1) */
205 #define STD_R0_0R12 0xf80c0000 /* std %r0,0(%r12) */
206 #define LD_R0_0R1 0xe8010000 /* ld %r0,0(%r1) */
207 #define LD_R0_0R12 0xe80c0000 /* ld %r0,0(%r12) */
208 #define STFD_FR0_0R1 0xd8010000 /* stfd %fr0,0(%r1) */
209 #define LFD_FR0_0R1 0xc8010000 /* lfd %fr0,0(%r1) */
210 #define LI_R12_0 0x39800000 /* li %r12,0 */
211 #define STVX_VR0_R12_R0 0x7c0c01ce /* stvx %v0,%r12,%r0 */
212 #define LVX_VR0_R12_R0 0x7c0c00ce /* lvx %v0,%r12,%r0 */
213 #define MTLR_R0 0x7c0803a6 /* mtlr %r0 */
214 #define BLR 0x4e800020 /* blr */
215
216 /* Since .opd is an array of descriptors and each entry will end up
217 with identical R_PPC64_RELATIVE relocs, there is really no need to
218 propagate .opd relocs; The dynamic linker should be taught to
219 relocate .opd without reloc entries. */
220 #ifndef NO_OPD_RELOCS
221 #define NO_OPD_RELOCS 0
222 #endif
223 \f
224 #define ONES(n) (((bfd_vma) 1 << ((n) - 1) << 1) - 1)
225
226 /* Relocation HOWTO's. */
227 static reloc_howto_type *ppc64_elf_howto_table[(int) R_PPC64_max];
228
229 static reloc_howto_type ppc64_elf_howto_raw[] = {
230 /* This reloc does nothing. */
231 HOWTO (R_PPC64_NONE, /* type */
232 0, /* rightshift */
233 2, /* size (0 = byte, 1 = short, 2 = long) */
234 32, /* bitsize */
235 FALSE, /* pc_relative */
236 0, /* bitpos */
237 complain_overflow_dont, /* complain_on_overflow */
238 bfd_elf_generic_reloc, /* special_function */
239 "R_PPC64_NONE", /* name */
240 FALSE, /* partial_inplace */
241 0, /* src_mask */
242 0, /* dst_mask */
243 FALSE), /* pcrel_offset */
244
245 /* A standard 32 bit relocation. */
246 HOWTO (R_PPC64_ADDR32, /* type */
247 0, /* rightshift */
248 2, /* size (0 = byte, 1 = short, 2 = long) */
249 32, /* bitsize */
250 FALSE, /* pc_relative */
251 0, /* bitpos */
252 complain_overflow_bitfield, /* complain_on_overflow */
253 bfd_elf_generic_reloc, /* special_function */
254 "R_PPC64_ADDR32", /* name */
255 FALSE, /* partial_inplace */
256 0, /* src_mask */
257 0xffffffff, /* dst_mask */
258 FALSE), /* pcrel_offset */
259
260 /* An absolute 26 bit branch; the lower two bits must be zero.
261 FIXME: we don't check that, we just clear them. */
262 HOWTO (R_PPC64_ADDR24, /* type */
263 0, /* rightshift */
264 2, /* size (0 = byte, 1 = short, 2 = long) */
265 26, /* bitsize */
266 FALSE, /* pc_relative */
267 0, /* bitpos */
268 complain_overflow_bitfield, /* complain_on_overflow */
269 bfd_elf_generic_reloc, /* special_function */
270 "R_PPC64_ADDR24", /* name */
271 FALSE, /* partial_inplace */
272 0, /* src_mask */
273 0x03fffffc, /* dst_mask */
274 FALSE), /* pcrel_offset */
275
276 /* A standard 16 bit relocation. */
277 HOWTO (R_PPC64_ADDR16, /* type */
278 0, /* rightshift */
279 1, /* size (0 = byte, 1 = short, 2 = long) */
280 16, /* bitsize */
281 FALSE, /* pc_relative */
282 0, /* bitpos */
283 complain_overflow_bitfield, /* complain_on_overflow */
284 bfd_elf_generic_reloc, /* special_function */
285 "R_PPC64_ADDR16", /* name */
286 FALSE, /* partial_inplace */
287 0, /* src_mask */
288 0xffff, /* dst_mask */
289 FALSE), /* pcrel_offset */
290
291 /* A 16 bit relocation without overflow. */
292 HOWTO (R_PPC64_ADDR16_LO, /* type */
293 0, /* rightshift */
294 1, /* size (0 = byte, 1 = short, 2 = long) */
295 16, /* bitsize */
296 FALSE, /* pc_relative */
297 0, /* bitpos */
298 complain_overflow_dont,/* complain_on_overflow */
299 bfd_elf_generic_reloc, /* special_function */
300 "R_PPC64_ADDR16_LO", /* name */
301 FALSE, /* partial_inplace */
302 0, /* src_mask */
303 0xffff, /* dst_mask */
304 FALSE), /* pcrel_offset */
305
306 /* Bits 16-31 of an address. */
307 HOWTO (R_PPC64_ADDR16_HI, /* type */
308 16, /* rightshift */
309 1, /* size (0 = byte, 1 = short, 2 = long) */
310 16, /* bitsize */
311 FALSE, /* pc_relative */
312 0, /* bitpos */
313 complain_overflow_signed, /* complain_on_overflow */
314 bfd_elf_generic_reloc, /* special_function */
315 "R_PPC64_ADDR16_HI", /* name */
316 FALSE, /* partial_inplace */
317 0, /* src_mask */
318 0xffff, /* dst_mask */
319 FALSE), /* pcrel_offset */
320
321 /* Bits 16-31 of an address, plus 1 if the contents of the low 16
322 bits, treated as a signed number, is negative. */
323 HOWTO (R_PPC64_ADDR16_HA, /* type */
324 16, /* rightshift */
325 1, /* size (0 = byte, 1 = short, 2 = long) */
326 16, /* bitsize */
327 FALSE, /* pc_relative */
328 0, /* bitpos */
329 complain_overflow_signed, /* complain_on_overflow */
330 ppc64_elf_ha_reloc, /* special_function */
331 "R_PPC64_ADDR16_HA", /* name */
332 FALSE, /* partial_inplace */
333 0, /* src_mask */
334 0xffff, /* dst_mask */
335 FALSE), /* pcrel_offset */
336
337 /* An absolute 16 bit branch; the lower two bits must be zero.
338 FIXME: we don't check that, we just clear them. */
339 HOWTO (R_PPC64_ADDR14, /* type */
340 0, /* rightshift */
341 2, /* size (0 = byte, 1 = short, 2 = long) */
342 16, /* bitsize */
343 FALSE, /* pc_relative */
344 0, /* bitpos */
345 complain_overflow_bitfield, /* complain_on_overflow */
346 ppc64_elf_branch_reloc, /* special_function */
347 "R_PPC64_ADDR14", /* name */
348 FALSE, /* partial_inplace */
349 0, /* src_mask */
350 0x0000fffc, /* dst_mask */
351 FALSE), /* pcrel_offset */
352
353 /* An absolute 16 bit branch, for which bit 10 should be set to
354 indicate that the branch is expected to be taken. The lower two
355 bits must be zero. */
356 HOWTO (R_PPC64_ADDR14_BRTAKEN, /* type */
357 0, /* rightshift */
358 2, /* size (0 = byte, 1 = short, 2 = long) */
359 16, /* bitsize */
360 FALSE, /* pc_relative */
361 0, /* bitpos */
362 complain_overflow_bitfield, /* complain_on_overflow */
363 ppc64_elf_brtaken_reloc, /* special_function */
364 "R_PPC64_ADDR14_BRTAKEN",/* name */
365 FALSE, /* partial_inplace */
366 0, /* src_mask */
367 0x0000fffc, /* dst_mask */
368 FALSE), /* pcrel_offset */
369
370 /* An absolute 16 bit branch, for which bit 10 should be set to
371 indicate that the branch is not expected to be taken. The lower
372 two bits must be zero. */
373 HOWTO (R_PPC64_ADDR14_BRNTAKEN, /* 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_bitfield, /* complain_on_overflow */
380 ppc64_elf_brtaken_reloc, /* special_function */
381 "R_PPC64_ADDR14_BRNTAKEN",/* name */
382 FALSE, /* partial_inplace */
383 0, /* src_mask */
384 0x0000fffc, /* dst_mask */
385 FALSE), /* pcrel_offset */
386
387 /* A relative 26 bit branch; the lower two bits must be zero. */
388 HOWTO (R_PPC64_REL24, /* type */
389 0, /* rightshift */
390 2, /* size (0 = byte, 1 = short, 2 = long) */
391 26, /* bitsize */
392 TRUE, /* pc_relative */
393 0, /* bitpos */
394 complain_overflow_signed, /* complain_on_overflow */
395 ppc64_elf_branch_reloc, /* special_function */
396 "R_PPC64_REL24", /* name */
397 FALSE, /* partial_inplace */
398 0, /* src_mask */
399 0x03fffffc, /* dst_mask */
400 TRUE), /* pcrel_offset */
401
402 /* A relative 16 bit branch; the lower two bits must be zero. */
403 HOWTO (R_PPC64_REL14, /* type */
404 0, /* rightshift */
405 2, /* size (0 = byte, 1 = short, 2 = long) */
406 16, /* bitsize */
407 TRUE, /* pc_relative */
408 0, /* bitpos */
409 complain_overflow_signed, /* complain_on_overflow */
410 ppc64_elf_branch_reloc, /* special_function */
411 "R_PPC64_REL14", /* name */
412 FALSE, /* partial_inplace */
413 0, /* src_mask */
414 0x0000fffc, /* dst_mask */
415 TRUE), /* pcrel_offset */
416
417 /* A relative 16 bit branch. Bit 10 should be set to indicate that
418 the branch is expected to be taken. The lower two bits must be
419 zero. */
420 HOWTO (R_PPC64_REL14_BRTAKEN, /* type */
421 0, /* rightshift */
422 2, /* size (0 = byte, 1 = short, 2 = long) */
423 16, /* bitsize */
424 TRUE, /* pc_relative */
425 0, /* bitpos */
426 complain_overflow_signed, /* complain_on_overflow */
427 ppc64_elf_brtaken_reloc, /* special_function */
428 "R_PPC64_REL14_BRTAKEN", /* name */
429 FALSE, /* partial_inplace */
430 0, /* src_mask */
431 0x0000fffc, /* dst_mask */
432 TRUE), /* pcrel_offset */
433
434 /* A relative 16 bit branch. Bit 10 should be set to indicate that
435 the branch is not expected to be taken. The lower two bits must
436 be zero. */
437 HOWTO (R_PPC64_REL14_BRNTAKEN, /* 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_brtaken_reloc, /* special_function */
445 "R_PPC64_REL14_BRNTAKEN",/* name */
446 FALSE, /* partial_inplace */
447 0, /* src_mask */
448 0x0000fffc, /* dst_mask */
449 TRUE), /* pcrel_offset */
450
451 /* Like R_PPC64_ADDR16, but referring to the GOT table entry for the
452 symbol. */
453 HOWTO (R_PPC64_GOT16, /* type */
454 0, /* rightshift */
455 1, /* size (0 = byte, 1 = short, 2 = long) */
456 16, /* bitsize */
457 FALSE, /* pc_relative */
458 0, /* bitpos */
459 complain_overflow_signed, /* complain_on_overflow */
460 ppc64_elf_unhandled_reloc, /* special_function */
461 "R_PPC64_GOT16", /* name */
462 FALSE, /* partial_inplace */
463 0, /* src_mask */
464 0xffff, /* dst_mask */
465 FALSE), /* pcrel_offset */
466
467 /* Like R_PPC64_ADDR16_LO, but referring to the GOT table entry for
468 the symbol. */
469 HOWTO (R_PPC64_GOT16_LO, /* type */
470 0, /* rightshift */
471 1, /* size (0 = byte, 1 = short, 2 = long) */
472 16, /* bitsize */
473 FALSE, /* pc_relative */
474 0, /* bitpos */
475 complain_overflow_dont, /* complain_on_overflow */
476 ppc64_elf_unhandled_reloc, /* special_function */
477 "R_PPC64_GOT16_LO", /* name */
478 FALSE, /* partial_inplace */
479 0, /* src_mask */
480 0xffff, /* dst_mask */
481 FALSE), /* pcrel_offset */
482
483 /* Like R_PPC64_ADDR16_HI, but referring to the GOT table entry for
484 the symbol. */
485 HOWTO (R_PPC64_GOT16_HI, /* type */
486 16, /* rightshift */
487 1, /* size (0 = byte, 1 = short, 2 = long) */
488 16, /* bitsize */
489 FALSE, /* pc_relative */
490 0, /* bitpos */
491 complain_overflow_signed,/* complain_on_overflow */
492 ppc64_elf_unhandled_reloc, /* special_function */
493 "R_PPC64_GOT16_HI", /* name */
494 FALSE, /* partial_inplace */
495 0, /* src_mask */
496 0xffff, /* dst_mask */
497 FALSE), /* pcrel_offset */
498
499 /* Like R_PPC64_ADDR16_HA, but referring to the GOT table entry for
500 the symbol. */
501 HOWTO (R_PPC64_GOT16_HA, /* type */
502 16, /* rightshift */
503 1, /* size (0 = byte, 1 = short, 2 = long) */
504 16, /* bitsize */
505 FALSE, /* pc_relative */
506 0, /* bitpos */
507 complain_overflow_signed,/* complain_on_overflow */
508 ppc64_elf_unhandled_reloc, /* special_function */
509 "R_PPC64_GOT16_HA", /* name */
510 FALSE, /* partial_inplace */
511 0, /* src_mask */
512 0xffff, /* dst_mask */
513 FALSE), /* pcrel_offset */
514
515 /* This is used only by the dynamic linker. The symbol should exist
516 both in the object being run and in some shared library. The
517 dynamic linker copies the data addressed by the symbol from the
518 shared library into the object, because the object being
519 run has to have the data at some particular address. */
520 HOWTO (R_PPC64_COPY, /* type */
521 0, /* rightshift */
522 0, /* this one is variable size */
523 0, /* bitsize */
524 FALSE, /* pc_relative */
525 0, /* bitpos */
526 complain_overflow_dont, /* complain_on_overflow */
527 ppc64_elf_unhandled_reloc, /* special_function */
528 "R_PPC64_COPY", /* name */
529 FALSE, /* partial_inplace */
530 0, /* src_mask */
531 0, /* dst_mask */
532 FALSE), /* pcrel_offset */
533
534 /* Like R_PPC64_ADDR64, but used when setting global offset table
535 entries. */
536 HOWTO (R_PPC64_GLOB_DAT, /* type */
537 0, /* rightshift */
538 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
539 64, /* bitsize */
540 FALSE, /* pc_relative */
541 0, /* bitpos */
542 complain_overflow_dont, /* complain_on_overflow */
543 ppc64_elf_unhandled_reloc, /* special_function */
544 "R_PPC64_GLOB_DAT", /* name */
545 FALSE, /* partial_inplace */
546 0, /* src_mask */
547 ONES (64), /* dst_mask */
548 FALSE), /* pcrel_offset */
549
550 /* Created by the link editor. Marks a procedure linkage table
551 entry for a symbol. */
552 HOWTO (R_PPC64_JMP_SLOT, /* type */
553 0, /* rightshift */
554 0, /* size (0 = byte, 1 = short, 2 = long) */
555 0, /* bitsize */
556 FALSE, /* pc_relative */
557 0, /* bitpos */
558 complain_overflow_dont, /* complain_on_overflow */
559 ppc64_elf_unhandled_reloc, /* special_function */
560 "R_PPC64_JMP_SLOT", /* name */
561 FALSE, /* partial_inplace */
562 0, /* src_mask */
563 0, /* dst_mask */
564 FALSE), /* pcrel_offset */
565
566 /* Used only by the dynamic linker. When the object is run, this
567 doubleword64 is set to the load address of the object, plus the
568 addend. */
569 HOWTO (R_PPC64_RELATIVE, /* type */
570 0, /* rightshift */
571 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
572 64, /* bitsize */
573 FALSE, /* pc_relative */
574 0, /* bitpos */
575 complain_overflow_dont, /* complain_on_overflow */
576 bfd_elf_generic_reloc, /* special_function */
577 "R_PPC64_RELATIVE", /* name */
578 FALSE, /* partial_inplace */
579 0, /* src_mask */
580 ONES (64), /* dst_mask */
581 FALSE), /* pcrel_offset */
582
583 /* Like R_PPC64_ADDR32, but may be unaligned. */
584 HOWTO (R_PPC64_UADDR32, /* type */
585 0, /* rightshift */
586 2, /* size (0 = byte, 1 = short, 2 = long) */
587 32, /* bitsize */
588 FALSE, /* pc_relative */
589 0, /* bitpos */
590 complain_overflow_bitfield, /* complain_on_overflow */
591 bfd_elf_generic_reloc, /* special_function */
592 "R_PPC64_UADDR32", /* name */
593 FALSE, /* partial_inplace */
594 0, /* src_mask */
595 0xffffffff, /* dst_mask */
596 FALSE), /* pcrel_offset */
597
598 /* Like R_PPC64_ADDR16, but may be unaligned. */
599 HOWTO (R_PPC64_UADDR16, /* type */
600 0, /* rightshift */
601 1, /* size (0 = byte, 1 = short, 2 = long) */
602 16, /* bitsize */
603 FALSE, /* pc_relative */
604 0, /* bitpos */
605 complain_overflow_bitfield, /* complain_on_overflow */
606 bfd_elf_generic_reloc, /* special_function */
607 "R_PPC64_UADDR16", /* name */
608 FALSE, /* partial_inplace */
609 0, /* src_mask */
610 0xffff, /* dst_mask */
611 FALSE), /* pcrel_offset */
612
613 /* 32-bit PC relative. */
614 HOWTO (R_PPC64_REL32, /* type */
615 0, /* rightshift */
616 2, /* size (0 = byte, 1 = short, 2 = long) */
617 32, /* bitsize */
618 TRUE, /* pc_relative */
619 0, /* bitpos */
620 /* FIXME: Verify. Was complain_overflow_bitfield. */
621 complain_overflow_signed, /* complain_on_overflow */
622 bfd_elf_generic_reloc, /* special_function */
623 "R_PPC64_REL32", /* name */
624 FALSE, /* partial_inplace */
625 0, /* src_mask */
626 0xffffffff, /* dst_mask */
627 TRUE), /* pcrel_offset */
628
629 /* 32-bit relocation to the symbol's procedure linkage table. */
630 HOWTO (R_PPC64_PLT32, /* type */
631 0, /* rightshift */
632 2, /* size (0 = byte, 1 = short, 2 = long) */
633 32, /* bitsize */
634 FALSE, /* pc_relative */
635 0, /* bitpos */
636 complain_overflow_bitfield, /* complain_on_overflow */
637 ppc64_elf_unhandled_reloc, /* special_function */
638 "R_PPC64_PLT32", /* name */
639 FALSE, /* partial_inplace */
640 0, /* src_mask */
641 0xffffffff, /* dst_mask */
642 FALSE), /* pcrel_offset */
643
644 /* 32-bit PC relative relocation to the symbol's procedure linkage table.
645 FIXME: R_PPC64_PLTREL32 not supported. */
646 HOWTO (R_PPC64_PLTREL32, /* type */
647 0, /* rightshift */
648 2, /* size (0 = byte, 1 = short, 2 = long) */
649 32, /* bitsize */
650 TRUE, /* pc_relative */
651 0, /* bitpos */
652 complain_overflow_signed, /* complain_on_overflow */
653 bfd_elf_generic_reloc, /* special_function */
654 "R_PPC64_PLTREL32", /* name */
655 FALSE, /* partial_inplace */
656 0, /* src_mask */
657 0xffffffff, /* dst_mask */
658 TRUE), /* pcrel_offset */
659
660 /* Like R_PPC64_ADDR16_LO, but referring to the PLT table entry for
661 the symbol. */
662 HOWTO (R_PPC64_PLT16_LO, /* type */
663 0, /* rightshift */
664 1, /* size (0 = byte, 1 = short, 2 = long) */
665 16, /* bitsize */
666 FALSE, /* pc_relative */
667 0, /* bitpos */
668 complain_overflow_dont, /* complain_on_overflow */
669 ppc64_elf_unhandled_reloc, /* special_function */
670 "R_PPC64_PLT16_LO", /* name */
671 FALSE, /* partial_inplace */
672 0, /* src_mask */
673 0xffff, /* dst_mask */
674 FALSE), /* pcrel_offset */
675
676 /* Like R_PPC64_ADDR16_HI, but referring to the PLT table entry for
677 the symbol. */
678 HOWTO (R_PPC64_PLT16_HI, /* type */
679 16, /* rightshift */
680 1, /* size (0 = byte, 1 = short, 2 = long) */
681 16, /* bitsize */
682 FALSE, /* pc_relative */
683 0, /* bitpos */
684 complain_overflow_signed, /* complain_on_overflow */
685 ppc64_elf_unhandled_reloc, /* special_function */
686 "R_PPC64_PLT16_HI", /* name */
687 FALSE, /* partial_inplace */
688 0, /* src_mask */
689 0xffff, /* dst_mask */
690 FALSE), /* pcrel_offset */
691
692 /* Like R_PPC64_ADDR16_HA, but referring to the PLT table entry for
693 the symbol. */
694 HOWTO (R_PPC64_PLT16_HA, /* type */
695 16, /* rightshift */
696 1, /* size (0 = byte, 1 = short, 2 = long) */
697 16, /* bitsize */
698 FALSE, /* pc_relative */
699 0, /* bitpos */
700 complain_overflow_signed, /* complain_on_overflow */
701 ppc64_elf_unhandled_reloc, /* special_function */
702 "R_PPC64_PLT16_HA", /* name */
703 FALSE, /* partial_inplace */
704 0, /* src_mask */
705 0xffff, /* dst_mask */
706 FALSE), /* pcrel_offset */
707
708 /* 16-bit section relative relocation. */
709 HOWTO (R_PPC64_SECTOFF, /* type */
710 0, /* rightshift */
711 1, /* size (0 = byte, 1 = short, 2 = long) */
712 16, /* bitsize */
713 FALSE, /* pc_relative */
714 0, /* bitpos */
715 complain_overflow_bitfield, /* complain_on_overflow */
716 ppc64_elf_sectoff_reloc, /* special_function */
717 "R_PPC64_SECTOFF", /* name */
718 FALSE, /* partial_inplace */
719 0, /* src_mask */
720 0xffff, /* dst_mask */
721 FALSE), /* pcrel_offset */
722
723 /* Like R_PPC64_SECTOFF, but no overflow warning. */
724 HOWTO (R_PPC64_SECTOFF_LO, /* type */
725 0, /* rightshift */
726 1, /* size (0 = byte, 1 = short, 2 = long) */
727 16, /* bitsize */
728 FALSE, /* pc_relative */
729 0, /* bitpos */
730 complain_overflow_dont, /* complain_on_overflow */
731 ppc64_elf_sectoff_reloc, /* special_function */
732 "R_PPC64_SECTOFF_LO", /* name */
733 FALSE, /* partial_inplace */
734 0, /* src_mask */
735 0xffff, /* dst_mask */
736 FALSE), /* pcrel_offset */
737
738 /* 16-bit upper half section relative relocation. */
739 HOWTO (R_PPC64_SECTOFF_HI, /* type */
740 16, /* rightshift */
741 1, /* size (0 = byte, 1 = short, 2 = long) */
742 16, /* bitsize */
743 FALSE, /* pc_relative */
744 0, /* bitpos */
745 complain_overflow_signed, /* complain_on_overflow */
746 ppc64_elf_sectoff_reloc, /* special_function */
747 "R_PPC64_SECTOFF_HI", /* name */
748 FALSE, /* partial_inplace */
749 0, /* src_mask */
750 0xffff, /* dst_mask */
751 FALSE), /* pcrel_offset */
752
753 /* 16-bit upper half adjusted section relative relocation. */
754 HOWTO (R_PPC64_SECTOFF_HA, /* type */
755 16, /* rightshift */
756 1, /* size (0 = byte, 1 = short, 2 = long) */
757 16, /* bitsize */
758 FALSE, /* pc_relative */
759 0, /* bitpos */
760 complain_overflow_signed, /* complain_on_overflow */
761 ppc64_elf_sectoff_ha_reloc, /* special_function */
762 "R_PPC64_SECTOFF_HA", /* name */
763 FALSE, /* partial_inplace */
764 0, /* src_mask */
765 0xffff, /* dst_mask */
766 FALSE), /* pcrel_offset */
767
768 /* Like R_PPC64_REL24 without touching the two least significant bits. */
769 HOWTO (R_PPC64_REL30, /* type */
770 2, /* rightshift */
771 2, /* size (0 = byte, 1 = short, 2 = long) */
772 30, /* bitsize */
773 TRUE, /* pc_relative */
774 0, /* bitpos */
775 complain_overflow_dont, /* complain_on_overflow */
776 bfd_elf_generic_reloc, /* special_function */
777 "R_PPC64_REL30", /* name */
778 FALSE, /* partial_inplace */
779 0, /* src_mask */
780 0xfffffffc, /* dst_mask */
781 TRUE), /* pcrel_offset */
782
783 /* Relocs in the 64-bit PowerPC ELF ABI, not in the 32-bit ABI. */
784
785 /* A standard 64-bit relocation. */
786 HOWTO (R_PPC64_ADDR64, /* type */
787 0, /* rightshift */
788 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
789 64, /* bitsize */
790 FALSE, /* pc_relative */
791 0, /* bitpos */
792 complain_overflow_dont, /* complain_on_overflow */
793 bfd_elf_generic_reloc, /* special_function */
794 "R_PPC64_ADDR64", /* name */
795 FALSE, /* partial_inplace */
796 0, /* src_mask */
797 ONES (64), /* dst_mask */
798 FALSE), /* pcrel_offset */
799
800 /* The bits 32-47 of an address. */
801 HOWTO (R_PPC64_ADDR16_HIGHER, /* type */
802 32, /* rightshift */
803 1, /* size (0 = byte, 1 = short, 2 = long) */
804 16, /* bitsize */
805 FALSE, /* pc_relative */
806 0, /* bitpos */
807 complain_overflow_dont, /* complain_on_overflow */
808 bfd_elf_generic_reloc, /* special_function */
809 "R_PPC64_ADDR16_HIGHER", /* name */
810 FALSE, /* partial_inplace */
811 0, /* src_mask */
812 0xffff, /* dst_mask */
813 FALSE), /* pcrel_offset */
814
815 /* The bits 32-47 of an address, plus 1 if the contents of the low
816 16 bits, treated as a signed number, is negative. */
817 HOWTO (R_PPC64_ADDR16_HIGHERA, /* type */
818 32, /* rightshift */
819 1, /* size (0 = byte, 1 = short, 2 = long) */
820 16, /* bitsize */
821 FALSE, /* pc_relative */
822 0, /* bitpos */
823 complain_overflow_dont, /* complain_on_overflow */
824 ppc64_elf_ha_reloc, /* special_function */
825 "R_PPC64_ADDR16_HIGHERA", /* name */
826 FALSE, /* partial_inplace */
827 0, /* src_mask */
828 0xffff, /* dst_mask */
829 FALSE), /* pcrel_offset */
830
831 /* The bits 48-63 of an address. */
832 HOWTO (R_PPC64_ADDR16_HIGHEST,/* type */
833 48, /* rightshift */
834 1, /* size (0 = byte, 1 = short, 2 = long) */
835 16, /* bitsize */
836 FALSE, /* pc_relative */
837 0, /* bitpos */
838 complain_overflow_dont, /* complain_on_overflow */
839 bfd_elf_generic_reloc, /* special_function */
840 "R_PPC64_ADDR16_HIGHEST", /* name */
841 FALSE, /* partial_inplace */
842 0, /* src_mask */
843 0xffff, /* dst_mask */
844 FALSE), /* pcrel_offset */
845
846 /* The bits 48-63 of an address, plus 1 if the contents of the low
847 16 bits, treated as a signed number, is negative. */
848 HOWTO (R_PPC64_ADDR16_HIGHESTA,/* type */
849 48, /* rightshift */
850 1, /* size (0 = byte, 1 = short, 2 = long) */
851 16, /* bitsize */
852 FALSE, /* pc_relative */
853 0, /* bitpos */
854 complain_overflow_dont, /* complain_on_overflow */
855 ppc64_elf_ha_reloc, /* special_function */
856 "R_PPC64_ADDR16_HIGHESTA", /* name */
857 FALSE, /* partial_inplace */
858 0, /* src_mask */
859 0xffff, /* dst_mask */
860 FALSE), /* pcrel_offset */
861
862 /* Like ADDR64, but may be unaligned. */
863 HOWTO (R_PPC64_UADDR64, /* type */
864 0, /* rightshift */
865 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
866 64, /* bitsize */
867 FALSE, /* pc_relative */
868 0, /* bitpos */
869 complain_overflow_dont, /* complain_on_overflow */
870 bfd_elf_generic_reloc, /* special_function */
871 "R_PPC64_UADDR64", /* name */
872 FALSE, /* partial_inplace */
873 0, /* src_mask */
874 ONES (64), /* dst_mask */
875 FALSE), /* pcrel_offset */
876
877 /* 64-bit relative relocation. */
878 HOWTO (R_PPC64_REL64, /* type */
879 0, /* rightshift */
880 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
881 64, /* bitsize */
882 TRUE, /* pc_relative */
883 0, /* bitpos */
884 complain_overflow_dont, /* complain_on_overflow */
885 bfd_elf_generic_reloc, /* special_function */
886 "R_PPC64_REL64", /* name */
887 FALSE, /* partial_inplace */
888 0, /* src_mask */
889 ONES (64), /* dst_mask */
890 TRUE), /* pcrel_offset */
891
892 /* 64-bit relocation to the symbol's procedure linkage table. */
893 HOWTO (R_PPC64_PLT64, /* type */
894 0, /* rightshift */
895 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
896 64, /* bitsize */
897 FALSE, /* pc_relative */
898 0, /* bitpos */
899 complain_overflow_dont, /* complain_on_overflow */
900 ppc64_elf_unhandled_reloc, /* special_function */
901 "R_PPC64_PLT64", /* name */
902 FALSE, /* partial_inplace */
903 0, /* src_mask */
904 ONES (64), /* dst_mask */
905 FALSE), /* pcrel_offset */
906
907 /* 64-bit PC relative relocation to the symbol's procedure linkage
908 table. */
909 /* FIXME: R_PPC64_PLTREL64 not supported. */
910 HOWTO (R_PPC64_PLTREL64, /* type */
911 0, /* rightshift */
912 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
913 64, /* bitsize */
914 TRUE, /* pc_relative */
915 0, /* bitpos */
916 complain_overflow_dont, /* complain_on_overflow */
917 ppc64_elf_unhandled_reloc, /* special_function */
918 "R_PPC64_PLTREL64", /* name */
919 FALSE, /* partial_inplace */
920 0, /* src_mask */
921 ONES (64), /* dst_mask */
922 TRUE), /* pcrel_offset */
923
924 /* 16 bit TOC-relative relocation. */
925
926 /* R_PPC64_TOC16 47 half16* S + A - .TOC. */
927 HOWTO (R_PPC64_TOC16, /* type */
928 0, /* rightshift */
929 1, /* size (0 = byte, 1 = short, 2 = long) */
930 16, /* bitsize */
931 FALSE, /* pc_relative */
932 0, /* bitpos */
933 complain_overflow_signed, /* complain_on_overflow */
934 ppc64_elf_toc_reloc, /* special_function */
935 "R_PPC64_TOC16", /* name */
936 FALSE, /* partial_inplace */
937 0, /* src_mask */
938 0xffff, /* dst_mask */
939 FALSE), /* pcrel_offset */
940
941 /* 16 bit TOC-relative relocation without overflow. */
942
943 /* R_PPC64_TOC16_LO 48 half16 #lo (S + A - .TOC.) */
944 HOWTO (R_PPC64_TOC16_LO, /* type */
945 0, /* rightshift */
946 1, /* size (0 = byte, 1 = short, 2 = long) */
947 16, /* bitsize */
948 FALSE, /* pc_relative */
949 0, /* bitpos */
950 complain_overflow_dont, /* complain_on_overflow */
951 ppc64_elf_toc_reloc, /* special_function */
952 "R_PPC64_TOC16_LO", /* name */
953 FALSE, /* partial_inplace */
954 0, /* src_mask */
955 0xffff, /* dst_mask */
956 FALSE), /* pcrel_offset */
957
958 /* 16 bit TOC-relative relocation, high 16 bits. */
959
960 /* R_PPC64_TOC16_HI 49 half16 #hi (S + A - .TOC.) */
961 HOWTO (R_PPC64_TOC16_HI, /* type */
962 16, /* rightshift */
963 1, /* size (0 = byte, 1 = short, 2 = long) */
964 16, /* bitsize */
965 FALSE, /* pc_relative */
966 0, /* bitpos */
967 complain_overflow_signed, /* complain_on_overflow */
968 ppc64_elf_toc_reloc, /* special_function */
969 "R_PPC64_TOC16_HI", /* name */
970 FALSE, /* partial_inplace */
971 0, /* src_mask */
972 0xffff, /* dst_mask */
973 FALSE), /* pcrel_offset */
974
975 /* 16 bit TOC-relative relocation, high 16 bits, plus 1 if the
976 contents of the low 16 bits, treated as a signed number, is
977 negative. */
978
979 /* R_PPC64_TOC16_HA 50 half16 #ha (S + A - .TOC.) */
980 HOWTO (R_PPC64_TOC16_HA, /* type */
981 16, /* rightshift */
982 1, /* size (0 = byte, 1 = short, 2 = long) */
983 16, /* bitsize */
984 FALSE, /* pc_relative */
985 0, /* bitpos */
986 complain_overflow_signed, /* complain_on_overflow */
987 ppc64_elf_toc_ha_reloc, /* special_function */
988 "R_PPC64_TOC16_HA", /* name */
989 FALSE, /* partial_inplace */
990 0, /* src_mask */
991 0xffff, /* dst_mask */
992 FALSE), /* pcrel_offset */
993
994 /* 64-bit relocation; insert value of TOC base (.TOC.). */
995
996 /* R_PPC64_TOC 51 doubleword64 .TOC. */
997 HOWTO (R_PPC64_TOC, /* type */
998 0, /* rightshift */
999 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1000 64, /* bitsize */
1001 FALSE, /* pc_relative */
1002 0, /* bitpos */
1003 complain_overflow_bitfield, /* complain_on_overflow */
1004 ppc64_elf_toc64_reloc, /* special_function */
1005 "R_PPC64_TOC", /* name */
1006 FALSE, /* partial_inplace */
1007 0, /* src_mask */
1008 ONES (64), /* dst_mask */
1009 FALSE), /* pcrel_offset */
1010
1011 /* Like R_PPC64_GOT16, but also informs the link editor that the
1012 value to relocate may (!) refer to a PLT entry which the link
1013 editor (a) may replace with the symbol value. If the link editor
1014 is unable to fully resolve the symbol, it may (b) create a PLT
1015 entry and store the address to the new PLT entry in the GOT.
1016 This permits lazy resolution of function symbols at run time.
1017 The link editor may also skip all of this and just (c) emit a
1018 R_PPC64_GLOB_DAT to tie the symbol to the GOT entry. */
1019 /* FIXME: R_PPC64_PLTGOT16 not implemented. */
1020 HOWTO (R_PPC64_PLTGOT16, /* type */
1021 0, /* rightshift */
1022 1, /* size (0 = byte, 1 = short, 2 = long) */
1023 16, /* bitsize */
1024 FALSE, /* pc_relative */
1025 0, /* bitpos */
1026 complain_overflow_signed, /* complain_on_overflow */
1027 ppc64_elf_unhandled_reloc, /* special_function */
1028 "R_PPC64_PLTGOT16", /* name */
1029 FALSE, /* partial_inplace */
1030 0, /* src_mask */
1031 0xffff, /* dst_mask */
1032 FALSE), /* pcrel_offset */
1033
1034 /* Like R_PPC64_PLTGOT16, but without overflow. */
1035 /* FIXME: R_PPC64_PLTGOT16_LO not implemented. */
1036 HOWTO (R_PPC64_PLTGOT16_LO, /* type */
1037 0, /* rightshift */
1038 1, /* size (0 = byte, 1 = short, 2 = long) */
1039 16, /* bitsize */
1040 FALSE, /* pc_relative */
1041 0, /* bitpos */
1042 complain_overflow_dont, /* complain_on_overflow */
1043 ppc64_elf_unhandled_reloc, /* special_function */
1044 "R_PPC64_PLTGOT16_LO", /* name */
1045 FALSE, /* partial_inplace */
1046 0, /* src_mask */
1047 0xffff, /* dst_mask */
1048 FALSE), /* pcrel_offset */
1049
1050 /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address. */
1051 /* FIXME: R_PPC64_PLTGOT16_HI not implemented. */
1052 HOWTO (R_PPC64_PLTGOT16_HI, /* type */
1053 16, /* rightshift */
1054 1, /* size (0 = byte, 1 = short, 2 = long) */
1055 16, /* bitsize */
1056 FALSE, /* pc_relative */
1057 0, /* bitpos */
1058 complain_overflow_signed, /* complain_on_overflow */
1059 ppc64_elf_unhandled_reloc, /* special_function */
1060 "R_PPC64_PLTGOT16_HI", /* name */
1061 FALSE, /* partial_inplace */
1062 0, /* src_mask */
1063 0xffff, /* dst_mask */
1064 FALSE), /* pcrel_offset */
1065
1066 /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address, plus
1067 1 if the contents of the low 16 bits, treated as a signed number,
1068 is negative. */
1069 /* FIXME: R_PPC64_PLTGOT16_HA not implemented. */
1070 HOWTO (R_PPC64_PLTGOT16_HA, /* type */
1071 16, /* rightshift */
1072 1, /* size (0 = byte, 1 = short, 2 = long) */
1073 16, /* bitsize */
1074 FALSE, /* pc_relative */
1075 0, /* bitpos */
1076 complain_overflow_signed, /* complain_on_overflow */
1077 ppc64_elf_unhandled_reloc, /* special_function */
1078 "R_PPC64_PLTGOT16_HA", /* name */
1079 FALSE, /* partial_inplace */
1080 0, /* src_mask */
1081 0xffff, /* dst_mask */
1082 FALSE), /* pcrel_offset */
1083
1084 /* Like R_PPC64_ADDR16, but for instructions with a DS field. */
1085 HOWTO (R_PPC64_ADDR16_DS, /* type */
1086 0, /* rightshift */
1087 1, /* size (0 = byte, 1 = short, 2 = long) */
1088 16, /* bitsize */
1089 FALSE, /* pc_relative */
1090 0, /* bitpos */
1091 complain_overflow_bitfield, /* complain_on_overflow */
1092 bfd_elf_generic_reloc, /* special_function */
1093 "R_PPC64_ADDR16_DS", /* name */
1094 FALSE, /* partial_inplace */
1095 0, /* src_mask */
1096 0xfffc, /* dst_mask */
1097 FALSE), /* pcrel_offset */
1098
1099 /* Like R_PPC64_ADDR16_LO, but for instructions with a DS field. */
1100 HOWTO (R_PPC64_ADDR16_LO_DS, /* type */
1101 0, /* rightshift */
1102 1, /* size (0 = byte, 1 = short, 2 = long) */
1103 16, /* bitsize */
1104 FALSE, /* pc_relative */
1105 0, /* bitpos */
1106 complain_overflow_dont,/* complain_on_overflow */
1107 bfd_elf_generic_reloc, /* special_function */
1108 "R_PPC64_ADDR16_LO_DS",/* name */
1109 FALSE, /* partial_inplace */
1110 0, /* src_mask */
1111 0xfffc, /* dst_mask */
1112 FALSE), /* pcrel_offset */
1113
1114 /* Like R_PPC64_GOT16, but for instructions with a DS field. */
1115 HOWTO (R_PPC64_GOT16_DS, /* type */
1116 0, /* rightshift */
1117 1, /* size (0 = byte, 1 = short, 2 = long) */
1118 16, /* bitsize */
1119 FALSE, /* pc_relative */
1120 0, /* bitpos */
1121 complain_overflow_signed, /* complain_on_overflow */
1122 ppc64_elf_unhandled_reloc, /* special_function */
1123 "R_PPC64_GOT16_DS", /* name */
1124 FALSE, /* partial_inplace */
1125 0, /* src_mask */
1126 0xfffc, /* dst_mask */
1127 FALSE), /* pcrel_offset */
1128
1129 /* Like R_PPC64_GOT16_LO, but for instructions with a DS field. */
1130 HOWTO (R_PPC64_GOT16_LO_DS, /* type */
1131 0, /* rightshift */
1132 1, /* size (0 = byte, 1 = short, 2 = long) */
1133 16, /* bitsize */
1134 FALSE, /* pc_relative */
1135 0, /* bitpos */
1136 complain_overflow_dont, /* complain_on_overflow */
1137 ppc64_elf_unhandled_reloc, /* special_function */
1138 "R_PPC64_GOT16_LO_DS", /* name */
1139 FALSE, /* partial_inplace */
1140 0, /* src_mask */
1141 0xfffc, /* dst_mask */
1142 FALSE), /* pcrel_offset */
1143
1144 /* Like R_PPC64_PLT16_LO, but for instructions with a DS field. */
1145 HOWTO (R_PPC64_PLT16_LO_DS, /* type */
1146 0, /* rightshift */
1147 1, /* size (0 = byte, 1 = short, 2 = long) */
1148 16, /* bitsize */
1149 FALSE, /* pc_relative */
1150 0, /* bitpos */
1151 complain_overflow_dont, /* complain_on_overflow */
1152 ppc64_elf_unhandled_reloc, /* special_function */
1153 "R_PPC64_PLT16_LO_DS", /* name */
1154 FALSE, /* partial_inplace */
1155 0, /* src_mask */
1156 0xfffc, /* dst_mask */
1157 FALSE), /* pcrel_offset */
1158
1159 /* Like R_PPC64_SECTOFF, but for instructions with a DS field. */
1160 HOWTO (R_PPC64_SECTOFF_DS, /* type */
1161 0, /* rightshift */
1162 1, /* size (0 = byte, 1 = short, 2 = long) */
1163 16, /* bitsize */
1164 FALSE, /* pc_relative */
1165 0, /* bitpos */
1166 complain_overflow_bitfield, /* complain_on_overflow */
1167 ppc64_elf_sectoff_reloc, /* special_function */
1168 "R_PPC64_SECTOFF_DS", /* name */
1169 FALSE, /* partial_inplace */
1170 0, /* src_mask */
1171 0xfffc, /* dst_mask */
1172 FALSE), /* pcrel_offset */
1173
1174 /* Like R_PPC64_SECTOFF_LO, but for instructions with a DS field. */
1175 HOWTO (R_PPC64_SECTOFF_LO_DS, /* type */
1176 0, /* rightshift */
1177 1, /* size (0 = byte, 1 = short, 2 = long) */
1178 16, /* bitsize */
1179 FALSE, /* pc_relative */
1180 0, /* bitpos */
1181 complain_overflow_dont, /* complain_on_overflow */
1182 ppc64_elf_sectoff_reloc, /* special_function */
1183 "R_PPC64_SECTOFF_LO_DS",/* name */
1184 FALSE, /* partial_inplace */
1185 0, /* src_mask */
1186 0xfffc, /* dst_mask */
1187 FALSE), /* pcrel_offset */
1188
1189 /* Like R_PPC64_TOC16, but for instructions with a DS field. */
1190 HOWTO (R_PPC64_TOC16_DS, /* type */
1191 0, /* rightshift */
1192 1, /* size (0 = byte, 1 = short, 2 = long) */
1193 16, /* bitsize */
1194 FALSE, /* pc_relative */
1195 0, /* bitpos */
1196 complain_overflow_signed, /* complain_on_overflow */
1197 ppc64_elf_toc_reloc, /* special_function */
1198 "R_PPC64_TOC16_DS", /* name */
1199 FALSE, /* partial_inplace */
1200 0, /* src_mask */
1201 0xfffc, /* dst_mask */
1202 FALSE), /* pcrel_offset */
1203
1204 /* Like R_PPC64_TOC16_LO, but for instructions with a DS field. */
1205 HOWTO (R_PPC64_TOC16_LO_DS, /* type */
1206 0, /* rightshift */
1207 1, /* size (0 = byte, 1 = short, 2 = long) */
1208 16, /* bitsize */
1209 FALSE, /* pc_relative */
1210 0, /* bitpos */
1211 complain_overflow_dont, /* complain_on_overflow */
1212 ppc64_elf_toc_reloc, /* special_function */
1213 "R_PPC64_TOC16_LO_DS", /* name */
1214 FALSE, /* partial_inplace */
1215 0, /* src_mask */
1216 0xfffc, /* dst_mask */
1217 FALSE), /* pcrel_offset */
1218
1219 /* Like R_PPC64_PLTGOT16, but for instructions with a DS field. */
1220 /* FIXME: R_PPC64_PLTGOT16_DS not implemented. */
1221 HOWTO (R_PPC64_PLTGOT16_DS, /* type */
1222 0, /* rightshift */
1223 1, /* size (0 = byte, 1 = short, 2 = long) */
1224 16, /* bitsize */
1225 FALSE, /* pc_relative */
1226 0, /* bitpos */
1227 complain_overflow_signed, /* complain_on_overflow */
1228 ppc64_elf_unhandled_reloc, /* special_function */
1229 "R_PPC64_PLTGOT16_DS", /* name */
1230 FALSE, /* partial_inplace */
1231 0, /* src_mask */
1232 0xfffc, /* dst_mask */
1233 FALSE), /* pcrel_offset */
1234
1235 /* Like R_PPC64_PLTGOT16_LO, but for instructions with a DS field. */
1236 /* FIXME: R_PPC64_PLTGOT16_LO not implemented. */
1237 HOWTO (R_PPC64_PLTGOT16_LO_DS,/* type */
1238 0, /* rightshift */
1239 1, /* size (0 = byte, 1 = short, 2 = long) */
1240 16, /* bitsize */
1241 FALSE, /* pc_relative */
1242 0, /* bitpos */
1243 complain_overflow_dont, /* complain_on_overflow */
1244 ppc64_elf_unhandled_reloc, /* special_function */
1245 "R_PPC64_PLTGOT16_LO_DS",/* name */
1246 FALSE, /* partial_inplace */
1247 0, /* src_mask */
1248 0xfffc, /* dst_mask */
1249 FALSE), /* pcrel_offset */
1250
1251 /* Marker relocs for TLS. */
1252 HOWTO (R_PPC64_TLS,
1253 0, /* rightshift */
1254 2, /* size (0 = byte, 1 = short, 2 = long) */
1255 32, /* bitsize */
1256 FALSE, /* pc_relative */
1257 0, /* bitpos */
1258 complain_overflow_dont, /* complain_on_overflow */
1259 bfd_elf_generic_reloc, /* special_function */
1260 "R_PPC64_TLS", /* name */
1261 FALSE, /* partial_inplace */
1262 0, /* src_mask */
1263 0, /* dst_mask */
1264 FALSE), /* pcrel_offset */
1265
1266 HOWTO (R_PPC64_TLSGD,
1267 0, /* rightshift */
1268 2, /* size (0 = byte, 1 = short, 2 = long) */
1269 32, /* bitsize */
1270 FALSE, /* pc_relative */
1271 0, /* bitpos */
1272 complain_overflow_dont, /* complain_on_overflow */
1273 bfd_elf_generic_reloc, /* special_function */
1274 "R_PPC64_TLSGD", /* name */
1275 FALSE, /* partial_inplace */
1276 0, /* src_mask */
1277 0, /* dst_mask */
1278 FALSE), /* pcrel_offset */
1279
1280 HOWTO (R_PPC64_TLSLD,
1281 0, /* rightshift */
1282 2, /* size (0 = byte, 1 = short, 2 = long) */
1283 32, /* bitsize */
1284 FALSE, /* pc_relative */
1285 0, /* bitpos */
1286 complain_overflow_dont, /* complain_on_overflow */
1287 bfd_elf_generic_reloc, /* special_function */
1288 "R_PPC64_TLSLD", /* name */
1289 FALSE, /* partial_inplace */
1290 0, /* src_mask */
1291 0, /* dst_mask */
1292 FALSE), /* pcrel_offset */
1293
1294 HOWTO (R_PPC64_TOCSAVE,
1295 0, /* rightshift */
1296 2, /* size (0 = byte, 1 = short, 2 = long) */
1297 32, /* bitsize */
1298 FALSE, /* pc_relative */
1299 0, /* bitpos */
1300 complain_overflow_dont, /* complain_on_overflow */
1301 bfd_elf_generic_reloc, /* special_function */
1302 "R_PPC64_TOCSAVE", /* name */
1303 FALSE, /* partial_inplace */
1304 0, /* src_mask */
1305 0, /* dst_mask */
1306 FALSE), /* pcrel_offset */
1307
1308 /* Computes the load module index of the load module that contains the
1309 definition of its TLS sym. */
1310 HOWTO (R_PPC64_DTPMOD64,
1311 0, /* rightshift */
1312 4, /* size (0 = byte, 1 = short, 2 = long) */
1313 64, /* bitsize */
1314 FALSE, /* pc_relative */
1315 0, /* bitpos */
1316 complain_overflow_dont, /* complain_on_overflow */
1317 ppc64_elf_unhandled_reloc, /* special_function */
1318 "R_PPC64_DTPMOD64", /* name */
1319 FALSE, /* partial_inplace */
1320 0, /* src_mask */
1321 ONES (64), /* dst_mask */
1322 FALSE), /* pcrel_offset */
1323
1324 /* Computes a dtv-relative displacement, the difference between the value
1325 of sym+add and the base address of the thread-local storage block that
1326 contains the definition of sym, minus 0x8000. */
1327 HOWTO (R_PPC64_DTPREL64,
1328 0, /* rightshift */
1329 4, /* size (0 = byte, 1 = short, 2 = long) */
1330 64, /* bitsize */
1331 FALSE, /* pc_relative */
1332 0, /* bitpos */
1333 complain_overflow_dont, /* complain_on_overflow */
1334 ppc64_elf_unhandled_reloc, /* special_function */
1335 "R_PPC64_DTPREL64", /* name */
1336 FALSE, /* partial_inplace */
1337 0, /* src_mask */
1338 ONES (64), /* dst_mask */
1339 FALSE), /* pcrel_offset */
1340
1341 /* A 16 bit dtprel reloc. */
1342 HOWTO (R_PPC64_DTPREL16,
1343 0, /* rightshift */
1344 1, /* size (0 = byte, 1 = short, 2 = long) */
1345 16, /* bitsize */
1346 FALSE, /* pc_relative */
1347 0, /* bitpos */
1348 complain_overflow_signed, /* complain_on_overflow */
1349 ppc64_elf_unhandled_reloc, /* special_function */
1350 "R_PPC64_DTPREL16", /* name */
1351 FALSE, /* partial_inplace */
1352 0, /* src_mask */
1353 0xffff, /* dst_mask */
1354 FALSE), /* pcrel_offset */
1355
1356 /* Like DTPREL16, but no overflow. */
1357 HOWTO (R_PPC64_DTPREL16_LO,
1358 0, /* rightshift */
1359 1, /* size (0 = byte, 1 = short, 2 = long) */
1360 16, /* bitsize */
1361 FALSE, /* pc_relative */
1362 0, /* bitpos */
1363 complain_overflow_dont, /* complain_on_overflow */
1364 ppc64_elf_unhandled_reloc, /* special_function */
1365 "R_PPC64_DTPREL16_LO", /* name */
1366 FALSE, /* partial_inplace */
1367 0, /* src_mask */
1368 0xffff, /* dst_mask */
1369 FALSE), /* pcrel_offset */
1370
1371 /* Like DTPREL16_LO, but next higher group of 16 bits. */
1372 HOWTO (R_PPC64_DTPREL16_HI,
1373 16, /* rightshift */
1374 1, /* size (0 = byte, 1 = short, 2 = long) */
1375 16, /* bitsize */
1376 FALSE, /* pc_relative */
1377 0, /* bitpos */
1378 complain_overflow_signed, /* complain_on_overflow */
1379 ppc64_elf_unhandled_reloc, /* special_function */
1380 "R_PPC64_DTPREL16_HI", /* name */
1381 FALSE, /* partial_inplace */
1382 0, /* src_mask */
1383 0xffff, /* dst_mask */
1384 FALSE), /* pcrel_offset */
1385
1386 /* Like DTPREL16_HI, but adjust for low 16 bits. */
1387 HOWTO (R_PPC64_DTPREL16_HA,
1388 16, /* rightshift */
1389 1, /* size (0 = byte, 1 = short, 2 = long) */
1390 16, /* bitsize */
1391 FALSE, /* pc_relative */
1392 0, /* bitpos */
1393 complain_overflow_signed, /* complain_on_overflow */
1394 ppc64_elf_unhandled_reloc, /* special_function */
1395 "R_PPC64_DTPREL16_HA", /* name */
1396 FALSE, /* partial_inplace */
1397 0, /* src_mask */
1398 0xffff, /* dst_mask */
1399 FALSE), /* pcrel_offset */
1400
1401 /* Like DTPREL16_HI, but next higher group of 16 bits. */
1402 HOWTO (R_PPC64_DTPREL16_HIGHER,
1403 32, /* rightshift */
1404 1, /* size (0 = byte, 1 = short, 2 = long) */
1405 16, /* bitsize */
1406 FALSE, /* pc_relative */
1407 0, /* bitpos */
1408 complain_overflow_dont, /* complain_on_overflow */
1409 ppc64_elf_unhandled_reloc, /* special_function */
1410 "R_PPC64_DTPREL16_HIGHER", /* name */
1411 FALSE, /* partial_inplace */
1412 0, /* src_mask */
1413 0xffff, /* dst_mask */
1414 FALSE), /* pcrel_offset */
1415
1416 /* Like DTPREL16_HIGHER, but adjust for low 16 bits. */
1417 HOWTO (R_PPC64_DTPREL16_HIGHERA,
1418 32, /* rightshift */
1419 1, /* size (0 = byte, 1 = short, 2 = long) */
1420 16, /* bitsize */
1421 FALSE, /* pc_relative */
1422 0, /* bitpos */
1423 complain_overflow_dont, /* complain_on_overflow */
1424 ppc64_elf_unhandled_reloc, /* special_function */
1425 "R_PPC64_DTPREL16_HIGHERA", /* name */
1426 FALSE, /* partial_inplace */
1427 0, /* src_mask */
1428 0xffff, /* dst_mask */
1429 FALSE), /* pcrel_offset */
1430
1431 /* Like DTPREL16_HIGHER, but next higher group of 16 bits. */
1432 HOWTO (R_PPC64_DTPREL16_HIGHEST,
1433 48, /* rightshift */
1434 1, /* size (0 = byte, 1 = short, 2 = long) */
1435 16, /* bitsize */
1436 FALSE, /* pc_relative */
1437 0, /* bitpos */
1438 complain_overflow_dont, /* complain_on_overflow */
1439 ppc64_elf_unhandled_reloc, /* special_function */
1440 "R_PPC64_DTPREL16_HIGHEST", /* name */
1441 FALSE, /* partial_inplace */
1442 0, /* src_mask */
1443 0xffff, /* dst_mask */
1444 FALSE), /* pcrel_offset */
1445
1446 /* Like DTPREL16_HIGHEST, but adjust for low 16 bits. */
1447 HOWTO (R_PPC64_DTPREL16_HIGHESTA,
1448 48, /* rightshift */
1449 1, /* size (0 = byte, 1 = short, 2 = long) */
1450 16, /* bitsize */
1451 FALSE, /* pc_relative */
1452 0, /* bitpos */
1453 complain_overflow_dont, /* complain_on_overflow */
1454 ppc64_elf_unhandled_reloc, /* special_function */
1455 "R_PPC64_DTPREL16_HIGHESTA", /* name */
1456 FALSE, /* partial_inplace */
1457 0, /* src_mask */
1458 0xffff, /* dst_mask */
1459 FALSE), /* pcrel_offset */
1460
1461 /* Like DTPREL16, but for insns with a DS field. */
1462 HOWTO (R_PPC64_DTPREL16_DS,
1463 0, /* rightshift */
1464 1, /* size (0 = byte, 1 = short, 2 = long) */
1465 16, /* bitsize */
1466 FALSE, /* pc_relative */
1467 0, /* bitpos */
1468 complain_overflow_signed, /* complain_on_overflow */
1469 ppc64_elf_unhandled_reloc, /* special_function */
1470 "R_PPC64_DTPREL16_DS", /* name */
1471 FALSE, /* partial_inplace */
1472 0, /* src_mask */
1473 0xfffc, /* dst_mask */
1474 FALSE), /* pcrel_offset */
1475
1476 /* Like DTPREL16_DS, but no overflow. */
1477 HOWTO (R_PPC64_DTPREL16_LO_DS,
1478 0, /* rightshift */
1479 1, /* size (0 = byte, 1 = short, 2 = long) */
1480 16, /* bitsize */
1481 FALSE, /* pc_relative */
1482 0, /* bitpos */
1483 complain_overflow_dont, /* complain_on_overflow */
1484 ppc64_elf_unhandled_reloc, /* special_function */
1485 "R_PPC64_DTPREL16_LO_DS", /* name */
1486 FALSE, /* partial_inplace */
1487 0, /* src_mask */
1488 0xfffc, /* dst_mask */
1489 FALSE), /* pcrel_offset */
1490
1491 /* Computes a tp-relative displacement, the difference between the value of
1492 sym+add and the value of the thread pointer (r13). */
1493 HOWTO (R_PPC64_TPREL64,
1494 0, /* rightshift */
1495 4, /* size (0 = byte, 1 = short, 2 = long) */
1496 64, /* bitsize */
1497 FALSE, /* pc_relative */
1498 0, /* bitpos */
1499 complain_overflow_dont, /* complain_on_overflow */
1500 ppc64_elf_unhandled_reloc, /* special_function */
1501 "R_PPC64_TPREL64", /* name */
1502 FALSE, /* partial_inplace */
1503 0, /* src_mask */
1504 ONES (64), /* dst_mask */
1505 FALSE), /* pcrel_offset */
1506
1507 /* A 16 bit tprel reloc. */
1508 HOWTO (R_PPC64_TPREL16,
1509 0, /* rightshift */
1510 1, /* size (0 = byte, 1 = short, 2 = long) */
1511 16, /* bitsize */
1512 FALSE, /* pc_relative */
1513 0, /* bitpos */
1514 complain_overflow_signed, /* complain_on_overflow */
1515 ppc64_elf_unhandled_reloc, /* special_function */
1516 "R_PPC64_TPREL16", /* name */
1517 FALSE, /* partial_inplace */
1518 0, /* src_mask */
1519 0xffff, /* dst_mask */
1520 FALSE), /* pcrel_offset */
1521
1522 /* Like TPREL16, but no overflow. */
1523 HOWTO (R_PPC64_TPREL16_LO,
1524 0, /* rightshift */
1525 1, /* size (0 = byte, 1 = short, 2 = long) */
1526 16, /* bitsize */
1527 FALSE, /* pc_relative */
1528 0, /* bitpos */
1529 complain_overflow_dont, /* complain_on_overflow */
1530 ppc64_elf_unhandled_reloc, /* special_function */
1531 "R_PPC64_TPREL16_LO", /* name */
1532 FALSE, /* partial_inplace */
1533 0, /* src_mask */
1534 0xffff, /* dst_mask */
1535 FALSE), /* pcrel_offset */
1536
1537 /* Like TPREL16_LO, but next higher group of 16 bits. */
1538 HOWTO (R_PPC64_TPREL16_HI,
1539 16, /* rightshift */
1540 1, /* size (0 = byte, 1 = short, 2 = long) */
1541 16, /* bitsize */
1542 FALSE, /* pc_relative */
1543 0, /* bitpos */
1544 complain_overflow_signed, /* complain_on_overflow */
1545 ppc64_elf_unhandled_reloc, /* special_function */
1546 "R_PPC64_TPREL16_HI", /* name */
1547 FALSE, /* partial_inplace */
1548 0, /* src_mask */
1549 0xffff, /* dst_mask */
1550 FALSE), /* pcrel_offset */
1551
1552 /* Like TPREL16_HI, but adjust for low 16 bits. */
1553 HOWTO (R_PPC64_TPREL16_HA,
1554 16, /* rightshift */
1555 1, /* size (0 = byte, 1 = short, 2 = long) */
1556 16, /* bitsize */
1557 FALSE, /* pc_relative */
1558 0, /* bitpos */
1559 complain_overflow_signed, /* complain_on_overflow */
1560 ppc64_elf_unhandled_reloc, /* special_function */
1561 "R_PPC64_TPREL16_HA", /* name */
1562 FALSE, /* partial_inplace */
1563 0, /* src_mask */
1564 0xffff, /* dst_mask */
1565 FALSE), /* pcrel_offset */
1566
1567 /* Like TPREL16_HI, but next higher group of 16 bits. */
1568 HOWTO (R_PPC64_TPREL16_HIGHER,
1569 32, /* rightshift */
1570 1, /* size (0 = byte, 1 = short, 2 = long) */
1571 16, /* bitsize */
1572 FALSE, /* pc_relative */
1573 0, /* bitpos */
1574 complain_overflow_dont, /* complain_on_overflow */
1575 ppc64_elf_unhandled_reloc, /* special_function */
1576 "R_PPC64_TPREL16_HIGHER", /* name */
1577 FALSE, /* partial_inplace */
1578 0, /* src_mask */
1579 0xffff, /* dst_mask */
1580 FALSE), /* pcrel_offset */
1581
1582 /* Like TPREL16_HIGHER, but adjust for low 16 bits. */
1583 HOWTO (R_PPC64_TPREL16_HIGHERA,
1584 32, /* rightshift */
1585 1, /* size (0 = byte, 1 = short, 2 = long) */
1586 16, /* bitsize */
1587 FALSE, /* pc_relative */
1588 0, /* bitpos */
1589 complain_overflow_dont, /* complain_on_overflow */
1590 ppc64_elf_unhandled_reloc, /* special_function */
1591 "R_PPC64_TPREL16_HIGHERA", /* name */
1592 FALSE, /* partial_inplace */
1593 0, /* src_mask */
1594 0xffff, /* dst_mask */
1595 FALSE), /* pcrel_offset */
1596
1597 /* Like TPREL16_HIGHER, but next higher group of 16 bits. */
1598 HOWTO (R_PPC64_TPREL16_HIGHEST,
1599 48, /* rightshift */
1600 1, /* size (0 = byte, 1 = short, 2 = long) */
1601 16, /* bitsize */
1602 FALSE, /* pc_relative */
1603 0, /* bitpos */
1604 complain_overflow_dont, /* complain_on_overflow */
1605 ppc64_elf_unhandled_reloc, /* special_function */
1606 "R_PPC64_TPREL16_HIGHEST", /* name */
1607 FALSE, /* partial_inplace */
1608 0, /* src_mask */
1609 0xffff, /* dst_mask */
1610 FALSE), /* pcrel_offset */
1611
1612 /* Like TPREL16_HIGHEST, but adjust for low 16 bits. */
1613 HOWTO (R_PPC64_TPREL16_HIGHESTA,
1614 48, /* rightshift */
1615 1, /* size (0 = byte, 1 = short, 2 = long) */
1616 16, /* bitsize */
1617 FALSE, /* pc_relative */
1618 0, /* bitpos */
1619 complain_overflow_dont, /* complain_on_overflow */
1620 ppc64_elf_unhandled_reloc, /* special_function */
1621 "R_PPC64_TPREL16_HIGHESTA", /* name */
1622 FALSE, /* partial_inplace */
1623 0, /* src_mask */
1624 0xffff, /* dst_mask */
1625 FALSE), /* pcrel_offset */
1626
1627 /* Like TPREL16, but for insns with a DS field. */
1628 HOWTO (R_PPC64_TPREL16_DS,
1629 0, /* rightshift */
1630 1, /* size (0 = byte, 1 = short, 2 = long) */
1631 16, /* bitsize */
1632 FALSE, /* pc_relative */
1633 0, /* bitpos */
1634 complain_overflow_signed, /* complain_on_overflow */
1635 ppc64_elf_unhandled_reloc, /* special_function */
1636 "R_PPC64_TPREL16_DS", /* name */
1637 FALSE, /* partial_inplace */
1638 0, /* src_mask */
1639 0xfffc, /* dst_mask */
1640 FALSE), /* pcrel_offset */
1641
1642 /* Like TPREL16_DS, but no overflow. */
1643 HOWTO (R_PPC64_TPREL16_LO_DS,
1644 0, /* rightshift */
1645 1, /* size (0 = byte, 1 = short, 2 = long) */
1646 16, /* bitsize */
1647 FALSE, /* pc_relative */
1648 0, /* bitpos */
1649 complain_overflow_dont, /* complain_on_overflow */
1650 ppc64_elf_unhandled_reloc, /* special_function */
1651 "R_PPC64_TPREL16_LO_DS", /* name */
1652 FALSE, /* partial_inplace */
1653 0, /* src_mask */
1654 0xfffc, /* dst_mask */
1655 FALSE), /* pcrel_offset */
1656
1657 /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1658 with values (sym+add)@dtpmod and (sym+add)@dtprel, and computes the offset
1659 to the first entry relative to the TOC base (r2). */
1660 HOWTO (R_PPC64_GOT_TLSGD16,
1661 0, /* rightshift */
1662 1, /* size (0 = byte, 1 = short, 2 = long) */
1663 16, /* bitsize */
1664 FALSE, /* pc_relative */
1665 0, /* bitpos */
1666 complain_overflow_signed, /* complain_on_overflow */
1667 ppc64_elf_unhandled_reloc, /* special_function */
1668 "R_PPC64_GOT_TLSGD16", /* name */
1669 FALSE, /* partial_inplace */
1670 0, /* src_mask */
1671 0xffff, /* dst_mask */
1672 FALSE), /* pcrel_offset */
1673
1674 /* Like GOT_TLSGD16, but no overflow. */
1675 HOWTO (R_PPC64_GOT_TLSGD16_LO,
1676 0, /* rightshift */
1677 1, /* size (0 = byte, 1 = short, 2 = long) */
1678 16, /* bitsize */
1679 FALSE, /* pc_relative */
1680 0, /* bitpos */
1681 complain_overflow_dont, /* complain_on_overflow */
1682 ppc64_elf_unhandled_reloc, /* special_function */
1683 "R_PPC64_GOT_TLSGD16_LO", /* name */
1684 FALSE, /* partial_inplace */
1685 0, /* src_mask */
1686 0xffff, /* dst_mask */
1687 FALSE), /* pcrel_offset */
1688
1689 /* Like GOT_TLSGD16_LO, but next higher group of 16 bits. */
1690 HOWTO (R_PPC64_GOT_TLSGD16_HI,
1691 16, /* rightshift */
1692 1, /* size (0 = byte, 1 = short, 2 = long) */
1693 16, /* bitsize */
1694 FALSE, /* pc_relative */
1695 0, /* bitpos */
1696 complain_overflow_signed, /* complain_on_overflow */
1697 ppc64_elf_unhandled_reloc, /* special_function */
1698 "R_PPC64_GOT_TLSGD16_HI", /* name */
1699 FALSE, /* partial_inplace */
1700 0, /* src_mask */
1701 0xffff, /* dst_mask */
1702 FALSE), /* pcrel_offset */
1703
1704 /* Like GOT_TLSGD16_HI, but adjust for low 16 bits. */
1705 HOWTO (R_PPC64_GOT_TLSGD16_HA,
1706 16, /* rightshift */
1707 1, /* size (0 = byte, 1 = short, 2 = long) */
1708 16, /* bitsize */
1709 FALSE, /* pc_relative */
1710 0, /* bitpos */
1711 complain_overflow_signed, /* complain_on_overflow */
1712 ppc64_elf_unhandled_reloc, /* special_function */
1713 "R_PPC64_GOT_TLSGD16_HA", /* name */
1714 FALSE, /* partial_inplace */
1715 0, /* src_mask */
1716 0xffff, /* dst_mask */
1717 FALSE), /* pcrel_offset */
1718
1719 /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1720 with values (sym+add)@dtpmod and zero, and computes the offset to the
1721 first entry relative to the TOC base (r2). */
1722 HOWTO (R_PPC64_GOT_TLSLD16,
1723 0, /* rightshift */
1724 1, /* size (0 = byte, 1 = short, 2 = long) */
1725 16, /* bitsize */
1726 FALSE, /* pc_relative */
1727 0, /* bitpos */
1728 complain_overflow_signed, /* complain_on_overflow */
1729 ppc64_elf_unhandled_reloc, /* special_function */
1730 "R_PPC64_GOT_TLSLD16", /* name */
1731 FALSE, /* partial_inplace */
1732 0, /* src_mask */
1733 0xffff, /* dst_mask */
1734 FALSE), /* pcrel_offset */
1735
1736 /* Like GOT_TLSLD16, but no overflow. */
1737 HOWTO (R_PPC64_GOT_TLSLD16_LO,
1738 0, /* rightshift */
1739 1, /* size (0 = byte, 1 = short, 2 = long) */
1740 16, /* bitsize */
1741 FALSE, /* pc_relative */
1742 0, /* bitpos */
1743 complain_overflow_dont, /* complain_on_overflow */
1744 ppc64_elf_unhandled_reloc, /* special_function */
1745 "R_PPC64_GOT_TLSLD16_LO", /* name */
1746 FALSE, /* partial_inplace */
1747 0, /* src_mask */
1748 0xffff, /* dst_mask */
1749 FALSE), /* pcrel_offset */
1750
1751 /* Like GOT_TLSLD16_LO, but next higher group of 16 bits. */
1752 HOWTO (R_PPC64_GOT_TLSLD16_HI,
1753 16, /* rightshift */
1754 1, /* size (0 = byte, 1 = short, 2 = long) */
1755 16, /* bitsize */
1756 FALSE, /* pc_relative */
1757 0, /* bitpos */
1758 complain_overflow_signed, /* complain_on_overflow */
1759 ppc64_elf_unhandled_reloc, /* special_function */
1760 "R_PPC64_GOT_TLSLD16_HI", /* name */
1761 FALSE, /* partial_inplace */
1762 0, /* src_mask */
1763 0xffff, /* dst_mask */
1764 FALSE), /* pcrel_offset */
1765
1766 /* Like GOT_TLSLD16_HI, but adjust for low 16 bits. */
1767 HOWTO (R_PPC64_GOT_TLSLD16_HA,
1768 16, /* rightshift */
1769 1, /* size (0 = byte, 1 = short, 2 = long) */
1770 16, /* bitsize */
1771 FALSE, /* pc_relative */
1772 0, /* bitpos */
1773 complain_overflow_signed, /* complain_on_overflow */
1774 ppc64_elf_unhandled_reloc, /* special_function */
1775 "R_PPC64_GOT_TLSLD16_HA", /* name */
1776 FALSE, /* partial_inplace */
1777 0, /* src_mask */
1778 0xffff, /* dst_mask */
1779 FALSE), /* pcrel_offset */
1780
1781 /* Allocates an entry in the GOT with value (sym+add)@dtprel, and computes
1782 the offset to the entry relative to the TOC base (r2). */
1783 HOWTO (R_PPC64_GOT_DTPREL16_DS,
1784 0, /* rightshift */
1785 1, /* size (0 = byte, 1 = short, 2 = long) */
1786 16, /* bitsize */
1787 FALSE, /* pc_relative */
1788 0, /* bitpos */
1789 complain_overflow_signed, /* complain_on_overflow */
1790 ppc64_elf_unhandled_reloc, /* special_function */
1791 "R_PPC64_GOT_DTPREL16_DS", /* name */
1792 FALSE, /* partial_inplace */
1793 0, /* src_mask */
1794 0xfffc, /* dst_mask */
1795 FALSE), /* pcrel_offset */
1796
1797 /* Like GOT_DTPREL16_DS, but no overflow. */
1798 HOWTO (R_PPC64_GOT_DTPREL16_LO_DS,
1799 0, /* rightshift */
1800 1, /* size (0 = byte, 1 = short, 2 = long) */
1801 16, /* bitsize */
1802 FALSE, /* pc_relative */
1803 0, /* bitpos */
1804 complain_overflow_dont, /* complain_on_overflow */
1805 ppc64_elf_unhandled_reloc, /* special_function */
1806 "R_PPC64_GOT_DTPREL16_LO_DS", /* name */
1807 FALSE, /* partial_inplace */
1808 0, /* src_mask */
1809 0xfffc, /* dst_mask */
1810 FALSE), /* pcrel_offset */
1811
1812 /* Like GOT_DTPREL16_LO_DS, but next higher group of 16 bits. */
1813 HOWTO (R_PPC64_GOT_DTPREL16_HI,
1814 16, /* rightshift */
1815 1, /* size (0 = byte, 1 = short, 2 = long) */
1816 16, /* bitsize */
1817 FALSE, /* pc_relative */
1818 0, /* bitpos */
1819 complain_overflow_signed, /* complain_on_overflow */
1820 ppc64_elf_unhandled_reloc, /* special_function */
1821 "R_PPC64_GOT_DTPREL16_HI", /* name */
1822 FALSE, /* partial_inplace */
1823 0, /* src_mask */
1824 0xffff, /* dst_mask */
1825 FALSE), /* pcrel_offset */
1826
1827 /* Like GOT_DTPREL16_HI, but adjust for low 16 bits. */
1828 HOWTO (R_PPC64_GOT_DTPREL16_HA,
1829 16, /* rightshift */
1830 1, /* size (0 = byte, 1 = short, 2 = long) */
1831 16, /* bitsize */
1832 FALSE, /* pc_relative */
1833 0, /* bitpos */
1834 complain_overflow_signed, /* complain_on_overflow */
1835 ppc64_elf_unhandled_reloc, /* special_function */
1836 "R_PPC64_GOT_DTPREL16_HA", /* name */
1837 FALSE, /* partial_inplace */
1838 0, /* src_mask */
1839 0xffff, /* dst_mask */
1840 FALSE), /* pcrel_offset */
1841
1842 /* Allocates an entry in the GOT with value (sym+add)@tprel, and computes the
1843 offset to the entry relative to the TOC base (r2). */
1844 HOWTO (R_PPC64_GOT_TPREL16_DS,
1845 0, /* rightshift */
1846 1, /* size (0 = byte, 1 = short, 2 = long) */
1847 16, /* bitsize */
1848 FALSE, /* pc_relative */
1849 0, /* bitpos */
1850 complain_overflow_signed, /* complain_on_overflow */
1851 ppc64_elf_unhandled_reloc, /* special_function */
1852 "R_PPC64_GOT_TPREL16_DS", /* name */
1853 FALSE, /* partial_inplace */
1854 0, /* src_mask */
1855 0xfffc, /* dst_mask */
1856 FALSE), /* pcrel_offset */
1857
1858 /* Like GOT_TPREL16_DS, but no overflow. */
1859 HOWTO (R_PPC64_GOT_TPREL16_LO_DS,
1860 0, /* rightshift */
1861 1, /* size (0 = byte, 1 = short, 2 = long) */
1862 16, /* bitsize */
1863 FALSE, /* pc_relative */
1864 0, /* bitpos */
1865 complain_overflow_dont, /* complain_on_overflow */
1866 ppc64_elf_unhandled_reloc, /* special_function */
1867 "R_PPC64_GOT_TPREL16_LO_DS", /* name */
1868 FALSE, /* partial_inplace */
1869 0, /* src_mask */
1870 0xfffc, /* dst_mask */
1871 FALSE), /* pcrel_offset */
1872
1873 /* Like GOT_TPREL16_LO_DS, but next higher group of 16 bits. */
1874 HOWTO (R_PPC64_GOT_TPREL16_HI,
1875 16, /* rightshift */
1876 1, /* size (0 = byte, 1 = short, 2 = long) */
1877 16, /* bitsize */
1878 FALSE, /* pc_relative */
1879 0, /* bitpos */
1880 complain_overflow_signed, /* complain_on_overflow */
1881 ppc64_elf_unhandled_reloc, /* special_function */
1882 "R_PPC64_GOT_TPREL16_HI", /* name */
1883 FALSE, /* partial_inplace */
1884 0, /* src_mask */
1885 0xffff, /* dst_mask */
1886 FALSE), /* pcrel_offset */
1887
1888 /* Like GOT_TPREL16_HI, but adjust for low 16 bits. */
1889 HOWTO (R_PPC64_GOT_TPREL16_HA,
1890 16, /* rightshift */
1891 1, /* size (0 = byte, 1 = short, 2 = long) */
1892 16, /* bitsize */
1893 FALSE, /* pc_relative */
1894 0, /* bitpos */
1895 complain_overflow_signed, /* complain_on_overflow */
1896 ppc64_elf_unhandled_reloc, /* special_function */
1897 "R_PPC64_GOT_TPREL16_HA", /* name */
1898 FALSE, /* partial_inplace */
1899 0, /* src_mask */
1900 0xffff, /* dst_mask */
1901 FALSE), /* pcrel_offset */
1902
1903 HOWTO (R_PPC64_JMP_IREL, /* type */
1904 0, /* rightshift */
1905 0, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1906 0, /* bitsize */
1907 FALSE, /* pc_relative */
1908 0, /* bitpos */
1909 complain_overflow_dont, /* complain_on_overflow */
1910 ppc64_elf_unhandled_reloc, /* special_function */
1911 "R_PPC64_JMP_IREL", /* name */
1912 FALSE, /* partial_inplace */
1913 0, /* src_mask */
1914 0, /* dst_mask */
1915 FALSE), /* pcrel_offset */
1916
1917 HOWTO (R_PPC64_IRELATIVE, /* type */
1918 0, /* rightshift */
1919 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1920 64, /* bitsize */
1921 FALSE, /* pc_relative */
1922 0, /* bitpos */
1923 complain_overflow_dont, /* complain_on_overflow */
1924 bfd_elf_generic_reloc, /* special_function */
1925 "R_PPC64_IRELATIVE", /* name */
1926 FALSE, /* partial_inplace */
1927 0, /* src_mask */
1928 ONES (64), /* dst_mask */
1929 FALSE), /* pcrel_offset */
1930
1931 /* A 16 bit relative relocation. */
1932 HOWTO (R_PPC64_REL16, /* type */
1933 0, /* rightshift */
1934 1, /* size (0 = byte, 1 = short, 2 = long) */
1935 16, /* bitsize */
1936 TRUE, /* pc_relative */
1937 0, /* bitpos */
1938 complain_overflow_bitfield, /* complain_on_overflow */
1939 bfd_elf_generic_reloc, /* special_function */
1940 "R_PPC64_REL16", /* name */
1941 FALSE, /* partial_inplace */
1942 0, /* src_mask */
1943 0xffff, /* dst_mask */
1944 TRUE), /* pcrel_offset */
1945
1946 /* A 16 bit relative relocation without overflow. */
1947 HOWTO (R_PPC64_REL16_LO, /* type */
1948 0, /* rightshift */
1949 1, /* size (0 = byte, 1 = short, 2 = long) */
1950 16, /* bitsize */
1951 TRUE, /* pc_relative */
1952 0, /* bitpos */
1953 complain_overflow_dont,/* complain_on_overflow */
1954 bfd_elf_generic_reloc, /* special_function */
1955 "R_PPC64_REL16_LO", /* name */
1956 FALSE, /* partial_inplace */
1957 0, /* src_mask */
1958 0xffff, /* dst_mask */
1959 TRUE), /* pcrel_offset */
1960
1961 /* The high order 16 bits of a relative address. */
1962 HOWTO (R_PPC64_REL16_HI, /* type */
1963 16, /* rightshift */
1964 1, /* size (0 = byte, 1 = short, 2 = long) */
1965 16, /* bitsize */
1966 TRUE, /* pc_relative */
1967 0, /* bitpos */
1968 complain_overflow_signed, /* complain_on_overflow */
1969 bfd_elf_generic_reloc, /* special_function */
1970 "R_PPC64_REL16_HI", /* name */
1971 FALSE, /* partial_inplace */
1972 0, /* src_mask */
1973 0xffff, /* dst_mask */
1974 TRUE), /* pcrel_offset */
1975
1976 /* The high order 16 bits of a relative address, plus 1 if the contents of
1977 the low 16 bits, treated as a signed number, is negative. */
1978 HOWTO (R_PPC64_REL16_HA, /* type */
1979 16, /* rightshift */
1980 1, /* size (0 = byte, 1 = short, 2 = long) */
1981 16, /* bitsize */
1982 TRUE, /* pc_relative */
1983 0, /* bitpos */
1984 complain_overflow_signed, /* complain_on_overflow */
1985 ppc64_elf_ha_reloc, /* special_function */
1986 "R_PPC64_REL16_HA", /* name */
1987 FALSE, /* partial_inplace */
1988 0, /* src_mask */
1989 0xffff, /* dst_mask */
1990 TRUE), /* pcrel_offset */
1991
1992 /* Like R_PPC64_ADDR16_HI, but no overflow. */
1993 HOWTO (R_PPC64_ADDR16_HIGH, /* type */
1994 16, /* rightshift */
1995 1, /* size (0 = byte, 1 = short, 2 = long) */
1996 16, /* bitsize */
1997 FALSE, /* pc_relative */
1998 0, /* bitpos */
1999 complain_overflow_dont, /* complain_on_overflow */
2000 bfd_elf_generic_reloc, /* special_function */
2001 "R_PPC64_ADDR16_HIGH", /* name */
2002 FALSE, /* partial_inplace */
2003 0, /* src_mask */
2004 0xffff, /* dst_mask */
2005 FALSE), /* pcrel_offset */
2006
2007 /* Like R_PPC64_ADDR16_HA, but no overflow. */
2008 HOWTO (R_PPC64_ADDR16_HIGHA, /* type */
2009 16, /* rightshift */
2010 1, /* size (0 = byte, 1 = short, 2 = long) */
2011 16, /* bitsize */
2012 FALSE, /* pc_relative */
2013 0, /* bitpos */
2014 complain_overflow_dont, /* complain_on_overflow */
2015 ppc64_elf_ha_reloc, /* special_function */
2016 "R_PPC64_ADDR16_HIGHA", /* name */
2017 FALSE, /* partial_inplace */
2018 0, /* src_mask */
2019 0xffff, /* dst_mask */
2020 FALSE), /* pcrel_offset */
2021
2022 /* Like R_PPC64_DTPREL16_HI, but no overflow. */
2023 HOWTO (R_PPC64_DTPREL16_HIGH,
2024 16, /* rightshift */
2025 1, /* size (0 = byte, 1 = short, 2 = long) */
2026 16, /* bitsize */
2027 FALSE, /* pc_relative */
2028 0, /* bitpos */
2029 complain_overflow_dont, /* complain_on_overflow */
2030 ppc64_elf_unhandled_reloc, /* special_function */
2031 "R_PPC64_DTPREL16_HIGH", /* name */
2032 FALSE, /* partial_inplace */
2033 0, /* src_mask */
2034 0xffff, /* dst_mask */
2035 FALSE), /* pcrel_offset */
2036
2037 /* Like R_PPC64_DTPREL16_HA, but no overflow. */
2038 HOWTO (R_PPC64_DTPREL16_HIGHA,
2039 16, /* rightshift */
2040 1, /* size (0 = byte, 1 = short, 2 = long) */
2041 16, /* bitsize */
2042 FALSE, /* pc_relative */
2043 0, /* bitpos */
2044 complain_overflow_dont, /* complain_on_overflow */
2045 ppc64_elf_unhandled_reloc, /* special_function */
2046 "R_PPC64_DTPREL16_HIGHA", /* name */
2047 FALSE, /* partial_inplace */
2048 0, /* src_mask */
2049 0xffff, /* dst_mask */
2050 FALSE), /* pcrel_offset */
2051
2052 /* Like R_PPC64_TPREL16_HI, but no overflow. */
2053 HOWTO (R_PPC64_TPREL16_HIGH,
2054 16, /* rightshift */
2055 1, /* size (0 = byte, 1 = short, 2 = long) */
2056 16, /* bitsize */
2057 FALSE, /* pc_relative */
2058 0, /* bitpos */
2059 complain_overflow_dont, /* complain_on_overflow */
2060 ppc64_elf_unhandled_reloc, /* special_function */
2061 "R_PPC64_TPREL16_HIGH", /* name */
2062 FALSE, /* partial_inplace */
2063 0, /* src_mask */
2064 0xffff, /* dst_mask */
2065 FALSE), /* pcrel_offset */
2066
2067 /* Like R_PPC64_TPREL16_HA, but no overflow. */
2068 HOWTO (R_PPC64_TPREL16_HIGHA,
2069 16, /* rightshift */
2070 1, /* size (0 = byte, 1 = short, 2 = long) */
2071 16, /* bitsize */
2072 FALSE, /* pc_relative */
2073 0, /* bitpos */
2074 complain_overflow_dont, /* complain_on_overflow */
2075 ppc64_elf_unhandled_reloc, /* special_function */
2076 "R_PPC64_TPREL16_HIGHA", /* name */
2077 FALSE, /* partial_inplace */
2078 0, /* src_mask */
2079 0xffff, /* dst_mask */
2080 FALSE), /* pcrel_offset */
2081
2082 /* GNU extension to record C++ vtable hierarchy. */
2083 HOWTO (R_PPC64_GNU_VTINHERIT, /* type */
2084 0, /* rightshift */
2085 0, /* size (0 = byte, 1 = short, 2 = long) */
2086 0, /* bitsize */
2087 FALSE, /* pc_relative */
2088 0, /* bitpos */
2089 complain_overflow_dont, /* complain_on_overflow */
2090 NULL, /* special_function */
2091 "R_PPC64_GNU_VTINHERIT", /* name */
2092 FALSE, /* partial_inplace */
2093 0, /* src_mask */
2094 0, /* dst_mask */
2095 FALSE), /* pcrel_offset */
2096
2097 /* GNU extension to record C++ vtable member usage. */
2098 HOWTO (R_PPC64_GNU_VTENTRY, /* type */
2099 0, /* rightshift */
2100 0, /* size (0 = byte, 1 = short, 2 = long) */
2101 0, /* bitsize */
2102 FALSE, /* pc_relative */
2103 0, /* bitpos */
2104 complain_overflow_dont, /* complain_on_overflow */
2105 NULL, /* special_function */
2106 "R_PPC64_GNU_VTENTRY", /* name */
2107 FALSE, /* partial_inplace */
2108 0, /* src_mask */
2109 0, /* dst_mask */
2110 FALSE), /* pcrel_offset */
2111 };
2112
2113 \f
2114 /* Initialize the ppc64_elf_howto_table, so that linear accesses can
2115 be done. */
2116
2117 static void
2118 ppc_howto_init (void)
2119 {
2120 unsigned int i, type;
2121
2122 for (i = 0;
2123 i < sizeof (ppc64_elf_howto_raw) / sizeof (ppc64_elf_howto_raw[0]);
2124 i++)
2125 {
2126 type = ppc64_elf_howto_raw[i].type;
2127 BFD_ASSERT (type < (sizeof (ppc64_elf_howto_table)
2128 / sizeof (ppc64_elf_howto_table[0])));
2129 ppc64_elf_howto_table[type] = &ppc64_elf_howto_raw[i];
2130 }
2131 }
2132
2133 static reloc_howto_type *
2134 ppc64_elf_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2135 bfd_reloc_code_real_type code)
2136 {
2137 enum elf_ppc64_reloc_type r = R_PPC64_NONE;
2138
2139 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2140 /* Initialize howto table if needed. */
2141 ppc_howto_init ();
2142
2143 switch (code)
2144 {
2145 default:
2146 return NULL;
2147
2148 case BFD_RELOC_NONE: r = R_PPC64_NONE;
2149 break;
2150 case BFD_RELOC_32: r = R_PPC64_ADDR32;
2151 break;
2152 case BFD_RELOC_PPC_BA26: r = R_PPC64_ADDR24;
2153 break;
2154 case BFD_RELOC_16: r = R_PPC64_ADDR16;
2155 break;
2156 case BFD_RELOC_LO16: r = R_PPC64_ADDR16_LO;
2157 break;
2158 case BFD_RELOC_HI16: r = R_PPC64_ADDR16_HI;
2159 break;
2160 case BFD_RELOC_PPC64_ADDR16_HIGH: r = R_PPC64_ADDR16_HIGH;
2161 break;
2162 case BFD_RELOC_HI16_S: r = R_PPC64_ADDR16_HA;
2163 break;
2164 case BFD_RELOC_PPC64_ADDR16_HIGHA: r = R_PPC64_ADDR16_HIGHA;
2165 break;
2166 case BFD_RELOC_PPC_BA16: r = R_PPC64_ADDR14;
2167 break;
2168 case BFD_RELOC_PPC_BA16_BRTAKEN: r = R_PPC64_ADDR14_BRTAKEN;
2169 break;
2170 case BFD_RELOC_PPC_BA16_BRNTAKEN: r = R_PPC64_ADDR14_BRNTAKEN;
2171 break;
2172 case BFD_RELOC_PPC_B26: r = R_PPC64_REL24;
2173 break;
2174 case BFD_RELOC_PPC_B16: r = R_PPC64_REL14;
2175 break;
2176 case BFD_RELOC_PPC_B16_BRTAKEN: r = R_PPC64_REL14_BRTAKEN;
2177 break;
2178 case BFD_RELOC_PPC_B16_BRNTAKEN: r = R_PPC64_REL14_BRNTAKEN;
2179 break;
2180 case BFD_RELOC_16_GOTOFF: r = R_PPC64_GOT16;
2181 break;
2182 case BFD_RELOC_LO16_GOTOFF: r = R_PPC64_GOT16_LO;
2183 break;
2184 case BFD_RELOC_HI16_GOTOFF: r = R_PPC64_GOT16_HI;
2185 break;
2186 case BFD_RELOC_HI16_S_GOTOFF: r = R_PPC64_GOT16_HA;
2187 break;
2188 case BFD_RELOC_PPC_COPY: r = R_PPC64_COPY;
2189 break;
2190 case BFD_RELOC_PPC_GLOB_DAT: r = R_PPC64_GLOB_DAT;
2191 break;
2192 case BFD_RELOC_32_PCREL: r = R_PPC64_REL32;
2193 break;
2194 case BFD_RELOC_32_PLTOFF: r = R_PPC64_PLT32;
2195 break;
2196 case BFD_RELOC_32_PLT_PCREL: r = R_PPC64_PLTREL32;
2197 break;
2198 case BFD_RELOC_LO16_PLTOFF: r = R_PPC64_PLT16_LO;
2199 break;
2200 case BFD_RELOC_HI16_PLTOFF: r = R_PPC64_PLT16_HI;
2201 break;
2202 case BFD_RELOC_HI16_S_PLTOFF: r = R_PPC64_PLT16_HA;
2203 break;
2204 case BFD_RELOC_16_BASEREL: r = R_PPC64_SECTOFF;
2205 break;
2206 case BFD_RELOC_LO16_BASEREL: r = R_PPC64_SECTOFF_LO;
2207 break;
2208 case BFD_RELOC_HI16_BASEREL: r = R_PPC64_SECTOFF_HI;
2209 break;
2210 case BFD_RELOC_HI16_S_BASEREL: r = R_PPC64_SECTOFF_HA;
2211 break;
2212 case BFD_RELOC_CTOR: r = R_PPC64_ADDR64;
2213 break;
2214 case BFD_RELOC_64: r = R_PPC64_ADDR64;
2215 break;
2216 case BFD_RELOC_PPC64_HIGHER: r = R_PPC64_ADDR16_HIGHER;
2217 break;
2218 case BFD_RELOC_PPC64_HIGHER_S: r = R_PPC64_ADDR16_HIGHERA;
2219 break;
2220 case BFD_RELOC_PPC64_HIGHEST: r = R_PPC64_ADDR16_HIGHEST;
2221 break;
2222 case BFD_RELOC_PPC64_HIGHEST_S: r = R_PPC64_ADDR16_HIGHESTA;
2223 break;
2224 case BFD_RELOC_64_PCREL: r = R_PPC64_REL64;
2225 break;
2226 case BFD_RELOC_64_PLTOFF: r = R_PPC64_PLT64;
2227 break;
2228 case BFD_RELOC_64_PLT_PCREL: r = R_PPC64_PLTREL64;
2229 break;
2230 case BFD_RELOC_PPC_TOC16: r = R_PPC64_TOC16;
2231 break;
2232 case BFD_RELOC_PPC64_TOC16_LO: r = R_PPC64_TOC16_LO;
2233 break;
2234 case BFD_RELOC_PPC64_TOC16_HI: r = R_PPC64_TOC16_HI;
2235 break;
2236 case BFD_RELOC_PPC64_TOC16_HA: r = R_PPC64_TOC16_HA;
2237 break;
2238 case BFD_RELOC_PPC64_TOC: r = R_PPC64_TOC;
2239 break;
2240 case BFD_RELOC_PPC64_PLTGOT16: r = R_PPC64_PLTGOT16;
2241 break;
2242 case BFD_RELOC_PPC64_PLTGOT16_LO: r = R_PPC64_PLTGOT16_LO;
2243 break;
2244 case BFD_RELOC_PPC64_PLTGOT16_HI: r = R_PPC64_PLTGOT16_HI;
2245 break;
2246 case BFD_RELOC_PPC64_PLTGOT16_HA: r = R_PPC64_PLTGOT16_HA;
2247 break;
2248 case BFD_RELOC_PPC64_ADDR16_DS: r = R_PPC64_ADDR16_DS;
2249 break;
2250 case BFD_RELOC_PPC64_ADDR16_LO_DS: r = R_PPC64_ADDR16_LO_DS;
2251 break;
2252 case BFD_RELOC_PPC64_GOT16_DS: r = R_PPC64_GOT16_DS;
2253 break;
2254 case BFD_RELOC_PPC64_GOT16_LO_DS: r = R_PPC64_GOT16_LO_DS;
2255 break;
2256 case BFD_RELOC_PPC64_PLT16_LO_DS: r = R_PPC64_PLT16_LO_DS;
2257 break;
2258 case BFD_RELOC_PPC64_SECTOFF_DS: r = R_PPC64_SECTOFF_DS;
2259 break;
2260 case BFD_RELOC_PPC64_SECTOFF_LO_DS: r = R_PPC64_SECTOFF_LO_DS;
2261 break;
2262 case BFD_RELOC_PPC64_TOC16_DS: r = R_PPC64_TOC16_DS;
2263 break;
2264 case BFD_RELOC_PPC64_TOC16_LO_DS: r = R_PPC64_TOC16_LO_DS;
2265 break;
2266 case BFD_RELOC_PPC64_PLTGOT16_DS: r = R_PPC64_PLTGOT16_DS;
2267 break;
2268 case BFD_RELOC_PPC64_PLTGOT16_LO_DS: r = R_PPC64_PLTGOT16_LO_DS;
2269 break;
2270 case BFD_RELOC_PPC_TLS: r = R_PPC64_TLS;
2271 break;
2272 case BFD_RELOC_PPC_TLSGD: r = R_PPC64_TLSGD;
2273 break;
2274 case BFD_RELOC_PPC_TLSLD: r = R_PPC64_TLSLD;
2275 break;
2276 case BFD_RELOC_PPC_DTPMOD: r = R_PPC64_DTPMOD64;
2277 break;
2278 case BFD_RELOC_PPC_TPREL16: r = R_PPC64_TPREL16;
2279 break;
2280 case BFD_RELOC_PPC_TPREL16_LO: r = R_PPC64_TPREL16_LO;
2281 break;
2282 case BFD_RELOC_PPC_TPREL16_HI: r = R_PPC64_TPREL16_HI;
2283 break;
2284 case BFD_RELOC_PPC64_TPREL16_HIGH: r = R_PPC64_TPREL16_HIGH;
2285 break;
2286 case BFD_RELOC_PPC_TPREL16_HA: r = R_PPC64_TPREL16_HA;
2287 break;
2288 case BFD_RELOC_PPC64_TPREL16_HIGHA: r = R_PPC64_TPREL16_HIGHA;
2289 break;
2290 case BFD_RELOC_PPC_TPREL: r = R_PPC64_TPREL64;
2291 break;
2292 case BFD_RELOC_PPC_DTPREL16: r = R_PPC64_DTPREL16;
2293 break;
2294 case BFD_RELOC_PPC_DTPREL16_LO: r = R_PPC64_DTPREL16_LO;
2295 break;
2296 case BFD_RELOC_PPC_DTPREL16_HI: r = R_PPC64_DTPREL16_HI;
2297 break;
2298 case BFD_RELOC_PPC64_DTPREL16_HIGH: r = R_PPC64_DTPREL16_HIGH;
2299 break;
2300 case BFD_RELOC_PPC_DTPREL16_HA: r = R_PPC64_DTPREL16_HA;
2301 break;
2302 case BFD_RELOC_PPC64_DTPREL16_HIGHA: r = R_PPC64_DTPREL16_HIGHA;
2303 break;
2304 case BFD_RELOC_PPC_DTPREL: r = R_PPC64_DTPREL64;
2305 break;
2306 case BFD_RELOC_PPC_GOT_TLSGD16: r = R_PPC64_GOT_TLSGD16;
2307 break;
2308 case BFD_RELOC_PPC_GOT_TLSGD16_LO: r = R_PPC64_GOT_TLSGD16_LO;
2309 break;
2310 case BFD_RELOC_PPC_GOT_TLSGD16_HI: r = R_PPC64_GOT_TLSGD16_HI;
2311 break;
2312 case BFD_RELOC_PPC_GOT_TLSGD16_HA: r = R_PPC64_GOT_TLSGD16_HA;
2313 break;
2314 case BFD_RELOC_PPC_GOT_TLSLD16: r = R_PPC64_GOT_TLSLD16;
2315 break;
2316 case BFD_RELOC_PPC_GOT_TLSLD16_LO: r = R_PPC64_GOT_TLSLD16_LO;
2317 break;
2318 case BFD_RELOC_PPC_GOT_TLSLD16_HI: r = R_PPC64_GOT_TLSLD16_HI;
2319 break;
2320 case BFD_RELOC_PPC_GOT_TLSLD16_HA: r = R_PPC64_GOT_TLSLD16_HA;
2321 break;
2322 case BFD_RELOC_PPC_GOT_TPREL16: r = R_PPC64_GOT_TPREL16_DS;
2323 break;
2324 case BFD_RELOC_PPC_GOT_TPREL16_LO: r = R_PPC64_GOT_TPREL16_LO_DS;
2325 break;
2326 case BFD_RELOC_PPC_GOT_TPREL16_HI: r = R_PPC64_GOT_TPREL16_HI;
2327 break;
2328 case BFD_RELOC_PPC_GOT_TPREL16_HA: r = R_PPC64_GOT_TPREL16_HA;
2329 break;
2330 case BFD_RELOC_PPC_GOT_DTPREL16: r = R_PPC64_GOT_DTPREL16_DS;
2331 break;
2332 case BFD_RELOC_PPC_GOT_DTPREL16_LO: r = R_PPC64_GOT_DTPREL16_LO_DS;
2333 break;
2334 case BFD_RELOC_PPC_GOT_DTPREL16_HI: r = R_PPC64_GOT_DTPREL16_HI;
2335 break;
2336 case BFD_RELOC_PPC_GOT_DTPREL16_HA: r = R_PPC64_GOT_DTPREL16_HA;
2337 break;
2338 case BFD_RELOC_PPC64_TPREL16_DS: r = R_PPC64_TPREL16_DS;
2339 break;
2340 case BFD_RELOC_PPC64_TPREL16_LO_DS: r = R_PPC64_TPREL16_LO_DS;
2341 break;
2342 case BFD_RELOC_PPC64_TPREL16_HIGHER: r = R_PPC64_TPREL16_HIGHER;
2343 break;
2344 case BFD_RELOC_PPC64_TPREL16_HIGHERA: r = R_PPC64_TPREL16_HIGHERA;
2345 break;
2346 case BFD_RELOC_PPC64_TPREL16_HIGHEST: r = R_PPC64_TPREL16_HIGHEST;
2347 break;
2348 case BFD_RELOC_PPC64_TPREL16_HIGHESTA: r = R_PPC64_TPREL16_HIGHESTA;
2349 break;
2350 case BFD_RELOC_PPC64_DTPREL16_DS: r = R_PPC64_DTPREL16_DS;
2351 break;
2352 case BFD_RELOC_PPC64_DTPREL16_LO_DS: r = R_PPC64_DTPREL16_LO_DS;
2353 break;
2354 case BFD_RELOC_PPC64_DTPREL16_HIGHER: r = R_PPC64_DTPREL16_HIGHER;
2355 break;
2356 case BFD_RELOC_PPC64_DTPREL16_HIGHERA: r = R_PPC64_DTPREL16_HIGHERA;
2357 break;
2358 case BFD_RELOC_PPC64_DTPREL16_HIGHEST: r = R_PPC64_DTPREL16_HIGHEST;
2359 break;
2360 case BFD_RELOC_PPC64_DTPREL16_HIGHESTA: r = R_PPC64_DTPREL16_HIGHESTA;
2361 break;
2362 case BFD_RELOC_16_PCREL: r = R_PPC64_REL16;
2363 break;
2364 case BFD_RELOC_LO16_PCREL: r = R_PPC64_REL16_LO;
2365 break;
2366 case BFD_RELOC_HI16_PCREL: r = R_PPC64_REL16_HI;
2367 break;
2368 case BFD_RELOC_HI16_S_PCREL: r = R_PPC64_REL16_HA;
2369 break;
2370 case BFD_RELOC_VTABLE_INHERIT: r = R_PPC64_GNU_VTINHERIT;
2371 break;
2372 case BFD_RELOC_VTABLE_ENTRY: r = R_PPC64_GNU_VTENTRY;
2373 break;
2374 }
2375
2376 return ppc64_elf_howto_table[r];
2377 };
2378
2379 static reloc_howto_type *
2380 ppc64_elf_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2381 const char *r_name)
2382 {
2383 unsigned int i;
2384
2385 for (i = 0;
2386 i < sizeof (ppc64_elf_howto_raw) / sizeof (ppc64_elf_howto_raw[0]);
2387 i++)
2388 if (ppc64_elf_howto_raw[i].name != NULL
2389 && strcasecmp (ppc64_elf_howto_raw[i].name, r_name) == 0)
2390 return &ppc64_elf_howto_raw[i];
2391
2392 return NULL;
2393 }
2394
2395 /* Set the howto pointer for a PowerPC ELF reloc. */
2396
2397 static void
2398 ppc64_elf_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr,
2399 Elf_Internal_Rela *dst)
2400 {
2401 unsigned int type;
2402
2403 /* Initialize howto table if needed. */
2404 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2405 ppc_howto_init ();
2406
2407 type = ELF64_R_TYPE (dst->r_info);
2408 if (type >= (sizeof (ppc64_elf_howto_table)
2409 / sizeof (ppc64_elf_howto_table[0])))
2410 {
2411 (*_bfd_error_handler) (_("%B: invalid relocation type %d"),
2412 abfd, (int) type);
2413 type = R_PPC64_NONE;
2414 }
2415 cache_ptr->howto = ppc64_elf_howto_table[type];
2416 }
2417
2418 /* Handle the R_PPC64_ADDR16_HA and similar relocs. */
2419
2420 static bfd_reloc_status_type
2421 ppc64_elf_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2422 void *data, asection *input_section,
2423 bfd *output_bfd, char **error_message)
2424 {
2425 /* If this is a relocatable link (output_bfd test tells us), just
2426 call the generic function. Any adjustment will be done at final
2427 link time. */
2428 if (output_bfd != NULL)
2429 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2430 input_section, output_bfd, error_message);
2431
2432 /* Adjust the addend for sign extension of the low 16 bits.
2433 We won't actually be using the low 16 bits, so trashing them
2434 doesn't matter. */
2435 reloc_entry->addend += 0x8000;
2436 return bfd_reloc_continue;
2437 }
2438
2439 static bfd_reloc_status_type
2440 ppc64_elf_branch_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2441 void *data, asection *input_section,
2442 bfd *output_bfd, char **error_message)
2443 {
2444 if (output_bfd != NULL)
2445 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2446 input_section, output_bfd, error_message);
2447
2448 if (strcmp (symbol->section->name, ".opd") == 0
2449 && (symbol->section->owner->flags & DYNAMIC) == 0)
2450 {
2451 bfd_vma dest = opd_entry_value (symbol->section,
2452 symbol->value + reloc_entry->addend,
2453 NULL, NULL, FALSE);
2454 if (dest != (bfd_vma) -1)
2455 reloc_entry->addend = dest - (symbol->value
2456 + symbol->section->output_section->vma
2457 + symbol->section->output_offset);
2458 }
2459 return bfd_reloc_continue;
2460 }
2461
2462 static bfd_reloc_status_type
2463 ppc64_elf_brtaken_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2464 void *data, asection *input_section,
2465 bfd *output_bfd, char **error_message)
2466 {
2467 long insn;
2468 enum elf_ppc64_reloc_type r_type;
2469 bfd_size_type octets;
2470 /* Assume 'at' branch hints. */
2471 bfd_boolean is_isa_v2 = TRUE;
2472
2473 /* If this is a relocatable link (output_bfd test tells us), just
2474 call the generic function. Any adjustment will be done at final
2475 link time. */
2476 if (output_bfd != NULL)
2477 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2478 input_section, output_bfd, error_message);
2479
2480 octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2481 insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
2482 insn &= ~(0x01 << 21);
2483 r_type = reloc_entry->howto->type;
2484 if (r_type == R_PPC64_ADDR14_BRTAKEN
2485 || r_type == R_PPC64_REL14_BRTAKEN)
2486 insn |= 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field. */
2487
2488 if (is_isa_v2)
2489 {
2490 /* Set 'a' bit. This is 0b00010 in BO field for branch
2491 on CR(BI) insns (BO == 001at or 011at), and 0b01000
2492 for branch on CTR insns (BO == 1a00t or 1a01t). */
2493 if ((insn & (0x14 << 21)) == (0x04 << 21))
2494 insn |= 0x02 << 21;
2495 else if ((insn & (0x14 << 21)) == (0x10 << 21))
2496 insn |= 0x08 << 21;
2497 else
2498 goto out;
2499 }
2500 else
2501 {
2502 bfd_vma target = 0;
2503 bfd_vma from;
2504
2505 if (!bfd_is_com_section (symbol->section))
2506 target = symbol->value;
2507 target += symbol->section->output_section->vma;
2508 target += symbol->section->output_offset;
2509 target += reloc_entry->addend;
2510
2511 from = (reloc_entry->address
2512 + input_section->output_offset
2513 + input_section->output_section->vma);
2514
2515 /* Invert 'y' bit if not the default. */
2516 if ((bfd_signed_vma) (target - from) < 0)
2517 insn ^= 0x01 << 21;
2518 }
2519 bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
2520 out:
2521 return ppc64_elf_branch_reloc (abfd, reloc_entry, symbol, data,
2522 input_section, output_bfd, error_message);
2523 }
2524
2525 static bfd_reloc_status_type
2526 ppc64_elf_sectoff_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2527 void *data, asection *input_section,
2528 bfd *output_bfd, char **error_message)
2529 {
2530 /* If this is a relocatable link (output_bfd test tells us), just
2531 call the generic function. Any adjustment will be done at final
2532 link time. */
2533 if (output_bfd != NULL)
2534 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2535 input_section, output_bfd, error_message);
2536
2537 /* Subtract the symbol section base address. */
2538 reloc_entry->addend -= symbol->section->output_section->vma;
2539 return bfd_reloc_continue;
2540 }
2541
2542 static bfd_reloc_status_type
2543 ppc64_elf_sectoff_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2544 void *data, asection *input_section,
2545 bfd *output_bfd, char **error_message)
2546 {
2547 /* If this is a relocatable link (output_bfd test tells us), just
2548 call the generic function. Any adjustment will be done at final
2549 link time. */
2550 if (output_bfd != NULL)
2551 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2552 input_section, output_bfd, error_message);
2553
2554 /* Subtract the symbol section base address. */
2555 reloc_entry->addend -= symbol->section->output_section->vma;
2556
2557 /* Adjust the addend for sign extension of the low 16 bits. */
2558 reloc_entry->addend += 0x8000;
2559 return bfd_reloc_continue;
2560 }
2561
2562 static bfd_reloc_status_type
2563 ppc64_elf_toc_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2564 void *data, asection *input_section,
2565 bfd *output_bfd, char **error_message)
2566 {
2567 bfd_vma TOCstart;
2568
2569 /* If this is a relocatable link (output_bfd test tells us), just
2570 call the generic function. Any adjustment will be done at final
2571 link time. */
2572 if (output_bfd != NULL)
2573 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2574 input_section, output_bfd, error_message);
2575
2576 TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2577 if (TOCstart == 0)
2578 TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2579
2580 /* Subtract the TOC base address. */
2581 reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2582 return bfd_reloc_continue;
2583 }
2584
2585 static bfd_reloc_status_type
2586 ppc64_elf_toc_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2587 void *data, asection *input_section,
2588 bfd *output_bfd, char **error_message)
2589 {
2590 bfd_vma TOCstart;
2591
2592 /* If this is a relocatable link (output_bfd test tells us), just
2593 call the generic function. Any adjustment will be done at final
2594 link time. */
2595 if (output_bfd != NULL)
2596 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2597 input_section, output_bfd, error_message);
2598
2599 TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2600 if (TOCstart == 0)
2601 TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2602
2603 /* Subtract the TOC base address. */
2604 reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2605
2606 /* Adjust the addend for sign extension of the low 16 bits. */
2607 reloc_entry->addend += 0x8000;
2608 return bfd_reloc_continue;
2609 }
2610
2611 static bfd_reloc_status_type
2612 ppc64_elf_toc64_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2613 void *data, asection *input_section,
2614 bfd *output_bfd, char **error_message)
2615 {
2616 bfd_vma TOCstart;
2617 bfd_size_type octets;
2618
2619 /* If this is a relocatable link (output_bfd test tells us), just
2620 call the generic function. Any adjustment will be done at final
2621 link time. */
2622 if (output_bfd != NULL)
2623 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2624 input_section, output_bfd, error_message);
2625
2626 TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2627 if (TOCstart == 0)
2628 TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2629
2630 octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2631 bfd_put_64 (abfd, TOCstart + TOC_BASE_OFF, (bfd_byte *) data + octets);
2632 return bfd_reloc_ok;
2633 }
2634
2635 static bfd_reloc_status_type
2636 ppc64_elf_unhandled_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2637 void *data, asection *input_section,
2638 bfd *output_bfd, char **error_message)
2639 {
2640 /* If this is a relocatable link (output_bfd test tells us), just
2641 call the generic function. Any adjustment will be done at final
2642 link time. */
2643 if (output_bfd != NULL)
2644 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2645 input_section, output_bfd, error_message);
2646
2647 if (error_message != NULL)
2648 {
2649 static char buf[60];
2650 sprintf (buf, "generic linker can't handle %s",
2651 reloc_entry->howto->name);
2652 *error_message = buf;
2653 }
2654 return bfd_reloc_dangerous;
2655 }
2656
2657 /* Track GOT entries needed for a given symbol. We might need more
2658 than one got entry per symbol. */
2659 struct got_entry
2660 {
2661 struct got_entry *next;
2662
2663 /* The symbol addend that we'll be placing in the GOT. */
2664 bfd_vma addend;
2665
2666 /* Unlike other ELF targets, we use separate GOT entries for the same
2667 symbol referenced from different input files. This is to support
2668 automatic multiple TOC/GOT sections, where the TOC base can vary
2669 from one input file to another. After partitioning into TOC groups
2670 we merge entries within the group.
2671
2672 Point to the BFD owning this GOT entry. */
2673 bfd *owner;
2674
2675 /* Zero for non-tls entries, or TLS_TLS and one of TLS_GD, TLS_LD,
2676 TLS_TPREL or TLS_DTPREL for tls entries. */
2677 unsigned char tls_type;
2678
2679 /* Non-zero if got.ent points to real entry. */
2680 unsigned char is_indirect;
2681
2682 /* Reference count until size_dynamic_sections, GOT offset thereafter. */
2683 union
2684 {
2685 bfd_signed_vma refcount;
2686 bfd_vma offset;
2687 struct got_entry *ent;
2688 } got;
2689 };
2690
2691 /* The same for PLT. */
2692 struct plt_entry
2693 {
2694 struct plt_entry *next;
2695
2696 bfd_vma addend;
2697
2698 union
2699 {
2700 bfd_signed_vma refcount;
2701 bfd_vma offset;
2702 } plt;
2703 };
2704
2705 struct ppc64_elf_obj_tdata
2706 {
2707 struct elf_obj_tdata elf;
2708
2709 /* Shortcuts to dynamic linker sections. */
2710 asection *got;
2711 asection *relgot;
2712
2713 /* Used during garbage collection. We attach global symbols defined
2714 on removed .opd entries to this section so that the sym is removed. */
2715 asection *deleted_section;
2716
2717 /* TLS local dynamic got entry handling. Support for multiple GOT
2718 sections means we potentially need one of these for each input bfd. */
2719 struct got_entry tlsld_got;
2720
2721 union {
2722 /* A copy of relocs before they are modified for --emit-relocs. */
2723 Elf_Internal_Rela *relocs;
2724
2725 /* Section contents. */
2726 bfd_byte *contents;
2727 } opd;
2728
2729 /* Nonzero if this bfd has small toc/got relocs, ie. that expect
2730 the reloc to be in the range -32768 to 32767. */
2731 unsigned int has_small_toc_reloc : 1;
2732
2733 /* Set if toc/got ha relocs detected not using r2, or lo reloc
2734 instruction not one we handle. */
2735 unsigned int unexpected_toc_insn : 1;
2736 };
2737
2738 #define ppc64_elf_tdata(bfd) \
2739 ((struct ppc64_elf_obj_tdata *) (bfd)->tdata.any)
2740
2741 #define ppc64_tlsld_got(bfd) \
2742 (&ppc64_elf_tdata (bfd)->tlsld_got)
2743
2744 #define is_ppc64_elf(bfd) \
2745 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
2746 && elf_object_id (bfd) == PPC64_ELF_DATA)
2747
2748 /* Override the generic function because we store some extras. */
2749
2750 static bfd_boolean
2751 ppc64_elf_mkobject (bfd *abfd)
2752 {
2753 return bfd_elf_allocate_object (abfd, sizeof (struct ppc64_elf_obj_tdata),
2754 PPC64_ELF_DATA);
2755 }
2756
2757 /* Fix bad default arch selected for a 64 bit input bfd when the
2758 default is 32 bit. */
2759
2760 static bfd_boolean
2761 ppc64_elf_object_p (bfd *abfd)
2762 {
2763 if (abfd->arch_info->the_default && abfd->arch_info->bits_per_word == 32)
2764 {
2765 Elf_Internal_Ehdr *i_ehdr = elf_elfheader (abfd);
2766
2767 if (i_ehdr->e_ident[EI_CLASS] == ELFCLASS64)
2768 {
2769 /* Relies on arch after 32 bit default being 64 bit default. */
2770 abfd->arch_info = abfd->arch_info->next;
2771 BFD_ASSERT (abfd->arch_info->bits_per_word == 64);
2772 }
2773 }
2774 return TRUE;
2775 }
2776
2777 /* Support for core dump NOTE sections. */
2778
2779 static bfd_boolean
2780 ppc64_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
2781 {
2782 size_t offset, size;
2783
2784 if (note->descsz != 504)
2785 return FALSE;
2786
2787 /* pr_cursig */
2788 elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
2789
2790 /* pr_pid */
2791 elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 32);
2792
2793 /* pr_reg */
2794 offset = 112;
2795 size = 384;
2796
2797 /* Make a ".reg/999" section. */
2798 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
2799 size, note->descpos + offset);
2800 }
2801
2802 static bfd_boolean
2803 ppc64_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
2804 {
2805 if (note->descsz != 136)
2806 return FALSE;
2807
2808 elf_tdata (abfd)->core->pid
2809 = bfd_get_32 (abfd, note->descdata + 24);
2810 elf_tdata (abfd)->core->program
2811 = _bfd_elfcore_strndup (abfd, note->descdata + 40, 16);
2812 elf_tdata (abfd)->core->command
2813 = _bfd_elfcore_strndup (abfd, note->descdata + 56, 80);
2814
2815 return TRUE;
2816 }
2817
2818 static char *
2819 ppc64_elf_write_core_note (bfd *abfd, char *buf, int *bufsiz, int note_type,
2820 ...)
2821 {
2822 switch (note_type)
2823 {
2824 default:
2825 return NULL;
2826
2827 case NT_PRPSINFO:
2828 {
2829 char data[136];
2830 va_list ap;
2831
2832 va_start (ap, note_type);
2833 memset (data, 0, sizeof (data));
2834 strncpy (data + 40, va_arg (ap, const char *), 16);
2835 strncpy (data + 56, va_arg (ap, const char *), 80);
2836 va_end (ap);
2837 return elfcore_write_note (abfd, buf, bufsiz,
2838 "CORE", note_type, data, sizeof (data));
2839 }
2840
2841 case NT_PRSTATUS:
2842 {
2843 char data[504];
2844 va_list ap;
2845 long pid;
2846 int cursig;
2847 const void *greg;
2848
2849 va_start (ap, note_type);
2850 memset (data, 0, 112);
2851 pid = va_arg (ap, long);
2852 bfd_put_32 (abfd, pid, data + 32);
2853 cursig = va_arg (ap, int);
2854 bfd_put_16 (abfd, cursig, data + 12);
2855 greg = va_arg (ap, const void *);
2856 memcpy (data + 112, greg, 384);
2857 memset (data + 496, 0, 8);
2858 va_end (ap);
2859 return elfcore_write_note (abfd, buf, bufsiz,
2860 "CORE", note_type, data, sizeof (data));
2861 }
2862 }
2863 }
2864
2865 /* Add extra PPC sections. */
2866
2867 static const struct bfd_elf_special_section ppc64_elf_special_sections[]=
2868 {
2869 { STRING_COMMA_LEN (".plt"), 0, SHT_NOBITS, 0 },
2870 { STRING_COMMA_LEN (".sbss"), -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE },
2871 { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2872 { STRING_COMMA_LEN (".toc"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2873 { STRING_COMMA_LEN (".toc1"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2874 { STRING_COMMA_LEN (".tocbss"), 0, SHT_NOBITS, SHF_ALLOC + SHF_WRITE },
2875 { NULL, 0, 0, 0, 0 }
2876 };
2877
2878 enum _ppc64_sec_type {
2879 sec_normal = 0,
2880 sec_opd = 1,
2881 sec_toc = 2
2882 };
2883
2884 struct _ppc64_elf_section_data
2885 {
2886 struct bfd_elf_section_data elf;
2887
2888 union
2889 {
2890 /* An array with one entry for each opd function descriptor. */
2891 struct _opd_sec_data
2892 {
2893 /* Points to the function code section for local opd entries. */
2894 asection **func_sec;
2895
2896 /* After editing .opd, adjust references to opd local syms. */
2897 long *adjust;
2898 } opd;
2899
2900 /* An array for toc sections, indexed by offset/8. */
2901 struct _toc_sec_data
2902 {
2903 /* Specifies the relocation symbol index used at a given toc offset. */
2904 unsigned *symndx;
2905
2906 /* And the relocation addend. */
2907 bfd_vma *add;
2908 } toc;
2909 } u;
2910
2911 enum _ppc64_sec_type sec_type:2;
2912
2913 /* Flag set when small branches are detected. Used to
2914 select suitable defaults for the stub group size. */
2915 unsigned int has_14bit_branch:1;
2916 };
2917
2918 #define ppc64_elf_section_data(sec) \
2919 ((struct _ppc64_elf_section_data *) elf_section_data (sec))
2920
2921 static bfd_boolean
2922 ppc64_elf_new_section_hook (bfd *abfd, asection *sec)
2923 {
2924 if (!sec->used_by_bfd)
2925 {
2926 struct _ppc64_elf_section_data *sdata;
2927 bfd_size_type amt = sizeof (*sdata);
2928
2929 sdata = bfd_zalloc (abfd, amt);
2930 if (sdata == NULL)
2931 return FALSE;
2932 sec->used_by_bfd = sdata;
2933 }
2934
2935 return _bfd_elf_new_section_hook (abfd, sec);
2936 }
2937
2938 static struct _opd_sec_data *
2939 get_opd_info (asection * sec)
2940 {
2941 if (sec != NULL
2942 && ppc64_elf_section_data (sec) != NULL
2943 && ppc64_elf_section_data (sec)->sec_type == sec_opd)
2944 return &ppc64_elf_section_data (sec)->u.opd;
2945 return NULL;
2946 }
2947
2948 static inline int
2949 abiversion (bfd *abfd)
2950 {
2951 return elf_elfheader (abfd)->e_flags & EF_PPC64_ABI;
2952 }
2953
2954 static inline void
2955 set_abiversion (bfd *abfd, int ver)
2956 {
2957 elf_elfheader (abfd)->e_flags &= ~EF_PPC64_ABI;
2958 elf_elfheader (abfd)->e_flags |= ver & EF_PPC64_ABI;
2959 }
2960 \f
2961 /* Parameters for the qsort hook. */
2962 static bfd_boolean synthetic_relocatable;
2963
2964 /* qsort comparison function for ppc64_elf_get_synthetic_symtab. */
2965
2966 static int
2967 compare_symbols (const void *ap, const void *bp)
2968 {
2969 const asymbol *a = * (const asymbol **) ap;
2970 const asymbol *b = * (const asymbol **) bp;
2971
2972 /* Section symbols first. */
2973 if ((a->flags & BSF_SECTION_SYM) && !(b->flags & BSF_SECTION_SYM))
2974 return -1;
2975 if (!(a->flags & BSF_SECTION_SYM) && (b->flags & BSF_SECTION_SYM))
2976 return 1;
2977
2978 /* then .opd symbols. */
2979 if (strcmp (a->section->name, ".opd") == 0
2980 && strcmp (b->section->name, ".opd") != 0)
2981 return -1;
2982 if (strcmp (a->section->name, ".opd") != 0
2983 && strcmp (b->section->name, ".opd") == 0)
2984 return 1;
2985
2986 /* then other code symbols. */
2987 if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
2988 == (SEC_CODE | SEC_ALLOC)
2989 && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
2990 != (SEC_CODE | SEC_ALLOC))
2991 return -1;
2992
2993 if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
2994 != (SEC_CODE | SEC_ALLOC)
2995 && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
2996 == (SEC_CODE | SEC_ALLOC))
2997 return 1;
2998
2999 if (synthetic_relocatable)
3000 {
3001 if (a->section->id < b->section->id)
3002 return -1;
3003
3004 if (a->section->id > b->section->id)
3005 return 1;
3006 }
3007
3008 if (a->value + a->section->vma < b->value + b->section->vma)
3009 return -1;
3010
3011 if (a->value + a->section->vma > b->value + b->section->vma)
3012 return 1;
3013
3014 /* For syms with the same value, prefer strong dynamic global function
3015 syms over other syms. */
3016 if ((a->flags & BSF_GLOBAL) != 0 && (b->flags & BSF_GLOBAL) == 0)
3017 return -1;
3018
3019 if ((a->flags & BSF_GLOBAL) == 0 && (b->flags & BSF_GLOBAL) != 0)
3020 return 1;
3021
3022 if ((a->flags & BSF_FUNCTION) != 0 && (b->flags & BSF_FUNCTION) == 0)
3023 return -1;
3024
3025 if ((a->flags & BSF_FUNCTION) == 0 && (b->flags & BSF_FUNCTION) != 0)
3026 return 1;
3027
3028 if ((a->flags & BSF_WEAK) == 0 && (b->flags & BSF_WEAK) != 0)
3029 return -1;
3030
3031 if ((a->flags & BSF_WEAK) != 0 && (b->flags & BSF_WEAK) == 0)
3032 return 1;
3033
3034 if ((a->flags & BSF_DYNAMIC) != 0 && (b->flags & BSF_DYNAMIC) == 0)
3035 return -1;
3036
3037 if ((a->flags & BSF_DYNAMIC) == 0 && (b->flags & BSF_DYNAMIC) != 0)
3038 return 1;
3039
3040 return 0;
3041 }
3042
3043 /* Search SYMS for a symbol of the given VALUE. */
3044
3045 static asymbol *
3046 sym_exists_at (asymbol **syms, long lo, long hi, int id, bfd_vma value)
3047 {
3048 long mid;
3049
3050 if (id == -1)
3051 {
3052 while (lo < hi)
3053 {
3054 mid = (lo + hi) >> 1;
3055 if (syms[mid]->value + syms[mid]->section->vma < value)
3056 lo = mid + 1;
3057 else if (syms[mid]->value + syms[mid]->section->vma > value)
3058 hi = mid;
3059 else
3060 return syms[mid];
3061 }
3062 }
3063 else
3064 {
3065 while (lo < hi)
3066 {
3067 mid = (lo + hi) >> 1;
3068 if (syms[mid]->section->id < id)
3069 lo = mid + 1;
3070 else if (syms[mid]->section->id > id)
3071 hi = mid;
3072 else if (syms[mid]->value < value)
3073 lo = mid + 1;
3074 else if (syms[mid]->value > value)
3075 hi = mid;
3076 else
3077 return syms[mid];
3078 }
3079 }
3080 return NULL;
3081 }
3082
3083 static bfd_boolean
3084 section_covers_vma (bfd *abfd ATTRIBUTE_UNUSED, asection *section, void *ptr)
3085 {
3086 bfd_vma vma = *(bfd_vma *) ptr;
3087 return ((section->flags & SEC_ALLOC) != 0
3088 && section->vma <= vma
3089 && vma < section->vma + section->size);
3090 }
3091
3092 /* Create synthetic symbols, effectively restoring "dot-symbol" function
3093 entry syms. Also generate @plt symbols for the glink branch table. */
3094
3095 static long
3096 ppc64_elf_get_synthetic_symtab (bfd *abfd,
3097 long static_count, asymbol **static_syms,
3098 long dyn_count, asymbol **dyn_syms,
3099 asymbol **ret)
3100 {
3101 asymbol *s;
3102 long i;
3103 long count;
3104 char *names;
3105 long symcount, codesecsym, codesecsymend, secsymend, opdsymend;
3106 asection *opd = NULL;
3107 bfd_boolean relocatable = (abfd->flags & (EXEC_P | DYNAMIC)) == 0;
3108 asymbol **syms;
3109 int abi = abiversion (abfd);
3110
3111 *ret = NULL;
3112
3113 if (abi < 2)
3114 {
3115 opd = bfd_get_section_by_name (abfd, ".opd");
3116 if (opd == NULL && abi == 1)
3117 return 0;
3118 }
3119
3120 symcount = static_count;
3121 if (!relocatable)
3122 symcount += dyn_count;
3123 if (symcount == 0)
3124 return 0;
3125
3126 syms = bfd_malloc ((symcount + 1) * sizeof (*syms));
3127 if (syms == NULL)
3128 return -1;
3129
3130 if (!relocatable && static_count != 0 && dyn_count != 0)
3131 {
3132 /* Use both symbol tables. */
3133 memcpy (syms, static_syms, static_count * sizeof (*syms));
3134 memcpy (syms + static_count, dyn_syms, (dyn_count + 1) * sizeof (*syms));
3135 }
3136 else if (!relocatable && static_count == 0)
3137 memcpy (syms, dyn_syms, (symcount + 1) * sizeof (*syms));
3138 else
3139 memcpy (syms, static_syms, (symcount + 1) * sizeof (*syms));
3140
3141 synthetic_relocatable = relocatable;
3142 qsort (syms, symcount, sizeof (*syms), compare_symbols);
3143
3144 if (!relocatable && symcount > 1)
3145 {
3146 long j;
3147 /* Trim duplicate syms, since we may have merged the normal and
3148 dynamic symbols. Actually, we only care about syms that have
3149 different values, so trim any with the same value. */
3150 for (i = 1, j = 1; i < symcount; ++i)
3151 if (syms[i - 1]->value + syms[i - 1]->section->vma
3152 != syms[i]->value + syms[i]->section->vma)
3153 syms[j++] = syms[i];
3154 symcount = j;
3155 }
3156
3157 i = 0;
3158 if (strcmp (syms[i]->section->name, ".opd") == 0)
3159 ++i;
3160 codesecsym = i;
3161
3162 for (; i < symcount; ++i)
3163 if (((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3164 != (SEC_CODE | SEC_ALLOC))
3165 || (syms[i]->flags & BSF_SECTION_SYM) == 0)
3166 break;
3167 codesecsymend = i;
3168
3169 for (; i < symcount; ++i)
3170 if ((syms[i]->flags & BSF_SECTION_SYM) == 0)
3171 break;
3172 secsymend = i;
3173
3174 for (; i < symcount; ++i)
3175 if (strcmp (syms[i]->section->name, ".opd") != 0)
3176 break;
3177 opdsymend = i;
3178
3179 for (; i < symcount; ++i)
3180 if ((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3181 != (SEC_CODE | SEC_ALLOC))
3182 break;
3183 symcount = i;
3184
3185 count = 0;
3186
3187 if (relocatable)
3188 {
3189 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3190 arelent *r;
3191 size_t size;
3192 long relcount;
3193
3194 if (opdsymend == secsymend)
3195 goto done;
3196
3197 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3198 relcount = (opd->flags & SEC_RELOC) ? opd->reloc_count : 0;
3199 if (relcount == 0)
3200 goto done;
3201
3202 if (!(*slurp_relocs) (abfd, opd, static_syms, FALSE))
3203 {
3204 count = -1;
3205 goto done;
3206 }
3207
3208 size = 0;
3209 for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3210 {
3211 asymbol *sym;
3212
3213 while (r < opd->relocation + relcount
3214 && r->address < syms[i]->value + opd->vma)
3215 ++r;
3216
3217 if (r == opd->relocation + relcount)
3218 break;
3219
3220 if (r->address != syms[i]->value + opd->vma)
3221 continue;
3222
3223 if (r->howto->type != R_PPC64_ADDR64)
3224 continue;
3225
3226 sym = *r->sym_ptr_ptr;
3227 if (!sym_exists_at (syms, opdsymend, symcount,
3228 sym->section->id, sym->value + r->addend))
3229 {
3230 ++count;
3231 size += sizeof (asymbol);
3232 size += strlen (syms[i]->name) + 2;
3233 }
3234 }
3235
3236 s = *ret = bfd_malloc (size);
3237 if (s == NULL)
3238 {
3239 count = -1;
3240 goto done;
3241 }
3242
3243 names = (char *) (s + count);
3244
3245 for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3246 {
3247 asymbol *sym;
3248
3249 while (r < opd->relocation + relcount
3250 && r->address < syms[i]->value + opd->vma)
3251 ++r;
3252
3253 if (r == opd->relocation + relcount)
3254 break;
3255
3256 if (r->address != syms[i]->value + opd->vma)
3257 continue;
3258
3259 if (r->howto->type != R_PPC64_ADDR64)
3260 continue;
3261
3262 sym = *r->sym_ptr_ptr;
3263 if (!sym_exists_at (syms, opdsymend, symcount,
3264 sym->section->id, sym->value + r->addend))
3265 {
3266 size_t len;
3267
3268 *s = *syms[i];
3269 s->flags |= BSF_SYNTHETIC;
3270 s->section = sym->section;
3271 s->value = sym->value + r->addend;
3272 s->name = names;
3273 *names++ = '.';
3274 len = strlen (syms[i]->name);
3275 memcpy (names, syms[i]->name, len + 1);
3276 names += len + 1;
3277 /* Have udata.p point back to the original symbol this
3278 synthetic symbol was derived from. */
3279 s->udata.p = syms[i];
3280 s++;
3281 }
3282 }
3283 }
3284 else
3285 {
3286 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3287 bfd_byte *contents = NULL;
3288 size_t size;
3289 long plt_count = 0;
3290 bfd_vma glink_vma = 0, resolv_vma = 0;
3291 asection *dynamic, *glink = NULL, *relplt = NULL;
3292 arelent *p;
3293
3294 if (opd != NULL && !bfd_malloc_and_get_section (abfd, opd, &contents))
3295 {
3296 free_contents_and_exit:
3297 if (contents)
3298 free (contents);
3299 count = -1;
3300 goto done;
3301 }
3302
3303 size = 0;
3304 for (i = secsymend; i < opdsymend; ++i)
3305 {
3306 bfd_vma ent;
3307
3308 /* Ignore bogus symbols. */
3309 if (syms[i]->value > opd->size - 8)
3310 continue;
3311
3312 ent = bfd_get_64 (abfd, contents + syms[i]->value);
3313 if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3314 {
3315 ++count;
3316 size += sizeof (asymbol);
3317 size += strlen (syms[i]->name) + 2;
3318 }
3319 }
3320
3321 /* Get start of .glink stubs from DT_PPC64_GLINK. */
3322 if (dyn_count != 0
3323 && (dynamic = bfd_get_section_by_name (abfd, ".dynamic")) != NULL)
3324 {
3325 bfd_byte *dynbuf, *extdyn, *extdynend;
3326 size_t extdynsize;
3327 void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *);
3328
3329 if (!bfd_malloc_and_get_section (abfd, dynamic, &dynbuf))
3330 goto free_contents_and_exit;
3331
3332 extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
3333 swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
3334
3335 extdyn = dynbuf;
3336 extdynend = extdyn + dynamic->size;
3337 for (; extdyn < extdynend; extdyn += extdynsize)
3338 {
3339 Elf_Internal_Dyn dyn;
3340 (*swap_dyn_in) (abfd, extdyn, &dyn);
3341
3342 if (dyn.d_tag == DT_NULL)
3343 break;
3344
3345 if (dyn.d_tag == DT_PPC64_GLINK)
3346 {
3347 /* The first glink stub starts at offset 32; see comment in
3348 ppc64_elf_finish_dynamic_sections. */
3349 glink_vma = dyn.d_un.d_val + 32;
3350 /* The .glink section usually does not survive the final
3351 link; search for the section (usually .text) where the
3352 glink stubs now reside. */
3353 glink = bfd_sections_find_if (abfd, section_covers_vma,
3354 &glink_vma);
3355 break;
3356 }
3357 }
3358
3359 free (dynbuf);
3360 }
3361
3362 if (glink != NULL)
3363 {
3364 /* Determine __glink trampoline by reading the relative branch
3365 from the first glink stub. */
3366 bfd_byte buf[4];
3367 if (bfd_get_section_contents (abfd, glink, buf,
3368 glink_vma + 4 - glink->vma, 4))
3369 {
3370 unsigned int insn = bfd_get_32 (abfd, buf);
3371 insn ^= B_DOT;
3372 if ((insn & ~0x3fffffc) == 0)
3373 resolv_vma = glink_vma + 4 + (insn ^ 0x2000000) - 0x2000000;
3374 }
3375
3376 if (resolv_vma)
3377 size += sizeof (asymbol) + sizeof ("__glink_PLTresolve");
3378
3379 relplt = bfd_get_section_by_name (abfd, ".rela.plt");
3380 if (relplt != NULL)
3381 {
3382 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3383 if (! (*slurp_relocs) (abfd, relplt, dyn_syms, TRUE))
3384 goto free_contents_and_exit;
3385
3386 plt_count = relplt->size / sizeof (Elf64_External_Rela);
3387 size += plt_count * sizeof (asymbol);
3388
3389 p = relplt->relocation;
3390 for (i = 0; i < plt_count; i++, p++)
3391 {
3392 size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
3393 if (p->addend != 0)
3394 size += sizeof ("+0x") - 1 + 16;
3395 }
3396 }
3397 }
3398
3399 s = *ret = bfd_malloc (size);
3400 if (s == NULL)
3401 goto free_contents_and_exit;
3402
3403 names = (char *) (s + count + plt_count + (resolv_vma != 0));
3404
3405 for (i = secsymend; i < opdsymend; ++i)
3406 {
3407 bfd_vma ent;
3408
3409 if (syms[i]->value > opd->size - 8)
3410 continue;
3411
3412 ent = bfd_get_64 (abfd, contents + syms[i]->value);
3413 if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3414 {
3415 long lo, hi;
3416 size_t len;
3417 asection *sec = abfd->sections;
3418
3419 *s = *syms[i];
3420 lo = codesecsym;
3421 hi = codesecsymend;
3422 while (lo < hi)
3423 {
3424 long mid = (lo + hi) >> 1;
3425 if (syms[mid]->section->vma < ent)
3426 lo = mid + 1;
3427 else if (syms[mid]->section->vma > ent)
3428 hi = mid;
3429 else
3430 {
3431 sec = syms[mid]->section;
3432 break;
3433 }
3434 }
3435
3436 if (lo >= hi && lo > codesecsym)
3437 sec = syms[lo - 1]->section;
3438
3439 for (; sec != NULL; sec = sec->next)
3440 {
3441 if (sec->vma > ent)
3442 break;
3443 /* SEC_LOAD may not be set if SEC is from a separate debug
3444 info file. */
3445 if ((sec->flags & SEC_ALLOC) == 0)
3446 break;
3447 if ((sec->flags & SEC_CODE) != 0)
3448 s->section = sec;
3449 }
3450 s->flags |= BSF_SYNTHETIC;
3451 s->value = ent - s->section->vma;
3452 s->name = names;
3453 *names++ = '.';
3454 len = strlen (syms[i]->name);
3455 memcpy (names, syms[i]->name, len + 1);
3456 names += len + 1;
3457 /* Have udata.p point back to the original symbol this
3458 synthetic symbol was derived from. */
3459 s->udata.p = syms[i];
3460 s++;
3461 }
3462 }
3463 free (contents);
3464
3465 if (glink != NULL && relplt != NULL)
3466 {
3467 if (resolv_vma)
3468 {
3469 /* Add a symbol for the main glink trampoline. */
3470 memset (s, 0, sizeof *s);
3471 s->the_bfd = abfd;
3472 s->flags = BSF_GLOBAL | BSF_SYNTHETIC;
3473 s->section = glink;
3474 s->value = resolv_vma - glink->vma;
3475 s->name = names;
3476 memcpy (names, "__glink_PLTresolve", sizeof ("__glink_PLTresolve"));
3477 names += sizeof ("__glink_PLTresolve");
3478 s++;
3479 count++;
3480 }
3481
3482 /* FIXME: It would be very much nicer to put sym@plt on the
3483 stub rather than on the glink branch table entry. The
3484 objdump disassembler would then use a sensible symbol
3485 name on plt calls. The difficulty in doing so is
3486 a) finding the stubs, and,
3487 b) matching stubs against plt entries, and,
3488 c) there can be multiple stubs for a given plt entry.
3489
3490 Solving (a) could be done by code scanning, but older
3491 ppc64 binaries used different stubs to current code.
3492 (b) is the tricky one since you need to known the toc
3493 pointer for at least one function that uses a pic stub to
3494 be able to calculate the plt address referenced.
3495 (c) means gdb would need to set multiple breakpoints (or
3496 find the glink branch itself) when setting breakpoints
3497 for pending shared library loads. */
3498 p = relplt->relocation;
3499 for (i = 0; i < plt_count; i++, p++)
3500 {
3501 size_t len;
3502
3503 *s = **p->sym_ptr_ptr;
3504 /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set. Since
3505 we are defining a symbol, ensure one of them is set. */
3506 if ((s->flags & BSF_LOCAL) == 0)
3507 s->flags |= BSF_GLOBAL;
3508 s->flags |= BSF_SYNTHETIC;
3509 s->section = glink;
3510 s->value = glink_vma - glink->vma;
3511 s->name = names;
3512 s->udata.p = NULL;
3513 len = strlen ((*p->sym_ptr_ptr)->name);
3514 memcpy (names, (*p->sym_ptr_ptr)->name, len);
3515 names += len;
3516 if (p->addend != 0)
3517 {
3518 memcpy (names, "+0x", sizeof ("+0x") - 1);
3519 names += sizeof ("+0x") - 1;
3520 bfd_sprintf_vma (abfd, names, p->addend);
3521 names += strlen (names);
3522 }
3523 memcpy (names, "@plt", sizeof ("@plt"));
3524 names += sizeof ("@plt");
3525 s++;
3526 glink_vma += 8;
3527 if (i >= 0x8000)
3528 glink_vma += 4;
3529 }
3530 count += plt_count;
3531 }
3532 }
3533
3534 done:
3535 free (syms);
3536 return count;
3537 }
3538 \f
3539 /* The following functions are specific to the ELF linker, while
3540 functions above are used generally. Those named ppc64_elf_* are
3541 called by the main ELF linker code. They appear in this file more
3542 or less in the order in which they are called. eg.
3543 ppc64_elf_check_relocs is called early in the link process,
3544 ppc64_elf_finish_dynamic_sections is one of the last functions
3545 called.
3546
3547 PowerPC64-ELF uses a similar scheme to PowerPC64-XCOFF in that
3548 functions have both a function code symbol and a function descriptor
3549 symbol. A call to foo in a relocatable object file looks like:
3550
3551 . .text
3552 . x:
3553 . bl .foo
3554 . nop
3555
3556 The function definition in another object file might be:
3557
3558 . .section .opd
3559 . foo: .quad .foo
3560 . .quad .TOC.@tocbase
3561 . .quad 0
3562 .
3563 . .text
3564 . .foo: blr
3565
3566 When the linker resolves the call during a static link, the branch
3567 unsurprisingly just goes to .foo and the .opd information is unused.
3568 If the function definition is in a shared library, things are a little
3569 different: The call goes via a plt call stub, the opd information gets
3570 copied to the plt, and the linker patches the nop.
3571
3572 . x:
3573 . bl .foo_stub
3574 . ld 2,40(1)
3575 .
3576 .
3577 . .foo_stub:
3578 . std 2,40(1) # in practice, the call stub
3579 . addis 11,2,Lfoo@toc@ha # is slightly optimized, but
3580 . addi 11,11,Lfoo@toc@l # this is the general idea
3581 . ld 12,0(11)
3582 . ld 2,8(11)
3583 . mtctr 12
3584 . ld 11,16(11)
3585 . bctr
3586 .
3587 . .section .plt
3588 . Lfoo: reloc (R_PPC64_JMP_SLOT, foo)
3589
3590 The "reloc ()" notation is supposed to indicate that the linker emits
3591 an R_PPC64_JMP_SLOT reloc against foo. The dynamic linker does the opd
3592 copying.
3593
3594 What are the difficulties here? Well, firstly, the relocations
3595 examined by the linker in check_relocs are against the function code
3596 sym .foo, while the dynamic relocation in the plt is emitted against
3597 the function descriptor symbol, foo. Somewhere along the line, we need
3598 to carefully copy dynamic link information from one symbol to the other.
3599 Secondly, the generic part of the elf linker will make .foo a dynamic
3600 symbol as is normal for most other backends. We need foo dynamic
3601 instead, at least for an application final link. However, when
3602 creating a shared library containing foo, we need to have both symbols
3603 dynamic so that references to .foo are satisfied during the early
3604 stages of linking. Otherwise the linker might decide to pull in a
3605 definition from some other object, eg. a static library.
3606
3607 Update: As of August 2004, we support a new convention. Function
3608 calls may use the function descriptor symbol, ie. "bl foo". This
3609 behaves exactly as "bl .foo". */
3610
3611 /* Of those relocs that might be copied as dynamic relocs, this function
3612 selects those that must be copied when linking a shared library,
3613 even when the symbol is local. */
3614
3615 static int
3616 must_be_dyn_reloc (struct bfd_link_info *info,
3617 enum elf_ppc64_reloc_type r_type)
3618 {
3619 switch (r_type)
3620 {
3621 default:
3622 return 1;
3623
3624 case R_PPC64_REL32:
3625 case R_PPC64_REL64:
3626 case R_PPC64_REL30:
3627 return 0;
3628
3629 case R_PPC64_TPREL16:
3630 case R_PPC64_TPREL16_LO:
3631 case R_PPC64_TPREL16_HI:
3632 case R_PPC64_TPREL16_HA:
3633 case R_PPC64_TPREL16_DS:
3634 case R_PPC64_TPREL16_LO_DS:
3635 case R_PPC64_TPREL16_HIGH:
3636 case R_PPC64_TPREL16_HIGHA:
3637 case R_PPC64_TPREL16_HIGHER:
3638 case R_PPC64_TPREL16_HIGHERA:
3639 case R_PPC64_TPREL16_HIGHEST:
3640 case R_PPC64_TPREL16_HIGHESTA:
3641 case R_PPC64_TPREL64:
3642 return !info->executable;
3643 }
3644 }
3645
3646 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
3647 copying dynamic variables from a shared lib into an app's dynbss
3648 section, and instead use a dynamic relocation to point into the
3649 shared lib. With code that gcc generates, it's vital that this be
3650 enabled; In the PowerPC64 ABI, the address of a function is actually
3651 the address of a function descriptor, which resides in the .opd
3652 section. gcc uses the descriptor directly rather than going via the
3653 GOT as some other ABI's do, which means that initialized function
3654 pointers must reference the descriptor. Thus, a function pointer
3655 initialized to the address of a function in a shared library will
3656 either require a copy reloc, or a dynamic reloc. Using a copy reloc
3657 redefines the function descriptor symbol to point to the copy. This
3658 presents a problem as a plt entry for that function is also
3659 initialized from the function descriptor symbol and the copy reloc
3660 may not be initialized first. */
3661 #define ELIMINATE_COPY_RELOCS 1
3662
3663 /* Section name for stubs is the associated section name plus this
3664 string. */
3665 #define STUB_SUFFIX ".stub"
3666
3667 /* Linker stubs.
3668 ppc_stub_long_branch:
3669 Used when a 14 bit branch (or even a 24 bit branch) can't reach its
3670 destination, but a 24 bit branch in a stub section will reach.
3671 . b dest
3672
3673 ppc_stub_plt_branch:
3674 Similar to the above, but a 24 bit branch in the stub section won't
3675 reach its destination.
3676 . addis %r11,%r2,xxx@toc@ha
3677 . ld %r12,xxx@toc@l(%r11)
3678 . mtctr %r12
3679 . bctr
3680
3681 ppc_stub_plt_call:
3682 Used to call a function in a shared library. If it so happens that
3683 the plt entry referenced crosses a 64k boundary, then an extra
3684 "addi %r11,%r11,xxx@toc@l" will be inserted before the "mtctr".
3685 . std %r2,40(%r1)
3686 . addis %r11,%r2,xxx@toc@ha
3687 . ld %r12,xxx+0@toc@l(%r11)
3688 . mtctr %r12
3689 . ld %r2,xxx+8@toc@l(%r11)
3690 . ld %r11,xxx+16@toc@l(%r11)
3691 . bctr
3692
3693 ppc_stub_long_branch and ppc_stub_plt_branch may also have additional
3694 code to adjust the value and save r2 to support multiple toc sections.
3695 A ppc_stub_long_branch with an r2 offset looks like:
3696 . std %r2,40(%r1)
3697 . addis %r2,%r2,off@ha
3698 . addi %r2,%r2,off@l
3699 . b dest
3700
3701 A ppc_stub_plt_branch with an r2 offset looks like:
3702 . std %r2,40(%r1)
3703 . addis %r11,%r2,xxx@toc@ha
3704 . ld %r12,xxx@toc@l(%r11)
3705 . addis %r2,%r2,off@ha
3706 . addi %r2,%r2,off@l
3707 . mtctr %r12
3708 . bctr
3709
3710 In cases where the "addis" instruction would add zero, the "addis" is
3711 omitted and following instructions modified slightly in some cases.
3712 */
3713
3714 enum ppc_stub_type {
3715 ppc_stub_none,
3716 ppc_stub_long_branch,
3717 ppc_stub_long_branch_r2off,
3718 ppc_stub_plt_branch,
3719 ppc_stub_plt_branch_r2off,
3720 ppc_stub_plt_call,
3721 ppc_stub_plt_call_r2save
3722 };
3723
3724 struct ppc_stub_hash_entry {
3725
3726 /* Base hash table entry structure. */
3727 struct bfd_hash_entry root;
3728
3729 enum ppc_stub_type stub_type;
3730
3731 /* The stub section. */
3732 asection *stub_sec;
3733
3734 /* Offset within stub_sec of the beginning of this stub. */
3735 bfd_vma stub_offset;
3736
3737 /* Given the symbol's value and its section we can determine its final
3738 value when building the stubs (so the stub knows where to jump. */
3739 bfd_vma target_value;
3740 asection *target_section;
3741
3742 /* The symbol table entry, if any, that this was derived from. */
3743 struct ppc_link_hash_entry *h;
3744 struct plt_entry *plt_ent;
3745
3746 /* Where this stub is being called from, or, in the case of combined
3747 stub sections, the first input section in the group. */
3748 asection *id_sec;
3749 };
3750
3751 struct ppc_branch_hash_entry {
3752
3753 /* Base hash table entry structure. */
3754 struct bfd_hash_entry root;
3755
3756 /* Offset within branch lookup table. */
3757 unsigned int offset;
3758
3759 /* Generation marker. */
3760 unsigned int iter;
3761 };
3762
3763 /* Used to track dynamic relocations for local symbols. */
3764 struct ppc_dyn_relocs
3765 {
3766 struct ppc_dyn_relocs *next;
3767
3768 /* The input section of the reloc. */
3769 asection *sec;
3770
3771 /* Total number of relocs copied for the input section. */
3772 unsigned int count : 31;
3773
3774 /* Whether this entry is for STT_GNU_IFUNC symbols. */
3775 unsigned int ifunc : 1;
3776 };
3777
3778 struct ppc_link_hash_entry
3779 {
3780 struct elf_link_hash_entry elf;
3781
3782 union {
3783 /* A pointer to the most recently used stub hash entry against this
3784 symbol. */
3785 struct ppc_stub_hash_entry *stub_cache;
3786
3787 /* A pointer to the next symbol starting with a '.' */
3788 struct ppc_link_hash_entry *next_dot_sym;
3789 } u;
3790
3791 /* Track dynamic relocs copied for this symbol. */
3792 struct elf_dyn_relocs *dyn_relocs;
3793
3794 /* Link between function code and descriptor symbols. */
3795 struct ppc_link_hash_entry *oh;
3796
3797 /* Flag function code and descriptor symbols. */
3798 unsigned int is_func:1;
3799 unsigned int is_func_descriptor:1;
3800 unsigned int fake:1;
3801
3802 /* Whether global opd/toc sym has been adjusted or not.
3803 After ppc64_elf_edit_opd/ppc64_elf_edit_toc has run, this flag
3804 should be set for all globals defined in any opd/toc section. */
3805 unsigned int adjust_done:1;
3806
3807 /* Set if we twiddled this symbol to weak at some stage. */
3808 unsigned int was_undefined:1;
3809
3810 /* Contexts in which symbol is used in the GOT (or TOC).
3811 TLS_GD .. TLS_EXPLICIT bits are or'd into the mask as the
3812 corresponding relocs are encountered during check_relocs.
3813 tls_optimize clears TLS_GD .. TLS_TPREL when optimizing to
3814 indicate the corresponding GOT entry type is not needed.
3815 tls_optimize may also set TLS_TPRELGD when a GD reloc turns into
3816 a TPREL one. We use a separate flag rather than setting TPREL
3817 just for convenience in distinguishing the two cases. */
3818 #define TLS_GD 1 /* GD reloc. */
3819 #define TLS_LD 2 /* LD reloc. */
3820 #define TLS_TPREL 4 /* TPREL reloc, => IE. */
3821 #define TLS_DTPREL 8 /* DTPREL reloc, => LD. */
3822 #define TLS_TLS 16 /* Any TLS reloc. */
3823 #define TLS_EXPLICIT 32 /* Marks TOC section TLS relocs. */
3824 #define TLS_TPRELGD 64 /* TPREL reloc resulting from GD->IE. */
3825 #define PLT_IFUNC 128 /* STT_GNU_IFUNC. */
3826 unsigned char tls_mask;
3827 };
3828
3829 /* ppc64 ELF linker hash table. */
3830
3831 struct ppc_link_hash_table
3832 {
3833 struct elf_link_hash_table elf;
3834
3835 /* The stub hash table. */
3836 struct bfd_hash_table stub_hash_table;
3837
3838 /* Another hash table for plt_branch stubs. */
3839 struct bfd_hash_table branch_hash_table;
3840
3841 /* Hash table for function prologue tocsave. */
3842 htab_t tocsave_htab;
3843
3844 /* Linker stub bfd. */
3845 bfd *stub_bfd;
3846
3847 /* Linker call-backs. */
3848 asection * (*add_stub_section) (const char *, asection *);
3849 void (*layout_sections_again) (void);
3850
3851 /* Array to keep track of which stub sections have been created, and
3852 information on stub grouping. */
3853 struct map_stub {
3854 /* This is the section to which stubs in the group will be attached. */
3855 asection *link_sec;
3856 /* The stub section. */
3857 asection *stub_sec;
3858 /* Along with elf_gp, specifies the TOC pointer used in this group. */
3859 bfd_vma toc_off;
3860 } *stub_group;
3861
3862 /* Temp used when calculating TOC pointers. */
3863 bfd_vma toc_curr;
3864 bfd *toc_bfd;
3865 asection *toc_first_sec;
3866
3867 /* Highest input section id. */
3868 int top_id;
3869
3870 /* Highest output section index. */
3871 int top_index;
3872
3873 /* Used when adding symbols. */
3874 struct ppc_link_hash_entry *dot_syms;
3875
3876 /* List of input sections for each output section. */
3877 asection **input_list;
3878
3879 /* Short-cuts to get to dynamic linker sections. */
3880 asection *got;
3881 asection *plt;
3882 asection *relplt;
3883 asection *iplt;
3884 asection *reliplt;
3885 asection *dynbss;
3886 asection *relbss;
3887 asection *glink;
3888 asection *sfpr;
3889 asection *brlt;
3890 asection *relbrlt;
3891 asection *glink_eh_frame;
3892
3893 /* Shortcut to .__tls_get_addr and __tls_get_addr. */
3894 struct ppc_link_hash_entry *tls_get_addr;
3895 struct ppc_link_hash_entry *tls_get_addr_fd;
3896
3897 /* The size of reliplt used by got entry relocs. */
3898 bfd_size_type got_reli_size;
3899
3900 /* Statistics. */
3901 unsigned long stub_count[ppc_stub_plt_call_r2save];
3902
3903 /* Number of stubs against global syms. */
3904 unsigned long stub_globals;
3905
3906 /* Alignment of PLT call stubs. */
3907 unsigned int plt_stub_align:4;
3908
3909 /* Set if we're linking code with function descriptors. */
3910 unsigned int opd_abi:1;
3911
3912 /* Set if PLT call stubs should load r11. */
3913 unsigned int plt_static_chain:1;
3914
3915 /* Set if PLT call stubs need a read-read barrier. */
3916 unsigned int plt_thread_safe:1;
3917
3918 /* Set if we should emit symbols for stubs. */
3919 unsigned int emit_stub_syms:1;
3920
3921 /* Set if __tls_get_addr optimization should not be done. */
3922 unsigned int no_tls_get_addr_opt:1;
3923
3924 /* Support for multiple toc sections. */
3925 unsigned int do_multi_toc:1;
3926 unsigned int multi_toc_needed:1;
3927 unsigned int second_toc_pass:1;
3928 unsigned int do_toc_opt:1;
3929
3930 /* Set on error. */
3931 unsigned int stub_error:1;
3932
3933 /* Temp used by ppc64_elf_process_dot_syms. */
3934 unsigned int twiddled_syms:1;
3935
3936 /* Incremented every time we size stubs. */
3937 unsigned int stub_iteration;
3938
3939 /* Small local sym cache. */
3940 struct sym_cache sym_cache;
3941 };
3942
3943 /* Rename some of the generic section flags to better document how they
3944 are used here. */
3945
3946 /* Nonzero if this section has TLS related relocations. */
3947 #define has_tls_reloc sec_flg0
3948
3949 /* Nonzero if this section has a call to __tls_get_addr. */
3950 #define has_tls_get_addr_call sec_flg1
3951
3952 /* Nonzero if this section has any toc or got relocs. */
3953 #define has_toc_reloc sec_flg2
3954
3955 /* Nonzero if this section has a call to another section that uses
3956 the toc or got. */
3957 #define makes_toc_func_call sec_flg3
3958
3959 /* Recursion protection when determining above flag. */
3960 #define call_check_in_progress sec_flg4
3961 #define call_check_done sec_flg5
3962
3963 /* Get the ppc64 ELF linker hash table from a link_info structure. */
3964
3965 #define ppc_hash_table(p) \
3966 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
3967 == PPC64_ELF_DATA ? ((struct ppc_link_hash_table *) ((p)->hash)) : NULL)
3968
3969 #define ppc_stub_hash_lookup(table, string, create, copy) \
3970 ((struct ppc_stub_hash_entry *) \
3971 bfd_hash_lookup ((table), (string), (create), (copy)))
3972
3973 #define ppc_branch_hash_lookup(table, string, create, copy) \
3974 ((struct ppc_branch_hash_entry *) \
3975 bfd_hash_lookup ((table), (string), (create), (copy)))
3976
3977 /* Create an entry in the stub hash table. */
3978
3979 static struct bfd_hash_entry *
3980 stub_hash_newfunc (struct bfd_hash_entry *entry,
3981 struct bfd_hash_table *table,
3982 const char *string)
3983 {
3984 /* Allocate the structure if it has not already been allocated by a
3985 subclass. */
3986 if (entry == NULL)
3987 {
3988 entry = bfd_hash_allocate (table, sizeof (struct ppc_stub_hash_entry));
3989 if (entry == NULL)
3990 return entry;
3991 }
3992
3993 /* Call the allocation method of the superclass. */
3994 entry = bfd_hash_newfunc (entry, table, string);
3995 if (entry != NULL)
3996 {
3997 struct ppc_stub_hash_entry *eh;
3998
3999 /* Initialize the local fields. */
4000 eh = (struct ppc_stub_hash_entry *) entry;
4001 eh->stub_type = ppc_stub_none;
4002 eh->stub_sec = NULL;
4003 eh->stub_offset = 0;
4004 eh->target_value = 0;
4005 eh->target_section = NULL;
4006 eh->h = NULL;
4007 eh->id_sec = NULL;
4008 }
4009
4010 return entry;
4011 }
4012
4013 /* Create an entry in the branch hash table. */
4014
4015 static struct bfd_hash_entry *
4016 branch_hash_newfunc (struct bfd_hash_entry *entry,
4017 struct bfd_hash_table *table,
4018 const char *string)
4019 {
4020 /* Allocate the structure if it has not already been allocated by a
4021 subclass. */
4022 if (entry == NULL)
4023 {
4024 entry = bfd_hash_allocate (table, sizeof (struct ppc_branch_hash_entry));
4025 if (entry == NULL)
4026 return entry;
4027 }
4028
4029 /* Call the allocation method of the superclass. */
4030 entry = bfd_hash_newfunc (entry, table, string);
4031 if (entry != NULL)
4032 {
4033 struct ppc_branch_hash_entry *eh;
4034
4035 /* Initialize the local fields. */
4036 eh = (struct ppc_branch_hash_entry *) entry;
4037 eh->offset = 0;
4038 eh->iter = 0;
4039 }
4040
4041 return entry;
4042 }
4043
4044 /* Create an entry in a ppc64 ELF linker hash table. */
4045
4046 static struct bfd_hash_entry *
4047 link_hash_newfunc (struct bfd_hash_entry *entry,
4048 struct bfd_hash_table *table,
4049 const char *string)
4050 {
4051 /* Allocate the structure if it has not already been allocated by a
4052 subclass. */
4053 if (entry == NULL)
4054 {
4055 entry = bfd_hash_allocate (table, sizeof (struct ppc_link_hash_entry));
4056 if (entry == NULL)
4057 return entry;
4058 }
4059
4060 /* Call the allocation method of the superclass. */
4061 entry = _bfd_elf_link_hash_newfunc (entry, table, string);
4062 if (entry != NULL)
4063 {
4064 struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) entry;
4065
4066 memset (&eh->u.stub_cache, 0,
4067 (sizeof (struct ppc_link_hash_entry)
4068 - offsetof (struct ppc_link_hash_entry, u.stub_cache)));
4069
4070 /* When making function calls, old ABI code references function entry
4071 points (dot symbols), while new ABI code references the function
4072 descriptor symbol. We need to make any combination of reference and
4073 definition work together, without breaking archive linking.
4074
4075 For a defined function "foo" and an undefined call to "bar":
4076 An old object defines "foo" and ".foo", references ".bar" (possibly
4077 "bar" too).
4078 A new object defines "foo" and references "bar".
4079
4080 A new object thus has no problem with its undefined symbols being
4081 satisfied by definitions in an old object. On the other hand, the
4082 old object won't have ".bar" satisfied by a new object.
4083
4084 Keep a list of newly added dot-symbols. */
4085
4086 if (string[0] == '.')
4087 {
4088 struct ppc_link_hash_table *htab;
4089
4090 htab = (struct ppc_link_hash_table *) table;
4091 eh->u.next_dot_sym = htab->dot_syms;
4092 htab->dot_syms = eh;
4093 }
4094 }
4095
4096 return entry;
4097 }
4098
4099 struct tocsave_entry {
4100 asection *sec;
4101 bfd_vma offset;
4102 };
4103
4104 static hashval_t
4105 tocsave_htab_hash (const void *p)
4106 {
4107 const struct tocsave_entry *e = (const struct tocsave_entry *) p;
4108 return ((bfd_vma)(intptr_t) e->sec ^ e->offset) >> 3;
4109 }
4110
4111 static int
4112 tocsave_htab_eq (const void *p1, const void *p2)
4113 {
4114 const struct tocsave_entry *e1 = (const struct tocsave_entry *) p1;
4115 const struct tocsave_entry *e2 = (const struct tocsave_entry *) p2;
4116 return e1->sec == e2->sec && e1->offset == e2->offset;
4117 }
4118
4119 /* Create a ppc64 ELF linker hash table. */
4120
4121 static struct bfd_link_hash_table *
4122 ppc64_elf_link_hash_table_create (bfd *abfd)
4123 {
4124 struct ppc_link_hash_table *htab;
4125 bfd_size_type amt = sizeof (struct ppc_link_hash_table);
4126
4127 htab = bfd_zmalloc (amt);
4128 if (htab == NULL)
4129 return NULL;
4130
4131 if (!_bfd_elf_link_hash_table_init (&htab->elf, abfd, link_hash_newfunc,
4132 sizeof (struct ppc_link_hash_entry),
4133 PPC64_ELF_DATA))
4134 {
4135 free (htab);
4136 return NULL;
4137 }
4138
4139 /* Init the stub hash table too. */
4140 if (!bfd_hash_table_init (&htab->stub_hash_table, stub_hash_newfunc,
4141 sizeof (struct ppc_stub_hash_entry)))
4142 return NULL;
4143
4144 /* And the branch hash table. */
4145 if (!bfd_hash_table_init (&htab->branch_hash_table, branch_hash_newfunc,
4146 sizeof (struct ppc_branch_hash_entry)))
4147 return NULL;
4148
4149 htab->tocsave_htab = htab_try_create (1024,
4150 tocsave_htab_hash,
4151 tocsave_htab_eq,
4152 NULL);
4153 if (htab->tocsave_htab == NULL)
4154 return NULL;
4155
4156 /* Initializing two fields of the union is just cosmetic. We really
4157 only care about glist, but when compiled on a 32-bit host the
4158 bfd_vma fields are larger. Setting the bfd_vma to zero makes
4159 debugger inspection of these fields look nicer. */
4160 htab->elf.init_got_refcount.refcount = 0;
4161 htab->elf.init_got_refcount.glist = NULL;
4162 htab->elf.init_plt_refcount.refcount = 0;
4163 htab->elf.init_plt_refcount.glist = NULL;
4164 htab->elf.init_got_offset.offset = 0;
4165 htab->elf.init_got_offset.glist = NULL;
4166 htab->elf.init_plt_offset.offset = 0;
4167 htab->elf.init_plt_offset.glist = NULL;
4168
4169 return &htab->elf.root;
4170 }
4171
4172 /* Free the derived linker hash table. */
4173
4174 static void
4175 ppc64_elf_link_hash_table_free (struct bfd_link_hash_table *hash)
4176 {
4177 struct ppc_link_hash_table *htab = (struct ppc_link_hash_table *) hash;
4178
4179 bfd_hash_table_free (&htab->stub_hash_table);
4180 bfd_hash_table_free (&htab->branch_hash_table);
4181 if (htab->tocsave_htab)
4182 htab_delete (htab->tocsave_htab);
4183 _bfd_elf_link_hash_table_free (hash);
4184 }
4185
4186 /* Create sections for linker generated code. */
4187
4188 static bfd_boolean
4189 create_linkage_sections (bfd *dynobj, struct bfd_link_info *info)
4190 {
4191 struct ppc_link_hash_table *htab;
4192 flagword flags;
4193
4194 htab = ppc_hash_table (info);
4195
4196 /* Create .sfpr for code to save and restore fp regs. */
4197 flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY
4198 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4199 htab->sfpr = bfd_make_section_anyway_with_flags (dynobj, ".sfpr",
4200 flags);
4201 if (htab->sfpr == NULL
4202 || ! bfd_set_section_alignment (dynobj, htab->sfpr, 2))
4203 return FALSE;
4204
4205 /* Create .glink for lazy dynamic linking support. */
4206 htab->glink = bfd_make_section_anyway_with_flags (dynobj, ".glink",
4207 flags);
4208 if (htab->glink == NULL
4209 || ! bfd_set_section_alignment (dynobj, htab->glink, 3))
4210 return FALSE;
4211
4212 if (!info->no_ld_generated_unwind_info)
4213 {
4214 flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_HAS_CONTENTS
4215 | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4216 htab->glink_eh_frame = bfd_make_section_anyway_with_flags (dynobj,
4217 ".eh_frame",
4218 flags);
4219 if (htab->glink_eh_frame == NULL
4220 || !bfd_set_section_alignment (dynobj, htab->glink_eh_frame, 2))
4221 return FALSE;
4222 }
4223
4224 flags = SEC_ALLOC | SEC_LINKER_CREATED;
4225 htab->iplt = bfd_make_section_anyway_with_flags (dynobj, ".iplt", flags);
4226 if (htab->iplt == NULL
4227 || ! bfd_set_section_alignment (dynobj, htab->iplt, 3))
4228 return FALSE;
4229
4230 flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4231 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4232 htab->reliplt = bfd_make_section_anyway_with_flags (dynobj,
4233 ".rela.iplt",
4234 flags);
4235 if (htab->reliplt == NULL
4236 || ! bfd_set_section_alignment (dynobj, htab->reliplt, 3))
4237 return FALSE;
4238
4239 /* Create branch lookup table for plt_branch stubs. */
4240 flags = (SEC_ALLOC | SEC_LOAD
4241 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4242 htab->brlt = bfd_make_section_anyway_with_flags (dynobj, ".branch_lt",
4243 flags);
4244 if (htab->brlt == NULL
4245 || ! bfd_set_section_alignment (dynobj, htab->brlt, 3))
4246 return FALSE;
4247
4248 if (!info->shared)
4249 return TRUE;
4250
4251 flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4252 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4253 htab->relbrlt = bfd_make_section_anyway_with_flags (dynobj,
4254 ".rela.branch_lt",
4255 flags);
4256 if (htab->relbrlt == NULL
4257 || ! bfd_set_section_alignment (dynobj, htab->relbrlt, 3))
4258 return FALSE;
4259
4260 return TRUE;
4261 }
4262
4263 /* Satisfy the ELF linker by filling in some fields in our fake bfd. */
4264
4265 bfd_boolean
4266 ppc64_elf_init_stub_bfd (bfd *abfd, struct bfd_link_info *info)
4267 {
4268 struct ppc_link_hash_table *htab;
4269
4270 elf_elfheader (abfd)->e_ident[EI_CLASS] = ELFCLASS64;
4271
4272 /* Always hook our dynamic sections into the first bfd, which is the
4273 linker created stub bfd. This ensures that the GOT header is at
4274 the start of the output TOC section. */
4275 htab = ppc_hash_table (info);
4276 if (htab == NULL)
4277 return FALSE;
4278 htab->stub_bfd = abfd;
4279 htab->elf.dynobj = abfd;
4280
4281 if (info->relocatable)
4282 return TRUE;
4283
4284 return create_linkage_sections (htab->elf.dynobj, info);
4285 }
4286
4287 /* Build a name for an entry in the stub hash table. */
4288
4289 static char *
4290 ppc_stub_name (const asection *input_section,
4291 const asection *sym_sec,
4292 const struct ppc_link_hash_entry *h,
4293 const Elf_Internal_Rela *rel)
4294 {
4295 char *stub_name;
4296 ssize_t len;
4297
4298 /* rel->r_addend is actually 64 bit, but who uses more than +/- 2^31
4299 offsets from a sym as a branch target? In fact, we could
4300 probably assume the addend is always zero. */
4301 BFD_ASSERT (((int) rel->r_addend & 0xffffffff) == rel->r_addend);
4302
4303 if (h)
4304 {
4305 len = 8 + 1 + strlen (h->elf.root.root.string) + 1 + 8 + 1;
4306 stub_name = bfd_malloc (len);
4307 if (stub_name == NULL)
4308 return stub_name;
4309
4310 len = sprintf (stub_name, "%08x.%s+%x",
4311 input_section->id & 0xffffffff,
4312 h->elf.root.root.string,
4313 (int) rel->r_addend & 0xffffffff);
4314 }
4315 else
4316 {
4317 len = 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1;
4318 stub_name = bfd_malloc (len);
4319 if (stub_name == NULL)
4320 return stub_name;
4321
4322 len = sprintf (stub_name, "%08x.%x:%x+%x",
4323 input_section->id & 0xffffffff,
4324 sym_sec->id & 0xffffffff,
4325 (int) ELF64_R_SYM (rel->r_info) & 0xffffffff,
4326 (int) rel->r_addend & 0xffffffff);
4327 }
4328 if (len > 2 && stub_name[len - 2] == '+' && stub_name[len - 1] == '0')
4329 stub_name[len - 2] = 0;
4330 return stub_name;
4331 }
4332
4333 /* Look up an entry in the stub hash. Stub entries are cached because
4334 creating the stub name takes a bit of time. */
4335
4336 static struct ppc_stub_hash_entry *
4337 ppc_get_stub_entry (const asection *input_section,
4338 const asection *sym_sec,
4339 struct ppc_link_hash_entry *h,
4340 const Elf_Internal_Rela *rel,
4341 struct ppc_link_hash_table *htab)
4342 {
4343 struct ppc_stub_hash_entry *stub_entry;
4344 const asection *id_sec;
4345
4346 /* If this input section is part of a group of sections sharing one
4347 stub section, then use the id of the first section in the group.
4348 Stub names need to include a section id, as there may well be
4349 more than one stub used to reach say, printf, and we need to
4350 distinguish between them. */
4351 id_sec = htab->stub_group[input_section->id].link_sec;
4352
4353 if (h != NULL && h->u.stub_cache != NULL
4354 && h->u.stub_cache->h == h
4355 && h->u.stub_cache->id_sec == id_sec)
4356 {
4357 stub_entry = h->u.stub_cache;
4358 }
4359 else
4360 {
4361 char *stub_name;
4362
4363 stub_name = ppc_stub_name (id_sec, sym_sec, h, rel);
4364 if (stub_name == NULL)
4365 return NULL;
4366
4367 stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
4368 stub_name, FALSE, FALSE);
4369 if (h != NULL)
4370 h->u.stub_cache = stub_entry;
4371
4372 free (stub_name);
4373 }
4374
4375 return stub_entry;
4376 }
4377
4378 /* Add a new stub entry to the stub hash. Not all fields of the new
4379 stub entry are initialised. */
4380
4381 static struct ppc_stub_hash_entry *
4382 ppc_add_stub (const char *stub_name,
4383 asection *section,
4384 struct bfd_link_info *info)
4385 {
4386 struct ppc_link_hash_table *htab = ppc_hash_table (info);
4387 asection *link_sec;
4388 asection *stub_sec;
4389 struct ppc_stub_hash_entry *stub_entry;
4390
4391 link_sec = htab->stub_group[section->id].link_sec;
4392 stub_sec = htab->stub_group[section->id].stub_sec;
4393 if (stub_sec == NULL)
4394 {
4395 stub_sec = htab->stub_group[link_sec->id].stub_sec;
4396 if (stub_sec == NULL)
4397 {
4398 size_t namelen;
4399 bfd_size_type len;
4400 char *s_name;
4401
4402 namelen = strlen (link_sec->name);
4403 len = namelen + sizeof (STUB_SUFFIX);
4404 s_name = bfd_alloc (htab->stub_bfd, len);
4405 if (s_name == NULL)
4406 return NULL;
4407
4408 memcpy (s_name, link_sec->name, namelen);
4409 memcpy (s_name + namelen, STUB_SUFFIX, sizeof (STUB_SUFFIX));
4410 stub_sec = (*htab->add_stub_section) (s_name, link_sec);
4411 if (stub_sec == NULL)
4412 return NULL;
4413 htab->stub_group[link_sec->id].stub_sec = stub_sec;
4414 }
4415 htab->stub_group[section->id].stub_sec = stub_sec;
4416 }
4417
4418 /* Enter this entry into the linker stub hash table. */
4419 stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table, stub_name,
4420 TRUE, FALSE);
4421 if (stub_entry == NULL)
4422 {
4423 info->callbacks->einfo (_("%P: %B: cannot create stub entry %s\n"),
4424 section->owner, stub_name);
4425 return NULL;
4426 }
4427
4428 stub_entry->stub_sec = stub_sec;
4429 stub_entry->stub_offset = 0;
4430 stub_entry->id_sec = link_sec;
4431 return stub_entry;
4432 }
4433
4434 /* Create .got and .rela.got sections in ABFD, and .got in dynobj if
4435 not already done. */
4436
4437 static bfd_boolean
4438 create_got_section (bfd *abfd, struct bfd_link_info *info)
4439 {
4440 asection *got, *relgot;
4441 flagword flags;
4442 struct ppc_link_hash_table *htab = ppc_hash_table (info);
4443
4444 if (!is_ppc64_elf (abfd))
4445 return FALSE;
4446 if (htab == NULL)
4447 return FALSE;
4448
4449 if (!htab->got)
4450 {
4451 if (! _bfd_elf_create_got_section (htab->elf.dynobj, info))
4452 return FALSE;
4453
4454 htab->got = bfd_get_linker_section (htab->elf.dynobj, ".got");
4455 if (!htab->got)
4456 abort ();
4457 }
4458
4459 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
4460 | SEC_LINKER_CREATED);
4461
4462 got = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
4463 if (!got
4464 || !bfd_set_section_alignment (abfd, got, 3))
4465 return FALSE;
4466
4467 relgot = bfd_make_section_anyway_with_flags (abfd, ".rela.got",
4468 flags | SEC_READONLY);
4469 if (!relgot
4470 || ! bfd_set_section_alignment (abfd, relgot, 3))
4471 return FALSE;
4472
4473 ppc64_elf_tdata (abfd)->got = got;
4474 ppc64_elf_tdata (abfd)->relgot = relgot;
4475 return TRUE;
4476 }
4477
4478 /* Create the dynamic sections, and set up shortcuts. */
4479
4480 static bfd_boolean
4481 ppc64_elf_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
4482 {
4483 struct ppc_link_hash_table *htab;
4484
4485 if (!_bfd_elf_create_dynamic_sections (dynobj, info))
4486 return FALSE;
4487
4488 htab = ppc_hash_table (info);
4489 if (htab == NULL)
4490 return FALSE;
4491
4492 if (!htab->got)
4493 htab->got = bfd_get_linker_section (dynobj, ".got");
4494 htab->plt = bfd_get_linker_section (dynobj, ".plt");
4495 htab->relplt = bfd_get_linker_section (dynobj, ".rela.plt");
4496 htab->dynbss = bfd_get_linker_section (dynobj, ".dynbss");
4497 if (!info->shared)
4498 htab->relbss = bfd_get_linker_section (dynobj, ".rela.bss");
4499
4500 if (!htab->got || !htab->plt || !htab->relplt || !htab->dynbss
4501 || (!info->shared && !htab->relbss))
4502 abort ();
4503
4504 return TRUE;
4505 }
4506
4507 /* Follow indirect and warning symbol links. */
4508
4509 static inline struct bfd_link_hash_entry *
4510 follow_link (struct bfd_link_hash_entry *h)
4511 {
4512 while (h->type == bfd_link_hash_indirect
4513 || h->type == bfd_link_hash_warning)
4514 h = h->u.i.link;
4515 return h;
4516 }
4517
4518 static inline struct elf_link_hash_entry *
4519 elf_follow_link (struct elf_link_hash_entry *h)
4520 {
4521 return (struct elf_link_hash_entry *) follow_link (&h->root);
4522 }
4523
4524 static inline struct ppc_link_hash_entry *
4525 ppc_follow_link (struct ppc_link_hash_entry *h)
4526 {
4527 return (struct ppc_link_hash_entry *) follow_link (&h->elf.root);
4528 }
4529
4530 /* Merge PLT info on FROM with that on TO. */
4531
4532 static void
4533 move_plt_plist (struct ppc_link_hash_entry *from,
4534 struct ppc_link_hash_entry *to)
4535 {
4536 if (from->elf.plt.plist != NULL)
4537 {
4538 if (to->elf.plt.plist != NULL)
4539 {
4540 struct plt_entry **entp;
4541 struct plt_entry *ent;
4542
4543 for (entp = &from->elf.plt.plist; (ent = *entp) != NULL; )
4544 {
4545 struct plt_entry *dent;
4546
4547 for (dent = to->elf.plt.plist; dent != NULL; dent = dent->next)
4548 if (dent->addend == ent->addend)
4549 {
4550 dent->plt.refcount += ent->plt.refcount;
4551 *entp = ent->next;
4552 break;
4553 }
4554 if (dent == NULL)
4555 entp = &ent->next;
4556 }
4557 *entp = to->elf.plt.plist;
4558 }
4559
4560 to->elf.plt.plist = from->elf.plt.plist;
4561 from->elf.plt.plist = NULL;
4562 }
4563 }
4564
4565 /* Copy the extra info we tack onto an elf_link_hash_entry. */
4566
4567 static void
4568 ppc64_elf_copy_indirect_symbol (struct bfd_link_info *info,
4569 struct elf_link_hash_entry *dir,
4570 struct elf_link_hash_entry *ind)
4571 {
4572 struct ppc_link_hash_entry *edir, *eind;
4573
4574 edir = (struct ppc_link_hash_entry *) dir;
4575 eind = (struct ppc_link_hash_entry *) ind;
4576
4577 edir->is_func |= eind->is_func;
4578 edir->is_func_descriptor |= eind->is_func_descriptor;
4579 edir->tls_mask |= eind->tls_mask;
4580 if (eind->oh != NULL)
4581 edir->oh = ppc_follow_link (eind->oh);
4582
4583 /* If called to transfer flags for a weakdef during processing
4584 of elf_adjust_dynamic_symbol, don't copy NON_GOT_REF.
4585 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
4586 if (!(ELIMINATE_COPY_RELOCS
4587 && eind->elf.root.type != bfd_link_hash_indirect
4588 && edir->elf.dynamic_adjusted))
4589 edir->elf.non_got_ref |= eind->elf.non_got_ref;
4590
4591 edir->elf.ref_dynamic |= eind->elf.ref_dynamic;
4592 edir->elf.ref_regular |= eind->elf.ref_regular;
4593 edir->elf.ref_regular_nonweak |= eind->elf.ref_regular_nonweak;
4594 edir->elf.needs_plt |= eind->elf.needs_plt;
4595
4596 /* Copy over any dynamic relocs we may have on the indirect sym. */
4597 if (eind->dyn_relocs != NULL)
4598 {
4599 if (edir->dyn_relocs != NULL)
4600 {
4601 struct elf_dyn_relocs **pp;
4602 struct elf_dyn_relocs *p;
4603
4604 /* Add reloc counts against the indirect sym to the direct sym
4605 list. Merge any entries against the same section. */
4606 for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
4607 {
4608 struct elf_dyn_relocs *q;
4609
4610 for (q = edir->dyn_relocs; q != NULL; q = q->next)
4611 if (q->sec == p->sec)
4612 {
4613 q->pc_count += p->pc_count;
4614 q->count += p->count;
4615 *pp = p->next;
4616 break;
4617 }
4618 if (q == NULL)
4619 pp = &p->next;
4620 }
4621 *pp = edir->dyn_relocs;
4622 }
4623
4624 edir->dyn_relocs = eind->dyn_relocs;
4625 eind->dyn_relocs = NULL;
4626 }
4627
4628 /* If we were called to copy over info for a weak sym, that's all.
4629 You might think dyn_relocs need not be copied over; After all,
4630 both syms will be dynamic or both non-dynamic so we're just
4631 moving reloc accounting around. However, ELIMINATE_COPY_RELOCS
4632 code in ppc64_elf_adjust_dynamic_symbol needs to check for
4633 dyn_relocs in read-only sections, and it does so on what is the
4634 DIR sym here. */
4635 if (eind->elf.root.type != bfd_link_hash_indirect)
4636 return;
4637
4638 /* Copy over got entries that we may have already seen to the
4639 symbol which just became indirect. */
4640 if (eind->elf.got.glist != NULL)
4641 {
4642 if (edir->elf.got.glist != NULL)
4643 {
4644 struct got_entry **entp;
4645 struct got_entry *ent;
4646
4647 for (entp = &eind->elf.got.glist; (ent = *entp) != NULL; )
4648 {
4649 struct got_entry *dent;
4650
4651 for (dent = edir->elf.got.glist; dent != NULL; dent = dent->next)
4652 if (dent->addend == ent->addend
4653 && dent->owner == ent->owner
4654 && dent->tls_type == ent->tls_type)
4655 {
4656 dent->got.refcount += ent->got.refcount;
4657 *entp = ent->next;
4658 break;
4659 }
4660 if (dent == NULL)
4661 entp = &ent->next;
4662 }
4663 *entp = edir->elf.got.glist;
4664 }
4665
4666 edir->elf.got.glist = eind->elf.got.glist;
4667 eind->elf.got.glist = NULL;
4668 }
4669
4670 /* And plt entries. */
4671 move_plt_plist (eind, edir);
4672
4673 if (eind->elf.dynindx != -1)
4674 {
4675 if (edir->elf.dynindx != -1)
4676 _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
4677 edir->elf.dynstr_index);
4678 edir->elf.dynindx = eind->elf.dynindx;
4679 edir->elf.dynstr_index = eind->elf.dynstr_index;
4680 eind->elf.dynindx = -1;
4681 eind->elf.dynstr_index = 0;
4682 }
4683 }
4684
4685 /* Find the function descriptor hash entry from the given function code
4686 hash entry FH. Link the entries via their OH fields. */
4687
4688 static struct ppc_link_hash_entry *
4689 lookup_fdh (struct ppc_link_hash_entry *fh, struct ppc_link_hash_table *htab)
4690 {
4691 struct ppc_link_hash_entry *fdh = fh->oh;
4692
4693 if (fdh == NULL)
4694 {
4695 const char *fd_name = fh->elf.root.root.string + 1;
4696
4697 fdh = (struct ppc_link_hash_entry *)
4698 elf_link_hash_lookup (&htab->elf, fd_name, FALSE, FALSE, FALSE);
4699 if (fdh == NULL)
4700 return fdh;
4701
4702 fdh->is_func_descriptor = 1;
4703 fdh->oh = fh;
4704 fh->is_func = 1;
4705 fh->oh = fdh;
4706 }
4707
4708 return ppc_follow_link (fdh);
4709 }
4710
4711 /* Make a fake function descriptor sym for the code sym FH. */
4712
4713 static struct ppc_link_hash_entry *
4714 make_fdh (struct bfd_link_info *info,
4715 struct ppc_link_hash_entry *fh)
4716 {
4717 bfd *abfd;
4718 asymbol *newsym;
4719 struct bfd_link_hash_entry *bh;
4720 struct ppc_link_hash_entry *fdh;
4721
4722 abfd = fh->elf.root.u.undef.abfd;
4723 newsym = bfd_make_empty_symbol (abfd);
4724 newsym->name = fh->elf.root.root.string + 1;
4725 newsym->section = bfd_und_section_ptr;
4726 newsym->value = 0;
4727 newsym->flags = BSF_WEAK;
4728
4729 bh = NULL;
4730 if (!_bfd_generic_link_add_one_symbol (info, abfd, newsym->name,
4731 newsym->flags, newsym->section,
4732 newsym->value, NULL, FALSE, FALSE,
4733 &bh))
4734 return NULL;
4735
4736 fdh = (struct ppc_link_hash_entry *) bh;
4737 fdh->elf.non_elf = 0;
4738 fdh->fake = 1;
4739 fdh->is_func_descriptor = 1;
4740 fdh->oh = fh;
4741 fh->is_func = 1;
4742 fh->oh = fdh;
4743 return fdh;
4744 }
4745
4746 /* Fix function descriptor symbols defined in .opd sections to be
4747 function type. */
4748
4749 static bfd_boolean
4750 ppc64_elf_add_symbol_hook (bfd *ibfd,
4751 struct bfd_link_info *info,
4752 Elf_Internal_Sym *isym,
4753 const char **name ATTRIBUTE_UNUSED,
4754 flagword *flags ATTRIBUTE_UNUSED,
4755 asection **sec,
4756 bfd_vma *value ATTRIBUTE_UNUSED)
4757 {
4758 if ((ibfd->flags & DYNAMIC) == 0
4759 && ELF_ST_BIND (isym->st_info) == STB_GNU_UNIQUE)
4760 elf_tdata (info->output_bfd)->has_gnu_symbols = TRUE;
4761
4762 if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
4763 {
4764 if ((ibfd->flags & DYNAMIC) == 0)
4765 elf_tdata (info->output_bfd)->has_gnu_symbols = TRUE;
4766 }
4767 else if (ELF_ST_TYPE (isym->st_info) == STT_FUNC)
4768 ;
4769 else if (*sec != NULL
4770 && strcmp ((*sec)->name, ".opd") == 0)
4771 isym->st_info = ELF_ST_INFO (ELF_ST_BIND (isym->st_info), STT_FUNC);
4772
4773 return TRUE;
4774 }
4775
4776 /* This function makes an old ABI object reference to ".bar" cause the
4777 inclusion of a new ABI object archive that defines "bar".
4778 NAME is a symbol defined in an archive. Return a symbol in the hash
4779 table that might be satisfied by the archive symbols. */
4780
4781 static struct elf_link_hash_entry *
4782 ppc64_elf_archive_symbol_lookup (bfd *abfd,
4783 struct bfd_link_info *info,
4784 const char *name)
4785 {
4786 struct elf_link_hash_entry *h;
4787 char *dot_name;
4788 size_t len;
4789
4790 h = _bfd_elf_archive_symbol_lookup (abfd, info, name);
4791 if (h != NULL
4792 /* Don't return this sym if it is a fake function descriptor
4793 created by add_symbol_adjust. */
4794 && !(h->root.type == bfd_link_hash_undefweak
4795 && ((struct ppc_link_hash_entry *) h)->fake))
4796 return h;
4797
4798 if (name[0] == '.')
4799 return h;
4800
4801 len = strlen (name);
4802 dot_name = bfd_alloc (abfd, len + 2);
4803 if (dot_name == NULL)
4804 return (struct elf_link_hash_entry *) 0 - 1;
4805 dot_name[0] = '.';
4806 memcpy (dot_name + 1, name, len + 1);
4807 h = _bfd_elf_archive_symbol_lookup (abfd, info, dot_name);
4808 bfd_release (abfd, dot_name);
4809 return h;
4810 }
4811
4812 /* This function satisfies all old ABI object references to ".bar" if a
4813 new ABI object defines "bar". Well, at least, undefined dot symbols
4814 are made weak. This stops later archive searches from including an
4815 object if we already have a function descriptor definition. It also
4816 prevents the linker complaining about undefined symbols.
4817 We also check and correct mismatched symbol visibility here. The
4818 most restrictive visibility of the function descriptor and the
4819 function entry symbol is used. */
4820
4821 static bfd_boolean
4822 add_symbol_adjust (struct ppc_link_hash_entry *eh, struct bfd_link_info *info)
4823 {
4824 struct ppc_link_hash_table *htab;
4825 struct ppc_link_hash_entry *fdh;
4826
4827 if (eh->elf.root.type == bfd_link_hash_indirect)
4828 return TRUE;
4829
4830 if (eh->elf.root.type == bfd_link_hash_warning)
4831 eh = (struct ppc_link_hash_entry *) eh->elf.root.u.i.link;
4832
4833 if (eh->elf.root.root.string[0] != '.')
4834 abort ();
4835
4836 htab = ppc_hash_table (info);
4837 if (htab == NULL)
4838 return FALSE;
4839
4840 fdh = lookup_fdh (eh, htab);
4841 if (fdh == NULL)
4842 {
4843 if (!info->relocatable
4844 && (eh->elf.root.type == bfd_link_hash_undefined
4845 || eh->elf.root.type == bfd_link_hash_undefweak)
4846 && eh->elf.ref_regular)
4847 {
4848 /* Make an undefweak function descriptor sym, which is enough to
4849 pull in an --as-needed shared lib, but won't cause link
4850 errors. Archives are handled elsewhere. */
4851 fdh = make_fdh (info, eh);
4852 if (fdh == NULL)
4853 return FALSE;
4854 fdh->elf.ref_regular = 1;
4855 }
4856 }
4857 else
4858 {
4859 unsigned entry_vis = ELF_ST_VISIBILITY (eh->elf.other) - 1;
4860 unsigned descr_vis = ELF_ST_VISIBILITY (fdh->elf.other) - 1;
4861 if (entry_vis < descr_vis)
4862 fdh->elf.other += entry_vis - descr_vis;
4863 else if (entry_vis > descr_vis)
4864 eh->elf.other += descr_vis - entry_vis;
4865
4866 if ((fdh->elf.root.type == bfd_link_hash_defined
4867 || fdh->elf.root.type == bfd_link_hash_defweak)
4868 && eh->elf.root.type == bfd_link_hash_undefined)
4869 {
4870 eh->elf.root.type = bfd_link_hash_undefweak;
4871 eh->was_undefined = 1;
4872 htab->twiddled_syms = 1;
4873 }
4874 }
4875
4876 return TRUE;
4877 }
4878
4879 /* Process list of dot-symbols we made in link_hash_newfunc. */
4880
4881 static bfd_boolean
4882 ppc64_elf_process_dot_syms (bfd *ibfd, struct bfd_link_info *info)
4883 {
4884 struct ppc_link_hash_table *htab;
4885 struct ppc_link_hash_entry **p, *eh;
4886
4887 if (!is_ppc64_elf (info->output_bfd))
4888 return TRUE;
4889 htab = ppc_hash_table (info);
4890 if (htab == NULL)
4891 return FALSE;
4892
4893 if (is_ppc64_elf (ibfd))
4894 {
4895 p = &htab->dot_syms;
4896 while ((eh = *p) != NULL)
4897 {
4898 *p = NULL;
4899 if (&eh->elf == htab->elf.hgot)
4900 ;
4901 else if (htab->elf.hgot == NULL
4902 && strcmp (eh->elf.root.root.string, ".TOC.") == 0)
4903 htab->elf.hgot = &eh->elf;
4904 else if (!add_symbol_adjust (eh, info))
4905 return FALSE;
4906 p = &eh->u.next_dot_sym;
4907 }
4908 }
4909
4910 /* Clear the list for non-ppc64 input files. */
4911 p = &htab->dot_syms;
4912 while ((eh = *p) != NULL)
4913 {
4914 *p = NULL;
4915 p = &eh->u.next_dot_sym;
4916 }
4917
4918 /* We need to fix the undefs list for any syms we have twiddled to
4919 undef_weak. */
4920 if (htab->twiddled_syms)
4921 {
4922 bfd_link_repair_undef_list (&htab->elf.root);
4923 htab->twiddled_syms = 0;
4924 }
4925 return TRUE;
4926 }
4927
4928 /* Undo hash table changes when an --as-needed input file is determined
4929 not to be needed. */
4930
4931 static bfd_boolean
4932 ppc64_elf_notice_as_needed (bfd *ibfd,
4933 struct bfd_link_info *info,
4934 enum notice_asneeded_action act)
4935 {
4936 if (act == notice_not_needed)
4937 {
4938 struct ppc_link_hash_table *htab = ppc_hash_table (info);
4939
4940 if (htab == NULL)
4941 return FALSE;
4942
4943 htab->dot_syms = NULL;
4944 }
4945 return _bfd_elf_notice_as_needed (ibfd, info, act);
4946 }
4947
4948 /* If --just-symbols against a final linked binary, then assume we need
4949 toc adjusting stubs when calling functions defined there. */
4950
4951 static void
4952 ppc64_elf_link_just_syms (asection *sec, struct bfd_link_info *info)
4953 {
4954 if ((sec->flags & SEC_CODE) != 0
4955 && (sec->owner->flags & (EXEC_P | DYNAMIC)) != 0
4956 && is_ppc64_elf (sec->owner))
4957 {
4958 asection *got = bfd_get_section_by_name (sec->owner, ".got");
4959 if (got != NULL
4960 && got->size >= elf_backend_got_header_size
4961 && bfd_get_section_by_name (sec->owner, ".opd") != NULL)
4962 sec->has_toc_reloc = 1;
4963 }
4964 _bfd_elf_link_just_syms (sec, info);
4965 }
4966
4967 static struct plt_entry **
4968 update_local_sym_info (bfd *abfd, Elf_Internal_Shdr *symtab_hdr,
4969 unsigned long r_symndx, bfd_vma r_addend, int tls_type)
4970 {
4971 struct got_entry **local_got_ents = elf_local_got_ents (abfd);
4972 struct plt_entry **local_plt;
4973 unsigned char *local_got_tls_masks;
4974
4975 if (local_got_ents == NULL)
4976 {
4977 bfd_size_type size = symtab_hdr->sh_info;
4978
4979 size *= (sizeof (*local_got_ents)
4980 + sizeof (*local_plt)
4981 + sizeof (*local_got_tls_masks));
4982 local_got_ents = bfd_zalloc (abfd, size);
4983 if (local_got_ents == NULL)
4984 return NULL;
4985 elf_local_got_ents (abfd) = local_got_ents;
4986 }
4987
4988 if ((tls_type & (PLT_IFUNC | TLS_EXPLICIT)) == 0)
4989 {
4990 struct got_entry *ent;
4991
4992 for (ent = local_got_ents[r_symndx]; ent != NULL; ent = ent->next)
4993 if (ent->addend == r_addend
4994 && ent->owner == abfd
4995 && ent->tls_type == tls_type)
4996 break;
4997 if (ent == NULL)
4998 {
4999 bfd_size_type amt = sizeof (*ent);
5000 ent = bfd_alloc (abfd, amt);
5001 if (ent == NULL)
5002 return FALSE;
5003 ent->next = local_got_ents[r_symndx];
5004 ent->addend = r_addend;
5005 ent->owner = abfd;
5006 ent->tls_type = tls_type;
5007 ent->is_indirect = FALSE;
5008 ent->got.refcount = 0;
5009 local_got_ents[r_symndx] = ent;
5010 }
5011 ent->got.refcount += 1;
5012 }
5013
5014 local_plt = (struct plt_entry **) (local_got_ents + symtab_hdr->sh_info);
5015 local_got_tls_masks = (unsigned char *) (local_plt + symtab_hdr->sh_info);
5016 local_got_tls_masks[r_symndx] |= tls_type;
5017
5018 return local_plt + r_symndx;
5019 }
5020
5021 static bfd_boolean
5022 update_plt_info (bfd *abfd, struct plt_entry **plist, bfd_vma addend)
5023 {
5024 struct plt_entry *ent;
5025
5026 for (ent = *plist; ent != NULL; ent = ent->next)
5027 if (ent->addend == addend)
5028 break;
5029 if (ent == NULL)
5030 {
5031 bfd_size_type amt = sizeof (*ent);
5032 ent = bfd_alloc (abfd, amt);
5033 if (ent == NULL)
5034 return FALSE;
5035 ent->next = *plist;
5036 ent->addend = addend;
5037 ent->plt.refcount = 0;
5038 *plist = ent;
5039 }
5040 ent->plt.refcount += 1;
5041 return TRUE;
5042 }
5043
5044 static bfd_boolean
5045 is_branch_reloc (enum elf_ppc64_reloc_type r_type)
5046 {
5047 return (r_type == R_PPC64_REL24
5048 || r_type == R_PPC64_REL14
5049 || r_type == R_PPC64_REL14_BRTAKEN
5050 || r_type == R_PPC64_REL14_BRNTAKEN
5051 || r_type == R_PPC64_ADDR24
5052 || r_type == R_PPC64_ADDR14
5053 || r_type == R_PPC64_ADDR14_BRTAKEN
5054 || r_type == R_PPC64_ADDR14_BRNTAKEN);
5055 }
5056
5057 /* Look through the relocs for a section during the first phase, and
5058 calculate needed space in the global offset table, procedure
5059 linkage table, and dynamic reloc sections. */
5060
5061 static bfd_boolean
5062 ppc64_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
5063 asection *sec, const Elf_Internal_Rela *relocs)
5064 {
5065 struct ppc_link_hash_table *htab;
5066 Elf_Internal_Shdr *symtab_hdr;
5067 struct elf_link_hash_entry **sym_hashes;
5068 const Elf_Internal_Rela *rel;
5069 const Elf_Internal_Rela *rel_end;
5070 asection *sreloc;
5071 asection **opd_sym_map;
5072 struct elf_link_hash_entry *tga, *dottga;
5073
5074 if (info->relocatable)
5075 return TRUE;
5076
5077 /* Don't do anything special with non-loaded, non-alloced sections.
5078 In particular, any relocs in such sections should not affect GOT
5079 and PLT reference counting (ie. we don't allow them to create GOT
5080 or PLT entries), there's no possibility or desire to optimize TLS
5081 relocs, and there's not much point in propagating relocs to shared
5082 libs that the dynamic linker won't relocate. */
5083 if ((sec->flags & SEC_ALLOC) == 0)
5084 return TRUE;
5085
5086 BFD_ASSERT (is_ppc64_elf (abfd));
5087
5088 htab = ppc_hash_table (info);
5089 if (htab == NULL)
5090 return FALSE;
5091
5092 tga = elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
5093 FALSE, FALSE, TRUE);
5094 dottga = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
5095 FALSE, FALSE, TRUE);
5096 symtab_hdr = &elf_symtab_hdr (abfd);
5097 sym_hashes = elf_sym_hashes (abfd);
5098 sreloc = NULL;
5099 opd_sym_map = NULL;
5100 if (strcmp (sec->name, ".opd") == 0)
5101 {
5102 /* Garbage collection needs some extra help with .opd sections.
5103 We don't want to necessarily keep everything referenced by
5104 relocs in .opd, as that would keep all functions. Instead,
5105 if we reference an .opd symbol (a function descriptor), we
5106 want to keep the function code symbol's section. This is
5107 easy for global symbols, but for local syms we need to keep
5108 information about the associated function section. */
5109 bfd_size_type amt;
5110
5111 if (abiversion (abfd) == 0)
5112 set_abiversion (abfd, 1);
5113 else if (abiversion (abfd) == 2)
5114 {
5115 info->callbacks->einfo (_("%P: .opd not allowed in ABI version %d\n"),
5116 abiversion (abfd));
5117 bfd_set_error (bfd_error_bad_value);
5118 return FALSE;
5119 }
5120 amt = sec->size * sizeof (*opd_sym_map) / 8;
5121 opd_sym_map = bfd_zalloc (abfd, amt);
5122 if (opd_sym_map == NULL)
5123 return FALSE;
5124 ppc64_elf_section_data (sec)->u.opd.func_sec = opd_sym_map;
5125 BFD_ASSERT (ppc64_elf_section_data (sec)->sec_type == sec_normal);
5126 ppc64_elf_section_data (sec)->sec_type = sec_opd;
5127 }
5128
5129 rel_end = relocs + sec->reloc_count;
5130 for (rel = relocs; rel < rel_end; rel++)
5131 {
5132 unsigned long r_symndx;
5133 struct elf_link_hash_entry *h;
5134 enum elf_ppc64_reloc_type r_type;
5135 int tls_type;
5136 struct _ppc64_elf_section_data *ppc64_sec;
5137 struct plt_entry **ifunc;
5138
5139 r_symndx = ELF64_R_SYM (rel->r_info);
5140 if (r_symndx < symtab_hdr->sh_info)
5141 h = NULL;
5142 else
5143 {
5144 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
5145 h = elf_follow_link (h);
5146
5147 /* PR15323, ref flags aren't set for references in the same
5148 object. */
5149 h->root.non_ir_ref = 1;
5150
5151 if (h == htab->elf.hgot)
5152 sec->has_toc_reloc = 1;
5153 }
5154
5155 tls_type = 0;
5156 ifunc = NULL;
5157 if (h != NULL)
5158 {
5159 if (h->type == STT_GNU_IFUNC)
5160 {
5161 h->needs_plt = 1;
5162 ifunc = &h->plt.plist;
5163 }
5164 }
5165 else
5166 {
5167 Elf_Internal_Sym *isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5168 abfd, r_symndx);
5169 if (isym == NULL)
5170 return FALSE;
5171
5172 if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
5173 {
5174 ifunc = update_local_sym_info (abfd, symtab_hdr, r_symndx,
5175 rel->r_addend, PLT_IFUNC);
5176 if (ifunc == NULL)
5177 return FALSE;
5178 }
5179 }
5180 r_type = ELF64_R_TYPE (rel->r_info);
5181 if (is_branch_reloc (r_type))
5182 {
5183 if (h != NULL && (h == tga || h == dottga))
5184 {
5185 if (rel != relocs
5186 && (ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSGD
5187 || ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSLD))
5188 /* We have a new-style __tls_get_addr call with a marker
5189 reloc. */
5190 ;
5191 else
5192 /* Mark this section as having an old-style call. */
5193 sec->has_tls_get_addr_call = 1;
5194 }
5195
5196 /* STT_GNU_IFUNC symbols must have a PLT entry. */
5197 if (ifunc != NULL
5198 && !update_plt_info (abfd, ifunc, rel->r_addend))
5199 return FALSE;
5200 }
5201
5202 switch (r_type)
5203 {
5204 case R_PPC64_TLSGD:
5205 case R_PPC64_TLSLD:
5206 /* These special tls relocs tie a call to __tls_get_addr with
5207 its parameter symbol. */
5208 break;
5209
5210 case R_PPC64_GOT_TLSLD16:
5211 case R_PPC64_GOT_TLSLD16_LO:
5212 case R_PPC64_GOT_TLSLD16_HI:
5213 case R_PPC64_GOT_TLSLD16_HA:
5214 tls_type = TLS_TLS | TLS_LD;
5215 goto dogottls;
5216
5217 case R_PPC64_GOT_TLSGD16:
5218 case R_PPC64_GOT_TLSGD16_LO:
5219 case R_PPC64_GOT_TLSGD16_HI:
5220 case R_PPC64_GOT_TLSGD16_HA:
5221 tls_type = TLS_TLS | TLS_GD;
5222 goto dogottls;
5223
5224 case R_PPC64_GOT_TPREL16_DS:
5225 case R_PPC64_GOT_TPREL16_LO_DS:
5226 case R_PPC64_GOT_TPREL16_HI:
5227 case R_PPC64_GOT_TPREL16_HA:
5228 if (!info->executable)
5229 info->flags |= DF_STATIC_TLS;
5230 tls_type = TLS_TLS | TLS_TPREL;
5231 goto dogottls;
5232
5233 case R_PPC64_GOT_DTPREL16_DS:
5234 case R_PPC64_GOT_DTPREL16_LO_DS:
5235 case R_PPC64_GOT_DTPREL16_HI:
5236 case R_PPC64_GOT_DTPREL16_HA:
5237 tls_type = TLS_TLS | TLS_DTPREL;
5238 dogottls:
5239 sec->has_tls_reloc = 1;
5240 /* Fall thru */
5241
5242 case R_PPC64_GOT16:
5243 case R_PPC64_GOT16_DS:
5244 case R_PPC64_GOT16_HA:
5245 case R_PPC64_GOT16_HI:
5246 case R_PPC64_GOT16_LO:
5247 case R_PPC64_GOT16_LO_DS:
5248 /* This symbol requires a global offset table entry. */
5249 sec->has_toc_reloc = 1;
5250 if (r_type == R_PPC64_GOT_TLSLD16
5251 || r_type == R_PPC64_GOT_TLSGD16
5252 || r_type == R_PPC64_GOT_TPREL16_DS
5253 || r_type == R_PPC64_GOT_DTPREL16_DS
5254 || r_type == R_PPC64_GOT16
5255 || r_type == R_PPC64_GOT16_DS)
5256 {
5257 htab->do_multi_toc = 1;
5258 ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5259 }
5260
5261 if (ppc64_elf_tdata (abfd)->got == NULL
5262 && !create_got_section (abfd, info))
5263 return FALSE;
5264
5265 if (h != NULL)
5266 {
5267 struct ppc_link_hash_entry *eh;
5268 struct got_entry *ent;
5269
5270 eh = (struct ppc_link_hash_entry *) h;
5271 for (ent = eh->elf.got.glist; ent != NULL; ent = ent->next)
5272 if (ent->addend == rel->r_addend
5273 && ent->owner == abfd
5274 && ent->tls_type == tls_type)
5275 break;
5276 if (ent == NULL)
5277 {
5278 bfd_size_type amt = sizeof (*ent);
5279 ent = bfd_alloc (abfd, amt);
5280 if (ent == NULL)
5281 return FALSE;
5282 ent->next = eh->elf.got.glist;
5283 ent->addend = rel->r_addend;
5284 ent->owner = abfd;
5285 ent->tls_type = tls_type;
5286 ent->is_indirect = FALSE;
5287 ent->got.refcount = 0;
5288 eh->elf.got.glist = ent;
5289 }
5290 ent->got.refcount += 1;
5291 eh->tls_mask |= tls_type;
5292 }
5293 else
5294 /* This is a global offset table entry for a local symbol. */
5295 if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5296 rel->r_addend, tls_type))
5297 return FALSE;
5298 break;
5299
5300 case R_PPC64_PLT16_HA:
5301 case R_PPC64_PLT16_HI:
5302 case R_PPC64_PLT16_LO:
5303 case R_PPC64_PLT32:
5304 case R_PPC64_PLT64:
5305 /* This symbol requires a procedure linkage table entry. We
5306 actually build the entry in adjust_dynamic_symbol,
5307 because this might be a case of linking PIC code without
5308 linking in any dynamic objects, in which case we don't
5309 need to generate a procedure linkage table after all. */
5310 if (h == NULL)
5311 {
5312 /* It does not make sense to have a procedure linkage
5313 table entry for a local symbol. */
5314 bfd_set_error (bfd_error_bad_value);
5315 return FALSE;
5316 }
5317 else
5318 {
5319 if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5320 return FALSE;
5321 h->needs_plt = 1;
5322 if (h->root.root.string[0] == '.'
5323 && h->root.root.string[1] != '\0')
5324 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5325 }
5326 break;
5327
5328 /* The following relocations don't need to propagate the
5329 relocation if linking a shared object since they are
5330 section relative. */
5331 case R_PPC64_SECTOFF:
5332 case R_PPC64_SECTOFF_LO:
5333 case R_PPC64_SECTOFF_HI:
5334 case R_PPC64_SECTOFF_HA:
5335 case R_PPC64_SECTOFF_DS:
5336 case R_PPC64_SECTOFF_LO_DS:
5337 case R_PPC64_DTPREL16:
5338 case R_PPC64_DTPREL16_LO:
5339 case R_PPC64_DTPREL16_HI:
5340 case R_PPC64_DTPREL16_HA:
5341 case R_PPC64_DTPREL16_DS:
5342 case R_PPC64_DTPREL16_LO_DS:
5343 case R_PPC64_DTPREL16_HIGH:
5344 case R_PPC64_DTPREL16_HIGHA:
5345 case R_PPC64_DTPREL16_HIGHER:
5346 case R_PPC64_DTPREL16_HIGHERA:
5347 case R_PPC64_DTPREL16_HIGHEST:
5348 case R_PPC64_DTPREL16_HIGHESTA:
5349 break;
5350
5351 /* Nor do these. */
5352 case R_PPC64_REL16:
5353 case R_PPC64_REL16_LO:
5354 case R_PPC64_REL16_HI:
5355 case R_PPC64_REL16_HA:
5356 break;
5357
5358 case R_PPC64_TOC16:
5359 case R_PPC64_TOC16_DS:
5360 htab->do_multi_toc = 1;
5361 ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5362 case R_PPC64_TOC16_LO:
5363 case R_PPC64_TOC16_HI:
5364 case R_PPC64_TOC16_HA:
5365 case R_PPC64_TOC16_LO_DS:
5366 sec->has_toc_reloc = 1;
5367 break;
5368
5369 /* This relocation describes the C++ object vtable hierarchy.
5370 Reconstruct it for later use during GC. */
5371 case R_PPC64_GNU_VTINHERIT:
5372 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
5373 return FALSE;
5374 break;
5375
5376 /* This relocation describes which C++ vtable entries are actually
5377 used. Record for later use during GC. */
5378 case R_PPC64_GNU_VTENTRY:
5379 BFD_ASSERT (h != NULL);
5380 if (h != NULL
5381 && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
5382 return FALSE;
5383 break;
5384
5385 case R_PPC64_REL14:
5386 case R_PPC64_REL14_BRTAKEN:
5387 case R_PPC64_REL14_BRNTAKEN:
5388 {
5389 asection *dest = NULL;
5390
5391 /* Heuristic: If jumping outside our section, chances are
5392 we are going to need a stub. */
5393 if (h != NULL)
5394 {
5395 /* If the sym is weak it may be overridden later, so
5396 don't assume we know where a weak sym lives. */
5397 if (h->root.type == bfd_link_hash_defined)
5398 dest = h->root.u.def.section;
5399 }
5400 else
5401 {
5402 Elf_Internal_Sym *isym;
5403
5404 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5405 abfd, r_symndx);
5406 if (isym == NULL)
5407 return FALSE;
5408
5409 dest = bfd_section_from_elf_index (abfd, isym->st_shndx);
5410 }
5411
5412 if (dest != sec)
5413 ppc64_elf_section_data (sec)->has_14bit_branch = 1;
5414 }
5415 /* Fall through. */
5416
5417 case R_PPC64_REL24:
5418 if (h != NULL && ifunc == NULL)
5419 {
5420 /* We may need a .plt entry if the function this reloc
5421 refers to is in a shared lib. */
5422 if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5423 return FALSE;
5424 h->needs_plt = 1;
5425 if (h->root.root.string[0] == '.'
5426 && h->root.root.string[1] != '\0')
5427 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5428 if (h == tga || h == dottga)
5429 sec->has_tls_reloc = 1;
5430 }
5431 break;
5432
5433 case R_PPC64_TPREL64:
5434 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_TPREL;
5435 if (!info->executable)
5436 info->flags |= DF_STATIC_TLS;
5437 goto dotlstoc;
5438
5439 case R_PPC64_DTPMOD64:
5440 if (rel + 1 < rel_end
5441 && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
5442 && rel[1].r_offset == rel->r_offset + 8)
5443 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_GD;
5444 else
5445 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_LD;
5446 goto dotlstoc;
5447
5448 case R_PPC64_DTPREL64:
5449 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_DTPREL;
5450 if (rel != relocs
5451 && rel[-1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPMOD64)
5452 && rel[-1].r_offset == rel->r_offset - 8)
5453 /* This is the second reloc of a dtpmod, dtprel pair.
5454 Don't mark with TLS_DTPREL. */
5455 goto dodyn;
5456
5457 dotlstoc:
5458 sec->has_tls_reloc = 1;
5459 if (h != NULL)
5460 {
5461 struct ppc_link_hash_entry *eh;
5462 eh = (struct ppc_link_hash_entry *) h;
5463 eh->tls_mask |= tls_type;
5464 }
5465 else
5466 if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5467 rel->r_addend, tls_type))
5468 return FALSE;
5469
5470 ppc64_sec = ppc64_elf_section_data (sec);
5471 if (ppc64_sec->sec_type != sec_toc)
5472 {
5473 bfd_size_type amt;
5474
5475 /* One extra to simplify get_tls_mask. */
5476 amt = sec->size * sizeof (unsigned) / 8 + sizeof (unsigned);
5477 ppc64_sec->u.toc.symndx = bfd_zalloc (abfd, amt);
5478 if (ppc64_sec->u.toc.symndx == NULL)
5479 return FALSE;
5480 amt = sec->size * sizeof (bfd_vma) / 8;
5481 ppc64_sec->u.toc.add = bfd_zalloc (abfd, amt);
5482 if (ppc64_sec->u.toc.add == NULL)
5483 return FALSE;
5484 BFD_ASSERT (ppc64_sec->sec_type == sec_normal);
5485 ppc64_sec->sec_type = sec_toc;
5486 }
5487 BFD_ASSERT (rel->r_offset % 8 == 0);
5488 ppc64_sec->u.toc.symndx[rel->r_offset / 8] = r_symndx;
5489 ppc64_sec->u.toc.add[rel->r_offset / 8] = rel->r_addend;
5490
5491 /* Mark the second slot of a GD or LD entry.
5492 -1 to indicate GD and -2 to indicate LD. */
5493 if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_GD))
5494 ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -1;
5495 else if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_LD))
5496 ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -2;
5497 goto dodyn;
5498
5499 case R_PPC64_TPREL16:
5500 case R_PPC64_TPREL16_LO:
5501 case R_PPC64_TPREL16_HI:
5502 case R_PPC64_TPREL16_HA:
5503 case R_PPC64_TPREL16_DS:
5504 case R_PPC64_TPREL16_LO_DS:
5505 case R_PPC64_TPREL16_HIGH:
5506 case R_PPC64_TPREL16_HIGHA:
5507 case R_PPC64_TPREL16_HIGHER:
5508 case R_PPC64_TPREL16_HIGHERA:
5509 case R_PPC64_TPREL16_HIGHEST:
5510 case R_PPC64_TPREL16_HIGHESTA:
5511 if (info->shared)
5512 {
5513 if (!info->executable)
5514 info->flags |= DF_STATIC_TLS;
5515 goto dodyn;
5516 }
5517 break;
5518
5519 case R_PPC64_ADDR64:
5520 if (opd_sym_map != NULL
5521 && rel + 1 < rel_end
5522 && ELF64_R_TYPE ((rel + 1)->r_info) == R_PPC64_TOC)
5523 {
5524 if (h != NULL)
5525 {
5526 if (h->root.root.string[0] == '.'
5527 && h->root.root.string[1] != 0
5528 && lookup_fdh ((struct ppc_link_hash_entry *) h, htab))
5529 ;
5530 else
5531 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5532 }
5533 else
5534 {
5535 asection *s;
5536 Elf_Internal_Sym *isym;
5537
5538 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5539 abfd, r_symndx);
5540 if (isym == NULL)
5541 return FALSE;
5542
5543 s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5544 if (s != NULL && s != sec)
5545 opd_sym_map[rel->r_offset / 8] = s;
5546 }
5547 }
5548 /* Fall through. */
5549
5550 case R_PPC64_REL30:
5551 case R_PPC64_REL32:
5552 case R_PPC64_REL64:
5553 case R_PPC64_ADDR14:
5554 case R_PPC64_ADDR14_BRNTAKEN:
5555 case R_PPC64_ADDR14_BRTAKEN:
5556 case R_PPC64_ADDR16:
5557 case R_PPC64_ADDR16_DS:
5558 case R_PPC64_ADDR16_HA:
5559 case R_PPC64_ADDR16_HI:
5560 case R_PPC64_ADDR16_HIGH:
5561 case R_PPC64_ADDR16_HIGHA:
5562 case R_PPC64_ADDR16_HIGHER:
5563 case R_PPC64_ADDR16_HIGHERA:
5564 case R_PPC64_ADDR16_HIGHEST:
5565 case R_PPC64_ADDR16_HIGHESTA:
5566 case R_PPC64_ADDR16_LO:
5567 case R_PPC64_ADDR16_LO_DS:
5568 case R_PPC64_ADDR24:
5569 case R_PPC64_ADDR32:
5570 case R_PPC64_UADDR16:
5571 case R_PPC64_UADDR32:
5572 case R_PPC64_UADDR64:
5573 case R_PPC64_TOC:
5574 if (h != NULL && !info->shared)
5575 /* We may need a copy reloc. */
5576 h->non_got_ref = 1;
5577
5578 /* Don't propagate .opd relocs. */
5579 if (NO_OPD_RELOCS && opd_sym_map != NULL)
5580 break;
5581
5582 /* If we are creating a shared library, and this is a reloc
5583 against a global symbol, or a non PC relative reloc
5584 against a local symbol, then we need to copy the reloc
5585 into the shared library. However, if we are linking with
5586 -Bsymbolic, we do not need to copy a reloc against a
5587 global symbol which is defined in an object we are
5588 including in the link (i.e., DEF_REGULAR is set). At
5589 this point we have not seen all the input files, so it is
5590 possible that DEF_REGULAR is not set now but will be set
5591 later (it is never cleared). In case of a weak definition,
5592 DEF_REGULAR may be cleared later by a strong definition in
5593 a shared library. We account for that possibility below by
5594 storing information in the dyn_relocs field of the hash
5595 table entry. A similar situation occurs when creating
5596 shared libraries and symbol visibility changes render the
5597 symbol local.
5598
5599 If on the other hand, we are creating an executable, we
5600 may need to keep relocations for symbols satisfied by a
5601 dynamic library if we manage to avoid copy relocs for the
5602 symbol. */
5603 dodyn:
5604 if ((info->shared
5605 && (must_be_dyn_reloc (info, r_type)
5606 || (h != NULL
5607 && (!SYMBOLIC_BIND (info, h)
5608 || h->root.type == bfd_link_hash_defweak
5609 || !h->def_regular))))
5610 || (ELIMINATE_COPY_RELOCS
5611 && !info->shared
5612 && h != NULL
5613 && (h->root.type == bfd_link_hash_defweak
5614 || !h->def_regular))
5615 || (!info->shared
5616 && ifunc != NULL))
5617 {
5618 /* We must copy these reloc types into the output file.
5619 Create a reloc section in dynobj and make room for
5620 this reloc. */
5621 if (sreloc == NULL)
5622 {
5623 sreloc = _bfd_elf_make_dynamic_reloc_section
5624 (sec, htab->elf.dynobj, 3, abfd, /*rela?*/ TRUE);
5625
5626 if (sreloc == NULL)
5627 return FALSE;
5628 }
5629
5630 /* If this is a global symbol, we count the number of
5631 relocations we need for this symbol. */
5632 if (h != NULL)
5633 {
5634 struct elf_dyn_relocs *p;
5635 struct elf_dyn_relocs **head;
5636
5637 head = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
5638 p = *head;
5639 if (p == NULL || p->sec != sec)
5640 {
5641 p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5642 if (p == NULL)
5643 return FALSE;
5644 p->next = *head;
5645 *head = p;
5646 p->sec = sec;
5647 p->count = 0;
5648 p->pc_count = 0;
5649 }
5650 p->count += 1;
5651 if (!must_be_dyn_reloc (info, r_type))
5652 p->pc_count += 1;
5653 }
5654 else
5655 {
5656 /* Track dynamic relocs needed for local syms too.
5657 We really need local syms available to do this
5658 easily. Oh well. */
5659 struct ppc_dyn_relocs *p;
5660 struct ppc_dyn_relocs **head;
5661 bfd_boolean is_ifunc;
5662 asection *s;
5663 void *vpp;
5664 Elf_Internal_Sym *isym;
5665
5666 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5667 abfd, r_symndx);
5668 if (isym == NULL)
5669 return FALSE;
5670
5671 s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5672 if (s == NULL)
5673 s = sec;
5674
5675 vpp = &elf_section_data (s)->local_dynrel;
5676 head = (struct ppc_dyn_relocs **) vpp;
5677 is_ifunc = ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC;
5678 p = *head;
5679 if (p != NULL && p->sec == sec && p->ifunc != is_ifunc)
5680 p = p->next;
5681 if (p == NULL || p->sec != sec || p->ifunc != is_ifunc)
5682 {
5683 p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5684 if (p == NULL)
5685 return FALSE;
5686 p->next = *head;
5687 *head = p;
5688 p->sec = sec;
5689 p->ifunc = is_ifunc;
5690 p->count = 0;
5691 }
5692 p->count += 1;
5693 }
5694 }
5695 break;
5696
5697 default:
5698 break;
5699 }
5700 }
5701
5702 return TRUE;
5703 }
5704
5705 /* Merge backend specific data from an object file to the output
5706 object file when linking. */
5707
5708 static bfd_boolean
5709 ppc64_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
5710 {
5711 unsigned long iflags, oflags;
5712
5713 if ((ibfd->flags & BFD_LINKER_CREATED) != 0)
5714 return TRUE;
5715
5716 if (!is_ppc64_elf (ibfd) || !is_ppc64_elf (obfd))
5717 return TRUE;
5718
5719 if (!_bfd_generic_verify_endian_match (ibfd, obfd))
5720 return FALSE;
5721
5722 iflags = elf_elfheader (ibfd)->e_flags;
5723 oflags = elf_elfheader (obfd)->e_flags;
5724
5725 if (!elf_flags_init (obfd) || oflags == 0)
5726 {
5727 elf_flags_init (obfd) = TRUE;
5728 elf_elfheader (obfd)->e_flags = iflags;
5729 }
5730 else if (iflags == oflags || iflags == 0)
5731 ;
5732 else if (iflags & ~EF_PPC64_ABI)
5733 {
5734 (*_bfd_error_handler)
5735 (_("%B uses unknown e_flags 0x%lx"), ibfd, iflags);
5736 bfd_set_error (bfd_error_bad_value);
5737 return FALSE;
5738 }
5739 else
5740 {
5741 (*_bfd_error_handler)
5742 (_("%B: ABI version %ld is not compatible with ABI version %ld output"),
5743 ibfd, iflags, oflags);
5744 bfd_set_error (bfd_error_bad_value);
5745 return FALSE;
5746 }
5747
5748 /* Merge Tag_compatibility attributes and any common GNU ones. */
5749 _bfd_elf_merge_object_attributes (ibfd, obfd);
5750
5751 return TRUE;
5752 }
5753
5754 static bfd_boolean
5755 ppc64_elf_print_private_bfd_data (bfd *abfd, void *ptr)
5756 {
5757 /* Print normal ELF private data. */
5758 _bfd_elf_print_private_bfd_data (abfd, ptr);
5759
5760 if (elf_elfheader (abfd)->e_flags != 0)
5761 {
5762 FILE *file = ptr;
5763
5764 /* xgettext:c-format */
5765 fprintf (file, _("private flags = 0x%lx:"),
5766 elf_elfheader (abfd)->e_flags);
5767
5768 if ((elf_elfheader (abfd)->e_flags & EF_PPC64_ABI) != 0)
5769 fprintf (file, _(" [abiv%ld]"),
5770 elf_elfheader (abfd)->e_flags & EF_PPC64_ABI);
5771 fputc ('\n', file);
5772 }
5773
5774 return TRUE;
5775 }
5776
5777 /* OFFSET in OPD_SEC specifies a function descriptor. Return the address
5778 of the code entry point, and its section. */
5779
5780 static bfd_vma
5781 opd_entry_value (asection *opd_sec,
5782 bfd_vma offset,
5783 asection **code_sec,
5784 bfd_vma *code_off,
5785 bfd_boolean in_code_sec)
5786 {
5787 bfd *opd_bfd = opd_sec->owner;
5788 Elf_Internal_Rela *relocs;
5789 Elf_Internal_Rela *lo, *hi, *look;
5790 bfd_vma val;
5791
5792 /* No relocs implies we are linking a --just-symbols object, or looking
5793 at a final linked executable with addr2line or somesuch. */
5794 if (opd_sec->reloc_count == 0)
5795 {
5796 bfd_byte *contents = ppc64_elf_tdata (opd_bfd)->opd.contents;
5797
5798 if (contents == NULL)
5799 {
5800 if (!bfd_malloc_and_get_section (opd_bfd, opd_sec, &contents))
5801 return (bfd_vma) -1;
5802 ppc64_elf_tdata (opd_bfd)->opd.contents = contents;
5803 }
5804
5805 val = bfd_get_64 (opd_bfd, contents + offset);
5806 if (code_sec != NULL)
5807 {
5808 asection *sec, *likely = NULL;
5809
5810 if (in_code_sec)
5811 {
5812 sec = *code_sec;
5813 if (sec->vma <= val
5814 && val < sec->vma + sec->size)
5815 likely = sec;
5816 else
5817 val = -1;
5818 }
5819 else
5820 for (sec = opd_bfd->sections; sec != NULL; sec = sec->next)
5821 if (sec->vma <= val
5822 && (sec->flags & SEC_LOAD) != 0
5823 && (sec->flags & SEC_ALLOC) != 0)
5824 likely = sec;
5825 if (likely != NULL)
5826 {
5827 *code_sec = likely;
5828 if (code_off != NULL)
5829 *code_off = val - likely->vma;
5830 }
5831 }
5832 return val;
5833 }
5834
5835 BFD_ASSERT (is_ppc64_elf (opd_bfd));
5836
5837 relocs = ppc64_elf_tdata (opd_bfd)->opd.relocs;
5838 if (relocs == NULL)
5839 relocs = _bfd_elf_link_read_relocs (opd_bfd, opd_sec, NULL, NULL, TRUE);
5840
5841 /* Go find the opd reloc at the sym address. */
5842 lo = relocs;
5843 BFD_ASSERT (lo != NULL);
5844 hi = lo + opd_sec->reloc_count - 1; /* ignore last reloc */
5845 val = (bfd_vma) -1;
5846 while (lo < hi)
5847 {
5848 look = lo + (hi - lo) / 2;
5849 if (look->r_offset < offset)
5850 lo = look + 1;
5851 else if (look->r_offset > offset)
5852 hi = look;
5853 else
5854 {
5855 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (opd_bfd);
5856
5857 if (ELF64_R_TYPE (look->r_info) == R_PPC64_ADDR64
5858 && ELF64_R_TYPE ((look + 1)->r_info) == R_PPC64_TOC)
5859 {
5860 unsigned long symndx = ELF64_R_SYM (look->r_info);
5861 asection *sec;
5862
5863 if (symndx < symtab_hdr->sh_info
5864 || elf_sym_hashes (opd_bfd) == NULL)
5865 {
5866 Elf_Internal_Sym *sym;
5867
5868 sym = (Elf_Internal_Sym *) symtab_hdr->contents;
5869 if (sym == NULL)
5870 {
5871 size_t symcnt = symtab_hdr->sh_info;
5872 if (elf_sym_hashes (opd_bfd) == NULL)
5873 symcnt = symtab_hdr->sh_size / symtab_hdr->sh_entsize;
5874 sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr, symcnt,
5875 0, NULL, NULL, NULL);
5876 if (sym == NULL)
5877 break;
5878 symtab_hdr->contents = (bfd_byte *) sym;
5879 }
5880
5881 sym += symndx;
5882 val = sym->st_value;
5883 sec = bfd_section_from_elf_index (opd_bfd, sym->st_shndx);
5884 BFD_ASSERT ((sec->flags & SEC_MERGE) == 0);
5885 }
5886 else
5887 {
5888 struct elf_link_hash_entry **sym_hashes;
5889 struct elf_link_hash_entry *rh;
5890
5891 sym_hashes = elf_sym_hashes (opd_bfd);
5892 rh = sym_hashes[symndx - symtab_hdr->sh_info];
5893 if (rh != NULL)
5894 {
5895 rh = elf_follow_link (rh);
5896 BFD_ASSERT (rh->root.type == bfd_link_hash_defined
5897 || rh->root.type == bfd_link_hash_defweak);
5898 val = rh->root.u.def.value;
5899 sec = rh->root.u.def.section;
5900 }
5901 else
5902 {
5903 /* Handle the odd case where we can be called
5904 during bfd_elf_link_add_symbols before the
5905 symbol hashes have been fully populated. */
5906 Elf_Internal_Sym *sym;
5907
5908 sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr, 1,
5909 symndx, NULL, NULL, NULL);
5910 if (sym == NULL)
5911 break;
5912
5913 val = sym->st_value;
5914 sec = bfd_section_from_elf_index (opd_bfd, sym->st_shndx);
5915 free (sym);
5916 }
5917 }
5918 val += look->r_addend;
5919 if (code_off != NULL)
5920 *code_off = val;
5921 if (code_sec != NULL)
5922 {
5923 if (in_code_sec && *code_sec != sec)
5924 return -1;
5925 else
5926 *code_sec = sec;
5927 }
5928 if (sec != NULL && sec->output_section != NULL)
5929 val += sec->output_section->vma + sec->output_offset;
5930 }
5931 break;
5932 }
5933 }
5934
5935 return val;
5936 }
5937
5938 /* If the ELF symbol SYM might be a function in SEC, return the
5939 function size and set *CODE_OFF to the function's entry point,
5940 otherwise return zero. */
5941
5942 static bfd_size_type
5943 ppc64_elf_maybe_function_sym (const asymbol *sym, asection *sec,
5944 bfd_vma *code_off)
5945 {
5946 bfd_size_type size;
5947
5948 if ((sym->flags & (BSF_SECTION_SYM | BSF_FILE | BSF_OBJECT
5949 | BSF_THREAD_LOCAL | BSF_RELC | BSF_SRELC)) != 0)
5950 return 0;
5951
5952 size = 0;
5953 if (!(sym->flags & BSF_SYNTHETIC))
5954 size = ((elf_symbol_type *) sym)->internal_elf_sym.st_size;
5955
5956 if (strcmp (sym->section->name, ".opd") == 0)
5957 {
5958 if (opd_entry_value (sym->section, sym->value,
5959 &sec, code_off, TRUE) == (bfd_vma) -1)
5960 return 0;
5961 /* An old ABI binary with dot-syms has a size of 24 on the .opd
5962 symbol. This size has nothing to do with the code size of the
5963 function, which is what we're supposed to return, but the
5964 code size isn't available without looking up the dot-sym.
5965 However, doing that would be a waste of time particularly
5966 since elf_find_function will look at the dot-sym anyway.
5967 Now, elf_find_function will keep the largest size of any
5968 function sym found at the code address of interest, so return
5969 1 here to avoid it incorrectly caching a larger function size
5970 for a small function. This does mean we return the wrong
5971 size for a new-ABI function of size 24, but all that does is
5972 disable caching for such functions. */
5973 if (size == 24)
5974 size = 1;
5975 }
5976 else
5977 {
5978 if (sym->section != sec)
5979 return 0;
5980 *code_off = sym->value;
5981 }
5982 if (size == 0)
5983 size = 1;
5984 return size;
5985 }
5986
5987 /* Return true if symbol is defined in a regular object file. */
5988
5989 static bfd_boolean
5990 is_static_defined (struct elf_link_hash_entry *h)
5991 {
5992 return ((h->root.type == bfd_link_hash_defined
5993 || h->root.type == bfd_link_hash_defweak)
5994 && h->root.u.def.section != NULL
5995 && h->root.u.def.section->output_section != NULL);
5996 }
5997
5998 /* If FDH is a function descriptor symbol, return the associated code
5999 entry symbol if it is defined. Return NULL otherwise. */
6000
6001 static struct ppc_link_hash_entry *
6002 defined_code_entry (struct ppc_link_hash_entry *fdh)
6003 {
6004 if (fdh->is_func_descriptor)
6005 {
6006 struct ppc_link_hash_entry *fh = ppc_follow_link (fdh->oh);
6007 if (fh->elf.root.type == bfd_link_hash_defined
6008 || fh->elf.root.type == bfd_link_hash_defweak)
6009 return fh;
6010 }
6011 return NULL;
6012 }
6013
6014 /* If FH is a function code entry symbol, return the associated
6015 function descriptor symbol if it is defined. Return NULL otherwise. */
6016
6017 static struct ppc_link_hash_entry *
6018 defined_func_desc (struct ppc_link_hash_entry *fh)
6019 {
6020 if (fh->oh != NULL
6021 && fh->oh->is_func_descriptor)
6022 {
6023 struct ppc_link_hash_entry *fdh = ppc_follow_link (fh->oh);
6024 if (fdh->elf.root.type == bfd_link_hash_defined
6025 || fdh->elf.root.type == bfd_link_hash_defweak)
6026 return fdh;
6027 }
6028 return NULL;
6029 }
6030
6031 /* Mark all our entry sym sections, both opd and code section. */
6032
6033 static void
6034 ppc64_elf_gc_keep (struct bfd_link_info *info)
6035 {
6036 struct ppc_link_hash_table *htab = ppc_hash_table (info);
6037 struct bfd_sym_chain *sym;
6038
6039 if (htab == NULL)
6040 return;
6041
6042 for (sym = info->gc_sym_list; sym != NULL; sym = sym->next)
6043 {
6044 struct ppc_link_hash_entry *eh, *fh;
6045 asection *sec;
6046
6047 eh = (struct ppc_link_hash_entry *)
6048 elf_link_hash_lookup (&htab->elf, sym->name, FALSE, FALSE, TRUE);
6049 if (eh == NULL)
6050 continue;
6051 if (eh->elf.root.type != bfd_link_hash_defined
6052 && eh->elf.root.type != bfd_link_hash_defweak)
6053 continue;
6054
6055 fh = defined_code_entry (eh);
6056 if (fh != NULL)
6057 {
6058 sec = fh->elf.root.u.def.section;
6059 sec->flags |= SEC_KEEP;
6060 }
6061 else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6062 && opd_entry_value (eh->elf.root.u.def.section,
6063 eh->elf.root.u.def.value,
6064 &sec, NULL, FALSE) != (bfd_vma) -1)
6065 sec->flags |= SEC_KEEP;
6066
6067 sec = eh->elf.root.u.def.section;
6068 sec->flags |= SEC_KEEP;
6069 }
6070 }
6071
6072 /* Mark sections containing dynamically referenced symbols. When
6073 building shared libraries, we must assume that any visible symbol is
6074 referenced. */
6075
6076 static bfd_boolean
6077 ppc64_elf_gc_mark_dynamic_ref (struct elf_link_hash_entry *h, void *inf)
6078 {
6079 struct bfd_link_info *info = (struct bfd_link_info *) inf;
6080 struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
6081 struct ppc_link_hash_entry *fdh;
6082
6083 /* Dynamic linking info is on the func descriptor sym. */
6084 fdh = defined_func_desc (eh);
6085 if (fdh != NULL)
6086 eh = fdh;
6087
6088 if ((eh->elf.root.type == bfd_link_hash_defined
6089 || eh->elf.root.type == bfd_link_hash_defweak)
6090 && (eh->elf.ref_dynamic
6091 || (!info->executable
6092 && eh->elf.def_regular
6093 && ELF_ST_VISIBILITY (eh->elf.other) != STV_INTERNAL
6094 && ELF_ST_VISIBILITY (eh->elf.other) != STV_HIDDEN
6095 && (strchr (eh->elf.root.root.string, ELF_VER_CHR) != NULL
6096 || !bfd_hide_sym_by_version (info->version_info,
6097 eh->elf.root.root.string)))))
6098 {
6099 asection *code_sec;
6100 struct ppc_link_hash_entry *fh;
6101
6102 eh->elf.root.u.def.section->flags |= SEC_KEEP;
6103
6104 /* Function descriptor syms cause the associated
6105 function code sym section to be marked. */
6106 fh = defined_code_entry (eh);
6107 if (fh != NULL)
6108 {
6109 code_sec = fh->elf.root.u.def.section;
6110 code_sec->flags |= SEC_KEEP;
6111 }
6112 else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6113 && opd_entry_value (eh->elf.root.u.def.section,
6114 eh->elf.root.u.def.value,
6115 &code_sec, NULL, FALSE) != (bfd_vma) -1)
6116 code_sec->flags |= SEC_KEEP;
6117 }
6118
6119 return TRUE;
6120 }
6121
6122 /* Return the section that should be marked against GC for a given
6123 relocation. */
6124
6125 static asection *
6126 ppc64_elf_gc_mark_hook (asection *sec,
6127 struct bfd_link_info *info,
6128 Elf_Internal_Rela *rel,
6129 struct elf_link_hash_entry *h,
6130 Elf_Internal_Sym *sym)
6131 {
6132 asection *rsec;
6133
6134 /* Syms return NULL if we're marking .opd, so we avoid marking all
6135 function sections, as all functions are referenced in .opd. */
6136 rsec = NULL;
6137 if (get_opd_info (sec) != NULL)
6138 return rsec;
6139
6140 if (h != NULL)
6141 {
6142 enum elf_ppc64_reloc_type r_type;
6143 struct ppc_link_hash_entry *eh, *fh, *fdh;
6144
6145 r_type = ELF64_R_TYPE (rel->r_info);
6146 switch (r_type)
6147 {
6148 case R_PPC64_GNU_VTINHERIT:
6149 case R_PPC64_GNU_VTENTRY:
6150 break;
6151
6152 default:
6153 switch (h->root.type)
6154 {
6155 case bfd_link_hash_defined:
6156 case bfd_link_hash_defweak:
6157 eh = (struct ppc_link_hash_entry *) h;
6158 fdh = defined_func_desc (eh);
6159 if (fdh != NULL)
6160 eh = fdh;
6161
6162 /* Function descriptor syms cause the associated
6163 function code sym section to be marked. */
6164 fh = defined_code_entry (eh);
6165 if (fh != NULL)
6166 {
6167 /* They also mark their opd section. */
6168 eh->elf.root.u.def.section->gc_mark = 1;
6169
6170 rsec = fh->elf.root.u.def.section;
6171 }
6172 else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6173 && opd_entry_value (eh->elf.root.u.def.section,
6174 eh->elf.root.u.def.value,
6175 &rsec, NULL, FALSE) != (bfd_vma) -1)
6176 eh->elf.root.u.def.section->gc_mark = 1;
6177 else
6178 rsec = h->root.u.def.section;
6179 break;
6180
6181 case bfd_link_hash_common:
6182 rsec = h->root.u.c.p->section;
6183 break;
6184
6185 default:
6186 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
6187 }
6188 }
6189 }
6190 else
6191 {
6192 struct _opd_sec_data *opd;
6193
6194 rsec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
6195 opd = get_opd_info (rsec);
6196 if (opd != NULL && opd->func_sec != NULL)
6197 {
6198 rsec->gc_mark = 1;
6199
6200 rsec = opd->func_sec[(sym->st_value + rel->r_addend) / 8];
6201 }
6202 }
6203
6204 return rsec;
6205 }
6206
6207 /* Update the .got, .plt. and dynamic reloc reference counts for the
6208 section being removed. */
6209
6210 static bfd_boolean
6211 ppc64_elf_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info,
6212 asection *sec, const Elf_Internal_Rela *relocs)
6213 {
6214 struct ppc_link_hash_table *htab;
6215 Elf_Internal_Shdr *symtab_hdr;
6216 struct elf_link_hash_entry **sym_hashes;
6217 struct got_entry **local_got_ents;
6218 const Elf_Internal_Rela *rel, *relend;
6219
6220 if (info->relocatable)
6221 return TRUE;
6222
6223 if ((sec->flags & SEC_ALLOC) == 0)
6224 return TRUE;
6225
6226 elf_section_data (sec)->local_dynrel = NULL;
6227
6228 htab = ppc_hash_table (info);
6229 if (htab == NULL)
6230 return FALSE;
6231
6232 symtab_hdr = &elf_symtab_hdr (abfd);
6233 sym_hashes = elf_sym_hashes (abfd);
6234 local_got_ents = elf_local_got_ents (abfd);
6235
6236 relend = relocs + sec->reloc_count;
6237 for (rel = relocs; rel < relend; rel++)
6238 {
6239 unsigned long r_symndx;
6240 enum elf_ppc64_reloc_type r_type;
6241 struct elf_link_hash_entry *h = NULL;
6242 unsigned char tls_type = 0;
6243
6244 r_symndx = ELF64_R_SYM (rel->r_info);
6245 r_type = ELF64_R_TYPE (rel->r_info);
6246 if (r_symndx >= symtab_hdr->sh_info)
6247 {
6248 struct ppc_link_hash_entry *eh;
6249 struct elf_dyn_relocs **pp;
6250 struct elf_dyn_relocs *p;
6251
6252 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
6253 h = elf_follow_link (h);
6254 eh = (struct ppc_link_hash_entry *) h;
6255
6256 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
6257 if (p->sec == sec)
6258 {
6259 /* Everything must go for SEC. */
6260 *pp = p->next;
6261 break;
6262 }
6263 }
6264
6265 if (is_branch_reloc (r_type))
6266 {
6267 struct plt_entry **ifunc = NULL;
6268 if (h != NULL)
6269 {
6270 if (h->type == STT_GNU_IFUNC)
6271 ifunc = &h->plt.plist;
6272 }
6273 else if (local_got_ents != NULL)
6274 {
6275 struct plt_entry **local_plt = (struct plt_entry **)
6276 (local_got_ents + symtab_hdr->sh_info);
6277 unsigned char *local_got_tls_masks = (unsigned char *)
6278 (local_plt + symtab_hdr->sh_info);
6279 if ((local_got_tls_masks[r_symndx] & PLT_IFUNC) != 0)
6280 ifunc = local_plt + r_symndx;
6281 }
6282 if (ifunc != NULL)
6283 {
6284 struct plt_entry *ent;
6285
6286 for (ent = *ifunc; ent != NULL; ent = ent->next)
6287 if (ent->addend == rel->r_addend)
6288 break;
6289 if (ent == NULL)
6290 abort ();
6291 if (ent->plt.refcount > 0)
6292 ent->plt.refcount -= 1;
6293 continue;
6294 }
6295 }
6296
6297 switch (r_type)
6298 {
6299 case R_PPC64_GOT_TLSLD16:
6300 case R_PPC64_GOT_TLSLD16_LO:
6301 case R_PPC64_GOT_TLSLD16_HI:
6302 case R_PPC64_GOT_TLSLD16_HA:
6303 tls_type = TLS_TLS | TLS_LD;
6304 goto dogot;
6305
6306 case R_PPC64_GOT_TLSGD16:
6307 case R_PPC64_GOT_TLSGD16_LO:
6308 case R_PPC64_GOT_TLSGD16_HI:
6309 case R_PPC64_GOT_TLSGD16_HA:
6310 tls_type = TLS_TLS | TLS_GD;
6311 goto dogot;
6312
6313 case R_PPC64_GOT_TPREL16_DS:
6314 case R_PPC64_GOT_TPREL16_LO_DS:
6315 case R_PPC64_GOT_TPREL16_HI:
6316 case R_PPC64_GOT_TPREL16_HA:
6317 tls_type = TLS_TLS | TLS_TPREL;
6318 goto dogot;
6319
6320 case R_PPC64_GOT_DTPREL16_DS:
6321 case R_PPC64_GOT_DTPREL16_LO_DS:
6322 case R_PPC64_GOT_DTPREL16_HI:
6323 case R_PPC64_GOT_DTPREL16_HA:
6324 tls_type = TLS_TLS | TLS_DTPREL;
6325 goto dogot;
6326
6327 case R_PPC64_GOT16:
6328 case R_PPC64_GOT16_DS:
6329 case R_PPC64_GOT16_HA:
6330 case R_PPC64_GOT16_HI:
6331 case R_PPC64_GOT16_LO:
6332 case R_PPC64_GOT16_LO_DS:
6333 dogot:
6334 {
6335 struct got_entry *ent;
6336
6337 if (h != NULL)
6338 ent = h->got.glist;
6339 else
6340 ent = local_got_ents[r_symndx];
6341
6342 for (; ent != NULL; ent = ent->next)
6343 if (ent->addend == rel->r_addend
6344 && ent->owner == abfd
6345 && ent->tls_type == tls_type)
6346 break;
6347 if (ent == NULL)
6348 abort ();
6349 if (ent->got.refcount > 0)
6350 ent->got.refcount -= 1;
6351 }
6352 break;
6353
6354 case R_PPC64_PLT16_HA:
6355 case R_PPC64_PLT16_HI:
6356 case R_PPC64_PLT16_LO:
6357 case R_PPC64_PLT32:
6358 case R_PPC64_PLT64:
6359 case R_PPC64_REL14:
6360 case R_PPC64_REL14_BRNTAKEN:
6361 case R_PPC64_REL14_BRTAKEN:
6362 case R_PPC64_REL24:
6363 if (h != NULL)
6364 {
6365 struct plt_entry *ent;
6366
6367 for (ent = h->plt.plist; ent != NULL; ent = ent->next)
6368 if (ent->addend == rel->r_addend)
6369 break;
6370 if (ent != NULL && ent->plt.refcount > 0)
6371 ent->plt.refcount -= 1;
6372 }
6373 break;
6374
6375 default:
6376 break;
6377 }
6378 }
6379 return TRUE;
6380 }
6381
6382 /* The maximum size of .sfpr. */
6383 #define SFPR_MAX (218*4)
6384
6385 struct sfpr_def_parms
6386 {
6387 const char name[12];
6388 unsigned char lo, hi;
6389 bfd_byte * (*write_ent) (bfd *, bfd_byte *, int);
6390 bfd_byte * (*write_tail) (bfd *, bfd_byte *, int);
6391 };
6392
6393 /* Auto-generate _save*, _rest* functions in .sfpr. */
6394
6395 static bfd_boolean
6396 sfpr_define (struct bfd_link_info *info, const struct sfpr_def_parms *parm)
6397 {
6398 struct ppc_link_hash_table *htab = ppc_hash_table (info);
6399 unsigned int i;
6400 size_t len = strlen (parm->name);
6401 bfd_boolean writing = FALSE;
6402 char sym[16];
6403
6404 if (htab == NULL)
6405 return FALSE;
6406
6407 memcpy (sym, parm->name, len);
6408 sym[len + 2] = 0;
6409
6410 for (i = parm->lo; i <= parm->hi; i++)
6411 {
6412 struct elf_link_hash_entry *h;
6413
6414 sym[len + 0] = i / 10 + '0';
6415 sym[len + 1] = i % 10 + '0';
6416 h = elf_link_hash_lookup (&htab->elf, sym, FALSE, FALSE, TRUE);
6417 if (h != NULL
6418 && !h->def_regular)
6419 {
6420 h->root.type = bfd_link_hash_defined;
6421 h->root.u.def.section = htab->sfpr;
6422 h->root.u.def.value = htab->sfpr->size;
6423 h->type = STT_FUNC;
6424 h->def_regular = 1;
6425 _bfd_elf_link_hash_hide_symbol (info, h, TRUE);
6426 writing = TRUE;
6427 if (htab->sfpr->contents == NULL)
6428 {
6429 htab->sfpr->contents = bfd_alloc (htab->elf.dynobj, SFPR_MAX);
6430 if (htab->sfpr->contents == NULL)
6431 return FALSE;
6432 }
6433 }
6434 if (writing)
6435 {
6436 bfd_byte *p = htab->sfpr->contents + htab->sfpr->size;
6437 if (i != parm->hi)
6438 p = (*parm->write_ent) (htab->elf.dynobj, p, i);
6439 else
6440 p = (*parm->write_tail) (htab->elf.dynobj, p, i);
6441 htab->sfpr->size = p - htab->sfpr->contents;
6442 }
6443 }
6444
6445 return TRUE;
6446 }
6447
6448 static bfd_byte *
6449 savegpr0 (bfd *abfd, bfd_byte *p, int r)
6450 {
6451 bfd_put_32 (abfd, STD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6452 return p + 4;
6453 }
6454
6455 static bfd_byte *
6456 savegpr0_tail (bfd *abfd, bfd_byte *p, int r)
6457 {
6458 p = savegpr0 (abfd, p, r);
6459 bfd_put_32 (abfd, STD_R0_0R1 + 16, p);
6460 p = p + 4;
6461 bfd_put_32 (abfd, BLR, p);
6462 return p + 4;
6463 }
6464
6465 static bfd_byte *
6466 restgpr0 (bfd *abfd, bfd_byte *p, int r)
6467 {
6468 bfd_put_32 (abfd, LD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6469 return p + 4;
6470 }
6471
6472 static bfd_byte *
6473 restgpr0_tail (bfd *abfd, bfd_byte *p, int r)
6474 {
6475 bfd_put_32 (abfd, LD_R0_0R1 + 16, p);
6476 p = p + 4;
6477 p = restgpr0 (abfd, p, r);
6478 bfd_put_32 (abfd, MTLR_R0, p);
6479 p = p + 4;
6480 if (r == 29)
6481 {
6482 p = restgpr0 (abfd, p, 30);
6483 p = restgpr0 (abfd, p, 31);
6484 }
6485 bfd_put_32 (abfd, BLR, p);
6486 return p + 4;
6487 }
6488
6489 static bfd_byte *
6490 savegpr1 (bfd *abfd, bfd_byte *p, int r)
6491 {
6492 bfd_put_32 (abfd, STD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6493 return p + 4;
6494 }
6495
6496 static bfd_byte *
6497 savegpr1_tail (bfd *abfd, bfd_byte *p, int r)
6498 {
6499 p = savegpr1 (abfd, p, r);
6500 bfd_put_32 (abfd, BLR, p);
6501 return p + 4;
6502 }
6503
6504 static bfd_byte *
6505 restgpr1 (bfd *abfd, bfd_byte *p, int r)
6506 {
6507 bfd_put_32 (abfd, LD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6508 return p + 4;
6509 }
6510
6511 static bfd_byte *
6512 restgpr1_tail (bfd *abfd, bfd_byte *p, int r)
6513 {
6514 p = restgpr1 (abfd, p, r);
6515 bfd_put_32 (abfd, BLR, p);
6516 return p + 4;
6517 }
6518
6519 static bfd_byte *
6520 savefpr (bfd *abfd, bfd_byte *p, int r)
6521 {
6522 bfd_put_32 (abfd, STFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6523 return p + 4;
6524 }
6525
6526 static bfd_byte *
6527 savefpr0_tail (bfd *abfd, bfd_byte *p, int r)
6528 {
6529 p = savefpr (abfd, p, r);
6530 bfd_put_32 (abfd, STD_R0_0R1 + 16, p);
6531 p = p + 4;
6532 bfd_put_32 (abfd, BLR, p);
6533 return p + 4;
6534 }
6535
6536 static bfd_byte *
6537 restfpr (bfd *abfd, bfd_byte *p, int r)
6538 {
6539 bfd_put_32 (abfd, LFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6540 return p + 4;
6541 }
6542
6543 static bfd_byte *
6544 restfpr0_tail (bfd *abfd, bfd_byte *p, int r)
6545 {
6546 bfd_put_32 (abfd, LD_R0_0R1 + 16, p);
6547 p = p + 4;
6548 p = restfpr (abfd, p, r);
6549 bfd_put_32 (abfd, MTLR_R0, p);
6550 p = p + 4;
6551 if (r == 29)
6552 {
6553 p = restfpr (abfd, p, 30);
6554 p = restfpr (abfd, p, 31);
6555 }
6556 bfd_put_32 (abfd, BLR, p);
6557 return p + 4;
6558 }
6559
6560 static bfd_byte *
6561 savefpr1_tail (bfd *abfd, bfd_byte *p, int r)
6562 {
6563 p = savefpr (abfd, p, r);
6564 bfd_put_32 (abfd, BLR, p);
6565 return p + 4;
6566 }
6567
6568 static bfd_byte *
6569 restfpr1_tail (bfd *abfd, bfd_byte *p, int r)
6570 {
6571 p = restfpr (abfd, p, r);
6572 bfd_put_32 (abfd, BLR, p);
6573 return p + 4;
6574 }
6575
6576 static bfd_byte *
6577 savevr (bfd *abfd, bfd_byte *p, int r)
6578 {
6579 bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6580 p = p + 4;
6581 bfd_put_32 (abfd, STVX_VR0_R12_R0 + (r << 21), p);
6582 return p + 4;
6583 }
6584
6585 static bfd_byte *
6586 savevr_tail (bfd *abfd, bfd_byte *p, int r)
6587 {
6588 p = savevr (abfd, p, r);
6589 bfd_put_32 (abfd, BLR, p);
6590 return p + 4;
6591 }
6592
6593 static bfd_byte *
6594 restvr (bfd *abfd, bfd_byte *p, int r)
6595 {
6596 bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6597 p = p + 4;
6598 bfd_put_32 (abfd, LVX_VR0_R12_R0 + (r << 21), p);
6599 return p + 4;
6600 }
6601
6602 static bfd_byte *
6603 restvr_tail (bfd *abfd, bfd_byte *p, int r)
6604 {
6605 p = restvr (abfd, p, r);
6606 bfd_put_32 (abfd, BLR, p);
6607 return p + 4;
6608 }
6609
6610 /* Called via elf_link_hash_traverse to transfer dynamic linking
6611 information on function code symbol entries to their corresponding
6612 function descriptor symbol entries. */
6613
6614 static bfd_boolean
6615 func_desc_adjust (struct elf_link_hash_entry *h, void *inf)
6616 {
6617 struct bfd_link_info *info;
6618 struct ppc_link_hash_table *htab;
6619 struct plt_entry *ent;
6620 struct ppc_link_hash_entry *fh;
6621 struct ppc_link_hash_entry *fdh;
6622 bfd_boolean force_local;
6623
6624 fh = (struct ppc_link_hash_entry *) h;
6625 if (fh->elf.root.type == bfd_link_hash_indirect)
6626 return TRUE;
6627
6628 info = inf;
6629 htab = ppc_hash_table (info);
6630 if (htab == NULL)
6631 return FALSE;
6632
6633 /* Resolve undefined references to dot-symbols as the value
6634 in the function descriptor, if we have one in a regular object.
6635 This is to satisfy cases like ".quad .foo". Calls to functions
6636 in dynamic objects are handled elsewhere. */
6637 if (fh->elf.root.type == bfd_link_hash_undefweak
6638 && fh->was_undefined
6639 && (fdh = defined_func_desc (fh)) != NULL
6640 && get_opd_info (fdh->elf.root.u.def.section) != NULL
6641 && opd_entry_value (fdh->elf.root.u.def.section,
6642 fdh->elf.root.u.def.value,
6643 &fh->elf.root.u.def.section,
6644 &fh->elf.root.u.def.value, FALSE) != (bfd_vma) -1)
6645 {
6646 fh->elf.root.type = fdh->elf.root.type;
6647 fh->elf.forced_local = 1;
6648 fh->elf.def_regular = fdh->elf.def_regular;
6649 fh->elf.def_dynamic = fdh->elf.def_dynamic;
6650 }
6651
6652 /* If this is a function code symbol, transfer dynamic linking
6653 information to the function descriptor symbol. */
6654 if (!fh->is_func)
6655 return TRUE;
6656
6657 for (ent = fh->elf.plt.plist; ent != NULL; ent = ent->next)
6658 if (ent->plt.refcount > 0)
6659 break;
6660 if (ent == NULL
6661 || fh->elf.root.root.string[0] != '.'
6662 || fh->elf.root.root.string[1] == '\0')
6663 return TRUE;
6664
6665 /* Find the corresponding function descriptor symbol. Create it
6666 as undefined if necessary. */
6667
6668 fdh = lookup_fdh (fh, htab);
6669 if (fdh == NULL
6670 && !info->executable
6671 && (fh->elf.root.type == bfd_link_hash_undefined
6672 || fh->elf.root.type == bfd_link_hash_undefweak))
6673 {
6674 fdh = make_fdh (info, fh);
6675 if (fdh == NULL)
6676 return FALSE;
6677 }
6678
6679 /* Fake function descriptors are made undefweak. If the function
6680 code symbol is strong undefined, make the fake sym the same.
6681 If the function code symbol is defined, then force the fake
6682 descriptor local; We can't support overriding of symbols in a
6683 shared library on a fake descriptor. */
6684
6685 if (fdh != NULL
6686 && fdh->fake
6687 && fdh->elf.root.type == bfd_link_hash_undefweak)
6688 {
6689 if (fh->elf.root.type == bfd_link_hash_undefined)
6690 {
6691 fdh->elf.root.type = bfd_link_hash_undefined;
6692 bfd_link_add_undef (&htab->elf.root, &fdh->elf.root);
6693 }
6694 else if (fh->elf.root.type == bfd_link_hash_defined
6695 || fh->elf.root.type == bfd_link_hash_defweak)
6696 {
6697 _bfd_elf_link_hash_hide_symbol (info, &fdh->elf, TRUE);
6698 }
6699 }
6700
6701 if (fdh != NULL
6702 && !fdh->elf.forced_local
6703 && (!info->executable
6704 || fdh->elf.def_dynamic
6705 || fdh->elf.ref_dynamic
6706 || (fdh->elf.root.type == bfd_link_hash_undefweak
6707 && ELF_ST_VISIBILITY (fdh->elf.other) == STV_DEFAULT)))
6708 {
6709 if (fdh->elf.dynindx == -1)
6710 if (! bfd_elf_link_record_dynamic_symbol (info, &fdh->elf))
6711 return FALSE;
6712 fdh->elf.ref_regular |= fh->elf.ref_regular;
6713 fdh->elf.ref_dynamic |= fh->elf.ref_dynamic;
6714 fdh->elf.ref_regular_nonweak |= fh->elf.ref_regular_nonweak;
6715 fdh->elf.non_got_ref |= fh->elf.non_got_ref;
6716 if (ELF_ST_VISIBILITY (fh->elf.other) == STV_DEFAULT)
6717 {
6718 move_plt_plist (fh, fdh);
6719 fdh->elf.needs_plt = 1;
6720 }
6721 fdh->is_func_descriptor = 1;
6722 fdh->oh = fh;
6723 fh->oh = fdh;
6724 }
6725
6726 /* Now that the info is on the function descriptor, clear the
6727 function code sym info. Any function code syms for which we
6728 don't have a definition in a regular file, we force local.
6729 This prevents a shared library from exporting syms that have
6730 been imported from another library. Function code syms that
6731 are really in the library we must leave global to prevent the
6732 linker dragging in a definition from a static library. */
6733 force_local = (!fh->elf.def_regular
6734 || fdh == NULL
6735 || !fdh->elf.def_regular
6736 || fdh->elf.forced_local);
6737 _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
6738
6739 return TRUE;
6740 }
6741
6742 /* Called near the start of bfd_elf_size_dynamic_sections. We use
6743 this hook to a) provide some gcc support functions, and b) transfer
6744 dynamic linking information gathered so far on function code symbol
6745 entries, to their corresponding function descriptor symbol entries. */
6746
6747 static bfd_boolean
6748 ppc64_elf_func_desc_adjust (bfd *obfd ATTRIBUTE_UNUSED,
6749 struct bfd_link_info *info)
6750 {
6751 struct ppc_link_hash_table *htab;
6752 unsigned int i;
6753 static const struct sfpr_def_parms funcs[] =
6754 {
6755 { "_savegpr0_", 14, 31, savegpr0, savegpr0_tail },
6756 { "_restgpr0_", 14, 29, restgpr0, restgpr0_tail },
6757 { "_restgpr0_", 30, 31, restgpr0, restgpr0_tail },
6758 { "_savegpr1_", 14, 31, savegpr1, savegpr1_tail },
6759 { "_restgpr1_", 14, 31, restgpr1, restgpr1_tail },
6760 { "_savefpr_", 14, 31, savefpr, savefpr0_tail },
6761 { "_restfpr_", 14, 29, restfpr, restfpr0_tail },
6762 { "_restfpr_", 30, 31, restfpr, restfpr0_tail },
6763 { "._savef", 14, 31, savefpr, savefpr1_tail },
6764 { "._restf", 14, 31, restfpr, restfpr1_tail },
6765 { "_savevr_", 20, 31, savevr, savevr_tail },
6766 { "_restvr_", 20, 31, restvr, restvr_tail }
6767 };
6768
6769 htab = ppc_hash_table (info);
6770 if (htab == NULL)
6771 return FALSE;
6772
6773 if (!info->relocatable
6774 && htab->elf.hgot != NULL)
6775 _bfd_elf_link_hash_hide_symbol (info, htab->elf.hgot, TRUE);
6776
6777 if (htab->sfpr == NULL)
6778 /* We don't have any relocs. */
6779 return TRUE;
6780
6781 /* Provide any missing _save* and _rest* functions. */
6782 htab->sfpr->size = 0;
6783 if (!info->relocatable)
6784 for (i = 0; i < sizeof (funcs) / sizeof (funcs[0]); i++)
6785 if (!sfpr_define (info, &funcs[i]))
6786 return FALSE;
6787
6788 elf_link_hash_traverse (&htab->elf, func_desc_adjust, info);
6789
6790 if (htab->sfpr->size == 0)
6791 htab->sfpr->flags |= SEC_EXCLUDE;
6792
6793 return TRUE;
6794 }
6795
6796 /* Adjust a symbol defined by a dynamic object and referenced by a
6797 regular object. The current definition is in some section of the
6798 dynamic object, but we're not including those sections. We have to
6799 change the definition to something the rest of the link can
6800 understand. */
6801
6802 static bfd_boolean
6803 ppc64_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
6804 struct elf_link_hash_entry *h)
6805 {
6806 struct ppc_link_hash_table *htab;
6807 asection *s;
6808
6809 htab = ppc_hash_table (info);
6810 if (htab == NULL)
6811 return FALSE;
6812
6813 /* Deal with function syms. */
6814 if (h->type == STT_FUNC
6815 || h->type == STT_GNU_IFUNC
6816 || h->needs_plt)
6817 {
6818 /* Clear procedure linkage table information for any symbol that
6819 won't need a .plt entry. */
6820 struct plt_entry *ent;
6821 for (ent = h->plt.plist; ent != NULL; ent = ent->next)
6822 if (ent->plt.refcount > 0)
6823 break;
6824 if (ent == NULL
6825 || (h->type != STT_GNU_IFUNC
6826 && (SYMBOL_CALLS_LOCAL (info, h)
6827 || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
6828 && h->root.type == bfd_link_hash_undefweak))))
6829 {
6830 h->plt.plist = NULL;
6831 h->needs_plt = 0;
6832 }
6833 }
6834 else
6835 h->plt.plist = NULL;
6836
6837 /* If this is a weak symbol, and there is a real definition, the
6838 processor independent code will have arranged for us to see the
6839 real definition first, and we can just use the same value. */
6840 if (h->u.weakdef != NULL)
6841 {
6842 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
6843 || h->u.weakdef->root.type == bfd_link_hash_defweak);
6844 h->root.u.def.section = h->u.weakdef->root.u.def.section;
6845 h->root.u.def.value = h->u.weakdef->root.u.def.value;
6846 if (ELIMINATE_COPY_RELOCS)
6847 h->non_got_ref = h->u.weakdef->non_got_ref;
6848 return TRUE;
6849 }
6850
6851 /* If we are creating a shared library, we must presume that the
6852 only references to the symbol are via the global offset table.
6853 For such cases we need not do anything here; the relocations will
6854 be handled correctly by relocate_section. */
6855 if (info->shared)
6856 return TRUE;
6857
6858 /* If there are no references to this symbol that do not use the
6859 GOT, we don't need to generate a copy reloc. */
6860 if (!h->non_got_ref)
6861 return TRUE;
6862
6863 /* Don't generate a copy reloc for symbols defined in the executable. */
6864 if (!h->def_dynamic || !h->ref_regular || h->def_regular)
6865 return TRUE;
6866
6867 if (ELIMINATE_COPY_RELOCS)
6868 {
6869 struct ppc_link_hash_entry * eh;
6870 struct elf_dyn_relocs *p;
6871
6872 eh = (struct ppc_link_hash_entry *) h;
6873 for (p = eh->dyn_relocs; p != NULL; p = p->next)
6874 {
6875 s = p->sec->output_section;
6876 if (s != NULL && (s->flags & SEC_READONLY) != 0)
6877 break;
6878 }
6879
6880 /* If we didn't find any dynamic relocs in read-only sections, then
6881 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
6882 if (p == NULL)
6883 {
6884 h->non_got_ref = 0;
6885 return TRUE;
6886 }
6887 }
6888
6889 if (h->plt.plist != NULL)
6890 {
6891 /* We should never get here, but unfortunately there are versions
6892 of gcc out there that improperly (for this ABI) put initialized
6893 function pointers, vtable refs and suchlike in read-only
6894 sections. Allow them to proceed, but warn that this might
6895 break at runtime. */
6896 info->callbacks->einfo
6897 (_("%P: copy reloc against `%T' requires lazy plt linking; "
6898 "avoid setting LD_BIND_NOW=1 or upgrade gcc\n"),
6899 h->root.root.string);
6900 }
6901
6902 /* This is a reference to a symbol defined by a dynamic object which
6903 is not a function. */
6904
6905 /* We must allocate the symbol in our .dynbss section, which will
6906 become part of the .bss section of the executable. There will be
6907 an entry for this symbol in the .dynsym section. The dynamic
6908 object will contain position independent code, so all references
6909 from the dynamic object to this symbol will go through the global
6910 offset table. The dynamic linker will use the .dynsym entry to
6911 determine the address it must put in the global offset table, so
6912 both the dynamic object and the regular object will refer to the
6913 same memory location for the variable. */
6914
6915 /* We must generate a R_PPC64_COPY reloc to tell the dynamic linker
6916 to copy the initial value out of the dynamic object and into the
6917 runtime process image. We need to remember the offset into the
6918 .rela.bss section we are going to use. */
6919 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
6920 {
6921 htab->relbss->size += sizeof (Elf64_External_Rela);
6922 h->needs_copy = 1;
6923 }
6924
6925 s = htab->dynbss;
6926
6927 return _bfd_elf_adjust_dynamic_copy (h, s);
6928 }
6929
6930 /* If given a function descriptor symbol, hide both the function code
6931 sym and the descriptor. */
6932 static void
6933 ppc64_elf_hide_symbol (struct bfd_link_info *info,
6934 struct elf_link_hash_entry *h,
6935 bfd_boolean force_local)
6936 {
6937 struct ppc_link_hash_entry *eh;
6938 _bfd_elf_link_hash_hide_symbol (info, h, force_local);
6939
6940 eh = (struct ppc_link_hash_entry *) h;
6941 if (eh->is_func_descriptor)
6942 {
6943 struct ppc_link_hash_entry *fh = eh->oh;
6944
6945 if (fh == NULL)
6946 {
6947 const char *p, *q;
6948 struct ppc_link_hash_table *htab;
6949 char save;
6950
6951 /* We aren't supposed to use alloca in BFD because on
6952 systems which do not have alloca the version in libiberty
6953 calls xmalloc, which might cause the program to crash
6954 when it runs out of memory. This function doesn't have a
6955 return status, so there's no way to gracefully return an
6956 error. So cheat. We know that string[-1] can be safely
6957 accessed; It's either a string in an ELF string table,
6958 or allocated in an objalloc structure. */
6959
6960 p = eh->elf.root.root.string - 1;
6961 save = *p;
6962 *(char *) p = '.';
6963 htab = ppc_hash_table (info);
6964 if (htab == NULL)
6965 return;
6966
6967 fh = (struct ppc_link_hash_entry *)
6968 elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
6969 *(char *) p = save;
6970
6971 /* Unfortunately, if it so happens that the string we were
6972 looking for was allocated immediately before this string,
6973 then we overwrote the string terminator. That's the only
6974 reason the lookup should fail. */
6975 if (fh == NULL)
6976 {
6977 q = eh->elf.root.root.string + strlen (eh->elf.root.root.string);
6978 while (q >= eh->elf.root.root.string && *q == *p)
6979 --q, --p;
6980 if (q < eh->elf.root.root.string && *p == '.')
6981 fh = (struct ppc_link_hash_entry *)
6982 elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
6983 }
6984 if (fh != NULL)
6985 {
6986 eh->oh = fh;
6987 fh->oh = eh;
6988 }
6989 }
6990 if (fh != NULL)
6991 _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
6992 }
6993 }
6994
6995 static bfd_boolean
6996 get_sym_h (struct elf_link_hash_entry **hp,
6997 Elf_Internal_Sym **symp,
6998 asection **symsecp,
6999 unsigned char **tls_maskp,
7000 Elf_Internal_Sym **locsymsp,
7001 unsigned long r_symndx,
7002 bfd *ibfd)
7003 {
7004 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
7005
7006 if (r_symndx >= symtab_hdr->sh_info)
7007 {
7008 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
7009 struct elf_link_hash_entry *h;
7010
7011 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
7012 h = elf_follow_link (h);
7013
7014 if (hp != NULL)
7015 *hp = h;
7016
7017 if (symp != NULL)
7018 *symp = NULL;
7019
7020 if (symsecp != NULL)
7021 {
7022 asection *symsec = NULL;
7023 if (h->root.type == bfd_link_hash_defined
7024 || h->root.type == bfd_link_hash_defweak)
7025 symsec = h->root.u.def.section;
7026 *symsecp = symsec;
7027 }
7028
7029 if (tls_maskp != NULL)
7030 {
7031 struct ppc_link_hash_entry *eh;
7032
7033 eh = (struct ppc_link_hash_entry *) h;
7034 *tls_maskp = &eh->tls_mask;
7035 }
7036 }
7037 else
7038 {
7039 Elf_Internal_Sym *sym;
7040 Elf_Internal_Sym *locsyms = *locsymsp;
7041
7042 if (locsyms == NULL)
7043 {
7044 locsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
7045 if (locsyms == NULL)
7046 locsyms = bfd_elf_get_elf_syms (ibfd, symtab_hdr,
7047 symtab_hdr->sh_info,
7048 0, NULL, NULL, NULL);
7049 if (locsyms == NULL)
7050 return FALSE;
7051 *locsymsp = locsyms;
7052 }
7053 sym = locsyms + r_symndx;
7054
7055 if (hp != NULL)
7056 *hp = NULL;
7057
7058 if (symp != NULL)
7059 *symp = sym;
7060
7061 if (symsecp != NULL)
7062 *symsecp = bfd_section_from_elf_index (ibfd, sym->st_shndx);
7063
7064 if (tls_maskp != NULL)
7065 {
7066 struct got_entry **lgot_ents;
7067 unsigned char *tls_mask;
7068
7069 tls_mask = NULL;
7070 lgot_ents = elf_local_got_ents (ibfd);
7071 if (lgot_ents != NULL)
7072 {
7073 struct plt_entry **local_plt = (struct plt_entry **)
7074 (lgot_ents + symtab_hdr->sh_info);
7075 unsigned char *lgot_masks = (unsigned char *)
7076 (local_plt + symtab_hdr->sh_info);
7077 tls_mask = &lgot_masks[r_symndx];
7078 }
7079 *tls_maskp = tls_mask;
7080 }
7081 }
7082 return TRUE;
7083 }
7084
7085 /* Returns TLS_MASKP for the given REL symbol. Function return is 0 on
7086 error, 2 on a toc GD type suitable for optimization, 3 on a toc LD
7087 type suitable for optimization, and 1 otherwise. */
7088
7089 static int
7090 get_tls_mask (unsigned char **tls_maskp,
7091 unsigned long *toc_symndx,
7092 bfd_vma *toc_addend,
7093 Elf_Internal_Sym **locsymsp,
7094 const Elf_Internal_Rela *rel,
7095 bfd *ibfd)
7096 {
7097 unsigned long r_symndx;
7098 int next_r;
7099 struct elf_link_hash_entry *h;
7100 Elf_Internal_Sym *sym;
7101 asection *sec;
7102 bfd_vma off;
7103
7104 r_symndx = ELF64_R_SYM (rel->r_info);
7105 if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7106 return 0;
7107
7108 if ((*tls_maskp != NULL && **tls_maskp != 0)
7109 || sec == NULL
7110 || ppc64_elf_section_data (sec) == NULL
7111 || ppc64_elf_section_data (sec)->sec_type != sec_toc)
7112 return 1;
7113
7114 /* Look inside a TOC section too. */
7115 if (h != NULL)
7116 {
7117 BFD_ASSERT (h->root.type == bfd_link_hash_defined);
7118 off = h->root.u.def.value;
7119 }
7120 else
7121 off = sym->st_value;
7122 off += rel->r_addend;
7123 BFD_ASSERT (off % 8 == 0);
7124 r_symndx = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8];
7125 next_r = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8 + 1];
7126 if (toc_symndx != NULL)
7127 *toc_symndx = r_symndx;
7128 if (toc_addend != NULL)
7129 *toc_addend = ppc64_elf_section_data (sec)->u.toc.add[off / 8];
7130 if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7131 return 0;
7132 if ((h == NULL || is_static_defined (h))
7133 && (next_r == -1 || next_r == -2))
7134 return 1 - next_r;
7135 return 1;
7136 }
7137
7138 /* Find (or create) an entry in the tocsave hash table. */
7139
7140 static struct tocsave_entry *
7141 tocsave_find (struct ppc_link_hash_table *htab,
7142 enum insert_option insert,
7143 Elf_Internal_Sym **local_syms,
7144 const Elf_Internal_Rela *irela,
7145 bfd *ibfd)
7146 {
7147 unsigned long r_indx;
7148 struct elf_link_hash_entry *h;
7149 Elf_Internal_Sym *sym;
7150 struct tocsave_entry ent, *p;
7151 hashval_t hash;
7152 struct tocsave_entry **slot;
7153
7154 r_indx = ELF64_R_SYM (irela->r_info);
7155 if (!get_sym_h (&h, &sym, &ent.sec, NULL, local_syms, r_indx, ibfd))
7156 return NULL;
7157 if (ent.sec == NULL || ent.sec->output_section == NULL)
7158 {
7159 (*_bfd_error_handler)
7160 (_("%B: undefined symbol on R_PPC64_TOCSAVE relocation"));
7161 return NULL;
7162 }
7163
7164 if (h != NULL)
7165 ent.offset = h->root.u.def.value;
7166 else
7167 ent.offset = sym->st_value;
7168 ent.offset += irela->r_addend;
7169
7170 hash = tocsave_htab_hash (&ent);
7171 slot = ((struct tocsave_entry **)
7172 htab_find_slot_with_hash (htab->tocsave_htab, &ent, hash, insert));
7173 if (slot == NULL)
7174 return NULL;
7175
7176 if (*slot == NULL)
7177 {
7178 p = (struct tocsave_entry *) bfd_alloc (ibfd, sizeof (*p));
7179 if (p == NULL)
7180 return NULL;
7181 *p = ent;
7182 *slot = p;
7183 }
7184 return *slot;
7185 }
7186
7187 /* Adjust all global syms defined in opd sections. In gcc generated
7188 code for the old ABI, these will already have been done. */
7189
7190 static bfd_boolean
7191 adjust_opd_syms (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
7192 {
7193 struct ppc_link_hash_entry *eh;
7194 asection *sym_sec;
7195 struct _opd_sec_data *opd;
7196
7197 if (h->root.type == bfd_link_hash_indirect)
7198 return TRUE;
7199
7200 if (h->root.type != bfd_link_hash_defined
7201 && h->root.type != bfd_link_hash_defweak)
7202 return TRUE;
7203
7204 eh = (struct ppc_link_hash_entry *) h;
7205 if (eh->adjust_done)
7206 return TRUE;
7207
7208 sym_sec = eh->elf.root.u.def.section;
7209 opd = get_opd_info (sym_sec);
7210 if (opd != NULL && opd->adjust != NULL)
7211 {
7212 long adjust = opd->adjust[eh->elf.root.u.def.value / 8];
7213 if (adjust == -1)
7214 {
7215 /* This entry has been deleted. */
7216 asection *dsec = ppc64_elf_tdata (sym_sec->owner)->deleted_section;
7217 if (dsec == NULL)
7218 {
7219 for (dsec = sym_sec->owner->sections; dsec; dsec = dsec->next)
7220 if (discarded_section (dsec))
7221 {
7222 ppc64_elf_tdata (sym_sec->owner)->deleted_section = dsec;
7223 break;
7224 }
7225 }
7226 eh->elf.root.u.def.value = 0;
7227 eh->elf.root.u.def.section = dsec;
7228 }
7229 else
7230 eh->elf.root.u.def.value += adjust;
7231 eh->adjust_done = 1;
7232 }
7233 return TRUE;
7234 }
7235
7236 /* Handles decrementing dynamic reloc counts for the reloc specified by
7237 R_INFO in section SEC. If LOCAL_SYMS is NULL, then H and SYM
7238 have already been determined. */
7239
7240 static bfd_boolean
7241 dec_dynrel_count (bfd_vma r_info,
7242 asection *sec,
7243 struct bfd_link_info *info,
7244 Elf_Internal_Sym **local_syms,
7245 struct elf_link_hash_entry *h,
7246 Elf_Internal_Sym *sym)
7247 {
7248 enum elf_ppc64_reloc_type r_type;
7249 asection *sym_sec = NULL;
7250
7251 /* Can this reloc be dynamic? This switch, and later tests here
7252 should be kept in sync with the code in check_relocs. */
7253 r_type = ELF64_R_TYPE (r_info);
7254 switch (r_type)
7255 {
7256 default:
7257 return TRUE;
7258
7259 case R_PPC64_TPREL16:
7260 case R_PPC64_TPREL16_LO:
7261 case R_PPC64_TPREL16_HI:
7262 case R_PPC64_TPREL16_HA:
7263 case R_PPC64_TPREL16_DS:
7264 case R_PPC64_TPREL16_LO_DS:
7265 case R_PPC64_TPREL16_HIGH:
7266 case R_PPC64_TPREL16_HIGHA:
7267 case R_PPC64_TPREL16_HIGHER:
7268 case R_PPC64_TPREL16_HIGHERA:
7269 case R_PPC64_TPREL16_HIGHEST:
7270 case R_PPC64_TPREL16_HIGHESTA:
7271 if (!info->shared)
7272 return TRUE;
7273
7274 case R_PPC64_TPREL64:
7275 case R_PPC64_DTPMOD64:
7276 case R_PPC64_DTPREL64:
7277 case R_PPC64_ADDR64:
7278 case R_PPC64_REL30:
7279 case R_PPC64_REL32:
7280 case R_PPC64_REL64:
7281 case R_PPC64_ADDR14:
7282 case R_PPC64_ADDR14_BRNTAKEN:
7283 case R_PPC64_ADDR14_BRTAKEN:
7284 case R_PPC64_ADDR16:
7285 case R_PPC64_ADDR16_DS:
7286 case R_PPC64_ADDR16_HA:
7287 case R_PPC64_ADDR16_HI:
7288 case R_PPC64_ADDR16_HIGH:
7289 case R_PPC64_ADDR16_HIGHA:
7290 case R_PPC64_ADDR16_HIGHER:
7291 case R_PPC64_ADDR16_HIGHERA:
7292 case R_PPC64_ADDR16_HIGHEST:
7293 case R_PPC64_ADDR16_HIGHESTA:
7294 case R_PPC64_ADDR16_LO:
7295 case R_PPC64_ADDR16_LO_DS:
7296 case R_PPC64_ADDR24:
7297 case R_PPC64_ADDR32:
7298 case R_PPC64_UADDR16:
7299 case R_PPC64_UADDR32:
7300 case R_PPC64_UADDR64:
7301 case R_PPC64_TOC:
7302 break;
7303 }
7304
7305 if (local_syms != NULL)
7306 {
7307 unsigned long r_symndx;
7308 bfd *ibfd = sec->owner;
7309
7310 r_symndx = ELF64_R_SYM (r_info);
7311 if (!get_sym_h (&h, &sym, &sym_sec, NULL, local_syms, r_symndx, ibfd))
7312 return FALSE;
7313 }
7314
7315 if ((info->shared
7316 && (must_be_dyn_reloc (info, r_type)
7317 || (h != NULL
7318 && (!SYMBOLIC_BIND (info, h)
7319 || h->root.type == bfd_link_hash_defweak
7320 || !h->def_regular))))
7321 || (ELIMINATE_COPY_RELOCS
7322 && !info->shared
7323 && h != NULL
7324 && (h->root.type == bfd_link_hash_defweak
7325 || !h->def_regular)))
7326 ;
7327 else
7328 return TRUE;
7329
7330 if (h != NULL)
7331 {
7332 struct elf_dyn_relocs *p;
7333 struct elf_dyn_relocs **pp;
7334 pp = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
7335
7336 /* elf_gc_sweep may have already removed all dyn relocs associated
7337 with local syms for a given section. Also, symbol flags are
7338 changed by elf_gc_sweep_symbol, confusing the test above. Don't
7339 report a dynreloc miscount. */
7340 if (*pp == NULL && info->gc_sections)
7341 return TRUE;
7342
7343 while ((p = *pp) != NULL)
7344 {
7345 if (p->sec == sec)
7346 {
7347 if (!must_be_dyn_reloc (info, r_type))
7348 p->pc_count -= 1;
7349 p->count -= 1;
7350 if (p->count == 0)
7351 *pp = p->next;
7352 return TRUE;
7353 }
7354 pp = &p->next;
7355 }
7356 }
7357 else
7358 {
7359 struct ppc_dyn_relocs *p;
7360 struct ppc_dyn_relocs **pp;
7361 void *vpp;
7362 bfd_boolean is_ifunc;
7363
7364 if (local_syms == NULL)
7365 sym_sec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
7366 if (sym_sec == NULL)
7367 sym_sec = sec;
7368
7369 vpp = &elf_section_data (sym_sec)->local_dynrel;
7370 pp = (struct ppc_dyn_relocs **) vpp;
7371
7372 if (*pp == NULL && info->gc_sections)
7373 return TRUE;
7374
7375 is_ifunc = ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC;
7376 while ((p = *pp) != NULL)
7377 {
7378 if (p->sec == sec && p->ifunc == is_ifunc)
7379 {
7380 p->count -= 1;
7381 if (p->count == 0)
7382 *pp = p->next;
7383 return TRUE;
7384 }
7385 pp = &p->next;
7386 }
7387 }
7388
7389 info->callbacks->einfo (_("%P: dynreloc miscount for %B, section %A\n"),
7390 sec->owner, sec);
7391 bfd_set_error (bfd_error_bad_value);
7392 return FALSE;
7393 }
7394
7395 /* Remove unused Official Procedure Descriptor entries. Currently we
7396 only remove those associated with functions in discarded link-once
7397 sections, or weakly defined functions that have been overridden. It
7398 would be possible to remove many more entries for statically linked
7399 applications. */
7400
7401 bfd_boolean
7402 ppc64_elf_edit_opd (struct bfd_link_info *info, bfd_boolean non_overlapping)
7403 {
7404 bfd *ibfd;
7405 bfd_boolean some_edited = FALSE;
7406 asection *need_pad = NULL;
7407
7408 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
7409 {
7410 asection *sec;
7411 Elf_Internal_Rela *relstart, *rel, *relend;
7412 Elf_Internal_Shdr *symtab_hdr;
7413 Elf_Internal_Sym *local_syms;
7414 bfd_vma offset;
7415 struct _opd_sec_data *opd;
7416 bfd_boolean need_edit, add_aux_fields;
7417 bfd_size_type cnt_16b = 0;
7418
7419 if (!is_ppc64_elf (ibfd))
7420 continue;
7421
7422 sec = bfd_get_section_by_name (ibfd, ".opd");
7423 if (sec == NULL || sec->size == 0)
7424 continue;
7425
7426 if (sec->sec_info_type == SEC_INFO_TYPE_JUST_SYMS)
7427 continue;
7428
7429 if (sec->output_section == bfd_abs_section_ptr)
7430 continue;
7431
7432 /* Look through the section relocs. */
7433 if ((sec->flags & SEC_RELOC) == 0 || sec->reloc_count == 0)
7434 continue;
7435
7436 local_syms = NULL;
7437 symtab_hdr = &elf_symtab_hdr (ibfd);
7438
7439 /* Read the relocations. */
7440 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
7441 info->keep_memory);
7442 if (relstart == NULL)
7443 return FALSE;
7444
7445 /* First run through the relocs to check they are sane, and to
7446 determine whether we need to edit this opd section. */
7447 need_edit = FALSE;
7448 need_pad = sec;
7449 offset = 0;
7450 relend = relstart + sec->reloc_count;
7451 for (rel = relstart; rel < relend; )
7452 {
7453 enum elf_ppc64_reloc_type r_type;
7454 unsigned long r_symndx;
7455 asection *sym_sec;
7456 struct elf_link_hash_entry *h;
7457 Elf_Internal_Sym *sym;
7458
7459 /* .opd contains a regular array of 16 or 24 byte entries. We're
7460 only interested in the reloc pointing to a function entry
7461 point. */
7462 if (rel->r_offset != offset
7463 || rel + 1 >= relend
7464 || (rel + 1)->r_offset != offset + 8)
7465 {
7466 /* If someone messes with .opd alignment then after a
7467 "ld -r" we might have padding in the middle of .opd.
7468 Also, there's nothing to prevent someone putting
7469 something silly in .opd with the assembler. No .opd
7470 optimization for them! */
7471 broken_opd:
7472 (*_bfd_error_handler)
7473 (_("%B: .opd is not a regular array of opd entries"), ibfd);
7474 need_edit = FALSE;
7475 break;
7476 }
7477
7478 if ((r_type = ELF64_R_TYPE (rel->r_info)) != R_PPC64_ADDR64
7479 || (r_type = ELF64_R_TYPE ((rel + 1)->r_info)) != R_PPC64_TOC)
7480 {
7481 (*_bfd_error_handler)
7482 (_("%B: unexpected reloc type %u in .opd section"),
7483 ibfd, r_type);
7484 need_edit = FALSE;
7485 break;
7486 }
7487
7488 r_symndx = ELF64_R_SYM (rel->r_info);
7489 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7490 r_symndx, ibfd))
7491 goto error_ret;
7492
7493 if (sym_sec == NULL || sym_sec->owner == NULL)
7494 {
7495 const char *sym_name;
7496 if (h != NULL)
7497 sym_name = h->root.root.string;
7498 else
7499 sym_name = bfd_elf_sym_name (ibfd, symtab_hdr, sym,
7500 sym_sec);
7501
7502 (*_bfd_error_handler)
7503 (_("%B: undefined sym `%s' in .opd section"),
7504 ibfd, sym_name);
7505 need_edit = FALSE;
7506 break;
7507 }
7508
7509 /* opd entries are always for functions defined in the
7510 current input bfd. If the symbol isn't defined in the
7511 input bfd, then we won't be using the function in this
7512 bfd; It must be defined in a linkonce section in another
7513 bfd, or is weak. It's also possible that we are
7514 discarding the function due to a linker script /DISCARD/,
7515 which we test for via the output_section. */
7516 if (sym_sec->owner != ibfd
7517 || sym_sec->output_section == bfd_abs_section_ptr)
7518 need_edit = TRUE;
7519
7520 rel += 2;
7521 if (rel == relend
7522 || (rel + 1 == relend && rel->r_offset == offset + 16))
7523 {
7524 if (sec->size == offset + 24)
7525 {
7526 need_pad = NULL;
7527 break;
7528 }
7529 if (rel == relend && sec->size == offset + 16)
7530 {
7531 cnt_16b++;
7532 break;
7533 }
7534 goto broken_opd;
7535 }
7536
7537 if (rel->r_offset == offset + 24)
7538 offset += 24;
7539 else if (rel->r_offset != offset + 16)
7540 goto broken_opd;
7541 else if (rel + 1 < relend
7542 && ELF64_R_TYPE (rel[0].r_info) == R_PPC64_ADDR64
7543 && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOC)
7544 {
7545 offset += 16;
7546 cnt_16b++;
7547 }
7548 else if (rel + 2 < relend
7549 && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_ADDR64
7550 && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_TOC)
7551 {
7552 offset += 24;
7553 rel += 1;
7554 }
7555 else
7556 goto broken_opd;
7557 }
7558
7559 add_aux_fields = non_overlapping && cnt_16b > 0;
7560
7561 if (need_edit || add_aux_fields)
7562 {
7563 Elf_Internal_Rela *write_rel;
7564 Elf_Internal_Shdr *rel_hdr;
7565 bfd_byte *rptr, *wptr;
7566 bfd_byte *new_contents;
7567 bfd_boolean skip;
7568 long opd_ent_size;
7569 bfd_size_type amt;
7570
7571 new_contents = NULL;
7572 amt = sec->size * sizeof (long) / 8;
7573 opd = &ppc64_elf_section_data (sec)->u.opd;
7574 opd->adjust = bfd_zalloc (sec->owner, amt);
7575 if (opd->adjust == NULL)
7576 return FALSE;
7577 ppc64_elf_section_data (sec)->sec_type = sec_opd;
7578
7579 /* This seems a waste of time as input .opd sections are all
7580 zeros as generated by gcc, but I suppose there's no reason
7581 this will always be so. We might start putting something in
7582 the third word of .opd entries. */
7583 if ((sec->flags & SEC_IN_MEMORY) == 0)
7584 {
7585 bfd_byte *loc;
7586 if (!bfd_malloc_and_get_section (ibfd, sec, &loc))
7587 {
7588 if (loc != NULL)
7589 free (loc);
7590 error_ret:
7591 if (local_syms != NULL
7592 && symtab_hdr->contents != (unsigned char *) local_syms)
7593 free (local_syms);
7594 if (elf_section_data (sec)->relocs != relstart)
7595 free (relstart);
7596 return FALSE;
7597 }
7598 sec->contents = loc;
7599 sec->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
7600 }
7601
7602 elf_section_data (sec)->relocs = relstart;
7603
7604 new_contents = sec->contents;
7605 if (add_aux_fields)
7606 {
7607 new_contents = bfd_malloc (sec->size + cnt_16b * 8);
7608 if (new_contents == NULL)
7609 return FALSE;
7610 need_pad = FALSE;
7611 }
7612 wptr = new_contents;
7613 rptr = sec->contents;
7614
7615 write_rel = relstart;
7616 skip = FALSE;
7617 offset = 0;
7618 opd_ent_size = 0;
7619 for (rel = relstart; rel < relend; rel++)
7620 {
7621 unsigned long r_symndx;
7622 asection *sym_sec;
7623 struct elf_link_hash_entry *h;
7624 Elf_Internal_Sym *sym;
7625
7626 r_symndx = ELF64_R_SYM (rel->r_info);
7627 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7628 r_symndx, ibfd))
7629 goto error_ret;
7630
7631 if (rel->r_offset == offset)
7632 {
7633 struct ppc_link_hash_entry *fdh = NULL;
7634
7635 /* See if the .opd entry is full 24 byte or
7636 16 byte (with fd_aux entry overlapped with next
7637 fd_func). */
7638 opd_ent_size = 24;
7639 if ((rel + 2 == relend && sec->size == offset + 16)
7640 || (rel + 3 < relend
7641 && rel[2].r_offset == offset + 16
7642 && rel[3].r_offset == offset + 24
7643 && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_ADDR64
7644 && ELF64_R_TYPE (rel[3].r_info) == R_PPC64_TOC))
7645 opd_ent_size = 16;
7646
7647 if (h != NULL
7648 && h->root.root.string[0] == '.')
7649 {
7650 struct ppc_link_hash_table *htab;
7651
7652 htab = ppc_hash_table (info);
7653 if (htab != NULL)
7654 fdh = lookup_fdh ((struct ppc_link_hash_entry *) h,
7655 htab);
7656 if (fdh != NULL
7657 && fdh->elf.root.type != bfd_link_hash_defined
7658 && fdh->elf.root.type != bfd_link_hash_defweak)
7659 fdh = NULL;
7660 }
7661
7662 skip = (sym_sec->owner != ibfd
7663 || sym_sec->output_section == bfd_abs_section_ptr);
7664 if (skip)
7665 {
7666 if (fdh != NULL && sym_sec->owner == ibfd)
7667 {
7668 /* Arrange for the function descriptor sym
7669 to be dropped. */
7670 fdh->elf.root.u.def.value = 0;
7671 fdh->elf.root.u.def.section = sym_sec;
7672 }
7673 opd->adjust[rel->r_offset / 8] = -1;
7674 }
7675 else
7676 {
7677 /* We'll be keeping this opd entry. */
7678
7679 if (fdh != NULL)
7680 {
7681 /* Redefine the function descriptor symbol to
7682 this location in the opd section. It is
7683 necessary to update the value here rather
7684 than using an array of adjustments as we do
7685 for local symbols, because various places
7686 in the generic ELF code use the value
7687 stored in u.def.value. */
7688 fdh->elf.root.u.def.value = wptr - new_contents;
7689 fdh->adjust_done = 1;
7690 }
7691
7692 /* Local syms are a bit tricky. We could
7693 tweak them as they can be cached, but
7694 we'd need to look through the local syms
7695 for the function descriptor sym which we
7696 don't have at the moment. So keep an
7697 array of adjustments. */
7698 opd->adjust[rel->r_offset / 8]
7699 = (wptr - new_contents) - (rptr - sec->contents);
7700
7701 if (wptr != rptr)
7702 memcpy (wptr, rptr, opd_ent_size);
7703 wptr += opd_ent_size;
7704 if (add_aux_fields && opd_ent_size == 16)
7705 {
7706 memset (wptr, '\0', 8);
7707 wptr += 8;
7708 }
7709 }
7710 rptr += opd_ent_size;
7711 offset += opd_ent_size;
7712 }
7713
7714 if (skip)
7715 {
7716 if (!NO_OPD_RELOCS
7717 && !info->relocatable
7718 && !dec_dynrel_count (rel->r_info, sec, info,
7719 NULL, h, sym))
7720 goto error_ret;
7721 }
7722 else
7723 {
7724 /* We need to adjust any reloc offsets to point to the
7725 new opd entries. While we're at it, we may as well
7726 remove redundant relocs. */
7727 rel->r_offset += opd->adjust[(offset - opd_ent_size) / 8];
7728 if (write_rel != rel)
7729 memcpy (write_rel, rel, sizeof (*rel));
7730 ++write_rel;
7731 }
7732 }
7733
7734 sec->size = wptr - new_contents;
7735 sec->reloc_count = write_rel - relstart;
7736 if (add_aux_fields)
7737 {
7738 free (sec->contents);
7739 sec->contents = new_contents;
7740 }
7741
7742 /* Fudge the header size too, as this is used later in
7743 elf_bfd_final_link if we are emitting relocs. */
7744 rel_hdr = _bfd_elf_single_rel_hdr (sec);
7745 rel_hdr->sh_size = sec->reloc_count * rel_hdr->sh_entsize;
7746 some_edited = TRUE;
7747 }
7748 else if (elf_section_data (sec)->relocs != relstart)
7749 free (relstart);
7750
7751 if (local_syms != NULL
7752 && symtab_hdr->contents != (unsigned char *) local_syms)
7753 {
7754 if (!info->keep_memory)
7755 free (local_syms);
7756 else
7757 symtab_hdr->contents = (unsigned char *) local_syms;
7758 }
7759 }
7760
7761 if (some_edited)
7762 elf_link_hash_traverse (elf_hash_table (info), adjust_opd_syms, NULL);
7763
7764 /* If we are doing a final link and the last .opd entry is just 16 byte
7765 long, add a 8 byte padding after it. */
7766 if (need_pad != NULL && !info->relocatable)
7767 {
7768 bfd_byte *p;
7769
7770 if ((need_pad->flags & SEC_IN_MEMORY) == 0)
7771 {
7772 BFD_ASSERT (need_pad->size > 0);
7773
7774 p = bfd_malloc (need_pad->size + 8);
7775 if (p == NULL)
7776 return FALSE;
7777
7778 if (! bfd_get_section_contents (need_pad->owner, need_pad,
7779 p, 0, need_pad->size))
7780 return FALSE;
7781
7782 need_pad->contents = p;
7783 need_pad->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
7784 }
7785 else
7786 {
7787 p = bfd_realloc (need_pad->contents, need_pad->size + 8);
7788 if (p == NULL)
7789 return FALSE;
7790
7791 need_pad->contents = p;
7792 }
7793
7794 memset (need_pad->contents + need_pad->size, 0, 8);
7795 need_pad->size += 8;
7796 }
7797
7798 return TRUE;
7799 }
7800
7801 /* Set htab->tls_get_addr and call the generic ELF tls_setup function. */
7802
7803 asection *
7804 ppc64_elf_tls_setup (struct bfd_link_info *info,
7805 int no_tls_get_addr_opt,
7806 int *no_multi_toc)
7807 {
7808 struct ppc_link_hash_table *htab;
7809
7810 htab = ppc_hash_table (info);
7811 if (htab == NULL)
7812 return NULL;
7813
7814 if (abiversion (info->output_bfd) == 1)
7815 htab->opd_abi = 1;
7816
7817 if (*no_multi_toc)
7818 htab->do_multi_toc = 0;
7819 else if (!htab->do_multi_toc)
7820 *no_multi_toc = 1;
7821
7822 htab->tls_get_addr = ((struct ppc_link_hash_entry *)
7823 elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
7824 FALSE, FALSE, TRUE));
7825 /* Move dynamic linking info to the function descriptor sym. */
7826 if (htab->tls_get_addr != NULL)
7827 func_desc_adjust (&htab->tls_get_addr->elf, info);
7828 htab->tls_get_addr_fd = ((struct ppc_link_hash_entry *)
7829 elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
7830 FALSE, FALSE, TRUE));
7831 if (!no_tls_get_addr_opt)
7832 {
7833 struct elf_link_hash_entry *opt, *opt_fd, *tga, *tga_fd;
7834
7835 opt = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr_opt",
7836 FALSE, FALSE, TRUE);
7837 if (opt != NULL)
7838 func_desc_adjust (opt, info);
7839 opt_fd = elf_link_hash_lookup (&htab->elf, "__tls_get_addr_opt",
7840 FALSE, FALSE, TRUE);
7841 if (opt_fd != NULL
7842 && (opt_fd->root.type == bfd_link_hash_defined
7843 || opt_fd->root.type == bfd_link_hash_defweak))
7844 {
7845 /* If glibc supports an optimized __tls_get_addr call stub,
7846 signalled by the presence of __tls_get_addr_opt, and we'll
7847 be calling __tls_get_addr via a plt call stub, then
7848 make __tls_get_addr point to __tls_get_addr_opt. */
7849 tga_fd = &htab->tls_get_addr_fd->elf;
7850 if (htab->elf.dynamic_sections_created
7851 && tga_fd != NULL
7852 && (tga_fd->type == STT_FUNC
7853 || tga_fd->needs_plt)
7854 && !(SYMBOL_CALLS_LOCAL (info, tga_fd)
7855 || (ELF_ST_VISIBILITY (tga_fd->other) != STV_DEFAULT
7856 && tga_fd->root.type == bfd_link_hash_undefweak)))
7857 {
7858 struct plt_entry *ent;
7859
7860 for (ent = tga_fd->plt.plist; ent != NULL; ent = ent->next)
7861 if (ent->plt.refcount > 0)
7862 break;
7863 if (ent != NULL)
7864 {
7865 tga_fd->root.type = bfd_link_hash_indirect;
7866 tga_fd->root.u.i.link = &opt_fd->root;
7867 ppc64_elf_copy_indirect_symbol (info, opt_fd, tga_fd);
7868 if (opt_fd->dynindx != -1)
7869 {
7870 /* Use __tls_get_addr_opt in dynamic relocations. */
7871 opt_fd->dynindx = -1;
7872 _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
7873 opt_fd->dynstr_index);
7874 if (!bfd_elf_link_record_dynamic_symbol (info, opt_fd))
7875 return NULL;
7876 }
7877 htab->tls_get_addr_fd = (struct ppc_link_hash_entry *) opt_fd;
7878 tga = &htab->tls_get_addr->elf;
7879 if (opt != NULL && tga != NULL)
7880 {
7881 tga->root.type = bfd_link_hash_indirect;
7882 tga->root.u.i.link = &opt->root;
7883 ppc64_elf_copy_indirect_symbol (info, opt, tga);
7884 _bfd_elf_link_hash_hide_symbol (info, opt,
7885 tga->forced_local);
7886 htab->tls_get_addr = (struct ppc_link_hash_entry *) opt;
7887 }
7888 htab->tls_get_addr_fd->oh = htab->tls_get_addr;
7889 htab->tls_get_addr_fd->is_func_descriptor = 1;
7890 if (htab->tls_get_addr != NULL)
7891 {
7892 htab->tls_get_addr->oh = htab->tls_get_addr_fd;
7893 htab->tls_get_addr->is_func = 1;
7894 }
7895 }
7896 }
7897 }
7898 else
7899 no_tls_get_addr_opt = TRUE;
7900 }
7901 htab->no_tls_get_addr_opt = no_tls_get_addr_opt;
7902 return _bfd_elf_tls_setup (info->output_bfd, info);
7903 }
7904
7905 /* Return TRUE iff REL is a branch reloc with a global symbol matching
7906 HASH1 or HASH2. */
7907
7908 static bfd_boolean
7909 branch_reloc_hash_match (const bfd *ibfd,
7910 const Elf_Internal_Rela *rel,
7911 const struct ppc_link_hash_entry *hash1,
7912 const struct ppc_link_hash_entry *hash2)
7913 {
7914 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
7915 enum elf_ppc64_reloc_type r_type = ELF64_R_TYPE (rel->r_info);
7916 unsigned int r_symndx = ELF64_R_SYM (rel->r_info);
7917
7918 if (r_symndx >= symtab_hdr->sh_info && is_branch_reloc (r_type))
7919 {
7920 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
7921 struct elf_link_hash_entry *h;
7922
7923 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
7924 h = elf_follow_link (h);
7925 if (h == &hash1->elf || h == &hash2->elf)
7926 return TRUE;
7927 }
7928 return FALSE;
7929 }
7930
7931 /* Run through all the TLS relocs looking for optimization
7932 opportunities. The linker has been hacked (see ppc64elf.em) to do
7933 a preliminary section layout so that we know the TLS segment
7934 offsets. We can't optimize earlier because some optimizations need
7935 to know the tp offset, and we need to optimize before allocating
7936 dynamic relocations. */
7937
7938 bfd_boolean
7939 ppc64_elf_tls_optimize (struct bfd_link_info *info)
7940 {
7941 bfd *ibfd;
7942 asection *sec;
7943 struct ppc_link_hash_table *htab;
7944 unsigned char *toc_ref;
7945 int pass;
7946
7947 if (info->relocatable || !info->executable)
7948 return TRUE;
7949
7950 htab = ppc_hash_table (info);
7951 if (htab == NULL)
7952 return FALSE;
7953
7954 /* Make two passes over the relocs. On the first pass, mark toc
7955 entries involved with tls relocs, and check that tls relocs
7956 involved in setting up a tls_get_addr call are indeed followed by
7957 such a call. If they are not, we can't do any tls optimization.
7958 On the second pass twiddle tls_mask flags to notify
7959 relocate_section that optimization can be done, and adjust got
7960 and plt refcounts. */
7961 toc_ref = NULL;
7962 for (pass = 0; pass < 2; ++pass)
7963 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
7964 {
7965 Elf_Internal_Sym *locsyms = NULL;
7966 asection *toc = bfd_get_section_by_name (ibfd, ".toc");
7967
7968 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
7969 if (sec->has_tls_reloc && !bfd_is_abs_section (sec->output_section))
7970 {
7971 Elf_Internal_Rela *relstart, *rel, *relend;
7972 bfd_boolean found_tls_get_addr_arg = 0;
7973
7974 /* Read the relocations. */
7975 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
7976 info->keep_memory);
7977 if (relstart == NULL)
7978 return FALSE;
7979
7980 relend = relstart + sec->reloc_count;
7981 for (rel = relstart; rel < relend; rel++)
7982 {
7983 enum elf_ppc64_reloc_type r_type;
7984 unsigned long r_symndx;
7985 struct elf_link_hash_entry *h;
7986 Elf_Internal_Sym *sym;
7987 asection *sym_sec;
7988 unsigned char *tls_mask;
7989 unsigned char tls_set, tls_clear, tls_type = 0;
7990 bfd_vma value;
7991 bfd_boolean ok_tprel, is_local;
7992 long toc_ref_index = 0;
7993 int expecting_tls_get_addr = 0;
7994 bfd_boolean ret = FALSE;
7995
7996 r_symndx = ELF64_R_SYM (rel->r_info);
7997 if (!get_sym_h (&h, &sym, &sym_sec, &tls_mask, &locsyms,
7998 r_symndx, ibfd))
7999 {
8000 err_free_rel:
8001 if (elf_section_data (sec)->relocs != relstart)
8002 free (relstart);
8003 if (toc_ref != NULL)
8004 free (toc_ref);
8005 if (locsyms != NULL
8006 && (elf_symtab_hdr (ibfd).contents
8007 != (unsigned char *) locsyms))
8008 free (locsyms);
8009 return ret;
8010 }
8011
8012 if (h != NULL)
8013 {
8014 if (h->root.type == bfd_link_hash_defined
8015 || h->root.type == bfd_link_hash_defweak)
8016 value = h->root.u.def.value;
8017 else if (h->root.type == bfd_link_hash_undefweak)
8018 value = 0;
8019 else
8020 {
8021 found_tls_get_addr_arg = 0;
8022 continue;
8023 }
8024 }
8025 else
8026 /* Symbols referenced by TLS relocs must be of type
8027 STT_TLS. So no need for .opd local sym adjust. */
8028 value = sym->st_value;
8029
8030 ok_tprel = FALSE;
8031 is_local = FALSE;
8032 if (h == NULL
8033 || !h->def_dynamic)
8034 {
8035 is_local = TRUE;
8036 if (h != NULL
8037 && h->root.type == bfd_link_hash_undefweak)
8038 ok_tprel = TRUE;
8039 else
8040 {
8041 value += sym_sec->output_offset;
8042 value += sym_sec->output_section->vma;
8043 value -= htab->elf.tls_sec->vma;
8044 ok_tprel = (value + TP_OFFSET + ((bfd_vma) 1 << 31)
8045 < (bfd_vma) 1 << 32);
8046 }
8047 }
8048
8049 r_type = ELF64_R_TYPE (rel->r_info);
8050 /* If this section has old-style __tls_get_addr calls
8051 without marker relocs, then check that each
8052 __tls_get_addr call reloc is preceded by a reloc
8053 that conceivably belongs to the __tls_get_addr arg
8054 setup insn. If we don't find matching arg setup
8055 relocs, don't do any tls optimization. */
8056 if (pass == 0
8057 && sec->has_tls_get_addr_call
8058 && h != NULL
8059 && (h == &htab->tls_get_addr->elf
8060 || h == &htab->tls_get_addr_fd->elf)
8061 && !found_tls_get_addr_arg
8062 && is_branch_reloc (r_type))
8063 {
8064 info->callbacks->minfo (_("%H __tls_get_addr lost arg, "
8065 "TLS optimization disabled\n"),
8066 ibfd, sec, rel->r_offset);
8067 ret = TRUE;
8068 goto err_free_rel;
8069 }
8070
8071 found_tls_get_addr_arg = 0;
8072 switch (r_type)
8073 {
8074 case R_PPC64_GOT_TLSLD16:
8075 case R_PPC64_GOT_TLSLD16_LO:
8076 expecting_tls_get_addr = 1;
8077 found_tls_get_addr_arg = 1;
8078 /* Fall thru */
8079
8080 case R_PPC64_GOT_TLSLD16_HI:
8081 case R_PPC64_GOT_TLSLD16_HA:
8082 /* These relocs should never be against a symbol
8083 defined in a shared lib. Leave them alone if
8084 that turns out to be the case. */
8085 if (!is_local)
8086 continue;
8087
8088 /* LD -> LE */
8089 tls_set = 0;
8090 tls_clear = TLS_LD;
8091 tls_type = TLS_TLS | TLS_LD;
8092 break;
8093
8094 case R_PPC64_GOT_TLSGD16:
8095 case R_PPC64_GOT_TLSGD16_LO:
8096 expecting_tls_get_addr = 1;
8097 found_tls_get_addr_arg = 1;
8098 /* Fall thru */
8099
8100 case R_PPC64_GOT_TLSGD16_HI:
8101 case R_PPC64_GOT_TLSGD16_HA:
8102 if (ok_tprel)
8103 /* GD -> LE */
8104 tls_set = 0;
8105 else
8106 /* GD -> IE */
8107 tls_set = TLS_TLS | TLS_TPRELGD;
8108 tls_clear = TLS_GD;
8109 tls_type = TLS_TLS | TLS_GD;
8110 break;
8111
8112 case R_PPC64_GOT_TPREL16_DS:
8113 case R_PPC64_GOT_TPREL16_LO_DS:
8114 case R_PPC64_GOT_TPREL16_HI:
8115 case R_PPC64_GOT_TPREL16_HA:
8116 if (ok_tprel)
8117 {
8118 /* IE -> LE */
8119 tls_set = 0;
8120 tls_clear = TLS_TPREL;
8121 tls_type = TLS_TLS | TLS_TPREL;
8122 break;
8123 }
8124 continue;
8125
8126 case R_PPC64_TLSGD:
8127 case R_PPC64_TLSLD:
8128 found_tls_get_addr_arg = 1;
8129 /* Fall thru */
8130
8131 case R_PPC64_TLS:
8132 case R_PPC64_TOC16:
8133 case R_PPC64_TOC16_LO:
8134 if (sym_sec == NULL || sym_sec != toc)
8135 continue;
8136
8137 /* Mark this toc entry as referenced by a TLS
8138 code sequence. We can do that now in the
8139 case of R_PPC64_TLS, and after checking for
8140 tls_get_addr for the TOC16 relocs. */
8141 if (toc_ref == NULL)
8142 toc_ref = bfd_zmalloc (toc->output_section->rawsize / 8);
8143 if (toc_ref == NULL)
8144 goto err_free_rel;
8145
8146 if (h != NULL)
8147 value = h->root.u.def.value;
8148 else
8149 value = sym->st_value;
8150 value += rel->r_addend;
8151 BFD_ASSERT (value < toc->size && value % 8 == 0);
8152 toc_ref_index = (value + toc->output_offset) / 8;
8153 if (r_type == R_PPC64_TLS
8154 || r_type == R_PPC64_TLSGD
8155 || r_type == R_PPC64_TLSLD)
8156 {
8157 toc_ref[toc_ref_index] = 1;
8158 continue;
8159 }
8160
8161 if (pass != 0 && toc_ref[toc_ref_index] == 0)
8162 continue;
8163
8164 tls_set = 0;
8165 tls_clear = 0;
8166 expecting_tls_get_addr = 2;
8167 break;
8168
8169 case R_PPC64_TPREL64:
8170 if (pass == 0
8171 || sec != toc
8172 || toc_ref == NULL
8173 || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
8174 continue;
8175 if (ok_tprel)
8176 {
8177 /* IE -> LE */
8178 tls_set = TLS_EXPLICIT;
8179 tls_clear = TLS_TPREL;
8180 break;
8181 }
8182 continue;
8183
8184 case R_PPC64_DTPMOD64:
8185 if (pass == 0
8186 || sec != toc
8187 || toc_ref == NULL
8188 || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
8189 continue;
8190 if (rel + 1 < relend
8191 && (rel[1].r_info
8192 == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64))
8193 && rel[1].r_offset == rel->r_offset + 8)
8194 {
8195 if (ok_tprel)
8196 /* GD -> LE */
8197 tls_set = TLS_EXPLICIT | TLS_GD;
8198 else
8199 /* GD -> IE */
8200 tls_set = TLS_EXPLICIT | TLS_GD | TLS_TPRELGD;
8201 tls_clear = TLS_GD;
8202 }
8203 else
8204 {
8205 if (!is_local)
8206 continue;
8207
8208 /* LD -> LE */
8209 tls_set = TLS_EXPLICIT;
8210 tls_clear = TLS_LD;
8211 }
8212 break;
8213
8214 default:
8215 continue;
8216 }
8217
8218 if (pass == 0)
8219 {
8220 if (!expecting_tls_get_addr
8221 || !sec->has_tls_get_addr_call)
8222 continue;
8223
8224 if (rel + 1 < relend
8225 && branch_reloc_hash_match (ibfd, rel + 1,
8226 htab->tls_get_addr,
8227 htab->tls_get_addr_fd))
8228 {
8229 if (expecting_tls_get_addr == 2)
8230 {
8231 /* Check for toc tls entries. */
8232 unsigned char *toc_tls;
8233 int retval;
8234
8235 retval = get_tls_mask (&toc_tls, NULL, NULL,
8236 &locsyms,
8237 rel, ibfd);
8238 if (retval == 0)
8239 goto err_free_rel;
8240 if (toc_tls != NULL)
8241 {
8242 if ((*toc_tls & (TLS_GD | TLS_LD)) != 0)
8243 found_tls_get_addr_arg = 1;
8244 if (retval > 1)
8245 toc_ref[toc_ref_index] = 1;
8246 }
8247 }
8248 continue;
8249 }
8250
8251 if (expecting_tls_get_addr != 1)
8252 continue;
8253
8254 /* Uh oh, we didn't find the expected call. We
8255 could just mark this symbol to exclude it
8256 from tls optimization but it's safer to skip
8257 the entire optimization. */
8258 info->callbacks->minfo (_("%H arg lost __tls_get_addr, "
8259 "TLS optimization disabled\n"),
8260 ibfd, sec, rel->r_offset);
8261 ret = TRUE;
8262 goto err_free_rel;
8263 }
8264
8265 if (expecting_tls_get_addr && htab->tls_get_addr != NULL)
8266 {
8267 struct plt_entry *ent;
8268 for (ent = htab->tls_get_addr->elf.plt.plist;
8269 ent != NULL;
8270 ent = ent->next)
8271 if (ent->addend == 0)
8272 {
8273 if (ent->plt.refcount > 0)
8274 {
8275 ent->plt.refcount -= 1;
8276 expecting_tls_get_addr = 0;
8277 }
8278 break;
8279 }
8280 }
8281
8282 if (expecting_tls_get_addr && htab->tls_get_addr_fd != NULL)
8283 {
8284 struct plt_entry *ent;
8285 for (ent = htab->tls_get_addr_fd->elf.plt.plist;
8286 ent != NULL;
8287 ent = ent->next)
8288 if (ent->addend == 0)
8289 {
8290 if (ent->plt.refcount > 0)
8291 ent->plt.refcount -= 1;
8292 break;
8293 }
8294 }
8295
8296 if (tls_clear == 0)
8297 continue;
8298
8299 if ((tls_set & TLS_EXPLICIT) == 0)
8300 {
8301 struct got_entry *ent;
8302
8303 /* Adjust got entry for this reloc. */
8304 if (h != NULL)
8305 ent = h->got.glist;
8306 else
8307 ent = elf_local_got_ents (ibfd)[r_symndx];
8308
8309 for (; ent != NULL; ent = ent->next)
8310 if (ent->addend == rel->r_addend
8311 && ent->owner == ibfd
8312 && ent->tls_type == tls_type)
8313 break;
8314 if (ent == NULL)
8315 abort ();
8316
8317 if (tls_set == 0)
8318 {
8319 /* We managed to get rid of a got entry. */
8320 if (ent->got.refcount > 0)
8321 ent->got.refcount -= 1;
8322 }
8323 }
8324 else
8325 {
8326 /* If we got rid of a DTPMOD/DTPREL reloc pair then
8327 we'll lose one or two dyn relocs. */
8328 if (!dec_dynrel_count (rel->r_info, sec, info,
8329 NULL, h, sym))
8330 return FALSE;
8331
8332 if (tls_set == (TLS_EXPLICIT | TLS_GD))
8333 {
8334 if (!dec_dynrel_count ((rel + 1)->r_info, sec, info,
8335 NULL, h, sym))
8336 return FALSE;
8337 }
8338 }
8339
8340 *tls_mask |= tls_set;
8341 *tls_mask &= ~tls_clear;
8342 }
8343
8344 if (elf_section_data (sec)->relocs != relstart)
8345 free (relstart);
8346 }
8347
8348 if (locsyms != NULL
8349 && (elf_symtab_hdr (ibfd).contents != (unsigned char *) locsyms))
8350 {
8351 if (!info->keep_memory)
8352 free (locsyms);
8353 else
8354 elf_symtab_hdr (ibfd).contents = (unsigned char *) locsyms;
8355 }
8356 }
8357
8358 if (toc_ref != NULL)
8359 free (toc_ref);
8360 return TRUE;
8361 }
8362
8363 /* Called via elf_link_hash_traverse from ppc64_elf_edit_toc to adjust
8364 the values of any global symbols in a toc section that has been
8365 edited. Globals in toc sections should be a rarity, so this function
8366 sets a flag if any are found in toc sections other than the one just
8367 edited, so that futher hash table traversals can be avoided. */
8368
8369 struct adjust_toc_info
8370 {
8371 asection *toc;
8372 unsigned long *skip;
8373 bfd_boolean global_toc_syms;
8374 };
8375
8376 enum toc_skip_enum { ref_from_discarded = 1, can_optimize = 2 };
8377
8378 static bfd_boolean
8379 adjust_toc_syms (struct elf_link_hash_entry *h, void *inf)
8380 {
8381 struct ppc_link_hash_entry *eh;
8382 struct adjust_toc_info *toc_inf = (struct adjust_toc_info *) inf;
8383 unsigned long i;
8384
8385 if (h->root.type != bfd_link_hash_defined
8386 && h->root.type != bfd_link_hash_defweak)
8387 return TRUE;
8388
8389 eh = (struct ppc_link_hash_entry *) h;
8390 if (eh->adjust_done)
8391 return TRUE;
8392
8393 if (eh->elf.root.u.def.section == toc_inf->toc)
8394 {
8395 if (eh->elf.root.u.def.value > toc_inf->toc->rawsize)
8396 i = toc_inf->toc->rawsize >> 3;
8397 else
8398 i = eh->elf.root.u.def.value >> 3;
8399
8400 if ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0)
8401 {
8402 (*_bfd_error_handler)
8403 (_("%s defined on removed toc entry"), eh->elf.root.root.string);
8404 do
8405 ++i;
8406 while ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0);
8407 eh->elf.root.u.def.value = (bfd_vma) i << 3;
8408 }
8409
8410 eh->elf.root.u.def.value -= toc_inf->skip[i];
8411 eh->adjust_done = 1;
8412 }
8413 else if (strcmp (eh->elf.root.u.def.section->name, ".toc") == 0)
8414 toc_inf->global_toc_syms = TRUE;
8415
8416 return TRUE;
8417 }
8418
8419 /* Return TRUE iff INSN is one we expect on a _LO variety toc/got reloc. */
8420
8421 static bfd_boolean
8422 ok_lo_toc_insn (unsigned int insn)
8423 {
8424 return ((insn & (0x3f << 26)) == 14u << 26 /* addi */
8425 || (insn & (0x3f << 26)) == 32u << 26 /* lwz */
8426 || (insn & (0x3f << 26)) == 34u << 26 /* lbz */
8427 || (insn & (0x3f << 26)) == 36u << 26 /* stw */
8428 || (insn & (0x3f << 26)) == 38u << 26 /* stb */
8429 || (insn & (0x3f << 26)) == 40u << 26 /* lhz */
8430 || (insn & (0x3f << 26)) == 42u << 26 /* lha */
8431 || (insn & (0x3f << 26)) == 44u << 26 /* sth */
8432 || (insn & (0x3f << 26)) == 46u << 26 /* lmw */
8433 || (insn & (0x3f << 26)) == 47u << 26 /* stmw */
8434 || (insn & (0x3f << 26)) == 48u << 26 /* lfs */
8435 || (insn & (0x3f << 26)) == 50u << 26 /* lfd */
8436 || (insn & (0x3f << 26)) == 52u << 26 /* stfs */
8437 || (insn & (0x3f << 26)) == 54u << 26 /* stfd */
8438 || ((insn & (0x3f << 26)) == 58u << 26 /* lwa,ld,lmd */
8439 && (insn & 3) != 1)
8440 || ((insn & (0x3f << 26)) == 62u << 26 /* std, stmd */
8441 && ((insn & 3) == 0 || (insn & 3) == 3))
8442 || (insn & (0x3f << 26)) == 12u << 26 /* addic */);
8443 }
8444
8445 /* Examine all relocs referencing .toc sections in order to remove
8446 unused .toc entries. */
8447
8448 bfd_boolean
8449 ppc64_elf_edit_toc (struct bfd_link_info *info)
8450 {
8451 bfd *ibfd;
8452 struct adjust_toc_info toc_inf;
8453 struct ppc_link_hash_table *htab = ppc_hash_table (info);
8454
8455 htab->do_toc_opt = 1;
8456 toc_inf.global_toc_syms = TRUE;
8457 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
8458 {
8459 asection *toc, *sec;
8460 Elf_Internal_Shdr *symtab_hdr;
8461 Elf_Internal_Sym *local_syms;
8462 Elf_Internal_Rela *relstart, *rel, *toc_relocs;
8463 unsigned long *skip, *drop;
8464 unsigned char *used;
8465 unsigned char *keep, last, some_unused;
8466
8467 if (!is_ppc64_elf (ibfd))
8468 continue;
8469
8470 toc = bfd_get_section_by_name (ibfd, ".toc");
8471 if (toc == NULL
8472 || toc->size == 0
8473 || toc->sec_info_type == SEC_INFO_TYPE_JUST_SYMS
8474 || discarded_section (toc))
8475 continue;
8476
8477 toc_relocs = NULL;
8478 local_syms = NULL;
8479 symtab_hdr = &elf_symtab_hdr (ibfd);
8480
8481 /* Look at sections dropped from the final link. */
8482 skip = NULL;
8483 relstart = NULL;
8484 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8485 {
8486 if (sec->reloc_count == 0
8487 || !discarded_section (sec)
8488 || get_opd_info (sec)
8489 || (sec->flags & SEC_ALLOC) == 0
8490 || (sec->flags & SEC_DEBUGGING) != 0)
8491 continue;
8492
8493 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL, FALSE);
8494 if (relstart == NULL)
8495 goto error_ret;
8496
8497 /* Run through the relocs to see which toc entries might be
8498 unused. */
8499 for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
8500 {
8501 enum elf_ppc64_reloc_type r_type;
8502 unsigned long r_symndx;
8503 asection *sym_sec;
8504 struct elf_link_hash_entry *h;
8505 Elf_Internal_Sym *sym;
8506 bfd_vma val;
8507
8508 r_type = ELF64_R_TYPE (rel->r_info);
8509 switch (r_type)
8510 {
8511 default:
8512 continue;
8513
8514 case R_PPC64_TOC16:
8515 case R_PPC64_TOC16_LO:
8516 case R_PPC64_TOC16_HI:
8517 case R_PPC64_TOC16_HA:
8518 case R_PPC64_TOC16_DS:
8519 case R_PPC64_TOC16_LO_DS:
8520 break;
8521 }
8522
8523 r_symndx = ELF64_R_SYM (rel->r_info);
8524 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8525 r_symndx, ibfd))
8526 goto error_ret;
8527
8528 if (sym_sec != toc)
8529 continue;
8530
8531 if (h != NULL)
8532 val = h->root.u.def.value;
8533 else
8534 val = sym->st_value;
8535 val += rel->r_addend;
8536
8537 if (val >= toc->size)
8538 continue;
8539
8540 /* Anything in the toc ought to be aligned to 8 bytes.
8541 If not, don't mark as unused. */
8542 if (val & 7)
8543 continue;
8544
8545 if (skip == NULL)
8546 {
8547 skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
8548 if (skip == NULL)
8549 goto error_ret;
8550 }
8551
8552 skip[val >> 3] = ref_from_discarded;
8553 }
8554
8555 if (elf_section_data (sec)->relocs != relstart)
8556 free (relstart);
8557 }
8558
8559 /* For largetoc loads of address constants, we can convert
8560 . addis rx,2,addr@got@ha
8561 . ld ry,addr@got@l(rx)
8562 to
8563 . addis rx,2,addr@toc@ha
8564 . addi ry,rx,addr@toc@l
8565 when addr is within 2G of the toc pointer. This then means
8566 that the word storing "addr" in the toc is no longer needed. */
8567
8568 if (!ppc64_elf_tdata (ibfd)->has_small_toc_reloc
8569 && toc->output_section->rawsize < (bfd_vma) 1 << 31
8570 && toc->reloc_count != 0)
8571 {
8572 /* Read toc relocs. */
8573 toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
8574 info->keep_memory);
8575 if (toc_relocs == NULL)
8576 goto error_ret;
8577
8578 for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
8579 {
8580 enum elf_ppc64_reloc_type r_type;
8581 unsigned long r_symndx;
8582 asection *sym_sec;
8583 struct elf_link_hash_entry *h;
8584 Elf_Internal_Sym *sym;
8585 bfd_vma val, addr;
8586
8587 r_type = ELF64_R_TYPE (rel->r_info);
8588 if (r_type != R_PPC64_ADDR64)
8589 continue;
8590
8591 r_symndx = ELF64_R_SYM (rel->r_info);
8592 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8593 r_symndx, ibfd))
8594 goto error_ret;
8595
8596 if (sym_sec == NULL
8597 || discarded_section (sym_sec))
8598 continue;
8599
8600 if (!SYMBOL_CALLS_LOCAL (info, h))
8601 continue;
8602
8603 if (h != NULL)
8604 {
8605 if (h->type == STT_GNU_IFUNC)
8606 continue;
8607 val = h->root.u.def.value;
8608 }
8609 else
8610 {
8611 if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
8612 continue;
8613 val = sym->st_value;
8614 }
8615 val += rel->r_addend;
8616 val += sym_sec->output_section->vma + sym_sec->output_offset;
8617
8618 /* We don't yet know the exact toc pointer value, but we
8619 know it will be somewhere in the toc section. Don't
8620 optimize if the difference from any possible toc
8621 pointer is outside [ff..f80008000, 7fff7fff]. */
8622 addr = toc->output_section->vma + TOC_BASE_OFF;
8623 if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
8624 continue;
8625
8626 addr = toc->output_section->vma + toc->output_section->rawsize;
8627 if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
8628 continue;
8629
8630 if (skip == NULL)
8631 {
8632 skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
8633 if (skip == NULL)
8634 goto error_ret;
8635 }
8636
8637 skip[rel->r_offset >> 3]
8638 |= can_optimize | ((rel - toc_relocs) << 2);
8639 }
8640 }
8641
8642 if (skip == NULL)
8643 continue;
8644
8645 used = bfd_zmalloc (sizeof (*used) * (toc->size + 7) / 8);
8646 if (used == NULL)
8647 {
8648 error_ret:
8649 if (local_syms != NULL
8650 && symtab_hdr->contents != (unsigned char *) local_syms)
8651 free (local_syms);
8652 if (sec != NULL
8653 && relstart != NULL
8654 && elf_section_data (sec)->relocs != relstart)
8655 free (relstart);
8656 if (toc_relocs != NULL
8657 && elf_section_data (toc)->relocs != toc_relocs)
8658 free (toc_relocs);
8659 if (skip != NULL)
8660 free (skip);
8661 return FALSE;
8662 }
8663
8664 /* Now check all kept sections that might reference the toc.
8665 Check the toc itself last. */
8666 for (sec = (ibfd->sections == toc && toc->next ? toc->next
8667 : ibfd->sections);
8668 sec != NULL;
8669 sec = (sec == toc ? NULL
8670 : sec->next == NULL ? toc
8671 : sec->next == toc && toc->next ? toc->next
8672 : sec->next))
8673 {
8674 int repeat;
8675
8676 if (sec->reloc_count == 0
8677 || discarded_section (sec)
8678 || get_opd_info (sec)
8679 || (sec->flags & SEC_ALLOC) == 0
8680 || (sec->flags & SEC_DEBUGGING) != 0)
8681 continue;
8682
8683 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8684 info->keep_memory);
8685 if (relstart == NULL)
8686 goto error_ret;
8687
8688 /* Mark toc entries referenced as used. */
8689 do
8690 {
8691 repeat = 0;
8692 for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
8693 {
8694 enum elf_ppc64_reloc_type r_type;
8695 unsigned long r_symndx;
8696 asection *sym_sec;
8697 struct elf_link_hash_entry *h;
8698 Elf_Internal_Sym *sym;
8699 bfd_vma val;
8700 enum {no_check, check_lo, check_ha} insn_check;
8701
8702 r_type = ELF64_R_TYPE (rel->r_info);
8703 switch (r_type)
8704 {
8705 default:
8706 insn_check = no_check;
8707 break;
8708
8709 case R_PPC64_GOT_TLSLD16_HA:
8710 case R_PPC64_GOT_TLSGD16_HA:
8711 case R_PPC64_GOT_TPREL16_HA:
8712 case R_PPC64_GOT_DTPREL16_HA:
8713 case R_PPC64_GOT16_HA:
8714 case R_PPC64_TOC16_HA:
8715 insn_check = check_ha;
8716 break;
8717
8718 case R_PPC64_GOT_TLSLD16_LO:
8719 case R_PPC64_GOT_TLSGD16_LO:
8720 case R_PPC64_GOT_TPREL16_LO_DS:
8721 case R_PPC64_GOT_DTPREL16_LO_DS:
8722 case R_PPC64_GOT16_LO:
8723 case R_PPC64_GOT16_LO_DS:
8724 case R_PPC64_TOC16_LO:
8725 case R_PPC64_TOC16_LO_DS:
8726 insn_check = check_lo;
8727 break;
8728 }
8729
8730 if (insn_check != no_check)
8731 {
8732 bfd_vma off = rel->r_offset & ~3;
8733 unsigned char buf[4];
8734 unsigned int insn;
8735
8736 if (!bfd_get_section_contents (ibfd, sec, buf, off, 4))
8737 {
8738 free (used);
8739 goto error_ret;
8740 }
8741 insn = bfd_get_32 (ibfd, buf);
8742 if (insn_check == check_lo
8743 ? !ok_lo_toc_insn (insn)
8744 : ((insn & ((0x3f << 26) | 0x1f << 16))
8745 != ((15u << 26) | (2 << 16)) /* addis rt,2,imm */))
8746 {
8747 char str[12];
8748
8749 ppc64_elf_tdata (ibfd)->unexpected_toc_insn = 1;
8750 sprintf (str, "%#08x", insn);
8751 info->callbacks->einfo
8752 (_("%P: %H: toc optimization is not supported for"
8753 " %s instruction.\n"),
8754 ibfd, sec, rel->r_offset & ~3, str);
8755 }
8756 }
8757
8758 switch (r_type)
8759 {
8760 case R_PPC64_TOC16:
8761 case R_PPC64_TOC16_LO:
8762 case R_PPC64_TOC16_HI:
8763 case R_PPC64_TOC16_HA:
8764 case R_PPC64_TOC16_DS:
8765 case R_PPC64_TOC16_LO_DS:
8766 /* In case we're taking addresses of toc entries. */
8767 case R_PPC64_ADDR64:
8768 break;
8769
8770 default:
8771 continue;
8772 }
8773
8774 r_symndx = ELF64_R_SYM (rel->r_info);
8775 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8776 r_symndx, ibfd))
8777 {
8778 free (used);
8779 goto error_ret;
8780 }
8781
8782 if (sym_sec != toc)
8783 continue;
8784
8785 if (h != NULL)
8786 val = h->root.u.def.value;
8787 else
8788 val = sym->st_value;
8789 val += rel->r_addend;
8790
8791 if (val >= toc->size)
8792 continue;
8793
8794 if ((skip[val >> 3] & can_optimize) != 0)
8795 {
8796 bfd_vma off;
8797 unsigned char opc;
8798
8799 switch (r_type)
8800 {
8801 case R_PPC64_TOC16_HA:
8802 break;
8803
8804 case R_PPC64_TOC16_LO_DS:
8805 off = rel->r_offset;
8806 off += (bfd_big_endian (ibfd) ? -2 : 3);
8807 if (!bfd_get_section_contents (ibfd, sec, &opc,
8808 off, 1))
8809 {
8810 free (used);
8811 goto error_ret;
8812 }
8813 if ((opc & (0x3f << 2)) == (58u << 2))
8814 break;
8815 /* Fall thru */
8816
8817 default:
8818 /* Wrong sort of reloc, or not a ld. We may
8819 as well clear ref_from_discarded too. */
8820 skip[val >> 3] = 0;
8821 }
8822 }
8823
8824 if (sec != toc)
8825 used[val >> 3] = 1;
8826 /* For the toc section, we only mark as used if this
8827 entry itself isn't unused. */
8828 else if ((used[rel->r_offset >> 3]
8829 || !(skip[rel->r_offset >> 3] & ref_from_discarded))
8830 && !used[val >> 3])
8831 {
8832 /* Do all the relocs again, to catch reference
8833 chains. */
8834 repeat = 1;
8835 used[val >> 3] = 1;
8836 }
8837 }
8838 }
8839 while (repeat);
8840
8841 if (elf_section_data (sec)->relocs != relstart)
8842 free (relstart);
8843 }
8844
8845 /* Merge the used and skip arrays. Assume that TOC
8846 doublewords not appearing as either used or unused belong
8847 to to an entry more than one doubleword in size. */
8848 for (drop = skip, keep = used, last = 0, some_unused = 0;
8849 drop < skip + (toc->size + 7) / 8;
8850 ++drop, ++keep)
8851 {
8852 if (*keep)
8853 {
8854 *drop &= ~ref_from_discarded;
8855 if ((*drop & can_optimize) != 0)
8856 some_unused = 1;
8857 last = 0;
8858 }
8859 else if ((*drop & ref_from_discarded) != 0)
8860 {
8861 some_unused = 1;
8862 last = ref_from_discarded;
8863 }
8864 else
8865 *drop = last;
8866 }
8867
8868 free (used);
8869
8870 if (some_unused)
8871 {
8872 bfd_byte *contents, *src;
8873 unsigned long off;
8874 Elf_Internal_Sym *sym;
8875 bfd_boolean local_toc_syms = FALSE;
8876
8877 /* Shuffle the toc contents, and at the same time convert the
8878 skip array from booleans into offsets. */
8879 if (!bfd_malloc_and_get_section (ibfd, toc, &contents))
8880 goto error_ret;
8881
8882 elf_section_data (toc)->this_hdr.contents = contents;
8883
8884 for (src = contents, off = 0, drop = skip;
8885 src < contents + toc->size;
8886 src += 8, ++drop)
8887 {
8888 if ((*drop & (can_optimize | ref_from_discarded)) != 0)
8889 off += 8;
8890 else if (off != 0)
8891 {
8892 *drop = off;
8893 memcpy (src - off, src, 8);
8894 }
8895 }
8896 *drop = off;
8897 toc->rawsize = toc->size;
8898 toc->size = src - contents - off;
8899
8900 /* Adjust addends for relocs against the toc section sym,
8901 and optimize any accesses we can. */
8902 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8903 {
8904 if (sec->reloc_count == 0
8905 || discarded_section (sec))
8906 continue;
8907
8908 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8909 info->keep_memory);
8910 if (relstart == NULL)
8911 goto error_ret;
8912
8913 for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
8914 {
8915 enum elf_ppc64_reloc_type r_type;
8916 unsigned long r_symndx;
8917 asection *sym_sec;
8918 struct elf_link_hash_entry *h;
8919 bfd_vma val;
8920
8921 r_type = ELF64_R_TYPE (rel->r_info);
8922 switch (r_type)
8923 {
8924 default:
8925 continue;
8926
8927 case R_PPC64_TOC16:
8928 case R_PPC64_TOC16_LO:
8929 case R_PPC64_TOC16_HI:
8930 case R_PPC64_TOC16_HA:
8931 case R_PPC64_TOC16_DS:
8932 case R_PPC64_TOC16_LO_DS:
8933 case R_PPC64_ADDR64:
8934 break;
8935 }
8936
8937 r_symndx = ELF64_R_SYM (rel->r_info);
8938 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8939 r_symndx, ibfd))
8940 goto error_ret;
8941
8942 if (sym_sec != toc)
8943 continue;
8944
8945 if (h != NULL)
8946 val = h->root.u.def.value;
8947 else
8948 {
8949 val = sym->st_value;
8950 if (val != 0)
8951 local_toc_syms = TRUE;
8952 }
8953
8954 val += rel->r_addend;
8955
8956 if (val > toc->rawsize)
8957 val = toc->rawsize;
8958 else if ((skip[val >> 3] & ref_from_discarded) != 0)
8959 continue;
8960 else if ((skip[val >> 3] & can_optimize) != 0)
8961 {
8962 Elf_Internal_Rela *tocrel
8963 = toc_relocs + (skip[val >> 3] >> 2);
8964 unsigned long tsym = ELF64_R_SYM (tocrel->r_info);
8965
8966 switch (r_type)
8967 {
8968 case R_PPC64_TOC16_HA:
8969 rel->r_info = ELF64_R_INFO (tsym, R_PPC64_TOC16_HA);
8970 break;
8971
8972 case R_PPC64_TOC16_LO_DS:
8973 rel->r_info = ELF64_R_INFO (tsym, R_PPC64_LO_DS_OPT);
8974 break;
8975
8976 default:
8977 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
8978 ppc_howto_init ();
8979 info->callbacks->einfo
8980 (_("%P: %H: %s references "
8981 "optimized away TOC entry\n"),
8982 ibfd, sec, rel->r_offset,
8983 ppc64_elf_howto_table[r_type]->name);
8984 bfd_set_error (bfd_error_bad_value);
8985 goto error_ret;
8986 }
8987 rel->r_addend = tocrel->r_addend;
8988 elf_section_data (sec)->relocs = relstart;
8989 continue;
8990 }
8991
8992 if (h != NULL || sym->st_value != 0)
8993 continue;
8994
8995 rel->r_addend -= skip[val >> 3];
8996 elf_section_data (sec)->relocs = relstart;
8997 }
8998
8999 if (elf_section_data (sec)->relocs != relstart)
9000 free (relstart);
9001 }
9002
9003 /* We shouldn't have local or global symbols defined in the TOC,
9004 but handle them anyway. */
9005 if (local_syms != NULL)
9006 for (sym = local_syms;
9007 sym < local_syms + symtab_hdr->sh_info;
9008 ++sym)
9009 if (sym->st_value != 0
9010 && bfd_section_from_elf_index (ibfd, sym->st_shndx) == toc)
9011 {
9012 unsigned long i;
9013
9014 if (sym->st_value > toc->rawsize)
9015 i = toc->rawsize >> 3;
9016 else
9017 i = sym->st_value >> 3;
9018
9019 if ((skip[i] & (ref_from_discarded | can_optimize)) != 0)
9020 {
9021 if (local_toc_syms)
9022 (*_bfd_error_handler)
9023 (_("%s defined on removed toc entry"),
9024 bfd_elf_sym_name (ibfd, symtab_hdr, sym, NULL));
9025 do
9026 ++i;
9027 while ((skip[i] & (ref_from_discarded | can_optimize)));
9028 sym->st_value = (bfd_vma) i << 3;
9029 }
9030
9031 sym->st_value -= skip[i];
9032 symtab_hdr->contents = (unsigned char *) local_syms;
9033 }
9034
9035 /* Adjust any global syms defined in this toc input section. */
9036 if (toc_inf.global_toc_syms)
9037 {
9038 toc_inf.toc = toc;
9039 toc_inf.skip = skip;
9040 toc_inf.global_toc_syms = FALSE;
9041 elf_link_hash_traverse (elf_hash_table (info), adjust_toc_syms,
9042 &toc_inf);
9043 }
9044
9045 if (toc->reloc_count != 0)
9046 {
9047 Elf_Internal_Shdr *rel_hdr;
9048 Elf_Internal_Rela *wrel;
9049 bfd_size_type sz;
9050
9051 /* Remove unused toc relocs, and adjust those we keep. */
9052 if (toc_relocs == NULL)
9053 toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
9054 info->keep_memory);
9055 if (toc_relocs == NULL)
9056 goto error_ret;
9057
9058 wrel = toc_relocs;
9059 for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
9060 if ((skip[rel->r_offset >> 3]
9061 & (ref_from_discarded | can_optimize)) == 0)
9062 {
9063 wrel->r_offset = rel->r_offset - skip[rel->r_offset >> 3];
9064 wrel->r_info = rel->r_info;
9065 wrel->r_addend = rel->r_addend;
9066 ++wrel;
9067 }
9068 else if (!dec_dynrel_count (rel->r_info, toc, info,
9069 &local_syms, NULL, NULL))
9070 goto error_ret;
9071
9072 elf_section_data (toc)->relocs = toc_relocs;
9073 toc->reloc_count = wrel - toc_relocs;
9074 rel_hdr = _bfd_elf_single_rel_hdr (toc);
9075 sz = rel_hdr->sh_entsize;
9076 rel_hdr->sh_size = toc->reloc_count * sz;
9077 }
9078 }
9079 else if (toc_relocs != NULL
9080 && elf_section_data (toc)->relocs != toc_relocs)
9081 free (toc_relocs);
9082
9083 if (local_syms != NULL
9084 && symtab_hdr->contents != (unsigned char *) local_syms)
9085 {
9086 if (!info->keep_memory)
9087 free (local_syms);
9088 else
9089 symtab_hdr->contents = (unsigned char *) local_syms;
9090 }
9091 free (skip);
9092 }
9093
9094 return TRUE;
9095 }
9096
9097 /* Return true iff input section I references the TOC using
9098 instructions limited to +/-32k offsets. */
9099
9100 bfd_boolean
9101 ppc64_elf_has_small_toc_reloc (asection *i)
9102 {
9103 return (is_ppc64_elf (i->owner)
9104 && ppc64_elf_tdata (i->owner)->has_small_toc_reloc);
9105 }
9106
9107 /* Allocate space for one GOT entry. */
9108
9109 static void
9110 allocate_got (struct elf_link_hash_entry *h,
9111 struct bfd_link_info *info,
9112 struct got_entry *gent)
9113 {
9114 struct ppc_link_hash_table *htab = ppc_hash_table (info);
9115 bfd_boolean dyn;
9116 struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
9117 int entsize = (gent->tls_type & eh->tls_mask & (TLS_GD | TLS_LD)
9118 ? 16 : 8);
9119 int rentsize = (gent->tls_type & eh->tls_mask & TLS_GD
9120 ? 2 : 1) * sizeof (Elf64_External_Rela);
9121 asection *got = ppc64_elf_tdata (gent->owner)->got;
9122
9123 gent->got.offset = got->size;
9124 got->size += entsize;
9125
9126 dyn = htab->elf.dynamic_sections_created;
9127 if (h->type == STT_GNU_IFUNC)
9128 {
9129 htab->reliplt->size += rentsize;
9130 htab->got_reli_size += rentsize;
9131 }
9132 else if ((info->shared
9133 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h))
9134 && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
9135 || h->root.type != bfd_link_hash_undefweak))
9136 {
9137 asection *relgot = ppc64_elf_tdata (gent->owner)->relgot;
9138 relgot->size += rentsize;
9139 }
9140 }
9141
9142 /* This function merges got entries in the same toc group. */
9143
9144 static void
9145 merge_got_entries (struct got_entry **pent)
9146 {
9147 struct got_entry *ent, *ent2;
9148
9149 for (ent = *pent; ent != NULL; ent = ent->next)
9150 if (!ent->is_indirect)
9151 for (ent2 = ent->next; ent2 != NULL; ent2 = ent2->next)
9152 if (!ent2->is_indirect
9153 && ent2->addend == ent->addend
9154 && ent2->tls_type == ent->tls_type
9155 && elf_gp (ent2->owner) == elf_gp (ent->owner))
9156 {
9157 ent2->is_indirect = TRUE;
9158 ent2->got.ent = ent;
9159 }
9160 }
9161
9162 /* Allocate space in .plt, .got and associated reloc sections for
9163 dynamic relocs. */
9164
9165 static bfd_boolean
9166 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
9167 {
9168 struct bfd_link_info *info;
9169 struct ppc_link_hash_table *htab;
9170 asection *s;
9171 struct ppc_link_hash_entry *eh;
9172 struct elf_dyn_relocs *p;
9173 struct got_entry **pgent, *gent;
9174
9175 if (h->root.type == bfd_link_hash_indirect)
9176 return TRUE;
9177
9178 info = (struct bfd_link_info *) inf;
9179 htab = ppc_hash_table (info);
9180 if (htab == NULL)
9181 return FALSE;
9182
9183 if ((htab->elf.dynamic_sections_created
9184 && h->dynindx != -1
9185 && WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info->shared, h))
9186 || h->type == STT_GNU_IFUNC)
9187 {
9188 struct plt_entry *pent;
9189 bfd_boolean doneone = FALSE;
9190 for (pent = h->plt.plist; pent != NULL; pent = pent->next)
9191 if (pent->plt.refcount > 0)
9192 {
9193 if (!htab->elf.dynamic_sections_created
9194 || h->dynindx == -1)
9195 {
9196 s = htab->iplt;
9197 pent->plt.offset = s->size;
9198 s->size += PLT_ENTRY_SIZE;
9199 s = htab->reliplt;
9200 }
9201 else
9202 {
9203 /* If this is the first .plt entry, make room for the special
9204 first entry. */
9205 s = htab->plt;
9206 if (s->size == 0)
9207 s->size += PLT_INITIAL_ENTRY_SIZE;
9208
9209 pent->plt.offset = s->size;
9210
9211 /* Make room for this entry. */
9212 s->size += PLT_ENTRY_SIZE;
9213
9214 /* Make room for the .glink code. */
9215 s = htab->glink;
9216 if (s->size == 0)
9217 s->size += GLINK_CALL_STUB_SIZE;
9218 /* We need bigger stubs past index 32767. */
9219 if (s->size >= GLINK_CALL_STUB_SIZE + 32768*2*4)
9220 s->size += 4;
9221 s->size += 2*4;
9222
9223 /* We also need to make an entry in the .rela.plt section. */
9224 s = htab->relplt;
9225 }
9226 s->size += sizeof (Elf64_External_Rela);
9227 doneone = TRUE;
9228 }
9229 else
9230 pent->plt.offset = (bfd_vma) -1;
9231 if (!doneone)
9232 {
9233 h->plt.plist = NULL;
9234 h->needs_plt = 0;
9235 }
9236 }
9237 else
9238 {
9239 h->plt.plist = NULL;
9240 h->needs_plt = 0;
9241 }
9242
9243 eh = (struct ppc_link_hash_entry *) h;
9244 /* Run through the TLS GD got entries first if we're changing them
9245 to TPREL. */
9246 if ((eh->tls_mask & TLS_TPRELGD) != 0)
9247 for (gent = h->got.glist; gent != NULL; gent = gent->next)
9248 if (gent->got.refcount > 0
9249 && (gent->tls_type & TLS_GD) != 0)
9250 {
9251 /* This was a GD entry that has been converted to TPREL. If
9252 there happens to be a TPREL entry we can use that one. */
9253 struct got_entry *ent;
9254 for (ent = h->got.glist; ent != NULL; ent = ent->next)
9255 if (ent->got.refcount > 0
9256 && (ent->tls_type & TLS_TPREL) != 0
9257 && ent->addend == gent->addend
9258 && ent->owner == gent->owner)
9259 {
9260 gent->got.refcount = 0;
9261 break;
9262 }
9263
9264 /* If not, then we'll be using our own TPREL entry. */
9265 if (gent->got.refcount != 0)
9266 gent->tls_type = TLS_TLS | TLS_TPREL;
9267 }
9268
9269 /* Remove any list entry that won't generate a word in the GOT before
9270 we call merge_got_entries. Otherwise we risk merging to empty
9271 entries. */
9272 pgent = &h->got.glist;
9273 while ((gent = *pgent) != NULL)
9274 if (gent->got.refcount > 0)
9275 {
9276 if ((gent->tls_type & TLS_LD) != 0
9277 && !h->def_dynamic)
9278 {
9279 ppc64_tlsld_got (gent->owner)->got.refcount += 1;
9280 *pgent = gent->next;
9281 }
9282 else
9283 pgent = &gent->next;
9284 }
9285 else
9286 *pgent = gent->next;
9287
9288 if (!htab->do_multi_toc)
9289 merge_got_entries (&h->got.glist);
9290
9291 for (gent = h->got.glist; gent != NULL; gent = gent->next)
9292 if (!gent->is_indirect)
9293 {
9294 /* Make sure this symbol is output as a dynamic symbol.
9295 Undefined weak syms won't yet be marked as dynamic,
9296 nor will all TLS symbols. */
9297 if (h->dynindx == -1
9298 && !h->forced_local
9299 && h->type != STT_GNU_IFUNC
9300 && htab->elf.dynamic_sections_created)
9301 {
9302 if (! bfd_elf_link_record_dynamic_symbol (info, h))
9303 return FALSE;
9304 }
9305
9306 if (!is_ppc64_elf (gent->owner))
9307 abort ();
9308
9309 allocate_got (h, info, gent);
9310 }
9311
9312 if (eh->dyn_relocs == NULL
9313 || (!htab->elf.dynamic_sections_created
9314 && h->type != STT_GNU_IFUNC))
9315 return TRUE;
9316
9317 /* In the shared -Bsymbolic case, discard space allocated for
9318 dynamic pc-relative relocs against symbols which turn out to be
9319 defined in regular objects. For the normal shared case, discard
9320 space for relocs that have become local due to symbol visibility
9321 changes. */
9322
9323 if (info->shared)
9324 {
9325 /* Relocs that use pc_count are those that appear on a call insn,
9326 or certain REL relocs (see must_be_dyn_reloc) that can be
9327 generated via assembly. We want calls to protected symbols to
9328 resolve directly to the function rather than going via the plt.
9329 If people want function pointer comparisons to work as expected
9330 then they should avoid writing weird assembly. */
9331 if (SYMBOL_CALLS_LOCAL (info, h))
9332 {
9333 struct elf_dyn_relocs **pp;
9334
9335 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
9336 {
9337 p->count -= p->pc_count;
9338 p->pc_count = 0;
9339 if (p->count == 0)
9340 *pp = p->next;
9341 else
9342 pp = &p->next;
9343 }
9344 }
9345
9346 /* Also discard relocs on undefined weak syms with non-default
9347 visibility. */
9348 if (eh->dyn_relocs != NULL
9349 && h->root.type == bfd_link_hash_undefweak)
9350 {
9351 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
9352 eh->dyn_relocs = NULL;
9353
9354 /* Make sure this symbol is output as a dynamic symbol.
9355 Undefined weak syms won't yet be marked as dynamic. */
9356 else if (h->dynindx == -1
9357 && !h->forced_local)
9358 {
9359 if (! bfd_elf_link_record_dynamic_symbol (info, h))
9360 return FALSE;
9361 }
9362 }
9363 }
9364 else if (h->type == STT_GNU_IFUNC)
9365 {
9366 if (!h->non_got_ref)
9367 eh->dyn_relocs = NULL;
9368 }
9369 else if (ELIMINATE_COPY_RELOCS)
9370 {
9371 /* For the non-shared case, discard space for relocs against
9372 symbols which turn out to need copy relocs or are not
9373 dynamic. */
9374
9375 if (!h->non_got_ref
9376 && !h->def_regular)
9377 {
9378 /* Make sure this symbol is output as a dynamic symbol.
9379 Undefined weak syms won't yet be marked as dynamic. */
9380 if (h->dynindx == -1
9381 && !h->forced_local)
9382 {
9383 if (! bfd_elf_link_record_dynamic_symbol (info, h))
9384 return FALSE;
9385 }
9386
9387 /* If that succeeded, we know we'll be keeping all the
9388 relocs. */
9389 if (h->dynindx != -1)
9390 goto keep;
9391 }
9392
9393 eh->dyn_relocs = NULL;
9394
9395 keep: ;
9396 }
9397
9398 /* Finally, allocate space. */
9399 for (p = eh->dyn_relocs; p != NULL; p = p->next)
9400 {
9401 asection *sreloc = elf_section_data (p->sec)->sreloc;
9402 if (eh->elf.type == STT_GNU_IFUNC)
9403 sreloc = htab->reliplt;
9404 sreloc->size += p->count * sizeof (Elf64_External_Rela);
9405 }
9406
9407 return TRUE;
9408 }
9409
9410 /* Find any dynamic relocs that apply to read-only sections. */
9411
9412 static bfd_boolean
9413 readonly_dynrelocs (struct elf_link_hash_entry *h, void *inf)
9414 {
9415 struct ppc_link_hash_entry *eh;
9416 struct elf_dyn_relocs *p;
9417
9418 eh = (struct ppc_link_hash_entry *) h;
9419 for (p = eh->dyn_relocs; p != NULL; p = p->next)
9420 {
9421 asection *s = p->sec->output_section;
9422
9423 if (s != NULL && (s->flags & SEC_READONLY) != 0)
9424 {
9425 struct bfd_link_info *info = inf;
9426
9427 info->flags |= DF_TEXTREL;
9428
9429 /* Not an error, just cut short the traversal. */
9430 return FALSE;
9431 }
9432 }
9433 return TRUE;
9434 }
9435
9436 /* Set the sizes of the dynamic sections. */
9437
9438 static bfd_boolean
9439 ppc64_elf_size_dynamic_sections (bfd *output_bfd,
9440 struct bfd_link_info *info)
9441 {
9442 struct ppc_link_hash_table *htab;
9443 bfd *dynobj;
9444 asection *s;
9445 bfd_boolean relocs;
9446 bfd *ibfd;
9447 struct got_entry *first_tlsld;
9448
9449 htab = ppc_hash_table (info);
9450 if (htab == NULL)
9451 return FALSE;
9452
9453 dynobj = htab->elf.dynobj;
9454 if (dynobj == NULL)
9455 abort ();
9456
9457 if (htab->elf.dynamic_sections_created)
9458 {
9459 /* Set the contents of the .interp section to the interpreter. */
9460 if (info->executable)
9461 {
9462 s = bfd_get_linker_section (dynobj, ".interp");
9463 if (s == NULL)
9464 abort ();
9465 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
9466 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
9467 }
9468 }
9469
9470 /* Set up .got offsets for local syms, and space for local dynamic
9471 relocs. */
9472 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
9473 {
9474 struct got_entry **lgot_ents;
9475 struct got_entry **end_lgot_ents;
9476 struct plt_entry **local_plt;
9477 struct plt_entry **end_local_plt;
9478 unsigned char *lgot_masks;
9479 bfd_size_type locsymcount;
9480 Elf_Internal_Shdr *symtab_hdr;
9481
9482 if (!is_ppc64_elf (ibfd))
9483 continue;
9484
9485 for (s = ibfd->sections; s != NULL; s = s->next)
9486 {
9487 struct ppc_dyn_relocs *p;
9488
9489 for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
9490 {
9491 if (!bfd_is_abs_section (p->sec)
9492 && bfd_is_abs_section (p->sec->output_section))
9493 {
9494 /* Input section has been discarded, either because
9495 it is a copy of a linkonce section or due to
9496 linker script /DISCARD/, so we'll be discarding
9497 the relocs too. */
9498 }
9499 else if (p->count != 0)
9500 {
9501 asection *srel = elf_section_data (p->sec)->sreloc;
9502 if (p->ifunc)
9503 srel = htab->reliplt;
9504 srel->size += p->count * sizeof (Elf64_External_Rela);
9505 if ((p->sec->output_section->flags & SEC_READONLY) != 0)
9506 info->flags |= DF_TEXTREL;
9507 }
9508 }
9509 }
9510
9511 lgot_ents = elf_local_got_ents (ibfd);
9512 if (!lgot_ents)
9513 continue;
9514
9515 symtab_hdr = &elf_symtab_hdr (ibfd);
9516 locsymcount = symtab_hdr->sh_info;
9517 end_lgot_ents = lgot_ents + locsymcount;
9518 local_plt = (struct plt_entry **) end_lgot_ents;
9519 end_local_plt = local_plt + locsymcount;
9520 lgot_masks = (unsigned char *) end_local_plt;
9521 s = ppc64_elf_tdata (ibfd)->got;
9522 for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
9523 {
9524 struct got_entry **pent, *ent;
9525
9526 pent = lgot_ents;
9527 while ((ent = *pent) != NULL)
9528 if (ent->got.refcount > 0)
9529 {
9530 if ((ent->tls_type & *lgot_masks & TLS_LD) != 0)
9531 {
9532 ppc64_tlsld_got (ibfd)->got.refcount += 1;
9533 *pent = ent->next;
9534 }
9535 else
9536 {
9537 unsigned int ent_size = 8;
9538 unsigned int rel_size = sizeof (Elf64_External_Rela);
9539
9540 ent->got.offset = s->size;
9541 if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
9542 {
9543 ent_size *= 2;
9544 rel_size *= 2;
9545 }
9546 s->size += ent_size;
9547 if ((*lgot_masks & PLT_IFUNC) != 0)
9548 {
9549 htab->reliplt->size += rel_size;
9550 htab->got_reli_size += rel_size;
9551 }
9552 else if (info->shared)
9553 {
9554 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
9555 srel->size += rel_size;
9556 }
9557 pent = &ent->next;
9558 }
9559 }
9560 else
9561 *pent = ent->next;
9562 }
9563
9564 /* Allocate space for calls to local STT_GNU_IFUNC syms in .iplt. */
9565 for (; local_plt < end_local_plt; ++local_plt)
9566 {
9567 struct plt_entry *ent;
9568
9569 for (ent = *local_plt; ent != NULL; ent = ent->next)
9570 if (ent->plt.refcount > 0)
9571 {
9572 s = htab->iplt;
9573 ent->plt.offset = s->size;
9574 s->size += PLT_ENTRY_SIZE;
9575
9576 htab->reliplt->size += sizeof (Elf64_External_Rela);
9577 }
9578 else
9579 ent->plt.offset = (bfd_vma) -1;
9580 }
9581 }
9582
9583 /* Allocate global sym .plt and .got entries, and space for global
9584 sym dynamic relocs. */
9585 elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, info);
9586
9587 first_tlsld = NULL;
9588 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
9589 {
9590 struct got_entry *ent;
9591
9592 if (!is_ppc64_elf (ibfd))
9593 continue;
9594
9595 ent = ppc64_tlsld_got (ibfd);
9596 if (ent->got.refcount > 0)
9597 {
9598 if (!htab->do_multi_toc && first_tlsld != NULL)
9599 {
9600 ent->is_indirect = TRUE;
9601 ent->got.ent = first_tlsld;
9602 }
9603 else
9604 {
9605 if (first_tlsld == NULL)
9606 first_tlsld = ent;
9607 s = ppc64_elf_tdata (ibfd)->got;
9608 ent->got.offset = s->size;
9609 ent->owner = ibfd;
9610 s->size += 16;
9611 if (info->shared)
9612 {
9613 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
9614 srel->size += sizeof (Elf64_External_Rela);
9615 }
9616 }
9617 }
9618 else
9619 ent->got.offset = (bfd_vma) -1;
9620 }
9621
9622 /* We now have determined the sizes of the various dynamic sections.
9623 Allocate memory for them. */
9624 relocs = FALSE;
9625 for (s = dynobj->sections; s != NULL; s = s->next)
9626 {
9627 if ((s->flags & SEC_LINKER_CREATED) == 0)
9628 continue;
9629
9630 if (s == htab->brlt || s == htab->relbrlt)
9631 /* These haven't been allocated yet; don't strip. */
9632 continue;
9633 else if (s == htab->got
9634 || s == htab->plt
9635 || s == htab->iplt
9636 || s == htab->glink
9637 || s == htab->dynbss)
9638 {
9639 /* Strip this section if we don't need it; see the
9640 comment below. */
9641 }
9642 else if (s == htab->glink_eh_frame)
9643 {
9644 if (!bfd_is_abs_section (s->output_section))
9645 /* Not sized yet. */
9646 continue;
9647 }
9648 else if (CONST_STRNEQ (s->name, ".rela"))
9649 {
9650 if (s->size != 0)
9651 {
9652 if (s != htab->relplt)
9653 relocs = TRUE;
9654
9655 /* We use the reloc_count field as a counter if we need
9656 to copy relocs into the output file. */
9657 s->reloc_count = 0;
9658 }
9659 }
9660 else
9661 {
9662 /* It's not one of our sections, so don't allocate space. */
9663 continue;
9664 }
9665
9666 if (s->size == 0)
9667 {
9668 /* If we don't need this section, strip it from the
9669 output file. This is mostly to handle .rela.bss and
9670 .rela.plt. We must create both sections in
9671 create_dynamic_sections, because they must be created
9672 before the linker maps input sections to output
9673 sections. The linker does that before
9674 adjust_dynamic_symbol is called, and it is that
9675 function which decides whether anything needs to go
9676 into these sections. */
9677 s->flags |= SEC_EXCLUDE;
9678 continue;
9679 }
9680
9681 if ((s->flags & SEC_HAS_CONTENTS) == 0)
9682 continue;
9683
9684 /* Allocate memory for the section contents. We use bfd_zalloc
9685 here in case unused entries are not reclaimed before the
9686 section's contents are written out. This should not happen,
9687 but this way if it does we get a R_PPC64_NONE reloc in .rela
9688 sections instead of garbage.
9689 We also rely on the section contents being zero when writing
9690 the GOT. */
9691 s->contents = bfd_zalloc (dynobj, s->size);
9692 if (s->contents == NULL)
9693 return FALSE;
9694 }
9695
9696 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
9697 {
9698 if (!is_ppc64_elf (ibfd))
9699 continue;
9700
9701 s = ppc64_elf_tdata (ibfd)->got;
9702 if (s != NULL && s != htab->got)
9703 {
9704 if (s->size == 0)
9705 s->flags |= SEC_EXCLUDE;
9706 else
9707 {
9708 s->contents = bfd_zalloc (ibfd, s->size);
9709 if (s->contents == NULL)
9710 return FALSE;
9711 }
9712 }
9713 s = ppc64_elf_tdata (ibfd)->relgot;
9714 if (s != NULL)
9715 {
9716 if (s->size == 0)
9717 s->flags |= SEC_EXCLUDE;
9718 else
9719 {
9720 s->contents = bfd_zalloc (ibfd, s->size);
9721 if (s->contents == NULL)
9722 return FALSE;
9723 relocs = TRUE;
9724 s->reloc_count = 0;
9725 }
9726 }
9727 }
9728
9729 if (htab->elf.dynamic_sections_created)
9730 {
9731 /* Add some entries to the .dynamic section. We fill in the
9732 values later, in ppc64_elf_finish_dynamic_sections, but we
9733 must add the entries now so that we get the correct size for
9734 the .dynamic section. The DT_DEBUG entry is filled in by the
9735 dynamic linker and used by the debugger. */
9736 #define add_dynamic_entry(TAG, VAL) \
9737 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
9738
9739 if (info->executable)
9740 {
9741 if (!add_dynamic_entry (DT_DEBUG, 0))
9742 return FALSE;
9743 }
9744
9745 if (htab->plt != NULL && htab->plt->size != 0)
9746 {
9747 if (!add_dynamic_entry (DT_PLTGOT, 0)
9748 || !add_dynamic_entry (DT_PLTRELSZ, 0)
9749 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
9750 || !add_dynamic_entry (DT_JMPREL, 0)
9751 || !add_dynamic_entry (DT_PPC64_GLINK, 0))
9752 return FALSE;
9753 }
9754
9755 if (NO_OPD_RELOCS && abiversion (output_bfd) <= 1)
9756 {
9757 if (!add_dynamic_entry (DT_PPC64_OPD, 0)
9758 || !add_dynamic_entry (DT_PPC64_OPDSZ, 0))
9759 return FALSE;
9760 }
9761
9762 if (!htab->no_tls_get_addr_opt
9763 && htab->tls_get_addr_fd != NULL
9764 && htab->tls_get_addr_fd->elf.plt.plist != NULL
9765 && !add_dynamic_entry (DT_PPC64_TLSOPT, 0))
9766 return FALSE;
9767
9768 if (relocs)
9769 {
9770 if (!add_dynamic_entry (DT_RELA, 0)
9771 || !add_dynamic_entry (DT_RELASZ, 0)
9772 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
9773 return FALSE;
9774
9775 /* If any dynamic relocs apply to a read-only section,
9776 then we need a DT_TEXTREL entry. */
9777 if ((info->flags & DF_TEXTREL) == 0)
9778 elf_link_hash_traverse (&htab->elf, readonly_dynrelocs, info);
9779
9780 if ((info->flags & DF_TEXTREL) != 0)
9781 {
9782 if (!add_dynamic_entry (DT_TEXTREL, 0))
9783 return FALSE;
9784 }
9785 }
9786 }
9787 #undef add_dynamic_entry
9788
9789 return TRUE;
9790 }
9791
9792 /* Determine the type of stub needed, if any, for a call. */
9793
9794 static inline enum ppc_stub_type
9795 ppc_type_of_stub (asection *input_sec,
9796 const Elf_Internal_Rela *rel,
9797 struct ppc_link_hash_entry **hash,
9798 struct plt_entry **plt_ent,
9799 bfd_vma destination)
9800 {
9801 struct ppc_link_hash_entry *h = *hash;
9802 bfd_vma location;
9803 bfd_vma branch_offset;
9804 bfd_vma max_branch_offset;
9805 enum elf_ppc64_reloc_type r_type;
9806
9807 if (h != NULL)
9808 {
9809 struct plt_entry *ent;
9810 struct ppc_link_hash_entry *fdh = h;
9811 if (h->oh != NULL
9812 && h->oh->is_func_descriptor)
9813 {
9814 fdh = ppc_follow_link (h->oh);
9815 *hash = fdh;
9816 }
9817
9818 for (ent = fdh->elf.plt.plist; ent != NULL; ent = ent->next)
9819 if (ent->addend == rel->r_addend
9820 && ent->plt.offset != (bfd_vma) -1)
9821 {
9822 *plt_ent = ent;
9823 return ppc_stub_plt_call;
9824 }
9825
9826 /* Here, we know we don't have a plt entry. If we don't have a
9827 either a defined function descriptor or a defined entry symbol
9828 in a regular object file, then it is pointless trying to make
9829 any other type of stub. */
9830 if (!is_static_defined (&fdh->elf)
9831 && !is_static_defined (&h->elf))
9832 return ppc_stub_none;
9833 }
9834 else if (elf_local_got_ents (input_sec->owner) != NULL)
9835 {
9836 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (input_sec->owner);
9837 struct plt_entry **local_plt = (struct plt_entry **)
9838 elf_local_got_ents (input_sec->owner) + symtab_hdr->sh_info;
9839 unsigned long r_symndx = ELF64_R_SYM (rel->r_info);
9840
9841 if (local_plt[r_symndx] != NULL)
9842 {
9843 struct plt_entry *ent;
9844
9845 for (ent = local_plt[r_symndx]; ent != NULL; ent = ent->next)
9846 if (ent->addend == rel->r_addend
9847 && ent->plt.offset != (bfd_vma) -1)
9848 {
9849 *plt_ent = ent;
9850 return ppc_stub_plt_call;
9851 }
9852 }
9853 }
9854
9855 /* Determine where the call point is. */
9856 location = (input_sec->output_offset
9857 + input_sec->output_section->vma
9858 + rel->r_offset);
9859
9860 branch_offset = destination - location;
9861 r_type = ELF64_R_TYPE (rel->r_info);
9862
9863 /* Determine if a long branch stub is needed. */
9864 max_branch_offset = 1 << 25;
9865 if (r_type != R_PPC64_REL24)
9866 max_branch_offset = 1 << 15;
9867
9868 if (branch_offset + max_branch_offset >= 2 * max_branch_offset)
9869 /* We need a stub. Figure out whether a long_branch or plt_branch
9870 is needed later. */
9871 return ppc_stub_long_branch;
9872
9873 return ppc_stub_none;
9874 }
9875
9876 /* With power7 weakly ordered memory model, it is possible for ld.so
9877 to update a plt entry in one thread and have another thread see a
9878 stale zero toc entry. To avoid this we need some sort of acquire
9879 barrier in the call stub. One solution is to make the load of the
9880 toc word seem to appear to depend on the load of the function entry
9881 word. Another solution is to test for r2 being zero, and branch to
9882 the appropriate glink entry if so.
9883
9884 . fake dep barrier compare
9885 . ld 12,xxx(2) ld 12,xxx(2)
9886 . mtctr 12 mtctr 12
9887 . xor 11,12,12 ld 2,xxx+8(2)
9888 . add 2,2,11 cmpldi 2,0
9889 . ld 2,xxx+8(2) bnectr+
9890 . bctr b <glink_entry>
9891
9892 The solution involving the compare turns out to be faster, so
9893 that's what we use unless the branch won't reach. */
9894
9895 #define ALWAYS_USE_FAKE_DEP 0
9896 #define ALWAYS_EMIT_R2SAVE 0
9897
9898 #define PPC_LO(v) ((v) & 0xffff)
9899 #define PPC_HI(v) (((v) >> 16) & 0xffff)
9900 #define PPC_HA(v) PPC_HI ((v) + 0x8000)
9901
9902 static inline unsigned int
9903 plt_stub_size (struct ppc_link_hash_table *htab,
9904 struct ppc_stub_hash_entry *stub_entry,
9905 bfd_vma off)
9906 {
9907 unsigned size = PLT_CALL_STUB_SIZE;
9908
9909 if (!(ALWAYS_EMIT_R2SAVE
9910 || stub_entry->stub_type == ppc_stub_plt_call_r2save))
9911 size -= 4;
9912 if (!htab->plt_static_chain)
9913 size -= 4;
9914 if (htab->plt_thread_safe)
9915 size += 8;
9916 if (PPC_HA (off) == 0)
9917 size -= 4;
9918 if (PPC_HA (off + 8 + 8 * htab->plt_static_chain) != PPC_HA (off))
9919 size += 4;
9920 if (stub_entry->h != NULL
9921 && (stub_entry->h == htab->tls_get_addr_fd
9922 || stub_entry->h == htab->tls_get_addr)
9923 && !htab->no_tls_get_addr_opt)
9924 size += 13 * 4;
9925 return size;
9926 }
9927
9928 /* If this stub would cross fewer 2**plt_stub_align boundaries if we align,
9929 then return the padding needed to do so. */
9930 static inline unsigned int
9931 plt_stub_pad (struct ppc_link_hash_table *htab,
9932 struct ppc_stub_hash_entry *stub_entry,
9933 bfd_vma plt_off)
9934 {
9935 int stub_align = 1 << htab->plt_stub_align;
9936 unsigned stub_size = plt_stub_size (htab, stub_entry, plt_off);
9937 bfd_vma stub_off = stub_entry->stub_sec->size;
9938
9939 if (((stub_off + stub_size - 1) & -stub_align) - (stub_off & -stub_align)
9940 > (stub_size & -stub_align))
9941 return stub_align - (stub_off & (stub_align - 1));
9942 return 0;
9943 }
9944
9945 /* Build a .plt call stub. */
9946
9947 static inline bfd_byte *
9948 build_plt_stub (struct ppc_link_hash_table *htab,
9949 struct ppc_stub_hash_entry *stub_entry,
9950 bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
9951 {
9952 bfd *obfd = htab->stub_bfd;
9953 bfd_boolean plt_static_chain = htab->plt_static_chain;
9954 bfd_boolean plt_thread_safe = htab->plt_thread_safe;
9955 bfd_boolean use_fake_dep = plt_thread_safe;
9956 bfd_vma cmp_branch_off = 0;
9957
9958 if (!ALWAYS_USE_FAKE_DEP
9959 && plt_thread_safe
9960 && !(stub_entry->h != NULL
9961 && (stub_entry->h == htab->tls_get_addr_fd
9962 || stub_entry->h == htab->tls_get_addr)
9963 && !htab->no_tls_get_addr_opt))
9964 {
9965 bfd_vma pltoff = stub_entry->plt_ent->plt.offset & ~1;
9966 bfd_vma pltindex = (pltoff - PLT_INITIAL_ENTRY_SIZE) / PLT_ENTRY_SIZE;
9967 bfd_vma glinkoff = GLINK_CALL_STUB_SIZE + pltindex * 8;
9968 bfd_vma to, from;
9969
9970 if (pltindex > 32768)
9971 glinkoff += (pltindex - 32768) * 4;
9972 to = (glinkoff
9973 + htab->glink->output_offset
9974 + htab->glink->output_section->vma);
9975 from = (p - stub_entry->stub_sec->contents
9976 + 4 * (ALWAYS_EMIT_R2SAVE
9977 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
9978 + 4 * (PPC_HA (offset) != 0)
9979 + 4 * (PPC_HA (offset + 8 + 8 * plt_static_chain)
9980 != PPC_HA (offset))
9981 + 4 * (plt_static_chain != 0)
9982 + 20
9983 + stub_entry->stub_sec->output_offset
9984 + stub_entry->stub_sec->output_section->vma);
9985 cmp_branch_off = to - from;
9986 use_fake_dep = cmp_branch_off + (1 << 25) >= (1 << 26);
9987 }
9988
9989 if (PPC_HA (offset) != 0)
9990 {
9991 if (r != NULL)
9992 {
9993 if (ALWAYS_EMIT_R2SAVE
9994 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
9995 r[0].r_offset += 4;
9996 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
9997 r[1].r_offset = r[0].r_offset + 4;
9998 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
9999 r[1].r_addend = r[0].r_addend;
10000 if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10001 {
10002 r[2].r_offset = r[1].r_offset + 4;
10003 r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO);
10004 r[2].r_addend = r[0].r_addend;
10005 }
10006 else
10007 {
10008 r[2].r_offset = r[1].r_offset + 8 + 8 * use_fake_dep;
10009 r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10010 r[2].r_addend = r[0].r_addend + 8;
10011 if (plt_static_chain)
10012 {
10013 r[3].r_offset = r[2].r_offset + 4;
10014 r[3].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10015 r[3].r_addend = r[0].r_addend + 16;
10016 }
10017 }
10018 }
10019 if (ALWAYS_EMIT_R2SAVE
10020 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10021 bfd_put_32 (obfd, STD_R2_40R1, p), p += 4;
10022 bfd_put_32 (obfd, ADDIS_R11_R2 | PPC_HA (offset), p), p += 4;
10023 bfd_put_32 (obfd, LD_R12_0R11 | PPC_LO (offset), p), p += 4;
10024 if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10025 {
10026 bfd_put_32 (obfd, ADDI_R11_R11 | PPC_LO (offset), p), p += 4;
10027 offset = 0;
10028 }
10029 bfd_put_32 (obfd, MTCTR_R12, p), p += 4;
10030 if (use_fake_dep)
10031 {
10032 bfd_put_32 (obfd, XOR_R2_R12_R12, p), p += 4;
10033 bfd_put_32 (obfd, ADD_R11_R11_R2, p), p += 4;
10034 }
10035 bfd_put_32 (obfd, LD_R2_0R11 | PPC_LO (offset + 8), p), p += 4;
10036 if (plt_static_chain)
10037 bfd_put_32 (obfd, LD_R11_0R11 | PPC_LO (offset + 16), p), p += 4;
10038 }
10039 else
10040 {
10041 if (r != NULL)
10042 {
10043 if (ALWAYS_EMIT_R2SAVE
10044 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10045 r[0].r_offset += 4;
10046 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10047 if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10048 {
10049 r[1].r_offset = r[0].r_offset + 4;
10050 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16);
10051 r[1].r_addend = r[0].r_addend;
10052 }
10053 else
10054 {
10055 r[1].r_offset = r[0].r_offset + 8 + 8 * use_fake_dep;
10056 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10057 r[1].r_addend = r[0].r_addend + 8 + 8 * plt_static_chain;
10058 if (plt_static_chain)
10059 {
10060 r[2].r_offset = r[1].r_offset + 4;
10061 r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10062 r[2].r_addend = r[0].r_addend + 8;
10063 }
10064 }
10065 }
10066 if (ALWAYS_EMIT_R2SAVE
10067 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10068 bfd_put_32 (obfd, STD_R2_40R1, p), p += 4;
10069 bfd_put_32 (obfd, LD_R12_0R2 | PPC_LO (offset), p), p += 4;
10070 if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10071 {
10072 bfd_put_32 (obfd, ADDI_R2_R2 | PPC_LO (offset), p), p += 4;
10073 offset = 0;
10074 }
10075 bfd_put_32 (obfd, MTCTR_R12, p), p += 4;
10076 if (use_fake_dep)
10077 {
10078 bfd_put_32 (obfd, XOR_R11_R12_R12, p), p += 4;
10079 bfd_put_32 (obfd, ADD_R2_R2_R11, p), p += 4;
10080 }
10081 if (plt_static_chain)
10082 bfd_put_32 (obfd, LD_R11_0R2 | PPC_LO (offset + 16), p), p += 4;
10083 bfd_put_32 (obfd, LD_R2_0R2 | PPC_LO (offset + 8), p), p += 4;
10084 }
10085 if (plt_thread_safe && !use_fake_dep)
10086 {
10087 bfd_put_32 (obfd, CMPLDI_R2_0, p), p += 4;
10088 bfd_put_32 (obfd, BNECTR_P4, p), p += 4;
10089 bfd_put_32 (obfd, B_DOT | (cmp_branch_off & 0x3fffffc), p), p += 4;
10090 }
10091 else
10092 bfd_put_32 (obfd, BCTR, p), p += 4;
10093 return p;
10094 }
10095
10096 /* Build a special .plt call stub for __tls_get_addr. */
10097
10098 #define LD_R11_0R3 0xe9630000
10099 #define LD_R12_0R3 0xe9830000
10100 #define MR_R0_R3 0x7c601b78
10101 #define CMPDI_R11_0 0x2c2b0000
10102 #define ADD_R3_R12_R13 0x7c6c6a14
10103 #define BEQLR 0x4d820020
10104 #define MR_R3_R0 0x7c030378
10105 #define MFLR_R11 0x7d6802a6
10106 #define STD_R11_0R1 0xf9610000
10107 #define BCTRL 0x4e800421
10108 #define LD_R11_0R1 0xe9610000
10109 #define LD_R2_0R1 0xe8410000
10110 #define MTLR_R11 0x7d6803a6
10111
10112 static inline bfd_byte *
10113 build_tls_get_addr_stub (struct ppc_link_hash_table *htab,
10114 struct ppc_stub_hash_entry *stub_entry,
10115 bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
10116 {
10117 bfd *obfd = htab->stub_bfd;
10118
10119 bfd_put_32 (obfd, LD_R11_0R3 + 0, p), p += 4;
10120 bfd_put_32 (obfd, LD_R12_0R3 + 8, p), p += 4;
10121 bfd_put_32 (obfd, MR_R0_R3, p), p += 4;
10122 bfd_put_32 (obfd, CMPDI_R11_0, p), p += 4;
10123 bfd_put_32 (obfd, ADD_R3_R12_R13, p), p += 4;
10124 bfd_put_32 (obfd, BEQLR, p), p += 4;
10125 bfd_put_32 (obfd, MR_R3_R0, p), p += 4;
10126 bfd_put_32 (obfd, MFLR_R11, p), p += 4;
10127 bfd_put_32 (obfd, STD_R11_0R1 + 32, p), p += 4;
10128
10129 if (r != NULL)
10130 r[0].r_offset += 9 * 4;
10131 p = build_plt_stub (htab, stub_entry, p, offset, r);
10132 bfd_put_32 (obfd, BCTRL, p - 4);
10133
10134 bfd_put_32 (obfd, LD_R11_0R1 + 32, p), p += 4;
10135 bfd_put_32 (obfd, LD_R2_0R1 + 40, p), p += 4;
10136 bfd_put_32 (obfd, MTLR_R11, p), p += 4;
10137 bfd_put_32 (obfd, BLR, p), p += 4;
10138
10139 return p;
10140 }
10141
10142 static Elf_Internal_Rela *
10143 get_relocs (asection *sec, int count)
10144 {
10145 Elf_Internal_Rela *relocs;
10146 struct bfd_elf_section_data *elfsec_data;
10147
10148 elfsec_data = elf_section_data (sec);
10149 relocs = elfsec_data->relocs;
10150 if (relocs == NULL)
10151 {
10152 bfd_size_type relsize;
10153 relsize = sec->reloc_count * sizeof (*relocs);
10154 relocs = bfd_alloc (sec->owner, relsize);
10155 if (relocs == NULL)
10156 return NULL;
10157 elfsec_data->relocs = relocs;
10158 elfsec_data->rela.hdr = bfd_zalloc (sec->owner,
10159 sizeof (Elf_Internal_Shdr));
10160 if (elfsec_data->rela.hdr == NULL)
10161 return NULL;
10162 elfsec_data->rela.hdr->sh_size = (sec->reloc_count
10163 * sizeof (Elf64_External_Rela));
10164 elfsec_data->rela.hdr->sh_entsize = sizeof (Elf64_External_Rela);
10165 sec->reloc_count = 0;
10166 }
10167 relocs += sec->reloc_count;
10168 sec->reloc_count += count;
10169 return relocs;
10170 }
10171
10172 static bfd_vma
10173 get_r2off (struct bfd_link_info *info,
10174 struct ppc_stub_hash_entry *stub_entry)
10175 {
10176 struct ppc_link_hash_table *htab = ppc_hash_table (info);
10177 bfd_vma r2off = htab->stub_group[stub_entry->target_section->id].toc_off;
10178
10179 if (r2off == 0)
10180 {
10181 /* Support linking -R objects. Get the toc pointer from the
10182 opd entry. */
10183 char buf[8];
10184 asection *opd = stub_entry->h->elf.root.u.def.section;
10185 bfd_vma opd_off = stub_entry->h->elf.root.u.def.value;
10186
10187 if (strcmp (opd->name, ".opd") != 0
10188 || opd->reloc_count != 0)
10189 {
10190 info->callbacks->einfo (_("%P: cannot find opd entry toc for `%T'\n"),
10191 stub_entry->h->elf.root.root.string);
10192 bfd_set_error (bfd_error_bad_value);
10193 return 0;
10194 }
10195 if (!bfd_get_section_contents (opd->owner, opd, buf, opd_off + 8, 8))
10196 return 0;
10197 r2off = bfd_get_64 (opd->owner, buf);
10198 r2off -= elf_gp (info->output_bfd);
10199 }
10200 r2off -= htab->stub_group[stub_entry->id_sec->id].toc_off;
10201 return r2off;
10202 }
10203
10204 static bfd_boolean
10205 ppc_build_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
10206 {
10207 struct ppc_stub_hash_entry *stub_entry;
10208 struct ppc_branch_hash_entry *br_entry;
10209 struct bfd_link_info *info;
10210 struct ppc_link_hash_table *htab;
10211 bfd_byte *loc;
10212 bfd_byte *p;
10213 bfd_vma dest, off;
10214 int size;
10215 Elf_Internal_Rela *r;
10216 asection *plt;
10217
10218 /* Massage our args to the form they really have. */
10219 stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
10220 info = in_arg;
10221
10222 htab = ppc_hash_table (info);
10223 if (htab == NULL)
10224 return FALSE;
10225
10226 /* Make a note of the offset within the stubs for this entry. */
10227 stub_entry->stub_offset = stub_entry->stub_sec->size;
10228 loc = stub_entry->stub_sec->contents + stub_entry->stub_offset;
10229
10230 htab->stub_count[stub_entry->stub_type - 1] += 1;
10231 switch (stub_entry->stub_type)
10232 {
10233 case ppc_stub_long_branch:
10234 case ppc_stub_long_branch_r2off:
10235 /* Branches are relative. This is where we are going to. */
10236 off = dest = (stub_entry->target_value
10237 + stub_entry->target_section->output_offset
10238 + stub_entry->target_section->output_section->vma);
10239
10240 /* And this is where we are coming from. */
10241 off -= (stub_entry->stub_offset
10242 + stub_entry->stub_sec->output_offset
10243 + stub_entry->stub_sec->output_section->vma);
10244
10245 size = 4;
10246 if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
10247 {
10248 bfd_vma r2off = get_r2off (info, stub_entry);
10249
10250 if (r2off == 0)
10251 {
10252 htab->stub_error = TRUE;
10253 return FALSE;
10254 }
10255 bfd_put_32 (htab->stub_bfd, STD_R2_40R1, loc);
10256 loc += 4;
10257 size = 12;
10258 if (PPC_HA (r2off) != 0)
10259 {
10260 size = 16;
10261 bfd_put_32 (htab->stub_bfd, ADDIS_R2_R2 | PPC_HA (r2off), loc);
10262 loc += 4;
10263 }
10264 bfd_put_32 (htab->stub_bfd, ADDI_R2_R2 | PPC_LO (r2off), loc);
10265 loc += 4;
10266 off -= size - 4;
10267 }
10268 bfd_put_32 (htab->stub_bfd, B_DOT | (off & 0x3fffffc), loc);
10269
10270 if (off + (1 << 25) >= (bfd_vma) (1 << 26))
10271 {
10272 info->callbacks->einfo
10273 (_("%P: long branch stub `%s' offset overflow\n"),
10274 stub_entry->root.string);
10275 htab->stub_error = TRUE;
10276 return FALSE;
10277 }
10278
10279 if (info->emitrelocations)
10280 {
10281 r = get_relocs (stub_entry->stub_sec, 1);
10282 if (r == NULL)
10283 return FALSE;
10284 r->r_offset = loc - stub_entry->stub_sec->contents;
10285 r->r_info = ELF64_R_INFO (0, R_PPC64_REL24);
10286 r->r_addend = dest;
10287 if (stub_entry->h != NULL)
10288 {
10289 struct elf_link_hash_entry **hashes;
10290 unsigned long symndx;
10291 struct ppc_link_hash_entry *h;
10292
10293 hashes = elf_sym_hashes (htab->stub_bfd);
10294 if (hashes == NULL)
10295 {
10296 bfd_size_type hsize;
10297
10298 hsize = (htab->stub_globals + 1) * sizeof (*hashes);
10299 hashes = bfd_zalloc (htab->stub_bfd, hsize);
10300 if (hashes == NULL)
10301 return FALSE;
10302 elf_sym_hashes (htab->stub_bfd) = hashes;
10303 htab->stub_globals = 1;
10304 }
10305 symndx = htab->stub_globals++;
10306 h = stub_entry->h;
10307 hashes[symndx] = &h->elf;
10308 r->r_info = ELF64_R_INFO (symndx, R_PPC64_REL24);
10309 if (h->oh != NULL && h->oh->is_func)
10310 h = ppc_follow_link (h->oh);
10311 if (h->elf.root.u.def.section != stub_entry->target_section)
10312 /* H is an opd symbol. The addend must be zero. */
10313 r->r_addend = 0;
10314 else
10315 {
10316 off = (h->elf.root.u.def.value
10317 + h->elf.root.u.def.section->output_offset
10318 + h->elf.root.u.def.section->output_section->vma);
10319 r->r_addend -= off;
10320 }
10321 }
10322 }
10323 break;
10324
10325 case ppc_stub_plt_branch:
10326 case ppc_stub_plt_branch_r2off:
10327 br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
10328 stub_entry->root.string + 9,
10329 FALSE, FALSE);
10330 if (br_entry == NULL)
10331 {
10332 info->callbacks->einfo (_("%P: can't find branch stub `%s'\n"),
10333 stub_entry->root.string);
10334 htab->stub_error = TRUE;
10335 return FALSE;
10336 }
10337
10338 dest = (stub_entry->target_value
10339 + stub_entry->target_section->output_offset
10340 + stub_entry->target_section->output_section->vma);
10341
10342 bfd_put_64 (htab->brlt->owner, dest,
10343 htab->brlt->contents + br_entry->offset);
10344
10345 if (br_entry->iter == htab->stub_iteration)
10346 {
10347 br_entry->iter = 0;
10348
10349 if (htab->relbrlt != NULL)
10350 {
10351 /* Create a reloc for the branch lookup table entry. */
10352 Elf_Internal_Rela rela;
10353 bfd_byte *rl;
10354
10355 rela.r_offset = (br_entry->offset
10356 + htab->brlt->output_offset
10357 + htab->brlt->output_section->vma);
10358 rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
10359 rela.r_addend = dest;
10360
10361 rl = htab->relbrlt->contents;
10362 rl += (htab->relbrlt->reloc_count++
10363 * sizeof (Elf64_External_Rela));
10364 bfd_elf64_swap_reloca_out (htab->relbrlt->owner, &rela, rl);
10365 }
10366 else if (info->emitrelocations)
10367 {
10368 r = get_relocs (htab->brlt, 1);
10369 if (r == NULL)
10370 return FALSE;
10371 /* brlt, being SEC_LINKER_CREATED does not go through the
10372 normal reloc processing. Symbols and offsets are not
10373 translated from input file to output file form, so
10374 set up the offset per the output file. */
10375 r->r_offset = (br_entry->offset
10376 + htab->brlt->output_offset
10377 + htab->brlt->output_section->vma);
10378 r->r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
10379 r->r_addend = dest;
10380 }
10381 }
10382
10383 dest = (br_entry->offset
10384 + htab->brlt->output_offset
10385 + htab->brlt->output_section->vma);
10386
10387 off = (dest
10388 - elf_gp (htab->brlt->output_section->owner)
10389 - htab->stub_group[stub_entry->id_sec->id].toc_off);
10390
10391 if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
10392 {
10393 info->callbacks->einfo
10394 (_("%P: linkage table error against `%T'\n"),
10395 stub_entry->root.string);
10396 bfd_set_error (bfd_error_bad_value);
10397 htab->stub_error = TRUE;
10398 return FALSE;
10399 }
10400
10401 if (info->emitrelocations)
10402 {
10403 r = get_relocs (stub_entry->stub_sec, 1 + (PPC_HA (off) != 0));
10404 if (r == NULL)
10405 return FALSE;
10406 r[0].r_offset = loc - stub_entry->stub_sec->contents;
10407 if (bfd_big_endian (info->output_bfd))
10408 r[0].r_offset += 2;
10409 if (stub_entry->stub_type == ppc_stub_plt_branch_r2off)
10410 r[0].r_offset += 4;
10411 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10412 r[0].r_addend = dest;
10413 if (PPC_HA (off) != 0)
10414 {
10415 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
10416 r[1].r_offset = r[0].r_offset + 4;
10417 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10418 r[1].r_addend = r[0].r_addend;
10419 }
10420 }
10421
10422 if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
10423 {
10424 if (PPC_HA (off) != 0)
10425 {
10426 size = 16;
10427 bfd_put_32 (htab->stub_bfd, ADDIS_R11_R2 | PPC_HA (off), loc);
10428 loc += 4;
10429 bfd_put_32 (htab->stub_bfd, LD_R12_0R11 | PPC_LO (off), loc);
10430 }
10431 else
10432 {
10433 size = 12;
10434 bfd_put_32 (htab->stub_bfd, LD_R12_0R2 | PPC_LO (off), loc);
10435 }
10436 }
10437 else
10438 {
10439 bfd_vma r2off = get_r2off (info, stub_entry);
10440
10441 if (r2off == 0)
10442 {
10443 htab->stub_error = TRUE;
10444 return FALSE;
10445 }
10446
10447 bfd_put_32 (htab->stub_bfd, STD_R2_40R1, loc);
10448 loc += 4;
10449 size = 20;
10450 if (PPC_HA (off) != 0)
10451 {
10452 size += 4;
10453 bfd_put_32 (htab->stub_bfd, ADDIS_R11_R2 | PPC_HA (off), loc);
10454 loc += 4;
10455 bfd_put_32 (htab->stub_bfd, LD_R12_0R11 | PPC_LO (off), loc);
10456 loc += 4;
10457 }
10458 else
10459 {
10460 bfd_put_32 (htab->stub_bfd, LD_R12_0R2 | PPC_LO (off), loc);
10461 loc += 4;
10462 }
10463
10464 if (PPC_HA (r2off) != 0)
10465 {
10466 size += 4;
10467 bfd_put_32 (htab->stub_bfd, ADDIS_R2_R2 | PPC_HA (r2off), loc);
10468 loc += 4;
10469 }
10470 bfd_put_32 (htab->stub_bfd, ADDI_R2_R2 | PPC_LO (r2off), loc);
10471 }
10472 loc += 4;
10473 bfd_put_32 (htab->stub_bfd, MTCTR_R12, loc);
10474 loc += 4;
10475 bfd_put_32 (htab->stub_bfd, BCTR, loc);
10476 break;
10477
10478 case ppc_stub_plt_call:
10479 case ppc_stub_plt_call_r2save:
10480 if (stub_entry->h != NULL
10481 && stub_entry->h->is_func_descriptor
10482 && stub_entry->h->oh != NULL)
10483 {
10484 struct ppc_link_hash_entry *fh = ppc_follow_link (stub_entry->h->oh);
10485
10486 /* If the old-ABI "dot-symbol" is undefined make it weak so
10487 we don't get a link error from RELOC_FOR_GLOBAL_SYMBOL.
10488 FIXME: We used to define the symbol on one of the call
10489 stubs instead, which is why we test symbol section id
10490 against htab->top_id in various places. Likely all
10491 these checks could now disappear. */
10492 if (fh->elf.root.type == bfd_link_hash_undefined)
10493 fh->elf.root.type = bfd_link_hash_undefweak;
10494 /* Stop undo_symbol_twiddle changing it back to undefined. */
10495 fh->was_undefined = 0;
10496 }
10497
10498 /* Now build the stub. */
10499 dest = stub_entry->plt_ent->plt.offset & ~1;
10500 if (dest >= (bfd_vma) -2)
10501 abort ();
10502
10503 plt = htab->plt;
10504 if (!htab->elf.dynamic_sections_created
10505 || stub_entry->h == NULL
10506 || stub_entry->h->elf.dynindx == -1)
10507 plt = htab->iplt;
10508
10509 dest += plt->output_offset + plt->output_section->vma;
10510
10511 if (stub_entry->h == NULL
10512 && (stub_entry->plt_ent->plt.offset & 1) == 0)
10513 {
10514 Elf_Internal_Rela rela;
10515 bfd_byte *rl;
10516
10517 rela.r_offset = dest;
10518 if (htab->opd_abi)
10519 rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
10520 else
10521 rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
10522 rela.r_addend = (stub_entry->target_value
10523 + stub_entry->target_section->output_offset
10524 + stub_entry->target_section->output_section->vma);
10525
10526 rl = (htab->reliplt->contents
10527 + (htab->reliplt->reloc_count++
10528 * sizeof (Elf64_External_Rela)));
10529 bfd_elf64_swap_reloca_out (info->output_bfd, &rela, rl);
10530 stub_entry->plt_ent->plt.offset |= 1;
10531 }
10532
10533 off = (dest
10534 - elf_gp (plt->output_section->owner)
10535 - htab->stub_group[stub_entry->id_sec->id].toc_off);
10536
10537 if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
10538 {
10539 info->callbacks->einfo
10540 (_("%P: linkage table error against `%T'\n"),
10541 stub_entry->h != NULL
10542 ? stub_entry->h->elf.root.root.string
10543 : "<local sym>");
10544 bfd_set_error (bfd_error_bad_value);
10545 htab->stub_error = TRUE;
10546 return FALSE;
10547 }
10548
10549 if (htab->plt_stub_align != 0)
10550 {
10551 unsigned pad = plt_stub_pad (htab, stub_entry, off);
10552
10553 stub_entry->stub_sec->size += pad;
10554 stub_entry->stub_offset = stub_entry->stub_sec->size;
10555 loc += pad;
10556 }
10557
10558 r = NULL;
10559 if (info->emitrelocations)
10560 {
10561 r = get_relocs (stub_entry->stub_sec,
10562 (2
10563 + (PPC_HA (off) != 0)
10564 + (htab->plt_static_chain
10565 && PPC_HA (off + 16) == PPC_HA (off))));
10566 if (r == NULL)
10567 return FALSE;
10568 r[0].r_offset = loc - stub_entry->stub_sec->contents;
10569 if (bfd_big_endian (info->output_bfd))
10570 r[0].r_offset += 2;
10571 r[0].r_addend = dest;
10572 }
10573 if (stub_entry->h != NULL
10574 && (stub_entry->h == htab->tls_get_addr_fd
10575 || stub_entry->h == htab->tls_get_addr)
10576 && !htab->no_tls_get_addr_opt)
10577 p = build_tls_get_addr_stub (htab, stub_entry, loc, off, r);
10578 else
10579 p = build_plt_stub (htab, stub_entry, loc, off, r);
10580 size = p - loc;
10581 break;
10582
10583 default:
10584 BFD_FAIL ();
10585 return FALSE;
10586 }
10587
10588 stub_entry->stub_sec->size += size;
10589
10590 if (htab->emit_stub_syms)
10591 {
10592 struct elf_link_hash_entry *h;
10593 size_t len1, len2;
10594 char *name;
10595 const char *const stub_str[] = { "long_branch",
10596 "long_branch_r2off",
10597 "plt_branch",
10598 "plt_branch_r2off",
10599 "plt_call",
10600 "plt_call" };
10601
10602 len1 = strlen (stub_str[stub_entry->stub_type - 1]);
10603 len2 = strlen (stub_entry->root.string);
10604 name = bfd_malloc (len1 + len2 + 2);
10605 if (name == NULL)
10606 return FALSE;
10607 memcpy (name, stub_entry->root.string, 9);
10608 memcpy (name + 9, stub_str[stub_entry->stub_type - 1], len1);
10609 memcpy (name + len1 + 9, stub_entry->root.string + 8, len2 - 8 + 1);
10610 h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
10611 if (h == NULL)
10612 return FALSE;
10613 if (h->root.type == bfd_link_hash_new)
10614 {
10615 h->root.type = bfd_link_hash_defined;
10616 h->root.u.def.section = stub_entry->stub_sec;
10617 h->root.u.def.value = stub_entry->stub_offset;
10618 h->ref_regular = 1;
10619 h->def_regular = 1;
10620 h->ref_regular_nonweak = 1;
10621 h->forced_local = 1;
10622 h->non_elf = 0;
10623 }
10624 }
10625
10626 return TRUE;
10627 }
10628
10629 /* As above, but don't actually build the stub. Just bump offset so
10630 we know stub section sizes, and select plt_branch stubs where
10631 long_branch stubs won't do. */
10632
10633 static bfd_boolean
10634 ppc_size_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
10635 {
10636 struct ppc_stub_hash_entry *stub_entry;
10637 struct bfd_link_info *info;
10638 struct ppc_link_hash_table *htab;
10639 bfd_vma off;
10640 int size;
10641
10642 /* Massage our args to the form they really have. */
10643 stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
10644 info = in_arg;
10645
10646 htab = ppc_hash_table (info);
10647 if (htab == NULL)
10648 return FALSE;
10649
10650 if (stub_entry->stub_type == ppc_stub_plt_call
10651 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10652 {
10653 asection *plt;
10654 off = stub_entry->plt_ent->plt.offset & ~(bfd_vma) 1;
10655 if (off >= (bfd_vma) -2)
10656 abort ();
10657 plt = htab->plt;
10658 if (!htab->elf.dynamic_sections_created
10659 || stub_entry->h == NULL
10660 || stub_entry->h->elf.dynindx == -1)
10661 plt = htab->iplt;
10662 off += (plt->output_offset
10663 + plt->output_section->vma
10664 - elf_gp (plt->output_section->owner)
10665 - htab->stub_group[stub_entry->id_sec->id].toc_off);
10666
10667 size = plt_stub_size (htab, stub_entry, off);
10668 if (htab->plt_stub_align)
10669 size += plt_stub_pad (htab, stub_entry, off);
10670 if (info->emitrelocations)
10671 {
10672 stub_entry->stub_sec->reloc_count
10673 += (2
10674 + (PPC_HA (off) != 0)
10675 + (htab->plt_static_chain
10676 && PPC_HA (off + 16) == PPC_HA (off)));
10677 stub_entry->stub_sec->flags |= SEC_RELOC;
10678 }
10679 }
10680 else
10681 {
10682 /* ppc_stub_long_branch or ppc_stub_plt_branch, or their r2off
10683 variants. */
10684 bfd_vma r2off = 0;
10685
10686 off = (stub_entry->target_value
10687 + stub_entry->target_section->output_offset
10688 + stub_entry->target_section->output_section->vma);
10689 off -= (stub_entry->stub_sec->size
10690 + stub_entry->stub_sec->output_offset
10691 + stub_entry->stub_sec->output_section->vma);
10692
10693 /* Reset the stub type from the plt variant in case we now
10694 can reach with a shorter stub. */
10695 if (stub_entry->stub_type >= ppc_stub_plt_branch)
10696 stub_entry->stub_type += ppc_stub_long_branch - ppc_stub_plt_branch;
10697
10698 size = 4;
10699 if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
10700 {
10701 r2off = get_r2off (info, stub_entry);
10702 if (r2off == 0)
10703 {
10704 htab->stub_error = TRUE;
10705 return FALSE;
10706 }
10707 size = 12;
10708 if (PPC_HA (r2off) != 0)
10709 size = 16;
10710 off -= size - 4;
10711 }
10712
10713 /* If the branch offset if too big, use a ppc_stub_plt_branch. */
10714 if (off + (1 << 25) >= (bfd_vma) (1 << 26))
10715 {
10716 struct ppc_branch_hash_entry *br_entry;
10717
10718 br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
10719 stub_entry->root.string + 9,
10720 TRUE, FALSE);
10721 if (br_entry == NULL)
10722 {
10723 info->callbacks->einfo (_("%P: can't build branch stub `%s'\n"),
10724 stub_entry->root.string);
10725 htab->stub_error = TRUE;
10726 return FALSE;
10727 }
10728
10729 if (br_entry->iter != htab->stub_iteration)
10730 {
10731 br_entry->iter = htab->stub_iteration;
10732 br_entry->offset = htab->brlt->size;
10733 htab->brlt->size += 8;
10734
10735 if (htab->relbrlt != NULL)
10736 htab->relbrlt->size += sizeof (Elf64_External_Rela);
10737 else if (info->emitrelocations)
10738 {
10739 htab->brlt->reloc_count += 1;
10740 htab->brlt->flags |= SEC_RELOC;
10741 }
10742 }
10743
10744 stub_entry->stub_type += ppc_stub_plt_branch - ppc_stub_long_branch;
10745 off = (br_entry->offset
10746 + htab->brlt->output_offset
10747 + htab->brlt->output_section->vma
10748 - elf_gp (htab->brlt->output_section->owner)
10749 - htab->stub_group[stub_entry->id_sec->id].toc_off);
10750
10751 if (info->emitrelocations)
10752 {
10753 stub_entry->stub_sec->reloc_count += 1 + (PPC_HA (off) != 0);
10754 stub_entry->stub_sec->flags |= SEC_RELOC;
10755 }
10756
10757 if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
10758 {
10759 size = 12;
10760 if (PPC_HA (off) != 0)
10761 size = 16;
10762 }
10763 else
10764 {
10765 size = 20;
10766 if (PPC_HA (off) != 0)
10767 size += 4;
10768
10769 if (PPC_HA (r2off) != 0)
10770 size += 4;
10771 }
10772 }
10773 else if (info->emitrelocations)
10774 {
10775 stub_entry->stub_sec->reloc_count += 1;
10776 stub_entry->stub_sec->flags |= SEC_RELOC;
10777 }
10778 }
10779
10780 stub_entry->stub_sec->size += size;
10781 return TRUE;
10782 }
10783
10784 /* Set up various things so that we can make a list of input sections
10785 for each output section included in the link. Returns -1 on error,
10786 0 when no stubs will be needed, and 1 on success. */
10787
10788 int
10789 ppc64_elf_setup_section_lists
10790 (struct bfd_link_info *info,
10791 asection *(*add_stub_section) (const char *, asection *),
10792 void (*layout_sections_again) (void))
10793 {
10794 bfd *input_bfd;
10795 int top_id, top_index, id;
10796 asection *section;
10797 asection **input_list;
10798 bfd_size_type amt;
10799 struct ppc_link_hash_table *htab = ppc_hash_table (info);
10800
10801 if (htab == NULL)
10802 return -1;
10803 /* Stash our params away. */
10804 htab->add_stub_section = add_stub_section;
10805 htab->layout_sections_again = layout_sections_again;
10806
10807 /* Find the top input section id. */
10808 for (input_bfd = info->input_bfds, top_id = 3;
10809 input_bfd != NULL;
10810 input_bfd = input_bfd->link_next)
10811 {
10812 for (section = input_bfd->sections;
10813 section != NULL;
10814 section = section->next)
10815 {
10816 if (top_id < section->id)
10817 top_id = section->id;
10818 }
10819 }
10820
10821 htab->top_id = top_id;
10822 amt = sizeof (struct map_stub) * (top_id + 1);
10823 htab->stub_group = bfd_zmalloc (amt);
10824 if (htab->stub_group == NULL)
10825 return -1;
10826
10827 /* Set toc_off for com, und, abs and ind sections. */
10828 for (id = 0; id < 3; id++)
10829 htab->stub_group[id].toc_off = TOC_BASE_OFF;
10830
10831 /* We can't use output_bfd->section_count here to find the top output
10832 section index as some sections may have been removed, and
10833 strip_excluded_output_sections doesn't renumber the indices. */
10834 for (section = info->output_bfd->sections, top_index = 0;
10835 section != NULL;
10836 section = section->next)
10837 {
10838 if (top_index < section->index)
10839 top_index = section->index;
10840 }
10841
10842 htab->top_index = top_index;
10843 amt = sizeof (asection *) * (top_index + 1);
10844 input_list = bfd_zmalloc (amt);
10845 htab->input_list = input_list;
10846 if (input_list == NULL)
10847 return -1;
10848
10849 return 1;
10850 }
10851
10852 /* Set up for first pass at multitoc partitioning. */
10853
10854 void
10855 ppc64_elf_start_multitoc_partition (struct bfd_link_info *info)
10856 {
10857 struct ppc_link_hash_table *htab = ppc_hash_table (info);
10858
10859 htab->toc_curr = ppc64_elf_set_toc (info, info->output_bfd);
10860 htab->toc_bfd = NULL;
10861 htab->toc_first_sec = NULL;
10862 }
10863
10864 /* The linker repeatedly calls this function for each TOC input section
10865 and linker generated GOT section. Group input bfds such that the toc
10866 within a group is less than 64k in size. */
10867
10868 bfd_boolean
10869 ppc64_elf_next_toc_section (struct bfd_link_info *info, asection *isec)
10870 {
10871 struct ppc_link_hash_table *htab = ppc_hash_table (info);
10872 bfd_vma addr, off, limit;
10873
10874 if (htab == NULL)
10875 return FALSE;
10876
10877 if (!htab->second_toc_pass)
10878 {
10879 /* Keep track of the first .toc or .got section for this input bfd. */
10880 bfd_boolean new_bfd = htab->toc_bfd != isec->owner;
10881
10882 if (new_bfd)
10883 {
10884 htab->toc_bfd = isec->owner;
10885 htab->toc_first_sec = isec;
10886 }
10887
10888 addr = isec->output_offset + isec->output_section->vma;
10889 off = addr - htab->toc_curr;
10890 limit = 0x80008000;
10891 if (ppc64_elf_tdata (isec->owner)->has_small_toc_reloc)
10892 limit = 0x10000;
10893 if (off + isec->size > limit)
10894 {
10895 addr = (htab->toc_first_sec->output_offset
10896 + htab->toc_first_sec->output_section->vma);
10897 htab->toc_curr = addr;
10898 }
10899
10900 /* toc_curr is the base address of this toc group. Set elf_gp
10901 for the input section to be the offset relative to the
10902 output toc base plus 0x8000. Making the input elf_gp an
10903 offset allows us to move the toc as a whole without
10904 recalculating input elf_gp. */
10905 off = htab->toc_curr - elf_gp (isec->output_section->owner);
10906 off += TOC_BASE_OFF;
10907
10908 /* Die if someone uses a linker script that doesn't keep input
10909 file .toc and .got together. */
10910 if (new_bfd
10911 && elf_gp (isec->owner) != 0
10912 && elf_gp (isec->owner) != off)
10913 return FALSE;
10914
10915 elf_gp (isec->owner) = off;
10916 return TRUE;
10917 }
10918
10919 /* During the second pass toc_first_sec points to the start of
10920 a toc group, and toc_curr is used to track the old elf_gp.
10921 We use toc_bfd to ensure we only look at each bfd once. */
10922 if (htab->toc_bfd == isec->owner)
10923 return TRUE;
10924 htab->toc_bfd = isec->owner;
10925
10926 if (htab->toc_first_sec == NULL
10927 || htab->toc_curr != elf_gp (isec->owner))
10928 {
10929 htab->toc_curr = elf_gp (isec->owner);
10930 htab->toc_first_sec = isec;
10931 }
10932 addr = (htab->toc_first_sec->output_offset
10933 + htab->toc_first_sec->output_section->vma);
10934 off = addr - elf_gp (isec->output_section->owner) + TOC_BASE_OFF;
10935 elf_gp (isec->owner) = off;
10936
10937 return TRUE;
10938 }
10939
10940 /* Called via elf_link_hash_traverse to merge GOT entries for global
10941 symbol H. */
10942
10943 static bfd_boolean
10944 merge_global_got (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
10945 {
10946 if (h->root.type == bfd_link_hash_indirect)
10947 return TRUE;
10948
10949 merge_got_entries (&h->got.glist);
10950
10951 return TRUE;
10952 }
10953
10954 /* Called via elf_link_hash_traverse to allocate GOT entries for global
10955 symbol H. */
10956
10957 static bfd_boolean
10958 reallocate_got (struct elf_link_hash_entry *h, void *inf)
10959 {
10960 struct got_entry *gent;
10961
10962 if (h->root.type == bfd_link_hash_indirect)
10963 return TRUE;
10964
10965 for (gent = h->got.glist; gent != NULL; gent = gent->next)
10966 if (!gent->is_indirect)
10967 allocate_got (h, (struct bfd_link_info *) inf, gent);
10968 return TRUE;
10969 }
10970
10971 /* Called on the first multitoc pass after the last call to
10972 ppc64_elf_next_toc_section. This function removes duplicate GOT
10973 entries. */
10974
10975 bfd_boolean
10976 ppc64_elf_layout_multitoc (struct bfd_link_info *info)
10977 {
10978 struct ppc_link_hash_table *htab = ppc_hash_table (info);
10979 struct bfd *ibfd, *ibfd2;
10980 bfd_boolean done_something;
10981
10982 htab->multi_toc_needed = htab->toc_curr != elf_gp (info->output_bfd);
10983
10984 if (!htab->do_multi_toc)
10985 return FALSE;
10986
10987 /* Merge global sym got entries within a toc group. */
10988 elf_link_hash_traverse (&htab->elf, merge_global_got, info);
10989
10990 /* And tlsld_got. */
10991 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
10992 {
10993 struct got_entry *ent, *ent2;
10994
10995 if (!is_ppc64_elf (ibfd))
10996 continue;
10997
10998 ent = ppc64_tlsld_got (ibfd);
10999 if (!ent->is_indirect
11000 && ent->got.offset != (bfd_vma) -1)
11001 {
11002 for (ibfd2 = ibfd->link_next; ibfd2 != NULL; ibfd2 = ibfd2->link_next)
11003 {
11004 if (!is_ppc64_elf (ibfd2))
11005 continue;
11006
11007 ent2 = ppc64_tlsld_got (ibfd2);
11008 if (!ent2->is_indirect
11009 && ent2->got.offset != (bfd_vma) -1
11010 && elf_gp (ibfd2) == elf_gp (ibfd))
11011 {
11012 ent2->is_indirect = TRUE;
11013 ent2->got.ent = ent;
11014 }
11015 }
11016 }
11017 }
11018
11019 /* Zap sizes of got sections. */
11020 htab->reliplt->rawsize = htab->reliplt->size;
11021 htab->reliplt->size -= htab->got_reli_size;
11022 htab->got_reli_size = 0;
11023
11024 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
11025 {
11026 asection *got, *relgot;
11027
11028 if (!is_ppc64_elf (ibfd))
11029 continue;
11030
11031 got = ppc64_elf_tdata (ibfd)->got;
11032 if (got != NULL)
11033 {
11034 got->rawsize = got->size;
11035 got->size = 0;
11036 relgot = ppc64_elf_tdata (ibfd)->relgot;
11037 relgot->rawsize = relgot->size;
11038 relgot->size = 0;
11039 }
11040 }
11041
11042 /* Now reallocate the got, local syms first. We don't need to
11043 allocate section contents again since we never increase size. */
11044 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
11045 {
11046 struct got_entry **lgot_ents;
11047 struct got_entry **end_lgot_ents;
11048 struct plt_entry **local_plt;
11049 struct plt_entry **end_local_plt;
11050 unsigned char *lgot_masks;
11051 bfd_size_type locsymcount;
11052 Elf_Internal_Shdr *symtab_hdr;
11053 asection *s;
11054
11055 if (!is_ppc64_elf (ibfd))
11056 continue;
11057
11058 lgot_ents = elf_local_got_ents (ibfd);
11059 if (!lgot_ents)
11060 continue;
11061
11062 symtab_hdr = &elf_symtab_hdr (ibfd);
11063 locsymcount = symtab_hdr->sh_info;
11064 end_lgot_ents = lgot_ents + locsymcount;
11065 local_plt = (struct plt_entry **) end_lgot_ents;
11066 end_local_plt = local_plt + locsymcount;
11067 lgot_masks = (unsigned char *) end_local_plt;
11068 s = ppc64_elf_tdata (ibfd)->got;
11069 for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
11070 {
11071 struct got_entry *ent;
11072
11073 for (ent = *lgot_ents; ent != NULL; ent = ent->next)
11074 {
11075 unsigned int ent_size = 8;
11076 unsigned int rel_size = sizeof (Elf64_External_Rela);
11077
11078 ent->got.offset = s->size;
11079 if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
11080 {
11081 ent_size *= 2;
11082 rel_size *= 2;
11083 }
11084 s->size += ent_size;
11085 if ((*lgot_masks & PLT_IFUNC) != 0)
11086 {
11087 htab->reliplt->size += rel_size;
11088 htab->got_reli_size += rel_size;
11089 }
11090 else if (info->shared)
11091 {
11092 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
11093 srel->size += rel_size;
11094 }
11095 }
11096 }
11097 }
11098
11099 elf_link_hash_traverse (&htab->elf, reallocate_got, info);
11100
11101 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
11102 {
11103 struct got_entry *ent;
11104
11105 if (!is_ppc64_elf (ibfd))
11106 continue;
11107
11108 ent = ppc64_tlsld_got (ibfd);
11109 if (!ent->is_indirect
11110 && ent->got.offset != (bfd_vma) -1)
11111 {
11112 asection *s = ppc64_elf_tdata (ibfd)->got;
11113 ent->got.offset = s->size;
11114 s->size += 16;
11115 if (info->shared)
11116 {
11117 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
11118 srel->size += sizeof (Elf64_External_Rela);
11119 }
11120 }
11121 }
11122
11123 done_something = htab->reliplt->rawsize != htab->reliplt->size;
11124 if (!done_something)
11125 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
11126 {
11127 asection *got;
11128
11129 if (!is_ppc64_elf (ibfd))
11130 continue;
11131
11132 got = ppc64_elf_tdata (ibfd)->got;
11133 if (got != NULL)
11134 {
11135 done_something = got->rawsize != got->size;
11136 if (done_something)
11137 break;
11138 }
11139 }
11140
11141 if (done_something)
11142 (*htab->layout_sections_again) ();
11143
11144 /* Set up for second pass over toc sections to recalculate elf_gp
11145 on input sections. */
11146 htab->toc_bfd = NULL;
11147 htab->toc_first_sec = NULL;
11148 htab->second_toc_pass = TRUE;
11149 return done_something;
11150 }
11151
11152 /* Called after second pass of multitoc partitioning. */
11153
11154 void
11155 ppc64_elf_finish_multitoc_partition (struct bfd_link_info *info)
11156 {
11157 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11158
11159 /* After the second pass, toc_curr tracks the TOC offset used
11160 for code sections below in ppc64_elf_next_input_section. */
11161 htab->toc_curr = TOC_BASE_OFF;
11162 }
11163
11164 /* No toc references were found in ISEC. If the code in ISEC makes no
11165 calls, then there's no need to use toc adjusting stubs when branching
11166 into ISEC. Actually, indirect calls from ISEC are OK as they will
11167 load r2. Returns -1 on error, 0 for no stub needed, 1 for stub
11168 needed, and 2 if a cyclical call-graph was found but no other reason
11169 for a stub was detected. If called from the top level, a return of
11170 2 means the same as a return of 0. */
11171
11172 static int
11173 toc_adjusting_stub_needed (struct bfd_link_info *info, asection *isec)
11174 {
11175 int ret;
11176
11177 /* Mark this section as checked. */
11178 isec->call_check_done = 1;
11179
11180 /* We know none of our code bearing sections will need toc stubs. */
11181 if ((isec->flags & SEC_LINKER_CREATED) != 0)
11182 return 0;
11183
11184 if (isec->size == 0)
11185 return 0;
11186
11187 if (isec->output_section == NULL)
11188 return 0;
11189
11190 ret = 0;
11191 if (isec->reloc_count != 0)
11192 {
11193 Elf_Internal_Rela *relstart, *rel;
11194 Elf_Internal_Sym *local_syms;
11195 struct ppc_link_hash_table *htab;
11196
11197 relstart = _bfd_elf_link_read_relocs (isec->owner, isec, NULL, NULL,
11198 info->keep_memory);
11199 if (relstart == NULL)
11200 return -1;
11201
11202 /* Look for branches to outside of this section. */
11203 local_syms = NULL;
11204 htab = ppc_hash_table (info);
11205 if (htab == NULL)
11206 return -1;
11207
11208 for (rel = relstart; rel < relstart + isec->reloc_count; ++rel)
11209 {
11210 enum elf_ppc64_reloc_type r_type;
11211 unsigned long r_symndx;
11212 struct elf_link_hash_entry *h;
11213 struct ppc_link_hash_entry *eh;
11214 Elf_Internal_Sym *sym;
11215 asection *sym_sec;
11216 struct _opd_sec_data *opd;
11217 bfd_vma sym_value;
11218 bfd_vma dest;
11219
11220 r_type = ELF64_R_TYPE (rel->r_info);
11221 if (r_type != R_PPC64_REL24
11222 && r_type != R_PPC64_REL14
11223 && r_type != R_PPC64_REL14_BRTAKEN
11224 && r_type != R_PPC64_REL14_BRNTAKEN)
11225 continue;
11226
11227 r_symndx = ELF64_R_SYM (rel->r_info);
11228 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms, r_symndx,
11229 isec->owner))
11230 {
11231 ret = -1;
11232 break;
11233 }
11234
11235 /* Calls to dynamic lib functions go through a plt call stub
11236 that uses r2. */
11237 eh = (struct ppc_link_hash_entry *) h;
11238 if (eh != NULL
11239 && (eh->elf.plt.plist != NULL
11240 || (eh->oh != NULL
11241 && ppc_follow_link (eh->oh)->elf.plt.plist != NULL)))
11242 {
11243 ret = 1;
11244 break;
11245 }
11246
11247 if (sym_sec == NULL)
11248 /* Ignore other undefined symbols. */
11249 continue;
11250
11251 /* Assume branches to other sections not included in the
11252 link need stubs too, to cover -R and absolute syms. */
11253 if (sym_sec->output_section == NULL)
11254 {
11255 ret = 1;
11256 break;
11257 }
11258
11259 if (h == NULL)
11260 sym_value = sym->st_value;
11261 else
11262 {
11263 if (h->root.type != bfd_link_hash_defined
11264 && h->root.type != bfd_link_hash_defweak)
11265 abort ();
11266 sym_value = h->root.u.def.value;
11267 }
11268 sym_value += rel->r_addend;
11269
11270 /* If this branch reloc uses an opd sym, find the code section. */
11271 opd = get_opd_info (sym_sec);
11272 if (opd != NULL)
11273 {
11274 if (h == NULL && opd->adjust != NULL)
11275 {
11276 long adjust;
11277
11278 adjust = opd->adjust[sym->st_value / 8];
11279 if (adjust == -1)
11280 /* Assume deleted functions won't ever be called. */
11281 continue;
11282 sym_value += adjust;
11283 }
11284
11285 dest = opd_entry_value (sym_sec, sym_value,
11286 &sym_sec, NULL, FALSE);
11287 if (dest == (bfd_vma) -1)
11288 continue;
11289 }
11290 else
11291 dest = (sym_value
11292 + sym_sec->output_offset
11293 + sym_sec->output_section->vma);
11294
11295 /* Ignore branch to self. */
11296 if (sym_sec == isec)
11297 continue;
11298
11299 /* If the called function uses the toc, we need a stub. */
11300 if (sym_sec->has_toc_reloc
11301 || sym_sec->makes_toc_func_call)
11302 {
11303 ret = 1;
11304 break;
11305 }
11306
11307 /* Assume any branch that needs a long branch stub might in fact
11308 need a plt_branch stub. A plt_branch stub uses r2. */
11309 else if (dest - (isec->output_offset
11310 + isec->output_section->vma
11311 + rel->r_offset) + (1 << 25) >= (2 << 25))
11312 {
11313 ret = 1;
11314 break;
11315 }
11316
11317 /* If calling back to a section in the process of being
11318 tested, we can't say for sure that no toc adjusting stubs
11319 are needed, so don't return zero. */
11320 else if (sym_sec->call_check_in_progress)
11321 ret = 2;
11322
11323 /* Branches to another section that itself doesn't have any TOC
11324 references are OK. Recursively call ourselves to check. */
11325 else if (!sym_sec->call_check_done)
11326 {
11327 int recur;
11328
11329 /* Mark current section as indeterminate, so that other
11330 sections that call back to current won't be marked as
11331 known. */
11332 isec->call_check_in_progress = 1;
11333 recur = toc_adjusting_stub_needed (info, sym_sec);
11334 isec->call_check_in_progress = 0;
11335
11336 if (recur != 0)
11337 {
11338 ret = recur;
11339 if (recur != 2)
11340 break;
11341 }
11342 }
11343 }
11344
11345 if (local_syms != NULL
11346 && (elf_symtab_hdr (isec->owner).contents
11347 != (unsigned char *) local_syms))
11348 free (local_syms);
11349 if (elf_section_data (isec)->relocs != relstart)
11350 free (relstart);
11351 }
11352
11353 if ((ret & 1) == 0
11354 && isec->map_head.s != NULL
11355 && (strcmp (isec->output_section->name, ".init") == 0
11356 || strcmp (isec->output_section->name, ".fini") == 0))
11357 {
11358 if (isec->map_head.s->has_toc_reloc
11359 || isec->map_head.s->makes_toc_func_call)
11360 ret = 1;
11361 else if (!isec->map_head.s->call_check_done)
11362 {
11363 int recur;
11364 isec->call_check_in_progress = 1;
11365 recur = toc_adjusting_stub_needed (info, isec->map_head.s);
11366 isec->call_check_in_progress = 0;
11367 if (recur != 0)
11368 ret = recur;
11369 }
11370 }
11371
11372 if (ret == 1)
11373 isec->makes_toc_func_call = 1;
11374
11375 return ret;
11376 }
11377
11378 /* The linker repeatedly calls this function for each input section,
11379 in the order that input sections are linked into output sections.
11380 Build lists of input sections to determine groupings between which
11381 we may insert linker stubs. */
11382
11383 bfd_boolean
11384 ppc64_elf_next_input_section (struct bfd_link_info *info, asection *isec)
11385 {
11386 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11387
11388 if (htab == NULL)
11389 return FALSE;
11390
11391 if ((isec->output_section->flags & SEC_CODE) != 0
11392 && isec->output_section->index <= htab->top_index)
11393 {
11394 asection **list = htab->input_list + isec->output_section->index;
11395 /* Steal the link_sec pointer for our list. */
11396 #define PREV_SEC(sec) (htab->stub_group[(sec)->id].link_sec)
11397 /* This happens to make the list in reverse order,
11398 which is what we want. */
11399 PREV_SEC (isec) = *list;
11400 *list = isec;
11401 }
11402
11403 if (htab->multi_toc_needed)
11404 {
11405 /* If a code section has a function that uses the TOC then we need
11406 to use the right TOC (obviously). Also, make sure that .opd gets
11407 the correct TOC value for R_PPC64_TOC relocs that don't have or
11408 can't find their function symbol (shouldn't ever happen now).
11409 Also specially treat .fixup for the linux kernel. .fixup
11410 contains branches, but only back to the function that hit an
11411 exception. */
11412 if (isec->has_toc_reloc
11413 || (isec->flags & SEC_CODE) == 0
11414 || strcmp (isec->name, ".fixup") == 0)
11415 {
11416 if (elf_gp (isec->owner) != 0)
11417 htab->toc_curr = elf_gp (isec->owner);
11418 }
11419 else
11420 {
11421 if (!isec->call_check_done
11422 && toc_adjusting_stub_needed (info, isec) < 0)
11423 return FALSE;
11424 /* If we make a local call from this section, ie. a branch
11425 without a following nop, then we have no place to put a
11426 toc restoring insn. We must use the same toc group as
11427 the callee.
11428 Testing makes_toc_func_call actually tests for *any*
11429 calls to functions that need a good toc pointer. A more
11430 precise test would be better, as this one will set
11431 incorrect values for pasted .init/.fini fragments.
11432 (Fixed later in check_pasted_section.) */
11433 if (isec->makes_toc_func_call
11434 && elf_gp (isec->owner) != 0)
11435 htab->toc_curr = elf_gp (isec->owner);
11436 }
11437 }
11438
11439 /* Functions that don't use the TOC can belong in any TOC group.
11440 Use the last TOC base. */
11441 htab->stub_group[isec->id].toc_off = htab->toc_curr;
11442 return TRUE;
11443 }
11444
11445 /* Check that all .init and .fini sections use the same toc, if they
11446 have toc relocs. */
11447
11448 static bfd_boolean
11449 check_pasted_section (struct bfd_link_info *info, const char *name)
11450 {
11451 asection *o = bfd_get_section_by_name (info->output_bfd, name);
11452
11453 if (o != NULL)
11454 {
11455 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11456 bfd_vma toc_off = 0;
11457 asection *i;
11458
11459 for (i = o->map_head.s; i != NULL; i = i->map_head.s)
11460 if (i->has_toc_reloc)
11461 {
11462 if (toc_off == 0)
11463 toc_off = htab->stub_group[i->id].toc_off;
11464 else if (toc_off != htab->stub_group[i->id].toc_off)
11465 return FALSE;
11466 }
11467
11468 if (toc_off == 0)
11469 for (i = o->map_head.s; i != NULL; i = i->map_head.s)
11470 if (i->makes_toc_func_call)
11471 {
11472 toc_off = htab->stub_group[i->id].toc_off;
11473 break;
11474 }
11475
11476 /* Make sure the whole pasted function uses the same toc offset. */
11477 if (toc_off != 0)
11478 for (i = o->map_head.s; i != NULL; i = i->map_head.s)
11479 htab->stub_group[i->id].toc_off = toc_off;
11480 }
11481 return TRUE;
11482 }
11483
11484 bfd_boolean
11485 ppc64_elf_check_init_fini (struct bfd_link_info *info)
11486 {
11487 return (check_pasted_section (info, ".init")
11488 & check_pasted_section (info, ".fini"));
11489 }
11490
11491 /* See whether we can group stub sections together. Grouping stub
11492 sections may result in fewer stubs. More importantly, we need to
11493 put all .init* and .fini* stubs at the beginning of the .init or
11494 .fini output sections respectively, because glibc splits the
11495 _init and _fini functions into multiple parts. Putting a stub in
11496 the middle of a function is not a good idea. */
11497
11498 static void
11499 group_sections (struct ppc_link_hash_table *htab,
11500 bfd_size_type stub_group_size,
11501 bfd_boolean stubs_always_before_branch)
11502 {
11503 asection **list;
11504 bfd_size_type stub14_group_size;
11505 bfd_boolean suppress_size_errors;
11506
11507 suppress_size_errors = FALSE;
11508 stub14_group_size = stub_group_size;
11509 if (stub_group_size == 1)
11510 {
11511 /* Default values. */
11512 if (stubs_always_before_branch)
11513 {
11514 stub_group_size = 0x1e00000;
11515 stub14_group_size = 0x7800;
11516 }
11517 else
11518 {
11519 stub_group_size = 0x1c00000;
11520 stub14_group_size = 0x7000;
11521 }
11522 suppress_size_errors = TRUE;
11523 }
11524
11525 list = htab->input_list + htab->top_index;
11526 do
11527 {
11528 asection *tail = *list;
11529 while (tail != NULL)
11530 {
11531 asection *curr;
11532 asection *prev;
11533 bfd_size_type total;
11534 bfd_boolean big_sec;
11535 bfd_vma curr_toc;
11536
11537 curr = tail;
11538 total = tail->size;
11539 big_sec = total > (ppc64_elf_section_data (tail) != NULL
11540 && ppc64_elf_section_data (tail)->has_14bit_branch
11541 ? stub14_group_size : stub_group_size);
11542 if (big_sec && !suppress_size_errors)
11543 (*_bfd_error_handler) (_("%B section %A exceeds stub group size"),
11544 tail->owner, tail);
11545 curr_toc = htab->stub_group[tail->id].toc_off;
11546
11547 while ((prev = PREV_SEC (curr)) != NULL
11548 && ((total += curr->output_offset - prev->output_offset)
11549 < (ppc64_elf_section_data (prev) != NULL
11550 && ppc64_elf_section_data (prev)->has_14bit_branch
11551 ? stub14_group_size : stub_group_size))
11552 && htab->stub_group[prev->id].toc_off == curr_toc)
11553 curr = prev;
11554
11555 /* OK, the size from the start of CURR to the end is less
11556 than stub_group_size and thus can be handled by one stub
11557 section. (or the tail section is itself larger than
11558 stub_group_size, in which case we may be toast.) We
11559 should really be keeping track of the total size of stubs
11560 added here, as stubs contribute to the final output
11561 section size. That's a little tricky, and this way will
11562 only break if stubs added make the total size more than
11563 2^25, ie. for the default stub_group_size, if stubs total
11564 more than 2097152 bytes, or nearly 75000 plt call stubs. */
11565 do
11566 {
11567 prev = PREV_SEC (tail);
11568 /* Set up this stub group. */
11569 htab->stub_group[tail->id].link_sec = curr;
11570 }
11571 while (tail != curr && (tail = prev) != NULL);
11572
11573 /* But wait, there's more! Input sections up to stub_group_size
11574 bytes before the stub section can be handled by it too.
11575 Don't do this if we have a really large section after the
11576 stubs, as adding more stubs increases the chance that
11577 branches may not reach into the stub section. */
11578 if (!stubs_always_before_branch && !big_sec)
11579 {
11580 total = 0;
11581 while (prev != NULL
11582 && ((total += tail->output_offset - prev->output_offset)
11583 < (ppc64_elf_section_data (prev) != NULL
11584 && ppc64_elf_section_data (prev)->has_14bit_branch
11585 ? stub14_group_size : stub_group_size))
11586 && htab->stub_group[prev->id].toc_off == curr_toc)
11587 {
11588 tail = prev;
11589 prev = PREV_SEC (tail);
11590 htab->stub_group[tail->id].link_sec = curr;
11591 }
11592 }
11593 tail = prev;
11594 }
11595 }
11596 while (list-- != htab->input_list);
11597 free (htab->input_list);
11598 #undef PREV_SEC
11599 }
11600
11601 static const unsigned char glink_eh_frame_cie[] =
11602 {
11603 0, 0, 0, 16, /* length. */
11604 0, 0, 0, 0, /* id. */
11605 1, /* CIE version. */
11606 'z', 'R', 0, /* Augmentation string. */
11607 4, /* Code alignment. */
11608 0x78, /* Data alignment. */
11609 65, /* RA reg. */
11610 1, /* Augmentation size. */
11611 DW_EH_PE_pcrel | DW_EH_PE_sdata4, /* FDE encoding. */
11612 DW_CFA_def_cfa, 1, 0 /* def_cfa: r1 offset 0. */
11613 };
11614
11615 /* Stripping output sections is normally done before dynamic section
11616 symbols have been allocated. This function is called later, and
11617 handles cases like htab->brlt which is mapped to its own output
11618 section. */
11619
11620 static void
11621 maybe_strip_output (struct bfd_link_info *info, asection *isec)
11622 {
11623 if (isec->size == 0
11624 && isec->output_section->size == 0
11625 && !(isec->output_section->flags & SEC_KEEP)
11626 && !bfd_section_removed_from_list (info->output_bfd,
11627 isec->output_section)
11628 && elf_section_data (isec->output_section)->dynindx == 0)
11629 {
11630 isec->output_section->flags |= SEC_EXCLUDE;
11631 bfd_section_list_remove (info->output_bfd, isec->output_section);
11632 info->output_bfd->section_count--;
11633 }
11634 }
11635
11636 /* Determine and set the size of the stub section for a final link.
11637
11638 The basic idea here is to examine all the relocations looking for
11639 PC-relative calls to a target that is unreachable with a "bl"
11640 instruction. */
11641
11642 bfd_boolean
11643 ppc64_elf_size_stubs (struct bfd_link_info *info, bfd_signed_vma group_size,
11644 bfd_boolean plt_static_chain, int plt_thread_safe,
11645 int plt_stub_align)
11646 {
11647 bfd_size_type stub_group_size;
11648 bfd_boolean stubs_always_before_branch;
11649 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11650
11651 if (htab == NULL)
11652 return FALSE;
11653
11654 htab->plt_static_chain = plt_static_chain;
11655 htab->plt_stub_align = plt_stub_align;
11656 if (plt_thread_safe == -1 && !info->executable)
11657 plt_thread_safe = 1;
11658 if (plt_thread_safe == -1)
11659 {
11660 static const char *const thread_starter[] =
11661 {
11662 "pthread_create",
11663 /* libstdc++ */
11664 "_ZNSt6thread15_M_start_threadESt10shared_ptrINS_10_Impl_baseEE",
11665 /* librt */
11666 "aio_init", "aio_read", "aio_write", "aio_fsync", "lio_listio",
11667 "mq_notify", "create_timer",
11668 /* libanl */
11669 "getaddrinfo_a",
11670 /* libgomp */
11671 "GOMP_parallel_start",
11672 "GOMP_parallel_loop_static_start",
11673 "GOMP_parallel_loop_dynamic_start",
11674 "GOMP_parallel_loop_guided_start",
11675 "GOMP_parallel_loop_runtime_start",
11676 "GOMP_parallel_sections_start",
11677 };
11678 unsigned i;
11679
11680 for (i = 0; i < sizeof (thread_starter)/ sizeof (thread_starter[0]); i++)
11681 {
11682 struct elf_link_hash_entry *h;
11683 h = elf_link_hash_lookup (&htab->elf, thread_starter[i],
11684 FALSE, FALSE, TRUE);
11685 plt_thread_safe = h != NULL && h->ref_regular;
11686 if (plt_thread_safe)
11687 break;
11688 }
11689 }
11690 htab->plt_thread_safe = plt_thread_safe;
11691 stubs_always_before_branch = group_size < 0;
11692 if (group_size < 0)
11693 stub_group_size = -group_size;
11694 else
11695 stub_group_size = group_size;
11696
11697 group_sections (htab, stub_group_size, stubs_always_before_branch);
11698
11699 while (1)
11700 {
11701 bfd *input_bfd;
11702 unsigned int bfd_indx;
11703 asection *stub_sec;
11704
11705 htab->stub_iteration += 1;
11706
11707 for (input_bfd = info->input_bfds, bfd_indx = 0;
11708 input_bfd != NULL;
11709 input_bfd = input_bfd->link_next, bfd_indx++)
11710 {
11711 Elf_Internal_Shdr *symtab_hdr;
11712 asection *section;
11713 Elf_Internal_Sym *local_syms = NULL;
11714
11715 if (!is_ppc64_elf (input_bfd))
11716 continue;
11717
11718 /* We'll need the symbol table in a second. */
11719 symtab_hdr = &elf_symtab_hdr (input_bfd);
11720 if (symtab_hdr->sh_info == 0)
11721 continue;
11722
11723 /* Walk over each section attached to the input bfd. */
11724 for (section = input_bfd->sections;
11725 section != NULL;
11726 section = section->next)
11727 {
11728 Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
11729
11730 /* If there aren't any relocs, then there's nothing more
11731 to do. */
11732 if ((section->flags & SEC_RELOC) == 0
11733 || (section->flags & SEC_ALLOC) == 0
11734 || (section->flags & SEC_LOAD) == 0
11735 || (section->flags & SEC_CODE) == 0
11736 || section->reloc_count == 0)
11737 continue;
11738
11739 /* If this section is a link-once section that will be
11740 discarded, then don't create any stubs. */
11741 if (section->output_section == NULL
11742 || section->output_section->owner != info->output_bfd)
11743 continue;
11744
11745 /* Get the relocs. */
11746 internal_relocs
11747 = _bfd_elf_link_read_relocs (input_bfd, section, NULL, NULL,
11748 info->keep_memory);
11749 if (internal_relocs == NULL)
11750 goto error_ret_free_local;
11751
11752 /* Now examine each relocation. */
11753 irela = internal_relocs;
11754 irelaend = irela + section->reloc_count;
11755 for (; irela < irelaend; irela++)
11756 {
11757 enum elf_ppc64_reloc_type r_type;
11758 unsigned int r_indx;
11759 enum ppc_stub_type stub_type;
11760 struct ppc_stub_hash_entry *stub_entry;
11761 asection *sym_sec, *code_sec;
11762 bfd_vma sym_value, code_value;
11763 bfd_vma destination;
11764 bfd_boolean ok_dest;
11765 struct ppc_link_hash_entry *hash;
11766 struct ppc_link_hash_entry *fdh;
11767 struct elf_link_hash_entry *h;
11768 Elf_Internal_Sym *sym;
11769 char *stub_name;
11770 const asection *id_sec;
11771 struct _opd_sec_data *opd;
11772 struct plt_entry *plt_ent;
11773
11774 r_type = ELF64_R_TYPE (irela->r_info);
11775 r_indx = ELF64_R_SYM (irela->r_info);
11776
11777 if (r_type >= R_PPC64_max)
11778 {
11779 bfd_set_error (bfd_error_bad_value);
11780 goto error_ret_free_internal;
11781 }
11782
11783 /* Only look for stubs on branch instructions. */
11784 if (r_type != R_PPC64_REL24
11785 && r_type != R_PPC64_REL14
11786 && r_type != R_PPC64_REL14_BRTAKEN
11787 && r_type != R_PPC64_REL14_BRNTAKEN)
11788 continue;
11789
11790 /* Now determine the call target, its name, value,
11791 section. */
11792 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
11793 r_indx, input_bfd))
11794 goto error_ret_free_internal;
11795 hash = (struct ppc_link_hash_entry *) h;
11796
11797 ok_dest = FALSE;
11798 fdh = NULL;
11799 sym_value = 0;
11800 if (hash == NULL)
11801 {
11802 sym_value = sym->st_value;
11803 ok_dest = TRUE;
11804 }
11805 else if (hash->elf.root.type == bfd_link_hash_defined
11806 || hash->elf.root.type == bfd_link_hash_defweak)
11807 {
11808 sym_value = hash->elf.root.u.def.value;
11809 if (sym_sec->output_section != NULL)
11810 ok_dest = TRUE;
11811 }
11812 else if (hash->elf.root.type == bfd_link_hash_undefweak
11813 || hash->elf.root.type == bfd_link_hash_undefined)
11814 {
11815 /* Recognise an old ABI func code entry sym, and
11816 use the func descriptor sym instead if it is
11817 defined. */
11818 if (hash->elf.root.root.string[0] == '.'
11819 && (fdh = lookup_fdh (hash, htab)) != NULL)
11820 {
11821 if (fdh->elf.root.type == bfd_link_hash_defined
11822 || fdh->elf.root.type == bfd_link_hash_defweak)
11823 {
11824 sym_sec = fdh->elf.root.u.def.section;
11825 sym_value = fdh->elf.root.u.def.value;
11826 if (sym_sec->output_section != NULL)
11827 ok_dest = TRUE;
11828 }
11829 else
11830 fdh = NULL;
11831 }
11832 }
11833 else
11834 {
11835 bfd_set_error (bfd_error_bad_value);
11836 goto error_ret_free_internal;
11837 }
11838
11839 destination = 0;
11840 if (ok_dest)
11841 {
11842 sym_value += irela->r_addend;
11843 destination = (sym_value
11844 + sym_sec->output_offset
11845 + sym_sec->output_section->vma);
11846 }
11847
11848 code_sec = sym_sec;
11849 code_value = sym_value;
11850 opd = get_opd_info (sym_sec);
11851 if (opd != NULL)
11852 {
11853 bfd_vma dest;
11854
11855 if (hash == NULL && opd->adjust != NULL)
11856 {
11857 long adjust = opd->adjust[sym_value / 8];
11858 if (adjust == -1)
11859 continue;
11860 code_value += adjust;
11861 sym_value += adjust;
11862 }
11863 dest = opd_entry_value (sym_sec, sym_value,
11864 &code_sec, &code_value, FALSE);
11865 if (dest != (bfd_vma) -1)
11866 {
11867 destination = dest;
11868 if (fdh != NULL)
11869 {
11870 /* Fixup old ABI sym to point at code
11871 entry. */
11872 hash->elf.root.type = bfd_link_hash_defweak;
11873 hash->elf.root.u.def.section = code_sec;
11874 hash->elf.root.u.def.value = code_value;
11875 }
11876 }
11877 }
11878
11879 /* Determine what (if any) linker stub is needed. */
11880 plt_ent = NULL;
11881 stub_type = ppc_type_of_stub (section, irela, &hash,
11882 &plt_ent, destination);
11883
11884 if (stub_type != ppc_stub_plt_call)
11885 {
11886 /* Check whether we need a TOC adjusting stub.
11887 Since the linker pastes together pieces from
11888 different object files when creating the
11889 _init and _fini functions, it may be that a
11890 call to what looks like a local sym is in
11891 fact a call needing a TOC adjustment. */
11892 if (code_sec != NULL
11893 && code_sec->output_section != NULL
11894 && (htab->stub_group[code_sec->id].toc_off
11895 != htab->stub_group[section->id].toc_off)
11896 && (code_sec->has_toc_reloc
11897 || code_sec->makes_toc_func_call))
11898 stub_type = ppc_stub_long_branch_r2off;
11899 }
11900
11901 if (stub_type == ppc_stub_none)
11902 continue;
11903
11904 /* __tls_get_addr calls might be eliminated. */
11905 if (stub_type != ppc_stub_plt_call
11906 && hash != NULL
11907 && (hash == htab->tls_get_addr
11908 || hash == htab->tls_get_addr_fd)
11909 && section->has_tls_reloc
11910 && irela != internal_relocs)
11911 {
11912 /* Get tls info. */
11913 unsigned char *tls_mask;
11914
11915 if (!get_tls_mask (&tls_mask, NULL, NULL, &local_syms,
11916 irela - 1, input_bfd))
11917 goto error_ret_free_internal;
11918 if (*tls_mask != 0)
11919 continue;
11920 }
11921
11922 if (stub_type == ppc_stub_plt_call
11923 && irela + 1 < irelaend
11924 && irela[1].r_offset == irela->r_offset + 4
11925 && ELF64_R_TYPE (irela[1].r_info) == R_PPC64_TOCSAVE)
11926 {
11927 if (!tocsave_find (htab, INSERT,
11928 &local_syms, irela + 1, input_bfd))
11929 goto error_ret_free_internal;
11930 }
11931 else if (stub_type == ppc_stub_plt_call)
11932 stub_type = ppc_stub_plt_call_r2save;
11933
11934 /* Support for grouping stub sections. */
11935 id_sec = htab->stub_group[section->id].link_sec;
11936
11937 /* Get the name of this stub. */
11938 stub_name = ppc_stub_name (id_sec, sym_sec, hash, irela);
11939 if (!stub_name)
11940 goto error_ret_free_internal;
11941
11942 stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
11943 stub_name, FALSE, FALSE);
11944 if (stub_entry != NULL)
11945 {
11946 /* The proper stub has already been created. */
11947 free (stub_name);
11948 if (stub_type == ppc_stub_plt_call_r2save)
11949 stub_entry->stub_type = stub_type;
11950 continue;
11951 }
11952
11953 stub_entry = ppc_add_stub (stub_name, section, info);
11954 if (stub_entry == NULL)
11955 {
11956 free (stub_name);
11957 error_ret_free_internal:
11958 if (elf_section_data (section)->relocs == NULL)
11959 free (internal_relocs);
11960 error_ret_free_local:
11961 if (local_syms != NULL
11962 && (symtab_hdr->contents
11963 != (unsigned char *) local_syms))
11964 free (local_syms);
11965 return FALSE;
11966 }
11967
11968 stub_entry->stub_type = stub_type;
11969 if (stub_type != ppc_stub_plt_call
11970 && stub_type != ppc_stub_plt_call_r2save)
11971 {
11972 stub_entry->target_value = code_value;
11973 stub_entry->target_section = code_sec;
11974 }
11975 else
11976 {
11977 stub_entry->target_value = sym_value;
11978 stub_entry->target_section = sym_sec;
11979 }
11980 stub_entry->h = hash;
11981 stub_entry->plt_ent = plt_ent;
11982
11983 if (stub_entry->h != NULL)
11984 htab->stub_globals += 1;
11985 }
11986
11987 /* We're done with the internal relocs, free them. */
11988 if (elf_section_data (section)->relocs != internal_relocs)
11989 free (internal_relocs);
11990 }
11991
11992 if (local_syms != NULL
11993 && symtab_hdr->contents != (unsigned char *) local_syms)
11994 {
11995 if (!info->keep_memory)
11996 free (local_syms);
11997 else
11998 symtab_hdr->contents = (unsigned char *) local_syms;
11999 }
12000 }
12001
12002 /* We may have added some stubs. Find out the new size of the
12003 stub sections. */
12004 for (stub_sec = htab->stub_bfd->sections;
12005 stub_sec != NULL;
12006 stub_sec = stub_sec->next)
12007 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12008 {
12009 stub_sec->rawsize = stub_sec->size;
12010 stub_sec->size = 0;
12011 stub_sec->reloc_count = 0;
12012 stub_sec->flags &= ~SEC_RELOC;
12013 }
12014
12015 htab->brlt->size = 0;
12016 htab->brlt->reloc_count = 0;
12017 htab->brlt->flags &= ~SEC_RELOC;
12018 if (htab->relbrlt != NULL)
12019 htab->relbrlt->size = 0;
12020
12021 bfd_hash_traverse (&htab->stub_hash_table, ppc_size_one_stub, info);
12022
12023 if (info->emitrelocations
12024 && htab->glink != NULL && htab->glink->size != 0)
12025 {
12026 htab->glink->reloc_count = 1;
12027 htab->glink->flags |= SEC_RELOC;
12028 }
12029
12030 if (htab->glink_eh_frame != NULL
12031 && !bfd_is_abs_section (htab->glink_eh_frame->output_section)
12032 && htab->glink_eh_frame->output_section->size != 0)
12033 {
12034 size_t size = 0, align;
12035
12036 for (stub_sec = htab->stub_bfd->sections;
12037 stub_sec != NULL;
12038 stub_sec = stub_sec->next)
12039 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12040 size += 20;
12041 if (htab->glink != NULL && htab->glink->size != 0)
12042 size += 24;
12043 if (size != 0)
12044 size += sizeof (glink_eh_frame_cie);
12045 align = 1;
12046 align <<= htab->glink_eh_frame->output_section->alignment_power;
12047 align -= 1;
12048 size = (size + align) & ~align;
12049 htab->glink_eh_frame->rawsize = htab->glink_eh_frame->size;
12050 htab->glink_eh_frame->size = size;
12051 }
12052
12053 if (htab->plt_stub_align != 0)
12054 for (stub_sec = htab->stub_bfd->sections;
12055 stub_sec != NULL;
12056 stub_sec = stub_sec->next)
12057 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12058 stub_sec->size = ((stub_sec->size + (1 << htab->plt_stub_align) - 1)
12059 & (-1 << htab->plt_stub_align));
12060
12061 for (stub_sec = htab->stub_bfd->sections;
12062 stub_sec != NULL;
12063 stub_sec = stub_sec->next)
12064 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
12065 && stub_sec->rawsize != stub_sec->size)
12066 break;
12067
12068 /* Exit from this loop when no stubs have been added, and no stubs
12069 have changed size. */
12070 if (stub_sec == NULL
12071 && (htab->glink_eh_frame == NULL
12072 || htab->glink_eh_frame->rawsize == htab->glink_eh_frame->size))
12073 break;
12074
12075 /* Ask the linker to do its stuff. */
12076 (*htab->layout_sections_again) ();
12077 }
12078
12079 maybe_strip_output (info, htab->brlt);
12080 if (htab->glink_eh_frame != NULL)
12081 maybe_strip_output (info, htab->glink_eh_frame);
12082
12083 return TRUE;
12084 }
12085
12086 /* Called after we have determined section placement. If sections
12087 move, we'll be called again. Provide a value for TOCstart. */
12088
12089 bfd_vma
12090 ppc64_elf_set_toc (struct bfd_link_info *info, bfd *obfd)
12091 {
12092 asection *s;
12093 bfd_vma TOCstart;
12094
12095 /* The TOC consists of sections .got, .toc, .tocbss, .plt in that
12096 order. The TOC starts where the first of these sections starts. */
12097 s = bfd_get_section_by_name (obfd, ".got");
12098 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12099 s = bfd_get_section_by_name (obfd, ".toc");
12100 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12101 s = bfd_get_section_by_name (obfd, ".tocbss");
12102 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12103 s = bfd_get_section_by_name (obfd, ".plt");
12104 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12105 {
12106 /* This may happen for
12107 o references to TOC base (SYM@toc / TOC[tc0]) without a
12108 .toc directive
12109 o bad linker script
12110 o --gc-sections and empty TOC sections
12111
12112 FIXME: Warn user? */
12113
12114 /* Look for a likely section. We probably won't even be
12115 using TOCstart. */
12116 for (s = obfd->sections; s != NULL; s = s->next)
12117 if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_READONLY
12118 | SEC_EXCLUDE))
12119 == (SEC_ALLOC | SEC_SMALL_DATA))
12120 break;
12121 if (s == NULL)
12122 for (s = obfd->sections; s != NULL; s = s->next)
12123 if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_EXCLUDE))
12124 == (SEC_ALLOC | SEC_SMALL_DATA))
12125 break;
12126 if (s == NULL)
12127 for (s = obfd->sections; s != NULL; s = s->next)
12128 if ((s->flags & (SEC_ALLOC | SEC_READONLY | SEC_EXCLUDE))
12129 == SEC_ALLOC)
12130 break;
12131 if (s == NULL)
12132 for (s = obfd->sections; s != NULL; s = s->next)
12133 if ((s->flags & (SEC_ALLOC | SEC_EXCLUDE)) == SEC_ALLOC)
12134 break;
12135 }
12136
12137 TOCstart = 0;
12138 if (s != NULL)
12139 TOCstart = s->output_section->vma + s->output_offset;
12140
12141 _bfd_set_gp_value (obfd, TOCstart);
12142
12143 if (info != NULL && s != NULL && is_ppc64_elf (obfd))
12144 {
12145 struct ppc_link_hash_table *htab = ppc_hash_table (info);
12146
12147 if (htab != NULL
12148 && htab->elf.hgot != NULL)
12149 {
12150 htab->elf.hgot->type = STT_OBJECT;
12151 htab->elf.hgot->root.type = bfd_link_hash_defined;
12152 htab->elf.hgot->root.u.def.value = TOC_BASE_OFF;
12153 htab->elf.hgot->root.u.def.section = s;
12154 }
12155 }
12156 return TOCstart;
12157 }
12158
12159 /* Build all the stubs associated with the current output file.
12160 The stubs are kept in a hash table attached to the main linker
12161 hash table. This function is called via gldelf64ppc_finish. */
12162
12163 bfd_boolean
12164 ppc64_elf_build_stubs (bfd_boolean emit_stub_syms,
12165 struct bfd_link_info *info,
12166 char **stats)
12167 {
12168 struct ppc_link_hash_table *htab = ppc_hash_table (info);
12169 asection *stub_sec;
12170 bfd_byte *p;
12171 int stub_sec_count = 0;
12172
12173 if (htab == NULL)
12174 return FALSE;
12175
12176 htab->emit_stub_syms = emit_stub_syms;
12177
12178 /* Allocate memory to hold the linker stubs. */
12179 for (stub_sec = htab->stub_bfd->sections;
12180 stub_sec != NULL;
12181 stub_sec = stub_sec->next)
12182 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
12183 && stub_sec->size != 0)
12184 {
12185 stub_sec->contents = bfd_zalloc (htab->stub_bfd, stub_sec->size);
12186 if (stub_sec->contents == NULL)
12187 return FALSE;
12188 /* We want to check that built size is the same as calculated
12189 size. rawsize is a convenient location to use. */
12190 stub_sec->rawsize = stub_sec->size;
12191 stub_sec->size = 0;
12192 }
12193
12194 if (htab->glink != NULL && htab->glink->size != 0)
12195 {
12196 unsigned int indx;
12197 bfd_vma plt0;
12198
12199 /* Build the .glink plt call stub. */
12200 if (htab->emit_stub_syms)
12201 {
12202 struct elf_link_hash_entry *h;
12203 h = elf_link_hash_lookup (&htab->elf, "__glink_PLTresolve",
12204 TRUE, FALSE, FALSE);
12205 if (h == NULL)
12206 return FALSE;
12207 if (h->root.type == bfd_link_hash_new)
12208 {
12209 h->root.type = bfd_link_hash_defined;
12210 h->root.u.def.section = htab->glink;
12211 h->root.u.def.value = 8;
12212 h->ref_regular = 1;
12213 h->def_regular = 1;
12214 h->ref_regular_nonweak = 1;
12215 h->forced_local = 1;
12216 h->non_elf = 0;
12217 }
12218 }
12219 plt0 = htab->plt->output_section->vma + htab->plt->output_offset - 16;
12220 if (info->emitrelocations)
12221 {
12222 Elf_Internal_Rela *r = get_relocs (htab->glink, 1);
12223 if (r == NULL)
12224 return FALSE;
12225 r->r_offset = (htab->glink->output_offset
12226 + htab->glink->output_section->vma);
12227 r->r_info = ELF64_R_INFO (0, R_PPC64_REL64);
12228 r->r_addend = plt0;
12229 }
12230 p = htab->glink->contents;
12231 plt0 -= htab->glink->output_section->vma + htab->glink->output_offset;
12232 bfd_put_64 (htab->glink->owner, plt0, p);
12233 p += 8;
12234 bfd_put_32 (htab->glink->owner, MFLR_R12, p);
12235 p += 4;
12236 bfd_put_32 (htab->glink->owner, BCL_20_31, p);
12237 p += 4;
12238 bfd_put_32 (htab->glink->owner, MFLR_R11, p);
12239 p += 4;
12240 bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
12241 p += 4;
12242 bfd_put_32 (htab->glink->owner, MTLR_R12, p);
12243 p += 4;
12244 bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
12245 p += 4;
12246 bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
12247 p += 4;
12248 bfd_put_32 (htab->glink->owner, LD_R2_0R11 | 8, p);
12249 p += 4;
12250 bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
12251 p += 4;
12252 bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 16, p);
12253 p += 4;
12254 bfd_put_32 (htab->glink->owner, BCTR, p);
12255 p += 4;
12256 while (p - htab->glink->contents < GLINK_CALL_STUB_SIZE)
12257 {
12258 bfd_put_32 (htab->glink->owner, NOP, p);
12259 p += 4;
12260 }
12261
12262 /* Build the .glink lazy link call stubs. */
12263 indx = 0;
12264 while (p < htab->glink->contents + htab->glink->size)
12265 {
12266 if (indx < 0x8000)
12267 {
12268 bfd_put_32 (htab->glink->owner, LI_R0_0 | indx, p);
12269 p += 4;
12270 }
12271 else
12272 {
12273 bfd_put_32 (htab->glink->owner, LIS_R0_0 | PPC_HI (indx), p);
12274 p += 4;
12275 bfd_put_32 (htab->glink->owner, ORI_R0_R0_0 | PPC_LO (indx), p);
12276 p += 4;
12277 }
12278 bfd_put_32 (htab->glink->owner,
12279 B_DOT | ((htab->glink->contents - p + 8) & 0x3fffffc), p);
12280 indx++;
12281 p += 4;
12282 }
12283 htab->glink->rawsize = p - htab->glink->contents;
12284 }
12285
12286 if (htab->brlt->size != 0)
12287 {
12288 htab->brlt->contents = bfd_zalloc (htab->brlt->owner,
12289 htab->brlt->size);
12290 if (htab->brlt->contents == NULL)
12291 return FALSE;
12292 }
12293 if (htab->relbrlt != NULL && htab->relbrlt->size != 0)
12294 {
12295 htab->relbrlt->contents = bfd_zalloc (htab->relbrlt->owner,
12296 htab->relbrlt->size);
12297 if (htab->relbrlt->contents == NULL)
12298 return FALSE;
12299 }
12300
12301 if (htab->glink_eh_frame != NULL
12302 && htab->glink_eh_frame->size != 0)
12303 {
12304 bfd_vma val;
12305 bfd_byte *last_fde;
12306 size_t last_fde_len, size, align, pad;
12307
12308 p = bfd_zalloc (htab->glink_eh_frame->owner, htab->glink_eh_frame->size);
12309 if (p == NULL)
12310 return FALSE;
12311 htab->glink_eh_frame->contents = p;
12312 last_fde = p;
12313
12314 htab->glink_eh_frame->rawsize = htab->glink_eh_frame->size;
12315
12316 memcpy (p, glink_eh_frame_cie, sizeof (glink_eh_frame_cie));
12317 /* CIE length (rewrite in case little-endian). */
12318 last_fde_len = sizeof (glink_eh_frame_cie) - 4;
12319 bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
12320 p += sizeof (glink_eh_frame_cie);
12321
12322 for (stub_sec = htab->stub_bfd->sections;
12323 stub_sec != NULL;
12324 stub_sec = stub_sec->next)
12325 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12326 {
12327 last_fde = p;
12328 last_fde_len = 16;
12329 /* FDE length. */
12330 bfd_put_32 (htab->elf.dynobj, 16, p);
12331 p += 4;
12332 /* CIE pointer. */
12333 val = p - htab->glink_eh_frame->contents;
12334 bfd_put_32 (htab->elf.dynobj, val, p);
12335 p += 4;
12336 /* Offset to stub section. */
12337 val = (stub_sec->output_section->vma
12338 + stub_sec->output_offset);
12339 val -= (htab->glink_eh_frame->output_section->vma
12340 + htab->glink_eh_frame->output_offset);
12341 val -= p - htab->glink_eh_frame->contents;
12342 if (val + 0x80000000 > 0xffffffff)
12343 {
12344 info->callbacks->einfo
12345 (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
12346 stub_sec->name);
12347 return FALSE;
12348 }
12349 bfd_put_32 (htab->elf.dynobj, val, p);
12350 p += 4;
12351 /* stub section size. */
12352 bfd_put_32 (htab->elf.dynobj, stub_sec->rawsize, p);
12353 p += 4;
12354 /* Augmentation. */
12355 p += 1;
12356 /* Pad. */
12357 p += 3;
12358 }
12359 if (htab->glink != NULL && htab->glink->size != 0)
12360 {
12361 last_fde = p;
12362 last_fde_len = 20;
12363 /* FDE length. */
12364 bfd_put_32 (htab->elf.dynobj, 20, p);
12365 p += 4;
12366 /* CIE pointer. */
12367 val = p - htab->glink_eh_frame->contents;
12368 bfd_put_32 (htab->elf.dynobj, val, p);
12369 p += 4;
12370 /* Offset to .glink. */
12371 val = (htab->glink->output_section->vma
12372 + htab->glink->output_offset
12373 + 8);
12374 val -= (htab->glink_eh_frame->output_section->vma
12375 + htab->glink_eh_frame->output_offset);
12376 val -= p - htab->glink_eh_frame->contents;
12377 if (val + 0x80000000 > 0xffffffff)
12378 {
12379 info->callbacks->einfo
12380 (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
12381 htab->glink->name);
12382 return FALSE;
12383 }
12384 bfd_put_32 (htab->elf.dynobj, val, p);
12385 p += 4;
12386 /* .glink size. */
12387 bfd_put_32 (htab->elf.dynobj, htab->glink->rawsize - 8, p);
12388 p += 4;
12389 /* Augmentation. */
12390 p += 1;
12391
12392 *p++ = DW_CFA_advance_loc + 1;
12393 *p++ = DW_CFA_register;
12394 *p++ = 65;
12395 *p++ = 12;
12396 *p++ = DW_CFA_advance_loc + 4;
12397 *p++ = DW_CFA_restore_extended;
12398 *p++ = 65;
12399 }
12400 /* Subsume any padding into the last FDE if user .eh_frame
12401 sections are aligned more than glink_eh_frame. Otherwise any
12402 zero padding will be seen as a terminator. */
12403 size = p - htab->glink_eh_frame->contents;
12404 align = 1;
12405 align <<= htab->glink_eh_frame->output_section->alignment_power;
12406 align -= 1;
12407 pad = ((size + align) & ~align) - size;
12408 htab->glink_eh_frame->size = size + pad;
12409 bfd_put_32 (htab->elf.dynobj, last_fde_len + pad, last_fde);
12410 }
12411
12412 /* Build the stubs as directed by the stub hash table. */
12413 bfd_hash_traverse (&htab->stub_hash_table, ppc_build_one_stub, info);
12414
12415 if (htab->relbrlt != NULL)
12416 htab->relbrlt->reloc_count = 0;
12417
12418 if (htab->plt_stub_align != 0)
12419 for (stub_sec = htab->stub_bfd->sections;
12420 stub_sec != NULL;
12421 stub_sec = stub_sec->next)
12422 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12423 stub_sec->size = ((stub_sec->size + (1 << htab->plt_stub_align) - 1)
12424 & (-1 << htab->plt_stub_align));
12425
12426 for (stub_sec = htab->stub_bfd->sections;
12427 stub_sec != NULL;
12428 stub_sec = stub_sec->next)
12429 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12430 {
12431 stub_sec_count += 1;
12432 if (stub_sec->rawsize != stub_sec->size)
12433 break;
12434 }
12435
12436 if (stub_sec != NULL
12437 || htab->glink->rawsize != htab->glink->size
12438 || (htab->glink_eh_frame != NULL
12439 && htab->glink_eh_frame->rawsize != htab->glink_eh_frame->size))
12440 {
12441 htab->stub_error = TRUE;
12442 info->callbacks->einfo (_("%P: stubs don't match calculated size\n"));
12443 }
12444
12445 if (htab->stub_error)
12446 return FALSE;
12447
12448 if (stats != NULL)
12449 {
12450 *stats = bfd_malloc (500);
12451 if (*stats == NULL)
12452 return FALSE;
12453
12454 sprintf (*stats, _("linker stubs in %u group%s\n"
12455 " branch %lu\n"
12456 " toc adjust %lu\n"
12457 " long branch %lu\n"
12458 " long toc adj %lu\n"
12459 " plt call %lu\n"
12460 " plt call toc %lu"),
12461 stub_sec_count,
12462 stub_sec_count == 1 ? "" : "s",
12463 htab->stub_count[ppc_stub_long_branch - 1],
12464 htab->stub_count[ppc_stub_long_branch_r2off - 1],
12465 htab->stub_count[ppc_stub_plt_branch - 1],
12466 htab->stub_count[ppc_stub_plt_branch_r2off - 1],
12467 htab->stub_count[ppc_stub_plt_call - 1],
12468 htab->stub_count[ppc_stub_plt_call_r2save - 1]);
12469 }
12470 return TRUE;
12471 }
12472
12473 /* This function undoes the changes made by add_symbol_adjust. */
12474
12475 static bfd_boolean
12476 undo_symbol_twiddle (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
12477 {
12478 struct ppc_link_hash_entry *eh;
12479
12480 if (h->root.type == bfd_link_hash_indirect)
12481 return TRUE;
12482
12483 eh = (struct ppc_link_hash_entry *) h;
12484 if (eh->elf.root.type != bfd_link_hash_undefweak || !eh->was_undefined)
12485 return TRUE;
12486
12487 eh->elf.root.type = bfd_link_hash_undefined;
12488 return TRUE;
12489 }
12490
12491 void
12492 ppc64_elf_restore_symbols (struct bfd_link_info *info)
12493 {
12494 struct ppc_link_hash_table *htab = ppc_hash_table (info);
12495
12496 if (htab != NULL)
12497 elf_link_hash_traverse (&htab->elf, undo_symbol_twiddle, info);
12498 }
12499
12500 /* What to do when ld finds relocations against symbols defined in
12501 discarded sections. */
12502
12503 static unsigned int
12504 ppc64_elf_action_discarded (asection *sec)
12505 {
12506 if (strcmp (".opd", sec->name) == 0)
12507 return 0;
12508
12509 if (strcmp (".toc", sec->name) == 0)
12510 return 0;
12511
12512 if (strcmp (".toc1", sec->name) == 0)
12513 return 0;
12514
12515 return _bfd_elf_default_action_discarded (sec);
12516 }
12517
12518 /* The RELOCATE_SECTION function is called by the ELF backend linker
12519 to handle the relocations for a section.
12520
12521 The relocs are always passed as Rela structures; if the section
12522 actually uses Rel structures, the r_addend field will always be
12523 zero.
12524
12525 This function is responsible for adjust the section contents as
12526 necessary, and (if using Rela relocs and generating a
12527 relocatable output file) adjusting the reloc addend as
12528 necessary.
12529
12530 This function does not have to worry about setting the reloc
12531 address or the reloc symbol index.
12532
12533 LOCAL_SYMS is a pointer to the swapped in local symbols.
12534
12535 LOCAL_SECTIONS is an array giving the section in the input file
12536 corresponding to the st_shndx field of each local symbol.
12537
12538 The global hash table entry for the global symbols can be found
12539 via elf_sym_hashes (input_bfd).
12540
12541 When generating relocatable output, this function must handle
12542 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
12543 going to be the section symbol corresponding to the output
12544 section, which means that the addend must be adjusted
12545 accordingly. */
12546
12547 static bfd_boolean
12548 ppc64_elf_relocate_section (bfd *output_bfd,
12549 struct bfd_link_info *info,
12550 bfd *input_bfd,
12551 asection *input_section,
12552 bfd_byte *contents,
12553 Elf_Internal_Rela *relocs,
12554 Elf_Internal_Sym *local_syms,
12555 asection **local_sections)
12556 {
12557 struct ppc_link_hash_table *htab;
12558 Elf_Internal_Shdr *symtab_hdr;
12559 struct elf_link_hash_entry **sym_hashes;
12560 Elf_Internal_Rela *rel;
12561 Elf_Internal_Rela *relend;
12562 Elf_Internal_Rela outrel;
12563 bfd_byte *loc;
12564 struct got_entry **local_got_ents;
12565 bfd_vma TOCstart;
12566 bfd_boolean ret = TRUE;
12567 bfd_boolean is_opd;
12568 /* Assume 'at' branch hints. */
12569 bfd_boolean is_isa_v2 = TRUE;
12570 bfd_vma d_offset = (bfd_big_endian (output_bfd) ? 2 : 0);
12571
12572 /* Initialize howto table if needed. */
12573 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
12574 ppc_howto_init ();
12575
12576 htab = ppc_hash_table (info);
12577 if (htab == NULL)
12578 return FALSE;
12579
12580 /* Don't relocate stub sections. */
12581 if (input_section->owner == htab->stub_bfd)
12582 return TRUE;
12583
12584 BFD_ASSERT (is_ppc64_elf (input_bfd));
12585
12586 local_got_ents = elf_local_got_ents (input_bfd);
12587 TOCstart = elf_gp (output_bfd);
12588 symtab_hdr = &elf_symtab_hdr (input_bfd);
12589 sym_hashes = elf_sym_hashes (input_bfd);
12590 is_opd = ppc64_elf_section_data (input_section)->sec_type == sec_opd;
12591
12592 rel = relocs;
12593 relend = relocs + input_section->reloc_count;
12594 for (; rel < relend; rel++)
12595 {
12596 enum elf_ppc64_reloc_type r_type;
12597 bfd_vma addend;
12598 bfd_reloc_status_type r;
12599 Elf_Internal_Sym *sym;
12600 asection *sec;
12601 struct elf_link_hash_entry *h_elf;
12602 struct ppc_link_hash_entry *h;
12603 struct ppc_link_hash_entry *fdh;
12604 const char *sym_name;
12605 unsigned long r_symndx, toc_symndx;
12606 bfd_vma toc_addend;
12607 unsigned char tls_mask, tls_gd, tls_type;
12608 unsigned char sym_type;
12609 bfd_vma relocation;
12610 bfd_boolean unresolved_reloc;
12611 bfd_boolean warned;
12612 enum { DEST_NORMAL, DEST_OPD, DEST_STUB } reloc_dest;
12613 unsigned int insn;
12614 unsigned int mask;
12615 struct ppc_stub_hash_entry *stub_entry;
12616 bfd_vma max_br_offset;
12617 bfd_vma from;
12618 const Elf_Internal_Rela orig_rel = *rel;
12619
12620 r_type = ELF64_R_TYPE (rel->r_info);
12621 r_symndx = ELF64_R_SYM (rel->r_info);
12622
12623 /* For old style R_PPC64_TOC relocs with a zero symbol, use the
12624 symbol of the previous ADDR64 reloc. The symbol gives us the
12625 proper TOC base to use. */
12626 if (rel->r_info == ELF64_R_INFO (0, R_PPC64_TOC)
12627 && rel != relocs
12628 && ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_ADDR64
12629 && is_opd)
12630 r_symndx = ELF64_R_SYM (rel[-1].r_info);
12631
12632 sym = NULL;
12633 sec = NULL;
12634 h_elf = NULL;
12635 sym_name = NULL;
12636 unresolved_reloc = FALSE;
12637 warned = FALSE;
12638
12639 if (r_symndx < symtab_hdr->sh_info)
12640 {
12641 /* It's a local symbol. */
12642 struct _opd_sec_data *opd;
12643
12644 sym = local_syms + r_symndx;
12645 sec = local_sections[r_symndx];
12646 sym_name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym, sec);
12647 sym_type = ELF64_ST_TYPE (sym->st_info);
12648 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
12649 opd = get_opd_info (sec);
12650 if (opd != NULL && opd->adjust != NULL)
12651 {
12652 long adjust = opd->adjust[(sym->st_value + rel->r_addend) / 8];
12653 if (adjust == -1)
12654 relocation = 0;
12655 else
12656 {
12657 /* If this is a relocation against the opd section sym
12658 and we have edited .opd, adjust the reloc addend so
12659 that ld -r and ld --emit-relocs output is correct.
12660 If it is a reloc against some other .opd symbol,
12661 then the symbol value will be adjusted later. */
12662 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
12663 rel->r_addend += adjust;
12664 else
12665 relocation += adjust;
12666 }
12667 }
12668 }
12669 else
12670 {
12671 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
12672 r_symndx, symtab_hdr, sym_hashes,
12673 h_elf, sec, relocation,
12674 unresolved_reloc, warned);
12675 sym_name = h_elf->root.root.string;
12676 sym_type = h_elf->type;
12677 if (sec != NULL
12678 && sec->owner == output_bfd
12679 && strcmp (sec->name, ".opd") == 0)
12680 {
12681 /* This is a symbol defined in a linker script. All
12682 such are defined in output sections, even those
12683 defined by simple assignment from a symbol defined in
12684 an input section. Transfer the symbol to an
12685 appropriate input .opd section, so that a branch to
12686 this symbol will be mapped to the location specified
12687 by the opd entry. */
12688 struct bfd_link_order *lo;
12689 for (lo = sec->map_head.link_order; lo != NULL; lo = lo->next)
12690 if (lo->type == bfd_indirect_link_order)
12691 {
12692 asection *isec = lo->u.indirect.section;
12693 if (h_elf->root.u.def.value >= isec->output_offset
12694 && h_elf->root.u.def.value < (isec->output_offset
12695 + isec->size))
12696 {
12697 h_elf->root.u.def.value -= isec->output_offset;
12698 h_elf->root.u.def.section = isec;
12699 sec = isec;
12700 break;
12701 }
12702 }
12703 }
12704 }
12705 h = (struct ppc_link_hash_entry *) h_elf;
12706
12707 if (sec != NULL && discarded_section (sec))
12708 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
12709 rel, 1, relend,
12710 ppc64_elf_howto_table[r_type], 0,
12711 contents);
12712
12713 if (info->relocatable)
12714 continue;
12715
12716 if (h != NULL && &h->elf == htab->elf.hgot)
12717 {
12718 relocation = (TOCstart
12719 + htab->stub_group[input_section->id].toc_off);
12720 sec = bfd_abs_section_ptr;
12721 unresolved_reloc = FALSE;
12722 }
12723
12724 /* TLS optimizations. Replace instruction sequences and relocs
12725 based on information we collected in tls_optimize. We edit
12726 RELOCS so that --emit-relocs will output something sensible
12727 for the final instruction stream. */
12728 tls_mask = 0;
12729 tls_gd = 0;
12730 toc_symndx = 0;
12731 if (h != NULL)
12732 tls_mask = h->tls_mask;
12733 else if (local_got_ents != NULL)
12734 {
12735 struct plt_entry **local_plt = (struct plt_entry **)
12736 (local_got_ents + symtab_hdr->sh_info);
12737 unsigned char *lgot_masks = (unsigned char *)
12738 (local_plt + symtab_hdr->sh_info);
12739 tls_mask = lgot_masks[r_symndx];
12740 }
12741 if (tls_mask == 0
12742 && (r_type == R_PPC64_TLS
12743 || r_type == R_PPC64_TLSGD
12744 || r_type == R_PPC64_TLSLD))
12745 {
12746 /* Check for toc tls entries. */
12747 unsigned char *toc_tls;
12748
12749 if (!get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
12750 &local_syms, rel, input_bfd))
12751 return FALSE;
12752
12753 if (toc_tls)
12754 tls_mask = *toc_tls;
12755 }
12756
12757 /* Check that tls relocs are used with tls syms, and non-tls
12758 relocs are used with non-tls syms. */
12759 if (r_symndx != STN_UNDEF
12760 && r_type != R_PPC64_NONE
12761 && (h == NULL
12762 || h->elf.root.type == bfd_link_hash_defined
12763 || h->elf.root.type == bfd_link_hash_defweak)
12764 && (IS_PPC64_TLS_RELOC (r_type)
12765 != (sym_type == STT_TLS
12766 || (sym_type == STT_SECTION
12767 && (sec->flags & SEC_THREAD_LOCAL) != 0))))
12768 {
12769 if (tls_mask != 0
12770 && (r_type == R_PPC64_TLS
12771 || r_type == R_PPC64_TLSGD
12772 || r_type == R_PPC64_TLSLD))
12773 /* R_PPC64_TLS is OK against a symbol in the TOC. */
12774 ;
12775 else
12776 info->callbacks->einfo
12777 (!IS_PPC64_TLS_RELOC (r_type)
12778 ? _("%P: %H: %s used with TLS symbol `%T'\n")
12779 : _("%P: %H: %s used with non-TLS symbol `%T'\n"),
12780 input_bfd, input_section, rel->r_offset,
12781 ppc64_elf_howto_table[r_type]->name,
12782 sym_name);
12783 }
12784
12785 /* Ensure reloc mapping code below stays sane. */
12786 if (R_PPC64_TOC16_LO_DS != R_PPC64_TOC16_DS + 1
12787 || R_PPC64_TOC16_LO != R_PPC64_TOC16 + 1
12788 || (R_PPC64_GOT_TLSLD16 & 3) != (R_PPC64_GOT_TLSGD16 & 3)
12789 || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TLSGD16_LO & 3)
12790 || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TLSGD16_HI & 3)
12791 || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TLSGD16_HA & 3)
12792 || (R_PPC64_GOT_TLSLD16 & 3) != (R_PPC64_GOT_TPREL16_DS & 3)
12793 || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TPREL16_LO_DS & 3)
12794 || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TPREL16_HI & 3)
12795 || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TPREL16_HA & 3))
12796 abort ();
12797
12798 switch (r_type)
12799 {
12800 default:
12801 break;
12802
12803 case R_PPC64_LO_DS_OPT:
12804 insn = bfd_get_32 (output_bfd, contents + rel->r_offset - d_offset);
12805 if ((insn & (0x3f << 26)) != 58u << 26)
12806 abort ();
12807 insn += (14u << 26) - (58u << 26);
12808 bfd_put_32 (output_bfd, insn, contents + rel->r_offset - d_offset);
12809 r_type = R_PPC64_TOC16_LO;
12810 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
12811 break;
12812
12813 case R_PPC64_TOC16:
12814 case R_PPC64_TOC16_LO:
12815 case R_PPC64_TOC16_DS:
12816 case R_PPC64_TOC16_LO_DS:
12817 {
12818 /* Check for toc tls entries. */
12819 unsigned char *toc_tls;
12820 int retval;
12821
12822 retval = get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
12823 &local_syms, rel, input_bfd);
12824 if (retval == 0)
12825 return FALSE;
12826
12827 if (toc_tls)
12828 {
12829 tls_mask = *toc_tls;
12830 if (r_type == R_PPC64_TOC16_DS
12831 || r_type == R_PPC64_TOC16_LO_DS)
12832 {
12833 if (tls_mask != 0
12834 && (tls_mask & (TLS_DTPREL | TLS_TPREL)) == 0)
12835 goto toctprel;
12836 }
12837 else
12838 {
12839 /* If we found a GD reloc pair, then we might be
12840 doing a GD->IE transition. */
12841 if (retval == 2)
12842 {
12843 tls_gd = TLS_TPRELGD;
12844 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
12845 goto tls_ldgd_opt;
12846 }
12847 else if (retval == 3)
12848 {
12849 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
12850 goto tls_ldgd_opt;
12851 }
12852 }
12853 }
12854 }
12855 break;
12856
12857 case R_PPC64_GOT_TPREL16_HI:
12858 case R_PPC64_GOT_TPREL16_HA:
12859 if (tls_mask != 0
12860 && (tls_mask & TLS_TPREL) == 0)
12861 {
12862 rel->r_offset -= d_offset;
12863 bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
12864 r_type = R_PPC64_NONE;
12865 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
12866 }
12867 break;
12868
12869 case R_PPC64_GOT_TPREL16_DS:
12870 case R_PPC64_GOT_TPREL16_LO_DS:
12871 if (tls_mask != 0
12872 && (tls_mask & TLS_TPREL) == 0)
12873 {
12874 toctprel:
12875 insn = bfd_get_32 (output_bfd, contents + rel->r_offset - d_offset);
12876 insn &= 31 << 21;
12877 insn |= 0x3c0d0000; /* addis 0,13,0 */
12878 bfd_put_32 (output_bfd, insn, contents + rel->r_offset - d_offset);
12879 r_type = R_PPC64_TPREL16_HA;
12880 if (toc_symndx != 0)
12881 {
12882 rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
12883 rel->r_addend = toc_addend;
12884 /* We changed the symbol. Start over in order to
12885 get h, sym, sec etc. right. */
12886 rel--;
12887 continue;
12888 }
12889 else
12890 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
12891 }
12892 break;
12893
12894 case R_PPC64_TLS:
12895 if (tls_mask != 0
12896 && (tls_mask & TLS_TPREL) == 0)
12897 {
12898 insn = bfd_get_32 (output_bfd, contents + rel->r_offset);
12899 insn = _bfd_elf_ppc_at_tls_transform (insn, 13);
12900 if (insn == 0)
12901 abort ();
12902 bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
12903 /* Was PPC64_TLS which sits on insn boundary, now
12904 PPC64_TPREL16_LO which is at low-order half-word. */
12905 rel->r_offset += d_offset;
12906 r_type = R_PPC64_TPREL16_LO;
12907 if (toc_symndx != 0)
12908 {
12909 rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
12910 rel->r_addend = toc_addend;
12911 /* We changed the symbol. Start over in order to
12912 get h, sym, sec etc. right. */
12913 rel--;
12914 continue;
12915 }
12916 else
12917 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
12918 }
12919 break;
12920
12921 case R_PPC64_GOT_TLSGD16_HI:
12922 case R_PPC64_GOT_TLSGD16_HA:
12923 tls_gd = TLS_TPRELGD;
12924 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
12925 goto tls_gdld_hi;
12926 break;
12927
12928 case R_PPC64_GOT_TLSLD16_HI:
12929 case R_PPC64_GOT_TLSLD16_HA:
12930 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
12931 {
12932 tls_gdld_hi:
12933 if ((tls_mask & tls_gd) != 0)
12934 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
12935 + R_PPC64_GOT_TPREL16_DS);
12936 else
12937 {
12938 rel->r_offset -= d_offset;
12939 bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
12940 r_type = R_PPC64_NONE;
12941 }
12942 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
12943 }
12944 break;
12945
12946 case R_PPC64_GOT_TLSGD16:
12947 case R_PPC64_GOT_TLSGD16_LO:
12948 tls_gd = TLS_TPRELGD;
12949 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
12950 goto tls_ldgd_opt;
12951 break;
12952
12953 case R_PPC64_GOT_TLSLD16:
12954 case R_PPC64_GOT_TLSLD16_LO:
12955 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
12956 {
12957 unsigned int insn1, insn2, insn3;
12958 bfd_vma offset;
12959
12960 tls_ldgd_opt:
12961 offset = (bfd_vma) -1;
12962 /* If not using the newer R_PPC64_TLSGD/LD to mark
12963 __tls_get_addr calls, we must trust that the call
12964 stays with its arg setup insns, ie. that the next
12965 reloc is the __tls_get_addr call associated with
12966 the current reloc. Edit both insns. */
12967 if (input_section->has_tls_get_addr_call
12968 && rel + 1 < relend
12969 && branch_reloc_hash_match (input_bfd, rel + 1,
12970 htab->tls_get_addr,
12971 htab->tls_get_addr_fd))
12972 offset = rel[1].r_offset;
12973 if ((tls_mask & tls_gd) != 0)
12974 {
12975 /* IE */
12976 insn1 = bfd_get_32 (output_bfd,
12977 contents + rel->r_offset - d_offset);
12978 insn1 &= (1 << 26) - (1 << 2);
12979 insn1 |= 58 << 26; /* ld */
12980 insn2 = 0x7c636a14; /* add 3,3,13 */
12981 if (offset != (bfd_vma) -1)
12982 rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
12983 if ((tls_mask & TLS_EXPLICIT) == 0)
12984 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
12985 + R_PPC64_GOT_TPREL16_DS);
12986 else
12987 r_type += R_PPC64_TOC16_DS - R_PPC64_TOC16;
12988 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
12989 }
12990 else
12991 {
12992 /* LE */
12993 insn1 = 0x3c6d0000; /* addis 3,13,0 */
12994 insn2 = 0x38630000; /* addi 3,3,0 */
12995 if (tls_gd == 0)
12996 {
12997 /* Was an LD reloc. */
12998 if (toc_symndx)
12999 sec = local_sections[toc_symndx];
13000 for (r_symndx = 0;
13001 r_symndx < symtab_hdr->sh_info;
13002 r_symndx++)
13003 if (local_sections[r_symndx] == sec)
13004 break;
13005 if (r_symndx >= symtab_hdr->sh_info)
13006 r_symndx = STN_UNDEF;
13007 rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
13008 if (r_symndx != STN_UNDEF)
13009 rel->r_addend -= (local_syms[r_symndx].st_value
13010 + sec->output_offset
13011 + sec->output_section->vma);
13012 }
13013 else if (toc_symndx != 0)
13014 {
13015 r_symndx = toc_symndx;
13016 rel->r_addend = toc_addend;
13017 }
13018 r_type = R_PPC64_TPREL16_HA;
13019 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13020 if (offset != (bfd_vma) -1)
13021 {
13022 rel[1].r_info = ELF64_R_INFO (r_symndx,
13023 R_PPC64_TPREL16_LO);
13024 rel[1].r_offset = offset + d_offset;
13025 rel[1].r_addend = rel->r_addend;
13026 }
13027 }
13028 bfd_put_32 (output_bfd, insn1,
13029 contents + rel->r_offset - d_offset);
13030 if (offset != (bfd_vma) -1)
13031 {
13032 insn3 = bfd_get_32 (output_bfd,
13033 contents + offset + 4);
13034 if (insn3 == NOP
13035 || insn3 == CROR_151515 || insn3 == CROR_313131)
13036 {
13037 rel[1].r_offset += 4;
13038 bfd_put_32 (output_bfd, insn2, contents + offset + 4);
13039 insn2 = NOP;
13040 }
13041 bfd_put_32 (output_bfd, insn2, contents + offset);
13042 }
13043 if ((tls_mask & tls_gd) == 0
13044 && (tls_gd == 0 || toc_symndx != 0))
13045 {
13046 /* We changed the symbol. Start over in order
13047 to get h, sym, sec etc. right. */
13048 rel--;
13049 continue;
13050 }
13051 }
13052 break;
13053
13054 case R_PPC64_TLSGD:
13055 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13056 {
13057 unsigned int insn2, insn3;
13058 bfd_vma offset = rel->r_offset;
13059
13060 if ((tls_mask & TLS_TPRELGD) != 0)
13061 {
13062 /* IE */
13063 r_type = R_PPC64_NONE;
13064 insn2 = 0x7c636a14; /* add 3,3,13 */
13065 }
13066 else
13067 {
13068 /* LE */
13069 if (toc_symndx != 0)
13070 {
13071 r_symndx = toc_symndx;
13072 rel->r_addend = toc_addend;
13073 }
13074 r_type = R_PPC64_TPREL16_LO;
13075 rel->r_offset = offset + d_offset;
13076 insn2 = 0x38630000; /* addi 3,3,0 */
13077 }
13078 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13079 /* Zap the reloc on the _tls_get_addr call too. */
13080 BFD_ASSERT (offset == rel[1].r_offset);
13081 rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13082 insn3 = bfd_get_32 (output_bfd,
13083 contents + offset + 4);
13084 if (insn3 == NOP
13085 || insn3 == CROR_151515 || insn3 == CROR_313131)
13086 {
13087 rel->r_offset += 4;
13088 bfd_put_32 (output_bfd, insn2, contents + offset + 4);
13089 insn2 = NOP;
13090 }
13091 bfd_put_32 (output_bfd, insn2, contents + offset);
13092 if ((tls_mask & TLS_TPRELGD) == 0 && toc_symndx != 0)
13093 {
13094 rel--;
13095 continue;
13096 }
13097 }
13098 break;
13099
13100 case R_PPC64_TLSLD:
13101 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13102 {
13103 unsigned int insn2, insn3;
13104 bfd_vma offset = rel->r_offset;
13105
13106 if (toc_symndx)
13107 sec = local_sections[toc_symndx];
13108 for (r_symndx = 0;
13109 r_symndx < symtab_hdr->sh_info;
13110 r_symndx++)
13111 if (local_sections[r_symndx] == sec)
13112 break;
13113 if (r_symndx >= symtab_hdr->sh_info)
13114 r_symndx = STN_UNDEF;
13115 rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
13116 if (r_symndx != STN_UNDEF)
13117 rel->r_addend -= (local_syms[r_symndx].st_value
13118 + sec->output_offset
13119 + sec->output_section->vma);
13120
13121 r_type = R_PPC64_TPREL16_LO;
13122 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13123 rel->r_offset = offset + d_offset;
13124 /* Zap the reloc on the _tls_get_addr call too. */
13125 BFD_ASSERT (offset == rel[1].r_offset);
13126 rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13127 insn2 = 0x38630000; /* addi 3,3,0 */
13128 insn3 = bfd_get_32 (output_bfd,
13129 contents + offset + 4);
13130 if (insn3 == NOP
13131 || insn3 == CROR_151515 || insn3 == CROR_313131)
13132 {
13133 rel->r_offset += 4;
13134 bfd_put_32 (output_bfd, insn2, contents + offset + 4);
13135 insn2 = NOP;
13136 }
13137 bfd_put_32 (output_bfd, insn2, contents + offset);
13138 rel--;
13139 continue;
13140 }
13141 break;
13142
13143 case R_PPC64_DTPMOD64:
13144 if (rel + 1 < relend
13145 && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
13146 && rel[1].r_offset == rel->r_offset + 8)
13147 {
13148 if ((tls_mask & TLS_GD) == 0)
13149 {
13150 rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_NONE);
13151 if ((tls_mask & TLS_TPRELGD) != 0)
13152 r_type = R_PPC64_TPREL64;
13153 else
13154 {
13155 bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
13156 r_type = R_PPC64_NONE;
13157 }
13158 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13159 }
13160 }
13161 else
13162 {
13163 if ((tls_mask & TLS_LD) == 0)
13164 {
13165 bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
13166 r_type = R_PPC64_NONE;
13167 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13168 }
13169 }
13170 break;
13171
13172 case R_PPC64_TPREL64:
13173 if ((tls_mask & TLS_TPREL) == 0)
13174 {
13175 r_type = R_PPC64_NONE;
13176 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13177 }
13178 break;
13179 }
13180
13181 /* Handle other relocations that tweak non-addend part of insn. */
13182 insn = 0;
13183 max_br_offset = 1 << 25;
13184 addend = rel->r_addend;
13185 reloc_dest = DEST_NORMAL;
13186 switch (r_type)
13187 {
13188 default:
13189 break;
13190
13191 case R_PPC64_TOCSAVE:
13192 if (relocation + addend == (rel->r_offset
13193 + input_section->output_offset
13194 + input_section->output_section->vma)
13195 && tocsave_find (htab, NO_INSERT,
13196 &local_syms, rel, input_bfd))
13197 {
13198 insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
13199 if (insn == NOP
13200 || insn == CROR_151515 || insn == CROR_313131)
13201 bfd_put_32 (input_bfd, STD_R2_40R1,
13202 contents + rel->r_offset);
13203 }
13204 break;
13205
13206 /* Branch taken prediction relocations. */
13207 case R_PPC64_ADDR14_BRTAKEN:
13208 case R_PPC64_REL14_BRTAKEN:
13209 insn = 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field. */
13210 /* Fall thru. */
13211
13212 /* Branch not taken prediction relocations. */
13213 case R_PPC64_ADDR14_BRNTAKEN:
13214 case R_PPC64_REL14_BRNTAKEN:
13215 insn |= bfd_get_32 (output_bfd,
13216 contents + rel->r_offset) & ~(0x01 << 21);
13217 /* Fall thru. */
13218
13219 case R_PPC64_REL14:
13220 max_br_offset = 1 << 15;
13221 /* Fall thru. */
13222
13223 case R_PPC64_REL24:
13224 /* Calls to functions with a different TOC, such as calls to
13225 shared objects, need to alter the TOC pointer. This is
13226 done using a linkage stub. A REL24 branching to these
13227 linkage stubs needs to be followed by a nop, as the nop
13228 will be replaced with an instruction to restore the TOC
13229 base pointer. */
13230 fdh = h;
13231 if (h != NULL
13232 && h->oh != NULL
13233 && h->oh->is_func_descriptor)
13234 fdh = ppc_follow_link (h->oh);
13235 stub_entry = ppc_get_stub_entry (input_section, sec, fdh, &orig_rel,
13236 htab);
13237 if (stub_entry != NULL
13238 && (stub_entry->stub_type == ppc_stub_plt_call
13239 || stub_entry->stub_type == ppc_stub_plt_call_r2save
13240 || stub_entry->stub_type == ppc_stub_plt_branch_r2off
13241 || stub_entry->stub_type == ppc_stub_long_branch_r2off))
13242 {
13243 bfd_boolean can_plt_call = FALSE;
13244
13245 /* All of these stubs will modify r2, so there must be a
13246 branch and link followed by a nop. The nop is
13247 replaced by an insn to restore r2. */
13248 if (rel->r_offset + 8 <= input_section->size)
13249 {
13250 unsigned long br;
13251
13252 br = bfd_get_32 (input_bfd,
13253 contents + rel->r_offset);
13254 if ((br & 1) != 0)
13255 {
13256 unsigned long nop;
13257
13258 nop = bfd_get_32 (input_bfd,
13259 contents + rel->r_offset + 4);
13260 if (nop == NOP
13261 || nop == CROR_151515 || nop == CROR_313131)
13262 {
13263 if (h != NULL
13264 && (h == htab->tls_get_addr_fd
13265 || h == htab->tls_get_addr)
13266 && !htab->no_tls_get_addr_opt)
13267 {
13268 /* Special stub used, leave nop alone. */
13269 }
13270 else
13271 bfd_put_32 (input_bfd, LD_R2_40R1,
13272 contents + rel->r_offset + 4);
13273 can_plt_call = TRUE;
13274 }
13275 }
13276 }
13277
13278 if (!can_plt_call && h != NULL)
13279 {
13280 const char *name = h->elf.root.root.string;
13281
13282 if (*name == '.')
13283 ++name;
13284
13285 if (strncmp (name, "__libc_start_main", 17) == 0
13286 && (name[17] == 0 || name[17] == '@'))
13287 {
13288 /* Allow crt1 branch to go via a toc adjusting
13289 stub. Other calls that never return could do
13290 the same, if we could detect such. */
13291 can_plt_call = TRUE;
13292 }
13293 }
13294
13295 if (!can_plt_call)
13296 {
13297 /* g++ as of 20130507 emits self-calls without a
13298 following nop. This is arguably wrong since we
13299 have conflicting information. On the one hand a
13300 global symbol and on the other a local call
13301 sequence, but don't error for this special case.
13302 It isn't possible to cheaply verify we have
13303 exactly such a call. Allow all calls to the same
13304 section. */
13305 asection *code_sec = sec;
13306
13307 if (get_opd_info (sec) != NULL)
13308 {
13309 bfd_vma off = (relocation + addend
13310 - sec->output_section->vma
13311 - sec->output_offset);
13312
13313 opd_entry_value (sec, off, &code_sec, NULL, FALSE);
13314 }
13315 if (code_sec == input_section)
13316 can_plt_call = TRUE;
13317 }
13318
13319 if (!can_plt_call)
13320 {
13321 info->callbacks->einfo
13322 (_("%P: %H: call to `%T' lacks nop, can't restore toc; "
13323 "recompile with -fPIC"),
13324 input_bfd, input_section, rel->r_offset, sym_name);
13325
13326 bfd_set_error (bfd_error_bad_value);
13327 ret = FALSE;
13328 }
13329
13330 if (can_plt_call
13331 && (stub_entry->stub_type == ppc_stub_plt_call
13332 || stub_entry->stub_type == ppc_stub_plt_call_r2save))
13333 unresolved_reloc = FALSE;
13334 }
13335
13336 if ((stub_entry == NULL
13337 || stub_entry->stub_type == ppc_stub_long_branch
13338 || stub_entry->stub_type == ppc_stub_plt_branch)
13339 && get_opd_info (sec) != NULL)
13340 {
13341 /* The branch destination is the value of the opd entry. */
13342 bfd_vma off = (relocation + addend
13343 - sec->output_section->vma
13344 - sec->output_offset);
13345 bfd_vma dest = opd_entry_value (sec, off, NULL, NULL, FALSE);
13346 if (dest != (bfd_vma) -1)
13347 {
13348 relocation = dest;
13349 addend = 0;
13350 reloc_dest = DEST_OPD;
13351 }
13352 }
13353
13354 /* If the branch is out of reach we ought to have a long
13355 branch stub. */
13356 from = (rel->r_offset
13357 + input_section->output_offset
13358 + input_section->output_section->vma);
13359
13360 if (stub_entry != NULL
13361 && (stub_entry->stub_type == ppc_stub_long_branch
13362 || stub_entry->stub_type == ppc_stub_plt_branch)
13363 && (r_type == R_PPC64_ADDR14_BRTAKEN
13364 || r_type == R_PPC64_ADDR14_BRNTAKEN
13365 || (relocation + addend - from + max_br_offset
13366 < 2 * max_br_offset)))
13367 /* Don't use the stub if this branch is in range. */
13368 stub_entry = NULL;
13369
13370 if (stub_entry != NULL)
13371 {
13372 /* Munge up the value and addend so that we call the stub
13373 rather than the procedure directly. */
13374 relocation = (stub_entry->stub_offset
13375 + stub_entry->stub_sec->output_offset
13376 + stub_entry->stub_sec->output_section->vma);
13377 addend = 0;
13378 reloc_dest = DEST_STUB;
13379
13380 if ((stub_entry->stub_type == ppc_stub_plt_call
13381 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
13382 && (ALWAYS_EMIT_R2SAVE
13383 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
13384 && rel + 1 < relend
13385 && rel[1].r_offset == rel->r_offset + 4
13386 && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOCSAVE)
13387 relocation += 4;
13388 }
13389
13390 if (insn != 0)
13391 {
13392 if (is_isa_v2)
13393 {
13394 /* Set 'a' bit. This is 0b00010 in BO field for branch
13395 on CR(BI) insns (BO == 001at or 011at), and 0b01000
13396 for branch on CTR insns (BO == 1a00t or 1a01t). */
13397 if ((insn & (0x14 << 21)) == (0x04 << 21))
13398 insn |= 0x02 << 21;
13399 else if ((insn & (0x14 << 21)) == (0x10 << 21))
13400 insn |= 0x08 << 21;
13401 else
13402 break;
13403 }
13404 else
13405 {
13406 /* Invert 'y' bit if not the default. */
13407 if ((bfd_signed_vma) (relocation + addend - from) < 0)
13408 insn ^= 0x01 << 21;
13409 }
13410
13411 bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
13412 }
13413
13414 /* NOP out calls to undefined weak functions.
13415 We can thus call a weak function without first
13416 checking whether the function is defined. */
13417 else if (h != NULL
13418 && h->elf.root.type == bfd_link_hash_undefweak
13419 && h->elf.dynindx == -1
13420 && r_type == R_PPC64_REL24
13421 && relocation == 0
13422 && addend == 0)
13423 {
13424 bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
13425 continue;
13426 }
13427 break;
13428 }
13429
13430 /* Set `addend'. */
13431 tls_type = 0;
13432 switch (r_type)
13433 {
13434 default:
13435 info->callbacks->einfo
13436 (_("%P: %B: unknown relocation type %d for `%T'\n"),
13437 input_bfd, (int) r_type, sym_name);
13438
13439 bfd_set_error (bfd_error_bad_value);
13440 ret = FALSE;
13441 continue;
13442
13443 case R_PPC64_NONE:
13444 case R_PPC64_TLS:
13445 case R_PPC64_TLSGD:
13446 case R_PPC64_TLSLD:
13447 case R_PPC64_TOCSAVE:
13448 case R_PPC64_GNU_VTINHERIT:
13449 case R_PPC64_GNU_VTENTRY:
13450 continue;
13451
13452 /* GOT16 relocations. Like an ADDR16 using the symbol's
13453 address in the GOT as relocation value instead of the
13454 symbol's value itself. Also, create a GOT entry for the
13455 symbol and put the symbol value there. */
13456 case R_PPC64_GOT_TLSGD16:
13457 case R_PPC64_GOT_TLSGD16_LO:
13458 case R_PPC64_GOT_TLSGD16_HI:
13459 case R_PPC64_GOT_TLSGD16_HA:
13460 tls_type = TLS_TLS | TLS_GD;
13461 goto dogot;
13462
13463 case R_PPC64_GOT_TLSLD16:
13464 case R_PPC64_GOT_TLSLD16_LO:
13465 case R_PPC64_GOT_TLSLD16_HI:
13466 case R_PPC64_GOT_TLSLD16_HA:
13467 tls_type = TLS_TLS | TLS_LD;
13468 goto dogot;
13469
13470 case R_PPC64_GOT_TPREL16_DS:
13471 case R_PPC64_GOT_TPREL16_LO_DS:
13472 case R_PPC64_GOT_TPREL16_HI:
13473 case R_PPC64_GOT_TPREL16_HA:
13474 tls_type = TLS_TLS | TLS_TPREL;
13475 goto dogot;
13476
13477 case R_PPC64_GOT_DTPREL16_DS:
13478 case R_PPC64_GOT_DTPREL16_LO_DS:
13479 case R_PPC64_GOT_DTPREL16_HI:
13480 case R_PPC64_GOT_DTPREL16_HA:
13481 tls_type = TLS_TLS | TLS_DTPREL;
13482 goto dogot;
13483
13484 case R_PPC64_GOT16:
13485 case R_PPC64_GOT16_LO:
13486 case R_PPC64_GOT16_HI:
13487 case R_PPC64_GOT16_HA:
13488 case R_PPC64_GOT16_DS:
13489 case R_PPC64_GOT16_LO_DS:
13490 dogot:
13491 {
13492 /* Relocation is to the entry for this symbol in the global
13493 offset table. */
13494 asection *got;
13495 bfd_vma *offp;
13496 bfd_vma off;
13497 unsigned long indx = 0;
13498 struct got_entry *ent;
13499
13500 if (tls_type == (TLS_TLS | TLS_LD)
13501 && (h == NULL
13502 || !h->elf.def_dynamic))
13503 ent = ppc64_tlsld_got (input_bfd);
13504 else
13505 {
13506
13507 if (h != NULL)
13508 {
13509 bfd_boolean dyn = htab->elf.dynamic_sections_created;
13510 if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared,
13511 &h->elf)
13512 || (info->shared
13513 && SYMBOL_CALLS_LOCAL (info, &h->elf)))
13514 /* This is actually a static link, or it is a
13515 -Bsymbolic link and the symbol is defined
13516 locally, or the symbol was forced to be local
13517 because of a version file. */
13518 ;
13519 else
13520 {
13521 BFD_ASSERT (h->elf.dynindx != -1);
13522 indx = h->elf.dynindx;
13523 unresolved_reloc = FALSE;
13524 }
13525 ent = h->elf.got.glist;
13526 }
13527 else
13528 {
13529 if (local_got_ents == NULL)
13530 abort ();
13531 ent = local_got_ents[r_symndx];
13532 }
13533
13534 for (; ent != NULL; ent = ent->next)
13535 if (ent->addend == orig_rel.r_addend
13536 && ent->owner == input_bfd
13537 && ent->tls_type == tls_type)
13538 break;
13539 }
13540
13541 if (ent == NULL)
13542 abort ();
13543 if (ent->is_indirect)
13544 ent = ent->got.ent;
13545 offp = &ent->got.offset;
13546 got = ppc64_elf_tdata (ent->owner)->got;
13547 if (got == NULL)
13548 abort ();
13549
13550 /* The offset must always be a multiple of 8. We use the
13551 least significant bit to record whether we have already
13552 processed this entry. */
13553 off = *offp;
13554 if ((off & 1) != 0)
13555 off &= ~1;
13556 else
13557 {
13558 /* Generate relocs for the dynamic linker, except in
13559 the case of TLSLD where we'll use one entry per
13560 module. */
13561 asection *relgot;
13562 bfd_boolean ifunc;
13563
13564 *offp = off | 1;
13565 relgot = NULL;
13566 ifunc = (h != NULL
13567 ? h->elf.type == STT_GNU_IFUNC
13568 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC);
13569 if (ifunc)
13570 relgot = htab->reliplt;
13571 else if ((info->shared || indx != 0)
13572 && (h == NULL
13573 || (tls_type == (TLS_TLS | TLS_LD)
13574 && !h->elf.def_dynamic)
13575 || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
13576 || h->elf.root.type != bfd_link_hash_undefweak))
13577 relgot = ppc64_elf_tdata (ent->owner)->relgot;
13578 if (relgot != NULL)
13579 {
13580 outrel.r_offset = (got->output_section->vma
13581 + got->output_offset
13582 + off);
13583 outrel.r_addend = addend;
13584 if (tls_type & (TLS_LD | TLS_GD))
13585 {
13586 outrel.r_addend = 0;
13587 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPMOD64);
13588 if (tls_type == (TLS_TLS | TLS_GD))
13589 {
13590 loc = relgot->contents;
13591 loc += (relgot->reloc_count++
13592 * sizeof (Elf64_External_Rela));
13593 bfd_elf64_swap_reloca_out (output_bfd,
13594 &outrel, loc);
13595 outrel.r_offset += 8;
13596 outrel.r_addend = addend;
13597 outrel.r_info
13598 = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
13599 }
13600 }
13601 else if (tls_type == (TLS_TLS | TLS_DTPREL))
13602 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
13603 else if (tls_type == (TLS_TLS | TLS_TPREL))
13604 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_TPREL64);
13605 else if (indx != 0)
13606 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_GLOB_DAT);
13607 else
13608 {
13609 if (ifunc)
13610 outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
13611 else
13612 outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
13613
13614 /* Write the .got section contents for the sake
13615 of prelink. */
13616 loc = got->contents + off;
13617 bfd_put_64 (output_bfd, outrel.r_addend + relocation,
13618 loc);
13619 }
13620
13621 if (indx == 0 && tls_type != (TLS_TLS | TLS_LD))
13622 {
13623 outrel.r_addend += relocation;
13624 if (tls_type & (TLS_GD | TLS_DTPREL | TLS_TPREL))
13625 outrel.r_addend -= htab->elf.tls_sec->vma;
13626 }
13627 loc = relgot->contents;
13628 loc += (relgot->reloc_count++
13629 * sizeof (Elf64_External_Rela));
13630 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
13631 }
13632
13633 /* Init the .got section contents here if we're not
13634 emitting a reloc. */
13635 else
13636 {
13637 relocation += addend;
13638 if (tls_type == (TLS_TLS | TLS_LD))
13639 relocation = 1;
13640 else if (tls_type != 0)
13641 {
13642 relocation -= htab->elf.tls_sec->vma + DTP_OFFSET;
13643 if (tls_type == (TLS_TLS | TLS_TPREL))
13644 relocation += DTP_OFFSET - TP_OFFSET;
13645
13646 if (tls_type == (TLS_TLS | TLS_GD))
13647 {
13648 bfd_put_64 (output_bfd, relocation,
13649 got->contents + off + 8);
13650 relocation = 1;
13651 }
13652 }
13653
13654 bfd_put_64 (output_bfd, relocation,
13655 got->contents + off);
13656 }
13657 }
13658
13659 if (off >= (bfd_vma) -2)
13660 abort ();
13661
13662 relocation = got->output_section->vma + got->output_offset + off;
13663 addend = -(TOCstart + htab->stub_group[input_section->id].toc_off);
13664 }
13665 break;
13666
13667 case R_PPC64_PLT16_HA:
13668 case R_PPC64_PLT16_HI:
13669 case R_PPC64_PLT16_LO:
13670 case R_PPC64_PLT32:
13671 case R_PPC64_PLT64:
13672 /* Relocation is to the entry for this symbol in the
13673 procedure linkage table. */
13674
13675 /* Resolve a PLT reloc against a local symbol directly,
13676 without using the procedure linkage table. */
13677 if (h == NULL)
13678 break;
13679
13680 /* It's possible that we didn't make a PLT entry for this
13681 symbol. This happens when statically linking PIC code,
13682 or when using -Bsymbolic. Go find a match if there is a
13683 PLT entry. */
13684 if (htab->plt != NULL)
13685 {
13686 struct plt_entry *ent;
13687 for (ent = h->elf.plt.plist; ent != NULL; ent = ent->next)
13688 if (ent->addend == orig_rel.r_addend
13689 && ent->plt.offset != (bfd_vma) -1)
13690 {
13691 relocation = (htab->plt->output_section->vma
13692 + htab->plt->output_offset
13693 + ent->plt.offset);
13694 unresolved_reloc = FALSE;
13695 }
13696 }
13697 break;
13698
13699 case R_PPC64_TOC:
13700 /* Relocation value is TOC base. */
13701 relocation = TOCstart;
13702 if (r_symndx == STN_UNDEF)
13703 relocation += htab->stub_group[input_section->id].toc_off;
13704 else if (unresolved_reloc)
13705 ;
13706 else if (sec != NULL && sec->id <= htab->top_id)
13707 relocation += htab->stub_group[sec->id].toc_off;
13708 else
13709 unresolved_reloc = TRUE;
13710 goto dodyn;
13711
13712 /* TOC16 relocs. We want the offset relative to the TOC base,
13713 which is the address of the start of the TOC plus 0x8000.
13714 The TOC consists of sections .got, .toc, .tocbss, and .plt,
13715 in this order. */
13716 case R_PPC64_TOC16:
13717 case R_PPC64_TOC16_LO:
13718 case R_PPC64_TOC16_HI:
13719 case R_PPC64_TOC16_DS:
13720 case R_PPC64_TOC16_LO_DS:
13721 case R_PPC64_TOC16_HA:
13722 addend -= TOCstart + htab->stub_group[input_section->id].toc_off;
13723 break;
13724
13725 /* Relocate against the beginning of the section. */
13726 case R_PPC64_SECTOFF:
13727 case R_PPC64_SECTOFF_LO:
13728 case R_PPC64_SECTOFF_HI:
13729 case R_PPC64_SECTOFF_DS:
13730 case R_PPC64_SECTOFF_LO_DS:
13731 case R_PPC64_SECTOFF_HA:
13732 if (sec != NULL)
13733 addend -= sec->output_section->vma;
13734 break;
13735
13736 case R_PPC64_REL16:
13737 case R_PPC64_REL16_LO:
13738 case R_PPC64_REL16_HI:
13739 case R_PPC64_REL16_HA:
13740 break;
13741
13742 case R_PPC64_REL14:
13743 case R_PPC64_REL14_BRNTAKEN:
13744 case R_PPC64_REL14_BRTAKEN:
13745 case R_PPC64_REL24:
13746 break;
13747
13748 case R_PPC64_TPREL16:
13749 case R_PPC64_TPREL16_LO:
13750 case R_PPC64_TPREL16_HI:
13751 case R_PPC64_TPREL16_HA:
13752 case R_PPC64_TPREL16_DS:
13753 case R_PPC64_TPREL16_LO_DS:
13754 case R_PPC64_TPREL16_HIGH:
13755 case R_PPC64_TPREL16_HIGHA:
13756 case R_PPC64_TPREL16_HIGHER:
13757 case R_PPC64_TPREL16_HIGHERA:
13758 case R_PPC64_TPREL16_HIGHEST:
13759 case R_PPC64_TPREL16_HIGHESTA:
13760 if (h != NULL
13761 && h->elf.root.type == bfd_link_hash_undefweak
13762 && h->elf.dynindx == -1)
13763 {
13764 /* Make this relocation against an undefined weak symbol
13765 resolve to zero. This is really just a tweak, since
13766 code using weak externs ought to check that they are
13767 defined before using them. */
13768 bfd_byte *p = contents + rel->r_offset - d_offset;
13769
13770 insn = bfd_get_32 (output_bfd, p);
13771 insn = _bfd_elf_ppc_at_tprel_transform (insn, 13);
13772 if (insn != 0)
13773 bfd_put_32 (output_bfd, insn, p);
13774 break;
13775 }
13776 addend -= htab->elf.tls_sec->vma + TP_OFFSET;
13777 if (info->shared)
13778 /* The TPREL16 relocs shouldn't really be used in shared
13779 libs as they will result in DT_TEXTREL being set, but
13780 support them anyway. */
13781 goto dodyn;
13782 break;
13783
13784 case R_PPC64_DTPREL16:
13785 case R_PPC64_DTPREL16_LO:
13786 case R_PPC64_DTPREL16_HI:
13787 case R_PPC64_DTPREL16_HA:
13788 case R_PPC64_DTPREL16_DS:
13789 case R_PPC64_DTPREL16_LO_DS:
13790 case R_PPC64_DTPREL16_HIGH:
13791 case R_PPC64_DTPREL16_HIGHA:
13792 case R_PPC64_DTPREL16_HIGHER:
13793 case R_PPC64_DTPREL16_HIGHERA:
13794 case R_PPC64_DTPREL16_HIGHEST:
13795 case R_PPC64_DTPREL16_HIGHESTA:
13796 addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
13797 break;
13798
13799 case R_PPC64_DTPMOD64:
13800 relocation = 1;
13801 addend = 0;
13802 goto dodyn;
13803
13804 case R_PPC64_TPREL64:
13805 addend -= htab->elf.tls_sec->vma + TP_OFFSET;
13806 goto dodyn;
13807
13808 case R_PPC64_DTPREL64:
13809 addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
13810 /* Fall thru */
13811
13812 /* Relocations that may need to be propagated if this is a
13813 dynamic object. */
13814 case R_PPC64_REL30:
13815 case R_PPC64_REL32:
13816 case R_PPC64_REL64:
13817 case R_PPC64_ADDR14:
13818 case R_PPC64_ADDR14_BRNTAKEN:
13819 case R_PPC64_ADDR14_BRTAKEN:
13820 case R_PPC64_ADDR16:
13821 case R_PPC64_ADDR16_DS:
13822 case R_PPC64_ADDR16_HA:
13823 case R_PPC64_ADDR16_HI:
13824 case R_PPC64_ADDR16_HIGH:
13825 case R_PPC64_ADDR16_HIGHA:
13826 case R_PPC64_ADDR16_HIGHER:
13827 case R_PPC64_ADDR16_HIGHERA:
13828 case R_PPC64_ADDR16_HIGHEST:
13829 case R_PPC64_ADDR16_HIGHESTA:
13830 case R_PPC64_ADDR16_LO:
13831 case R_PPC64_ADDR16_LO_DS:
13832 case R_PPC64_ADDR24:
13833 case R_PPC64_ADDR32:
13834 case R_PPC64_ADDR64:
13835 case R_PPC64_UADDR16:
13836 case R_PPC64_UADDR32:
13837 case R_PPC64_UADDR64:
13838 dodyn:
13839 if ((input_section->flags & SEC_ALLOC) == 0)
13840 break;
13841
13842 if (NO_OPD_RELOCS && is_opd)
13843 break;
13844
13845 if ((info->shared
13846 && (h == NULL
13847 || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
13848 || h->elf.root.type != bfd_link_hash_undefweak)
13849 && (must_be_dyn_reloc (info, r_type)
13850 || !SYMBOL_CALLS_LOCAL (info, &h->elf)))
13851 || (ELIMINATE_COPY_RELOCS
13852 && !info->shared
13853 && h != NULL
13854 && h->elf.dynindx != -1
13855 && !h->elf.non_got_ref
13856 && !h->elf.def_regular)
13857 || (!info->shared
13858 && (h != NULL
13859 ? h->elf.type == STT_GNU_IFUNC
13860 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)))
13861 {
13862 bfd_boolean skip, relocate;
13863 asection *sreloc;
13864 bfd_vma out_off;
13865
13866 /* When generating a dynamic object, these relocations
13867 are copied into the output file to be resolved at run
13868 time. */
13869
13870 skip = FALSE;
13871 relocate = FALSE;
13872
13873 out_off = _bfd_elf_section_offset (output_bfd, info,
13874 input_section, rel->r_offset);
13875 if (out_off == (bfd_vma) -1)
13876 skip = TRUE;
13877 else if (out_off == (bfd_vma) -2)
13878 skip = TRUE, relocate = TRUE;
13879 out_off += (input_section->output_section->vma
13880 + input_section->output_offset);
13881 outrel.r_offset = out_off;
13882 outrel.r_addend = rel->r_addend;
13883
13884 /* Optimize unaligned reloc use. */
13885 if ((r_type == R_PPC64_ADDR64 && (out_off & 7) != 0)
13886 || (r_type == R_PPC64_UADDR64 && (out_off & 7) == 0))
13887 r_type ^= R_PPC64_ADDR64 ^ R_PPC64_UADDR64;
13888 else if ((r_type == R_PPC64_ADDR32 && (out_off & 3) != 0)
13889 || (r_type == R_PPC64_UADDR32 && (out_off & 3) == 0))
13890 r_type ^= R_PPC64_ADDR32 ^ R_PPC64_UADDR32;
13891 else if ((r_type == R_PPC64_ADDR16 && (out_off & 1) != 0)
13892 || (r_type == R_PPC64_UADDR16 && (out_off & 1) == 0))
13893 r_type ^= R_PPC64_ADDR16 ^ R_PPC64_UADDR16;
13894
13895 if (skip)
13896 memset (&outrel, 0, sizeof outrel);
13897 else if (!SYMBOL_CALLS_LOCAL (info, &h->elf)
13898 && !is_opd
13899 && r_type != R_PPC64_TOC)
13900 {
13901 BFD_ASSERT (h->elf.dynindx != -1);
13902 outrel.r_info = ELF64_R_INFO (h->elf.dynindx, r_type);
13903 }
13904 else
13905 {
13906 /* This symbol is local, or marked to become local,
13907 or this is an opd section reloc which must point
13908 at a local function. */
13909 outrel.r_addend += relocation;
13910 if (r_type == R_PPC64_ADDR64 || r_type == R_PPC64_TOC)
13911 {
13912 if (is_opd && h != NULL)
13913 {
13914 /* Lie about opd entries. This case occurs
13915 when building shared libraries and we
13916 reference a function in another shared
13917 lib. The same thing happens for a weak
13918 definition in an application that's
13919 overridden by a strong definition in a
13920 shared lib. (I believe this is a generic
13921 bug in binutils handling of weak syms.)
13922 In these cases we won't use the opd
13923 entry in this lib. */
13924 unresolved_reloc = FALSE;
13925 }
13926 if (!is_opd
13927 && r_type == R_PPC64_ADDR64
13928 && (h != NULL
13929 ? h->elf.type == STT_GNU_IFUNC
13930 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
13931 outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
13932 else
13933 {
13934 outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
13935
13936 /* We need to relocate .opd contents for ld.so.
13937 Prelink also wants simple and consistent rules
13938 for relocs. This make all RELATIVE relocs have
13939 *r_offset equal to r_addend. */
13940 relocate = TRUE;
13941 }
13942 }
13943 else
13944 {
13945 long indx = 0;
13946
13947 if (h != NULL
13948 ? h->elf.type == STT_GNU_IFUNC
13949 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
13950 {
13951 info->callbacks->einfo
13952 (_("%P: %H: %s for indirect "
13953 "function `%T' unsupported\n"),
13954 input_bfd, input_section, rel->r_offset,
13955 ppc64_elf_howto_table[r_type]->name,
13956 sym_name);
13957 ret = FALSE;
13958 }
13959 else if (r_symndx == STN_UNDEF || bfd_is_abs_section (sec))
13960 ;
13961 else if (sec == NULL || sec->owner == NULL)
13962 {
13963 bfd_set_error (bfd_error_bad_value);
13964 return FALSE;
13965 }
13966 else
13967 {
13968 asection *osec;
13969
13970 osec = sec->output_section;
13971 indx = elf_section_data (osec)->dynindx;
13972
13973 if (indx == 0)
13974 {
13975 if ((osec->flags & SEC_READONLY) == 0
13976 && htab->elf.data_index_section != NULL)
13977 osec = htab->elf.data_index_section;
13978 else
13979 osec = htab->elf.text_index_section;
13980 indx = elf_section_data (osec)->dynindx;
13981 }
13982 BFD_ASSERT (indx != 0);
13983
13984 /* We are turning this relocation into one
13985 against a section symbol, so subtract out
13986 the output section's address but not the
13987 offset of the input section in the output
13988 section. */
13989 outrel.r_addend -= osec->vma;
13990 }
13991
13992 outrel.r_info = ELF64_R_INFO (indx, r_type);
13993 }
13994 }
13995
13996 sreloc = elf_section_data (input_section)->sreloc;
13997 if (h != NULL
13998 ? h->elf.type == STT_GNU_IFUNC
13999 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
14000 sreloc = htab->reliplt;
14001 if (sreloc == NULL)
14002 abort ();
14003
14004 if (sreloc->reloc_count * sizeof (Elf64_External_Rela)
14005 >= sreloc->size)
14006 abort ();
14007 loc = sreloc->contents;
14008 loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
14009 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
14010
14011 /* If this reloc is against an external symbol, it will
14012 be computed at runtime, so there's no need to do
14013 anything now. However, for the sake of prelink ensure
14014 that the section contents are a known value. */
14015 if (! relocate)
14016 {
14017 unresolved_reloc = FALSE;
14018 /* The value chosen here is quite arbitrary as ld.so
14019 ignores section contents except for the special
14020 case of .opd where the contents might be accessed
14021 before relocation. Choose zero, as that won't
14022 cause reloc overflow. */
14023 relocation = 0;
14024 addend = 0;
14025 /* Use *r_offset == r_addend for R_PPC64_ADDR64 relocs
14026 to improve backward compatibility with older
14027 versions of ld. */
14028 if (r_type == R_PPC64_ADDR64)
14029 addend = outrel.r_addend;
14030 /* Adjust pc_relative relocs to have zero in *r_offset. */
14031 else if (ppc64_elf_howto_table[r_type]->pc_relative)
14032 addend = (input_section->output_section->vma
14033 + input_section->output_offset
14034 + rel->r_offset);
14035 }
14036 }
14037 break;
14038
14039 case R_PPC64_COPY:
14040 case R_PPC64_GLOB_DAT:
14041 case R_PPC64_JMP_SLOT:
14042 case R_PPC64_JMP_IREL:
14043 case R_PPC64_RELATIVE:
14044 /* We shouldn't ever see these dynamic relocs in relocatable
14045 files. */
14046 /* Fall through. */
14047
14048 case R_PPC64_PLTGOT16:
14049 case R_PPC64_PLTGOT16_DS:
14050 case R_PPC64_PLTGOT16_HA:
14051 case R_PPC64_PLTGOT16_HI:
14052 case R_PPC64_PLTGOT16_LO:
14053 case R_PPC64_PLTGOT16_LO_DS:
14054 case R_PPC64_PLTREL32:
14055 case R_PPC64_PLTREL64:
14056 /* These ones haven't been implemented yet. */
14057
14058 info->callbacks->einfo
14059 (_("%P: %B: %s is not supported for `%T'\n"),
14060 input_bfd,
14061 ppc64_elf_howto_table[r_type]->name, sym_name);
14062
14063 bfd_set_error (bfd_error_invalid_operation);
14064 ret = FALSE;
14065 continue;
14066 }
14067
14068 /* Multi-instruction sequences that access the TOC can be
14069 optimized, eg. addis ra,r2,0; addi rb,ra,x;
14070 to nop; addi rb,r2,x; */
14071 switch (r_type)
14072 {
14073 default:
14074 break;
14075
14076 case R_PPC64_GOT_TLSLD16_HI:
14077 case R_PPC64_GOT_TLSGD16_HI:
14078 case R_PPC64_GOT_TPREL16_HI:
14079 case R_PPC64_GOT_DTPREL16_HI:
14080 case R_PPC64_GOT16_HI:
14081 case R_PPC64_TOC16_HI:
14082 /* These relocs would only be useful if building up an
14083 offset to later add to r2, perhaps in an indexed
14084 addressing mode instruction. Don't try to optimize.
14085 Unfortunately, the possibility of someone building up an
14086 offset like this or even with the HA relocs, means that
14087 we need to check the high insn when optimizing the low
14088 insn. */
14089 break;
14090
14091 case R_PPC64_GOT_TLSLD16_HA:
14092 case R_PPC64_GOT_TLSGD16_HA:
14093 case R_PPC64_GOT_TPREL16_HA:
14094 case R_PPC64_GOT_DTPREL16_HA:
14095 case R_PPC64_GOT16_HA:
14096 case R_PPC64_TOC16_HA:
14097 if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
14098 && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
14099 {
14100 bfd_byte *p = contents + (rel->r_offset & ~3);
14101 bfd_put_32 (input_bfd, NOP, p);
14102 }
14103 break;
14104
14105 case R_PPC64_GOT_TLSLD16_LO:
14106 case R_PPC64_GOT_TLSGD16_LO:
14107 case R_PPC64_GOT_TPREL16_LO_DS:
14108 case R_PPC64_GOT_DTPREL16_LO_DS:
14109 case R_PPC64_GOT16_LO:
14110 case R_PPC64_GOT16_LO_DS:
14111 case R_PPC64_TOC16_LO:
14112 case R_PPC64_TOC16_LO_DS:
14113 if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
14114 && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
14115 {
14116 bfd_byte *p = contents + (rel->r_offset & ~3);
14117 insn = bfd_get_32 (input_bfd, p);
14118 if ((insn & (0x3f << 26)) == 12u << 26 /* addic */)
14119 {
14120 /* Transform addic to addi when we change reg. */
14121 insn &= ~((0x3f << 26) | (0x1f << 16));
14122 insn |= (14u << 26) | (2 << 16);
14123 }
14124 else
14125 {
14126 insn &= ~(0x1f << 16);
14127 insn |= 2 << 16;
14128 }
14129 bfd_put_32 (input_bfd, insn, p);
14130 }
14131 break;
14132 }
14133
14134 /* Do any further special processing. */
14135 switch (r_type)
14136 {
14137 default:
14138 break;
14139
14140 case R_PPC64_REL16_HA:
14141 case R_PPC64_ADDR16_HA:
14142 case R_PPC64_ADDR16_HIGHA:
14143 case R_PPC64_ADDR16_HIGHERA:
14144 case R_PPC64_ADDR16_HIGHESTA:
14145 case R_PPC64_TOC16_HA:
14146 case R_PPC64_SECTOFF_HA:
14147 case R_PPC64_TPREL16_HA:
14148 case R_PPC64_TPREL16_HIGHA:
14149 case R_PPC64_TPREL16_HIGHERA:
14150 case R_PPC64_TPREL16_HIGHESTA:
14151 case R_PPC64_DTPREL16_HA:
14152 case R_PPC64_DTPREL16_HIGHA:
14153 case R_PPC64_DTPREL16_HIGHERA:
14154 case R_PPC64_DTPREL16_HIGHESTA:
14155 /* It's just possible that this symbol is a weak symbol
14156 that's not actually defined anywhere. In that case,
14157 'sec' would be NULL, and we should leave the symbol
14158 alone (it will be set to zero elsewhere in the link). */
14159 if (sec == NULL)
14160 break;
14161 /* Fall thru */
14162
14163 case R_PPC64_GOT16_HA:
14164 case R_PPC64_PLTGOT16_HA:
14165 case R_PPC64_PLT16_HA:
14166 case R_PPC64_GOT_TLSGD16_HA:
14167 case R_PPC64_GOT_TLSLD16_HA:
14168 case R_PPC64_GOT_TPREL16_HA:
14169 case R_PPC64_GOT_DTPREL16_HA:
14170 /* Add 0x10000 if sign bit in 0:15 is set.
14171 Bits 0:15 are not used. */
14172 addend += 0x8000;
14173 break;
14174
14175 case R_PPC64_ADDR16_DS:
14176 case R_PPC64_ADDR16_LO_DS:
14177 case R_PPC64_GOT16_DS:
14178 case R_PPC64_GOT16_LO_DS:
14179 case R_PPC64_PLT16_LO_DS:
14180 case R_PPC64_SECTOFF_DS:
14181 case R_PPC64_SECTOFF_LO_DS:
14182 case R_PPC64_TOC16_DS:
14183 case R_PPC64_TOC16_LO_DS:
14184 case R_PPC64_PLTGOT16_DS:
14185 case R_PPC64_PLTGOT16_LO_DS:
14186 case R_PPC64_GOT_TPREL16_DS:
14187 case R_PPC64_GOT_TPREL16_LO_DS:
14188 case R_PPC64_GOT_DTPREL16_DS:
14189 case R_PPC64_GOT_DTPREL16_LO_DS:
14190 case R_PPC64_TPREL16_DS:
14191 case R_PPC64_TPREL16_LO_DS:
14192 case R_PPC64_DTPREL16_DS:
14193 case R_PPC64_DTPREL16_LO_DS:
14194 insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
14195 mask = 3;
14196 /* If this reloc is against an lq insn, then the value must be
14197 a multiple of 16. This is somewhat of a hack, but the
14198 "correct" way to do this by defining _DQ forms of all the
14199 _DS relocs bloats all reloc switches in this file. It
14200 doesn't seem to make much sense to use any of these relocs
14201 in data, so testing the insn should be safe. */
14202 if ((insn & (0x3f << 26)) == (56u << 26))
14203 mask = 15;
14204 if (((relocation + addend) & mask) != 0)
14205 {
14206 info->callbacks->einfo
14207 (_("%P: %H: error: %s not a multiple of %u\n"),
14208 input_bfd, input_section, rel->r_offset,
14209 ppc64_elf_howto_table[r_type]->name,
14210 mask + 1);
14211 bfd_set_error (bfd_error_bad_value);
14212 ret = FALSE;
14213 continue;
14214 }
14215 break;
14216 }
14217
14218 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
14219 because such sections are not SEC_ALLOC and thus ld.so will
14220 not process them. */
14221 if (unresolved_reloc
14222 && !((input_section->flags & SEC_DEBUGGING) != 0
14223 && h->elf.def_dynamic)
14224 && _bfd_elf_section_offset (output_bfd, info, input_section,
14225 rel->r_offset) != (bfd_vma) -1)
14226 {
14227 info->callbacks->einfo
14228 (_("%P: %H: unresolvable %s against `%T'\n"),
14229 input_bfd, input_section, rel->r_offset,
14230 ppc64_elf_howto_table[(int) r_type]->name,
14231 h->elf.root.root.string);
14232 ret = FALSE;
14233 }
14234
14235 r = _bfd_final_link_relocate (ppc64_elf_howto_table[(int) r_type],
14236 input_bfd,
14237 input_section,
14238 contents,
14239 rel->r_offset,
14240 relocation,
14241 addend);
14242
14243 if (r != bfd_reloc_ok)
14244 {
14245 char *more_info = NULL;
14246 const char *reloc_name = ppc64_elf_howto_table[r_type]->name;
14247
14248 if (reloc_dest != DEST_NORMAL)
14249 {
14250 more_info = bfd_malloc (strlen (reloc_name) + 8);
14251 if (more_info != NULL)
14252 {
14253 strcpy (more_info, reloc_name);
14254 strcat (more_info, (reloc_dest == DEST_OPD
14255 ? " (OPD)" : " (stub)"));
14256 reloc_name = more_info;
14257 }
14258 }
14259
14260 if (r == bfd_reloc_overflow)
14261 {
14262 if (warned)
14263 continue;
14264 if (h != NULL
14265 && h->elf.root.type == bfd_link_hash_undefweak
14266 && ppc64_elf_howto_table[r_type]->pc_relative)
14267 {
14268 /* Assume this is a call protected by other code that
14269 detects the symbol is undefined. If this is the case,
14270 we can safely ignore the overflow. If not, the
14271 program is hosed anyway, and a little warning isn't
14272 going to help. */
14273
14274 continue;
14275 }
14276
14277 if (!((*info->callbacks->reloc_overflow)
14278 (info, &h->elf.root, sym_name,
14279 reloc_name, orig_rel.r_addend,
14280 input_bfd, input_section, rel->r_offset)))
14281 return FALSE;
14282 }
14283 else
14284 {
14285 info->callbacks->einfo
14286 (_("%P: %H: %s against `%T': error %d\n"),
14287 input_bfd, input_section, rel->r_offset,
14288 reloc_name, sym_name, (int) r);
14289 ret = FALSE;
14290 }
14291 if (more_info != NULL)
14292 free (more_info);
14293 }
14294 }
14295
14296 /* If we're emitting relocations, then shortly after this function
14297 returns, reloc offsets and addends for this section will be
14298 adjusted. Worse, reloc symbol indices will be for the output
14299 file rather than the input. Save a copy of the relocs for
14300 opd_entry_value. */
14301 if (is_opd && (info->emitrelocations || info->relocatable))
14302 {
14303 bfd_size_type amt;
14304 amt = input_section->reloc_count * sizeof (Elf_Internal_Rela);
14305 rel = bfd_alloc (input_bfd, amt);
14306 BFD_ASSERT (ppc64_elf_tdata (input_bfd)->opd.relocs == NULL);
14307 ppc64_elf_tdata (input_bfd)->opd.relocs = rel;
14308 if (rel == NULL)
14309 return FALSE;
14310 memcpy (rel, relocs, amt);
14311 }
14312 return ret;
14313 }
14314
14315 /* Adjust the value of any local symbols in opd sections. */
14316
14317 static int
14318 ppc64_elf_output_symbol_hook (struct bfd_link_info *info,
14319 const char *name ATTRIBUTE_UNUSED,
14320 Elf_Internal_Sym *elfsym,
14321 asection *input_sec,
14322 struct elf_link_hash_entry *h)
14323 {
14324 struct _opd_sec_data *opd;
14325 long adjust;
14326 bfd_vma value;
14327
14328 if (h != NULL)
14329 return 1;
14330
14331 opd = get_opd_info (input_sec);
14332 if (opd == NULL || opd->adjust == NULL)
14333 return 1;
14334
14335 value = elfsym->st_value - input_sec->output_offset;
14336 if (!info->relocatable)
14337 value -= input_sec->output_section->vma;
14338
14339 adjust = opd->adjust[value / 8];
14340 if (adjust == -1)
14341 return 2;
14342
14343 elfsym->st_value += adjust;
14344 return 1;
14345 }
14346
14347 /* Finish up dynamic symbol handling. We set the contents of various
14348 dynamic sections here. */
14349
14350 static bfd_boolean
14351 ppc64_elf_finish_dynamic_symbol (bfd *output_bfd,
14352 struct bfd_link_info *info,
14353 struct elf_link_hash_entry *h,
14354 Elf_Internal_Sym *sym ATTRIBUTE_UNUSED)
14355 {
14356 struct ppc_link_hash_table *htab;
14357 struct plt_entry *ent;
14358 Elf_Internal_Rela rela;
14359 bfd_byte *loc;
14360
14361 htab = ppc_hash_table (info);
14362 if (htab == NULL)
14363 return FALSE;
14364
14365 for (ent = h->plt.plist; ent != NULL; ent = ent->next)
14366 if (ent->plt.offset != (bfd_vma) -1)
14367 {
14368 /* This symbol has an entry in the procedure linkage
14369 table. Set it up. */
14370 if (!htab->elf.dynamic_sections_created
14371 || h->dynindx == -1)
14372 {
14373 BFD_ASSERT (h->type == STT_GNU_IFUNC
14374 && h->def_regular
14375 && (h->root.type == bfd_link_hash_defined
14376 || h->root.type == bfd_link_hash_defweak));
14377 rela.r_offset = (htab->iplt->output_section->vma
14378 + htab->iplt->output_offset
14379 + ent->plt.offset);
14380 if (htab->opd_abi)
14381 rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
14382 else
14383 rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
14384 rela.r_addend = (h->root.u.def.value
14385 + h->root.u.def.section->output_offset
14386 + h->root.u.def.section->output_section->vma
14387 + ent->addend);
14388 loc = (htab->reliplt->contents
14389 + (htab->reliplt->reloc_count++
14390 * sizeof (Elf64_External_Rela)));
14391 }
14392 else
14393 {
14394 rela.r_offset = (htab->plt->output_section->vma
14395 + htab->plt->output_offset
14396 + ent->plt.offset);
14397 rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_JMP_SLOT);
14398 rela.r_addend = ent->addend;
14399 loc = (htab->relplt->contents
14400 + ((ent->plt.offset - PLT_INITIAL_ENTRY_SIZE)
14401 / (PLT_ENTRY_SIZE / sizeof (Elf64_External_Rela))));
14402 }
14403 bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
14404 }
14405
14406 if (h->needs_copy)
14407 {
14408 /* This symbol needs a copy reloc. Set it up. */
14409
14410 if (h->dynindx == -1
14411 || (h->root.type != bfd_link_hash_defined
14412 && h->root.type != bfd_link_hash_defweak)
14413 || htab->relbss == NULL)
14414 abort ();
14415
14416 rela.r_offset = (h->root.u.def.value
14417 + h->root.u.def.section->output_section->vma
14418 + h->root.u.def.section->output_offset);
14419 rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_COPY);
14420 rela.r_addend = 0;
14421 loc = htab->relbss->contents;
14422 loc += htab->relbss->reloc_count++ * sizeof (Elf64_External_Rela);
14423 bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
14424 }
14425
14426 return TRUE;
14427 }
14428
14429 /* Used to decide how to sort relocs in an optimal manner for the
14430 dynamic linker, before writing them out. */
14431
14432 static enum elf_reloc_type_class
14433 ppc64_elf_reloc_type_class (const struct bfd_link_info *info,
14434 const asection *rel_sec,
14435 const Elf_Internal_Rela *rela)
14436 {
14437 enum elf_ppc64_reloc_type r_type;
14438 struct ppc_link_hash_table *htab = ppc_hash_table (info);
14439
14440 if (rel_sec == htab->reliplt)
14441 return reloc_class_ifunc;
14442
14443 r_type = ELF64_R_TYPE (rela->r_info);
14444 switch (r_type)
14445 {
14446 case R_PPC64_RELATIVE:
14447 return reloc_class_relative;
14448 case R_PPC64_JMP_SLOT:
14449 return reloc_class_plt;
14450 case R_PPC64_COPY:
14451 return reloc_class_copy;
14452 default:
14453 return reloc_class_normal;
14454 }
14455 }
14456
14457 /* Finish up the dynamic sections. */
14458
14459 static bfd_boolean
14460 ppc64_elf_finish_dynamic_sections (bfd *output_bfd,
14461 struct bfd_link_info *info)
14462 {
14463 struct ppc_link_hash_table *htab;
14464 bfd *dynobj;
14465 asection *sdyn;
14466
14467 htab = ppc_hash_table (info);
14468 if (htab == NULL)
14469 return FALSE;
14470
14471 dynobj = htab->elf.dynobj;
14472 sdyn = bfd_get_linker_section (dynobj, ".dynamic");
14473
14474 if (htab->elf.dynamic_sections_created)
14475 {
14476 Elf64_External_Dyn *dyncon, *dynconend;
14477
14478 if (sdyn == NULL || htab->got == NULL)
14479 abort ();
14480
14481 dyncon = (Elf64_External_Dyn *) sdyn->contents;
14482 dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
14483 for (; dyncon < dynconend; dyncon++)
14484 {
14485 Elf_Internal_Dyn dyn;
14486 asection *s;
14487
14488 bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
14489
14490 switch (dyn.d_tag)
14491 {
14492 default:
14493 continue;
14494
14495 case DT_PPC64_GLINK:
14496 s = htab->glink;
14497 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
14498 /* We stupidly defined DT_PPC64_GLINK to be the start
14499 of glink rather than the first entry point, which is
14500 what ld.so needs, and now have a bigger stub to
14501 support automatic multiple TOCs. */
14502 dyn.d_un.d_ptr += GLINK_CALL_STUB_SIZE - 32;
14503 break;
14504
14505 case DT_PPC64_OPD:
14506 s = bfd_get_section_by_name (output_bfd, ".opd");
14507 if (s == NULL)
14508 continue;
14509 dyn.d_un.d_ptr = s->vma;
14510 break;
14511
14512 case DT_PPC64_OPDSZ:
14513 s = bfd_get_section_by_name (output_bfd, ".opd");
14514 if (s == NULL)
14515 continue;
14516 dyn.d_un.d_val = s->size;
14517 break;
14518
14519 case DT_PLTGOT:
14520 s = htab->plt;
14521 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
14522 break;
14523
14524 case DT_JMPREL:
14525 s = htab->relplt;
14526 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
14527 break;
14528
14529 case DT_PLTRELSZ:
14530 dyn.d_un.d_val = htab->relplt->size;
14531 break;
14532
14533 case DT_RELASZ:
14534 /* Don't count procedure linkage table relocs in the
14535 overall reloc count. */
14536 s = htab->relplt;
14537 if (s == NULL)
14538 continue;
14539 dyn.d_un.d_val -= s->size;
14540 break;
14541
14542 case DT_RELA:
14543 /* We may not be using the standard ELF linker script.
14544 If .rela.plt is the first .rela section, we adjust
14545 DT_RELA to not include it. */
14546 s = htab->relplt;
14547 if (s == NULL)
14548 continue;
14549 if (dyn.d_un.d_ptr != s->output_section->vma + s->output_offset)
14550 continue;
14551 dyn.d_un.d_ptr += s->size;
14552 break;
14553 }
14554
14555 bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
14556 }
14557 }
14558
14559 if (htab->got != NULL && htab->got->size != 0)
14560 {
14561 /* Fill in the first entry in the global offset table.
14562 We use it to hold the link-time TOCbase. */
14563 bfd_put_64 (output_bfd,
14564 elf_gp (output_bfd) + TOC_BASE_OFF,
14565 htab->got->contents);
14566
14567 /* Set .got entry size. */
14568 elf_section_data (htab->got->output_section)->this_hdr.sh_entsize = 8;
14569 }
14570
14571 if (htab->plt != NULL && htab->plt->size != 0)
14572 {
14573 /* Set .plt entry size. */
14574 elf_section_data (htab->plt->output_section)->this_hdr.sh_entsize
14575 = PLT_ENTRY_SIZE;
14576 }
14577
14578 /* brlt is SEC_LINKER_CREATED, so we need to write out relocs for
14579 brlt ourselves if emitrelocations. */
14580 if (htab->brlt != NULL
14581 && htab->brlt->reloc_count != 0
14582 && !_bfd_elf_link_output_relocs (output_bfd,
14583 htab->brlt,
14584 elf_section_data (htab->brlt)->rela.hdr,
14585 elf_section_data (htab->brlt)->relocs,
14586 NULL))
14587 return FALSE;
14588
14589 if (htab->glink != NULL
14590 && htab->glink->reloc_count != 0
14591 && !_bfd_elf_link_output_relocs (output_bfd,
14592 htab->glink,
14593 elf_section_data (htab->glink)->rela.hdr,
14594 elf_section_data (htab->glink)->relocs,
14595 NULL))
14596 return FALSE;
14597
14598
14599 if (htab->glink_eh_frame != NULL
14600 && htab->glink_eh_frame->sec_info_type == SEC_INFO_TYPE_EH_FRAME
14601 && !_bfd_elf_write_section_eh_frame (output_bfd, info,
14602 htab->glink_eh_frame,
14603 htab->glink_eh_frame->contents))
14604 return FALSE;
14605
14606 /* We need to handle writing out multiple GOT sections ourselves,
14607 since we didn't add them to DYNOBJ. We know dynobj is the first
14608 bfd. */
14609 while ((dynobj = dynobj->link_next) != NULL)
14610 {
14611 asection *s;
14612
14613 if (!is_ppc64_elf (dynobj))
14614 continue;
14615
14616 s = ppc64_elf_tdata (dynobj)->got;
14617 if (s != NULL
14618 && s->size != 0
14619 && s->output_section != bfd_abs_section_ptr
14620 && !bfd_set_section_contents (output_bfd, s->output_section,
14621 s->contents, s->output_offset,
14622 s->size))
14623 return FALSE;
14624 s = ppc64_elf_tdata (dynobj)->relgot;
14625 if (s != NULL
14626 && s->size != 0
14627 && s->output_section != bfd_abs_section_ptr
14628 && !bfd_set_section_contents (output_bfd, s->output_section,
14629 s->contents, s->output_offset,
14630 s->size))
14631 return FALSE;
14632 }
14633
14634 return TRUE;
14635 }
14636
14637 #include "elf64-target.h"
14638
14639 /* FreeBSD support */
14640
14641 #undef TARGET_LITTLE_SYM
14642 #undef TARGET_LITTLE_NAME
14643
14644 #undef TARGET_BIG_SYM
14645 #define TARGET_BIG_SYM bfd_elf64_powerpc_freebsd_vec
14646 #undef TARGET_BIG_NAME
14647 #define TARGET_BIG_NAME "elf64-powerpc-freebsd"
14648
14649 #undef ELF_OSABI
14650 #define ELF_OSABI ELFOSABI_FREEBSD
14651
14652 #undef elf64_bed
14653 #define elf64_bed elf64_powerpc_fbsd_bed
14654
14655 #include "elf64-target.h"
14656
GDB Binutils - Deliverables
This page took 0.366272 seconds and 4 git commands to generate.