projects / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
STT_GNU_IFUNC support for PowerPC.
[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 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 <amodra@bigpond.net.au>
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
38 static bfd_reloc_status_type ppc64_elf_ha_reloc
39 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
40 static bfd_reloc_status_type ppc64_elf_branch_reloc
41 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
42 static bfd_reloc_status_type ppc64_elf_brtaken_reloc
43 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
44 static bfd_reloc_status_type ppc64_elf_sectoff_reloc
45 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
46 static bfd_reloc_status_type ppc64_elf_sectoff_ha_reloc
47 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
48 static bfd_reloc_status_type ppc64_elf_toc_reloc
49 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
50 static bfd_reloc_status_type ppc64_elf_toc_ha_reloc
51 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
52 static bfd_reloc_status_type ppc64_elf_toc64_reloc
53 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
54 static bfd_reloc_status_type ppc64_elf_unhandled_reloc
55 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
56 static bfd_vma opd_entry_value
57 (asection *, bfd_vma, asection **, bfd_vma *);
58
59 #define TARGET_LITTLE_SYM bfd_elf64_powerpcle_vec
60 #define TARGET_LITTLE_NAME "elf64-powerpcle"
61 #define TARGET_BIG_SYM bfd_elf64_powerpc_vec
62 #define TARGET_BIG_NAME "elf64-powerpc"
63 #define ELF_ARCH bfd_arch_powerpc
64 #define ELF_MACHINE_CODE EM_PPC64
65 #define ELF_MAXPAGESIZE 0x10000
66 #define ELF_COMMONPAGESIZE 0x1000
67 #define elf_info_to_howto ppc64_elf_info_to_howto
68
69 #define elf_backend_want_got_sym 0
70 #define elf_backend_want_plt_sym 0
71 #define elf_backend_plt_alignment 3
72 #define elf_backend_plt_not_loaded 1
73 #define elf_backend_got_header_size 8
74 #define elf_backend_can_gc_sections 1
75 #define elf_backend_can_refcount 1
76 #define elf_backend_rela_normal 1
77 #define elf_backend_default_execstack 0
78
79 #define bfd_elf64_mkobject ppc64_elf_mkobject
80 #define bfd_elf64_bfd_reloc_type_lookup ppc64_elf_reloc_type_lookup
81 #define bfd_elf64_bfd_reloc_name_lookup ppc64_elf_reloc_name_lookup
82 #define bfd_elf64_bfd_merge_private_bfd_data ppc64_elf_merge_private_bfd_data
83 #define bfd_elf64_new_section_hook ppc64_elf_new_section_hook
84 #define bfd_elf64_bfd_link_hash_table_create ppc64_elf_link_hash_table_create
85 #define bfd_elf64_bfd_link_hash_table_free ppc64_elf_link_hash_table_free
86 #define bfd_elf64_get_synthetic_symtab ppc64_elf_get_synthetic_symtab
87
88 #define elf_backend_object_p ppc64_elf_object_p
89 #define elf_backend_grok_prstatus ppc64_elf_grok_prstatus
90 #define elf_backend_grok_psinfo ppc64_elf_grok_psinfo
91 #define elf_backend_write_core_note ppc64_elf_write_core_note
92 #define elf_backend_create_dynamic_sections ppc64_elf_create_dynamic_sections
93 #define elf_backend_copy_indirect_symbol ppc64_elf_copy_indirect_symbol
94 #define elf_backend_add_symbol_hook ppc64_elf_add_symbol_hook
95 #define elf_backend_check_directives ppc64_elf_process_dot_syms
96 #define elf_backend_as_needed_cleanup ppc64_elf_as_needed_cleanup
97 #define elf_backend_archive_symbol_lookup ppc64_elf_archive_symbol_lookup
98 #define elf_backend_check_relocs ppc64_elf_check_relocs
99 #define elf_backend_gc_keep ppc64_elf_gc_keep
100 #define elf_backend_gc_mark_dynamic_ref ppc64_elf_gc_mark_dynamic_ref
101 #define elf_backend_gc_mark_hook ppc64_elf_gc_mark_hook
102 #define elf_backend_gc_sweep_hook ppc64_elf_gc_sweep_hook
103 #define elf_backend_adjust_dynamic_symbol ppc64_elf_adjust_dynamic_symbol
104 #define elf_backend_hide_symbol ppc64_elf_hide_symbol
105 #define elf_backend_always_size_sections ppc64_elf_func_desc_adjust
106 #define elf_backend_size_dynamic_sections ppc64_elf_size_dynamic_sections
107 #define elf_backend_init_index_section _bfd_elf_init_2_index_sections
108 #define elf_backend_action_discarded ppc64_elf_action_discarded
109 #define elf_backend_relocate_section ppc64_elf_relocate_section
110 #define elf_backend_finish_dynamic_symbol ppc64_elf_finish_dynamic_symbol
111 #define elf_backend_reloc_type_class ppc64_elf_reloc_type_class
112 #define elf_backend_finish_dynamic_sections ppc64_elf_finish_dynamic_sections
113 #define elf_backend_link_output_symbol_hook ppc64_elf_output_symbol_hook
114 #define elf_backend_special_sections ppc64_elf_special_sections
115 #define elf_backend_post_process_headers _bfd_elf_set_osabi
116
117 /* The name of the dynamic interpreter. This is put in the .interp
118 section. */
119 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
120
121 /* The size in bytes of an entry in the procedure linkage table. */
122 #define PLT_ENTRY_SIZE 24
123
124 /* The initial size of the plt reserved for the dynamic linker. */
125 #define PLT_INITIAL_ENTRY_SIZE PLT_ENTRY_SIZE
126
127 /* TOC base pointers offset from start of TOC. */
128 #define TOC_BASE_OFF 0x8000
129
130 /* Offset of tp and dtp pointers from start of TLS block. */
131 #define TP_OFFSET 0x7000
132 #define DTP_OFFSET 0x8000
133
134 /* .plt call stub instructions. The normal stub is like this, but
135 sometimes the .plt entry crosses a 64k boundary and we need to
136 insert an addi to adjust r12. */
137 #define PLT_CALL_STUB_SIZE (7*4)
138 #define ADDIS_R12_R2 0x3d820000 /* addis %r12,%r2,xxx@ha */
139 #define STD_R2_40R1 0xf8410028 /* std %r2,40(%r1) */
140 #define LD_R11_0R12 0xe96c0000 /* ld %r11,xxx+0@l(%r12) */
141 #define MTCTR_R11 0x7d6903a6 /* mtctr %r11 */
142 #define LD_R2_0R12 0xe84c0000 /* ld %r2,xxx+8@l(%r12) */
143 /* ld %r11,xxx+16@l(%r12) */
144 #define BCTR 0x4e800420 /* bctr */
145
146
147 #define ADDIS_R12_R12 0x3d8c0000 /* addis %r12,%r12,off@ha */
148 #define ADDI_R12_R12 0x398c0000 /* addi %r12,%r12,off@l */
149 #define ADDIS_R2_R2 0x3c420000 /* addis %r2,%r2,off@ha */
150 #define ADDI_R2_R2 0x38420000 /* addi %r2,%r2,off@l */
151
152 #define LD_R11_0R2 0xe9620000 /* ld %r11,xxx+0(%r2) */
153 #define LD_R2_0R2 0xe8420000 /* ld %r2,xxx+0(%r2) */
154
155 #define LD_R2_40R1 0xe8410028 /* ld %r2,40(%r1) */
156
157 /* glink call stub instructions. We enter with the index in R0. */
158 #define GLINK_CALL_STUB_SIZE (16*4)
159 /* 0: */
160 /* .quad plt0-1f */
161 /* __glink: */
162 #define MFLR_R12 0x7d8802a6 /* mflr %12 */
163 #define BCL_20_31 0x429f0005 /* bcl 20,31,1f */
164 /* 1: */
165 #define MFLR_R11 0x7d6802a6 /* mflr %11 */
166 #define LD_R2_M16R11 0xe84bfff0 /* ld %2,(0b-1b)(%11) */
167 #define MTLR_R12 0x7d8803a6 /* mtlr %12 */
168 #define ADD_R12_R2_R11 0x7d825a14 /* add %12,%2,%11 */
169 /* ld %11,0(%12) */
170 /* ld %2,8(%12) */
171 /* mtctr %11 */
172 /* ld %11,16(%12) */
173 /* bctr */
174
175 /* Pad with this. */
176 #define NOP 0x60000000
177
178 /* Some other nops. */
179 #define CROR_151515 0x4def7b82
180 #define CROR_313131 0x4ffffb82
181
182 /* .glink entries for the first 32k functions are two instructions. */
183 #define LI_R0_0 0x38000000 /* li %r0,0 */
184 #define B_DOT 0x48000000 /* b . */
185
186 /* After that, we need two instructions to load the index, followed by
187 a branch. */
188 #define LIS_R0_0 0x3c000000 /* lis %r0,0 */
189 #define ORI_R0_R0_0 0x60000000 /* ori %r0,%r0,0 */
190
191 /* Instructions used by the save and restore reg functions. */
192 #define STD_R0_0R1 0xf8010000 /* std %r0,0(%r1) */
193 #define STD_R0_0R12 0xf80c0000 /* std %r0,0(%r12) */
194 #define LD_R0_0R1 0xe8010000 /* ld %r0,0(%r1) */
195 #define LD_R0_0R12 0xe80c0000 /* ld %r0,0(%r12) */
196 #define STFD_FR0_0R1 0xd8010000 /* stfd %fr0,0(%r1) */
197 #define LFD_FR0_0R1 0xc8010000 /* lfd %fr0,0(%r1) */
198 #define LI_R12_0 0x39800000 /* li %r12,0 */
199 #define STVX_VR0_R12_R0 0x7c0c01ce /* stvx %v0,%r12,%r0 */
200 #define LVX_VR0_R12_R0 0x7c0c00ce /* lvx %v0,%r12,%r0 */
201 #define MTLR_R0 0x7c0803a6 /* mtlr %r0 */
202 #define BLR 0x4e800020 /* blr */
203
204 /* Since .opd is an array of descriptors and each entry will end up
205 with identical R_PPC64_RELATIVE relocs, there is really no need to
206 propagate .opd relocs; The dynamic linker should be taught to
207 relocate .opd without reloc entries. */
208 #ifndef NO_OPD_RELOCS
209 #define NO_OPD_RELOCS 0
210 #endif
211 \f
212 #define ONES(n) (((bfd_vma) 1 << ((n) - 1) << 1) - 1)
213
214 /* Relocation HOWTO's. */
215 static reloc_howto_type *ppc64_elf_howto_table[(int) R_PPC64_max];
216
217 static reloc_howto_type ppc64_elf_howto_raw[] = {
218 /* This reloc does nothing. */
219 HOWTO (R_PPC64_NONE, /* type */
220 0, /* rightshift */
221 2, /* size (0 = byte, 1 = short, 2 = long) */
222 32, /* bitsize */
223 FALSE, /* pc_relative */
224 0, /* bitpos */
225 complain_overflow_dont, /* complain_on_overflow */
226 bfd_elf_generic_reloc, /* special_function */
227 "R_PPC64_NONE", /* name */
228 FALSE, /* partial_inplace */
229 0, /* src_mask */
230 0, /* dst_mask */
231 FALSE), /* pcrel_offset */
232
233 /* A standard 32 bit relocation. */
234 HOWTO (R_PPC64_ADDR32, /* type */
235 0, /* rightshift */
236 2, /* size (0 = byte, 1 = short, 2 = long) */
237 32, /* bitsize */
238 FALSE, /* pc_relative */
239 0, /* bitpos */
240 complain_overflow_bitfield, /* complain_on_overflow */
241 bfd_elf_generic_reloc, /* special_function */
242 "R_PPC64_ADDR32", /* name */
243 FALSE, /* partial_inplace */
244 0, /* src_mask */
245 0xffffffff, /* dst_mask */
246 FALSE), /* pcrel_offset */
247
248 /* An absolute 26 bit branch; the lower two bits must be zero.
249 FIXME: we don't check that, we just clear them. */
250 HOWTO (R_PPC64_ADDR24, /* type */
251 0, /* rightshift */
252 2, /* size (0 = byte, 1 = short, 2 = long) */
253 26, /* bitsize */
254 FALSE, /* pc_relative */
255 0, /* bitpos */
256 complain_overflow_bitfield, /* complain_on_overflow */
257 bfd_elf_generic_reloc, /* special_function */
258 "R_PPC64_ADDR24", /* name */
259 FALSE, /* partial_inplace */
260 0, /* src_mask */
261 0x03fffffc, /* dst_mask */
262 FALSE), /* pcrel_offset */
263
264 /* A standard 16 bit relocation. */
265 HOWTO (R_PPC64_ADDR16, /* type */
266 0, /* rightshift */
267 1, /* size (0 = byte, 1 = short, 2 = long) */
268 16, /* bitsize */
269 FALSE, /* pc_relative */
270 0, /* bitpos */
271 complain_overflow_bitfield, /* complain_on_overflow */
272 bfd_elf_generic_reloc, /* special_function */
273 "R_PPC64_ADDR16", /* name */
274 FALSE, /* partial_inplace */
275 0, /* src_mask */
276 0xffff, /* dst_mask */
277 FALSE), /* pcrel_offset */
278
279 /* A 16 bit relocation without overflow. */
280 HOWTO (R_PPC64_ADDR16_LO, /* type */
281 0, /* rightshift */
282 1, /* size (0 = byte, 1 = short, 2 = long) */
283 16, /* bitsize */
284 FALSE, /* pc_relative */
285 0, /* bitpos */
286 complain_overflow_dont,/* complain_on_overflow */
287 bfd_elf_generic_reloc, /* special_function */
288 "R_PPC64_ADDR16_LO", /* name */
289 FALSE, /* partial_inplace */
290 0, /* src_mask */
291 0xffff, /* dst_mask */
292 FALSE), /* pcrel_offset */
293
294 /* Bits 16-31 of an address. */
295 HOWTO (R_PPC64_ADDR16_HI, /* type */
296 16, /* rightshift */
297 1, /* size (0 = byte, 1 = short, 2 = long) */
298 16, /* bitsize */
299 FALSE, /* pc_relative */
300 0, /* bitpos */
301 complain_overflow_dont, /* complain_on_overflow */
302 bfd_elf_generic_reloc, /* special_function */
303 "R_PPC64_ADDR16_HI", /* name */
304 FALSE, /* partial_inplace */
305 0, /* src_mask */
306 0xffff, /* dst_mask */
307 FALSE), /* pcrel_offset */
308
309 /* Bits 16-31 of an address, plus 1 if the contents of the low 16
310 bits, treated as a signed number, is negative. */
311 HOWTO (R_PPC64_ADDR16_HA, /* type */
312 16, /* rightshift */
313 1, /* size (0 = byte, 1 = short, 2 = long) */
314 16, /* bitsize */
315 FALSE, /* pc_relative */
316 0, /* bitpos */
317 complain_overflow_dont, /* complain_on_overflow */
318 ppc64_elf_ha_reloc, /* special_function */
319 "R_PPC64_ADDR16_HA", /* name */
320 FALSE, /* partial_inplace */
321 0, /* src_mask */
322 0xffff, /* dst_mask */
323 FALSE), /* pcrel_offset */
324
325 /* An absolute 16 bit branch; the lower two bits must be zero.
326 FIXME: we don't check that, we just clear them. */
327 HOWTO (R_PPC64_ADDR14, /* type */
328 0, /* rightshift */
329 2, /* size (0 = byte, 1 = short, 2 = long) */
330 16, /* bitsize */
331 FALSE, /* pc_relative */
332 0, /* bitpos */
333 complain_overflow_bitfield, /* complain_on_overflow */
334 ppc64_elf_branch_reloc, /* special_function */
335 "R_PPC64_ADDR14", /* name */
336 FALSE, /* partial_inplace */
337 0, /* src_mask */
338 0x0000fffc, /* dst_mask */
339 FALSE), /* pcrel_offset */
340
341 /* An absolute 16 bit branch, for which bit 10 should be set to
342 indicate that the branch is expected to be taken. The lower two
343 bits must be zero. */
344 HOWTO (R_PPC64_ADDR14_BRTAKEN, /* type */
345 0, /* rightshift */
346 2, /* size (0 = byte, 1 = short, 2 = long) */
347 16, /* bitsize */
348 FALSE, /* pc_relative */
349 0, /* bitpos */
350 complain_overflow_bitfield, /* complain_on_overflow */
351 ppc64_elf_brtaken_reloc, /* special_function */
352 "R_PPC64_ADDR14_BRTAKEN",/* name */
353 FALSE, /* partial_inplace */
354 0, /* src_mask */
355 0x0000fffc, /* dst_mask */
356 FALSE), /* pcrel_offset */
357
358 /* An absolute 16 bit branch, for which bit 10 should be set to
359 indicate that the branch is not expected to be taken. The lower
360 two bits must be zero. */
361 HOWTO (R_PPC64_ADDR14_BRNTAKEN, /* type */
362 0, /* rightshift */
363 2, /* size (0 = byte, 1 = short, 2 = long) */
364 16, /* bitsize */
365 FALSE, /* pc_relative */
366 0, /* bitpos */
367 complain_overflow_bitfield, /* complain_on_overflow */
368 ppc64_elf_brtaken_reloc, /* special_function */
369 "R_PPC64_ADDR14_BRNTAKEN",/* name */
370 FALSE, /* partial_inplace */
371 0, /* src_mask */
372 0x0000fffc, /* dst_mask */
373 FALSE), /* pcrel_offset */
374
375 /* A relative 26 bit branch; the lower two bits must be zero. */
376 HOWTO (R_PPC64_REL24, /* type */
377 0, /* rightshift */
378 2, /* size (0 = byte, 1 = short, 2 = long) */
379 26, /* bitsize */
380 TRUE, /* pc_relative */
381 0, /* bitpos */
382 complain_overflow_signed, /* complain_on_overflow */
383 ppc64_elf_branch_reloc, /* special_function */
384 "R_PPC64_REL24", /* name */
385 FALSE, /* partial_inplace */
386 0, /* src_mask */
387 0x03fffffc, /* dst_mask */
388 TRUE), /* pcrel_offset */
389
390 /* A relative 16 bit branch; the lower two bits must be zero. */
391 HOWTO (R_PPC64_REL14, /* type */
392 0, /* rightshift */
393 2, /* size (0 = byte, 1 = short, 2 = long) */
394 16, /* bitsize */
395 TRUE, /* pc_relative */
396 0, /* bitpos */
397 complain_overflow_signed, /* complain_on_overflow */
398 ppc64_elf_branch_reloc, /* special_function */
399 "R_PPC64_REL14", /* name */
400 FALSE, /* partial_inplace */
401 0, /* src_mask */
402 0x0000fffc, /* dst_mask */
403 TRUE), /* pcrel_offset */
404
405 /* A relative 16 bit branch. Bit 10 should be set to indicate that
406 the branch is expected to be taken. The lower two bits must be
407 zero. */
408 HOWTO (R_PPC64_REL14_BRTAKEN, /* type */
409 0, /* rightshift */
410 2, /* size (0 = byte, 1 = short, 2 = long) */
411 16, /* bitsize */
412 TRUE, /* pc_relative */
413 0, /* bitpos */
414 complain_overflow_signed, /* complain_on_overflow */
415 ppc64_elf_brtaken_reloc, /* special_function */
416 "R_PPC64_REL14_BRTAKEN", /* name */
417 FALSE, /* partial_inplace */
418 0, /* src_mask */
419 0x0000fffc, /* dst_mask */
420 TRUE), /* pcrel_offset */
421
422 /* A relative 16 bit branch. Bit 10 should be set to indicate that
423 the branch is not expected to be taken. The lower two bits must
424 be zero. */
425 HOWTO (R_PPC64_REL14_BRNTAKEN, /* type */
426 0, /* rightshift */
427 2, /* size (0 = byte, 1 = short, 2 = long) */
428 16, /* bitsize */
429 TRUE, /* pc_relative */
430 0, /* bitpos */
431 complain_overflow_signed, /* complain_on_overflow */
432 ppc64_elf_brtaken_reloc, /* special_function */
433 "R_PPC64_REL14_BRNTAKEN",/* name */
434 FALSE, /* partial_inplace */
435 0, /* src_mask */
436 0x0000fffc, /* dst_mask */
437 TRUE), /* pcrel_offset */
438
439 /* Like R_PPC64_ADDR16, but referring to the GOT table entry for the
440 symbol. */
441 HOWTO (R_PPC64_GOT16, /* type */
442 0, /* rightshift */
443 1, /* size (0 = byte, 1 = short, 2 = long) */
444 16, /* bitsize */
445 FALSE, /* pc_relative */
446 0, /* bitpos */
447 complain_overflow_signed, /* complain_on_overflow */
448 ppc64_elf_unhandled_reloc, /* special_function */
449 "R_PPC64_GOT16", /* name */
450 FALSE, /* partial_inplace */
451 0, /* src_mask */
452 0xffff, /* dst_mask */
453 FALSE), /* pcrel_offset */
454
455 /* Like R_PPC64_ADDR16_LO, but referring to the GOT table entry for
456 the symbol. */
457 HOWTO (R_PPC64_GOT16_LO, /* type */
458 0, /* rightshift */
459 1, /* size (0 = byte, 1 = short, 2 = long) */
460 16, /* bitsize */
461 FALSE, /* pc_relative */
462 0, /* bitpos */
463 complain_overflow_dont, /* complain_on_overflow */
464 ppc64_elf_unhandled_reloc, /* special_function */
465 "R_PPC64_GOT16_LO", /* name */
466 FALSE, /* partial_inplace */
467 0, /* src_mask */
468 0xffff, /* dst_mask */
469 FALSE), /* pcrel_offset */
470
471 /* Like R_PPC64_ADDR16_HI, but referring to the GOT table entry for
472 the symbol. */
473 HOWTO (R_PPC64_GOT16_HI, /* type */
474 16, /* rightshift */
475 1, /* size (0 = byte, 1 = short, 2 = long) */
476 16, /* bitsize */
477 FALSE, /* pc_relative */
478 0, /* bitpos */
479 complain_overflow_dont,/* complain_on_overflow */
480 ppc64_elf_unhandled_reloc, /* special_function */
481 "R_PPC64_GOT16_HI", /* name */
482 FALSE, /* partial_inplace */
483 0, /* src_mask */
484 0xffff, /* dst_mask */
485 FALSE), /* pcrel_offset */
486
487 /* Like R_PPC64_ADDR16_HA, but referring to the GOT table entry for
488 the symbol. */
489 HOWTO (R_PPC64_GOT16_HA, /* type */
490 16, /* rightshift */
491 1, /* size (0 = byte, 1 = short, 2 = long) */
492 16, /* bitsize */
493 FALSE, /* pc_relative */
494 0, /* bitpos */
495 complain_overflow_dont,/* complain_on_overflow */
496 ppc64_elf_unhandled_reloc, /* special_function */
497 "R_PPC64_GOT16_HA", /* name */
498 FALSE, /* partial_inplace */
499 0, /* src_mask */
500 0xffff, /* dst_mask */
501 FALSE), /* pcrel_offset */
502
503 /* This is used only by the dynamic linker. The symbol should exist
504 both in the object being run and in some shared library. The
505 dynamic linker copies the data addressed by the symbol from the
506 shared library into the object, because the object being
507 run has to have the data at some particular address. */
508 HOWTO (R_PPC64_COPY, /* type */
509 0, /* rightshift */
510 0, /* this one is variable size */
511 0, /* bitsize */
512 FALSE, /* pc_relative */
513 0, /* bitpos */
514 complain_overflow_dont, /* complain_on_overflow */
515 ppc64_elf_unhandled_reloc, /* special_function */
516 "R_PPC64_COPY", /* name */
517 FALSE, /* partial_inplace */
518 0, /* src_mask */
519 0, /* dst_mask */
520 FALSE), /* pcrel_offset */
521
522 /* Like R_PPC64_ADDR64, but used when setting global offset table
523 entries. */
524 HOWTO (R_PPC64_GLOB_DAT, /* type */
525 0, /* rightshift */
526 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
527 64, /* bitsize */
528 FALSE, /* pc_relative */
529 0, /* bitpos */
530 complain_overflow_dont, /* complain_on_overflow */
531 ppc64_elf_unhandled_reloc, /* special_function */
532 "R_PPC64_GLOB_DAT", /* name */
533 FALSE, /* partial_inplace */
534 0, /* src_mask */
535 ONES (64), /* dst_mask */
536 FALSE), /* pcrel_offset */
537
538 /* Created by the link editor. Marks a procedure linkage table
539 entry for a symbol. */
540 HOWTO (R_PPC64_JMP_SLOT, /* type */
541 0, /* rightshift */
542 0, /* size (0 = byte, 1 = short, 2 = long) */
543 0, /* bitsize */
544 FALSE, /* pc_relative */
545 0, /* bitpos */
546 complain_overflow_dont, /* complain_on_overflow */
547 ppc64_elf_unhandled_reloc, /* special_function */
548 "R_PPC64_JMP_SLOT", /* name */
549 FALSE, /* partial_inplace */
550 0, /* src_mask */
551 0, /* dst_mask */
552 FALSE), /* pcrel_offset */
553
554 /* Used only by the dynamic linker. When the object is run, this
555 doubleword64 is set to the load address of the object, plus the
556 addend. */
557 HOWTO (R_PPC64_RELATIVE, /* type */
558 0, /* rightshift */
559 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
560 64, /* bitsize */
561 FALSE, /* pc_relative */
562 0, /* bitpos */
563 complain_overflow_dont, /* complain_on_overflow */
564 bfd_elf_generic_reloc, /* special_function */
565 "R_PPC64_RELATIVE", /* name */
566 FALSE, /* partial_inplace */
567 0, /* src_mask */
568 ONES (64), /* dst_mask */
569 FALSE), /* pcrel_offset */
570
571 /* Like R_PPC64_ADDR32, but may be unaligned. */
572 HOWTO (R_PPC64_UADDR32, /* type */
573 0, /* rightshift */
574 2, /* size (0 = byte, 1 = short, 2 = long) */
575 32, /* bitsize */
576 FALSE, /* pc_relative */
577 0, /* bitpos */
578 complain_overflow_bitfield, /* complain_on_overflow */
579 bfd_elf_generic_reloc, /* special_function */
580 "R_PPC64_UADDR32", /* name */
581 FALSE, /* partial_inplace */
582 0, /* src_mask */
583 0xffffffff, /* dst_mask */
584 FALSE), /* pcrel_offset */
585
586 /* Like R_PPC64_ADDR16, but may be unaligned. */
587 HOWTO (R_PPC64_UADDR16, /* type */
588 0, /* rightshift */
589 1, /* size (0 = byte, 1 = short, 2 = long) */
590 16, /* bitsize */
591 FALSE, /* pc_relative */
592 0, /* bitpos */
593 complain_overflow_bitfield, /* complain_on_overflow */
594 bfd_elf_generic_reloc, /* special_function */
595 "R_PPC64_UADDR16", /* name */
596 FALSE, /* partial_inplace */
597 0, /* src_mask */
598 0xffff, /* dst_mask */
599 FALSE), /* pcrel_offset */
600
601 /* 32-bit PC relative. */
602 HOWTO (R_PPC64_REL32, /* type */
603 0, /* rightshift */
604 2, /* size (0 = byte, 1 = short, 2 = long) */
605 32, /* bitsize */
606 TRUE, /* pc_relative */
607 0, /* bitpos */
608 /* FIXME: Verify. Was complain_overflow_bitfield. */
609 complain_overflow_signed, /* complain_on_overflow */
610 bfd_elf_generic_reloc, /* special_function */
611 "R_PPC64_REL32", /* name */
612 FALSE, /* partial_inplace */
613 0, /* src_mask */
614 0xffffffff, /* dst_mask */
615 TRUE), /* pcrel_offset */
616
617 /* 32-bit relocation to the symbol's procedure linkage table. */
618 HOWTO (R_PPC64_PLT32, /* type */
619 0, /* rightshift */
620 2, /* size (0 = byte, 1 = short, 2 = long) */
621 32, /* bitsize */
622 FALSE, /* pc_relative */
623 0, /* bitpos */
624 complain_overflow_bitfield, /* complain_on_overflow */
625 ppc64_elf_unhandled_reloc, /* special_function */
626 "R_PPC64_PLT32", /* name */
627 FALSE, /* partial_inplace */
628 0, /* src_mask */
629 0xffffffff, /* dst_mask */
630 FALSE), /* pcrel_offset */
631
632 /* 32-bit PC relative relocation to the symbol's procedure linkage table.
633 FIXME: R_PPC64_PLTREL32 not supported. */
634 HOWTO (R_PPC64_PLTREL32, /* type */
635 0, /* rightshift */
636 2, /* size (0 = byte, 1 = short, 2 = long) */
637 32, /* bitsize */
638 TRUE, /* pc_relative */
639 0, /* bitpos */
640 complain_overflow_signed, /* complain_on_overflow */
641 bfd_elf_generic_reloc, /* special_function */
642 "R_PPC64_PLTREL32", /* name */
643 FALSE, /* partial_inplace */
644 0, /* src_mask */
645 0xffffffff, /* dst_mask */
646 TRUE), /* pcrel_offset */
647
648 /* Like R_PPC64_ADDR16_LO, but referring to the PLT table entry for
649 the symbol. */
650 HOWTO (R_PPC64_PLT16_LO, /* type */
651 0, /* rightshift */
652 1, /* size (0 = byte, 1 = short, 2 = long) */
653 16, /* bitsize */
654 FALSE, /* pc_relative */
655 0, /* bitpos */
656 complain_overflow_dont, /* complain_on_overflow */
657 ppc64_elf_unhandled_reloc, /* special_function */
658 "R_PPC64_PLT16_LO", /* name */
659 FALSE, /* partial_inplace */
660 0, /* src_mask */
661 0xffff, /* dst_mask */
662 FALSE), /* pcrel_offset */
663
664 /* Like R_PPC64_ADDR16_HI, but referring to the PLT table entry for
665 the symbol. */
666 HOWTO (R_PPC64_PLT16_HI, /* type */
667 16, /* rightshift */
668 1, /* size (0 = byte, 1 = short, 2 = long) */
669 16, /* bitsize */
670 FALSE, /* pc_relative */
671 0, /* bitpos */
672 complain_overflow_dont, /* complain_on_overflow */
673 ppc64_elf_unhandled_reloc, /* special_function */
674 "R_PPC64_PLT16_HI", /* name */
675 FALSE, /* partial_inplace */
676 0, /* src_mask */
677 0xffff, /* dst_mask */
678 FALSE), /* pcrel_offset */
679
680 /* Like R_PPC64_ADDR16_HA, but referring to the PLT table entry for
681 the symbol. */
682 HOWTO (R_PPC64_PLT16_HA, /* type */
683 16, /* rightshift */
684 1, /* size (0 = byte, 1 = short, 2 = long) */
685 16, /* bitsize */
686 FALSE, /* pc_relative */
687 0, /* bitpos */
688 complain_overflow_dont, /* complain_on_overflow */
689 ppc64_elf_unhandled_reloc, /* special_function */
690 "R_PPC64_PLT16_HA", /* name */
691 FALSE, /* partial_inplace */
692 0, /* src_mask */
693 0xffff, /* dst_mask */
694 FALSE), /* pcrel_offset */
695
696 /* 16-bit section relative relocation. */
697 HOWTO (R_PPC64_SECTOFF, /* type */
698 0, /* rightshift */
699 1, /* size (0 = byte, 1 = short, 2 = long) */
700 16, /* bitsize */
701 FALSE, /* pc_relative */
702 0, /* bitpos */
703 complain_overflow_bitfield, /* complain_on_overflow */
704 ppc64_elf_sectoff_reloc, /* special_function */
705 "R_PPC64_SECTOFF", /* name */
706 FALSE, /* partial_inplace */
707 0, /* src_mask */
708 0xffff, /* dst_mask */
709 FALSE), /* pcrel_offset */
710
711 /* Like R_PPC64_SECTOFF, but no overflow warning. */
712 HOWTO (R_PPC64_SECTOFF_LO, /* type */
713 0, /* rightshift */
714 1, /* size (0 = byte, 1 = short, 2 = long) */
715 16, /* bitsize */
716 FALSE, /* pc_relative */
717 0, /* bitpos */
718 complain_overflow_dont, /* complain_on_overflow */
719 ppc64_elf_sectoff_reloc, /* special_function */
720 "R_PPC64_SECTOFF_LO", /* name */
721 FALSE, /* partial_inplace */
722 0, /* src_mask */
723 0xffff, /* dst_mask */
724 FALSE), /* pcrel_offset */
725
726 /* 16-bit upper half section relative relocation. */
727 HOWTO (R_PPC64_SECTOFF_HI, /* type */
728 16, /* rightshift */
729 1, /* size (0 = byte, 1 = short, 2 = long) */
730 16, /* bitsize */
731 FALSE, /* pc_relative */
732 0, /* bitpos */
733 complain_overflow_dont, /* complain_on_overflow */
734 ppc64_elf_sectoff_reloc, /* special_function */
735 "R_PPC64_SECTOFF_HI", /* name */
736 FALSE, /* partial_inplace */
737 0, /* src_mask */
738 0xffff, /* dst_mask */
739 FALSE), /* pcrel_offset */
740
741 /* 16-bit upper half adjusted section relative relocation. */
742 HOWTO (R_PPC64_SECTOFF_HA, /* type */
743 16, /* rightshift */
744 1, /* size (0 = byte, 1 = short, 2 = long) */
745 16, /* bitsize */
746 FALSE, /* pc_relative */
747 0, /* bitpos */
748 complain_overflow_dont, /* complain_on_overflow */
749 ppc64_elf_sectoff_ha_reloc, /* special_function */
750 "R_PPC64_SECTOFF_HA", /* name */
751 FALSE, /* partial_inplace */
752 0, /* src_mask */
753 0xffff, /* dst_mask */
754 FALSE), /* pcrel_offset */
755
756 /* Like R_PPC64_REL24 without touching the two least significant bits. */
757 HOWTO (R_PPC64_REL30, /* type */
758 2, /* rightshift */
759 2, /* size (0 = byte, 1 = short, 2 = long) */
760 30, /* bitsize */
761 TRUE, /* pc_relative */
762 0, /* bitpos */
763 complain_overflow_dont, /* complain_on_overflow */
764 bfd_elf_generic_reloc, /* special_function */
765 "R_PPC64_REL30", /* name */
766 FALSE, /* partial_inplace */
767 0, /* src_mask */
768 0xfffffffc, /* dst_mask */
769 TRUE), /* pcrel_offset */
770
771 /* Relocs in the 64-bit PowerPC ELF ABI, not in the 32-bit ABI. */
772
773 /* A standard 64-bit relocation. */
774 HOWTO (R_PPC64_ADDR64, /* type */
775 0, /* rightshift */
776 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
777 64, /* bitsize */
778 FALSE, /* pc_relative */
779 0, /* bitpos */
780 complain_overflow_dont, /* complain_on_overflow */
781 bfd_elf_generic_reloc, /* special_function */
782 "R_PPC64_ADDR64", /* name */
783 FALSE, /* partial_inplace */
784 0, /* src_mask */
785 ONES (64), /* dst_mask */
786 FALSE), /* pcrel_offset */
787
788 /* The bits 32-47 of an address. */
789 HOWTO (R_PPC64_ADDR16_HIGHER, /* type */
790 32, /* rightshift */
791 1, /* size (0 = byte, 1 = short, 2 = long) */
792 16, /* bitsize */
793 FALSE, /* pc_relative */
794 0, /* bitpos */
795 complain_overflow_dont, /* complain_on_overflow */
796 bfd_elf_generic_reloc, /* special_function */
797 "R_PPC64_ADDR16_HIGHER", /* name */
798 FALSE, /* partial_inplace */
799 0, /* src_mask */
800 0xffff, /* dst_mask */
801 FALSE), /* pcrel_offset */
802
803 /* The bits 32-47 of an address, plus 1 if the contents of the low
804 16 bits, treated as a signed number, is negative. */
805 HOWTO (R_PPC64_ADDR16_HIGHERA, /* type */
806 32, /* rightshift */
807 1, /* size (0 = byte, 1 = short, 2 = long) */
808 16, /* bitsize */
809 FALSE, /* pc_relative */
810 0, /* bitpos */
811 complain_overflow_dont, /* complain_on_overflow */
812 ppc64_elf_ha_reloc, /* special_function */
813 "R_PPC64_ADDR16_HIGHERA", /* name */
814 FALSE, /* partial_inplace */
815 0, /* src_mask */
816 0xffff, /* dst_mask */
817 FALSE), /* pcrel_offset */
818
819 /* The bits 48-63 of an address. */
820 HOWTO (R_PPC64_ADDR16_HIGHEST,/* type */
821 48, /* rightshift */
822 1, /* size (0 = byte, 1 = short, 2 = long) */
823 16, /* bitsize */
824 FALSE, /* pc_relative */
825 0, /* bitpos */
826 complain_overflow_dont, /* complain_on_overflow */
827 bfd_elf_generic_reloc, /* special_function */
828 "R_PPC64_ADDR16_HIGHEST", /* name */
829 FALSE, /* partial_inplace */
830 0, /* src_mask */
831 0xffff, /* dst_mask */
832 FALSE), /* pcrel_offset */
833
834 /* The bits 48-63 of an address, plus 1 if the contents of the low
835 16 bits, treated as a signed number, is negative. */
836 HOWTO (R_PPC64_ADDR16_HIGHESTA,/* type */
837 48, /* rightshift */
838 1, /* size (0 = byte, 1 = short, 2 = long) */
839 16, /* bitsize */
840 FALSE, /* pc_relative */
841 0, /* bitpos */
842 complain_overflow_dont, /* complain_on_overflow */
843 ppc64_elf_ha_reloc, /* special_function */
844 "R_PPC64_ADDR16_HIGHESTA", /* name */
845 FALSE, /* partial_inplace */
846 0, /* src_mask */
847 0xffff, /* dst_mask */
848 FALSE), /* pcrel_offset */
849
850 /* Like ADDR64, but may be unaligned. */
851 HOWTO (R_PPC64_UADDR64, /* type */
852 0, /* rightshift */
853 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
854 64, /* bitsize */
855 FALSE, /* pc_relative */
856 0, /* bitpos */
857 complain_overflow_dont, /* complain_on_overflow */
858 bfd_elf_generic_reloc, /* special_function */
859 "R_PPC64_UADDR64", /* name */
860 FALSE, /* partial_inplace */
861 0, /* src_mask */
862 ONES (64), /* dst_mask */
863 FALSE), /* pcrel_offset */
864
865 /* 64-bit relative relocation. */
866 HOWTO (R_PPC64_REL64, /* type */
867 0, /* rightshift */
868 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
869 64, /* bitsize */
870 TRUE, /* pc_relative */
871 0, /* bitpos */
872 complain_overflow_dont, /* complain_on_overflow */
873 bfd_elf_generic_reloc, /* special_function */
874 "R_PPC64_REL64", /* name */
875 FALSE, /* partial_inplace */
876 0, /* src_mask */
877 ONES (64), /* dst_mask */
878 TRUE), /* pcrel_offset */
879
880 /* 64-bit relocation to the symbol's procedure linkage table. */
881 HOWTO (R_PPC64_PLT64, /* type */
882 0, /* rightshift */
883 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
884 64, /* bitsize */
885 FALSE, /* pc_relative */
886 0, /* bitpos */
887 complain_overflow_dont, /* complain_on_overflow */
888 ppc64_elf_unhandled_reloc, /* special_function */
889 "R_PPC64_PLT64", /* name */
890 FALSE, /* partial_inplace */
891 0, /* src_mask */
892 ONES (64), /* dst_mask */
893 FALSE), /* pcrel_offset */
894
895 /* 64-bit PC relative relocation to the symbol's procedure linkage
896 table. */
897 /* FIXME: R_PPC64_PLTREL64 not supported. */
898 HOWTO (R_PPC64_PLTREL64, /* type */
899 0, /* rightshift */
900 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
901 64, /* bitsize */
902 TRUE, /* pc_relative */
903 0, /* bitpos */
904 complain_overflow_dont, /* complain_on_overflow */
905 ppc64_elf_unhandled_reloc, /* special_function */
906 "R_PPC64_PLTREL64", /* name */
907 FALSE, /* partial_inplace */
908 0, /* src_mask */
909 ONES (64), /* dst_mask */
910 TRUE), /* pcrel_offset */
911
912 /* 16 bit TOC-relative relocation. */
913
914 /* R_PPC64_TOC16 47 half16* S + A - .TOC. */
915 HOWTO (R_PPC64_TOC16, /* type */
916 0, /* rightshift */
917 1, /* size (0 = byte, 1 = short, 2 = long) */
918 16, /* bitsize */
919 FALSE, /* pc_relative */
920 0, /* bitpos */
921 complain_overflow_signed, /* complain_on_overflow */
922 ppc64_elf_toc_reloc, /* special_function */
923 "R_PPC64_TOC16", /* name */
924 FALSE, /* partial_inplace */
925 0, /* src_mask */
926 0xffff, /* dst_mask */
927 FALSE), /* pcrel_offset */
928
929 /* 16 bit TOC-relative relocation without overflow. */
930
931 /* R_PPC64_TOC16_LO 48 half16 #lo (S + A - .TOC.) */
932 HOWTO (R_PPC64_TOC16_LO, /* type */
933 0, /* rightshift */
934 1, /* size (0 = byte, 1 = short, 2 = long) */
935 16, /* bitsize */
936 FALSE, /* pc_relative */
937 0, /* bitpos */
938 complain_overflow_dont, /* complain_on_overflow */
939 ppc64_elf_toc_reloc, /* special_function */
940 "R_PPC64_TOC16_LO", /* name */
941 FALSE, /* partial_inplace */
942 0, /* src_mask */
943 0xffff, /* dst_mask */
944 FALSE), /* pcrel_offset */
945
946 /* 16 bit TOC-relative relocation, high 16 bits. */
947
948 /* R_PPC64_TOC16_HI 49 half16 #hi (S + A - .TOC.) */
949 HOWTO (R_PPC64_TOC16_HI, /* type */
950 16, /* rightshift */
951 1, /* size (0 = byte, 1 = short, 2 = long) */
952 16, /* bitsize */
953 FALSE, /* pc_relative */
954 0, /* bitpos */
955 complain_overflow_dont, /* complain_on_overflow */
956 ppc64_elf_toc_reloc, /* special_function */
957 "R_PPC64_TOC16_HI", /* name */
958 FALSE, /* partial_inplace */
959 0, /* src_mask */
960 0xffff, /* dst_mask */
961 FALSE), /* pcrel_offset */
962
963 /* 16 bit TOC-relative relocation, high 16 bits, plus 1 if the
964 contents of the low 16 bits, treated as a signed number, is
965 negative. */
966
967 /* R_PPC64_TOC16_HA 50 half16 #ha (S + A - .TOC.) */
968 HOWTO (R_PPC64_TOC16_HA, /* type */
969 16, /* rightshift */
970 1, /* size (0 = byte, 1 = short, 2 = long) */
971 16, /* bitsize */
972 FALSE, /* pc_relative */
973 0, /* bitpos */
974 complain_overflow_dont, /* complain_on_overflow */
975 ppc64_elf_toc_ha_reloc, /* special_function */
976 "R_PPC64_TOC16_HA", /* name */
977 FALSE, /* partial_inplace */
978 0, /* src_mask */
979 0xffff, /* dst_mask */
980 FALSE), /* pcrel_offset */
981
982 /* 64-bit relocation; insert value of TOC base (.TOC.). */
983
984 /* R_PPC64_TOC 51 doubleword64 .TOC. */
985 HOWTO (R_PPC64_TOC, /* type */
986 0, /* rightshift */
987 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
988 64, /* bitsize */
989 FALSE, /* pc_relative */
990 0, /* bitpos */
991 complain_overflow_bitfield, /* complain_on_overflow */
992 ppc64_elf_toc64_reloc, /* special_function */
993 "R_PPC64_TOC", /* name */
994 FALSE, /* partial_inplace */
995 0, /* src_mask */
996 ONES (64), /* dst_mask */
997 FALSE), /* pcrel_offset */
998
999 /* Like R_PPC64_GOT16, but also informs the link editor that the
1000 value to relocate may (!) refer to a PLT entry which the link
1001 editor (a) may replace with the symbol value. If the link editor
1002 is unable to fully resolve the symbol, it may (b) create a PLT
1003 entry and store the address to the new PLT entry in the GOT.
1004 This permits lazy resolution of function symbols at run time.
1005 The link editor may also skip all of this and just (c) emit a
1006 R_PPC64_GLOB_DAT to tie the symbol to the GOT entry. */
1007 /* FIXME: R_PPC64_PLTGOT16 not implemented. */
1008 HOWTO (R_PPC64_PLTGOT16, /* type */
1009 0, /* rightshift */
1010 1, /* size (0 = byte, 1 = short, 2 = long) */
1011 16, /* bitsize */
1012 FALSE, /* pc_relative */
1013 0, /* bitpos */
1014 complain_overflow_signed, /* complain_on_overflow */
1015 ppc64_elf_unhandled_reloc, /* special_function */
1016 "R_PPC64_PLTGOT16", /* name */
1017 FALSE, /* partial_inplace */
1018 0, /* src_mask */
1019 0xffff, /* dst_mask */
1020 FALSE), /* pcrel_offset */
1021
1022 /* Like R_PPC64_PLTGOT16, but without overflow. */
1023 /* FIXME: R_PPC64_PLTGOT16_LO not implemented. */
1024 HOWTO (R_PPC64_PLTGOT16_LO, /* type */
1025 0, /* rightshift */
1026 1, /* size (0 = byte, 1 = short, 2 = long) */
1027 16, /* bitsize */
1028 FALSE, /* pc_relative */
1029 0, /* bitpos */
1030 complain_overflow_dont, /* complain_on_overflow */
1031 ppc64_elf_unhandled_reloc, /* special_function */
1032 "R_PPC64_PLTGOT16_LO", /* name */
1033 FALSE, /* partial_inplace */
1034 0, /* src_mask */
1035 0xffff, /* dst_mask */
1036 FALSE), /* pcrel_offset */
1037
1038 /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address. */
1039 /* FIXME: R_PPC64_PLTGOT16_HI not implemented. */
1040 HOWTO (R_PPC64_PLTGOT16_HI, /* type */
1041 16, /* rightshift */
1042 1, /* size (0 = byte, 1 = short, 2 = long) */
1043 16, /* bitsize */
1044 FALSE, /* pc_relative */
1045 0, /* bitpos */
1046 complain_overflow_dont, /* complain_on_overflow */
1047 ppc64_elf_unhandled_reloc, /* special_function */
1048 "R_PPC64_PLTGOT16_HI", /* name */
1049 FALSE, /* partial_inplace */
1050 0, /* src_mask */
1051 0xffff, /* dst_mask */
1052 FALSE), /* pcrel_offset */
1053
1054 /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address, plus
1055 1 if the contents of the low 16 bits, treated as a signed number,
1056 is negative. */
1057 /* FIXME: R_PPC64_PLTGOT16_HA not implemented. */
1058 HOWTO (R_PPC64_PLTGOT16_HA, /* type */
1059 16, /* rightshift */
1060 1, /* size (0 = byte, 1 = short, 2 = long) */
1061 16, /* bitsize */
1062 FALSE, /* pc_relative */
1063 0, /* bitpos */
1064 complain_overflow_dont,/* complain_on_overflow */
1065 ppc64_elf_unhandled_reloc, /* special_function */
1066 "R_PPC64_PLTGOT16_HA", /* name */
1067 FALSE, /* partial_inplace */
1068 0, /* src_mask */
1069 0xffff, /* dst_mask */
1070 FALSE), /* pcrel_offset */
1071
1072 /* Like R_PPC64_ADDR16, but for instructions with a DS field. */
1073 HOWTO (R_PPC64_ADDR16_DS, /* type */
1074 0, /* rightshift */
1075 1, /* size (0 = byte, 1 = short, 2 = long) */
1076 16, /* bitsize */
1077 FALSE, /* pc_relative */
1078 0, /* bitpos */
1079 complain_overflow_bitfield, /* complain_on_overflow */
1080 bfd_elf_generic_reloc, /* special_function */
1081 "R_PPC64_ADDR16_DS", /* name */
1082 FALSE, /* partial_inplace */
1083 0, /* src_mask */
1084 0xfffc, /* dst_mask */
1085 FALSE), /* pcrel_offset */
1086
1087 /* Like R_PPC64_ADDR16_LO, but for instructions with a DS field. */
1088 HOWTO (R_PPC64_ADDR16_LO_DS, /* type */
1089 0, /* rightshift */
1090 1, /* size (0 = byte, 1 = short, 2 = long) */
1091 16, /* bitsize */
1092 FALSE, /* pc_relative */
1093 0, /* bitpos */
1094 complain_overflow_dont,/* complain_on_overflow */
1095 bfd_elf_generic_reloc, /* special_function */
1096 "R_PPC64_ADDR16_LO_DS",/* name */
1097 FALSE, /* partial_inplace */
1098 0, /* src_mask */
1099 0xfffc, /* dst_mask */
1100 FALSE), /* pcrel_offset */
1101
1102 /* Like R_PPC64_GOT16, but for instructions with a DS field. */
1103 HOWTO (R_PPC64_GOT16_DS, /* type */
1104 0, /* rightshift */
1105 1, /* size (0 = byte, 1 = short, 2 = long) */
1106 16, /* bitsize */
1107 FALSE, /* pc_relative */
1108 0, /* bitpos */
1109 complain_overflow_signed, /* complain_on_overflow */
1110 ppc64_elf_unhandled_reloc, /* special_function */
1111 "R_PPC64_GOT16_DS", /* name */
1112 FALSE, /* partial_inplace */
1113 0, /* src_mask */
1114 0xfffc, /* dst_mask */
1115 FALSE), /* pcrel_offset */
1116
1117 /* Like R_PPC64_GOT16_LO, but for instructions with a DS field. */
1118 HOWTO (R_PPC64_GOT16_LO_DS, /* type */
1119 0, /* rightshift */
1120 1, /* size (0 = byte, 1 = short, 2 = long) */
1121 16, /* bitsize */
1122 FALSE, /* pc_relative */
1123 0, /* bitpos */
1124 complain_overflow_dont, /* complain_on_overflow */
1125 ppc64_elf_unhandled_reloc, /* special_function */
1126 "R_PPC64_GOT16_LO_DS", /* name */
1127 FALSE, /* partial_inplace */
1128 0, /* src_mask */
1129 0xfffc, /* dst_mask */
1130 FALSE), /* pcrel_offset */
1131
1132 /* Like R_PPC64_PLT16_LO, but for instructions with a DS field. */
1133 HOWTO (R_PPC64_PLT16_LO_DS, /* type */
1134 0, /* rightshift */
1135 1, /* size (0 = byte, 1 = short, 2 = long) */
1136 16, /* bitsize */
1137 FALSE, /* pc_relative */
1138 0, /* bitpos */
1139 complain_overflow_dont, /* complain_on_overflow */
1140 ppc64_elf_unhandled_reloc, /* special_function */
1141 "R_PPC64_PLT16_LO_DS", /* name */
1142 FALSE, /* partial_inplace */
1143 0, /* src_mask */
1144 0xfffc, /* dst_mask */
1145 FALSE), /* pcrel_offset */
1146
1147 /* Like R_PPC64_SECTOFF, but for instructions with a DS field. */
1148 HOWTO (R_PPC64_SECTOFF_DS, /* type */
1149 0, /* rightshift */
1150 1, /* size (0 = byte, 1 = short, 2 = long) */
1151 16, /* bitsize */
1152 FALSE, /* pc_relative */
1153 0, /* bitpos */
1154 complain_overflow_bitfield, /* complain_on_overflow */
1155 ppc64_elf_sectoff_reloc, /* special_function */
1156 "R_PPC64_SECTOFF_DS", /* name */
1157 FALSE, /* partial_inplace */
1158 0, /* src_mask */
1159 0xfffc, /* dst_mask */
1160 FALSE), /* pcrel_offset */
1161
1162 /* Like R_PPC64_SECTOFF_LO, but for instructions with a DS field. */
1163 HOWTO (R_PPC64_SECTOFF_LO_DS, /* type */
1164 0, /* rightshift */
1165 1, /* size (0 = byte, 1 = short, 2 = long) */
1166 16, /* bitsize */
1167 FALSE, /* pc_relative */
1168 0, /* bitpos */
1169 complain_overflow_dont, /* complain_on_overflow */
1170 ppc64_elf_sectoff_reloc, /* special_function */
1171 "R_PPC64_SECTOFF_LO_DS",/* name */
1172 FALSE, /* partial_inplace */
1173 0, /* src_mask */
1174 0xfffc, /* dst_mask */
1175 FALSE), /* pcrel_offset */
1176
1177 /* Like R_PPC64_TOC16, but for instructions with a DS field. */
1178 HOWTO (R_PPC64_TOC16_DS, /* type */
1179 0, /* rightshift */
1180 1, /* size (0 = byte, 1 = short, 2 = long) */
1181 16, /* bitsize */
1182 FALSE, /* pc_relative */
1183 0, /* bitpos */
1184 complain_overflow_signed, /* complain_on_overflow */
1185 ppc64_elf_toc_reloc, /* special_function */
1186 "R_PPC64_TOC16_DS", /* name */
1187 FALSE, /* partial_inplace */
1188 0, /* src_mask */
1189 0xfffc, /* dst_mask */
1190 FALSE), /* pcrel_offset */
1191
1192 /* Like R_PPC64_TOC16_LO, but for instructions with a DS field. */
1193 HOWTO (R_PPC64_TOC16_LO_DS, /* type */
1194 0, /* rightshift */
1195 1, /* size (0 = byte, 1 = short, 2 = long) */
1196 16, /* bitsize */
1197 FALSE, /* pc_relative */
1198 0, /* bitpos */
1199 complain_overflow_dont, /* complain_on_overflow */
1200 ppc64_elf_toc_reloc, /* special_function */
1201 "R_PPC64_TOC16_LO_DS", /* name */
1202 FALSE, /* partial_inplace */
1203 0, /* src_mask */
1204 0xfffc, /* dst_mask */
1205 FALSE), /* pcrel_offset */
1206
1207 /* Like R_PPC64_PLTGOT16, but for instructions with a DS field. */
1208 /* FIXME: R_PPC64_PLTGOT16_DS not implemented. */
1209 HOWTO (R_PPC64_PLTGOT16_DS, /* type */
1210 0, /* rightshift */
1211 1, /* size (0 = byte, 1 = short, 2 = long) */
1212 16, /* bitsize */
1213 FALSE, /* pc_relative */
1214 0, /* bitpos */
1215 complain_overflow_signed, /* complain_on_overflow */
1216 ppc64_elf_unhandled_reloc, /* special_function */
1217 "R_PPC64_PLTGOT16_DS", /* name */
1218 FALSE, /* partial_inplace */
1219 0, /* src_mask */
1220 0xfffc, /* dst_mask */
1221 FALSE), /* pcrel_offset */
1222
1223 /* Like R_PPC64_PLTGOT16_LO, but for instructions with a DS field. */
1224 /* FIXME: R_PPC64_PLTGOT16_LO not implemented. */
1225 HOWTO (R_PPC64_PLTGOT16_LO_DS,/* type */
1226 0, /* rightshift */
1227 1, /* size (0 = byte, 1 = short, 2 = long) */
1228 16, /* bitsize */
1229 FALSE, /* pc_relative */
1230 0, /* bitpos */
1231 complain_overflow_dont, /* complain_on_overflow */
1232 ppc64_elf_unhandled_reloc, /* special_function */
1233 "R_PPC64_PLTGOT16_LO_DS",/* name */
1234 FALSE, /* partial_inplace */
1235 0, /* src_mask */
1236 0xfffc, /* dst_mask */
1237 FALSE), /* pcrel_offset */
1238
1239 /* Marker relocs for TLS. */
1240 HOWTO (R_PPC64_TLS,
1241 0, /* rightshift */
1242 2, /* size (0 = byte, 1 = short, 2 = long) */
1243 32, /* bitsize */
1244 FALSE, /* pc_relative */
1245 0, /* bitpos */
1246 complain_overflow_dont, /* complain_on_overflow */
1247 bfd_elf_generic_reloc, /* special_function */
1248 "R_PPC64_TLS", /* name */
1249 FALSE, /* partial_inplace */
1250 0, /* src_mask */
1251 0, /* dst_mask */
1252 FALSE), /* pcrel_offset */
1253
1254 HOWTO (R_PPC64_TLSGD,
1255 0, /* rightshift */
1256 2, /* size (0 = byte, 1 = short, 2 = long) */
1257 32, /* bitsize */
1258 FALSE, /* pc_relative */
1259 0, /* bitpos */
1260 complain_overflow_dont, /* complain_on_overflow */
1261 bfd_elf_generic_reloc, /* special_function */
1262 "R_PPC64_TLSGD", /* name */
1263 FALSE, /* partial_inplace */
1264 0, /* src_mask */
1265 0, /* dst_mask */
1266 FALSE), /* pcrel_offset */
1267
1268 HOWTO (R_PPC64_TLSLD,
1269 0, /* rightshift */
1270 2, /* size (0 = byte, 1 = short, 2 = long) */
1271 32, /* bitsize */
1272 FALSE, /* pc_relative */
1273 0, /* bitpos */
1274 complain_overflow_dont, /* complain_on_overflow */
1275 bfd_elf_generic_reloc, /* special_function */
1276 "R_PPC64_TLSLD", /* name */
1277 FALSE, /* partial_inplace */
1278 0, /* src_mask */
1279 0, /* dst_mask */
1280 FALSE), /* pcrel_offset */
1281
1282 /* Computes the load module index of the load module that contains the
1283 definition of its TLS sym. */
1284 HOWTO (R_PPC64_DTPMOD64,
1285 0, /* rightshift */
1286 4, /* size (0 = byte, 1 = short, 2 = long) */
1287 64, /* bitsize */
1288 FALSE, /* pc_relative */
1289 0, /* bitpos */
1290 complain_overflow_dont, /* complain_on_overflow */
1291 ppc64_elf_unhandled_reloc, /* special_function */
1292 "R_PPC64_DTPMOD64", /* name */
1293 FALSE, /* partial_inplace */
1294 0, /* src_mask */
1295 ONES (64), /* dst_mask */
1296 FALSE), /* pcrel_offset */
1297
1298 /* Computes a dtv-relative displacement, the difference between the value
1299 of sym+add and the base address of the thread-local storage block that
1300 contains the definition of sym, minus 0x8000. */
1301 HOWTO (R_PPC64_DTPREL64,
1302 0, /* rightshift */
1303 4, /* size (0 = byte, 1 = short, 2 = long) */
1304 64, /* bitsize */
1305 FALSE, /* pc_relative */
1306 0, /* bitpos */
1307 complain_overflow_dont, /* complain_on_overflow */
1308 ppc64_elf_unhandled_reloc, /* special_function */
1309 "R_PPC64_DTPREL64", /* name */
1310 FALSE, /* partial_inplace */
1311 0, /* src_mask */
1312 ONES (64), /* dst_mask */
1313 FALSE), /* pcrel_offset */
1314
1315 /* A 16 bit dtprel reloc. */
1316 HOWTO (R_PPC64_DTPREL16,
1317 0, /* rightshift */
1318 1, /* size (0 = byte, 1 = short, 2 = long) */
1319 16, /* bitsize */
1320 FALSE, /* pc_relative */
1321 0, /* bitpos */
1322 complain_overflow_signed, /* complain_on_overflow */
1323 ppc64_elf_unhandled_reloc, /* special_function */
1324 "R_PPC64_DTPREL16", /* name */
1325 FALSE, /* partial_inplace */
1326 0, /* src_mask */
1327 0xffff, /* dst_mask */
1328 FALSE), /* pcrel_offset */
1329
1330 /* Like DTPREL16, but no overflow. */
1331 HOWTO (R_PPC64_DTPREL16_LO,
1332 0, /* rightshift */
1333 1, /* size (0 = byte, 1 = short, 2 = long) */
1334 16, /* bitsize */
1335 FALSE, /* pc_relative */
1336 0, /* bitpos */
1337 complain_overflow_dont, /* complain_on_overflow */
1338 ppc64_elf_unhandled_reloc, /* special_function */
1339 "R_PPC64_DTPREL16_LO", /* name */
1340 FALSE, /* partial_inplace */
1341 0, /* src_mask */
1342 0xffff, /* dst_mask */
1343 FALSE), /* pcrel_offset */
1344
1345 /* Like DTPREL16_LO, but next higher group of 16 bits. */
1346 HOWTO (R_PPC64_DTPREL16_HI,
1347 16, /* rightshift */
1348 1, /* size (0 = byte, 1 = short, 2 = long) */
1349 16, /* bitsize */
1350 FALSE, /* pc_relative */
1351 0, /* bitpos */
1352 complain_overflow_dont, /* complain_on_overflow */
1353 ppc64_elf_unhandled_reloc, /* special_function */
1354 "R_PPC64_DTPREL16_HI", /* name */
1355 FALSE, /* partial_inplace */
1356 0, /* src_mask */
1357 0xffff, /* dst_mask */
1358 FALSE), /* pcrel_offset */
1359
1360 /* Like DTPREL16_HI, but adjust for low 16 bits. */
1361 HOWTO (R_PPC64_DTPREL16_HA,
1362 16, /* rightshift */
1363 1, /* size (0 = byte, 1 = short, 2 = long) */
1364 16, /* bitsize */
1365 FALSE, /* pc_relative */
1366 0, /* bitpos */
1367 complain_overflow_dont, /* complain_on_overflow */
1368 ppc64_elf_unhandled_reloc, /* special_function */
1369 "R_PPC64_DTPREL16_HA", /* name */
1370 FALSE, /* partial_inplace */
1371 0, /* src_mask */
1372 0xffff, /* dst_mask */
1373 FALSE), /* pcrel_offset */
1374
1375 /* Like DTPREL16_HI, but next higher group of 16 bits. */
1376 HOWTO (R_PPC64_DTPREL16_HIGHER,
1377 32, /* rightshift */
1378 1, /* size (0 = byte, 1 = short, 2 = long) */
1379 16, /* bitsize */
1380 FALSE, /* pc_relative */
1381 0, /* bitpos */
1382 complain_overflow_dont, /* complain_on_overflow */
1383 ppc64_elf_unhandled_reloc, /* special_function */
1384 "R_PPC64_DTPREL16_HIGHER", /* name */
1385 FALSE, /* partial_inplace */
1386 0, /* src_mask */
1387 0xffff, /* dst_mask */
1388 FALSE), /* pcrel_offset */
1389
1390 /* Like DTPREL16_HIGHER, but adjust for low 16 bits. */
1391 HOWTO (R_PPC64_DTPREL16_HIGHERA,
1392 32, /* rightshift */
1393 1, /* size (0 = byte, 1 = short, 2 = long) */
1394 16, /* bitsize */
1395 FALSE, /* pc_relative */
1396 0, /* bitpos */
1397 complain_overflow_dont, /* complain_on_overflow */
1398 ppc64_elf_unhandled_reloc, /* special_function */
1399 "R_PPC64_DTPREL16_HIGHERA", /* name */
1400 FALSE, /* partial_inplace */
1401 0, /* src_mask */
1402 0xffff, /* dst_mask */
1403 FALSE), /* pcrel_offset */
1404
1405 /* Like DTPREL16_HIGHER, but next higher group of 16 bits. */
1406 HOWTO (R_PPC64_DTPREL16_HIGHEST,
1407 48, /* rightshift */
1408 1, /* size (0 = byte, 1 = short, 2 = long) */
1409 16, /* bitsize */
1410 FALSE, /* pc_relative */
1411 0, /* bitpos */
1412 complain_overflow_dont, /* complain_on_overflow */
1413 ppc64_elf_unhandled_reloc, /* special_function */
1414 "R_PPC64_DTPREL16_HIGHEST", /* name */
1415 FALSE, /* partial_inplace */
1416 0, /* src_mask */
1417 0xffff, /* dst_mask */
1418 FALSE), /* pcrel_offset */
1419
1420 /* Like DTPREL16_HIGHEST, but adjust for low 16 bits. */
1421 HOWTO (R_PPC64_DTPREL16_HIGHESTA,
1422 48, /* rightshift */
1423 1, /* size (0 = byte, 1 = short, 2 = long) */
1424 16, /* bitsize */
1425 FALSE, /* pc_relative */
1426 0, /* bitpos */
1427 complain_overflow_dont, /* complain_on_overflow */
1428 ppc64_elf_unhandled_reloc, /* special_function */
1429 "R_PPC64_DTPREL16_HIGHESTA", /* name */
1430 FALSE, /* partial_inplace */
1431 0, /* src_mask */
1432 0xffff, /* dst_mask */
1433 FALSE), /* pcrel_offset */
1434
1435 /* Like DTPREL16, but for insns with a DS field. */
1436 HOWTO (R_PPC64_DTPREL16_DS,
1437 0, /* rightshift */
1438 1, /* size (0 = byte, 1 = short, 2 = long) */
1439 16, /* bitsize */
1440 FALSE, /* pc_relative */
1441 0, /* bitpos */
1442 complain_overflow_signed, /* complain_on_overflow */
1443 ppc64_elf_unhandled_reloc, /* special_function */
1444 "R_PPC64_DTPREL16_DS", /* name */
1445 FALSE, /* partial_inplace */
1446 0, /* src_mask */
1447 0xfffc, /* dst_mask */
1448 FALSE), /* pcrel_offset */
1449
1450 /* Like DTPREL16_DS, but no overflow. */
1451 HOWTO (R_PPC64_DTPREL16_LO_DS,
1452 0, /* rightshift */
1453 1, /* size (0 = byte, 1 = short, 2 = long) */
1454 16, /* bitsize */
1455 FALSE, /* pc_relative */
1456 0, /* bitpos */
1457 complain_overflow_dont, /* complain_on_overflow */
1458 ppc64_elf_unhandled_reloc, /* special_function */
1459 "R_PPC64_DTPREL16_LO_DS", /* name */
1460 FALSE, /* partial_inplace */
1461 0, /* src_mask */
1462 0xfffc, /* dst_mask */
1463 FALSE), /* pcrel_offset */
1464
1465 /* Computes a tp-relative displacement, the difference between the value of
1466 sym+add and the value of the thread pointer (r13). */
1467 HOWTO (R_PPC64_TPREL64,
1468 0, /* rightshift */
1469 4, /* size (0 = byte, 1 = short, 2 = long) */
1470 64, /* bitsize */
1471 FALSE, /* pc_relative */
1472 0, /* bitpos */
1473 complain_overflow_dont, /* complain_on_overflow */
1474 ppc64_elf_unhandled_reloc, /* special_function */
1475 "R_PPC64_TPREL64", /* name */
1476 FALSE, /* partial_inplace */
1477 0, /* src_mask */
1478 ONES (64), /* dst_mask */
1479 FALSE), /* pcrel_offset */
1480
1481 /* A 16 bit tprel reloc. */
1482 HOWTO (R_PPC64_TPREL16,
1483 0, /* rightshift */
1484 1, /* size (0 = byte, 1 = short, 2 = long) */
1485 16, /* bitsize */
1486 FALSE, /* pc_relative */
1487 0, /* bitpos */
1488 complain_overflow_signed, /* complain_on_overflow */
1489 ppc64_elf_unhandled_reloc, /* special_function */
1490 "R_PPC64_TPREL16", /* name */
1491 FALSE, /* partial_inplace */
1492 0, /* src_mask */
1493 0xffff, /* dst_mask */
1494 FALSE), /* pcrel_offset */
1495
1496 /* Like TPREL16, but no overflow. */
1497 HOWTO (R_PPC64_TPREL16_LO,
1498 0, /* rightshift */
1499 1, /* size (0 = byte, 1 = short, 2 = long) */
1500 16, /* bitsize */
1501 FALSE, /* pc_relative */
1502 0, /* bitpos */
1503 complain_overflow_dont, /* complain_on_overflow */
1504 ppc64_elf_unhandled_reloc, /* special_function */
1505 "R_PPC64_TPREL16_LO", /* name */
1506 FALSE, /* partial_inplace */
1507 0, /* src_mask */
1508 0xffff, /* dst_mask */
1509 FALSE), /* pcrel_offset */
1510
1511 /* Like TPREL16_LO, but next higher group of 16 bits. */
1512 HOWTO (R_PPC64_TPREL16_HI,
1513 16, /* rightshift */
1514 1, /* size (0 = byte, 1 = short, 2 = long) */
1515 16, /* bitsize */
1516 FALSE, /* pc_relative */
1517 0, /* bitpos */
1518 complain_overflow_dont, /* complain_on_overflow */
1519 ppc64_elf_unhandled_reloc, /* special_function */
1520 "R_PPC64_TPREL16_HI", /* name */
1521 FALSE, /* partial_inplace */
1522 0, /* src_mask */
1523 0xffff, /* dst_mask */
1524 FALSE), /* pcrel_offset */
1525
1526 /* Like TPREL16_HI, but adjust for low 16 bits. */
1527 HOWTO (R_PPC64_TPREL16_HA,
1528 16, /* rightshift */
1529 1, /* size (0 = byte, 1 = short, 2 = long) */
1530 16, /* bitsize */
1531 FALSE, /* pc_relative */
1532 0, /* bitpos */
1533 complain_overflow_dont, /* complain_on_overflow */
1534 ppc64_elf_unhandled_reloc, /* special_function */
1535 "R_PPC64_TPREL16_HA", /* name */
1536 FALSE, /* partial_inplace */
1537 0, /* src_mask */
1538 0xffff, /* dst_mask */
1539 FALSE), /* pcrel_offset */
1540
1541 /* Like TPREL16_HI, but next higher group of 16 bits. */
1542 HOWTO (R_PPC64_TPREL16_HIGHER,
1543 32, /* rightshift */
1544 1, /* size (0 = byte, 1 = short, 2 = long) */
1545 16, /* bitsize */
1546 FALSE, /* pc_relative */
1547 0, /* bitpos */
1548 complain_overflow_dont, /* complain_on_overflow */
1549 ppc64_elf_unhandled_reloc, /* special_function */
1550 "R_PPC64_TPREL16_HIGHER", /* name */
1551 FALSE, /* partial_inplace */
1552 0, /* src_mask */
1553 0xffff, /* dst_mask */
1554 FALSE), /* pcrel_offset */
1555
1556 /* Like TPREL16_HIGHER, but adjust for low 16 bits. */
1557 HOWTO (R_PPC64_TPREL16_HIGHERA,
1558 32, /* rightshift */
1559 1, /* size (0 = byte, 1 = short, 2 = long) */
1560 16, /* bitsize */
1561 FALSE, /* pc_relative */
1562 0, /* bitpos */
1563 complain_overflow_dont, /* complain_on_overflow */
1564 ppc64_elf_unhandled_reloc, /* special_function */
1565 "R_PPC64_TPREL16_HIGHERA", /* name */
1566 FALSE, /* partial_inplace */
1567 0, /* src_mask */
1568 0xffff, /* dst_mask */
1569 FALSE), /* pcrel_offset */
1570
1571 /* Like TPREL16_HIGHER, but next higher group of 16 bits. */
1572 HOWTO (R_PPC64_TPREL16_HIGHEST,
1573 48, /* rightshift */
1574 1, /* size (0 = byte, 1 = short, 2 = long) */
1575 16, /* bitsize */
1576 FALSE, /* pc_relative */
1577 0, /* bitpos */
1578 complain_overflow_dont, /* complain_on_overflow */
1579 ppc64_elf_unhandled_reloc, /* special_function */
1580 "R_PPC64_TPREL16_HIGHEST", /* name */
1581 FALSE, /* partial_inplace */
1582 0, /* src_mask */
1583 0xffff, /* dst_mask */
1584 FALSE), /* pcrel_offset */
1585
1586 /* Like TPREL16_HIGHEST, but adjust for low 16 bits. */
1587 HOWTO (R_PPC64_TPREL16_HIGHESTA,
1588 48, /* rightshift */
1589 1, /* size (0 = byte, 1 = short, 2 = long) */
1590 16, /* bitsize */
1591 FALSE, /* pc_relative */
1592 0, /* bitpos */
1593 complain_overflow_dont, /* complain_on_overflow */
1594 ppc64_elf_unhandled_reloc, /* special_function */
1595 "R_PPC64_TPREL16_HIGHESTA", /* name */
1596 FALSE, /* partial_inplace */
1597 0, /* src_mask */
1598 0xffff, /* dst_mask */
1599 FALSE), /* pcrel_offset */
1600
1601 /* Like TPREL16, but for insns with a DS field. */
1602 HOWTO (R_PPC64_TPREL16_DS,
1603 0, /* rightshift */
1604 1, /* size (0 = byte, 1 = short, 2 = long) */
1605 16, /* bitsize */
1606 FALSE, /* pc_relative */
1607 0, /* bitpos */
1608 complain_overflow_signed, /* complain_on_overflow */
1609 ppc64_elf_unhandled_reloc, /* special_function */
1610 "R_PPC64_TPREL16_DS", /* name */
1611 FALSE, /* partial_inplace */
1612 0, /* src_mask */
1613 0xfffc, /* dst_mask */
1614 FALSE), /* pcrel_offset */
1615
1616 /* Like TPREL16_DS, but no overflow. */
1617 HOWTO (R_PPC64_TPREL16_LO_DS,
1618 0, /* rightshift */
1619 1, /* size (0 = byte, 1 = short, 2 = long) */
1620 16, /* bitsize */
1621 FALSE, /* pc_relative */
1622 0, /* bitpos */
1623 complain_overflow_dont, /* complain_on_overflow */
1624 ppc64_elf_unhandled_reloc, /* special_function */
1625 "R_PPC64_TPREL16_LO_DS", /* name */
1626 FALSE, /* partial_inplace */
1627 0, /* src_mask */
1628 0xfffc, /* dst_mask */
1629 FALSE), /* pcrel_offset */
1630
1631 /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1632 with values (sym+add)@dtpmod and (sym+add)@dtprel, and computes the offset
1633 to the first entry relative to the TOC base (r2). */
1634 HOWTO (R_PPC64_GOT_TLSGD16,
1635 0, /* rightshift */
1636 1, /* size (0 = byte, 1 = short, 2 = long) */
1637 16, /* bitsize */
1638 FALSE, /* pc_relative */
1639 0, /* bitpos */
1640 complain_overflow_signed, /* complain_on_overflow */
1641 ppc64_elf_unhandled_reloc, /* special_function */
1642 "R_PPC64_GOT_TLSGD16", /* name */
1643 FALSE, /* partial_inplace */
1644 0, /* src_mask */
1645 0xffff, /* dst_mask */
1646 FALSE), /* pcrel_offset */
1647
1648 /* Like GOT_TLSGD16, but no overflow. */
1649 HOWTO (R_PPC64_GOT_TLSGD16_LO,
1650 0, /* rightshift */
1651 1, /* size (0 = byte, 1 = short, 2 = long) */
1652 16, /* bitsize */
1653 FALSE, /* pc_relative */
1654 0, /* bitpos */
1655 complain_overflow_dont, /* complain_on_overflow */
1656 ppc64_elf_unhandled_reloc, /* special_function */
1657 "R_PPC64_GOT_TLSGD16_LO", /* name */
1658 FALSE, /* partial_inplace */
1659 0, /* src_mask */
1660 0xffff, /* dst_mask */
1661 FALSE), /* pcrel_offset */
1662
1663 /* Like GOT_TLSGD16_LO, but next higher group of 16 bits. */
1664 HOWTO (R_PPC64_GOT_TLSGD16_HI,
1665 16, /* rightshift */
1666 1, /* size (0 = byte, 1 = short, 2 = long) */
1667 16, /* bitsize */
1668 FALSE, /* pc_relative */
1669 0, /* bitpos */
1670 complain_overflow_dont, /* complain_on_overflow */
1671 ppc64_elf_unhandled_reloc, /* special_function */
1672 "R_PPC64_GOT_TLSGD16_HI", /* name */
1673 FALSE, /* partial_inplace */
1674 0, /* src_mask */
1675 0xffff, /* dst_mask */
1676 FALSE), /* pcrel_offset */
1677
1678 /* Like GOT_TLSGD16_HI, but adjust for low 16 bits. */
1679 HOWTO (R_PPC64_GOT_TLSGD16_HA,
1680 16, /* rightshift */
1681 1, /* size (0 = byte, 1 = short, 2 = long) */
1682 16, /* bitsize */
1683 FALSE, /* pc_relative */
1684 0, /* bitpos */
1685 complain_overflow_dont, /* complain_on_overflow */
1686 ppc64_elf_unhandled_reloc, /* special_function */
1687 "R_PPC64_GOT_TLSGD16_HA", /* name */
1688 FALSE, /* partial_inplace */
1689 0, /* src_mask */
1690 0xffff, /* dst_mask */
1691 FALSE), /* pcrel_offset */
1692
1693 /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1694 with values (sym+add)@dtpmod and zero, and computes the offset to the
1695 first entry relative to the TOC base (r2). */
1696 HOWTO (R_PPC64_GOT_TLSLD16,
1697 0, /* rightshift */
1698 1, /* size (0 = byte, 1 = short, 2 = long) */
1699 16, /* bitsize */
1700 FALSE, /* pc_relative */
1701 0, /* bitpos */
1702 complain_overflow_signed, /* complain_on_overflow */
1703 ppc64_elf_unhandled_reloc, /* special_function */
1704 "R_PPC64_GOT_TLSLD16", /* name */
1705 FALSE, /* partial_inplace */
1706 0, /* src_mask */
1707 0xffff, /* dst_mask */
1708 FALSE), /* pcrel_offset */
1709
1710 /* Like GOT_TLSLD16, but no overflow. */
1711 HOWTO (R_PPC64_GOT_TLSLD16_LO,
1712 0, /* rightshift */
1713 1, /* size (0 = byte, 1 = short, 2 = long) */
1714 16, /* bitsize */
1715 FALSE, /* pc_relative */
1716 0, /* bitpos */
1717 complain_overflow_dont, /* complain_on_overflow */
1718 ppc64_elf_unhandled_reloc, /* special_function */
1719 "R_PPC64_GOT_TLSLD16_LO", /* name */
1720 FALSE, /* partial_inplace */
1721 0, /* src_mask */
1722 0xffff, /* dst_mask */
1723 FALSE), /* pcrel_offset */
1724
1725 /* Like GOT_TLSLD16_LO, but next higher group of 16 bits. */
1726 HOWTO (R_PPC64_GOT_TLSLD16_HI,
1727 16, /* rightshift */
1728 1, /* size (0 = byte, 1 = short, 2 = long) */
1729 16, /* bitsize */
1730 FALSE, /* pc_relative */
1731 0, /* bitpos */
1732 complain_overflow_dont, /* complain_on_overflow */
1733 ppc64_elf_unhandled_reloc, /* special_function */
1734 "R_PPC64_GOT_TLSLD16_HI", /* name */
1735 FALSE, /* partial_inplace */
1736 0, /* src_mask */
1737 0xffff, /* dst_mask */
1738 FALSE), /* pcrel_offset */
1739
1740 /* Like GOT_TLSLD16_HI, but adjust for low 16 bits. */
1741 HOWTO (R_PPC64_GOT_TLSLD16_HA,
1742 16, /* rightshift */
1743 1, /* size (0 = byte, 1 = short, 2 = long) */
1744 16, /* bitsize */
1745 FALSE, /* pc_relative */
1746 0, /* bitpos */
1747 complain_overflow_dont, /* complain_on_overflow */
1748 ppc64_elf_unhandled_reloc, /* special_function */
1749 "R_PPC64_GOT_TLSLD16_HA", /* name */
1750 FALSE, /* partial_inplace */
1751 0, /* src_mask */
1752 0xffff, /* dst_mask */
1753 FALSE), /* pcrel_offset */
1754
1755 /* Allocates an entry in the GOT with value (sym+add)@dtprel, and computes
1756 the offset to the entry relative to the TOC base (r2). */
1757 HOWTO (R_PPC64_GOT_DTPREL16_DS,
1758 0, /* rightshift */
1759 1, /* size (0 = byte, 1 = short, 2 = long) */
1760 16, /* bitsize */
1761 FALSE, /* pc_relative */
1762 0, /* bitpos */
1763 complain_overflow_signed, /* complain_on_overflow */
1764 ppc64_elf_unhandled_reloc, /* special_function */
1765 "R_PPC64_GOT_DTPREL16_DS", /* name */
1766 FALSE, /* partial_inplace */
1767 0, /* src_mask */
1768 0xfffc, /* dst_mask */
1769 FALSE), /* pcrel_offset */
1770
1771 /* Like GOT_DTPREL16_DS, but no overflow. */
1772 HOWTO (R_PPC64_GOT_DTPREL16_LO_DS,
1773 0, /* rightshift */
1774 1, /* size (0 = byte, 1 = short, 2 = long) */
1775 16, /* bitsize */
1776 FALSE, /* pc_relative */
1777 0, /* bitpos */
1778 complain_overflow_dont, /* complain_on_overflow */
1779 ppc64_elf_unhandled_reloc, /* special_function */
1780 "R_PPC64_GOT_DTPREL16_LO_DS", /* name */
1781 FALSE, /* partial_inplace */
1782 0, /* src_mask */
1783 0xfffc, /* dst_mask */
1784 FALSE), /* pcrel_offset */
1785
1786 /* Like GOT_DTPREL16_LO_DS, but next higher group of 16 bits. */
1787 HOWTO (R_PPC64_GOT_DTPREL16_HI,
1788 16, /* rightshift */
1789 1, /* size (0 = byte, 1 = short, 2 = long) */
1790 16, /* bitsize */
1791 FALSE, /* pc_relative */
1792 0, /* bitpos */
1793 complain_overflow_dont, /* complain_on_overflow */
1794 ppc64_elf_unhandled_reloc, /* special_function */
1795 "R_PPC64_GOT_DTPREL16_HI", /* name */
1796 FALSE, /* partial_inplace */
1797 0, /* src_mask */
1798 0xffff, /* dst_mask */
1799 FALSE), /* pcrel_offset */
1800
1801 /* Like GOT_DTPREL16_HI, but adjust for low 16 bits. */
1802 HOWTO (R_PPC64_GOT_DTPREL16_HA,
1803 16, /* rightshift */
1804 1, /* size (0 = byte, 1 = short, 2 = long) */
1805 16, /* bitsize */
1806 FALSE, /* pc_relative */
1807 0, /* bitpos */
1808 complain_overflow_dont, /* complain_on_overflow */
1809 ppc64_elf_unhandled_reloc, /* special_function */
1810 "R_PPC64_GOT_DTPREL16_HA", /* name */
1811 FALSE, /* partial_inplace */
1812 0, /* src_mask */
1813 0xffff, /* dst_mask */
1814 FALSE), /* pcrel_offset */
1815
1816 /* Allocates an entry in the GOT with value (sym+add)@tprel, and computes the
1817 offset to the entry relative to the TOC base (r2). */
1818 HOWTO (R_PPC64_GOT_TPREL16_DS,
1819 0, /* rightshift */
1820 1, /* size (0 = byte, 1 = short, 2 = long) */
1821 16, /* bitsize */
1822 FALSE, /* pc_relative */
1823 0, /* bitpos */
1824 complain_overflow_signed, /* complain_on_overflow */
1825 ppc64_elf_unhandled_reloc, /* special_function */
1826 "R_PPC64_GOT_TPREL16_DS", /* name */
1827 FALSE, /* partial_inplace */
1828 0, /* src_mask */
1829 0xfffc, /* dst_mask */
1830 FALSE), /* pcrel_offset */
1831
1832 /* Like GOT_TPREL16_DS, but no overflow. */
1833 HOWTO (R_PPC64_GOT_TPREL16_LO_DS,
1834 0, /* rightshift */
1835 1, /* size (0 = byte, 1 = short, 2 = long) */
1836 16, /* bitsize */
1837 FALSE, /* pc_relative */
1838 0, /* bitpos */
1839 complain_overflow_dont, /* complain_on_overflow */
1840 ppc64_elf_unhandled_reloc, /* special_function */
1841 "R_PPC64_GOT_TPREL16_LO_DS", /* name */
1842 FALSE, /* partial_inplace */
1843 0, /* src_mask */
1844 0xfffc, /* dst_mask */
1845 FALSE), /* pcrel_offset */
1846
1847 /* Like GOT_TPREL16_LO_DS, but next higher group of 16 bits. */
1848 HOWTO (R_PPC64_GOT_TPREL16_HI,
1849 16, /* rightshift */
1850 1, /* size (0 = byte, 1 = short, 2 = long) */
1851 16, /* bitsize */
1852 FALSE, /* pc_relative */
1853 0, /* bitpos */
1854 complain_overflow_dont, /* complain_on_overflow */
1855 ppc64_elf_unhandled_reloc, /* special_function */
1856 "R_PPC64_GOT_TPREL16_HI", /* name */
1857 FALSE, /* partial_inplace */
1858 0, /* src_mask */
1859 0xffff, /* dst_mask */
1860 FALSE), /* pcrel_offset */
1861
1862 /* Like GOT_TPREL16_HI, but adjust for low 16 bits. */
1863 HOWTO (R_PPC64_GOT_TPREL16_HA,
1864 16, /* rightshift */
1865 1, /* size (0 = byte, 1 = short, 2 = long) */
1866 16, /* bitsize */
1867 FALSE, /* pc_relative */
1868 0, /* bitpos */
1869 complain_overflow_dont, /* complain_on_overflow */
1870 ppc64_elf_unhandled_reloc, /* special_function */
1871 "R_PPC64_GOT_TPREL16_HA", /* name */
1872 FALSE, /* partial_inplace */
1873 0, /* src_mask */
1874 0xffff, /* dst_mask */
1875 FALSE), /* pcrel_offset */
1876
1877 HOWTO (R_PPC64_IRELATIVE, /* type */
1878 0, /* rightshift */
1879 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1880 64, /* bitsize */
1881 FALSE, /* pc_relative */
1882 0, /* bitpos */
1883 complain_overflow_dont, /* complain_on_overflow */
1884 bfd_elf_generic_reloc, /* special_function */
1885 "R_PPC64_IRELATIVE", /* name */
1886 FALSE, /* partial_inplace */
1887 0, /* src_mask */
1888 ONES (64), /* dst_mask */
1889 FALSE), /* pcrel_offset */
1890
1891 /* GNU extension to record C++ vtable hierarchy. */
1892 HOWTO (R_PPC64_GNU_VTINHERIT, /* type */
1893 0, /* rightshift */
1894 0, /* size (0 = byte, 1 = short, 2 = long) */
1895 0, /* bitsize */
1896 FALSE, /* pc_relative */
1897 0, /* bitpos */
1898 complain_overflow_dont, /* complain_on_overflow */
1899 NULL, /* special_function */
1900 "R_PPC64_GNU_VTINHERIT", /* name */
1901 FALSE, /* partial_inplace */
1902 0, /* src_mask */
1903 0, /* dst_mask */
1904 FALSE), /* pcrel_offset */
1905
1906 /* GNU extension to record C++ vtable member usage. */
1907 HOWTO (R_PPC64_GNU_VTENTRY, /* type */
1908 0, /* rightshift */
1909 0, /* size (0 = byte, 1 = short, 2 = long) */
1910 0, /* bitsize */
1911 FALSE, /* pc_relative */
1912 0, /* bitpos */
1913 complain_overflow_dont, /* complain_on_overflow */
1914 NULL, /* special_function */
1915 "R_PPC64_GNU_VTENTRY", /* name */
1916 FALSE, /* partial_inplace */
1917 0, /* src_mask */
1918 0, /* dst_mask */
1919 FALSE), /* pcrel_offset */
1920 };
1921
1922 \f
1923 /* Initialize the ppc64_elf_howto_table, so that linear accesses can
1924 be done. */
1925
1926 static void
1927 ppc_howto_init (void)
1928 {
1929 unsigned int i, type;
1930
1931 for (i = 0;
1932 i < sizeof (ppc64_elf_howto_raw) / sizeof (ppc64_elf_howto_raw[0]);
1933 i++)
1934 {
1935 type = ppc64_elf_howto_raw[i].type;
1936 BFD_ASSERT (type < (sizeof (ppc64_elf_howto_table)
1937 / sizeof (ppc64_elf_howto_table[0])));
1938 ppc64_elf_howto_table[type] = &ppc64_elf_howto_raw[i];
1939 }
1940 }
1941
1942 static reloc_howto_type *
1943 ppc64_elf_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
1944 bfd_reloc_code_real_type code)
1945 {
1946 enum elf_ppc64_reloc_type r = R_PPC64_NONE;
1947
1948 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
1949 /* Initialize howto table if needed. */
1950 ppc_howto_init ();
1951
1952 switch (code)
1953 {
1954 default:
1955 return NULL;
1956
1957 case BFD_RELOC_NONE: r = R_PPC64_NONE;
1958 break;
1959 case BFD_RELOC_32: r = R_PPC64_ADDR32;
1960 break;
1961 case BFD_RELOC_PPC_BA26: r = R_PPC64_ADDR24;
1962 break;
1963 case BFD_RELOC_16: r = R_PPC64_ADDR16;
1964 break;
1965 case BFD_RELOC_LO16: r = R_PPC64_ADDR16_LO;
1966 break;
1967 case BFD_RELOC_HI16: r = R_PPC64_ADDR16_HI;
1968 break;
1969 case BFD_RELOC_HI16_S: r = R_PPC64_ADDR16_HA;
1970 break;
1971 case BFD_RELOC_PPC_BA16: r = R_PPC64_ADDR14;
1972 break;
1973 case BFD_RELOC_PPC_BA16_BRTAKEN: r = R_PPC64_ADDR14_BRTAKEN;
1974 break;
1975 case BFD_RELOC_PPC_BA16_BRNTAKEN: r = R_PPC64_ADDR14_BRNTAKEN;
1976 break;
1977 case BFD_RELOC_PPC_B26: r = R_PPC64_REL24;
1978 break;
1979 case BFD_RELOC_PPC_B16: r = R_PPC64_REL14;
1980 break;
1981 case BFD_RELOC_PPC_B16_BRTAKEN: r = R_PPC64_REL14_BRTAKEN;
1982 break;
1983 case BFD_RELOC_PPC_B16_BRNTAKEN: r = R_PPC64_REL14_BRNTAKEN;
1984 break;
1985 case BFD_RELOC_16_GOTOFF: r = R_PPC64_GOT16;
1986 break;
1987 case BFD_RELOC_LO16_GOTOFF: r = R_PPC64_GOT16_LO;
1988 break;
1989 case BFD_RELOC_HI16_GOTOFF: r = R_PPC64_GOT16_HI;
1990 break;
1991 case BFD_RELOC_HI16_S_GOTOFF: r = R_PPC64_GOT16_HA;
1992 break;
1993 case BFD_RELOC_PPC_COPY: r = R_PPC64_COPY;
1994 break;
1995 case BFD_RELOC_PPC_GLOB_DAT: r = R_PPC64_GLOB_DAT;
1996 break;
1997 case BFD_RELOC_32_PCREL: r = R_PPC64_REL32;
1998 break;
1999 case BFD_RELOC_32_PLTOFF: r = R_PPC64_PLT32;
2000 break;
2001 case BFD_RELOC_32_PLT_PCREL: r = R_PPC64_PLTREL32;
2002 break;
2003 case BFD_RELOC_LO16_PLTOFF: r = R_PPC64_PLT16_LO;
2004 break;
2005 case BFD_RELOC_HI16_PLTOFF: r = R_PPC64_PLT16_HI;
2006 break;
2007 case BFD_RELOC_HI16_S_PLTOFF: r = R_PPC64_PLT16_HA;
2008 break;
2009 case BFD_RELOC_16_BASEREL: r = R_PPC64_SECTOFF;
2010 break;
2011 case BFD_RELOC_LO16_BASEREL: r = R_PPC64_SECTOFF_LO;
2012 break;
2013 case BFD_RELOC_HI16_BASEREL: r = R_PPC64_SECTOFF_HI;
2014 break;
2015 case BFD_RELOC_HI16_S_BASEREL: r = R_PPC64_SECTOFF_HA;
2016 break;
2017 case BFD_RELOC_CTOR: r = R_PPC64_ADDR64;
2018 break;
2019 case BFD_RELOC_64: r = R_PPC64_ADDR64;
2020 break;
2021 case BFD_RELOC_PPC64_HIGHER: r = R_PPC64_ADDR16_HIGHER;
2022 break;
2023 case BFD_RELOC_PPC64_HIGHER_S: r = R_PPC64_ADDR16_HIGHERA;
2024 break;
2025 case BFD_RELOC_PPC64_HIGHEST: r = R_PPC64_ADDR16_HIGHEST;
2026 break;
2027 case BFD_RELOC_PPC64_HIGHEST_S: r = R_PPC64_ADDR16_HIGHESTA;
2028 break;
2029 case BFD_RELOC_64_PCREL: r = R_PPC64_REL64;
2030 break;
2031 case BFD_RELOC_64_PLTOFF: r = R_PPC64_PLT64;
2032 break;
2033 case BFD_RELOC_64_PLT_PCREL: r = R_PPC64_PLTREL64;
2034 break;
2035 case BFD_RELOC_PPC_TOC16: r = R_PPC64_TOC16;
2036 break;
2037 case BFD_RELOC_PPC64_TOC16_LO: r = R_PPC64_TOC16_LO;
2038 break;
2039 case BFD_RELOC_PPC64_TOC16_HI: r = R_PPC64_TOC16_HI;
2040 break;
2041 case BFD_RELOC_PPC64_TOC16_HA: r = R_PPC64_TOC16_HA;
2042 break;
2043 case BFD_RELOC_PPC64_TOC: r = R_PPC64_TOC;
2044 break;
2045 case BFD_RELOC_PPC64_PLTGOT16: r = R_PPC64_PLTGOT16;
2046 break;
2047 case BFD_RELOC_PPC64_PLTGOT16_LO: r = R_PPC64_PLTGOT16_LO;
2048 break;
2049 case BFD_RELOC_PPC64_PLTGOT16_HI: r = R_PPC64_PLTGOT16_HI;
2050 break;
2051 case BFD_RELOC_PPC64_PLTGOT16_HA: r = R_PPC64_PLTGOT16_HA;
2052 break;
2053 case BFD_RELOC_PPC64_ADDR16_DS: r = R_PPC64_ADDR16_DS;
2054 break;
2055 case BFD_RELOC_PPC64_ADDR16_LO_DS: r = R_PPC64_ADDR16_LO_DS;
2056 break;
2057 case BFD_RELOC_PPC64_GOT16_DS: r = R_PPC64_GOT16_DS;
2058 break;
2059 case BFD_RELOC_PPC64_GOT16_LO_DS: r = R_PPC64_GOT16_LO_DS;
2060 break;
2061 case BFD_RELOC_PPC64_PLT16_LO_DS: r = R_PPC64_PLT16_LO_DS;
2062 break;
2063 case BFD_RELOC_PPC64_SECTOFF_DS: r = R_PPC64_SECTOFF_DS;
2064 break;
2065 case BFD_RELOC_PPC64_SECTOFF_LO_DS: r = R_PPC64_SECTOFF_LO_DS;
2066 break;
2067 case BFD_RELOC_PPC64_TOC16_DS: r = R_PPC64_TOC16_DS;
2068 break;
2069 case BFD_RELOC_PPC64_TOC16_LO_DS: r = R_PPC64_TOC16_LO_DS;
2070 break;
2071 case BFD_RELOC_PPC64_PLTGOT16_DS: r = R_PPC64_PLTGOT16_DS;
2072 break;
2073 case BFD_RELOC_PPC64_PLTGOT16_LO_DS: r = R_PPC64_PLTGOT16_LO_DS;
2074 break;
2075 case BFD_RELOC_PPC_TLS: r = R_PPC64_TLS;
2076 break;
2077 case BFD_RELOC_PPC_TLSGD: r = R_PPC64_TLSGD;
2078 break;
2079 case BFD_RELOC_PPC_TLSLD: r = R_PPC64_TLSLD;
2080 break;
2081 case BFD_RELOC_PPC_DTPMOD: r = R_PPC64_DTPMOD64;
2082 break;
2083 case BFD_RELOC_PPC_TPREL16: r = R_PPC64_TPREL16;
2084 break;
2085 case BFD_RELOC_PPC_TPREL16_LO: r = R_PPC64_TPREL16_LO;
2086 break;
2087 case BFD_RELOC_PPC_TPREL16_HI: r = R_PPC64_TPREL16_HI;
2088 break;
2089 case BFD_RELOC_PPC_TPREL16_HA: r = R_PPC64_TPREL16_HA;
2090 break;
2091 case BFD_RELOC_PPC_TPREL: r = R_PPC64_TPREL64;
2092 break;
2093 case BFD_RELOC_PPC_DTPREL16: r = R_PPC64_DTPREL16;
2094 break;
2095 case BFD_RELOC_PPC_DTPREL16_LO: r = R_PPC64_DTPREL16_LO;
2096 break;
2097 case BFD_RELOC_PPC_DTPREL16_HI: r = R_PPC64_DTPREL16_HI;
2098 break;
2099 case BFD_RELOC_PPC_DTPREL16_HA: r = R_PPC64_DTPREL16_HA;
2100 break;
2101 case BFD_RELOC_PPC_DTPREL: r = R_PPC64_DTPREL64;
2102 break;
2103 case BFD_RELOC_PPC_GOT_TLSGD16: r = R_PPC64_GOT_TLSGD16;
2104 break;
2105 case BFD_RELOC_PPC_GOT_TLSGD16_LO: r = R_PPC64_GOT_TLSGD16_LO;
2106 break;
2107 case BFD_RELOC_PPC_GOT_TLSGD16_HI: r = R_PPC64_GOT_TLSGD16_HI;
2108 break;
2109 case BFD_RELOC_PPC_GOT_TLSGD16_HA: r = R_PPC64_GOT_TLSGD16_HA;
2110 break;
2111 case BFD_RELOC_PPC_GOT_TLSLD16: r = R_PPC64_GOT_TLSLD16;
2112 break;
2113 case BFD_RELOC_PPC_GOT_TLSLD16_LO: r = R_PPC64_GOT_TLSLD16_LO;
2114 break;
2115 case BFD_RELOC_PPC_GOT_TLSLD16_HI: r = R_PPC64_GOT_TLSLD16_HI;
2116 break;
2117 case BFD_RELOC_PPC_GOT_TLSLD16_HA: r = R_PPC64_GOT_TLSLD16_HA;
2118 break;
2119 case BFD_RELOC_PPC_GOT_TPREL16: r = R_PPC64_GOT_TPREL16_DS;
2120 break;
2121 case BFD_RELOC_PPC_GOT_TPREL16_LO: r = R_PPC64_GOT_TPREL16_LO_DS;
2122 break;
2123 case BFD_RELOC_PPC_GOT_TPREL16_HI: r = R_PPC64_GOT_TPREL16_HI;
2124 break;
2125 case BFD_RELOC_PPC_GOT_TPREL16_HA: r = R_PPC64_GOT_TPREL16_HA;
2126 break;
2127 case BFD_RELOC_PPC_GOT_DTPREL16: r = R_PPC64_GOT_DTPREL16_DS;
2128 break;
2129 case BFD_RELOC_PPC_GOT_DTPREL16_LO: r = R_PPC64_GOT_DTPREL16_LO_DS;
2130 break;
2131 case BFD_RELOC_PPC_GOT_DTPREL16_HI: r = R_PPC64_GOT_DTPREL16_HI;
2132 break;
2133 case BFD_RELOC_PPC_GOT_DTPREL16_HA: r = R_PPC64_GOT_DTPREL16_HA;
2134 break;
2135 case BFD_RELOC_PPC64_TPREL16_DS: r = R_PPC64_TPREL16_DS;
2136 break;
2137 case BFD_RELOC_PPC64_TPREL16_LO_DS: r = R_PPC64_TPREL16_LO_DS;
2138 break;
2139 case BFD_RELOC_PPC64_TPREL16_HIGHER: r = R_PPC64_TPREL16_HIGHER;
2140 break;
2141 case BFD_RELOC_PPC64_TPREL16_HIGHERA: r = R_PPC64_TPREL16_HIGHERA;
2142 break;
2143 case BFD_RELOC_PPC64_TPREL16_HIGHEST: r = R_PPC64_TPREL16_HIGHEST;
2144 break;
2145 case BFD_RELOC_PPC64_TPREL16_HIGHESTA: r = R_PPC64_TPREL16_HIGHESTA;
2146 break;
2147 case BFD_RELOC_PPC64_DTPREL16_DS: r = R_PPC64_DTPREL16_DS;
2148 break;
2149 case BFD_RELOC_PPC64_DTPREL16_LO_DS: r = R_PPC64_DTPREL16_LO_DS;
2150 break;
2151 case BFD_RELOC_PPC64_DTPREL16_HIGHER: r = R_PPC64_DTPREL16_HIGHER;
2152 break;
2153 case BFD_RELOC_PPC64_DTPREL16_HIGHERA: r = R_PPC64_DTPREL16_HIGHERA;
2154 break;
2155 case BFD_RELOC_PPC64_DTPREL16_HIGHEST: r = R_PPC64_DTPREL16_HIGHEST;
2156 break;
2157 case BFD_RELOC_PPC64_DTPREL16_HIGHESTA: r = R_PPC64_DTPREL16_HIGHESTA;
2158 break;
2159 case BFD_RELOC_VTABLE_INHERIT: r = R_PPC64_GNU_VTINHERIT;
2160 break;
2161 case BFD_RELOC_VTABLE_ENTRY: r = R_PPC64_GNU_VTENTRY;
2162 break;
2163 }
2164
2165 return ppc64_elf_howto_table[r];
2166 };
2167
2168 static reloc_howto_type *
2169 ppc64_elf_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2170 const char *r_name)
2171 {
2172 unsigned int i;
2173
2174 for (i = 0;
2175 i < sizeof (ppc64_elf_howto_raw) / sizeof (ppc64_elf_howto_raw[0]);
2176 i++)
2177 if (ppc64_elf_howto_raw[i].name != NULL
2178 && strcasecmp (ppc64_elf_howto_raw[i].name, r_name) == 0)
2179 return &ppc64_elf_howto_raw[i];
2180
2181 return NULL;
2182 }
2183
2184 /* Set the howto pointer for a PowerPC ELF reloc. */
2185
2186 static void
2187 ppc64_elf_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr,
2188 Elf_Internal_Rela *dst)
2189 {
2190 unsigned int type;
2191
2192 /* Initialize howto table if needed. */
2193 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2194 ppc_howto_init ();
2195
2196 type = ELF64_R_TYPE (dst->r_info);
2197 if (type >= (sizeof (ppc64_elf_howto_table)
2198 / sizeof (ppc64_elf_howto_table[0])))
2199 {
2200 (*_bfd_error_handler) (_("%B: invalid relocation type %d"),
2201 abfd, (int) type);
2202 type = R_PPC64_NONE;
2203 }
2204 cache_ptr->howto = ppc64_elf_howto_table[type];
2205 }
2206
2207 /* Handle the R_PPC64_ADDR16_HA and similar relocs. */
2208
2209 static bfd_reloc_status_type
2210 ppc64_elf_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2211 void *data, asection *input_section,
2212 bfd *output_bfd, char **error_message)
2213 {
2214 /* If this is a relocatable link (output_bfd test tells us), just
2215 call the generic function. Any adjustment will be done at final
2216 link time. */
2217 if (output_bfd != NULL)
2218 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2219 input_section, output_bfd, error_message);
2220
2221 /* Adjust the addend for sign extension of the low 16 bits.
2222 We won't actually be using the low 16 bits, so trashing them
2223 doesn't matter. */
2224 reloc_entry->addend += 0x8000;
2225 return bfd_reloc_continue;
2226 }
2227
2228 static bfd_reloc_status_type
2229 ppc64_elf_branch_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2230 void *data, asection *input_section,
2231 bfd *output_bfd, char **error_message)
2232 {
2233 if (output_bfd != NULL)
2234 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2235 input_section, output_bfd, error_message);
2236
2237 if (strcmp (symbol->section->name, ".opd") == 0
2238 && (symbol->section->owner->flags & DYNAMIC) == 0)
2239 {
2240 bfd_vma dest = opd_entry_value (symbol->section,
2241 symbol->value + reloc_entry->addend,
2242 NULL, NULL);
2243 if (dest != (bfd_vma) -1)
2244 reloc_entry->addend = dest - (symbol->value
2245 + symbol->section->output_section->vma
2246 + symbol->section->output_offset);
2247 }
2248 return bfd_reloc_continue;
2249 }
2250
2251 static bfd_reloc_status_type
2252 ppc64_elf_brtaken_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2253 void *data, asection *input_section,
2254 bfd *output_bfd, char **error_message)
2255 {
2256 long insn;
2257 enum elf_ppc64_reloc_type r_type;
2258 bfd_size_type octets;
2259 /* Disabled until we sort out how ld should choose 'y' vs 'at'. */
2260 bfd_boolean is_power4 = FALSE;
2261
2262 /* If this is a relocatable link (output_bfd test tells us), just
2263 call the generic function. Any adjustment will be done at final
2264 link time. */
2265 if (output_bfd != NULL)
2266 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2267 input_section, output_bfd, error_message);
2268
2269 octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2270 insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
2271 insn &= ~(0x01 << 21);
2272 r_type = reloc_entry->howto->type;
2273 if (r_type == R_PPC64_ADDR14_BRTAKEN
2274 || r_type == R_PPC64_REL14_BRTAKEN)
2275 insn |= 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field. */
2276
2277 if (is_power4)
2278 {
2279 /* Set 'a' bit. This is 0b00010 in BO field for branch
2280 on CR(BI) insns (BO == 001at or 011at), and 0b01000
2281 for branch on CTR insns (BO == 1a00t or 1a01t). */
2282 if ((insn & (0x14 << 21)) == (0x04 << 21))
2283 insn |= 0x02 << 21;
2284 else if ((insn & (0x14 << 21)) == (0x10 << 21))
2285 insn |= 0x08 << 21;
2286 else
2287 goto out;
2288 }
2289 else
2290 {
2291 bfd_vma target = 0;
2292 bfd_vma from;
2293
2294 if (!bfd_is_com_section (symbol->section))
2295 target = symbol->value;
2296 target += symbol->section->output_section->vma;
2297 target += symbol->section->output_offset;
2298 target += reloc_entry->addend;
2299
2300 from = (reloc_entry->address
2301 + input_section->output_offset
2302 + input_section->output_section->vma);
2303
2304 /* Invert 'y' bit if not the default. */
2305 if ((bfd_signed_vma) (target - from) < 0)
2306 insn ^= 0x01 << 21;
2307 }
2308 bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
2309 out:
2310 return ppc64_elf_branch_reloc (abfd, reloc_entry, symbol, data,
2311 input_section, output_bfd, error_message);
2312 }
2313
2314 static bfd_reloc_status_type
2315 ppc64_elf_sectoff_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2316 void *data, asection *input_section,
2317 bfd *output_bfd, char **error_message)
2318 {
2319 /* If this is a relocatable link (output_bfd test tells us), just
2320 call the generic function. Any adjustment will be done at final
2321 link time. */
2322 if (output_bfd != NULL)
2323 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2324 input_section, output_bfd, error_message);
2325
2326 /* Subtract the symbol section base address. */
2327 reloc_entry->addend -= symbol->section->output_section->vma;
2328 return bfd_reloc_continue;
2329 }
2330
2331 static bfd_reloc_status_type
2332 ppc64_elf_sectoff_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2333 void *data, asection *input_section,
2334 bfd *output_bfd, char **error_message)
2335 {
2336 /* If this is a relocatable link (output_bfd test tells us), just
2337 call the generic function. Any adjustment will be done at final
2338 link time. */
2339 if (output_bfd != NULL)
2340 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2341 input_section, output_bfd, error_message);
2342
2343 /* Subtract the symbol section base address. */
2344 reloc_entry->addend -= symbol->section->output_section->vma;
2345
2346 /* Adjust the addend for sign extension of the low 16 bits. */
2347 reloc_entry->addend += 0x8000;
2348 return bfd_reloc_continue;
2349 }
2350
2351 static bfd_reloc_status_type
2352 ppc64_elf_toc_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2353 void *data, asection *input_section,
2354 bfd *output_bfd, char **error_message)
2355 {
2356 bfd_vma TOCstart;
2357
2358 /* If this is a relocatable link (output_bfd test tells us), just
2359 call the generic function. Any adjustment will be done at final
2360 link time. */
2361 if (output_bfd != NULL)
2362 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2363 input_section, output_bfd, error_message);
2364
2365 TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2366 if (TOCstart == 0)
2367 TOCstart = ppc64_elf_toc (input_section->output_section->owner);
2368
2369 /* Subtract the TOC base address. */
2370 reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2371 return bfd_reloc_continue;
2372 }
2373
2374 static bfd_reloc_status_type
2375 ppc64_elf_toc_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2376 void *data, asection *input_section,
2377 bfd *output_bfd, char **error_message)
2378 {
2379 bfd_vma TOCstart;
2380
2381 /* If this is a relocatable link (output_bfd test tells us), just
2382 call the generic function. Any adjustment will be done at final
2383 link time. */
2384 if (output_bfd != NULL)
2385 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2386 input_section, output_bfd, error_message);
2387
2388 TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2389 if (TOCstart == 0)
2390 TOCstart = ppc64_elf_toc (input_section->output_section->owner);
2391
2392 /* Subtract the TOC base address. */
2393 reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2394
2395 /* Adjust the addend for sign extension of the low 16 bits. */
2396 reloc_entry->addend += 0x8000;
2397 return bfd_reloc_continue;
2398 }
2399
2400 static bfd_reloc_status_type
2401 ppc64_elf_toc64_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2402 void *data, asection *input_section,
2403 bfd *output_bfd, char **error_message)
2404 {
2405 bfd_vma TOCstart;
2406 bfd_size_type octets;
2407
2408 /* If this is a relocatable link (output_bfd test tells us), just
2409 call the generic function. Any adjustment will be done at final
2410 link time. */
2411 if (output_bfd != NULL)
2412 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2413 input_section, output_bfd, error_message);
2414
2415 TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2416 if (TOCstart == 0)
2417 TOCstart = ppc64_elf_toc (input_section->output_section->owner);
2418
2419 octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2420 bfd_put_64 (abfd, TOCstart + TOC_BASE_OFF, (bfd_byte *) data + octets);
2421 return bfd_reloc_ok;
2422 }
2423
2424 static bfd_reloc_status_type
2425 ppc64_elf_unhandled_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2426 void *data, asection *input_section,
2427 bfd *output_bfd, char **error_message)
2428 {
2429 /* If this is a relocatable link (output_bfd test tells us), just
2430 call the generic function. Any adjustment will be done at final
2431 link time. */
2432 if (output_bfd != NULL)
2433 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2434 input_section, output_bfd, error_message);
2435
2436 if (error_message != NULL)
2437 {
2438 static char buf[60];
2439 sprintf (buf, "generic linker can't handle %s",
2440 reloc_entry->howto->name);
2441 *error_message = buf;
2442 }
2443 return bfd_reloc_dangerous;
2444 }
2445
2446 struct ppc64_elf_obj_tdata
2447 {
2448 struct elf_obj_tdata elf;
2449
2450 /* Shortcuts to dynamic linker sections. */
2451 asection *got;
2452 asection *relgot;
2453
2454 /* Used during garbage collection. We attach global symbols defined
2455 on removed .opd entries to this section so that the sym is removed. */
2456 asection *deleted_section;
2457
2458 /* TLS local dynamic got entry handling. Suppose for multiple GOT
2459 sections means we potentially need one of these for each input bfd. */
2460 union {
2461 bfd_signed_vma refcount;
2462 bfd_vma offset;
2463 } tlsld_got;
2464
2465 /* A copy of relocs before they are modified for --emit-relocs. */
2466 Elf_Internal_Rela *opd_relocs;
2467 };
2468
2469 #define ppc64_elf_tdata(bfd) \
2470 ((struct ppc64_elf_obj_tdata *) (bfd)->tdata.any)
2471
2472 #define ppc64_tlsld_got(bfd) \
2473 (&ppc64_elf_tdata (bfd)->tlsld_got)
2474
2475 #define is_ppc64_elf(bfd) \
2476 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
2477 && elf_object_id (bfd) == PPC64_ELF_TDATA)
2478
2479 /* Override the generic function because we store some extras. */
2480
2481 static bfd_boolean
2482 ppc64_elf_mkobject (bfd *abfd)
2483 {
2484 return bfd_elf_allocate_object (abfd, sizeof (struct ppc64_elf_obj_tdata),
2485 PPC64_ELF_TDATA);
2486 }
2487
2488 /* Fix bad default arch selected for a 64 bit input bfd when the
2489 default is 32 bit. */
2490
2491 static bfd_boolean
2492 ppc64_elf_object_p (bfd *abfd)
2493 {
2494 if (abfd->arch_info->the_default && abfd->arch_info->bits_per_word == 32)
2495 {
2496 Elf_Internal_Ehdr *i_ehdr = elf_elfheader (abfd);
2497
2498 if (i_ehdr->e_ident[EI_CLASS] == ELFCLASS64)
2499 {
2500 /* Relies on arch after 32 bit default being 64 bit default. */
2501 abfd->arch_info = abfd->arch_info->next;
2502 BFD_ASSERT (abfd->arch_info->bits_per_word == 64);
2503 }
2504 }
2505 return TRUE;
2506 }
2507
2508 /* Support for core dump NOTE sections. */
2509
2510 static bfd_boolean
2511 ppc64_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
2512 {
2513 size_t offset, size;
2514
2515 if (note->descsz != 504)
2516 return FALSE;
2517
2518 /* pr_cursig */
2519 elf_tdata (abfd)->core_signal = bfd_get_16 (abfd, note->descdata + 12);
2520
2521 /* pr_pid */
2522 elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, note->descdata + 32);
2523
2524 /* pr_reg */
2525 offset = 112;
2526 size = 384;
2527
2528 /* Make a ".reg/999" section. */
2529 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
2530 size, note->descpos + offset);
2531 }
2532
2533 static bfd_boolean
2534 ppc64_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
2535 {
2536 if (note->descsz != 136)
2537 return FALSE;
2538
2539 elf_tdata (abfd)->core_program
2540 = _bfd_elfcore_strndup (abfd, note->descdata + 40, 16);
2541 elf_tdata (abfd)->core_command
2542 = _bfd_elfcore_strndup (abfd, note->descdata + 56, 80);
2543
2544 return TRUE;
2545 }
2546
2547 static char *
2548 ppc64_elf_write_core_note (bfd *abfd, char *buf, int *bufsiz, int note_type,
2549 ...)
2550 {
2551 switch (note_type)
2552 {
2553 default:
2554 return NULL;
2555
2556 case NT_PRPSINFO:
2557 {
2558 char data[136];
2559 va_list ap;
2560
2561 va_start (ap, note_type);
2562 memset (data, 0, 40);
2563 strncpy (data + 40, va_arg (ap, const char *), 16);
2564 strncpy (data + 56, va_arg (ap, const char *), 80);
2565 va_end (ap);
2566 return elfcore_write_note (abfd, buf, bufsiz,
2567 "CORE", note_type, data, sizeof (data));
2568 }
2569
2570 case NT_PRSTATUS:
2571 {
2572 char data[504];
2573 va_list ap;
2574 long pid;
2575 int cursig;
2576 const void *greg;
2577
2578 va_start (ap, note_type);
2579 memset (data, 0, 112);
2580 pid = va_arg (ap, long);
2581 bfd_put_32 (abfd, pid, data + 32);
2582 cursig = va_arg (ap, int);
2583 bfd_put_16 (abfd, cursig, data + 12);
2584 greg = va_arg (ap, const void *);
2585 memcpy (data + 112, greg, 384);
2586 memset (data + 496, 0, 8);
2587 va_end (ap);
2588 return elfcore_write_note (abfd, buf, bufsiz,
2589 "CORE", note_type, data, sizeof (data));
2590 }
2591 }
2592 }
2593
2594 /* Merge backend specific data from an object file to the output
2595 object file when linking. */
2596
2597 static bfd_boolean
2598 ppc64_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
2599 {
2600 /* Check if we have the same endianess. */
2601 if (ibfd->xvec->byteorder != obfd->xvec->byteorder
2602 && ibfd->xvec->byteorder != BFD_ENDIAN_UNKNOWN
2603 && obfd->xvec->byteorder != BFD_ENDIAN_UNKNOWN)
2604 {
2605 const char *msg;
2606
2607 if (bfd_big_endian (ibfd))
2608 msg = _("%B: compiled for a big endian system "
2609 "and target is little endian");
2610 else
2611 msg = _("%B: compiled for a little endian system "
2612 "and target is big endian");
2613
2614 (*_bfd_error_handler) (msg, ibfd);
2615
2616 bfd_set_error (bfd_error_wrong_format);
2617 return FALSE;
2618 }
2619
2620 return TRUE;
2621 }
2622
2623 /* Add extra PPC sections. */
2624
2625 static const struct bfd_elf_special_section ppc64_elf_special_sections[]=
2626 {
2627 { STRING_COMMA_LEN (".plt"), 0, SHT_NOBITS, 0 },
2628 { STRING_COMMA_LEN (".sbss"), -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE },
2629 { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2630 { STRING_COMMA_LEN (".toc"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2631 { STRING_COMMA_LEN (".toc1"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2632 { STRING_COMMA_LEN (".tocbss"), 0, SHT_NOBITS, SHF_ALLOC + SHF_WRITE },
2633 { NULL, 0, 0, 0, 0 }
2634 };
2635
2636 enum _ppc64_sec_type {
2637 sec_normal = 0,
2638 sec_opd = 1,
2639 sec_toc = 2
2640 };
2641
2642 struct _ppc64_elf_section_data
2643 {
2644 struct bfd_elf_section_data elf;
2645
2646 union
2647 {
2648 /* An array with one entry for each opd function descriptor. */
2649 struct _opd_sec_data
2650 {
2651 /* Points to the function code section for local opd entries. */
2652 asection **func_sec;
2653
2654 /* After editing .opd, adjust references to opd local syms. */
2655 long *adjust;
2656 } opd;
2657
2658 /* An array for toc sections, indexed by offset/8. */
2659 struct _toc_sec_data
2660 {
2661 /* Specifies the relocation symbol index used at a given toc offset. */
2662 unsigned *symndx;
2663
2664 /* And the relocation addend. */
2665 bfd_vma *add;
2666 } toc;
2667 } u;
2668
2669 enum _ppc64_sec_type sec_type:2;
2670
2671 /* Flag set when small branches are detected. Used to
2672 select suitable defaults for the stub group size. */
2673 unsigned int has_14bit_branch:1;
2674 };
2675
2676 #define ppc64_elf_section_data(sec) \
2677 ((struct _ppc64_elf_section_data *) elf_section_data (sec))
2678
2679 static bfd_boolean
2680 ppc64_elf_new_section_hook (bfd *abfd, asection *sec)
2681 {
2682 if (!sec->used_by_bfd)
2683 {
2684 struct _ppc64_elf_section_data *sdata;
2685 bfd_size_type amt = sizeof (*sdata);
2686
2687 sdata = bfd_zalloc (abfd, amt);
2688 if (sdata == NULL)
2689 return FALSE;
2690 sec->used_by_bfd = sdata;
2691 }
2692
2693 return _bfd_elf_new_section_hook (abfd, sec);
2694 }
2695
2696 static struct _opd_sec_data *
2697 get_opd_info (asection * sec)
2698 {
2699 if (sec != NULL
2700 && ppc64_elf_section_data (sec) != NULL
2701 && ppc64_elf_section_data (sec)->sec_type == sec_opd)
2702 return &ppc64_elf_section_data (sec)->u.opd;
2703 return NULL;
2704 }
2705 \f
2706 /* Parameters for the qsort hook. */
2707 static bfd_boolean synthetic_relocatable;
2708
2709 /* qsort comparison function for ppc64_elf_get_synthetic_symtab. */
2710
2711 static int
2712 compare_symbols (const void *ap, const void *bp)
2713 {
2714 const asymbol *a = * (const asymbol **) ap;
2715 const asymbol *b = * (const asymbol **) bp;
2716
2717 /* Section symbols first. */
2718 if ((a->flags & BSF_SECTION_SYM) && !(b->flags & BSF_SECTION_SYM))
2719 return -1;
2720 if (!(a->flags & BSF_SECTION_SYM) && (b->flags & BSF_SECTION_SYM))
2721 return 1;
2722
2723 /* then .opd symbols. */
2724 if (strcmp (a->section->name, ".opd") == 0
2725 && strcmp (b->section->name, ".opd") != 0)
2726 return -1;
2727 if (strcmp (a->section->name, ".opd") != 0
2728 && strcmp (b->section->name, ".opd") == 0)
2729 return 1;
2730
2731 /* then other code symbols. */
2732 if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
2733 == (SEC_CODE | SEC_ALLOC)
2734 && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
2735 != (SEC_CODE | SEC_ALLOC))
2736 return -1;
2737
2738 if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
2739 != (SEC_CODE | SEC_ALLOC)
2740 && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
2741 == (SEC_CODE | SEC_ALLOC))
2742 return 1;
2743
2744 if (synthetic_relocatable)
2745 {
2746 if (a->section->id < b->section->id)
2747 return -1;
2748
2749 if (a->section->id > b->section->id)
2750 return 1;
2751 }
2752
2753 if (a->value + a->section->vma < b->value + b->section->vma)
2754 return -1;
2755
2756 if (a->value + a->section->vma > b->value + b->section->vma)
2757 return 1;
2758
2759 /* For syms with the same value, prefer strong dynamic global function
2760 syms over other syms. */
2761 if ((a->flags & BSF_GLOBAL) != 0 && (b->flags & BSF_GLOBAL) == 0)
2762 return -1;
2763
2764 if ((a->flags & BSF_GLOBAL) == 0 && (b->flags & BSF_GLOBAL) != 0)
2765 return 1;
2766
2767 if ((a->flags & BSF_FUNCTION) != 0 && (b->flags & BSF_FUNCTION) == 0)
2768 return -1;
2769
2770 if ((a->flags & BSF_FUNCTION) == 0 && (b->flags & BSF_FUNCTION) != 0)
2771 return 1;
2772
2773 if ((a->flags & BSF_WEAK) == 0 && (b->flags & BSF_WEAK) != 0)
2774 return -1;
2775
2776 if ((a->flags & BSF_WEAK) != 0 && (b->flags & BSF_WEAK) == 0)
2777 return 1;
2778
2779 if ((a->flags & BSF_DYNAMIC) != 0 && (b->flags & BSF_DYNAMIC) == 0)
2780 return -1;
2781
2782 if ((a->flags & BSF_DYNAMIC) == 0 && (b->flags & BSF_DYNAMIC) != 0)
2783 return 1;
2784
2785 return 0;
2786 }
2787
2788 /* Search SYMS for a symbol of the given VALUE. */
2789
2790 static asymbol *
2791 sym_exists_at (asymbol **syms, long lo, long hi, int id, bfd_vma value)
2792 {
2793 long mid;
2794
2795 if (id == -1)
2796 {
2797 while (lo < hi)
2798 {
2799 mid = (lo + hi) >> 1;
2800 if (syms[mid]->value + syms[mid]->section->vma < value)
2801 lo = mid + 1;
2802 else if (syms[mid]->value + syms[mid]->section->vma > value)
2803 hi = mid;
2804 else
2805 return syms[mid];
2806 }
2807 }
2808 else
2809 {
2810 while (lo < hi)
2811 {
2812 mid = (lo + hi) >> 1;
2813 if (syms[mid]->section->id < id)
2814 lo = mid + 1;
2815 else if (syms[mid]->section->id > id)
2816 hi = mid;
2817 else if (syms[mid]->value < value)
2818 lo = mid + 1;
2819 else if (syms[mid]->value > value)
2820 hi = mid;
2821 else
2822 return syms[mid];
2823 }
2824 }
2825 return NULL;
2826 }
2827
2828 static bfd_boolean
2829 section_covers_vma (bfd *abfd ATTRIBUTE_UNUSED, asection *section, void *ptr)
2830 {
2831 bfd_vma vma = *(bfd_vma *) ptr;
2832 return ((section->flags & SEC_ALLOC) != 0
2833 && section->vma <= vma
2834 && vma < section->vma + section->size);
2835 }
2836
2837 /* Create synthetic symbols, effectively restoring "dot-symbol" function
2838 entry syms. Also generate @plt symbols for the glink branch table. */
2839
2840 static long
2841 ppc64_elf_get_synthetic_symtab (bfd *abfd,
2842 long static_count, asymbol **static_syms,
2843 long dyn_count, asymbol **dyn_syms,
2844 asymbol **ret)
2845 {
2846 asymbol *s;
2847 long i;
2848 long count;
2849 char *names;
2850 long symcount, codesecsym, codesecsymend, secsymend, opdsymend;
2851 asection *opd;
2852 bfd_boolean relocatable = (abfd->flags & (EXEC_P | DYNAMIC)) == 0;
2853 asymbol **syms;
2854
2855 *ret = NULL;
2856
2857 opd = bfd_get_section_by_name (abfd, ".opd");
2858 if (opd == NULL)
2859 return 0;
2860
2861 symcount = static_count;
2862 if (!relocatable)
2863 symcount += dyn_count;
2864 if (symcount == 0)
2865 return 0;
2866
2867 syms = bfd_malloc ((symcount + 1) * sizeof (*syms));
2868 if (syms == NULL)
2869 return -1;
2870
2871 if (!relocatable && static_count != 0 && dyn_count != 0)
2872 {
2873 /* Use both symbol tables. */
2874 memcpy (syms, static_syms, static_count * sizeof (*syms));
2875 memcpy (syms + static_count, dyn_syms, (dyn_count + 1) * sizeof (*syms));
2876 }
2877 else if (!relocatable && static_count == 0)
2878 memcpy (syms, dyn_syms, (symcount + 1) * sizeof (*syms));
2879 else
2880 memcpy (syms, static_syms, (symcount + 1) * sizeof (*syms));
2881
2882 synthetic_relocatable = relocatable;
2883 qsort (syms, symcount, sizeof (*syms), compare_symbols);
2884
2885 if (!relocatable && symcount > 1)
2886 {
2887 long j;
2888 /* Trim duplicate syms, since we may have merged the normal and
2889 dynamic symbols. Actually, we only care about syms that have
2890 different values, so trim any with the same value. */
2891 for (i = 1, j = 1; i < symcount; ++i)
2892 if (syms[i - 1]->value + syms[i - 1]->section->vma
2893 != syms[i]->value + syms[i]->section->vma)
2894 syms[j++] = syms[i];
2895 symcount = j;
2896 }
2897
2898 i = 0;
2899 if (strcmp (syms[i]->section->name, ".opd") == 0)
2900 ++i;
2901 codesecsym = i;
2902
2903 for (; i < symcount; ++i)
2904 if (((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
2905 != (SEC_CODE | SEC_ALLOC))
2906 || (syms[i]->flags & BSF_SECTION_SYM) == 0)
2907 break;
2908 codesecsymend = i;
2909
2910 for (; i < symcount; ++i)
2911 if ((syms[i]->flags & BSF_SECTION_SYM) == 0)
2912 break;
2913 secsymend = i;
2914
2915 for (; i < symcount; ++i)
2916 if (strcmp (syms[i]->section->name, ".opd") != 0)
2917 break;
2918 opdsymend = i;
2919
2920 for (; i < symcount; ++i)
2921 if ((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
2922 != (SEC_CODE | SEC_ALLOC))
2923 break;
2924 symcount = i;
2925
2926 count = 0;
2927
2928 if (relocatable)
2929 {
2930 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
2931 arelent *r;
2932 size_t size;
2933 long relcount;
2934
2935 if (opdsymend == secsymend)
2936 goto done;
2937
2938 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
2939 relcount = (opd->flags & SEC_RELOC) ? opd->reloc_count : 0;
2940 if (relcount == 0)
2941 goto done;
2942
2943 if (!(*slurp_relocs) (abfd, opd, static_syms, FALSE))
2944 {
2945 count = -1;
2946 goto done;
2947 }
2948
2949 size = 0;
2950 for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
2951 {
2952 asymbol *sym;
2953
2954 while (r < opd->relocation + relcount
2955 && r->address < syms[i]->value + opd->vma)
2956 ++r;
2957
2958 if (r == opd->relocation + relcount)
2959 break;
2960
2961 if (r->address != syms[i]->value + opd->vma)
2962 continue;
2963
2964 if (r->howto->type != R_PPC64_ADDR64)
2965 continue;
2966
2967 sym = *r->sym_ptr_ptr;
2968 if (!sym_exists_at (syms, opdsymend, symcount,
2969 sym->section->id, sym->value + r->addend))
2970 {
2971 ++count;
2972 size += sizeof (asymbol);
2973 size += strlen (syms[i]->name) + 2;
2974 }
2975 }
2976
2977 s = *ret = bfd_malloc (size);
2978 if (s == NULL)
2979 {
2980 count = -1;
2981 goto done;
2982 }
2983
2984 names = (char *) (s + count);
2985
2986 for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
2987 {
2988 asymbol *sym;
2989
2990 while (r < opd->relocation + relcount
2991 && r->address < syms[i]->value + opd->vma)
2992 ++r;
2993
2994 if (r == opd->relocation + relcount)
2995 break;
2996
2997 if (r->address != syms[i]->value + opd->vma)
2998 continue;
2999
3000 if (r->howto->type != R_PPC64_ADDR64)
3001 continue;
3002
3003 sym = *r->sym_ptr_ptr;
3004 if (!sym_exists_at (syms, opdsymend, symcount,
3005 sym->section->id, sym->value + r->addend))
3006 {
3007 size_t len;
3008
3009 *s = *syms[i];
3010 s->flags |= BSF_SYNTHETIC;
3011 s->section = sym->section;
3012 s->value = sym->value + r->addend;
3013 s->name = names;
3014 *names++ = '.';
3015 len = strlen (syms[i]->name);
3016 memcpy (names, syms[i]->name, len + 1);
3017 names += len + 1;
3018 /* Have udata.p point back to the original symbol this
3019 synthetic symbol was derived from. */
3020 s->udata.p = syms[i];
3021 s++;
3022 }
3023 }
3024 }
3025 else
3026 {
3027 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3028 bfd_byte *contents;
3029 size_t size;
3030 long plt_count = 0;
3031 bfd_vma glink_vma = 0, resolv_vma = 0;
3032 asection *dynamic, *glink = NULL, *relplt = NULL;
3033 arelent *p;
3034
3035 if (!bfd_malloc_and_get_section (abfd, opd, &contents))
3036 {
3037 if (contents)
3038 {
3039 free_contents_and_exit:
3040 free (contents);
3041 }
3042 count = -1;
3043 goto done;
3044 }
3045
3046 size = 0;
3047 for (i = secsymend; i < opdsymend; ++i)
3048 {
3049 bfd_vma ent;
3050
3051 /* Ignore bogus symbols. */
3052 if (syms[i]->value > opd->size - 8)
3053 continue;
3054
3055 ent = bfd_get_64 (abfd, contents + syms[i]->value);
3056 if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3057 {
3058 ++count;
3059 size += sizeof (asymbol);
3060 size += strlen (syms[i]->name) + 2;
3061 }
3062 }
3063
3064 /* Get start of .glink stubs from DT_PPC64_GLINK. */
3065 if (dyn_count != 0
3066 && (dynamic = bfd_get_section_by_name (abfd, ".dynamic")) != NULL)
3067 {
3068 bfd_byte *dynbuf, *extdyn, *extdynend;
3069 size_t extdynsize;
3070 void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *);
3071
3072 if (!bfd_malloc_and_get_section (abfd, dynamic, &dynbuf))
3073 goto free_contents_and_exit;
3074
3075 extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
3076 swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
3077
3078 extdyn = dynbuf;
3079 extdynend = extdyn + dynamic->size;
3080 for (; extdyn < extdynend; extdyn += extdynsize)
3081 {
3082 Elf_Internal_Dyn dyn;
3083 (*swap_dyn_in) (abfd, extdyn, &dyn);
3084
3085 if (dyn.d_tag == DT_NULL)
3086 break;
3087
3088 if (dyn.d_tag == DT_PPC64_GLINK)
3089 {
3090 /* The first glink stub starts at offset 32; see comment in
3091 ppc64_elf_finish_dynamic_sections. */
3092 glink_vma = dyn.d_un.d_val + 32;
3093 /* The .glink section usually does not survive the final
3094 link; search for the section (usually .text) where the
3095 glink stubs now reside. */
3096 glink = bfd_sections_find_if (abfd, section_covers_vma,
3097 &glink_vma);
3098 break;
3099 }
3100 }
3101
3102 free (dynbuf);
3103 }
3104
3105 if (glink != NULL)
3106 {
3107 /* Determine __glink trampoline by reading the relative branch
3108 from the first glink stub. */
3109 bfd_byte buf[4];
3110 if (bfd_get_section_contents (abfd, glink, buf,
3111 glink_vma + 4 - glink->vma, 4))
3112 {
3113 unsigned int insn = bfd_get_32 (abfd, buf);
3114 insn ^= B_DOT;
3115 if ((insn & ~0x3fffffc) == 0)
3116 resolv_vma = glink_vma + 4 + (insn ^ 0x2000000) - 0x2000000;
3117 }
3118
3119 if (resolv_vma)
3120 size += sizeof (asymbol) + sizeof ("__glink_PLTresolve");
3121
3122 relplt = bfd_get_section_by_name (abfd, ".rela.plt");
3123 if (relplt != NULL)
3124 {
3125 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3126 if (! (*slurp_relocs) (abfd, relplt, dyn_syms, TRUE))
3127 goto free_contents_and_exit;
3128
3129 plt_count = relplt->size / sizeof (Elf64_External_Rela);
3130 size += plt_count * sizeof (asymbol);
3131
3132 p = relplt->relocation;
3133 for (i = 0; i < plt_count; i++, p++)
3134 {
3135 size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
3136 if (p->addend != 0)
3137 size += sizeof ("+0x") - 1 + 16;
3138 }
3139 }
3140 }
3141
3142 s = *ret = bfd_malloc (size);
3143 if (s == NULL)
3144 goto free_contents_and_exit;
3145
3146 names = (char *) (s + count + plt_count + (resolv_vma != 0));
3147
3148 for (i = secsymend; i < opdsymend; ++i)
3149 {
3150 bfd_vma ent;
3151
3152 if (syms[i]->value > opd->size - 8)
3153 continue;
3154
3155 ent = bfd_get_64 (abfd, contents + syms[i]->value);
3156 if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3157 {
3158 long lo, hi;
3159 size_t len;
3160 asection *sec = abfd->sections;
3161
3162 *s = *syms[i];
3163 lo = codesecsym;
3164 hi = codesecsymend;
3165 while (lo < hi)
3166 {
3167 long mid = (lo + hi) >> 1;
3168 if (syms[mid]->section->vma < ent)
3169 lo = mid + 1;
3170 else if (syms[mid]->section->vma > ent)
3171 hi = mid;
3172 else
3173 {
3174 sec = syms[mid]->section;
3175 break;
3176 }
3177 }
3178
3179 if (lo >= hi && lo > codesecsym)
3180 sec = syms[lo - 1]->section;
3181
3182 for (; sec != NULL; sec = sec->next)
3183 {
3184 if (sec->vma > ent)
3185 break;
3186 if ((sec->flags & SEC_ALLOC) == 0
3187 || (sec->flags & SEC_LOAD) == 0)
3188 break;
3189 if ((sec->flags & SEC_CODE) != 0)
3190 s->section = sec;
3191 }
3192 s->flags |= BSF_SYNTHETIC;
3193 s->value = ent - s->section->vma;
3194 s->name = names;
3195 *names++ = '.';
3196 len = strlen (syms[i]->name);
3197 memcpy (names, syms[i]->name, len + 1);
3198 names += len + 1;
3199 /* Have udata.p point back to the original symbol this
3200 synthetic symbol was derived from. */
3201 s->udata.p = syms[i];
3202 s++;
3203 }
3204 }
3205 free (contents);
3206
3207 if (glink != NULL && relplt != NULL)
3208 {
3209 if (resolv_vma)
3210 {
3211 /* Add a symbol for the main glink trampoline. */
3212 memset (s, 0, sizeof *s);
3213 s->the_bfd = abfd;
3214 s->flags = BSF_GLOBAL | BSF_SYNTHETIC;
3215 s->section = glink;
3216 s->value = resolv_vma - glink->vma;
3217 s->name = names;
3218 memcpy (names, "__glink_PLTresolve", sizeof ("__glink_PLTresolve"));
3219 names += sizeof ("__glink_PLTresolve");
3220 s++;
3221 count++;
3222 }
3223
3224 /* FIXME: It would be very much nicer to put sym@plt on the
3225 stub rather than on the glink branch table entry. The
3226 objdump disassembler would then use a sensible symbol
3227 name on plt calls. The difficulty in doing so is
3228 a) finding the stubs, and,
3229 b) matching stubs against plt entries, and,
3230 c) there can be multiple stubs for a given plt entry.
3231
3232 Solving (a) could be done by code scanning, but older
3233 ppc64 binaries used different stubs to current code.
3234 (b) is the tricky one since you need to known the toc
3235 pointer for at least one function that uses a pic stub to
3236 be able to calculate the plt address referenced.
3237 (c) means gdb would need to set multiple breakpoints (or
3238 find the glink branch itself) when setting breakpoints
3239 for pending shared library loads. */
3240 p = relplt->relocation;
3241 for (i = 0; i < plt_count; i++, p++)
3242 {
3243 size_t len;
3244
3245 *s = **p->sym_ptr_ptr;
3246 /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set. Since
3247 we are defining a symbol, ensure one of them is set. */
3248 if ((s->flags & BSF_LOCAL) == 0)
3249 s->flags |= BSF_GLOBAL;
3250 s->flags |= BSF_SYNTHETIC;
3251 s->section = glink;
3252 s->value = glink_vma - glink->vma;
3253 s->name = names;
3254 s->udata.p = NULL;
3255 len = strlen ((*p->sym_ptr_ptr)->name);
3256 memcpy (names, (*p->sym_ptr_ptr)->name, len);
3257 names += len;
3258 if (p->addend != 0)
3259 {
3260 memcpy (names, "+0x", sizeof ("+0x") - 1);
3261 names += sizeof ("+0x") - 1;
3262 bfd_sprintf_vma (abfd, names, p->addend);
3263 names += strlen (names);
3264 }
3265 memcpy (names, "@plt", sizeof ("@plt"));
3266 names += sizeof ("@plt");
3267 s++;
3268 glink_vma += 8;
3269 if (i >= 0x8000)
3270 glink_vma += 4;
3271 }
3272 count += plt_count;
3273 }
3274 }
3275
3276 done:
3277 free (syms);
3278 return count;
3279 }
3280 \f
3281 /* The following functions are specific to the ELF linker, while
3282 functions above are used generally. Those named ppc64_elf_* are
3283 called by the main ELF linker code. They appear in this file more
3284 or less in the order in which they are called. eg.
3285 ppc64_elf_check_relocs is called early in the link process,
3286 ppc64_elf_finish_dynamic_sections is one of the last functions
3287 called.
3288
3289 PowerPC64-ELF uses a similar scheme to PowerPC64-XCOFF in that
3290 functions have both a function code symbol and a function descriptor
3291 symbol. A call to foo in a relocatable object file looks like:
3292
3293 . .text
3294 . x:
3295 . bl .foo
3296 . nop
3297
3298 The function definition in another object file might be:
3299
3300 . .section .opd
3301 . foo: .quad .foo
3302 . .quad .TOC.@tocbase
3303 . .quad 0
3304 .
3305 . .text
3306 . .foo: blr
3307
3308 When the linker resolves the call during a static link, the branch
3309 unsurprisingly just goes to .foo and the .opd information is unused.
3310 If the function definition is in a shared library, things are a little
3311 different: The call goes via a plt call stub, the opd information gets
3312 copied to the plt, and the linker patches the nop.
3313
3314 . x:
3315 . bl .foo_stub
3316 . ld 2,40(1)
3317 .
3318 .
3319 . .foo_stub:
3320 . addis 12,2,Lfoo@toc@ha # in practice, the call stub
3321 . addi 12,12,Lfoo@toc@l # is slightly optimized, but
3322 . std 2,40(1) # this is the general idea
3323 . ld 11,0(12)
3324 . ld 2,8(12)
3325 . mtctr 11
3326 . ld 11,16(12)
3327 . bctr
3328 .
3329 . .section .plt
3330 . Lfoo: reloc (R_PPC64_JMP_SLOT, foo)
3331
3332 The "reloc ()" notation is supposed to indicate that the linker emits
3333 an R_PPC64_JMP_SLOT reloc against foo. The dynamic linker does the opd
3334 copying.
3335
3336 What are the difficulties here? Well, firstly, the relocations
3337 examined by the linker in check_relocs are against the function code
3338 sym .foo, while the dynamic relocation in the plt is emitted against
3339 the function descriptor symbol, foo. Somewhere along the line, we need
3340 to carefully copy dynamic link information from one symbol to the other.
3341 Secondly, the generic part of the elf linker will make .foo a dynamic
3342 symbol as is normal for most other backends. We need foo dynamic
3343 instead, at least for an application final link. However, when
3344 creating a shared library containing foo, we need to have both symbols
3345 dynamic so that references to .foo are satisfied during the early
3346 stages of linking. Otherwise the linker might decide to pull in a
3347 definition from some other object, eg. a static library.
3348
3349 Update: As of August 2004, we support a new convention. Function
3350 calls may use the function descriptor symbol, ie. "bl foo". This
3351 behaves exactly as "bl .foo". */
3352
3353 /* The linker needs to keep track of the number of relocs that it
3354 decides to copy as dynamic relocs in check_relocs for each symbol.
3355 This is so that it can later discard them if they are found to be
3356 unnecessary. We store the information in a field extending the
3357 regular ELF linker hash table. */
3358
3359 struct ppc_dyn_relocs
3360 {
3361 struct ppc_dyn_relocs *next;
3362
3363 /* The input section of the reloc. */
3364 asection *sec;
3365
3366 /* Total number of relocs copied for the input section. */
3367 bfd_size_type count;
3368
3369 /* Number of pc-relative relocs copied for the input section. */
3370 bfd_size_type pc_count;
3371 };
3372
3373 /* Track GOT entries needed for a given symbol. We might need more
3374 than one got entry per symbol. */
3375 struct got_entry
3376 {
3377 struct got_entry *next;
3378
3379 /* The symbol addend that we'll be placing in the GOT. */
3380 bfd_vma addend;
3381
3382 /* Unlike other ELF targets, we use separate GOT entries for the same
3383 symbol referenced from different input files. This is to support
3384 automatic multiple TOC/GOT sections, where the TOC base can vary
3385 from one input file to another. FIXME: After group_sections we
3386 ought to merge entries within the group.
3387
3388 Point to the BFD owning this GOT entry. */
3389 bfd *owner;
3390
3391 /* Zero for non-tls entries, or TLS_TLS and one of TLS_GD, TLS_LD,
3392 TLS_TPREL or TLS_DTPREL for tls entries. */
3393 char tls_type;
3394
3395 /* Reference count until size_dynamic_sections, GOT offset thereafter. */
3396 union
3397 {
3398 bfd_signed_vma refcount;
3399 bfd_vma offset;
3400 } got;
3401 };
3402
3403 /* The same for PLT. */
3404 struct plt_entry
3405 {
3406 struct plt_entry *next;
3407
3408 bfd_vma addend;
3409
3410 union
3411 {
3412 bfd_signed_vma refcount;
3413 bfd_vma offset;
3414 } plt;
3415 };
3416
3417 /* Of those relocs that might be copied as dynamic relocs, this function
3418 selects those that must be copied when linking a shared library,
3419 even when the symbol is local. */
3420
3421 static int
3422 must_be_dyn_reloc (struct bfd_link_info *info,
3423 enum elf_ppc64_reloc_type r_type)
3424 {
3425 switch (r_type)
3426 {
3427 default:
3428 return 1;
3429
3430 case R_PPC64_REL32:
3431 case R_PPC64_REL64:
3432 case R_PPC64_REL30:
3433 return 0;
3434
3435 case R_PPC64_TPREL16:
3436 case R_PPC64_TPREL16_LO:
3437 case R_PPC64_TPREL16_HI:
3438 case R_PPC64_TPREL16_HA:
3439 case R_PPC64_TPREL16_DS:
3440 case R_PPC64_TPREL16_LO_DS:
3441 case R_PPC64_TPREL16_HIGHER:
3442 case R_PPC64_TPREL16_HIGHERA:
3443 case R_PPC64_TPREL16_HIGHEST:
3444 case R_PPC64_TPREL16_HIGHESTA:
3445 case R_PPC64_TPREL64:
3446 return !info->executable;
3447 }
3448 }
3449
3450 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
3451 copying dynamic variables from a shared lib into an app's dynbss
3452 section, and instead use a dynamic relocation to point into the
3453 shared lib. With code that gcc generates, it's vital that this be
3454 enabled; In the PowerPC64 ABI, the address of a function is actually
3455 the address of a function descriptor, which resides in the .opd
3456 section. gcc uses the descriptor directly rather than going via the
3457 GOT as some other ABI's do, which means that initialized function
3458 pointers must reference the descriptor. Thus, a function pointer
3459 initialized to the address of a function in a shared library will
3460 either require a copy reloc, or a dynamic reloc. Using a copy reloc
3461 redefines the function descriptor symbol to point to the copy. This
3462 presents a problem as a plt entry for that function is also
3463 initialized from the function descriptor symbol and the copy reloc
3464 may not be initialized first. */
3465 #define ELIMINATE_COPY_RELOCS 1
3466
3467 /* Section name for stubs is the associated section name plus this
3468 string. */
3469 #define STUB_SUFFIX ".stub"
3470
3471 /* Linker stubs.
3472 ppc_stub_long_branch:
3473 Used when a 14 bit branch (or even a 24 bit branch) can't reach its
3474 destination, but a 24 bit branch in a stub section will reach.
3475 . b dest
3476
3477 ppc_stub_plt_branch:
3478 Similar to the above, but a 24 bit branch in the stub section won't
3479 reach its destination.
3480 . addis %r12,%r2,xxx@toc@ha
3481 . ld %r11,xxx@toc@l(%r12)
3482 . mtctr %r11
3483 . bctr
3484
3485 ppc_stub_plt_call:
3486 Used to call a function in a shared library. If it so happens that
3487 the plt entry referenced crosses a 64k boundary, then an extra
3488 "addi %r12,%r12,xxx@toc@l" will be inserted before the "mtctr".
3489 . addis %r12,%r2,xxx@toc@ha
3490 . std %r2,40(%r1)
3491 . ld %r11,xxx+0@toc@l(%r12)
3492 . mtctr %r11
3493 . ld %r2,xxx+8@toc@l(%r12)
3494 . ld %r11,xxx+16@toc@l(%r12)
3495 . bctr
3496
3497 ppc_stub_long_branch and ppc_stub_plt_branch may also have additional
3498 code to adjust the value and save r2 to support multiple toc sections.
3499 A ppc_stub_long_branch with an r2 offset looks like:
3500 . std %r2,40(%r1)
3501 . addis %r2,%r2,off@ha
3502 . addi %r2,%r2,off@l
3503 . b dest
3504
3505 A ppc_stub_plt_branch with an r2 offset looks like:
3506 . std %r2,40(%r1)
3507 . addis %r12,%r2,xxx@toc@ha
3508 . ld %r11,xxx@toc@l(%r12)
3509 . addis %r2,%r2,off@ha
3510 . addi %r2,%r2,off@l
3511 . mtctr %r11
3512 . bctr
3513
3514 In cases where the "addis" instruction would add zero, the "addis" is
3515 omitted and following instructions modified slightly in some cases.
3516 */
3517
3518 enum ppc_stub_type {
3519 ppc_stub_none,
3520 ppc_stub_long_branch,
3521 ppc_stub_long_branch_r2off,
3522 ppc_stub_plt_branch,
3523 ppc_stub_plt_branch_r2off,
3524 ppc_stub_plt_call
3525 };
3526
3527 struct ppc_stub_hash_entry {
3528
3529 /* Base hash table entry structure. */
3530 struct bfd_hash_entry root;
3531
3532 enum ppc_stub_type stub_type;
3533
3534 /* The stub section. */
3535 asection *stub_sec;
3536
3537 /* Offset within stub_sec of the beginning of this stub. */
3538 bfd_vma stub_offset;
3539
3540 /* Given the symbol's value and its section we can determine its final
3541 value when building the stubs (so the stub knows where to jump. */
3542 bfd_vma target_value;
3543 asection *target_section;
3544
3545 /* The symbol table entry, if any, that this was derived from. */
3546 struct ppc_link_hash_entry *h;
3547 struct plt_entry *plt_ent;
3548
3549 /* And the reloc addend that this was derived from. */
3550 bfd_vma addend;
3551
3552 /* Where this stub is being called from, or, in the case of combined
3553 stub sections, the first input section in the group. */
3554 asection *id_sec;
3555 };
3556
3557 struct ppc_branch_hash_entry {
3558
3559 /* Base hash table entry structure. */
3560 struct bfd_hash_entry root;
3561
3562 /* Offset within branch lookup table. */
3563 unsigned int offset;
3564
3565 /* Generation marker. */
3566 unsigned int iter;
3567 };
3568
3569 struct ppc_link_hash_entry
3570 {
3571 struct elf_link_hash_entry elf;
3572
3573 union {
3574 /* A pointer to the most recently used stub hash entry against this
3575 symbol. */
3576 struct ppc_stub_hash_entry *stub_cache;
3577
3578 /* A pointer to the next symbol starting with a '.' */
3579 struct ppc_link_hash_entry *next_dot_sym;
3580 } u;
3581
3582 /* Track dynamic relocs copied for this symbol. */
3583 struct ppc_dyn_relocs *dyn_relocs;
3584
3585 /* Link between function code and descriptor symbols. */
3586 struct ppc_link_hash_entry *oh;
3587
3588 /* Flag function code and descriptor symbols. */
3589 unsigned int is_func:1;
3590 unsigned int is_func_descriptor:1;
3591 unsigned int fake:1;
3592
3593 /* Whether global opd/toc sym has been adjusted or not.
3594 After ppc64_elf_edit_opd/ppc64_elf_edit_toc has run, this flag
3595 should be set for all globals defined in any opd/toc section. */
3596 unsigned int adjust_done:1;
3597
3598 /* Set if we twiddled this symbol to weak at some stage. */
3599 unsigned int was_undefined:1;
3600
3601 /* Contexts in which symbol is used in the GOT (or TOC).
3602 TLS_GD .. TLS_EXPLICIT bits are or'd into the mask as the
3603 corresponding relocs are encountered during check_relocs.
3604 tls_optimize clears TLS_GD .. TLS_TPREL when optimizing to
3605 indicate the corresponding GOT entry type is not needed.
3606 tls_optimize may also set TLS_TPRELGD when a GD reloc turns into
3607 a TPREL one. We use a separate flag rather than setting TPREL
3608 just for convenience in distinguishing the two cases. */
3609 #define TLS_GD 1 /* GD reloc. */
3610 #define TLS_LD 2 /* LD reloc. */
3611 #define TLS_TPREL 4 /* TPREL reloc, => IE. */
3612 #define TLS_DTPREL 8 /* DTPREL reloc, => LD. */
3613 #define TLS_TLS 16 /* Any TLS reloc. */
3614 #define TLS_EXPLICIT 32 /* Marks TOC section TLS relocs. */
3615 #define TLS_TPRELGD 64 /* TPREL reloc resulting from GD->IE. */
3616 #define PLT_IFUNC 128 /* STT_GNU_IFUNC. */
3617 char tls_mask;
3618 };
3619
3620 /* ppc64 ELF linker hash table. */
3621
3622 struct ppc_link_hash_table
3623 {
3624 struct elf_link_hash_table elf;
3625
3626 /* The stub hash table. */
3627 struct bfd_hash_table stub_hash_table;
3628
3629 /* Another hash table for plt_branch stubs. */
3630 struct bfd_hash_table branch_hash_table;
3631
3632 /* Linker stub bfd. */
3633 bfd *stub_bfd;
3634
3635 /* Linker call-backs. */
3636 asection * (*add_stub_section) (const char *, asection *);
3637 void (*layout_sections_again) (void);
3638
3639 /* Array to keep track of which stub sections have been created, and
3640 information on stub grouping. */
3641 struct map_stub {
3642 /* This is the section to which stubs in the group will be attached. */
3643 asection *link_sec;
3644 /* The stub section. */
3645 asection *stub_sec;
3646 /* Along with elf_gp, specifies the TOC pointer used in this group. */
3647 bfd_vma toc_off;
3648 } *stub_group;
3649
3650 /* Temp used when calculating TOC pointers. */
3651 bfd_vma toc_curr;
3652
3653 /* Highest input section id. */
3654 int top_id;
3655
3656 /* Highest output section index. */
3657 int top_index;
3658
3659 /* Used when adding symbols. */
3660 struct ppc_link_hash_entry *dot_syms;
3661
3662 /* List of input sections for each output section. */
3663 asection **input_list;
3664
3665 /* Short-cuts to get to dynamic linker sections. */
3666 asection *got;
3667 asection *plt;
3668 asection *relplt;
3669 asection *iplt;
3670 asection *reliplt;
3671 asection *dynbss;
3672 asection *relbss;
3673 asection *glink;
3674 asection *sfpr;
3675 asection *brlt;
3676 asection *relbrlt;
3677
3678 /* Shortcut to .__tls_get_addr and __tls_get_addr. */
3679 struct ppc_link_hash_entry *tls_get_addr;
3680 struct ppc_link_hash_entry *tls_get_addr_fd;
3681
3682 /* Statistics. */
3683 unsigned long stub_count[ppc_stub_plt_call];
3684
3685 /* Number of stubs against global syms. */
3686 unsigned long stub_globals;
3687
3688 /* Set if we should emit symbols for stubs. */
3689 unsigned int emit_stub_syms:1;
3690
3691 /* Support for multiple toc sections. */
3692 unsigned int no_multi_toc:1;
3693 unsigned int multi_toc_needed:1;
3694
3695 /* Set on error. */
3696 unsigned int stub_error:1;
3697
3698 /* Temp used by ppc64_elf_process_dot_syms. */
3699 unsigned int twiddled_syms:1;
3700
3701 /* Incremented every time we size stubs. */
3702 unsigned int stub_iteration;
3703
3704 /* Small local sym cache. */
3705 struct sym_cache sym_cache;
3706 };
3707
3708 /* Rename some of the generic section flags to better document how they
3709 are used here. */
3710 #define has_toc_reloc has_gp_reloc
3711 #define makes_toc_func_call need_finalize_relax
3712 #define call_check_in_progress reloc_done
3713
3714 /* Get the ppc64 ELF linker hash table from a link_info structure. */
3715
3716 #define ppc_hash_table(p) \
3717 ((struct ppc_link_hash_table *) ((p)->hash))
3718
3719 #define ppc_stub_hash_lookup(table, string, create, copy) \
3720 ((struct ppc_stub_hash_entry *) \
3721 bfd_hash_lookup ((table), (string), (create), (copy)))
3722
3723 #define ppc_branch_hash_lookup(table, string, create, copy) \
3724 ((struct ppc_branch_hash_entry *) \
3725 bfd_hash_lookup ((table), (string), (create), (copy)))
3726
3727 /* Create an entry in the stub hash table. */
3728
3729 static struct bfd_hash_entry *
3730 stub_hash_newfunc (struct bfd_hash_entry *entry,
3731 struct bfd_hash_table *table,
3732 const char *string)
3733 {
3734 /* Allocate the structure if it has not already been allocated by a
3735 subclass. */
3736 if (entry == NULL)
3737 {
3738 entry = bfd_hash_allocate (table, sizeof (struct ppc_stub_hash_entry));
3739 if (entry == NULL)
3740 return entry;
3741 }
3742
3743 /* Call the allocation method of the superclass. */
3744 entry = bfd_hash_newfunc (entry, table, string);
3745 if (entry != NULL)
3746 {
3747 struct ppc_stub_hash_entry *eh;
3748
3749 /* Initialize the local fields. */
3750 eh = (struct ppc_stub_hash_entry *) entry;
3751 eh->stub_type = ppc_stub_none;
3752 eh->stub_sec = NULL;
3753 eh->stub_offset = 0;
3754 eh->target_value = 0;
3755 eh->target_section = NULL;
3756 eh->h = NULL;
3757 eh->id_sec = NULL;
3758 }
3759
3760 return entry;
3761 }
3762
3763 /* Create an entry in the branch hash table. */
3764
3765 static struct bfd_hash_entry *
3766 branch_hash_newfunc (struct bfd_hash_entry *entry,
3767 struct bfd_hash_table *table,
3768 const char *string)
3769 {
3770 /* Allocate the structure if it has not already been allocated by a
3771 subclass. */
3772 if (entry == NULL)
3773 {
3774 entry = bfd_hash_allocate (table, sizeof (struct ppc_branch_hash_entry));
3775 if (entry == NULL)
3776 return entry;
3777 }
3778
3779 /* Call the allocation method of the superclass. */
3780 entry = bfd_hash_newfunc (entry, table, string);
3781 if (entry != NULL)
3782 {
3783 struct ppc_branch_hash_entry *eh;
3784
3785 /* Initialize the local fields. */
3786 eh = (struct ppc_branch_hash_entry *) entry;
3787 eh->offset = 0;
3788 eh->iter = 0;
3789 }
3790
3791 return entry;
3792 }
3793
3794 /* Create an entry in a ppc64 ELF linker hash table. */
3795
3796 static struct bfd_hash_entry *
3797 link_hash_newfunc (struct bfd_hash_entry *entry,
3798 struct bfd_hash_table *table,
3799 const char *string)
3800 {
3801 /* Allocate the structure if it has not already been allocated by a
3802 subclass. */
3803 if (entry == NULL)
3804 {
3805 entry = bfd_hash_allocate (table, sizeof (struct ppc_link_hash_entry));
3806 if (entry == NULL)
3807 return entry;
3808 }
3809
3810 /* Call the allocation method of the superclass. */
3811 entry = _bfd_elf_link_hash_newfunc (entry, table, string);
3812 if (entry != NULL)
3813 {
3814 struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) entry;
3815
3816 memset (&eh->u.stub_cache, 0,
3817 (sizeof (struct ppc_link_hash_entry)
3818 - offsetof (struct ppc_link_hash_entry, u.stub_cache)));
3819
3820 /* When making function calls, old ABI code references function entry
3821 points (dot symbols), while new ABI code references the function
3822 descriptor symbol. We need to make any combination of reference and
3823 definition work together, without breaking archive linking.
3824
3825 For a defined function "foo" and an undefined call to "bar":
3826 An old object defines "foo" and ".foo", references ".bar" (possibly
3827 "bar" too).
3828 A new object defines "foo" and references "bar".
3829
3830 A new object thus has no problem with its undefined symbols being
3831 satisfied by definitions in an old object. On the other hand, the
3832 old object won't have ".bar" satisfied by a new object.
3833
3834 Keep a list of newly added dot-symbols. */
3835
3836 if (string[0] == '.')
3837 {
3838 struct ppc_link_hash_table *htab;
3839
3840 htab = (struct ppc_link_hash_table *) table;
3841 eh->u.next_dot_sym = htab->dot_syms;
3842 htab->dot_syms = eh;
3843 }
3844 }
3845
3846 return entry;
3847 }
3848
3849 /* Create a ppc64 ELF linker hash table. */
3850
3851 static struct bfd_link_hash_table *
3852 ppc64_elf_link_hash_table_create (bfd *abfd)
3853 {
3854 struct ppc_link_hash_table *htab;
3855 bfd_size_type amt = sizeof (struct ppc_link_hash_table);
3856
3857 htab = bfd_zmalloc (amt);
3858 if (htab == NULL)
3859 return NULL;
3860
3861 if (!_bfd_elf_link_hash_table_init (&htab->elf, abfd, link_hash_newfunc,
3862 sizeof (struct ppc_link_hash_entry)))
3863 {
3864 free (htab);
3865 return NULL;
3866 }
3867
3868 /* Init the stub hash table too. */
3869 if (!bfd_hash_table_init (&htab->stub_hash_table, stub_hash_newfunc,
3870 sizeof (struct ppc_stub_hash_entry)))
3871 return NULL;
3872
3873 /* And the branch hash table. */
3874 if (!bfd_hash_table_init (&htab->branch_hash_table, branch_hash_newfunc,
3875 sizeof (struct ppc_branch_hash_entry)))
3876 return NULL;
3877
3878 /* Initializing two fields of the union is just cosmetic. We really
3879 only care about glist, but when compiled on a 32-bit host the
3880 bfd_vma fields are larger. Setting the bfd_vma to zero makes
3881 debugger inspection of these fields look nicer. */
3882 htab->elf.init_got_refcount.refcount = 0;
3883 htab->elf.init_got_refcount.glist = NULL;
3884 htab->elf.init_plt_refcount.refcount = 0;
3885 htab->elf.init_plt_refcount.glist = NULL;
3886 htab->elf.init_got_offset.offset = 0;
3887 htab->elf.init_got_offset.glist = NULL;
3888 htab->elf.init_plt_offset.offset = 0;
3889 htab->elf.init_plt_offset.glist = NULL;
3890
3891 return &htab->elf.root;
3892 }
3893
3894 /* Free the derived linker hash table. */
3895
3896 static void
3897 ppc64_elf_link_hash_table_free (struct bfd_link_hash_table *hash)
3898 {
3899 struct ppc_link_hash_table *ret = (struct ppc_link_hash_table *) hash;
3900
3901 bfd_hash_table_free (&ret->stub_hash_table);
3902 bfd_hash_table_free (&ret->branch_hash_table);
3903 _bfd_generic_link_hash_table_free (hash);
3904 }
3905
3906 /* Satisfy the ELF linker by filling in some fields in our fake bfd. */
3907
3908 void
3909 ppc64_elf_init_stub_bfd (bfd *abfd, struct bfd_link_info *info)
3910 {
3911 struct ppc_link_hash_table *htab;
3912
3913 elf_elfheader (abfd)->e_ident[EI_CLASS] = ELFCLASS64;
3914
3915 /* Always hook our dynamic sections into the first bfd, which is the
3916 linker created stub bfd. This ensures that the GOT header is at
3917 the start of the output TOC section. */
3918 htab = ppc_hash_table (info);
3919 htab->stub_bfd = abfd;
3920 htab->elf.dynobj = abfd;
3921 }
3922
3923 /* Build a name for an entry in the stub hash table. */
3924
3925 static char *
3926 ppc_stub_name (const asection *input_section,
3927 const asection *sym_sec,
3928 const struct ppc_link_hash_entry *h,
3929 const Elf_Internal_Rela *rel)
3930 {
3931 char *stub_name;
3932 bfd_size_type len;
3933
3934 /* rel->r_addend is actually 64 bit, but who uses more than +/- 2^31
3935 offsets from a sym as a branch target? In fact, we could
3936 probably assume the addend is always zero. */
3937 BFD_ASSERT (((int) rel->r_addend & 0xffffffff) == rel->r_addend);
3938
3939 if (h)
3940 {
3941 len = 8 + 1 + strlen (h->elf.root.root.string) + 1 + 8 + 1;
3942 stub_name = bfd_malloc (len);
3943 if (stub_name == NULL)
3944 return stub_name;
3945
3946 sprintf (stub_name, "%08x.%s+%x",
3947 input_section->id & 0xffffffff,
3948 h->elf.root.root.string,
3949 (int) rel->r_addend & 0xffffffff);
3950 }
3951 else
3952 {
3953 len = 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1;
3954 stub_name = bfd_malloc (len);
3955 if (stub_name == NULL)
3956 return stub_name;
3957
3958 sprintf (stub_name, "%08x.%x:%x+%x",
3959 input_section->id & 0xffffffff,
3960 sym_sec->id & 0xffffffff,
3961 (int) ELF64_R_SYM (rel->r_info) & 0xffffffff,
3962 (int) rel->r_addend & 0xffffffff);
3963 }
3964 if (stub_name[len - 2] == '+' && stub_name[len - 1] == '0')
3965 stub_name[len - 2] = 0;
3966 return stub_name;
3967 }
3968
3969 /* Look up an entry in the stub hash. Stub entries are cached because
3970 creating the stub name takes a bit of time. */
3971
3972 static struct ppc_stub_hash_entry *
3973 ppc_get_stub_entry (const asection *input_section,
3974 const asection *sym_sec,
3975 struct ppc_link_hash_entry *h,
3976 const Elf_Internal_Rela *rel,
3977 struct ppc_link_hash_table *htab)
3978 {
3979 struct ppc_stub_hash_entry *stub_entry;
3980 const asection *id_sec;
3981
3982 /* If this input section is part of a group of sections sharing one
3983 stub section, then use the id of the first section in the group.
3984 Stub names need to include a section id, as there may well be
3985 more than one stub used to reach say, printf, and we need to
3986 distinguish between them. */
3987 id_sec = htab->stub_group[input_section->id].link_sec;
3988
3989 if (h != NULL && h->u.stub_cache != NULL
3990 && h->u.stub_cache->h == h
3991 && h->u.stub_cache->id_sec == id_sec)
3992 {
3993 stub_entry = h->u.stub_cache;
3994 }
3995 else
3996 {
3997 char *stub_name;
3998
3999 stub_name = ppc_stub_name (id_sec, sym_sec, h, rel);
4000 if (stub_name == NULL)
4001 return NULL;
4002
4003 stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
4004 stub_name, FALSE, FALSE);
4005 if (h != NULL)
4006 h->u.stub_cache = stub_entry;
4007
4008 free (stub_name);
4009 }
4010
4011 return stub_entry;
4012 }
4013
4014 /* Add a new stub entry to the stub hash. Not all fields of the new
4015 stub entry are initialised. */
4016
4017 static struct ppc_stub_hash_entry *
4018 ppc_add_stub (const char *stub_name,
4019 asection *section,
4020 struct ppc_link_hash_table *htab)
4021 {
4022 asection *link_sec;
4023 asection *stub_sec;
4024 struct ppc_stub_hash_entry *stub_entry;
4025
4026 link_sec = htab->stub_group[section->id].link_sec;
4027 stub_sec = htab->stub_group[section->id].stub_sec;
4028 if (stub_sec == NULL)
4029 {
4030 stub_sec = htab->stub_group[link_sec->id].stub_sec;
4031 if (stub_sec == NULL)
4032 {
4033 size_t namelen;
4034 bfd_size_type len;
4035 char *s_name;
4036
4037 namelen = strlen (link_sec->name);
4038 len = namelen + sizeof (STUB_SUFFIX);
4039 s_name = bfd_alloc (htab->stub_bfd, len);
4040 if (s_name == NULL)
4041 return NULL;
4042
4043 memcpy (s_name, link_sec->name, namelen);
4044 memcpy (s_name + namelen, STUB_SUFFIX, sizeof (STUB_SUFFIX));
4045 stub_sec = (*htab->add_stub_section) (s_name, link_sec);
4046 if (stub_sec == NULL)
4047 return NULL;
4048 htab->stub_group[link_sec->id].stub_sec = stub_sec;
4049 }
4050 htab->stub_group[section->id].stub_sec = stub_sec;
4051 }
4052
4053 /* Enter this entry into the linker stub hash table. */
4054 stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table, stub_name,
4055 TRUE, FALSE);
4056 if (stub_entry == NULL)
4057 {
4058 (*_bfd_error_handler) (_("%B: cannot create stub entry %s"),
4059 section->owner, stub_name);
4060 return NULL;
4061 }
4062
4063 stub_entry->stub_sec = stub_sec;
4064 stub_entry->stub_offset = 0;
4065 stub_entry->id_sec = link_sec;
4066 return stub_entry;
4067 }
4068
4069 /* Create sections for linker generated code. */
4070
4071 static bfd_boolean
4072 create_linkage_sections (bfd *dynobj, struct bfd_link_info *info)
4073 {
4074 struct ppc_link_hash_table *htab;
4075 flagword flags;
4076
4077 htab = ppc_hash_table (info);
4078
4079 /* Create .sfpr for code to save and restore fp regs. */
4080 flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY
4081 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4082 htab->sfpr = bfd_make_section_anyway_with_flags (dynobj, ".sfpr",
4083 flags);
4084 if (htab->sfpr == NULL
4085 || ! bfd_set_section_alignment (dynobj, htab->sfpr, 2))
4086 return FALSE;
4087
4088 /* Create .glink for lazy dynamic linking support. */
4089 htab->glink = bfd_make_section_anyway_with_flags (dynobj, ".glink",
4090 flags);
4091 if (htab->glink == NULL
4092 || ! bfd_set_section_alignment (dynobj, htab->glink, 3))
4093 return FALSE;
4094
4095 flags = SEC_ALLOC | SEC_LINKER_CREATED;
4096 htab->iplt = bfd_make_section_anyway_with_flags (dynobj, ".iplt", flags);
4097 if (htab->iplt == NULL
4098 || ! bfd_set_section_alignment (dynobj, htab->iplt, 3))
4099 return FALSE;
4100
4101 flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4102 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4103 htab->reliplt = bfd_make_section_anyway_with_flags (dynobj,
4104 ".rela.iplt",
4105 flags);
4106 if (htab->reliplt == NULL
4107 || ! bfd_set_section_alignment (dynobj, htab->reliplt, 3))
4108 return FALSE;
4109
4110 /* Create branch lookup table for plt_branch stubs. */
4111 flags = (SEC_ALLOC | SEC_LOAD
4112 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4113 htab->brlt = bfd_make_section_anyway_with_flags (dynobj, ".branch_lt",
4114 flags);
4115 if (htab->brlt == NULL
4116 || ! bfd_set_section_alignment (dynobj, htab->brlt, 3))
4117 return FALSE;
4118
4119 if (!info->shared)
4120 return TRUE;
4121
4122 flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4123 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4124 htab->relbrlt = bfd_make_section_anyway_with_flags (dynobj,
4125 ".rela.branch_lt",
4126 flags);
4127 if (htab->relbrlt == NULL
4128 || ! bfd_set_section_alignment (dynobj, htab->relbrlt, 3))
4129 return FALSE;
4130
4131 return TRUE;
4132 }
4133
4134 /* Create .got and .rela.got sections in ABFD, and .got in dynobj if
4135 not already done. */
4136
4137 static bfd_boolean
4138 create_got_section (bfd *abfd, struct bfd_link_info *info)
4139 {
4140 asection *got, *relgot;
4141 flagword flags;
4142 struct ppc_link_hash_table *htab = ppc_hash_table (info);
4143
4144 if (!is_ppc64_elf (abfd))
4145 return FALSE;
4146
4147 if (!htab->got)
4148 {
4149 if (! _bfd_elf_create_got_section (htab->elf.dynobj, info))
4150 return FALSE;
4151
4152 htab->got = bfd_get_section_by_name (htab->elf.dynobj, ".got");
4153 if (!htab->got)
4154 abort ();
4155 }
4156
4157 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
4158 | SEC_LINKER_CREATED);
4159
4160 got = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
4161 if (!got
4162 || !bfd_set_section_alignment (abfd, got, 3))
4163 return FALSE;
4164
4165 relgot = bfd_make_section_anyway_with_flags (abfd, ".rela.got",
4166 flags | SEC_READONLY);
4167 if (!relgot
4168 || ! bfd_set_section_alignment (abfd, relgot, 3))
4169 return FALSE;
4170
4171 ppc64_elf_tdata (abfd)->got = got;
4172 ppc64_elf_tdata (abfd)->relgot = relgot;
4173 return TRUE;
4174 }
4175
4176 /* Create the dynamic sections, and set up shortcuts. */
4177
4178 static bfd_boolean
4179 ppc64_elf_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
4180 {
4181 struct ppc_link_hash_table *htab;
4182
4183 if (!_bfd_elf_create_dynamic_sections (dynobj, info))
4184 return FALSE;
4185
4186 htab = ppc_hash_table (info);
4187 if (!htab->got)
4188 htab->got = bfd_get_section_by_name (dynobj, ".got");
4189 htab->plt = bfd_get_section_by_name (dynobj, ".plt");
4190 htab->relplt = bfd_get_section_by_name (dynobj, ".rela.plt");
4191 htab->dynbss = bfd_get_section_by_name (dynobj, ".dynbss");
4192 if (!info->shared)
4193 htab->relbss = bfd_get_section_by_name (dynobj, ".rela.bss");
4194
4195 if (!htab->got || !htab->plt || !htab->relplt || !htab->dynbss
4196 || (!info->shared && !htab->relbss))
4197 abort ();
4198
4199 return TRUE;
4200 }
4201
4202 /* Merge PLT info on FROM with that on TO. */
4203
4204 static void
4205 move_plt_plist (struct ppc_link_hash_entry *from,
4206 struct ppc_link_hash_entry *to)
4207 {
4208 if (from->elf.plt.plist != NULL)
4209 {
4210 if (to->elf.plt.plist != NULL)
4211 {
4212 struct plt_entry **entp;
4213 struct plt_entry *ent;
4214
4215 for (entp = &from->elf.plt.plist; (ent = *entp) != NULL; )
4216 {
4217 struct plt_entry *dent;
4218
4219 for (dent = to->elf.plt.plist; dent != NULL; dent = dent->next)
4220 if (dent->addend == ent->addend)
4221 {
4222 dent->plt.refcount += ent->plt.refcount;
4223 *entp = ent->next;
4224 break;
4225 }
4226 if (dent == NULL)
4227 entp = &ent->next;
4228 }
4229 *entp = to->elf.plt.plist;
4230 }
4231
4232 to->elf.plt.plist = from->elf.plt.plist;
4233 from->elf.plt.plist = NULL;
4234 }
4235 }
4236
4237 /* Copy the extra info we tack onto an elf_link_hash_entry. */
4238
4239 static void
4240 ppc64_elf_copy_indirect_symbol (struct bfd_link_info *info,
4241 struct elf_link_hash_entry *dir,
4242 struct elf_link_hash_entry *ind)
4243 {
4244 struct ppc_link_hash_entry *edir, *eind;
4245
4246 edir = (struct ppc_link_hash_entry *) dir;
4247 eind = (struct ppc_link_hash_entry *) ind;
4248
4249 /* Copy over any dynamic relocs we may have on the indirect sym. */
4250 if (eind->dyn_relocs != NULL)
4251 {
4252 if (edir->dyn_relocs != NULL)
4253 {
4254 struct ppc_dyn_relocs **pp;
4255 struct ppc_dyn_relocs *p;
4256
4257 /* Add reloc counts against the indirect sym to the direct sym
4258 list. Merge any entries against the same section. */
4259 for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
4260 {
4261 struct ppc_dyn_relocs *q;
4262
4263 for (q = edir->dyn_relocs; q != NULL; q = q->next)
4264 if (q->sec == p->sec)
4265 {
4266 q->pc_count += p->pc_count;
4267 q->count += p->count;
4268 *pp = p->next;
4269 break;
4270 }
4271 if (q == NULL)
4272 pp = &p->next;
4273 }
4274 *pp = edir->dyn_relocs;
4275 }
4276
4277 edir->dyn_relocs = eind->dyn_relocs;
4278 eind->dyn_relocs = NULL;
4279 }
4280
4281 edir->is_func |= eind->is_func;
4282 edir->is_func_descriptor |= eind->is_func_descriptor;
4283 edir->tls_mask |= eind->tls_mask;
4284
4285 /* If called to transfer flags for a weakdef during processing
4286 of elf_adjust_dynamic_symbol, don't copy NON_GOT_REF.
4287 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
4288 if (!(ELIMINATE_COPY_RELOCS
4289 && eind->elf.root.type != bfd_link_hash_indirect
4290 && edir->elf.dynamic_adjusted))
4291 edir->elf.non_got_ref |= eind->elf.non_got_ref;
4292
4293 edir->elf.ref_dynamic |= eind->elf.ref_dynamic;
4294 edir->elf.ref_regular |= eind->elf.ref_regular;
4295 edir->elf.ref_regular_nonweak |= eind->elf.ref_regular_nonweak;
4296 edir->elf.needs_plt |= eind->elf.needs_plt;
4297
4298 /* If we were called to copy over info for a weak sym, that's all. */
4299 if (eind->elf.root.type != bfd_link_hash_indirect)
4300 return;
4301
4302 /* Copy over got entries that we may have already seen to the
4303 symbol which just became indirect. */
4304 if (eind->elf.got.glist != NULL)
4305 {
4306 if (edir->elf.got.glist != NULL)
4307 {
4308 struct got_entry **entp;
4309 struct got_entry *ent;
4310
4311 for (entp = &eind->elf.got.glist; (ent = *entp) != NULL; )
4312 {
4313 struct got_entry *dent;
4314
4315 for (dent = edir->elf.got.glist; dent != NULL; dent = dent->next)
4316 if (dent->addend == ent->addend
4317 && dent->owner == ent->owner
4318 && dent->tls_type == ent->tls_type)
4319 {
4320 dent->got.refcount += ent->got.refcount;
4321 *entp = ent->next;
4322 break;
4323 }
4324 if (dent == NULL)
4325 entp = &ent->next;
4326 }
4327 *entp = edir->elf.got.glist;
4328 }
4329
4330 edir->elf.got.glist = eind->elf.got.glist;
4331 eind->elf.got.glist = NULL;
4332 }
4333
4334 /* And plt entries. */
4335 move_plt_plist (eind, edir);
4336
4337 if (eind->elf.dynindx != -1)
4338 {
4339 if (edir->elf.dynindx != -1)
4340 _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
4341 edir->elf.dynstr_index);
4342 edir->elf.dynindx = eind->elf.dynindx;
4343 edir->elf.dynstr_index = eind->elf.dynstr_index;
4344 eind->elf.dynindx = -1;
4345 eind->elf.dynstr_index = 0;
4346 }
4347 }
4348
4349 /* Find the function descriptor hash entry from the given function code
4350 hash entry FH. Link the entries via their OH fields. */
4351
4352 static struct ppc_link_hash_entry *
4353 get_fdh (struct ppc_link_hash_entry *fh, struct ppc_link_hash_table *htab)
4354 {
4355 struct ppc_link_hash_entry *fdh = fh->oh;
4356
4357 if (fdh == NULL)
4358 {
4359 const char *fd_name = fh->elf.root.root.string + 1;
4360
4361 fdh = (struct ppc_link_hash_entry *)
4362 elf_link_hash_lookup (&htab->elf, fd_name, FALSE, FALSE, FALSE);
4363 if (fdh != NULL)
4364 {
4365 fdh->is_func_descriptor = 1;
4366 fdh->oh = fh;
4367 fh->is_func = 1;
4368 fh->oh = fdh;
4369 }
4370 }
4371
4372 return fdh;
4373 }
4374
4375 /* Make a fake function descriptor sym for the code sym FH. */
4376
4377 static struct ppc_link_hash_entry *
4378 make_fdh (struct bfd_link_info *info,
4379 struct ppc_link_hash_entry *fh)
4380 {
4381 bfd *abfd;
4382 asymbol *newsym;
4383 struct bfd_link_hash_entry *bh;
4384 struct ppc_link_hash_entry *fdh;
4385
4386 abfd = fh->elf.root.u.undef.abfd;
4387 newsym = bfd_make_empty_symbol (abfd);
4388 newsym->name = fh->elf.root.root.string + 1;
4389 newsym->section = bfd_und_section_ptr;
4390 newsym->value = 0;
4391 newsym->flags = BSF_WEAK;
4392
4393 bh = NULL;
4394 if (!_bfd_generic_link_add_one_symbol (info, abfd, newsym->name,
4395 newsym->flags, newsym->section,
4396 newsym->value, NULL, FALSE, FALSE,
4397 &bh))
4398 return NULL;
4399
4400 fdh = (struct ppc_link_hash_entry *) bh;
4401 fdh->elf.non_elf = 0;
4402 fdh->fake = 1;
4403 fdh->is_func_descriptor = 1;
4404 fdh->oh = fh;
4405 fh->is_func = 1;
4406 fh->oh = fdh;
4407 return fdh;
4408 }
4409
4410 /* Fix function descriptor symbols defined in .opd sections to be
4411 function type. */
4412
4413 static bfd_boolean
4414 ppc64_elf_add_symbol_hook (bfd *ibfd ATTRIBUTE_UNUSED,
4415 struct bfd_link_info *info,
4416 Elf_Internal_Sym *isym,
4417 const char **name ATTRIBUTE_UNUSED,
4418 flagword *flags ATTRIBUTE_UNUSED,
4419 asection **sec,
4420 bfd_vma *value ATTRIBUTE_UNUSED)
4421 {
4422 if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
4423 elf_tdata (info->output_bfd)->has_ifunc_symbols = TRUE;
4424 else if (ELF_ST_TYPE (isym->st_info) == STT_FUNC)
4425 ;
4426 else if (*sec != NULL
4427 && strcmp (bfd_get_section_name (ibfd, *sec), ".opd") == 0)
4428 isym->st_info = ELF_ST_INFO (ELF_ST_BIND (isym->st_info), STT_FUNC);
4429
4430 return TRUE;
4431 }
4432
4433 /* This function makes an old ABI object reference to ".bar" cause the
4434 inclusion of a new ABI object archive that defines "bar".
4435 NAME is a symbol defined in an archive. Return a symbol in the hash
4436 table that might be satisfied by the archive symbols. */
4437
4438 static struct elf_link_hash_entry *
4439 ppc64_elf_archive_symbol_lookup (bfd *abfd,
4440 struct bfd_link_info *info,
4441 const char *name)
4442 {
4443 struct elf_link_hash_entry *h;
4444 char *dot_name;
4445 size_t len;
4446
4447 h = _bfd_elf_archive_symbol_lookup (abfd, info, name);
4448 if (h != NULL
4449 /* Don't return this sym if it is a fake function descriptor
4450 created by add_symbol_adjust. */
4451 && !(h->root.type == bfd_link_hash_undefweak
4452 && ((struct ppc_link_hash_entry *) h)->fake))
4453 return h;
4454
4455 if (name[0] == '.')
4456 return h;
4457
4458 len = strlen (name);
4459 dot_name = bfd_alloc (abfd, len + 2);
4460 if (dot_name == NULL)
4461 return (struct elf_link_hash_entry *) 0 - 1;
4462 dot_name[0] = '.';
4463 memcpy (dot_name + 1, name, len + 1);
4464 h = _bfd_elf_archive_symbol_lookup (abfd, info, dot_name);
4465 bfd_release (abfd, dot_name);
4466 return h;
4467 }
4468
4469 /* This function satisfies all old ABI object references to ".bar" if a
4470 new ABI object defines "bar". Well, at least, undefined dot symbols
4471 are made weak. This stops later archive searches from including an
4472 object if we already have a function descriptor definition. It also
4473 prevents the linker complaining about undefined symbols.
4474 We also check and correct mismatched symbol visibility here. The
4475 most restrictive visibility of the function descriptor and the
4476 function entry symbol is used. */
4477
4478 static bfd_boolean
4479 add_symbol_adjust (struct ppc_link_hash_entry *eh, struct bfd_link_info *info)
4480 {
4481 struct ppc_link_hash_table *htab;
4482 struct ppc_link_hash_entry *fdh;
4483
4484 if (eh->elf.root.type == bfd_link_hash_indirect)
4485 return TRUE;
4486
4487 if (eh->elf.root.type == bfd_link_hash_warning)
4488 eh = (struct ppc_link_hash_entry *) eh->elf.root.u.i.link;
4489
4490 if (eh->elf.root.root.string[0] != '.')
4491 abort ();
4492
4493 htab = ppc_hash_table (info);
4494 fdh = get_fdh (eh, htab);
4495 if (fdh == NULL
4496 && !info->relocatable
4497 && (eh->elf.root.type == bfd_link_hash_undefined
4498 || eh->elf.root.type == bfd_link_hash_undefweak)
4499 && eh->elf.ref_regular)
4500 {
4501 /* Make an undefweak function descriptor sym, which is enough to
4502 pull in an --as-needed shared lib, but won't cause link
4503 errors. Archives are handled elsewhere. */
4504 fdh = make_fdh (info, eh);
4505 if (fdh == NULL)
4506 return FALSE;
4507 else
4508 fdh->elf.ref_regular = 1;
4509 }
4510 else if (fdh != NULL)
4511 {
4512 unsigned entry_vis = ELF_ST_VISIBILITY (eh->elf.other) - 1;
4513 unsigned descr_vis = ELF_ST_VISIBILITY (fdh->elf.other) - 1;
4514 if (entry_vis < descr_vis)
4515 fdh->elf.other += entry_vis - descr_vis;
4516 else if (entry_vis > descr_vis)
4517 eh->elf.other += descr_vis - entry_vis;
4518
4519 if ((fdh->elf.root.type == bfd_link_hash_defined
4520 || fdh->elf.root.type == bfd_link_hash_defweak)
4521 && eh->elf.root.type == bfd_link_hash_undefined)
4522 {
4523 eh->elf.root.type = bfd_link_hash_undefweak;
4524 eh->was_undefined = 1;
4525 htab->twiddled_syms = 1;
4526 }
4527 }
4528
4529 return TRUE;
4530 }
4531
4532 /* Process list of dot-symbols we made in link_hash_newfunc. */
4533
4534 static bfd_boolean
4535 ppc64_elf_process_dot_syms (bfd *ibfd, struct bfd_link_info *info)
4536 {
4537 struct ppc_link_hash_table *htab;
4538 struct ppc_link_hash_entry **p, *eh;
4539
4540 htab = ppc_hash_table (info);
4541 if (!is_ppc64_elf (info->output_bfd))
4542 return TRUE;
4543
4544 if (is_ppc64_elf (ibfd))
4545 {
4546 p = &htab->dot_syms;
4547 while ((eh = *p) != NULL)
4548 {
4549 *p = NULL;
4550 if (!add_symbol_adjust (eh, info))
4551 return FALSE;
4552 p = &eh->u.next_dot_sym;
4553 }
4554 }
4555
4556 /* Clear the list for non-ppc64 input files. */
4557 p = &htab->dot_syms;
4558 while ((eh = *p) != NULL)
4559 {
4560 *p = NULL;
4561 p = &eh->u.next_dot_sym;
4562 }
4563
4564 /* We need to fix the undefs list for any syms we have twiddled to
4565 undef_weak. */
4566 if (htab->twiddled_syms)
4567 {
4568 bfd_link_repair_undef_list (&htab->elf.root);
4569 htab->twiddled_syms = 0;
4570 }
4571 return TRUE;
4572 }
4573
4574 /* Undo hash table changes when an --as-needed input file is determined
4575 not to be needed. */
4576
4577 static bfd_boolean
4578 ppc64_elf_as_needed_cleanup (bfd *ibfd ATTRIBUTE_UNUSED,
4579 struct bfd_link_info *info)
4580 {
4581 ppc_hash_table (info)->dot_syms = NULL;
4582 return TRUE;
4583 }
4584
4585 static struct plt_entry **
4586 update_local_sym_info (bfd *abfd, Elf_Internal_Shdr *symtab_hdr,
4587 unsigned long r_symndx, bfd_vma r_addend, int tls_type)
4588 {
4589 struct got_entry **local_got_ents = elf_local_got_ents (abfd);
4590 struct plt_entry **local_plt;
4591 char *local_got_tls_masks;
4592
4593 if (local_got_ents == NULL)
4594 {
4595 bfd_size_type size = symtab_hdr->sh_info;
4596
4597 size *= (sizeof (*local_got_ents)
4598 + sizeof (*local_plt)
4599 + sizeof (*local_got_tls_masks));
4600 local_got_ents = bfd_zalloc (abfd, size);
4601 if (local_got_ents == NULL)
4602 return NULL;
4603 elf_local_got_ents (abfd) = local_got_ents;
4604 }
4605
4606 if ((tls_type & (PLT_IFUNC | TLS_EXPLICIT)) == 0)
4607 {
4608 struct got_entry *ent;
4609
4610 for (ent = local_got_ents[r_symndx]; ent != NULL; ent = ent->next)
4611 if (ent->addend == r_addend
4612 && ent->owner == abfd
4613 && ent->tls_type == tls_type)
4614 break;
4615 if (ent == NULL)
4616 {
4617 bfd_size_type amt = sizeof (*ent);
4618 ent = bfd_alloc (abfd, amt);
4619 if (ent == NULL)
4620 return FALSE;
4621 ent->next = local_got_ents[r_symndx];
4622 ent->addend = r_addend;
4623 ent->owner = abfd;
4624 ent->tls_type = tls_type;
4625 ent->got.refcount = 0;
4626 local_got_ents[r_symndx] = ent;
4627 }
4628 ent->got.refcount += 1;
4629 }
4630
4631 local_plt = (struct plt_entry **) (local_got_ents + symtab_hdr->sh_info);
4632 local_got_tls_masks = (char *) (local_plt + symtab_hdr->sh_info);
4633 local_got_tls_masks[r_symndx] |= tls_type;
4634
4635 return local_plt + r_symndx;
4636 }
4637
4638 static bfd_boolean
4639 update_plt_info (bfd *abfd, struct plt_entry **plist, bfd_vma addend)
4640 {
4641 struct plt_entry *ent;
4642
4643 for (ent = *plist; ent != NULL; ent = ent->next)
4644 if (ent->addend == addend)
4645 break;
4646 if (ent == NULL)
4647 {
4648 bfd_size_type amt = sizeof (*ent);
4649 ent = bfd_alloc (abfd, amt);
4650 if (ent == NULL)
4651 return FALSE;
4652 ent->next = *plist;
4653 ent->addend = addend;
4654 ent->plt.refcount = 0;
4655 *plist = ent;
4656 }
4657 ent->plt.refcount += 1;
4658 return TRUE;
4659 }
4660
4661 static bfd_boolean
4662 is_branch_reloc (enum elf_ppc64_reloc_type r_type)
4663 {
4664 return (r_type == R_PPC64_REL24
4665 || r_type == R_PPC64_REL14
4666 || r_type == R_PPC64_REL14_BRTAKEN
4667 || r_type == R_PPC64_REL14_BRNTAKEN
4668 || r_type == R_PPC64_ADDR24
4669 || r_type == R_PPC64_ADDR14
4670 || r_type == R_PPC64_ADDR14_BRTAKEN
4671 || r_type == R_PPC64_ADDR14_BRNTAKEN);
4672 }
4673
4674 /* Look through the relocs for a section during the first phase, and
4675 calculate needed space in the global offset table, procedure
4676 linkage table, and dynamic reloc sections. */
4677
4678 static bfd_boolean
4679 ppc64_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
4680 asection *sec, const Elf_Internal_Rela *relocs)
4681 {
4682 struct ppc_link_hash_table *htab;
4683 Elf_Internal_Shdr *symtab_hdr;
4684 struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
4685 const Elf_Internal_Rela *rel;
4686 const Elf_Internal_Rela *rel_end;
4687 asection *sreloc;
4688 asection **opd_sym_map;
4689 struct elf_link_hash_entry *tga, *dottga;
4690
4691 if (info->relocatable)
4692 return TRUE;
4693
4694 /* Don't do anything special with non-loaded, non-alloced sections.
4695 In particular, any relocs in such sections should not affect GOT
4696 and PLT reference counting (ie. we don't allow them to create GOT
4697 or PLT entries), there's no possibility or desire to optimize TLS
4698 relocs, and there's not much point in propagating relocs to shared
4699 libs that the dynamic linker won't relocate. */
4700 if ((sec->flags & SEC_ALLOC) == 0)
4701 return TRUE;
4702
4703 BFD_ASSERT (is_ppc64_elf (abfd));
4704
4705 htab = ppc_hash_table (info);
4706 tga = elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
4707 FALSE, FALSE, TRUE);
4708 dottga = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
4709 FALSE, FALSE, TRUE);
4710 symtab_hdr = &elf_symtab_hdr (abfd);
4711
4712 sym_hashes = elf_sym_hashes (abfd);
4713 sym_hashes_end = (sym_hashes
4714 + symtab_hdr->sh_size / sizeof (Elf64_External_Sym)
4715 - symtab_hdr->sh_info);
4716
4717 sreloc = NULL;
4718 opd_sym_map = NULL;
4719 if (strcmp (bfd_get_section_name (abfd, sec), ".opd") == 0)
4720 {
4721 /* Garbage collection needs some extra help with .opd sections.
4722 We don't want to necessarily keep everything referenced by
4723 relocs in .opd, as that would keep all functions. Instead,
4724 if we reference an .opd symbol (a function descriptor), we
4725 want to keep the function code symbol's section. This is
4726 easy for global symbols, but for local syms we need to keep
4727 information about the associated function section. */
4728 bfd_size_type amt;
4729
4730 amt = sec->size * sizeof (*opd_sym_map) / 8;
4731 opd_sym_map = bfd_zalloc (abfd, amt);
4732 if (opd_sym_map == NULL)
4733 return FALSE;
4734 ppc64_elf_section_data (sec)->u.opd.func_sec = opd_sym_map;
4735 BFD_ASSERT (ppc64_elf_section_data (sec)->sec_type == sec_normal);
4736 ppc64_elf_section_data (sec)->sec_type = sec_opd;
4737 }
4738
4739 if (htab->sfpr == NULL
4740 && !create_linkage_sections (htab->elf.dynobj, info))
4741 return FALSE;
4742
4743 rel_end = relocs + sec->reloc_count;
4744 for (rel = relocs; rel < rel_end; rel++)
4745 {
4746 unsigned long r_symndx;
4747 struct elf_link_hash_entry *h;
4748 enum elf_ppc64_reloc_type r_type;
4749 int tls_type;
4750 struct _ppc64_elf_section_data *ppc64_sec;
4751 struct plt_entry **ifunc;
4752
4753 r_symndx = ELF64_R_SYM (rel->r_info);
4754 if (r_symndx < symtab_hdr->sh_info)
4755 h = NULL;
4756 else
4757 {
4758 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
4759 while (h->root.type == bfd_link_hash_indirect
4760 || h->root.type == bfd_link_hash_warning)
4761 h = (struct elf_link_hash_entry *) h->root.u.i.link;
4762 }
4763
4764 tls_type = 0;
4765 ifunc = NULL;
4766 r_type = ELF64_R_TYPE (rel->r_info);
4767 if (is_branch_reloc (r_type))
4768 {
4769 if (h != NULL && (h == tga || h == dottga))
4770 {
4771 if (rel != relocs
4772 && (ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSGD
4773 || ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSLD))
4774 /* We have a new-style __tls_get_addr call with a marker
4775 reloc. */
4776 ;
4777 else
4778 /* Mark this section as having an old-style call. */
4779 sec->has_tls_get_addr_call = 1;
4780 }
4781
4782 /* STT_GNU_IFUNC symbols must have a PLT entry. */
4783 if (h != NULL)
4784 {
4785 if (h->type == STT_GNU_IFUNC)
4786 {
4787 h->needs_plt = 1;
4788 ifunc = &h->plt.plist;
4789 }
4790 }
4791 else
4792 {
4793 Elf_Internal_Sym *isym = bfd_sym_from_r_symndx (&htab->sym_cache,
4794 abfd, r_symndx);
4795 if (isym == NULL)
4796 return FALSE;
4797
4798 if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
4799 {
4800 ifunc = update_local_sym_info (abfd, symtab_hdr, r_symndx,
4801 rel->r_addend, PLT_IFUNC);
4802 if (ifunc == NULL)
4803 return FALSE;
4804 }
4805 }
4806 if (ifunc != NULL
4807 && !update_plt_info (abfd, ifunc, rel->r_addend))
4808 return FALSE;
4809 }
4810
4811 switch (r_type)
4812 {
4813 case R_PPC64_TLSGD:
4814 case R_PPC64_TLSLD:
4815 /* These special tls relocs tie a call to __tls_get_addr with
4816 its parameter symbol. */
4817 break;
4818
4819 case R_PPC64_GOT_TLSLD16:
4820 case R_PPC64_GOT_TLSLD16_LO:
4821 case R_PPC64_GOT_TLSLD16_HI:
4822 case R_PPC64_GOT_TLSLD16_HA:
4823 tls_type = TLS_TLS | TLS_LD;
4824 goto dogottls;
4825
4826 case R_PPC64_GOT_TLSGD16:
4827 case R_PPC64_GOT_TLSGD16_LO:
4828 case R_PPC64_GOT_TLSGD16_HI:
4829 case R_PPC64_GOT_TLSGD16_HA:
4830 tls_type = TLS_TLS | TLS_GD;
4831 goto dogottls;
4832
4833 case R_PPC64_GOT_TPREL16_DS:
4834 case R_PPC64_GOT_TPREL16_LO_DS:
4835 case R_PPC64_GOT_TPREL16_HI:
4836 case R_PPC64_GOT_TPREL16_HA:
4837 if (!info->executable)
4838 info->flags |= DF_STATIC_TLS;
4839 tls_type = TLS_TLS | TLS_TPREL;
4840 goto dogottls;
4841
4842 case R_PPC64_GOT_DTPREL16_DS:
4843 case R_PPC64_GOT_DTPREL16_LO_DS:
4844 case R_PPC64_GOT_DTPREL16_HI:
4845 case R_PPC64_GOT_DTPREL16_HA:
4846 tls_type = TLS_TLS | TLS_DTPREL;
4847 dogottls:
4848 sec->has_tls_reloc = 1;
4849 /* Fall thru */
4850
4851 case R_PPC64_GOT16:
4852 case R_PPC64_GOT16_DS:
4853 case R_PPC64_GOT16_HA:
4854 case R_PPC64_GOT16_HI:
4855 case R_PPC64_GOT16_LO:
4856 case R_PPC64_GOT16_LO_DS:
4857 /* This symbol requires a global offset table entry. */
4858 sec->has_toc_reloc = 1;
4859 if (ppc64_elf_tdata (abfd)->got == NULL
4860 && !create_got_section (abfd, info))
4861 return FALSE;
4862
4863 if (h != NULL)
4864 {
4865 struct ppc_link_hash_entry *eh;
4866 struct got_entry *ent;
4867
4868 eh = (struct ppc_link_hash_entry *) h;
4869 for (ent = eh->elf.got.glist; ent != NULL; ent = ent->next)
4870 if (ent->addend == rel->r_addend
4871 && ent->owner == abfd
4872 && ent->tls_type == tls_type)
4873 break;
4874 if (ent == NULL)
4875 {
4876 bfd_size_type amt = sizeof (*ent);
4877 ent = bfd_alloc (abfd, amt);
4878 if (ent == NULL)
4879 return FALSE;
4880 ent->next = eh->elf.got.glist;
4881 ent->addend = rel->r_addend;
4882 ent->owner = abfd;
4883 ent->tls_type = tls_type;
4884 ent->got.refcount = 0;
4885 eh->elf.got.glist = ent;
4886 }
4887 ent->got.refcount += 1;
4888 eh->tls_mask |= tls_type;
4889 }
4890 else
4891 /* This is a global offset table entry for a local symbol. */
4892 if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
4893 rel->r_addend, tls_type))
4894 return FALSE;
4895 break;
4896
4897 case R_PPC64_PLT16_HA:
4898 case R_PPC64_PLT16_HI:
4899 case R_PPC64_PLT16_LO:
4900 case R_PPC64_PLT32:
4901 case R_PPC64_PLT64:
4902 /* This symbol requires a procedure linkage table entry. We
4903 actually build the entry in adjust_dynamic_symbol,
4904 because this might be a case of linking PIC code without
4905 linking in any dynamic objects, in which case we don't
4906 need to generate a procedure linkage table after all. */
4907 if (h == NULL)
4908 {
4909 /* It does not make sense to have a procedure linkage
4910 table entry for a local symbol. */
4911 bfd_set_error (bfd_error_bad_value);
4912 return FALSE;
4913 }
4914 else
4915 {
4916 if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
4917 return FALSE;
4918 h->needs_plt = 1;
4919 if (h->root.root.string[0] == '.'
4920 && h->root.root.string[1] != '\0')
4921 ((struct ppc_link_hash_entry *) h)->is_func = 1;
4922 }
4923 break;
4924
4925 /* The following relocations don't need to propagate the
4926 relocation if linking a shared object since they are
4927 section relative. */
4928 case R_PPC64_SECTOFF:
4929 case R_PPC64_SECTOFF_LO:
4930 case R_PPC64_SECTOFF_HI:
4931 case R_PPC64_SECTOFF_HA:
4932 case R_PPC64_SECTOFF_DS:
4933 case R_PPC64_SECTOFF_LO_DS:
4934 case R_PPC64_DTPREL16:
4935 case R_PPC64_DTPREL16_LO:
4936 case R_PPC64_DTPREL16_HI:
4937 case R_PPC64_DTPREL16_HA:
4938 case R_PPC64_DTPREL16_DS:
4939 case R_PPC64_DTPREL16_LO_DS:
4940 case R_PPC64_DTPREL16_HIGHER:
4941 case R_PPC64_DTPREL16_HIGHERA:
4942 case R_PPC64_DTPREL16_HIGHEST:
4943 case R_PPC64_DTPREL16_HIGHESTA:
4944 break;
4945
4946 /* Nor do these. */
4947 case R_PPC64_TOC16:
4948 case R_PPC64_TOC16_LO:
4949 case R_PPC64_TOC16_HI:
4950 case R_PPC64_TOC16_HA:
4951 case R_PPC64_TOC16_DS:
4952 case R_PPC64_TOC16_LO_DS:
4953 sec->has_toc_reloc = 1;
4954 break;
4955
4956 /* This relocation describes the C++ object vtable hierarchy.
4957 Reconstruct it for later use during GC. */
4958 case R_PPC64_GNU_VTINHERIT:
4959 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
4960 return FALSE;
4961 break;
4962
4963 /* This relocation describes which C++ vtable entries are actually
4964 used. Record for later use during GC. */
4965 case R_PPC64_GNU_VTENTRY:
4966 BFD_ASSERT (h != NULL);
4967 if (h != NULL
4968 && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
4969 return FALSE;
4970 break;
4971
4972 case R_PPC64_REL14:
4973 case R_PPC64_REL14_BRTAKEN:
4974 case R_PPC64_REL14_BRNTAKEN:
4975 {
4976 asection *dest = NULL;
4977
4978 /* Heuristic: If jumping outside our section, chances are
4979 we are going to need a stub. */
4980 if (h != NULL)
4981 {
4982 /* If the sym is weak it may be overridden later, so
4983 don't assume we know where a weak sym lives. */
4984 if (h->root.type == bfd_link_hash_defined)
4985 dest = h->root.u.def.section;
4986 }
4987 else
4988 {
4989 Elf_Internal_Sym *isym;
4990
4991 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
4992 abfd, r_symndx);
4993 if (isym == NULL)
4994 return FALSE;
4995
4996 dest = bfd_section_from_elf_index (abfd, isym->st_shndx);
4997 }
4998
4999 if (dest != sec)
5000 ppc64_elf_section_data (sec)->has_14bit_branch = 1;
5001 }
5002 /* Fall through. */
5003
5004 case R_PPC64_REL24:
5005 if (h != NULL && ifunc == NULL)
5006 {
5007 /* We may need a .plt entry if the function this reloc
5008 refers to is in a shared lib. */
5009 if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5010 return FALSE;
5011 h->needs_plt = 1;
5012 if (h->root.root.string[0] == '.'
5013 && h->root.root.string[1] != '\0')
5014 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5015 if (h == tga || h == dottga)
5016 sec->has_tls_reloc = 1;
5017 }
5018 break;
5019
5020 case R_PPC64_TPREL64:
5021 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_TPREL;
5022 if (!info->executable)
5023 info->flags |= DF_STATIC_TLS;
5024 goto dotlstoc;
5025
5026 case R_PPC64_DTPMOD64:
5027 if (rel + 1 < rel_end
5028 && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
5029 && rel[1].r_offset == rel->r_offset + 8)
5030 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_GD;
5031 else
5032 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_LD;
5033 goto dotlstoc;
5034
5035 case R_PPC64_DTPREL64:
5036 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_DTPREL;
5037 if (rel != relocs
5038 && rel[-1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPMOD64)
5039 && rel[-1].r_offset == rel->r_offset - 8)
5040 /* This is the second reloc of a dtpmod, dtprel pair.
5041 Don't mark with TLS_DTPREL. */
5042 goto dodyn;
5043
5044 dotlstoc:
5045 sec->has_tls_reloc = 1;
5046 if (h != NULL)
5047 {
5048 struct ppc_link_hash_entry *eh;
5049 eh = (struct ppc_link_hash_entry *) h;
5050 eh->tls_mask |= tls_type;
5051 }
5052 else
5053 if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5054 rel->r_addend, tls_type))
5055 return FALSE;
5056
5057 ppc64_sec = ppc64_elf_section_data (sec);
5058 if (ppc64_sec->sec_type != sec_toc)
5059 {
5060 bfd_size_type amt;
5061
5062 /* One extra to simplify get_tls_mask. */
5063 amt = sec->size * sizeof (unsigned) / 8 + sizeof (unsigned);
5064 ppc64_sec->u.toc.symndx = bfd_zalloc (abfd, amt);
5065 if (ppc64_sec->u.toc.symndx == NULL)
5066 return FALSE;
5067 amt = sec->size * sizeof (bfd_vma) / 8;
5068 ppc64_sec->u.toc.add = bfd_zalloc (abfd, amt);
5069 if (ppc64_sec->u.toc.add == NULL)
5070 return FALSE;
5071 BFD_ASSERT (ppc64_sec->sec_type == sec_normal);
5072 ppc64_sec->sec_type = sec_toc;
5073 }
5074 BFD_ASSERT (rel->r_offset % 8 == 0);
5075 ppc64_sec->u.toc.symndx[rel->r_offset / 8] = r_symndx;
5076 ppc64_sec->u.toc.add[rel->r_offset / 8] = rel->r_addend;
5077
5078 /* Mark the second slot of a GD or LD entry.
5079 -1 to indicate GD and -2 to indicate LD. */
5080 if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_GD))
5081 ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -1;
5082 else if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_LD))
5083 ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -2;
5084 goto dodyn;
5085
5086 case R_PPC64_TPREL16:
5087 case R_PPC64_TPREL16_LO:
5088 case R_PPC64_TPREL16_HI:
5089 case R_PPC64_TPREL16_HA:
5090 case R_PPC64_TPREL16_DS:
5091 case R_PPC64_TPREL16_LO_DS:
5092 case R_PPC64_TPREL16_HIGHER:
5093 case R_PPC64_TPREL16_HIGHERA:
5094 case R_PPC64_TPREL16_HIGHEST:
5095 case R_PPC64_TPREL16_HIGHESTA:
5096 if (info->shared)
5097 {
5098 if (!info->executable)
5099 info->flags |= DF_STATIC_TLS;
5100 goto dodyn;
5101 }
5102 break;
5103
5104 case R_PPC64_ADDR64:
5105 if (opd_sym_map != NULL
5106 && rel + 1 < rel_end
5107 && ELF64_R_TYPE ((rel + 1)->r_info) == R_PPC64_TOC)
5108 {
5109 if (h != NULL)
5110 {
5111 if (h->root.root.string[0] == '.'
5112 && h->root.root.string[1] != 0
5113 && get_fdh ((struct ppc_link_hash_entry *) h, htab))
5114 ;
5115 else
5116 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5117 }
5118 else
5119 {
5120 asection *s;
5121 Elf_Internal_Sym *isym;
5122
5123 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5124 abfd, r_symndx);
5125 if (isym == NULL)
5126 return FALSE;
5127
5128 s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5129 if (s != NULL && s != sec)
5130 opd_sym_map[rel->r_offset / 8] = s;
5131 }
5132 }
5133 /* Fall through. */
5134
5135 case R_PPC64_REL30:
5136 case R_PPC64_REL32:
5137 case R_PPC64_REL64:
5138 case R_PPC64_ADDR14:
5139 case R_PPC64_ADDR14_BRNTAKEN:
5140 case R_PPC64_ADDR14_BRTAKEN:
5141 case R_PPC64_ADDR16:
5142 case R_PPC64_ADDR16_DS:
5143 case R_PPC64_ADDR16_HA:
5144 case R_PPC64_ADDR16_HI:
5145 case R_PPC64_ADDR16_HIGHER:
5146 case R_PPC64_ADDR16_HIGHERA:
5147 case R_PPC64_ADDR16_HIGHEST:
5148 case R_PPC64_ADDR16_HIGHESTA:
5149 case R_PPC64_ADDR16_LO:
5150 case R_PPC64_ADDR16_LO_DS:
5151 case R_PPC64_ADDR24:
5152 case R_PPC64_ADDR32:
5153 case R_PPC64_UADDR16:
5154 case R_PPC64_UADDR32:
5155 case R_PPC64_UADDR64:
5156 case R_PPC64_TOC:
5157 if (h != NULL && !info->shared)
5158 /* We may need a copy reloc. */
5159 h->non_got_ref = 1;
5160
5161 /* Don't propagate .opd relocs. */
5162 if (NO_OPD_RELOCS && opd_sym_map != NULL)
5163 break;
5164
5165 /* If we are creating a shared library, and this is a reloc
5166 against a global symbol, or a non PC relative reloc
5167 against a local symbol, then we need to copy the reloc
5168 into the shared library. However, if we are linking with
5169 -Bsymbolic, we do not need to copy a reloc against a
5170 global symbol which is defined in an object we are
5171 including in the link (i.e., DEF_REGULAR is set). At
5172 this point we have not seen all the input files, so it is
5173 possible that DEF_REGULAR is not set now but will be set
5174 later (it is never cleared). In case of a weak definition,
5175 DEF_REGULAR may be cleared later by a strong definition in
5176 a shared library. We account for that possibility below by
5177 storing information in the dyn_relocs field of the hash
5178 table entry. A similar situation occurs when creating
5179 shared libraries and symbol visibility changes render the
5180 symbol local.
5181
5182 If on the other hand, we are creating an executable, we
5183 may need to keep relocations for symbols satisfied by a
5184 dynamic library if we manage to avoid copy relocs for the
5185 symbol. */
5186 dodyn:
5187 if ((info->shared
5188 && (must_be_dyn_reloc (info, r_type)
5189 || (h != NULL
5190 && (! info->symbolic
5191 || h->root.type == bfd_link_hash_defweak
5192 || !h->def_regular))))
5193 || (ELIMINATE_COPY_RELOCS
5194 && !info->shared
5195 && h != NULL
5196 && (h->root.type == bfd_link_hash_defweak
5197 || !h->def_regular)))
5198 {
5199 struct ppc_dyn_relocs *p;
5200 struct ppc_dyn_relocs **head;
5201
5202 /* We must copy these reloc types into the output file.
5203 Create a reloc section in dynobj and make room for
5204 this reloc. */
5205 if (sreloc == NULL)
5206 {
5207 sreloc = _bfd_elf_make_dynamic_reloc_section
5208 (sec, htab->elf.dynobj, 3, abfd, /*rela?*/ TRUE);
5209
5210 if (sreloc == NULL)
5211 return FALSE;
5212 }
5213
5214 /* If this is a global symbol, we count the number of
5215 relocations we need for this symbol. */
5216 if (h != NULL)
5217 {
5218 head = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
5219 }
5220 else
5221 {
5222 /* Track dynamic relocs needed for local syms too.
5223 We really need local syms available to do this
5224 easily. Oh well. */
5225 asection *s;
5226 void *vpp;
5227 Elf_Internal_Sym *isym;
5228
5229 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5230 abfd, r_symndx);
5231 if (isym == NULL)
5232 return FALSE;
5233
5234 s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5235 if (s == NULL)
5236 s = sec;
5237
5238 vpp = &elf_section_data (s)->local_dynrel;
5239 head = (struct ppc_dyn_relocs **) vpp;
5240 }
5241
5242 p = *head;
5243 if (p == NULL || p->sec != sec)
5244 {
5245 p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5246 if (p == NULL)
5247 return FALSE;
5248 p->next = *head;
5249 *head = p;
5250 p->sec = sec;
5251 p->count = 0;
5252 p->pc_count = 0;
5253 }
5254
5255 p->count += 1;
5256 if (!must_be_dyn_reloc (info, r_type))
5257 p->pc_count += 1;
5258 }
5259 break;
5260
5261 default:
5262 break;
5263 }
5264 }
5265
5266 return TRUE;
5267 }
5268
5269 /* OFFSET in OPD_SEC specifies a function descriptor. Return the address
5270 of the code entry point, and its section. */
5271
5272 static bfd_vma
5273 opd_entry_value (asection *opd_sec,
5274 bfd_vma offset,
5275 asection **code_sec,
5276 bfd_vma *code_off)
5277 {
5278 bfd *opd_bfd = opd_sec->owner;
5279 Elf_Internal_Rela *relocs;
5280 Elf_Internal_Rela *lo, *hi, *look;
5281 bfd_vma val;
5282
5283 /* No relocs implies we are linking a --just-symbols object. */
5284 if (opd_sec->reloc_count == 0)
5285 {
5286 bfd_vma val;
5287
5288 if (!bfd_get_section_contents (opd_bfd, opd_sec, &val, offset, 8))
5289 return (bfd_vma) -1;
5290
5291 if (code_sec != NULL)
5292 {
5293 asection *sec, *likely = NULL;
5294 for (sec = opd_bfd->sections; sec != NULL; sec = sec->next)
5295 if (sec->vma <= val
5296 && (sec->flags & SEC_LOAD) != 0
5297 && (sec->flags & SEC_ALLOC) != 0)
5298 likely = sec;
5299 if (likely != NULL)
5300 {
5301 *code_sec = likely;
5302 if (code_off != NULL)
5303 *code_off = val - likely->vma;
5304 }
5305 }
5306 return val;
5307 }
5308
5309 BFD_ASSERT (is_ppc64_elf (opd_bfd));
5310
5311 relocs = ppc64_elf_tdata (opd_bfd)->opd_relocs;
5312 if (relocs == NULL)
5313 relocs = _bfd_elf_link_read_relocs (opd_bfd, opd_sec, NULL, NULL, TRUE);
5314
5315 /* Go find the opd reloc at the sym address. */
5316 lo = relocs;
5317 BFD_ASSERT (lo != NULL);
5318 hi = lo + opd_sec->reloc_count - 1; /* ignore last reloc */
5319 val = (bfd_vma) -1;
5320 while (lo < hi)
5321 {
5322 look = lo + (hi - lo) / 2;
5323 if (look->r_offset < offset)
5324 lo = look + 1;
5325 else if (look->r_offset > offset)
5326 hi = look;
5327 else
5328 {
5329 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (opd_bfd);
5330
5331 if (ELF64_R_TYPE (look->r_info) == R_PPC64_ADDR64
5332 && ELF64_R_TYPE ((look + 1)->r_info) == R_PPC64_TOC)
5333 {
5334 unsigned long symndx = ELF64_R_SYM (look->r_info);
5335 asection *sec;
5336
5337 if (symndx < symtab_hdr->sh_info)
5338 {
5339 Elf_Internal_Sym *sym;
5340
5341 sym = (Elf_Internal_Sym *) symtab_hdr->contents;
5342 if (sym == NULL)
5343 {
5344 sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr,
5345 symtab_hdr->sh_info,
5346 0, NULL, NULL, NULL);
5347 if (sym == NULL)
5348 break;
5349 symtab_hdr->contents = (bfd_byte *) sym;
5350 }
5351
5352 sym += symndx;
5353 val = sym->st_value;
5354 sec = bfd_section_from_elf_index (opd_bfd, sym->st_shndx);
5355 BFD_ASSERT ((sec->flags & SEC_MERGE) == 0);
5356 }
5357 else
5358 {
5359 struct elf_link_hash_entry **sym_hashes;
5360 struct elf_link_hash_entry *rh;
5361
5362 sym_hashes = elf_sym_hashes (opd_bfd);
5363 rh = sym_hashes[symndx - symtab_hdr->sh_info];
5364 while (rh->root.type == bfd_link_hash_indirect
5365 || rh->root.type == bfd_link_hash_warning)
5366 rh = ((struct elf_link_hash_entry *) rh->root.u.i.link);
5367 BFD_ASSERT (rh->root.type == bfd_link_hash_defined
5368 || rh->root.type == bfd_link_hash_defweak);
5369 val = rh->root.u.def.value;
5370 sec = rh->root.u.def.section;
5371 }
5372 val += look->r_addend;
5373 if (code_off != NULL)
5374 *code_off = val;
5375 if (code_sec != NULL)
5376 *code_sec = sec;
5377 if (sec != NULL && sec->output_section != NULL)
5378 val += sec->output_section->vma + sec->output_offset;
5379 }
5380 break;
5381 }
5382 }
5383
5384 return val;
5385 }
5386
5387 /* Mark all our entry sym sections, both opd and code section. */
5388
5389 static void
5390 ppc64_elf_gc_keep (struct bfd_link_info *info)
5391 {
5392 struct ppc_link_hash_table *htab = ppc_hash_table (info);
5393 struct bfd_sym_chain *sym;
5394
5395 for (sym = info->gc_sym_list; sym != NULL; sym = sym->next)
5396 {
5397 struct ppc_link_hash_entry *eh;
5398 asection *sec;
5399
5400 eh = (struct ppc_link_hash_entry *)
5401 elf_link_hash_lookup (&htab->elf, sym->name, FALSE, FALSE, FALSE);
5402 if (eh == NULL)
5403 continue;
5404 if (eh->elf.root.type != bfd_link_hash_defined
5405 && eh->elf.root.type != bfd_link_hash_defweak)
5406 continue;
5407
5408 if (eh->is_func_descriptor
5409 && (eh->oh->elf.root.type == bfd_link_hash_defined
5410 || eh->oh->elf.root.type == bfd_link_hash_defweak))
5411 {
5412 sec = eh->oh->elf.root.u.def.section;
5413 sec->flags |= SEC_KEEP;
5414 }
5415 else if (get_opd_info (eh->elf.root.u.def.section) != NULL
5416 && opd_entry_value (eh->elf.root.u.def.section,
5417 eh->elf.root.u.def.value,
5418 &sec, NULL) != (bfd_vma) -1)
5419 sec->flags |= SEC_KEEP;
5420
5421 sec = eh->elf.root.u.def.section;
5422 sec->flags |= SEC_KEEP;
5423 }
5424 }
5425
5426 /* Mark sections containing dynamically referenced symbols. When
5427 building shared libraries, we must assume that any visible symbol is
5428 referenced. */
5429
5430 static bfd_boolean
5431 ppc64_elf_gc_mark_dynamic_ref (struct elf_link_hash_entry *h, void *inf)
5432 {
5433 struct bfd_link_info *info = (struct bfd_link_info *) inf;
5434 struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
5435
5436 if (eh->elf.root.type == bfd_link_hash_warning)
5437 eh = (struct ppc_link_hash_entry *) eh->elf.root.u.i.link;
5438
5439 /* Dynamic linking info is on the func descriptor sym. */
5440 if (eh->oh != NULL
5441 && eh->oh->is_func_descriptor
5442 && (eh->oh->elf.root.type == bfd_link_hash_defined
5443 || eh->oh->elf.root.type == bfd_link_hash_defweak))
5444 eh = eh->oh;
5445
5446 if ((eh->elf.root.type == bfd_link_hash_defined
5447 || eh->elf.root.type == bfd_link_hash_defweak)
5448 && (eh->elf.ref_dynamic
5449 || (!info->executable
5450 && eh->elf.def_regular
5451 && ELF_ST_VISIBILITY (eh->elf.other) != STV_INTERNAL
5452 && ELF_ST_VISIBILITY (eh->elf.other) != STV_HIDDEN)))
5453 {
5454 asection *code_sec;
5455
5456 eh->elf.root.u.def.section->flags |= SEC_KEEP;
5457
5458 /* Function descriptor syms cause the associated
5459 function code sym section to be marked. */
5460 if (eh->is_func_descriptor
5461 && (eh->oh->elf.root.type == bfd_link_hash_defined
5462 || eh->oh->elf.root.type == bfd_link_hash_defweak))
5463 eh->oh->elf.root.u.def.section->flags |= SEC_KEEP;
5464 else if (get_opd_info (eh->elf.root.u.def.section) != NULL
5465 && opd_entry_value (eh->elf.root.u.def.section,
5466 eh->elf.root.u.def.value,
5467 &code_sec, NULL) != (bfd_vma) -1)
5468 code_sec->flags |= SEC_KEEP;
5469 }
5470
5471 return TRUE;
5472 }
5473
5474 /* Return the section that should be marked against GC for a given
5475 relocation. */
5476
5477 static asection *
5478 ppc64_elf_gc_mark_hook (asection *sec,
5479 struct bfd_link_info *info ATTRIBUTE_UNUSED,
5480 Elf_Internal_Rela *rel,
5481 struct elf_link_hash_entry *h,
5482 Elf_Internal_Sym *sym)
5483 {
5484 asection *rsec;
5485
5486 /* Syms return NULL if we're marking .opd, so we avoid marking all
5487 function sections, as all functions are referenced in .opd. */
5488 rsec = NULL;
5489 if (get_opd_info (sec) != NULL)
5490 return rsec;
5491
5492 if (h != NULL)
5493 {
5494 enum elf_ppc64_reloc_type r_type;
5495 struct ppc_link_hash_entry *eh;
5496
5497 r_type = ELF64_R_TYPE (rel->r_info);
5498 switch (r_type)
5499 {
5500 case R_PPC64_GNU_VTINHERIT:
5501 case R_PPC64_GNU_VTENTRY:
5502 break;
5503
5504 default:
5505 switch (h->root.type)
5506 {
5507 case bfd_link_hash_defined:
5508 case bfd_link_hash_defweak:
5509 eh = (struct ppc_link_hash_entry *) h;
5510 if (eh->oh != NULL
5511 && eh->oh->is_func_descriptor
5512 && (eh->oh->elf.root.type == bfd_link_hash_defined
5513 || eh->oh->elf.root.type == bfd_link_hash_defweak))
5514 eh = eh->oh;
5515
5516 /* Function descriptor syms cause the associated
5517 function code sym section to be marked. */
5518 if (eh->is_func_descriptor
5519 && (eh->oh->elf.root.type == bfd_link_hash_defined
5520 || eh->oh->elf.root.type == bfd_link_hash_defweak))
5521 {
5522 /* They also mark their opd section. */
5523 eh->elf.root.u.def.section->gc_mark = 1;
5524
5525 rsec = eh->oh->elf.root.u.def.section;
5526 }
5527 else if (get_opd_info (eh->elf.root.u.def.section) != NULL
5528 && opd_entry_value (eh->elf.root.u.def.section,
5529 eh->elf.root.u.def.value,
5530 &rsec, NULL) != (bfd_vma) -1)
5531 eh->elf.root.u.def.section->gc_mark = 1;
5532 else
5533 rsec = h->root.u.def.section;
5534 break;
5535
5536 case bfd_link_hash_common:
5537 rsec = h->root.u.c.p->section;
5538 break;
5539
5540 default:
5541 break;
5542 }
5543 }
5544 }
5545 else
5546 {
5547 struct _opd_sec_data *opd;
5548
5549 rsec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
5550 opd = get_opd_info (rsec);
5551 if (opd != NULL && opd->func_sec != NULL)
5552 {
5553 rsec->gc_mark = 1;
5554
5555 rsec = opd->func_sec[(sym->st_value + rel->r_addend) / 8];
5556 }
5557 }
5558
5559 return rsec;
5560 }
5561
5562 /* Update the .got, .plt. and dynamic reloc reference counts for the
5563 section being removed. */
5564
5565 static bfd_boolean
5566 ppc64_elf_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info,
5567 asection *sec, const Elf_Internal_Rela *relocs)
5568 {
5569 struct ppc_link_hash_table *htab;
5570 Elf_Internal_Shdr *symtab_hdr;
5571 struct elf_link_hash_entry **sym_hashes;
5572 struct got_entry **local_got_ents;
5573 const Elf_Internal_Rela *rel, *relend;
5574
5575 if (info->relocatable)
5576 return TRUE;
5577
5578 if ((sec->flags & SEC_ALLOC) == 0)
5579 return TRUE;
5580
5581 elf_section_data (sec)->local_dynrel = NULL;
5582
5583 htab = ppc_hash_table (info);
5584 symtab_hdr = &elf_symtab_hdr (abfd);
5585 sym_hashes = elf_sym_hashes (abfd);
5586 local_got_ents = elf_local_got_ents (abfd);
5587
5588 relend = relocs + sec->reloc_count;
5589 for (rel = relocs; rel < relend; rel++)
5590 {
5591 unsigned long r_symndx;
5592 enum elf_ppc64_reloc_type r_type;
5593 struct elf_link_hash_entry *h = NULL;
5594 char tls_type = 0;
5595
5596 r_symndx = ELF64_R_SYM (rel->r_info);
5597 r_type = ELF64_R_TYPE (rel->r_info);
5598 if (r_symndx >= symtab_hdr->sh_info)
5599 {
5600 struct ppc_link_hash_entry *eh;
5601 struct ppc_dyn_relocs **pp;
5602 struct ppc_dyn_relocs *p;
5603
5604 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
5605 while (h->root.type == bfd_link_hash_indirect
5606 || h->root.type == bfd_link_hash_warning)
5607 h = (struct elf_link_hash_entry *) h->root.u.i.link;
5608 eh = (struct ppc_link_hash_entry *) h;
5609
5610 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
5611 if (p->sec == sec)
5612 {
5613 /* Everything must go for SEC. */
5614 *pp = p->next;
5615 break;
5616 }
5617 }
5618
5619 if (is_branch_reloc (r_type))
5620 {
5621 struct plt_entry **ifunc = NULL;
5622 if (h != NULL)
5623 {
5624 if (h->type == STT_GNU_IFUNC)
5625 ifunc = &h->plt.plist;
5626 }
5627 else if (local_got_ents != NULL)
5628 {
5629 struct plt_entry **local_plt = (struct plt_entry **)
5630 (local_got_ents + symtab_hdr->sh_info);
5631 char *local_got_tls_masks = (char *)
5632 (local_plt + symtab_hdr->sh_info);
5633 if ((local_got_tls_masks[r_symndx] & PLT_IFUNC) != 0)
5634 ifunc = local_plt + r_symndx;
5635 }
5636 if (ifunc != NULL)
5637 {
5638 struct plt_entry *ent;
5639
5640 for (ent = *ifunc; ent != NULL; ent = ent->next)
5641 if (ent->addend == rel->r_addend)
5642 break;
5643 if (ent == NULL)
5644 abort ();
5645 if (ent->plt.refcount > 0)
5646 ent->plt.refcount -= 1;
5647 continue;
5648 }
5649 }
5650
5651 switch (r_type)
5652 {
5653 case R_PPC64_GOT_TLSLD16:
5654 case R_PPC64_GOT_TLSLD16_LO:
5655 case R_PPC64_GOT_TLSLD16_HI:
5656 case R_PPC64_GOT_TLSLD16_HA:
5657 tls_type = TLS_TLS | TLS_LD;
5658 goto dogot;
5659
5660 case R_PPC64_GOT_TLSGD16:
5661 case R_PPC64_GOT_TLSGD16_LO:
5662 case R_PPC64_GOT_TLSGD16_HI:
5663 case R_PPC64_GOT_TLSGD16_HA:
5664 tls_type = TLS_TLS | TLS_GD;
5665 goto dogot;
5666
5667 case R_PPC64_GOT_TPREL16_DS:
5668 case R_PPC64_GOT_TPREL16_LO_DS:
5669 case R_PPC64_GOT_TPREL16_HI:
5670 case R_PPC64_GOT_TPREL16_HA:
5671 tls_type = TLS_TLS | TLS_TPREL;
5672 goto dogot;
5673
5674 case R_PPC64_GOT_DTPREL16_DS:
5675 case R_PPC64_GOT_DTPREL16_LO_DS:
5676 case R_PPC64_GOT_DTPREL16_HI:
5677 case R_PPC64_GOT_DTPREL16_HA:
5678 tls_type = TLS_TLS | TLS_DTPREL;
5679 goto dogot;
5680
5681 case R_PPC64_GOT16:
5682 case R_PPC64_GOT16_DS:
5683 case R_PPC64_GOT16_HA:
5684 case R_PPC64_GOT16_HI:
5685 case R_PPC64_GOT16_LO:
5686 case R_PPC64_GOT16_LO_DS:
5687 dogot:
5688 {
5689 struct got_entry *ent;
5690
5691 if (h != NULL)
5692 ent = h->got.glist;
5693 else
5694 ent = local_got_ents[r_symndx];
5695
5696 for (; ent != NULL; ent = ent->next)
5697 if (ent->addend == rel->r_addend
5698 && ent->owner == abfd
5699 && ent->tls_type == tls_type)
5700 break;
5701 if (ent == NULL)
5702 abort ();
5703 if (ent->got.refcount > 0)
5704 ent->got.refcount -= 1;
5705 }
5706 break;
5707
5708 case R_PPC64_PLT16_HA:
5709 case R_PPC64_PLT16_HI:
5710 case R_PPC64_PLT16_LO:
5711 case R_PPC64_PLT32:
5712 case R_PPC64_PLT64:
5713 case R_PPC64_REL14:
5714 case R_PPC64_REL14_BRNTAKEN:
5715 case R_PPC64_REL14_BRTAKEN:
5716 case R_PPC64_REL24:
5717 if (h != NULL)
5718 {
5719 struct plt_entry *ent;
5720
5721 for (ent = h->plt.plist; ent != NULL; ent = ent->next)
5722 if (ent->addend == rel->r_addend)
5723 break;
5724 if (ent == NULL)
5725 abort ();
5726 if (ent->plt.refcount > 0)
5727 ent->plt.refcount -= 1;
5728 }
5729 break;
5730
5731 default:
5732 break;
5733 }
5734 }
5735 return TRUE;
5736 }
5737
5738 /* The maximum size of .sfpr. */
5739 #define SFPR_MAX (218*4)
5740
5741 struct sfpr_def_parms
5742 {
5743 const char name[12];
5744 unsigned char lo, hi;
5745 bfd_byte * (*write_ent) (bfd *, bfd_byte *, int);
5746 bfd_byte * (*write_tail) (bfd *, bfd_byte *, int);
5747 };
5748
5749 /* Auto-generate _save*, _rest* functions in .sfpr. */
5750
5751 static unsigned int
5752 sfpr_define (struct bfd_link_info *info, const struct sfpr_def_parms *parm)
5753 {
5754 struct ppc_link_hash_table *htab = ppc_hash_table (info);
5755 unsigned int i;
5756 size_t len = strlen (parm->name);
5757 bfd_boolean writing = FALSE;
5758 char sym[16];
5759
5760 memcpy (sym, parm->name, len);
5761 sym[len + 2] = 0;
5762
5763 for (i = parm->lo; i <= parm->hi; i++)
5764 {
5765 struct elf_link_hash_entry *h;
5766
5767 sym[len + 0] = i / 10 + '0';
5768 sym[len + 1] = i % 10 + '0';
5769 h = elf_link_hash_lookup (&htab->elf, sym, FALSE, FALSE, TRUE);
5770 if (h != NULL
5771 && !h->def_regular)
5772 {
5773 h->root.type = bfd_link_hash_defined;
5774 h->root.u.def.section = htab->sfpr;
5775 h->root.u.def.value = htab->sfpr->size;
5776 h->type = STT_FUNC;
5777 h->def_regular = 1;
5778 _bfd_elf_link_hash_hide_symbol (info, h, TRUE);
5779 writing = TRUE;
5780 if (htab->sfpr->contents == NULL)
5781 {
5782 htab->sfpr->contents = bfd_alloc (htab->elf.dynobj, SFPR_MAX);
5783 if (htab->sfpr->contents == NULL)
5784 return FALSE;
5785 }
5786 }
5787 if (writing)
5788 {
5789 bfd_byte *p = htab->sfpr->contents + htab->sfpr->size;
5790 if (i != parm->hi)
5791 p = (*parm->write_ent) (htab->elf.dynobj, p, i);
5792 else
5793 p = (*parm->write_tail) (htab->elf.dynobj, p, i);
5794 htab->sfpr->size = p - htab->sfpr->contents;
5795 }
5796 }
5797
5798 return TRUE;
5799 }
5800
5801 static bfd_byte *
5802 savegpr0 (bfd *abfd, bfd_byte *p, int r)
5803 {
5804 bfd_put_32 (abfd, STD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
5805 return p + 4;
5806 }
5807
5808 static bfd_byte *
5809 savegpr0_tail (bfd *abfd, bfd_byte *p, int r)
5810 {
5811 p = savegpr0 (abfd, p, r);
5812 bfd_put_32 (abfd, STD_R0_0R1 + 16, p);
5813 p = p + 4;
5814 bfd_put_32 (abfd, BLR, p);
5815 return p + 4;
5816 }
5817
5818 static bfd_byte *
5819 restgpr0 (bfd *abfd, bfd_byte *p, int r)
5820 {
5821 bfd_put_32 (abfd, LD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
5822 return p + 4;
5823 }
5824
5825 static bfd_byte *
5826 restgpr0_tail (bfd *abfd, bfd_byte *p, int r)
5827 {
5828 bfd_put_32 (abfd, LD_R0_0R1 + 16, p);
5829 p = p + 4;
5830 p = restgpr0 (abfd, p, r);
5831 bfd_put_32 (abfd, MTLR_R0, p);
5832 p = p + 4;
5833 if (r == 29)
5834 {
5835 p = restgpr0 (abfd, p, 30);
5836 p = restgpr0 (abfd, p, 31);
5837 }
5838 bfd_put_32 (abfd, BLR, p);
5839 return p + 4;
5840 }
5841
5842 static bfd_byte *
5843 savegpr1 (bfd *abfd, bfd_byte *p, int r)
5844 {
5845 bfd_put_32 (abfd, STD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
5846 return p + 4;
5847 }
5848
5849 static bfd_byte *
5850 savegpr1_tail (bfd *abfd, bfd_byte *p, int r)
5851 {
5852 p = savegpr1 (abfd, p, r);
5853 bfd_put_32 (abfd, BLR, p);
5854 return p + 4;
5855 }
5856
5857 static bfd_byte *
5858 restgpr1 (bfd *abfd, bfd_byte *p, int r)
5859 {
5860 bfd_put_32 (abfd, LD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
5861 return p + 4;
5862 }
5863
5864 static bfd_byte *
5865 restgpr1_tail (bfd *abfd, bfd_byte *p, int r)
5866 {
5867 p = restgpr1 (abfd, p, r);
5868 bfd_put_32 (abfd, BLR, p);
5869 return p + 4;
5870 }
5871
5872 static bfd_byte *
5873 savefpr (bfd *abfd, bfd_byte *p, int r)
5874 {
5875 bfd_put_32 (abfd, STFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
5876 return p + 4;
5877 }
5878
5879 static bfd_byte *
5880 savefpr0_tail (bfd *abfd, bfd_byte *p, int r)
5881 {
5882 p = savefpr (abfd, p, r);
5883 bfd_put_32 (abfd, STD_R0_0R1 + 16, p);
5884 p = p + 4;
5885 bfd_put_32 (abfd, BLR, p);
5886 return p + 4;
5887 }
5888
5889 static bfd_byte *
5890 restfpr (bfd *abfd, bfd_byte *p, int r)
5891 {
5892 bfd_put_32 (abfd, LFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
5893 return p + 4;
5894 }
5895
5896 static bfd_byte *
5897 restfpr0_tail (bfd *abfd, bfd_byte *p, int r)
5898 {
5899 bfd_put_32 (abfd, LD_R0_0R1 + 16, p);
5900 p = p + 4;
5901 p = restfpr (abfd, p, r);
5902 bfd_put_32 (abfd, MTLR_R0, p);
5903 p = p + 4;
5904 if (r == 29)
5905 {
5906 p = restfpr (abfd, p, 30);
5907 p = restfpr (abfd, p, 31);
5908 }
5909 bfd_put_32 (abfd, BLR, p);
5910 return p + 4;
5911 }
5912
5913 static bfd_byte *
5914 savefpr1_tail (bfd *abfd, bfd_byte *p, int r)
5915 {
5916 p = savefpr (abfd, p, r);
5917 bfd_put_32 (abfd, BLR, p);
5918 return p + 4;
5919 }
5920
5921 static bfd_byte *
5922 restfpr1_tail (bfd *abfd, bfd_byte *p, int r)
5923 {
5924 p = restfpr (abfd, p, r);
5925 bfd_put_32 (abfd, BLR, p);
5926 return p + 4;
5927 }
5928
5929 static bfd_byte *
5930 savevr (bfd *abfd, bfd_byte *p, int r)
5931 {
5932 bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
5933 p = p + 4;
5934 bfd_put_32 (abfd, STVX_VR0_R12_R0 + (r << 21), p);
5935 return p + 4;
5936 }
5937
5938 static bfd_byte *
5939 savevr_tail (bfd *abfd, bfd_byte *p, int r)
5940 {
5941 p = savevr (abfd, p, r);
5942 bfd_put_32 (abfd, BLR, p);
5943 return p + 4;
5944 }
5945
5946 static bfd_byte *
5947 restvr (bfd *abfd, bfd_byte *p, int r)
5948 {
5949 bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
5950 p = p + 4;
5951 bfd_put_32 (abfd, LVX_VR0_R12_R0 + (r << 21), p);
5952 return p + 4;
5953 }
5954
5955 static bfd_byte *
5956 restvr_tail (bfd *abfd, bfd_byte *p, int r)
5957 {
5958 p = restvr (abfd, p, r);
5959 bfd_put_32 (abfd, BLR, p);
5960 return p + 4;
5961 }
5962
5963 /* Called via elf_link_hash_traverse to transfer dynamic linking
5964 information on function code symbol entries to their corresponding
5965 function descriptor symbol entries. */
5966
5967 static bfd_boolean
5968 func_desc_adjust (struct elf_link_hash_entry *h, void *inf)
5969 {
5970 struct bfd_link_info *info;
5971 struct ppc_link_hash_table *htab;
5972 struct plt_entry *ent;
5973 struct ppc_link_hash_entry *fh;
5974 struct ppc_link_hash_entry *fdh;
5975 bfd_boolean force_local;
5976
5977 fh = (struct ppc_link_hash_entry *) h;
5978 if (fh->elf.root.type == bfd_link_hash_indirect)
5979 return TRUE;
5980
5981 if (fh->elf.root.type == bfd_link_hash_warning)
5982 fh = (struct ppc_link_hash_entry *) fh->elf.root.u.i.link;
5983
5984 info = inf;
5985 htab = ppc_hash_table (info);
5986
5987 /* Resolve undefined references to dot-symbols as the value
5988 in the function descriptor, if we have one in a regular object.
5989 This is to satisfy cases like ".quad .foo". Calls to functions
5990 in dynamic objects are handled elsewhere. */
5991 if (fh->elf.root.type == bfd_link_hash_undefweak
5992 && fh->was_undefined
5993 && (fh->oh->elf.root.type == bfd_link_hash_defined
5994 || fh->oh->elf.root.type == bfd_link_hash_defweak)
5995 && get_opd_info (fh->oh->elf.root.u.def.section) != NULL
5996 && opd_entry_value (fh->oh->elf.root.u.def.section,
5997 fh->oh->elf.root.u.def.value,
5998 &fh->elf.root.u.def.section,
5999 &fh->elf.root.u.def.value) != (bfd_vma) -1)
6000 {
6001 fh->elf.root.type = fh->oh->elf.root.type;
6002 fh->elf.forced_local = 1;
6003 fh->elf.def_regular = fh->oh->elf.def_regular;
6004 fh->elf.def_dynamic = fh->oh->elf.def_dynamic;
6005 }
6006
6007 /* If this is a function code symbol, transfer dynamic linking
6008 information to the function descriptor symbol. */
6009 if (!fh->is_func)
6010 return TRUE;
6011
6012 for (ent = fh->elf.plt.plist; ent != NULL; ent = ent->next)
6013 if (ent->plt.refcount > 0)
6014 break;
6015 if (ent == NULL
6016 || fh->elf.root.root.string[0] != '.'
6017 || fh->elf.root.root.string[1] == '\0')
6018 return TRUE;
6019
6020 /* Find the corresponding function descriptor symbol. Create it
6021 as undefined if necessary. */
6022
6023 fdh = get_fdh (fh, htab);
6024 if (fdh != NULL)
6025 while (fdh->elf.root.type == bfd_link_hash_indirect
6026 || fdh->elf.root.type == bfd_link_hash_warning)
6027 fdh = (struct ppc_link_hash_entry *) fdh->elf.root.u.i.link;
6028
6029 if (fdh == NULL
6030 && !info->executable
6031 && (fh->elf.root.type == bfd_link_hash_undefined
6032 || fh->elf.root.type == bfd_link_hash_undefweak))
6033 {
6034 fdh = make_fdh (info, fh);
6035 if (fdh == NULL)
6036 return FALSE;
6037 }
6038
6039 /* Fake function descriptors are made undefweak. If the function
6040 code symbol is strong undefined, make the fake sym the same.
6041 If the function code symbol is defined, then force the fake
6042 descriptor local; We can't support overriding of symbols in a
6043 shared library on a fake descriptor. */
6044
6045 if (fdh != NULL
6046 && fdh->fake
6047 && fdh->elf.root.type == bfd_link_hash_undefweak)
6048 {
6049 if (fh->elf.root.type == bfd_link_hash_undefined)
6050 {
6051 fdh->elf.root.type = bfd_link_hash_undefined;
6052 bfd_link_add_undef (&htab->elf.root, &fdh->elf.root);
6053 }
6054 else if (fh->elf.root.type == bfd_link_hash_defined
6055 || fh->elf.root.type == bfd_link_hash_defweak)
6056 {
6057 _bfd_elf_link_hash_hide_symbol (info, &fdh->elf, TRUE);
6058 }
6059 }
6060
6061 if (fdh != NULL
6062 && !fdh->elf.forced_local
6063 && (!info->executable
6064 || fdh->elf.def_dynamic
6065 || fdh->elf.ref_dynamic
6066 || (fdh->elf.root.type == bfd_link_hash_undefweak
6067 && ELF_ST_VISIBILITY (fdh->elf.other) == STV_DEFAULT)))
6068 {
6069 if (fdh->elf.dynindx == -1)
6070 if (! bfd_elf_link_record_dynamic_symbol (info, &fdh->elf))
6071 return FALSE;
6072 fdh->elf.ref_regular |= fh->elf.ref_regular;
6073 fdh->elf.ref_dynamic |= fh->elf.ref_dynamic;
6074 fdh->elf.ref_regular_nonweak |= fh->elf.ref_regular_nonweak;
6075 fdh->elf.non_got_ref |= fh->elf.non_got_ref;
6076 if (ELF_ST_VISIBILITY (fh->elf.other) == STV_DEFAULT)
6077 {
6078 move_plt_plist (fh, fdh);
6079 fdh->elf.needs_plt = 1;
6080 }
6081 fdh->is_func_descriptor = 1;
6082 fdh->oh = fh;
6083 fh->oh = fdh;
6084 }
6085
6086 /* Now that the info is on the function descriptor, clear the
6087 function code sym info. Any function code syms for which we
6088 don't have a definition in a regular file, we force local.
6089 This prevents a shared library from exporting syms that have
6090 been imported from another library. Function code syms that
6091 are really in the library we must leave global to prevent the
6092 linker dragging in a definition from a static library. */
6093 force_local = (!fh->elf.def_regular
6094 || fdh == NULL
6095 || !fdh->elf.def_regular
6096 || fdh->elf.forced_local);
6097 _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
6098
6099 return TRUE;
6100 }
6101
6102 /* Called near the start of bfd_elf_size_dynamic_sections. We use
6103 this hook to a) provide some gcc support functions, and b) transfer
6104 dynamic linking information gathered so far on function code symbol
6105 entries, to their corresponding function descriptor symbol entries. */
6106
6107 static bfd_boolean
6108 ppc64_elf_func_desc_adjust (bfd *obfd ATTRIBUTE_UNUSED,
6109 struct bfd_link_info *info)
6110 {
6111 struct ppc_link_hash_table *htab;
6112 unsigned int i;
6113 const struct sfpr_def_parms funcs[] =
6114 {
6115 { "_savegpr0_", 14, 31, savegpr0, savegpr0_tail },
6116 { "_restgpr0_", 14, 29, restgpr0, restgpr0_tail },
6117 { "_restgpr0_", 30, 31, restgpr0, restgpr0_tail },
6118 { "_savegpr1_", 14, 31, savegpr1, savegpr1_tail },
6119 { "_restgpr1_", 14, 31, restgpr1, restgpr1_tail },
6120 { "_savefpr_", 14, 31, savefpr, savefpr0_tail },
6121 { "_restfpr_", 14, 29, restfpr, restfpr0_tail },
6122 { "_restfpr_", 30, 31, restfpr, restfpr0_tail },
6123 { "._savef", 14, 31, savefpr, savefpr1_tail },
6124 { "._restf", 14, 31, restfpr, restfpr1_tail },
6125 { "_savevr_", 20, 31, savevr, savevr_tail },
6126 { "_restvr_", 20, 31, restvr, restvr_tail }
6127 };
6128
6129 htab = ppc_hash_table (info);
6130 if (htab->sfpr == NULL)
6131 /* We don't have any relocs. */
6132 return TRUE;
6133
6134 /* Provide any missing _save* and _rest* functions. */
6135 htab->sfpr->size = 0;
6136 for (i = 0; i < sizeof (funcs) / sizeof (funcs[0]); i++)
6137 if (!sfpr_define (info, &funcs[i]))
6138 return FALSE;
6139
6140 elf_link_hash_traverse (&htab->elf, func_desc_adjust, info);
6141
6142 if (htab->sfpr->size == 0)
6143 htab->sfpr->flags |= SEC_EXCLUDE;
6144
6145 return TRUE;
6146 }
6147
6148 /* Adjust a symbol defined by a dynamic object and referenced by a
6149 regular object. The current definition is in some section of the
6150 dynamic object, but we're not including those sections. We have to
6151 change the definition to something the rest of the link can
6152 understand. */
6153
6154 static bfd_boolean
6155 ppc64_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
6156 struct elf_link_hash_entry *h)
6157 {
6158 struct ppc_link_hash_table *htab;
6159 asection *s;
6160
6161 htab = ppc_hash_table (info);
6162
6163 /* Deal with function syms. */
6164 if (h->type == STT_FUNC
6165 || h->type == STT_GNU_IFUNC
6166 || h->needs_plt)
6167 {
6168 /* Clear procedure linkage table information for any symbol that
6169 won't need a .plt entry. */
6170 struct plt_entry *ent;
6171 for (ent = h->plt.plist; ent != NULL; ent = ent->next)
6172 if (ent->plt.refcount > 0)
6173 break;
6174 if (ent == NULL
6175 || (h->type != STT_GNU_IFUNC
6176 && (SYMBOL_CALLS_LOCAL (info, h)
6177 || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
6178 && h->root.type == bfd_link_hash_undefweak))))
6179 {
6180 h->plt.plist = NULL;
6181 h->needs_plt = 0;
6182 }
6183 }
6184 else
6185 h->plt.plist = NULL;
6186
6187 /* If this is a weak symbol, and there is a real definition, the
6188 processor independent code will have arranged for us to see the
6189 real definition first, and we can just use the same value. */
6190 if (h->u.weakdef != NULL)
6191 {
6192 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
6193 || h->u.weakdef->root.type == bfd_link_hash_defweak);
6194 h->root.u.def.section = h->u.weakdef->root.u.def.section;
6195 h->root.u.def.value = h->u.weakdef->root.u.def.value;
6196 if (ELIMINATE_COPY_RELOCS)
6197 h->non_got_ref = h->u.weakdef->non_got_ref;
6198 return TRUE;
6199 }
6200
6201 /* If we are creating a shared library, we must presume that the
6202 only references to the symbol are via the global offset table.
6203 For such cases we need not do anything here; the relocations will
6204 be handled correctly by relocate_section. */
6205 if (info->shared)
6206 return TRUE;
6207
6208 /* If there are no references to this symbol that do not use the
6209 GOT, we don't need to generate a copy reloc. */
6210 if (!h->non_got_ref)
6211 return TRUE;
6212
6213 /* Don't generate a copy reloc for symbols defined in the executable. */
6214 if (!h->def_dynamic || !h->ref_regular || h->def_regular)
6215 return TRUE;
6216
6217 if (ELIMINATE_COPY_RELOCS)
6218 {
6219 struct ppc_link_hash_entry * eh;
6220 struct ppc_dyn_relocs *p;
6221
6222 eh = (struct ppc_link_hash_entry *) h;
6223 for (p = eh->dyn_relocs; p != NULL; p = p->next)
6224 {
6225 s = p->sec->output_section;
6226 if (s != NULL && (s->flags & SEC_READONLY) != 0)
6227 break;
6228 }
6229
6230 /* If we didn't find any dynamic relocs in read-only sections, then
6231 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
6232 if (p == NULL)
6233 {
6234 h->non_got_ref = 0;
6235 return TRUE;
6236 }
6237 }
6238
6239 if (h->plt.plist != NULL)
6240 {
6241 /* We should never get here, but unfortunately there are versions
6242 of gcc out there that improperly (for this ABI) put initialized
6243 function pointers, vtable refs and suchlike in read-only
6244 sections. Allow them to proceed, but warn that this might
6245 break at runtime. */
6246 (*_bfd_error_handler)
6247 (_("copy reloc against `%s' requires lazy plt linking; "
6248 "avoid setting LD_BIND_NOW=1 or upgrade gcc"),
6249 h->root.root.string);
6250 }
6251
6252 /* This is a reference to a symbol defined by a dynamic object which
6253 is not a function. */
6254
6255 if (h->size == 0)
6256 {
6257 (*_bfd_error_handler) (_("dynamic variable `%s' is zero size"),
6258 h->root.root.string);
6259 return TRUE;
6260 }
6261
6262 /* We must allocate the symbol in our .dynbss section, which will
6263 become part of the .bss section of the executable. There will be
6264 an entry for this symbol in the .dynsym section. The dynamic
6265 object will contain position independent code, so all references
6266 from the dynamic object to this symbol will go through the global
6267 offset table. The dynamic linker will use the .dynsym entry to
6268 determine the address it must put in the global offset table, so
6269 both the dynamic object and the regular object will refer to the
6270 same memory location for the variable. */
6271
6272 /* We must generate a R_PPC64_COPY reloc to tell the dynamic linker
6273 to copy the initial value out of the dynamic object and into the
6274 runtime process image. We need to remember the offset into the
6275 .rela.bss section we are going to use. */
6276 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
6277 {
6278 htab->relbss->size += sizeof (Elf64_External_Rela);
6279 h->needs_copy = 1;
6280 }
6281
6282 s = htab->dynbss;
6283
6284 return _bfd_elf_adjust_dynamic_copy (h, s);
6285 }
6286
6287 /* If given a function descriptor symbol, hide both the function code
6288 sym and the descriptor. */
6289 static void
6290 ppc64_elf_hide_symbol (struct bfd_link_info *info,
6291 struct elf_link_hash_entry *h,
6292 bfd_boolean force_local)
6293 {
6294 struct ppc_link_hash_entry *eh;
6295 _bfd_elf_link_hash_hide_symbol (info, h, force_local);
6296
6297 eh = (struct ppc_link_hash_entry *) h;
6298 if (eh->is_func_descriptor)
6299 {
6300 struct ppc_link_hash_entry *fh = eh->oh;
6301
6302 if (fh == NULL)
6303 {
6304 const char *p, *q;
6305 struct ppc_link_hash_table *htab;
6306 char save;
6307
6308 /* We aren't supposed to use alloca in BFD because on
6309 systems which do not have alloca the version in libiberty
6310 calls xmalloc, which might cause the program to crash
6311 when it runs out of memory. This function doesn't have a
6312 return status, so there's no way to gracefully return an
6313 error. So cheat. We know that string[-1] can be safely
6314 accessed; It's either a string in an ELF string table,
6315 or allocated in an objalloc structure. */
6316
6317 p = eh->elf.root.root.string - 1;
6318 save = *p;
6319 *(char *) p = '.';
6320 htab = ppc_hash_table (info);
6321 fh = (struct ppc_link_hash_entry *)
6322 elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
6323 *(char *) p = save;
6324
6325 /* Unfortunately, if it so happens that the string we were
6326 looking for was allocated immediately before this string,
6327 then we overwrote the string terminator. That's the only
6328 reason the lookup should fail. */
6329 if (fh == NULL)
6330 {
6331 q = eh->elf.root.root.string + strlen (eh->elf.root.root.string);
6332 while (q >= eh->elf.root.root.string && *q == *p)
6333 --q, --p;
6334 if (q < eh->elf.root.root.string && *p == '.')
6335 fh = (struct ppc_link_hash_entry *)
6336 elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
6337 }
6338 if (fh != NULL)
6339 {
6340 eh->oh = fh;
6341 fh->oh = eh;
6342 }
6343 }
6344 if (fh != NULL)
6345 _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
6346 }
6347 }
6348
6349 static bfd_boolean
6350 get_sym_h (struct elf_link_hash_entry **hp,
6351 Elf_Internal_Sym **symp,
6352 asection **symsecp,
6353 char **tls_maskp,
6354 Elf_Internal_Sym **locsymsp,
6355 unsigned long r_symndx,
6356 bfd *ibfd)
6357 {
6358 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
6359
6360 if (r_symndx >= symtab_hdr->sh_info)
6361 {
6362 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
6363 struct elf_link_hash_entry *h;
6364
6365 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
6366 while (h->root.type == bfd_link_hash_indirect
6367 || h->root.type == bfd_link_hash_warning)
6368 h = (struct elf_link_hash_entry *) h->root.u.i.link;
6369
6370 if (hp != NULL)
6371 *hp = h;
6372
6373 if (symp != NULL)
6374 *symp = NULL;
6375
6376 if (symsecp != NULL)
6377 {
6378 asection *symsec = NULL;
6379 if (h->root.type == bfd_link_hash_defined
6380 || h->root.type == bfd_link_hash_defweak)
6381 symsec = h->root.u.def.section;
6382 *symsecp = symsec;
6383 }
6384
6385 if (tls_maskp != NULL)
6386 {
6387 struct ppc_link_hash_entry *eh;
6388
6389 eh = (struct ppc_link_hash_entry *) h;
6390 *tls_maskp = &eh->tls_mask;
6391 }
6392 }
6393 else
6394 {
6395 Elf_Internal_Sym *sym;
6396 Elf_Internal_Sym *locsyms = *locsymsp;
6397
6398 if (locsyms == NULL)
6399 {
6400 locsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
6401 if (locsyms == NULL)
6402 locsyms = bfd_elf_get_elf_syms (ibfd, symtab_hdr,
6403 symtab_hdr->sh_info,
6404 0, NULL, NULL, NULL);
6405 if (locsyms == NULL)
6406 return FALSE;
6407 *locsymsp = locsyms;
6408 }
6409 sym = locsyms + r_symndx;
6410
6411 if (hp != NULL)
6412 *hp = NULL;
6413
6414 if (symp != NULL)
6415 *symp = sym;
6416
6417 if (symsecp != NULL)
6418 *symsecp = bfd_section_from_elf_index (ibfd, sym->st_shndx);
6419
6420 if (tls_maskp != NULL)
6421 {
6422 struct got_entry **lgot_ents;
6423 char *tls_mask;
6424
6425 tls_mask = NULL;
6426 lgot_ents = elf_local_got_ents (ibfd);
6427 if (lgot_ents != NULL)
6428 {
6429 struct plt_entry **local_plt = (struct plt_entry **)
6430 (lgot_ents + symtab_hdr->sh_info);
6431 char *lgot_masks = (char *)
6432 (local_plt + symtab_hdr->sh_info);
6433 tls_mask = &lgot_masks[r_symndx];
6434 }
6435 *tls_maskp = tls_mask;
6436 }
6437 }
6438 return TRUE;
6439 }
6440
6441 /* Returns TLS_MASKP for the given REL symbol. Function return is 0 on
6442 error, 2 on a toc GD type suitable for optimization, 3 on a toc LD
6443 type suitable for optimization, and 1 otherwise. */
6444
6445 static int
6446 get_tls_mask (char **tls_maskp,
6447 unsigned long *toc_symndx,
6448 bfd_vma *toc_addend,
6449 Elf_Internal_Sym **locsymsp,
6450 const Elf_Internal_Rela *rel,
6451 bfd *ibfd)
6452 {
6453 unsigned long r_symndx;
6454 int next_r;
6455 struct elf_link_hash_entry *h;
6456 Elf_Internal_Sym *sym;
6457 asection *sec;
6458 bfd_vma off;
6459
6460 r_symndx = ELF64_R_SYM (rel->r_info);
6461 if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
6462 return 0;
6463
6464 if ((*tls_maskp != NULL && **tls_maskp != 0)
6465 || sec == NULL
6466 || ppc64_elf_section_data (sec)->sec_type != sec_toc)
6467 return 1;
6468
6469 /* Look inside a TOC section too. */
6470 if (h != NULL)
6471 {
6472 BFD_ASSERT (h->root.type == bfd_link_hash_defined);
6473 off = h->root.u.def.value;
6474 }
6475 else
6476 off = sym->st_value;
6477 off += rel->r_addend;
6478 BFD_ASSERT (off % 8 == 0);
6479 r_symndx = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8];
6480 next_r = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8 + 1];
6481 if (toc_symndx != NULL)
6482 *toc_symndx = r_symndx;
6483 if (toc_addend != NULL)
6484 *toc_addend = ppc64_elf_section_data (sec)->u.toc.add[off / 8];
6485 if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
6486 return 0;
6487 if ((h == NULL
6488 || ((h->root.type == bfd_link_hash_defined
6489 || h->root.type == bfd_link_hash_defweak)
6490 && !h->def_dynamic))
6491 && (next_r == -1 || next_r == -2))
6492 return 1 - next_r;
6493 return 1;
6494 }
6495
6496 /* Adjust all global syms defined in opd sections. In gcc generated
6497 code for the old ABI, these will already have been done. */
6498
6499 static bfd_boolean
6500 adjust_opd_syms (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
6501 {
6502 struct ppc_link_hash_entry *eh;
6503 asection *sym_sec;
6504 struct _opd_sec_data *opd;
6505
6506 if (h->root.type == bfd_link_hash_indirect)
6507 return TRUE;
6508
6509 if (h->root.type == bfd_link_hash_warning)
6510 h = (struct elf_link_hash_entry *) h->root.u.i.link;
6511
6512 if (h->root.type != bfd_link_hash_defined
6513 && h->root.type != bfd_link_hash_defweak)
6514 return TRUE;
6515
6516 eh = (struct ppc_link_hash_entry *) h;
6517 if (eh->adjust_done)
6518 return TRUE;
6519
6520 sym_sec = eh->elf.root.u.def.section;
6521 opd = get_opd_info (sym_sec);
6522 if (opd != NULL && opd->adjust != NULL)
6523 {
6524 long adjust = opd->adjust[eh->elf.root.u.def.value / 8];
6525 if (adjust == -1)
6526 {
6527 /* This entry has been deleted. */
6528 asection *dsec = ppc64_elf_tdata (sym_sec->owner)->deleted_section;
6529 if (dsec == NULL)
6530 {
6531 for (dsec = sym_sec->owner->sections; dsec; dsec = dsec->next)
6532 if (elf_discarded_section (dsec))
6533 {
6534 ppc64_elf_tdata (sym_sec->owner)->deleted_section = dsec;
6535 break;
6536 }
6537 }
6538 eh->elf.root.u.def.value = 0;
6539 eh->elf.root.u.def.section = dsec;
6540 }
6541 else
6542 eh->elf.root.u.def.value += adjust;
6543 eh->adjust_done = 1;
6544 }
6545 return TRUE;
6546 }
6547
6548 /* Handles decrementing dynamic reloc counts for the reloc specified by
6549 R_INFO in section SEC. If LOCAL_SYMS is NULL, then H and SYM_SEC
6550 have already been determined. */
6551
6552 static bfd_boolean
6553 dec_dynrel_count (bfd_vma r_info,
6554 asection *sec,
6555 struct bfd_link_info *info,
6556 Elf_Internal_Sym **local_syms,
6557 struct elf_link_hash_entry *h,
6558 asection *sym_sec)
6559 {
6560 enum elf_ppc64_reloc_type r_type;
6561 struct ppc_dyn_relocs *p;
6562 struct ppc_dyn_relocs **pp;
6563
6564 /* Can this reloc be dynamic? This switch, and later tests here
6565 should be kept in sync with the code in check_relocs. */
6566 r_type = ELF64_R_TYPE (r_info);
6567 switch (r_type)
6568 {
6569 default:
6570 return TRUE;
6571
6572 case R_PPC64_TPREL16:
6573 case R_PPC64_TPREL16_LO:
6574 case R_PPC64_TPREL16_HI:
6575 case R_PPC64_TPREL16_HA:
6576 case R_PPC64_TPREL16_DS:
6577 case R_PPC64_TPREL16_LO_DS:
6578 case R_PPC64_TPREL16_HIGHER:
6579 case R_PPC64_TPREL16_HIGHERA:
6580 case R_PPC64_TPREL16_HIGHEST:
6581 case R_PPC64_TPREL16_HIGHESTA:
6582 if (!info->shared)
6583 return TRUE;
6584
6585 case R_PPC64_TPREL64:
6586 case R_PPC64_DTPMOD64:
6587 case R_PPC64_DTPREL64:
6588 case R_PPC64_ADDR64:
6589 case R_PPC64_REL30:
6590 case R_PPC64_REL32:
6591 case R_PPC64_REL64:
6592 case R_PPC64_ADDR14:
6593 case R_PPC64_ADDR14_BRNTAKEN:
6594 case R_PPC64_ADDR14_BRTAKEN:
6595 case R_PPC64_ADDR16:
6596 case R_PPC64_ADDR16_DS:
6597 case R_PPC64_ADDR16_HA:
6598 case R_PPC64_ADDR16_HI:
6599 case R_PPC64_ADDR16_HIGHER:
6600 case R_PPC64_ADDR16_HIGHERA:
6601 case R_PPC64_ADDR16_HIGHEST:
6602 case R_PPC64_ADDR16_HIGHESTA:
6603 case R_PPC64_ADDR16_LO:
6604 case R_PPC64_ADDR16_LO_DS:
6605 case R_PPC64_ADDR24:
6606 case R_PPC64_ADDR32:
6607 case R_PPC64_UADDR16:
6608 case R_PPC64_UADDR32:
6609 case R_PPC64_UADDR64:
6610 case R_PPC64_TOC:
6611 break;
6612 }
6613
6614 if (local_syms != NULL)
6615 {
6616 unsigned long r_symndx;
6617 Elf_Internal_Sym *sym;
6618 bfd *ibfd = sec->owner;
6619
6620 r_symndx = ELF64_R_SYM (r_info);
6621 if (!get_sym_h (&h, &sym, &sym_sec, NULL, local_syms, r_symndx, ibfd))
6622 return FALSE;
6623 }
6624
6625 if ((info->shared
6626 && (must_be_dyn_reloc (info, r_type)
6627 || (h != NULL
6628 && (!info->symbolic
6629 || h->root.type == bfd_link_hash_defweak
6630 || !h->def_regular))))
6631 || (ELIMINATE_COPY_RELOCS
6632 && !info->shared
6633 && h != NULL
6634 && (h->root.type == bfd_link_hash_defweak
6635 || !h->def_regular)))
6636 ;
6637 else
6638 return TRUE;
6639
6640 if (h != NULL)
6641 pp = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
6642 else
6643 {
6644 if (sym_sec != NULL)
6645 {
6646 void *vpp = &elf_section_data (sym_sec)->local_dynrel;
6647 pp = (struct ppc_dyn_relocs **) vpp;
6648 }
6649 else
6650 {
6651 void *vpp = &elf_section_data (sec)->local_dynrel;
6652 pp = (struct ppc_dyn_relocs **) vpp;
6653 }
6654
6655 /* elf_gc_sweep may have already removed all dyn relocs associated
6656 with local syms for a given section. Don't report a dynreloc
6657 miscount. */
6658 if (*pp == NULL)
6659 return TRUE;
6660 }
6661
6662 while ((p = *pp) != NULL)
6663 {
6664 if (p->sec == sec)
6665 {
6666 if (!must_be_dyn_reloc (info, r_type))
6667 p->pc_count -= 1;
6668 p->count -= 1;
6669 if (p->count == 0)
6670 *pp = p->next;
6671 return TRUE;
6672 }
6673 pp = &p->next;
6674 }
6675
6676 (*_bfd_error_handler) (_("dynreloc miscount for %B, section %A"),
6677 sec->owner, sec);
6678 bfd_set_error (bfd_error_bad_value);
6679 return FALSE;
6680 }
6681
6682 /* Remove unused Official Procedure Descriptor entries. Currently we
6683 only remove those associated with functions in discarded link-once
6684 sections, or weakly defined functions that have been overridden. It
6685 would be possible to remove many more entries for statically linked
6686 applications. */
6687
6688 bfd_boolean
6689 ppc64_elf_edit_opd (bfd *obfd, struct bfd_link_info *info,
6690 bfd_boolean non_overlapping)
6691 {
6692 bfd *ibfd;
6693 bfd_boolean some_edited = FALSE;
6694 asection *need_pad = NULL;
6695
6696 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
6697 {
6698 asection *sec;
6699 Elf_Internal_Rela *relstart, *rel, *relend;
6700 Elf_Internal_Shdr *symtab_hdr;
6701 Elf_Internal_Sym *local_syms;
6702 struct elf_link_hash_entry **sym_hashes;
6703 bfd_vma offset;
6704 struct _opd_sec_data *opd;
6705 bfd_boolean need_edit, add_aux_fields;
6706 bfd_size_type cnt_16b = 0;
6707
6708 sec = bfd_get_section_by_name (ibfd, ".opd");
6709 if (sec == NULL || sec->size == 0)
6710 continue;
6711
6712 if (sec->sec_info_type == ELF_INFO_TYPE_JUST_SYMS)
6713 continue;
6714
6715 if (sec->output_section == bfd_abs_section_ptr)
6716 continue;
6717
6718 /* Look through the section relocs. */
6719 if ((sec->flags & SEC_RELOC) == 0 || sec->reloc_count == 0)
6720 continue;
6721
6722 local_syms = NULL;
6723 symtab_hdr = &elf_symtab_hdr (ibfd);
6724 sym_hashes = elf_sym_hashes (ibfd);
6725
6726 /* Read the relocations. */
6727 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
6728 info->keep_memory);
6729 if (relstart == NULL)
6730 return FALSE;
6731
6732 /* First run through the relocs to check they are sane, and to
6733 determine whether we need to edit this opd section. */
6734 need_edit = FALSE;
6735 need_pad = sec;
6736 offset = 0;
6737 relend = relstart + sec->reloc_count;
6738 for (rel = relstart; rel < relend; )
6739 {
6740 enum elf_ppc64_reloc_type r_type;
6741 unsigned long r_symndx;
6742 asection *sym_sec;
6743 struct elf_link_hash_entry *h;
6744 Elf_Internal_Sym *sym;
6745
6746 /* .opd contains a regular array of 16 or 24 byte entries. We're
6747 only interested in the reloc pointing to a function entry
6748 point. */
6749 if (rel->r_offset != offset
6750 || rel + 1 >= relend
6751 || (rel + 1)->r_offset != offset + 8)
6752 {
6753 /* If someone messes with .opd alignment then after a
6754 "ld -r" we might have padding in the middle of .opd.
6755 Also, there's nothing to prevent someone putting
6756 something silly in .opd with the assembler. No .opd
6757 optimization for them! */
6758 broken_opd:
6759 (*_bfd_error_handler)
6760 (_("%B: .opd is not a regular array of opd entries"), ibfd);
6761 need_edit = FALSE;
6762 break;
6763 }
6764
6765 if ((r_type = ELF64_R_TYPE (rel->r_info)) != R_PPC64_ADDR64
6766 || (r_type = ELF64_R_TYPE ((rel + 1)->r_info)) != R_PPC64_TOC)
6767 {
6768 (*_bfd_error_handler)
6769 (_("%B: unexpected reloc type %u in .opd section"),
6770 ibfd, r_type);
6771 need_edit = FALSE;
6772 break;
6773 }
6774
6775 r_symndx = ELF64_R_SYM (rel->r_info);
6776 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
6777 r_symndx, ibfd))
6778 goto error_ret;
6779
6780 if (sym_sec == NULL || sym_sec->owner == NULL)
6781 {
6782 const char *sym_name;
6783 if (h != NULL)
6784 sym_name = h->root.root.string;
6785 else
6786 sym_name = bfd_elf_sym_name (ibfd, symtab_hdr, sym,
6787 sym_sec);
6788
6789 (*_bfd_error_handler)
6790 (_("%B: undefined sym `%s' in .opd section"),
6791 ibfd, sym_name);
6792 need_edit = FALSE;
6793 break;
6794 }
6795
6796 /* opd entries are always for functions defined in the
6797 current input bfd. If the symbol isn't defined in the
6798 input bfd, then we won't be using the function in this
6799 bfd; It must be defined in a linkonce section in another
6800 bfd, or is weak. It's also possible that we are
6801 discarding the function due to a linker script /DISCARD/,
6802 which we test for via the output_section. */
6803 if (sym_sec->owner != ibfd
6804 || sym_sec->output_section == bfd_abs_section_ptr)
6805 need_edit = TRUE;
6806
6807 rel += 2;
6808 if (rel == relend
6809 || (rel + 1 == relend && rel->r_offset == offset + 16))
6810 {
6811 if (sec->size == offset + 24)
6812 {
6813 need_pad = NULL;
6814 break;
6815 }
6816 if (rel == relend && sec->size == offset + 16)
6817 {
6818 cnt_16b++;
6819 break;
6820 }
6821 goto broken_opd;
6822 }
6823
6824 if (rel->r_offset == offset + 24)
6825 offset += 24;
6826 else if (rel->r_offset != offset + 16)
6827 goto broken_opd;
6828 else if (rel + 1 < relend
6829 && ELF64_R_TYPE (rel[0].r_info) == R_PPC64_ADDR64
6830 && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOC)
6831 {
6832 offset += 16;
6833 cnt_16b++;
6834 }
6835 else if (rel + 2 < relend
6836 && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_ADDR64
6837 && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_TOC)
6838 {
6839 offset += 24;
6840 rel += 1;
6841 }
6842 else
6843 goto broken_opd;
6844 }
6845
6846 add_aux_fields = non_overlapping && cnt_16b > 0;
6847
6848 if (need_edit || add_aux_fields)
6849 {
6850 Elf_Internal_Rela *write_rel;
6851 bfd_byte *rptr, *wptr;
6852 bfd_byte *new_contents;
6853 bfd_boolean skip;
6854 long opd_ent_size;
6855 bfd_size_type amt;
6856
6857 new_contents = NULL;
6858 amt = sec->size * sizeof (long) / 8;
6859 opd = &ppc64_elf_section_data (sec)->u.opd;
6860 opd->adjust = bfd_zalloc (obfd, amt);
6861 if (opd->adjust == NULL)
6862 return FALSE;
6863 ppc64_elf_section_data (sec)->sec_type = sec_opd;
6864
6865 /* This seems a waste of time as input .opd sections are all
6866 zeros as generated by gcc, but I suppose there's no reason
6867 this will always be so. We might start putting something in
6868 the third word of .opd entries. */
6869 if ((sec->flags & SEC_IN_MEMORY) == 0)
6870 {
6871 bfd_byte *loc;
6872 if (!bfd_malloc_and_get_section (ibfd, sec, &loc))
6873 {
6874 if (loc != NULL)
6875 free (loc);
6876 error_ret:
6877 if (local_syms != NULL
6878 && symtab_hdr->contents != (unsigned char *) local_syms)
6879 free (local_syms);
6880 if (elf_section_data (sec)->relocs != relstart)
6881 free (relstart);
6882 return FALSE;
6883 }
6884 sec->contents = loc;
6885 sec->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
6886 }
6887
6888 elf_section_data (sec)->relocs = relstart;
6889
6890 new_contents = sec->contents;
6891 if (add_aux_fields)
6892 {
6893 new_contents = bfd_malloc (sec->size + cnt_16b * 8);
6894 if (new_contents == NULL)
6895 return FALSE;
6896 need_pad = FALSE;
6897 }
6898 wptr = new_contents;
6899 rptr = sec->contents;
6900
6901 write_rel = relstart;
6902 skip = FALSE;
6903 offset = 0;
6904 opd_ent_size = 0;
6905 for (rel = relstart; rel < relend; rel++)
6906 {
6907 unsigned long r_symndx;
6908 asection *sym_sec;
6909 struct elf_link_hash_entry *h;
6910 Elf_Internal_Sym *sym;
6911
6912 r_symndx = ELF64_R_SYM (rel->r_info);
6913 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
6914 r_symndx, ibfd))
6915 goto error_ret;
6916
6917 if (rel->r_offset == offset)
6918 {
6919 struct ppc_link_hash_entry *fdh = NULL;
6920
6921 /* See if the .opd entry is full 24 byte or
6922 16 byte (with fd_aux entry overlapped with next
6923 fd_func). */
6924 opd_ent_size = 24;
6925 if ((rel + 2 == relend && sec->size == offset + 16)
6926 || (rel + 3 < relend
6927 && rel[2].r_offset == offset + 16
6928 && rel[3].r_offset == offset + 24
6929 && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_ADDR64
6930 && ELF64_R_TYPE (rel[3].r_info) == R_PPC64_TOC))
6931 opd_ent_size = 16;
6932
6933 if (h != NULL
6934 && h->root.root.string[0] == '.')
6935 {
6936 fdh = get_fdh ((struct ppc_link_hash_entry *) h,
6937 ppc_hash_table (info));
6938 if (fdh != NULL
6939 && fdh->elf.root.type != bfd_link_hash_defined
6940 && fdh->elf.root.type != bfd_link_hash_defweak)
6941 fdh = NULL;
6942 }
6943
6944 skip = (sym_sec->owner != ibfd
6945 || sym_sec->output_section == bfd_abs_section_ptr);
6946 if (skip)
6947 {
6948 if (fdh != NULL && sym_sec->owner == ibfd)
6949 {
6950 /* Arrange for the function descriptor sym
6951 to be dropped. */
6952 fdh->elf.root.u.def.value = 0;
6953 fdh->elf.root.u.def.section = sym_sec;
6954 }
6955 opd->adjust[rel->r_offset / 8] = -1;
6956 }
6957 else
6958 {
6959 /* We'll be keeping this opd entry. */
6960
6961 if (fdh != NULL)
6962 {
6963 /* Redefine the function descriptor symbol to
6964 this location in the opd section. It is
6965 necessary to update the value here rather
6966 than using an array of adjustments as we do
6967 for local symbols, because various places
6968 in the generic ELF code use the value
6969 stored in u.def.value. */
6970 fdh->elf.root.u.def.value = wptr - new_contents;
6971 fdh->adjust_done = 1;
6972 }
6973
6974 /* Local syms are a bit tricky. We could
6975 tweak them as they can be cached, but
6976 we'd need to look through the local syms
6977 for the function descriptor sym which we
6978 don't have at the moment. So keep an
6979 array of adjustments. */
6980 opd->adjust[rel->r_offset / 8]
6981 = (wptr - new_contents) - (rptr - sec->contents);
6982
6983 if (wptr != rptr)
6984 memcpy (wptr, rptr, opd_ent_size);
6985 wptr += opd_ent_size;
6986 if (add_aux_fields && opd_ent_size == 16)
6987 {
6988 memset (wptr, '\0', 8);
6989 wptr += 8;
6990 }
6991 }
6992 rptr += opd_ent_size;
6993 offset += opd_ent_size;
6994 }
6995
6996 if (skip)
6997 {
6998 if (!NO_OPD_RELOCS
6999 && !info->relocatable
7000 && !dec_dynrel_count (rel->r_info, sec, info,
7001 NULL, h, sym_sec))
7002 goto error_ret;
7003 }
7004 else
7005 {
7006 /* We need to adjust any reloc offsets to point to the
7007 new opd entries. While we're at it, we may as well
7008 remove redundant relocs. */
7009 rel->r_offset += opd->adjust[(offset - opd_ent_size) / 8];
7010 if (write_rel != rel)
7011 memcpy (write_rel, rel, sizeof (*rel));
7012 ++write_rel;
7013 }
7014 }
7015
7016 sec->size = wptr - new_contents;
7017 sec->reloc_count = write_rel - relstart;
7018 if (add_aux_fields)
7019 {
7020 free (sec->contents);
7021 sec->contents = new_contents;
7022 }
7023
7024 /* Fudge the header size too, as this is used later in
7025 elf_bfd_final_link if we are emitting relocs. */
7026 elf_section_data (sec)->rel_hdr.sh_size
7027 = sec->reloc_count * elf_section_data (sec)->rel_hdr.sh_entsize;
7028 BFD_ASSERT (elf_section_data (sec)->rel_hdr2 == NULL);
7029 some_edited = TRUE;
7030 }
7031 else if (elf_section_data (sec)->relocs != relstart)
7032 free (relstart);
7033
7034 if (local_syms != NULL
7035 && symtab_hdr->contents != (unsigned char *) local_syms)
7036 {
7037 if (!info->keep_memory)
7038 free (local_syms);
7039 else
7040 symtab_hdr->contents = (unsigned char *) local_syms;
7041 }
7042 }
7043
7044 if (some_edited)
7045 elf_link_hash_traverse (elf_hash_table (info), adjust_opd_syms, NULL);
7046
7047 /* If we are doing a final link and the last .opd entry is just 16 byte
7048 long, add a 8 byte padding after it. */
7049 if (need_pad != NULL && !info->relocatable)
7050 {
7051 bfd_byte *p;
7052
7053 if ((need_pad->flags & SEC_IN_MEMORY) == 0)
7054 {
7055 BFD_ASSERT (need_pad->size > 0);
7056
7057 p = bfd_malloc (need_pad->size + 8);
7058 if (p == NULL)
7059 return FALSE;
7060
7061 if (! bfd_get_section_contents (need_pad->owner, need_pad,
7062 p, 0, need_pad->size))
7063 return FALSE;
7064
7065 need_pad->contents = p;
7066 need_pad->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
7067 }
7068 else
7069 {
7070 p = bfd_realloc (need_pad->contents, need_pad->size + 8);
7071 if (p == NULL)
7072 return FALSE;
7073
7074 need_pad->contents = p;
7075 }
7076
7077 memset (need_pad->contents + need_pad->size, 0, 8);
7078 need_pad->size += 8;
7079 }
7080
7081 return TRUE;
7082 }
7083
7084 /* Set htab->tls_get_addr and call the generic ELF tls_setup function. */
7085
7086 asection *
7087 ppc64_elf_tls_setup (bfd *obfd, struct bfd_link_info *info)
7088 {
7089 struct ppc_link_hash_table *htab;
7090
7091 htab = ppc_hash_table (info);
7092 htab->tls_get_addr = ((struct ppc_link_hash_entry *)
7093 elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
7094 FALSE, FALSE, TRUE));
7095 htab->tls_get_addr_fd = ((struct ppc_link_hash_entry *)
7096 elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
7097 FALSE, FALSE, TRUE));
7098 return _bfd_elf_tls_setup (obfd, info);
7099 }
7100
7101 /* Return TRUE iff REL is a branch reloc with a global symbol matching
7102 HASH1 or HASH2. */
7103
7104 static bfd_boolean
7105 branch_reloc_hash_match (const bfd *ibfd,
7106 const Elf_Internal_Rela *rel,
7107 const struct ppc_link_hash_entry *hash1,
7108 const struct ppc_link_hash_entry *hash2)
7109 {
7110 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
7111 enum elf_ppc64_reloc_type r_type = ELF64_R_TYPE (rel->r_info);
7112 unsigned int r_symndx = ELF64_R_SYM (rel->r_info);
7113
7114 if (r_symndx >= symtab_hdr->sh_info && is_branch_reloc (r_type))
7115 {
7116 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
7117 struct elf_link_hash_entry *h;
7118
7119 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
7120 while (h->root.type == bfd_link_hash_indirect
7121 || h->root.type == bfd_link_hash_warning)
7122 h = (struct elf_link_hash_entry *) h->root.u.i.link;
7123 if (h == &hash1->elf || h == &hash2->elf)
7124 return TRUE;
7125 }
7126 return FALSE;
7127 }
7128
7129 /* Run through all the TLS relocs looking for optimization
7130 opportunities. The linker has been hacked (see ppc64elf.em) to do
7131 a preliminary section layout so that we know the TLS segment
7132 offsets. We can't optimize earlier because some optimizations need
7133 to know the tp offset, and we need to optimize before allocating
7134 dynamic relocations. */
7135
7136 bfd_boolean
7137 ppc64_elf_tls_optimize (bfd *obfd ATTRIBUTE_UNUSED, struct bfd_link_info *info)
7138 {
7139 bfd *ibfd;
7140 asection *sec;
7141 struct ppc_link_hash_table *htab;
7142 int pass;
7143
7144 if (info->relocatable || !info->executable)
7145 return TRUE;
7146
7147 htab = ppc_hash_table (info);
7148 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
7149 {
7150 Elf_Internal_Sym *locsyms = NULL;
7151 asection *toc = bfd_get_section_by_name (ibfd, ".toc");
7152 unsigned char *toc_ref = NULL;
7153
7154 /* Look at all the sections for this file. Make two passes over
7155 the relocs. On the first pass, mark toc entries involved
7156 with tls relocs, and check that tls relocs involved in
7157 setting up a tls_get_addr call are indeed followed by such a
7158 call. If they are not, exclude them from the optimizations
7159 done on the second pass. */
7160 for (pass = 0; pass < 2; ++pass)
7161 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
7162 if (sec->has_tls_reloc && !bfd_is_abs_section (sec->output_section))
7163 {
7164 Elf_Internal_Rela *relstart, *rel, *relend;
7165
7166 /* Read the relocations. */
7167 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
7168 info->keep_memory);
7169 if (relstart == NULL)
7170 return FALSE;
7171
7172 relend = relstart + sec->reloc_count;
7173 for (rel = relstart; rel < relend; rel++)
7174 {
7175 enum elf_ppc64_reloc_type r_type;
7176 unsigned long r_symndx;
7177 struct elf_link_hash_entry *h;
7178 Elf_Internal_Sym *sym;
7179 asection *sym_sec;
7180 char *tls_mask;
7181 char tls_set, tls_clear, tls_type = 0;
7182 bfd_vma value;
7183 bfd_boolean ok_tprel, is_local;
7184 long toc_ref_index = 0;
7185 int expecting_tls_get_addr = 0;
7186
7187 r_symndx = ELF64_R_SYM (rel->r_info);
7188 if (!get_sym_h (&h, &sym, &sym_sec, &tls_mask, &locsyms,
7189 r_symndx, ibfd))
7190 {
7191 err_free_rel:
7192 if (elf_section_data (sec)->relocs != relstart)
7193 free (relstart);
7194 if (toc_ref != NULL)
7195 free (toc_ref);
7196 if (locsyms != NULL
7197 && (elf_symtab_hdr (ibfd).contents
7198 != (unsigned char *) locsyms))
7199 free (locsyms);
7200 return FALSE;
7201 }
7202
7203 if (h != NULL)
7204 {
7205 if (h->root.type != bfd_link_hash_defined
7206 && h->root.type != bfd_link_hash_defweak)
7207 continue;
7208 value = h->root.u.def.value;
7209 }
7210 else
7211 /* Symbols referenced by TLS relocs must be of type
7212 STT_TLS. So no need for .opd local sym adjust. */
7213 value = sym->st_value;
7214
7215 ok_tprel = FALSE;
7216 is_local = FALSE;
7217 if (h == NULL
7218 || !h->def_dynamic)
7219 {
7220 is_local = TRUE;
7221 value += sym_sec->output_offset;
7222 value += sym_sec->output_section->vma;
7223 value -= htab->elf.tls_sec->vma;
7224 ok_tprel = (value + TP_OFFSET + ((bfd_vma) 1 << 31)
7225 < (bfd_vma) 1 << 32);
7226 }
7227
7228 r_type = ELF64_R_TYPE (rel->r_info);
7229 switch (r_type)
7230 {
7231 case R_PPC64_GOT_TLSLD16:
7232 case R_PPC64_GOT_TLSLD16_LO:
7233 expecting_tls_get_addr = 1;
7234 /* Fall thru */
7235
7236 case R_PPC64_GOT_TLSLD16_HI:
7237 case R_PPC64_GOT_TLSLD16_HA:
7238 /* These relocs should never be against a symbol
7239 defined in a shared lib. Leave them alone if
7240 that turns out to be the case. */
7241 if (!is_local)
7242 continue;
7243
7244 /* LD -> LE */
7245 tls_set = 0;
7246 tls_clear = TLS_LD;
7247 tls_type = TLS_TLS | TLS_LD;
7248 break;
7249
7250 case R_PPC64_GOT_TLSGD16:
7251 case R_PPC64_GOT_TLSGD16_LO:
7252 expecting_tls_get_addr = 1;
7253 /* Fall thru */
7254
7255 case R_PPC64_GOT_TLSGD16_HI:
7256 case R_PPC64_GOT_TLSGD16_HA:
7257 if (ok_tprel)
7258 /* GD -> LE */
7259 tls_set = 0;
7260 else
7261 /* GD -> IE */
7262 tls_set = TLS_TLS | TLS_TPRELGD;
7263 tls_clear = TLS_GD;
7264 tls_type = TLS_TLS | TLS_GD;
7265 break;
7266
7267 case R_PPC64_GOT_TPREL16_DS:
7268 case R_PPC64_GOT_TPREL16_LO_DS:
7269 case R_PPC64_GOT_TPREL16_HI:
7270 case R_PPC64_GOT_TPREL16_HA:
7271 if (ok_tprel)
7272 {
7273 /* IE -> LE */
7274 tls_set = 0;
7275 tls_clear = TLS_TPREL;
7276 tls_type = TLS_TLS | TLS_TPREL;
7277 break;
7278 }
7279 continue;
7280
7281 case R_PPC64_TOC16:
7282 case R_PPC64_TOC16_LO:
7283 case R_PPC64_TLS:
7284 case R_PPC64_TLSGD:
7285 case R_PPC64_TLSLD:
7286 if (sym_sec == NULL || sym_sec != toc)
7287 continue;
7288
7289 /* Mark this toc entry as referenced by a TLS
7290 code sequence. We can do that now in the
7291 case of R_PPC64_TLS, and after checking for
7292 tls_get_addr for the TOC16 relocs. */
7293 if (toc_ref == NULL)
7294 {
7295 toc_ref = bfd_zmalloc (toc->size / 8);
7296 if (toc_ref == NULL)
7297 goto err_free_rel;
7298 }
7299 if (h != NULL)
7300 value = h->root.u.def.value;
7301 else
7302 value = sym->st_value;
7303 value += rel->r_addend;
7304 BFD_ASSERT (value < toc->size && value % 8 == 0);
7305 toc_ref_index = value / 8;
7306 if (r_type == R_PPC64_TLS
7307 || r_type == R_PPC64_TLSGD
7308 || r_type == R_PPC64_TLSLD)
7309 {
7310 toc_ref[toc_ref_index] = 1;
7311 continue;
7312 }
7313
7314 if (pass != 0 && toc_ref[toc_ref_index] == 0)
7315 continue;
7316
7317 tls_set = 0;
7318 tls_clear = 0;
7319 expecting_tls_get_addr = 2;
7320 break;
7321
7322 case R_PPC64_TPREL64:
7323 if (pass == 0
7324 || sec != toc
7325 || toc_ref == NULL
7326 || !toc_ref[rel->r_offset / 8])
7327 continue;
7328 if (ok_tprel)
7329 {
7330 /* IE -> LE */
7331 tls_set = TLS_EXPLICIT;
7332 tls_clear = TLS_TPREL;
7333 break;
7334 }
7335 continue;
7336
7337 case R_PPC64_DTPMOD64:
7338 if (pass == 0
7339 || sec != toc
7340 || toc_ref == NULL
7341 || !toc_ref[rel->r_offset / 8])
7342 continue;
7343 if (rel + 1 < relend
7344 && (rel[1].r_info
7345 == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64))
7346 && rel[1].r_offset == rel->r_offset + 8)
7347 {
7348 if (ok_tprel)
7349 /* GD -> LE */
7350 tls_set = TLS_EXPLICIT | TLS_GD;
7351 else
7352 /* GD -> IE */
7353 tls_set = TLS_EXPLICIT | TLS_GD | TLS_TPRELGD;
7354 tls_clear = TLS_GD;
7355 }
7356 else
7357 {
7358 if (!is_local)
7359 continue;
7360
7361 /* LD -> LE */
7362 tls_set = TLS_EXPLICIT;
7363 tls_clear = TLS_LD;
7364 }
7365 break;
7366
7367 default:
7368 continue;
7369 }
7370
7371 if (pass == 0)
7372 {
7373 if (!expecting_tls_get_addr
7374 || !sec->has_tls_get_addr_call)
7375 continue;
7376
7377 if (rel + 1 < relend
7378 && branch_reloc_hash_match (ibfd, rel + 1,
7379 htab->tls_get_addr,
7380 htab->tls_get_addr_fd))
7381 {
7382 if (expecting_tls_get_addr == 2)
7383 {
7384 /* Check for toc tls entries. */
7385 char *toc_tls;
7386 int retval;
7387
7388 retval = get_tls_mask (&toc_tls, NULL, NULL,
7389 &locsyms,
7390 rel, ibfd);
7391 if (retval == 0)
7392 goto err_free_rel;
7393 if (retval > 1 && toc_tls != NULL)
7394 toc_ref[toc_ref_index] = 1;
7395 }
7396 continue;
7397 }
7398
7399 if (expecting_tls_get_addr != 1)
7400 continue;
7401
7402 /* Uh oh, we didn't find the expected call. We
7403 could just mark this symbol to exclude it
7404 from tls optimization but it's safer to skip
7405 the entire section. */
7406 sec->has_tls_reloc = 0;
7407 break;
7408 }
7409
7410 if (expecting_tls_get_addr && htab->tls_get_addr != NULL)
7411 {
7412 struct plt_entry *ent;
7413 for (ent = htab->tls_get_addr->elf.plt.plist;
7414 ent != NULL;
7415 ent = ent->next)
7416 if (ent->addend == 0)
7417 {
7418 if (ent->plt.refcount > 0)
7419 {
7420 ent->plt.refcount -= 1;
7421 expecting_tls_get_addr = 0;
7422 }
7423 break;
7424 }
7425 }
7426
7427 if (expecting_tls_get_addr && htab->tls_get_addr_fd != NULL)
7428 {
7429 struct plt_entry *ent;
7430 for (ent = htab->tls_get_addr_fd->elf.plt.plist;
7431 ent != NULL;
7432 ent = ent->next)
7433 if (ent->addend == 0)
7434 {
7435 if (ent->plt.refcount > 0)
7436 ent->plt.refcount -= 1;
7437 break;
7438 }
7439 }
7440
7441 if (tls_clear == 0)
7442 continue;
7443
7444 if ((tls_set & TLS_EXPLICIT) == 0)
7445 {
7446 struct got_entry *ent;
7447
7448 /* Adjust got entry for this reloc. */
7449 if (h != NULL)
7450 ent = h->got.glist;
7451 else
7452 ent = elf_local_got_ents (ibfd)[r_symndx];
7453
7454 for (; ent != NULL; ent = ent->next)
7455 if (ent->addend == rel->r_addend
7456 && ent->owner == ibfd
7457 && ent->tls_type == tls_type)
7458 break;
7459 if (ent == NULL)
7460 abort ();
7461
7462 if (tls_set == 0)
7463 {
7464 /* We managed to get rid of a got entry. */
7465 if (ent->got.refcount > 0)
7466 ent->got.refcount -= 1;
7467 }
7468 }
7469 else
7470 {
7471 /* If we got rid of a DTPMOD/DTPREL reloc pair then
7472 we'll lose one or two dyn relocs. */
7473 if (!dec_dynrel_count (rel->r_info, sec, info,
7474 NULL, h, sym_sec))
7475 return FALSE;
7476
7477 if (tls_set == (TLS_EXPLICIT | TLS_GD))
7478 {
7479 if (!dec_dynrel_count ((rel + 1)->r_info, sec, info,
7480 NULL, h, sym_sec))
7481 return FALSE;
7482 }
7483 }
7484
7485 *tls_mask |= tls_set;
7486 *tls_mask &= ~tls_clear;
7487 }
7488
7489 if (elf_section_data (sec)->relocs != relstart)
7490 free (relstart);
7491 }
7492
7493 if (toc_ref != NULL)
7494 free (toc_ref);
7495
7496 if (locsyms != NULL
7497 && (elf_symtab_hdr (ibfd).contents != (unsigned char *) locsyms))
7498 {
7499 if (!info->keep_memory)
7500 free (locsyms);
7501 else
7502 elf_symtab_hdr (ibfd).contents = (unsigned char *) locsyms;
7503 }
7504 }
7505 return TRUE;
7506 }
7507
7508 /* Called via elf_link_hash_traverse from ppc64_elf_edit_toc to adjust
7509 the values of any global symbols in a toc section that has been
7510 edited. Globals in toc sections should be a rarity, so this function
7511 sets a flag if any are found in toc sections other than the one just
7512 edited, so that futher hash table traversals can be avoided. */
7513
7514 struct adjust_toc_info
7515 {
7516 asection *toc;
7517 unsigned long *skip;
7518 bfd_boolean global_toc_syms;
7519 };
7520
7521 static bfd_boolean
7522 adjust_toc_syms (struct elf_link_hash_entry *h, void *inf)
7523 {
7524 struct ppc_link_hash_entry *eh;
7525 struct adjust_toc_info *toc_inf = (struct adjust_toc_info *) inf;
7526
7527 if (h->root.type == bfd_link_hash_indirect)
7528 return TRUE;
7529
7530 if (h->root.type == bfd_link_hash_warning)
7531 h = (struct elf_link_hash_entry *) h->root.u.i.link;
7532
7533 if (h->root.type != bfd_link_hash_defined
7534 && h->root.type != bfd_link_hash_defweak)
7535 return TRUE;
7536
7537 eh = (struct ppc_link_hash_entry *) h;
7538 if (eh->adjust_done)
7539 return TRUE;
7540
7541 if (eh->elf.root.u.def.section == toc_inf->toc)
7542 {
7543 unsigned long skip = toc_inf->skip[eh->elf.root.u.def.value >> 3];
7544 if (skip != (unsigned long) -1)
7545 eh->elf.root.u.def.value -= skip;
7546 else
7547 {
7548 (*_bfd_error_handler)
7549 (_("%s defined in removed toc entry"), eh->elf.root.root.string);
7550 eh->elf.root.u.def.section = &bfd_abs_section;
7551 eh->elf.root.u.def.value = 0;
7552 }
7553 eh->adjust_done = 1;
7554 }
7555 else if (strcmp (eh->elf.root.u.def.section->name, ".toc") == 0)
7556 toc_inf->global_toc_syms = TRUE;
7557
7558 return TRUE;
7559 }
7560
7561 /* Examine all relocs referencing .toc sections in order to remove
7562 unused .toc entries. */
7563
7564 bfd_boolean
7565 ppc64_elf_edit_toc (bfd *obfd ATTRIBUTE_UNUSED, struct bfd_link_info *info)
7566 {
7567 bfd *ibfd;
7568 struct adjust_toc_info toc_inf;
7569
7570 toc_inf.global_toc_syms = TRUE;
7571 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
7572 {
7573 asection *toc, *sec;
7574 Elf_Internal_Shdr *symtab_hdr;
7575 Elf_Internal_Sym *local_syms;
7576 struct elf_link_hash_entry **sym_hashes;
7577 Elf_Internal_Rela *relstart, *rel;
7578 unsigned long *skip, *drop;
7579 unsigned char *used;
7580 unsigned char *keep, last, some_unused;
7581
7582 toc = bfd_get_section_by_name (ibfd, ".toc");
7583 if (toc == NULL
7584 || toc->size == 0
7585 || toc->sec_info_type == ELF_INFO_TYPE_JUST_SYMS
7586 || elf_discarded_section (toc))
7587 continue;
7588
7589 local_syms = NULL;
7590 symtab_hdr = &elf_symtab_hdr (ibfd);
7591 sym_hashes = elf_sym_hashes (ibfd);
7592
7593 /* Look at sections dropped from the final link. */
7594 skip = NULL;
7595 relstart = NULL;
7596 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
7597 {
7598 if (sec->reloc_count == 0
7599 || !elf_discarded_section (sec)
7600 || get_opd_info (sec)
7601 || (sec->flags & SEC_ALLOC) == 0
7602 || (sec->flags & SEC_DEBUGGING) != 0)
7603 continue;
7604
7605 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL, FALSE);
7606 if (relstart == NULL)
7607 goto error_ret;
7608
7609 /* Run through the relocs to see which toc entries might be
7610 unused. */
7611 for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
7612 {
7613 enum elf_ppc64_reloc_type r_type;
7614 unsigned long r_symndx;
7615 asection *sym_sec;
7616 struct elf_link_hash_entry *h;
7617 Elf_Internal_Sym *sym;
7618 bfd_vma val;
7619
7620 r_type = ELF64_R_TYPE (rel->r_info);
7621 switch (r_type)
7622 {
7623 default:
7624 continue;
7625
7626 case R_PPC64_TOC16:
7627 case R_PPC64_TOC16_LO:
7628 case R_PPC64_TOC16_HI:
7629 case R_PPC64_TOC16_HA:
7630 case R_PPC64_TOC16_DS:
7631 case R_PPC64_TOC16_LO_DS:
7632 break;
7633 }
7634
7635 r_symndx = ELF64_R_SYM (rel->r_info);
7636 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7637 r_symndx, ibfd))
7638 goto error_ret;
7639
7640 if (sym_sec != toc)
7641 continue;
7642
7643 if (h != NULL)
7644 val = h->root.u.def.value;
7645 else
7646 val = sym->st_value;
7647 val += rel->r_addend;
7648
7649 if (val >= toc->size)
7650 continue;
7651
7652 /* Anything in the toc ought to be aligned to 8 bytes.
7653 If not, don't mark as unused. */
7654 if (val & 7)
7655 continue;
7656
7657 if (skip == NULL)
7658 {
7659 skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 7) / 8);
7660 if (skip == NULL)
7661 goto error_ret;
7662 }
7663
7664 skip[val >> 3] = 1;
7665 }
7666
7667 if (elf_section_data (sec)->relocs != relstart)
7668 free (relstart);
7669 }
7670
7671 if (skip == NULL)
7672 continue;
7673
7674 used = bfd_zmalloc (sizeof (*used) * (toc->size + 7) / 8);
7675 if (used == NULL)
7676 {
7677 error_ret:
7678 if (local_syms != NULL
7679 && symtab_hdr->contents != (unsigned char *) local_syms)
7680 free (local_syms);
7681 if (sec != NULL
7682 && relstart != NULL
7683 && elf_section_data (sec)->relocs != relstart)
7684 free (relstart);
7685 if (skip != NULL)
7686 free (skip);
7687 return FALSE;
7688 }
7689
7690 /* Now check all kept sections that might reference the toc.
7691 Check the toc itself last. */
7692 for (sec = (ibfd->sections == toc && toc->next ? toc->next
7693 : ibfd->sections);
7694 sec != NULL;
7695 sec = (sec == toc ? NULL
7696 : sec->next == NULL ? toc
7697 : sec->next == toc && toc->next ? toc->next
7698 : sec->next))
7699 {
7700 int repeat;
7701
7702 if (sec->reloc_count == 0
7703 || elf_discarded_section (sec)
7704 || get_opd_info (sec)
7705 || (sec->flags & SEC_ALLOC) == 0
7706 || (sec->flags & SEC_DEBUGGING) != 0)
7707 continue;
7708
7709 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL, TRUE);
7710 if (relstart == NULL)
7711 goto error_ret;
7712
7713 /* Mark toc entries referenced as used. */
7714 repeat = 0;
7715 do
7716 for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
7717 {
7718 enum elf_ppc64_reloc_type r_type;
7719 unsigned long r_symndx;
7720 asection *sym_sec;
7721 struct elf_link_hash_entry *h;
7722 Elf_Internal_Sym *sym;
7723 bfd_vma val;
7724
7725 r_type = ELF64_R_TYPE (rel->r_info);
7726 switch (r_type)
7727 {
7728 case R_PPC64_TOC16:
7729 case R_PPC64_TOC16_LO:
7730 case R_PPC64_TOC16_HI:
7731 case R_PPC64_TOC16_HA:
7732 case R_PPC64_TOC16_DS:
7733 case R_PPC64_TOC16_LO_DS:
7734 /* In case we're taking addresses of toc entries. */
7735 case R_PPC64_ADDR64:
7736 break;
7737
7738 default:
7739 continue;
7740 }
7741
7742 r_symndx = ELF64_R_SYM (rel->r_info);
7743 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7744 r_symndx, ibfd))
7745 {
7746 free (used);
7747 goto error_ret;
7748 }
7749
7750 if (sym_sec != toc)
7751 continue;
7752
7753 if (h != NULL)
7754 val = h->root.u.def.value;
7755 else
7756 val = sym->st_value;
7757 val += rel->r_addend;
7758
7759 if (val >= toc->size)
7760 continue;
7761
7762 /* For the toc section, we only mark as used if
7763 this entry itself isn't unused. */
7764 if (sec == toc
7765 && !used[val >> 3]
7766 && (used[rel->r_offset >> 3]
7767 || !skip[rel->r_offset >> 3]))
7768 /* Do all the relocs again, to catch reference
7769 chains. */
7770 repeat = 1;
7771
7772 used[val >> 3] = 1;
7773 }
7774 while (repeat);
7775 }
7776
7777 /* Merge the used and skip arrays. Assume that TOC
7778 doublewords not appearing as either used or unused belong
7779 to to an entry more than one doubleword in size. */
7780 for (drop = skip, keep = used, last = 0, some_unused = 0;
7781 drop < skip + (toc->size + 7) / 8;
7782 ++drop, ++keep)
7783 {
7784 if (*keep)
7785 {
7786 *drop = 0;
7787 last = 0;
7788 }
7789 else if (*drop)
7790 {
7791 some_unused = 1;
7792 last = 1;
7793 }
7794 else
7795 *drop = last;
7796 }
7797
7798 free (used);
7799
7800 if (some_unused)
7801 {
7802 bfd_byte *contents, *src;
7803 unsigned long off;
7804
7805 /* Shuffle the toc contents, and at the same time convert the
7806 skip array from booleans into offsets. */
7807 if (!bfd_malloc_and_get_section (ibfd, toc, &contents))
7808 goto error_ret;
7809
7810 elf_section_data (toc)->this_hdr.contents = contents;
7811
7812 for (src = contents, off = 0, drop = skip;
7813 src < contents + toc->size;
7814 src += 8, ++drop)
7815 {
7816 if (*drop)
7817 {
7818 *drop = (unsigned long) -1;
7819 off += 8;
7820 }
7821 else if (off != 0)
7822 {
7823 *drop = off;
7824 memcpy (src - off, src, 8);
7825 }
7826 }
7827 toc->rawsize = toc->size;
7828 toc->size = src - contents - off;
7829
7830 if (toc->reloc_count != 0)
7831 {
7832 Elf_Internal_Rela *wrel;
7833 bfd_size_type sz;
7834
7835 /* Read toc relocs. */
7836 relstart = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
7837 TRUE);
7838 if (relstart == NULL)
7839 goto error_ret;
7840
7841 /* Remove unused toc relocs, and adjust those we keep. */
7842 wrel = relstart;
7843 for (rel = relstart; rel < relstart + toc->reloc_count; ++rel)
7844 if (skip[rel->r_offset >> 3] != (unsigned long) -1)
7845 {
7846 wrel->r_offset = rel->r_offset - skip[rel->r_offset >> 3];
7847 wrel->r_info = rel->r_info;
7848 wrel->r_addend = rel->r_addend;
7849 ++wrel;
7850 }
7851 else if (!dec_dynrel_count (rel->r_info, toc, info,
7852 &local_syms, NULL, NULL))
7853 goto error_ret;
7854
7855 toc->reloc_count = wrel - relstart;
7856 sz = elf_section_data (toc)->rel_hdr.sh_entsize;
7857 elf_section_data (toc)->rel_hdr.sh_size = toc->reloc_count * sz;
7858 BFD_ASSERT (elf_section_data (toc)->rel_hdr2 == NULL);
7859 }
7860
7861 /* Adjust addends for relocs against the toc section sym. */
7862 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
7863 {
7864 if (sec->reloc_count == 0
7865 || elf_discarded_section (sec))
7866 continue;
7867
7868 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
7869 TRUE);
7870 if (relstart == NULL)
7871 goto error_ret;
7872
7873 for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
7874 {
7875 enum elf_ppc64_reloc_type r_type;
7876 unsigned long r_symndx;
7877 asection *sym_sec;
7878 struct elf_link_hash_entry *h;
7879 Elf_Internal_Sym *sym;
7880
7881 r_type = ELF64_R_TYPE (rel->r_info);
7882 switch (r_type)
7883 {
7884 default:
7885 continue;
7886
7887 case R_PPC64_TOC16:
7888 case R_PPC64_TOC16_LO:
7889 case R_PPC64_TOC16_HI:
7890 case R_PPC64_TOC16_HA:
7891 case R_PPC64_TOC16_DS:
7892 case R_PPC64_TOC16_LO_DS:
7893 case R_PPC64_ADDR64:
7894 break;
7895 }
7896
7897 r_symndx = ELF64_R_SYM (rel->r_info);
7898 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7899 r_symndx, ibfd))
7900 goto error_ret;
7901
7902 if (sym_sec != toc || h != NULL || sym->st_value != 0)
7903 continue;
7904
7905 rel->r_addend -= skip[rel->r_addend >> 3];
7906 }
7907 }
7908
7909 /* We shouldn't have local or global symbols defined in the TOC,
7910 but handle them anyway. */
7911 if (local_syms != NULL)
7912 {
7913 Elf_Internal_Sym *sym;
7914
7915 for (sym = local_syms;
7916 sym < local_syms + symtab_hdr->sh_info;
7917 ++sym)
7918 if (sym->st_value != 0
7919 && bfd_section_from_elf_index (ibfd, sym->st_shndx) == toc)
7920 {
7921 if (skip[sym->st_value >> 3] != (unsigned long) -1)
7922 sym->st_value -= skip[sym->st_value >> 3];
7923 else
7924 {
7925 (*_bfd_error_handler)
7926 (_("%s defined in removed toc entry"),
7927 bfd_elf_sym_name (ibfd, symtab_hdr, sym,
7928 NULL));
7929 sym->st_value = 0;
7930 sym->st_shndx = SHN_ABS;
7931 }
7932 symtab_hdr->contents = (unsigned char *) local_syms;
7933 }
7934 }
7935
7936 /* Finally, adjust any global syms defined in the toc. */
7937 if (toc_inf.global_toc_syms)
7938 {
7939 toc_inf.toc = toc;
7940 toc_inf.skip = skip;
7941 toc_inf.global_toc_syms = FALSE;
7942 elf_link_hash_traverse (elf_hash_table (info), adjust_toc_syms,
7943 &toc_inf);
7944 }
7945 }
7946
7947 if (local_syms != NULL
7948 && symtab_hdr->contents != (unsigned char *) local_syms)
7949 {
7950 if (!info->keep_memory)
7951 free (local_syms);
7952 else
7953 symtab_hdr->contents = (unsigned char *) local_syms;
7954 }
7955 free (skip);
7956 }
7957
7958 return TRUE;
7959 }
7960
7961 /* Allocate space in .plt, .got and associated reloc sections for
7962 dynamic relocs. */
7963
7964 static bfd_boolean
7965 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
7966 {
7967 struct bfd_link_info *info;
7968 struct ppc_link_hash_table *htab;
7969 asection *s;
7970 struct ppc_link_hash_entry *eh;
7971 struct ppc_dyn_relocs *p;
7972 struct got_entry *gent;
7973
7974 if (h->root.type == bfd_link_hash_indirect)
7975 return TRUE;
7976
7977 if (h->root.type == bfd_link_hash_warning)
7978 h = (struct elf_link_hash_entry *) h->root.u.i.link;
7979
7980 info = (struct bfd_link_info *) inf;
7981 htab = ppc_hash_table (info);
7982
7983 if ((htab->elf.dynamic_sections_created
7984 && h->dynindx != -1
7985 && WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info->shared, h))
7986 || h->type == STT_GNU_IFUNC)
7987 {
7988 struct plt_entry *pent;
7989 bfd_boolean doneone = FALSE;
7990 for (pent = h->plt.plist; pent != NULL; pent = pent->next)
7991 if (pent->plt.refcount > 0)
7992 {
7993 if (!htab->elf.dynamic_sections_created)
7994 {
7995 s = htab->iplt;
7996 pent->plt.offset = s->size;
7997 s->size += PLT_ENTRY_SIZE;
7998 s = htab->reliplt;
7999 }
8000 else
8001 {
8002 /* If this is the first .plt entry, make room for the special
8003 first entry. */
8004 s = htab->plt;
8005 if (s->size == 0)
8006 s->size += PLT_INITIAL_ENTRY_SIZE;
8007
8008 pent->plt.offset = s->size;
8009
8010 /* Make room for this entry. */
8011 s->size += PLT_ENTRY_SIZE;
8012
8013 /* Make room for the .glink code. */
8014 s = htab->glink;
8015 if (s->size == 0)
8016 s->size += GLINK_CALL_STUB_SIZE;
8017 /* We need bigger stubs past index 32767. */
8018 if (s->size >= GLINK_CALL_STUB_SIZE + 32768*2*4)
8019 s->size += 4;
8020 s->size += 2*4;
8021
8022 /* We also need to make an entry in the .rela.plt section. */
8023 s = htab->relplt;
8024 }
8025 s->size += sizeof (Elf64_External_Rela);
8026 doneone = TRUE;
8027 }
8028 else
8029 pent->plt.offset = (bfd_vma) -1;
8030 if (!doneone)
8031 {
8032 h->plt.plist = NULL;
8033 h->needs_plt = 0;
8034 }
8035 }
8036 else
8037 {
8038 h->plt.plist = NULL;
8039 h->needs_plt = 0;
8040 }
8041
8042 eh = (struct ppc_link_hash_entry *) h;
8043 /* Run through the TLS GD got entries first if we're changing them
8044 to TPREL. */
8045 if ((eh->tls_mask & TLS_TPRELGD) != 0)
8046 for (gent = h->got.glist; gent != NULL; gent = gent->next)
8047 if (gent->got.refcount > 0
8048 && (gent->tls_type & TLS_GD) != 0)
8049 {
8050 /* This was a GD entry that has been converted to TPREL. If
8051 there happens to be a TPREL entry we can use that one. */
8052 struct got_entry *ent;
8053 for (ent = h->got.glist; ent != NULL; ent = ent->next)
8054 if (ent->got.refcount > 0
8055 && (ent->tls_type & TLS_TPREL) != 0
8056 && ent->addend == gent->addend
8057 && ent->owner == gent->owner)
8058 {
8059 gent->got.refcount = 0;
8060 break;
8061 }
8062
8063 /* If not, then we'll be using our own TPREL entry. */
8064 if (gent->got.refcount != 0)
8065 gent->tls_type = TLS_TLS | TLS_TPREL;
8066 }
8067
8068 for (gent = h->got.glist; gent != NULL; gent = gent->next)
8069 if (gent->got.refcount > 0)
8070 {
8071 bfd_boolean dyn;
8072
8073 /* Make sure this symbol is output as a dynamic symbol.
8074 Undefined weak syms won't yet be marked as dynamic,
8075 nor will all TLS symbols. */
8076 if (h->dynindx == -1
8077 && !h->forced_local
8078 && htab->elf.dynamic_sections_created)
8079 {
8080 if (! bfd_elf_link_record_dynamic_symbol (info, h))
8081 return FALSE;
8082 }
8083
8084 if ((gent->tls_type & TLS_LD) != 0
8085 && !h->def_dynamic)
8086 {
8087 ppc64_tlsld_got (gent->owner)->refcount += 1;
8088 gent->got.offset = (bfd_vma) -1;
8089 continue;
8090 }
8091
8092 if (!is_ppc64_elf (gent->owner))
8093 continue;
8094
8095 s = ppc64_elf_tdata (gent->owner)->got;
8096 gent->got.offset = s->size;
8097 s->size
8098 += (gent->tls_type & eh->tls_mask & (TLS_GD | TLS_LD)) ? 16 : 8;
8099 dyn = htab->elf.dynamic_sections_created;
8100 if ((info->shared
8101 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h))
8102 && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
8103 || h->root.type != bfd_link_hash_undefweak))
8104 ppc64_elf_tdata (gent->owner)->relgot->size
8105 += (gent->tls_type & eh->tls_mask & TLS_GD
8106 ? 2 * sizeof (Elf64_External_Rela)
8107 : sizeof (Elf64_External_Rela));
8108 }
8109 else
8110 gent->got.offset = (bfd_vma) -1;
8111
8112 if (eh->dyn_relocs == NULL
8113 || !htab->elf.dynamic_sections_created)
8114 return TRUE;
8115
8116 /* In the shared -Bsymbolic case, discard space allocated for
8117 dynamic pc-relative relocs against symbols which turn out to be
8118 defined in regular objects. For the normal shared case, discard
8119 space for relocs that have become local due to symbol visibility
8120 changes. */
8121
8122 if (info->shared)
8123 {
8124 /* Relocs that use pc_count are those that appear on a call insn,
8125 or certain REL relocs (see must_be_dyn_reloc) that can be
8126 generated via assembly. We want calls to protected symbols to
8127 resolve directly to the function rather than going via the plt.
8128 If people want function pointer comparisons to work as expected
8129 then they should avoid writing weird assembly. */
8130 if (SYMBOL_CALLS_LOCAL (info, h))
8131 {
8132 struct ppc_dyn_relocs **pp;
8133
8134 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
8135 {
8136 p->count -= p->pc_count;
8137 p->pc_count = 0;
8138 if (p->count == 0)
8139 *pp = p->next;
8140 else
8141 pp = &p->next;
8142 }
8143 }
8144
8145 /* Also discard relocs on undefined weak syms with non-default
8146 visibility. */
8147 if (eh->dyn_relocs != NULL
8148 && h->root.type == bfd_link_hash_undefweak)
8149 {
8150 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
8151 eh->dyn_relocs = NULL;
8152
8153 /* Make sure this symbol is output as a dynamic symbol.
8154 Undefined weak syms won't yet be marked as dynamic. */
8155 else if (h->dynindx == -1
8156 && !h->forced_local)
8157 {
8158 if (! bfd_elf_link_record_dynamic_symbol (info, h))
8159 return FALSE;
8160 }
8161 }
8162 }
8163 else if (ELIMINATE_COPY_RELOCS)
8164 {
8165 /* For the non-shared case, discard space for relocs against
8166 symbols which turn out to need copy relocs or are not
8167 dynamic. */
8168
8169 if (!h->non_got_ref
8170 && !h->def_regular)
8171 {
8172 /* Make sure this symbol is output as a dynamic symbol.
8173 Undefined weak syms won't yet be marked as dynamic. */
8174 if (h->dynindx == -1
8175 && !h->forced_local)
8176 {
8177 if (! bfd_elf_link_record_dynamic_symbol (info, h))
8178 return FALSE;
8179 }
8180
8181 /* If that succeeded, we know we'll be keeping all the
8182 relocs. */
8183 if (h->dynindx != -1)
8184 goto keep;
8185 }
8186
8187 eh->dyn_relocs = NULL;
8188
8189 keep: ;
8190 }
8191
8192 /* Finally, allocate space. */
8193 for (p = eh->dyn_relocs; p != NULL; p = p->next)
8194 {
8195 asection *sreloc = elf_section_data (p->sec)->sreloc;
8196 sreloc->size += p->count * sizeof (Elf64_External_Rela);
8197 }
8198
8199 return TRUE;
8200 }
8201
8202 /* Find any dynamic relocs that apply to read-only sections. */
8203
8204 static bfd_boolean
8205 readonly_dynrelocs (struct elf_link_hash_entry *h, void *inf)
8206 {
8207 struct ppc_link_hash_entry *eh;
8208 struct ppc_dyn_relocs *p;
8209
8210 if (h->root.type == bfd_link_hash_warning)
8211 h = (struct elf_link_hash_entry *) h->root.u.i.link;
8212
8213 eh = (struct ppc_link_hash_entry *) h;
8214 for (p = eh->dyn_relocs; p != NULL; p = p->next)
8215 {
8216 asection *s = p->sec->output_section;
8217
8218 if (s != NULL && (s->flags & SEC_READONLY) != 0)
8219 {
8220 struct bfd_link_info *info = inf;
8221
8222 info->flags |= DF_TEXTREL;
8223
8224 /* Not an error, just cut short the traversal. */
8225 return FALSE;
8226 }
8227 }
8228 return TRUE;
8229 }
8230
8231 /* Set the sizes of the dynamic sections. */
8232
8233 static bfd_boolean
8234 ppc64_elf_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
8235 struct bfd_link_info *info)
8236 {
8237 struct ppc_link_hash_table *htab;
8238 bfd *dynobj;
8239 asection *s;
8240 bfd_boolean relocs;
8241 bfd *ibfd;
8242
8243 htab = ppc_hash_table (info);
8244 dynobj = htab->elf.dynobj;
8245 if (dynobj == NULL)
8246 abort ();
8247
8248 if (htab->elf.dynamic_sections_created)
8249 {
8250 /* Set the contents of the .interp section to the interpreter. */
8251 if (info->executable)
8252 {
8253 s = bfd_get_section_by_name (dynobj, ".interp");
8254 if (s == NULL)
8255 abort ();
8256 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
8257 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
8258 }
8259 }
8260
8261 /* Set up .got offsets for local syms, and space for local dynamic
8262 relocs. */
8263 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
8264 {
8265 struct got_entry **lgot_ents;
8266 struct got_entry **end_lgot_ents;
8267 struct plt_entry **local_plt;
8268 struct plt_entry **end_local_plt;
8269 char *lgot_masks;
8270 bfd_size_type locsymcount;
8271 Elf_Internal_Shdr *symtab_hdr;
8272 asection *srel;
8273
8274 if (!is_ppc64_elf (ibfd))
8275 continue;
8276
8277 for (s = ibfd->sections; s != NULL; s = s->next)
8278 {
8279 struct ppc_dyn_relocs *p;
8280
8281 for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
8282 {
8283 if (!bfd_is_abs_section (p->sec)
8284 && bfd_is_abs_section (p->sec->output_section))
8285 {
8286 /* Input section has been discarded, either because
8287 it is a copy of a linkonce section or due to
8288 linker script /DISCARD/, so we'll be discarding
8289 the relocs too. */
8290 }
8291 else if (p->count != 0)
8292 {
8293 srel = elf_section_data (p->sec)->sreloc;
8294 srel->size += p->count * sizeof (Elf64_External_Rela);
8295 if ((p->sec->output_section->flags & SEC_READONLY) != 0)
8296 info->flags |= DF_TEXTREL;
8297 }
8298 }
8299 }
8300
8301 lgot_ents = elf_local_got_ents (ibfd);
8302 if (!lgot_ents)
8303 continue;
8304
8305 symtab_hdr = &elf_symtab_hdr (ibfd);
8306 locsymcount = symtab_hdr->sh_info;
8307 end_lgot_ents = lgot_ents + locsymcount;
8308 local_plt = (struct plt_entry **) end_lgot_ents;
8309 end_local_plt = local_plt + locsymcount;
8310 lgot_masks = (char *) end_local_plt;
8311 s = ppc64_elf_tdata (ibfd)->got;
8312 srel = ppc64_elf_tdata (ibfd)->relgot;
8313 for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
8314 {
8315 struct got_entry *ent;
8316
8317 for (ent = *lgot_ents; ent != NULL; ent = ent->next)
8318 if (ent->got.refcount > 0)
8319 {
8320 if ((ent->tls_type & *lgot_masks & TLS_LD) != 0)
8321 {
8322 ppc64_tlsld_got (ibfd)->refcount += 1;
8323 ent->got.offset = (bfd_vma) -1;
8324 }
8325 else
8326 {
8327 ent->got.offset = s->size;
8328 if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
8329 {
8330 s->size += 16;
8331 if (info->shared)
8332 srel->size += 2 * sizeof (Elf64_External_Rela);
8333 }
8334 else
8335 {
8336 s->size += 8;
8337 if (info->shared)
8338 srel->size += sizeof (Elf64_External_Rela);
8339 }
8340 }
8341 }
8342 else
8343 ent->got.offset = (bfd_vma) -1;
8344 }
8345
8346 /* Allocate space for calls to local STT_GNU_IFUNC syms in .iplt. */
8347 for (; local_plt < end_local_plt; ++local_plt)
8348 {
8349 struct plt_entry *ent;
8350
8351 for (ent = *local_plt; ent != NULL; ent = ent->next)
8352 if (ent->plt.refcount > 0)
8353 {
8354 asection *s = htab->iplt;
8355
8356 ent->plt.offset = s->size;
8357 s->size += PLT_ENTRY_SIZE;
8358
8359 htab->reliplt += sizeof (Elf64_External_Rela);
8360 }
8361 else
8362 ent->plt.offset = (bfd_vma) -1;
8363 }
8364 }
8365
8366 /* Allocate global sym .plt and .got entries, and space for global
8367 sym dynamic relocs. */
8368 elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, info);
8369
8370 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
8371 {
8372 if (!is_ppc64_elf (ibfd))
8373 continue;
8374
8375 if (ppc64_tlsld_got (ibfd)->refcount > 0)
8376 {
8377 s = ppc64_elf_tdata (ibfd)->got;
8378 ppc64_tlsld_got (ibfd)->offset = s->size;
8379 s->size += 16;
8380 if (info->shared)
8381 {
8382 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
8383 srel->size += sizeof (Elf64_External_Rela);
8384 }
8385 }
8386 else
8387 ppc64_tlsld_got (ibfd)->offset = (bfd_vma) -1;
8388 }
8389
8390 /* We now have determined the sizes of the various dynamic sections.
8391 Allocate memory for them. */
8392 relocs = FALSE;
8393 for (s = dynobj->sections; s != NULL; s = s->next)
8394 {
8395 if ((s->flags & SEC_LINKER_CREATED) == 0)
8396 continue;
8397
8398 if (s == htab->brlt || s == htab->relbrlt)
8399 /* These haven't been allocated yet; don't strip. */
8400 continue;
8401 else if (s == htab->got
8402 || s == htab->plt
8403 || s == htab->iplt
8404 || s == htab->glink
8405 || s == htab->dynbss)
8406 {
8407 /* Strip this section if we don't need it; see the
8408 comment below. */
8409 }
8410 else if (CONST_STRNEQ (bfd_get_section_name (dynobj, s), ".rela"))
8411 {
8412 if (s->size != 0)
8413 {
8414 if (s != htab->relplt)
8415 relocs = TRUE;
8416
8417 /* We use the reloc_count field as a counter if we need
8418 to copy relocs into the output file. */
8419 s->reloc_count = 0;
8420 }
8421 }
8422 else
8423 {
8424 /* It's not one of our sections, so don't allocate space. */
8425 continue;
8426 }
8427
8428 if (s->size == 0)
8429 {
8430 /* If we don't need this section, strip it from the
8431 output file. This is mostly to handle .rela.bss and
8432 .rela.plt. We must create both sections in
8433 create_dynamic_sections, because they must be created
8434 before the linker maps input sections to output
8435 sections. The linker does that before
8436 adjust_dynamic_symbol is called, and it is that
8437 function which decides whether anything needs to go
8438 into these sections. */
8439 s->flags |= SEC_EXCLUDE;
8440 continue;
8441 }
8442
8443 if ((s->flags & SEC_HAS_CONTENTS) == 0)
8444 continue;
8445
8446 /* Allocate memory for the section contents. We use bfd_zalloc
8447 here in case unused entries are not reclaimed before the
8448 section's contents are written out. This should not happen,
8449 but this way if it does we get a R_PPC64_NONE reloc in .rela
8450 sections instead of garbage.
8451 We also rely on the section contents being zero when writing
8452 the GOT. */
8453 s->contents = bfd_zalloc (dynobj, s->size);
8454 if (s->contents == NULL)
8455 return FALSE;
8456 }
8457
8458 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
8459 {
8460 if (!is_ppc64_elf (ibfd))
8461 continue;
8462
8463 s = ppc64_elf_tdata (ibfd)->got;
8464 if (s != NULL && s != htab->got)
8465 {
8466 if (s->size == 0)
8467 s->flags |= SEC_EXCLUDE;
8468 else
8469 {
8470 s->contents = bfd_zalloc (ibfd, s->size);
8471 if (s->contents == NULL)
8472 return FALSE;
8473 }
8474 }
8475 s = ppc64_elf_tdata (ibfd)->relgot;
8476 if (s != NULL)
8477 {
8478 if (s->size == 0)
8479 s->flags |= SEC_EXCLUDE;
8480 else
8481 {
8482 s->contents = bfd_zalloc (ibfd, s->size);
8483 if (s->contents == NULL)
8484 return FALSE;
8485 relocs = TRUE;
8486 s->reloc_count = 0;
8487 }
8488 }
8489 }
8490
8491 if (htab->elf.dynamic_sections_created)
8492 {
8493 /* Add some entries to the .dynamic section. We fill in the
8494 values later, in ppc64_elf_finish_dynamic_sections, but we
8495 must add the entries now so that we get the correct size for
8496 the .dynamic section. The DT_DEBUG entry is filled in by the
8497 dynamic linker and used by the debugger. */
8498 #define add_dynamic_entry(TAG, VAL) \
8499 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
8500
8501 if (info->executable)
8502 {
8503 if (!add_dynamic_entry (DT_DEBUG, 0))
8504 return FALSE;
8505 }
8506
8507 if (htab->plt != NULL && htab->plt->size != 0)
8508 {
8509 if (!add_dynamic_entry (DT_PLTGOT, 0)
8510 || !add_dynamic_entry (DT_PLTRELSZ, 0)
8511 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
8512 || !add_dynamic_entry (DT_JMPREL, 0)
8513 || !add_dynamic_entry (DT_PPC64_GLINK, 0))
8514 return FALSE;
8515 }
8516
8517 if (NO_OPD_RELOCS)
8518 {
8519 if (!add_dynamic_entry (DT_PPC64_OPD, 0)
8520 || !add_dynamic_entry (DT_PPC64_OPDSZ, 0))
8521 return FALSE;
8522 }
8523
8524 if (relocs)
8525 {
8526 if (!add_dynamic_entry (DT_RELA, 0)
8527 || !add_dynamic_entry (DT_RELASZ, 0)
8528 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
8529 return FALSE;
8530
8531 /* If any dynamic relocs apply to a read-only section,
8532 then we need a DT_TEXTREL entry. */
8533 if ((info->flags & DF_TEXTREL) == 0)
8534 elf_link_hash_traverse (&htab->elf, readonly_dynrelocs, info);
8535
8536 if ((info->flags & DF_TEXTREL) != 0)
8537 {
8538 if (!add_dynamic_entry (DT_TEXTREL, 0))
8539 return FALSE;
8540 }
8541 }
8542 }
8543 #undef add_dynamic_entry
8544
8545 return TRUE;
8546 }
8547
8548 /* Determine the type of stub needed, if any, for a call. */
8549
8550 static inline enum ppc_stub_type
8551 ppc_type_of_stub (asection *input_sec,
8552 const Elf_Internal_Rela *rel,
8553 struct ppc_link_hash_entry **hash,
8554 struct plt_entry **plt_ent,
8555 bfd_vma destination)
8556 {
8557 struct ppc_link_hash_entry *h = *hash;
8558 bfd_vma location;
8559 bfd_vma branch_offset;
8560 bfd_vma max_branch_offset;
8561 enum elf_ppc64_reloc_type r_type;
8562
8563 if (h != NULL)
8564 {
8565 struct plt_entry *ent;
8566 struct ppc_link_hash_entry *fdh = h;
8567 if (fdh->oh != NULL
8568 && fdh->oh->is_func_descriptor)
8569 fdh = fdh->oh;
8570
8571 for (ent = fdh->elf.plt.plist; ent != NULL; ent = ent->next)
8572 if (ent->addend == rel->r_addend
8573 && ent->plt.offset != (bfd_vma) -1)
8574 {
8575 *hash = fdh;
8576 *plt_ent = ent;
8577 return ppc_stub_plt_call;
8578 }
8579
8580 /* Here, we know we don't have a plt entry. If we don't have a
8581 either a defined function descriptor or a defined entry symbol
8582 in a regular object file, then it is pointless trying to make
8583 any other type of stub. */
8584 if (!((fdh->elf.root.type == bfd_link_hash_defined
8585 || fdh->elf.root.type == bfd_link_hash_defweak)
8586 && fdh->elf.root.u.def.section->output_section != NULL)
8587 && !((h->elf.root.type == bfd_link_hash_defined
8588 || h->elf.root.type == bfd_link_hash_defweak)
8589 && h->elf.root.u.def.section->output_section != NULL))
8590 return ppc_stub_none;
8591 }
8592 else if (elf_local_got_ents (input_sec->owner) != NULL)
8593 {
8594 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (input_sec->owner);
8595 struct plt_entry **local_plt = (struct plt_entry **)
8596 elf_local_got_ents (input_sec->owner) + symtab_hdr->sh_info;
8597 unsigned long r_symndx = ELF64_R_SYM (rel->r_info);
8598
8599 if (local_plt[r_symndx] != NULL)
8600 {
8601 struct plt_entry *ent;
8602
8603 for (ent = local_plt[r_symndx]; ent != NULL; ent = ent->next)
8604 if (ent->addend == rel->r_addend
8605 && ent->plt.offset != (bfd_vma) -1)
8606 {
8607 *plt_ent = ent;
8608 return ppc_stub_plt_call;
8609 }
8610 }
8611 }
8612
8613 /* Determine where the call point is. */
8614 location = (input_sec->output_offset
8615 + input_sec->output_section->vma
8616 + rel->r_offset);
8617
8618 branch_offset = destination - location;
8619 r_type = ELF64_R_TYPE (rel->r_info);
8620
8621 /* Determine if a long branch stub is needed. */
8622 max_branch_offset = 1 << 25;
8623 if (r_type != R_PPC64_REL24)
8624 max_branch_offset = 1 << 15;
8625
8626 if (branch_offset + max_branch_offset >= 2 * max_branch_offset)
8627 /* We need a stub. Figure out whether a long_branch or plt_branch
8628 is needed later. */
8629 return ppc_stub_long_branch;
8630
8631 return ppc_stub_none;
8632 }
8633
8634 /* Build a .plt call stub. */
8635
8636 static inline bfd_byte *
8637 build_plt_stub (bfd *obfd, bfd_byte *p, int offset, Elf_Internal_Rela *r)
8638 {
8639 #define PPC_LO(v) ((v) & 0xffff)
8640 #define PPC_HI(v) (((v) >> 16) & 0xffff)
8641 #define PPC_HA(v) PPC_HI ((v) + 0x8000)
8642
8643 if (PPC_HA (offset) != 0)
8644 {
8645 if (r != NULL)
8646 {
8647 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
8648 r[1].r_offset = r[0].r_offset + 8;
8649 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
8650 r[1].r_addend = r[0].r_addend;
8651 if (PPC_HA (offset + 16) != PPC_HA (offset))
8652 {
8653 r[2].r_offset = r[1].r_offset + 4;
8654 r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO);
8655 r[2].r_addend = r[0].r_addend;
8656 }
8657 else
8658 {
8659 r[2].r_offset = r[1].r_offset + 8;
8660 r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
8661 r[2].r_addend = r[0].r_addend + 8;
8662 r[3].r_offset = r[2].r_offset + 4;
8663 r[3].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
8664 r[3].r_addend = r[0].r_addend + 16;
8665 }
8666 }
8667 bfd_put_32 (obfd, ADDIS_R12_R2 | PPC_HA (offset), p), p += 4;
8668 bfd_put_32 (obfd, STD_R2_40R1, p), p += 4;
8669 bfd_put_32 (obfd, LD_R11_0R12 | PPC_LO (offset), p), p += 4;
8670 if (PPC_HA (offset + 16) != PPC_HA (offset))
8671 {
8672 bfd_put_32 (obfd, ADDI_R12_R12 | PPC_LO (offset), p), p += 4;
8673 offset = 0;
8674 }
8675 bfd_put_32 (obfd, MTCTR_R11, p), p += 4;
8676 bfd_put_32 (obfd, LD_R2_0R12 | PPC_LO (offset + 8), p), p += 4;
8677 bfd_put_32 (obfd, LD_R11_0R12 | PPC_LO (offset + 16), p), p += 4;
8678 bfd_put_32 (obfd, BCTR, p), p += 4;
8679 }
8680 else
8681 {
8682 if (r != NULL)
8683 {
8684 r[0].r_offset += 4;
8685 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
8686 if (PPC_HA (offset + 16) != PPC_HA (offset))
8687 {
8688 r[1].r_offset = r[0].r_offset + 4;
8689 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16);
8690 r[1].r_addend = r[0].r_addend;
8691 }
8692 else
8693 {
8694 r[1].r_offset = r[0].r_offset + 8;
8695 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
8696 r[1].r_addend = r[0].r_addend + 16;
8697 r[2].r_offset = r[1].r_offset + 4;
8698 r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
8699 r[2].r_addend = r[0].r_addend + 8;
8700 }
8701 }
8702 bfd_put_32 (obfd, STD_R2_40R1, p), p += 4;
8703 bfd_put_32 (obfd, LD_R11_0R2 | PPC_LO (offset), p), p += 4;
8704 if (PPC_HA (offset + 16) != PPC_HA (offset))
8705 {
8706 bfd_put_32 (obfd, ADDI_R2_R2 | PPC_LO (offset), p), p += 4;
8707 offset = 0;
8708 }
8709 bfd_put_32 (obfd, MTCTR_R11, p), p += 4;
8710 bfd_put_32 (obfd, LD_R11_0R2 | PPC_LO (offset + 16), p), p += 4;
8711 bfd_put_32 (obfd, LD_R2_0R2 | PPC_LO (offset + 8), p), p += 4;
8712 bfd_put_32 (obfd, BCTR, p), p += 4;
8713 }
8714 return p;
8715 }
8716
8717 static Elf_Internal_Rela *
8718 get_relocs (asection *sec, int count)
8719 {
8720 Elf_Internal_Rela *relocs;
8721 struct bfd_elf_section_data *elfsec_data;
8722
8723 elfsec_data = elf_section_data (sec);
8724 relocs = elfsec_data->relocs;
8725 if (relocs == NULL)
8726 {
8727 bfd_size_type relsize;
8728 relsize = sec->reloc_count * sizeof (*relocs);
8729 relocs = bfd_alloc (sec->owner, relsize);
8730 if (relocs == NULL)
8731 return NULL;
8732 elfsec_data->relocs = relocs;
8733 elfsec_data->rel_hdr.sh_size = (sec->reloc_count
8734 * sizeof (Elf64_External_Rela));
8735 elfsec_data->rel_hdr.sh_entsize = sizeof (Elf64_External_Rela);
8736 sec->reloc_count = 0;
8737 }
8738 relocs += sec->reloc_count;
8739 sec->reloc_count += count;
8740 return relocs;
8741 }
8742
8743 static bfd_boolean
8744 ppc_build_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
8745 {
8746 struct ppc_stub_hash_entry *stub_entry;
8747 struct ppc_branch_hash_entry *br_entry;
8748 struct bfd_link_info *info;
8749 struct ppc_link_hash_table *htab;
8750 bfd_byte *loc;
8751 bfd_byte *p;
8752 bfd_vma dest, off;
8753 int size;
8754 Elf_Internal_Rela *r;
8755 asection *plt;
8756
8757 /* Massage our args to the form they really have. */
8758 stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
8759 info = in_arg;
8760
8761 htab = ppc_hash_table (info);
8762
8763 /* Make a note of the offset within the stubs for this entry. */
8764 stub_entry->stub_offset = stub_entry->stub_sec->size;
8765 loc = stub_entry->stub_sec->contents + stub_entry->stub_offset;
8766
8767 htab->stub_count[stub_entry->stub_type - 1] += 1;
8768 switch (stub_entry->stub_type)
8769 {
8770 case ppc_stub_long_branch:
8771 case ppc_stub_long_branch_r2off:
8772 /* Branches are relative. This is where we are going to. */
8773 off = dest = (stub_entry->target_value
8774 + stub_entry->target_section->output_offset
8775 + stub_entry->target_section->output_section->vma);
8776
8777 /* And this is where we are coming from. */
8778 off -= (stub_entry->stub_offset
8779 + stub_entry->stub_sec->output_offset
8780 + stub_entry->stub_sec->output_section->vma);
8781
8782 size = 4;
8783 if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
8784 {
8785 bfd_vma r2off;
8786
8787 r2off = (htab->stub_group[stub_entry->target_section->id].toc_off
8788 - htab->stub_group[stub_entry->id_sec->id].toc_off);
8789 bfd_put_32 (htab->stub_bfd, STD_R2_40R1, loc);
8790 loc += 4;
8791 size = 12;
8792 if (PPC_HA (r2off) != 0)
8793 {
8794 size = 16;
8795 bfd_put_32 (htab->stub_bfd, ADDIS_R2_R2 | PPC_HA (r2off), loc);
8796 loc += 4;
8797 }
8798 bfd_put_32 (htab->stub_bfd, ADDI_R2_R2 | PPC_LO (r2off), loc);
8799 loc += 4;
8800 off -= size - 4;
8801 }
8802 bfd_put_32 (htab->stub_bfd, B_DOT | (off & 0x3fffffc), loc);
8803
8804 if (off + (1 << 25) >= (bfd_vma) (1 << 26))
8805 {
8806 (*_bfd_error_handler) (_("long branch stub `%s' offset overflow"),
8807 stub_entry->root.string);
8808 htab->stub_error = TRUE;
8809 return FALSE;
8810 }
8811
8812 if (info->emitrelocations)
8813 {
8814 r = get_relocs (stub_entry->stub_sec, 1);
8815 if (r == NULL)
8816 return FALSE;
8817 r->r_offset = loc - stub_entry->stub_sec->contents;
8818 r->r_info = ELF64_R_INFO (0, R_PPC64_REL24);
8819 r->r_addend = dest;
8820 if (stub_entry->h != NULL)
8821 {
8822 struct elf_link_hash_entry **hashes;
8823 unsigned long symndx;
8824 struct ppc_link_hash_entry *h;
8825
8826 hashes = elf_sym_hashes (htab->stub_bfd);
8827 if (hashes == NULL)
8828 {
8829 bfd_size_type hsize;
8830
8831 hsize = (htab->stub_globals + 1) * sizeof (*hashes);
8832 hashes = bfd_zalloc (htab->stub_bfd, hsize);
8833 if (hashes == NULL)
8834 return FALSE;
8835 elf_sym_hashes (htab->stub_bfd) = hashes;
8836 htab->stub_globals = 1;
8837 }
8838 symndx = htab->stub_globals++;
8839 h = stub_entry->h;
8840 hashes[symndx] = &h->elf;
8841 r->r_info = ELF64_R_INFO (symndx, R_PPC64_REL24);
8842 if (h->oh != NULL && h->oh->is_func)
8843 h = h->oh;
8844 if (h->elf.root.u.def.section != stub_entry->target_section)
8845 /* H is an opd symbol. The addend must be zero. */
8846 r->r_addend = 0;
8847 else
8848 {
8849 off = (h->elf.root.u.def.value
8850 + h->elf.root.u.def.section->output_offset
8851 + h->elf.root.u.def.section->output_section->vma);
8852 r->r_addend -= off;
8853 }
8854 }
8855 }
8856 break;
8857
8858 case ppc_stub_plt_branch:
8859 case ppc_stub_plt_branch_r2off:
8860 br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
8861 stub_entry->root.string + 9,
8862 FALSE, FALSE);
8863 if (br_entry == NULL)
8864 {
8865 (*_bfd_error_handler) (_("can't find branch stub `%s'"),
8866 stub_entry->root.string);
8867 htab->stub_error = TRUE;
8868 return FALSE;
8869 }
8870
8871 dest = (stub_entry->target_value
8872 + stub_entry->target_section->output_offset
8873 + stub_entry->target_section->output_section->vma);
8874
8875 bfd_put_64 (htab->brlt->owner, dest,
8876 htab->brlt->contents + br_entry->offset);
8877
8878 if (br_entry->iter == htab->stub_iteration)
8879 {
8880 br_entry->iter = 0;
8881
8882 if (htab->relbrlt != NULL)
8883 {
8884 /* Create a reloc for the branch lookup table entry. */
8885 Elf_Internal_Rela rela;
8886 bfd_byte *rl;
8887
8888 rela.r_offset = (br_entry->offset
8889 + htab->brlt->output_offset
8890 + htab->brlt->output_section->vma);
8891 rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
8892 rela.r_addend = dest;
8893
8894 rl = htab->relbrlt->contents;
8895 rl += (htab->relbrlt->reloc_count++
8896 * sizeof (Elf64_External_Rela));
8897 bfd_elf64_swap_reloca_out (htab->relbrlt->owner, &rela, rl);
8898 }
8899 else if (info->emitrelocations)
8900 {
8901 r = get_relocs (htab->brlt, 1);
8902 if (r == NULL)
8903 return FALSE;
8904 /* brlt, being SEC_LINKER_CREATED does not go through the
8905 normal reloc processing. Symbols and offsets are not
8906 translated from input file to output file form, so
8907 set up the offset per the output file. */
8908 r->r_offset = (br_entry->offset
8909 + htab->brlt->output_offset
8910 + htab->brlt->output_section->vma);
8911 r->r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
8912 r->r_addend = dest;
8913 }
8914 }
8915
8916 dest = (br_entry->offset
8917 + htab->brlt->output_offset
8918 + htab->brlt->output_section->vma);
8919
8920 off = (dest
8921 - elf_gp (htab->brlt->output_section->owner)
8922 - htab->stub_group[stub_entry->id_sec->id].toc_off);
8923
8924 if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
8925 {
8926 (*_bfd_error_handler)
8927 (_("linkage table error against `%s'"),
8928 stub_entry->root.string);
8929 bfd_set_error (bfd_error_bad_value);
8930 htab->stub_error = TRUE;
8931 return FALSE;
8932 }
8933
8934 if (info->emitrelocations)
8935 {
8936 r = get_relocs (stub_entry->stub_sec, 1 + (PPC_HA (off) != 0));
8937 if (r == NULL)
8938 return FALSE;
8939 r[0].r_offset = loc - stub_entry->stub_sec->contents;
8940 if (bfd_big_endian (info->output_bfd))
8941 r[0].r_offset += 2;
8942 if (stub_entry->stub_type == ppc_stub_plt_branch_r2off)
8943 r[0].r_offset += 4;
8944 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
8945 r[0].r_addend = dest;
8946 if (PPC_HA (off) != 0)
8947 {
8948 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
8949 r[1].r_offset = r[0].r_offset + 4;
8950 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
8951 r[1].r_addend = r[0].r_addend;
8952 }
8953 }
8954
8955 if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
8956 {
8957 if (PPC_HA (off) != 0)
8958 {
8959 size = 16;
8960 bfd_put_32 (htab->stub_bfd, ADDIS_R12_R2 | PPC_HA (off), loc);
8961 loc += 4;
8962 bfd_put_32 (htab->stub_bfd, LD_R11_0R12 | PPC_LO (off), loc);
8963 }
8964 else
8965 {
8966 size = 12;
8967 bfd_put_32 (htab->stub_bfd, LD_R11_0R2 | PPC_LO (off), loc);
8968 }
8969 }
8970 else
8971 {
8972 bfd_vma r2off;
8973
8974 r2off = (htab->stub_group[stub_entry->target_section->id].toc_off
8975 - htab->stub_group[stub_entry->id_sec->id].toc_off);
8976 bfd_put_32 (htab->stub_bfd, STD_R2_40R1, loc);
8977 loc += 4;
8978 size = 20;
8979 if (PPC_HA (off) != 0)
8980 {
8981 size += 4;
8982 bfd_put_32 (htab->stub_bfd, ADDIS_R12_R2 | PPC_HA (off), loc);
8983 loc += 4;
8984 bfd_put_32 (htab->stub_bfd, LD_R11_0R12 | PPC_LO (off), loc);
8985 loc += 4;
8986 }
8987 else
8988 {
8989 bfd_put_32 (htab->stub_bfd, LD_R11_0R2 | PPC_LO (off), loc);
8990 loc += 4;
8991 }
8992
8993 if (PPC_HA (r2off) != 0)
8994 {
8995 size += 4;
8996 bfd_put_32 (htab->stub_bfd, ADDIS_R2_R2 | PPC_HA (r2off), loc);
8997 loc += 4;
8998 }
8999 bfd_put_32 (htab->stub_bfd, ADDI_R2_R2 | PPC_LO (r2off), loc);
9000 }
9001 loc += 4;
9002 bfd_put_32 (htab->stub_bfd, MTCTR_R11, loc);
9003 loc += 4;
9004 bfd_put_32 (htab->stub_bfd, BCTR, loc);
9005 break;
9006
9007 case ppc_stub_plt_call:
9008 /* Do the best we can for shared libraries built without
9009 exporting ".foo" for each "foo". This can happen when symbol
9010 versioning scripts strip all bar a subset of symbols. */
9011 if (stub_entry->h != NULL
9012 && stub_entry->h->oh != NULL
9013 && stub_entry->h->oh->elf.root.type != bfd_link_hash_defined
9014 && stub_entry->h->oh->elf.root.type != bfd_link_hash_defweak)
9015 {
9016 /* Point the symbol at the stub. There may be multiple stubs,
9017 we don't really care; The main thing is to make this sym
9018 defined somewhere. Maybe defining the symbol in the stub
9019 section is a silly idea. If we didn't do this, htab->top_id
9020 could disappear. */
9021 stub_entry->h->oh->elf.root.type = bfd_link_hash_defined;
9022 stub_entry->h->oh->elf.root.u.def.section = stub_entry->stub_sec;
9023 stub_entry->h->oh->elf.root.u.def.value = stub_entry->stub_offset;
9024 }
9025
9026 /* Now build the stub. */
9027 dest = stub_entry->plt_ent->plt.offset & ~1;
9028 if (dest >= (bfd_vma) -2)
9029 abort ();
9030
9031 plt = htab->plt;
9032 if (!htab->elf.dynamic_sections_created)
9033 plt = htab->iplt;
9034
9035 dest += plt->output_offset + plt->output_section->vma;
9036
9037 if (stub_entry->h == NULL
9038 && (stub_entry->plt_ent->plt.offset & 1) == 0)
9039 {
9040 Elf_Internal_Rela rela;
9041 bfd_byte *rl;
9042
9043 rela.r_offset = dest;
9044 rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
9045 rela.r_addend = (stub_entry->target_value
9046 + stub_entry->target_section->output_offset
9047 + stub_entry->target_section->output_section->vma);
9048
9049 if (!htab->elf.dynamic_sections_created)
9050 rl = (htab->reliplt->contents
9051 + (stub_entry->plt_ent->plt.offset
9052 / (PLT_ENTRY_SIZE / sizeof (Elf64_External_Rela))));
9053 else
9054 rl = (htab->relplt->contents
9055 + ((stub_entry->plt_ent->plt.offset - PLT_INITIAL_ENTRY_SIZE)
9056 / (PLT_ENTRY_SIZE / sizeof (Elf64_External_Rela))));
9057 bfd_elf32_swap_reloca_out (info->output_bfd, &rela, rl);
9058 stub_entry->plt_ent->plt.offset |= 1;
9059 }
9060
9061 off = (dest
9062 - elf_gp (plt->output_section->owner)
9063 - htab->stub_group[stub_entry->id_sec->id].toc_off);
9064
9065 if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
9066 {
9067 (*_bfd_error_handler)
9068 (_("linkage table error against `%s'"),
9069 stub_entry->h != NULL
9070 ? stub_entry->h->elf.root.root.string
9071 : "<local sym>");
9072 bfd_set_error (bfd_error_bad_value);
9073 htab->stub_error = TRUE;
9074 return FALSE;
9075 }
9076
9077 r = NULL;
9078 if (info->emitrelocations)
9079 {
9080 r = get_relocs (stub_entry->stub_sec,
9081 (2 + (PPC_HA (off) != 0)
9082 + (PPC_HA (off + 16) == PPC_HA (off))));
9083 if (r == NULL)
9084 return FALSE;
9085 r[0].r_offset = loc - stub_entry->stub_sec->contents;
9086 if (bfd_big_endian (info->output_bfd))
9087 r[0].r_offset += 2;
9088 r[0].r_addend = dest;
9089 }
9090 p = build_plt_stub (htab->stub_bfd, loc, off, r);
9091 size = p - loc;
9092 break;
9093
9094 default:
9095 BFD_FAIL ();
9096 return FALSE;
9097 }
9098
9099 stub_entry->stub_sec->size += size;
9100
9101 if (htab->emit_stub_syms)
9102 {
9103 struct elf_link_hash_entry *h;
9104 size_t len1, len2;
9105 char *name;
9106 const char *const stub_str[] = { "long_branch",
9107 "long_branch_r2off",
9108 "plt_branch",
9109 "plt_branch_r2off",
9110 "plt_call" };
9111
9112 len1 = strlen (stub_str[stub_entry->stub_type - 1]);
9113 len2 = strlen (stub_entry->root.string);
9114 name = bfd_malloc (len1 + len2 + 2);
9115 if (name == NULL)
9116 return FALSE;
9117 memcpy (name, stub_entry->root.string, 9);
9118 memcpy (name + 9, stub_str[stub_entry->stub_type - 1], len1);
9119 memcpy (name + len1 + 9, stub_entry->root.string + 8, len2 - 8 + 1);
9120 h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
9121 if (h == NULL)
9122 return FALSE;
9123 if (h->root.type == bfd_link_hash_new)
9124 {
9125 h->root.type = bfd_link_hash_defined;
9126 h->root.u.def.section = stub_entry->stub_sec;
9127 h->root.u.def.value = stub_entry->stub_offset;
9128 h->ref_regular = 1;
9129 h->def_regular = 1;
9130 h->ref_regular_nonweak = 1;
9131 h->forced_local = 1;
9132 h->non_elf = 0;
9133 }
9134 }
9135
9136 return TRUE;
9137 }
9138
9139 /* As above, but don't actually build the stub. Just bump offset so
9140 we know stub section sizes, and select plt_branch stubs where
9141 long_branch stubs won't do. */
9142
9143 static bfd_boolean
9144 ppc_size_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
9145 {
9146 struct ppc_stub_hash_entry *stub_entry;
9147 struct bfd_link_info *info;
9148 struct ppc_link_hash_table *htab;
9149 bfd_vma off;
9150 int size;
9151
9152 /* Massage our args to the form they really have. */
9153 stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
9154 info = in_arg;
9155
9156 htab = ppc_hash_table (info);
9157
9158 if (stub_entry->stub_type == ppc_stub_plt_call)
9159 {
9160 asection *plt;
9161 off = stub_entry->plt_ent->plt.offset & ~(bfd_vma) 1;
9162 if (off >= (bfd_vma) -2)
9163 abort ();
9164 plt = htab->plt;
9165 if (!htab->elf.dynamic_sections_created)
9166 plt = htab->iplt;
9167 off += (plt->output_offset
9168 + plt->output_section->vma
9169 - elf_gp (plt->output_section->owner)
9170 - htab->stub_group[stub_entry->id_sec->id].toc_off);
9171
9172 size = PLT_CALL_STUB_SIZE;
9173 if (PPC_HA (off) == 0)
9174 size -= 4;
9175 if (PPC_HA (off + 16) != PPC_HA (off))
9176 size += 4;
9177 if (info->emitrelocations)
9178 {
9179 stub_entry->stub_sec->reloc_count
9180 += 2 + (PPC_HA (off) != 0) + (PPC_HA (off + 16) == PPC_HA (off));
9181 stub_entry->stub_sec->flags |= SEC_RELOC;
9182 }
9183 }
9184 else
9185 {
9186 /* ppc_stub_long_branch or ppc_stub_plt_branch, or their r2off
9187 variants. */
9188 bfd_vma r2off = 0;
9189
9190 off = (stub_entry->target_value
9191 + stub_entry->target_section->output_offset
9192 + stub_entry->target_section->output_section->vma);
9193 off -= (stub_entry->stub_sec->size
9194 + stub_entry->stub_sec->output_offset
9195 + stub_entry->stub_sec->output_section->vma);
9196
9197 /* Reset the stub type from the plt variant in case we now
9198 can reach with a shorter stub. */
9199 if (stub_entry->stub_type >= ppc_stub_plt_branch)
9200 stub_entry->stub_type += ppc_stub_long_branch - ppc_stub_plt_branch;
9201
9202 size = 4;
9203 if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
9204 {
9205 r2off = (htab->stub_group[stub_entry->target_section->id].toc_off
9206 - htab->stub_group[stub_entry->id_sec->id].toc_off);
9207 size = 12;
9208 if (PPC_HA (r2off) != 0)
9209 size = 16;
9210 off -= size - 4;
9211 }
9212
9213 /* If the branch offset if too big, use a ppc_stub_plt_branch. */
9214 if (off + (1 << 25) >= (bfd_vma) (1 << 26))
9215 {
9216 struct ppc_branch_hash_entry *br_entry;
9217
9218 br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
9219 stub_entry->root.string + 9,
9220 TRUE, FALSE);
9221 if (br_entry == NULL)
9222 {
9223 (*_bfd_error_handler) (_("can't build branch stub `%s'"),
9224 stub_entry->root.string);
9225 htab->stub_error = TRUE;
9226 return FALSE;
9227 }
9228
9229 if (br_entry->iter != htab->stub_iteration)
9230 {
9231 br_entry->iter = htab->stub_iteration;
9232 br_entry->offset = htab->brlt->size;
9233 htab->brlt->size += 8;
9234
9235 if (htab->relbrlt != NULL)
9236 htab->relbrlt->size += sizeof (Elf64_External_Rela);
9237 else if (info->emitrelocations)
9238 {
9239 htab->brlt->reloc_count += 1;
9240 htab->brlt->flags |= SEC_RELOC;
9241 }
9242 }
9243
9244 stub_entry->stub_type += ppc_stub_plt_branch - ppc_stub_long_branch;
9245 off = (br_entry->offset
9246 + htab->brlt->output_offset
9247 + htab->brlt->output_section->vma
9248 - elf_gp (htab->brlt->output_section->owner)
9249 - htab->stub_group[stub_entry->id_sec->id].toc_off);
9250
9251 if (info->emitrelocations)
9252 {
9253 stub_entry->stub_sec->reloc_count += 1 + (PPC_HA (off) != 0);
9254 stub_entry->stub_sec->flags |= SEC_RELOC;
9255 }
9256
9257 if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
9258 {
9259 size = 12;
9260 if (PPC_HA (off) != 0)
9261 size = 16;
9262 }
9263 else
9264 {
9265 size = 20;
9266 if (PPC_HA (off) != 0)
9267 size += 4;
9268
9269 if (PPC_HA (r2off) != 0)
9270 size += 4;
9271 }
9272 }
9273 else if (info->emitrelocations)
9274 {
9275 stub_entry->stub_sec->reloc_count += 1;
9276 stub_entry->stub_sec->flags |= SEC_RELOC;
9277 }
9278 }
9279
9280 stub_entry->stub_sec->size += size;
9281 return TRUE;
9282 }
9283
9284 /* Set up various things so that we can make a list of input sections
9285 for each output section included in the link. Returns -1 on error,
9286 0 when no stubs will be needed, and 1 on success. */
9287
9288 int
9289 ppc64_elf_setup_section_lists (bfd *output_bfd,
9290 struct bfd_link_info *info,
9291 int no_multi_toc)
9292 {
9293 bfd *input_bfd;
9294 int top_id, top_index, id;
9295 asection *section;
9296 asection **input_list;
9297 bfd_size_type amt;
9298 struct ppc_link_hash_table *htab = ppc_hash_table (info);
9299
9300 htab->no_multi_toc = no_multi_toc;
9301
9302 if (htab->brlt == NULL)
9303 return 0;
9304
9305 /* Find the top input section id. */
9306 for (input_bfd = info->input_bfds, top_id = 3;
9307 input_bfd != NULL;
9308 input_bfd = input_bfd->link_next)
9309 {
9310 for (section = input_bfd->sections;
9311 section != NULL;
9312 section = section->next)
9313 {
9314 if (top_id < section->id)
9315 top_id = section->id;
9316 }
9317 }
9318
9319 htab->top_id = top_id;
9320 amt = sizeof (struct map_stub) * (top_id + 1);
9321 htab->stub_group = bfd_zmalloc (amt);
9322 if (htab->stub_group == NULL)
9323 return -1;
9324
9325 /* Set toc_off for com, und, abs and ind sections. */
9326 for (id = 0; id < 3; id++)
9327 htab->stub_group[id].toc_off = TOC_BASE_OFF;
9328
9329 elf_gp (output_bfd) = htab->toc_curr = ppc64_elf_toc (output_bfd);
9330
9331 /* We can't use output_bfd->section_count here to find the top output
9332 section index as some sections may have been removed, and
9333 strip_excluded_output_sections doesn't renumber the indices. */
9334 for (section = output_bfd->sections, top_index = 0;
9335 section != NULL;
9336 section = section->next)
9337 {
9338 if (top_index < section->index)
9339 top_index = section->index;
9340 }
9341
9342 htab->top_index = top_index;
9343 amt = sizeof (asection *) * (top_index + 1);
9344 input_list = bfd_zmalloc (amt);
9345 htab->input_list = input_list;
9346 if (input_list == NULL)
9347 return -1;
9348
9349 return 1;
9350 }
9351
9352 /* The linker repeatedly calls this function for each TOC input section
9353 and linker generated GOT section. Group input bfds such that the toc
9354 within a group is less than 64k in size. Will break with cute linker
9355 scripts that play games with dot in the output toc section. */
9356
9357 void
9358 ppc64_elf_next_toc_section (struct bfd_link_info *info, asection *isec)
9359 {
9360 struct ppc_link_hash_table *htab = ppc_hash_table (info);
9361
9362 if (!htab->no_multi_toc)
9363 {
9364 bfd_vma addr = isec->output_offset + isec->output_section->vma;
9365 bfd_vma off = addr - htab->toc_curr;
9366
9367 if (off + isec->size > 0x10000)
9368 htab->toc_curr = addr;
9369
9370 elf_gp (isec->owner) = (htab->toc_curr
9371 - elf_gp (isec->output_section->owner)
9372 + TOC_BASE_OFF);
9373 }
9374 }
9375
9376 /* Called after the last call to the above function. */
9377
9378 void
9379 ppc64_elf_reinit_toc (bfd *output_bfd, struct bfd_link_info *info)
9380 {
9381 struct ppc_link_hash_table *htab = ppc_hash_table (info);
9382
9383 htab->multi_toc_needed = htab->toc_curr != elf_gp (output_bfd);
9384
9385 /* toc_curr tracks the TOC offset used for code sections below in
9386 ppc64_elf_next_input_section. Start off at 0x8000. */
9387 htab->toc_curr = TOC_BASE_OFF;
9388 }
9389
9390 /* No toc references were found in ISEC. If the code in ISEC makes no
9391 calls, then there's no need to use toc adjusting stubs when branching
9392 into ISEC. Actually, indirect calls from ISEC are OK as they will
9393 load r2. Returns -1 on error, 0 for no stub needed, 1 for stub
9394 needed, and 2 if a cyclical call-graph was found but no other reason
9395 for a stub was detected. If called from the top level, a return of
9396 2 means the same as a return of 0. */
9397
9398 static int
9399 toc_adjusting_stub_needed (struct bfd_link_info *info, asection *isec)
9400 {
9401 Elf_Internal_Rela *relstart, *rel;
9402 Elf_Internal_Sym *local_syms;
9403 int ret;
9404 struct ppc_link_hash_table *htab;
9405
9406 /* We know none of our code bearing sections will need toc stubs. */
9407 if ((isec->flags & SEC_LINKER_CREATED) != 0)
9408 return 0;
9409
9410 if (isec->size == 0)
9411 return 0;
9412
9413 if (isec->output_section == NULL)
9414 return 0;
9415
9416 if (isec->reloc_count == 0)
9417 return 0;
9418
9419 relstart = _bfd_elf_link_read_relocs (isec->owner, isec, NULL, NULL,
9420 info->keep_memory);
9421 if (relstart == NULL)
9422 return -1;
9423
9424 /* Look for branches to outside of this section. */
9425 local_syms = NULL;
9426 ret = 0;
9427 htab = ppc_hash_table (info);
9428 for (rel = relstart; rel < relstart + isec->reloc_count; ++rel)
9429 {
9430 enum elf_ppc64_reloc_type r_type;
9431 unsigned long r_symndx;
9432 struct elf_link_hash_entry *h;
9433 struct ppc_link_hash_entry *eh;
9434 Elf_Internal_Sym *sym;
9435 asection *sym_sec;
9436 struct _opd_sec_data *opd;
9437 bfd_vma sym_value;
9438 bfd_vma dest;
9439
9440 r_type = ELF64_R_TYPE (rel->r_info);
9441 if (r_type != R_PPC64_REL24
9442 && r_type != R_PPC64_REL14
9443 && r_type != R_PPC64_REL14_BRTAKEN
9444 && r_type != R_PPC64_REL14_BRNTAKEN)
9445 continue;
9446
9447 r_symndx = ELF64_R_SYM (rel->r_info);
9448 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms, r_symndx,
9449 isec->owner))
9450 {
9451 ret = -1;
9452 break;
9453 }
9454
9455 /* Calls to dynamic lib functions go through a plt call stub
9456 that uses r2. */
9457 eh = (struct ppc_link_hash_entry *) h;
9458 if (eh != NULL
9459 && (eh->elf.plt.plist != NULL
9460 || (eh->oh != NULL
9461 && eh->oh->elf.plt.plist != NULL)))
9462 {
9463 ret = 1;
9464 break;
9465 }
9466
9467 if (sym_sec == NULL)
9468 /* Ignore other undefined symbols. */
9469 continue;
9470
9471 /* Assume branches to other sections not included in the link need
9472 stubs too, to cover -R and absolute syms. */
9473 if (sym_sec->output_section == NULL)
9474 {
9475 ret = 1;
9476 break;
9477 }
9478
9479 if (h == NULL)
9480 sym_value = sym->st_value;
9481 else
9482 {
9483 if (h->root.type != bfd_link_hash_defined
9484 && h->root.type != bfd_link_hash_defweak)
9485 abort ();
9486 sym_value = h->root.u.def.value;
9487 }
9488 sym_value += rel->r_addend;
9489
9490 /* If this branch reloc uses an opd sym, find the code section. */
9491 opd = get_opd_info (sym_sec);
9492 if (opd != NULL)
9493 {
9494 if (h == NULL && opd->adjust != NULL)
9495 {
9496 long adjust;
9497
9498 adjust = opd->adjust[sym->st_value / 8];
9499 if (adjust == -1)
9500 /* Assume deleted functions won't ever be called. */
9501 continue;
9502 sym_value += adjust;
9503 }
9504
9505 dest = opd_entry_value (sym_sec, sym_value, &sym_sec, NULL);
9506 if (dest == (bfd_vma) -1)
9507 continue;
9508 }
9509 else
9510 dest = (sym_value
9511 + sym_sec->output_offset
9512 + sym_sec->output_section->vma);
9513
9514 /* Ignore branch to self. */
9515 if (sym_sec == isec)
9516 continue;
9517
9518 /* If the called function uses the toc, we need a stub. */
9519 if (sym_sec->has_toc_reloc
9520 || sym_sec->makes_toc_func_call)
9521 {
9522 ret = 1;
9523 break;
9524 }
9525
9526 /* Assume any branch that needs a long branch stub might in fact
9527 need a plt_branch stub. A plt_branch stub uses r2. */
9528 else if (dest - (isec->output_offset
9529 + isec->output_section->vma
9530 + rel->r_offset) + (1 << 25) >= (2 << 25))
9531 {
9532 ret = 1;
9533 break;
9534 }
9535
9536 /* If calling back to a section in the process of being tested, we
9537 can't say for sure that no toc adjusting stubs are needed, so
9538 don't return zero. */
9539 else if (sym_sec->call_check_in_progress)
9540 ret = 2;
9541
9542 /* Branches to another section that itself doesn't have any TOC
9543 references are OK. Recursively call ourselves to check. */
9544 else if (sym_sec->id <= htab->top_id
9545 && htab->stub_group[sym_sec->id].toc_off == 0)
9546 {
9547 int recur;
9548
9549 /* Mark current section as indeterminate, so that other
9550 sections that call back to current won't be marked as
9551 known. */
9552 isec->call_check_in_progress = 1;
9553 recur = toc_adjusting_stub_needed (info, sym_sec);
9554 isec->call_check_in_progress = 0;
9555
9556 if (recur < 0)
9557 {
9558 /* An error. Exit. */
9559 ret = -1;
9560 break;
9561 }
9562 else if (recur <= 1)
9563 {
9564 /* Known result. Mark as checked and set section flag. */
9565 htab->stub_group[sym_sec->id].toc_off = 1;
9566 if (recur != 0)
9567 {
9568 sym_sec->makes_toc_func_call = 1;
9569 ret = 1;
9570 break;
9571 }
9572 }
9573 else
9574 {
9575 /* Unknown result. Continue checking. */
9576 ret = 2;
9577 }
9578 }
9579 }
9580
9581 if (local_syms != NULL
9582 && (elf_symtab_hdr (isec->owner).contents != (unsigned char *) local_syms))
9583 free (local_syms);
9584 if (elf_section_data (isec)->relocs != relstart)
9585 free (relstart);
9586
9587 return ret;
9588 }
9589
9590 /* The linker repeatedly calls this function for each input section,
9591 in the order that input sections are linked into output sections.
9592 Build lists of input sections to determine groupings between which
9593 we may insert linker stubs. */
9594
9595 bfd_boolean
9596 ppc64_elf_next_input_section (struct bfd_link_info *info, asection *isec)
9597 {
9598 struct ppc_link_hash_table *htab = ppc_hash_table (info);
9599
9600 if ((isec->output_section->flags & SEC_CODE) != 0
9601 && isec->output_section->index <= htab->top_index)
9602 {
9603 asection **list = htab->input_list + isec->output_section->index;
9604 /* Steal the link_sec pointer for our list. */
9605 #define PREV_SEC(sec) (htab->stub_group[(sec)->id].link_sec)
9606 /* This happens to make the list in reverse order,
9607 which is what we want. */
9608 PREV_SEC (isec) = *list;
9609 *list = isec;
9610 }
9611
9612 if (htab->multi_toc_needed)
9613 {
9614 /* If a code section has a function that uses the TOC then we need
9615 to use the right TOC (obviously). Also, make sure that .opd gets
9616 the correct TOC value for R_PPC64_TOC relocs that don't have or
9617 can't find their function symbol (shouldn't ever happen now).
9618 Also specially treat .fixup for the linux kernel. .fixup
9619 contains branches, but only back to the function that hit an
9620 exception. */
9621 if (isec->has_toc_reloc
9622 || (isec->flags & SEC_CODE) == 0
9623 || strcmp (isec->name, ".fixup") == 0)
9624 {
9625 if (elf_gp (isec->owner) != 0)
9626 htab->toc_curr = elf_gp (isec->owner);
9627 }
9628 else if (htab->stub_group[isec->id].toc_off == 0)
9629 {
9630 int ret = toc_adjusting_stub_needed (info, isec);
9631 if (ret < 0)
9632 return FALSE;
9633 else
9634 isec->makes_toc_func_call = ret & 1;
9635 }
9636 }
9637
9638 /* Functions that don't use the TOC can belong in any TOC group.
9639 Use the last TOC base. This happens to make _init and _fini
9640 pasting work. */
9641 htab->stub_group[isec->id].toc_off = htab->toc_curr;
9642 return TRUE;
9643 }
9644
9645 /* See whether we can group stub sections together. Grouping stub
9646 sections may result in fewer stubs. More importantly, we need to
9647 put all .init* and .fini* stubs at the beginning of the .init or
9648 .fini output sections respectively, because glibc splits the
9649 _init and _fini functions into multiple parts. Putting a stub in
9650 the middle of a function is not a good idea. */
9651
9652 static void
9653 group_sections (struct ppc_link_hash_table *htab,
9654 bfd_size_type stub_group_size,
9655 bfd_boolean stubs_always_before_branch)
9656 {
9657 asection **list;
9658 bfd_size_type stub14_group_size;
9659 bfd_boolean suppress_size_errors;
9660
9661 suppress_size_errors = FALSE;
9662 stub14_group_size = stub_group_size;
9663 if (stub_group_size == 1)
9664 {
9665 /* Default values. */
9666 if (stubs_always_before_branch)
9667 {
9668 stub_group_size = 0x1e00000;
9669 stub14_group_size = 0x7800;
9670 }
9671 else
9672 {
9673 stub_group_size = 0x1c00000;
9674 stub14_group_size = 0x7000;
9675 }
9676 suppress_size_errors = TRUE;
9677 }
9678
9679 list = htab->input_list + htab->top_index;
9680 do
9681 {
9682 asection *tail = *list;
9683 while (tail != NULL)
9684 {
9685 asection *curr;
9686 asection *prev;
9687 bfd_size_type total;
9688 bfd_boolean big_sec;
9689 bfd_vma curr_toc;
9690
9691 curr = tail;
9692 total = tail->size;
9693 big_sec = total > (ppc64_elf_section_data (tail)->has_14bit_branch
9694 ? stub14_group_size : stub_group_size);
9695 if (big_sec && !suppress_size_errors)
9696 (*_bfd_error_handler) (_("%B section %A exceeds stub group size"),
9697 tail->owner, tail);
9698 curr_toc = htab->stub_group[tail->id].toc_off;
9699
9700 while ((prev = PREV_SEC (curr)) != NULL
9701 && ((total += curr->output_offset - prev->output_offset)
9702 < (ppc64_elf_section_data (prev)->has_14bit_branch
9703 ? stub14_group_size : stub_group_size))
9704 && htab->stub_group[prev->id].toc_off == curr_toc)
9705 curr = prev;
9706
9707 /* OK, the size from the start of CURR to the end is less
9708 than stub_group_size and thus can be handled by one stub
9709 section. (or the tail section is itself larger than
9710 stub_group_size, in which case we may be toast.) We
9711 should really be keeping track of the total size of stubs
9712 added here, as stubs contribute to the final output
9713 section size. That's a little tricky, and this way will
9714 only break if stubs added make the total size more than
9715 2^25, ie. for the default stub_group_size, if stubs total
9716 more than 2097152 bytes, or nearly 75000 plt call stubs. */
9717 do
9718 {
9719 prev = PREV_SEC (tail);
9720 /* Set up this stub group. */
9721 htab->stub_group[tail->id].link_sec = curr;
9722 }
9723 while (tail != curr && (tail = prev) != NULL);
9724
9725 /* But wait, there's more! Input sections up to stub_group_size
9726 bytes before the stub section can be handled by it too.
9727 Don't do this if we have a really large section after the
9728 stubs, as adding more stubs increases the chance that
9729 branches may not reach into the stub section. */
9730 if (!stubs_always_before_branch && !big_sec)
9731 {
9732 total = 0;
9733 while (prev != NULL
9734 && ((total += tail->output_offset - prev->output_offset)
9735 < (ppc64_elf_section_data (prev)->has_14bit_branch
9736 ? stub14_group_size : stub_group_size))
9737 && htab->stub_group[prev->id].toc_off == curr_toc)
9738 {
9739 tail = prev;
9740 prev = PREV_SEC (tail);
9741 htab->stub_group[tail->id].link_sec = curr;
9742 }
9743 }
9744 tail = prev;
9745 }
9746 }
9747 while (list-- != htab->input_list);
9748 free (htab->input_list);
9749 #undef PREV_SEC
9750 }
9751
9752 /* Determine and set the size of the stub section for a final link.
9753
9754 The basic idea here is to examine all the relocations looking for
9755 PC-relative calls to a target that is unreachable with a "bl"
9756 instruction. */
9757
9758 bfd_boolean
9759 ppc64_elf_size_stubs (bfd *output_bfd,
9760 struct bfd_link_info *info,
9761 bfd_signed_vma group_size,
9762 asection *(*add_stub_section) (const char *, asection *),
9763 void (*layout_sections_again) (void))
9764 {
9765 bfd_size_type stub_group_size;
9766 bfd_boolean stubs_always_before_branch;
9767 struct ppc_link_hash_table *htab = ppc_hash_table (info);
9768
9769 /* Stash our params away. */
9770 htab->add_stub_section = add_stub_section;
9771 htab->layout_sections_again = layout_sections_again;
9772 stubs_always_before_branch = group_size < 0;
9773 if (group_size < 0)
9774 stub_group_size = -group_size;
9775 else
9776 stub_group_size = group_size;
9777
9778 group_sections (htab, stub_group_size, stubs_always_before_branch);
9779
9780 while (1)
9781 {
9782 bfd *input_bfd;
9783 unsigned int bfd_indx;
9784 asection *stub_sec;
9785
9786 htab->stub_iteration += 1;
9787
9788 for (input_bfd = info->input_bfds, bfd_indx = 0;
9789 input_bfd != NULL;
9790 input_bfd = input_bfd->link_next, bfd_indx++)
9791 {
9792 Elf_Internal_Shdr *symtab_hdr;
9793 asection *section;
9794 Elf_Internal_Sym *local_syms = NULL;
9795
9796 if (!is_ppc64_elf (input_bfd))
9797 continue;
9798
9799 /* We'll need the symbol table in a second. */
9800 symtab_hdr = &elf_symtab_hdr (input_bfd);
9801 if (symtab_hdr->sh_info == 0)
9802 continue;
9803
9804 /* Walk over each section attached to the input bfd. */
9805 for (section = input_bfd->sections;
9806 section != NULL;
9807 section = section->next)
9808 {
9809 Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
9810
9811 /* If there aren't any relocs, then there's nothing more
9812 to do. */
9813 if ((section->flags & SEC_RELOC) == 0
9814 || (section->flags & SEC_ALLOC) == 0
9815 || (section->flags & SEC_LOAD) == 0
9816 || (section->flags & SEC_CODE) == 0
9817 || section->reloc_count == 0)
9818 continue;
9819
9820 /* If this section is a link-once section that will be
9821 discarded, then don't create any stubs. */
9822 if (section->output_section == NULL
9823 || section->output_section->owner != output_bfd)
9824 continue;
9825
9826 /* Get the relocs. */
9827 internal_relocs
9828 = _bfd_elf_link_read_relocs (input_bfd, section, NULL, NULL,
9829 info->keep_memory);
9830 if (internal_relocs == NULL)
9831 goto error_ret_free_local;
9832
9833 /* Now examine each relocation. */
9834 irela = internal_relocs;
9835 irelaend = irela + section->reloc_count;
9836 for (; irela < irelaend; irela++)
9837 {
9838 enum elf_ppc64_reloc_type r_type;
9839 unsigned int r_indx;
9840 enum ppc_stub_type stub_type;
9841 struct ppc_stub_hash_entry *stub_entry;
9842 asection *sym_sec, *code_sec;
9843 bfd_vma sym_value, code_value;
9844 bfd_vma destination;
9845 bfd_boolean ok_dest;
9846 struct ppc_link_hash_entry *hash;
9847 struct ppc_link_hash_entry *fdh;
9848 struct elf_link_hash_entry *h;
9849 Elf_Internal_Sym *sym;
9850 char *stub_name;
9851 const asection *id_sec;
9852 struct _opd_sec_data *opd;
9853 struct plt_entry *plt_ent;
9854
9855 r_type = ELF64_R_TYPE (irela->r_info);
9856 r_indx = ELF64_R_SYM (irela->r_info);
9857
9858 if (r_type >= R_PPC64_max)
9859 {
9860 bfd_set_error (bfd_error_bad_value);
9861 goto error_ret_free_internal;
9862 }
9863
9864 /* Only look for stubs on branch instructions. */
9865 if (r_type != R_PPC64_REL24
9866 && r_type != R_PPC64_REL14
9867 && r_type != R_PPC64_REL14_BRTAKEN
9868 && r_type != R_PPC64_REL14_BRNTAKEN)
9869 continue;
9870
9871 /* Now determine the call target, its name, value,
9872 section. */
9873 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9874 r_indx, input_bfd))
9875 goto error_ret_free_internal;
9876 hash = (struct ppc_link_hash_entry *) h;
9877
9878 ok_dest = FALSE;
9879 fdh = NULL;
9880 sym_value = 0;
9881 if (hash == NULL)
9882 {
9883 sym_value = sym->st_value;
9884 ok_dest = TRUE;
9885 }
9886 else if (hash->elf.root.type == bfd_link_hash_defined
9887 || hash->elf.root.type == bfd_link_hash_defweak)
9888 {
9889 sym_value = hash->elf.root.u.def.value;
9890 if (sym_sec->output_section != NULL)
9891 ok_dest = TRUE;
9892 }
9893 else if (hash->elf.root.type == bfd_link_hash_undefweak
9894 || hash->elf.root.type == bfd_link_hash_undefined)
9895 {
9896 /* Recognise an old ABI func code entry sym, and
9897 use the func descriptor sym instead if it is
9898 defined. */
9899 if (hash->elf.root.root.string[0] == '.'
9900 && (fdh = get_fdh (hash, htab)) != NULL)
9901 {
9902 if (fdh->elf.root.type == bfd_link_hash_defined
9903 || fdh->elf.root.type == bfd_link_hash_defweak)
9904 {
9905 sym_sec = fdh->elf.root.u.def.section;
9906 sym_value = fdh->elf.root.u.def.value;
9907 if (sym_sec->output_section != NULL)
9908 ok_dest = TRUE;
9909 }
9910 else
9911 fdh = NULL;
9912 }
9913 }
9914 else
9915 {
9916 bfd_set_error (bfd_error_bad_value);
9917 goto error_ret_free_internal;
9918 }
9919
9920 destination = 0;
9921 if (ok_dest)
9922 {
9923 sym_value += irela->r_addend;
9924 destination = (sym_value
9925 + sym_sec->output_offset
9926 + sym_sec->output_section->vma);
9927 }
9928
9929 code_sec = sym_sec;
9930 code_value = sym_value;
9931 opd = get_opd_info (sym_sec);
9932 if (opd != NULL)
9933 {
9934 bfd_vma dest;
9935
9936 if (hash == NULL && opd->adjust != NULL)
9937 {
9938 long adjust = opd->adjust[sym_value / 8];
9939 if (adjust == -1)
9940 continue;
9941 code_value += adjust;
9942 sym_value += adjust;
9943 }
9944 dest = opd_entry_value (sym_sec, sym_value,
9945 &code_sec, &code_value);
9946 if (dest != (bfd_vma) -1)
9947 {
9948 destination = dest;
9949 if (fdh != NULL)
9950 {
9951 /* Fixup old ABI sym to point at code
9952 entry. */
9953 hash->elf.root.type = bfd_link_hash_defweak;
9954 hash->elf.root.u.def.section = code_sec;
9955 hash->elf.root.u.def.value = code_value;
9956 }
9957 }
9958 }
9959
9960 /* Determine what (if any) linker stub is needed. */
9961 plt_ent = NULL;
9962 stub_type = ppc_type_of_stub (section, irela, &hash,
9963 &plt_ent, destination);
9964
9965 if (stub_type != ppc_stub_plt_call)
9966 {
9967 /* Check whether we need a TOC adjusting stub.
9968 Since the linker pastes together pieces from
9969 different object files when creating the
9970 _init and _fini functions, it may be that a
9971 call to what looks like a local sym is in
9972 fact a call needing a TOC adjustment. */
9973 if (code_sec != NULL
9974 && code_sec->output_section != NULL
9975 && (htab->stub_group[code_sec->id].toc_off
9976 != htab->stub_group[section->id].toc_off)
9977 && (code_sec->has_toc_reloc
9978 || code_sec->makes_toc_func_call))
9979 stub_type = ppc_stub_long_branch_r2off;
9980 }
9981
9982 if (stub_type == ppc_stub_none)
9983 continue;
9984
9985 /* __tls_get_addr calls might be eliminated. */
9986 if (stub_type != ppc_stub_plt_call
9987 && hash != NULL
9988 && (hash == htab->tls_get_addr
9989 || hash == htab->tls_get_addr_fd)
9990 && section->has_tls_reloc
9991 && irela != internal_relocs)
9992 {
9993 /* Get tls info. */
9994 char *tls_mask;
9995
9996 if (!get_tls_mask (&tls_mask, NULL, NULL, &local_syms,
9997 irela - 1, input_bfd))
9998 goto error_ret_free_internal;
9999 if (*tls_mask != 0)
10000 continue;
10001 }
10002
10003 /* Support for grouping stub sections. */
10004 id_sec = htab->stub_group[section->id].link_sec;
10005
10006 /* Get the name of this stub. */
10007 stub_name = ppc_stub_name (id_sec, sym_sec, hash, irela);
10008 if (!stub_name)
10009 goto error_ret_free_internal;
10010
10011 stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
10012 stub_name, FALSE, FALSE);
10013 if (stub_entry != NULL)
10014 {
10015 /* The proper stub has already been created. */
10016 free (stub_name);
10017 continue;
10018 }
10019
10020 stub_entry = ppc_add_stub (stub_name, section, htab);
10021 if (stub_entry == NULL)
10022 {
10023 free (stub_name);
10024 error_ret_free_internal:
10025 if (elf_section_data (section)->relocs == NULL)
10026 free (internal_relocs);
10027 error_ret_free_local:
10028 if (local_syms != NULL
10029 && (symtab_hdr->contents
10030 != (unsigned char *) local_syms))
10031 free (local_syms);
10032 return FALSE;
10033 }
10034
10035 stub_entry->stub_type = stub_type;
10036 if (stub_type != ppc_stub_plt_call)
10037 {
10038 stub_entry->target_value = code_value;
10039 stub_entry->target_section = code_sec;
10040 }
10041 else
10042 {
10043 stub_entry->target_value = sym_value;
10044 stub_entry->target_section = sym_sec;
10045 }
10046 stub_entry->h = hash;
10047 stub_entry->plt_ent = plt_ent;
10048 stub_entry->addend = irela->r_addend;
10049
10050 if (stub_entry->h != NULL)
10051 htab->stub_globals += 1;
10052 }
10053
10054 /* We're done with the internal relocs, free them. */
10055 if (elf_section_data (section)->relocs != internal_relocs)
10056 free (internal_relocs);
10057 }
10058
10059 if (local_syms != NULL
10060 && symtab_hdr->contents != (unsigned char *) local_syms)
10061 {
10062 if (!info->keep_memory)
10063 free (local_syms);
10064 else
10065 symtab_hdr->contents = (unsigned char *) local_syms;
10066 }
10067 }
10068
10069 /* We may have added some stubs. Find out the new size of the
10070 stub sections. */
10071 for (stub_sec = htab->stub_bfd->sections;
10072 stub_sec != NULL;
10073 stub_sec = stub_sec->next)
10074 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
10075 {
10076 stub_sec->rawsize = stub_sec->size;
10077 stub_sec->size = 0;
10078 stub_sec->reloc_count = 0;
10079 stub_sec->flags &= ~SEC_RELOC;
10080 }
10081
10082 htab->brlt->size = 0;
10083 htab->brlt->reloc_count = 0;
10084 htab->brlt->flags &= ~SEC_RELOC;
10085 if (htab->relbrlt != NULL)
10086 htab->relbrlt->size = 0;
10087
10088 bfd_hash_traverse (&htab->stub_hash_table, ppc_size_one_stub, info);
10089
10090 if (info->emitrelocations
10091 && htab->glink != NULL && htab->glink->size != 0)
10092 {
10093 htab->glink->reloc_count = 1;
10094 htab->glink->flags |= SEC_RELOC;
10095 }
10096
10097 for (stub_sec = htab->stub_bfd->sections;
10098 stub_sec != NULL;
10099 stub_sec = stub_sec->next)
10100 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
10101 && stub_sec->rawsize != stub_sec->size)
10102 break;
10103
10104 /* Exit from this loop when no stubs have been added, and no stubs
10105 have changed size. */
10106 if (stub_sec == NULL)
10107 break;
10108
10109 /* Ask the linker to do its stuff. */
10110 (*htab->layout_sections_again) ();
10111 }
10112
10113 /* It would be nice to strip htab->brlt from the output if the
10114 section is empty, but it's too late. If we strip sections here,
10115 the dynamic symbol table is corrupted since the section symbol
10116 for the stripped section isn't written. */
10117
10118 return TRUE;
10119 }
10120
10121 /* Called after we have determined section placement. If sections
10122 move, we'll be called again. Provide a value for TOCstart. */
10123
10124 bfd_vma
10125 ppc64_elf_toc (bfd *obfd)
10126 {
10127 asection *s;
10128 bfd_vma TOCstart;
10129
10130 /* The TOC consists of sections .got, .toc, .tocbss, .plt in that
10131 order. The TOC starts where the first of these sections starts. */
10132 s = bfd_get_section_by_name (obfd, ".got");
10133 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
10134 s = bfd_get_section_by_name (obfd, ".toc");
10135 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
10136 s = bfd_get_section_by_name (obfd, ".tocbss");
10137 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
10138 s = bfd_get_section_by_name (obfd, ".plt");
10139 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
10140 {
10141 /* This may happen for
10142 o references to TOC base (SYM@toc / TOC[tc0]) without a
10143 .toc directive
10144 o bad linker script
10145 o --gc-sections and empty TOC sections
10146
10147 FIXME: Warn user? */
10148
10149 /* Look for a likely section. We probably won't even be
10150 using TOCstart. */
10151 for (s = obfd->sections; s != NULL; s = s->next)
10152 if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_READONLY
10153 | SEC_EXCLUDE))
10154 == (SEC_ALLOC | SEC_SMALL_DATA))
10155 break;
10156 if (s == NULL)
10157 for (s = obfd->sections; s != NULL; s = s->next)
10158 if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_EXCLUDE))
10159 == (SEC_ALLOC | SEC_SMALL_DATA))
10160 break;
10161 if (s == NULL)
10162 for (s = obfd->sections; s != NULL; s = s->next)
10163 if ((s->flags & (SEC_ALLOC | SEC_READONLY | SEC_EXCLUDE))
10164 == SEC_ALLOC)
10165 break;
10166 if (s == NULL)
10167 for (s = obfd->sections; s != NULL; s = s->next)
10168 if ((s->flags & (SEC_ALLOC | SEC_EXCLUDE)) == SEC_ALLOC)
10169 break;
10170 }
10171
10172 TOCstart = 0;
10173 if (s != NULL)
10174 TOCstart = s->output_section->vma + s->output_offset;
10175
10176 return TOCstart;
10177 }
10178
10179 /* Build all the stubs associated with the current output file.
10180 The stubs are kept in a hash table attached to the main linker
10181 hash table. This function is called via gldelf64ppc_finish. */
10182
10183 bfd_boolean
10184 ppc64_elf_build_stubs (bfd_boolean emit_stub_syms,
10185 struct bfd_link_info *info,
10186 char **stats)
10187 {
10188 struct ppc_link_hash_table *htab = ppc_hash_table (info);
10189 asection *stub_sec;
10190 bfd_byte *p;
10191 int stub_sec_count = 0;
10192
10193 htab->emit_stub_syms = emit_stub_syms;
10194
10195 /* Allocate memory to hold the linker stubs. */
10196 for (stub_sec = htab->stub_bfd->sections;
10197 stub_sec != NULL;
10198 stub_sec = stub_sec->next)
10199 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
10200 && stub_sec->size != 0)
10201 {
10202 stub_sec->contents = bfd_zalloc (htab->stub_bfd, stub_sec->size);
10203 if (stub_sec->contents == NULL)
10204 return FALSE;
10205 /* We want to check that built size is the same as calculated
10206 size. rawsize is a convenient location to use. */
10207 stub_sec->rawsize = stub_sec->size;
10208 stub_sec->size = 0;
10209 }
10210
10211 if (htab->glink != NULL && htab->glink->size != 0)
10212 {
10213 unsigned int indx;
10214 bfd_vma plt0;
10215
10216 /* Build the .glink plt call stub. */
10217 if (htab->emit_stub_syms)
10218 {
10219 struct elf_link_hash_entry *h;
10220 h = elf_link_hash_lookup (&htab->elf, "__glink_PLTresolve",
10221 TRUE, FALSE, FALSE);
10222 if (h == NULL)
10223 return FALSE;
10224 if (h->root.type == bfd_link_hash_new)
10225 {
10226 h->root.type = bfd_link_hash_defined;
10227 h->root.u.def.section = htab->glink;
10228 h->root.u.def.value = 8;
10229 h->ref_regular = 1;
10230 h->def_regular = 1;
10231 h->ref_regular_nonweak = 1;
10232 h->forced_local = 1;
10233 h->non_elf = 0;
10234 }
10235 }
10236 plt0 = htab->plt->output_section->vma + htab->plt->output_offset - 16;
10237 if (info->emitrelocations)
10238 {
10239 Elf_Internal_Rela *r = get_relocs (htab->glink, 1);
10240 if (r == NULL)
10241 return FALSE;
10242 r->r_offset = (htab->glink->output_offset
10243 + htab->glink->output_section->vma);
10244 r->r_info = ELF64_R_INFO (0, R_PPC64_REL64);
10245 r->r_addend = plt0;
10246 }
10247 p = htab->glink->contents;
10248 plt0 -= htab->glink->output_section->vma + htab->glink->output_offset;
10249 bfd_put_64 (htab->glink->owner, plt0, p);
10250 p += 8;
10251 bfd_put_32 (htab->glink->owner, MFLR_R12, p);
10252 p += 4;
10253 bfd_put_32 (htab->glink->owner, BCL_20_31, p);
10254 p += 4;
10255 bfd_put_32 (htab->glink->owner, MFLR_R11, p);
10256 p += 4;
10257 bfd_put_32 (htab->glink->owner, LD_R2_M16R11, p);
10258 p += 4;
10259 bfd_put_32 (htab->glink->owner, MTLR_R12, p);
10260 p += 4;
10261 bfd_put_32 (htab->glink->owner, ADD_R12_R2_R11, p);
10262 p += 4;
10263 bfd_put_32 (htab->glink->owner, LD_R11_0R12, p);
10264 p += 4;
10265 bfd_put_32 (htab->glink->owner, LD_R2_0R12 | 8, p);
10266 p += 4;
10267 bfd_put_32 (htab->glink->owner, MTCTR_R11, p);
10268 p += 4;
10269 bfd_put_32 (htab->glink->owner, LD_R11_0R12 | 16, p);
10270 p += 4;
10271 bfd_put_32 (htab->glink->owner, BCTR, p);
10272 p += 4;
10273 while (p - htab->glink->contents < GLINK_CALL_STUB_SIZE)
10274 {
10275 bfd_put_32 (htab->glink->owner, NOP, p);
10276 p += 4;
10277 }
10278
10279 /* Build the .glink lazy link call stubs. */
10280 indx = 0;
10281 while (p < htab->glink->contents + htab->glink->size)
10282 {
10283 if (indx < 0x8000)
10284 {
10285 bfd_put_32 (htab->glink->owner, LI_R0_0 | indx, p);
10286 p += 4;
10287 }
10288 else
10289 {
10290 bfd_put_32 (htab->glink->owner, LIS_R0_0 | PPC_HI (indx), p);
10291 p += 4;
10292 bfd_put_32 (htab->glink->owner, ORI_R0_R0_0 | PPC_LO (indx), p);
10293 p += 4;
10294 }
10295 bfd_put_32 (htab->glink->owner,
10296 B_DOT | ((htab->glink->contents - p + 8) & 0x3fffffc), p);
10297 indx++;
10298 p += 4;
10299 }
10300 htab->glink->rawsize = p - htab->glink->contents;
10301 }
10302
10303 if (htab->brlt->size != 0)
10304 {
10305 htab->brlt->contents = bfd_zalloc (htab->brlt->owner,
10306 htab->brlt->size);
10307 if (htab->brlt->contents == NULL)
10308 return FALSE;
10309 }
10310 if (htab->relbrlt != NULL && htab->relbrlt->size != 0)
10311 {
10312 htab->relbrlt->contents = bfd_zalloc (htab->relbrlt->owner,
10313 htab->relbrlt->size);
10314 if (htab->relbrlt->contents == NULL)
10315 return FALSE;
10316 }
10317
10318 /* Build the stubs as directed by the stub hash table. */
10319 bfd_hash_traverse (&htab->stub_hash_table, ppc_build_one_stub, info);
10320
10321 if (htab->relbrlt != NULL)
10322 htab->relbrlt->reloc_count = 0;
10323
10324 for (stub_sec = htab->stub_bfd->sections;
10325 stub_sec != NULL;
10326 stub_sec = stub_sec->next)
10327 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
10328 {
10329 stub_sec_count += 1;
10330 if (stub_sec->rawsize != stub_sec->size)
10331 break;
10332 }
10333
10334 if (stub_sec != NULL
10335 || htab->glink->rawsize != htab->glink->size)
10336 {
10337 htab->stub_error = TRUE;
10338 (*_bfd_error_handler) (_("stubs don't match calculated size"));
10339 }
10340
10341 if (htab->stub_error)
10342 return FALSE;
10343
10344 if (stats != NULL)
10345 {
10346 *stats = bfd_malloc (500);
10347 if (*stats == NULL)
10348 return FALSE;
10349
10350 sprintf (*stats, _("linker stubs in %u group%s\n"
10351 " branch %lu\n"
10352 " toc adjust %lu\n"
10353 " long branch %lu\n"
10354 " long toc adj %lu\n"
10355 " plt call %lu"),
10356 stub_sec_count,
10357 stub_sec_count == 1 ? "" : "s",
10358 htab->stub_count[ppc_stub_long_branch - 1],
10359 htab->stub_count[ppc_stub_long_branch_r2off - 1],
10360 htab->stub_count[ppc_stub_plt_branch - 1],
10361 htab->stub_count[ppc_stub_plt_branch_r2off - 1],
10362 htab->stub_count[ppc_stub_plt_call - 1]);
10363 }
10364 return TRUE;
10365 }
10366
10367 /* This function undoes the changes made by add_symbol_adjust. */
10368
10369 static bfd_boolean
10370 undo_symbol_twiddle (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
10371 {
10372 struct ppc_link_hash_entry *eh;
10373
10374 if (h->root.type == bfd_link_hash_indirect)
10375 return TRUE;
10376
10377 if (h->root.type == bfd_link_hash_warning)
10378 h = (struct elf_link_hash_entry *) h->root.u.i.link;
10379
10380 eh = (struct ppc_link_hash_entry *) h;
10381 if (eh->elf.root.type != bfd_link_hash_undefweak || !eh->was_undefined)
10382 return TRUE;
10383
10384 eh->elf.root.type = bfd_link_hash_undefined;
10385 return TRUE;
10386 }
10387
10388 void
10389 ppc64_elf_restore_symbols (struct bfd_link_info *info)
10390 {
10391 struct ppc_link_hash_table *htab = ppc_hash_table (info);
10392 elf_link_hash_traverse (&htab->elf, undo_symbol_twiddle, info);
10393 }
10394
10395 /* What to do when ld finds relocations against symbols defined in
10396 discarded sections. */
10397
10398 static unsigned int
10399 ppc64_elf_action_discarded (asection *sec)
10400 {
10401 if (strcmp (".opd", sec->name) == 0)
10402 return 0;
10403
10404 if (strcmp (".toc", sec->name) == 0)
10405 return 0;
10406
10407 if (strcmp (".toc1", sec->name) == 0)
10408 return 0;
10409
10410 return _bfd_elf_default_action_discarded (sec);
10411 }
10412
10413 /* The RELOCATE_SECTION function is called by the ELF backend linker
10414 to handle the relocations for a section.
10415
10416 The relocs are always passed as Rela structures; if the section
10417 actually uses Rel structures, the r_addend field will always be
10418 zero.
10419
10420 This function is responsible for adjust the section contents as
10421 necessary, and (if using Rela relocs and generating a
10422 relocatable output file) adjusting the reloc addend as
10423 necessary.
10424
10425 This function does not have to worry about setting the reloc
10426 address or the reloc symbol index.
10427
10428 LOCAL_SYMS is a pointer to the swapped in local symbols.
10429
10430 LOCAL_SECTIONS is an array giving the section in the input file
10431 corresponding to the st_shndx field of each local symbol.
10432
10433 The global hash table entry for the global symbols can be found
10434 via elf_sym_hashes (input_bfd).
10435
10436 When generating relocatable output, this function must handle
10437 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
10438 going to be the section symbol corresponding to the output
10439 section, which means that the addend must be adjusted
10440 accordingly. */
10441
10442 static bfd_boolean
10443 ppc64_elf_relocate_section (bfd *output_bfd,
10444 struct bfd_link_info *info,
10445 bfd *input_bfd,
10446 asection *input_section,
10447 bfd_byte *contents,
10448 Elf_Internal_Rela *relocs,
10449 Elf_Internal_Sym *local_syms,
10450 asection **local_sections)
10451 {
10452 struct ppc_link_hash_table *htab;
10453 Elf_Internal_Shdr *symtab_hdr;
10454 struct elf_link_hash_entry **sym_hashes;
10455 Elf_Internal_Rela *rel;
10456 Elf_Internal_Rela *relend;
10457 Elf_Internal_Rela outrel;
10458 bfd_byte *loc;
10459 struct got_entry **local_got_ents;
10460 bfd_vma TOCstart;
10461 bfd_boolean ret = TRUE;
10462 bfd_boolean is_opd;
10463 /* Disabled until we sort out how ld should choose 'y' vs 'at'. */
10464 bfd_boolean is_power4 = FALSE;
10465 bfd_vma d_offset = (bfd_big_endian (output_bfd) ? 2 : 0);
10466
10467 /* Initialize howto table if needed. */
10468 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
10469 ppc_howto_init ();
10470
10471 htab = ppc_hash_table (info);
10472
10473 /* Don't relocate stub sections. */
10474 if (input_section->owner == htab->stub_bfd)
10475 return TRUE;
10476
10477 BFD_ASSERT (is_ppc64_elf (input_bfd));
10478
10479 local_got_ents = elf_local_got_ents (input_bfd);
10480 TOCstart = elf_gp (output_bfd);
10481 symtab_hdr = &elf_symtab_hdr (input_bfd);
10482 sym_hashes = elf_sym_hashes (input_bfd);
10483 is_opd = ppc64_elf_section_data (input_section)->sec_type == sec_opd;
10484
10485 rel = relocs;
10486 relend = relocs + input_section->reloc_count;
10487 for (; rel < relend; rel++)
10488 {
10489 enum elf_ppc64_reloc_type r_type;
10490 bfd_vma addend, orig_addend;
10491 bfd_reloc_status_type r;
10492 Elf_Internal_Sym *sym;
10493 asection *sec;
10494 struct elf_link_hash_entry *h_elf;
10495 struct ppc_link_hash_entry *h;
10496 struct ppc_link_hash_entry *fdh;
10497 const char *sym_name;
10498 unsigned long r_symndx, toc_symndx;
10499 bfd_vma toc_addend;
10500 char tls_mask, tls_gd, tls_type;
10501 char sym_type;
10502 bfd_vma relocation;
10503 bfd_boolean unresolved_reloc;
10504 bfd_boolean warned;
10505 unsigned long insn, mask;
10506 struct ppc_stub_hash_entry *stub_entry;
10507 bfd_vma max_br_offset;
10508 bfd_vma from;
10509
10510 r_type = ELF64_R_TYPE (rel->r_info);
10511 r_symndx = ELF64_R_SYM (rel->r_info);
10512
10513 /* For old style R_PPC64_TOC relocs with a zero symbol, use the
10514 symbol of the previous ADDR64 reloc. The symbol gives us the
10515 proper TOC base to use. */
10516 if (rel->r_info == ELF64_R_INFO (0, R_PPC64_TOC)
10517 && rel != relocs
10518 && ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_ADDR64
10519 && is_opd)
10520 r_symndx = ELF64_R_SYM (rel[-1].r_info);
10521
10522 sym = NULL;
10523 sec = NULL;
10524 h_elf = NULL;
10525 sym_name = NULL;
10526 unresolved_reloc = FALSE;
10527 warned = FALSE;
10528 orig_addend = rel->r_addend;
10529
10530 if (r_symndx < symtab_hdr->sh_info)
10531 {
10532 /* It's a local symbol. */
10533 struct _opd_sec_data *opd;
10534
10535 sym = local_syms + r_symndx;
10536 sec = local_sections[r_symndx];
10537 sym_name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym, sec);
10538 sym_type = ELF64_ST_TYPE (sym->st_info);
10539 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
10540 opd = get_opd_info (sec);
10541 if (opd != NULL && opd->adjust != NULL)
10542 {
10543 long adjust = opd->adjust[(sym->st_value + rel->r_addend) / 8];
10544 if (adjust == -1)
10545 relocation = 0;
10546 else
10547 {
10548 /* If this is a relocation against the opd section sym
10549 and we have edited .opd, adjust the reloc addend so
10550 that ld -r and ld --emit-relocs output is correct.
10551 If it is a reloc against some other .opd symbol,
10552 then the symbol value will be adjusted later. */
10553 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
10554 rel->r_addend += adjust;
10555 else
10556 relocation += adjust;
10557 }
10558 }
10559 }
10560 else
10561 {
10562 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
10563 r_symndx, symtab_hdr, sym_hashes,
10564 h_elf, sec, relocation,
10565 unresolved_reloc, warned);
10566 sym_name = h_elf->root.root.string;
10567 sym_type = h_elf->type;
10568 }
10569 h = (struct ppc_link_hash_entry *) h_elf;
10570
10571 if (sec != NULL && elf_discarded_section (sec))
10572 {
10573 /* For relocs against symbols from removed linkonce sections,
10574 or sections discarded by a linker script, we just want the
10575 section contents zeroed. Avoid any special processing. */
10576 _bfd_clear_contents (ppc64_elf_howto_table[r_type], input_bfd,
10577 contents + rel->r_offset);
10578 rel->r_info = 0;
10579 rel->r_addend = 0;
10580 continue;
10581 }
10582
10583 if (info->relocatable)
10584 continue;
10585
10586 /* TLS optimizations. Replace instruction sequences and relocs
10587 based on information we collected in tls_optimize. We edit
10588 RELOCS so that --emit-relocs will output something sensible
10589 for the final instruction stream. */
10590 tls_mask = 0;
10591 tls_gd = 0;
10592 toc_symndx = 0;
10593 if (h != NULL)
10594 tls_mask = h->tls_mask;
10595 else if (local_got_ents != NULL)
10596 {
10597 struct plt_entry **local_plt = (struct plt_entry **)
10598 (local_got_ents + symtab_hdr->sh_info);
10599 char *lgot_masks = (char *)
10600 (local_plt + symtab_hdr->sh_info);
10601 tls_mask = lgot_masks[r_symndx];
10602 }
10603 if (tls_mask == 0
10604 && (r_type == R_PPC64_TLS
10605 || r_type == R_PPC64_TLSGD
10606 || r_type == R_PPC64_TLSLD))
10607 {
10608 /* Check for toc tls entries. */
10609 char *toc_tls;
10610
10611 if (!get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
10612 &local_syms, rel, input_bfd))
10613 return FALSE;
10614
10615 if (toc_tls)
10616 tls_mask = *toc_tls;
10617 }
10618
10619 /* Check that tls relocs are used with tls syms, and non-tls
10620 relocs are used with non-tls syms. */
10621 if (r_symndx != 0
10622 && r_type != R_PPC64_NONE
10623 && (h == NULL
10624 || h->elf.root.type == bfd_link_hash_defined
10625 || h->elf.root.type == bfd_link_hash_defweak)
10626 && (IS_PPC64_TLS_RELOC (r_type)
10627 != (sym_type == STT_TLS
10628 || (sym_type == STT_SECTION
10629 && (sec->flags & SEC_THREAD_LOCAL) != 0))))
10630 {
10631 if (tls_mask != 0
10632 && (r_type == R_PPC64_TLS
10633 || r_type == R_PPC64_TLSGD
10634 || r_type == R_PPC64_TLSLD))
10635 /* R_PPC64_TLS is OK against a symbol in the TOC. */
10636 ;
10637 else
10638 (*_bfd_error_handler)
10639 (!IS_PPC64_TLS_RELOC (r_type)
10640 ? _("%B(%A+0x%lx): %s used with TLS symbol %s")
10641 : _("%B(%A+0x%lx): %s used with non-TLS symbol %s"),
10642 input_bfd,
10643 input_section,
10644 (long) rel->r_offset,
10645 ppc64_elf_howto_table[r_type]->name,
10646 sym_name);
10647 }
10648
10649 /* Ensure reloc mapping code below stays sane. */
10650 if (R_PPC64_TOC16_LO_DS != R_PPC64_TOC16_DS + 1
10651 || R_PPC64_TOC16_LO != R_PPC64_TOC16 + 1
10652 || (R_PPC64_GOT_TLSLD16 & 3) != (R_PPC64_GOT_TLSGD16 & 3)
10653 || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TLSGD16_LO & 3)
10654 || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TLSGD16_HI & 3)
10655 || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TLSGD16_HA & 3)
10656 || (R_PPC64_GOT_TLSLD16 & 3) != (R_PPC64_GOT_TPREL16_DS & 3)
10657 || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TPREL16_LO_DS & 3)
10658 || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TPREL16_HI & 3)
10659 || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TPREL16_HA & 3))
10660 abort ();
10661
10662 switch (r_type)
10663 {
10664 default:
10665 break;
10666
10667 case R_PPC64_TOC16:
10668 case R_PPC64_TOC16_LO:
10669 case R_PPC64_TOC16_DS:
10670 case R_PPC64_TOC16_LO_DS:
10671 {
10672 /* Check for toc tls entries. */
10673 char *toc_tls;
10674 int retval;
10675
10676 retval = get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
10677 &local_syms, rel, input_bfd);
10678 if (retval == 0)
10679 return FALSE;
10680
10681 if (toc_tls)
10682 {
10683 tls_mask = *toc_tls;
10684 if (r_type == R_PPC64_TOC16_DS
10685 || r_type == R_PPC64_TOC16_LO_DS)
10686 {
10687 if (tls_mask != 0
10688 && (tls_mask & (TLS_DTPREL | TLS_TPREL)) == 0)
10689 goto toctprel;
10690 }
10691 else
10692 {
10693 /* If we found a GD reloc pair, then we might be
10694 doing a GD->IE transition. */
10695 if (retval == 2)
10696 {
10697 tls_gd = TLS_TPRELGD;
10698 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
10699 goto tls_ldgd_opt;
10700 }
10701 else if (retval == 3)
10702 {
10703 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
10704 goto tls_ldgd_opt;
10705 }
10706 }
10707 }
10708 }
10709 break;
10710
10711 case R_PPC64_GOT_TPREL16_DS:
10712 case R_PPC64_GOT_TPREL16_LO_DS:
10713 if (tls_mask != 0
10714 && (tls_mask & TLS_TPREL) == 0)
10715 {
10716 toctprel:
10717 insn = bfd_get_32 (output_bfd, contents + rel->r_offset - d_offset);
10718 insn &= 31 << 21;
10719 insn |= 0x3c0d0000; /* addis 0,13,0 */
10720 bfd_put_32 (output_bfd, insn, contents + rel->r_offset - d_offset);
10721 r_type = R_PPC64_TPREL16_HA;
10722 if (toc_symndx != 0)
10723 {
10724 rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
10725 rel->r_addend = toc_addend;
10726 /* We changed the symbol. Start over in order to
10727 get h, sym, sec etc. right. */
10728 rel--;
10729 continue;
10730 }
10731 else
10732 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
10733 }
10734 break;
10735
10736 case R_PPC64_TLS:
10737 if (tls_mask != 0
10738 && (tls_mask & TLS_TPREL) == 0)
10739 {
10740 bfd_vma rtra;
10741 insn = bfd_get_32 (output_bfd, contents + rel->r_offset);
10742 if ((insn & ((0x3f << 26) | (31 << 11)))
10743 == ((31 << 26) | (13 << 11)))
10744 rtra = insn & ((1 << 26) - (1 << 16));
10745 else if ((insn & ((0x3f << 26) | (31 << 16)))
10746 == ((31 << 26) | (13 << 16)))
10747 rtra = (insn & (31 << 21)) | ((insn & (31 << 11)) << 5);
10748 else
10749 abort ();
10750 if ((insn & ((1 << 11) - (1 << 1))) == 266 << 1)
10751 /* add -> addi. */
10752 insn = 14 << 26;
10753 else if ((insn & (31 << 1)) == 23 << 1
10754 && ((insn & (31 << 6)) < 14 << 6
10755 || ((insn & (31 << 6)) >= 16 << 6
10756 && (insn & (31 << 6)) < 24 << 6)))
10757 /* load and store indexed -> dform. */
10758 insn = (32 | ((insn >> 6) & 31)) << 26;
10759 else if ((insn & (31 << 1)) == 21 << 1
10760 && (insn & (0x1a << 6)) == 0)
10761 /* ldx, ldux, stdx, stdux -> ld, ldu, std, stdu. */
10762 insn = (((58 | ((insn >> 6) & 4)) << 26)
10763 | ((insn >> 6) & 1));
10764 else if ((insn & (31 << 1)) == 21 << 1
10765 && (insn & ((1 << 11) - (1 << 1))) == 341 << 1)
10766 /* lwax -> lwa. */
10767 insn = (58 << 26) | 2;
10768 else
10769 abort ();
10770 insn |= rtra;
10771 bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
10772 /* Was PPC64_TLS which sits on insn boundary, now
10773 PPC64_TPREL16_LO which is at low-order half-word. */
10774 rel->r_offset += d_offset;
10775 r_type = R_PPC64_TPREL16_LO;
10776 if (toc_symndx != 0)
10777 {
10778 rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
10779 rel->r_addend = toc_addend;
10780 /* We changed the symbol. Start over in order to
10781 get h, sym, sec etc. right. */
10782 rel--;
10783 continue;
10784 }
10785 else
10786 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
10787 }
10788 break;
10789
10790 case R_PPC64_GOT_TLSGD16_HI:
10791 case R_PPC64_GOT_TLSGD16_HA:
10792 tls_gd = TLS_TPRELGD;
10793 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
10794 goto tls_gdld_hi;
10795 break;
10796
10797 case R_PPC64_GOT_TLSLD16_HI:
10798 case R_PPC64_GOT_TLSLD16_HA:
10799 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
10800 {
10801 tls_gdld_hi:
10802 if ((tls_mask & tls_gd) != 0)
10803 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
10804 + R_PPC64_GOT_TPREL16_DS);
10805 else
10806 {
10807 bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
10808 rel->r_offset -= d_offset;
10809 r_type = R_PPC64_NONE;
10810 }
10811 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
10812 }
10813 break;
10814
10815 case R_PPC64_GOT_TLSGD16:
10816 case R_PPC64_GOT_TLSGD16_LO:
10817 tls_gd = TLS_TPRELGD;
10818 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
10819 goto tls_ldgd_opt;
10820 break;
10821
10822 case R_PPC64_GOT_TLSLD16:
10823 case R_PPC64_GOT_TLSLD16_LO:
10824 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
10825 {
10826 unsigned int insn1, insn2, insn3;
10827 bfd_vma offset;
10828
10829 tls_ldgd_opt:
10830 offset = (bfd_vma) -1;
10831 /* If not using the newer R_PPC64_TLSGD/LD to mark
10832 __tls_get_addr calls, we must trust that the call
10833 stays with its arg setup insns, ie. that the next
10834 reloc is the __tls_get_addr call associated with
10835 the current reloc. Edit both insns. */
10836 if (input_section->has_tls_get_addr_call
10837 && rel + 1 < relend
10838 && branch_reloc_hash_match (input_bfd, rel + 1,
10839 htab->tls_get_addr,
10840 htab->tls_get_addr_fd))
10841 offset = rel[1].r_offset;
10842 if ((tls_mask & tls_gd) != 0)
10843 {
10844 /* IE */
10845 insn1 = bfd_get_32 (output_bfd,
10846 contents + rel->r_offset - d_offset);
10847 insn1 &= (1 << 26) - (1 << 2);
10848 insn1 |= 58 << 26; /* ld */
10849 insn2 = 0x7c636a14; /* add 3,3,13 */
10850 if (offset != (bfd_vma) -1)
10851 rel[1].r_info = ELF64_R_INFO (ELF64_R_SYM (rel[1].r_info),
10852 R_PPC64_NONE);
10853 if ((tls_mask & TLS_EXPLICIT) == 0)
10854 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
10855 + R_PPC64_GOT_TPREL16_DS);
10856 else
10857 r_type += R_PPC64_TOC16_DS - R_PPC64_TOC16;
10858 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
10859 }
10860 else
10861 {
10862 /* LE */
10863 insn1 = 0x3c6d0000; /* addis 3,13,0 */
10864 insn2 = 0x38630000; /* addi 3,3,0 */
10865 if (tls_gd == 0)
10866 {
10867 /* Was an LD reloc. */
10868 if (toc_symndx)
10869 sec = local_sections[toc_symndx];
10870 for (r_symndx = 0;
10871 r_symndx < symtab_hdr->sh_info;
10872 r_symndx++)
10873 if (local_sections[r_symndx] == sec)
10874 break;
10875 if (r_symndx >= symtab_hdr->sh_info)
10876 r_symndx = 0;
10877 rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
10878 if (r_symndx != 0)
10879 rel->r_addend -= (local_syms[r_symndx].st_value
10880 + sec->output_offset
10881 + sec->output_section->vma);
10882 }
10883 else if (toc_symndx != 0)
10884 {
10885 r_symndx = toc_symndx;
10886 rel->r_addend = toc_addend;
10887 }
10888 r_type = R_PPC64_TPREL16_HA;
10889 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
10890 if (offset != (bfd_vma) -1)
10891 {
10892 rel[1].r_info = ELF64_R_INFO (r_symndx,
10893 R_PPC64_TPREL16_LO);
10894 rel[1].r_offset = offset + d_offset;
10895 rel[1].r_addend = rel->r_addend;
10896 }
10897 }
10898 bfd_put_32 (output_bfd, insn1,
10899 contents + rel->r_offset - d_offset);
10900 if (offset != (bfd_vma) -1)
10901 {
10902 insn3 = bfd_get_32 (output_bfd,
10903 contents + offset + 4);
10904 if (insn3 == NOP
10905 || insn3 == CROR_151515 || insn3 == CROR_313131)
10906 {
10907 rel[1].r_offset += 4;
10908 bfd_put_32 (output_bfd, insn2, contents + offset + 4);
10909 insn2 = NOP;
10910 }
10911 bfd_put_32 (output_bfd, insn2, contents + offset);
10912 }
10913 if ((tls_mask & tls_gd) == 0
10914 && (tls_gd == 0 || toc_symndx != 0))
10915 {
10916 /* We changed the symbol. Start over in order
10917 to get h, sym, sec etc. right. */
10918 rel--;
10919 continue;
10920 }
10921 }
10922 break;
10923
10924 case R_PPC64_TLSGD:
10925 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
10926 {
10927 unsigned int insn2, insn3;
10928 bfd_vma offset = rel->r_offset;
10929
10930 if ((tls_mask & TLS_TPRELGD) != 0)
10931 {
10932 /* IE */
10933 r_type = R_PPC64_NONE;
10934 insn2 = 0x7c636a14; /* add 3,3,13 */
10935 }
10936 else
10937 {
10938 /* LE */
10939 if (toc_symndx != 0)
10940 {
10941 r_symndx = toc_symndx;
10942 rel->r_addend = toc_addend;
10943 }
10944 r_type = R_PPC64_TPREL16_LO;
10945 rel->r_offset = offset + d_offset;
10946 insn2 = 0x38630000; /* addi 3,3,0 */
10947 }
10948 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
10949 /* Zap the reloc on the _tls_get_addr call too. */
10950 BFD_ASSERT (offset == rel[1].r_offset);
10951 rel[1].r_info = ELF64_R_INFO (ELF64_R_SYM (rel[1].r_info),
10952 R_PPC64_NONE);
10953 insn3 = bfd_get_32 (output_bfd,
10954 contents + offset + 4);
10955 if (insn3 == NOP
10956 || insn3 == CROR_151515 || insn3 == CROR_313131)
10957 {
10958 rel->r_offset += 4;
10959 bfd_put_32 (output_bfd, insn2, contents + offset + 4);
10960 insn2 = NOP;
10961 }
10962 bfd_put_32 (output_bfd, insn2, contents + offset);
10963 if ((tls_mask & TLS_TPRELGD) == 0 && toc_symndx != 0)
10964 {
10965 rel--;
10966 continue;
10967 }
10968 }
10969 break;
10970
10971 case R_PPC64_TLSLD:
10972 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
10973 {
10974 unsigned int insn2, insn3;
10975 bfd_vma offset = rel->r_offset;
10976
10977 if (toc_symndx)
10978 sec = local_sections[toc_symndx];
10979 for (r_symndx = 0;
10980 r_symndx < symtab_hdr->sh_info;
10981 r_symndx++)
10982 if (local_sections[r_symndx] == sec)
10983 break;
10984 if (r_symndx >= symtab_hdr->sh_info)
10985 r_symndx = 0;
10986 rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
10987 if (r_symndx != 0)
10988 rel->r_addend -= (local_syms[r_symndx].st_value
10989 + sec->output_offset
10990 + sec->output_section->vma);
10991
10992 r_type = R_PPC64_TPREL16_LO;
10993 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
10994 rel->r_offset = offset + d_offset;
10995 /* Zap the reloc on the _tls_get_addr call too. */
10996 BFD_ASSERT (offset == rel[1].r_offset);
10997 rel[1].r_info = ELF64_R_INFO (ELF64_R_SYM (rel[1].r_info),
10998 R_PPC64_NONE);
10999 insn2 = 0x38630000; /* addi 3,3,0 */
11000 insn3 = bfd_get_32 (output_bfd,
11001 contents + offset + 4);
11002 if (insn3 == NOP
11003 || insn3 == CROR_151515 || insn3 == CROR_313131)
11004 {
11005 rel->r_offset += 4;
11006 bfd_put_32 (output_bfd, insn2, contents + offset + 4);
11007 insn2 = NOP;
11008 }
11009 bfd_put_32 (output_bfd, insn2, contents + offset);
11010 rel--;
11011 continue;
11012 }
11013 break;
11014
11015 case R_PPC64_DTPMOD64:
11016 if (rel + 1 < relend
11017 && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
11018 && rel[1].r_offset == rel->r_offset + 8)
11019 {
11020 if ((tls_mask & TLS_GD) == 0)
11021 {
11022 rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_NONE);
11023 if ((tls_mask & TLS_TPRELGD) != 0)
11024 r_type = R_PPC64_TPREL64;
11025 else
11026 {
11027 bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
11028 r_type = R_PPC64_NONE;
11029 }
11030 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
11031 }
11032 }
11033 else
11034 {
11035 if ((tls_mask & TLS_LD) == 0)
11036 {
11037 bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
11038 r_type = R_PPC64_NONE;
11039 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
11040 }
11041 }
11042 break;
11043
11044 case R_PPC64_TPREL64:
11045 if ((tls_mask & TLS_TPREL) == 0)
11046 {
11047 r_type = R_PPC64_NONE;
11048 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
11049 }
11050 break;
11051 }
11052
11053 /* Handle other relocations that tweak non-addend part of insn. */
11054 insn = 0;
11055 max_br_offset = 1 << 25;
11056 addend = rel->r_addend;
11057 switch (r_type)
11058 {
11059 default:
11060 break;
11061
11062 /* Branch taken prediction relocations. */
11063 case R_PPC64_ADDR14_BRTAKEN:
11064 case R_PPC64_REL14_BRTAKEN:
11065 insn = 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field. */
11066 /* Fall thru. */
11067
11068 /* Branch not taken prediction relocations. */
11069 case R_PPC64_ADDR14_BRNTAKEN:
11070 case R_PPC64_REL14_BRNTAKEN:
11071 insn |= bfd_get_32 (output_bfd,
11072 contents + rel->r_offset) & ~(0x01 << 21);
11073 /* Fall thru. */
11074
11075 case R_PPC64_REL14:
11076 max_br_offset = 1 << 15;
11077 /* Fall thru. */
11078
11079 case R_PPC64_REL24:
11080 /* Calls to functions with a different TOC, such as calls to
11081 shared objects, need to alter the TOC pointer. This is
11082 done using a linkage stub. A REL24 branching to these
11083 linkage stubs needs to be followed by a nop, as the nop
11084 will be replaced with an instruction to restore the TOC
11085 base pointer. */
11086 stub_entry = NULL;
11087 fdh = h;
11088 if (((h != NULL
11089 && (((fdh = h->oh) != NULL
11090 && fdh->elf.plt.plist != NULL)
11091 || (fdh = h)->elf.plt.plist != NULL))
11092 || (sec != NULL
11093 && sec->output_section != NULL
11094 && sec->id <= htab->top_id
11095 && (htab->stub_group[sec->id].toc_off
11096 != htab->stub_group[input_section->id].toc_off)))
11097 && (stub_entry = ppc_get_stub_entry (input_section, sec, fdh,
11098 rel, htab)) != NULL
11099 && (stub_entry->stub_type == ppc_stub_plt_call
11100 || stub_entry->stub_type == ppc_stub_plt_branch_r2off
11101 || stub_entry->stub_type == ppc_stub_long_branch_r2off))
11102 {
11103 bfd_boolean can_plt_call = FALSE;
11104
11105 if (rel->r_offset + 8 <= input_section->size)
11106 {
11107 unsigned long nop;
11108 nop = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
11109 if (nop == NOP
11110 || nop == CROR_151515 || nop == CROR_313131)
11111 {
11112 bfd_put_32 (input_bfd, LD_R2_40R1,
11113 contents + rel->r_offset + 4);
11114 can_plt_call = TRUE;
11115 }
11116 }
11117
11118 if (!can_plt_call)
11119 {
11120 if (stub_entry->stub_type == ppc_stub_plt_call)
11121 {
11122 /* If this is a plain branch rather than a branch
11123 and link, don't require a nop. However, don't
11124 allow tail calls in a shared library as they
11125 will result in r2 being corrupted. */
11126 unsigned long br;
11127 br = bfd_get_32 (input_bfd, contents + rel->r_offset);
11128 if (info->executable && (br & 1) == 0)
11129 can_plt_call = TRUE;
11130 else
11131 stub_entry = NULL;
11132 }
11133 else if (h != NULL
11134 && strcmp (h->elf.root.root.string,
11135 ".__libc_start_main") == 0)
11136 {
11137 /* Allow crt1 branch to go via a toc adjusting stub. */
11138 can_plt_call = TRUE;
11139 }
11140 else
11141 {
11142 if (strcmp (input_section->output_section->name,
11143 ".init") == 0
11144 || strcmp (input_section->output_section->name,
11145 ".fini") == 0)
11146 (*_bfd_error_handler)
11147 (_("%B(%A+0x%lx): automatic multiple TOCs "
11148 "not supported using your crt files; "
11149 "recompile with -mminimal-toc or upgrade gcc"),
11150 input_bfd,
11151 input_section,
11152 (long) rel->r_offset);
11153 else
11154 (*_bfd_error_handler)
11155 (_("%B(%A+0x%lx): sibling call optimization to `%s' "
11156 "does not allow automatic multiple TOCs; "
11157 "recompile with -mminimal-toc or "
11158 "-fno-optimize-sibling-calls, "
11159 "or make `%s' extern"),
11160 input_bfd,
11161 input_section,
11162 (long) rel->r_offset,
11163 sym_name,
11164 sym_name);
11165 bfd_set_error (bfd_error_bad_value);
11166 ret = FALSE;
11167 }
11168 }
11169
11170 if (can_plt_call
11171 && stub_entry->stub_type == ppc_stub_plt_call)
11172 unresolved_reloc = FALSE;
11173 }
11174
11175 if (stub_entry == NULL
11176 && get_opd_info (sec) != NULL)
11177 {
11178 /* The branch destination is the value of the opd entry. */
11179 bfd_vma off = (relocation + addend
11180 - sec->output_section->vma
11181 - sec->output_offset);
11182 bfd_vma dest = opd_entry_value (sec, off, NULL, NULL);
11183 if (dest != (bfd_vma) -1)
11184 {
11185 relocation = dest;
11186 addend = 0;
11187 }
11188 }
11189
11190 /* If the branch is out of reach we ought to have a long
11191 branch stub. */
11192 from = (rel->r_offset
11193 + input_section->output_offset
11194 + input_section->output_section->vma);
11195
11196 if (stub_entry == NULL
11197 && (relocation + addend - from + max_br_offset
11198 >= 2 * max_br_offset)
11199 && r_type != R_PPC64_ADDR14_BRTAKEN
11200 && r_type != R_PPC64_ADDR14_BRNTAKEN)
11201 stub_entry = ppc_get_stub_entry (input_section, sec, h, rel,
11202 htab);
11203
11204 if (stub_entry != NULL)
11205 {
11206 /* Munge up the value and addend so that we call the stub
11207 rather than the procedure directly. */
11208 relocation = (stub_entry->stub_offset
11209 + stub_entry->stub_sec->output_offset
11210 + stub_entry->stub_sec->output_section->vma);
11211 addend = 0;
11212 }
11213
11214 if (insn != 0)
11215 {
11216 if (is_power4)
11217 {
11218 /* Set 'a' bit. This is 0b00010 in BO field for branch
11219 on CR(BI) insns (BO == 001at or 011at), and 0b01000
11220 for branch on CTR insns (BO == 1a00t or 1a01t). */
11221 if ((insn & (0x14 << 21)) == (0x04 << 21))
11222 insn |= 0x02 << 21;
11223 else if ((insn & (0x14 << 21)) == (0x10 << 21))
11224 insn |= 0x08 << 21;
11225 else
11226 break;
11227 }
11228 else
11229 {
11230 /* Invert 'y' bit if not the default. */
11231 if ((bfd_signed_vma) (relocation + addend - from) < 0)
11232 insn ^= 0x01 << 21;
11233 }
11234
11235 bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
11236 }
11237
11238 /* NOP out calls to undefined weak functions.
11239 We can thus call a weak function without first
11240 checking whether the function is defined. */
11241 else if (h != NULL
11242 && h->elf.root.type == bfd_link_hash_undefweak
11243 && r_type == R_PPC64_REL24
11244 && relocation == 0
11245 && addend == 0)
11246 {
11247 bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
11248 continue;
11249 }
11250 break;
11251 }
11252
11253 /* Set `addend'. */
11254 tls_type = 0;
11255 switch (r_type)
11256 {
11257 default:
11258 (*_bfd_error_handler)
11259 (_("%B: unknown relocation type %d for symbol %s"),
11260 input_bfd, (int) r_type, sym_name);
11261
11262 bfd_set_error (bfd_error_bad_value);
11263 ret = FALSE;
11264 continue;
11265
11266 case R_PPC64_NONE:
11267 case R_PPC64_TLS:
11268 case R_PPC64_TLSGD:
11269 case R_PPC64_TLSLD:
11270 case R_PPC64_GNU_VTINHERIT:
11271 case R_PPC64_GNU_VTENTRY:
11272 continue;
11273
11274 /* GOT16 relocations. Like an ADDR16 using the symbol's
11275 address in the GOT as relocation value instead of the
11276 symbol's value itself. Also, create a GOT entry for the
11277 symbol and put the symbol value there. */
11278 case R_PPC64_GOT_TLSGD16:
11279 case R_PPC64_GOT_TLSGD16_LO:
11280 case R_PPC64_GOT_TLSGD16_HI:
11281 case R_PPC64_GOT_TLSGD16_HA:
11282 tls_type = TLS_TLS | TLS_GD;
11283 goto dogot;
11284
11285 case R_PPC64_GOT_TLSLD16:
11286 case R_PPC64_GOT_TLSLD16_LO:
11287 case R_PPC64_GOT_TLSLD16_HI:
11288 case R_PPC64_GOT_TLSLD16_HA:
11289 tls_type = TLS_TLS | TLS_LD;
11290 goto dogot;
11291
11292 case R_PPC64_GOT_TPREL16_DS:
11293 case R_PPC64_GOT_TPREL16_LO_DS:
11294 case R_PPC64_GOT_TPREL16_HI:
11295 case R_PPC64_GOT_TPREL16_HA:
11296 tls_type = TLS_TLS | TLS_TPREL;
11297 goto dogot;
11298
11299 case R_PPC64_GOT_DTPREL16_DS:
11300 case R_PPC64_GOT_DTPREL16_LO_DS:
11301 case R_PPC64_GOT_DTPREL16_HI:
11302 case R_PPC64_GOT_DTPREL16_HA:
11303 tls_type = TLS_TLS | TLS_DTPREL;
11304 goto dogot;
11305
11306 case R_PPC64_GOT16:
11307 case R_PPC64_GOT16_LO:
11308 case R_PPC64_GOT16_HI:
11309 case R_PPC64_GOT16_HA:
11310 case R_PPC64_GOT16_DS:
11311 case R_PPC64_GOT16_LO_DS:
11312 dogot:
11313 {
11314 /* Relocation is to the entry for this symbol in the global
11315 offset table. */
11316 asection *got;
11317 bfd_vma *offp;
11318 bfd_vma off;
11319 unsigned long indx = 0;
11320
11321 if (tls_type == (TLS_TLS | TLS_LD)
11322 && (h == NULL
11323 || !h->elf.def_dynamic))
11324 offp = &ppc64_tlsld_got (input_bfd)->offset;
11325 else
11326 {
11327 struct got_entry *ent;
11328
11329 if (h != NULL)
11330 {
11331 bfd_boolean dyn = htab->elf.dynamic_sections_created;
11332 if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared,
11333 &h->elf)
11334 || (info->shared
11335 && SYMBOL_REFERENCES_LOCAL (info, &h->elf)))
11336 /* This is actually a static link, or it is a
11337 -Bsymbolic link and the symbol is defined
11338 locally, or the symbol was forced to be local
11339 because of a version file. */
11340 ;
11341 else
11342 {
11343 indx = h->elf.dynindx;
11344 unresolved_reloc = FALSE;
11345 }
11346 ent = h->elf.got.glist;
11347 }
11348 else
11349 {
11350 if (local_got_ents == NULL)
11351 abort ();
11352 ent = local_got_ents[r_symndx];
11353 }
11354
11355 for (; ent != NULL; ent = ent->next)
11356 if (ent->addend == orig_addend
11357 && ent->owner == input_bfd
11358 && ent->tls_type == tls_type)
11359 break;
11360 if (ent == NULL)
11361 abort ();
11362 offp = &ent->got.offset;
11363 }
11364
11365 got = ppc64_elf_tdata (input_bfd)->got;
11366 if (got == NULL)
11367 abort ();
11368
11369 /* The offset must always be a multiple of 8. We use the
11370 least significant bit to record whether we have already
11371 processed this entry. */
11372 off = *offp;
11373 if ((off & 1) != 0)
11374 off &= ~1;
11375 else
11376 {
11377 /* Generate relocs for the dynamic linker, except in
11378 the case of TLSLD where we'll use one entry per
11379 module. */
11380 asection *relgot = ppc64_elf_tdata (input_bfd)->relgot;
11381
11382 *offp = off | 1;
11383 if ((info->shared || indx != 0)
11384 && (offp == &ppc64_tlsld_got (input_bfd)->offset
11385 || h == NULL
11386 || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
11387 || h->elf.root.type != bfd_link_hash_undefweak))
11388 {
11389 outrel.r_offset = (got->output_section->vma
11390 + got->output_offset
11391 + off);
11392 outrel.r_addend = addend;
11393 if (tls_type & (TLS_LD | TLS_GD))
11394 {
11395 outrel.r_addend = 0;
11396 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPMOD64);
11397 if (tls_type == (TLS_TLS | TLS_GD))
11398 {
11399 loc = relgot->contents;
11400 loc += (relgot->reloc_count++
11401 * sizeof (Elf64_External_Rela));
11402 bfd_elf64_swap_reloca_out (output_bfd,
11403 &outrel, loc);
11404 outrel.r_offset += 8;
11405 outrel.r_addend = addend;
11406 outrel.r_info
11407 = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
11408 }
11409 }
11410 else if (tls_type == (TLS_TLS | TLS_DTPREL))
11411 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
11412 else if (tls_type == (TLS_TLS | TLS_TPREL))
11413 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_TPREL64);
11414 else if (indx == 0)
11415 {
11416 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_RELATIVE);
11417
11418 /* Write the .got section contents for the sake
11419 of prelink. */
11420 loc = got->contents + off;
11421 bfd_put_64 (output_bfd, outrel.r_addend + relocation,
11422 loc);
11423 }
11424 else
11425 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_GLOB_DAT);
11426
11427 if (indx == 0 && tls_type != (TLS_TLS | TLS_LD))
11428 {
11429 outrel.r_addend += relocation;
11430 if (tls_type & (TLS_GD | TLS_DTPREL | TLS_TPREL))
11431 outrel.r_addend -= htab->elf.tls_sec->vma;
11432 }
11433 loc = relgot->contents;
11434 loc += (relgot->reloc_count++
11435 * sizeof (Elf64_External_Rela));
11436 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
11437 }
11438
11439 /* Init the .got section contents here if we're not
11440 emitting a reloc. */
11441 else
11442 {
11443 relocation += addend;
11444 if (tls_type == (TLS_TLS | TLS_LD))
11445 relocation = 1;
11446 else if (tls_type != 0)
11447 {
11448 relocation -= htab->elf.tls_sec->vma + DTP_OFFSET;
11449 if (tls_type == (TLS_TLS | TLS_TPREL))
11450 relocation += DTP_OFFSET - TP_OFFSET;
11451
11452 if (tls_type == (TLS_TLS | TLS_GD))
11453 {
11454 bfd_put_64 (output_bfd, relocation,
11455 got->contents + off + 8);
11456 relocation = 1;
11457 }
11458 }
11459
11460 bfd_put_64 (output_bfd, relocation,
11461 got->contents + off);
11462 }
11463 }
11464
11465 if (off >= (bfd_vma) -2)
11466 abort ();
11467
11468 relocation = got->output_offset + off;
11469
11470 /* TOC base (r2) is TOC start plus 0x8000. */
11471 addend = -TOC_BASE_OFF;
11472 }
11473 break;
11474
11475 case R_PPC64_PLT16_HA:
11476 case R_PPC64_PLT16_HI:
11477 case R_PPC64_PLT16_LO:
11478 case R_PPC64_PLT32:
11479 case R_PPC64_PLT64:
11480 /* Relocation is to the entry for this symbol in the
11481 procedure linkage table. */
11482
11483 /* Resolve a PLT reloc against a local symbol directly,
11484 without using the procedure linkage table. */
11485 if (h == NULL)
11486 break;
11487
11488 /* It's possible that we didn't make a PLT entry for this
11489 symbol. This happens when statically linking PIC code,
11490 or when using -Bsymbolic. Go find a match if there is a
11491 PLT entry. */
11492 if (htab->plt != NULL)
11493 {
11494 struct plt_entry *ent;
11495 for (ent = h->elf.plt.plist; ent != NULL; ent = ent->next)
11496 if (ent->addend == orig_addend
11497 && ent->plt.offset != (bfd_vma) -1)
11498 {
11499 relocation = (htab->plt->output_section->vma
11500 + htab->plt->output_offset
11501 + ent->plt.offset);
11502 unresolved_reloc = FALSE;
11503 }
11504 }
11505 break;
11506
11507 case R_PPC64_TOC:
11508 /* Relocation value is TOC base. */
11509 relocation = TOCstart;
11510 if (r_symndx == 0)
11511 relocation += htab->stub_group[input_section->id].toc_off;
11512 else if (unresolved_reloc)
11513 ;
11514 else if (sec != NULL && sec->id <= htab->top_id)
11515 relocation += htab->stub_group[sec->id].toc_off;
11516 else
11517 unresolved_reloc = TRUE;
11518 goto dodyn;
11519
11520 /* TOC16 relocs. We want the offset relative to the TOC base,
11521 which is the address of the start of the TOC plus 0x8000.
11522 The TOC consists of sections .got, .toc, .tocbss, and .plt,
11523 in this order. */
11524 case R_PPC64_TOC16:
11525 case R_PPC64_TOC16_LO:
11526 case R_PPC64_TOC16_HI:
11527 case R_PPC64_TOC16_DS:
11528 case R_PPC64_TOC16_LO_DS:
11529 case R_PPC64_TOC16_HA:
11530 addend -= TOCstart + htab->stub_group[input_section->id].toc_off;
11531 break;
11532
11533 /* Relocate against the beginning of the section. */
11534 case R_PPC64_SECTOFF:
11535 case R_PPC64_SECTOFF_LO:
11536 case R_PPC64_SECTOFF_HI:
11537 case R_PPC64_SECTOFF_DS:
11538 case R_PPC64_SECTOFF_LO_DS:
11539 case R_PPC64_SECTOFF_HA:
11540 if (sec != NULL)
11541 addend -= sec->output_section->vma;
11542 break;
11543
11544 case R_PPC64_REL14:
11545 case R_PPC64_REL14_BRNTAKEN:
11546 case R_PPC64_REL14_BRTAKEN:
11547 case R_PPC64_REL24:
11548 break;
11549
11550 case R_PPC64_TPREL16:
11551 case R_PPC64_TPREL16_LO:
11552 case R_PPC64_TPREL16_HI:
11553 case R_PPC64_TPREL16_HA:
11554 case R_PPC64_TPREL16_DS:
11555 case R_PPC64_TPREL16_LO_DS:
11556 case R_PPC64_TPREL16_HIGHER:
11557 case R_PPC64_TPREL16_HIGHERA:
11558 case R_PPC64_TPREL16_HIGHEST:
11559 case R_PPC64_TPREL16_HIGHESTA:
11560 addend -= htab->elf.tls_sec->vma + TP_OFFSET;
11561 if (info->shared)
11562 /* The TPREL16 relocs shouldn't really be used in shared
11563 libs as they will result in DT_TEXTREL being set, but
11564 support them anyway. */
11565 goto dodyn;
11566 break;
11567
11568 case R_PPC64_DTPREL16:
11569 case R_PPC64_DTPREL16_LO:
11570 case R_PPC64_DTPREL16_HI:
11571 case R_PPC64_DTPREL16_HA:
11572 case R_PPC64_DTPREL16_DS:
11573 case R_PPC64_DTPREL16_LO_DS:
11574 case R_PPC64_DTPREL16_HIGHER:
11575 case R_PPC64_DTPREL16_HIGHERA:
11576 case R_PPC64_DTPREL16_HIGHEST:
11577 case R_PPC64_DTPREL16_HIGHESTA:
11578 addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
11579 break;
11580
11581 case R_PPC64_DTPMOD64:
11582 relocation = 1;
11583 addend = 0;
11584 goto dodyn;
11585
11586 case R_PPC64_TPREL64:
11587 addend -= htab->elf.tls_sec->vma + TP_OFFSET;
11588 goto dodyn;
11589
11590 case R_PPC64_DTPREL64:
11591 addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
11592 /* Fall thru */
11593
11594 /* Relocations that may need to be propagated if this is a
11595 dynamic object. */
11596 case R_PPC64_REL30:
11597 case R_PPC64_REL32:
11598 case R_PPC64_REL64:
11599 case R_PPC64_ADDR14:
11600 case R_PPC64_ADDR14_BRNTAKEN:
11601 case R_PPC64_ADDR14_BRTAKEN:
11602 case R_PPC64_ADDR16:
11603 case R_PPC64_ADDR16_DS:
11604 case R_PPC64_ADDR16_HA:
11605 case R_PPC64_ADDR16_HI:
11606 case R_PPC64_ADDR16_HIGHER:
11607 case R_PPC64_ADDR16_HIGHERA:
11608 case R_PPC64_ADDR16_HIGHEST:
11609 case R_PPC64_ADDR16_HIGHESTA:
11610 case R_PPC64_ADDR16_LO:
11611 case R_PPC64_ADDR16_LO_DS:
11612 case R_PPC64_ADDR24:
11613 case R_PPC64_ADDR32:
11614 case R_PPC64_ADDR64:
11615 case R_PPC64_UADDR16:
11616 case R_PPC64_UADDR32:
11617 case R_PPC64_UADDR64:
11618 dodyn:
11619 if ((input_section->flags & SEC_ALLOC) == 0)
11620 break;
11621
11622 if (NO_OPD_RELOCS && is_opd)
11623 break;
11624
11625 if ((info->shared
11626 && (h == NULL
11627 || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
11628 || h->elf.root.type != bfd_link_hash_undefweak)
11629 && (must_be_dyn_reloc (info, r_type)
11630 || !SYMBOL_CALLS_LOCAL (info, &h->elf)))
11631 || (ELIMINATE_COPY_RELOCS
11632 && !info->shared
11633 && h != NULL
11634 && h->elf.dynindx != -1
11635 && !h->elf.non_got_ref
11636 && !h->elf.def_regular))
11637 {
11638 Elf_Internal_Rela outrel;
11639 bfd_boolean skip, relocate;
11640 asection *sreloc;
11641 bfd_byte *loc;
11642 bfd_vma out_off;
11643
11644 /* When generating a dynamic object, these relocations
11645 are copied into the output file to be resolved at run
11646 time. */
11647
11648 skip = FALSE;
11649 relocate = FALSE;
11650
11651 out_off = _bfd_elf_section_offset (output_bfd, info,
11652 input_section, rel->r_offset);
11653 if (out_off == (bfd_vma) -1)
11654 skip = TRUE;
11655 else if (out_off == (bfd_vma) -2)
11656 skip = TRUE, relocate = TRUE;
11657 out_off += (input_section->output_section->vma
11658 + input_section->output_offset);
11659 outrel.r_offset = out_off;
11660 outrel.r_addend = rel->r_addend;
11661
11662 /* Optimize unaligned reloc use. */
11663 if ((r_type == R_PPC64_ADDR64 && (out_off & 7) != 0)
11664 || (r_type == R_PPC64_UADDR64 && (out_off & 7) == 0))
11665 r_type ^= R_PPC64_ADDR64 ^ R_PPC64_UADDR64;
11666 else if ((r_type == R_PPC64_ADDR32 && (out_off & 3) != 0)
11667 || (r_type == R_PPC64_UADDR32 && (out_off & 3) == 0))
11668 r_type ^= R_PPC64_ADDR32 ^ R_PPC64_UADDR32;
11669 else if ((r_type == R_PPC64_ADDR16 && (out_off & 1) != 0)
11670 || (r_type == R_PPC64_UADDR16 && (out_off & 1) == 0))
11671 r_type ^= R_PPC64_ADDR16 ^ R_PPC64_UADDR16;
11672
11673 if (skip)
11674 memset (&outrel, 0, sizeof outrel);
11675 else if (!SYMBOL_REFERENCES_LOCAL (info, &h->elf)
11676 && !is_opd
11677 && r_type != R_PPC64_TOC)
11678 outrel.r_info = ELF64_R_INFO (h->elf.dynindx, r_type);
11679 else
11680 {
11681 /* This symbol is local, or marked to become local,
11682 or this is an opd section reloc which must point
11683 at a local function. */
11684 outrel.r_addend += relocation;
11685 if (r_type == R_PPC64_ADDR64 || r_type == R_PPC64_TOC)
11686 {
11687 if (is_opd && h != NULL)
11688 {
11689 /* Lie about opd entries. This case occurs
11690 when building shared libraries and we
11691 reference a function in another shared
11692 lib. The same thing happens for a weak
11693 definition in an application that's
11694 overridden by a strong definition in a
11695 shared lib. (I believe this is a generic
11696 bug in binutils handling of weak syms.)
11697 In these cases we won't use the opd
11698 entry in this lib. */
11699 unresolved_reloc = FALSE;
11700 }
11701 outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
11702
11703 /* We need to relocate .opd contents for ld.so.
11704 Prelink also wants simple and consistent rules
11705 for relocs. This make all RELATIVE relocs have
11706 *r_offset equal to r_addend. */
11707 relocate = TRUE;
11708 }
11709 else
11710 {
11711 long indx = 0;
11712
11713 if (r_symndx == 0 || bfd_is_abs_section (sec))
11714 ;
11715 else if (sec == NULL || sec->owner == NULL)
11716 {
11717 bfd_set_error (bfd_error_bad_value);
11718 return FALSE;
11719 }
11720 else
11721 {
11722 asection *osec;
11723
11724 osec = sec->output_section;
11725 indx = elf_section_data (osec)->dynindx;
11726
11727 if (indx == 0)
11728 {
11729 if ((osec->flags & SEC_READONLY) == 0
11730 && htab->elf.data_index_section != NULL)
11731 osec = htab->elf.data_index_section;
11732 else
11733 osec = htab->elf.text_index_section;
11734 indx = elf_section_data (osec)->dynindx;
11735 }
11736 BFD_ASSERT (indx != 0);
11737
11738 /* We are turning this relocation into one
11739 against a section symbol, so subtract out
11740 the output section's address but not the
11741 offset of the input section in the output
11742 section. */
11743 outrel.r_addend -= osec->vma;
11744 }
11745
11746 outrel.r_info = ELF64_R_INFO (indx, r_type);
11747 }
11748 }
11749
11750 sreloc = elf_section_data (input_section)->sreloc;
11751 if (sreloc == NULL)
11752 abort ();
11753
11754 if (sreloc->reloc_count * sizeof (Elf64_External_Rela)
11755 >= sreloc->size)
11756 abort ();
11757 loc = sreloc->contents;
11758 loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
11759 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
11760
11761 /* If this reloc is against an external symbol, it will
11762 be computed at runtime, so there's no need to do
11763 anything now. However, for the sake of prelink ensure
11764 that the section contents are a known value. */
11765 if (! relocate)
11766 {
11767 unresolved_reloc = FALSE;
11768 /* The value chosen here is quite arbitrary as ld.so
11769 ignores section contents except for the special
11770 case of .opd where the contents might be accessed
11771 before relocation. Choose zero, as that won't
11772 cause reloc overflow. */
11773 relocation = 0;
11774 addend = 0;
11775 /* Use *r_offset == r_addend for R_PPC64_ADDR64 relocs
11776 to improve backward compatibility with older
11777 versions of ld. */
11778 if (r_type == R_PPC64_ADDR64)
11779 addend = outrel.r_addend;
11780 /* Adjust pc_relative relocs to have zero in *r_offset. */
11781 else if (ppc64_elf_howto_table[r_type]->pc_relative)
11782 addend = (input_section->output_section->vma
11783 + input_section->output_offset
11784 + rel->r_offset);
11785 }
11786 }
11787 break;
11788
11789 case R_PPC64_COPY:
11790 case R_PPC64_GLOB_DAT:
11791 case R_PPC64_JMP_SLOT:
11792 case R_PPC64_RELATIVE:
11793 /* We shouldn't ever see these dynamic relocs in relocatable
11794 files. */
11795 /* Fall through. */
11796
11797 case R_PPC64_PLTGOT16:
11798 case R_PPC64_PLTGOT16_DS:
11799 case R_PPC64_PLTGOT16_HA:
11800 case R_PPC64_PLTGOT16_HI:
11801 case R_PPC64_PLTGOT16_LO:
11802 case R_PPC64_PLTGOT16_LO_DS:
11803 case R_PPC64_PLTREL32:
11804 case R_PPC64_PLTREL64:
11805 /* These ones haven't been implemented yet. */
11806
11807 (*_bfd_error_handler)
11808 (_("%B: relocation %s is not supported for symbol %s."),
11809 input_bfd,
11810 ppc64_elf_howto_table[r_type]->name, sym_name);
11811
11812 bfd_set_error (bfd_error_invalid_operation);
11813 ret = FALSE;
11814 continue;
11815 }
11816
11817 /* Do any further special processing. */
11818 switch (r_type)
11819 {
11820 default:
11821 break;
11822
11823 case R_PPC64_ADDR16_HA:
11824 case R_PPC64_ADDR16_HIGHERA:
11825 case R_PPC64_ADDR16_HIGHESTA:
11826 case R_PPC64_TOC16_HA:
11827 case R_PPC64_SECTOFF_HA:
11828 case R_PPC64_TPREL16_HA:
11829 case R_PPC64_DTPREL16_HA:
11830 case R_PPC64_TPREL16_HIGHER:
11831 case R_PPC64_TPREL16_HIGHERA:
11832 case R_PPC64_TPREL16_HIGHEST:
11833 case R_PPC64_TPREL16_HIGHESTA:
11834 case R_PPC64_DTPREL16_HIGHER:
11835 case R_PPC64_DTPREL16_HIGHERA:
11836 case R_PPC64_DTPREL16_HIGHEST:
11837 case R_PPC64_DTPREL16_HIGHESTA:
11838 /* It's just possible that this symbol is a weak symbol
11839 that's not actually defined anywhere. In that case,
11840 'sec' would be NULL, and we should leave the symbol
11841 alone (it will be set to zero elsewhere in the link). */
11842 if (sec == NULL)
11843 break;
11844 /* Fall thru */
11845
11846 case R_PPC64_GOT16_HA:
11847 case R_PPC64_PLTGOT16_HA:
11848 case R_PPC64_PLT16_HA:
11849 case R_PPC64_GOT_TLSGD16_HA:
11850 case R_PPC64_GOT_TLSLD16_HA:
11851 case R_PPC64_GOT_TPREL16_HA:
11852 case R_PPC64_GOT_DTPREL16_HA:
11853 /* Add 0x10000 if sign bit in 0:15 is set.
11854 Bits 0:15 are not used. */
11855 addend += 0x8000;
11856 break;
11857
11858 case R_PPC64_ADDR16_DS:
11859 case R_PPC64_ADDR16_LO_DS:
11860 case R_PPC64_GOT16_DS:
11861 case R_PPC64_GOT16_LO_DS:
11862 case R_PPC64_PLT16_LO_DS:
11863 case R_PPC64_SECTOFF_DS:
11864 case R_PPC64_SECTOFF_LO_DS:
11865 case R_PPC64_TOC16_DS:
11866 case R_PPC64_TOC16_LO_DS:
11867 case R_PPC64_PLTGOT16_DS:
11868 case R_PPC64_PLTGOT16_LO_DS:
11869 case R_PPC64_GOT_TPREL16_DS:
11870 case R_PPC64_GOT_TPREL16_LO_DS:
11871 case R_PPC64_GOT_DTPREL16_DS:
11872 case R_PPC64_GOT_DTPREL16_LO_DS:
11873 case R_PPC64_TPREL16_DS:
11874 case R_PPC64_TPREL16_LO_DS:
11875 case R_PPC64_DTPREL16_DS:
11876 case R_PPC64_DTPREL16_LO_DS:
11877 insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
11878 mask = 3;
11879 /* If this reloc is against an lq insn, then the value must be
11880 a multiple of 16. This is somewhat of a hack, but the
11881 "correct" way to do this by defining _DQ forms of all the
11882 _DS relocs bloats all reloc switches in this file. It
11883 doesn't seem to make much sense to use any of these relocs
11884 in data, so testing the insn should be safe. */
11885 if ((insn & (0x3f << 26)) == (56u << 26))
11886 mask = 15;
11887 if (((relocation + addend) & mask) != 0)
11888 {
11889 (*_bfd_error_handler)
11890 (_("%B: error: relocation %s not a multiple of %d"),
11891 input_bfd,
11892 ppc64_elf_howto_table[r_type]->name,
11893 mask + 1);
11894 bfd_set_error (bfd_error_bad_value);
11895 ret = FALSE;
11896 continue;
11897 }
11898 break;
11899 }
11900
11901 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
11902 because such sections are not SEC_ALLOC and thus ld.so will
11903 not process them. */
11904 if (unresolved_reloc
11905 && !((input_section->flags & SEC_DEBUGGING) != 0
11906 && h->elf.def_dynamic))
11907 {
11908 (*_bfd_error_handler)
11909 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
11910 input_bfd,
11911 input_section,
11912 (long) rel->r_offset,
11913 ppc64_elf_howto_table[(int) r_type]->name,
11914 h->elf.root.root.string);
11915 ret = FALSE;
11916 }
11917
11918 r = _bfd_final_link_relocate (ppc64_elf_howto_table[(int) r_type],
11919 input_bfd,
11920 input_section,
11921 contents,
11922 rel->r_offset,
11923 relocation,
11924 addend);
11925
11926 if (r != bfd_reloc_ok)
11927 {
11928 if (sym_name == NULL)
11929 sym_name = "(null)";
11930 if (r == bfd_reloc_overflow)
11931 {
11932 if (warned)
11933 continue;
11934 if (h != NULL
11935 && h->elf.root.type == bfd_link_hash_undefweak
11936 && ppc64_elf_howto_table[r_type]->pc_relative)
11937 {
11938 /* Assume this is a call protected by other code that
11939 detects the symbol is undefined. If this is the case,
11940 we can safely ignore the overflow. If not, the
11941 program is hosed anyway, and a little warning isn't
11942 going to help. */
11943
11944 continue;
11945 }
11946
11947 if (!((*info->callbacks->reloc_overflow)
11948 (info, (h ? &h->elf.root : NULL), sym_name,
11949 ppc64_elf_howto_table[r_type]->name,
11950 orig_addend, input_bfd, input_section, rel->r_offset)))
11951 return FALSE;
11952 }
11953 else
11954 {
11955 (*_bfd_error_handler)
11956 (_("%B(%A+0x%lx): %s reloc against `%s': error %d"),
11957 input_bfd,
11958 input_section,
11959 (long) rel->r_offset,
11960 ppc64_elf_howto_table[r_type]->name,
11961 sym_name,
11962 (int) r);
11963 ret = FALSE;
11964 }
11965 }
11966 }
11967
11968 /* If we're emitting relocations, then shortly after this function
11969 returns, reloc offsets and addends for this section will be
11970 adjusted. Worse, reloc symbol indices will be for the output
11971 file rather than the input. Save a copy of the relocs for
11972 opd_entry_value. */
11973 if (is_opd && (info->emitrelocations || info->relocatable))
11974 {
11975 bfd_size_type amt;
11976 amt = input_section->reloc_count * sizeof (Elf_Internal_Rela);
11977 rel = bfd_alloc (input_bfd, amt);
11978 BFD_ASSERT (ppc64_elf_tdata (input_bfd)->opd_relocs == NULL);
11979 ppc64_elf_tdata (input_bfd)->opd_relocs = rel;
11980 if (rel == NULL)
11981 return FALSE;
11982 memcpy (rel, relocs, amt);
11983 }
11984 return ret;
11985 }
11986
11987 /* Adjust the value of any local symbols in opd sections. */
11988
11989 static int
11990 ppc64_elf_output_symbol_hook (struct bfd_link_info *info,
11991 const char *name ATTRIBUTE_UNUSED,
11992 Elf_Internal_Sym *elfsym,
11993 asection *input_sec,
11994 struct elf_link_hash_entry *h)
11995 {
11996 struct _opd_sec_data *opd;
11997 long adjust;
11998 bfd_vma value;
11999
12000 if (h != NULL)
12001 return 1;
12002
12003 opd = get_opd_info (input_sec);
12004 if (opd == NULL || opd->adjust == NULL)
12005 return 1;
12006
12007 value = elfsym->st_value - input_sec->output_offset;
12008 if (!info->relocatable)
12009 value -= input_sec->output_section->vma;
12010
12011 adjust = opd->adjust[value / 8];
12012 if (adjust == -1)
12013 return 2;
12014
12015 elfsym->st_value += adjust;
12016 return 1;
12017 }
12018
12019 /* Finish up dynamic symbol handling. We set the contents of various
12020 dynamic sections here. */
12021
12022 static bfd_boolean
12023 ppc64_elf_finish_dynamic_symbol (bfd *output_bfd,
12024 struct bfd_link_info *info,
12025 struct elf_link_hash_entry *h,
12026 Elf_Internal_Sym *sym)
12027 {
12028 struct ppc_link_hash_table *htab;
12029 struct plt_entry *ent;
12030 Elf_Internal_Rela rela;
12031 bfd_byte *loc;
12032
12033 htab = ppc_hash_table (info);
12034
12035 for (ent = h->plt.plist; ent != NULL; ent = ent->next)
12036 if (ent->plt.offset != (bfd_vma) -1)
12037 {
12038 /* This symbol has an entry in the procedure linkage
12039 table. Set it up. */
12040 asection *plt = htab->plt;
12041 if (!htab->elf.dynamic_sections_created)
12042 plt = htab->iplt;
12043
12044 rela.r_offset = (plt->output_section->vma
12045 + plt->output_offset
12046 + ent->plt.offset);
12047
12048 if (!htab->elf.dynamic_sections_created
12049 || h->dynindx == -1)
12050 {
12051 BFD_ASSERT (h->type == STT_GNU_IFUNC
12052 && h->def_regular
12053 && (h->root.type == bfd_link_hash_defined
12054 || h->root.type == bfd_link_hash_defweak));
12055 rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
12056 rela.r_addend = (h->root.u.def.value
12057 + h->root.u.def.section->output_offset
12058 + h->root.u.def.section->output_section->vma
12059 + ent->addend);
12060 }
12061 else
12062 {
12063 rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_JMP_SLOT);
12064 rela.r_addend = ent->addend;
12065 }
12066
12067 if (!htab->elf.dynamic_sections_created)
12068 loc = (htab->reliplt->contents
12069 + (ent->plt.offset
12070 / (PLT_ENTRY_SIZE / sizeof (Elf64_External_Rela))));
12071 else
12072 loc = (htab->relplt->contents
12073 + ((ent->plt.offset - PLT_INITIAL_ENTRY_SIZE)
12074 / (PLT_ENTRY_SIZE / sizeof (Elf64_External_Rela))));
12075 bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
12076 }
12077
12078 if (h->needs_copy)
12079 {
12080 Elf_Internal_Rela rela;
12081 bfd_byte *loc;
12082
12083 /* This symbol needs a copy reloc. Set it up. */
12084
12085 if (h->dynindx == -1
12086 || (h->root.type != bfd_link_hash_defined
12087 && h->root.type != bfd_link_hash_defweak)
12088 || htab->relbss == NULL)
12089 abort ();
12090
12091 rela.r_offset = (h->root.u.def.value
12092 + h->root.u.def.section->output_section->vma
12093 + h->root.u.def.section->output_offset);
12094 rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_COPY);
12095 rela.r_addend = 0;
12096 loc = htab->relbss->contents;
12097 loc += htab->relbss->reloc_count++ * sizeof (Elf64_External_Rela);
12098 bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
12099 }
12100
12101 /* Mark some specially defined symbols as absolute. */
12102 if (strcmp (h->root.root.string, "_DYNAMIC") == 0)
12103 sym->st_shndx = SHN_ABS;
12104
12105 return TRUE;
12106 }
12107
12108 /* Used to decide how to sort relocs in an optimal manner for the
12109 dynamic linker, before writing them out. */
12110
12111 static enum elf_reloc_type_class
12112 ppc64_elf_reloc_type_class (const Elf_Internal_Rela *rela)
12113 {
12114 enum elf_ppc64_reloc_type r_type;
12115
12116 r_type = ELF64_R_TYPE (rela->r_info);
12117 switch (r_type)
12118 {
12119 case R_PPC64_RELATIVE:
12120 return reloc_class_relative;
12121 case R_PPC64_JMP_SLOT:
12122 return reloc_class_plt;
12123 case R_PPC64_COPY:
12124 return reloc_class_copy;
12125 default:
12126 return reloc_class_normal;
12127 }
12128 }
12129
12130 /* Finish up the dynamic sections. */
12131
12132 static bfd_boolean
12133 ppc64_elf_finish_dynamic_sections (bfd *output_bfd,
12134 struct bfd_link_info *info)
12135 {
12136 struct ppc_link_hash_table *htab;
12137 bfd *dynobj;
12138 asection *sdyn;
12139
12140 htab = ppc_hash_table (info);
12141 dynobj = htab->elf.dynobj;
12142 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
12143
12144 if (htab->elf.dynamic_sections_created)
12145 {
12146 Elf64_External_Dyn *dyncon, *dynconend;
12147
12148 if (sdyn == NULL || htab->got == NULL)
12149 abort ();
12150
12151 dyncon = (Elf64_External_Dyn *) sdyn->contents;
12152 dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
12153 for (; dyncon < dynconend; dyncon++)
12154 {
12155 Elf_Internal_Dyn dyn;
12156 asection *s;
12157
12158 bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
12159
12160 switch (dyn.d_tag)
12161 {
12162 default:
12163 continue;
12164
12165 case DT_PPC64_GLINK:
12166 s = htab->glink;
12167 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
12168 /* We stupidly defined DT_PPC64_GLINK to be the start
12169 of glink rather than the first entry point, which is
12170 what ld.so needs, and now have a bigger stub to
12171 support automatic multiple TOCs. */
12172 dyn.d_un.d_ptr += GLINK_CALL_STUB_SIZE - 32;
12173 break;
12174
12175 case DT_PPC64_OPD:
12176 s = bfd_get_section_by_name (output_bfd, ".opd");
12177 if (s == NULL)
12178 continue;
12179 dyn.d_un.d_ptr = s->vma;
12180 break;
12181
12182 case DT_PPC64_OPDSZ:
12183 s = bfd_get_section_by_name (output_bfd, ".opd");
12184 if (s == NULL)
12185 continue;
12186 dyn.d_un.d_val = s->size;
12187 break;
12188
12189 case DT_PLTGOT:
12190 s = htab->plt;
12191 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
12192 break;
12193
12194 case DT_JMPREL:
12195 s = htab->relplt;
12196 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
12197 break;
12198
12199 case DT_PLTRELSZ:
12200 dyn.d_un.d_val = htab->relplt->size;
12201 break;
12202
12203 case DT_RELASZ:
12204 /* Don't count procedure linkage table relocs in the
12205 overall reloc count. */
12206 s = htab->relplt;
12207 if (s == NULL)
12208 continue;
12209 dyn.d_un.d_val -= s->size;
12210 break;
12211
12212 case DT_RELA:
12213 /* We may not be using the standard ELF linker script.
12214 If .rela.plt is the first .rela section, we adjust
12215 DT_RELA to not include it. */
12216 s = htab->relplt;
12217 if (s == NULL)
12218 continue;
12219 if (dyn.d_un.d_ptr != s->output_section->vma + s->output_offset)
12220 continue;
12221 dyn.d_un.d_ptr += s->size;
12222 break;
12223 }
12224
12225 bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
12226 }
12227 }
12228
12229 if (htab->got != NULL && htab->got->size != 0)
12230 {
12231 /* Fill in the first entry in the global offset table.
12232 We use it to hold the link-time TOCbase. */
12233 bfd_put_64 (output_bfd,
12234 elf_gp (output_bfd) + TOC_BASE_OFF,
12235 htab->got->contents);
12236
12237 /* Set .got entry size. */
12238 elf_section_data (htab->got->output_section)->this_hdr.sh_entsize = 8;
12239 }
12240
12241 if (htab->plt != NULL && htab->plt->size != 0)
12242 {
12243 /* Set .plt entry size. */
12244 elf_section_data (htab->plt->output_section)->this_hdr.sh_entsize
12245 = PLT_ENTRY_SIZE;
12246 }
12247
12248 /* brlt is SEC_LINKER_CREATED, so we need to write out relocs for
12249 brlt ourselves if emitrelocations. */
12250 if (htab->brlt != NULL
12251 && htab->brlt->reloc_count != 0
12252 && !_bfd_elf_link_output_relocs (output_bfd,
12253 htab->brlt,
12254 &elf_section_data (htab->brlt)->rel_hdr,
12255 elf_section_data (htab->brlt)->relocs,
12256 NULL))
12257 return FALSE;
12258
12259 if (htab->glink != NULL
12260 && htab->glink->reloc_count != 0
12261 && !_bfd_elf_link_output_relocs (output_bfd,
12262 htab->glink,
12263 &elf_section_data (htab->glink)->rel_hdr,
12264 elf_section_data (htab->glink)->relocs,
12265 NULL))
12266 return FALSE;
12267
12268 /* We need to handle writing out multiple GOT sections ourselves,
12269 since we didn't add them to DYNOBJ. We know dynobj is the first
12270 bfd. */
12271 while ((dynobj = dynobj->link_next) != NULL)
12272 {
12273 asection *s;
12274
12275 if (!is_ppc64_elf (dynobj))
12276 continue;
12277
12278 s = ppc64_elf_tdata (dynobj)->got;
12279 if (s != NULL
12280 && s->size != 0
12281 && s->output_section != bfd_abs_section_ptr
12282 && !bfd_set_section_contents (output_bfd, s->output_section,
12283 s->contents, s->output_offset,
12284 s->size))
12285 return FALSE;
12286 s = ppc64_elf_tdata (dynobj)->relgot;
12287 if (s != NULL
12288 && s->size != 0
12289 && s->output_section != bfd_abs_section_ptr
12290 && !bfd_set_section_contents (output_bfd, s->output_section,
12291 s->contents, s->output_offset,
12292 s->size))
12293 return FALSE;
12294 }
12295
12296 return TRUE;
12297 }
12298
12299 #include "elf64-target.h"