projects / deliverable / binutils-gdb.git / blob
? search:


37701f252c6825f27c3ec97c55b9e286d9ddbc7e
[deliverable/binutils-gdb.git] / bfd / elf64-ppc.c
1 /* PowerPC64-specific support for 64-bit ELF.
2 Copyright 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008,
3 2009, 2010 Free Software Foundation, Inc.
4 Written by Linus Nordberg, Swox AB <info@swox.com>,
5 based on elf32-ppc.c by Ian Lance Taylor.
6 Largely rewritten by Alan Modra.
7
8 This file is part of BFD, the Binary File Descriptor library.
9
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3 of the License, or
13 (at your option) any later version.
14
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
19
20 You should have received a copy of the GNU General Public License along
21 with this program; if not, write to the Free Software Foundation, Inc.,
22 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */
23
24
25 /* The 64-bit PowerPC ELF ABI may be found at
26 http://www.linuxbase.org/spec/ELF/ppc64/PPC-elf64abi.txt, and
27 http://www.linuxbase.org/spec/ELF/ppc64/spec/book1.html */
28
29 #include "sysdep.h"
30 #include <stdarg.h>
31 #include "bfd.h"
32 #include "bfdlink.h"
33 #include "libbfd.h"
34 #include "elf-bfd.h"
35 #include "elf/ppc64.h"
36 #include "elf64-ppc.h"
37
38 static bfd_reloc_status_type ppc64_elf_ha_reloc
39 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
40 static bfd_reloc_status_type ppc64_elf_branch_reloc
41 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
42 static bfd_reloc_status_type ppc64_elf_brtaken_reloc
43 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
44 static bfd_reloc_status_type ppc64_elf_sectoff_reloc
45 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
46 static bfd_reloc_status_type ppc64_elf_sectoff_ha_reloc
47 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
48 static bfd_reloc_status_type ppc64_elf_toc_reloc
49 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
50 static bfd_reloc_status_type ppc64_elf_toc_ha_reloc
51 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
52 static bfd_reloc_status_type ppc64_elf_toc64_reloc
53 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
54 static bfd_reloc_status_type ppc64_elf_unhandled_reloc
55 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
56 static bfd_vma opd_entry_value
57 (asection *, bfd_vma, asection **, bfd_vma *);
58
59 #define TARGET_LITTLE_SYM bfd_elf64_powerpcle_vec
60 #define TARGET_LITTLE_NAME "elf64-powerpcle"
61 #define TARGET_BIG_SYM bfd_elf64_powerpc_vec
62 #define TARGET_BIG_NAME "elf64-powerpc"
63 #define ELF_ARCH bfd_arch_powerpc
64 #define ELF_MACHINE_CODE EM_PPC64
65 #define ELF_MAXPAGESIZE 0x10000
66 #define ELF_COMMONPAGESIZE 0x1000
67 #define elf_info_to_howto ppc64_elf_info_to_howto
68
69 #define elf_backend_want_got_sym 0
70 #define elf_backend_want_plt_sym 0
71 #define elf_backend_plt_alignment 3
72 #define elf_backend_plt_not_loaded 1
73 #define elf_backend_got_header_size 8
74 #define elf_backend_can_gc_sections 1
75 #define elf_backend_can_refcount 1
76 #define elf_backend_rela_normal 1
77 #define elf_backend_default_execstack 0
78
79 #define bfd_elf64_mkobject ppc64_elf_mkobject
80 #define bfd_elf64_bfd_reloc_type_lookup ppc64_elf_reloc_type_lookup
81 #define bfd_elf64_bfd_reloc_name_lookup ppc64_elf_reloc_name_lookup
82 #define bfd_elf64_bfd_merge_private_bfd_data ppc64_elf_merge_private_bfd_data
83 #define bfd_elf64_new_section_hook ppc64_elf_new_section_hook
84 #define bfd_elf64_bfd_link_hash_table_create ppc64_elf_link_hash_table_create
85 #define bfd_elf64_bfd_link_hash_table_free ppc64_elf_link_hash_table_free
86 #define bfd_elf64_get_synthetic_symtab ppc64_elf_get_synthetic_symtab
87
88 #define elf_backend_object_p ppc64_elf_object_p
89 #define elf_backend_grok_prstatus ppc64_elf_grok_prstatus
90 #define elf_backend_grok_psinfo ppc64_elf_grok_psinfo
91 #define elf_backend_write_core_note ppc64_elf_write_core_note
92 #define elf_backend_create_dynamic_sections ppc64_elf_create_dynamic_sections
93 #define elf_backend_copy_indirect_symbol ppc64_elf_copy_indirect_symbol
94 #define elf_backend_add_symbol_hook ppc64_elf_add_symbol_hook
95 #define elf_backend_check_directives ppc64_elf_process_dot_syms
96 #define elf_backend_as_needed_cleanup ppc64_elf_as_needed_cleanup
97 #define elf_backend_archive_symbol_lookup ppc64_elf_archive_symbol_lookup
98 #define elf_backend_check_relocs ppc64_elf_check_relocs
99 #define elf_backend_gc_keep ppc64_elf_gc_keep
100 #define elf_backend_gc_mark_dynamic_ref ppc64_elf_gc_mark_dynamic_ref
101 #define elf_backend_gc_mark_hook ppc64_elf_gc_mark_hook
102 #define elf_backend_gc_sweep_hook ppc64_elf_gc_sweep_hook
103 #define elf_backend_adjust_dynamic_symbol ppc64_elf_adjust_dynamic_symbol
104 #define elf_backend_hide_symbol ppc64_elf_hide_symbol
105 #define elf_backend_always_size_sections ppc64_elf_func_desc_adjust
106 #define elf_backend_size_dynamic_sections ppc64_elf_size_dynamic_sections
107 #define elf_backend_init_index_section _bfd_elf_init_2_index_sections
108 #define elf_backend_action_discarded ppc64_elf_action_discarded
109 #define elf_backend_relocate_section ppc64_elf_relocate_section
110 #define elf_backend_finish_dynamic_symbol ppc64_elf_finish_dynamic_symbol
111 #define elf_backend_reloc_type_class ppc64_elf_reloc_type_class
112 #define elf_backend_finish_dynamic_sections ppc64_elf_finish_dynamic_sections
113 #define elf_backend_link_output_symbol_hook ppc64_elf_output_symbol_hook
114 #define elf_backend_special_sections ppc64_elf_special_sections
115 #define elf_backend_post_process_headers _bfd_elf_set_osabi
116
117 /* The name of the dynamic interpreter. This is put in the .interp
118 section. */
119 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
120
121 /* The size in bytes of an entry in the procedure linkage table. */
122 #define PLT_ENTRY_SIZE 24
123
124 /* The initial size of the plt reserved for the dynamic linker. */
125 #define PLT_INITIAL_ENTRY_SIZE PLT_ENTRY_SIZE
126
127 /* TOC base pointers offset from start of TOC. */
128 #define TOC_BASE_OFF 0x8000
129
130 /* Offset of tp and dtp pointers from start of TLS block. */
131 #define TP_OFFSET 0x7000
132 #define DTP_OFFSET 0x8000
133
134 /* .plt call stub instructions. The normal stub is like this, but
135 sometimes the .plt entry crosses a 64k boundary and we need to
136 insert an addi to adjust r12. */
137 #define PLT_CALL_STUB_SIZE (7*4)
138 #define ADDIS_R12_R2 0x3d820000 /* addis %r12,%r2,xxx@ha */
139 #define STD_R2_40R1 0xf8410028 /* std %r2,40(%r1) */
140 #define LD_R11_0R12 0xe96c0000 /* ld %r11,xxx+0@l(%r12) */
141 #define MTCTR_R11 0x7d6903a6 /* mtctr %r11 */
142 #define LD_R2_0R12 0xe84c0000 /* ld %r2,xxx+8@l(%r12) */
143 /* ld %r11,xxx+16@l(%r12) */
144 #define BCTR 0x4e800420 /* bctr */
145
146
147 #define ADDIS_R12_R12 0x3d8c0000 /* addis %r12,%r12,off@ha */
148 #define ADDI_R12_R12 0x398c0000 /* addi %r12,%r12,off@l */
149 #define ADDIS_R2_R2 0x3c420000 /* addis %r2,%r2,off@ha */
150 #define ADDI_R2_R2 0x38420000 /* addi %r2,%r2,off@l */
151
152 #define LD_R11_0R2 0xe9620000 /* ld %r11,xxx+0(%r2) */
153 #define LD_R2_0R2 0xe8420000 /* ld %r2,xxx+0(%r2) */
154
155 #define LD_R2_40R1 0xe8410028 /* ld %r2,40(%r1) */
156
157 /* glink call stub instructions. We enter with the index in R0. */
158 #define GLINK_CALL_STUB_SIZE (16*4)
159 /* 0: */
160 /* .quad plt0-1f */
161 /* __glink: */
162 #define MFLR_R12 0x7d8802a6 /* mflr %12 */
163 #define BCL_20_31 0x429f0005 /* bcl 20,31,1f */
164 /* 1: */
165 #define MFLR_R11 0x7d6802a6 /* mflr %11 */
166 #define LD_R2_M16R11 0xe84bfff0 /* ld %2,(0b-1b)(%11) */
167 #define MTLR_R12 0x7d8803a6 /* mtlr %12 */
168 #define ADD_R12_R2_R11 0x7d825a14 /* add %12,%2,%11 */
169 /* ld %11,0(%12) */
170 /* ld %2,8(%12) */
171 /* mtctr %11 */
172 /* ld %11,16(%12) */
173 /* bctr */
174
175 /* Pad with this. */
176 #define NOP 0x60000000
177
178 /* Some other nops. */
179 #define CROR_151515 0x4def7b82
180 #define CROR_313131 0x4ffffb82
181
182 /* .glink entries for the first 32k functions are two instructions. */
183 #define LI_R0_0 0x38000000 /* li %r0,0 */
184 #define B_DOT 0x48000000 /* b . */
185
186 /* After that, we need two instructions to load the index, followed by
187 a branch. */
188 #define LIS_R0_0 0x3c000000 /* lis %r0,0 */
189 #define ORI_R0_R0_0 0x60000000 /* ori %r0,%r0,0 */
190
191 /* Instructions used by the save and restore reg functions. */
192 #define STD_R0_0R1 0xf8010000 /* std %r0,0(%r1) */
193 #define STD_R0_0R12 0xf80c0000 /* std %r0,0(%r12) */
194 #define LD_R0_0R1 0xe8010000 /* ld %r0,0(%r1) */
195 #define LD_R0_0R12 0xe80c0000 /* ld %r0,0(%r12) */
196 #define STFD_FR0_0R1 0xd8010000 /* stfd %fr0,0(%r1) */
197 #define LFD_FR0_0R1 0xc8010000 /* lfd %fr0,0(%r1) */
198 #define LI_R12_0 0x39800000 /* li %r12,0 */
199 #define STVX_VR0_R12_R0 0x7c0c01ce /* stvx %v0,%r12,%r0 */
200 #define LVX_VR0_R12_R0 0x7c0c00ce /* lvx %v0,%r12,%r0 */
201 #define MTLR_R0 0x7c0803a6 /* mtlr %r0 */
202 #define BLR 0x4e800020 /* blr */
203
204 /* Since .opd is an array of descriptors and each entry will end up
205 with identical R_PPC64_RELATIVE relocs, there is really no need to
206 propagate .opd relocs; The dynamic linker should be taught to
207 relocate .opd without reloc entries. */
208 #ifndef NO_OPD_RELOCS
209 #define NO_OPD_RELOCS 0
210 #endif
211 \f
212 #define ONES(n) (((bfd_vma) 1 << ((n) - 1) << 1) - 1)
213
214 /* Relocation HOWTO's. */
215 static reloc_howto_type *ppc64_elf_howto_table[(int) R_PPC64_max];
216
217 static reloc_howto_type ppc64_elf_howto_raw[] = {
218 /* This reloc does nothing. */
219 HOWTO (R_PPC64_NONE, /* type */
220 0, /* rightshift */
221 2, /* size (0 = byte, 1 = short, 2 = long) */
222 32, /* bitsize */
223 FALSE, /* pc_relative */
224 0, /* bitpos */
225 complain_overflow_dont, /* complain_on_overflow */
226 bfd_elf_generic_reloc, /* special_function */
227 "R_PPC64_NONE", /* name */
228 FALSE, /* partial_inplace */
229 0, /* src_mask */
230 0, /* dst_mask */
231 FALSE), /* pcrel_offset */
232
233 /* A standard 32 bit relocation. */
234 HOWTO (R_PPC64_ADDR32, /* type */
235 0, /* rightshift */
236 2, /* size (0 = byte, 1 = short, 2 = long) */
237 32, /* bitsize */
238 FALSE, /* pc_relative */
239 0, /* bitpos */
240 complain_overflow_bitfield, /* complain_on_overflow */
241 bfd_elf_generic_reloc, /* special_function */
242 "R_PPC64_ADDR32", /* name */
243 FALSE, /* partial_inplace */
244 0, /* src_mask */
245 0xffffffff, /* dst_mask */
246 FALSE), /* pcrel_offset */
247
248 /* An absolute 26 bit branch; the lower two bits must be zero.
249 FIXME: we don't check that, we just clear them. */
250 HOWTO (R_PPC64_ADDR24, /* type */
251 0, /* rightshift */
252 2, /* size (0 = byte, 1 = short, 2 = long) */
253 26, /* bitsize */
254 FALSE, /* pc_relative */
255 0, /* bitpos */
256 complain_overflow_bitfield, /* complain_on_overflow */
257 bfd_elf_generic_reloc, /* special_function */
258 "R_PPC64_ADDR24", /* name */
259 FALSE, /* partial_inplace */
260 0, /* src_mask */
261 0x03fffffc, /* dst_mask */
262 FALSE), /* pcrel_offset */
263
264 /* A standard 16 bit relocation. */
265 HOWTO (R_PPC64_ADDR16, /* type */
266 0, /* rightshift */
267 1, /* size (0 = byte, 1 = short, 2 = long) */
268 16, /* bitsize */
269 FALSE, /* pc_relative */
270 0, /* bitpos */
271 complain_overflow_bitfield, /* complain_on_overflow */
272 bfd_elf_generic_reloc, /* special_function */
273 "R_PPC64_ADDR16", /* name */
274 FALSE, /* partial_inplace */
275 0, /* src_mask */
276 0xffff, /* dst_mask */
277 FALSE), /* pcrel_offset */
278
279 /* A 16 bit relocation without overflow. */
280 HOWTO (R_PPC64_ADDR16_LO, /* type */
281 0, /* rightshift */
282 1, /* size (0 = byte, 1 = short, 2 = long) */
283 16, /* bitsize */
284 FALSE, /* pc_relative */
285 0, /* bitpos */
286 complain_overflow_dont,/* complain_on_overflow */
287 bfd_elf_generic_reloc, /* special_function */
288 "R_PPC64_ADDR16_LO", /* name */
289 FALSE, /* partial_inplace */
290 0, /* src_mask */
291 0xffff, /* dst_mask */
292 FALSE), /* pcrel_offset */
293
294 /* Bits 16-31 of an address. */
295 HOWTO (R_PPC64_ADDR16_HI, /* type */
296 16, /* rightshift */
297 1, /* size (0 = byte, 1 = short, 2 = long) */
298 16, /* bitsize */
299 FALSE, /* pc_relative */
300 0, /* bitpos */
301 complain_overflow_dont, /* complain_on_overflow */
302 bfd_elf_generic_reloc, /* special_function */
303 "R_PPC64_ADDR16_HI", /* name */
304 FALSE, /* partial_inplace */
305 0, /* src_mask */
306 0xffff, /* dst_mask */
307 FALSE), /* pcrel_offset */
308
309 /* Bits 16-31 of an address, plus 1 if the contents of the low 16
310 bits, treated as a signed number, is negative. */
311 HOWTO (R_PPC64_ADDR16_HA, /* type */
312 16, /* rightshift */
313 1, /* size (0 = byte, 1 = short, 2 = long) */
314 16, /* bitsize */
315 FALSE, /* pc_relative */
316 0, /* bitpos */
317 complain_overflow_dont, /* complain_on_overflow */
318 ppc64_elf_ha_reloc, /* special_function */
319 "R_PPC64_ADDR16_HA", /* name */
320 FALSE, /* partial_inplace */
321 0, /* src_mask */
322 0xffff, /* dst_mask */
323 FALSE), /* pcrel_offset */
324
325 /* An absolute 16 bit branch; the lower two bits must be zero.
326 FIXME: we don't check that, we just clear them. */
327 HOWTO (R_PPC64_ADDR14, /* type */
328 0, /* rightshift */
329 2, /* size (0 = byte, 1 = short, 2 = long) */
330 16, /* bitsize */
331 FALSE, /* pc_relative */
332 0, /* bitpos */
333 complain_overflow_bitfield, /* complain_on_overflow */
334 ppc64_elf_branch_reloc, /* special_function */
335 "R_PPC64_ADDR14", /* name */
336 FALSE, /* partial_inplace */
337 0, /* src_mask */
338 0x0000fffc, /* dst_mask */
339 FALSE), /* pcrel_offset */
340
341 /* An absolute 16 bit branch, for which bit 10 should be set to
342 indicate that the branch is expected to be taken. The lower two
343 bits must be zero. */
344 HOWTO (R_PPC64_ADDR14_BRTAKEN, /* type */
345 0, /* rightshift */
346 2, /* size (0 = byte, 1 = short, 2 = long) */
347 16, /* bitsize */
348 FALSE, /* pc_relative */
349 0, /* bitpos */
350 complain_overflow_bitfield, /* complain_on_overflow */
351 ppc64_elf_brtaken_reloc, /* special_function */
352 "R_PPC64_ADDR14_BRTAKEN",/* name */
353 FALSE, /* partial_inplace */
354 0, /* src_mask */
355 0x0000fffc, /* dst_mask */
356 FALSE), /* pcrel_offset */
357
358 /* An absolute 16 bit branch, for which bit 10 should be set to
359 indicate that the branch is not expected to be taken. The lower
360 two bits must be zero. */
361 HOWTO (R_PPC64_ADDR14_BRNTAKEN, /* type */
362 0, /* rightshift */
363 2, /* size (0 = byte, 1 = short, 2 = long) */
364 16, /* bitsize */
365 FALSE, /* pc_relative */
366 0, /* bitpos */
367 complain_overflow_bitfield, /* complain_on_overflow */
368 ppc64_elf_brtaken_reloc, /* special_function */
369 "R_PPC64_ADDR14_BRNTAKEN",/* name */
370 FALSE, /* partial_inplace */
371 0, /* src_mask */
372 0x0000fffc, /* dst_mask */
373 FALSE), /* pcrel_offset */
374
375 /* A relative 26 bit branch; the lower two bits must be zero. */
376 HOWTO (R_PPC64_REL24, /* type */
377 0, /* rightshift */
378 2, /* size (0 = byte, 1 = short, 2 = long) */
379 26, /* bitsize */
380 TRUE, /* pc_relative */
381 0, /* bitpos */
382 complain_overflow_signed, /* complain_on_overflow */
383 ppc64_elf_branch_reloc, /* special_function */
384 "R_PPC64_REL24", /* name */
385 FALSE, /* partial_inplace */
386 0, /* src_mask */
387 0x03fffffc, /* dst_mask */
388 TRUE), /* pcrel_offset */
389
390 /* A relative 16 bit branch; the lower two bits must be zero. */
391 HOWTO (R_PPC64_REL14, /* type */
392 0, /* rightshift */
393 2, /* size (0 = byte, 1 = short, 2 = long) */
394 16, /* bitsize */
395 TRUE, /* pc_relative */
396 0, /* bitpos */
397 complain_overflow_signed, /* complain_on_overflow */
398 ppc64_elf_branch_reloc, /* special_function */
399 "R_PPC64_REL14", /* name */
400 FALSE, /* partial_inplace */
401 0, /* src_mask */
402 0x0000fffc, /* dst_mask */
403 TRUE), /* pcrel_offset */
404
405 /* A relative 16 bit branch. Bit 10 should be set to indicate that
406 the branch is expected to be taken. The lower two bits must be
407 zero. */
408 HOWTO (R_PPC64_REL14_BRTAKEN, /* type */
409 0, /* rightshift */
410 2, /* size (0 = byte, 1 = short, 2 = long) */
411 16, /* bitsize */
412 TRUE, /* pc_relative */
413 0, /* bitpos */
414 complain_overflow_signed, /* complain_on_overflow */
415 ppc64_elf_brtaken_reloc, /* special_function */
416 "R_PPC64_REL14_BRTAKEN", /* name */
417 FALSE, /* partial_inplace */
418 0, /* src_mask */
419 0x0000fffc, /* dst_mask */
420 TRUE), /* pcrel_offset */
421
422 /* A relative 16 bit branch. Bit 10 should be set to indicate that
423 the branch is not expected to be taken. The lower two bits must
424 be zero. */
425 HOWTO (R_PPC64_REL14_BRNTAKEN, /* type */
426 0, /* rightshift */
427 2, /* size (0 = byte, 1 = short, 2 = long) */
428 16, /* bitsize */
429 TRUE, /* pc_relative */
430 0, /* bitpos */
431 complain_overflow_signed, /* complain_on_overflow */
432 ppc64_elf_brtaken_reloc, /* special_function */
433 "R_PPC64_REL14_BRNTAKEN",/* name */
434 FALSE, /* partial_inplace */
435 0, /* src_mask */
436 0x0000fffc, /* dst_mask */
437 TRUE), /* pcrel_offset */
438
439 /* Like R_PPC64_ADDR16, but referring to the GOT table entry for the
440 symbol. */
441 HOWTO (R_PPC64_GOT16, /* type */
442 0, /* rightshift */
443 1, /* size (0 = byte, 1 = short, 2 = long) */
444 16, /* bitsize */
445 FALSE, /* pc_relative */
446 0, /* bitpos */
447 complain_overflow_signed, /* complain_on_overflow */
448 ppc64_elf_unhandled_reloc, /* special_function */
449 "R_PPC64_GOT16", /* name */
450 FALSE, /* partial_inplace */
451 0, /* src_mask */
452 0xffff, /* dst_mask */
453 FALSE), /* pcrel_offset */
454
455 /* Like R_PPC64_ADDR16_LO, but referring to the GOT table entry for
456 the symbol. */
457 HOWTO (R_PPC64_GOT16_LO, /* type */
458 0, /* rightshift */
459 1, /* size (0 = byte, 1 = short, 2 = long) */
460 16, /* bitsize */
461 FALSE, /* pc_relative */
462 0, /* bitpos */
463 complain_overflow_dont, /* complain_on_overflow */
464 ppc64_elf_unhandled_reloc, /* special_function */
465 "R_PPC64_GOT16_LO", /* name */
466 FALSE, /* partial_inplace */
467 0, /* src_mask */
468 0xffff, /* dst_mask */
469 FALSE), /* pcrel_offset */
470
471 /* Like R_PPC64_ADDR16_HI, but referring to the GOT table entry for
472 the symbol. */
473 HOWTO (R_PPC64_GOT16_HI, /* type */
474 16, /* rightshift */
475 1, /* size (0 = byte, 1 = short, 2 = long) */
476 16, /* bitsize */
477 FALSE, /* pc_relative */
478 0, /* bitpos */
479 complain_overflow_dont,/* complain_on_overflow */
480 ppc64_elf_unhandled_reloc, /* special_function */
481 "R_PPC64_GOT16_HI", /* name */
482 FALSE, /* partial_inplace */
483 0, /* src_mask */
484 0xffff, /* dst_mask */
485 FALSE), /* pcrel_offset */
486
487 /* Like R_PPC64_ADDR16_HA, but referring to the GOT table entry for
488 the symbol. */
489 HOWTO (R_PPC64_GOT16_HA, /* type */
490 16, /* rightshift */
491 1, /* size (0 = byte, 1 = short, 2 = long) */
492 16, /* bitsize */
493 FALSE, /* pc_relative */
494 0, /* bitpos */
495 complain_overflow_dont,/* complain_on_overflow */
496 ppc64_elf_unhandled_reloc, /* special_function */
497 "R_PPC64_GOT16_HA", /* name */
498 FALSE, /* partial_inplace */
499 0, /* src_mask */
500 0xffff, /* dst_mask */
501 FALSE), /* pcrel_offset */
502
503 /* This is used only by the dynamic linker. The symbol should exist
504 both in the object being run and in some shared library. The
505 dynamic linker copies the data addressed by the symbol from the
506 shared library into the object, because the object being
507 run has to have the data at some particular address. */
508 HOWTO (R_PPC64_COPY, /* type */
509 0, /* rightshift */
510 0, /* this one is variable size */
511 0, /* bitsize */
512 FALSE, /* pc_relative */
513 0, /* bitpos */
514 complain_overflow_dont, /* complain_on_overflow */
515 ppc64_elf_unhandled_reloc, /* special_function */
516 "R_PPC64_COPY", /* name */
517 FALSE, /* partial_inplace */
518 0, /* src_mask */
519 0, /* dst_mask */
520 FALSE), /* pcrel_offset */
521
522 /* Like R_PPC64_ADDR64, but used when setting global offset table
523 entries. */
524 HOWTO (R_PPC64_GLOB_DAT, /* type */
525 0, /* rightshift */
526 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
527 64, /* bitsize */
528 FALSE, /* pc_relative */
529 0, /* bitpos */
530 complain_overflow_dont, /* complain_on_overflow */
531 ppc64_elf_unhandled_reloc, /* special_function */
532 "R_PPC64_GLOB_DAT", /* name */
533 FALSE, /* partial_inplace */
534 0, /* src_mask */
535 ONES (64), /* dst_mask */
536 FALSE), /* pcrel_offset */
537
538 /* Created by the link editor. Marks a procedure linkage table
539 entry for a symbol. */
540 HOWTO (R_PPC64_JMP_SLOT, /* type */
541 0, /* rightshift */
542 0, /* size (0 = byte, 1 = short, 2 = long) */
543 0, /* bitsize */
544 FALSE, /* pc_relative */
545 0, /* bitpos */
546 complain_overflow_dont, /* complain_on_overflow */
547 ppc64_elf_unhandled_reloc, /* special_function */
548 "R_PPC64_JMP_SLOT", /* name */
549 FALSE, /* partial_inplace */
550 0, /* src_mask */
551 0, /* dst_mask */
552 FALSE), /* pcrel_offset */
553
554 /* Used only by the dynamic linker. When the object is run, this
555 doubleword64 is set to the load address of the object, plus the
556 addend. */
557 HOWTO (R_PPC64_RELATIVE, /* type */
558 0, /* rightshift */
559 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
560 64, /* bitsize */
561 FALSE, /* pc_relative */
562 0, /* bitpos */
563 complain_overflow_dont, /* complain_on_overflow */
564 bfd_elf_generic_reloc, /* special_function */
565 "R_PPC64_RELATIVE", /* name */
566 FALSE, /* partial_inplace */
567 0, /* src_mask */
568 ONES (64), /* dst_mask */
569 FALSE), /* pcrel_offset */
570
571 /* Like R_PPC64_ADDR32, but may be unaligned. */
572 HOWTO (R_PPC64_UADDR32, /* type */
573 0, /* rightshift */
574 2, /* size (0 = byte, 1 = short, 2 = long) */
575 32, /* bitsize */
576 FALSE, /* pc_relative */
577 0, /* bitpos */
578 complain_overflow_bitfield, /* complain_on_overflow */
579 bfd_elf_generic_reloc, /* special_function */
580 "R_PPC64_UADDR32", /* name */
581 FALSE, /* partial_inplace */
582 0, /* src_mask */
583 0xffffffff, /* dst_mask */
584 FALSE), /* pcrel_offset */
585
586 /* Like R_PPC64_ADDR16, but may be unaligned. */
587 HOWTO (R_PPC64_UADDR16, /* type */
588 0, /* rightshift */
589 1, /* size (0 = byte, 1 = short, 2 = long) */
590 16, /* bitsize */
591 FALSE, /* pc_relative */
592 0, /* bitpos */
593 complain_overflow_bitfield, /* complain_on_overflow */
594 bfd_elf_generic_reloc, /* special_function */
595 "R_PPC64_UADDR16", /* name */
596 FALSE, /* partial_inplace */
597 0, /* src_mask */
598 0xffff, /* dst_mask */
599 FALSE), /* pcrel_offset */
600
601 /* 32-bit PC relative. */
602 HOWTO (R_PPC64_REL32, /* type */
603 0, /* rightshift */
604 2, /* size (0 = byte, 1 = short, 2 = long) */
605 32, /* bitsize */
606 TRUE, /* pc_relative */
607 0, /* bitpos */
608 /* FIXME: Verify. Was complain_overflow_bitfield. */
609 complain_overflow_signed, /* complain_on_overflow */
610 bfd_elf_generic_reloc, /* special_function */
611 "R_PPC64_REL32", /* name */
612 FALSE, /* partial_inplace */
613 0, /* src_mask */
614 0xffffffff, /* dst_mask */
615 TRUE), /* pcrel_offset */
616
617 /* 32-bit relocation to the symbol's procedure linkage table. */
618 HOWTO (R_PPC64_PLT32, /* type */
619 0, /* rightshift */
620 2, /* size (0 = byte, 1 = short, 2 = long) */
621 32, /* bitsize */
622 FALSE, /* pc_relative */
623 0, /* bitpos */
624 complain_overflow_bitfield, /* complain_on_overflow */
625 ppc64_elf_unhandled_reloc, /* special_function */
626 "R_PPC64_PLT32", /* name */
627 FALSE, /* partial_inplace */
628 0, /* src_mask */
629 0xffffffff, /* dst_mask */
630 FALSE), /* pcrel_offset */
631
632 /* 32-bit PC relative relocation to the symbol's procedure linkage table.
633 FIXME: R_PPC64_PLTREL32 not supported. */
634 HOWTO (R_PPC64_PLTREL32, /* type */
635 0, /* rightshift */
636 2, /* size (0 = byte, 1 = short, 2 = long) */
637 32, /* bitsize */
638 TRUE, /* pc_relative */
639 0, /* bitpos */
640 complain_overflow_signed, /* complain_on_overflow */
641 bfd_elf_generic_reloc, /* special_function */
642 "R_PPC64_PLTREL32", /* name */
643 FALSE, /* partial_inplace */
644 0, /* src_mask */
645 0xffffffff, /* dst_mask */
646 TRUE), /* pcrel_offset */
647
648 /* Like R_PPC64_ADDR16_LO, but referring to the PLT table entry for
649 the symbol. */
650 HOWTO (R_PPC64_PLT16_LO, /* type */
651 0, /* rightshift */
652 1, /* size (0 = byte, 1 = short, 2 = long) */
653 16, /* bitsize */
654 FALSE, /* pc_relative */
655 0, /* bitpos */
656 complain_overflow_dont, /* complain_on_overflow */
657 ppc64_elf_unhandled_reloc, /* special_function */
658 "R_PPC64_PLT16_LO", /* name */
659 FALSE, /* partial_inplace */
660 0, /* src_mask */
661 0xffff, /* dst_mask */
662 FALSE), /* pcrel_offset */
663
664 /* Like R_PPC64_ADDR16_HI, but referring to the PLT table entry for
665 the symbol. */
666 HOWTO (R_PPC64_PLT16_HI, /* type */
667 16, /* rightshift */
668 1, /* size (0 = byte, 1 = short, 2 = long) */
669 16, /* bitsize */
670 FALSE, /* pc_relative */
671 0, /* bitpos */
672 complain_overflow_dont, /* complain_on_overflow */
673 ppc64_elf_unhandled_reloc, /* special_function */
674 "R_PPC64_PLT16_HI", /* name */
675 FALSE, /* partial_inplace */
676 0, /* src_mask */
677 0xffff, /* dst_mask */
678 FALSE), /* pcrel_offset */
679
680 /* Like R_PPC64_ADDR16_HA, but referring to the PLT table entry for
681 the symbol. */
682 HOWTO (R_PPC64_PLT16_HA, /* type */
683 16, /* rightshift */
684 1, /* size (0 = byte, 1 = short, 2 = long) */
685 16, /* bitsize */
686 FALSE, /* pc_relative */
687 0, /* bitpos */
688 complain_overflow_dont, /* complain_on_overflow */
689 ppc64_elf_unhandled_reloc, /* special_function */
690 "R_PPC64_PLT16_HA", /* name */
691 FALSE, /* partial_inplace */
692 0, /* src_mask */
693 0xffff, /* dst_mask */
694 FALSE), /* pcrel_offset */
695
696 /* 16-bit section relative relocation. */
697 HOWTO (R_PPC64_SECTOFF, /* type */
698 0, /* rightshift */
699 1, /* size (0 = byte, 1 = short, 2 = long) */
700 16, /* bitsize */
701 FALSE, /* pc_relative */
702 0, /* bitpos */
703 complain_overflow_bitfield, /* complain_on_overflow */
704 ppc64_elf_sectoff_reloc, /* special_function */
705 "R_PPC64_SECTOFF", /* name */
706 FALSE, /* partial_inplace */
707 0, /* src_mask */
708 0xffff, /* dst_mask */
709 FALSE), /* pcrel_offset */
710
711 /* Like R_PPC64_SECTOFF, but no overflow warning. */
712 HOWTO (R_PPC64_SECTOFF_LO, /* type */
713 0, /* rightshift */
714 1, /* size (0 = byte, 1 = short, 2 = long) */
715 16, /* bitsize */
716 FALSE, /* pc_relative */
717 0, /* bitpos */
718 complain_overflow_dont, /* complain_on_overflow */
719 ppc64_elf_sectoff_reloc, /* special_function */
720 "R_PPC64_SECTOFF_LO", /* name */
721 FALSE, /* partial_inplace */
722 0, /* src_mask */
723 0xffff, /* dst_mask */
724 FALSE), /* pcrel_offset */
725
726 /* 16-bit upper half section relative relocation. */
727 HOWTO (R_PPC64_SECTOFF_HI, /* type */
728 16, /* rightshift */
729 1, /* size (0 = byte, 1 = short, 2 = long) */
730 16, /* bitsize */
731 FALSE, /* pc_relative */
732 0, /* bitpos */
733 complain_overflow_dont, /* complain_on_overflow */
734 ppc64_elf_sectoff_reloc, /* special_function */
735 "R_PPC64_SECTOFF_HI", /* name */
736 FALSE, /* partial_inplace */
737 0, /* src_mask */
738 0xffff, /* dst_mask */
739 FALSE), /* pcrel_offset */
740
741 /* 16-bit upper half adjusted section relative relocation. */
742 HOWTO (R_PPC64_SECTOFF_HA, /* type */
743 16, /* rightshift */
744 1, /* size (0 = byte, 1 = short, 2 = long) */
745 16, /* bitsize */
746 FALSE, /* pc_relative */
747 0, /* bitpos */
748 complain_overflow_dont, /* complain_on_overflow */
749 ppc64_elf_sectoff_ha_reloc, /* special_function */
750 "R_PPC64_SECTOFF_HA", /* name */
751 FALSE, /* partial_inplace */
752 0, /* src_mask */
753 0xffff, /* dst_mask */
754 FALSE), /* pcrel_offset */
755
756 /* Like R_PPC64_REL24 without touching the two least significant bits. */
757 HOWTO (R_PPC64_REL30, /* type */
758 2, /* rightshift */
759 2, /* size (0 = byte, 1 = short, 2 = long) */
760 30, /* bitsize */
761 TRUE, /* pc_relative */
762 0, /* bitpos */
763 complain_overflow_dont, /* complain_on_overflow */
764 bfd_elf_generic_reloc, /* special_function */
765 "R_PPC64_REL30", /* name */
766 FALSE, /* partial_inplace */
767 0, /* src_mask */
768 0xfffffffc, /* dst_mask */
769 TRUE), /* pcrel_offset */
770
771 /* Relocs in the 64-bit PowerPC ELF ABI, not in the 32-bit ABI. */
772
773 /* A standard 64-bit relocation. */
774 HOWTO (R_PPC64_ADDR64, /* type */
775 0, /* rightshift */
776 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
777 64, /* bitsize */
778 FALSE, /* pc_relative */
779 0, /* bitpos */
780 complain_overflow_dont, /* complain_on_overflow */
781 bfd_elf_generic_reloc, /* special_function */
782 "R_PPC64_ADDR64", /* name */
783 FALSE, /* partial_inplace */
784 0, /* src_mask */
785 ONES (64), /* dst_mask */
786 FALSE), /* pcrel_offset */
787
788 /* The bits 32-47 of an address. */
789 HOWTO (R_PPC64_ADDR16_HIGHER, /* type */
790 32, /* rightshift */
791 1, /* size (0 = byte, 1 = short, 2 = long) */
792 16, /* bitsize */
793 FALSE, /* pc_relative */
794 0, /* bitpos */
795 complain_overflow_dont, /* complain_on_overflow */
796 bfd_elf_generic_reloc, /* special_function */
797 "R_PPC64_ADDR16_HIGHER", /* name */
798 FALSE, /* partial_inplace */
799 0, /* src_mask */
800 0xffff, /* dst_mask */
801 FALSE), /* pcrel_offset */
802
803 /* The bits 32-47 of an address, plus 1 if the contents of the low
804 16 bits, treated as a signed number, is negative. */
805 HOWTO (R_PPC64_ADDR16_HIGHERA, /* type */
806 32, /* rightshift */
807 1, /* size (0 = byte, 1 = short, 2 = long) */
808 16, /* bitsize */
809 FALSE, /* pc_relative */
810 0, /* bitpos */
811 complain_overflow_dont, /* complain_on_overflow */
812 ppc64_elf_ha_reloc, /* special_function */
813 "R_PPC64_ADDR16_HIGHERA", /* name */
814 FALSE, /* partial_inplace */
815 0, /* src_mask */
816 0xffff, /* dst_mask */
817 FALSE), /* pcrel_offset */
818
819 /* The bits 48-63 of an address. */
820 HOWTO (R_PPC64_ADDR16_HIGHEST,/* type */
821 48, /* rightshift */
822 1, /* size (0 = byte, 1 = short, 2 = long) */
823 16, /* bitsize */
824 FALSE, /* pc_relative */
825 0, /* bitpos */
826 complain_overflow_dont, /* complain_on_overflow */
827 bfd_elf_generic_reloc, /* special_function */
828 "R_PPC64_ADDR16_HIGHEST", /* name */
829 FALSE, /* partial_inplace */
830 0, /* src_mask */
831 0xffff, /* dst_mask */
832 FALSE), /* pcrel_offset */
833
834 /* The bits 48-63 of an address, plus 1 if the contents of the low
835 16 bits, treated as a signed number, is negative. */
836 HOWTO (R_PPC64_ADDR16_HIGHESTA,/* type */
837 48, /* rightshift */
838 1, /* size (0 = byte, 1 = short, 2 = long) */
839 16, /* bitsize */
840 FALSE, /* pc_relative */
841 0, /* bitpos */
842 complain_overflow_dont, /* complain_on_overflow */
843 ppc64_elf_ha_reloc, /* special_function */
844 "R_PPC64_ADDR16_HIGHESTA", /* name */
845 FALSE, /* partial_inplace */
846 0, /* src_mask */
847 0xffff, /* dst_mask */
848 FALSE), /* pcrel_offset */
849
850 /* Like ADDR64, but may be unaligned. */
851 HOWTO (R_PPC64_UADDR64, /* type */
852 0, /* rightshift */
853 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
854 64, /* bitsize */
855 FALSE, /* pc_relative */
856 0, /* bitpos */
857 complain_overflow_dont, /* complain_on_overflow */
858 bfd_elf_generic_reloc, /* special_function */
859 "R_PPC64_UADDR64", /* name */
860 FALSE, /* partial_inplace */
861 0, /* src_mask */
862 ONES (64), /* dst_mask */
863 FALSE), /* pcrel_offset */
864
865 /* 64-bit relative relocation. */
866 HOWTO (R_PPC64_REL64, /* type */
867 0, /* rightshift */
868 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
869 64, /* bitsize */
870 TRUE, /* pc_relative */
871 0, /* bitpos */
872 complain_overflow_dont, /* complain_on_overflow */
873 bfd_elf_generic_reloc, /* special_function */
874 "R_PPC64_REL64", /* name */
875 FALSE, /* partial_inplace */
876 0, /* src_mask */
877 ONES (64), /* dst_mask */
878 TRUE), /* pcrel_offset */
879
880 /* 64-bit relocation to the symbol's procedure linkage table. */
881 HOWTO (R_PPC64_PLT64, /* type */
882 0, /* rightshift */
883 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
884 64, /* bitsize */
885 FALSE, /* pc_relative */
886 0, /* bitpos */
887 complain_overflow_dont, /* complain_on_overflow */
888 ppc64_elf_unhandled_reloc, /* special_function */
889 "R_PPC64_PLT64", /* name */
890 FALSE, /* partial_inplace */
891 0, /* src_mask */
892 ONES (64), /* dst_mask */
893 FALSE), /* pcrel_offset */
894
895 /* 64-bit PC relative relocation to the symbol's procedure linkage
896 table. */
897 /* FIXME: R_PPC64_PLTREL64 not supported. */
898 HOWTO (R_PPC64_PLTREL64, /* type */
899 0, /* rightshift */
900 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
901 64, /* bitsize */
902 TRUE, /* pc_relative */
903 0, /* bitpos */
904 complain_overflow_dont, /* complain_on_overflow */
905 ppc64_elf_unhandled_reloc, /* special_function */
906 "R_PPC64_PLTREL64", /* name */
907 FALSE, /* partial_inplace */
908 0, /* src_mask */
909 ONES (64), /* dst_mask */
910 TRUE), /* pcrel_offset */
911
912 /* 16 bit TOC-relative relocation. */
913
914 /* R_PPC64_TOC16 47 half16* S + A - .TOC. */
915 HOWTO (R_PPC64_TOC16, /* type */
916 0, /* rightshift */
917 1, /* size (0 = byte, 1 = short, 2 = long) */
918 16, /* bitsize */
919 FALSE, /* pc_relative */
920 0, /* bitpos */
921 complain_overflow_signed, /* complain_on_overflow */
922 ppc64_elf_toc_reloc, /* special_function */
923 "R_PPC64_TOC16", /* name */
924 FALSE, /* partial_inplace */
925 0, /* src_mask */
926 0xffff, /* dst_mask */
927 FALSE), /* pcrel_offset */
928
929 /* 16 bit TOC-relative relocation without overflow. */
930
931 /* R_PPC64_TOC16_LO 48 half16 #lo (S + A - .TOC.) */
932 HOWTO (R_PPC64_TOC16_LO, /* type */
933 0, /* rightshift */
934 1, /* size (0 = byte, 1 = short, 2 = long) */
935 16, /* bitsize */
936 FALSE, /* pc_relative */
937 0, /* bitpos */
938 complain_overflow_dont, /* complain_on_overflow */
939 ppc64_elf_toc_reloc, /* special_function */
940 "R_PPC64_TOC16_LO", /* name */
941 FALSE, /* partial_inplace */
942 0, /* src_mask */
943 0xffff, /* dst_mask */
944 FALSE), /* pcrel_offset */
945
946 /* 16 bit TOC-relative relocation, high 16 bits. */
947
948 /* R_PPC64_TOC16_HI 49 half16 #hi (S + A - .TOC.) */
949 HOWTO (R_PPC64_TOC16_HI, /* type */
950 16, /* rightshift */
951 1, /* size (0 = byte, 1 = short, 2 = long) */
952 16, /* bitsize */
953 FALSE, /* pc_relative */
954 0, /* bitpos */
955 complain_overflow_dont, /* complain_on_overflow */
956 ppc64_elf_toc_reloc, /* special_function */
957 "R_PPC64_TOC16_HI", /* name */
958 FALSE, /* partial_inplace */
959 0, /* src_mask */
960 0xffff, /* dst_mask */
961 FALSE), /* pcrel_offset */
962
963 /* 16 bit TOC-relative relocation, high 16 bits, plus 1 if the
964 contents of the low 16 bits, treated as a signed number, is
965 negative. */
966
967 /* R_PPC64_TOC16_HA 50 half16 #ha (S + A - .TOC.) */
968 HOWTO (R_PPC64_TOC16_HA, /* type */
969 16, /* rightshift */
970 1, /* size (0 = byte, 1 = short, 2 = long) */
971 16, /* bitsize */
972 FALSE, /* pc_relative */
973 0, /* bitpos */
974 complain_overflow_dont, /* complain_on_overflow */
975 ppc64_elf_toc_ha_reloc, /* special_function */
976 "R_PPC64_TOC16_HA", /* name */
977 FALSE, /* partial_inplace */
978 0, /* src_mask */
979 0xffff, /* dst_mask */
980 FALSE), /* pcrel_offset */
981
982 /* 64-bit relocation; insert value of TOC base (.TOC.). */
983
984 /* R_PPC64_TOC 51 doubleword64 .TOC. */
985 HOWTO (R_PPC64_TOC, /* type */
986 0, /* rightshift */
987 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
988 64, /* bitsize */
989 FALSE, /* pc_relative */
990 0, /* bitpos */
991 complain_overflow_bitfield, /* complain_on_overflow */
992 ppc64_elf_toc64_reloc, /* special_function */
993 "R_PPC64_TOC", /* name */
994 FALSE, /* partial_inplace */
995 0, /* src_mask */
996 ONES (64), /* dst_mask */
997 FALSE), /* pcrel_offset */
998
999 /* Like R_PPC64_GOT16, but also informs the link editor that the
1000 value to relocate may (!) refer to a PLT entry which the link
1001 editor (a) may replace with the symbol value. If the link editor
1002 is unable to fully resolve the symbol, it may (b) create a PLT
1003 entry and store the address to the new PLT entry in the GOT.
1004 This permits lazy resolution of function symbols at run time.
1005 The link editor may also skip all of this and just (c) emit a
1006 R_PPC64_GLOB_DAT to tie the symbol to the GOT entry. */
1007 /* FIXME: R_PPC64_PLTGOT16 not implemented. */
1008 HOWTO (R_PPC64_PLTGOT16, /* type */
1009 0, /* rightshift */
1010 1, /* size (0 = byte, 1 = short, 2 = long) */
1011 16, /* bitsize */
1012 FALSE, /* pc_relative */
1013 0, /* bitpos */
1014 complain_overflow_signed, /* complain_on_overflow */
1015 ppc64_elf_unhandled_reloc, /* special_function */
1016 "R_PPC64_PLTGOT16", /* name */
1017 FALSE, /* partial_inplace */
1018 0, /* src_mask */
1019 0xffff, /* dst_mask */
1020 FALSE), /* pcrel_offset */
1021
1022 /* Like R_PPC64_PLTGOT16, but without overflow. */
1023 /* FIXME: R_PPC64_PLTGOT16_LO not implemented. */
1024 HOWTO (R_PPC64_PLTGOT16_LO, /* type */
1025 0, /* rightshift */
1026 1, /* size (0 = byte, 1 = short, 2 = long) */
1027 16, /* bitsize */
1028 FALSE, /* pc_relative */
1029 0, /* bitpos */
1030 complain_overflow_dont, /* complain_on_overflow */
1031 ppc64_elf_unhandled_reloc, /* special_function */
1032 "R_PPC64_PLTGOT16_LO", /* name */
1033 FALSE, /* partial_inplace */
1034 0, /* src_mask */
1035 0xffff, /* dst_mask */
1036 FALSE), /* pcrel_offset */
1037
1038 /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address. */
1039 /* FIXME: R_PPC64_PLTGOT16_HI not implemented. */
1040 HOWTO (R_PPC64_PLTGOT16_HI, /* type */
1041 16, /* rightshift */
1042 1, /* size (0 = byte, 1 = short, 2 = long) */
1043 16, /* bitsize */
1044 FALSE, /* pc_relative */
1045 0, /* bitpos */
1046 complain_overflow_dont, /* complain_on_overflow */
1047 ppc64_elf_unhandled_reloc, /* special_function */
1048 "R_PPC64_PLTGOT16_HI", /* name */
1049 FALSE, /* partial_inplace */
1050 0, /* src_mask */
1051 0xffff, /* dst_mask */
1052 FALSE), /* pcrel_offset */
1053
1054 /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address, plus
1055 1 if the contents of the low 16 bits, treated as a signed number,
1056 is negative. */
1057 /* FIXME: R_PPC64_PLTGOT16_HA not implemented. */
1058 HOWTO (R_PPC64_PLTGOT16_HA, /* type */
1059 16, /* rightshift */
1060 1, /* size (0 = byte, 1 = short, 2 = long) */
1061 16, /* bitsize */
1062 FALSE, /* pc_relative */
1063 0, /* bitpos */
1064 complain_overflow_dont,/* complain_on_overflow */
1065 ppc64_elf_unhandled_reloc, /* special_function */
1066 "R_PPC64_PLTGOT16_HA", /* name */
1067 FALSE, /* partial_inplace */
1068 0, /* src_mask */
1069 0xffff, /* dst_mask */
1070 FALSE), /* pcrel_offset */
1071
1072 /* Like R_PPC64_ADDR16, but for instructions with a DS field. */
1073 HOWTO (R_PPC64_ADDR16_DS, /* type */
1074 0, /* rightshift */
1075 1, /* size (0 = byte, 1 = short, 2 = long) */
1076 16, /* bitsize */
1077 FALSE, /* pc_relative */
1078 0, /* bitpos */
1079 complain_overflow_bitfield, /* complain_on_overflow */
1080 bfd_elf_generic_reloc, /* special_function */
1081 "R_PPC64_ADDR16_DS", /* name */
1082 FALSE, /* partial_inplace */
1083 0, /* src_mask */
1084 0xfffc, /* dst_mask */
1085 FALSE), /* pcrel_offset */
1086
1087 /* Like R_PPC64_ADDR16_LO, but for instructions with a DS field. */
1088 HOWTO (R_PPC64_ADDR16_LO_DS, /* type */
1089 0, /* rightshift */
1090 1, /* size (0 = byte, 1 = short, 2 = long) */
1091 16, /* bitsize */
1092 FALSE, /* pc_relative */
1093 0, /* bitpos */
1094 complain_overflow_dont,/* complain_on_overflow */
1095 bfd_elf_generic_reloc, /* special_function */
1096 "R_PPC64_ADDR16_LO_DS",/* name */
1097 FALSE, /* partial_inplace */
1098 0, /* src_mask */
1099 0xfffc, /* dst_mask */
1100 FALSE), /* pcrel_offset */
1101
1102 /* Like R_PPC64_GOT16, but for instructions with a DS field. */
1103 HOWTO (R_PPC64_GOT16_DS, /* type */
1104 0, /* rightshift */
1105 1, /* size (0 = byte, 1 = short, 2 = long) */
1106 16, /* bitsize */
1107 FALSE, /* pc_relative */
1108 0, /* bitpos */
1109 complain_overflow_signed, /* complain_on_overflow */
1110 ppc64_elf_unhandled_reloc, /* special_function */
1111 "R_PPC64_GOT16_DS", /* name */
1112 FALSE, /* partial_inplace */
1113 0, /* src_mask */
1114 0xfffc, /* dst_mask */
1115 FALSE), /* pcrel_offset */
1116
1117 /* Like R_PPC64_GOT16_LO, but for instructions with a DS field. */
1118 HOWTO (R_PPC64_GOT16_LO_DS, /* type */
1119 0, /* rightshift */
1120 1, /* size (0 = byte, 1 = short, 2 = long) */
1121 16, /* bitsize */
1122 FALSE, /* pc_relative */
1123 0, /* bitpos */
1124 complain_overflow_dont, /* complain_on_overflow */
1125 ppc64_elf_unhandled_reloc, /* special_function */
1126 "R_PPC64_GOT16_LO_DS", /* name */
1127 FALSE, /* partial_inplace */
1128 0, /* src_mask */
1129 0xfffc, /* dst_mask */
1130 FALSE), /* pcrel_offset */
1131
1132 /* Like R_PPC64_PLT16_LO, but for instructions with a DS field. */
1133 HOWTO (R_PPC64_PLT16_LO_DS, /* type */
1134 0, /* rightshift */
1135 1, /* size (0 = byte, 1 = short, 2 = long) */
1136 16, /* bitsize */
1137 FALSE, /* pc_relative */
1138 0, /* bitpos */
1139 complain_overflow_dont, /* complain_on_overflow */
1140 ppc64_elf_unhandled_reloc, /* special_function */
1141 "R_PPC64_PLT16_LO_DS", /* name */
1142 FALSE, /* partial_inplace */
1143 0, /* src_mask */
1144 0xfffc, /* dst_mask */
1145 FALSE), /* pcrel_offset */
1146
1147 /* Like R_PPC64_SECTOFF, but for instructions with a DS field. */
1148 HOWTO (R_PPC64_SECTOFF_DS, /* type */
1149 0, /* rightshift */
1150 1, /* size (0 = byte, 1 = short, 2 = long) */
1151 16, /* bitsize */
1152 FALSE, /* pc_relative */
1153 0, /* bitpos */
1154 complain_overflow_bitfield, /* complain_on_overflow */
1155 ppc64_elf_sectoff_reloc, /* special_function */
1156 "R_PPC64_SECTOFF_DS", /* name */
1157 FALSE, /* partial_inplace */
1158 0, /* src_mask */
1159 0xfffc, /* dst_mask */
1160 FALSE), /* pcrel_offset */
1161
1162 /* Like R_PPC64_SECTOFF_LO, but for instructions with a DS field. */
1163 HOWTO (R_PPC64_SECTOFF_LO_DS, /* type */
1164 0, /* rightshift */
1165 1, /* size (0 = byte, 1 = short, 2 = long) */
1166 16, /* bitsize */
1167 FALSE, /* pc_relative */
1168 0, /* bitpos */
1169 complain_overflow_dont, /* complain_on_overflow */
1170 ppc64_elf_sectoff_reloc, /* special_function */
1171 "R_PPC64_SECTOFF_LO_DS",/* name */
1172 FALSE, /* partial_inplace */
1173 0, /* src_mask */
1174 0xfffc, /* dst_mask */
1175 FALSE), /* pcrel_offset */
1176
1177 /* Like R_PPC64_TOC16, but for instructions with a DS field. */
1178 HOWTO (R_PPC64_TOC16_DS, /* type */
1179 0, /* rightshift */
1180 1, /* size (0 = byte, 1 = short, 2 = long) */
1181 16, /* bitsize */
1182 FALSE, /* pc_relative */
1183 0, /* bitpos */
1184 complain_overflow_signed, /* complain_on_overflow */
1185 ppc64_elf_toc_reloc, /* special_function */
1186 "R_PPC64_TOC16_DS", /* name */
1187 FALSE, /* partial_inplace */
1188 0, /* src_mask */
1189 0xfffc, /* dst_mask */
1190 FALSE), /* pcrel_offset */
1191
1192 /* Like R_PPC64_TOC16_LO, but for instructions with a DS field. */
1193 HOWTO (R_PPC64_TOC16_LO_DS, /* type */
1194 0, /* rightshift */
1195 1, /* size (0 = byte, 1 = short, 2 = long) */
1196 16, /* bitsize */
1197 FALSE, /* pc_relative */
1198 0, /* bitpos */
1199 complain_overflow_dont, /* complain_on_overflow */
1200 ppc64_elf_toc_reloc, /* special_function */
1201 "R_PPC64_TOC16_LO_DS", /* name */
1202 FALSE, /* partial_inplace */
1203 0, /* src_mask */
1204 0xfffc, /* dst_mask */
1205 FALSE), /* pcrel_offset */
1206
1207 /* Like R_PPC64_PLTGOT16, but for instructions with a DS field. */
1208 /* FIXME: R_PPC64_PLTGOT16_DS not implemented. */
1209 HOWTO (R_PPC64_PLTGOT16_DS, /* type */
1210 0, /* rightshift */
1211 1, /* size (0 = byte, 1 = short, 2 = long) */
1212 16, /* bitsize */
1213 FALSE, /* pc_relative */
1214 0, /* bitpos */
1215 complain_overflow_signed, /* complain_on_overflow */
1216 ppc64_elf_unhandled_reloc, /* special_function */
1217 "R_PPC64_PLTGOT16_DS", /* name */
1218 FALSE, /* partial_inplace */
1219 0, /* src_mask */
1220 0xfffc, /* dst_mask */
1221 FALSE), /* pcrel_offset */
1222
1223 /* Like R_PPC64_PLTGOT16_LO, but for instructions with a DS field. */
1224 /* FIXME: R_PPC64_PLTGOT16_LO not implemented. */
1225 HOWTO (R_PPC64_PLTGOT16_LO_DS,/* type */
1226 0, /* rightshift */
1227 1, /* size (0 = byte, 1 = short, 2 = long) */
1228 16, /* bitsize */
1229 FALSE, /* pc_relative */
1230 0, /* bitpos */
1231 complain_overflow_dont, /* complain_on_overflow */
1232 ppc64_elf_unhandled_reloc, /* special_function */
1233 "R_PPC64_PLTGOT16_LO_DS",/* name */
1234 FALSE, /* partial_inplace */
1235 0, /* src_mask */
1236 0xfffc, /* dst_mask */
1237 FALSE), /* pcrel_offset */
1238
1239 /* Marker relocs for TLS. */
1240 HOWTO (R_PPC64_TLS,
1241 0, /* rightshift */
1242 2, /* size (0 = byte, 1 = short, 2 = long) */
1243 32, /* bitsize */
1244 FALSE, /* pc_relative */
1245 0, /* bitpos */
1246 complain_overflow_dont, /* complain_on_overflow */
1247 bfd_elf_generic_reloc, /* special_function */
1248 "R_PPC64_TLS", /* name */
1249 FALSE, /* partial_inplace */
1250 0, /* src_mask */
1251 0, /* dst_mask */
1252 FALSE), /* pcrel_offset */
1253
1254 HOWTO (R_PPC64_TLSGD,
1255 0, /* rightshift */
1256 2, /* size (0 = byte, 1 = short, 2 = long) */
1257 32, /* bitsize */
1258 FALSE, /* pc_relative */
1259 0, /* bitpos */
1260 complain_overflow_dont, /* complain_on_overflow */
1261 bfd_elf_generic_reloc, /* special_function */
1262 "R_PPC64_TLSGD", /* name */
1263 FALSE, /* partial_inplace */
1264 0, /* src_mask */
1265 0, /* dst_mask */
1266 FALSE), /* pcrel_offset */
1267
1268 HOWTO (R_PPC64_TLSLD,
1269 0, /* rightshift */
1270 2, /* size (0 = byte, 1 = short, 2 = long) */
1271 32, /* bitsize */
1272 FALSE, /* pc_relative */
1273 0, /* bitpos */
1274 complain_overflow_dont, /* complain_on_overflow */
1275 bfd_elf_generic_reloc, /* special_function */
1276 "R_PPC64_TLSLD", /* name */
1277 FALSE, /* partial_inplace */
1278 0, /* src_mask */
1279 0, /* dst_mask */
1280 FALSE), /* pcrel_offset */
1281
1282 /* Computes the load module index of the load module that contains the
1283 definition of its TLS sym. */
1284 HOWTO (R_PPC64_DTPMOD64,
1285 0, /* rightshift */
1286 4, /* size (0 = byte, 1 = short, 2 = long) */
1287 64, /* bitsize */
1288 FALSE, /* pc_relative */
1289 0, /* bitpos */
1290 complain_overflow_dont, /* complain_on_overflow */
1291 ppc64_elf_unhandled_reloc, /* special_function */
1292 "R_PPC64_DTPMOD64", /* name */
1293 FALSE, /* partial_inplace */
1294 0, /* src_mask */
1295 ONES (64), /* dst_mask */
1296 FALSE), /* pcrel_offset */
1297
1298 /* Computes a dtv-relative displacement, the difference between the value
1299 of sym+add and the base address of the thread-local storage block that
1300 contains the definition of sym, minus 0x8000. */
1301 HOWTO (R_PPC64_DTPREL64,
1302 0, /* rightshift */
1303 4, /* size (0 = byte, 1 = short, 2 = long) */
1304 64, /* bitsize */
1305 FALSE, /* pc_relative */
1306 0, /* bitpos */
1307 complain_overflow_dont, /* complain_on_overflow */
1308 ppc64_elf_unhandled_reloc, /* special_function */
1309 "R_PPC64_DTPREL64", /* name */
1310 FALSE, /* partial_inplace */
1311 0, /* src_mask */
1312 ONES (64), /* dst_mask */
1313 FALSE), /* pcrel_offset */
1314
1315 /* A 16 bit dtprel reloc. */
1316 HOWTO (R_PPC64_DTPREL16,
1317 0, /* rightshift */
1318 1, /* size (0 = byte, 1 = short, 2 = long) */
1319 16, /* bitsize */
1320 FALSE, /* pc_relative */
1321 0, /* bitpos */
1322 complain_overflow_signed, /* complain_on_overflow */
1323 ppc64_elf_unhandled_reloc, /* special_function */
1324 "R_PPC64_DTPREL16", /* name */
1325 FALSE, /* partial_inplace */
1326 0, /* src_mask */
1327 0xffff, /* dst_mask */
1328 FALSE), /* pcrel_offset */
1329
1330 /* Like DTPREL16, but no overflow. */
1331 HOWTO (R_PPC64_DTPREL16_LO,
1332 0, /* rightshift */
1333 1, /* size (0 = byte, 1 = short, 2 = long) */
1334 16, /* bitsize */
1335 FALSE, /* pc_relative */
1336 0, /* bitpos */
1337 complain_overflow_dont, /* complain_on_overflow */
1338 ppc64_elf_unhandled_reloc, /* special_function */
1339 "R_PPC64_DTPREL16_LO", /* name */
1340 FALSE, /* partial_inplace */
1341 0, /* src_mask */
1342 0xffff, /* dst_mask */
1343 FALSE), /* pcrel_offset */
1344
1345 /* Like DTPREL16_LO, but next higher group of 16 bits. */
1346 HOWTO (R_PPC64_DTPREL16_HI,
1347 16, /* rightshift */
1348 1, /* size (0 = byte, 1 = short, 2 = long) */
1349 16, /* bitsize */
1350 FALSE, /* pc_relative */
1351 0, /* bitpos */
1352 complain_overflow_dont, /* complain_on_overflow */
1353 ppc64_elf_unhandled_reloc, /* special_function */
1354 "R_PPC64_DTPREL16_HI", /* name */
1355 FALSE, /* partial_inplace */
1356 0, /* src_mask */
1357 0xffff, /* dst_mask */
1358 FALSE), /* pcrel_offset */
1359
1360 /* Like DTPREL16_HI, but adjust for low 16 bits. */
1361 HOWTO (R_PPC64_DTPREL16_HA,
1362 16, /* rightshift */
1363 1, /* size (0 = byte, 1 = short, 2 = long) */
1364 16, /* bitsize */
1365 FALSE, /* pc_relative */
1366 0, /* bitpos */
1367 complain_overflow_dont, /* complain_on_overflow */
1368 ppc64_elf_unhandled_reloc, /* special_function */
1369 "R_PPC64_DTPREL16_HA", /* name */
1370 FALSE, /* partial_inplace */
1371 0, /* src_mask */
1372 0xffff, /* dst_mask */
1373 FALSE), /* pcrel_offset */
1374
1375 /* Like DTPREL16_HI, but next higher group of 16 bits. */
1376 HOWTO (R_PPC64_DTPREL16_HIGHER,
1377 32, /* rightshift */
1378 1, /* size (0 = byte, 1 = short, 2 = long) */
1379 16, /* bitsize */
1380 FALSE, /* pc_relative */
1381 0, /* bitpos */
1382 complain_overflow_dont, /* complain_on_overflow */
1383 ppc64_elf_unhandled_reloc, /* special_function */
1384 "R_PPC64_DTPREL16_HIGHER", /* name */
1385 FALSE, /* partial_inplace */
1386 0, /* src_mask */
1387 0xffff, /* dst_mask */
1388 FALSE), /* pcrel_offset */
1389
1390 /* Like DTPREL16_HIGHER, but adjust for low 16 bits. */
1391 HOWTO (R_PPC64_DTPREL16_HIGHERA,
1392 32, /* rightshift */
1393 1, /* size (0 = byte, 1 = short, 2 = long) */
1394 16, /* bitsize */
1395 FALSE, /* pc_relative */
1396 0, /* bitpos */
1397 complain_overflow_dont, /* complain_on_overflow */
1398 ppc64_elf_unhandled_reloc, /* special_function */
1399 "R_PPC64_DTPREL16_HIGHERA", /* name */
1400 FALSE, /* partial_inplace */
1401 0, /* src_mask */
1402 0xffff, /* dst_mask */
1403 FALSE), /* pcrel_offset */
1404
1405 /* Like DTPREL16_HIGHER, but next higher group of 16 bits. */
1406 HOWTO (R_PPC64_DTPREL16_HIGHEST,
1407 48, /* rightshift */
1408 1, /* size (0 = byte, 1 = short, 2 = long) */
1409 16, /* bitsize */
1410 FALSE, /* pc_relative */
1411 0, /* bitpos */
1412 complain_overflow_dont, /* complain_on_overflow */
1413 ppc64_elf_unhandled_reloc, /* special_function */
1414 "R_PPC64_DTPREL16_HIGHEST", /* name */
1415 FALSE, /* partial_inplace */
1416 0, /* src_mask */
1417 0xffff, /* dst_mask */
1418 FALSE), /* pcrel_offset */
1419
1420 /* Like DTPREL16_HIGHEST, but adjust for low 16 bits. */
1421 HOWTO (R_PPC64_DTPREL16_HIGHESTA,
1422 48, /* rightshift */
1423 1, /* size (0 = byte, 1 = short, 2 = long) */
1424 16, /* bitsize */
1425 FALSE, /* pc_relative */
1426 0, /* bitpos */
1427 complain_overflow_dont, /* complain_on_overflow */
1428 ppc64_elf_unhandled_reloc, /* special_function */
1429 "R_PPC64_DTPREL16_HIGHESTA", /* name */
1430 FALSE, /* partial_inplace */
1431 0, /* src_mask */
1432 0xffff, /* dst_mask */
1433 FALSE), /* pcrel_offset */
1434
1435 /* Like DTPREL16, but for insns with a DS field. */
1436 HOWTO (R_PPC64_DTPREL16_DS,
1437 0, /* rightshift */
1438 1, /* size (0 = byte, 1 = short, 2 = long) */
1439 16, /* bitsize */
1440 FALSE, /* pc_relative */
1441 0, /* bitpos */
1442 complain_overflow_signed, /* complain_on_overflow */
1443 ppc64_elf_unhandled_reloc, /* special_function */
1444 "R_PPC64_DTPREL16_DS", /* name */
1445 FALSE, /* partial_inplace */
1446 0, /* src_mask */
1447 0xfffc, /* dst_mask */
1448 FALSE), /* pcrel_offset */
1449
1450 /* Like DTPREL16_DS, but no overflow. */
1451 HOWTO (R_PPC64_DTPREL16_LO_DS,
1452 0, /* rightshift */
1453 1, /* size (0 = byte, 1 = short, 2 = long) */
1454 16, /* bitsize */
1455 FALSE, /* pc_relative */
1456 0, /* bitpos */
1457 complain_overflow_dont, /* complain_on_overflow */
1458 ppc64_elf_unhandled_reloc, /* special_function */
1459 "R_PPC64_DTPREL16_LO_DS", /* name */
1460 FALSE, /* partial_inplace */
1461 0, /* src_mask */
1462 0xfffc, /* dst_mask */
1463 FALSE), /* pcrel_offset */
1464
1465 /* Computes a tp-relative displacement, the difference between the value of
1466 sym+add and the value of the thread pointer (r13). */
1467 HOWTO (R_PPC64_TPREL64,
1468 0, /* rightshift */
1469 4, /* size (0 = byte, 1 = short, 2 = long) */
1470 64, /* bitsize */
1471 FALSE, /* pc_relative */
1472 0, /* bitpos */
1473 complain_overflow_dont, /* complain_on_overflow */
1474 ppc64_elf_unhandled_reloc, /* special_function */
1475 "R_PPC64_TPREL64", /* name */
1476 FALSE, /* partial_inplace */
1477 0, /* src_mask */
1478 ONES (64), /* dst_mask */
1479 FALSE), /* pcrel_offset */
1480
1481 /* A 16 bit tprel reloc. */
1482 HOWTO (R_PPC64_TPREL16,
1483 0, /* rightshift */
1484 1, /* size (0 = byte, 1 = short, 2 = long) */
1485 16, /* bitsize */
1486 FALSE, /* pc_relative */
1487 0, /* bitpos */
1488 complain_overflow_signed, /* complain_on_overflow */
1489 ppc64_elf_unhandled_reloc, /* special_function */
1490 "R_PPC64_TPREL16", /* name */
1491 FALSE, /* partial_inplace */
1492 0, /* src_mask */
1493 0xffff, /* dst_mask */
1494 FALSE), /* pcrel_offset */
1495
1496 /* Like TPREL16, but no overflow. */
1497 HOWTO (R_PPC64_TPREL16_LO,
1498 0, /* rightshift */
1499 1, /* size (0 = byte, 1 = short, 2 = long) */
1500 16, /* bitsize */
1501 FALSE, /* pc_relative */
1502 0, /* bitpos */
1503 complain_overflow_dont, /* complain_on_overflow */
1504 ppc64_elf_unhandled_reloc, /* special_function */
1505 "R_PPC64_TPREL16_LO", /* name */
1506 FALSE, /* partial_inplace */
1507 0, /* src_mask */
1508 0xffff, /* dst_mask */
1509 FALSE), /* pcrel_offset */
1510
1511 /* Like TPREL16_LO, but next higher group of 16 bits. */
1512 HOWTO (R_PPC64_TPREL16_HI,
1513 16, /* rightshift */
1514 1, /* size (0 = byte, 1 = short, 2 = long) */
1515 16, /* bitsize */
1516 FALSE, /* pc_relative */
1517 0, /* bitpos */
1518 complain_overflow_dont, /* complain_on_overflow */
1519 ppc64_elf_unhandled_reloc, /* special_function */
1520 "R_PPC64_TPREL16_HI", /* name */
1521 FALSE, /* partial_inplace */
1522 0, /* src_mask */
1523 0xffff, /* dst_mask */
1524 FALSE), /* pcrel_offset */
1525
1526 /* Like TPREL16_HI, but adjust for low 16 bits. */
1527 HOWTO (R_PPC64_TPREL16_HA,
1528 16, /* rightshift */
1529 1, /* size (0 = byte, 1 = short, 2 = long) */
1530 16, /* bitsize */
1531 FALSE, /* pc_relative */
1532 0, /* bitpos */
1533 complain_overflow_dont, /* complain_on_overflow */
1534 ppc64_elf_unhandled_reloc, /* special_function */
1535 "R_PPC64_TPREL16_HA", /* name */
1536 FALSE, /* partial_inplace */
1537 0, /* src_mask */
1538 0xffff, /* dst_mask */
1539 FALSE), /* pcrel_offset */
1540
1541 /* Like TPREL16_HI, but next higher group of 16 bits. */
1542 HOWTO (R_PPC64_TPREL16_HIGHER,
1543 32, /* rightshift */
1544 1, /* size (0 = byte, 1 = short, 2 = long) */
1545 16, /* bitsize */
1546 FALSE, /* pc_relative */
1547 0, /* bitpos */
1548 complain_overflow_dont, /* complain_on_overflow */
1549 ppc64_elf_unhandled_reloc, /* special_function */
1550 "R_PPC64_TPREL16_HIGHER", /* name */
1551 FALSE, /* partial_inplace */
1552 0, /* src_mask */
1553 0xffff, /* dst_mask */
1554 FALSE), /* pcrel_offset */
1555
1556 /* Like TPREL16_HIGHER, but adjust for low 16 bits. */
1557 HOWTO (R_PPC64_TPREL16_HIGHERA,
1558 32, /* rightshift */
1559 1, /* size (0 = byte, 1 = short, 2 = long) */
1560 16, /* bitsize */
1561 FALSE, /* pc_relative */
1562 0, /* bitpos */
1563 complain_overflow_dont, /* complain_on_overflow */
1564 ppc64_elf_unhandled_reloc, /* special_function */
1565 "R_PPC64_TPREL16_HIGHERA", /* name */
1566 FALSE, /* partial_inplace */
1567 0, /* src_mask */
1568 0xffff, /* dst_mask */
1569 FALSE), /* pcrel_offset */
1570
1571 /* Like TPREL16_HIGHER, but next higher group of 16 bits. */
1572 HOWTO (R_PPC64_TPREL16_HIGHEST,
1573 48, /* rightshift */
1574 1, /* size (0 = byte, 1 = short, 2 = long) */
1575 16, /* bitsize */
1576 FALSE, /* pc_relative */
1577 0, /* bitpos */
1578 complain_overflow_dont, /* complain_on_overflow */
1579 ppc64_elf_unhandled_reloc, /* special_function */
1580 "R_PPC64_TPREL16_HIGHEST", /* name */
1581 FALSE, /* partial_inplace */
1582 0, /* src_mask */
1583 0xffff, /* dst_mask */
1584 FALSE), /* pcrel_offset */
1585
1586 /* Like TPREL16_HIGHEST, but adjust for low 16 bits. */
1587 HOWTO (R_PPC64_TPREL16_HIGHESTA,
1588 48, /* rightshift */
1589 1, /* size (0 = byte, 1 = short, 2 = long) */
1590 16, /* bitsize */
1591 FALSE, /* pc_relative */
1592 0, /* bitpos */
1593 complain_overflow_dont, /* complain_on_overflow */
1594 ppc64_elf_unhandled_reloc, /* special_function */
1595 "R_PPC64_TPREL16_HIGHESTA", /* name */
1596 FALSE, /* partial_inplace */
1597 0, /* src_mask */
1598 0xffff, /* dst_mask */
1599 FALSE), /* pcrel_offset */
1600
1601 /* Like TPREL16, but for insns with a DS field. */
1602 HOWTO (R_PPC64_TPREL16_DS,
1603 0, /* rightshift */
1604 1, /* size (0 = byte, 1 = short, 2 = long) */
1605 16, /* bitsize */
1606 FALSE, /* pc_relative */
1607 0, /* bitpos */
1608 complain_overflow_signed, /* complain_on_overflow */
1609 ppc64_elf_unhandled_reloc, /* special_function */
1610 "R_PPC64_TPREL16_DS", /* name */
1611 FALSE, /* partial_inplace */
1612 0, /* src_mask */
1613 0xfffc, /* dst_mask */
1614 FALSE), /* pcrel_offset */
1615
1616 /* Like TPREL16_DS, but no overflow. */
1617 HOWTO (R_PPC64_TPREL16_LO_DS,
1618 0, /* rightshift */
1619 1, /* size (0 = byte, 1 = short, 2 = long) */
1620 16, /* bitsize */
1621 FALSE, /* pc_relative */
1622 0, /* bitpos */
1623 complain_overflow_dont, /* complain_on_overflow */
1624 ppc64_elf_unhandled_reloc, /* special_function */
1625 "R_PPC64_TPREL16_LO_DS", /* name */
1626 FALSE, /* partial_inplace */
1627 0, /* src_mask */
1628 0xfffc, /* dst_mask */
1629 FALSE), /* pcrel_offset */
1630
1631 /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1632 with values (sym+add)@dtpmod and (sym+add)@dtprel, and computes the offset
1633 to the first entry relative to the TOC base (r2). */
1634 HOWTO (R_PPC64_GOT_TLSGD16,
1635 0, /* rightshift */
1636 1, /* size (0 = byte, 1 = short, 2 = long) */
1637 16, /* bitsize */
1638 FALSE, /* pc_relative */
1639 0, /* bitpos */
1640 complain_overflow_signed, /* complain_on_overflow */
1641 ppc64_elf_unhandled_reloc, /* special_function */
1642 "R_PPC64_GOT_TLSGD16", /* name */
1643 FALSE, /* partial_inplace */
1644 0, /* src_mask */
1645 0xffff, /* dst_mask */
1646 FALSE), /* pcrel_offset */
1647
1648 /* Like GOT_TLSGD16, but no overflow. */
1649 HOWTO (R_PPC64_GOT_TLSGD16_LO,
1650 0, /* rightshift */
1651 1, /* size (0 = byte, 1 = short, 2 = long) */
1652 16, /* bitsize */
1653 FALSE, /* pc_relative */
1654 0, /* bitpos */
1655 complain_overflow_dont, /* complain_on_overflow */
1656 ppc64_elf_unhandled_reloc, /* special_function */
1657 "R_PPC64_GOT_TLSGD16_LO", /* name */
1658 FALSE, /* partial_inplace */
1659 0, /* src_mask */
1660 0xffff, /* dst_mask */
1661 FALSE), /* pcrel_offset */
1662
1663 /* Like GOT_TLSGD16_LO, but next higher group of 16 bits. */
1664 HOWTO (R_PPC64_GOT_TLSGD16_HI,
1665 16, /* rightshift */
1666 1, /* size (0 = byte, 1 = short, 2 = long) */
1667 16, /* bitsize */
1668 FALSE, /* pc_relative */
1669 0, /* bitpos */
1670 complain_overflow_dont, /* complain_on_overflow */
1671 ppc64_elf_unhandled_reloc, /* special_function */
1672 "R_PPC64_GOT_TLSGD16_HI", /* name */
1673 FALSE, /* partial_inplace */
1674 0, /* src_mask */
1675 0xffff, /* dst_mask */
1676 FALSE), /* pcrel_offset */
1677
1678 /* Like GOT_TLSGD16_HI, but adjust for low 16 bits. */
1679 HOWTO (R_PPC64_GOT_TLSGD16_HA,
1680 16, /* rightshift */
1681 1, /* size (0 = byte, 1 = short, 2 = long) */
1682 16, /* bitsize */
1683 FALSE, /* pc_relative */
1684 0, /* bitpos */
1685 complain_overflow_dont, /* complain_on_overflow */
1686 ppc64_elf_unhandled_reloc, /* special_function */
1687 "R_PPC64_GOT_TLSGD16_HA", /* name */
1688 FALSE, /* partial_inplace */
1689 0, /* src_mask */
1690 0xffff, /* dst_mask */
1691 FALSE), /* pcrel_offset */
1692
1693 /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1694 with values (sym+add)@dtpmod and zero, and computes the offset to the
1695 first entry relative to the TOC base (r2). */
1696 HOWTO (R_PPC64_GOT_TLSLD16,
1697 0, /* rightshift */
1698 1, /* size (0 = byte, 1 = short, 2 = long) */
1699 16, /* bitsize */
1700 FALSE, /* pc_relative */
1701 0, /* bitpos */
1702 complain_overflow_signed, /* complain_on_overflow */
1703 ppc64_elf_unhandled_reloc, /* special_function */
1704 "R_PPC64_GOT_TLSLD16", /* name */
1705 FALSE, /* partial_inplace */
1706 0, /* src_mask */
1707 0xffff, /* dst_mask */
1708 FALSE), /* pcrel_offset */
1709
1710 /* Like GOT_TLSLD16, but no overflow. */
1711 HOWTO (R_PPC64_GOT_TLSLD16_LO,
1712 0, /* rightshift */
1713 1, /* size (0 = byte, 1 = short, 2 = long) */
1714 16, /* bitsize */
1715 FALSE, /* pc_relative */
1716 0, /* bitpos */
1717 complain_overflow_dont, /* complain_on_overflow */
1718 ppc64_elf_unhandled_reloc, /* special_function */
1719 "R_PPC64_GOT_TLSLD16_LO", /* name */
1720 FALSE, /* partial_inplace */
1721 0, /* src_mask */
1722 0xffff, /* dst_mask */
1723 FALSE), /* pcrel_offset */
1724
1725 /* Like GOT_TLSLD16_LO, but next higher group of 16 bits. */
1726 HOWTO (R_PPC64_GOT_TLSLD16_HI,
1727 16, /* rightshift */
1728 1, /* size (0 = byte, 1 = short, 2 = long) */
1729 16, /* bitsize */
1730 FALSE, /* pc_relative */
1731 0, /* bitpos */
1732 complain_overflow_dont, /* complain_on_overflow */
1733 ppc64_elf_unhandled_reloc, /* special_function */
1734 "R_PPC64_GOT_TLSLD16_HI", /* name */
1735 FALSE, /* partial_inplace */
1736 0, /* src_mask */
1737 0xffff, /* dst_mask */
1738 FALSE), /* pcrel_offset */
1739
1740 /* Like GOT_TLSLD16_HI, but adjust for low 16 bits. */
1741 HOWTO (R_PPC64_GOT_TLSLD16_HA,
1742 16, /* rightshift */
1743 1, /* size (0 = byte, 1 = short, 2 = long) */
1744 16, /* bitsize */
1745 FALSE, /* pc_relative */
1746 0, /* bitpos */
1747 complain_overflow_dont, /* complain_on_overflow */
1748 ppc64_elf_unhandled_reloc, /* special_function */
1749 "R_PPC64_GOT_TLSLD16_HA", /* name */
1750 FALSE, /* partial_inplace */
1751 0, /* src_mask */
1752 0xffff, /* dst_mask */
1753 FALSE), /* pcrel_offset */
1754
1755 /* Allocates an entry in the GOT with value (sym+add)@dtprel, and computes
1756 the offset to the entry relative to the TOC base (r2). */
1757 HOWTO (R_PPC64_GOT_DTPREL16_DS,
1758 0, /* rightshift */
1759 1, /* size (0 = byte, 1 = short, 2 = long) */
1760 16, /* bitsize */
1761 FALSE, /* pc_relative */
1762 0, /* bitpos */
1763 complain_overflow_signed, /* complain_on_overflow */
1764 ppc64_elf_unhandled_reloc, /* special_function */
1765 "R_PPC64_GOT_DTPREL16_DS", /* name */
1766 FALSE, /* partial_inplace */
1767 0, /* src_mask */
1768 0xfffc, /* dst_mask */
1769 FALSE), /* pcrel_offset */
1770
1771 /* Like GOT_DTPREL16_DS, but no overflow. */
1772 HOWTO (R_PPC64_GOT_DTPREL16_LO_DS,
1773 0, /* rightshift */
1774 1, /* size (0 = byte, 1 = short, 2 = long) */
1775 16, /* bitsize */
1776 FALSE, /* pc_relative */
1777 0, /* bitpos */
1778 complain_overflow_dont, /* complain_on_overflow */
1779 ppc64_elf_unhandled_reloc, /* special_function */
1780 "R_PPC64_GOT_DTPREL16_LO_DS", /* name */
1781 FALSE, /* partial_inplace */
1782 0, /* src_mask */
1783 0xfffc, /* dst_mask */
1784 FALSE), /* pcrel_offset */
1785
1786 /* Like GOT_DTPREL16_LO_DS, but next higher group of 16 bits. */
1787 HOWTO (R_PPC64_GOT_DTPREL16_HI,
1788 16, /* rightshift */
1789 1, /* size (0 = byte, 1 = short, 2 = long) */
1790 16, /* bitsize */
1791 FALSE, /* pc_relative */
1792 0, /* bitpos */
1793 complain_overflow_dont, /* complain_on_overflow */
1794 ppc64_elf_unhandled_reloc, /* special_function */
1795 "R_PPC64_GOT_DTPREL16_HI", /* name */
1796 FALSE, /* partial_inplace */
1797 0, /* src_mask */
1798 0xffff, /* dst_mask */
1799 FALSE), /* pcrel_offset */
1800
1801 /* Like GOT_DTPREL16_HI, but adjust for low 16 bits. */
1802 HOWTO (R_PPC64_GOT_DTPREL16_HA,
1803 16, /* rightshift */
1804 1, /* size (0 = byte, 1 = short, 2 = long) */
1805 16, /* bitsize */
1806 FALSE, /* pc_relative */
1807 0, /* bitpos */
1808 complain_overflow_dont, /* complain_on_overflow */
1809 ppc64_elf_unhandled_reloc, /* special_function */
1810 "R_PPC64_GOT_DTPREL16_HA", /* name */
1811 FALSE, /* partial_inplace */
1812 0, /* src_mask */
1813 0xffff, /* dst_mask */
1814 FALSE), /* pcrel_offset */
1815
1816 /* Allocates an entry in the GOT with value (sym+add)@tprel, and computes the
1817 offset to the entry relative to the TOC base (r2). */
1818 HOWTO (R_PPC64_GOT_TPREL16_DS,
1819 0, /* rightshift */
1820 1, /* size (0 = byte, 1 = short, 2 = long) */
1821 16, /* bitsize */
1822 FALSE, /* pc_relative */
1823 0, /* bitpos */
1824 complain_overflow_signed, /* complain_on_overflow */
1825 ppc64_elf_unhandled_reloc, /* special_function */
1826 "R_PPC64_GOT_TPREL16_DS", /* name */
1827 FALSE, /* partial_inplace */
1828 0, /* src_mask */
1829 0xfffc, /* dst_mask */
1830 FALSE), /* pcrel_offset */
1831
1832 /* Like GOT_TPREL16_DS, but no overflow. */
1833 HOWTO (R_PPC64_GOT_TPREL16_LO_DS,
1834 0, /* rightshift */
1835 1, /* size (0 = byte, 1 = short, 2 = long) */
1836 16, /* bitsize */
1837 FALSE, /* pc_relative */
1838 0, /* bitpos */
1839 complain_overflow_dont, /* complain_on_overflow */
1840 ppc64_elf_unhandled_reloc, /* special_function */
1841 "R_PPC64_GOT_TPREL16_LO_DS", /* name */
1842 FALSE, /* partial_inplace */
1843 0, /* src_mask */
1844 0xfffc, /* dst_mask */
1845 FALSE), /* pcrel_offset */
1846
1847 /* Like GOT_TPREL16_LO_DS, but next higher group of 16 bits. */
1848 HOWTO (R_PPC64_GOT_TPREL16_HI,
1849 16, /* rightshift */
1850 1, /* size (0 = byte, 1 = short, 2 = long) */
1851 16, /* bitsize */
1852 FALSE, /* pc_relative */
1853 0, /* bitpos */
1854 complain_overflow_dont, /* complain_on_overflow */
1855 ppc64_elf_unhandled_reloc, /* special_function */
1856 "R_PPC64_GOT_TPREL16_HI", /* name */
1857 FALSE, /* partial_inplace */
1858 0, /* src_mask */
1859 0xffff, /* dst_mask */
1860 FALSE), /* pcrel_offset */
1861
1862 /* Like GOT_TPREL16_HI, but adjust for low 16 bits. */
1863 HOWTO (R_PPC64_GOT_TPREL16_HA,
1864 16, /* rightshift */
1865 1, /* size (0 = byte, 1 = short, 2 = long) */
1866 16, /* bitsize */
1867 FALSE, /* pc_relative */
1868 0, /* bitpos */
1869 complain_overflow_dont, /* complain_on_overflow */
1870 ppc64_elf_unhandled_reloc, /* special_function */
1871 "R_PPC64_GOT_TPREL16_HA", /* name */
1872 FALSE, /* partial_inplace */
1873 0, /* src_mask */
1874 0xffff, /* dst_mask */
1875 FALSE), /* pcrel_offset */
1876
1877 HOWTO (R_PPC64_JMP_IREL, /* type */
1878 0, /* rightshift */
1879 0, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1880 0, /* bitsize */
1881 FALSE, /* pc_relative */
1882 0, /* bitpos */
1883 complain_overflow_dont, /* complain_on_overflow */
1884 ppc64_elf_unhandled_reloc, /* special_function */
1885 "R_PPC64_JMP_IREL", /* name */
1886 FALSE, /* partial_inplace */
1887 0, /* src_mask */
1888 0, /* dst_mask */
1889 FALSE), /* pcrel_offset */
1890
1891 HOWTO (R_PPC64_IRELATIVE, /* type */
1892 0, /* rightshift */
1893 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1894 64, /* bitsize */
1895 FALSE, /* pc_relative */
1896 0, /* bitpos */
1897 complain_overflow_dont, /* complain_on_overflow */
1898 bfd_elf_generic_reloc, /* special_function */
1899 "R_PPC64_IRELATIVE", /* name */
1900 FALSE, /* partial_inplace */
1901 0, /* src_mask */
1902 ONES (64), /* dst_mask */
1903 FALSE), /* pcrel_offset */
1904
1905 /* A 16 bit relative relocation. */
1906 HOWTO (R_PPC64_REL16, /* type */
1907 0, /* rightshift */
1908 1, /* size (0 = byte, 1 = short, 2 = long) */
1909 16, /* bitsize */
1910 TRUE, /* pc_relative */
1911 0, /* bitpos */
1912 complain_overflow_bitfield, /* complain_on_overflow */
1913 bfd_elf_generic_reloc, /* special_function */
1914 "R_PPC64_REL16", /* name */
1915 FALSE, /* partial_inplace */
1916 0, /* src_mask */
1917 0xffff, /* dst_mask */
1918 TRUE), /* pcrel_offset */
1919
1920 /* A 16 bit relative relocation without overflow. */
1921 HOWTO (R_PPC64_REL16_LO, /* type */
1922 0, /* rightshift */
1923 1, /* size (0 = byte, 1 = short, 2 = long) */
1924 16, /* bitsize */
1925 TRUE, /* pc_relative */
1926 0, /* bitpos */
1927 complain_overflow_dont,/* complain_on_overflow */
1928 bfd_elf_generic_reloc, /* special_function */
1929 "R_PPC64_REL16_LO", /* name */
1930 FALSE, /* partial_inplace */
1931 0, /* src_mask */
1932 0xffff, /* dst_mask */
1933 TRUE), /* pcrel_offset */
1934
1935 /* The high order 16 bits of a relative address. */
1936 HOWTO (R_PPC64_REL16_HI, /* type */
1937 16, /* rightshift */
1938 1, /* size (0 = byte, 1 = short, 2 = long) */
1939 16, /* bitsize */
1940 TRUE, /* pc_relative */
1941 0, /* bitpos */
1942 complain_overflow_dont, /* complain_on_overflow */
1943 bfd_elf_generic_reloc, /* special_function */
1944 "R_PPC64_REL16_HI", /* name */
1945 FALSE, /* partial_inplace */
1946 0, /* src_mask */
1947 0xffff, /* dst_mask */
1948 TRUE), /* pcrel_offset */
1949
1950 /* The high order 16 bits of a relative address, plus 1 if the contents of
1951 the low 16 bits, treated as a signed number, is negative. */
1952 HOWTO (R_PPC64_REL16_HA, /* type */
1953 16, /* rightshift */
1954 1, /* size (0 = byte, 1 = short, 2 = long) */
1955 16, /* bitsize */
1956 TRUE, /* pc_relative */
1957 0, /* bitpos */
1958 complain_overflow_dont, /* complain_on_overflow */
1959 ppc64_elf_ha_reloc, /* special_function */
1960 "R_PPC64_REL16_HA", /* name */
1961 FALSE, /* partial_inplace */
1962 0, /* src_mask */
1963 0xffff, /* dst_mask */
1964 TRUE), /* pcrel_offset */
1965
1966 /* GNU extension to record C++ vtable hierarchy. */
1967 HOWTO (R_PPC64_GNU_VTINHERIT, /* type */
1968 0, /* rightshift */
1969 0, /* size (0 = byte, 1 = short, 2 = long) */
1970 0, /* bitsize */
1971 FALSE, /* pc_relative */
1972 0, /* bitpos */
1973 complain_overflow_dont, /* complain_on_overflow */
1974 NULL, /* special_function */
1975 "R_PPC64_GNU_VTINHERIT", /* name */
1976 FALSE, /* partial_inplace */
1977 0, /* src_mask */
1978 0, /* dst_mask */
1979 FALSE), /* pcrel_offset */
1980
1981 /* GNU extension to record C++ vtable member usage. */
1982 HOWTO (R_PPC64_GNU_VTENTRY, /* type */
1983 0, /* rightshift */
1984 0, /* size (0 = byte, 1 = short, 2 = long) */
1985 0, /* bitsize */
1986 FALSE, /* pc_relative */
1987 0, /* bitpos */
1988 complain_overflow_dont, /* complain_on_overflow */
1989 NULL, /* special_function */
1990 "R_PPC64_GNU_VTENTRY", /* name */
1991 FALSE, /* partial_inplace */
1992 0, /* src_mask */
1993 0, /* dst_mask */
1994 FALSE), /* pcrel_offset */
1995 };
1996
1997 \f
1998 /* Initialize the ppc64_elf_howto_table, so that linear accesses can
1999 be done. */
2000
2001 static void
2002 ppc_howto_init (void)
2003 {
2004 unsigned int i, type;
2005
2006 for (i = 0;
2007 i < sizeof (ppc64_elf_howto_raw) / sizeof (ppc64_elf_howto_raw[0]);
2008 i++)
2009 {
2010 type = ppc64_elf_howto_raw[i].type;
2011 BFD_ASSERT (type < (sizeof (ppc64_elf_howto_table)
2012 / sizeof (ppc64_elf_howto_table[0])));
2013 ppc64_elf_howto_table[type] = &ppc64_elf_howto_raw[i];
2014 }
2015 }
2016
2017 static reloc_howto_type *
2018 ppc64_elf_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2019 bfd_reloc_code_real_type code)
2020 {
2021 enum elf_ppc64_reloc_type r = R_PPC64_NONE;
2022
2023 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2024 /* Initialize howto table if needed. */
2025 ppc_howto_init ();
2026
2027 switch (code)
2028 {
2029 default:
2030 return NULL;
2031
2032 case BFD_RELOC_NONE: r = R_PPC64_NONE;
2033 break;
2034 case BFD_RELOC_32: r = R_PPC64_ADDR32;
2035 break;
2036 case BFD_RELOC_PPC_BA26: r = R_PPC64_ADDR24;
2037 break;
2038 case BFD_RELOC_16: r = R_PPC64_ADDR16;
2039 break;
2040 case BFD_RELOC_LO16: r = R_PPC64_ADDR16_LO;
2041 break;
2042 case BFD_RELOC_HI16: r = R_PPC64_ADDR16_HI;
2043 break;
2044 case BFD_RELOC_HI16_S: r = R_PPC64_ADDR16_HA;
2045 break;
2046 case BFD_RELOC_PPC_BA16: r = R_PPC64_ADDR14;
2047 break;
2048 case BFD_RELOC_PPC_BA16_BRTAKEN: r = R_PPC64_ADDR14_BRTAKEN;
2049 break;
2050 case BFD_RELOC_PPC_BA16_BRNTAKEN: r = R_PPC64_ADDR14_BRNTAKEN;
2051 break;
2052 case BFD_RELOC_PPC_B26: r = R_PPC64_REL24;
2053 break;
2054 case BFD_RELOC_PPC_B16: r = R_PPC64_REL14;
2055 break;
2056 case BFD_RELOC_PPC_B16_BRTAKEN: r = R_PPC64_REL14_BRTAKEN;
2057 break;
2058 case BFD_RELOC_PPC_B16_BRNTAKEN: r = R_PPC64_REL14_BRNTAKEN;
2059 break;
2060 case BFD_RELOC_16_GOTOFF: r = R_PPC64_GOT16;
2061 break;
2062 case BFD_RELOC_LO16_GOTOFF: r = R_PPC64_GOT16_LO;
2063 break;
2064 case BFD_RELOC_HI16_GOTOFF: r = R_PPC64_GOT16_HI;
2065 break;
2066 case BFD_RELOC_HI16_S_GOTOFF: r = R_PPC64_GOT16_HA;
2067 break;
2068 case BFD_RELOC_PPC_COPY: r = R_PPC64_COPY;
2069 break;
2070 case BFD_RELOC_PPC_GLOB_DAT: r = R_PPC64_GLOB_DAT;
2071 break;
2072 case BFD_RELOC_32_PCREL: r = R_PPC64_REL32;
2073 break;
2074 case BFD_RELOC_32_PLTOFF: r = R_PPC64_PLT32;
2075 break;
2076 case BFD_RELOC_32_PLT_PCREL: r = R_PPC64_PLTREL32;
2077 break;
2078 case BFD_RELOC_LO16_PLTOFF: r = R_PPC64_PLT16_LO;
2079 break;
2080 case BFD_RELOC_HI16_PLTOFF: r = R_PPC64_PLT16_HI;
2081 break;
2082 case BFD_RELOC_HI16_S_PLTOFF: r = R_PPC64_PLT16_HA;
2083 break;
2084 case BFD_RELOC_16_BASEREL: r = R_PPC64_SECTOFF;
2085 break;
2086 case BFD_RELOC_LO16_BASEREL: r = R_PPC64_SECTOFF_LO;
2087 break;
2088 case BFD_RELOC_HI16_BASEREL: r = R_PPC64_SECTOFF_HI;
2089 break;
2090 case BFD_RELOC_HI16_S_BASEREL: r = R_PPC64_SECTOFF_HA;
2091 break;
2092 case BFD_RELOC_CTOR: r = R_PPC64_ADDR64;
2093 break;
2094 case BFD_RELOC_64: r = R_PPC64_ADDR64;
2095 break;
2096 case BFD_RELOC_PPC64_HIGHER: r = R_PPC64_ADDR16_HIGHER;
2097 break;
2098 case BFD_RELOC_PPC64_HIGHER_S: r = R_PPC64_ADDR16_HIGHERA;
2099 break;
2100 case BFD_RELOC_PPC64_HIGHEST: r = R_PPC64_ADDR16_HIGHEST;
2101 break;
2102 case BFD_RELOC_PPC64_HIGHEST_S: r = R_PPC64_ADDR16_HIGHESTA;
2103 break;
2104 case BFD_RELOC_64_PCREL: r = R_PPC64_REL64;
2105 break;
2106 case BFD_RELOC_64_PLTOFF: r = R_PPC64_PLT64;
2107 break;
2108 case BFD_RELOC_64_PLT_PCREL: r = R_PPC64_PLTREL64;
2109 break;
2110 case BFD_RELOC_PPC_TOC16: r = R_PPC64_TOC16;
2111 break;
2112 case BFD_RELOC_PPC64_TOC16_LO: r = R_PPC64_TOC16_LO;
2113 break;
2114 case BFD_RELOC_PPC64_TOC16_HI: r = R_PPC64_TOC16_HI;
2115 break;
2116 case BFD_RELOC_PPC64_TOC16_HA: r = R_PPC64_TOC16_HA;
2117 break;
2118 case BFD_RELOC_PPC64_TOC: r = R_PPC64_TOC;
2119 break;
2120 case BFD_RELOC_PPC64_PLTGOT16: r = R_PPC64_PLTGOT16;
2121 break;
2122 case BFD_RELOC_PPC64_PLTGOT16_LO: r = R_PPC64_PLTGOT16_LO;
2123 break;
2124 case BFD_RELOC_PPC64_PLTGOT16_HI: r = R_PPC64_PLTGOT16_HI;
2125 break;
2126 case BFD_RELOC_PPC64_PLTGOT16_HA: r = R_PPC64_PLTGOT16_HA;
2127 break;
2128 case BFD_RELOC_PPC64_ADDR16_DS: r = R_PPC64_ADDR16_DS;
2129 break;
2130 case BFD_RELOC_PPC64_ADDR16_LO_DS: r = R_PPC64_ADDR16_LO_DS;
2131 break;
2132 case BFD_RELOC_PPC64_GOT16_DS: r = R_PPC64_GOT16_DS;
2133 break;
2134 case BFD_RELOC_PPC64_GOT16_LO_DS: r = R_PPC64_GOT16_LO_DS;
2135 break;
2136 case BFD_RELOC_PPC64_PLT16_LO_DS: r = R_PPC64_PLT16_LO_DS;
2137 break;
2138 case BFD_RELOC_PPC64_SECTOFF_DS: r = R_PPC64_SECTOFF_DS;
2139 break;
2140 case BFD_RELOC_PPC64_SECTOFF_LO_DS: r = R_PPC64_SECTOFF_LO_DS;
2141 break;
2142 case BFD_RELOC_PPC64_TOC16_DS: r = R_PPC64_TOC16_DS;
2143 break;
2144 case BFD_RELOC_PPC64_TOC16_LO_DS: r = R_PPC64_TOC16_LO_DS;
2145 break;
2146 case BFD_RELOC_PPC64_PLTGOT16_DS: r = R_PPC64_PLTGOT16_DS;
2147 break;
2148 case BFD_RELOC_PPC64_PLTGOT16_LO_DS: r = R_PPC64_PLTGOT16_LO_DS;
2149 break;
2150 case BFD_RELOC_PPC_TLS: r = R_PPC64_TLS;
2151 break;
2152 case BFD_RELOC_PPC_TLSGD: r = R_PPC64_TLSGD;
2153 break;
2154 case BFD_RELOC_PPC_TLSLD: r = R_PPC64_TLSLD;
2155 break;
2156 case BFD_RELOC_PPC_DTPMOD: r = R_PPC64_DTPMOD64;
2157 break;
2158 case BFD_RELOC_PPC_TPREL16: r = R_PPC64_TPREL16;
2159 break;
2160 case BFD_RELOC_PPC_TPREL16_LO: r = R_PPC64_TPREL16_LO;
2161 break;
2162 case BFD_RELOC_PPC_TPREL16_HI: r = R_PPC64_TPREL16_HI;
2163 break;
2164 case BFD_RELOC_PPC_TPREL16_HA: r = R_PPC64_TPREL16_HA;
2165 break;
2166 case BFD_RELOC_PPC_TPREL: r = R_PPC64_TPREL64;
2167 break;
2168 case BFD_RELOC_PPC_DTPREL16: r = R_PPC64_DTPREL16;
2169 break;
2170 case BFD_RELOC_PPC_DTPREL16_LO: r = R_PPC64_DTPREL16_LO;
2171 break;
2172 case BFD_RELOC_PPC_DTPREL16_HI: r = R_PPC64_DTPREL16_HI;
2173 break;
2174 case BFD_RELOC_PPC_DTPREL16_HA: r = R_PPC64_DTPREL16_HA;
2175 break;
2176 case BFD_RELOC_PPC_DTPREL: r = R_PPC64_DTPREL64;
2177 break;
2178 case BFD_RELOC_PPC_GOT_TLSGD16: r = R_PPC64_GOT_TLSGD16;
2179 break;
2180 case BFD_RELOC_PPC_GOT_TLSGD16_LO: r = R_PPC64_GOT_TLSGD16_LO;
2181 break;
2182 case BFD_RELOC_PPC_GOT_TLSGD16_HI: r = R_PPC64_GOT_TLSGD16_HI;
2183 break;
2184 case BFD_RELOC_PPC_GOT_TLSGD16_HA: r = R_PPC64_GOT_TLSGD16_HA;
2185 break;
2186 case BFD_RELOC_PPC_GOT_TLSLD16: r = R_PPC64_GOT_TLSLD16;
2187 break;
2188 case BFD_RELOC_PPC_GOT_TLSLD16_LO: r = R_PPC64_GOT_TLSLD16_LO;
2189 break;
2190 case BFD_RELOC_PPC_GOT_TLSLD16_HI: r = R_PPC64_GOT_TLSLD16_HI;
2191 break;
2192 case BFD_RELOC_PPC_GOT_TLSLD16_HA: r = R_PPC64_GOT_TLSLD16_HA;
2193 break;
2194 case BFD_RELOC_PPC_GOT_TPREL16: r = R_PPC64_GOT_TPREL16_DS;
2195 break;
2196 case BFD_RELOC_PPC_GOT_TPREL16_LO: r = R_PPC64_GOT_TPREL16_LO_DS;
2197 break;
2198 case BFD_RELOC_PPC_GOT_TPREL16_HI: r = R_PPC64_GOT_TPREL16_HI;
2199 break;
2200 case BFD_RELOC_PPC_GOT_TPREL16_HA: r = R_PPC64_GOT_TPREL16_HA;
2201 break;
2202 case BFD_RELOC_PPC_GOT_DTPREL16: r = R_PPC64_GOT_DTPREL16_DS;
2203 break;
2204 case BFD_RELOC_PPC_GOT_DTPREL16_LO: r = R_PPC64_GOT_DTPREL16_LO_DS;
2205 break;
2206 case BFD_RELOC_PPC_GOT_DTPREL16_HI: r = R_PPC64_GOT_DTPREL16_HI;
2207 break;
2208 case BFD_RELOC_PPC_GOT_DTPREL16_HA: r = R_PPC64_GOT_DTPREL16_HA;
2209 break;
2210 case BFD_RELOC_PPC64_TPREL16_DS: r = R_PPC64_TPREL16_DS;
2211 break;
2212 case BFD_RELOC_PPC64_TPREL16_LO_DS: r = R_PPC64_TPREL16_LO_DS;
2213 break;
2214 case BFD_RELOC_PPC64_TPREL16_HIGHER: r = R_PPC64_TPREL16_HIGHER;
2215 break;
2216 case BFD_RELOC_PPC64_TPREL16_HIGHERA: r = R_PPC64_TPREL16_HIGHERA;
2217 break;
2218 case BFD_RELOC_PPC64_TPREL16_HIGHEST: r = R_PPC64_TPREL16_HIGHEST;
2219 break;
2220 case BFD_RELOC_PPC64_TPREL16_HIGHESTA: r = R_PPC64_TPREL16_HIGHESTA;
2221 break;
2222 case BFD_RELOC_PPC64_DTPREL16_DS: r = R_PPC64_DTPREL16_DS;
2223 break;
2224 case BFD_RELOC_PPC64_DTPREL16_LO_DS: r = R_PPC64_DTPREL16_LO_DS;
2225 break;
2226 case BFD_RELOC_PPC64_DTPREL16_HIGHER: r = R_PPC64_DTPREL16_HIGHER;
2227 break;
2228 case BFD_RELOC_PPC64_DTPREL16_HIGHERA: r = R_PPC64_DTPREL16_HIGHERA;
2229 break;
2230 case BFD_RELOC_PPC64_DTPREL16_HIGHEST: r = R_PPC64_DTPREL16_HIGHEST;
2231 break;
2232 case BFD_RELOC_PPC64_DTPREL16_HIGHESTA: r = R_PPC64_DTPREL16_HIGHESTA;
2233 break;
2234 case BFD_RELOC_16_PCREL: r = R_PPC64_REL16;
2235 break;
2236 case BFD_RELOC_LO16_PCREL: r = R_PPC64_REL16_LO;
2237 break;
2238 case BFD_RELOC_HI16_PCREL: r = R_PPC64_REL16_HI;
2239 break;
2240 case BFD_RELOC_HI16_S_PCREL: r = R_PPC64_REL16_HA;
2241 break;
2242 case BFD_RELOC_VTABLE_INHERIT: r = R_PPC64_GNU_VTINHERIT;
2243 break;
2244 case BFD_RELOC_VTABLE_ENTRY: r = R_PPC64_GNU_VTENTRY;
2245 break;
2246 }
2247
2248 return ppc64_elf_howto_table[r];
2249 };
2250
2251 static reloc_howto_type *
2252 ppc64_elf_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2253 const char *r_name)
2254 {
2255 unsigned int i;
2256
2257 for (i = 0;
2258 i < sizeof (ppc64_elf_howto_raw) / sizeof (ppc64_elf_howto_raw[0]);
2259 i++)
2260 if (ppc64_elf_howto_raw[i].name != NULL
2261 && strcasecmp (ppc64_elf_howto_raw[i].name, r_name) == 0)
2262 return &ppc64_elf_howto_raw[i];
2263
2264 return NULL;
2265 }
2266
2267 /* Set the howto pointer for a PowerPC ELF reloc. */
2268
2269 static void
2270 ppc64_elf_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr,
2271 Elf_Internal_Rela *dst)
2272 {
2273 unsigned int type;
2274
2275 /* Initialize howto table if needed. */
2276 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2277 ppc_howto_init ();
2278
2279 type = ELF64_R_TYPE (dst->r_info);
2280 if (type >= (sizeof (ppc64_elf_howto_table)
2281 / sizeof (ppc64_elf_howto_table[0])))
2282 {
2283 (*_bfd_error_handler) (_("%B: invalid relocation type %d"),
2284 abfd, (int) type);
2285 type = R_PPC64_NONE;
2286 }
2287 cache_ptr->howto = ppc64_elf_howto_table[type];
2288 }
2289
2290 /* Handle the R_PPC64_ADDR16_HA and similar relocs. */
2291
2292 static bfd_reloc_status_type
2293 ppc64_elf_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2294 void *data, asection *input_section,
2295 bfd *output_bfd, char **error_message)
2296 {
2297 /* If this is a relocatable link (output_bfd test tells us), just
2298 call the generic function. Any adjustment will be done at final
2299 link time. */
2300 if (output_bfd != NULL)
2301 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2302 input_section, output_bfd, error_message);
2303
2304 /* Adjust the addend for sign extension of the low 16 bits.
2305 We won't actually be using the low 16 bits, so trashing them
2306 doesn't matter. */
2307 reloc_entry->addend += 0x8000;
2308 return bfd_reloc_continue;
2309 }
2310
2311 static bfd_reloc_status_type
2312 ppc64_elf_branch_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2313 void *data, asection *input_section,
2314 bfd *output_bfd, char **error_message)
2315 {
2316 if (output_bfd != NULL)
2317 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2318 input_section, output_bfd, error_message);
2319
2320 if (strcmp (symbol->section->name, ".opd") == 0
2321 && (symbol->section->owner->flags & DYNAMIC) == 0)
2322 {
2323 bfd_vma dest = opd_entry_value (symbol->section,
2324 symbol->value + reloc_entry->addend,
2325 NULL, NULL);
2326 if (dest != (bfd_vma) -1)
2327 reloc_entry->addend = dest - (symbol->value
2328 + symbol->section->output_section->vma
2329 + symbol->section->output_offset);
2330 }
2331 return bfd_reloc_continue;
2332 }
2333
2334 static bfd_reloc_status_type
2335 ppc64_elf_brtaken_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2336 void *data, asection *input_section,
2337 bfd *output_bfd, char **error_message)
2338 {
2339 long insn;
2340 enum elf_ppc64_reloc_type r_type;
2341 bfd_size_type octets;
2342 /* Disabled until we sort out how ld should choose 'y' vs 'at'. */
2343 bfd_boolean is_power4 = FALSE;
2344
2345 /* If this is a relocatable link (output_bfd test tells us), just
2346 call the generic function. Any adjustment will be done at final
2347 link time. */
2348 if (output_bfd != NULL)
2349 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2350 input_section, output_bfd, error_message);
2351
2352 octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2353 insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
2354 insn &= ~(0x01 << 21);
2355 r_type = reloc_entry->howto->type;
2356 if (r_type == R_PPC64_ADDR14_BRTAKEN
2357 || r_type == R_PPC64_REL14_BRTAKEN)
2358 insn |= 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field. */
2359
2360 if (is_power4)
2361 {
2362 /* Set 'a' bit. This is 0b00010 in BO field for branch
2363 on CR(BI) insns (BO == 001at or 011at), and 0b01000
2364 for branch on CTR insns (BO == 1a00t or 1a01t). */
2365 if ((insn & (0x14 << 21)) == (0x04 << 21))
2366 insn |= 0x02 << 21;
2367 else if ((insn & (0x14 << 21)) == (0x10 << 21))
2368 insn |= 0x08 << 21;
2369 else
2370 goto out;
2371 }
2372 else
2373 {
2374 bfd_vma target = 0;
2375 bfd_vma from;
2376
2377 if (!bfd_is_com_section (symbol->section))
2378 target = symbol->value;
2379 target += symbol->section->output_section->vma;
2380 target += symbol->section->output_offset;
2381 target += reloc_entry->addend;
2382
2383 from = (reloc_entry->address
2384 + input_section->output_offset
2385 + input_section->output_section->vma);
2386
2387 /* Invert 'y' bit if not the default. */
2388 if ((bfd_signed_vma) (target - from) < 0)
2389 insn ^= 0x01 << 21;
2390 }
2391 bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
2392 out:
2393 return ppc64_elf_branch_reloc (abfd, reloc_entry, symbol, data,
2394 input_section, output_bfd, error_message);
2395 }
2396
2397 static bfd_reloc_status_type
2398 ppc64_elf_sectoff_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2399 void *data, asection *input_section,
2400 bfd *output_bfd, char **error_message)
2401 {
2402 /* If this is a relocatable link (output_bfd test tells us), just
2403 call the generic function. Any adjustment will be done at final
2404 link time. */
2405 if (output_bfd != NULL)
2406 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2407 input_section, output_bfd, error_message);
2408
2409 /* Subtract the symbol section base address. */
2410 reloc_entry->addend -= symbol->section->output_section->vma;
2411 return bfd_reloc_continue;
2412 }
2413
2414 static bfd_reloc_status_type
2415 ppc64_elf_sectoff_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2416 void *data, asection *input_section,
2417 bfd *output_bfd, char **error_message)
2418 {
2419 /* If this is a relocatable link (output_bfd test tells us), just
2420 call the generic function. Any adjustment will be done at final
2421 link time. */
2422 if (output_bfd != NULL)
2423 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2424 input_section, output_bfd, error_message);
2425
2426 /* Subtract the symbol section base address. */
2427 reloc_entry->addend -= symbol->section->output_section->vma;
2428
2429 /* Adjust the addend for sign extension of the low 16 bits. */
2430 reloc_entry->addend += 0x8000;
2431 return bfd_reloc_continue;
2432 }
2433
2434 static bfd_reloc_status_type
2435 ppc64_elf_toc_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2436 void *data, asection *input_section,
2437 bfd *output_bfd, char **error_message)
2438 {
2439 bfd_vma TOCstart;
2440
2441 /* If this is a relocatable link (output_bfd test tells us), just
2442 call the generic function. Any adjustment will be done at final
2443 link time. */
2444 if (output_bfd != NULL)
2445 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2446 input_section, output_bfd, error_message);
2447
2448 TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2449 if (TOCstart == 0)
2450 TOCstart = ppc64_elf_toc (input_section->output_section->owner);
2451
2452 /* Subtract the TOC base address. */
2453 reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2454 return bfd_reloc_continue;
2455 }
2456
2457 static bfd_reloc_status_type
2458 ppc64_elf_toc_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2459 void *data, asection *input_section,
2460 bfd *output_bfd, char **error_message)
2461 {
2462 bfd_vma TOCstart;
2463
2464 /* If this is a relocatable link (output_bfd test tells us), just
2465 call the generic function. Any adjustment will be done at final
2466 link time. */
2467 if (output_bfd != NULL)
2468 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2469 input_section, output_bfd, error_message);
2470
2471 TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2472 if (TOCstart == 0)
2473 TOCstart = ppc64_elf_toc (input_section->output_section->owner);
2474
2475 /* Subtract the TOC base address. */
2476 reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2477
2478 /* Adjust the addend for sign extension of the low 16 bits. */
2479 reloc_entry->addend += 0x8000;
2480 return bfd_reloc_continue;
2481 }
2482
2483 static bfd_reloc_status_type
2484 ppc64_elf_toc64_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2485 void *data, asection *input_section,
2486 bfd *output_bfd, char **error_message)
2487 {
2488 bfd_vma TOCstart;
2489 bfd_size_type octets;
2490
2491 /* If this is a relocatable link (output_bfd test tells us), just
2492 call the generic function. Any adjustment will be done at final
2493 link time. */
2494 if (output_bfd != NULL)
2495 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2496 input_section, output_bfd, error_message);
2497
2498 TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2499 if (TOCstart == 0)
2500 TOCstart = ppc64_elf_toc (input_section->output_section->owner);
2501
2502 octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2503 bfd_put_64 (abfd, TOCstart + TOC_BASE_OFF, (bfd_byte *) data + octets);
2504 return bfd_reloc_ok;
2505 }
2506
2507 static bfd_reloc_status_type
2508 ppc64_elf_unhandled_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2509 void *data, asection *input_section,
2510 bfd *output_bfd, char **error_message)
2511 {
2512 /* If this is a relocatable link (output_bfd test tells us), just
2513 call the generic function. Any adjustment will be done at final
2514 link time. */
2515 if (output_bfd != NULL)
2516 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2517 input_section, output_bfd, error_message);
2518
2519 if (error_message != NULL)
2520 {
2521 static char buf[60];
2522 sprintf (buf, "generic linker can't handle %s",
2523 reloc_entry->howto->name);
2524 *error_message = buf;
2525 }
2526 return bfd_reloc_dangerous;
2527 }
2528
2529 /* Track GOT entries needed for a given symbol. We might need more
2530 than one got entry per symbol. */
2531 struct got_entry
2532 {
2533 struct got_entry *next;
2534
2535 /* The symbol addend that we'll be placing in the GOT. */
2536 bfd_vma addend;
2537
2538 /* Unlike other ELF targets, we use separate GOT entries for the same
2539 symbol referenced from different input files. This is to support
2540 automatic multiple TOC/GOT sections, where the TOC base can vary
2541 from one input file to another. After partitioning into TOC groups
2542 we merge entries within the group.
2543
2544 Point to the BFD owning this GOT entry. */
2545 bfd *owner;
2546
2547 /* Zero for non-tls entries, or TLS_TLS and one of TLS_GD, TLS_LD,
2548 TLS_TPREL or TLS_DTPREL for tls entries. */
2549 char tls_type;
2550
2551 /* Non-zero if got.ent points to real entry. */
2552 char is_indirect;
2553
2554 /* Reference count until size_dynamic_sections, GOT offset thereafter. */
2555 union
2556 {
2557 bfd_signed_vma refcount;
2558 bfd_vma offset;
2559 struct got_entry *ent;
2560 } got;
2561 };
2562
2563 /* The same for PLT. */
2564 struct plt_entry
2565 {
2566 struct plt_entry *next;
2567
2568 bfd_vma addend;
2569
2570 union
2571 {
2572 bfd_signed_vma refcount;
2573 bfd_vma offset;
2574 } plt;
2575 };
2576
2577 struct ppc64_elf_obj_tdata
2578 {
2579 struct elf_obj_tdata elf;
2580
2581 /* Shortcuts to dynamic linker sections. */
2582 asection *got;
2583 asection *relgot;
2584
2585 /* Used during garbage collection. We attach global symbols defined
2586 on removed .opd entries to this section so that the sym is removed. */
2587 asection *deleted_section;
2588
2589 /* TLS local dynamic got entry handling. Support for multiple GOT
2590 sections means we potentially need one of these for each input bfd. */
2591 struct got_entry tlsld_got;
2592
2593 /* A copy of relocs before they are modified for --emit-relocs. */
2594 Elf_Internal_Rela *opd_relocs;
2595 };
2596
2597 #define ppc64_elf_tdata(bfd) \
2598 ((struct ppc64_elf_obj_tdata *) (bfd)->tdata.any)
2599
2600 #define ppc64_tlsld_got(bfd) \
2601 (&ppc64_elf_tdata (bfd)->tlsld_got)
2602
2603 #define is_ppc64_elf(bfd) \
2604 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
2605 && elf_object_id (bfd) == PPC64_ELF_DATA)
2606
2607 /* Override the generic function because we store some extras. */
2608
2609 static bfd_boolean
2610 ppc64_elf_mkobject (bfd *abfd)
2611 {
2612 return bfd_elf_allocate_object (abfd, sizeof (struct ppc64_elf_obj_tdata),
2613 PPC64_ELF_DATA);
2614 }
2615
2616 /* Fix bad default arch selected for a 64 bit input bfd when the
2617 default is 32 bit. */
2618
2619 static bfd_boolean
2620 ppc64_elf_object_p (bfd *abfd)
2621 {
2622 if (abfd->arch_info->the_default && abfd->arch_info->bits_per_word == 32)
2623 {
2624 Elf_Internal_Ehdr *i_ehdr = elf_elfheader (abfd);
2625
2626 if (i_ehdr->e_ident[EI_CLASS] == ELFCLASS64)
2627 {
2628 /* Relies on arch after 32 bit default being 64 bit default. */
2629 abfd->arch_info = abfd->arch_info->next;
2630 BFD_ASSERT (abfd->arch_info->bits_per_word == 64);
2631 }
2632 }
2633 return TRUE;
2634 }
2635
2636 /* Support for core dump NOTE sections. */
2637
2638 static bfd_boolean
2639 ppc64_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
2640 {
2641 size_t offset, size;
2642
2643 if (note->descsz != 504)
2644 return FALSE;
2645
2646 /* pr_cursig */
2647 elf_tdata (abfd)->core_signal = bfd_get_16 (abfd, note->descdata + 12);
2648
2649 /* pr_pid */
2650 elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, note->descdata + 32);
2651
2652 /* pr_reg */
2653 offset = 112;
2654 size = 384;
2655
2656 /* Make a ".reg/999" section. */
2657 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
2658 size, note->descpos + offset);
2659 }
2660
2661 static bfd_boolean
2662 ppc64_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
2663 {
2664 if (note->descsz != 136)
2665 return FALSE;
2666
2667 elf_tdata (abfd)->core_program
2668 = _bfd_elfcore_strndup (abfd, note->descdata + 40, 16);
2669 elf_tdata (abfd)->core_command
2670 = _bfd_elfcore_strndup (abfd, note->descdata + 56, 80);
2671
2672 return TRUE;
2673 }
2674
2675 static char *
2676 ppc64_elf_write_core_note (bfd *abfd, char *buf, int *bufsiz, int note_type,
2677 ...)
2678 {
2679 switch (note_type)
2680 {
2681 default:
2682 return NULL;
2683
2684 case NT_PRPSINFO:
2685 {
2686 char data[136];
2687 va_list ap;
2688
2689 va_start (ap, note_type);
2690 memset (data, 0, 40);
2691 strncpy (data + 40, va_arg (ap, const char *), 16);
2692 strncpy (data + 56, va_arg (ap, const char *), 80);
2693 va_end (ap);
2694 return elfcore_write_note (abfd, buf, bufsiz,
2695 "CORE", note_type, data, sizeof (data));
2696 }
2697
2698 case NT_PRSTATUS:
2699 {
2700 char data[504];
2701 va_list ap;
2702 long pid;
2703 int cursig;
2704 const void *greg;
2705
2706 va_start (ap, note_type);
2707 memset (data, 0, 112);
2708 pid = va_arg (ap, long);
2709 bfd_put_32 (abfd, pid, data + 32);
2710 cursig = va_arg (ap, int);
2711 bfd_put_16 (abfd, cursig, data + 12);
2712 greg = va_arg (ap, const void *);
2713 memcpy (data + 112, greg, 384);
2714 memset (data + 496, 0, 8);
2715 va_end (ap);
2716 return elfcore_write_note (abfd, buf, bufsiz,
2717 "CORE", note_type, data, sizeof (data));
2718 }
2719 }
2720 }
2721
2722 /* Merge backend specific data from an object file to the output
2723 object file when linking. */
2724
2725 static bfd_boolean
2726 ppc64_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
2727 {
2728 /* Check if we have the same endianess. */
2729 if (ibfd->xvec->byteorder != obfd->xvec->byteorder
2730 && ibfd->xvec->byteorder != BFD_ENDIAN_UNKNOWN
2731 && obfd->xvec->byteorder != BFD_ENDIAN_UNKNOWN)
2732 {
2733 const char *msg;
2734
2735 if (bfd_big_endian (ibfd))
2736 msg = _("%B: compiled for a big endian system "
2737 "and target is little endian");
2738 else
2739 msg = _("%B: compiled for a little endian system "
2740 "and target is big endian");
2741
2742 (*_bfd_error_handler) (msg, ibfd);
2743
2744 bfd_set_error (bfd_error_wrong_format);
2745 return FALSE;
2746 }
2747
2748 return TRUE;
2749 }
2750
2751 /* Add extra PPC sections. */
2752
2753 static const struct bfd_elf_special_section ppc64_elf_special_sections[]=
2754 {
2755 { STRING_COMMA_LEN (".plt"), 0, SHT_NOBITS, 0 },
2756 { STRING_COMMA_LEN (".sbss"), -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE },
2757 { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2758 { STRING_COMMA_LEN (".toc"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2759 { STRING_COMMA_LEN (".toc1"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2760 { STRING_COMMA_LEN (".tocbss"), 0, SHT_NOBITS, SHF_ALLOC + SHF_WRITE },
2761 { NULL, 0, 0, 0, 0 }
2762 };
2763
2764 enum _ppc64_sec_type {
2765 sec_normal = 0,
2766 sec_opd = 1,
2767 sec_toc = 2
2768 };
2769
2770 struct _ppc64_elf_section_data
2771 {
2772 struct bfd_elf_section_data elf;
2773
2774 union
2775 {
2776 /* An array with one entry for each opd function descriptor. */
2777 struct _opd_sec_data
2778 {
2779 /* Points to the function code section for local opd entries. */
2780 asection **func_sec;
2781
2782 /* After editing .opd, adjust references to opd local syms. */
2783 long *adjust;
2784 } opd;
2785
2786 /* An array for toc sections, indexed by offset/8. */
2787 struct _toc_sec_data
2788 {
2789 /* Specifies the relocation symbol index used at a given toc offset. */
2790 unsigned *symndx;
2791
2792 /* And the relocation addend. */
2793 bfd_vma *add;
2794 } toc;
2795 } u;
2796
2797 enum _ppc64_sec_type sec_type:2;
2798
2799 /* Flag set when small branches are detected. Used to
2800 select suitable defaults for the stub group size. */
2801 unsigned int has_14bit_branch:1;
2802 };
2803
2804 #define ppc64_elf_section_data(sec) \
2805 ((struct _ppc64_elf_section_data *) elf_section_data (sec))
2806
2807 static bfd_boolean
2808 ppc64_elf_new_section_hook (bfd *abfd, asection *sec)
2809 {
2810 if (!sec->used_by_bfd)
2811 {
2812 struct _ppc64_elf_section_data *sdata;
2813 bfd_size_type amt = sizeof (*sdata);
2814
2815 sdata = bfd_zalloc (abfd, amt);
2816 if (sdata == NULL)
2817 return FALSE;
2818 sec->used_by_bfd = sdata;
2819 }
2820
2821 return _bfd_elf_new_section_hook (abfd, sec);
2822 }
2823
2824 static struct _opd_sec_data *
2825 get_opd_info (asection * sec)
2826 {
2827 if (sec != NULL
2828 && ppc64_elf_section_data (sec) != NULL
2829 && ppc64_elf_section_data (sec)->sec_type == sec_opd)
2830 return &ppc64_elf_section_data (sec)->u.opd;
2831 return NULL;
2832 }
2833 \f
2834 /* Parameters for the qsort hook. */
2835 static bfd_boolean synthetic_relocatable;
2836
2837 /* qsort comparison function for ppc64_elf_get_synthetic_symtab. */
2838
2839 static int
2840 compare_symbols (const void *ap, const void *bp)
2841 {
2842 const asymbol *a = * (const asymbol **) ap;
2843 const asymbol *b = * (const asymbol **) bp;
2844
2845 /* Section symbols first. */
2846 if ((a->flags & BSF_SECTION_SYM) && !(b->flags & BSF_SECTION_SYM))
2847 return -1;
2848 if (!(a->flags & BSF_SECTION_SYM) && (b->flags & BSF_SECTION_SYM))
2849 return 1;
2850
2851 /* then .opd symbols. */
2852 if (strcmp (a->section->name, ".opd") == 0
2853 && strcmp (b->section->name, ".opd") != 0)
2854 return -1;
2855 if (strcmp (a->section->name, ".opd") != 0
2856 && strcmp (b->section->name, ".opd") == 0)
2857 return 1;
2858
2859 /* then other code symbols. */
2860 if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
2861 == (SEC_CODE | SEC_ALLOC)
2862 && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
2863 != (SEC_CODE | SEC_ALLOC))
2864 return -1;
2865
2866 if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
2867 != (SEC_CODE | SEC_ALLOC)
2868 && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
2869 == (SEC_CODE | SEC_ALLOC))
2870 return 1;
2871
2872 if (synthetic_relocatable)
2873 {
2874 if (a->section->id < b->section->id)
2875 return -1;
2876
2877 if (a->section->id > b->section->id)
2878 return 1;
2879 }
2880
2881 if (a->value + a->section->vma < b->value + b->section->vma)
2882 return -1;
2883
2884 if (a->value + a->section->vma > b->value + b->section->vma)
2885 return 1;
2886
2887 /* For syms with the same value, prefer strong dynamic global function
2888 syms over other syms. */
2889 if ((a->flags & BSF_GLOBAL) != 0 && (b->flags & BSF_GLOBAL) == 0)
2890 return -1;
2891
2892 if ((a->flags & BSF_GLOBAL) == 0 && (b->flags & BSF_GLOBAL) != 0)
2893 return 1;
2894
2895 if ((a->flags & BSF_FUNCTION) != 0 && (b->flags & BSF_FUNCTION) == 0)
2896 return -1;
2897
2898 if ((a->flags & BSF_FUNCTION) == 0 && (b->flags & BSF_FUNCTION) != 0)
2899 return 1;
2900
2901 if ((a->flags & BSF_WEAK) == 0 && (b->flags & BSF_WEAK) != 0)
2902 return -1;
2903
2904 if ((a->flags & BSF_WEAK) != 0 && (b->flags & BSF_WEAK) == 0)
2905 return 1;
2906
2907 if ((a->flags & BSF_DYNAMIC) != 0 && (b->flags & BSF_DYNAMIC) == 0)
2908 return -1;
2909
2910 if ((a->flags & BSF_DYNAMIC) == 0 && (b->flags & BSF_DYNAMIC) != 0)
2911 return 1;
2912
2913 return 0;
2914 }
2915
2916 /* Search SYMS for a symbol of the given VALUE. */
2917
2918 static asymbol *
2919 sym_exists_at (asymbol **syms, long lo, long hi, int id, bfd_vma value)
2920 {
2921 long mid;
2922
2923 if (id == -1)
2924 {
2925 while (lo < hi)
2926 {
2927 mid = (lo + hi) >> 1;
2928 if (syms[mid]->value + syms[mid]->section->vma < value)
2929 lo = mid + 1;
2930 else if (syms[mid]->value + syms[mid]->section->vma > value)
2931 hi = mid;
2932 else
2933 return syms[mid];
2934 }
2935 }
2936 else
2937 {
2938 while (lo < hi)
2939 {
2940 mid = (lo + hi) >> 1;
2941 if (syms[mid]->section->id < id)
2942 lo = mid + 1;
2943 else if (syms[mid]->section->id > id)
2944 hi = mid;
2945 else if (syms[mid]->value < value)
2946 lo = mid + 1;
2947 else if (syms[mid]->value > value)
2948 hi = mid;
2949 else
2950 return syms[mid];
2951 }
2952 }
2953 return NULL;
2954 }
2955
2956 static bfd_boolean
2957 section_covers_vma (bfd *abfd ATTRIBUTE_UNUSED, asection *section, void *ptr)
2958 {
2959 bfd_vma vma = *(bfd_vma *) ptr;
2960 return ((section->flags & SEC_ALLOC) != 0
2961 && section->vma <= vma
2962 && vma < section->vma + section->size);
2963 }
2964
2965 /* Create synthetic symbols, effectively restoring "dot-symbol" function
2966 entry syms. Also generate @plt symbols for the glink branch table. */
2967
2968 static long
2969 ppc64_elf_get_synthetic_symtab (bfd *abfd,
2970 long static_count, asymbol **static_syms,
2971 long dyn_count, asymbol **dyn_syms,
2972 asymbol **ret)
2973 {
2974 asymbol *s;
2975 long i;
2976 long count;
2977 char *names;
2978 long symcount, codesecsym, codesecsymend, secsymend, opdsymend;
2979 asection *opd;
2980 bfd_boolean relocatable = (abfd->flags & (EXEC_P | DYNAMIC)) == 0;
2981 asymbol **syms;
2982
2983 *ret = NULL;
2984
2985 opd = bfd_get_section_by_name (abfd, ".opd");
2986 if (opd == NULL)
2987 return 0;
2988
2989 symcount = static_count;
2990 if (!relocatable)
2991 symcount += dyn_count;
2992 if (symcount == 0)
2993 return 0;
2994
2995 syms = bfd_malloc ((symcount + 1) * sizeof (*syms));
2996 if (syms == NULL)
2997 return -1;
2998
2999 if (!relocatable && static_count != 0 && dyn_count != 0)
3000 {
3001 /* Use both symbol tables. */
3002 memcpy (syms, static_syms, static_count * sizeof (*syms));
3003 memcpy (syms + static_count, dyn_syms, (dyn_count + 1) * sizeof (*syms));
3004 }
3005 else if (!relocatable && static_count == 0)
3006 memcpy (syms, dyn_syms, (symcount + 1) * sizeof (*syms));
3007 else
3008 memcpy (syms, static_syms, (symcount + 1) * sizeof (*syms));
3009
3010 synthetic_relocatable = relocatable;
3011 qsort (syms, symcount, sizeof (*syms), compare_symbols);
3012
3013 if (!relocatable && symcount > 1)
3014 {
3015 long j;
3016 /* Trim duplicate syms, since we may have merged the normal and
3017 dynamic symbols. Actually, we only care about syms that have
3018 different values, so trim any with the same value. */
3019 for (i = 1, j = 1; i < symcount; ++i)
3020 if (syms[i - 1]->value + syms[i - 1]->section->vma
3021 != syms[i]->value + syms[i]->section->vma)
3022 syms[j++] = syms[i];
3023 symcount = j;
3024 }
3025
3026 i = 0;
3027 if (strcmp (syms[i]->section->name, ".opd") == 0)
3028 ++i;
3029 codesecsym = i;
3030
3031 for (; i < symcount; ++i)
3032 if (((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3033 != (SEC_CODE | SEC_ALLOC))
3034 || (syms[i]->flags & BSF_SECTION_SYM) == 0)
3035 break;
3036 codesecsymend = i;
3037
3038 for (; i < symcount; ++i)
3039 if ((syms[i]->flags & BSF_SECTION_SYM) == 0)
3040 break;
3041 secsymend = i;
3042
3043 for (; i < symcount; ++i)
3044 if (strcmp (syms[i]->section->name, ".opd") != 0)
3045 break;
3046 opdsymend = i;
3047
3048 for (; i < symcount; ++i)
3049 if ((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3050 != (SEC_CODE | SEC_ALLOC))
3051 break;
3052 symcount = i;
3053
3054 count = 0;
3055
3056 if (relocatable)
3057 {
3058 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3059 arelent *r;
3060 size_t size;
3061 long relcount;
3062
3063 if (opdsymend == secsymend)
3064 goto done;
3065
3066 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3067 relcount = (opd->flags & SEC_RELOC) ? opd->reloc_count : 0;
3068 if (relcount == 0)
3069 goto done;
3070
3071 if (!(*slurp_relocs) (abfd, opd, static_syms, FALSE))
3072 {
3073 count = -1;
3074 goto done;
3075 }
3076
3077 size = 0;
3078 for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3079 {
3080 asymbol *sym;
3081
3082 while (r < opd->relocation + relcount
3083 && r->address < syms[i]->value + opd->vma)
3084 ++r;
3085
3086 if (r == opd->relocation + relcount)
3087 break;
3088
3089 if (r->address != syms[i]->value + opd->vma)
3090 continue;
3091
3092 if (r->howto->type != R_PPC64_ADDR64)
3093 continue;
3094
3095 sym = *r->sym_ptr_ptr;
3096 if (!sym_exists_at (syms, opdsymend, symcount,
3097 sym->section->id, sym->value + r->addend))
3098 {
3099 ++count;
3100 size += sizeof (asymbol);
3101 size += strlen (syms[i]->name) + 2;
3102 }
3103 }
3104
3105 s = *ret = bfd_malloc (size);
3106 if (s == NULL)
3107 {
3108 count = -1;
3109 goto done;
3110 }
3111
3112 names = (char *) (s + count);
3113
3114 for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3115 {
3116 asymbol *sym;
3117
3118 while (r < opd->relocation + relcount
3119 && r->address < syms[i]->value + opd->vma)
3120 ++r;
3121
3122 if (r == opd->relocation + relcount)
3123 break;
3124
3125 if (r->address != syms[i]->value + opd->vma)
3126 continue;
3127
3128 if (r->howto->type != R_PPC64_ADDR64)
3129 continue;
3130
3131 sym = *r->sym_ptr_ptr;
3132 if (!sym_exists_at (syms, opdsymend, symcount,
3133 sym->section->id, sym->value + r->addend))
3134 {
3135 size_t len;
3136
3137 *s = *syms[i];
3138 s->flags |= BSF_SYNTHETIC;
3139 s->section = sym->section;
3140 s->value = sym->value + r->addend;
3141 s->name = names;
3142 *names++ = '.';
3143 len = strlen (syms[i]->name);
3144 memcpy (names, syms[i]->name, len + 1);
3145 names += len + 1;
3146 /* Have udata.p point back to the original symbol this
3147 synthetic symbol was derived from. */
3148 s->udata.p = syms[i];
3149 s++;
3150 }
3151 }
3152 }
3153 else
3154 {
3155 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3156 bfd_byte *contents;
3157 size_t size;
3158 long plt_count = 0;
3159 bfd_vma glink_vma = 0, resolv_vma = 0;
3160 asection *dynamic, *glink = NULL, *relplt = NULL;
3161 arelent *p;
3162
3163 if (!bfd_malloc_and_get_section (abfd, opd, &contents))
3164 {
3165 if (contents)
3166 {
3167 free_contents_and_exit:
3168 free (contents);
3169 }
3170 count = -1;
3171 goto done;
3172 }
3173
3174 size = 0;
3175 for (i = secsymend; i < opdsymend; ++i)
3176 {
3177 bfd_vma ent;
3178
3179 /* Ignore bogus symbols. */
3180 if (syms[i]->value > opd->size - 8)
3181 continue;
3182
3183 ent = bfd_get_64 (abfd, contents + syms[i]->value);
3184 if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3185 {
3186 ++count;
3187 size += sizeof (asymbol);
3188 size += strlen (syms[i]->name) + 2;
3189 }
3190 }
3191
3192 /* Get start of .glink stubs from DT_PPC64_GLINK. */
3193 if (dyn_count != 0
3194 && (dynamic = bfd_get_section_by_name (abfd, ".dynamic")) != NULL)
3195 {
3196 bfd_byte *dynbuf, *extdyn, *extdynend;
3197 size_t extdynsize;
3198 void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *);
3199
3200 if (!bfd_malloc_and_get_section (abfd, dynamic, &dynbuf))
3201 goto free_contents_and_exit;
3202
3203 extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
3204 swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
3205
3206 extdyn = dynbuf;
3207 extdynend = extdyn + dynamic->size;
3208 for (; extdyn < extdynend; extdyn += extdynsize)
3209 {
3210 Elf_Internal_Dyn dyn;
3211 (*swap_dyn_in) (abfd, extdyn, &dyn);
3212
3213 if (dyn.d_tag == DT_NULL)
3214 break;
3215
3216 if (dyn.d_tag == DT_PPC64_GLINK)
3217 {
3218 /* The first glink stub starts at offset 32; see comment in
3219 ppc64_elf_finish_dynamic_sections. */
3220 glink_vma = dyn.d_un.d_val + 32;
3221 /* The .glink section usually does not survive the final
3222 link; search for the section (usually .text) where the
3223 glink stubs now reside. */
3224 glink = bfd_sections_find_if (abfd, section_covers_vma,
3225 &glink_vma);
3226 break;
3227 }
3228 }
3229
3230 free (dynbuf);
3231 }
3232
3233 if (glink != NULL)
3234 {
3235 /* Determine __glink trampoline by reading the relative branch
3236 from the first glink stub. */
3237 bfd_byte buf[4];
3238 if (bfd_get_section_contents (abfd, glink, buf,
3239 glink_vma + 4 - glink->vma, 4))
3240 {
3241 unsigned int insn = bfd_get_32 (abfd, buf);
3242 insn ^= B_DOT;
3243 if ((insn & ~0x3fffffc) == 0)
3244 resolv_vma = glink_vma + 4 + (insn ^ 0x2000000) - 0x2000000;
3245 }
3246
3247 if (resolv_vma)
3248 size += sizeof (asymbol) + sizeof ("__glink_PLTresolve");
3249
3250 relplt = bfd_get_section_by_name (abfd, ".rela.plt");
3251 if (relplt != NULL)
3252 {
3253 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3254 if (! (*slurp_relocs) (abfd, relplt, dyn_syms, TRUE))
3255 goto free_contents_and_exit;
3256
3257 plt_count = relplt->size / sizeof (Elf64_External_Rela);
3258 size += plt_count * sizeof (asymbol);
3259
3260 p = relplt->relocation;
3261 for (i = 0; i < plt_count; i++, p++)
3262 {
3263 size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
3264 if (p->addend != 0)
3265 size += sizeof ("+0x") - 1 + 16;
3266 }
3267 }
3268 }
3269
3270 s = *ret = bfd_malloc (size);
3271 if (s == NULL)
3272 goto free_contents_and_exit;
3273
3274 names = (char *) (s + count + plt_count + (resolv_vma != 0));
3275
3276 for (i = secsymend; i < opdsymend; ++i)
3277 {
3278 bfd_vma ent;
3279
3280 if (syms[i]->value > opd->size - 8)
3281 continue;
3282
3283 ent = bfd_get_64 (abfd, contents + syms[i]->value);
3284 if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3285 {
3286 long lo, hi;
3287 size_t len;
3288 asection *sec = abfd->sections;
3289
3290 *s = *syms[i];
3291 lo = codesecsym;
3292 hi = codesecsymend;
3293 while (lo < hi)
3294 {
3295 long mid = (lo + hi) >> 1;
3296 if (syms[mid]->section->vma < ent)
3297 lo = mid + 1;
3298 else if (syms[mid]->section->vma > ent)
3299 hi = mid;
3300 else
3301 {
3302 sec = syms[mid]->section;
3303 break;
3304 }
3305 }
3306
3307 if (lo >= hi && lo > codesecsym)
3308 sec = syms[lo - 1]->section;
3309
3310 for (; sec != NULL; sec = sec->next)
3311 {
3312 if (sec->vma > ent)
3313 break;
3314 if ((sec->flags & SEC_ALLOC) == 0
3315 || (sec->flags & SEC_LOAD) == 0)
3316 break;
3317 if ((sec->flags & SEC_CODE) != 0)
3318 s->section = sec;
3319 }
3320 s->flags |= BSF_SYNTHETIC;
3321 s->value = ent - s->section->vma;
3322 s->name = names;
3323 *names++ = '.';
3324 len = strlen (syms[i]->name);
3325 memcpy (names, syms[i]->name, len + 1);
3326 names += len + 1;
3327 /* Have udata.p point back to the original symbol this
3328 synthetic symbol was derived from. */
3329 s->udata.p = syms[i];
3330 s++;
3331 }
3332 }
3333 free (contents);
3334
3335 if (glink != NULL && relplt != NULL)
3336 {
3337 if (resolv_vma)
3338 {
3339 /* Add a symbol for the main glink trampoline. */
3340 memset (s, 0, sizeof *s);
3341 s->the_bfd = abfd;
3342 s->flags = BSF_GLOBAL | BSF_SYNTHETIC;
3343 s->section = glink;
3344 s->value = resolv_vma - glink->vma;
3345 s->name = names;
3346 memcpy (names, "__glink_PLTresolve", sizeof ("__glink_PLTresolve"));
3347 names += sizeof ("__glink_PLTresolve");
3348 s++;
3349 count++;
3350 }
3351
3352 /* FIXME: It would be very much nicer to put sym@plt on the
3353 stub rather than on the glink branch table entry. The
3354 objdump disassembler would then use a sensible symbol
3355 name on plt calls. The difficulty in doing so is
3356 a) finding the stubs, and,
3357 b) matching stubs against plt entries, and,
3358 c) there can be multiple stubs for a given plt entry.
3359
3360 Solving (a) could be done by code scanning, but older
3361 ppc64 binaries used different stubs to current code.
3362 (b) is the tricky one since you need to known the toc
3363 pointer for at least one function that uses a pic stub to
3364 be able to calculate the plt address referenced.
3365 (c) means gdb would need to set multiple breakpoints (or
3366 find the glink branch itself) when setting breakpoints
3367 for pending shared library loads. */
3368 p = relplt->relocation;
3369 for (i = 0; i < plt_count; i++, p++)
3370 {
3371 size_t len;
3372
3373 *s = **p->sym_ptr_ptr;
3374 /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set. Since
3375 we are defining a symbol, ensure one of them is set. */
3376 if ((s->flags & BSF_LOCAL) == 0)
3377 s->flags |= BSF_GLOBAL;
3378 s->flags |= BSF_SYNTHETIC;
3379 s->section = glink;
3380 s->value = glink_vma - glink->vma;
3381 s->name = names;
3382 s->udata.p = NULL;
3383 len = strlen ((*p->sym_ptr_ptr)->name);
3384 memcpy (names, (*p->sym_ptr_ptr)->name, len);
3385 names += len;
3386 if (p->addend != 0)
3387 {
3388 memcpy (names, "+0x", sizeof ("+0x") - 1);
3389 names += sizeof ("+0x") - 1;
3390 bfd_sprintf_vma (abfd, names, p->addend);
3391 names += strlen (names);
3392 }
3393 memcpy (names, "@plt", sizeof ("@plt"));
3394 names += sizeof ("@plt");
3395 s++;
3396 glink_vma += 8;
3397 if (i >= 0x8000)
3398 glink_vma += 4;
3399 }
3400 count += plt_count;
3401 }
3402 }
3403
3404 done:
3405 free (syms);
3406 return count;
3407 }
3408 \f
3409 /* The following functions are specific to the ELF linker, while
3410 functions above are used generally. Those named ppc64_elf_* are
3411 called by the main ELF linker code. They appear in this file more
3412 or less in the order in which they are called. eg.
3413 ppc64_elf_check_relocs is called early in the link process,
3414 ppc64_elf_finish_dynamic_sections is one of the last functions
3415 called.
3416
3417 PowerPC64-ELF uses a similar scheme to PowerPC64-XCOFF in that
3418 functions have both a function code symbol and a function descriptor
3419 symbol. A call to foo in a relocatable object file looks like:
3420
3421 . .text
3422 . x:
3423 . bl .foo
3424 . nop
3425
3426 The function definition in another object file might be:
3427
3428 . .section .opd
3429 . foo: .quad .foo
3430 . .quad .TOC.@tocbase
3431 . .quad 0
3432 .
3433 . .text
3434 . .foo: blr
3435
3436 When the linker resolves the call during a static link, the branch
3437 unsurprisingly just goes to .foo and the .opd information is unused.
3438 If the function definition is in a shared library, things are a little
3439 different: The call goes via a plt call stub, the opd information gets
3440 copied to the plt, and the linker patches the nop.
3441
3442 . x:
3443 . bl .foo_stub
3444 . ld 2,40(1)
3445 .
3446 .
3447 . .foo_stub:
3448 . addis 12,2,Lfoo@toc@ha # in practice, the call stub
3449 . addi 12,12,Lfoo@toc@l # is slightly optimized, but
3450 . std 2,40(1) # this is the general idea
3451 . ld 11,0(12)
3452 . ld 2,8(12)
3453 . mtctr 11
3454 . ld 11,16(12)
3455 . bctr
3456 .
3457 . .section .plt
3458 . Lfoo: reloc (R_PPC64_JMP_SLOT, foo)
3459
3460 The "reloc ()" notation is supposed to indicate that the linker emits
3461 an R_PPC64_JMP_SLOT reloc against foo. The dynamic linker does the opd
3462 copying.
3463
3464 What are the difficulties here? Well, firstly, the relocations
3465 examined by the linker in check_relocs are against the function code
3466 sym .foo, while the dynamic relocation in the plt is emitted against
3467 the function descriptor symbol, foo. Somewhere along the line, we need
3468 to carefully copy dynamic link information from one symbol to the other.
3469 Secondly, the generic part of the elf linker will make .foo a dynamic
3470 symbol as is normal for most other backends. We need foo dynamic
3471 instead, at least for an application final link. However, when
3472 creating a shared library containing foo, we need to have both symbols
3473 dynamic so that references to .foo are satisfied during the early
3474 stages of linking. Otherwise the linker might decide to pull in a
3475 definition from some other object, eg. a static library.
3476
3477 Update: As of August 2004, we support a new convention. Function
3478 calls may use the function descriptor symbol, ie. "bl foo". This
3479 behaves exactly as "bl .foo". */
3480
3481 /* The linker needs to keep track of the number of relocs that it
3482 decides to copy as dynamic relocs in check_relocs for each symbol.
3483 This is so that it can later discard them if they are found to be
3484 unnecessary. We store the information in a field extending the
3485 regular ELF linker hash table. */
3486
3487 struct ppc_dyn_relocs
3488 {
3489 struct ppc_dyn_relocs *next;
3490
3491 /* The input section of the reloc. */
3492 asection *sec;
3493
3494 /* Total number of relocs copied for the input section. */
3495 bfd_size_type count;
3496
3497 /* Number of pc-relative relocs copied for the input section. */
3498 bfd_size_type pc_count;
3499 };
3500
3501 /* Of those relocs that might be copied as dynamic relocs, this function
3502 selects those that must be copied when linking a shared library,
3503 even when the symbol is local. */
3504
3505 static int
3506 must_be_dyn_reloc (struct bfd_link_info *info,
3507 enum elf_ppc64_reloc_type r_type)
3508 {
3509 switch (r_type)
3510 {
3511 default:
3512 return 1;
3513
3514 case R_PPC64_REL32:
3515 case R_PPC64_REL64:
3516 case R_PPC64_REL30:
3517 return 0;
3518
3519 case R_PPC64_TPREL16:
3520 case R_PPC64_TPREL16_LO:
3521 case R_PPC64_TPREL16_HI:
3522 case R_PPC64_TPREL16_HA:
3523 case R_PPC64_TPREL16_DS:
3524 case R_PPC64_TPREL16_LO_DS:
3525 case R_PPC64_TPREL16_HIGHER:
3526 case R_PPC64_TPREL16_HIGHERA:
3527 case R_PPC64_TPREL16_HIGHEST:
3528 case R_PPC64_TPREL16_HIGHESTA:
3529 case R_PPC64_TPREL64:
3530 return !info->executable;
3531 }
3532 }
3533
3534 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
3535 copying dynamic variables from a shared lib into an app's dynbss
3536 section, and instead use a dynamic relocation to point into the
3537 shared lib. With code that gcc generates, it's vital that this be
3538 enabled; In the PowerPC64 ABI, the address of a function is actually
3539 the address of a function descriptor, which resides in the .opd
3540 section. gcc uses the descriptor directly rather than going via the
3541 GOT as some other ABI's do, which means that initialized function
3542 pointers must reference the descriptor. Thus, a function pointer
3543 initialized to the address of a function in a shared library will
3544 either require a copy reloc, or a dynamic reloc. Using a copy reloc
3545 redefines the function descriptor symbol to point to the copy. This
3546 presents a problem as a plt entry for that function is also
3547 initialized from the function descriptor symbol and the copy reloc
3548 may not be initialized first. */
3549 #define ELIMINATE_COPY_RELOCS 1
3550
3551 /* Section name for stubs is the associated section name plus this
3552 string. */
3553 #define STUB_SUFFIX ".stub"
3554
3555 /* Linker stubs.
3556 ppc_stub_long_branch:
3557 Used when a 14 bit branch (or even a 24 bit branch) can't reach its
3558 destination, but a 24 bit branch in a stub section will reach.
3559 . b dest
3560
3561 ppc_stub_plt_branch:
3562 Similar to the above, but a 24 bit branch in the stub section won't
3563 reach its destination.
3564 . addis %r12,%r2,xxx@toc@ha
3565 . ld %r11,xxx@toc@l(%r12)
3566 . mtctr %r11
3567 . bctr
3568
3569 ppc_stub_plt_call:
3570 Used to call a function in a shared library. If it so happens that
3571 the plt entry referenced crosses a 64k boundary, then an extra
3572 "addi %r12,%r12,xxx@toc@l" will be inserted before the "mtctr".
3573 . addis %r12,%r2,xxx@toc@ha
3574 . std %r2,40(%r1)
3575 . ld %r11,xxx+0@toc@l(%r12)
3576 . mtctr %r11
3577 . ld %r2,xxx+8@toc@l(%r12)
3578 . ld %r11,xxx+16@toc@l(%r12)
3579 . bctr
3580
3581 ppc_stub_long_branch and ppc_stub_plt_branch may also have additional
3582 code to adjust the value and save r2 to support multiple toc sections.
3583 A ppc_stub_long_branch with an r2 offset looks like:
3584 . std %r2,40(%r1)
3585 . addis %r2,%r2,off@ha
3586 . addi %r2,%r2,off@l
3587 . b dest
3588
3589 A ppc_stub_plt_branch with an r2 offset looks like:
3590 . std %r2,40(%r1)
3591 . addis %r12,%r2,xxx@toc@ha
3592 . ld %r11,xxx@toc@l(%r12)
3593 . addis %r2,%r2,off@ha
3594 . addi %r2,%r2,off@l
3595 . mtctr %r11
3596 . bctr
3597
3598 In cases where the "addis" instruction would add zero, the "addis" is
3599 omitted and following instructions modified slightly in some cases.
3600 */
3601
3602 enum ppc_stub_type {
3603 ppc_stub_none,
3604 ppc_stub_long_branch,
3605 ppc_stub_long_branch_r2off,
3606 ppc_stub_plt_branch,
3607 ppc_stub_plt_branch_r2off,
3608 ppc_stub_plt_call
3609 };
3610
3611 struct ppc_stub_hash_entry {
3612
3613 /* Base hash table entry structure. */
3614 struct bfd_hash_entry root;
3615
3616 enum ppc_stub_type stub_type;
3617
3618 /* The stub section. */
3619 asection *stub_sec;
3620
3621 /* Offset within stub_sec of the beginning of this stub. */
3622 bfd_vma stub_offset;
3623
3624 /* Given the symbol's value and its section we can determine its final
3625 value when building the stubs (so the stub knows where to jump. */
3626 bfd_vma target_value;
3627 asection *target_section;
3628
3629 /* The symbol table entry, if any, that this was derived from. */
3630 struct ppc_link_hash_entry *h;
3631 struct plt_entry *plt_ent;
3632
3633 /* And the reloc addend that this was derived from. */
3634 bfd_vma addend;
3635
3636 /* Where this stub is being called from, or, in the case of combined
3637 stub sections, the first input section in the group. */
3638 asection *id_sec;
3639 };
3640
3641 struct ppc_branch_hash_entry {
3642
3643 /* Base hash table entry structure. */
3644 struct bfd_hash_entry root;
3645
3646 /* Offset within branch lookup table. */
3647 unsigned int offset;
3648
3649 /* Generation marker. */
3650 unsigned int iter;
3651 };
3652
3653 struct ppc_link_hash_entry
3654 {
3655 struct elf_link_hash_entry elf;
3656
3657 union {
3658 /* A pointer to the most recently used stub hash entry against this
3659 symbol. */
3660 struct ppc_stub_hash_entry *stub_cache;
3661
3662 /* A pointer to the next symbol starting with a '.' */
3663 struct ppc_link_hash_entry *next_dot_sym;
3664 } u;
3665
3666 /* Track dynamic relocs copied for this symbol. */
3667 struct ppc_dyn_relocs *dyn_relocs;
3668
3669 /* Link between function code and descriptor symbols. */
3670 struct ppc_link_hash_entry *oh;
3671
3672 /* Flag function code and descriptor symbols. */
3673 unsigned int is_func:1;
3674 unsigned int is_func_descriptor:1;
3675 unsigned int fake:1;
3676
3677 /* Whether global opd/toc sym has been adjusted or not.
3678 After ppc64_elf_edit_opd/ppc64_elf_edit_toc has run, this flag
3679 should be set for all globals defined in any opd/toc section. */
3680 unsigned int adjust_done:1;
3681
3682 /* Set if we twiddled this symbol to weak at some stage. */
3683 unsigned int was_undefined:1;
3684
3685 /* Contexts in which symbol is used in the GOT (or TOC).
3686 TLS_GD .. TLS_EXPLICIT bits are or'd into the mask as the
3687 corresponding relocs are encountered during check_relocs.
3688 tls_optimize clears TLS_GD .. TLS_TPREL when optimizing to
3689 indicate the corresponding GOT entry type is not needed.
3690 tls_optimize may also set TLS_TPRELGD when a GD reloc turns into
3691 a TPREL one. We use a separate flag rather than setting TPREL
3692 just for convenience in distinguishing the two cases. */
3693 #define TLS_GD 1 /* GD reloc. */
3694 #define TLS_LD 2 /* LD reloc. */
3695 #define TLS_TPREL 4 /* TPREL reloc, => IE. */
3696 #define TLS_DTPREL 8 /* DTPREL reloc, => LD. */
3697 #define TLS_TLS 16 /* Any TLS reloc. */
3698 #define TLS_EXPLICIT 32 /* Marks TOC section TLS relocs. */
3699 #define TLS_TPRELGD 64 /* TPREL reloc resulting from GD->IE. */
3700 #define PLT_IFUNC 128 /* STT_GNU_IFUNC. */
3701 char tls_mask;
3702 };
3703
3704 /* ppc64 ELF linker hash table. */
3705
3706 struct ppc_link_hash_table
3707 {
3708 struct elf_link_hash_table elf;
3709
3710 /* The stub hash table. */
3711 struct bfd_hash_table stub_hash_table;
3712
3713 /* Another hash table for plt_branch stubs. */
3714 struct bfd_hash_table branch_hash_table;
3715
3716 /* Linker stub bfd. */
3717 bfd *stub_bfd;
3718
3719 /* Linker call-backs. */
3720 asection * (*add_stub_section) (const char *, asection *);
3721 void (*layout_sections_again) (void);
3722
3723 /* Array to keep track of which stub sections have been created, and
3724 information on stub grouping. */
3725 struct map_stub {
3726 /* This is the section to which stubs in the group will be attached. */
3727 asection *link_sec;
3728 /* The stub section. */
3729 asection *stub_sec;
3730 /* Along with elf_gp, specifies the TOC pointer used in this group. */
3731 bfd_vma toc_off;
3732 } *stub_group;
3733
3734 /* Temp used when calculating TOC pointers. */
3735 bfd_vma toc_curr;
3736 bfd *toc_bfd;
3737 asection *toc_first_sec;
3738
3739 /* Highest input section id. */
3740 int top_id;
3741
3742 /* Highest output section index. */
3743 int top_index;
3744
3745 /* Used when adding symbols. */
3746 struct ppc_link_hash_entry *dot_syms;
3747
3748 /* List of input sections for each output section. */
3749 asection **input_list;
3750
3751 /* Short-cuts to get to dynamic linker sections. */
3752 asection *got;
3753 asection *plt;
3754 asection *relplt;
3755 asection *iplt;
3756 asection *reliplt;
3757 asection *dynbss;
3758 asection *relbss;
3759 asection *glink;
3760 asection *sfpr;
3761 asection *brlt;
3762 asection *relbrlt;
3763
3764 /* Shortcut to .__tls_get_addr and __tls_get_addr. */
3765 struct ppc_link_hash_entry *tls_get_addr;
3766 struct ppc_link_hash_entry *tls_get_addr_fd;
3767
3768 /* The size of reliplt used by got entry relocs. */
3769 bfd_size_type got_reli_size;
3770
3771 /* Statistics. */
3772 unsigned long stub_count[ppc_stub_plt_call];
3773
3774 /* Number of stubs against global syms. */
3775 unsigned long stub_globals;
3776
3777 /* Set if we should emit symbols for stubs. */
3778 unsigned int emit_stub_syms:1;
3779
3780 /* Set if __tls_get_addr optimization should not be done. */
3781 unsigned int no_tls_get_addr_opt:1;
3782
3783 /* Support for multiple toc sections. */
3784 unsigned int multi_toc_needed:1;
3785 unsigned int second_toc_pass:1;
3786
3787 /* Set on error. */
3788 unsigned int stub_error:1;
3789
3790 /* Temp used by ppc64_elf_process_dot_syms. */
3791 unsigned int twiddled_syms:1;
3792
3793 /* Incremented every time we size stubs. */
3794 unsigned int stub_iteration;
3795
3796 /* Small local sym cache. */
3797 struct sym_cache sym_cache;
3798 };
3799
3800 /* Rename some of the generic section flags to better document how they
3801 are used here. */
3802
3803 /* Nonzero if this section has TLS related relocations. */
3804 #define has_tls_reloc sec_flg0
3805
3806 /* Nonzero if this section has a call to __tls_get_addr. */
3807 #define has_tls_get_addr_call sec_flg1
3808
3809 /* Nonzero if this section has any toc or got relocs. */
3810 #define has_toc_reloc sec_flg2
3811
3812 /* Nonzero if this section has a call to another section that uses
3813 the toc or got. */
3814 #define makes_toc_func_call sec_flg4
3815
3816 /* Recursion protection when determining above flag. */
3817 #define call_check_in_progress sec_flg5
3818
3819 /* Get the ppc64 ELF linker hash table from a link_info structure. */
3820
3821 #define ppc_hash_table(p) \
3822 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
3823 == PPC64_ELF_DATA ? ((struct ppc_link_hash_table *) ((p)->hash)) : NULL)
3824
3825 #define ppc_stub_hash_lookup(table, string, create, copy) \
3826 ((struct ppc_stub_hash_entry *) \
3827 bfd_hash_lookup ((table), (string), (create), (copy)))
3828
3829 #define ppc_branch_hash_lookup(table, string, create, copy) \
3830 ((struct ppc_branch_hash_entry *) \
3831 bfd_hash_lookup ((table), (string), (create), (copy)))
3832
3833 /* Create an entry in the stub hash table. */
3834
3835 static struct bfd_hash_entry *
3836 stub_hash_newfunc (struct bfd_hash_entry *entry,
3837 struct bfd_hash_table *table,
3838 const char *string)
3839 {
3840 /* Allocate the structure if it has not already been allocated by a
3841 subclass. */
3842 if (entry == NULL)
3843 {
3844 entry = bfd_hash_allocate (table, sizeof (struct ppc_stub_hash_entry));
3845 if (entry == NULL)
3846 return entry;
3847 }
3848
3849 /* Call the allocation method of the superclass. */
3850 entry = bfd_hash_newfunc (entry, table, string);
3851 if (entry != NULL)
3852 {
3853 struct ppc_stub_hash_entry *eh;
3854
3855 /* Initialize the local fields. */
3856 eh = (struct ppc_stub_hash_entry *) entry;
3857 eh->stub_type = ppc_stub_none;
3858 eh->stub_sec = NULL;
3859 eh->stub_offset = 0;
3860 eh->target_value = 0;
3861 eh->target_section = NULL;
3862 eh->h = NULL;
3863 eh->id_sec = NULL;
3864 }
3865
3866 return entry;
3867 }
3868
3869 /* Create an entry in the branch hash table. */
3870
3871 static struct bfd_hash_entry *
3872 branch_hash_newfunc (struct bfd_hash_entry *entry,
3873 struct bfd_hash_table *table,
3874 const char *string)
3875 {
3876 /* Allocate the structure if it has not already been allocated by a
3877 subclass. */
3878 if (entry == NULL)
3879 {
3880 entry = bfd_hash_allocate (table, sizeof (struct ppc_branch_hash_entry));
3881 if (entry == NULL)
3882 return entry;
3883 }
3884
3885 /* Call the allocation method of the superclass. */
3886 entry = bfd_hash_newfunc (entry, table, string);
3887 if (entry != NULL)
3888 {
3889 struct ppc_branch_hash_entry *eh;
3890
3891 /* Initialize the local fields. */
3892 eh = (struct ppc_branch_hash_entry *) entry;
3893 eh->offset = 0;
3894 eh->iter = 0;
3895 }
3896
3897 return entry;
3898 }
3899
3900 /* Create an entry in a ppc64 ELF linker hash table. */
3901
3902 static struct bfd_hash_entry *
3903 link_hash_newfunc (struct bfd_hash_entry *entry,
3904 struct bfd_hash_table *table,
3905 const char *string)
3906 {
3907 /* Allocate the structure if it has not already been allocated by a
3908 subclass. */
3909 if (entry == NULL)
3910 {
3911 entry = bfd_hash_allocate (table, sizeof (struct ppc_link_hash_entry));
3912 if (entry == NULL)
3913 return entry;
3914 }
3915
3916 /* Call the allocation method of the superclass. */
3917 entry = _bfd_elf_link_hash_newfunc (entry, table, string);
3918 if (entry != NULL)
3919 {
3920 struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) entry;
3921
3922 memset (&eh->u.stub_cache, 0,
3923 (sizeof (struct ppc_link_hash_entry)
3924 - offsetof (struct ppc_link_hash_entry, u.stub_cache)));
3925
3926 /* When making function calls, old ABI code references function entry
3927 points (dot symbols), while new ABI code references the function
3928 descriptor symbol. We need to make any combination of reference and
3929 definition work together, without breaking archive linking.
3930
3931 For a defined function "foo" and an undefined call to "bar":
3932 An old object defines "foo" and ".foo", references ".bar" (possibly
3933 "bar" too).
3934 A new object defines "foo" and references "bar".
3935
3936 A new object thus has no problem with its undefined symbols being
3937 satisfied by definitions in an old object. On the other hand, the
3938 old object won't have ".bar" satisfied by a new object.
3939
3940 Keep a list of newly added dot-symbols. */
3941
3942 if (string[0] == '.')
3943 {
3944 struct ppc_link_hash_table *htab;
3945
3946 htab = (struct ppc_link_hash_table *) table;
3947 eh->u.next_dot_sym = htab->dot_syms;
3948 htab->dot_syms = eh;
3949 }
3950 }
3951
3952 return entry;
3953 }
3954
3955 /* Create a ppc64 ELF linker hash table. */
3956
3957 static struct bfd_link_hash_table *
3958 ppc64_elf_link_hash_table_create (bfd *abfd)
3959 {
3960 struct ppc_link_hash_table *htab;
3961 bfd_size_type amt = sizeof (struct ppc_link_hash_table);
3962
3963 htab = bfd_zmalloc (amt);
3964 if (htab == NULL)
3965 return NULL;
3966
3967 if (!_bfd_elf_link_hash_table_init (&htab->elf, abfd, link_hash_newfunc,
3968 sizeof (struct ppc_link_hash_entry),
3969 PPC64_ELF_DATA))
3970 {
3971 free (htab);
3972 return NULL;
3973 }
3974
3975 /* Init the stub hash table too. */
3976 if (!bfd_hash_table_init (&htab->stub_hash_table, stub_hash_newfunc,
3977 sizeof (struct ppc_stub_hash_entry)))
3978 return NULL;
3979
3980 /* And the branch hash table. */
3981 if (!bfd_hash_table_init (&htab->branch_hash_table, branch_hash_newfunc,
3982 sizeof (struct ppc_branch_hash_entry)))
3983 return NULL;
3984
3985 /* Initializing two fields of the union is just cosmetic. We really
3986 only care about glist, but when compiled on a 32-bit host the
3987 bfd_vma fields are larger. Setting the bfd_vma to zero makes
3988 debugger inspection of these fields look nicer. */
3989 htab->elf.init_got_refcount.refcount = 0;
3990 htab->elf.init_got_refcount.glist = NULL;
3991 htab->elf.init_plt_refcount.refcount = 0;
3992 htab->elf.init_plt_refcount.glist = NULL;
3993 htab->elf.init_got_offset.offset = 0;
3994 htab->elf.init_got_offset.glist = NULL;
3995 htab->elf.init_plt_offset.offset = 0;
3996 htab->elf.init_plt_offset.glist = NULL;
3997
3998 return &htab->elf.root;
3999 }
4000
4001 /* Free the derived linker hash table. */
4002
4003 static void
4004 ppc64_elf_link_hash_table_free (struct bfd_link_hash_table *hash)
4005 {
4006 struct ppc_link_hash_table *ret = (struct ppc_link_hash_table *) hash;
4007
4008 bfd_hash_table_free (&ret->stub_hash_table);
4009 bfd_hash_table_free (&ret->branch_hash_table);
4010 _bfd_generic_link_hash_table_free (hash);
4011 }
4012
4013 /* Satisfy the ELF linker by filling in some fields in our fake bfd. */
4014
4015 void
4016 ppc64_elf_init_stub_bfd (bfd *abfd, struct bfd_link_info *info)
4017 {
4018 struct ppc_link_hash_table *htab;
4019
4020 elf_elfheader (abfd)->e_ident[EI_CLASS] = ELFCLASS64;
4021
4022 /* Always hook our dynamic sections into the first bfd, which is the
4023 linker created stub bfd. This ensures that the GOT header is at
4024 the start of the output TOC section. */
4025 htab = ppc_hash_table (info);
4026 if (htab == NULL)
4027 return;
4028 htab->stub_bfd = abfd;
4029 htab->elf.dynobj = abfd;
4030 }
4031
4032 /* Build a name for an entry in the stub hash table. */
4033
4034 static char *
4035 ppc_stub_name (const asection *input_section,
4036 const asection *sym_sec,
4037 const struct ppc_link_hash_entry *h,
4038 const Elf_Internal_Rela *rel)
4039 {
4040 char *stub_name;
4041 bfd_size_type len;
4042
4043 /* rel->r_addend is actually 64 bit, but who uses more than +/- 2^31
4044 offsets from a sym as a branch target? In fact, we could
4045 probably assume the addend is always zero. */
4046 BFD_ASSERT (((int) rel->r_addend & 0xffffffff) == rel->r_addend);
4047
4048 if (h)
4049 {
4050 len = 8 + 1 + strlen (h->elf.root.root.string) + 1 + 8 + 1;
4051 stub_name = bfd_malloc (len);
4052 if (stub_name == NULL)
4053 return stub_name;
4054
4055 sprintf (stub_name, "%08x.%s+%x",
4056 input_section->id & 0xffffffff,
4057 h->elf.root.root.string,
4058 (int) rel->r_addend & 0xffffffff);
4059 }
4060 else
4061 {
4062 len = 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1;
4063 stub_name = bfd_malloc (len);
4064 if (stub_name == NULL)
4065 return stub_name;
4066
4067 sprintf (stub_name, "%08x.%x:%x+%x",
4068 input_section->id & 0xffffffff,
4069 sym_sec->id & 0xffffffff,
4070 (int) ELF64_R_SYM (rel->r_info) & 0xffffffff,
4071 (int) rel->r_addend & 0xffffffff);
4072 }
4073 if (stub_name[len - 2] == '+' && stub_name[len - 1] == '0')
4074 stub_name[len - 2] = 0;
4075 return stub_name;
4076 }
4077
4078 /* Look up an entry in the stub hash. Stub entries are cached because
4079 creating the stub name takes a bit of time. */
4080
4081 static struct ppc_stub_hash_entry *
4082 ppc_get_stub_entry (const asection *input_section,
4083 const asection *sym_sec,
4084 struct ppc_link_hash_entry *h,
4085 const Elf_Internal_Rela *rel,
4086 struct ppc_link_hash_table *htab)
4087 {
4088 struct ppc_stub_hash_entry *stub_entry;
4089 const asection *id_sec;
4090
4091 /* If this input section is part of a group of sections sharing one
4092 stub section, then use the id of the first section in the group.
4093 Stub names need to include a section id, as there may well be
4094 more than one stub used to reach say, printf, and we need to
4095 distinguish between them. */
4096 id_sec = htab->stub_group[input_section->id].link_sec;
4097
4098 if (h != NULL && h->u.stub_cache != NULL
4099 && h->u.stub_cache->h == h
4100 && h->u.stub_cache->id_sec == id_sec)
4101 {
4102 stub_entry = h->u.stub_cache;
4103 }
4104 else
4105 {
4106 char *stub_name;
4107
4108 stub_name = ppc_stub_name (id_sec, sym_sec, h, rel);
4109 if (stub_name == NULL)
4110 return NULL;
4111
4112 stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
4113 stub_name, FALSE, FALSE);
4114 if (h != NULL)
4115 h->u.stub_cache = stub_entry;
4116
4117 free (stub_name);
4118 }
4119
4120 return stub_entry;
4121 }
4122
4123 /* Add a new stub entry to the stub hash. Not all fields of the new
4124 stub entry are initialised. */
4125
4126 static struct ppc_stub_hash_entry *
4127 ppc_add_stub (const char *stub_name,
4128 asection *section,
4129 struct ppc_link_hash_table *htab)
4130 {
4131 asection *link_sec;
4132 asection *stub_sec;
4133 struct ppc_stub_hash_entry *stub_entry;
4134
4135 link_sec = htab->stub_group[section->id].link_sec;
4136 stub_sec = htab->stub_group[section->id].stub_sec;
4137 if (stub_sec == NULL)
4138 {
4139 stub_sec = htab->stub_group[link_sec->id].stub_sec;
4140 if (stub_sec == NULL)
4141 {
4142 size_t namelen;
4143 bfd_size_type len;
4144 char *s_name;
4145
4146 namelen = strlen (link_sec->name);
4147 len = namelen + sizeof (STUB_SUFFIX);
4148 s_name = bfd_alloc (htab->stub_bfd, len);
4149 if (s_name == NULL)
4150 return NULL;
4151
4152 memcpy (s_name, link_sec->name, namelen);
4153 memcpy (s_name + namelen, STUB_SUFFIX, sizeof (STUB_SUFFIX));
4154 stub_sec = (*htab->add_stub_section) (s_name, link_sec);
4155 if (stub_sec == NULL)
4156 return NULL;
4157 htab->stub_group[link_sec->id].stub_sec = stub_sec;
4158 }
4159 htab->stub_group[section->id].stub_sec = stub_sec;
4160 }
4161
4162 /* Enter this entry into the linker stub hash table. */
4163 stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table, stub_name,
4164 TRUE, FALSE);
4165 if (stub_entry == NULL)
4166 {
4167 (*_bfd_error_handler) (_("%B: cannot create stub entry %s"),
4168 section->owner, stub_name);
4169 return NULL;
4170 }
4171
4172 stub_entry->stub_sec = stub_sec;
4173 stub_entry->stub_offset = 0;
4174 stub_entry->id_sec = link_sec;
4175 return stub_entry;
4176 }
4177
4178 /* Create sections for linker generated code. */
4179
4180 static bfd_boolean
4181 create_linkage_sections (bfd *dynobj, struct bfd_link_info *info)
4182 {
4183 struct ppc_link_hash_table *htab;
4184 flagword flags;
4185
4186 htab = ppc_hash_table (info);
4187 if (htab == NULL)
4188 return FALSE;
4189
4190 /* Create .sfpr for code to save and restore fp regs. */
4191 flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY
4192 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4193 htab->sfpr = bfd_make_section_anyway_with_flags (dynobj, ".sfpr",
4194 flags);
4195 if (htab->sfpr == NULL
4196 || ! bfd_set_section_alignment (dynobj, htab->sfpr, 2))
4197 return FALSE;
4198
4199 /* Create .glink for lazy dynamic linking support. */
4200 htab->glink = bfd_make_section_anyway_with_flags (dynobj, ".glink",
4201 flags);
4202 if (htab->glink == NULL
4203 || ! bfd_set_section_alignment (dynobj, htab->glink, 3))
4204 return FALSE;
4205
4206 flags = SEC_ALLOC | SEC_LINKER_CREATED;
4207 htab->iplt = bfd_make_section_anyway_with_flags (dynobj, ".iplt", flags);
4208 if (htab->iplt == NULL
4209 || ! bfd_set_section_alignment (dynobj, htab->iplt, 3))
4210 return FALSE;
4211
4212 flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4213 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4214 htab->reliplt = bfd_make_section_anyway_with_flags (dynobj,
4215 ".rela.iplt",
4216 flags);
4217 if (htab->reliplt == NULL
4218 || ! bfd_set_section_alignment (dynobj, htab->reliplt, 3))
4219 return FALSE;
4220
4221 /* Create branch lookup table for plt_branch stubs. */
4222 flags = (SEC_ALLOC | SEC_LOAD
4223 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4224 htab->brlt = bfd_make_section_anyway_with_flags (dynobj, ".branch_lt",
4225 flags);
4226 if (htab->brlt == NULL
4227 || ! bfd_set_section_alignment (dynobj, htab->brlt, 3))
4228 return FALSE;
4229
4230 if (!info->shared)
4231 return TRUE;
4232
4233 flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4234 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4235 htab->relbrlt = bfd_make_section_anyway_with_flags (dynobj,
4236 ".rela.branch_lt",
4237 flags);
4238 if (htab->relbrlt == NULL
4239 || ! bfd_set_section_alignment (dynobj, htab->relbrlt, 3))
4240 return FALSE;
4241
4242 return TRUE;
4243 }
4244
4245 /* Create .got and .rela.got sections in ABFD, and .got in dynobj if
4246 not already done. */
4247
4248 static bfd_boolean
4249 create_got_section (bfd *abfd, struct bfd_link_info *info)
4250 {
4251 asection *got, *relgot;
4252 flagword flags;
4253 struct ppc_link_hash_table *htab = ppc_hash_table (info);
4254
4255 if (!is_ppc64_elf (abfd))
4256 return FALSE;
4257 if (htab == NULL)
4258 return FALSE;
4259
4260 if (!htab->got)
4261 {
4262 if (! _bfd_elf_create_got_section (htab->elf.dynobj, info))
4263 return FALSE;
4264
4265 htab->got = bfd_get_section_by_name (htab->elf.dynobj, ".got");
4266 if (!htab->got)
4267 abort ();
4268 }
4269
4270 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
4271 | SEC_LINKER_CREATED);
4272
4273 got = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
4274 if (!got
4275 || !bfd_set_section_alignment (abfd, got, 3))
4276 return FALSE;
4277
4278 relgot = bfd_make_section_anyway_with_flags (abfd, ".rela.got",
4279 flags | SEC_READONLY);
4280 if (!relgot
4281 || ! bfd_set_section_alignment (abfd, relgot, 3))
4282 return FALSE;
4283
4284 ppc64_elf_tdata (abfd)->got = got;
4285 ppc64_elf_tdata (abfd)->relgot = relgot;
4286 return TRUE;
4287 }
4288
4289 /* Create the dynamic sections, and set up shortcuts. */
4290
4291 static bfd_boolean
4292 ppc64_elf_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
4293 {
4294 struct ppc_link_hash_table *htab;
4295
4296 if (!_bfd_elf_create_dynamic_sections (dynobj, info))
4297 return FALSE;
4298
4299 htab = ppc_hash_table (info);
4300 if (htab == NULL)
4301 return FALSE;
4302
4303 if (!htab->got)
4304 htab->got = bfd_get_section_by_name (dynobj, ".got");
4305 htab->plt = bfd_get_section_by_name (dynobj, ".plt");
4306 htab->relplt = bfd_get_section_by_name (dynobj, ".rela.plt");
4307 htab->dynbss = bfd_get_section_by_name (dynobj, ".dynbss");
4308 if (!info->shared)
4309 htab->relbss = bfd_get_section_by_name (dynobj, ".rela.bss");
4310
4311 if (!htab->got || !htab->plt || !htab->relplt || !htab->dynbss
4312 || (!info->shared && !htab->relbss))
4313 abort ();
4314
4315 return TRUE;
4316 }
4317
4318 /* Follow indirect and warning symbol links. */
4319
4320 static inline struct bfd_link_hash_entry *
4321 follow_link (struct bfd_link_hash_entry *h)
4322 {
4323 while (h->type == bfd_link_hash_indirect
4324 || h->type == bfd_link_hash_warning)
4325 h = h->u.i.link;
4326 return h;
4327 }
4328
4329 static inline struct elf_link_hash_entry *
4330 elf_follow_link (struct elf_link_hash_entry *h)
4331 {
4332 return (struct elf_link_hash_entry *) follow_link (&h->root);
4333 }
4334
4335 static inline struct ppc_link_hash_entry *
4336 ppc_follow_link (struct ppc_link_hash_entry *h)
4337 {
4338 return (struct ppc_link_hash_entry *) follow_link (&h->elf.root);
4339 }
4340
4341 /* Merge PLT info on FROM with that on TO. */
4342
4343 static void
4344 move_plt_plist (struct ppc_link_hash_entry *from,
4345 struct ppc_link_hash_entry *to)
4346 {
4347 if (from->elf.plt.plist != NULL)
4348 {
4349 if (to->elf.plt.plist != NULL)
4350 {
4351 struct plt_entry **entp;
4352 struct plt_entry *ent;
4353
4354 for (entp = &from->elf.plt.plist; (ent = *entp) != NULL; )
4355 {
4356 struct plt_entry *dent;
4357
4358 for (dent = to->elf.plt.plist; dent != NULL; dent = dent->next)
4359 if (dent->addend == ent->addend)
4360 {
4361 dent->plt.refcount += ent->plt.refcount;
4362 *entp = ent->next;
4363 break;
4364 }
4365 if (dent == NULL)
4366 entp = &ent->next;
4367 }
4368 *entp = to->elf.plt.plist;
4369 }
4370
4371 to->elf.plt.plist = from->elf.plt.plist;
4372 from->elf.plt.plist = NULL;
4373 }
4374 }
4375
4376 /* Copy the extra info we tack onto an elf_link_hash_entry. */
4377
4378 static void
4379 ppc64_elf_copy_indirect_symbol (struct bfd_link_info *info,
4380 struct elf_link_hash_entry *dir,
4381 struct elf_link_hash_entry *ind)
4382 {
4383 struct ppc_link_hash_entry *edir, *eind;
4384
4385 edir = (struct ppc_link_hash_entry *) dir;
4386 eind = (struct ppc_link_hash_entry *) ind;
4387
4388 /* Copy over any dynamic relocs we may have on the indirect sym. */
4389 if (eind->dyn_relocs != NULL)
4390 {
4391 if (edir->dyn_relocs != NULL)
4392 {
4393 struct ppc_dyn_relocs **pp;
4394 struct ppc_dyn_relocs *p;
4395
4396 /* Add reloc counts against the indirect sym to the direct sym
4397 list. Merge any entries against the same section. */
4398 for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
4399 {
4400 struct ppc_dyn_relocs *q;
4401
4402 for (q = edir->dyn_relocs; q != NULL; q = q->next)
4403 if (q->sec == p->sec)
4404 {
4405 q->pc_count += p->pc_count;
4406 q->count += p->count;
4407 *pp = p->next;
4408 break;
4409 }
4410 if (q == NULL)
4411 pp = &p->next;
4412 }
4413 *pp = edir->dyn_relocs;
4414 }
4415
4416 edir->dyn_relocs = eind->dyn_relocs;
4417 eind->dyn_relocs = NULL;
4418 }
4419
4420 edir->is_func |= eind->is_func;
4421 edir->is_func_descriptor |= eind->is_func_descriptor;
4422 edir->tls_mask |= eind->tls_mask;
4423 if (eind->oh != NULL)
4424 edir->oh = ppc_follow_link (eind->oh);
4425
4426 /* If called to transfer flags for a weakdef during processing
4427 of elf_adjust_dynamic_symbol, don't copy NON_GOT_REF.
4428 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
4429 if (!(ELIMINATE_COPY_RELOCS
4430 && eind->elf.root.type != bfd_link_hash_indirect
4431 && edir->elf.dynamic_adjusted))
4432 edir->elf.non_got_ref |= eind->elf.non_got_ref;
4433
4434 edir->elf.ref_dynamic |= eind->elf.ref_dynamic;
4435 edir->elf.ref_regular |= eind->elf.ref_regular;
4436 edir->elf.ref_regular_nonweak |= eind->elf.ref_regular_nonweak;
4437 edir->elf.needs_plt |= eind->elf.needs_plt;
4438
4439 /* If we were called to copy over info for a weak sym, that's all. */
4440 if (eind->elf.root.type != bfd_link_hash_indirect)
4441 return;
4442
4443 /* Copy over got entries that we may have already seen to the
4444 symbol which just became indirect. */
4445 if (eind->elf.got.glist != NULL)
4446 {
4447 if (edir->elf.got.glist != NULL)
4448 {
4449 struct got_entry **entp;
4450 struct got_entry *ent;
4451
4452 for (entp = &eind->elf.got.glist; (ent = *entp) != NULL; )
4453 {
4454 struct got_entry *dent;
4455
4456 for (dent = edir->elf.got.glist; dent != NULL; dent = dent->next)
4457 if (dent->addend == ent->addend
4458 && dent->owner == ent->owner
4459 && dent->tls_type == ent->tls_type)
4460 {
4461 dent->got.refcount += ent->got.refcount;
4462 *entp = ent->next;
4463 break;
4464 }
4465 if (dent == NULL)
4466 entp = &ent->next;
4467 }
4468 *entp = edir->elf.got.glist;
4469 }
4470
4471 edir->elf.got.glist = eind->elf.got.glist;
4472 eind->elf.got.glist = NULL;
4473 }
4474
4475 /* And plt entries. */
4476 move_plt_plist (eind, edir);
4477
4478 if (eind->elf.dynindx != -1)
4479 {
4480 if (edir->elf.dynindx != -1)
4481 _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
4482 edir->elf.dynstr_index);
4483 edir->elf.dynindx = eind->elf.dynindx;
4484 edir->elf.dynstr_index = eind->elf.dynstr_index;
4485 eind->elf.dynindx = -1;
4486 eind->elf.dynstr_index = 0;
4487 }
4488 }
4489
4490 /* Find the function descriptor hash entry from the given function code
4491 hash entry FH. Link the entries via their OH fields. */
4492
4493 static struct ppc_link_hash_entry *
4494 lookup_fdh (struct ppc_link_hash_entry *fh, struct ppc_link_hash_table *htab)
4495 {
4496 struct ppc_link_hash_entry *fdh = fh->oh;
4497
4498 if (fdh == NULL)
4499 {
4500 const char *fd_name = fh->elf.root.root.string + 1;
4501
4502 fdh = (struct ppc_link_hash_entry *)
4503 elf_link_hash_lookup (&htab->elf, fd_name, FALSE, FALSE, FALSE);
4504 if (fdh == NULL)
4505 return fdh;
4506
4507 fdh->is_func_descriptor = 1;
4508 fdh->oh = fh;
4509 fh->is_func = 1;
4510 fh->oh = fdh;
4511 }
4512
4513 return ppc_follow_link (fdh);
4514 }
4515
4516 /* Make a fake function descriptor sym for the code sym FH. */
4517
4518 static struct ppc_link_hash_entry *
4519 make_fdh (struct bfd_link_info *info,
4520 struct ppc_link_hash_entry *fh)
4521 {
4522 bfd *abfd;
4523 asymbol *newsym;
4524 struct bfd_link_hash_entry *bh;
4525 struct ppc_link_hash_entry *fdh;
4526
4527 abfd = fh->elf.root.u.undef.abfd;
4528 newsym = bfd_make_empty_symbol (abfd);
4529 newsym->name = fh->elf.root.root.string + 1;
4530 newsym->section = bfd_und_section_ptr;
4531 newsym->value = 0;
4532 newsym->flags = BSF_WEAK;
4533
4534 bh = NULL;
4535 if (!_bfd_generic_link_add_one_symbol (info, abfd, newsym->name,
4536 newsym->flags, newsym->section,
4537 newsym->value, NULL, FALSE, FALSE,
4538 &bh))
4539 return NULL;
4540
4541 fdh = (struct ppc_link_hash_entry *) bh;
4542 fdh->elf.non_elf = 0;
4543 fdh->fake = 1;
4544 fdh->is_func_descriptor = 1;
4545 fdh->oh = fh;
4546 fh->is_func = 1;
4547 fh->oh = fdh;
4548 return fdh;
4549 }
4550
4551 /* Fix function descriptor symbols defined in .opd sections to be
4552 function type. */
4553
4554 static bfd_boolean
4555 ppc64_elf_add_symbol_hook (bfd *ibfd ATTRIBUTE_UNUSED,
4556 struct bfd_link_info *info,
4557 Elf_Internal_Sym *isym,
4558 const char **name ATTRIBUTE_UNUSED,
4559 flagword *flags ATTRIBUTE_UNUSED,
4560 asection **sec,
4561 bfd_vma *value ATTRIBUTE_UNUSED)
4562 {
4563 if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
4564 elf_tdata (info->output_bfd)->has_ifunc_symbols = TRUE;
4565 else if (ELF_ST_TYPE (isym->st_info) == STT_FUNC)
4566 ;
4567 else if (*sec != NULL
4568 && strcmp (bfd_get_section_name (ibfd, *sec), ".opd") == 0)
4569 isym->st_info = ELF_ST_INFO (ELF_ST_BIND (isym->st_info), STT_FUNC);
4570
4571 return TRUE;
4572 }
4573
4574 /* This function makes an old ABI object reference to ".bar" cause the
4575 inclusion of a new ABI object archive that defines "bar".
4576 NAME is a symbol defined in an archive. Return a symbol in the hash
4577 table that might be satisfied by the archive symbols. */
4578
4579 static struct elf_link_hash_entry *
4580 ppc64_elf_archive_symbol_lookup (bfd *abfd,
4581 struct bfd_link_info *info,
4582 const char *name)
4583 {
4584 struct elf_link_hash_entry *h;
4585 char *dot_name;
4586 size_t len;
4587
4588 h = _bfd_elf_archive_symbol_lookup (abfd, info, name);
4589 if (h != NULL
4590 /* Don't return this sym if it is a fake function descriptor
4591 created by add_symbol_adjust. */
4592 && !(h->root.type == bfd_link_hash_undefweak
4593 && ((struct ppc_link_hash_entry *) h)->fake))
4594 return h;
4595
4596 if (name[0] == '.')
4597 return h;
4598
4599 len = strlen (name);
4600 dot_name = bfd_alloc (abfd, len + 2);
4601 if (dot_name == NULL)
4602 return (struct elf_link_hash_entry *) 0 - 1;
4603 dot_name[0] = '.';
4604 memcpy (dot_name + 1, name, len + 1);
4605 h = _bfd_elf_archive_symbol_lookup (abfd, info, dot_name);
4606 bfd_release (abfd, dot_name);
4607 return h;
4608 }
4609
4610 /* This function satisfies all old ABI object references to ".bar" if a
4611 new ABI object defines "bar". Well, at least, undefined dot symbols
4612 are made weak. This stops later archive searches from including an
4613 object if we already have a function descriptor definition. It also
4614 prevents the linker complaining about undefined symbols.
4615 We also check and correct mismatched symbol visibility here. The
4616 most restrictive visibility of the function descriptor and the
4617 function entry symbol is used. */
4618
4619 static bfd_boolean
4620 add_symbol_adjust (struct ppc_link_hash_entry *eh, struct bfd_link_info *info)
4621 {
4622 struct ppc_link_hash_table *htab;
4623 struct ppc_link_hash_entry *fdh;
4624
4625 if (eh->elf.root.type == bfd_link_hash_indirect)
4626 return TRUE;
4627
4628 if (eh->elf.root.type == bfd_link_hash_warning)
4629 eh = (struct ppc_link_hash_entry *) eh->elf.root.u.i.link;
4630
4631 if (eh->elf.root.root.string[0] != '.')
4632 abort ();
4633
4634 htab = ppc_hash_table (info);
4635 if (htab == NULL)
4636 return FALSE;
4637
4638 fdh = lookup_fdh (eh, htab);
4639 if (fdh == NULL)
4640 {
4641 if (!info->relocatable
4642 && (eh->elf.root.type == bfd_link_hash_undefined
4643 || eh->elf.root.type == bfd_link_hash_undefweak)
4644 && eh->elf.ref_regular)
4645 {
4646 /* Make an undefweak function descriptor sym, which is enough to
4647 pull in an --as-needed shared lib, but won't cause link
4648 errors. Archives are handled elsewhere. */
4649 fdh = make_fdh (info, eh);
4650 if (fdh == NULL)
4651 return FALSE;
4652 fdh->elf.ref_regular = 1;
4653 }
4654 }
4655 else
4656 {
4657 unsigned entry_vis = ELF_ST_VISIBILITY (eh->elf.other) - 1;
4658 unsigned descr_vis = ELF_ST_VISIBILITY (fdh->elf.other) - 1;
4659 if (entry_vis < descr_vis)
4660 fdh->elf.other += entry_vis - descr_vis;
4661 else if (entry_vis > descr_vis)
4662 eh->elf.other += descr_vis - entry_vis;
4663
4664 if ((fdh->elf.root.type == bfd_link_hash_defined
4665 || fdh->elf.root.type == bfd_link_hash_defweak)
4666 && eh->elf.root.type == bfd_link_hash_undefined)
4667 {
4668 eh->elf.root.type = bfd_link_hash_undefweak;
4669 eh->was_undefined = 1;
4670 htab->twiddled_syms = 1;
4671 }
4672 }
4673
4674 return TRUE;
4675 }
4676
4677 /* Process list of dot-symbols we made in link_hash_newfunc. */
4678
4679 static bfd_boolean
4680 ppc64_elf_process_dot_syms (bfd *ibfd, struct bfd_link_info *info)
4681 {
4682 struct ppc_link_hash_table *htab;
4683 struct ppc_link_hash_entry **p, *eh;
4684
4685 if (!is_ppc64_elf (info->output_bfd))
4686 return TRUE;
4687 htab = ppc_hash_table (info);
4688 if (htab == NULL)
4689 return FALSE;
4690
4691 if (is_ppc64_elf (ibfd))
4692 {
4693 p = &htab->dot_syms;
4694 while ((eh = *p) != NULL)
4695 {
4696 *p = NULL;
4697 if (!add_symbol_adjust (eh, info))
4698 return FALSE;
4699 p = &eh->u.next_dot_sym;
4700 }
4701 }
4702
4703 /* Clear the list for non-ppc64 input files. */
4704 p = &htab->dot_syms;
4705 while ((eh = *p) != NULL)
4706 {
4707 *p = NULL;
4708 p = &eh->u.next_dot_sym;
4709 }
4710
4711 /* We need to fix the undefs list for any syms we have twiddled to
4712 undef_weak. */
4713 if (htab->twiddled_syms)
4714 {
4715 bfd_link_repair_undef_list (&htab->elf.root);
4716 htab->twiddled_syms = 0;
4717 }
4718 return TRUE;
4719 }
4720
4721 /* Undo hash table changes when an --as-needed input file is determined
4722 not to be needed. */
4723
4724 static bfd_boolean
4725 ppc64_elf_as_needed_cleanup (bfd *ibfd ATTRIBUTE_UNUSED,
4726 struct bfd_link_info *info)
4727 {
4728 struct ppc_link_hash_table *htab = ppc_hash_table (info);
4729
4730 if (htab == NULL)
4731 return FALSE;
4732
4733 htab->dot_syms = NULL;
4734 return TRUE;
4735 }
4736
4737 static struct plt_entry **
4738 update_local_sym_info (bfd *abfd, Elf_Internal_Shdr *symtab_hdr,
4739 unsigned long r_symndx, bfd_vma r_addend, int tls_type)
4740 {
4741 struct got_entry **local_got_ents = elf_local_got_ents (abfd);
4742 struct plt_entry **local_plt;
4743 char *local_got_tls_masks;
4744
4745 if (local_got_ents == NULL)
4746 {
4747 bfd_size_type size = symtab_hdr->sh_info;
4748
4749 size *= (sizeof (*local_got_ents)
4750 + sizeof (*local_plt)
4751 + sizeof (*local_got_tls_masks));
4752 local_got_ents = bfd_zalloc (abfd, size);
4753 if (local_got_ents == NULL)
4754 return NULL;
4755 elf_local_got_ents (abfd) = local_got_ents;
4756 }
4757
4758 if ((tls_type & (PLT_IFUNC | TLS_EXPLICIT)) == 0)
4759 {
4760 struct got_entry *ent;
4761
4762 for (ent = local_got_ents[r_symndx]; ent != NULL; ent = ent->next)
4763 if (ent->addend == r_addend
4764 && ent->owner == abfd
4765 && ent->tls_type == tls_type)
4766 break;
4767 if (ent == NULL)
4768 {
4769 bfd_size_type amt = sizeof (*ent);
4770 ent = bfd_alloc (abfd, amt);
4771 if (ent == NULL)
4772 return FALSE;
4773 ent->next = local_got_ents[r_symndx];
4774 ent->addend = r_addend;
4775 ent->owner = abfd;
4776 ent->tls_type = tls_type;
4777 ent->is_indirect = FALSE;
4778 ent->got.refcount = 0;
4779 local_got_ents[r_symndx] = ent;
4780 }
4781 ent->got.refcount += 1;
4782 }
4783
4784 local_plt = (struct plt_entry **) (local_got_ents + symtab_hdr->sh_info);
4785 local_got_tls_masks = (char *) (local_plt + symtab_hdr->sh_info);
4786 local_got_tls_masks[r_symndx] |= tls_type;
4787
4788 return local_plt + r_symndx;
4789 }
4790
4791 static bfd_boolean
4792 update_plt_info (bfd *abfd, struct plt_entry **plist, bfd_vma addend)
4793 {
4794 struct plt_entry *ent;
4795
4796 for (ent = *plist; ent != NULL; ent = ent->next)
4797 if (ent->addend == addend)
4798 break;
4799 if (ent == NULL)
4800 {
4801 bfd_size_type amt = sizeof (*ent);
4802 ent = bfd_alloc (abfd, amt);
4803 if (ent == NULL)
4804 return FALSE;
4805 ent->next = *plist;
4806 ent->addend = addend;
4807 ent->plt.refcount = 0;
4808 *plist = ent;
4809 }
4810 ent->plt.refcount += 1;
4811 return TRUE;
4812 }
4813
4814 static bfd_boolean
4815 is_branch_reloc (enum elf_ppc64_reloc_type r_type)
4816 {
4817 return (r_type == R_PPC64_REL24
4818 || r_type == R_PPC64_REL14
4819 || r_type == R_PPC64_REL14_BRTAKEN
4820 || r_type == R_PPC64_REL14_BRNTAKEN
4821 || r_type == R_PPC64_ADDR24
4822 || r_type == R_PPC64_ADDR14
4823 || r_type == R_PPC64_ADDR14_BRTAKEN
4824 || r_type == R_PPC64_ADDR14_BRNTAKEN);
4825 }
4826
4827 /* Look through the relocs for a section during the first phase, and
4828 calculate needed space in the global offset table, procedure
4829 linkage table, and dynamic reloc sections. */
4830
4831 static bfd_boolean
4832 ppc64_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
4833 asection *sec, const Elf_Internal_Rela *relocs)
4834 {
4835 struct ppc_link_hash_table *htab;
4836 Elf_Internal_Shdr *symtab_hdr;
4837 struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
4838 const Elf_Internal_Rela *rel;
4839 const Elf_Internal_Rela *rel_end;
4840 asection *sreloc;
4841 asection **opd_sym_map;
4842 struct elf_link_hash_entry *tga, *dottga;
4843
4844 if (info->relocatable)
4845 return TRUE;
4846
4847 /* Don't do anything special with non-loaded, non-alloced sections.
4848 In particular, any relocs in such sections should not affect GOT
4849 and PLT reference counting (ie. we don't allow them to create GOT
4850 or PLT entries), there's no possibility or desire to optimize TLS
4851 relocs, and there's not much point in propagating relocs to shared
4852 libs that the dynamic linker won't relocate. */
4853 if ((sec->flags & SEC_ALLOC) == 0)
4854 return TRUE;
4855
4856 BFD_ASSERT (is_ppc64_elf (abfd));
4857
4858 htab = ppc_hash_table (info);
4859 if (htab == NULL)
4860 return FALSE;
4861
4862 tga = elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
4863 FALSE, FALSE, TRUE);
4864 dottga = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
4865 FALSE, FALSE, TRUE);
4866 symtab_hdr = &elf_symtab_hdr (abfd);
4867
4868 sym_hashes = elf_sym_hashes (abfd);
4869 sym_hashes_end = (sym_hashes
4870 + symtab_hdr->sh_size / sizeof (Elf64_External_Sym)
4871 - symtab_hdr->sh_info);
4872
4873 sreloc = NULL;
4874 opd_sym_map = NULL;
4875 if (strcmp (bfd_get_section_name (abfd, sec), ".opd") == 0)
4876 {
4877 /* Garbage collection needs some extra help with .opd sections.
4878 We don't want to necessarily keep everything referenced by
4879 relocs in .opd, as that would keep all functions. Instead,
4880 if we reference an .opd symbol (a function descriptor), we
4881 want to keep the function code symbol's section. This is
4882 easy for global symbols, but for local syms we need to keep
4883 information about the associated function section. */
4884 bfd_size_type amt;
4885
4886 amt = sec->size * sizeof (*opd_sym_map) / 8;
4887 opd_sym_map = bfd_zalloc (abfd, amt);
4888 if (opd_sym_map == NULL)
4889 return FALSE;
4890 ppc64_elf_section_data (sec)->u.opd.func_sec = opd_sym_map;
4891 BFD_ASSERT (ppc64_elf_section_data (sec)->sec_type == sec_normal);
4892 ppc64_elf_section_data (sec)->sec_type = sec_opd;
4893 }
4894
4895 if (htab->sfpr == NULL
4896 && !create_linkage_sections (htab->elf.dynobj, info))
4897 return FALSE;
4898
4899 rel_end = relocs + sec->reloc_count;
4900 for (rel = relocs; rel < rel_end; rel++)
4901 {
4902 unsigned long r_symndx;
4903 struct elf_link_hash_entry *h;
4904 enum elf_ppc64_reloc_type r_type;
4905 int tls_type;
4906 struct _ppc64_elf_section_data *ppc64_sec;
4907 struct plt_entry **ifunc;
4908
4909 r_symndx = ELF64_R_SYM (rel->r_info);
4910 if (r_symndx < symtab_hdr->sh_info)
4911 h = NULL;
4912 else
4913 {
4914 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
4915 h = elf_follow_link (h);
4916 }
4917
4918 tls_type = 0;
4919 ifunc = NULL;
4920 if (h != NULL)
4921 {
4922 if (h->type == STT_GNU_IFUNC)
4923 {
4924 h->needs_plt = 1;
4925 ifunc = &h->plt.plist;
4926 }
4927 }
4928 else
4929 {
4930 Elf_Internal_Sym *isym = bfd_sym_from_r_symndx (&htab->sym_cache,
4931 abfd, r_symndx);
4932 if (isym == NULL)
4933 return FALSE;
4934
4935 if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
4936 {
4937 ifunc = update_local_sym_info (abfd, symtab_hdr, r_symndx,
4938 rel->r_addend, PLT_IFUNC);
4939 if (ifunc == NULL)
4940 return FALSE;
4941 }
4942 }
4943 r_type = ELF64_R_TYPE (rel->r_info);
4944 if (is_branch_reloc (r_type))
4945 {
4946 if (h != NULL && (h == tga || h == dottga))
4947 {
4948 if (rel != relocs
4949 && (ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSGD
4950 || ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSLD))
4951 /* We have a new-style __tls_get_addr call with a marker
4952 reloc. */
4953 ;
4954 else
4955 /* Mark this section as having an old-style call. */
4956 sec->has_tls_get_addr_call = 1;
4957 }
4958
4959 /* STT_GNU_IFUNC symbols must have a PLT entry. */
4960 if (ifunc != NULL
4961 && !update_plt_info (abfd, ifunc, rel->r_addend))
4962 return FALSE;
4963 }
4964
4965 switch (r_type)
4966 {
4967 case R_PPC64_TLSGD:
4968 case R_PPC64_TLSLD:
4969 /* These special tls relocs tie a call to __tls_get_addr with
4970 its parameter symbol. */
4971 break;
4972
4973 case R_PPC64_GOT_TLSLD16:
4974 case R_PPC64_GOT_TLSLD16_LO:
4975 case R_PPC64_GOT_TLSLD16_HI:
4976 case R_PPC64_GOT_TLSLD16_HA:
4977 tls_type = TLS_TLS | TLS_LD;
4978 goto dogottls;
4979
4980 case R_PPC64_GOT_TLSGD16:
4981 case R_PPC64_GOT_TLSGD16_LO:
4982 case R_PPC64_GOT_TLSGD16_HI:
4983 case R_PPC64_GOT_TLSGD16_HA:
4984 tls_type = TLS_TLS | TLS_GD;
4985 goto dogottls;
4986
4987 case R_PPC64_GOT_TPREL16_DS:
4988 case R_PPC64_GOT_TPREL16_LO_DS:
4989 case R_PPC64_GOT_TPREL16_HI:
4990 case R_PPC64_GOT_TPREL16_HA:
4991 if (!info->executable)
4992 info->flags |= DF_STATIC_TLS;
4993 tls_type = TLS_TLS | TLS_TPREL;
4994 goto dogottls;
4995
4996 case R_PPC64_GOT_DTPREL16_DS:
4997 case R_PPC64_GOT_DTPREL16_LO_DS:
4998 case R_PPC64_GOT_DTPREL16_HI:
4999 case R_PPC64_GOT_DTPREL16_HA:
5000 tls_type = TLS_TLS | TLS_DTPREL;
5001 dogottls:
5002 sec->has_tls_reloc = 1;
5003 /* Fall thru */
5004
5005 case R_PPC64_GOT16:
5006 case R_PPC64_GOT16_DS:
5007 case R_PPC64_GOT16_HA:
5008 case R_PPC64_GOT16_HI:
5009 case R_PPC64_GOT16_LO:
5010 case R_PPC64_GOT16_LO_DS:
5011 /* This symbol requires a global offset table entry. */
5012 sec->has_toc_reloc = 1;
5013 if (ppc64_elf_tdata (abfd)->got == NULL
5014 && !create_got_section (abfd, info))
5015 return FALSE;
5016
5017 if (h != NULL)
5018 {
5019 struct ppc_link_hash_entry *eh;
5020 struct got_entry *ent;
5021
5022 eh = (struct ppc_link_hash_entry *) h;
5023 for (ent = eh->elf.got.glist; ent != NULL; ent = ent->next)
5024 if (ent->addend == rel->r_addend
5025 && ent->owner == abfd
5026 && ent->tls_type == tls_type)
5027 break;
5028 if (ent == NULL)
5029 {
5030 bfd_size_type amt = sizeof (*ent);
5031 ent = bfd_alloc (abfd, amt);
5032 if (ent == NULL)
5033 return FALSE;
5034 ent->next = eh->elf.got.glist;
5035 ent->addend = rel->r_addend;
5036 ent->owner = abfd;
5037 ent->tls_type = tls_type;
5038 ent->is_indirect = FALSE;
5039 ent->got.refcount = 0;
5040 eh->elf.got.glist = ent;
5041 }
5042 ent->got.refcount += 1;
5043 eh->tls_mask |= tls_type;
5044 }
5045 else
5046 /* This is a global offset table entry for a local symbol. */
5047 if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5048 rel->r_addend, tls_type))
5049 return FALSE;
5050 break;
5051
5052 case R_PPC64_PLT16_HA:
5053 case R_PPC64_PLT16_HI:
5054 case R_PPC64_PLT16_LO:
5055 case R_PPC64_PLT32:
5056 case R_PPC64_PLT64:
5057 /* This symbol requires a procedure linkage table entry. We
5058 actually build the entry in adjust_dynamic_symbol,
5059 because this might be a case of linking PIC code without
5060 linking in any dynamic objects, in which case we don't
5061 need to generate a procedure linkage table after all. */
5062 if (h == NULL)
5063 {
5064 /* It does not make sense to have a procedure linkage
5065 table entry for a local symbol. */
5066 bfd_set_error (bfd_error_bad_value);
5067 return FALSE;
5068 }
5069 else
5070 {
5071 if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5072 return FALSE;
5073 h->needs_plt = 1;
5074 if (h->root.root.string[0] == '.'
5075 && h->root.root.string[1] != '\0')
5076 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5077 }
5078 break;
5079
5080 /* The following relocations don't need to propagate the
5081 relocation if linking a shared object since they are
5082 section relative. */
5083 case R_PPC64_SECTOFF:
5084 case R_PPC64_SECTOFF_LO:
5085 case R_PPC64_SECTOFF_HI:
5086 case R_PPC64_SECTOFF_HA:
5087 case R_PPC64_SECTOFF_DS:
5088 case R_PPC64_SECTOFF_LO_DS:
5089 case R_PPC64_DTPREL16:
5090 case R_PPC64_DTPREL16_LO:
5091 case R_PPC64_DTPREL16_HI:
5092 case R_PPC64_DTPREL16_HA:
5093 case R_PPC64_DTPREL16_DS:
5094 case R_PPC64_DTPREL16_LO_DS:
5095 case R_PPC64_DTPREL16_HIGHER:
5096 case R_PPC64_DTPREL16_HIGHERA:
5097 case R_PPC64_DTPREL16_HIGHEST:
5098 case R_PPC64_DTPREL16_HIGHESTA:
5099 break;
5100
5101 /* Nor do these. */
5102 case R_PPC64_REL16:
5103 case R_PPC64_REL16_LO:
5104 case R_PPC64_REL16_HI:
5105 case R_PPC64_REL16_HA:
5106 break;
5107
5108 case R_PPC64_TOC16:
5109 case R_PPC64_TOC16_LO:
5110 case R_PPC64_TOC16_HI:
5111 case R_PPC64_TOC16_HA:
5112 case R_PPC64_TOC16_DS:
5113 case R_PPC64_TOC16_LO_DS:
5114 sec->has_toc_reloc = 1;
5115 break;
5116
5117 /* This relocation describes the C++ object vtable hierarchy.
5118 Reconstruct it for later use during GC. */
5119 case R_PPC64_GNU_VTINHERIT:
5120 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
5121 return FALSE;
5122 break;
5123
5124 /* This relocation describes which C++ vtable entries are actually
5125 used. Record for later use during GC. */
5126 case R_PPC64_GNU_VTENTRY:
5127 BFD_ASSERT (h != NULL);
5128 if (h != NULL
5129 && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
5130 return FALSE;
5131 break;
5132
5133 case R_PPC64_REL14:
5134 case R_PPC64_REL14_BRTAKEN:
5135 case R_PPC64_REL14_BRNTAKEN:
5136 {
5137 asection *dest = NULL;
5138
5139 /* Heuristic: If jumping outside our section, chances are
5140 we are going to need a stub. */
5141 if (h != NULL)
5142 {
5143 /* If the sym is weak it may be overridden later, so
5144 don't assume we know where a weak sym lives. */
5145 if (h->root.type == bfd_link_hash_defined)
5146 dest = h->root.u.def.section;
5147 }
5148 else
5149 {
5150 Elf_Internal_Sym *isym;
5151
5152 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5153 abfd, r_symndx);
5154 if (isym == NULL)
5155 return FALSE;
5156
5157 dest = bfd_section_from_elf_index (abfd, isym->st_shndx);
5158 }
5159
5160 if (dest != sec)
5161 ppc64_elf_section_data (sec)->has_14bit_branch = 1;
5162 }
5163 /* Fall through. */
5164
5165 case R_PPC64_REL24:
5166 if (h != NULL && ifunc == NULL)
5167 {
5168 /* We may need a .plt entry if the function this reloc
5169 refers to is in a shared lib. */
5170 if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5171 return FALSE;
5172 h->needs_plt = 1;
5173 if (h->root.root.string[0] == '.'
5174 && h->root.root.string[1] != '\0')
5175 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5176 if (h == tga || h == dottga)
5177 sec->has_tls_reloc = 1;
5178 }
5179 break;
5180
5181 case R_PPC64_TPREL64:
5182 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_TPREL;
5183 if (!info->executable)
5184 info->flags |= DF_STATIC_TLS;
5185 goto dotlstoc;
5186
5187 case R_PPC64_DTPMOD64:
5188 if (rel + 1 < rel_end
5189 && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
5190 && rel[1].r_offset == rel->r_offset + 8)
5191 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_GD;
5192 else
5193 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_LD;
5194 goto dotlstoc;
5195
5196 case R_PPC64_DTPREL64:
5197 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_DTPREL;
5198 if (rel != relocs
5199 && rel[-1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPMOD64)
5200 && rel[-1].r_offset == rel->r_offset - 8)
5201 /* This is the second reloc of a dtpmod, dtprel pair.
5202 Don't mark with TLS_DTPREL. */
5203 goto dodyn;
5204
5205 dotlstoc:
5206 sec->has_tls_reloc = 1;
5207 if (h != NULL)
5208 {
5209 struct ppc_link_hash_entry *eh;
5210 eh = (struct ppc_link_hash_entry *) h;
5211 eh->tls_mask |= tls_type;
5212 }
5213 else
5214 if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5215 rel->r_addend, tls_type))
5216 return FALSE;
5217
5218 ppc64_sec = ppc64_elf_section_data (sec);
5219 if (ppc64_sec->sec_type != sec_toc)
5220 {
5221 bfd_size_type amt;
5222
5223 /* One extra to simplify get_tls_mask. */
5224 amt = sec->size * sizeof (unsigned) / 8 + sizeof (unsigned);
5225 ppc64_sec->u.toc.symndx = bfd_zalloc (abfd, amt);
5226 if (ppc64_sec->u.toc.symndx == NULL)
5227 return FALSE;
5228 amt = sec->size * sizeof (bfd_vma) / 8;
5229 ppc64_sec->u.toc.add = bfd_zalloc (abfd, amt);
5230 if (ppc64_sec->u.toc.add == NULL)
5231 return FALSE;
5232 BFD_ASSERT (ppc64_sec->sec_type == sec_normal);
5233 ppc64_sec->sec_type = sec_toc;
5234 }
5235 BFD_ASSERT (rel->r_offset % 8 == 0);
5236 ppc64_sec->u.toc.symndx[rel->r_offset / 8] = r_symndx;
5237 ppc64_sec->u.toc.add[rel->r_offset / 8] = rel->r_addend;
5238
5239 /* Mark the second slot of a GD or LD entry.
5240 -1 to indicate GD and -2 to indicate LD. */
5241 if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_GD))
5242 ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -1;
5243 else if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_LD))
5244 ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -2;
5245 goto dodyn;
5246
5247 case R_PPC64_TPREL16:
5248 case R_PPC64_TPREL16_LO:
5249 case R_PPC64_TPREL16_HI:
5250 case R_PPC64_TPREL16_HA:
5251 case R_PPC64_TPREL16_DS:
5252 case R_PPC64_TPREL16_LO_DS:
5253 case R_PPC64_TPREL16_HIGHER:
5254 case R_PPC64_TPREL16_HIGHERA:
5255 case R_PPC64_TPREL16_HIGHEST:
5256 case R_PPC64_TPREL16_HIGHESTA:
5257 if (info->shared)
5258 {
5259 if (!info->executable)
5260 info->flags |= DF_STATIC_TLS;
5261 goto dodyn;
5262 }
5263 break;
5264
5265 case R_PPC64_ADDR64:
5266 if (opd_sym_map != NULL
5267 && rel + 1 < rel_end
5268 && ELF64_R_TYPE ((rel + 1)->r_info) == R_PPC64_TOC)
5269 {
5270 if (h != NULL)
5271 {
5272 if (h->root.root.string[0] == '.'
5273 && h->root.root.string[1] != 0
5274 && lookup_fdh ((struct ppc_link_hash_entry *) h, htab))
5275 ;
5276 else
5277 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5278 }
5279 else
5280 {
5281 asection *s;
5282 Elf_Internal_Sym *isym;
5283
5284 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5285 abfd, r_symndx);
5286 if (isym == NULL)
5287 return FALSE;
5288
5289 s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5290 if (s != NULL && s != sec)
5291 opd_sym_map[rel->r_offset / 8] = s;
5292 }
5293 }
5294 /* Fall through. */
5295
5296 case R_PPC64_REL30:
5297 case R_PPC64_REL32:
5298 case R_PPC64_REL64:
5299 case R_PPC64_ADDR14:
5300 case R_PPC64_ADDR14_BRNTAKEN:
5301 case R_PPC64_ADDR14_BRTAKEN:
5302 case R_PPC64_ADDR16:
5303 case R_PPC64_ADDR16_DS:
5304 case R_PPC64_ADDR16_HA:
5305 case R_PPC64_ADDR16_HI:
5306 case R_PPC64_ADDR16_HIGHER:
5307 case R_PPC64_ADDR16_HIGHERA:
5308 case R_PPC64_ADDR16_HIGHEST:
5309 case R_PPC64_ADDR16_HIGHESTA:
5310 case R_PPC64_ADDR16_LO:
5311 case R_PPC64_ADDR16_LO_DS:
5312 case R_PPC64_ADDR24:
5313 case R_PPC64_ADDR32:
5314 case R_PPC64_UADDR16:
5315 case R_PPC64_UADDR32:
5316 case R_PPC64_UADDR64:
5317 case R_PPC64_TOC:
5318 if (h != NULL && !info->shared)
5319 /* We may need a copy reloc. */
5320 h->non_got_ref = 1;
5321
5322 /* Don't propagate .opd relocs. */
5323 if (NO_OPD_RELOCS && opd_sym_map != NULL)
5324 break;
5325
5326 /* If we are creating a shared library, and this is a reloc
5327 against a global symbol, or a non PC relative reloc
5328 against a local symbol, then we need to copy the reloc
5329 into the shared library. However, if we are linking with
5330 -Bsymbolic, we do not need to copy a reloc against a
5331 global symbol which is defined in an object we are
5332 including in the link (i.e., DEF_REGULAR is set). At
5333 this point we have not seen all the input files, so it is
5334 possible that DEF_REGULAR is not set now but will be set
5335 later (it is never cleared). In case of a weak definition,
5336 DEF_REGULAR may be cleared later by a strong definition in
5337 a shared library. We account for that possibility below by
5338 storing information in the dyn_relocs field of the hash
5339 table entry. A similar situation occurs when creating
5340 shared libraries and symbol visibility changes render the
5341 symbol local.
5342
5343 If on the other hand, we are creating an executable, we
5344 may need to keep relocations for symbols satisfied by a
5345 dynamic library if we manage to avoid copy relocs for the
5346 symbol. */
5347 dodyn:
5348 if ((info->shared
5349 && (must_be_dyn_reloc (info, r_type)
5350 || (h != NULL
5351 && (! info->symbolic
5352 || h->root.type == bfd_link_hash_defweak
5353 || !h->def_regular))))
5354 || (ELIMINATE_COPY_RELOCS
5355 && !info->shared
5356 && h != NULL
5357 && (h->root.type == bfd_link_hash_defweak
5358 || !h->def_regular))
5359 || (!info->shared
5360 && ifunc != NULL))
5361 {
5362 struct ppc_dyn_relocs *p;
5363 struct ppc_dyn_relocs **head;
5364
5365 /* We must copy these reloc types into the output file.
5366 Create a reloc section in dynobj and make room for
5367 this reloc. */
5368 if (sreloc == NULL)
5369 {
5370 sreloc = _bfd_elf_make_dynamic_reloc_section
5371 (sec, htab->elf.dynobj, 3, abfd, /*rela?*/ TRUE);
5372
5373 if (sreloc == NULL)
5374 return FALSE;
5375 }
5376
5377 /* If this is a global symbol, we count the number of
5378 relocations we need for this symbol. */
5379 if (h != NULL)
5380 {
5381 head = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
5382 }
5383 else
5384 {
5385 /* Track dynamic relocs needed for local syms too.
5386 We really need local syms available to do this
5387 easily. Oh well. */
5388 asection *s;
5389 void *vpp;
5390 Elf_Internal_Sym *isym;
5391
5392 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5393 abfd, r_symndx);
5394 if (isym == NULL)
5395 return FALSE;
5396
5397 s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5398 if (s == NULL)
5399 s = sec;
5400
5401 vpp = &elf_section_data (s)->local_dynrel;
5402 head = (struct ppc_dyn_relocs **) vpp;
5403 }
5404
5405 p = *head;
5406 if (p == NULL || p->sec != sec)
5407 {
5408 p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5409 if (p == NULL)
5410 return FALSE;
5411 p->next = *head;
5412 *head = p;
5413 p->sec = sec;
5414 p->count = 0;
5415 p->pc_count = 0;
5416 }
5417
5418 p->count += 1;
5419 if (!must_be_dyn_reloc (info, r_type))
5420 p->pc_count += 1;
5421 }
5422 break;
5423
5424 default:
5425 break;
5426 }
5427 }
5428
5429 return TRUE;
5430 }
5431
5432 /* OFFSET in OPD_SEC specifies a function descriptor. Return the address
5433 of the code entry point, and its section. */
5434
5435 static bfd_vma
5436 opd_entry_value (asection *opd_sec,
5437 bfd_vma offset,
5438 asection **code_sec,
5439 bfd_vma *code_off)
5440 {
5441 bfd *opd_bfd = opd_sec->owner;
5442 Elf_Internal_Rela *relocs;
5443 Elf_Internal_Rela *lo, *hi, *look;
5444 bfd_vma val;
5445
5446 /* No relocs implies we are linking a --just-symbols object. */
5447 if (opd_sec->reloc_count == 0)
5448 {
5449 if (!bfd_get_section_contents (opd_bfd, opd_sec, &val, offset, 8))
5450 return (bfd_vma) -1;
5451
5452 if (code_sec != NULL)
5453 {
5454 asection *sec, *likely = NULL;
5455 for (sec = opd_bfd->sections; sec != NULL; sec = sec->next)
5456 if (sec->vma <= val
5457 && (sec->flags & SEC_LOAD) != 0
5458 && (sec->flags & SEC_ALLOC) != 0)
5459 likely = sec;
5460 if (likely != NULL)
5461 {
5462 *code_sec = likely;
5463 if (code_off != NULL)
5464 *code_off = val - likely->vma;
5465 }
5466 }
5467 return val;
5468 }
5469
5470 BFD_ASSERT (is_ppc64_elf (opd_bfd));
5471
5472 relocs = ppc64_elf_tdata (opd_bfd)->opd_relocs;
5473 if (relocs == NULL)
5474 relocs = _bfd_elf_link_read_relocs (opd_bfd, opd_sec, NULL, NULL, TRUE);
5475
5476 /* Go find the opd reloc at the sym address. */
5477 lo = relocs;
5478 BFD_ASSERT (lo != NULL);
5479 hi = lo + opd_sec->reloc_count - 1; /* ignore last reloc */
5480 val = (bfd_vma) -1;
5481 while (lo < hi)
5482 {
5483 look = lo + (hi - lo) / 2;
5484 if (look->r_offset < offset)
5485 lo = look + 1;
5486 else if (look->r_offset > offset)
5487 hi = look;
5488 else
5489 {
5490 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (opd_bfd);
5491
5492 if (ELF64_R_TYPE (look->r_info) == R_PPC64_ADDR64
5493 && ELF64_R_TYPE ((look + 1)->r_info) == R_PPC64_TOC)
5494 {
5495 unsigned long symndx = ELF64_R_SYM (look->r_info);
5496 asection *sec;
5497
5498 if (symndx < symtab_hdr->sh_info)
5499 {
5500 Elf_Internal_Sym *sym;
5501
5502 sym = (Elf_Internal_Sym *) symtab_hdr->contents;
5503 if (sym == NULL)
5504 {
5505 sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr,
5506 symtab_hdr->sh_info,
5507 0, NULL, NULL, NULL);
5508 if (sym == NULL)
5509 break;
5510 symtab_hdr->contents = (bfd_byte *) sym;
5511 }
5512
5513 sym += symndx;
5514 val = sym->st_value;
5515 sec = bfd_section_from_elf_index (opd_bfd, sym->st_shndx);
5516 BFD_ASSERT ((sec->flags & SEC_MERGE) == 0);
5517 }
5518 else
5519 {
5520 struct elf_link_hash_entry **sym_hashes;
5521 struct elf_link_hash_entry *rh;
5522
5523 sym_hashes = elf_sym_hashes (opd_bfd);
5524 rh = sym_hashes[symndx - symtab_hdr->sh_info];
5525 rh = elf_follow_link (rh);
5526 BFD_ASSERT (rh->root.type == bfd_link_hash_defined
5527 || rh->root.type == bfd_link_hash_defweak);
5528 val = rh->root.u.def.value;
5529 sec = rh->root.u.def.section;
5530 }
5531 val += look->r_addend;
5532 if (code_off != NULL)
5533 *code_off = val;
5534 if (code_sec != NULL)
5535 *code_sec = sec;
5536 if (sec != NULL && sec->output_section != NULL)
5537 val += sec->output_section->vma + sec->output_offset;
5538 }
5539 break;
5540 }
5541 }
5542
5543 return val;
5544 }
5545
5546 /* If FDH is a function descriptor symbol, return the associated code
5547 entry symbol if it is defined. Return NULL otherwise. */
5548
5549 static struct ppc_link_hash_entry *
5550 defined_code_entry (struct ppc_link_hash_entry *fdh)
5551 {
5552 if (fdh->is_func_descriptor)
5553 {
5554 struct ppc_link_hash_entry *fh = ppc_follow_link (fdh->oh);
5555 if (fh->elf.root.type == bfd_link_hash_defined
5556 || fh->elf.root.type == bfd_link_hash_defweak)
5557 return fh;
5558 }
5559 return NULL;
5560 }
5561
5562 /* If FH is a function code entry symbol, return the associated
5563 function descriptor symbol if it is defined. Return NULL otherwise. */
5564
5565 static struct ppc_link_hash_entry *
5566 defined_func_desc (struct ppc_link_hash_entry *fh)
5567 {
5568 if (fh->oh != NULL
5569 && fh->oh->is_func_descriptor)
5570 {
5571 struct ppc_link_hash_entry *fdh = ppc_follow_link (fh->oh);
5572 if (fdh->elf.root.type == bfd_link_hash_defined
5573 || fdh->elf.root.type == bfd_link_hash_defweak)
5574 return fdh;
5575 }
5576 return NULL;
5577 }
5578
5579 /* Mark all our entry sym sections, both opd and code section. */
5580
5581 static void
5582 ppc64_elf_gc_keep (struct bfd_link_info *info)
5583 {
5584 struct ppc_link_hash_table *htab = ppc_hash_table (info);
5585 struct bfd_sym_chain *sym;
5586
5587 if (htab == NULL)
5588 return;
5589
5590 for (sym = info->gc_sym_list; sym != NULL; sym = sym->next)
5591 {
5592 struct ppc_link_hash_entry *eh, *fh;
5593 asection *sec;
5594
5595 eh = (struct ppc_link_hash_entry *)
5596 elf_link_hash_lookup (&htab->elf, sym->name, FALSE, FALSE, TRUE);
5597 if (eh == NULL)
5598 continue;
5599 if (eh->elf.root.type != bfd_link_hash_defined
5600 && eh->elf.root.type != bfd_link_hash_defweak)
5601 continue;
5602
5603 fh = defined_code_entry (eh);
5604 if (fh != NULL)
5605 {
5606 sec = fh->elf.root.u.def.section;
5607 sec->flags |= SEC_KEEP;
5608 }
5609 else if (get_opd_info (eh->elf.root.u.def.section) != NULL
5610 && opd_entry_value (eh->elf.root.u.def.section,
5611 eh->elf.root.u.def.value,
5612 &sec, NULL) != (bfd_vma) -1)
5613 sec->flags |= SEC_KEEP;
5614
5615 sec = eh->elf.root.u.def.section;
5616 sec->flags |= SEC_KEEP;
5617 }
5618 }
5619
5620 /* Mark sections containing dynamically referenced symbols. When
5621 building shared libraries, we must assume that any visible symbol is
5622 referenced. */
5623
5624 static bfd_boolean
5625 ppc64_elf_gc_mark_dynamic_ref (struct elf_link_hash_entry *h, void *inf)
5626 {
5627 struct bfd_link_info *info = (struct bfd_link_info *) inf;
5628 struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
5629 struct ppc_link_hash_entry *fdh;
5630
5631 if (eh->elf.root.type == bfd_link_hash_warning)
5632 eh = (struct ppc_link_hash_entry *) eh->elf.root.u.i.link;
5633
5634 /* Dynamic linking info is on the func descriptor sym. */
5635 fdh = defined_func_desc (eh);
5636 if (fdh != NULL)
5637 eh = fdh;
5638
5639 if ((eh->elf.root.type == bfd_link_hash_defined
5640 || eh->elf.root.type == bfd_link_hash_defweak)
5641 && (eh->elf.ref_dynamic
5642 || (!info->executable
5643 && eh->elf.def_regular
5644 && ELF_ST_VISIBILITY (eh->elf.other) != STV_INTERNAL
5645 && ELF_ST_VISIBILITY (eh->elf.other) != STV_HIDDEN)))
5646 {
5647 asection *code_sec;
5648 struct ppc_link_hash_entry *fh;
5649
5650 eh->elf.root.u.def.section->flags |= SEC_KEEP;
5651
5652 /* Function descriptor syms cause the associated
5653 function code sym section to be marked. */
5654 fh = defined_code_entry (eh);
5655 if (fh != NULL)
5656 {
5657 code_sec = fh->elf.root.u.def.section;
5658 code_sec->flags |= SEC_KEEP;
5659 }
5660 else if (get_opd_info (eh->elf.root.u.def.section) != NULL
5661 && opd_entry_value (eh->elf.root.u.def.section,
5662 eh->elf.root.u.def.value,
5663 &code_sec, NULL) != (bfd_vma) -1)
5664 code_sec->flags |= SEC_KEEP;
5665 }
5666
5667 return TRUE;
5668 }
5669
5670 /* Return the section that should be marked against GC for a given
5671 relocation. */
5672
5673 static asection *
5674 ppc64_elf_gc_mark_hook (asection *sec,
5675 struct bfd_link_info *info,
5676 Elf_Internal_Rela *rel,
5677 struct elf_link_hash_entry *h,
5678 Elf_Internal_Sym *sym)
5679 {
5680 asection *rsec;
5681
5682 /* Syms return NULL if we're marking .opd, so we avoid marking all
5683 function sections, as all functions are referenced in .opd. */
5684 rsec = NULL;
5685 if (get_opd_info (sec) != NULL)
5686 return rsec;
5687
5688 if (h != NULL)
5689 {
5690 enum elf_ppc64_reloc_type r_type;
5691 struct ppc_link_hash_entry *eh, *fh, *fdh;
5692
5693 r_type = ELF64_R_TYPE (rel->r_info);
5694 switch (r_type)
5695 {
5696 case R_PPC64_GNU_VTINHERIT:
5697 case R_PPC64_GNU_VTENTRY:
5698 break;
5699
5700 default:
5701 switch (h->root.type)
5702 {
5703 case bfd_link_hash_defined:
5704 case bfd_link_hash_defweak:
5705 eh = (struct ppc_link_hash_entry *) h;
5706 fdh = defined_func_desc (eh);
5707 if (fdh != NULL)
5708 eh = fdh;
5709
5710 /* Function descriptor syms cause the associated
5711 function code sym section to be marked. */
5712 fh = defined_code_entry (eh);
5713 if (fh != NULL)
5714 {
5715 /* They also mark their opd section. */
5716 eh->elf.root.u.def.section->gc_mark = 1;
5717
5718 rsec = fh->elf.root.u.def.section;
5719 }
5720 else if (get_opd_info (eh->elf.root.u.def.section) != NULL
5721 && opd_entry_value (eh->elf.root.u.def.section,
5722 eh->elf.root.u.def.value,
5723 &rsec, NULL) != (bfd_vma) -1)
5724 eh->elf.root.u.def.section->gc_mark = 1;
5725 else
5726 rsec = h->root.u.def.section;
5727 break;
5728
5729 case bfd_link_hash_common:
5730 rsec = h->root.u.c.p->section;
5731 break;
5732
5733 default:
5734 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
5735 }
5736 }
5737 }
5738 else
5739 {
5740 struct _opd_sec_data *opd;
5741
5742 rsec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
5743 opd = get_opd_info (rsec);
5744 if (opd != NULL && opd->func_sec != NULL)
5745 {
5746 rsec->gc_mark = 1;
5747
5748 rsec = opd->func_sec[(sym->st_value + rel->r_addend) / 8];
5749 }
5750 }
5751
5752 return rsec;
5753 }
5754
5755 /* Update the .got, .plt. and dynamic reloc reference counts for the
5756 section being removed. */
5757
5758 static bfd_boolean
5759 ppc64_elf_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info,
5760 asection *sec, const Elf_Internal_Rela *relocs)
5761 {
5762 struct ppc_link_hash_table *htab;
5763 Elf_Internal_Shdr *symtab_hdr;
5764 struct elf_link_hash_entry **sym_hashes;
5765 struct got_entry **local_got_ents;
5766 const Elf_Internal_Rela *rel, *relend;
5767
5768 if (info->relocatable)
5769 return TRUE;
5770
5771 if ((sec->flags & SEC_ALLOC) == 0)
5772 return TRUE;
5773
5774 elf_section_data (sec)->local_dynrel = NULL;
5775
5776 htab = ppc_hash_table (info);
5777 if (htab == NULL)
5778 return FALSE;
5779
5780 symtab_hdr = &elf_symtab_hdr (abfd);
5781 sym_hashes = elf_sym_hashes (abfd);
5782 local_got_ents = elf_local_got_ents (abfd);
5783
5784 relend = relocs + sec->reloc_count;
5785 for (rel = relocs; rel < relend; rel++)
5786 {
5787 unsigned long r_symndx;
5788 enum elf_ppc64_reloc_type r_type;
5789 struct elf_link_hash_entry *h = NULL;
5790 char tls_type = 0;
5791
5792 r_symndx = ELF64_R_SYM (rel->r_info);
5793 r_type = ELF64_R_TYPE (rel->r_info);
5794 if (r_symndx >= symtab_hdr->sh_info)
5795 {
5796 struct ppc_link_hash_entry *eh;
5797 struct ppc_dyn_relocs **pp;
5798 struct ppc_dyn_relocs *p;
5799
5800 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
5801 h = elf_follow_link (h);
5802 eh = (struct ppc_link_hash_entry *) h;
5803
5804 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
5805 if (p->sec == sec)
5806 {
5807 /* Everything must go for SEC. */
5808 *pp = p->next;
5809 break;
5810 }
5811 }
5812
5813 if (is_branch_reloc (r_type))
5814 {
5815 struct plt_entry **ifunc = NULL;
5816 if (h != NULL)
5817 {
5818 if (h->type == STT_GNU_IFUNC)
5819 ifunc = &h->plt.plist;
5820 }
5821 else if (local_got_ents != NULL)
5822 {
5823 struct plt_entry **local_plt = (struct plt_entry **)
5824 (local_got_ents + symtab_hdr->sh_info);
5825 char *local_got_tls_masks = (char *)
5826 (local_plt + symtab_hdr->sh_info);
5827 if ((local_got_tls_masks[r_symndx] & PLT_IFUNC) != 0)
5828 ifunc = local_plt + r_symndx;
5829 }
5830 if (ifunc != NULL)
5831 {
5832 struct plt_entry *ent;
5833
5834 for (ent = *ifunc; ent != NULL; ent = ent->next)
5835 if (ent->addend == rel->r_addend)
5836 break;
5837 if (ent == NULL)
5838 abort ();
5839 if (ent->plt.refcount > 0)
5840 ent->plt.refcount -= 1;
5841 continue;
5842 }
5843 }
5844
5845 switch (r_type)
5846 {
5847 case R_PPC64_GOT_TLSLD16:
5848 case R_PPC64_GOT_TLSLD16_LO:
5849 case R_PPC64_GOT_TLSLD16_HI:
5850 case R_PPC64_GOT_TLSLD16_HA:
5851 tls_type = TLS_TLS | TLS_LD;
5852 goto dogot;
5853
5854 case R_PPC64_GOT_TLSGD16:
5855 case R_PPC64_GOT_TLSGD16_LO:
5856 case R_PPC64_GOT_TLSGD16_HI:
5857 case R_PPC64_GOT_TLSGD16_HA:
5858 tls_type = TLS_TLS | TLS_GD;
5859 goto dogot;
5860
5861 case R_PPC64_GOT_TPREL16_DS:
5862 case R_PPC64_GOT_TPREL16_LO_DS:
5863 case R_PPC64_GOT_TPREL16_HI:
5864 case R_PPC64_GOT_TPREL16_HA:
5865 tls_type = TLS_TLS | TLS_TPREL;
5866 goto dogot;
5867
5868 case R_PPC64_GOT_DTPREL16_DS:
5869 case R_PPC64_GOT_DTPREL16_LO_DS:
5870 case R_PPC64_GOT_DTPREL16_HI:
5871 case R_PPC64_GOT_DTPREL16_HA:
5872 tls_type = TLS_TLS | TLS_DTPREL;
5873 goto dogot;
5874
5875 case R_PPC64_GOT16:
5876 case R_PPC64_GOT16_DS:
5877 case R_PPC64_GOT16_HA:
5878 case R_PPC64_GOT16_HI:
5879 case R_PPC64_GOT16_LO:
5880 case R_PPC64_GOT16_LO_DS:
5881 dogot:
5882 {
5883 struct got_entry *ent;
5884
5885 if (h != NULL)
5886 ent = h->got.glist;
5887 else
5888 ent = local_got_ents[r_symndx];
5889
5890 for (; ent != NULL; ent = ent->next)
5891 if (ent->addend == rel->r_addend
5892 && ent->owner == abfd
5893 && ent->tls_type == tls_type)
5894 break;
5895 if (ent == NULL)
5896 abort ();
5897 if (ent->got.refcount > 0)
5898 ent->got.refcount -= 1;
5899 }
5900 break;
5901
5902 case R_PPC64_PLT16_HA:
5903 case R_PPC64_PLT16_HI:
5904 case R_PPC64_PLT16_LO:
5905 case R_PPC64_PLT32:
5906 case R_PPC64_PLT64:
5907 case R_PPC64_REL14:
5908 case R_PPC64_REL14_BRNTAKEN:
5909 case R_PPC64_REL14_BRTAKEN:
5910 case R_PPC64_REL24:
5911 if (h != NULL)
5912 {
5913 struct plt_entry *ent;
5914
5915 for (ent = h->plt.plist; ent != NULL; ent = ent->next)
5916 if (ent->addend == rel->r_addend)
5917 break;
5918 if (ent != NULL && ent->plt.refcount > 0)
5919 ent->plt.refcount -= 1;
5920 }
5921 break;
5922
5923 default:
5924 break;
5925 }
5926 }
5927 return TRUE;
5928 }
5929
5930 /* The maximum size of .sfpr. */
5931 #define SFPR_MAX (218*4)
5932
5933 struct sfpr_def_parms
5934 {
5935 const char name[12];
5936 unsigned char lo, hi;
5937 bfd_byte * (*write_ent) (bfd *, bfd_byte *, int);
5938 bfd_byte * (*write_tail) (bfd *, bfd_byte *, int);
5939 };
5940
5941 /* Auto-generate _save*, _rest* functions in .sfpr. */
5942
5943 static bfd_boolean
5944 sfpr_define (struct bfd_link_info *info, const struct sfpr_def_parms *parm)
5945 {
5946 struct ppc_link_hash_table *htab = ppc_hash_table (info);
5947 unsigned int i;
5948 size_t len = strlen (parm->name);
5949 bfd_boolean writing = FALSE;
5950 char sym[16];
5951
5952 if (htab == NULL)
5953 return FALSE;
5954
5955 memcpy (sym, parm->name, len);
5956 sym[len + 2] = 0;
5957
5958 for (i = parm->lo; i <= parm->hi; i++)
5959 {
5960 struct elf_link_hash_entry *h;
5961
5962 sym[len + 0] = i / 10 + '0';
5963 sym[len + 1] = i % 10 + '0';
5964 h = elf_link_hash_lookup (&htab->elf, sym, FALSE, FALSE, TRUE);
5965 if (h != NULL
5966 && !h->def_regular)
5967 {
5968 h->root.type = bfd_link_hash_defined;
5969 h->root.u.def.section = htab->sfpr;
5970 h->root.u.def.value = htab->sfpr->size;
5971 h->type = STT_FUNC;
5972 h->def_regular = 1;
5973 _bfd_elf_link_hash_hide_symbol (info, h, TRUE);
5974 writing = TRUE;
5975 if (htab->sfpr->contents == NULL)
5976 {
5977 htab->sfpr->contents = bfd_alloc (htab->elf.dynobj, SFPR_MAX);
5978 if (htab->sfpr->contents == NULL)
5979 return FALSE;
5980 }
5981 }
5982 if (writing)
5983 {
5984 bfd_byte *p = htab->sfpr->contents + htab->sfpr->size;
5985 if (i != parm->hi)
5986 p = (*parm->write_ent) (htab->elf.dynobj, p, i);
5987 else
5988 p = (*parm->write_tail) (htab->elf.dynobj, p, i);
5989 htab->sfpr->size = p - htab->sfpr->contents;
5990 }
5991 }
5992
5993 return TRUE;
5994 }
5995
5996 static bfd_byte *
5997 savegpr0 (bfd *abfd, bfd_byte *p, int r)
5998 {
5999 bfd_put_32 (abfd, STD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6000 return p + 4;
6001 }
6002
6003 static bfd_byte *
6004 savegpr0_tail (bfd *abfd, bfd_byte *p, int r)
6005 {
6006 p = savegpr0 (abfd, p, r);
6007 bfd_put_32 (abfd, STD_R0_0R1 + 16, p);
6008 p = p + 4;
6009 bfd_put_32 (abfd, BLR, p);
6010 return p + 4;
6011 }
6012
6013 static bfd_byte *
6014 restgpr0 (bfd *abfd, bfd_byte *p, int r)
6015 {
6016 bfd_put_32 (abfd, LD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6017 return p + 4;
6018 }
6019
6020 static bfd_byte *
6021 restgpr0_tail (bfd *abfd, bfd_byte *p, int r)
6022 {
6023 bfd_put_32 (abfd, LD_R0_0R1 + 16, p);
6024 p = p + 4;
6025 p = restgpr0 (abfd, p, r);
6026 bfd_put_32 (abfd, MTLR_R0, p);
6027 p = p + 4;
6028 if (r == 29)
6029 {
6030 p = restgpr0 (abfd, p, 30);
6031 p = restgpr0 (abfd, p, 31);
6032 }
6033 bfd_put_32 (abfd, BLR, p);
6034 return p + 4;
6035 }
6036
6037 static bfd_byte *
6038 savegpr1 (bfd *abfd, bfd_byte *p, int r)
6039 {
6040 bfd_put_32 (abfd, STD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6041 return p + 4;
6042 }
6043
6044 static bfd_byte *
6045 savegpr1_tail (bfd *abfd, bfd_byte *p, int r)
6046 {
6047 p = savegpr1 (abfd, p, r);
6048 bfd_put_32 (abfd, BLR, p);
6049 return p + 4;
6050 }
6051
6052 static bfd_byte *
6053 restgpr1 (bfd *abfd, bfd_byte *p, int r)
6054 {
6055 bfd_put_32 (abfd, LD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6056 return p + 4;
6057 }
6058
6059 static bfd_byte *
6060 restgpr1_tail (bfd *abfd, bfd_byte *p, int r)
6061 {
6062 p = restgpr1 (abfd, p, r);
6063 bfd_put_32 (abfd, BLR, p);
6064 return p + 4;
6065 }
6066
6067 static bfd_byte *
6068 savefpr (bfd *abfd, bfd_byte *p, int r)
6069 {
6070 bfd_put_32 (abfd, STFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6071 return p + 4;
6072 }
6073
6074 static bfd_byte *
6075 savefpr0_tail (bfd *abfd, bfd_byte *p, int r)
6076 {
6077 p = savefpr (abfd, p, r);
6078 bfd_put_32 (abfd, STD_R0_0R1 + 16, p);
6079 p = p + 4;
6080 bfd_put_32 (abfd, BLR, p);
6081 return p + 4;
6082 }
6083
6084 static bfd_byte *
6085 restfpr (bfd *abfd, bfd_byte *p, int r)
6086 {
6087 bfd_put_32 (abfd, LFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6088 return p + 4;
6089 }
6090
6091 static bfd_byte *
6092 restfpr0_tail (bfd *abfd, bfd_byte *p, int r)
6093 {
6094 bfd_put_32 (abfd, LD_R0_0R1 + 16, p);
6095 p = p + 4;
6096 p = restfpr (abfd, p, r);
6097 bfd_put_32 (abfd, MTLR_R0, p);
6098 p = p + 4;
6099 if (r == 29)
6100 {
6101 p = restfpr (abfd, p, 30);
6102 p = restfpr (abfd, p, 31);
6103 }
6104 bfd_put_32 (abfd, BLR, p);
6105 return p + 4;
6106 }
6107
6108 static bfd_byte *
6109 savefpr1_tail (bfd *abfd, bfd_byte *p, int r)
6110 {
6111 p = savefpr (abfd, p, r);
6112 bfd_put_32 (abfd, BLR, p);
6113 return p + 4;
6114 }
6115
6116 static bfd_byte *
6117 restfpr1_tail (bfd *abfd, bfd_byte *p, int r)
6118 {
6119 p = restfpr (abfd, p, r);
6120 bfd_put_32 (abfd, BLR, p);
6121 return p + 4;
6122 }
6123
6124 static bfd_byte *
6125 savevr (bfd *abfd, bfd_byte *p, int r)
6126 {
6127 bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6128 p = p + 4;
6129 bfd_put_32 (abfd, STVX_VR0_R12_R0 + (r << 21), p);
6130 return p + 4;
6131 }
6132
6133 static bfd_byte *
6134 savevr_tail (bfd *abfd, bfd_byte *p, int r)
6135 {
6136 p = savevr (abfd, p, r);
6137 bfd_put_32 (abfd, BLR, p);
6138 return p + 4;
6139 }
6140
6141 static bfd_byte *
6142 restvr (bfd *abfd, bfd_byte *p, int r)
6143 {
6144 bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6145 p = p + 4;
6146 bfd_put_32 (abfd, LVX_VR0_R12_R0 + (r << 21), p);
6147 return p + 4;
6148 }
6149
6150 static bfd_byte *
6151 restvr_tail (bfd *abfd, bfd_byte *p, int r)
6152 {
6153 p = restvr (abfd, p, r);
6154 bfd_put_32 (abfd, BLR, p);
6155 return p + 4;
6156 }
6157
6158 /* Called via elf_link_hash_traverse to transfer dynamic linking
6159 information on function code symbol entries to their corresponding
6160 function descriptor symbol entries. */
6161
6162 static bfd_boolean
6163 func_desc_adjust (struct elf_link_hash_entry *h, void *inf)
6164 {
6165 struct bfd_link_info *info;
6166 struct ppc_link_hash_table *htab;
6167 struct plt_entry *ent;
6168 struct ppc_link_hash_entry *fh;
6169 struct ppc_link_hash_entry *fdh;
6170 bfd_boolean force_local;
6171
6172 fh = (struct ppc_link_hash_entry *) h;
6173 if (fh->elf.root.type == bfd_link_hash_indirect)
6174 return TRUE;
6175
6176 if (fh->elf.root.type == bfd_link_hash_warning)
6177 fh = (struct ppc_link_hash_entry *) fh->elf.root.u.i.link;
6178
6179 info = inf;
6180 htab = ppc_hash_table (info);
6181 if (htab == NULL)
6182 return FALSE;
6183
6184 /* Resolve undefined references to dot-symbols as the value
6185 in the function descriptor, if we have one in a regular object.
6186 This is to satisfy cases like ".quad .foo". Calls to functions
6187 in dynamic objects are handled elsewhere. */
6188 if (fh->elf.root.type == bfd_link_hash_undefweak
6189 && fh->was_undefined
6190 && (fdh = defined_func_desc (fh)) != NULL
6191 && get_opd_info (fdh->elf.root.u.def.section) != NULL
6192 && opd_entry_value (fdh->elf.root.u.def.section,
6193 fdh->elf.root.u.def.value,
6194 &fh->elf.root.u.def.section,
6195 &fh->elf.root.u.def.value) != (bfd_vma) -1)
6196 {
6197 fh->elf.root.type = fdh->elf.root.type;
6198 fh->elf.forced_local = 1;
6199 fh->elf.def_regular = fdh->elf.def_regular;
6200 fh->elf.def_dynamic = fdh->elf.def_dynamic;
6201 }
6202
6203 /* If this is a function code symbol, transfer dynamic linking
6204 information to the function descriptor symbol. */
6205 if (!fh->is_func)
6206 return TRUE;
6207
6208 for (ent = fh->elf.plt.plist; ent != NULL; ent = ent->next)
6209 if (ent->plt.refcount > 0)
6210 break;
6211 if (ent == NULL
6212 || fh->elf.root.root.string[0] != '.'
6213 || fh->elf.root.root.string[1] == '\0')
6214 return TRUE;
6215
6216 /* Find the corresponding function descriptor symbol. Create it
6217 as undefined if necessary. */
6218
6219 fdh = lookup_fdh (fh, htab);
6220 if (fdh == NULL
6221 && !info->executable
6222 && (fh->elf.root.type == bfd_link_hash_undefined
6223 || fh->elf.root.type == bfd_link_hash_undefweak))
6224 {
6225 fdh = make_fdh (info, fh);
6226 if (fdh == NULL)
6227 return FALSE;
6228 }
6229
6230 /* Fake function descriptors are made undefweak. If the function
6231 code symbol is strong undefined, make the fake sym the same.
6232 If the function code symbol is defined, then force the fake
6233 descriptor local; We can't support overriding of symbols in a
6234 shared library on a fake descriptor. */
6235
6236 if (fdh != NULL
6237 && fdh->fake
6238 && fdh->elf.root.type == bfd_link_hash_undefweak)
6239 {
6240 if (fh->elf.root.type == bfd_link_hash_undefined)
6241 {
6242 fdh->elf.root.type = bfd_link_hash_undefined;
6243 bfd_link_add_undef (&htab->elf.root, &fdh->elf.root);
6244 }
6245 else if (fh->elf.root.type == bfd_link_hash_defined
6246 || fh->elf.root.type == bfd_link_hash_defweak)
6247 {
6248 _bfd_elf_link_hash_hide_symbol (info, &fdh->elf, TRUE);
6249 }
6250 }
6251
6252 if (fdh != NULL
6253 && !fdh->elf.forced_local
6254 && (!info->executable
6255 || fdh->elf.def_dynamic
6256 || fdh->elf.ref_dynamic
6257 || (fdh->elf.root.type == bfd_link_hash_undefweak
6258 && ELF_ST_VISIBILITY (fdh->elf.other) == STV_DEFAULT)))
6259 {
6260 if (fdh->elf.dynindx == -1)
6261 if (! bfd_elf_link_record_dynamic_symbol (info, &fdh->elf))
6262 return FALSE;
6263 fdh->elf.ref_regular |= fh->elf.ref_regular;
6264 fdh->elf.ref_dynamic |= fh->elf.ref_dynamic;
6265 fdh->elf.ref_regular_nonweak |= fh->elf.ref_regular_nonweak;
6266 fdh->elf.non_got_ref |= fh->elf.non_got_ref;
6267 if (ELF_ST_VISIBILITY (fh->elf.other) == STV_DEFAULT)
6268 {
6269 move_plt_plist (fh, fdh);
6270 fdh->elf.needs_plt = 1;
6271 }
6272 fdh->is_func_descriptor = 1;
6273 fdh->oh = fh;
6274 fh->oh = fdh;
6275 }
6276
6277 /* Now that the info is on the function descriptor, clear the
6278 function code sym info. Any function code syms for which we
6279 don't have a definition in a regular file, we force local.
6280 This prevents a shared library from exporting syms that have
6281 been imported from another library. Function code syms that
6282 are really in the library we must leave global to prevent the
6283 linker dragging in a definition from a static library. */
6284 force_local = (!fh->elf.def_regular
6285 || fdh == NULL
6286 || !fdh->elf.def_regular
6287 || fdh->elf.forced_local);
6288 _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
6289
6290 return TRUE;
6291 }
6292
6293 /* Called near the start of bfd_elf_size_dynamic_sections. We use
6294 this hook to a) provide some gcc support functions, and b) transfer
6295 dynamic linking information gathered so far on function code symbol
6296 entries, to their corresponding function descriptor symbol entries. */
6297
6298 static bfd_boolean
6299 ppc64_elf_func_desc_adjust (bfd *obfd ATTRIBUTE_UNUSED,
6300 struct bfd_link_info *info)
6301 {
6302 struct ppc_link_hash_table *htab;
6303 unsigned int i;
6304 const struct sfpr_def_parms funcs[] =
6305 {
6306 { "_savegpr0_", 14, 31, savegpr0, savegpr0_tail },
6307 { "_restgpr0_", 14, 29, restgpr0, restgpr0_tail },
6308 { "_restgpr0_", 30, 31, restgpr0, restgpr0_tail },
6309 { "_savegpr1_", 14, 31, savegpr1, savegpr1_tail },
6310 { "_restgpr1_", 14, 31, restgpr1, restgpr1_tail },
6311 { "_savefpr_", 14, 31, savefpr, savefpr0_tail },
6312 { "_restfpr_", 14, 29, restfpr, restfpr0_tail },
6313 { "_restfpr_", 30, 31, restfpr, restfpr0_tail },
6314 { "._savef", 14, 31, savefpr, savefpr1_tail },
6315 { "._restf", 14, 31, restfpr, restfpr1_tail },
6316 { "_savevr_", 20, 31, savevr, savevr_tail },
6317 { "_restvr_", 20, 31, restvr, restvr_tail }
6318 };
6319
6320 htab = ppc_hash_table (info);
6321 if (htab == NULL)
6322 return FALSE;
6323
6324 if (htab->sfpr == NULL)
6325 /* We don't have any relocs. */
6326 return TRUE;
6327
6328 /* Provide any missing _save* and _rest* functions. */
6329 htab->sfpr->size = 0;
6330 for (i = 0; i < sizeof (funcs) / sizeof (funcs[0]); i++)
6331 if (!sfpr_define (info, &funcs[i]))
6332 return FALSE;
6333
6334 elf_link_hash_traverse (&htab->elf, func_desc_adjust, info);
6335
6336 if (htab->sfpr->size == 0)
6337 htab->sfpr->flags |= SEC_EXCLUDE;
6338
6339 return TRUE;
6340 }
6341
6342 /* Adjust a symbol defined by a dynamic object and referenced by a
6343 regular object. The current definition is in some section of the
6344 dynamic object, but we're not including those sections. We have to
6345 change the definition to something the rest of the link can
6346 understand. */
6347
6348 static bfd_boolean
6349 ppc64_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
6350 struct elf_link_hash_entry *h)
6351 {
6352 struct ppc_link_hash_table *htab;
6353 asection *s;
6354
6355 htab = ppc_hash_table (info);
6356 if (htab == NULL)
6357 return FALSE;
6358
6359 /* Deal with function syms. */
6360 if (h->type == STT_FUNC
6361 || h->type == STT_GNU_IFUNC
6362 || h->needs_plt)
6363 {
6364 /* Clear procedure linkage table information for any symbol that
6365 won't need a .plt entry. */
6366 struct plt_entry *ent;
6367 for (ent = h->plt.plist; ent != NULL; ent = ent->next)
6368 if (ent->plt.refcount > 0)
6369 break;
6370 if (ent == NULL
6371 || (h->type != STT_GNU_IFUNC
6372 && (SYMBOL_CALLS_LOCAL (info, h)
6373 || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
6374 && h->root.type == bfd_link_hash_undefweak))))
6375 {
6376 h->plt.plist = NULL;
6377 h->needs_plt = 0;
6378 }
6379 }
6380 else
6381 h->plt.plist = NULL;
6382
6383 /* If this is a weak symbol, and there is a real definition, the
6384 processor independent code will have arranged for us to see the
6385 real definition first, and we can just use the same value. */
6386 if (h->u.weakdef != NULL)
6387 {
6388 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
6389 || h->u.weakdef->root.type == bfd_link_hash_defweak);
6390 h->root.u.def.section = h->u.weakdef->root.u.def.section;
6391 h->root.u.def.value = h->u.weakdef->root.u.def.value;
6392 if (ELIMINATE_COPY_RELOCS)
6393 h->non_got_ref = h->u.weakdef->non_got_ref;
6394 return TRUE;
6395 }
6396
6397 /* If we are creating a shared library, we must presume that the
6398 only references to the symbol are via the global offset table.
6399 For such cases we need not do anything here; the relocations will
6400 be handled correctly by relocate_section. */
6401 if (info->shared)
6402 return TRUE;
6403
6404 /* If there are no references to this symbol that do not use the
6405 GOT, we don't need to generate a copy reloc. */
6406 if (!h->non_got_ref)
6407 return TRUE;
6408
6409 /* Don't generate a copy reloc for symbols defined in the executable. */
6410 if (!h->def_dynamic || !h->ref_regular || h->def_regular)
6411 return TRUE;
6412
6413 if (ELIMINATE_COPY_RELOCS)
6414 {
6415 struct ppc_link_hash_entry * eh;
6416 struct ppc_dyn_relocs *p;
6417
6418 eh = (struct ppc_link_hash_entry *) h;
6419 for (p = eh->dyn_relocs; p != NULL; p = p->next)
6420 {
6421 s = p->sec->output_section;
6422 if (s != NULL && (s->flags & SEC_READONLY) != 0)
6423 break;
6424 }
6425
6426 /* If we didn't find any dynamic relocs in read-only sections, then
6427 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
6428 if (p == NULL)
6429 {
6430 h->non_got_ref = 0;
6431 return TRUE;
6432 }
6433 }
6434
6435 if (h->plt.plist != NULL)
6436 {
6437 /* We should never get here, but unfortunately there are versions
6438 of gcc out there that improperly (for this ABI) put initialized
6439 function pointers, vtable refs and suchlike in read-only
6440 sections. Allow them to proceed, but warn that this might
6441 break at runtime. */
6442 (*_bfd_error_handler)
6443 (_("copy reloc against `%s' requires lazy plt linking; "
6444 "avoid setting LD_BIND_NOW=1 or upgrade gcc"),
6445 h->root.root.string);
6446 }
6447
6448 /* This is a reference to a symbol defined by a dynamic object which
6449 is not a function. */
6450
6451 if (h->size == 0)
6452 {
6453 (*_bfd_error_handler) (_("dynamic variable `%s' is zero size"),
6454 h->root.root.string);
6455 return TRUE;
6456 }
6457
6458 /* We must allocate the symbol in our .dynbss section, which will
6459 become part of the .bss section of the executable. There will be
6460 an entry for this symbol in the .dynsym section. The dynamic
6461 object will contain position independent code, so all references
6462 from the dynamic object to this symbol will go through the global
6463 offset table. The dynamic linker will use the .dynsym entry to
6464 determine the address it must put in the global offset table, so
6465 both the dynamic object and the regular object will refer to the
6466 same memory location for the variable. */
6467
6468 /* We must generate a R_PPC64_COPY reloc to tell the dynamic linker
6469 to copy the initial value out of the dynamic object and into the
6470 runtime process image. We need to remember the offset into the
6471 .rela.bss section we are going to use. */
6472 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
6473 {
6474 htab->relbss->size += sizeof (Elf64_External_Rela);
6475 h->needs_copy = 1;
6476 }
6477
6478 s = htab->dynbss;
6479
6480 return _bfd_elf_adjust_dynamic_copy (h, s);
6481 }
6482
6483 /* If given a function descriptor symbol, hide both the function code
6484 sym and the descriptor. */
6485 static void
6486 ppc64_elf_hide_symbol (struct bfd_link_info *info,
6487 struct elf_link_hash_entry *h,
6488 bfd_boolean force_local)
6489 {
6490 struct ppc_link_hash_entry *eh;
6491 _bfd_elf_link_hash_hide_symbol (info, h, force_local);
6492
6493 eh = (struct ppc_link_hash_entry *) h;
6494 if (eh->is_func_descriptor)
6495 {
6496 struct ppc_link_hash_entry *fh = eh->oh;
6497
6498 if (fh == NULL)
6499 {
6500 const char *p, *q;
6501 struct ppc_link_hash_table *htab;
6502 char save;
6503
6504 /* We aren't supposed to use alloca in BFD because on
6505 systems which do not have alloca the version in libiberty
6506 calls xmalloc, which might cause the program to crash
6507 when it runs out of memory. This function doesn't have a
6508 return status, so there's no way to gracefully return an
6509 error. So cheat. We know that string[-1] can be safely
6510 accessed; It's either a string in an ELF string table,
6511 or allocated in an objalloc structure. */
6512
6513 p = eh->elf.root.root.string - 1;
6514 save = *p;
6515 *(char *) p = '.';
6516 htab = ppc_hash_table (info);
6517 if (htab == NULL)
6518 return;
6519
6520 fh = (struct ppc_link_hash_entry *)
6521 elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
6522 *(char *) p = save;
6523
6524 /* Unfortunately, if it so happens that the string we were
6525 looking for was allocated immediately before this string,
6526 then we overwrote the string terminator. That's the only
6527 reason the lookup should fail. */
6528 if (fh == NULL)
6529 {
6530 q = eh->elf.root.root.string + strlen (eh->elf.root.root.string);
6531 while (q >= eh->elf.root.root.string && *q == *p)
6532 --q, --p;
6533 if (q < eh->elf.root.root.string && *p == '.')
6534 fh = (struct ppc_link_hash_entry *)
6535 elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
6536 }
6537 if (fh != NULL)
6538 {
6539 eh->oh = fh;
6540 fh->oh = eh;
6541 }
6542 }
6543 if (fh != NULL)
6544 _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
6545 }
6546 }
6547
6548 static bfd_boolean
6549 get_sym_h (struct elf_link_hash_entry **hp,
6550 Elf_Internal_Sym **symp,
6551 asection **symsecp,
6552 char **tls_maskp,
6553 Elf_Internal_Sym **locsymsp,
6554 unsigned long r_symndx,
6555 bfd *ibfd)
6556 {
6557 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
6558
6559 if (r_symndx >= symtab_hdr->sh_info)
6560 {
6561 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
6562 struct elf_link_hash_entry *h;
6563
6564 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
6565 h = elf_follow_link (h);
6566
6567 if (hp != NULL)
6568 *hp = h;
6569
6570 if (symp != NULL)
6571 *symp = NULL;
6572
6573 if (symsecp != NULL)
6574 {
6575 asection *symsec = NULL;
6576 if (h->root.type == bfd_link_hash_defined
6577 || h->root.type == bfd_link_hash_defweak)
6578 symsec = h->root.u.def.section;
6579 *symsecp = symsec;
6580 }
6581
6582 if (tls_maskp != NULL)
6583 {
6584 struct ppc_link_hash_entry *eh;
6585
6586 eh = (struct ppc_link_hash_entry *) h;
6587 *tls_maskp = &eh->tls_mask;
6588 }
6589 }
6590 else
6591 {
6592 Elf_Internal_Sym *sym;
6593 Elf_Internal_Sym *locsyms = *locsymsp;
6594
6595 if (locsyms == NULL)
6596 {
6597 locsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
6598 if (locsyms == NULL)
6599 locsyms = bfd_elf_get_elf_syms (ibfd, symtab_hdr,
6600 symtab_hdr->sh_info,
6601 0, NULL, NULL, NULL);
6602 if (locsyms == NULL)
6603 return FALSE;
6604 *locsymsp = locsyms;
6605 }
6606 sym = locsyms + r_symndx;
6607
6608 if (hp != NULL)
6609 *hp = NULL;
6610
6611 if (symp != NULL)
6612 *symp = sym;
6613
6614 if (symsecp != NULL)
6615 *symsecp = bfd_section_from_elf_index (ibfd, sym->st_shndx);
6616
6617 if (tls_maskp != NULL)
6618 {
6619 struct got_entry **lgot_ents;
6620 char *tls_mask;
6621
6622 tls_mask = NULL;
6623 lgot_ents = elf_local_got_ents (ibfd);
6624 if (lgot_ents != NULL)
6625 {
6626 struct plt_entry **local_plt = (struct plt_entry **)
6627 (lgot_ents + symtab_hdr->sh_info);
6628 char *lgot_masks = (char *)
6629 (local_plt + symtab_hdr->sh_info);
6630 tls_mask = &lgot_masks[r_symndx];
6631 }
6632 *tls_maskp = tls_mask;
6633 }
6634 }
6635 return TRUE;
6636 }
6637
6638 /* Returns TLS_MASKP for the given REL symbol. Function return is 0 on
6639 error, 2 on a toc GD type suitable for optimization, 3 on a toc LD
6640 type suitable for optimization, and 1 otherwise. */
6641
6642 static int
6643 get_tls_mask (char **tls_maskp,
6644 unsigned long *toc_symndx,
6645 bfd_vma *toc_addend,
6646 Elf_Internal_Sym **locsymsp,
6647 const Elf_Internal_Rela *rel,
6648 bfd *ibfd)
6649 {
6650 unsigned long r_symndx;
6651 int next_r;
6652 struct elf_link_hash_entry *h;
6653 Elf_Internal_Sym *sym;
6654 asection *sec;
6655 bfd_vma off;
6656
6657 r_symndx = ELF64_R_SYM (rel->r_info);
6658 if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
6659 return 0;
6660
6661 if ((*tls_maskp != NULL && **tls_maskp != 0)
6662 || sec == NULL
6663 || ppc64_elf_section_data (sec)->sec_type != sec_toc)
6664 return 1;
6665
6666 /* Look inside a TOC section too. */
6667 if (h != NULL)
6668 {
6669 BFD_ASSERT (h->root.type == bfd_link_hash_defined);
6670 off = h->root.u.def.value;
6671 }
6672 else
6673 off = sym->st_value;
6674 off += rel->r_addend;
6675 BFD_ASSERT (off % 8 == 0);
6676 r_symndx = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8];
6677 next_r = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8 + 1];
6678 if (toc_symndx != NULL)
6679 *toc_symndx = r_symndx;
6680 if (toc_addend != NULL)
6681 *toc_addend = ppc64_elf_section_data (sec)->u.toc.add[off / 8];
6682 if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
6683 return 0;
6684 if ((h == NULL
6685 || ((h->root.type == bfd_link_hash_defined
6686 || h->root.type == bfd_link_hash_defweak)
6687 && !h->def_dynamic))
6688 && (next_r == -1 || next_r == -2))
6689 return 1 - next_r;
6690 return 1;
6691 }
6692
6693 /* Adjust all global syms defined in opd sections. In gcc generated
6694 code for the old ABI, these will already have been done. */
6695
6696 static bfd_boolean
6697 adjust_opd_syms (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
6698 {
6699 struct ppc_link_hash_entry *eh;
6700 asection *sym_sec;
6701 struct _opd_sec_data *opd;
6702
6703 if (h->root.type == bfd_link_hash_indirect)
6704 return TRUE;
6705
6706 if (h->root.type == bfd_link_hash_warning)
6707 h = (struct elf_link_hash_entry *) h->root.u.i.link;
6708
6709 if (h->root.type != bfd_link_hash_defined
6710 && h->root.type != bfd_link_hash_defweak)
6711 return TRUE;
6712
6713 eh = (struct ppc_link_hash_entry *) h;
6714 if (eh->adjust_done)
6715 return TRUE;
6716
6717 sym_sec = eh->elf.root.u.def.section;
6718 opd = get_opd_info (sym_sec);
6719 if (opd != NULL && opd->adjust != NULL)
6720 {
6721 long adjust = opd->adjust[eh->elf.root.u.def.value / 8];
6722 if (adjust == -1)
6723 {
6724 /* This entry has been deleted. */
6725 asection *dsec = ppc64_elf_tdata (sym_sec->owner)->deleted_section;
6726 if (dsec == NULL)
6727 {
6728 for (dsec = sym_sec->owner->sections; dsec; dsec = dsec->next)
6729 if (elf_discarded_section (dsec))
6730 {
6731 ppc64_elf_tdata (sym_sec->owner)->deleted_section = dsec;
6732 break;
6733 }
6734 }
6735 eh->elf.root.u.def.value = 0;
6736 eh->elf.root.u.def.section = dsec;
6737 }
6738 else
6739 eh->elf.root.u.def.value += adjust;
6740 eh->adjust_done = 1;
6741 }
6742 return TRUE;
6743 }
6744
6745 /* Handles decrementing dynamic reloc counts for the reloc specified by
6746 R_INFO in section SEC. If LOCAL_SYMS is NULL, then H and SYM_SEC
6747 have already been determined. */
6748
6749 static bfd_boolean
6750 dec_dynrel_count (bfd_vma r_info,
6751 asection *sec,
6752 struct bfd_link_info *info,
6753 Elf_Internal_Sym **local_syms,
6754 struct elf_link_hash_entry *h,
6755 asection *sym_sec)
6756 {
6757 enum elf_ppc64_reloc_type r_type;
6758 struct ppc_dyn_relocs *p;
6759 struct ppc_dyn_relocs **pp;
6760
6761 /* Can this reloc be dynamic? This switch, and later tests here
6762 should be kept in sync with the code in check_relocs. */
6763 r_type = ELF64_R_TYPE (r_info);
6764 switch (r_type)
6765 {
6766 default:
6767 return TRUE;
6768
6769 case R_PPC64_TPREL16:
6770 case R_PPC64_TPREL16_LO:
6771 case R_PPC64_TPREL16_HI:
6772 case R_PPC64_TPREL16_HA:
6773 case R_PPC64_TPREL16_DS:
6774 case R_PPC64_TPREL16_LO_DS:
6775 case R_PPC64_TPREL16_HIGHER:
6776 case R_PPC64_TPREL16_HIGHERA:
6777 case R_PPC64_TPREL16_HIGHEST:
6778 case R_PPC64_TPREL16_HIGHESTA:
6779 if (!info->shared)
6780 return TRUE;
6781
6782 case R_PPC64_TPREL64:
6783 case R_PPC64_DTPMOD64:
6784 case R_PPC64_DTPREL64:
6785 case R_PPC64_ADDR64:
6786 case R_PPC64_REL30:
6787 case R_PPC64_REL32:
6788 case R_PPC64_REL64:
6789 case R_PPC64_ADDR14:
6790 case R_PPC64_ADDR14_BRNTAKEN:
6791 case R_PPC64_ADDR14_BRTAKEN:
6792 case R_PPC64_ADDR16:
6793 case R_PPC64_ADDR16_DS:
6794 case R_PPC64_ADDR16_HA:
6795 case R_PPC64_ADDR16_HI:
6796 case R_PPC64_ADDR16_HIGHER:
6797 case R_PPC64_ADDR16_HIGHERA:
6798 case R_PPC64_ADDR16_HIGHEST:
6799 case R_PPC64_ADDR16_HIGHESTA:
6800 case R_PPC64_ADDR16_LO:
6801 case R_PPC64_ADDR16_LO_DS:
6802 case R_PPC64_ADDR24:
6803 case R_PPC64_ADDR32:
6804 case R_PPC64_UADDR16:
6805 case R_PPC64_UADDR32:
6806 case R_PPC64_UADDR64:
6807 case R_PPC64_TOC:
6808 break;
6809 }
6810
6811 if (local_syms != NULL)
6812 {
6813 unsigned long r_symndx;
6814 Elf_Internal_Sym *sym;
6815 bfd *ibfd = sec->owner;
6816
6817 r_symndx = ELF64_R_SYM (r_info);
6818 if (!get_sym_h (&h, &sym, &sym_sec, NULL, local_syms, r_symndx, ibfd))
6819 return FALSE;
6820 }
6821
6822 if ((info->shared
6823 && (must_be_dyn_reloc (info, r_type)
6824 || (h != NULL
6825 && (!info->symbolic
6826 || h->root.type == bfd_link_hash_defweak
6827 || !h->def_regular))))
6828 || (ELIMINATE_COPY_RELOCS
6829 && !info->shared
6830 && h != NULL
6831 && (h->root.type == bfd_link_hash_defweak
6832 || !h->def_regular)))
6833 ;
6834 else
6835 return TRUE;
6836
6837 if (h != NULL)
6838 pp = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
6839 else
6840 {
6841 if (sym_sec != NULL)
6842 {
6843 void *vpp = &elf_section_data (sym_sec)->local_dynrel;
6844 pp = (struct ppc_dyn_relocs **) vpp;
6845 }
6846 else
6847 {
6848 void *vpp = &elf_section_data (sec)->local_dynrel;
6849 pp = (struct ppc_dyn_relocs **) vpp;
6850 }
6851
6852 /* elf_gc_sweep may have already removed all dyn relocs associated
6853 with local syms for a given section. Don't report a dynreloc
6854 miscount. */
6855 if (*pp == NULL)
6856 return TRUE;
6857 }
6858
6859 while ((p = *pp) != NULL)
6860 {
6861 if (p->sec == sec)
6862 {
6863 if (!must_be_dyn_reloc (info, r_type))
6864 p->pc_count -= 1;
6865 p->count -= 1;
6866 if (p->count == 0)
6867 *pp = p->next;
6868 return TRUE;
6869 }
6870 pp = &p->next;
6871 }
6872
6873 (*_bfd_error_handler) (_("dynreloc miscount for %B, section %A"),
6874 sec->owner, sec);
6875 bfd_set_error (bfd_error_bad_value);
6876 return FALSE;
6877 }
6878
6879 /* Remove unused Official Procedure Descriptor entries. Currently we
6880 only remove those associated with functions in discarded link-once
6881 sections, or weakly defined functions that have been overridden. It
6882 would be possible to remove many more entries for statically linked
6883 applications. */
6884
6885 bfd_boolean
6886 ppc64_elf_edit_opd (bfd *obfd, struct bfd_link_info *info,
6887 bfd_boolean non_overlapping)
6888 {
6889 bfd *ibfd;
6890 bfd_boolean some_edited = FALSE;
6891 asection *need_pad = NULL;
6892
6893 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
6894 {
6895 asection *sec;
6896 Elf_Internal_Rela *relstart, *rel, *relend;
6897 Elf_Internal_Shdr *symtab_hdr;
6898 Elf_Internal_Sym *local_syms;
6899 struct elf_link_hash_entry **sym_hashes;
6900 bfd_vma offset;
6901 struct _opd_sec_data *opd;
6902 bfd_boolean need_edit, add_aux_fields;
6903 bfd_size_type cnt_16b = 0;
6904
6905 sec = bfd_get_section_by_name (ibfd, ".opd");
6906 if (sec == NULL || sec->size == 0)
6907 continue;
6908
6909 if (sec->sec_info_type == ELF_INFO_TYPE_JUST_SYMS)
6910 continue;
6911
6912 if (sec->output_section == bfd_abs_section_ptr)
6913 continue;
6914
6915 /* Look through the section relocs. */
6916 if ((sec->flags & SEC_RELOC) == 0 || sec->reloc_count == 0)
6917 continue;
6918
6919 local_syms = NULL;
6920 symtab_hdr = &elf_symtab_hdr (ibfd);
6921 sym_hashes = elf_sym_hashes (ibfd);
6922
6923 /* Read the relocations. */
6924 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
6925 info->keep_memory);
6926 if (relstart == NULL)
6927 return FALSE;
6928
6929 /* First run through the relocs to check they are sane, and to
6930 determine whether we need to edit this opd section. */
6931 need_edit = FALSE;
6932 need_pad = sec;
6933 offset = 0;
6934 relend = relstart + sec->reloc_count;
6935 for (rel = relstart; rel < relend; )
6936 {
6937 enum elf_ppc64_reloc_type r_type;
6938 unsigned long r_symndx;
6939 asection *sym_sec;
6940 struct elf_link_hash_entry *h;
6941 Elf_Internal_Sym *sym;
6942
6943 /* .opd contains a regular array of 16 or 24 byte entries. We're
6944 only interested in the reloc pointing to a function entry
6945 point. */
6946 if (rel->r_offset != offset
6947 || rel + 1 >= relend
6948 || (rel + 1)->r_offset != offset + 8)
6949 {
6950 /* If someone messes with .opd alignment then after a
6951 "ld -r" we might have padding in the middle of .opd.
6952 Also, there's nothing to prevent someone putting
6953 something silly in .opd with the assembler. No .opd
6954 optimization for them! */
6955 broken_opd:
6956 (*_bfd_error_handler)
6957 (_("%B: .opd is not a regular array of opd entries"), ibfd);
6958 need_edit = FALSE;
6959 break;
6960 }
6961
6962 if ((r_type = ELF64_R_TYPE (rel->r_info)) != R_PPC64_ADDR64
6963 || (r_type = ELF64_R_TYPE ((rel + 1)->r_info)) != R_PPC64_TOC)
6964 {
6965 (*_bfd_error_handler)
6966 (_("%B: unexpected reloc type %u in .opd section"),
6967 ibfd, r_type);
6968 need_edit = FALSE;
6969 break;
6970 }
6971
6972 r_symndx = ELF64_R_SYM (rel->r_info);
6973 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
6974 r_symndx, ibfd))
6975 goto error_ret;
6976
6977 if (sym_sec == NULL || sym_sec->owner == NULL)
6978 {
6979 const char *sym_name;
6980 if (h != NULL)
6981 sym_name = h->root.root.string;
6982 else
6983 sym_name = bfd_elf_sym_name (ibfd, symtab_hdr, sym,
6984 sym_sec);
6985
6986 (*_bfd_error_handler)
6987 (_("%B: undefined sym `%s' in .opd section"),
6988 ibfd, sym_name);
6989 need_edit = FALSE;
6990 break;
6991 }
6992
6993 /* opd entries are always for functions defined in the
6994 current input bfd. If the symbol isn't defined in the
6995 input bfd, then we won't be using the function in this
6996 bfd; It must be defined in a linkonce section in another
6997 bfd, or is weak. It's also possible that we are
6998 discarding the function due to a linker script /DISCARD/,
6999 which we test for via the output_section. */
7000 if (sym_sec->owner != ibfd
7001 || sym_sec->output_section == bfd_abs_section_ptr)
7002 need_edit = TRUE;
7003
7004 rel += 2;
7005 if (rel == relend
7006 || (rel + 1 == relend && rel->r_offset == offset + 16))
7007 {
7008 if (sec->size == offset + 24)
7009 {
7010 need_pad = NULL;
7011 break;
7012 }
7013 if (rel == relend && sec->size == offset + 16)
7014 {
7015 cnt_16b++;
7016 break;
7017 }
7018 goto broken_opd;
7019 }
7020
7021 if (rel->r_offset == offset + 24)
7022 offset += 24;
7023 else if (rel->r_offset != offset + 16)
7024 goto broken_opd;
7025 else if (rel + 1 < relend
7026 && ELF64_R_TYPE (rel[0].r_info) == R_PPC64_ADDR64
7027 && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOC)
7028 {
7029 offset += 16;
7030 cnt_16b++;
7031 }
7032 else if (rel + 2 < relend
7033 && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_ADDR64
7034 && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_TOC)
7035 {
7036 offset += 24;
7037 rel += 1;
7038 }
7039 else
7040 goto broken_opd;
7041 }
7042
7043 add_aux_fields = non_overlapping && cnt_16b > 0;
7044
7045 if (need_edit || add_aux_fields)
7046 {
7047 Elf_Internal_Rela *write_rel;
7048 bfd_byte *rptr, *wptr;
7049 bfd_byte *new_contents;
7050 bfd_boolean skip;
7051 long opd_ent_size;
7052 bfd_size_type amt;
7053
7054 new_contents = NULL;
7055 amt = sec->size * sizeof (long) / 8;
7056 opd = &ppc64_elf_section_data (sec)->u.opd;
7057 opd->adjust = bfd_zalloc (obfd, amt);
7058 if (opd->adjust == NULL)
7059 return FALSE;
7060 ppc64_elf_section_data (sec)->sec_type = sec_opd;
7061
7062 /* This seems a waste of time as input .opd sections are all
7063 zeros as generated by gcc, but I suppose there's no reason
7064 this will always be so. We might start putting something in
7065 the third word of .opd entries. */
7066 if ((sec->flags & SEC_IN_MEMORY) == 0)
7067 {
7068 bfd_byte *loc;
7069 if (!bfd_malloc_and_get_section (ibfd, sec, &loc))
7070 {
7071 if (loc != NULL)
7072 free (loc);
7073 error_ret:
7074 if (local_syms != NULL
7075 && symtab_hdr->contents != (unsigned char *) local_syms)
7076 free (local_syms);
7077 if (elf_section_data (sec)->relocs != relstart)
7078 free (relstart);
7079 return FALSE;
7080 }
7081 sec->contents = loc;
7082 sec->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
7083 }
7084
7085 elf_section_data (sec)->relocs = relstart;
7086
7087 new_contents = sec->contents;
7088 if (add_aux_fields)
7089 {
7090 new_contents = bfd_malloc (sec->size + cnt_16b * 8);
7091 if (new_contents == NULL)
7092 return FALSE;
7093 need_pad = FALSE;
7094 }
7095 wptr = new_contents;
7096 rptr = sec->contents;
7097
7098 write_rel = relstart;
7099 skip = FALSE;
7100 offset = 0;
7101 opd_ent_size = 0;
7102 for (rel = relstart; rel < relend; rel++)
7103 {
7104 unsigned long r_symndx;
7105 asection *sym_sec;
7106 struct elf_link_hash_entry *h;
7107 Elf_Internal_Sym *sym;
7108
7109 r_symndx = ELF64_R_SYM (rel->r_info);
7110 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7111 r_symndx, ibfd))
7112 goto error_ret;
7113
7114 if (rel->r_offset == offset)
7115 {
7116 struct ppc_link_hash_entry *fdh = NULL;
7117
7118 /* See if the .opd entry is full 24 byte or
7119 16 byte (with fd_aux entry overlapped with next
7120 fd_func). */
7121 opd_ent_size = 24;
7122 if ((rel + 2 == relend && sec->size == offset + 16)
7123 || (rel + 3 < relend
7124 && rel[2].r_offset == offset + 16
7125 && rel[3].r_offset == offset + 24
7126 && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_ADDR64
7127 && ELF64_R_TYPE (rel[3].r_info) == R_PPC64_TOC))
7128 opd_ent_size = 16;
7129
7130 if (h != NULL
7131 && h->root.root.string[0] == '.')
7132 {
7133 struct ppc_link_hash_table *htab;
7134
7135 htab = ppc_hash_table (info);
7136 if (htab != NULL)
7137 fdh = lookup_fdh ((struct ppc_link_hash_entry *) h,
7138 htab);
7139 if (fdh != NULL
7140 && fdh->elf.root.type != bfd_link_hash_defined
7141 && fdh->elf.root.type != bfd_link_hash_defweak)
7142 fdh = NULL;
7143 }
7144
7145 skip = (sym_sec->owner != ibfd
7146 || sym_sec->output_section == bfd_abs_section_ptr);
7147 if (skip)
7148 {
7149 if (fdh != NULL && sym_sec->owner == ibfd)
7150 {
7151 /* Arrange for the function descriptor sym
7152 to be dropped. */
7153 fdh->elf.root.u.def.value = 0;
7154 fdh->elf.root.u.def.section = sym_sec;
7155 }
7156 opd->adjust[rel->r_offset / 8] = -1;
7157 }
7158 else
7159 {
7160 /* We'll be keeping this opd entry. */
7161
7162 if (fdh != NULL)
7163 {
7164 /* Redefine the function descriptor symbol to
7165 this location in the opd section. It is
7166 necessary to update the value here rather
7167 than using an array of adjustments as we do
7168 for local symbols, because various places
7169 in the generic ELF code use the value
7170 stored in u.def.value. */
7171 fdh->elf.root.u.def.value = wptr - new_contents;
7172 fdh->adjust_done = 1;
7173 }
7174
7175 /* Local syms are a bit tricky. We could
7176 tweak them as they can be cached, but
7177 we'd need to look through the local syms
7178 for the function descriptor sym which we
7179 don't have at the moment. So keep an
7180 array of adjustments. */
7181 opd->adjust[rel->r_offset / 8]
7182 = (wptr - new_contents) - (rptr - sec->contents);
7183
7184 if (wptr != rptr)
7185 memcpy (wptr, rptr, opd_ent_size);
7186 wptr += opd_ent_size;
7187 if (add_aux_fields && opd_ent_size == 16)
7188 {
7189 memset (wptr, '\0', 8);
7190 wptr += 8;
7191 }
7192 }
7193 rptr += opd_ent_size;
7194 offset += opd_ent_size;
7195 }
7196
7197 if (skip)
7198 {
7199 if (!NO_OPD_RELOCS
7200 && !info->relocatable
7201 && !dec_dynrel_count (rel->r_info, sec, info,
7202 NULL, h, sym_sec))
7203 goto error_ret;
7204 }
7205 else
7206 {
7207 /* We need to adjust any reloc offsets to point to the
7208 new opd entries. While we're at it, we may as well
7209 remove redundant relocs. */
7210 rel->r_offset += opd->adjust[(offset - opd_ent_size) / 8];
7211 if (write_rel != rel)
7212 memcpy (write_rel, rel, sizeof (*rel));
7213 ++write_rel;
7214 }
7215 }
7216
7217 sec->size = wptr - new_contents;
7218 sec->reloc_count = write_rel - relstart;
7219 if (add_aux_fields)
7220 {
7221 free (sec->contents);
7222 sec->contents = new_contents;
7223 }
7224
7225 /* Fudge the header size too, as this is used later in
7226 elf_bfd_final_link if we are emitting relocs. */
7227 elf_section_data (sec)->rel_hdr.sh_size
7228 = sec->reloc_count * elf_section_data (sec)->rel_hdr.sh_entsize;
7229 BFD_ASSERT (elf_section_data (sec)->rel_hdr2 == NULL);
7230 some_edited = TRUE;
7231 }
7232 else if (elf_section_data (sec)->relocs != relstart)
7233 free (relstart);
7234
7235 if (local_syms != NULL
7236 && symtab_hdr->contents != (unsigned char *) local_syms)
7237 {
7238 if (!info->keep_memory)
7239 free (local_syms);
7240 else
7241 symtab_hdr->contents = (unsigned char *) local_syms;
7242 }
7243 }
7244
7245 if (some_edited)
7246 elf_link_hash_traverse (elf_hash_table (info), adjust_opd_syms, NULL);
7247
7248 /* If we are doing a final link and the last .opd entry is just 16 byte
7249 long, add a 8 byte padding after it. */
7250 if (need_pad != NULL && !info->relocatable)
7251 {
7252 bfd_byte *p;
7253
7254 if ((need_pad->flags & SEC_IN_MEMORY) == 0)
7255 {
7256 BFD_ASSERT (need_pad->size > 0);
7257
7258 p = bfd_malloc (need_pad->size + 8);
7259 if (p == NULL)
7260 return FALSE;
7261
7262 if (! bfd_get_section_contents (need_pad->owner, need_pad,
7263 p, 0, need_pad->size))
7264 return FALSE;
7265
7266 need_pad->contents = p;
7267 need_pad->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
7268 }
7269 else
7270 {
7271 p = bfd_realloc (need_pad->contents, need_pad->size + 8);
7272 if (p == NULL)
7273 return FALSE;
7274
7275 need_pad->contents = p;
7276 }
7277
7278 memset (need_pad->contents + need_pad->size, 0, 8);
7279 need_pad->size += 8;
7280 }
7281
7282 return TRUE;
7283 }
7284
7285 /* Set htab->tls_get_addr and call the generic ELF tls_setup function. */
7286
7287 asection *
7288 ppc64_elf_tls_setup (bfd *obfd,
7289 struct bfd_link_info *info,
7290 int no_tls_get_addr_opt)
7291 {
7292 struct ppc_link_hash_table *htab;
7293
7294 htab = ppc_hash_table (info);
7295 if (htab == NULL)
7296 return NULL;
7297
7298 htab->tls_get_addr = ((struct ppc_link_hash_entry *)
7299 elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
7300 FALSE, FALSE, TRUE));
7301 /* Move dynamic linking info to the function descriptor sym. */
7302 if (htab->tls_get_addr != NULL)
7303 func_desc_adjust (&htab->tls_get_addr->elf, info);
7304 htab->tls_get_addr_fd = ((struct ppc_link_hash_entry *)
7305 elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
7306 FALSE, FALSE, TRUE));
7307 if (!no_tls_get_addr_opt)
7308 {
7309 struct elf_link_hash_entry *opt, *opt_fd, *tga, *tga_fd;
7310
7311 opt = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr_opt",
7312 FALSE, FALSE, TRUE);
7313 if (opt != NULL)
7314 func_desc_adjust (opt, info);
7315 opt_fd = elf_link_hash_lookup (&htab->elf, "__tls_get_addr_opt",
7316 FALSE, FALSE, TRUE);
7317 if (opt_fd != NULL
7318 && (opt_fd->root.type == bfd_link_hash_defined
7319 || opt_fd->root.type == bfd_link_hash_defweak))
7320 {
7321 /* If glibc supports an optimized __tls_get_addr call stub,
7322 signalled by the presence of __tls_get_addr_opt, and we'll
7323 be calling __tls_get_addr via a plt call stub, then
7324 make __tls_get_addr point to __tls_get_addr_opt. */
7325 tga_fd = &htab->tls_get_addr_fd->elf;
7326 if (htab->elf.dynamic_sections_created
7327 && tga_fd != NULL
7328 && (tga_fd->type == STT_FUNC
7329 || tga_fd->needs_plt)
7330 && !(SYMBOL_CALLS_LOCAL (info, tga_fd)
7331 || (ELF_ST_VISIBILITY (tga_fd->other) != STV_DEFAULT
7332 && tga_fd->root.type == bfd_link_hash_undefweak)))
7333 {
7334 struct plt_entry *ent;
7335
7336 for (ent = tga_fd->plt.plist; ent != NULL; ent = ent->next)
7337 if (ent->plt.refcount > 0)
7338 break;
7339 if (ent != NULL)
7340 {
7341 tga_fd->root.type = bfd_link_hash_indirect;
7342 tga_fd->root.u.i.link = &opt_fd->root;
7343 ppc64_elf_copy_indirect_symbol (info, opt_fd, tga_fd);
7344 if (opt_fd->dynindx != -1)
7345 {
7346 /* Use __tls_get_addr_opt in dynamic relocations. */
7347 opt_fd->dynindx = -1;
7348 _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
7349 opt_fd->dynstr_index);
7350 if (!bfd_elf_link_record_dynamic_symbol (info, opt_fd))
7351 return FALSE;
7352 }
7353 htab->tls_get_addr_fd = (struct ppc_link_hash_entry *) opt_fd;
7354 tga = &htab->tls_get_addr->elf;
7355 if (opt != NULL && tga != NULL)
7356 {
7357 tga->root.type = bfd_link_hash_indirect;
7358 tga->root.u.i.link = &opt->root;
7359 ppc64_elf_copy_indirect_symbol (info, opt, tga);
7360 _bfd_elf_link_hash_hide_symbol (info, opt,
7361 tga->forced_local);
7362 htab->tls_get_addr = (struct ppc_link_hash_entry *) opt;
7363 }
7364 htab->tls_get_addr_fd->oh = htab->tls_get_addr;
7365 htab->tls_get_addr_fd->is_func_descriptor = 1;
7366 if (htab->tls_get_addr != NULL)
7367 {
7368 htab->tls_get_addr->oh = htab->tls_get_addr_fd;
7369 htab->tls_get_addr->is_func = 1;
7370 }
7371 }
7372 }
7373 }
7374 else
7375 no_tls_get_addr_opt = TRUE;
7376 }
7377 htab->no_tls_get_addr_opt = no_tls_get_addr_opt;
7378 return _bfd_elf_tls_setup (obfd, info);
7379 }
7380
7381 /* Return TRUE iff REL is a branch reloc with a global symbol matching
7382 HASH1 or HASH2. */
7383
7384 static bfd_boolean
7385 branch_reloc_hash_match (const bfd *ibfd,
7386 const Elf_Internal_Rela *rel,
7387 const struct ppc_link_hash_entry *hash1,
7388 const struct ppc_link_hash_entry *hash2)
7389 {
7390 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
7391 enum elf_ppc64_reloc_type r_type = ELF64_R_TYPE (rel->r_info);
7392 unsigned int r_symndx = ELF64_R_SYM (rel->r_info);
7393
7394 if (r_symndx >= symtab_hdr->sh_info && is_branch_reloc (r_type))
7395 {
7396 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
7397 struct elf_link_hash_entry *h;
7398
7399 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
7400 h = elf_follow_link (h);
7401 if (h == &hash1->elf || h == &hash2->elf)
7402 return TRUE;
7403 }
7404 return FALSE;
7405 }
7406
7407 /* Run through all the TLS relocs looking for optimization
7408 opportunities. The linker has been hacked (see ppc64elf.em) to do
7409 a preliminary section layout so that we know the TLS segment
7410 offsets. We can't optimize earlier because some optimizations need
7411 to know the tp offset, and we need to optimize before allocating
7412 dynamic relocations. */
7413
7414 bfd_boolean
7415 ppc64_elf_tls_optimize (bfd *obfd ATTRIBUTE_UNUSED, struct bfd_link_info *info)
7416 {
7417 bfd *ibfd;
7418 asection *sec;
7419 struct ppc_link_hash_table *htab;
7420 int pass;
7421
7422 if (info->relocatable || !info->executable)
7423 return TRUE;
7424
7425 htab = ppc_hash_table (info);
7426 if (htab == NULL)
7427 return FALSE;
7428
7429 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
7430 {
7431 Elf_Internal_Sym *locsyms = NULL;
7432 asection *toc = bfd_get_section_by_name (ibfd, ".toc");
7433 unsigned char *toc_ref = NULL;
7434
7435 /* Look at all the sections for this file. Make two passes over
7436 the relocs. On the first pass, mark toc entries involved
7437 with tls relocs, and check that tls relocs involved in
7438 setting up a tls_get_addr call are indeed followed by such a
7439 call. If they are not, exclude them from the optimizations
7440 done on the second pass. */
7441 for (pass = 0; pass < 2; ++pass)
7442 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
7443 if (sec->has_tls_reloc && !bfd_is_abs_section (sec->output_section))
7444 {
7445 Elf_Internal_Rela *relstart, *rel, *relend;
7446
7447 /* Read the relocations. */
7448 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
7449 info->keep_memory);
7450 if (relstart == NULL)
7451 return FALSE;
7452
7453 relend = relstart + sec->reloc_count;
7454 for (rel = relstart; rel < relend; rel++)
7455 {
7456 enum elf_ppc64_reloc_type r_type;
7457 unsigned long r_symndx;
7458 struct elf_link_hash_entry *h;
7459 Elf_Internal_Sym *sym;
7460 asection *sym_sec;
7461 char *tls_mask;
7462 char tls_set, tls_clear, tls_type = 0;
7463 bfd_vma value;
7464 bfd_boolean ok_tprel, is_local;
7465 long toc_ref_index = 0;
7466 int expecting_tls_get_addr = 0;
7467
7468 r_symndx = ELF64_R_SYM (rel->r_info);
7469 if (!get_sym_h (&h, &sym, &sym_sec, &tls_mask, &locsyms,
7470 r_symndx, ibfd))
7471 {
7472 err_free_rel:
7473 if (elf_section_data (sec)->relocs != relstart)
7474 free (relstart);
7475 if (toc_ref != NULL)
7476 free (toc_ref);
7477 if (locsyms != NULL
7478 && (elf_symtab_hdr (ibfd).contents
7479 != (unsigned char *) locsyms))
7480 free (locsyms);
7481 return FALSE;
7482 }
7483
7484 if (h != NULL)
7485 {
7486 if (h->root.type == bfd_link_hash_defined
7487 || h->root.type == bfd_link_hash_defweak)
7488 value = h->root.u.def.value;
7489 else if (h->root.type == bfd_link_hash_undefweak)
7490 value = 0;
7491 else
7492 continue;
7493 }
7494 else
7495 /* Symbols referenced by TLS relocs must be of type
7496 STT_TLS. So no need for .opd local sym adjust. */
7497 value = sym->st_value;
7498
7499 ok_tprel = FALSE;
7500 is_local = FALSE;
7501 if (h == NULL
7502 || !h->def_dynamic)
7503 {
7504 is_local = TRUE;
7505 if (h != NULL
7506 && h->root.type == bfd_link_hash_undefweak)
7507 ok_tprel = TRUE;
7508 else
7509 {
7510 value += sym_sec->output_offset;
7511 value += sym_sec->output_section->vma;
7512 value -= htab->elf.tls_sec->vma;
7513 ok_tprel = (value + TP_OFFSET + ((bfd_vma) 1 << 31)
7514 < (bfd_vma) 1 << 32);
7515 }
7516 }
7517
7518 r_type = ELF64_R_TYPE (rel->r_info);
7519 switch (r_type)
7520 {
7521 case R_PPC64_GOT_TLSLD16:
7522 case R_PPC64_GOT_TLSLD16_LO:
7523 expecting_tls_get_addr = 1;
7524 /* Fall thru */
7525
7526 case R_PPC64_GOT_TLSLD16_HI:
7527 case R_PPC64_GOT_TLSLD16_HA:
7528 /* These relocs should never be against a symbol
7529 defined in a shared lib. Leave them alone if
7530 that turns out to be the case. */
7531 if (!is_local)
7532 continue;
7533
7534 /* LD -> LE */
7535 tls_set = 0;
7536 tls_clear = TLS_LD;
7537 tls_type = TLS_TLS | TLS_LD;
7538 break;
7539
7540 case R_PPC64_GOT_TLSGD16:
7541 case R_PPC64_GOT_TLSGD16_LO:
7542 expecting_tls_get_addr = 1;
7543 /* Fall thru */
7544
7545 case R_PPC64_GOT_TLSGD16_HI:
7546 case R_PPC64_GOT_TLSGD16_HA:
7547 if (ok_tprel)
7548 /* GD -> LE */
7549 tls_set = 0;
7550 else
7551 /* GD -> IE */
7552 tls_set = TLS_TLS | TLS_TPRELGD;
7553 tls_clear = TLS_GD;
7554 tls_type = TLS_TLS | TLS_GD;
7555 break;
7556
7557 case R_PPC64_GOT_TPREL16_DS:
7558 case R_PPC64_GOT_TPREL16_LO_DS:
7559 case R_PPC64_GOT_TPREL16_HI:
7560 case R_PPC64_GOT_TPREL16_HA:
7561 if (ok_tprel)
7562 {
7563 /* IE -> LE */
7564 tls_set = 0;
7565 tls_clear = TLS_TPREL;
7566 tls_type = TLS_TLS | TLS_TPREL;
7567 break;
7568 }
7569 continue;
7570
7571 case R_PPC64_TOC16:
7572 case R_PPC64_TOC16_LO:
7573 case R_PPC64_TLS:
7574 case R_PPC64_TLSGD:
7575 case R_PPC64_TLSLD:
7576 if (sym_sec == NULL || sym_sec != toc)
7577 continue;
7578
7579 /* Mark this toc entry as referenced by a TLS
7580 code sequence. We can do that now in the
7581 case of R_PPC64_TLS, and after checking for
7582 tls_get_addr for the TOC16 relocs. */
7583 if (toc_ref == NULL)
7584 {
7585 toc_ref = bfd_zmalloc (toc->size / 8);
7586 if (toc_ref == NULL)
7587 goto err_free_rel;
7588 }
7589 if (h != NULL)
7590 value = h->root.u.def.value;
7591 else
7592 value = sym->st_value;
7593 value += rel->r_addend;
7594 BFD_ASSERT (value < toc->size && value % 8 == 0);
7595 toc_ref_index = value / 8;
7596 if (r_type == R_PPC64_TLS
7597 || r_type == R_PPC64_TLSGD
7598 || r_type == R_PPC64_TLSLD)
7599 {
7600 toc_ref[toc_ref_index] = 1;
7601 continue;
7602 }
7603
7604 if (pass != 0 && toc_ref[toc_ref_index] == 0)
7605 continue;
7606
7607 tls_set = 0;
7608 tls_clear = 0;
7609 expecting_tls_get_addr = 2;
7610 break;
7611
7612 case R_PPC64_TPREL64:
7613 if (pass == 0
7614 || sec != toc
7615 || toc_ref == NULL
7616 || !toc_ref[rel->r_offset / 8])
7617 continue;
7618 if (ok_tprel)
7619 {
7620 /* IE -> LE */
7621 tls_set = TLS_EXPLICIT;
7622 tls_clear = TLS_TPREL;
7623 break;
7624 }
7625 continue;
7626
7627 case R_PPC64_DTPMOD64:
7628 if (pass == 0
7629 || sec != toc
7630 || toc_ref == NULL
7631 || !toc_ref[rel->r_offset / 8])
7632 continue;
7633 if (rel + 1 < relend
7634 && (rel[1].r_info
7635 == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64))
7636 && rel[1].r_offset == rel->r_offset + 8)
7637 {
7638 if (ok_tprel)
7639 /* GD -> LE */
7640 tls_set = TLS_EXPLICIT | TLS_GD;
7641 else
7642 /* GD -> IE */
7643 tls_set = TLS_EXPLICIT | TLS_GD | TLS_TPRELGD;
7644 tls_clear = TLS_GD;
7645 }
7646 else
7647 {
7648 if (!is_local)
7649 continue;
7650
7651 /* LD -> LE */
7652 tls_set = TLS_EXPLICIT;
7653 tls_clear = TLS_LD;
7654 }
7655 break;
7656
7657 default:
7658 continue;
7659 }
7660
7661 if (pass == 0)
7662 {
7663 if (!expecting_tls_get_addr
7664 || !sec->has_tls_get_addr_call)
7665 continue;
7666
7667 if (rel + 1 < relend
7668 && branch_reloc_hash_match (ibfd, rel + 1,
7669 htab->tls_get_addr,
7670 htab->tls_get_addr_fd))
7671 {
7672 if (expecting_tls_get_addr == 2)
7673 {
7674 /* Check for toc tls entries. */
7675 char *toc_tls;
7676 int retval;
7677
7678 retval = get_tls_mask (&toc_tls, NULL, NULL,
7679 &locsyms,
7680 rel, ibfd);
7681 if (retval == 0)
7682 goto err_free_rel;
7683 if (retval > 1 && toc_tls != NULL)
7684 toc_ref[toc_ref_index] = 1;
7685 }
7686 continue;
7687 }
7688
7689 if (expecting_tls_get_addr != 1)
7690 continue;
7691
7692 /* Uh oh, we didn't find the expected call. We
7693 could just mark this symbol to exclude it
7694 from tls optimization but it's safer to skip
7695 the entire section. */
7696 sec->has_tls_reloc = 0;
7697 break;
7698 }
7699
7700 if (expecting_tls_get_addr && htab->tls_get_addr != NULL)
7701 {
7702 struct plt_entry *ent;
7703 for (ent = htab->tls_get_addr->elf.plt.plist;
7704 ent != NULL;
7705 ent = ent->next)
7706 if (ent->addend == 0)
7707 {
7708 if (ent->plt.refcount > 0)
7709 {
7710 ent->plt.refcount -= 1;
7711 expecting_tls_get_addr = 0;
7712 }
7713 break;
7714 }
7715 }
7716
7717 if (expecting_tls_get_addr && htab->tls_get_addr_fd != NULL)
7718 {
7719 struct plt_entry *ent;
7720 for (ent = htab->tls_get_addr_fd->elf.plt.plist;
7721 ent != NULL;
7722 ent = ent->next)
7723 if (ent->addend == 0)
7724 {
7725 if (ent->plt.refcount > 0)
7726 ent->plt.refcount -= 1;
7727 break;
7728 }
7729 }
7730
7731 if (tls_clear == 0)
7732 continue;
7733
7734 if ((tls_set & TLS_EXPLICIT) == 0)
7735 {
7736 struct got_entry *ent;
7737
7738 /* Adjust got entry for this reloc. */
7739 if (h != NULL)
7740 ent = h->got.glist;
7741 else
7742 ent = elf_local_got_ents (ibfd)[r_symndx];
7743
7744 for (; ent != NULL; ent = ent->next)
7745 if (ent->addend == rel->r_addend
7746 && ent->owner == ibfd
7747 && ent->tls_type == tls_type)
7748 break;
7749 if (ent == NULL)
7750 abort ();
7751
7752 if (tls_set == 0)
7753 {
7754 /* We managed to get rid of a got entry. */
7755 if (ent->got.refcount > 0)
7756 ent->got.refcount -= 1;
7757 }
7758 }
7759 else
7760 {
7761 /* If we got rid of a DTPMOD/DTPREL reloc pair then
7762 we'll lose one or two dyn relocs. */
7763 if (!dec_dynrel_count (rel->r_info, sec, info,
7764 NULL, h, sym_sec))
7765 return FALSE;
7766
7767 if (tls_set == (TLS_EXPLICIT | TLS_GD))
7768 {
7769 if (!dec_dynrel_count ((rel + 1)->r_info, sec, info,
7770 NULL, h, sym_sec))
7771 return FALSE;
7772 }
7773 }
7774
7775 *tls_mask |= tls_set;
7776 *tls_mask &= ~tls_clear;
7777 }
7778
7779 if (elf_section_data (sec)->relocs != relstart)
7780 free (relstart);
7781 }
7782
7783 if (toc_ref != NULL)
7784 free (toc_ref);
7785
7786 if (locsyms != NULL
7787 && (elf_symtab_hdr (ibfd).contents != (unsigned char *) locsyms))
7788 {
7789 if (!info->keep_memory)
7790 free (locsyms);
7791 else
7792 elf_symtab_hdr (ibfd).contents = (unsigned char *) locsyms;
7793 }
7794 }
7795 return TRUE;
7796 }
7797
7798 /* Called via elf_link_hash_traverse from ppc64_elf_edit_toc to adjust
7799 the values of any global symbols in a toc section that has been
7800 edited. Globals in toc sections should be a rarity, so this function
7801 sets a flag if any are found in toc sections other than the one just
7802 edited, so that futher hash table traversals can be avoided. */
7803
7804 struct adjust_toc_info
7805 {
7806 asection *toc;
7807 unsigned long *skip;
7808 bfd_boolean global_toc_syms;
7809 };
7810
7811 static bfd_boolean
7812 adjust_toc_syms (struct elf_link_hash_entry *h, void *inf)
7813 {
7814 struct ppc_link_hash_entry *eh;
7815 struct adjust_toc_info *toc_inf = (struct adjust_toc_info *) inf;
7816
7817 if (h->root.type == bfd_link_hash_indirect)
7818 return TRUE;
7819
7820 if (h->root.type == bfd_link_hash_warning)
7821 h = (struct elf_link_hash_entry *) h->root.u.i.link;
7822
7823 if (h->root.type != bfd_link_hash_defined
7824 && h->root.type != bfd_link_hash_defweak)
7825 return TRUE;
7826
7827 eh = (struct ppc_link_hash_entry *) h;
7828 if (eh->adjust_done)
7829 return TRUE;
7830
7831 if (eh->elf.root.u.def.section == toc_inf->toc)
7832 {
7833 unsigned long skip = toc_inf->skip[eh->elf.root.u.def.value >> 3];
7834 if (skip != (unsigned long) -1)
7835 eh->elf.root.u.def.value -= skip;
7836 else
7837 {
7838 (*_bfd_error_handler)
7839 (_("%s defined in removed toc entry"), eh->elf.root.root.string);
7840 eh->elf.root.u.def.section = &bfd_abs_section;
7841 eh->elf.root.u.def.value = 0;
7842 }
7843 eh->adjust_done = 1;
7844 }
7845 else if (strcmp (eh->elf.root.u.def.section->name, ".toc") == 0)
7846 toc_inf->global_toc_syms = TRUE;
7847
7848 return TRUE;
7849 }
7850
7851 /* Examine all relocs referencing .toc sections in order to remove
7852 unused .toc entries. */
7853
7854 bfd_boolean
7855 ppc64_elf_edit_toc (bfd *obfd ATTRIBUTE_UNUSED, struct bfd_link_info *info)
7856 {
7857 bfd *ibfd;
7858 struct adjust_toc_info toc_inf;
7859
7860 toc_inf.global_toc_syms = TRUE;
7861 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
7862 {
7863 asection *toc, *sec;
7864 Elf_Internal_Shdr *symtab_hdr;
7865 Elf_Internal_Sym *local_syms;
7866 struct elf_link_hash_entry **sym_hashes;
7867 Elf_Internal_Rela *relstart, *rel;
7868 unsigned long *skip, *drop;
7869 unsigned char *used;
7870 unsigned char *keep, last, some_unused;
7871
7872 toc = bfd_get_section_by_name (ibfd, ".toc");
7873 if (toc == NULL
7874 || toc->size == 0
7875 || toc->sec_info_type == ELF_INFO_TYPE_JUST_SYMS
7876 || elf_discarded_section (toc))
7877 continue;
7878
7879 local_syms = NULL;
7880 symtab_hdr = &elf_symtab_hdr (ibfd);
7881 sym_hashes = elf_sym_hashes (ibfd);
7882
7883 /* Look at sections dropped from the final link. */
7884 skip = NULL;
7885 relstart = NULL;
7886 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
7887 {
7888 if (sec->reloc_count == 0
7889 || !elf_discarded_section (sec)
7890 || get_opd_info (sec)
7891 || (sec->flags & SEC_ALLOC) == 0
7892 || (sec->flags & SEC_DEBUGGING) != 0)
7893 continue;
7894
7895 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL, FALSE);
7896 if (relstart == NULL)
7897 goto error_ret;
7898
7899 /* Run through the relocs to see which toc entries might be
7900 unused. */
7901 for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
7902 {
7903 enum elf_ppc64_reloc_type r_type;
7904 unsigned long r_symndx;
7905 asection *sym_sec;
7906 struct elf_link_hash_entry *h;
7907 Elf_Internal_Sym *sym;
7908 bfd_vma val;
7909
7910 r_type = ELF64_R_TYPE (rel->r_info);
7911 switch (r_type)
7912 {
7913 default:
7914 continue;
7915
7916 case R_PPC64_TOC16:
7917 case R_PPC64_TOC16_LO:
7918 case R_PPC64_TOC16_HI:
7919 case R_PPC64_TOC16_HA:
7920 case R_PPC64_TOC16_DS:
7921 case R_PPC64_TOC16_LO_DS:
7922 break;
7923 }
7924
7925 r_symndx = ELF64_R_SYM (rel->r_info);
7926 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7927 r_symndx, ibfd))
7928 goto error_ret;
7929
7930 if (sym_sec != toc)
7931 continue;
7932
7933 if (h != NULL)
7934 val = h->root.u.def.value;
7935 else
7936 val = sym->st_value;
7937 val += rel->r_addend;
7938
7939 if (val >= toc->size)
7940 continue;
7941
7942 /* Anything in the toc ought to be aligned to 8 bytes.
7943 If not, don't mark as unused. */
7944 if (val & 7)
7945 continue;
7946
7947 if (skip == NULL)
7948 {
7949 skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 7) / 8);
7950 if (skip == NULL)
7951 goto error_ret;
7952 }
7953
7954 skip[val >> 3] = 1;
7955 }
7956
7957 if (elf_section_data (sec)->relocs != relstart)
7958 free (relstart);
7959 }
7960
7961 if (skip == NULL)
7962 continue;
7963
7964 used = bfd_zmalloc (sizeof (*used) * (toc->size + 7) / 8);
7965 if (used == NULL)
7966 {
7967 error_ret:
7968 if (local_syms != NULL
7969 && symtab_hdr->contents != (unsigned char *) local_syms)
7970 free (local_syms);
7971 if (sec != NULL
7972 && relstart != NULL
7973 && elf_section_data (sec)->relocs != relstart)
7974 free (relstart);
7975 if (skip != NULL)
7976 free (skip);
7977 return FALSE;
7978 }
7979
7980 /* Now check all kept sections that might reference the toc.
7981 Check the toc itself last. */
7982 for (sec = (ibfd->sections == toc && toc->next ? toc->next
7983 : ibfd->sections);
7984 sec != NULL;
7985 sec = (sec == toc ? NULL
7986 : sec->next == NULL ? toc
7987 : sec->next == toc && toc->next ? toc->next
7988 : sec->next))
7989 {
7990 int repeat;
7991
7992 if (sec->reloc_count == 0
7993 || elf_discarded_section (sec)
7994 || get_opd_info (sec)
7995 || (sec->flags & SEC_ALLOC) == 0
7996 || (sec->flags & SEC_DEBUGGING) != 0)
7997 continue;
7998
7999 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL, TRUE);
8000 if (relstart == NULL)
8001 goto error_ret;
8002
8003 /* Mark toc entries referenced as used. */
8004 repeat = 0;
8005 do
8006 for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
8007 {
8008 enum elf_ppc64_reloc_type r_type;
8009 unsigned long r_symndx;
8010 asection *sym_sec;
8011 struct elf_link_hash_entry *h;
8012 Elf_Internal_Sym *sym;
8013 bfd_vma val;
8014
8015 r_type = ELF64_R_TYPE (rel->r_info);
8016 switch (r_type)
8017 {
8018 case R_PPC64_TOC16:
8019 case R_PPC64_TOC16_LO:
8020 case R_PPC64_TOC16_HI:
8021 case R_PPC64_TOC16_HA:
8022 case R_PPC64_TOC16_DS:
8023 case R_PPC64_TOC16_LO_DS:
8024 /* In case we're taking addresses of toc entries. */
8025 case R_PPC64_ADDR64:
8026 break;
8027
8028 default:
8029 continue;
8030 }
8031
8032 r_symndx = ELF64_R_SYM (rel->r_info);
8033 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8034 r_symndx, ibfd))
8035 {
8036 free (used);
8037 goto error_ret;
8038 }
8039
8040 if (sym_sec != toc)
8041 continue;
8042
8043 if (h != NULL)
8044 val = h->root.u.def.value;
8045 else
8046 val = sym->st_value;
8047 val += rel->r_addend;
8048
8049 if (val >= toc->size)
8050 continue;
8051
8052 /* For the toc section, we only mark as used if
8053 this entry itself isn't unused. */
8054 if (sec == toc
8055 && !used[val >> 3]
8056 && (used[rel->r_offset >> 3]
8057 || !skip[rel->r_offset >> 3]))
8058 /* Do all the relocs again, to catch reference
8059 chains. */
8060 repeat = 1;
8061
8062 used[val >> 3] = 1;
8063 }
8064 while (repeat);
8065 }
8066
8067 /* Merge the used and skip arrays. Assume that TOC
8068 doublewords not appearing as either used or unused belong
8069 to to an entry more than one doubleword in size. */
8070 for (drop = skip, keep = used, last = 0, some_unused = 0;
8071 drop < skip + (toc->size + 7) / 8;
8072 ++drop, ++keep)
8073 {
8074 if (*keep)
8075 {
8076 *drop = 0;
8077 last = 0;
8078 }
8079 else if (*drop)
8080 {
8081 some_unused = 1;
8082 last = 1;
8083 }
8084 else
8085 *drop = last;
8086 }
8087
8088 free (used);
8089
8090 if (some_unused)
8091 {
8092 bfd_byte *contents, *src;
8093 unsigned long off;
8094
8095 /* Shuffle the toc contents, and at the same time convert the
8096 skip array from booleans into offsets. */
8097 if (!bfd_malloc_and_get_section (ibfd, toc, &contents))
8098 goto error_ret;
8099
8100 elf_section_data (toc)->this_hdr.contents = contents;
8101
8102 for (src = contents, off = 0, drop = skip;
8103 src < contents + toc->size;
8104 src += 8, ++drop)
8105 {
8106 if (*drop)
8107 {
8108 *drop = (unsigned long) -1;
8109 off += 8;
8110 }
8111 else if (off != 0)
8112 {
8113 *drop = off;
8114 memcpy (src - off, src, 8);
8115 }
8116 }
8117 toc->rawsize = toc->size;
8118 toc->size = src - contents - off;
8119
8120 if (toc->reloc_count != 0)
8121 {
8122 Elf_Internal_Rela *wrel;
8123 bfd_size_type sz;
8124
8125 /* Read toc relocs. */
8126 relstart = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
8127 TRUE);
8128 if (relstart == NULL)
8129 goto error_ret;
8130
8131 /* Remove unused toc relocs, and adjust those we keep. */
8132 wrel = relstart;
8133 for (rel = relstart; rel < relstart + toc->reloc_count; ++rel)
8134 if (skip[rel->r_offset >> 3] != (unsigned long) -1)
8135 {
8136 wrel->r_offset = rel->r_offset - skip[rel->r_offset >> 3];
8137 wrel->r_info = rel->r_info;
8138 wrel->r_addend = rel->r_addend;
8139 ++wrel;
8140 }
8141 else if (!dec_dynrel_count (rel->r_info, toc, info,
8142 &local_syms, NULL, NULL))
8143 goto error_ret;
8144
8145 toc->reloc_count = wrel - relstart;
8146 sz = elf_section_data (toc)->rel_hdr.sh_entsize;
8147 elf_section_data (toc)->rel_hdr.sh_size = toc->reloc_count * sz;
8148 BFD_ASSERT (elf_section_data (toc)->rel_hdr2 == NULL);
8149 }
8150
8151 /* Adjust addends for relocs against the toc section sym. */
8152 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8153 {
8154 if (sec->reloc_count == 0
8155 || elf_discarded_section (sec))
8156 continue;
8157
8158 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8159 TRUE);
8160 if (relstart == NULL)
8161 goto error_ret;
8162
8163 for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
8164 {
8165 enum elf_ppc64_reloc_type r_type;
8166 unsigned long r_symndx;
8167 asection *sym_sec;
8168 struct elf_link_hash_entry *h;
8169 Elf_Internal_Sym *sym;
8170
8171 r_type = ELF64_R_TYPE (rel->r_info);
8172 switch (r_type)
8173 {
8174 default:
8175 continue;
8176
8177 case R_PPC64_TOC16:
8178 case R_PPC64_TOC16_LO:
8179 case R_PPC64_TOC16_HI:
8180 case R_PPC64_TOC16_HA:
8181 case R_PPC64_TOC16_DS:
8182 case R_PPC64_TOC16_LO_DS:
8183 case R_PPC64_ADDR64:
8184 break;
8185 }
8186
8187 r_symndx = ELF64_R_SYM (rel->r_info);
8188 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8189 r_symndx, ibfd))
8190 goto error_ret;
8191
8192 if (sym_sec != toc || h != NULL || sym->st_value != 0)
8193 continue;
8194
8195 rel->r_addend -= skip[rel->r_addend >> 3];
8196 }
8197 }
8198
8199 /* We shouldn't have local or global symbols defined in the TOC,
8200 but handle them anyway. */
8201 if (local_syms != NULL)
8202 {
8203 Elf_Internal_Sym *sym;
8204
8205 for (sym = local_syms;
8206 sym < local_syms + symtab_hdr->sh_info;
8207 ++sym)
8208 if (sym->st_value != 0
8209 && bfd_section_from_elf_index (ibfd, sym->st_shndx) == toc)
8210 {
8211 if (skip[sym->st_value >> 3] != (unsigned long) -1)
8212 sym->st_value -= skip[sym->st_value >> 3];
8213 else
8214 {
8215 (*_bfd_error_handler)
8216 (_("%s defined in removed toc entry"),
8217 bfd_elf_sym_name (ibfd, symtab_hdr, sym,
8218 NULL));
8219 sym->st_value = 0;
8220 sym->st_shndx = SHN_ABS;
8221 }
8222 symtab_hdr->contents = (unsigned char *) local_syms;
8223 }
8224 }
8225
8226 /* Finally, adjust any global syms defined in the toc. */
8227 if (toc_inf.global_toc_syms)
8228 {
8229 toc_inf.toc = toc;
8230 toc_inf.skip = skip;
8231 toc_inf.global_toc_syms = FALSE;
8232 elf_link_hash_traverse (elf_hash_table (info), adjust_toc_syms,
8233 &toc_inf);
8234 }
8235 }
8236
8237 if (local_syms != NULL
8238 && symtab_hdr->contents != (unsigned char *) local_syms)
8239 {
8240 if (!info->keep_memory)
8241 free (local_syms);
8242 else
8243 symtab_hdr->contents = (unsigned char *) local_syms;
8244 }
8245 free (skip);
8246 }
8247
8248 return TRUE;
8249 }
8250
8251 /* Allocate space for one GOT entry. */
8252
8253 static void
8254 allocate_got (struct elf_link_hash_entry *h,
8255 struct bfd_link_info *info,
8256 struct got_entry *gent)
8257 {
8258 struct ppc_link_hash_table *htab = ppc_hash_table (info);
8259 bfd_boolean dyn;
8260 struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
8261 int entsize = (gent->tls_type & eh->tls_mask & (TLS_GD | TLS_LD)
8262 ? 16 : 8);
8263 int rentsize = (gent->tls_type & eh->tls_mask & TLS_GD
8264 ? 2 : 1) * sizeof (Elf64_External_Rela);
8265 asection *got = ppc64_elf_tdata (gent->owner)->got;
8266
8267 gent->got.offset = got->size;
8268 got->size += entsize;
8269
8270 dyn = htab->elf.dynamic_sections_created;
8271 if ((info->shared
8272 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h))
8273 && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
8274 || h->root.type != bfd_link_hash_undefweak))
8275 {
8276 asection *relgot = ppc64_elf_tdata (gent->owner)->relgot;
8277 relgot->size += rentsize;
8278 }
8279 else if (h->type == STT_GNU_IFUNC)
8280 {
8281 asection *relgot = htab->reliplt;
8282 relgot->size += rentsize;
8283 htab->got_reli_size += rentsize;
8284 }
8285 }
8286
8287 /* Allocate space in .plt, .got and associated reloc sections for
8288 dynamic relocs. */
8289
8290 static bfd_boolean
8291 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
8292 {
8293 struct bfd_link_info *info;
8294 struct ppc_link_hash_table *htab;
8295 asection *s;
8296 struct ppc_link_hash_entry *eh;
8297 struct ppc_dyn_relocs *p;
8298 struct got_entry *gent;
8299
8300 if (h->root.type == bfd_link_hash_indirect)
8301 return TRUE;
8302
8303 if (h->root.type == bfd_link_hash_warning)
8304 h = (struct elf_link_hash_entry *) h->root.u.i.link;
8305
8306 info = (struct bfd_link_info *) inf;
8307 htab = ppc_hash_table (info);
8308 if (htab == NULL)
8309 return FALSE;
8310
8311 if ((htab->elf.dynamic_sections_created
8312 && h->dynindx != -1
8313 && WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info->shared, h))
8314 || h->type == STT_GNU_IFUNC)
8315 {
8316 struct plt_entry *pent;
8317 bfd_boolean doneone = FALSE;
8318 for (pent = h->plt.plist; pent != NULL; pent = pent->next)
8319 if (pent->plt.refcount > 0)
8320 {
8321 if (!htab->elf.dynamic_sections_created
8322 || h->dynindx == -1)
8323 {
8324 s = htab->iplt;
8325 pent->plt.offset = s->size;
8326 s->size += PLT_ENTRY_SIZE;
8327 s = htab->reliplt;
8328 }
8329 else
8330 {
8331 /* If this is the first .plt entry, make room for the special
8332 first entry. */
8333 s = htab->plt;
8334 if (s->size == 0)
8335 s->size += PLT_INITIAL_ENTRY_SIZE;
8336
8337 pent->plt.offset = s->size;
8338
8339 /* Make room for this entry. */
8340 s->size += PLT_ENTRY_SIZE;
8341
8342 /* Make room for the .glink code. */
8343 s = htab->glink;
8344 if (s->size == 0)
8345 s->size += GLINK_CALL_STUB_SIZE;
8346 /* We need bigger stubs past index 32767. */
8347 if (s->size >= GLINK_CALL_STUB_SIZE + 32768*2*4)
8348 s->size += 4;
8349 s->size += 2*4;
8350
8351 /* We also need to make an entry in the .rela.plt section. */
8352 s = htab->relplt;
8353 }
8354 s->size += sizeof (Elf64_External_Rela);
8355 doneone = TRUE;
8356 }
8357 else
8358 pent->plt.offset = (bfd_vma) -1;
8359 if (!doneone)
8360 {
8361 h->plt.plist = NULL;
8362 h->needs_plt = 0;
8363 }
8364 }
8365 else
8366 {
8367 h->plt.plist = NULL;
8368 h->needs_plt = 0;
8369 }
8370
8371 eh = (struct ppc_link_hash_entry *) h;
8372 /* Run through the TLS GD got entries first if we're changing them
8373 to TPREL. */
8374 if ((eh->tls_mask & TLS_TPRELGD) != 0)
8375 for (gent = h->got.glist; gent != NULL; gent = gent->next)
8376 if (gent->got.refcount > 0
8377 && (gent->tls_type & TLS_GD) != 0)
8378 {
8379 /* This was a GD entry that has been converted to TPREL. If
8380 there happens to be a TPREL entry we can use that one. */
8381 struct got_entry *ent;
8382 for (ent = h->got.glist; ent != NULL; ent = ent->next)
8383 if (ent->got.refcount > 0
8384 && (ent->tls_type & TLS_TPREL) != 0
8385 && ent->addend == gent->addend
8386 && ent->owner == gent->owner)
8387 {
8388 gent->got.refcount = 0;
8389 break;
8390 }
8391
8392 /* If not, then we'll be using our own TPREL entry. */
8393 if (gent->got.refcount != 0)
8394 gent->tls_type = TLS_TLS | TLS_TPREL;
8395 }
8396
8397 for (gent = h->got.glist; gent != NULL; gent = gent->next)
8398 if (gent->got.refcount > 0)
8399 {
8400 /* Make sure this symbol is output as a dynamic symbol.
8401 Undefined weak syms won't yet be marked as dynamic,
8402 nor will all TLS symbols. */
8403 if (h->dynindx == -1
8404 && !h->forced_local
8405 && h->type != STT_GNU_IFUNC
8406 && htab->elf.dynamic_sections_created)
8407 {
8408 if (! bfd_elf_link_record_dynamic_symbol (info, h))
8409 return FALSE;
8410 }
8411
8412 if ((gent->tls_type & TLS_LD) != 0
8413 && !h->def_dynamic)
8414 {
8415 ppc64_tlsld_got (gent->owner)->got.refcount += 1;
8416 gent->got.offset = (bfd_vma) -1;
8417 continue;
8418 }
8419
8420 if (!is_ppc64_elf (gent->owner))
8421 abort ();
8422
8423 allocate_got (h, info, gent);
8424 }
8425 else
8426 gent->got.offset = (bfd_vma) -1;
8427
8428 if (eh->dyn_relocs == NULL
8429 || (!htab->elf.dynamic_sections_created
8430 && h->type != STT_GNU_IFUNC))
8431 return TRUE;
8432
8433 /* In the shared -Bsymbolic case, discard space allocated for
8434 dynamic pc-relative relocs against symbols which turn out to be
8435 defined in regular objects. For the normal shared case, discard
8436 space for relocs that have become local due to symbol visibility
8437 changes. */
8438
8439 if (info->shared)
8440 {
8441 /* Relocs that use pc_count are those that appear on a call insn,
8442 or certain REL relocs (see must_be_dyn_reloc) that can be
8443 generated via assembly. We want calls to protected symbols to
8444 resolve directly to the function rather than going via the plt.
8445 If people want function pointer comparisons to work as expected
8446 then they should avoid writing weird assembly. */
8447 if (SYMBOL_CALLS_LOCAL (info, h))
8448 {
8449 struct ppc_dyn_relocs **pp;
8450
8451 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
8452 {
8453 p->count -= p->pc_count;
8454 p->pc_count = 0;
8455 if (p->count == 0)
8456 *pp = p->next;
8457 else
8458 pp = &p->next;
8459 }
8460 }
8461
8462 /* Also discard relocs on undefined weak syms with non-default
8463 visibility. */
8464 if (eh->dyn_relocs != NULL
8465 && h->root.type == bfd_link_hash_undefweak)
8466 {
8467 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
8468 eh->dyn_relocs = NULL;
8469
8470 /* Make sure this symbol is output as a dynamic symbol.
8471 Undefined weak syms won't yet be marked as dynamic. */
8472 else if (h->dynindx == -1
8473 && !h->forced_local)
8474 {
8475 if (! bfd_elf_link_record_dynamic_symbol (info, h))
8476 return FALSE;
8477 }
8478 }
8479 }
8480 else if (h->type == STT_GNU_IFUNC)
8481 {
8482 if (!h->non_got_ref)
8483 eh->dyn_relocs = NULL;
8484 }
8485 else if (ELIMINATE_COPY_RELOCS)
8486 {
8487 /* For the non-shared case, discard space for relocs against
8488 symbols which turn out to need copy relocs or are not
8489 dynamic. */
8490
8491 if (!h->non_got_ref
8492 && !h->def_regular)
8493 {
8494 /* Make sure this symbol is output as a dynamic symbol.
8495 Undefined weak syms won't yet be marked as dynamic. */
8496 if (h->dynindx == -1
8497 && !h->forced_local)
8498 {
8499 if (! bfd_elf_link_record_dynamic_symbol (info, h))
8500 return FALSE;
8501 }
8502
8503 /* If that succeeded, we know we'll be keeping all the
8504 relocs. */
8505 if (h->dynindx != -1)
8506 goto keep;
8507 }
8508
8509 eh->dyn_relocs = NULL;
8510
8511 keep: ;
8512 }
8513
8514 /* Finally, allocate space. */
8515 for (p = eh->dyn_relocs; p != NULL; p = p->next)
8516 {
8517 asection *sreloc = elf_section_data (p->sec)->sreloc;
8518 if (!htab->elf.dynamic_sections_created)
8519 sreloc = htab->reliplt;
8520 sreloc->size += p->count * sizeof (Elf64_External_Rela);
8521 }
8522
8523 return TRUE;
8524 }
8525
8526 /* Find any dynamic relocs that apply to read-only sections. */
8527
8528 static bfd_boolean
8529 readonly_dynrelocs (struct elf_link_hash_entry *h, void *inf)
8530 {
8531 struct ppc_link_hash_entry *eh;
8532 struct ppc_dyn_relocs *p;
8533
8534 if (h->root.type == bfd_link_hash_warning)
8535 h = (struct elf_link_hash_entry *) h->root.u.i.link;
8536
8537 eh = (struct ppc_link_hash_entry *) h;
8538 for (p = eh->dyn_relocs; p != NULL; p = p->next)
8539 {
8540 asection *s = p->sec->output_section;
8541
8542 if (s != NULL && (s->flags & SEC_READONLY) != 0)
8543 {
8544 struct bfd_link_info *info = inf;
8545
8546 info->flags |= DF_TEXTREL;
8547
8548 /* Not an error, just cut short the traversal. */
8549 return FALSE;
8550 }
8551 }
8552 return TRUE;
8553 }
8554
8555 /* Set the sizes of the dynamic sections. */
8556
8557 static bfd_boolean
8558 ppc64_elf_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
8559 struct bfd_link_info *info)
8560 {
8561 struct ppc_link_hash_table *htab;
8562 bfd *dynobj;
8563 asection *s;
8564 bfd_boolean relocs;
8565 bfd *ibfd;
8566
8567 htab = ppc_hash_table (info);
8568 if (htab == NULL)
8569 return FALSE;
8570
8571 dynobj = htab->elf.dynobj;
8572 if (dynobj == NULL)
8573 abort ();
8574
8575 if (htab->elf.dynamic_sections_created)
8576 {
8577 /* Set the contents of the .interp section to the interpreter. */
8578 if (info->executable)
8579 {
8580 s = bfd_get_section_by_name (dynobj, ".interp");
8581 if (s == NULL)
8582 abort ();
8583 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
8584 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
8585 }
8586 }
8587
8588 /* Set up .got offsets for local syms, and space for local dynamic
8589 relocs. */
8590 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
8591 {
8592 struct got_entry **lgot_ents;
8593 struct got_entry **end_lgot_ents;
8594 struct plt_entry **local_plt;
8595 struct plt_entry **end_local_plt;
8596 char *lgot_masks;
8597 bfd_size_type locsymcount;
8598 Elf_Internal_Shdr *symtab_hdr;
8599 asection *srel;
8600
8601 if (!is_ppc64_elf (ibfd))
8602 continue;
8603
8604 for (s = ibfd->sections; s != NULL; s = s->next)
8605 {
8606 struct ppc_dyn_relocs *p;
8607
8608 for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
8609 {
8610 if (!bfd_is_abs_section (p->sec)
8611 && bfd_is_abs_section (p->sec->output_section))
8612 {
8613 /* Input section has been discarded, either because
8614 it is a copy of a linkonce section or due to
8615 linker script /DISCARD/, so we'll be discarding
8616 the relocs too. */
8617 }
8618 else if (p->count != 0)
8619 {
8620 srel = elf_section_data (p->sec)->sreloc;
8621 if (!htab->elf.dynamic_sections_created)
8622 srel = htab->reliplt;
8623 srel->size += p->count * sizeof (Elf64_External_Rela);
8624 if ((p->sec->output_section->flags & SEC_READONLY) != 0)
8625 info->flags |= DF_TEXTREL;
8626 }
8627 }
8628 }
8629
8630 lgot_ents = elf_local_got_ents (ibfd);
8631 if (!lgot_ents)
8632 continue;
8633
8634 symtab_hdr = &elf_symtab_hdr (ibfd);
8635 locsymcount = symtab_hdr->sh_info;
8636 end_lgot_ents = lgot_ents + locsymcount;
8637 local_plt = (struct plt_entry **) end_lgot_ents;
8638 end_local_plt = local_plt + locsymcount;
8639 lgot_masks = (char *) end_local_plt;
8640 s = ppc64_elf_tdata (ibfd)->got;
8641 srel = ppc64_elf_tdata (ibfd)->relgot;
8642 for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
8643 {
8644 struct got_entry *ent;
8645
8646 for (ent = *lgot_ents; ent != NULL; ent = ent->next)
8647 if (ent->got.refcount > 0)
8648 {
8649 if ((ent->tls_type & *lgot_masks & TLS_LD) != 0)
8650 {
8651 ppc64_tlsld_got (ibfd)->got.refcount += 1;
8652 ent->got.offset = (bfd_vma) -1;
8653 }
8654 else
8655 {
8656 unsigned int num = 1;
8657 ent->got.offset = s->size;
8658 if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
8659 num = 2;
8660 s->size += num * 8;
8661 if (info->shared)
8662 srel->size += num * sizeof (Elf64_External_Rela);
8663 else if ((*lgot_masks & PLT_IFUNC) != 0)
8664 {
8665 htab->reliplt->size
8666 += num * sizeof (Elf64_External_Rela);
8667 htab->got_reli_size
8668 += num * sizeof (Elf64_External_Rela);
8669 }
8670 }
8671 }
8672 else
8673 ent->got.offset = (bfd_vma) -1;
8674 }
8675
8676 /* Allocate space for calls to local STT_GNU_IFUNC syms in .iplt. */
8677 for (; local_plt < end_local_plt; ++local_plt)
8678 {
8679 struct plt_entry *ent;
8680
8681 for (ent = *local_plt; ent != NULL; ent = ent->next)
8682 if (ent->plt.refcount > 0)
8683 {
8684 s = htab->iplt;
8685 ent->plt.offset = s->size;
8686 s->size += PLT_ENTRY_SIZE;
8687
8688 htab->reliplt->size += sizeof (Elf64_External_Rela);
8689 }
8690 else
8691 ent->plt.offset = (bfd_vma) -1;
8692 }
8693 }
8694
8695 /* Allocate global sym .plt and .got entries, and space for global
8696 sym dynamic relocs. */
8697 elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, info);
8698
8699 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
8700 {
8701 if (!is_ppc64_elf (ibfd))
8702 continue;
8703
8704 if (ppc64_tlsld_got (ibfd)->got.refcount > 0)
8705 {
8706 s = ppc64_elf_tdata (ibfd)->got;
8707 ppc64_tlsld_got (ibfd)->got.offset = s->size;
8708 ppc64_tlsld_got (ibfd)->owner = ibfd;
8709 s->size += 16;
8710 if (info->shared)
8711 {
8712 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
8713 srel->size += sizeof (Elf64_External_Rela);
8714 }
8715 }
8716 else
8717 ppc64_tlsld_got (ibfd)->got.offset = (bfd_vma) -1;
8718 }
8719
8720 /* We now have determined the sizes of the various dynamic sections.
8721 Allocate memory for them. */
8722 relocs = FALSE;
8723 for (s = dynobj->sections; s != NULL; s = s->next)
8724 {
8725 if ((s->flags & SEC_LINKER_CREATED) == 0)
8726 continue;
8727
8728 if (s == htab->brlt || s == htab->relbrlt)
8729 /* These haven't been allocated yet; don't strip. */
8730 continue;
8731 else if (s == htab->got
8732 || s == htab->plt
8733 || s == htab->iplt
8734 || s == htab->glink
8735 || s == htab->dynbss)
8736 {
8737 /* Strip this section if we don't need it; see the
8738 comment below. */
8739 }
8740 else if (CONST_STRNEQ (bfd_get_section_name (dynobj, s), ".rela"))
8741 {
8742 if (s->size != 0)
8743 {
8744 if (s != htab->relplt)
8745 relocs = TRUE;
8746
8747 /* We use the reloc_count field as a counter if we need
8748 to copy relocs into the output file. */
8749 s->reloc_count = 0;
8750 }
8751 }
8752 else
8753 {
8754 /* It's not one of our sections, so don't allocate space. */
8755 continue;
8756 }
8757
8758 if (s->size == 0)
8759 {
8760 /* If we don't need this section, strip it from the
8761 output file. This is mostly to handle .rela.bss and
8762 .rela.plt. We must create both sections in
8763 create_dynamic_sections, because they must be created
8764 before the linker maps input sections to output
8765 sections. The linker does that before
8766 adjust_dynamic_symbol is called, and it is that
8767 function which decides whether anything needs to go
8768 into these sections. */
8769 s->flags |= SEC_EXCLUDE;
8770 continue;
8771 }
8772
8773 if ((s->flags & SEC_HAS_CONTENTS) == 0)
8774 continue;
8775
8776 /* Allocate memory for the section contents. We use bfd_zalloc
8777 here in case unused entries are not reclaimed before the
8778 section's contents are written out. This should not happen,
8779 but this way if it does we get a R_PPC64_NONE reloc in .rela
8780 sections instead of garbage.
8781 We also rely on the section contents being zero when writing
8782 the GOT. */
8783 s->contents = bfd_zalloc (dynobj, s->size);
8784 if (s->contents == NULL)
8785 return FALSE;
8786 }
8787
8788 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
8789 {
8790 if (!is_ppc64_elf (ibfd))
8791 continue;
8792
8793 s = ppc64_elf_tdata (ibfd)->got;
8794 if (s != NULL && s != htab->got)
8795 {
8796 if (s->size == 0)
8797 s->flags |= SEC_EXCLUDE;
8798 else
8799 {
8800 s->contents = bfd_zalloc (ibfd, s->size);
8801 if (s->contents == NULL)
8802 return FALSE;
8803 }
8804 }
8805 s = ppc64_elf_tdata (ibfd)->relgot;
8806 if (s != NULL)
8807 {
8808 if (s->size == 0)
8809 s->flags |= SEC_EXCLUDE;
8810 else
8811 {
8812 s->contents = bfd_zalloc (ibfd, s->size);
8813 if (s->contents == NULL)
8814 return FALSE;
8815 relocs = TRUE;
8816 s->reloc_count = 0;
8817 }
8818 }
8819 }
8820
8821 if (htab->elf.dynamic_sections_created)
8822 {
8823 /* Add some entries to the .dynamic section. We fill in the
8824 values later, in ppc64_elf_finish_dynamic_sections, but we
8825 must add the entries now so that we get the correct size for
8826 the .dynamic section. The DT_DEBUG entry is filled in by the
8827 dynamic linker and used by the debugger. */
8828 #define add_dynamic_entry(TAG, VAL) \
8829 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
8830
8831 if (info->executable)
8832 {
8833 if (!add_dynamic_entry (DT_DEBUG, 0))
8834 return FALSE;
8835 }
8836
8837 if (htab->plt != NULL && htab->plt->size != 0)
8838 {
8839 if (!add_dynamic_entry (DT_PLTGOT, 0)
8840 || !add_dynamic_entry (DT_PLTRELSZ, 0)
8841 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
8842 || !add_dynamic_entry (DT_JMPREL, 0)
8843 || !add_dynamic_entry (DT_PPC64_GLINK, 0))
8844 return FALSE;
8845 }
8846
8847 if (NO_OPD_RELOCS)
8848 {
8849 if (!add_dynamic_entry (DT_PPC64_OPD, 0)
8850 || !add_dynamic_entry (DT_PPC64_OPDSZ, 0))
8851 return FALSE;
8852 }
8853
8854 if (!htab->no_tls_get_addr_opt
8855 && htab->tls_get_addr_fd != NULL
8856 && htab->tls_get_addr_fd->elf.plt.plist != NULL
8857 && !add_dynamic_entry (DT_PPC64_TLSOPT, 0))
8858 return FALSE;
8859
8860 if (relocs)
8861 {
8862 if (!add_dynamic_entry (DT_RELA, 0)
8863 || !add_dynamic_entry (DT_RELASZ, 0)
8864 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
8865 return FALSE;
8866
8867 /* If any dynamic relocs apply to a read-only section,
8868 then we need a DT_TEXTREL entry. */
8869 if ((info->flags & DF_TEXTREL) == 0)
8870 elf_link_hash_traverse (&htab->elf, readonly_dynrelocs, info);
8871
8872 if ((info->flags & DF_TEXTREL) != 0)
8873 {
8874 if (!add_dynamic_entry (DT_TEXTREL, 0))
8875 return FALSE;
8876 }
8877 }
8878 }
8879 #undef add_dynamic_entry
8880
8881 return TRUE;
8882 }
8883
8884 /* Determine the type of stub needed, if any, for a call. */
8885
8886 static inline enum ppc_stub_type
8887 ppc_type_of_stub (asection *input_sec,
8888 const Elf_Internal_Rela *rel,
8889 struct ppc_link_hash_entry **hash,
8890 struct plt_entry **plt_ent,
8891 bfd_vma destination)
8892 {
8893 struct ppc_link_hash_entry *h = *hash;
8894 bfd_vma location;
8895 bfd_vma branch_offset;
8896 bfd_vma max_branch_offset;
8897 enum elf_ppc64_reloc_type r_type;
8898
8899 if (h != NULL)
8900 {
8901 struct plt_entry *ent;
8902 struct ppc_link_hash_entry *fdh = h;
8903 if (h->oh != NULL
8904 && h->oh->is_func_descriptor)
8905 fdh = ppc_follow_link (h->oh);
8906
8907 for (ent = fdh->elf.plt.plist; ent != NULL; ent = ent->next)
8908 if (ent->addend == rel->r_addend
8909 && ent->plt.offset != (bfd_vma) -1)
8910 {
8911 *hash = fdh;
8912 *plt_ent = ent;
8913 return ppc_stub_plt_call;
8914 }
8915
8916 /* Here, we know we don't have a plt entry. If we don't have a
8917 either a defined function descriptor or a defined entry symbol
8918 in a regular object file, then it is pointless trying to make
8919 any other type of stub. */
8920 if (!((fdh->elf.root.type == bfd_link_hash_defined
8921 || fdh->elf.root.type == bfd_link_hash_defweak)
8922 && fdh->elf.root.u.def.section->output_section != NULL)
8923 && !((h->elf.root.type == bfd_link_hash_defined
8924 || h->elf.root.type == bfd_link_hash_defweak)
8925 && h->elf.root.u.def.section->output_section != NULL))
8926 return ppc_stub_none;
8927 }
8928 else if (elf_local_got_ents (input_sec->owner) != NULL)
8929 {
8930 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (input_sec->owner);
8931 struct plt_entry **local_plt = (struct plt_entry **)
8932 elf_local_got_ents (input_sec->owner) + symtab_hdr->sh_info;
8933 unsigned long r_symndx = ELF64_R_SYM (rel->r_info);
8934
8935 if (local_plt[r_symndx] != NULL)
8936 {
8937 struct plt_entry *ent;
8938
8939 for (ent = local_plt[r_symndx]; ent != NULL; ent = ent->next)
8940 if (ent->addend == rel->r_addend
8941 && ent->plt.offset != (bfd_vma) -1)
8942 {
8943 *plt_ent = ent;
8944 return ppc_stub_plt_call;
8945 }
8946 }
8947 }
8948
8949 /* Determine where the call point is. */
8950 location = (input_sec->output_offset
8951 + input_sec->output_section->vma
8952 + rel->r_offset);
8953
8954 branch_offset = destination - location;
8955 r_type = ELF64_R_TYPE (rel->r_info);
8956
8957 /* Determine if a long branch stub is needed. */
8958 max_branch_offset = 1 << 25;
8959 if (r_type != R_PPC64_REL24)
8960 max_branch_offset = 1 << 15;
8961
8962 if (branch_offset + max_branch_offset >= 2 * max_branch_offset)
8963 /* We need a stub. Figure out whether a long_branch or plt_branch
8964 is needed later. */
8965 return ppc_stub_long_branch;
8966
8967 return ppc_stub_none;
8968 }
8969
8970 /* Build a .plt call stub. */
8971
8972 static inline bfd_byte *
8973 build_plt_stub (bfd *obfd, bfd_byte *p, int offset, Elf_Internal_Rela *r)
8974 {
8975 #define PPC_LO(v) ((v) & 0xffff)
8976 #define PPC_HI(v) (((v) >> 16) & 0xffff)
8977 #define PPC_HA(v) PPC_HI ((v) + 0x8000)
8978
8979 if (PPC_HA (offset) != 0)
8980 {
8981 if (r != NULL)
8982 {
8983 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
8984 r[1].r_offset = r[0].r_offset + 8;
8985 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
8986 r[1].r_addend = r[0].r_addend;
8987 if (PPC_HA (offset + 16) != PPC_HA (offset))
8988 {
8989 r[2].r_offset = r[1].r_offset + 4;
8990 r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO);
8991 r[2].r_addend = r[0].r_addend;
8992 }
8993 else
8994 {
8995 r[2].r_offset = r[1].r_offset + 8;
8996 r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
8997 r[2].r_addend = r[0].r_addend + 8;
8998 r[3].r_offset = r[2].r_offset + 4;
8999 r[3].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
9000 r[3].r_addend = r[0].r_addend + 16;
9001 }
9002 }
9003 bfd_put_32 (obfd, ADDIS_R12_R2 | PPC_HA (offset), p), p += 4;
9004 bfd_put_32 (obfd, STD_R2_40R1, p), p += 4;
9005 bfd_put_32 (obfd, LD_R11_0R12 | PPC_LO (offset), p), p += 4;
9006 if (PPC_HA (offset + 16) != PPC_HA (offset))
9007 {
9008 bfd_put_32 (obfd, ADDI_R12_R12 | PPC_LO (offset), p), p += 4;
9009 offset = 0;
9010 }
9011 bfd_put_32 (obfd, MTCTR_R11, p), p += 4;
9012 bfd_put_32 (obfd, LD_R2_0R12 | PPC_LO (offset + 8), p), p += 4;
9013 bfd_put_32 (obfd, LD_R11_0R12 | PPC_LO (offset + 16), p), p += 4;
9014 bfd_put_32 (obfd, BCTR, p), p += 4;
9015 }
9016 else
9017 {
9018 if (r != NULL)
9019 {
9020 r[0].r_offset += 4;
9021 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
9022 if (PPC_HA (offset + 16) != PPC_HA (offset))
9023 {
9024 r[1].r_offset = r[0].r_offset + 4;
9025 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16);
9026 r[1].r_addend = r[0].r_addend;
9027 }
9028 else
9029 {
9030 r[1].r_offset = r[0].r_offset + 8;
9031 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
9032 r[1].r_addend = r[0].r_addend + 16;
9033 r[2].r_offset = r[1].r_offset + 4;
9034 r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
9035 r[2].r_addend = r[0].r_addend + 8;
9036 }
9037 }
9038 bfd_put_32 (obfd, STD_R2_40R1, p), p += 4;
9039 bfd_put_32 (obfd, LD_R11_0R2 | PPC_LO (offset), p), p += 4;
9040 if (PPC_HA (offset + 16) != PPC_HA (offset))
9041 {
9042 bfd_put_32 (obfd, ADDI_R2_R2 | PPC_LO (offset), p), p += 4;
9043 offset = 0;
9044 }
9045 bfd_put_32 (obfd, MTCTR_R11, p), p += 4;
9046 bfd_put_32 (obfd, LD_R11_0R2 | PPC_LO (offset + 16), p), p += 4;
9047 bfd_put_32 (obfd, LD_R2_0R2 | PPC_LO (offset + 8), p), p += 4;
9048 bfd_put_32 (obfd, BCTR, p), p += 4;
9049 }
9050 return p;
9051 }
9052
9053 /* Build a special .plt call stub for __tls_get_addr. */
9054
9055 #define LD_R11_0R3 0xe9630000
9056 #define LD_R12_0R3 0xe9830000
9057 #define MR_R0_R3 0x7c601b78
9058 #define CMPDI_R11_0 0x2c2b0000
9059 #define ADD_R3_R12_R13 0x7c6c6a14
9060 #define BEQLR 0x4d820020
9061 #define MR_R3_R0 0x7c030378
9062 #define MFLR_R11 0x7d6802a6
9063 #define STD_R11_0R1 0xf9610000
9064 #define BCTRL 0x4e800421
9065 #define LD_R11_0R1 0xe9610000
9066 #define LD_R2_0R1 0xe8410000
9067 #define MTLR_R11 0x7d6803a6
9068
9069 static inline bfd_byte *
9070 build_tls_get_addr_stub (bfd *obfd, bfd_byte *p, int offset,
9071 Elf_Internal_Rela *r)
9072 {
9073 bfd_put_32 (obfd, LD_R11_0R3 + 0, p), p += 4;
9074 bfd_put_32 (obfd, LD_R12_0R3 + 8, p), p += 4;
9075 bfd_put_32 (obfd, MR_R0_R3, p), p += 4;
9076 bfd_put_32 (obfd, CMPDI_R11_0, p), p += 4;
9077 bfd_put_32 (obfd, ADD_R3_R12_R13, p), p += 4;
9078 bfd_put_32 (obfd, BEQLR, p), p += 4;
9079 bfd_put_32 (obfd, MR_R3_R0, p), p += 4;
9080 bfd_put_32 (obfd, MFLR_R11, p), p += 4;
9081 bfd_put_32 (obfd, STD_R11_0R1 + 32, p), p += 4;
9082
9083 if (r != NULL)
9084 r[0].r_offset += 9 * 4;
9085 p = build_plt_stub (obfd, p, offset, r);
9086 bfd_put_32 (obfd, BCTRL, p - 4);
9087
9088 bfd_put_32 (obfd, LD_R11_0R1 + 32, p), p += 4;
9089 bfd_put_32 (obfd, LD_R2_0R1 + 40, p), p += 4;
9090 bfd_put_32 (obfd, MTLR_R11, p), p += 4;
9091 bfd_put_32 (obfd, BLR, p), p += 4;
9092
9093 return p;
9094 }
9095
9096 static Elf_Internal_Rela *
9097 get_relocs (asection *sec, int count)
9098 {
9099 Elf_Internal_Rela *relocs;
9100 struct bfd_elf_section_data *elfsec_data;
9101
9102 elfsec_data = elf_section_data (sec);
9103 relocs = elfsec_data->relocs;
9104 if (relocs == NULL)
9105 {
9106 bfd_size_type relsize;
9107 relsize = sec->reloc_count * sizeof (*relocs);
9108 relocs = bfd_alloc (sec->owner, relsize);
9109 if (relocs == NULL)
9110 return NULL;
9111 elfsec_data->relocs = relocs;
9112 elfsec_data->rel_hdr.sh_size = (sec->reloc_count
9113 * sizeof (Elf64_External_Rela));
9114 elfsec_data->rel_hdr.sh_entsize = sizeof (Elf64_External_Rela);
9115 sec->reloc_count = 0;
9116 }
9117 relocs += sec->reloc_count;
9118 sec->reloc_count += count;
9119 return relocs;
9120 }
9121
9122 static bfd_boolean
9123 ppc_build_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
9124 {
9125 struct ppc_stub_hash_entry *stub_entry;
9126 struct ppc_branch_hash_entry *br_entry;
9127 struct bfd_link_info *info;
9128 struct ppc_link_hash_table *htab;
9129 bfd_byte *loc;
9130 bfd_byte *p;
9131 bfd_vma dest, off;
9132 int size;
9133 Elf_Internal_Rela *r;
9134 asection *plt;
9135
9136 /* Massage our args to the form they really have. */
9137 stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
9138 info = in_arg;
9139
9140 htab = ppc_hash_table (info);
9141 if (htab == NULL)
9142 return FALSE;
9143
9144 /* Make a note of the offset within the stubs for this entry. */
9145 stub_entry->stub_offset = stub_entry->stub_sec->size;
9146 loc = stub_entry->stub_sec->contents + stub_entry->stub_offset;
9147
9148 htab->stub_count[stub_entry->stub_type - 1] += 1;
9149 switch (stub_entry->stub_type)
9150 {
9151 case ppc_stub_long_branch:
9152 case ppc_stub_long_branch_r2off:
9153 /* Branches are relative. This is where we are going to. */
9154 off = dest = (stub_entry->target_value
9155 + stub_entry->target_section->output_offset
9156 + stub_entry->target_section->output_section->vma);
9157
9158 /* And this is where we are coming from. */
9159 off -= (stub_entry->stub_offset
9160 + stub_entry->stub_sec->output_offset
9161 + stub_entry->stub_sec->output_section->vma);
9162
9163 size = 4;
9164 if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
9165 {
9166 bfd_vma r2off;
9167
9168 r2off = (htab->stub_group[stub_entry->target_section->id].toc_off
9169 - htab->stub_group[stub_entry->id_sec->id].toc_off);
9170 bfd_put_32 (htab->stub_bfd, STD_R2_40R1, loc);
9171 loc += 4;
9172 size = 12;
9173 if (PPC_HA (r2off) != 0)
9174 {
9175 size = 16;
9176 bfd_put_32 (htab->stub_bfd, ADDIS_R2_R2 | PPC_HA (r2off), loc);
9177 loc += 4;
9178 }
9179 bfd_put_32 (htab->stub_bfd, ADDI_R2_R2 | PPC_LO (r2off), loc);
9180 loc += 4;
9181 off -= size - 4;
9182 }
9183 bfd_put_32 (htab->stub_bfd, B_DOT | (off & 0x3fffffc), loc);
9184
9185 if (off + (1 << 25) >= (bfd_vma) (1 << 26))
9186 {
9187 (*_bfd_error_handler) (_("long branch stub `%s' offset overflow"),
9188 stub_entry->root.string);
9189 htab->stub_error = TRUE;
9190 return FALSE;
9191 }
9192
9193 if (info->emitrelocations)
9194 {
9195 r = get_relocs (stub_entry->stub_sec, 1);
9196 if (r == NULL)
9197 return FALSE;
9198 r->r_offset = loc - stub_entry->stub_sec->contents;
9199 r->r_info = ELF64_R_INFO (0, R_PPC64_REL24);
9200 r->r_addend = dest;
9201 if (stub_entry->h != NULL)
9202 {
9203 struct elf_link_hash_entry **hashes;
9204 unsigned long symndx;
9205 struct ppc_link_hash_entry *h;
9206
9207 hashes = elf_sym_hashes (htab->stub_bfd);
9208 if (hashes == NULL)
9209 {
9210 bfd_size_type hsize;
9211
9212 hsize = (htab->stub_globals + 1) * sizeof (*hashes);
9213 hashes = bfd_zalloc (htab->stub_bfd, hsize);
9214 if (hashes == NULL)
9215 return FALSE;
9216 elf_sym_hashes (htab->stub_bfd) = hashes;
9217 htab->stub_globals = 1;
9218 }
9219 symndx = htab->stub_globals++;
9220 h = stub_entry->h;
9221 hashes[symndx] = &h->elf;
9222 r->r_info = ELF64_R_INFO (symndx, R_PPC64_REL24);
9223 if (h->oh != NULL && h->oh->is_func)
9224 h = ppc_follow_link (h->oh);
9225 if (h->elf.root.u.def.section != stub_entry->target_section)
9226 /* H is an opd symbol. The addend must be zero. */
9227 r->r_addend = 0;
9228 else
9229 {
9230 off = (h->elf.root.u.def.value
9231 + h->elf.root.u.def.section->output_offset
9232 + h->elf.root.u.def.section->output_section->vma);
9233 r->r_addend -= off;
9234 }
9235 }
9236 }
9237 break;
9238
9239 case ppc_stub_plt_branch:
9240 case ppc_stub_plt_branch_r2off:
9241 br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
9242 stub_entry->root.string + 9,
9243 FALSE, FALSE);
9244 if (br_entry == NULL)
9245 {
9246 (*_bfd_error_handler) (_("can't find branch stub `%s'"),
9247 stub_entry->root.string);
9248 htab->stub_error = TRUE;
9249 return FALSE;
9250 }
9251
9252 dest = (stub_entry->target_value
9253 + stub_entry->target_section->output_offset
9254 + stub_entry->target_section->output_section->vma);
9255
9256 bfd_put_64 (htab->brlt->owner, dest,
9257 htab->brlt->contents + br_entry->offset);
9258
9259 if (br_entry->iter == htab->stub_iteration)
9260 {
9261 br_entry->iter = 0;
9262
9263 if (htab->relbrlt != NULL)
9264 {
9265 /* Create a reloc for the branch lookup table entry. */
9266 Elf_Internal_Rela rela;
9267 bfd_byte *rl;
9268
9269 rela.r_offset = (br_entry->offset
9270 + htab->brlt->output_offset
9271 + htab->brlt->output_section->vma);
9272 rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
9273 rela.r_addend = dest;
9274
9275 rl = htab->relbrlt->contents;
9276 rl += (htab->relbrlt->reloc_count++
9277 * sizeof (Elf64_External_Rela));
9278 bfd_elf64_swap_reloca_out (htab->relbrlt->owner, &rela, rl);
9279 }
9280 else if (info->emitrelocations)
9281 {
9282 r = get_relocs (htab->brlt, 1);
9283 if (r == NULL)
9284 return FALSE;
9285 /* brlt, being SEC_LINKER_CREATED does not go through the
9286 normal reloc processing. Symbols and offsets are not
9287 translated from input file to output file form, so
9288 set up the offset per the output file. */
9289 r->r_offset = (br_entry->offset
9290 + htab->brlt->output_offset
9291 + htab->brlt->output_section->vma);
9292 r->r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
9293 r->r_addend = dest;
9294 }
9295 }
9296
9297 dest = (br_entry->offset
9298 + htab->brlt->output_offset
9299 + htab->brlt->output_section->vma);
9300
9301 off = (dest
9302 - elf_gp (htab->brlt->output_section->owner)
9303 - htab->stub_group[stub_entry->id_sec->id].toc_off);
9304
9305 if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
9306 {
9307 (*_bfd_error_handler)
9308 (_("linkage table error against `%s'"),
9309 stub_entry->root.string);
9310 bfd_set_error (bfd_error_bad_value);
9311 htab->stub_error = TRUE;
9312 return FALSE;
9313 }
9314
9315 if (info->emitrelocations)
9316 {
9317 r = get_relocs (stub_entry->stub_sec, 1 + (PPC_HA (off) != 0));
9318 if (r == NULL)
9319 return FALSE;
9320 r[0].r_offset = loc - stub_entry->stub_sec->contents;
9321 if (bfd_big_endian (info->output_bfd))
9322 r[0].r_offset += 2;
9323 if (stub_entry->stub_type == ppc_stub_plt_branch_r2off)
9324 r[0].r_offset += 4;
9325 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
9326 r[0].r_addend = dest;
9327 if (PPC_HA (off) != 0)
9328 {
9329 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
9330 r[1].r_offset = r[0].r_offset + 4;
9331 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
9332 r[1].r_addend = r[0].r_addend;
9333 }
9334 }
9335
9336 if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
9337 {
9338 if (PPC_HA (off) != 0)
9339 {
9340 size = 16;
9341 bfd_put_32 (htab->stub_bfd, ADDIS_R12_R2 | PPC_HA (off), loc);
9342 loc += 4;
9343 bfd_put_32 (htab->stub_bfd, LD_R11_0R12 | PPC_LO (off), loc);
9344 }
9345 else
9346 {
9347 size = 12;
9348 bfd_put_32 (htab->stub_bfd, LD_R11_0R2 | PPC_LO (off), loc);
9349 }
9350 }
9351 else
9352 {
9353 bfd_vma r2off;
9354
9355 r2off = (htab->stub_group[stub_entry->target_section->id].toc_off
9356 - htab->stub_group[stub_entry->id_sec->id].toc_off);
9357 bfd_put_32 (htab->stub_bfd, STD_R2_40R1, loc);
9358 loc += 4;
9359 size = 20;
9360 if (PPC_HA (off) != 0)
9361 {
9362 size += 4;
9363 bfd_put_32 (htab->stub_bfd, ADDIS_R12_R2 | PPC_HA (off), loc);
9364 loc += 4;
9365 bfd_put_32 (htab->stub_bfd, LD_R11_0R12 | PPC_LO (off), loc);
9366 loc += 4;
9367 }
9368 else
9369 {
9370 bfd_put_32 (htab->stub_bfd, LD_R11_0R2 | PPC_LO (off), loc);
9371 loc += 4;
9372 }
9373
9374 if (PPC_HA (r2off) != 0)
9375 {
9376 size += 4;
9377 bfd_put_32 (htab->stub_bfd, ADDIS_R2_R2 | PPC_HA (r2off), loc);
9378 loc += 4;
9379 }
9380 bfd_put_32 (htab->stub_bfd, ADDI_R2_R2 | PPC_LO (r2off), loc);
9381 }
9382 loc += 4;
9383 bfd_put_32 (htab->stub_bfd, MTCTR_R11, loc);
9384 loc += 4;
9385 bfd_put_32 (htab->stub_bfd, BCTR, loc);
9386 break;
9387
9388 case ppc_stub_plt_call:
9389 if (stub_entry->h != NULL
9390 && stub_entry->h->is_func_descriptor
9391 && stub_entry->h->oh != NULL)
9392 {
9393 struct ppc_link_hash_entry *fh = ppc_follow_link (stub_entry->h->oh);
9394
9395 /* If the old-ABI "dot-symbol" is undefined make it weak so
9396 we don't get a link error from RELOC_FOR_GLOBAL_SYMBOL.
9397 FIXME: We used to define the symbol on one of the call
9398 stubs instead, which is why we test symbol section id
9399 against htab->top_id in various places. Likely all
9400 these checks could now disappear. */
9401 if (fh->elf.root.type == bfd_link_hash_undefined)
9402 fh->elf.root.type = bfd_link_hash_undefweak;
9403 }
9404
9405 /* Now build the stub. */
9406 dest = stub_entry->plt_ent->plt.offset & ~1;
9407 if (dest >= (bfd_vma) -2)
9408 abort ();
9409
9410 plt = htab->plt;
9411 if (!htab->elf.dynamic_sections_created
9412 || stub_entry->h == NULL
9413 || stub_entry->h->elf.dynindx == -1)
9414 plt = htab->iplt;
9415
9416 dest += plt->output_offset + plt->output_section->vma;
9417
9418 if (stub_entry->h == NULL
9419 && (stub_entry->plt_ent->plt.offset & 1) == 0)
9420 {
9421 Elf_Internal_Rela rela;
9422 bfd_byte *rl;
9423
9424 rela.r_offset = dest;
9425 rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
9426 rela.r_addend = (stub_entry->target_value
9427 + stub_entry->target_section->output_offset
9428 + stub_entry->target_section->output_section->vma);
9429
9430 rl = (htab->reliplt->contents
9431 + (htab->reliplt->reloc_count++
9432 * sizeof (Elf64_External_Rela)));
9433 bfd_elf64_swap_reloca_out (info->output_bfd, &rela, rl);
9434 stub_entry->plt_ent->plt.offset |= 1;
9435 }
9436
9437 off = (dest
9438 - elf_gp (plt->output_section->owner)
9439 - htab->stub_group[stub_entry->id_sec->id].toc_off);
9440
9441 if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
9442 {
9443 (*_bfd_error_handler)
9444 (_("linkage table error against `%s'"),
9445 stub_entry->h != NULL
9446 ? stub_entry->h->elf.root.root.string
9447 : "<local sym>");
9448 bfd_set_error (bfd_error_bad_value);
9449 htab->stub_error = TRUE;
9450 return FALSE;
9451 }
9452
9453 r = NULL;
9454 if (info->emitrelocations)
9455 {
9456 r = get_relocs (stub_entry->stub_sec,
9457 (2 + (PPC_HA (off) != 0)
9458 + (PPC_HA (off + 16) == PPC_HA (off))));
9459 if (r == NULL)
9460 return FALSE;
9461 r[0].r_offset = loc - stub_entry->stub_sec->contents;
9462 if (bfd_big_endian (info->output_bfd))
9463 r[0].r_offset += 2;
9464 r[0].r_addend = dest;
9465 }
9466 if (stub_entry->h != NULL
9467 && (stub_entry->h == htab->tls_get_addr_fd
9468 || stub_entry->h == htab->tls_get_addr)
9469 && !htab->no_tls_get_addr_opt)
9470 p = build_tls_get_addr_stub (htab->stub_bfd, loc, off, r);
9471 else
9472 p = build_plt_stub (htab->stub_bfd, loc, off, r);
9473 size = p - loc;
9474 break;
9475
9476 default:
9477 BFD_FAIL ();
9478 return FALSE;
9479 }
9480
9481 stub_entry->stub_sec->size += size;
9482
9483 if (htab->emit_stub_syms)
9484 {
9485 struct elf_link_hash_entry *h;
9486 size_t len1, len2;
9487 char *name;
9488 const char *const stub_str[] = { "long_branch",
9489 "long_branch_r2off",
9490 "plt_branch",
9491 "plt_branch_r2off",
9492 "plt_call" };
9493
9494 len1 = strlen (stub_str[stub_entry->stub_type - 1]);
9495 len2 = strlen (stub_entry->root.string);
9496 name = bfd_malloc (len1 + len2 + 2);
9497 if (name == NULL)
9498 return FALSE;
9499 memcpy (name, stub_entry->root.string, 9);
9500 memcpy (name + 9, stub_str[stub_entry->stub_type - 1], len1);
9501 memcpy (name + len1 + 9, stub_entry->root.string + 8, len2 - 8 + 1);
9502 h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
9503 if (h == NULL)
9504 return FALSE;
9505 if (h->root.type == bfd_link_hash_new)
9506 {
9507 h->root.type = bfd_link_hash_defined;
9508 h->root.u.def.section = stub_entry->stub_sec;
9509 h->root.u.def.value = stub_entry->stub_offset;
9510 h->ref_regular = 1;
9511 h->def_regular = 1;
9512 h->ref_regular_nonweak = 1;
9513 h->forced_local = 1;
9514 h->non_elf = 0;
9515 }
9516 }
9517
9518 return TRUE;
9519 }
9520
9521 /* As above, but don't actually build the stub. Just bump offset so
9522 we know stub section sizes, and select plt_branch stubs where
9523 long_branch stubs won't do. */
9524
9525 static bfd_boolean
9526 ppc_size_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
9527 {
9528 struct ppc_stub_hash_entry *stub_entry;
9529 struct bfd_link_info *info;
9530 struct ppc_link_hash_table *htab;
9531 bfd_vma off;
9532 int size;
9533
9534 /* Massage our args to the form they really have. */
9535 stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
9536 info = in_arg;
9537
9538 htab = ppc_hash_table (info);
9539 if (htab == NULL)
9540 return FALSE;
9541
9542 if (stub_entry->stub_type == ppc_stub_plt_call)
9543 {
9544 asection *plt;
9545 off = stub_entry->plt_ent->plt.offset & ~(bfd_vma) 1;
9546 if (off >= (bfd_vma) -2)
9547 abort ();
9548 plt = htab->plt;
9549 if (!htab->elf.dynamic_sections_created
9550 || stub_entry->h == NULL
9551 || stub_entry->h->elf.dynindx == -1)
9552 plt = htab->iplt;
9553 off += (plt->output_offset
9554 + plt->output_section->vma
9555 - elf_gp (plt->output_section->owner)
9556 - htab->stub_group[stub_entry->id_sec->id].toc_off);
9557
9558 size = PLT_CALL_STUB_SIZE;
9559 if (PPC_HA (off) == 0)
9560 size -= 4;
9561 if (PPC_HA (off + 16) != PPC_HA (off))
9562 size += 4;
9563 if (stub_entry->h != NULL
9564 && (stub_entry->h == htab->tls_get_addr_fd
9565 || stub_entry->h == htab->tls_get_addr)
9566 && !htab->no_tls_get_addr_opt)
9567 size += 13 * 4;
9568 if (info->emitrelocations)
9569 {
9570 stub_entry->stub_sec->reloc_count
9571 += 2 + (PPC_HA (off) != 0) + (PPC_HA (off + 16) == PPC_HA (off));
9572 stub_entry->stub_sec->flags |= SEC_RELOC;
9573 }
9574 }
9575 else
9576 {
9577 /* ppc_stub_long_branch or ppc_stub_plt_branch, or their r2off
9578 variants. */
9579 bfd_vma r2off = 0;
9580
9581 off = (stub_entry->target_value
9582 + stub_entry->target_section->output_offset
9583 + stub_entry->target_section->output_section->vma);
9584 off -= (stub_entry->stub_sec->size
9585 + stub_entry->stub_sec->output_offset
9586 + stub_entry->stub_sec->output_section->vma);
9587
9588 /* Reset the stub type from the plt variant in case we now
9589 can reach with a shorter stub. */
9590 if (stub_entry->stub_type >= ppc_stub_plt_branch)
9591 stub_entry->stub_type += ppc_stub_long_branch - ppc_stub_plt_branch;
9592
9593 size = 4;
9594 if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
9595 {
9596 r2off = (htab->stub_group[stub_entry->target_section->id].toc_off
9597 - htab->stub_group[stub_entry->id_sec->id].toc_off);
9598 size = 12;
9599 if (PPC_HA (r2off) != 0)
9600 size = 16;
9601 off -= size - 4;
9602 }
9603
9604 /* If the branch offset if too big, use a ppc_stub_plt_branch. */
9605 if (off + (1 << 25) >= (bfd_vma) (1 << 26))
9606 {
9607 struct ppc_branch_hash_entry *br_entry;
9608
9609 br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
9610 stub_entry->root.string + 9,
9611 TRUE, FALSE);
9612 if (br_entry == NULL)
9613 {
9614 (*_bfd_error_handler) (_("can't build branch stub `%s'"),
9615 stub_entry->root.string);
9616 htab->stub_error = TRUE;
9617 return FALSE;
9618 }
9619
9620 if (br_entry->iter != htab->stub_iteration)
9621 {
9622 br_entry->iter = htab->stub_iteration;
9623 br_entry->offset = htab->brlt->size;
9624 htab->brlt->size += 8;
9625
9626 if (htab->relbrlt != NULL)
9627 htab->relbrlt->size += sizeof (Elf64_External_Rela);
9628 else if (info->emitrelocations)
9629 {
9630 htab->brlt->reloc_count += 1;
9631 htab->brlt->flags |= SEC_RELOC;
9632 }
9633 }
9634
9635 stub_entry->stub_type += ppc_stub_plt_branch - ppc_stub_long_branch;
9636 off = (br_entry->offset
9637 + htab->brlt->output_offset
9638 + htab->brlt->output_section->vma
9639 - elf_gp (htab->brlt->output_section->owner)
9640 - htab->stub_group[stub_entry->id_sec->id].toc_off);
9641
9642 if (info->emitrelocations)
9643 {
9644 stub_entry->stub_sec->reloc_count += 1 + (PPC_HA (off) != 0);
9645 stub_entry->stub_sec->flags |= SEC_RELOC;
9646 }
9647
9648 if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
9649 {
9650 size = 12;
9651 if (PPC_HA (off) != 0)
9652 size = 16;
9653 }
9654 else
9655 {
9656 size = 20;
9657 if (PPC_HA (off) != 0)
9658 size += 4;
9659
9660 if (PPC_HA (r2off) != 0)
9661 size += 4;
9662 }
9663 }
9664 else if (info->emitrelocations)
9665 {
9666 stub_entry->stub_sec->reloc_count += 1;
9667 stub_entry->stub_sec->flags |= SEC_RELOC;
9668 }
9669 }
9670
9671 stub_entry->stub_sec->size += size;
9672 return TRUE;
9673 }
9674
9675 /* Set up various things so that we can make a list of input sections
9676 for each output section included in the link. Returns -1 on error,
9677 0 when no stubs will be needed, and 1 on success. */
9678
9679 int
9680 ppc64_elf_setup_section_lists
9681 (struct bfd_link_info *info,
9682 asection *(*add_stub_section) (const char *, asection *),
9683 void (*layout_sections_again) (void))
9684 {
9685 bfd *input_bfd;
9686 int top_id, top_index, id;
9687 asection *section;
9688 asection **input_list;
9689 bfd_size_type amt;
9690 struct ppc_link_hash_table *htab = ppc_hash_table (info);
9691
9692 if (htab == NULL)
9693 return -1;
9694 /* Stash our params away. */
9695 htab->add_stub_section = add_stub_section;
9696 htab->layout_sections_again = layout_sections_again;
9697
9698 if (htab->brlt == NULL)
9699 return 0;
9700
9701 /* Find the top input section id. */
9702 for (input_bfd = info->input_bfds, top_id = 3;
9703 input_bfd != NULL;
9704 input_bfd = input_bfd->link_next)
9705 {
9706 for (section = input_bfd->sections;
9707 section != NULL;
9708 section = section->next)
9709 {
9710 if (top_id < section->id)
9711 top_id = section->id;
9712 }
9713 }
9714
9715 htab->top_id = top_id;
9716 amt = sizeof (struct map_stub) * (top_id + 1);
9717 htab->stub_group = bfd_zmalloc (amt);
9718 if (htab->stub_group == NULL)
9719 return -1;
9720
9721 /* Set toc_off for com, und, abs and ind sections. */
9722 for (id = 0; id < 3; id++)
9723 htab->stub_group[id].toc_off = TOC_BASE_OFF;
9724
9725 /* We can't use output_bfd->section_count here to find the top output
9726 section index as some sections may have been removed, and
9727 strip_excluded_output_sections doesn't renumber the indices. */
9728 for (section = info->output_bfd->sections, top_index = 0;
9729 section != NULL;
9730 section = section->next)
9731 {
9732 if (top_index < section->index)
9733 top_index = section->index;
9734 }
9735
9736 htab->top_index = top_index;
9737 amt = sizeof (asection *) * (top_index + 1);
9738 input_list = bfd_zmalloc (amt);
9739 htab->input_list = input_list;
9740 if (input_list == NULL)
9741 return -1;
9742
9743 return 1;
9744 }
9745
9746 /* Set up for first pass at multitoc partitioning. */
9747
9748 void
9749 ppc64_elf_start_multitoc_partition (struct bfd_link_info *info)
9750 {
9751 struct ppc_link_hash_table *htab = ppc_hash_table (info);
9752
9753 elf_gp (info->output_bfd) = ppc64_elf_toc (info->output_bfd);
9754 htab->toc_curr = elf_gp (info->output_bfd);
9755 htab->toc_bfd = NULL;
9756 htab->toc_first_sec = NULL;
9757 }
9758
9759 /* The linker repeatedly calls this function for each TOC input section
9760 and linker generated GOT section. Group input bfds such that the toc
9761 within a group is less than 64k in size. */
9762
9763 bfd_boolean
9764 ppc64_elf_next_toc_section (struct bfd_link_info *info, asection *isec)
9765 {
9766 struct ppc_link_hash_table *htab = ppc_hash_table (info);
9767 bfd_vma addr, off;
9768
9769 if (htab == NULL)
9770 return FALSE;
9771
9772 if (!htab->second_toc_pass)
9773 {
9774 /* Keep track of the first .toc or .got section for this input bfd. */
9775 if (htab->toc_bfd != isec->owner)
9776 {
9777 htab->toc_bfd = isec->owner;
9778 htab->toc_first_sec = isec;
9779 }
9780
9781 addr = isec->output_offset + isec->output_section->vma;
9782 off = addr - htab->toc_curr;
9783 if (off + isec->size > 0x10000)
9784 {
9785 addr = (htab->toc_first_sec->output_offset
9786 + htab->toc_first_sec->output_section->vma);
9787 htab->toc_curr = addr;
9788 }
9789
9790 /* toc_curr is the base address of this toc group. Set elf_gp
9791 for the input section to be the offset relative to the
9792 output toc base plus 0x8000. Making the input elf_gp an
9793 offset allows us to move the toc as a whole without
9794 recalculating input elf_gp. */
9795 off = htab->toc_curr - elf_gp (isec->output_section->owner);
9796 off += TOC_BASE_OFF;
9797
9798 /* Die if someone uses a linker script that doesn't keep input
9799 file .toc and .got together. */
9800 if (elf_gp (isec->owner) != 0
9801 && elf_gp (isec->owner) != off)
9802 return FALSE;
9803
9804 elf_gp (isec->owner) = off;
9805 return TRUE;
9806 }
9807
9808 /* During the second pass toc_first_sec points to the start of
9809 a toc group, and toc_curr is used to track the old elf_gp.
9810 We use toc_bfd to ensure we only look at each bfd once. */
9811 if (htab->toc_bfd == isec->owner)
9812 return TRUE;
9813 htab->toc_bfd = isec->owner;
9814
9815 if (htab->toc_first_sec == NULL
9816 || htab->toc_curr != elf_gp (isec->owner))
9817 {
9818 htab->toc_curr = elf_gp (isec->owner);
9819 htab->toc_first_sec = isec;
9820 }
9821 addr = (htab->toc_first_sec->output_offset
9822 + htab->toc_first_sec->output_section->vma);
9823 off = addr - elf_gp (isec->output_section->owner) + TOC_BASE_OFF;
9824 elf_gp (isec->owner) = off;
9825
9826 return TRUE;
9827 }
9828
9829 /* This function removes unneeded got entries (those with got.offset == -1)
9830 and merges entries in the same toc group. */
9831
9832 static void
9833 merge_got_entries (struct got_entry **pent)
9834 {
9835 struct got_entry *ent, *ent2;
9836
9837 while ((ent = *pent) != NULL)
9838 {
9839 if (!ent->is_indirect)
9840 {
9841 if (ent->got.offset == (bfd_vma) -1)
9842 {
9843 *pent = ent->next;
9844 continue;
9845 }
9846 for (ent2 = ent->next; ent2 != NULL; ent2 = ent2->next)
9847 if (!ent2->is_indirect
9848 && ent2->got.offset != (bfd_vma) -1
9849 && ent2->addend == ent->addend
9850 && ent2->tls_type == ent->tls_type
9851 && elf_gp (ent2->owner) == elf_gp (ent->owner))
9852 {
9853 ent2->is_indirect = TRUE;
9854 ent2->got.ent = ent;
9855 }
9856 }
9857 pent = &ent->next;
9858 }
9859 }
9860
9861 /* Called via elf_link_hash_traverse to merge GOT entries for global
9862 symbol H. */
9863
9864 static bfd_boolean
9865 merge_global_got (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
9866 {
9867 if (h->root.type == bfd_link_hash_indirect)
9868 return TRUE;
9869
9870 if (h->root.type == bfd_link_hash_warning)
9871 h = (struct elf_link_hash_entry *) h->root.u.i.link;
9872
9873 merge_got_entries (&h->got.glist);
9874
9875 return TRUE;
9876 }
9877
9878 /* Called via elf_link_hash_traverse to allocate GOT entries for global
9879 symbol H. */
9880
9881 static bfd_boolean
9882 reallocate_got (struct elf_link_hash_entry *h, void *inf)
9883 {
9884 struct got_entry *gent;
9885
9886 if (h->root.type == bfd_link_hash_indirect)
9887 return TRUE;
9888
9889 if (h->root.type == bfd_link_hash_warning)
9890 h = (struct elf_link_hash_entry *) h->root.u.i.link;
9891
9892 for (gent = h->got.glist; gent != NULL; gent = gent->next)
9893 if (!gent->is_indirect)
9894 allocate_got (h, (struct bfd_link_info *) inf, gent);
9895 return TRUE;
9896 }
9897
9898 /* Called on the first multitoc pass after the last call to
9899 ppc64_elf_next_toc_section. This function removes duplicate GOT
9900 entries. */
9901
9902 bfd_boolean
9903 ppc64_elf_layout_multitoc (struct bfd_link_info *info)
9904 {
9905 struct ppc_link_hash_table *htab = ppc_hash_table (info);
9906 struct bfd *ibfd, *ibfd2;
9907 bfd_boolean done_something;
9908
9909 htab->multi_toc_needed = htab->toc_curr != elf_gp (info->output_bfd);
9910
9911 /* Merge local got entries within a toc group. */
9912 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
9913 {
9914 struct got_entry **lgot_ents;
9915 struct got_entry **end_lgot_ents;
9916 Elf_Internal_Shdr *symtab_hdr;
9917 bfd_size_type locsymcount;
9918
9919 if (!is_ppc64_elf (ibfd))
9920 continue;
9921
9922 lgot_ents = elf_local_got_ents (ibfd);
9923 if (!lgot_ents)
9924 continue;
9925
9926 symtab_hdr = &elf_symtab_hdr (ibfd);
9927 locsymcount = symtab_hdr->sh_info;
9928 end_lgot_ents = lgot_ents + locsymcount;
9929
9930 for (; lgot_ents < end_lgot_ents; ++lgot_ents)
9931 merge_got_entries (lgot_ents);
9932 }
9933
9934 /* And the same for global sym got entries. */
9935 elf_link_hash_traverse (&htab->elf, merge_global_got, info);
9936
9937 /* And tlsld_got. */
9938 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
9939 {
9940 struct got_entry *ent, *ent2;
9941
9942 if (!is_ppc64_elf (ibfd))
9943 continue;
9944
9945 ent = ppc64_tlsld_got (ibfd);
9946 if (!ent->is_indirect
9947 && ent->got.offset != (bfd_vma) -1)
9948 {
9949 for (ibfd2 = ibfd->link_next; ibfd2 != NULL; ibfd2 = ibfd2->link_next)
9950 {
9951 if (!is_ppc64_elf (ibfd2))
9952 continue;
9953
9954 ent2 = ppc64_tlsld_got (ibfd2);
9955 if (!ent2->is_indirect
9956 && ent2->got.offset != (bfd_vma) -1
9957 && elf_gp (ibfd2) == elf_gp (ibfd))
9958 {
9959 ent2->is_indirect = TRUE;
9960 ent2->got.ent = ent;
9961 }
9962 }
9963 }
9964 }
9965
9966 /* Zap sizes of got sections. */
9967 htab->reliplt->rawsize = htab->reliplt->size;
9968 htab->reliplt->size -= htab->got_reli_size;
9969 htab->got_reli_size = 0;
9970
9971 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
9972 {
9973 asection *got, *relgot;
9974
9975 if (!is_ppc64_elf (ibfd))
9976 continue;
9977
9978 got = ppc64_elf_tdata (ibfd)->got;
9979 if (got != NULL)
9980 {
9981 got->rawsize = got->size;
9982 got->size = 0;
9983 relgot = ppc64_elf_tdata (ibfd)->relgot;
9984 relgot->rawsize = relgot->size;
9985 relgot->size = 0;
9986 }
9987 }
9988
9989 /* Now reallocate the got, local syms first. We don't need to
9990 allocate section contents again since we never increase size. */
9991 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
9992 {
9993 struct got_entry **lgot_ents;
9994 struct got_entry **end_lgot_ents;
9995 struct plt_entry **local_plt;
9996 struct plt_entry **end_local_plt;
9997 char *lgot_masks;
9998 bfd_size_type locsymcount;
9999 Elf_Internal_Shdr *symtab_hdr;
10000 asection *s, *srel;
10001
10002 if (!is_ppc64_elf (ibfd))
10003 continue;
10004
10005 lgot_ents = elf_local_got_ents (ibfd);
10006 if (!lgot_ents)
10007 continue;
10008
10009 symtab_hdr = &elf_symtab_hdr (ibfd);
10010 locsymcount = symtab_hdr->sh_info;
10011 end_lgot_ents = lgot_ents + locsymcount;
10012 local_plt = (struct plt_entry **) end_lgot_ents;
10013 end_local_plt = local_plt + locsymcount;
10014 lgot_masks = (char *) end_local_plt;
10015 s = ppc64_elf_tdata (ibfd)->got;
10016 srel = ppc64_elf_tdata (ibfd)->relgot;
10017 for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
10018 {
10019 struct got_entry *ent;
10020
10021 for (ent = *lgot_ents; ent != NULL; ent = ent->next)
10022 if (!ent->is_indirect)
10023 {
10024 unsigned int num = 1;
10025 ent->got.offset = s->size;
10026 if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
10027 num = 2;
10028 s->size += num * 8;
10029 if (info->shared)
10030 srel->size += num * sizeof (Elf64_External_Rela);
10031 else if ((*lgot_masks & PLT_IFUNC) != 0)
10032 {
10033 htab->reliplt->size
10034 += num * sizeof (Elf64_External_Rela);
10035 htab->got_reli_size
10036 += num * sizeof (Elf64_External_Rela);
10037 }
10038 }
10039 }
10040 }
10041
10042 elf_link_hash_traverse (&htab->elf, reallocate_got, info);
10043
10044 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
10045 {
10046 struct got_entry *ent;
10047
10048 if (!is_ppc64_elf (ibfd))
10049 continue;
10050
10051 ent = ppc64_tlsld_got (ibfd);
10052 if (!ent->is_indirect
10053 && ent->got.offset != (bfd_vma) -1)
10054 {
10055 asection *s = ppc64_elf_tdata (ibfd)->got;
10056 ent->got.offset = s->size;
10057 s->size += 16;
10058 if (info->shared)
10059 {
10060 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
10061 srel->size += sizeof (Elf64_External_Rela);
10062 }
10063 }
10064 }
10065
10066 done_something = htab->reliplt->rawsize != htab->reliplt->size;
10067 if (!done_something)
10068 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
10069 {
10070 asection *got;
10071
10072 if (!is_ppc64_elf (ibfd))
10073 continue;
10074
10075 got = ppc64_elf_tdata (ibfd)->got;
10076 if (got != NULL)
10077 {
10078 done_something = got->rawsize != got->size;
10079 if (done_something)
10080 break;
10081 }
10082 }
10083
10084 if (done_something)
10085 (*htab->layout_sections_again) ();
10086
10087 /* Set up for second pass over toc sections to recalculate elf_gp
10088 on input sections. */
10089 htab->toc_bfd = NULL;
10090 htab->toc_first_sec = NULL;
10091 htab->second_toc_pass = TRUE;
10092 return done_something;
10093 }
10094
10095 /* Called after second pass of multitoc partitioning. */
10096
10097 void
10098 ppc64_elf_finish_multitoc_partition (struct bfd_link_info *info)
10099 {
10100 struct ppc_link_hash_table *htab = ppc_hash_table (info);
10101
10102 if (htab == NULL)
10103 return;
10104
10105 /* After the second pass, toc_curr tracks the TOC offset used
10106 for code sections below in ppc64_elf_next_input_section. */
10107 htab->toc_curr = TOC_BASE_OFF;
10108 }
10109
10110 /* No toc references were found in ISEC. If the code in ISEC makes no
10111 calls, then there's no need to use toc adjusting stubs when branching
10112 into ISEC. Actually, indirect calls from ISEC are OK as they will
10113 load r2. Returns -1 on error, 0 for no stub needed, 1 for stub
10114 needed, and 2 if a cyclical call-graph was found but no other reason
10115 for a stub was detected. If called from the top level, a return of
10116 2 means the same as a return of 0. */
10117
10118 static int
10119 toc_adjusting_stub_needed (struct bfd_link_info *info, asection *isec)
10120 {
10121 Elf_Internal_Rela *relstart, *rel;
10122 Elf_Internal_Sym *local_syms;
10123 int ret;
10124 struct ppc_link_hash_table *htab;
10125
10126 /* We know none of our code bearing sections will need toc stubs. */
10127 if ((isec->flags & SEC_LINKER_CREATED) != 0)
10128 return 0;
10129
10130 if (isec->size == 0)
10131 return 0;
10132
10133 if (isec->output_section == NULL)
10134 return 0;
10135
10136 if (isec->reloc_count == 0)
10137 return 0;
10138
10139 relstart = _bfd_elf_link_read_relocs (isec->owner, isec, NULL, NULL,
10140 info->keep_memory);
10141 if (relstart == NULL)
10142 return -1;
10143
10144 /* Look for branches to outside of this section. */
10145 local_syms = NULL;
10146 ret = 0;
10147 htab = ppc_hash_table (info);
10148 if (htab == NULL)
10149 return -1;
10150
10151 for (rel = relstart; rel < relstart + isec->reloc_count; ++rel)
10152 {
10153 enum elf_ppc64_reloc_type r_type;
10154 unsigned long r_symndx;
10155 struct elf_link_hash_entry *h;
10156 struct ppc_link_hash_entry *eh;
10157 Elf_Internal_Sym *sym;
10158 asection *sym_sec;
10159 struct _opd_sec_data *opd;
10160 bfd_vma sym_value;
10161 bfd_vma dest;
10162
10163 r_type = ELF64_R_TYPE (rel->r_info);
10164 if (r_type != R_PPC64_REL24
10165 && r_type != R_PPC64_REL14
10166 && r_type != R_PPC64_REL14_BRTAKEN
10167 && r_type != R_PPC64_REL14_BRNTAKEN)
10168 continue;
10169
10170 r_symndx = ELF64_R_SYM (rel->r_info);
10171 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms, r_symndx,
10172 isec->owner))
10173 {
10174 ret = -1;
10175 break;
10176 }
10177
10178 /* Calls to dynamic lib functions go through a plt call stub
10179 that uses r2. */
10180 eh = (struct ppc_link_hash_entry *) h;
10181 if (eh != NULL
10182 && (eh->elf.plt.plist != NULL
10183 || (eh->oh != NULL
10184 && ppc_follow_link (eh->oh)->elf.plt.plist != NULL)))
10185 {
10186 ret = 1;
10187 break;
10188 }
10189
10190 if (sym_sec == NULL)
10191 /* Ignore other undefined symbols. */
10192 continue;
10193
10194 /* Assume branches to other sections not included in the link need
10195 stubs too, to cover -R and absolute syms. */
10196 if (sym_sec->output_section == NULL)
10197 {
10198 ret = 1;
10199 break;
10200 }
10201
10202 if (h == NULL)
10203 sym_value = sym->st_value;
10204 else
10205 {
10206 if (h->root.type != bfd_link_hash_defined
10207 && h->root.type != bfd_link_hash_defweak)
10208 abort ();
10209 sym_value = h->root.u.def.value;
10210 }
10211 sym_value += rel->r_addend;
10212
10213 /* If this branch reloc uses an opd sym, find the code section. */
10214 opd = get_opd_info (sym_sec);
10215 if (opd != NULL)
10216 {
10217 if (h == NULL && opd->adjust != NULL)
10218 {
10219 long adjust;
10220
10221 adjust = opd->adjust[sym->st_value / 8];
10222 if (adjust == -1)
10223 /* Assume deleted functions won't ever be called. */
10224 continue;
10225 sym_value += adjust;
10226 }
10227
10228 dest = opd_entry_value (sym_sec, sym_value, &sym_sec, NULL);
10229 if (dest == (bfd_vma) -1)
10230 continue;
10231 }
10232 else
10233 dest = (sym_value
10234 + sym_sec->output_offset
10235 + sym_sec->output_section->vma);
10236
10237 /* Ignore branch to self. */
10238 if (sym_sec == isec)
10239 continue;
10240
10241 /* If the called function uses the toc, we need a stub. */
10242 if (sym_sec->has_toc_reloc
10243 || sym_sec->makes_toc_func_call)
10244 {
10245 ret = 1;
10246 break;
10247 }
10248
10249 /* Assume any branch that needs a long branch stub might in fact
10250 need a plt_branch stub. A plt_branch stub uses r2. */
10251 else if (dest - (isec->output_offset
10252 + isec->output_section->vma
10253 + rel->r_offset) + (1 << 25) >= (2 << 25))
10254 {
10255 ret = 1;
10256 break;
10257 }
10258
10259 /* If calling back to a section in the process of being tested, we
10260 can't say for sure that no toc adjusting stubs are needed, so
10261 don't return zero. */
10262 else if (sym_sec->call_check_in_progress)
10263 ret = 2;
10264
10265 /* Branches to another section that itself doesn't have any TOC
10266 references are OK. Recursively call ourselves to check. */
10267 else if (sym_sec->id <= htab->top_id
10268 && htab->stub_group[sym_sec->id].toc_off == 0)
10269 {
10270 int recur;
10271
10272 /* Mark current section as indeterminate, so that other
10273 sections that call back to current won't be marked as
10274 known. */
10275 isec->call_check_in_progress = 1;
10276 recur = toc_adjusting_stub_needed (info, sym_sec);
10277 isec->call_check_in_progress = 0;
10278
10279 if (recur < 0)
10280 {
10281 /* An error. Exit. */
10282 ret = -1;
10283 break;
10284 }
10285 else if (recur <= 1)
10286 {
10287 /* Known result. Mark as checked and set section flag. */
10288 htab->stub_group[sym_sec->id].toc_off = 1;
10289 if (recur != 0)
10290 {
10291 sym_sec->makes_toc_func_call = 1;
10292 ret = 1;
10293 break;
10294 }
10295 }
10296 else
10297 {
10298 /* Unknown result. Continue checking. */
10299 ret = 2;
10300 }
10301 }
10302 }
10303
10304 if (local_syms != NULL
10305 && (elf_symtab_hdr (isec->owner).contents != (unsigned char *) local_syms))
10306 free (local_syms);
10307 if (elf_section_data (isec)->relocs != relstart)
10308 free (relstart);
10309
10310 return ret;
10311 }
10312
10313 /* The linker repeatedly calls this function for each input section,
10314 in the order that input sections are linked into output sections.
10315 Build lists of input sections to determine groupings between which
10316 we may insert linker stubs. */
10317
10318 bfd_boolean
10319 ppc64_elf_next_input_section (struct bfd_link_info *info, asection *isec)
10320 {
10321 struct ppc_link_hash_table *htab = ppc_hash_table (info);
10322
10323 if (htab == NULL)
10324 return FALSE;
10325
10326 if ((isec->output_section->flags & SEC_CODE) != 0
10327 && isec->output_section->index <= htab->top_index)
10328 {
10329 asection **list = htab->input_list + isec->output_section->index;
10330 /* Steal the link_sec pointer for our list. */
10331 #define PREV_SEC(sec) (htab->stub_group[(sec)->id].link_sec)
10332 /* This happens to make the list in reverse order,
10333 which is what we want. */
10334 PREV_SEC (isec) = *list;
10335 *list = isec;
10336 }
10337
10338 if (htab->multi_toc_needed)
10339 {
10340 /* If a code section has a function that uses the TOC then we need
10341 to use the right TOC (obviously). Also, make sure that .opd gets
10342 the correct TOC value for R_PPC64_TOC relocs that don't have or
10343 can't find their function symbol (shouldn't ever happen now).
10344 Also specially treat .fixup for the linux kernel. .fixup
10345 contains branches, but only back to the function that hit an
10346 exception. */
10347 if (isec->has_toc_reloc
10348 || (isec->flags & SEC_CODE) == 0
10349 || strcmp (isec->name, ".fixup") == 0)
10350 {
10351 if (elf_gp (isec->owner) != 0)
10352 htab->toc_curr = elf_gp (isec->owner);
10353 }
10354 else if (htab->stub_group[isec->id].toc_off == 0)
10355 {
10356 int ret = toc_adjusting_stub_needed (info, isec);
10357 if (ret < 0)
10358 return FALSE;
10359 else
10360 isec->makes_toc_func_call = ret & 1;
10361 }
10362 }
10363
10364 /* Functions that don't use the TOC can belong in any TOC group.
10365 Use the last TOC base. This happens to make _init and _fini
10366 pasting work. */
10367 htab->stub_group[isec->id].toc_off = htab->toc_curr;
10368 return TRUE;
10369 }
10370
10371 /* See whether we can group stub sections together. Grouping stub
10372 sections may result in fewer stubs. More importantly, we need to
10373 put all .init* and .fini* stubs at the beginning of the .init or
10374 .fini output sections respectively, because glibc splits the
10375 _init and _fini functions into multiple parts. Putting a stub in
10376 the middle of a function is not a good idea. */
10377
10378 static void
10379 group_sections (struct ppc_link_hash_table *htab,
10380 bfd_size_type stub_group_size,
10381 bfd_boolean stubs_always_before_branch)
10382 {
10383 asection **list;
10384 bfd_size_type stub14_group_size;
10385 bfd_boolean suppress_size_errors;
10386
10387 suppress_size_errors = FALSE;
10388 stub14_group_size = stub_group_size;
10389 if (stub_group_size == 1)
10390 {
10391 /* Default values. */
10392 if (stubs_always_before_branch)
10393 {
10394 stub_group_size = 0x1e00000;
10395 stub14_group_size = 0x7800;
10396 }
10397 else
10398 {
10399 stub_group_size = 0x1c00000;
10400 stub14_group_size = 0x7000;
10401 }
10402 suppress_size_errors = TRUE;
10403 }
10404
10405 list = htab->input_list + htab->top_index;
10406 do
10407 {
10408 asection *tail = *list;
10409 while (tail != NULL)
10410 {
10411 asection *curr;
10412 asection *prev;
10413 bfd_size_type total;
10414 bfd_boolean big_sec;
10415 bfd_vma curr_toc;
10416
10417 curr = tail;
10418 total = tail->size;
10419 big_sec = total > (ppc64_elf_section_data (tail)->has_14bit_branch
10420 ? stub14_group_size : stub_group_size);
10421 if (big_sec && !suppress_size_errors)
10422 (*_bfd_error_handler) (_("%B section %A exceeds stub group size"),
10423 tail->owner, tail);
10424 curr_toc = htab->stub_group[tail->id].toc_off;
10425
10426 while ((prev = PREV_SEC (curr)) != NULL
10427 && ((total += curr->output_offset - prev->output_offset)
10428 < (ppc64_elf_section_data (prev)->has_14bit_branch
10429 ? stub14_group_size : stub_group_size))
10430 && htab->stub_group[prev->id].toc_off == curr_toc)
10431 curr = prev;
10432
10433 /* OK, the size from the start of CURR to the end is less
10434 than stub_group_size and thus can be handled by one stub
10435 section. (or the tail section is itself larger than
10436 stub_group_size, in which case we may be toast.) We
10437 should really be keeping track of the total size of stubs
10438 added here, as stubs contribute to the final output
10439 section size. That's a little tricky, and this way will
10440 only break if stubs added make the total size more than
10441 2^25, ie. for the default stub_group_size, if stubs total
10442 more than 2097152 bytes, or nearly 75000 plt call stubs. */
10443 do
10444 {
10445 prev = PREV_SEC (tail);
10446 /* Set up this stub group. */
10447 htab->stub_group[tail->id].link_sec = curr;
10448 }
10449 while (tail != curr && (tail = prev) != NULL);
10450
10451 /* But wait, there's more! Input sections up to stub_group_size
10452 bytes before the stub section can be handled by it too.
10453 Don't do this if we have a really large section after the
10454 stubs, as adding more stubs increases the chance that
10455 branches may not reach into the stub section. */
10456 if (!stubs_always_before_branch && !big_sec)
10457 {
10458 total = 0;
10459 while (prev != NULL
10460 && ((total += tail->output_offset - prev->output_offset)
10461 < (ppc64_elf_section_data (prev)->has_14bit_branch
10462 ? stub14_group_size : stub_group_size))
10463 && htab->stub_group[prev->id].toc_off == curr_toc)
10464 {
10465 tail = prev;
10466 prev = PREV_SEC (tail);
10467 htab->stub_group[tail->id].link_sec = curr;
10468 }
10469 }
10470 tail = prev;
10471 }
10472 }
10473 while (list-- != htab->input_list);
10474 free (htab->input_list);
10475 #undef PREV_SEC
10476 }
10477
10478 /* Determine and set the size of the stub section for a final link.
10479
10480 The basic idea here is to examine all the relocations looking for
10481 PC-relative calls to a target that is unreachable with a "bl"
10482 instruction. */
10483
10484 bfd_boolean
10485 ppc64_elf_size_stubs (struct bfd_link_info *info, bfd_signed_vma group_size)
10486 {
10487 bfd_size_type stub_group_size;
10488 bfd_boolean stubs_always_before_branch;
10489 struct ppc_link_hash_table *htab = ppc_hash_table (info);
10490
10491 if (htab == NULL)
10492 return FALSE;
10493
10494 stubs_always_before_branch = group_size < 0;
10495 if (group_size < 0)
10496 stub_group_size = -group_size;
10497 else
10498 stub_group_size = group_size;
10499
10500 group_sections (htab, stub_group_size, stubs_always_before_branch);
10501
10502 while (1)
10503 {
10504 bfd *input_bfd;
10505 unsigned int bfd_indx;
10506 asection *stub_sec;
10507
10508 htab->stub_iteration += 1;
10509
10510 for (input_bfd = info->input_bfds, bfd_indx = 0;
10511 input_bfd != NULL;
10512 input_bfd = input_bfd->link_next, bfd_indx++)
10513 {
10514 Elf_Internal_Shdr *symtab_hdr;
10515 asection *section;
10516 Elf_Internal_Sym *local_syms = NULL;
10517
10518 if (!is_ppc64_elf (input_bfd))
10519 continue;
10520
10521 /* We'll need the symbol table in a second. */
10522 symtab_hdr = &elf_symtab_hdr (input_bfd);
10523 if (symtab_hdr->sh_info == 0)
10524 continue;
10525
10526 /* Walk over each section attached to the input bfd. */
10527 for (section = input_bfd->sections;
10528 section != NULL;
10529 section = section->next)
10530 {
10531 Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
10532
10533 /* If there aren't any relocs, then there's nothing more
10534 to do. */
10535 if ((section->flags & SEC_RELOC) == 0
10536 || (section->flags & SEC_ALLOC) == 0
10537 || (section->flags & SEC_LOAD) == 0
10538 || (section->flags & SEC_CODE) == 0
10539 || section->reloc_count == 0)
10540 continue;
10541
10542 /* If this section is a link-once section that will be
10543 discarded, then don't create any stubs. */
10544 if (section->output_section == NULL
10545 || section->output_section->owner != info->output_bfd)
10546 continue;
10547
10548 /* Get the relocs. */
10549 internal_relocs
10550 = _bfd_elf_link_read_relocs (input_bfd, section, NULL, NULL,
10551 info->keep_memory);
10552 if (internal_relocs == NULL)
10553 goto error_ret_free_local;
10554
10555 /* Now examine each relocation. */
10556 irela = internal_relocs;
10557 irelaend = irela + section->reloc_count;
10558 for (; irela < irelaend; irela++)
10559 {
10560 enum elf_ppc64_reloc_type r_type;
10561 unsigned int r_indx;
10562 enum ppc_stub_type stub_type;
10563 struct ppc_stub_hash_entry *stub_entry;
10564 asection *sym_sec, *code_sec;
10565 bfd_vma sym_value, code_value;
10566 bfd_vma destination;
10567 bfd_boolean ok_dest;
10568 struct ppc_link_hash_entry *hash;
10569 struct ppc_link_hash_entry *fdh;
10570 struct elf_link_hash_entry *h;
10571 Elf_Internal_Sym *sym;
10572 char *stub_name;
10573 const asection *id_sec;
10574 struct _opd_sec_data *opd;
10575 struct plt_entry *plt_ent;
10576
10577 r_type = ELF64_R_TYPE (irela->r_info);
10578 r_indx = ELF64_R_SYM (irela->r_info);
10579
10580 if (r_type >= R_PPC64_max)
10581 {
10582 bfd_set_error (bfd_error_bad_value);
10583 goto error_ret_free_internal;
10584 }
10585
10586 /* Only look for stubs on branch instructions. */
10587 if (r_type != R_PPC64_REL24
10588 && r_type != R_PPC64_REL14
10589 && r_type != R_PPC64_REL14_BRTAKEN
10590 && r_type != R_PPC64_REL14_BRNTAKEN)
10591 continue;
10592
10593 /* Now determine the call target, its name, value,
10594 section. */
10595 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
10596 r_indx, input_bfd))
10597 goto error_ret_free_internal;
10598 hash = (struct ppc_link_hash_entry *) h;
10599
10600 ok_dest = FALSE;
10601 fdh = NULL;
10602 sym_value = 0;
10603 if (hash == NULL)
10604 {
10605 sym_value = sym->st_value;
10606 ok_dest = TRUE;
10607 }
10608 else if (hash->elf.root.type == bfd_link_hash_defined
10609 || hash->elf.root.type == bfd_link_hash_defweak)
10610 {
10611 sym_value = hash->elf.root.u.def.value;
10612 if (sym_sec->output_section != NULL)
10613 ok_dest = TRUE;
10614 }
10615 else if (hash->elf.root.type == bfd_link_hash_undefweak
10616 || hash->elf.root.type == bfd_link_hash_undefined)
10617 {
10618 /* Recognise an old ABI func code entry sym, and
10619 use the func descriptor sym instead if it is
10620 defined. */
10621 if (hash->elf.root.root.string[0] == '.'
10622 && (fdh = lookup_fdh (hash, htab)) != NULL)
10623 {
10624 if (fdh->elf.root.type == bfd_link_hash_defined
10625 || fdh->elf.root.type == bfd_link_hash_defweak)
10626 {
10627 sym_sec = fdh->elf.root.u.def.section;
10628 sym_value = fdh->elf.root.u.def.value;
10629 if (sym_sec->output_section != NULL)
10630 ok_dest = TRUE;
10631 }
10632 else
10633 fdh = NULL;
10634 }
10635 }
10636 else
10637 {
10638 bfd_set_error (bfd_error_bad_value);
10639 goto error_ret_free_internal;
10640 }
10641
10642 destination = 0;
10643 if (ok_dest)
10644 {
10645 sym_value += irela->r_addend;
10646 destination = (sym_value
10647 + sym_sec->output_offset
10648 + sym_sec->output_section->vma);
10649 }
10650
10651 code_sec = sym_sec;
10652 code_value = sym_value;
10653 opd = get_opd_info (sym_sec);
10654 if (opd != NULL)
10655 {
10656 bfd_vma dest;
10657
10658 if (hash == NULL && opd->adjust != NULL)
10659 {
10660 long adjust = opd->adjust[sym_value / 8];
10661 if (adjust == -1)
10662 continue;
10663 code_value += adjust;
10664 sym_value += adjust;
10665 }
10666 dest = opd_entry_value (sym_sec, sym_value,
10667 &code_sec, &code_value);
10668 if (dest != (bfd_vma) -1)
10669 {
10670 destination = dest;
10671 if (fdh != NULL)
10672 {
10673 /* Fixup old ABI sym to point at code
10674 entry. */
10675 hash->elf.root.type = bfd_link_hash_defweak;
10676 hash->elf.root.u.def.section = code_sec;
10677 hash->elf.root.u.def.value = code_value;
10678 }
10679 }
10680 }
10681
10682 /* Determine what (if any) linker stub is needed. */
10683 plt_ent = NULL;
10684 stub_type = ppc_type_of_stub (section, irela, &hash,
10685 &plt_ent, destination);
10686
10687 if (stub_type != ppc_stub_plt_call)
10688 {
10689 /* Check whether we need a TOC adjusting stub.
10690 Since the linker pastes together pieces from
10691 different object files when creating the
10692 _init and _fini functions, it may be that a
10693 call to what looks like a local sym is in
10694 fact a call needing a TOC adjustment. */
10695 if (code_sec != NULL
10696 && code_sec->output_section != NULL
10697 && (htab->stub_group[code_sec->id].toc_off
10698 != htab->stub_group[section->id].toc_off)
10699 && (code_sec->has_toc_reloc
10700 || code_sec->makes_toc_func_call))
10701 stub_type = ppc_stub_long_branch_r2off;
10702 }
10703
10704 if (stub_type == ppc_stub_none)
10705 continue;
10706
10707 /* __tls_get_addr calls might be eliminated. */
10708 if (stub_type != ppc_stub_plt_call
10709 && hash != NULL
10710 && (hash == htab->tls_get_addr
10711 || hash == htab->tls_get_addr_fd)
10712 && section->has_tls_reloc
10713 && irela != internal_relocs)
10714 {
10715 /* Get tls info. */
10716 char *tls_mask;
10717
10718 if (!get_tls_mask (&tls_mask, NULL, NULL, &local_syms,
10719 irela - 1, input_bfd))
10720 goto error_ret_free_internal;
10721 if (*tls_mask != 0)
10722 continue;
10723 }
10724
10725 /* Support for grouping stub sections. */
10726 id_sec = htab->stub_group[section->id].link_sec;
10727
10728 /* Get the name of this stub. */
10729 stub_name = ppc_stub_name (id_sec, sym_sec, hash, irela);
10730 if (!stub_name)
10731 goto error_ret_free_internal;
10732
10733 stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
10734 stub_name, FALSE, FALSE);
10735 if (stub_entry != NULL)
10736 {
10737 /* The proper stub has already been created. */
10738 free (stub_name);
10739 continue;
10740 }
10741
10742 stub_entry = ppc_add_stub (stub_name, section, htab);
10743 if (stub_entry == NULL)
10744 {
10745 free (stub_name);
10746 error_ret_free_internal:
10747 if (elf_section_data (section)->relocs == NULL)
10748 free (internal_relocs);
10749 error_ret_free_local:
10750 if (local_syms != NULL
10751 && (symtab_hdr->contents
10752 != (unsigned char *) local_syms))
10753 free (local_syms);
10754 return FALSE;
10755 }
10756
10757 stub_entry->stub_type = stub_type;
10758 if (stub_type != ppc_stub_plt_call)
10759 {
10760 stub_entry->target_value = code_value;
10761 stub_entry->target_section = code_sec;
10762 }
10763 else
10764 {
10765 stub_entry->target_value = sym_value;
10766 stub_entry->target_section = sym_sec;
10767 }
10768 stub_entry->h = hash;
10769 stub_entry->plt_ent = plt_ent;
10770 stub_entry->addend = irela->r_addend;
10771
10772 if (stub_entry->h != NULL)
10773 htab->stub_globals += 1;
10774 }
10775
10776 /* We're done with the internal relocs, free them. */
10777 if (elf_section_data (section)->relocs != internal_relocs)
10778 free (internal_relocs);
10779 }
10780
10781 if (local_syms != NULL
10782 && symtab_hdr->contents != (unsigned char *) local_syms)
10783 {
10784 if (!info->keep_memory)
10785 free (local_syms);
10786 else
10787 symtab_hdr->contents = (unsigned char *) local_syms;
10788 }
10789 }
10790
10791 /* We may have added some stubs. Find out the new size of the
10792 stub sections. */
10793 for (stub_sec = htab->stub_bfd->sections;
10794 stub_sec != NULL;
10795 stub_sec = stub_sec->next)
10796 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
10797 {
10798 stub_sec->rawsize = stub_sec->size;
10799 stub_sec->size = 0;
10800 stub_sec->reloc_count = 0;
10801 stub_sec->flags &= ~SEC_RELOC;
10802 }
10803
10804 htab->brlt->size = 0;
10805 htab->brlt->reloc_count = 0;
10806 htab->brlt->flags &= ~SEC_RELOC;
10807 if (htab->relbrlt != NULL)
10808 htab->relbrlt->size = 0;
10809
10810 bfd_hash_traverse (&htab->stub_hash_table, ppc_size_one_stub, info);
10811
10812 if (info->emitrelocations
10813 && htab->glink != NULL && htab->glink->size != 0)
10814 {
10815 htab->glink->reloc_count = 1;
10816 htab->glink->flags |= SEC_RELOC;
10817 }
10818
10819 for (stub_sec = htab->stub_bfd->sections;
10820 stub_sec != NULL;
10821 stub_sec = stub_sec->next)
10822 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
10823 && stub_sec->rawsize != stub_sec->size)
10824 break;
10825
10826 /* Exit from this loop when no stubs have been added, and no stubs
10827 have changed size. */
10828 if (stub_sec == NULL)
10829 break;
10830
10831 /* Ask the linker to do its stuff. */
10832 (*htab->layout_sections_again) ();
10833 }
10834
10835 /* It would be nice to strip htab->brlt from the output if the
10836 section is empty, but it's too late. If we strip sections here,
10837 the dynamic symbol table is corrupted since the section symbol
10838 for the stripped section isn't written. */
10839
10840 return TRUE;
10841 }
10842
10843 /* Called after we have determined section placement. If sections
10844 move, we'll be called again. Provide a value for TOCstart. */
10845
10846 bfd_vma
10847 ppc64_elf_toc (bfd *obfd)
10848 {
10849 asection *s;
10850 bfd_vma TOCstart;
10851
10852 /* The TOC consists of sections .got, .toc, .tocbss, .plt in that
10853 order. The TOC starts where the first of these sections starts. */
10854 s = bfd_get_section_by_name (obfd, ".got");
10855 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
10856 s = bfd_get_section_by_name (obfd, ".toc");
10857 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
10858 s = bfd_get_section_by_name (obfd, ".tocbss");
10859 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
10860 s = bfd_get_section_by_name (obfd, ".plt");
10861 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
10862 {
10863 /* This may happen for
10864 o references to TOC base (SYM@toc / TOC[tc0]) without a
10865 .toc directive
10866 o bad linker script
10867 o --gc-sections and empty TOC sections
10868
10869 FIXME: Warn user? */
10870
10871 /* Look for a likely section. We probably won't even be
10872 using TOCstart. */
10873 for (s = obfd->sections; s != NULL; s = s->next)
10874 if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_READONLY
10875 | SEC_EXCLUDE))
10876 == (SEC_ALLOC | SEC_SMALL_DATA))
10877 break;
10878 if (s == NULL)
10879 for (s = obfd->sections; s != NULL; s = s->next)
10880 if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_EXCLUDE))
10881 == (SEC_ALLOC | SEC_SMALL_DATA))
10882 break;
10883 if (s == NULL)
10884 for (s = obfd->sections; s != NULL; s = s->next)
10885 if ((s->flags & (SEC_ALLOC | SEC_READONLY | SEC_EXCLUDE))
10886 == SEC_ALLOC)
10887 break;
10888 if (s == NULL)
10889 for (s = obfd->sections; s != NULL; s = s->next)
10890 if ((s->flags & (SEC_ALLOC | SEC_EXCLUDE)) == SEC_ALLOC)
10891 break;
10892 }
10893
10894 TOCstart = 0;
10895 if (s != NULL)
10896 TOCstart = s->output_section->vma + s->output_offset;
10897
10898 return TOCstart;
10899 }
10900
10901 /* Build all the stubs associated with the current output file.
10902 The stubs are kept in a hash table attached to the main linker
10903 hash table. This function is called via gldelf64ppc_finish. */
10904
10905 bfd_boolean
10906 ppc64_elf_build_stubs (bfd_boolean emit_stub_syms,
10907 struct bfd_link_info *info,
10908 char **stats)
10909 {
10910 struct ppc_link_hash_table *htab = ppc_hash_table (info);
10911 asection *stub_sec;
10912 bfd_byte *p;
10913 int stub_sec_count = 0;
10914
10915 if (htab == NULL)
10916 return FALSE;
10917
10918 htab->emit_stub_syms = emit_stub_syms;
10919
10920 /* Allocate memory to hold the linker stubs. */
10921 for (stub_sec = htab->stub_bfd->sections;
10922 stub_sec != NULL;
10923 stub_sec = stub_sec->next)
10924 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
10925 && stub_sec->size != 0)
10926 {
10927 stub_sec->contents = bfd_zalloc (htab->stub_bfd, stub_sec->size);
10928 if (stub_sec->contents == NULL)
10929 return FALSE;
10930 /* We want to check that built size is the same as calculated
10931 size. rawsize is a convenient location to use. */
10932 stub_sec->rawsize = stub_sec->size;
10933 stub_sec->size = 0;
10934 }
10935
10936 if (htab->glink != NULL && htab->glink->size != 0)
10937 {
10938 unsigned int indx;
10939 bfd_vma plt0;
10940
10941 /* Build the .glink plt call stub. */
10942 if (htab->emit_stub_syms)
10943 {
10944 struct elf_link_hash_entry *h;
10945 h = elf_link_hash_lookup (&htab->elf, "__glink_PLTresolve",
10946 TRUE, FALSE, FALSE);
10947 if (h == NULL)
10948 return FALSE;
10949 if (h->root.type == bfd_link_hash_new)
10950 {
10951 h->root.type = bfd_link_hash_defined;
10952 h->root.u.def.section = htab->glink;
10953 h->root.u.def.value = 8;
10954 h->ref_regular = 1;
10955 h->def_regular = 1;
10956 h->ref_regular_nonweak = 1;
10957 h->forced_local = 1;
10958 h->non_elf = 0;
10959 }
10960 }
10961 plt0 = htab->plt->output_section->vma + htab->plt->output_offset - 16;
10962 if (info->emitrelocations)
10963 {
10964 Elf_Internal_Rela *r = get_relocs (htab->glink, 1);
10965 if (r == NULL)
10966 return FALSE;
10967 r->r_offset = (htab->glink->output_offset
10968 + htab->glink->output_section->vma);
10969 r->r_info = ELF64_R_INFO (0, R_PPC64_REL64);
10970 r->r_addend = plt0;
10971 }
10972 p = htab->glink->contents;
10973 plt0 -= htab->glink->output_section->vma + htab->glink->output_offset;
10974 bfd_put_64 (htab->glink->owner, plt0, p);
10975 p += 8;
10976 bfd_put_32 (htab->glink->owner, MFLR_R12, p);
10977 p += 4;
10978 bfd_put_32 (htab->glink->owner, BCL_20_31, p);
10979 p += 4;
10980 bfd_put_32 (htab->glink->owner, MFLR_R11, p);
10981 p += 4;
10982 bfd_put_32 (htab->glink->owner, LD_R2_M16R11, p);
10983 p += 4;
10984 bfd_put_32 (htab->glink->owner, MTLR_R12, p);
10985 p += 4;
10986 bfd_put_32 (htab->glink->owner, ADD_R12_R2_R11, p);
10987 p += 4;
10988 bfd_put_32 (htab->glink->owner, LD_R11_0R12, p);
10989 p += 4;
10990 bfd_put_32 (htab->glink->owner, LD_R2_0R12 | 8, p);
10991 p += 4;
10992 bfd_put_32 (htab->glink->owner, MTCTR_R11, p);
10993 p += 4;
10994 bfd_put_32 (htab->glink->owner, LD_R11_0R12 | 16, p);
10995 p += 4;
10996 bfd_put_32 (htab->glink->owner, BCTR, p);
10997 p += 4;
10998 while (p - htab->glink->contents < GLINK_CALL_STUB_SIZE)
10999 {
11000 bfd_put_32 (htab->glink->owner, NOP, p);
11001 p += 4;
11002 }
11003
11004 /* Build the .glink lazy link call stubs. */
11005 indx = 0;
11006 while (p < htab->glink->contents + htab->glink->size)
11007 {
11008 if (indx < 0x8000)
11009 {
11010 bfd_put_32 (htab->glink->owner, LI_R0_0 | indx, p);
11011 p += 4;
11012 }
11013 else
11014 {
11015 bfd_put_32 (htab->glink->owner, LIS_R0_0 | PPC_HI (indx), p);
11016 p += 4;
11017 bfd_put_32 (htab->glink->owner, ORI_R0_R0_0 | PPC_LO (indx), p);
11018 p += 4;
11019 }
11020 bfd_put_32 (htab->glink->owner,
11021 B_DOT | ((htab->glink->contents - p + 8) & 0x3fffffc), p);
11022 indx++;
11023 p += 4;
11024 }
11025 htab->glink->rawsize = p - htab->glink->contents;
11026 }
11027
11028 if (htab->brlt->size != 0)
11029 {
11030 htab->brlt->contents = bfd_zalloc (htab->brlt->owner,
11031 htab->brlt->size);
11032 if (htab->brlt->contents == NULL)
11033 return FALSE;
11034 }
11035 if (htab->relbrlt != NULL && htab->relbrlt->size != 0)
11036 {
11037 htab->relbrlt->contents = bfd_zalloc (htab->relbrlt->owner,
11038 htab->relbrlt->size);
11039 if (htab->relbrlt->contents == NULL)
11040 return FALSE;
11041 }
11042
11043 /* Build the stubs as directed by the stub hash table. */
11044 bfd_hash_traverse (&htab->stub_hash_table, ppc_build_one_stub, info);
11045
11046 if (htab->relbrlt != NULL)
11047 htab->relbrlt->reloc_count = 0;
11048
11049 for (stub_sec = htab->stub_bfd->sections;
11050 stub_sec != NULL;
11051 stub_sec = stub_sec->next)
11052 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
11053 {
11054 stub_sec_count += 1;
11055 if (stub_sec->rawsize != stub_sec->size)
11056 break;
11057 }
11058
11059 if (stub_sec != NULL
11060 || htab->glink->rawsize != htab->glink->size)
11061 {
11062 htab->stub_error = TRUE;
11063 (*_bfd_error_handler) (_("stubs don't match calculated size"));
11064 }
11065
11066 if (htab->stub_error)
11067 return FALSE;
11068
11069 if (stats != NULL)
11070 {
11071 *stats = bfd_malloc (500);
11072 if (*stats == NULL)
11073 return FALSE;
11074
11075 sprintf (*stats, _("linker stubs in %u group%s\n"
11076 " branch %lu\n"
11077 " toc adjust %lu\n"
11078 " long branch %lu\n"
11079 " long toc adj %lu\n"
11080 " plt call %lu"),
11081 stub_sec_count,
11082 stub_sec_count == 1 ? "" : "s",
11083 htab->stub_count[ppc_stub_long_branch - 1],
11084 htab->stub_count[ppc_stub_long_branch_r2off - 1],
11085 htab->stub_count[ppc_stub_plt_branch - 1],
11086 htab->stub_count[ppc_stub_plt_branch_r2off - 1],
11087 htab->stub_count[ppc_stub_plt_call - 1]);
11088 }
11089 return TRUE;
11090 }
11091
11092 /* This function undoes the changes made by add_symbol_adjust. */
11093
11094 static bfd_boolean
11095 undo_symbol_twiddle (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
11096 {
11097 struct ppc_link_hash_entry *eh;
11098
11099 if (h->root.type == bfd_link_hash_indirect)
11100 return TRUE;
11101
11102 if (h->root.type == bfd_link_hash_warning)
11103 h = (struct elf_link_hash_entry *) h->root.u.i.link;
11104
11105 eh = (struct ppc_link_hash_entry *) h;
11106 if (eh->elf.root.type != bfd_link_hash_undefweak || !eh->was_undefined)
11107 return TRUE;
11108
11109 eh->elf.root.type = bfd_link_hash_undefined;
11110 return TRUE;
11111 }
11112
11113 void
11114 ppc64_elf_restore_symbols (struct bfd_link_info *info)
11115 {
11116 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11117
11118 if (htab != NULL)
11119 elf_link_hash_traverse (&htab->elf, undo_symbol_twiddle, info);
11120 }
11121
11122 /* What to do when ld finds relocations against symbols defined in
11123 discarded sections. */
11124
11125 static unsigned int
11126 ppc64_elf_action_discarded (asection *sec)
11127 {
11128 if (strcmp (".opd", sec->name) == 0)
11129 return 0;
11130
11131 if (strcmp (".toc", sec->name) == 0)
11132 return 0;
11133
11134 if (strcmp (".toc1", sec->name) == 0)
11135 return 0;
11136
11137 return _bfd_elf_default_action_discarded (sec);
11138 }
11139
11140 /* The RELOCATE_SECTION function is called by the ELF backend linker
11141 to handle the relocations for a section.
11142
11143 The relocs are always passed as Rela structures; if the section
11144 actually uses Rel structures, the r_addend field will always be
11145 zero.
11146
11147 This function is responsible for adjust the section contents as
11148 necessary, and (if using Rela relocs and generating a
11149 relocatable output file) adjusting the reloc addend as
11150 necessary.
11151
11152 This function does not have to worry about setting the reloc
11153 address or the reloc symbol index.
11154
11155 LOCAL_SYMS is a pointer to the swapped in local symbols.
11156
11157 LOCAL_SECTIONS is an array giving the section in the input file
11158 corresponding to the st_shndx field of each local symbol.
11159
11160 The global hash table entry for the global symbols can be found
11161 via elf_sym_hashes (input_bfd).
11162
11163 When generating relocatable output, this function must handle
11164 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
11165 going to be the section symbol corresponding to the output
11166 section, which means that the addend must be adjusted
11167 accordingly. */
11168
11169 static bfd_boolean
11170 ppc64_elf_relocate_section (bfd *output_bfd,
11171 struct bfd_link_info *info,
11172 bfd *input_bfd,
11173 asection *input_section,
11174 bfd_byte *contents,
11175 Elf_Internal_Rela *relocs,
11176 Elf_Internal_Sym *local_syms,
11177 asection **local_sections)
11178 {
11179 struct ppc_link_hash_table *htab;
11180 Elf_Internal_Shdr *symtab_hdr;
11181 struct elf_link_hash_entry **sym_hashes;
11182 Elf_Internal_Rela *rel;
11183 Elf_Internal_Rela *relend;
11184 Elf_Internal_Rela outrel;
11185 bfd_byte *loc;
11186 struct got_entry **local_got_ents;
11187 bfd_vma TOCstart;
11188 bfd_boolean ret = TRUE;
11189 bfd_boolean is_opd;
11190 /* Disabled until we sort out how ld should choose 'y' vs 'at'. */
11191 bfd_boolean is_power4 = FALSE;
11192 bfd_vma d_offset = (bfd_big_endian (output_bfd) ? 2 : 0);
11193
11194 /* Initialize howto table if needed. */
11195 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
11196 ppc_howto_init ();
11197
11198 htab = ppc_hash_table (info);
11199 if (htab == NULL)
11200 return FALSE;
11201
11202 /* Don't relocate stub sections. */
11203 if (input_section->owner == htab->stub_bfd)
11204 return TRUE;
11205
11206 BFD_ASSERT (is_ppc64_elf (input_bfd));
11207
11208 local_got_ents = elf_local_got_ents (input_bfd);
11209 TOCstart = elf_gp (output_bfd);
11210 symtab_hdr = &elf_symtab_hdr (input_bfd);
11211 sym_hashes = elf_sym_hashes (input_bfd);
11212 is_opd = ppc64_elf_section_data (input_section)->sec_type == sec_opd;
11213
11214 rel = relocs;
11215 relend = relocs + input_section->reloc_count;
11216 for (; rel < relend; rel++)
11217 {
11218 enum elf_ppc64_reloc_type r_type;
11219 bfd_vma addend, orig_addend;
11220 bfd_reloc_status_type r;
11221 Elf_Internal_Sym *sym;
11222 asection *sec;
11223 struct elf_link_hash_entry *h_elf;
11224 struct ppc_link_hash_entry *h;
11225 struct ppc_link_hash_entry *fdh;
11226 const char *sym_name;
11227 unsigned long r_symndx, toc_symndx;
11228 bfd_vma toc_addend;
11229 char tls_mask, tls_gd, tls_type;
11230 char sym_type;
11231 bfd_vma relocation;
11232 bfd_boolean unresolved_reloc;
11233 bfd_boolean warned;
11234 unsigned long insn, mask;
11235 struct ppc_stub_hash_entry *stub_entry;
11236 bfd_vma max_br_offset;
11237 bfd_vma from;
11238
11239 r_type = ELF64_R_TYPE (rel->r_info);
11240 r_symndx = ELF64_R_SYM (rel->r_info);
11241
11242 /* For old style R_PPC64_TOC relocs with a zero symbol, use the
11243 symbol of the previous ADDR64 reloc. The symbol gives us the
11244 proper TOC base to use. */
11245 if (rel->r_info == ELF64_R_INFO (0, R_PPC64_TOC)
11246 && rel != relocs
11247 && ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_ADDR64
11248 && is_opd)
11249 r_symndx = ELF64_R_SYM (rel[-1].r_info);
11250
11251 sym = NULL;
11252 sec = NULL;
11253 h_elf = NULL;
11254 sym_name = NULL;
11255 unresolved_reloc = FALSE;
11256 warned = FALSE;
11257 orig_addend = rel->r_addend;
11258
11259 if (r_symndx < symtab_hdr->sh_info)
11260 {
11261 /* It's a local symbol. */
11262 struct _opd_sec_data *opd;
11263
11264 sym = local_syms + r_symndx;
11265 sec = local_sections[r_symndx];
11266 sym_name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym, sec);
11267 sym_type = ELF64_ST_TYPE (sym->st_info);
11268 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
11269 opd = get_opd_info (sec);
11270 if (opd != NULL && opd->adjust != NULL)
11271 {
11272 long adjust = opd->adjust[(sym->st_value + rel->r_addend) / 8];
11273 if (adjust == -1)
11274 relocation = 0;
11275 else
11276 {
11277 /* If this is a relocation against the opd section sym
11278 and we have edited .opd, adjust the reloc addend so
11279 that ld -r and ld --emit-relocs output is correct.
11280 If it is a reloc against some other .opd symbol,
11281 then the symbol value will be adjusted later. */
11282 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
11283 rel->r_addend += adjust;
11284 else
11285 relocation += adjust;
11286 }
11287 }
11288 }
11289 else
11290 {
11291 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
11292 r_symndx, symtab_hdr, sym_hashes,
11293 h_elf, sec, relocation,
11294 unresolved_reloc, warned);
11295 sym_name = h_elf->root.root.string;
11296 sym_type = h_elf->type;
11297 }
11298 h = (struct ppc_link_hash_entry *) h_elf;
11299
11300 if (sec != NULL && elf_discarded_section (sec))
11301 {
11302 /* For relocs against symbols from removed linkonce sections,
11303 or sections discarded by a linker script, we just want the
11304 section contents zeroed. Avoid any special processing. */
11305 _bfd_clear_contents (ppc64_elf_howto_table[r_type], input_bfd,
11306 contents + rel->r_offset);
11307 rel->r_info = 0;
11308 rel->r_addend = 0;
11309 continue;
11310 }
11311
11312 if (info->relocatable)
11313 continue;
11314
11315 /* TLS optimizations. Replace instruction sequences and relocs
11316 based on information we collected in tls_optimize. We edit
11317 RELOCS so that --emit-relocs will output something sensible
11318 for the final instruction stream. */
11319 tls_mask = 0;
11320 tls_gd = 0;
11321 toc_symndx = 0;
11322 if (h != NULL)
11323 tls_mask = h->tls_mask;
11324 else if (local_got_ents != NULL)
11325 {
11326 struct plt_entry **local_plt = (struct plt_entry **)
11327 (local_got_ents + symtab_hdr->sh_info);
11328 char *lgot_masks = (char *)
11329 (local_plt + symtab_hdr->sh_info);
11330 tls_mask = lgot_masks[r_symndx];
11331 }
11332 if (tls_mask == 0
11333 && (r_type == R_PPC64_TLS
11334 || r_type == R_PPC64_TLSGD
11335 || r_type == R_PPC64_TLSLD))
11336 {
11337 /* Check for toc tls entries. */
11338 char *toc_tls;
11339
11340 if (!get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
11341 &local_syms, rel, input_bfd))
11342 return FALSE;
11343
11344 if (toc_tls)
11345 tls_mask = *toc_tls;
11346 }
11347
11348 /* Check that tls relocs are used with tls syms, and non-tls
11349 relocs are used with non-tls syms. */
11350 if (r_symndx != 0
11351 && r_type != R_PPC64_NONE
11352 && (h == NULL
11353 || h->elf.root.type == bfd_link_hash_defined
11354 || h->elf.root.type == bfd_link_hash_defweak)
11355 && (IS_PPC64_TLS_RELOC (r_type)
11356 != (sym_type == STT_TLS
11357 || (sym_type == STT_SECTION
11358 && (sec->flags & SEC_THREAD_LOCAL) != 0))))
11359 {
11360 if (tls_mask != 0
11361 && (r_type == R_PPC64_TLS
11362 || r_type == R_PPC64_TLSGD
11363 || r_type == R_PPC64_TLSLD))
11364 /* R_PPC64_TLS is OK against a symbol in the TOC. */
11365 ;
11366 else
11367 (*_bfd_error_handler)
11368 (!IS_PPC64_TLS_RELOC (r_type)
11369 ? _("%B(%A+0x%lx): %s used with TLS symbol %s")
11370 : _("%B(%A+0x%lx): %s used with non-TLS symbol %s"),
11371 input_bfd,
11372 input_section,
11373 (long) rel->r_offset,
11374 ppc64_elf_howto_table[r_type]->name,
11375 sym_name);
11376 }
11377
11378 /* Ensure reloc mapping code below stays sane. */
11379 if (R_PPC64_TOC16_LO_DS != R_PPC64_TOC16_DS + 1
11380 || R_PPC64_TOC16_LO != R_PPC64_TOC16 + 1
11381 || (R_PPC64_GOT_TLSLD16 & 3) != (R_PPC64_GOT_TLSGD16 & 3)
11382 || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TLSGD16_LO & 3)
11383 || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TLSGD16_HI & 3)
11384 || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TLSGD16_HA & 3)
11385 || (R_PPC64_GOT_TLSLD16 & 3) != (R_PPC64_GOT_TPREL16_DS & 3)
11386 || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TPREL16_LO_DS & 3)
11387 || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TPREL16_HI & 3)
11388 || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TPREL16_HA & 3))
11389 abort ();
11390
11391 switch (r_type)
11392 {
11393 default:
11394 break;
11395
11396 case R_PPC64_TOC16:
11397 case R_PPC64_TOC16_LO:
11398 case R_PPC64_TOC16_DS:
11399 case R_PPC64_TOC16_LO_DS:
11400 {
11401 /* Check for toc tls entries. */
11402 char *toc_tls;
11403 int retval;
11404
11405 retval = get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
11406 &local_syms, rel, input_bfd);
11407 if (retval == 0)
11408 return FALSE;
11409
11410 if (toc_tls)
11411 {
11412 tls_mask = *toc_tls;
11413 if (r_type == R_PPC64_TOC16_DS
11414 || r_type == R_PPC64_TOC16_LO_DS)
11415 {
11416 if (tls_mask != 0
11417 && (tls_mask & (TLS_DTPREL | TLS_TPREL)) == 0)
11418 goto toctprel;
11419 }
11420 else
11421 {
11422 /* If we found a GD reloc pair, then we might be
11423 doing a GD->IE transition. */
11424 if (retval == 2)
11425 {
11426 tls_gd = TLS_TPRELGD;
11427 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
11428 goto tls_ldgd_opt;
11429 }
11430 else if (retval == 3)
11431 {
11432 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
11433 goto tls_ldgd_opt;
11434 }
11435 }
11436 }
11437 }
11438 break;
11439
11440 case R_PPC64_GOT_TPREL16_DS:
11441 case R_PPC64_GOT_TPREL16_LO_DS:
11442 if (tls_mask != 0
11443 && (tls_mask & TLS_TPREL) == 0)
11444 {
11445 toctprel:
11446 insn = bfd_get_32 (output_bfd, contents + rel->r_offset - d_offset);
11447 insn &= 31 << 21;
11448 insn |= 0x3c0d0000; /* addis 0,13,0 */
11449 bfd_put_32 (output_bfd, insn, contents + rel->r_offset - d_offset);
11450 r_type = R_PPC64_TPREL16_HA;
11451 if (toc_symndx != 0)
11452 {
11453 rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
11454 rel->r_addend = toc_addend;
11455 /* We changed the symbol. Start over in order to
11456 get h, sym, sec etc. right. */
11457 rel--;
11458 continue;
11459 }
11460 else
11461 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
11462 }
11463 break;
11464
11465 case R_PPC64_TLS:
11466 if (tls_mask != 0
11467 && (tls_mask & TLS_TPREL) == 0)
11468 {
11469 insn = bfd_get_32 (output_bfd, contents + rel->r_offset);
11470 insn = _bfd_elf_ppc_at_tls_transform (insn, 13);
11471 if (insn == 0)
11472 abort ();
11473 bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
11474 /* Was PPC64_TLS which sits on insn boundary, now
11475 PPC64_TPREL16_LO which is at low-order half-word. */
11476 rel->r_offset += d_offset;
11477 r_type = R_PPC64_TPREL16_LO;
11478 if (toc_symndx != 0)
11479 {
11480 rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
11481 rel->r_addend = toc_addend;
11482 /* We changed the symbol. Start over in order to
11483 get h, sym, sec etc. right. */
11484 rel--;
11485 continue;
11486 }
11487 else
11488 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
11489 }
11490 break;
11491
11492 case R_PPC64_GOT_TLSGD16_HI:
11493 case R_PPC64_GOT_TLSGD16_HA:
11494 tls_gd = TLS_TPRELGD;
11495 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
11496 goto tls_gdld_hi;
11497 break;
11498
11499 case R_PPC64_GOT_TLSLD16_HI:
11500 case R_PPC64_GOT_TLSLD16_HA:
11501 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
11502 {
11503 tls_gdld_hi:
11504 if ((tls_mask & tls_gd) != 0)
11505 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
11506 + R_PPC64_GOT_TPREL16_DS);
11507 else
11508 {
11509 bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
11510 rel->r_offset -= d_offset;
11511 r_type = R_PPC64_NONE;
11512 }
11513 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
11514 }
11515 break;
11516
11517 case R_PPC64_GOT_TLSGD16:
11518 case R_PPC64_GOT_TLSGD16_LO:
11519 tls_gd = TLS_TPRELGD;
11520 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
11521 goto tls_ldgd_opt;
11522 break;
11523
11524 case R_PPC64_GOT_TLSLD16:
11525 case R_PPC64_GOT_TLSLD16_LO:
11526 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
11527 {
11528 unsigned int insn1, insn2, insn3;
11529 bfd_vma offset;
11530
11531 tls_ldgd_opt:
11532 offset = (bfd_vma) -1;
11533 /* If not using the newer R_PPC64_TLSGD/LD to mark
11534 __tls_get_addr calls, we must trust that the call
11535 stays with its arg setup insns, ie. that the next
11536 reloc is the __tls_get_addr call associated with
11537 the current reloc. Edit both insns. */
11538 if (input_section->has_tls_get_addr_call
11539 && rel + 1 < relend
11540 && branch_reloc_hash_match (input_bfd, rel + 1,
11541 htab->tls_get_addr,
11542 htab->tls_get_addr_fd))
11543 offset = rel[1].r_offset;
11544 if ((tls_mask & tls_gd) != 0)
11545 {
11546 /* IE */
11547 insn1 = bfd_get_32 (output_bfd,
11548 contents + rel->r_offset - d_offset);
11549 insn1 &= (1 << 26) - (1 << 2);
11550 insn1 |= 58 << 26; /* ld */
11551 insn2 = 0x7c636a14; /* add 3,3,13 */
11552 if (offset != (bfd_vma) -1)
11553 rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
11554 if ((tls_mask & TLS_EXPLICIT) == 0)
11555 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
11556 + R_PPC64_GOT_TPREL16_DS);
11557 else
11558 r_type += R_PPC64_TOC16_DS - R_PPC64_TOC16;
11559 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
11560 }
11561 else
11562 {
11563 /* LE */
11564 insn1 = 0x3c6d0000; /* addis 3,13,0 */
11565 insn2 = 0x38630000; /* addi 3,3,0 */
11566 if (tls_gd == 0)
11567 {
11568 /* Was an LD reloc. */
11569 if (toc_symndx)
11570 sec = local_sections[toc_symndx];
11571 for (r_symndx = 0;
11572 r_symndx < symtab_hdr->sh_info;
11573 r_symndx++)
11574 if (local_sections[r_symndx] == sec)
11575 break;
11576 if (r_symndx >= symtab_hdr->sh_info)
11577 r_symndx = 0;
11578 rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
11579 if (r_symndx != 0)
11580 rel->r_addend -= (local_syms[r_symndx].st_value
11581 + sec->output_offset
11582 + sec->output_section->vma);
11583 }
11584 else if (toc_symndx != 0)
11585 {
11586 r_symndx = toc_symndx;
11587 rel->r_addend = toc_addend;
11588 }
11589 r_type = R_PPC64_TPREL16_HA;
11590 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
11591 if (offset != (bfd_vma) -1)
11592 {
11593 rel[1].r_info = ELF64_R_INFO (r_symndx,
11594 R_PPC64_TPREL16_LO);
11595 rel[1].r_offset = offset + d_offset;
11596 rel[1].r_addend = rel->r_addend;
11597 }
11598 }
11599 bfd_put_32 (output_bfd, insn1,
11600 contents + rel->r_offset - d_offset);
11601 if (offset != (bfd_vma) -1)
11602 {
11603 insn3 = bfd_get_32 (output_bfd,
11604 contents + offset + 4);
11605 if (insn3 == NOP
11606 || insn3 == CROR_151515 || insn3 == CROR_313131)
11607 {
11608 rel[1].r_offset += 4;
11609 bfd_put_32 (output_bfd, insn2, contents + offset + 4);
11610 insn2 = NOP;
11611 }
11612 bfd_put_32 (output_bfd, insn2, contents + offset);
11613 }
11614 if ((tls_mask & tls_gd) == 0
11615 && (tls_gd == 0 || toc_symndx != 0))
11616 {
11617 /* We changed the symbol. Start over in order
11618 to get h, sym, sec etc. right. */
11619 rel--;
11620 continue;
11621 }
11622 }
11623 break;
11624
11625 case R_PPC64_TLSGD:
11626 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
11627 {
11628 unsigned int insn2, insn3;
11629 bfd_vma offset = rel->r_offset;
11630
11631 if ((tls_mask & TLS_TPRELGD) != 0)
11632 {
11633 /* IE */
11634 r_type = R_PPC64_NONE;
11635 insn2 = 0x7c636a14; /* add 3,3,13 */
11636 }
11637 else
11638 {
11639 /* LE */
11640 if (toc_symndx != 0)
11641 {
11642 r_symndx = toc_symndx;
11643 rel->r_addend = toc_addend;
11644 }
11645 r_type = R_PPC64_TPREL16_LO;
11646 rel->r_offset = offset + d_offset;
11647 insn2 = 0x38630000; /* addi 3,3,0 */
11648 }
11649 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
11650 /* Zap the reloc on the _tls_get_addr call too. */
11651 BFD_ASSERT (offset == rel[1].r_offset);
11652 rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
11653 insn3 = bfd_get_32 (output_bfd,
11654 contents + offset + 4);
11655 if (insn3 == NOP
11656 || insn3 == CROR_151515 || insn3 == CROR_313131)
11657 {
11658 rel->r_offset += 4;
11659 bfd_put_32 (output_bfd, insn2, contents + offset + 4);
11660 insn2 = NOP;
11661 }
11662 bfd_put_32 (output_bfd, insn2, contents + offset);
11663 if ((tls_mask & TLS_TPRELGD) == 0 && toc_symndx != 0)
11664 {
11665 rel--;
11666 continue;
11667 }
11668 }
11669 break;
11670
11671 case R_PPC64_TLSLD:
11672 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
11673 {
11674 unsigned int insn2, insn3;
11675 bfd_vma offset = rel->r_offset;
11676
11677 if (toc_symndx)
11678 sec = local_sections[toc_symndx];
11679 for (r_symndx = 0;
11680 r_symndx < symtab_hdr->sh_info;
11681 r_symndx++)
11682 if (local_sections[r_symndx] == sec)
11683 break;
11684 if (r_symndx >= symtab_hdr->sh_info)
11685 r_symndx = 0;
11686 rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
11687 if (r_symndx != 0)
11688 rel->r_addend -= (local_syms[r_symndx].st_value
11689 + sec->output_offset
11690 + sec->output_section->vma);
11691
11692 r_type = R_PPC64_TPREL16_LO;
11693 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
11694 rel->r_offset = offset + d_offset;
11695 /* Zap the reloc on the _tls_get_addr call too. */
11696 BFD_ASSERT (offset == rel[1].r_offset);
11697 rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
11698 insn2 = 0x38630000; /* addi 3,3,0 */
11699 insn3 = bfd_get_32 (output_bfd,
11700 contents + offset + 4);
11701 if (insn3 == NOP
11702 || insn3 == CROR_151515 || insn3 == CROR_313131)
11703 {
11704 rel->r_offset += 4;
11705 bfd_put_32 (output_bfd, insn2, contents + offset + 4);
11706 insn2 = NOP;
11707 }
11708 bfd_put_32 (output_bfd, insn2, contents + offset);
11709 rel--;
11710 continue;
11711 }
11712 break;
11713
11714 case R_PPC64_DTPMOD64:
11715 if (rel + 1 < relend
11716 && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
11717 && rel[1].r_offset == rel->r_offset + 8)
11718 {
11719 if ((tls_mask & TLS_GD) == 0)
11720 {
11721 rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_NONE);
11722 if ((tls_mask & TLS_TPRELGD) != 0)
11723 r_type = R_PPC64_TPREL64;
11724 else
11725 {
11726 bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
11727 r_type = R_PPC64_NONE;
11728 }
11729 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
11730 }
11731 }
11732 else
11733 {
11734 if ((tls_mask & TLS_LD) == 0)
11735 {
11736 bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
11737 r_type = R_PPC64_NONE;
11738 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
11739 }
11740 }
11741 break;
11742
11743 case R_PPC64_TPREL64:
11744 if ((tls_mask & TLS_TPREL) == 0)
11745 {
11746 r_type = R_PPC64_NONE;
11747 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
11748 }
11749 break;
11750 }
11751
11752 /* Handle other relocations that tweak non-addend part of insn. */
11753 insn = 0;
11754 max_br_offset = 1 << 25;
11755 addend = rel->r_addend;
11756 switch (r_type)
11757 {
11758 default:
11759 break;
11760
11761 /* Branch taken prediction relocations. */
11762 case R_PPC64_ADDR14_BRTAKEN:
11763 case R_PPC64_REL14_BRTAKEN:
11764 insn = 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field. */
11765 /* Fall thru. */
11766
11767 /* Branch not taken prediction relocations. */
11768 case R_PPC64_ADDR14_BRNTAKEN:
11769 case R_PPC64_REL14_BRNTAKEN:
11770 insn |= bfd_get_32 (output_bfd,
11771 contents + rel->r_offset) & ~(0x01 << 21);
11772 /* Fall thru. */
11773
11774 case R_PPC64_REL14:
11775 max_br_offset = 1 << 15;
11776 /* Fall thru. */
11777
11778 case R_PPC64_REL24:
11779 /* Calls to functions with a different TOC, such as calls to
11780 shared objects, need to alter the TOC pointer. This is
11781 done using a linkage stub. A REL24 branching to these
11782 linkage stubs needs to be followed by a nop, as the nop
11783 will be replaced with an instruction to restore the TOC
11784 base pointer. */
11785 stub_entry = NULL;
11786 fdh = h;
11787 if (h != NULL
11788 && h->oh != NULL
11789 && h->oh->is_func_descriptor)
11790 fdh = ppc_follow_link (h->oh);
11791 if (((fdh != NULL
11792 && fdh->elf.plt.plist != NULL)
11793 || (sec != NULL
11794 && sec->output_section != NULL
11795 && sec->id <= htab->top_id
11796 && (htab->stub_group[sec->id].toc_off
11797 != htab->stub_group[input_section->id].toc_off))
11798 || (h == NULL
11799 && ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
11800 && (stub_entry = ppc_get_stub_entry (input_section, sec, fdh,
11801 rel, htab)) != NULL
11802 && (stub_entry->stub_type == ppc_stub_plt_call
11803 || stub_entry->stub_type == ppc_stub_plt_branch_r2off
11804 || stub_entry->stub_type == ppc_stub_long_branch_r2off))
11805 {
11806 bfd_boolean can_plt_call = FALSE;
11807
11808 if (rel->r_offset + 8 <= input_section->size)
11809 {
11810 unsigned long nop;
11811 nop = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
11812 if (nop == NOP
11813 || nop == CROR_151515 || nop == CROR_313131)
11814 {
11815 if (h != NULL
11816 && (h == htab->tls_get_addr_fd
11817 || h == htab->tls_get_addr)
11818 && !htab->no_tls_get_addr_opt)
11819 {
11820 /* Special stub used, leave nop alone. */
11821 }
11822 else
11823 bfd_put_32 (input_bfd, LD_R2_40R1,
11824 contents + rel->r_offset + 4);
11825 can_plt_call = TRUE;
11826 }
11827 }
11828
11829 if (!can_plt_call)
11830 {
11831 if (stub_entry->stub_type == ppc_stub_plt_call)
11832 {
11833 /* If this is a plain branch rather than a branch
11834 and link, don't require a nop. However, don't
11835 allow tail calls in a shared library as they
11836 will result in r2 being corrupted. */
11837 unsigned long br;
11838 br = bfd_get_32 (input_bfd, contents + rel->r_offset);
11839 if (info->executable && (br & 1) == 0)
11840 can_plt_call = TRUE;
11841 else
11842 stub_entry = NULL;
11843 }
11844 else if (h != NULL
11845 && strcmp (h->elf.root.root.string,
11846 ".__libc_start_main") == 0)
11847 {
11848 /* Allow crt1 branch to go via a toc adjusting stub. */
11849 can_plt_call = TRUE;
11850 }
11851 else
11852 {
11853 if (strcmp (input_section->output_section->name,
11854 ".init") == 0
11855 || strcmp (input_section->output_section->name,
11856 ".fini") == 0)
11857 (*_bfd_error_handler)
11858 (_("%B(%A+0x%lx): automatic multiple TOCs "
11859 "not supported using your crt files; "
11860 "recompile with -mminimal-toc or upgrade gcc"),
11861 input_bfd,
11862 input_section,
11863 (long) rel->r_offset);
11864 else
11865 (*_bfd_error_handler)
11866 (_("%B(%A+0x%lx): sibling call optimization to `%s' "
11867 "does not allow automatic multiple TOCs; "
11868 "recompile with -mminimal-toc or "
11869 "-fno-optimize-sibling-calls, "
11870 "or make `%s' extern"),
11871 input_bfd,
11872 input_section,
11873 (long) rel->r_offset,
11874 sym_name,
11875 sym_name);
11876 bfd_set_error (bfd_error_bad_value);
11877 ret = FALSE;
11878 }
11879 }
11880
11881 if (can_plt_call
11882 && stub_entry->stub_type == ppc_stub_plt_call)
11883 unresolved_reloc = FALSE;
11884 }
11885
11886 if (stub_entry == NULL
11887 && get_opd_info (sec) != NULL)
11888 {
11889 /* The branch destination is the value of the opd entry. */
11890 bfd_vma off = (relocation + addend
11891 - sec->output_section->vma
11892 - sec->output_offset);
11893 bfd_vma dest = opd_entry_value (sec, off, NULL, NULL);
11894 if (dest != (bfd_vma) -1)
11895 {
11896 relocation = dest;
11897 addend = 0;
11898 }
11899 }
11900
11901 /* If the branch is out of reach we ought to have a long
11902 branch stub. */
11903 from = (rel->r_offset
11904 + input_section->output_offset
11905 + input_section->output_section->vma);
11906
11907 if (stub_entry == NULL
11908 && (relocation + addend - from + max_br_offset
11909 >= 2 * max_br_offset)
11910 && r_type != R_PPC64_ADDR14_BRTAKEN
11911 && r_type != R_PPC64_ADDR14_BRNTAKEN)
11912 stub_entry = ppc_get_stub_entry (input_section, sec, h, rel,
11913 htab);
11914
11915 if (stub_entry != NULL)
11916 {
11917 /* Munge up the value and addend so that we call the stub
11918 rather than the procedure directly. */
11919 relocation = (stub_entry->stub_offset
11920 + stub_entry->stub_sec->output_offset
11921 + stub_entry->stub_sec->output_section->vma);
11922 addend = 0;
11923 }
11924
11925 if (insn != 0)
11926 {
11927 if (is_power4)
11928 {
11929 /* Set 'a' bit. This is 0b00010 in BO field for branch
11930 on CR(BI) insns (BO == 001at or 011at), and 0b01000
11931 for branch on CTR insns (BO == 1a00t or 1a01t). */
11932 if ((insn & (0x14 << 21)) == (0x04 << 21))
11933 insn |= 0x02 << 21;
11934 else if ((insn & (0x14 << 21)) == (0x10 << 21))
11935 insn |= 0x08 << 21;
11936 else
11937 break;
11938 }
11939 else
11940 {
11941 /* Invert 'y' bit if not the default. */
11942 if ((bfd_signed_vma) (relocation + addend - from) < 0)
11943 insn ^= 0x01 << 21;
11944 }
11945
11946 bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
11947 }
11948
11949 /* NOP out calls to undefined weak functions.
11950 We can thus call a weak function without first
11951 checking whether the function is defined. */
11952 else if (h != NULL
11953 && h->elf.root.type == bfd_link_hash_undefweak
11954 && h->elf.dynindx == -1
11955 && r_type == R_PPC64_REL24
11956 && relocation == 0
11957 && addend == 0)
11958 {
11959 bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
11960 continue;
11961 }
11962 break;
11963 }
11964
11965 /* Set `addend'. */
11966 tls_type = 0;
11967 switch (r_type)
11968 {
11969 default:
11970 (*_bfd_error_handler)
11971 (_("%B: unknown relocation type %d for symbol %s"),
11972 input_bfd, (int) r_type, sym_name);
11973
11974 bfd_set_error (bfd_error_bad_value);
11975 ret = FALSE;
11976 continue;
11977
11978 case R_PPC64_NONE:
11979 case R_PPC64_TLS:
11980 case R_PPC64_TLSGD:
11981 case R_PPC64_TLSLD:
11982 case R_PPC64_GNU_VTINHERIT:
11983 case R_PPC64_GNU_VTENTRY:
11984 continue;
11985
11986 /* GOT16 relocations. Like an ADDR16 using the symbol's
11987 address in the GOT as relocation value instead of the
11988 symbol's value itself. Also, create a GOT entry for the
11989 symbol and put the symbol value there. */
11990 case R_PPC64_GOT_TLSGD16:
11991 case R_PPC64_GOT_TLSGD16_LO:
11992 case R_PPC64_GOT_TLSGD16_HI:
11993 case R_PPC64_GOT_TLSGD16_HA:
11994 tls_type = TLS_TLS | TLS_GD;
11995 goto dogot;
11996
11997 case R_PPC64_GOT_TLSLD16:
11998 case R_PPC64_GOT_TLSLD16_LO:
11999 case R_PPC64_GOT_TLSLD16_HI:
12000 case R_PPC64_GOT_TLSLD16_HA:
12001 tls_type = TLS_TLS | TLS_LD;
12002 goto dogot;
12003
12004 case R_PPC64_GOT_TPREL16_DS:
12005 case R_PPC64_GOT_TPREL16_LO_DS:
12006 case R_PPC64_GOT_TPREL16_HI:
12007 case R_PPC64_GOT_TPREL16_HA:
12008 tls_type = TLS_TLS | TLS_TPREL;
12009 goto dogot;
12010
12011 case R_PPC64_GOT_DTPREL16_DS:
12012 case R_PPC64_GOT_DTPREL16_LO_DS:
12013 case R_PPC64_GOT_DTPREL16_HI:
12014 case R_PPC64_GOT_DTPREL16_HA:
12015 tls_type = TLS_TLS | TLS_DTPREL;
12016 goto dogot;
12017
12018 case R_PPC64_GOT16:
12019 case R_PPC64_GOT16_LO:
12020 case R_PPC64_GOT16_HI:
12021 case R_PPC64_GOT16_HA:
12022 case R_PPC64_GOT16_DS:
12023 case R_PPC64_GOT16_LO_DS:
12024 dogot:
12025 {
12026 /* Relocation is to the entry for this symbol in the global
12027 offset table. */
12028 asection *got;
12029 bfd_vma *offp;
12030 bfd_vma off;
12031 unsigned long indx = 0;
12032 struct got_entry *ent;
12033
12034 if (tls_type == (TLS_TLS | TLS_LD)
12035 && (h == NULL
12036 || !h->elf.def_dynamic))
12037 ent = ppc64_tlsld_got (input_bfd);
12038 else
12039 {
12040
12041 if (h != NULL)
12042 {
12043 bfd_boolean dyn = htab->elf.dynamic_sections_created;
12044 if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared,
12045 &h->elf)
12046 || (info->shared
12047 && SYMBOL_REFERENCES_LOCAL (info, &h->elf)))
12048 /* This is actually a static link, or it is a
12049 -Bsymbolic link and the symbol is defined
12050 locally, or the symbol was forced to be local
12051 because of a version file. */
12052 ;
12053 else
12054 {
12055 indx = h->elf.dynindx;
12056 unresolved_reloc = FALSE;
12057 }
12058 ent = h->elf.got.glist;
12059 }
12060 else
12061 {
12062 if (local_got_ents == NULL)
12063 abort ();
12064 ent = local_got_ents[r_symndx];
12065 }
12066
12067 for (; ent != NULL; ent = ent->next)
12068 if (ent->addend == orig_addend
12069 && ent->owner == input_bfd
12070 && ent->tls_type == tls_type)
12071 break;
12072 }
12073
12074 if (ent == NULL)
12075 abort ();
12076 if (ent->is_indirect)
12077 ent = ent->got.ent;
12078 offp = &ent->got.offset;
12079 got = ppc64_elf_tdata (ent->owner)->got;
12080 if (got == NULL)
12081 abort ();
12082
12083 /* The offset must always be a multiple of 8. We use the
12084 least significant bit to record whether we have already
12085 processed this entry. */
12086 off = *offp;
12087 if ((off & 1) != 0)
12088 off &= ~1;
12089 else
12090 {
12091 /* Generate relocs for the dynamic linker, except in
12092 the case of TLSLD where we'll use one entry per
12093 module. */
12094 asection *relgot;
12095 bfd_boolean ifunc;
12096
12097 *offp = off | 1;
12098 relgot = NULL;
12099 ifunc = (h != NULL
12100 ? h->elf.type == STT_GNU_IFUNC
12101 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC);
12102 if ((info->shared || indx != 0)
12103 && (h == NULL
12104 || (tls_type == (TLS_TLS | TLS_LD)
12105 && !h->elf.def_dynamic)
12106 || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
12107 || h->elf.root.type != bfd_link_hash_undefweak))
12108 relgot = ppc64_elf_tdata (ent->owner)->relgot;
12109 else if (ifunc)
12110 relgot = htab->reliplt;
12111 if (relgot != NULL)
12112 {
12113 outrel.r_offset = (got->output_section->vma
12114 + got->output_offset
12115 + off);
12116 outrel.r_addend = addend;
12117 if (tls_type & (TLS_LD | TLS_GD))
12118 {
12119 outrel.r_addend = 0;
12120 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPMOD64);
12121 if (tls_type == (TLS_TLS | TLS_GD))
12122 {
12123 loc = relgot->contents;
12124 loc += (relgot->reloc_count++
12125 * sizeof (Elf64_External_Rela));
12126 bfd_elf64_swap_reloca_out (output_bfd,
12127 &outrel, loc);
12128 outrel.r_offset += 8;
12129 outrel.r_addend = addend;
12130 outrel.r_info
12131 = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
12132 }
12133 }
12134 else if (tls_type == (TLS_TLS | TLS_DTPREL))
12135 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
12136 else if (tls_type == (TLS_TLS | TLS_TPREL))
12137 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_TPREL64);
12138 else if (indx != 0)
12139 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_GLOB_DAT);
12140 else
12141 {
12142 if (ifunc)
12143 outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
12144 else
12145 outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
12146
12147 /* Write the .got section contents for the sake
12148 of prelink. */
12149 loc = got->contents + off;
12150 bfd_put_64 (output_bfd, outrel.r_addend + relocation,
12151 loc);
12152 }
12153
12154 if (indx == 0 && tls_type != (TLS_TLS | TLS_LD))
12155 {
12156 outrel.r_addend += relocation;
12157 if (tls_type & (TLS_GD | TLS_DTPREL | TLS_TPREL))
12158 outrel.r_addend -= htab->elf.tls_sec->vma;
12159 }
12160 loc = relgot->contents;
12161 loc += (relgot->reloc_count++
12162 * sizeof (Elf64_External_Rela));
12163 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
12164 }
12165
12166 /* Init the .got section contents here if we're not
12167 emitting a reloc. */
12168 else
12169 {
12170 relocation += addend;
12171 if (tls_type == (TLS_TLS | TLS_LD))
12172 relocation = 1;
12173 else if (tls_type != 0)
12174 {
12175 relocation -= htab->elf.tls_sec->vma + DTP_OFFSET;
12176 if (tls_type == (TLS_TLS | TLS_TPREL))
12177 relocation += DTP_OFFSET - TP_OFFSET;
12178
12179 if (tls_type == (TLS_TLS | TLS_GD))
12180 {
12181 bfd_put_64 (output_bfd, relocation,
12182 got->contents + off + 8);
12183 relocation = 1;
12184 }
12185 }
12186
12187 bfd_put_64 (output_bfd, relocation,
12188 got->contents + off);
12189 }
12190 }
12191
12192 if (off >= (bfd_vma) -2)
12193 abort ();
12194
12195 relocation = got->output_section->vma + got->output_offset + off;
12196 addend = -(TOCstart + htab->stub_group[input_section->id].toc_off);
12197 }
12198 break;
12199
12200 case R_PPC64_PLT16_HA:
12201 case R_PPC64_PLT16_HI:
12202 case R_PPC64_PLT16_LO:
12203 case R_PPC64_PLT32:
12204 case R_PPC64_PLT64:
12205 /* Relocation is to the entry for this symbol in the
12206 procedure linkage table. */
12207
12208 /* Resolve a PLT reloc against a local symbol directly,
12209 without using the procedure linkage table. */
12210 if (h == NULL)
12211 break;
12212
12213 /* It's possible that we didn't make a PLT entry for this
12214 symbol. This happens when statically linking PIC code,
12215 or when using -Bsymbolic. Go find a match if there is a
12216 PLT entry. */
12217 if (htab->plt != NULL)
12218 {
12219 struct plt_entry *ent;
12220 for (ent = h->elf.plt.plist; ent != NULL; ent = ent->next)
12221 if (ent->addend == orig_addend
12222 && ent->plt.offset != (bfd_vma) -1)
12223 {
12224 relocation = (htab->plt->output_section->vma
12225 + htab->plt->output_offset
12226 + ent->plt.offset);
12227 unresolved_reloc = FALSE;
12228 }
12229 }
12230 break;
12231
12232 case R_PPC64_TOC:
12233 /* Relocation value is TOC base. */
12234 relocation = TOCstart;
12235 if (r_symndx == 0)
12236 relocation += htab->stub_group[input_section->id].toc_off;
12237 else if (unresolved_reloc)
12238 ;
12239 else if (sec != NULL && sec->id <= htab->top_id)
12240 relocation += htab->stub_group[sec->id].toc_off;
12241 else
12242 unresolved_reloc = TRUE;
12243 goto dodyn;
12244
12245 /* TOC16 relocs. We want the offset relative to the TOC base,
12246 which is the address of the start of the TOC plus 0x8000.
12247 The TOC consists of sections .got, .toc, .tocbss, and .plt,
12248 in this order. */
12249 case R_PPC64_TOC16:
12250 case R_PPC64_TOC16_LO:
12251 case R_PPC64_TOC16_HI:
12252 case R_PPC64_TOC16_DS:
12253 case R_PPC64_TOC16_LO_DS:
12254 case R_PPC64_TOC16_HA:
12255 addend -= TOCstart + htab->stub_group[input_section->id].toc_off;
12256 break;
12257
12258 /* Relocate against the beginning of the section. */
12259 case R_PPC64_SECTOFF:
12260 case R_PPC64_SECTOFF_LO:
12261 case R_PPC64_SECTOFF_HI:
12262 case R_PPC64_SECTOFF_DS:
12263 case R_PPC64_SECTOFF_LO_DS:
12264 case R_PPC64_SECTOFF_HA:
12265 if (sec != NULL)
12266 addend -= sec->output_section->vma;
12267 break;
12268
12269 case R_PPC64_REL16:
12270 case R_PPC64_REL16_LO:
12271 case R_PPC64_REL16_HI:
12272 case R_PPC64_REL16_HA:
12273 break;
12274
12275 case R_PPC64_REL14:
12276 case R_PPC64_REL14_BRNTAKEN:
12277 case R_PPC64_REL14_BRTAKEN:
12278 case R_PPC64_REL24:
12279 break;
12280
12281 case R_PPC64_TPREL16:
12282 case R_PPC64_TPREL16_LO:
12283 case R_PPC64_TPREL16_HI:
12284 case R_PPC64_TPREL16_HA:
12285 case R_PPC64_TPREL16_DS:
12286 case R_PPC64_TPREL16_LO_DS:
12287 case R_PPC64_TPREL16_HIGHER:
12288 case R_PPC64_TPREL16_HIGHERA:
12289 case R_PPC64_TPREL16_HIGHEST:
12290 case R_PPC64_TPREL16_HIGHESTA:
12291 if (h != NULL
12292 && h->elf.root.type == bfd_link_hash_undefweak
12293 && h->elf.dynindx == -1)
12294 {
12295 /* Make this relocation against an undefined weak symbol
12296 resolve to zero. This is really just a tweak, since
12297 code using weak externs ought to check that they are
12298 defined before using them. */
12299 bfd_byte *p = contents + rel->r_offset - d_offset;
12300
12301 insn = bfd_get_32 (output_bfd, p);
12302 insn = _bfd_elf_ppc_at_tprel_transform (insn, 13);
12303 if (insn != 0)
12304 bfd_put_32 (output_bfd, insn, p);
12305 break;
12306 }
12307 addend -= htab->elf.tls_sec->vma + TP_OFFSET;
12308 if (info->shared)
12309 /* The TPREL16 relocs shouldn't really be used in shared
12310 libs as they will result in DT_TEXTREL being set, but
12311 support them anyway. */
12312 goto dodyn;
12313 break;
12314
12315 case R_PPC64_DTPREL16:
12316 case R_PPC64_DTPREL16_LO:
12317 case R_PPC64_DTPREL16_HI:
12318 case R_PPC64_DTPREL16_HA:
12319 case R_PPC64_DTPREL16_DS:
12320 case R_PPC64_DTPREL16_LO_DS:
12321 case R_PPC64_DTPREL16_HIGHER:
12322 case R_PPC64_DTPREL16_HIGHERA:
12323 case R_PPC64_DTPREL16_HIGHEST:
12324 case R_PPC64_DTPREL16_HIGHESTA:
12325 addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
12326 break;
12327
12328 case R_PPC64_DTPMOD64:
12329 relocation = 1;
12330 addend = 0;
12331 goto dodyn;
12332
12333 case R_PPC64_TPREL64:
12334 addend -= htab->elf.tls_sec->vma + TP_OFFSET;
12335 goto dodyn;
12336
12337 case R_PPC64_DTPREL64:
12338 addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
12339 /* Fall thru */
12340
12341 /* Relocations that may need to be propagated if this is a
12342 dynamic object. */
12343 case R_PPC64_REL30:
12344 case R_PPC64_REL32:
12345 case R_PPC64_REL64:
12346 case R_PPC64_ADDR14:
12347 case R_PPC64_ADDR14_BRNTAKEN:
12348 case R_PPC64_ADDR14_BRTAKEN:
12349 case R_PPC64_ADDR16:
12350 case R_PPC64_ADDR16_DS:
12351 case R_PPC64_ADDR16_HA:
12352 case R_PPC64_ADDR16_HI:
12353 case R_PPC64_ADDR16_HIGHER:
12354 case R_PPC64_ADDR16_HIGHERA:
12355 case R_PPC64_ADDR16_HIGHEST:
12356 case R_PPC64_ADDR16_HIGHESTA:
12357 case R_PPC64_ADDR16_LO:
12358 case R_PPC64_ADDR16_LO_DS:
12359 case R_PPC64_ADDR24:
12360 case R_PPC64_ADDR32:
12361 case R_PPC64_ADDR64:
12362 case R_PPC64_UADDR16:
12363 case R_PPC64_UADDR32:
12364 case R_PPC64_UADDR64:
12365 dodyn:
12366 if ((input_section->flags & SEC_ALLOC) == 0)
12367 break;
12368
12369 if (NO_OPD_RELOCS && is_opd)
12370 break;
12371
12372 if ((info->shared
12373 && (h == NULL
12374 || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
12375 || h->elf.root.type != bfd_link_hash_undefweak)
12376 && (must_be_dyn_reloc (info, r_type)
12377 || !SYMBOL_CALLS_LOCAL (info, &h->elf)))
12378 || (ELIMINATE_COPY_RELOCS
12379 && !info->shared
12380 && h != NULL
12381 && h->elf.dynindx != -1
12382 && !h->elf.non_got_ref
12383 && !h->elf.def_regular)
12384 || (!info->shared
12385 && (h != NULL
12386 ? h->elf.type == STT_GNU_IFUNC
12387 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)))
12388 {
12389 bfd_boolean skip, relocate;
12390 asection *sreloc;
12391 bfd_vma out_off;
12392
12393 /* When generating a dynamic object, these relocations
12394 are copied into the output file to be resolved at run
12395 time. */
12396
12397 skip = FALSE;
12398 relocate = FALSE;
12399
12400 out_off = _bfd_elf_section_offset (output_bfd, info,
12401 input_section, rel->r_offset);
12402 if (out_off == (bfd_vma) -1)
12403 skip = TRUE;
12404 else if (out_off == (bfd_vma) -2)
12405 skip = TRUE, relocate = TRUE;
12406 out_off += (input_section->output_section->vma
12407 + input_section->output_offset);
12408 outrel.r_offset = out_off;
12409 outrel.r_addend = rel->r_addend;
12410
12411 /* Optimize unaligned reloc use. */
12412 if ((r_type == R_PPC64_ADDR64 && (out_off & 7) != 0)
12413 || (r_type == R_PPC64_UADDR64 && (out_off & 7) == 0))
12414 r_type ^= R_PPC64_ADDR64 ^ R_PPC64_UADDR64;
12415 else if ((r_type == R_PPC64_ADDR32 && (out_off & 3) != 0)
12416 || (r_type == R_PPC64_UADDR32 && (out_off & 3) == 0))
12417 r_type ^= R_PPC64_ADDR32 ^ R_PPC64_UADDR32;
12418 else if ((r_type == R_PPC64_ADDR16 && (out_off & 1) != 0)
12419 || (r_type == R_PPC64_UADDR16 && (out_off & 1) == 0))
12420 r_type ^= R_PPC64_ADDR16 ^ R_PPC64_UADDR16;
12421
12422 if (skip)
12423 memset (&outrel, 0, sizeof outrel);
12424 else if (!SYMBOL_REFERENCES_LOCAL (info, &h->elf)
12425 && !is_opd
12426 && r_type != R_PPC64_TOC)
12427 outrel.r_info = ELF64_R_INFO (h->elf.dynindx, r_type);
12428 else
12429 {
12430 /* This symbol is local, or marked to become local,
12431 or this is an opd section reloc which must point
12432 at a local function. */
12433 outrel.r_addend += relocation;
12434 if (r_type == R_PPC64_ADDR64 || r_type == R_PPC64_TOC)
12435 {
12436 if (is_opd && h != NULL)
12437 {
12438 /* Lie about opd entries. This case occurs
12439 when building shared libraries and we
12440 reference a function in another shared
12441 lib. The same thing happens for a weak
12442 definition in an application that's
12443 overridden by a strong definition in a
12444 shared lib. (I believe this is a generic
12445 bug in binutils handling of weak syms.)
12446 In these cases we won't use the opd
12447 entry in this lib. */
12448 unresolved_reloc = FALSE;
12449 }
12450 if (!is_opd
12451 && r_type == R_PPC64_ADDR64
12452 && (h != NULL
12453 ? h->elf.type == STT_GNU_IFUNC
12454 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
12455 outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
12456 else
12457 {
12458 outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
12459
12460 /* We need to relocate .opd contents for ld.so.
12461 Prelink also wants simple and consistent rules
12462 for relocs. This make all RELATIVE relocs have
12463 *r_offset equal to r_addend. */
12464 relocate = TRUE;
12465 }
12466 }
12467 else
12468 {
12469 long indx = 0;
12470
12471 if (h != NULL
12472 ? h->elf.type == STT_GNU_IFUNC
12473 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
12474 {
12475 (*_bfd_error_handler)
12476 (_("%B(%A+0x%lx): relocation %s for indirect "
12477 "function %s unsupported"),
12478 input_bfd,
12479 input_section,
12480 (long) rel->r_offset,
12481 ppc64_elf_howto_table[r_type]->name,
12482 sym_name);
12483 ret = FALSE;
12484 }
12485 else if (r_symndx == 0 || bfd_is_abs_section (sec))
12486 ;
12487 else if (sec == NULL || sec->owner == NULL)
12488 {
12489 bfd_set_error (bfd_error_bad_value);
12490 return FALSE;
12491 }
12492 else
12493 {
12494 asection *osec;
12495
12496 osec = sec->output_section;
12497 indx = elf_section_data (osec)->dynindx;
12498
12499 if (indx == 0)
12500 {
12501 if ((osec->flags & SEC_READONLY) == 0
12502 && htab->elf.data_index_section != NULL)
12503 osec = htab->elf.data_index_section;
12504 else
12505 osec = htab->elf.text_index_section;
12506 indx = elf_section_data (osec)->dynindx;
12507 }
12508 BFD_ASSERT (indx != 0);
12509
12510 /* We are turning this relocation into one
12511 against a section symbol, so subtract out
12512 the output section's address but not the
12513 offset of the input section in the output
12514 section. */
12515 outrel.r_addend -= osec->vma;
12516 }
12517
12518 outrel.r_info = ELF64_R_INFO (indx, r_type);
12519 }
12520 }
12521
12522 sreloc = elf_section_data (input_section)->sreloc;
12523 if (!htab->elf.dynamic_sections_created)
12524 sreloc = htab->reliplt;
12525 if (sreloc == NULL)
12526 abort ();
12527
12528 if (sreloc->reloc_count * sizeof (Elf64_External_Rela)
12529 >= sreloc->size)
12530 abort ();
12531 loc = sreloc->contents;
12532 loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
12533 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
12534
12535 /* If this reloc is against an external symbol, it will
12536 be computed at runtime, so there's no need to do
12537 anything now. However, for the sake of prelink ensure
12538 that the section contents are a known value. */
12539 if (! relocate)
12540 {
12541 unresolved_reloc = FALSE;
12542 /* The value chosen here is quite arbitrary as ld.so
12543 ignores section contents except for the special
12544 case of .opd where the contents might be accessed
12545 before relocation. Choose zero, as that won't
12546 cause reloc overflow. */
12547 relocation = 0;
12548 addend = 0;
12549 /* Use *r_offset == r_addend for R_PPC64_ADDR64 relocs
12550 to improve backward compatibility with older
12551 versions of ld. */
12552 if (r_type == R_PPC64_ADDR64)
12553 addend = outrel.r_addend;
12554 /* Adjust pc_relative relocs to have zero in *r_offset. */
12555 else if (ppc64_elf_howto_table[r_type]->pc_relative)
12556 addend = (input_section->output_section->vma
12557 + input_section->output_offset
12558 + rel->r_offset);
12559 }
12560 }
12561 break;
12562
12563 case R_PPC64_COPY:
12564 case R_PPC64_GLOB_DAT:
12565 case R_PPC64_JMP_SLOT:
12566 case R_PPC64_JMP_IREL:
12567 case R_PPC64_RELATIVE:
12568 /* We shouldn't ever see these dynamic relocs in relocatable
12569 files. */
12570 /* Fall through. */
12571
12572 case R_PPC64_PLTGOT16:
12573 case R_PPC64_PLTGOT16_DS:
12574 case R_PPC64_PLTGOT16_HA:
12575 case R_PPC64_PLTGOT16_HI:
12576 case R_PPC64_PLTGOT16_LO:
12577 case R_PPC64_PLTGOT16_LO_DS:
12578 case R_PPC64_PLTREL32:
12579 case R_PPC64_PLTREL64:
12580 /* These ones haven't been implemented yet. */
12581
12582 (*_bfd_error_handler)
12583 (_("%B: relocation %s is not supported for symbol %s."),
12584 input_bfd,
12585 ppc64_elf_howto_table[r_type]->name, sym_name);
12586
12587 bfd_set_error (bfd_error_invalid_operation);
12588 ret = FALSE;
12589 continue;
12590 }
12591
12592 /* Do any further special processing. */
12593 switch (r_type)
12594 {
12595 default:
12596 break;
12597
12598 case R_PPC64_ADDR16_HA:
12599 case R_PPC64_REL16_HA:
12600 case R_PPC64_ADDR16_HIGHERA:
12601 case R_PPC64_ADDR16_HIGHESTA:
12602 case R_PPC64_TOC16_HA:
12603 case R_PPC64_SECTOFF_HA:
12604 case R_PPC64_TPREL16_HA:
12605 case R_PPC64_DTPREL16_HA:
12606 case R_PPC64_TPREL16_HIGHER:
12607 case R_PPC64_TPREL16_HIGHERA:
12608 case R_PPC64_TPREL16_HIGHEST:
12609 case R_PPC64_TPREL16_HIGHESTA:
12610 case R_PPC64_DTPREL16_HIGHER:
12611 case R_PPC64_DTPREL16_HIGHERA:
12612 case R_PPC64_DTPREL16_HIGHEST:
12613 case R_PPC64_DTPREL16_HIGHESTA:
12614 /* It's just possible that this symbol is a weak symbol
12615 that's not actually defined anywhere. In that case,
12616 'sec' would be NULL, and we should leave the symbol
12617 alone (it will be set to zero elsewhere in the link). */
12618 if (sec == NULL)
12619 break;
12620 /* Fall thru */
12621
12622 case R_PPC64_GOT16_HA:
12623 case R_PPC64_PLTGOT16_HA:
12624 case R_PPC64_PLT16_HA:
12625 case R_PPC64_GOT_TLSGD16_HA:
12626 case R_PPC64_GOT_TLSLD16_HA:
12627 case R_PPC64_GOT_TPREL16_HA:
12628 case R_PPC64_GOT_DTPREL16_HA:
12629 /* Add 0x10000 if sign bit in 0:15 is set.
12630 Bits 0:15 are not used. */
12631 addend += 0x8000;
12632 break;
12633
12634 case R_PPC64_ADDR16_DS:
12635 case R_PPC64_ADDR16_LO_DS:
12636 case R_PPC64_GOT16_DS:
12637 case R_PPC64_GOT16_LO_DS:
12638 case R_PPC64_PLT16_LO_DS:
12639 case R_PPC64_SECTOFF_DS:
12640 case R_PPC64_SECTOFF_LO_DS:
12641 case R_PPC64_TOC16_DS:
12642 case R_PPC64_TOC16_LO_DS:
12643 case R_PPC64_PLTGOT16_DS:
12644 case R_PPC64_PLTGOT16_LO_DS:
12645 case R_PPC64_GOT_TPREL16_DS:
12646 case R_PPC64_GOT_TPREL16_LO_DS:
12647 case R_PPC64_GOT_DTPREL16_DS:
12648 case R_PPC64_GOT_DTPREL16_LO_DS:
12649 case R_PPC64_TPREL16_DS:
12650 case R_PPC64_TPREL16_LO_DS:
12651 case R_PPC64_DTPREL16_DS:
12652 case R_PPC64_DTPREL16_LO_DS:
12653 insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
12654 mask = 3;
12655 /* If this reloc is against an lq insn, then the value must be
12656 a multiple of 16. This is somewhat of a hack, but the
12657 "correct" way to do this by defining _DQ forms of all the
12658 _DS relocs bloats all reloc switches in this file. It
12659 doesn't seem to make much sense to use any of these relocs
12660 in data, so testing the insn should be safe. */
12661 if ((insn & (0x3f << 26)) == (56u << 26))
12662 mask = 15;
12663 if (((relocation + addend) & mask) != 0)
12664 {
12665 (*_bfd_error_handler)
12666 (_("%B: error: relocation %s not a multiple of %d"),
12667 input_bfd,
12668 ppc64_elf_howto_table[r_type]->name,
12669 mask + 1);
12670 bfd_set_error (bfd_error_bad_value);
12671 ret = FALSE;
12672 continue;
12673 }
12674 break;
12675 }
12676
12677 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
12678 because such sections are not SEC_ALLOC and thus ld.so will
12679 not process them. */
12680 if (unresolved_reloc
12681 && !((input_section->flags & SEC_DEBUGGING) != 0
12682 && h->elf.def_dynamic))
12683 {
12684 (*_bfd_error_handler)
12685 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
12686 input_bfd,
12687 input_section,
12688 (long) rel->r_offset,
12689 ppc64_elf_howto_table[(int) r_type]->name,
12690 h->elf.root.root.string);
12691 ret = FALSE;
12692 }
12693
12694 r = _bfd_final_link_relocate (ppc64_elf_howto_table[(int) r_type],
12695 input_bfd,
12696 input_section,
12697 contents,
12698 rel->r_offset,
12699 relocation,
12700 addend);
12701
12702 if (r != bfd_reloc_ok)
12703 {
12704 if (sym_name == NULL)
12705 sym_name = "(null)";
12706 if (r == bfd_reloc_overflow)
12707 {
12708 if (warned)
12709 continue;
12710 if (h != NULL
12711 && h->elf.root.type == bfd_link_hash_undefweak
12712 && ppc64_elf_howto_table[r_type]->pc_relative)
12713 {
12714 /* Assume this is a call protected by other code that
12715 detects the symbol is undefined. If this is the case,
12716 we can safely ignore the overflow. If not, the
12717 program is hosed anyway, and a little warning isn't
12718 going to help. */
12719
12720 continue;
12721 }
12722
12723 if (!((*info->callbacks->reloc_overflow)
12724 (info, (h ? &h->elf.root : NULL), sym_name,
12725 ppc64_elf_howto_table[r_type]->name,
12726 orig_addend, input_bfd, input_section, rel->r_offset)))
12727 return FALSE;
12728 }
12729 else
12730 {
12731 (*_bfd_error_handler)
12732 (_("%B(%A+0x%lx): %s reloc against `%s': error %d"),
12733 input_bfd,
12734 input_section,
12735 (long) rel->r_offset,
12736 ppc64_elf_howto_table[r_type]->name,
12737 sym_name,
12738 (int) r);
12739 ret = FALSE;
12740 }
12741 }
12742 }
12743
12744 /* If we're emitting relocations, then shortly after this function
12745 returns, reloc offsets and addends for this section will be
12746 adjusted. Worse, reloc symbol indices will be for the output
12747 file rather than the input. Save a copy of the relocs for
12748 opd_entry_value. */
12749 if (is_opd && (info->emitrelocations || info->relocatable))
12750 {
12751 bfd_size_type amt;
12752 amt = input_section->reloc_count * sizeof (Elf_Internal_Rela);
12753 rel = bfd_alloc (input_bfd, amt);
12754 BFD_ASSERT (ppc64_elf_tdata (input_bfd)->opd_relocs == NULL);
12755 ppc64_elf_tdata (input_bfd)->opd_relocs = rel;
12756 if (rel == NULL)
12757 return FALSE;
12758 memcpy (rel, relocs, amt);
12759 }
12760 return ret;
12761 }
12762
12763 /* Adjust the value of any local symbols in opd sections. */
12764
12765 static int
12766 ppc64_elf_output_symbol_hook (struct bfd_link_info *info,
12767 const char *name ATTRIBUTE_UNUSED,
12768 Elf_Internal_Sym *elfsym,
12769 asection *input_sec,
12770 struct elf_link_hash_entry *h)
12771 {
12772 struct _opd_sec_data *opd;
12773 long adjust;
12774 bfd_vma value;
12775
12776 if (h != NULL)
12777 return 1;
12778
12779 opd = get_opd_info (input_sec);
12780 if (opd == NULL || opd->adjust == NULL)
12781 return 1;
12782
12783 value = elfsym->st_value - input_sec->output_offset;
12784 if (!info->relocatable)
12785 value -= input_sec->output_section->vma;
12786
12787 adjust = opd->adjust[value / 8];
12788 if (adjust == -1)
12789 return 2;
12790
12791 elfsym->st_value += adjust;
12792 return 1;
12793 }
12794
12795 /* Finish up dynamic symbol handling. We set the contents of various
12796 dynamic sections here. */
12797
12798 static bfd_boolean
12799 ppc64_elf_finish_dynamic_symbol (bfd *output_bfd,
12800 struct bfd_link_info *info,
12801 struct elf_link_hash_entry *h,
12802 Elf_Internal_Sym *sym)
12803 {
12804 struct ppc_link_hash_table *htab;
12805 struct plt_entry *ent;
12806 Elf_Internal_Rela rela;
12807 bfd_byte *loc;
12808
12809 htab = ppc_hash_table (info);
12810 if (htab == NULL)
12811 return FALSE;
12812
12813 for (ent = h->plt.plist; ent != NULL; ent = ent->next)
12814 if (ent->plt.offset != (bfd_vma) -1)
12815 {
12816 /* This symbol has an entry in the procedure linkage
12817 table. Set it up. */
12818 if (!htab->elf.dynamic_sections_created
12819 || h->dynindx == -1)
12820 {
12821 BFD_ASSERT (h->type == STT_GNU_IFUNC
12822 && h->def_regular
12823 && (h->root.type == bfd_link_hash_defined
12824 || h->root.type == bfd_link_hash_defweak));
12825 rela.r_offset = (htab->iplt->output_section->vma
12826 + htab->iplt->output_offset
12827 + ent->plt.offset);
12828 rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
12829 rela.r_addend = (h->root.u.def.value
12830 + h->root.u.def.section->output_offset
12831 + h->root.u.def.section->output_section->vma
12832 + ent->addend);
12833 loc = (htab->reliplt->contents
12834 + (htab->reliplt->reloc_count++
12835 * sizeof (Elf64_External_Rela)));
12836 }
12837 else
12838 {
12839 rela.r_offset = (htab->plt->output_section->vma
12840 + htab->plt->output_offset
12841 + ent->plt.offset);
12842 rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_JMP_SLOT);
12843 rela.r_addend = ent->addend;
12844 loc = (htab->relplt->contents
12845 + ((ent->plt.offset - PLT_INITIAL_ENTRY_SIZE)
12846 / (PLT_ENTRY_SIZE / sizeof (Elf64_External_Rela))));
12847 }
12848 bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
12849 }
12850
12851 if (h->needs_copy)
12852 {
12853 /* This symbol needs a copy reloc. Set it up. */
12854
12855 if (h->dynindx == -1
12856 || (h->root.type != bfd_link_hash_defined
12857 && h->root.type != bfd_link_hash_defweak)
12858 || htab->relbss == NULL)
12859 abort ();
12860
12861 rela.r_offset = (h->root.u.def.value
12862 + h->root.u.def.section->output_section->vma
12863 + h->root.u.def.section->output_offset);
12864 rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_COPY);
12865 rela.r_addend = 0;
12866 loc = htab->relbss->contents;
12867 loc += htab->relbss->reloc_count++ * sizeof (Elf64_External_Rela);
12868 bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
12869 }
12870
12871 /* Mark some specially defined symbols as absolute. */
12872 if (strcmp (h->root.root.string, "_DYNAMIC") == 0)
12873 sym->st_shndx = SHN_ABS;
12874
12875 return TRUE;
12876 }
12877
12878 /* Used to decide how to sort relocs in an optimal manner for the
12879 dynamic linker, before writing them out. */
12880
12881 static enum elf_reloc_type_class
12882 ppc64_elf_reloc_type_class (const Elf_Internal_Rela *rela)
12883 {
12884 enum elf_ppc64_reloc_type r_type;
12885
12886 r_type = ELF64_R_TYPE (rela->r_info);
12887 switch (r_type)
12888 {
12889 case R_PPC64_RELATIVE:
12890 return reloc_class_relative;
12891 case R_PPC64_JMP_SLOT:
12892 return reloc_class_plt;
12893 case R_PPC64_COPY:
12894 return reloc_class_copy;
12895 default:
12896 return reloc_class_normal;
12897 }
12898 }
12899
12900 /* Finish up the dynamic sections. */
12901
12902 static bfd_boolean
12903 ppc64_elf_finish_dynamic_sections (bfd *output_bfd,
12904 struct bfd_link_info *info)
12905 {
12906 struct ppc_link_hash_table *htab;
12907 bfd *dynobj;
12908 asection *sdyn;
12909
12910 htab = ppc_hash_table (info);
12911 if (htab == NULL)
12912 return FALSE;
12913
12914 dynobj = htab->elf.dynobj;
12915 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
12916
12917 if (htab->elf.dynamic_sections_created)
12918 {
12919 Elf64_External_Dyn *dyncon, *dynconend;
12920
12921 if (sdyn == NULL || htab->got == NULL)
12922 abort ();
12923
12924 dyncon = (Elf64_External_Dyn *) sdyn->contents;
12925 dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
12926 for (; dyncon < dynconend; dyncon++)
12927 {
12928 Elf_Internal_Dyn dyn;
12929 asection *s;
12930
12931 bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
12932
12933 switch (dyn.d_tag)
12934 {
12935 default:
12936 continue;
12937
12938 case DT_PPC64_GLINK:
12939 s = htab->glink;
12940 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
12941 /* We stupidly defined DT_PPC64_GLINK to be the start
12942 of glink rather than the first entry point, which is
12943 what ld.so needs, and now have a bigger stub to
12944 support automatic multiple TOCs. */
12945 dyn.d_un.d_ptr += GLINK_CALL_STUB_SIZE - 32;
12946 break;
12947
12948 case DT_PPC64_OPD:
12949 s = bfd_get_section_by_name (output_bfd, ".opd");
12950 if (s == NULL)
12951 continue;
12952 dyn.d_un.d_ptr = s->vma;
12953 break;
12954
12955 case DT_PPC64_OPDSZ:
12956 s = bfd_get_section_by_name (output_bfd, ".opd");
12957 if (s == NULL)
12958 continue;
12959 dyn.d_un.d_val = s->size;
12960 break;
12961
12962 case DT_PLTGOT:
12963 s = htab->plt;
12964 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
12965 break;
12966
12967 case DT_JMPREL:
12968 s = htab->relplt;
12969 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
12970 break;
12971
12972 case DT_PLTRELSZ:
12973 dyn.d_un.d_val = htab->relplt->size;
12974 break;
12975
12976 case DT_RELASZ:
12977 /* Don't count procedure linkage table relocs in the
12978 overall reloc count. */
12979 s = htab->relplt;
12980 if (s == NULL)
12981 continue;
12982 dyn.d_un.d_val -= s->size;
12983 break;
12984
12985 case DT_RELA:
12986 /* We may not be using the standard ELF linker script.
12987 If .rela.plt is the first .rela section, we adjust
12988 DT_RELA to not include it. */
12989 s = htab->relplt;
12990 if (s == NULL)
12991 continue;
12992 if (dyn.d_un.d_ptr != s->output_section->vma + s->output_offset)
12993 continue;
12994 dyn.d_un.d_ptr += s->size;
12995 break;
12996 }
12997
12998 bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
12999 }
13000 }
13001
13002 if (htab->got != NULL && htab->got->size != 0)
13003 {
13004 /* Fill in the first entry in the global offset table.
13005 We use it to hold the link-time TOCbase. */
13006 bfd_put_64 (output_bfd,
13007 elf_gp (output_bfd) + TOC_BASE_OFF,
13008 htab->got->contents);
13009
13010 /* Set .got entry size. */
13011 elf_section_data (htab->got->output_section)->this_hdr.sh_entsize = 8;
13012 }
13013
13014 if (htab->plt != NULL && htab->plt->size != 0)
13015 {
13016 /* Set .plt entry size. */
13017 elf_section_data (htab->plt->output_section)->this_hdr.sh_entsize
13018 = PLT_ENTRY_SIZE;
13019 }
13020
13021 /* brlt is SEC_LINKER_CREATED, so we need to write out relocs for
13022 brlt ourselves if emitrelocations. */
13023 if (htab->brlt != NULL
13024 && htab->brlt->reloc_count != 0
13025 && !_bfd_elf_link_output_relocs (output_bfd,
13026 htab->brlt,
13027 &elf_section_data (htab->brlt)->rel_hdr,
13028 elf_section_data (htab->brlt)->relocs,
13029 NULL))
13030 return FALSE;
13031
13032 if (htab->glink != NULL
13033 && htab->glink->reloc_count != 0
13034 && !_bfd_elf_link_output_relocs (output_bfd,
13035 htab->glink,
13036 &elf_section_data (htab->glink)->rel_hdr,
13037 elf_section_data (htab->glink)->relocs,
13038 NULL))
13039 return FALSE;
13040
13041 /* We need to handle writing out multiple GOT sections ourselves,
13042 since we didn't add them to DYNOBJ. We know dynobj is the first
13043 bfd. */
13044 while ((dynobj = dynobj->link_next) != NULL)
13045 {
13046 asection *s;
13047
13048 if (!is_ppc64_elf (dynobj))
13049 continue;
13050
13051 s = ppc64_elf_tdata (dynobj)->got;
13052 if (s != NULL
13053 && s->size != 0
13054 && s->output_section != bfd_abs_section_ptr
13055 && !bfd_set_section_contents (output_bfd, s->output_section,
13056 s->contents, s->output_offset,
13057 s->size))
13058 return FALSE;
13059 s = ppc64_elf_tdata (dynobj)->relgot;
13060 if (s != NULL
13061 && s->size != 0
13062 && s->output_section != bfd_abs_section_ptr
13063 && !bfd_set_section_contents (output_bfd, s->output_section,
13064 s->contents, s->output_offset,
13065 s->size))
13066 return FALSE;
13067 }
13068
13069 return TRUE;
13070 }
13071
13072 #include "elf64-target.h"
GDB Binutils - Deliverables
This page took 0.315461 seconds and 4 git commands to generate.