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