projects / deliverable / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
* maint.c (print_bfd_section_info): Print the section index.
[deliverable/binutils-gdb.git] / bfd / elf64-ppc.c
1 /* PowerPC64-specific support for 64-bit ELF.
2 Copyright 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008,
3 2009, 2010, 2011, 2012 Free Software Foundation, Inc.
4 Written by Linus Nordberg, Swox AB <info@swox.com>,
5 based on elf32-ppc.c by Ian Lance Taylor.
6 Largely rewritten by Alan Modra.
7
8 This file is part of BFD, the Binary File Descriptor library.
9
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3 of the License, or
13 (at your option) any later version.
14
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
19
20 You should have received a copy of the GNU General Public License along
21 with this program; if not, write to the Free Software Foundation, Inc.,
22 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */
23
24
25 /* The 64-bit PowerPC ELF ABI may be found at
26 http://www.linuxbase.org/spec/ELF/ppc64/PPC-elf64abi.txt, and
27 http://www.linuxbase.org/spec/ELF/ppc64/spec/book1.html */
28
29 #include "sysdep.h"
30 #include <stdarg.h>
31 #include "bfd.h"
32 #include "bfdlink.h"
33 #include "libbfd.h"
34 #include "elf-bfd.h"
35 #include "elf/ppc64.h"
36 #include "elf64-ppc.h"
37 #include "dwarf2.h"
38
39 static bfd_reloc_status_type ppc64_elf_ha_reloc
40 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
41 static bfd_reloc_status_type ppc64_elf_branch_reloc
42 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
43 static bfd_reloc_status_type ppc64_elf_brtaken_reloc
44 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
45 static bfd_reloc_status_type ppc64_elf_sectoff_reloc
46 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
47 static bfd_reloc_status_type ppc64_elf_sectoff_ha_reloc
48 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
49 static bfd_reloc_status_type ppc64_elf_toc_reloc
50 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
51 static bfd_reloc_status_type ppc64_elf_toc_ha_reloc
52 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
53 static bfd_reloc_status_type ppc64_elf_toc64_reloc
54 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
55 static bfd_reloc_status_type ppc64_elf_unhandled_reloc
56 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
57 static bfd_vma opd_entry_value
58 (asection *, bfd_vma, asection **, bfd_vma *, bfd_boolean);
59
60 #define TARGET_LITTLE_SYM bfd_elf64_powerpcle_vec
61 #define TARGET_LITTLE_NAME "elf64-powerpcle"
62 #define TARGET_BIG_SYM bfd_elf64_powerpc_vec
63 #define TARGET_BIG_NAME "elf64-powerpc"
64 #define ELF_ARCH bfd_arch_powerpc
65 #define ELF_TARGET_ID PPC64_ELF_DATA
66 #define ELF_MACHINE_CODE EM_PPC64
67 #define ELF_MAXPAGESIZE 0x10000
68 #define ELF_COMMONPAGESIZE 0x1000
69 #define elf_info_to_howto ppc64_elf_info_to_howto
70
71 #define elf_backend_want_got_sym 0
72 #define elf_backend_want_plt_sym 0
73 #define elf_backend_plt_alignment 3
74 #define elf_backend_plt_not_loaded 1
75 #define elf_backend_got_header_size 8
76 #define elf_backend_can_gc_sections 1
77 #define elf_backend_can_refcount 1
78 #define elf_backend_rela_normal 1
79 #define elf_backend_default_execstack 0
80
81 #define bfd_elf64_mkobject ppc64_elf_mkobject
82 #define bfd_elf64_bfd_reloc_type_lookup ppc64_elf_reloc_type_lookup
83 #define bfd_elf64_bfd_reloc_name_lookup ppc64_elf_reloc_name_lookup
84 #define bfd_elf64_bfd_merge_private_bfd_data _bfd_generic_verify_endian_match
85 #define bfd_elf64_new_section_hook ppc64_elf_new_section_hook
86 #define bfd_elf64_bfd_link_hash_table_create ppc64_elf_link_hash_table_create
87 #define bfd_elf64_bfd_link_hash_table_free ppc64_elf_link_hash_table_free
88 #define bfd_elf64_get_synthetic_symtab ppc64_elf_get_synthetic_symtab
89 #define bfd_elf64_bfd_link_just_syms ppc64_elf_link_just_syms
90
91 #define elf_backend_object_p ppc64_elf_object_p
92 #define elf_backend_grok_prstatus ppc64_elf_grok_prstatus
93 #define elf_backend_grok_psinfo ppc64_elf_grok_psinfo
94 #define elf_backend_write_core_note ppc64_elf_write_core_note
95 #define elf_backend_create_dynamic_sections ppc64_elf_create_dynamic_sections
96 #define elf_backend_copy_indirect_symbol ppc64_elf_copy_indirect_symbol
97 #define elf_backend_add_symbol_hook ppc64_elf_add_symbol_hook
98 #define elf_backend_check_directives ppc64_elf_process_dot_syms
99 #define elf_backend_as_needed_cleanup ppc64_elf_as_needed_cleanup
100 #define elf_backend_archive_symbol_lookup ppc64_elf_archive_symbol_lookup
101 #define elf_backend_check_relocs ppc64_elf_check_relocs
102 #define elf_backend_gc_keep ppc64_elf_gc_keep
103 #define elf_backend_gc_mark_dynamic_ref ppc64_elf_gc_mark_dynamic_ref
104 #define elf_backend_gc_mark_hook ppc64_elf_gc_mark_hook
105 #define elf_backend_gc_sweep_hook ppc64_elf_gc_sweep_hook
106 #define elf_backend_adjust_dynamic_symbol ppc64_elf_adjust_dynamic_symbol
107 #define elf_backend_hide_symbol ppc64_elf_hide_symbol
108 #define elf_backend_maybe_function_sym ppc64_elf_maybe_function_sym
109 #define elf_backend_always_size_sections ppc64_elf_func_desc_adjust
110 #define elf_backend_size_dynamic_sections ppc64_elf_size_dynamic_sections
111 #define elf_backend_init_index_section _bfd_elf_init_2_index_sections
112 #define elf_backend_action_discarded ppc64_elf_action_discarded
113 #define elf_backend_relocate_section ppc64_elf_relocate_section
114 #define elf_backend_finish_dynamic_symbol ppc64_elf_finish_dynamic_symbol
115 #define elf_backend_reloc_type_class ppc64_elf_reloc_type_class
116 #define elf_backend_finish_dynamic_sections ppc64_elf_finish_dynamic_sections
117 #define elf_backend_link_output_symbol_hook ppc64_elf_output_symbol_hook
118 #define elf_backend_special_sections ppc64_elf_special_sections
119 #define elf_backend_post_process_headers _bfd_elf_set_osabi
120
121 /* The name of the dynamic interpreter. This is put in the .interp
122 section. */
123 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
124
125 /* The size in bytes of an entry in the procedure linkage table. */
126 #define PLT_ENTRY_SIZE 24
127
128 /* The initial size of the plt reserved for the dynamic linker. */
129 #define PLT_INITIAL_ENTRY_SIZE PLT_ENTRY_SIZE
130
131 /* TOC base pointers offset from start of TOC. */
132 #define TOC_BASE_OFF 0x8000
133
134 /* Offset of tp and dtp pointers from start of TLS block. */
135 #define TP_OFFSET 0x7000
136 #define DTP_OFFSET 0x8000
137
138 /* .plt call stub instructions. The normal stub is like this, but
139 sometimes the .plt entry crosses a 64k boundary and we need to
140 insert an addi to adjust r12. */
141 #define PLT_CALL_STUB_SIZE (7*4)
142 #define ADDIS_R12_R2 0x3d820000 /* addis %r12,%r2,xxx@ha */
143 #define STD_R2_40R1 0xf8410028 /* std %r2,40(%r1) */
144 #define LD_R11_0R12 0xe96c0000 /* ld %r11,xxx+0@l(%r12) */
145 #define MTCTR_R11 0x7d6903a6 /* mtctr %r11 */
146 #define LD_R2_0R12 0xe84c0000 /* ld %r2,xxx+8@l(%r12) */
147 /* ld %r11,xxx+16@l(%r12) */
148 #define BCTR 0x4e800420 /* bctr */
149
150
151 #define ADDIS_R12_R12 0x3d8c0000 /* addis %r12,%r12,off@ha */
152 #define ADDI_R12_R12 0x398c0000 /* addi %r12,%r12,off@l */
153 #define ADDIS_R2_R2 0x3c420000 /* addis %r2,%r2,off@ha */
154 #define ADDI_R2_R2 0x38420000 /* addi %r2,%r2,off@l */
155
156 #define XOR_R11_R11_R11 0x7d6b5a78 /* xor %r11,%r11,%r11 */
157 #define ADD_R12_R12_R11 0x7d8c5a14 /* add %r12,%r12,%r11 */
158 #define ADD_R2_R2_R11 0x7c425a14 /* add %r2,%r2,%r11 */
159 #define CMPLDI_R2_0 0x28220000 /* cmpldi %r2,0 */
160 #define BNECTR 0x4ca20420 /* bnectr+ */
161 #define BNECTR_P4 0x4ce20420 /* bnectr+ */
162
163 #define LD_R11_0R2 0xe9620000 /* ld %r11,xxx+0(%r2) */
164 #define LD_R2_0R2 0xe8420000 /* ld %r2,xxx+0(%r2) */
165
166 #define LD_R2_40R1 0xe8410028 /* ld %r2,40(%r1) */
167
168 /* glink call stub instructions. We enter with the index in R0. */
169 #define GLINK_CALL_STUB_SIZE (16*4)
170 /* 0: */
171 /* .quad plt0-1f */
172 /* __glink: */
173 #define MFLR_R12 0x7d8802a6 /* mflr %12 */
174 #define BCL_20_31 0x429f0005 /* bcl 20,31,1f */
175 /* 1: */
176 #define MFLR_R11 0x7d6802a6 /* mflr %11 */
177 #define LD_R2_M16R11 0xe84bfff0 /* ld %2,(0b-1b)(%11) */
178 #define MTLR_R12 0x7d8803a6 /* mtlr %12 */
179 #define ADD_R12_R2_R11 0x7d825a14 /* add %12,%2,%11 */
180 /* ld %11,0(%12) */
181 /* ld %2,8(%12) */
182 /* mtctr %11 */
183 /* ld %11,16(%12) */
184 /* bctr */
185
186 /* Pad with this. */
187 #define NOP 0x60000000
188
189 /* Some other nops. */
190 #define CROR_151515 0x4def7b82
191 #define CROR_313131 0x4ffffb82
192
193 /* .glink entries for the first 32k functions are two instructions. */
194 #define LI_R0_0 0x38000000 /* li %r0,0 */
195 #define B_DOT 0x48000000 /* b . */
196
197 /* After that, we need two instructions to load the index, followed by
198 a branch. */
199 #define LIS_R0_0 0x3c000000 /* lis %r0,0 */
200 #define ORI_R0_R0_0 0x60000000 /* ori %r0,%r0,0 */
201
202 /* Instructions used by the save and restore reg functions. */
203 #define STD_R0_0R1 0xf8010000 /* std %r0,0(%r1) */
204 #define STD_R0_0R12 0xf80c0000 /* std %r0,0(%r12) */
205 #define LD_R0_0R1 0xe8010000 /* ld %r0,0(%r1) */
206 #define LD_R0_0R12 0xe80c0000 /* ld %r0,0(%r12) */
207 #define STFD_FR0_0R1 0xd8010000 /* stfd %fr0,0(%r1) */
208 #define LFD_FR0_0R1 0xc8010000 /* lfd %fr0,0(%r1) */
209 #define LI_R12_0 0x39800000 /* li %r12,0 */
210 #define STVX_VR0_R12_R0 0x7c0c01ce /* stvx %v0,%r12,%r0 */
211 #define LVX_VR0_R12_R0 0x7c0c00ce /* lvx %v0,%r12,%r0 */
212 #define MTLR_R0 0x7c0803a6 /* mtlr %r0 */
213 #define BLR 0x4e800020 /* blr */
214
215 /* Since .opd is an array of descriptors and each entry will end up
216 with identical R_PPC64_RELATIVE relocs, there is really no need to
217 propagate .opd relocs; The dynamic linker should be taught to
218 relocate .opd without reloc entries. */
219 #ifndef NO_OPD_RELOCS
220 #define NO_OPD_RELOCS 0
221 #endif
222 \f
223 #define ONES(n) (((bfd_vma) 1 << ((n) - 1) << 1) - 1)
224
225 /* Relocation HOWTO's. */
226 static reloc_howto_type *ppc64_elf_howto_table[(int) R_PPC64_max];
227
228 static reloc_howto_type ppc64_elf_howto_raw[] = {
229 /* This reloc does nothing. */
230 HOWTO (R_PPC64_NONE, /* type */
231 0, /* rightshift */
232 2, /* size (0 = byte, 1 = short, 2 = long) */
233 32, /* bitsize */
234 FALSE, /* pc_relative */
235 0, /* bitpos */
236 complain_overflow_dont, /* complain_on_overflow */
237 bfd_elf_generic_reloc, /* special_function */
238 "R_PPC64_NONE", /* name */
239 FALSE, /* partial_inplace */
240 0, /* src_mask */
241 0, /* dst_mask */
242 FALSE), /* pcrel_offset */
243
244 /* A standard 32 bit relocation. */
245 HOWTO (R_PPC64_ADDR32, /* type */
246 0, /* rightshift */
247 2, /* size (0 = byte, 1 = short, 2 = long) */
248 32, /* bitsize */
249 FALSE, /* pc_relative */
250 0, /* bitpos */
251 complain_overflow_bitfield, /* complain_on_overflow */
252 bfd_elf_generic_reloc, /* special_function */
253 "R_PPC64_ADDR32", /* name */
254 FALSE, /* partial_inplace */
255 0, /* src_mask */
256 0xffffffff, /* dst_mask */
257 FALSE), /* pcrel_offset */
258
259 /* An absolute 26 bit branch; the lower two bits must be zero.
260 FIXME: we don't check that, we just clear them. */
261 HOWTO (R_PPC64_ADDR24, /* type */
262 0, /* rightshift */
263 2, /* size (0 = byte, 1 = short, 2 = long) */
264 26, /* bitsize */
265 FALSE, /* pc_relative */
266 0, /* bitpos */
267 complain_overflow_bitfield, /* complain_on_overflow */
268 bfd_elf_generic_reloc, /* special_function */
269 "R_PPC64_ADDR24", /* name */
270 FALSE, /* partial_inplace */
271 0, /* src_mask */
272 0x03fffffc, /* dst_mask */
273 FALSE), /* pcrel_offset */
274
275 /* A standard 16 bit relocation. */
276 HOWTO (R_PPC64_ADDR16, /* type */
277 0, /* rightshift */
278 1, /* size (0 = byte, 1 = short, 2 = long) */
279 16, /* bitsize */
280 FALSE, /* pc_relative */
281 0, /* bitpos */
282 complain_overflow_bitfield, /* complain_on_overflow */
283 bfd_elf_generic_reloc, /* special_function */
284 "R_PPC64_ADDR16", /* name */
285 FALSE, /* partial_inplace */
286 0, /* src_mask */
287 0xffff, /* dst_mask */
288 FALSE), /* pcrel_offset */
289
290 /* A 16 bit relocation without overflow. */
291 HOWTO (R_PPC64_ADDR16_LO, /* type */
292 0, /* rightshift */
293 1, /* size (0 = byte, 1 = short, 2 = long) */
294 16, /* bitsize */
295 FALSE, /* pc_relative */
296 0, /* bitpos */
297 complain_overflow_dont,/* complain_on_overflow */
298 bfd_elf_generic_reloc, /* special_function */
299 "R_PPC64_ADDR16_LO", /* name */
300 FALSE, /* partial_inplace */
301 0, /* src_mask */
302 0xffff, /* dst_mask */
303 FALSE), /* pcrel_offset */
304
305 /* Bits 16-31 of an address. */
306 HOWTO (R_PPC64_ADDR16_HI, /* type */
307 16, /* rightshift */
308 1, /* size (0 = byte, 1 = short, 2 = long) */
309 16, /* bitsize */
310 FALSE, /* pc_relative */
311 0, /* bitpos */
312 complain_overflow_dont, /* complain_on_overflow */
313 bfd_elf_generic_reloc, /* special_function */
314 "R_PPC64_ADDR16_HI", /* name */
315 FALSE, /* partial_inplace */
316 0, /* src_mask */
317 0xffff, /* dst_mask */
318 FALSE), /* pcrel_offset */
319
320 /* Bits 16-31 of an address, plus 1 if the contents of the low 16
321 bits, treated as a signed number, is negative. */
322 HOWTO (R_PPC64_ADDR16_HA, /* type */
323 16, /* rightshift */
324 1, /* size (0 = byte, 1 = short, 2 = long) */
325 16, /* bitsize */
326 FALSE, /* pc_relative */
327 0, /* bitpos */
328 complain_overflow_dont, /* complain_on_overflow */
329 ppc64_elf_ha_reloc, /* special_function */
330 "R_PPC64_ADDR16_HA", /* name */
331 FALSE, /* partial_inplace */
332 0, /* src_mask */
333 0xffff, /* dst_mask */
334 FALSE), /* pcrel_offset */
335
336 /* An absolute 16 bit branch; the lower two bits must be zero.
337 FIXME: we don't check that, we just clear them. */
338 HOWTO (R_PPC64_ADDR14, /* type */
339 0, /* rightshift */
340 2, /* size (0 = byte, 1 = short, 2 = long) */
341 16, /* bitsize */
342 FALSE, /* pc_relative */
343 0, /* bitpos */
344 complain_overflow_bitfield, /* complain_on_overflow */
345 ppc64_elf_branch_reloc, /* special_function */
346 "R_PPC64_ADDR14", /* name */
347 FALSE, /* partial_inplace */
348 0, /* src_mask */
349 0x0000fffc, /* dst_mask */
350 FALSE), /* pcrel_offset */
351
352 /* An absolute 16 bit branch, for which bit 10 should be set to
353 indicate that the branch is expected to be taken. The lower two
354 bits must be zero. */
355 HOWTO (R_PPC64_ADDR14_BRTAKEN, /* type */
356 0, /* rightshift */
357 2, /* size (0 = byte, 1 = short, 2 = long) */
358 16, /* bitsize */
359 FALSE, /* pc_relative */
360 0, /* bitpos */
361 complain_overflow_bitfield, /* complain_on_overflow */
362 ppc64_elf_brtaken_reloc, /* special_function */
363 "R_PPC64_ADDR14_BRTAKEN",/* name */
364 FALSE, /* partial_inplace */
365 0, /* src_mask */
366 0x0000fffc, /* dst_mask */
367 FALSE), /* pcrel_offset */
368
369 /* An absolute 16 bit branch, for which bit 10 should be set to
370 indicate that the branch is not expected to be taken. The lower
371 two bits must be zero. */
372 HOWTO (R_PPC64_ADDR14_BRNTAKEN, /* type */
373 0, /* rightshift */
374 2, /* size (0 = byte, 1 = short, 2 = long) */
375 16, /* bitsize */
376 FALSE, /* pc_relative */
377 0, /* bitpos */
378 complain_overflow_bitfield, /* complain_on_overflow */
379 ppc64_elf_brtaken_reloc, /* special_function */
380 "R_PPC64_ADDR14_BRNTAKEN",/* name */
381 FALSE, /* partial_inplace */
382 0, /* src_mask */
383 0x0000fffc, /* dst_mask */
384 FALSE), /* pcrel_offset */
385
386 /* A relative 26 bit branch; the lower two bits must be zero. */
387 HOWTO (R_PPC64_REL24, /* type */
388 0, /* rightshift */
389 2, /* size (0 = byte, 1 = short, 2 = long) */
390 26, /* bitsize */
391 TRUE, /* pc_relative */
392 0, /* bitpos */
393 complain_overflow_signed, /* complain_on_overflow */
394 ppc64_elf_branch_reloc, /* special_function */
395 "R_PPC64_REL24", /* name */
396 FALSE, /* partial_inplace */
397 0, /* src_mask */
398 0x03fffffc, /* dst_mask */
399 TRUE), /* pcrel_offset */
400
401 /* A relative 16 bit branch; the lower two bits must be zero. */
402 HOWTO (R_PPC64_REL14, /* type */
403 0, /* rightshift */
404 2, /* size (0 = byte, 1 = short, 2 = long) */
405 16, /* bitsize */
406 TRUE, /* pc_relative */
407 0, /* bitpos */
408 complain_overflow_signed, /* complain_on_overflow */
409 ppc64_elf_branch_reloc, /* special_function */
410 "R_PPC64_REL14", /* name */
411 FALSE, /* partial_inplace */
412 0, /* src_mask */
413 0x0000fffc, /* dst_mask */
414 TRUE), /* pcrel_offset */
415
416 /* A relative 16 bit branch. Bit 10 should be set to indicate that
417 the branch is expected to be taken. The lower two bits must be
418 zero. */
419 HOWTO (R_PPC64_REL14_BRTAKEN, /* type */
420 0, /* rightshift */
421 2, /* size (0 = byte, 1 = short, 2 = long) */
422 16, /* bitsize */
423 TRUE, /* pc_relative */
424 0, /* bitpos */
425 complain_overflow_signed, /* complain_on_overflow */
426 ppc64_elf_brtaken_reloc, /* special_function */
427 "R_PPC64_REL14_BRTAKEN", /* name */
428 FALSE, /* partial_inplace */
429 0, /* src_mask */
430 0x0000fffc, /* dst_mask */
431 TRUE), /* pcrel_offset */
432
433 /* A relative 16 bit branch. Bit 10 should be set to indicate that
434 the branch is not expected to be taken. The lower two bits must
435 be zero. */
436 HOWTO (R_PPC64_REL14_BRNTAKEN, /* type */
437 0, /* rightshift */
438 2, /* size (0 = byte, 1 = short, 2 = long) */
439 16, /* bitsize */
440 TRUE, /* pc_relative */
441 0, /* bitpos */
442 complain_overflow_signed, /* complain_on_overflow */
443 ppc64_elf_brtaken_reloc, /* special_function */
444 "R_PPC64_REL14_BRNTAKEN",/* name */
445 FALSE, /* partial_inplace */
446 0, /* src_mask */
447 0x0000fffc, /* dst_mask */
448 TRUE), /* pcrel_offset */
449
450 /* Like R_PPC64_ADDR16, but referring to the GOT table entry for the
451 symbol. */
452 HOWTO (R_PPC64_GOT16, /* type */
453 0, /* rightshift */
454 1, /* size (0 = byte, 1 = short, 2 = long) */
455 16, /* bitsize */
456 FALSE, /* pc_relative */
457 0, /* bitpos */
458 complain_overflow_signed, /* complain_on_overflow */
459 ppc64_elf_unhandled_reloc, /* special_function */
460 "R_PPC64_GOT16", /* name */
461 FALSE, /* partial_inplace */
462 0, /* src_mask */
463 0xffff, /* dst_mask */
464 FALSE), /* pcrel_offset */
465
466 /* Like R_PPC64_ADDR16_LO, but referring to the GOT table entry for
467 the symbol. */
468 HOWTO (R_PPC64_GOT16_LO, /* type */
469 0, /* rightshift */
470 1, /* size (0 = byte, 1 = short, 2 = long) */
471 16, /* bitsize */
472 FALSE, /* pc_relative */
473 0, /* bitpos */
474 complain_overflow_dont, /* complain_on_overflow */
475 ppc64_elf_unhandled_reloc, /* special_function */
476 "R_PPC64_GOT16_LO", /* name */
477 FALSE, /* partial_inplace */
478 0, /* src_mask */
479 0xffff, /* dst_mask */
480 FALSE), /* pcrel_offset */
481
482 /* Like R_PPC64_ADDR16_HI, but referring to the GOT table entry for
483 the symbol. */
484 HOWTO (R_PPC64_GOT16_HI, /* type */
485 16, /* rightshift */
486 1, /* size (0 = byte, 1 = short, 2 = long) */
487 16, /* bitsize */
488 FALSE, /* pc_relative */
489 0, /* bitpos */
490 complain_overflow_dont,/* complain_on_overflow */
491 ppc64_elf_unhandled_reloc, /* special_function */
492 "R_PPC64_GOT16_HI", /* name */
493 FALSE, /* partial_inplace */
494 0, /* src_mask */
495 0xffff, /* dst_mask */
496 FALSE), /* pcrel_offset */
497
498 /* Like R_PPC64_ADDR16_HA, but referring to the GOT table entry for
499 the symbol. */
500 HOWTO (R_PPC64_GOT16_HA, /* type */
501 16, /* rightshift */
502 1, /* size (0 = byte, 1 = short, 2 = long) */
503 16, /* bitsize */
504 FALSE, /* pc_relative */
505 0, /* bitpos */
506 complain_overflow_dont,/* complain_on_overflow */
507 ppc64_elf_unhandled_reloc, /* special_function */
508 "R_PPC64_GOT16_HA", /* name */
509 FALSE, /* partial_inplace */
510 0, /* src_mask */
511 0xffff, /* dst_mask */
512 FALSE), /* pcrel_offset */
513
514 /* This is used only by the dynamic linker. The symbol should exist
515 both in the object being run and in some shared library. The
516 dynamic linker copies the data addressed by the symbol from the
517 shared library into the object, because the object being
518 run has to have the data at some particular address. */
519 HOWTO (R_PPC64_COPY, /* type */
520 0, /* rightshift */
521 0, /* this one is variable size */
522 0, /* bitsize */
523 FALSE, /* pc_relative */
524 0, /* bitpos */
525 complain_overflow_dont, /* complain_on_overflow */
526 ppc64_elf_unhandled_reloc, /* special_function */
527 "R_PPC64_COPY", /* name */
528 FALSE, /* partial_inplace */
529 0, /* src_mask */
530 0, /* dst_mask */
531 FALSE), /* pcrel_offset */
532
533 /* Like R_PPC64_ADDR64, but used when setting global offset table
534 entries. */
535 HOWTO (R_PPC64_GLOB_DAT, /* type */
536 0, /* rightshift */
537 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
538 64, /* bitsize */
539 FALSE, /* pc_relative */
540 0, /* bitpos */
541 complain_overflow_dont, /* complain_on_overflow */
542 ppc64_elf_unhandled_reloc, /* special_function */
543 "R_PPC64_GLOB_DAT", /* name */
544 FALSE, /* partial_inplace */
545 0, /* src_mask */
546 ONES (64), /* dst_mask */
547 FALSE), /* pcrel_offset */
548
549 /* Created by the link editor. Marks a procedure linkage table
550 entry for a symbol. */
551 HOWTO (R_PPC64_JMP_SLOT, /* type */
552 0, /* rightshift */
553 0, /* size (0 = byte, 1 = short, 2 = long) */
554 0, /* bitsize */
555 FALSE, /* pc_relative */
556 0, /* bitpos */
557 complain_overflow_dont, /* complain_on_overflow */
558 ppc64_elf_unhandled_reloc, /* special_function */
559 "R_PPC64_JMP_SLOT", /* name */
560 FALSE, /* partial_inplace */
561 0, /* src_mask */
562 0, /* dst_mask */
563 FALSE), /* pcrel_offset */
564
565 /* Used only by the dynamic linker. When the object is run, this
566 doubleword64 is set to the load address of the object, plus the
567 addend. */
568 HOWTO (R_PPC64_RELATIVE, /* type */
569 0, /* rightshift */
570 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
571 64, /* bitsize */
572 FALSE, /* pc_relative */
573 0, /* bitpos */
574 complain_overflow_dont, /* complain_on_overflow */
575 bfd_elf_generic_reloc, /* special_function */
576 "R_PPC64_RELATIVE", /* name */
577 FALSE, /* partial_inplace */
578 0, /* src_mask */
579 ONES (64), /* dst_mask */
580 FALSE), /* pcrel_offset */
581
582 /* Like R_PPC64_ADDR32, but may be unaligned. */
583 HOWTO (R_PPC64_UADDR32, /* type */
584 0, /* rightshift */
585 2, /* size (0 = byte, 1 = short, 2 = long) */
586 32, /* bitsize */
587 FALSE, /* pc_relative */
588 0, /* bitpos */
589 complain_overflow_bitfield, /* complain_on_overflow */
590 bfd_elf_generic_reloc, /* special_function */
591 "R_PPC64_UADDR32", /* name */
592 FALSE, /* partial_inplace */
593 0, /* src_mask */
594 0xffffffff, /* dst_mask */
595 FALSE), /* pcrel_offset */
596
597 /* Like R_PPC64_ADDR16, but may be unaligned. */
598 HOWTO (R_PPC64_UADDR16, /* type */
599 0, /* rightshift */
600 1, /* size (0 = byte, 1 = short, 2 = long) */
601 16, /* bitsize */
602 FALSE, /* pc_relative */
603 0, /* bitpos */
604 complain_overflow_bitfield, /* complain_on_overflow */
605 bfd_elf_generic_reloc, /* special_function */
606 "R_PPC64_UADDR16", /* name */
607 FALSE, /* partial_inplace */
608 0, /* src_mask */
609 0xffff, /* dst_mask */
610 FALSE), /* pcrel_offset */
611
612 /* 32-bit PC relative. */
613 HOWTO (R_PPC64_REL32, /* type */
614 0, /* rightshift */
615 2, /* size (0 = byte, 1 = short, 2 = long) */
616 32, /* bitsize */
617 TRUE, /* pc_relative */
618 0, /* bitpos */
619 /* FIXME: Verify. Was complain_overflow_bitfield. */
620 complain_overflow_signed, /* complain_on_overflow */
621 bfd_elf_generic_reloc, /* special_function */
622 "R_PPC64_REL32", /* name */
623 FALSE, /* partial_inplace */
624 0, /* src_mask */
625 0xffffffff, /* dst_mask */
626 TRUE), /* pcrel_offset */
627
628 /* 32-bit relocation to the symbol's procedure linkage table. */
629 HOWTO (R_PPC64_PLT32, /* type */
630 0, /* rightshift */
631 2, /* size (0 = byte, 1 = short, 2 = long) */
632 32, /* bitsize */
633 FALSE, /* pc_relative */
634 0, /* bitpos */
635 complain_overflow_bitfield, /* complain_on_overflow */
636 ppc64_elf_unhandled_reloc, /* special_function */
637 "R_PPC64_PLT32", /* name */
638 FALSE, /* partial_inplace */
639 0, /* src_mask */
640 0xffffffff, /* dst_mask */
641 FALSE), /* pcrel_offset */
642
643 /* 32-bit PC relative relocation to the symbol's procedure linkage table.
644 FIXME: R_PPC64_PLTREL32 not supported. */
645 HOWTO (R_PPC64_PLTREL32, /* type */
646 0, /* rightshift */
647 2, /* size (0 = byte, 1 = short, 2 = long) */
648 32, /* bitsize */
649 TRUE, /* pc_relative */
650 0, /* bitpos */
651 complain_overflow_signed, /* complain_on_overflow */
652 bfd_elf_generic_reloc, /* special_function */
653 "R_PPC64_PLTREL32", /* name */
654 FALSE, /* partial_inplace */
655 0, /* src_mask */
656 0xffffffff, /* dst_mask */
657 TRUE), /* pcrel_offset */
658
659 /* Like R_PPC64_ADDR16_LO, but referring to the PLT table entry for
660 the symbol. */
661 HOWTO (R_PPC64_PLT16_LO, /* type */
662 0, /* rightshift */
663 1, /* size (0 = byte, 1 = short, 2 = long) */
664 16, /* bitsize */
665 FALSE, /* pc_relative */
666 0, /* bitpos */
667 complain_overflow_dont, /* complain_on_overflow */
668 ppc64_elf_unhandled_reloc, /* special_function */
669 "R_PPC64_PLT16_LO", /* name */
670 FALSE, /* partial_inplace */
671 0, /* src_mask */
672 0xffff, /* dst_mask */
673 FALSE), /* pcrel_offset */
674
675 /* Like R_PPC64_ADDR16_HI, but referring to the PLT table entry for
676 the symbol. */
677 HOWTO (R_PPC64_PLT16_HI, /* type */
678 16, /* rightshift */
679 1, /* size (0 = byte, 1 = short, 2 = long) */
680 16, /* bitsize */
681 FALSE, /* pc_relative */
682 0, /* bitpos */
683 complain_overflow_dont, /* complain_on_overflow */
684 ppc64_elf_unhandled_reloc, /* special_function */
685 "R_PPC64_PLT16_HI", /* name */
686 FALSE, /* partial_inplace */
687 0, /* src_mask */
688 0xffff, /* dst_mask */
689 FALSE), /* pcrel_offset */
690
691 /* Like R_PPC64_ADDR16_HA, but referring to the PLT table entry for
692 the symbol. */
693 HOWTO (R_PPC64_PLT16_HA, /* type */
694 16, /* rightshift */
695 1, /* size (0 = byte, 1 = short, 2 = long) */
696 16, /* bitsize */
697 FALSE, /* pc_relative */
698 0, /* bitpos */
699 complain_overflow_dont, /* complain_on_overflow */
700 ppc64_elf_unhandled_reloc, /* special_function */
701 "R_PPC64_PLT16_HA", /* name */
702 FALSE, /* partial_inplace */
703 0, /* src_mask */
704 0xffff, /* dst_mask */
705 FALSE), /* pcrel_offset */
706
707 /* 16-bit section relative relocation. */
708 HOWTO (R_PPC64_SECTOFF, /* type */
709 0, /* rightshift */
710 1, /* size (0 = byte, 1 = short, 2 = long) */
711 16, /* bitsize */
712 FALSE, /* pc_relative */
713 0, /* bitpos */
714 complain_overflow_bitfield, /* complain_on_overflow */
715 ppc64_elf_sectoff_reloc, /* special_function */
716 "R_PPC64_SECTOFF", /* name */
717 FALSE, /* partial_inplace */
718 0, /* src_mask */
719 0xffff, /* dst_mask */
720 FALSE), /* pcrel_offset */
721
722 /* Like R_PPC64_SECTOFF, but no overflow warning. */
723 HOWTO (R_PPC64_SECTOFF_LO, /* type */
724 0, /* rightshift */
725 1, /* size (0 = byte, 1 = short, 2 = long) */
726 16, /* bitsize */
727 FALSE, /* pc_relative */
728 0, /* bitpos */
729 complain_overflow_dont, /* complain_on_overflow */
730 ppc64_elf_sectoff_reloc, /* special_function */
731 "R_PPC64_SECTOFF_LO", /* name */
732 FALSE, /* partial_inplace */
733 0, /* src_mask */
734 0xffff, /* dst_mask */
735 FALSE), /* pcrel_offset */
736
737 /* 16-bit upper half section relative relocation. */
738 HOWTO (R_PPC64_SECTOFF_HI, /* type */
739 16, /* rightshift */
740 1, /* size (0 = byte, 1 = short, 2 = long) */
741 16, /* bitsize */
742 FALSE, /* pc_relative */
743 0, /* bitpos */
744 complain_overflow_dont, /* complain_on_overflow */
745 ppc64_elf_sectoff_reloc, /* special_function */
746 "R_PPC64_SECTOFF_HI", /* name */
747 FALSE, /* partial_inplace */
748 0, /* src_mask */
749 0xffff, /* dst_mask */
750 FALSE), /* pcrel_offset */
751
752 /* 16-bit upper half adjusted section relative relocation. */
753 HOWTO (R_PPC64_SECTOFF_HA, /* type */
754 16, /* rightshift */
755 1, /* size (0 = byte, 1 = short, 2 = long) */
756 16, /* bitsize */
757 FALSE, /* pc_relative */
758 0, /* bitpos */
759 complain_overflow_dont, /* complain_on_overflow */
760 ppc64_elf_sectoff_ha_reloc, /* special_function */
761 "R_PPC64_SECTOFF_HA", /* name */
762 FALSE, /* partial_inplace */
763 0, /* src_mask */
764 0xffff, /* dst_mask */
765 FALSE), /* pcrel_offset */
766
767 /* Like R_PPC64_REL24 without touching the two least significant bits. */
768 HOWTO (R_PPC64_REL30, /* type */
769 2, /* rightshift */
770 2, /* size (0 = byte, 1 = short, 2 = long) */
771 30, /* bitsize */
772 TRUE, /* pc_relative */
773 0, /* bitpos */
774 complain_overflow_dont, /* complain_on_overflow */
775 bfd_elf_generic_reloc, /* special_function */
776 "R_PPC64_REL30", /* name */
777 FALSE, /* partial_inplace */
778 0, /* src_mask */
779 0xfffffffc, /* dst_mask */
780 TRUE), /* pcrel_offset */
781
782 /* Relocs in the 64-bit PowerPC ELF ABI, not in the 32-bit ABI. */
783
784 /* A standard 64-bit relocation. */
785 HOWTO (R_PPC64_ADDR64, /* type */
786 0, /* rightshift */
787 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
788 64, /* bitsize */
789 FALSE, /* pc_relative */
790 0, /* bitpos */
791 complain_overflow_dont, /* complain_on_overflow */
792 bfd_elf_generic_reloc, /* special_function */
793 "R_PPC64_ADDR64", /* name */
794 FALSE, /* partial_inplace */
795 0, /* src_mask */
796 ONES (64), /* dst_mask */
797 FALSE), /* pcrel_offset */
798
799 /* The bits 32-47 of an address. */
800 HOWTO (R_PPC64_ADDR16_HIGHER, /* type */
801 32, /* rightshift */
802 1, /* size (0 = byte, 1 = short, 2 = long) */
803 16, /* bitsize */
804 FALSE, /* pc_relative */
805 0, /* bitpos */
806 complain_overflow_dont, /* complain_on_overflow */
807 bfd_elf_generic_reloc, /* special_function */
808 "R_PPC64_ADDR16_HIGHER", /* name */
809 FALSE, /* partial_inplace */
810 0, /* src_mask */
811 0xffff, /* dst_mask */
812 FALSE), /* pcrel_offset */
813
814 /* The bits 32-47 of an address, plus 1 if the contents of the low
815 16 bits, treated as a signed number, is negative. */
816 HOWTO (R_PPC64_ADDR16_HIGHERA, /* type */
817 32, /* rightshift */
818 1, /* size (0 = byte, 1 = short, 2 = long) */
819 16, /* bitsize */
820 FALSE, /* pc_relative */
821 0, /* bitpos */
822 complain_overflow_dont, /* complain_on_overflow */
823 ppc64_elf_ha_reloc, /* special_function */
824 "R_PPC64_ADDR16_HIGHERA", /* name */
825 FALSE, /* partial_inplace */
826 0, /* src_mask */
827 0xffff, /* dst_mask */
828 FALSE), /* pcrel_offset */
829
830 /* The bits 48-63 of an address. */
831 HOWTO (R_PPC64_ADDR16_HIGHEST,/* type */
832 48, /* rightshift */
833 1, /* size (0 = byte, 1 = short, 2 = long) */
834 16, /* bitsize */
835 FALSE, /* pc_relative */
836 0, /* bitpos */
837 complain_overflow_dont, /* complain_on_overflow */
838 bfd_elf_generic_reloc, /* special_function */
839 "R_PPC64_ADDR16_HIGHEST", /* name */
840 FALSE, /* partial_inplace */
841 0, /* src_mask */
842 0xffff, /* dst_mask */
843 FALSE), /* pcrel_offset */
844
845 /* The bits 48-63 of an address, plus 1 if the contents of the low
846 16 bits, treated as a signed number, is negative. */
847 HOWTO (R_PPC64_ADDR16_HIGHESTA,/* type */
848 48, /* rightshift */
849 1, /* size (0 = byte, 1 = short, 2 = long) */
850 16, /* bitsize */
851 FALSE, /* pc_relative */
852 0, /* bitpos */
853 complain_overflow_dont, /* complain_on_overflow */
854 ppc64_elf_ha_reloc, /* special_function */
855 "R_PPC64_ADDR16_HIGHESTA", /* name */
856 FALSE, /* partial_inplace */
857 0, /* src_mask */
858 0xffff, /* dst_mask */
859 FALSE), /* pcrel_offset */
860
861 /* Like ADDR64, but may be unaligned. */
862 HOWTO (R_PPC64_UADDR64, /* type */
863 0, /* rightshift */
864 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
865 64, /* bitsize */
866 FALSE, /* pc_relative */
867 0, /* bitpos */
868 complain_overflow_dont, /* complain_on_overflow */
869 bfd_elf_generic_reloc, /* special_function */
870 "R_PPC64_UADDR64", /* name */
871 FALSE, /* partial_inplace */
872 0, /* src_mask */
873 ONES (64), /* dst_mask */
874 FALSE), /* pcrel_offset */
875
876 /* 64-bit relative relocation. */
877 HOWTO (R_PPC64_REL64, /* type */
878 0, /* rightshift */
879 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
880 64, /* bitsize */
881 TRUE, /* pc_relative */
882 0, /* bitpos */
883 complain_overflow_dont, /* complain_on_overflow */
884 bfd_elf_generic_reloc, /* special_function */
885 "R_PPC64_REL64", /* name */
886 FALSE, /* partial_inplace */
887 0, /* src_mask */
888 ONES (64), /* dst_mask */
889 TRUE), /* pcrel_offset */
890
891 /* 64-bit relocation to the symbol's procedure linkage table. */
892 HOWTO (R_PPC64_PLT64, /* type */
893 0, /* rightshift */
894 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
895 64, /* bitsize */
896 FALSE, /* pc_relative */
897 0, /* bitpos */
898 complain_overflow_dont, /* complain_on_overflow */
899 ppc64_elf_unhandled_reloc, /* special_function */
900 "R_PPC64_PLT64", /* name */
901 FALSE, /* partial_inplace */
902 0, /* src_mask */
903 ONES (64), /* dst_mask */
904 FALSE), /* pcrel_offset */
905
906 /* 64-bit PC relative relocation to the symbol's procedure linkage
907 table. */
908 /* FIXME: R_PPC64_PLTREL64 not supported. */
909 HOWTO (R_PPC64_PLTREL64, /* type */
910 0, /* rightshift */
911 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
912 64, /* bitsize */
913 TRUE, /* pc_relative */
914 0, /* bitpos */
915 complain_overflow_dont, /* complain_on_overflow */
916 ppc64_elf_unhandled_reloc, /* special_function */
917 "R_PPC64_PLTREL64", /* name */
918 FALSE, /* partial_inplace */
919 0, /* src_mask */
920 ONES (64), /* dst_mask */
921 TRUE), /* pcrel_offset */
922
923 /* 16 bit TOC-relative relocation. */
924
925 /* R_PPC64_TOC16 47 half16* S + A - .TOC. */
926 HOWTO (R_PPC64_TOC16, /* type */
927 0, /* rightshift */
928 1, /* size (0 = byte, 1 = short, 2 = long) */
929 16, /* bitsize */
930 FALSE, /* pc_relative */
931 0, /* bitpos */
932 complain_overflow_signed, /* complain_on_overflow */
933 ppc64_elf_toc_reloc, /* special_function */
934 "R_PPC64_TOC16", /* name */
935 FALSE, /* partial_inplace */
936 0, /* src_mask */
937 0xffff, /* dst_mask */
938 FALSE), /* pcrel_offset */
939
940 /* 16 bit TOC-relative relocation without overflow. */
941
942 /* R_PPC64_TOC16_LO 48 half16 #lo (S + A - .TOC.) */
943 HOWTO (R_PPC64_TOC16_LO, /* type */
944 0, /* rightshift */
945 1, /* size (0 = byte, 1 = short, 2 = long) */
946 16, /* bitsize */
947 FALSE, /* pc_relative */
948 0, /* bitpos */
949 complain_overflow_dont, /* complain_on_overflow */
950 ppc64_elf_toc_reloc, /* special_function */
951 "R_PPC64_TOC16_LO", /* name */
952 FALSE, /* partial_inplace */
953 0, /* src_mask */
954 0xffff, /* dst_mask */
955 FALSE), /* pcrel_offset */
956
957 /* 16 bit TOC-relative relocation, high 16 bits. */
958
959 /* R_PPC64_TOC16_HI 49 half16 #hi (S + A - .TOC.) */
960 HOWTO (R_PPC64_TOC16_HI, /* type */
961 16, /* rightshift */
962 1, /* size (0 = byte, 1 = short, 2 = long) */
963 16, /* bitsize */
964 FALSE, /* pc_relative */
965 0, /* bitpos */
966 complain_overflow_dont, /* complain_on_overflow */
967 ppc64_elf_toc_reloc, /* special_function */
968 "R_PPC64_TOC16_HI", /* name */
969 FALSE, /* partial_inplace */
970 0, /* src_mask */
971 0xffff, /* dst_mask */
972 FALSE), /* pcrel_offset */
973
974 /* 16 bit TOC-relative relocation, high 16 bits, plus 1 if the
975 contents of the low 16 bits, treated as a signed number, is
976 negative. */
977
978 /* R_PPC64_TOC16_HA 50 half16 #ha (S + A - .TOC.) */
979 HOWTO (R_PPC64_TOC16_HA, /* type */
980 16, /* rightshift */
981 1, /* size (0 = byte, 1 = short, 2 = long) */
982 16, /* bitsize */
983 FALSE, /* pc_relative */
984 0, /* bitpos */
985 complain_overflow_dont, /* complain_on_overflow */
986 ppc64_elf_toc_ha_reloc, /* special_function */
987 "R_PPC64_TOC16_HA", /* name */
988 FALSE, /* partial_inplace */
989 0, /* src_mask */
990 0xffff, /* dst_mask */
991 FALSE), /* pcrel_offset */
992
993 /* 64-bit relocation; insert value of TOC base (.TOC.). */
994
995 /* R_PPC64_TOC 51 doubleword64 .TOC. */
996 HOWTO (R_PPC64_TOC, /* type */
997 0, /* rightshift */
998 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
999 64, /* bitsize */
1000 FALSE, /* pc_relative */
1001 0, /* bitpos */
1002 complain_overflow_bitfield, /* complain_on_overflow */
1003 ppc64_elf_toc64_reloc, /* special_function */
1004 "R_PPC64_TOC", /* name */
1005 FALSE, /* partial_inplace */
1006 0, /* src_mask */
1007 ONES (64), /* dst_mask */
1008 FALSE), /* pcrel_offset */
1009
1010 /* Like R_PPC64_GOT16, but also informs the link editor that the
1011 value to relocate may (!) refer to a PLT entry which the link
1012 editor (a) may replace with the symbol value. If the link editor
1013 is unable to fully resolve the symbol, it may (b) create a PLT
1014 entry and store the address to the new PLT entry in the GOT.
1015 This permits lazy resolution of function symbols at run time.
1016 The link editor may also skip all of this and just (c) emit a
1017 R_PPC64_GLOB_DAT to tie the symbol to the GOT entry. */
1018 /* FIXME: R_PPC64_PLTGOT16 not implemented. */
1019 HOWTO (R_PPC64_PLTGOT16, /* type */
1020 0, /* rightshift */
1021 1, /* size (0 = byte, 1 = short, 2 = long) */
1022 16, /* bitsize */
1023 FALSE, /* pc_relative */
1024 0, /* bitpos */
1025 complain_overflow_signed, /* complain_on_overflow */
1026 ppc64_elf_unhandled_reloc, /* special_function */
1027 "R_PPC64_PLTGOT16", /* name */
1028 FALSE, /* partial_inplace */
1029 0, /* src_mask */
1030 0xffff, /* dst_mask */
1031 FALSE), /* pcrel_offset */
1032
1033 /* Like R_PPC64_PLTGOT16, but without overflow. */
1034 /* FIXME: R_PPC64_PLTGOT16_LO not implemented. */
1035 HOWTO (R_PPC64_PLTGOT16_LO, /* type */
1036 0, /* rightshift */
1037 1, /* size (0 = byte, 1 = short, 2 = long) */
1038 16, /* bitsize */
1039 FALSE, /* pc_relative */
1040 0, /* bitpos */
1041 complain_overflow_dont, /* complain_on_overflow */
1042 ppc64_elf_unhandled_reloc, /* special_function */
1043 "R_PPC64_PLTGOT16_LO", /* name */
1044 FALSE, /* partial_inplace */
1045 0, /* src_mask */
1046 0xffff, /* dst_mask */
1047 FALSE), /* pcrel_offset */
1048
1049 /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address. */
1050 /* FIXME: R_PPC64_PLTGOT16_HI not implemented. */
1051 HOWTO (R_PPC64_PLTGOT16_HI, /* type */
1052 16, /* rightshift */
1053 1, /* size (0 = byte, 1 = short, 2 = long) */
1054 16, /* bitsize */
1055 FALSE, /* pc_relative */
1056 0, /* bitpos */
1057 complain_overflow_dont, /* complain_on_overflow */
1058 ppc64_elf_unhandled_reloc, /* special_function */
1059 "R_PPC64_PLTGOT16_HI", /* name */
1060 FALSE, /* partial_inplace */
1061 0, /* src_mask */
1062 0xffff, /* dst_mask */
1063 FALSE), /* pcrel_offset */
1064
1065 /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address, plus
1066 1 if the contents of the low 16 bits, treated as a signed number,
1067 is negative. */
1068 /* FIXME: R_PPC64_PLTGOT16_HA not implemented. */
1069 HOWTO (R_PPC64_PLTGOT16_HA, /* type */
1070 16, /* rightshift */
1071 1, /* size (0 = byte, 1 = short, 2 = long) */
1072 16, /* bitsize */
1073 FALSE, /* pc_relative */
1074 0, /* bitpos */
1075 complain_overflow_dont,/* complain_on_overflow */
1076 ppc64_elf_unhandled_reloc, /* special_function */
1077 "R_PPC64_PLTGOT16_HA", /* name */
1078 FALSE, /* partial_inplace */
1079 0, /* src_mask */
1080 0xffff, /* dst_mask */
1081 FALSE), /* pcrel_offset */
1082
1083 /* Like R_PPC64_ADDR16, but for instructions with a DS field. */
1084 HOWTO (R_PPC64_ADDR16_DS, /* type */
1085 0, /* rightshift */
1086 1, /* size (0 = byte, 1 = short, 2 = long) */
1087 16, /* bitsize */
1088 FALSE, /* pc_relative */
1089 0, /* bitpos */
1090 complain_overflow_bitfield, /* complain_on_overflow */
1091 bfd_elf_generic_reloc, /* special_function */
1092 "R_PPC64_ADDR16_DS", /* name */
1093 FALSE, /* partial_inplace */
1094 0, /* src_mask */
1095 0xfffc, /* dst_mask */
1096 FALSE), /* pcrel_offset */
1097
1098 /* Like R_PPC64_ADDR16_LO, but for instructions with a DS field. */
1099 HOWTO (R_PPC64_ADDR16_LO_DS, /* type */
1100 0, /* rightshift */
1101 1, /* size (0 = byte, 1 = short, 2 = long) */
1102 16, /* bitsize */
1103 FALSE, /* pc_relative */
1104 0, /* bitpos */
1105 complain_overflow_dont,/* complain_on_overflow */
1106 bfd_elf_generic_reloc, /* special_function */
1107 "R_PPC64_ADDR16_LO_DS",/* name */
1108 FALSE, /* partial_inplace */
1109 0, /* src_mask */
1110 0xfffc, /* dst_mask */
1111 FALSE), /* pcrel_offset */
1112
1113 /* Like R_PPC64_GOT16, but for instructions with a DS field. */
1114 HOWTO (R_PPC64_GOT16_DS, /* type */
1115 0, /* rightshift */
1116 1, /* size (0 = byte, 1 = short, 2 = long) */
1117 16, /* bitsize */
1118 FALSE, /* pc_relative */
1119 0, /* bitpos */
1120 complain_overflow_signed, /* complain_on_overflow */
1121 ppc64_elf_unhandled_reloc, /* special_function */
1122 "R_PPC64_GOT16_DS", /* name */
1123 FALSE, /* partial_inplace */
1124 0, /* src_mask */
1125 0xfffc, /* dst_mask */
1126 FALSE), /* pcrel_offset */
1127
1128 /* Like R_PPC64_GOT16_LO, but for instructions with a DS field. */
1129 HOWTO (R_PPC64_GOT16_LO_DS, /* type */
1130 0, /* rightshift */
1131 1, /* size (0 = byte, 1 = short, 2 = long) */
1132 16, /* bitsize */
1133 FALSE, /* pc_relative */
1134 0, /* bitpos */
1135 complain_overflow_dont, /* complain_on_overflow */
1136 ppc64_elf_unhandled_reloc, /* special_function */
1137 "R_PPC64_GOT16_LO_DS", /* name */
1138 FALSE, /* partial_inplace */
1139 0, /* src_mask */
1140 0xfffc, /* dst_mask */
1141 FALSE), /* pcrel_offset */
1142
1143 /* Like R_PPC64_PLT16_LO, but for instructions with a DS field. */
1144 HOWTO (R_PPC64_PLT16_LO_DS, /* type */
1145 0, /* rightshift */
1146 1, /* size (0 = byte, 1 = short, 2 = long) */
1147 16, /* bitsize */
1148 FALSE, /* pc_relative */
1149 0, /* bitpos */
1150 complain_overflow_dont, /* complain_on_overflow */
1151 ppc64_elf_unhandled_reloc, /* special_function */
1152 "R_PPC64_PLT16_LO_DS", /* name */
1153 FALSE, /* partial_inplace */
1154 0, /* src_mask */
1155 0xfffc, /* dst_mask */
1156 FALSE), /* pcrel_offset */
1157
1158 /* Like R_PPC64_SECTOFF, but for instructions with a DS field. */
1159 HOWTO (R_PPC64_SECTOFF_DS, /* type */
1160 0, /* rightshift */
1161 1, /* size (0 = byte, 1 = short, 2 = long) */
1162 16, /* bitsize */
1163 FALSE, /* pc_relative */
1164 0, /* bitpos */
1165 complain_overflow_bitfield, /* complain_on_overflow */
1166 ppc64_elf_sectoff_reloc, /* special_function */
1167 "R_PPC64_SECTOFF_DS", /* name */
1168 FALSE, /* partial_inplace */
1169 0, /* src_mask */
1170 0xfffc, /* dst_mask */
1171 FALSE), /* pcrel_offset */
1172
1173 /* Like R_PPC64_SECTOFF_LO, but for instructions with a DS field. */
1174 HOWTO (R_PPC64_SECTOFF_LO_DS, /* type */
1175 0, /* rightshift */
1176 1, /* size (0 = byte, 1 = short, 2 = long) */
1177 16, /* bitsize */
1178 FALSE, /* pc_relative */
1179 0, /* bitpos */
1180 complain_overflow_dont, /* complain_on_overflow */
1181 ppc64_elf_sectoff_reloc, /* special_function */
1182 "R_PPC64_SECTOFF_LO_DS",/* name */
1183 FALSE, /* partial_inplace */
1184 0, /* src_mask */
1185 0xfffc, /* dst_mask */
1186 FALSE), /* pcrel_offset */
1187
1188 /* Like R_PPC64_TOC16, but for instructions with a DS field. */
1189 HOWTO (R_PPC64_TOC16_DS, /* type */
1190 0, /* rightshift */
1191 1, /* size (0 = byte, 1 = short, 2 = long) */
1192 16, /* bitsize */
1193 FALSE, /* pc_relative */
1194 0, /* bitpos */
1195 complain_overflow_signed, /* complain_on_overflow */
1196 ppc64_elf_toc_reloc, /* special_function */
1197 "R_PPC64_TOC16_DS", /* name */
1198 FALSE, /* partial_inplace */
1199 0, /* src_mask */
1200 0xfffc, /* dst_mask */
1201 FALSE), /* pcrel_offset */
1202
1203 /* Like R_PPC64_TOC16_LO, but for instructions with a DS field. */
1204 HOWTO (R_PPC64_TOC16_LO_DS, /* type */
1205 0, /* rightshift */
1206 1, /* size (0 = byte, 1 = short, 2 = long) */
1207 16, /* bitsize */
1208 FALSE, /* pc_relative */
1209 0, /* bitpos */
1210 complain_overflow_dont, /* complain_on_overflow */
1211 ppc64_elf_toc_reloc, /* special_function */
1212 "R_PPC64_TOC16_LO_DS", /* name */
1213 FALSE, /* partial_inplace */
1214 0, /* src_mask */
1215 0xfffc, /* dst_mask */
1216 FALSE), /* pcrel_offset */
1217
1218 /* Like R_PPC64_PLTGOT16, but for instructions with a DS field. */
1219 /* FIXME: R_PPC64_PLTGOT16_DS not implemented. */
1220 HOWTO (R_PPC64_PLTGOT16_DS, /* type */
1221 0, /* rightshift */
1222 1, /* size (0 = byte, 1 = short, 2 = long) */
1223 16, /* bitsize */
1224 FALSE, /* pc_relative */
1225 0, /* bitpos */
1226 complain_overflow_signed, /* complain_on_overflow */
1227 ppc64_elf_unhandled_reloc, /* special_function */
1228 "R_PPC64_PLTGOT16_DS", /* name */
1229 FALSE, /* partial_inplace */
1230 0, /* src_mask */
1231 0xfffc, /* dst_mask */
1232 FALSE), /* pcrel_offset */
1233
1234 /* Like R_PPC64_PLTGOT16_LO, but for instructions with a DS field. */
1235 /* FIXME: R_PPC64_PLTGOT16_LO not implemented. */
1236 HOWTO (R_PPC64_PLTGOT16_LO_DS,/* type */
1237 0, /* rightshift */
1238 1, /* size (0 = byte, 1 = short, 2 = long) */
1239 16, /* bitsize */
1240 FALSE, /* pc_relative */
1241 0, /* bitpos */
1242 complain_overflow_dont, /* complain_on_overflow */
1243 ppc64_elf_unhandled_reloc, /* special_function */
1244 "R_PPC64_PLTGOT16_LO_DS",/* name */
1245 FALSE, /* partial_inplace */
1246 0, /* src_mask */
1247 0xfffc, /* dst_mask */
1248 FALSE), /* pcrel_offset */
1249
1250 /* Marker relocs for TLS. */
1251 HOWTO (R_PPC64_TLS,
1252 0, /* rightshift */
1253 2, /* size (0 = byte, 1 = short, 2 = long) */
1254 32, /* bitsize */
1255 FALSE, /* pc_relative */
1256 0, /* bitpos */
1257 complain_overflow_dont, /* complain_on_overflow */
1258 bfd_elf_generic_reloc, /* special_function */
1259 "R_PPC64_TLS", /* name */
1260 FALSE, /* partial_inplace */
1261 0, /* src_mask */
1262 0, /* dst_mask */
1263 FALSE), /* pcrel_offset */
1264
1265 HOWTO (R_PPC64_TLSGD,
1266 0, /* rightshift */
1267 2, /* size (0 = byte, 1 = short, 2 = long) */
1268 32, /* bitsize */
1269 FALSE, /* pc_relative */
1270 0, /* bitpos */
1271 complain_overflow_dont, /* complain_on_overflow */
1272 bfd_elf_generic_reloc, /* special_function */
1273 "R_PPC64_TLSGD", /* name */
1274 FALSE, /* partial_inplace */
1275 0, /* src_mask */
1276 0, /* dst_mask */
1277 FALSE), /* pcrel_offset */
1278
1279 HOWTO (R_PPC64_TLSLD,
1280 0, /* rightshift */
1281 2, /* size (0 = byte, 1 = short, 2 = long) */
1282 32, /* bitsize */
1283 FALSE, /* pc_relative */
1284 0, /* bitpos */
1285 complain_overflow_dont, /* complain_on_overflow */
1286 bfd_elf_generic_reloc, /* special_function */
1287 "R_PPC64_TLSLD", /* name */
1288 FALSE, /* partial_inplace */
1289 0, /* src_mask */
1290 0, /* dst_mask */
1291 FALSE), /* pcrel_offset */
1292
1293 HOWTO (R_PPC64_TOCSAVE,
1294 0, /* rightshift */
1295 2, /* size (0 = byte, 1 = short, 2 = long) */
1296 32, /* bitsize */
1297 FALSE, /* pc_relative */
1298 0, /* bitpos */
1299 complain_overflow_dont, /* complain_on_overflow */
1300 bfd_elf_generic_reloc, /* special_function */
1301 "R_PPC64_TOCSAVE", /* name */
1302 FALSE, /* partial_inplace */
1303 0, /* src_mask */
1304 0, /* dst_mask */
1305 FALSE), /* pcrel_offset */
1306
1307 /* Computes the load module index of the load module that contains the
1308 definition of its TLS sym. */
1309 HOWTO (R_PPC64_DTPMOD64,
1310 0, /* rightshift */
1311 4, /* size (0 = byte, 1 = short, 2 = long) */
1312 64, /* bitsize */
1313 FALSE, /* pc_relative */
1314 0, /* bitpos */
1315 complain_overflow_dont, /* complain_on_overflow */
1316 ppc64_elf_unhandled_reloc, /* special_function */
1317 "R_PPC64_DTPMOD64", /* name */
1318 FALSE, /* partial_inplace */
1319 0, /* src_mask */
1320 ONES (64), /* dst_mask */
1321 FALSE), /* pcrel_offset */
1322
1323 /* Computes a dtv-relative displacement, the difference between the value
1324 of sym+add and the base address of the thread-local storage block that
1325 contains the definition of sym, minus 0x8000. */
1326 HOWTO (R_PPC64_DTPREL64,
1327 0, /* rightshift */
1328 4, /* size (0 = byte, 1 = short, 2 = long) */
1329 64, /* bitsize */
1330 FALSE, /* pc_relative */
1331 0, /* bitpos */
1332 complain_overflow_dont, /* complain_on_overflow */
1333 ppc64_elf_unhandled_reloc, /* special_function */
1334 "R_PPC64_DTPREL64", /* name */
1335 FALSE, /* partial_inplace */
1336 0, /* src_mask */
1337 ONES (64), /* dst_mask */
1338 FALSE), /* pcrel_offset */
1339
1340 /* A 16 bit dtprel reloc. */
1341 HOWTO (R_PPC64_DTPREL16,
1342 0, /* rightshift */
1343 1, /* size (0 = byte, 1 = short, 2 = long) */
1344 16, /* bitsize */
1345 FALSE, /* pc_relative */
1346 0, /* bitpos */
1347 complain_overflow_signed, /* complain_on_overflow */
1348 ppc64_elf_unhandled_reloc, /* special_function */
1349 "R_PPC64_DTPREL16", /* name */
1350 FALSE, /* partial_inplace */
1351 0, /* src_mask */
1352 0xffff, /* dst_mask */
1353 FALSE), /* pcrel_offset */
1354
1355 /* Like DTPREL16, but no overflow. */
1356 HOWTO (R_PPC64_DTPREL16_LO,
1357 0, /* rightshift */
1358 1, /* size (0 = byte, 1 = short, 2 = long) */
1359 16, /* bitsize */
1360 FALSE, /* pc_relative */
1361 0, /* bitpos */
1362 complain_overflow_dont, /* complain_on_overflow */
1363 ppc64_elf_unhandled_reloc, /* special_function */
1364 "R_PPC64_DTPREL16_LO", /* name */
1365 FALSE, /* partial_inplace */
1366 0, /* src_mask */
1367 0xffff, /* dst_mask */
1368 FALSE), /* pcrel_offset */
1369
1370 /* Like DTPREL16_LO, but next higher group of 16 bits. */
1371 HOWTO (R_PPC64_DTPREL16_HI,
1372 16, /* rightshift */
1373 1, /* size (0 = byte, 1 = short, 2 = long) */
1374 16, /* bitsize */
1375 FALSE, /* pc_relative */
1376 0, /* bitpos */
1377 complain_overflow_dont, /* complain_on_overflow */
1378 ppc64_elf_unhandled_reloc, /* special_function */
1379 "R_PPC64_DTPREL16_HI", /* name */
1380 FALSE, /* partial_inplace */
1381 0, /* src_mask */
1382 0xffff, /* dst_mask */
1383 FALSE), /* pcrel_offset */
1384
1385 /* Like DTPREL16_HI, but adjust for low 16 bits. */
1386 HOWTO (R_PPC64_DTPREL16_HA,
1387 16, /* rightshift */
1388 1, /* size (0 = byte, 1 = short, 2 = long) */
1389 16, /* bitsize */
1390 FALSE, /* pc_relative */
1391 0, /* bitpos */
1392 complain_overflow_dont, /* complain_on_overflow */
1393 ppc64_elf_unhandled_reloc, /* special_function */
1394 "R_PPC64_DTPREL16_HA", /* name */
1395 FALSE, /* partial_inplace */
1396 0, /* src_mask */
1397 0xffff, /* dst_mask */
1398 FALSE), /* pcrel_offset */
1399
1400 /* Like DTPREL16_HI, but next higher group of 16 bits. */
1401 HOWTO (R_PPC64_DTPREL16_HIGHER,
1402 32, /* rightshift */
1403 1, /* size (0 = byte, 1 = short, 2 = long) */
1404 16, /* bitsize */
1405 FALSE, /* pc_relative */
1406 0, /* bitpos */
1407 complain_overflow_dont, /* complain_on_overflow */
1408 ppc64_elf_unhandled_reloc, /* special_function */
1409 "R_PPC64_DTPREL16_HIGHER", /* name */
1410 FALSE, /* partial_inplace */
1411 0, /* src_mask */
1412 0xffff, /* dst_mask */
1413 FALSE), /* pcrel_offset */
1414
1415 /* Like DTPREL16_HIGHER, but adjust for low 16 bits. */
1416 HOWTO (R_PPC64_DTPREL16_HIGHERA,
1417 32, /* rightshift */
1418 1, /* size (0 = byte, 1 = short, 2 = long) */
1419 16, /* bitsize */
1420 FALSE, /* pc_relative */
1421 0, /* bitpos */
1422 complain_overflow_dont, /* complain_on_overflow */
1423 ppc64_elf_unhandled_reloc, /* special_function */
1424 "R_PPC64_DTPREL16_HIGHERA", /* name */
1425 FALSE, /* partial_inplace */
1426 0, /* src_mask */
1427 0xffff, /* dst_mask */
1428 FALSE), /* pcrel_offset */
1429
1430 /* Like DTPREL16_HIGHER, but next higher group of 16 bits. */
1431 HOWTO (R_PPC64_DTPREL16_HIGHEST,
1432 48, /* rightshift */
1433 1, /* size (0 = byte, 1 = short, 2 = long) */
1434 16, /* bitsize */
1435 FALSE, /* pc_relative */
1436 0, /* bitpos */
1437 complain_overflow_dont, /* complain_on_overflow */
1438 ppc64_elf_unhandled_reloc, /* special_function */
1439 "R_PPC64_DTPREL16_HIGHEST", /* name */
1440 FALSE, /* partial_inplace */
1441 0, /* src_mask */
1442 0xffff, /* dst_mask */
1443 FALSE), /* pcrel_offset */
1444
1445 /* Like DTPREL16_HIGHEST, but adjust for low 16 bits. */
1446 HOWTO (R_PPC64_DTPREL16_HIGHESTA,
1447 48, /* rightshift */
1448 1, /* size (0 = byte, 1 = short, 2 = long) */
1449 16, /* bitsize */
1450 FALSE, /* pc_relative */
1451 0, /* bitpos */
1452 complain_overflow_dont, /* complain_on_overflow */
1453 ppc64_elf_unhandled_reloc, /* special_function */
1454 "R_PPC64_DTPREL16_HIGHESTA", /* name */
1455 FALSE, /* partial_inplace */
1456 0, /* src_mask */
1457 0xffff, /* dst_mask */
1458 FALSE), /* pcrel_offset */
1459
1460 /* Like DTPREL16, but for insns with a DS field. */
1461 HOWTO (R_PPC64_DTPREL16_DS,
1462 0, /* rightshift */
1463 1, /* size (0 = byte, 1 = short, 2 = long) */
1464 16, /* bitsize */
1465 FALSE, /* pc_relative */
1466 0, /* bitpos */
1467 complain_overflow_signed, /* complain_on_overflow */
1468 ppc64_elf_unhandled_reloc, /* special_function */
1469 "R_PPC64_DTPREL16_DS", /* name */
1470 FALSE, /* partial_inplace */
1471 0, /* src_mask */
1472 0xfffc, /* dst_mask */
1473 FALSE), /* pcrel_offset */
1474
1475 /* Like DTPREL16_DS, but no overflow. */
1476 HOWTO (R_PPC64_DTPREL16_LO_DS,
1477 0, /* rightshift */
1478 1, /* size (0 = byte, 1 = short, 2 = long) */
1479 16, /* bitsize */
1480 FALSE, /* pc_relative */
1481 0, /* bitpos */
1482 complain_overflow_dont, /* complain_on_overflow */
1483 ppc64_elf_unhandled_reloc, /* special_function */
1484 "R_PPC64_DTPREL16_LO_DS", /* name */
1485 FALSE, /* partial_inplace */
1486 0, /* src_mask */
1487 0xfffc, /* dst_mask */
1488 FALSE), /* pcrel_offset */
1489
1490 /* Computes a tp-relative displacement, the difference between the value of
1491 sym+add and the value of the thread pointer (r13). */
1492 HOWTO (R_PPC64_TPREL64,
1493 0, /* rightshift */
1494 4, /* size (0 = byte, 1 = short, 2 = long) */
1495 64, /* bitsize */
1496 FALSE, /* pc_relative */
1497 0, /* bitpos */
1498 complain_overflow_dont, /* complain_on_overflow */
1499 ppc64_elf_unhandled_reloc, /* special_function */
1500 "R_PPC64_TPREL64", /* name */
1501 FALSE, /* partial_inplace */
1502 0, /* src_mask */
1503 ONES (64), /* dst_mask */
1504 FALSE), /* pcrel_offset */
1505
1506 /* A 16 bit tprel reloc. */
1507 HOWTO (R_PPC64_TPREL16,
1508 0, /* rightshift */
1509 1, /* size (0 = byte, 1 = short, 2 = long) */
1510 16, /* bitsize */
1511 FALSE, /* pc_relative */
1512 0, /* bitpos */
1513 complain_overflow_signed, /* complain_on_overflow */
1514 ppc64_elf_unhandled_reloc, /* special_function */
1515 "R_PPC64_TPREL16", /* name */
1516 FALSE, /* partial_inplace */
1517 0, /* src_mask */
1518 0xffff, /* dst_mask */
1519 FALSE), /* pcrel_offset */
1520
1521 /* Like TPREL16, but no overflow. */
1522 HOWTO (R_PPC64_TPREL16_LO,
1523 0, /* rightshift */
1524 1, /* size (0 = byte, 1 = short, 2 = long) */
1525 16, /* bitsize */
1526 FALSE, /* pc_relative */
1527 0, /* bitpos */
1528 complain_overflow_dont, /* complain_on_overflow */
1529 ppc64_elf_unhandled_reloc, /* special_function */
1530 "R_PPC64_TPREL16_LO", /* name */
1531 FALSE, /* partial_inplace */
1532 0, /* src_mask */
1533 0xffff, /* dst_mask */
1534 FALSE), /* pcrel_offset */
1535
1536 /* Like TPREL16_LO, but next higher group of 16 bits. */
1537 HOWTO (R_PPC64_TPREL16_HI,
1538 16, /* rightshift */
1539 1, /* size (0 = byte, 1 = short, 2 = long) */
1540 16, /* bitsize */
1541 FALSE, /* pc_relative */
1542 0, /* bitpos */
1543 complain_overflow_dont, /* complain_on_overflow */
1544 ppc64_elf_unhandled_reloc, /* special_function */
1545 "R_PPC64_TPREL16_HI", /* name */
1546 FALSE, /* partial_inplace */
1547 0, /* src_mask */
1548 0xffff, /* dst_mask */
1549 FALSE), /* pcrel_offset */
1550
1551 /* Like TPREL16_HI, but adjust for low 16 bits. */
1552 HOWTO (R_PPC64_TPREL16_HA,
1553 16, /* rightshift */
1554 1, /* size (0 = byte, 1 = short, 2 = long) */
1555 16, /* bitsize */
1556 FALSE, /* pc_relative */
1557 0, /* bitpos */
1558 complain_overflow_dont, /* complain_on_overflow */
1559 ppc64_elf_unhandled_reloc, /* special_function */
1560 "R_PPC64_TPREL16_HA", /* name */
1561 FALSE, /* partial_inplace */
1562 0, /* src_mask */
1563 0xffff, /* dst_mask */
1564 FALSE), /* pcrel_offset */
1565
1566 /* Like TPREL16_HI, but next higher group of 16 bits. */
1567 HOWTO (R_PPC64_TPREL16_HIGHER,
1568 32, /* rightshift */
1569 1, /* size (0 = byte, 1 = short, 2 = long) */
1570 16, /* bitsize */
1571 FALSE, /* pc_relative */
1572 0, /* bitpos */
1573 complain_overflow_dont, /* complain_on_overflow */
1574 ppc64_elf_unhandled_reloc, /* special_function */
1575 "R_PPC64_TPREL16_HIGHER", /* name */
1576 FALSE, /* partial_inplace */
1577 0, /* src_mask */
1578 0xffff, /* dst_mask */
1579 FALSE), /* pcrel_offset */
1580
1581 /* Like TPREL16_HIGHER, but adjust for low 16 bits. */
1582 HOWTO (R_PPC64_TPREL16_HIGHERA,
1583 32, /* rightshift */
1584 1, /* size (0 = byte, 1 = short, 2 = long) */
1585 16, /* bitsize */
1586 FALSE, /* pc_relative */
1587 0, /* bitpos */
1588 complain_overflow_dont, /* complain_on_overflow */
1589 ppc64_elf_unhandled_reloc, /* special_function */
1590 "R_PPC64_TPREL16_HIGHERA", /* name */
1591 FALSE, /* partial_inplace */
1592 0, /* src_mask */
1593 0xffff, /* dst_mask */
1594 FALSE), /* pcrel_offset */
1595
1596 /* Like TPREL16_HIGHER, but next higher group of 16 bits. */
1597 HOWTO (R_PPC64_TPREL16_HIGHEST,
1598 48, /* rightshift */
1599 1, /* size (0 = byte, 1 = short, 2 = long) */
1600 16, /* bitsize */
1601 FALSE, /* pc_relative */
1602 0, /* bitpos */
1603 complain_overflow_dont, /* complain_on_overflow */
1604 ppc64_elf_unhandled_reloc, /* special_function */
1605 "R_PPC64_TPREL16_HIGHEST", /* name */
1606 FALSE, /* partial_inplace */
1607 0, /* src_mask */
1608 0xffff, /* dst_mask */
1609 FALSE), /* pcrel_offset */
1610
1611 /* Like TPREL16_HIGHEST, but adjust for low 16 bits. */
1612 HOWTO (R_PPC64_TPREL16_HIGHESTA,
1613 48, /* rightshift */
1614 1, /* size (0 = byte, 1 = short, 2 = long) */
1615 16, /* bitsize */
1616 FALSE, /* pc_relative */
1617 0, /* bitpos */
1618 complain_overflow_dont, /* complain_on_overflow */
1619 ppc64_elf_unhandled_reloc, /* special_function */
1620 "R_PPC64_TPREL16_HIGHESTA", /* name */
1621 FALSE, /* partial_inplace */
1622 0, /* src_mask */
1623 0xffff, /* dst_mask */
1624 FALSE), /* pcrel_offset */
1625
1626 /* Like TPREL16, but for insns with a DS field. */
1627 HOWTO (R_PPC64_TPREL16_DS,
1628 0, /* rightshift */
1629 1, /* size (0 = byte, 1 = short, 2 = long) */
1630 16, /* bitsize */
1631 FALSE, /* pc_relative */
1632 0, /* bitpos */
1633 complain_overflow_signed, /* complain_on_overflow */
1634 ppc64_elf_unhandled_reloc, /* special_function */
1635 "R_PPC64_TPREL16_DS", /* name */
1636 FALSE, /* partial_inplace */
1637 0, /* src_mask */
1638 0xfffc, /* dst_mask */
1639 FALSE), /* pcrel_offset */
1640
1641 /* Like TPREL16_DS, but no overflow. */
1642 HOWTO (R_PPC64_TPREL16_LO_DS,
1643 0, /* rightshift */
1644 1, /* size (0 = byte, 1 = short, 2 = long) */
1645 16, /* bitsize */
1646 FALSE, /* pc_relative */
1647 0, /* bitpos */
1648 complain_overflow_dont, /* complain_on_overflow */
1649 ppc64_elf_unhandled_reloc, /* special_function */
1650 "R_PPC64_TPREL16_LO_DS", /* name */
1651 FALSE, /* partial_inplace */
1652 0, /* src_mask */
1653 0xfffc, /* dst_mask */
1654 FALSE), /* pcrel_offset */
1655
1656 /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1657 with values (sym+add)@dtpmod and (sym+add)@dtprel, and computes the offset
1658 to the first entry relative to the TOC base (r2). */
1659 HOWTO (R_PPC64_GOT_TLSGD16,
1660 0, /* rightshift */
1661 1, /* size (0 = byte, 1 = short, 2 = long) */
1662 16, /* bitsize */
1663 FALSE, /* pc_relative */
1664 0, /* bitpos */
1665 complain_overflow_signed, /* complain_on_overflow */
1666 ppc64_elf_unhandled_reloc, /* special_function */
1667 "R_PPC64_GOT_TLSGD16", /* name */
1668 FALSE, /* partial_inplace */
1669 0, /* src_mask */
1670 0xffff, /* dst_mask */
1671 FALSE), /* pcrel_offset */
1672
1673 /* Like GOT_TLSGD16, but no overflow. */
1674 HOWTO (R_PPC64_GOT_TLSGD16_LO,
1675 0, /* rightshift */
1676 1, /* size (0 = byte, 1 = short, 2 = long) */
1677 16, /* bitsize */
1678 FALSE, /* pc_relative */
1679 0, /* bitpos */
1680 complain_overflow_dont, /* complain_on_overflow */
1681 ppc64_elf_unhandled_reloc, /* special_function */
1682 "R_PPC64_GOT_TLSGD16_LO", /* name */
1683 FALSE, /* partial_inplace */
1684 0, /* src_mask */
1685 0xffff, /* dst_mask */
1686 FALSE), /* pcrel_offset */
1687
1688 /* Like GOT_TLSGD16_LO, but next higher group of 16 bits. */
1689 HOWTO (R_PPC64_GOT_TLSGD16_HI,
1690 16, /* rightshift */
1691 1, /* size (0 = byte, 1 = short, 2 = long) */
1692 16, /* bitsize */
1693 FALSE, /* pc_relative */
1694 0, /* bitpos */
1695 complain_overflow_dont, /* complain_on_overflow */
1696 ppc64_elf_unhandled_reloc, /* special_function */
1697 "R_PPC64_GOT_TLSGD16_HI", /* name */
1698 FALSE, /* partial_inplace */
1699 0, /* src_mask */
1700 0xffff, /* dst_mask */
1701 FALSE), /* pcrel_offset */
1702
1703 /* Like GOT_TLSGD16_HI, but adjust for low 16 bits. */
1704 HOWTO (R_PPC64_GOT_TLSGD16_HA,
1705 16, /* rightshift */
1706 1, /* size (0 = byte, 1 = short, 2 = long) */
1707 16, /* bitsize */
1708 FALSE, /* pc_relative */
1709 0, /* bitpos */
1710 complain_overflow_dont, /* complain_on_overflow */
1711 ppc64_elf_unhandled_reloc, /* special_function */
1712 "R_PPC64_GOT_TLSGD16_HA", /* name */
1713 FALSE, /* partial_inplace */
1714 0, /* src_mask */
1715 0xffff, /* dst_mask */
1716 FALSE), /* pcrel_offset */
1717
1718 /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1719 with values (sym+add)@dtpmod and zero, and computes the offset to the
1720 first entry relative to the TOC base (r2). */
1721 HOWTO (R_PPC64_GOT_TLSLD16,
1722 0, /* rightshift */
1723 1, /* size (0 = byte, 1 = short, 2 = long) */
1724 16, /* bitsize */
1725 FALSE, /* pc_relative */
1726 0, /* bitpos */
1727 complain_overflow_signed, /* complain_on_overflow */
1728 ppc64_elf_unhandled_reloc, /* special_function */
1729 "R_PPC64_GOT_TLSLD16", /* name */
1730 FALSE, /* partial_inplace */
1731 0, /* src_mask */
1732 0xffff, /* dst_mask */
1733 FALSE), /* pcrel_offset */
1734
1735 /* Like GOT_TLSLD16, but no overflow. */
1736 HOWTO (R_PPC64_GOT_TLSLD16_LO,
1737 0, /* rightshift */
1738 1, /* size (0 = byte, 1 = short, 2 = long) */
1739 16, /* bitsize */
1740 FALSE, /* pc_relative */
1741 0, /* bitpos */
1742 complain_overflow_dont, /* complain_on_overflow */
1743 ppc64_elf_unhandled_reloc, /* special_function */
1744 "R_PPC64_GOT_TLSLD16_LO", /* name */
1745 FALSE, /* partial_inplace */
1746 0, /* src_mask */
1747 0xffff, /* dst_mask */
1748 FALSE), /* pcrel_offset */
1749
1750 /* Like GOT_TLSLD16_LO, but next higher group of 16 bits. */
1751 HOWTO (R_PPC64_GOT_TLSLD16_HI,
1752 16, /* rightshift */
1753 1, /* size (0 = byte, 1 = short, 2 = long) */
1754 16, /* bitsize */
1755 FALSE, /* pc_relative */
1756 0, /* bitpos */
1757 complain_overflow_dont, /* complain_on_overflow */
1758 ppc64_elf_unhandled_reloc, /* special_function */
1759 "R_PPC64_GOT_TLSLD16_HI", /* name */
1760 FALSE, /* partial_inplace */
1761 0, /* src_mask */
1762 0xffff, /* dst_mask */
1763 FALSE), /* pcrel_offset */
1764
1765 /* Like GOT_TLSLD16_HI, but adjust for low 16 bits. */
1766 HOWTO (R_PPC64_GOT_TLSLD16_HA,
1767 16, /* rightshift */
1768 1, /* size (0 = byte, 1 = short, 2 = long) */
1769 16, /* bitsize */
1770 FALSE, /* pc_relative */
1771 0, /* bitpos */
1772 complain_overflow_dont, /* complain_on_overflow */
1773 ppc64_elf_unhandled_reloc, /* special_function */
1774 "R_PPC64_GOT_TLSLD16_HA", /* name */
1775 FALSE, /* partial_inplace */
1776 0, /* src_mask */
1777 0xffff, /* dst_mask */
1778 FALSE), /* pcrel_offset */
1779
1780 /* Allocates an entry in the GOT with value (sym+add)@dtprel, and computes
1781 the offset to the entry relative to the TOC base (r2). */
1782 HOWTO (R_PPC64_GOT_DTPREL16_DS,
1783 0, /* rightshift */
1784 1, /* size (0 = byte, 1 = short, 2 = long) */
1785 16, /* bitsize */
1786 FALSE, /* pc_relative */
1787 0, /* bitpos */
1788 complain_overflow_signed, /* complain_on_overflow */
1789 ppc64_elf_unhandled_reloc, /* special_function */
1790 "R_PPC64_GOT_DTPREL16_DS", /* name */
1791 FALSE, /* partial_inplace */
1792 0, /* src_mask */
1793 0xfffc, /* dst_mask */
1794 FALSE), /* pcrel_offset */
1795
1796 /* Like GOT_DTPREL16_DS, but no overflow. */
1797 HOWTO (R_PPC64_GOT_DTPREL16_LO_DS,
1798 0, /* rightshift */
1799 1, /* size (0 = byte, 1 = short, 2 = long) */
1800 16, /* bitsize */
1801 FALSE, /* pc_relative */
1802 0, /* bitpos */
1803 complain_overflow_dont, /* complain_on_overflow */
1804 ppc64_elf_unhandled_reloc, /* special_function */
1805 "R_PPC64_GOT_DTPREL16_LO_DS", /* name */
1806 FALSE, /* partial_inplace */
1807 0, /* src_mask */
1808 0xfffc, /* dst_mask */
1809 FALSE), /* pcrel_offset */
1810
1811 /* Like GOT_DTPREL16_LO_DS, but next higher group of 16 bits. */
1812 HOWTO (R_PPC64_GOT_DTPREL16_HI,
1813 16, /* rightshift */
1814 1, /* size (0 = byte, 1 = short, 2 = long) */
1815 16, /* bitsize */
1816 FALSE, /* pc_relative */
1817 0, /* bitpos */
1818 complain_overflow_dont, /* complain_on_overflow */
1819 ppc64_elf_unhandled_reloc, /* special_function */
1820 "R_PPC64_GOT_DTPREL16_HI", /* name */
1821 FALSE, /* partial_inplace */
1822 0, /* src_mask */
1823 0xffff, /* dst_mask */
1824 FALSE), /* pcrel_offset */
1825
1826 /* Like GOT_DTPREL16_HI, but adjust for low 16 bits. */
1827 HOWTO (R_PPC64_GOT_DTPREL16_HA,
1828 16, /* rightshift */
1829 1, /* size (0 = byte, 1 = short, 2 = long) */
1830 16, /* bitsize */
1831 FALSE, /* pc_relative */
1832 0, /* bitpos */
1833 complain_overflow_dont, /* complain_on_overflow */
1834 ppc64_elf_unhandled_reloc, /* special_function */
1835 "R_PPC64_GOT_DTPREL16_HA", /* name */
1836 FALSE, /* partial_inplace */
1837 0, /* src_mask */
1838 0xffff, /* dst_mask */
1839 FALSE), /* pcrel_offset */
1840
1841 /* Allocates an entry in the GOT with value (sym+add)@tprel, and computes the
1842 offset to the entry relative to the TOC base (r2). */
1843 HOWTO (R_PPC64_GOT_TPREL16_DS,
1844 0, /* rightshift */
1845 1, /* size (0 = byte, 1 = short, 2 = long) */
1846 16, /* bitsize */
1847 FALSE, /* pc_relative */
1848 0, /* bitpos */
1849 complain_overflow_signed, /* complain_on_overflow */
1850 ppc64_elf_unhandled_reloc, /* special_function */
1851 "R_PPC64_GOT_TPREL16_DS", /* name */
1852 FALSE, /* partial_inplace */
1853 0, /* src_mask */
1854 0xfffc, /* dst_mask */
1855 FALSE), /* pcrel_offset */
1856
1857 /* Like GOT_TPREL16_DS, but no overflow. */
1858 HOWTO (R_PPC64_GOT_TPREL16_LO_DS,
1859 0, /* rightshift */
1860 1, /* size (0 = byte, 1 = short, 2 = long) */
1861 16, /* bitsize */
1862 FALSE, /* pc_relative */
1863 0, /* bitpos */
1864 complain_overflow_dont, /* complain_on_overflow */
1865 ppc64_elf_unhandled_reloc, /* special_function */
1866 "R_PPC64_GOT_TPREL16_LO_DS", /* name */
1867 FALSE, /* partial_inplace */
1868 0, /* src_mask */
1869 0xfffc, /* dst_mask */
1870 FALSE), /* pcrel_offset */
1871
1872 /* Like GOT_TPREL16_LO_DS, but next higher group of 16 bits. */
1873 HOWTO (R_PPC64_GOT_TPREL16_HI,
1874 16, /* rightshift */
1875 1, /* size (0 = byte, 1 = short, 2 = long) */
1876 16, /* bitsize */
1877 FALSE, /* pc_relative */
1878 0, /* bitpos */
1879 complain_overflow_dont, /* complain_on_overflow */
1880 ppc64_elf_unhandled_reloc, /* special_function */
1881 "R_PPC64_GOT_TPREL16_HI", /* name */
1882 FALSE, /* partial_inplace */
1883 0, /* src_mask */
1884 0xffff, /* dst_mask */
1885 FALSE), /* pcrel_offset */
1886
1887 /* Like GOT_TPREL16_HI, but adjust for low 16 bits. */
1888 HOWTO (R_PPC64_GOT_TPREL16_HA,
1889 16, /* rightshift */
1890 1, /* size (0 = byte, 1 = short, 2 = long) */
1891 16, /* bitsize */
1892 FALSE, /* pc_relative */
1893 0, /* bitpos */
1894 complain_overflow_dont, /* complain_on_overflow */
1895 ppc64_elf_unhandled_reloc, /* special_function */
1896 "R_PPC64_GOT_TPREL16_HA", /* name */
1897 FALSE, /* partial_inplace */
1898 0, /* src_mask */
1899 0xffff, /* dst_mask */
1900 FALSE), /* pcrel_offset */
1901
1902 HOWTO (R_PPC64_JMP_IREL, /* type */
1903 0, /* rightshift */
1904 0, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1905 0, /* bitsize */
1906 FALSE, /* pc_relative */
1907 0, /* bitpos */
1908 complain_overflow_dont, /* complain_on_overflow */
1909 ppc64_elf_unhandled_reloc, /* special_function */
1910 "R_PPC64_JMP_IREL", /* name */
1911 FALSE, /* partial_inplace */
1912 0, /* src_mask */
1913 0, /* dst_mask */
1914 FALSE), /* pcrel_offset */
1915
1916 HOWTO (R_PPC64_IRELATIVE, /* type */
1917 0, /* rightshift */
1918 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1919 64, /* bitsize */
1920 FALSE, /* pc_relative */
1921 0, /* bitpos */
1922 complain_overflow_dont, /* complain_on_overflow */
1923 bfd_elf_generic_reloc, /* special_function */
1924 "R_PPC64_IRELATIVE", /* name */
1925 FALSE, /* partial_inplace */
1926 0, /* src_mask */
1927 ONES (64), /* dst_mask */
1928 FALSE), /* pcrel_offset */
1929
1930 /* A 16 bit relative relocation. */
1931 HOWTO (R_PPC64_REL16, /* type */
1932 0, /* rightshift */
1933 1, /* size (0 = byte, 1 = short, 2 = long) */
1934 16, /* bitsize */
1935 TRUE, /* pc_relative */
1936 0, /* bitpos */
1937 complain_overflow_bitfield, /* complain_on_overflow */
1938 bfd_elf_generic_reloc, /* special_function */
1939 "R_PPC64_REL16", /* name */
1940 FALSE, /* partial_inplace */
1941 0, /* src_mask */
1942 0xffff, /* dst_mask */
1943 TRUE), /* pcrel_offset */
1944
1945 /* A 16 bit relative relocation without overflow. */
1946 HOWTO (R_PPC64_REL16_LO, /* type */
1947 0, /* rightshift */
1948 1, /* size (0 = byte, 1 = short, 2 = long) */
1949 16, /* bitsize */
1950 TRUE, /* pc_relative */
1951 0, /* bitpos */
1952 complain_overflow_dont,/* complain_on_overflow */
1953 bfd_elf_generic_reloc, /* special_function */
1954 "R_PPC64_REL16_LO", /* name */
1955 FALSE, /* partial_inplace */
1956 0, /* src_mask */
1957 0xffff, /* dst_mask */
1958 TRUE), /* pcrel_offset */
1959
1960 /* The high order 16 bits of a relative address. */
1961 HOWTO (R_PPC64_REL16_HI, /* type */
1962 16, /* rightshift */
1963 1, /* size (0 = byte, 1 = short, 2 = long) */
1964 16, /* bitsize */
1965 TRUE, /* pc_relative */
1966 0, /* bitpos */
1967 complain_overflow_dont, /* complain_on_overflow */
1968 bfd_elf_generic_reloc, /* special_function */
1969 "R_PPC64_REL16_HI", /* name */
1970 FALSE, /* partial_inplace */
1971 0, /* src_mask */
1972 0xffff, /* dst_mask */
1973 TRUE), /* pcrel_offset */
1974
1975 /* The high order 16 bits of a relative address, plus 1 if the contents of
1976 the low 16 bits, treated as a signed number, is negative. */
1977 HOWTO (R_PPC64_REL16_HA, /* type */
1978 16, /* rightshift */
1979 1, /* size (0 = byte, 1 = short, 2 = long) */
1980 16, /* bitsize */
1981 TRUE, /* pc_relative */
1982 0, /* bitpos */
1983 complain_overflow_dont, /* complain_on_overflow */
1984 ppc64_elf_ha_reloc, /* special_function */
1985 "R_PPC64_REL16_HA", /* name */
1986 FALSE, /* partial_inplace */
1987 0, /* src_mask */
1988 0xffff, /* dst_mask */
1989 TRUE), /* pcrel_offset */
1990
1991 /* GNU extension to record C++ vtable hierarchy. */
1992 HOWTO (R_PPC64_GNU_VTINHERIT, /* type */
1993 0, /* rightshift */
1994 0, /* size (0 = byte, 1 = short, 2 = long) */
1995 0, /* bitsize */
1996 FALSE, /* pc_relative */
1997 0, /* bitpos */
1998 complain_overflow_dont, /* complain_on_overflow */
1999 NULL, /* special_function */
2000 "R_PPC64_GNU_VTINHERIT", /* name */
2001 FALSE, /* partial_inplace */
2002 0, /* src_mask */
2003 0, /* dst_mask */
2004 FALSE), /* pcrel_offset */
2005
2006 /* GNU extension to record C++ vtable member usage. */
2007 HOWTO (R_PPC64_GNU_VTENTRY, /* type */
2008 0, /* rightshift */
2009 0, /* size (0 = byte, 1 = short, 2 = long) */
2010 0, /* bitsize */
2011 FALSE, /* pc_relative */
2012 0, /* bitpos */
2013 complain_overflow_dont, /* complain_on_overflow */
2014 NULL, /* special_function */
2015 "R_PPC64_GNU_VTENTRY", /* name */
2016 FALSE, /* partial_inplace */
2017 0, /* src_mask */
2018 0, /* dst_mask */
2019 FALSE), /* pcrel_offset */
2020 };
2021
2022 \f
2023 /* Initialize the ppc64_elf_howto_table, so that linear accesses can
2024 be done. */
2025
2026 static void
2027 ppc_howto_init (void)
2028 {
2029 unsigned int i, type;
2030
2031 for (i = 0;
2032 i < sizeof (ppc64_elf_howto_raw) / sizeof (ppc64_elf_howto_raw[0]);
2033 i++)
2034 {
2035 type = ppc64_elf_howto_raw[i].type;
2036 BFD_ASSERT (type < (sizeof (ppc64_elf_howto_table)
2037 / sizeof (ppc64_elf_howto_table[0])));
2038 ppc64_elf_howto_table[type] = &ppc64_elf_howto_raw[i];
2039 }
2040 }
2041
2042 static reloc_howto_type *
2043 ppc64_elf_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2044 bfd_reloc_code_real_type code)
2045 {
2046 enum elf_ppc64_reloc_type r = R_PPC64_NONE;
2047
2048 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2049 /* Initialize howto table if needed. */
2050 ppc_howto_init ();
2051
2052 switch (code)
2053 {
2054 default:
2055 return NULL;
2056
2057 case BFD_RELOC_NONE: r = R_PPC64_NONE;
2058 break;
2059 case BFD_RELOC_32: r = R_PPC64_ADDR32;
2060 break;
2061 case BFD_RELOC_PPC_BA26: r = R_PPC64_ADDR24;
2062 break;
2063 case BFD_RELOC_16: r = R_PPC64_ADDR16;
2064 break;
2065 case BFD_RELOC_LO16: r = R_PPC64_ADDR16_LO;
2066 break;
2067 case BFD_RELOC_HI16: r = R_PPC64_ADDR16_HI;
2068 break;
2069 case BFD_RELOC_HI16_S: r = R_PPC64_ADDR16_HA;
2070 break;
2071 case BFD_RELOC_PPC_BA16: r = R_PPC64_ADDR14;
2072 break;
2073 case BFD_RELOC_PPC_BA16_BRTAKEN: r = R_PPC64_ADDR14_BRTAKEN;
2074 break;
2075 case BFD_RELOC_PPC_BA16_BRNTAKEN: r = R_PPC64_ADDR14_BRNTAKEN;
2076 break;
2077 case BFD_RELOC_PPC_B26: r = R_PPC64_REL24;
2078 break;
2079 case BFD_RELOC_PPC_B16: r = R_PPC64_REL14;
2080 break;
2081 case BFD_RELOC_PPC_B16_BRTAKEN: r = R_PPC64_REL14_BRTAKEN;
2082 break;
2083 case BFD_RELOC_PPC_B16_BRNTAKEN: r = R_PPC64_REL14_BRNTAKEN;
2084 break;
2085 case BFD_RELOC_16_GOTOFF: r = R_PPC64_GOT16;
2086 break;
2087 case BFD_RELOC_LO16_GOTOFF: r = R_PPC64_GOT16_LO;
2088 break;
2089 case BFD_RELOC_HI16_GOTOFF: r = R_PPC64_GOT16_HI;
2090 break;
2091 case BFD_RELOC_HI16_S_GOTOFF: r = R_PPC64_GOT16_HA;
2092 break;
2093 case BFD_RELOC_PPC_COPY: r = R_PPC64_COPY;
2094 break;
2095 case BFD_RELOC_PPC_GLOB_DAT: r = R_PPC64_GLOB_DAT;
2096 break;
2097 case BFD_RELOC_32_PCREL: r = R_PPC64_REL32;
2098 break;
2099 case BFD_RELOC_32_PLTOFF: r = R_PPC64_PLT32;
2100 break;
2101 case BFD_RELOC_32_PLT_PCREL: r = R_PPC64_PLTREL32;
2102 break;
2103 case BFD_RELOC_LO16_PLTOFF: r = R_PPC64_PLT16_LO;
2104 break;
2105 case BFD_RELOC_HI16_PLTOFF: r = R_PPC64_PLT16_HI;
2106 break;
2107 case BFD_RELOC_HI16_S_PLTOFF: r = R_PPC64_PLT16_HA;
2108 break;
2109 case BFD_RELOC_16_BASEREL: r = R_PPC64_SECTOFF;
2110 break;
2111 case BFD_RELOC_LO16_BASEREL: r = R_PPC64_SECTOFF_LO;
2112 break;
2113 case BFD_RELOC_HI16_BASEREL: r = R_PPC64_SECTOFF_HI;
2114 break;
2115 case BFD_RELOC_HI16_S_BASEREL: r = R_PPC64_SECTOFF_HA;
2116 break;
2117 case BFD_RELOC_CTOR: r = R_PPC64_ADDR64;
2118 break;
2119 case BFD_RELOC_64: r = R_PPC64_ADDR64;
2120 break;
2121 case BFD_RELOC_PPC64_HIGHER: r = R_PPC64_ADDR16_HIGHER;
2122 break;
2123 case BFD_RELOC_PPC64_HIGHER_S: r = R_PPC64_ADDR16_HIGHERA;
2124 break;
2125 case BFD_RELOC_PPC64_HIGHEST: r = R_PPC64_ADDR16_HIGHEST;
2126 break;
2127 case BFD_RELOC_PPC64_HIGHEST_S: r = R_PPC64_ADDR16_HIGHESTA;
2128 break;
2129 case BFD_RELOC_64_PCREL: r = R_PPC64_REL64;
2130 break;
2131 case BFD_RELOC_64_PLTOFF: r = R_PPC64_PLT64;
2132 break;
2133 case BFD_RELOC_64_PLT_PCREL: r = R_PPC64_PLTREL64;
2134 break;
2135 case BFD_RELOC_PPC_TOC16: r = R_PPC64_TOC16;
2136 break;
2137 case BFD_RELOC_PPC64_TOC16_LO: r = R_PPC64_TOC16_LO;
2138 break;
2139 case BFD_RELOC_PPC64_TOC16_HI: r = R_PPC64_TOC16_HI;
2140 break;
2141 case BFD_RELOC_PPC64_TOC16_HA: r = R_PPC64_TOC16_HA;
2142 break;
2143 case BFD_RELOC_PPC64_TOC: r = R_PPC64_TOC;
2144 break;
2145 case BFD_RELOC_PPC64_PLTGOT16: r = R_PPC64_PLTGOT16;
2146 break;
2147 case BFD_RELOC_PPC64_PLTGOT16_LO: r = R_PPC64_PLTGOT16_LO;
2148 break;
2149 case BFD_RELOC_PPC64_PLTGOT16_HI: r = R_PPC64_PLTGOT16_HI;
2150 break;
2151 case BFD_RELOC_PPC64_PLTGOT16_HA: r = R_PPC64_PLTGOT16_HA;
2152 break;
2153 case BFD_RELOC_PPC64_ADDR16_DS: r = R_PPC64_ADDR16_DS;
2154 break;
2155 case BFD_RELOC_PPC64_ADDR16_LO_DS: r = R_PPC64_ADDR16_LO_DS;
2156 break;
2157 case BFD_RELOC_PPC64_GOT16_DS: r = R_PPC64_GOT16_DS;
2158 break;
2159 case BFD_RELOC_PPC64_GOT16_LO_DS: r = R_PPC64_GOT16_LO_DS;
2160 break;
2161 case BFD_RELOC_PPC64_PLT16_LO_DS: r = R_PPC64_PLT16_LO_DS;
2162 break;
2163 case BFD_RELOC_PPC64_SECTOFF_DS: r = R_PPC64_SECTOFF_DS;
2164 break;
2165 case BFD_RELOC_PPC64_SECTOFF_LO_DS: r = R_PPC64_SECTOFF_LO_DS;
2166 break;
2167 case BFD_RELOC_PPC64_TOC16_DS: r = R_PPC64_TOC16_DS;
2168 break;
2169 case BFD_RELOC_PPC64_TOC16_LO_DS: r = R_PPC64_TOC16_LO_DS;
2170 break;
2171 case BFD_RELOC_PPC64_PLTGOT16_DS: r = R_PPC64_PLTGOT16_DS;
2172 break;
2173 case BFD_RELOC_PPC64_PLTGOT16_LO_DS: r = R_PPC64_PLTGOT16_LO_DS;
2174 break;
2175 case BFD_RELOC_PPC_TLS: r = R_PPC64_TLS;
2176 break;
2177 case BFD_RELOC_PPC_TLSGD: r = R_PPC64_TLSGD;
2178 break;
2179 case BFD_RELOC_PPC_TLSLD: r = R_PPC64_TLSLD;
2180 break;
2181 case BFD_RELOC_PPC_DTPMOD: r = R_PPC64_DTPMOD64;
2182 break;
2183 case BFD_RELOC_PPC_TPREL16: r = R_PPC64_TPREL16;
2184 break;
2185 case BFD_RELOC_PPC_TPREL16_LO: r = R_PPC64_TPREL16_LO;
2186 break;
2187 case BFD_RELOC_PPC_TPREL16_HI: r = R_PPC64_TPREL16_HI;
2188 break;
2189 case BFD_RELOC_PPC_TPREL16_HA: r = R_PPC64_TPREL16_HA;
2190 break;
2191 case BFD_RELOC_PPC_TPREL: r = R_PPC64_TPREL64;
2192 break;
2193 case BFD_RELOC_PPC_DTPREL16: r = R_PPC64_DTPREL16;
2194 break;
2195 case BFD_RELOC_PPC_DTPREL16_LO: r = R_PPC64_DTPREL16_LO;
2196 break;
2197 case BFD_RELOC_PPC_DTPREL16_HI: r = R_PPC64_DTPREL16_HI;
2198 break;
2199 case BFD_RELOC_PPC_DTPREL16_HA: r = R_PPC64_DTPREL16_HA;
2200 break;
2201 case BFD_RELOC_PPC_DTPREL: r = R_PPC64_DTPREL64;
2202 break;
2203 case BFD_RELOC_PPC_GOT_TLSGD16: r = R_PPC64_GOT_TLSGD16;
2204 break;
2205 case BFD_RELOC_PPC_GOT_TLSGD16_LO: r = R_PPC64_GOT_TLSGD16_LO;
2206 break;
2207 case BFD_RELOC_PPC_GOT_TLSGD16_HI: r = R_PPC64_GOT_TLSGD16_HI;
2208 break;
2209 case BFD_RELOC_PPC_GOT_TLSGD16_HA: r = R_PPC64_GOT_TLSGD16_HA;
2210 break;
2211 case BFD_RELOC_PPC_GOT_TLSLD16: r = R_PPC64_GOT_TLSLD16;
2212 break;
2213 case BFD_RELOC_PPC_GOT_TLSLD16_LO: r = R_PPC64_GOT_TLSLD16_LO;
2214 break;
2215 case BFD_RELOC_PPC_GOT_TLSLD16_HI: r = R_PPC64_GOT_TLSLD16_HI;
2216 break;
2217 case BFD_RELOC_PPC_GOT_TLSLD16_HA: r = R_PPC64_GOT_TLSLD16_HA;
2218 break;
2219 case BFD_RELOC_PPC_GOT_TPREL16: r = R_PPC64_GOT_TPREL16_DS;
2220 break;
2221 case BFD_RELOC_PPC_GOT_TPREL16_LO: r = R_PPC64_GOT_TPREL16_LO_DS;
2222 break;
2223 case BFD_RELOC_PPC_GOT_TPREL16_HI: r = R_PPC64_GOT_TPREL16_HI;
2224 break;
2225 case BFD_RELOC_PPC_GOT_TPREL16_HA: r = R_PPC64_GOT_TPREL16_HA;
2226 break;
2227 case BFD_RELOC_PPC_GOT_DTPREL16: r = R_PPC64_GOT_DTPREL16_DS;
2228 break;
2229 case BFD_RELOC_PPC_GOT_DTPREL16_LO: r = R_PPC64_GOT_DTPREL16_LO_DS;
2230 break;
2231 case BFD_RELOC_PPC_GOT_DTPREL16_HI: r = R_PPC64_GOT_DTPREL16_HI;
2232 break;
2233 case BFD_RELOC_PPC_GOT_DTPREL16_HA: r = R_PPC64_GOT_DTPREL16_HA;
2234 break;
2235 case BFD_RELOC_PPC64_TPREL16_DS: r = R_PPC64_TPREL16_DS;
2236 break;
2237 case BFD_RELOC_PPC64_TPREL16_LO_DS: r = R_PPC64_TPREL16_LO_DS;
2238 break;
2239 case BFD_RELOC_PPC64_TPREL16_HIGHER: r = R_PPC64_TPREL16_HIGHER;
2240 break;
2241 case BFD_RELOC_PPC64_TPREL16_HIGHERA: r = R_PPC64_TPREL16_HIGHERA;
2242 break;
2243 case BFD_RELOC_PPC64_TPREL16_HIGHEST: r = R_PPC64_TPREL16_HIGHEST;
2244 break;
2245 case BFD_RELOC_PPC64_TPREL16_HIGHESTA: r = R_PPC64_TPREL16_HIGHESTA;
2246 break;
2247 case BFD_RELOC_PPC64_DTPREL16_DS: r = R_PPC64_DTPREL16_DS;
2248 break;
2249 case BFD_RELOC_PPC64_DTPREL16_LO_DS: r = R_PPC64_DTPREL16_LO_DS;
2250 break;
2251 case BFD_RELOC_PPC64_DTPREL16_HIGHER: r = R_PPC64_DTPREL16_HIGHER;
2252 break;
2253 case BFD_RELOC_PPC64_DTPREL16_HIGHERA: r = R_PPC64_DTPREL16_HIGHERA;
2254 break;
2255 case BFD_RELOC_PPC64_DTPREL16_HIGHEST: r = R_PPC64_DTPREL16_HIGHEST;
2256 break;
2257 case BFD_RELOC_PPC64_DTPREL16_HIGHESTA: r = R_PPC64_DTPREL16_HIGHESTA;
2258 break;
2259 case BFD_RELOC_16_PCREL: r = R_PPC64_REL16;
2260 break;
2261 case BFD_RELOC_LO16_PCREL: r = R_PPC64_REL16_LO;
2262 break;
2263 case BFD_RELOC_HI16_PCREL: r = R_PPC64_REL16_HI;
2264 break;
2265 case BFD_RELOC_HI16_S_PCREL: r = R_PPC64_REL16_HA;
2266 break;
2267 case BFD_RELOC_VTABLE_INHERIT: r = R_PPC64_GNU_VTINHERIT;
2268 break;
2269 case BFD_RELOC_VTABLE_ENTRY: r = R_PPC64_GNU_VTENTRY;
2270 break;
2271 }
2272
2273 return ppc64_elf_howto_table[r];
2274 };
2275
2276 static reloc_howto_type *
2277 ppc64_elf_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2278 const char *r_name)
2279 {
2280 unsigned int i;
2281
2282 for (i = 0;
2283 i < sizeof (ppc64_elf_howto_raw) / sizeof (ppc64_elf_howto_raw[0]);
2284 i++)
2285 if (ppc64_elf_howto_raw[i].name != NULL
2286 && strcasecmp (ppc64_elf_howto_raw[i].name, r_name) == 0)
2287 return &ppc64_elf_howto_raw[i];
2288
2289 return NULL;
2290 }
2291
2292 /* Set the howto pointer for a PowerPC ELF reloc. */
2293
2294 static void
2295 ppc64_elf_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr,
2296 Elf_Internal_Rela *dst)
2297 {
2298 unsigned int type;
2299
2300 /* Initialize howto table if needed. */
2301 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2302 ppc_howto_init ();
2303
2304 type = ELF64_R_TYPE (dst->r_info);
2305 if (type >= (sizeof (ppc64_elf_howto_table)
2306 / sizeof (ppc64_elf_howto_table[0])))
2307 {
2308 (*_bfd_error_handler) (_("%B: invalid relocation type %d"),
2309 abfd, (int) type);
2310 type = R_PPC64_NONE;
2311 }
2312 cache_ptr->howto = ppc64_elf_howto_table[type];
2313 }
2314
2315 /* Handle the R_PPC64_ADDR16_HA and similar relocs. */
2316
2317 static bfd_reloc_status_type
2318 ppc64_elf_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2319 void *data, asection *input_section,
2320 bfd *output_bfd, char **error_message)
2321 {
2322 /* If this is a relocatable link (output_bfd test tells us), just
2323 call the generic function. Any adjustment will be done at final
2324 link time. */
2325 if (output_bfd != NULL)
2326 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2327 input_section, output_bfd, error_message);
2328
2329 /* Adjust the addend for sign extension of the low 16 bits.
2330 We won't actually be using the low 16 bits, so trashing them
2331 doesn't matter. */
2332 reloc_entry->addend += 0x8000;
2333 return bfd_reloc_continue;
2334 }
2335
2336 static bfd_reloc_status_type
2337 ppc64_elf_branch_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2338 void *data, asection *input_section,
2339 bfd *output_bfd, char **error_message)
2340 {
2341 if (output_bfd != NULL)
2342 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2343 input_section, output_bfd, error_message);
2344
2345 if (strcmp (symbol->section->name, ".opd") == 0
2346 && (symbol->section->owner->flags & DYNAMIC) == 0)
2347 {
2348 bfd_vma dest = opd_entry_value (symbol->section,
2349 symbol->value + reloc_entry->addend,
2350 NULL, NULL, FALSE);
2351 if (dest != (bfd_vma) -1)
2352 reloc_entry->addend = dest - (symbol->value
2353 + symbol->section->output_section->vma
2354 + symbol->section->output_offset);
2355 }
2356 return bfd_reloc_continue;
2357 }
2358
2359 static bfd_reloc_status_type
2360 ppc64_elf_brtaken_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2361 void *data, asection *input_section,
2362 bfd *output_bfd, char **error_message)
2363 {
2364 long insn;
2365 enum elf_ppc64_reloc_type r_type;
2366 bfd_size_type octets;
2367 /* Assume 'at' branch hints. */
2368 bfd_boolean is_isa_v2 = TRUE;
2369
2370 /* If this is a relocatable link (output_bfd test tells us), just
2371 call the generic function. Any adjustment will be done at final
2372 link time. */
2373 if (output_bfd != NULL)
2374 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2375 input_section, output_bfd, error_message);
2376
2377 octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2378 insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
2379 insn &= ~(0x01 << 21);
2380 r_type = reloc_entry->howto->type;
2381 if (r_type == R_PPC64_ADDR14_BRTAKEN
2382 || r_type == R_PPC64_REL14_BRTAKEN)
2383 insn |= 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field. */
2384
2385 if (is_isa_v2)
2386 {
2387 /* Set 'a' bit. This is 0b00010 in BO field for branch
2388 on CR(BI) insns (BO == 001at or 011at), and 0b01000
2389 for branch on CTR insns (BO == 1a00t or 1a01t). */
2390 if ((insn & (0x14 << 21)) == (0x04 << 21))
2391 insn |= 0x02 << 21;
2392 else if ((insn & (0x14 << 21)) == (0x10 << 21))
2393 insn |= 0x08 << 21;
2394 else
2395 goto out;
2396 }
2397 else
2398 {
2399 bfd_vma target = 0;
2400 bfd_vma from;
2401
2402 if (!bfd_is_com_section (symbol->section))
2403 target = symbol->value;
2404 target += symbol->section->output_section->vma;
2405 target += symbol->section->output_offset;
2406 target += reloc_entry->addend;
2407
2408 from = (reloc_entry->address
2409 + input_section->output_offset
2410 + input_section->output_section->vma);
2411
2412 /* Invert 'y' bit if not the default. */
2413 if ((bfd_signed_vma) (target - from) < 0)
2414 insn ^= 0x01 << 21;
2415 }
2416 bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
2417 out:
2418 return ppc64_elf_branch_reloc (abfd, reloc_entry, symbol, data,
2419 input_section, output_bfd, error_message);
2420 }
2421
2422 static bfd_reloc_status_type
2423 ppc64_elf_sectoff_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2424 void *data, asection *input_section,
2425 bfd *output_bfd, char **error_message)
2426 {
2427 /* If this is a relocatable link (output_bfd test tells us), just
2428 call the generic function. Any adjustment will be done at final
2429 link time. */
2430 if (output_bfd != NULL)
2431 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2432 input_section, output_bfd, error_message);
2433
2434 /* Subtract the symbol section base address. */
2435 reloc_entry->addend -= symbol->section->output_section->vma;
2436 return bfd_reloc_continue;
2437 }
2438
2439 static bfd_reloc_status_type
2440 ppc64_elf_sectoff_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2441 void *data, asection *input_section,
2442 bfd *output_bfd, char **error_message)
2443 {
2444 /* If this is a relocatable link (output_bfd test tells us), just
2445 call the generic function. Any adjustment will be done at final
2446 link time. */
2447 if (output_bfd != NULL)
2448 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2449 input_section, output_bfd, error_message);
2450
2451 /* Subtract the symbol section base address. */
2452 reloc_entry->addend -= symbol->section->output_section->vma;
2453
2454 /* Adjust the addend for sign extension of the low 16 bits. */
2455 reloc_entry->addend += 0x8000;
2456 return bfd_reloc_continue;
2457 }
2458
2459 static bfd_reloc_status_type
2460 ppc64_elf_toc_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2461 void *data, asection *input_section,
2462 bfd *output_bfd, char **error_message)
2463 {
2464 bfd_vma TOCstart;
2465
2466 /* If this is a relocatable link (output_bfd test tells us), just
2467 call the generic function. Any adjustment will be done at final
2468 link time. */
2469 if (output_bfd != NULL)
2470 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2471 input_section, output_bfd, error_message);
2472
2473 TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2474 if (TOCstart == 0)
2475 TOCstart = ppc64_elf_toc (input_section->output_section->owner);
2476
2477 /* Subtract the TOC base address. */
2478 reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2479 return bfd_reloc_continue;
2480 }
2481
2482 static bfd_reloc_status_type
2483 ppc64_elf_toc_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2484 void *data, asection *input_section,
2485 bfd *output_bfd, char **error_message)
2486 {
2487 bfd_vma TOCstart;
2488
2489 /* If this is a relocatable link (output_bfd test tells us), just
2490 call the generic function. Any adjustment will be done at final
2491 link time. */
2492 if (output_bfd != NULL)
2493 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2494 input_section, output_bfd, error_message);
2495
2496 TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2497 if (TOCstart == 0)
2498 TOCstart = ppc64_elf_toc (input_section->output_section->owner);
2499
2500 /* Subtract the TOC base address. */
2501 reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2502
2503 /* Adjust the addend for sign extension of the low 16 bits. */
2504 reloc_entry->addend += 0x8000;
2505 return bfd_reloc_continue;
2506 }
2507
2508 static bfd_reloc_status_type
2509 ppc64_elf_toc64_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2510 void *data, asection *input_section,
2511 bfd *output_bfd, char **error_message)
2512 {
2513 bfd_vma TOCstart;
2514 bfd_size_type octets;
2515
2516 /* If this is a relocatable link (output_bfd test tells us), just
2517 call the generic function. Any adjustment will be done at final
2518 link time. */
2519 if (output_bfd != NULL)
2520 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2521 input_section, output_bfd, error_message);
2522
2523 TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2524 if (TOCstart == 0)
2525 TOCstart = ppc64_elf_toc (input_section->output_section->owner);
2526
2527 octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2528 bfd_put_64 (abfd, TOCstart + TOC_BASE_OFF, (bfd_byte *) data + octets);
2529 return bfd_reloc_ok;
2530 }
2531
2532 static bfd_reloc_status_type
2533 ppc64_elf_unhandled_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2534 void *data, asection *input_section,
2535 bfd *output_bfd, char **error_message)
2536 {
2537 /* If this is a relocatable link (output_bfd test tells us), just
2538 call the generic function. Any adjustment will be done at final
2539 link time. */
2540 if (output_bfd != NULL)
2541 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2542 input_section, output_bfd, error_message);
2543
2544 if (error_message != NULL)
2545 {
2546 static char buf[60];
2547 sprintf (buf, "generic linker can't handle %s",
2548 reloc_entry->howto->name);
2549 *error_message = buf;
2550 }
2551 return bfd_reloc_dangerous;
2552 }
2553
2554 /* Track GOT entries needed for a given symbol. We might need more
2555 than one got entry per symbol. */
2556 struct got_entry
2557 {
2558 struct got_entry *next;
2559
2560 /* The symbol addend that we'll be placing in the GOT. */
2561 bfd_vma addend;
2562
2563 /* Unlike other ELF targets, we use separate GOT entries for the same
2564 symbol referenced from different input files. This is to support
2565 automatic multiple TOC/GOT sections, where the TOC base can vary
2566 from one input file to another. After partitioning into TOC groups
2567 we merge entries within the group.
2568
2569 Point to the BFD owning this GOT entry. */
2570 bfd *owner;
2571
2572 /* Zero for non-tls entries, or TLS_TLS and one of TLS_GD, TLS_LD,
2573 TLS_TPREL or TLS_DTPREL for tls entries. */
2574 unsigned char tls_type;
2575
2576 /* Non-zero if got.ent points to real entry. */
2577 unsigned char is_indirect;
2578
2579 /* Reference count until size_dynamic_sections, GOT offset thereafter. */
2580 union
2581 {
2582 bfd_signed_vma refcount;
2583 bfd_vma offset;
2584 struct got_entry *ent;
2585 } got;
2586 };
2587
2588 /* The same for PLT. */
2589 struct plt_entry
2590 {
2591 struct plt_entry *next;
2592
2593 bfd_vma addend;
2594
2595 union
2596 {
2597 bfd_signed_vma refcount;
2598 bfd_vma offset;
2599 } plt;
2600 };
2601
2602 struct ppc64_elf_obj_tdata
2603 {
2604 struct elf_obj_tdata elf;
2605
2606 /* Shortcuts to dynamic linker sections. */
2607 asection *got;
2608 asection *relgot;
2609
2610 /* Used during garbage collection. We attach global symbols defined
2611 on removed .opd entries to this section so that the sym is removed. */
2612 asection *deleted_section;
2613
2614 /* TLS local dynamic got entry handling. Support for multiple GOT
2615 sections means we potentially need one of these for each input bfd. */
2616 struct got_entry tlsld_got;
2617
2618 /* A copy of relocs before they are modified for --emit-relocs. */
2619 Elf_Internal_Rela *opd_relocs;
2620
2621 /* Nonzero if this bfd has small toc/got relocs, ie. that expect
2622 the reloc to be in the range -32768 to 32767. */
2623 unsigned int has_small_toc_reloc : 1;
2624
2625 /* Set if toc/got ha relocs detected not using r2, or lo reloc
2626 instruction not one we handle. */
2627 unsigned int unexpected_toc_insn : 1;
2628 };
2629
2630 #define ppc64_elf_tdata(bfd) \
2631 ((struct ppc64_elf_obj_tdata *) (bfd)->tdata.any)
2632
2633 #define ppc64_tlsld_got(bfd) \
2634 (&ppc64_elf_tdata (bfd)->tlsld_got)
2635
2636 #define is_ppc64_elf(bfd) \
2637 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
2638 && elf_object_id (bfd) == PPC64_ELF_DATA)
2639
2640 /* Override the generic function because we store some extras. */
2641
2642 static bfd_boolean
2643 ppc64_elf_mkobject (bfd *abfd)
2644 {
2645 return bfd_elf_allocate_object (abfd, sizeof (struct ppc64_elf_obj_tdata),
2646 PPC64_ELF_DATA);
2647 }
2648
2649 /* Fix bad default arch selected for a 64 bit input bfd when the
2650 default is 32 bit. */
2651
2652 static bfd_boolean
2653 ppc64_elf_object_p (bfd *abfd)
2654 {
2655 if (abfd->arch_info->the_default && abfd->arch_info->bits_per_word == 32)
2656 {
2657 Elf_Internal_Ehdr *i_ehdr = elf_elfheader (abfd);
2658
2659 if (i_ehdr->e_ident[EI_CLASS] == ELFCLASS64)
2660 {
2661 /* Relies on arch after 32 bit default being 64 bit default. */
2662 abfd->arch_info = abfd->arch_info->next;
2663 BFD_ASSERT (abfd->arch_info->bits_per_word == 64);
2664 }
2665 }
2666 return TRUE;
2667 }
2668
2669 /* Support for core dump NOTE sections. */
2670
2671 static bfd_boolean
2672 ppc64_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
2673 {
2674 size_t offset, size;
2675
2676 if (note->descsz != 504)
2677 return FALSE;
2678
2679 /* pr_cursig */
2680 elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
2681
2682 /* pr_pid */
2683 elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 32);
2684
2685 /* pr_reg */
2686 offset = 112;
2687 size = 384;
2688
2689 /* Make a ".reg/999" section. */
2690 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
2691 size, note->descpos + offset);
2692 }
2693
2694 static bfd_boolean
2695 ppc64_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
2696 {
2697 if (note->descsz != 136)
2698 return FALSE;
2699
2700 elf_tdata (abfd)->core->pid
2701 = bfd_get_32 (abfd, note->descdata + 24);
2702 elf_tdata (abfd)->core->program
2703 = _bfd_elfcore_strndup (abfd, note->descdata + 40, 16);
2704 elf_tdata (abfd)->core->command
2705 = _bfd_elfcore_strndup (abfd, note->descdata + 56, 80);
2706
2707 return TRUE;
2708 }
2709
2710 static char *
2711 ppc64_elf_write_core_note (bfd *abfd, char *buf, int *bufsiz, int note_type,
2712 ...)
2713 {
2714 switch (note_type)
2715 {
2716 default:
2717 return NULL;
2718
2719 case NT_PRPSINFO:
2720 {
2721 char data[136];
2722 va_list ap;
2723
2724 va_start (ap, note_type);
2725 memset (data, 0, sizeof (data));
2726 strncpy (data + 40, va_arg (ap, const char *), 16);
2727 strncpy (data + 56, va_arg (ap, const char *), 80);
2728 va_end (ap);
2729 return elfcore_write_note (abfd, buf, bufsiz,
2730 "CORE", note_type, data, sizeof (data));
2731 }
2732
2733 case NT_PRSTATUS:
2734 {
2735 char data[504];
2736 va_list ap;
2737 long pid;
2738 int cursig;
2739 const void *greg;
2740
2741 va_start (ap, note_type);
2742 memset (data, 0, 112);
2743 pid = va_arg (ap, long);
2744 bfd_put_32 (abfd, pid, data + 32);
2745 cursig = va_arg (ap, int);
2746 bfd_put_16 (abfd, cursig, data + 12);
2747 greg = va_arg (ap, const void *);
2748 memcpy (data + 112, greg, 384);
2749 memset (data + 496, 0, 8);
2750 va_end (ap);
2751 return elfcore_write_note (abfd, buf, bufsiz,
2752 "CORE", note_type, data, sizeof (data));
2753 }
2754 }
2755 }
2756
2757 /* Add extra PPC sections. */
2758
2759 static const struct bfd_elf_special_section ppc64_elf_special_sections[]=
2760 {
2761 { STRING_COMMA_LEN (".plt"), 0, SHT_NOBITS, 0 },
2762 { STRING_COMMA_LEN (".sbss"), -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE },
2763 { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2764 { STRING_COMMA_LEN (".toc"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2765 { STRING_COMMA_LEN (".toc1"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2766 { STRING_COMMA_LEN (".tocbss"), 0, SHT_NOBITS, SHF_ALLOC + SHF_WRITE },
2767 { NULL, 0, 0, 0, 0 }
2768 };
2769
2770 enum _ppc64_sec_type {
2771 sec_normal = 0,
2772 sec_opd = 1,
2773 sec_toc = 2
2774 };
2775
2776 struct _ppc64_elf_section_data
2777 {
2778 struct bfd_elf_section_data elf;
2779
2780 union
2781 {
2782 /* An array with one entry for each opd function descriptor. */
2783 struct _opd_sec_data
2784 {
2785 /* Points to the function code section for local opd entries. */
2786 asection **func_sec;
2787
2788 /* After editing .opd, adjust references to opd local syms. */
2789 long *adjust;
2790 } opd;
2791
2792 /* An array for toc sections, indexed by offset/8. */
2793 struct _toc_sec_data
2794 {
2795 /* Specifies the relocation symbol index used at a given toc offset. */
2796 unsigned *symndx;
2797
2798 /* And the relocation addend. */
2799 bfd_vma *add;
2800 } toc;
2801 } u;
2802
2803 enum _ppc64_sec_type sec_type:2;
2804
2805 /* Flag set when small branches are detected. Used to
2806 select suitable defaults for the stub group size. */
2807 unsigned int has_14bit_branch:1;
2808 };
2809
2810 #define ppc64_elf_section_data(sec) \
2811 ((struct _ppc64_elf_section_data *) elf_section_data (sec))
2812
2813 static bfd_boolean
2814 ppc64_elf_new_section_hook (bfd *abfd, asection *sec)
2815 {
2816 if (!sec->used_by_bfd)
2817 {
2818 struct _ppc64_elf_section_data *sdata;
2819 bfd_size_type amt = sizeof (*sdata);
2820
2821 sdata = bfd_zalloc (abfd, amt);
2822 if (sdata == NULL)
2823 return FALSE;
2824 sec->used_by_bfd = sdata;
2825 }
2826
2827 return _bfd_elf_new_section_hook (abfd, sec);
2828 }
2829
2830 static struct _opd_sec_data *
2831 get_opd_info (asection * sec)
2832 {
2833 if (sec != NULL
2834 && ppc64_elf_section_data (sec) != NULL
2835 && ppc64_elf_section_data (sec)->sec_type == sec_opd)
2836 return &ppc64_elf_section_data (sec)->u.opd;
2837 return NULL;
2838 }
2839 \f
2840 /* Parameters for the qsort hook. */
2841 static bfd_boolean synthetic_relocatable;
2842
2843 /* qsort comparison function for ppc64_elf_get_synthetic_symtab. */
2844
2845 static int
2846 compare_symbols (const void *ap, const void *bp)
2847 {
2848 const asymbol *a = * (const asymbol **) ap;
2849 const asymbol *b = * (const asymbol **) bp;
2850
2851 /* Section symbols first. */
2852 if ((a->flags & BSF_SECTION_SYM) && !(b->flags & BSF_SECTION_SYM))
2853 return -1;
2854 if (!(a->flags & BSF_SECTION_SYM) && (b->flags & BSF_SECTION_SYM))
2855 return 1;
2856
2857 /* then .opd symbols. */
2858 if (strcmp (a->section->name, ".opd") == 0
2859 && strcmp (b->section->name, ".opd") != 0)
2860 return -1;
2861 if (strcmp (a->section->name, ".opd") != 0
2862 && strcmp (b->section->name, ".opd") == 0)
2863 return 1;
2864
2865 /* then other code symbols. */
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 ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
2873 != (SEC_CODE | SEC_ALLOC)
2874 && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
2875 == (SEC_CODE | SEC_ALLOC))
2876 return 1;
2877
2878 if (synthetic_relocatable)
2879 {
2880 if (a->section->id < b->section->id)
2881 return -1;
2882
2883 if (a->section->id > b->section->id)
2884 return 1;
2885 }
2886
2887 if (a->value + a->section->vma < b->value + b->section->vma)
2888 return -1;
2889
2890 if (a->value + a->section->vma > b->value + b->section->vma)
2891 return 1;
2892
2893 /* For syms with the same value, prefer strong dynamic global function
2894 syms over other syms. */
2895 if ((a->flags & BSF_GLOBAL) != 0 && (b->flags & BSF_GLOBAL) == 0)
2896 return -1;
2897
2898 if ((a->flags & BSF_GLOBAL) == 0 && (b->flags & BSF_GLOBAL) != 0)
2899 return 1;
2900
2901 if ((a->flags & BSF_FUNCTION) != 0 && (b->flags & BSF_FUNCTION) == 0)
2902 return -1;
2903
2904 if ((a->flags & BSF_FUNCTION) == 0 && (b->flags & BSF_FUNCTION) != 0)
2905 return 1;
2906
2907 if ((a->flags & BSF_WEAK) == 0 && (b->flags & BSF_WEAK) != 0)
2908 return -1;
2909
2910 if ((a->flags & BSF_WEAK) != 0 && (b->flags & BSF_WEAK) == 0)
2911 return 1;
2912
2913 if ((a->flags & BSF_DYNAMIC) != 0 && (b->flags & BSF_DYNAMIC) == 0)
2914 return -1;
2915
2916 if ((a->flags & BSF_DYNAMIC) == 0 && (b->flags & BSF_DYNAMIC) != 0)
2917 return 1;
2918
2919 return 0;
2920 }
2921
2922 /* Search SYMS for a symbol of the given VALUE. */
2923
2924 static asymbol *
2925 sym_exists_at (asymbol **syms, long lo, long hi, int id, bfd_vma value)
2926 {
2927 long mid;
2928
2929 if (id == -1)
2930 {
2931 while (lo < hi)
2932 {
2933 mid = (lo + hi) >> 1;
2934 if (syms[mid]->value + syms[mid]->section->vma < value)
2935 lo = mid + 1;
2936 else if (syms[mid]->value + syms[mid]->section->vma > value)
2937 hi = mid;
2938 else
2939 return syms[mid];
2940 }
2941 }
2942 else
2943 {
2944 while (lo < hi)
2945 {
2946 mid = (lo + hi) >> 1;
2947 if (syms[mid]->section->id < id)
2948 lo = mid + 1;
2949 else if (syms[mid]->section->id > id)
2950 hi = mid;
2951 else if (syms[mid]->value < value)
2952 lo = mid + 1;
2953 else if (syms[mid]->value > value)
2954 hi = mid;
2955 else
2956 return syms[mid];
2957 }
2958 }
2959 return NULL;
2960 }
2961
2962 static bfd_boolean
2963 section_covers_vma (bfd *abfd ATTRIBUTE_UNUSED, asection *section, void *ptr)
2964 {
2965 bfd_vma vma = *(bfd_vma *) ptr;
2966 return ((section->flags & SEC_ALLOC) != 0
2967 && section->vma <= vma
2968 && vma < section->vma + section->size);
2969 }
2970
2971 /* Create synthetic symbols, effectively restoring "dot-symbol" function
2972 entry syms. Also generate @plt symbols for the glink branch table. */
2973
2974 static long
2975 ppc64_elf_get_synthetic_symtab (bfd *abfd,
2976 long static_count, asymbol **static_syms,
2977 long dyn_count, asymbol **dyn_syms,
2978 asymbol **ret)
2979 {
2980 asymbol *s;
2981 long i;
2982 long count;
2983 char *names;
2984 long symcount, codesecsym, codesecsymend, secsymend, opdsymend;
2985 asection *opd;
2986 bfd_boolean relocatable = (abfd->flags & (EXEC_P | DYNAMIC)) == 0;
2987 asymbol **syms;
2988
2989 *ret = NULL;
2990
2991 opd = bfd_get_section_by_name (abfd, ".opd");
2992 if (opd == NULL)
2993 return 0;
2994
2995 symcount = static_count;
2996 if (!relocatable)
2997 symcount += dyn_count;
2998 if (symcount == 0)
2999 return 0;
3000
3001 syms = bfd_malloc ((symcount + 1) * sizeof (*syms));
3002 if (syms == NULL)
3003 return -1;
3004
3005 if (!relocatable && static_count != 0 && dyn_count != 0)
3006 {
3007 /* Use both symbol tables. */
3008 memcpy (syms, static_syms, static_count * sizeof (*syms));
3009 memcpy (syms + static_count, dyn_syms, (dyn_count + 1) * sizeof (*syms));
3010 }
3011 else if (!relocatable && static_count == 0)
3012 memcpy (syms, dyn_syms, (symcount + 1) * sizeof (*syms));
3013 else
3014 memcpy (syms, static_syms, (symcount + 1) * sizeof (*syms));
3015
3016 synthetic_relocatable = relocatable;
3017 qsort (syms, symcount, sizeof (*syms), compare_symbols);
3018
3019 if (!relocatable && symcount > 1)
3020 {
3021 long j;
3022 /* Trim duplicate syms, since we may have merged the normal and
3023 dynamic symbols. Actually, we only care about syms that have
3024 different values, so trim any with the same value. */
3025 for (i = 1, j = 1; i < symcount; ++i)
3026 if (syms[i - 1]->value + syms[i - 1]->section->vma
3027 != syms[i]->value + syms[i]->section->vma)
3028 syms[j++] = syms[i];
3029 symcount = j;
3030 }
3031
3032 i = 0;
3033 if (strcmp (syms[i]->section->name, ".opd") == 0)
3034 ++i;
3035 codesecsym = i;
3036
3037 for (; i < symcount; ++i)
3038 if (((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3039 != (SEC_CODE | SEC_ALLOC))
3040 || (syms[i]->flags & BSF_SECTION_SYM) == 0)
3041 break;
3042 codesecsymend = i;
3043
3044 for (; i < symcount; ++i)
3045 if ((syms[i]->flags & BSF_SECTION_SYM) == 0)
3046 break;
3047 secsymend = i;
3048
3049 for (; i < symcount; ++i)
3050 if (strcmp (syms[i]->section->name, ".opd") != 0)
3051 break;
3052 opdsymend = i;
3053
3054 for (; i < symcount; ++i)
3055 if ((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3056 != (SEC_CODE | SEC_ALLOC))
3057 break;
3058 symcount = i;
3059
3060 count = 0;
3061
3062 if (relocatable)
3063 {
3064 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3065 arelent *r;
3066 size_t size;
3067 long relcount;
3068
3069 if (opdsymend == secsymend)
3070 goto done;
3071
3072 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3073 relcount = (opd->flags & SEC_RELOC) ? opd->reloc_count : 0;
3074 if (relcount == 0)
3075 goto done;
3076
3077 if (!(*slurp_relocs) (abfd, opd, static_syms, FALSE))
3078 {
3079 count = -1;
3080 goto done;
3081 }
3082
3083 size = 0;
3084 for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3085 {
3086 asymbol *sym;
3087
3088 while (r < opd->relocation + relcount
3089 && r->address < syms[i]->value + opd->vma)
3090 ++r;
3091
3092 if (r == opd->relocation + relcount)
3093 break;
3094
3095 if (r->address != syms[i]->value + opd->vma)
3096 continue;
3097
3098 if (r->howto->type != R_PPC64_ADDR64)
3099 continue;
3100
3101 sym = *r->sym_ptr_ptr;
3102 if (!sym_exists_at (syms, opdsymend, symcount,
3103 sym->section->id, sym->value + r->addend))
3104 {
3105 ++count;
3106 size += sizeof (asymbol);
3107 size += strlen (syms[i]->name) + 2;
3108 }
3109 }
3110
3111 s = *ret = bfd_malloc (size);
3112 if (s == NULL)
3113 {
3114 count = -1;
3115 goto done;
3116 }
3117
3118 names = (char *) (s + count);
3119
3120 for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3121 {
3122 asymbol *sym;
3123
3124 while (r < opd->relocation + relcount
3125 && r->address < syms[i]->value + opd->vma)
3126 ++r;
3127
3128 if (r == opd->relocation + relcount)
3129 break;
3130
3131 if (r->address != syms[i]->value + opd->vma)
3132 continue;
3133
3134 if (r->howto->type != R_PPC64_ADDR64)
3135 continue;
3136
3137 sym = *r->sym_ptr_ptr;
3138 if (!sym_exists_at (syms, opdsymend, symcount,
3139 sym->section->id, sym->value + r->addend))
3140 {
3141 size_t len;
3142
3143 *s = *syms[i];
3144 s->flags |= BSF_SYNTHETIC;
3145 s->section = sym->section;
3146 s->value = sym->value + r->addend;
3147 s->name = names;
3148 *names++ = '.';
3149 len = strlen (syms[i]->name);
3150 memcpy (names, syms[i]->name, len + 1);
3151 names += len + 1;
3152 /* Have udata.p point back to the original symbol this
3153 synthetic symbol was derived from. */
3154 s->udata.p = syms[i];
3155 s++;
3156 }
3157 }
3158 }
3159 else
3160 {
3161 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3162 bfd_byte *contents;
3163 size_t size;
3164 long plt_count = 0;
3165 bfd_vma glink_vma = 0, resolv_vma = 0;
3166 asection *dynamic, *glink = NULL, *relplt = NULL;
3167 arelent *p;
3168
3169 if (!bfd_malloc_and_get_section (abfd, opd, &contents))
3170 {
3171 if (contents)
3172 {
3173 free_contents_and_exit:
3174 free (contents);
3175 }
3176 count = -1;
3177 goto done;
3178 }
3179
3180 size = 0;
3181 for (i = secsymend; i < opdsymend; ++i)
3182 {
3183 bfd_vma ent;
3184
3185 /* Ignore bogus symbols. */
3186 if (syms[i]->value > opd->size - 8)
3187 continue;
3188
3189 ent = bfd_get_64 (abfd, contents + syms[i]->value);
3190 if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3191 {
3192 ++count;
3193 size += sizeof (asymbol);
3194 size += strlen (syms[i]->name) + 2;
3195 }
3196 }
3197
3198 /* Get start of .glink stubs from DT_PPC64_GLINK. */
3199 if (dyn_count != 0
3200 && (dynamic = bfd_get_section_by_name (abfd, ".dynamic")) != NULL)
3201 {
3202 bfd_byte *dynbuf, *extdyn, *extdynend;
3203 size_t extdynsize;
3204 void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *);
3205
3206 if (!bfd_malloc_and_get_section (abfd, dynamic, &dynbuf))
3207 goto free_contents_and_exit;
3208
3209 extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
3210 swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
3211
3212 extdyn = dynbuf;
3213 extdynend = extdyn + dynamic->size;
3214 for (; extdyn < extdynend; extdyn += extdynsize)
3215 {
3216 Elf_Internal_Dyn dyn;
3217 (*swap_dyn_in) (abfd, extdyn, &dyn);
3218
3219 if (dyn.d_tag == DT_NULL)
3220 break;
3221
3222 if (dyn.d_tag == DT_PPC64_GLINK)
3223 {
3224 /* The first glink stub starts at offset 32; see comment in
3225 ppc64_elf_finish_dynamic_sections. */
3226 glink_vma = dyn.d_un.d_val + 32;
3227 /* The .glink section usually does not survive the final
3228 link; search for the section (usually .text) where the
3229 glink stubs now reside. */
3230 glink = bfd_sections_find_if (abfd, section_covers_vma,
3231 &glink_vma);
3232 break;
3233 }
3234 }
3235
3236 free (dynbuf);
3237 }
3238
3239 if (glink != NULL)
3240 {
3241 /* Determine __glink trampoline by reading the relative branch
3242 from the first glink stub. */
3243 bfd_byte buf[4];
3244 if (bfd_get_section_contents (abfd, glink, buf,
3245 glink_vma + 4 - glink->vma, 4))
3246 {
3247 unsigned int insn = bfd_get_32 (abfd, buf);
3248 insn ^= B_DOT;
3249 if ((insn & ~0x3fffffc) == 0)
3250 resolv_vma = glink_vma + 4 + (insn ^ 0x2000000) - 0x2000000;
3251 }
3252
3253 if (resolv_vma)
3254 size += sizeof (asymbol) + sizeof ("__glink_PLTresolve");
3255
3256 relplt = bfd_get_section_by_name (abfd, ".rela.plt");
3257 if (relplt != NULL)
3258 {
3259 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3260 if (! (*slurp_relocs) (abfd, relplt, dyn_syms, TRUE))
3261 goto free_contents_and_exit;
3262
3263 plt_count = relplt->size / sizeof (Elf64_External_Rela);
3264 size += plt_count * sizeof (asymbol);
3265
3266 p = relplt->relocation;
3267 for (i = 0; i < plt_count; i++, p++)
3268 {
3269 size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
3270 if (p->addend != 0)
3271 size += sizeof ("+0x") - 1 + 16;
3272 }
3273 }
3274 }
3275
3276 s = *ret = bfd_malloc (size);
3277 if (s == NULL)
3278 goto free_contents_and_exit;
3279
3280 names = (char *) (s + count + plt_count + (resolv_vma != 0));
3281
3282 for (i = secsymend; i < opdsymend; ++i)
3283 {
3284 bfd_vma ent;
3285
3286 if (syms[i]->value > opd->size - 8)
3287 continue;
3288
3289 ent = bfd_get_64 (abfd, contents + syms[i]->value);
3290 if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3291 {
3292 long lo, hi;
3293 size_t len;
3294 asection *sec = abfd->sections;
3295
3296 *s = *syms[i];
3297 lo = codesecsym;
3298 hi = codesecsymend;
3299 while (lo < hi)
3300 {
3301 long mid = (lo + hi) >> 1;
3302 if (syms[mid]->section->vma < ent)
3303 lo = mid + 1;
3304 else if (syms[mid]->section->vma > ent)
3305 hi = mid;
3306 else
3307 {
3308 sec = syms[mid]->section;
3309 break;
3310 }
3311 }
3312
3313 if (lo >= hi && lo > codesecsym)
3314 sec = syms[lo - 1]->section;
3315
3316 for (; sec != NULL; sec = sec->next)
3317 {
3318 if (sec->vma > ent)
3319 break;
3320 /* SEC_LOAD may not be set if SEC is from a separate debug
3321 info file. */
3322 if ((sec->flags & SEC_ALLOC) == 0)
3323 break;
3324 if ((sec->flags & SEC_CODE) != 0)
3325 s->section = sec;
3326 }
3327 s->flags |= BSF_SYNTHETIC;
3328 s->value = ent - s->section->vma;
3329 s->name = names;
3330 *names++ = '.';
3331 len = strlen (syms[i]->name);
3332 memcpy (names, syms[i]->name, len + 1);
3333 names += len + 1;
3334 /* Have udata.p point back to the original symbol this
3335 synthetic symbol was derived from. */
3336 s->udata.p = syms[i];
3337 s++;
3338 }
3339 }
3340 free (contents);
3341
3342 if (glink != NULL && relplt != NULL)
3343 {
3344 if (resolv_vma)
3345 {
3346 /* Add a symbol for the main glink trampoline. */
3347 memset (s, 0, sizeof *s);
3348 s->the_bfd = abfd;
3349 s->flags = BSF_GLOBAL | BSF_SYNTHETIC;
3350 s->section = glink;
3351 s->value = resolv_vma - glink->vma;
3352 s->name = names;
3353 memcpy (names, "__glink_PLTresolve", sizeof ("__glink_PLTresolve"));
3354 names += sizeof ("__glink_PLTresolve");
3355 s++;
3356 count++;
3357 }
3358
3359 /* FIXME: It would be very much nicer to put sym@plt on the
3360 stub rather than on the glink branch table entry. The
3361 objdump disassembler would then use a sensible symbol
3362 name on plt calls. The difficulty in doing so is
3363 a) finding the stubs, and,
3364 b) matching stubs against plt entries, and,
3365 c) there can be multiple stubs for a given plt entry.
3366
3367 Solving (a) could be done by code scanning, but older
3368 ppc64 binaries used different stubs to current code.
3369 (b) is the tricky one since you need to known the toc
3370 pointer for at least one function that uses a pic stub to
3371 be able to calculate the plt address referenced.
3372 (c) means gdb would need to set multiple breakpoints (or
3373 find the glink branch itself) when setting breakpoints
3374 for pending shared library loads. */
3375 p = relplt->relocation;
3376 for (i = 0; i < plt_count; i++, p++)
3377 {
3378 size_t len;
3379
3380 *s = **p->sym_ptr_ptr;
3381 /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set. Since
3382 we are defining a symbol, ensure one of them is set. */
3383 if ((s->flags & BSF_LOCAL) == 0)
3384 s->flags |= BSF_GLOBAL;
3385 s->flags |= BSF_SYNTHETIC;
3386 s->section = glink;
3387 s->value = glink_vma - glink->vma;
3388 s->name = names;
3389 s->udata.p = NULL;
3390 len = strlen ((*p->sym_ptr_ptr)->name);
3391 memcpy (names, (*p->sym_ptr_ptr)->name, len);
3392 names += len;
3393 if (p->addend != 0)
3394 {
3395 memcpy (names, "+0x", sizeof ("+0x") - 1);
3396 names += sizeof ("+0x") - 1;
3397 bfd_sprintf_vma (abfd, names, p->addend);
3398 names += strlen (names);
3399 }
3400 memcpy (names, "@plt", sizeof ("@plt"));
3401 names += sizeof ("@plt");
3402 s++;
3403 glink_vma += 8;
3404 if (i >= 0x8000)
3405 glink_vma += 4;
3406 }
3407 count += plt_count;
3408 }
3409 }
3410
3411 done:
3412 free (syms);
3413 return count;
3414 }
3415 \f
3416 /* The following functions are specific to the ELF linker, while
3417 functions above are used generally. Those named ppc64_elf_* are
3418 called by the main ELF linker code. They appear in this file more
3419 or less in the order in which they are called. eg.
3420 ppc64_elf_check_relocs is called early in the link process,
3421 ppc64_elf_finish_dynamic_sections is one of the last functions
3422 called.
3423
3424 PowerPC64-ELF uses a similar scheme to PowerPC64-XCOFF in that
3425 functions have both a function code symbol and a function descriptor
3426 symbol. A call to foo in a relocatable object file looks like:
3427
3428 . .text
3429 . x:
3430 . bl .foo
3431 . nop
3432
3433 The function definition in another object file might be:
3434
3435 . .section .opd
3436 . foo: .quad .foo
3437 . .quad .TOC.@tocbase
3438 . .quad 0
3439 .
3440 . .text
3441 . .foo: blr
3442
3443 When the linker resolves the call during a static link, the branch
3444 unsurprisingly just goes to .foo and the .opd information is unused.
3445 If the function definition is in a shared library, things are a little
3446 different: The call goes via a plt call stub, the opd information gets
3447 copied to the plt, and the linker patches the nop.
3448
3449 . x:
3450 . bl .foo_stub
3451 . ld 2,40(1)
3452 .
3453 .
3454 . .foo_stub:
3455 . addis 12,2,Lfoo@toc@ha # in practice, the call stub
3456 . addi 12,12,Lfoo@toc@l # is slightly optimized, but
3457 . std 2,40(1) # this is the general idea
3458 . ld 11,0(12)
3459 . ld 2,8(12)
3460 . mtctr 11
3461 . ld 11,16(12)
3462 . bctr
3463 .
3464 . .section .plt
3465 . Lfoo: reloc (R_PPC64_JMP_SLOT, foo)
3466
3467 The "reloc ()" notation is supposed to indicate that the linker emits
3468 an R_PPC64_JMP_SLOT reloc against foo. The dynamic linker does the opd
3469 copying.
3470
3471 What are the difficulties here? Well, firstly, the relocations
3472 examined by the linker in check_relocs are against the function code
3473 sym .foo, while the dynamic relocation in the plt is emitted against
3474 the function descriptor symbol, foo. Somewhere along the line, we need
3475 to carefully copy dynamic link information from one symbol to the other.
3476 Secondly, the generic part of the elf linker will make .foo a dynamic
3477 symbol as is normal for most other backends. We need foo dynamic
3478 instead, at least for an application final link. However, when
3479 creating a shared library containing foo, we need to have both symbols
3480 dynamic so that references to .foo are satisfied during the early
3481 stages of linking. Otherwise the linker might decide to pull in a
3482 definition from some other object, eg. a static library.
3483
3484 Update: As of August 2004, we support a new convention. Function
3485 calls may use the function descriptor symbol, ie. "bl foo". This
3486 behaves exactly as "bl .foo". */
3487
3488 /* Of those relocs that might be copied as dynamic relocs, this function
3489 selects those that must be copied when linking a shared library,
3490 even when the symbol is local. */
3491
3492 static int
3493 must_be_dyn_reloc (struct bfd_link_info *info,
3494 enum elf_ppc64_reloc_type r_type)
3495 {
3496 switch (r_type)
3497 {
3498 default:
3499 return 1;
3500
3501 case R_PPC64_REL32:
3502 case R_PPC64_REL64:
3503 case R_PPC64_REL30:
3504 return 0;
3505
3506 case R_PPC64_TPREL16:
3507 case R_PPC64_TPREL16_LO:
3508 case R_PPC64_TPREL16_HI:
3509 case R_PPC64_TPREL16_HA:
3510 case R_PPC64_TPREL16_DS:
3511 case R_PPC64_TPREL16_LO_DS:
3512 case R_PPC64_TPREL16_HIGHER:
3513 case R_PPC64_TPREL16_HIGHERA:
3514 case R_PPC64_TPREL16_HIGHEST:
3515 case R_PPC64_TPREL16_HIGHESTA:
3516 case R_PPC64_TPREL64:
3517 return !info->executable;
3518 }
3519 }
3520
3521 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
3522 copying dynamic variables from a shared lib into an app's dynbss
3523 section, and instead use a dynamic relocation to point into the
3524 shared lib. With code that gcc generates, it's vital that this be
3525 enabled; In the PowerPC64 ABI, the address of a function is actually
3526 the address of a function descriptor, which resides in the .opd
3527 section. gcc uses the descriptor directly rather than going via the
3528 GOT as some other ABI's do, which means that initialized function
3529 pointers must reference the descriptor. Thus, a function pointer
3530 initialized to the address of a function in a shared library will
3531 either require a copy reloc, or a dynamic reloc. Using a copy reloc
3532 redefines the function descriptor symbol to point to the copy. This
3533 presents a problem as a plt entry for that function is also
3534 initialized from the function descriptor symbol and the copy reloc
3535 may not be initialized first. */
3536 #define ELIMINATE_COPY_RELOCS 1
3537
3538 /* Section name for stubs is the associated section name plus this
3539 string. */
3540 #define STUB_SUFFIX ".stub"
3541
3542 /* Linker stubs.
3543 ppc_stub_long_branch:
3544 Used when a 14 bit branch (or even a 24 bit branch) can't reach its
3545 destination, but a 24 bit branch in a stub section will reach.
3546 . b dest
3547
3548 ppc_stub_plt_branch:
3549 Similar to the above, but a 24 bit branch in the stub section won't
3550 reach its destination.
3551 . addis %r12,%r2,xxx@toc@ha
3552 . ld %r11,xxx@toc@l(%r12)
3553 . mtctr %r11
3554 . bctr
3555
3556 ppc_stub_plt_call:
3557 Used to call a function in a shared library. If it so happens that
3558 the plt entry referenced crosses a 64k boundary, then an extra
3559 "addi %r12,%r12,xxx@toc@l" will be inserted before the "mtctr".
3560 . addis %r12,%r2,xxx@toc@ha
3561 . std %r2,40(%r1)
3562 . ld %r11,xxx+0@toc@l(%r12)
3563 . mtctr %r11
3564 . ld %r2,xxx+8@toc@l(%r12)
3565 . ld %r11,xxx+16@toc@l(%r12)
3566 . bctr
3567
3568 ppc_stub_long_branch and ppc_stub_plt_branch may also have additional
3569 code to adjust the value and save r2 to support multiple toc sections.
3570 A ppc_stub_long_branch with an r2 offset looks like:
3571 . std %r2,40(%r1)
3572 . addis %r2,%r2,off@ha
3573 . addi %r2,%r2,off@l
3574 . b dest
3575
3576 A ppc_stub_plt_branch with an r2 offset looks like:
3577 . std %r2,40(%r1)
3578 . addis %r12,%r2,xxx@toc@ha
3579 . ld %r11,xxx@toc@l(%r12)
3580 . addis %r2,%r2,off@ha
3581 . addi %r2,%r2,off@l
3582 . mtctr %r11
3583 . bctr
3584
3585 In cases where the "addis" instruction would add zero, the "addis" is
3586 omitted and following instructions modified slightly in some cases.
3587 */
3588
3589 enum ppc_stub_type {
3590 ppc_stub_none,
3591 ppc_stub_long_branch,
3592 ppc_stub_long_branch_r2off,
3593 ppc_stub_plt_branch,
3594 ppc_stub_plt_branch_r2off,
3595 ppc_stub_plt_call,
3596 ppc_stub_plt_call_r2save
3597 };
3598
3599 struct ppc_stub_hash_entry {
3600
3601 /* Base hash table entry structure. */
3602 struct bfd_hash_entry root;
3603
3604 enum ppc_stub_type stub_type;
3605
3606 /* The stub section. */
3607 asection *stub_sec;
3608
3609 /* Offset within stub_sec of the beginning of this stub. */
3610 bfd_vma stub_offset;
3611
3612 /* Given the symbol's value and its section we can determine its final
3613 value when building the stubs (so the stub knows where to jump. */
3614 bfd_vma target_value;
3615 asection *target_section;
3616
3617 /* The symbol table entry, if any, that this was derived from. */
3618 struct ppc_link_hash_entry *h;
3619 struct plt_entry *plt_ent;
3620
3621 /* And the reloc addend that this was derived from. */
3622 bfd_vma addend;
3623
3624 /* Where this stub is being called from, or, in the case of combined
3625 stub sections, the first input section in the group. */
3626 asection *id_sec;
3627 };
3628
3629 struct ppc_branch_hash_entry {
3630
3631 /* Base hash table entry structure. */
3632 struct bfd_hash_entry root;
3633
3634 /* Offset within branch lookup table. */
3635 unsigned int offset;
3636
3637 /* Generation marker. */
3638 unsigned int iter;
3639 };
3640
3641 /* Used to track dynamic relocations for local symbols. */
3642 struct ppc_dyn_relocs
3643 {
3644 struct ppc_dyn_relocs *next;
3645
3646 /* The input section of the reloc. */
3647 asection *sec;
3648
3649 /* Total number of relocs copied for the input section. */
3650 unsigned int count : 31;
3651
3652 /* Whether this entry is for STT_GNU_IFUNC symbols. */
3653 unsigned int ifunc : 1;
3654 };
3655
3656 struct ppc_link_hash_entry
3657 {
3658 struct elf_link_hash_entry elf;
3659
3660 union {
3661 /* A pointer to the most recently used stub hash entry against this
3662 symbol. */
3663 struct ppc_stub_hash_entry *stub_cache;
3664
3665 /* A pointer to the next symbol starting with a '.' */
3666 struct ppc_link_hash_entry *next_dot_sym;
3667 } u;
3668
3669 /* Track dynamic relocs copied for this symbol. */
3670 struct elf_dyn_relocs *dyn_relocs;
3671
3672 /* Link between function code and descriptor symbols. */
3673 struct ppc_link_hash_entry *oh;
3674
3675 /* Flag function code and descriptor symbols. */
3676 unsigned int is_func:1;
3677 unsigned int is_func_descriptor:1;
3678 unsigned int fake:1;
3679
3680 /* Whether global opd/toc sym has been adjusted or not.
3681 After ppc64_elf_edit_opd/ppc64_elf_edit_toc has run, this flag
3682 should be set for all globals defined in any opd/toc section. */
3683 unsigned int adjust_done:1;
3684
3685 /* Set if we twiddled this symbol to weak at some stage. */
3686 unsigned int was_undefined:1;
3687
3688 /* Contexts in which symbol is used in the GOT (or TOC).
3689 TLS_GD .. TLS_EXPLICIT bits are or'd into the mask as the
3690 corresponding relocs are encountered during check_relocs.
3691 tls_optimize clears TLS_GD .. TLS_TPREL when optimizing to
3692 indicate the corresponding GOT entry type is not needed.
3693 tls_optimize may also set TLS_TPRELGD when a GD reloc turns into
3694 a TPREL one. We use a separate flag rather than setting TPREL
3695 just for convenience in distinguishing the two cases. */
3696 #define TLS_GD 1 /* GD reloc. */
3697 #define TLS_LD 2 /* LD reloc. */
3698 #define TLS_TPREL 4 /* TPREL reloc, => IE. */
3699 #define TLS_DTPREL 8 /* DTPREL reloc, => LD. */
3700 #define TLS_TLS 16 /* Any TLS reloc. */
3701 #define TLS_EXPLICIT 32 /* Marks TOC section TLS relocs. */
3702 #define TLS_TPRELGD 64 /* TPREL reloc resulting from GD->IE. */
3703 #define PLT_IFUNC 128 /* STT_GNU_IFUNC. */
3704 unsigned char tls_mask;
3705 };
3706
3707 /* ppc64 ELF linker hash table. */
3708
3709 struct ppc_link_hash_table
3710 {
3711 struct elf_link_hash_table elf;
3712
3713 /* The stub hash table. */
3714 struct bfd_hash_table stub_hash_table;
3715
3716 /* Another hash table for plt_branch stubs. */
3717 struct bfd_hash_table branch_hash_table;
3718
3719 /* Hash table for function prologue tocsave. */
3720 htab_t tocsave_htab;
3721
3722 /* Linker stub bfd. */
3723 bfd *stub_bfd;
3724
3725 /* Linker call-backs. */
3726 asection * (*add_stub_section) (const char *, asection *);
3727 void (*layout_sections_again) (void);
3728
3729 /* Array to keep track of which stub sections have been created, and
3730 information on stub grouping. */
3731 struct map_stub {
3732 /* This is the section to which stubs in the group will be attached. */
3733 asection *link_sec;
3734 /* The stub section. */
3735 asection *stub_sec;
3736 /* Along with elf_gp, specifies the TOC pointer used in this group. */
3737 bfd_vma toc_off;
3738 } *stub_group;
3739
3740 /* Temp used when calculating TOC pointers. */
3741 bfd_vma toc_curr;
3742 bfd *toc_bfd;
3743 asection *toc_first_sec;
3744
3745 /* Highest input section id. */
3746 int top_id;
3747
3748 /* Highest output section index. */
3749 int top_index;
3750
3751 /* Used when adding symbols. */
3752 struct ppc_link_hash_entry *dot_syms;
3753
3754 /* List of input sections for each output section. */
3755 asection **input_list;
3756
3757 /* Short-cuts to get to dynamic linker sections. */
3758 asection *got;
3759 asection *plt;
3760 asection *relplt;
3761 asection *iplt;
3762 asection *reliplt;
3763 asection *dynbss;
3764 asection *relbss;
3765 asection *glink;
3766 asection *sfpr;
3767 asection *brlt;
3768 asection *relbrlt;
3769 asection *glink_eh_frame;
3770
3771 /* Shortcut to .__tls_get_addr and __tls_get_addr. */
3772 struct ppc_link_hash_entry *tls_get_addr;
3773 struct ppc_link_hash_entry *tls_get_addr_fd;
3774
3775 /* The special .TOC. symbol. */
3776 struct ppc_link_hash_entry *dot_toc_dot;
3777
3778 /* The size of reliplt used by got entry relocs. */
3779 bfd_size_type got_reli_size;
3780
3781 /* Statistics. */
3782 unsigned long stub_count[ppc_stub_plt_call_r2save];
3783
3784 /* Number of stubs against global syms. */
3785 unsigned long stub_globals;
3786
3787 /* Alignment of PLT call stubs. */
3788 unsigned int plt_stub_align:4;
3789
3790 /* Set if PLT call stubs should load r11. */
3791 unsigned int plt_static_chain:1;
3792
3793 /* Set if PLT call stubs need a read-read barrier. */
3794 unsigned int plt_thread_safe:1;
3795
3796 /* Set if we should emit symbols for stubs. */
3797 unsigned int emit_stub_syms:1;
3798
3799 /* Set if __tls_get_addr optimization should not be done. */
3800 unsigned int no_tls_get_addr_opt:1;
3801
3802 /* Support for multiple toc sections. */
3803 unsigned int do_multi_toc:1;
3804 unsigned int multi_toc_needed:1;
3805 unsigned int second_toc_pass:1;
3806 unsigned int do_toc_opt:1;
3807
3808 /* Set on error. */
3809 unsigned int stub_error:1;
3810
3811 /* Temp used by ppc64_elf_process_dot_syms. */
3812 unsigned int twiddled_syms:1;
3813
3814 /* Incremented every time we size stubs. */
3815 unsigned int stub_iteration;
3816
3817 /* Small local sym cache. */
3818 struct sym_cache sym_cache;
3819 };
3820
3821 /* Rename some of the generic section flags to better document how they
3822 are used here. */
3823
3824 /* Nonzero if this section has TLS related relocations. */
3825 #define has_tls_reloc sec_flg0
3826
3827 /* Nonzero if this section has a call to __tls_get_addr. */
3828 #define has_tls_get_addr_call sec_flg1
3829
3830 /* Nonzero if this section has any toc or got relocs. */
3831 #define has_toc_reloc sec_flg2
3832
3833 /* Nonzero if this section has a call to another section that uses
3834 the toc or got. */
3835 #define makes_toc_func_call sec_flg3
3836
3837 /* Recursion protection when determining above flag. */
3838 #define call_check_in_progress sec_flg4
3839 #define call_check_done sec_flg5
3840
3841 /* Get the ppc64 ELF linker hash table from a link_info structure. */
3842
3843 #define ppc_hash_table(p) \
3844 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
3845 == PPC64_ELF_DATA ? ((struct ppc_link_hash_table *) ((p)->hash)) : NULL)
3846
3847 #define ppc_stub_hash_lookup(table, string, create, copy) \
3848 ((struct ppc_stub_hash_entry *) \
3849 bfd_hash_lookup ((table), (string), (create), (copy)))
3850
3851 #define ppc_branch_hash_lookup(table, string, create, copy) \
3852 ((struct ppc_branch_hash_entry *) \
3853 bfd_hash_lookup ((table), (string), (create), (copy)))
3854
3855 /* Create an entry in the stub hash table. */
3856
3857 static struct bfd_hash_entry *
3858 stub_hash_newfunc (struct bfd_hash_entry *entry,
3859 struct bfd_hash_table *table,
3860 const char *string)
3861 {
3862 /* Allocate the structure if it has not already been allocated by a
3863 subclass. */
3864 if (entry == NULL)
3865 {
3866 entry = bfd_hash_allocate (table, sizeof (struct ppc_stub_hash_entry));
3867 if (entry == NULL)
3868 return entry;
3869 }
3870
3871 /* Call the allocation method of the superclass. */
3872 entry = bfd_hash_newfunc (entry, table, string);
3873 if (entry != NULL)
3874 {
3875 struct ppc_stub_hash_entry *eh;
3876
3877 /* Initialize the local fields. */
3878 eh = (struct ppc_stub_hash_entry *) entry;
3879 eh->stub_type = ppc_stub_none;
3880 eh->stub_sec = NULL;
3881 eh->stub_offset = 0;
3882 eh->target_value = 0;
3883 eh->target_section = NULL;
3884 eh->h = NULL;
3885 eh->id_sec = NULL;
3886 }
3887
3888 return entry;
3889 }
3890
3891 /* Create an entry in the branch hash table. */
3892
3893 static struct bfd_hash_entry *
3894 branch_hash_newfunc (struct bfd_hash_entry *entry,
3895 struct bfd_hash_table *table,
3896 const char *string)
3897 {
3898 /* Allocate the structure if it has not already been allocated by a
3899 subclass. */
3900 if (entry == NULL)
3901 {
3902 entry = bfd_hash_allocate (table, sizeof (struct ppc_branch_hash_entry));
3903 if (entry == NULL)
3904 return entry;
3905 }
3906
3907 /* Call the allocation method of the superclass. */
3908 entry = bfd_hash_newfunc (entry, table, string);
3909 if (entry != NULL)
3910 {
3911 struct ppc_branch_hash_entry *eh;
3912
3913 /* Initialize the local fields. */
3914 eh = (struct ppc_branch_hash_entry *) entry;
3915 eh->offset = 0;
3916 eh->iter = 0;
3917 }
3918
3919 return entry;
3920 }
3921
3922 /* Create an entry in a ppc64 ELF linker hash table. */
3923
3924 static struct bfd_hash_entry *
3925 link_hash_newfunc (struct bfd_hash_entry *entry,
3926 struct bfd_hash_table *table,
3927 const char *string)
3928 {
3929 /* Allocate the structure if it has not already been allocated by a
3930 subclass. */
3931 if (entry == NULL)
3932 {
3933 entry = bfd_hash_allocate (table, sizeof (struct ppc_link_hash_entry));
3934 if (entry == NULL)
3935 return entry;
3936 }
3937
3938 /* Call the allocation method of the superclass. */
3939 entry = _bfd_elf_link_hash_newfunc (entry, table, string);
3940 if (entry != NULL)
3941 {
3942 struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) entry;
3943
3944 memset (&eh->u.stub_cache, 0,
3945 (sizeof (struct ppc_link_hash_entry)
3946 - offsetof (struct ppc_link_hash_entry, u.stub_cache)));
3947
3948 /* When making function calls, old ABI code references function entry
3949 points (dot symbols), while new ABI code references the function
3950 descriptor symbol. We need to make any combination of reference and
3951 definition work together, without breaking archive linking.
3952
3953 For a defined function "foo" and an undefined call to "bar":
3954 An old object defines "foo" and ".foo", references ".bar" (possibly
3955 "bar" too).
3956 A new object defines "foo" and references "bar".
3957
3958 A new object thus has no problem with its undefined symbols being
3959 satisfied by definitions in an old object. On the other hand, the
3960 old object won't have ".bar" satisfied by a new object.
3961
3962 Keep a list of newly added dot-symbols. */
3963
3964 if (string[0] == '.')
3965 {
3966 struct ppc_link_hash_table *htab;
3967
3968 htab = (struct ppc_link_hash_table *) table;
3969 eh->u.next_dot_sym = htab->dot_syms;
3970 htab->dot_syms = eh;
3971 }
3972 }
3973
3974 return entry;
3975 }
3976
3977 struct tocsave_entry {
3978 asection *sec;
3979 bfd_vma offset;
3980 };
3981
3982 static hashval_t
3983 tocsave_htab_hash (const void *p)
3984 {
3985 const struct tocsave_entry *e = (const struct tocsave_entry *) p;
3986 return ((bfd_vma)(intptr_t) e->sec ^ e->offset) >> 3;
3987 }
3988
3989 static int
3990 tocsave_htab_eq (const void *p1, const void *p2)
3991 {
3992 const struct tocsave_entry *e1 = (const struct tocsave_entry *) p1;
3993 const struct tocsave_entry *e2 = (const struct tocsave_entry *) p2;
3994 return e1->sec == e2->sec && e1->offset == e2->offset;
3995 }
3996
3997 /* Create a ppc64 ELF linker hash table. */
3998
3999 static struct bfd_link_hash_table *
4000 ppc64_elf_link_hash_table_create (bfd *abfd)
4001 {
4002 struct ppc_link_hash_table *htab;
4003 bfd_size_type amt = sizeof (struct ppc_link_hash_table);
4004
4005 htab = bfd_zmalloc (amt);
4006 if (htab == NULL)
4007 return NULL;
4008
4009 if (!_bfd_elf_link_hash_table_init (&htab->elf, abfd, link_hash_newfunc,
4010 sizeof (struct ppc_link_hash_entry),
4011 PPC64_ELF_DATA))
4012 {
4013 free (htab);
4014 return NULL;
4015 }
4016
4017 /* Init the stub hash table too. */
4018 if (!bfd_hash_table_init (&htab->stub_hash_table, stub_hash_newfunc,
4019 sizeof (struct ppc_stub_hash_entry)))
4020 return NULL;
4021
4022 /* And the branch hash table. */
4023 if (!bfd_hash_table_init (&htab->branch_hash_table, branch_hash_newfunc,
4024 sizeof (struct ppc_branch_hash_entry)))
4025 return NULL;
4026
4027 htab->tocsave_htab = htab_try_create (1024,
4028 tocsave_htab_hash,
4029 tocsave_htab_eq,
4030 NULL);
4031 if (htab->tocsave_htab == NULL)
4032 return NULL;
4033
4034 /* Initializing two fields of the union is just cosmetic. We really
4035 only care about glist, but when compiled on a 32-bit host the
4036 bfd_vma fields are larger. Setting the bfd_vma to zero makes
4037 debugger inspection of these fields look nicer. */
4038 htab->elf.init_got_refcount.refcount = 0;
4039 htab->elf.init_got_refcount.glist = NULL;
4040 htab->elf.init_plt_refcount.refcount = 0;
4041 htab->elf.init_plt_refcount.glist = NULL;
4042 htab->elf.init_got_offset.offset = 0;
4043 htab->elf.init_got_offset.glist = NULL;
4044 htab->elf.init_plt_offset.offset = 0;
4045 htab->elf.init_plt_offset.glist = NULL;
4046
4047 return &htab->elf.root;
4048 }
4049
4050 /* Free the derived linker hash table. */
4051
4052 static void
4053 ppc64_elf_link_hash_table_free (struct bfd_link_hash_table *hash)
4054 {
4055 struct ppc_link_hash_table *htab = (struct ppc_link_hash_table *) hash;
4056
4057 bfd_hash_table_free (&htab->stub_hash_table);
4058 bfd_hash_table_free (&htab->branch_hash_table);
4059 if (htab->tocsave_htab)
4060 htab_delete (htab->tocsave_htab);
4061 _bfd_elf_link_hash_table_free (hash);
4062 }
4063
4064 /* Satisfy the ELF linker by filling in some fields in our fake bfd. */
4065
4066 void
4067 ppc64_elf_init_stub_bfd (bfd *abfd, struct bfd_link_info *info)
4068 {
4069 struct ppc_link_hash_table *htab;
4070
4071 elf_elfheader (abfd)->e_ident[EI_CLASS] = ELFCLASS64;
4072
4073 /* Always hook our dynamic sections into the first bfd, which is the
4074 linker created stub bfd. This ensures that the GOT header is at
4075 the start of the output TOC section. */
4076 htab = ppc_hash_table (info);
4077 if (htab == NULL)
4078 return;
4079 htab->stub_bfd = abfd;
4080 htab->elf.dynobj = abfd;
4081 }
4082
4083 /* Build a name for an entry in the stub hash table. */
4084
4085 static char *
4086 ppc_stub_name (const asection *input_section,
4087 const asection *sym_sec,
4088 const struct ppc_link_hash_entry *h,
4089 const Elf_Internal_Rela *rel)
4090 {
4091 char *stub_name;
4092 ssize_t len;
4093
4094 /* rel->r_addend is actually 64 bit, but who uses more than +/- 2^31
4095 offsets from a sym as a branch target? In fact, we could
4096 probably assume the addend is always zero. */
4097 BFD_ASSERT (((int) rel->r_addend & 0xffffffff) == rel->r_addend);
4098
4099 if (h)
4100 {
4101 len = 8 + 1 + strlen (h->elf.root.root.string) + 1 + 8 + 1;
4102 stub_name = bfd_malloc (len);
4103 if (stub_name == NULL)
4104 return stub_name;
4105
4106 len = sprintf (stub_name, "%08x.%s+%x",
4107 input_section->id & 0xffffffff,
4108 h->elf.root.root.string,
4109 (int) rel->r_addend & 0xffffffff);
4110 }
4111 else
4112 {
4113 len = 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1;
4114 stub_name = bfd_malloc (len);
4115 if (stub_name == NULL)
4116 return stub_name;
4117
4118 len = sprintf (stub_name, "%08x.%x:%x+%x",
4119 input_section->id & 0xffffffff,
4120 sym_sec->id & 0xffffffff,
4121 (int) ELF64_R_SYM (rel->r_info) & 0xffffffff,
4122 (int) rel->r_addend & 0xffffffff);
4123 }
4124 if (len > 2 && stub_name[len - 2] == '+' && stub_name[len - 1] == '0')
4125 stub_name[len - 2] = 0;
4126 return stub_name;
4127 }
4128
4129 /* Look up an entry in the stub hash. Stub entries are cached because
4130 creating the stub name takes a bit of time. */
4131
4132 static struct ppc_stub_hash_entry *
4133 ppc_get_stub_entry (const asection *input_section,
4134 const asection *sym_sec,
4135 struct ppc_link_hash_entry *h,
4136 const Elf_Internal_Rela *rel,
4137 struct ppc_link_hash_table *htab)
4138 {
4139 struct ppc_stub_hash_entry *stub_entry;
4140 const asection *id_sec;
4141
4142 /* If this input section is part of a group of sections sharing one
4143 stub section, then use the id of the first section in the group.
4144 Stub names need to include a section id, as there may well be
4145 more than one stub used to reach say, printf, and we need to
4146 distinguish between them. */
4147 id_sec = htab->stub_group[input_section->id].link_sec;
4148
4149 if (h != NULL && h->u.stub_cache != NULL
4150 && h->u.stub_cache->h == h
4151 && h->u.stub_cache->id_sec == id_sec)
4152 {
4153 stub_entry = h->u.stub_cache;
4154 }
4155 else
4156 {
4157 char *stub_name;
4158
4159 stub_name = ppc_stub_name (id_sec, sym_sec, h, rel);
4160 if (stub_name == NULL)
4161 return NULL;
4162
4163 stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
4164 stub_name, FALSE, FALSE);
4165 if (h != NULL)
4166 h->u.stub_cache = stub_entry;
4167
4168 free (stub_name);
4169 }
4170
4171 return stub_entry;
4172 }
4173
4174 /* Add a new stub entry to the stub hash. Not all fields of the new
4175 stub entry are initialised. */
4176
4177 static struct ppc_stub_hash_entry *
4178 ppc_add_stub (const char *stub_name,
4179 asection *section,
4180 struct bfd_link_info *info)
4181 {
4182 struct ppc_link_hash_table *htab = ppc_hash_table (info);
4183 asection *link_sec;
4184 asection *stub_sec;
4185 struct ppc_stub_hash_entry *stub_entry;
4186
4187 link_sec = htab->stub_group[section->id].link_sec;
4188 stub_sec = htab->stub_group[section->id].stub_sec;
4189 if (stub_sec == NULL)
4190 {
4191 stub_sec = htab->stub_group[link_sec->id].stub_sec;
4192 if (stub_sec == NULL)
4193 {
4194 size_t namelen;
4195 bfd_size_type len;
4196 char *s_name;
4197
4198 namelen = strlen (link_sec->name);
4199 len = namelen + sizeof (STUB_SUFFIX);
4200 s_name = bfd_alloc (htab->stub_bfd, len);
4201 if (s_name == NULL)
4202 return NULL;
4203
4204 memcpy (s_name, link_sec->name, namelen);
4205 memcpy (s_name + namelen, STUB_SUFFIX, sizeof (STUB_SUFFIX));
4206 stub_sec = (*htab->add_stub_section) (s_name, link_sec);
4207 if (stub_sec == NULL)
4208 return NULL;
4209 htab->stub_group[link_sec->id].stub_sec = stub_sec;
4210 }
4211 htab->stub_group[section->id].stub_sec = stub_sec;
4212 }
4213
4214 /* Enter this entry into the linker stub hash table. */
4215 stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table, stub_name,
4216 TRUE, FALSE);
4217 if (stub_entry == NULL)
4218 {
4219 info->callbacks->einfo (_("%P: %B: cannot create stub entry %s\n"),
4220 section->owner, stub_name);
4221 return NULL;
4222 }
4223
4224 stub_entry->stub_sec = stub_sec;
4225 stub_entry->stub_offset = 0;
4226 stub_entry->id_sec = link_sec;
4227 return stub_entry;
4228 }
4229
4230 /* Create sections for linker generated code. */
4231
4232 static bfd_boolean
4233 create_linkage_sections (bfd *dynobj, struct bfd_link_info *info)
4234 {
4235 struct ppc_link_hash_table *htab;
4236 flagword flags;
4237
4238 htab = ppc_hash_table (info);
4239 if (htab == NULL)
4240 return FALSE;
4241
4242 /* Create .sfpr for code to save and restore fp regs. */
4243 flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY
4244 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4245 htab->sfpr = bfd_make_section_anyway_with_flags (dynobj, ".sfpr",
4246 flags);
4247 if (htab->sfpr == NULL
4248 || ! bfd_set_section_alignment (dynobj, htab->sfpr, 2))
4249 return FALSE;
4250
4251 /* Create .glink for lazy dynamic linking support. */
4252 htab->glink = bfd_make_section_anyway_with_flags (dynobj, ".glink",
4253 flags);
4254 if (htab->glink == NULL
4255 || ! bfd_set_section_alignment (dynobj, htab->glink, 3))
4256 return FALSE;
4257
4258 if (!info->no_ld_generated_unwind_info)
4259 {
4260 flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_HAS_CONTENTS
4261 | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4262 htab->glink_eh_frame = bfd_make_section_anyway_with_flags (dynobj,
4263 ".eh_frame",
4264 flags);
4265 if (htab->glink_eh_frame == NULL
4266 || !bfd_set_section_alignment (dynobj, htab->glink_eh_frame, 2))
4267 return FALSE;
4268 }
4269
4270 flags = SEC_ALLOC | SEC_LINKER_CREATED;
4271 htab->iplt = bfd_make_section_anyway_with_flags (dynobj, ".iplt", flags);
4272 if (htab->iplt == NULL
4273 || ! bfd_set_section_alignment (dynobj, htab->iplt, 3))
4274 return FALSE;
4275
4276 flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4277 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4278 htab->reliplt = bfd_make_section_anyway_with_flags (dynobj,
4279 ".rela.iplt",
4280 flags);
4281 if (htab->reliplt == NULL
4282 || ! bfd_set_section_alignment (dynobj, htab->reliplt, 3))
4283 return FALSE;
4284
4285 /* Create branch lookup table for plt_branch stubs. */
4286 flags = (SEC_ALLOC | SEC_LOAD
4287 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4288 htab->brlt = bfd_make_section_anyway_with_flags (dynobj, ".branch_lt",
4289 flags);
4290 if (htab->brlt == NULL
4291 || ! bfd_set_section_alignment (dynobj, htab->brlt, 3))
4292 return FALSE;
4293
4294 if (!info->shared)
4295 return TRUE;
4296
4297 flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4298 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4299 htab->relbrlt = bfd_make_section_anyway_with_flags (dynobj,
4300 ".rela.branch_lt",
4301 flags);
4302 if (htab->relbrlt == NULL
4303 || ! bfd_set_section_alignment (dynobj, htab->relbrlt, 3))
4304 return FALSE;
4305
4306 return TRUE;
4307 }
4308
4309 /* Create .got and .rela.got sections in ABFD, and .got in dynobj if
4310 not already done. */
4311
4312 static bfd_boolean
4313 create_got_section (bfd *abfd, struct bfd_link_info *info)
4314 {
4315 asection *got, *relgot;
4316 flagword flags;
4317 struct ppc_link_hash_table *htab = ppc_hash_table (info);
4318
4319 if (!is_ppc64_elf (abfd))
4320 return FALSE;
4321 if (htab == NULL)
4322 return FALSE;
4323
4324 if (!htab->got)
4325 {
4326 if (! _bfd_elf_create_got_section (htab->elf.dynobj, info))
4327 return FALSE;
4328
4329 htab->got = bfd_get_linker_section (htab->elf.dynobj, ".got");
4330 if (!htab->got)
4331 abort ();
4332 }
4333
4334 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
4335 | SEC_LINKER_CREATED);
4336
4337 got = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
4338 if (!got
4339 || !bfd_set_section_alignment (abfd, got, 3))
4340 return FALSE;
4341
4342 relgot = bfd_make_section_anyway_with_flags (abfd, ".rela.got",
4343 flags | SEC_READONLY);
4344 if (!relgot
4345 || ! bfd_set_section_alignment (abfd, relgot, 3))
4346 return FALSE;
4347
4348 ppc64_elf_tdata (abfd)->got = got;
4349 ppc64_elf_tdata (abfd)->relgot = relgot;
4350 return TRUE;
4351 }
4352
4353 /* Create the dynamic sections, and set up shortcuts. */
4354
4355 static bfd_boolean
4356 ppc64_elf_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
4357 {
4358 struct ppc_link_hash_table *htab;
4359
4360 if (!_bfd_elf_create_dynamic_sections (dynobj, info))
4361 return FALSE;
4362
4363 htab = ppc_hash_table (info);
4364 if (htab == NULL)
4365 return FALSE;
4366
4367 if (!htab->got)
4368 htab->got = bfd_get_linker_section (dynobj, ".got");
4369 htab->plt = bfd_get_linker_section (dynobj, ".plt");
4370 htab->relplt = bfd_get_linker_section (dynobj, ".rela.plt");
4371 htab->dynbss = bfd_get_linker_section (dynobj, ".dynbss");
4372 if (!info->shared)
4373 htab->relbss = bfd_get_linker_section (dynobj, ".rela.bss");
4374
4375 if (!htab->got || !htab->plt || !htab->relplt || !htab->dynbss
4376 || (!info->shared && !htab->relbss))
4377 abort ();
4378
4379 return TRUE;
4380 }
4381
4382 /* Follow indirect and warning symbol links. */
4383
4384 static inline struct bfd_link_hash_entry *
4385 follow_link (struct bfd_link_hash_entry *h)
4386 {
4387 while (h->type == bfd_link_hash_indirect
4388 || h->type == bfd_link_hash_warning)
4389 h = h->u.i.link;
4390 return h;
4391 }
4392
4393 static inline struct elf_link_hash_entry *
4394 elf_follow_link (struct elf_link_hash_entry *h)
4395 {
4396 return (struct elf_link_hash_entry *) follow_link (&h->root);
4397 }
4398
4399 static inline struct ppc_link_hash_entry *
4400 ppc_follow_link (struct ppc_link_hash_entry *h)
4401 {
4402 return (struct ppc_link_hash_entry *) follow_link (&h->elf.root);
4403 }
4404
4405 /* Merge PLT info on FROM with that on TO. */
4406
4407 static void
4408 move_plt_plist (struct ppc_link_hash_entry *from,
4409 struct ppc_link_hash_entry *to)
4410 {
4411 if (from->elf.plt.plist != NULL)
4412 {
4413 if (to->elf.plt.plist != NULL)
4414 {
4415 struct plt_entry **entp;
4416 struct plt_entry *ent;
4417
4418 for (entp = &from->elf.plt.plist; (ent = *entp) != NULL; )
4419 {
4420 struct plt_entry *dent;
4421
4422 for (dent = to->elf.plt.plist; dent != NULL; dent = dent->next)
4423 if (dent->addend == ent->addend)
4424 {
4425 dent->plt.refcount += ent->plt.refcount;
4426 *entp = ent->next;
4427 break;
4428 }
4429 if (dent == NULL)
4430 entp = &ent->next;
4431 }
4432 *entp = to->elf.plt.plist;
4433 }
4434
4435 to->elf.plt.plist = from->elf.plt.plist;
4436 from->elf.plt.plist = NULL;
4437 }
4438 }
4439
4440 /* Copy the extra info we tack onto an elf_link_hash_entry. */
4441
4442 static void
4443 ppc64_elf_copy_indirect_symbol (struct bfd_link_info *info,
4444 struct elf_link_hash_entry *dir,
4445 struct elf_link_hash_entry *ind)
4446 {
4447 struct ppc_link_hash_entry *edir, *eind;
4448
4449 edir = (struct ppc_link_hash_entry *) dir;
4450 eind = (struct ppc_link_hash_entry *) ind;
4451
4452 edir->is_func |= eind->is_func;
4453 edir->is_func_descriptor |= eind->is_func_descriptor;
4454 edir->tls_mask |= eind->tls_mask;
4455 if (eind->oh != NULL)
4456 edir->oh = ppc_follow_link (eind->oh);
4457
4458 /* If called to transfer flags for a weakdef during processing
4459 of elf_adjust_dynamic_symbol, don't copy NON_GOT_REF.
4460 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
4461 if (!(ELIMINATE_COPY_RELOCS
4462 && eind->elf.root.type != bfd_link_hash_indirect
4463 && edir->elf.dynamic_adjusted))
4464 edir->elf.non_got_ref |= eind->elf.non_got_ref;
4465
4466 edir->elf.ref_dynamic |= eind->elf.ref_dynamic;
4467 edir->elf.ref_regular |= eind->elf.ref_regular;
4468 edir->elf.ref_regular_nonweak |= eind->elf.ref_regular_nonweak;
4469 edir->elf.needs_plt |= eind->elf.needs_plt;
4470
4471 /* Copy over any dynamic relocs we may have on the indirect sym. */
4472 if (eind->dyn_relocs != NULL)
4473 {
4474 if (edir->dyn_relocs != NULL)
4475 {
4476 struct elf_dyn_relocs **pp;
4477 struct elf_dyn_relocs *p;
4478
4479 /* Add reloc counts against the indirect sym to the direct sym
4480 list. Merge any entries against the same section. */
4481 for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
4482 {
4483 struct elf_dyn_relocs *q;
4484
4485 for (q = edir->dyn_relocs; q != NULL; q = q->next)
4486 if (q->sec == p->sec)
4487 {
4488 q->pc_count += p->pc_count;
4489 q->count += p->count;
4490 *pp = p->next;
4491 break;
4492 }
4493 if (q == NULL)
4494 pp = &p->next;
4495 }
4496 *pp = edir->dyn_relocs;
4497 }
4498
4499 edir->dyn_relocs = eind->dyn_relocs;
4500 eind->dyn_relocs = NULL;
4501 }
4502
4503 /* If we were called to copy over info for a weak sym, that's all.
4504 You might think dyn_relocs need not be copied over; After all,
4505 both syms will be dynamic or both non-dynamic so we're just
4506 moving reloc accounting around. However, ELIMINATE_COPY_RELOCS
4507 code in ppc64_elf_adjust_dynamic_symbol needs to check for
4508 dyn_relocs in read-only sections, and it does so on what is the
4509 DIR sym here. */
4510 if (eind->elf.root.type != bfd_link_hash_indirect)
4511 return;
4512
4513 /* Copy over got entries that we may have already seen to the
4514 symbol which just became indirect. */
4515 if (eind->elf.got.glist != NULL)
4516 {
4517 if (edir->elf.got.glist != NULL)
4518 {
4519 struct got_entry **entp;
4520 struct got_entry *ent;
4521
4522 for (entp = &eind->elf.got.glist; (ent = *entp) != NULL; )
4523 {
4524 struct got_entry *dent;
4525
4526 for (dent = edir->elf.got.glist; dent != NULL; dent = dent->next)
4527 if (dent->addend == ent->addend
4528 && dent->owner == ent->owner
4529 && dent->tls_type == ent->tls_type)
4530 {
4531 dent->got.refcount += ent->got.refcount;
4532 *entp = ent->next;
4533 break;
4534 }
4535 if (dent == NULL)
4536 entp = &ent->next;
4537 }
4538 *entp = edir->elf.got.glist;
4539 }
4540
4541 edir->elf.got.glist = eind->elf.got.glist;
4542 eind->elf.got.glist = NULL;
4543 }
4544
4545 /* And plt entries. */
4546 move_plt_plist (eind, edir);
4547
4548 if (eind->elf.dynindx != -1)
4549 {
4550 if (edir->elf.dynindx != -1)
4551 _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
4552 edir->elf.dynstr_index);
4553 edir->elf.dynindx = eind->elf.dynindx;
4554 edir->elf.dynstr_index = eind->elf.dynstr_index;
4555 eind->elf.dynindx = -1;
4556 eind->elf.dynstr_index = 0;
4557 }
4558 }
4559
4560 /* Find the function descriptor hash entry from the given function code
4561 hash entry FH. Link the entries via their OH fields. */
4562
4563 static struct ppc_link_hash_entry *
4564 lookup_fdh (struct ppc_link_hash_entry *fh, struct ppc_link_hash_table *htab)
4565 {
4566 struct ppc_link_hash_entry *fdh = fh->oh;
4567
4568 if (fdh == NULL)
4569 {
4570 const char *fd_name = fh->elf.root.root.string + 1;
4571
4572 fdh = (struct ppc_link_hash_entry *)
4573 elf_link_hash_lookup (&htab->elf, fd_name, FALSE, FALSE, FALSE);
4574 if (fdh == NULL)
4575 return fdh;
4576
4577 fdh->is_func_descriptor = 1;
4578 fdh->oh = fh;
4579 fh->is_func = 1;
4580 fh->oh = fdh;
4581 }
4582
4583 return ppc_follow_link (fdh);
4584 }
4585
4586 /* Make a fake function descriptor sym for the code sym FH. */
4587
4588 static struct ppc_link_hash_entry *
4589 make_fdh (struct bfd_link_info *info,
4590 struct ppc_link_hash_entry *fh)
4591 {
4592 bfd *abfd;
4593 asymbol *newsym;
4594 struct bfd_link_hash_entry *bh;
4595 struct ppc_link_hash_entry *fdh;
4596
4597 abfd = fh->elf.root.u.undef.abfd;
4598 newsym = bfd_make_empty_symbol (abfd);
4599 newsym->name = fh->elf.root.root.string + 1;
4600 newsym->section = bfd_und_section_ptr;
4601 newsym->value = 0;
4602 newsym->flags = BSF_WEAK;
4603
4604 bh = NULL;
4605 if (!_bfd_generic_link_add_one_symbol (info, abfd, newsym->name,
4606 newsym->flags, newsym->section,
4607 newsym->value, NULL, FALSE, FALSE,
4608 &bh))
4609 return NULL;
4610
4611 fdh = (struct ppc_link_hash_entry *) bh;
4612 fdh->elf.non_elf = 0;
4613 fdh->fake = 1;
4614 fdh->is_func_descriptor = 1;
4615 fdh->oh = fh;
4616 fh->is_func = 1;
4617 fh->oh = fdh;
4618 return fdh;
4619 }
4620
4621 /* Fix function descriptor symbols defined in .opd sections to be
4622 function type. */
4623
4624 static bfd_boolean
4625 ppc64_elf_add_symbol_hook (bfd *ibfd,
4626 struct bfd_link_info *info,
4627 Elf_Internal_Sym *isym,
4628 const char **name ATTRIBUTE_UNUSED,
4629 flagword *flags ATTRIBUTE_UNUSED,
4630 asection **sec,
4631 bfd_vma *value ATTRIBUTE_UNUSED)
4632 {
4633 if ((ibfd->flags & DYNAMIC) == 0
4634 && ELF_ST_BIND (isym->st_info) == STB_GNU_UNIQUE)
4635 elf_tdata (info->output_bfd)->has_gnu_symbols = TRUE;
4636
4637 if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
4638 {
4639 if ((ibfd->flags & DYNAMIC) == 0)
4640 elf_tdata (info->output_bfd)->has_gnu_symbols = TRUE;
4641 }
4642 else if (ELF_ST_TYPE (isym->st_info) == STT_FUNC)
4643 ;
4644 else if (*sec != NULL
4645 && strcmp ((*sec)->name, ".opd") == 0)
4646 isym->st_info = ELF_ST_INFO (ELF_ST_BIND (isym->st_info), STT_FUNC);
4647
4648 return TRUE;
4649 }
4650
4651 /* This function makes an old ABI object reference to ".bar" cause the
4652 inclusion of a new ABI object archive that defines "bar".
4653 NAME is a symbol defined in an archive. Return a symbol in the hash
4654 table that might be satisfied by the archive symbols. */
4655
4656 static struct elf_link_hash_entry *
4657 ppc64_elf_archive_symbol_lookup (bfd *abfd,
4658 struct bfd_link_info *info,
4659 const char *name)
4660 {
4661 struct elf_link_hash_entry *h;
4662 char *dot_name;
4663 size_t len;
4664
4665 h = _bfd_elf_archive_symbol_lookup (abfd, info, name);
4666 if (h != NULL
4667 /* Don't return this sym if it is a fake function descriptor
4668 created by add_symbol_adjust. */
4669 && !(h->root.type == bfd_link_hash_undefweak
4670 && ((struct ppc_link_hash_entry *) h)->fake))
4671 return h;
4672
4673 if (name[0] == '.')
4674 return h;
4675
4676 len = strlen (name);
4677 dot_name = bfd_alloc (abfd, len + 2);
4678 if (dot_name == NULL)
4679 return (struct elf_link_hash_entry *) 0 - 1;
4680 dot_name[0] = '.';
4681 memcpy (dot_name + 1, name, len + 1);
4682 h = _bfd_elf_archive_symbol_lookup (abfd, info, dot_name);
4683 bfd_release (abfd, dot_name);
4684 return h;
4685 }
4686
4687 /* This function satisfies all old ABI object references to ".bar" if a
4688 new ABI object defines "bar". Well, at least, undefined dot symbols
4689 are made weak. This stops later archive searches from including an
4690 object if we already have a function descriptor definition. It also
4691 prevents the linker complaining about undefined symbols.
4692 We also check and correct mismatched symbol visibility here. The
4693 most restrictive visibility of the function descriptor and the
4694 function entry symbol is used. */
4695
4696 static bfd_boolean
4697 add_symbol_adjust (struct ppc_link_hash_entry *eh, struct bfd_link_info *info)
4698 {
4699 struct ppc_link_hash_table *htab;
4700 struct ppc_link_hash_entry *fdh;
4701
4702 if (eh->elf.root.type == bfd_link_hash_indirect)
4703 return TRUE;
4704
4705 if (eh->elf.root.type == bfd_link_hash_warning)
4706 eh = (struct ppc_link_hash_entry *) eh->elf.root.u.i.link;
4707
4708 if (eh->elf.root.root.string[0] != '.')
4709 abort ();
4710
4711 htab = ppc_hash_table (info);
4712 if (htab == NULL)
4713 return FALSE;
4714
4715 fdh = lookup_fdh (eh, htab);
4716 if (fdh == NULL)
4717 {
4718 if (!info->relocatable
4719 && (eh->elf.root.type == bfd_link_hash_undefined
4720 || eh->elf.root.type == bfd_link_hash_undefweak)
4721 && eh->elf.ref_regular)
4722 {
4723 /* Make an undefweak function descriptor sym, which is enough to
4724 pull in an --as-needed shared lib, but won't cause link
4725 errors. Archives are handled elsewhere. */
4726 fdh = make_fdh (info, eh);
4727 if (fdh == NULL)
4728 return FALSE;
4729 fdh->elf.ref_regular = 1;
4730 }
4731 }
4732 else
4733 {
4734 unsigned entry_vis = ELF_ST_VISIBILITY (eh->elf.other) - 1;
4735 unsigned descr_vis = ELF_ST_VISIBILITY (fdh->elf.other) - 1;
4736 if (entry_vis < descr_vis)
4737 fdh->elf.other += entry_vis - descr_vis;
4738 else if (entry_vis > descr_vis)
4739 eh->elf.other += descr_vis - entry_vis;
4740
4741 if ((fdh->elf.root.type == bfd_link_hash_defined
4742 || fdh->elf.root.type == bfd_link_hash_defweak)
4743 && eh->elf.root.type == bfd_link_hash_undefined)
4744 {
4745 eh->elf.root.type = bfd_link_hash_undefweak;
4746 eh->was_undefined = 1;
4747 htab->twiddled_syms = 1;
4748 }
4749 }
4750
4751 return TRUE;
4752 }
4753
4754 /* Process list of dot-symbols we made in link_hash_newfunc. */
4755
4756 static bfd_boolean
4757 ppc64_elf_process_dot_syms (bfd *ibfd, struct bfd_link_info *info)
4758 {
4759 struct ppc_link_hash_table *htab;
4760 struct ppc_link_hash_entry **p, *eh;
4761
4762 if (!is_ppc64_elf (info->output_bfd))
4763 return TRUE;
4764 htab = ppc_hash_table (info);
4765 if (htab == NULL)
4766 return FALSE;
4767
4768 if (is_ppc64_elf (ibfd))
4769 {
4770 p = &htab->dot_syms;
4771 while ((eh = *p) != NULL)
4772 {
4773 *p = NULL;
4774 if (!add_symbol_adjust (eh, info))
4775 return FALSE;
4776 p = &eh->u.next_dot_sym;
4777 }
4778 }
4779
4780 /* Clear the list for non-ppc64 input files. */
4781 p = &htab->dot_syms;
4782 while ((eh = *p) != NULL)
4783 {
4784 *p = NULL;
4785 p = &eh->u.next_dot_sym;
4786 }
4787
4788 /* We need to fix the undefs list for any syms we have twiddled to
4789 undef_weak. */
4790 if (htab->twiddled_syms)
4791 {
4792 bfd_link_repair_undef_list (&htab->elf.root);
4793 htab->twiddled_syms = 0;
4794 }
4795 return TRUE;
4796 }
4797
4798 /* Undo hash table changes when an --as-needed input file is determined
4799 not to be needed. */
4800
4801 static bfd_boolean
4802 ppc64_elf_as_needed_cleanup (bfd *ibfd ATTRIBUTE_UNUSED,
4803 struct bfd_link_info *info)
4804 {
4805 struct ppc_link_hash_table *htab = ppc_hash_table (info);
4806
4807 if (htab == NULL)
4808 return FALSE;
4809
4810 htab->dot_syms = NULL;
4811 return TRUE;
4812 }
4813
4814 /* If --just-symbols against a final linked binary, then assume we need
4815 toc adjusting stubs when calling functions defined there. */
4816
4817 static void
4818 ppc64_elf_link_just_syms (asection *sec, struct bfd_link_info *info)
4819 {
4820 if ((sec->flags & SEC_CODE) != 0
4821 && (sec->owner->flags & (EXEC_P | DYNAMIC)) != 0
4822 && is_ppc64_elf (sec->owner))
4823 {
4824 asection *got = bfd_get_section_by_name (sec->owner, ".got");
4825 if (got != NULL
4826 && got->size >= elf_backend_got_header_size
4827 && bfd_get_section_by_name (sec->owner, ".opd") != NULL)
4828 sec->has_toc_reloc = 1;
4829 }
4830 _bfd_elf_link_just_syms (sec, info);
4831 }
4832
4833 static struct plt_entry **
4834 update_local_sym_info (bfd *abfd, Elf_Internal_Shdr *symtab_hdr,
4835 unsigned long r_symndx, bfd_vma r_addend, int tls_type)
4836 {
4837 struct got_entry **local_got_ents = elf_local_got_ents (abfd);
4838 struct plt_entry **local_plt;
4839 unsigned char *local_got_tls_masks;
4840
4841 if (local_got_ents == NULL)
4842 {
4843 bfd_size_type size = symtab_hdr->sh_info;
4844
4845 size *= (sizeof (*local_got_ents)
4846 + sizeof (*local_plt)
4847 + sizeof (*local_got_tls_masks));
4848 local_got_ents = bfd_zalloc (abfd, size);
4849 if (local_got_ents == NULL)
4850 return NULL;
4851 elf_local_got_ents (abfd) = local_got_ents;
4852 }
4853
4854 if ((tls_type & (PLT_IFUNC | TLS_EXPLICIT)) == 0)
4855 {
4856 struct got_entry *ent;
4857
4858 for (ent = local_got_ents[r_symndx]; ent != NULL; ent = ent->next)
4859 if (ent->addend == r_addend
4860 && ent->owner == abfd
4861 && ent->tls_type == tls_type)
4862 break;
4863 if (ent == NULL)
4864 {
4865 bfd_size_type amt = sizeof (*ent);
4866 ent = bfd_alloc (abfd, amt);
4867 if (ent == NULL)
4868 return FALSE;
4869 ent->next = local_got_ents[r_symndx];
4870 ent->addend = r_addend;
4871 ent->owner = abfd;
4872 ent->tls_type = tls_type;
4873 ent->is_indirect = FALSE;
4874 ent->got.refcount = 0;
4875 local_got_ents[r_symndx] = ent;
4876 }
4877 ent->got.refcount += 1;
4878 }
4879
4880 local_plt = (struct plt_entry **) (local_got_ents + symtab_hdr->sh_info);
4881 local_got_tls_masks = (unsigned char *) (local_plt + symtab_hdr->sh_info);
4882 local_got_tls_masks[r_symndx] |= tls_type;
4883
4884 return local_plt + r_symndx;
4885 }
4886
4887 static bfd_boolean
4888 update_plt_info (bfd *abfd, struct plt_entry **plist, bfd_vma addend)
4889 {
4890 struct plt_entry *ent;
4891
4892 for (ent = *plist; ent != NULL; ent = ent->next)
4893 if (ent->addend == addend)
4894 break;
4895 if (ent == NULL)
4896 {
4897 bfd_size_type amt = sizeof (*ent);
4898 ent = bfd_alloc (abfd, amt);
4899 if (ent == NULL)
4900 return FALSE;
4901 ent->next = *plist;
4902 ent->addend = addend;
4903 ent->plt.refcount = 0;
4904 *plist = ent;
4905 }
4906 ent->plt.refcount += 1;
4907 return TRUE;
4908 }
4909
4910 static bfd_boolean
4911 is_branch_reloc (enum elf_ppc64_reloc_type r_type)
4912 {
4913 return (r_type == R_PPC64_REL24
4914 || r_type == R_PPC64_REL14
4915 || r_type == R_PPC64_REL14_BRTAKEN
4916 || r_type == R_PPC64_REL14_BRNTAKEN
4917 || r_type == R_PPC64_ADDR24
4918 || r_type == R_PPC64_ADDR14
4919 || r_type == R_PPC64_ADDR14_BRTAKEN
4920 || r_type == R_PPC64_ADDR14_BRNTAKEN);
4921 }
4922
4923 /* Look through the relocs for a section during the first phase, and
4924 calculate needed space in the global offset table, procedure
4925 linkage table, and dynamic reloc sections. */
4926
4927 static bfd_boolean
4928 ppc64_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
4929 asection *sec, const Elf_Internal_Rela *relocs)
4930 {
4931 struct ppc_link_hash_table *htab;
4932 Elf_Internal_Shdr *symtab_hdr;
4933 struct elf_link_hash_entry **sym_hashes;
4934 const Elf_Internal_Rela *rel;
4935 const Elf_Internal_Rela *rel_end;
4936 asection *sreloc;
4937 asection **opd_sym_map;
4938 struct elf_link_hash_entry *tga, *dottga;
4939
4940 if (info->relocatable)
4941 return TRUE;
4942
4943 /* Don't do anything special with non-loaded, non-alloced sections.
4944 In particular, any relocs in such sections should not affect GOT
4945 and PLT reference counting (ie. we don't allow them to create GOT
4946 or PLT entries), there's no possibility or desire to optimize TLS
4947 relocs, and there's not much point in propagating relocs to shared
4948 libs that the dynamic linker won't relocate. */
4949 if ((sec->flags & SEC_ALLOC) == 0)
4950 return TRUE;
4951
4952 BFD_ASSERT (is_ppc64_elf (abfd));
4953
4954 htab = ppc_hash_table (info);
4955 if (htab == NULL)
4956 return FALSE;
4957
4958 tga = elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
4959 FALSE, FALSE, TRUE);
4960 dottga = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
4961 FALSE, FALSE, TRUE);
4962 symtab_hdr = &elf_symtab_hdr (abfd);
4963 sym_hashes = elf_sym_hashes (abfd);
4964 sreloc = NULL;
4965 opd_sym_map = NULL;
4966 if (strcmp (sec->name, ".opd") == 0)
4967 {
4968 /* Garbage collection needs some extra help with .opd sections.
4969 We don't want to necessarily keep everything referenced by
4970 relocs in .opd, as that would keep all functions. Instead,
4971 if we reference an .opd symbol (a function descriptor), we
4972 want to keep the function code symbol's section. This is
4973 easy for global symbols, but for local syms we need to keep
4974 information about the associated function section. */
4975 bfd_size_type amt;
4976
4977 amt = sec->size * sizeof (*opd_sym_map) / 8;
4978 opd_sym_map = bfd_zalloc (abfd, amt);
4979 if (opd_sym_map == NULL)
4980 return FALSE;
4981 ppc64_elf_section_data (sec)->u.opd.func_sec = opd_sym_map;
4982 BFD_ASSERT (ppc64_elf_section_data (sec)->sec_type == sec_normal);
4983 ppc64_elf_section_data (sec)->sec_type = sec_opd;
4984 }
4985
4986 if (htab->sfpr == NULL
4987 && !create_linkage_sections (htab->elf.dynobj, info))
4988 return FALSE;
4989
4990 rel_end = relocs + sec->reloc_count;
4991 for (rel = relocs; rel < rel_end; rel++)
4992 {
4993 unsigned long r_symndx;
4994 struct elf_link_hash_entry *h;
4995 enum elf_ppc64_reloc_type r_type;
4996 int tls_type;
4997 struct _ppc64_elf_section_data *ppc64_sec;
4998 struct plt_entry **ifunc;
4999
5000 r_symndx = ELF64_R_SYM (rel->r_info);
5001 if (r_symndx < symtab_hdr->sh_info)
5002 h = NULL;
5003 else
5004 {
5005 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
5006 h = elf_follow_link (h);
5007
5008 /* PR15323, ref flags aren't set for references in the same
5009 object. */
5010 h->root.non_ir_ref = 1;
5011 }
5012
5013 tls_type = 0;
5014 ifunc = NULL;
5015 if (h != NULL)
5016 {
5017 if (h->type == STT_GNU_IFUNC)
5018 {
5019 h->needs_plt = 1;
5020 ifunc = &h->plt.plist;
5021 }
5022 }
5023 else
5024 {
5025 Elf_Internal_Sym *isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5026 abfd, r_symndx);
5027 if (isym == NULL)
5028 return FALSE;
5029
5030 if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
5031 {
5032 ifunc = update_local_sym_info (abfd, symtab_hdr, r_symndx,
5033 rel->r_addend, PLT_IFUNC);
5034 if (ifunc == NULL)
5035 return FALSE;
5036 }
5037 }
5038 r_type = ELF64_R_TYPE (rel->r_info);
5039 if (is_branch_reloc (r_type))
5040 {
5041 if (h != NULL && (h == tga || h == dottga))
5042 {
5043 if (rel != relocs
5044 && (ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSGD
5045 || ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSLD))
5046 /* We have a new-style __tls_get_addr call with a marker
5047 reloc. */
5048 ;
5049 else
5050 /* Mark this section as having an old-style call. */
5051 sec->has_tls_get_addr_call = 1;
5052 }
5053
5054 /* STT_GNU_IFUNC symbols must have a PLT entry. */
5055 if (ifunc != NULL
5056 && !update_plt_info (abfd, ifunc, rel->r_addend))
5057 return FALSE;
5058 }
5059
5060 switch (r_type)
5061 {
5062 case R_PPC64_TLSGD:
5063 case R_PPC64_TLSLD:
5064 /* These special tls relocs tie a call to __tls_get_addr with
5065 its parameter symbol. */
5066 break;
5067
5068 case R_PPC64_GOT_TLSLD16:
5069 case R_PPC64_GOT_TLSLD16_LO:
5070 case R_PPC64_GOT_TLSLD16_HI:
5071 case R_PPC64_GOT_TLSLD16_HA:
5072 tls_type = TLS_TLS | TLS_LD;
5073 goto dogottls;
5074
5075 case R_PPC64_GOT_TLSGD16:
5076 case R_PPC64_GOT_TLSGD16_LO:
5077 case R_PPC64_GOT_TLSGD16_HI:
5078 case R_PPC64_GOT_TLSGD16_HA:
5079 tls_type = TLS_TLS | TLS_GD;
5080 goto dogottls;
5081
5082 case R_PPC64_GOT_TPREL16_DS:
5083 case R_PPC64_GOT_TPREL16_LO_DS:
5084 case R_PPC64_GOT_TPREL16_HI:
5085 case R_PPC64_GOT_TPREL16_HA:
5086 if (!info->executable)
5087 info->flags |= DF_STATIC_TLS;
5088 tls_type = TLS_TLS | TLS_TPREL;
5089 goto dogottls;
5090
5091 case R_PPC64_GOT_DTPREL16_DS:
5092 case R_PPC64_GOT_DTPREL16_LO_DS:
5093 case R_PPC64_GOT_DTPREL16_HI:
5094 case R_PPC64_GOT_DTPREL16_HA:
5095 tls_type = TLS_TLS | TLS_DTPREL;
5096 dogottls:
5097 sec->has_tls_reloc = 1;
5098 /* Fall thru */
5099
5100 case R_PPC64_GOT16:
5101 case R_PPC64_GOT16_DS:
5102 case R_PPC64_GOT16_HA:
5103 case R_PPC64_GOT16_HI:
5104 case R_PPC64_GOT16_LO:
5105 case R_PPC64_GOT16_LO_DS:
5106 /* This symbol requires a global offset table entry. */
5107 sec->has_toc_reloc = 1;
5108 if (r_type == R_PPC64_GOT_TLSLD16
5109 || r_type == R_PPC64_GOT_TLSGD16
5110 || r_type == R_PPC64_GOT_TPREL16_DS
5111 || r_type == R_PPC64_GOT_DTPREL16_DS
5112 || r_type == R_PPC64_GOT16
5113 || r_type == R_PPC64_GOT16_DS)
5114 {
5115 htab->do_multi_toc = 1;
5116 ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5117 }
5118
5119 if (ppc64_elf_tdata (abfd)->got == NULL
5120 && !create_got_section (abfd, info))
5121 return FALSE;
5122
5123 if (h != NULL)
5124 {
5125 struct ppc_link_hash_entry *eh;
5126 struct got_entry *ent;
5127
5128 eh = (struct ppc_link_hash_entry *) h;
5129 for (ent = eh->elf.got.glist; ent != NULL; ent = ent->next)
5130 if (ent->addend == rel->r_addend
5131 && ent->owner == abfd
5132 && ent->tls_type == tls_type)
5133 break;
5134 if (ent == NULL)
5135 {
5136 bfd_size_type amt = sizeof (*ent);
5137 ent = bfd_alloc (abfd, amt);
5138 if (ent == NULL)
5139 return FALSE;
5140 ent->next = eh->elf.got.glist;
5141 ent->addend = rel->r_addend;
5142 ent->owner = abfd;
5143 ent->tls_type = tls_type;
5144 ent->is_indirect = FALSE;
5145 ent->got.refcount = 0;
5146 eh->elf.got.glist = ent;
5147 }
5148 ent->got.refcount += 1;
5149 eh->tls_mask |= tls_type;
5150 }
5151 else
5152 /* This is a global offset table entry for a local symbol. */
5153 if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5154 rel->r_addend, tls_type))
5155 return FALSE;
5156 break;
5157
5158 case R_PPC64_PLT16_HA:
5159 case R_PPC64_PLT16_HI:
5160 case R_PPC64_PLT16_LO:
5161 case R_PPC64_PLT32:
5162 case R_PPC64_PLT64:
5163 /* This symbol requires a procedure linkage table entry. We
5164 actually build the entry in adjust_dynamic_symbol,
5165 because this might be a case of linking PIC code without
5166 linking in any dynamic objects, in which case we don't
5167 need to generate a procedure linkage table after all. */
5168 if (h == NULL)
5169 {
5170 /* It does not make sense to have a procedure linkage
5171 table entry for a local symbol. */
5172 bfd_set_error (bfd_error_bad_value);
5173 return FALSE;
5174 }
5175 else
5176 {
5177 if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5178 return FALSE;
5179 h->needs_plt = 1;
5180 if (h->root.root.string[0] == '.'
5181 && h->root.root.string[1] != '\0')
5182 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5183 }
5184 break;
5185
5186 /* The following relocations don't need to propagate the
5187 relocation if linking a shared object since they are
5188 section relative. */
5189 case R_PPC64_SECTOFF:
5190 case R_PPC64_SECTOFF_LO:
5191 case R_PPC64_SECTOFF_HI:
5192 case R_PPC64_SECTOFF_HA:
5193 case R_PPC64_SECTOFF_DS:
5194 case R_PPC64_SECTOFF_LO_DS:
5195 case R_PPC64_DTPREL16:
5196 case R_PPC64_DTPREL16_LO:
5197 case R_PPC64_DTPREL16_HI:
5198 case R_PPC64_DTPREL16_HA:
5199 case R_PPC64_DTPREL16_DS:
5200 case R_PPC64_DTPREL16_LO_DS:
5201 case R_PPC64_DTPREL16_HIGHER:
5202 case R_PPC64_DTPREL16_HIGHERA:
5203 case R_PPC64_DTPREL16_HIGHEST:
5204 case R_PPC64_DTPREL16_HIGHESTA:
5205 break;
5206
5207 /* Nor do these. */
5208 case R_PPC64_REL16:
5209 case R_PPC64_REL16_LO:
5210 case R_PPC64_REL16_HI:
5211 case R_PPC64_REL16_HA:
5212 break;
5213
5214 case R_PPC64_TOC16:
5215 case R_PPC64_TOC16_DS:
5216 htab->do_multi_toc = 1;
5217 ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5218 case R_PPC64_TOC16_LO:
5219 case R_PPC64_TOC16_HI:
5220 case R_PPC64_TOC16_HA:
5221 case R_PPC64_TOC16_LO_DS:
5222 sec->has_toc_reloc = 1;
5223 break;
5224
5225 /* This relocation describes the C++ object vtable hierarchy.
5226 Reconstruct it for later use during GC. */
5227 case R_PPC64_GNU_VTINHERIT:
5228 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
5229 return FALSE;
5230 break;
5231
5232 /* This relocation describes which C++ vtable entries are actually
5233 used. Record for later use during GC. */
5234 case R_PPC64_GNU_VTENTRY:
5235 BFD_ASSERT (h != NULL);
5236 if (h != NULL
5237 && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
5238 return FALSE;
5239 break;
5240
5241 case R_PPC64_REL14:
5242 case R_PPC64_REL14_BRTAKEN:
5243 case R_PPC64_REL14_BRNTAKEN:
5244 {
5245 asection *dest = NULL;
5246
5247 /* Heuristic: If jumping outside our section, chances are
5248 we are going to need a stub. */
5249 if (h != NULL)
5250 {
5251 /* If the sym is weak it may be overridden later, so
5252 don't assume we know where a weak sym lives. */
5253 if (h->root.type == bfd_link_hash_defined)
5254 dest = h->root.u.def.section;
5255 }
5256 else
5257 {
5258 Elf_Internal_Sym *isym;
5259
5260 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5261 abfd, r_symndx);
5262 if (isym == NULL)
5263 return FALSE;
5264
5265 dest = bfd_section_from_elf_index (abfd, isym->st_shndx);
5266 }
5267
5268 if (dest != sec)
5269 ppc64_elf_section_data (sec)->has_14bit_branch = 1;
5270 }
5271 /* Fall through. */
5272
5273 case R_PPC64_REL24:
5274 if (h != NULL && ifunc == NULL)
5275 {
5276 /* We may need a .plt entry if the function this reloc
5277 refers to is in a shared lib. */
5278 if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5279 return FALSE;
5280 h->needs_plt = 1;
5281 if (h->root.root.string[0] == '.'
5282 && h->root.root.string[1] != '\0')
5283 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5284 if (h == tga || h == dottga)
5285 sec->has_tls_reloc = 1;
5286 }
5287 break;
5288
5289 case R_PPC64_TPREL64:
5290 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_TPREL;
5291 if (!info->executable)
5292 info->flags |= DF_STATIC_TLS;
5293 goto dotlstoc;
5294
5295 case R_PPC64_DTPMOD64:
5296 if (rel + 1 < rel_end
5297 && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
5298 && rel[1].r_offset == rel->r_offset + 8)
5299 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_GD;
5300 else
5301 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_LD;
5302 goto dotlstoc;
5303
5304 case R_PPC64_DTPREL64:
5305 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_DTPREL;
5306 if (rel != relocs
5307 && rel[-1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPMOD64)
5308 && rel[-1].r_offset == rel->r_offset - 8)
5309 /* This is the second reloc of a dtpmod, dtprel pair.
5310 Don't mark with TLS_DTPREL. */
5311 goto dodyn;
5312
5313 dotlstoc:
5314 sec->has_tls_reloc = 1;
5315 if (h != NULL)
5316 {
5317 struct ppc_link_hash_entry *eh;
5318 eh = (struct ppc_link_hash_entry *) h;
5319 eh->tls_mask |= tls_type;
5320 }
5321 else
5322 if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5323 rel->r_addend, tls_type))
5324 return FALSE;
5325
5326 ppc64_sec = ppc64_elf_section_data (sec);
5327 if (ppc64_sec->sec_type != sec_toc)
5328 {
5329 bfd_size_type amt;
5330
5331 /* One extra to simplify get_tls_mask. */
5332 amt = sec->size * sizeof (unsigned) / 8 + sizeof (unsigned);
5333 ppc64_sec->u.toc.symndx = bfd_zalloc (abfd, amt);
5334 if (ppc64_sec->u.toc.symndx == NULL)
5335 return FALSE;
5336 amt = sec->size * sizeof (bfd_vma) / 8;
5337 ppc64_sec->u.toc.add = bfd_zalloc (abfd, amt);
5338 if (ppc64_sec->u.toc.add == NULL)
5339 return FALSE;
5340 BFD_ASSERT (ppc64_sec->sec_type == sec_normal);
5341 ppc64_sec->sec_type = sec_toc;
5342 }
5343 BFD_ASSERT (rel->r_offset % 8 == 0);
5344 ppc64_sec->u.toc.symndx[rel->r_offset / 8] = r_symndx;
5345 ppc64_sec->u.toc.add[rel->r_offset / 8] = rel->r_addend;
5346
5347 /* Mark the second slot of a GD or LD entry.
5348 -1 to indicate GD and -2 to indicate LD. */
5349 if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_GD))
5350 ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -1;
5351 else if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_LD))
5352 ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -2;
5353 goto dodyn;
5354
5355 case R_PPC64_TPREL16:
5356 case R_PPC64_TPREL16_LO:
5357 case R_PPC64_TPREL16_HI:
5358 case R_PPC64_TPREL16_HA:
5359 case R_PPC64_TPREL16_DS:
5360 case R_PPC64_TPREL16_LO_DS:
5361 case R_PPC64_TPREL16_HIGHER:
5362 case R_PPC64_TPREL16_HIGHERA:
5363 case R_PPC64_TPREL16_HIGHEST:
5364 case R_PPC64_TPREL16_HIGHESTA:
5365 if (info->shared)
5366 {
5367 if (!info->executable)
5368 info->flags |= DF_STATIC_TLS;
5369 goto dodyn;
5370 }
5371 break;
5372
5373 case R_PPC64_ADDR64:
5374 if (opd_sym_map != NULL
5375 && rel + 1 < rel_end
5376 && ELF64_R_TYPE ((rel + 1)->r_info) == R_PPC64_TOC)
5377 {
5378 if (h != NULL)
5379 {
5380 if (h->root.root.string[0] == '.'
5381 && h->root.root.string[1] != 0
5382 && lookup_fdh ((struct ppc_link_hash_entry *) h, htab))
5383 ;
5384 else
5385 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5386 }
5387 else
5388 {
5389 asection *s;
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 && s != sec)
5399 opd_sym_map[rel->r_offset / 8] = s;
5400 }
5401 }
5402 /* Fall through. */
5403
5404 case R_PPC64_REL30:
5405 case R_PPC64_REL32:
5406 case R_PPC64_REL64:
5407 case R_PPC64_ADDR14:
5408 case R_PPC64_ADDR14_BRNTAKEN:
5409 case R_PPC64_ADDR14_BRTAKEN:
5410 case R_PPC64_ADDR16:
5411 case R_PPC64_ADDR16_DS:
5412 case R_PPC64_ADDR16_HA:
5413 case R_PPC64_ADDR16_HI:
5414 case R_PPC64_ADDR16_HIGHER:
5415 case R_PPC64_ADDR16_HIGHERA:
5416 case R_PPC64_ADDR16_HIGHEST:
5417 case R_PPC64_ADDR16_HIGHESTA:
5418 case R_PPC64_ADDR16_LO:
5419 case R_PPC64_ADDR16_LO_DS:
5420 case R_PPC64_ADDR24:
5421 case R_PPC64_ADDR32:
5422 case R_PPC64_UADDR16:
5423 case R_PPC64_UADDR32:
5424 case R_PPC64_UADDR64:
5425 case R_PPC64_TOC:
5426 if (h != NULL && !info->shared)
5427 /* We may need a copy reloc. */
5428 h->non_got_ref = 1;
5429
5430 /* Don't propagate .opd relocs. */
5431 if (NO_OPD_RELOCS && opd_sym_map != NULL)
5432 break;
5433
5434 /* If we are creating a shared library, and this is a reloc
5435 against a global symbol, or a non PC relative reloc
5436 against a local symbol, then we need to copy the reloc
5437 into the shared library. However, if we are linking with
5438 -Bsymbolic, we do not need to copy a reloc against a
5439 global symbol which is defined in an object we are
5440 including in the link (i.e., DEF_REGULAR is set). At
5441 this point we have not seen all the input files, so it is
5442 possible that DEF_REGULAR is not set now but will be set
5443 later (it is never cleared). In case of a weak definition,
5444 DEF_REGULAR may be cleared later by a strong definition in
5445 a shared library. We account for that possibility below by
5446 storing information in the dyn_relocs field of the hash
5447 table entry. A similar situation occurs when creating
5448 shared libraries and symbol visibility changes render the
5449 symbol local.
5450
5451 If on the other hand, we are creating an executable, we
5452 may need to keep relocations for symbols satisfied by a
5453 dynamic library if we manage to avoid copy relocs for the
5454 symbol. */
5455 dodyn:
5456 if ((info->shared
5457 && (must_be_dyn_reloc (info, r_type)
5458 || (h != NULL
5459 && (!SYMBOLIC_BIND (info, h)
5460 || h->root.type == bfd_link_hash_defweak
5461 || !h->def_regular))))
5462 || (ELIMINATE_COPY_RELOCS
5463 && !info->shared
5464 && h != NULL
5465 && (h->root.type == bfd_link_hash_defweak
5466 || !h->def_regular))
5467 || (!info->shared
5468 && ifunc != NULL))
5469 {
5470 /* We must copy these reloc types into the output file.
5471 Create a reloc section in dynobj and make room for
5472 this reloc. */
5473 if (sreloc == NULL)
5474 {
5475 sreloc = _bfd_elf_make_dynamic_reloc_section
5476 (sec, htab->elf.dynobj, 3, abfd, /*rela?*/ TRUE);
5477
5478 if (sreloc == NULL)
5479 return FALSE;
5480 }
5481
5482 /* If this is a global symbol, we count the number of
5483 relocations we need for this symbol. */
5484 if (h != NULL)
5485 {
5486 struct elf_dyn_relocs *p;
5487 struct elf_dyn_relocs **head;
5488
5489 head = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
5490 p = *head;
5491 if (p == NULL || p->sec != sec)
5492 {
5493 p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5494 if (p == NULL)
5495 return FALSE;
5496 p->next = *head;
5497 *head = p;
5498 p->sec = sec;
5499 p->count = 0;
5500 p->pc_count = 0;
5501 }
5502 p->count += 1;
5503 if (!must_be_dyn_reloc (info, r_type))
5504 p->pc_count += 1;
5505 }
5506 else
5507 {
5508 /* Track dynamic relocs needed for local syms too.
5509 We really need local syms available to do this
5510 easily. Oh well. */
5511 struct ppc_dyn_relocs *p;
5512 struct ppc_dyn_relocs **head;
5513 bfd_boolean is_ifunc;
5514 asection *s;
5515 void *vpp;
5516 Elf_Internal_Sym *isym;
5517
5518 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5519 abfd, r_symndx);
5520 if (isym == NULL)
5521 return FALSE;
5522
5523 s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5524 if (s == NULL)
5525 s = sec;
5526
5527 vpp = &elf_section_data (s)->local_dynrel;
5528 head = (struct ppc_dyn_relocs **) vpp;
5529 is_ifunc = ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC;
5530 p = *head;
5531 if (p != NULL && p->sec == sec && p->ifunc != is_ifunc)
5532 p = p->next;
5533 if (p == NULL || p->sec != sec || p->ifunc != is_ifunc)
5534 {
5535 p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5536 if (p == NULL)
5537 return FALSE;
5538 p->next = *head;
5539 *head = p;
5540 p->sec = sec;
5541 p->ifunc = is_ifunc;
5542 p->count = 0;
5543 }
5544 p->count += 1;
5545 }
5546 }
5547 break;
5548
5549 default:
5550 break;
5551 }
5552 }
5553
5554 return TRUE;
5555 }
5556
5557 /* OFFSET in OPD_SEC specifies a function descriptor. Return the address
5558 of the code entry point, and its section. */
5559
5560 static bfd_vma
5561 opd_entry_value (asection *opd_sec,
5562 bfd_vma offset,
5563 asection **code_sec,
5564 bfd_vma *code_off,
5565 bfd_boolean in_code_sec)
5566 {
5567 bfd *opd_bfd = opd_sec->owner;
5568 Elf_Internal_Rela *relocs;
5569 Elf_Internal_Rela *lo, *hi, *look;
5570 bfd_vma val;
5571
5572 /* No relocs implies we are linking a --just-symbols object, or looking
5573 at a final linked executable with addr2line or somesuch. */
5574 if (opd_sec->reloc_count == 0)
5575 {
5576 char buf[8];
5577
5578 if (!bfd_get_section_contents (opd_bfd, opd_sec, buf, offset, 8))
5579 return (bfd_vma) -1;
5580
5581 val = bfd_get_64 (opd_bfd, buf);
5582 if (code_sec != NULL)
5583 {
5584 asection *sec, *likely = NULL;
5585
5586 if (in_code_sec)
5587 {
5588 sec = *code_sec;
5589 if (sec->vma <= val
5590 && val < sec->vma + sec->size)
5591 likely = sec;
5592 else
5593 val = -1;
5594 }
5595 else
5596 for (sec = opd_bfd->sections; sec != NULL; sec = sec->next)
5597 if (sec->vma <= val
5598 && (sec->flags & SEC_LOAD) != 0
5599 && (sec->flags & SEC_ALLOC) != 0)
5600 likely = sec;
5601 if (likely != NULL)
5602 {
5603 *code_sec = likely;
5604 if (code_off != NULL)
5605 *code_off = val - likely->vma;
5606 }
5607 }
5608 return val;
5609 }
5610
5611 BFD_ASSERT (is_ppc64_elf (opd_bfd));
5612
5613 relocs = ppc64_elf_tdata (opd_bfd)->opd_relocs;
5614 if (relocs == NULL)
5615 relocs = _bfd_elf_link_read_relocs (opd_bfd, opd_sec, NULL, NULL, TRUE);
5616
5617 /* Go find the opd reloc at the sym address. */
5618 lo = relocs;
5619 BFD_ASSERT (lo != NULL);
5620 hi = lo + opd_sec->reloc_count - 1; /* ignore last reloc */
5621 val = (bfd_vma) -1;
5622 while (lo < hi)
5623 {
5624 look = lo + (hi - lo) / 2;
5625 if (look->r_offset < offset)
5626 lo = look + 1;
5627 else if (look->r_offset > offset)
5628 hi = look;
5629 else
5630 {
5631 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (opd_bfd);
5632
5633 if (ELF64_R_TYPE (look->r_info) == R_PPC64_ADDR64
5634 && ELF64_R_TYPE ((look + 1)->r_info) == R_PPC64_TOC)
5635 {
5636 unsigned long symndx = ELF64_R_SYM (look->r_info);
5637 asection *sec;
5638
5639 if (symndx < symtab_hdr->sh_info
5640 || elf_sym_hashes (opd_bfd) == NULL)
5641 {
5642 Elf_Internal_Sym *sym;
5643
5644 sym = (Elf_Internal_Sym *) symtab_hdr->contents;
5645 if (sym == NULL)
5646 {
5647 size_t symcnt = symtab_hdr->sh_info;
5648 if (elf_sym_hashes (opd_bfd) == NULL)
5649 symcnt = symtab_hdr->sh_size / symtab_hdr->sh_entsize;
5650 sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr, symcnt,
5651 0, NULL, NULL, NULL);
5652 if (sym == NULL)
5653 break;
5654 symtab_hdr->contents = (bfd_byte *) sym;
5655 }
5656
5657 sym += symndx;
5658 val = sym->st_value;
5659 sec = bfd_section_from_elf_index (opd_bfd, sym->st_shndx);
5660 BFD_ASSERT ((sec->flags & SEC_MERGE) == 0);
5661 }
5662 else
5663 {
5664 struct elf_link_hash_entry **sym_hashes;
5665 struct elf_link_hash_entry *rh;
5666
5667 sym_hashes = elf_sym_hashes (opd_bfd);
5668 rh = sym_hashes[symndx - symtab_hdr->sh_info];
5669 rh = elf_follow_link (rh);
5670 BFD_ASSERT (rh->root.type == bfd_link_hash_defined
5671 || rh->root.type == bfd_link_hash_defweak);
5672 val = rh->root.u.def.value;
5673 sec = rh->root.u.def.section;
5674 }
5675 val += look->r_addend;
5676 if (code_off != NULL)
5677 *code_off = val;
5678 if (code_sec != NULL)
5679 {
5680 if (in_code_sec && *code_sec != sec)
5681 return -1;
5682 else
5683 *code_sec = sec;
5684 }
5685 if (sec != NULL && sec->output_section != NULL)
5686 val += sec->output_section->vma + sec->output_offset;
5687 }
5688 break;
5689 }
5690 }
5691
5692 return val;
5693 }
5694
5695 /* If the ELF symbol SYM might be a function in SEC, return the
5696 function size and set *CODE_OFF to the function's entry point,
5697 otherwise return zero. */
5698
5699 static bfd_size_type
5700 ppc64_elf_maybe_function_sym (const asymbol *sym, asection *sec,
5701 bfd_vma *code_off)
5702 {
5703 bfd_size_type size;
5704
5705 if ((sym->flags & (BSF_SECTION_SYM | BSF_FILE | BSF_OBJECT
5706 | BSF_THREAD_LOCAL | BSF_RELC | BSF_SRELC)) != 0)
5707 return 0;
5708
5709 size = 0;
5710 if (!(sym->flags & BSF_SYNTHETIC))
5711 size = ((elf_symbol_type *) sym)->internal_elf_sym.st_size;
5712
5713 if (strcmp (sym->section->name, ".opd") == 0)
5714 {
5715 if (opd_entry_value (sym->section, sym->value,
5716 &sec, code_off, TRUE) == (bfd_vma) -1)
5717 return 0;
5718 /* An old ABI binary with dot-syms has a size of 24 on the .opd
5719 symbol. This size has nothing to do with the code size of the
5720 function, which is what we're supposed to return, but the
5721 code size isn't available without looking up the dot-sym.
5722 However, doing that would be a waste of time particularly
5723 since elf_find_function will look at the dot-sym anyway.
5724 Now, elf_find_function will keep the largest size of any
5725 function sym found at the code address of interest, so return
5726 1 here to avoid it incorrectly caching a larger function size
5727 for a small function. This does mean we return the wrong
5728 size for a new-ABI function of size 24, but all that does is
5729 disable caching for such functions. */
5730 if (size == 24)
5731 size = 1;
5732 }
5733 else
5734 {
5735 if (sym->section != sec)
5736 return 0;
5737 *code_off = sym->value;
5738 }
5739 if (size == 0)
5740 size = 1;
5741 return size;
5742 }
5743
5744 /* Return true if symbol is defined in a regular object file. */
5745
5746 static bfd_boolean
5747 is_static_defined (struct elf_link_hash_entry *h)
5748 {
5749 return ((h->root.type == bfd_link_hash_defined
5750 || h->root.type == bfd_link_hash_defweak)
5751 && h->root.u.def.section != NULL
5752 && h->root.u.def.section->output_section != NULL);
5753 }
5754
5755 /* If FDH is a function descriptor symbol, return the associated code
5756 entry symbol if it is defined. Return NULL otherwise. */
5757
5758 static struct ppc_link_hash_entry *
5759 defined_code_entry (struct ppc_link_hash_entry *fdh)
5760 {
5761 if (fdh->is_func_descriptor)
5762 {
5763 struct ppc_link_hash_entry *fh = ppc_follow_link (fdh->oh);
5764 if (fh->elf.root.type == bfd_link_hash_defined
5765 || fh->elf.root.type == bfd_link_hash_defweak)
5766 return fh;
5767 }
5768 return NULL;
5769 }
5770
5771 /* If FH is a function code entry symbol, return the associated
5772 function descriptor symbol if it is defined. Return NULL otherwise. */
5773
5774 static struct ppc_link_hash_entry *
5775 defined_func_desc (struct ppc_link_hash_entry *fh)
5776 {
5777 if (fh->oh != NULL
5778 && fh->oh->is_func_descriptor)
5779 {
5780 struct ppc_link_hash_entry *fdh = ppc_follow_link (fh->oh);
5781 if (fdh->elf.root.type == bfd_link_hash_defined
5782 || fdh->elf.root.type == bfd_link_hash_defweak)
5783 return fdh;
5784 }
5785 return NULL;
5786 }
5787
5788 /* Mark all our entry sym sections, both opd and code section. */
5789
5790 static void
5791 ppc64_elf_gc_keep (struct bfd_link_info *info)
5792 {
5793 struct ppc_link_hash_table *htab = ppc_hash_table (info);
5794 struct bfd_sym_chain *sym;
5795
5796 if (htab == NULL)
5797 return;
5798
5799 for (sym = info->gc_sym_list; sym != NULL; sym = sym->next)
5800 {
5801 struct ppc_link_hash_entry *eh, *fh;
5802 asection *sec;
5803
5804 eh = (struct ppc_link_hash_entry *)
5805 elf_link_hash_lookup (&htab->elf, sym->name, FALSE, FALSE, TRUE);
5806 if (eh == NULL)
5807 continue;
5808 if (eh->elf.root.type != bfd_link_hash_defined
5809 && eh->elf.root.type != bfd_link_hash_defweak)
5810 continue;
5811
5812 fh = defined_code_entry (eh);
5813 if (fh != NULL)
5814 {
5815 sec = fh->elf.root.u.def.section;
5816 sec->flags |= SEC_KEEP;
5817 }
5818 else if (get_opd_info (eh->elf.root.u.def.section) != NULL
5819 && opd_entry_value (eh->elf.root.u.def.section,
5820 eh->elf.root.u.def.value,
5821 &sec, NULL, FALSE) != (bfd_vma) -1)
5822 sec->flags |= SEC_KEEP;
5823
5824 sec = eh->elf.root.u.def.section;
5825 sec->flags |= SEC_KEEP;
5826 }
5827 }
5828
5829 /* Mark sections containing dynamically referenced symbols. When
5830 building shared libraries, we must assume that any visible symbol is
5831 referenced. */
5832
5833 static bfd_boolean
5834 ppc64_elf_gc_mark_dynamic_ref (struct elf_link_hash_entry *h, void *inf)
5835 {
5836 struct bfd_link_info *info = (struct bfd_link_info *) inf;
5837 struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
5838 struct ppc_link_hash_entry *fdh;
5839
5840 /* Dynamic linking info is on the func descriptor sym. */
5841 fdh = defined_func_desc (eh);
5842 if (fdh != NULL)
5843 eh = fdh;
5844
5845 if ((eh->elf.root.type == bfd_link_hash_defined
5846 || eh->elf.root.type == bfd_link_hash_defweak)
5847 && (eh->elf.ref_dynamic
5848 || (!info->executable
5849 && eh->elf.def_regular
5850 && ELF_ST_VISIBILITY (eh->elf.other) != STV_INTERNAL
5851 && ELF_ST_VISIBILITY (eh->elf.other) != STV_HIDDEN
5852 && (strchr (eh->elf.root.root.string, ELF_VER_CHR) != NULL
5853 || !bfd_hide_sym_by_version (info->version_info,
5854 eh->elf.root.root.string)))))
5855 {
5856 asection *code_sec;
5857 struct ppc_link_hash_entry *fh;
5858
5859 eh->elf.root.u.def.section->flags |= SEC_KEEP;
5860
5861 /* Function descriptor syms cause the associated
5862 function code sym section to be marked. */
5863 fh = defined_code_entry (eh);
5864 if (fh != NULL)
5865 {
5866 code_sec = fh->elf.root.u.def.section;
5867 code_sec->flags |= SEC_KEEP;
5868 }
5869 else if (get_opd_info (eh->elf.root.u.def.section) != NULL
5870 && opd_entry_value (eh->elf.root.u.def.section,
5871 eh->elf.root.u.def.value,
5872 &code_sec, NULL, FALSE) != (bfd_vma) -1)
5873 code_sec->flags |= SEC_KEEP;
5874 }
5875
5876 return TRUE;
5877 }
5878
5879 /* Return the section that should be marked against GC for a given
5880 relocation. */
5881
5882 static asection *
5883 ppc64_elf_gc_mark_hook (asection *sec,
5884 struct bfd_link_info *info,
5885 Elf_Internal_Rela *rel,
5886 struct elf_link_hash_entry *h,
5887 Elf_Internal_Sym *sym)
5888 {
5889 asection *rsec;
5890
5891 /* Syms return NULL if we're marking .opd, so we avoid marking all
5892 function sections, as all functions are referenced in .opd. */
5893 rsec = NULL;
5894 if (get_opd_info (sec) != NULL)
5895 return rsec;
5896
5897 if (h != NULL)
5898 {
5899 enum elf_ppc64_reloc_type r_type;
5900 struct ppc_link_hash_entry *eh, *fh, *fdh;
5901
5902 r_type = ELF64_R_TYPE (rel->r_info);
5903 switch (r_type)
5904 {
5905 case R_PPC64_GNU_VTINHERIT:
5906 case R_PPC64_GNU_VTENTRY:
5907 break;
5908
5909 default:
5910 switch (h->root.type)
5911 {
5912 case bfd_link_hash_defined:
5913 case bfd_link_hash_defweak:
5914 eh = (struct ppc_link_hash_entry *) h;
5915 fdh = defined_func_desc (eh);
5916 if (fdh != NULL)
5917 eh = fdh;
5918
5919 /* Function descriptor syms cause the associated
5920 function code sym section to be marked. */
5921 fh = defined_code_entry (eh);
5922 if (fh != NULL)
5923 {
5924 /* They also mark their opd section. */
5925 eh->elf.root.u.def.section->gc_mark = 1;
5926
5927 rsec = fh->elf.root.u.def.section;
5928 }
5929 else if (get_opd_info (eh->elf.root.u.def.section) != NULL
5930 && opd_entry_value (eh->elf.root.u.def.section,
5931 eh->elf.root.u.def.value,
5932 &rsec, NULL, FALSE) != (bfd_vma) -1)
5933 eh->elf.root.u.def.section->gc_mark = 1;
5934 else
5935 rsec = h->root.u.def.section;
5936 break;
5937
5938 case bfd_link_hash_common:
5939 rsec = h->root.u.c.p->section;
5940 break;
5941
5942 default:
5943 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
5944 }
5945 }
5946 }
5947 else
5948 {
5949 struct _opd_sec_data *opd;
5950
5951 rsec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
5952 opd = get_opd_info (rsec);
5953 if (opd != NULL && opd->func_sec != NULL)
5954 {
5955 rsec->gc_mark = 1;
5956
5957 rsec = opd->func_sec[(sym->st_value + rel->r_addend) / 8];
5958 }
5959 }
5960
5961 return rsec;
5962 }
5963
5964 /* Update the .got, .plt. and dynamic reloc reference counts for the
5965 section being removed. */
5966
5967 static bfd_boolean
5968 ppc64_elf_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info,
5969 asection *sec, const Elf_Internal_Rela *relocs)
5970 {
5971 struct ppc_link_hash_table *htab;
5972 Elf_Internal_Shdr *symtab_hdr;
5973 struct elf_link_hash_entry **sym_hashes;
5974 struct got_entry **local_got_ents;
5975 const Elf_Internal_Rela *rel, *relend;
5976
5977 if (info->relocatable)
5978 return TRUE;
5979
5980 if ((sec->flags & SEC_ALLOC) == 0)
5981 return TRUE;
5982
5983 elf_section_data (sec)->local_dynrel = NULL;
5984
5985 htab = ppc_hash_table (info);
5986 if (htab == NULL)
5987 return FALSE;
5988
5989 symtab_hdr = &elf_symtab_hdr (abfd);
5990 sym_hashes = elf_sym_hashes (abfd);
5991 local_got_ents = elf_local_got_ents (abfd);
5992
5993 relend = relocs + sec->reloc_count;
5994 for (rel = relocs; rel < relend; rel++)
5995 {
5996 unsigned long r_symndx;
5997 enum elf_ppc64_reloc_type r_type;
5998 struct elf_link_hash_entry *h = NULL;
5999 unsigned char tls_type = 0;
6000
6001 r_symndx = ELF64_R_SYM (rel->r_info);
6002 r_type = ELF64_R_TYPE (rel->r_info);
6003 if (r_symndx >= symtab_hdr->sh_info)
6004 {
6005 struct ppc_link_hash_entry *eh;
6006 struct elf_dyn_relocs **pp;
6007 struct elf_dyn_relocs *p;
6008
6009 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
6010 h = elf_follow_link (h);
6011 eh = (struct ppc_link_hash_entry *) h;
6012
6013 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
6014 if (p->sec == sec)
6015 {
6016 /* Everything must go for SEC. */
6017 *pp = p->next;
6018 break;
6019 }
6020 }
6021
6022 if (is_branch_reloc (r_type))
6023 {
6024 struct plt_entry **ifunc = NULL;
6025 if (h != NULL)
6026 {
6027 if (h->type == STT_GNU_IFUNC)
6028 ifunc = &h->plt.plist;
6029 }
6030 else if (local_got_ents != NULL)
6031 {
6032 struct plt_entry **local_plt = (struct plt_entry **)
6033 (local_got_ents + symtab_hdr->sh_info);
6034 unsigned char *local_got_tls_masks = (unsigned char *)
6035 (local_plt + symtab_hdr->sh_info);
6036 if ((local_got_tls_masks[r_symndx] & PLT_IFUNC) != 0)
6037 ifunc = local_plt + r_symndx;
6038 }
6039 if (ifunc != NULL)
6040 {
6041 struct plt_entry *ent;
6042
6043 for (ent = *ifunc; ent != NULL; ent = ent->next)
6044 if (ent->addend == rel->r_addend)
6045 break;
6046 if (ent == NULL)
6047 abort ();
6048 if (ent->plt.refcount > 0)
6049 ent->plt.refcount -= 1;
6050 continue;
6051 }
6052 }
6053
6054 switch (r_type)
6055 {
6056 case R_PPC64_GOT_TLSLD16:
6057 case R_PPC64_GOT_TLSLD16_LO:
6058 case R_PPC64_GOT_TLSLD16_HI:
6059 case R_PPC64_GOT_TLSLD16_HA:
6060 tls_type = TLS_TLS | TLS_LD;
6061 goto dogot;
6062
6063 case R_PPC64_GOT_TLSGD16:
6064 case R_PPC64_GOT_TLSGD16_LO:
6065 case R_PPC64_GOT_TLSGD16_HI:
6066 case R_PPC64_GOT_TLSGD16_HA:
6067 tls_type = TLS_TLS | TLS_GD;
6068 goto dogot;
6069
6070 case R_PPC64_GOT_TPREL16_DS:
6071 case R_PPC64_GOT_TPREL16_LO_DS:
6072 case R_PPC64_GOT_TPREL16_HI:
6073 case R_PPC64_GOT_TPREL16_HA:
6074 tls_type = TLS_TLS | TLS_TPREL;
6075 goto dogot;
6076
6077 case R_PPC64_GOT_DTPREL16_DS:
6078 case R_PPC64_GOT_DTPREL16_LO_DS:
6079 case R_PPC64_GOT_DTPREL16_HI:
6080 case R_PPC64_GOT_DTPREL16_HA:
6081 tls_type = TLS_TLS | TLS_DTPREL;
6082 goto dogot;
6083
6084 case R_PPC64_GOT16:
6085 case R_PPC64_GOT16_DS:
6086 case R_PPC64_GOT16_HA:
6087 case R_PPC64_GOT16_HI:
6088 case R_PPC64_GOT16_LO:
6089 case R_PPC64_GOT16_LO_DS:
6090 dogot:
6091 {
6092 struct got_entry *ent;
6093
6094 if (h != NULL)
6095 ent = h->got.glist;
6096 else
6097 ent = local_got_ents[r_symndx];
6098
6099 for (; ent != NULL; ent = ent->next)
6100 if (ent->addend == rel->r_addend
6101 && ent->owner == abfd
6102 && ent->tls_type == tls_type)
6103 break;
6104 if (ent == NULL)
6105 abort ();
6106 if (ent->got.refcount > 0)
6107 ent->got.refcount -= 1;
6108 }
6109 break;
6110
6111 case R_PPC64_PLT16_HA:
6112 case R_PPC64_PLT16_HI:
6113 case R_PPC64_PLT16_LO:
6114 case R_PPC64_PLT32:
6115 case R_PPC64_PLT64:
6116 case R_PPC64_REL14:
6117 case R_PPC64_REL14_BRNTAKEN:
6118 case R_PPC64_REL14_BRTAKEN:
6119 case R_PPC64_REL24:
6120 if (h != NULL)
6121 {
6122 struct plt_entry *ent;
6123
6124 for (ent = h->plt.plist; ent != NULL; ent = ent->next)
6125 if (ent->addend == rel->r_addend)
6126 break;
6127 if (ent != NULL && ent->plt.refcount > 0)
6128 ent->plt.refcount -= 1;
6129 }
6130 break;
6131
6132 default:
6133 break;
6134 }
6135 }
6136 return TRUE;
6137 }
6138
6139 /* The maximum size of .sfpr. */
6140 #define SFPR_MAX (218*4)
6141
6142 struct sfpr_def_parms
6143 {
6144 const char name[12];
6145 unsigned char lo, hi;
6146 bfd_byte * (*write_ent) (bfd *, bfd_byte *, int);
6147 bfd_byte * (*write_tail) (bfd *, bfd_byte *, int);
6148 };
6149
6150 /* Auto-generate _save*, _rest* functions in .sfpr. */
6151
6152 static bfd_boolean
6153 sfpr_define (struct bfd_link_info *info, const struct sfpr_def_parms *parm)
6154 {
6155 struct ppc_link_hash_table *htab = ppc_hash_table (info);
6156 unsigned int i;
6157 size_t len = strlen (parm->name);
6158 bfd_boolean writing = FALSE;
6159 char sym[16];
6160
6161 if (htab == NULL)
6162 return FALSE;
6163
6164 memcpy (sym, parm->name, len);
6165 sym[len + 2] = 0;
6166
6167 for (i = parm->lo; i <= parm->hi; i++)
6168 {
6169 struct elf_link_hash_entry *h;
6170
6171 sym[len + 0] = i / 10 + '0';
6172 sym[len + 1] = i % 10 + '0';
6173 h = elf_link_hash_lookup (&htab->elf, sym, FALSE, FALSE, TRUE);
6174 if (h != NULL
6175 && !h->def_regular)
6176 {
6177 h->root.type = bfd_link_hash_defined;
6178 h->root.u.def.section = htab->sfpr;
6179 h->root.u.def.value = htab->sfpr->size;
6180 h->type = STT_FUNC;
6181 h->def_regular = 1;
6182 _bfd_elf_link_hash_hide_symbol (info, h, TRUE);
6183 writing = TRUE;
6184 if (htab->sfpr->contents == NULL)
6185 {
6186 htab->sfpr->contents = bfd_alloc (htab->elf.dynobj, SFPR_MAX);
6187 if (htab->sfpr->contents == NULL)
6188 return FALSE;
6189 }
6190 }
6191 if (writing)
6192 {
6193 bfd_byte *p = htab->sfpr->contents + htab->sfpr->size;
6194 if (i != parm->hi)
6195 p = (*parm->write_ent) (htab->elf.dynobj, p, i);
6196 else
6197 p = (*parm->write_tail) (htab->elf.dynobj, p, i);
6198 htab->sfpr->size = p - htab->sfpr->contents;
6199 }
6200 }
6201
6202 return TRUE;
6203 }
6204
6205 static bfd_byte *
6206 savegpr0 (bfd *abfd, bfd_byte *p, int r)
6207 {
6208 bfd_put_32 (abfd, STD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6209 return p + 4;
6210 }
6211
6212 static bfd_byte *
6213 savegpr0_tail (bfd *abfd, bfd_byte *p, int r)
6214 {
6215 p = savegpr0 (abfd, p, r);
6216 bfd_put_32 (abfd, STD_R0_0R1 + 16, p);
6217 p = p + 4;
6218 bfd_put_32 (abfd, BLR, p);
6219 return p + 4;
6220 }
6221
6222 static bfd_byte *
6223 restgpr0 (bfd *abfd, bfd_byte *p, int r)
6224 {
6225 bfd_put_32 (abfd, LD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6226 return p + 4;
6227 }
6228
6229 static bfd_byte *
6230 restgpr0_tail (bfd *abfd, bfd_byte *p, int r)
6231 {
6232 bfd_put_32 (abfd, LD_R0_0R1 + 16, p);
6233 p = p + 4;
6234 p = restgpr0 (abfd, p, r);
6235 bfd_put_32 (abfd, MTLR_R0, p);
6236 p = p + 4;
6237 if (r == 29)
6238 {
6239 p = restgpr0 (abfd, p, 30);
6240 p = restgpr0 (abfd, p, 31);
6241 }
6242 bfd_put_32 (abfd, BLR, p);
6243 return p + 4;
6244 }
6245
6246 static bfd_byte *
6247 savegpr1 (bfd *abfd, bfd_byte *p, int r)
6248 {
6249 bfd_put_32 (abfd, STD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6250 return p + 4;
6251 }
6252
6253 static bfd_byte *
6254 savegpr1_tail (bfd *abfd, bfd_byte *p, int r)
6255 {
6256 p = savegpr1 (abfd, p, r);
6257 bfd_put_32 (abfd, BLR, p);
6258 return p + 4;
6259 }
6260
6261 static bfd_byte *
6262 restgpr1 (bfd *abfd, bfd_byte *p, int r)
6263 {
6264 bfd_put_32 (abfd, LD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6265 return p + 4;
6266 }
6267
6268 static bfd_byte *
6269 restgpr1_tail (bfd *abfd, bfd_byte *p, int r)
6270 {
6271 p = restgpr1 (abfd, p, r);
6272 bfd_put_32 (abfd, BLR, p);
6273 return p + 4;
6274 }
6275
6276 static bfd_byte *
6277 savefpr (bfd *abfd, bfd_byte *p, int r)
6278 {
6279 bfd_put_32 (abfd, STFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6280 return p + 4;
6281 }
6282
6283 static bfd_byte *
6284 savefpr0_tail (bfd *abfd, bfd_byte *p, int r)
6285 {
6286 p = savefpr (abfd, p, r);
6287 bfd_put_32 (abfd, STD_R0_0R1 + 16, p);
6288 p = p + 4;
6289 bfd_put_32 (abfd, BLR, p);
6290 return p + 4;
6291 }
6292
6293 static bfd_byte *
6294 restfpr (bfd *abfd, bfd_byte *p, int r)
6295 {
6296 bfd_put_32 (abfd, LFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6297 return p + 4;
6298 }
6299
6300 static bfd_byte *
6301 restfpr0_tail (bfd *abfd, bfd_byte *p, int r)
6302 {
6303 bfd_put_32 (abfd, LD_R0_0R1 + 16, p);
6304 p = p + 4;
6305 p = restfpr (abfd, p, r);
6306 bfd_put_32 (abfd, MTLR_R0, p);
6307 p = p + 4;
6308 if (r == 29)
6309 {
6310 p = restfpr (abfd, p, 30);
6311 p = restfpr (abfd, p, 31);
6312 }
6313 bfd_put_32 (abfd, BLR, p);
6314 return p + 4;
6315 }
6316
6317 static bfd_byte *
6318 savefpr1_tail (bfd *abfd, bfd_byte *p, int r)
6319 {
6320 p = savefpr (abfd, p, r);
6321 bfd_put_32 (abfd, BLR, p);
6322 return p + 4;
6323 }
6324
6325 static bfd_byte *
6326 restfpr1_tail (bfd *abfd, bfd_byte *p, int r)
6327 {
6328 p = restfpr (abfd, p, r);
6329 bfd_put_32 (abfd, BLR, p);
6330 return p + 4;
6331 }
6332
6333 static bfd_byte *
6334 savevr (bfd *abfd, bfd_byte *p, int r)
6335 {
6336 bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6337 p = p + 4;
6338 bfd_put_32 (abfd, STVX_VR0_R12_R0 + (r << 21), p);
6339 return p + 4;
6340 }
6341
6342 static bfd_byte *
6343 savevr_tail (bfd *abfd, bfd_byte *p, int r)
6344 {
6345 p = savevr (abfd, p, r);
6346 bfd_put_32 (abfd, BLR, p);
6347 return p + 4;
6348 }
6349
6350 static bfd_byte *
6351 restvr (bfd *abfd, bfd_byte *p, int r)
6352 {
6353 bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6354 p = p + 4;
6355 bfd_put_32 (abfd, LVX_VR0_R12_R0 + (r << 21), p);
6356 return p + 4;
6357 }
6358
6359 static bfd_byte *
6360 restvr_tail (bfd *abfd, bfd_byte *p, int r)
6361 {
6362 p = restvr (abfd, p, r);
6363 bfd_put_32 (abfd, BLR, p);
6364 return p + 4;
6365 }
6366
6367 /* Called via elf_link_hash_traverse to transfer dynamic linking
6368 information on function code symbol entries to their corresponding
6369 function descriptor symbol entries. */
6370
6371 static bfd_boolean
6372 func_desc_adjust (struct elf_link_hash_entry *h, void *inf)
6373 {
6374 struct bfd_link_info *info;
6375 struct ppc_link_hash_table *htab;
6376 struct plt_entry *ent;
6377 struct ppc_link_hash_entry *fh;
6378 struct ppc_link_hash_entry *fdh;
6379 bfd_boolean force_local;
6380
6381 fh = (struct ppc_link_hash_entry *) h;
6382 if (fh->elf.root.type == bfd_link_hash_indirect)
6383 return TRUE;
6384
6385 info = inf;
6386 htab = ppc_hash_table (info);
6387 if (htab == NULL)
6388 return FALSE;
6389
6390 /* Resolve undefined references to dot-symbols as the value
6391 in the function descriptor, if we have one in a regular object.
6392 This is to satisfy cases like ".quad .foo". Calls to functions
6393 in dynamic objects are handled elsewhere. */
6394 if (fh->elf.root.type == bfd_link_hash_undefweak
6395 && fh->was_undefined
6396 && (fdh = defined_func_desc (fh)) != NULL
6397 && get_opd_info (fdh->elf.root.u.def.section) != NULL
6398 && opd_entry_value (fdh->elf.root.u.def.section,
6399 fdh->elf.root.u.def.value,
6400 &fh->elf.root.u.def.section,
6401 &fh->elf.root.u.def.value, FALSE) != (bfd_vma) -1)
6402 {
6403 fh->elf.root.type = fdh->elf.root.type;
6404 fh->elf.forced_local = 1;
6405 fh->elf.def_regular = fdh->elf.def_regular;
6406 fh->elf.def_dynamic = fdh->elf.def_dynamic;
6407 }
6408
6409 /* If this is a function code symbol, transfer dynamic linking
6410 information to the function descriptor symbol. */
6411 if (!fh->is_func)
6412 return TRUE;
6413
6414 for (ent = fh->elf.plt.plist; ent != NULL; ent = ent->next)
6415 if (ent->plt.refcount > 0)
6416 break;
6417 if (ent == NULL
6418 || fh->elf.root.root.string[0] != '.'
6419 || fh->elf.root.root.string[1] == '\0')
6420 return TRUE;
6421
6422 /* Find the corresponding function descriptor symbol. Create it
6423 as undefined if necessary. */
6424
6425 fdh = lookup_fdh (fh, htab);
6426 if (fdh == NULL
6427 && !info->executable
6428 && (fh->elf.root.type == bfd_link_hash_undefined
6429 || fh->elf.root.type == bfd_link_hash_undefweak))
6430 {
6431 fdh = make_fdh (info, fh);
6432 if (fdh == NULL)
6433 return FALSE;
6434 }
6435
6436 /* Fake function descriptors are made undefweak. If the function
6437 code symbol is strong undefined, make the fake sym the same.
6438 If the function code symbol is defined, then force the fake
6439 descriptor local; We can't support overriding of symbols in a
6440 shared library on a fake descriptor. */
6441
6442 if (fdh != NULL
6443 && fdh->fake
6444 && fdh->elf.root.type == bfd_link_hash_undefweak)
6445 {
6446 if (fh->elf.root.type == bfd_link_hash_undefined)
6447 {
6448 fdh->elf.root.type = bfd_link_hash_undefined;
6449 bfd_link_add_undef (&htab->elf.root, &fdh->elf.root);
6450 }
6451 else if (fh->elf.root.type == bfd_link_hash_defined
6452 || fh->elf.root.type == bfd_link_hash_defweak)
6453 {
6454 _bfd_elf_link_hash_hide_symbol (info, &fdh->elf, TRUE);
6455 }
6456 }
6457
6458 if (fdh != NULL
6459 && !fdh->elf.forced_local
6460 && (!info->executable
6461 || fdh->elf.def_dynamic
6462 || fdh->elf.ref_dynamic
6463 || (fdh->elf.root.type == bfd_link_hash_undefweak
6464 && ELF_ST_VISIBILITY (fdh->elf.other) == STV_DEFAULT)))
6465 {
6466 if (fdh->elf.dynindx == -1)
6467 if (! bfd_elf_link_record_dynamic_symbol (info, &fdh->elf))
6468 return FALSE;
6469 fdh->elf.ref_regular |= fh->elf.ref_regular;
6470 fdh->elf.ref_dynamic |= fh->elf.ref_dynamic;
6471 fdh->elf.ref_regular_nonweak |= fh->elf.ref_regular_nonweak;
6472 fdh->elf.non_got_ref |= fh->elf.non_got_ref;
6473 if (ELF_ST_VISIBILITY (fh->elf.other) == STV_DEFAULT)
6474 {
6475 move_plt_plist (fh, fdh);
6476 fdh->elf.needs_plt = 1;
6477 }
6478 fdh->is_func_descriptor = 1;
6479 fdh->oh = fh;
6480 fh->oh = fdh;
6481 }
6482
6483 /* Now that the info is on the function descriptor, clear the
6484 function code sym info. Any function code syms for which we
6485 don't have a definition in a regular file, we force local.
6486 This prevents a shared library from exporting syms that have
6487 been imported from another library. Function code syms that
6488 are really in the library we must leave global to prevent the
6489 linker dragging in a definition from a static library. */
6490 force_local = (!fh->elf.def_regular
6491 || fdh == NULL
6492 || !fdh->elf.def_regular
6493 || fdh->elf.forced_local);
6494 _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
6495
6496 return TRUE;
6497 }
6498
6499 /* Called near the start of bfd_elf_size_dynamic_sections. We use
6500 this hook to a) provide some gcc support functions, and b) transfer
6501 dynamic linking information gathered so far on function code symbol
6502 entries, to their corresponding function descriptor symbol entries. */
6503
6504 static bfd_boolean
6505 ppc64_elf_func_desc_adjust (bfd *obfd ATTRIBUTE_UNUSED,
6506 struct bfd_link_info *info)
6507 {
6508 struct ppc_link_hash_table *htab;
6509 unsigned int i;
6510 static const struct sfpr_def_parms funcs[] =
6511 {
6512 { "_savegpr0_", 14, 31, savegpr0, savegpr0_tail },
6513 { "_restgpr0_", 14, 29, restgpr0, restgpr0_tail },
6514 { "_restgpr0_", 30, 31, restgpr0, restgpr0_tail },
6515 { "_savegpr1_", 14, 31, savegpr1, savegpr1_tail },
6516 { "_restgpr1_", 14, 31, restgpr1, restgpr1_tail },
6517 { "_savefpr_", 14, 31, savefpr, savefpr0_tail },
6518 { "_restfpr_", 14, 29, restfpr, restfpr0_tail },
6519 { "_restfpr_", 30, 31, restfpr, restfpr0_tail },
6520 { "._savef", 14, 31, savefpr, savefpr1_tail },
6521 { "._restf", 14, 31, restfpr, restfpr1_tail },
6522 { "_savevr_", 20, 31, savevr, savevr_tail },
6523 { "_restvr_", 20, 31, restvr, restvr_tail }
6524 };
6525
6526 htab = ppc_hash_table (info);
6527 if (htab == NULL)
6528 return FALSE;
6529
6530 if (htab->sfpr == NULL)
6531 /* We don't have any relocs. */
6532 return TRUE;
6533
6534 /* Provide any missing _save* and _rest* functions. */
6535 htab->sfpr->size = 0;
6536 if (!info->relocatable)
6537 for (i = 0; i < sizeof (funcs) / sizeof (funcs[0]); i++)
6538 if (!sfpr_define (info, &funcs[i]))
6539 return FALSE;
6540
6541 elf_link_hash_traverse (&htab->elf, func_desc_adjust, info);
6542
6543 if (htab->sfpr->size == 0)
6544 htab->sfpr->flags |= SEC_EXCLUDE;
6545
6546 return TRUE;
6547 }
6548
6549 /* Adjust a symbol defined by a dynamic object and referenced by a
6550 regular object. The current definition is in some section of the
6551 dynamic object, but we're not including those sections. We have to
6552 change the definition to something the rest of the link can
6553 understand. */
6554
6555 static bfd_boolean
6556 ppc64_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
6557 struct elf_link_hash_entry *h)
6558 {
6559 struct ppc_link_hash_table *htab;
6560 asection *s;
6561
6562 htab = ppc_hash_table (info);
6563 if (htab == NULL)
6564 return FALSE;
6565
6566 /* Deal with function syms. */
6567 if (h->type == STT_FUNC
6568 || h->type == STT_GNU_IFUNC
6569 || h->needs_plt)
6570 {
6571 /* Clear procedure linkage table information for any symbol that
6572 won't need a .plt entry. */
6573 struct plt_entry *ent;
6574 for (ent = h->plt.plist; ent != NULL; ent = ent->next)
6575 if (ent->plt.refcount > 0)
6576 break;
6577 if (ent == NULL
6578 || (h->type != STT_GNU_IFUNC
6579 && (SYMBOL_CALLS_LOCAL (info, h)
6580 || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
6581 && h->root.type == bfd_link_hash_undefweak))))
6582 {
6583 h->plt.plist = NULL;
6584 h->needs_plt = 0;
6585 }
6586 }
6587 else
6588 h->plt.plist = NULL;
6589
6590 /* If this is a weak symbol, and there is a real definition, the
6591 processor independent code will have arranged for us to see the
6592 real definition first, and we can just use the same value. */
6593 if (h->u.weakdef != NULL)
6594 {
6595 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
6596 || h->u.weakdef->root.type == bfd_link_hash_defweak);
6597 h->root.u.def.section = h->u.weakdef->root.u.def.section;
6598 h->root.u.def.value = h->u.weakdef->root.u.def.value;
6599 if (ELIMINATE_COPY_RELOCS)
6600 h->non_got_ref = h->u.weakdef->non_got_ref;
6601 return TRUE;
6602 }
6603
6604 /* If we are creating a shared library, we must presume that the
6605 only references to the symbol are via the global offset table.
6606 For such cases we need not do anything here; the relocations will
6607 be handled correctly by relocate_section. */
6608 if (info->shared)
6609 return TRUE;
6610
6611 /* If there are no references to this symbol that do not use the
6612 GOT, we don't need to generate a copy reloc. */
6613 if (!h->non_got_ref)
6614 return TRUE;
6615
6616 /* Don't generate a copy reloc for symbols defined in the executable. */
6617 if (!h->def_dynamic || !h->ref_regular || h->def_regular)
6618 return TRUE;
6619
6620 if (ELIMINATE_COPY_RELOCS)
6621 {
6622 struct ppc_link_hash_entry * eh;
6623 struct elf_dyn_relocs *p;
6624
6625 eh = (struct ppc_link_hash_entry *) h;
6626 for (p = eh->dyn_relocs; p != NULL; p = p->next)
6627 {
6628 s = p->sec->output_section;
6629 if (s != NULL && (s->flags & SEC_READONLY) != 0)
6630 break;
6631 }
6632
6633 /* If we didn't find any dynamic relocs in read-only sections, then
6634 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
6635 if (p == NULL)
6636 {
6637 h->non_got_ref = 0;
6638 return TRUE;
6639 }
6640 }
6641
6642 if (h->plt.plist != NULL)
6643 {
6644 /* We should never get here, but unfortunately there are versions
6645 of gcc out there that improperly (for this ABI) put initialized
6646 function pointers, vtable refs and suchlike in read-only
6647 sections. Allow them to proceed, but warn that this might
6648 break at runtime. */
6649 info->callbacks->einfo
6650 (_("%P: copy reloc against `%T' requires lazy plt linking; "
6651 "avoid setting LD_BIND_NOW=1 or upgrade gcc\n"),
6652 h->root.root.string);
6653 }
6654
6655 /* This is a reference to a symbol defined by a dynamic object which
6656 is not a function. */
6657
6658 /* We must allocate the symbol in our .dynbss section, which will
6659 become part of the .bss section of the executable. There will be
6660 an entry for this symbol in the .dynsym section. The dynamic
6661 object will contain position independent code, so all references
6662 from the dynamic object to this symbol will go through the global
6663 offset table. The dynamic linker will use the .dynsym entry to
6664 determine the address it must put in the global offset table, so
6665 both the dynamic object and the regular object will refer to the
6666 same memory location for the variable. */
6667
6668 /* We must generate a R_PPC64_COPY reloc to tell the dynamic linker
6669 to copy the initial value out of the dynamic object and into the
6670 runtime process image. We need to remember the offset into the
6671 .rela.bss section we are going to use. */
6672 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
6673 {
6674 htab->relbss->size += sizeof (Elf64_External_Rela);
6675 h->needs_copy = 1;
6676 }
6677
6678 s = htab->dynbss;
6679
6680 return _bfd_elf_adjust_dynamic_copy (h, s);
6681 }
6682
6683 /* If given a function descriptor symbol, hide both the function code
6684 sym and the descriptor. */
6685 static void
6686 ppc64_elf_hide_symbol (struct bfd_link_info *info,
6687 struct elf_link_hash_entry *h,
6688 bfd_boolean force_local)
6689 {
6690 struct ppc_link_hash_entry *eh;
6691 _bfd_elf_link_hash_hide_symbol (info, h, force_local);
6692
6693 eh = (struct ppc_link_hash_entry *) h;
6694 if (eh->is_func_descriptor)
6695 {
6696 struct ppc_link_hash_entry *fh = eh->oh;
6697
6698 if (fh == NULL)
6699 {
6700 const char *p, *q;
6701 struct ppc_link_hash_table *htab;
6702 char save;
6703
6704 /* We aren't supposed to use alloca in BFD because on
6705 systems which do not have alloca the version in libiberty
6706 calls xmalloc, which might cause the program to crash
6707 when it runs out of memory. This function doesn't have a
6708 return status, so there's no way to gracefully return an
6709 error. So cheat. We know that string[-1] can be safely
6710 accessed; It's either a string in an ELF string table,
6711 or allocated in an objalloc structure. */
6712
6713 p = eh->elf.root.root.string - 1;
6714 save = *p;
6715 *(char *) p = '.';
6716 htab = ppc_hash_table (info);
6717 if (htab == NULL)
6718 return;
6719
6720 fh = (struct ppc_link_hash_entry *)
6721 elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
6722 *(char *) p = save;
6723
6724 /* Unfortunately, if it so happens that the string we were
6725 looking for was allocated immediately before this string,
6726 then we overwrote the string terminator. That's the only
6727 reason the lookup should fail. */
6728 if (fh == NULL)
6729 {
6730 q = eh->elf.root.root.string + strlen (eh->elf.root.root.string);
6731 while (q >= eh->elf.root.root.string && *q == *p)
6732 --q, --p;
6733 if (q < eh->elf.root.root.string && *p == '.')
6734 fh = (struct ppc_link_hash_entry *)
6735 elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
6736 }
6737 if (fh != NULL)
6738 {
6739 eh->oh = fh;
6740 fh->oh = eh;
6741 }
6742 }
6743 if (fh != NULL)
6744 _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
6745 }
6746 }
6747
6748 static bfd_boolean
6749 get_sym_h (struct elf_link_hash_entry **hp,
6750 Elf_Internal_Sym **symp,
6751 asection **symsecp,
6752 unsigned char **tls_maskp,
6753 Elf_Internal_Sym **locsymsp,
6754 unsigned long r_symndx,
6755 bfd *ibfd)
6756 {
6757 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
6758
6759 if (r_symndx >= symtab_hdr->sh_info)
6760 {
6761 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
6762 struct elf_link_hash_entry *h;
6763
6764 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
6765 h = elf_follow_link (h);
6766
6767 if (hp != NULL)
6768 *hp = h;
6769
6770 if (symp != NULL)
6771 *symp = NULL;
6772
6773 if (symsecp != NULL)
6774 {
6775 asection *symsec = NULL;
6776 if (h->root.type == bfd_link_hash_defined
6777 || h->root.type == bfd_link_hash_defweak)
6778 symsec = h->root.u.def.section;
6779 *symsecp = symsec;
6780 }
6781
6782 if (tls_maskp != NULL)
6783 {
6784 struct ppc_link_hash_entry *eh;
6785
6786 eh = (struct ppc_link_hash_entry *) h;
6787 *tls_maskp = &eh->tls_mask;
6788 }
6789 }
6790 else
6791 {
6792 Elf_Internal_Sym *sym;
6793 Elf_Internal_Sym *locsyms = *locsymsp;
6794
6795 if (locsyms == NULL)
6796 {
6797 locsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
6798 if (locsyms == NULL)
6799 locsyms = bfd_elf_get_elf_syms (ibfd, symtab_hdr,
6800 symtab_hdr->sh_info,
6801 0, NULL, NULL, NULL);
6802 if (locsyms == NULL)
6803 return FALSE;
6804 *locsymsp = locsyms;
6805 }
6806 sym = locsyms + r_symndx;
6807
6808 if (hp != NULL)
6809 *hp = NULL;
6810
6811 if (symp != NULL)
6812 *symp = sym;
6813
6814 if (symsecp != NULL)
6815 *symsecp = bfd_section_from_elf_index (ibfd, sym->st_shndx);
6816
6817 if (tls_maskp != NULL)
6818 {
6819 struct got_entry **lgot_ents;
6820 unsigned char *tls_mask;
6821
6822 tls_mask = NULL;
6823 lgot_ents = elf_local_got_ents (ibfd);
6824 if (lgot_ents != NULL)
6825 {
6826 struct plt_entry **local_plt = (struct plt_entry **)
6827 (lgot_ents + symtab_hdr->sh_info);
6828 unsigned char *lgot_masks = (unsigned char *)
6829 (local_plt + symtab_hdr->sh_info);
6830 tls_mask = &lgot_masks[r_symndx];
6831 }
6832 *tls_maskp = tls_mask;
6833 }
6834 }
6835 return TRUE;
6836 }
6837
6838 /* Returns TLS_MASKP for the given REL symbol. Function return is 0 on
6839 error, 2 on a toc GD type suitable for optimization, 3 on a toc LD
6840 type suitable for optimization, and 1 otherwise. */
6841
6842 static int
6843 get_tls_mask (unsigned char **tls_maskp,
6844 unsigned long *toc_symndx,
6845 bfd_vma *toc_addend,
6846 Elf_Internal_Sym **locsymsp,
6847 const Elf_Internal_Rela *rel,
6848 bfd *ibfd)
6849 {
6850 unsigned long r_symndx;
6851 int next_r;
6852 struct elf_link_hash_entry *h;
6853 Elf_Internal_Sym *sym;
6854 asection *sec;
6855 bfd_vma off;
6856
6857 r_symndx = ELF64_R_SYM (rel->r_info);
6858 if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
6859 return 0;
6860
6861 if ((*tls_maskp != NULL && **tls_maskp != 0)
6862 || sec == NULL
6863 || ppc64_elf_section_data (sec) == NULL
6864 || ppc64_elf_section_data (sec)->sec_type != sec_toc)
6865 return 1;
6866
6867 /* Look inside a TOC section too. */
6868 if (h != NULL)
6869 {
6870 BFD_ASSERT (h->root.type == bfd_link_hash_defined);
6871 off = h->root.u.def.value;
6872 }
6873 else
6874 off = sym->st_value;
6875 off += rel->r_addend;
6876 BFD_ASSERT (off % 8 == 0);
6877 r_symndx = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8];
6878 next_r = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8 + 1];
6879 if (toc_symndx != NULL)
6880 *toc_symndx = r_symndx;
6881 if (toc_addend != NULL)
6882 *toc_addend = ppc64_elf_section_data (sec)->u.toc.add[off / 8];
6883 if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
6884 return 0;
6885 if ((h == NULL || is_static_defined (h))
6886 && (next_r == -1 || next_r == -2))
6887 return 1 - next_r;
6888 return 1;
6889 }
6890
6891 /* Find (or create) an entry in the tocsave hash table. */
6892
6893 static struct tocsave_entry *
6894 tocsave_find (struct ppc_link_hash_table *htab,
6895 enum insert_option insert,
6896 Elf_Internal_Sym **local_syms,
6897 const Elf_Internal_Rela *irela,
6898 bfd *ibfd)
6899 {
6900 unsigned long r_indx;
6901 struct elf_link_hash_entry *h;
6902 Elf_Internal_Sym *sym;
6903 struct tocsave_entry ent, *p;
6904 hashval_t hash;
6905 struct tocsave_entry **slot;
6906
6907 r_indx = ELF64_R_SYM (irela->r_info);
6908 if (!get_sym_h (&h, &sym, &ent.sec, NULL, local_syms, r_indx, ibfd))
6909 return NULL;
6910 if (ent.sec == NULL || ent.sec->output_section == NULL)
6911 {
6912 (*_bfd_error_handler)
6913 (_("%B: undefined symbol on R_PPC64_TOCSAVE relocation"));
6914 return NULL;
6915 }
6916
6917 if (h != NULL)
6918 ent.offset = h->root.u.def.value;
6919 else
6920 ent.offset = sym->st_value;
6921 ent.offset += irela->r_addend;
6922
6923 hash = tocsave_htab_hash (&ent);
6924 slot = ((struct tocsave_entry **)
6925 htab_find_slot_with_hash (htab->tocsave_htab, &ent, hash, insert));
6926 if (slot == NULL)
6927 return NULL;
6928
6929 if (*slot == NULL)
6930 {
6931 p = (struct tocsave_entry *) bfd_alloc (ibfd, sizeof (*p));
6932 if (p == NULL)
6933 return NULL;
6934 *p = ent;
6935 *slot = p;
6936 }
6937 return *slot;
6938 }
6939
6940 /* Adjust all global syms defined in opd sections. In gcc generated
6941 code for the old ABI, these will already have been done. */
6942
6943 static bfd_boolean
6944 adjust_opd_syms (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
6945 {
6946 struct ppc_link_hash_entry *eh;
6947 asection *sym_sec;
6948 struct _opd_sec_data *opd;
6949
6950 if (h->root.type == bfd_link_hash_indirect)
6951 return TRUE;
6952
6953 if (h->root.type != bfd_link_hash_defined
6954 && h->root.type != bfd_link_hash_defweak)
6955 return TRUE;
6956
6957 eh = (struct ppc_link_hash_entry *) h;
6958 if (eh->adjust_done)
6959 return TRUE;
6960
6961 sym_sec = eh->elf.root.u.def.section;
6962 opd = get_opd_info (sym_sec);
6963 if (opd != NULL && opd->adjust != NULL)
6964 {
6965 long adjust = opd->adjust[eh->elf.root.u.def.value / 8];
6966 if (adjust == -1)
6967 {
6968 /* This entry has been deleted. */
6969 asection *dsec = ppc64_elf_tdata (sym_sec->owner)->deleted_section;
6970 if (dsec == NULL)
6971 {
6972 for (dsec = sym_sec->owner->sections; dsec; dsec = dsec->next)
6973 if (discarded_section (dsec))
6974 {
6975 ppc64_elf_tdata (sym_sec->owner)->deleted_section = dsec;
6976 break;
6977 }
6978 }
6979 eh->elf.root.u.def.value = 0;
6980 eh->elf.root.u.def.section = dsec;
6981 }
6982 else
6983 eh->elf.root.u.def.value += adjust;
6984 eh->adjust_done = 1;
6985 }
6986 return TRUE;
6987 }
6988
6989 /* Handles decrementing dynamic reloc counts for the reloc specified by
6990 R_INFO in section SEC. If LOCAL_SYMS is NULL, then H and SYM
6991 have already been determined. */
6992
6993 static bfd_boolean
6994 dec_dynrel_count (bfd_vma r_info,
6995 asection *sec,
6996 struct bfd_link_info *info,
6997 Elf_Internal_Sym **local_syms,
6998 struct elf_link_hash_entry *h,
6999 Elf_Internal_Sym *sym)
7000 {
7001 enum elf_ppc64_reloc_type r_type;
7002 asection *sym_sec = NULL;
7003
7004 /* Can this reloc be dynamic? This switch, and later tests here
7005 should be kept in sync with the code in check_relocs. */
7006 r_type = ELF64_R_TYPE (r_info);
7007 switch (r_type)
7008 {
7009 default:
7010 return TRUE;
7011
7012 case R_PPC64_TPREL16:
7013 case R_PPC64_TPREL16_LO:
7014 case R_PPC64_TPREL16_HI:
7015 case R_PPC64_TPREL16_HA:
7016 case R_PPC64_TPREL16_DS:
7017 case R_PPC64_TPREL16_LO_DS:
7018 case R_PPC64_TPREL16_HIGHER:
7019 case R_PPC64_TPREL16_HIGHERA:
7020 case R_PPC64_TPREL16_HIGHEST:
7021 case R_PPC64_TPREL16_HIGHESTA:
7022 if (!info->shared)
7023 return TRUE;
7024
7025 case R_PPC64_TPREL64:
7026 case R_PPC64_DTPMOD64:
7027 case R_PPC64_DTPREL64:
7028 case R_PPC64_ADDR64:
7029 case R_PPC64_REL30:
7030 case R_PPC64_REL32:
7031 case R_PPC64_REL64:
7032 case R_PPC64_ADDR14:
7033 case R_PPC64_ADDR14_BRNTAKEN:
7034 case R_PPC64_ADDR14_BRTAKEN:
7035 case R_PPC64_ADDR16:
7036 case R_PPC64_ADDR16_DS:
7037 case R_PPC64_ADDR16_HA:
7038 case R_PPC64_ADDR16_HI:
7039 case R_PPC64_ADDR16_HIGHER:
7040 case R_PPC64_ADDR16_HIGHERA:
7041 case R_PPC64_ADDR16_HIGHEST:
7042 case R_PPC64_ADDR16_HIGHESTA:
7043 case R_PPC64_ADDR16_LO:
7044 case R_PPC64_ADDR16_LO_DS:
7045 case R_PPC64_ADDR24:
7046 case R_PPC64_ADDR32:
7047 case R_PPC64_UADDR16:
7048 case R_PPC64_UADDR32:
7049 case R_PPC64_UADDR64:
7050 case R_PPC64_TOC:
7051 break;
7052 }
7053
7054 if (local_syms != NULL)
7055 {
7056 unsigned long r_symndx;
7057 bfd *ibfd = sec->owner;
7058
7059 r_symndx = ELF64_R_SYM (r_info);
7060 if (!get_sym_h (&h, &sym, &sym_sec, NULL, local_syms, r_symndx, ibfd))
7061 return FALSE;
7062 }
7063
7064 if ((info->shared
7065 && (must_be_dyn_reloc (info, r_type)
7066 || (h != NULL
7067 && (!SYMBOLIC_BIND (info, h)
7068 || h->root.type == bfd_link_hash_defweak
7069 || !h->def_regular))))
7070 || (ELIMINATE_COPY_RELOCS
7071 && !info->shared
7072 && h != NULL
7073 && (h->root.type == bfd_link_hash_defweak
7074 || !h->def_regular)))
7075 ;
7076 else
7077 return TRUE;
7078
7079 if (h != NULL)
7080 {
7081 struct elf_dyn_relocs *p;
7082 struct elf_dyn_relocs **pp;
7083 pp = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
7084
7085 /* elf_gc_sweep may have already removed all dyn relocs associated
7086 with local syms for a given section. Also, symbol flags are
7087 changed by elf_gc_sweep_symbol, confusing the test above. Don't
7088 report a dynreloc miscount. */
7089 if (*pp == NULL && info->gc_sections)
7090 return TRUE;
7091
7092 while ((p = *pp) != NULL)
7093 {
7094 if (p->sec == sec)
7095 {
7096 if (!must_be_dyn_reloc (info, r_type))
7097 p->pc_count -= 1;
7098 p->count -= 1;
7099 if (p->count == 0)
7100 *pp = p->next;
7101 return TRUE;
7102 }
7103 pp = &p->next;
7104 }
7105 }
7106 else
7107 {
7108 struct ppc_dyn_relocs *p;
7109 struct ppc_dyn_relocs **pp;
7110 void *vpp;
7111 bfd_boolean is_ifunc;
7112
7113 if (local_syms == NULL)
7114 sym_sec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
7115 if (sym_sec == NULL)
7116 sym_sec = sec;
7117
7118 vpp = &elf_section_data (sym_sec)->local_dynrel;
7119 pp = (struct ppc_dyn_relocs **) vpp;
7120
7121 if (*pp == NULL && info->gc_sections)
7122 return TRUE;
7123
7124 is_ifunc = ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC;
7125 while ((p = *pp) != NULL)
7126 {
7127 if (p->sec == sec && p->ifunc == is_ifunc)
7128 {
7129 p->count -= 1;
7130 if (p->count == 0)
7131 *pp = p->next;
7132 return TRUE;
7133 }
7134 pp = &p->next;
7135 }
7136 }
7137
7138 info->callbacks->einfo (_("%P: dynreloc miscount for %B, section %A\n"),
7139 sec->owner, sec);
7140 bfd_set_error (bfd_error_bad_value);
7141 return FALSE;
7142 }
7143
7144 /* Remove unused Official Procedure Descriptor entries. Currently we
7145 only remove those associated with functions in discarded link-once
7146 sections, or weakly defined functions that have been overridden. It
7147 would be possible to remove many more entries for statically linked
7148 applications. */
7149
7150 bfd_boolean
7151 ppc64_elf_edit_opd (struct bfd_link_info *info, bfd_boolean non_overlapping)
7152 {
7153 bfd *ibfd;
7154 bfd_boolean some_edited = FALSE;
7155 asection *need_pad = NULL;
7156
7157 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
7158 {
7159 asection *sec;
7160 Elf_Internal_Rela *relstart, *rel, *relend;
7161 Elf_Internal_Shdr *symtab_hdr;
7162 Elf_Internal_Sym *local_syms;
7163 bfd_vma offset;
7164 struct _opd_sec_data *opd;
7165 bfd_boolean need_edit, add_aux_fields;
7166 bfd_size_type cnt_16b = 0;
7167
7168 if (!is_ppc64_elf (ibfd))
7169 continue;
7170
7171 sec = bfd_get_section_by_name (ibfd, ".opd");
7172 if (sec == NULL || sec->size == 0)
7173 continue;
7174
7175 if (sec->sec_info_type == SEC_INFO_TYPE_JUST_SYMS)
7176 continue;
7177
7178 if (sec->output_section == bfd_abs_section_ptr)
7179 continue;
7180
7181 /* Look through the section relocs. */
7182 if ((sec->flags & SEC_RELOC) == 0 || sec->reloc_count == 0)
7183 continue;
7184
7185 local_syms = NULL;
7186 symtab_hdr = &elf_symtab_hdr (ibfd);
7187
7188 /* Read the relocations. */
7189 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
7190 info->keep_memory);
7191 if (relstart == NULL)
7192 return FALSE;
7193
7194 /* First run through the relocs to check they are sane, and to
7195 determine whether we need to edit this opd section. */
7196 need_edit = FALSE;
7197 need_pad = sec;
7198 offset = 0;
7199 relend = relstart + sec->reloc_count;
7200 for (rel = relstart; rel < relend; )
7201 {
7202 enum elf_ppc64_reloc_type r_type;
7203 unsigned long r_symndx;
7204 asection *sym_sec;
7205 struct elf_link_hash_entry *h;
7206 Elf_Internal_Sym *sym;
7207
7208 /* .opd contains a regular array of 16 or 24 byte entries. We're
7209 only interested in the reloc pointing to a function entry
7210 point. */
7211 if (rel->r_offset != offset
7212 || rel + 1 >= relend
7213 || (rel + 1)->r_offset != offset + 8)
7214 {
7215 /* If someone messes with .opd alignment then after a
7216 "ld -r" we might have padding in the middle of .opd.
7217 Also, there's nothing to prevent someone putting
7218 something silly in .opd with the assembler. No .opd
7219 optimization for them! */
7220 broken_opd:
7221 (*_bfd_error_handler)
7222 (_("%B: .opd is not a regular array of opd entries"), ibfd);
7223 need_edit = FALSE;
7224 break;
7225 }
7226
7227 if ((r_type = ELF64_R_TYPE (rel->r_info)) != R_PPC64_ADDR64
7228 || (r_type = ELF64_R_TYPE ((rel + 1)->r_info)) != R_PPC64_TOC)
7229 {
7230 (*_bfd_error_handler)
7231 (_("%B: unexpected reloc type %u in .opd section"),
7232 ibfd, r_type);
7233 need_edit = FALSE;
7234 break;
7235 }
7236
7237 r_symndx = ELF64_R_SYM (rel->r_info);
7238 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7239 r_symndx, ibfd))
7240 goto error_ret;
7241
7242 if (sym_sec == NULL || sym_sec->owner == NULL)
7243 {
7244 const char *sym_name;
7245 if (h != NULL)
7246 sym_name = h->root.root.string;
7247 else
7248 sym_name = bfd_elf_sym_name (ibfd, symtab_hdr, sym,
7249 sym_sec);
7250
7251 (*_bfd_error_handler)
7252 (_("%B: undefined sym `%s' in .opd section"),
7253 ibfd, sym_name);
7254 need_edit = FALSE;
7255 break;
7256 }
7257
7258 /* opd entries are always for functions defined in the
7259 current input bfd. If the symbol isn't defined in the
7260 input bfd, then we won't be using the function in this
7261 bfd; It must be defined in a linkonce section in another
7262 bfd, or is weak. It's also possible that we are
7263 discarding the function due to a linker script /DISCARD/,
7264 which we test for via the output_section. */
7265 if (sym_sec->owner != ibfd
7266 || sym_sec->output_section == bfd_abs_section_ptr)
7267 need_edit = TRUE;
7268
7269 rel += 2;
7270 if (rel == relend
7271 || (rel + 1 == relend && rel->r_offset == offset + 16))
7272 {
7273 if (sec->size == offset + 24)
7274 {
7275 need_pad = NULL;
7276 break;
7277 }
7278 if (rel == relend && sec->size == offset + 16)
7279 {
7280 cnt_16b++;
7281 break;
7282 }
7283 goto broken_opd;
7284 }
7285
7286 if (rel->r_offset == offset + 24)
7287 offset += 24;
7288 else if (rel->r_offset != offset + 16)
7289 goto broken_opd;
7290 else if (rel + 1 < relend
7291 && ELF64_R_TYPE (rel[0].r_info) == R_PPC64_ADDR64
7292 && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOC)
7293 {
7294 offset += 16;
7295 cnt_16b++;
7296 }
7297 else if (rel + 2 < relend
7298 && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_ADDR64
7299 && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_TOC)
7300 {
7301 offset += 24;
7302 rel += 1;
7303 }
7304 else
7305 goto broken_opd;
7306 }
7307
7308 add_aux_fields = non_overlapping && cnt_16b > 0;
7309
7310 if (need_edit || add_aux_fields)
7311 {
7312 Elf_Internal_Rela *write_rel;
7313 Elf_Internal_Shdr *rel_hdr;
7314 bfd_byte *rptr, *wptr;
7315 bfd_byte *new_contents;
7316 bfd_boolean skip;
7317 long opd_ent_size;
7318 bfd_size_type amt;
7319
7320 new_contents = NULL;
7321 amt = sec->size * sizeof (long) / 8;
7322 opd = &ppc64_elf_section_data (sec)->u.opd;
7323 opd->adjust = bfd_zalloc (sec->owner, amt);
7324 if (opd->adjust == NULL)
7325 return FALSE;
7326 ppc64_elf_section_data (sec)->sec_type = sec_opd;
7327
7328 /* This seems a waste of time as input .opd sections are all
7329 zeros as generated by gcc, but I suppose there's no reason
7330 this will always be so. We might start putting something in
7331 the third word of .opd entries. */
7332 if ((sec->flags & SEC_IN_MEMORY) == 0)
7333 {
7334 bfd_byte *loc;
7335 if (!bfd_malloc_and_get_section (ibfd, sec, &loc))
7336 {
7337 if (loc != NULL)
7338 free (loc);
7339 error_ret:
7340 if (local_syms != NULL
7341 && symtab_hdr->contents != (unsigned char *) local_syms)
7342 free (local_syms);
7343 if (elf_section_data (sec)->relocs != relstart)
7344 free (relstart);
7345 return FALSE;
7346 }
7347 sec->contents = loc;
7348 sec->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
7349 }
7350
7351 elf_section_data (sec)->relocs = relstart;
7352
7353 new_contents = sec->contents;
7354 if (add_aux_fields)
7355 {
7356 new_contents = bfd_malloc (sec->size + cnt_16b * 8);
7357 if (new_contents == NULL)
7358 return FALSE;
7359 need_pad = FALSE;
7360 }
7361 wptr = new_contents;
7362 rptr = sec->contents;
7363
7364 write_rel = relstart;
7365 skip = FALSE;
7366 offset = 0;
7367 opd_ent_size = 0;
7368 for (rel = relstart; rel < relend; rel++)
7369 {
7370 unsigned long r_symndx;
7371 asection *sym_sec;
7372 struct elf_link_hash_entry *h;
7373 Elf_Internal_Sym *sym;
7374
7375 r_symndx = ELF64_R_SYM (rel->r_info);
7376 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7377 r_symndx, ibfd))
7378 goto error_ret;
7379
7380 if (rel->r_offset == offset)
7381 {
7382 struct ppc_link_hash_entry *fdh = NULL;
7383
7384 /* See if the .opd entry is full 24 byte or
7385 16 byte (with fd_aux entry overlapped with next
7386 fd_func). */
7387 opd_ent_size = 24;
7388 if ((rel + 2 == relend && sec->size == offset + 16)
7389 || (rel + 3 < relend
7390 && rel[2].r_offset == offset + 16
7391 && rel[3].r_offset == offset + 24
7392 && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_ADDR64
7393 && ELF64_R_TYPE (rel[3].r_info) == R_PPC64_TOC))
7394 opd_ent_size = 16;
7395
7396 if (h != NULL
7397 && h->root.root.string[0] == '.')
7398 {
7399 struct ppc_link_hash_table *htab;
7400
7401 htab = ppc_hash_table (info);
7402 if (htab != NULL)
7403 fdh = lookup_fdh ((struct ppc_link_hash_entry *) h,
7404 htab);
7405 if (fdh != NULL
7406 && fdh->elf.root.type != bfd_link_hash_defined
7407 && fdh->elf.root.type != bfd_link_hash_defweak)
7408 fdh = NULL;
7409 }
7410
7411 skip = (sym_sec->owner != ibfd
7412 || sym_sec->output_section == bfd_abs_section_ptr);
7413 if (skip)
7414 {
7415 if (fdh != NULL && sym_sec->owner == ibfd)
7416 {
7417 /* Arrange for the function descriptor sym
7418 to be dropped. */
7419 fdh->elf.root.u.def.value = 0;
7420 fdh->elf.root.u.def.section = sym_sec;
7421 }
7422 opd->adjust[rel->r_offset / 8] = -1;
7423 }
7424 else
7425 {
7426 /* We'll be keeping this opd entry. */
7427
7428 if (fdh != NULL)
7429 {
7430 /* Redefine the function descriptor symbol to
7431 this location in the opd section. It is
7432 necessary to update the value here rather
7433 than using an array of adjustments as we do
7434 for local symbols, because various places
7435 in the generic ELF code use the value
7436 stored in u.def.value. */
7437 fdh->elf.root.u.def.value = wptr - new_contents;
7438 fdh->adjust_done = 1;
7439 }
7440
7441 /* Local syms are a bit tricky. We could
7442 tweak them as they can be cached, but
7443 we'd need to look through the local syms
7444 for the function descriptor sym which we
7445 don't have at the moment. So keep an
7446 array of adjustments. */
7447 opd->adjust[rel->r_offset / 8]
7448 = (wptr - new_contents) - (rptr - sec->contents);
7449
7450 if (wptr != rptr)
7451 memcpy (wptr, rptr, opd_ent_size);
7452 wptr += opd_ent_size;
7453 if (add_aux_fields && opd_ent_size == 16)
7454 {
7455 memset (wptr, '\0', 8);
7456 wptr += 8;
7457 }
7458 }
7459 rptr += opd_ent_size;
7460 offset += opd_ent_size;
7461 }
7462
7463 if (skip)
7464 {
7465 if (!NO_OPD_RELOCS
7466 && !info->relocatable
7467 && !dec_dynrel_count (rel->r_info, sec, info,
7468 NULL, h, sym))
7469 goto error_ret;
7470 }
7471 else
7472 {
7473 /* We need to adjust any reloc offsets to point to the
7474 new opd entries. While we're at it, we may as well
7475 remove redundant relocs. */
7476 rel->r_offset += opd->adjust[(offset - opd_ent_size) / 8];
7477 if (write_rel != rel)
7478 memcpy (write_rel, rel, sizeof (*rel));
7479 ++write_rel;
7480 }
7481 }
7482
7483 sec->size = wptr - new_contents;
7484 sec->reloc_count = write_rel - relstart;
7485 if (add_aux_fields)
7486 {
7487 free (sec->contents);
7488 sec->contents = new_contents;
7489 }
7490
7491 /* Fudge the header size too, as this is used later in
7492 elf_bfd_final_link if we are emitting relocs. */
7493 rel_hdr = _bfd_elf_single_rel_hdr (sec);
7494 rel_hdr->sh_size = sec->reloc_count * rel_hdr->sh_entsize;
7495 some_edited = TRUE;
7496 }
7497 else if (elf_section_data (sec)->relocs != relstart)
7498 free (relstart);
7499
7500 if (local_syms != NULL
7501 && symtab_hdr->contents != (unsigned char *) local_syms)
7502 {
7503 if (!info->keep_memory)
7504 free (local_syms);
7505 else
7506 symtab_hdr->contents = (unsigned char *) local_syms;
7507 }
7508 }
7509
7510 if (some_edited)
7511 elf_link_hash_traverse (elf_hash_table (info), adjust_opd_syms, NULL);
7512
7513 /* If we are doing a final link and the last .opd entry is just 16 byte
7514 long, add a 8 byte padding after it. */
7515 if (need_pad != NULL && !info->relocatable)
7516 {
7517 bfd_byte *p;
7518
7519 if ((need_pad->flags & SEC_IN_MEMORY) == 0)
7520 {
7521 BFD_ASSERT (need_pad->size > 0);
7522
7523 p = bfd_malloc (need_pad->size + 8);
7524 if (p == NULL)
7525 return FALSE;
7526
7527 if (! bfd_get_section_contents (need_pad->owner, need_pad,
7528 p, 0, need_pad->size))
7529 return FALSE;
7530
7531 need_pad->contents = p;
7532 need_pad->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
7533 }
7534 else
7535 {
7536 p = bfd_realloc (need_pad->contents, need_pad->size + 8);
7537 if (p == NULL)
7538 return FALSE;
7539
7540 need_pad->contents = p;
7541 }
7542
7543 memset (need_pad->contents + need_pad->size, 0, 8);
7544 need_pad->size += 8;
7545 }
7546
7547 return TRUE;
7548 }
7549
7550 /* Set htab->tls_get_addr and call the generic ELF tls_setup function. */
7551
7552 asection *
7553 ppc64_elf_tls_setup (struct bfd_link_info *info,
7554 int no_tls_get_addr_opt,
7555 int *no_multi_toc)
7556 {
7557 struct ppc_link_hash_table *htab;
7558
7559 htab = ppc_hash_table (info);
7560 if (htab == NULL)
7561 return NULL;
7562
7563 if (*no_multi_toc)
7564 htab->do_multi_toc = 0;
7565 else if (!htab->do_multi_toc)
7566 *no_multi_toc = 1;
7567
7568 htab->tls_get_addr = ((struct ppc_link_hash_entry *)
7569 elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
7570 FALSE, FALSE, TRUE));
7571 /* Move dynamic linking info to the function descriptor sym. */
7572 if (htab->tls_get_addr != NULL)
7573 func_desc_adjust (&htab->tls_get_addr->elf, info);
7574 htab->tls_get_addr_fd = ((struct ppc_link_hash_entry *)
7575 elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
7576 FALSE, FALSE, TRUE));
7577 if (!no_tls_get_addr_opt)
7578 {
7579 struct elf_link_hash_entry *opt, *opt_fd, *tga, *tga_fd;
7580
7581 opt = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr_opt",
7582 FALSE, FALSE, TRUE);
7583 if (opt != NULL)
7584 func_desc_adjust (opt, info);
7585 opt_fd = elf_link_hash_lookup (&htab->elf, "__tls_get_addr_opt",
7586 FALSE, FALSE, TRUE);
7587 if (opt_fd != NULL
7588 && (opt_fd->root.type == bfd_link_hash_defined
7589 || opt_fd->root.type == bfd_link_hash_defweak))
7590 {
7591 /* If glibc supports an optimized __tls_get_addr call stub,
7592 signalled by the presence of __tls_get_addr_opt, and we'll
7593 be calling __tls_get_addr via a plt call stub, then
7594 make __tls_get_addr point to __tls_get_addr_opt. */
7595 tga_fd = &htab->tls_get_addr_fd->elf;
7596 if (htab->elf.dynamic_sections_created
7597 && tga_fd != NULL
7598 && (tga_fd->type == STT_FUNC
7599 || tga_fd->needs_plt)
7600 && !(SYMBOL_CALLS_LOCAL (info, tga_fd)
7601 || (ELF_ST_VISIBILITY (tga_fd->other) != STV_DEFAULT
7602 && tga_fd->root.type == bfd_link_hash_undefweak)))
7603 {
7604 struct plt_entry *ent;
7605
7606 for (ent = tga_fd->plt.plist; ent != NULL; ent = ent->next)
7607 if (ent->plt.refcount > 0)
7608 break;
7609 if (ent != NULL)
7610 {
7611 tga_fd->root.type = bfd_link_hash_indirect;
7612 tga_fd->root.u.i.link = &opt_fd->root;
7613 ppc64_elf_copy_indirect_symbol (info, opt_fd, tga_fd);
7614 if (opt_fd->dynindx != -1)
7615 {
7616 /* Use __tls_get_addr_opt in dynamic relocations. */
7617 opt_fd->dynindx = -1;
7618 _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
7619 opt_fd->dynstr_index);
7620 if (!bfd_elf_link_record_dynamic_symbol (info, opt_fd))
7621 return NULL;
7622 }
7623 htab->tls_get_addr_fd = (struct ppc_link_hash_entry *) opt_fd;
7624 tga = &htab->tls_get_addr->elf;
7625 if (opt != NULL && tga != NULL)
7626 {
7627 tga->root.type = bfd_link_hash_indirect;
7628 tga->root.u.i.link = &opt->root;
7629 ppc64_elf_copy_indirect_symbol (info, opt, tga);
7630 _bfd_elf_link_hash_hide_symbol (info, opt,
7631 tga->forced_local);
7632 htab->tls_get_addr = (struct ppc_link_hash_entry *) opt;
7633 }
7634 htab->tls_get_addr_fd->oh = htab->tls_get_addr;
7635 htab->tls_get_addr_fd->is_func_descriptor = 1;
7636 if (htab->tls_get_addr != NULL)
7637 {
7638 htab->tls_get_addr->oh = htab->tls_get_addr_fd;
7639 htab->tls_get_addr->is_func = 1;
7640 }
7641 }
7642 }
7643 }
7644 else
7645 no_tls_get_addr_opt = TRUE;
7646 }
7647 htab->no_tls_get_addr_opt = no_tls_get_addr_opt;
7648 return _bfd_elf_tls_setup (info->output_bfd, info);
7649 }
7650
7651 /* Return TRUE iff REL is a branch reloc with a global symbol matching
7652 HASH1 or HASH2. */
7653
7654 static bfd_boolean
7655 branch_reloc_hash_match (const bfd *ibfd,
7656 const Elf_Internal_Rela *rel,
7657 const struct ppc_link_hash_entry *hash1,
7658 const struct ppc_link_hash_entry *hash2)
7659 {
7660 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
7661 enum elf_ppc64_reloc_type r_type = ELF64_R_TYPE (rel->r_info);
7662 unsigned int r_symndx = ELF64_R_SYM (rel->r_info);
7663
7664 if (r_symndx >= symtab_hdr->sh_info && is_branch_reloc (r_type))
7665 {
7666 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
7667 struct elf_link_hash_entry *h;
7668
7669 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
7670 h = elf_follow_link (h);
7671 if (h == &hash1->elf || h == &hash2->elf)
7672 return TRUE;
7673 }
7674 return FALSE;
7675 }
7676
7677 /* Run through all the TLS relocs looking for optimization
7678 opportunities. The linker has been hacked (see ppc64elf.em) to do
7679 a preliminary section layout so that we know the TLS segment
7680 offsets. We can't optimize earlier because some optimizations need
7681 to know the tp offset, and we need to optimize before allocating
7682 dynamic relocations. */
7683
7684 bfd_boolean
7685 ppc64_elf_tls_optimize (struct bfd_link_info *info)
7686 {
7687 bfd *ibfd;
7688 asection *sec;
7689 struct ppc_link_hash_table *htab;
7690 unsigned char *toc_ref;
7691 int pass;
7692
7693 if (info->relocatable || !info->executable)
7694 return TRUE;
7695
7696 htab = ppc_hash_table (info);
7697 if (htab == NULL)
7698 return FALSE;
7699
7700 /* Make two passes over the relocs. On the first pass, mark toc
7701 entries involved with tls relocs, and check that tls relocs
7702 involved in setting up a tls_get_addr call are indeed followed by
7703 such a call. If they are not, we can't do any tls optimization.
7704 On the second pass twiddle tls_mask flags to notify
7705 relocate_section that optimization can be done, and adjust got
7706 and plt refcounts. */
7707 toc_ref = NULL;
7708 for (pass = 0; pass < 2; ++pass)
7709 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
7710 {
7711 Elf_Internal_Sym *locsyms = NULL;
7712 asection *toc = bfd_get_section_by_name (ibfd, ".toc");
7713
7714 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
7715 if (sec->has_tls_reloc && !bfd_is_abs_section (sec->output_section))
7716 {
7717 Elf_Internal_Rela *relstart, *rel, *relend;
7718 bfd_boolean found_tls_get_addr_arg = 0;
7719
7720 /* Read the relocations. */
7721 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
7722 info->keep_memory);
7723 if (relstart == NULL)
7724 return FALSE;
7725
7726 relend = relstart + sec->reloc_count;
7727 for (rel = relstart; rel < relend; rel++)
7728 {
7729 enum elf_ppc64_reloc_type r_type;
7730 unsigned long r_symndx;
7731 struct elf_link_hash_entry *h;
7732 Elf_Internal_Sym *sym;
7733 asection *sym_sec;
7734 unsigned char *tls_mask;
7735 unsigned char tls_set, tls_clear, tls_type = 0;
7736 bfd_vma value;
7737 bfd_boolean ok_tprel, is_local;
7738 long toc_ref_index = 0;
7739 int expecting_tls_get_addr = 0;
7740 bfd_boolean ret = FALSE;
7741
7742 r_symndx = ELF64_R_SYM (rel->r_info);
7743 if (!get_sym_h (&h, &sym, &sym_sec, &tls_mask, &locsyms,
7744 r_symndx, ibfd))
7745 {
7746 err_free_rel:
7747 if (elf_section_data (sec)->relocs != relstart)
7748 free (relstart);
7749 if (toc_ref != NULL)
7750 free (toc_ref);
7751 if (locsyms != NULL
7752 && (elf_symtab_hdr (ibfd).contents
7753 != (unsigned char *) locsyms))
7754 free (locsyms);
7755 return ret;
7756 }
7757
7758 if (h != NULL)
7759 {
7760 if (h->root.type == bfd_link_hash_defined
7761 || h->root.type == bfd_link_hash_defweak)
7762 value = h->root.u.def.value;
7763 else if (h->root.type == bfd_link_hash_undefweak)
7764 value = 0;
7765 else
7766 {
7767 found_tls_get_addr_arg = 0;
7768 continue;
7769 }
7770 }
7771 else
7772 /* Symbols referenced by TLS relocs must be of type
7773 STT_TLS. So no need for .opd local sym adjust. */
7774 value = sym->st_value;
7775
7776 ok_tprel = FALSE;
7777 is_local = FALSE;
7778 if (h == NULL
7779 || !h->def_dynamic)
7780 {
7781 is_local = TRUE;
7782 if (h != NULL
7783 && h->root.type == bfd_link_hash_undefweak)
7784 ok_tprel = TRUE;
7785 else
7786 {
7787 value += sym_sec->output_offset;
7788 value += sym_sec->output_section->vma;
7789 value -= htab->elf.tls_sec->vma;
7790 ok_tprel = (value + TP_OFFSET + ((bfd_vma) 1 << 31)
7791 < (bfd_vma) 1 << 32);
7792 }
7793 }
7794
7795 r_type = ELF64_R_TYPE (rel->r_info);
7796 /* If this section has old-style __tls_get_addr calls
7797 without marker relocs, then check that each
7798 __tls_get_addr call reloc is preceded by a reloc
7799 that conceivably belongs to the __tls_get_addr arg
7800 setup insn. If we don't find matching arg setup
7801 relocs, don't do any tls optimization. */
7802 if (pass == 0
7803 && sec->has_tls_get_addr_call
7804 && h != NULL
7805 && (h == &htab->tls_get_addr->elf
7806 || h == &htab->tls_get_addr_fd->elf)
7807 && !found_tls_get_addr_arg
7808 && is_branch_reloc (r_type))
7809 {
7810 info->callbacks->minfo (_("%H __tls_get_addr lost arg, "
7811 "TLS optimization disabled\n"),
7812 ibfd, sec, rel->r_offset);
7813 ret = TRUE;
7814 goto err_free_rel;
7815 }
7816
7817 found_tls_get_addr_arg = 0;
7818 switch (r_type)
7819 {
7820 case R_PPC64_GOT_TLSLD16:
7821 case R_PPC64_GOT_TLSLD16_LO:
7822 expecting_tls_get_addr = 1;
7823 found_tls_get_addr_arg = 1;
7824 /* Fall thru */
7825
7826 case R_PPC64_GOT_TLSLD16_HI:
7827 case R_PPC64_GOT_TLSLD16_HA:
7828 /* These relocs should never be against a symbol
7829 defined in a shared lib. Leave them alone if
7830 that turns out to be the case. */
7831 if (!is_local)
7832 continue;
7833
7834 /* LD -> LE */
7835 tls_set = 0;
7836 tls_clear = TLS_LD;
7837 tls_type = TLS_TLS | TLS_LD;
7838 break;
7839
7840 case R_PPC64_GOT_TLSGD16:
7841 case R_PPC64_GOT_TLSGD16_LO:
7842 expecting_tls_get_addr = 1;
7843 found_tls_get_addr_arg = 1;
7844 /* Fall thru */
7845
7846 case R_PPC64_GOT_TLSGD16_HI:
7847 case R_PPC64_GOT_TLSGD16_HA:
7848 if (ok_tprel)
7849 /* GD -> LE */
7850 tls_set = 0;
7851 else
7852 /* GD -> IE */
7853 tls_set = TLS_TLS | TLS_TPRELGD;
7854 tls_clear = TLS_GD;
7855 tls_type = TLS_TLS | TLS_GD;
7856 break;
7857
7858 case R_PPC64_GOT_TPREL16_DS:
7859 case R_PPC64_GOT_TPREL16_LO_DS:
7860 case R_PPC64_GOT_TPREL16_HI:
7861 case R_PPC64_GOT_TPREL16_HA:
7862 if (ok_tprel)
7863 {
7864 /* IE -> LE */
7865 tls_set = 0;
7866 tls_clear = TLS_TPREL;
7867 tls_type = TLS_TLS | TLS_TPREL;
7868 break;
7869 }
7870 continue;
7871
7872 case R_PPC64_TLSGD:
7873 case R_PPC64_TLSLD:
7874 found_tls_get_addr_arg = 1;
7875 /* Fall thru */
7876
7877 case R_PPC64_TLS:
7878 case R_PPC64_TOC16:
7879 case R_PPC64_TOC16_LO:
7880 if (sym_sec == NULL || sym_sec != toc)
7881 continue;
7882
7883 /* Mark this toc entry as referenced by a TLS
7884 code sequence. We can do that now in the
7885 case of R_PPC64_TLS, and after checking for
7886 tls_get_addr for the TOC16 relocs. */
7887 if (toc_ref == NULL)
7888 toc_ref = bfd_zmalloc (toc->output_section->rawsize / 8);
7889 if (toc_ref == NULL)
7890 goto err_free_rel;
7891
7892 if (h != NULL)
7893 value = h->root.u.def.value;
7894 else
7895 value = sym->st_value;
7896 value += rel->r_addend;
7897 BFD_ASSERT (value < toc->size && value % 8 == 0);
7898 toc_ref_index = (value + toc->output_offset) / 8;
7899 if (r_type == R_PPC64_TLS
7900 || r_type == R_PPC64_TLSGD
7901 || r_type == R_PPC64_TLSLD)
7902 {
7903 toc_ref[toc_ref_index] = 1;
7904 continue;
7905 }
7906
7907 if (pass != 0 && toc_ref[toc_ref_index] == 0)
7908 continue;
7909
7910 tls_set = 0;
7911 tls_clear = 0;
7912 expecting_tls_get_addr = 2;
7913 break;
7914
7915 case R_PPC64_TPREL64:
7916 if (pass == 0
7917 || sec != toc
7918 || toc_ref == NULL
7919 || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
7920 continue;
7921 if (ok_tprel)
7922 {
7923 /* IE -> LE */
7924 tls_set = TLS_EXPLICIT;
7925 tls_clear = TLS_TPREL;
7926 break;
7927 }
7928 continue;
7929
7930 case R_PPC64_DTPMOD64:
7931 if (pass == 0
7932 || sec != toc
7933 || toc_ref == NULL
7934 || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
7935 continue;
7936 if (rel + 1 < relend
7937 && (rel[1].r_info
7938 == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64))
7939 && rel[1].r_offset == rel->r_offset + 8)
7940 {
7941 if (ok_tprel)
7942 /* GD -> LE */
7943 tls_set = TLS_EXPLICIT | TLS_GD;
7944 else
7945 /* GD -> IE */
7946 tls_set = TLS_EXPLICIT | TLS_GD | TLS_TPRELGD;
7947 tls_clear = TLS_GD;
7948 }
7949 else
7950 {
7951 if (!is_local)
7952 continue;
7953
7954 /* LD -> LE */
7955 tls_set = TLS_EXPLICIT;
7956 tls_clear = TLS_LD;
7957 }
7958 break;
7959
7960 default:
7961 continue;
7962 }
7963
7964 if (pass == 0)
7965 {
7966 if (!expecting_tls_get_addr
7967 || !sec->has_tls_get_addr_call)
7968 continue;
7969
7970 if (rel + 1 < relend
7971 && branch_reloc_hash_match (ibfd, rel + 1,
7972 htab->tls_get_addr,
7973 htab->tls_get_addr_fd))
7974 {
7975 if (expecting_tls_get_addr == 2)
7976 {
7977 /* Check for toc tls entries. */
7978 unsigned char *toc_tls;
7979 int retval;
7980
7981 retval = get_tls_mask (&toc_tls, NULL, NULL,
7982 &locsyms,
7983 rel, ibfd);
7984 if (retval == 0)
7985 goto err_free_rel;
7986 if (toc_tls != NULL)
7987 {
7988 if ((*toc_tls & (TLS_GD | TLS_LD)) != 0)
7989 found_tls_get_addr_arg = 1;
7990 if (retval > 1)
7991 toc_ref[toc_ref_index] = 1;
7992 }
7993 }
7994 continue;
7995 }
7996
7997 if (expecting_tls_get_addr != 1)
7998 continue;
7999
8000 /* Uh oh, we didn't find the expected call. We
8001 could just mark this symbol to exclude it
8002 from tls optimization but it's safer to skip
8003 the entire optimization. */
8004 info->callbacks->minfo (_("%H arg lost __tls_get_addr, "
8005 "TLS optimization disabled\n"),
8006 ibfd, sec, rel->r_offset);
8007 ret = TRUE;
8008 goto err_free_rel;
8009 }
8010
8011 if (expecting_tls_get_addr && htab->tls_get_addr != NULL)
8012 {
8013 struct plt_entry *ent;
8014 for (ent = htab->tls_get_addr->elf.plt.plist;
8015 ent != NULL;
8016 ent = ent->next)
8017 if (ent->addend == 0)
8018 {
8019 if (ent->plt.refcount > 0)
8020 {
8021 ent->plt.refcount -= 1;
8022 expecting_tls_get_addr = 0;
8023 }
8024 break;
8025 }
8026 }
8027
8028 if (expecting_tls_get_addr && htab->tls_get_addr_fd != NULL)
8029 {
8030 struct plt_entry *ent;
8031 for (ent = htab->tls_get_addr_fd->elf.plt.plist;
8032 ent != NULL;
8033 ent = ent->next)
8034 if (ent->addend == 0)
8035 {
8036 if (ent->plt.refcount > 0)
8037 ent->plt.refcount -= 1;
8038 break;
8039 }
8040 }
8041
8042 if (tls_clear == 0)
8043 continue;
8044
8045 if ((tls_set & TLS_EXPLICIT) == 0)
8046 {
8047 struct got_entry *ent;
8048
8049 /* Adjust got entry for this reloc. */
8050 if (h != NULL)
8051 ent = h->got.glist;
8052 else
8053 ent = elf_local_got_ents (ibfd)[r_symndx];
8054
8055 for (; ent != NULL; ent = ent->next)
8056 if (ent->addend == rel->r_addend
8057 && ent->owner == ibfd
8058 && ent->tls_type == tls_type)
8059 break;
8060 if (ent == NULL)
8061 abort ();
8062
8063 if (tls_set == 0)
8064 {
8065 /* We managed to get rid of a got entry. */
8066 if (ent->got.refcount > 0)
8067 ent->got.refcount -= 1;
8068 }
8069 }
8070 else
8071 {
8072 /* If we got rid of a DTPMOD/DTPREL reloc pair then
8073 we'll lose one or two dyn relocs. */
8074 if (!dec_dynrel_count (rel->r_info, sec, info,
8075 NULL, h, sym))
8076 return FALSE;
8077
8078 if (tls_set == (TLS_EXPLICIT | TLS_GD))
8079 {
8080 if (!dec_dynrel_count ((rel + 1)->r_info, sec, info,
8081 NULL, h, sym))
8082 return FALSE;
8083 }
8084 }
8085
8086 *tls_mask |= tls_set;
8087 *tls_mask &= ~tls_clear;
8088 }
8089
8090 if (elf_section_data (sec)->relocs != relstart)
8091 free (relstart);
8092 }
8093
8094 if (locsyms != NULL
8095 && (elf_symtab_hdr (ibfd).contents != (unsigned char *) locsyms))
8096 {
8097 if (!info->keep_memory)
8098 free (locsyms);
8099 else
8100 elf_symtab_hdr (ibfd).contents = (unsigned char *) locsyms;
8101 }
8102 }
8103
8104 if (toc_ref != NULL)
8105 free (toc_ref);
8106 return TRUE;
8107 }
8108
8109 /* Called via elf_link_hash_traverse from ppc64_elf_edit_toc to adjust
8110 the values of any global symbols in a toc section that has been
8111 edited. Globals in toc sections should be a rarity, so this function
8112 sets a flag if any are found in toc sections other than the one just
8113 edited, so that futher hash table traversals can be avoided. */
8114
8115 struct adjust_toc_info
8116 {
8117 asection *toc;
8118 unsigned long *skip;
8119 bfd_boolean global_toc_syms;
8120 };
8121
8122 enum toc_skip_enum { ref_from_discarded = 1, can_optimize = 2 };
8123
8124 static bfd_boolean
8125 adjust_toc_syms (struct elf_link_hash_entry *h, void *inf)
8126 {
8127 struct ppc_link_hash_entry *eh;
8128 struct adjust_toc_info *toc_inf = (struct adjust_toc_info *) inf;
8129 unsigned long i;
8130
8131 if (h->root.type != bfd_link_hash_defined
8132 && h->root.type != bfd_link_hash_defweak)
8133 return TRUE;
8134
8135 eh = (struct ppc_link_hash_entry *) h;
8136 if (eh->adjust_done)
8137 return TRUE;
8138
8139 if (eh->elf.root.u.def.section == toc_inf->toc)
8140 {
8141 if (eh->elf.root.u.def.value > toc_inf->toc->rawsize)
8142 i = toc_inf->toc->rawsize >> 3;
8143 else
8144 i = eh->elf.root.u.def.value >> 3;
8145
8146 if ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0)
8147 {
8148 (*_bfd_error_handler)
8149 (_("%s defined on removed toc entry"), eh->elf.root.root.string);
8150 do
8151 ++i;
8152 while ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0);
8153 eh->elf.root.u.def.value = (bfd_vma) i << 3;
8154 }
8155
8156 eh->elf.root.u.def.value -= toc_inf->skip[i];
8157 eh->adjust_done = 1;
8158 }
8159 else if (strcmp (eh->elf.root.u.def.section->name, ".toc") == 0)
8160 toc_inf->global_toc_syms = TRUE;
8161
8162 return TRUE;
8163 }
8164
8165 /* Return TRUE iff INSN is one we expect on a _LO variety toc/got reloc. */
8166
8167 static bfd_boolean
8168 ok_lo_toc_insn (unsigned int insn)
8169 {
8170 return ((insn & (0x3f << 26)) == 14u << 26 /* addi */
8171 || (insn & (0x3f << 26)) == 32u << 26 /* lwz */
8172 || (insn & (0x3f << 26)) == 34u << 26 /* lbz */
8173 || (insn & (0x3f << 26)) == 36u << 26 /* stw */
8174 || (insn & (0x3f << 26)) == 38u << 26 /* stb */
8175 || (insn & (0x3f << 26)) == 40u << 26 /* lhz */
8176 || (insn & (0x3f << 26)) == 42u << 26 /* lha */
8177 || (insn & (0x3f << 26)) == 44u << 26 /* sth */
8178 || (insn & (0x3f << 26)) == 46u << 26 /* lmw */
8179 || (insn & (0x3f << 26)) == 47u << 26 /* stmw */
8180 || (insn & (0x3f << 26)) == 48u << 26 /* lfs */
8181 || (insn & (0x3f << 26)) == 50u << 26 /* lfd */
8182 || (insn & (0x3f << 26)) == 52u << 26 /* stfs */
8183 || (insn & (0x3f << 26)) == 54u << 26 /* stfd */
8184 || ((insn & (0x3f << 26)) == 58u << 26 /* lwa,ld,lmd */
8185 && (insn & 3) != 1)
8186 || ((insn & (0x3f << 26)) == 62u << 26 /* std, stmd */
8187 && ((insn & 3) == 0 || (insn & 3) == 3))
8188 || (insn & (0x3f << 26)) == 12u << 26 /* addic */);
8189 }
8190
8191 /* Examine all relocs referencing .toc sections in order to remove
8192 unused .toc entries. */
8193
8194 bfd_boolean
8195 ppc64_elf_edit_toc (struct bfd_link_info *info)
8196 {
8197 bfd *ibfd;
8198 struct adjust_toc_info toc_inf;
8199 struct ppc_link_hash_table *htab = ppc_hash_table (info);
8200
8201 htab->do_toc_opt = 1;
8202 toc_inf.global_toc_syms = TRUE;
8203 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
8204 {
8205 asection *toc, *sec;
8206 Elf_Internal_Shdr *symtab_hdr;
8207 Elf_Internal_Sym *local_syms;
8208 Elf_Internal_Rela *relstart, *rel, *toc_relocs;
8209 unsigned long *skip, *drop;
8210 unsigned char *used;
8211 unsigned char *keep, last, some_unused;
8212
8213 if (!is_ppc64_elf (ibfd))
8214 continue;
8215
8216 toc = bfd_get_section_by_name (ibfd, ".toc");
8217 if (toc == NULL
8218 || toc->size == 0
8219 || toc->sec_info_type == SEC_INFO_TYPE_JUST_SYMS
8220 || discarded_section (toc))
8221 continue;
8222
8223 toc_relocs = NULL;
8224 local_syms = NULL;
8225 symtab_hdr = &elf_symtab_hdr (ibfd);
8226
8227 /* Look at sections dropped from the final link. */
8228 skip = NULL;
8229 relstart = NULL;
8230 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8231 {
8232 if (sec->reloc_count == 0
8233 || !discarded_section (sec)
8234 || get_opd_info (sec)
8235 || (sec->flags & SEC_ALLOC) == 0
8236 || (sec->flags & SEC_DEBUGGING) != 0)
8237 continue;
8238
8239 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL, FALSE);
8240 if (relstart == NULL)
8241 goto error_ret;
8242
8243 /* Run through the relocs to see which toc entries might be
8244 unused. */
8245 for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
8246 {
8247 enum elf_ppc64_reloc_type r_type;
8248 unsigned long r_symndx;
8249 asection *sym_sec;
8250 struct elf_link_hash_entry *h;
8251 Elf_Internal_Sym *sym;
8252 bfd_vma val;
8253
8254 r_type = ELF64_R_TYPE (rel->r_info);
8255 switch (r_type)
8256 {
8257 default:
8258 continue;
8259
8260 case R_PPC64_TOC16:
8261 case R_PPC64_TOC16_LO:
8262 case R_PPC64_TOC16_HI:
8263 case R_PPC64_TOC16_HA:
8264 case R_PPC64_TOC16_DS:
8265 case R_PPC64_TOC16_LO_DS:
8266 break;
8267 }
8268
8269 r_symndx = ELF64_R_SYM (rel->r_info);
8270 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8271 r_symndx, ibfd))
8272 goto error_ret;
8273
8274 if (sym_sec != toc)
8275 continue;
8276
8277 if (h != NULL)
8278 val = h->root.u.def.value;
8279 else
8280 val = sym->st_value;
8281 val += rel->r_addend;
8282
8283 if (val >= toc->size)
8284 continue;
8285
8286 /* Anything in the toc ought to be aligned to 8 bytes.
8287 If not, don't mark as unused. */
8288 if (val & 7)
8289 continue;
8290
8291 if (skip == NULL)
8292 {
8293 skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
8294 if (skip == NULL)
8295 goto error_ret;
8296 }
8297
8298 skip[val >> 3] = ref_from_discarded;
8299 }
8300
8301 if (elf_section_data (sec)->relocs != relstart)
8302 free (relstart);
8303 }
8304
8305 /* For largetoc loads of address constants, we can convert
8306 . addis rx,2,addr@got@ha
8307 . ld ry,addr@got@l(rx)
8308 to
8309 . addis rx,2,addr@toc@ha
8310 . addi ry,rx,addr@toc@l
8311 when addr is within 2G of the toc pointer. This then means
8312 that the word storing "addr" in the toc is no longer needed. */
8313
8314 if (!ppc64_elf_tdata (ibfd)->has_small_toc_reloc
8315 && toc->output_section->rawsize < (bfd_vma) 1 << 31
8316 && toc->reloc_count != 0)
8317 {
8318 /* Read toc relocs. */
8319 toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
8320 info->keep_memory);
8321 if (toc_relocs == NULL)
8322 goto error_ret;
8323
8324 for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
8325 {
8326 enum elf_ppc64_reloc_type r_type;
8327 unsigned long r_symndx;
8328 asection *sym_sec;
8329 struct elf_link_hash_entry *h;
8330 Elf_Internal_Sym *sym;
8331 bfd_vma val, addr;
8332
8333 r_type = ELF64_R_TYPE (rel->r_info);
8334 if (r_type != R_PPC64_ADDR64)
8335 continue;
8336
8337 r_symndx = ELF64_R_SYM (rel->r_info);
8338 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8339 r_symndx, ibfd))
8340 goto error_ret;
8341
8342 if (sym_sec == NULL
8343 || discarded_section (sym_sec))
8344 continue;
8345
8346 if (!SYMBOL_CALLS_LOCAL (info, h))
8347 continue;
8348
8349 if (h != NULL)
8350 {
8351 if (h->type == STT_GNU_IFUNC)
8352 continue;
8353 val = h->root.u.def.value;
8354 }
8355 else
8356 {
8357 if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
8358 continue;
8359 val = sym->st_value;
8360 }
8361 val += rel->r_addend;
8362 val += sym_sec->output_section->vma + sym_sec->output_offset;
8363
8364 /* We don't yet know the exact toc pointer value, but we
8365 know it will be somewhere in the toc section. Don't
8366 optimize if the difference from any possible toc
8367 pointer is outside [ff..f80008000, 7fff7fff]. */
8368 addr = toc->output_section->vma + TOC_BASE_OFF;
8369 if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
8370 continue;
8371
8372 addr = toc->output_section->vma + toc->output_section->rawsize;
8373 if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
8374 continue;
8375
8376 if (skip == NULL)
8377 {
8378 skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
8379 if (skip == NULL)
8380 goto error_ret;
8381 }
8382
8383 skip[rel->r_offset >> 3]
8384 |= can_optimize | ((rel - toc_relocs) << 2);
8385 }
8386 }
8387
8388 if (skip == NULL)
8389 continue;
8390
8391 used = bfd_zmalloc (sizeof (*used) * (toc->size + 7) / 8);
8392 if (used == NULL)
8393 {
8394 error_ret:
8395 if (local_syms != NULL
8396 && symtab_hdr->contents != (unsigned char *) local_syms)
8397 free (local_syms);
8398 if (sec != NULL
8399 && relstart != NULL
8400 && elf_section_data (sec)->relocs != relstart)
8401 free (relstart);
8402 if (toc_relocs != NULL
8403 && elf_section_data (toc)->relocs != toc_relocs)
8404 free (toc_relocs);
8405 if (skip != NULL)
8406 free (skip);
8407 return FALSE;
8408 }
8409
8410 /* Now check all kept sections that might reference the toc.
8411 Check the toc itself last. */
8412 for (sec = (ibfd->sections == toc && toc->next ? toc->next
8413 : ibfd->sections);
8414 sec != NULL;
8415 sec = (sec == toc ? NULL
8416 : sec->next == NULL ? toc
8417 : sec->next == toc && toc->next ? toc->next
8418 : sec->next))
8419 {
8420 int repeat;
8421
8422 if (sec->reloc_count == 0
8423 || discarded_section (sec)
8424 || get_opd_info (sec)
8425 || (sec->flags & SEC_ALLOC) == 0
8426 || (sec->flags & SEC_DEBUGGING) != 0)
8427 continue;
8428
8429 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8430 info->keep_memory);
8431 if (relstart == NULL)
8432 goto error_ret;
8433
8434 /* Mark toc entries referenced as used. */
8435 do
8436 {
8437 repeat = 0;
8438 for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
8439 {
8440 enum elf_ppc64_reloc_type r_type;
8441 unsigned long r_symndx;
8442 asection *sym_sec;
8443 struct elf_link_hash_entry *h;
8444 Elf_Internal_Sym *sym;
8445 bfd_vma val;
8446 enum {no_check, check_lo, check_ha} insn_check;
8447
8448 r_type = ELF64_R_TYPE (rel->r_info);
8449 switch (r_type)
8450 {
8451 default:
8452 insn_check = no_check;
8453 break;
8454
8455 case R_PPC64_GOT_TLSLD16_HA:
8456 case R_PPC64_GOT_TLSGD16_HA:
8457 case R_PPC64_GOT_TPREL16_HA:
8458 case R_PPC64_GOT_DTPREL16_HA:
8459 case R_PPC64_GOT16_HA:
8460 case R_PPC64_TOC16_HA:
8461 insn_check = check_ha;
8462 break;
8463
8464 case R_PPC64_GOT_TLSLD16_LO:
8465 case R_PPC64_GOT_TLSGD16_LO:
8466 case R_PPC64_GOT_TPREL16_LO_DS:
8467 case R_PPC64_GOT_DTPREL16_LO_DS:
8468 case R_PPC64_GOT16_LO:
8469 case R_PPC64_GOT16_LO_DS:
8470 case R_PPC64_TOC16_LO:
8471 case R_PPC64_TOC16_LO_DS:
8472 insn_check = check_lo;
8473 break;
8474 }
8475
8476 if (insn_check != no_check)
8477 {
8478 bfd_vma off = rel->r_offset & ~3;
8479 unsigned char buf[4];
8480 unsigned int insn;
8481
8482 if (!bfd_get_section_contents (ibfd, sec, buf, off, 4))
8483 {
8484 free (used);
8485 goto error_ret;
8486 }
8487 insn = bfd_get_32 (ibfd, buf);
8488 if (insn_check == check_lo
8489 ? !ok_lo_toc_insn (insn)
8490 : ((insn & ((0x3f << 26) | 0x1f << 16))
8491 != ((15u << 26) | (2 << 16)) /* addis rt,2,imm */))
8492 {
8493 char str[12];
8494
8495 ppc64_elf_tdata (ibfd)->unexpected_toc_insn = 1;
8496 sprintf (str, "%#08x", insn);
8497 info->callbacks->einfo
8498 (_("%P: %H: toc optimization is not supported for"
8499 " %s instruction.\n"),
8500 ibfd, sec, rel->r_offset & ~3, str);
8501 }
8502 }
8503
8504 switch (r_type)
8505 {
8506 case R_PPC64_TOC16:
8507 case R_PPC64_TOC16_LO:
8508 case R_PPC64_TOC16_HI:
8509 case R_PPC64_TOC16_HA:
8510 case R_PPC64_TOC16_DS:
8511 case R_PPC64_TOC16_LO_DS:
8512 /* In case we're taking addresses of toc entries. */
8513 case R_PPC64_ADDR64:
8514 break;
8515
8516 default:
8517 continue;
8518 }
8519
8520 r_symndx = ELF64_R_SYM (rel->r_info);
8521 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8522 r_symndx, ibfd))
8523 {
8524 free (used);
8525 goto error_ret;
8526 }
8527
8528 if (sym_sec != toc)
8529 continue;
8530
8531 if (h != NULL)
8532 val = h->root.u.def.value;
8533 else
8534 val = sym->st_value;
8535 val += rel->r_addend;
8536
8537 if (val >= toc->size)
8538 continue;
8539
8540 if ((skip[val >> 3] & can_optimize) != 0)
8541 {
8542 bfd_vma off;
8543 unsigned char opc;
8544
8545 switch (r_type)
8546 {
8547 case R_PPC64_TOC16_HA:
8548 break;
8549
8550 case R_PPC64_TOC16_LO_DS:
8551 off = rel->r_offset;
8552 off += (bfd_big_endian (ibfd) ? -2 : 3);
8553 if (!bfd_get_section_contents (ibfd, sec, &opc,
8554 off, 1))
8555 {
8556 free (used);
8557 goto error_ret;
8558 }
8559 if ((opc & (0x3f << 2)) == (58u << 2))
8560 break;
8561 /* Fall thru */
8562
8563 default:
8564 /* Wrong sort of reloc, or not a ld. We may
8565 as well clear ref_from_discarded too. */
8566 skip[val >> 3] = 0;
8567 }
8568 }
8569
8570 if (sec != toc)
8571 used[val >> 3] = 1;
8572 /* For the toc section, we only mark as used if this
8573 entry itself isn't unused. */
8574 else if ((used[rel->r_offset >> 3]
8575 || !(skip[rel->r_offset >> 3] & ref_from_discarded))
8576 && !used[val >> 3])
8577 {
8578 /* Do all the relocs again, to catch reference
8579 chains. */
8580 repeat = 1;
8581 used[val >> 3] = 1;
8582 }
8583 }
8584 }
8585 while (repeat);
8586
8587 if (elf_section_data (sec)->relocs != relstart)
8588 free (relstart);
8589 }
8590
8591 /* Merge the used and skip arrays. Assume that TOC
8592 doublewords not appearing as either used or unused belong
8593 to to an entry more than one doubleword in size. */
8594 for (drop = skip, keep = used, last = 0, some_unused = 0;
8595 drop < skip + (toc->size + 7) / 8;
8596 ++drop, ++keep)
8597 {
8598 if (*keep)
8599 {
8600 *drop &= ~ref_from_discarded;
8601 if ((*drop & can_optimize) != 0)
8602 some_unused = 1;
8603 last = 0;
8604 }
8605 else if ((*drop & ref_from_discarded) != 0)
8606 {
8607 some_unused = 1;
8608 last = ref_from_discarded;
8609 }
8610 else
8611 *drop = last;
8612 }
8613
8614 free (used);
8615
8616 if (some_unused)
8617 {
8618 bfd_byte *contents, *src;
8619 unsigned long off;
8620 Elf_Internal_Sym *sym;
8621 bfd_boolean local_toc_syms = FALSE;
8622
8623 /* Shuffle the toc contents, and at the same time convert the
8624 skip array from booleans into offsets. */
8625 if (!bfd_malloc_and_get_section (ibfd, toc, &contents))
8626 goto error_ret;
8627
8628 elf_section_data (toc)->this_hdr.contents = contents;
8629
8630 for (src = contents, off = 0, drop = skip;
8631 src < contents + toc->size;
8632 src += 8, ++drop)
8633 {
8634 if ((*drop & (can_optimize | ref_from_discarded)) != 0)
8635 off += 8;
8636 else if (off != 0)
8637 {
8638 *drop = off;
8639 memcpy (src - off, src, 8);
8640 }
8641 }
8642 *drop = off;
8643 toc->rawsize = toc->size;
8644 toc->size = src - contents - off;
8645
8646 /* Adjust addends for relocs against the toc section sym,
8647 and optimize any accesses we can. */
8648 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8649 {
8650 if (sec->reloc_count == 0
8651 || discarded_section (sec))
8652 continue;
8653
8654 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8655 info->keep_memory);
8656 if (relstart == NULL)
8657 goto error_ret;
8658
8659 for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
8660 {
8661 enum elf_ppc64_reloc_type r_type;
8662 unsigned long r_symndx;
8663 asection *sym_sec;
8664 struct elf_link_hash_entry *h;
8665 bfd_vma val;
8666
8667 r_type = ELF64_R_TYPE (rel->r_info);
8668 switch (r_type)
8669 {
8670 default:
8671 continue;
8672
8673 case R_PPC64_TOC16:
8674 case R_PPC64_TOC16_LO:
8675 case R_PPC64_TOC16_HI:
8676 case R_PPC64_TOC16_HA:
8677 case R_PPC64_TOC16_DS:
8678 case R_PPC64_TOC16_LO_DS:
8679 case R_PPC64_ADDR64:
8680 break;
8681 }
8682
8683 r_symndx = ELF64_R_SYM (rel->r_info);
8684 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8685 r_symndx, ibfd))
8686 goto error_ret;
8687
8688 if (sym_sec != toc)
8689 continue;
8690
8691 if (h != NULL)
8692 val = h->root.u.def.value;
8693 else
8694 {
8695 val = sym->st_value;
8696 if (val != 0)
8697 local_toc_syms = TRUE;
8698 }
8699
8700 val += rel->r_addend;
8701
8702 if (val > toc->rawsize)
8703 val = toc->rawsize;
8704 else if ((skip[val >> 3] & ref_from_discarded) != 0)
8705 continue;
8706 else if ((skip[val >> 3] & can_optimize) != 0)
8707 {
8708 Elf_Internal_Rela *tocrel
8709 = toc_relocs + (skip[val >> 3] >> 2);
8710 unsigned long tsym = ELF64_R_SYM (tocrel->r_info);
8711
8712 switch (r_type)
8713 {
8714 case R_PPC64_TOC16_HA:
8715 rel->r_info = ELF64_R_INFO (tsym, R_PPC64_TOC16_HA);
8716 break;
8717
8718 case R_PPC64_TOC16_LO_DS:
8719 rel->r_info = ELF64_R_INFO (tsym, R_PPC64_LO_DS_OPT);
8720 break;
8721
8722 default:
8723 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
8724 ppc_howto_init ();
8725 info->callbacks->einfo
8726 (_("%P: %H: %s references "
8727 "optimized away TOC entry\n"),
8728 ibfd, sec, rel->r_offset,
8729 ppc64_elf_howto_table[r_type]->name);
8730 bfd_set_error (bfd_error_bad_value);
8731 goto error_ret;
8732 }
8733 rel->r_addend = tocrel->r_addend;
8734 elf_section_data (sec)->relocs = relstart;
8735 continue;
8736 }
8737
8738 if (h != NULL || sym->st_value != 0)
8739 continue;
8740
8741 rel->r_addend -= skip[val >> 3];
8742 elf_section_data (sec)->relocs = relstart;
8743 }
8744
8745 if (elf_section_data (sec)->relocs != relstart)
8746 free (relstart);
8747 }
8748
8749 /* We shouldn't have local or global symbols defined in the TOC,
8750 but handle them anyway. */
8751 if (local_syms != NULL)
8752 for (sym = local_syms;
8753 sym < local_syms + symtab_hdr->sh_info;
8754 ++sym)
8755 if (sym->st_value != 0
8756 && bfd_section_from_elf_index (ibfd, sym->st_shndx) == toc)
8757 {
8758 unsigned long i;
8759
8760 if (sym->st_value > toc->rawsize)
8761 i = toc->rawsize >> 3;
8762 else
8763 i = sym->st_value >> 3;
8764
8765 if ((skip[i] & (ref_from_discarded | can_optimize)) != 0)
8766 {
8767 if (local_toc_syms)
8768 (*_bfd_error_handler)
8769 (_("%s defined on removed toc entry"),
8770 bfd_elf_sym_name (ibfd, symtab_hdr, sym, NULL));
8771 do
8772 ++i;
8773 while ((skip[i] & (ref_from_discarded | can_optimize)));
8774 sym->st_value = (bfd_vma) i << 3;
8775 }
8776
8777 sym->st_value -= skip[i];
8778 symtab_hdr->contents = (unsigned char *) local_syms;
8779 }
8780
8781 /* Adjust any global syms defined in this toc input section. */
8782 if (toc_inf.global_toc_syms)
8783 {
8784 toc_inf.toc = toc;
8785 toc_inf.skip = skip;
8786 toc_inf.global_toc_syms = FALSE;
8787 elf_link_hash_traverse (elf_hash_table (info), adjust_toc_syms,
8788 &toc_inf);
8789 }
8790
8791 if (toc->reloc_count != 0)
8792 {
8793 Elf_Internal_Shdr *rel_hdr;
8794 Elf_Internal_Rela *wrel;
8795 bfd_size_type sz;
8796
8797 /* Remove unused toc relocs, and adjust those we keep. */
8798 if (toc_relocs == NULL)
8799 toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
8800 info->keep_memory);
8801 if (toc_relocs == NULL)
8802 goto error_ret;
8803
8804 wrel = toc_relocs;
8805 for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
8806 if ((skip[rel->r_offset >> 3]
8807 & (ref_from_discarded | can_optimize)) == 0)
8808 {
8809 wrel->r_offset = rel->r_offset - skip[rel->r_offset >> 3];
8810 wrel->r_info = rel->r_info;
8811 wrel->r_addend = rel->r_addend;
8812 ++wrel;
8813 }
8814 else if (!dec_dynrel_count (rel->r_info, toc, info,
8815 &local_syms, NULL, NULL))
8816 goto error_ret;
8817
8818 elf_section_data (toc)->relocs = toc_relocs;
8819 toc->reloc_count = wrel - toc_relocs;
8820 rel_hdr = _bfd_elf_single_rel_hdr (toc);
8821 sz = rel_hdr->sh_entsize;
8822 rel_hdr->sh_size = toc->reloc_count * sz;
8823 }
8824 }
8825 else if (toc_relocs != NULL
8826 && elf_section_data (toc)->relocs != toc_relocs)
8827 free (toc_relocs);
8828
8829 if (local_syms != NULL
8830 && symtab_hdr->contents != (unsigned char *) local_syms)
8831 {
8832 if (!info->keep_memory)
8833 free (local_syms);
8834 else
8835 symtab_hdr->contents = (unsigned char *) local_syms;
8836 }
8837 free (skip);
8838 }
8839
8840 return TRUE;
8841 }
8842
8843 /* Return true iff input section I references the TOC using
8844 instructions limited to +/-32k offsets. */
8845
8846 bfd_boolean
8847 ppc64_elf_has_small_toc_reloc (asection *i)
8848 {
8849 return (is_ppc64_elf (i->owner)
8850 && ppc64_elf_tdata (i->owner)->has_small_toc_reloc);
8851 }
8852
8853 /* Allocate space for one GOT entry. */
8854
8855 static void
8856 allocate_got (struct elf_link_hash_entry *h,
8857 struct bfd_link_info *info,
8858 struct got_entry *gent)
8859 {
8860 struct ppc_link_hash_table *htab = ppc_hash_table (info);
8861 bfd_boolean dyn;
8862 struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
8863 int entsize = (gent->tls_type & eh->tls_mask & (TLS_GD | TLS_LD)
8864 ? 16 : 8);
8865 int rentsize = (gent->tls_type & eh->tls_mask & TLS_GD
8866 ? 2 : 1) * sizeof (Elf64_External_Rela);
8867 asection *got = ppc64_elf_tdata (gent->owner)->got;
8868
8869 gent->got.offset = got->size;
8870 got->size += entsize;
8871
8872 dyn = htab->elf.dynamic_sections_created;
8873 if (h->type == STT_GNU_IFUNC)
8874 {
8875 htab->reliplt->size += rentsize;
8876 htab->got_reli_size += rentsize;
8877 }
8878 else if ((info->shared
8879 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h))
8880 && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
8881 || h->root.type != bfd_link_hash_undefweak))
8882 {
8883 asection *relgot = ppc64_elf_tdata (gent->owner)->relgot;
8884 relgot->size += rentsize;
8885 }
8886 }
8887
8888 /* This function merges got entries in the same toc group. */
8889
8890 static void
8891 merge_got_entries (struct got_entry **pent)
8892 {
8893 struct got_entry *ent, *ent2;
8894
8895 for (ent = *pent; ent != NULL; ent = ent->next)
8896 if (!ent->is_indirect)
8897 for (ent2 = ent->next; ent2 != NULL; ent2 = ent2->next)
8898 if (!ent2->is_indirect
8899 && ent2->addend == ent->addend
8900 && ent2->tls_type == ent->tls_type
8901 && elf_gp (ent2->owner) == elf_gp (ent->owner))
8902 {
8903 ent2->is_indirect = TRUE;
8904 ent2->got.ent = ent;
8905 }
8906 }
8907
8908 /* Allocate space in .plt, .got and associated reloc sections for
8909 dynamic relocs. */
8910
8911 static bfd_boolean
8912 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
8913 {
8914 struct bfd_link_info *info;
8915 struct ppc_link_hash_table *htab;
8916 asection *s;
8917 struct ppc_link_hash_entry *eh;
8918 struct elf_dyn_relocs *p;
8919 struct got_entry **pgent, *gent;
8920
8921 if (h->root.type == bfd_link_hash_indirect)
8922 return TRUE;
8923
8924 info = (struct bfd_link_info *) inf;
8925 htab = ppc_hash_table (info);
8926 if (htab == NULL)
8927 return FALSE;
8928
8929 if ((htab->elf.dynamic_sections_created
8930 && h->dynindx != -1
8931 && WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info->shared, h))
8932 || h->type == STT_GNU_IFUNC)
8933 {
8934 struct plt_entry *pent;
8935 bfd_boolean doneone = FALSE;
8936 for (pent = h->plt.plist; pent != NULL; pent = pent->next)
8937 if (pent->plt.refcount > 0)
8938 {
8939 if (!htab->elf.dynamic_sections_created
8940 || h->dynindx == -1)
8941 {
8942 s = htab->iplt;
8943 pent->plt.offset = s->size;
8944 s->size += PLT_ENTRY_SIZE;
8945 s = htab->reliplt;
8946 }
8947 else
8948 {
8949 /* If this is the first .plt entry, make room for the special
8950 first entry. */
8951 s = htab->plt;
8952 if (s->size == 0)
8953 s->size += PLT_INITIAL_ENTRY_SIZE;
8954
8955 pent->plt.offset = s->size;
8956
8957 /* Make room for this entry. */
8958 s->size += PLT_ENTRY_SIZE;
8959
8960 /* Make room for the .glink code. */
8961 s = htab->glink;
8962 if (s->size == 0)
8963 s->size += GLINK_CALL_STUB_SIZE;
8964 /* We need bigger stubs past index 32767. */
8965 if (s->size >= GLINK_CALL_STUB_SIZE + 32768*2*4)
8966 s->size += 4;
8967 s->size += 2*4;
8968
8969 /* We also need to make an entry in the .rela.plt section. */
8970 s = htab->relplt;
8971 }
8972 s->size += sizeof (Elf64_External_Rela);
8973 doneone = TRUE;
8974 }
8975 else
8976 pent->plt.offset = (bfd_vma) -1;
8977 if (!doneone)
8978 {
8979 h->plt.plist = NULL;
8980 h->needs_plt = 0;
8981 }
8982 }
8983 else
8984 {
8985 h->plt.plist = NULL;
8986 h->needs_plt = 0;
8987 }
8988
8989 eh = (struct ppc_link_hash_entry *) h;
8990 /* Run through the TLS GD got entries first if we're changing them
8991 to TPREL. */
8992 if ((eh->tls_mask & TLS_TPRELGD) != 0)
8993 for (gent = h->got.glist; gent != NULL; gent = gent->next)
8994 if (gent->got.refcount > 0
8995 && (gent->tls_type & TLS_GD) != 0)
8996 {
8997 /* This was a GD entry that has been converted to TPREL. If
8998 there happens to be a TPREL entry we can use that one. */
8999 struct got_entry *ent;
9000 for (ent = h->got.glist; ent != NULL; ent = ent->next)
9001 if (ent->got.refcount > 0
9002 && (ent->tls_type & TLS_TPREL) != 0
9003 && ent->addend == gent->addend
9004 && ent->owner == gent->owner)
9005 {
9006 gent->got.refcount = 0;
9007 break;
9008 }
9009
9010 /* If not, then we'll be using our own TPREL entry. */
9011 if (gent->got.refcount != 0)
9012 gent->tls_type = TLS_TLS | TLS_TPREL;
9013 }
9014
9015 /* Remove any list entry that won't generate a word in the GOT before
9016 we call merge_got_entries. Otherwise we risk merging to empty
9017 entries. */
9018 pgent = &h->got.glist;
9019 while ((gent = *pgent) != NULL)
9020 if (gent->got.refcount > 0)
9021 {
9022 if ((gent->tls_type & TLS_LD) != 0
9023 && !h->def_dynamic)
9024 {
9025 ppc64_tlsld_got (gent->owner)->got.refcount += 1;
9026 *pgent = gent->next;
9027 }
9028 else
9029 pgent = &gent->next;
9030 }
9031 else
9032 *pgent = gent->next;
9033
9034 if (!htab->do_multi_toc)
9035 merge_got_entries (&h->got.glist);
9036
9037 for (gent = h->got.glist; gent != NULL; gent = gent->next)
9038 if (!gent->is_indirect)
9039 {
9040 /* Make sure this symbol is output as a dynamic symbol.
9041 Undefined weak syms won't yet be marked as dynamic,
9042 nor will all TLS symbols. */
9043 if (h->dynindx == -1
9044 && !h->forced_local
9045 && h->type != STT_GNU_IFUNC
9046 && htab->elf.dynamic_sections_created)
9047 {
9048 if (! bfd_elf_link_record_dynamic_symbol (info, h))
9049 return FALSE;
9050 }
9051
9052 if (!is_ppc64_elf (gent->owner))
9053 abort ();
9054
9055 allocate_got (h, info, gent);
9056 }
9057
9058 if (eh->dyn_relocs == NULL
9059 || (!htab->elf.dynamic_sections_created
9060 && h->type != STT_GNU_IFUNC))
9061 return TRUE;
9062
9063 /* In the shared -Bsymbolic case, discard space allocated for
9064 dynamic pc-relative relocs against symbols which turn out to be
9065 defined in regular objects. For the normal shared case, discard
9066 space for relocs that have become local due to symbol visibility
9067 changes. */
9068
9069 if (info->shared)
9070 {
9071 /* Relocs that use pc_count are those that appear on a call insn,
9072 or certain REL relocs (see must_be_dyn_reloc) that can be
9073 generated via assembly. We want calls to protected symbols to
9074 resolve directly to the function rather than going via the plt.
9075 If people want function pointer comparisons to work as expected
9076 then they should avoid writing weird assembly. */
9077 if (SYMBOL_CALLS_LOCAL (info, h))
9078 {
9079 struct elf_dyn_relocs **pp;
9080
9081 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
9082 {
9083 p->count -= p->pc_count;
9084 p->pc_count = 0;
9085 if (p->count == 0)
9086 *pp = p->next;
9087 else
9088 pp = &p->next;
9089 }
9090 }
9091
9092 /* Also discard relocs on undefined weak syms with non-default
9093 visibility. */
9094 if (eh->dyn_relocs != NULL
9095 && h->root.type == bfd_link_hash_undefweak)
9096 {
9097 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
9098 eh->dyn_relocs = NULL;
9099
9100 /* Make sure this symbol is output as a dynamic symbol.
9101 Undefined weak syms won't yet be marked as dynamic. */
9102 else if (h->dynindx == -1
9103 && !h->forced_local)
9104 {
9105 if (! bfd_elf_link_record_dynamic_symbol (info, h))
9106 return FALSE;
9107 }
9108 }
9109 }
9110 else if (h->type == STT_GNU_IFUNC)
9111 {
9112 if (!h->non_got_ref)
9113 eh->dyn_relocs = NULL;
9114 }
9115 else if (ELIMINATE_COPY_RELOCS)
9116 {
9117 /* For the non-shared case, discard space for relocs against
9118 symbols which turn out to need copy relocs or are not
9119 dynamic. */
9120
9121 if (!h->non_got_ref
9122 && !h->def_regular)
9123 {
9124 /* Make sure this symbol is output as a dynamic symbol.
9125 Undefined weak syms won't yet be marked as dynamic. */
9126 if (h->dynindx == -1
9127 && !h->forced_local)
9128 {
9129 if (! bfd_elf_link_record_dynamic_symbol (info, h))
9130 return FALSE;
9131 }
9132
9133 /* If that succeeded, we know we'll be keeping all the
9134 relocs. */
9135 if (h->dynindx != -1)
9136 goto keep;
9137 }
9138
9139 eh->dyn_relocs = NULL;
9140
9141 keep: ;
9142 }
9143
9144 /* Finally, allocate space. */
9145 for (p = eh->dyn_relocs; p != NULL; p = p->next)
9146 {
9147 asection *sreloc = elf_section_data (p->sec)->sreloc;
9148 if (eh->elf.type == STT_GNU_IFUNC)
9149 sreloc = htab->reliplt;
9150 sreloc->size += p->count * sizeof (Elf64_External_Rela);
9151 }
9152
9153 return TRUE;
9154 }
9155
9156 /* Find any dynamic relocs that apply to read-only sections. */
9157
9158 static bfd_boolean
9159 readonly_dynrelocs (struct elf_link_hash_entry *h, void *inf)
9160 {
9161 struct ppc_link_hash_entry *eh;
9162 struct elf_dyn_relocs *p;
9163
9164 eh = (struct ppc_link_hash_entry *) h;
9165 for (p = eh->dyn_relocs; p != NULL; p = p->next)
9166 {
9167 asection *s = p->sec->output_section;
9168
9169 if (s != NULL && (s->flags & SEC_READONLY) != 0)
9170 {
9171 struct bfd_link_info *info = inf;
9172
9173 info->flags |= DF_TEXTREL;
9174
9175 /* Not an error, just cut short the traversal. */
9176 return FALSE;
9177 }
9178 }
9179 return TRUE;
9180 }
9181
9182 /* Set the sizes of the dynamic sections. */
9183
9184 static bfd_boolean
9185 ppc64_elf_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
9186 struct bfd_link_info *info)
9187 {
9188 struct ppc_link_hash_table *htab;
9189 bfd *dynobj;
9190 asection *s;
9191 bfd_boolean relocs;
9192 bfd *ibfd;
9193 struct got_entry *first_tlsld;
9194
9195 htab = ppc_hash_table (info);
9196 if (htab == NULL)
9197 return FALSE;
9198
9199 dynobj = htab->elf.dynobj;
9200 if (dynobj == NULL)
9201 abort ();
9202
9203 if (htab->elf.dynamic_sections_created)
9204 {
9205 /* Set the contents of the .interp section to the interpreter. */
9206 if (info->executable)
9207 {
9208 s = bfd_get_linker_section (dynobj, ".interp");
9209 if (s == NULL)
9210 abort ();
9211 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
9212 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
9213 }
9214 }
9215
9216 /* Set up .got offsets for local syms, and space for local dynamic
9217 relocs. */
9218 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
9219 {
9220 struct got_entry **lgot_ents;
9221 struct got_entry **end_lgot_ents;
9222 struct plt_entry **local_plt;
9223 struct plt_entry **end_local_plt;
9224 unsigned char *lgot_masks;
9225 bfd_size_type locsymcount;
9226 Elf_Internal_Shdr *symtab_hdr;
9227
9228 if (!is_ppc64_elf (ibfd))
9229 continue;
9230
9231 for (s = ibfd->sections; s != NULL; s = s->next)
9232 {
9233 struct ppc_dyn_relocs *p;
9234
9235 for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
9236 {
9237 if (!bfd_is_abs_section (p->sec)
9238 && bfd_is_abs_section (p->sec->output_section))
9239 {
9240 /* Input section has been discarded, either because
9241 it is a copy of a linkonce section or due to
9242 linker script /DISCARD/, so we'll be discarding
9243 the relocs too. */
9244 }
9245 else if (p->count != 0)
9246 {
9247 asection *srel = elf_section_data (p->sec)->sreloc;
9248 if (p->ifunc)
9249 srel = htab->reliplt;
9250 srel->size += p->count * sizeof (Elf64_External_Rela);
9251 if ((p->sec->output_section->flags & SEC_READONLY) != 0)
9252 info->flags |= DF_TEXTREL;
9253 }
9254 }
9255 }
9256
9257 lgot_ents = elf_local_got_ents (ibfd);
9258 if (!lgot_ents)
9259 continue;
9260
9261 symtab_hdr = &elf_symtab_hdr (ibfd);
9262 locsymcount = symtab_hdr->sh_info;
9263 end_lgot_ents = lgot_ents + locsymcount;
9264 local_plt = (struct plt_entry **) end_lgot_ents;
9265 end_local_plt = local_plt + locsymcount;
9266 lgot_masks = (unsigned char *) end_local_plt;
9267 s = ppc64_elf_tdata (ibfd)->got;
9268 for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
9269 {
9270 struct got_entry **pent, *ent;
9271
9272 pent = lgot_ents;
9273 while ((ent = *pent) != NULL)
9274 if (ent->got.refcount > 0)
9275 {
9276 if ((ent->tls_type & *lgot_masks & TLS_LD) != 0)
9277 {
9278 ppc64_tlsld_got (ibfd)->got.refcount += 1;
9279 *pent = ent->next;
9280 }
9281 else
9282 {
9283 unsigned int ent_size = 8;
9284 unsigned int rel_size = sizeof (Elf64_External_Rela);
9285
9286 ent->got.offset = s->size;
9287 if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
9288 {
9289 ent_size *= 2;
9290 rel_size *= 2;
9291 }
9292 s->size += ent_size;
9293 if ((*lgot_masks & PLT_IFUNC) != 0)
9294 {
9295 htab->reliplt->size += rel_size;
9296 htab->got_reli_size += rel_size;
9297 }
9298 else if (info->shared)
9299 {
9300 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
9301 srel->size += rel_size;
9302 }
9303 pent = &ent->next;
9304 }
9305 }
9306 else
9307 *pent = ent->next;
9308 }
9309
9310 /* Allocate space for calls to local STT_GNU_IFUNC syms in .iplt. */
9311 for (; local_plt < end_local_plt; ++local_plt)
9312 {
9313 struct plt_entry *ent;
9314
9315 for (ent = *local_plt; ent != NULL; ent = ent->next)
9316 if (ent->plt.refcount > 0)
9317 {
9318 s = htab->iplt;
9319 ent->plt.offset = s->size;
9320 s->size += PLT_ENTRY_SIZE;
9321
9322 htab->reliplt->size += sizeof (Elf64_External_Rela);
9323 }
9324 else
9325 ent->plt.offset = (bfd_vma) -1;
9326 }
9327 }
9328
9329 /* Allocate global sym .plt and .got entries, and space for global
9330 sym dynamic relocs. */
9331 elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, info);
9332
9333 first_tlsld = NULL;
9334 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
9335 {
9336 struct got_entry *ent;
9337
9338 if (!is_ppc64_elf (ibfd))
9339 continue;
9340
9341 ent = ppc64_tlsld_got (ibfd);
9342 if (ent->got.refcount > 0)
9343 {
9344 if (!htab->do_multi_toc && first_tlsld != NULL)
9345 {
9346 ent->is_indirect = TRUE;
9347 ent->got.ent = first_tlsld;
9348 }
9349 else
9350 {
9351 if (first_tlsld == NULL)
9352 first_tlsld = ent;
9353 s = ppc64_elf_tdata (ibfd)->got;
9354 ent->got.offset = s->size;
9355 ent->owner = ibfd;
9356 s->size += 16;
9357 if (info->shared)
9358 {
9359 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
9360 srel->size += sizeof (Elf64_External_Rela);
9361 }
9362 }
9363 }
9364 else
9365 ent->got.offset = (bfd_vma) -1;
9366 }
9367
9368 /* We now have determined the sizes of the various dynamic sections.
9369 Allocate memory for them. */
9370 relocs = FALSE;
9371 for (s = dynobj->sections; s != NULL; s = s->next)
9372 {
9373 if ((s->flags & SEC_LINKER_CREATED) == 0)
9374 continue;
9375
9376 if (s == htab->brlt || s == htab->relbrlt)
9377 /* These haven't been allocated yet; don't strip. */
9378 continue;
9379 else if (s == htab->got
9380 || s == htab->plt
9381 || s == htab->iplt
9382 || s == htab->glink
9383 || s == htab->dynbss)
9384 {
9385 /* Strip this section if we don't need it; see the
9386 comment below. */
9387 }
9388 else if (s == htab->glink_eh_frame)
9389 {
9390 if (!bfd_is_abs_section (s->output_section))
9391 /* Not sized yet. */
9392 continue;
9393 }
9394 else if (CONST_STRNEQ (s->name, ".rela"))
9395 {
9396 if (s->size != 0)
9397 {
9398 if (s != htab->relplt)
9399 relocs = TRUE;
9400
9401 /* We use the reloc_count field as a counter if we need
9402 to copy relocs into the output file. */
9403 s->reloc_count = 0;
9404 }
9405 }
9406 else
9407 {
9408 /* It's not one of our sections, so don't allocate space. */
9409 continue;
9410 }
9411
9412 if (s->size == 0)
9413 {
9414 /* If we don't need this section, strip it from the
9415 output file. This is mostly to handle .rela.bss and
9416 .rela.plt. We must create both sections in
9417 create_dynamic_sections, because they must be created
9418 before the linker maps input sections to output
9419 sections. The linker does that before
9420 adjust_dynamic_symbol is called, and it is that
9421 function which decides whether anything needs to go
9422 into these sections. */
9423 s->flags |= SEC_EXCLUDE;
9424 continue;
9425 }
9426
9427 if ((s->flags & SEC_HAS_CONTENTS) == 0)
9428 continue;
9429
9430 /* Allocate memory for the section contents. We use bfd_zalloc
9431 here in case unused entries are not reclaimed before the
9432 section's contents are written out. This should not happen,
9433 but this way if it does we get a R_PPC64_NONE reloc in .rela
9434 sections instead of garbage.
9435 We also rely on the section contents being zero when writing
9436 the GOT. */
9437 s->contents = bfd_zalloc (dynobj, s->size);
9438 if (s->contents == NULL)
9439 return FALSE;
9440 }
9441
9442 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
9443 {
9444 if (!is_ppc64_elf (ibfd))
9445 continue;
9446
9447 s = ppc64_elf_tdata (ibfd)->got;
9448 if (s != NULL && s != htab->got)
9449 {
9450 if (s->size == 0)
9451 s->flags |= SEC_EXCLUDE;
9452 else
9453 {
9454 s->contents = bfd_zalloc (ibfd, s->size);
9455 if (s->contents == NULL)
9456 return FALSE;
9457 }
9458 }
9459 s = ppc64_elf_tdata (ibfd)->relgot;
9460 if (s != NULL)
9461 {
9462 if (s->size == 0)
9463 s->flags |= SEC_EXCLUDE;
9464 else
9465 {
9466 s->contents = bfd_zalloc (ibfd, s->size);
9467 if (s->contents == NULL)
9468 return FALSE;
9469 relocs = TRUE;
9470 s->reloc_count = 0;
9471 }
9472 }
9473 }
9474
9475 if (htab->elf.dynamic_sections_created)
9476 {
9477 /* Add some entries to the .dynamic section. We fill in the
9478 values later, in ppc64_elf_finish_dynamic_sections, but we
9479 must add the entries now so that we get the correct size for
9480 the .dynamic section. The DT_DEBUG entry is filled in by the
9481 dynamic linker and used by the debugger. */
9482 #define add_dynamic_entry(TAG, VAL) \
9483 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
9484
9485 if (info->executable)
9486 {
9487 if (!add_dynamic_entry (DT_DEBUG, 0))
9488 return FALSE;
9489 }
9490
9491 if (htab->plt != NULL && htab->plt->size != 0)
9492 {
9493 if (!add_dynamic_entry (DT_PLTGOT, 0)
9494 || !add_dynamic_entry (DT_PLTRELSZ, 0)
9495 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
9496 || !add_dynamic_entry (DT_JMPREL, 0)
9497 || !add_dynamic_entry (DT_PPC64_GLINK, 0))
9498 return FALSE;
9499 }
9500
9501 if (NO_OPD_RELOCS)
9502 {
9503 if (!add_dynamic_entry (DT_PPC64_OPD, 0)
9504 || !add_dynamic_entry (DT_PPC64_OPDSZ, 0))
9505 return FALSE;
9506 }
9507
9508 if (!htab->no_tls_get_addr_opt
9509 && htab->tls_get_addr_fd != NULL
9510 && htab->tls_get_addr_fd->elf.plt.plist != NULL
9511 && !add_dynamic_entry (DT_PPC64_TLSOPT, 0))
9512 return FALSE;
9513
9514 if (relocs)
9515 {
9516 if (!add_dynamic_entry (DT_RELA, 0)
9517 || !add_dynamic_entry (DT_RELASZ, 0)
9518 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
9519 return FALSE;
9520
9521 /* If any dynamic relocs apply to a read-only section,
9522 then we need a DT_TEXTREL entry. */
9523 if ((info->flags & DF_TEXTREL) == 0)
9524 elf_link_hash_traverse (&htab->elf, readonly_dynrelocs, info);
9525
9526 if ((info->flags & DF_TEXTREL) != 0)
9527 {
9528 if (!add_dynamic_entry (DT_TEXTREL, 0))
9529 return FALSE;
9530 }
9531 }
9532 }
9533 #undef add_dynamic_entry
9534
9535 return TRUE;
9536 }
9537
9538 /* Determine the type of stub needed, if any, for a call. */
9539
9540 static inline enum ppc_stub_type
9541 ppc_type_of_stub (asection *input_sec,
9542 const Elf_Internal_Rela *rel,
9543 struct ppc_link_hash_entry **hash,
9544 struct plt_entry **plt_ent,
9545 bfd_vma destination)
9546 {
9547 struct ppc_link_hash_entry *h = *hash;
9548 bfd_vma location;
9549 bfd_vma branch_offset;
9550 bfd_vma max_branch_offset;
9551 enum elf_ppc64_reloc_type r_type;
9552
9553 if (h != NULL)
9554 {
9555 struct plt_entry *ent;
9556 struct ppc_link_hash_entry *fdh = h;
9557 if (h->oh != NULL
9558 && h->oh->is_func_descriptor)
9559 {
9560 fdh = ppc_follow_link (h->oh);
9561 *hash = fdh;
9562 }
9563
9564 for (ent = fdh->elf.plt.plist; ent != NULL; ent = ent->next)
9565 if (ent->addend == rel->r_addend
9566 && ent->plt.offset != (bfd_vma) -1)
9567 {
9568 *plt_ent = ent;
9569 return ppc_stub_plt_call;
9570 }
9571
9572 /* Here, we know we don't have a plt entry. If we don't have a
9573 either a defined function descriptor or a defined entry symbol
9574 in a regular object file, then it is pointless trying to make
9575 any other type of stub. */
9576 if (!is_static_defined (&fdh->elf)
9577 && !is_static_defined (&h->elf))
9578 return ppc_stub_none;
9579 }
9580 else if (elf_local_got_ents (input_sec->owner) != NULL)
9581 {
9582 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (input_sec->owner);
9583 struct plt_entry **local_plt = (struct plt_entry **)
9584 elf_local_got_ents (input_sec->owner) + symtab_hdr->sh_info;
9585 unsigned long r_symndx = ELF64_R_SYM (rel->r_info);
9586
9587 if (local_plt[r_symndx] != NULL)
9588 {
9589 struct plt_entry *ent;
9590
9591 for (ent = local_plt[r_symndx]; ent != NULL; ent = ent->next)
9592 if (ent->addend == rel->r_addend
9593 && ent->plt.offset != (bfd_vma) -1)
9594 {
9595 *plt_ent = ent;
9596 return ppc_stub_plt_call;
9597 }
9598 }
9599 }
9600
9601 /* Determine where the call point is. */
9602 location = (input_sec->output_offset
9603 + input_sec->output_section->vma
9604 + rel->r_offset);
9605
9606 branch_offset = destination - location;
9607 r_type = ELF64_R_TYPE (rel->r_info);
9608
9609 /* Determine if a long branch stub is needed. */
9610 max_branch_offset = 1 << 25;
9611 if (r_type != R_PPC64_REL24)
9612 max_branch_offset = 1 << 15;
9613
9614 if (branch_offset + max_branch_offset >= 2 * max_branch_offset)
9615 /* We need a stub. Figure out whether a long_branch or plt_branch
9616 is needed later. */
9617 return ppc_stub_long_branch;
9618
9619 return ppc_stub_none;
9620 }
9621
9622 /* With power7 weakly ordered memory model, it is possible for ld.so
9623 to update a plt entry in one thread and have another thread see a
9624 stale zero toc entry. To avoid this we need some sort of acquire
9625 barrier in the call stub. One solution is to make the load of the
9626 toc word seem to appear to depend on the load of the function entry
9627 word. Another solution is to test for r2 being zero, and branch to
9628 the appropriate glink entry if so.
9629
9630 . fake dep barrier compare
9631 . ld 11,xxx(2) ld 11,xxx(2)
9632 . mtctr 11 mtctr 11
9633 . xor 11,11,11 ld 2,xxx+8(2)
9634 . add 2,2,11 cmpldi 2,0
9635 . ld 2,xxx+8(2) bnectr+
9636 . bctr b <glink_entry>
9637
9638 The solution involving the compare turns out to be faster, so
9639 that's what we use unless the branch won't reach. */
9640
9641 #define ALWAYS_USE_FAKE_DEP 0
9642 #define ALWAYS_EMIT_R2SAVE 0
9643
9644 #define PPC_LO(v) ((v) & 0xffff)
9645 #define PPC_HI(v) (((v) >> 16) & 0xffff)
9646 #define PPC_HA(v) PPC_HI ((v) + 0x8000)
9647
9648 static inline unsigned int
9649 plt_stub_size (struct ppc_link_hash_table *htab,
9650 struct ppc_stub_hash_entry *stub_entry,
9651 bfd_vma off)
9652 {
9653 unsigned size = PLT_CALL_STUB_SIZE;
9654
9655 if (!(ALWAYS_EMIT_R2SAVE
9656 || stub_entry->stub_type == ppc_stub_plt_call_r2save))
9657 size -= 4;
9658 if (!htab->plt_static_chain)
9659 size -= 4;
9660 if (htab->plt_thread_safe)
9661 size += 8;
9662 if (PPC_HA (off) == 0)
9663 size -= 4;
9664 if (PPC_HA (off + 8 + 8 * htab->plt_static_chain) != PPC_HA (off))
9665 size += 4;
9666 if (stub_entry->h != NULL
9667 && (stub_entry->h == htab->tls_get_addr_fd
9668 || stub_entry->h == htab->tls_get_addr)
9669 && !htab->no_tls_get_addr_opt)
9670 size += 13 * 4;
9671 return size;
9672 }
9673
9674 /* If this stub would cross fewer 2**plt_stub_align boundaries if we align,
9675 then return the padding needed to do so. */
9676 static inline unsigned int
9677 plt_stub_pad (struct ppc_link_hash_table *htab,
9678 struct ppc_stub_hash_entry *stub_entry,
9679 bfd_vma plt_off)
9680 {
9681 int stub_align = 1 << htab->plt_stub_align;
9682 unsigned stub_size = plt_stub_size (htab, stub_entry, plt_off);
9683 bfd_vma stub_off = stub_entry->stub_sec->size;
9684
9685 if (((stub_off + stub_size - 1) & -stub_align) - (stub_off & -stub_align)
9686 > (stub_size & -stub_align))
9687 return stub_align - (stub_off & (stub_align - 1));
9688 return 0;
9689 }
9690
9691 /* Build a .plt call stub. */
9692
9693 static inline bfd_byte *
9694 build_plt_stub (struct ppc_link_hash_table *htab,
9695 struct ppc_stub_hash_entry *stub_entry,
9696 bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
9697 {
9698 bfd *obfd = htab->stub_bfd;
9699 bfd_boolean plt_static_chain = htab->plt_static_chain;
9700 bfd_boolean plt_thread_safe = htab->plt_thread_safe;
9701 bfd_boolean use_fake_dep = plt_thread_safe;
9702 bfd_vma cmp_branch_off = 0;
9703
9704 if (!ALWAYS_USE_FAKE_DEP
9705 && plt_thread_safe
9706 && !(stub_entry->h != NULL
9707 && (stub_entry->h == htab->tls_get_addr_fd
9708 || stub_entry->h == htab->tls_get_addr)
9709 && !htab->no_tls_get_addr_opt))
9710 {
9711 bfd_vma pltoff = stub_entry->plt_ent->plt.offset & ~1;
9712 bfd_vma pltindex = (pltoff - PLT_INITIAL_ENTRY_SIZE) / PLT_ENTRY_SIZE;
9713 bfd_vma glinkoff = GLINK_CALL_STUB_SIZE + pltindex * 8;
9714 bfd_vma to, from;
9715
9716 if (pltindex > 32768)
9717 glinkoff += (pltindex - 32768) * 4;
9718 to = (glinkoff
9719 + htab->glink->output_offset
9720 + htab->glink->output_section->vma);
9721 from = (p - stub_entry->stub_sec->contents
9722 + 4 * (ALWAYS_EMIT_R2SAVE
9723 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
9724 + 4 * (PPC_HA (offset) != 0)
9725 + 4 * (PPC_HA (offset + 8 + 8 * plt_static_chain)
9726 != PPC_HA (offset))
9727 + 4 * (plt_static_chain != 0)
9728 + 20
9729 + stub_entry->stub_sec->output_offset
9730 + stub_entry->stub_sec->output_section->vma);
9731 cmp_branch_off = to - from;
9732 use_fake_dep = cmp_branch_off + (1 << 25) >= (1 << 26);
9733 }
9734
9735 if (PPC_HA (offset) != 0)
9736 {
9737 if (r != NULL)
9738 {
9739 if (ALWAYS_EMIT_R2SAVE
9740 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
9741 r[0].r_offset += 4;
9742 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
9743 r[1].r_offset = r[0].r_offset + 4;
9744 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
9745 r[1].r_addend = r[0].r_addend;
9746 if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
9747 {
9748 r[2].r_offset = r[1].r_offset + 4;
9749 r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO);
9750 r[2].r_addend = r[0].r_addend;
9751 }
9752 else
9753 {
9754 r[2].r_offset = r[1].r_offset + 8 + 8 * use_fake_dep;
9755 r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
9756 r[2].r_addend = r[0].r_addend + 8;
9757 if (plt_static_chain)
9758 {
9759 r[3].r_offset = r[2].r_offset + 4;
9760 r[3].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
9761 r[3].r_addend = r[0].r_addend + 16;
9762 }
9763 }
9764 }
9765 if (ALWAYS_EMIT_R2SAVE
9766 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
9767 bfd_put_32 (obfd, STD_R2_40R1, p), p += 4;
9768 bfd_put_32 (obfd, ADDIS_R12_R2 | PPC_HA (offset), p), p += 4;
9769 bfd_put_32 (obfd, LD_R11_0R12 | PPC_LO (offset), p), p += 4;
9770 if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
9771 {
9772 bfd_put_32 (obfd, ADDI_R12_R12 | PPC_LO (offset), p), p += 4;
9773 offset = 0;
9774 }
9775 bfd_put_32 (obfd, MTCTR_R11, p), p += 4;
9776 if (use_fake_dep)
9777 {
9778 bfd_put_32 (obfd, XOR_R11_R11_R11, p), p += 4;
9779 bfd_put_32 (obfd, ADD_R12_R12_R11, p), p += 4;
9780 }
9781 bfd_put_32 (obfd, LD_R2_0R12 | PPC_LO (offset + 8), p), p += 4;
9782 if (plt_static_chain)
9783 bfd_put_32 (obfd, LD_R11_0R12 | PPC_LO (offset + 16), p), p += 4;
9784 }
9785 else
9786 {
9787 if (r != NULL)
9788 {
9789 if (ALWAYS_EMIT_R2SAVE
9790 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
9791 r[0].r_offset += 4;
9792 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
9793 if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
9794 {
9795 r[1].r_offset = r[0].r_offset + 4;
9796 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16);
9797 r[1].r_addend = r[0].r_addend;
9798 }
9799 else
9800 {
9801 r[1].r_offset = r[0].r_offset + 8 + 8 * use_fake_dep;
9802 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
9803 r[1].r_addend = r[0].r_addend + 8 + 8 * plt_static_chain;
9804 if (plt_static_chain)
9805 {
9806 r[2].r_offset = r[1].r_offset + 4;
9807 r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
9808 r[2].r_addend = r[0].r_addend + 8;
9809 }
9810 }
9811 }
9812 if (ALWAYS_EMIT_R2SAVE
9813 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
9814 bfd_put_32 (obfd, STD_R2_40R1, p), p += 4;
9815 bfd_put_32 (obfd, LD_R11_0R2 | PPC_LO (offset), p), p += 4;
9816 if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
9817 {
9818 bfd_put_32 (obfd, ADDI_R2_R2 | PPC_LO (offset), p), p += 4;
9819 offset = 0;
9820 }
9821 bfd_put_32 (obfd, MTCTR_R11, p), p += 4;
9822 if (use_fake_dep)
9823 {
9824 bfd_put_32 (obfd, XOR_R11_R11_R11, p), p += 4;
9825 bfd_put_32 (obfd, ADD_R2_R2_R11, p), p += 4;
9826 }
9827 if (plt_static_chain)
9828 bfd_put_32 (obfd, LD_R11_0R2 | PPC_LO (offset + 16), p), p += 4;
9829 bfd_put_32 (obfd, LD_R2_0R2 | PPC_LO (offset + 8), p), p += 4;
9830 }
9831 if (plt_thread_safe && !use_fake_dep)
9832 {
9833 bfd_put_32 (obfd, CMPLDI_R2_0, p), p += 4;
9834 bfd_put_32 (obfd, BNECTR_P4, p), p += 4;
9835 bfd_put_32 (obfd, B_DOT | (cmp_branch_off & 0x3fffffc), p), p += 4;
9836 }
9837 else
9838 bfd_put_32 (obfd, BCTR, p), p += 4;
9839 return p;
9840 }
9841
9842 /* Build a special .plt call stub for __tls_get_addr. */
9843
9844 #define LD_R11_0R3 0xe9630000
9845 #define LD_R12_0R3 0xe9830000
9846 #define MR_R0_R3 0x7c601b78
9847 #define CMPDI_R11_0 0x2c2b0000
9848 #define ADD_R3_R12_R13 0x7c6c6a14
9849 #define BEQLR 0x4d820020
9850 #define MR_R3_R0 0x7c030378
9851 #define MFLR_R11 0x7d6802a6
9852 #define STD_R11_0R1 0xf9610000
9853 #define BCTRL 0x4e800421
9854 #define LD_R11_0R1 0xe9610000
9855 #define LD_R2_0R1 0xe8410000
9856 #define MTLR_R11 0x7d6803a6
9857
9858 static inline bfd_byte *
9859 build_tls_get_addr_stub (struct ppc_link_hash_table *htab,
9860 struct ppc_stub_hash_entry *stub_entry,
9861 bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
9862 {
9863 bfd *obfd = htab->stub_bfd;
9864
9865 bfd_put_32 (obfd, LD_R11_0R3 + 0, p), p += 4;
9866 bfd_put_32 (obfd, LD_R12_0R3 + 8, p), p += 4;
9867 bfd_put_32 (obfd, MR_R0_R3, p), p += 4;
9868 bfd_put_32 (obfd, CMPDI_R11_0, p), p += 4;
9869 bfd_put_32 (obfd, ADD_R3_R12_R13, p), p += 4;
9870 bfd_put_32 (obfd, BEQLR, p), p += 4;
9871 bfd_put_32 (obfd, MR_R3_R0, p), p += 4;
9872 bfd_put_32 (obfd, MFLR_R11, p), p += 4;
9873 bfd_put_32 (obfd, STD_R11_0R1 + 32, p), p += 4;
9874
9875 if (r != NULL)
9876 r[0].r_offset += 9 * 4;
9877 p = build_plt_stub (htab, stub_entry, p, offset, r);
9878 bfd_put_32 (obfd, BCTRL, p - 4);
9879
9880 bfd_put_32 (obfd, LD_R11_0R1 + 32, p), p += 4;
9881 bfd_put_32 (obfd, LD_R2_0R1 + 40, p), p += 4;
9882 bfd_put_32 (obfd, MTLR_R11, p), p += 4;
9883 bfd_put_32 (obfd, BLR, p), p += 4;
9884
9885 return p;
9886 }
9887
9888 static Elf_Internal_Rela *
9889 get_relocs (asection *sec, int count)
9890 {
9891 Elf_Internal_Rela *relocs;
9892 struct bfd_elf_section_data *elfsec_data;
9893
9894 elfsec_data = elf_section_data (sec);
9895 relocs = elfsec_data->relocs;
9896 if (relocs == NULL)
9897 {
9898 bfd_size_type relsize;
9899 relsize = sec->reloc_count * sizeof (*relocs);
9900 relocs = bfd_alloc (sec->owner, relsize);
9901 if (relocs == NULL)
9902 return NULL;
9903 elfsec_data->relocs = relocs;
9904 elfsec_data->rela.hdr = bfd_zalloc (sec->owner,
9905 sizeof (Elf_Internal_Shdr));
9906 if (elfsec_data->rela.hdr == NULL)
9907 return NULL;
9908 elfsec_data->rela.hdr->sh_size = (sec->reloc_count
9909 * sizeof (Elf64_External_Rela));
9910 elfsec_data->rela.hdr->sh_entsize = sizeof (Elf64_External_Rela);
9911 sec->reloc_count = 0;
9912 }
9913 relocs += sec->reloc_count;
9914 sec->reloc_count += count;
9915 return relocs;
9916 }
9917
9918 static bfd_vma
9919 get_r2off (struct bfd_link_info *info,
9920 struct ppc_stub_hash_entry *stub_entry)
9921 {
9922 struct ppc_link_hash_table *htab = ppc_hash_table (info);
9923 bfd_vma r2off = htab->stub_group[stub_entry->target_section->id].toc_off;
9924
9925 if (r2off == 0)
9926 {
9927 /* Support linking -R objects. Get the toc pointer from the
9928 opd entry. */
9929 char buf[8];
9930 asection *opd = stub_entry->h->elf.root.u.def.section;
9931 bfd_vma opd_off = stub_entry->h->elf.root.u.def.value;
9932
9933 if (strcmp (opd->name, ".opd") != 0
9934 || opd->reloc_count != 0)
9935 {
9936 info->callbacks->einfo (_("%P: cannot find opd entry toc for `%T'\n"),
9937 stub_entry->h->elf.root.root.string);
9938 bfd_set_error (bfd_error_bad_value);
9939 return 0;
9940 }
9941 if (!bfd_get_section_contents (opd->owner, opd, buf, opd_off + 8, 8))
9942 return 0;
9943 r2off = bfd_get_64 (opd->owner, buf);
9944 r2off -= elf_gp (info->output_bfd);
9945 }
9946 r2off -= htab->stub_group[stub_entry->id_sec->id].toc_off;
9947 return r2off;
9948 }
9949
9950 static bfd_boolean
9951 ppc_build_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
9952 {
9953 struct ppc_stub_hash_entry *stub_entry;
9954 struct ppc_branch_hash_entry *br_entry;
9955 struct bfd_link_info *info;
9956 struct ppc_link_hash_table *htab;
9957 bfd_byte *loc;
9958 bfd_byte *p;
9959 bfd_vma dest, off;
9960 int size;
9961 Elf_Internal_Rela *r;
9962 asection *plt;
9963
9964 /* Massage our args to the form they really have. */
9965 stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
9966 info = in_arg;
9967
9968 htab = ppc_hash_table (info);
9969 if (htab == NULL)
9970 return FALSE;
9971
9972 /* Make a note of the offset within the stubs for this entry. */
9973 stub_entry->stub_offset = stub_entry->stub_sec->size;
9974 loc = stub_entry->stub_sec->contents + stub_entry->stub_offset;
9975
9976 htab->stub_count[stub_entry->stub_type - 1] += 1;
9977 switch (stub_entry->stub_type)
9978 {
9979 case ppc_stub_long_branch:
9980 case ppc_stub_long_branch_r2off:
9981 /* Branches are relative. This is where we are going to. */
9982 off = dest = (stub_entry->target_value
9983 + stub_entry->target_section->output_offset
9984 + stub_entry->target_section->output_section->vma);
9985
9986 /* And this is where we are coming from. */
9987 off -= (stub_entry->stub_offset
9988 + stub_entry->stub_sec->output_offset
9989 + stub_entry->stub_sec->output_section->vma);
9990
9991 size = 4;
9992 if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
9993 {
9994 bfd_vma r2off = get_r2off (info, stub_entry);
9995
9996 if (r2off == 0)
9997 {
9998 htab->stub_error = TRUE;
9999 return FALSE;
10000 }
10001 bfd_put_32 (htab->stub_bfd, STD_R2_40R1, loc);
10002 loc += 4;
10003 size = 12;
10004 if (PPC_HA (r2off) != 0)
10005 {
10006 size = 16;
10007 bfd_put_32 (htab->stub_bfd, ADDIS_R2_R2 | PPC_HA (r2off), loc);
10008 loc += 4;
10009 }
10010 bfd_put_32 (htab->stub_bfd, ADDI_R2_R2 | PPC_LO (r2off), loc);
10011 loc += 4;
10012 off -= size - 4;
10013 }
10014 bfd_put_32 (htab->stub_bfd, B_DOT | (off & 0x3fffffc), loc);
10015
10016 if (off + (1 << 25) >= (bfd_vma) (1 << 26))
10017 {
10018 info->callbacks->einfo
10019 (_("%P: long branch stub `%s' offset overflow\n"),
10020 stub_entry->root.string);
10021 htab->stub_error = TRUE;
10022 return FALSE;
10023 }
10024
10025 if (info->emitrelocations)
10026 {
10027 r = get_relocs (stub_entry->stub_sec, 1);
10028 if (r == NULL)
10029 return FALSE;
10030 r->r_offset = loc - stub_entry->stub_sec->contents;
10031 r->r_info = ELF64_R_INFO (0, R_PPC64_REL24);
10032 r->r_addend = dest;
10033 if (stub_entry->h != NULL)
10034 {
10035 struct elf_link_hash_entry **hashes;
10036 unsigned long symndx;
10037 struct ppc_link_hash_entry *h;
10038
10039 hashes = elf_sym_hashes (htab->stub_bfd);
10040 if (hashes == NULL)
10041 {
10042 bfd_size_type hsize;
10043
10044 hsize = (htab->stub_globals + 1) * sizeof (*hashes);
10045 hashes = bfd_zalloc (htab->stub_bfd, hsize);
10046 if (hashes == NULL)
10047 return FALSE;
10048 elf_sym_hashes (htab->stub_bfd) = hashes;
10049 htab->stub_globals = 1;
10050 }
10051 symndx = htab->stub_globals++;
10052 h = stub_entry->h;
10053 hashes[symndx] = &h->elf;
10054 r->r_info = ELF64_R_INFO (symndx, R_PPC64_REL24);
10055 if (h->oh != NULL && h->oh->is_func)
10056 h = ppc_follow_link (h->oh);
10057 if (h->elf.root.u.def.section != stub_entry->target_section)
10058 /* H is an opd symbol. The addend must be zero. */
10059 r->r_addend = 0;
10060 else
10061 {
10062 off = (h->elf.root.u.def.value
10063 + h->elf.root.u.def.section->output_offset
10064 + h->elf.root.u.def.section->output_section->vma);
10065 r->r_addend -= off;
10066 }
10067 }
10068 }
10069 break;
10070
10071 case ppc_stub_plt_branch:
10072 case ppc_stub_plt_branch_r2off:
10073 br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
10074 stub_entry->root.string + 9,
10075 FALSE, FALSE);
10076 if (br_entry == NULL)
10077 {
10078 info->callbacks->einfo (_("%P: can't find branch stub `%s'\n"),
10079 stub_entry->root.string);
10080 htab->stub_error = TRUE;
10081 return FALSE;
10082 }
10083
10084 dest = (stub_entry->target_value
10085 + stub_entry->target_section->output_offset
10086 + stub_entry->target_section->output_section->vma);
10087
10088 bfd_put_64 (htab->brlt->owner, dest,
10089 htab->brlt->contents + br_entry->offset);
10090
10091 if (br_entry->iter == htab->stub_iteration)
10092 {
10093 br_entry->iter = 0;
10094
10095 if (htab->relbrlt != NULL)
10096 {
10097 /* Create a reloc for the branch lookup table entry. */
10098 Elf_Internal_Rela rela;
10099 bfd_byte *rl;
10100
10101 rela.r_offset = (br_entry->offset
10102 + htab->brlt->output_offset
10103 + htab->brlt->output_section->vma);
10104 rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
10105 rela.r_addend = dest;
10106
10107 rl = htab->relbrlt->contents;
10108 rl += (htab->relbrlt->reloc_count++
10109 * sizeof (Elf64_External_Rela));
10110 bfd_elf64_swap_reloca_out (htab->relbrlt->owner, &rela, rl);
10111 }
10112 else if (info->emitrelocations)
10113 {
10114 r = get_relocs (htab->brlt, 1);
10115 if (r == NULL)
10116 return FALSE;
10117 /* brlt, being SEC_LINKER_CREATED does not go through the
10118 normal reloc processing. Symbols and offsets are not
10119 translated from input file to output file form, so
10120 set up the offset per the output file. */
10121 r->r_offset = (br_entry->offset
10122 + htab->brlt->output_offset
10123 + htab->brlt->output_section->vma);
10124 r->r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
10125 r->r_addend = dest;
10126 }
10127 }
10128
10129 dest = (br_entry->offset
10130 + htab->brlt->output_offset
10131 + htab->brlt->output_section->vma);
10132
10133 off = (dest
10134 - elf_gp (htab->brlt->output_section->owner)
10135 - htab->stub_group[stub_entry->id_sec->id].toc_off);
10136
10137 if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
10138 {
10139 info->callbacks->einfo
10140 (_("%P: linkage table error against `%T'\n"),
10141 stub_entry->root.string);
10142 bfd_set_error (bfd_error_bad_value);
10143 htab->stub_error = TRUE;
10144 return FALSE;
10145 }
10146
10147 if (info->emitrelocations)
10148 {
10149 r = get_relocs (stub_entry->stub_sec, 1 + (PPC_HA (off) != 0));
10150 if (r == NULL)
10151 return FALSE;
10152 r[0].r_offset = loc - stub_entry->stub_sec->contents;
10153 if (bfd_big_endian (info->output_bfd))
10154 r[0].r_offset += 2;
10155 if (stub_entry->stub_type == ppc_stub_plt_branch_r2off)
10156 r[0].r_offset += 4;
10157 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10158 r[0].r_addend = dest;
10159 if (PPC_HA (off) != 0)
10160 {
10161 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
10162 r[1].r_offset = r[0].r_offset + 4;
10163 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10164 r[1].r_addend = r[0].r_addend;
10165 }
10166 }
10167
10168 if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
10169 {
10170 if (PPC_HA (off) != 0)
10171 {
10172 size = 16;
10173 bfd_put_32 (htab->stub_bfd, ADDIS_R12_R2 | PPC_HA (off), loc);
10174 loc += 4;
10175 bfd_put_32 (htab->stub_bfd, LD_R11_0R12 | PPC_LO (off), loc);
10176 }
10177 else
10178 {
10179 size = 12;
10180 bfd_put_32 (htab->stub_bfd, LD_R11_0R2 | PPC_LO (off), loc);
10181 }
10182 }
10183 else
10184 {
10185 bfd_vma r2off = get_r2off (info, stub_entry);
10186
10187 if (r2off == 0)
10188 {
10189 htab->stub_error = TRUE;
10190 return FALSE;
10191 }
10192
10193 bfd_put_32 (htab->stub_bfd, STD_R2_40R1, loc);
10194 loc += 4;
10195 size = 20;
10196 if (PPC_HA (off) != 0)
10197 {
10198 size += 4;
10199 bfd_put_32 (htab->stub_bfd, ADDIS_R12_R2 | PPC_HA (off), loc);
10200 loc += 4;
10201 bfd_put_32 (htab->stub_bfd, LD_R11_0R12 | PPC_LO (off), loc);
10202 loc += 4;
10203 }
10204 else
10205 {
10206 bfd_put_32 (htab->stub_bfd, LD_R11_0R2 | PPC_LO (off), loc);
10207 loc += 4;
10208 }
10209
10210 if (PPC_HA (r2off) != 0)
10211 {
10212 size += 4;
10213 bfd_put_32 (htab->stub_bfd, ADDIS_R2_R2 | PPC_HA (r2off), loc);
10214 loc += 4;
10215 }
10216 bfd_put_32 (htab->stub_bfd, ADDI_R2_R2 | PPC_LO (r2off), loc);
10217 }
10218 loc += 4;
10219 bfd_put_32 (htab->stub_bfd, MTCTR_R11, loc);
10220 loc += 4;
10221 bfd_put_32 (htab->stub_bfd, BCTR, loc);
10222 break;
10223
10224 case ppc_stub_plt_call:
10225 case ppc_stub_plt_call_r2save:
10226 if (stub_entry->h != NULL
10227 && stub_entry->h->is_func_descriptor
10228 && stub_entry->h->oh != NULL)
10229 {
10230 struct ppc_link_hash_entry *fh = ppc_follow_link (stub_entry->h->oh);
10231
10232 /* If the old-ABI "dot-symbol" is undefined make it weak so
10233 we don't get a link error from RELOC_FOR_GLOBAL_SYMBOL.
10234 FIXME: We used to define the symbol on one of the call
10235 stubs instead, which is why we test symbol section id
10236 against htab->top_id in various places. Likely all
10237 these checks could now disappear. */
10238 if (fh->elf.root.type == bfd_link_hash_undefined)
10239 fh->elf.root.type = bfd_link_hash_undefweak;
10240 /* Stop undo_symbol_twiddle changing it back to undefined. */
10241 fh->was_undefined = 0;
10242 }
10243
10244 /* Now build the stub. */
10245 dest = stub_entry->plt_ent->plt.offset & ~1;
10246 if (dest >= (bfd_vma) -2)
10247 abort ();
10248
10249 plt = htab->plt;
10250 if (!htab->elf.dynamic_sections_created
10251 || stub_entry->h == NULL
10252 || stub_entry->h->elf.dynindx == -1)
10253 plt = htab->iplt;
10254
10255 dest += plt->output_offset + plt->output_section->vma;
10256
10257 if (stub_entry->h == NULL
10258 && (stub_entry->plt_ent->plt.offset & 1) == 0)
10259 {
10260 Elf_Internal_Rela rela;
10261 bfd_byte *rl;
10262
10263 rela.r_offset = dest;
10264 rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
10265 rela.r_addend = (stub_entry->target_value
10266 + stub_entry->target_section->output_offset
10267 + stub_entry->target_section->output_section->vma);
10268
10269 rl = (htab->reliplt->contents
10270 + (htab->reliplt->reloc_count++
10271 * sizeof (Elf64_External_Rela)));
10272 bfd_elf64_swap_reloca_out (info->output_bfd, &rela, rl);
10273 stub_entry->plt_ent->plt.offset |= 1;
10274 }
10275
10276 off = (dest
10277 - elf_gp (plt->output_section->owner)
10278 - htab->stub_group[stub_entry->id_sec->id].toc_off);
10279
10280 if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
10281 {
10282 info->callbacks->einfo
10283 (_("%P: linkage table error against `%T'\n"),
10284 stub_entry->h != NULL
10285 ? stub_entry->h->elf.root.root.string
10286 : "<local sym>");
10287 bfd_set_error (bfd_error_bad_value);
10288 htab->stub_error = TRUE;
10289 return FALSE;
10290 }
10291
10292 if (htab->plt_stub_align != 0)
10293 {
10294 unsigned pad = plt_stub_pad (htab, stub_entry, off);
10295
10296 stub_entry->stub_sec->size += pad;
10297 stub_entry->stub_offset = stub_entry->stub_sec->size;
10298 loc += pad;
10299 }
10300
10301 r = NULL;
10302 if (info->emitrelocations)
10303 {
10304 r = get_relocs (stub_entry->stub_sec,
10305 (2
10306 + (PPC_HA (off) != 0)
10307 + (htab->plt_static_chain
10308 && PPC_HA (off + 16) == PPC_HA (off))));
10309 if (r == NULL)
10310 return FALSE;
10311 r[0].r_offset = loc - stub_entry->stub_sec->contents;
10312 if (bfd_big_endian (info->output_bfd))
10313 r[0].r_offset += 2;
10314 r[0].r_addend = dest;
10315 }
10316 if (stub_entry->h != NULL
10317 && (stub_entry->h == htab->tls_get_addr_fd
10318 || stub_entry->h == htab->tls_get_addr)
10319 && !htab->no_tls_get_addr_opt)
10320 p = build_tls_get_addr_stub (htab, stub_entry, loc, off, r);
10321 else
10322 p = build_plt_stub (htab, stub_entry, loc, off, r);
10323 size = p - loc;
10324 break;
10325
10326 default:
10327 BFD_FAIL ();
10328 return FALSE;
10329 }
10330
10331 stub_entry->stub_sec->size += size;
10332
10333 if (htab->emit_stub_syms)
10334 {
10335 struct elf_link_hash_entry *h;
10336 size_t len1, len2;
10337 char *name;
10338 const char *const stub_str[] = { "long_branch",
10339 "long_branch_r2off",
10340 "plt_branch",
10341 "plt_branch_r2off",
10342 "plt_call",
10343 "plt_call" };
10344
10345 len1 = strlen (stub_str[stub_entry->stub_type - 1]);
10346 len2 = strlen (stub_entry->root.string);
10347 name = bfd_malloc (len1 + len2 + 2);
10348 if (name == NULL)
10349 return FALSE;
10350 memcpy (name, stub_entry->root.string, 9);
10351 memcpy (name + 9, stub_str[stub_entry->stub_type - 1], len1);
10352 memcpy (name + len1 + 9, stub_entry->root.string + 8, len2 - 8 + 1);
10353 h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
10354 if (h == NULL)
10355 return FALSE;
10356 if (h->root.type == bfd_link_hash_new)
10357 {
10358 h->root.type = bfd_link_hash_defined;
10359 h->root.u.def.section = stub_entry->stub_sec;
10360 h->root.u.def.value = stub_entry->stub_offset;
10361 h->ref_regular = 1;
10362 h->def_regular = 1;
10363 h->ref_regular_nonweak = 1;
10364 h->forced_local = 1;
10365 h->non_elf = 0;
10366 }
10367 }
10368
10369 return TRUE;
10370 }
10371
10372 /* As above, but don't actually build the stub. Just bump offset so
10373 we know stub section sizes, and select plt_branch stubs where
10374 long_branch stubs won't do. */
10375
10376 static bfd_boolean
10377 ppc_size_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
10378 {
10379 struct ppc_stub_hash_entry *stub_entry;
10380 struct bfd_link_info *info;
10381 struct ppc_link_hash_table *htab;
10382 bfd_vma off;
10383 int size;
10384
10385 /* Massage our args to the form they really have. */
10386 stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
10387 info = in_arg;
10388
10389 htab = ppc_hash_table (info);
10390 if (htab == NULL)
10391 return FALSE;
10392
10393 if (stub_entry->stub_type == ppc_stub_plt_call
10394 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10395 {
10396 asection *plt;
10397 off = stub_entry->plt_ent->plt.offset & ~(bfd_vma) 1;
10398 if (off >= (bfd_vma) -2)
10399 abort ();
10400 plt = htab->plt;
10401 if (!htab->elf.dynamic_sections_created
10402 || stub_entry->h == NULL
10403 || stub_entry->h->elf.dynindx == -1)
10404 plt = htab->iplt;
10405 off += (plt->output_offset
10406 + plt->output_section->vma
10407 - elf_gp (plt->output_section->owner)
10408 - htab->stub_group[stub_entry->id_sec->id].toc_off);
10409
10410 size = plt_stub_size (htab, stub_entry, off);
10411 if (htab->plt_stub_align)
10412 size += plt_stub_pad (htab, stub_entry, off);
10413 if (info->emitrelocations)
10414 {
10415 stub_entry->stub_sec->reloc_count
10416 += (2
10417 + (PPC_HA (off) != 0)
10418 + (htab->plt_static_chain
10419 && PPC_HA (off + 16) == PPC_HA (off)));
10420 stub_entry->stub_sec->flags |= SEC_RELOC;
10421 }
10422 }
10423 else
10424 {
10425 /* ppc_stub_long_branch or ppc_stub_plt_branch, or their r2off
10426 variants. */
10427 bfd_vma r2off = 0;
10428
10429 off = (stub_entry->target_value
10430 + stub_entry->target_section->output_offset
10431 + stub_entry->target_section->output_section->vma);
10432 off -= (stub_entry->stub_sec->size
10433 + stub_entry->stub_sec->output_offset
10434 + stub_entry->stub_sec->output_section->vma);
10435
10436 /* Reset the stub type from the plt variant in case we now
10437 can reach with a shorter stub. */
10438 if (stub_entry->stub_type >= ppc_stub_plt_branch)
10439 stub_entry->stub_type += ppc_stub_long_branch - ppc_stub_plt_branch;
10440
10441 size = 4;
10442 if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
10443 {
10444 r2off = get_r2off (info, stub_entry);
10445 if (r2off == 0)
10446 {
10447 htab->stub_error = TRUE;
10448 return FALSE;
10449 }
10450 size = 12;
10451 if (PPC_HA (r2off) != 0)
10452 size = 16;
10453 off -= size - 4;
10454 }
10455
10456 /* If the branch offset if too big, use a ppc_stub_plt_branch. */
10457 if (off + (1 << 25) >= (bfd_vma) (1 << 26))
10458 {
10459 struct ppc_branch_hash_entry *br_entry;
10460
10461 br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
10462 stub_entry->root.string + 9,
10463 TRUE, FALSE);
10464 if (br_entry == NULL)
10465 {
10466 info->callbacks->einfo (_("%P: can't build branch stub `%s'\n"),
10467 stub_entry->root.string);
10468 htab->stub_error = TRUE;
10469 return FALSE;
10470 }
10471
10472 if (br_entry->iter != htab->stub_iteration)
10473 {
10474 br_entry->iter = htab->stub_iteration;
10475 br_entry->offset = htab->brlt->size;
10476 htab->brlt->size += 8;
10477
10478 if (htab->relbrlt != NULL)
10479 htab->relbrlt->size += sizeof (Elf64_External_Rela);
10480 else if (info->emitrelocations)
10481 {
10482 htab->brlt->reloc_count += 1;
10483 htab->brlt->flags |= SEC_RELOC;
10484 }
10485 }
10486
10487 stub_entry->stub_type += ppc_stub_plt_branch - ppc_stub_long_branch;
10488 off = (br_entry->offset
10489 + htab->brlt->output_offset
10490 + htab->brlt->output_section->vma
10491 - elf_gp (htab->brlt->output_section->owner)
10492 - htab->stub_group[stub_entry->id_sec->id].toc_off);
10493
10494 if (info->emitrelocations)
10495 {
10496 stub_entry->stub_sec->reloc_count += 1 + (PPC_HA (off) != 0);
10497 stub_entry->stub_sec->flags |= SEC_RELOC;
10498 }
10499
10500 if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
10501 {
10502 size = 12;
10503 if (PPC_HA (off) != 0)
10504 size = 16;
10505 }
10506 else
10507 {
10508 size = 20;
10509 if (PPC_HA (off) != 0)
10510 size += 4;
10511
10512 if (PPC_HA (r2off) != 0)
10513 size += 4;
10514 }
10515 }
10516 else if (info->emitrelocations)
10517 {
10518 stub_entry->stub_sec->reloc_count += 1;
10519 stub_entry->stub_sec->flags |= SEC_RELOC;
10520 }
10521 }
10522
10523 stub_entry->stub_sec->size += size;
10524 return TRUE;
10525 }
10526
10527 /* Set up various things so that we can make a list of input sections
10528 for each output section included in the link. Returns -1 on error,
10529 0 when no stubs will be needed, and 1 on success. */
10530
10531 int
10532 ppc64_elf_setup_section_lists
10533 (struct bfd_link_info *info,
10534 asection *(*add_stub_section) (const char *, asection *),
10535 void (*layout_sections_again) (void))
10536 {
10537 bfd *input_bfd;
10538 int top_id, top_index, id;
10539 asection *section;
10540 asection **input_list;
10541 bfd_size_type amt;
10542 struct ppc_link_hash_table *htab = ppc_hash_table (info);
10543
10544 if (htab == NULL)
10545 return -1;
10546 /* Stash our params away. */
10547 htab->add_stub_section = add_stub_section;
10548 htab->layout_sections_again = layout_sections_again;
10549
10550 if (htab->brlt == NULL)
10551 return 0;
10552
10553 /* Find the top input section id. */
10554 for (input_bfd = info->input_bfds, top_id = 3;
10555 input_bfd != NULL;
10556 input_bfd = input_bfd->link_next)
10557 {
10558 for (section = input_bfd->sections;
10559 section != NULL;
10560 section = section->next)
10561 {
10562 if (top_id < section->id)
10563 top_id = section->id;
10564 }
10565 }
10566
10567 htab->top_id = top_id;
10568 amt = sizeof (struct map_stub) * (top_id + 1);
10569 htab->stub_group = bfd_zmalloc (amt);
10570 if (htab->stub_group == NULL)
10571 return -1;
10572
10573 /* Set toc_off for com, und, abs and ind sections. */
10574 for (id = 0; id < 3; id++)
10575 htab->stub_group[id].toc_off = TOC_BASE_OFF;
10576
10577 /* We can't use output_bfd->section_count here to find the top output
10578 section index as some sections may have been removed, and
10579 strip_excluded_output_sections doesn't renumber the indices. */
10580 for (section = info->output_bfd->sections, top_index = 0;
10581 section != NULL;
10582 section = section->next)
10583 {
10584 if (top_index < section->index)
10585 top_index = section->index;
10586 }
10587
10588 htab->top_index = top_index;
10589 amt = sizeof (asection *) * (top_index + 1);
10590 input_list = bfd_zmalloc (amt);
10591 htab->input_list = input_list;
10592 if (input_list == NULL)
10593 return -1;
10594
10595 return 1;
10596 }
10597
10598 /* Set up for first pass at multitoc partitioning. */
10599
10600 void
10601 ppc64_elf_start_multitoc_partition (struct bfd_link_info *info)
10602 {
10603 struct ppc_link_hash_table *htab = ppc_hash_table (info);
10604
10605 elf_gp (info->output_bfd) = ppc64_elf_toc (info->output_bfd);
10606 htab->toc_curr = elf_gp (info->output_bfd);
10607 htab->toc_bfd = NULL;
10608 htab->toc_first_sec = NULL;
10609 }
10610
10611 /* The linker repeatedly calls this function for each TOC input section
10612 and linker generated GOT section. Group input bfds such that the toc
10613 within a group is less than 64k in size. */
10614
10615 bfd_boolean
10616 ppc64_elf_next_toc_section (struct bfd_link_info *info, asection *isec)
10617 {
10618 struct ppc_link_hash_table *htab = ppc_hash_table (info);
10619 bfd_vma addr, off, limit;
10620
10621 if (htab == NULL)
10622 return FALSE;
10623
10624 if (!htab->second_toc_pass)
10625 {
10626 /* Keep track of the first .toc or .got section for this input bfd. */
10627 bfd_boolean new_bfd = htab->toc_bfd != isec->owner;
10628
10629 if (new_bfd)
10630 {
10631 htab->toc_bfd = isec->owner;
10632 htab->toc_first_sec = isec;
10633 }
10634
10635 addr = isec->output_offset + isec->output_section->vma;
10636 off = addr - htab->toc_curr;
10637 limit = 0x80008000;
10638 if (ppc64_elf_tdata (isec->owner)->has_small_toc_reloc)
10639 limit = 0x10000;
10640 if (off + isec->size > limit)
10641 {
10642 addr = (htab->toc_first_sec->output_offset
10643 + htab->toc_first_sec->output_section->vma);
10644 htab->toc_curr = addr;
10645 }
10646
10647 /* toc_curr is the base address of this toc group. Set elf_gp
10648 for the input section to be the offset relative to the
10649 output toc base plus 0x8000. Making the input elf_gp an
10650 offset allows us to move the toc as a whole without
10651 recalculating input elf_gp. */
10652 off = htab->toc_curr - elf_gp (isec->output_section->owner);
10653 off += TOC_BASE_OFF;
10654
10655 /* Die if someone uses a linker script that doesn't keep input
10656 file .toc and .got together. */
10657 if (new_bfd
10658 && elf_gp (isec->owner) != 0
10659 && elf_gp (isec->owner) != off)
10660 return FALSE;
10661
10662 elf_gp (isec->owner) = off;
10663 return TRUE;
10664 }
10665
10666 /* During the second pass toc_first_sec points to the start of
10667 a toc group, and toc_curr is used to track the old elf_gp.
10668 We use toc_bfd to ensure we only look at each bfd once. */
10669 if (htab->toc_bfd == isec->owner)
10670 return TRUE;
10671 htab->toc_bfd = isec->owner;
10672
10673 if (htab->toc_first_sec == NULL
10674 || htab->toc_curr != elf_gp (isec->owner))
10675 {
10676 htab->toc_curr = elf_gp (isec->owner);
10677 htab->toc_first_sec = isec;
10678 }
10679 addr = (htab->toc_first_sec->output_offset
10680 + htab->toc_first_sec->output_section->vma);
10681 off = addr - elf_gp (isec->output_section->owner) + TOC_BASE_OFF;
10682 elf_gp (isec->owner) = off;
10683
10684 return TRUE;
10685 }
10686
10687 /* Called via elf_link_hash_traverse to merge GOT entries for global
10688 symbol H. */
10689
10690 static bfd_boolean
10691 merge_global_got (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
10692 {
10693 if (h->root.type == bfd_link_hash_indirect)
10694 return TRUE;
10695
10696 merge_got_entries (&h->got.glist);
10697
10698 return TRUE;
10699 }
10700
10701 /* Called via elf_link_hash_traverse to allocate GOT entries for global
10702 symbol H. */
10703
10704 static bfd_boolean
10705 reallocate_got (struct elf_link_hash_entry *h, void *inf)
10706 {
10707 struct got_entry *gent;
10708
10709 if (h->root.type == bfd_link_hash_indirect)
10710 return TRUE;
10711
10712 for (gent = h->got.glist; gent != NULL; gent = gent->next)
10713 if (!gent->is_indirect)
10714 allocate_got (h, (struct bfd_link_info *) inf, gent);
10715 return TRUE;
10716 }
10717
10718 /* Called on the first multitoc pass after the last call to
10719 ppc64_elf_next_toc_section. This function removes duplicate GOT
10720 entries. */
10721
10722 bfd_boolean
10723 ppc64_elf_layout_multitoc (struct bfd_link_info *info)
10724 {
10725 struct ppc_link_hash_table *htab = ppc_hash_table (info);
10726 struct bfd *ibfd, *ibfd2;
10727 bfd_boolean done_something;
10728
10729 htab->multi_toc_needed = htab->toc_curr != elf_gp (info->output_bfd);
10730
10731 if (!htab->do_multi_toc)
10732 return FALSE;
10733
10734 /* Merge global sym got entries within a toc group. */
10735 elf_link_hash_traverse (&htab->elf, merge_global_got, info);
10736
10737 /* And tlsld_got. */
10738 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
10739 {
10740 struct got_entry *ent, *ent2;
10741
10742 if (!is_ppc64_elf (ibfd))
10743 continue;
10744
10745 ent = ppc64_tlsld_got (ibfd);
10746 if (!ent->is_indirect
10747 && ent->got.offset != (bfd_vma) -1)
10748 {
10749 for (ibfd2 = ibfd->link_next; ibfd2 != NULL; ibfd2 = ibfd2->link_next)
10750 {
10751 if (!is_ppc64_elf (ibfd2))
10752 continue;
10753
10754 ent2 = ppc64_tlsld_got (ibfd2);
10755 if (!ent2->is_indirect
10756 && ent2->got.offset != (bfd_vma) -1
10757 && elf_gp (ibfd2) == elf_gp (ibfd))
10758 {
10759 ent2->is_indirect = TRUE;
10760 ent2->got.ent = ent;
10761 }
10762 }
10763 }
10764 }
10765
10766 /* Zap sizes of got sections. */
10767 htab->reliplt->rawsize = htab->reliplt->size;
10768 htab->reliplt->size -= htab->got_reli_size;
10769 htab->got_reli_size = 0;
10770
10771 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
10772 {
10773 asection *got, *relgot;
10774
10775 if (!is_ppc64_elf (ibfd))
10776 continue;
10777
10778 got = ppc64_elf_tdata (ibfd)->got;
10779 if (got != NULL)
10780 {
10781 got->rawsize = got->size;
10782 got->size = 0;
10783 relgot = ppc64_elf_tdata (ibfd)->relgot;
10784 relgot->rawsize = relgot->size;
10785 relgot->size = 0;
10786 }
10787 }
10788
10789 /* Now reallocate the got, local syms first. We don't need to
10790 allocate section contents again since we never increase size. */
10791 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
10792 {
10793 struct got_entry **lgot_ents;
10794 struct got_entry **end_lgot_ents;
10795 struct plt_entry **local_plt;
10796 struct plt_entry **end_local_plt;
10797 unsigned char *lgot_masks;
10798 bfd_size_type locsymcount;
10799 Elf_Internal_Shdr *symtab_hdr;
10800 asection *s;
10801
10802 if (!is_ppc64_elf (ibfd))
10803 continue;
10804
10805 lgot_ents = elf_local_got_ents (ibfd);
10806 if (!lgot_ents)
10807 continue;
10808
10809 symtab_hdr = &elf_symtab_hdr (ibfd);
10810 locsymcount = symtab_hdr->sh_info;
10811 end_lgot_ents = lgot_ents + locsymcount;
10812 local_plt = (struct plt_entry **) end_lgot_ents;
10813 end_local_plt = local_plt + locsymcount;
10814 lgot_masks = (unsigned char *) end_local_plt;
10815 s = ppc64_elf_tdata (ibfd)->got;
10816 for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
10817 {
10818 struct got_entry *ent;
10819
10820 for (ent = *lgot_ents; ent != NULL; ent = ent->next)
10821 {
10822 unsigned int ent_size = 8;
10823 unsigned int rel_size = sizeof (Elf64_External_Rela);
10824
10825 ent->got.offset = s->size;
10826 if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
10827 {
10828 ent_size *= 2;
10829 rel_size *= 2;
10830 }
10831 s->size += ent_size;
10832 if ((*lgot_masks & PLT_IFUNC) != 0)
10833 {
10834 htab->reliplt->size += rel_size;
10835 htab->got_reli_size += rel_size;
10836 }
10837 else if (info->shared)
10838 {
10839 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
10840 srel->size += rel_size;
10841 }
10842 }
10843 }
10844 }
10845
10846 elf_link_hash_traverse (&htab->elf, reallocate_got, info);
10847
10848 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
10849 {
10850 struct got_entry *ent;
10851
10852 if (!is_ppc64_elf (ibfd))
10853 continue;
10854
10855 ent = ppc64_tlsld_got (ibfd);
10856 if (!ent->is_indirect
10857 && ent->got.offset != (bfd_vma) -1)
10858 {
10859 asection *s = ppc64_elf_tdata (ibfd)->got;
10860 ent->got.offset = s->size;
10861 s->size += 16;
10862 if (info->shared)
10863 {
10864 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
10865 srel->size += sizeof (Elf64_External_Rela);
10866 }
10867 }
10868 }
10869
10870 done_something = htab->reliplt->rawsize != htab->reliplt->size;
10871 if (!done_something)
10872 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
10873 {
10874 asection *got;
10875
10876 if (!is_ppc64_elf (ibfd))
10877 continue;
10878
10879 got = ppc64_elf_tdata (ibfd)->got;
10880 if (got != NULL)
10881 {
10882 done_something = got->rawsize != got->size;
10883 if (done_something)
10884 break;
10885 }
10886 }
10887
10888 if (done_something)
10889 (*htab->layout_sections_again) ();
10890
10891 /* Set up for second pass over toc sections to recalculate elf_gp
10892 on input sections. */
10893 htab->toc_bfd = NULL;
10894 htab->toc_first_sec = NULL;
10895 htab->second_toc_pass = TRUE;
10896 return done_something;
10897 }
10898
10899 /* Called after second pass of multitoc partitioning. */
10900
10901 void
10902 ppc64_elf_finish_multitoc_partition (struct bfd_link_info *info)
10903 {
10904 struct ppc_link_hash_table *htab = ppc_hash_table (info);
10905
10906 /* After the second pass, toc_curr tracks the TOC offset used
10907 for code sections below in ppc64_elf_next_input_section. */
10908 htab->toc_curr = TOC_BASE_OFF;
10909 }
10910
10911 /* No toc references were found in ISEC. If the code in ISEC makes no
10912 calls, then there's no need to use toc adjusting stubs when branching
10913 into ISEC. Actually, indirect calls from ISEC are OK as they will
10914 load r2. Returns -1 on error, 0 for no stub needed, 1 for stub
10915 needed, and 2 if a cyclical call-graph was found but no other reason
10916 for a stub was detected. If called from the top level, a return of
10917 2 means the same as a return of 0. */
10918
10919 static int
10920 toc_adjusting_stub_needed (struct bfd_link_info *info, asection *isec)
10921 {
10922 int ret;
10923
10924 /* Mark this section as checked. */
10925 isec->call_check_done = 1;
10926
10927 /* We know none of our code bearing sections will need toc stubs. */
10928 if ((isec->flags & SEC_LINKER_CREATED) != 0)
10929 return 0;
10930
10931 if (isec->size == 0)
10932 return 0;
10933
10934 if (isec->output_section == NULL)
10935 return 0;
10936
10937 ret = 0;
10938 if (isec->reloc_count != 0)
10939 {
10940 Elf_Internal_Rela *relstart, *rel;
10941 Elf_Internal_Sym *local_syms;
10942 struct ppc_link_hash_table *htab;
10943
10944 relstart = _bfd_elf_link_read_relocs (isec->owner, isec, NULL, NULL,
10945 info->keep_memory);
10946 if (relstart == NULL)
10947 return -1;
10948
10949 /* Look for branches to outside of this section. */
10950 local_syms = NULL;
10951 htab = ppc_hash_table (info);
10952 if (htab == NULL)
10953 return -1;
10954
10955 for (rel = relstart; rel < relstart + isec->reloc_count; ++rel)
10956 {
10957 enum elf_ppc64_reloc_type r_type;
10958 unsigned long r_symndx;
10959 struct elf_link_hash_entry *h;
10960 struct ppc_link_hash_entry *eh;
10961 Elf_Internal_Sym *sym;
10962 asection *sym_sec;
10963 struct _opd_sec_data *opd;
10964 bfd_vma sym_value;
10965 bfd_vma dest;
10966
10967 r_type = ELF64_R_TYPE (rel->r_info);
10968 if (r_type != R_PPC64_REL24
10969 && r_type != R_PPC64_REL14
10970 && r_type != R_PPC64_REL14_BRTAKEN
10971 && r_type != R_PPC64_REL14_BRNTAKEN)
10972 continue;
10973
10974 r_symndx = ELF64_R_SYM (rel->r_info);
10975 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms, r_symndx,
10976 isec->owner))
10977 {
10978 ret = -1;
10979 break;
10980 }
10981
10982 /* Calls to dynamic lib functions go through a plt call stub
10983 that uses r2. */
10984 eh = (struct ppc_link_hash_entry *) h;
10985 if (eh != NULL
10986 && (eh->elf.plt.plist != NULL
10987 || (eh->oh != NULL
10988 && ppc_follow_link (eh->oh)->elf.plt.plist != NULL)))
10989 {
10990 ret = 1;
10991 break;
10992 }
10993
10994 if (sym_sec == NULL)
10995 /* Ignore other undefined symbols. */
10996 continue;
10997
10998 /* Assume branches to other sections not included in the
10999 link need stubs too, to cover -R and absolute syms. */
11000 if (sym_sec->output_section == NULL)
11001 {
11002 ret = 1;
11003 break;
11004 }
11005
11006 if (h == NULL)
11007 sym_value = sym->st_value;
11008 else
11009 {
11010 if (h->root.type != bfd_link_hash_defined
11011 && h->root.type != bfd_link_hash_defweak)
11012 abort ();
11013 sym_value = h->root.u.def.value;
11014 }
11015 sym_value += rel->r_addend;
11016
11017 /* If this branch reloc uses an opd sym, find the code section. */
11018 opd = get_opd_info (sym_sec);
11019 if (opd != NULL)
11020 {
11021 if (h == NULL && opd->adjust != NULL)
11022 {
11023 long adjust;
11024
11025 adjust = opd->adjust[sym->st_value / 8];
11026 if (adjust == -1)
11027 /* Assume deleted functions won't ever be called. */
11028 continue;
11029 sym_value += adjust;
11030 }
11031
11032 dest = opd_entry_value (sym_sec, sym_value,
11033 &sym_sec, NULL, FALSE);
11034 if (dest == (bfd_vma) -1)
11035 continue;
11036 }
11037 else
11038 dest = (sym_value
11039 + sym_sec->output_offset
11040 + sym_sec->output_section->vma);
11041
11042 /* Ignore branch to self. */
11043 if (sym_sec == isec)
11044 continue;
11045
11046 /* If the called function uses the toc, we need a stub. */
11047 if (sym_sec->has_toc_reloc
11048 || sym_sec->makes_toc_func_call)
11049 {
11050 ret = 1;
11051 break;
11052 }
11053
11054 /* Assume any branch that needs a long branch stub might in fact
11055 need a plt_branch stub. A plt_branch stub uses r2. */
11056 else if (dest - (isec->output_offset
11057 + isec->output_section->vma
11058 + rel->r_offset) + (1 << 25) >= (2 << 25))
11059 {
11060 ret = 1;
11061 break;
11062 }
11063
11064 /* If calling back to a section in the process of being
11065 tested, we can't say for sure that no toc adjusting stubs
11066 are needed, so don't return zero. */
11067 else if (sym_sec->call_check_in_progress)
11068 ret = 2;
11069
11070 /* Branches to another section that itself doesn't have any TOC
11071 references are OK. Recursively call ourselves to check. */
11072 else if (!sym_sec->call_check_done)
11073 {
11074 int recur;
11075
11076 /* Mark current section as indeterminate, so that other
11077 sections that call back to current won't be marked as
11078 known. */
11079 isec->call_check_in_progress = 1;
11080 recur = toc_adjusting_stub_needed (info, sym_sec);
11081 isec->call_check_in_progress = 0;
11082
11083 if (recur != 0)
11084 {
11085 ret = recur;
11086 if (recur != 2)
11087 break;
11088 }
11089 }
11090 }
11091
11092 if (local_syms != NULL
11093 && (elf_symtab_hdr (isec->owner).contents
11094 != (unsigned char *) local_syms))
11095 free (local_syms);
11096 if (elf_section_data (isec)->relocs != relstart)
11097 free (relstart);
11098 }
11099
11100 if ((ret & 1) == 0
11101 && isec->map_head.s != NULL
11102 && (strcmp (isec->output_section->name, ".init") == 0
11103 || strcmp (isec->output_section->name, ".fini") == 0))
11104 {
11105 if (isec->map_head.s->has_toc_reloc
11106 || isec->map_head.s->makes_toc_func_call)
11107 ret = 1;
11108 else if (!isec->map_head.s->call_check_done)
11109 {
11110 int recur;
11111 isec->call_check_in_progress = 1;
11112 recur = toc_adjusting_stub_needed (info, isec->map_head.s);
11113 isec->call_check_in_progress = 0;
11114 if (recur != 0)
11115 ret = recur;
11116 }
11117 }
11118
11119 if (ret == 1)
11120 isec->makes_toc_func_call = 1;
11121
11122 return ret;
11123 }
11124
11125 /* The linker repeatedly calls this function for each input section,
11126 in the order that input sections are linked into output sections.
11127 Build lists of input sections to determine groupings between which
11128 we may insert linker stubs. */
11129
11130 bfd_boolean
11131 ppc64_elf_next_input_section (struct bfd_link_info *info, asection *isec)
11132 {
11133 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11134
11135 if (htab == NULL)
11136 return FALSE;
11137
11138 if ((isec->output_section->flags & SEC_CODE) != 0
11139 && isec->output_section->index <= htab->top_index)
11140 {
11141 asection **list = htab->input_list + isec->output_section->index;
11142 /* Steal the link_sec pointer for our list. */
11143 #define PREV_SEC(sec) (htab->stub_group[(sec)->id].link_sec)
11144 /* This happens to make the list in reverse order,
11145 which is what we want. */
11146 PREV_SEC (isec) = *list;
11147 *list = isec;
11148 }
11149
11150 if (htab->multi_toc_needed)
11151 {
11152 /* If a code section has a function that uses the TOC then we need
11153 to use the right TOC (obviously). Also, make sure that .opd gets
11154 the correct TOC value for R_PPC64_TOC relocs that don't have or
11155 can't find their function symbol (shouldn't ever happen now).
11156 Also specially treat .fixup for the linux kernel. .fixup
11157 contains branches, but only back to the function that hit an
11158 exception. */
11159 if (isec->has_toc_reloc
11160 || (isec->flags & SEC_CODE) == 0
11161 || strcmp (isec->name, ".fixup") == 0)
11162 {
11163 if (elf_gp (isec->owner) != 0)
11164 htab->toc_curr = elf_gp (isec->owner);
11165 }
11166 else
11167 {
11168 if (!isec->call_check_done
11169 && toc_adjusting_stub_needed (info, isec) < 0)
11170 return FALSE;
11171 /* If we make a local call from this section, ie. a branch
11172 without a following nop, then we have no place to put a
11173 toc restoring insn. We must use the same toc group as
11174 the callee.
11175 Testing makes_toc_func_call actually tests for *any*
11176 calls to functions that need a good toc pointer. A more
11177 precise test would be better, as this one will set
11178 incorrect values for pasted .init/.fini fragments.
11179 (Fixed later in check_pasted_section.) */
11180 if (isec->makes_toc_func_call
11181 && elf_gp (isec->owner) != 0)
11182 htab->toc_curr = elf_gp (isec->owner);
11183 }
11184 }
11185
11186 /* Functions that don't use the TOC can belong in any TOC group.
11187 Use the last TOC base. */
11188 htab->stub_group[isec->id].toc_off = htab->toc_curr;
11189 return TRUE;
11190 }
11191
11192 /* Check that all .init and .fini sections use the same toc, if they
11193 have toc relocs. */
11194
11195 static bfd_boolean
11196 check_pasted_section (struct bfd_link_info *info, const char *name)
11197 {
11198 asection *o = bfd_get_section_by_name (info->output_bfd, name);
11199
11200 if (o != NULL)
11201 {
11202 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11203 bfd_vma toc_off = 0;
11204 asection *i;
11205
11206 for (i = o->map_head.s; i != NULL; i = i->map_head.s)
11207 if (i->has_toc_reloc)
11208 {
11209 if (toc_off == 0)
11210 toc_off = htab->stub_group[i->id].toc_off;
11211 else if (toc_off != htab->stub_group[i->id].toc_off)
11212 return FALSE;
11213 }
11214
11215 if (toc_off == 0)
11216 for (i = o->map_head.s; i != NULL; i = i->map_head.s)
11217 if (i->makes_toc_func_call)
11218 {
11219 toc_off = htab->stub_group[i->id].toc_off;
11220 break;
11221 }
11222
11223 /* Make sure the whole pasted function uses the same toc offset. */
11224 if (toc_off != 0)
11225 for (i = o->map_head.s; i != NULL; i = i->map_head.s)
11226 htab->stub_group[i->id].toc_off = toc_off;
11227 }
11228 return TRUE;
11229 }
11230
11231 bfd_boolean
11232 ppc64_elf_check_init_fini (struct bfd_link_info *info)
11233 {
11234 return (check_pasted_section (info, ".init")
11235 & check_pasted_section (info, ".fini"));
11236 }
11237
11238 /* See whether we can group stub sections together. Grouping stub
11239 sections may result in fewer stubs. More importantly, we need to
11240 put all .init* and .fini* stubs at the beginning of the .init or
11241 .fini output sections respectively, because glibc splits the
11242 _init and _fini functions into multiple parts. Putting a stub in
11243 the middle of a function is not a good idea. */
11244
11245 static void
11246 group_sections (struct ppc_link_hash_table *htab,
11247 bfd_size_type stub_group_size,
11248 bfd_boolean stubs_always_before_branch)
11249 {
11250 asection **list;
11251 bfd_size_type stub14_group_size;
11252 bfd_boolean suppress_size_errors;
11253
11254 suppress_size_errors = FALSE;
11255 stub14_group_size = stub_group_size;
11256 if (stub_group_size == 1)
11257 {
11258 /* Default values. */
11259 if (stubs_always_before_branch)
11260 {
11261 stub_group_size = 0x1e00000;
11262 stub14_group_size = 0x7800;
11263 }
11264 else
11265 {
11266 stub_group_size = 0x1c00000;
11267 stub14_group_size = 0x7000;
11268 }
11269 suppress_size_errors = TRUE;
11270 }
11271
11272 list = htab->input_list + htab->top_index;
11273 do
11274 {
11275 asection *tail = *list;
11276 while (tail != NULL)
11277 {
11278 asection *curr;
11279 asection *prev;
11280 bfd_size_type total;
11281 bfd_boolean big_sec;
11282 bfd_vma curr_toc;
11283
11284 curr = tail;
11285 total = tail->size;
11286 big_sec = total > (ppc64_elf_section_data (tail) != NULL
11287 && ppc64_elf_section_data (tail)->has_14bit_branch
11288 ? stub14_group_size : stub_group_size);
11289 if (big_sec && !suppress_size_errors)
11290 (*_bfd_error_handler) (_("%B section %A exceeds stub group size"),
11291 tail->owner, tail);
11292 curr_toc = htab->stub_group[tail->id].toc_off;
11293
11294 while ((prev = PREV_SEC (curr)) != NULL
11295 && ((total += curr->output_offset - prev->output_offset)
11296 < (ppc64_elf_section_data (prev) != NULL
11297 && ppc64_elf_section_data (prev)->has_14bit_branch
11298 ? stub14_group_size : stub_group_size))
11299 && htab->stub_group[prev->id].toc_off == curr_toc)
11300 curr = prev;
11301
11302 /* OK, the size from the start of CURR to the end is less
11303 than stub_group_size and thus can be handled by one stub
11304 section. (or the tail section is itself larger than
11305 stub_group_size, in which case we may be toast.) We
11306 should really be keeping track of the total size of stubs
11307 added here, as stubs contribute to the final output
11308 section size. That's a little tricky, and this way will
11309 only break if stubs added make the total size more than
11310 2^25, ie. for the default stub_group_size, if stubs total
11311 more than 2097152 bytes, or nearly 75000 plt call stubs. */
11312 do
11313 {
11314 prev = PREV_SEC (tail);
11315 /* Set up this stub group. */
11316 htab->stub_group[tail->id].link_sec = curr;
11317 }
11318 while (tail != curr && (tail = prev) != NULL);
11319
11320 /* But wait, there's more! Input sections up to stub_group_size
11321 bytes before the stub section can be handled by it too.
11322 Don't do this if we have a really large section after the
11323 stubs, as adding more stubs increases the chance that
11324 branches may not reach into the stub section. */
11325 if (!stubs_always_before_branch && !big_sec)
11326 {
11327 total = 0;
11328 while (prev != NULL
11329 && ((total += tail->output_offset - prev->output_offset)
11330 < (ppc64_elf_section_data (prev) != NULL
11331 && ppc64_elf_section_data (prev)->has_14bit_branch
11332 ? stub14_group_size : stub_group_size))
11333 && htab->stub_group[prev->id].toc_off == curr_toc)
11334 {
11335 tail = prev;
11336 prev = PREV_SEC (tail);
11337 htab->stub_group[tail->id].link_sec = curr;
11338 }
11339 }
11340 tail = prev;
11341 }
11342 }
11343 while (list-- != htab->input_list);
11344 free (htab->input_list);
11345 #undef PREV_SEC
11346 }
11347
11348 static const unsigned char glink_eh_frame_cie[] =
11349 {
11350 0, 0, 0, 16, /* length. */
11351 0, 0, 0, 0, /* id. */
11352 1, /* CIE version. */
11353 'z', 'R', 0, /* Augmentation string. */
11354 4, /* Code alignment. */
11355 0x78, /* Data alignment. */
11356 65, /* RA reg. */
11357 1, /* Augmentation size. */
11358 DW_EH_PE_pcrel | DW_EH_PE_sdata4, /* FDE encoding. */
11359 DW_CFA_def_cfa, 1, 0 /* def_cfa: r1 offset 0. */
11360 };
11361
11362 /* Stripping output sections is normally done before dynamic section
11363 symbols have been allocated. This function is called later, and
11364 handles cases like htab->brlt which is mapped to its own output
11365 section. */
11366
11367 static void
11368 maybe_strip_output (struct bfd_link_info *info, asection *isec)
11369 {
11370 if (isec->size == 0
11371 && isec->output_section->size == 0
11372 && !(isec->output_section->flags & SEC_KEEP)
11373 && !bfd_section_removed_from_list (info->output_bfd,
11374 isec->output_section)
11375 && elf_section_data (isec->output_section)->dynindx == 0)
11376 {
11377 isec->output_section->flags |= SEC_EXCLUDE;
11378 bfd_section_list_remove (info->output_bfd, isec->output_section);
11379 info->output_bfd->section_count--;
11380 }
11381 }
11382
11383 /* Determine and set the size of the stub section for a final link.
11384
11385 The basic idea here is to examine all the relocations looking for
11386 PC-relative calls to a target that is unreachable with a "bl"
11387 instruction. */
11388
11389 bfd_boolean
11390 ppc64_elf_size_stubs (struct bfd_link_info *info, bfd_signed_vma group_size,
11391 bfd_boolean plt_static_chain, int plt_thread_safe,
11392 int plt_stub_align)
11393 {
11394 bfd_size_type stub_group_size;
11395 bfd_boolean stubs_always_before_branch;
11396 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11397
11398 if (htab == NULL)
11399 return FALSE;
11400
11401 htab->plt_static_chain = plt_static_chain;
11402 htab->plt_stub_align = plt_stub_align;
11403 if (plt_thread_safe == -1 && !info->executable)
11404 plt_thread_safe = 1;
11405 if (plt_thread_safe == -1)
11406 {
11407 static const char *const thread_starter[] =
11408 {
11409 "pthread_create",
11410 /* libstdc++ */
11411 "_ZNSt6thread15_M_start_threadESt10shared_ptrINS_10_Impl_baseEE",
11412 /* librt */
11413 "aio_init", "aio_read", "aio_write", "aio_fsync", "lio_listio",
11414 "mq_notify", "create_timer",
11415 /* libanl */
11416 "getaddrinfo_a",
11417 /* libgomp */
11418 "GOMP_parallel_start",
11419 "GOMP_parallel_loop_static_start",
11420 "GOMP_parallel_loop_dynamic_start",
11421 "GOMP_parallel_loop_guided_start",
11422 "GOMP_parallel_loop_runtime_start",
11423 "GOMP_parallel_sections_start",
11424 };
11425 unsigned i;
11426
11427 for (i = 0; i < sizeof (thread_starter)/ sizeof (thread_starter[0]); i++)
11428 {
11429 struct elf_link_hash_entry *h;
11430 h = elf_link_hash_lookup (&htab->elf, thread_starter[i],
11431 FALSE, FALSE, TRUE);
11432 plt_thread_safe = h != NULL && h->ref_regular;
11433 if (plt_thread_safe)
11434 break;
11435 }
11436 }
11437 htab->plt_thread_safe = plt_thread_safe;
11438 htab->dot_toc_dot = ((struct ppc_link_hash_entry *)
11439 elf_link_hash_lookup (&htab->elf, ".TOC.",
11440 FALSE, FALSE, TRUE));
11441 stubs_always_before_branch = group_size < 0;
11442 if (group_size < 0)
11443 stub_group_size = -group_size;
11444 else
11445 stub_group_size = group_size;
11446
11447 group_sections (htab, stub_group_size, stubs_always_before_branch);
11448
11449 while (1)
11450 {
11451 bfd *input_bfd;
11452 unsigned int bfd_indx;
11453 asection *stub_sec;
11454
11455 htab->stub_iteration += 1;
11456
11457 for (input_bfd = info->input_bfds, bfd_indx = 0;
11458 input_bfd != NULL;
11459 input_bfd = input_bfd->link_next, bfd_indx++)
11460 {
11461 Elf_Internal_Shdr *symtab_hdr;
11462 asection *section;
11463 Elf_Internal_Sym *local_syms = NULL;
11464
11465 if (!is_ppc64_elf (input_bfd))
11466 continue;
11467
11468 /* We'll need the symbol table in a second. */
11469 symtab_hdr = &elf_symtab_hdr (input_bfd);
11470 if (symtab_hdr->sh_info == 0)
11471 continue;
11472
11473 /* Walk over each section attached to the input bfd. */
11474 for (section = input_bfd->sections;
11475 section != NULL;
11476 section = section->next)
11477 {
11478 Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
11479
11480 /* If there aren't any relocs, then there's nothing more
11481 to do. */
11482 if ((section->flags & SEC_RELOC) == 0
11483 || (section->flags & SEC_ALLOC) == 0
11484 || (section->flags & SEC_LOAD) == 0
11485 || (section->flags & SEC_CODE) == 0
11486 || section->reloc_count == 0)
11487 continue;
11488
11489 /* If this section is a link-once section that will be
11490 discarded, then don't create any stubs. */
11491 if (section->output_section == NULL
11492 || section->output_section->owner != info->output_bfd)
11493 continue;
11494
11495 /* Get the relocs. */
11496 internal_relocs
11497 = _bfd_elf_link_read_relocs (input_bfd, section, NULL, NULL,
11498 info->keep_memory);
11499 if (internal_relocs == NULL)
11500 goto error_ret_free_local;
11501
11502 /* Now examine each relocation. */
11503 irela = internal_relocs;
11504 irelaend = irela + section->reloc_count;
11505 for (; irela < irelaend; irela++)
11506 {
11507 enum elf_ppc64_reloc_type r_type;
11508 unsigned int r_indx;
11509 enum ppc_stub_type stub_type;
11510 struct ppc_stub_hash_entry *stub_entry;
11511 asection *sym_sec, *code_sec;
11512 bfd_vma sym_value, code_value;
11513 bfd_vma destination;
11514 bfd_boolean ok_dest;
11515 struct ppc_link_hash_entry *hash;
11516 struct ppc_link_hash_entry *fdh;
11517 struct elf_link_hash_entry *h;
11518 Elf_Internal_Sym *sym;
11519 char *stub_name;
11520 const asection *id_sec;
11521 struct _opd_sec_data *opd;
11522 struct plt_entry *plt_ent;
11523
11524 r_type = ELF64_R_TYPE (irela->r_info);
11525 r_indx = ELF64_R_SYM (irela->r_info);
11526
11527 if (r_type >= R_PPC64_max)
11528 {
11529 bfd_set_error (bfd_error_bad_value);
11530 goto error_ret_free_internal;
11531 }
11532
11533 /* Only look for stubs on branch instructions. */
11534 if (r_type != R_PPC64_REL24
11535 && r_type != R_PPC64_REL14
11536 && r_type != R_PPC64_REL14_BRTAKEN
11537 && r_type != R_PPC64_REL14_BRNTAKEN)
11538 continue;
11539
11540 /* Now determine the call target, its name, value,
11541 section. */
11542 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
11543 r_indx, input_bfd))
11544 goto error_ret_free_internal;
11545 hash = (struct ppc_link_hash_entry *) h;
11546
11547 ok_dest = FALSE;
11548 fdh = NULL;
11549 sym_value = 0;
11550 if (hash == NULL)
11551 {
11552 sym_value = sym->st_value;
11553 ok_dest = TRUE;
11554 }
11555 else if (hash->elf.root.type == bfd_link_hash_defined
11556 || hash->elf.root.type == bfd_link_hash_defweak)
11557 {
11558 sym_value = hash->elf.root.u.def.value;
11559 if (sym_sec->output_section != NULL)
11560 ok_dest = TRUE;
11561 }
11562 else if (hash->elf.root.type == bfd_link_hash_undefweak
11563 || hash->elf.root.type == bfd_link_hash_undefined)
11564 {
11565 /* Recognise an old ABI func code entry sym, and
11566 use the func descriptor sym instead if it is
11567 defined. */
11568 if (hash->elf.root.root.string[0] == '.'
11569 && (fdh = lookup_fdh (hash, htab)) != NULL)
11570 {
11571 if (fdh->elf.root.type == bfd_link_hash_defined
11572 || fdh->elf.root.type == bfd_link_hash_defweak)
11573 {
11574 sym_sec = fdh->elf.root.u.def.section;
11575 sym_value = fdh->elf.root.u.def.value;
11576 if (sym_sec->output_section != NULL)
11577 ok_dest = TRUE;
11578 }
11579 else
11580 fdh = NULL;
11581 }
11582 }
11583 else
11584 {
11585 bfd_set_error (bfd_error_bad_value);
11586 goto error_ret_free_internal;
11587 }
11588
11589 destination = 0;
11590 if (ok_dest)
11591 {
11592 sym_value += irela->r_addend;
11593 destination = (sym_value
11594 + sym_sec->output_offset
11595 + sym_sec->output_section->vma);
11596 }
11597
11598 code_sec = sym_sec;
11599 code_value = sym_value;
11600 opd = get_opd_info (sym_sec);
11601 if (opd != NULL)
11602 {
11603 bfd_vma dest;
11604
11605 if (hash == NULL && opd->adjust != NULL)
11606 {
11607 long adjust = opd->adjust[sym_value / 8];
11608 if (adjust == -1)
11609 continue;
11610 code_value += adjust;
11611 sym_value += adjust;
11612 }
11613 dest = opd_entry_value (sym_sec, sym_value,
11614 &code_sec, &code_value, FALSE);
11615 if (dest != (bfd_vma) -1)
11616 {
11617 destination = dest;
11618 if (fdh != NULL)
11619 {
11620 /* Fixup old ABI sym to point at code
11621 entry. */
11622 hash->elf.root.type = bfd_link_hash_defweak;
11623 hash->elf.root.u.def.section = code_sec;
11624 hash->elf.root.u.def.value = code_value;
11625 }
11626 }
11627 }
11628
11629 /* Determine what (if any) linker stub is needed. */
11630 plt_ent = NULL;
11631 stub_type = ppc_type_of_stub (section, irela, &hash,
11632 &plt_ent, destination);
11633
11634 if (stub_type != ppc_stub_plt_call)
11635 {
11636 /* Check whether we need a TOC adjusting stub.
11637 Since the linker pastes together pieces from
11638 different object files when creating the
11639 _init and _fini functions, it may be that a
11640 call to what looks like a local sym is in
11641 fact a call needing a TOC adjustment. */
11642 if (code_sec != NULL
11643 && code_sec->output_section != NULL
11644 && (htab->stub_group[code_sec->id].toc_off
11645 != htab->stub_group[section->id].toc_off)
11646 && (code_sec->has_toc_reloc
11647 || code_sec->makes_toc_func_call))
11648 stub_type = ppc_stub_long_branch_r2off;
11649 }
11650
11651 if (stub_type == ppc_stub_none)
11652 continue;
11653
11654 /* __tls_get_addr calls might be eliminated. */
11655 if (stub_type != ppc_stub_plt_call
11656 && hash != NULL
11657 && (hash == htab->tls_get_addr
11658 || hash == htab->tls_get_addr_fd)
11659 && section->has_tls_reloc
11660 && irela != internal_relocs)
11661 {
11662 /* Get tls info. */
11663 unsigned char *tls_mask;
11664
11665 if (!get_tls_mask (&tls_mask, NULL, NULL, &local_syms,
11666 irela - 1, input_bfd))
11667 goto error_ret_free_internal;
11668 if (*tls_mask != 0)
11669 continue;
11670 }
11671
11672 if (stub_type == ppc_stub_plt_call
11673 && irela + 1 < irelaend
11674 && irela[1].r_offset == irela->r_offset + 4
11675 && ELF64_R_TYPE (irela[1].r_info) == R_PPC64_TOCSAVE)
11676 {
11677 if (!tocsave_find (htab, INSERT,
11678 &local_syms, irela + 1, input_bfd))
11679 goto error_ret_free_internal;
11680 }
11681 else if (stub_type == ppc_stub_plt_call)
11682 stub_type = ppc_stub_plt_call_r2save;
11683
11684 /* Support for grouping stub sections. */
11685 id_sec = htab->stub_group[section->id].link_sec;
11686
11687 /* Get the name of this stub. */
11688 stub_name = ppc_stub_name (id_sec, sym_sec, hash, irela);
11689 if (!stub_name)
11690 goto error_ret_free_internal;
11691
11692 stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
11693 stub_name, FALSE, FALSE);
11694 if (stub_entry != NULL)
11695 {
11696 /* The proper stub has already been created. */
11697 free (stub_name);
11698 if (stub_type == ppc_stub_plt_call_r2save)
11699 stub_entry->stub_type = stub_type;
11700 continue;
11701 }
11702
11703 stub_entry = ppc_add_stub (stub_name, section, info);
11704 if (stub_entry == NULL)
11705 {
11706 free (stub_name);
11707 error_ret_free_internal:
11708 if (elf_section_data (section)->relocs == NULL)
11709 free (internal_relocs);
11710 error_ret_free_local:
11711 if (local_syms != NULL
11712 && (symtab_hdr->contents
11713 != (unsigned char *) local_syms))
11714 free (local_syms);
11715 return FALSE;
11716 }
11717
11718 stub_entry->stub_type = stub_type;
11719 if (stub_type != ppc_stub_plt_call
11720 && stub_type != ppc_stub_plt_call_r2save)
11721 {
11722 stub_entry->target_value = code_value;
11723 stub_entry->target_section = code_sec;
11724 }
11725 else
11726 {
11727 stub_entry->target_value = sym_value;
11728 stub_entry->target_section = sym_sec;
11729 }
11730 stub_entry->h = hash;
11731 stub_entry->plt_ent = plt_ent;
11732 stub_entry->addend = irela->r_addend;
11733
11734 if (stub_entry->h != NULL)
11735 htab->stub_globals += 1;
11736 }
11737
11738 /* We're done with the internal relocs, free them. */
11739 if (elf_section_data (section)->relocs != internal_relocs)
11740 free (internal_relocs);
11741 }
11742
11743 if (local_syms != NULL
11744 && symtab_hdr->contents != (unsigned char *) local_syms)
11745 {
11746 if (!info->keep_memory)
11747 free (local_syms);
11748 else
11749 symtab_hdr->contents = (unsigned char *) local_syms;
11750 }
11751 }
11752
11753 /* We may have added some stubs. Find out the new size of the
11754 stub sections. */
11755 for (stub_sec = htab->stub_bfd->sections;
11756 stub_sec != NULL;
11757 stub_sec = stub_sec->next)
11758 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
11759 {
11760 stub_sec->rawsize = stub_sec->size;
11761 stub_sec->size = 0;
11762 stub_sec->reloc_count = 0;
11763 stub_sec->flags &= ~SEC_RELOC;
11764 }
11765
11766 htab->brlt->size = 0;
11767 htab->brlt->reloc_count = 0;
11768 htab->brlt->flags &= ~SEC_RELOC;
11769 if (htab->relbrlt != NULL)
11770 htab->relbrlt->size = 0;
11771
11772 bfd_hash_traverse (&htab->stub_hash_table, ppc_size_one_stub, info);
11773
11774 if (info->emitrelocations
11775 && htab->glink != NULL && htab->glink->size != 0)
11776 {
11777 htab->glink->reloc_count = 1;
11778 htab->glink->flags |= SEC_RELOC;
11779 }
11780
11781 if (htab->glink_eh_frame != NULL
11782 && !bfd_is_abs_section (htab->glink_eh_frame->output_section)
11783 && htab->glink_eh_frame->output_section->size != 0)
11784 {
11785 size_t size = 0, align;
11786
11787 for (stub_sec = htab->stub_bfd->sections;
11788 stub_sec != NULL;
11789 stub_sec = stub_sec->next)
11790 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
11791 size += 20;
11792 if (htab->glink != NULL && htab->glink->size != 0)
11793 size += 24;
11794 if (size != 0)
11795 size += sizeof (glink_eh_frame_cie);
11796 align = 1;
11797 align <<= htab->glink_eh_frame->output_section->alignment_power;
11798 align -= 1;
11799 size = (size + align) & ~align;
11800 htab->glink_eh_frame->rawsize = htab->glink_eh_frame->size;
11801 htab->glink_eh_frame->size = size;
11802 }
11803
11804 if (htab->plt_stub_align != 0)
11805 for (stub_sec = htab->stub_bfd->sections;
11806 stub_sec != NULL;
11807 stub_sec = stub_sec->next)
11808 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
11809 stub_sec->size = ((stub_sec->size + (1 << htab->plt_stub_align) - 1)
11810 & (-1 << htab->plt_stub_align));
11811
11812 for (stub_sec = htab->stub_bfd->sections;
11813 stub_sec != NULL;
11814 stub_sec = stub_sec->next)
11815 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
11816 && stub_sec->rawsize != stub_sec->size)
11817 break;
11818
11819 /* Exit from this loop when no stubs have been added, and no stubs
11820 have changed size. */
11821 if (stub_sec == NULL
11822 && (htab->glink_eh_frame == NULL
11823 || htab->glink_eh_frame->rawsize == htab->glink_eh_frame->size))
11824 break;
11825
11826 /* Ask the linker to do its stuff. */
11827 (*htab->layout_sections_again) ();
11828 }
11829
11830 maybe_strip_output (info, htab->brlt);
11831 if (htab->glink_eh_frame != NULL)
11832 maybe_strip_output (info, htab->glink_eh_frame);
11833
11834 return TRUE;
11835 }
11836
11837 /* Called after we have determined section placement. If sections
11838 move, we'll be called again. Provide a value for TOCstart. */
11839
11840 bfd_vma
11841 ppc64_elf_toc (bfd *obfd)
11842 {
11843 asection *s;
11844 bfd_vma TOCstart;
11845
11846 /* The TOC consists of sections .got, .toc, .tocbss, .plt in that
11847 order. The TOC starts where the first of these sections starts. */
11848 s = bfd_get_section_by_name (obfd, ".got");
11849 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
11850 s = bfd_get_section_by_name (obfd, ".toc");
11851 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
11852 s = bfd_get_section_by_name (obfd, ".tocbss");
11853 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
11854 s = bfd_get_section_by_name (obfd, ".plt");
11855 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
11856 {
11857 /* This may happen for
11858 o references to TOC base (SYM@toc / TOC[tc0]) without a
11859 .toc directive
11860 o bad linker script
11861 o --gc-sections and empty TOC sections
11862
11863 FIXME: Warn user? */
11864
11865 /* Look for a likely section. We probably won't even be
11866 using TOCstart. */
11867 for (s = obfd->sections; s != NULL; s = s->next)
11868 if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_READONLY
11869 | SEC_EXCLUDE))
11870 == (SEC_ALLOC | SEC_SMALL_DATA))
11871 break;
11872 if (s == NULL)
11873 for (s = obfd->sections; s != NULL; s = s->next)
11874 if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_EXCLUDE))
11875 == (SEC_ALLOC | SEC_SMALL_DATA))
11876 break;
11877 if (s == NULL)
11878 for (s = obfd->sections; s != NULL; s = s->next)
11879 if ((s->flags & (SEC_ALLOC | SEC_READONLY | SEC_EXCLUDE))
11880 == SEC_ALLOC)
11881 break;
11882 if (s == NULL)
11883 for (s = obfd->sections; s != NULL; s = s->next)
11884 if ((s->flags & (SEC_ALLOC | SEC_EXCLUDE)) == SEC_ALLOC)
11885 break;
11886 }
11887
11888 TOCstart = 0;
11889 if (s != NULL)
11890 TOCstart = s->output_section->vma + s->output_offset;
11891
11892 return TOCstart;
11893 }
11894
11895 /* Build all the stubs associated with the current output file.
11896 The stubs are kept in a hash table attached to the main linker
11897 hash table. This function is called via gldelf64ppc_finish. */
11898
11899 bfd_boolean
11900 ppc64_elf_build_stubs (bfd_boolean emit_stub_syms,
11901 struct bfd_link_info *info,
11902 char **stats)
11903 {
11904 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11905 asection *stub_sec;
11906 bfd_byte *p;
11907 int stub_sec_count = 0;
11908
11909 if (htab == NULL)
11910 return FALSE;
11911
11912 htab->emit_stub_syms = emit_stub_syms;
11913
11914 /* Allocate memory to hold the linker stubs. */
11915 for (stub_sec = htab->stub_bfd->sections;
11916 stub_sec != NULL;
11917 stub_sec = stub_sec->next)
11918 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
11919 && stub_sec->size != 0)
11920 {
11921 stub_sec->contents = bfd_zalloc (htab->stub_bfd, stub_sec->size);
11922 if (stub_sec->contents == NULL)
11923 return FALSE;
11924 /* We want to check that built size is the same as calculated
11925 size. rawsize is a convenient location to use. */
11926 stub_sec->rawsize = stub_sec->size;
11927 stub_sec->size = 0;
11928 }
11929
11930 if (htab->glink != NULL && htab->glink->size != 0)
11931 {
11932 unsigned int indx;
11933 bfd_vma plt0;
11934
11935 /* Build the .glink plt call stub. */
11936 if (htab->emit_stub_syms)
11937 {
11938 struct elf_link_hash_entry *h;
11939 h = elf_link_hash_lookup (&htab->elf, "__glink_PLTresolve",
11940 TRUE, FALSE, FALSE);
11941 if (h == NULL)
11942 return FALSE;
11943 if (h->root.type == bfd_link_hash_new)
11944 {
11945 h->root.type = bfd_link_hash_defined;
11946 h->root.u.def.section = htab->glink;
11947 h->root.u.def.value = 8;
11948 h->ref_regular = 1;
11949 h->def_regular = 1;
11950 h->ref_regular_nonweak = 1;
11951 h->forced_local = 1;
11952 h->non_elf = 0;
11953 }
11954 }
11955 plt0 = htab->plt->output_section->vma + htab->plt->output_offset - 16;
11956 if (info->emitrelocations)
11957 {
11958 Elf_Internal_Rela *r = get_relocs (htab->glink, 1);
11959 if (r == NULL)
11960 return FALSE;
11961 r->r_offset = (htab->glink->output_offset
11962 + htab->glink->output_section->vma);
11963 r->r_info = ELF64_R_INFO (0, R_PPC64_REL64);
11964 r->r_addend = plt0;
11965 }
11966 p = htab->glink->contents;
11967 plt0 -= htab->glink->output_section->vma + htab->glink->output_offset;
11968 bfd_put_64 (htab->glink->owner, plt0, p);
11969 p += 8;
11970 bfd_put_32 (htab->glink->owner, MFLR_R12, p);
11971 p += 4;
11972 bfd_put_32 (htab->glink->owner, BCL_20_31, p);
11973 p += 4;
11974 bfd_put_32 (htab->glink->owner, MFLR_R11, p);
11975 p += 4;
11976 bfd_put_32 (htab->glink->owner, LD_R2_M16R11, p);
11977 p += 4;
11978 bfd_put_32 (htab->glink->owner, MTLR_R12, p);
11979 p += 4;
11980 bfd_put_32 (htab->glink->owner, ADD_R12_R2_R11, p);
11981 p += 4;
11982 bfd_put_32 (htab->glink->owner, LD_R11_0R12, p);
11983 p += 4;
11984 bfd_put_32 (htab->glink->owner, LD_R2_0R12 | 8, p);
11985 p += 4;
11986 bfd_put_32 (htab->glink->owner, MTCTR_R11, p);
11987 p += 4;
11988 bfd_put_32 (htab->glink->owner, LD_R11_0R12 | 16, p);
11989 p += 4;
11990 bfd_put_32 (htab->glink->owner, BCTR, p);
11991 p += 4;
11992 while (p - htab->glink->contents < GLINK_CALL_STUB_SIZE)
11993 {
11994 bfd_put_32 (htab->glink->owner, NOP, p);
11995 p += 4;
11996 }
11997
11998 /* Build the .glink lazy link call stubs. */
11999 indx = 0;
12000 while (p < htab->glink->contents + htab->glink->size)
12001 {
12002 if (indx < 0x8000)
12003 {
12004 bfd_put_32 (htab->glink->owner, LI_R0_0 | indx, p);
12005 p += 4;
12006 }
12007 else
12008 {
12009 bfd_put_32 (htab->glink->owner, LIS_R0_0 | PPC_HI (indx), p);
12010 p += 4;
12011 bfd_put_32 (htab->glink->owner, ORI_R0_R0_0 | PPC_LO (indx), p);
12012 p += 4;
12013 }
12014 bfd_put_32 (htab->glink->owner,
12015 B_DOT | ((htab->glink->contents - p + 8) & 0x3fffffc), p);
12016 indx++;
12017 p += 4;
12018 }
12019 htab->glink->rawsize = p - htab->glink->contents;
12020 }
12021
12022 if (htab->brlt->size != 0)
12023 {
12024 htab->brlt->contents = bfd_zalloc (htab->brlt->owner,
12025 htab->brlt->size);
12026 if (htab->brlt->contents == NULL)
12027 return FALSE;
12028 }
12029 if (htab->relbrlt != NULL && htab->relbrlt->size != 0)
12030 {
12031 htab->relbrlt->contents = bfd_zalloc (htab->relbrlt->owner,
12032 htab->relbrlt->size);
12033 if (htab->relbrlt->contents == NULL)
12034 return FALSE;
12035 }
12036
12037 if (htab->glink_eh_frame != NULL
12038 && htab->glink_eh_frame->size != 0)
12039 {
12040 bfd_vma val;
12041 bfd_byte *last_fde;
12042 size_t last_fde_len, size, align, pad;
12043
12044 p = bfd_zalloc (htab->glink_eh_frame->owner, htab->glink_eh_frame->size);
12045 if (p == NULL)
12046 return FALSE;
12047 htab->glink_eh_frame->contents = p;
12048 last_fde = p;
12049
12050 htab->glink_eh_frame->rawsize = htab->glink_eh_frame->size;
12051
12052 memcpy (p, glink_eh_frame_cie, sizeof (glink_eh_frame_cie));
12053 /* CIE length (rewrite in case little-endian). */
12054 last_fde_len = sizeof (glink_eh_frame_cie) - 4;
12055 bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
12056 p += sizeof (glink_eh_frame_cie);
12057
12058 for (stub_sec = htab->stub_bfd->sections;
12059 stub_sec != NULL;
12060 stub_sec = stub_sec->next)
12061 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12062 {
12063 last_fde = p;
12064 last_fde_len = 16;
12065 /* FDE length. */
12066 bfd_put_32 (htab->elf.dynobj, 16, p);
12067 p += 4;
12068 /* CIE pointer. */
12069 val = p - htab->glink_eh_frame->contents;
12070 bfd_put_32 (htab->elf.dynobj, val, p);
12071 p += 4;
12072 /* Offset to stub section. */
12073 val = (stub_sec->output_section->vma
12074 + stub_sec->output_offset);
12075 val -= (htab->glink_eh_frame->output_section->vma
12076 + htab->glink_eh_frame->output_offset);
12077 val -= p - htab->glink_eh_frame->contents;
12078 if (val + 0x80000000 > 0xffffffff)
12079 {
12080 info->callbacks->einfo
12081 (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
12082 stub_sec->name);
12083 return FALSE;
12084 }
12085 bfd_put_32 (htab->elf.dynobj, val, p);
12086 p += 4;
12087 /* stub section size. */
12088 bfd_put_32 (htab->elf.dynobj, stub_sec->rawsize, p);
12089 p += 4;
12090 /* Augmentation. */
12091 p += 1;
12092 /* Pad. */
12093 p += 3;
12094 }
12095 if (htab->glink != NULL && htab->glink->size != 0)
12096 {
12097 last_fde = p;
12098 last_fde_len = 20;
12099 /* FDE length. */
12100 bfd_put_32 (htab->elf.dynobj, 20, p);
12101 p += 4;
12102 /* CIE pointer. */
12103 val = p - htab->glink_eh_frame->contents;
12104 bfd_put_32 (htab->elf.dynobj, val, p);
12105 p += 4;
12106 /* Offset to .glink. */
12107 val = (htab->glink->output_section->vma
12108 + htab->glink->output_offset
12109 + 8);
12110 val -= (htab->glink_eh_frame->output_section->vma
12111 + htab->glink_eh_frame->output_offset);
12112 val -= p - htab->glink_eh_frame->contents;
12113 if (val + 0x80000000 > 0xffffffff)
12114 {
12115 info->callbacks->einfo
12116 (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
12117 htab->glink->name);
12118 return FALSE;
12119 }
12120 bfd_put_32 (htab->elf.dynobj, val, p);
12121 p += 4;
12122 /* .glink size. */
12123 bfd_put_32 (htab->elf.dynobj, htab->glink->rawsize - 8, p);
12124 p += 4;
12125 /* Augmentation. */
12126 p += 1;
12127
12128 *p++ = DW_CFA_advance_loc + 1;
12129 *p++ = DW_CFA_register;
12130 *p++ = 65;
12131 *p++ = 12;
12132 *p++ = DW_CFA_advance_loc + 4;
12133 *p++ = DW_CFA_restore_extended;
12134 *p++ = 65;
12135 }
12136 /* Subsume any padding into the last FDE if user .eh_frame
12137 sections are aligned more than glink_eh_frame. Otherwise any
12138 zero padding will be seen as a terminator. */
12139 size = p - htab->glink_eh_frame->contents;
12140 align = 1;
12141 align <<= htab->glink_eh_frame->output_section->alignment_power;
12142 align -= 1;
12143 pad = ((size + align) & ~align) - size;
12144 htab->glink_eh_frame->size = size + pad;
12145 bfd_put_32 (htab->elf.dynobj, last_fde_len + pad, last_fde);
12146 }
12147
12148 /* Build the stubs as directed by the stub hash table. */
12149 bfd_hash_traverse (&htab->stub_hash_table, ppc_build_one_stub, info);
12150
12151 if (htab->relbrlt != NULL)
12152 htab->relbrlt->reloc_count = 0;
12153
12154 if (htab->plt_stub_align != 0)
12155 for (stub_sec = htab->stub_bfd->sections;
12156 stub_sec != NULL;
12157 stub_sec = stub_sec->next)
12158 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12159 stub_sec->size = ((stub_sec->size + (1 << htab->plt_stub_align) - 1)
12160 & (-1 << htab->plt_stub_align));
12161
12162 for (stub_sec = htab->stub_bfd->sections;
12163 stub_sec != NULL;
12164 stub_sec = stub_sec->next)
12165 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12166 {
12167 stub_sec_count += 1;
12168 if (stub_sec->rawsize != stub_sec->size)
12169 break;
12170 }
12171
12172 if (stub_sec != NULL
12173 || htab->glink->rawsize != htab->glink->size
12174 || (htab->glink_eh_frame != NULL
12175 && htab->glink_eh_frame->rawsize != htab->glink_eh_frame->size))
12176 {
12177 htab->stub_error = TRUE;
12178 info->callbacks->einfo (_("%P: stubs don't match calculated size\n"));
12179 }
12180
12181 if (htab->stub_error)
12182 return FALSE;
12183
12184 if (stats != NULL)
12185 {
12186 *stats = bfd_malloc (500);
12187 if (*stats == NULL)
12188 return FALSE;
12189
12190 sprintf (*stats, _("linker stubs in %u group%s\n"
12191 " branch %lu\n"
12192 " toc adjust %lu\n"
12193 " long branch %lu\n"
12194 " long toc adj %lu\n"
12195 " plt call %lu\n"
12196 " plt call toc %lu"),
12197 stub_sec_count,
12198 stub_sec_count == 1 ? "" : "s",
12199 htab->stub_count[ppc_stub_long_branch - 1],
12200 htab->stub_count[ppc_stub_long_branch_r2off - 1],
12201 htab->stub_count[ppc_stub_plt_branch - 1],
12202 htab->stub_count[ppc_stub_plt_branch_r2off - 1],
12203 htab->stub_count[ppc_stub_plt_call - 1],
12204 htab->stub_count[ppc_stub_plt_call_r2save - 1]);
12205 }
12206 return TRUE;
12207 }
12208
12209 /* This function undoes the changes made by add_symbol_adjust. */
12210
12211 static bfd_boolean
12212 undo_symbol_twiddle (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
12213 {
12214 struct ppc_link_hash_entry *eh;
12215
12216 if (h->root.type == bfd_link_hash_indirect)
12217 return TRUE;
12218
12219 eh = (struct ppc_link_hash_entry *) h;
12220 if (eh->elf.root.type != bfd_link_hash_undefweak || !eh->was_undefined)
12221 return TRUE;
12222
12223 eh->elf.root.type = bfd_link_hash_undefined;
12224 return TRUE;
12225 }
12226
12227 void
12228 ppc64_elf_restore_symbols (struct bfd_link_info *info)
12229 {
12230 struct ppc_link_hash_table *htab = ppc_hash_table (info);
12231
12232 if (htab != NULL)
12233 elf_link_hash_traverse (&htab->elf, undo_symbol_twiddle, info);
12234 }
12235
12236 /* What to do when ld finds relocations against symbols defined in
12237 discarded sections. */
12238
12239 static unsigned int
12240 ppc64_elf_action_discarded (asection *sec)
12241 {
12242 if (strcmp (".opd", sec->name) == 0)
12243 return 0;
12244
12245 if (strcmp (".toc", sec->name) == 0)
12246 return 0;
12247
12248 if (strcmp (".toc1", sec->name) == 0)
12249 return 0;
12250
12251 return _bfd_elf_default_action_discarded (sec);
12252 }
12253
12254 /* The RELOCATE_SECTION function is called by the ELF backend linker
12255 to handle the relocations for a section.
12256
12257 The relocs are always passed as Rela structures; if the section
12258 actually uses Rel structures, the r_addend field will always be
12259 zero.
12260
12261 This function is responsible for adjust the section contents as
12262 necessary, and (if using Rela relocs and generating a
12263 relocatable output file) adjusting the reloc addend as
12264 necessary.
12265
12266 This function does not have to worry about setting the reloc
12267 address or the reloc symbol index.
12268
12269 LOCAL_SYMS is a pointer to the swapped in local symbols.
12270
12271 LOCAL_SECTIONS is an array giving the section in the input file
12272 corresponding to the st_shndx field of each local symbol.
12273
12274 The global hash table entry for the global symbols can be found
12275 via elf_sym_hashes (input_bfd).
12276
12277 When generating relocatable output, this function must handle
12278 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
12279 going to be the section symbol corresponding to the output
12280 section, which means that the addend must be adjusted
12281 accordingly. */
12282
12283 static bfd_boolean
12284 ppc64_elf_relocate_section (bfd *output_bfd,
12285 struct bfd_link_info *info,
12286 bfd *input_bfd,
12287 asection *input_section,
12288 bfd_byte *contents,
12289 Elf_Internal_Rela *relocs,
12290 Elf_Internal_Sym *local_syms,
12291 asection **local_sections)
12292 {
12293 struct ppc_link_hash_table *htab;
12294 Elf_Internal_Shdr *symtab_hdr;
12295 struct elf_link_hash_entry **sym_hashes;
12296 Elf_Internal_Rela *rel;
12297 Elf_Internal_Rela *relend;
12298 Elf_Internal_Rela outrel;
12299 bfd_byte *loc;
12300 struct got_entry **local_got_ents;
12301 bfd_vma TOCstart;
12302 bfd_boolean ret = TRUE;
12303 bfd_boolean is_opd;
12304 /* Assume 'at' branch hints. */
12305 bfd_boolean is_isa_v2 = TRUE;
12306 bfd_vma d_offset = (bfd_big_endian (output_bfd) ? 2 : 0);
12307
12308 /* Initialize howto table if needed. */
12309 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
12310 ppc_howto_init ();
12311
12312 htab = ppc_hash_table (info);
12313 if (htab == NULL)
12314 return FALSE;
12315
12316 /* Don't relocate stub sections. */
12317 if (input_section->owner == htab->stub_bfd)
12318 return TRUE;
12319
12320 BFD_ASSERT (is_ppc64_elf (input_bfd));
12321
12322 local_got_ents = elf_local_got_ents (input_bfd);
12323 TOCstart = elf_gp (output_bfd);
12324 symtab_hdr = &elf_symtab_hdr (input_bfd);
12325 sym_hashes = elf_sym_hashes (input_bfd);
12326 is_opd = ppc64_elf_section_data (input_section)->sec_type == sec_opd;
12327
12328 rel = relocs;
12329 relend = relocs + input_section->reloc_count;
12330 for (; rel < relend; rel++)
12331 {
12332 enum elf_ppc64_reloc_type r_type;
12333 bfd_vma addend;
12334 bfd_reloc_status_type r;
12335 Elf_Internal_Sym *sym;
12336 asection *sec;
12337 struct elf_link_hash_entry *h_elf;
12338 struct ppc_link_hash_entry *h;
12339 struct ppc_link_hash_entry *fdh;
12340 const char *sym_name;
12341 unsigned long r_symndx, toc_symndx;
12342 bfd_vma toc_addend;
12343 unsigned char tls_mask, tls_gd, tls_type;
12344 unsigned char sym_type;
12345 bfd_vma relocation;
12346 bfd_boolean unresolved_reloc;
12347 bfd_boolean warned;
12348 enum { DEST_NORMAL, DEST_OPD, DEST_STUB } reloc_dest;
12349 unsigned int insn;
12350 unsigned int mask;
12351 struct ppc_stub_hash_entry *stub_entry;
12352 bfd_vma max_br_offset;
12353 bfd_vma from;
12354 const Elf_Internal_Rela orig_rel = *rel;
12355
12356 r_type = ELF64_R_TYPE (rel->r_info);
12357 r_symndx = ELF64_R_SYM (rel->r_info);
12358
12359 /* For old style R_PPC64_TOC relocs with a zero symbol, use the
12360 symbol of the previous ADDR64 reloc. The symbol gives us the
12361 proper TOC base to use. */
12362 if (rel->r_info == ELF64_R_INFO (0, R_PPC64_TOC)
12363 && rel != relocs
12364 && ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_ADDR64
12365 && is_opd)
12366 r_symndx = ELF64_R_SYM (rel[-1].r_info);
12367
12368 sym = NULL;
12369 sec = NULL;
12370 h_elf = NULL;
12371 sym_name = NULL;
12372 unresolved_reloc = FALSE;
12373 warned = FALSE;
12374
12375 if (r_symndx < symtab_hdr->sh_info)
12376 {
12377 /* It's a local symbol. */
12378 struct _opd_sec_data *opd;
12379
12380 sym = local_syms + r_symndx;
12381 sec = local_sections[r_symndx];
12382 sym_name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym, sec);
12383 sym_type = ELF64_ST_TYPE (sym->st_info);
12384 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
12385 opd = get_opd_info (sec);
12386 if (opd != NULL && opd->adjust != NULL)
12387 {
12388 long adjust = opd->adjust[(sym->st_value + rel->r_addend) / 8];
12389 if (adjust == -1)
12390 relocation = 0;
12391 else
12392 {
12393 /* If this is a relocation against the opd section sym
12394 and we have edited .opd, adjust the reloc addend so
12395 that ld -r and ld --emit-relocs output is correct.
12396 If it is a reloc against some other .opd symbol,
12397 then the symbol value will be adjusted later. */
12398 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
12399 rel->r_addend += adjust;
12400 else
12401 relocation += adjust;
12402 }
12403 }
12404 }
12405 else
12406 {
12407 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
12408 r_symndx, symtab_hdr, sym_hashes,
12409 h_elf, sec, relocation,
12410 unresolved_reloc, warned);
12411 sym_name = h_elf->root.root.string;
12412 sym_type = h_elf->type;
12413 if (sec != NULL
12414 && sec->owner == output_bfd
12415 && strcmp (sec->name, ".opd") == 0)
12416 {
12417 /* This is a symbol defined in a linker script. All
12418 such are defined in output sections, even those
12419 defined by simple assignment from a symbol defined in
12420 an input section. Transfer the symbol to an
12421 appropriate input .opd section, so that a branch to
12422 this symbol will be mapped to the location specified
12423 by the opd entry. */
12424 struct bfd_link_order *lo;
12425 for (lo = sec->map_head.link_order; lo != NULL; lo = lo->next)
12426 if (lo->type == bfd_indirect_link_order)
12427 {
12428 asection *isec = lo->u.indirect.section;
12429 if (h_elf->root.u.def.value >= isec->output_offset
12430 && h_elf->root.u.def.value < (isec->output_offset
12431 + isec->size))
12432 {
12433 h_elf->root.u.def.value -= isec->output_offset;
12434 h_elf->root.u.def.section = isec;
12435 sec = isec;
12436 break;
12437 }
12438 }
12439 }
12440 if (h_elf == &htab->dot_toc_dot->elf)
12441 {
12442 relocation = (TOCstart
12443 + htab->stub_group[input_section->id].toc_off);
12444 sec = bfd_abs_section_ptr;
12445 unresolved_reloc = FALSE;
12446 }
12447 }
12448 h = (struct ppc_link_hash_entry *) h_elf;
12449
12450 if (sec != NULL && discarded_section (sec))
12451 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
12452 rel, 1, relend,
12453 ppc64_elf_howto_table[r_type], 0,
12454 contents);
12455
12456 if (info->relocatable)
12457 continue;
12458
12459 /* TLS optimizations. Replace instruction sequences and relocs
12460 based on information we collected in tls_optimize. We edit
12461 RELOCS so that --emit-relocs will output something sensible
12462 for the final instruction stream. */
12463 tls_mask = 0;
12464 tls_gd = 0;
12465 toc_symndx = 0;
12466 if (h != NULL)
12467 tls_mask = h->tls_mask;
12468 else if (local_got_ents != NULL)
12469 {
12470 struct plt_entry **local_plt = (struct plt_entry **)
12471 (local_got_ents + symtab_hdr->sh_info);
12472 unsigned char *lgot_masks = (unsigned char *)
12473 (local_plt + symtab_hdr->sh_info);
12474 tls_mask = lgot_masks[r_symndx];
12475 }
12476 if (tls_mask == 0
12477 && (r_type == R_PPC64_TLS
12478 || r_type == R_PPC64_TLSGD
12479 || r_type == R_PPC64_TLSLD))
12480 {
12481 /* Check for toc tls entries. */
12482 unsigned char *toc_tls;
12483
12484 if (!get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
12485 &local_syms, rel, input_bfd))
12486 return FALSE;
12487
12488 if (toc_tls)
12489 tls_mask = *toc_tls;
12490 }
12491
12492 /* Check that tls relocs are used with tls syms, and non-tls
12493 relocs are used with non-tls syms. */
12494 if (r_symndx != STN_UNDEF
12495 && r_type != R_PPC64_NONE
12496 && (h == NULL
12497 || h->elf.root.type == bfd_link_hash_defined
12498 || h->elf.root.type == bfd_link_hash_defweak)
12499 && (IS_PPC64_TLS_RELOC (r_type)
12500 != (sym_type == STT_TLS
12501 || (sym_type == STT_SECTION
12502 && (sec->flags & SEC_THREAD_LOCAL) != 0))))
12503 {
12504 if (tls_mask != 0
12505 && (r_type == R_PPC64_TLS
12506 || r_type == R_PPC64_TLSGD
12507 || r_type == R_PPC64_TLSLD))
12508 /* R_PPC64_TLS is OK against a symbol in the TOC. */
12509 ;
12510 else
12511 info->callbacks->einfo
12512 (!IS_PPC64_TLS_RELOC (r_type)
12513 ? _("%P: %H: %s used with TLS symbol `%T'\n")
12514 : _("%P: %H: %s used with non-TLS symbol `%T'\n"),
12515 input_bfd, input_section, rel->r_offset,
12516 ppc64_elf_howto_table[r_type]->name,
12517 sym_name);
12518 }
12519
12520 /* Ensure reloc mapping code below stays sane. */
12521 if (R_PPC64_TOC16_LO_DS != R_PPC64_TOC16_DS + 1
12522 || R_PPC64_TOC16_LO != R_PPC64_TOC16 + 1
12523 || (R_PPC64_GOT_TLSLD16 & 3) != (R_PPC64_GOT_TLSGD16 & 3)
12524 || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TLSGD16_LO & 3)
12525 || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TLSGD16_HI & 3)
12526 || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TLSGD16_HA & 3)
12527 || (R_PPC64_GOT_TLSLD16 & 3) != (R_PPC64_GOT_TPREL16_DS & 3)
12528 || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TPREL16_LO_DS & 3)
12529 || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TPREL16_HI & 3)
12530 || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TPREL16_HA & 3))
12531 abort ();
12532
12533 switch (r_type)
12534 {
12535 default:
12536 break;
12537
12538 case R_PPC64_LO_DS_OPT:
12539 insn = bfd_get_32 (output_bfd, contents + rel->r_offset - d_offset);
12540 if ((insn & (0x3f << 26)) != 58u << 26)
12541 abort ();
12542 insn += (14u << 26) - (58u << 26);
12543 bfd_put_32 (output_bfd, insn, contents + rel->r_offset - d_offset);
12544 r_type = R_PPC64_TOC16_LO;
12545 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
12546 break;
12547
12548 case R_PPC64_TOC16:
12549 case R_PPC64_TOC16_LO:
12550 case R_PPC64_TOC16_DS:
12551 case R_PPC64_TOC16_LO_DS:
12552 {
12553 /* Check for toc tls entries. */
12554 unsigned char *toc_tls;
12555 int retval;
12556
12557 retval = get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
12558 &local_syms, rel, input_bfd);
12559 if (retval == 0)
12560 return FALSE;
12561
12562 if (toc_tls)
12563 {
12564 tls_mask = *toc_tls;
12565 if (r_type == R_PPC64_TOC16_DS
12566 || r_type == R_PPC64_TOC16_LO_DS)
12567 {
12568 if (tls_mask != 0
12569 && (tls_mask & (TLS_DTPREL | TLS_TPREL)) == 0)
12570 goto toctprel;
12571 }
12572 else
12573 {
12574 /* If we found a GD reloc pair, then we might be
12575 doing a GD->IE transition. */
12576 if (retval == 2)
12577 {
12578 tls_gd = TLS_TPRELGD;
12579 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
12580 goto tls_ldgd_opt;
12581 }
12582 else if (retval == 3)
12583 {
12584 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
12585 goto tls_ldgd_opt;
12586 }
12587 }
12588 }
12589 }
12590 break;
12591
12592 case R_PPC64_GOT_TPREL16_HI:
12593 case R_PPC64_GOT_TPREL16_HA:
12594 if (tls_mask != 0
12595 && (tls_mask & TLS_TPREL) == 0)
12596 {
12597 rel->r_offset -= d_offset;
12598 bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
12599 r_type = R_PPC64_NONE;
12600 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
12601 }
12602 break;
12603
12604 case R_PPC64_GOT_TPREL16_DS:
12605 case R_PPC64_GOT_TPREL16_LO_DS:
12606 if (tls_mask != 0
12607 && (tls_mask & TLS_TPREL) == 0)
12608 {
12609 toctprel:
12610 insn = bfd_get_32 (output_bfd, contents + rel->r_offset - d_offset);
12611 insn &= 31 << 21;
12612 insn |= 0x3c0d0000; /* addis 0,13,0 */
12613 bfd_put_32 (output_bfd, insn, contents + rel->r_offset - d_offset);
12614 r_type = R_PPC64_TPREL16_HA;
12615 if (toc_symndx != 0)
12616 {
12617 rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
12618 rel->r_addend = toc_addend;
12619 /* We changed the symbol. Start over in order to
12620 get h, sym, sec etc. right. */
12621 rel--;
12622 continue;
12623 }
12624 else
12625 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
12626 }
12627 break;
12628
12629 case R_PPC64_TLS:
12630 if (tls_mask != 0
12631 && (tls_mask & TLS_TPREL) == 0)
12632 {
12633 insn = bfd_get_32 (output_bfd, contents + rel->r_offset);
12634 insn = _bfd_elf_ppc_at_tls_transform (insn, 13);
12635 if (insn == 0)
12636 abort ();
12637 bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
12638 /* Was PPC64_TLS which sits on insn boundary, now
12639 PPC64_TPREL16_LO which is at low-order half-word. */
12640 rel->r_offset += d_offset;
12641 r_type = R_PPC64_TPREL16_LO;
12642 if (toc_symndx != 0)
12643 {
12644 rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
12645 rel->r_addend = toc_addend;
12646 /* We changed the symbol. Start over in order to
12647 get h, sym, sec etc. right. */
12648 rel--;
12649 continue;
12650 }
12651 else
12652 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
12653 }
12654 break;
12655
12656 case R_PPC64_GOT_TLSGD16_HI:
12657 case R_PPC64_GOT_TLSGD16_HA:
12658 tls_gd = TLS_TPRELGD;
12659 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
12660 goto tls_gdld_hi;
12661 break;
12662
12663 case R_PPC64_GOT_TLSLD16_HI:
12664 case R_PPC64_GOT_TLSLD16_HA:
12665 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
12666 {
12667 tls_gdld_hi:
12668 if ((tls_mask & tls_gd) != 0)
12669 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
12670 + R_PPC64_GOT_TPREL16_DS);
12671 else
12672 {
12673 rel->r_offset -= d_offset;
12674 bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
12675 r_type = R_PPC64_NONE;
12676 }
12677 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
12678 }
12679 break;
12680
12681 case R_PPC64_GOT_TLSGD16:
12682 case R_PPC64_GOT_TLSGD16_LO:
12683 tls_gd = TLS_TPRELGD;
12684 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
12685 goto tls_ldgd_opt;
12686 break;
12687
12688 case R_PPC64_GOT_TLSLD16:
12689 case R_PPC64_GOT_TLSLD16_LO:
12690 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
12691 {
12692 unsigned int insn1, insn2, insn3;
12693 bfd_vma offset;
12694
12695 tls_ldgd_opt:
12696 offset = (bfd_vma) -1;
12697 /* If not using the newer R_PPC64_TLSGD/LD to mark
12698 __tls_get_addr calls, we must trust that the call
12699 stays with its arg setup insns, ie. that the next
12700 reloc is the __tls_get_addr call associated with
12701 the current reloc. Edit both insns. */
12702 if (input_section->has_tls_get_addr_call
12703 && rel + 1 < relend
12704 && branch_reloc_hash_match (input_bfd, rel + 1,
12705 htab->tls_get_addr,
12706 htab->tls_get_addr_fd))
12707 offset = rel[1].r_offset;
12708 if ((tls_mask & tls_gd) != 0)
12709 {
12710 /* IE */
12711 insn1 = bfd_get_32 (output_bfd,
12712 contents + rel->r_offset - d_offset);
12713 insn1 &= (1 << 26) - (1 << 2);
12714 insn1 |= 58 << 26; /* ld */
12715 insn2 = 0x7c636a14; /* add 3,3,13 */
12716 if (offset != (bfd_vma) -1)
12717 rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
12718 if ((tls_mask & TLS_EXPLICIT) == 0)
12719 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
12720 + R_PPC64_GOT_TPREL16_DS);
12721 else
12722 r_type += R_PPC64_TOC16_DS - R_PPC64_TOC16;
12723 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
12724 }
12725 else
12726 {
12727 /* LE */
12728 insn1 = 0x3c6d0000; /* addis 3,13,0 */
12729 insn2 = 0x38630000; /* addi 3,3,0 */
12730 if (tls_gd == 0)
12731 {
12732 /* Was an LD reloc. */
12733 if (toc_symndx)
12734 sec = local_sections[toc_symndx];
12735 for (r_symndx = 0;
12736 r_symndx < symtab_hdr->sh_info;
12737 r_symndx++)
12738 if (local_sections[r_symndx] == sec)
12739 break;
12740 if (r_symndx >= symtab_hdr->sh_info)
12741 r_symndx = STN_UNDEF;
12742 rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
12743 if (r_symndx != STN_UNDEF)
12744 rel->r_addend -= (local_syms[r_symndx].st_value
12745 + sec->output_offset
12746 + sec->output_section->vma);
12747 }
12748 else if (toc_symndx != 0)
12749 {
12750 r_symndx = toc_symndx;
12751 rel->r_addend = toc_addend;
12752 }
12753 r_type = R_PPC64_TPREL16_HA;
12754 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
12755 if (offset != (bfd_vma) -1)
12756 {
12757 rel[1].r_info = ELF64_R_INFO (r_symndx,
12758 R_PPC64_TPREL16_LO);
12759 rel[1].r_offset = offset + d_offset;
12760 rel[1].r_addend = rel->r_addend;
12761 }
12762 }
12763 bfd_put_32 (output_bfd, insn1,
12764 contents + rel->r_offset - d_offset);
12765 if (offset != (bfd_vma) -1)
12766 {
12767 insn3 = bfd_get_32 (output_bfd,
12768 contents + offset + 4);
12769 if (insn3 == NOP
12770 || insn3 == CROR_151515 || insn3 == CROR_313131)
12771 {
12772 rel[1].r_offset += 4;
12773 bfd_put_32 (output_bfd, insn2, contents + offset + 4);
12774 insn2 = NOP;
12775 }
12776 bfd_put_32 (output_bfd, insn2, contents + offset);
12777 }
12778 if ((tls_mask & tls_gd) == 0
12779 && (tls_gd == 0 || toc_symndx != 0))
12780 {
12781 /* We changed the symbol. Start over in order
12782 to get h, sym, sec etc. right. */
12783 rel--;
12784 continue;
12785 }
12786 }
12787 break;
12788
12789 case R_PPC64_TLSGD:
12790 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
12791 {
12792 unsigned int insn2, insn3;
12793 bfd_vma offset = rel->r_offset;
12794
12795 if ((tls_mask & TLS_TPRELGD) != 0)
12796 {
12797 /* IE */
12798 r_type = R_PPC64_NONE;
12799 insn2 = 0x7c636a14; /* add 3,3,13 */
12800 }
12801 else
12802 {
12803 /* LE */
12804 if (toc_symndx != 0)
12805 {
12806 r_symndx = toc_symndx;
12807 rel->r_addend = toc_addend;
12808 }
12809 r_type = R_PPC64_TPREL16_LO;
12810 rel->r_offset = offset + d_offset;
12811 insn2 = 0x38630000; /* addi 3,3,0 */
12812 }
12813 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
12814 /* Zap the reloc on the _tls_get_addr call too. */
12815 BFD_ASSERT (offset == rel[1].r_offset);
12816 rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
12817 insn3 = bfd_get_32 (output_bfd,
12818 contents + offset + 4);
12819 if (insn3 == NOP
12820 || insn3 == CROR_151515 || insn3 == CROR_313131)
12821 {
12822 rel->r_offset += 4;
12823 bfd_put_32 (output_bfd, insn2, contents + offset + 4);
12824 insn2 = NOP;
12825 }
12826 bfd_put_32 (output_bfd, insn2, contents + offset);
12827 if ((tls_mask & TLS_TPRELGD) == 0 && toc_symndx != 0)
12828 {
12829 rel--;
12830 continue;
12831 }
12832 }
12833 break;
12834
12835 case R_PPC64_TLSLD:
12836 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
12837 {
12838 unsigned int insn2, insn3;
12839 bfd_vma offset = rel->r_offset;
12840
12841 if (toc_symndx)
12842 sec = local_sections[toc_symndx];
12843 for (r_symndx = 0;
12844 r_symndx < symtab_hdr->sh_info;
12845 r_symndx++)
12846 if (local_sections[r_symndx] == sec)
12847 break;
12848 if (r_symndx >= symtab_hdr->sh_info)
12849 r_symndx = STN_UNDEF;
12850 rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
12851 if (r_symndx != STN_UNDEF)
12852 rel->r_addend -= (local_syms[r_symndx].st_value
12853 + sec->output_offset
12854 + sec->output_section->vma);
12855
12856 r_type = R_PPC64_TPREL16_LO;
12857 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
12858 rel->r_offset = offset + d_offset;
12859 /* Zap the reloc on the _tls_get_addr call too. */
12860 BFD_ASSERT (offset == rel[1].r_offset);
12861 rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
12862 insn2 = 0x38630000; /* addi 3,3,0 */
12863 insn3 = bfd_get_32 (output_bfd,
12864 contents + offset + 4);
12865 if (insn3 == NOP
12866 || insn3 == CROR_151515 || insn3 == CROR_313131)
12867 {
12868 rel->r_offset += 4;
12869 bfd_put_32 (output_bfd, insn2, contents + offset + 4);
12870 insn2 = NOP;
12871 }
12872 bfd_put_32 (output_bfd, insn2, contents + offset);
12873 rel--;
12874 continue;
12875 }
12876 break;
12877
12878 case R_PPC64_DTPMOD64:
12879 if (rel + 1 < relend
12880 && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
12881 && rel[1].r_offset == rel->r_offset + 8)
12882 {
12883 if ((tls_mask & TLS_GD) == 0)
12884 {
12885 rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_NONE);
12886 if ((tls_mask & TLS_TPRELGD) != 0)
12887 r_type = R_PPC64_TPREL64;
12888 else
12889 {
12890 bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
12891 r_type = R_PPC64_NONE;
12892 }
12893 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
12894 }
12895 }
12896 else
12897 {
12898 if ((tls_mask & TLS_LD) == 0)
12899 {
12900 bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
12901 r_type = R_PPC64_NONE;
12902 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
12903 }
12904 }
12905 break;
12906
12907 case R_PPC64_TPREL64:
12908 if ((tls_mask & TLS_TPREL) == 0)
12909 {
12910 r_type = R_PPC64_NONE;
12911 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
12912 }
12913 break;
12914 }
12915
12916 /* Handle other relocations that tweak non-addend part of insn. */
12917 insn = 0;
12918 max_br_offset = 1 << 25;
12919 addend = rel->r_addend;
12920 reloc_dest = DEST_NORMAL;
12921 switch (r_type)
12922 {
12923 default:
12924 break;
12925
12926 case R_PPC64_TOCSAVE:
12927 if (relocation + addend == (rel->r_offset
12928 + input_section->output_offset
12929 + input_section->output_section->vma)
12930 && tocsave_find (htab, NO_INSERT,
12931 &local_syms, rel, input_bfd))
12932 {
12933 insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
12934 if (insn == NOP
12935 || insn == CROR_151515 || insn == CROR_313131)
12936 bfd_put_32 (input_bfd, STD_R2_40R1,
12937 contents + rel->r_offset);
12938 }
12939 break;
12940
12941 /* Branch taken prediction relocations. */
12942 case R_PPC64_ADDR14_BRTAKEN:
12943 case R_PPC64_REL14_BRTAKEN:
12944 insn = 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field. */
12945 /* Fall thru. */
12946
12947 /* Branch not taken prediction relocations. */
12948 case R_PPC64_ADDR14_BRNTAKEN:
12949 case R_PPC64_REL14_BRNTAKEN:
12950 insn |= bfd_get_32 (output_bfd,
12951 contents + rel->r_offset) & ~(0x01 << 21);
12952 /* Fall thru. */
12953
12954 case R_PPC64_REL14:
12955 max_br_offset = 1 << 15;
12956 /* Fall thru. */
12957
12958 case R_PPC64_REL24:
12959 /* Calls to functions with a different TOC, such as calls to
12960 shared objects, need to alter the TOC pointer. This is
12961 done using a linkage stub. A REL24 branching to these
12962 linkage stubs needs to be followed by a nop, as the nop
12963 will be replaced with an instruction to restore the TOC
12964 base pointer. */
12965 fdh = h;
12966 if (h != NULL
12967 && h->oh != NULL
12968 && h->oh->is_func_descriptor)
12969 fdh = ppc_follow_link (h->oh);
12970 stub_entry = ppc_get_stub_entry (input_section, sec, fdh, &orig_rel,
12971 htab);
12972 if (stub_entry != NULL
12973 && (stub_entry->stub_type == ppc_stub_plt_call
12974 || stub_entry->stub_type == ppc_stub_plt_call_r2save
12975 || stub_entry->stub_type == ppc_stub_plt_branch_r2off
12976 || stub_entry->stub_type == ppc_stub_long_branch_r2off))
12977 {
12978 bfd_boolean can_plt_call = FALSE;
12979
12980 if (rel->r_offset + 8 <= input_section->size)
12981 {
12982 unsigned long nop;
12983 nop = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
12984 if (nop == NOP
12985 || nop == CROR_151515 || nop == CROR_313131)
12986 {
12987 if (h != NULL
12988 && (h == htab->tls_get_addr_fd
12989 || h == htab->tls_get_addr)
12990 && !htab->no_tls_get_addr_opt)
12991 {
12992 /* Special stub used, leave nop alone. */
12993 }
12994 else
12995 bfd_put_32 (input_bfd, LD_R2_40R1,
12996 contents + rel->r_offset + 4);
12997 can_plt_call = TRUE;
12998 }
12999 }
13000
13001 if (!can_plt_call)
13002 {
13003 if (stub_entry->stub_type == ppc_stub_plt_call
13004 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
13005 {
13006 /* If this is a plain branch rather than a branch
13007 and link, don't require a nop. However, don't
13008 allow tail calls in a shared library as they
13009 will result in r2 being corrupted. */
13010 unsigned long br;
13011 br = bfd_get_32 (input_bfd, contents + rel->r_offset);
13012 if (info->executable && (br & 1) == 0)
13013 can_plt_call = TRUE;
13014 else
13015 stub_entry = NULL;
13016 }
13017 else if (h != NULL
13018 && strcmp (h->elf.root.root.string,
13019 ".__libc_start_main") == 0)
13020 {
13021 /* Allow crt1 branch to go via a toc adjusting stub. */
13022 can_plt_call = TRUE;
13023 }
13024 else
13025 {
13026 info->callbacks->einfo
13027 (_("%P: %H: call to `%T' lacks nop, can't restore toc; "
13028 "recompile with -fPIC"),
13029 input_bfd, input_section, rel->r_offset, sym_name);
13030
13031 bfd_set_error (bfd_error_bad_value);
13032 ret = FALSE;
13033 }
13034 }
13035
13036 if (can_plt_call
13037 && (stub_entry->stub_type == ppc_stub_plt_call
13038 || stub_entry->stub_type == ppc_stub_plt_call_r2save))
13039 unresolved_reloc = FALSE;
13040 }
13041
13042 if ((stub_entry == NULL
13043 || stub_entry->stub_type == ppc_stub_long_branch
13044 || stub_entry->stub_type == ppc_stub_plt_branch)
13045 && get_opd_info (sec) != NULL)
13046 {
13047 /* The branch destination is the value of the opd entry. */
13048 bfd_vma off = (relocation + addend
13049 - sec->output_section->vma
13050 - sec->output_offset);
13051 bfd_vma dest = opd_entry_value (sec, off, NULL, NULL, FALSE);
13052 if (dest != (bfd_vma) -1)
13053 {
13054 relocation = dest;
13055 addend = 0;
13056 reloc_dest = DEST_OPD;
13057 }
13058 }
13059
13060 /* If the branch is out of reach we ought to have a long
13061 branch stub. */
13062 from = (rel->r_offset
13063 + input_section->output_offset
13064 + input_section->output_section->vma);
13065
13066 if (stub_entry != NULL
13067 && (stub_entry->stub_type == ppc_stub_long_branch
13068 || stub_entry->stub_type == ppc_stub_plt_branch)
13069 && (r_type == R_PPC64_ADDR14_BRTAKEN
13070 || r_type == R_PPC64_ADDR14_BRNTAKEN
13071 || (relocation + addend - from + max_br_offset
13072 < 2 * max_br_offset)))
13073 /* Don't use the stub if this branch is in range. */
13074 stub_entry = NULL;
13075
13076 if (stub_entry != NULL)
13077 {
13078 /* Munge up the value and addend so that we call the stub
13079 rather than the procedure directly. */
13080 relocation = (stub_entry->stub_offset
13081 + stub_entry->stub_sec->output_offset
13082 + stub_entry->stub_sec->output_section->vma);
13083 addend = 0;
13084 reloc_dest = DEST_STUB;
13085
13086 if ((stub_entry->stub_type == ppc_stub_plt_call
13087 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
13088 && (ALWAYS_EMIT_R2SAVE
13089 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
13090 && rel + 1 < relend
13091 && rel[1].r_offset == rel->r_offset + 4
13092 && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOCSAVE)
13093 relocation += 4;
13094 }
13095
13096 if (insn != 0)
13097 {
13098 if (is_isa_v2)
13099 {
13100 /* Set 'a' bit. This is 0b00010 in BO field for branch
13101 on CR(BI) insns (BO == 001at or 011at), and 0b01000
13102 for branch on CTR insns (BO == 1a00t or 1a01t). */
13103 if ((insn & (0x14 << 21)) == (0x04 << 21))
13104 insn |= 0x02 << 21;
13105 else if ((insn & (0x14 << 21)) == (0x10 << 21))
13106 insn |= 0x08 << 21;
13107 else
13108 break;
13109 }
13110 else
13111 {
13112 /* Invert 'y' bit if not the default. */
13113 if ((bfd_signed_vma) (relocation + addend - from) < 0)
13114 insn ^= 0x01 << 21;
13115 }
13116
13117 bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
13118 }
13119
13120 /* NOP out calls to undefined weak functions.
13121 We can thus call a weak function without first
13122 checking whether the function is defined. */
13123 else if (h != NULL
13124 && h->elf.root.type == bfd_link_hash_undefweak
13125 && h->elf.dynindx == -1
13126 && r_type == R_PPC64_REL24
13127 && relocation == 0
13128 && addend == 0)
13129 {
13130 bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
13131 continue;
13132 }
13133 break;
13134 }
13135
13136 /* Set `addend'. */
13137 tls_type = 0;
13138 switch (r_type)
13139 {
13140 default:
13141 info->callbacks->einfo
13142 (_("%P: %B: unknown relocation type %d for `%T'\n"),
13143 input_bfd, (int) r_type, sym_name);
13144
13145 bfd_set_error (bfd_error_bad_value);
13146 ret = FALSE;
13147 continue;
13148
13149 case R_PPC64_NONE:
13150 case R_PPC64_TLS:
13151 case R_PPC64_TLSGD:
13152 case R_PPC64_TLSLD:
13153 case R_PPC64_TOCSAVE:
13154 case R_PPC64_GNU_VTINHERIT:
13155 case R_PPC64_GNU_VTENTRY:
13156 continue;
13157
13158 /* GOT16 relocations. Like an ADDR16 using the symbol's
13159 address in the GOT as relocation value instead of the
13160 symbol's value itself. Also, create a GOT entry for the
13161 symbol and put the symbol value there. */
13162 case R_PPC64_GOT_TLSGD16:
13163 case R_PPC64_GOT_TLSGD16_LO:
13164 case R_PPC64_GOT_TLSGD16_HI:
13165 case R_PPC64_GOT_TLSGD16_HA:
13166 tls_type = TLS_TLS | TLS_GD;
13167 goto dogot;
13168
13169 case R_PPC64_GOT_TLSLD16:
13170 case R_PPC64_GOT_TLSLD16_LO:
13171 case R_PPC64_GOT_TLSLD16_HI:
13172 case R_PPC64_GOT_TLSLD16_HA:
13173 tls_type = TLS_TLS | TLS_LD;
13174 goto dogot;
13175
13176 case R_PPC64_GOT_TPREL16_DS:
13177 case R_PPC64_GOT_TPREL16_LO_DS:
13178 case R_PPC64_GOT_TPREL16_HI:
13179 case R_PPC64_GOT_TPREL16_HA:
13180 tls_type = TLS_TLS | TLS_TPREL;
13181 goto dogot;
13182
13183 case R_PPC64_GOT_DTPREL16_DS:
13184 case R_PPC64_GOT_DTPREL16_LO_DS:
13185 case R_PPC64_GOT_DTPREL16_HI:
13186 case R_PPC64_GOT_DTPREL16_HA:
13187 tls_type = TLS_TLS | TLS_DTPREL;
13188 goto dogot;
13189
13190 case R_PPC64_GOT16:
13191 case R_PPC64_GOT16_LO:
13192 case R_PPC64_GOT16_HI:
13193 case R_PPC64_GOT16_HA:
13194 case R_PPC64_GOT16_DS:
13195 case R_PPC64_GOT16_LO_DS:
13196 dogot:
13197 {
13198 /* Relocation is to the entry for this symbol in the global
13199 offset table. */
13200 asection *got;
13201 bfd_vma *offp;
13202 bfd_vma off;
13203 unsigned long indx = 0;
13204 struct got_entry *ent;
13205
13206 if (tls_type == (TLS_TLS | TLS_LD)
13207 && (h == NULL
13208 || !h->elf.def_dynamic))
13209 ent = ppc64_tlsld_got (input_bfd);
13210 else
13211 {
13212
13213 if (h != NULL)
13214 {
13215 bfd_boolean dyn = htab->elf.dynamic_sections_created;
13216 if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared,
13217 &h->elf)
13218 || (info->shared
13219 && SYMBOL_CALLS_LOCAL (info, &h->elf)))
13220 /* This is actually a static link, or it is a
13221 -Bsymbolic link and the symbol is defined
13222 locally, or the symbol was forced to be local
13223 because of a version file. */
13224 ;
13225 else
13226 {
13227 BFD_ASSERT (h->elf.dynindx != -1);
13228 indx = h->elf.dynindx;
13229 unresolved_reloc = FALSE;
13230 }
13231 ent = h->elf.got.glist;
13232 }
13233 else
13234 {
13235 if (local_got_ents == NULL)
13236 abort ();
13237 ent = local_got_ents[r_symndx];
13238 }
13239
13240 for (; ent != NULL; ent = ent->next)
13241 if (ent->addend == orig_rel.r_addend
13242 && ent->owner == input_bfd
13243 && ent->tls_type == tls_type)
13244 break;
13245 }
13246
13247 if (ent == NULL)
13248 abort ();
13249 if (ent->is_indirect)
13250 ent = ent->got.ent;
13251 offp = &ent->got.offset;
13252 got = ppc64_elf_tdata (ent->owner)->got;
13253 if (got == NULL)
13254 abort ();
13255
13256 /* The offset must always be a multiple of 8. We use the
13257 least significant bit to record whether we have already
13258 processed this entry. */
13259 off = *offp;
13260 if ((off & 1) != 0)
13261 off &= ~1;
13262 else
13263 {
13264 /* Generate relocs for the dynamic linker, except in
13265 the case of TLSLD where we'll use one entry per
13266 module. */
13267 asection *relgot;
13268 bfd_boolean ifunc;
13269
13270 *offp = off | 1;
13271 relgot = NULL;
13272 ifunc = (h != NULL
13273 ? h->elf.type == STT_GNU_IFUNC
13274 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC);
13275 if (ifunc)
13276 relgot = htab->reliplt;
13277 else if ((info->shared || indx != 0)
13278 && (h == NULL
13279 || (tls_type == (TLS_TLS | TLS_LD)
13280 && !h->elf.def_dynamic)
13281 || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
13282 || h->elf.root.type != bfd_link_hash_undefweak))
13283 relgot = ppc64_elf_tdata (ent->owner)->relgot;
13284 if (relgot != NULL)
13285 {
13286 outrel.r_offset = (got->output_section->vma
13287 + got->output_offset
13288 + off);
13289 outrel.r_addend = addend;
13290 if (tls_type & (TLS_LD | TLS_GD))
13291 {
13292 outrel.r_addend = 0;
13293 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPMOD64);
13294 if (tls_type == (TLS_TLS | TLS_GD))
13295 {
13296 loc = relgot->contents;
13297 loc += (relgot->reloc_count++
13298 * sizeof (Elf64_External_Rela));
13299 bfd_elf64_swap_reloca_out (output_bfd,
13300 &outrel, loc);
13301 outrel.r_offset += 8;
13302 outrel.r_addend = addend;
13303 outrel.r_info
13304 = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
13305 }
13306 }
13307 else if (tls_type == (TLS_TLS | TLS_DTPREL))
13308 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
13309 else if (tls_type == (TLS_TLS | TLS_TPREL))
13310 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_TPREL64);
13311 else if (indx != 0)
13312 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_GLOB_DAT);
13313 else
13314 {
13315 if (ifunc)
13316 outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
13317 else
13318 outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
13319
13320 /* Write the .got section contents for the sake
13321 of prelink. */
13322 loc = got->contents + off;
13323 bfd_put_64 (output_bfd, outrel.r_addend + relocation,
13324 loc);
13325 }
13326
13327 if (indx == 0 && tls_type != (TLS_TLS | TLS_LD))
13328 {
13329 outrel.r_addend += relocation;
13330 if (tls_type & (TLS_GD | TLS_DTPREL | TLS_TPREL))
13331 outrel.r_addend -= htab->elf.tls_sec->vma;
13332 }
13333 loc = relgot->contents;
13334 loc += (relgot->reloc_count++
13335 * sizeof (Elf64_External_Rela));
13336 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
13337 }
13338
13339 /* Init the .got section contents here if we're not
13340 emitting a reloc. */
13341 else
13342 {
13343 relocation += addend;
13344 if (tls_type == (TLS_TLS | TLS_LD))
13345 relocation = 1;
13346 else if (tls_type != 0)
13347 {
13348 relocation -= htab->elf.tls_sec->vma + DTP_OFFSET;
13349 if (tls_type == (TLS_TLS | TLS_TPREL))
13350 relocation += DTP_OFFSET - TP_OFFSET;
13351
13352 if (tls_type == (TLS_TLS | TLS_GD))
13353 {
13354 bfd_put_64 (output_bfd, relocation,
13355 got->contents + off + 8);
13356 relocation = 1;
13357 }
13358 }
13359
13360 bfd_put_64 (output_bfd, relocation,
13361 got->contents + off);
13362 }
13363 }
13364
13365 if (off >= (bfd_vma) -2)
13366 abort ();
13367
13368 relocation = got->output_section->vma + got->output_offset + off;
13369 addend = -(TOCstart + htab->stub_group[input_section->id].toc_off);
13370 }
13371 break;
13372
13373 case R_PPC64_PLT16_HA:
13374 case R_PPC64_PLT16_HI:
13375 case R_PPC64_PLT16_LO:
13376 case R_PPC64_PLT32:
13377 case R_PPC64_PLT64:
13378 /* Relocation is to the entry for this symbol in the
13379 procedure linkage table. */
13380
13381 /* Resolve a PLT reloc against a local symbol directly,
13382 without using the procedure linkage table. */
13383 if (h == NULL)
13384 break;
13385
13386 /* It's possible that we didn't make a PLT entry for this
13387 symbol. This happens when statically linking PIC code,
13388 or when using -Bsymbolic. Go find a match if there is a
13389 PLT entry. */
13390 if (htab->plt != NULL)
13391 {
13392 struct plt_entry *ent;
13393 for (ent = h->elf.plt.plist; ent != NULL; ent = ent->next)
13394 if (ent->addend == orig_rel.r_addend
13395 && ent->plt.offset != (bfd_vma) -1)
13396 {
13397 relocation = (htab->plt->output_section->vma
13398 + htab->plt->output_offset
13399 + ent->plt.offset);
13400 unresolved_reloc = FALSE;
13401 }
13402 }
13403 break;
13404
13405 case R_PPC64_TOC:
13406 /* Relocation value is TOC base. */
13407 relocation = TOCstart;
13408 if (r_symndx == STN_UNDEF)
13409 relocation += htab->stub_group[input_section->id].toc_off;
13410 else if (unresolved_reloc)
13411 ;
13412 else if (sec != NULL && sec->id <= htab->top_id)
13413 relocation += htab->stub_group[sec->id].toc_off;
13414 else
13415 unresolved_reloc = TRUE;
13416 goto dodyn;
13417
13418 /* TOC16 relocs. We want the offset relative to the TOC base,
13419 which is the address of the start of the TOC plus 0x8000.
13420 The TOC consists of sections .got, .toc, .tocbss, and .plt,
13421 in this order. */
13422 case R_PPC64_TOC16:
13423 case R_PPC64_TOC16_LO:
13424 case R_PPC64_TOC16_HI:
13425 case R_PPC64_TOC16_DS:
13426 case R_PPC64_TOC16_LO_DS:
13427 case R_PPC64_TOC16_HA:
13428 addend -= TOCstart + htab->stub_group[input_section->id].toc_off;
13429 break;
13430
13431 /* Relocate against the beginning of the section. */
13432 case R_PPC64_SECTOFF:
13433 case R_PPC64_SECTOFF_LO:
13434 case R_PPC64_SECTOFF_HI:
13435 case R_PPC64_SECTOFF_DS:
13436 case R_PPC64_SECTOFF_LO_DS:
13437 case R_PPC64_SECTOFF_HA:
13438 if (sec != NULL)
13439 addend -= sec->output_section->vma;
13440 break;
13441
13442 case R_PPC64_REL16:
13443 case R_PPC64_REL16_LO:
13444 case R_PPC64_REL16_HI:
13445 case R_PPC64_REL16_HA:
13446 break;
13447
13448 case R_PPC64_REL14:
13449 case R_PPC64_REL14_BRNTAKEN:
13450 case R_PPC64_REL14_BRTAKEN:
13451 case R_PPC64_REL24:
13452 break;
13453
13454 case R_PPC64_TPREL16:
13455 case R_PPC64_TPREL16_LO:
13456 case R_PPC64_TPREL16_HI:
13457 case R_PPC64_TPREL16_HA:
13458 case R_PPC64_TPREL16_DS:
13459 case R_PPC64_TPREL16_LO_DS:
13460 case R_PPC64_TPREL16_HIGHER:
13461 case R_PPC64_TPREL16_HIGHERA:
13462 case R_PPC64_TPREL16_HIGHEST:
13463 case R_PPC64_TPREL16_HIGHESTA:
13464 if (h != NULL
13465 && h->elf.root.type == bfd_link_hash_undefweak
13466 && h->elf.dynindx == -1)
13467 {
13468 /* Make this relocation against an undefined weak symbol
13469 resolve to zero. This is really just a tweak, since
13470 code using weak externs ought to check that they are
13471 defined before using them. */
13472 bfd_byte *p = contents + rel->r_offset - d_offset;
13473
13474 insn = bfd_get_32 (output_bfd, p);
13475 insn = _bfd_elf_ppc_at_tprel_transform (insn, 13);
13476 if (insn != 0)
13477 bfd_put_32 (output_bfd, insn, p);
13478 break;
13479 }
13480 addend -= htab->elf.tls_sec->vma + TP_OFFSET;
13481 if (info->shared)
13482 /* The TPREL16 relocs shouldn't really be used in shared
13483 libs as they will result in DT_TEXTREL being set, but
13484 support them anyway. */
13485 goto dodyn;
13486 break;
13487
13488 case R_PPC64_DTPREL16:
13489 case R_PPC64_DTPREL16_LO:
13490 case R_PPC64_DTPREL16_HI:
13491 case R_PPC64_DTPREL16_HA:
13492 case R_PPC64_DTPREL16_DS:
13493 case R_PPC64_DTPREL16_LO_DS:
13494 case R_PPC64_DTPREL16_HIGHER:
13495 case R_PPC64_DTPREL16_HIGHERA:
13496 case R_PPC64_DTPREL16_HIGHEST:
13497 case R_PPC64_DTPREL16_HIGHESTA:
13498 addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
13499 break;
13500
13501 case R_PPC64_DTPMOD64:
13502 relocation = 1;
13503 addend = 0;
13504 goto dodyn;
13505
13506 case R_PPC64_TPREL64:
13507 addend -= htab->elf.tls_sec->vma + TP_OFFSET;
13508 goto dodyn;
13509
13510 case R_PPC64_DTPREL64:
13511 addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
13512 /* Fall thru */
13513
13514 /* Relocations that may need to be propagated if this is a
13515 dynamic object. */
13516 case R_PPC64_REL30:
13517 case R_PPC64_REL32:
13518 case R_PPC64_REL64:
13519 case R_PPC64_ADDR14:
13520 case R_PPC64_ADDR14_BRNTAKEN:
13521 case R_PPC64_ADDR14_BRTAKEN:
13522 case R_PPC64_ADDR16:
13523 case R_PPC64_ADDR16_DS:
13524 case R_PPC64_ADDR16_HA:
13525 case R_PPC64_ADDR16_HI:
13526 case R_PPC64_ADDR16_HIGHER:
13527 case R_PPC64_ADDR16_HIGHERA:
13528 case R_PPC64_ADDR16_HIGHEST:
13529 case R_PPC64_ADDR16_HIGHESTA:
13530 case R_PPC64_ADDR16_LO:
13531 case R_PPC64_ADDR16_LO_DS:
13532 case R_PPC64_ADDR24:
13533 case R_PPC64_ADDR32:
13534 case R_PPC64_ADDR64:
13535 case R_PPC64_UADDR16:
13536 case R_PPC64_UADDR32:
13537 case R_PPC64_UADDR64:
13538 dodyn:
13539 if ((input_section->flags & SEC_ALLOC) == 0)
13540 break;
13541
13542 if (NO_OPD_RELOCS && is_opd)
13543 break;
13544
13545 if ((info->shared
13546 && (h == NULL
13547 || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
13548 || h->elf.root.type != bfd_link_hash_undefweak)
13549 && (must_be_dyn_reloc (info, r_type)
13550 || !SYMBOL_CALLS_LOCAL (info, &h->elf)))
13551 || (ELIMINATE_COPY_RELOCS
13552 && !info->shared
13553 && h != NULL
13554 && h->elf.dynindx != -1
13555 && !h->elf.non_got_ref
13556 && !h->elf.def_regular)
13557 || (!info->shared
13558 && (h != NULL
13559 ? h->elf.type == STT_GNU_IFUNC
13560 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)))
13561 {
13562 bfd_boolean skip, relocate;
13563 asection *sreloc;
13564 bfd_vma out_off;
13565
13566 /* When generating a dynamic object, these relocations
13567 are copied into the output file to be resolved at run
13568 time. */
13569
13570 skip = FALSE;
13571 relocate = FALSE;
13572
13573 out_off = _bfd_elf_section_offset (output_bfd, info,
13574 input_section, rel->r_offset);
13575 if (out_off == (bfd_vma) -1)
13576 skip = TRUE;
13577 else if (out_off == (bfd_vma) -2)
13578 skip = TRUE, relocate = TRUE;
13579 out_off += (input_section->output_section->vma
13580 + input_section->output_offset);
13581 outrel.r_offset = out_off;
13582 outrel.r_addend = rel->r_addend;
13583
13584 /* Optimize unaligned reloc use. */
13585 if ((r_type == R_PPC64_ADDR64 && (out_off & 7) != 0)
13586 || (r_type == R_PPC64_UADDR64 && (out_off & 7) == 0))
13587 r_type ^= R_PPC64_ADDR64 ^ R_PPC64_UADDR64;
13588 else if ((r_type == R_PPC64_ADDR32 && (out_off & 3) != 0)
13589 || (r_type == R_PPC64_UADDR32 && (out_off & 3) == 0))
13590 r_type ^= R_PPC64_ADDR32 ^ R_PPC64_UADDR32;
13591 else if ((r_type == R_PPC64_ADDR16 && (out_off & 1) != 0)
13592 || (r_type == R_PPC64_UADDR16 && (out_off & 1) == 0))
13593 r_type ^= R_PPC64_ADDR16 ^ R_PPC64_UADDR16;
13594
13595 if (skip)
13596 memset (&outrel, 0, sizeof outrel);
13597 else if (!SYMBOL_CALLS_LOCAL (info, &h->elf)
13598 && !is_opd
13599 && r_type != R_PPC64_TOC)
13600 {
13601 BFD_ASSERT (h->elf.dynindx != -1);
13602 outrel.r_info = ELF64_R_INFO (h->elf.dynindx, r_type);
13603 }
13604 else
13605 {
13606 /* This symbol is local, or marked to become local,
13607 or this is an opd section reloc which must point
13608 at a local function. */
13609 outrel.r_addend += relocation;
13610 if (r_type == R_PPC64_ADDR64 || r_type == R_PPC64_TOC)
13611 {
13612 if (is_opd && h != NULL)
13613 {
13614 /* Lie about opd entries. This case occurs
13615 when building shared libraries and we
13616 reference a function in another shared
13617 lib. The same thing happens for a weak
13618 definition in an application that's
13619 overridden by a strong definition in a
13620 shared lib. (I believe this is a generic
13621 bug in binutils handling of weak syms.)
13622 In these cases we won't use the opd
13623 entry in this lib. */
13624 unresolved_reloc = FALSE;
13625 }
13626 if (!is_opd
13627 && r_type == R_PPC64_ADDR64
13628 && (h != NULL
13629 ? h->elf.type == STT_GNU_IFUNC
13630 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
13631 outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
13632 else
13633 {
13634 outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
13635
13636 /* We need to relocate .opd contents for ld.so.
13637 Prelink also wants simple and consistent rules
13638 for relocs. This make all RELATIVE relocs have
13639 *r_offset equal to r_addend. */
13640 relocate = TRUE;
13641 }
13642 }
13643 else
13644 {
13645 long indx = 0;
13646
13647 if (h != NULL
13648 ? h->elf.type == STT_GNU_IFUNC
13649 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
13650 {
13651 info->callbacks->einfo
13652 (_("%P: %H: %s for indirect "
13653 "function `%T' unsupported\n"),
13654 input_bfd, input_section, rel->r_offset,
13655 ppc64_elf_howto_table[r_type]->name,
13656 sym_name);
13657 ret = FALSE;
13658 }
13659 else if (r_symndx == STN_UNDEF || bfd_is_abs_section (sec))
13660 ;
13661 else if (sec == NULL || sec->owner == NULL)
13662 {
13663 bfd_set_error (bfd_error_bad_value);
13664 return FALSE;
13665 }
13666 else
13667 {
13668 asection *osec;
13669
13670 osec = sec->output_section;
13671 indx = elf_section_data (osec)->dynindx;
13672
13673 if (indx == 0)
13674 {
13675 if ((osec->flags & SEC_READONLY) == 0
13676 && htab->elf.data_index_section != NULL)
13677 osec = htab->elf.data_index_section;
13678 else
13679 osec = htab->elf.text_index_section;
13680 indx = elf_section_data (osec)->dynindx;
13681 }
13682 BFD_ASSERT (indx != 0);
13683
13684 /* We are turning this relocation into one
13685 against a section symbol, so subtract out
13686 the output section's address but not the
13687 offset of the input section in the output
13688 section. */
13689 outrel.r_addend -= osec->vma;
13690 }
13691
13692 outrel.r_info = ELF64_R_INFO (indx, r_type);
13693 }
13694 }
13695
13696 sreloc = elf_section_data (input_section)->sreloc;
13697 if (h != NULL
13698 ? h->elf.type == STT_GNU_IFUNC
13699 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
13700 sreloc = htab->reliplt;
13701 if (sreloc == NULL)
13702 abort ();
13703
13704 if (sreloc->reloc_count * sizeof (Elf64_External_Rela)
13705 >= sreloc->size)
13706 abort ();
13707 loc = sreloc->contents;
13708 loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
13709 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
13710
13711 /* If this reloc is against an external symbol, it will
13712 be computed at runtime, so there's no need to do
13713 anything now. However, for the sake of prelink ensure
13714 that the section contents are a known value. */
13715 if (! relocate)
13716 {
13717 unresolved_reloc = FALSE;
13718 /* The value chosen here is quite arbitrary as ld.so
13719 ignores section contents except for the special
13720 case of .opd where the contents might be accessed
13721 before relocation. Choose zero, as that won't
13722 cause reloc overflow. */
13723 relocation = 0;
13724 addend = 0;
13725 /* Use *r_offset == r_addend for R_PPC64_ADDR64 relocs
13726 to improve backward compatibility with older
13727 versions of ld. */
13728 if (r_type == R_PPC64_ADDR64)
13729 addend = outrel.r_addend;
13730 /* Adjust pc_relative relocs to have zero in *r_offset. */
13731 else if (ppc64_elf_howto_table[r_type]->pc_relative)
13732 addend = (input_section->output_section->vma
13733 + input_section->output_offset
13734 + rel->r_offset);
13735 }
13736 }
13737 break;
13738
13739 case R_PPC64_COPY:
13740 case R_PPC64_GLOB_DAT:
13741 case R_PPC64_JMP_SLOT:
13742 case R_PPC64_JMP_IREL:
13743 case R_PPC64_RELATIVE:
13744 /* We shouldn't ever see these dynamic relocs in relocatable
13745 files. */
13746 /* Fall through. */
13747
13748 case R_PPC64_PLTGOT16:
13749 case R_PPC64_PLTGOT16_DS:
13750 case R_PPC64_PLTGOT16_HA:
13751 case R_PPC64_PLTGOT16_HI:
13752 case R_PPC64_PLTGOT16_LO:
13753 case R_PPC64_PLTGOT16_LO_DS:
13754 case R_PPC64_PLTREL32:
13755 case R_PPC64_PLTREL64:
13756 /* These ones haven't been implemented yet. */
13757
13758 info->callbacks->einfo
13759 (_("%P: %B: %s is not supported for `%T'\n"),
13760 input_bfd,
13761 ppc64_elf_howto_table[r_type]->name, sym_name);
13762
13763 bfd_set_error (bfd_error_invalid_operation);
13764 ret = FALSE;
13765 continue;
13766 }
13767
13768 /* Multi-instruction sequences that access the TOC can be
13769 optimized, eg. addis ra,r2,0; addi rb,ra,x;
13770 to nop; addi rb,r2,x; */
13771 switch (r_type)
13772 {
13773 default:
13774 break;
13775
13776 case R_PPC64_GOT_TLSLD16_HI:
13777 case R_PPC64_GOT_TLSGD16_HI:
13778 case R_PPC64_GOT_TPREL16_HI:
13779 case R_PPC64_GOT_DTPREL16_HI:
13780 case R_PPC64_GOT16_HI:
13781 case R_PPC64_TOC16_HI:
13782 /* These relocs would only be useful if building up an
13783 offset to later add to r2, perhaps in an indexed
13784 addressing mode instruction. Don't try to optimize.
13785 Unfortunately, the possibility of someone building up an
13786 offset like this or even with the HA relocs, means that
13787 we need to check the high insn when optimizing the low
13788 insn. */
13789 break;
13790
13791 case R_PPC64_GOT_TLSLD16_HA:
13792 case R_PPC64_GOT_TLSGD16_HA:
13793 case R_PPC64_GOT_TPREL16_HA:
13794 case R_PPC64_GOT_DTPREL16_HA:
13795 case R_PPC64_GOT16_HA:
13796 case R_PPC64_TOC16_HA:
13797 if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
13798 && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
13799 {
13800 bfd_byte *p = contents + (rel->r_offset & ~3);
13801 bfd_put_32 (input_bfd, NOP, p);
13802 }
13803 break;
13804
13805 case R_PPC64_GOT_TLSLD16_LO:
13806 case R_PPC64_GOT_TLSGD16_LO:
13807 case R_PPC64_GOT_TPREL16_LO_DS:
13808 case R_PPC64_GOT_DTPREL16_LO_DS:
13809 case R_PPC64_GOT16_LO:
13810 case R_PPC64_GOT16_LO_DS:
13811 case R_PPC64_TOC16_LO:
13812 case R_PPC64_TOC16_LO_DS:
13813 if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
13814 && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
13815 {
13816 bfd_byte *p = contents + (rel->r_offset & ~3);
13817 insn = bfd_get_32 (input_bfd, p);
13818 if ((insn & (0x3f << 26)) == 12u << 26 /* addic */)
13819 {
13820 /* Transform addic to addi when we change reg. */
13821 insn &= ~((0x3f << 26) | (0x1f << 16));
13822 insn |= (14u << 26) | (2 << 16);
13823 }
13824 else
13825 {
13826 insn &= ~(0x1f << 16);
13827 insn |= 2 << 16;
13828 }
13829 bfd_put_32 (input_bfd, insn, p);
13830 }
13831 break;
13832 }
13833
13834 /* Do any further special processing. */
13835 switch (r_type)
13836 {
13837 default:
13838 break;
13839
13840 case R_PPC64_ADDR16_HA:
13841 case R_PPC64_REL16_HA:
13842 case R_PPC64_ADDR16_HIGHERA:
13843 case R_PPC64_ADDR16_HIGHESTA:
13844 case R_PPC64_TOC16_HA:
13845 case R_PPC64_SECTOFF_HA:
13846 case R_PPC64_TPREL16_HA:
13847 case R_PPC64_DTPREL16_HA:
13848 case R_PPC64_TPREL16_HIGHER:
13849 case R_PPC64_TPREL16_HIGHERA:
13850 case R_PPC64_TPREL16_HIGHEST:
13851 case R_PPC64_TPREL16_HIGHESTA:
13852 case R_PPC64_DTPREL16_HIGHER:
13853 case R_PPC64_DTPREL16_HIGHERA:
13854 case R_PPC64_DTPREL16_HIGHEST:
13855 case R_PPC64_DTPREL16_HIGHESTA:
13856 /* It's just possible that this symbol is a weak symbol
13857 that's not actually defined anywhere. In that case,
13858 'sec' would be NULL, and we should leave the symbol
13859 alone (it will be set to zero elsewhere in the link). */
13860 if (sec == NULL)
13861 break;
13862 /* Fall thru */
13863
13864 case R_PPC64_GOT16_HA:
13865 case R_PPC64_PLTGOT16_HA:
13866 case R_PPC64_PLT16_HA:
13867 case R_PPC64_GOT_TLSGD16_HA:
13868 case R_PPC64_GOT_TLSLD16_HA:
13869 case R_PPC64_GOT_TPREL16_HA:
13870 case R_PPC64_GOT_DTPREL16_HA:
13871 /* Add 0x10000 if sign bit in 0:15 is set.
13872 Bits 0:15 are not used. */
13873 addend += 0x8000;
13874 break;
13875
13876 case R_PPC64_ADDR16_DS:
13877 case R_PPC64_ADDR16_LO_DS:
13878 case R_PPC64_GOT16_DS:
13879 case R_PPC64_GOT16_LO_DS:
13880 case R_PPC64_PLT16_LO_DS:
13881 case R_PPC64_SECTOFF_DS:
13882 case R_PPC64_SECTOFF_LO_DS:
13883 case R_PPC64_TOC16_DS:
13884 case R_PPC64_TOC16_LO_DS:
13885 case R_PPC64_PLTGOT16_DS:
13886 case R_PPC64_PLTGOT16_LO_DS:
13887 case R_PPC64_GOT_TPREL16_DS:
13888 case R_PPC64_GOT_TPREL16_LO_DS:
13889 case R_PPC64_GOT_DTPREL16_DS:
13890 case R_PPC64_GOT_DTPREL16_LO_DS:
13891 case R_PPC64_TPREL16_DS:
13892 case R_PPC64_TPREL16_LO_DS:
13893 case R_PPC64_DTPREL16_DS:
13894 case R_PPC64_DTPREL16_LO_DS:
13895 insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
13896 mask = 3;
13897 /* If this reloc is against an lq insn, then the value must be
13898 a multiple of 16. This is somewhat of a hack, but the
13899 "correct" way to do this by defining _DQ forms of all the
13900 _DS relocs bloats all reloc switches in this file. It
13901 doesn't seem to make much sense to use any of these relocs
13902 in data, so testing the insn should be safe. */
13903 if ((insn & (0x3f << 26)) == (56u << 26))
13904 mask = 15;
13905 if (((relocation + addend) & mask) != 0)
13906 {
13907 info->callbacks->einfo
13908 (_("%P: %H: error: %s not a multiple of %u\n"),
13909 input_bfd, input_section, rel->r_offset,
13910 ppc64_elf_howto_table[r_type]->name,
13911 mask + 1);
13912 bfd_set_error (bfd_error_bad_value);
13913 ret = FALSE;
13914 continue;
13915 }
13916 break;
13917 }
13918
13919 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
13920 because such sections are not SEC_ALLOC and thus ld.so will
13921 not process them. */
13922 if (unresolved_reloc
13923 && !((input_section->flags & SEC_DEBUGGING) != 0
13924 && h->elf.def_dynamic)
13925 && _bfd_elf_section_offset (output_bfd, info, input_section,
13926 rel->r_offset) != (bfd_vma) -1)
13927 {
13928 info->callbacks->einfo
13929 (_("%P: %H: unresolvable %s against `%T'\n"),
13930 input_bfd, input_section, rel->r_offset,
13931 ppc64_elf_howto_table[(int) r_type]->name,
13932 h->elf.root.root.string);
13933 ret = FALSE;
13934 }
13935
13936 r = _bfd_final_link_relocate (ppc64_elf_howto_table[(int) r_type],
13937 input_bfd,
13938 input_section,
13939 contents,
13940 rel->r_offset,
13941 relocation,
13942 addend);
13943
13944 if (r != bfd_reloc_ok)
13945 {
13946 char *more_info = NULL;
13947 const char *reloc_name = ppc64_elf_howto_table[r_type]->name;
13948
13949 if (reloc_dest != DEST_NORMAL)
13950 {
13951 more_info = bfd_malloc (strlen (reloc_name) + 8);
13952 if (more_info != NULL)
13953 {
13954 strcpy (more_info, reloc_name);
13955 strcat (more_info, (reloc_dest == DEST_OPD
13956 ? " (OPD)" : " (stub)"));
13957 reloc_name = more_info;
13958 }
13959 }
13960
13961 if (r == bfd_reloc_overflow)
13962 {
13963 if (warned)
13964 continue;
13965 if (h != NULL
13966 && h->elf.root.type == bfd_link_hash_undefweak
13967 && ppc64_elf_howto_table[r_type]->pc_relative)
13968 {
13969 /* Assume this is a call protected by other code that
13970 detects the symbol is undefined. If this is the case,
13971 we can safely ignore the overflow. If not, the
13972 program is hosed anyway, and a little warning isn't
13973 going to help. */
13974
13975 continue;
13976 }
13977
13978 if (!((*info->callbacks->reloc_overflow)
13979 (info, &h->elf.root, sym_name,
13980 reloc_name, orig_rel.r_addend,
13981 input_bfd, input_section, rel->r_offset)))
13982 return FALSE;
13983 }
13984 else
13985 {
13986 info->callbacks->einfo
13987 (_("%P: %H: %s against `%T': error %d\n"),
13988 input_bfd, input_section, rel->r_offset,
13989 reloc_name, sym_name, (int) r);
13990 ret = FALSE;
13991 }
13992 if (more_info != NULL)
13993 free (more_info);
13994 }
13995 }
13996
13997 /* If we're emitting relocations, then shortly after this function
13998 returns, reloc offsets and addends for this section will be
13999 adjusted. Worse, reloc symbol indices will be for the output
14000 file rather than the input. Save a copy of the relocs for
14001 opd_entry_value. */
14002 if (is_opd && (info->emitrelocations || info->relocatable))
14003 {
14004 bfd_size_type amt;
14005 amt = input_section->reloc_count * sizeof (Elf_Internal_Rela);
14006 rel = bfd_alloc (input_bfd, amt);
14007 BFD_ASSERT (ppc64_elf_tdata (input_bfd)->opd_relocs == NULL);
14008 ppc64_elf_tdata (input_bfd)->opd_relocs = rel;
14009 if (rel == NULL)
14010 return FALSE;
14011 memcpy (rel, relocs, amt);
14012 }
14013 return ret;
14014 }
14015
14016 /* Adjust the value of any local symbols in opd sections. */
14017
14018 static int
14019 ppc64_elf_output_symbol_hook (struct bfd_link_info *info,
14020 const char *name ATTRIBUTE_UNUSED,
14021 Elf_Internal_Sym *elfsym,
14022 asection *input_sec,
14023 struct elf_link_hash_entry *h)
14024 {
14025 struct _opd_sec_data *opd;
14026 long adjust;
14027 bfd_vma value;
14028
14029 if (h != NULL)
14030 return 1;
14031
14032 opd = get_opd_info (input_sec);
14033 if (opd == NULL || opd->adjust == NULL)
14034 return 1;
14035
14036 value = elfsym->st_value - input_sec->output_offset;
14037 if (!info->relocatable)
14038 value -= input_sec->output_section->vma;
14039
14040 adjust = opd->adjust[value / 8];
14041 if (adjust == -1)
14042 return 2;
14043
14044 elfsym->st_value += adjust;
14045 return 1;
14046 }
14047
14048 /* Finish up dynamic symbol handling. We set the contents of various
14049 dynamic sections here. */
14050
14051 static bfd_boolean
14052 ppc64_elf_finish_dynamic_symbol (bfd *output_bfd,
14053 struct bfd_link_info *info,
14054 struct elf_link_hash_entry *h,
14055 Elf_Internal_Sym *sym ATTRIBUTE_UNUSED)
14056 {
14057 struct ppc_link_hash_table *htab;
14058 struct plt_entry *ent;
14059 Elf_Internal_Rela rela;
14060 bfd_byte *loc;
14061
14062 htab = ppc_hash_table (info);
14063 if (htab == NULL)
14064 return FALSE;
14065
14066 for (ent = h->plt.plist; ent != NULL; ent = ent->next)
14067 if (ent->plt.offset != (bfd_vma) -1)
14068 {
14069 /* This symbol has an entry in the procedure linkage
14070 table. Set it up. */
14071 if (!htab->elf.dynamic_sections_created
14072 || h->dynindx == -1)
14073 {
14074 BFD_ASSERT (h->type == STT_GNU_IFUNC
14075 && h->def_regular
14076 && (h->root.type == bfd_link_hash_defined
14077 || h->root.type == bfd_link_hash_defweak));
14078 rela.r_offset = (htab->iplt->output_section->vma
14079 + htab->iplt->output_offset
14080 + ent->plt.offset);
14081 rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
14082 rela.r_addend = (h->root.u.def.value
14083 + h->root.u.def.section->output_offset
14084 + h->root.u.def.section->output_section->vma
14085 + ent->addend);
14086 loc = (htab->reliplt->contents
14087 + (htab->reliplt->reloc_count++
14088 * sizeof (Elf64_External_Rela)));
14089 }
14090 else
14091 {
14092 rela.r_offset = (htab->plt->output_section->vma
14093 + htab->plt->output_offset
14094 + ent->plt.offset);
14095 rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_JMP_SLOT);
14096 rela.r_addend = ent->addend;
14097 loc = (htab->relplt->contents
14098 + ((ent->plt.offset - PLT_INITIAL_ENTRY_SIZE)
14099 / (PLT_ENTRY_SIZE / sizeof (Elf64_External_Rela))));
14100 }
14101 bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
14102 }
14103
14104 if (h->needs_copy)
14105 {
14106 /* This symbol needs a copy reloc. Set it up. */
14107
14108 if (h->dynindx == -1
14109 || (h->root.type != bfd_link_hash_defined
14110 && h->root.type != bfd_link_hash_defweak)
14111 || htab->relbss == NULL)
14112 abort ();
14113
14114 rela.r_offset = (h->root.u.def.value
14115 + h->root.u.def.section->output_section->vma
14116 + h->root.u.def.section->output_offset);
14117 rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_COPY);
14118 rela.r_addend = 0;
14119 loc = htab->relbss->contents;
14120 loc += htab->relbss->reloc_count++ * sizeof (Elf64_External_Rela);
14121 bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
14122 }
14123
14124 return TRUE;
14125 }
14126
14127 /* Used to decide how to sort relocs in an optimal manner for the
14128 dynamic linker, before writing them out. */
14129
14130 static enum elf_reloc_type_class
14131 ppc64_elf_reloc_type_class (const struct bfd_link_info *info,
14132 const asection *rel_sec,
14133 const Elf_Internal_Rela *rela)
14134 {
14135 enum elf_ppc64_reloc_type r_type;
14136 struct ppc_link_hash_table *htab = ppc_hash_table (info);
14137
14138 if (rel_sec == htab->reliplt)
14139 return reloc_class_ifunc;
14140
14141 r_type = ELF64_R_TYPE (rela->r_info);
14142 switch (r_type)
14143 {
14144 case R_PPC64_RELATIVE:
14145 return reloc_class_relative;
14146 case R_PPC64_JMP_SLOT:
14147 return reloc_class_plt;
14148 case R_PPC64_COPY:
14149 return reloc_class_copy;
14150 default:
14151 return reloc_class_normal;
14152 }
14153 }
14154
14155 /* Finish up the dynamic sections. */
14156
14157 static bfd_boolean
14158 ppc64_elf_finish_dynamic_sections (bfd *output_bfd,
14159 struct bfd_link_info *info)
14160 {
14161 struct ppc_link_hash_table *htab;
14162 bfd *dynobj;
14163 asection *sdyn;
14164
14165 htab = ppc_hash_table (info);
14166 if (htab == NULL)
14167 return FALSE;
14168
14169 dynobj = htab->elf.dynobj;
14170 sdyn = bfd_get_linker_section (dynobj, ".dynamic");
14171
14172 if (htab->elf.dynamic_sections_created)
14173 {
14174 Elf64_External_Dyn *dyncon, *dynconend;
14175
14176 if (sdyn == NULL || htab->got == NULL)
14177 abort ();
14178
14179 dyncon = (Elf64_External_Dyn *) sdyn->contents;
14180 dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
14181 for (; dyncon < dynconend; dyncon++)
14182 {
14183 Elf_Internal_Dyn dyn;
14184 asection *s;
14185
14186 bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
14187
14188 switch (dyn.d_tag)
14189 {
14190 default:
14191 continue;
14192
14193 case DT_PPC64_GLINK:
14194 s = htab->glink;
14195 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
14196 /* We stupidly defined DT_PPC64_GLINK to be the start
14197 of glink rather than the first entry point, which is
14198 what ld.so needs, and now have a bigger stub to
14199 support automatic multiple TOCs. */
14200 dyn.d_un.d_ptr += GLINK_CALL_STUB_SIZE - 32;
14201 break;
14202
14203 case DT_PPC64_OPD:
14204 s = bfd_get_section_by_name (output_bfd, ".opd");
14205 if (s == NULL)
14206 continue;
14207 dyn.d_un.d_ptr = s->vma;
14208 break;
14209
14210 case DT_PPC64_OPDSZ:
14211 s = bfd_get_section_by_name (output_bfd, ".opd");
14212 if (s == NULL)
14213 continue;
14214 dyn.d_un.d_val = s->size;
14215 break;
14216
14217 case DT_PLTGOT:
14218 s = htab->plt;
14219 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
14220 break;
14221
14222 case DT_JMPREL:
14223 s = htab->relplt;
14224 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
14225 break;
14226
14227 case DT_PLTRELSZ:
14228 dyn.d_un.d_val = htab->relplt->size;
14229 break;
14230
14231 case DT_RELASZ:
14232 /* Don't count procedure linkage table relocs in the
14233 overall reloc count. */
14234 s = htab->relplt;
14235 if (s == NULL)
14236 continue;
14237 dyn.d_un.d_val -= s->size;
14238 break;
14239
14240 case DT_RELA:
14241 /* We may not be using the standard ELF linker script.
14242 If .rela.plt is the first .rela section, we adjust
14243 DT_RELA to not include it. */
14244 s = htab->relplt;
14245 if (s == NULL)
14246 continue;
14247 if (dyn.d_un.d_ptr != s->output_section->vma + s->output_offset)
14248 continue;
14249 dyn.d_un.d_ptr += s->size;
14250 break;
14251 }
14252
14253 bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
14254 }
14255 }
14256
14257 if (htab->got != NULL && htab->got->size != 0)
14258 {
14259 /* Fill in the first entry in the global offset table.
14260 We use it to hold the link-time TOCbase. */
14261 bfd_put_64 (output_bfd,
14262 elf_gp (output_bfd) + TOC_BASE_OFF,
14263 htab->got->contents);
14264
14265 /* Set .got entry size. */
14266 elf_section_data (htab->got->output_section)->this_hdr.sh_entsize = 8;
14267 }
14268
14269 if (htab->plt != NULL && htab->plt->size != 0)
14270 {
14271 /* Set .plt entry size. */
14272 elf_section_data (htab->plt->output_section)->this_hdr.sh_entsize
14273 = PLT_ENTRY_SIZE;
14274 }
14275
14276 /* brlt is SEC_LINKER_CREATED, so we need to write out relocs for
14277 brlt ourselves if emitrelocations. */
14278 if (htab->brlt != NULL
14279 && htab->brlt->reloc_count != 0
14280 && !_bfd_elf_link_output_relocs (output_bfd,
14281 htab->brlt,
14282 elf_section_data (htab->brlt)->rela.hdr,
14283 elf_section_data (htab->brlt)->relocs,
14284 NULL))
14285 return FALSE;
14286
14287 if (htab->glink != NULL
14288 && htab->glink->reloc_count != 0
14289 && !_bfd_elf_link_output_relocs (output_bfd,
14290 htab->glink,
14291 elf_section_data (htab->glink)->rela.hdr,
14292 elf_section_data (htab->glink)->relocs,
14293 NULL))
14294 return FALSE;
14295
14296
14297 if (htab->glink_eh_frame != NULL
14298 && htab->glink_eh_frame->sec_info_type == SEC_INFO_TYPE_EH_FRAME
14299 && !_bfd_elf_write_section_eh_frame (output_bfd, info,
14300 htab->glink_eh_frame,
14301 htab->glink_eh_frame->contents))
14302 return FALSE;
14303
14304 /* We need to handle writing out multiple GOT sections ourselves,
14305 since we didn't add them to DYNOBJ. We know dynobj is the first
14306 bfd. */
14307 while ((dynobj = dynobj->link_next) != NULL)
14308 {
14309 asection *s;
14310
14311 if (!is_ppc64_elf (dynobj))
14312 continue;
14313
14314 s = ppc64_elf_tdata (dynobj)->got;
14315 if (s != NULL
14316 && s->size != 0
14317 && s->output_section != bfd_abs_section_ptr
14318 && !bfd_set_section_contents (output_bfd, s->output_section,
14319 s->contents, s->output_offset,
14320 s->size))
14321 return FALSE;
14322 s = ppc64_elf_tdata (dynobj)->relgot;
14323 if (s != NULL
14324 && s->size != 0
14325 && s->output_section != bfd_abs_section_ptr
14326 && !bfd_set_section_contents (output_bfd, s->output_section,
14327 s->contents, s->output_offset,
14328 s->size))
14329 return FALSE;
14330 }
14331
14332 return TRUE;
14333 }
14334
14335 #include "elf64-target.h"
14336
14337 /* FreeBSD support */
14338
14339 #undef TARGET_LITTLE_SYM
14340 #undef TARGET_LITTLE_NAME
14341
14342 #undef TARGET_BIG_SYM
14343 #define TARGET_BIG_SYM bfd_elf64_powerpc_freebsd_vec
14344 #undef TARGET_BIG_NAME
14345 #define TARGET_BIG_NAME "elf64-powerpc-freebsd"
14346
14347 #undef ELF_OSABI
14348 #define ELF_OSABI ELFOSABI_FREEBSD
14349
14350 #undef elf64_bed
14351 #define elf64_bed elf64_powerpc_fbsd_bed
14352
14353 #include "elf64-target.h"
14354
GDB Binutils - Deliverables
This page took 0.343415 seconds and 4 git commands to generate.