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