projects / deliverable / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
sim: bfin: only regen linux-fixed-code.h in maintainer mode
[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 /* Create sections for linker generated code. */
4065
4066 static bfd_boolean
4067 create_linkage_sections (bfd *dynobj, struct bfd_link_info *info)
4068 {
4069 struct ppc_link_hash_table *htab;
4070 flagword flags;
4071
4072 htab = ppc_hash_table (info);
4073
4074 /* Create .sfpr for code to save and restore fp regs. */
4075 flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY
4076 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4077 htab->sfpr = bfd_make_section_anyway_with_flags (dynobj, ".sfpr",
4078 flags);
4079 if (htab->sfpr == NULL
4080 || ! bfd_set_section_alignment (dynobj, htab->sfpr, 2))
4081 return FALSE;
4082
4083 /* Create .glink for lazy dynamic linking support. */
4084 htab->glink = bfd_make_section_anyway_with_flags (dynobj, ".glink",
4085 flags);
4086 if (htab->glink == NULL
4087 || ! bfd_set_section_alignment (dynobj, htab->glink, 3))
4088 return FALSE;
4089
4090 if (!info->no_ld_generated_unwind_info)
4091 {
4092 flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_HAS_CONTENTS
4093 | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4094 htab->glink_eh_frame = bfd_make_section_anyway_with_flags (dynobj,
4095 ".eh_frame",
4096 flags);
4097 if (htab->glink_eh_frame == NULL
4098 || !bfd_set_section_alignment (dynobj, htab->glink_eh_frame, 2))
4099 return FALSE;
4100 }
4101
4102 flags = SEC_ALLOC | SEC_LINKER_CREATED;
4103 htab->iplt = bfd_make_section_anyway_with_flags (dynobj, ".iplt", flags);
4104 if (htab->iplt == NULL
4105 || ! bfd_set_section_alignment (dynobj, htab->iplt, 3))
4106 return FALSE;
4107
4108 flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4109 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4110 htab->reliplt = bfd_make_section_anyway_with_flags (dynobj,
4111 ".rela.iplt",
4112 flags);
4113 if (htab->reliplt == NULL
4114 || ! bfd_set_section_alignment (dynobj, htab->reliplt, 3))
4115 return FALSE;
4116
4117 /* Create branch lookup table for plt_branch stubs. */
4118 flags = (SEC_ALLOC | SEC_LOAD
4119 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4120 htab->brlt = bfd_make_section_anyway_with_flags (dynobj, ".branch_lt",
4121 flags);
4122 if (htab->brlt == NULL
4123 || ! bfd_set_section_alignment (dynobj, htab->brlt, 3))
4124 return FALSE;
4125
4126 if (!info->shared)
4127 return TRUE;
4128
4129 flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4130 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4131 htab->relbrlt = bfd_make_section_anyway_with_flags (dynobj,
4132 ".rela.branch_lt",
4133 flags);
4134 if (htab->relbrlt == NULL
4135 || ! bfd_set_section_alignment (dynobj, htab->relbrlt, 3))
4136 return FALSE;
4137
4138 return TRUE;
4139 }
4140
4141 /* Satisfy the ELF linker by filling in some fields in our fake bfd. */
4142
4143 bfd_boolean
4144 ppc64_elf_init_stub_bfd (bfd *abfd, struct bfd_link_info *info)
4145 {
4146 struct ppc_link_hash_table *htab;
4147
4148 elf_elfheader (abfd)->e_ident[EI_CLASS] = ELFCLASS64;
4149
4150 /* Always hook our dynamic sections into the first bfd, which is the
4151 linker created stub bfd. This ensures that the GOT header is at
4152 the start of the output TOC section. */
4153 htab = ppc_hash_table (info);
4154 if (htab == NULL)
4155 return FALSE;
4156 htab->stub_bfd = abfd;
4157 htab->elf.dynobj = abfd;
4158
4159 if (info->relocatable)
4160 return TRUE;
4161
4162 return create_linkage_sections (htab->elf.dynobj, info);
4163 }
4164
4165 /* Build a name for an entry in the stub hash table. */
4166
4167 static char *
4168 ppc_stub_name (const asection *input_section,
4169 const asection *sym_sec,
4170 const struct ppc_link_hash_entry *h,
4171 const Elf_Internal_Rela *rel)
4172 {
4173 char *stub_name;
4174 ssize_t len;
4175
4176 /* rel->r_addend is actually 64 bit, but who uses more than +/- 2^31
4177 offsets from a sym as a branch target? In fact, we could
4178 probably assume the addend is always zero. */
4179 BFD_ASSERT (((int) rel->r_addend & 0xffffffff) == rel->r_addend);
4180
4181 if (h)
4182 {
4183 len = 8 + 1 + strlen (h->elf.root.root.string) + 1 + 8 + 1;
4184 stub_name = bfd_malloc (len);
4185 if (stub_name == NULL)
4186 return stub_name;
4187
4188 len = sprintf (stub_name, "%08x.%s+%x",
4189 input_section->id & 0xffffffff,
4190 h->elf.root.root.string,
4191 (int) rel->r_addend & 0xffffffff);
4192 }
4193 else
4194 {
4195 len = 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1;
4196 stub_name = bfd_malloc (len);
4197 if (stub_name == NULL)
4198 return stub_name;
4199
4200 len = sprintf (stub_name, "%08x.%x:%x+%x",
4201 input_section->id & 0xffffffff,
4202 sym_sec->id & 0xffffffff,
4203 (int) ELF64_R_SYM (rel->r_info) & 0xffffffff,
4204 (int) rel->r_addend & 0xffffffff);
4205 }
4206 if (len > 2 && stub_name[len - 2] == '+' && stub_name[len - 1] == '0')
4207 stub_name[len - 2] = 0;
4208 return stub_name;
4209 }
4210
4211 /* Look up an entry in the stub hash. Stub entries are cached because
4212 creating the stub name takes a bit of time. */
4213
4214 static struct ppc_stub_hash_entry *
4215 ppc_get_stub_entry (const asection *input_section,
4216 const asection *sym_sec,
4217 struct ppc_link_hash_entry *h,
4218 const Elf_Internal_Rela *rel,
4219 struct ppc_link_hash_table *htab)
4220 {
4221 struct ppc_stub_hash_entry *stub_entry;
4222 const asection *id_sec;
4223
4224 /* If this input section is part of a group of sections sharing one
4225 stub section, then use the id of the first section in the group.
4226 Stub names need to include a section id, as there may well be
4227 more than one stub used to reach say, printf, and we need to
4228 distinguish between them. */
4229 id_sec = htab->stub_group[input_section->id].link_sec;
4230
4231 if (h != NULL && h->u.stub_cache != NULL
4232 && h->u.stub_cache->h == h
4233 && h->u.stub_cache->id_sec == id_sec)
4234 {
4235 stub_entry = h->u.stub_cache;
4236 }
4237 else
4238 {
4239 char *stub_name;
4240
4241 stub_name = ppc_stub_name (id_sec, sym_sec, h, rel);
4242 if (stub_name == NULL)
4243 return NULL;
4244
4245 stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
4246 stub_name, FALSE, FALSE);
4247 if (h != NULL)
4248 h->u.stub_cache = stub_entry;
4249
4250 free (stub_name);
4251 }
4252
4253 return stub_entry;
4254 }
4255
4256 /* Add a new stub entry to the stub hash. Not all fields of the new
4257 stub entry are initialised. */
4258
4259 static struct ppc_stub_hash_entry *
4260 ppc_add_stub (const char *stub_name,
4261 asection *section,
4262 struct bfd_link_info *info)
4263 {
4264 struct ppc_link_hash_table *htab = ppc_hash_table (info);
4265 asection *link_sec;
4266 asection *stub_sec;
4267 struct ppc_stub_hash_entry *stub_entry;
4268
4269 link_sec = htab->stub_group[section->id].link_sec;
4270 stub_sec = htab->stub_group[section->id].stub_sec;
4271 if (stub_sec == NULL)
4272 {
4273 stub_sec = htab->stub_group[link_sec->id].stub_sec;
4274 if (stub_sec == NULL)
4275 {
4276 size_t namelen;
4277 bfd_size_type len;
4278 char *s_name;
4279
4280 namelen = strlen (link_sec->name);
4281 len = namelen + sizeof (STUB_SUFFIX);
4282 s_name = bfd_alloc (htab->stub_bfd, len);
4283 if (s_name == NULL)
4284 return NULL;
4285
4286 memcpy (s_name, link_sec->name, namelen);
4287 memcpy (s_name + namelen, STUB_SUFFIX, sizeof (STUB_SUFFIX));
4288 stub_sec = (*htab->add_stub_section) (s_name, link_sec);
4289 if (stub_sec == NULL)
4290 return NULL;
4291 htab->stub_group[link_sec->id].stub_sec = stub_sec;
4292 }
4293 htab->stub_group[section->id].stub_sec = stub_sec;
4294 }
4295
4296 /* Enter this entry into the linker stub hash table. */
4297 stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table, stub_name,
4298 TRUE, FALSE);
4299 if (stub_entry == NULL)
4300 {
4301 info->callbacks->einfo (_("%P: %B: cannot create stub entry %s\n"),
4302 section->owner, stub_name);
4303 return NULL;
4304 }
4305
4306 stub_entry->stub_sec = stub_sec;
4307 stub_entry->stub_offset = 0;
4308 stub_entry->id_sec = link_sec;
4309 return stub_entry;
4310 }
4311
4312 /* Create .got and .rela.got sections in ABFD, and .got in dynobj if
4313 not already done. */
4314
4315 static bfd_boolean
4316 create_got_section (bfd *abfd, struct bfd_link_info *info)
4317 {
4318 asection *got, *relgot;
4319 flagword flags;
4320 struct ppc_link_hash_table *htab = ppc_hash_table (info);
4321
4322 if (!is_ppc64_elf (abfd))
4323 return FALSE;
4324 if (htab == NULL)
4325 return FALSE;
4326
4327 if (!htab->got)
4328 {
4329 if (! _bfd_elf_create_got_section (htab->elf.dynobj, info))
4330 return FALSE;
4331
4332 htab->got = bfd_get_linker_section (htab->elf.dynobj, ".got");
4333 if (!htab->got)
4334 abort ();
4335 }
4336
4337 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
4338 | SEC_LINKER_CREATED);
4339
4340 got = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
4341 if (!got
4342 || !bfd_set_section_alignment (abfd, got, 3))
4343 return FALSE;
4344
4345 relgot = bfd_make_section_anyway_with_flags (abfd, ".rela.got",
4346 flags | SEC_READONLY);
4347 if (!relgot
4348 || ! bfd_set_section_alignment (abfd, relgot, 3))
4349 return FALSE;
4350
4351 ppc64_elf_tdata (abfd)->got = got;
4352 ppc64_elf_tdata (abfd)->relgot = relgot;
4353 return TRUE;
4354 }
4355
4356 /* Create the dynamic sections, and set up shortcuts. */
4357
4358 static bfd_boolean
4359 ppc64_elf_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
4360 {
4361 struct ppc_link_hash_table *htab;
4362
4363 if (!_bfd_elf_create_dynamic_sections (dynobj, info))
4364 return FALSE;
4365
4366 htab = ppc_hash_table (info);
4367 if (htab == NULL)
4368 return FALSE;
4369
4370 if (!htab->got)
4371 htab->got = bfd_get_linker_section (dynobj, ".got");
4372 htab->plt = bfd_get_linker_section (dynobj, ".plt");
4373 htab->relplt = bfd_get_linker_section (dynobj, ".rela.plt");
4374 htab->dynbss = bfd_get_linker_section (dynobj, ".dynbss");
4375 if (!info->shared)
4376 htab->relbss = bfd_get_linker_section (dynobj, ".rela.bss");
4377
4378 if (!htab->got || !htab->plt || !htab->relplt || !htab->dynbss
4379 || (!info->shared && !htab->relbss))
4380 abort ();
4381
4382 return TRUE;
4383 }
4384
4385 /* Follow indirect and warning symbol links. */
4386
4387 static inline struct bfd_link_hash_entry *
4388 follow_link (struct bfd_link_hash_entry *h)
4389 {
4390 while (h->type == bfd_link_hash_indirect
4391 || h->type == bfd_link_hash_warning)
4392 h = h->u.i.link;
4393 return h;
4394 }
4395
4396 static inline struct elf_link_hash_entry *
4397 elf_follow_link (struct elf_link_hash_entry *h)
4398 {
4399 return (struct elf_link_hash_entry *) follow_link (&h->root);
4400 }
4401
4402 static inline struct ppc_link_hash_entry *
4403 ppc_follow_link (struct ppc_link_hash_entry *h)
4404 {
4405 return (struct ppc_link_hash_entry *) follow_link (&h->elf.root);
4406 }
4407
4408 /* Merge PLT info on FROM with that on TO. */
4409
4410 static void
4411 move_plt_plist (struct ppc_link_hash_entry *from,
4412 struct ppc_link_hash_entry *to)
4413 {
4414 if (from->elf.plt.plist != NULL)
4415 {
4416 if (to->elf.plt.plist != NULL)
4417 {
4418 struct plt_entry **entp;
4419 struct plt_entry *ent;
4420
4421 for (entp = &from->elf.plt.plist; (ent = *entp) != NULL; )
4422 {
4423 struct plt_entry *dent;
4424
4425 for (dent = to->elf.plt.plist; dent != NULL; dent = dent->next)
4426 if (dent->addend == ent->addend)
4427 {
4428 dent->plt.refcount += ent->plt.refcount;
4429 *entp = ent->next;
4430 break;
4431 }
4432 if (dent == NULL)
4433 entp = &ent->next;
4434 }
4435 *entp = to->elf.plt.plist;
4436 }
4437
4438 to->elf.plt.plist = from->elf.plt.plist;
4439 from->elf.plt.plist = NULL;
4440 }
4441 }
4442
4443 /* Copy the extra info we tack onto an elf_link_hash_entry. */
4444
4445 static void
4446 ppc64_elf_copy_indirect_symbol (struct bfd_link_info *info,
4447 struct elf_link_hash_entry *dir,
4448 struct elf_link_hash_entry *ind)
4449 {
4450 struct ppc_link_hash_entry *edir, *eind;
4451
4452 edir = (struct ppc_link_hash_entry *) dir;
4453 eind = (struct ppc_link_hash_entry *) ind;
4454
4455 edir->is_func |= eind->is_func;
4456 edir->is_func_descriptor |= eind->is_func_descriptor;
4457 edir->tls_mask |= eind->tls_mask;
4458 if (eind->oh != NULL)
4459 edir->oh = ppc_follow_link (eind->oh);
4460
4461 /* If called to transfer flags for a weakdef during processing
4462 of elf_adjust_dynamic_symbol, don't copy NON_GOT_REF.
4463 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
4464 if (!(ELIMINATE_COPY_RELOCS
4465 && eind->elf.root.type != bfd_link_hash_indirect
4466 && edir->elf.dynamic_adjusted))
4467 edir->elf.non_got_ref |= eind->elf.non_got_ref;
4468
4469 edir->elf.ref_dynamic |= eind->elf.ref_dynamic;
4470 edir->elf.ref_regular |= eind->elf.ref_regular;
4471 edir->elf.ref_regular_nonweak |= eind->elf.ref_regular_nonweak;
4472 edir->elf.needs_plt |= eind->elf.needs_plt;
4473
4474 /* Copy over any dynamic relocs we may have on the indirect sym. */
4475 if (eind->dyn_relocs != NULL)
4476 {
4477 if (edir->dyn_relocs != NULL)
4478 {
4479 struct elf_dyn_relocs **pp;
4480 struct elf_dyn_relocs *p;
4481
4482 /* Add reloc counts against the indirect sym to the direct sym
4483 list. Merge any entries against the same section. */
4484 for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
4485 {
4486 struct elf_dyn_relocs *q;
4487
4488 for (q = edir->dyn_relocs; q != NULL; q = q->next)
4489 if (q->sec == p->sec)
4490 {
4491 q->pc_count += p->pc_count;
4492 q->count += p->count;
4493 *pp = p->next;
4494 break;
4495 }
4496 if (q == NULL)
4497 pp = &p->next;
4498 }
4499 *pp = edir->dyn_relocs;
4500 }
4501
4502 edir->dyn_relocs = eind->dyn_relocs;
4503 eind->dyn_relocs = NULL;
4504 }
4505
4506 /* If we were called to copy over info for a weak sym, that's all.
4507 You might think dyn_relocs need not be copied over; After all,
4508 both syms will be dynamic or both non-dynamic so we're just
4509 moving reloc accounting around. However, ELIMINATE_COPY_RELOCS
4510 code in ppc64_elf_adjust_dynamic_symbol needs to check for
4511 dyn_relocs in read-only sections, and it does so on what is the
4512 DIR sym here. */
4513 if (eind->elf.root.type != bfd_link_hash_indirect)
4514 return;
4515
4516 /* Copy over got entries that we may have already seen to the
4517 symbol which just became indirect. */
4518 if (eind->elf.got.glist != NULL)
4519 {
4520 if (edir->elf.got.glist != NULL)
4521 {
4522 struct got_entry **entp;
4523 struct got_entry *ent;
4524
4525 for (entp = &eind->elf.got.glist; (ent = *entp) != NULL; )
4526 {
4527 struct got_entry *dent;
4528
4529 for (dent = edir->elf.got.glist; dent != NULL; dent = dent->next)
4530 if (dent->addend == ent->addend
4531 && dent->owner == ent->owner
4532 && dent->tls_type == ent->tls_type)
4533 {
4534 dent->got.refcount += ent->got.refcount;
4535 *entp = ent->next;
4536 break;
4537 }
4538 if (dent == NULL)
4539 entp = &ent->next;
4540 }
4541 *entp = edir->elf.got.glist;
4542 }
4543
4544 edir->elf.got.glist = eind->elf.got.glist;
4545 eind->elf.got.glist = NULL;
4546 }
4547
4548 /* And plt entries. */
4549 move_plt_plist (eind, edir);
4550
4551 if (eind->elf.dynindx != -1)
4552 {
4553 if (edir->elf.dynindx != -1)
4554 _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
4555 edir->elf.dynstr_index);
4556 edir->elf.dynindx = eind->elf.dynindx;
4557 edir->elf.dynstr_index = eind->elf.dynstr_index;
4558 eind->elf.dynindx = -1;
4559 eind->elf.dynstr_index = 0;
4560 }
4561 }
4562
4563 /* Find the function descriptor hash entry from the given function code
4564 hash entry FH. Link the entries via their OH fields. */
4565
4566 static struct ppc_link_hash_entry *
4567 lookup_fdh (struct ppc_link_hash_entry *fh, struct ppc_link_hash_table *htab)
4568 {
4569 struct ppc_link_hash_entry *fdh = fh->oh;
4570
4571 if (fdh == NULL)
4572 {
4573 const char *fd_name = fh->elf.root.root.string + 1;
4574
4575 fdh = (struct ppc_link_hash_entry *)
4576 elf_link_hash_lookup (&htab->elf, fd_name, FALSE, FALSE, FALSE);
4577 if (fdh == NULL)
4578 return fdh;
4579
4580 fdh->is_func_descriptor = 1;
4581 fdh->oh = fh;
4582 fh->is_func = 1;
4583 fh->oh = fdh;
4584 }
4585
4586 return ppc_follow_link (fdh);
4587 }
4588
4589 /* Make a fake function descriptor sym for the code sym FH. */
4590
4591 static struct ppc_link_hash_entry *
4592 make_fdh (struct bfd_link_info *info,
4593 struct ppc_link_hash_entry *fh)
4594 {
4595 bfd *abfd;
4596 asymbol *newsym;
4597 struct bfd_link_hash_entry *bh;
4598 struct ppc_link_hash_entry *fdh;
4599
4600 abfd = fh->elf.root.u.undef.abfd;
4601 newsym = bfd_make_empty_symbol (abfd);
4602 newsym->name = fh->elf.root.root.string + 1;
4603 newsym->section = bfd_und_section_ptr;
4604 newsym->value = 0;
4605 newsym->flags = BSF_WEAK;
4606
4607 bh = NULL;
4608 if (!_bfd_generic_link_add_one_symbol (info, abfd, newsym->name,
4609 newsym->flags, newsym->section,
4610 newsym->value, NULL, FALSE, FALSE,
4611 &bh))
4612 return NULL;
4613
4614 fdh = (struct ppc_link_hash_entry *) bh;
4615 fdh->elf.non_elf = 0;
4616 fdh->fake = 1;
4617 fdh->is_func_descriptor = 1;
4618 fdh->oh = fh;
4619 fh->is_func = 1;
4620 fh->oh = fdh;
4621 return fdh;
4622 }
4623
4624 /* Fix function descriptor symbols defined in .opd sections to be
4625 function type. */
4626
4627 static bfd_boolean
4628 ppc64_elf_add_symbol_hook (bfd *ibfd,
4629 struct bfd_link_info *info,
4630 Elf_Internal_Sym *isym,
4631 const char **name ATTRIBUTE_UNUSED,
4632 flagword *flags ATTRIBUTE_UNUSED,
4633 asection **sec,
4634 bfd_vma *value ATTRIBUTE_UNUSED)
4635 {
4636 if ((ibfd->flags & DYNAMIC) == 0
4637 && ELF_ST_BIND (isym->st_info) == STB_GNU_UNIQUE)
4638 elf_tdata (info->output_bfd)->has_gnu_symbols = TRUE;
4639
4640 if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
4641 {
4642 if ((ibfd->flags & DYNAMIC) == 0)
4643 elf_tdata (info->output_bfd)->has_gnu_symbols = TRUE;
4644 }
4645 else if (ELF_ST_TYPE (isym->st_info) == STT_FUNC)
4646 ;
4647 else if (*sec != NULL
4648 && strcmp ((*sec)->name, ".opd") == 0)
4649 isym->st_info = ELF_ST_INFO (ELF_ST_BIND (isym->st_info), STT_FUNC);
4650
4651 return TRUE;
4652 }
4653
4654 /* This function makes an old ABI object reference to ".bar" cause the
4655 inclusion of a new ABI object archive that defines "bar".
4656 NAME is a symbol defined in an archive. Return a symbol in the hash
4657 table that might be satisfied by the archive symbols. */
4658
4659 static struct elf_link_hash_entry *
4660 ppc64_elf_archive_symbol_lookup (bfd *abfd,
4661 struct bfd_link_info *info,
4662 const char *name)
4663 {
4664 struct elf_link_hash_entry *h;
4665 char *dot_name;
4666 size_t len;
4667
4668 h = _bfd_elf_archive_symbol_lookup (abfd, info, name);
4669 if (h != NULL
4670 /* Don't return this sym if it is a fake function descriptor
4671 created by add_symbol_adjust. */
4672 && !(h->root.type == bfd_link_hash_undefweak
4673 && ((struct ppc_link_hash_entry *) h)->fake))
4674 return h;
4675
4676 if (name[0] == '.')
4677 return h;
4678
4679 len = strlen (name);
4680 dot_name = bfd_alloc (abfd, len + 2);
4681 if (dot_name == NULL)
4682 return (struct elf_link_hash_entry *) 0 - 1;
4683 dot_name[0] = '.';
4684 memcpy (dot_name + 1, name, len + 1);
4685 h = _bfd_elf_archive_symbol_lookup (abfd, info, dot_name);
4686 bfd_release (abfd, dot_name);
4687 return h;
4688 }
4689
4690 /* This function satisfies all old ABI object references to ".bar" if a
4691 new ABI object defines "bar". Well, at least, undefined dot symbols
4692 are made weak. This stops later archive searches from including an
4693 object if we already have a function descriptor definition. It also
4694 prevents the linker complaining about undefined symbols.
4695 We also check and correct mismatched symbol visibility here. The
4696 most restrictive visibility of the function descriptor and the
4697 function entry symbol is used. */
4698
4699 static bfd_boolean
4700 add_symbol_adjust (struct ppc_link_hash_entry *eh, struct bfd_link_info *info)
4701 {
4702 struct ppc_link_hash_table *htab;
4703 struct ppc_link_hash_entry *fdh;
4704
4705 if (eh->elf.root.type == bfd_link_hash_indirect)
4706 return TRUE;
4707
4708 if (eh->elf.root.type == bfd_link_hash_warning)
4709 eh = (struct ppc_link_hash_entry *) eh->elf.root.u.i.link;
4710
4711 if (eh->elf.root.root.string[0] != '.')
4712 abort ();
4713
4714 htab = ppc_hash_table (info);
4715 if (htab == NULL)
4716 return FALSE;
4717
4718 fdh = lookup_fdh (eh, htab);
4719 if (fdh == NULL)
4720 {
4721 if (!info->relocatable
4722 && (eh->elf.root.type == bfd_link_hash_undefined
4723 || eh->elf.root.type == bfd_link_hash_undefweak)
4724 && eh->elf.ref_regular)
4725 {
4726 /* Make an undefweak function descriptor sym, which is enough to
4727 pull in an --as-needed shared lib, but won't cause link
4728 errors. Archives are handled elsewhere. */
4729 fdh = make_fdh (info, eh);
4730 if (fdh == NULL)
4731 return FALSE;
4732 fdh->elf.ref_regular = 1;
4733 }
4734 }
4735 else
4736 {
4737 unsigned entry_vis = ELF_ST_VISIBILITY (eh->elf.other) - 1;
4738 unsigned descr_vis = ELF_ST_VISIBILITY (fdh->elf.other) - 1;
4739 if (entry_vis < descr_vis)
4740 fdh->elf.other += entry_vis - descr_vis;
4741 else if (entry_vis > descr_vis)
4742 eh->elf.other += descr_vis - entry_vis;
4743
4744 if ((fdh->elf.root.type == bfd_link_hash_defined
4745 || fdh->elf.root.type == bfd_link_hash_defweak)
4746 && eh->elf.root.type == bfd_link_hash_undefined)
4747 {
4748 eh->elf.root.type = bfd_link_hash_undefweak;
4749 eh->was_undefined = 1;
4750 htab->twiddled_syms = 1;
4751 }
4752 }
4753
4754 return TRUE;
4755 }
4756
4757 /* Process list of dot-symbols we made in link_hash_newfunc. */
4758
4759 static bfd_boolean
4760 ppc64_elf_process_dot_syms (bfd *ibfd, struct bfd_link_info *info)
4761 {
4762 struct ppc_link_hash_table *htab;
4763 struct ppc_link_hash_entry **p, *eh;
4764
4765 if (!is_ppc64_elf (info->output_bfd))
4766 return TRUE;
4767 htab = ppc_hash_table (info);
4768 if (htab == NULL)
4769 return FALSE;
4770
4771 if (is_ppc64_elf (ibfd))
4772 {
4773 p = &htab->dot_syms;
4774 while ((eh = *p) != NULL)
4775 {
4776 *p = NULL;
4777 if (!add_symbol_adjust (eh, info))
4778 return FALSE;
4779 p = &eh->u.next_dot_sym;
4780 }
4781 }
4782
4783 /* Clear the list for non-ppc64 input files. */
4784 p = &htab->dot_syms;
4785 while ((eh = *p) != NULL)
4786 {
4787 *p = NULL;
4788 p = &eh->u.next_dot_sym;
4789 }
4790
4791 /* We need to fix the undefs list for any syms we have twiddled to
4792 undef_weak. */
4793 if (htab->twiddled_syms)
4794 {
4795 bfd_link_repair_undef_list (&htab->elf.root);
4796 htab->twiddled_syms = 0;
4797 }
4798 return TRUE;
4799 }
4800
4801 /* Undo hash table changes when an --as-needed input file is determined
4802 not to be needed. */
4803
4804 static bfd_boolean
4805 ppc64_elf_as_needed_cleanup (bfd *ibfd ATTRIBUTE_UNUSED,
4806 struct bfd_link_info *info)
4807 {
4808 struct ppc_link_hash_table *htab = ppc_hash_table (info);
4809
4810 if (htab == NULL)
4811 return FALSE;
4812
4813 htab->dot_syms = NULL;
4814 return TRUE;
4815 }
4816
4817 /* If --just-symbols against a final linked binary, then assume we need
4818 toc adjusting stubs when calling functions defined there. */
4819
4820 static void
4821 ppc64_elf_link_just_syms (asection *sec, struct bfd_link_info *info)
4822 {
4823 if ((sec->flags & SEC_CODE) != 0
4824 && (sec->owner->flags & (EXEC_P | DYNAMIC)) != 0
4825 && is_ppc64_elf (sec->owner))
4826 {
4827 asection *got = bfd_get_section_by_name (sec->owner, ".got");
4828 if (got != NULL
4829 && got->size >= elf_backend_got_header_size
4830 && bfd_get_section_by_name (sec->owner, ".opd") != NULL)
4831 sec->has_toc_reloc = 1;
4832 }
4833 _bfd_elf_link_just_syms (sec, info);
4834 }
4835
4836 static struct plt_entry **
4837 update_local_sym_info (bfd *abfd, Elf_Internal_Shdr *symtab_hdr,
4838 unsigned long r_symndx, bfd_vma r_addend, int tls_type)
4839 {
4840 struct got_entry **local_got_ents = elf_local_got_ents (abfd);
4841 struct plt_entry **local_plt;
4842 unsigned char *local_got_tls_masks;
4843
4844 if (local_got_ents == NULL)
4845 {
4846 bfd_size_type size = symtab_hdr->sh_info;
4847
4848 size *= (sizeof (*local_got_ents)
4849 + sizeof (*local_plt)
4850 + sizeof (*local_got_tls_masks));
4851 local_got_ents = bfd_zalloc (abfd, size);
4852 if (local_got_ents == NULL)
4853 return NULL;
4854 elf_local_got_ents (abfd) = local_got_ents;
4855 }
4856
4857 if ((tls_type & (PLT_IFUNC | TLS_EXPLICIT)) == 0)
4858 {
4859 struct got_entry *ent;
4860
4861 for (ent = local_got_ents[r_symndx]; ent != NULL; ent = ent->next)
4862 if (ent->addend == r_addend
4863 && ent->owner == abfd
4864 && ent->tls_type == tls_type)
4865 break;
4866 if (ent == NULL)
4867 {
4868 bfd_size_type amt = sizeof (*ent);
4869 ent = bfd_alloc (abfd, amt);
4870 if (ent == NULL)
4871 return FALSE;
4872 ent->next = local_got_ents[r_symndx];
4873 ent->addend = r_addend;
4874 ent->owner = abfd;
4875 ent->tls_type = tls_type;
4876 ent->is_indirect = FALSE;
4877 ent->got.refcount = 0;
4878 local_got_ents[r_symndx] = ent;
4879 }
4880 ent->got.refcount += 1;
4881 }
4882
4883 local_plt = (struct plt_entry **) (local_got_ents + symtab_hdr->sh_info);
4884 local_got_tls_masks = (unsigned char *) (local_plt + symtab_hdr->sh_info);
4885 local_got_tls_masks[r_symndx] |= tls_type;
4886
4887 return local_plt + r_symndx;
4888 }
4889
4890 static bfd_boolean
4891 update_plt_info (bfd *abfd, struct plt_entry **plist, bfd_vma addend)
4892 {
4893 struct plt_entry *ent;
4894
4895 for (ent = *plist; ent != NULL; ent = ent->next)
4896 if (ent->addend == addend)
4897 break;
4898 if (ent == NULL)
4899 {
4900 bfd_size_type amt = sizeof (*ent);
4901 ent = bfd_alloc (abfd, amt);
4902 if (ent == NULL)
4903 return FALSE;
4904 ent->next = *plist;
4905 ent->addend = addend;
4906 ent->plt.refcount = 0;
4907 *plist = ent;
4908 }
4909 ent->plt.refcount += 1;
4910 return TRUE;
4911 }
4912
4913 static bfd_boolean
4914 is_branch_reloc (enum elf_ppc64_reloc_type r_type)
4915 {
4916 return (r_type == R_PPC64_REL24
4917 || r_type == R_PPC64_REL14
4918 || r_type == R_PPC64_REL14_BRTAKEN
4919 || r_type == R_PPC64_REL14_BRNTAKEN
4920 || r_type == R_PPC64_ADDR24
4921 || r_type == R_PPC64_ADDR14
4922 || r_type == R_PPC64_ADDR14_BRTAKEN
4923 || r_type == R_PPC64_ADDR14_BRNTAKEN);
4924 }
4925
4926 /* Look through the relocs for a section during the first phase, and
4927 calculate needed space in the global offset table, procedure
4928 linkage table, and dynamic reloc sections. */
4929
4930 static bfd_boolean
4931 ppc64_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
4932 asection *sec, const Elf_Internal_Rela *relocs)
4933 {
4934 struct ppc_link_hash_table *htab;
4935 Elf_Internal_Shdr *symtab_hdr;
4936 struct elf_link_hash_entry **sym_hashes;
4937 const Elf_Internal_Rela *rel;
4938 const Elf_Internal_Rela *rel_end;
4939 asection *sreloc;
4940 asection **opd_sym_map;
4941 struct elf_link_hash_entry *tga, *dottga;
4942
4943 if (info->relocatable)
4944 return TRUE;
4945
4946 /* Don't do anything special with non-loaded, non-alloced sections.
4947 In particular, any relocs in such sections should not affect GOT
4948 and PLT reference counting (ie. we don't allow them to create GOT
4949 or PLT entries), there's no possibility or desire to optimize TLS
4950 relocs, and there's not much point in propagating relocs to shared
4951 libs that the dynamic linker won't relocate. */
4952 if ((sec->flags & SEC_ALLOC) == 0)
4953 return TRUE;
4954
4955 BFD_ASSERT (is_ppc64_elf (abfd));
4956
4957 htab = ppc_hash_table (info);
4958 if (htab == NULL)
4959 return FALSE;
4960
4961 tga = elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
4962 FALSE, FALSE, TRUE);
4963 dottga = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
4964 FALSE, FALSE, TRUE);
4965 symtab_hdr = &elf_symtab_hdr (abfd);
4966 sym_hashes = elf_sym_hashes (abfd);
4967 sreloc = NULL;
4968 opd_sym_map = NULL;
4969 if (strcmp (sec->name, ".opd") == 0)
4970 {
4971 /* Garbage collection needs some extra help with .opd sections.
4972 We don't want to necessarily keep everything referenced by
4973 relocs in .opd, as that would keep all functions. Instead,
4974 if we reference an .opd symbol (a function descriptor), we
4975 want to keep the function code symbol's section. This is
4976 easy for global symbols, but for local syms we need to keep
4977 information about the associated function section. */
4978 bfd_size_type amt;
4979
4980 amt = sec->size * sizeof (*opd_sym_map) / 8;
4981 opd_sym_map = bfd_zalloc (abfd, amt);
4982 if (opd_sym_map == NULL)
4983 return FALSE;
4984 ppc64_elf_section_data (sec)->u.opd.func_sec = opd_sym_map;
4985 BFD_ASSERT (ppc64_elf_section_data (sec)->sec_type == sec_normal);
4986 ppc64_elf_section_data (sec)->sec_type = sec_opd;
4987 }
4988
4989 rel_end = relocs + sec->reloc_count;
4990 for (rel = relocs; rel < rel_end; rel++)
4991 {
4992 unsigned long r_symndx;
4993 struct elf_link_hash_entry *h;
4994 enum elf_ppc64_reloc_type r_type;
4995 int tls_type;
4996 struct _ppc64_elf_section_data *ppc64_sec;
4997 struct plt_entry **ifunc;
4998
4999 r_symndx = ELF64_R_SYM (rel->r_info);
5000 if (r_symndx < symtab_hdr->sh_info)
5001 h = NULL;
5002 else
5003 {
5004 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
5005 h = elf_follow_link (h);
5006
5007 /* PR15323, ref flags aren't set for references in the same
5008 object. */
5009 h->root.non_ir_ref = 1;
5010 }
5011
5012 tls_type = 0;
5013 ifunc = NULL;
5014 if (h != NULL)
5015 {
5016 if (h->type == STT_GNU_IFUNC)
5017 {
5018 h->needs_plt = 1;
5019 ifunc = &h->plt.plist;
5020 }
5021 }
5022 else
5023 {
5024 Elf_Internal_Sym *isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5025 abfd, r_symndx);
5026 if (isym == NULL)
5027 return FALSE;
5028
5029 if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
5030 {
5031 ifunc = update_local_sym_info (abfd, symtab_hdr, r_symndx,
5032 rel->r_addend, PLT_IFUNC);
5033 if (ifunc == NULL)
5034 return FALSE;
5035 }
5036 }
5037 r_type = ELF64_R_TYPE (rel->r_info);
5038 if (is_branch_reloc (r_type))
5039 {
5040 if (h != NULL && (h == tga || h == dottga))
5041 {
5042 if (rel != relocs
5043 && (ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSGD
5044 || ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSLD))
5045 /* We have a new-style __tls_get_addr call with a marker
5046 reloc. */
5047 ;
5048 else
5049 /* Mark this section as having an old-style call. */
5050 sec->has_tls_get_addr_call = 1;
5051 }
5052
5053 /* STT_GNU_IFUNC symbols must have a PLT entry. */
5054 if (ifunc != NULL
5055 && !update_plt_info (abfd, ifunc, rel->r_addend))
5056 return FALSE;
5057 }
5058
5059 switch (r_type)
5060 {
5061 case R_PPC64_TLSGD:
5062 case R_PPC64_TLSLD:
5063 /* These special tls relocs tie a call to __tls_get_addr with
5064 its parameter symbol. */
5065 break;
5066
5067 case R_PPC64_GOT_TLSLD16:
5068 case R_PPC64_GOT_TLSLD16_LO:
5069 case R_PPC64_GOT_TLSLD16_HI:
5070 case R_PPC64_GOT_TLSLD16_HA:
5071 tls_type = TLS_TLS | TLS_LD;
5072 goto dogottls;
5073
5074 case R_PPC64_GOT_TLSGD16:
5075 case R_PPC64_GOT_TLSGD16_LO:
5076 case R_PPC64_GOT_TLSGD16_HI:
5077 case R_PPC64_GOT_TLSGD16_HA:
5078 tls_type = TLS_TLS | TLS_GD;
5079 goto dogottls;
5080
5081 case R_PPC64_GOT_TPREL16_DS:
5082 case R_PPC64_GOT_TPREL16_LO_DS:
5083 case R_PPC64_GOT_TPREL16_HI:
5084 case R_PPC64_GOT_TPREL16_HA:
5085 if (!info->executable)
5086 info->flags |= DF_STATIC_TLS;
5087 tls_type = TLS_TLS | TLS_TPREL;
5088 goto dogottls;
5089
5090 case R_PPC64_GOT_DTPREL16_DS:
5091 case R_PPC64_GOT_DTPREL16_LO_DS:
5092 case R_PPC64_GOT_DTPREL16_HI:
5093 case R_PPC64_GOT_DTPREL16_HA:
5094 tls_type = TLS_TLS | TLS_DTPREL;
5095 dogottls:
5096 sec->has_tls_reloc = 1;
5097 /* Fall thru */
5098
5099 case R_PPC64_GOT16:
5100 case R_PPC64_GOT16_DS:
5101 case R_PPC64_GOT16_HA:
5102 case R_PPC64_GOT16_HI:
5103 case R_PPC64_GOT16_LO:
5104 case R_PPC64_GOT16_LO_DS:
5105 /* This symbol requires a global offset table entry. */
5106 sec->has_toc_reloc = 1;
5107 if (r_type == R_PPC64_GOT_TLSLD16
5108 || r_type == R_PPC64_GOT_TLSGD16
5109 || r_type == R_PPC64_GOT_TPREL16_DS
5110 || r_type == R_PPC64_GOT_DTPREL16_DS
5111 || r_type == R_PPC64_GOT16
5112 || r_type == R_PPC64_GOT16_DS)
5113 {
5114 htab->do_multi_toc = 1;
5115 ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5116 }
5117
5118 if (ppc64_elf_tdata (abfd)->got == NULL
5119 && !create_got_section (abfd, info))
5120 return FALSE;
5121
5122 if (h != NULL)
5123 {
5124 struct ppc_link_hash_entry *eh;
5125 struct got_entry *ent;
5126
5127 eh = (struct ppc_link_hash_entry *) h;
5128 for (ent = eh->elf.got.glist; ent != NULL; ent = ent->next)
5129 if (ent->addend == rel->r_addend
5130 && ent->owner == abfd
5131 && ent->tls_type == tls_type)
5132 break;
5133 if (ent == NULL)
5134 {
5135 bfd_size_type amt = sizeof (*ent);
5136 ent = bfd_alloc (abfd, amt);
5137 if (ent == NULL)
5138 return FALSE;
5139 ent->next = eh->elf.got.glist;
5140 ent->addend = rel->r_addend;
5141 ent->owner = abfd;
5142 ent->tls_type = tls_type;
5143 ent->is_indirect = FALSE;
5144 ent->got.refcount = 0;
5145 eh->elf.got.glist = ent;
5146 }
5147 ent->got.refcount += 1;
5148 eh->tls_mask |= tls_type;
5149 }
5150 else
5151 /* This is a global offset table entry for a local symbol. */
5152 if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5153 rel->r_addend, tls_type))
5154 return FALSE;
5155 break;
5156
5157 case R_PPC64_PLT16_HA:
5158 case R_PPC64_PLT16_HI:
5159 case R_PPC64_PLT16_LO:
5160 case R_PPC64_PLT32:
5161 case R_PPC64_PLT64:
5162 /* This symbol requires a procedure linkage table entry. We
5163 actually build the entry in adjust_dynamic_symbol,
5164 because this might be a case of linking PIC code without
5165 linking in any dynamic objects, in which case we don't
5166 need to generate a procedure linkage table after all. */
5167 if (h == NULL)
5168 {
5169 /* It does not make sense to have a procedure linkage
5170 table entry for a local symbol. */
5171 bfd_set_error (bfd_error_bad_value);
5172 return FALSE;
5173 }
5174 else
5175 {
5176 if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5177 return FALSE;
5178 h->needs_plt = 1;
5179 if (h->root.root.string[0] == '.'
5180 && h->root.root.string[1] != '\0')
5181 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5182 }
5183 break;
5184
5185 /* The following relocations don't need to propagate the
5186 relocation if linking a shared object since they are
5187 section relative. */
5188 case R_PPC64_SECTOFF:
5189 case R_PPC64_SECTOFF_LO:
5190 case R_PPC64_SECTOFF_HI:
5191 case R_PPC64_SECTOFF_HA:
5192 case R_PPC64_SECTOFF_DS:
5193 case R_PPC64_SECTOFF_LO_DS:
5194 case R_PPC64_DTPREL16:
5195 case R_PPC64_DTPREL16_LO:
5196 case R_PPC64_DTPREL16_HI:
5197 case R_PPC64_DTPREL16_HA:
5198 case R_PPC64_DTPREL16_DS:
5199 case R_PPC64_DTPREL16_LO_DS:
5200 case R_PPC64_DTPREL16_HIGHER:
5201 case R_PPC64_DTPREL16_HIGHERA:
5202 case R_PPC64_DTPREL16_HIGHEST:
5203 case R_PPC64_DTPREL16_HIGHESTA:
5204 break;
5205
5206 /* Nor do these. */
5207 case R_PPC64_REL16:
5208 case R_PPC64_REL16_LO:
5209 case R_PPC64_REL16_HI:
5210 case R_PPC64_REL16_HA:
5211 break;
5212
5213 case R_PPC64_TOC16:
5214 case R_PPC64_TOC16_DS:
5215 htab->do_multi_toc = 1;
5216 ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5217 case R_PPC64_TOC16_LO:
5218 case R_PPC64_TOC16_HI:
5219 case R_PPC64_TOC16_HA:
5220 case R_PPC64_TOC16_LO_DS:
5221 sec->has_toc_reloc = 1;
5222 break;
5223
5224 /* This relocation describes the C++ object vtable hierarchy.
5225 Reconstruct it for later use during GC. */
5226 case R_PPC64_GNU_VTINHERIT:
5227 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
5228 return FALSE;
5229 break;
5230
5231 /* This relocation describes which C++ vtable entries are actually
5232 used. Record for later use during GC. */
5233 case R_PPC64_GNU_VTENTRY:
5234 BFD_ASSERT (h != NULL);
5235 if (h != NULL
5236 && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
5237 return FALSE;
5238 break;
5239
5240 case R_PPC64_REL14:
5241 case R_PPC64_REL14_BRTAKEN:
5242 case R_PPC64_REL14_BRNTAKEN:
5243 {
5244 asection *dest = NULL;
5245
5246 /* Heuristic: If jumping outside our section, chances are
5247 we are going to need a stub. */
5248 if (h != NULL)
5249 {
5250 /* If the sym is weak it may be overridden later, so
5251 don't assume we know where a weak sym lives. */
5252 if (h->root.type == bfd_link_hash_defined)
5253 dest = h->root.u.def.section;
5254 }
5255 else
5256 {
5257 Elf_Internal_Sym *isym;
5258
5259 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5260 abfd, r_symndx);
5261 if (isym == NULL)
5262 return FALSE;
5263
5264 dest = bfd_section_from_elf_index (abfd, isym->st_shndx);
5265 }
5266
5267 if (dest != sec)
5268 ppc64_elf_section_data (sec)->has_14bit_branch = 1;
5269 }
5270 /* Fall through. */
5271
5272 case R_PPC64_REL24:
5273 if (h != NULL && ifunc == NULL)
5274 {
5275 /* We may need a .plt entry if the function this reloc
5276 refers to is in a shared lib. */
5277 if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5278 return FALSE;
5279 h->needs_plt = 1;
5280 if (h->root.root.string[0] == '.'
5281 && h->root.root.string[1] != '\0')
5282 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5283 if (h == tga || h == dottga)
5284 sec->has_tls_reloc = 1;
5285 }
5286 break;
5287
5288 case R_PPC64_TPREL64:
5289 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_TPREL;
5290 if (!info->executable)
5291 info->flags |= DF_STATIC_TLS;
5292 goto dotlstoc;
5293
5294 case R_PPC64_DTPMOD64:
5295 if (rel + 1 < rel_end
5296 && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
5297 && rel[1].r_offset == rel->r_offset + 8)
5298 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_GD;
5299 else
5300 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_LD;
5301 goto dotlstoc;
5302
5303 case R_PPC64_DTPREL64:
5304 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_DTPREL;
5305 if (rel != relocs
5306 && rel[-1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPMOD64)
5307 && rel[-1].r_offset == rel->r_offset - 8)
5308 /* This is the second reloc of a dtpmod, dtprel pair.
5309 Don't mark with TLS_DTPREL. */
5310 goto dodyn;
5311
5312 dotlstoc:
5313 sec->has_tls_reloc = 1;
5314 if (h != NULL)
5315 {
5316 struct ppc_link_hash_entry *eh;
5317 eh = (struct ppc_link_hash_entry *) h;
5318 eh->tls_mask |= tls_type;
5319 }
5320 else
5321 if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5322 rel->r_addend, tls_type))
5323 return FALSE;
5324
5325 ppc64_sec = ppc64_elf_section_data (sec);
5326 if (ppc64_sec->sec_type != sec_toc)
5327 {
5328 bfd_size_type amt;
5329
5330 /* One extra to simplify get_tls_mask. */
5331 amt = sec->size * sizeof (unsigned) / 8 + sizeof (unsigned);
5332 ppc64_sec->u.toc.symndx = bfd_zalloc (abfd, amt);
5333 if (ppc64_sec->u.toc.symndx == NULL)
5334 return FALSE;
5335 amt = sec->size * sizeof (bfd_vma) / 8;
5336 ppc64_sec->u.toc.add = bfd_zalloc (abfd, amt);
5337 if (ppc64_sec->u.toc.add == NULL)
5338 return FALSE;
5339 BFD_ASSERT (ppc64_sec->sec_type == sec_normal);
5340 ppc64_sec->sec_type = sec_toc;
5341 }
5342 BFD_ASSERT (rel->r_offset % 8 == 0);
5343 ppc64_sec->u.toc.symndx[rel->r_offset / 8] = r_symndx;
5344 ppc64_sec->u.toc.add[rel->r_offset / 8] = rel->r_addend;
5345
5346 /* Mark the second slot of a GD or LD entry.
5347 -1 to indicate GD and -2 to indicate LD. */
5348 if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_GD))
5349 ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -1;
5350 else if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_LD))
5351 ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -2;
5352 goto dodyn;
5353
5354 case R_PPC64_TPREL16:
5355 case R_PPC64_TPREL16_LO:
5356 case R_PPC64_TPREL16_HI:
5357 case R_PPC64_TPREL16_HA:
5358 case R_PPC64_TPREL16_DS:
5359 case R_PPC64_TPREL16_LO_DS:
5360 case R_PPC64_TPREL16_HIGHER:
5361 case R_PPC64_TPREL16_HIGHERA:
5362 case R_PPC64_TPREL16_HIGHEST:
5363 case R_PPC64_TPREL16_HIGHESTA:
5364 if (info->shared)
5365 {
5366 if (!info->executable)
5367 info->flags |= DF_STATIC_TLS;
5368 goto dodyn;
5369 }
5370 break;
5371
5372 case R_PPC64_ADDR64:
5373 if (opd_sym_map != NULL
5374 && rel + 1 < rel_end
5375 && ELF64_R_TYPE ((rel + 1)->r_info) == R_PPC64_TOC)
5376 {
5377 if (h != NULL)
5378 {
5379 if (h->root.root.string[0] == '.'
5380 && h->root.root.string[1] != 0
5381 && lookup_fdh ((struct ppc_link_hash_entry *) h, htab))
5382 ;
5383 else
5384 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5385 }
5386 else
5387 {
5388 asection *s;
5389 Elf_Internal_Sym *isym;
5390
5391 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5392 abfd, r_symndx);
5393 if (isym == NULL)
5394 return FALSE;
5395
5396 s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5397 if (s != NULL && s != sec)
5398 opd_sym_map[rel->r_offset / 8] = s;
5399 }
5400 }
5401 /* Fall through. */
5402
5403 case R_PPC64_REL30:
5404 case R_PPC64_REL32:
5405 case R_PPC64_REL64:
5406 case R_PPC64_ADDR14:
5407 case R_PPC64_ADDR14_BRNTAKEN:
5408 case R_PPC64_ADDR14_BRTAKEN:
5409 case R_PPC64_ADDR16:
5410 case R_PPC64_ADDR16_DS:
5411 case R_PPC64_ADDR16_HA:
5412 case R_PPC64_ADDR16_HI:
5413 case R_PPC64_ADDR16_HIGHER:
5414 case R_PPC64_ADDR16_HIGHERA:
5415 case R_PPC64_ADDR16_HIGHEST:
5416 case R_PPC64_ADDR16_HIGHESTA:
5417 case R_PPC64_ADDR16_LO:
5418 case R_PPC64_ADDR16_LO_DS:
5419 case R_PPC64_ADDR24:
5420 case R_PPC64_ADDR32:
5421 case R_PPC64_UADDR16:
5422 case R_PPC64_UADDR32:
5423 case R_PPC64_UADDR64:
5424 case R_PPC64_TOC:
5425 if (h != NULL && !info->shared)
5426 /* We may need a copy reloc. */
5427 h->non_got_ref = 1;
5428
5429 /* Don't propagate .opd relocs. */
5430 if (NO_OPD_RELOCS && opd_sym_map != NULL)
5431 break;
5432
5433 /* If we are creating a shared library, and this is a reloc
5434 against a global symbol, or a non PC relative reloc
5435 against a local symbol, then we need to copy the reloc
5436 into the shared library. However, if we are linking with
5437 -Bsymbolic, we do not need to copy a reloc against a
5438 global symbol which is defined in an object we are
5439 including in the link (i.e., DEF_REGULAR is set). At
5440 this point we have not seen all the input files, so it is
5441 possible that DEF_REGULAR is not set now but will be set
5442 later (it is never cleared). In case of a weak definition,
5443 DEF_REGULAR may be cleared later by a strong definition in
5444 a shared library. We account for that possibility below by
5445 storing information in the dyn_relocs field of the hash
5446 table entry. A similar situation occurs when creating
5447 shared libraries and symbol visibility changes render the
5448 symbol local.
5449
5450 If on the other hand, we are creating an executable, we
5451 may need to keep relocations for symbols satisfied by a
5452 dynamic library if we manage to avoid copy relocs for the
5453 symbol. */
5454 dodyn:
5455 if ((info->shared
5456 && (must_be_dyn_reloc (info, r_type)
5457 || (h != NULL
5458 && (!SYMBOLIC_BIND (info, h)
5459 || h->root.type == bfd_link_hash_defweak
5460 || !h->def_regular))))
5461 || (ELIMINATE_COPY_RELOCS
5462 && !info->shared
5463 && h != NULL
5464 && (h->root.type == bfd_link_hash_defweak
5465 || !h->def_regular))
5466 || (!info->shared
5467 && ifunc != NULL))
5468 {
5469 /* We must copy these reloc types into the output file.
5470 Create a reloc section in dynobj and make room for
5471 this reloc. */
5472 if (sreloc == NULL)
5473 {
5474 sreloc = _bfd_elf_make_dynamic_reloc_section
5475 (sec, htab->elf.dynobj, 3, abfd, /*rela?*/ TRUE);
5476
5477 if (sreloc == NULL)
5478 return FALSE;
5479 }
5480
5481 /* If this is a global symbol, we count the number of
5482 relocations we need for this symbol. */
5483 if (h != NULL)
5484 {
5485 struct elf_dyn_relocs *p;
5486 struct elf_dyn_relocs **head;
5487
5488 head = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
5489 p = *head;
5490 if (p == NULL || p->sec != sec)
5491 {
5492 p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5493 if (p == NULL)
5494 return FALSE;
5495 p->next = *head;
5496 *head = p;
5497 p->sec = sec;
5498 p->count = 0;
5499 p->pc_count = 0;
5500 }
5501 p->count += 1;
5502 if (!must_be_dyn_reloc (info, r_type))
5503 p->pc_count += 1;
5504 }
5505 else
5506 {
5507 /* Track dynamic relocs needed for local syms too.
5508 We really need local syms available to do this
5509 easily. Oh well. */
5510 struct ppc_dyn_relocs *p;
5511 struct ppc_dyn_relocs **head;
5512 bfd_boolean is_ifunc;
5513 asection *s;
5514 void *vpp;
5515 Elf_Internal_Sym *isym;
5516
5517 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5518 abfd, r_symndx);
5519 if (isym == NULL)
5520 return FALSE;
5521
5522 s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5523 if (s == NULL)
5524 s = sec;
5525
5526 vpp = &elf_section_data (s)->local_dynrel;
5527 head = (struct ppc_dyn_relocs **) vpp;
5528 is_ifunc = ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC;
5529 p = *head;
5530 if (p != NULL && p->sec == sec && p->ifunc != is_ifunc)
5531 p = p->next;
5532 if (p == NULL || p->sec != sec || p->ifunc != is_ifunc)
5533 {
5534 p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5535 if (p == NULL)
5536 return FALSE;
5537 p->next = *head;
5538 *head = p;
5539 p->sec = sec;
5540 p->ifunc = is_ifunc;
5541 p->count = 0;
5542 }
5543 p->count += 1;
5544 }
5545 }
5546 break;
5547
5548 default:
5549 break;
5550 }
5551 }
5552
5553 return TRUE;
5554 }
5555
5556 /* OFFSET in OPD_SEC specifies a function descriptor. Return the address
5557 of the code entry point, and its section. */
5558
5559 static bfd_vma
5560 opd_entry_value (asection *opd_sec,
5561 bfd_vma offset,
5562 asection **code_sec,
5563 bfd_vma *code_off,
5564 bfd_boolean in_code_sec)
5565 {
5566 bfd *opd_bfd = opd_sec->owner;
5567 Elf_Internal_Rela *relocs;
5568 Elf_Internal_Rela *lo, *hi, *look;
5569 bfd_vma val;
5570
5571 /* No relocs implies we are linking a --just-symbols object, or looking
5572 at a final linked executable with addr2line or somesuch. */
5573 if (opd_sec->reloc_count == 0)
5574 {
5575 char buf[8];
5576
5577 if (!bfd_get_section_contents (opd_bfd, opd_sec, buf, offset, 8))
5578 return (bfd_vma) -1;
5579
5580 val = bfd_get_64 (opd_bfd, buf);
5581 if (code_sec != NULL)
5582 {
5583 asection *sec, *likely = NULL;
5584
5585 if (in_code_sec)
5586 {
5587 sec = *code_sec;
5588 if (sec->vma <= val
5589 && val < sec->vma + sec->size)
5590 likely = sec;
5591 else
5592 val = -1;
5593 }
5594 else
5595 for (sec = opd_bfd->sections; sec != NULL; sec = sec->next)
5596 if (sec->vma <= val
5597 && (sec->flags & SEC_LOAD) != 0
5598 && (sec->flags & SEC_ALLOC) != 0)
5599 likely = sec;
5600 if (likely != NULL)
5601 {
5602 *code_sec = likely;
5603 if (code_off != NULL)
5604 *code_off = val - likely->vma;
5605 }
5606 }
5607 return val;
5608 }
5609
5610 BFD_ASSERT (is_ppc64_elf (opd_bfd));
5611
5612 relocs = ppc64_elf_tdata (opd_bfd)->opd_relocs;
5613 if (relocs == NULL)
5614 relocs = _bfd_elf_link_read_relocs (opd_bfd, opd_sec, NULL, NULL, TRUE);
5615
5616 /* Go find the opd reloc at the sym address. */
5617 lo = relocs;
5618 BFD_ASSERT (lo != NULL);
5619 hi = lo + opd_sec->reloc_count - 1; /* ignore last reloc */
5620 val = (bfd_vma) -1;
5621 while (lo < hi)
5622 {
5623 look = lo + (hi - lo) / 2;
5624 if (look->r_offset < offset)
5625 lo = look + 1;
5626 else if (look->r_offset > offset)
5627 hi = look;
5628 else
5629 {
5630 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (opd_bfd);
5631
5632 if (ELF64_R_TYPE (look->r_info) == R_PPC64_ADDR64
5633 && ELF64_R_TYPE ((look + 1)->r_info) == R_PPC64_TOC)
5634 {
5635 unsigned long symndx = ELF64_R_SYM (look->r_info);
5636 asection *sec;
5637
5638 if (symndx < symtab_hdr->sh_info
5639 || elf_sym_hashes (opd_bfd) == NULL)
5640 {
5641 Elf_Internal_Sym *sym;
5642
5643 sym = (Elf_Internal_Sym *) symtab_hdr->contents;
5644 if (sym == NULL)
5645 {
5646 size_t symcnt = symtab_hdr->sh_info;
5647 if (elf_sym_hashes (opd_bfd) == NULL)
5648 symcnt = symtab_hdr->sh_size / symtab_hdr->sh_entsize;
5649 sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr, symcnt,
5650 0, NULL, NULL, NULL);
5651 if (sym == NULL)
5652 break;
5653 symtab_hdr->contents = (bfd_byte *) sym;
5654 }
5655
5656 sym += symndx;
5657 val = sym->st_value;
5658 sec = bfd_section_from_elf_index (opd_bfd, sym->st_shndx);
5659 BFD_ASSERT ((sec->flags & SEC_MERGE) == 0);
5660 }
5661 else
5662 {
5663 struct elf_link_hash_entry **sym_hashes;
5664 struct elf_link_hash_entry *rh;
5665
5666 sym_hashes = elf_sym_hashes (opd_bfd);
5667 rh = sym_hashes[symndx - symtab_hdr->sh_info];
5668 if (rh != NULL)
5669 {
5670 rh = elf_follow_link (rh);
5671 BFD_ASSERT (rh->root.type == bfd_link_hash_defined
5672 || rh->root.type == bfd_link_hash_defweak);
5673 val = rh->root.u.def.value;
5674 sec = rh->root.u.def.section;
5675 }
5676 else
5677 {
5678 /* Handle the odd case where we can be called
5679 during bfd_elf_link_add_symbols before the
5680 symbol hashes have been fully populated. */
5681 Elf_Internal_Sym *sym;
5682
5683 sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr, 1,
5684 symndx, NULL, NULL, NULL);
5685 if (sym == NULL)
5686 break;
5687
5688 val = sym->st_value;
5689 sec = bfd_section_from_elf_index (opd_bfd, sym->st_shndx);
5690 free (sym);
5691 }
5692 }
5693 val += look->r_addend;
5694 if (code_off != NULL)
5695 *code_off = val;
5696 if (code_sec != NULL)
5697 {
5698 if (in_code_sec && *code_sec != sec)
5699 return -1;
5700 else
5701 *code_sec = sec;
5702 }
5703 if (sec != NULL && sec->output_section != NULL)
5704 val += sec->output_section->vma + sec->output_offset;
5705 }
5706 break;
5707 }
5708 }
5709
5710 return val;
5711 }
5712
5713 /* If the ELF symbol SYM might be a function in SEC, return the
5714 function size and set *CODE_OFF to the function's entry point,
5715 otherwise return zero. */
5716
5717 static bfd_size_type
5718 ppc64_elf_maybe_function_sym (const asymbol *sym, asection *sec,
5719 bfd_vma *code_off)
5720 {
5721 bfd_size_type size;
5722
5723 if ((sym->flags & (BSF_SECTION_SYM | BSF_FILE | BSF_OBJECT
5724 | BSF_THREAD_LOCAL | BSF_RELC | BSF_SRELC)) != 0)
5725 return 0;
5726
5727 size = 0;
5728 if (!(sym->flags & BSF_SYNTHETIC))
5729 size = ((elf_symbol_type *) sym)->internal_elf_sym.st_size;
5730
5731 if (strcmp (sym->section->name, ".opd") == 0)
5732 {
5733 if (opd_entry_value (sym->section, sym->value,
5734 &sec, code_off, TRUE) == (bfd_vma) -1)
5735 return 0;
5736 /* An old ABI binary with dot-syms has a size of 24 on the .opd
5737 symbol. This size has nothing to do with the code size of the
5738 function, which is what we're supposed to return, but the
5739 code size isn't available without looking up the dot-sym.
5740 However, doing that would be a waste of time particularly
5741 since elf_find_function will look at the dot-sym anyway.
5742 Now, elf_find_function will keep the largest size of any
5743 function sym found at the code address of interest, so return
5744 1 here to avoid it incorrectly caching a larger function size
5745 for a small function. This does mean we return the wrong
5746 size for a new-ABI function of size 24, but all that does is
5747 disable caching for such functions. */
5748 if (size == 24)
5749 size = 1;
5750 }
5751 else
5752 {
5753 if (sym->section != sec)
5754 return 0;
5755 *code_off = sym->value;
5756 }
5757 if (size == 0)
5758 size = 1;
5759 return size;
5760 }
5761
5762 /* Return true if symbol is defined in a regular object file. */
5763
5764 static bfd_boolean
5765 is_static_defined (struct elf_link_hash_entry *h)
5766 {
5767 return ((h->root.type == bfd_link_hash_defined
5768 || h->root.type == bfd_link_hash_defweak)
5769 && h->root.u.def.section != NULL
5770 && h->root.u.def.section->output_section != NULL);
5771 }
5772
5773 /* If FDH is a function descriptor symbol, return the associated code
5774 entry symbol if it is defined. Return NULL otherwise. */
5775
5776 static struct ppc_link_hash_entry *
5777 defined_code_entry (struct ppc_link_hash_entry *fdh)
5778 {
5779 if (fdh->is_func_descriptor)
5780 {
5781 struct ppc_link_hash_entry *fh = ppc_follow_link (fdh->oh);
5782 if (fh->elf.root.type == bfd_link_hash_defined
5783 || fh->elf.root.type == bfd_link_hash_defweak)
5784 return fh;
5785 }
5786 return NULL;
5787 }
5788
5789 /* If FH is a function code entry symbol, return the associated
5790 function descriptor symbol if it is defined. Return NULL otherwise. */
5791
5792 static struct ppc_link_hash_entry *
5793 defined_func_desc (struct ppc_link_hash_entry *fh)
5794 {
5795 if (fh->oh != NULL
5796 && fh->oh->is_func_descriptor)
5797 {
5798 struct ppc_link_hash_entry *fdh = ppc_follow_link (fh->oh);
5799 if (fdh->elf.root.type == bfd_link_hash_defined
5800 || fdh->elf.root.type == bfd_link_hash_defweak)
5801 return fdh;
5802 }
5803 return NULL;
5804 }
5805
5806 /* Mark all our entry sym sections, both opd and code section. */
5807
5808 static void
5809 ppc64_elf_gc_keep (struct bfd_link_info *info)
5810 {
5811 struct ppc_link_hash_table *htab = ppc_hash_table (info);
5812 struct bfd_sym_chain *sym;
5813
5814 if (htab == NULL)
5815 return;
5816
5817 for (sym = info->gc_sym_list; sym != NULL; sym = sym->next)
5818 {
5819 struct ppc_link_hash_entry *eh, *fh;
5820 asection *sec;
5821
5822 eh = (struct ppc_link_hash_entry *)
5823 elf_link_hash_lookup (&htab->elf, sym->name, FALSE, FALSE, TRUE);
5824 if (eh == NULL)
5825 continue;
5826 if (eh->elf.root.type != bfd_link_hash_defined
5827 && eh->elf.root.type != bfd_link_hash_defweak)
5828 continue;
5829
5830 fh = defined_code_entry (eh);
5831 if (fh != NULL)
5832 {
5833 sec = fh->elf.root.u.def.section;
5834 sec->flags |= SEC_KEEP;
5835 }
5836 else if (get_opd_info (eh->elf.root.u.def.section) != NULL
5837 && opd_entry_value (eh->elf.root.u.def.section,
5838 eh->elf.root.u.def.value,
5839 &sec, NULL, FALSE) != (bfd_vma) -1)
5840 sec->flags |= SEC_KEEP;
5841
5842 sec = eh->elf.root.u.def.section;
5843 sec->flags |= SEC_KEEP;
5844 }
5845 }
5846
5847 /* Mark sections containing dynamically referenced symbols. When
5848 building shared libraries, we must assume that any visible symbol is
5849 referenced. */
5850
5851 static bfd_boolean
5852 ppc64_elf_gc_mark_dynamic_ref (struct elf_link_hash_entry *h, void *inf)
5853 {
5854 struct bfd_link_info *info = (struct bfd_link_info *) inf;
5855 struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
5856 struct ppc_link_hash_entry *fdh;
5857
5858 /* Dynamic linking info is on the func descriptor sym. */
5859 fdh = defined_func_desc (eh);
5860 if (fdh != NULL)
5861 eh = fdh;
5862
5863 if ((eh->elf.root.type == bfd_link_hash_defined
5864 || eh->elf.root.type == bfd_link_hash_defweak)
5865 && (eh->elf.ref_dynamic
5866 || (!info->executable
5867 && eh->elf.def_regular
5868 && ELF_ST_VISIBILITY (eh->elf.other) != STV_INTERNAL
5869 && ELF_ST_VISIBILITY (eh->elf.other) != STV_HIDDEN
5870 && (strchr (eh->elf.root.root.string, ELF_VER_CHR) != NULL
5871 || !bfd_hide_sym_by_version (info->version_info,
5872 eh->elf.root.root.string)))))
5873 {
5874 asection *code_sec;
5875 struct ppc_link_hash_entry *fh;
5876
5877 eh->elf.root.u.def.section->flags |= SEC_KEEP;
5878
5879 /* Function descriptor syms cause the associated
5880 function code sym section to be marked. */
5881 fh = defined_code_entry (eh);
5882 if (fh != NULL)
5883 {
5884 code_sec = fh->elf.root.u.def.section;
5885 code_sec->flags |= SEC_KEEP;
5886 }
5887 else if (get_opd_info (eh->elf.root.u.def.section) != NULL
5888 && opd_entry_value (eh->elf.root.u.def.section,
5889 eh->elf.root.u.def.value,
5890 &code_sec, NULL, FALSE) != (bfd_vma) -1)
5891 code_sec->flags |= SEC_KEEP;
5892 }
5893
5894 return TRUE;
5895 }
5896
5897 /* Return the section that should be marked against GC for a given
5898 relocation. */
5899
5900 static asection *
5901 ppc64_elf_gc_mark_hook (asection *sec,
5902 struct bfd_link_info *info,
5903 Elf_Internal_Rela *rel,
5904 struct elf_link_hash_entry *h,
5905 Elf_Internal_Sym *sym)
5906 {
5907 asection *rsec;
5908
5909 /* Syms return NULL if we're marking .opd, so we avoid marking all
5910 function sections, as all functions are referenced in .opd. */
5911 rsec = NULL;
5912 if (get_opd_info (sec) != NULL)
5913 return rsec;
5914
5915 if (h != NULL)
5916 {
5917 enum elf_ppc64_reloc_type r_type;
5918 struct ppc_link_hash_entry *eh, *fh, *fdh;
5919
5920 r_type = ELF64_R_TYPE (rel->r_info);
5921 switch (r_type)
5922 {
5923 case R_PPC64_GNU_VTINHERIT:
5924 case R_PPC64_GNU_VTENTRY:
5925 break;
5926
5927 default:
5928 switch (h->root.type)
5929 {
5930 case bfd_link_hash_defined:
5931 case bfd_link_hash_defweak:
5932 eh = (struct ppc_link_hash_entry *) h;
5933 fdh = defined_func_desc (eh);
5934 if (fdh != NULL)
5935 eh = fdh;
5936
5937 /* Function descriptor syms cause the associated
5938 function code sym section to be marked. */
5939 fh = defined_code_entry (eh);
5940 if (fh != NULL)
5941 {
5942 /* They also mark their opd section. */
5943 eh->elf.root.u.def.section->gc_mark = 1;
5944
5945 rsec = fh->elf.root.u.def.section;
5946 }
5947 else if (get_opd_info (eh->elf.root.u.def.section) != NULL
5948 && opd_entry_value (eh->elf.root.u.def.section,
5949 eh->elf.root.u.def.value,
5950 &rsec, NULL, FALSE) != (bfd_vma) -1)
5951 eh->elf.root.u.def.section->gc_mark = 1;
5952 else
5953 rsec = h->root.u.def.section;
5954 break;
5955
5956 case bfd_link_hash_common:
5957 rsec = h->root.u.c.p->section;
5958 break;
5959
5960 default:
5961 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
5962 }
5963 }
5964 }
5965 else
5966 {
5967 struct _opd_sec_data *opd;
5968
5969 rsec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
5970 opd = get_opd_info (rsec);
5971 if (opd != NULL && opd->func_sec != NULL)
5972 {
5973 rsec->gc_mark = 1;
5974
5975 rsec = opd->func_sec[(sym->st_value + rel->r_addend) / 8];
5976 }
5977 }
5978
5979 return rsec;
5980 }
5981
5982 /* Update the .got, .plt. and dynamic reloc reference counts for the
5983 section being removed. */
5984
5985 static bfd_boolean
5986 ppc64_elf_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info,
5987 asection *sec, const Elf_Internal_Rela *relocs)
5988 {
5989 struct ppc_link_hash_table *htab;
5990 Elf_Internal_Shdr *symtab_hdr;
5991 struct elf_link_hash_entry **sym_hashes;
5992 struct got_entry **local_got_ents;
5993 const Elf_Internal_Rela *rel, *relend;
5994
5995 if (info->relocatable)
5996 return TRUE;
5997
5998 if ((sec->flags & SEC_ALLOC) == 0)
5999 return TRUE;
6000
6001 elf_section_data (sec)->local_dynrel = NULL;
6002
6003 htab = ppc_hash_table (info);
6004 if (htab == NULL)
6005 return FALSE;
6006
6007 symtab_hdr = &elf_symtab_hdr (abfd);
6008 sym_hashes = elf_sym_hashes (abfd);
6009 local_got_ents = elf_local_got_ents (abfd);
6010
6011 relend = relocs + sec->reloc_count;
6012 for (rel = relocs; rel < relend; rel++)
6013 {
6014 unsigned long r_symndx;
6015 enum elf_ppc64_reloc_type r_type;
6016 struct elf_link_hash_entry *h = NULL;
6017 unsigned char tls_type = 0;
6018
6019 r_symndx = ELF64_R_SYM (rel->r_info);
6020 r_type = ELF64_R_TYPE (rel->r_info);
6021 if (r_symndx >= symtab_hdr->sh_info)
6022 {
6023 struct ppc_link_hash_entry *eh;
6024 struct elf_dyn_relocs **pp;
6025 struct elf_dyn_relocs *p;
6026
6027 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
6028 h = elf_follow_link (h);
6029 eh = (struct ppc_link_hash_entry *) h;
6030
6031 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
6032 if (p->sec == sec)
6033 {
6034 /* Everything must go for SEC. */
6035 *pp = p->next;
6036 break;
6037 }
6038 }
6039
6040 if (is_branch_reloc (r_type))
6041 {
6042 struct plt_entry **ifunc = NULL;
6043 if (h != NULL)
6044 {
6045 if (h->type == STT_GNU_IFUNC)
6046 ifunc = &h->plt.plist;
6047 }
6048 else if (local_got_ents != NULL)
6049 {
6050 struct plt_entry **local_plt = (struct plt_entry **)
6051 (local_got_ents + symtab_hdr->sh_info);
6052 unsigned char *local_got_tls_masks = (unsigned char *)
6053 (local_plt + symtab_hdr->sh_info);
6054 if ((local_got_tls_masks[r_symndx] & PLT_IFUNC) != 0)
6055 ifunc = local_plt + r_symndx;
6056 }
6057 if (ifunc != NULL)
6058 {
6059 struct plt_entry *ent;
6060
6061 for (ent = *ifunc; ent != NULL; ent = ent->next)
6062 if (ent->addend == rel->r_addend)
6063 break;
6064 if (ent == NULL)
6065 abort ();
6066 if (ent->plt.refcount > 0)
6067 ent->plt.refcount -= 1;
6068 continue;
6069 }
6070 }
6071
6072 switch (r_type)
6073 {
6074 case R_PPC64_GOT_TLSLD16:
6075 case R_PPC64_GOT_TLSLD16_LO:
6076 case R_PPC64_GOT_TLSLD16_HI:
6077 case R_PPC64_GOT_TLSLD16_HA:
6078 tls_type = TLS_TLS | TLS_LD;
6079 goto dogot;
6080
6081 case R_PPC64_GOT_TLSGD16:
6082 case R_PPC64_GOT_TLSGD16_LO:
6083 case R_PPC64_GOT_TLSGD16_HI:
6084 case R_PPC64_GOT_TLSGD16_HA:
6085 tls_type = TLS_TLS | TLS_GD;
6086 goto dogot;
6087
6088 case R_PPC64_GOT_TPREL16_DS:
6089 case R_PPC64_GOT_TPREL16_LO_DS:
6090 case R_PPC64_GOT_TPREL16_HI:
6091 case R_PPC64_GOT_TPREL16_HA:
6092 tls_type = TLS_TLS | TLS_TPREL;
6093 goto dogot;
6094
6095 case R_PPC64_GOT_DTPREL16_DS:
6096 case R_PPC64_GOT_DTPREL16_LO_DS:
6097 case R_PPC64_GOT_DTPREL16_HI:
6098 case R_PPC64_GOT_DTPREL16_HA:
6099 tls_type = TLS_TLS | TLS_DTPREL;
6100 goto dogot;
6101
6102 case R_PPC64_GOT16:
6103 case R_PPC64_GOT16_DS:
6104 case R_PPC64_GOT16_HA:
6105 case R_PPC64_GOT16_HI:
6106 case R_PPC64_GOT16_LO:
6107 case R_PPC64_GOT16_LO_DS:
6108 dogot:
6109 {
6110 struct got_entry *ent;
6111
6112 if (h != NULL)
6113 ent = h->got.glist;
6114 else
6115 ent = local_got_ents[r_symndx];
6116
6117 for (; ent != NULL; ent = ent->next)
6118 if (ent->addend == rel->r_addend
6119 && ent->owner == abfd
6120 && ent->tls_type == tls_type)
6121 break;
6122 if (ent == NULL)
6123 abort ();
6124 if (ent->got.refcount > 0)
6125 ent->got.refcount -= 1;
6126 }
6127 break;
6128
6129 case R_PPC64_PLT16_HA:
6130 case R_PPC64_PLT16_HI:
6131 case R_PPC64_PLT16_LO:
6132 case R_PPC64_PLT32:
6133 case R_PPC64_PLT64:
6134 case R_PPC64_REL14:
6135 case R_PPC64_REL14_BRNTAKEN:
6136 case R_PPC64_REL14_BRTAKEN:
6137 case R_PPC64_REL24:
6138 if (h != NULL)
6139 {
6140 struct plt_entry *ent;
6141
6142 for (ent = h->plt.plist; ent != NULL; ent = ent->next)
6143 if (ent->addend == rel->r_addend)
6144 break;
6145 if (ent != NULL && ent->plt.refcount > 0)
6146 ent->plt.refcount -= 1;
6147 }
6148 break;
6149
6150 default:
6151 break;
6152 }
6153 }
6154 return TRUE;
6155 }
6156
6157 /* The maximum size of .sfpr. */
6158 #define SFPR_MAX (218*4)
6159
6160 struct sfpr_def_parms
6161 {
6162 const char name[12];
6163 unsigned char lo, hi;
6164 bfd_byte * (*write_ent) (bfd *, bfd_byte *, int);
6165 bfd_byte * (*write_tail) (bfd *, bfd_byte *, int);
6166 };
6167
6168 /* Auto-generate _save*, _rest* functions in .sfpr. */
6169
6170 static bfd_boolean
6171 sfpr_define (struct bfd_link_info *info, const struct sfpr_def_parms *parm)
6172 {
6173 struct ppc_link_hash_table *htab = ppc_hash_table (info);
6174 unsigned int i;
6175 size_t len = strlen (parm->name);
6176 bfd_boolean writing = FALSE;
6177 char sym[16];
6178
6179 if (htab == NULL)
6180 return FALSE;
6181
6182 memcpy (sym, parm->name, len);
6183 sym[len + 2] = 0;
6184
6185 for (i = parm->lo; i <= parm->hi; i++)
6186 {
6187 struct elf_link_hash_entry *h;
6188
6189 sym[len + 0] = i / 10 + '0';
6190 sym[len + 1] = i % 10 + '0';
6191 h = elf_link_hash_lookup (&htab->elf, sym, FALSE, FALSE, TRUE);
6192 if (h != NULL
6193 && !h->def_regular)
6194 {
6195 h->root.type = bfd_link_hash_defined;
6196 h->root.u.def.section = htab->sfpr;
6197 h->root.u.def.value = htab->sfpr->size;
6198 h->type = STT_FUNC;
6199 h->def_regular = 1;
6200 _bfd_elf_link_hash_hide_symbol (info, h, TRUE);
6201 writing = TRUE;
6202 if (htab->sfpr->contents == NULL)
6203 {
6204 htab->sfpr->contents = bfd_alloc (htab->elf.dynobj, SFPR_MAX);
6205 if (htab->sfpr->contents == NULL)
6206 return FALSE;
6207 }
6208 }
6209 if (writing)
6210 {
6211 bfd_byte *p = htab->sfpr->contents + htab->sfpr->size;
6212 if (i != parm->hi)
6213 p = (*parm->write_ent) (htab->elf.dynobj, p, i);
6214 else
6215 p = (*parm->write_tail) (htab->elf.dynobj, p, i);
6216 htab->sfpr->size = p - htab->sfpr->contents;
6217 }
6218 }
6219
6220 return TRUE;
6221 }
6222
6223 static bfd_byte *
6224 savegpr0 (bfd *abfd, bfd_byte *p, int r)
6225 {
6226 bfd_put_32 (abfd, STD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6227 return p + 4;
6228 }
6229
6230 static bfd_byte *
6231 savegpr0_tail (bfd *abfd, bfd_byte *p, int r)
6232 {
6233 p = savegpr0 (abfd, p, r);
6234 bfd_put_32 (abfd, STD_R0_0R1 + 16, p);
6235 p = p + 4;
6236 bfd_put_32 (abfd, BLR, p);
6237 return p + 4;
6238 }
6239
6240 static bfd_byte *
6241 restgpr0 (bfd *abfd, bfd_byte *p, int r)
6242 {
6243 bfd_put_32 (abfd, LD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6244 return p + 4;
6245 }
6246
6247 static bfd_byte *
6248 restgpr0_tail (bfd *abfd, bfd_byte *p, int r)
6249 {
6250 bfd_put_32 (abfd, LD_R0_0R1 + 16, p);
6251 p = p + 4;
6252 p = restgpr0 (abfd, p, r);
6253 bfd_put_32 (abfd, MTLR_R0, p);
6254 p = p + 4;
6255 if (r == 29)
6256 {
6257 p = restgpr0 (abfd, p, 30);
6258 p = restgpr0 (abfd, p, 31);
6259 }
6260 bfd_put_32 (abfd, BLR, p);
6261 return p + 4;
6262 }
6263
6264 static bfd_byte *
6265 savegpr1 (bfd *abfd, bfd_byte *p, int r)
6266 {
6267 bfd_put_32 (abfd, STD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6268 return p + 4;
6269 }
6270
6271 static bfd_byte *
6272 savegpr1_tail (bfd *abfd, bfd_byte *p, int r)
6273 {
6274 p = savegpr1 (abfd, p, r);
6275 bfd_put_32 (abfd, BLR, p);
6276 return p + 4;
6277 }
6278
6279 static bfd_byte *
6280 restgpr1 (bfd *abfd, bfd_byte *p, int r)
6281 {
6282 bfd_put_32 (abfd, LD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6283 return p + 4;
6284 }
6285
6286 static bfd_byte *
6287 restgpr1_tail (bfd *abfd, bfd_byte *p, int r)
6288 {
6289 p = restgpr1 (abfd, p, r);
6290 bfd_put_32 (abfd, BLR, p);
6291 return p + 4;
6292 }
6293
6294 static bfd_byte *
6295 savefpr (bfd *abfd, bfd_byte *p, int r)
6296 {
6297 bfd_put_32 (abfd, STFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6298 return p + 4;
6299 }
6300
6301 static bfd_byte *
6302 savefpr0_tail (bfd *abfd, bfd_byte *p, int r)
6303 {
6304 p = savefpr (abfd, p, r);
6305 bfd_put_32 (abfd, STD_R0_0R1 + 16, p);
6306 p = p + 4;
6307 bfd_put_32 (abfd, BLR, p);
6308 return p + 4;
6309 }
6310
6311 static bfd_byte *
6312 restfpr (bfd *abfd, bfd_byte *p, int r)
6313 {
6314 bfd_put_32 (abfd, LFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6315 return p + 4;
6316 }
6317
6318 static bfd_byte *
6319 restfpr0_tail (bfd *abfd, bfd_byte *p, int r)
6320 {
6321 bfd_put_32 (abfd, LD_R0_0R1 + 16, p);
6322 p = p + 4;
6323 p = restfpr (abfd, p, r);
6324 bfd_put_32 (abfd, MTLR_R0, p);
6325 p = p + 4;
6326 if (r == 29)
6327 {
6328 p = restfpr (abfd, p, 30);
6329 p = restfpr (abfd, p, 31);
6330 }
6331 bfd_put_32 (abfd, BLR, p);
6332 return p + 4;
6333 }
6334
6335 static bfd_byte *
6336 savefpr1_tail (bfd *abfd, bfd_byte *p, int r)
6337 {
6338 p = savefpr (abfd, p, r);
6339 bfd_put_32 (abfd, BLR, p);
6340 return p + 4;
6341 }
6342
6343 static bfd_byte *
6344 restfpr1_tail (bfd *abfd, bfd_byte *p, int r)
6345 {
6346 p = restfpr (abfd, p, r);
6347 bfd_put_32 (abfd, BLR, p);
6348 return p + 4;
6349 }
6350
6351 static bfd_byte *
6352 savevr (bfd *abfd, bfd_byte *p, int r)
6353 {
6354 bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6355 p = p + 4;
6356 bfd_put_32 (abfd, STVX_VR0_R12_R0 + (r << 21), p);
6357 return p + 4;
6358 }
6359
6360 static bfd_byte *
6361 savevr_tail (bfd *abfd, bfd_byte *p, int r)
6362 {
6363 p = savevr (abfd, p, r);
6364 bfd_put_32 (abfd, BLR, p);
6365 return p + 4;
6366 }
6367
6368 static bfd_byte *
6369 restvr (bfd *abfd, bfd_byte *p, int r)
6370 {
6371 bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6372 p = p + 4;
6373 bfd_put_32 (abfd, LVX_VR0_R12_R0 + (r << 21), p);
6374 return p + 4;
6375 }
6376
6377 static bfd_byte *
6378 restvr_tail (bfd *abfd, bfd_byte *p, int r)
6379 {
6380 p = restvr (abfd, p, r);
6381 bfd_put_32 (abfd, BLR, p);
6382 return p + 4;
6383 }
6384
6385 /* Called via elf_link_hash_traverse to transfer dynamic linking
6386 information on function code symbol entries to their corresponding
6387 function descriptor symbol entries. */
6388
6389 static bfd_boolean
6390 func_desc_adjust (struct elf_link_hash_entry *h, void *inf)
6391 {
6392 struct bfd_link_info *info;
6393 struct ppc_link_hash_table *htab;
6394 struct plt_entry *ent;
6395 struct ppc_link_hash_entry *fh;
6396 struct ppc_link_hash_entry *fdh;
6397 bfd_boolean force_local;
6398
6399 fh = (struct ppc_link_hash_entry *) h;
6400 if (fh->elf.root.type == bfd_link_hash_indirect)
6401 return TRUE;
6402
6403 info = inf;
6404 htab = ppc_hash_table (info);
6405 if (htab == NULL)
6406 return FALSE;
6407
6408 /* Resolve undefined references to dot-symbols as the value
6409 in the function descriptor, if we have one in a regular object.
6410 This is to satisfy cases like ".quad .foo". Calls to functions
6411 in dynamic objects are handled elsewhere. */
6412 if (fh->elf.root.type == bfd_link_hash_undefweak
6413 && fh->was_undefined
6414 && (fdh = defined_func_desc (fh)) != NULL
6415 && get_opd_info (fdh->elf.root.u.def.section) != NULL
6416 && opd_entry_value (fdh->elf.root.u.def.section,
6417 fdh->elf.root.u.def.value,
6418 &fh->elf.root.u.def.section,
6419 &fh->elf.root.u.def.value, FALSE) != (bfd_vma) -1)
6420 {
6421 fh->elf.root.type = fdh->elf.root.type;
6422 fh->elf.forced_local = 1;
6423 fh->elf.def_regular = fdh->elf.def_regular;
6424 fh->elf.def_dynamic = fdh->elf.def_dynamic;
6425 }
6426
6427 /* If this is a function code symbol, transfer dynamic linking
6428 information to the function descriptor symbol. */
6429 if (!fh->is_func)
6430 return TRUE;
6431
6432 for (ent = fh->elf.plt.plist; ent != NULL; ent = ent->next)
6433 if (ent->plt.refcount > 0)
6434 break;
6435 if (ent == NULL
6436 || fh->elf.root.root.string[0] != '.'
6437 || fh->elf.root.root.string[1] == '\0')
6438 return TRUE;
6439
6440 /* Find the corresponding function descriptor symbol. Create it
6441 as undefined if necessary. */
6442
6443 fdh = lookup_fdh (fh, htab);
6444 if (fdh == NULL
6445 && !info->executable
6446 && (fh->elf.root.type == bfd_link_hash_undefined
6447 || fh->elf.root.type == bfd_link_hash_undefweak))
6448 {
6449 fdh = make_fdh (info, fh);
6450 if (fdh == NULL)
6451 return FALSE;
6452 }
6453
6454 /* Fake function descriptors are made undefweak. If the function
6455 code symbol is strong undefined, make the fake sym the same.
6456 If the function code symbol is defined, then force the fake
6457 descriptor local; We can't support overriding of symbols in a
6458 shared library on a fake descriptor. */
6459
6460 if (fdh != NULL
6461 && fdh->fake
6462 && fdh->elf.root.type == bfd_link_hash_undefweak)
6463 {
6464 if (fh->elf.root.type == bfd_link_hash_undefined)
6465 {
6466 fdh->elf.root.type = bfd_link_hash_undefined;
6467 bfd_link_add_undef (&htab->elf.root, &fdh->elf.root);
6468 }
6469 else if (fh->elf.root.type == bfd_link_hash_defined
6470 || fh->elf.root.type == bfd_link_hash_defweak)
6471 {
6472 _bfd_elf_link_hash_hide_symbol (info, &fdh->elf, TRUE);
6473 }
6474 }
6475
6476 if (fdh != NULL
6477 && !fdh->elf.forced_local
6478 && (!info->executable
6479 || fdh->elf.def_dynamic
6480 || fdh->elf.ref_dynamic
6481 || (fdh->elf.root.type == bfd_link_hash_undefweak
6482 && ELF_ST_VISIBILITY (fdh->elf.other) == STV_DEFAULT)))
6483 {
6484 if (fdh->elf.dynindx == -1)
6485 if (! bfd_elf_link_record_dynamic_symbol (info, &fdh->elf))
6486 return FALSE;
6487 fdh->elf.ref_regular |= fh->elf.ref_regular;
6488 fdh->elf.ref_dynamic |= fh->elf.ref_dynamic;
6489 fdh->elf.ref_regular_nonweak |= fh->elf.ref_regular_nonweak;
6490 fdh->elf.non_got_ref |= fh->elf.non_got_ref;
6491 if (ELF_ST_VISIBILITY (fh->elf.other) == STV_DEFAULT)
6492 {
6493 move_plt_plist (fh, fdh);
6494 fdh->elf.needs_plt = 1;
6495 }
6496 fdh->is_func_descriptor = 1;
6497 fdh->oh = fh;
6498 fh->oh = fdh;
6499 }
6500
6501 /* Now that the info is on the function descriptor, clear the
6502 function code sym info. Any function code syms for which we
6503 don't have a definition in a regular file, we force local.
6504 This prevents a shared library from exporting syms that have
6505 been imported from another library. Function code syms that
6506 are really in the library we must leave global to prevent the
6507 linker dragging in a definition from a static library. */
6508 force_local = (!fh->elf.def_regular
6509 || fdh == NULL
6510 || !fdh->elf.def_regular
6511 || fdh->elf.forced_local);
6512 _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
6513
6514 return TRUE;
6515 }
6516
6517 /* Called near the start of bfd_elf_size_dynamic_sections. We use
6518 this hook to a) provide some gcc support functions, and b) transfer
6519 dynamic linking information gathered so far on function code symbol
6520 entries, to their corresponding function descriptor symbol entries. */
6521
6522 static bfd_boolean
6523 ppc64_elf_func_desc_adjust (bfd *obfd ATTRIBUTE_UNUSED,
6524 struct bfd_link_info *info)
6525 {
6526 struct ppc_link_hash_table *htab;
6527 unsigned int i;
6528 static const struct sfpr_def_parms funcs[] =
6529 {
6530 { "_savegpr0_", 14, 31, savegpr0, savegpr0_tail },
6531 { "_restgpr0_", 14, 29, restgpr0, restgpr0_tail },
6532 { "_restgpr0_", 30, 31, restgpr0, restgpr0_tail },
6533 { "_savegpr1_", 14, 31, savegpr1, savegpr1_tail },
6534 { "_restgpr1_", 14, 31, restgpr1, restgpr1_tail },
6535 { "_savefpr_", 14, 31, savefpr, savefpr0_tail },
6536 { "_restfpr_", 14, 29, restfpr, restfpr0_tail },
6537 { "_restfpr_", 30, 31, restfpr, restfpr0_tail },
6538 { "._savef", 14, 31, savefpr, savefpr1_tail },
6539 { "._restf", 14, 31, restfpr, restfpr1_tail },
6540 { "_savevr_", 20, 31, savevr, savevr_tail },
6541 { "_restvr_", 20, 31, restvr, restvr_tail }
6542 };
6543
6544 htab = ppc_hash_table (info);
6545 if (htab == NULL)
6546 return FALSE;
6547
6548 if (htab->sfpr == NULL)
6549 /* We don't have any relocs. */
6550 return TRUE;
6551
6552 /* Provide any missing _save* and _rest* functions. */
6553 htab->sfpr->size = 0;
6554 if (!info->relocatable)
6555 for (i = 0; i < sizeof (funcs) / sizeof (funcs[0]); i++)
6556 if (!sfpr_define (info, &funcs[i]))
6557 return FALSE;
6558
6559 elf_link_hash_traverse (&htab->elf, func_desc_adjust, info);
6560
6561 if (htab->sfpr->size == 0)
6562 htab->sfpr->flags |= SEC_EXCLUDE;
6563
6564 return TRUE;
6565 }
6566
6567 /* Adjust a symbol defined by a dynamic object and referenced by a
6568 regular object. The current definition is in some section of the
6569 dynamic object, but we're not including those sections. We have to
6570 change the definition to something the rest of the link can
6571 understand. */
6572
6573 static bfd_boolean
6574 ppc64_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
6575 struct elf_link_hash_entry *h)
6576 {
6577 struct ppc_link_hash_table *htab;
6578 asection *s;
6579
6580 htab = ppc_hash_table (info);
6581 if (htab == NULL)
6582 return FALSE;
6583
6584 /* Deal with function syms. */
6585 if (h->type == STT_FUNC
6586 || h->type == STT_GNU_IFUNC
6587 || h->needs_plt)
6588 {
6589 /* Clear procedure linkage table information for any symbol that
6590 won't need a .plt entry. */
6591 struct plt_entry *ent;
6592 for (ent = h->plt.plist; ent != NULL; ent = ent->next)
6593 if (ent->plt.refcount > 0)
6594 break;
6595 if (ent == NULL
6596 || (h->type != STT_GNU_IFUNC
6597 && (SYMBOL_CALLS_LOCAL (info, h)
6598 || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
6599 && h->root.type == bfd_link_hash_undefweak))))
6600 {
6601 h->plt.plist = NULL;
6602 h->needs_plt = 0;
6603 }
6604 }
6605 else
6606 h->plt.plist = NULL;
6607
6608 /* If this is a weak symbol, and there is a real definition, the
6609 processor independent code will have arranged for us to see the
6610 real definition first, and we can just use the same value. */
6611 if (h->u.weakdef != NULL)
6612 {
6613 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
6614 || h->u.weakdef->root.type == bfd_link_hash_defweak);
6615 h->root.u.def.section = h->u.weakdef->root.u.def.section;
6616 h->root.u.def.value = h->u.weakdef->root.u.def.value;
6617 if (ELIMINATE_COPY_RELOCS)
6618 h->non_got_ref = h->u.weakdef->non_got_ref;
6619 return TRUE;
6620 }
6621
6622 /* If we are creating a shared library, we must presume that the
6623 only references to the symbol are via the global offset table.
6624 For such cases we need not do anything here; the relocations will
6625 be handled correctly by relocate_section. */
6626 if (info->shared)
6627 return TRUE;
6628
6629 /* If there are no references to this symbol that do not use the
6630 GOT, we don't need to generate a copy reloc. */
6631 if (!h->non_got_ref)
6632 return TRUE;
6633
6634 /* Don't generate a copy reloc for symbols defined in the executable. */
6635 if (!h->def_dynamic || !h->ref_regular || h->def_regular)
6636 return TRUE;
6637
6638 if (ELIMINATE_COPY_RELOCS)
6639 {
6640 struct ppc_link_hash_entry * eh;
6641 struct elf_dyn_relocs *p;
6642
6643 eh = (struct ppc_link_hash_entry *) h;
6644 for (p = eh->dyn_relocs; p != NULL; p = p->next)
6645 {
6646 s = p->sec->output_section;
6647 if (s != NULL && (s->flags & SEC_READONLY) != 0)
6648 break;
6649 }
6650
6651 /* If we didn't find any dynamic relocs in read-only sections, then
6652 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
6653 if (p == NULL)
6654 {
6655 h->non_got_ref = 0;
6656 return TRUE;
6657 }
6658 }
6659
6660 if (h->plt.plist != NULL)
6661 {
6662 /* We should never get here, but unfortunately there are versions
6663 of gcc out there that improperly (for this ABI) put initialized
6664 function pointers, vtable refs and suchlike in read-only
6665 sections. Allow them to proceed, but warn that this might
6666 break at runtime. */
6667 info->callbacks->einfo
6668 (_("%P: copy reloc against `%T' requires lazy plt linking; "
6669 "avoid setting LD_BIND_NOW=1 or upgrade gcc\n"),
6670 h->root.root.string);
6671 }
6672
6673 /* This is a reference to a symbol defined by a dynamic object which
6674 is not a function. */
6675
6676 /* We must allocate the symbol in our .dynbss section, which will
6677 become part of the .bss section of the executable. There will be
6678 an entry for this symbol in the .dynsym section. The dynamic
6679 object will contain position independent code, so all references
6680 from the dynamic object to this symbol will go through the global
6681 offset table. The dynamic linker will use the .dynsym entry to
6682 determine the address it must put in the global offset table, so
6683 both the dynamic object and the regular object will refer to the
6684 same memory location for the variable. */
6685
6686 /* We must generate a R_PPC64_COPY reloc to tell the dynamic linker
6687 to copy the initial value out of the dynamic object and into the
6688 runtime process image. We need to remember the offset into the
6689 .rela.bss section we are going to use. */
6690 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
6691 {
6692 htab->relbss->size += sizeof (Elf64_External_Rela);
6693 h->needs_copy = 1;
6694 }
6695
6696 s = htab->dynbss;
6697
6698 return _bfd_elf_adjust_dynamic_copy (h, s);
6699 }
6700
6701 /* If given a function descriptor symbol, hide both the function code
6702 sym and the descriptor. */
6703 static void
6704 ppc64_elf_hide_symbol (struct bfd_link_info *info,
6705 struct elf_link_hash_entry *h,
6706 bfd_boolean force_local)
6707 {
6708 struct ppc_link_hash_entry *eh;
6709 _bfd_elf_link_hash_hide_symbol (info, h, force_local);
6710
6711 eh = (struct ppc_link_hash_entry *) h;
6712 if (eh->is_func_descriptor)
6713 {
6714 struct ppc_link_hash_entry *fh = eh->oh;
6715
6716 if (fh == NULL)
6717 {
6718 const char *p, *q;
6719 struct ppc_link_hash_table *htab;
6720 char save;
6721
6722 /* We aren't supposed to use alloca in BFD because on
6723 systems which do not have alloca the version in libiberty
6724 calls xmalloc, which might cause the program to crash
6725 when it runs out of memory. This function doesn't have a
6726 return status, so there's no way to gracefully return an
6727 error. So cheat. We know that string[-1] can be safely
6728 accessed; It's either a string in an ELF string table,
6729 or allocated in an objalloc structure. */
6730
6731 p = eh->elf.root.root.string - 1;
6732 save = *p;
6733 *(char *) p = '.';
6734 htab = ppc_hash_table (info);
6735 if (htab == NULL)
6736 return;
6737
6738 fh = (struct ppc_link_hash_entry *)
6739 elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
6740 *(char *) p = save;
6741
6742 /* Unfortunately, if it so happens that the string we were
6743 looking for was allocated immediately before this string,
6744 then we overwrote the string terminator. That's the only
6745 reason the lookup should fail. */
6746 if (fh == NULL)
6747 {
6748 q = eh->elf.root.root.string + strlen (eh->elf.root.root.string);
6749 while (q >= eh->elf.root.root.string && *q == *p)
6750 --q, --p;
6751 if (q < eh->elf.root.root.string && *p == '.')
6752 fh = (struct ppc_link_hash_entry *)
6753 elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
6754 }
6755 if (fh != NULL)
6756 {
6757 eh->oh = fh;
6758 fh->oh = eh;
6759 }
6760 }
6761 if (fh != NULL)
6762 _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
6763 }
6764 }
6765
6766 static bfd_boolean
6767 get_sym_h (struct elf_link_hash_entry **hp,
6768 Elf_Internal_Sym **symp,
6769 asection **symsecp,
6770 unsigned char **tls_maskp,
6771 Elf_Internal_Sym **locsymsp,
6772 unsigned long r_symndx,
6773 bfd *ibfd)
6774 {
6775 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
6776
6777 if (r_symndx >= symtab_hdr->sh_info)
6778 {
6779 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
6780 struct elf_link_hash_entry *h;
6781
6782 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
6783 h = elf_follow_link (h);
6784
6785 if (hp != NULL)
6786 *hp = h;
6787
6788 if (symp != NULL)
6789 *symp = NULL;
6790
6791 if (symsecp != NULL)
6792 {
6793 asection *symsec = NULL;
6794 if (h->root.type == bfd_link_hash_defined
6795 || h->root.type == bfd_link_hash_defweak)
6796 symsec = h->root.u.def.section;
6797 *symsecp = symsec;
6798 }
6799
6800 if (tls_maskp != NULL)
6801 {
6802 struct ppc_link_hash_entry *eh;
6803
6804 eh = (struct ppc_link_hash_entry *) h;
6805 *tls_maskp = &eh->tls_mask;
6806 }
6807 }
6808 else
6809 {
6810 Elf_Internal_Sym *sym;
6811 Elf_Internal_Sym *locsyms = *locsymsp;
6812
6813 if (locsyms == NULL)
6814 {
6815 locsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
6816 if (locsyms == NULL)
6817 locsyms = bfd_elf_get_elf_syms (ibfd, symtab_hdr,
6818 symtab_hdr->sh_info,
6819 0, NULL, NULL, NULL);
6820 if (locsyms == NULL)
6821 return FALSE;
6822 *locsymsp = locsyms;
6823 }
6824 sym = locsyms + r_symndx;
6825
6826 if (hp != NULL)
6827 *hp = NULL;
6828
6829 if (symp != NULL)
6830 *symp = sym;
6831
6832 if (symsecp != NULL)
6833 *symsecp = bfd_section_from_elf_index (ibfd, sym->st_shndx);
6834
6835 if (tls_maskp != NULL)
6836 {
6837 struct got_entry **lgot_ents;
6838 unsigned char *tls_mask;
6839
6840 tls_mask = NULL;
6841 lgot_ents = elf_local_got_ents (ibfd);
6842 if (lgot_ents != NULL)
6843 {
6844 struct plt_entry **local_plt = (struct plt_entry **)
6845 (lgot_ents + symtab_hdr->sh_info);
6846 unsigned char *lgot_masks = (unsigned char *)
6847 (local_plt + symtab_hdr->sh_info);
6848 tls_mask = &lgot_masks[r_symndx];
6849 }
6850 *tls_maskp = tls_mask;
6851 }
6852 }
6853 return TRUE;
6854 }
6855
6856 /* Returns TLS_MASKP for the given REL symbol. Function return is 0 on
6857 error, 2 on a toc GD type suitable for optimization, 3 on a toc LD
6858 type suitable for optimization, and 1 otherwise. */
6859
6860 static int
6861 get_tls_mask (unsigned char **tls_maskp,
6862 unsigned long *toc_symndx,
6863 bfd_vma *toc_addend,
6864 Elf_Internal_Sym **locsymsp,
6865 const Elf_Internal_Rela *rel,
6866 bfd *ibfd)
6867 {
6868 unsigned long r_symndx;
6869 int next_r;
6870 struct elf_link_hash_entry *h;
6871 Elf_Internal_Sym *sym;
6872 asection *sec;
6873 bfd_vma off;
6874
6875 r_symndx = ELF64_R_SYM (rel->r_info);
6876 if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
6877 return 0;
6878
6879 if ((*tls_maskp != NULL && **tls_maskp != 0)
6880 || sec == NULL
6881 || ppc64_elf_section_data (sec) == NULL
6882 || ppc64_elf_section_data (sec)->sec_type != sec_toc)
6883 return 1;
6884
6885 /* Look inside a TOC section too. */
6886 if (h != NULL)
6887 {
6888 BFD_ASSERT (h->root.type == bfd_link_hash_defined);
6889 off = h->root.u.def.value;
6890 }
6891 else
6892 off = sym->st_value;
6893 off += rel->r_addend;
6894 BFD_ASSERT (off % 8 == 0);
6895 r_symndx = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8];
6896 next_r = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8 + 1];
6897 if (toc_symndx != NULL)
6898 *toc_symndx = r_symndx;
6899 if (toc_addend != NULL)
6900 *toc_addend = ppc64_elf_section_data (sec)->u.toc.add[off / 8];
6901 if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
6902 return 0;
6903 if ((h == NULL || is_static_defined (h))
6904 && (next_r == -1 || next_r == -2))
6905 return 1 - next_r;
6906 return 1;
6907 }
6908
6909 /* Find (or create) an entry in the tocsave hash table. */
6910
6911 static struct tocsave_entry *
6912 tocsave_find (struct ppc_link_hash_table *htab,
6913 enum insert_option insert,
6914 Elf_Internal_Sym **local_syms,
6915 const Elf_Internal_Rela *irela,
6916 bfd *ibfd)
6917 {
6918 unsigned long r_indx;
6919 struct elf_link_hash_entry *h;
6920 Elf_Internal_Sym *sym;
6921 struct tocsave_entry ent, *p;
6922 hashval_t hash;
6923 struct tocsave_entry **slot;
6924
6925 r_indx = ELF64_R_SYM (irela->r_info);
6926 if (!get_sym_h (&h, &sym, &ent.sec, NULL, local_syms, r_indx, ibfd))
6927 return NULL;
6928 if (ent.sec == NULL || ent.sec->output_section == NULL)
6929 {
6930 (*_bfd_error_handler)
6931 (_("%B: undefined symbol on R_PPC64_TOCSAVE relocation"));
6932 return NULL;
6933 }
6934
6935 if (h != NULL)
6936 ent.offset = h->root.u.def.value;
6937 else
6938 ent.offset = sym->st_value;
6939 ent.offset += irela->r_addend;
6940
6941 hash = tocsave_htab_hash (&ent);
6942 slot = ((struct tocsave_entry **)
6943 htab_find_slot_with_hash (htab->tocsave_htab, &ent, hash, insert));
6944 if (slot == NULL)
6945 return NULL;
6946
6947 if (*slot == NULL)
6948 {
6949 p = (struct tocsave_entry *) bfd_alloc (ibfd, sizeof (*p));
6950 if (p == NULL)
6951 return NULL;
6952 *p = ent;
6953 *slot = p;
6954 }
6955 return *slot;
6956 }
6957
6958 /* Adjust all global syms defined in opd sections. In gcc generated
6959 code for the old ABI, these will already have been done. */
6960
6961 static bfd_boolean
6962 adjust_opd_syms (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
6963 {
6964 struct ppc_link_hash_entry *eh;
6965 asection *sym_sec;
6966 struct _opd_sec_data *opd;
6967
6968 if (h->root.type == bfd_link_hash_indirect)
6969 return TRUE;
6970
6971 if (h->root.type != bfd_link_hash_defined
6972 && h->root.type != bfd_link_hash_defweak)
6973 return TRUE;
6974
6975 eh = (struct ppc_link_hash_entry *) h;
6976 if (eh->adjust_done)
6977 return TRUE;
6978
6979 sym_sec = eh->elf.root.u.def.section;
6980 opd = get_opd_info (sym_sec);
6981 if (opd != NULL && opd->adjust != NULL)
6982 {
6983 long adjust = opd->adjust[eh->elf.root.u.def.value / 8];
6984 if (adjust == -1)
6985 {
6986 /* This entry has been deleted. */
6987 asection *dsec = ppc64_elf_tdata (sym_sec->owner)->deleted_section;
6988 if (dsec == NULL)
6989 {
6990 for (dsec = sym_sec->owner->sections; dsec; dsec = dsec->next)
6991 if (discarded_section (dsec))
6992 {
6993 ppc64_elf_tdata (sym_sec->owner)->deleted_section = dsec;
6994 break;
6995 }
6996 }
6997 eh->elf.root.u.def.value = 0;
6998 eh->elf.root.u.def.section = dsec;
6999 }
7000 else
7001 eh->elf.root.u.def.value += adjust;
7002 eh->adjust_done = 1;
7003 }
7004 return TRUE;
7005 }
7006
7007 /* Handles decrementing dynamic reloc counts for the reloc specified by
7008 R_INFO in section SEC. If LOCAL_SYMS is NULL, then H and SYM
7009 have already been determined. */
7010
7011 static bfd_boolean
7012 dec_dynrel_count (bfd_vma r_info,
7013 asection *sec,
7014 struct bfd_link_info *info,
7015 Elf_Internal_Sym **local_syms,
7016 struct elf_link_hash_entry *h,
7017 Elf_Internal_Sym *sym)
7018 {
7019 enum elf_ppc64_reloc_type r_type;
7020 asection *sym_sec = NULL;
7021
7022 /* Can this reloc be dynamic? This switch, and later tests here
7023 should be kept in sync with the code in check_relocs. */
7024 r_type = ELF64_R_TYPE (r_info);
7025 switch (r_type)
7026 {
7027 default:
7028 return TRUE;
7029
7030 case R_PPC64_TPREL16:
7031 case R_PPC64_TPREL16_LO:
7032 case R_PPC64_TPREL16_HI:
7033 case R_PPC64_TPREL16_HA:
7034 case R_PPC64_TPREL16_DS:
7035 case R_PPC64_TPREL16_LO_DS:
7036 case R_PPC64_TPREL16_HIGHER:
7037 case R_PPC64_TPREL16_HIGHERA:
7038 case R_PPC64_TPREL16_HIGHEST:
7039 case R_PPC64_TPREL16_HIGHESTA:
7040 if (!info->shared)
7041 return TRUE;
7042
7043 case R_PPC64_TPREL64:
7044 case R_PPC64_DTPMOD64:
7045 case R_PPC64_DTPREL64:
7046 case R_PPC64_ADDR64:
7047 case R_PPC64_REL30:
7048 case R_PPC64_REL32:
7049 case R_PPC64_REL64:
7050 case R_PPC64_ADDR14:
7051 case R_PPC64_ADDR14_BRNTAKEN:
7052 case R_PPC64_ADDR14_BRTAKEN:
7053 case R_PPC64_ADDR16:
7054 case R_PPC64_ADDR16_DS:
7055 case R_PPC64_ADDR16_HA:
7056 case R_PPC64_ADDR16_HI:
7057 case R_PPC64_ADDR16_HIGHER:
7058 case R_PPC64_ADDR16_HIGHERA:
7059 case R_PPC64_ADDR16_HIGHEST:
7060 case R_PPC64_ADDR16_HIGHESTA:
7061 case R_PPC64_ADDR16_LO:
7062 case R_PPC64_ADDR16_LO_DS:
7063 case R_PPC64_ADDR24:
7064 case R_PPC64_ADDR32:
7065 case R_PPC64_UADDR16:
7066 case R_PPC64_UADDR32:
7067 case R_PPC64_UADDR64:
7068 case R_PPC64_TOC:
7069 break;
7070 }
7071
7072 if (local_syms != NULL)
7073 {
7074 unsigned long r_symndx;
7075 bfd *ibfd = sec->owner;
7076
7077 r_symndx = ELF64_R_SYM (r_info);
7078 if (!get_sym_h (&h, &sym, &sym_sec, NULL, local_syms, r_symndx, ibfd))
7079 return FALSE;
7080 }
7081
7082 if ((info->shared
7083 && (must_be_dyn_reloc (info, r_type)
7084 || (h != NULL
7085 && (!SYMBOLIC_BIND (info, h)
7086 || h->root.type == bfd_link_hash_defweak
7087 || !h->def_regular))))
7088 || (ELIMINATE_COPY_RELOCS
7089 && !info->shared
7090 && h != NULL
7091 && (h->root.type == bfd_link_hash_defweak
7092 || !h->def_regular)))
7093 ;
7094 else
7095 return TRUE;
7096
7097 if (h != NULL)
7098 {
7099 struct elf_dyn_relocs *p;
7100 struct elf_dyn_relocs **pp;
7101 pp = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
7102
7103 /* elf_gc_sweep may have already removed all dyn relocs associated
7104 with local syms for a given section. Also, symbol flags are
7105 changed by elf_gc_sweep_symbol, confusing the test above. Don't
7106 report a dynreloc miscount. */
7107 if (*pp == NULL && info->gc_sections)
7108 return TRUE;
7109
7110 while ((p = *pp) != NULL)
7111 {
7112 if (p->sec == sec)
7113 {
7114 if (!must_be_dyn_reloc (info, r_type))
7115 p->pc_count -= 1;
7116 p->count -= 1;
7117 if (p->count == 0)
7118 *pp = p->next;
7119 return TRUE;
7120 }
7121 pp = &p->next;
7122 }
7123 }
7124 else
7125 {
7126 struct ppc_dyn_relocs *p;
7127 struct ppc_dyn_relocs **pp;
7128 void *vpp;
7129 bfd_boolean is_ifunc;
7130
7131 if (local_syms == NULL)
7132 sym_sec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
7133 if (sym_sec == NULL)
7134 sym_sec = sec;
7135
7136 vpp = &elf_section_data (sym_sec)->local_dynrel;
7137 pp = (struct ppc_dyn_relocs **) vpp;
7138
7139 if (*pp == NULL && info->gc_sections)
7140 return TRUE;
7141
7142 is_ifunc = ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC;
7143 while ((p = *pp) != NULL)
7144 {
7145 if (p->sec == sec && p->ifunc == is_ifunc)
7146 {
7147 p->count -= 1;
7148 if (p->count == 0)
7149 *pp = p->next;
7150 return TRUE;
7151 }
7152 pp = &p->next;
7153 }
7154 }
7155
7156 info->callbacks->einfo (_("%P: dynreloc miscount for %B, section %A\n"),
7157 sec->owner, sec);
7158 bfd_set_error (bfd_error_bad_value);
7159 return FALSE;
7160 }
7161
7162 /* Remove unused Official Procedure Descriptor entries. Currently we
7163 only remove those associated with functions in discarded link-once
7164 sections, or weakly defined functions that have been overridden. It
7165 would be possible to remove many more entries for statically linked
7166 applications. */
7167
7168 bfd_boolean
7169 ppc64_elf_edit_opd (struct bfd_link_info *info, bfd_boolean non_overlapping)
7170 {
7171 bfd *ibfd;
7172 bfd_boolean some_edited = FALSE;
7173 asection *need_pad = NULL;
7174
7175 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
7176 {
7177 asection *sec;
7178 Elf_Internal_Rela *relstart, *rel, *relend;
7179 Elf_Internal_Shdr *symtab_hdr;
7180 Elf_Internal_Sym *local_syms;
7181 bfd_vma offset;
7182 struct _opd_sec_data *opd;
7183 bfd_boolean need_edit, add_aux_fields;
7184 bfd_size_type cnt_16b = 0;
7185
7186 if (!is_ppc64_elf (ibfd))
7187 continue;
7188
7189 sec = bfd_get_section_by_name (ibfd, ".opd");
7190 if (sec == NULL || sec->size == 0)
7191 continue;
7192
7193 if (sec->sec_info_type == SEC_INFO_TYPE_JUST_SYMS)
7194 continue;
7195
7196 if (sec->output_section == bfd_abs_section_ptr)
7197 continue;
7198
7199 /* Look through the section relocs. */
7200 if ((sec->flags & SEC_RELOC) == 0 || sec->reloc_count == 0)
7201 continue;
7202
7203 local_syms = NULL;
7204 symtab_hdr = &elf_symtab_hdr (ibfd);
7205
7206 /* Read the relocations. */
7207 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
7208 info->keep_memory);
7209 if (relstart == NULL)
7210 return FALSE;
7211
7212 /* First run through the relocs to check they are sane, and to
7213 determine whether we need to edit this opd section. */
7214 need_edit = FALSE;
7215 need_pad = sec;
7216 offset = 0;
7217 relend = relstart + sec->reloc_count;
7218 for (rel = relstart; rel < relend; )
7219 {
7220 enum elf_ppc64_reloc_type r_type;
7221 unsigned long r_symndx;
7222 asection *sym_sec;
7223 struct elf_link_hash_entry *h;
7224 Elf_Internal_Sym *sym;
7225
7226 /* .opd contains a regular array of 16 or 24 byte entries. We're
7227 only interested in the reloc pointing to a function entry
7228 point. */
7229 if (rel->r_offset != offset
7230 || rel + 1 >= relend
7231 || (rel + 1)->r_offset != offset + 8)
7232 {
7233 /* If someone messes with .opd alignment then after a
7234 "ld -r" we might have padding in the middle of .opd.
7235 Also, there's nothing to prevent someone putting
7236 something silly in .opd with the assembler. No .opd
7237 optimization for them! */
7238 broken_opd:
7239 (*_bfd_error_handler)
7240 (_("%B: .opd is not a regular array of opd entries"), ibfd);
7241 need_edit = FALSE;
7242 break;
7243 }
7244
7245 if ((r_type = ELF64_R_TYPE (rel->r_info)) != R_PPC64_ADDR64
7246 || (r_type = ELF64_R_TYPE ((rel + 1)->r_info)) != R_PPC64_TOC)
7247 {
7248 (*_bfd_error_handler)
7249 (_("%B: unexpected reloc type %u in .opd section"),
7250 ibfd, r_type);
7251 need_edit = FALSE;
7252 break;
7253 }
7254
7255 r_symndx = ELF64_R_SYM (rel->r_info);
7256 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7257 r_symndx, ibfd))
7258 goto error_ret;
7259
7260 if (sym_sec == NULL || sym_sec->owner == NULL)
7261 {
7262 const char *sym_name;
7263 if (h != NULL)
7264 sym_name = h->root.root.string;
7265 else
7266 sym_name = bfd_elf_sym_name (ibfd, symtab_hdr, sym,
7267 sym_sec);
7268
7269 (*_bfd_error_handler)
7270 (_("%B: undefined sym `%s' in .opd section"),
7271 ibfd, sym_name);
7272 need_edit = FALSE;
7273 break;
7274 }
7275
7276 /* opd entries are always for functions defined in the
7277 current input bfd. If the symbol isn't defined in the
7278 input bfd, then we won't be using the function in this
7279 bfd; It must be defined in a linkonce section in another
7280 bfd, or is weak. It's also possible that we are
7281 discarding the function due to a linker script /DISCARD/,
7282 which we test for via the output_section. */
7283 if (sym_sec->owner != ibfd
7284 || sym_sec->output_section == bfd_abs_section_ptr)
7285 need_edit = TRUE;
7286
7287 rel += 2;
7288 if (rel == relend
7289 || (rel + 1 == relend && rel->r_offset == offset + 16))
7290 {
7291 if (sec->size == offset + 24)
7292 {
7293 need_pad = NULL;
7294 break;
7295 }
7296 if (rel == relend && sec->size == offset + 16)
7297 {
7298 cnt_16b++;
7299 break;
7300 }
7301 goto broken_opd;
7302 }
7303
7304 if (rel->r_offset == offset + 24)
7305 offset += 24;
7306 else if (rel->r_offset != offset + 16)
7307 goto broken_opd;
7308 else if (rel + 1 < relend
7309 && ELF64_R_TYPE (rel[0].r_info) == R_PPC64_ADDR64
7310 && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOC)
7311 {
7312 offset += 16;
7313 cnt_16b++;
7314 }
7315 else if (rel + 2 < relend
7316 && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_ADDR64
7317 && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_TOC)
7318 {
7319 offset += 24;
7320 rel += 1;
7321 }
7322 else
7323 goto broken_opd;
7324 }
7325
7326 add_aux_fields = non_overlapping && cnt_16b > 0;
7327
7328 if (need_edit || add_aux_fields)
7329 {
7330 Elf_Internal_Rela *write_rel;
7331 Elf_Internal_Shdr *rel_hdr;
7332 bfd_byte *rptr, *wptr;
7333 bfd_byte *new_contents;
7334 bfd_boolean skip;
7335 long opd_ent_size;
7336 bfd_size_type amt;
7337
7338 new_contents = NULL;
7339 amt = sec->size * sizeof (long) / 8;
7340 opd = &ppc64_elf_section_data (sec)->u.opd;
7341 opd->adjust = bfd_zalloc (sec->owner, amt);
7342 if (opd->adjust == NULL)
7343 return FALSE;
7344 ppc64_elf_section_data (sec)->sec_type = sec_opd;
7345
7346 /* This seems a waste of time as input .opd sections are all
7347 zeros as generated by gcc, but I suppose there's no reason
7348 this will always be so. We might start putting something in
7349 the third word of .opd entries. */
7350 if ((sec->flags & SEC_IN_MEMORY) == 0)
7351 {
7352 bfd_byte *loc;
7353 if (!bfd_malloc_and_get_section (ibfd, sec, &loc))
7354 {
7355 if (loc != NULL)
7356 free (loc);
7357 error_ret:
7358 if (local_syms != NULL
7359 && symtab_hdr->contents != (unsigned char *) local_syms)
7360 free (local_syms);
7361 if (elf_section_data (sec)->relocs != relstart)
7362 free (relstart);
7363 return FALSE;
7364 }
7365 sec->contents = loc;
7366 sec->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
7367 }
7368
7369 elf_section_data (sec)->relocs = relstart;
7370
7371 new_contents = sec->contents;
7372 if (add_aux_fields)
7373 {
7374 new_contents = bfd_malloc (sec->size + cnt_16b * 8);
7375 if (new_contents == NULL)
7376 return FALSE;
7377 need_pad = FALSE;
7378 }
7379 wptr = new_contents;
7380 rptr = sec->contents;
7381
7382 write_rel = relstart;
7383 skip = FALSE;
7384 offset = 0;
7385 opd_ent_size = 0;
7386 for (rel = relstart; rel < relend; rel++)
7387 {
7388 unsigned long r_symndx;
7389 asection *sym_sec;
7390 struct elf_link_hash_entry *h;
7391 Elf_Internal_Sym *sym;
7392
7393 r_symndx = ELF64_R_SYM (rel->r_info);
7394 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7395 r_symndx, ibfd))
7396 goto error_ret;
7397
7398 if (rel->r_offset == offset)
7399 {
7400 struct ppc_link_hash_entry *fdh = NULL;
7401
7402 /* See if the .opd entry is full 24 byte or
7403 16 byte (with fd_aux entry overlapped with next
7404 fd_func). */
7405 opd_ent_size = 24;
7406 if ((rel + 2 == relend && sec->size == offset + 16)
7407 || (rel + 3 < relend
7408 && rel[2].r_offset == offset + 16
7409 && rel[3].r_offset == offset + 24
7410 && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_ADDR64
7411 && ELF64_R_TYPE (rel[3].r_info) == R_PPC64_TOC))
7412 opd_ent_size = 16;
7413
7414 if (h != NULL
7415 && h->root.root.string[0] == '.')
7416 {
7417 struct ppc_link_hash_table *htab;
7418
7419 htab = ppc_hash_table (info);
7420 if (htab != NULL)
7421 fdh = lookup_fdh ((struct ppc_link_hash_entry *) h,
7422 htab);
7423 if (fdh != NULL
7424 && fdh->elf.root.type != bfd_link_hash_defined
7425 && fdh->elf.root.type != bfd_link_hash_defweak)
7426 fdh = NULL;
7427 }
7428
7429 skip = (sym_sec->owner != ibfd
7430 || sym_sec->output_section == bfd_abs_section_ptr);
7431 if (skip)
7432 {
7433 if (fdh != NULL && sym_sec->owner == ibfd)
7434 {
7435 /* Arrange for the function descriptor sym
7436 to be dropped. */
7437 fdh->elf.root.u.def.value = 0;
7438 fdh->elf.root.u.def.section = sym_sec;
7439 }
7440 opd->adjust[rel->r_offset / 8] = -1;
7441 }
7442 else
7443 {
7444 /* We'll be keeping this opd entry. */
7445
7446 if (fdh != NULL)
7447 {
7448 /* Redefine the function descriptor symbol to
7449 this location in the opd section. It is
7450 necessary to update the value here rather
7451 than using an array of adjustments as we do
7452 for local symbols, because various places
7453 in the generic ELF code use the value
7454 stored in u.def.value. */
7455 fdh->elf.root.u.def.value = wptr - new_contents;
7456 fdh->adjust_done = 1;
7457 }
7458
7459 /* Local syms are a bit tricky. We could
7460 tweak them as they can be cached, but
7461 we'd need to look through the local syms
7462 for the function descriptor sym which we
7463 don't have at the moment. So keep an
7464 array of adjustments. */
7465 opd->adjust[rel->r_offset / 8]
7466 = (wptr - new_contents) - (rptr - sec->contents);
7467
7468 if (wptr != rptr)
7469 memcpy (wptr, rptr, opd_ent_size);
7470 wptr += opd_ent_size;
7471 if (add_aux_fields && opd_ent_size == 16)
7472 {
7473 memset (wptr, '\0', 8);
7474 wptr += 8;
7475 }
7476 }
7477 rptr += opd_ent_size;
7478 offset += opd_ent_size;
7479 }
7480
7481 if (skip)
7482 {
7483 if (!NO_OPD_RELOCS
7484 && !info->relocatable
7485 && !dec_dynrel_count (rel->r_info, sec, info,
7486 NULL, h, sym))
7487 goto error_ret;
7488 }
7489 else
7490 {
7491 /* We need to adjust any reloc offsets to point to the
7492 new opd entries. While we're at it, we may as well
7493 remove redundant relocs. */
7494 rel->r_offset += opd->adjust[(offset - opd_ent_size) / 8];
7495 if (write_rel != rel)
7496 memcpy (write_rel, rel, sizeof (*rel));
7497 ++write_rel;
7498 }
7499 }
7500
7501 sec->size = wptr - new_contents;
7502 sec->reloc_count = write_rel - relstart;
7503 if (add_aux_fields)
7504 {
7505 free (sec->contents);
7506 sec->contents = new_contents;
7507 }
7508
7509 /* Fudge the header size too, as this is used later in
7510 elf_bfd_final_link if we are emitting relocs. */
7511 rel_hdr = _bfd_elf_single_rel_hdr (sec);
7512 rel_hdr->sh_size = sec->reloc_count * rel_hdr->sh_entsize;
7513 some_edited = TRUE;
7514 }
7515 else if (elf_section_data (sec)->relocs != relstart)
7516 free (relstart);
7517
7518 if (local_syms != NULL
7519 && symtab_hdr->contents != (unsigned char *) local_syms)
7520 {
7521 if (!info->keep_memory)
7522 free (local_syms);
7523 else
7524 symtab_hdr->contents = (unsigned char *) local_syms;
7525 }
7526 }
7527
7528 if (some_edited)
7529 elf_link_hash_traverse (elf_hash_table (info), adjust_opd_syms, NULL);
7530
7531 /* If we are doing a final link and the last .opd entry is just 16 byte
7532 long, add a 8 byte padding after it. */
7533 if (need_pad != NULL && !info->relocatable)
7534 {
7535 bfd_byte *p;
7536
7537 if ((need_pad->flags & SEC_IN_MEMORY) == 0)
7538 {
7539 BFD_ASSERT (need_pad->size > 0);
7540
7541 p = bfd_malloc (need_pad->size + 8);
7542 if (p == NULL)
7543 return FALSE;
7544
7545 if (! bfd_get_section_contents (need_pad->owner, need_pad,
7546 p, 0, need_pad->size))
7547 return FALSE;
7548
7549 need_pad->contents = p;
7550 need_pad->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
7551 }
7552 else
7553 {
7554 p = bfd_realloc (need_pad->contents, need_pad->size + 8);
7555 if (p == NULL)
7556 return FALSE;
7557
7558 need_pad->contents = p;
7559 }
7560
7561 memset (need_pad->contents + need_pad->size, 0, 8);
7562 need_pad->size += 8;
7563 }
7564
7565 return TRUE;
7566 }
7567
7568 /* Set htab->tls_get_addr and call the generic ELF tls_setup function. */
7569
7570 asection *
7571 ppc64_elf_tls_setup (struct bfd_link_info *info,
7572 int no_tls_get_addr_opt,
7573 int *no_multi_toc)
7574 {
7575 struct ppc_link_hash_table *htab;
7576
7577 htab = ppc_hash_table (info);
7578 if (htab == NULL)
7579 return NULL;
7580
7581 if (*no_multi_toc)
7582 htab->do_multi_toc = 0;
7583 else if (!htab->do_multi_toc)
7584 *no_multi_toc = 1;
7585
7586 htab->tls_get_addr = ((struct ppc_link_hash_entry *)
7587 elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
7588 FALSE, FALSE, TRUE));
7589 /* Move dynamic linking info to the function descriptor sym. */
7590 if (htab->tls_get_addr != NULL)
7591 func_desc_adjust (&htab->tls_get_addr->elf, info);
7592 htab->tls_get_addr_fd = ((struct ppc_link_hash_entry *)
7593 elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
7594 FALSE, FALSE, TRUE));
7595 if (!no_tls_get_addr_opt)
7596 {
7597 struct elf_link_hash_entry *opt, *opt_fd, *tga, *tga_fd;
7598
7599 opt = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr_opt",
7600 FALSE, FALSE, TRUE);
7601 if (opt != NULL)
7602 func_desc_adjust (opt, info);
7603 opt_fd = elf_link_hash_lookup (&htab->elf, "__tls_get_addr_opt",
7604 FALSE, FALSE, TRUE);
7605 if (opt_fd != NULL
7606 && (opt_fd->root.type == bfd_link_hash_defined
7607 || opt_fd->root.type == bfd_link_hash_defweak))
7608 {
7609 /* If glibc supports an optimized __tls_get_addr call stub,
7610 signalled by the presence of __tls_get_addr_opt, and we'll
7611 be calling __tls_get_addr via a plt call stub, then
7612 make __tls_get_addr point to __tls_get_addr_opt. */
7613 tga_fd = &htab->tls_get_addr_fd->elf;
7614 if (htab->elf.dynamic_sections_created
7615 && tga_fd != NULL
7616 && (tga_fd->type == STT_FUNC
7617 || tga_fd->needs_plt)
7618 && !(SYMBOL_CALLS_LOCAL (info, tga_fd)
7619 || (ELF_ST_VISIBILITY (tga_fd->other) != STV_DEFAULT
7620 && tga_fd->root.type == bfd_link_hash_undefweak)))
7621 {
7622 struct plt_entry *ent;
7623
7624 for (ent = tga_fd->plt.plist; ent != NULL; ent = ent->next)
7625 if (ent->plt.refcount > 0)
7626 break;
7627 if (ent != NULL)
7628 {
7629 tga_fd->root.type = bfd_link_hash_indirect;
7630 tga_fd->root.u.i.link = &opt_fd->root;
7631 ppc64_elf_copy_indirect_symbol (info, opt_fd, tga_fd);
7632 if (opt_fd->dynindx != -1)
7633 {
7634 /* Use __tls_get_addr_opt in dynamic relocations. */
7635 opt_fd->dynindx = -1;
7636 _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
7637 opt_fd->dynstr_index);
7638 if (!bfd_elf_link_record_dynamic_symbol (info, opt_fd))
7639 return NULL;
7640 }
7641 htab->tls_get_addr_fd = (struct ppc_link_hash_entry *) opt_fd;
7642 tga = &htab->tls_get_addr->elf;
7643 if (opt != NULL && tga != NULL)
7644 {
7645 tga->root.type = bfd_link_hash_indirect;
7646 tga->root.u.i.link = &opt->root;
7647 ppc64_elf_copy_indirect_symbol (info, opt, tga);
7648 _bfd_elf_link_hash_hide_symbol (info, opt,
7649 tga->forced_local);
7650 htab->tls_get_addr = (struct ppc_link_hash_entry *) opt;
7651 }
7652 htab->tls_get_addr_fd->oh = htab->tls_get_addr;
7653 htab->tls_get_addr_fd->is_func_descriptor = 1;
7654 if (htab->tls_get_addr != NULL)
7655 {
7656 htab->tls_get_addr->oh = htab->tls_get_addr_fd;
7657 htab->tls_get_addr->is_func = 1;
7658 }
7659 }
7660 }
7661 }
7662 else
7663 no_tls_get_addr_opt = TRUE;
7664 }
7665 htab->no_tls_get_addr_opt = no_tls_get_addr_opt;
7666 return _bfd_elf_tls_setup (info->output_bfd, info);
7667 }
7668
7669 /* Return TRUE iff REL is a branch reloc with a global symbol matching
7670 HASH1 or HASH2. */
7671
7672 static bfd_boolean
7673 branch_reloc_hash_match (const bfd *ibfd,
7674 const Elf_Internal_Rela *rel,
7675 const struct ppc_link_hash_entry *hash1,
7676 const struct ppc_link_hash_entry *hash2)
7677 {
7678 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
7679 enum elf_ppc64_reloc_type r_type = ELF64_R_TYPE (rel->r_info);
7680 unsigned int r_symndx = ELF64_R_SYM (rel->r_info);
7681
7682 if (r_symndx >= symtab_hdr->sh_info && is_branch_reloc (r_type))
7683 {
7684 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
7685 struct elf_link_hash_entry *h;
7686
7687 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
7688 h = elf_follow_link (h);
7689 if (h == &hash1->elf || h == &hash2->elf)
7690 return TRUE;
7691 }
7692 return FALSE;
7693 }
7694
7695 /* Run through all the TLS relocs looking for optimization
7696 opportunities. The linker has been hacked (see ppc64elf.em) to do
7697 a preliminary section layout so that we know the TLS segment
7698 offsets. We can't optimize earlier because some optimizations need
7699 to know the tp offset, and we need to optimize before allocating
7700 dynamic relocations. */
7701
7702 bfd_boolean
7703 ppc64_elf_tls_optimize (struct bfd_link_info *info)
7704 {
7705 bfd *ibfd;
7706 asection *sec;
7707 struct ppc_link_hash_table *htab;
7708 unsigned char *toc_ref;
7709 int pass;
7710
7711 if (info->relocatable || !info->executable)
7712 return TRUE;
7713
7714 htab = ppc_hash_table (info);
7715 if (htab == NULL)
7716 return FALSE;
7717
7718 /* Make two passes over the relocs. On the first pass, mark toc
7719 entries involved with tls relocs, and check that tls relocs
7720 involved in setting up a tls_get_addr call are indeed followed by
7721 such a call. If they are not, we can't do any tls optimization.
7722 On the second pass twiddle tls_mask flags to notify
7723 relocate_section that optimization can be done, and adjust got
7724 and plt refcounts. */
7725 toc_ref = NULL;
7726 for (pass = 0; pass < 2; ++pass)
7727 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
7728 {
7729 Elf_Internal_Sym *locsyms = NULL;
7730 asection *toc = bfd_get_section_by_name (ibfd, ".toc");
7731
7732 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
7733 if (sec->has_tls_reloc && !bfd_is_abs_section (sec->output_section))
7734 {
7735 Elf_Internal_Rela *relstart, *rel, *relend;
7736 bfd_boolean found_tls_get_addr_arg = 0;
7737
7738 /* Read the relocations. */
7739 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
7740 info->keep_memory);
7741 if (relstart == NULL)
7742 return FALSE;
7743
7744 relend = relstart + sec->reloc_count;
7745 for (rel = relstart; rel < relend; rel++)
7746 {
7747 enum elf_ppc64_reloc_type r_type;
7748 unsigned long r_symndx;
7749 struct elf_link_hash_entry *h;
7750 Elf_Internal_Sym *sym;
7751 asection *sym_sec;
7752 unsigned char *tls_mask;
7753 unsigned char tls_set, tls_clear, tls_type = 0;
7754 bfd_vma value;
7755 bfd_boolean ok_tprel, is_local;
7756 long toc_ref_index = 0;
7757 int expecting_tls_get_addr = 0;
7758 bfd_boolean ret = FALSE;
7759
7760 r_symndx = ELF64_R_SYM (rel->r_info);
7761 if (!get_sym_h (&h, &sym, &sym_sec, &tls_mask, &locsyms,
7762 r_symndx, ibfd))
7763 {
7764 err_free_rel:
7765 if (elf_section_data (sec)->relocs != relstart)
7766 free (relstart);
7767 if (toc_ref != NULL)
7768 free (toc_ref);
7769 if (locsyms != NULL
7770 && (elf_symtab_hdr (ibfd).contents
7771 != (unsigned char *) locsyms))
7772 free (locsyms);
7773 return ret;
7774 }
7775
7776 if (h != NULL)
7777 {
7778 if (h->root.type == bfd_link_hash_defined
7779 || h->root.type == bfd_link_hash_defweak)
7780 value = h->root.u.def.value;
7781 else if (h->root.type == bfd_link_hash_undefweak)
7782 value = 0;
7783 else
7784 {
7785 found_tls_get_addr_arg = 0;
7786 continue;
7787 }
7788 }
7789 else
7790 /* Symbols referenced by TLS relocs must be of type
7791 STT_TLS. So no need for .opd local sym adjust. */
7792 value = sym->st_value;
7793
7794 ok_tprel = FALSE;
7795 is_local = FALSE;
7796 if (h == NULL
7797 || !h->def_dynamic)
7798 {
7799 is_local = TRUE;
7800 if (h != NULL
7801 && h->root.type == bfd_link_hash_undefweak)
7802 ok_tprel = TRUE;
7803 else
7804 {
7805 value += sym_sec->output_offset;
7806 value += sym_sec->output_section->vma;
7807 value -= htab->elf.tls_sec->vma;
7808 ok_tprel = (value + TP_OFFSET + ((bfd_vma) 1 << 31)
7809 < (bfd_vma) 1 << 32);
7810 }
7811 }
7812
7813 r_type = ELF64_R_TYPE (rel->r_info);
7814 /* If this section has old-style __tls_get_addr calls
7815 without marker relocs, then check that each
7816 __tls_get_addr call reloc is preceded by a reloc
7817 that conceivably belongs to the __tls_get_addr arg
7818 setup insn. If we don't find matching arg setup
7819 relocs, don't do any tls optimization. */
7820 if (pass == 0
7821 && sec->has_tls_get_addr_call
7822 && h != NULL
7823 && (h == &htab->tls_get_addr->elf
7824 || h == &htab->tls_get_addr_fd->elf)
7825 && !found_tls_get_addr_arg
7826 && is_branch_reloc (r_type))
7827 {
7828 info->callbacks->minfo (_("%H __tls_get_addr lost arg, "
7829 "TLS optimization disabled\n"),
7830 ibfd, sec, rel->r_offset);
7831 ret = TRUE;
7832 goto err_free_rel;
7833 }
7834
7835 found_tls_get_addr_arg = 0;
7836 switch (r_type)
7837 {
7838 case R_PPC64_GOT_TLSLD16:
7839 case R_PPC64_GOT_TLSLD16_LO:
7840 expecting_tls_get_addr = 1;
7841 found_tls_get_addr_arg = 1;
7842 /* Fall thru */
7843
7844 case R_PPC64_GOT_TLSLD16_HI:
7845 case R_PPC64_GOT_TLSLD16_HA:
7846 /* These relocs should never be against a symbol
7847 defined in a shared lib. Leave them alone if
7848 that turns out to be the case. */
7849 if (!is_local)
7850 continue;
7851
7852 /* LD -> LE */
7853 tls_set = 0;
7854 tls_clear = TLS_LD;
7855 tls_type = TLS_TLS | TLS_LD;
7856 break;
7857
7858 case R_PPC64_GOT_TLSGD16:
7859 case R_PPC64_GOT_TLSGD16_LO:
7860 expecting_tls_get_addr = 1;
7861 found_tls_get_addr_arg = 1;
7862 /* Fall thru */
7863
7864 case R_PPC64_GOT_TLSGD16_HI:
7865 case R_PPC64_GOT_TLSGD16_HA:
7866 if (ok_tprel)
7867 /* GD -> LE */
7868 tls_set = 0;
7869 else
7870 /* GD -> IE */
7871 tls_set = TLS_TLS | TLS_TPRELGD;
7872 tls_clear = TLS_GD;
7873 tls_type = TLS_TLS | TLS_GD;
7874 break;
7875
7876 case R_PPC64_GOT_TPREL16_DS:
7877 case R_PPC64_GOT_TPREL16_LO_DS:
7878 case R_PPC64_GOT_TPREL16_HI:
7879 case R_PPC64_GOT_TPREL16_HA:
7880 if (ok_tprel)
7881 {
7882 /* IE -> LE */
7883 tls_set = 0;
7884 tls_clear = TLS_TPREL;
7885 tls_type = TLS_TLS | TLS_TPREL;
7886 break;
7887 }
7888 continue;
7889
7890 case R_PPC64_TLSGD:
7891 case R_PPC64_TLSLD:
7892 found_tls_get_addr_arg = 1;
7893 /* Fall thru */
7894
7895 case R_PPC64_TLS:
7896 case R_PPC64_TOC16:
7897 case R_PPC64_TOC16_LO:
7898 if (sym_sec == NULL || sym_sec != toc)
7899 continue;
7900
7901 /* Mark this toc entry as referenced by a TLS
7902 code sequence. We can do that now in the
7903 case of R_PPC64_TLS, and after checking for
7904 tls_get_addr for the TOC16 relocs. */
7905 if (toc_ref == NULL)
7906 toc_ref = bfd_zmalloc (toc->output_section->rawsize / 8);
7907 if (toc_ref == NULL)
7908 goto err_free_rel;
7909
7910 if (h != NULL)
7911 value = h->root.u.def.value;
7912 else
7913 value = sym->st_value;
7914 value += rel->r_addend;
7915 BFD_ASSERT (value < toc->size && value % 8 == 0);
7916 toc_ref_index = (value + toc->output_offset) / 8;
7917 if (r_type == R_PPC64_TLS
7918 || r_type == R_PPC64_TLSGD
7919 || r_type == R_PPC64_TLSLD)
7920 {
7921 toc_ref[toc_ref_index] = 1;
7922 continue;
7923 }
7924
7925 if (pass != 0 && toc_ref[toc_ref_index] == 0)
7926 continue;
7927
7928 tls_set = 0;
7929 tls_clear = 0;
7930 expecting_tls_get_addr = 2;
7931 break;
7932
7933 case R_PPC64_TPREL64:
7934 if (pass == 0
7935 || sec != toc
7936 || toc_ref == NULL
7937 || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
7938 continue;
7939 if (ok_tprel)
7940 {
7941 /* IE -> LE */
7942 tls_set = TLS_EXPLICIT;
7943 tls_clear = TLS_TPREL;
7944 break;
7945 }
7946 continue;
7947
7948 case R_PPC64_DTPMOD64:
7949 if (pass == 0
7950 || sec != toc
7951 || toc_ref == NULL
7952 || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
7953 continue;
7954 if (rel + 1 < relend
7955 && (rel[1].r_info
7956 == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64))
7957 && rel[1].r_offset == rel->r_offset + 8)
7958 {
7959 if (ok_tprel)
7960 /* GD -> LE */
7961 tls_set = TLS_EXPLICIT | TLS_GD;
7962 else
7963 /* GD -> IE */
7964 tls_set = TLS_EXPLICIT | TLS_GD | TLS_TPRELGD;
7965 tls_clear = TLS_GD;
7966 }
7967 else
7968 {
7969 if (!is_local)
7970 continue;
7971
7972 /* LD -> LE */
7973 tls_set = TLS_EXPLICIT;
7974 tls_clear = TLS_LD;
7975 }
7976 break;
7977
7978 default:
7979 continue;
7980 }
7981
7982 if (pass == 0)
7983 {
7984 if (!expecting_tls_get_addr
7985 || !sec->has_tls_get_addr_call)
7986 continue;
7987
7988 if (rel + 1 < relend
7989 && branch_reloc_hash_match (ibfd, rel + 1,
7990 htab->tls_get_addr,
7991 htab->tls_get_addr_fd))
7992 {
7993 if (expecting_tls_get_addr == 2)
7994 {
7995 /* Check for toc tls entries. */
7996 unsigned char *toc_tls;
7997 int retval;
7998
7999 retval = get_tls_mask (&toc_tls, NULL, NULL,
8000 &locsyms,
8001 rel, ibfd);
8002 if (retval == 0)
8003 goto err_free_rel;
8004 if (toc_tls != NULL)
8005 {
8006 if ((*toc_tls & (TLS_GD | TLS_LD)) != 0)
8007 found_tls_get_addr_arg = 1;
8008 if (retval > 1)
8009 toc_ref[toc_ref_index] = 1;
8010 }
8011 }
8012 continue;
8013 }
8014
8015 if (expecting_tls_get_addr != 1)
8016 continue;
8017
8018 /* Uh oh, we didn't find the expected call. We
8019 could just mark this symbol to exclude it
8020 from tls optimization but it's safer to skip
8021 the entire optimization. */
8022 info->callbacks->minfo (_("%H arg lost __tls_get_addr, "
8023 "TLS optimization disabled\n"),
8024 ibfd, sec, rel->r_offset);
8025 ret = TRUE;
8026 goto err_free_rel;
8027 }
8028
8029 if (expecting_tls_get_addr && htab->tls_get_addr != NULL)
8030 {
8031 struct plt_entry *ent;
8032 for (ent = htab->tls_get_addr->elf.plt.plist;
8033 ent != NULL;
8034 ent = ent->next)
8035 if (ent->addend == 0)
8036 {
8037 if (ent->plt.refcount > 0)
8038 {
8039 ent->plt.refcount -= 1;
8040 expecting_tls_get_addr = 0;
8041 }
8042 break;
8043 }
8044 }
8045
8046 if (expecting_tls_get_addr && htab->tls_get_addr_fd != NULL)
8047 {
8048 struct plt_entry *ent;
8049 for (ent = htab->tls_get_addr_fd->elf.plt.plist;
8050 ent != NULL;
8051 ent = ent->next)
8052 if (ent->addend == 0)
8053 {
8054 if (ent->plt.refcount > 0)
8055 ent->plt.refcount -= 1;
8056 break;
8057 }
8058 }
8059
8060 if (tls_clear == 0)
8061 continue;
8062
8063 if ((tls_set & TLS_EXPLICIT) == 0)
8064 {
8065 struct got_entry *ent;
8066
8067 /* Adjust got entry for this reloc. */
8068 if (h != NULL)
8069 ent = h->got.glist;
8070 else
8071 ent = elf_local_got_ents (ibfd)[r_symndx];
8072
8073 for (; ent != NULL; ent = ent->next)
8074 if (ent->addend == rel->r_addend
8075 && ent->owner == ibfd
8076 && ent->tls_type == tls_type)
8077 break;
8078 if (ent == NULL)
8079 abort ();
8080
8081 if (tls_set == 0)
8082 {
8083 /* We managed to get rid of a got entry. */
8084 if (ent->got.refcount > 0)
8085 ent->got.refcount -= 1;
8086 }
8087 }
8088 else
8089 {
8090 /* If we got rid of a DTPMOD/DTPREL reloc pair then
8091 we'll lose one or two dyn relocs. */
8092 if (!dec_dynrel_count (rel->r_info, sec, info,
8093 NULL, h, sym))
8094 return FALSE;
8095
8096 if (tls_set == (TLS_EXPLICIT | TLS_GD))
8097 {
8098 if (!dec_dynrel_count ((rel + 1)->r_info, sec, info,
8099 NULL, h, sym))
8100 return FALSE;
8101 }
8102 }
8103
8104 *tls_mask |= tls_set;
8105 *tls_mask &= ~tls_clear;
8106 }
8107
8108 if (elf_section_data (sec)->relocs != relstart)
8109 free (relstart);
8110 }
8111
8112 if (locsyms != NULL
8113 && (elf_symtab_hdr (ibfd).contents != (unsigned char *) locsyms))
8114 {
8115 if (!info->keep_memory)
8116 free (locsyms);
8117 else
8118 elf_symtab_hdr (ibfd).contents = (unsigned char *) locsyms;
8119 }
8120 }
8121
8122 if (toc_ref != NULL)
8123 free (toc_ref);
8124 return TRUE;
8125 }
8126
8127 /* Called via elf_link_hash_traverse from ppc64_elf_edit_toc to adjust
8128 the values of any global symbols in a toc section that has been
8129 edited. Globals in toc sections should be a rarity, so this function
8130 sets a flag if any are found in toc sections other than the one just
8131 edited, so that futher hash table traversals can be avoided. */
8132
8133 struct adjust_toc_info
8134 {
8135 asection *toc;
8136 unsigned long *skip;
8137 bfd_boolean global_toc_syms;
8138 };
8139
8140 enum toc_skip_enum { ref_from_discarded = 1, can_optimize = 2 };
8141
8142 static bfd_boolean
8143 adjust_toc_syms (struct elf_link_hash_entry *h, void *inf)
8144 {
8145 struct ppc_link_hash_entry *eh;
8146 struct adjust_toc_info *toc_inf = (struct adjust_toc_info *) inf;
8147 unsigned long i;
8148
8149 if (h->root.type != bfd_link_hash_defined
8150 && h->root.type != bfd_link_hash_defweak)
8151 return TRUE;
8152
8153 eh = (struct ppc_link_hash_entry *) h;
8154 if (eh->adjust_done)
8155 return TRUE;
8156
8157 if (eh->elf.root.u.def.section == toc_inf->toc)
8158 {
8159 if (eh->elf.root.u.def.value > toc_inf->toc->rawsize)
8160 i = toc_inf->toc->rawsize >> 3;
8161 else
8162 i = eh->elf.root.u.def.value >> 3;
8163
8164 if ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0)
8165 {
8166 (*_bfd_error_handler)
8167 (_("%s defined on removed toc entry"), eh->elf.root.root.string);
8168 do
8169 ++i;
8170 while ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0);
8171 eh->elf.root.u.def.value = (bfd_vma) i << 3;
8172 }
8173
8174 eh->elf.root.u.def.value -= toc_inf->skip[i];
8175 eh->adjust_done = 1;
8176 }
8177 else if (strcmp (eh->elf.root.u.def.section->name, ".toc") == 0)
8178 toc_inf->global_toc_syms = TRUE;
8179
8180 return TRUE;
8181 }
8182
8183 /* Return TRUE iff INSN is one we expect on a _LO variety toc/got reloc. */
8184
8185 static bfd_boolean
8186 ok_lo_toc_insn (unsigned int insn)
8187 {
8188 return ((insn & (0x3f << 26)) == 14u << 26 /* addi */
8189 || (insn & (0x3f << 26)) == 32u << 26 /* lwz */
8190 || (insn & (0x3f << 26)) == 34u << 26 /* lbz */
8191 || (insn & (0x3f << 26)) == 36u << 26 /* stw */
8192 || (insn & (0x3f << 26)) == 38u << 26 /* stb */
8193 || (insn & (0x3f << 26)) == 40u << 26 /* lhz */
8194 || (insn & (0x3f << 26)) == 42u << 26 /* lha */
8195 || (insn & (0x3f << 26)) == 44u << 26 /* sth */
8196 || (insn & (0x3f << 26)) == 46u << 26 /* lmw */
8197 || (insn & (0x3f << 26)) == 47u << 26 /* stmw */
8198 || (insn & (0x3f << 26)) == 48u << 26 /* lfs */
8199 || (insn & (0x3f << 26)) == 50u << 26 /* lfd */
8200 || (insn & (0x3f << 26)) == 52u << 26 /* stfs */
8201 || (insn & (0x3f << 26)) == 54u << 26 /* stfd */
8202 || ((insn & (0x3f << 26)) == 58u << 26 /* lwa,ld,lmd */
8203 && (insn & 3) != 1)
8204 || ((insn & (0x3f << 26)) == 62u << 26 /* std, stmd */
8205 && ((insn & 3) == 0 || (insn & 3) == 3))
8206 || (insn & (0x3f << 26)) == 12u << 26 /* addic */);
8207 }
8208
8209 /* Examine all relocs referencing .toc sections in order to remove
8210 unused .toc entries. */
8211
8212 bfd_boolean
8213 ppc64_elf_edit_toc (struct bfd_link_info *info)
8214 {
8215 bfd *ibfd;
8216 struct adjust_toc_info toc_inf;
8217 struct ppc_link_hash_table *htab = ppc_hash_table (info);
8218
8219 htab->do_toc_opt = 1;
8220 toc_inf.global_toc_syms = TRUE;
8221 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
8222 {
8223 asection *toc, *sec;
8224 Elf_Internal_Shdr *symtab_hdr;
8225 Elf_Internal_Sym *local_syms;
8226 Elf_Internal_Rela *relstart, *rel, *toc_relocs;
8227 unsigned long *skip, *drop;
8228 unsigned char *used;
8229 unsigned char *keep, last, some_unused;
8230
8231 if (!is_ppc64_elf (ibfd))
8232 continue;
8233
8234 toc = bfd_get_section_by_name (ibfd, ".toc");
8235 if (toc == NULL
8236 || toc->size == 0
8237 || toc->sec_info_type == SEC_INFO_TYPE_JUST_SYMS
8238 || discarded_section (toc))
8239 continue;
8240
8241 toc_relocs = NULL;
8242 local_syms = NULL;
8243 symtab_hdr = &elf_symtab_hdr (ibfd);
8244
8245 /* Look at sections dropped from the final link. */
8246 skip = NULL;
8247 relstart = NULL;
8248 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8249 {
8250 if (sec->reloc_count == 0
8251 || !discarded_section (sec)
8252 || get_opd_info (sec)
8253 || (sec->flags & SEC_ALLOC) == 0
8254 || (sec->flags & SEC_DEBUGGING) != 0)
8255 continue;
8256
8257 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL, FALSE);
8258 if (relstart == NULL)
8259 goto error_ret;
8260
8261 /* Run through the relocs to see which toc entries might be
8262 unused. */
8263 for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
8264 {
8265 enum elf_ppc64_reloc_type r_type;
8266 unsigned long r_symndx;
8267 asection *sym_sec;
8268 struct elf_link_hash_entry *h;
8269 Elf_Internal_Sym *sym;
8270 bfd_vma val;
8271
8272 r_type = ELF64_R_TYPE (rel->r_info);
8273 switch (r_type)
8274 {
8275 default:
8276 continue;
8277
8278 case R_PPC64_TOC16:
8279 case R_PPC64_TOC16_LO:
8280 case R_PPC64_TOC16_HI:
8281 case R_PPC64_TOC16_HA:
8282 case R_PPC64_TOC16_DS:
8283 case R_PPC64_TOC16_LO_DS:
8284 break;
8285 }
8286
8287 r_symndx = ELF64_R_SYM (rel->r_info);
8288 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8289 r_symndx, ibfd))
8290 goto error_ret;
8291
8292 if (sym_sec != toc)
8293 continue;
8294
8295 if (h != NULL)
8296 val = h->root.u.def.value;
8297 else
8298 val = sym->st_value;
8299 val += rel->r_addend;
8300
8301 if (val >= toc->size)
8302 continue;
8303
8304 /* Anything in the toc ought to be aligned to 8 bytes.
8305 If not, don't mark as unused. */
8306 if (val & 7)
8307 continue;
8308
8309 if (skip == NULL)
8310 {
8311 skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
8312 if (skip == NULL)
8313 goto error_ret;
8314 }
8315
8316 skip[val >> 3] = ref_from_discarded;
8317 }
8318
8319 if (elf_section_data (sec)->relocs != relstart)
8320 free (relstart);
8321 }
8322
8323 /* For largetoc loads of address constants, we can convert
8324 . addis rx,2,addr@got@ha
8325 . ld ry,addr@got@l(rx)
8326 to
8327 . addis rx,2,addr@toc@ha
8328 . addi ry,rx,addr@toc@l
8329 when addr is within 2G of the toc pointer. This then means
8330 that the word storing "addr" in the toc is no longer needed. */
8331
8332 if (!ppc64_elf_tdata (ibfd)->has_small_toc_reloc
8333 && toc->output_section->rawsize < (bfd_vma) 1 << 31
8334 && toc->reloc_count != 0)
8335 {
8336 /* Read toc relocs. */
8337 toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
8338 info->keep_memory);
8339 if (toc_relocs == NULL)
8340 goto error_ret;
8341
8342 for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
8343 {
8344 enum elf_ppc64_reloc_type r_type;
8345 unsigned long r_symndx;
8346 asection *sym_sec;
8347 struct elf_link_hash_entry *h;
8348 Elf_Internal_Sym *sym;
8349 bfd_vma val, addr;
8350
8351 r_type = ELF64_R_TYPE (rel->r_info);
8352 if (r_type != R_PPC64_ADDR64)
8353 continue;
8354
8355 r_symndx = ELF64_R_SYM (rel->r_info);
8356 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8357 r_symndx, ibfd))
8358 goto error_ret;
8359
8360 if (sym_sec == NULL
8361 || discarded_section (sym_sec))
8362 continue;
8363
8364 if (!SYMBOL_CALLS_LOCAL (info, h))
8365 continue;
8366
8367 if (h != NULL)
8368 {
8369 if (h->type == STT_GNU_IFUNC)
8370 continue;
8371 val = h->root.u.def.value;
8372 }
8373 else
8374 {
8375 if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
8376 continue;
8377 val = sym->st_value;
8378 }
8379 val += rel->r_addend;
8380 val += sym_sec->output_section->vma + sym_sec->output_offset;
8381
8382 /* We don't yet know the exact toc pointer value, but we
8383 know it will be somewhere in the toc section. Don't
8384 optimize if the difference from any possible toc
8385 pointer is outside [ff..f80008000, 7fff7fff]. */
8386 addr = toc->output_section->vma + TOC_BASE_OFF;
8387 if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
8388 continue;
8389
8390 addr = toc->output_section->vma + toc->output_section->rawsize;
8391 if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
8392 continue;
8393
8394 if (skip == NULL)
8395 {
8396 skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
8397 if (skip == NULL)
8398 goto error_ret;
8399 }
8400
8401 skip[rel->r_offset >> 3]
8402 |= can_optimize | ((rel - toc_relocs) << 2);
8403 }
8404 }
8405
8406 if (skip == NULL)
8407 continue;
8408
8409 used = bfd_zmalloc (sizeof (*used) * (toc->size + 7) / 8);
8410 if (used == NULL)
8411 {
8412 error_ret:
8413 if (local_syms != NULL
8414 && symtab_hdr->contents != (unsigned char *) local_syms)
8415 free (local_syms);
8416 if (sec != NULL
8417 && relstart != NULL
8418 && elf_section_data (sec)->relocs != relstart)
8419 free (relstart);
8420 if (toc_relocs != NULL
8421 && elf_section_data (toc)->relocs != toc_relocs)
8422 free (toc_relocs);
8423 if (skip != NULL)
8424 free (skip);
8425 return FALSE;
8426 }
8427
8428 /* Now check all kept sections that might reference the toc.
8429 Check the toc itself last. */
8430 for (sec = (ibfd->sections == toc && toc->next ? toc->next
8431 : ibfd->sections);
8432 sec != NULL;
8433 sec = (sec == toc ? NULL
8434 : sec->next == NULL ? toc
8435 : sec->next == toc && toc->next ? toc->next
8436 : sec->next))
8437 {
8438 int repeat;
8439
8440 if (sec->reloc_count == 0
8441 || discarded_section (sec)
8442 || get_opd_info (sec)
8443 || (sec->flags & SEC_ALLOC) == 0
8444 || (sec->flags & SEC_DEBUGGING) != 0)
8445 continue;
8446
8447 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8448 info->keep_memory);
8449 if (relstart == NULL)
8450 goto error_ret;
8451
8452 /* Mark toc entries referenced as used. */
8453 do
8454 {
8455 repeat = 0;
8456 for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
8457 {
8458 enum elf_ppc64_reloc_type r_type;
8459 unsigned long r_symndx;
8460 asection *sym_sec;
8461 struct elf_link_hash_entry *h;
8462 Elf_Internal_Sym *sym;
8463 bfd_vma val;
8464 enum {no_check, check_lo, check_ha} insn_check;
8465
8466 r_type = ELF64_R_TYPE (rel->r_info);
8467 switch (r_type)
8468 {
8469 default:
8470 insn_check = no_check;
8471 break;
8472
8473 case R_PPC64_GOT_TLSLD16_HA:
8474 case R_PPC64_GOT_TLSGD16_HA:
8475 case R_PPC64_GOT_TPREL16_HA:
8476 case R_PPC64_GOT_DTPREL16_HA:
8477 case R_PPC64_GOT16_HA:
8478 case R_PPC64_TOC16_HA:
8479 insn_check = check_ha;
8480 break;
8481
8482 case R_PPC64_GOT_TLSLD16_LO:
8483 case R_PPC64_GOT_TLSGD16_LO:
8484 case R_PPC64_GOT_TPREL16_LO_DS:
8485 case R_PPC64_GOT_DTPREL16_LO_DS:
8486 case R_PPC64_GOT16_LO:
8487 case R_PPC64_GOT16_LO_DS:
8488 case R_PPC64_TOC16_LO:
8489 case R_PPC64_TOC16_LO_DS:
8490 insn_check = check_lo;
8491 break;
8492 }
8493
8494 if (insn_check != no_check)
8495 {
8496 bfd_vma off = rel->r_offset & ~3;
8497 unsigned char buf[4];
8498 unsigned int insn;
8499
8500 if (!bfd_get_section_contents (ibfd, sec, buf, off, 4))
8501 {
8502 free (used);
8503 goto error_ret;
8504 }
8505 insn = bfd_get_32 (ibfd, buf);
8506 if (insn_check == check_lo
8507 ? !ok_lo_toc_insn (insn)
8508 : ((insn & ((0x3f << 26) | 0x1f << 16))
8509 != ((15u << 26) | (2 << 16)) /* addis rt,2,imm */))
8510 {
8511 char str[12];
8512
8513 ppc64_elf_tdata (ibfd)->unexpected_toc_insn = 1;
8514 sprintf (str, "%#08x", insn);
8515 info->callbacks->einfo
8516 (_("%P: %H: toc optimization is not supported for"
8517 " %s instruction.\n"),
8518 ibfd, sec, rel->r_offset & ~3, str);
8519 }
8520 }
8521
8522 switch (r_type)
8523 {
8524 case R_PPC64_TOC16:
8525 case R_PPC64_TOC16_LO:
8526 case R_PPC64_TOC16_HI:
8527 case R_PPC64_TOC16_HA:
8528 case R_PPC64_TOC16_DS:
8529 case R_PPC64_TOC16_LO_DS:
8530 /* In case we're taking addresses of toc entries. */
8531 case R_PPC64_ADDR64:
8532 break;
8533
8534 default:
8535 continue;
8536 }
8537
8538 r_symndx = ELF64_R_SYM (rel->r_info);
8539 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8540 r_symndx, ibfd))
8541 {
8542 free (used);
8543 goto error_ret;
8544 }
8545
8546 if (sym_sec != toc)
8547 continue;
8548
8549 if (h != NULL)
8550 val = h->root.u.def.value;
8551 else
8552 val = sym->st_value;
8553 val += rel->r_addend;
8554
8555 if (val >= toc->size)
8556 continue;
8557
8558 if ((skip[val >> 3] & can_optimize) != 0)
8559 {
8560 bfd_vma off;
8561 unsigned char opc;
8562
8563 switch (r_type)
8564 {
8565 case R_PPC64_TOC16_HA:
8566 break;
8567
8568 case R_PPC64_TOC16_LO_DS:
8569 off = rel->r_offset;
8570 off += (bfd_big_endian (ibfd) ? -2 : 3);
8571 if (!bfd_get_section_contents (ibfd, sec, &opc,
8572 off, 1))
8573 {
8574 free (used);
8575 goto error_ret;
8576 }
8577 if ((opc & (0x3f << 2)) == (58u << 2))
8578 break;
8579 /* Fall thru */
8580
8581 default:
8582 /* Wrong sort of reloc, or not a ld. We may
8583 as well clear ref_from_discarded too. */
8584 skip[val >> 3] = 0;
8585 }
8586 }
8587
8588 if (sec != toc)
8589 used[val >> 3] = 1;
8590 /* For the toc section, we only mark as used if this
8591 entry itself isn't unused. */
8592 else if ((used[rel->r_offset >> 3]
8593 || !(skip[rel->r_offset >> 3] & ref_from_discarded))
8594 && !used[val >> 3])
8595 {
8596 /* Do all the relocs again, to catch reference
8597 chains. */
8598 repeat = 1;
8599 used[val >> 3] = 1;
8600 }
8601 }
8602 }
8603 while (repeat);
8604
8605 if (elf_section_data (sec)->relocs != relstart)
8606 free (relstart);
8607 }
8608
8609 /* Merge the used and skip arrays. Assume that TOC
8610 doublewords not appearing as either used or unused belong
8611 to to an entry more than one doubleword in size. */
8612 for (drop = skip, keep = used, last = 0, some_unused = 0;
8613 drop < skip + (toc->size + 7) / 8;
8614 ++drop, ++keep)
8615 {
8616 if (*keep)
8617 {
8618 *drop &= ~ref_from_discarded;
8619 if ((*drop & can_optimize) != 0)
8620 some_unused = 1;
8621 last = 0;
8622 }
8623 else if ((*drop & ref_from_discarded) != 0)
8624 {
8625 some_unused = 1;
8626 last = ref_from_discarded;
8627 }
8628 else
8629 *drop = last;
8630 }
8631
8632 free (used);
8633
8634 if (some_unused)
8635 {
8636 bfd_byte *contents, *src;
8637 unsigned long off;
8638 Elf_Internal_Sym *sym;
8639 bfd_boolean local_toc_syms = FALSE;
8640
8641 /* Shuffle the toc contents, and at the same time convert the
8642 skip array from booleans into offsets. */
8643 if (!bfd_malloc_and_get_section (ibfd, toc, &contents))
8644 goto error_ret;
8645
8646 elf_section_data (toc)->this_hdr.contents = contents;
8647
8648 for (src = contents, off = 0, drop = skip;
8649 src < contents + toc->size;
8650 src += 8, ++drop)
8651 {
8652 if ((*drop & (can_optimize | ref_from_discarded)) != 0)
8653 off += 8;
8654 else if (off != 0)
8655 {
8656 *drop = off;
8657 memcpy (src - off, src, 8);
8658 }
8659 }
8660 *drop = off;
8661 toc->rawsize = toc->size;
8662 toc->size = src - contents - off;
8663
8664 /* Adjust addends for relocs against the toc section sym,
8665 and optimize any accesses we can. */
8666 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8667 {
8668 if (sec->reloc_count == 0
8669 || discarded_section (sec))
8670 continue;
8671
8672 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8673 info->keep_memory);
8674 if (relstart == NULL)
8675 goto error_ret;
8676
8677 for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
8678 {
8679 enum elf_ppc64_reloc_type r_type;
8680 unsigned long r_symndx;
8681 asection *sym_sec;
8682 struct elf_link_hash_entry *h;
8683 bfd_vma val;
8684
8685 r_type = ELF64_R_TYPE (rel->r_info);
8686 switch (r_type)
8687 {
8688 default:
8689 continue;
8690
8691 case R_PPC64_TOC16:
8692 case R_PPC64_TOC16_LO:
8693 case R_PPC64_TOC16_HI:
8694 case R_PPC64_TOC16_HA:
8695 case R_PPC64_TOC16_DS:
8696 case R_PPC64_TOC16_LO_DS:
8697 case R_PPC64_ADDR64:
8698 break;
8699 }
8700
8701 r_symndx = ELF64_R_SYM (rel->r_info);
8702 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8703 r_symndx, ibfd))
8704 goto error_ret;
8705
8706 if (sym_sec != toc)
8707 continue;
8708
8709 if (h != NULL)
8710 val = h->root.u.def.value;
8711 else
8712 {
8713 val = sym->st_value;
8714 if (val != 0)
8715 local_toc_syms = TRUE;
8716 }
8717
8718 val += rel->r_addend;
8719
8720 if (val > toc->rawsize)
8721 val = toc->rawsize;
8722 else if ((skip[val >> 3] & ref_from_discarded) != 0)
8723 continue;
8724 else if ((skip[val >> 3] & can_optimize) != 0)
8725 {
8726 Elf_Internal_Rela *tocrel
8727 = toc_relocs + (skip[val >> 3] >> 2);
8728 unsigned long tsym = ELF64_R_SYM (tocrel->r_info);
8729
8730 switch (r_type)
8731 {
8732 case R_PPC64_TOC16_HA:
8733 rel->r_info = ELF64_R_INFO (tsym, R_PPC64_TOC16_HA);
8734 break;
8735
8736 case R_PPC64_TOC16_LO_DS:
8737 rel->r_info = ELF64_R_INFO (tsym, R_PPC64_LO_DS_OPT);
8738 break;
8739
8740 default:
8741 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
8742 ppc_howto_init ();
8743 info->callbacks->einfo
8744 (_("%P: %H: %s references "
8745 "optimized away TOC entry\n"),
8746 ibfd, sec, rel->r_offset,
8747 ppc64_elf_howto_table[r_type]->name);
8748 bfd_set_error (bfd_error_bad_value);
8749 goto error_ret;
8750 }
8751 rel->r_addend = tocrel->r_addend;
8752 elf_section_data (sec)->relocs = relstart;
8753 continue;
8754 }
8755
8756 if (h != NULL || sym->st_value != 0)
8757 continue;
8758
8759 rel->r_addend -= skip[val >> 3];
8760 elf_section_data (sec)->relocs = relstart;
8761 }
8762
8763 if (elf_section_data (sec)->relocs != relstart)
8764 free (relstart);
8765 }
8766
8767 /* We shouldn't have local or global symbols defined in the TOC,
8768 but handle them anyway. */
8769 if (local_syms != NULL)
8770 for (sym = local_syms;
8771 sym < local_syms + symtab_hdr->sh_info;
8772 ++sym)
8773 if (sym->st_value != 0
8774 && bfd_section_from_elf_index (ibfd, sym->st_shndx) == toc)
8775 {
8776 unsigned long i;
8777
8778 if (sym->st_value > toc->rawsize)
8779 i = toc->rawsize >> 3;
8780 else
8781 i = sym->st_value >> 3;
8782
8783 if ((skip[i] & (ref_from_discarded | can_optimize)) != 0)
8784 {
8785 if (local_toc_syms)
8786 (*_bfd_error_handler)
8787 (_("%s defined on removed toc entry"),
8788 bfd_elf_sym_name (ibfd, symtab_hdr, sym, NULL));
8789 do
8790 ++i;
8791 while ((skip[i] & (ref_from_discarded | can_optimize)));
8792 sym->st_value = (bfd_vma) i << 3;
8793 }
8794
8795 sym->st_value -= skip[i];
8796 symtab_hdr->contents = (unsigned char *) local_syms;
8797 }
8798
8799 /* Adjust any global syms defined in this toc input section. */
8800 if (toc_inf.global_toc_syms)
8801 {
8802 toc_inf.toc = toc;
8803 toc_inf.skip = skip;
8804 toc_inf.global_toc_syms = FALSE;
8805 elf_link_hash_traverse (elf_hash_table (info), adjust_toc_syms,
8806 &toc_inf);
8807 }
8808
8809 if (toc->reloc_count != 0)
8810 {
8811 Elf_Internal_Shdr *rel_hdr;
8812 Elf_Internal_Rela *wrel;
8813 bfd_size_type sz;
8814
8815 /* Remove unused toc relocs, and adjust those we keep. */
8816 if (toc_relocs == NULL)
8817 toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
8818 info->keep_memory);
8819 if (toc_relocs == NULL)
8820 goto error_ret;
8821
8822 wrel = toc_relocs;
8823 for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
8824 if ((skip[rel->r_offset >> 3]
8825 & (ref_from_discarded | can_optimize)) == 0)
8826 {
8827 wrel->r_offset = rel->r_offset - skip[rel->r_offset >> 3];
8828 wrel->r_info = rel->r_info;
8829 wrel->r_addend = rel->r_addend;
8830 ++wrel;
8831 }
8832 else if (!dec_dynrel_count (rel->r_info, toc, info,
8833 &local_syms, NULL, NULL))
8834 goto error_ret;
8835
8836 elf_section_data (toc)->relocs = toc_relocs;
8837 toc->reloc_count = wrel - toc_relocs;
8838 rel_hdr = _bfd_elf_single_rel_hdr (toc);
8839 sz = rel_hdr->sh_entsize;
8840 rel_hdr->sh_size = toc->reloc_count * sz;
8841 }
8842 }
8843 else if (toc_relocs != NULL
8844 && elf_section_data (toc)->relocs != toc_relocs)
8845 free (toc_relocs);
8846
8847 if (local_syms != NULL
8848 && symtab_hdr->contents != (unsigned char *) local_syms)
8849 {
8850 if (!info->keep_memory)
8851 free (local_syms);
8852 else
8853 symtab_hdr->contents = (unsigned char *) local_syms;
8854 }
8855 free (skip);
8856 }
8857
8858 return TRUE;
8859 }
8860
8861 /* Return true iff input section I references the TOC using
8862 instructions limited to +/-32k offsets. */
8863
8864 bfd_boolean
8865 ppc64_elf_has_small_toc_reloc (asection *i)
8866 {
8867 return (is_ppc64_elf (i->owner)
8868 && ppc64_elf_tdata (i->owner)->has_small_toc_reloc);
8869 }
8870
8871 /* Allocate space for one GOT entry. */
8872
8873 static void
8874 allocate_got (struct elf_link_hash_entry *h,
8875 struct bfd_link_info *info,
8876 struct got_entry *gent)
8877 {
8878 struct ppc_link_hash_table *htab = ppc_hash_table (info);
8879 bfd_boolean dyn;
8880 struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
8881 int entsize = (gent->tls_type & eh->tls_mask & (TLS_GD | TLS_LD)
8882 ? 16 : 8);
8883 int rentsize = (gent->tls_type & eh->tls_mask & TLS_GD
8884 ? 2 : 1) * sizeof (Elf64_External_Rela);
8885 asection *got = ppc64_elf_tdata (gent->owner)->got;
8886
8887 gent->got.offset = got->size;
8888 got->size += entsize;
8889
8890 dyn = htab->elf.dynamic_sections_created;
8891 if (h->type == STT_GNU_IFUNC)
8892 {
8893 htab->reliplt->size += rentsize;
8894 htab->got_reli_size += rentsize;
8895 }
8896 else if ((info->shared
8897 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h))
8898 && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
8899 || h->root.type != bfd_link_hash_undefweak))
8900 {
8901 asection *relgot = ppc64_elf_tdata (gent->owner)->relgot;
8902 relgot->size += rentsize;
8903 }
8904 }
8905
8906 /* This function merges got entries in the same toc group. */
8907
8908 static void
8909 merge_got_entries (struct got_entry **pent)
8910 {
8911 struct got_entry *ent, *ent2;
8912
8913 for (ent = *pent; ent != NULL; ent = ent->next)
8914 if (!ent->is_indirect)
8915 for (ent2 = ent->next; ent2 != NULL; ent2 = ent2->next)
8916 if (!ent2->is_indirect
8917 && ent2->addend == ent->addend
8918 && ent2->tls_type == ent->tls_type
8919 && elf_gp (ent2->owner) == elf_gp (ent->owner))
8920 {
8921 ent2->is_indirect = TRUE;
8922 ent2->got.ent = ent;
8923 }
8924 }
8925
8926 /* Allocate space in .plt, .got and associated reloc sections for
8927 dynamic relocs. */
8928
8929 static bfd_boolean
8930 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
8931 {
8932 struct bfd_link_info *info;
8933 struct ppc_link_hash_table *htab;
8934 asection *s;
8935 struct ppc_link_hash_entry *eh;
8936 struct elf_dyn_relocs *p;
8937 struct got_entry **pgent, *gent;
8938
8939 if (h->root.type == bfd_link_hash_indirect)
8940 return TRUE;
8941
8942 info = (struct bfd_link_info *) inf;
8943 htab = ppc_hash_table (info);
8944 if (htab == NULL)
8945 return FALSE;
8946
8947 if ((htab->elf.dynamic_sections_created
8948 && h->dynindx != -1
8949 && WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info->shared, h))
8950 || h->type == STT_GNU_IFUNC)
8951 {
8952 struct plt_entry *pent;
8953 bfd_boolean doneone = FALSE;
8954 for (pent = h->plt.plist; pent != NULL; pent = pent->next)
8955 if (pent->plt.refcount > 0)
8956 {
8957 if (!htab->elf.dynamic_sections_created
8958 || h->dynindx == -1)
8959 {
8960 s = htab->iplt;
8961 pent->plt.offset = s->size;
8962 s->size += PLT_ENTRY_SIZE;
8963 s = htab->reliplt;
8964 }
8965 else
8966 {
8967 /* If this is the first .plt entry, make room for the special
8968 first entry. */
8969 s = htab->plt;
8970 if (s->size == 0)
8971 s->size += PLT_INITIAL_ENTRY_SIZE;
8972
8973 pent->plt.offset = s->size;
8974
8975 /* Make room for this entry. */
8976 s->size += PLT_ENTRY_SIZE;
8977
8978 /* Make room for the .glink code. */
8979 s = htab->glink;
8980 if (s->size == 0)
8981 s->size += GLINK_CALL_STUB_SIZE;
8982 /* We need bigger stubs past index 32767. */
8983 if (s->size >= GLINK_CALL_STUB_SIZE + 32768*2*4)
8984 s->size += 4;
8985 s->size += 2*4;
8986
8987 /* We also need to make an entry in the .rela.plt section. */
8988 s = htab->relplt;
8989 }
8990 s->size += sizeof (Elf64_External_Rela);
8991 doneone = TRUE;
8992 }
8993 else
8994 pent->plt.offset = (bfd_vma) -1;
8995 if (!doneone)
8996 {
8997 h->plt.plist = NULL;
8998 h->needs_plt = 0;
8999 }
9000 }
9001 else
9002 {
9003 h->plt.plist = NULL;
9004 h->needs_plt = 0;
9005 }
9006
9007 eh = (struct ppc_link_hash_entry *) h;
9008 /* Run through the TLS GD got entries first if we're changing them
9009 to TPREL. */
9010 if ((eh->tls_mask & TLS_TPRELGD) != 0)
9011 for (gent = h->got.glist; gent != NULL; gent = gent->next)
9012 if (gent->got.refcount > 0
9013 && (gent->tls_type & TLS_GD) != 0)
9014 {
9015 /* This was a GD entry that has been converted to TPREL. If
9016 there happens to be a TPREL entry we can use that one. */
9017 struct got_entry *ent;
9018 for (ent = h->got.glist; ent != NULL; ent = ent->next)
9019 if (ent->got.refcount > 0
9020 && (ent->tls_type & TLS_TPREL) != 0
9021 && ent->addend == gent->addend
9022 && ent->owner == gent->owner)
9023 {
9024 gent->got.refcount = 0;
9025 break;
9026 }
9027
9028 /* If not, then we'll be using our own TPREL entry. */
9029 if (gent->got.refcount != 0)
9030 gent->tls_type = TLS_TLS | TLS_TPREL;
9031 }
9032
9033 /* Remove any list entry that won't generate a word in the GOT before
9034 we call merge_got_entries. Otherwise we risk merging to empty
9035 entries. */
9036 pgent = &h->got.glist;
9037 while ((gent = *pgent) != NULL)
9038 if (gent->got.refcount > 0)
9039 {
9040 if ((gent->tls_type & TLS_LD) != 0
9041 && !h->def_dynamic)
9042 {
9043 ppc64_tlsld_got (gent->owner)->got.refcount += 1;
9044 *pgent = gent->next;
9045 }
9046 else
9047 pgent = &gent->next;
9048 }
9049 else
9050 *pgent = gent->next;
9051
9052 if (!htab->do_multi_toc)
9053 merge_got_entries (&h->got.glist);
9054
9055 for (gent = h->got.glist; gent != NULL; gent = gent->next)
9056 if (!gent->is_indirect)
9057 {
9058 /* Make sure this symbol is output as a dynamic symbol.
9059 Undefined weak syms won't yet be marked as dynamic,
9060 nor will all TLS symbols. */
9061 if (h->dynindx == -1
9062 && !h->forced_local
9063 && h->type != STT_GNU_IFUNC
9064 && htab->elf.dynamic_sections_created)
9065 {
9066 if (! bfd_elf_link_record_dynamic_symbol (info, h))
9067 return FALSE;
9068 }
9069
9070 if (!is_ppc64_elf (gent->owner))
9071 abort ();
9072
9073 allocate_got (h, info, gent);
9074 }
9075
9076 if (eh->dyn_relocs == NULL
9077 || (!htab->elf.dynamic_sections_created
9078 && h->type != STT_GNU_IFUNC))
9079 return TRUE;
9080
9081 /* In the shared -Bsymbolic case, discard space allocated for
9082 dynamic pc-relative relocs against symbols which turn out to be
9083 defined in regular objects. For the normal shared case, discard
9084 space for relocs that have become local due to symbol visibility
9085 changes. */
9086
9087 if (info->shared)
9088 {
9089 /* Relocs that use pc_count are those that appear on a call insn,
9090 or certain REL relocs (see must_be_dyn_reloc) that can be
9091 generated via assembly. We want calls to protected symbols to
9092 resolve directly to the function rather than going via the plt.
9093 If people want function pointer comparisons to work as expected
9094 then they should avoid writing weird assembly. */
9095 if (SYMBOL_CALLS_LOCAL (info, h))
9096 {
9097 struct elf_dyn_relocs **pp;
9098
9099 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
9100 {
9101 p->count -= p->pc_count;
9102 p->pc_count = 0;
9103 if (p->count == 0)
9104 *pp = p->next;
9105 else
9106 pp = &p->next;
9107 }
9108 }
9109
9110 /* Also discard relocs on undefined weak syms with non-default
9111 visibility. */
9112 if (eh->dyn_relocs != NULL
9113 && h->root.type == bfd_link_hash_undefweak)
9114 {
9115 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
9116 eh->dyn_relocs = NULL;
9117
9118 /* Make sure this symbol is output as a dynamic symbol.
9119 Undefined weak syms won't yet be marked as dynamic. */
9120 else if (h->dynindx == -1
9121 && !h->forced_local)
9122 {
9123 if (! bfd_elf_link_record_dynamic_symbol (info, h))
9124 return FALSE;
9125 }
9126 }
9127 }
9128 else if (h->type == STT_GNU_IFUNC)
9129 {
9130 if (!h->non_got_ref)
9131 eh->dyn_relocs = NULL;
9132 }
9133 else if (ELIMINATE_COPY_RELOCS)
9134 {
9135 /* For the non-shared case, discard space for relocs against
9136 symbols which turn out to need copy relocs or are not
9137 dynamic. */
9138
9139 if (!h->non_got_ref
9140 && !h->def_regular)
9141 {
9142 /* Make sure this symbol is output as a dynamic symbol.
9143 Undefined weak syms won't yet be marked as dynamic. */
9144 if (h->dynindx == -1
9145 && !h->forced_local)
9146 {
9147 if (! bfd_elf_link_record_dynamic_symbol (info, h))
9148 return FALSE;
9149 }
9150
9151 /* If that succeeded, we know we'll be keeping all the
9152 relocs. */
9153 if (h->dynindx != -1)
9154 goto keep;
9155 }
9156
9157 eh->dyn_relocs = NULL;
9158
9159 keep: ;
9160 }
9161
9162 /* Finally, allocate space. */
9163 for (p = eh->dyn_relocs; p != NULL; p = p->next)
9164 {
9165 asection *sreloc = elf_section_data (p->sec)->sreloc;
9166 if (eh->elf.type == STT_GNU_IFUNC)
9167 sreloc = htab->reliplt;
9168 sreloc->size += p->count * sizeof (Elf64_External_Rela);
9169 }
9170
9171 return TRUE;
9172 }
9173
9174 /* Find any dynamic relocs that apply to read-only sections. */
9175
9176 static bfd_boolean
9177 readonly_dynrelocs (struct elf_link_hash_entry *h, void *inf)
9178 {
9179 struct ppc_link_hash_entry *eh;
9180 struct elf_dyn_relocs *p;
9181
9182 eh = (struct ppc_link_hash_entry *) h;
9183 for (p = eh->dyn_relocs; p != NULL; p = p->next)
9184 {
9185 asection *s = p->sec->output_section;
9186
9187 if (s != NULL && (s->flags & SEC_READONLY) != 0)
9188 {
9189 struct bfd_link_info *info = inf;
9190
9191 info->flags |= DF_TEXTREL;
9192
9193 /* Not an error, just cut short the traversal. */
9194 return FALSE;
9195 }
9196 }
9197 return TRUE;
9198 }
9199
9200 /* Set the sizes of the dynamic sections. */
9201
9202 static bfd_boolean
9203 ppc64_elf_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
9204 struct bfd_link_info *info)
9205 {
9206 struct ppc_link_hash_table *htab;
9207 bfd *dynobj;
9208 asection *s;
9209 bfd_boolean relocs;
9210 bfd *ibfd;
9211 struct got_entry *first_tlsld;
9212
9213 htab = ppc_hash_table (info);
9214 if (htab == NULL)
9215 return FALSE;
9216
9217 dynobj = htab->elf.dynobj;
9218 if (dynobj == NULL)
9219 abort ();
9220
9221 if (htab->elf.dynamic_sections_created)
9222 {
9223 /* Set the contents of the .interp section to the interpreter. */
9224 if (info->executable)
9225 {
9226 s = bfd_get_linker_section (dynobj, ".interp");
9227 if (s == NULL)
9228 abort ();
9229 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
9230 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
9231 }
9232 }
9233
9234 /* Set up .got offsets for local syms, and space for local dynamic
9235 relocs. */
9236 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
9237 {
9238 struct got_entry **lgot_ents;
9239 struct got_entry **end_lgot_ents;
9240 struct plt_entry **local_plt;
9241 struct plt_entry **end_local_plt;
9242 unsigned char *lgot_masks;
9243 bfd_size_type locsymcount;
9244 Elf_Internal_Shdr *symtab_hdr;
9245
9246 if (!is_ppc64_elf (ibfd))
9247 continue;
9248
9249 for (s = ibfd->sections; s != NULL; s = s->next)
9250 {
9251 struct ppc_dyn_relocs *p;
9252
9253 for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
9254 {
9255 if (!bfd_is_abs_section (p->sec)
9256 && bfd_is_abs_section (p->sec->output_section))
9257 {
9258 /* Input section has been discarded, either because
9259 it is a copy of a linkonce section or due to
9260 linker script /DISCARD/, so we'll be discarding
9261 the relocs too. */
9262 }
9263 else if (p->count != 0)
9264 {
9265 asection *srel = elf_section_data (p->sec)->sreloc;
9266 if (p->ifunc)
9267 srel = htab->reliplt;
9268 srel->size += p->count * sizeof (Elf64_External_Rela);
9269 if ((p->sec->output_section->flags & SEC_READONLY) != 0)
9270 info->flags |= DF_TEXTREL;
9271 }
9272 }
9273 }
9274
9275 lgot_ents = elf_local_got_ents (ibfd);
9276 if (!lgot_ents)
9277 continue;
9278
9279 symtab_hdr = &elf_symtab_hdr (ibfd);
9280 locsymcount = symtab_hdr->sh_info;
9281 end_lgot_ents = lgot_ents + locsymcount;
9282 local_plt = (struct plt_entry **) end_lgot_ents;
9283 end_local_plt = local_plt + locsymcount;
9284 lgot_masks = (unsigned char *) end_local_plt;
9285 s = ppc64_elf_tdata (ibfd)->got;
9286 for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
9287 {
9288 struct got_entry **pent, *ent;
9289
9290 pent = lgot_ents;
9291 while ((ent = *pent) != NULL)
9292 if (ent->got.refcount > 0)
9293 {
9294 if ((ent->tls_type & *lgot_masks & TLS_LD) != 0)
9295 {
9296 ppc64_tlsld_got (ibfd)->got.refcount += 1;
9297 *pent = ent->next;
9298 }
9299 else
9300 {
9301 unsigned int ent_size = 8;
9302 unsigned int rel_size = sizeof (Elf64_External_Rela);
9303
9304 ent->got.offset = s->size;
9305 if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
9306 {
9307 ent_size *= 2;
9308 rel_size *= 2;
9309 }
9310 s->size += ent_size;
9311 if ((*lgot_masks & PLT_IFUNC) != 0)
9312 {
9313 htab->reliplt->size += rel_size;
9314 htab->got_reli_size += rel_size;
9315 }
9316 else if (info->shared)
9317 {
9318 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
9319 srel->size += rel_size;
9320 }
9321 pent = &ent->next;
9322 }
9323 }
9324 else
9325 *pent = ent->next;
9326 }
9327
9328 /* Allocate space for calls to local STT_GNU_IFUNC syms in .iplt. */
9329 for (; local_plt < end_local_plt; ++local_plt)
9330 {
9331 struct plt_entry *ent;
9332
9333 for (ent = *local_plt; ent != NULL; ent = ent->next)
9334 if (ent->plt.refcount > 0)
9335 {
9336 s = htab->iplt;
9337 ent->plt.offset = s->size;
9338 s->size += PLT_ENTRY_SIZE;
9339
9340 htab->reliplt->size += sizeof (Elf64_External_Rela);
9341 }
9342 else
9343 ent->plt.offset = (bfd_vma) -1;
9344 }
9345 }
9346
9347 /* Allocate global sym .plt and .got entries, and space for global
9348 sym dynamic relocs. */
9349 elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, info);
9350
9351 first_tlsld = NULL;
9352 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
9353 {
9354 struct got_entry *ent;
9355
9356 if (!is_ppc64_elf (ibfd))
9357 continue;
9358
9359 ent = ppc64_tlsld_got (ibfd);
9360 if (ent->got.refcount > 0)
9361 {
9362 if (!htab->do_multi_toc && first_tlsld != NULL)
9363 {
9364 ent->is_indirect = TRUE;
9365 ent->got.ent = first_tlsld;
9366 }
9367 else
9368 {
9369 if (first_tlsld == NULL)
9370 first_tlsld = ent;
9371 s = ppc64_elf_tdata (ibfd)->got;
9372 ent->got.offset = s->size;
9373 ent->owner = ibfd;
9374 s->size += 16;
9375 if (info->shared)
9376 {
9377 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
9378 srel->size += sizeof (Elf64_External_Rela);
9379 }
9380 }
9381 }
9382 else
9383 ent->got.offset = (bfd_vma) -1;
9384 }
9385
9386 /* We now have determined the sizes of the various dynamic sections.
9387 Allocate memory for them. */
9388 relocs = FALSE;
9389 for (s = dynobj->sections; s != NULL; s = s->next)
9390 {
9391 if ((s->flags & SEC_LINKER_CREATED) == 0)
9392 continue;
9393
9394 if (s == htab->brlt || s == htab->relbrlt)
9395 /* These haven't been allocated yet; don't strip. */
9396 continue;
9397 else if (s == htab->got
9398 || s == htab->plt
9399 || s == htab->iplt
9400 || s == htab->glink
9401 || s == htab->dynbss)
9402 {
9403 /* Strip this section if we don't need it; see the
9404 comment below. */
9405 }
9406 else if (s == htab->glink_eh_frame)
9407 {
9408 if (!bfd_is_abs_section (s->output_section))
9409 /* Not sized yet. */
9410 continue;
9411 }
9412 else if (CONST_STRNEQ (s->name, ".rela"))
9413 {
9414 if (s->size != 0)
9415 {
9416 if (s != htab->relplt)
9417 relocs = TRUE;
9418
9419 /* We use the reloc_count field as a counter if we need
9420 to copy relocs into the output file. */
9421 s->reloc_count = 0;
9422 }
9423 }
9424 else
9425 {
9426 /* It's not one of our sections, so don't allocate space. */
9427 continue;
9428 }
9429
9430 if (s->size == 0)
9431 {
9432 /* If we don't need this section, strip it from the
9433 output file. This is mostly to handle .rela.bss and
9434 .rela.plt. We must create both sections in
9435 create_dynamic_sections, because they must be created
9436 before the linker maps input sections to output
9437 sections. The linker does that before
9438 adjust_dynamic_symbol is called, and it is that
9439 function which decides whether anything needs to go
9440 into these sections. */
9441 s->flags |= SEC_EXCLUDE;
9442 continue;
9443 }
9444
9445 if ((s->flags & SEC_HAS_CONTENTS) == 0)
9446 continue;
9447
9448 /* Allocate memory for the section contents. We use bfd_zalloc
9449 here in case unused entries are not reclaimed before the
9450 section's contents are written out. This should not happen,
9451 but this way if it does we get a R_PPC64_NONE reloc in .rela
9452 sections instead of garbage.
9453 We also rely on the section contents being zero when writing
9454 the GOT. */
9455 s->contents = bfd_zalloc (dynobj, s->size);
9456 if (s->contents == NULL)
9457 return FALSE;
9458 }
9459
9460 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
9461 {
9462 if (!is_ppc64_elf (ibfd))
9463 continue;
9464
9465 s = ppc64_elf_tdata (ibfd)->got;
9466 if (s != NULL && s != htab->got)
9467 {
9468 if (s->size == 0)
9469 s->flags |= SEC_EXCLUDE;
9470 else
9471 {
9472 s->contents = bfd_zalloc (ibfd, s->size);
9473 if (s->contents == NULL)
9474 return FALSE;
9475 }
9476 }
9477 s = ppc64_elf_tdata (ibfd)->relgot;
9478 if (s != NULL)
9479 {
9480 if (s->size == 0)
9481 s->flags |= SEC_EXCLUDE;
9482 else
9483 {
9484 s->contents = bfd_zalloc (ibfd, s->size);
9485 if (s->contents == NULL)
9486 return FALSE;
9487 relocs = TRUE;
9488 s->reloc_count = 0;
9489 }
9490 }
9491 }
9492
9493 if (htab->elf.dynamic_sections_created)
9494 {
9495 /* Add some entries to the .dynamic section. We fill in the
9496 values later, in ppc64_elf_finish_dynamic_sections, but we
9497 must add the entries now so that we get the correct size for
9498 the .dynamic section. The DT_DEBUG entry is filled in by the
9499 dynamic linker and used by the debugger. */
9500 #define add_dynamic_entry(TAG, VAL) \
9501 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
9502
9503 if (info->executable)
9504 {
9505 if (!add_dynamic_entry (DT_DEBUG, 0))
9506 return FALSE;
9507 }
9508
9509 if (htab->plt != NULL && htab->plt->size != 0)
9510 {
9511 if (!add_dynamic_entry (DT_PLTGOT, 0)
9512 || !add_dynamic_entry (DT_PLTRELSZ, 0)
9513 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
9514 || !add_dynamic_entry (DT_JMPREL, 0)
9515 || !add_dynamic_entry (DT_PPC64_GLINK, 0))
9516 return FALSE;
9517 }
9518
9519 if (NO_OPD_RELOCS)
9520 {
9521 if (!add_dynamic_entry (DT_PPC64_OPD, 0)
9522 || !add_dynamic_entry (DT_PPC64_OPDSZ, 0))
9523 return FALSE;
9524 }
9525
9526 if (!htab->no_tls_get_addr_opt
9527 && htab->tls_get_addr_fd != NULL
9528 && htab->tls_get_addr_fd->elf.plt.plist != NULL
9529 && !add_dynamic_entry (DT_PPC64_TLSOPT, 0))
9530 return FALSE;
9531
9532 if (relocs)
9533 {
9534 if (!add_dynamic_entry (DT_RELA, 0)
9535 || !add_dynamic_entry (DT_RELASZ, 0)
9536 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
9537 return FALSE;
9538
9539 /* If any dynamic relocs apply to a read-only section,
9540 then we need a DT_TEXTREL entry. */
9541 if ((info->flags & DF_TEXTREL) == 0)
9542 elf_link_hash_traverse (&htab->elf, readonly_dynrelocs, info);
9543
9544 if ((info->flags & DF_TEXTREL) != 0)
9545 {
9546 if (!add_dynamic_entry (DT_TEXTREL, 0))
9547 return FALSE;
9548 }
9549 }
9550 }
9551 #undef add_dynamic_entry
9552
9553 return TRUE;
9554 }
9555
9556 /* Determine the type of stub needed, if any, for a call. */
9557
9558 static inline enum ppc_stub_type
9559 ppc_type_of_stub (asection *input_sec,
9560 const Elf_Internal_Rela *rel,
9561 struct ppc_link_hash_entry **hash,
9562 struct plt_entry **plt_ent,
9563 bfd_vma destination)
9564 {
9565 struct ppc_link_hash_entry *h = *hash;
9566 bfd_vma location;
9567 bfd_vma branch_offset;
9568 bfd_vma max_branch_offset;
9569 enum elf_ppc64_reloc_type r_type;
9570
9571 if (h != NULL)
9572 {
9573 struct plt_entry *ent;
9574 struct ppc_link_hash_entry *fdh = h;
9575 if (h->oh != NULL
9576 && h->oh->is_func_descriptor)
9577 {
9578 fdh = ppc_follow_link (h->oh);
9579 *hash = fdh;
9580 }
9581
9582 for (ent = fdh->elf.plt.plist; ent != NULL; ent = ent->next)
9583 if (ent->addend == rel->r_addend
9584 && ent->plt.offset != (bfd_vma) -1)
9585 {
9586 *plt_ent = ent;
9587 return ppc_stub_plt_call;
9588 }
9589
9590 /* Here, we know we don't have a plt entry. If we don't have a
9591 either a defined function descriptor or a defined entry symbol
9592 in a regular object file, then it is pointless trying to make
9593 any other type of stub. */
9594 if (!is_static_defined (&fdh->elf)
9595 && !is_static_defined (&h->elf))
9596 return ppc_stub_none;
9597 }
9598 else if (elf_local_got_ents (input_sec->owner) != NULL)
9599 {
9600 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (input_sec->owner);
9601 struct plt_entry **local_plt = (struct plt_entry **)
9602 elf_local_got_ents (input_sec->owner) + symtab_hdr->sh_info;
9603 unsigned long r_symndx = ELF64_R_SYM (rel->r_info);
9604
9605 if (local_plt[r_symndx] != NULL)
9606 {
9607 struct plt_entry *ent;
9608
9609 for (ent = local_plt[r_symndx]; ent != NULL; ent = ent->next)
9610 if (ent->addend == rel->r_addend
9611 && ent->plt.offset != (bfd_vma) -1)
9612 {
9613 *plt_ent = ent;
9614 return ppc_stub_plt_call;
9615 }
9616 }
9617 }
9618
9619 /* Determine where the call point is. */
9620 location = (input_sec->output_offset
9621 + input_sec->output_section->vma
9622 + rel->r_offset);
9623
9624 branch_offset = destination - location;
9625 r_type = ELF64_R_TYPE (rel->r_info);
9626
9627 /* Determine if a long branch stub is needed. */
9628 max_branch_offset = 1 << 25;
9629 if (r_type != R_PPC64_REL24)
9630 max_branch_offset = 1 << 15;
9631
9632 if (branch_offset + max_branch_offset >= 2 * max_branch_offset)
9633 /* We need a stub. Figure out whether a long_branch or plt_branch
9634 is needed later. */
9635 return ppc_stub_long_branch;
9636
9637 return ppc_stub_none;
9638 }
9639
9640 /* With power7 weakly ordered memory model, it is possible for ld.so
9641 to update a plt entry in one thread and have another thread see a
9642 stale zero toc entry. To avoid this we need some sort of acquire
9643 barrier in the call stub. One solution is to make the load of the
9644 toc word seem to appear to depend on the load of the function entry
9645 word. Another solution is to test for r2 being zero, and branch to
9646 the appropriate glink entry if so.
9647
9648 . fake dep barrier compare
9649 . ld 11,xxx(2) ld 11,xxx(2)
9650 . mtctr 11 mtctr 11
9651 . xor 11,11,11 ld 2,xxx+8(2)
9652 . add 2,2,11 cmpldi 2,0
9653 . ld 2,xxx+8(2) bnectr+
9654 . bctr b <glink_entry>
9655
9656 The solution involving the compare turns out to be faster, so
9657 that's what we use unless the branch won't reach. */
9658
9659 #define ALWAYS_USE_FAKE_DEP 0
9660 #define ALWAYS_EMIT_R2SAVE 0
9661
9662 #define PPC_LO(v) ((v) & 0xffff)
9663 #define PPC_HI(v) (((v) >> 16) & 0xffff)
9664 #define PPC_HA(v) PPC_HI ((v) + 0x8000)
9665
9666 static inline unsigned int
9667 plt_stub_size (struct ppc_link_hash_table *htab,
9668 struct ppc_stub_hash_entry *stub_entry,
9669 bfd_vma off)
9670 {
9671 unsigned size = PLT_CALL_STUB_SIZE;
9672
9673 if (!(ALWAYS_EMIT_R2SAVE
9674 || stub_entry->stub_type == ppc_stub_plt_call_r2save))
9675 size -= 4;
9676 if (!htab->plt_static_chain)
9677 size -= 4;
9678 if (htab->plt_thread_safe)
9679 size += 8;
9680 if (PPC_HA (off) == 0)
9681 size -= 4;
9682 if (PPC_HA (off + 8 + 8 * htab->plt_static_chain) != PPC_HA (off))
9683 size += 4;
9684 if (stub_entry->h != NULL
9685 && (stub_entry->h == htab->tls_get_addr_fd
9686 || stub_entry->h == htab->tls_get_addr)
9687 && !htab->no_tls_get_addr_opt)
9688 size += 13 * 4;
9689 return size;
9690 }
9691
9692 /* If this stub would cross fewer 2**plt_stub_align boundaries if we align,
9693 then return the padding needed to do so. */
9694 static inline unsigned int
9695 plt_stub_pad (struct ppc_link_hash_table *htab,
9696 struct ppc_stub_hash_entry *stub_entry,
9697 bfd_vma plt_off)
9698 {
9699 int stub_align = 1 << htab->plt_stub_align;
9700 unsigned stub_size = plt_stub_size (htab, stub_entry, plt_off);
9701 bfd_vma stub_off = stub_entry->stub_sec->size;
9702
9703 if (((stub_off + stub_size - 1) & -stub_align) - (stub_off & -stub_align)
9704 > (stub_size & -stub_align))
9705 return stub_align - (stub_off & (stub_align - 1));
9706 return 0;
9707 }
9708
9709 /* Build a .plt call stub. */
9710
9711 static inline bfd_byte *
9712 build_plt_stub (struct ppc_link_hash_table *htab,
9713 struct ppc_stub_hash_entry *stub_entry,
9714 bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
9715 {
9716 bfd *obfd = htab->stub_bfd;
9717 bfd_boolean plt_static_chain = htab->plt_static_chain;
9718 bfd_boolean plt_thread_safe = htab->plt_thread_safe;
9719 bfd_boolean use_fake_dep = plt_thread_safe;
9720 bfd_vma cmp_branch_off = 0;
9721
9722 if (!ALWAYS_USE_FAKE_DEP
9723 && plt_thread_safe
9724 && !(stub_entry->h != NULL
9725 && (stub_entry->h == htab->tls_get_addr_fd
9726 || stub_entry->h == htab->tls_get_addr)
9727 && !htab->no_tls_get_addr_opt))
9728 {
9729 bfd_vma pltoff = stub_entry->plt_ent->plt.offset & ~1;
9730 bfd_vma pltindex = (pltoff - PLT_INITIAL_ENTRY_SIZE) / PLT_ENTRY_SIZE;
9731 bfd_vma glinkoff = GLINK_CALL_STUB_SIZE + pltindex * 8;
9732 bfd_vma to, from;
9733
9734 if (pltindex > 32768)
9735 glinkoff += (pltindex - 32768) * 4;
9736 to = (glinkoff
9737 + htab->glink->output_offset
9738 + htab->glink->output_section->vma);
9739 from = (p - stub_entry->stub_sec->contents
9740 + 4 * (ALWAYS_EMIT_R2SAVE
9741 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
9742 + 4 * (PPC_HA (offset) != 0)
9743 + 4 * (PPC_HA (offset + 8 + 8 * plt_static_chain)
9744 != PPC_HA (offset))
9745 + 4 * (plt_static_chain != 0)
9746 + 20
9747 + stub_entry->stub_sec->output_offset
9748 + stub_entry->stub_sec->output_section->vma);
9749 cmp_branch_off = to - from;
9750 use_fake_dep = cmp_branch_off + (1 << 25) >= (1 << 26);
9751 }
9752
9753 if (PPC_HA (offset) != 0)
9754 {
9755 if (r != NULL)
9756 {
9757 if (ALWAYS_EMIT_R2SAVE
9758 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
9759 r[0].r_offset += 4;
9760 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
9761 r[1].r_offset = r[0].r_offset + 4;
9762 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
9763 r[1].r_addend = r[0].r_addend;
9764 if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
9765 {
9766 r[2].r_offset = r[1].r_offset + 4;
9767 r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO);
9768 r[2].r_addend = r[0].r_addend;
9769 }
9770 else
9771 {
9772 r[2].r_offset = r[1].r_offset + 8 + 8 * use_fake_dep;
9773 r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
9774 r[2].r_addend = r[0].r_addend + 8;
9775 if (plt_static_chain)
9776 {
9777 r[3].r_offset = r[2].r_offset + 4;
9778 r[3].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
9779 r[3].r_addend = r[0].r_addend + 16;
9780 }
9781 }
9782 }
9783 if (ALWAYS_EMIT_R2SAVE
9784 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
9785 bfd_put_32 (obfd, STD_R2_40R1, p), p += 4;
9786 bfd_put_32 (obfd, ADDIS_R12_R2 | PPC_HA (offset), p), p += 4;
9787 bfd_put_32 (obfd, LD_R11_0R12 | PPC_LO (offset), p), p += 4;
9788 if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
9789 {
9790 bfd_put_32 (obfd, ADDI_R12_R12 | PPC_LO (offset), p), p += 4;
9791 offset = 0;
9792 }
9793 bfd_put_32 (obfd, MTCTR_R11, p), p += 4;
9794 if (use_fake_dep)
9795 {
9796 bfd_put_32 (obfd, XOR_R11_R11_R11, p), p += 4;
9797 bfd_put_32 (obfd, ADD_R12_R12_R11, p), p += 4;
9798 }
9799 bfd_put_32 (obfd, LD_R2_0R12 | PPC_LO (offset + 8), p), p += 4;
9800 if (plt_static_chain)
9801 bfd_put_32 (obfd, LD_R11_0R12 | PPC_LO (offset + 16), p), p += 4;
9802 }
9803 else
9804 {
9805 if (r != NULL)
9806 {
9807 if (ALWAYS_EMIT_R2SAVE
9808 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
9809 r[0].r_offset += 4;
9810 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
9811 if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
9812 {
9813 r[1].r_offset = r[0].r_offset + 4;
9814 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16);
9815 r[1].r_addend = r[0].r_addend;
9816 }
9817 else
9818 {
9819 r[1].r_offset = r[0].r_offset + 8 + 8 * use_fake_dep;
9820 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
9821 r[1].r_addend = r[0].r_addend + 8 + 8 * plt_static_chain;
9822 if (plt_static_chain)
9823 {
9824 r[2].r_offset = r[1].r_offset + 4;
9825 r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
9826 r[2].r_addend = r[0].r_addend + 8;
9827 }
9828 }
9829 }
9830 if (ALWAYS_EMIT_R2SAVE
9831 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
9832 bfd_put_32 (obfd, STD_R2_40R1, p), p += 4;
9833 bfd_put_32 (obfd, LD_R11_0R2 | PPC_LO (offset), p), p += 4;
9834 if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
9835 {
9836 bfd_put_32 (obfd, ADDI_R2_R2 | PPC_LO (offset), p), p += 4;
9837 offset = 0;
9838 }
9839 bfd_put_32 (obfd, MTCTR_R11, p), p += 4;
9840 if (use_fake_dep)
9841 {
9842 bfd_put_32 (obfd, XOR_R11_R11_R11, p), p += 4;
9843 bfd_put_32 (obfd, ADD_R2_R2_R11, p), p += 4;
9844 }
9845 if (plt_static_chain)
9846 bfd_put_32 (obfd, LD_R11_0R2 | PPC_LO (offset + 16), p), p += 4;
9847 bfd_put_32 (obfd, LD_R2_0R2 | PPC_LO (offset + 8), p), p += 4;
9848 }
9849 if (plt_thread_safe && !use_fake_dep)
9850 {
9851 bfd_put_32 (obfd, CMPLDI_R2_0, p), p += 4;
9852 bfd_put_32 (obfd, BNECTR_P4, p), p += 4;
9853 bfd_put_32 (obfd, B_DOT | (cmp_branch_off & 0x3fffffc), p), p += 4;
9854 }
9855 else
9856 bfd_put_32 (obfd, BCTR, p), p += 4;
9857 return p;
9858 }
9859
9860 /* Build a special .plt call stub for __tls_get_addr. */
9861
9862 #define LD_R11_0R3 0xe9630000
9863 #define LD_R12_0R3 0xe9830000
9864 #define MR_R0_R3 0x7c601b78
9865 #define CMPDI_R11_0 0x2c2b0000
9866 #define ADD_R3_R12_R13 0x7c6c6a14
9867 #define BEQLR 0x4d820020
9868 #define MR_R3_R0 0x7c030378
9869 #define MFLR_R11 0x7d6802a6
9870 #define STD_R11_0R1 0xf9610000
9871 #define BCTRL 0x4e800421
9872 #define LD_R11_0R1 0xe9610000
9873 #define LD_R2_0R1 0xe8410000
9874 #define MTLR_R11 0x7d6803a6
9875
9876 static inline bfd_byte *
9877 build_tls_get_addr_stub (struct ppc_link_hash_table *htab,
9878 struct ppc_stub_hash_entry *stub_entry,
9879 bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
9880 {
9881 bfd *obfd = htab->stub_bfd;
9882
9883 bfd_put_32 (obfd, LD_R11_0R3 + 0, p), p += 4;
9884 bfd_put_32 (obfd, LD_R12_0R3 + 8, p), p += 4;
9885 bfd_put_32 (obfd, MR_R0_R3, p), p += 4;
9886 bfd_put_32 (obfd, CMPDI_R11_0, p), p += 4;
9887 bfd_put_32 (obfd, ADD_R3_R12_R13, p), p += 4;
9888 bfd_put_32 (obfd, BEQLR, p), p += 4;
9889 bfd_put_32 (obfd, MR_R3_R0, p), p += 4;
9890 bfd_put_32 (obfd, MFLR_R11, p), p += 4;
9891 bfd_put_32 (obfd, STD_R11_0R1 + 32, p), p += 4;
9892
9893 if (r != NULL)
9894 r[0].r_offset += 9 * 4;
9895 p = build_plt_stub (htab, stub_entry, p, offset, r);
9896 bfd_put_32 (obfd, BCTRL, p - 4);
9897
9898 bfd_put_32 (obfd, LD_R11_0R1 + 32, p), p += 4;
9899 bfd_put_32 (obfd, LD_R2_0R1 + 40, p), p += 4;
9900 bfd_put_32 (obfd, MTLR_R11, p), p += 4;
9901 bfd_put_32 (obfd, BLR, p), p += 4;
9902
9903 return p;
9904 }
9905
9906 static Elf_Internal_Rela *
9907 get_relocs (asection *sec, int count)
9908 {
9909 Elf_Internal_Rela *relocs;
9910 struct bfd_elf_section_data *elfsec_data;
9911
9912 elfsec_data = elf_section_data (sec);
9913 relocs = elfsec_data->relocs;
9914 if (relocs == NULL)
9915 {
9916 bfd_size_type relsize;
9917 relsize = sec->reloc_count * sizeof (*relocs);
9918 relocs = bfd_alloc (sec->owner, relsize);
9919 if (relocs == NULL)
9920 return NULL;
9921 elfsec_data->relocs = relocs;
9922 elfsec_data->rela.hdr = bfd_zalloc (sec->owner,
9923 sizeof (Elf_Internal_Shdr));
9924 if (elfsec_data->rela.hdr == NULL)
9925 return NULL;
9926 elfsec_data->rela.hdr->sh_size = (sec->reloc_count
9927 * sizeof (Elf64_External_Rela));
9928 elfsec_data->rela.hdr->sh_entsize = sizeof (Elf64_External_Rela);
9929 sec->reloc_count = 0;
9930 }
9931 relocs += sec->reloc_count;
9932 sec->reloc_count += count;
9933 return relocs;
9934 }
9935
9936 static bfd_vma
9937 get_r2off (struct bfd_link_info *info,
9938 struct ppc_stub_hash_entry *stub_entry)
9939 {
9940 struct ppc_link_hash_table *htab = ppc_hash_table (info);
9941 bfd_vma r2off = htab->stub_group[stub_entry->target_section->id].toc_off;
9942
9943 if (r2off == 0)
9944 {
9945 /* Support linking -R objects. Get the toc pointer from the
9946 opd entry. */
9947 char buf[8];
9948 asection *opd = stub_entry->h->elf.root.u.def.section;
9949 bfd_vma opd_off = stub_entry->h->elf.root.u.def.value;
9950
9951 if (strcmp (opd->name, ".opd") != 0
9952 || opd->reloc_count != 0)
9953 {
9954 info->callbacks->einfo (_("%P: cannot find opd entry toc for `%T'\n"),
9955 stub_entry->h->elf.root.root.string);
9956 bfd_set_error (bfd_error_bad_value);
9957 return 0;
9958 }
9959 if (!bfd_get_section_contents (opd->owner, opd, buf, opd_off + 8, 8))
9960 return 0;
9961 r2off = bfd_get_64 (opd->owner, buf);
9962 r2off -= elf_gp (info->output_bfd);
9963 }
9964 r2off -= htab->stub_group[stub_entry->id_sec->id].toc_off;
9965 return r2off;
9966 }
9967
9968 static bfd_boolean
9969 ppc_build_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
9970 {
9971 struct ppc_stub_hash_entry *stub_entry;
9972 struct ppc_branch_hash_entry *br_entry;
9973 struct bfd_link_info *info;
9974 struct ppc_link_hash_table *htab;
9975 bfd_byte *loc;
9976 bfd_byte *p;
9977 bfd_vma dest, off;
9978 int size;
9979 Elf_Internal_Rela *r;
9980 asection *plt;
9981
9982 /* Massage our args to the form they really have. */
9983 stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
9984 info = in_arg;
9985
9986 htab = ppc_hash_table (info);
9987 if (htab == NULL)
9988 return FALSE;
9989
9990 /* Make a note of the offset within the stubs for this entry. */
9991 stub_entry->stub_offset = stub_entry->stub_sec->size;
9992 loc = stub_entry->stub_sec->contents + stub_entry->stub_offset;
9993
9994 htab->stub_count[stub_entry->stub_type - 1] += 1;
9995 switch (stub_entry->stub_type)
9996 {
9997 case ppc_stub_long_branch:
9998 case ppc_stub_long_branch_r2off:
9999 /* Branches are relative. This is where we are going to. */
10000 off = dest = (stub_entry->target_value
10001 + stub_entry->target_section->output_offset
10002 + stub_entry->target_section->output_section->vma);
10003
10004 /* And this is where we are coming from. */
10005 off -= (stub_entry->stub_offset
10006 + stub_entry->stub_sec->output_offset
10007 + stub_entry->stub_sec->output_section->vma);
10008
10009 size = 4;
10010 if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
10011 {
10012 bfd_vma r2off = get_r2off (info, stub_entry);
10013
10014 if (r2off == 0)
10015 {
10016 htab->stub_error = TRUE;
10017 return FALSE;
10018 }
10019 bfd_put_32 (htab->stub_bfd, STD_R2_40R1, loc);
10020 loc += 4;
10021 size = 12;
10022 if (PPC_HA (r2off) != 0)
10023 {
10024 size = 16;
10025 bfd_put_32 (htab->stub_bfd, ADDIS_R2_R2 | PPC_HA (r2off), loc);
10026 loc += 4;
10027 }
10028 bfd_put_32 (htab->stub_bfd, ADDI_R2_R2 | PPC_LO (r2off), loc);
10029 loc += 4;
10030 off -= size - 4;
10031 }
10032 bfd_put_32 (htab->stub_bfd, B_DOT | (off & 0x3fffffc), loc);
10033
10034 if (off + (1 << 25) >= (bfd_vma) (1 << 26))
10035 {
10036 info->callbacks->einfo
10037 (_("%P: long branch stub `%s' offset overflow\n"),
10038 stub_entry->root.string);
10039 htab->stub_error = TRUE;
10040 return FALSE;
10041 }
10042
10043 if (info->emitrelocations)
10044 {
10045 r = get_relocs (stub_entry->stub_sec, 1);
10046 if (r == NULL)
10047 return FALSE;
10048 r->r_offset = loc - stub_entry->stub_sec->contents;
10049 r->r_info = ELF64_R_INFO (0, R_PPC64_REL24);
10050 r->r_addend = dest;
10051 if (stub_entry->h != NULL)
10052 {
10053 struct elf_link_hash_entry **hashes;
10054 unsigned long symndx;
10055 struct ppc_link_hash_entry *h;
10056
10057 hashes = elf_sym_hashes (htab->stub_bfd);
10058 if (hashes == NULL)
10059 {
10060 bfd_size_type hsize;
10061
10062 hsize = (htab->stub_globals + 1) * sizeof (*hashes);
10063 hashes = bfd_zalloc (htab->stub_bfd, hsize);
10064 if (hashes == NULL)
10065 return FALSE;
10066 elf_sym_hashes (htab->stub_bfd) = hashes;
10067 htab->stub_globals = 1;
10068 }
10069 symndx = htab->stub_globals++;
10070 h = stub_entry->h;
10071 hashes[symndx] = &h->elf;
10072 r->r_info = ELF64_R_INFO (symndx, R_PPC64_REL24);
10073 if (h->oh != NULL && h->oh->is_func)
10074 h = ppc_follow_link (h->oh);
10075 if (h->elf.root.u.def.section != stub_entry->target_section)
10076 /* H is an opd symbol. The addend must be zero. */
10077 r->r_addend = 0;
10078 else
10079 {
10080 off = (h->elf.root.u.def.value
10081 + h->elf.root.u.def.section->output_offset
10082 + h->elf.root.u.def.section->output_section->vma);
10083 r->r_addend -= off;
10084 }
10085 }
10086 }
10087 break;
10088
10089 case ppc_stub_plt_branch:
10090 case ppc_stub_plt_branch_r2off:
10091 br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
10092 stub_entry->root.string + 9,
10093 FALSE, FALSE);
10094 if (br_entry == NULL)
10095 {
10096 info->callbacks->einfo (_("%P: can't find branch stub `%s'\n"),
10097 stub_entry->root.string);
10098 htab->stub_error = TRUE;
10099 return FALSE;
10100 }
10101
10102 dest = (stub_entry->target_value
10103 + stub_entry->target_section->output_offset
10104 + stub_entry->target_section->output_section->vma);
10105
10106 bfd_put_64 (htab->brlt->owner, dest,
10107 htab->brlt->contents + br_entry->offset);
10108
10109 if (br_entry->iter == htab->stub_iteration)
10110 {
10111 br_entry->iter = 0;
10112
10113 if (htab->relbrlt != NULL)
10114 {
10115 /* Create a reloc for the branch lookup table entry. */
10116 Elf_Internal_Rela rela;
10117 bfd_byte *rl;
10118
10119 rela.r_offset = (br_entry->offset
10120 + htab->brlt->output_offset
10121 + htab->brlt->output_section->vma);
10122 rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
10123 rela.r_addend = dest;
10124
10125 rl = htab->relbrlt->contents;
10126 rl += (htab->relbrlt->reloc_count++
10127 * sizeof (Elf64_External_Rela));
10128 bfd_elf64_swap_reloca_out (htab->relbrlt->owner, &rela, rl);
10129 }
10130 else if (info->emitrelocations)
10131 {
10132 r = get_relocs (htab->brlt, 1);
10133 if (r == NULL)
10134 return FALSE;
10135 /* brlt, being SEC_LINKER_CREATED does not go through the
10136 normal reloc processing. Symbols and offsets are not
10137 translated from input file to output file form, so
10138 set up the offset per the output file. */
10139 r->r_offset = (br_entry->offset
10140 + htab->brlt->output_offset
10141 + htab->brlt->output_section->vma);
10142 r->r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
10143 r->r_addend = dest;
10144 }
10145 }
10146
10147 dest = (br_entry->offset
10148 + htab->brlt->output_offset
10149 + htab->brlt->output_section->vma);
10150
10151 off = (dest
10152 - elf_gp (htab->brlt->output_section->owner)
10153 - htab->stub_group[stub_entry->id_sec->id].toc_off);
10154
10155 if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
10156 {
10157 info->callbacks->einfo
10158 (_("%P: linkage table error against `%T'\n"),
10159 stub_entry->root.string);
10160 bfd_set_error (bfd_error_bad_value);
10161 htab->stub_error = TRUE;
10162 return FALSE;
10163 }
10164
10165 if (info->emitrelocations)
10166 {
10167 r = get_relocs (stub_entry->stub_sec, 1 + (PPC_HA (off) != 0));
10168 if (r == NULL)
10169 return FALSE;
10170 r[0].r_offset = loc - stub_entry->stub_sec->contents;
10171 if (bfd_big_endian (info->output_bfd))
10172 r[0].r_offset += 2;
10173 if (stub_entry->stub_type == ppc_stub_plt_branch_r2off)
10174 r[0].r_offset += 4;
10175 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10176 r[0].r_addend = dest;
10177 if (PPC_HA (off) != 0)
10178 {
10179 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
10180 r[1].r_offset = r[0].r_offset + 4;
10181 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10182 r[1].r_addend = r[0].r_addend;
10183 }
10184 }
10185
10186 if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
10187 {
10188 if (PPC_HA (off) != 0)
10189 {
10190 size = 16;
10191 bfd_put_32 (htab->stub_bfd, ADDIS_R12_R2 | PPC_HA (off), loc);
10192 loc += 4;
10193 bfd_put_32 (htab->stub_bfd, LD_R11_0R12 | PPC_LO (off), loc);
10194 }
10195 else
10196 {
10197 size = 12;
10198 bfd_put_32 (htab->stub_bfd, LD_R11_0R2 | PPC_LO (off), loc);
10199 }
10200 }
10201 else
10202 {
10203 bfd_vma r2off = get_r2off (info, stub_entry);
10204
10205 if (r2off == 0)
10206 {
10207 htab->stub_error = TRUE;
10208 return FALSE;
10209 }
10210
10211 bfd_put_32 (htab->stub_bfd, STD_R2_40R1, loc);
10212 loc += 4;
10213 size = 20;
10214 if (PPC_HA (off) != 0)
10215 {
10216 size += 4;
10217 bfd_put_32 (htab->stub_bfd, ADDIS_R12_R2 | PPC_HA (off), loc);
10218 loc += 4;
10219 bfd_put_32 (htab->stub_bfd, LD_R11_0R12 | PPC_LO (off), loc);
10220 loc += 4;
10221 }
10222 else
10223 {
10224 bfd_put_32 (htab->stub_bfd, LD_R11_0R2 | PPC_LO (off), loc);
10225 loc += 4;
10226 }
10227
10228 if (PPC_HA (r2off) != 0)
10229 {
10230 size += 4;
10231 bfd_put_32 (htab->stub_bfd, ADDIS_R2_R2 | PPC_HA (r2off), loc);
10232 loc += 4;
10233 }
10234 bfd_put_32 (htab->stub_bfd, ADDI_R2_R2 | PPC_LO (r2off), loc);
10235 }
10236 loc += 4;
10237 bfd_put_32 (htab->stub_bfd, MTCTR_R11, loc);
10238 loc += 4;
10239 bfd_put_32 (htab->stub_bfd, BCTR, loc);
10240 break;
10241
10242 case ppc_stub_plt_call:
10243 case ppc_stub_plt_call_r2save:
10244 if (stub_entry->h != NULL
10245 && stub_entry->h->is_func_descriptor
10246 && stub_entry->h->oh != NULL)
10247 {
10248 struct ppc_link_hash_entry *fh = ppc_follow_link (stub_entry->h->oh);
10249
10250 /* If the old-ABI "dot-symbol" is undefined make it weak so
10251 we don't get a link error from RELOC_FOR_GLOBAL_SYMBOL.
10252 FIXME: We used to define the symbol on one of the call
10253 stubs instead, which is why we test symbol section id
10254 against htab->top_id in various places. Likely all
10255 these checks could now disappear. */
10256 if (fh->elf.root.type == bfd_link_hash_undefined)
10257 fh->elf.root.type = bfd_link_hash_undefweak;
10258 /* Stop undo_symbol_twiddle changing it back to undefined. */
10259 fh->was_undefined = 0;
10260 }
10261
10262 /* Now build the stub. */
10263 dest = stub_entry->plt_ent->plt.offset & ~1;
10264 if (dest >= (bfd_vma) -2)
10265 abort ();
10266
10267 plt = htab->plt;
10268 if (!htab->elf.dynamic_sections_created
10269 || stub_entry->h == NULL
10270 || stub_entry->h->elf.dynindx == -1)
10271 plt = htab->iplt;
10272
10273 dest += plt->output_offset + plt->output_section->vma;
10274
10275 if (stub_entry->h == NULL
10276 && (stub_entry->plt_ent->plt.offset & 1) == 0)
10277 {
10278 Elf_Internal_Rela rela;
10279 bfd_byte *rl;
10280
10281 rela.r_offset = dest;
10282 rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
10283 rela.r_addend = (stub_entry->target_value
10284 + stub_entry->target_section->output_offset
10285 + stub_entry->target_section->output_section->vma);
10286
10287 rl = (htab->reliplt->contents
10288 + (htab->reliplt->reloc_count++
10289 * sizeof (Elf64_External_Rela)));
10290 bfd_elf64_swap_reloca_out (info->output_bfd, &rela, rl);
10291 stub_entry->plt_ent->plt.offset |= 1;
10292 }
10293
10294 off = (dest
10295 - elf_gp (plt->output_section->owner)
10296 - htab->stub_group[stub_entry->id_sec->id].toc_off);
10297
10298 if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
10299 {
10300 info->callbacks->einfo
10301 (_("%P: linkage table error against `%T'\n"),
10302 stub_entry->h != NULL
10303 ? stub_entry->h->elf.root.root.string
10304 : "<local sym>");
10305 bfd_set_error (bfd_error_bad_value);
10306 htab->stub_error = TRUE;
10307 return FALSE;
10308 }
10309
10310 if (htab->plt_stub_align != 0)
10311 {
10312 unsigned pad = plt_stub_pad (htab, stub_entry, off);
10313
10314 stub_entry->stub_sec->size += pad;
10315 stub_entry->stub_offset = stub_entry->stub_sec->size;
10316 loc += pad;
10317 }
10318
10319 r = NULL;
10320 if (info->emitrelocations)
10321 {
10322 r = get_relocs (stub_entry->stub_sec,
10323 (2
10324 + (PPC_HA (off) != 0)
10325 + (htab->plt_static_chain
10326 && PPC_HA (off + 16) == PPC_HA (off))));
10327 if (r == NULL)
10328 return FALSE;
10329 r[0].r_offset = loc - stub_entry->stub_sec->contents;
10330 if (bfd_big_endian (info->output_bfd))
10331 r[0].r_offset += 2;
10332 r[0].r_addend = dest;
10333 }
10334 if (stub_entry->h != NULL
10335 && (stub_entry->h == htab->tls_get_addr_fd
10336 || stub_entry->h == htab->tls_get_addr)
10337 && !htab->no_tls_get_addr_opt)
10338 p = build_tls_get_addr_stub (htab, stub_entry, loc, off, r);
10339 else
10340 p = build_plt_stub (htab, stub_entry, loc, off, r);
10341 size = p - loc;
10342 break;
10343
10344 default:
10345 BFD_FAIL ();
10346 return FALSE;
10347 }
10348
10349 stub_entry->stub_sec->size += size;
10350
10351 if (htab->emit_stub_syms)
10352 {
10353 struct elf_link_hash_entry *h;
10354 size_t len1, len2;
10355 char *name;
10356 const char *const stub_str[] = { "long_branch",
10357 "long_branch_r2off",
10358 "plt_branch",
10359 "plt_branch_r2off",
10360 "plt_call",
10361 "plt_call" };
10362
10363 len1 = strlen (stub_str[stub_entry->stub_type - 1]);
10364 len2 = strlen (stub_entry->root.string);
10365 name = bfd_malloc (len1 + len2 + 2);
10366 if (name == NULL)
10367 return FALSE;
10368 memcpy (name, stub_entry->root.string, 9);
10369 memcpy (name + 9, stub_str[stub_entry->stub_type - 1], len1);
10370 memcpy (name + len1 + 9, stub_entry->root.string + 8, len2 - 8 + 1);
10371 h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
10372 if (h == NULL)
10373 return FALSE;
10374 if (h->root.type == bfd_link_hash_new)
10375 {
10376 h->root.type = bfd_link_hash_defined;
10377 h->root.u.def.section = stub_entry->stub_sec;
10378 h->root.u.def.value = stub_entry->stub_offset;
10379 h->ref_regular = 1;
10380 h->def_regular = 1;
10381 h->ref_regular_nonweak = 1;
10382 h->forced_local = 1;
10383 h->non_elf = 0;
10384 }
10385 }
10386
10387 return TRUE;
10388 }
10389
10390 /* As above, but don't actually build the stub. Just bump offset so
10391 we know stub section sizes, and select plt_branch stubs where
10392 long_branch stubs won't do. */
10393
10394 static bfd_boolean
10395 ppc_size_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
10396 {
10397 struct ppc_stub_hash_entry *stub_entry;
10398 struct bfd_link_info *info;
10399 struct ppc_link_hash_table *htab;
10400 bfd_vma off;
10401 int size;
10402
10403 /* Massage our args to the form they really have. */
10404 stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
10405 info = in_arg;
10406
10407 htab = ppc_hash_table (info);
10408 if (htab == NULL)
10409 return FALSE;
10410
10411 if (stub_entry->stub_type == ppc_stub_plt_call
10412 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10413 {
10414 asection *plt;
10415 off = stub_entry->plt_ent->plt.offset & ~(bfd_vma) 1;
10416 if (off >= (bfd_vma) -2)
10417 abort ();
10418 plt = htab->plt;
10419 if (!htab->elf.dynamic_sections_created
10420 || stub_entry->h == NULL
10421 || stub_entry->h->elf.dynindx == -1)
10422 plt = htab->iplt;
10423 off += (plt->output_offset
10424 + plt->output_section->vma
10425 - elf_gp (plt->output_section->owner)
10426 - htab->stub_group[stub_entry->id_sec->id].toc_off);
10427
10428 size = plt_stub_size (htab, stub_entry, off);
10429 if (htab->plt_stub_align)
10430 size += plt_stub_pad (htab, stub_entry, off);
10431 if (info->emitrelocations)
10432 {
10433 stub_entry->stub_sec->reloc_count
10434 += (2
10435 + (PPC_HA (off) != 0)
10436 + (htab->plt_static_chain
10437 && PPC_HA (off + 16) == PPC_HA (off)));
10438 stub_entry->stub_sec->flags |= SEC_RELOC;
10439 }
10440 }
10441 else
10442 {
10443 /* ppc_stub_long_branch or ppc_stub_plt_branch, or their r2off
10444 variants. */
10445 bfd_vma r2off = 0;
10446
10447 off = (stub_entry->target_value
10448 + stub_entry->target_section->output_offset
10449 + stub_entry->target_section->output_section->vma);
10450 off -= (stub_entry->stub_sec->size
10451 + stub_entry->stub_sec->output_offset
10452 + stub_entry->stub_sec->output_section->vma);
10453
10454 /* Reset the stub type from the plt variant in case we now
10455 can reach with a shorter stub. */
10456 if (stub_entry->stub_type >= ppc_stub_plt_branch)
10457 stub_entry->stub_type += ppc_stub_long_branch - ppc_stub_plt_branch;
10458
10459 size = 4;
10460 if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
10461 {
10462 r2off = get_r2off (info, stub_entry);
10463 if (r2off == 0)
10464 {
10465 htab->stub_error = TRUE;
10466 return FALSE;
10467 }
10468 size = 12;
10469 if (PPC_HA (r2off) != 0)
10470 size = 16;
10471 off -= size - 4;
10472 }
10473
10474 /* If the branch offset if too big, use a ppc_stub_plt_branch. */
10475 if (off + (1 << 25) >= (bfd_vma) (1 << 26))
10476 {
10477 struct ppc_branch_hash_entry *br_entry;
10478
10479 br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
10480 stub_entry->root.string + 9,
10481 TRUE, FALSE);
10482 if (br_entry == NULL)
10483 {
10484 info->callbacks->einfo (_("%P: can't build branch stub `%s'\n"),
10485 stub_entry->root.string);
10486 htab->stub_error = TRUE;
10487 return FALSE;
10488 }
10489
10490 if (br_entry->iter != htab->stub_iteration)
10491 {
10492 br_entry->iter = htab->stub_iteration;
10493 br_entry->offset = htab->brlt->size;
10494 htab->brlt->size += 8;
10495
10496 if (htab->relbrlt != NULL)
10497 htab->relbrlt->size += sizeof (Elf64_External_Rela);
10498 else if (info->emitrelocations)
10499 {
10500 htab->brlt->reloc_count += 1;
10501 htab->brlt->flags |= SEC_RELOC;
10502 }
10503 }
10504
10505 stub_entry->stub_type += ppc_stub_plt_branch - ppc_stub_long_branch;
10506 off = (br_entry->offset
10507 + htab->brlt->output_offset
10508 + htab->brlt->output_section->vma
10509 - elf_gp (htab->brlt->output_section->owner)
10510 - htab->stub_group[stub_entry->id_sec->id].toc_off);
10511
10512 if (info->emitrelocations)
10513 {
10514 stub_entry->stub_sec->reloc_count += 1 + (PPC_HA (off) != 0);
10515 stub_entry->stub_sec->flags |= SEC_RELOC;
10516 }
10517
10518 if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
10519 {
10520 size = 12;
10521 if (PPC_HA (off) != 0)
10522 size = 16;
10523 }
10524 else
10525 {
10526 size = 20;
10527 if (PPC_HA (off) != 0)
10528 size += 4;
10529
10530 if (PPC_HA (r2off) != 0)
10531 size += 4;
10532 }
10533 }
10534 else if (info->emitrelocations)
10535 {
10536 stub_entry->stub_sec->reloc_count += 1;
10537 stub_entry->stub_sec->flags |= SEC_RELOC;
10538 }
10539 }
10540
10541 stub_entry->stub_sec->size += size;
10542 return TRUE;
10543 }
10544
10545 /* Set up various things so that we can make a list of input sections
10546 for each output section included in the link. Returns -1 on error,
10547 0 when no stubs will be needed, and 1 on success. */
10548
10549 int
10550 ppc64_elf_setup_section_lists
10551 (struct bfd_link_info *info,
10552 asection *(*add_stub_section) (const char *, asection *),
10553 void (*layout_sections_again) (void))
10554 {
10555 bfd *input_bfd;
10556 int top_id, top_index, id;
10557 asection *section;
10558 asection **input_list;
10559 bfd_size_type amt;
10560 struct ppc_link_hash_table *htab = ppc_hash_table (info);
10561
10562 if (htab == NULL)
10563 return -1;
10564 /* Stash our params away. */
10565 htab->add_stub_section = add_stub_section;
10566 htab->layout_sections_again = layout_sections_again;
10567
10568 /* Find the top input section id. */
10569 for (input_bfd = info->input_bfds, top_id = 3;
10570 input_bfd != NULL;
10571 input_bfd = input_bfd->link_next)
10572 {
10573 for (section = input_bfd->sections;
10574 section != NULL;
10575 section = section->next)
10576 {
10577 if (top_id < section->id)
10578 top_id = section->id;
10579 }
10580 }
10581
10582 htab->top_id = top_id;
10583 amt = sizeof (struct map_stub) * (top_id + 1);
10584 htab->stub_group = bfd_zmalloc (amt);
10585 if (htab->stub_group == NULL)
10586 return -1;
10587
10588 /* Set toc_off for com, und, abs and ind sections. */
10589 for (id = 0; id < 3; id++)
10590 htab->stub_group[id].toc_off = TOC_BASE_OFF;
10591
10592 /* We can't use output_bfd->section_count here to find the top output
10593 section index as some sections may have been removed, and
10594 strip_excluded_output_sections doesn't renumber the indices. */
10595 for (section = info->output_bfd->sections, top_index = 0;
10596 section != NULL;
10597 section = section->next)
10598 {
10599 if (top_index < section->index)
10600 top_index = section->index;
10601 }
10602
10603 htab->top_index = top_index;
10604 amt = sizeof (asection *) * (top_index + 1);
10605 input_list = bfd_zmalloc (amt);
10606 htab->input_list = input_list;
10607 if (input_list == NULL)
10608 return -1;
10609
10610 return 1;
10611 }
10612
10613 /* Set up for first pass at multitoc partitioning. */
10614
10615 void
10616 ppc64_elf_start_multitoc_partition (struct bfd_link_info *info)
10617 {
10618 struct ppc_link_hash_table *htab = ppc_hash_table (info);
10619
10620 elf_gp (info->output_bfd) = ppc64_elf_toc (info->output_bfd);
10621 htab->toc_curr = elf_gp (info->output_bfd);
10622 htab->toc_bfd = NULL;
10623 htab->toc_first_sec = NULL;
10624 }
10625
10626 /* The linker repeatedly calls this function for each TOC input section
10627 and linker generated GOT section. Group input bfds such that the toc
10628 within a group is less than 64k in size. */
10629
10630 bfd_boolean
10631 ppc64_elf_next_toc_section (struct bfd_link_info *info, asection *isec)
10632 {
10633 struct ppc_link_hash_table *htab = ppc_hash_table (info);
10634 bfd_vma addr, off, limit;
10635
10636 if (htab == NULL)
10637 return FALSE;
10638
10639 if (!htab->second_toc_pass)
10640 {
10641 /* Keep track of the first .toc or .got section for this input bfd. */
10642 bfd_boolean new_bfd = htab->toc_bfd != isec->owner;
10643
10644 if (new_bfd)
10645 {
10646 htab->toc_bfd = isec->owner;
10647 htab->toc_first_sec = isec;
10648 }
10649
10650 addr = isec->output_offset + isec->output_section->vma;
10651 off = addr - htab->toc_curr;
10652 limit = 0x80008000;
10653 if (ppc64_elf_tdata (isec->owner)->has_small_toc_reloc)
10654 limit = 0x10000;
10655 if (off + isec->size > limit)
10656 {
10657 addr = (htab->toc_first_sec->output_offset
10658 + htab->toc_first_sec->output_section->vma);
10659 htab->toc_curr = addr;
10660 }
10661
10662 /* toc_curr is the base address of this toc group. Set elf_gp
10663 for the input section to be the offset relative to the
10664 output toc base plus 0x8000. Making the input elf_gp an
10665 offset allows us to move the toc as a whole without
10666 recalculating input elf_gp. */
10667 off = htab->toc_curr - elf_gp (isec->output_section->owner);
10668 off += TOC_BASE_OFF;
10669
10670 /* Die if someone uses a linker script that doesn't keep input
10671 file .toc and .got together. */
10672 if (new_bfd
10673 && elf_gp (isec->owner) != 0
10674 && elf_gp (isec->owner) != off)
10675 return FALSE;
10676
10677 elf_gp (isec->owner) = off;
10678 return TRUE;
10679 }
10680
10681 /* During the second pass toc_first_sec points to the start of
10682 a toc group, and toc_curr is used to track the old elf_gp.
10683 We use toc_bfd to ensure we only look at each bfd once. */
10684 if (htab->toc_bfd == isec->owner)
10685 return TRUE;
10686 htab->toc_bfd = isec->owner;
10687
10688 if (htab->toc_first_sec == NULL
10689 || htab->toc_curr != elf_gp (isec->owner))
10690 {
10691 htab->toc_curr = elf_gp (isec->owner);
10692 htab->toc_first_sec = isec;
10693 }
10694 addr = (htab->toc_first_sec->output_offset
10695 + htab->toc_first_sec->output_section->vma);
10696 off = addr - elf_gp (isec->output_section->owner) + TOC_BASE_OFF;
10697 elf_gp (isec->owner) = off;
10698
10699 return TRUE;
10700 }
10701
10702 /* Called via elf_link_hash_traverse to merge GOT entries for global
10703 symbol H. */
10704
10705 static bfd_boolean
10706 merge_global_got (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
10707 {
10708 if (h->root.type == bfd_link_hash_indirect)
10709 return TRUE;
10710
10711 merge_got_entries (&h->got.glist);
10712
10713 return TRUE;
10714 }
10715
10716 /* Called via elf_link_hash_traverse to allocate GOT entries for global
10717 symbol H. */
10718
10719 static bfd_boolean
10720 reallocate_got (struct elf_link_hash_entry *h, void *inf)
10721 {
10722 struct got_entry *gent;
10723
10724 if (h->root.type == bfd_link_hash_indirect)
10725 return TRUE;
10726
10727 for (gent = h->got.glist; gent != NULL; gent = gent->next)
10728 if (!gent->is_indirect)
10729 allocate_got (h, (struct bfd_link_info *) inf, gent);
10730 return TRUE;
10731 }
10732
10733 /* Called on the first multitoc pass after the last call to
10734 ppc64_elf_next_toc_section. This function removes duplicate GOT
10735 entries. */
10736
10737 bfd_boolean
10738 ppc64_elf_layout_multitoc (struct bfd_link_info *info)
10739 {
10740 struct ppc_link_hash_table *htab = ppc_hash_table (info);
10741 struct bfd *ibfd, *ibfd2;
10742 bfd_boolean done_something;
10743
10744 htab->multi_toc_needed = htab->toc_curr != elf_gp (info->output_bfd);
10745
10746 if (!htab->do_multi_toc)
10747 return FALSE;
10748
10749 /* Merge global sym got entries within a toc group. */
10750 elf_link_hash_traverse (&htab->elf, merge_global_got, info);
10751
10752 /* And tlsld_got. */
10753 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
10754 {
10755 struct got_entry *ent, *ent2;
10756
10757 if (!is_ppc64_elf (ibfd))
10758 continue;
10759
10760 ent = ppc64_tlsld_got (ibfd);
10761 if (!ent->is_indirect
10762 && ent->got.offset != (bfd_vma) -1)
10763 {
10764 for (ibfd2 = ibfd->link_next; ibfd2 != NULL; ibfd2 = ibfd2->link_next)
10765 {
10766 if (!is_ppc64_elf (ibfd2))
10767 continue;
10768
10769 ent2 = ppc64_tlsld_got (ibfd2);
10770 if (!ent2->is_indirect
10771 && ent2->got.offset != (bfd_vma) -1
10772 && elf_gp (ibfd2) == elf_gp (ibfd))
10773 {
10774 ent2->is_indirect = TRUE;
10775 ent2->got.ent = ent;
10776 }
10777 }
10778 }
10779 }
10780
10781 /* Zap sizes of got sections. */
10782 htab->reliplt->rawsize = htab->reliplt->size;
10783 htab->reliplt->size -= htab->got_reli_size;
10784 htab->got_reli_size = 0;
10785
10786 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
10787 {
10788 asection *got, *relgot;
10789
10790 if (!is_ppc64_elf (ibfd))
10791 continue;
10792
10793 got = ppc64_elf_tdata (ibfd)->got;
10794 if (got != NULL)
10795 {
10796 got->rawsize = got->size;
10797 got->size = 0;
10798 relgot = ppc64_elf_tdata (ibfd)->relgot;
10799 relgot->rawsize = relgot->size;
10800 relgot->size = 0;
10801 }
10802 }
10803
10804 /* Now reallocate the got, local syms first. We don't need to
10805 allocate section contents again since we never increase size. */
10806 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
10807 {
10808 struct got_entry **lgot_ents;
10809 struct got_entry **end_lgot_ents;
10810 struct plt_entry **local_plt;
10811 struct plt_entry **end_local_plt;
10812 unsigned char *lgot_masks;
10813 bfd_size_type locsymcount;
10814 Elf_Internal_Shdr *symtab_hdr;
10815 asection *s;
10816
10817 if (!is_ppc64_elf (ibfd))
10818 continue;
10819
10820 lgot_ents = elf_local_got_ents (ibfd);
10821 if (!lgot_ents)
10822 continue;
10823
10824 symtab_hdr = &elf_symtab_hdr (ibfd);
10825 locsymcount = symtab_hdr->sh_info;
10826 end_lgot_ents = lgot_ents + locsymcount;
10827 local_plt = (struct plt_entry **) end_lgot_ents;
10828 end_local_plt = local_plt + locsymcount;
10829 lgot_masks = (unsigned char *) end_local_plt;
10830 s = ppc64_elf_tdata (ibfd)->got;
10831 for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
10832 {
10833 struct got_entry *ent;
10834
10835 for (ent = *lgot_ents; ent != NULL; ent = ent->next)
10836 {
10837 unsigned int ent_size = 8;
10838 unsigned int rel_size = sizeof (Elf64_External_Rela);
10839
10840 ent->got.offset = s->size;
10841 if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
10842 {
10843 ent_size *= 2;
10844 rel_size *= 2;
10845 }
10846 s->size += ent_size;
10847 if ((*lgot_masks & PLT_IFUNC) != 0)
10848 {
10849 htab->reliplt->size += rel_size;
10850 htab->got_reli_size += rel_size;
10851 }
10852 else if (info->shared)
10853 {
10854 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
10855 srel->size += rel_size;
10856 }
10857 }
10858 }
10859 }
10860
10861 elf_link_hash_traverse (&htab->elf, reallocate_got, info);
10862
10863 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
10864 {
10865 struct got_entry *ent;
10866
10867 if (!is_ppc64_elf (ibfd))
10868 continue;
10869
10870 ent = ppc64_tlsld_got (ibfd);
10871 if (!ent->is_indirect
10872 && ent->got.offset != (bfd_vma) -1)
10873 {
10874 asection *s = ppc64_elf_tdata (ibfd)->got;
10875 ent->got.offset = s->size;
10876 s->size += 16;
10877 if (info->shared)
10878 {
10879 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
10880 srel->size += sizeof (Elf64_External_Rela);
10881 }
10882 }
10883 }
10884
10885 done_something = htab->reliplt->rawsize != htab->reliplt->size;
10886 if (!done_something)
10887 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
10888 {
10889 asection *got;
10890
10891 if (!is_ppc64_elf (ibfd))
10892 continue;
10893
10894 got = ppc64_elf_tdata (ibfd)->got;
10895 if (got != NULL)
10896 {
10897 done_something = got->rawsize != got->size;
10898 if (done_something)
10899 break;
10900 }
10901 }
10902
10903 if (done_something)
10904 (*htab->layout_sections_again) ();
10905
10906 /* Set up for second pass over toc sections to recalculate elf_gp
10907 on input sections. */
10908 htab->toc_bfd = NULL;
10909 htab->toc_first_sec = NULL;
10910 htab->second_toc_pass = TRUE;
10911 return done_something;
10912 }
10913
10914 /* Called after second pass of multitoc partitioning. */
10915
10916 void
10917 ppc64_elf_finish_multitoc_partition (struct bfd_link_info *info)
10918 {
10919 struct ppc_link_hash_table *htab = ppc_hash_table (info);
10920
10921 /* After the second pass, toc_curr tracks the TOC offset used
10922 for code sections below in ppc64_elf_next_input_section. */
10923 htab->toc_curr = TOC_BASE_OFF;
10924 }
10925
10926 /* No toc references were found in ISEC. If the code in ISEC makes no
10927 calls, then there's no need to use toc adjusting stubs when branching
10928 into ISEC. Actually, indirect calls from ISEC are OK as they will
10929 load r2. Returns -1 on error, 0 for no stub needed, 1 for stub
10930 needed, and 2 if a cyclical call-graph was found but no other reason
10931 for a stub was detected. If called from the top level, a return of
10932 2 means the same as a return of 0. */
10933
10934 static int
10935 toc_adjusting_stub_needed (struct bfd_link_info *info, asection *isec)
10936 {
10937 int ret;
10938
10939 /* Mark this section as checked. */
10940 isec->call_check_done = 1;
10941
10942 /* We know none of our code bearing sections will need toc stubs. */
10943 if ((isec->flags & SEC_LINKER_CREATED) != 0)
10944 return 0;
10945
10946 if (isec->size == 0)
10947 return 0;
10948
10949 if (isec->output_section == NULL)
10950 return 0;
10951
10952 ret = 0;
10953 if (isec->reloc_count != 0)
10954 {
10955 Elf_Internal_Rela *relstart, *rel;
10956 Elf_Internal_Sym *local_syms;
10957 struct ppc_link_hash_table *htab;
10958
10959 relstart = _bfd_elf_link_read_relocs (isec->owner, isec, NULL, NULL,
10960 info->keep_memory);
10961 if (relstart == NULL)
10962 return -1;
10963
10964 /* Look for branches to outside of this section. */
10965 local_syms = NULL;
10966 htab = ppc_hash_table (info);
10967 if (htab == NULL)
10968 return -1;
10969
10970 for (rel = relstart; rel < relstart + isec->reloc_count; ++rel)
10971 {
10972 enum elf_ppc64_reloc_type r_type;
10973 unsigned long r_symndx;
10974 struct elf_link_hash_entry *h;
10975 struct ppc_link_hash_entry *eh;
10976 Elf_Internal_Sym *sym;
10977 asection *sym_sec;
10978 struct _opd_sec_data *opd;
10979 bfd_vma sym_value;
10980 bfd_vma dest;
10981
10982 r_type = ELF64_R_TYPE (rel->r_info);
10983 if (r_type != R_PPC64_REL24
10984 && r_type != R_PPC64_REL14
10985 && r_type != R_PPC64_REL14_BRTAKEN
10986 && r_type != R_PPC64_REL14_BRNTAKEN)
10987 continue;
10988
10989 r_symndx = ELF64_R_SYM (rel->r_info);
10990 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms, r_symndx,
10991 isec->owner))
10992 {
10993 ret = -1;
10994 break;
10995 }
10996
10997 /* Calls to dynamic lib functions go through a plt call stub
10998 that uses r2. */
10999 eh = (struct ppc_link_hash_entry *) h;
11000 if (eh != NULL
11001 && (eh->elf.plt.plist != NULL
11002 || (eh->oh != NULL
11003 && ppc_follow_link (eh->oh)->elf.plt.plist != NULL)))
11004 {
11005 ret = 1;
11006 break;
11007 }
11008
11009 if (sym_sec == NULL)
11010 /* Ignore other undefined symbols. */
11011 continue;
11012
11013 /* Assume branches to other sections not included in the
11014 link need stubs too, to cover -R and absolute syms. */
11015 if (sym_sec->output_section == NULL)
11016 {
11017 ret = 1;
11018 break;
11019 }
11020
11021 if (h == NULL)
11022 sym_value = sym->st_value;
11023 else
11024 {
11025 if (h->root.type != bfd_link_hash_defined
11026 && h->root.type != bfd_link_hash_defweak)
11027 abort ();
11028 sym_value = h->root.u.def.value;
11029 }
11030 sym_value += rel->r_addend;
11031
11032 /* If this branch reloc uses an opd sym, find the code section. */
11033 opd = get_opd_info (sym_sec);
11034 if (opd != NULL)
11035 {
11036 if (h == NULL && opd->adjust != NULL)
11037 {
11038 long adjust;
11039
11040 adjust = opd->adjust[sym->st_value / 8];
11041 if (adjust == -1)
11042 /* Assume deleted functions won't ever be called. */
11043 continue;
11044 sym_value += adjust;
11045 }
11046
11047 dest = opd_entry_value (sym_sec, sym_value,
11048 &sym_sec, NULL, FALSE);
11049 if (dest == (bfd_vma) -1)
11050 continue;
11051 }
11052 else
11053 dest = (sym_value
11054 + sym_sec->output_offset
11055 + sym_sec->output_section->vma);
11056
11057 /* Ignore branch to self. */
11058 if (sym_sec == isec)
11059 continue;
11060
11061 /* If the called function uses the toc, we need a stub. */
11062 if (sym_sec->has_toc_reloc
11063 || sym_sec->makes_toc_func_call)
11064 {
11065 ret = 1;
11066 break;
11067 }
11068
11069 /* Assume any branch that needs a long branch stub might in fact
11070 need a plt_branch stub. A plt_branch stub uses r2. */
11071 else if (dest - (isec->output_offset
11072 + isec->output_section->vma
11073 + rel->r_offset) + (1 << 25) >= (2 << 25))
11074 {
11075 ret = 1;
11076 break;
11077 }
11078
11079 /* If calling back to a section in the process of being
11080 tested, we can't say for sure that no toc adjusting stubs
11081 are needed, so don't return zero. */
11082 else if (sym_sec->call_check_in_progress)
11083 ret = 2;
11084
11085 /* Branches to another section that itself doesn't have any TOC
11086 references are OK. Recursively call ourselves to check. */
11087 else if (!sym_sec->call_check_done)
11088 {
11089 int recur;
11090
11091 /* Mark current section as indeterminate, so that other
11092 sections that call back to current won't be marked as
11093 known. */
11094 isec->call_check_in_progress = 1;
11095 recur = toc_adjusting_stub_needed (info, sym_sec);
11096 isec->call_check_in_progress = 0;
11097
11098 if (recur != 0)
11099 {
11100 ret = recur;
11101 if (recur != 2)
11102 break;
11103 }
11104 }
11105 }
11106
11107 if (local_syms != NULL
11108 && (elf_symtab_hdr (isec->owner).contents
11109 != (unsigned char *) local_syms))
11110 free (local_syms);
11111 if (elf_section_data (isec)->relocs != relstart)
11112 free (relstart);
11113 }
11114
11115 if ((ret & 1) == 0
11116 && isec->map_head.s != NULL
11117 && (strcmp (isec->output_section->name, ".init") == 0
11118 || strcmp (isec->output_section->name, ".fini") == 0))
11119 {
11120 if (isec->map_head.s->has_toc_reloc
11121 || isec->map_head.s->makes_toc_func_call)
11122 ret = 1;
11123 else if (!isec->map_head.s->call_check_done)
11124 {
11125 int recur;
11126 isec->call_check_in_progress = 1;
11127 recur = toc_adjusting_stub_needed (info, isec->map_head.s);
11128 isec->call_check_in_progress = 0;
11129 if (recur != 0)
11130 ret = recur;
11131 }
11132 }
11133
11134 if (ret == 1)
11135 isec->makes_toc_func_call = 1;
11136
11137 return ret;
11138 }
11139
11140 /* The linker repeatedly calls this function for each input section,
11141 in the order that input sections are linked into output sections.
11142 Build lists of input sections to determine groupings between which
11143 we may insert linker stubs. */
11144
11145 bfd_boolean
11146 ppc64_elf_next_input_section (struct bfd_link_info *info, asection *isec)
11147 {
11148 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11149
11150 if (htab == NULL)
11151 return FALSE;
11152
11153 if ((isec->output_section->flags & SEC_CODE) != 0
11154 && isec->output_section->index <= htab->top_index)
11155 {
11156 asection **list = htab->input_list + isec->output_section->index;
11157 /* Steal the link_sec pointer for our list. */
11158 #define PREV_SEC(sec) (htab->stub_group[(sec)->id].link_sec)
11159 /* This happens to make the list in reverse order,
11160 which is what we want. */
11161 PREV_SEC (isec) = *list;
11162 *list = isec;
11163 }
11164
11165 if (htab->multi_toc_needed)
11166 {
11167 /* If a code section has a function that uses the TOC then we need
11168 to use the right TOC (obviously). Also, make sure that .opd gets
11169 the correct TOC value for R_PPC64_TOC relocs that don't have or
11170 can't find their function symbol (shouldn't ever happen now).
11171 Also specially treat .fixup for the linux kernel. .fixup
11172 contains branches, but only back to the function that hit an
11173 exception. */
11174 if (isec->has_toc_reloc
11175 || (isec->flags & SEC_CODE) == 0
11176 || strcmp (isec->name, ".fixup") == 0)
11177 {
11178 if (elf_gp (isec->owner) != 0)
11179 htab->toc_curr = elf_gp (isec->owner);
11180 }
11181 else
11182 {
11183 if (!isec->call_check_done
11184 && toc_adjusting_stub_needed (info, isec) < 0)
11185 return FALSE;
11186 /* If we make a local call from this section, ie. a branch
11187 without a following nop, then we have no place to put a
11188 toc restoring insn. We must use the same toc group as
11189 the callee.
11190 Testing makes_toc_func_call actually tests for *any*
11191 calls to functions that need a good toc pointer. A more
11192 precise test would be better, as this one will set
11193 incorrect values for pasted .init/.fini fragments.
11194 (Fixed later in check_pasted_section.) */
11195 if (isec->makes_toc_func_call
11196 && elf_gp (isec->owner) != 0)
11197 htab->toc_curr = elf_gp (isec->owner);
11198 }
11199 }
11200
11201 /* Functions that don't use the TOC can belong in any TOC group.
11202 Use the last TOC base. */
11203 htab->stub_group[isec->id].toc_off = htab->toc_curr;
11204 return TRUE;
11205 }
11206
11207 /* Check that all .init and .fini sections use the same toc, if they
11208 have toc relocs. */
11209
11210 static bfd_boolean
11211 check_pasted_section (struct bfd_link_info *info, const char *name)
11212 {
11213 asection *o = bfd_get_section_by_name (info->output_bfd, name);
11214
11215 if (o != NULL)
11216 {
11217 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11218 bfd_vma toc_off = 0;
11219 asection *i;
11220
11221 for (i = o->map_head.s; i != NULL; i = i->map_head.s)
11222 if (i->has_toc_reloc)
11223 {
11224 if (toc_off == 0)
11225 toc_off = htab->stub_group[i->id].toc_off;
11226 else if (toc_off != htab->stub_group[i->id].toc_off)
11227 return FALSE;
11228 }
11229
11230 if (toc_off == 0)
11231 for (i = o->map_head.s; i != NULL; i = i->map_head.s)
11232 if (i->makes_toc_func_call)
11233 {
11234 toc_off = htab->stub_group[i->id].toc_off;
11235 break;
11236 }
11237
11238 /* Make sure the whole pasted function uses the same toc offset. */
11239 if (toc_off != 0)
11240 for (i = o->map_head.s; i != NULL; i = i->map_head.s)
11241 htab->stub_group[i->id].toc_off = toc_off;
11242 }
11243 return TRUE;
11244 }
11245
11246 bfd_boolean
11247 ppc64_elf_check_init_fini (struct bfd_link_info *info)
11248 {
11249 return (check_pasted_section (info, ".init")
11250 & check_pasted_section (info, ".fini"));
11251 }
11252
11253 /* See whether we can group stub sections together. Grouping stub
11254 sections may result in fewer stubs. More importantly, we need to
11255 put all .init* and .fini* stubs at the beginning of the .init or
11256 .fini output sections respectively, because glibc splits the
11257 _init and _fini functions into multiple parts. Putting a stub in
11258 the middle of a function is not a good idea. */
11259
11260 static void
11261 group_sections (struct ppc_link_hash_table *htab,
11262 bfd_size_type stub_group_size,
11263 bfd_boolean stubs_always_before_branch)
11264 {
11265 asection **list;
11266 bfd_size_type stub14_group_size;
11267 bfd_boolean suppress_size_errors;
11268
11269 suppress_size_errors = FALSE;
11270 stub14_group_size = stub_group_size;
11271 if (stub_group_size == 1)
11272 {
11273 /* Default values. */
11274 if (stubs_always_before_branch)
11275 {
11276 stub_group_size = 0x1e00000;
11277 stub14_group_size = 0x7800;
11278 }
11279 else
11280 {
11281 stub_group_size = 0x1c00000;
11282 stub14_group_size = 0x7000;
11283 }
11284 suppress_size_errors = TRUE;
11285 }
11286
11287 list = htab->input_list + htab->top_index;
11288 do
11289 {
11290 asection *tail = *list;
11291 while (tail != NULL)
11292 {
11293 asection *curr;
11294 asection *prev;
11295 bfd_size_type total;
11296 bfd_boolean big_sec;
11297 bfd_vma curr_toc;
11298
11299 curr = tail;
11300 total = tail->size;
11301 big_sec = total > (ppc64_elf_section_data (tail) != NULL
11302 && ppc64_elf_section_data (tail)->has_14bit_branch
11303 ? stub14_group_size : stub_group_size);
11304 if (big_sec && !suppress_size_errors)
11305 (*_bfd_error_handler) (_("%B section %A exceeds stub group size"),
11306 tail->owner, tail);
11307 curr_toc = htab->stub_group[tail->id].toc_off;
11308
11309 while ((prev = PREV_SEC (curr)) != NULL
11310 && ((total += curr->output_offset - prev->output_offset)
11311 < (ppc64_elf_section_data (prev) != NULL
11312 && ppc64_elf_section_data (prev)->has_14bit_branch
11313 ? stub14_group_size : stub_group_size))
11314 && htab->stub_group[prev->id].toc_off == curr_toc)
11315 curr = prev;
11316
11317 /* OK, the size from the start of CURR to the end is less
11318 than stub_group_size and thus can be handled by one stub
11319 section. (or the tail section is itself larger than
11320 stub_group_size, in which case we may be toast.) We
11321 should really be keeping track of the total size of stubs
11322 added here, as stubs contribute to the final output
11323 section size. That's a little tricky, and this way will
11324 only break if stubs added make the total size more than
11325 2^25, ie. for the default stub_group_size, if stubs total
11326 more than 2097152 bytes, or nearly 75000 plt call stubs. */
11327 do
11328 {
11329 prev = PREV_SEC (tail);
11330 /* Set up this stub group. */
11331 htab->stub_group[tail->id].link_sec = curr;
11332 }
11333 while (tail != curr && (tail = prev) != NULL);
11334
11335 /* But wait, there's more! Input sections up to stub_group_size
11336 bytes before the stub section can be handled by it too.
11337 Don't do this if we have a really large section after the
11338 stubs, as adding more stubs increases the chance that
11339 branches may not reach into the stub section. */
11340 if (!stubs_always_before_branch && !big_sec)
11341 {
11342 total = 0;
11343 while (prev != NULL
11344 && ((total += tail->output_offset - prev->output_offset)
11345 < (ppc64_elf_section_data (prev) != NULL
11346 && ppc64_elf_section_data (prev)->has_14bit_branch
11347 ? stub14_group_size : stub_group_size))
11348 && htab->stub_group[prev->id].toc_off == curr_toc)
11349 {
11350 tail = prev;
11351 prev = PREV_SEC (tail);
11352 htab->stub_group[tail->id].link_sec = curr;
11353 }
11354 }
11355 tail = prev;
11356 }
11357 }
11358 while (list-- != htab->input_list);
11359 free (htab->input_list);
11360 #undef PREV_SEC
11361 }
11362
11363 static const unsigned char glink_eh_frame_cie[] =
11364 {
11365 0, 0, 0, 16, /* length. */
11366 0, 0, 0, 0, /* id. */
11367 1, /* CIE version. */
11368 'z', 'R', 0, /* Augmentation string. */
11369 4, /* Code alignment. */
11370 0x78, /* Data alignment. */
11371 65, /* RA reg. */
11372 1, /* Augmentation size. */
11373 DW_EH_PE_pcrel | DW_EH_PE_sdata4, /* FDE encoding. */
11374 DW_CFA_def_cfa, 1, 0 /* def_cfa: r1 offset 0. */
11375 };
11376
11377 /* Stripping output sections is normally done before dynamic section
11378 symbols have been allocated. This function is called later, and
11379 handles cases like htab->brlt which is mapped to its own output
11380 section. */
11381
11382 static void
11383 maybe_strip_output (struct bfd_link_info *info, asection *isec)
11384 {
11385 if (isec->size == 0
11386 && isec->output_section->size == 0
11387 && !(isec->output_section->flags & SEC_KEEP)
11388 && !bfd_section_removed_from_list (info->output_bfd,
11389 isec->output_section)
11390 && elf_section_data (isec->output_section)->dynindx == 0)
11391 {
11392 isec->output_section->flags |= SEC_EXCLUDE;
11393 bfd_section_list_remove (info->output_bfd, isec->output_section);
11394 info->output_bfd->section_count--;
11395 }
11396 }
11397
11398 /* Determine and set the size of the stub section for a final link.
11399
11400 The basic idea here is to examine all the relocations looking for
11401 PC-relative calls to a target that is unreachable with a "bl"
11402 instruction. */
11403
11404 bfd_boolean
11405 ppc64_elf_size_stubs (struct bfd_link_info *info, bfd_signed_vma group_size,
11406 bfd_boolean plt_static_chain, int plt_thread_safe,
11407 int plt_stub_align)
11408 {
11409 bfd_size_type stub_group_size;
11410 bfd_boolean stubs_always_before_branch;
11411 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11412
11413 if (htab == NULL)
11414 return FALSE;
11415
11416 htab->plt_static_chain = plt_static_chain;
11417 htab->plt_stub_align = plt_stub_align;
11418 if (plt_thread_safe == -1 && !info->executable)
11419 plt_thread_safe = 1;
11420 if (plt_thread_safe == -1)
11421 {
11422 static const char *const thread_starter[] =
11423 {
11424 "pthread_create",
11425 /* libstdc++ */
11426 "_ZNSt6thread15_M_start_threadESt10shared_ptrINS_10_Impl_baseEE",
11427 /* librt */
11428 "aio_init", "aio_read", "aio_write", "aio_fsync", "lio_listio",
11429 "mq_notify", "create_timer",
11430 /* libanl */
11431 "getaddrinfo_a",
11432 /* libgomp */
11433 "GOMP_parallel_start",
11434 "GOMP_parallel_loop_static_start",
11435 "GOMP_parallel_loop_dynamic_start",
11436 "GOMP_parallel_loop_guided_start",
11437 "GOMP_parallel_loop_runtime_start",
11438 "GOMP_parallel_sections_start",
11439 };
11440 unsigned i;
11441
11442 for (i = 0; i < sizeof (thread_starter)/ sizeof (thread_starter[0]); i++)
11443 {
11444 struct elf_link_hash_entry *h;
11445 h = elf_link_hash_lookup (&htab->elf, thread_starter[i],
11446 FALSE, FALSE, TRUE);
11447 plt_thread_safe = h != NULL && h->ref_regular;
11448 if (plt_thread_safe)
11449 break;
11450 }
11451 }
11452 htab->plt_thread_safe = plt_thread_safe;
11453 htab->dot_toc_dot = ((struct ppc_link_hash_entry *)
11454 elf_link_hash_lookup (&htab->elf, ".TOC.",
11455 FALSE, FALSE, TRUE));
11456 stubs_always_before_branch = group_size < 0;
11457 if (group_size < 0)
11458 stub_group_size = -group_size;
11459 else
11460 stub_group_size = group_size;
11461
11462 group_sections (htab, stub_group_size, stubs_always_before_branch);
11463
11464 while (1)
11465 {
11466 bfd *input_bfd;
11467 unsigned int bfd_indx;
11468 asection *stub_sec;
11469
11470 htab->stub_iteration += 1;
11471
11472 for (input_bfd = info->input_bfds, bfd_indx = 0;
11473 input_bfd != NULL;
11474 input_bfd = input_bfd->link_next, bfd_indx++)
11475 {
11476 Elf_Internal_Shdr *symtab_hdr;
11477 asection *section;
11478 Elf_Internal_Sym *local_syms = NULL;
11479
11480 if (!is_ppc64_elf (input_bfd))
11481 continue;
11482
11483 /* We'll need the symbol table in a second. */
11484 symtab_hdr = &elf_symtab_hdr (input_bfd);
11485 if (symtab_hdr->sh_info == 0)
11486 continue;
11487
11488 /* Walk over each section attached to the input bfd. */
11489 for (section = input_bfd->sections;
11490 section != NULL;
11491 section = section->next)
11492 {
11493 Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
11494
11495 /* If there aren't any relocs, then there's nothing more
11496 to do. */
11497 if ((section->flags & SEC_RELOC) == 0
11498 || (section->flags & SEC_ALLOC) == 0
11499 || (section->flags & SEC_LOAD) == 0
11500 || (section->flags & SEC_CODE) == 0
11501 || section->reloc_count == 0)
11502 continue;
11503
11504 /* If this section is a link-once section that will be
11505 discarded, then don't create any stubs. */
11506 if (section->output_section == NULL
11507 || section->output_section->owner != info->output_bfd)
11508 continue;
11509
11510 /* Get the relocs. */
11511 internal_relocs
11512 = _bfd_elf_link_read_relocs (input_bfd, section, NULL, NULL,
11513 info->keep_memory);
11514 if (internal_relocs == NULL)
11515 goto error_ret_free_local;
11516
11517 /* Now examine each relocation. */
11518 irela = internal_relocs;
11519 irelaend = irela + section->reloc_count;
11520 for (; irela < irelaend; irela++)
11521 {
11522 enum elf_ppc64_reloc_type r_type;
11523 unsigned int r_indx;
11524 enum ppc_stub_type stub_type;
11525 struct ppc_stub_hash_entry *stub_entry;
11526 asection *sym_sec, *code_sec;
11527 bfd_vma sym_value, code_value;
11528 bfd_vma destination;
11529 bfd_boolean ok_dest;
11530 struct ppc_link_hash_entry *hash;
11531 struct ppc_link_hash_entry *fdh;
11532 struct elf_link_hash_entry *h;
11533 Elf_Internal_Sym *sym;
11534 char *stub_name;
11535 const asection *id_sec;
11536 struct _opd_sec_data *opd;
11537 struct plt_entry *plt_ent;
11538
11539 r_type = ELF64_R_TYPE (irela->r_info);
11540 r_indx = ELF64_R_SYM (irela->r_info);
11541
11542 if (r_type >= R_PPC64_max)
11543 {
11544 bfd_set_error (bfd_error_bad_value);
11545 goto error_ret_free_internal;
11546 }
11547
11548 /* Only look for stubs on branch instructions. */
11549 if (r_type != R_PPC64_REL24
11550 && r_type != R_PPC64_REL14
11551 && r_type != R_PPC64_REL14_BRTAKEN
11552 && r_type != R_PPC64_REL14_BRNTAKEN)
11553 continue;
11554
11555 /* Now determine the call target, its name, value,
11556 section. */
11557 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
11558 r_indx, input_bfd))
11559 goto error_ret_free_internal;
11560 hash = (struct ppc_link_hash_entry *) h;
11561
11562 ok_dest = FALSE;
11563 fdh = NULL;
11564 sym_value = 0;
11565 if (hash == NULL)
11566 {
11567 sym_value = sym->st_value;
11568 ok_dest = TRUE;
11569 }
11570 else if (hash->elf.root.type == bfd_link_hash_defined
11571 || hash->elf.root.type == bfd_link_hash_defweak)
11572 {
11573 sym_value = hash->elf.root.u.def.value;
11574 if (sym_sec->output_section != NULL)
11575 ok_dest = TRUE;
11576 }
11577 else if (hash->elf.root.type == bfd_link_hash_undefweak
11578 || hash->elf.root.type == bfd_link_hash_undefined)
11579 {
11580 /* Recognise an old ABI func code entry sym, and
11581 use the func descriptor sym instead if it is
11582 defined. */
11583 if (hash->elf.root.root.string[0] == '.'
11584 && (fdh = lookup_fdh (hash, htab)) != NULL)
11585 {
11586 if (fdh->elf.root.type == bfd_link_hash_defined
11587 || fdh->elf.root.type == bfd_link_hash_defweak)
11588 {
11589 sym_sec = fdh->elf.root.u.def.section;
11590 sym_value = fdh->elf.root.u.def.value;
11591 if (sym_sec->output_section != NULL)
11592 ok_dest = TRUE;
11593 }
11594 else
11595 fdh = NULL;
11596 }
11597 }
11598 else
11599 {
11600 bfd_set_error (bfd_error_bad_value);
11601 goto error_ret_free_internal;
11602 }
11603
11604 destination = 0;
11605 if (ok_dest)
11606 {
11607 sym_value += irela->r_addend;
11608 destination = (sym_value
11609 + sym_sec->output_offset
11610 + sym_sec->output_section->vma);
11611 }
11612
11613 code_sec = sym_sec;
11614 code_value = sym_value;
11615 opd = get_opd_info (sym_sec);
11616 if (opd != NULL)
11617 {
11618 bfd_vma dest;
11619
11620 if (hash == NULL && opd->adjust != NULL)
11621 {
11622 long adjust = opd->adjust[sym_value / 8];
11623 if (adjust == -1)
11624 continue;
11625 code_value += adjust;
11626 sym_value += adjust;
11627 }
11628 dest = opd_entry_value (sym_sec, sym_value,
11629 &code_sec, &code_value, FALSE);
11630 if (dest != (bfd_vma) -1)
11631 {
11632 destination = dest;
11633 if (fdh != NULL)
11634 {
11635 /* Fixup old ABI sym to point at code
11636 entry. */
11637 hash->elf.root.type = bfd_link_hash_defweak;
11638 hash->elf.root.u.def.section = code_sec;
11639 hash->elf.root.u.def.value = code_value;
11640 }
11641 }
11642 }
11643
11644 /* Determine what (if any) linker stub is needed. */
11645 plt_ent = NULL;
11646 stub_type = ppc_type_of_stub (section, irela, &hash,
11647 &plt_ent, destination);
11648
11649 if (stub_type != ppc_stub_plt_call)
11650 {
11651 /* Check whether we need a TOC adjusting stub.
11652 Since the linker pastes together pieces from
11653 different object files when creating the
11654 _init and _fini functions, it may be that a
11655 call to what looks like a local sym is in
11656 fact a call needing a TOC adjustment. */
11657 if (code_sec != NULL
11658 && code_sec->output_section != NULL
11659 && (htab->stub_group[code_sec->id].toc_off
11660 != htab->stub_group[section->id].toc_off)
11661 && (code_sec->has_toc_reloc
11662 || code_sec->makes_toc_func_call))
11663 stub_type = ppc_stub_long_branch_r2off;
11664 }
11665
11666 if (stub_type == ppc_stub_none)
11667 continue;
11668
11669 /* __tls_get_addr calls might be eliminated. */
11670 if (stub_type != ppc_stub_plt_call
11671 && hash != NULL
11672 && (hash == htab->tls_get_addr
11673 || hash == htab->tls_get_addr_fd)
11674 && section->has_tls_reloc
11675 && irela != internal_relocs)
11676 {
11677 /* Get tls info. */
11678 unsigned char *tls_mask;
11679
11680 if (!get_tls_mask (&tls_mask, NULL, NULL, &local_syms,
11681 irela - 1, input_bfd))
11682 goto error_ret_free_internal;
11683 if (*tls_mask != 0)
11684 continue;
11685 }
11686
11687 if (stub_type == ppc_stub_plt_call
11688 && irela + 1 < irelaend
11689 && irela[1].r_offset == irela->r_offset + 4
11690 && ELF64_R_TYPE (irela[1].r_info) == R_PPC64_TOCSAVE)
11691 {
11692 if (!tocsave_find (htab, INSERT,
11693 &local_syms, irela + 1, input_bfd))
11694 goto error_ret_free_internal;
11695 }
11696 else if (stub_type == ppc_stub_plt_call)
11697 stub_type = ppc_stub_plt_call_r2save;
11698
11699 /* Support for grouping stub sections. */
11700 id_sec = htab->stub_group[section->id].link_sec;
11701
11702 /* Get the name of this stub. */
11703 stub_name = ppc_stub_name (id_sec, sym_sec, hash, irela);
11704 if (!stub_name)
11705 goto error_ret_free_internal;
11706
11707 stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
11708 stub_name, FALSE, FALSE);
11709 if (stub_entry != NULL)
11710 {
11711 /* The proper stub has already been created. */
11712 free (stub_name);
11713 if (stub_type == ppc_stub_plt_call_r2save)
11714 stub_entry->stub_type = stub_type;
11715 continue;
11716 }
11717
11718 stub_entry = ppc_add_stub (stub_name, section, info);
11719 if (stub_entry == NULL)
11720 {
11721 free (stub_name);
11722 error_ret_free_internal:
11723 if (elf_section_data (section)->relocs == NULL)
11724 free (internal_relocs);
11725 error_ret_free_local:
11726 if (local_syms != NULL
11727 && (symtab_hdr->contents
11728 != (unsigned char *) local_syms))
11729 free (local_syms);
11730 return FALSE;
11731 }
11732
11733 stub_entry->stub_type = stub_type;
11734 if (stub_type != ppc_stub_plt_call
11735 && stub_type != ppc_stub_plt_call_r2save)
11736 {
11737 stub_entry->target_value = code_value;
11738 stub_entry->target_section = code_sec;
11739 }
11740 else
11741 {
11742 stub_entry->target_value = sym_value;
11743 stub_entry->target_section = sym_sec;
11744 }
11745 stub_entry->h = hash;
11746 stub_entry->plt_ent = plt_ent;
11747 stub_entry->addend = irela->r_addend;
11748
11749 if (stub_entry->h != NULL)
11750 htab->stub_globals += 1;
11751 }
11752
11753 /* We're done with the internal relocs, free them. */
11754 if (elf_section_data (section)->relocs != internal_relocs)
11755 free (internal_relocs);
11756 }
11757
11758 if (local_syms != NULL
11759 && symtab_hdr->contents != (unsigned char *) local_syms)
11760 {
11761 if (!info->keep_memory)
11762 free (local_syms);
11763 else
11764 symtab_hdr->contents = (unsigned char *) local_syms;
11765 }
11766 }
11767
11768 /* We may have added some stubs. Find out the new size of the
11769 stub sections. */
11770 for (stub_sec = htab->stub_bfd->sections;
11771 stub_sec != NULL;
11772 stub_sec = stub_sec->next)
11773 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
11774 {
11775 stub_sec->rawsize = stub_sec->size;
11776 stub_sec->size = 0;
11777 stub_sec->reloc_count = 0;
11778 stub_sec->flags &= ~SEC_RELOC;
11779 }
11780
11781 htab->brlt->size = 0;
11782 htab->brlt->reloc_count = 0;
11783 htab->brlt->flags &= ~SEC_RELOC;
11784 if (htab->relbrlt != NULL)
11785 htab->relbrlt->size = 0;
11786
11787 bfd_hash_traverse (&htab->stub_hash_table, ppc_size_one_stub, info);
11788
11789 if (info->emitrelocations
11790 && htab->glink != NULL && htab->glink->size != 0)
11791 {
11792 htab->glink->reloc_count = 1;
11793 htab->glink->flags |= SEC_RELOC;
11794 }
11795
11796 if (htab->glink_eh_frame != NULL
11797 && !bfd_is_abs_section (htab->glink_eh_frame->output_section)
11798 && htab->glink_eh_frame->output_section->size != 0)
11799 {
11800 size_t size = 0, align;
11801
11802 for (stub_sec = htab->stub_bfd->sections;
11803 stub_sec != NULL;
11804 stub_sec = stub_sec->next)
11805 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
11806 size += 20;
11807 if (htab->glink != NULL && htab->glink->size != 0)
11808 size += 24;
11809 if (size != 0)
11810 size += sizeof (glink_eh_frame_cie);
11811 align = 1;
11812 align <<= htab->glink_eh_frame->output_section->alignment_power;
11813 align -= 1;
11814 size = (size + align) & ~align;
11815 htab->glink_eh_frame->rawsize = htab->glink_eh_frame->size;
11816 htab->glink_eh_frame->size = size;
11817 }
11818
11819 if (htab->plt_stub_align != 0)
11820 for (stub_sec = htab->stub_bfd->sections;
11821 stub_sec != NULL;
11822 stub_sec = stub_sec->next)
11823 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
11824 stub_sec->size = ((stub_sec->size + (1 << htab->plt_stub_align) - 1)
11825 & (-1 << htab->plt_stub_align));
11826
11827 for (stub_sec = htab->stub_bfd->sections;
11828 stub_sec != NULL;
11829 stub_sec = stub_sec->next)
11830 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
11831 && stub_sec->rawsize != stub_sec->size)
11832 break;
11833
11834 /* Exit from this loop when no stubs have been added, and no stubs
11835 have changed size. */
11836 if (stub_sec == NULL
11837 && (htab->glink_eh_frame == NULL
11838 || htab->glink_eh_frame->rawsize == htab->glink_eh_frame->size))
11839 break;
11840
11841 /* Ask the linker to do its stuff. */
11842 (*htab->layout_sections_again) ();
11843 }
11844
11845 maybe_strip_output (info, htab->brlt);
11846 if (htab->glink_eh_frame != NULL)
11847 maybe_strip_output (info, htab->glink_eh_frame);
11848
11849 return TRUE;
11850 }
11851
11852 /* Called after we have determined section placement. If sections
11853 move, we'll be called again. Provide a value for TOCstart. */
11854
11855 bfd_vma
11856 ppc64_elf_toc (bfd *obfd)
11857 {
11858 asection *s;
11859 bfd_vma TOCstart;
11860
11861 /* The TOC consists of sections .got, .toc, .tocbss, .plt in that
11862 order. The TOC starts where the first of these sections starts. */
11863 s = bfd_get_section_by_name (obfd, ".got");
11864 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
11865 s = bfd_get_section_by_name (obfd, ".toc");
11866 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
11867 s = bfd_get_section_by_name (obfd, ".tocbss");
11868 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
11869 s = bfd_get_section_by_name (obfd, ".plt");
11870 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
11871 {
11872 /* This may happen for
11873 o references to TOC base (SYM@toc / TOC[tc0]) without a
11874 .toc directive
11875 o bad linker script
11876 o --gc-sections and empty TOC sections
11877
11878 FIXME: Warn user? */
11879
11880 /* Look for a likely section. We probably won't even be
11881 using TOCstart. */
11882 for (s = obfd->sections; s != NULL; s = s->next)
11883 if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_READONLY
11884 | SEC_EXCLUDE))
11885 == (SEC_ALLOC | SEC_SMALL_DATA))
11886 break;
11887 if (s == NULL)
11888 for (s = obfd->sections; s != NULL; s = s->next)
11889 if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_EXCLUDE))
11890 == (SEC_ALLOC | SEC_SMALL_DATA))
11891 break;
11892 if (s == NULL)
11893 for (s = obfd->sections; s != NULL; s = s->next)
11894 if ((s->flags & (SEC_ALLOC | SEC_READONLY | SEC_EXCLUDE))
11895 == SEC_ALLOC)
11896 break;
11897 if (s == NULL)
11898 for (s = obfd->sections; s != NULL; s = s->next)
11899 if ((s->flags & (SEC_ALLOC | SEC_EXCLUDE)) == SEC_ALLOC)
11900 break;
11901 }
11902
11903 TOCstart = 0;
11904 if (s != NULL)
11905 TOCstart = s->output_section->vma + s->output_offset;
11906
11907 return TOCstart;
11908 }
11909
11910 /* Build all the stubs associated with the current output file.
11911 The stubs are kept in a hash table attached to the main linker
11912 hash table. This function is called via gldelf64ppc_finish. */
11913
11914 bfd_boolean
11915 ppc64_elf_build_stubs (bfd_boolean emit_stub_syms,
11916 struct bfd_link_info *info,
11917 char **stats)
11918 {
11919 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11920 asection *stub_sec;
11921 bfd_byte *p;
11922 int stub_sec_count = 0;
11923
11924 if (htab == NULL)
11925 return FALSE;
11926
11927 htab->emit_stub_syms = emit_stub_syms;
11928
11929 /* Allocate memory to hold the linker stubs. */
11930 for (stub_sec = htab->stub_bfd->sections;
11931 stub_sec != NULL;
11932 stub_sec = stub_sec->next)
11933 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
11934 && stub_sec->size != 0)
11935 {
11936 stub_sec->contents = bfd_zalloc (htab->stub_bfd, stub_sec->size);
11937 if (stub_sec->contents == NULL)
11938 return FALSE;
11939 /* We want to check that built size is the same as calculated
11940 size. rawsize is a convenient location to use. */
11941 stub_sec->rawsize = stub_sec->size;
11942 stub_sec->size = 0;
11943 }
11944
11945 if (htab->glink != NULL && htab->glink->size != 0)
11946 {
11947 unsigned int indx;
11948 bfd_vma plt0;
11949
11950 /* Build the .glink plt call stub. */
11951 if (htab->emit_stub_syms)
11952 {
11953 struct elf_link_hash_entry *h;
11954 h = elf_link_hash_lookup (&htab->elf, "__glink_PLTresolve",
11955 TRUE, FALSE, FALSE);
11956 if (h == NULL)
11957 return FALSE;
11958 if (h->root.type == bfd_link_hash_new)
11959 {
11960 h->root.type = bfd_link_hash_defined;
11961 h->root.u.def.section = htab->glink;
11962 h->root.u.def.value = 8;
11963 h->ref_regular = 1;
11964 h->def_regular = 1;
11965 h->ref_regular_nonweak = 1;
11966 h->forced_local = 1;
11967 h->non_elf = 0;
11968 }
11969 }
11970 plt0 = htab->plt->output_section->vma + htab->plt->output_offset - 16;
11971 if (info->emitrelocations)
11972 {
11973 Elf_Internal_Rela *r = get_relocs (htab->glink, 1);
11974 if (r == NULL)
11975 return FALSE;
11976 r->r_offset = (htab->glink->output_offset
11977 + htab->glink->output_section->vma);
11978 r->r_info = ELF64_R_INFO (0, R_PPC64_REL64);
11979 r->r_addend = plt0;
11980 }
11981 p = htab->glink->contents;
11982 plt0 -= htab->glink->output_section->vma + htab->glink->output_offset;
11983 bfd_put_64 (htab->glink->owner, plt0, p);
11984 p += 8;
11985 bfd_put_32 (htab->glink->owner, MFLR_R12, p);
11986 p += 4;
11987 bfd_put_32 (htab->glink->owner, BCL_20_31, p);
11988 p += 4;
11989 bfd_put_32 (htab->glink->owner, MFLR_R11, p);
11990 p += 4;
11991 bfd_put_32 (htab->glink->owner, LD_R2_M16R11, p);
11992 p += 4;
11993 bfd_put_32 (htab->glink->owner, MTLR_R12, p);
11994 p += 4;
11995 bfd_put_32 (htab->glink->owner, ADD_R12_R2_R11, p);
11996 p += 4;
11997 bfd_put_32 (htab->glink->owner, LD_R11_0R12, p);
11998 p += 4;
11999 bfd_put_32 (htab->glink->owner, LD_R2_0R12 | 8, p);
12000 p += 4;
12001 bfd_put_32 (htab->glink->owner, MTCTR_R11, p);
12002 p += 4;
12003 bfd_put_32 (htab->glink->owner, LD_R11_0R12 | 16, p);
12004 p += 4;
12005 bfd_put_32 (htab->glink->owner, BCTR, p);
12006 p += 4;
12007 while (p - htab->glink->contents < GLINK_CALL_STUB_SIZE)
12008 {
12009 bfd_put_32 (htab->glink->owner, NOP, p);
12010 p += 4;
12011 }
12012
12013 /* Build the .glink lazy link call stubs. */
12014 indx = 0;
12015 while (p < htab->glink->contents + htab->glink->size)
12016 {
12017 if (indx < 0x8000)
12018 {
12019 bfd_put_32 (htab->glink->owner, LI_R0_0 | indx, p);
12020 p += 4;
12021 }
12022 else
12023 {
12024 bfd_put_32 (htab->glink->owner, LIS_R0_0 | PPC_HI (indx), p);
12025 p += 4;
12026 bfd_put_32 (htab->glink->owner, ORI_R0_R0_0 | PPC_LO (indx), p);
12027 p += 4;
12028 }
12029 bfd_put_32 (htab->glink->owner,
12030 B_DOT | ((htab->glink->contents - p + 8) & 0x3fffffc), p);
12031 indx++;
12032 p += 4;
12033 }
12034 htab->glink->rawsize = p - htab->glink->contents;
12035 }
12036
12037 if (htab->brlt->size != 0)
12038 {
12039 htab->brlt->contents = bfd_zalloc (htab->brlt->owner,
12040 htab->brlt->size);
12041 if (htab->brlt->contents == NULL)
12042 return FALSE;
12043 }
12044 if (htab->relbrlt != NULL && htab->relbrlt->size != 0)
12045 {
12046 htab->relbrlt->contents = bfd_zalloc (htab->relbrlt->owner,
12047 htab->relbrlt->size);
12048 if (htab->relbrlt->contents == NULL)
12049 return FALSE;
12050 }
12051
12052 if (htab->glink_eh_frame != NULL
12053 && htab->glink_eh_frame->size != 0)
12054 {
12055 bfd_vma val;
12056 bfd_byte *last_fde;
12057 size_t last_fde_len, size, align, pad;
12058
12059 p = bfd_zalloc (htab->glink_eh_frame->owner, htab->glink_eh_frame->size);
12060 if (p == NULL)
12061 return FALSE;
12062 htab->glink_eh_frame->contents = p;
12063 last_fde = p;
12064
12065 htab->glink_eh_frame->rawsize = htab->glink_eh_frame->size;
12066
12067 memcpy (p, glink_eh_frame_cie, sizeof (glink_eh_frame_cie));
12068 /* CIE length (rewrite in case little-endian). */
12069 last_fde_len = sizeof (glink_eh_frame_cie) - 4;
12070 bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
12071 p += sizeof (glink_eh_frame_cie);
12072
12073 for (stub_sec = htab->stub_bfd->sections;
12074 stub_sec != NULL;
12075 stub_sec = stub_sec->next)
12076 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12077 {
12078 last_fde = p;
12079 last_fde_len = 16;
12080 /* FDE length. */
12081 bfd_put_32 (htab->elf.dynobj, 16, p);
12082 p += 4;
12083 /* CIE pointer. */
12084 val = p - htab->glink_eh_frame->contents;
12085 bfd_put_32 (htab->elf.dynobj, val, p);
12086 p += 4;
12087 /* Offset to stub section. */
12088 val = (stub_sec->output_section->vma
12089 + stub_sec->output_offset);
12090 val -= (htab->glink_eh_frame->output_section->vma
12091 + htab->glink_eh_frame->output_offset);
12092 val -= p - htab->glink_eh_frame->contents;
12093 if (val + 0x80000000 > 0xffffffff)
12094 {
12095 info->callbacks->einfo
12096 (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
12097 stub_sec->name);
12098 return FALSE;
12099 }
12100 bfd_put_32 (htab->elf.dynobj, val, p);
12101 p += 4;
12102 /* stub section size. */
12103 bfd_put_32 (htab->elf.dynobj, stub_sec->rawsize, p);
12104 p += 4;
12105 /* Augmentation. */
12106 p += 1;
12107 /* Pad. */
12108 p += 3;
12109 }
12110 if (htab->glink != NULL && htab->glink->size != 0)
12111 {
12112 last_fde = p;
12113 last_fde_len = 20;
12114 /* FDE length. */
12115 bfd_put_32 (htab->elf.dynobj, 20, p);
12116 p += 4;
12117 /* CIE pointer. */
12118 val = p - htab->glink_eh_frame->contents;
12119 bfd_put_32 (htab->elf.dynobj, val, p);
12120 p += 4;
12121 /* Offset to .glink. */
12122 val = (htab->glink->output_section->vma
12123 + htab->glink->output_offset
12124 + 8);
12125 val -= (htab->glink_eh_frame->output_section->vma
12126 + htab->glink_eh_frame->output_offset);
12127 val -= p - htab->glink_eh_frame->contents;
12128 if (val + 0x80000000 > 0xffffffff)
12129 {
12130 info->callbacks->einfo
12131 (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
12132 htab->glink->name);
12133 return FALSE;
12134 }
12135 bfd_put_32 (htab->elf.dynobj, val, p);
12136 p += 4;
12137 /* .glink size. */
12138 bfd_put_32 (htab->elf.dynobj, htab->glink->rawsize - 8, p);
12139 p += 4;
12140 /* Augmentation. */
12141 p += 1;
12142
12143 *p++ = DW_CFA_advance_loc + 1;
12144 *p++ = DW_CFA_register;
12145 *p++ = 65;
12146 *p++ = 12;
12147 *p++ = DW_CFA_advance_loc + 4;
12148 *p++ = DW_CFA_restore_extended;
12149 *p++ = 65;
12150 }
12151 /* Subsume any padding into the last FDE if user .eh_frame
12152 sections are aligned more than glink_eh_frame. Otherwise any
12153 zero padding will be seen as a terminator. */
12154 size = p - htab->glink_eh_frame->contents;
12155 align = 1;
12156 align <<= htab->glink_eh_frame->output_section->alignment_power;
12157 align -= 1;
12158 pad = ((size + align) & ~align) - size;
12159 htab->glink_eh_frame->size = size + pad;
12160 bfd_put_32 (htab->elf.dynobj, last_fde_len + pad, last_fde);
12161 }
12162
12163 /* Build the stubs as directed by the stub hash table. */
12164 bfd_hash_traverse (&htab->stub_hash_table, ppc_build_one_stub, info);
12165
12166 if (htab->relbrlt != NULL)
12167 htab->relbrlt->reloc_count = 0;
12168
12169 if (htab->plt_stub_align != 0)
12170 for (stub_sec = htab->stub_bfd->sections;
12171 stub_sec != NULL;
12172 stub_sec = stub_sec->next)
12173 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12174 stub_sec->size = ((stub_sec->size + (1 << htab->plt_stub_align) - 1)
12175 & (-1 << htab->plt_stub_align));
12176
12177 for (stub_sec = htab->stub_bfd->sections;
12178 stub_sec != NULL;
12179 stub_sec = stub_sec->next)
12180 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12181 {
12182 stub_sec_count += 1;
12183 if (stub_sec->rawsize != stub_sec->size)
12184 break;
12185 }
12186
12187 if (stub_sec != NULL
12188 || htab->glink->rawsize != htab->glink->size
12189 || (htab->glink_eh_frame != NULL
12190 && htab->glink_eh_frame->rawsize != htab->glink_eh_frame->size))
12191 {
12192 htab->stub_error = TRUE;
12193 info->callbacks->einfo (_("%P: stubs don't match calculated size\n"));
12194 }
12195
12196 if (htab->stub_error)
12197 return FALSE;
12198
12199 if (stats != NULL)
12200 {
12201 *stats = bfd_malloc (500);
12202 if (*stats == NULL)
12203 return FALSE;
12204
12205 sprintf (*stats, _("linker stubs in %u group%s\n"
12206 " branch %lu\n"
12207 " toc adjust %lu\n"
12208 " long branch %lu\n"
12209 " long toc adj %lu\n"
12210 " plt call %lu\n"
12211 " plt call toc %lu"),
12212 stub_sec_count,
12213 stub_sec_count == 1 ? "" : "s",
12214 htab->stub_count[ppc_stub_long_branch - 1],
12215 htab->stub_count[ppc_stub_long_branch_r2off - 1],
12216 htab->stub_count[ppc_stub_plt_branch - 1],
12217 htab->stub_count[ppc_stub_plt_branch_r2off - 1],
12218 htab->stub_count[ppc_stub_plt_call - 1],
12219 htab->stub_count[ppc_stub_plt_call_r2save - 1]);
12220 }
12221 return TRUE;
12222 }
12223
12224 /* This function undoes the changes made by add_symbol_adjust. */
12225
12226 static bfd_boolean
12227 undo_symbol_twiddle (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
12228 {
12229 struct ppc_link_hash_entry *eh;
12230
12231 if (h->root.type == bfd_link_hash_indirect)
12232 return TRUE;
12233
12234 eh = (struct ppc_link_hash_entry *) h;
12235 if (eh->elf.root.type != bfd_link_hash_undefweak || !eh->was_undefined)
12236 return TRUE;
12237
12238 eh->elf.root.type = bfd_link_hash_undefined;
12239 return TRUE;
12240 }
12241
12242 void
12243 ppc64_elf_restore_symbols (struct bfd_link_info *info)
12244 {
12245 struct ppc_link_hash_table *htab = ppc_hash_table (info);
12246
12247 if (htab != NULL)
12248 elf_link_hash_traverse (&htab->elf, undo_symbol_twiddle, info);
12249 }
12250
12251 /* What to do when ld finds relocations against symbols defined in
12252 discarded sections. */
12253
12254 static unsigned int
12255 ppc64_elf_action_discarded (asection *sec)
12256 {
12257 if (strcmp (".opd", sec->name) == 0)
12258 return 0;
12259
12260 if (strcmp (".toc", sec->name) == 0)
12261 return 0;
12262
12263 if (strcmp (".toc1", sec->name) == 0)
12264 return 0;
12265
12266 return _bfd_elf_default_action_discarded (sec);
12267 }
12268
12269 /* The RELOCATE_SECTION function is called by the ELF backend linker
12270 to handle the relocations for a section.
12271
12272 The relocs are always passed as Rela structures; if the section
12273 actually uses Rel structures, the r_addend field will always be
12274 zero.
12275
12276 This function is responsible for adjust the section contents as
12277 necessary, and (if using Rela relocs and generating a
12278 relocatable output file) adjusting the reloc addend as
12279 necessary.
12280
12281 This function does not have to worry about setting the reloc
12282 address or the reloc symbol index.
12283
12284 LOCAL_SYMS is a pointer to the swapped in local symbols.
12285
12286 LOCAL_SECTIONS is an array giving the section in the input file
12287 corresponding to the st_shndx field of each local symbol.
12288
12289 The global hash table entry for the global symbols can be found
12290 via elf_sym_hashes (input_bfd).
12291
12292 When generating relocatable output, this function must handle
12293 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
12294 going to be the section symbol corresponding to the output
12295 section, which means that the addend must be adjusted
12296 accordingly. */
12297
12298 static bfd_boolean
12299 ppc64_elf_relocate_section (bfd *output_bfd,
12300 struct bfd_link_info *info,
12301 bfd *input_bfd,
12302 asection *input_section,
12303 bfd_byte *contents,
12304 Elf_Internal_Rela *relocs,
12305 Elf_Internal_Sym *local_syms,
12306 asection **local_sections)
12307 {
12308 struct ppc_link_hash_table *htab;
12309 Elf_Internal_Shdr *symtab_hdr;
12310 struct elf_link_hash_entry **sym_hashes;
12311 Elf_Internal_Rela *rel;
12312 Elf_Internal_Rela *relend;
12313 Elf_Internal_Rela outrel;
12314 bfd_byte *loc;
12315 struct got_entry **local_got_ents;
12316 bfd_vma TOCstart;
12317 bfd_boolean ret = TRUE;
12318 bfd_boolean is_opd;
12319 /* Assume 'at' branch hints. */
12320 bfd_boolean is_isa_v2 = TRUE;
12321 bfd_vma d_offset = (bfd_big_endian (output_bfd) ? 2 : 0);
12322
12323 /* Initialize howto table if needed. */
12324 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
12325 ppc_howto_init ();
12326
12327 htab = ppc_hash_table (info);
12328 if (htab == NULL)
12329 return FALSE;
12330
12331 /* Don't relocate stub sections. */
12332 if (input_section->owner == htab->stub_bfd)
12333 return TRUE;
12334
12335 BFD_ASSERT (is_ppc64_elf (input_bfd));
12336
12337 local_got_ents = elf_local_got_ents (input_bfd);
12338 TOCstart = elf_gp (output_bfd);
12339 symtab_hdr = &elf_symtab_hdr (input_bfd);
12340 sym_hashes = elf_sym_hashes (input_bfd);
12341 is_opd = ppc64_elf_section_data (input_section)->sec_type == sec_opd;
12342
12343 rel = relocs;
12344 relend = relocs + input_section->reloc_count;
12345 for (; rel < relend; rel++)
12346 {
12347 enum elf_ppc64_reloc_type r_type;
12348 bfd_vma addend;
12349 bfd_reloc_status_type r;
12350 Elf_Internal_Sym *sym;
12351 asection *sec;
12352 struct elf_link_hash_entry *h_elf;
12353 struct ppc_link_hash_entry *h;
12354 struct ppc_link_hash_entry *fdh;
12355 const char *sym_name;
12356 unsigned long r_symndx, toc_symndx;
12357 bfd_vma toc_addend;
12358 unsigned char tls_mask, tls_gd, tls_type;
12359 unsigned char sym_type;
12360 bfd_vma relocation;
12361 bfd_boolean unresolved_reloc;
12362 bfd_boolean warned;
12363 enum { DEST_NORMAL, DEST_OPD, DEST_STUB } reloc_dest;
12364 unsigned int insn;
12365 unsigned int mask;
12366 struct ppc_stub_hash_entry *stub_entry;
12367 bfd_vma max_br_offset;
12368 bfd_vma from;
12369 const Elf_Internal_Rela orig_rel = *rel;
12370
12371 r_type = ELF64_R_TYPE (rel->r_info);
12372 r_symndx = ELF64_R_SYM (rel->r_info);
12373
12374 /* For old style R_PPC64_TOC relocs with a zero symbol, use the
12375 symbol of the previous ADDR64 reloc. The symbol gives us the
12376 proper TOC base to use. */
12377 if (rel->r_info == ELF64_R_INFO (0, R_PPC64_TOC)
12378 && rel != relocs
12379 && ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_ADDR64
12380 && is_opd)
12381 r_symndx = ELF64_R_SYM (rel[-1].r_info);
12382
12383 sym = NULL;
12384 sec = NULL;
12385 h_elf = NULL;
12386 sym_name = NULL;
12387 unresolved_reloc = FALSE;
12388 warned = FALSE;
12389
12390 if (r_symndx < symtab_hdr->sh_info)
12391 {
12392 /* It's a local symbol. */
12393 struct _opd_sec_data *opd;
12394
12395 sym = local_syms + r_symndx;
12396 sec = local_sections[r_symndx];
12397 sym_name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym, sec);
12398 sym_type = ELF64_ST_TYPE (sym->st_info);
12399 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
12400 opd = get_opd_info (sec);
12401 if (opd != NULL && opd->adjust != NULL)
12402 {
12403 long adjust = opd->adjust[(sym->st_value + rel->r_addend) / 8];
12404 if (adjust == -1)
12405 relocation = 0;
12406 else
12407 {
12408 /* If this is a relocation against the opd section sym
12409 and we have edited .opd, adjust the reloc addend so
12410 that ld -r and ld --emit-relocs output is correct.
12411 If it is a reloc against some other .opd symbol,
12412 then the symbol value will be adjusted later. */
12413 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
12414 rel->r_addend += adjust;
12415 else
12416 relocation += adjust;
12417 }
12418 }
12419 }
12420 else
12421 {
12422 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
12423 r_symndx, symtab_hdr, sym_hashes,
12424 h_elf, sec, relocation,
12425 unresolved_reloc, warned);
12426 sym_name = h_elf->root.root.string;
12427 sym_type = h_elf->type;
12428 if (sec != NULL
12429 && sec->owner == output_bfd
12430 && strcmp (sec->name, ".opd") == 0)
12431 {
12432 /* This is a symbol defined in a linker script. All
12433 such are defined in output sections, even those
12434 defined by simple assignment from a symbol defined in
12435 an input section. Transfer the symbol to an
12436 appropriate input .opd section, so that a branch to
12437 this symbol will be mapped to the location specified
12438 by the opd entry. */
12439 struct bfd_link_order *lo;
12440 for (lo = sec->map_head.link_order; lo != NULL; lo = lo->next)
12441 if (lo->type == bfd_indirect_link_order)
12442 {
12443 asection *isec = lo->u.indirect.section;
12444 if (h_elf->root.u.def.value >= isec->output_offset
12445 && h_elf->root.u.def.value < (isec->output_offset
12446 + isec->size))
12447 {
12448 h_elf->root.u.def.value -= isec->output_offset;
12449 h_elf->root.u.def.section = isec;
12450 sec = isec;
12451 break;
12452 }
12453 }
12454 }
12455 if (h_elf == &htab->dot_toc_dot->elf)
12456 {
12457 relocation = (TOCstart
12458 + htab->stub_group[input_section->id].toc_off);
12459 sec = bfd_abs_section_ptr;
12460 unresolved_reloc = FALSE;
12461 }
12462 }
12463 h = (struct ppc_link_hash_entry *) h_elf;
12464
12465 if (sec != NULL && discarded_section (sec))
12466 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
12467 rel, 1, relend,
12468 ppc64_elf_howto_table[r_type], 0,
12469 contents);
12470
12471 if (info->relocatable)
12472 continue;
12473
12474 /* TLS optimizations. Replace instruction sequences and relocs
12475 based on information we collected in tls_optimize. We edit
12476 RELOCS so that --emit-relocs will output something sensible
12477 for the final instruction stream. */
12478 tls_mask = 0;
12479 tls_gd = 0;
12480 toc_symndx = 0;
12481 if (h != NULL)
12482 tls_mask = h->tls_mask;
12483 else if (local_got_ents != NULL)
12484 {
12485 struct plt_entry **local_plt = (struct plt_entry **)
12486 (local_got_ents + symtab_hdr->sh_info);
12487 unsigned char *lgot_masks = (unsigned char *)
12488 (local_plt + symtab_hdr->sh_info);
12489 tls_mask = lgot_masks[r_symndx];
12490 }
12491 if (tls_mask == 0
12492 && (r_type == R_PPC64_TLS
12493 || r_type == R_PPC64_TLSGD
12494 || r_type == R_PPC64_TLSLD))
12495 {
12496 /* Check for toc tls entries. */
12497 unsigned char *toc_tls;
12498
12499 if (!get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
12500 &local_syms, rel, input_bfd))
12501 return FALSE;
12502
12503 if (toc_tls)
12504 tls_mask = *toc_tls;
12505 }
12506
12507 /* Check that tls relocs are used with tls syms, and non-tls
12508 relocs are used with non-tls syms. */
12509 if (r_symndx != STN_UNDEF
12510 && r_type != R_PPC64_NONE
12511 && (h == NULL
12512 || h->elf.root.type == bfd_link_hash_defined
12513 || h->elf.root.type == bfd_link_hash_defweak)
12514 && (IS_PPC64_TLS_RELOC (r_type)
12515 != (sym_type == STT_TLS
12516 || (sym_type == STT_SECTION
12517 && (sec->flags & SEC_THREAD_LOCAL) != 0))))
12518 {
12519 if (tls_mask != 0
12520 && (r_type == R_PPC64_TLS
12521 || r_type == R_PPC64_TLSGD
12522 || r_type == R_PPC64_TLSLD))
12523 /* R_PPC64_TLS is OK against a symbol in the TOC. */
12524 ;
12525 else
12526 info->callbacks->einfo
12527 (!IS_PPC64_TLS_RELOC (r_type)
12528 ? _("%P: %H: %s used with TLS symbol `%T'\n")
12529 : _("%P: %H: %s used with non-TLS symbol `%T'\n"),
12530 input_bfd, input_section, rel->r_offset,
12531 ppc64_elf_howto_table[r_type]->name,
12532 sym_name);
12533 }
12534
12535 /* Ensure reloc mapping code below stays sane. */
12536 if (R_PPC64_TOC16_LO_DS != R_PPC64_TOC16_DS + 1
12537 || R_PPC64_TOC16_LO != R_PPC64_TOC16 + 1
12538 || (R_PPC64_GOT_TLSLD16 & 3) != (R_PPC64_GOT_TLSGD16 & 3)
12539 || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TLSGD16_LO & 3)
12540 || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TLSGD16_HI & 3)
12541 || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TLSGD16_HA & 3)
12542 || (R_PPC64_GOT_TLSLD16 & 3) != (R_PPC64_GOT_TPREL16_DS & 3)
12543 || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TPREL16_LO_DS & 3)
12544 || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TPREL16_HI & 3)
12545 || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TPREL16_HA & 3))
12546 abort ();
12547
12548 switch (r_type)
12549 {
12550 default:
12551 break;
12552
12553 case R_PPC64_LO_DS_OPT:
12554 insn = bfd_get_32 (output_bfd, contents + rel->r_offset - d_offset);
12555 if ((insn & (0x3f << 26)) != 58u << 26)
12556 abort ();
12557 insn += (14u << 26) - (58u << 26);
12558 bfd_put_32 (output_bfd, insn, contents + rel->r_offset - d_offset);
12559 r_type = R_PPC64_TOC16_LO;
12560 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
12561 break;
12562
12563 case R_PPC64_TOC16:
12564 case R_PPC64_TOC16_LO:
12565 case R_PPC64_TOC16_DS:
12566 case R_PPC64_TOC16_LO_DS:
12567 {
12568 /* Check for toc tls entries. */
12569 unsigned char *toc_tls;
12570 int retval;
12571
12572 retval = get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
12573 &local_syms, rel, input_bfd);
12574 if (retval == 0)
12575 return FALSE;
12576
12577 if (toc_tls)
12578 {
12579 tls_mask = *toc_tls;
12580 if (r_type == R_PPC64_TOC16_DS
12581 || r_type == R_PPC64_TOC16_LO_DS)
12582 {
12583 if (tls_mask != 0
12584 && (tls_mask & (TLS_DTPREL | TLS_TPREL)) == 0)
12585 goto toctprel;
12586 }
12587 else
12588 {
12589 /* If we found a GD reloc pair, then we might be
12590 doing a GD->IE transition. */
12591 if (retval == 2)
12592 {
12593 tls_gd = TLS_TPRELGD;
12594 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
12595 goto tls_ldgd_opt;
12596 }
12597 else if (retval == 3)
12598 {
12599 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
12600 goto tls_ldgd_opt;
12601 }
12602 }
12603 }
12604 }
12605 break;
12606
12607 case R_PPC64_GOT_TPREL16_HI:
12608 case R_PPC64_GOT_TPREL16_HA:
12609 if (tls_mask != 0
12610 && (tls_mask & TLS_TPREL) == 0)
12611 {
12612 rel->r_offset -= d_offset;
12613 bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
12614 r_type = R_PPC64_NONE;
12615 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
12616 }
12617 break;
12618
12619 case R_PPC64_GOT_TPREL16_DS:
12620 case R_PPC64_GOT_TPREL16_LO_DS:
12621 if (tls_mask != 0
12622 && (tls_mask & TLS_TPREL) == 0)
12623 {
12624 toctprel:
12625 insn = bfd_get_32 (output_bfd, contents + rel->r_offset - d_offset);
12626 insn &= 31 << 21;
12627 insn |= 0x3c0d0000; /* addis 0,13,0 */
12628 bfd_put_32 (output_bfd, insn, contents + rel->r_offset - d_offset);
12629 r_type = R_PPC64_TPREL16_HA;
12630 if (toc_symndx != 0)
12631 {
12632 rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
12633 rel->r_addend = toc_addend;
12634 /* We changed the symbol. Start over in order to
12635 get h, sym, sec etc. right. */
12636 rel--;
12637 continue;
12638 }
12639 else
12640 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
12641 }
12642 break;
12643
12644 case R_PPC64_TLS:
12645 if (tls_mask != 0
12646 && (tls_mask & TLS_TPREL) == 0)
12647 {
12648 insn = bfd_get_32 (output_bfd, contents + rel->r_offset);
12649 insn = _bfd_elf_ppc_at_tls_transform (insn, 13);
12650 if (insn == 0)
12651 abort ();
12652 bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
12653 /* Was PPC64_TLS which sits on insn boundary, now
12654 PPC64_TPREL16_LO which is at low-order half-word. */
12655 rel->r_offset += d_offset;
12656 r_type = R_PPC64_TPREL16_LO;
12657 if (toc_symndx != 0)
12658 {
12659 rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
12660 rel->r_addend = toc_addend;
12661 /* We changed the symbol. Start over in order to
12662 get h, sym, sec etc. right. */
12663 rel--;
12664 continue;
12665 }
12666 else
12667 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
12668 }
12669 break;
12670
12671 case R_PPC64_GOT_TLSGD16_HI:
12672 case R_PPC64_GOT_TLSGD16_HA:
12673 tls_gd = TLS_TPRELGD;
12674 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
12675 goto tls_gdld_hi;
12676 break;
12677
12678 case R_PPC64_GOT_TLSLD16_HI:
12679 case R_PPC64_GOT_TLSLD16_HA:
12680 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
12681 {
12682 tls_gdld_hi:
12683 if ((tls_mask & tls_gd) != 0)
12684 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
12685 + R_PPC64_GOT_TPREL16_DS);
12686 else
12687 {
12688 rel->r_offset -= d_offset;
12689 bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
12690 r_type = R_PPC64_NONE;
12691 }
12692 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
12693 }
12694 break;
12695
12696 case R_PPC64_GOT_TLSGD16:
12697 case R_PPC64_GOT_TLSGD16_LO:
12698 tls_gd = TLS_TPRELGD;
12699 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
12700 goto tls_ldgd_opt;
12701 break;
12702
12703 case R_PPC64_GOT_TLSLD16:
12704 case R_PPC64_GOT_TLSLD16_LO:
12705 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
12706 {
12707 unsigned int insn1, insn2, insn3;
12708 bfd_vma offset;
12709
12710 tls_ldgd_opt:
12711 offset = (bfd_vma) -1;
12712 /* If not using the newer R_PPC64_TLSGD/LD to mark
12713 __tls_get_addr calls, we must trust that the call
12714 stays with its arg setup insns, ie. that the next
12715 reloc is the __tls_get_addr call associated with
12716 the current reloc. Edit both insns. */
12717 if (input_section->has_tls_get_addr_call
12718 && rel + 1 < relend
12719 && branch_reloc_hash_match (input_bfd, rel + 1,
12720 htab->tls_get_addr,
12721 htab->tls_get_addr_fd))
12722 offset = rel[1].r_offset;
12723 if ((tls_mask & tls_gd) != 0)
12724 {
12725 /* IE */
12726 insn1 = bfd_get_32 (output_bfd,
12727 contents + rel->r_offset - d_offset);
12728 insn1 &= (1 << 26) - (1 << 2);
12729 insn1 |= 58 << 26; /* ld */
12730 insn2 = 0x7c636a14; /* add 3,3,13 */
12731 if (offset != (bfd_vma) -1)
12732 rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
12733 if ((tls_mask & TLS_EXPLICIT) == 0)
12734 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
12735 + R_PPC64_GOT_TPREL16_DS);
12736 else
12737 r_type += R_PPC64_TOC16_DS - R_PPC64_TOC16;
12738 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
12739 }
12740 else
12741 {
12742 /* LE */
12743 insn1 = 0x3c6d0000; /* addis 3,13,0 */
12744 insn2 = 0x38630000; /* addi 3,3,0 */
12745 if (tls_gd == 0)
12746 {
12747 /* Was an LD reloc. */
12748 if (toc_symndx)
12749 sec = local_sections[toc_symndx];
12750 for (r_symndx = 0;
12751 r_symndx < symtab_hdr->sh_info;
12752 r_symndx++)
12753 if (local_sections[r_symndx] == sec)
12754 break;
12755 if (r_symndx >= symtab_hdr->sh_info)
12756 r_symndx = STN_UNDEF;
12757 rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
12758 if (r_symndx != STN_UNDEF)
12759 rel->r_addend -= (local_syms[r_symndx].st_value
12760 + sec->output_offset
12761 + sec->output_section->vma);
12762 }
12763 else if (toc_symndx != 0)
12764 {
12765 r_symndx = toc_symndx;
12766 rel->r_addend = toc_addend;
12767 }
12768 r_type = R_PPC64_TPREL16_HA;
12769 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
12770 if (offset != (bfd_vma) -1)
12771 {
12772 rel[1].r_info = ELF64_R_INFO (r_symndx,
12773 R_PPC64_TPREL16_LO);
12774 rel[1].r_offset = offset + d_offset;
12775 rel[1].r_addend = rel->r_addend;
12776 }
12777 }
12778 bfd_put_32 (output_bfd, insn1,
12779 contents + rel->r_offset - d_offset);
12780 if (offset != (bfd_vma) -1)
12781 {
12782 insn3 = bfd_get_32 (output_bfd,
12783 contents + offset + 4);
12784 if (insn3 == NOP
12785 || insn3 == CROR_151515 || insn3 == CROR_313131)
12786 {
12787 rel[1].r_offset += 4;
12788 bfd_put_32 (output_bfd, insn2, contents + offset + 4);
12789 insn2 = NOP;
12790 }
12791 bfd_put_32 (output_bfd, insn2, contents + offset);
12792 }
12793 if ((tls_mask & tls_gd) == 0
12794 && (tls_gd == 0 || toc_symndx != 0))
12795 {
12796 /* We changed the symbol. Start over in order
12797 to get h, sym, sec etc. right. */
12798 rel--;
12799 continue;
12800 }
12801 }
12802 break;
12803
12804 case R_PPC64_TLSGD:
12805 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
12806 {
12807 unsigned int insn2, insn3;
12808 bfd_vma offset = rel->r_offset;
12809
12810 if ((tls_mask & TLS_TPRELGD) != 0)
12811 {
12812 /* IE */
12813 r_type = R_PPC64_NONE;
12814 insn2 = 0x7c636a14; /* add 3,3,13 */
12815 }
12816 else
12817 {
12818 /* LE */
12819 if (toc_symndx != 0)
12820 {
12821 r_symndx = toc_symndx;
12822 rel->r_addend = toc_addend;
12823 }
12824 r_type = R_PPC64_TPREL16_LO;
12825 rel->r_offset = offset + d_offset;
12826 insn2 = 0x38630000; /* addi 3,3,0 */
12827 }
12828 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
12829 /* Zap the reloc on the _tls_get_addr call too. */
12830 BFD_ASSERT (offset == rel[1].r_offset);
12831 rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
12832 insn3 = bfd_get_32 (output_bfd,
12833 contents + offset + 4);
12834 if (insn3 == NOP
12835 || insn3 == CROR_151515 || insn3 == CROR_313131)
12836 {
12837 rel->r_offset += 4;
12838 bfd_put_32 (output_bfd, insn2, contents + offset + 4);
12839 insn2 = NOP;
12840 }
12841 bfd_put_32 (output_bfd, insn2, contents + offset);
12842 if ((tls_mask & TLS_TPRELGD) == 0 && toc_symndx != 0)
12843 {
12844 rel--;
12845 continue;
12846 }
12847 }
12848 break;
12849
12850 case R_PPC64_TLSLD:
12851 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
12852 {
12853 unsigned int insn2, insn3;
12854 bfd_vma offset = rel->r_offset;
12855
12856 if (toc_symndx)
12857 sec = local_sections[toc_symndx];
12858 for (r_symndx = 0;
12859 r_symndx < symtab_hdr->sh_info;
12860 r_symndx++)
12861 if (local_sections[r_symndx] == sec)
12862 break;
12863 if (r_symndx >= symtab_hdr->sh_info)
12864 r_symndx = STN_UNDEF;
12865 rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
12866 if (r_symndx != STN_UNDEF)
12867 rel->r_addend -= (local_syms[r_symndx].st_value
12868 + sec->output_offset
12869 + sec->output_section->vma);
12870
12871 r_type = R_PPC64_TPREL16_LO;
12872 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
12873 rel->r_offset = offset + d_offset;
12874 /* Zap the reloc on the _tls_get_addr call too. */
12875 BFD_ASSERT (offset == rel[1].r_offset);
12876 rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
12877 insn2 = 0x38630000; /* addi 3,3,0 */
12878 insn3 = bfd_get_32 (output_bfd,
12879 contents + offset + 4);
12880 if (insn3 == NOP
12881 || insn3 == CROR_151515 || insn3 == CROR_313131)
12882 {
12883 rel->r_offset += 4;
12884 bfd_put_32 (output_bfd, insn2, contents + offset + 4);
12885 insn2 = NOP;
12886 }
12887 bfd_put_32 (output_bfd, insn2, contents + offset);
12888 rel--;
12889 continue;
12890 }
12891 break;
12892
12893 case R_PPC64_DTPMOD64:
12894 if (rel + 1 < relend
12895 && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
12896 && rel[1].r_offset == rel->r_offset + 8)
12897 {
12898 if ((tls_mask & TLS_GD) == 0)
12899 {
12900 rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_NONE);
12901 if ((tls_mask & TLS_TPRELGD) != 0)
12902 r_type = R_PPC64_TPREL64;
12903 else
12904 {
12905 bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
12906 r_type = R_PPC64_NONE;
12907 }
12908 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
12909 }
12910 }
12911 else
12912 {
12913 if ((tls_mask & TLS_LD) == 0)
12914 {
12915 bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
12916 r_type = R_PPC64_NONE;
12917 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
12918 }
12919 }
12920 break;
12921
12922 case R_PPC64_TPREL64:
12923 if ((tls_mask & TLS_TPREL) == 0)
12924 {
12925 r_type = R_PPC64_NONE;
12926 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
12927 }
12928 break;
12929 }
12930
12931 /* Handle other relocations that tweak non-addend part of insn. */
12932 insn = 0;
12933 max_br_offset = 1 << 25;
12934 addend = rel->r_addend;
12935 reloc_dest = DEST_NORMAL;
12936 switch (r_type)
12937 {
12938 default:
12939 break;
12940
12941 case R_PPC64_TOCSAVE:
12942 if (relocation + addend == (rel->r_offset
12943 + input_section->output_offset
12944 + input_section->output_section->vma)
12945 && tocsave_find (htab, NO_INSERT,
12946 &local_syms, rel, input_bfd))
12947 {
12948 insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
12949 if (insn == NOP
12950 || insn == CROR_151515 || insn == CROR_313131)
12951 bfd_put_32 (input_bfd, STD_R2_40R1,
12952 contents + rel->r_offset);
12953 }
12954 break;
12955
12956 /* Branch taken prediction relocations. */
12957 case R_PPC64_ADDR14_BRTAKEN:
12958 case R_PPC64_REL14_BRTAKEN:
12959 insn = 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field. */
12960 /* Fall thru. */
12961
12962 /* Branch not taken prediction relocations. */
12963 case R_PPC64_ADDR14_BRNTAKEN:
12964 case R_PPC64_REL14_BRNTAKEN:
12965 insn |= bfd_get_32 (output_bfd,
12966 contents + rel->r_offset) & ~(0x01 << 21);
12967 /* Fall thru. */
12968
12969 case R_PPC64_REL14:
12970 max_br_offset = 1 << 15;
12971 /* Fall thru. */
12972
12973 case R_PPC64_REL24:
12974 /* Calls to functions with a different TOC, such as calls to
12975 shared objects, need to alter the TOC pointer. This is
12976 done using a linkage stub. A REL24 branching to these
12977 linkage stubs needs to be followed by a nop, as the nop
12978 will be replaced with an instruction to restore the TOC
12979 base pointer. */
12980 fdh = h;
12981 if (h != NULL
12982 && h->oh != NULL
12983 && h->oh->is_func_descriptor)
12984 fdh = ppc_follow_link (h->oh);
12985 stub_entry = ppc_get_stub_entry (input_section, sec, fdh, &orig_rel,
12986 htab);
12987 if (stub_entry != NULL
12988 && (stub_entry->stub_type == ppc_stub_plt_call
12989 || stub_entry->stub_type == ppc_stub_plt_call_r2save
12990 || stub_entry->stub_type == ppc_stub_plt_branch_r2off
12991 || stub_entry->stub_type == ppc_stub_long_branch_r2off))
12992 {
12993 bfd_boolean can_plt_call = FALSE;
12994
12995 if (rel->r_offset + 8 <= input_section->size)
12996 {
12997 unsigned long nop;
12998 nop = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
12999 if (nop == NOP
13000 || nop == CROR_151515 || nop == CROR_313131)
13001 {
13002 if (h != NULL
13003 && (h == htab->tls_get_addr_fd
13004 || h == htab->tls_get_addr)
13005 && !htab->no_tls_get_addr_opt)
13006 {
13007 /* Special stub used, leave nop alone. */
13008 }
13009 else
13010 bfd_put_32 (input_bfd, LD_R2_40R1,
13011 contents + rel->r_offset + 4);
13012 can_plt_call = TRUE;
13013 }
13014 }
13015
13016 if (!can_plt_call)
13017 {
13018 if (stub_entry->stub_type == ppc_stub_plt_call
13019 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
13020 {
13021 /* If this is a plain branch rather than a branch
13022 and link, don't require a nop. However, don't
13023 allow tail calls in a shared library as they
13024 will result in r2 being corrupted. */
13025 unsigned long br;
13026 br = bfd_get_32 (input_bfd, contents + rel->r_offset);
13027 if (info->executable && (br & 1) == 0)
13028 can_plt_call = TRUE;
13029 else
13030 stub_entry = NULL;
13031 }
13032 else if (h != NULL
13033 && strcmp (h->elf.root.root.string,
13034 ".__libc_start_main") == 0)
13035 {
13036 /* Allow crt1 branch to go via a toc adjusting stub. */
13037 can_plt_call = TRUE;
13038 }
13039 else
13040 {
13041 info->callbacks->einfo
13042 (_("%P: %H: call to `%T' lacks nop, can't restore toc; "
13043 "recompile with -fPIC"),
13044 input_bfd, input_section, rel->r_offset, sym_name);
13045
13046 bfd_set_error (bfd_error_bad_value);
13047 ret = FALSE;
13048 }
13049 }
13050
13051 if (can_plt_call
13052 && (stub_entry->stub_type == ppc_stub_plt_call
13053 || stub_entry->stub_type == ppc_stub_plt_call_r2save))
13054 unresolved_reloc = FALSE;
13055 }
13056
13057 if ((stub_entry == NULL
13058 || stub_entry->stub_type == ppc_stub_long_branch
13059 || stub_entry->stub_type == ppc_stub_plt_branch)
13060 && get_opd_info (sec) != NULL)
13061 {
13062 /* The branch destination is the value of the opd entry. */
13063 bfd_vma off = (relocation + addend
13064 - sec->output_section->vma
13065 - sec->output_offset);
13066 bfd_vma dest = opd_entry_value (sec, off, NULL, NULL, FALSE);
13067 if (dest != (bfd_vma) -1)
13068 {
13069 relocation = dest;
13070 addend = 0;
13071 reloc_dest = DEST_OPD;
13072 }
13073 }
13074
13075 /* If the branch is out of reach we ought to have a long
13076 branch stub. */
13077 from = (rel->r_offset
13078 + input_section->output_offset
13079 + input_section->output_section->vma);
13080
13081 if (stub_entry != NULL
13082 && (stub_entry->stub_type == ppc_stub_long_branch
13083 || stub_entry->stub_type == ppc_stub_plt_branch)
13084 && (r_type == R_PPC64_ADDR14_BRTAKEN
13085 || r_type == R_PPC64_ADDR14_BRNTAKEN
13086 || (relocation + addend - from + max_br_offset
13087 < 2 * max_br_offset)))
13088 /* Don't use the stub if this branch is in range. */
13089 stub_entry = NULL;
13090
13091 if (stub_entry != NULL)
13092 {
13093 /* Munge up the value and addend so that we call the stub
13094 rather than the procedure directly. */
13095 relocation = (stub_entry->stub_offset
13096 + stub_entry->stub_sec->output_offset
13097 + stub_entry->stub_sec->output_section->vma);
13098 addend = 0;
13099 reloc_dest = DEST_STUB;
13100
13101 if ((stub_entry->stub_type == ppc_stub_plt_call
13102 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
13103 && (ALWAYS_EMIT_R2SAVE
13104 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
13105 && rel + 1 < relend
13106 && rel[1].r_offset == rel->r_offset + 4
13107 && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOCSAVE)
13108 relocation += 4;
13109 }
13110
13111 if (insn != 0)
13112 {
13113 if (is_isa_v2)
13114 {
13115 /* Set 'a' bit. This is 0b00010 in BO field for branch
13116 on CR(BI) insns (BO == 001at or 011at), and 0b01000
13117 for branch on CTR insns (BO == 1a00t or 1a01t). */
13118 if ((insn & (0x14 << 21)) == (0x04 << 21))
13119 insn |= 0x02 << 21;
13120 else if ((insn & (0x14 << 21)) == (0x10 << 21))
13121 insn |= 0x08 << 21;
13122 else
13123 break;
13124 }
13125 else
13126 {
13127 /* Invert 'y' bit if not the default. */
13128 if ((bfd_signed_vma) (relocation + addend - from) < 0)
13129 insn ^= 0x01 << 21;
13130 }
13131
13132 bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
13133 }
13134
13135 /* NOP out calls to undefined weak functions.
13136 We can thus call a weak function without first
13137 checking whether the function is defined. */
13138 else if (h != NULL
13139 && h->elf.root.type == bfd_link_hash_undefweak
13140 && h->elf.dynindx == -1
13141 && r_type == R_PPC64_REL24
13142 && relocation == 0
13143 && addend == 0)
13144 {
13145 bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
13146 continue;
13147 }
13148 break;
13149 }
13150
13151 /* Set `addend'. */
13152 tls_type = 0;
13153 switch (r_type)
13154 {
13155 default:
13156 info->callbacks->einfo
13157 (_("%P: %B: unknown relocation type %d for `%T'\n"),
13158 input_bfd, (int) r_type, sym_name);
13159
13160 bfd_set_error (bfd_error_bad_value);
13161 ret = FALSE;
13162 continue;
13163
13164 case R_PPC64_NONE:
13165 case R_PPC64_TLS:
13166 case R_PPC64_TLSGD:
13167 case R_PPC64_TLSLD:
13168 case R_PPC64_TOCSAVE:
13169 case R_PPC64_GNU_VTINHERIT:
13170 case R_PPC64_GNU_VTENTRY:
13171 continue;
13172
13173 /* GOT16 relocations. Like an ADDR16 using the symbol's
13174 address in the GOT as relocation value instead of the
13175 symbol's value itself. Also, create a GOT entry for the
13176 symbol and put the symbol value there. */
13177 case R_PPC64_GOT_TLSGD16:
13178 case R_PPC64_GOT_TLSGD16_LO:
13179 case R_PPC64_GOT_TLSGD16_HI:
13180 case R_PPC64_GOT_TLSGD16_HA:
13181 tls_type = TLS_TLS | TLS_GD;
13182 goto dogot;
13183
13184 case R_PPC64_GOT_TLSLD16:
13185 case R_PPC64_GOT_TLSLD16_LO:
13186 case R_PPC64_GOT_TLSLD16_HI:
13187 case R_PPC64_GOT_TLSLD16_HA:
13188 tls_type = TLS_TLS | TLS_LD;
13189 goto dogot;
13190
13191 case R_PPC64_GOT_TPREL16_DS:
13192 case R_PPC64_GOT_TPREL16_LO_DS:
13193 case R_PPC64_GOT_TPREL16_HI:
13194 case R_PPC64_GOT_TPREL16_HA:
13195 tls_type = TLS_TLS | TLS_TPREL;
13196 goto dogot;
13197
13198 case R_PPC64_GOT_DTPREL16_DS:
13199 case R_PPC64_GOT_DTPREL16_LO_DS:
13200 case R_PPC64_GOT_DTPREL16_HI:
13201 case R_PPC64_GOT_DTPREL16_HA:
13202 tls_type = TLS_TLS | TLS_DTPREL;
13203 goto dogot;
13204
13205 case R_PPC64_GOT16:
13206 case R_PPC64_GOT16_LO:
13207 case R_PPC64_GOT16_HI:
13208 case R_PPC64_GOT16_HA:
13209 case R_PPC64_GOT16_DS:
13210 case R_PPC64_GOT16_LO_DS:
13211 dogot:
13212 {
13213 /* Relocation is to the entry for this symbol in the global
13214 offset table. */
13215 asection *got;
13216 bfd_vma *offp;
13217 bfd_vma off;
13218 unsigned long indx = 0;
13219 struct got_entry *ent;
13220
13221 if (tls_type == (TLS_TLS | TLS_LD)
13222 && (h == NULL
13223 || !h->elf.def_dynamic))
13224 ent = ppc64_tlsld_got (input_bfd);
13225 else
13226 {
13227
13228 if (h != NULL)
13229 {
13230 bfd_boolean dyn = htab->elf.dynamic_sections_created;
13231 if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared,
13232 &h->elf)
13233 || (info->shared
13234 && SYMBOL_CALLS_LOCAL (info, &h->elf)))
13235 /* This is actually a static link, or it is a
13236 -Bsymbolic link and the symbol is defined
13237 locally, or the symbol was forced to be local
13238 because of a version file. */
13239 ;
13240 else
13241 {
13242 BFD_ASSERT (h->elf.dynindx != -1);
13243 indx = h->elf.dynindx;
13244 unresolved_reloc = FALSE;
13245 }
13246 ent = h->elf.got.glist;
13247 }
13248 else
13249 {
13250 if (local_got_ents == NULL)
13251 abort ();
13252 ent = local_got_ents[r_symndx];
13253 }
13254
13255 for (; ent != NULL; ent = ent->next)
13256 if (ent->addend == orig_rel.r_addend
13257 && ent->owner == input_bfd
13258 && ent->tls_type == tls_type)
13259 break;
13260 }
13261
13262 if (ent == NULL)
13263 abort ();
13264 if (ent->is_indirect)
13265 ent = ent->got.ent;
13266 offp = &ent->got.offset;
13267 got = ppc64_elf_tdata (ent->owner)->got;
13268 if (got == NULL)
13269 abort ();
13270
13271 /* The offset must always be a multiple of 8. We use the
13272 least significant bit to record whether we have already
13273 processed this entry. */
13274 off = *offp;
13275 if ((off & 1) != 0)
13276 off &= ~1;
13277 else
13278 {
13279 /* Generate relocs for the dynamic linker, except in
13280 the case of TLSLD where we'll use one entry per
13281 module. */
13282 asection *relgot;
13283 bfd_boolean ifunc;
13284
13285 *offp = off | 1;
13286 relgot = NULL;
13287 ifunc = (h != NULL
13288 ? h->elf.type == STT_GNU_IFUNC
13289 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC);
13290 if (ifunc)
13291 relgot = htab->reliplt;
13292 else if ((info->shared || indx != 0)
13293 && (h == NULL
13294 || (tls_type == (TLS_TLS | TLS_LD)
13295 && !h->elf.def_dynamic)
13296 || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
13297 || h->elf.root.type != bfd_link_hash_undefweak))
13298 relgot = ppc64_elf_tdata (ent->owner)->relgot;
13299 if (relgot != NULL)
13300 {
13301 outrel.r_offset = (got->output_section->vma
13302 + got->output_offset
13303 + off);
13304 outrel.r_addend = addend;
13305 if (tls_type & (TLS_LD | TLS_GD))
13306 {
13307 outrel.r_addend = 0;
13308 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPMOD64);
13309 if (tls_type == (TLS_TLS | TLS_GD))
13310 {
13311 loc = relgot->contents;
13312 loc += (relgot->reloc_count++
13313 * sizeof (Elf64_External_Rela));
13314 bfd_elf64_swap_reloca_out (output_bfd,
13315 &outrel, loc);
13316 outrel.r_offset += 8;
13317 outrel.r_addend = addend;
13318 outrel.r_info
13319 = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
13320 }
13321 }
13322 else if (tls_type == (TLS_TLS | TLS_DTPREL))
13323 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
13324 else if (tls_type == (TLS_TLS | TLS_TPREL))
13325 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_TPREL64);
13326 else if (indx != 0)
13327 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_GLOB_DAT);
13328 else
13329 {
13330 if (ifunc)
13331 outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
13332 else
13333 outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
13334
13335 /* Write the .got section contents for the sake
13336 of prelink. */
13337 loc = got->contents + off;
13338 bfd_put_64 (output_bfd, outrel.r_addend + relocation,
13339 loc);
13340 }
13341
13342 if (indx == 0 && tls_type != (TLS_TLS | TLS_LD))
13343 {
13344 outrel.r_addend += relocation;
13345 if (tls_type & (TLS_GD | TLS_DTPREL | TLS_TPREL))
13346 outrel.r_addend -= htab->elf.tls_sec->vma;
13347 }
13348 loc = relgot->contents;
13349 loc += (relgot->reloc_count++
13350 * sizeof (Elf64_External_Rela));
13351 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
13352 }
13353
13354 /* Init the .got section contents here if we're not
13355 emitting a reloc. */
13356 else
13357 {
13358 relocation += addend;
13359 if (tls_type == (TLS_TLS | TLS_LD))
13360 relocation = 1;
13361 else if (tls_type != 0)
13362 {
13363 relocation -= htab->elf.tls_sec->vma + DTP_OFFSET;
13364 if (tls_type == (TLS_TLS | TLS_TPREL))
13365 relocation += DTP_OFFSET - TP_OFFSET;
13366
13367 if (tls_type == (TLS_TLS | TLS_GD))
13368 {
13369 bfd_put_64 (output_bfd, relocation,
13370 got->contents + off + 8);
13371 relocation = 1;
13372 }
13373 }
13374
13375 bfd_put_64 (output_bfd, relocation,
13376 got->contents + off);
13377 }
13378 }
13379
13380 if (off >= (bfd_vma) -2)
13381 abort ();
13382
13383 relocation = got->output_section->vma + got->output_offset + off;
13384 addend = -(TOCstart + htab->stub_group[input_section->id].toc_off);
13385 }
13386 break;
13387
13388 case R_PPC64_PLT16_HA:
13389 case R_PPC64_PLT16_HI:
13390 case R_PPC64_PLT16_LO:
13391 case R_PPC64_PLT32:
13392 case R_PPC64_PLT64:
13393 /* Relocation is to the entry for this symbol in the
13394 procedure linkage table. */
13395
13396 /* Resolve a PLT reloc against a local symbol directly,
13397 without using the procedure linkage table. */
13398 if (h == NULL)
13399 break;
13400
13401 /* It's possible that we didn't make a PLT entry for this
13402 symbol. This happens when statically linking PIC code,
13403 or when using -Bsymbolic. Go find a match if there is a
13404 PLT entry. */
13405 if (htab->plt != NULL)
13406 {
13407 struct plt_entry *ent;
13408 for (ent = h->elf.plt.plist; ent != NULL; ent = ent->next)
13409 if (ent->addend == orig_rel.r_addend
13410 && ent->plt.offset != (bfd_vma) -1)
13411 {
13412 relocation = (htab->plt->output_section->vma
13413 + htab->plt->output_offset
13414 + ent->plt.offset);
13415 unresolved_reloc = FALSE;
13416 }
13417 }
13418 break;
13419
13420 case R_PPC64_TOC:
13421 /* Relocation value is TOC base. */
13422 relocation = TOCstart;
13423 if (r_symndx == STN_UNDEF)
13424 relocation += htab->stub_group[input_section->id].toc_off;
13425 else if (unresolved_reloc)
13426 ;
13427 else if (sec != NULL && sec->id <= htab->top_id)
13428 relocation += htab->stub_group[sec->id].toc_off;
13429 else
13430 unresolved_reloc = TRUE;
13431 goto dodyn;
13432
13433 /* TOC16 relocs. We want the offset relative to the TOC base,
13434 which is the address of the start of the TOC plus 0x8000.
13435 The TOC consists of sections .got, .toc, .tocbss, and .plt,
13436 in this order. */
13437 case R_PPC64_TOC16:
13438 case R_PPC64_TOC16_LO:
13439 case R_PPC64_TOC16_HI:
13440 case R_PPC64_TOC16_DS:
13441 case R_PPC64_TOC16_LO_DS:
13442 case R_PPC64_TOC16_HA:
13443 addend -= TOCstart + htab->stub_group[input_section->id].toc_off;
13444 break;
13445
13446 /* Relocate against the beginning of the section. */
13447 case R_PPC64_SECTOFF:
13448 case R_PPC64_SECTOFF_LO:
13449 case R_PPC64_SECTOFF_HI:
13450 case R_PPC64_SECTOFF_DS:
13451 case R_PPC64_SECTOFF_LO_DS:
13452 case R_PPC64_SECTOFF_HA:
13453 if (sec != NULL)
13454 addend -= sec->output_section->vma;
13455 break;
13456
13457 case R_PPC64_REL16:
13458 case R_PPC64_REL16_LO:
13459 case R_PPC64_REL16_HI:
13460 case R_PPC64_REL16_HA:
13461 break;
13462
13463 case R_PPC64_REL14:
13464 case R_PPC64_REL14_BRNTAKEN:
13465 case R_PPC64_REL14_BRTAKEN:
13466 case R_PPC64_REL24:
13467 break;
13468
13469 case R_PPC64_TPREL16:
13470 case R_PPC64_TPREL16_LO:
13471 case R_PPC64_TPREL16_HI:
13472 case R_PPC64_TPREL16_HA:
13473 case R_PPC64_TPREL16_DS:
13474 case R_PPC64_TPREL16_LO_DS:
13475 case R_PPC64_TPREL16_HIGHER:
13476 case R_PPC64_TPREL16_HIGHERA:
13477 case R_PPC64_TPREL16_HIGHEST:
13478 case R_PPC64_TPREL16_HIGHESTA:
13479 if (h != NULL
13480 && h->elf.root.type == bfd_link_hash_undefweak
13481 && h->elf.dynindx == -1)
13482 {
13483 /* Make this relocation against an undefined weak symbol
13484 resolve to zero. This is really just a tweak, since
13485 code using weak externs ought to check that they are
13486 defined before using them. */
13487 bfd_byte *p = contents + rel->r_offset - d_offset;
13488
13489 insn = bfd_get_32 (output_bfd, p);
13490 insn = _bfd_elf_ppc_at_tprel_transform (insn, 13);
13491 if (insn != 0)
13492 bfd_put_32 (output_bfd, insn, p);
13493 break;
13494 }
13495 addend -= htab->elf.tls_sec->vma + TP_OFFSET;
13496 if (info->shared)
13497 /* The TPREL16 relocs shouldn't really be used in shared
13498 libs as they will result in DT_TEXTREL being set, but
13499 support them anyway. */
13500 goto dodyn;
13501 break;
13502
13503 case R_PPC64_DTPREL16:
13504 case R_PPC64_DTPREL16_LO:
13505 case R_PPC64_DTPREL16_HI:
13506 case R_PPC64_DTPREL16_HA:
13507 case R_PPC64_DTPREL16_DS:
13508 case R_PPC64_DTPREL16_LO_DS:
13509 case R_PPC64_DTPREL16_HIGHER:
13510 case R_PPC64_DTPREL16_HIGHERA:
13511 case R_PPC64_DTPREL16_HIGHEST:
13512 case R_PPC64_DTPREL16_HIGHESTA:
13513 addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
13514 break;
13515
13516 case R_PPC64_DTPMOD64:
13517 relocation = 1;
13518 addend = 0;
13519 goto dodyn;
13520
13521 case R_PPC64_TPREL64:
13522 addend -= htab->elf.tls_sec->vma + TP_OFFSET;
13523 goto dodyn;
13524
13525 case R_PPC64_DTPREL64:
13526 addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
13527 /* Fall thru */
13528
13529 /* Relocations that may need to be propagated if this is a
13530 dynamic object. */
13531 case R_PPC64_REL30:
13532 case R_PPC64_REL32:
13533 case R_PPC64_REL64:
13534 case R_PPC64_ADDR14:
13535 case R_PPC64_ADDR14_BRNTAKEN:
13536 case R_PPC64_ADDR14_BRTAKEN:
13537 case R_PPC64_ADDR16:
13538 case R_PPC64_ADDR16_DS:
13539 case R_PPC64_ADDR16_HA:
13540 case R_PPC64_ADDR16_HI:
13541 case R_PPC64_ADDR16_HIGHER:
13542 case R_PPC64_ADDR16_HIGHERA:
13543 case R_PPC64_ADDR16_HIGHEST:
13544 case R_PPC64_ADDR16_HIGHESTA:
13545 case R_PPC64_ADDR16_LO:
13546 case R_PPC64_ADDR16_LO_DS:
13547 case R_PPC64_ADDR24:
13548 case R_PPC64_ADDR32:
13549 case R_PPC64_ADDR64:
13550 case R_PPC64_UADDR16:
13551 case R_PPC64_UADDR32:
13552 case R_PPC64_UADDR64:
13553 dodyn:
13554 if ((input_section->flags & SEC_ALLOC) == 0)
13555 break;
13556
13557 if (NO_OPD_RELOCS && is_opd)
13558 break;
13559
13560 if ((info->shared
13561 && (h == NULL
13562 || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
13563 || h->elf.root.type != bfd_link_hash_undefweak)
13564 && (must_be_dyn_reloc (info, r_type)
13565 || !SYMBOL_CALLS_LOCAL (info, &h->elf)))
13566 || (ELIMINATE_COPY_RELOCS
13567 && !info->shared
13568 && h != NULL
13569 && h->elf.dynindx != -1
13570 && !h->elf.non_got_ref
13571 && !h->elf.def_regular)
13572 || (!info->shared
13573 && (h != NULL
13574 ? h->elf.type == STT_GNU_IFUNC
13575 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)))
13576 {
13577 bfd_boolean skip, relocate;
13578 asection *sreloc;
13579 bfd_vma out_off;
13580
13581 /* When generating a dynamic object, these relocations
13582 are copied into the output file to be resolved at run
13583 time. */
13584
13585 skip = FALSE;
13586 relocate = FALSE;
13587
13588 out_off = _bfd_elf_section_offset (output_bfd, info,
13589 input_section, rel->r_offset);
13590 if (out_off == (bfd_vma) -1)
13591 skip = TRUE;
13592 else if (out_off == (bfd_vma) -2)
13593 skip = TRUE, relocate = TRUE;
13594 out_off += (input_section->output_section->vma
13595 + input_section->output_offset);
13596 outrel.r_offset = out_off;
13597 outrel.r_addend = rel->r_addend;
13598
13599 /* Optimize unaligned reloc use. */
13600 if ((r_type == R_PPC64_ADDR64 && (out_off & 7) != 0)
13601 || (r_type == R_PPC64_UADDR64 && (out_off & 7) == 0))
13602 r_type ^= R_PPC64_ADDR64 ^ R_PPC64_UADDR64;
13603 else if ((r_type == R_PPC64_ADDR32 && (out_off & 3) != 0)
13604 || (r_type == R_PPC64_UADDR32 && (out_off & 3) == 0))
13605 r_type ^= R_PPC64_ADDR32 ^ R_PPC64_UADDR32;
13606 else if ((r_type == R_PPC64_ADDR16 && (out_off & 1) != 0)
13607 || (r_type == R_PPC64_UADDR16 && (out_off & 1) == 0))
13608 r_type ^= R_PPC64_ADDR16 ^ R_PPC64_UADDR16;
13609
13610 if (skip)
13611 memset (&outrel, 0, sizeof outrel);
13612 else if (!SYMBOL_CALLS_LOCAL (info, &h->elf)
13613 && !is_opd
13614 && r_type != R_PPC64_TOC)
13615 {
13616 BFD_ASSERT (h->elf.dynindx != -1);
13617 outrel.r_info = ELF64_R_INFO (h->elf.dynindx, r_type);
13618 }
13619 else
13620 {
13621 /* This symbol is local, or marked to become local,
13622 or this is an opd section reloc which must point
13623 at a local function. */
13624 outrel.r_addend += relocation;
13625 if (r_type == R_PPC64_ADDR64 || r_type == R_PPC64_TOC)
13626 {
13627 if (is_opd && h != NULL)
13628 {
13629 /* Lie about opd entries. This case occurs
13630 when building shared libraries and we
13631 reference a function in another shared
13632 lib. The same thing happens for a weak
13633 definition in an application that's
13634 overridden by a strong definition in a
13635 shared lib. (I believe this is a generic
13636 bug in binutils handling of weak syms.)
13637 In these cases we won't use the opd
13638 entry in this lib. */
13639 unresolved_reloc = FALSE;
13640 }
13641 if (!is_opd
13642 && r_type == R_PPC64_ADDR64
13643 && (h != NULL
13644 ? h->elf.type == STT_GNU_IFUNC
13645 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
13646 outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
13647 else
13648 {
13649 outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
13650
13651 /* We need to relocate .opd contents for ld.so.
13652 Prelink also wants simple and consistent rules
13653 for relocs. This make all RELATIVE relocs have
13654 *r_offset equal to r_addend. */
13655 relocate = TRUE;
13656 }
13657 }
13658 else
13659 {
13660 long indx = 0;
13661
13662 if (h != NULL
13663 ? h->elf.type == STT_GNU_IFUNC
13664 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
13665 {
13666 info->callbacks->einfo
13667 (_("%P: %H: %s for indirect "
13668 "function `%T' unsupported\n"),
13669 input_bfd, input_section, rel->r_offset,
13670 ppc64_elf_howto_table[r_type]->name,
13671 sym_name);
13672 ret = FALSE;
13673 }
13674 else if (r_symndx == STN_UNDEF || bfd_is_abs_section (sec))
13675 ;
13676 else if (sec == NULL || sec->owner == NULL)
13677 {
13678 bfd_set_error (bfd_error_bad_value);
13679 return FALSE;
13680 }
13681 else
13682 {
13683 asection *osec;
13684
13685 osec = sec->output_section;
13686 indx = elf_section_data (osec)->dynindx;
13687
13688 if (indx == 0)
13689 {
13690 if ((osec->flags & SEC_READONLY) == 0
13691 && htab->elf.data_index_section != NULL)
13692 osec = htab->elf.data_index_section;
13693 else
13694 osec = htab->elf.text_index_section;
13695 indx = elf_section_data (osec)->dynindx;
13696 }
13697 BFD_ASSERT (indx != 0);
13698
13699 /* We are turning this relocation into one
13700 against a section symbol, so subtract out
13701 the output section's address but not the
13702 offset of the input section in the output
13703 section. */
13704 outrel.r_addend -= osec->vma;
13705 }
13706
13707 outrel.r_info = ELF64_R_INFO (indx, r_type);
13708 }
13709 }
13710
13711 sreloc = elf_section_data (input_section)->sreloc;
13712 if (h != NULL
13713 ? h->elf.type == STT_GNU_IFUNC
13714 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
13715 sreloc = htab->reliplt;
13716 if (sreloc == NULL)
13717 abort ();
13718
13719 if (sreloc->reloc_count * sizeof (Elf64_External_Rela)
13720 >= sreloc->size)
13721 abort ();
13722 loc = sreloc->contents;
13723 loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
13724 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
13725
13726 /* If this reloc is against an external symbol, it will
13727 be computed at runtime, so there's no need to do
13728 anything now. However, for the sake of prelink ensure
13729 that the section contents are a known value. */
13730 if (! relocate)
13731 {
13732 unresolved_reloc = FALSE;
13733 /* The value chosen here is quite arbitrary as ld.so
13734 ignores section contents except for the special
13735 case of .opd where the contents might be accessed
13736 before relocation. Choose zero, as that won't
13737 cause reloc overflow. */
13738 relocation = 0;
13739 addend = 0;
13740 /* Use *r_offset == r_addend for R_PPC64_ADDR64 relocs
13741 to improve backward compatibility with older
13742 versions of ld. */
13743 if (r_type == R_PPC64_ADDR64)
13744 addend = outrel.r_addend;
13745 /* Adjust pc_relative relocs to have zero in *r_offset. */
13746 else if (ppc64_elf_howto_table[r_type]->pc_relative)
13747 addend = (input_section->output_section->vma
13748 + input_section->output_offset
13749 + rel->r_offset);
13750 }
13751 }
13752 break;
13753
13754 case R_PPC64_COPY:
13755 case R_PPC64_GLOB_DAT:
13756 case R_PPC64_JMP_SLOT:
13757 case R_PPC64_JMP_IREL:
13758 case R_PPC64_RELATIVE:
13759 /* We shouldn't ever see these dynamic relocs in relocatable
13760 files. */
13761 /* Fall through. */
13762
13763 case R_PPC64_PLTGOT16:
13764 case R_PPC64_PLTGOT16_DS:
13765 case R_PPC64_PLTGOT16_HA:
13766 case R_PPC64_PLTGOT16_HI:
13767 case R_PPC64_PLTGOT16_LO:
13768 case R_PPC64_PLTGOT16_LO_DS:
13769 case R_PPC64_PLTREL32:
13770 case R_PPC64_PLTREL64:
13771 /* These ones haven't been implemented yet. */
13772
13773 info->callbacks->einfo
13774 (_("%P: %B: %s is not supported for `%T'\n"),
13775 input_bfd,
13776 ppc64_elf_howto_table[r_type]->name, sym_name);
13777
13778 bfd_set_error (bfd_error_invalid_operation);
13779 ret = FALSE;
13780 continue;
13781 }
13782
13783 /* Multi-instruction sequences that access the TOC can be
13784 optimized, eg. addis ra,r2,0; addi rb,ra,x;
13785 to nop; addi rb,r2,x; */
13786 switch (r_type)
13787 {
13788 default:
13789 break;
13790
13791 case R_PPC64_GOT_TLSLD16_HI:
13792 case R_PPC64_GOT_TLSGD16_HI:
13793 case R_PPC64_GOT_TPREL16_HI:
13794 case R_PPC64_GOT_DTPREL16_HI:
13795 case R_PPC64_GOT16_HI:
13796 case R_PPC64_TOC16_HI:
13797 /* These relocs would only be useful if building up an
13798 offset to later add to r2, perhaps in an indexed
13799 addressing mode instruction. Don't try to optimize.
13800 Unfortunately, the possibility of someone building up an
13801 offset like this or even with the HA relocs, means that
13802 we need to check the high insn when optimizing the low
13803 insn. */
13804 break;
13805
13806 case R_PPC64_GOT_TLSLD16_HA:
13807 case R_PPC64_GOT_TLSGD16_HA:
13808 case R_PPC64_GOT_TPREL16_HA:
13809 case R_PPC64_GOT_DTPREL16_HA:
13810 case R_PPC64_GOT16_HA:
13811 case R_PPC64_TOC16_HA:
13812 if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
13813 && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
13814 {
13815 bfd_byte *p = contents + (rel->r_offset & ~3);
13816 bfd_put_32 (input_bfd, NOP, p);
13817 }
13818 break;
13819
13820 case R_PPC64_GOT_TLSLD16_LO:
13821 case R_PPC64_GOT_TLSGD16_LO:
13822 case R_PPC64_GOT_TPREL16_LO_DS:
13823 case R_PPC64_GOT_DTPREL16_LO_DS:
13824 case R_PPC64_GOT16_LO:
13825 case R_PPC64_GOT16_LO_DS:
13826 case R_PPC64_TOC16_LO:
13827 case R_PPC64_TOC16_LO_DS:
13828 if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
13829 && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
13830 {
13831 bfd_byte *p = contents + (rel->r_offset & ~3);
13832 insn = bfd_get_32 (input_bfd, p);
13833 if ((insn & (0x3f << 26)) == 12u << 26 /* addic */)
13834 {
13835 /* Transform addic to addi when we change reg. */
13836 insn &= ~((0x3f << 26) | (0x1f << 16));
13837 insn |= (14u << 26) | (2 << 16);
13838 }
13839 else
13840 {
13841 insn &= ~(0x1f << 16);
13842 insn |= 2 << 16;
13843 }
13844 bfd_put_32 (input_bfd, insn, p);
13845 }
13846 break;
13847 }
13848
13849 /* Do any further special processing. */
13850 switch (r_type)
13851 {
13852 default:
13853 break;
13854
13855 case R_PPC64_ADDR16_HA:
13856 case R_PPC64_REL16_HA:
13857 case R_PPC64_ADDR16_HIGHERA:
13858 case R_PPC64_ADDR16_HIGHESTA:
13859 case R_PPC64_TOC16_HA:
13860 case R_PPC64_SECTOFF_HA:
13861 case R_PPC64_TPREL16_HA:
13862 case R_PPC64_DTPREL16_HA:
13863 case R_PPC64_TPREL16_HIGHER:
13864 case R_PPC64_TPREL16_HIGHERA:
13865 case R_PPC64_TPREL16_HIGHEST:
13866 case R_PPC64_TPREL16_HIGHESTA:
13867 case R_PPC64_DTPREL16_HIGHER:
13868 case R_PPC64_DTPREL16_HIGHERA:
13869 case R_PPC64_DTPREL16_HIGHEST:
13870 case R_PPC64_DTPREL16_HIGHESTA:
13871 /* It's just possible that this symbol is a weak symbol
13872 that's not actually defined anywhere. In that case,
13873 'sec' would be NULL, and we should leave the symbol
13874 alone (it will be set to zero elsewhere in the link). */
13875 if (sec == NULL)
13876 break;
13877 /* Fall thru */
13878
13879 case R_PPC64_GOT16_HA:
13880 case R_PPC64_PLTGOT16_HA:
13881 case R_PPC64_PLT16_HA:
13882 case R_PPC64_GOT_TLSGD16_HA:
13883 case R_PPC64_GOT_TLSLD16_HA:
13884 case R_PPC64_GOT_TPREL16_HA:
13885 case R_PPC64_GOT_DTPREL16_HA:
13886 /* Add 0x10000 if sign bit in 0:15 is set.
13887 Bits 0:15 are not used. */
13888 addend += 0x8000;
13889 break;
13890
13891 case R_PPC64_ADDR16_DS:
13892 case R_PPC64_ADDR16_LO_DS:
13893 case R_PPC64_GOT16_DS:
13894 case R_PPC64_GOT16_LO_DS:
13895 case R_PPC64_PLT16_LO_DS:
13896 case R_PPC64_SECTOFF_DS:
13897 case R_PPC64_SECTOFF_LO_DS:
13898 case R_PPC64_TOC16_DS:
13899 case R_PPC64_TOC16_LO_DS:
13900 case R_PPC64_PLTGOT16_DS:
13901 case R_PPC64_PLTGOT16_LO_DS:
13902 case R_PPC64_GOT_TPREL16_DS:
13903 case R_PPC64_GOT_TPREL16_LO_DS:
13904 case R_PPC64_GOT_DTPREL16_DS:
13905 case R_PPC64_GOT_DTPREL16_LO_DS:
13906 case R_PPC64_TPREL16_DS:
13907 case R_PPC64_TPREL16_LO_DS:
13908 case R_PPC64_DTPREL16_DS:
13909 case R_PPC64_DTPREL16_LO_DS:
13910 insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
13911 mask = 3;
13912 /* If this reloc is against an lq insn, then the value must be
13913 a multiple of 16. This is somewhat of a hack, but the
13914 "correct" way to do this by defining _DQ forms of all the
13915 _DS relocs bloats all reloc switches in this file. It
13916 doesn't seem to make much sense to use any of these relocs
13917 in data, so testing the insn should be safe. */
13918 if ((insn & (0x3f << 26)) == (56u << 26))
13919 mask = 15;
13920 if (((relocation + addend) & mask) != 0)
13921 {
13922 info->callbacks->einfo
13923 (_("%P: %H: error: %s not a multiple of %u\n"),
13924 input_bfd, input_section, rel->r_offset,
13925 ppc64_elf_howto_table[r_type]->name,
13926 mask + 1);
13927 bfd_set_error (bfd_error_bad_value);
13928 ret = FALSE;
13929 continue;
13930 }
13931 break;
13932 }
13933
13934 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
13935 because such sections are not SEC_ALLOC and thus ld.so will
13936 not process them. */
13937 if (unresolved_reloc
13938 && !((input_section->flags & SEC_DEBUGGING) != 0
13939 && h->elf.def_dynamic)
13940 && _bfd_elf_section_offset (output_bfd, info, input_section,
13941 rel->r_offset) != (bfd_vma) -1)
13942 {
13943 info->callbacks->einfo
13944 (_("%P: %H: unresolvable %s against `%T'\n"),
13945 input_bfd, input_section, rel->r_offset,
13946 ppc64_elf_howto_table[(int) r_type]->name,
13947 h->elf.root.root.string);
13948 ret = FALSE;
13949 }
13950
13951 r = _bfd_final_link_relocate (ppc64_elf_howto_table[(int) r_type],
13952 input_bfd,
13953 input_section,
13954 contents,
13955 rel->r_offset,
13956 relocation,
13957 addend);
13958
13959 if (r != bfd_reloc_ok)
13960 {
13961 char *more_info = NULL;
13962 const char *reloc_name = ppc64_elf_howto_table[r_type]->name;
13963
13964 if (reloc_dest != DEST_NORMAL)
13965 {
13966 more_info = bfd_malloc (strlen (reloc_name) + 8);
13967 if (more_info != NULL)
13968 {
13969 strcpy (more_info, reloc_name);
13970 strcat (more_info, (reloc_dest == DEST_OPD
13971 ? " (OPD)" : " (stub)"));
13972 reloc_name = more_info;
13973 }
13974 }
13975
13976 if (r == bfd_reloc_overflow)
13977 {
13978 if (warned)
13979 continue;
13980 if (h != NULL
13981 && h->elf.root.type == bfd_link_hash_undefweak
13982 && ppc64_elf_howto_table[r_type]->pc_relative)
13983 {
13984 /* Assume this is a call protected by other code that
13985 detects the symbol is undefined. If this is the case,
13986 we can safely ignore the overflow. If not, the
13987 program is hosed anyway, and a little warning isn't
13988 going to help. */
13989
13990 continue;
13991 }
13992
13993 if (!((*info->callbacks->reloc_overflow)
13994 (info, &h->elf.root, sym_name,
13995 reloc_name, orig_rel.r_addend,
13996 input_bfd, input_section, rel->r_offset)))
13997 return FALSE;
13998 }
13999 else
14000 {
14001 info->callbacks->einfo
14002 (_("%P: %H: %s against `%T': error %d\n"),
14003 input_bfd, input_section, rel->r_offset,
14004 reloc_name, sym_name, (int) r);
14005 ret = FALSE;
14006 }
14007 if (more_info != NULL)
14008 free (more_info);
14009 }
14010 }
14011
14012 /* If we're emitting relocations, then shortly after this function
14013 returns, reloc offsets and addends for this section will be
14014 adjusted. Worse, reloc symbol indices will be for the output
14015 file rather than the input. Save a copy of the relocs for
14016 opd_entry_value. */
14017 if (is_opd && (info->emitrelocations || info->relocatable))
14018 {
14019 bfd_size_type amt;
14020 amt = input_section->reloc_count * sizeof (Elf_Internal_Rela);
14021 rel = bfd_alloc (input_bfd, amt);
14022 BFD_ASSERT (ppc64_elf_tdata (input_bfd)->opd_relocs == NULL);
14023 ppc64_elf_tdata (input_bfd)->opd_relocs = rel;
14024 if (rel == NULL)
14025 return FALSE;
14026 memcpy (rel, relocs, amt);
14027 }
14028 return ret;
14029 }
14030
14031 /* Adjust the value of any local symbols in opd sections. */
14032
14033 static int
14034 ppc64_elf_output_symbol_hook (struct bfd_link_info *info,
14035 const char *name ATTRIBUTE_UNUSED,
14036 Elf_Internal_Sym *elfsym,
14037 asection *input_sec,
14038 struct elf_link_hash_entry *h)
14039 {
14040 struct _opd_sec_data *opd;
14041 long adjust;
14042 bfd_vma value;
14043
14044 if (h != NULL)
14045 return 1;
14046
14047 opd = get_opd_info (input_sec);
14048 if (opd == NULL || opd->adjust == NULL)
14049 return 1;
14050
14051 value = elfsym->st_value - input_sec->output_offset;
14052 if (!info->relocatable)
14053 value -= input_sec->output_section->vma;
14054
14055 adjust = opd->adjust[value / 8];
14056 if (adjust == -1)
14057 return 2;
14058
14059 elfsym->st_value += adjust;
14060 return 1;
14061 }
14062
14063 /* Finish up dynamic symbol handling. We set the contents of various
14064 dynamic sections here. */
14065
14066 static bfd_boolean
14067 ppc64_elf_finish_dynamic_symbol (bfd *output_bfd,
14068 struct bfd_link_info *info,
14069 struct elf_link_hash_entry *h,
14070 Elf_Internal_Sym *sym ATTRIBUTE_UNUSED)
14071 {
14072 struct ppc_link_hash_table *htab;
14073 struct plt_entry *ent;
14074 Elf_Internal_Rela rela;
14075 bfd_byte *loc;
14076
14077 htab = ppc_hash_table (info);
14078 if (htab == NULL)
14079 return FALSE;
14080
14081 for (ent = h->plt.plist; ent != NULL; ent = ent->next)
14082 if (ent->plt.offset != (bfd_vma) -1)
14083 {
14084 /* This symbol has an entry in the procedure linkage
14085 table. Set it up. */
14086 if (!htab->elf.dynamic_sections_created
14087 || h->dynindx == -1)
14088 {
14089 BFD_ASSERT (h->type == STT_GNU_IFUNC
14090 && h->def_regular
14091 && (h->root.type == bfd_link_hash_defined
14092 || h->root.type == bfd_link_hash_defweak));
14093 rela.r_offset = (htab->iplt->output_section->vma
14094 + htab->iplt->output_offset
14095 + ent->plt.offset);
14096 rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
14097 rela.r_addend = (h->root.u.def.value
14098 + h->root.u.def.section->output_offset
14099 + h->root.u.def.section->output_section->vma
14100 + ent->addend);
14101 loc = (htab->reliplt->contents
14102 + (htab->reliplt->reloc_count++
14103 * sizeof (Elf64_External_Rela)));
14104 }
14105 else
14106 {
14107 rela.r_offset = (htab->plt->output_section->vma
14108 + htab->plt->output_offset
14109 + ent->plt.offset);
14110 rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_JMP_SLOT);
14111 rela.r_addend = ent->addend;
14112 loc = (htab->relplt->contents
14113 + ((ent->plt.offset - PLT_INITIAL_ENTRY_SIZE)
14114 / (PLT_ENTRY_SIZE / sizeof (Elf64_External_Rela))));
14115 }
14116 bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
14117 }
14118
14119 if (h->needs_copy)
14120 {
14121 /* This symbol needs a copy reloc. Set it up. */
14122
14123 if (h->dynindx == -1
14124 || (h->root.type != bfd_link_hash_defined
14125 && h->root.type != bfd_link_hash_defweak)
14126 || htab->relbss == NULL)
14127 abort ();
14128
14129 rela.r_offset = (h->root.u.def.value
14130 + h->root.u.def.section->output_section->vma
14131 + h->root.u.def.section->output_offset);
14132 rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_COPY);
14133 rela.r_addend = 0;
14134 loc = htab->relbss->contents;
14135 loc += htab->relbss->reloc_count++ * sizeof (Elf64_External_Rela);
14136 bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
14137 }
14138
14139 return TRUE;
14140 }
14141
14142 /* Used to decide how to sort relocs in an optimal manner for the
14143 dynamic linker, before writing them out. */
14144
14145 static enum elf_reloc_type_class
14146 ppc64_elf_reloc_type_class (const struct bfd_link_info *info,
14147 const asection *rel_sec,
14148 const Elf_Internal_Rela *rela)
14149 {
14150 enum elf_ppc64_reloc_type r_type;
14151 struct ppc_link_hash_table *htab = ppc_hash_table (info);
14152
14153 if (rel_sec == htab->reliplt)
14154 return reloc_class_ifunc;
14155
14156 r_type = ELF64_R_TYPE (rela->r_info);
14157 switch (r_type)
14158 {
14159 case R_PPC64_RELATIVE:
14160 return reloc_class_relative;
14161 case R_PPC64_JMP_SLOT:
14162 return reloc_class_plt;
14163 case R_PPC64_COPY:
14164 return reloc_class_copy;
14165 default:
14166 return reloc_class_normal;
14167 }
14168 }
14169
14170 /* Finish up the dynamic sections. */
14171
14172 static bfd_boolean
14173 ppc64_elf_finish_dynamic_sections (bfd *output_bfd,
14174 struct bfd_link_info *info)
14175 {
14176 struct ppc_link_hash_table *htab;
14177 bfd *dynobj;
14178 asection *sdyn;
14179
14180 htab = ppc_hash_table (info);
14181 if (htab == NULL)
14182 return FALSE;
14183
14184 dynobj = htab->elf.dynobj;
14185 sdyn = bfd_get_linker_section (dynobj, ".dynamic");
14186
14187 if (htab->elf.dynamic_sections_created)
14188 {
14189 Elf64_External_Dyn *dyncon, *dynconend;
14190
14191 if (sdyn == NULL || htab->got == NULL)
14192 abort ();
14193
14194 dyncon = (Elf64_External_Dyn *) sdyn->contents;
14195 dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
14196 for (; dyncon < dynconend; dyncon++)
14197 {
14198 Elf_Internal_Dyn dyn;
14199 asection *s;
14200
14201 bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
14202
14203 switch (dyn.d_tag)
14204 {
14205 default:
14206 continue;
14207
14208 case DT_PPC64_GLINK:
14209 s = htab->glink;
14210 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
14211 /* We stupidly defined DT_PPC64_GLINK to be the start
14212 of glink rather than the first entry point, which is
14213 what ld.so needs, and now have a bigger stub to
14214 support automatic multiple TOCs. */
14215 dyn.d_un.d_ptr += GLINK_CALL_STUB_SIZE - 32;
14216 break;
14217
14218 case DT_PPC64_OPD:
14219 s = bfd_get_section_by_name (output_bfd, ".opd");
14220 if (s == NULL)
14221 continue;
14222 dyn.d_un.d_ptr = s->vma;
14223 break;
14224
14225 case DT_PPC64_OPDSZ:
14226 s = bfd_get_section_by_name (output_bfd, ".opd");
14227 if (s == NULL)
14228 continue;
14229 dyn.d_un.d_val = s->size;
14230 break;
14231
14232 case DT_PLTGOT:
14233 s = htab->plt;
14234 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
14235 break;
14236
14237 case DT_JMPREL:
14238 s = htab->relplt;
14239 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
14240 break;
14241
14242 case DT_PLTRELSZ:
14243 dyn.d_un.d_val = htab->relplt->size;
14244 break;
14245
14246 case DT_RELASZ:
14247 /* Don't count procedure linkage table relocs in the
14248 overall reloc count. */
14249 s = htab->relplt;
14250 if (s == NULL)
14251 continue;
14252 dyn.d_un.d_val -= s->size;
14253 break;
14254
14255 case DT_RELA:
14256 /* We may not be using the standard ELF linker script.
14257 If .rela.plt is the first .rela section, we adjust
14258 DT_RELA to not include it. */
14259 s = htab->relplt;
14260 if (s == NULL)
14261 continue;
14262 if (dyn.d_un.d_ptr != s->output_section->vma + s->output_offset)
14263 continue;
14264 dyn.d_un.d_ptr += s->size;
14265 break;
14266 }
14267
14268 bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
14269 }
14270 }
14271
14272 if (htab->got != NULL && htab->got->size != 0)
14273 {
14274 /* Fill in the first entry in the global offset table.
14275 We use it to hold the link-time TOCbase. */
14276 bfd_put_64 (output_bfd,
14277 elf_gp (output_bfd) + TOC_BASE_OFF,
14278 htab->got->contents);
14279
14280 /* Set .got entry size. */
14281 elf_section_data (htab->got->output_section)->this_hdr.sh_entsize = 8;
14282 }
14283
14284 if (htab->plt != NULL && htab->plt->size != 0)
14285 {
14286 /* Set .plt entry size. */
14287 elf_section_data (htab->plt->output_section)->this_hdr.sh_entsize
14288 = PLT_ENTRY_SIZE;
14289 }
14290
14291 /* brlt is SEC_LINKER_CREATED, so we need to write out relocs for
14292 brlt ourselves if emitrelocations. */
14293 if (htab->brlt != NULL
14294 && htab->brlt->reloc_count != 0
14295 && !_bfd_elf_link_output_relocs (output_bfd,
14296 htab->brlt,
14297 elf_section_data (htab->brlt)->rela.hdr,
14298 elf_section_data (htab->brlt)->relocs,
14299 NULL))
14300 return FALSE;
14301
14302 if (htab->glink != NULL
14303 && htab->glink->reloc_count != 0
14304 && !_bfd_elf_link_output_relocs (output_bfd,
14305 htab->glink,
14306 elf_section_data (htab->glink)->rela.hdr,
14307 elf_section_data (htab->glink)->relocs,
14308 NULL))
14309 return FALSE;
14310
14311
14312 if (htab->glink_eh_frame != NULL
14313 && htab->glink_eh_frame->sec_info_type == SEC_INFO_TYPE_EH_FRAME
14314 && !_bfd_elf_write_section_eh_frame (output_bfd, info,
14315 htab->glink_eh_frame,
14316 htab->glink_eh_frame->contents))
14317 return FALSE;
14318
14319 /* We need to handle writing out multiple GOT sections ourselves,
14320 since we didn't add them to DYNOBJ. We know dynobj is the first
14321 bfd. */
14322 while ((dynobj = dynobj->link_next) != NULL)
14323 {
14324 asection *s;
14325
14326 if (!is_ppc64_elf (dynobj))
14327 continue;
14328
14329 s = ppc64_elf_tdata (dynobj)->got;
14330 if (s != NULL
14331 && s->size != 0
14332 && s->output_section != bfd_abs_section_ptr
14333 && !bfd_set_section_contents (output_bfd, s->output_section,
14334 s->contents, s->output_offset,
14335 s->size))
14336 return FALSE;
14337 s = ppc64_elf_tdata (dynobj)->relgot;
14338 if (s != NULL
14339 && s->size != 0
14340 && s->output_section != bfd_abs_section_ptr
14341 && !bfd_set_section_contents (output_bfd, s->output_section,
14342 s->contents, s->output_offset,
14343 s->size))
14344 return FALSE;
14345 }
14346
14347 return TRUE;
14348 }
14349
14350 #include "elf64-target.h"
14351
14352 /* FreeBSD support */
14353
14354 #undef TARGET_LITTLE_SYM
14355 #undef TARGET_LITTLE_NAME
14356
14357 #undef TARGET_BIG_SYM
14358 #define TARGET_BIG_SYM bfd_elf64_powerpc_freebsd_vec
14359 #undef TARGET_BIG_NAME
14360 #define TARGET_BIG_NAME "elf64-powerpc-freebsd"
14361
14362 #undef ELF_OSABI
14363 #define ELF_OSABI ELFOSABI_FREEBSD
14364
14365 #undef elf64_bed
14366 #define elf64_bed elf64_powerpc_fbsd_bed
14367
14368 #include "elf64-target.h"
14369
GDB Binutils - Deliverables
This page took 0.699338 seconds and 4 git commands to generate.