projects / deliverable / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
ELFv2 stub, plt and glink changes
[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 ppc64_elf_merge_private_bfd_data
85 #define bfd_elf64_bfd_print_private_bfd_data ppc64_elf_print_private_bfd_data
86 #define bfd_elf64_new_section_hook ppc64_elf_new_section_hook
87 #define bfd_elf64_bfd_link_hash_table_create ppc64_elf_link_hash_table_create
88 #define bfd_elf64_bfd_link_hash_table_free ppc64_elf_link_hash_table_free
89 #define bfd_elf64_get_synthetic_symtab ppc64_elf_get_synthetic_symtab
90 #define bfd_elf64_bfd_link_just_syms ppc64_elf_link_just_syms
91
92 #define elf_backend_object_p ppc64_elf_object_p
93 #define elf_backend_grok_prstatus ppc64_elf_grok_prstatus
94 #define elf_backend_grok_psinfo ppc64_elf_grok_psinfo
95 #define elf_backend_write_core_note ppc64_elf_write_core_note
96 #define elf_backend_create_dynamic_sections ppc64_elf_create_dynamic_sections
97 #define elf_backend_copy_indirect_symbol ppc64_elf_copy_indirect_symbol
98 #define elf_backend_add_symbol_hook ppc64_elf_add_symbol_hook
99 #define elf_backend_check_directives ppc64_elf_process_dot_syms
100 #define elf_backend_notice_as_needed ppc64_elf_notice_as_needed
101 #define elf_backend_archive_symbol_lookup ppc64_elf_archive_symbol_lookup
102 #define elf_backend_check_relocs ppc64_elf_check_relocs
103 #define elf_backend_gc_keep ppc64_elf_gc_keep
104 #define elf_backend_gc_mark_dynamic_ref ppc64_elf_gc_mark_dynamic_ref
105 #define elf_backend_gc_mark_hook ppc64_elf_gc_mark_hook
106 #define elf_backend_gc_sweep_hook ppc64_elf_gc_sweep_hook
107 #define elf_backend_adjust_dynamic_symbol ppc64_elf_adjust_dynamic_symbol
108 #define elf_backend_hide_symbol ppc64_elf_hide_symbol
109 #define elf_backend_maybe_function_sym ppc64_elf_maybe_function_sym
110 #define elf_backend_always_size_sections ppc64_elf_func_desc_adjust
111 #define elf_backend_size_dynamic_sections ppc64_elf_size_dynamic_sections
112 #define elf_backend_init_index_section _bfd_elf_init_2_index_sections
113 #define elf_backend_action_discarded ppc64_elf_action_discarded
114 #define elf_backend_relocate_section ppc64_elf_relocate_section
115 #define elf_backend_finish_dynamic_symbol ppc64_elf_finish_dynamic_symbol
116 #define elf_backend_reloc_type_class ppc64_elf_reloc_type_class
117 #define elf_backend_finish_dynamic_sections ppc64_elf_finish_dynamic_sections
118 #define elf_backend_link_output_symbol_hook ppc64_elf_output_symbol_hook
119 #define elf_backend_special_sections ppc64_elf_special_sections
120 #define elf_backend_post_process_headers _bfd_elf_set_osabi
121 #define elf_backend_merge_symbol_attribute ppc64_elf_merge_symbol_attribute
122
123 /* The name of the dynamic interpreter. This is put in the .interp
124 section. */
125 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
126
127 /* The size in bytes of an entry in the procedure linkage table. */
128 #define PLT_ENTRY_SIZE(htab) (htab->opd_abi ? 24 : 8)
129
130 /* The initial size of the plt reserved for the dynamic linker. */
131 #define PLT_INITIAL_ENTRY_SIZE(htab) (htab->opd_abi ? 24 : 16)
132
133 /* TOC base pointers offset from start of TOC. */
134 #define TOC_BASE_OFF 0x8000
135
136 /* Offset of tp and dtp pointers from start of TLS block. */
137 #define TP_OFFSET 0x7000
138 #define DTP_OFFSET 0x8000
139
140 /* .plt call stub instructions. The normal stub is like this, but
141 sometimes the .plt entry crosses a 64k boundary and we need to
142 insert an addi to adjust r11. */
143 #define STD_R2_40R1 0xf8410028 /* std %r2,40(%r1) */
144 #define ADDIS_R11_R2 0x3d620000 /* addis %r11,%r2,xxx@ha */
145 #define LD_R12_0R11 0xe98b0000 /* ld %r12,xxx+0@l(%r11) */
146 #define MTCTR_R12 0x7d8903a6 /* mtctr %r12 */
147 #define LD_R2_0R11 0xe84b0000 /* ld %r2,xxx+8@l(%r11) */
148 #define LD_R11_0R11 0xe96b0000 /* ld %r11,xxx+16@l(%r11) */
149 #define BCTR 0x4e800420 /* bctr */
150
151 #define ADDI_R11_R11 0x396b0000 /* addi %r11,%r11,off@l */
152 #define ADDIS_R2_R2 0x3c420000 /* addis %r2,%r2,off@ha */
153 #define ADDI_R2_R2 0x38420000 /* addi %r2,%r2,off@l */
154
155 #define XOR_R2_R12_R12 0x7d826278 /* xor %r2,%r12,%r12 */
156 #define ADD_R11_R11_R2 0x7d6b1214 /* add %r11,%r11,%r2 */
157 #define XOR_R11_R12_R12 0x7d8b6278 /* xor %r11,%r12,%r12 */
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_R12_0R2 0xe9820000 /* ld %r12,xxx+0(%r2) */
164 #define LD_R11_0R2 0xe9620000 /* ld %r11,xxx+0(%r2) */
165 #define LD_R2_0R2 0xe8420000 /* ld %r2,xxx+0(%r2) */
166
167 #define LD_R2_40R1 0xe8410028 /* ld %r2,40(%r1) */
168
169 /* glink call stub instructions. We enter with the index in R0. */
170 #define GLINK_CALL_STUB_SIZE (16*4)
171 /* 0: */
172 /* .quad plt0-1f */
173 /* __glink: */
174 #define MFLR_R12 0x7d8802a6 /* mflr %12 */
175 #define BCL_20_31 0x429f0005 /* bcl 20,31,1f */
176 /* 1: */
177 #define MFLR_R11 0x7d6802a6 /* mflr %11 */
178 /* ld %2,(0b-1b)(%11) */
179 #define MTLR_R12 0x7d8803a6 /* mtlr %12 */
180 #define ADD_R11_R2_R11 0x7d625a14 /* add %11,%2,%11 */
181 /* ld %12,0(%11) */
182 /* ld %2,8(%11) */
183 /* mtctr %12 */
184 /* ld %11,16(%11) */
185 /* bctr */
186 #define MFLR_R0 0x7c0802a6 /* mflr %r0 */
187 #define MTLR_R0 0x7c0803a6 /* mtlr %r0 */
188 #define SUB_R12_R12_R11 0x7d8b6050 /* subf %r12,%r11,%r12 */
189 #define ADDI_R0_R12 0x380c0000 /* addi %r0,%r12,0 */
190 #define SRDI_R0_R0_2 0x7800f082 /* rldicl %r0,%r0,62,2 */
191
192 /* Pad with this. */
193 #define NOP 0x60000000
194
195 /* Some other nops. */
196 #define CROR_151515 0x4def7b82
197 #define CROR_313131 0x4ffffb82
198
199 /* .glink entries for the first 32k functions are two instructions. */
200 #define LI_R0_0 0x38000000 /* li %r0,0 */
201 #define B_DOT 0x48000000 /* b . */
202
203 /* After that, we need two instructions to load the index, followed by
204 a branch. */
205 #define LIS_R0_0 0x3c000000 /* lis %r0,0 */
206 #define ORI_R0_R0_0 0x60000000 /* ori %r0,%r0,0 */
207
208 /* Instructions used by the save and restore reg functions. */
209 #define STD_R0_0R1 0xf8010000 /* std %r0,0(%r1) */
210 #define STD_R0_0R12 0xf80c0000 /* std %r0,0(%r12) */
211 #define LD_R0_0R1 0xe8010000 /* ld %r0,0(%r1) */
212 #define LD_R0_0R12 0xe80c0000 /* ld %r0,0(%r12) */
213 #define STFD_FR0_0R1 0xd8010000 /* stfd %fr0,0(%r1) */
214 #define LFD_FR0_0R1 0xc8010000 /* lfd %fr0,0(%r1) */
215 #define LI_R12_0 0x39800000 /* li %r12,0 */
216 #define STVX_VR0_R12_R0 0x7c0c01ce /* stvx %v0,%r12,%r0 */
217 #define LVX_VR0_R12_R0 0x7c0c00ce /* lvx %v0,%r12,%r0 */
218 #define MTLR_R0 0x7c0803a6 /* mtlr %r0 */
219 #define BLR 0x4e800020 /* blr */
220
221 /* Since .opd is an array of descriptors and each entry will end up
222 with identical R_PPC64_RELATIVE relocs, there is really no need to
223 propagate .opd relocs; The dynamic linker should be taught to
224 relocate .opd without reloc entries. */
225 #ifndef NO_OPD_RELOCS
226 #define NO_OPD_RELOCS 0
227 #endif
228 \f
229 #define ONES(n) (((bfd_vma) 1 << ((n) - 1) << 1) - 1)
230
231 /* Relocation HOWTO's. */
232 static reloc_howto_type *ppc64_elf_howto_table[(int) R_PPC64_max];
233
234 static reloc_howto_type ppc64_elf_howto_raw[] = {
235 /* This reloc does nothing. */
236 HOWTO (R_PPC64_NONE, /* type */
237 0, /* rightshift */
238 2, /* size (0 = byte, 1 = short, 2 = long) */
239 32, /* bitsize */
240 FALSE, /* pc_relative */
241 0, /* bitpos */
242 complain_overflow_dont, /* complain_on_overflow */
243 bfd_elf_generic_reloc, /* special_function */
244 "R_PPC64_NONE", /* name */
245 FALSE, /* partial_inplace */
246 0, /* src_mask */
247 0, /* dst_mask */
248 FALSE), /* pcrel_offset */
249
250 /* A standard 32 bit relocation. */
251 HOWTO (R_PPC64_ADDR32, /* type */
252 0, /* rightshift */
253 2, /* size (0 = byte, 1 = short, 2 = long) */
254 32, /* bitsize */
255 FALSE, /* pc_relative */
256 0, /* bitpos */
257 complain_overflow_bitfield, /* complain_on_overflow */
258 bfd_elf_generic_reloc, /* special_function */
259 "R_PPC64_ADDR32", /* name */
260 FALSE, /* partial_inplace */
261 0, /* src_mask */
262 0xffffffff, /* dst_mask */
263 FALSE), /* pcrel_offset */
264
265 /* An absolute 26 bit branch; the lower two bits must be zero.
266 FIXME: we don't check that, we just clear them. */
267 HOWTO (R_PPC64_ADDR24, /* type */
268 0, /* rightshift */
269 2, /* size (0 = byte, 1 = short, 2 = long) */
270 26, /* bitsize */
271 FALSE, /* pc_relative */
272 0, /* bitpos */
273 complain_overflow_bitfield, /* complain_on_overflow */
274 bfd_elf_generic_reloc, /* special_function */
275 "R_PPC64_ADDR24", /* name */
276 FALSE, /* partial_inplace */
277 0, /* src_mask */
278 0x03fffffc, /* dst_mask */
279 FALSE), /* pcrel_offset */
280
281 /* A standard 16 bit relocation. */
282 HOWTO (R_PPC64_ADDR16, /* type */
283 0, /* rightshift */
284 1, /* size (0 = byte, 1 = short, 2 = long) */
285 16, /* bitsize */
286 FALSE, /* pc_relative */
287 0, /* bitpos */
288 complain_overflow_bitfield, /* complain_on_overflow */
289 bfd_elf_generic_reloc, /* special_function */
290 "R_PPC64_ADDR16", /* name */
291 FALSE, /* partial_inplace */
292 0, /* src_mask */
293 0xffff, /* dst_mask */
294 FALSE), /* pcrel_offset */
295
296 /* A 16 bit relocation without overflow. */
297 HOWTO (R_PPC64_ADDR16_LO, /* type */
298 0, /* rightshift */
299 1, /* size (0 = byte, 1 = short, 2 = long) */
300 16, /* bitsize */
301 FALSE, /* pc_relative */
302 0, /* bitpos */
303 complain_overflow_dont,/* complain_on_overflow */
304 bfd_elf_generic_reloc, /* special_function */
305 "R_PPC64_ADDR16_LO", /* name */
306 FALSE, /* partial_inplace */
307 0, /* src_mask */
308 0xffff, /* dst_mask */
309 FALSE), /* pcrel_offset */
310
311 /* Bits 16-31 of an address. */
312 HOWTO (R_PPC64_ADDR16_HI, /* type */
313 16, /* rightshift */
314 1, /* size (0 = byte, 1 = short, 2 = long) */
315 16, /* bitsize */
316 FALSE, /* pc_relative */
317 0, /* bitpos */
318 complain_overflow_signed, /* complain_on_overflow */
319 bfd_elf_generic_reloc, /* special_function */
320 "R_PPC64_ADDR16_HI", /* name */
321 FALSE, /* partial_inplace */
322 0, /* src_mask */
323 0xffff, /* dst_mask */
324 FALSE), /* pcrel_offset */
325
326 /* Bits 16-31 of an address, plus 1 if the contents of the low 16
327 bits, treated as a signed number, is negative. */
328 HOWTO (R_PPC64_ADDR16_HA, /* type */
329 16, /* rightshift */
330 1, /* size (0 = byte, 1 = short, 2 = long) */
331 16, /* bitsize */
332 FALSE, /* pc_relative */
333 0, /* bitpos */
334 complain_overflow_signed, /* complain_on_overflow */
335 ppc64_elf_ha_reloc, /* special_function */
336 "R_PPC64_ADDR16_HA", /* name */
337 FALSE, /* partial_inplace */
338 0, /* src_mask */
339 0xffff, /* dst_mask */
340 FALSE), /* pcrel_offset */
341
342 /* An absolute 16 bit branch; the lower two bits must be zero.
343 FIXME: we don't check that, we just clear them. */
344 HOWTO (R_PPC64_ADDR14, /* type */
345 0, /* rightshift */
346 2, /* size (0 = byte, 1 = short, 2 = long) */
347 16, /* bitsize */
348 FALSE, /* pc_relative */
349 0, /* bitpos */
350 complain_overflow_bitfield, /* complain_on_overflow */
351 ppc64_elf_branch_reloc, /* special_function */
352 "R_PPC64_ADDR14", /* name */
353 FALSE, /* partial_inplace */
354 0, /* src_mask */
355 0x0000fffc, /* dst_mask */
356 FALSE), /* pcrel_offset */
357
358 /* An absolute 16 bit branch, for which bit 10 should be set to
359 indicate that the branch is expected to be taken. The lower two
360 bits must be zero. */
361 HOWTO (R_PPC64_ADDR14_BRTAKEN, /* type */
362 0, /* rightshift */
363 2, /* size (0 = byte, 1 = short, 2 = long) */
364 16, /* bitsize */
365 FALSE, /* pc_relative */
366 0, /* bitpos */
367 complain_overflow_bitfield, /* complain_on_overflow */
368 ppc64_elf_brtaken_reloc, /* special_function */
369 "R_PPC64_ADDR14_BRTAKEN",/* name */
370 FALSE, /* partial_inplace */
371 0, /* src_mask */
372 0x0000fffc, /* dst_mask */
373 FALSE), /* pcrel_offset */
374
375 /* An absolute 16 bit branch, for which bit 10 should be set to
376 indicate that the branch is not expected to be taken. The lower
377 two bits must be zero. */
378 HOWTO (R_PPC64_ADDR14_BRNTAKEN, /* type */
379 0, /* rightshift */
380 2, /* size (0 = byte, 1 = short, 2 = long) */
381 16, /* bitsize */
382 FALSE, /* pc_relative */
383 0, /* bitpos */
384 complain_overflow_bitfield, /* complain_on_overflow */
385 ppc64_elf_brtaken_reloc, /* special_function */
386 "R_PPC64_ADDR14_BRNTAKEN",/* name */
387 FALSE, /* partial_inplace */
388 0, /* src_mask */
389 0x0000fffc, /* dst_mask */
390 FALSE), /* pcrel_offset */
391
392 /* A relative 26 bit branch; the lower two bits must be zero. */
393 HOWTO (R_PPC64_REL24, /* type */
394 0, /* rightshift */
395 2, /* size (0 = byte, 1 = short, 2 = long) */
396 26, /* bitsize */
397 TRUE, /* pc_relative */
398 0, /* bitpos */
399 complain_overflow_signed, /* complain_on_overflow */
400 ppc64_elf_branch_reloc, /* special_function */
401 "R_PPC64_REL24", /* name */
402 FALSE, /* partial_inplace */
403 0, /* src_mask */
404 0x03fffffc, /* dst_mask */
405 TRUE), /* pcrel_offset */
406
407 /* A relative 16 bit branch; the lower two bits must be zero. */
408 HOWTO (R_PPC64_REL14, /* type */
409 0, /* rightshift */
410 2, /* size (0 = byte, 1 = short, 2 = long) */
411 16, /* bitsize */
412 TRUE, /* pc_relative */
413 0, /* bitpos */
414 complain_overflow_signed, /* complain_on_overflow */
415 ppc64_elf_branch_reloc, /* special_function */
416 "R_PPC64_REL14", /* name */
417 FALSE, /* partial_inplace */
418 0, /* src_mask */
419 0x0000fffc, /* dst_mask */
420 TRUE), /* pcrel_offset */
421
422 /* A relative 16 bit branch. Bit 10 should be set to indicate that
423 the branch is expected to be taken. The lower two bits must be
424 zero. */
425 HOWTO (R_PPC64_REL14_BRTAKEN, /* type */
426 0, /* rightshift */
427 2, /* size (0 = byte, 1 = short, 2 = long) */
428 16, /* bitsize */
429 TRUE, /* pc_relative */
430 0, /* bitpos */
431 complain_overflow_signed, /* complain_on_overflow */
432 ppc64_elf_brtaken_reloc, /* special_function */
433 "R_PPC64_REL14_BRTAKEN", /* name */
434 FALSE, /* partial_inplace */
435 0, /* src_mask */
436 0x0000fffc, /* dst_mask */
437 TRUE), /* pcrel_offset */
438
439 /* A relative 16 bit branch. Bit 10 should be set to indicate that
440 the branch is not expected to be taken. The lower two bits must
441 be zero. */
442 HOWTO (R_PPC64_REL14_BRNTAKEN, /* type */
443 0, /* rightshift */
444 2, /* size (0 = byte, 1 = short, 2 = long) */
445 16, /* bitsize */
446 TRUE, /* pc_relative */
447 0, /* bitpos */
448 complain_overflow_signed, /* complain_on_overflow */
449 ppc64_elf_brtaken_reloc, /* special_function */
450 "R_PPC64_REL14_BRNTAKEN",/* name */
451 FALSE, /* partial_inplace */
452 0, /* src_mask */
453 0x0000fffc, /* dst_mask */
454 TRUE), /* pcrel_offset */
455
456 /* Like R_PPC64_ADDR16, but referring to the GOT table entry for the
457 symbol. */
458 HOWTO (R_PPC64_GOT16, /* type */
459 0, /* rightshift */
460 1, /* size (0 = byte, 1 = short, 2 = long) */
461 16, /* bitsize */
462 FALSE, /* pc_relative */
463 0, /* bitpos */
464 complain_overflow_signed, /* complain_on_overflow */
465 ppc64_elf_unhandled_reloc, /* special_function */
466 "R_PPC64_GOT16", /* name */
467 FALSE, /* partial_inplace */
468 0, /* src_mask */
469 0xffff, /* dst_mask */
470 FALSE), /* pcrel_offset */
471
472 /* Like R_PPC64_ADDR16_LO, but referring to the GOT table entry for
473 the symbol. */
474 HOWTO (R_PPC64_GOT16_LO, /* type */
475 0, /* rightshift */
476 1, /* size (0 = byte, 1 = short, 2 = long) */
477 16, /* bitsize */
478 FALSE, /* pc_relative */
479 0, /* bitpos */
480 complain_overflow_dont, /* complain_on_overflow */
481 ppc64_elf_unhandled_reloc, /* special_function */
482 "R_PPC64_GOT16_LO", /* name */
483 FALSE, /* partial_inplace */
484 0, /* src_mask */
485 0xffff, /* dst_mask */
486 FALSE), /* pcrel_offset */
487
488 /* Like R_PPC64_ADDR16_HI, but referring to the GOT table entry for
489 the symbol. */
490 HOWTO (R_PPC64_GOT16_HI, /* type */
491 16, /* rightshift */
492 1, /* size (0 = byte, 1 = short, 2 = long) */
493 16, /* bitsize */
494 FALSE, /* pc_relative */
495 0, /* bitpos */
496 complain_overflow_signed,/* complain_on_overflow */
497 ppc64_elf_unhandled_reloc, /* special_function */
498 "R_PPC64_GOT16_HI", /* name */
499 FALSE, /* partial_inplace */
500 0, /* src_mask */
501 0xffff, /* dst_mask */
502 FALSE), /* pcrel_offset */
503
504 /* Like R_PPC64_ADDR16_HA, but referring to the GOT table entry for
505 the symbol. */
506 HOWTO (R_PPC64_GOT16_HA, /* type */
507 16, /* rightshift */
508 1, /* size (0 = byte, 1 = short, 2 = long) */
509 16, /* bitsize */
510 FALSE, /* pc_relative */
511 0, /* bitpos */
512 complain_overflow_signed,/* complain_on_overflow */
513 ppc64_elf_unhandled_reloc, /* special_function */
514 "R_PPC64_GOT16_HA", /* name */
515 FALSE, /* partial_inplace */
516 0, /* src_mask */
517 0xffff, /* dst_mask */
518 FALSE), /* pcrel_offset */
519
520 /* This is used only by the dynamic linker. The symbol should exist
521 both in the object being run and in some shared library. The
522 dynamic linker copies the data addressed by the symbol from the
523 shared library into the object, because the object being
524 run has to have the data at some particular address. */
525 HOWTO (R_PPC64_COPY, /* type */
526 0, /* rightshift */
527 0, /* this one is variable size */
528 0, /* bitsize */
529 FALSE, /* pc_relative */
530 0, /* bitpos */
531 complain_overflow_dont, /* complain_on_overflow */
532 ppc64_elf_unhandled_reloc, /* special_function */
533 "R_PPC64_COPY", /* name */
534 FALSE, /* partial_inplace */
535 0, /* src_mask */
536 0, /* dst_mask */
537 FALSE), /* pcrel_offset */
538
539 /* Like R_PPC64_ADDR64, but used when setting global offset table
540 entries. */
541 HOWTO (R_PPC64_GLOB_DAT, /* type */
542 0, /* rightshift */
543 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
544 64, /* bitsize */
545 FALSE, /* pc_relative */
546 0, /* bitpos */
547 complain_overflow_dont, /* complain_on_overflow */
548 ppc64_elf_unhandled_reloc, /* special_function */
549 "R_PPC64_GLOB_DAT", /* name */
550 FALSE, /* partial_inplace */
551 0, /* src_mask */
552 ONES (64), /* dst_mask */
553 FALSE), /* pcrel_offset */
554
555 /* Created by the link editor. Marks a procedure linkage table
556 entry for a symbol. */
557 HOWTO (R_PPC64_JMP_SLOT, /* type */
558 0, /* rightshift */
559 0, /* size (0 = byte, 1 = short, 2 = long) */
560 0, /* bitsize */
561 FALSE, /* pc_relative */
562 0, /* bitpos */
563 complain_overflow_dont, /* complain_on_overflow */
564 ppc64_elf_unhandled_reloc, /* special_function */
565 "R_PPC64_JMP_SLOT", /* name */
566 FALSE, /* partial_inplace */
567 0, /* src_mask */
568 0, /* dst_mask */
569 FALSE), /* pcrel_offset */
570
571 /* Used only by the dynamic linker. When the object is run, this
572 doubleword64 is set to the load address of the object, plus the
573 addend. */
574 HOWTO (R_PPC64_RELATIVE, /* type */
575 0, /* rightshift */
576 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
577 64, /* bitsize */
578 FALSE, /* pc_relative */
579 0, /* bitpos */
580 complain_overflow_dont, /* complain_on_overflow */
581 bfd_elf_generic_reloc, /* special_function */
582 "R_PPC64_RELATIVE", /* name */
583 FALSE, /* partial_inplace */
584 0, /* src_mask */
585 ONES (64), /* dst_mask */
586 FALSE), /* pcrel_offset */
587
588 /* Like R_PPC64_ADDR32, but may be unaligned. */
589 HOWTO (R_PPC64_UADDR32, /* type */
590 0, /* rightshift */
591 2, /* size (0 = byte, 1 = short, 2 = long) */
592 32, /* bitsize */
593 FALSE, /* pc_relative */
594 0, /* bitpos */
595 complain_overflow_bitfield, /* complain_on_overflow */
596 bfd_elf_generic_reloc, /* special_function */
597 "R_PPC64_UADDR32", /* name */
598 FALSE, /* partial_inplace */
599 0, /* src_mask */
600 0xffffffff, /* dst_mask */
601 FALSE), /* pcrel_offset */
602
603 /* Like R_PPC64_ADDR16, but may be unaligned. */
604 HOWTO (R_PPC64_UADDR16, /* type */
605 0, /* rightshift */
606 1, /* size (0 = byte, 1 = short, 2 = long) */
607 16, /* bitsize */
608 FALSE, /* pc_relative */
609 0, /* bitpos */
610 complain_overflow_bitfield, /* complain_on_overflow */
611 bfd_elf_generic_reloc, /* special_function */
612 "R_PPC64_UADDR16", /* name */
613 FALSE, /* partial_inplace */
614 0, /* src_mask */
615 0xffff, /* dst_mask */
616 FALSE), /* pcrel_offset */
617
618 /* 32-bit PC relative. */
619 HOWTO (R_PPC64_REL32, /* type */
620 0, /* rightshift */
621 2, /* size (0 = byte, 1 = short, 2 = long) */
622 32, /* bitsize */
623 TRUE, /* pc_relative */
624 0, /* bitpos */
625 /* FIXME: Verify. Was complain_overflow_bitfield. */
626 complain_overflow_signed, /* complain_on_overflow */
627 bfd_elf_generic_reloc, /* special_function */
628 "R_PPC64_REL32", /* name */
629 FALSE, /* partial_inplace */
630 0, /* src_mask */
631 0xffffffff, /* dst_mask */
632 TRUE), /* pcrel_offset */
633
634 /* 32-bit relocation to the symbol's procedure linkage table. */
635 HOWTO (R_PPC64_PLT32, /* type */
636 0, /* rightshift */
637 2, /* size (0 = byte, 1 = short, 2 = long) */
638 32, /* bitsize */
639 FALSE, /* pc_relative */
640 0, /* bitpos */
641 complain_overflow_bitfield, /* complain_on_overflow */
642 ppc64_elf_unhandled_reloc, /* special_function */
643 "R_PPC64_PLT32", /* name */
644 FALSE, /* partial_inplace */
645 0, /* src_mask */
646 0xffffffff, /* dst_mask */
647 FALSE), /* pcrel_offset */
648
649 /* 32-bit PC relative relocation to the symbol's procedure linkage table.
650 FIXME: R_PPC64_PLTREL32 not supported. */
651 HOWTO (R_PPC64_PLTREL32, /* type */
652 0, /* rightshift */
653 2, /* size (0 = byte, 1 = short, 2 = long) */
654 32, /* bitsize */
655 TRUE, /* pc_relative */
656 0, /* bitpos */
657 complain_overflow_signed, /* complain_on_overflow */
658 bfd_elf_generic_reloc, /* special_function */
659 "R_PPC64_PLTREL32", /* name */
660 FALSE, /* partial_inplace */
661 0, /* src_mask */
662 0xffffffff, /* dst_mask */
663 TRUE), /* pcrel_offset */
664
665 /* Like R_PPC64_ADDR16_LO, but referring to the PLT table entry for
666 the symbol. */
667 HOWTO (R_PPC64_PLT16_LO, /* type */
668 0, /* rightshift */
669 1, /* size (0 = byte, 1 = short, 2 = long) */
670 16, /* bitsize */
671 FALSE, /* pc_relative */
672 0, /* bitpos */
673 complain_overflow_dont, /* complain_on_overflow */
674 ppc64_elf_unhandled_reloc, /* special_function */
675 "R_PPC64_PLT16_LO", /* name */
676 FALSE, /* partial_inplace */
677 0, /* src_mask */
678 0xffff, /* dst_mask */
679 FALSE), /* pcrel_offset */
680
681 /* Like R_PPC64_ADDR16_HI, but referring to the PLT table entry for
682 the symbol. */
683 HOWTO (R_PPC64_PLT16_HI, /* type */
684 16, /* rightshift */
685 1, /* size (0 = byte, 1 = short, 2 = long) */
686 16, /* bitsize */
687 FALSE, /* pc_relative */
688 0, /* bitpos */
689 complain_overflow_signed, /* complain_on_overflow */
690 ppc64_elf_unhandled_reloc, /* special_function */
691 "R_PPC64_PLT16_HI", /* name */
692 FALSE, /* partial_inplace */
693 0, /* src_mask */
694 0xffff, /* dst_mask */
695 FALSE), /* pcrel_offset */
696
697 /* Like R_PPC64_ADDR16_HA, but referring to the PLT table entry for
698 the symbol. */
699 HOWTO (R_PPC64_PLT16_HA, /* type */
700 16, /* rightshift */
701 1, /* size (0 = byte, 1 = short, 2 = long) */
702 16, /* bitsize */
703 FALSE, /* pc_relative */
704 0, /* bitpos */
705 complain_overflow_signed, /* complain_on_overflow */
706 ppc64_elf_unhandled_reloc, /* special_function */
707 "R_PPC64_PLT16_HA", /* name */
708 FALSE, /* partial_inplace */
709 0, /* src_mask */
710 0xffff, /* dst_mask */
711 FALSE), /* pcrel_offset */
712
713 /* 16-bit section relative relocation. */
714 HOWTO (R_PPC64_SECTOFF, /* type */
715 0, /* rightshift */
716 1, /* size (0 = byte, 1 = short, 2 = long) */
717 16, /* bitsize */
718 FALSE, /* pc_relative */
719 0, /* bitpos */
720 complain_overflow_bitfield, /* complain_on_overflow */
721 ppc64_elf_sectoff_reloc, /* special_function */
722 "R_PPC64_SECTOFF", /* name */
723 FALSE, /* partial_inplace */
724 0, /* src_mask */
725 0xffff, /* dst_mask */
726 FALSE), /* pcrel_offset */
727
728 /* Like R_PPC64_SECTOFF, but no overflow warning. */
729 HOWTO (R_PPC64_SECTOFF_LO, /* type */
730 0, /* rightshift */
731 1, /* size (0 = byte, 1 = short, 2 = long) */
732 16, /* bitsize */
733 FALSE, /* pc_relative */
734 0, /* bitpos */
735 complain_overflow_dont, /* complain_on_overflow */
736 ppc64_elf_sectoff_reloc, /* special_function */
737 "R_PPC64_SECTOFF_LO", /* name */
738 FALSE, /* partial_inplace */
739 0, /* src_mask */
740 0xffff, /* dst_mask */
741 FALSE), /* pcrel_offset */
742
743 /* 16-bit upper half section relative relocation. */
744 HOWTO (R_PPC64_SECTOFF_HI, /* type */
745 16, /* rightshift */
746 1, /* size (0 = byte, 1 = short, 2 = long) */
747 16, /* bitsize */
748 FALSE, /* pc_relative */
749 0, /* bitpos */
750 complain_overflow_signed, /* complain_on_overflow */
751 ppc64_elf_sectoff_reloc, /* special_function */
752 "R_PPC64_SECTOFF_HI", /* name */
753 FALSE, /* partial_inplace */
754 0, /* src_mask */
755 0xffff, /* dst_mask */
756 FALSE), /* pcrel_offset */
757
758 /* 16-bit upper half adjusted section relative relocation. */
759 HOWTO (R_PPC64_SECTOFF_HA, /* type */
760 16, /* rightshift */
761 1, /* size (0 = byte, 1 = short, 2 = long) */
762 16, /* bitsize */
763 FALSE, /* pc_relative */
764 0, /* bitpos */
765 complain_overflow_signed, /* complain_on_overflow */
766 ppc64_elf_sectoff_ha_reloc, /* special_function */
767 "R_PPC64_SECTOFF_HA", /* name */
768 FALSE, /* partial_inplace */
769 0, /* src_mask */
770 0xffff, /* dst_mask */
771 FALSE), /* pcrel_offset */
772
773 /* Like R_PPC64_REL24 without touching the two least significant bits. */
774 HOWTO (R_PPC64_REL30, /* type */
775 2, /* rightshift */
776 2, /* size (0 = byte, 1 = short, 2 = long) */
777 30, /* bitsize */
778 TRUE, /* pc_relative */
779 0, /* bitpos */
780 complain_overflow_dont, /* complain_on_overflow */
781 bfd_elf_generic_reloc, /* special_function */
782 "R_PPC64_REL30", /* name */
783 FALSE, /* partial_inplace */
784 0, /* src_mask */
785 0xfffffffc, /* dst_mask */
786 TRUE), /* pcrel_offset */
787
788 /* Relocs in the 64-bit PowerPC ELF ABI, not in the 32-bit ABI. */
789
790 /* A standard 64-bit relocation. */
791 HOWTO (R_PPC64_ADDR64, /* type */
792 0, /* rightshift */
793 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
794 64, /* bitsize */
795 FALSE, /* pc_relative */
796 0, /* bitpos */
797 complain_overflow_dont, /* complain_on_overflow */
798 bfd_elf_generic_reloc, /* special_function */
799 "R_PPC64_ADDR64", /* name */
800 FALSE, /* partial_inplace */
801 0, /* src_mask */
802 ONES (64), /* dst_mask */
803 FALSE), /* pcrel_offset */
804
805 /* The bits 32-47 of an address. */
806 HOWTO (R_PPC64_ADDR16_HIGHER, /* type */
807 32, /* rightshift */
808 1, /* size (0 = byte, 1 = short, 2 = long) */
809 16, /* bitsize */
810 FALSE, /* pc_relative */
811 0, /* bitpos */
812 complain_overflow_dont, /* complain_on_overflow */
813 bfd_elf_generic_reloc, /* special_function */
814 "R_PPC64_ADDR16_HIGHER", /* name */
815 FALSE, /* partial_inplace */
816 0, /* src_mask */
817 0xffff, /* dst_mask */
818 FALSE), /* pcrel_offset */
819
820 /* The bits 32-47 of an address, plus 1 if the contents of the low
821 16 bits, treated as a signed number, is negative. */
822 HOWTO (R_PPC64_ADDR16_HIGHERA, /* type */
823 32, /* rightshift */
824 1, /* size (0 = byte, 1 = short, 2 = long) */
825 16, /* bitsize */
826 FALSE, /* pc_relative */
827 0, /* bitpos */
828 complain_overflow_dont, /* complain_on_overflow */
829 ppc64_elf_ha_reloc, /* special_function */
830 "R_PPC64_ADDR16_HIGHERA", /* name */
831 FALSE, /* partial_inplace */
832 0, /* src_mask */
833 0xffff, /* dst_mask */
834 FALSE), /* pcrel_offset */
835
836 /* The bits 48-63 of an address. */
837 HOWTO (R_PPC64_ADDR16_HIGHEST,/* type */
838 48, /* rightshift */
839 1, /* size (0 = byte, 1 = short, 2 = long) */
840 16, /* bitsize */
841 FALSE, /* pc_relative */
842 0, /* bitpos */
843 complain_overflow_dont, /* complain_on_overflow */
844 bfd_elf_generic_reloc, /* special_function */
845 "R_PPC64_ADDR16_HIGHEST", /* name */
846 FALSE, /* partial_inplace */
847 0, /* src_mask */
848 0xffff, /* dst_mask */
849 FALSE), /* pcrel_offset */
850
851 /* The bits 48-63 of an address, plus 1 if the contents of the low
852 16 bits, treated as a signed number, is negative. */
853 HOWTO (R_PPC64_ADDR16_HIGHESTA,/* type */
854 48, /* rightshift */
855 1, /* size (0 = byte, 1 = short, 2 = long) */
856 16, /* bitsize */
857 FALSE, /* pc_relative */
858 0, /* bitpos */
859 complain_overflow_dont, /* complain_on_overflow */
860 ppc64_elf_ha_reloc, /* special_function */
861 "R_PPC64_ADDR16_HIGHESTA", /* name */
862 FALSE, /* partial_inplace */
863 0, /* src_mask */
864 0xffff, /* dst_mask */
865 FALSE), /* pcrel_offset */
866
867 /* Like ADDR64, but may be unaligned. */
868 HOWTO (R_PPC64_UADDR64, /* type */
869 0, /* rightshift */
870 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
871 64, /* bitsize */
872 FALSE, /* pc_relative */
873 0, /* bitpos */
874 complain_overflow_dont, /* complain_on_overflow */
875 bfd_elf_generic_reloc, /* special_function */
876 "R_PPC64_UADDR64", /* name */
877 FALSE, /* partial_inplace */
878 0, /* src_mask */
879 ONES (64), /* dst_mask */
880 FALSE), /* pcrel_offset */
881
882 /* 64-bit relative relocation. */
883 HOWTO (R_PPC64_REL64, /* type */
884 0, /* rightshift */
885 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
886 64, /* bitsize */
887 TRUE, /* pc_relative */
888 0, /* bitpos */
889 complain_overflow_dont, /* complain_on_overflow */
890 bfd_elf_generic_reloc, /* special_function */
891 "R_PPC64_REL64", /* name */
892 FALSE, /* partial_inplace */
893 0, /* src_mask */
894 ONES (64), /* dst_mask */
895 TRUE), /* pcrel_offset */
896
897 /* 64-bit relocation to the symbol's procedure linkage table. */
898 HOWTO (R_PPC64_PLT64, /* type */
899 0, /* rightshift */
900 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
901 64, /* bitsize */
902 FALSE, /* pc_relative */
903 0, /* bitpos */
904 complain_overflow_dont, /* complain_on_overflow */
905 ppc64_elf_unhandled_reloc, /* special_function */
906 "R_PPC64_PLT64", /* name */
907 FALSE, /* partial_inplace */
908 0, /* src_mask */
909 ONES (64), /* dst_mask */
910 FALSE), /* pcrel_offset */
911
912 /* 64-bit PC relative relocation to the symbol's procedure linkage
913 table. */
914 /* FIXME: R_PPC64_PLTREL64 not supported. */
915 HOWTO (R_PPC64_PLTREL64, /* type */
916 0, /* rightshift */
917 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
918 64, /* bitsize */
919 TRUE, /* pc_relative */
920 0, /* bitpos */
921 complain_overflow_dont, /* complain_on_overflow */
922 ppc64_elf_unhandled_reloc, /* special_function */
923 "R_PPC64_PLTREL64", /* name */
924 FALSE, /* partial_inplace */
925 0, /* src_mask */
926 ONES (64), /* dst_mask */
927 TRUE), /* pcrel_offset */
928
929 /* 16 bit TOC-relative relocation. */
930
931 /* R_PPC64_TOC16 47 half16* S + A - .TOC. */
932 HOWTO (R_PPC64_TOC16, /* type */
933 0, /* rightshift */
934 1, /* size (0 = byte, 1 = short, 2 = long) */
935 16, /* bitsize */
936 FALSE, /* pc_relative */
937 0, /* bitpos */
938 complain_overflow_signed, /* complain_on_overflow */
939 ppc64_elf_toc_reloc, /* special_function */
940 "R_PPC64_TOC16", /* name */
941 FALSE, /* partial_inplace */
942 0, /* src_mask */
943 0xffff, /* dst_mask */
944 FALSE), /* pcrel_offset */
945
946 /* 16 bit TOC-relative relocation without overflow. */
947
948 /* R_PPC64_TOC16_LO 48 half16 #lo (S + A - .TOC.) */
949 HOWTO (R_PPC64_TOC16_LO, /* type */
950 0, /* rightshift */
951 1, /* size (0 = byte, 1 = short, 2 = long) */
952 16, /* bitsize */
953 FALSE, /* pc_relative */
954 0, /* bitpos */
955 complain_overflow_dont, /* complain_on_overflow */
956 ppc64_elf_toc_reloc, /* special_function */
957 "R_PPC64_TOC16_LO", /* name */
958 FALSE, /* partial_inplace */
959 0, /* src_mask */
960 0xffff, /* dst_mask */
961 FALSE), /* pcrel_offset */
962
963 /* 16 bit TOC-relative relocation, high 16 bits. */
964
965 /* R_PPC64_TOC16_HI 49 half16 #hi (S + A - .TOC.) */
966 HOWTO (R_PPC64_TOC16_HI, /* type */
967 16, /* rightshift */
968 1, /* size (0 = byte, 1 = short, 2 = long) */
969 16, /* bitsize */
970 FALSE, /* pc_relative */
971 0, /* bitpos */
972 complain_overflow_signed, /* complain_on_overflow */
973 ppc64_elf_toc_reloc, /* special_function */
974 "R_PPC64_TOC16_HI", /* name */
975 FALSE, /* partial_inplace */
976 0, /* src_mask */
977 0xffff, /* dst_mask */
978 FALSE), /* pcrel_offset */
979
980 /* 16 bit TOC-relative relocation, high 16 bits, plus 1 if the
981 contents of the low 16 bits, treated as a signed number, is
982 negative. */
983
984 /* R_PPC64_TOC16_HA 50 half16 #ha (S + A - .TOC.) */
985 HOWTO (R_PPC64_TOC16_HA, /* type */
986 16, /* rightshift */
987 1, /* size (0 = byte, 1 = short, 2 = long) */
988 16, /* bitsize */
989 FALSE, /* pc_relative */
990 0, /* bitpos */
991 complain_overflow_signed, /* complain_on_overflow */
992 ppc64_elf_toc_ha_reloc, /* special_function */
993 "R_PPC64_TOC16_HA", /* name */
994 FALSE, /* partial_inplace */
995 0, /* src_mask */
996 0xffff, /* dst_mask */
997 FALSE), /* pcrel_offset */
998
999 /* 64-bit relocation; insert value of TOC base (.TOC.). */
1000
1001 /* R_PPC64_TOC 51 doubleword64 .TOC. */
1002 HOWTO (R_PPC64_TOC, /* type */
1003 0, /* rightshift */
1004 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1005 64, /* bitsize */
1006 FALSE, /* pc_relative */
1007 0, /* bitpos */
1008 complain_overflow_bitfield, /* complain_on_overflow */
1009 ppc64_elf_toc64_reloc, /* special_function */
1010 "R_PPC64_TOC", /* name */
1011 FALSE, /* partial_inplace */
1012 0, /* src_mask */
1013 ONES (64), /* dst_mask */
1014 FALSE), /* pcrel_offset */
1015
1016 /* Like R_PPC64_GOT16, but also informs the link editor that the
1017 value to relocate may (!) refer to a PLT entry which the link
1018 editor (a) may replace with the symbol value. If the link editor
1019 is unable to fully resolve the symbol, it may (b) create a PLT
1020 entry and store the address to the new PLT entry in the GOT.
1021 This permits lazy resolution of function symbols at run time.
1022 The link editor may also skip all of this and just (c) emit a
1023 R_PPC64_GLOB_DAT to tie the symbol to the GOT entry. */
1024 /* FIXME: R_PPC64_PLTGOT16 not implemented. */
1025 HOWTO (R_PPC64_PLTGOT16, /* type */
1026 0, /* rightshift */
1027 1, /* size (0 = byte, 1 = short, 2 = long) */
1028 16, /* bitsize */
1029 FALSE, /* pc_relative */
1030 0, /* bitpos */
1031 complain_overflow_signed, /* complain_on_overflow */
1032 ppc64_elf_unhandled_reloc, /* special_function */
1033 "R_PPC64_PLTGOT16", /* name */
1034 FALSE, /* partial_inplace */
1035 0, /* src_mask */
1036 0xffff, /* dst_mask */
1037 FALSE), /* pcrel_offset */
1038
1039 /* Like R_PPC64_PLTGOT16, but without overflow. */
1040 /* FIXME: R_PPC64_PLTGOT16_LO not implemented. */
1041 HOWTO (R_PPC64_PLTGOT16_LO, /* type */
1042 0, /* rightshift */
1043 1, /* size (0 = byte, 1 = short, 2 = long) */
1044 16, /* bitsize */
1045 FALSE, /* pc_relative */
1046 0, /* bitpos */
1047 complain_overflow_dont, /* complain_on_overflow */
1048 ppc64_elf_unhandled_reloc, /* special_function */
1049 "R_PPC64_PLTGOT16_LO", /* name */
1050 FALSE, /* partial_inplace */
1051 0, /* src_mask */
1052 0xffff, /* dst_mask */
1053 FALSE), /* pcrel_offset */
1054
1055 /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address. */
1056 /* FIXME: R_PPC64_PLTGOT16_HI not implemented. */
1057 HOWTO (R_PPC64_PLTGOT16_HI, /* type */
1058 16, /* rightshift */
1059 1, /* size (0 = byte, 1 = short, 2 = long) */
1060 16, /* bitsize */
1061 FALSE, /* pc_relative */
1062 0, /* bitpos */
1063 complain_overflow_signed, /* complain_on_overflow */
1064 ppc64_elf_unhandled_reloc, /* special_function */
1065 "R_PPC64_PLTGOT16_HI", /* name */
1066 FALSE, /* partial_inplace */
1067 0, /* src_mask */
1068 0xffff, /* dst_mask */
1069 FALSE), /* pcrel_offset */
1070
1071 /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address, plus
1072 1 if the contents of the low 16 bits, treated as a signed number,
1073 is negative. */
1074 /* FIXME: R_PPC64_PLTGOT16_HA not implemented. */
1075 HOWTO (R_PPC64_PLTGOT16_HA, /* type */
1076 16, /* rightshift */
1077 1, /* size (0 = byte, 1 = short, 2 = long) */
1078 16, /* bitsize */
1079 FALSE, /* pc_relative */
1080 0, /* bitpos */
1081 complain_overflow_signed, /* complain_on_overflow */
1082 ppc64_elf_unhandled_reloc, /* special_function */
1083 "R_PPC64_PLTGOT16_HA", /* name */
1084 FALSE, /* partial_inplace */
1085 0, /* src_mask */
1086 0xffff, /* dst_mask */
1087 FALSE), /* pcrel_offset */
1088
1089 /* Like R_PPC64_ADDR16, but for instructions with a DS field. */
1090 HOWTO (R_PPC64_ADDR16_DS, /* type */
1091 0, /* rightshift */
1092 1, /* size (0 = byte, 1 = short, 2 = long) */
1093 16, /* bitsize */
1094 FALSE, /* pc_relative */
1095 0, /* bitpos */
1096 complain_overflow_bitfield, /* complain_on_overflow */
1097 bfd_elf_generic_reloc, /* special_function */
1098 "R_PPC64_ADDR16_DS", /* name */
1099 FALSE, /* partial_inplace */
1100 0, /* src_mask */
1101 0xfffc, /* dst_mask */
1102 FALSE), /* pcrel_offset */
1103
1104 /* Like R_PPC64_ADDR16_LO, but for instructions with a DS field. */
1105 HOWTO (R_PPC64_ADDR16_LO_DS, /* type */
1106 0, /* rightshift */
1107 1, /* size (0 = byte, 1 = short, 2 = long) */
1108 16, /* bitsize */
1109 FALSE, /* pc_relative */
1110 0, /* bitpos */
1111 complain_overflow_dont,/* complain_on_overflow */
1112 bfd_elf_generic_reloc, /* special_function */
1113 "R_PPC64_ADDR16_LO_DS",/* name */
1114 FALSE, /* partial_inplace */
1115 0, /* src_mask */
1116 0xfffc, /* dst_mask */
1117 FALSE), /* pcrel_offset */
1118
1119 /* Like R_PPC64_GOT16, but for instructions with a DS field. */
1120 HOWTO (R_PPC64_GOT16_DS, /* type */
1121 0, /* rightshift */
1122 1, /* size (0 = byte, 1 = short, 2 = long) */
1123 16, /* bitsize */
1124 FALSE, /* pc_relative */
1125 0, /* bitpos */
1126 complain_overflow_signed, /* complain_on_overflow */
1127 ppc64_elf_unhandled_reloc, /* special_function */
1128 "R_PPC64_GOT16_DS", /* name */
1129 FALSE, /* partial_inplace */
1130 0, /* src_mask */
1131 0xfffc, /* dst_mask */
1132 FALSE), /* pcrel_offset */
1133
1134 /* Like R_PPC64_GOT16_LO, but for instructions with a DS field. */
1135 HOWTO (R_PPC64_GOT16_LO_DS, /* type */
1136 0, /* rightshift */
1137 1, /* size (0 = byte, 1 = short, 2 = long) */
1138 16, /* bitsize */
1139 FALSE, /* pc_relative */
1140 0, /* bitpos */
1141 complain_overflow_dont, /* complain_on_overflow */
1142 ppc64_elf_unhandled_reloc, /* special_function */
1143 "R_PPC64_GOT16_LO_DS", /* name */
1144 FALSE, /* partial_inplace */
1145 0, /* src_mask */
1146 0xfffc, /* dst_mask */
1147 FALSE), /* pcrel_offset */
1148
1149 /* Like R_PPC64_PLT16_LO, but for instructions with a DS field. */
1150 HOWTO (R_PPC64_PLT16_LO_DS, /* type */
1151 0, /* rightshift */
1152 1, /* size (0 = byte, 1 = short, 2 = long) */
1153 16, /* bitsize */
1154 FALSE, /* pc_relative */
1155 0, /* bitpos */
1156 complain_overflow_dont, /* complain_on_overflow */
1157 ppc64_elf_unhandled_reloc, /* special_function */
1158 "R_PPC64_PLT16_LO_DS", /* name */
1159 FALSE, /* partial_inplace */
1160 0, /* src_mask */
1161 0xfffc, /* dst_mask */
1162 FALSE), /* pcrel_offset */
1163
1164 /* Like R_PPC64_SECTOFF, but for instructions with a DS field. */
1165 HOWTO (R_PPC64_SECTOFF_DS, /* type */
1166 0, /* rightshift */
1167 1, /* size (0 = byte, 1 = short, 2 = long) */
1168 16, /* bitsize */
1169 FALSE, /* pc_relative */
1170 0, /* bitpos */
1171 complain_overflow_bitfield, /* complain_on_overflow */
1172 ppc64_elf_sectoff_reloc, /* special_function */
1173 "R_PPC64_SECTOFF_DS", /* name */
1174 FALSE, /* partial_inplace */
1175 0, /* src_mask */
1176 0xfffc, /* dst_mask */
1177 FALSE), /* pcrel_offset */
1178
1179 /* Like R_PPC64_SECTOFF_LO, but for instructions with a DS field. */
1180 HOWTO (R_PPC64_SECTOFF_LO_DS, /* type */
1181 0, /* rightshift */
1182 1, /* size (0 = byte, 1 = short, 2 = long) */
1183 16, /* bitsize */
1184 FALSE, /* pc_relative */
1185 0, /* bitpos */
1186 complain_overflow_dont, /* complain_on_overflow */
1187 ppc64_elf_sectoff_reloc, /* special_function */
1188 "R_PPC64_SECTOFF_LO_DS",/* name */
1189 FALSE, /* partial_inplace */
1190 0, /* src_mask */
1191 0xfffc, /* dst_mask */
1192 FALSE), /* pcrel_offset */
1193
1194 /* Like R_PPC64_TOC16, but for instructions with a DS field. */
1195 HOWTO (R_PPC64_TOC16_DS, /* type */
1196 0, /* rightshift */
1197 1, /* size (0 = byte, 1 = short, 2 = long) */
1198 16, /* bitsize */
1199 FALSE, /* pc_relative */
1200 0, /* bitpos */
1201 complain_overflow_signed, /* complain_on_overflow */
1202 ppc64_elf_toc_reloc, /* special_function */
1203 "R_PPC64_TOC16_DS", /* name */
1204 FALSE, /* partial_inplace */
1205 0, /* src_mask */
1206 0xfffc, /* dst_mask */
1207 FALSE), /* pcrel_offset */
1208
1209 /* Like R_PPC64_TOC16_LO, but for instructions with a DS field. */
1210 HOWTO (R_PPC64_TOC16_LO_DS, /* type */
1211 0, /* rightshift */
1212 1, /* size (0 = byte, 1 = short, 2 = long) */
1213 16, /* bitsize */
1214 FALSE, /* pc_relative */
1215 0, /* bitpos */
1216 complain_overflow_dont, /* complain_on_overflow */
1217 ppc64_elf_toc_reloc, /* special_function */
1218 "R_PPC64_TOC16_LO_DS", /* name */
1219 FALSE, /* partial_inplace */
1220 0, /* src_mask */
1221 0xfffc, /* dst_mask */
1222 FALSE), /* pcrel_offset */
1223
1224 /* Like R_PPC64_PLTGOT16, but for instructions with a DS field. */
1225 /* FIXME: R_PPC64_PLTGOT16_DS not implemented. */
1226 HOWTO (R_PPC64_PLTGOT16_DS, /* type */
1227 0, /* rightshift */
1228 1, /* size (0 = byte, 1 = short, 2 = long) */
1229 16, /* bitsize */
1230 FALSE, /* pc_relative */
1231 0, /* bitpos */
1232 complain_overflow_signed, /* complain_on_overflow */
1233 ppc64_elf_unhandled_reloc, /* special_function */
1234 "R_PPC64_PLTGOT16_DS", /* name */
1235 FALSE, /* partial_inplace */
1236 0, /* src_mask */
1237 0xfffc, /* dst_mask */
1238 FALSE), /* pcrel_offset */
1239
1240 /* Like R_PPC64_PLTGOT16_LO, but for instructions with a DS field. */
1241 /* FIXME: R_PPC64_PLTGOT16_LO not implemented. */
1242 HOWTO (R_PPC64_PLTGOT16_LO_DS,/* type */
1243 0, /* rightshift */
1244 1, /* size (0 = byte, 1 = short, 2 = long) */
1245 16, /* bitsize */
1246 FALSE, /* pc_relative */
1247 0, /* bitpos */
1248 complain_overflow_dont, /* complain_on_overflow */
1249 ppc64_elf_unhandled_reloc, /* special_function */
1250 "R_PPC64_PLTGOT16_LO_DS",/* name */
1251 FALSE, /* partial_inplace */
1252 0, /* src_mask */
1253 0xfffc, /* dst_mask */
1254 FALSE), /* pcrel_offset */
1255
1256 /* Marker relocs for TLS. */
1257 HOWTO (R_PPC64_TLS,
1258 0, /* rightshift */
1259 2, /* size (0 = byte, 1 = short, 2 = long) */
1260 32, /* bitsize */
1261 FALSE, /* pc_relative */
1262 0, /* bitpos */
1263 complain_overflow_dont, /* complain_on_overflow */
1264 bfd_elf_generic_reloc, /* special_function */
1265 "R_PPC64_TLS", /* name */
1266 FALSE, /* partial_inplace */
1267 0, /* src_mask */
1268 0, /* dst_mask */
1269 FALSE), /* pcrel_offset */
1270
1271 HOWTO (R_PPC64_TLSGD,
1272 0, /* rightshift */
1273 2, /* size (0 = byte, 1 = short, 2 = long) */
1274 32, /* bitsize */
1275 FALSE, /* pc_relative */
1276 0, /* bitpos */
1277 complain_overflow_dont, /* complain_on_overflow */
1278 bfd_elf_generic_reloc, /* special_function */
1279 "R_PPC64_TLSGD", /* name */
1280 FALSE, /* partial_inplace */
1281 0, /* src_mask */
1282 0, /* dst_mask */
1283 FALSE), /* pcrel_offset */
1284
1285 HOWTO (R_PPC64_TLSLD,
1286 0, /* rightshift */
1287 2, /* size (0 = byte, 1 = short, 2 = long) */
1288 32, /* bitsize */
1289 FALSE, /* pc_relative */
1290 0, /* bitpos */
1291 complain_overflow_dont, /* complain_on_overflow */
1292 bfd_elf_generic_reloc, /* special_function */
1293 "R_PPC64_TLSLD", /* name */
1294 FALSE, /* partial_inplace */
1295 0, /* src_mask */
1296 0, /* dst_mask */
1297 FALSE), /* pcrel_offset */
1298
1299 HOWTO (R_PPC64_TOCSAVE,
1300 0, /* rightshift */
1301 2, /* size (0 = byte, 1 = short, 2 = long) */
1302 32, /* bitsize */
1303 FALSE, /* pc_relative */
1304 0, /* bitpos */
1305 complain_overflow_dont, /* complain_on_overflow */
1306 bfd_elf_generic_reloc, /* special_function */
1307 "R_PPC64_TOCSAVE", /* name */
1308 FALSE, /* partial_inplace */
1309 0, /* src_mask */
1310 0, /* dst_mask */
1311 FALSE), /* pcrel_offset */
1312
1313 /* Computes the load module index of the load module that contains the
1314 definition of its TLS sym. */
1315 HOWTO (R_PPC64_DTPMOD64,
1316 0, /* rightshift */
1317 4, /* size (0 = byte, 1 = short, 2 = long) */
1318 64, /* bitsize */
1319 FALSE, /* pc_relative */
1320 0, /* bitpos */
1321 complain_overflow_dont, /* complain_on_overflow */
1322 ppc64_elf_unhandled_reloc, /* special_function */
1323 "R_PPC64_DTPMOD64", /* name */
1324 FALSE, /* partial_inplace */
1325 0, /* src_mask */
1326 ONES (64), /* dst_mask */
1327 FALSE), /* pcrel_offset */
1328
1329 /* Computes a dtv-relative displacement, the difference between the value
1330 of sym+add and the base address of the thread-local storage block that
1331 contains the definition of sym, minus 0x8000. */
1332 HOWTO (R_PPC64_DTPREL64,
1333 0, /* rightshift */
1334 4, /* size (0 = byte, 1 = short, 2 = long) */
1335 64, /* bitsize */
1336 FALSE, /* pc_relative */
1337 0, /* bitpos */
1338 complain_overflow_dont, /* complain_on_overflow */
1339 ppc64_elf_unhandled_reloc, /* special_function */
1340 "R_PPC64_DTPREL64", /* name */
1341 FALSE, /* partial_inplace */
1342 0, /* src_mask */
1343 ONES (64), /* dst_mask */
1344 FALSE), /* pcrel_offset */
1345
1346 /* A 16 bit dtprel reloc. */
1347 HOWTO (R_PPC64_DTPREL16,
1348 0, /* rightshift */
1349 1, /* size (0 = byte, 1 = short, 2 = long) */
1350 16, /* bitsize */
1351 FALSE, /* pc_relative */
1352 0, /* bitpos */
1353 complain_overflow_signed, /* complain_on_overflow */
1354 ppc64_elf_unhandled_reloc, /* special_function */
1355 "R_PPC64_DTPREL16", /* name */
1356 FALSE, /* partial_inplace */
1357 0, /* src_mask */
1358 0xffff, /* dst_mask */
1359 FALSE), /* pcrel_offset */
1360
1361 /* Like DTPREL16, but no overflow. */
1362 HOWTO (R_PPC64_DTPREL16_LO,
1363 0, /* rightshift */
1364 1, /* size (0 = byte, 1 = short, 2 = long) */
1365 16, /* bitsize */
1366 FALSE, /* pc_relative */
1367 0, /* bitpos */
1368 complain_overflow_dont, /* complain_on_overflow */
1369 ppc64_elf_unhandled_reloc, /* special_function */
1370 "R_PPC64_DTPREL16_LO", /* name */
1371 FALSE, /* partial_inplace */
1372 0, /* src_mask */
1373 0xffff, /* dst_mask */
1374 FALSE), /* pcrel_offset */
1375
1376 /* Like DTPREL16_LO, but next higher group of 16 bits. */
1377 HOWTO (R_PPC64_DTPREL16_HI,
1378 16, /* rightshift */
1379 1, /* size (0 = byte, 1 = short, 2 = long) */
1380 16, /* bitsize */
1381 FALSE, /* pc_relative */
1382 0, /* bitpos */
1383 complain_overflow_signed, /* complain_on_overflow */
1384 ppc64_elf_unhandled_reloc, /* special_function */
1385 "R_PPC64_DTPREL16_HI", /* name */
1386 FALSE, /* partial_inplace */
1387 0, /* src_mask */
1388 0xffff, /* dst_mask */
1389 FALSE), /* pcrel_offset */
1390
1391 /* Like DTPREL16_HI, but adjust for low 16 bits. */
1392 HOWTO (R_PPC64_DTPREL16_HA,
1393 16, /* rightshift */
1394 1, /* size (0 = byte, 1 = short, 2 = long) */
1395 16, /* bitsize */
1396 FALSE, /* pc_relative */
1397 0, /* bitpos */
1398 complain_overflow_signed, /* complain_on_overflow */
1399 ppc64_elf_unhandled_reloc, /* special_function */
1400 "R_PPC64_DTPREL16_HA", /* name */
1401 FALSE, /* partial_inplace */
1402 0, /* src_mask */
1403 0xffff, /* dst_mask */
1404 FALSE), /* pcrel_offset */
1405
1406 /* Like DTPREL16_HI, but next higher group of 16 bits. */
1407 HOWTO (R_PPC64_DTPREL16_HIGHER,
1408 32, /* rightshift */
1409 1, /* size (0 = byte, 1 = short, 2 = long) */
1410 16, /* bitsize */
1411 FALSE, /* pc_relative */
1412 0, /* bitpos */
1413 complain_overflow_dont, /* complain_on_overflow */
1414 ppc64_elf_unhandled_reloc, /* special_function */
1415 "R_PPC64_DTPREL16_HIGHER", /* name */
1416 FALSE, /* partial_inplace */
1417 0, /* src_mask */
1418 0xffff, /* dst_mask */
1419 FALSE), /* pcrel_offset */
1420
1421 /* Like DTPREL16_HIGHER, but adjust for low 16 bits. */
1422 HOWTO (R_PPC64_DTPREL16_HIGHERA,
1423 32, /* rightshift */
1424 1, /* size (0 = byte, 1 = short, 2 = long) */
1425 16, /* bitsize */
1426 FALSE, /* pc_relative */
1427 0, /* bitpos */
1428 complain_overflow_dont, /* complain_on_overflow */
1429 ppc64_elf_unhandled_reloc, /* special_function */
1430 "R_PPC64_DTPREL16_HIGHERA", /* name */
1431 FALSE, /* partial_inplace */
1432 0, /* src_mask */
1433 0xffff, /* dst_mask */
1434 FALSE), /* pcrel_offset */
1435
1436 /* Like DTPREL16_HIGHER, but next higher group of 16 bits. */
1437 HOWTO (R_PPC64_DTPREL16_HIGHEST,
1438 48, /* rightshift */
1439 1, /* size (0 = byte, 1 = short, 2 = long) */
1440 16, /* bitsize */
1441 FALSE, /* pc_relative */
1442 0, /* bitpos */
1443 complain_overflow_dont, /* complain_on_overflow */
1444 ppc64_elf_unhandled_reloc, /* special_function */
1445 "R_PPC64_DTPREL16_HIGHEST", /* name */
1446 FALSE, /* partial_inplace */
1447 0, /* src_mask */
1448 0xffff, /* dst_mask */
1449 FALSE), /* pcrel_offset */
1450
1451 /* Like DTPREL16_HIGHEST, but adjust for low 16 bits. */
1452 HOWTO (R_PPC64_DTPREL16_HIGHESTA,
1453 48, /* rightshift */
1454 1, /* size (0 = byte, 1 = short, 2 = long) */
1455 16, /* bitsize */
1456 FALSE, /* pc_relative */
1457 0, /* bitpos */
1458 complain_overflow_dont, /* complain_on_overflow */
1459 ppc64_elf_unhandled_reloc, /* special_function */
1460 "R_PPC64_DTPREL16_HIGHESTA", /* name */
1461 FALSE, /* partial_inplace */
1462 0, /* src_mask */
1463 0xffff, /* dst_mask */
1464 FALSE), /* pcrel_offset */
1465
1466 /* Like DTPREL16, but for insns with a DS field. */
1467 HOWTO (R_PPC64_DTPREL16_DS,
1468 0, /* rightshift */
1469 1, /* size (0 = byte, 1 = short, 2 = long) */
1470 16, /* bitsize */
1471 FALSE, /* pc_relative */
1472 0, /* bitpos */
1473 complain_overflow_signed, /* complain_on_overflow */
1474 ppc64_elf_unhandled_reloc, /* special_function */
1475 "R_PPC64_DTPREL16_DS", /* name */
1476 FALSE, /* partial_inplace */
1477 0, /* src_mask */
1478 0xfffc, /* dst_mask */
1479 FALSE), /* pcrel_offset */
1480
1481 /* Like DTPREL16_DS, but no overflow. */
1482 HOWTO (R_PPC64_DTPREL16_LO_DS,
1483 0, /* rightshift */
1484 1, /* size (0 = byte, 1 = short, 2 = long) */
1485 16, /* bitsize */
1486 FALSE, /* pc_relative */
1487 0, /* bitpos */
1488 complain_overflow_dont, /* complain_on_overflow */
1489 ppc64_elf_unhandled_reloc, /* special_function */
1490 "R_PPC64_DTPREL16_LO_DS", /* name */
1491 FALSE, /* partial_inplace */
1492 0, /* src_mask */
1493 0xfffc, /* dst_mask */
1494 FALSE), /* pcrel_offset */
1495
1496 /* Computes a tp-relative displacement, the difference between the value of
1497 sym+add and the value of the thread pointer (r13). */
1498 HOWTO (R_PPC64_TPREL64,
1499 0, /* rightshift */
1500 4, /* size (0 = byte, 1 = short, 2 = long) */
1501 64, /* bitsize */
1502 FALSE, /* pc_relative */
1503 0, /* bitpos */
1504 complain_overflow_dont, /* complain_on_overflow */
1505 ppc64_elf_unhandled_reloc, /* special_function */
1506 "R_PPC64_TPREL64", /* name */
1507 FALSE, /* partial_inplace */
1508 0, /* src_mask */
1509 ONES (64), /* dst_mask */
1510 FALSE), /* pcrel_offset */
1511
1512 /* A 16 bit tprel reloc. */
1513 HOWTO (R_PPC64_TPREL16,
1514 0, /* rightshift */
1515 1, /* size (0 = byte, 1 = short, 2 = long) */
1516 16, /* bitsize */
1517 FALSE, /* pc_relative */
1518 0, /* bitpos */
1519 complain_overflow_signed, /* complain_on_overflow */
1520 ppc64_elf_unhandled_reloc, /* special_function */
1521 "R_PPC64_TPREL16", /* name */
1522 FALSE, /* partial_inplace */
1523 0, /* src_mask */
1524 0xffff, /* dst_mask */
1525 FALSE), /* pcrel_offset */
1526
1527 /* Like TPREL16, but no overflow. */
1528 HOWTO (R_PPC64_TPREL16_LO,
1529 0, /* rightshift */
1530 1, /* size (0 = byte, 1 = short, 2 = long) */
1531 16, /* bitsize */
1532 FALSE, /* pc_relative */
1533 0, /* bitpos */
1534 complain_overflow_dont, /* complain_on_overflow */
1535 ppc64_elf_unhandled_reloc, /* special_function */
1536 "R_PPC64_TPREL16_LO", /* name */
1537 FALSE, /* partial_inplace */
1538 0, /* src_mask */
1539 0xffff, /* dst_mask */
1540 FALSE), /* pcrel_offset */
1541
1542 /* Like TPREL16_LO, but next higher group of 16 bits. */
1543 HOWTO (R_PPC64_TPREL16_HI,
1544 16, /* rightshift */
1545 1, /* size (0 = byte, 1 = short, 2 = long) */
1546 16, /* bitsize */
1547 FALSE, /* pc_relative */
1548 0, /* bitpos */
1549 complain_overflow_signed, /* complain_on_overflow */
1550 ppc64_elf_unhandled_reloc, /* special_function */
1551 "R_PPC64_TPREL16_HI", /* name */
1552 FALSE, /* partial_inplace */
1553 0, /* src_mask */
1554 0xffff, /* dst_mask */
1555 FALSE), /* pcrel_offset */
1556
1557 /* Like TPREL16_HI, but adjust for low 16 bits. */
1558 HOWTO (R_PPC64_TPREL16_HA,
1559 16, /* rightshift */
1560 1, /* size (0 = byte, 1 = short, 2 = long) */
1561 16, /* bitsize */
1562 FALSE, /* pc_relative */
1563 0, /* bitpos */
1564 complain_overflow_signed, /* complain_on_overflow */
1565 ppc64_elf_unhandled_reloc, /* special_function */
1566 "R_PPC64_TPREL16_HA", /* name */
1567 FALSE, /* partial_inplace */
1568 0, /* src_mask */
1569 0xffff, /* dst_mask */
1570 FALSE), /* pcrel_offset */
1571
1572 /* Like TPREL16_HI, but next higher group of 16 bits. */
1573 HOWTO (R_PPC64_TPREL16_HIGHER,
1574 32, /* rightshift */
1575 1, /* size (0 = byte, 1 = short, 2 = long) */
1576 16, /* bitsize */
1577 FALSE, /* pc_relative */
1578 0, /* bitpos */
1579 complain_overflow_dont, /* complain_on_overflow */
1580 ppc64_elf_unhandled_reloc, /* special_function */
1581 "R_PPC64_TPREL16_HIGHER", /* name */
1582 FALSE, /* partial_inplace */
1583 0, /* src_mask */
1584 0xffff, /* dst_mask */
1585 FALSE), /* pcrel_offset */
1586
1587 /* Like TPREL16_HIGHER, but adjust for low 16 bits. */
1588 HOWTO (R_PPC64_TPREL16_HIGHERA,
1589 32, /* rightshift */
1590 1, /* size (0 = byte, 1 = short, 2 = long) */
1591 16, /* bitsize */
1592 FALSE, /* pc_relative */
1593 0, /* bitpos */
1594 complain_overflow_dont, /* complain_on_overflow */
1595 ppc64_elf_unhandled_reloc, /* special_function */
1596 "R_PPC64_TPREL16_HIGHERA", /* name */
1597 FALSE, /* partial_inplace */
1598 0, /* src_mask */
1599 0xffff, /* dst_mask */
1600 FALSE), /* pcrel_offset */
1601
1602 /* Like TPREL16_HIGHER, but next higher group of 16 bits. */
1603 HOWTO (R_PPC64_TPREL16_HIGHEST,
1604 48, /* rightshift */
1605 1, /* size (0 = byte, 1 = short, 2 = long) */
1606 16, /* bitsize */
1607 FALSE, /* pc_relative */
1608 0, /* bitpos */
1609 complain_overflow_dont, /* complain_on_overflow */
1610 ppc64_elf_unhandled_reloc, /* special_function */
1611 "R_PPC64_TPREL16_HIGHEST", /* name */
1612 FALSE, /* partial_inplace */
1613 0, /* src_mask */
1614 0xffff, /* dst_mask */
1615 FALSE), /* pcrel_offset */
1616
1617 /* Like TPREL16_HIGHEST, but adjust for low 16 bits. */
1618 HOWTO (R_PPC64_TPREL16_HIGHESTA,
1619 48, /* rightshift */
1620 1, /* size (0 = byte, 1 = short, 2 = long) */
1621 16, /* bitsize */
1622 FALSE, /* pc_relative */
1623 0, /* bitpos */
1624 complain_overflow_dont, /* complain_on_overflow */
1625 ppc64_elf_unhandled_reloc, /* special_function */
1626 "R_PPC64_TPREL16_HIGHESTA", /* name */
1627 FALSE, /* partial_inplace */
1628 0, /* src_mask */
1629 0xffff, /* dst_mask */
1630 FALSE), /* pcrel_offset */
1631
1632 /* Like TPREL16, but for insns with a DS field. */
1633 HOWTO (R_PPC64_TPREL16_DS,
1634 0, /* rightshift */
1635 1, /* size (0 = byte, 1 = short, 2 = long) */
1636 16, /* bitsize */
1637 FALSE, /* pc_relative */
1638 0, /* bitpos */
1639 complain_overflow_signed, /* complain_on_overflow */
1640 ppc64_elf_unhandled_reloc, /* special_function */
1641 "R_PPC64_TPREL16_DS", /* name */
1642 FALSE, /* partial_inplace */
1643 0, /* src_mask */
1644 0xfffc, /* dst_mask */
1645 FALSE), /* pcrel_offset */
1646
1647 /* Like TPREL16_DS, but no overflow. */
1648 HOWTO (R_PPC64_TPREL16_LO_DS,
1649 0, /* rightshift */
1650 1, /* size (0 = byte, 1 = short, 2 = long) */
1651 16, /* bitsize */
1652 FALSE, /* pc_relative */
1653 0, /* bitpos */
1654 complain_overflow_dont, /* complain_on_overflow */
1655 ppc64_elf_unhandled_reloc, /* special_function */
1656 "R_PPC64_TPREL16_LO_DS", /* name */
1657 FALSE, /* partial_inplace */
1658 0, /* src_mask */
1659 0xfffc, /* dst_mask */
1660 FALSE), /* pcrel_offset */
1661
1662 /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1663 with values (sym+add)@dtpmod and (sym+add)@dtprel, and computes the offset
1664 to the first entry relative to the TOC base (r2). */
1665 HOWTO (R_PPC64_GOT_TLSGD16,
1666 0, /* rightshift */
1667 1, /* size (0 = byte, 1 = short, 2 = long) */
1668 16, /* bitsize */
1669 FALSE, /* pc_relative */
1670 0, /* bitpos */
1671 complain_overflow_signed, /* complain_on_overflow */
1672 ppc64_elf_unhandled_reloc, /* special_function */
1673 "R_PPC64_GOT_TLSGD16", /* name */
1674 FALSE, /* partial_inplace */
1675 0, /* src_mask */
1676 0xffff, /* dst_mask */
1677 FALSE), /* pcrel_offset */
1678
1679 /* Like GOT_TLSGD16, but no overflow. */
1680 HOWTO (R_PPC64_GOT_TLSGD16_LO,
1681 0, /* rightshift */
1682 1, /* size (0 = byte, 1 = short, 2 = long) */
1683 16, /* bitsize */
1684 FALSE, /* pc_relative */
1685 0, /* bitpos */
1686 complain_overflow_dont, /* complain_on_overflow */
1687 ppc64_elf_unhandled_reloc, /* special_function */
1688 "R_PPC64_GOT_TLSGD16_LO", /* name */
1689 FALSE, /* partial_inplace */
1690 0, /* src_mask */
1691 0xffff, /* dst_mask */
1692 FALSE), /* pcrel_offset */
1693
1694 /* Like GOT_TLSGD16_LO, but next higher group of 16 bits. */
1695 HOWTO (R_PPC64_GOT_TLSGD16_HI,
1696 16, /* rightshift */
1697 1, /* size (0 = byte, 1 = short, 2 = long) */
1698 16, /* bitsize */
1699 FALSE, /* pc_relative */
1700 0, /* bitpos */
1701 complain_overflow_signed, /* complain_on_overflow */
1702 ppc64_elf_unhandled_reloc, /* special_function */
1703 "R_PPC64_GOT_TLSGD16_HI", /* name */
1704 FALSE, /* partial_inplace */
1705 0, /* src_mask */
1706 0xffff, /* dst_mask */
1707 FALSE), /* pcrel_offset */
1708
1709 /* Like GOT_TLSGD16_HI, but adjust for low 16 bits. */
1710 HOWTO (R_PPC64_GOT_TLSGD16_HA,
1711 16, /* rightshift */
1712 1, /* size (0 = byte, 1 = short, 2 = long) */
1713 16, /* bitsize */
1714 FALSE, /* pc_relative */
1715 0, /* bitpos */
1716 complain_overflow_signed, /* complain_on_overflow */
1717 ppc64_elf_unhandled_reloc, /* special_function */
1718 "R_PPC64_GOT_TLSGD16_HA", /* name */
1719 FALSE, /* partial_inplace */
1720 0, /* src_mask */
1721 0xffff, /* dst_mask */
1722 FALSE), /* pcrel_offset */
1723
1724 /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1725 with values (sym+add)@dtpmod and zero, and computes the offset to the
1726 first entry relative to the TOC base (r2). */
1727 HOWTO (R_PPC64_GOT_TLSLD16,
1728 0, /* rightshift */
1729 1, /* size (0 = byte, 1 = short, 2 = long) */
1730 16, /* bitsize */
1731 FALSE, /* pc_relative */
1732 0, /* bitpos */
1733 complain_overflow_signed, /* complain_on_overflow */
1734 ppc64_elf_unhandled_reloc, /* special_function */
1735 "R_PPC64_GOT_TLSLD16", /* name */
1736 FALSE, /* partial_inplace */
1737 0, /* src_mask */
1738 0xffff, /* dst_mask */
1739 FALSE), /* pcrel_offset */
1740
1741 /* Like GOT_TLSLD16, but no overflow. */
1742 HOWTO (R_PPC64_GOT_TLSLD16_LO,
1743 0, /* rightshift */
1744 1, /* size (0 = byte, 1 = short, 2 = long) */
1745 16, /* bitsize */
1746 FALSE, /* pc_relative */
1747 0, /* bitpos */
1748 complain_overflow_dont, /* complain_on_overflow */
1749 ppc64_elf_unhandled_reloc, /* special_function */
1750 "R_PPC64_GOT_TLSLD16_LO", /* name */
1751 FALSE, /* partial_inplace */
1752 0, /* src_mask */
1753 0xffff, /* dst_mask */
1754 FALSE), /* pcrel_offset */
1755
1756 /* Like GOT_TLSLD16_LO, but next higher group of 16 bits. */
1757 HOWTO (R_PPC64_GOT_TLSLD16_HI,
1758 16, /* rightshift */
1759 1, /* size (0 = byte, 1 = short, 2 = long) */
1760 16, /* bitsize */
1761 FALSE, /* pc_relative */
1762 0, /* bitpos */
1763 complain_overflow_signed, /* complain_on_overflow */
1764 ppc64_elf_unhandled_reloc, /* special_function */
1765 "R_PPC64_GOT_TLSLD16_HI", /* name */
1766 FALSE, /* partial_inplace */
1767 0, /* src_mask */
1768 0xffff, /* dst_mask */
1769 FALSE), /* pcrel_offset */
1770
1771 /* Like GOT_TLSLD16_HI, but adjust for low 16 bits. */
1772 HOWTO (R_PPC64_GOT_TLSLD16_HA,
1773 16, /* rightshift */
1774 1, /* size (0 = byte, 1 = short, 2 = long) */
1775 16, /* bitsize */
1776 FALSE, /* pc_relative */
1777 0, /* bitpos */
1778 complain_overflow_signed, /* complain_on_overflow */
1779 ppc64_elf_unhandled_reloc, /* special_function */
1780 "R_PPC64_GOT_TLSLD16_HA", /* name */
1781 FALSE, /* partial_inplace */
1782 0, /* src_mask */
1783 0xffff, /* dst_mask */
1784 FALSE), /* pcrel_offset */
1785
1786 /* Allocates an entry in the GOT with value (sym+add)@dtprel, and computes
1787 the offset to the entry relative to the TOC base (r2). */
1788 HOWTO (R_PPC64_GOT_DTPREL16_DS,
1789 0, /* rightshift */
1790 1, /* size (0 = byte, 1 = short, 2 = long) */
1791 16, /* bitsize */
1792 FALSE, /* pc_relative */
1793 0, /* bitpos */
1794 complain_overflow_signed, /* complain_on_overflow */
1795 ppc64_elf_unhandled_reloc, /* special_function */
1796 "R_PPC64_GOT_DTPREL16_DS", /* name */
1797 FALSE, /* partial_inplace */
1798 0, /* src_mask */
1799 0xfffc, /* dst_mask */
1800 FALSE), /* pcrel_offset */
1801
1802 /* Like GOT_DTPREL16_DS, but no overflow. */
1803 HOWTO (R_PPC64_GOT_DTPREL16_LO_DS,
1804 0, /* rightshift */
1805 1, /* size (0 = byte, 1 = short, 2 = long) */
1806 16, /* bitsize */
1807 FALSE, /* pc_relative */
1808 0, /* bitpos */
1809 complain_overflow_dont, /* complain_on_overflow */
1810 ppc64_elf_unhandled_reloc, /* special_function */
1811 "R_PPC64_GOT_DTPREL16_LO_DS", /* name */
1812 FALSE, /* partial_inplace */
1813 0, /* src_mask */
1814 0xfffc, /* dst_mask */
1815 FALSE), /* pcrel_offset */
1816
1817 /* Like GOT_DTPREL16_LO_DS, but next higher group of 16 bits. */
1818 HOWTO (R_PPC64_GOT_DTPREL16_HI,
1819 16, /* rightshift */
1820 1, /* size (0 = byte, 1 = short, 2 = long) */
1821 16, /* bitsize */
1822 FALSE, /* pc_relative */
1823 0, /* bitpos */
1824 complain_overflow_signed, /* complain_on_overflow */
1825 ppc64_elf_unhandled_reloc, /* special_function */
1826 "R_PPC64_GOT_DTPREL16_HI", /* name */
1827 FALSE, /* partial_inplace */
1828 0, /* src_mask */
1829 0xffff, /* dst_mask */
1830 FALSE), /* pcrel_offset */
1831
1832 /* Like GOT_DTPREL16_HI, but adjust for low 16 bits. */
1833 HOWTO (R_PPC64_GOT_DTPREL16_HA,
1834 16, /* rightshift */
1835 1, /* size (0 = byte, 1 = short, 2 = long) */
1836 16, /* bitsize */
1837 FALSE, /* pc_relative */
1838 0, /* bitpos */
1839 complain_overflow_signed, /* complain_on_overflow */
1840 ppc64_elf_unhandled_reloc, /* special_function */
1841 "R_PPC64_GOT_DTPREL16_HA", /* name */
1842 FALSE, /* partial_inplace */
1843 0, /* src_mask */
1844 0xffff, /* dst_mask */
1845 FALSE), /* pcrel_offset */
1846
1847 /* Allocates an entry in the GOT with value (sym+add)@tprel, and computes the
1848 offset to the entry relative to the TOC base (r2). */
1849 HOWTO (R_PPC64_GOT_TPREL16_DS,
1850 0, /* rightshift */
1851 1, /* size (0 = byte, 1 = short, 2 = long) */
1852 16, /* bitsize */
1853 FALSE, /* pc_relative */
1854 0, /* bitpos */
1855 complain_overflow_signed, /* complain_on_overflow */
1856 ppc64_elf_unhandled_reloc, /* special_function */
1857 "R_PPC64_GOT_TPREL16_DS", /* name */
1858 FALSE, /* partial_inplace */
1859 0, /* src_mask */
1860 0xfffc, /* dst_mask */
1861 FALSE), /* pcrel_offset */
1862
1863 /* Like GOT_TPREL16_DS, but no overflow. */
1864 HOWTO (R_PPC64_GOT_TPREL16_LO_DS,
1865 0, /* rightshift */
1866 1, /* size (0 = byte, 1 = short, 2 = long) */
1867 16, /* bitsize */
1868 FALSE, /* pc_relative */
1869 0, /* bitpos */
1870 complain_overflow_dont, /* complain_on_overflow */
1871 ppc64_elf_unhandled_reloc, /* special_function */
1872 "R_PPC64_GOT_TPREL16_LO_DS", /* name */
1873 FALSE, /* partial_inplace */
1874 0, /* src_mask */
1875 0xfffc, /* dst_mask */
1876 FALSE), /* pcrel_offset */
1877
1878 /* Like GOT_TPREL16_LO_DS, but next higher group of 16 bits. */
1879 HOWTO (R_PPC64_GOT_TPREL16_HI,
1880 16, /* rightshift */
1881 1, /* size (0 = byte, 1 = short, 2 = long) */
1882 16, /* bitsize */
1883 FALSE, /* pc_relative */
1884 0, /* bitpos */
1885 complain_overflow_signed, /* complain_on_overflow */
1886 ppc64_elf_unhandled_reloc, /* special_function */
1887 "R_PPC64_GOT_TPREL16_HI", /* name */
1888 FALSE, /* partial_inplace */
1889 0, /* src_mask */
1890 0xffff, /* dst_mask */
1891 FALSE), /* pcrel_offset */
1892
1893 /* Like GOT_TPREL16_HI, but adjust for low 16 bits. */
1894 HOWTO (R_PPC64_GOT_TPREL16_HA,
1895 16, /* rightshift */
1896 1, /* size (0 = byte, 1 = short, 2 = long) */
1897 16, /* bitsize */
1898 FALSE, /* pc_relative */
1899 0, /* bitpos */
1900 complain_overflow_signed, /* complain_on_overflow */
1901 ppc64_elf_unhandled_reloc, /* special_function */
1902 "R_PPC64_GOT_TPREL16_HA", /* name */
1903 FALSE, /* partial_inplace */
1904 0, /* src_mask */
1905 0xffff, /* dst_mask */
1906 FALSE), /* pcrel_offset */
1907
1908 HOWTO (R_PPC64_JMP_IREL, /* type */
1909 0, /* rightshift */
1910 0, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1911 0, /* bitsize */
1912 FALSE, /* pc_relative */
1913 0, /* bitpos */
1914 complain_overflow_dont, /* complain_on_overflow */
1915 ppc64_elf_unhandled_reloc, /* special_function */
1916 "R_PPC64_JMP_IREL", /* name */
1917 FALSE, /* partial_inplace */
1918 0, /* src_mask */
1919 0, /* dst_mask */
1920 FALSE), /* pcrel_offset */
1921
1922 HOWTO (R_PPC64_IRELATIVE, /* type */
1923 0, /* rightshift */
1924 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1925 64, /* bitsize */
1926 FALSE, /* pc_relative */
1927 0, /* bitpos */
1928 complain_overflow_dont, /* complain_on_overflow */
1929 bfd_elf_generic_reloc, /* special_function */
1930 "R_PPC64_IRELATIVE", /* name */
1931 FALSE, /* partial_inplace */
1932 0, /* src_mask */
1933 ONES (64), /* dst_mask */
1934 FALSE), /* pcrel_offset */
1935
1936 /* A 16 bit relative relocation. */
1937 HOWTO (R_PPC64_REL16, /* type */
1938 0, /* rightshift */
1939 1, /* size (0 = byte, 1 = short, 2 = long) */
1940 16, /* bitsize */
1941 TRUE, /* pc_relative */
1942 0, /* bitpos */
1943 complain_overflow_bitfield, /* complain_on_overflow */
1944 bfd_elf_generic_reloc, /* special_function */
1945 "R_PPC64_REL16", /* name */
1946 FALSE, /* partial_inplace */
1947 0, /* src_mask */
1948 0xffff, /* dst_mask */
1949 TRUE), /* pcrel_offset */
1950
1951 /* A 16 bit relative relocation without overflow. */
1952 HOWTO (R_PPC64_REL16_LO, /* type */
1953 0, /* rightshift */
1954 1, /* size (0 = byte, 1 = short, 2 = long) */
1955 16, /* bitsize */
1956 TRUE, /* pc_relative */
1957 0, /* bitpos */
1958 complain_overflow_dont,/* complain_on_overflow */
1959 bfd_elf_generic_reloc, /* special_function */
1960 "R_PPC64_REL16_LO", /* name */
1961 FALSE, /* partial_inplace */
1962 0, /* src_mask */
1963 0xffff, /* dst_mask */
1964 TRUE), /* pcrel_offset */
1965
1966 /* The high order 16 bits of a relative address. */
1967 HOWTO (R_PPC64_REL16_HI, /* type */
1968 16, /* rightshift */
1969 1, /* size (0 = byte, 1 = short, 2 = long) */
1970 16, /* bitsize */
1971 TRUE, /* pc_relative */
1972 0, /* bitpos */
1973 complain_overflow_signed, /* complain_on_overflow */
1974 bfd_elf_generic_reloc, /* special_function */
1975 "R_PPC64_REL16_HI", /* name */
1976 FALSE, /* partial_inplace */
1977 0, /* src_mask */
1978 0xffff, /* dst_mask */
1979 TRUE), /* pcrel_offset */
1980
1981 /* The high order 16 bits of a relative address, plus 1 if the contents of
1982 the low 16 bits, treated as a signed number, is negative. */
1983 HOWTO (R_PPC64_REL16_HA, /* type */
1984 16, /* rightshift */
1985 1, /* size (0 = byte, 1 = short, 2 = long) */
1986 16, /* bitsize */
1987 TRUE, /* pc_relative */
1988 0, /* bitpos */
1989 complain_overflow_signed, /* complain_on_overflow */
1990 ppc64_elf_ha_reloc, /* special_function */
1991 "R_PPC64_REL16_HA", /* name */
1992 FALSE, /* partial_inplace */
1993 0, /* src_mask */
1994 0xffff, /* dst_mask */
1995 TRUE), /* pcrel_offset */
1996
1997 /* Like R_PPC64_ADDR16_HI, but no overflow. */
1998 HOWTO (R_PPC64_ADDR16_HIGH, /* type */
1999 16, /* rightshift */
2000 1, /* size (0 = byte, 1 = short, 2 = long) */
2001 16, /* bitsize */
2002 FALSE, /* pc_relative */
2003 0, /* bitpos */
2004 complain_overflow_dont, /* complain_on_overflow */
2005 bfd_elf_generic_reloc, /* special_function */
2006 "R_PPC64_ADDR16_HIGH", /* name */
2007 FALSE, /* partial_inplace */
2008 0, /* src_mask */
2009 0xffff, /* dst_mask */
2010 FALSE), /* pcrel_offset */
2011
2012 /* Like R_PPC64_ADDR16_HA, but no overflow. */
2013 HOWTO (R_PPC64_ADDR16_HIGHA, /* type */
2014 16, /* rightshift */
2015 1, /* size (0 = byte, 1 = short, 2 = long) */
2016 16, /* bitsize */
2017 FALSE, /* pc_relative */
2018 0, /* bitpos */
2019 complain_overflow_dont, /* complain_on_overflow */
2020 ppc64_elf_ha_reloc, /* special_function */
2021 "R_PPC64_ADDR16_HIGHA", /* name */
2022 FALSE, /* partial_inplace */
2023 0, /* src_mask */
2024 0xffff, /* dst_mask */
2025 FALSE), /* pcrel_offset */
2026
2027 /* Like R_PPC64_DTPREL16_HI, but no overflow. */
2028 HOWTO (R_PPC64_DTPREL16_HIGH,
2029 16, /* rightshift */
2030 1, /* size (0 = byte, 1 = short, 2 = long) */
2031 16, /* bitsize */
2032 FALSE, /* pc_relative */
2033 0, /* bitpos */
2034 complain_overflow_dont, /* complain_on_overflow */
2035 ppc64_elf_unhandled_reloc, /* special_function */
2036 "R_PPC64_DTPREL16_HIGH", /* name */
2037 FALSE, /* partial_inplace */
2038 0, /* src_mask */
2039 0xffff, /* dst_mask */
2040 FALSE), /* pcrel_offset */
2041
2042 /* Like R_PPC64_DTPREL16_HA, but no overflow. */
2043 HOWTO (R_PPC64_DTPREL16_HIGHA,
2044 16, /* rightshift */
2045 1, /* size (0 = byte, 1 = short, 2 = long) */
2046 16, /* bitsize */
2047 FALSE, /* pc_relative */
2048 0, /* bitpos */
2049 complain_overflow_dont, /* complain_on_overflow */
2050 ppc64_elf_unhandled_reloc, /* special_function */
2051 "R_PPC64_DTPREL16_HIGHA", /* name */
2052 FALSE, /* partial_inplace */
2053 0, /* src_mask */
2054 0xffff, /* dst_mask */
2055 FALSE), /* pcrel_offset */
2056
2057 /* Like R_PPC64_TPREL16_HI, but no overflow. */
2058 HOWTO (R_PPC64_TPREL16_HIGH,
2059 16, /* rightshift */
2060 1, /* size (0 = byte, 1 = short, 2 = long) */
2061 16, /* bitsize */
2062 FALSE, /* pc_relative */
2063 0, /* bitpos */
2064 complain_overflow_dont, /* complain_on_overflow */
2065 ppc64_elf_unhandled_reloc, /* special_function */
2066 "R_PPC64_TPREL16_HIGH", /* name */
2067 FALSE, /* partial_inplace */
2068 0, /* src_mask */
2069 0xffff, /* dst_mask */
2070 FALSE), /* pcrel_offset */
2071
2072 /* Like R_PPC64_TPREL16_HA, but no overflow. */
2073 HOWTO (R_PPC64_TPREL16_HIGHA,
2074 16, /* rightshift */
2075 1, /* size (0 = byte, 1 = short, 2 = long) */
2076 16, /* bitsize */
2077 FALSE, /* pc_relative */
2078 0, /* bitpos */
2079 complain_overflow_dont, /* complain_on_overflow */
2080 ppc64_elf_unhandled_reloc, /* special_function */
2081 "R_PPC64_TPREL16_HIGHA", /* name */
2082 FALSE, /* partial_inplace */
2083 0, /* src_mask */
2084 0xffff, /* dst_mask */
2085 FALSE), /* pcrel_offset */
2086
2087 /* GNU extension to record C++ vtable hierarchy. */
2088 HOWTO (R_PPC64_GNU_VTINHERIT, /* type */
2089 0, /* rightshift */
2090 0, /* size (0 = byte, 1 = short, 2 = long) */
2091 0, /* bitsize */
2092 FALSE, /* pc_relative */
2093 0, /* bitpos */
2094 complain_overflow_dont, /* complain_on_overflow */
2095 NULL, /* special_function */
2096 "R_PPC64_GNU_VTINHERIT", /* name */
2097 FALSE, /* partial_inplace */
2098 0, /* src_mask */
2099 0, /* dst_mask */
2100 FALSE), /* pcrel_offset */
2101
2102 /* GNU extension to record C++ vtable member usage. */
2103 HOWTO (R_PPC64_GNU_VTENTRY, /* type */
2104 0, /* rightshift */
2105 0, /* size (0 = byte, 1 = short, 2 = long) */
2106 0, /* bitsize */
2107 FALSE, /* pc_relative */
2108 0, /* bitpos */
2109 complain_overflow_dont, /* complain_on_overflow */
2110 NULL, /* special_function */
2111 "R_PPC64_GNU_VTENTRY", /* name */
2112 FALSE, /* partial_inplace */
2113 0, /* src_mask */
2114 0, /* dst_mask */
2115 FALSE), /* pcrel_offset */
2116 };
2117
2118 \f
2119 /* Initialize the ppc64_elf_howto_table, so that linear accesses can
2120 be done. */
2121
2122 static void
2123 ppc_howto_init (void)
2124 {
2125 unsigned int i, type;
2126
2127 for (i = 0;
2128 i < sizeof (ppc64_elf_howto_raw) / sizeof (ppc64_elf_howto_raw[0]);
2129 i++)
2130 {
2131 type = ppc64_elf_howto_raw[i].type;
2132 BFD_ASSERT (type < (sizeof (ppc64_elf_howto_table)
2133 / sizeof (ppc64_elf_howto_table[0])));
2134 ppc64_elf_howto_table[type] = &ppc64_elf_howto_raw[i];
2135 }
2136 }
2137
2138 static reloc_howto_type *
2139 ppc64_elf_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2140 bfd_reloc_code_real_type code)
2141 {
2142 enum elf_ppc64_reloc_type r = R_PPC64_NONE;
2143
2144 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2145 /* Initialize howto table if needed. */
2146 ppc_howto_init ();
2147
2148 switch (code)
2149 {
2150 default:
2151 return NULL;
2152
2153 case BFD_RELOC_NONE: r = R_PPC64_NONE;
2154 break;
2155 case BFD_RELOC_32: r = R_PPC64_ADDR32;
2156 break;
2157 case BFD_RELOC_PPC_BA26: r = R_PPC64_ADDR24;
2158 break;
2159 case BFD_RELOC_16: r = R_PPC64_ADDR16;
2160 break;
2161 case BFD_RELOC_LO16: r = R_PPC64_ADDR16_LO;
2162 break;
2163 case BFD_RELOC_HI16: r = R_PPC64_ADDR16_HI;
2164 break;
2165 case BFD_RELOC_PPC64_ADDR16_HIGH: r = R_PPC64_ADDR16_HIGH;
2166 break;
2167 case BFD_RELOC_HI16_S: r = R_PPC64_ADDR16_HA;
2168 break;
2169 case BFD_RELOC_PPC64_ADDR16_HIGHA: r = R_PPC64_ADDR16_HIGHA;
2170 break;
2171 case BFD_RELOC_PPC_BA16: r = R_PPC64_ADDR14;
2172 break;
2173 case BFD_RELOC_PPC_BA16_BRTAKEN: r = R_PPC64_ADDR14_BRTAKEN;
2174 break;
2175 case BFD_RELOC_PPC_BA16_BRNTAKEN: r = R_PPC64_ADDR14_BRNTAKEN;
2176 break;
2177 case BFD_RELOC_PPC_B26: r = R_PPC64_REL24;
2178 break;
2179 case BFD_RELOC_PPC_B16: r = R_PPC64_REL14;
2180 break;
2181 case BFD_RELOC_PPC_B16_BRTAKEN: r = R_PPC64_REL14_BRTAKEN;
2182 break;
2183 case BFD_RELOC_PPC_B16_BRNTAKEN: r = R_PPC64_REL14_BRNTAKEN;
2184 break;
2185 case BFD_RELOC_16_GOTOFF: r = R_PPC64_GOT16;
2186 break;
2187 case BFD_RELOC_LO16_GOTOFF: r = R_PPC64_GOT16_LO;
2188 break;
2189 case BFD_RELOC_HI16_GOTOFF: r = R_PPC64_GOT16_HI;
2190 break;
2191 case BFD_RELOC_HI16_S_GOTOFF: r = R_PPC64_GOT16_HA;
2192 break;
2193 case BFD_RELOC_PPC_COPY: r = R_PPC64_COPY;
2194 break;
2195 case BFD_RELOC_PPC_GLOB_DAT: r = R_PPC64_GLOB_DAT;
2196 break;
2197 case BFD_RELOC_32_PCREL: r = R_PPC64_REL32;
2198 break;
2199 case BFD_RELOC_32_PLTOFF: r = R_PPC64_PLT32;
2200 break;
2201 case BFD_RELOC_32_PLT_PCREL: r = R_PPC64_PLTREL32;
2202 break;
2203 case BFD_RELOC_LO16_PLTOFF: r = R_PPC64_PLT16_LO;
2204 break;
2205 case BFD_RELOC_HI16_PLTOFF: r = R_PPC64_PLT16_HI;
2206 break;
2207 case BFD_RELOC_HI16_S_PLTOFF: r = R_PPC64_PLT16_HA;
2208 break;
2209 case BFD_RELOC_16_BASEREL: r = R_PPC64_SECTOFF;
2210 break;
2211 case BFD_RELOC_LO16_BASEREL: r = R_PPC64_SECTOFF_LO;
2212 break;
2213 case BFD_RELOC_HI16_BASEREL: r = R_PPC64_SECTOFF_HI;
2214 break;
2215 case BFD_RELOC_HI16_S_BASEREL: r = R_PPC64_SECTOFF_HA;
2216 break;
2217 case BFD_RELOC_CTOR: r = R_PPC64_ADDR64;
2218 break;
2219 case BFD_RELOC_64: r = R_PPC64_ADDR64;
2220 break;
2221 case BFD_RELOC_PPC64_HIGHER: r = R_PPC64_ADDR16_HIGHER;
2222 break;
2223 case BFD_RELOC_PPC64_HIGHER_S: r = R_PPC64_ADDR16_HIGHERA;
2224 break;
2225 case BFD_RELOC_PPC64_HIGHEST: r = R_PPC64_ADDR16_HIGHEST;
2226 break;
2227 case BFD_RELOC_PPC64_HIGHEST_S: r = R_PPC64_ADDR16_HIGHESTA;
2228 break;
2229 case BFD_RELOC_64_PCREL: r = R_PPC64_REL64;
2230 break;
2231 case BFD_RELOC_64_PLTOFF: r = R_PPC64_PLT64;
2232 break;
2233 case BFD_RELOC_64_PLT_PCREL: r = R_PPC64_PLTREL64;
2234 break;
2235 case BFD_RELOC_PPC_TOC16: r = R_PPC64_TOC16;
2236 break;
2237 case BFD_RELOC_PPC64_TOC16_LO: r = R_PPC64_TOC16_LO;
2238 break;
2239 case BFD_RELOC_PPC64_TOC16_HI: r = R_PPC64_TOC16_HI;
2240 break;
2241 case BFD_RELOC_PPC64_TOC16_HA: r = R_PPC64_TOC16_HA;
2242 break;
2243 case BFD_RELOC_PPC64_TOC: r = R_PPC64_TOC;
2244 break;
2245 case BFD_RELOC_PPC64_PLTGOT16: r = R_PPC64_PLTGOT16;
2246 break;
2247 case BFD_RELOC_PPC64_PLTGOT16_LO: r = R_PPC64_PLTGOT16_LO;
2248 break;
2249 case BFD_RELOC_PPC64_PLTGOT16_HI: r = R_PPC64_PLTGOT16_HI;
2250 break;
2251 case BFD_RELOC_PPC64_PLTGOT16_HA: r = R_PPC64_PLTGOT16_HA;
2252 break;
2253 case BFD_RELOC_PPC64_ADDR16_DS: r = R_PPC64_ADDR16_DS;
2254 break;
2255 case BFD_RELOC_PPC64_ADDR16_LO_DS: r = R_PPC64_ADDR16_LO_DS;
2256 break;
2257 case BFD_RELOC_PPC64_GOT16_DS: r = R_PPC64_GOT16_DS;
2258 break;
2259 case BFD_RELOC_PPC64_GOT16_LO_DS: r = R_PPC64_GOT16_LO_DS;
2260 break;
2261 case BFD_RELOC_PPC64_PLT16_LO_DS: r = R_PPC64_PLT16_LO_DS;
2262 break;
2263 case BFD_RELOC_PPC64_SECTOFF_DS: r = R_PPC64_SECTOFF_DS;
2264 break;
2265 case BFD_RELOC_PPC64_SECTOFF_LO_DS: r = R_PPC64_SECTOFF_LO_DS;
2266 break;
2267 case BFD_RELOC_PPC64_TOC16_DS: r = R_PPC64_TOC16_DS;
2268 break;
2269 case BFD_RELOC_PPC64_TOC16_LO_DS: r = R_PPC64_TOC16_LO_DS;
2270 break;
2271 case BFD_RELOC_PPC64_PLTGOT16_DS: r = R_PPC64_PLTGOT16_DS;
2272 break;
2273 case BFD_RELOC_PPC64_PLTGOT16_LO_DS: r = R_PPC64_PLTGOT16_LO_DS;
2274 break;
2275 case BFD_RELOC_PPC_TLS: r = R_PPC64_TLS;
2276 break;
2277 case BFD_RELOC_PPC_TLSGD: r = R_PPC64_TLSGD;
2278 break;
2279 case BFD_RELOC_PPC_TLSLD: r = R_PPC64_TLSLD;
2280 break;
2281 case BFD_RELOC_PPC_DTPMOD: r = R_PPC64_DTPMOD64;
2282 break;
2283 case BFD_RELOC_PPC_TPREL16: r = R_PPC64_TPREL16;
2284 break;
2285 case BFD_RELOC_PPC_TPREL16_LO: r = R_PPC64_TPREL16_LO;
2286 break;
2287 case BFD_RELOC_PPC_TPREL16_HI: r = R_PPC64_TPREL16_HI;
2288 break;
2289 case BFD_RELOC_PPC64_TPREL16_HIGH: r = R_PPC64_TPREL16_HIGH;
2290 break;
2291 case BFD_RELOC_PPC_TPREL16_HA: r = R_PPC64_TPREL16_HA;
2292 break;
2293 case BFD_RELOC_PPC64_TPREL16_HIGHA: r = R_PPC64_TPREL16_HIGHA;
2294 break;
2295 case BFD_RELOC_PPC_TPREL: r = R_PPC64_TPREL64;
2296 break;
2297 case BFD_RELOC_PPC_DTPREL16: r = R_PPC64_DTPREL16;
2298 break;
2299 case BFD_RELOC_PPC_DTPREL16_LO: r = R_PPC64_DTPREL16_LO;
2300 break;
2301 case BFD_RELOC_PPC_DTPREL16_HI: r = R_PPC64_DTPREL16_HI;
2302 break;
2303 case BFD_RELOC_PPC64_DTPREL16_HIGH: r = R_PPC64_DTPREL16_HIGH;
2304 break;
2305 case BFD_RELOC_PPC_DTPREL16_HA: r = R_PPC64_DTPREL16_HA;
2306 break;
2307 case BFD_RELOC_PPC64_DTPREL16_HIGHA: r = R_PPC64_DTPREL16_HIGHA;
2308 break;
2309 case BFD_RELOC_PPC_DTPREL: r = R_PPC64_DTPREL64;
2310 break;
2311 case BFD_RELOC_PPC_GOT_TLSGD16: r = R_PPC64_GOT_TLSGD16;
2312 break;
2313 case BFD_RELOC_PPC_GOT_TLSGD16_LO: r = R_PPC64_GOT_TLSGD16_LO;
2314 break;
2315 case BFD_RELOC_PPC_GOT_TLSGD16_HI: r = R_PPC64_GOT_TLSGD16_HI;
2316 break;
2317 case BFD_RELOC_PPC_GOT_TLSGD16_HA: r = R_PPC64_GOT_TLSGD16_HA;
2318 break;
2319 case BFD_RELOC_PPC_GOT_TLSLD16: r = R_PPC64_GOT_TLSLD16;
2320 break;
2321 case BFD_RELOC_PPC_GOT_TLSLD16_LO: r = R_PPC64_GOT_TLSLD16_LO;
2322 break;
2323 case BFD_RELOC_PPC_GOT_TLSLD16_HI: r = R_PPC64_GOT_TLSLD16_HI;
2324 break;
2325 case BFD_RELOC_PPC_GOT_TLSLD16_HA: r = R_PPC64_GOT_TLSLD16_HA;
2326 break;
2327 case BFD_RELOC_PPC_GOT_TPREL16: r = R_PPC64_GOT_TPREL16_DS;
2328 break;
2329 case BFD_RELOC_PPC_GOT_TPREL16_LO: r = R_PPC64_GOT_TPREL16_LO_DS;
2330 break;
2331 case BFD_RELOC_PPC_GOT_TPREL16_HI: r = R_PPC64_GOT_TPREL16_HI;
2332 break;
2333 case BFD_RELOC_PPC_GOT_TPREL16_HA: r = R_PPC64_GOT_TPREL16_HA;
2334 break;
2335 case BFD_RELOC_PPC_GOT_DTPREL16: r = R_PPC64_GOT_DTPREL16_DS;
2336 break;
2337 case BFD_RELOC_PPC_GOT_DTPREL16_LO: r = R_PPC64_GOT_DTPREL16_LO_DS;
2338 break;
2339 case BFD_RELOC_PPC_GOT_DTPREL16_HI: r = R_PPC64_GOT_DTPREL16_HI;
2340 break;
2341 case BFD_RELOC_PPC_GOT_DTPREL16_HA: r = R_PPC64_GOT_DTPREL16_HA;
2342 break;
2343 case BFD_RELOC_PPC64_TPREL16_DS: r = R_PPC64_TPREL16_DS;
2344 break;
2345 case BFD_RELOC_PPC64_TPREL16_LO_DS: r = R_PPC64_TPREL16_LO_DS;
2346 break;
2347 case BFD_RELOC_PPC64_TPREL16_HIGHER: r = R_PPC64_TPREL16_HIGHER;
2348 break;
2349 case BFD_RELOC_PPC64_TPREL16_HIGHERA: r = R_PPC64_TPREL16_HIGHERA;
2350 break;
2351 case BFD_RELOC_PPC64_TPREL16_HIGHEST: r = R_PPC64_TPREL16_HIGHEST;
2352 break;
2353 case BFD_RELOC_PPC64_TPREL16_HIGHESTA: r = R_PPC64_TPREL16_HIGHESTA;
2354 break;
2355 case BFD_RELOC_PPC64_DTPREL16_DS: r = R_PPC64_DTPREL16_DS;
2356 break;
2357 case BFD_RELOC_PPC64_DTPREL16_LO_DS: r = R_PPC64_DTPREL16_LO_DS;
2358 break;
2359 case BFD_RELOC_PPC64_DTPREL16_HIGHER: r = R_PPC64_DTPREL16_HIGHER;
2360 break;
2361 case BFD_RELOC_PPC64_DTPREL16_HIGHERA: r = R_PPC64_DTPREL16_HIGHERA;
2362 break;
2363 case BFD_RELOC_PPC64_DTPREL16_HIGHEST: r = R_PPC64_DTPREL16_HIGHEST;
2364 break;
2365 case BFD_RELOC_PPC64_DTPREL16_HIGHESTA: r = R_PPC64_DTPREL16_HIGHESTA;
2366 break;
2367 case BFD_RELOC_16_PCREL: r = R_PPC64_REL16;
2368 break;
2369 case BFD_RELOC_LO16_PCREL: r = R_PPC64_REL16_LO;
2370 break;
2371 case BFD_RELOC_HI16_PCREL: r = R_PPC64_REL16_HI;
2372 break;
2373 case BFD_RELOC_HI16_S_PCREL: r = R_PPC64_REL16_HA;
2374 break;
2375 case BFD_RELOC_VTABLE_INHERIT: r = R_PPC64_GNU_VTINHERIT;
2376 break;
2377 case BFD_RELOC_VTABLE_ENTRY: r = R_PPC64_GNU_VTENTRY;
2378 break;
2379 }
2380
2381 return ppc64_elf_howto_table[r];
2382 };
2383
2384 static reloc_howto_type *
2385 ppc64_elf_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2386 const char *r_name)
2387 {
2388 unsigned int i;
2389
2390 for (i = 0;
2391 i < sizeof (ppc64_elf_howto_raw) / sizeof (ppc64_elf_howto_raw[0]);
2392 i++)
2393 if (ppc64_elf_howto_raw[i].name != NULL
2394 && strcasecmp (ppc64_elf_howto_raw[i].name, r_name) == 0)
2395 return &ppc64_elf_howto_raw[i];
2396
2397 return NULL;
2398 }
2399
2400 /* Set the howto pointer for a PowerPC ELF reloc. */
2401
2402 static void
2403 ppc64_elf_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr,
2404 Elf_Internal_Rela *dst)
2405 {
2406 unsigned int type;
2407
2408 /* Initialize howto table if needed. */
2409 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2410 ppc_howto_init ();
2411
2412 type = ELF64_R_TYPE (dst->r_info);
2413 if (type >= (sizeof (ppc64_elf_howto_table)
2414 / sizeof (ppc64_elf_howto_table[0])))
2415 {
2416 (*_bfd_error_handler) (_("%B: invalid relocation type %d"),
2417 abfd, (int) type);
2418 type = R_PPC64_NONE;
2419 }
2420 cache_ptr->howto = ppc64_elf_howto_table[type];
2421 }
2422
2423 /* Handle the R_PPC64_ADDR16_HA and similar relocs. */
2424
2425 static bfd_reloc_status_type
2426 ppc64_elf_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2427 void *data, asection *input_section,
2428 bfd *output_bfd, char **error_message)
2429 {
2430 /* If this is a relocatable link (output_bfd test tells us), just
2431 call the generic function. Any adjustment will be done at final
2432 link time. */
2433 if (output_bfd != NULL)
2434 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2435 input_section, output_bfd, error_message);
2436
2437 /* Adjust the addend for sign extension of the low 16 bits.
2438 We won't actually be using the low 16 bits, so trashing them
2439 doesn't matter. */
2440 reloc_entry->addend += 0x8000;
2441 return bfd_reloc_continue;
2442 }
2443
2444 static bfd_reloc_status_type
2445 ppc64_elf_branch_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2446 void *data, asection *input_section,
2447 bfd *output_bfd, char **error_message)
2448 {
2449 if (output_bfd != NULL)
2450 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2451 input_section, output_bfd, error_message);
2452
2453 if (strcmp (symbol->section->name, ".opd") == 0
2454 && (symbol->section->owner->flags & DYNAMIC) == 0)
2455 {
2456 bfd_vma dest = opd_entry_value (symbol->section,
2457 symbol->value + reloc_entry->addend,
2458 NULL, NULL, FALSE);
2459 if (dest != (bfd_vma) -1)
2460 reloc_entry->addend = dest - (symbol->value
2461 + symbol->section->output_section->vma
2462 + symbol->section->output_offset);
2463 }
2464 return bfd_reloc_continue;
2465 }
2466
2467 static bfd_reloc_status_type
2468 ppc64_elf_brtaken_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2469 void *data, asection *input_section,
2470 bfd *output_bfd, char **error_message)
2471 {
2472 long insn;
2473 enum elf_ppc64_reloc_type r_type;
2474 bfd_size_type octets;
2475 /* Assume 'at' branch hints. */
2476 bfd_boolean is_isa_v2 = TRUE;
2477
2478 /* If this is a relocatable link (output_bfd test tells us), just
2479 call the generic function. Any adjustment will be done at final
2480 link time. */
2481 if (output_bfd != NULL)
2482 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2483 input_section, output_bfd, error_message);
2484
2485 octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2486 insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
2487 insn &= ~(0x01 << 21);
2488 r_type = reloc_entry->howto->type;
2489 if (r_type == R_PPC64_ADDR14_BRTAKEN
2490 || r_type == R_PPC64_REL14_BRTAKEN)
2491 insn |= 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field. */
2492
2493 if (is_isa_v2)
2494 {
2495 /* Set 'a' bit. This is 0b00010 in BO field for branch
2496 on CR(BI) insns (BO == 001at or 011at), and 0b01000
2497 for branch on CTR insns (BO == 1a00t or 1a01t). */
2498 if ((insn & (0x14 << 21)) == (0x04 << 21))
2499 insn |= 0x02 << 21;
2500 else if ((insn & (0x14 << 21)) == (0x10 << 21))
2501 insn |= 0x08 << 21;
2502 else
2503 goto out;
2504 }
2505 else
2506 {
2507 bfd_vma target = 0;
2508 bfd_vma from;
2509
2510 if (!bfd_is_com_section (symbol->section))
2511 target = symbol->value;
2512 target += symbol->section->output_section->vma;
2513 target += symbol->section->output_offset;
2514 target += reloc_entry->addend;
2515
2516 from = (reloc_entry->address
2517 + input_section->output_offset
2518 + input_section->output_section->vma);
2519
2520 /* Invert 'y' bit if not the default. */
2521 if ((bfd_signed_vma) (target - from) < 0)
2522 insn ^= 0x01 << 21;
2523 }
2524 bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
2525 out:
2526 return ppc64_elf_branch_reloc (abfd, reloc_entry, symbol, data,
2527 input_section, output_bfd, error_message);
2528 }
2529
2530 static bfd_reloc_status_type
2531 ppc64_elf_sectoff_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2532 void *data, asection *input_section,
2533 bfd *output_bfd, char **error_message)
2534 {
2535 /* If this is a relocatable link (output_bfd test tells us), just
2536 call the generic function. Any adjustment will be done at final
2537 link time. */
2538 if (output_bfd != NULL)
2539 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2540 input_section, output_bfd, error_message);
2541
2542 /* Subtract the symbol section base address. */
2543 reloc_entry->addend -= symbol->section->output_section->vma;
2544 return bfd_reloc_continue;
2545 }
2546
2547 static bfd_reloc_status_type
2548 ppc64_elf_sectoff_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2549 void *data, asection *input_section,
2550 bfd *output_bfd, char **error_message)
2551 {
2552 /* If this is a relocatable link (output_bfd test tells us), just
2553 call the generic function. Any adjustment will be done at final
2554 link time. */
2555 if (output_bfd != NULL)
2556 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2557 input_section, output_bfd, error_message);
2558
2559 /* Subtract the symbol section base address. */
2560 reloc_entry->addend -= symbol->section->output_section->vma;
2561
2562 /* Adjust the addend for sign extension of the low 16 bits. */
2563 reloc_entry->addend += 0x8000;
2564 return bfd_reloc_continue;
2565 }
2566
2567 static bfd_reloc_status_type
2568 ppc64_elf_toc_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2569 void *data, asection *input_section,
2570 bfd *output_bfd, char **error_message)
2571 {
2572 bfd_vma TOCstart;
2573
2574 /* If this is a relocatable link (output_bfd test tells us), just
2575 call the generic function. Any adjustment will be done at final
2576 link time. */
2577 if (output_bfd != NULL)
2578 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2579 input_section, output_bfd, error_message);
2580
2581 TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2582 if (TOCstart == 0)
2583 TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2584
2585 /* Subtract the TOC base address. */
2586 reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2587 return bfd_reloc_continue;
2588 }
2589
2590 static bfd_reloc_status_type
2591 ppc64_elf_toc_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2592 void *data, asection *input_section,
2593 bfd *output_bfd, char **error_message)
2594 {
2595 bfd_vma TOCstart;
2596
2597 /* If this is a relocatable link (output_bfd test tells us), just
2598 call the generic function. Any adjustment will be done at final
2599 link time. */
2600 if (output_bfd != NULL)
2601 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2602 input_section, output_bfd, error_message);
2603
2604 TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2605 if (TOCstart == 0)
2606 TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2607
2608 /* Subtract the TOC base address. */
2609 reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2610
2611 /* Adjust the addend for sign extension of the low 16 bits. */
2612 reloc_entry->addend += 0x8000;
2613 return bfd_reloc_continue;
2614 }
2615
2616 static bfd_reloc_status_type
2617 ppc64_elf_toc64_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2618 void *data, asection *input_section,
2619 bfd *output_bfd, char **error_message)
2620 {
2621 bfd_vma TOCstart;
2622 bfd_size_type octets;
2623
2624 /* If this is a relocatable link (output_bfd test tells us), just
2625 call the generic function. Any adjustment will be done at final
2626 link time. */
2627 if (output_bfd != NULL)
2628 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2629 input_section, output_bfd, error_message);
2630
2631 TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2632 if (TOCstart == 0)
2633 TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2634
2635 octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2636 bfd_put_64 (abfd, TOCstart + TOC_BASE_OFF, (bfd_byte *) data + octets);
2637 return bfd_reloc_ok;
2638 }
2639
2640 static bfd_reloc_status_type
2641 ppc64_elf_unhandled_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2642 void *data, asection *input_section,
2643 bfd *output_bfd, char **error_message)
2644 {
2645 /* If this is a relocatable link (output_bfd test tells us), just
2646 call the generic function. Any adjustment will be done at final
2647 link time. */
2648 if (output_bfd != NULL)
2649 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2650 input_section, output_bfd, error_message);
2651
2652 if (error_message != NULL)
2653 {
2654 static char buf[60];
2655 sprintf (buf, "generic linker can't handle %s",
2656 reloc_entry->howto->name);
2657 *error_message = buf;
2658 }
2659 return bfd_reloc_dangerous;
2660 }
2661
2662 /* Track GOT entries needed for a given symbol. We might need more
2663 than one got entry per symbol. */
2664 struct got_entry
2665 {
2666 struct got_entry *next;
2667
2668 /* The symbol addend that we'll be placing in the GOT. */
2669 bfd_vma addend;
2670
2671 /* Unlike other ELF targets, we use separate GOT entries for the same
2672 symbol referenced from different input files. This is to support
2673 automatic multiple TOC/GOT sections, where the TOC base can vary
2674 from one input file to another. After partitioning into TOC groups
2675 we merge entries within the group.
2676
2677 Point to the BFD owning this GOT entry. */
2678 bfd *owner;
2679
2680 /* Zero for non-tls entries, or TLS_TLS and one of TLS_GD, TLS_LD,
2681 TLS_TPREL or TLS_DTPREL for tls entries. */
2682 unsigned char tls_type;
2683
2684 /* Non-zero if got.ent points to real entry. */
2685 unsigned char is_indirect;
2686
2687 /* Reference count until size_dynamic_sections, GOT offset thereafter. */
2688 union
2689 {
2690 bfd_signed_vma refcount;
2691 bfd_vma offset;
2692 struct got_entry *ent;
2693 } got;
2694 };
2695
2696 /* The same for PLT. */
2697 struct plt_entry
2698 {
2699 struct plt_entry *next;
2700
2701 bfd_vma addend;
2702
2703 union
2704 {
2705 bfd_signed_vma refcount;
2706 bfd_vma offset;
2707 } plt;
2708 };
2709
2710 struct ppc64_elf_obj_tdata
2711 {
2712 struct elf_obj_tdata elf;
2713
2714 /* Shortcuts to dynamic linker sections. */
2715 asection *got;
2716 asection *relgot;
2717
2718 /* Used during garbage collection. We attach global symbols defined
2719 on removed .opd entries to this section so that the sym is removed. */
2720 asection *deleted_section;
2721
2722 /* TLS local dynamic got entry handling. Support for multiple GOT
2723 sections means we potentially need one of these for each input bfd. */
2724 struct got_entry tlsld_got;
2725
2726 union {
2727 /* A copy of relocs before they are modified for --emit-relocs. */
2728 Elf_Internal_Rela *relocs;
2729
2730 /* Section contents. */
2731 bfd_byte *contents;
2732 } opd;
2733
2734 /* Nonzero if this bfd has small toc/got relocs, ie. that expect
2735 the reloc to be in the range -32768 to 32767. */
2736 unsigned int has_small_toc_reloc : 1;
2737
2738 /* Set if toc/got ha relocs detected not using r2, or lo reloc
2739 instruction not one we handle. */
2740 unsigned int unexpected_toc_insn : 1;
2741 };
2742
2743 #define ppc64_elf_tdata(bfd) \
2744 ((struct ppc64_elf_obj_tdata *) (bfd)->tdata.any)
2745
2746 #define ppc64_tlsld_got(bfd) \
2747 (&ppc64_elf_tdata (bfd)->tlsld_got)
2748
2749 #define is_ppc64_elf(bfd) \
2750 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
2751 && elf_object_id (bfd) == PPC64_ELF_DATA)
2752
2753 /* Override the generic function because we store some extras. */
2754
2755 static bfd_boolean
2756 ppc64_elf_mkobject (bfd *abfd)
2757 {
2758 return bfd_elf_allocate_object (abfd, sizeof (struct ppc64_elf_obj_tdata),
2759 PPC64_ELF_DATA);
2760 }
2761
2762 /* Fix bad default arch selected for a 64 bit input bfd when the
2763 default is 32 bit. */
2764
2765 static bfd_boolean
2766 ppc64_elf_object_p (bfd *abfd)
2767 {
2768 if (abfd->arch_info->the_default && abfd->arch_info->bits_per_word == 32)
2769 {
2770 Elf_Internal_Ehdr *i_ehdr = elf_elfheader (abfd);
2771
2772 if (i_ehdr->e_ident[EI_CLASS] == ELFCLASS64)
2773 {
2774 /* Relies on arch after 32 bit default being 64 bit default. */
2775 abfd->arch_info = abfd->arch_info->next;
2776 BFD_ASSERT (abfd->arch_info->bits_per_word == 64);
2777 }
2778 }
2779 return TRUE;
2780 }
2781
2782 /* Support for core dump NOTE sections. */
2783
2784 static bfd_boolean
2785 ppc64_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
2786 {
2787 size_t offset, size;
2788
2789 if (note->descsz != 504)
2790 return FALSE;
2791
2792 /* pr_cursig */
2793 elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
2794
2795 /* pr_pid */
2796 elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 32);
2797
2798 /* pr_reg */
2799 offset = 112;
2800 size = 384;
2801
2802 /* Make a ".reg/999" section. */
2803 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
2804 size, note->descpos + offset);
2805 }
2806
2807 static bfd_boolean
2808 ppc64_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
2809 {
2810 if (note->descsz != 136)
2811 return FALSE;
2812
2813 elf_tdata (abfd)->core->pid
2814 = bfd_get_32 (abfd, note->descdata + 24);
2815 elf_tdata (abfd)->core->program
2816 = _bfd_elfcore_strndup (abfd, note->descdata + 40, 16);
2817 elf_tdata (abfd)->core->command
2818 = _bfd_elfcore_strndup (abfd, note->descdata + 56, 80);
2819
2820 return TRUE;
2821 }
2822
2823 static char *
2824 ppc64_elf_write_core_note (bfd *abfd, char *buf, int *bufsiz, int note_type,
2825 ...)
2826 {
2827 switch (note_type)
2828 {
2829 default:
2830 return NULL;
2831
2832 case NT_PRPSINFO:
2833 {
2834 char data[136];
2835 va_list ap;
2836
2837 va_start (ap, note_type);
2838 memset (data, 0, sizeof (data));
2839 strncpy (data + 40, va_arg (ap, const char *), 16);
2840 strncpy (data + 56, va_arg (ap, const char *), 80);
2841 va_end (ap);
2842 return elfcore_write_note (abfd, buf, bufsiz,
2843 "CORE", note_type, data, sizeof (data));
2844 }
2845
2846 case NT_PRSTATUS:
2847 {
2848 char data[504];
2849 va_list ap;
2850 long pid;
2851 int cursig;
2852 const void *greg;
2853
2854 va_start (ap, note_type);
2855 memset (data, 0, 112);
2856 pid = va_arg (ap, long);
2857 bfd_put_32 (abfd, pid, data + 32);
2858 cursig = va_arg (ap, int);
2859 bfd_put_16 (abfd, cursig, data + 12);
2860 greg = va_arg (ap, const void *);
2861 memcpy (data + 112, greg, 384);
2862 memset (data + 496, 0, 8);
2863 va_end (ap);
2864 return elfcore_write_note (abfd, buf, bufsiz,
2865 "CORE", note_type, data, sizeof (data));
2866 }
2867 }
2868 }
2869
2870 /* Add extra PPC sections. */
2871
2872 static const struct bfd_elf_special_section ppc64_elf_special_sections[]=
2873 {
2874 { STRING_COMMA_LEN (".plt"), 0, SHT_NOBITS, 0 },
2875 { STRING_COMMA_LEN (".sbss"), -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE },
2876 { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2877 { STRING_COMMA_LEN (".toc"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2878 { STRING_COMMA_LEN (".toc1"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2879 { STRING_COMMA_LEN (".tocbss"), 0, SHT_NOBITS, SHF_ALLOC + SHF_WRITE },
2880 { NULL, 0, 0, 0, 0 }
2881 };
2882
2883 enum _ppc64_sec_type {
2884 sec_normal = 0,
2885 sec_opd = 1,
2886 sec_toc = 2
2887 };
2888
2889 struct _ppc64_elf_section_data
2890 {
2891 struct bfd_elf_section_data elf;
2892
2893 union
2894 {
2895 /* An array with one entry for each opd function descriptor. */
2896 struct _opd_sec_data
2897 {
2898 /* Points to the function code section for local opd entries. */
2899 asection **func_sec;
2900
2901 /* After editing .opd, adjust references to opd local syms. */
2902 long *adjust;
2903 } opd;
2904
2905 /* An array for toc sections, indexed by offset/8. */
2906 struct _toc_sec_data
2907 {
2908 /* Specifies the relocation symbol index used at a given toc offset. */
2909 unsigned *symndx;
2910
2911 /* And the relocation addend. */
2912 bfd_vma *add;
2913 } toc;
2914 } u;
2915
2916 enum _ppc64_sec_type sec_type:2;
2917
2918 /* Flag set when small branches are detected. Used to
2919 select suitable defaults for the stub group size. */
2920 unsigned int has_14bit_branch:1;
2921 };
2922
2923 #define ppc64_elf_section_data(sec) \
2924 ((struct _ppc64_elf_section_data *) elf_section_data (sec))
2925
2926 static bfd_boolean
2927 ppc64_elf_new_section_hook (bfd *abfd, asection *sec)
2928 {
2929 if (!sec->used_by_bfd)
2930 {
2931 struct _ppc64_elf_section_data *sdata;
2932 bfd_size_type amt = sizeof (*sdata);
2933
2934 sdata = bfd_zalloc (abfd, amt);
2935 if (sdata == NULL)
2936 return FALSE;
2937 sec->used_by_bfd = sdata;
2938 }
2939
2940 return _bfd_elf_new_section_hook (abfd, sec);
2941 }
2942
2943 static struct _opd_sec_data *
2944 get_opd_info (asection * sec)
2945 {
2946 if (sec != NULL
2947 && ppc64_elf_section_data (sec) != NULL
2948 && ppc64_elf_section_data (sec)->sec_type == sec_opd)
2949 return &ppc64_elf_section_data (sec)->u.opd;
2950 return NULL;
2951 }
2952
2953 static inline int
2954 abiversion (bfd *abfd)
2955 {
2956 return elf_elfheader (abfd)->e_flags & EF_PPC64_ABI;
2957 }
2958
2959 static inline void
2960 set_abiversion (bfd *abfd, int ver)
2961 {
2962 elf_elfheader (abfd)->e_flags &= ~EF_PPC64_ABI;
2963 elf_elfheader (abfd)->e_flags |= ver & EF_PPC64_ABI;
2964 }
2965 \f
2966 /* Parameters for the qsort hook. */
2967 static bfd_boolean synthetic_relocatable;
2968
2969 /* qsort comparison function for ppc64_elf_get_synthetic_symtab. */
2970
2971 static int
2972 compare_symbols (const void *ap, const void *bp)
2973 {
2974 const asymbol *a = * (const asymbol **) ap;
2975 const asymbol *b = * (const asymbol **) bp;
2976
2977 /* Section symbols first. */
2978 if ((a->flags & BSF_SECTION_SYM) && !(b->flags & BSF_SECTION_SYM))
2979 return -1;
2980 if (!(a->flags & BSF_SECTION_SYM) && (b->flags & BSF_SECTION_SYM))
2981 return 1;
2982
2983 /* then .opd symbols. */
2984 if (strcmp (a->section->name, ".opd") == 0
2985 && strcmp (b->section->name, ".opd") != 0)
2986 return -1;
2987 if (strcmp (a->section->name, ".opd") != 0
2988 && strcmp (b->section->name, ".opd") == 0)
2989 return 1;
2990
2991 /* then other code symbols. */
2992 if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
2993 == (SEC_CODE | SEC_ALLOC)
2994 && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
2995 != (SEC_CODE | SEC_ALLOC))
2996 return -1;
2997
2998 if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
2999 != (SEC_CODE | SEC_ALLOC)
3000 && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3001 == (SEC_CODE | SEC_ALLOC))
3002 return 1;
3003
3004 if (synthetic_relocatable)
3005 {
3006 if (a->section->id < b->section->id)
3007 return -1;
3008
3009 if (a->section->id > b->section->id)
3010 return 1;
3011 }
3012
3013 if (a->value + a->section->vma < b->value + b->section->vma)
3014 return -1;
3015
3016 if (a->value + a->section->vma > b->value + b->section->vma)
3017 return 1;
3018
3019 /* For syms with the same value, prefer strong dynamic global function
3020 syms over other syms. */
3021 if ((a->flags & BSF_GLOBAL) != 0 && (b->flags & BSF_GLOBAL) == 0)
3022 return -1;
3023
3024 if ((a->flags & BSF_GLOBAL) == 0 && (b->flags & BSF_GLOBAL) != 0)
3025 return 1;
3026
3027 if ((a->flags & BSF_FUNCTION) != 0 && (b->flags & BSF_FUNCTION) == 0)
3028 return -1;
3029
3030 if ((a->flags & BSF_FUNCTION) == 0 && (b->flags & BSF_FUNCTION) != 0)
3031 return 1;
3032
3033 if ((a->flags & BSF_WEAK) == 0 && (b->flags & BSF_WEAK) != 0)
3034 return -1;
3035
3036 if ((a->flags & BSF_WEAK) != 0 && (b->flags & BSF_WEAK) == 0)
3037 return 1;
3038
3039 if ((a->flags & BSF_DYNAMIC) != 0 && (b->flags & BSF_DYNAMIC) == 0)
3040 return -1;
3041
3042 if ((a->flags & BSF_DYNAMIC) == 0 && (b->flags & BSF_DYNAMIC) != 0)
3043 return 1;
3044
3045 return 0;
3046 }
3047
3048 /* Search SYMS for a symbol of the given VALUE. */
3049
3050 static asymbol *
3051 sym_exists_at (asymbol **syms, long lo, long hi, int id, bfd_vma value)
3052 {
3053 long mid;
3054
3055 if (id == -1)
3056 {
3057 while (lo < hi)
3058 {
3059 mid = (lo + hi) >> 1;
3060 if (syms[mid]->value + syms[mid]->section->vma < value)
3061 lo = mid + 1;
3062 else if (syms[mid]->value + syms[mid]->section->vma > value)
3063 hi = mid;
3064 else
3065 return syms[mid];
3066 }
3067 }
3068 else
3069 {
3070 while (lo < hi)
3071 {
3072 mid = (lo + hi) >> 1;
3073 if (syms[mid]->section->id < id)
3074 lo = mid + 1;
3075 else if (syms[mid]->section->id > id)
3076 hi = mid;
3077 else if (syms[mid]->value < value)
3078 lo = mid + 1;
3079 else if (syms[mid]->value > value)
3080 hi = mid;
3081 else
3082 return syms[mid];
3083 }
3084 }
3085 return NULL;
3086 }
3087
3088 static bfd_boolean
3089 section_covers_vma (bfd *abfd ATTRIBUTE_UNUSED, asection *section, void *ptr)
3090 {
3091 bfd_vma vma = *(bfd_vma *) ptr;
3092 return ((section->flags & SEC_ALLOC) != 0
3093 && section->vma <= vma
3094 && vma < section->vma + section->size);
3095 }
3096
3097 /* Create synthetic symbols, effectively restoring "dot-symbol" function
3098 entry syms. Also generate @plt symbols for the glink branch table. */
3099
3100 static long
3101 ppc64_elf_get_synthetic_symtab (bfd *abfd,
3102 long static_count, asymbol **static_syms,
3103 long dyn_count, asymbol **dyn_syms,
3104 asymbol **ret)
3105 {
3106 asymbol *s;
3107 long i;
3108 long count;
3109 char *names;
3110 long symcount, codesecsym, codesecsymend, secsymend, opdsymend;
3111 asection *opd = NULL;
3112 bfd_boolean relocatable = (abfd->flags & (EXEC_P | DYNAMIC)) == 0;
3113 asymbol **syms;
3114 int abi = abiversion (abfd);
3115
3116 *ret = NULL;
3117
3118 if (abi < 2)
3119 {
3120 opd = bfd_get_section_by_name (abfd, ".opd");
3121 if (opd == NULL && abi == 1)
3122 return 0;
3123 }
3124
3125 symcount = static_count;
3126 if (!relocatable)
3127 symcount += dyn_count;
3128 if (symcount == 0)
3129 return 0;
3130
3131 syms = bfd_malloc ((symcount + 1) * sizeof (*syms));
3132 if (syms == NULL)
3133 return -1;
3134
3135 if (!relocatable && static_count != 0 && dyn_count != 0)
3136 {
3137 /* Use both symbol tables. */
3138 memcpy (syms, static_syms, static_count * sizeof (*syms));
3139 memcpy (syms + static_count, dyn_syms, (dyn_count + 1) * sizeof (*syms));
3140 }
3141 else if (!relocatable && static_count == 0)
3142 memcpy (syms, dyn_syms, (symcount + 1) * sizeof (*syms));
3143 else
3144 memcpy (syms, static_syms, (symcount + 1) * sizeof (*syms));
3145
3146 synthetic_relocatable = relocatable;
3147 qsort (syms, symcount, sizeof (*syms), compare_symbols);
3148
3149 if (!relocatable && symcount > 1)
3150 {
3151 long j;
3152 /* Trim duplicate syms, since we may have merged the normal and
3153 dynamic symbols. Actually, we only care about syms that have
3154 different values, so trim any with the same value. */
3155 for (i = 1, j = 1; i < symcount; ++i)
3156 if (syms[i - 1]->value + syms[i - 1]->section->vma
3157 != syms[i]->value + syms[i]->section->vma)
3158 syms[j++] = syms[i];
3159 symcount = j;
3160 }
3161
3162 i = 0;
3163 if (strcmp (syms[i]->section->name, ".opd") == 0)
3164 ++i;
3165 codesecsym = i;
3166
3167 for (; i < symcount; ++i)
3168 if (((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3169 != (SEC_CODE | SEC_ALLOC))
3170 || (syms[i]->flags & BSF_SECTION_SYM) == 0)
3171 break;
3172 codesecsymend = i;
3173
3174 for (; i < symcount; ++i)
3175 if ((syms[i]->flags & BSF_SECTION_SYM) == 0)
3176 break;
3177 secsymend = i;
3178
3179 for (; i < symcount; ++i)
3180 if (strcmp (syms[i]->section->name, ".opd") != 0)
3181 break;
3182 opdsymend = i;
3183
3184 for (; i < symcount; ++i)
3185 if ((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3186 != (SEC_CODE | SEC_ALLOC))
3187 break;
3188 symcount = i;
3189
3190 count = 0;
3191
3192 if (relocatable)
3193 {
3194 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3195 arelent *r;
3196 size_t size;
3197 long relcount;
3198
3199 if (opdsymend == secsymend)
3200 goto done;
3201
3202 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3203 relcount = (opd->flags & SEC_RELOC) ? opd->reloc_count : 0;
3204 if (relcount == 0)
3205 goto done;
3206
3207 if (!(*slurp_relocs) (abfd, opd, static_syms, FALSE))
3208 {
3209 count = -1;
3210 goto done;
3211 }
3212
3213 size = 0;
3214 for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3215 {
3216 asymbol *sym;
3217
3218 while (r < opd->relocation + relcount
3219 && r->address < syms[i]->value + opd->vma)
3220 ++r;
3221
3222 if (r == opd->relocation + relcount)
3223 break;
3224
3225 if (r->address != syms[i]->value + opd->vma)
3226 continue;
3227
3228 if (r->howto->type != R_PPC64_ADDR64)
3229 continue;
3230
3231 sym = *r->sym_ptr_ptr;
3232 if (!sym_exists_at (syms, opdsymend, symcount,
3233 sym->section->id, sym->value + r->addend))
3234 {
3235 ++count;
3236 size += sizeof (asymbol);
3237 size += strlen (syms[i]->name) + 2;
3238 }
3239 }
3240
3241 s = *ret = bfd_malloc (size);
3242 if (s == NULL)
3243 {
3244 count = -1;
3245 goto done;
3246 }
3247
3248 names = (char *) (s + count);
3249
3250 for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3251 {
3252 asymbol *sym;
3253
3254 while (r < opd->relocation + relcount
3255 && r->address < syms[i]->value + opd->vma)
3256 ++r;
3257
3258 if (r == opd->relocation + relcount)
3259 break;
3260
3261 if (r->address != syms[i]->value + opd->vma)
3262 continue;
3263
3264 if (r->howto->type != R_PPC64_ADDR64)
3265 continue;
3266
3267 sym = *r->sym_ptr_ptr;
3268 if (!sym_exists_at (syms, opdsymend, symcount,
3269 sym->section->id, sym->value + r->addend))
3270 {
3271 size_t len;
3272
3273 *s = *syms[i];
3274 s->flags |= BSF_SYNTHETIC;
3275 s->section = sym->section;
3276 s->value = sym->value + r->addend;
3277 s->name = names;
3278 *names++ = '.';
3279 len = strlen (syms[i]->name);
3280 memcpy (names, syms[i]->name, len + 1);
3281 names += len + 1;
3282 /* Have udata.p point back to the original symbol this
3283 synthetic symbol was derived from. */
3284 s->udata.p = syms[i];
3285 s++;
3286 }
3287 }
3288 }
3289 else
3290 {
3291 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3292 bfd_byte *contents = NULL;
3293 size_t size;
3294 long plt_count = 0;
3295 bfd_vma glink_vma = 0, resolv_vma = 0;
3296 asection *dynamic, *glink = NULL, *relplt = NULL;
3297 arelent *p;
3298
3299 if (opd != NULL && !bfd_malloc_and_get_section (abfd, opd, &contents))
3300 {
3301 free_contents_and_exit:
3302 if (contents)
3303 free (contents);
3304 count = -1;
3305 goto done;
3306 }
3307
3308 size = 0;
3309 for (i = secsymend; i < opdsymend; ++i)
3310 {
3311 bfd_vma ent;
3312
3313 /* Ignore bogus symbols. */
3314 if (syms[i]->value > opd->size - 8)
3315 continue;
3316
3317 ent = bfd_get_64 (abfd, contents + syms[i]->value);
3318 if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3319 {
3320 ++count;
3321 size += sizeof (asymbol);
3322 size += strlen (syms[i]->name) + 2;
3323 }
3324 }
3325
3326 /* Get start of .glink stubs from DT_PPC64_GLINK. */
3327 if (dyn_count != 0
3328 && (dynamic = bfd_get_section_by_name (abfd, ".dynamic")) != NULL)
3329 {
3330 bfd_byte *dynbuf, *extdyn, *extdynend;
3331 size_t extdynsize;
3332 void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *);
3333
3334 if (!bfd_malloc_and_get_section (abfd, dynamic, &dynbuf))
3335 goto free_contents_and_exit;
3336
3337 extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
3338 swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
3339
3340 extdyn = dynbuf;
3341 extdynend = extdyn + dynamic->size;
3342 for (; extdyn < extdynend; extdyn += extdynsize)
3343 {
3344 Elf_Internal_Dyn dyn;
3345 (*swap_dyn_in) (abfd, extdyn, &dyn);
3346
3347 if (dyn.d_tag == DT_NULL)
3348 break;
3349
3350 if (dyn.d_tag == DT_PPC64_GLINK)
3351 {
3352 /* The first glink stub starts at offset 32; see
3353 comment in ppc64_elf_finish_dynamic_sections. */
3354 glink_vma = dyn.d_un.d_val + GLINK_CALL_STUB_SIZE - 8 * 4;
3355 /* The .glink section usually does not survive the final
3356 link; search for the section (usually .text) where the
3357 glink stubs now reside. */
3358 glink = bfd_sections_find_if (abfd, section_covers_vma,
3359 &glink_vma);
3360 break;
3361 }
3362 }
3363
3364 free (dynbuf);
3365 }
3366
3367 if (glink != NULL)
3368 {
3369 /* Determine __glink trampoline by reading the relative branch
3370 from the first glink stub. */
3371 bfd_byte buf[4];
3372 unsigned int off = 0;
3373
3374 while (bfd_get_section_contents (abfd, glink, buf,
3375 glink_vma + off - glink->vma, 4))
3376 {
3377 unsigned int insn = bfd_get_32 (abfd, buf);
3378 insn ^= B_DOT;
3379 if ((insn & ~0x3fffffc) == 0)
3380 {
3381 resolv_vma = glink_vma + off + (insn ^ 0x2000000) - 0x2000000;
3382 break;
3383 }
3384 off += 4;
3385 if (off > 4)
3386 break;
3387 }
3388
3389 if (resolv_vma)
3390 size += sizeof (asymbol) + sizeof ("__glink_PLTresolve");
3391
3392 relplt = bfd_get_section_by_name (abfd, ".rela.plt");
3393 if (relplt != NULL)
3394 {
3395 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3396 if (! (*slurp_relocs) (abfd, relplt, dyn_syms, TRUE))
3397 goto free_contents_and_exit;
3398
3399 plt_count = relplt->size / sizeof (Elf64_External_Rela);
3400 size += plt_count * sizeof (asymbol);
3401
3402 p = relplt->relocation;
3403 for (i = 0; i < plt_count; i++, p++)
3404 {
3405 size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
3406 if (p->addend != 0)
3407 size += sizeof ("+0x") - 1 + 16;
3408 }
3409 }
3410 }
3411
3412 s = *ret = bfd_malloc (size);
3413 if (s == NULL)
3414 goto free_contents_and_exit;
3415
3416 names = (char *) (s + count + plt_count + (resolv_vma != 0));
3417
3418 for (i = secsymend; i < opdsymend; ++i)
3419 {
3420 bfd_vma ent;
3421
3422 if (syms[i]->value > opd->size - 8)
3423 continue;
3424
3425 ent = bfd_get_64 (abfd, contents + syms[i]->value);
3426 if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3427 {
3428 long lo, hi;
3429 size_t len;
3430 asection *sec = abfd->sections;
3431
3432 *s = *syms[i];
3433 lo = codesecsym;
3434 hi = codesecsymend;
3435 while (lo < hi)
3436 {
3437 long mid = (lo + hi) >> 1;
3438 if (syms[mid]->section->vma < ent)
3439 lo = mid + 1;
3440 else if (syms[mid]->section->vma > ent)
3441 hi = mid;
3442 else
3443 {
3444 sec = syms[mid]->section;
3445 break;
3446 }
3447 }
3448
3449 if (lo >= hi && lo > codesecsym)
3450 sec = syms[lo - 1]->section;
3451
3452 for (; sec != NULL; sec = sec->next)
3453 {
3454 if (sec->vma > ent)
3455 break;
3456 /* SEC_LOAD may not be set if SEC is from a separate debug
3457 info file. */
3458 if ((sec->flags & SEC_ALLOC) == 0)
3459 break;
3460 if ((sec->flags & SEC_CODE) != 0)
3461 s->section = sec;
3462 }
3463 s->flags |= BSF_SYNTHETIC;
3464 s->value = ent - s->section->vma;
3465 s->name = names;
3466 *names++ = '.';
3467 len = strlen (syms[i]->name);
3468 memcpy (names, syms[i]->name, len + 1);
3469 names += len + 1;
3470 /* Have udata.p point back to the original symbol this
3471 synthetic symbol was derived from. */
3472 s->udata.p = syms[i];
3473 s++;
3474 }
3475 }
3476 free (contents);
3477
3478 if (glink != NULL && relplt != NULL)
3479 {
3480 if (resolv_vma)
3481 {
3482 /* Add a symbol for the main glink trampoline. */
3483 memset (s, 0, sizeof *s);
3484 s->the_bfd = abfd;
3485 s->flags = BSF_GLOBAL | BSF_SYNTHETIC;
3486 s->section = glink;
3487 s->value = resolv_vma - glink->vma;
3488 s->name = names;
3489 memcpy (names, "__glink_PLTresolve", sizeof ("__glink_PLTresolve"));
3490 names += sizeof ("__glink_PLTresolve");
3491 s++;
3492 count++;
3493 }
3494
3495 /* FIXME: It would be very much nicer to put sym@plt on the
3496 stub rather than on the glink branch table entry. The
3497 objdump disassembler would then use a sensible symbol
3498 name on plt calls. The difficulty in doing so is
3499 a) finding the stubs, and,
3500 b) matching stubs against plt entries, and,
3501 c) there can be multiple stubs for a given plt entry.
3502
3503 Solving (a) could be done by code scanning, but older
3504 ppc64 binaries used different stubs to current code.
3505 (b) is the tricky one since you need to known the toc
3506 pointer for at least one function that uses a pic stub to
3507 be able to calculate the plt address referenced.
3508 (c) means gdb would need to set multiple breakpoints (or
3509 find the glink branch itself) when setting breakpoints
3510 for pending shared library loads. */
3511 p = relplt->relocation;
3512 for (i = 0; i < plt_count; i++, p++)
3513 {
3514 size_t len;
3515
3516 *s = **p->sym_ptr_ptr;
3517 /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set. Since
3518 we are defining a symbol, ensure one of them is set. */
3519 if ((s->flags & BSF_LOCAL) == 0)
3520 s->flags |= BSF_GLOBAL;
3521 s->flags |= BSF_SYNTHETIC;
3522 s->section = glink;
3523 s->value = glink_vma - glink->vma;
3524 s->name = names;
3525 s->udata.p = NULL;
3526 len = strlen ((*p->sym_ptr_ptr)->name);
3527 memcpy (names, (*p->sym_ptr_ptr)->name, len);
3528 names += len;
3529 if (p->addend != 0)
3530 {
3531 memcpy (names, "+0x", sizeof ("+0x") - 1);
3532 names += sizeof ("+0x") - 1;
3533 bfd_sprintf_vma (abfd, names, p->addend);
3534 names += strlen (names);
3535 }
3536 memcpy (names, "@plt", sizeof ("@plt"));
3537 names += sizeof ("@plt");
3538 s++;
3539 if (abi < 2)
3540 {
3541 glink_vma += 8;
3542 if (i >= 0x8000)
3543 glink_vma += 4;
3544 }
3545 else
3546 glink_vma += 4;
3547 }
3548 count += plt_count;
3549 }
3550 }
3551
3552 done:
3553 free (syms);
3554 return count;
3555 }
3556 \f
3557 /* The following functions are specific to the ELF linker, while
3558 functions above are used generally. Those named ppc64_elf_* are
3559 called by the main ELF linker code. They appear in this file more
3560 or less in the order in which they are called. eg.
3561 ppc64_elf_check_relocs is called early in the link process,
3562 ppc64_elf_finish_dynamic_sections is one of the last functions
3563 called.
3564
3565 PowerPC64-ELF uses a similar scheme to PowerPC64-XCOFF in that
3566 functions have both a function code symbol and a function descriptor
3567 symbol. A call to foo in a relocatable object file looks like:
3568
3569 . .text
3570 . x:
3571 . bl .foo
3572 . nop
3573
3574 The function definition in another object file might be:
3575
3576 . .section .opd
3577 . foo: .quad .foo
3578 . .quad .TOC.@tocbase
3579 . .quad 0
3580 .
3581 . .text
3582 . .foo: blr
3583
3584 When the linker resolves the call during a static link, the branch
3585 unsurprisingly just goes to .foo and the .opd information is unused.
3586 If the function definition is in a shared library, things are a little
3587 different: The call goes via a plt call stub, the opd information gets
3588 copied to the plt, and the linker patches the nop.
3589
3590 . x:
3591 . bl .foo_stub
3592 . ld 2,40(1)
3593 .
3594 .
3595 . .foo_stub:
3596 . std 2,40(1) # in practice, the call stub
3597 . addis 11,2,Lfoo@toc@ha # is slightly optimized, but
3598 . addi 11,11,Lfoo@toc@l # this is the general idea
3599 . ld 12,0(11)
3600 . ld 2,8(11)
3601 . mtctr 12
3602 . ld 11,16(11)
3603 . bctr
3604 .
3605 . .section .plt
3606 . Lfoo: reloc (R_PPC64_JMP_SLOT, foo)
3607
3608 The "reloc ()" notation is supposed to indicate that the linker emits
3609 an R_PPC64_JMP_SLOT reloc against foo. The dynamic linker does the opd
3610 copying.
3611
3612 What are the difficulties here? Well, firstly, the relocations
3613 examined by the linker in check_relocs are against the function code
3614 sym .foo, while the dynamic relocation in the plt is emitted against
3615 the function descriptor symbol, foo. Somewhere along the line, we need
3616 to carefully copy dynamic link information from one symbol to the other.
3617 Secondly, the generic part of the elf linker will make .foo a dynamic
3618 symbol as is normal for most other backends. We need foo dynamic
3619 instead, at least for an application final link. However, when
3620 creating a shared library containing foo, we need to have both symbols
3621 dynamic so that references to .foo are satisfied during the early
3622 stages of linking. Otherwise the linker might decide to pull in a
3623 definition from some other object, eg. a static library.
3624
3625 Update: As of August 2004, we support a new convention. Function
3626 calls may use the function descriptor symbol, ie. "bl foo". This
3627 behaves exactly as "bl .foo". */
3628
3629 /* Of those relocs that might be copied as dynamic relocs, this function
3630 selects those that must be copied when linking a shared library,
3631 even when the symbol is local. */
3632
3633 static int
3634 must_be_dyn_reloc (struct bfd_link_info *info,
3635 enum elf_ppc64_reloc_type r_type)
3636 {
3637 switch (r_type)
3638 {
3639 default:
3640 return 1;
3641
3642 case R_PPC64_REL32:
3643 case R_PPC64_REL64:
3644 case R_PPC64_REL30:
3645 return 0;
3646
3647 case R_PPC64_TPREL16:
3648 case R_PPC64_TPREL16_LO:
3649 case R_PPC64_TPREL16_HI:
3650 case R_PPC64_TPREL16_HA:
3651 case R_PPC64_TPREL16_DS:
3652 case R_PPC64_TPREL16_LO_DS:
3653 case R_PPC64_TPREL16_HIGH:
3654 case R_PPC64_TPREL16_HIGHA:
3655 case R_PPC64_TPREL16_HIGHER:
3656 case R_PPC64_TPREL16_HIGHERA:
3657 case R_PPC64_TPREL16_HIGHEST:
3658 case R_PPC64_TPREL16_HIGHESTA:
3659 case R_PPC64_TPREL64:
3660 return !info->executable;
3661 }
3662 }
3663
3664 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
3665 copying dynamic variables from a shared lib into an app's dynbss
3666 section, and instead use a dynamic relocation to point into the
3667 shared lib. With code that gcc generates, it's vital that this be
3668 enabled; In the PowerPC64 ABI, the address of a function is actually
3669 the address of a function descriptor, which resides in the .opd
3670 section. gcc uses the descriptor directly rather than going via the
3671 GOT as some other ABI's do, which means that initialized function
3672 pointers must reference the descriptor. Thus, a function pointer
3673 initialized to the address of a function in a shared library will
3674 either require a copy reloc, or a dynamic reloc. Using a copy reloc
3675 redefines the function descriptor symbol to point to the copy. This
3676 presents a problem as a plt entry for that function is also
3677 initialized from the function descriptor symbol and the copy reloc
3678 may not be initialized first. */
3679 #define ELIMINATE_COPY_RELOCS 1
3680
3681 /* Section name for stubs is the associated section name plus this
3682 string. */
3683 #define STUB_SUFFIX ".stub"
3684
3685 /* Linker stubs.
3686 ppc_stub_long_branch:
3687 Used when a 14 bit branch (or even a 24 bit branch) can't reach its
3688 destination, but a 24 bit branch in a stub section will reach.
3689 . b dest
3690
3691 ppc_stub_plt_branch:
3692 Similar to the above, but a 24 bit branch in the stub section won't
3693 reach its destination.
3694 . addis %r11,%r2,xxx@toc@ha
3695 . ld %r12,xxx@toc@l(%r11)
3696 . mtctr %r12
3697 . bctr
3698
3699 ppc_stub_plt_call:
3700 Used to call a function in a shared library. If it so happens that
3701 the plt entry referenced crosses a 64k boundary, then an extra
3702 "addi %r11,%r11,xxx@toc@l" will be inserted before the "mtctr".
3703 . std %r2,40(%r1)
3704 . addis %r11,%r2,xxx@toc@ha
3705 . ld %r12,xxx+0@toc@l(%r11)
3706 . mtctr %r12
3707 . ld %r2,xxx+8@toc@l(%r11)
3708 . ld %r11,xxx+16@toc@l(%r11)
3709 . bctr
3710
3711 ppc_stub_long_branch and ppc_stub_plt_branch may also have additional
3712 code to adjust the value and save r2 to support multiple toc sections.
3713 A ppc_stub_long_branch with an r2 offset looks like:
3714 . std %r2,40(%r1)
3715 . addis %r2,%r2,off@ha
3716 . addi %r2,%r2,off@l
3717 . b dest
3718
3719 A ppc_stub_plt_branch with an r2 offset looks like:
3720 . std %r2,40(%r1)
3721 . addis %r11,%r2,xxx@toc@ha
3722 . ld %r12,xxx@toc@l(%r11)
3723 . addis %r2,%r2,off@ha
3724 . addi %r2,%r2,off@l
3725 . mtctr %r12
3726 . bctr
3727
3728 In cases where the "addis" instruction would add zero, the "addis" is
3729 omitted and following instructions modified slightly in some cases.
3730 */
3731
3732 enum ppc_stub_type {
3733 ppc_stub_none,
3734 ppc_stub_long_branch,
3735 ppc_stub_long_branch_r2off,
3736 ppc_stub_plt_branch,
3737 ppc_stub_plt_branch_r2off,
3738 ppc_stub_plt_call,
3739 ppc_stub_plt_call_r2save
3740 };
3741
3742 struct ppc_stub_hash_entry {
3743
3744 /* Base hash table entry structure. */
3745 struct bfd_hash_entry root;
3746
3747 enum ppc_stub_type stub_type;
3748
3749 /* The stub section. */
3750 asection *stub_sec;
3751
3752 /* Offset within stub_sec of the beginning of this stub. */
3753 bfd_vma stub_offset;
3754
3755 /* Given the symbol's value and its section we can determine its final
3756 value when building the stubs (so the stub knows where to jump. */
3757 bfd_vma target_value;
3758 asection *target_section;
3759
3760 /* The symbol table entry, if any, that this was derived from. */
3761 struct ppc_link_hash_entry *h;
3762 struct plt_entry *plt_ent;
3763
3764 /* Where this stub is being called from, or, in the case of combined
3765 stub sections, the first input section in the group. */
3766 asection *id_sec;
3767
3768 /* Symbol st_other. */
3769 unsigned char other;
3770 };
3771
3772 struct ppc_branch_hash_entry {
3773
3774 /* Base hash table entry structure. */
3775 struct bfd_hash_entry root;
3776
3777 /* Offset within branch lookup table. */
3778 unsigned int offset;
3779
3780 /* Generation marker. */
3781 unsigned int iter;
3782 };
3783
3784 /* Used to track dynamic relocations for local symbols. */
3785 struct ppc_dyn_relocs
3786 {
3787 struct ppc_dyn_relocs *next;
3788
3789 /* The input section of the reloc. */
3790 asection *sec;
3791
3792 /* Total number of relocs copied for the input section. */
3793 unsigned int count : 31;
3794
3795 /* Whether this entry is for STT_GNU_IFUNC symbols. */
3796 unsigned int ifunc : 1;
3797 };
3798
3799 struct ppc_link_hash_entry
3800 {
3801 struct elf_link_hash_entry elf;
3802
3803 union {
3804 /* A pointer to the most recently used stub hash entry against this
3805 symbol. */
3806 struct ppc_stub_hash_entry *stub_cache;
3807
3808 /* A pointer to the next symbol starting with a '.' */
3809 struct ppc_link_hash_entry *next_dot_sym;
3810 } u;
3811
3812 /* Track dynamic relocs copied for this symbol. */
3813 struct elf_dyn_relocs *dyn_relocs;
3814
3815 /* Link between function code and descriptor symbols. */
3816 struct ppc_link_hash_entry *oh;
3817
3818 /* Flag function code and descriptor symbols. */
3819 unsigned int is_func:1;
3820 unsigned int is_func_descriptor:1;
3821 unsigned int fake:1;
3822
3823 /* Whether global opd/toc sym has been adjusted or not.
3824 After ppc64_elf_edit_opd/ppc64_elf_edit_toc has run, this flag
3825 should be set for all globals defined in any opd/toc section. */
3826 unsigned int adjust_done:1;
3827
3828 /* Set if we twiddled this symbol to weak at some stage. */
3829 unsigned int was_undefined:1;
3830
3831 /* Contexts in which symbol is used in the GOT (or TOC).
3832 TLS_GD .. TLS_EXPLICIT bits are or'd into the mask as the
3833 corresponding relocs are encountered during check_relocs.
3834 tls_optimize clears TLS_GD .. TLS_TPREL when optimizing to
3835 indicate the corresponding GOT entry type is not needed.
3836 tls_optimize may also set TLS_TPRELGD when a GD reloc turns into
3837 a TPREL one. We use a separate flag rather than setting TPREL
3838 just for convenience in distinguishing the two cases. */
3839 #define TLS_GD 1 /* GD reloc. */
3840 #define TLS_LD 2 /* LD reloc. */
3841 #define TLS_TPREL 4 /* TPREL reloc, => IE. */
3842 #define TLS_DTPREL 8 /* DTPREL reloc, => LD. */
3843 #define TLS_TLS 16 /* Any TLS reloc. */
3844 #define TLS_EXPLICIT 32 /* Marks TOC section TLS relocs. */
3845 #define TLS_TPRELGD 64 /* TPREL reloc resulting from GD->IE. */
3846 #define PLT_IFUNC 128 /* STT_GNU_IFUNC. */
3847 unsigned char tls_mask;
3848 };
3849
3850 /* ppc64 ELF linker hash table. */
3851
3852 struct ppc_link_hash_table
3853 {
3854 struct elf_link_hash_table elf;
3855
3856 /* The stub hash table. */
3857 struct bfd_hash_table stub_hash_table;
3858
3859 /* Another hash table for plt_branch stubs. */
3860 struct bfd_hash_table branch_hash_table;
3861
3862 /* Hash table for function prologue tocsave. */
3863 htab_t tocsave_htab;
3864
3865 /* Linker stub bfd. */
3866 bfd *stub_bfd;
3867
3868 /* Linker call-backs. */
3869 asection * (*add_stub_section) (const char *, asection *);
3870 void (*layout_sections_again) (void);
3871
3872 /* Array to keep track of which stub sections have been created, and
3873 information on stub grouping. */
3874 struct map_stub {
3875 /* This is the section to which stubs in the group will be attached. */
3876 asection *link_sec;
3877 /* The stub section. */
3878 asection *stub_sec;
3879 /* Along with elf_gp, specifies the TOC pointer used in this group. */
3880 bfd_vma toc_off;
3881 } *stub_group;
3882
3883 /* Temp used when calculating TOC pointers. */
3884 bfd_vma toc_curr;
3885 bfd *toc_bfd;
3886 asection *toc_first_sec;
3887
3888 /* Highest input section id. */
3889 int top_id;
3890
3891 /* Highest output section index. */
3892 int top_index;
3893
3894 /* Used when adding symbols. */
3895 struct ppc_link_hash_entry *dot_syms;
3896
3897 /* List of input sections for each output section. */
3898 asection **input_list;
3899
3900 /* Short-cuts to get to dynamic linker sections. */
3901 asection *got;
3902 asection *plt;
3903 asection *relplt;
3904 asection *iplt;
3905 asection *reliplt;
3906 asection *dynbss;
3907 asection *relbss;
3908 asection *glink;
3909 asection *sfpr;
3910 asection *brlt;
3911 asection *relbrlt;
3912 asection *glink_eh_frame;
3913
3914 /* Shortcut to .__tls_get_addr and __tls_get_addr. */
3915 struct ppc_link_hash_entry *tls_get_addr;
3916 struct ppc_link_hash_entry *tls_get_addr_fd;
3917
3918 /* The size of reliplt used by got entry relocs. */
3919 bfd_size_type got_reli_size;
3920
3921 /* Statistics. */
3922 unsigned long stub_count[ppc_stub_plt_call_r2save];
3923
3924 /* Number of stubs against global syms. */
3925 unsigned long stub_globals;
3926
3927 /* Alignment of PLT call stubs. */
3928 unsigned int plt_stub_align:4;
3929
3930 /* Set if we're linking code with function descriptors. */
3931 unsigned int opd_abi:1;
3932
3933 /* Set if PLT call stubs should load r11. */
3934 unsigned int plt_static_chain:1;
3935
3936 /* Set if PLT call stubs need a read-read barrier. */
3937 unsigned int plt_thread_safe:1;
3938
3939 /* Set if we should emit symbols for stubs. */
3940 unsigned int emit_stub_syms:1;
3941
3942 /* Set if __tls_get_addr optimization should not be done. */
3943 unsigned int no_tls_get_addr_opt:1;
3944
3945 /* Support for multiple toc sections. */
3946 unsigned int do_multi_toc:1;
3947 unsigned int multi_toc_needed:1;
3948 unsigned int second_toc_pass:1;
3949 unsigned int do_toc_opt:1;
3950
3951 /* Set on error. */
3952 unsigned int stub_error:1;
3953
3954 /* Temp used by ppc64_elf_process_dot_syms. */
3955 unsigned int twiddled_syms:1;
3956
3957 /* Incremented every time we size stubs. */
3958 unsigned int stub_iteration;
3959
3960 /* Small local sym cache. */
3961 struct sym_cache sym_cache;
3962 };
3963
3964 /* Rename some of the generic section flags to better document how they
3965 are used here. */
3966
3967 /* Nonzero if this section has TLS related relocations. */
3968 #define has_tls_reloc sec_flg0
3969
3970 /* Nonzero if this section has a call to __tls_get_addr. */
3971 #define has_tls_get_addr_call sec_flg1
3972
3973 /* Nonzero if this section has any toc or got relocs. */
3974 #define has_toc_reloc sec_flg2
3975
3976 /* Nonzero if this section has a call to another section that uses
3977 the toc or got. */
3978 #define makes_toc_func_call sec_flg3
3979
3980 /* Recursion protection when determining above flag. */
3981 #define call_check_in_progress sec_flg4
3982 #define call_check_done sec_flg5
3983
3984 /* Get the ppc64 ELF linker hash table from a link_info structure. */
3985
3986 #define ppc_hash_table(p) \
3987 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
3988 == PPC64_ELF_DATA ? ((struct ppc_link_hash_table *) ((p)->hash)) : NULL)
3989
3990 #define ppc_stub_hash_lookup(table, string, create, copy) \
3991 ((struct ppc_stub_hash_entry *) \
3992 bfd_hash_lookup ((table), (string), (create), (copy)))
3993
3994 #define ppc_branch_hash_lookup(table, string, create, copy) \
3995 ((struct ppc_branch_hash_entry *) \
3996 bfd_hash_lookup ((table), (string), (create), (copy)))
3997
3998 /* Create an entry in the stub hash table. */
3999
4000 static struct bfd_hash_entry *
4001 stub_hash_newfunc (struct bfd_hash_entry *entry,
4002 struct bfd_hash_table *table,
4003 const char *string)
4004 {
4005 /* Allocate the structure if it has not already been allocated by a
4006 subclass. */
4007 if (entry == NULL)
4008 {
4009 entry = bfd_hash_allocate (table, sizeof (struct ppc_stub_hash_entry));
4010 if (entry == NULL)
4011 return entry;
4012 }
4013
4014 /* Call the allocation method of the superclass. */
4015 entry = bfd_hash_newfunc (entry, table, string);
4016 if (entry != NULL)
4017 {
4018 struct ppc_stub_hash_entry *eh;
4019
4020 /* Initialize the local fields. */
4021 eh = (struct ppc_stub_hash_entry *) entry;
4022 eh->stub_type = ppc_stub_none;
4023 eh->stub_sec = NULL;
4024 eh->stub_offset = 0;
4025 eh->target_value = 0;
4026 eh->target_section = NULL;
4027 eh->h = NULL;
4028 eh->plt_ent = NULL;
4029 eh->id_sec = NULL;
4030 eh->other = 0;
4031 }
4032
4033 return entry;
4034 }
4035
4036 /* Create an entry in the branch hash table. */
4037
4038 static struct bfd_hash_entry *
4039 branch_hash_newfunc (struct bfd_hash_entry *entry,
4040 struct bfd_hash_table *table,
4041 const char *string)
4042 {
4043 /* Allocate the structure if it has not already been allocated by a
4044 subclass. */
4045 if (entry == NULL)
4046 {
4047 entry = bfd_hash_allocate (table, sizeof (struct ppc_branch_hash_entry));
4048 if (entry == NULL)
4049 return entry;
4050 }
4051
4052 /* Call the allocation method of the superclass. */
4053 entry = bfd_hash_newfunc (entry, table, string);
4054 if (entry != NULL)
4055 {
4056 struct ppc_branch_hash_entry *eh;
4057
4058 /* Initialize the local fields. */
4059 eh = (struct ppc_branch_hash_entry *) entry;
4060 eh->offset = 0;
4061 eh->iter = 0;
4062 }
4063
4064 return entry;
4065 }
4066
4067 /* Create an entry in a ppc64 ELF linker hash table. */
4068
4069 static struct bfd_hash_entry *
4070 link_hash_newfunc (struct bfd_hash_entry *entry,
4071 struct bfd_hash_table *table,
4072 const char *string)
4073 {
4074 /* Allocate the structure if it has not already been allocated by a
4075 subclass. */
4076 if (entry == NULL)
4077 {
4078 entry = bfd_hash_allocate (table, sizeof (struct ppc_link_hash_entry));
4079 if (entry == NULL)
4080 return entry;
4081 }
4082
4083 /* Call the allocation method of the superclass. */
4084 entry = _bfd_elf_link_hash_newfunc (entry, table, string);
4085 if (entry != NULL)
4086 {
4087 struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) entry;
4088
4089 memset (&eh->u.stub_cache, 0,
4090 (sizeof (struct ppc_link_hash_entry)
4091 - offsetof (struct ppc_link_hash_entry, u.stub_cache)));
4092
4093 /* When making function calls, old ABI code references function entry
4094 points (dot symbols), while new ABI code references the function
4095 descriptor symbol. We need to make any combination of reference and
4096 definition work together, without breaking archive linking.
4097
4098 For a defined function "foo" and an undefined call to "bar":
4099 An old object defines "foo" and ".foo", references ".bar" (possibly
4100 "bar" too).
4101 A new object defines "foo" and references "bar".
4102
4103 A new object thus has no problem with its undefined symbols being
4104 satisfied by definitions in an old object. On the other hand, the
4105 old object won't have ".bar" satisfied by a new object.
4106
4107 Keep a list of newly added dot-symbols. */
4108
4109 if (string[0] == '.')
4110 {
4111 struct ppc_link_hash_table *htab;
4112
4113 htab = (struct ppc_link_hash_table *) table;
4114 eh->u.next_dot_sym = htab->dot_syms;
4115 htab->dot_syms = eh;
4116 }
4117 }
4118
4119 return entry;
4120 }
4121
4122 struct tocsave_entry {
4123 asection *sec;
4124 bfd_vma offset;
4125 };
4126
4127 static hashval_t
4128 tocsave_htab_hash (const void *p)
4129 {
4130 const struct tocsave_entry *e = (const struct tocsave_entry *) p;
4131 return ((bfd_vma)(intptr_t) e->sec ^ e->offset) >> 3;
4132 }
4133
4134 static int
4135 tocsave_htab_eq (const void *p1, const void *p2)
4136 {
4137 const struct tocsave_entry *e1 = (const struct tocsave_entry *) p1;
4138 const struct tocsave_entry *e2 = (const struct tocsave_entry *) p2;
4139 return e1->sec == e2->sec && e1->offset == e2->offset;
4140 }
4141
4142 /* Create a ppc64 ELF linker hash table. */
4143
4144 static struct bfd_link_hash_table *
4145 ppc64_elf_link_hash_table_create (bfd *abfd)
4146 {
4147 struct ppc_link_hash_table *htab;
4148 bfd_size_type amt = sizeof (struct ppc_link_hash_table);
4149
4150 htab = bfd_zmalloc (amt);
4151 if (htab == NULL)
4152 return NULL;
4153
4154 if (!_bfd_elf_link_hash_table_init (&htab->elf, abfd, link_hash_newfunc,
4155 sizeof (struct ppc_link_hash_entry),
4156 PPC64_ELF_DATA))
4157 {
4158 free (htab);
4159 return NULL;
4160 }
4161
4162 /* Init the stub hash table too. */
4163 if (!bfd_hash_table_init (&htab->stub_hash_table, stub_hash_newfunc,
4164 sizeof (struct ppc_stub_hash_entry)))
4165 return NULL;
4166
4167 /* And the branch hash table. */
4168 if (!bfd_hash_table_init (&htab->branch_hash_table, branch_hash_newfunc,
4169 sizeof (struct ppc_branch_hash_entry)))
4170 return NULL;
4171
4172 htab->tocsave_htab = htab_try_create (1024,
4173 tocsave_htab_hash,
4174 tocsave_htab_eq,
4175 NULL);
4176 if (htab->tocsave_htab == NULL)
4177 return NULL;
4178
4179 /* Initializing two fields of the union is just cosmetic. We really
4180 only care about glist, but when compiled on a 32-bit host the
4181 bfd_vma fields are larger. Setting the bfd_vma to zero makes
4182 debugger inspection of these fields look nicer. */
4183 htab->elf.init_got_refcount.refcount = 0;
4184 htab->elf.init_got_refcount.glist = NULL;
4185 htab->elf.init_plt_refcount.refcount = 0;
4186 htab->elf.init_plt_refcount.glist = NULL;
4187 htab->elf.init_got_offset.offset = 0;
4188 htab->elf.init_got_offset.glist = NULL;
4189 htab->elf.init_plt_offset.offset = 0;
4190 htab->elf.init_plt_offset.glist = NULL;
4191
4192 return &htab->elf.root;
4193 }
4194
4195 /* Free the derived linker hash table. */
4196
4197 static void
4198 ppc64_elf_link_hash_table_free (struct bfd_link_hash_table *hash)
4199 {
4200 struct ppc_link_hash_table *htab = (struct ppc_link_hash_table *) hash;
4201
4202 bfd_hash_table_free (&htab->stub_hash_table);
4203 bfd_hash_table_free (&htab->branch_hash_table);
4204 if (htab->tocsave_htab)
4205 htab_delete (htab->tocsave_htab);
4206 _bfd_elf_link_hash_table_free (hash);
4207 }
4208
4209 /* Create sections for linker generated code. */
4210
4211 static bfd_boolean
4212 create_linkage_sections (bfd *dynobj, struct bfd_link_info *info)
4213 {
4214 struct ppc_link_hash_table *htab;
4215 flagword flags;
4216
4217 htab = ppc_hash_table (info);
4218
4219 /* Create .sfpr for code to save and restore fp regs. */
4220 flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY
4221 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4222 htab->sfpr = bfd_make_section_anyway_with_flags (dynobj, ".sfpr",
4223 flags);
4224 if (htab->sfpr == NULL
4225 || ! bfd_set_section_alignment (dynobj, htab->sfpr, 2))
4226 return FALSE;
4227
4228 /* Create .glink for lazy dynamic linking support. */
4229 htab->glink = bfd_make_section_anyway_with_flags (dynobj, ".glink",
4230 flags);
4231 if (htab->glink == NULL
4232 || ! bfd_set_section_alignment (dynobj, htab->glink, 3))
4233 return FALSE;
4234
4235 if (!info->no_ld_generated_unwind_info)
4236 {
4237 flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_HAS_CONTENTS
4238 | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4239 htab->glink_eh_frame = bfd_make_section_anyway_with_flags (dynobj,
4240 ".eh_frame",
4241 flags);
4242 if (htab->glink_eh_frame == NULL
4243 || !bfd_set_section_alignment (dynobj, htab->glink_eh_frame, 2))
4244 return FALSE;
4245 }
4246
4247 flags = SEC_ALLOC | SEC_LINKER_CREATED;
4248 htab->iplt = bfd_make_section_anyway_with_flags (dynobj, ".iplt", flags);
4249 if (htab->iplt == NULL
4250 || ! bfd_set_section_alignment (dynobj, htab->iplt, 3))
4251 return FALSE;
4252
4253 flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4254 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4255 htab->reliplt = bfd_make_section_anyway_with_flags (dynobj,
4256 ".rela.iplt",
4257 flags);
4258 if (htab->reliplt == NULL
4259 || ! bfd_set_section_alignment (dynobj, htab->reliplt, 3))
4260 return FALSE;
4261
4262 /* Create branch lookup table for plt_branch stubs. */
4263 flags = (SEC_ALLOC | SEC_LOAD
4264 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4265 htab->brlt = bfd_make_section_anyway_with_flags (dynobj, ".branch_lt",
4266 flags);
4267 if (htab->brlt == NULL
4268 || ! bfd_set_section_alignment (dynobj, htab->brlt, 3))
4269 return FALSE;
4270
4271 if (!info->shared)
4272 return TRUE;
4273
4274 flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4275 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4276 htab->relbrlt = bfd_make_section_anyway_with_flags (dynobj,
4277 ".rela.branch_lt",
4278 flags);
4279 if (htab->relbrlt == NULL
4280 || ! bfd_set_section_alignment (dynobj, htab->relbrlt, 3))
4281 return FALSE;
4282
4283 return TRUE;
4284 }
4285
4286 /* Satisfy the ELF linker by filling in some fields in our fake bfd. */
4287
4288 bfd_boolean
4289 ppc64_elf_init_stub_bfd (bfd *abfd, struct bfd_link_info *info)
4290 {
4291 struct ppc_link_hash_table *htab;
4292
4293 elf_elfheader (abfd)->e_ident[EI_CLASS] = ELFCLASS64;
4294
4295 /* Always hook our dynamic sections into the first bfd, which is the
4296 linker created stub bfd. This ensures that the GOT header is at
4297 the start of the output TOC section. */
4298 htab = ppc_hash_table (info);
4299 if (htab == NULL)
4300 return FALSE;
4301 htab->stub_bfd = abfd;
4302 htab->elf.dynobj = abfd;
4303
4304 if (info->relocatable)
4305 return TRUE;
4306
4307 return create_linkage_sections (htab->elf.dynobj, info);
4308 }
4309
4310 /* Build a name for an entry in the stub hash table. */
4311
4312 static char *
4313 ppc_stub_name (const asection *input_section,
4314 const asection *sym_sec,
4315 const struct ppc_link_hash_entry *h,
4316 const Elf_Internal_Rela *rel)
4317 {
4318 char *stub_name;
4319 ssize_t len;
4320
4321 /* rel->r_addend is actually 64 bit, but who uses more than +/- 2^31
4322 offsets from a sym as a branch target? In fact, we could
4323 probably assume the addend is always zero. */
4324 BFD_ASSERT (((int) rel->r_addend & 0xffffffff) == rel->r_addend);
4325
4326 if (h)
4327 {
4328 len = 8 + 1 + strlen (h->elf.root.root.string) + 1 + 8 + 1;
4329 stub_name = bfd_malloc (len);
4330 if (stub_name == NULL)
4331 return stub_name;
4332
4333 len = sprintf (stub_name, "%08x.%s+%x",
4334 input_section->id & 0xffffffff,
4335 h->elf.root.root.string,
4336 (int) rel->r_addend & 0xffffffff);
4337 }
4338 else
4339 {
4340 len = 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1;
4341 stub_name = bfd_malloc (len);
4342 if (stub_name == NULL)
4343 return stub_name;
4344
4345 len = sprintf (stub_name, "%08x.%x:%x+%x",
4346 input_section->id & 0xffffffff,
4347 sym_sec->id & 0xffffffff,
4348 (int) ELF64_R_SYM (rel->r_info) & 0xffffffff,
4349 (int) rel->r_addend & 0xffffffff);
4350 }
4351 if (len > 2 && stub_name[len - 2] == '+' && stub_name[len - 1] == '0')
4352 stub_name[len - 2] = 0;
4353 return stub_name;
4354 }
4355
4356 /* Look up an entry in the stub hash. Stub entries are cached because
4357 creating the stub name takes a bit of time. */
4358
4359 static struct ppc_stub_hash_entry *
4360 ppc_get_stub_entry (const asection *input_section,
4361 const asection *sym_sec,
4362 struct ppc_link_hash_entry *h,
4363 const Elf_Internal_Rela *rel,
4364 struct ppc_link_hash_table *htab)
4365 {
4366 struct ppc_stub_hash_entry *stub_entry;
4367 const asection *id_sec;
4368
4369 /* If this input section is part of a group of sections sharing one
4370 stub section, then use the id of the first section in the group.
4371 Stub names need to include a section id, as there may well be
4372 more than one stub used to reach say, printf, and we need to
4373 distinguish between them. */
4374 id_sec = htab->stub_group[input_section->id].link_sec;
4375
4376 if (h != NULL && h->u.stub_cache != NULL
4377 && h->u.stub_cache->h == h
4378 && h->u.stub_cache->id_sec == id_sec)
4379 {
4380 stub_entry = h->u.stub_cache;
4381 }
4382 else
4383 {
4384 char *stub_name;
4385
4386 stub_name = ppc_stub_name (id_sec, sym_sec, h, rel);
4387 if (stub_name == NULL)
4388 return NULL;
4389
4390 stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
4391 stub_name, FALSE, FALSE);
4392 if (h != NULL)
4393 h->u.stub_cache = stub_entry;
4394
4395 free (stub_name);
4396 }
4397
4398 return stub_entry;
4399 }
4400
4401 /* Add a new stub entry to the stub hash. Not all fields of the new
4402 stub entry are initialised. */
4403
4404 static struct ppc_stub_hash_entry *
4405 ppc_add_stub (const char *stub_name,
4406 asection *section,
4407 struct bfd_link_info *info)
4408 {
4409 struct ppc_link_hash_table *htab = ppc_hash_table (info);
4410 asection *link_sec;
4411 asection *stub_sec;
4412 struct ppc_stub_hash_entry *stub_entry;
4413
4414 link_sec = htab->stub_group[section->id].link_sec;
4415 stub_sec = htab->stub_group[section->id].stub_sec;
4416 if (stub_sec == NULL)
4417 {
4418 stub_sec = htab->stub_group[link_sec->id].stub_sec;
4419 if (stub_sec == NULL)
4420 {
4421 size_t namelen;
4422 bfd_size_type len;
4423 char *s_name;
4424
4425 namelen = strlen (link_sec->name);
4426 len = namelen + sizeof (STUB_SUFFIX);
4427 s_name = bfd_alloc (htab->stub_bfd, len);
4428 if (s_name == NULL)
4429 return NULL;
4430
4431 memcpy (s_name, link_sec->name, namelen);
4432 memcpy (s_name + namelen, STUB_SUFFIX, sizeof (STUB_SUFFIX));
4433 stub_sec = (*htab->add_stub_section) (s_name, link_sec);
4434 if (stub_sec == NULL)
4435 return NULL;
4436 htab->stub_group[link_sec->id].stub_sec = stub_sec;
4437 }
4438 htab->stub_group[section->id].stub_sec = stub_sec;
4439 }
4440
4441 /* Enter this entry into the linker stub hash table. */
4442 stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table, stub_name,
4443 TRUE, FALSE);
4444 if (stub_entry == NULL)
4445 {
4446 info->callbacks->einfo (_("%P: %B: cannot create stub entry %s\n"),
4447 section->owner, stub_name);
4448 return NULL;
4449 }
4450
4451 stub_entry->stub_sec = stub_sec;
4452 stub_entry->stub_offset = 0;
4453 stub_entry->id_sec = link_sec;
4454 return stub_entry;
4455 }
4456
4457 /* Create .got and .rela.got sections in ABFD, and .got in dynobj if
4458 not already done. */
4459
4460 static bfd_boolean
4461 create_got_section (bfd *abfd, struct bfd_link_info *info)
4462 {
4463 asection *got, *relgot;
4464 flagword flags;
4465 struct ppc_link_hash_table *htab = ppc_hash_table (info);
4466
4467 if (!is_ppc64_elf (abfd))
4468 return FALSE;
4469 if (htab == NULL)
4470 return FALSE;
4471
4472 if (!htab->got)
4473 {
4474 if (! _bfd_elf_create_got_section (htab->elf.dynobj, info))
4475 return FALSE;
4476
4477 htab->got = bfd_get_linker_section (htab->elf.dynobj, ".got");
4478 if (!htab->got)
4479 abort ();
4480 }
4481
4482 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
4483 | SEC_LINKER_CREATED);
4484
4485 got = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
4486 if (!got
4487 || !bfd_set_section_alignment (abfd, got, 3))
4488 return FALSE;
4489
4490 relgot = bfd_make_section_anyway_with_flags (abfd, ".rela.got",
4491 flags | SEC_READONLY);
4492 if (!relgot
4493 || ! bfd_set_section_alignment (abfd, relgot, 3))
4494 return FALSE;
4495
4496 ppc64_elf_tdata (abfd)->got = got;
4497 ppc64_elf_tdata (abfd)->relgot = relgot;
4498 return TRUE;
4499 }
4500
4501 /* Create the dynamic sections, and set up shortcuts. */
4502
4503 static bfd_boolean
4504 ppc64_elf_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
4505 {
4506 struct ppc_link_hash_table *htab;
4507
4508 if (!_bfd_elf_create_dynamic_sections (dynobj, info))
4509 return FALSE;
4510
4511 htab = ppc_hash_table (info);
4512 if (htab == NULL)
4513 return FALSE;
4514
4515 if (!htab->got)
4516 htab->got = bfd_get_linker_section (dynobj, ".got");
4517 htab->plt = bfd_get_linker_section (dynobj, ".plt");
4518 htab->relplt = bfd_get_linker_section (dynobj, ".rela.plt");
4519 htab->dynbss = bfd_get_linker_section (dynobj, ".dynbss");
4520 if (!info->shared)
4521 htab->relbss = bfd_get_linker_section (dynobj, ".rela.bss");
4522
4523 if (!htab->got || !htab->plt || !htab->relplt || !htab->dynbss
4524 || (!info->shared && !htab->relbss))
4525 abort ();
4526
4527 return TRUE;
4528 }
4529
4530 /* Follow indirect and warning symbol links. */
4531
4532 static inline struct bfd_link_hash_entry *
4533 follow_link (struct bfd_link_hash_entry *h)
4534 {
4535 while (h->type == bfd_link_hash_indirect
4536 || h->type == bfd_link_hash_warning)
4537 h = h->u.i.link;
4538 return h;
4539 }
4540
4541 static inline struct elf_link_hash_entry *
4542 elf_follow_link (struct elf_link_hash_entry *h)
4543 {
4544 return (struct elf_link_hash_entry *) follow_link (&h->root);
4545 }
4546
4547 static inline struct ppc_link_hash_entry *
4548 ppc_follow_link (struct ppc_link_hash_entry *h)
4549 {
4550 return (struct ppc_link_hash_entry *) follow_link (&h->elf.root);
4551 }
4552
4553 /* Merge PLT info on FROM with that on TO. */
4554
4555 static void
4556 move_plt_plist (struct ppc_link_hash_entry *from,
4557 struct ppc_link_hash_entry *to)
4558 {
4559 if (from->elf.plt.plist != NULL)
4560 {
4561 if (to->elf.plt.plist != NULL)
4562 {
4563 struct plt_entry **entp;
4564 struct plt_entry *ent;
4565
4566 for (entp = &from->elf.plt.plist; (ent = *entp) != NULL; )
4567 {
4568 struct plt_entry *dent;
4569
4570 for (dent = to->elf.plt.plist; dent != NULL; dent = dent->next)
4571 if (dent->addend == ent->addend)
4572 {
4573 dent->plt.refcount += ent->plt.refcount;
4574 *entp = ent->next;
4575 break;
4576 }
4577 if (dent == NULL)
4578 entp = &ent->next;
4579 }
4580 *entp = to->elf.plt.plist;
4581 }
4582
4583 to->elf.plt.plist = from->elf.plt.plist;
4584 from->elf.plt.plist = NULL;
4585 }
4586 }
4587
4588 /* Copy the extra info we tack onto an elf_link_hash_entry. */
4589
4590 static void
4591 ppc64_elf_copy_indirect_symbol (struct bfd_link_info *info,
4592 struct elf_link_hash_entry *dir,
4593 struct elf_link_hash_entry *ind)
4594 {
4595 struct ppc_link_hash_entry *edir, *eind;
4596
4597 edir = (struct ppc_link_hash_entry *) dir;
4598 eind = (struct ppc_link_hash_entry *) ind;
4599
4600 edir->is_func |= eind->is_func;
4601 edir->is_func_descriptor |= eind->is_func_descriptor;
4602 edir->tls_mask |= eind->tls_mask;
4603 if (eind->oh != NULL)
4604 edir->oh = ppc_follow_link (eind->oh);
4605
4606 /* If called to transfer flags for a weakdef during processing
4607 of elf_adjust_dynamic_symbol, don't copy NON_GOT_REF.
4608 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
4609 if (!(ELIMINATE_COPY_RELOCS
4610 && eind->elf.root.type != bfd_link_hash_indirect
4611 && edir->elf.dynamic_adjusted))
4612 edir->elf.non_got_ref |= eind->elf.non_got_ref;
4613
4614 edir->elf.ref_dynamic |= eind->elf.ref_dynamic;
4615 edir->elf.ref_regular |= eind->elf.ref_regular;
4616 edir->elf.ref_regular_nonweak |= eind->elf.ref_regular_nonweak;
4617 edir->elf.needs_plt |= eind->elf.needs_plt;
4618
4619 /* Copy over any dynamic relocs we may have on the indirect sym. */
4620 if (eind->dyn_relocs != NULL)
4621 {
4622 if (edir->dyn_relocs != NULL)
4623 {
4624 struct elf_dyn_relocs **pp;
4625 struct elf_dyn_relocs *p;
4626
4627 /* Add reloc counts against the indirect sym to the direct sym
4628 list. Merge any entries against the same section. */
4629 for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
4630 {
4631 struct elf_dyn_relocs *q;
4632
4633 for (q = edir->dyn_relocs; q != NULL; q = q->next)
4634 if (q->sec == p->sec)
4635 {
4636 q->pc_count += p->pc_count;
4637 q->count += p->count;
4638 *pp = p->next;
4639 break;
4640 }
4641 if (q == NULL)
4642 pp = &p->next;
4643 }
4644 *pp = edir->dyn_relocs;
4645 }
4646
4647 edir->dyn_relocs = eind->dyn_relocs;
4648 eind->dyn_relocs = NULL;
4649 }
4650
4651 /* If we were called to copy over info for a weak sym, that's all.
4652 You might think dyn_relocs need not be copied over; After all,
4653 both syms will be dynamic or both non-dynamic so we're just
4654 moving reloc accounting around. However, ELIMINATE_COPY_RELOCS
4655 code in ppc64_elf_adjust_dynamic_symbol needs to check for
4656 dyn_relocs in read-only sections, and it does so on what is the
4657 DIR sym here. */
4658 if (eind->elf.root.type != bfd_link_hash_indirect)
4659 return;
4660
4661 /* Copy over got entries that we may have already seen to the
4662 symbol which just became indirect. */
4663 if (eind->elf.got.glist != NULL)
4664 {
4665 if (edir->elf.got.glist != NULL)
4666 {
4667 struct got_entry **entp;
4668 struct got_entry *ent;
4669
4670 for (entp = &eind->elf.got.glist; (ent = *entp) != NULL; )
4671 {
4672 struct got_entry *dent;
4673
4674 for (dent = edir->elf.got.glist; dent != NULL; dent = dent->next)
4675 if (dent->addend == ent->addend
4676 && dent->owner == ent->owner
4677 && dent->tls_type == ent->tls_type)
4678 {
4679 dent->got.refcount += ent->got.refcount;
4680 *entp = ent->next;
4681 break;
4682 }
4683 if (dent == NULL)
4684 entp = &ent->next;
4685 }
4686 *entp = edir->elf.got.glist;
4687 }
4688
4689 edir->elf.got.glist = eind->elf.got.glist;
4690 eind->elf.got.glist = NULL;
4691 }
4692
4693 /* And plt entries. */
4694 move_plt_plist (eind, edir);
4695
4696 if (eind->elf.dynindx != -1)
4697 {
4698 if (edir->elf.dynindx != -1)
4699 _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
4700 edir->elf.dynstr_index);
4701 edir->elf.dynindx = eind->elf.dynindx;
4702 edir->elf.dynstr_index = eind->elf.dynstr_index;
4703 eind->elf.dynindx = -1;
4704 eind->elf.dynstr_index = 0;
4705 }
4706 }
4707
4708 /* Find the function descriptor hash entry from the given function code
4709 hash entry FH. Link the entries via their OH fields. */
4710
4711 static struct ppc_link_hash_entry *
4712 lookup_fdh (struct ppc_link_hash_entry *fh, struct ppc_link_hash_table *htab)
4713 {
4714 struct ppc_link_hash_entry *fdh = fh->oh;
4715
4716 if (fdh == NULL)
4717 {
4718 const char *fd_name = fh->elf.root.root.string + 1;
4719
4720 fdh = (struct ppc_link_hash_entry *)
4721 elf_link_hash_lookup (&htab->elf, fd_name, FALSE, FALSE, FALSE);
4722 if (fdh == NULL)
4723 return fdh;
4724
4725 fdh->is_func_descriptor = 1;
4726 fdh->oh = fh;
4727 fh->is_func = 1;
4728 fh->oh = fdh;
4729 }
4730
4731 return ppc_follow_link (fdh);
4732 }
4733
4734 /* Make a fake function descriptor sym for the code sym FH. */
4735
4736 static struct ppc_link_hash_entry *
4737 make_fdh (struct bfd_link_info *info,
4738 struct ppc_link_hash_entry *fh)
4739 {
4740 bfd *abfd;
4741 asymbol *newsym;
4742 struct bfd_link_hash_entry *bh;
4743 struct ppc_link_hash_entry *fdh;
4744
4745 abfd = fh->elf.root.u.undef.abfd;
4746 newsym = bfd_make_empty_symbol (abfd);
4747 newsym->name = fh->elf.root.root.string + 1;
4748 newsym->section = bfd_und_section_ptr;
4749 newsym->value = 0;
4750 newsym->flags = BSF_WEAK;
4751
4752 bh = NULL;
4753 if (!_bfd_generic_link_add_one_symbol (info, abfd, newsym->name,
4754 newsym->flags, newsym->section,
4755 newsym->value, NULL, FALSE, FALSE,
4756 &bh))
4757 return NULL;
4758
4759 fdh = (struct ppc_link_hash_entry *) bh;
4760 fdh->elf.non_elf = 0;
4761 fdh->fake = 1;
4762 fdh->is_func_descriptor = 1;
4763 fdh->oh = fh;
4764 fh->is_func = 1;
4765 fh->oh = fdh;
4766 return fdh;
4767 }
4768
4769 /* Fix function descriptor symbols defined in .opd sections to be
4770 function type. */
4771
4772 static bfd_boolean
4773 ppc64_elf_add_symbol_hook (bfd *ibfd,
4774 struct bfd_link_info *info,
4775 Elf_Internal_Sym *isym,
4776 const char **name,
4777 flagword *flags ATTRIBUTE_UNUSED,
4778 asection **sec,
4779 bfd_vma *value ATTRIBUTE_UNUSED)
4780 {
4781 if ((ibfd->flags & DYNAMIC) == 0
4782 && ELF_ST_BIND (isym->st_info) == STB_GNU_UNIQUE)
4783 elf_tdata (info->output_bfd)->has_gnu_symbols = TRUE;
4784
4785 if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
4786 {
4787 if ((ibfd->flags & DYNAMIC) == 0)
4788 elf_tdata (info->output_bfd)->has_gnu_symbols = TRUE;
4789 }
4790 else if (ELF_ST_TYPE (isym->st_info) == STT_FUNC)
4791 ;
4792 else if (*sec != NULL
4793 && strcmp ((*sec)->name, ".opd") == 0)
4794 isym->st_info = ELF_ST_INFO (ELF_ST_BIND (isym->st_info), STT_FUNC);
4795
4796 if ((STO_PPC64_LOCAL_MASK & isym->st_other) != 0)
4797 {
4798 if (abiversion (ibfd) == 0)
4799 set_abiversion (ibfd, 2);
4800 else if (abiversion (ibfd) == 1)
4801 {
4802 info->callbacks->einfo (_("%P: symbol '%s' has invalid st_other"
4803 " for ABI version 1\n"), name);
4804 bfd_set_error (bfd_error_bad_value);
4805 return FALSE;
4806 }
4807 }
4808
4809 return TRUE;
4810 }
4811
4812 /* Merge non-visibility st_other attributes: local entry point. */
4813
4814 static void
4815 ppc64_elf_merge_symbol_attribute (struct elf_link_hash_entry *h,
4816 const Elf_Internal_Sym *isym,
4817 bfd_boolean definition,
4818 bfd_boolean dynamic)
4819 {
4820 if (definition && !dynamic)
4821 h->other = ((isym->st_other & ~ELF_ST_VISIBILITY (-1))
4822 | ELF_ST_VISIBILITY (h->other));
4823 }
4824
4825 /* This function makes an old ABI object reference to ".bar" cause the
4826 inclusion of a new ABI object archive that defines "bar".
4827 NAME is a symbol defined in an archive. Return a symbol in the hash
4828 table that might be satisfied by the archive symbols. */
4829
4830 static struct elf_link_hash_entry *
4831 ppc64_elf_archive_symbol_lookup (bfd *abfd,
4832 struct bfd_link_info *info,
4833 const char *name)
4834 {
4835 struct elf_link_hash_entry *h;
4836 char *dot_name;
4837 size_t len;
4838
4839 h = _bfd_elf_archive_symbol_lookup (abfd, info, name);
4840 if (h != NULL
4841 /* Don't return this sym if it is a fake function descriptor
4842 created by add_symbol_adjust. */
4843 && !(h->root.type == bfd_link_hash_undefweak
4844 && ((struct ppc_link_hash_entry *) h)->fake))
4845 return h;
4846
4847 if (name[0] == '.')
4848 return h;
4849
4850 len = strlen (name);
4851 dot_name = bfd_alloc (abfd, len + 2);
4852 if (dot_name == NULL)
4853 return (struct elf_link_hash_entry *) 0 - 1;
4854 dot_name[0] = '.';
4855 memcpy (dot_name + 1, name, len + 1);
4856 h = _bfd_elf_archive_symbol_lookup (abfd, info, dot_name);
4857 bfd_release (abfd, dot_name);
4858 return h;
4859 }
4860
4861 /* This function satisfies all old ABI object references to ".bar" if a
4862 new ABI object defines "bar". Well, at least, undefined dot symbols
4863 are made weak. This stops later archive searches from including an
4864 object if we already have a function descriptor definition. It also
4865 prevents the linker complaining about undefined symbols.
4866 We also check and correct mismatched symbol visibility here. The
4867 most restrictive visibility of the function descriptor and the
4868 function entry symbol is used. */
4869
4870 static bfd_boolean
4871 add_symbol_adjust (struct ppc_link_hash_entry *eh, struct bfd_link_info *info)
4872 {
4873 struct ppc_link_hash_table *htab;
4874 struct ppc_link_hash_entry *fdh;
4875
4876 if (eh->elf.root.type == bfd_link_hash_indirect)
4877 return TRUE;
4878
4879 if (eh->elf.root.type == bfd_link_hash_warning)
4880 eh = (struct ppc_link_hash_entry *) eh->elf.root.u.i.link;
4881
4882 if (eh->elf.root.root.string[0] != '.')
4883 abort ();
4884
4885 htab = ppc_hash_table (info);
4886 if (htab == NULL)
4887 return FALSE;
4888
4889 fdh = lookup_fdh (eh, htab);
4890 if (fdh == NULL)
4891 {
4892 if (!info->relocatable
4893 && (eh->elf.root.type == bfd_link_hash_undefined
4894 || eh->elf.root.type == bfd_link_hash_undefweak)
4895 && eh->elf.ref_regular)
4896 {
4897 /* Make an undefweak function descriptor sym, which is enough to
4898 pull in an --as-needed shared lib, but won't cause link
4899 errors. Archives are handled elsewhere. */
4900 fdh = make_fdh (info, eh);
4901 if (fdh == NULL)
4902 return FALSE;
4903 fdh->elf.ref_regular = 1;
4904 }
4905 }
4906 else
4907 {
4908 unsigned entry_vis = ELF_ST_VISIBILITY (eh->elf.other) - 1;
4909 unsigned descr_vis = ELF_ST_VISIBILITY (fdh->elf.other) - 1;
4910 if (entry_vis < descr_vis)
4911 fdh->elf.other += entry_vis - descr_vis;
4912 else if (entry_vis > descr_vis)
4913 eh->elf.other += descr_vis - entry_vis;
4914
4915 if ((fdh->elf.root.type == bfd_link_hash_defined
4916 || fdh->elf.root.type == bfd_link_hash_defweak)
4917 && eh->elf.root.type == bfd_link_hash_undefined)
4918 {
4919 eh->elf.root.type = bfd_link_hash_undefweak;
4920 eh->was_undefined = 1;
4921 htab->twiddled_syms = 1;
4922 }
4923 }
4924
4925 return TRUE;
4926 }
4927
4928 /* Process list of dot-symbols we made in link_hash_newfunc. */
4929
4930 static bfd_boolean
4931 ppc64_elf_process_dot_syms (bfd *ibfd, struct bfd_link_info *info)
4932 {
4933 struct ppc_link_hash_table *htab;
4934 struct ppc_link_hash_entry **p, *eh;
4935
4936 if (!is_ppc64_elf (info->output_bfd))
4937 return TRUE;
4938 htab = ppc_hash_table (info);
4939 if (htab == NULL)
4940 return FALSE;
4941
4942 if (is_ppc64_elf (ibfd))
4943 {
4944 p = &htab->dot_syms;
4945 while ((eh = *p) != NULL)
4946 {
4947 *p = NULL;
4948 if (&eh->elf == htab->elf.hgot)
4949 ;
4950 else if (htab->elf.hgot == NULL
4951 && strcmp (eh->elf.root.root.string, ".TOC.") == 0)
4952 htab->elf.hgot = &eh->elf;
4953 else if (!add_symbol_adjust (eh, info))
4954 return FALSE;
4955 p = &eh->u.next_dot_sym;
4956 }
4957 }
4958
4959 /* Clear the list for non-ppc64 input files. */
4960 p = &htab->dot_syms;
4961 while ((eh = *p) != NULL)
4962 {
4963 *p = NULL;
4964 p = &eh->u.next_dot_sym;
4965 }
4966
4967 /* We need to fix the undefs list for any syms we have twiddled to
4968 undef_weak. */
4969 if (htab->twiddled_syms)
4970 {
4971 bfd_link_repair_undef_list (&htab->elf.root);
4972 htab->twiddled_syms = 0;
4973 }
4974 return TRUE;
4975 }
4976
4977 /* Undo hash table changes when an --as-needed input file is determined
4978 not to be needed. */
4979
4980 static bfd_boolean
4981 ppc64_elf_notice_as_needed (bfd *ibfd,
4982 struct bfd_link_info *info,
4983 enum notice_asneeded_action act)
4984 {
4985 if (act == notice_not_needed)
4986 {
4987 struct ppc_link_hash_table *htab = ppc_hash_table (info);
4988
4989 if (htab == NULL)
4990 return FALSE;
4991
4992 htab->dot_syms = NULL;
4993 }
4994 return _bfd_elf_notice_as_needed (ibfd, info, act);
4995 }
4996
4997 /* If --just-symbols against a final linked binary, then assume we need
4998 toc adjusting stubs when calling functions defined there. */
4999
5000 static void
5001 ppc64_elf_link_just_syms (asection *sec, struct bfd_link_info *info)
5002 {
5003 if ((sec->flags & SEC_CODE) != 0
5004 && (sec->owner->flags & (EXEC_P | DYNAMIC)) != 0
5005 && is_ppc64_elf (sec->owner))
5006 {
5007 asection *got = bfd_get_section_by_name (sec->owner, ".got");
5008 if (got != NULL
5009 && got->size >= elf_backend_got_header_size
5010 && bfd_get_section_by_name (sec->owner, ".opd") != NULL)
5011 sec->has_toc_reloc = 1;
5012 }
5013 _bfd_elf_link_just_syms (sec, info);
5014 }
5015
5016 static struct plt_entry **
5017 update_local_sym_info (bfd *abfd, Elf_Internal_Shdr *symtab_hdr,
5018 unsigned long r_symndx, bfd_vma r_addend, int tls_type)
5019 {
5020 struct got_entry **local_got_ents = elf_local_got_ents (abfd);
5021 struct plt_entry **local_plt;
5022 unsigned char *local_got_tls_masks;
5023
5024 if (local_got_ents == NULL)
5025 {
5026 bfd_size_type size = symtab_hdr->sh_info;
5027
5028 size *= (sizeof (*local_got_ents)
5029 + sizeof (*local_plt)
5030 + sizeof (*local_got_tls_masks));
5031 local_got_ents = bfd_zalloc (abfd, size);
5032 if (local_got_ents == NULL)
5033 return NULL;
5034 elf_local_got_ents (abfd) = local_got_ents;
5035 }
5036
5037 if ((tls_type & (PLT_IFUNC | TLS_EXPLICIT)) == 0)
5038 {
5039 struct got_entry *ent;
5040
5041 for (ent = local_got_ents[r_symndx]; ent != NULL; ent = ent->next)
5042 if (ent->addend == r_addend
5043 && ent->owner == abfd
5044 && ent->tls_type == tls_type)
5045 break;
5046 if (ent == NULL)
5047 {
5048 bfd_size_type amt = sizeof (*ent);
5049 ent = bfd_alloc (abfd, amt);
5050 if (ent == NULL)
5051 return FALSE;
5052 ent->next = local_got_ents[r_symndx];
5053 ent->addend = r_addend;
5054 ent->owner = abfd;
5055 ent->tls_type = tls_type;
5056 ent->is_indirect = FALSE;
5057 ent->got.refcount = 0;
5058 local_got_ents[r_symndx] = ent;
5059 }
5060 ent->got.refcount += 1;
5061 }
5062
5063 local_plt = (struct plt_entry **) (local_got_ents + symtab_hdr->sh_info);
5064 local_got_tls_masks = (unsigned char *) (local_plt + symtab_hdr->sh_info);
5065 local_got_tls_masks[r_symndx] |= tls_type;
5066
5067 return local_plt + r_symndx;
5068 }
5069
5070 static bfd_boolean
5071 update_plt_info (bfd *abfd, struct plt_entry **plist, bfd_vma addend)
5072 {
5073 struct plt_entry *ent;
5074
5075 for (ent = *plist; ent != NULL; ent = ent->next)
5076 if (ent->addend == addend)
5077 break;
5078 if (ent == NULL)
5079 {
5080 bfd_size_type amt = sizeof (*ent);
5081 ent = bfd_alloc (abfd, amt);
5082 if (ent == NULL)
5083 return FALSE;
5084 ent->next = *plist;
5085 ent->addend = addend;
5086 ent->plt.refcount = 0;
5087 *plist = ent;
5088 }
5089 ent->plt.refcount += 1;
5090 return TRUE;
5091 }
5092
5093 static bfd_boolean
5094 is_branch_reloc (enum elf_ppc64_reloc_type r_type)
5095 {
5096 return (r_type == R_PPC64_REL24
5097 || r_type == R_PPC64_REL14
5098 || r_type == R_PPC64_REL14_BRTAKEN
5099 || r_type == R_PPC64_REL14_BRNTAKEN
5100 || r_type == R_PPC64_ADDR24
5101 || r_type == R_PPC64_ADDR14
5102 || r_type == R_PPC64_ADDR14_BRTAKEN
5103 || r_type == R_PPC64_ADDR14_BRNTAKEN);
5104 }
5105
5106 /* Look through the relocs for a section during the first phase, and
5107 calculate needed space in the global offset table, procedure
5108 linkage table, and dynamic reloc sections. */
5109
5110 static bfd_boolean
5111 ppc64_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
5112 asection *sec, const Elf_Internal_Rela *relocs)
5113 {
5114 struct ppc_link_hash_table *htab;
5115 Elf_Internal_Shdr *symtab_hdr;
5116 struct elf_link_hash_entry **sym_hashes;
5117 const Elf_Internal_Rela *rel;
5118 const Elf_Internal_Rela *rel_end;
5119 asection *sreloc;
5120 asection **opd_sym_map;
5121 struct elf_link_hash_entry *tga, *dottga;
5122
5123 if (info->relocatable)
5124 return TRUE;
5125
5126 /* Don't do anything special with non-loaded, non-alloced sections.
5127 In particular, any relocs in such sections should not affect GOT
5128 and PLT reference counting (ie. we don't allow them to create GOT
5129 or PLT entries), there's no possibility or desire to optimize TLS
5130 relocs, and there's not much point in propagating relocs to shared
5131 libs that the dynamic linker won't relocate. */
5132 if ((sec->flags & SEC_ALLOC) == 0)
5133 return TRUE;
5134
5135 BFD_ASSERT (is_ppc64_elf (abfd));
5136
5137 htab = ppc_hash_table (info);
5138 if (htab == NULL)
5139 return FALSE;
5140
5141 tga = elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
5142 FALSE, FALSE, TRUE);
5143 dottga = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
5144 FALSE, FALSE, TRUE);
5145 symtab_hdr = &elf_symtab_hdr (abfd);
5146 sym_hashes = elf_sym_hashes (abfd);
5147 sreloc = NULL;
5148 opd_sym_map = NULL;
5149 if (strcmp (sec->name, ".opd") == 0)
5150 {
5151 /* Garbage collection needs some extra help with .opd sections.
5152 We don't want to necessarily keep everything referenced by
5153 relocs in .opd, as that would keep all functions. Instead,
5154 if we reference an .opd symbol (a function descriptor), we
5155 want to keep the function code symbol's section. This is
5156 easy for global symbols, but for local syms we need to keep
5157 information about the associated function section. */
5158 bfd_size_type amt;
5159
5160 if (abiversion (abfd) == 0)
5161 set_abiversion (abfd, 1);
5162 else if (abiversion (abfd) == 2)
5163 {
5164 info->callbacks->einfo (_("%P: .opd not allowed in ABI version %d\n"),
5165 abiversion (abfd));
5166 bfd_set_error (bfd_error_bad_value);
5167 return FALSE;
5168 }
5169 amt = sec->size * sizeof (*opd_sym_map) / 8;
5170 opd_sym_map = bfd_zalloc (abfd, amt);
5171 if (opd_sym_map == NULL)
5172 return FALSE;
5173 ppc64_elf_section_data (sec)->u.opd.func_sec = opd_sym_map;
5174 BFD_ASSERT (ppc64_elf_section_data (sec)->sec_type == sec_normal);
5175 ppc64_elf_section_data (sec)->sec_type = sec_opd;
5176 }
5177
5178 rel_end = relocs + sec->reloc_count;
5179 for (rel = relocs; rel < rel_end; rel++)
5180 {
5181 unsigned long r_symndx;
5182 struct elf_link_hash_entry *h;
5183 enum elf_ppc64_reloc_type r_type;
5184 int tls_type;
5185 struct _ppc64_elf_section_data *ppc64_sec;
5186 struct plt_entry **ifunc;
5187
5188 r_symndx = ELF64_R_SYM (rel->r_info);
5189 if (r_symndx < symtab_hdr->sh_info)
5190 h = NULL;
5191 else
5192 {
5193 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
5194 h = elf_follow_link (h);
5195
5196 /* PR15323, ref flags aren't set for references in the same
5197 object. */
5198 h->root.non_ir_ref = 1;
5199
5200 if (h == htab->elf.hgot)
5201 sec->has_toc_reloc = 1;
5202 }
5203
5204 tls_type = 0;
5205 ifunc = NULL;
5206 if (h != NULL)
5207 {
5208 if (h->type == STT_GNU_IFUNC)
5209 {
5210 h->needs_plt = 1;
5211 ifunc = &h->plt.plist;
5212 }
5213 }
5214 else
5215 {
5216 Elf_Internal_Sym *isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5217 abfd, r_symndx);
5218 if (isym == NULL)
5219 return FALSE;
5220
5221 if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
5222 {
5223 ifunc = update_local_sym_info (abfd, symtab_hdr, r_symndx,
5224 rel->r_addend, PLT_IFUNC);
5225 if (ifunc == NULL)
5226 return FALSE;
5227 }
5228 }
5229 r_type = ELF64_R_TYPE (rel->r_info);
5230 if (is_branch_reloc (r_type))
5231 {
5232 if (h != NULL && (h == tga || h == dottga))
5233 {
5234 if (rel != relocs
5235 && (ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSGD
5236 || ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSLD))
5237 /* We have a new-style __tls_get_addr call with a marker
5238 reloc. */
5239 ;
5240 else
5241 /* Mark this section as having an old-style call. */
5242 sec->has_tls_get_addr_call = 1;
5243 }
5244
5245 /* STT_GNU_IFUNC symbols must have a PLT entry. */
5246 if (ifunc != NULL
5247 && !update_plt_info (abfd, ifunc, rel->r_addend))
5248 return FALSE;
5249 }
5250
5251 switch (r_type)
5252 {
5253 case R_PPC64_TLSGD:
5254 case R_PPC64_TLSLD:
5255 /* These special tls relocs tie a call to __tls_get_addr with
5256 its parameter symbol. */
5257 break;
5258
5259 case R_PPC64_GOT_TLSLD16:
5260 case R_PPC64_GOT_TLSLD16_LO:
5261 case R_PPC64_GOT_TLSLD16_HI:
5262 case R_PPC64_GOT_TLSLD16_HA:
5263 tls_type = TLS_TLS | TLS_LD;
5264 goto dogottls;
5265
5266 case R_PPC64_GOT_TLSGD16:
5267 case R_PPC64_GOT_TLSGD16_LO:
5268 case R_PPC64_GOT_TLSGD16_HI:
5269 case R_PPC64_GOT_TLSGD16_HA:
5270 tls_type = TLS_TLS | TLS_GD;
5271 goto dogottls;
5272
5273 case R_PPC64_GOT_TPREL16_DS:
5274 case R_PPC64_GOT_TPREL16_LO_DS:
5275 case R_PPC64_GOT_TPREL16_HI:
5276 case R_PPC64_GOT_TPREL16_HA:
5277 if (!info->executable)
5278 info->flags |= DF_STATIC_TLS;
5279 tls_type = TLS_TLS | TLS_TPREL;
5280 goto dogottls;
5281
5282 case R_PPC64_GOT_DTPREL16_DS:
5283 case R_PPC64_GOT_DTPREL16_LO_DS:
5284 case R_PPC64_GOT_DTPREL16_HI:
5285 case R_PPC64_GOT_DTPREL16_HA:
5286 tls_type = TLS_TLS | TLS_DTPREL;
5287 dogottls:
5288 sec->has_tls_reloc = 1;
5289 /* Fall thru */
5290
5291 case R_PPC64_GOT16:
5292 case R_PPC64_GOT16_DS:
5293 case R_PPC64_GOT16_HA:
5294 case R_PPC64_GOT16_HI:
5295 case R_PPC64_GOT16_LO:
5296 case R_PPC64_GOT16_LO_DS:
5297 /* This symbol requires a global offset table entry. */
5298 sec->has_toc_reloc = 1;
5299 if (r_type == R_PPC64_GOT_TLSLD16
5300 || r_type == R_PPC64_GOT_TLSGD16
5301 || r_type == R_PPC64_GOT_TPREL16_DS
5302 || r_type == R_PPC64_GOT_DTPREL16_DS
5303 || r_type == R_PPC64_GOT16
5304 || r_type == R_PPC64_GOT16_DS)
5305 {
5306 htab->do_multi_toc = 1;
5307 ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5308 }
5309
5310 if (ppc64_elf_tdata (abfd)->got == NULL
5311 && !create_got_section (abfd, info))
5312 return FALSE;
5313
5314 if (h != NULL)
5315 {
5316 struct ppc_link_hash_entry *eh;
5317 struct got_entry *ent;
5318
5319 eh = (struct ppc_link_hash_entry *) h;
5320 for (ent = eh->elf.got.glist; ent != NULL; ent = ent->next)
5321 if (ent->addend == rel->r_addend
5322 && ent->owner == abfd
5323 && ent->tls_type == tls_type)
5324 break;
5325 if (ent == NULL)
5326 {
5327 bfd_size_type amt = sizeof (*ent);
5328 ent = bfd_alloc (abfd, amt);
5329 if (ent == NULL)
5330 return FALSE;
5331 ent->next = eh->elf.got.glist;
5332 ent->addend = rel->r_addend;
5333 ent->owner = abfd;
5334 ent->tls_type = tls_type;
5335 ent->is_indirect = FALSE;
5336 ent->got.refcount = 0;
5337 eh->elf.got.glist = ent;
5338 }
5339 ent->got.refcount += 1;
5340 eh->tls_mask |= tls_type;
5341 }
5342 else
5343 /* This is a global offset table entry for a local symbol. */
5344 if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5345 rel->r_addend, tls_type))
5346 return FALSE;
5347 break;
5348
5349 case R_PPC64_PLT16_HA:
5350 case R_PPC64_PLT16_HI:
5351 case R_PPC64_PLT16_LO:
5352 case R_PPC64_PLT32:
5353 case R_PPC64_PLT64:
5354 /* This symbol requires a procedure linkage table entry. We
5355 actually build the entry in adjust_dynamic_symbol,
5356 because this might be a case of linking PIC code without
5357 linking in any dynamic objects, in which case we don't
5358 need to generate a procedure linkage table after all. */
5359 if (h == NULL)
5360 {
5361 /* It does not make sense to have a procedure linkage
5362 table entry for a local symbol. */
5363 bfd_set_error (bfd_error_bad_value);
5364 return FALSE;
5365 }
5366 else
5367 {
5368 if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5369 return FALSE;
5370 h->needs_plt = 1;
5371 if (h->root.root.string[0] == '.'
5372 && h->root.root.string[1] != '\0')
5373 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5374 }
5375 break;
5376
5377 /* The following relocations don't need to propagate the
5378 relocation if linking a shared object since they are
5379 section relative. */
5380 case R_PPC64_SECTOFF:
5381 case R_PPC64_SECTOFF_LO:
5382 case R_PPC64_SECTOFF_HI:
5383 case R_PPC64_SECTOFF_HA:
5384 case R_PPC64_SECTOFF_DS:
5385 case R_PPC64_SECTOFF_LO_DS:
5386 case R_PPC64_DTPREL16:
5387 case R_PPC64_DTPREL16_LO:
5388 case R_PPC64_DTPREL16_HI:
5389 case R_PPC64_DTPREL16_HA:
5390 case R_PPC64_DTPREL16_DS:
5391 case R_PPC64_DTPREL16_LO_DS:
5392 case R_PPC64_DTPREL16_HIGH:
5393 case R_PPC64_DTPREL16_HIGHA:
5394 case R_PPC64_DTPREL16_HIGHER:
5395 case R_PPC64_DTPREL16_HIGHERA:
5396 case R_PPC64_DTPREL16_HIGHEST:
5397 case R_PPC64_DTPREL16_HIGHESTA:
5398 break;
5399
5400 /* Nor do these. */
5401 case R_PPC64_REL16:
5402 case R_PPC64_REL16_LO:
5403 case R_PPC64_REL16_HI:
5404 case R_PPC64_REL16_HA:
5405 break;
5406
5407 case R_PPC64_TOC16:
5408 case R_PPC64_TOC16_DS:
5409 htab->do_multi_toc = 1;
5410 ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5411 case R_PPC64_TOC16_LO:
5412 case R_PPC64_TOC16_HI:
5413 case R_PPC64_TOC16_HA:
5414 case R_PPC64_TOC16_LO_DS:
5415 sec->has_toc_reloc = 1;
5416 break;
5417
5418 /* This relocation describes the C++ object vtable hierarchy.
5419 Reconstruct it for later use during GC. */
5420 case R_PPC64_GNU_VTINHERIT:
5421 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
5422 return FALSE;
5423 break;
5424
5425 /* This relocation describes which C++ vtable entries are actually
5426 used. Record for later use during GC. */
5427 case R_PPC64_GNU_VTENTRY:
5428 BFD_ASSERT (h != NULL);
5429 if (h != NULL
5430 && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
5431 return FALSE;
5432 break;
5433
5434 case R_PPC64_REL14:
5435 case R_PPC64_REL14_BRTAKEN:
5436 case R_PPC64_REL14_BRNTAKEN:
5437 {
5438 asection *dest = NULL;
5439
5440 /* Heuristic: If jumping outside our section, chances are
5441 we are going to need a stub. */
5442 if (h != NULL)
5443 {
5444 /* If the sym is weak it may be overridden later, so
5445 don't assume we know where a weak sym lives. */
5446 if (h->root.type == bfd_link_hash_defined)
5447 dest = h->root.u.def.section;
5448 }
5449 else
5450 {
5451 Elf_Internal_Sym *isym;
5452
5453 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5454 abfd, r_symndx);
5455 if (isym == NULL)
5456 return FALSE;
5457
5458 dest = bfd_section_from_elf_index (abfd, isym->st_shndx);
5459 }
5460
5461 if (dest != sec)
5462 ppc64_elf_section_data (sec)->has_14bit_branch = 1;
5463 }
5464 /* Fall through. */
5465
5466 case R_PPC64_REL24:
5467 if (h != NULL && ifunc == NULL)
5468 {
5469 /* We may need a .plt entry if the function this reloc
5470 refers to is in a shared lib. */
5471 if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5472 return FALSE;
5473 h->needs_plt = 1;
5474 if (h->root.root.string[0] == '.'
5475 && h->root.root.string[1] != '\0')
5476 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5477 if (h == tga || h == dottga)
5478 sec->has_tls_reloc = 1;
5479 }
5480 break;
5481
5482 case R_PPC64_TPREL64:
5483 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_TPREL;
5484 if (!info->executable)
5485 info->flags |= DF_STATIC_TLS;
5486 goto dotlstoc;
5487
5488 case R_PPC64_DTPMOD64:
5489 if (rel + 1 < rel_end
5490 && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
5491 && rel[1].r_offset == rel->r_offset + 8)
5492 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_GD;
5493 else
5494 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_LD;
5495 goto dotlstoc;
5496
5497 case R_PPC64_DTPREL64:
5498 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_DTPREL;
5499 if (rel != relocs
5500 && rel[-1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPMOD64)
5501 && rel[-1].r_offset == rel->r_offset - 8)
5502 /* This is the second reloc of a dtpmod, dtprel pair.
5503 Don't mark with TLS_DTPREL. */
5504 goto dodyn;
5505
5506 dotlstoc:
5507 sec->has_tls_reloc = 1;
5508 if (h != NULL)
5509 {
5510 struct ppc_link_hash_entry *eh;
5511 eh = (struct ppc_link_hash_entry *) h;
5512 eh->tls_mask |= tls_type;
5513 }
5514 else
5515 if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5516 rel->r_addend, tls_type))
5517 return FALSE;
5518
5519 ppc64_sec = ppc64_elf_section_data (sec);
5520 if (ppc64_sec->sec_type != sec_toc)
5521 {
5522 bfd_size_type amt;
5523
5524 /* One extra to simplify get_tls_mask. */
5525 amt = sec->size * sizeof (unsigned) / 8 + sizeof (unsigned);
5526 ppc64_sec->u.toc.symndx = bfd_zalloc (abfd, amt);
5527 if (ppc64_sec->u.toc.symndx == NULL)
5528 return FALSE;
5529 amt = sec->size * sizeof (bfd_vma) / 8;
5530 ppc64_sec->u.toc.add = bfd_zalloc (abfd, amt);
5531 if (ppc64_sec->u.toc.add == NULL)
5532 return FALSE;
5533 BFD_ASSERT (ppc64_sec->sec_type == sec_normal);
5534 ppc64_sec->sec_type = sec_toc;
5535 }
5536 BFD_ASSERT (rel->r_offset % 8 == 0);
5537 ppc64_sec->u.toc.symndx[rel->r_offset / 8] = r_symndx;
5538 ppc64_sec->u.toc.add[rel->r_offset / 8] = rel->r_addend;
5539
5540 /* Mark the second slot of a GD or LD entry.
5541 -1 to indicate GD and -2 to indicate LD. */
5542 if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_GD))
5543 ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -1;
5544 else if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_LD))
5545 ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -2;
5546 goto dodyn;
5547
5548 case R_PPC64_TPREL16:
5549 case R_PPC64_TPREL16_LO:
5550 case R_PPC64_TPREL16_HI:
5551 case R_PPC64_TPREL16_HA:
5552 case R_PPC64_TPREL16_DS:
5553 case R_PPC64_TPREL16_LO_DS:
5554 case R_PPC64_TPREL16_HIGH:
5555 case R_PPC64_TPREL16_HIGHA:
5556 case R_PPC64_TPREL16_HIGHER:
5557 case R_PPC64_TPREL16_HIGHERA:
5558 case R_PPC64_TPREL16_HIGHEST:
5559 case R_PPC64_TPREL16_HIGHESTA:
5560 if (info->shared)
5561 {
5562 if (!info->executable)
5563 info->flags |= DF_STATIC_TLS;
5564 goto dodyn;
5565 }
5566 break;
5567
5568 case R_PPC64_ADDR64:
5569 if (opd_sym_map != NULL
5570 && rel + 1 < rel_end
5571 && ELF64_R_TYPE ((rel + 1)->r_info) == R_PPC64_TOC)
5572 {
5573 if (h != NULL)
5574 {
5575 if (h->root.root.string[0] == '.'
5576 && h->root.root.string[1] != 0
5577 && lookup_fdh ((struct ppc_link_hash_entry *) h, htab))
5578 ;
5579 else
5580 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5581 }
5582 else
5583 {
5584 asection *s;
5585 Elf_Internal_Sym *isym;
5586
5587 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5588 abfd, r_symndx);
5589 if (isym == NULL)
5590 return FALSE;
5591
5592 s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5593 if (s != NULL && s != sec)
5594 opd_sym_map[rel->r_offset / 8] = s;
5595 }
5596 }
5597 /* Fall through. */
5598
5599 case R_PPC64_REL30:
5600 case R_PPC64_REL32:
5601 case R_PPC64_REL64:
5602 case R_PPC64_ADDR14:
5603 case R_PPC64_ADDR14_BRNTAKEN:
5604 case R_PPC64_ADDR14_BRTAKEN:
5605 case R_PPC64_ADDR16:
5606 case R_PPC64_ADDR16_DS:
5607 case R_PPC64_ADDR16_HA:
5608 case R_PPC64_ADDR16_HI:
5609 case R_PPC64_ADDR16_HIGH:
5610 case R_PPC64_ADDR16_HIGHA:
5611 case R_PPC64_ADDR16_HIGHER:
5612 case R_PPC64_ADDR16_HIGHERA:
5613 case R_PPC64_ADDR16_HIGHEST:
5614 case R_PPC64_ADDR16_HIGHESTA:
5615 case R_PPC64_ADDR16_LO:
5616 case R_PPC64_ADDR16_LO_DS:
5617 case R_PPC64_ADDR24:
5618 case R_PPC64_ADDR32:
5619 case R_PPC64_UADDR16:
5620 case R_PPC64_UADDR32:
5621 case R_PPC64_UADDR64:
5622 case R_PPC64_TOC:
5623 if (h != NULL && !info->shared)
5624 /* We may need a copy reloc. */
5625 h->non_got_ref = 1;
5626
5627 /* Don't propagate .opd relocs. */
5628 if (NO_OPD_RELOCS && opd_sym_map != NULL)
5629 break;
5630
5631 /* If we are creating a shared library, and this is a reloc
5632 against a global symbol, or a non PC relative reloc
5633 against a local symbol, then we need to copy the reloc
5634 into the shared library. However, if we are linking with
5635 -Bsymbolic, we do not need to copy a reloc against a
5636 global symbol which is defined in an object we are
5637 including in the link (i.e., DEF_REGULAR is set). At
5638 this point we have not seen all the input files, so it is
5639 possible that DEF_REGULAR is not set now but will be set
5640 later (it is never cleared). In case of a weak definition,
5641 DEF_REGULAR may be cleared later by a strong definition in
5642 a shared library. We account for that possibility below by
5643 storing information in the dyn_relocs field of the hash
5644 table entry. A similar situation occurs when creating
5645 shared libraries and symbol visibility changes render the
5646 symbol local.
5647
5648 If on the other hand, we are creating an executable, we
5649 may need to keep relocations for symbols satisfied by a
5650 dynamic library if we manage to avoid copy relocs for the
5651 symbol. */
5652 dodyn:
5653 if ((info->shared
5654 && (must_be_dyn_reloc (info, r_type)
5655 || (h != NULL
5656 && (!SYMBOLIC_BIND (info, h)
5657 || h->root.type == bfd_link_hash_defweak
5658 || !h->def_regular))))
5659 || (ELIMINATE_COPY_RELOCS
5660 && !info->shared
5661 && h != NULL
5662 && (h->root.type == bfd_link_hash_defweak
5663 || !h->def_regular))
5664 || (!info->shared
5665 && ifunc != NULL))
5666 {
5667 /* We must copy these reloc types into the output file.
5668 Create a reloc section in dynobj and make room for
5669 this reloc. */
5670 if (sreloc == NULL)
5671 {
5672 sreloc = _bfd_elf_make_dynamic_reloc_section
5673 (sec, htab->elf.dynobj, 3, abfd, /*rela?*/ TRUE);
5674
5675 if (sreloc == NULL)
5676 return FALSE;
5677 }
5678
5679 /* If this is a global symbol, we count the number of
5680 relocations we need for this symbol. */
5681 if (h != NULL)
5682 {
5683 struct elf_dyn_relocs *p;
5684 struct elf_dyn_relocs **head;
5685
5686 head = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
5687 p = *head;
5688 if (p == NULL || p->sec != sec)
5689 {
5690 p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5691 if (p == NULL)
5692 return FALSE;
5693 p->next = *head;
5694 *head = p;
5695 p->sec = sec;
5696 p->count = 0;
5697 p->pc_count = 0;
5698 }
5699 p->count += 1;
5700 if (!must_be_dyn_reloc (info, r_type))
5701 p->pc_count += 1;
5702 }
5703 else
5704 {
5705 /* Track dynamic relocs needed for local syms too.
5706 We really need local syms available to do this
5707 easily. Oh well. */
5708 struct ppc_dyn_relocs *p;
5709 struct ppc_dyn_relocs **head;
5710 bfd_boolean is_ifunc;
5711 asection *s;
5712 void *vpp;
5713 Elf_Internal_Sym *isym;
5714
5715 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5716 abfd, r_symndx);
5717 if (isym == NULL)
5718 return FALSE;
5719
5720 s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5721 if (s == NULL)
5722 s = sec;
5723
5724 vpp = &elf_section_data (s)->local_dynrel;
5725 head = (struct ppc_dyn_relocs **) vpp;
5726 is_ifunc = ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC;
5727 p = *head;
5728 if (p != NULL && p->sec == sec && p->ifunc != is_ifunc)
5729 p = p->next;
5730 if (p == NULL || p->sec != sec || p->ifunc != is_ifunc)
5731 {
5732 p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5733 if (p == NULL)
5734 return FALSE;
5735 p->next = *head;
5736 *head = p;
5737 p->sec = sec;
5738 p->ifunc = is_ifunc;
5739 p->count = 0;
5740 }
5741 p->count += 1;
5742 }
5743 }
5744 break;
5745
5746 default:
5747 break;
5748 }
5749 }
5750
5751 return TRUE;
5752 }
5753
5754 /* Merge backend specific data from an object file to the output
5755 object file when linking. */
5756
5757 static bfd_boolean
5758 ppc64_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
5759 {
5760 unsigned long iflags, oflags;
5761
5762 if ((ibfd->flags & BFD_LINKER_CREATED) != 0)
5763 return TRUE;
5764
5765 if (!is_ppc64_elf (ibfd) || !is_ppc64_elf (obfd))
5766 return TRUE;
5767
5768 if (!_bfd_generic_verify_endian_match (ibfd, obfd))
5769 return FALSE;
5770
5771 iflags = elf_elfheader (ibfd)->e_flags;
5772 oflags = elf_elfheader (obfd)->e_flags;
5773
5774 if (!elf_flags_init (obfd) || oflags == 0)
5775 {
5776 elf_flags_init (obfd) = TRUE;
5777 elf_elfheader (obfd)->e_flags = iflags;
5778 }
5779 else if (iflags == oflags || iflags == 0)
5780 ;
5781 else if (iflags & ~EF_PPC64_ABI)
5782 {
5783 (*_bfd_error_handler)
5784 (_("%B uses unknown e_flags 0x%lx"), ibfd, iflags);
5785 bfd_set_error (bfd_error_bad_value);
5786 return FALSE;
5787 }
5788 else
5789 {
5790 (*_bfd_error_handler)
5791 (_("%B: ABI version %ld is not compatible with ABI version %ld output"),
5792 ibfd, iflags, oflags);
5793 bfd_set_error (bfd_error_bad_value);
5794 return FALSE;
5795 }
5796
5797 /* Merge Tag_compatibility attributes and any common GNU ones. */
5798 _bfd_elf_merge_object_attributes (ibfd, obfd);
5799
5800 return TRUE;
5801 }
5802
5803 static bfd_boolean
5804 ppc64_elf_print_private_bfd_data (bfd *abfd, void *ptr)
5805 {
5806 /* Print normal ELF private data. */
5807 _bfd_elf_print_private_bfd_data (abfd, ptr);
5808
5809 if (elf_elfheader (abfd)->e_flags != 0)
5810 {
5811 FILE *file = ptr;
5812
5813 /* xgettext:c-format */
5814 fprintf (file, _("private flags = 0x%lx:"),
5815 elf_elfheader (abfd)->e_flags);
5816
5817 if ((elf_elfheader (abfd)->e_flags & EF_PPC64_ABI) != 0)
5818 fprintf (file, _(" [abiv%ld]"),
5819 elf_elfheader (abfd)->e_flags & EF_PPC64_ABI);
5820 fputc ('\n', file);
5821 }
5822
5823 return TRUE;
5824 }
5825
5826 /* OFFSET in OPD_SEC specifies a function descriptor. Return the address
5827 of the code entry point, and its section. */
5828
5829 static bfd_vma
5830 opd_entry_value (asection *opd_sec,
5831 bfd_vma offset,
5832 asection **code_sec,
5833 bfd_vma *code_off,
5834 bfd_boolean in_code_sec)
5835 {
5836 bfd *opd_bfd = opd_sec->owner;
5837 Elf_Internal_Rela *relocs;
5838 Elf_Internal_Rela *lo, *hi, *look;
5839 bfd_vma val;
5840
5841 /* No relocs implies we are linking a --just-symbols object, or looking
5842 at a final linked executable with addr2line or somesuch. */
5843 if (opd_sec->reloc_count == 0)
5844 {
5845 bfd_byte *contents = ppc64_elf_tdata (opd_bfd)->opd.contents;
5846
5847 if (contents == NULL)
5848 {
5849 if (!bfd_malloc_and_get_section (opd_bfd, opd_sec, &contents))
5850 return (bfd_vma) -1;
5851 ppc64_elf_tdata (opd_bfd)->opd.contents = contents;
5852 }
5853
5854 val = bfd_get_64 (opd_bfd, contents + offset);
5855 if (code_sec != NULL)
5856 {
5857 asection *sec, *likely = NULL;
5858
5859 if (in_code_sec)
5860 {
5861 sec = *code_sec;
5862 if (sec->vma <= val
5863 && val < sec->vma + sec->size)
5864 likely = sec;
5865 else
5866 val = -1;
5867 }
5868 else
5869 for (sec = opd_bfd->sections; sec != NULL; sec = sec->next)
5870 if (sec->vma <= val
5871 && (sec->flags & SEC_LOAD) != 0
5872 && (sec->flags & SEC_ALLOC) != 0)
5873 likely = sec;
5874 if (likely != NULL)
5875 {
5876 *code_sec = likely;
5877 if (code_off != NULL)
5878 *code_off = val - likely->vma;
5879 }
5880 }
5881 return val;
5882 }
5883
5884 BFD_ASSERT (is_ppc64_elf (opd_bfd));
5885
5886 relocs = ppc64_elf_tdata (opd_bfd)->opd.relocs;
5887 if (relocs == NULL)
5888 relocs = _bfd_elf_link_read_relocs (opd_bfd, opd_sec, NULL, NULL, TRUE);
5889
5890 /* Go find the opd reloc at the sym address. */
5891 lo = relocs;
5892 BFD_ASSERT (lo != NULL);
5893 hi = lo + opd_sec->reloc_count - 1; /* ignore last reloc */
5894 val = (bfd_vma) -1;
5895 while (lo < hi)
5896 {
5897 look = lo + (hi - lo) / 2;
5898 if (look->r_offset < offset)
5899 lo = look + 1;
5900 else if (look->r_offset > offset)
5901 hi = look;
5902 else
5903 {
5904 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (opd_bfd);
5905
5906 if (ELF64_R_TYPE (look->r_info) == R_PPC64_ADDR64
5907 && ELF64_R_TYPE ((look + 1)->r_info) == R_PPC64_TOC)
5908 {
5909 unsigned long symndx = ELF64_R_SYM (look->r_info);
5910 asection *sec;
5911
5912 if (symndx < symtab_hdr->sh_info
5913 || elf_sym_hashes (opd_bfd) == NULL)
5914 {
5915 Elf_Internal_Sym *sym;
5916
5917 sym = (Elf_Internal_Sym *) symtab_hdr->contents;
5918 if (sym == NULL)
5919 {
5920 size_t symcnt = symtab_hdr->sh_info;
5921 if (elf_sym_hashes (opd_bfd) == NULL)
5922 symcnt = symtab_hdr->sh_size / symtab_hdr->sh_entsize;
5923 sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr, symcnt,
5924 0, NULL, NULL, NULL);
5925 if (sym == NULL)
5926 break;
5927 symtab_hdr->contents = (bfd_byte *) sym;
5928 }
5929
5930 sym += symndx;
5931 val = sym->st_value;
5932 sec = bfd_section_from_elf_index (opd_bfd, sym->st_shndx);
5933 BFD_ASSERT ((sec->flags & SEC_MERGE) == 0);
5934 }
5935 else
5936 {
5937 struct elf_link_hash_entry **sym_hashes;
5938 struct elf_link_hash_entry *rh;
5939
5940 sym_hashes = elf_sym_hashes (opd_bfd);
5941 rh = sym_hashes[symndx - symtab_hdr->sh_info];
5942 if (rh != NULL)
5943 {
5944 rh = elf_follow_link (rh);
5945 BFD_ASSERT (rh->root.type == bfd_link_hash_defined
5946 || rh->root.type == bfd_link_hash_defweak);
5947 val = rh->root.u.def.value;
5948 sec = rh->root.u.def.section;
5949 }
5950 else
5951 {
5952 /* Handle the odd case where we can be called
5953 during bfd_elf_link_add_symbols before the
5954 symbol hashes have been fully populated. */
5955 Elf_Internal_Sym *sym;
5956
5957 sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr, 1,
5958 symndx, NULL, NULL, NULL);
5959 if (sym == NULL)
5960 break;
5961
5962 val = sym->st_value;
5963 sec = bfd_section_from_elf_index (opd_bfd, sym->st_shndx);
5964 free (sym);
5965 }
5966 }
5967 val += look->r_addend;
5968 if (code_off != NULL)
5969 *code_off = val;
5970 if (code_sec != NULL)
5971 {
5972 if (in_code_sec && *code_sec != sec)
5973 return -1;
5974 else
5975 *code_sec = sec;
5976 }
5977 if (sec != NULL && sec->output_section != NULL)
5978 val += sec->output_section->vma + sec->output_offset;
5979 }
5980 break;
5981 }
5982 }
5983
5984 return val;
5985 }
5986
5987 /* If the ELF symbol SYM might be a function in SEC, return the
5988 function size and set *CODE_OFF to the function's entry point,
5989 otherwise return zero. */
5990
5991 static bfd_size_type
5992 ppc64_elf_maybe_function_sym (const asymbol *sym, asection *sec,
5993 bfd_vma *code_off)
5994 {
5995 bfd_size_type size;
5996
5997 if ((sym->flags & (BSF_SECTION_SYM | BSF_FILE | BSF_OBJECT
5998 | BSF_THREAD_LOCAL | BSF_RELC | BSF_SRELC)) != 0)
5999 return 0;
6000
6001 size = 0;
6002 if (!(sym->flags & BSF_SYNTHETIC))
6003 size = ((elf_symbol_type *) sym)->internal_elf_sym.st_size;
6004
6005 if (strcmp (sym->section->name, ".opd") == 0)
6006 {
6007 if (opd_entry_value (sym->section, sym->value,
6008 &sec, code_off, TRUE) == (bfd_vma) -1)
6009 return 0;
6010 /* An old ABI binary with dot-syms has a size of 24 on the .opd
6011 symbol. This size has nothing to do with the code size of the
6012 function, which is what we're supposed to return, but the
6013 code size isn't available without looking up the dot-sym.
6014 However, doing that would be a waste of time particularly
6015 since elf_find_function will look at the dot-sym anyway.
6016 Now, elf_find_function will keep the largest size of any
6017 function sym found at the code address of interest, so return
6018 1 here to avoid it incorrectly caching a larger function size
6019 for a small function. This does mean we return the wrong
6020 size for a new-ABI function of size 24, but all that does is
6021 disable caching for such functions. */
6022 if (size == 24)
6023 size = 1;
6024 }
6025 else
6026 {
6027 if (sym->section != sec)
6028 return 0;
6029 *code_off = sym->value;
6030 }
6031 if (size == 0)
6032 size = 1;
6033 return size;
6034 }
6035
6036 /* Return true if symbol is defined in a regular object file. */
6037
6038 static bfd_boolean
6039 is_static_defined (struct elf_link_hash_entry *h)
6040 {
6041 return ((h->root.type == bfd_link_hash_defined
6042 || h->root.type == bfd_link_hash_defweak)
6043 && h->root.u.def.section != NULL
6044 && h->root.u.def.section->output_section != NULL);
6045 }
6046
6047 /* If FDH is a function descriptor symbol, return the associated code
6048 entry symbol if it is defined. Return NULL otherwise. */
6049
6050 static struct ppc_link_hash_entry *
6051 defined_code_entry (struct ppc_link_hash_entry *fdh)
6052 {
6053 if (fdh->is_func_descriptor)
6054 {
6055 struct ppc_link_hash_entry *fh = ppc_follow_link (fdh->oh);
6056 if (fh->elf.root.type == bfd_link_hash_defined
6057 || fh->elf.root.type == bfd_link_hash_defweak)
6058 return fh;
6059 }
6060 return NULL;
6061 }
6062
6063 /* If FH is a function code entry symbol, return the associated
6064 function descriptor symbol if it is defined. Return NULL otherwise. */
6065
6066 static struct ppc_link_hash_entry *
6067 defined_func_desc (struct ppc_link_hash_entry *fh)
6068 {
6069 if (fh->oh != NULL
6070 && fh->oh->is_func_descriptor)
6071 {
6072 struct ppc_link_hash_entry *fdh = ppc_follow_link (fh->oh);
6073 if (fdh->elf.root.type == bfd_link_hash_defined
6074 || fdh->elf.root.type == bfd_link_hash_defweak)
6075 return fdh;
6076 }
6077 return NULL;
6078 }
6079
6080 /* Mark all our entry sym sections, both opd and code section. */
6081
6082 static void
6083 ppc64_elf_gc_keep (struct bfd_link_info *info)
6084 {
6085 struct ppc_link_hash_table *htab = ppc_hash_table (info);
6086 struct bfd_sym_chain *sym;
6087
6088 if (htab == NULL)
6089 return;
6090
6091 for (sym = info->gc_sym_list; sym != NULL; sym = sym->next)
6092 {
6093 struct ppc_link_hash_entry *eh, *fh;
6094 asection *sec;
6095
6096 eh = (struct ppc_link_hash_entry *)
6097 elf_link_hash_lookup (&htab->elf, sym->name, FALSE, FALSE, TRUE);
6098 if (eh == NULL)
6099 continue;
6100 if (eh->elf.root.type != bfd_link_hash_defined
6101 && eh->elf.root.type != bfd_link_hash_defweak)
6102 continue;
6103
6104 fh = defined_code_entry (eh);
6105 if (fh != NULL)
6106 {
6107 sec = fh->elf.root.u.def.section;
6108 sec->flags |= SEC_KEEP;
6109 }
6110 else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6111 && opd_entry_value (eh->elf.root.u.def.section,
6112 eh->elf.root.u.def.value,
6113 &sec, NULL, FALSE) != (bfd_vma) -1)
6114 sec->flags |= SEC_KEEP;
6115
6116 sec = eh->elf.root.u.def.section;
6117 sec->flags |= SEC_KEEP;
6118 }
6119 }
6120
6121 /* Mark sections containing dynamically referenced symbols. When
6122 building shared libraries, we must assume that any visible symbol is
6123 referenced. */
6124
6125 static bfd_boolean
6126 ppc64_elf_gc_mark_dynamic_ref (struct elf_link_hash_entry *h, void *inf)
6127 {
6128 struct bfd_link_info *info = (struct bfd_link_info *) inf;
6129 struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
6130 struct ppc_link_hash_entry *fdh;
6131
6132 /* Dynamic linking info is on the func descriptor sym. */
6133 fdh = defined_func_desc (eh);
6134 if (fdh != NULL)
6135 eh = fdh;
6136
6137 if ((eh->elf.root.type == bfd_link_hash_defined
6138 || eh->elf.root.type == bfd_link_hash_defweak)
6139 && (eh->elf.ref_dynamic
6140 || (!info->executable
6141 && eh->elf.def_regular
6142 && ELF_ST_VISIBILITY (eh->elf.other) != STV_INTERNAL
6143 && ELF_ST_VISIBILITY (eh->elf.other) != STV_HIDDEN
6144 && (strchr (eh->elf.root.root.string, ELF_VER_CHR) != NULL
6145 || !bfd_hide_sym_by_version (info->version_info,
6146 eh->elf.root.root.string)))))
6147 {
6148 asection *code_sec;
6149 struct ppc_link_hash_entry *fh;
6150
6151 eh->elf.root.u.def.section->flags |= SEC_KEEP;
6152
6153 /* Function descriptor syms cause the associated
6154 function code sym section to be marked. */
6155 fh = defined_code_entry (eh);
6156 if (fh != NULL)
6157 {
6158 code_sec = fh->elf.root.u.def.section;
6159 code_sec->flags |= SEC_KEEP;
6160 }
6161 else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6162 && opd_entry_value (eh->elf.root.u.def.section,
6163 eh->elf.root.u.def.value,
6164 &code_sec, NULL, FALSE) != (bfd_vma) -1)
6165 code_sec->flags |= SEC_KEEP;
6166 }
6167
6168 return TRUE;
6169 }
6170
6171 /* Return the section that should be marked against GC for a given
6172 relocation. */
6173
6174 static asection *
6175 ppc64_elf_gc_mark_hook (asection *sec,
6176 struct bfd_link_info *info,
6177 Elf_Internal_Rela *rel,
6178 struct elf_link_hash_entry *h,
6179 Elf_Internal_Sym *sym)
6180 {
6181 asection *rsec;
6182
6183 /* Syms return NULL if we're marking .opd, so we avoid marking all
6184 function sections, as all functions are referenced in .opd. */
6185 rsec = NULL;
6186 if (get_opd_info (sec) != NULL)
6187 return rsec;
6188
6189 if (h != NULL)
6190 {
6191 enum elf_ppc64_reloc_type r_type;
6192 struct ppc_link_hash_entry *eh, *fh, *fdh;
6193
6194 r_type = ELF64_R_TYPE (rel->r_info);
6195 switch (r_type)
6196 {
6197 case R_PPC64_GNU_VTINHERIT:
6198 case R_PPC64_GNU_VTENTRY:
6199 break;
6200
6201 default:
6202 switch (h->root.type)
6203 {
6204 case bfd_link_hash_defined:
6205 case bfd_link_hash_defweak:
6206 eh = (struct ppc_link_hash_entry *) h;
6207 fdh = defined_func_desc (eh);
6208 if (fdh != NULL)
6209 eh = fdh;
6210
6211 /* Function descriptor syms cause the associated
6212 function code sym section to be marked. */
6213 fh = defined_code_entry (eh);
6214 if (fh != NULL)
6215 {
6216 /* They also mark their opd section. */
6217 eh->elf.root.u.def.section->gc_mark = 1;
6218
6219 rsec = fh->elf.root.u.def.section;
6220 }
6221 else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6222 && opd_entry_value (eh->elf.root.u.def.section,
6223 eh->elf.root.u.def.value,
6224 &rsec, NULL, FALSE) != (bfd_vma) -1)
6225 eh->elf.root.u.def.section->gc_mark = 1;
6226 else
6227 rsec = h->root.u.def.section;
6228 break;
6229
6230 case bfd_link_hash_common:
6231 rsec = h->root.u.c.p->section;
6232 break;
6233
6234 default:
6235 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
6236 }
6237 }
6238 }
6239 else
6240 {
6241 struct _opd_sec_data *opd;
6242
6243 rsec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
6244 opd = get_opd_info (rsec);
6245 if (opd != NULL && opd->func_sec != NULL)
6246 {
6247 rsec->gc_mark = 1;
6248
6249 rsec = opd->func_sec[(sym->st_value + rel->r_addend) / 8];
6250 }
6251 }
6252
6253 return rsec;
6254 }
6255
6256 /* Update the .got, .plt. and dynamic reloc reference counts for the
6257 section being removed. */
6258
6259 static bfd_boolean
6260 ppc64_elf_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info,
6261 asection *sec, const Elf_Internal_Rela *relocs)
6262 {
6263 struct ppc_link_hash_table *htab;
6264 Elf_Internal_Shdr *symtab_hdr;
6265 struct elf_link_hash_entry **sym_hashes;
6266 struct got_entry **local_got_ents;
6267 const Elf_Internal_Rela *rel, *relend;
6268
6269 if (info->relocatable)
6270 return TRUE;
6271
6272 if ((sec->flags & SEC_ALLOC) == 0)
6273 return TRUE;
6274
6275 elf_section_data (sec)->local_dynrel = NULL;
6276
6277 htab = ppc_hash_table (info);
6278 if (htab == NULL)
6279 return FALSE;
6280
6281 symtab_hdr = &elf_symtab_hdr (abfd);
6282 sym_hashes = elf_sym_hashes (abfd);
6283 local_got_ents = elf_local_got_ents (abfd);
6284
6285 relend = relocs + sec->reloc_count;
6286 for (rel = relocs; rel < relend; rel++)
6287 {
6288 unsigned long r_symndx;
6289 enum elf_ppc64_reloc_type r_type;
6290 struct elf_link_hash_entry *h = NULL;
6291 unsigned char tls_type = 0;
6292
6293 r_symndx = ELF64_R_SYM (rel->r_info);
6294 r_type = ELF64_R_TYPE (rel->r_info);
6295 if (r_symndx >= symtab_hdr->sh_info)
6296 {
6297 struct ppc_link_hash_entry *eh;
6298 struct elf_dyn_relocs **pp;
6299 struct elf_dyn_relocs *p;
6300
6301 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
6302 h = elf_follow_link (h);
6303 eh = (struct ppc_link_hash_entry *) h;
6304
6305 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
6306 if (p->sec == sec)
6307 {
6308 /* Everything must go for SEC. */
6309 *pp = p->next;
6310 break;
6311 }
6312 }
6313
6314 if (is_branch_reloc (r_type))
6315 {
6316 struct plt_entry **ifunc = NULL;
6317 if (h != NULL)
6318 {
6319 if (h->type == STT_GNU_IFUNC)
6320 ifunc = &h->plt.plist;
6321 }
6322 else if (local_got_ents != NULL)
6323 {
6324 struct plt_entry **local_plt = (struct plt_entry **)
6325 (local_got_ents + symtab_hdr->sh_info);
6326 unsigned char *local_got_tls_masks = (unsigned char *)
6327 (local_plt + symtab_hdr->sh_info);
6328 if ((local_got_tls_masks[r_symndx] & PLT_IFUNC) != 0)
6329 ifunc = local_plt + r_symndx;
6330 }
6331 if (ifunc != NULL)
6332 {
6333 struct plt_entry *ent;
6334
6335 for (ent = *ifunc; ent != NULL; ent = ent->next)
6336 if (ent->addend == rel->r_addend)
6337 break;
6338 if (ent == NULL)
6339 abort ();
6340 if (ent->plt.refcount > 0)
6341 ent->plt.refcount -= 1;
6342 continue;
6343 }
6344 }
6345
6346 switch (r_type)
6347 {
6348 case R_PPC64_GOT_TLSLD16:
6349 case R_PPC64_GOT_TLSLD16_LO:
6350 case R_PPC64_GOT_TLSLD16_HI:
6351 case R_PPC64_GOT_TLSLD16_HA:
6352 tls_type = TLS_TLS | TLS_LD;
6353 goto dogot;
6354
6355 case R_PPC64_GOT_TLSGD16:
6356 case R_PPC64_GOT_TLSGD16_LO:
6357 case R_PPC64_GOT_TLSGD16_HI:
6358 case R_PPC64_GOT_TLSGD16_HA:
6359 tls_type = TLS_TLS | TLS_GD;
6360 goto dogot;
6361
6362 case R_PPC64_GOT_TPREL16_DS:
6363 case R_PPC64_GOT_TPREL16_LO_DS:
6364 case R_PPC64_GOT_TPREL16_HI:
6365 case R_PPC64_GOT_TPREL16_HA:
6366 tls_type = TLS_TLS | TLS_TPREL;
6367 goto dogot;
6368
6369 case R_PPC64_GOT_DTPREL16_DS:
6370 case R_PPC64_GOT_DTPREL16_LO_DS:
6371 case R_PPC64_GOT_DTPREL16_HI:
6372 case R_PPC64_GOT_DTPREL16_HA:
6373 tls_type = TLS_TLS | TLS_DTPREL;
6374 goto dogot;
6375
6376 case R_PPC64_GOT16:
6377 case R_PPC64_GOT16_DS:
6378 case R_PPC64_GOT16_HA:
6379 case R_PPC64_GOT16_HI:
6380 case R_PPC64_GOT16_LO:
6381 case R_PPC64_GOT16_LO_DS:
6382 dogot:
6383 {
6384 struct got_entry *ent;
6385
6386 if (h != NULL)
6387 ent = h->got.glist;
6388 else
6389 ent = local_got_ents[r_symndx];
6390
6391 for (; ent != NULL; ent = ent->next)
6392 if (ent->addend == rel->r_addend
6393 && ent->owner == abfd
6394 && ent->tls_type == tls_type)
6395 break;
6396 if (ent == NULL)
6397 abort ();
6398 if (ent->got.refcount > 0)
6399 ent->got.refcount -= 1;
6400 }
6401 break;
6402
6403 case R_PPC64_PLT16_HA:
6404 case R_PPC64_PLT16_HI:
6405 case R_PPC64_PLT16_LO:
6406 case R_PPC64_PLT32:
6407 case R_PPC64_PLT64:
6408 case R_PPC64_REL14:
6409 case R_PPC64_REL14_BRNTAKEN:
6410 case R_PPC64_REL14_BRTAKEN:
6411 case R_PPC64_REL24:
6412 if (h != NULL)
6413 {
6414 struct plt_entry *ent;
6415
6416 for (ent = h->plt.plist; ent != NULL; ent = ent->next)
6417 if (ent->addend == rel->r_addend)
6418 break;
6419 if (ent != NULL && ent->plt.refcount > 0)
6420 ent->plt.refcount -= 1;
6421 }
6422 break;
6423
6424 default:
6425 break;
6426 }
6427 }
6428 return TRUE;
6429 }
6430
6431 /* The maximum size of .sfpr. */
6432 #define SFPR_MAX (218*4)
6433
6434 struct sfpr_def_parms
6435 {
6436 const char name[12];
6437 unsigned char lo, hi;
6438 bfd_byte * (*write_ent) (bfd *, bfd_byte *, int);
6439 bfd_byte * (*write_tail) (bfd *, bfd_byte *, int);
6440 };
6441
6442 /* Auto-generate _save*, _rest* functions in .sfpr. */
6443
6444 static bfd_boolean
6445 sfpr_define (struct bfd_link_info *info, const struct sfpr_def_parms *parm)
6446 {
6447 struct ppc_link_hash_table *htab = ppc_hash_table (info);
6448 unsigned int i;
6449 size_t len = strlen (parm->name);
6450 bfd_boolean writing = FALSE;
6451 char sym[16];
6452
6453 if (htab == NULL)
6454 return FALSE;
6455
6456 memcpy (sym, parm->name, len);
6457 sym[len + 2] = 0;
6458
6459 for (i = parm->lo; i <= parm->hi; i++)
6460 {
6461 struct elf_link_hash_entry *h;
6462
6463 sym[len + 0] = i / 10 + '0';
6464 sym[len + 1] = i % 10 + '0';
6465 h = elf_link_hash_lookup (&htab->elf, sym, FALSE, FALSE, TRUE);
6466 if (h != NULL
6467 && !h->def_regular)
6468 {
6469 h->root.type = bfd_link_hash_defined;
6470 h->root.u.def.section = htab->sfpr;
6471 h->root.u.def.value = htab->sfpr->size;
6472 h->type = STT_FUNC;
6473 h->def_regular = 1;
6474 _bfd_elf_link_hash_hide_symbol (info, h, TRUE);
6475 writing = TRUE;
6476 if (htab->sfpr->contents == NULL)
6477 {
6478 htab->sfpr->contents = bfd_alloc (htab->elf.dynobj, SFPR_MAX);
6479 if (htab->sfpr->contents == NULL)
6480 return FALSE;
6481 }
6482 }
6483 if (writing)
6484 {
6485 bfd_byte *p = htab->sfpr->contents + htab->sfpr->size;
6486 if (i != parm->hi)
6487 p = (*parm->write_ent) (htab->elf.dynobj, p, i);
6488 else
6489 p = (*parm->write_tail) (htab->elf.dynobj, p, i);
6490 htab->sfpr->size = p - htab->sfpr->contents;
6491 }
6492 }
6493
6494 return TRUE;
6495 }
6496
6497 static bfd_byte *
6498 savegpr0 (bfd *abfd, bfd_byte *p, int r)
6499 {
6500 bfd_put_32 (abfd, STD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6501 return p + 4;
6502 }
6503
6504 static bfd_byte *
6505 savegpr0_tail (bfd *abfd, bfd_byte *p, int r)
6506 {
6507 p = savegpr0 (abfd, p, r);
6508 bfd_put_32 (abfd, STD_R0_0R1 + 16, p);
6509 p = p + 4;
6510 bfd_put_32 (abfd, BLR, p);
6511 return p + 4;
6512 }
6513
6514 static bfd_byte *
6515 restgpr0 (bfd *abfd, bfd_byte *p, int r)
6516 {
6517 bfd_put_32 (abfd, LD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6518 return p + 4;
6519 }
6520
6521 static bfd_byte *
6522 restgpr0_tail (bfd *abfd, bfd_byte *p, int r)
6523 {
6524 bfd_put_32 (abfd, LD_R0_0R1 + 16, p);
6525 p = p + 4;
6526 p = restgpr0 (abfd, p, r);
6527 bfd_put_32 (abfd, MTLR_R0, p);
6528 p = p + 4;
6529 if (r == 29)
6530 {
6531 p = restgpr0 (abfd, p, 30);
6532 p = restgpr0 (abfd, p, 31);
6533 }
6534 bfd_put_32 (abfd, BLR, p);
6535 return p + 4;
6536 }
6537
6538 static bfd_byte *
6539 savegpr1 (bfd *abfd, bfd_byte *p, int r)
6540 {
6541 bfd_put_32 (abfd, STD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6542 return p + 4;
6543 }
6544
6545 static bfd_byte *
6546 savegpr1_tail (bfd *abfd, bfd_byte *p, int r)
6547 {
6548 p = savegpr1 (abfd, p, r);
6549 bfd_put_32 (abfd, BLR, p);
6550 return p + 4;
6551 }
6552
6553 static bfd_byte *
6554 restgpr1 (bfd *abfd, bfd_byte *p, int r)
6555 {
6556 bfd_put_32 (abfd, LD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6557 return p + 4;
6558 }
6559
6560 static bfd_byte *
6561 restgpr1_tail (bfd *abfd, bfd_byte *p, int r)
6562 {
6563 p = restgpr1 (abfd, p, r);
6564 bfd_put_32 (abfd, BLR, p);
6565 return p + 4;
6566 }
6567
6568 static bfd_byte *
6569 savefpr (bfd *abfd, bfd_byte *p, int r)
6570 {
6571 bfd_put_32 (abfd, STFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6572 return p + 4;
6573 }
6574
6575 static bfd_byte *
6576 savefpr0_tail (bfd *abfd, bfd_byte *p, int r)
6577 {
6578 p = savefpr (abfd, p, r);
6579 bfd_put_32 (abfd, STD_R0_0R1 + 16, p);
6580 p = p + 4;
6581 bfd_put_32 (abfd, BLR, p);
6582 return p + 4;
6583 }
6584
6585 static bfd_byte *
6586 restfpr (bfd *abfd, bfd_byte *p, int r)
6587 {
6588 bfd_put_32 (abfd, LFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6589 return p + 4;
6590 }
6591
6592 static bfd_byte *
6593 restfpr0_tail (bfd *abfd, bfd_byte *p, int r)
6594 {
6595 bfd_put_32 (abfd, LD_R0_0R1 + 16, p);
6596 p = p + 4;
6597 p = restfpr (abfd, p, r);
6598 bfd_put_32 (abfd, MTLR_R0, p);
6599 p = p + 4;
6600 if (r == 29)
6601 {
6602 p = restfpr (abfd, p, 30);
6603 p = restfpr (abfd, p, 31);
6604 }
6605 bfd_put_32 (abfd, BLR, p);
6606 return p + 4;
6607 }
6608
6609 static bfd_byte *
6610 savefpr1_tail (bfd *abfd, bfd_byte *p, int r)
6611 {
6612 p = savefpr (abfd, p, r);
6613 bfd_put_32 (abfd, BLR, p);
6614 return p + 4;
6615 }
6616
6617 static bfd_byte *
6618 restfpr1_tail (bfd *abfd, bfd_byte *p, int r)
6619 {
6620 p = restfpr (abfd, p, r);
6621 bfd_put_32 (abfd, BLR, p);
6622 return p + 4;
6623 }
6624
6625 static bfd_byte *
6626 savevr (bfd *abfd, bfd_byte *p, int r)
6627 {
6628 bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6629 p = p + 4;
6630 bfd_put_32 (abfd, STVX_VR0_R12_R0 + (r << 21), p);
6631 return p + 4;
6632 }
6633
6634 static bfd_byte *
6635 savevr_tail (bfd *abfd, bfd_byte *p, int r)
6636 {
6637 p = savevr (abfd, p, r);
6638 bfd_put_32 (abfd, BLR, p);
6639 return p + 4;
6640 }
6641
6642 static bfd_byte *
6643 restvr (bfd *abfd, bfd_byte *p, int r)
6644 {
6645 bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6646 p = p + 4;
6647 bfd_put_32 (abfd, LVX_VR0_R12_R0 + (r << 21), p);
6648 return p + 4;
6649 }
6650
6651 static bfd_byte *
6652 restvr_tail (bfd *abfd, bfd_byte *p, int r)
6653 {
6654 p = restvr (abfd, p, r);
6655 bfd_put_32 (abfd, BLR, p);
6656 return p + 4;
6657 }
6658
6659 /* Called via elf_link_hash_traverse to transfer dynamic linking
6660 information on function code symbol entries to their corresponding
6661 function descriptor symbol entries. */
6662
6663 static bfd_boolean
6664 func_desc_adjust (struct elf_link_hash_entry *h, void *inf)
6665 {
6666 struct bfd_link_info *info;
6667 struct ppc_link_hash_table *htab;
6668 struct plt_entry *ent;
6669 struct ppc_link_hash_entry *fh;
6670 struct ppc_link_hash_entry *fdh;
6671 bfd_boolean force_local;
6672
6673 fh = (struct ppc_link_hash_entry *) h;
6674 if (fh->elf.root.type == bfd_link_hash_indirect)
6675 return TRUE;
6676
6677 info = inf;
6678 htab = ppc_hash_table (info);
6679 if (htab == NULL)
6680 return FALSE;
6681
6682 /* Resolve undefined references to dot-symbols as the value
6683 in the function descriptor, if we have one in a regular object.
6684 This is to satisfy cases like ".quad .foo". Calls to functions
6685 in dynamic objects are handled elsewhere. */
6686 if (fh->elf.root.type == bfd_link_hash_undefweak
6687 && fh->was_undefined
6688 && (fdh = defined_func_desc (fh)) != NULL
6689 && get_opd_info (fdh->elf.root.u.def.section) != NULL
6690 && opd_entry_value (fdh->elf.root.u.def.section,
6691 fdh->elf.root.u.def.value,
6692 &fh->elf.root.u.def.section,
6693 &fh->elf.root.u.def.value, FALSE) != (bfd_vma) -1)
6694 {
6695 fh->elf.root.type = fdh->elf.root.type;
6696 fh->elf.forced_local = 1;
6697 fh->elf.def_regular = fdh->elf.def_regular;
6698 fh->elf.def_dynamic = fdh->elf.def_dynamic;
6699 }
6700
6701 /* If this is a function code symbol, transfer dynamic linking
6702 information to the function descriptor symbol. */
6703 if (!fh->is_func)
6704 return TRUE;
6705
6706 for (ent = fh->elf.plt.plist; ent != NULL; ent = ent->next)
6707 if (ent->plt.refcount > 0)
6708 break;
6709 if (ent == NULL
6710 || fh->elf.root.root.string[0] != '.'
6711 || fh->elf.root.root.string[1] == '\0')
6712 return TRUE;
6713
6714 /* Find the corresponding function descriptor symbol. Create it
6715 as undefined if necessary. */
6716
6717 fdh = lookup_fdh (fh, htab);
6718 if (fdh == NULL
6719 && !info->executable
6720 && (fh->elf.root.type == bfd_link_hash_undefined
6721 || fh->elf.root.type == bfd_link_hash_undefweak))
6722 {
6723 fdh = make_fdh (info, fh);
6724 if (fdh == NULL)
6725 return FALSE;
6726 }
6727
6728 /* Fake function descriptors are made undefweak. If the function
6729 code symbol is strong undefined, make the fake sym the same.
6730 If the function code symbol is defined, then force the fake
6731 descriptor local; We can't support overriding of symbols in a
6732 shared library on a fake descriptor. */
6733
6734 if (fdh != NULL
6735 && fdh->fake
6736 && fdh->elf.root.type == bfd_link_hash_undefweak)
6737 {
6738 if (fh->elf.root.type == bfd_link_hash_undefined)
6739 {
6740 fdh->elf.root.type = bfd_link_hash_undefined;
6741 bfd_link_add_undef (&htab->elf.root, &fdh->elf.root);
6742 }
6743 else if (fh->elf.root.type == bfd_link_hash_defined
6744 || fh->elf.root.type == bfd_link_hash_defweak)
6745 {
6746 _bfd_elf_link_hash_hide_symbol (info, &fdh->elf, TRUE);
6747 }
6748 }
6749
6750 if (fdh != NULL
6751 && !fdh->elf.forced_local
6752 && (!info->executable
6753 || fdh->elf.def_dynamic
6754 || fdh->elf.ref_dynamic
6755 || (fdh->elf.root.type == bfd_link_hash_undefweak
6756 && ELF_ST_VISIBILITY (fdh->elf.other) == STV_DEFAULT)))
6757 {
6758 if (fdh->elf.dynindx == -1)
6759 if (! bfd_elf_link_record_dynamic_symbol (info, &fdh->elf))
6760 return FALSE;
6761 fdh->elf.ref_regular |= fh->elf.ref_regular;
6762 fdh->elf.ref_dynamic |= fh->elf.ref_dynamic;
6763 fdh->elf.ref_regular_nonweak |= fh->elf.ref_regular_nonweak;
6764 fdh->elf.non_got_ref |= fh->elf.non_got_ref;
6765 if (ELF_ST_VISIBILITY (fh->elf.other) == STV_DEFAULT)
6766 {
6767 move_plt_plist (fh, fdh);
6768 fdh->elf.needs_plt = 1;
6769 }
6770 fdh->is_func_descriptor = 1;
6771 fdh->oh = fh;
6772 fh->oh = fdh;
6773 }
6774
6775 /* Now that the info is on the function descriptor, clear the
6776 function code sym info. Any function code syms for which we
6777 don't have a definition in a regular file, we force local.
6778 This prevents a shared library from exporting syms that have
6779 been imported from another library. Function code syms that
6780 are really in the library we must leave global to prevent the
6781 linker dragging in a definition from a static library. */
6782 force_local = (!fh->elf.def_regular
6783 || fdh == NULL
6784 || !fdh->elf.def_regular
6785 || fdh->elf.forced_local);
6786 _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
6787
6788 return TRUE;
6789 }
6790
6791 /* Called near the start of bfd_elf_size_dynamic_sections. We use
6792 this hook to a) provide some gcc support functions, and b) transfer
6793 dynamic linking information gathered so far on function code symbol
6794 entries, to their corresponding function descriptor symbol entries. */
6795
6796 static bfd_boolean
6797 ppc64_elf_func_desc_adjust (bfd *obfd ATTRIBUTE_UNUSED,
6798 struct bfd_link_info *info)
6799 {
6800 struct ppc_link_hash_table *htab;
6801 unsigned int i;
6802 static const struct sfpr_def_parms funcs[] =
6803 {
6804 { "_savegpr0_", 14, 31, savegpr0, savegpr0_tail },
6805 { "_restgpr0_", 14, 29, restgpr0, restgpr0_tail },
6806 { "_restgpr0_", 30, 31, restgpr0, restgpr0_tail },
6807 { "_savegpr1_", 14, 31, savegpr1, savegpr1_tail },
6808 { "_restgpr1_", 14, 31, restgpr1, restgpr1_tail },
6809 { "_savefpr_", 14, 31, savefpr, savefpr0_tail },
6810 { "_restfpr_", 14, 29, restfpr, restfpr0_tail },
6811 { "_restfpr_", 30, 31, restfpr, restfpr0_tail },
6812 { "._savef", 14, 31, savefpr, savefpr1_tail },
6813 { "._restf", 14, 31, restfpr, restfpr1_tail },
6814 { "_savevr_", 20, 31, savevr, savevr_tail },
6815 { "_restvr_", 20, 31, restvr, restvr_tail }
6816 };
6817
6818 htab = ppc_hash_table (info);
6819 if (htab == NULL)
6820 return FALSE;
6821
6822 if (!info->relocatable
6823 && htab->elf.hgot != NULL)
6824 _bfd_elf_link_hash_hide_symbol (info, htab->elf.hgot, TRUE);
6825
6826 if (htab->sfpr == NULL)
6827 /* We don't have any relocs. */
6828 return TRUE;
6829
6830 /* Provide any missing _save* and _rest* functions. */
6831 htab->sfpr->size = 0;
6832 if (!info->relocatable)
6833 for (i = 0; i < sizeof (funcs) / sizeof (funcs[0]); i++)
6834 if (!sfpr_define (info, &funcs[i]))
6835 return FALSE;
6836
6837 elf_link_hash_traverse (&htab->elf, func_desc_adjust, info);
6838
6839 if (htab->sfpr->size == 0)
6840 htab->sfpr->flags |= SEC_EXCLUDE;
6841
6842 return TRUE;
6843 }
6844
6845 /* Adjust a symbol defined by a dynamic object and referenced by a
6846 regular object. The current definition is in some section of the
6847 dynamic object, but we're not including those sections. We have to
6848 change the definition to something the rest of the link can
6849 understand. */
6850
6851 static bfd_boolean
6852 ppc64_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
6853 struct elf_link_hash_entry *h)
6854 {
6855 struct ppc_link_hash_table *htab;
6856 asection *s;
6857
6858 htab = ppc_hash_table (info);
6859 if (htab == NULL)
6860 return FALSE;
6861
6862 /* Deal with function syms. */
6863 if (h->type == STT_FUNC
6864 || h->type == STT_GNU_IFUNC
6865 || h->needs_plt)
6866 {
6867 /* Clear procedure linkage table information for any symbol that
6868 won't need a .plt entry. */
6869 struct plt_entry *ent;
6870 for (ent = h->plt.plist; ent != NULL; ent = ent->next)
6871 if (ent->plt.refcount > 0)
6872 break;
6873 if (ent == NULL
6874 || (h->type != STT_GNU_IFUNC
6875 && (SYMBOL_CALLS_LOCAL (info, h)
6876 || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
6877 && h->root.type == bfd_link_hash_undefweak))))
6878 {
6879 h->plt.plist = NULL;
6880 h->needs_plt = 0;
6881 }
6882 }
6883 else
6884 h->plt.plist = NULL;
6885
6886 /* If this is a weak symbol, and there is a real definition, the
6887 processor independent code will have arranged for us to see the
6888 real definition first, and we can just use the same value. */
6889 if (h->u.weakdef != NULL)
6890 {
6891 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
6892 || h->u.weakdef->root.type == bfd_link_hash_defweak);
6893 h->root.u.def.section = h->u.weakdef->root.u.def.section;
6894 h->root.u.def.value = h->u.weakdef->root.u.def.value;
6895 if (ELIMINATE_COPY_RELOCS)
6896 h->non_got_ref = h->u.weakdef->non_got_ref;
6897 return TRUE;
6898 }
6899
6900 /* If we are creating a shared library, we must presume that the
6901 only references to the symbol are via the global offset table.
6902 For such cases we need not do anything here; the relocations will
6903 be handled correctly by relocate_section. */
6904 if (info->shared)
6905 return TRUE;
6906
6907 /* If there are no references to this symbol that do not use the
6908 GOT, we don't need to generate a copy reloc. */
6909 if (!h->non_got_ref)
6910 return TRUE;
6911
6912 /* Don't generate a copy reloc for symbols defined in the executable. */
6913 if (!h->def_dynamic || !h->ref_regular || h->def_regular)
6914 return TRUE;
6915
6916 if (ELIMINATE_COPY_RELOCS)
6917 {
6918 struct ppc_link_hash_entry * eh;
6919 struct elf_dyn_relocs *p;
6920
6921 eh = (struct ppc_link_hash_entry *) h;
6922 for (p = eh->dyn_relocs; p != NULL; p = p->next)
6923 {
6924 s = p->sec->output_section;
6925 if (s != NULL && (s->flags & SEC_READONLY) != 0)
6926 break;
6927 }
6928
6929 /* If we didn't find any dynamic relocs in read-only sections, then
6930 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
6931 if (p == NULL)
6932 {
6933 h->non_got_ref = 0;
6934 return TRUE;
6935 }
6936 }
6937
6938 if (h->plt.plist != NULL)
6939 {
6940 /* We should never get here, but unfortunately there are versions
6941 of gcc out there that improperly (for this ABI) put initialized
6942 function pointers, vtable refs and suchlike in read-only
6943 sections. Allow them to proceed, but warn that this might
6944 break at runtime. */
6945 info->callbacks->einfo
6946 (_("%P: copy reloc against `%T' requires lazy plt linking; "
6947 "avoid setting LD_BIND_NOW=1 or upgrade gcc\n"),
6948 h->root.root.string);
6949 }
6950
6951 /* This is a reference to a symbol defined by a dynamic object which
6952 is not a function. */
6953
6954 /* We must allocate the symbol in our .dynbss section, which will
6955 become part of the .bss section of the executable. There will be
6956 an entry for this symbol in the .dynsym section. The dynamic
6957 object will contain position independent code, so all references
6958 from the dynamic object to this symbol will go through the global
6959 offset table. The dynamic linker will use the .dynsym entry to
6960 determine the address it must put in the global offset table, so
6961 both the dynamic object and the regular object will refer to the
6962 same memory location for the variable. */
6963
6964 /* We must generate a R_PPC64_COPY reloc to tell the dynamic linker
6965 to copy the initial value out of the dynamic object and into the
6966 runtime process image. We need to remember the offset into the
6967 .rela.bss section we are going to use. */
6968 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
6969 {
6970 htab->relbss->size += sizeof (Elf64_External_Rela);
6971 h->needs_copy = 1;
6972 }
6973
6974 s = htab->dynbss;
6975
6976 return _bfd_elf_adjust_dynamic_copy (h, s);
6977 }
6978
6979 /* If given a function descriptor symbol, hide both the function code
6980 sym and the descriptor. */
6981 static void
6982 ppc64_elf_hide_symbol (struct bfd_link_info *info,
6983 struct elf_link_hash_entry *h,
6984 bfd_boolean force_local)
6985 {
6986 struct ppc_link_hash_entry *eh;
6987 _bfd_elf_link_hash_hide_symbol (info, h, force_local);
6988
6989 eh = (struct ppc_link_hash_entry *) h;
6990 if (eh->is_func_descriptor)
6991 {
6992 struct ppc_link_hash_entry *fh = eh->oh;
6993
6994 if (fh == NULL)
6995 {
6996 const char *p, *q;
6997 struct ppc_link_hash_table *htab;
6998 char save;
6999
7000 /* We aren't supposed to use alloca in BFD because on
7001 systems which do not have alloca the version in libiberty
7002 calls xmalloc, which might cause the program to crash
7003 when it runs out of memory. This function doesn't have a
7004 return status, so there's no way to gracefully return an
7005 error. So cheat. We know that string[-1] can be safely
7006 accessed; It's either a string in an ELF string table,
7007 or allocated in an objalloc structure. */
7008
7009 p = eh->elf.root.root.string - 1;
7010 save = *p;
7011 *(char *) p = '.';
7012 htab = ppc_hash_table (info);
7013 if (htab == NULL)
7014 return;
7015
7016 fh = (struct ppc_link_hash_entry *)
7017 elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
7018 *(char *) p = save;
7019
7020 /* Unfortunately, if it so happens that the string we were
7021 looking for was allocated immediately before this string,
7022 then we overwrote the string terminator. That's the only
7023 reason the lookup should fail. */
7024 if (fh == NULL)
7025 {
7026 q = eh->elf.root.root.string + strlen (eh->elf.root.root.string);
7027 while (q >= eh->elf.root.root.string && *q == *p)
7028 --q, --p;
7029 if (q < eh->elf.root.root.string && *p == '.')
7030 fh = (struct ppc_link_hash_entry *)
7031 elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
7032 }
7033 if (fh != NULL)
7034 {
7035 eh->oh = fh;
7036 fh->oh = eh;
7037 }
7038 }
7039 if (fh != NULL)
7040 _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
7041 }
7042 }
7043
7044 static bfd_boolean
7045 get_sym_h (struct elf_link_hash_entry **hp,
7046 Elf_Internal_Sym **symp,
7047 asection **symsecp,
7048 unsigned char **tls_maskp,
7049 Elf_Internal_Sym **locsymsp,
7050 unsigned long r_symndx,
7051 bfd *ibfd)
7052 {
7053 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
7054
7055 if (r_symndx >= symtab_hdr->sh_info)
7056 {
7057 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
7058 struct elf_link_hash_entry *h;
7059
7060 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
7061 h = elf_follow_link (h);
7062
7063 if (hp != NULL)
7064 *hp = h;
7065
7066 if (symp != NULL)
7067 *symp = NULL;
7068
7069 if (symsecp != NULL)
7070 {
7071 asection *symsec = NULL;
7072 if (h->root.type == bfd_link_hash_defined
7073 || h->root.type == bfd_link_hash_defweak)
7074 symsec = h->root.u.def.section;
7075 *symsecp = symsec;
7076 }
7077
7078 if (tls_maskp != NULL)
7079 {
7080 struct ppc_link_hash_entry *eh;
7081
7082 eh = (struct ppc_link_hash_entry *) h;
7083 *tls_maskp = &eh->tls_mask;
7084 }
7085 }
7086 else
7087 {
7088 Elf_Internal_Sym *sym;
7089 Elf_Internal_Sym *locsyms = *locsymsp;
7090
7091 if (locsyms == NULL)
7092 {
7093 locsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
7094 if (locsyms == NULL)
7095 locsyms = bfd_elf_get_elf_syms (ibfd, symtab_hdr,
7096 symtab_hdr->sh_info,
7097 0, NULL, NULL, NULL);
7098 if (locsyms == NULL)
7099 return FALSE;
7100 *locsymsp = locsyms;
7101 }
7102 sym = locsyms + r_symndx;
7103
7104 if (hp != NULL)
7105 *hp = NULL;
7106
7107 if (symp != NULL)
7108 *symp = sym;
7109
7110 if (symsecp != NULL)
7111 *symsecp = bfd_section_from_elf_index (ibfd, sym->st_shndx);
7112
7113 if (tls_maskp != NULL)
7114 {
7115 struct got_entry **lgot_ents;
7116 unsigned char *tls_mask;
7117
7118 tls_mask = NULL;
7119 lgot_ents = elf_local_got_ents (ibfd);
7120 if (lgot_ents != NULL)
7121 {
7122 struct plt_entry **local_plt = (struct plt_entry **)
7123 (lgot_ents + symtab_hdr->sh_info);
7124 unsigned char *lgot_masks = (unsigned char *)
7125 (local_plt + symtab_hdr->sh_info);
7126 tls_mask = &lgot_masks[r_symndx];
7127 }
7128 *tls_maskp = tls_mask;
7129 }
7130 }
7131 return TRUE;
7132 }
7133
7134 /* Returns TLS_MASKP for the given REL symbol. Function return is 0 on
7135 error, 2 on a toc GD type suitable for optimization, 3 on a toc LD
7136 type suitable for optimization, and 1 otherwise. */
7137
7138 static int
7139 get_tls_mask (unsigned char **tls_maskp,
7140 unsigned long *toc_symndx,
7141 bfd_vma *toc_addend,
7142 Elf_Internal_Sym **locsymsp,
7143 const Elf_Internal_Rela *rel,
7144 bfd *ibfd)
7145 {
7146 unsigned long r_symndx;
7147 int next_r;
7148 struct elf_link_hash_entry *h;
7149 Elf_Internal_Sym *sym;
7150 asection *sec;
7151 bfd_vma off;
7152
7153 r_symndx = ELF64_R_SYM (rel->r_info);
7154 if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7155 return 0;
7156
7157 if ((*tls_maskp != NULL && **tls_maskp != 0)
7158 || sec == NULL
7159 || ppc64_elf_section_data (sec) == NULL
7160 || ppc64_elf_section_data (sec)->sec_type != sec_toc)
7161 return 1;
7162
7163 /* Look inside a TOC section too. */
7164 if (h != NULL)
7165 {
7166 BFD_ASSERT (h->root.type == bfd_link_hash_defined);
7167 off = h->root.u.def.value;
7168 }
7169 else
7170 off = sym->st_value;
7171 off += rel->r_addend;
7172 BFD_ASSERT (off % 8 == 0);
7173 r_symndx = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8];
7174 next_r = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8 + 1];
7175 if (toc_symndx != NULL)
7176 *toc_symndx = r_symndx;
7177 if (toc_addend != NULL)
7178 *toc_addend = ppc64_elf_section_data (sec)->u.toc.add[off / 8];
7179 if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7180 return 0;
7181 if ((h == NULL || is_static_defined (h))
7182 && (next_r == -1 || next_r == -2))
7183 return 1 - next_r;
7184 return 1;
7185 }
7186
7187 /* Find (or create) an entry in the tocsave hash table. */
7188
7189 static struct tocsave_entry *
7190 tocsave_find (struct ppc_link_hash_table *htab,
7191 enum insert_option insert,
7192 Elf_Internal_Sym **local_syms,
7193 const Elf_Internal_Rela *irela,
7194 bfd *ibfd)
7195 {
7196 unsigned long r_indx;
7197 struct elf_link_hash_entry *h;
7198 Elf_Internal_Sym *sym;
7199 struct tocsave_entry ent, *p;
7200 hashval_t hash;
7201 struct tocsave_entry **slot;
7202
7203 r_indx = ELF64_R_SYM (irela->r_info);
7204 if (!get_sym_h (&h, &sym, &ent.sec, NULL, local_syms, r_indx, ibfd))
7205 return NULL;
7206 if (ent.sec == NULL || ent.sec->output_section == NULL)
7207 {
7208 (*_bfd_error_handler)
7209 (_("%B: undefined symbol on R_PPC64_TOCSAVE relocation"));
7210 return NULL;
7211 }
7212
7213 if (h != NULL)
7214 ent.offset = h->root.u.def.value;
7215 else
7216 ent.offset = sym->st_value;
7217 ent.offset += irela->r_addend;
7218
7219 hash = tocsave_htab_hash (&ent);
7220 slot = ((struct tocsave_entry **)
7221 htab_find_slot_with_hash (htab->tocsave_htab, &ent, hash, insert));
7222 if (slot == NULL)
7223 return NULL;
7224
7225 if (*slot == NULL)
7226 {
7227 p = (struct tocsave_entry *) bfd_alloc (ibfd, sizeof (*p));
7228 if (p == NULL)
7229 return NULL;
7230 *p = ent;
7231 *slot = p;
7232 }
7233 return *slot;
7234 }
7235
7236 /* Adjust all global syms defined in opd sections. In gcc generated
7237 code for the old ABI, these will already have been done. */
7238
7239 static bfd_boolean
7240 adjust_opd_syms (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
7241 {
7242 struct ppc_link_hash_entry *eh;
7243 asection *sym_sec;
7244 struct _opd_sec_data *opd;
7245
7246 if (h->root.type == bfd_link_hash_indirect)
7247 return TRUE;
7248
7249 if (h->root.type != bfd_link_hash_defined
7250 && h->root.type != bfd_link_hash_defweak)
7251 return TRUE;
7252
7253 eh = (struct ppc_link_hash_entry *) h;
7254 if (eh->adjust_done)
7255 return TRUE;
7256
7257 sym_sec = eh->elf.root.u.def.section;
7258 opd = get_opd_info (sym_sec);
7259 if (opd != NULL && opd->adjust != NULL)
7260 {
7261 long adjust = opd->adjust[eh->elf.root.u.def.value / 8];
7262 if (adjust == -1)
7263 {
7264 /* This entry has been deleted. */
7265 asection *dsec = ppc64_elf_tdata (sym_sec->owner)->deleted_section;
7266 if (dsec == NULL)
7267 {
7268 for (dsec = sym_sec->owner->sections; dsec; dsec = dsec->next)
7269 if (discarded_section (dsec))
7270 {
7271 ppc64_elf_tdata (sym_sec->owner)->deleted_section = dsec;
7272 break;
7273 }
7274 }
7275 eh->elf.root.u.def.value = 0;
7276 eh->elf.root.u.def.section = dsec;
7277 }
7278 else
7279 eh->elf.root.u.def.value += adjust;
7280 eh->adjust_done = 1;
7281 }
7282 return TRUE;
7283 }
7284
7285 /* Handles decrementing dynamic reloc counts for the reloc specified by
7286 R_INFO in section SEC. If LOCAL_SYMS is NULL, then H and SYM
7287 have already been determined. */
7288
7289 static bfd_boolean
7290 dec_dynrel_count (bfd_vma r_info,
7291 asection *sec,
7292 struct bfd_link_info *info,
7293 Elf_Internal_Sym **local_syms,
7294 struct elf_link_hash_entry *h,
7295 Elf_Internal_Sym *sym)
7296 {
7297 enum elf_ppc64_reloc_type r_type;
7298 asection *sym_sec = NULL;
7299
7300 /* Can this reloc be dynamic? This switch, and later tests here
7301 should be kept in sync with the code in check_relocs. */
7302 r_type = ELF64_R_TYPE (r_info);
7303 switch (r_type)
7304 {
7305 default:
7306 return TRUE;
7307
7308 case R_PPC64_TPREL16:
7309 case R_PPC64_TPREL16_LO:
7310 case R_PPC64_TPREL16_HI:
7311 case R_PPC64_TPREL16_HA:
7312 case R_PPC64_TPREL16_DS:
7313 case R_PPC64_TPREL16_LO_DS:
7314 case R_PPC64_TPREL16_HIGH:
7315 case R_PPC64_TPREL16_HIGHA:
7316 case R_PPC64_TPREL16_HIGHER:
7317 case R_PPC64_TPREL16_HIGHERA:
7318 case R_PPC64_TPREL16_HIGHEST:
7319 case R_PPC64_TPREL16_HIGHESTA:
7320 if (!info->shared)
7321 return TRUE;
7322
7323 case R_PPC64_TPREL64:
7324 case R_PPC64_DTPMOD64:
7325 case R_PPC64_DTPREL64:
7326 case R_PPC64_ADDR64:
7327 case R_PPC64_REL30:
7328 case R_PPC64_REL32:
7329 case R_PPC64_REL64:
7330 case R_PPC64_ADDR14:
7331 case R_PPC64_ADDR14_BRNTAKEN:
7332 case R_PPC64_ADDR14_BRTAKEN:
7333 case R_PPC64_ADDR16:
7334 case R_PPC64_ADDR16_DS:
7335 case R_PPC64_ADDR16_HA:
7336 case R_PPC64_ADDR16_HI:
7337 case R_PPC64_ADDR16_HIGH:
7338 case R_PPC64_ADDR16_HIGHA:
7339 case R_PPC64_ADDR16_HIGHER:
7340 case R_PPC64_ADDR16_HIGHERA:
7341 case R_PPC64_ADDR16_HIGHEST:
7342 case R_PPC64_ADDR16_HIGHESTA:
7343 case R_PPC64_ADDR16_LO:
7344 case R_PPC64_ADDR16_LO_DS:
7345 case R_PPC64_ADDR24:
7346 case R_PPC64_ADDR32:
7347 case R_PPC64_UADDR16:
7348 case R_PPC64_UADDR32:
7349 case R_PPC64_UADDR64:
7350 case R_PPC64_TOC:
7351 break;
7352 }
7353
7354 if (local_syms != NULL)
7355 {
7356 unsigned long r_symndx;
7357 bfd *ibfd = sec->owner;
7358
7359 r_symndx = ELF64_R_SYM (r_info);
7360 if (!get_sym_h (&h, &sym, &sym_sec, NULL, local_syms, r_symndx, ibfd))
7361 return FALSE;
7362 }
7363
7364 if ((info->shared
7365 && (must_be_dyn_reloc (info, r_type)
7366 || (h != NULL
7367 && (!SYMBOLIC_BIND (info, h)
7368 || h->root.type == bfd_link_hash_defweak
7369 || !h->def_regular))))
7370 || (ELIMINATE_COPY_RELOCS
7371 && !info->shared
7372 && h != NULL
7373 && (h->root.type == bfd_link_hash_defweak
7374 || !h->def_regular)))
7375 ;
7376 else
7377 return TRUE;
7378
7379 if (h != NULL)
7380 {
7381 struct elf_dyn_relocs *p;
7382 struct elf_dyn_relocs **pp;
7383 pp = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
7384
7385 /* elf_gc_sweep may have already removed all dyn relocs associated
7386 with local syms for a given section. Also, symbol flags are
7387 changed by elf_gc_sweep_symbol, confusing the test above. Don't
7388 report a dynreloc miscount. */
7389 if (*pp == NULL && info->gc_sections)
7390 return TRUE;
7391
7392 while ((p = *pp) != NULL)
7393 {
7394 if (p->sec == sec)
7395 {
7396 if (!must_be_dyn_reloc (info, r_type))
7397 p->pc_count -= 1;
7398 p->count -= 1;
7399 if (p->count == 0)
7400 *pp = p->next;
7401 return TRUE;
7402 }
7403 pp = &p->next;
7404 }
7405 }
7406 else
7407 {
7408 struct ppc_dyn_relocs *p;
7409 struct ppc_dyn_relocs **pp;
7410 void *vpp;
7411 bfd_boolean is_ifunc;
7412
7413 if (local_syms == NULL)
7414 sym_sec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
7415 if (sym_sec == NULL)
7416 sym_sec = sec;
7417
7418 vpp = &elf_section_data (sym_sec)->local_dynrel;
7419 pp = (struct ppc_dyn_relocs **) vpp;
7420
7421 if (*pp == NULL && info->gc_sections)
7422 return TRUE;
7423
7424 is_ifunc = ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC;
7425 while ((p = *pp) != NULL)
7426 {
7427 if (p->sec == sec && p->ifunc == is_ifunc)
7428 {
7429 p->count -= 1;
7430 if (p->count == 0)
7431 *pp = p->next;
7432 return TRUE;
7433 }
7434 pp = &p->next;
7435 }
7436 }
7437
7438 info->callbacks->einfo (_("%P: dynreloc miscount for %B, section %A\n"),
7439 sec->owner, sec);
7440 bfd_set_error (bfd_error_bad_value);
7441 return FALSE;
7442 }
7443
7444 /* Remove unused Official Procedure Descriptor entries. Currently we
7445 only remove those associated with functions in discarded link-once
7446 sections, or weakly defined functions that have been overridden. It
7447 would be possible to remove many more entries for statically linked
7448 applications. */
7449
7450 bfd_boolean
7451 ppc64_elf_edit_opd (struct bfd_link_info *info, bfd_boolean non_overlapping)
7452 {
7453 bfd *ibfd;
7454 bfd_boolean some_edited = FALSE;
7455 asection *need_pad = NULL;
7456
7457 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
7458 {
7459 asection *sec;
7460 Elf_Internal_Rela *relstart, *rel, *relend;
7461 Elf_Internal_Shdr *symtab_hdr;
7462 Elf_Internal_Sym *local_syms;
7463 bfd_vma offset;
7464 struct _opd_sec_data *opd;
7465 bfd_boolean need_edit, add_aux_fields;
7466 bfd_size_type cnt_16b = 0;
7467
7468 if (!is_ppc64_elf (ibfd))
7469 continue;
7470
7471 sec = bfd_get_section_by_name (ibfd, ".opd");
7472 if (sec == NULL || sec->size == 0)
7473 continue;
7474
7475 if (sec->sec_info_type == SEC_INFO_TYPE_JUST_SYMS)
7476 continue;
7477
7478 if (sec->output_section == bfd_abs_section_ptr)
7479 continue;
7480
7481 /* Look through the section relocs. */
7482 if ((sec->flags & SEC_RELOC) == 0 || sec->reloc_count == 0)
7483 continue;
7484
7485 local_syms = NULL;
7486 symtab_hdr = &elf_symtab_hdr (ibfd);
7487
7488 /* Read the relocations. */
7489 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
7490 info->keep_memory);
7491 if (relstart == NULL)
7492 return FALSE;
7493
7494 /* First run through the relocs to check they are sane, and to
7495 determine whether we need to edit this opd section. */
7496 need_edit = FALSE;
7497 need_pad = sec;
7498 offset = 0;
7499 relend = relstart + sec->reloc_count;
7500 for (rel = relstart; rel < relend; )
7501 {
7502 enum elf_ppc64_reloc_type r_type;
7503 unsigned long r_symndx;
7504 asection *sym_sec;
7505 struct elf_link_hash_entry *h;
7506 Elf_Internal_Sym *sym;
7507
7508 /* .opd contains a regular array of 16 or 24 byte entries. We're
7509 only interested in the reloc pointing to a function entry
7510 point. */
7511 if (rel->r_offset != offset
7512 || rel + 1 >= relend
7513 || (rel + 1)->r_offset != offset + 8)
7514 {
7515 /* If someone messes with .opd alignment then after a
7516 "ld -r" we might have padding in the middle of .opd.
7517 Also, there's nothing to prevent someone putting
7518 something silly in .opd with the assembler. No .opd
7519 optimization for them! */
7520 broken_opd:
7521 (*_bfd_error_handler)
7522 (_("%B: .opd is not a regular array of opd entries"), ibfd);
7523 need_edit = FALSE;
7524 break;
7525 }
7526
7527 if ((r_type = ELF64_R_TYPE (rel->r_info)) != R_PPC64_ADDR64
7528 || (r_type = ELF64_R_TYPE ((rel + 1)->r_info)) != R_PPC64_TOC)
7529 {
7530 (*_bfd_error_handler)
7531 (_("%B: unexpected reloc type %u in .opd section"),
7532 ibfd, r_type);
7533 need_edit = FALSE;
7534 break;
7535 }
7536
7537 r_symndx = ELF64_R_SYM (rel->r_info);
7538 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7539 r_symndx, ibfd))
7540 goto error_ret;
7541
7542 if (sym_sec == NULL || sym_sec->owner == NULL)
7543 {
7544 const char *sym_name;
7545 if (h != NULL)
7546 sym_name = h->root.root.string;
7547 else
7548 sym_name = bfd_elf_sym_name (ibfd, symtab_hdr, sym,
7549 sym_sec);
7550
7551 (*_bfd_error_handler)
7552 (_("%B: undefined sym `%s' in .opd section"),
7553 ibfd, sym_name);
7554 need_edit = FALSE;
7555 break;
7556 }
7557
7558 /* opd entries are always for functions defined in the
7559 current input bfd. If the symbol isn't defined in the
7560 input bfd, then we won't be using the function in this
7561 bfd; It must be defined in a linkonce section in another
7562 bfd, or is weak. It's also possible that we are
7563 discarding the function due to a linker script /DISCARD/,
7564 which we test for via the output_section. */
7565 if (sym_sec->owner != ibfd
7566 || sym_sec->output_section == bfd_abs_section_ptr)
7567 need_edit = TRUE;
7568
7569 rel += 2;
7570 if (rel == relend
7571 || (rel + 1 == relend && rel->r_offset == offset + 16))
7572 {
7573 if (sec->size == offset + 24)
7574 {
7575 need_pad = NULL;
7576 break;
7577 }
7578 if (rel == relend && sec->size == offset + 16)
7579 {
7580 cnt_16b++;
7581 break;
7582 }
7583 goto broken_opd;
7584 }
7585
7586 if (rel->r_offset == offset + 24)
7587 offset += 24;
7588 else if (rel->r_offset != offset + 16)
7589 goto broken_opd;
7590 else if (rel + 1 < relend
7591 && ELF64_R_TYPE (rel[0].r_info) == R_PPC64_ADDR64
7592 && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOC)
7593 {
7594 offset += 16;
7595 cnt_16b++;
7596 }
7597 else if (rel + 2 < relend
7598 && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_ADDR64
7599 && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_TOC)
7600 {
7601 offset += 24;
7602 rel += 1;
7603 }
7604 else
7605 goto broken_opd;
7606 }
7607
7608 add_aux_fields = non_overlapping && cnt_16b > 0;
7609
7610 if (need_edit || add_aux_fields)
7611 {
7612 Elf_Internal_Rela *write_rel;
7613 Elf_Internal_Shdr *rel_hdr;
7614 bfd_byte *rptr, *wptr;
7615 bfd_byte *new_contents;
7616 bfd_boolean skip;
7617 long opd_ent_size;
7618 bfd_size_type amt;
7619
7620 new_contents = NULL;
7621 amt = sec->size * sizeof (long) / 8;
7622 opd = &ppc64_elf_section_data (sec)->u.opd;
7623 opd->adjust = bfd_zalloc (sec->owner, amt);
7624 if (opd->adjust == NULL)
7625 return FALSE;
7626 ppc64_elf_section_data (sec)->sec_type = sec_opd;
7627
7628 /* This seems a waste of time as input .opd sections are all
7629 zeros as generated by gcc, but I suppose there's no reason
7630 this will always be so. We might start putting something in
7631 the third word of .opd entries. */
7632 if ((sec->flags & SEC_IN_MEMORY) == 0)
7633 {
7634 bfd_byte *loc;
7635 if (!bfd_malloc_and_get_section (ibfd, sec, &loc))
7636 {
7637 if (loc != NULL)
7638 free (loc);
7639 error_ret:
7640 if (local_syms != NULL
7641 && symtab_hdr->contents != (unsigned char *) local_syms)
7642 free (local_syms);
7643 if (elf_section_data (sec)->relocs != relstart)
7644 free (relstart);
7645 return FALSE;
7646 }
7647 sec->contents = loc;
7648 sec->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
7649 }
7650
7651 elf_section_data (sec)->relocs = relstart;
7652
7653 new_contents = sec->contents;
7654 if (add_aux_fields)
7655 {
7656 new_contents = bfd_malloc (sec->size + cnt_16b * 8);
7657 if (new_contents == NULL)
7658 return FALSE;
7659 need_pad = FALSE;
7660 }
7661 wptr = new_contents;
7662 rptr = sec->contents;
7663
7664 write_rel = relstart;
7665 skip = FALSE;
7666 offset = 0;
7667 opd_ent_size = 0;
7668 for (rel = relstart; rel < relend; rel++)
7669 {
7670 unsigned long r_symndx;
7671 asection *sym_sec;
7672 struct elf_link_hash_entry *h;
7673 Elf_Internal_Sym *sym;
7674
7675 r_symndx = ELF64_R_SYM (rel->r_info);
7676 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7677 r_symndx, ibfd))
7678 goto error_ret;
7679
7680 if (rel->r_offset == offset)
7681 {
7682 struct ppc_link_hash_entry *fdh = NULL;
7683
7684 /* See if the .opd entry is full 24 byte or
7685 16 byte (with fd_aux entry overlapped with next
7686 fd_func). */
7687 opd_ent_size = 24;
7688 if ((rel + 2 == relend && sec->size == offset + 16)
7689 || (rel + 3 < relend
7690 && rel[2].r_offset == offset + 16
7691 && rel[3].r_offset == offset + 24
7692 && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_ADDR64
7693 && ELF64_R_TYPE (rel[3].r_info) == R_PPC64_TOC))
7694 opd_ent_size = 16;
7695
7696 if (h != NULL
7697 && h->root.root.string[0] == '.')
7698 {
7699 struct ppc_link_hash_table *htab;
7700
7701 htab = ppc_hash_table (info);
7702 if (htab != NULL)
7703 fdh = lookup_fdh ((struct ppc_link_hash_entry *) h,
7704 htab);
7705 if (fdh != NULL
7706 && fdh->elf.root.type != bfd_link_hash_defined
7707 && fdh->elf.root.type != bfd_link_hash_defweak)
7708 fdh = NULL;
7709 }
7710
7711 skip = (sym_sec->owner != ibfd
7712 || sym_sec->output_section == bfd_abs_section_ptr);
7713 if (skip)
7714 {
7715 if (fdh != NULL && sym_sec->owner == ibfd)
7716 {
7717 /* Arrange for the function descriptor sym
7718 to be dropped. */
7719 fdh->elf.root.u.def.value = 0;
7720 fdh->elf.root.u.def.section = sym_sec;
7721 }
7722 opd->adjust[rel->r_offset / 8] = -1;
7723 }
7724 else
7725 {
7726 /* We'll be keeping this opd entry. */
7727
7728 if (fdh != NULL)
7729 {
7730 /* Redefine the function descriptor symbol to
7731 this location in the opd section. It is
7732 necessary to update the value here rather
7733 than using an array of adjustments as we do
7734 for local symbols, because various places
7735 in the generic ELF code use the value
7736 stored in u.def.value. */
7737 fdh->elf.root.u.def.value = wptr - new_contents;
7738 fdh->adjust_done = 1;
7739 }
7740
7741 /* Local syms are a bit tricky. We could
7742 tweak them as they can be cached, but
7743 we'd need to look through the local syms
7744 for the function descriptor sym which we
7745 don't have at the moment. So keep an
7746 array of adjustments. */
7747 opd->adjust[rel->r_offset / 8]
7748 = (wptr - new_contents) - (rptr - sec->contents);
7749
7750 if (wptr != rptr)
7751 memcpy (wptr, rptr, opd_ent_size);
7752 wptr += opd_ent_size;
7753 if (add_aux_fields && opd_ent_size == 16)
7754 {
7755 memset (wptr, '\0', 8);
7756 wptr += 8;
7757 }
7758 }
7759 rptr += opd_ent_size;
7760 offset += opd_ent_size;
7761 }
7762
7763 if (skip)
7764 {
7765 if (!NO_OPD_RELOCS
7766 && !info->relocatable
7767 && !dec_dynrel_count (rel->r_info, sec, info,
7768 NULL, h, sym))
7769 goto error_ret;
7770 }
7771 else
7772 {
7773 /* We need to adjust any reloc offsets to point to the
7774 new opd entries. While we're at it, we may as well
7775 remove redundant relocs. */
7776 rel->r_offset += opd->adjust[(offset - opd_ent_size) / 8];
7777 if (write_rel != rel)
7778 memcpy (write_rel, rel, sizeof (*rel));
7779 ++write_rel;
7780 }
7781 }
7782
7783 sec->size = wptr - new_contents;
7784 sec->reloc_count = write_rel - relstart;
7785 if (add_aux_fields)
7786 {
7787 free (sec->contents);
7788 sec->contents = new_contents;
7789 }
7790
7791 /* Fudge the header size too, as this is used later in
7792 elf_bfd_final_link if we are emitting relocs. */
7793 rel_hdr = _bfd_elf_single_rel_hdr (sec);
7794 rel_hdr->sh_size = sec->reloc_count * rel_hdr->sh_entsize;
7795 some_edited = TRUE;
7796 }
7797 else if (elf_section_data (sec)->relocs != relstart)
7798 free (relstart);
7799
7800 if (local_syms != NULL
7801 && symtab_hdr->contents != (unsigned char *) local_syms)
7802 {
7803 if (!info->keep_memory)
7804 free (local_syms);
7805 else
7806 symtab_hdr->contents = (unsigned char *) local_syms;
7807 }
7808 }
7809
7810 if (some_edited)
7811 elf_link_hash_traverse (elf_hash_table (info), adjust_opd_syms, NULL);
7812
7813 /* If we are doing a final link and the last .opd entry is just 16 byte
7814 long, add a 8 byte padding after it. */
7815 if (need_pad != NULL && !info->relocatable)
7816 {
7817 bfd_byte *p;
7818
7819 if ((need_pad->flags & SEC_IN_MEMORY) == 0)
7820 {
7821 BFD_ASSERT (need_pad->size > 0);
7822
7823 p = bfd_malloc (need_pad->size + 8);
7824 if (p == NULL)
7825 return FALSE;
7826
7827 if (! bfd_get_section_contents (need_pad->owner, need_pad,
7828 p, 0, need_pad->size))
7829 return FALSE;
7830
7831 need_pad->contents = p;
7832 need_pad->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
7833 }
7834 else
7835 {
7836 p = bfd_realloc (need_pad->contents, need_pad->size + 8);
7837 if (p == NULL)
7838 return FALSE;
7839
7840 need_pad->contents = p;
7841 }
7842
7843 memset (need_pad->contents + need_pad->size, 0, 8);
7844 need_pad->size += 8;
7845 }
7846
7847 return TRUE;
7848 }
7849
7850 /* Set htab->tls_get_addr and call the generic ELF tls_setup function. */
7851
7852 asection *
7853 ppc64_elf_tls_setup (struct bfd_link_info *info,
7854 int no_tls_get_addr_opt,
7855 int *no_multi_toc)
7856 {
7857 struct ppc_link_hash_table *htab;
7858
7859 htab = ppc_hash_table (info);
7860 if (htab == NULL)
7861 return NULL;
7862
7863 if (abiversion (info->output_bfd) == 1)
7864 htab->opd_abi = 1;
7865
7866 if (*no_multi_toc)
7867 htab->do_multi_toc = 0;
7868 else if (!htab->do_multi_toc)
7869 *no_multi_toc = 1;
7870
7871 htab->tls_get_addr = ((struct ppc_link_hash_entry *)
7872 elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
7873 FALSE, FALSE, TRUE));
7874 /* Move dynamic linking info to the function descriptor sym. */
7875 if (htab->tls_get_addr != NULL)
7876 func_desc_adjust (&htab->tls_get_addr->elf, info);
7877 htab->tls_get_addr_fd = ((struct ppc_link_hash_entry *)
7878 elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
7879 FALSE, FALSE, TRUE));
7880 if (!no_tls_get_addr_opt)
7881 {
7882 struct elf_link_hash_entry *opt, *opt_fd, *tga, *tga_fd;
7883
7884 opt = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr_opt",
7885 FALSE, FALSE, TRUE);
7886 if (opt != NULL)
7887 func_desc_adjust (opt, info);
7888 opt_fd = elf_link_hash_lookup (&htab->elf, "__tls_get_addr_opt",
7889 FALSE, FALSE, TRUE);
7890 if (opt_fd != NULL
7891 && (opt_fd->root.type == bfd_link_hash_defined
7892 || opt_fd->root.type == bfd_link_hash_defweak))
7893 {
7894 /* If glibc supports an optimized __tls_get_addr call stub,
7895 signalled by the presence of __tls_get_addr_opt, and we'll
7896 be calling __tls_get_addr via a plt call stub, then
7897 make __tls_get_addr point to __tls_get_addr_opt. */
7898 tga_fd = &htab->tls_get_addr_fd->elf;
7899 if (htab->elf.dynamic_sections_created
7900 && tga_fd != NULL
7901 && (tga_fd->type == STT_FUNC
7902 || tga_fd->needs_plt)
7903 && !(SYMBOL_CALLS_LOCAL (info, tga_fd)
7904 || (ELF_ST_VISIBILITY (tga_fd->other) != STV_DEFAULT
7905 && tga_fd->root.type == bfd_link_hash_undefweak)))
7906 {
7907 struct plt_entry *ent;
7908
7909 for (ent = tga_fd->plt.plist; ent != NULL; ent = ent->next)
7910 if (ent->plt.refcount > 0)
7911 break;
7912 if (ent != NULL)
7913 {
7914 tga_fd->root.type = bfd_link_hash_indirect;
7915 tga_fd->root.u.i.link = &opt_fd->root;
7916 ppc64_elf_copy_indirect_symbol (info, opt_fd, tga_fd);
7917 if (opt_fd->dynindx != -1)
7918 {
7919 /* Use __tls_get_addr_opt in dynamic relocations. */
7920 opt_fd->dynindx = -1;
7921 _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
7922 opt_fd->dynstr_index);
7923 if (!bfd_elf_link_record_dynamic_symbol (info, opt_fd))
7924 return NULL;
7925 }
7926 htab->tls_get_addr_fd = (struct ppc_link_hash_entry *) opt_fd;
7927 tga = &htab->tls_get_addr->elf;
7928 if (opt != NULL && tga != NULL)
7929 {
7930 tga->root.type = bfd_link_hash_indirect;
7931 tga->root.u.i.link = &opt->root;
7932 ppc64_elf_copy_indirect_symbol (info, opt, tga);
7933 _bfd_elf_link_hash_hide_symbol (info, opt,
7934 tga->forced_local);
7935 htab->tls_get_addr = (struct ppc_link_hash_entry *) opt;
7936 }
7937 htab->tls_get_addr_fd->oh = htab->tls_get_addr;
7938 htab->tls_get_addr_fd->is_func_descriptor = 1;
7939 if (htab->tls_get_addr != NULL)
7940 {
7941 htab->tls_get_addr->oh = htab->tls_get_addr_fd;
7942 htab->tls_get_addr->is_func = 1;
7943 }
7944 }
7945 }
7946 }
7947 else
7948 no_tls_get_addr_opt = TRUE;
7949 }
7950 htab->no_tls_get_addr_opt = no_tls_get_addr_opt;
7951 return _bfd_elf_tls_setup (info->output_bfd, info);
7952 }
7953
7954 /* Return TRUE iff REL is a branch reloc with a global symbol matching
7955 HASH1 or HASH2. */
7956
7957 static bfd_boolean
7958 branch_reloc_hash_match (const bfd *ibfd,
7959 const Elf_Internal_Rela *rel,
7960 const struct ppc_link_hash_entry *hash1,
7961 const struct ppc_link_hash_entry *hash2)
7962 {
7963 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
7964 enum elf_ppc64_reloc_type r_type = ELF64_R_TYPE (rel->r_info);
7965 unsigned int r_symndx = ELF64_R_SYM (rel->r_info);
7966
7967 if (r_symndx >= symtab_hdr->sh_info && is_branch_reloc (r_type))
7968 {
7969 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
7970 struct elf_link_hash_entry *h;
7971
7972 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
7973 h = elf_follow_link (h);
7974 if (h == &hash1->elf || h == &hash2->elf)
7975 return TRUE;
7976 }
7977 return FALSE;
7978 }
7979
7980 /* Run through all the TLS relocs looking for optimization
7981 opportunities. The linker has been hacked (see ppc64elf.em) to do
7982 a preliminary section layout so that we know the TLS segment
7983 offsets. We can't optimize earlier because some optimizations need
7984 to know the tp offset, and we need to optimize before allocating
7985 dynamic relocations. */
7986
7987 bfd_boolean
7988 ppc64_elf_tls_optimize (struct bfd_link_info *info)
7989 {
7990 bfd *ibfd;
7991 asection *sec;
7992 struct ppc_link_hash_table *htab;
7993 unsigned char *toc_ref;
7994 int pass;
7995
7996 if (info->relocatable || !info->executable)
7997 return TRUE;
7998
7999 htab = ppc_hash_table (info);
8000 if (htab == NULL)
8001 return FALSE;
8002
8003 /* Make two passes over the relocs. On the first pass, mark toc
8004 entries involved with tls relocs, and check that tls relocs
8005 involved in setting up a tls_get_addr call are indeed followed by
8006 such a call. If they are not, we can't do any tls optimization.
8007 On the second pass twiddle tls_mask flags to notify
8008 relocate_section that optimization can be done, and adjust got
8009 and plt refcounts. */
8010 toc_ref = NULL;
8011 for (pass = 0; pass < 2; ++pass)
8012 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
8013 {
8014 Elf_Internal_Sym *locsyms = NULL;
8015 asection *toc = bfd_get_section_by_name (ibfd, ".toc");
8016
8017 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8018 if (sec->has_tls_reloc && !bfd_is_abs_section (sec->output_section))
8019 {
8020 Elf_Internal_Rela *relstart, *rel, *relend;
8021 bfd_boolean found_tls_get_addr_arg = 0;
8022
8023 /* Read the relocations. */
8024 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8025 info->keep_memory);
8026 if (relstart == NULL)
8027 return FALSE;
8028
8029 relend = relstart + sec->reloc_count;
8030 for (rel = relstart; rel < relend; rel++)
8031 {
8032 enum elf_ppc64_reloc_type r_type;
8033 unsigned long r_symndx;
8034 struct elf_link_hash_entry *h;
8035 Elf_Internal_Sym *sym;
8036 asection *sym_sec;
8037 unsigned char *tls_mask;
8038 unsigned char tls_set, tls_clear, tls_type = 0;
8039 bfd_vma value;
8040 bfd_boolean ok_tprel, is_local;
8041 long toc_ref_index = 0;
8042 int expecting_tls_get_addr = 0;
8043 bfd_boolean ret = FALSE;
8044
8045 r_symndx = ELF64_R_SYM (rel->r_info);
8046 if (!get_sym_h (&h, &sym, &sym_sec, &tls_mask, &locsyms,
8047 r_symndx, ibfd))
8048 {
8049 err_free_rel:
8050 if (elf_section_data (sec)->relocs != relstart)
8051 free (relstart);
8052 if (toc_ref != NULL)
8053 free (toc_ref);
8054 if (locsyms != NULL
8055 && (elf_symtab_hdr (ibfd).contents
8056 != (unsigned char *) locsyms))
8057 free (locsyms);
8058 return ret;
8059 }
8060
8061 if (h != NULL)
8062 {
8063 if (h->root.type == bfd_link_hash_defined
8064 || h->root.type == bfd_link_hash_defweak)
8065 value = h->root.u.def.value;
8066 else if (h->root.type == bfd_link_hash_undefweak)
8067 value = 0;
8068 else
8069 {
8070 found_tls_get_addr_arg = 0;
8071 continue;
8072 }
8073 }
8074 else
8075 /* Symbols referenced by TLS relocs must be of type
8076 STT_TLS. So no need for .opd local sym adjust. */
8077 value = sym->st_value;
8078
8079 ok_tprel = FALSE;
8080 is_local = FALSE;
8081 if (h == NULL
8082 || !h->def_dynamic)
8083 {
8084 is_local = TRUE;
8085 if (h != NULL
8086 && h->root.type == bfd_link_hash_undefweak)
8087 ok_tprel = TRUE;
8088 else
8089 {
8090 value += sym_sec->output_offset;
8091 value += sym_sec->output_section->vma;
8092 value -= htab->elf.tls_sec->vma;
8093 ok_tprel = (value + TP_OFFSET + ((bfd_vma) 1 << 31)
8094 < (bfd_vma) 1 << 32);
8095 }
8096 }
8097
8098 r_type = ELF64_R_TYPE (rel->r_info);
8099 /* If this section has old-style __tls_get_addr calls
8100 without marker relocs, then check that each
8101 __tls_get_addr call reloc is preceded by a reloc
8102 that conceivably belongs to the __tls_get_addr arg
8103 setup insn. If we don't find matching arg setup
8104 relocs, don't do any tls optimization. */
8105 if (pass == 0
8106 && sec->has_tls_get_addr_call
8107 && h != NULL
8108 && (h == &htab->tls_get_addr->elf
8109 || h == &htab->tls_get_addr_fd->elf)
8110 && !found_tls_get_addr_arg
8111 && is_branch_reloc (r_type))
8112 {
8113 info->callbacks->minfo (_("%H __tls_get_addr lost arg, "
8114 "TLS optimization disabled\n"),
8115 ibfd, sec, rel->r_offset);
8116 ret = TRUE;
8117 goto err_free_rel;
8118 }
8119
8120 found_tls_get_addr_arg = 0;
8121 switch (r_type)
8122 {
8123 case R_PPC64_GOT_TLSLD16:
8124 case R_PPC64_GOT_TLSLD16_LO:
8125 expecting_tls_get_addr = 1;
8126 found_tls_get_addr_arg = 1;
8127 /* Fall thru */
8128
8129 case R_PPC64_GOT_TLSLD16_HI:
8130 case R_PPC64_GOT_TLSLD16_HA:
8131 /* These relocs should never be against a symbol
8132 defined in a shared lib. Leave them alone if
8133 that turns out to be the case. */
8134 if (!is_local)
8135 continue;
8136
8137 /* LD -> LE */
8138 tls_set = 0;
8139 tls_clear = TLS_LD;
8140 tls_type = TLS_TLS | TLS_LD;
8141 break;
8142
8143 case R_PPC64_GOT_TLSGD16:
8144 case R_PPC64_GOT_TLSGD16_LO:
8145 expecting_tls_get_addr = 1;
8146 found_tls_get_addr_arg = 1;
8147 /* Fall thru */
8148
8149 case R_PPC64_GOT_TLSGD16_HI:
8150 case R_PPC64_GOT_TLSGD16_HA:
8151 if (ok_tprel)
8152 /* GD -> LE */
8153 tls_set = 0;
8154 else
8155 /* GD -> IE */
8156 tls_set = TLS_TLS | TLS_TPRELGD;
8157 tls_clear = TLS_GD;
8158 tls_type = TLS_TLS | TLS_GD;
8159 break;
8160
8161 case R_PPC64_GOT_TPREL16_DS:
8162 case R_PPC64_GOT_TPREL16_LO_DS:
8163 case R_PPC64_GOT_TPREL16_HI:
8164 case R_PPC64_GOT_TPREL16_HA:
8165 if (ok_tprel)
8166 {
8167 /* IE -> LE */
8168 tls_set = 0;
8169 tls_clear = TLS_TPREL;
8170 tls_type = TLS_TLS | TLS_TPREL;
8171 break;
8172 }
8173 continue;
8174
8175 case R_PPC64_TLSGD:
8176 case R_PPC64_TLSLD:
8177 found_tls_get_addr_arg = 1;
8178 /* Fall thru */
8179
8180 case R_PPC64_TLS:
8181 case R_PPC64_TOC16:
8182 case R_PPC64_TOC16_LO:
8183 if (sym_sec == NULL || sym_sec != toc)
8184 continue;
8185
8186 /* Mark this toc entry as referenced by a TLS
8187 code sequence. We can do that now in the
8188 case of R_PPC64_TLS, and after checking for
8189 tls_get_addr for the TOC16 relocs. */
8190 if (toc_ref == NULL)
8191 toc_ref = bfd_zmalloc (toc->output_section->rawsize / 8);
8192 if (toc_ref == NULL)
8193 goto err_free_rel;
8194
8195 if (h != NULL)
8196 value = h->root.u.def.value;
8197 else
8198 value = sym->st_value;
8199 value += rel->r_addend;
8200 BFD_ASSERT (value < toc->size && value % 8 == 0);
8201 toc_ref_index = (value + toc->output_offset) / 8;
8202 if (r_type == R_PPC64_TLS
8203 || r_type == R_PPC64_TLSGD
8204 || r_type == R_PPC64_TLSLD)
8205 {
8206 toc_ref[toc_ref_index] = 1;
8207 continue;
8208 }
8209
8210 if (pass != 0 && toc_ref[toc_ref_index] == 0)
8211 continue;
8212
8213 tls_set = 0;
8214 tls_clear = 0;
8215 expecting_tls_get_addr = 2;
8216 break;
8217
8218 case R_PPC64_TPREL64:
8219 if (pass == 0
8220 || sec != toc
8221 || toc_ref == NULL
8222 || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
8223 continue;
8224 if (ok_tprel)
8225 {
8226 /* IE -> LE */
8227 tls_set = TLS_EXPLICIT;
8228 tls_clear = TLS_TPREL;
8229 break;
8230 }
8231 continue;
8232
8233 case R_PPC64_DTPMOD64:
8234 if (pass == 0
8235 || sec != toc
8236 || toc_ref == NULL
8237 || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
8238 continue;
8239 if (rel + 1 < relend
8240 && (rel[1].r_info
8241 == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64))
8242 && rel[1].r_offset == rel->r_offset + 8)
8243 {
8244 if (ok_tprel)
8245 /* GD -> LE */
8246 tls_set = TLS_EXPLICIT | TLS_GD;
8247 else
8248 /* GD -> IE */
8249 tls_set = TLS_EXPLICIT | TLS_GD | TLS_TPRELGD;
8250 tls_clear = TLS_GD;
8251 }
8252 else
8253 {
8254 if (!is_local)
8255 continue;
8256
8257 /* LD -> LE */
8258 tls_set = TLS_EXPLICIT;
8259 tls_clear = TLS_LD;
8260 }
8261 break;
8262
8263 default:
8264 continue;
8265 }
8266
8267 if (pass == 0)
8268 {
8269 if (!expecting_tls_get_addr
8270 || !sec->has_tls_get_addr_call)
8271 continue;
8272
8273 if (rel + 1 < relend
8274 && branch_reloc_hash_match (ibfd, rel + 1,
8275 htab->tls_get_addr,
8276 htab->tls_get_addr_fd))
8277 {
8278 if (expecting_tls_get_addr == 2)
8279 {
8280 /* Check for toc tls entries. */
8281 unsigned char *toc_tls;
8282 int retval;
8283
8284 retval = get_tls_mask (&toc_tls, NULL, NULL,
8285 &locsyms,
8286 rel, ibfd);
8287 if (retval == 0)
8288 goto err_free_rel;
8289 if (toc_tls != NULL)
8290 {
8291 if ((*toc_tls & (TLS_GD | TLS_LD)) != 0)
8292 found_tls_get_addr_arg = 1;
8293 if (retval > 1)
8294 toc_ref[toc_ref_index] = 1;
8295 }
8296 }
8297 continue;
8298 }
8299
8300 if (expecting_tls_get_addr != 1)
8301 continue;
8302
8303 /* Uh oh, we didn't find the expected call. We
8304 could just mark this symbol to exclude it
8305 from tls optimization but it's safer to skip
8306 the entire optimization. */
8307 info->callbacks->minfo (_("%H arg lost __tls_get_addr, "
8308 "TLS optimization disabled\n"),
8309 ibfd, sec, rel->r_offset);
8310 ret = TRUE;
8311 goto err_free_rel;
8312 }
8313
8314 if (expecting_tls_get_addr && htab->tls_get_addr != NULL)
8315 {
8316 struct plt_entry *ent;
8317 for (ent = htab->tls_get_addr->elf.plt.plist;
8318 ent != NULL;
8319 ent = ent->next)
8320 if (ent->addend == 0)
8321 {
8322 if (ent->plt.refcount > 0)
8323 {
8324 ent->plt.refcount -= 1;
8325 expecting_tls_get_addr = 0;
8326 }
8327 break;
8328 }
8329 }
8330
8331 if (expecting_tls_get_addr && htab->tls_get_addr_fd != NULL)
8332 {
8333 struct plt_entry *ent;
8334 for (ent = htab->tls_get_addr_fd->elf.plt.plist;
8335 ent != NULL;
8336 ent = ent->next)
8337 if (ent->addend == 0)
8338 {
8339 if (ent->plt.refcount > 0)
8340 ent->plt.refcount -= 1;
8341 break;
8342 }
8343 }
8344
8345 if (tls_clear == 0)
8346 continue;
8347
8348 if ((tls_set & TLS_EXPLICIT) == 0)
8349 {
8350 struct got_entry *ent;
8351
8352 /* Adjust got entry for this reloc. */
8353 if (h != NULL)
8354 ent = h->got.glist;
8355 else
8356 ent = elf_local_got_ents (ibfd)[r_symndx];
8357
8358 for (; ent != NULL; ent = ent->next)
8359 if (ent->addend == rel->r_addend
8360 && ent->owner == ibfd
8361 && ent->tls_type == tls_type)
8362 break;
8363 if (ent == NULL)
8364 abort ();
8365
8366 if (tls_set == 0)
8367 {
8368 /* We managed to get rid of a got entry. */
8369 if (ent->got.refcount > 0)
8370 ent->got.refcount -= 1;
8371 }
8372 }
8373 else
8374 {
8375 /* If we got rid of a DTPMOD/DTPREL reloc pair then
8376 we'll lose one or two dyn relocs. */
8377 if (!dec_dynrel_count (rel->r_info, sec, info,
8378 NULL, h, sym))
8379 return FALSE;
8380
8381 if (tls_set == (TLS_EXPLICIT | TLS_GD))
8382 {
8383 if (!dec_dynrel_count ((rel + 1)->r_info, sec, info,
8384 NULL, h, sym))
8385 return FALSE;
8386 }
8387 }
8388
8389 *tls_mask |= tls_set;
8390 *tls_mask &= ~tls_clear;
8391 }
8392
8393 if (elf_section_data (sec)->relocs != relstart)
8394 free (relstart);
8395 }
8396
8397 if (locsyms != NULL
8398 && (elf_symtab_hdr (ibfd).contents != (unsigned char *) locsyms))
8399 {
8400 if (!info->keep_memory)
8401 free (locsyms);
8402 else
8403 elf_symtab_hdr (ibfd).contents = (unsigned char *) locsyms;
8404 }
8405 }
8406
8407 if (toc_ref != NULL)
8408 free (toc_ref);
8409 return TRUE;
8410 }
8411
8412 /* Called via elf_link_hash_traverse from ppc64_elf_edit_toc to adjust
8413 the values of any global symbols in a toc section that has been
8414 edited. Globals in toc sections should be a rarity, so this function
8415 sets a flag if any are found in toc sections other than the one just
8416 edited, so that futher hash table traversals can be avoided. */
8417
8418 struct adjust_toc_info
8419 {
8420 asection *toc;
8421 unsigned long *skip;
8422 bfd_boolean global_toc_syms;
8423 };
8424
8425 enum toc_skip_enum { ref_from_discarded = 1, can_optimize = 2 };
8426
8427 static bfd_boolean
8428 adjust_toc_syms (struct elf_link_hash_entry *h, void *inf)
8429 {
8430 struct ppc_link_hash_entry *eh;
8431 struct adjust_toc_info *toc_inf = (struct adjust_toc_info *) inf;
8432 unsigned long i;
8433
8434 if (h->root.type != bfd_link_hash_defined
8435 && h->root.type != bfd_link_hash_defweak)
8436 return TRUE;
8437
8438 eh = (struct ppc_link_hash_entry *) h;
8439 if (eh->adjust_done)
8440 return TRUE;
8441
8442 if (eh->elf.root.u.def.section == toc_inf->toc)
8443 {
8444 if (eh->elf.root.u.def.value > toc_inf->toc->rawsize)
8445 i = toc_inf->toc->rawsize >> 3;
8446 else
8447 i = eh->elf.root.u.def.value >> 3;
8448
8449 if ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0)
8450 {
8451 (*_bfd_error_handler)
8452 (_("%s defined on removed toc entry"), eh->elf.root.root.string);
8453 do
8454 ++i;
8455 while ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0);
8456 eh->elf.root.u.def.value = (bfd_vma) i << 3;
8457 }
8458
8459 eh->elf.root.u.def.value -= toc_inf->skip[i];
8460 eh->adjust_done = 1;
8461 }
8462 else if (strcmp (eh->elf.root.u.def.section->name, ".toc") == 0)
8463 toc_inf->global_toc_syms = TRUE;
8464
8465 return TRUE;
8466 }
8467
8468 /* Return TRUE iff INSN is one we expect on a _LO variety toc/got reloc. */
8469
8470 static bfd_boolean
8471 ok_lo_toc_insn (unsigned int insn)
8472 {
8473 return ((insn & (0x3f << 26)) == 14u << 26 /* addi */
8474 || (insn & (0x3f << 26)) == 32u << 26 /* lwz */
8475 || (insn & (0x3f << 26)) == 34u << 26 /* lbz */
8476 || (insn & (0x3f << 26)) == 36u << 26 /* stw */
8477 || (insn & (0x3f << 26)) == 38u << 26 /* stb */
8478 || (insn & (0x3f << 26)) == 40u << 26 /* lhz */
8479 || (insn & (0x3f << 26)) == 42u << 26 /* lha */
8480 || (insn & (0x3f << 26)) == 44u << 26 /* sth */
8481 || (insn & (0x3f << 26)) == 46u << 26 /* lmw */
8482 || (insn & (0x3f << 26)) == 47u << 26 /* stmw */
8483 || (insn & (0x3f << 26)) == 48u << 26 /* lfs */
8484 || (insn & (0x3f << 26)) == 50u << 26 /* lfd */
8485 || (insn & (0x3f << 26)) == 52u << 26 /* stfs */
8486 || (insn & (0x3f << 26)) == 54u << 26 /* stfd */
8487 || ((insn & (0x3f << 26)) == 58u << 26 /* lwa,ld,lmd */
8488 && (insn & 3) != 1)
8489 || ((insn & (0x3f << 26)) == 62u << 26 /* std, stmd */
8490 && ((insn & 3) == 0 || (insn & 3) == 3))
8491 || (insn & (0x3f << 26)) == 12u << 26 /* addic */);
8492 }
8493
8494 /* Examine all relocs referencing .toc sections in order to remove
8495 unused .toc entries. */
8496
8497 bfd_boolean
8498 ppc64_elf_edit_toc (struct bfd_link_info *info)
8499 {
8500 bfd *ibfd;
8501 struct adjust_toc_info toc_inf;
8502 struct ppc_link_hash_table *htab = ppc_hash_table (info);
8503
8504 htab->do_toc_opt = 1;
8505 toc_inf.global_toc_syms = TRUE;
8506 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
8507 {
8508 asection *toc, *sec;
8509 Elf_Internal_Shdr *symtab_hdr;
8510 Elf_Internal_Sym *local_syms;
8511 Elf_Internal_Rela *relstart, *rel, *toc_relocs;
8512 unsigned long *skip, *drop;
8513 unsigned char *used;
8514 unsigned char *keep, last, some_unused;
8515
8516 if (!is_ppc64_elf (ibfd))
8517 continue;
8518
8519 toc = bfd_get_section_by_name (ibfd, ".toc");
8520 if (toc == NULL
8521 || toc->size == 0
8522 || toc->sec_info_type == SEC_INFO_TYPE_JUST_SYMS
8523 || discarded_section (toc))
8524 continue;
8525
8526 toc_relocs = NULL;
8527 local_syms = NULL;
8528 symtab_hdr = &elf_symtab_hdr (ibfd);
8529
8530 /* Look at sections dropped from the final link. */
8531 skip = NULL;
8532 relstart = NULL;
8533 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8534 {
8535 if (sec->reloc_count == 0
8536 || !discarded_section (sec)
8537 || get_opd_info (sec)
8538 || (sec->flags & SEC_ALLOC) == 0
8539 || (sec->flags & SEC_DEBUGGING) != 0)
8540 continue;
8541
8542 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL, FALSE);
8543 if (relstart == NULL)
8544 goto error_ret;
8545
8546 /* Run through the relocs to see which toc entries might be
8547 unused. */
8548 for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
8549 {
8550 enum elf_ppc64_reloc_type r_type;
8551 unsigned long r_symndx;
8552 asection *sym_sec;
8553 struct elf_link_hash_entry *h;
8554 Elf_Internal_Sym *sym;
8555 bfd_vma val;
8556
8557 r_type = ELF64_R_TYPE (rel->r_info);
8558 switch (r_type)
8559 {
8560 default:
8561 continue;
8562
8563 case R_PPC64_TOC16:
8564 case R_PPC64_TOC16_LO:
8565 case R_PPC64_TOC16_HI:
8566 case R_PPC64_TOC16_HA:
8567 case R_PPC64_TOC16_DS:
8568 case R_PPC64_TOC16_LO_DS:
8569 break;
8570 }
8571
8572 r_symndx = ELF64_R_SYM (rel->r_info);
8573 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8574 r_symndx, ibfd))
8575 goto error_ret;
8576
8577 if (sym_sec != toc)
8578 continue;
8579
8580 if (h != NULL)
8581 val = h->root.u.def.value;
8582 else
8583 val = sym->st_value;
8584 val += rel->r_addend;
8585
8586 if (val >= toc->size)
8587 continue;
8588
8589 /* Anything in the toc ought to be aligned to 8 bytes.
8590 If not, don't mark as unused. */
8591 if (val & 7)
8592 continue;
8593
8594 if (skip == NULL)
8595 {
8596 skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
8597 if (skip == NULL)
8598 goto error_ret;
8599 }
8600
8601 skip[val >> 3] = ref_from_discarded;
8602 }
8603
8604 if (elf_section_data (sec)->relocs != relstart)
8605 free (relstart);
8606 }
8607
8608 /* For largetoc loads of address constants, we can convert
8609 . addis rx,2,addr@got@ha
8610 . ld ry,addr@got@l(rx)
8611 to
8612 . addis rx,2,addr@toc@ha
8613 . addi ry,rx,addr@toc@l
8614 when addr is within 2G of the toc pointer. This then means
8615 that the word storing "addr" in the toc is no longer needed. */
8616
8617 if (!ppc64_elf_tdata (ibfd)->has_small_toc_reloc
8618 && toc->output_section->rawsize < (bfd_vma) 1 << 31
8619 && toc->reloc_count != 0)
8620 {
8621 /* Read toc relocs. */
8622 toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
8623 info->keep_memory);
8624 if (toc_relocs == NULL)
8625 goto error_ret;
8626
8627 for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
8628 {
8629 enum elf_ppc64_reloc_type r_type;
8630 unsigned long r_symndx;
8631 asection *sym_sec;
8632 struct elf_link_hash_entry *h;
8633 Elf_Internal_Sym *sym;
8634 bfd_vma val, addr;
8635
8636 r_type = ELF64_R_TYPE (rel->r_info);
8637 if (r_type != R_PPC64_ADDR64)
8638 continue;
8639
8640 r_symndx = ELF64_R_SYM (rel->r_info);
8641 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8642 r_symndx, ibfd))
8643 goto error_ret;
8644
8645 if (sym_sec == NULL
8646 || discarded_section (sym_sec))
8647 continue;
8648
8649 if (!SYMBOL_CALLS_LOCAL (info, h))
8650 continue;
8651
8652 if (h != NULL)
8653 {
8654 if (h->type == STT_GNU_IFUNC)
8655 continue;
8656 val = h->root.u.def.value;
8657 }
8658 else
8659 {
8660 if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
8661 continue;
8662 val = sym->st_value;
8663 }
8664 val += rel->r_addend;
8665 val += sym_sec->output_section->vma + sym_sec->output_offset;
8666
8667 /* We don't yet know the exact toc pointer value, but we
8668 know it will be somewhere in the toc section. Don't
8669 optimize if the difference from any possible toc
8670 pointer is outside [ff..f80008000, 7fff7fff]. */
8671 addr = toc->output_section->vma + TOC_BASE_OFF;
8672 if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
8673 continue;
8674
8675 addr = toc->output_section->vma + toc->output_section->rawsize;
8676 if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
8677 continue;
8678
8679 if (skip == NULL)
8680 {
8681 skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
8682 if (skip == NULL)
8683 goto error_ret;
8684 }
8685
8686 skip[rel->r_offset >> 3]
8687 |= can_optimize | ((rel - toc_relocs) << 2);
8688 }
8689 }
8690
8691 if (skip == NULL)
8692 continue;
8693
8694 used = bfd_zmalloc (sizeof (*used) * (toc->size + 7) / 8);
8695 if (used == NULL)
8696 {
8697 error_ret:
8698 if (local_syms != NULL
8699 && symtab_hdr->contents != (unsigned char *) local_syms)
8700 free (local_syms);
8701 if (sec != NULL
8702 && relstart != NULL
8703 && elf_section_data (sec)->relocs != relstart)
8704 free (relstart);
8705 if (toc_relocs != NULL
8706 && elf_section_data (toc)->relocs != toc_relocs)
8707 free (toc_relocs);
8708 if (skip != NULL)
8709 free (skip);
8710 return FALSE;
8711 }
8712
8713 /* Now check all kept sections that might reference the toc.
8714 Check the toc itself last. */
8715 for (sec = (ibfd->sections == toc && toc->next ? toc->next
8716 : ibfd->sections);
8717 sec != NULL;
8718 sec = (sec == toc ? NULL
8719 : sec->next == NULL ? toc
8720 : sec->next == toc && toc->next ? toc->next
8721 : sec->next))
8722 {
8723 int repeat;
8724
8725 if (sec->reloc_count == 0
8726 || discarded_section (sec)
8727 || get_opd_info (sec)
8728 || (sec->flags & SEC_ALLOC) == 0
8729 || (sec->flags & SEC_DEBUGGING) != 0)
8730 continue;
8731
8732 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8733 info->keep_memory);
8734 if (relstart == NULL)
8735 goto error_ret;
8736
8737 /* Mark toc entries referenced as used. */
8738 do
8739 {
8740 repeat = 0;
8741 for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
8742 {
8743 enum elf_ppc64_reloc_type r_type;
8744 unsigned long r_symndx;
8745 asection *sym_sec;
8746 struct elf_link_hash_entry *h;
8747 Elf_Internal_Sym *sym;
8748 bfd_vma val;
8749 enum {no_check, check_lo, check_ha} insn_check;
8750
8751 r_type = ELF64_R_TYPE (rel->r_info);
8752 switch (r_type)
8753 {
8754 default:
8755 insn_check = no_check;
8756 break;
8757
8758 case R_PPC64_GOT_TLSLD16_HA:
8759 case R_PPC64_GOT_TLSGD16_HA:
8760 case R_PPC64_GOT_TPREL16_HA:
8761 case R_PPC64_GOT_DTPREL16_HA:
8762 case R_PPC64_GOT16_HA:
8763 case R_PPC64_TOC16_HA:
8764 insn_check = check_ha;
8765 break;
8766
8767 case R_PPC64_GOT_TLSLD16_LO:
8768 case R_PPC64_GOT_TLSGD16_LO:
8769 case R_PPC64_GOT_TPREL16_LO_DS:
8770 case R_PPC64_GOT_DTPREL16_LO_DS:
8771 case R_PPC64_GOT16_LO:
8772 case R_PPC64_GOT16_LO_DS:
8773 case R_PPC64_TOC16_LO:
8774 case R_PPC64_TOC16_LO_DS:
8775 insn_check = check_lo;
8776 break;
8777 }
8778
8779 if (insn_check != no_check)
8780 {
8781 bfd_vma off = rel->r_offset & ~3;
8782 unsigned char buf[4];
8783 unsigned int insn;
8784
8785 if (!bfd_get_section_contents (ibfd, sec, buf, off, 4))
8786 {
8787 free (used);
8788 goto error_ret;
8789 }
8790 insn = bfd_get_32 (ibfd, buf);
8791 if (insn_check == check_lo
8792 ? !ok_lo_toc_insn (insn)
8793 : ((insn & ((0x3f << 26) | 0x1f << 16))
8794 != ((15u << 26) | (2 << 16)) /* addis rt,2,imm */))
8795 {
8796 char str[12];
8797
8798 ppc64_elf_tdata (ibfd)->unexpected_toc_insn = 1;
8799 sprintf (str, "%#08x", insn);
8800 info->callbacks->einfo
8801 (_("%P: %H: toc optimization is not supported for"
8802 " %s instruction.\n"),
8803 ibfd, sec, rel->r_offset & ~3, str);
8804 }
8805 }
8806
8807 switch (r_type)
8808 {
8809 case R_PPC64_TOC16:
8810 case R_PPC64_TOC16_LO:
8811 case R_PPC64_TOC16_HI:
8812 case R_PPC64_TOC16_HA:
8813 case R_PPC64_TOC16_DS:
8814 case R_PPC64_TOC16_LO_DS:
8815 /* In case we're taking addresses of toc entries. */
8816 case R_PPC64_ADDR64:
8817 break;
8818
8819 default:
8820 continue;
8821 }
8822
8823 r_symndx = ELF64_R_SYM (rel->r_info);
8824 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8825 r_symndx, ibfd))
8826 {
8827 free (used);
8828 goto error_ret;
8829 }
8830
8831 if (sym_sec != toc)
8832 continue;
8833
8834 if (h != NULL)
8835 val = h->root.u.def.value;
8836 else
8837 val = sym->st_value;
8838 val += rel->r_addend;
8839
8840 if (val >= toc->size)
8841 continue;
8842
8843 if ((skip[val >> 3] & can_optimize) != 0)
8844 {
8845 bfd_vma off;
8846 unsigned char opc;
8847
8848 switch (r_type)
8849 {
8850 case R_PPC64_TOC16_HA:
8851 break;
8852
8853 case R_PPC64_TOC16_LO_DS:
8854 off = rel->r_offset;
8855 off += (bfd_big_endian (ibfd) ? -2 : 3);
8856 if (!bfd_get_section_contents (ibfd, sec, &opc,
8857 off, 1))
8858 {
8859 free (used);
8860 goto error_ret;
8861 }
8862 if ((opc & (0x3f << 2)) == (58u << 2))
8863 break;
8864 /* Fall thru */
8865
8866 default:
8867 /* Wrong sort of reloc, or not a ld. We may
8868 as well clear ref_from_discarded too. */
8869 skip[val >> 3] = 0;
8870 }
8871 }
8872
8873 if (sec != toc)
8874 used[val >> 3] = 1;
8875 /* For the toc section, we only mark as used if this
8876 entry itself isn't unused. */
8877 else if ((used[rel->r_offset >> 3]
8878 || !(skip[rel->r_offset >> 3] & ref_from_discarded))
8879 && !used[val >> 3])
8880 {
8881 /* Do all the relocs again, to catch reference
8882 chains. */
8883 repeat = 1;
8884 used[val >> 3] = 1;
8885 }
8886 }
8887 }
8888 while (repeat);
8889
8890 if (elf_section_data (sec)->relocs != relstart)
8891 free (relstart);
8892 }
8893
8894 /* Merge the used and skip arrays. Assume that TOC
8895 doublewords not appearing as either used or unused belong
8896 to to an entry more than one doubleword in size. */
8897 for (drop = skip, keep = used, last = 0, some_unused = 0;
8898 drop < skip + (toc->size + 7) / 8;
8899 ++drop, ++keep)
8900 {
8901 if (*keep)
8902 {
8903 *drop &= ~ref_from_discarded;
8904 if ((*drop & can_optimize) != 0)
8905 some_unused = 1;
8906 last = 0;
8907 }
8908 else if ((*drop & ref_from_discarded) != 0)
8909 {
8910 some_unused = 1;
8911 last = ref_from_discarded;
8912 }
8913 else
8914 *drop = last;
8915 }
8916
8917 free (used);
8918
8919 if (some_unused)
8920 {
8921 bfd_byte *contents, *src;
8922 unsigned long off;
8923 Elf_Internal_Sym *sym;
8924 bfd_boolean local_toc_syms = FALSE;
8925
8926 /* Shuffle the toc contents, and at the same time convert the
8927 skip array from booleans into offsets. */
8928 if (!bfd_malloc_and_get_section (ibfd, toc, &contents))
8929 goto error_ret;
8930
8931 elf_section_data (toc)->this_hdr.contents = contents;
8932
8933 for (src = contents, off = 0, drop = skip;
8934 src < contents + toc->size;
8935 src += 8, ++drop)
8936 {
8937 if ((*drop & (can_optimize | ref_from_discarded)) != 0)
8938 off += 8;
8939 else if (off != 0)
8940 {
8941 *drop = off;
8942 memcpy (src - off, src, 8);
8943 }
8944 }
8945 *drop = off;
8946 toc->rawsize = toc->size;
8947 toc->size = src - contents - off;
8948
8949 /* Adjust addends for relocs against the toc section sym,
8950 and optimize any accesses we can. */
8951 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8952 {
8953 if (sec->reloc_count == 0
8954 || discarded_section (sec))
8955 continue;
8956
8957 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8958 info->keep_memory);
8959 if (relstart == NULL)
8960 goto error_ret;
8961
8962 for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
8963 {
8964 enum elf_ppc64_reloc_type r_type;
8965 unsigned long r_symndx;
8966 asection *sym_sec;
8967 struct elf_link_hash_entry *h;
8968 bfd_vma val;
8969
8970 r_type = ELF64_R_TYPE (rel->r_info);
8971 switch (r_type)
8972 {
8973 default:
8974 continue;
8975
8976 case R_PPC64_TOC16:
8977 case R_PPC64_TOC16_LO:
8978 case R_PPC64_TOC16_HI:
8979 case R_PPC64_TOC16_HA:
8980 case R_PPC64_TOC16_DS:
8981 case R_PPC64_TOC16_LO_DS:
8982 case R_PPC64_ADDR64:
8983 break;
8984 }
8985
8986 r_symndx = ELF64_R_SYM (rel->r_info);
8987 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8988 r_symndx, ibfd))
8989 goto error_ret;
8990
8991 if (sym_sec != toc)
8992 continue;
8993
8994 if (h != NULL)
8995 val = h->root.u.def.value;
8996 else
8997 {
8998 val = sym->st_value;
8999 if (val != 0)
9000 local_toc_syms = TRUE;
9001 }
9002
9003 val += rel->r_addend;
9004
9005 if (val > toc->rawsize)
9006 val = toc->rawsize;
9007 else if ((skip[val >> 3] & ref_from_discarded) != 0)
9008 continue;
9009 else if ((skip[val >> 3] & can_optimize) != 0)
9010 {
9011 Elf_Internal_Rela *tocrel
9012 = toc_relocs + (skip[val >> 3] >> 2);
9013 unsigned long tsym = ELF64_R_SYM (tocrel->r_info);
9014
9015 switch (r_type)
9016 {
9017 case R_PPC64_TOC16_HA:
9018 rel->r_info = ELF64_R_INFO (tsym, R_PPC64_TOC16_HA);
9019 break;
9020
9021 case R_PPC64_TOC16_LO_DS:
9022 rel->r_info = ELF64_R_INFO (tsym, R_PPC64_LO_DS_OPT);
9023 break;
9024
9025 default:
9026 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
9027 ppc_howto_init ();
9028 info->callbacks->einfo
9029 (_("%P: %H: %s references "
9030 "optimized away TOC entry\n"),
9031 ibfd, sec, rel->r_offset,
9032 ppc64_elf_howto_table[r_type]->name);
9033 bfd_set_error (bfd_error_bad_value);
9034 goto error_ret;
9035 }
9036 rel->r_addend = tocrel->r_addend;
9037 elf_section_data (sec)->relocs = relstart;
9038 continue;
9039 }
9040
9041 if (h != NULL || sym->st_value != 0)
9042 continue;
9043
9044 rel->r_addend -= skip[val >> 3];
9045 elf_section_data (sec)->relocs = relstart;
9046 }
9047
9048 if (elf_section_data (sec)->relocs != relstart)
9049 free (relstart);
9050 }
9051
9052 /* We shouldn't have local or global symbols defined in the TOC,
9053 but handle them anyway. */
9054 if (local_syms != NULL)
9055 for (sym = local_syms;
9056 sym < local_syms + symtab_hdr->sh_info;
9057 ++sym)
9058 if (sym->st_value != 0
9059 && bfd_section_from_elf_index (ibfd, sym->st_shndx) == toc)
9060 {
9061 unsigned long i;
9062
9063 if (sym->st_value > toc->rawsize)
9064 i = toc->rawsize >> 3;
9065 else
9066 i = sym->st_value >> 3;
9067
9068 if ((skip[i] & (ref_from_discarded | can_optimize)) != 0)
9069 {
9070 if (local_toc_syms)
9071 (*_bfd_error_handler)
9072 (_("%s defined on removed toc entry"),
9073 bfd_elf_sym_name (ibfd, symtab_hdr, sym, NULL));
9074 do
9075 ++i;
9076 while ((skip[i] & (ref_from_discarded | can_optimize)));
9077 sym->st_value = (bfd_vma) i << 3;
9078 }
9079
9080 sym->st_value -= skip[i];
9081 symtab_hdr->contents = (unsigned char *) local_syms;
9082 }
9083
9084 /* Adjust any global syms defined in this toc input section. */
9085 if (toc_inf.global_toc_syms)
9086 {
9087 toc_inf.toc = toc;
9088 toc_inf.skip = skip;
9089 toc_inf.global_toc_syms = FALSE;
9090 elf_link_hash_traverse (elf_hash_table (info), adjust_toc_syms,
9091 &toc_inf);
9092 }
9093
9094 if (toc->reloc_count != 0)
9095 {
9096 Elf_Internal_Shdr *rel_hdr;
9097 Elf_Internal_Rela *wrel;
9098 bfd_size_type sz;
9099
9100 /* Remove unused toc relocs, and adjust those we keep. */
9101 if (toc_relocs == NULL)
9102 toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
9103 info->keep_memory);
9104 if (toc_relocs == NULL)
9105 goto error_ret;
9106
9107 wrel = toc_relocs;
9108 for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
9109 if ((skip[rel->r_offset >> 3]
9110 & (ref_from_discarded | can_optimize)) == 0)
9111 {
9112 wrel->r_offset = rel->r_offset - skip[rel->r_offset >> 3];
9113 wrel->r_info = rel->r_info;
9114 wrel->r_addend = rel->r_addend;
9115 ++wrel;
9116 }
9117 else if (!dec_dynrel_count (rel->r_info, toc, info,
9118 &local_syms, NULL, NULL))
9119 goto error_ret;
9120
9121 elf_section_data (toc)->relocs = toc_relocs;
9122 toc->reloc_count = wrel - toc_relocs;
9123 rel_hdr = _bfd_elf_single_rel_hdr (toc);
9124 sz = rel_hdr->sh_entsize;
9125 rel_hdr->sh_size = toc->reloc_count * sz;
9126 }
9127 }
9128 else if (toc_relocs != NULL
9129 && elf_section_data (toc)->relocs != toc_relocs)
9130 free (toc_relocs);
9131
9132 if (local_syms != NULL
9133 && symtab_hdr->contents != (unsigned char *) local_syms)
9134 {
9135 if (!info->keep_memory)
9136 free (local_syms);
9137 else
9138 symtab_hdr->contents = (unsigned char *) local_syms;
9139 }
9140 free (skip);
9141 }
9142
9143 return TRUE;
9144 }
9145
9146 /* Return true iff input section I references the TOC using
9147 instructions limited to +/-32k offsets. */
9148
9149 bfd_boolean
9150 ppc64_elf_has_small_toc_reloc (asection *i)
9151 {
9152 return (is_ppc64_elf (i->owner)
9153 && ppc64_elf_tdata (i->owner)->has_small_toc_reloc);
9154 }
9155
9156 /* Allocate space for one GOT entry. */
9157
9158 static void
9159 allocate_got (struct elf_link_hash_entry *h,
9160 struct bfd_link_info *info,
9161 struct got_entry *gent)
9162 {
9163 struct ppc_link_hash_table *htab = ppc_hash_table (info);
9164 bfd_boolean dyn;
9165 struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
9166 int entsize = (gent->tls_type & eh->tls_mask & (TLS_GD | TLS_LD)
9167 ? 16 : 8);
9168 int rentsize = (gent->tls_type & eh->tls_mask & TLS_GD
9169 ? 2 : 1) * sizeof (Elf64_External_Rela);
9170 asection *got = ppc64_elf_tdata (gent->owner)->got;
9171
9172 gent->got.offset = got->size;
9173 got->size += entsize;
9174
9175 dyn = htab->elf.dynamic_sections_created;
9176 if (h->type == STT_GNU_IFUNC)
9177 {
9178 htab->reliplt->size += rentsize;
9179 htab->got_reli_size += rentsize;
9180 }
9181 else if ((info->shared
9182 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h))
9183 && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
9184 || h->root.type != bfd_link_hash_undefweak))
9185 {
9186 asection *relgot = ppc64_elf_tdata (gent->owner)->relgot;
9187 relgot->size += rentsize;
9188 }
9189 }
9190
9191 /* This function merges got entries in the same toc group. */
9192
9193 static void
9194 merge_got_entries (struct got_entry **pent)
9195 {
9196 struct got_entry *ent, *ent2;
9197
9198 for (ent = *pent; ent != NULL; ent = ent->next)
9199 if (!ent->is_indirect)
9200 for (ent2 = ent->next; ent2 != NULL; ent2 = ent2->next)
9201 if (!ent2->is_indirect
9202 && ent2->addend == ent->addend
9203 && ent2->tls_type == ent->tls_type
9204 && elf_gp (ent2->owner) == elf_gp (ent->owner))
9205 {
9206 ent2->is_indirect = TRUE;
9207 ent2->got.ent = ent;
9208 }
9209 }
9210
9211 /* Allocate space in .plt, .got and associated reloc sections for
9212 dynamic relocs. */
9213
9214 static bfd_boolean
9215 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
9216 {
9217 struct bfd_link_info *info;
9218 struct ppc_link_hash_table *htab;
9219 asection *s;
9220 struct ppc_link_hash_entry *eh;
9221 struct elf_dyn_relocs *p;
9222 struct got_entry **pgent, *gent;
9223
9224 if (h->root.type == bfd_link_hash_indirect)
9225 return TRUE;
9226
9227 info = (struct bfd_link_info *) inf;
9228 htab = ppc_hash_table (info);
9229 if (htab == NULL)
9230 return FALSE;
9231
9232 if ((htab->elf.dynamic_sections_created
9233 && h->dynindx != -1
9234 && WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info->shared, h))
9235 || h->type == STT_GNU_IFUNC)
9236 {
9237 struct plt_entry *pent;
9238 bfd_boolean doneone = FALSE;
9239 for (pent = h->plt.plist; pent != NULL; pent = pent->next)
9240 if (pent->plt.refcount > 0)
9241 {
9242 if (!htab->elf.dynamic_sections_created
9243 || h->dynindx == -1)
9244 {
9245 s = htab->iplt;
9246 pent->plt.offset = s->size;
9247 s->size += PLT_ENTRY_SIZE (htab);
9248 s = htab->reliplt;
9249 }
9250 else
9251 {
9252 /* If this is the first .plt entry, make room for the special
9253 first entry. */
9254 s = htab->plt;
9255 if (s->size == 0)
9256 s->size += PLT_INITIAL_ENTRY_SIZE (htab);
9257
9258 pent->plt.offset = s->size;
9259
9260 /* Make room for this entry. */
9261 s->size += PLT_ENTRY_SIZE (htab);
9262
9263 /* Make room for the .glink code. */
9264 s = htab->glink;
9265 if (s->size == 0)
9266 s->size += GLINK_CALL_STUB_SIZE;
9267 if (htab->opd_abi)
9268 {
9269 /* We need bigger stubs past index 32767. */
9270 if (s->size >= GLINK_CALL_STUB_SIZE + 32768*2*4)
9271 s->size += 4;
9272 s->size += 2*4;
9273 }
9274 else
9275 s->size += 4;
9276
9277 /* We also need to make an entry in the .rela.plt section. */
9278 s = htab->relplt;
9279 }
9280 s->size += sizeof (Elf64_External_Rela);
9281 doneone = TRUE;
9282 }
9283 else
9284 pent->plt.offset = (bfd_vma) -1;
9285 if (!doneone)
9286 {
9287 h->plt.plist = NULL;
9288 h->needs_plt = 0;
9289 }
9290 }
9291 else
9292 {
9293 h->plt.plist = NULL;
9294 h->needs_plt = 0;
9295 }
9296
9297 eh = (struct ppc_link_hash_entry *) h;
9298 /* Run through the TLS GD got entries first if we're changing them
9299 to TPREL. */
9300 if ((eh->tls_mask & TLS_TPRELGD) != 0)
9301 for (gent = h->got.glist; gent != NULL; gent = gent->next)
9302 if (gent->got.refcount > 0
9303 && (gent->tls_type & TLS_GD) != 0)
9304 {
9305 /* This was a GD entry that has been converted to TPREL. If
9306 there happens to be a TPREL entry we can use that one. */
9307 struct got_entry *ent;
9308 for (ent = h->got.glist; ent != NULL; ent = ent->next)
9309 if (ent->got.refcount > 0
9310 && (ent->tls_type & TLS_TPREL) != 0
9311 && ent->addend == gent->addend
9312 && ent->owner == gent->owner)
9313 {
9314 gent->got.refcount = 0;
9315 break;
9316 }
9317
9318 /* If not, then we'll be using our own TPREL entry. */
9319 if (gent->got.refcount != 0)
9320 gent->tls_type = TLS_TLS | TLS_TPREL;
9321 }
9322
9323 /* Remove any list entry that won't generate a word in the GOT before
9324 we call merge_got_entries. Otherwise we risk merging to empty
9325 entries. */
9326 pgent = &h->got.glist;
9327 while ((gent = *pgent) != NULL)
9328 if (gent->got.refcount > 0)
9329 {
9330 if ((gent->tls_type & TLS_LD) != 0
9331 && !h->def_dynamic)
9332 {
9333 ppc64_tlsld_got (gent->owner)->got.refcount += 1;
9334 *pgent = gent->next;
9335 }
9336 else
9337 pgent = &gent->next;
9338 }
9339 else
9340 *pgent = gent->next;
9341
9342 if (!htab->do_multi_toc)
9343 merge_got_entries (&h->got.glist);
9344
9345 for (gent = h->got.glist; gent != NULL; gent = gent->next)
9346 if (!gent->is_indirect)
9347 {
9348 /* Make sure this symbol is output as a dynamic symbol.
9349 Undefined weak syms won't yet be marked as dynamic,
9350 nor will all TLS symbols. */
9351 if (h->dynindx == -1
9352 && !h->forced_local
9353 && h->type != STT_GNU_IFUNC
9354 && htab->elf.dynamic_sections_created)
9355 {
9356 if (! bfd_elf_link_record_dynamic_symbol (info, h))
9357 return FALSE;
9358 }
9359
9360 if (!is_ppc64_elf (gent->owner))
9361 abort ();
9362
9363 allocate_got (h, info, gent);
9364 }
9365
9366 if (eh->dyn_relocs == NULL
9367 || (!htab->elf.dynamic_sections_created
9368 && h->type != STT_GNU_IFUNC))
9369 return TRUE;
9370
9371 /* In the shared -Bsymbolic case, discard space allocated for
9372 dynamic pc-relative relocs against symbols which turn out to be
9373 defined in regular objects. For the normal shared case, discard
9374 space for relocs that have become local due to symbol visibility
9375 changes. */
9376
9377 if (info->shared)
9378 {
9379 /* Relocs that use pc_count are those that appear on a call insn,
9380 or certain REL relocs (see must_be_dyn_reloc) that can be
9381 generated via assembly. We want calls to protected symbols to
9382 resolve directly to the function rather than going via the plt.
9383 If people want function pointer comparisons to work as expected
9384 then they should avoid writing weird assembly. */
9385 if (SYMBOL_CALLS_LOCAL (info, h))
9386 {
9387 struct elf_dyn_relocs **pp;
9388
9389 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
9390 {
9391 p->count -= p->pc_count;
9392 p->pc_count = 0;
9393 if (p->count == 0)
9394 *pp = p->next;
9395 else
9396 pp = &p->next;
9397 }
9398 }
9399
9400 /* Also discard relocs on undefined weak syms with non-default
9401 visibility. */
9402 if (eh->dyn_relocs != NULL
9403 && h->root.type == bfd_link_hash_undefweak)
9404 {
9405 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
9406 eh->dyn_relocs = NULL;
9407
9408 /* Make sure this symbol is output as a dynamic symbol.
9409 Undefined weak syms won't yet be marked as dynamic. */
9410 else if (h->dynindx == -1
9411 && !h->forced_local)
9412 {
9413 if (! bfd_elf_link_record_dynamic_symbol (info, h))
9414 return FALSE;
9415 }
9416 }
9417 }
9418 else if (h->type == STT_GNU_IFUNC)
9419 {
9420 if (!h->non_got_ref)
9421 eh->dyn_relocs = NULL;
9422 }
9423 else if (ELIMINATE_COPY_RELOCS)
9424 {
9425 /* For the non-shared case, discard space for relocs against
9426 symbols which turn out to need copy relocs or are not
9427 dynamic. */
9428
9429 if (!h->non_got_ref
9430 && !h->def_regular)
9431 {
9432 /* Make sure this symbol is output as a dynamic symbol.
9433 Undefined weak syms won't yet be marked as dynamic. */
9434 if (h->dynindx == -1
9435 && !h->forced_local)
9436 {
9437 if (! bfd_elf_link_record_dynamic_symbol (info, h))
9438 return FALSE;
9439 }
9440
9441 /* If that succeeded, we know we'll be keeping all the
9442 relocs. */
9443 if (h->dynindx != -1)
9444 goto keep;
9445 }
9446
9447 eh->dyn_relocs = NULL;
9448
9449 keep: ;
9450 }
9451
9452 /* Finally, allocate space. */
9453 for (p = eh->dyn_relocs; p != NULL; p = p->next)
9454 {
9455 asection *sreloc = elf_section_data (p->sec)->sreloc;
9456 if (eh->elf.type == STT_GNU_IFUNC)
9457 sreloc = htab->reliplt;
9458 sreloc->size += p->count * sizeof (Elf64_External_Rela);
9459 }
9460
9461 return TRUE;
9462 }
9463
9464 /* Find any dynamic relocs that apply to read-only sections. */
9465
9466 static bfd_boolean
9467 readonly_dynrelocs (struct elf_link_hash_entry *h, void *inf)
9468 {
9469 struct ppc_link_hash_entry *eh;
9470 struct elf_dyn_relocs *p;
9471
9472 eh = (struct ppc_link_hash_entry *) h;
9473 for (p = eh->dyn_relocs; p != NULL; p = p->next)
9474 {
9475 asection *s = p->sec->output_section;
9476
9477 if (s != NULL && (s->flags & SEC_READONLY) != 0)
9478 {
9479 struct bfd_link_info *info = inf;
9480
9481 info->flags |= DF_TEXTREL;
9482
9483 /* Not an error, just cut short the traversal. */
9484 return FALSE;
9485 }
9486 }
9487 return TRUE;
9488 }
9489
9490 /* Set the sizes of the dynamic sections. */
9491
9492 static bfd_boolean
9493 ppc64_elf_size_dynamic_sections (bfd *output_bfd,
9494 struct bfd_link_info *info)
9495 {
9496 struct ppc_link_hash_table *htab;
9497 bfd *dynobj;
9498 asection *s;
9499 bfd_boolean relocs;
9500 bfd *ibfd;
9501 struct got_entry *first_tlsld;
9502
9503 htab = ppc_hash_table (info);
9504 if (htab == NULL)
9505 return FALSE;
9506
9507 dynobj = htab->elf.dynobj;
9508 if (dynobj == NULL)
9509 abort ();
9510
9511 if (htab->elf.dynamic_sections_created)
9512 {
9513 /* Set the contents of the .interp section to the interpreter. */
9514 if (info->executable)
9515 {
9516 s = bfd_get_linker_section (dynobj, ".interp");
9517 if (s == NULL)
9518 abort ();
9519 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
9520 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
9521 }
9522 }
9523
9524 /* Set up .got offsets for local syms, and space for local dynamic
9525 relocs. */
9526 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
9527 {
9528 struct got_entry **lgot_ents;
9529 struct got_entry **end_lgot_ents;
9530 struct plt_entry **local_plt;
9531 struct plt_entry **end_local_plt;
9532 unsigned char *lgot_masks;
9533 bfd_size_type locsymcount;
9534 Elf_Internal_Shdr *symtab_hdr;
9535
9536 if (!is_ppc64_elf (ibfd))
9537 continue;
9538
9539 for (s = ibfd->sections; s != NULL; s = s->next)
9540 {
9541 struct ppc_dyn_relocs *p;
9542
9543 for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
9544 {
9545 if (!bfd_is_abs_section (p->sec)
9546 && bfd_is_abs_section (p->sec->output_section))
9547 {
9548 /* Input section has been discarded, either because
9549 it is a copy of a linkonce section or due to
9550 linker script /DISCARD/, so we'll be discarding
9551 the relocs too. */
9552 }
9553 else if (p->count != 0)
9554 {
9555 asection *srel = elf_section_data (p->sec)->sreloc;
9556 if (p->ifunc)
9557 srel = htab->reliplt;
9558 srel->size += p->count * sizeof (Elf64_External_Rela);
9559 if ((p->sec->output_section->flags & SEC_READONLY) != 0)
9560 info->flags |= DF_TEXTREL;
9561 }
9562 }
9563 }
9564
9565 lgot_ents = elf_local_got_ents (ibfd);
9566 if (!lgot_ents)
9567 continue;
9568
9569 symtab_hdr = &elf_symtab_hdr (ibfd);
9570 locsymcount = symtab_hdr->sh_info;
9571 end_lgot_ents = lgot_ents + locsymcount;
9572 local_plt = (struct plt_entry **) end_lgot_ents;
9573 end_local_plt = local_plt + locsymcount;
9574 lgot_masks = (unsigned char *) end_local_plt;
9575 s = ppc64_elf_tdata (ibfd)->got;
9576 for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
9577 {
9578 struct got_entry **pent, *ent;
9579
9580 pent = lgot_ents;
9581 while ((ent = *pent) != NULL)
9582 if (ent->got.refcount > 0)
9583 {
9584 if ((ent->tls_type & *lgot_masks & TLS_LD) != 0)
9585 {
9586 ppc64_tlsld_got (ibfd)->got.refcount += 1;
9587 *pent = ent->next;
9588 }
9589 else
9590 {
9591 unsigned int ent_size = 8;
9592 unsigned int rel_size = sizeof (Elf64_External_Rela);
9593
9594 ent->got.offset = s->size;
9595 if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
9596 {
9597 ent_size *= 2;
9598 rel_size *= 2;
9599 }
9600 s->size += ent_size;
9601 if ((*lgot_masks & PLT_IFUNC) != 0)
9602 {
9603 htab->reliplt->size += rel_size;
9604 htab->got_reli_size += rel_size;
9605 }
9606 else if (info->shared)
9607 {
9608 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
9609 srel->size += rel_size;
9610 }
9611 pent = &ent->next;
9612 }
9613 }
9614 else
9615 *pent = ent->next;
9616 }
9617
9618 /* Allocate space for calls to local STT_GNU_IFUNC syms in .iplt. */
9619 for (; local_plt < end_local_plt; ++local_plt)
9620 {
9621 struct plt_entry *ent;
9622
9623 for (ent = *local_plt; ent != NULL; ent = ent->next)
9624 if (ent->plt.refcount > 0)
9625 {
9626 s = htab->iplt;
9627 ent->plt.offset = s->size;
9628 s->size += PLT_ENTRY_SIZE (htab);
9629
9630 htab->reliplt->size += sizeof (Elf64_External_Rela);
9631 }
9632 else
9633 ent->plt.offset = (bfd_vma) -1;
9634 }
9635 }
9636
9637 /* Allocate global sym .plt and .got entries, and space for global
9638 sym dynamic relocs. */
9639 elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, info);
9640
9641 first_tlsld = NULL;
9642 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
9643 {
9644 struct got_entry *ent;
9645
9646 if (!is_ppc64_elf (ibfd))
9647 continue;
9648
9649 ent = ppc64_tlsld_got (ibfd);
9650 if (ent->got.refcount > 0)
9651 {
9652 if (!htab->do_multi_toc && first_tlsld != NULL)
9653 {
9654 ent->is_indirect = TRUE;
9655 ent->got.ent = first_tlsld;
9656 }
9657 else
9658 {
9659 if (first_tlsld == NULL)
9660 first_tlsld = ent;
9661 s = ppc64_elf_tdata (ibfd)->got;
9662 ent->got.offset = s->size;
9663 ent->owner = ibfd;
9664 s->size += 16;
9665 if (info->shared)
9666 {
9667 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
9668 srel->size += sizeof (Elf64_External_Rela);
9669 }
9670 }
9671 }
9672 else
9673 ent->got.offset = (bfd_vma) -1;
9674 }
9675
9676 /* We now have determined the sizes of the various dynamic sections.
9677 Allocate memory for them. */
9678 relocs = FALSE;
9679 for (s = dynobj->sections; s != NULL; s = s->next)
9680 {
9681 if ((s->flags & SEC_LINKER_CREATED) == 0)
9682 continue;
9683
9684 if (s == htab->brlt || s == htab->relbrlt)
9685 /* These haven't been allocated yet; don't strip. */
9686 continue;
9687 else if (s == htab->got
9688 || s == htab->plt
9689 || s == htab->iplt
9690 || s == htab->glink
9691 || s == htab->dynbss)
9692 {
9693 /* Strip this section if we don't need it; see the
9694 comment below. */
9695 }
9696 else if (s == htab->glink_eh_frame)
9697 {
9698 if (!bfd_is_abs_section (s->output_section))
9699 /* Not sized yet. */
9700 continue;
9701 }
9702 else if (CONST_STRNEQ (s->name, ".rela"))
9703 {
9704 if (s->size != 0)
9705 {
9706 if (s != htab->relplt)
9707 relocs = TRUE;
9708
9709 /* We use the reloc_count field as a counter if we need
9710 to copy relocs into the output file. */
9711 s->reloc_count = 0;
9712 }
9713 }
9714 else
9715 {
9716 /* It's not one of our sections, so don't allocate space. */
9717 continue;
9718 }
9719
9720 if (s->size == 0)
9721 {
9722 /* If we don't need this section, strip it from the
9723 output file. This is mostly to handle .rela.bss and
9724 .rela.plt. We must create both sections in
9725 create_dynamic_sections, because they must be created
9726 before the linker maps input sections to output
9727 sections. The linker does that before
9728 adjust_dynamic_symbol is called, and it is that
9729 function which decides whether anything needs to go
9730 into these sections. */
9731 s->flags |= SEC_EXCLUDE;
9732 continue;
9733 }
9734
9735 if ((s->flags & SEC_HAS_CONTENTS) == 0)
9736 continue;
9737
9738 /* Allocate memory for the section contents. We use bfd_zalloc
9739 here in case unused entries are not reclaimed before the
9740 section's contents are written out. This should not happen,
9741 but this way if it does we get a R_PPC64_NONE reloc in .rela
9742 sections instead of garbage.
9743 We also rely on the section contents being zero when writing
9744 the GOT. */
9745 s->contents = bfd_zalloc (dynobj, s->size);
9746 if (s->contents == NULL)
9747 return FALSE;
9748 }
9749
9750 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
9751 {
9752 if (!is_ppc64_elf (ibfd))
9753 continue;
9754
9755 s = ppc64_elf_tdata (ibfd)->got;
9756 if (s != NULL && s != htab->got)
9757 {
9758 if (s->size == 0)
9759 s->flags |= SEC_EXCLUDE;
9760 else
9761 {
9762 s->contents = bfd_zalloc (ibfd, s->size);
9763 if (s->contents == NULL)
9764 return FALSE;
9765 }
9766 }
9767 s = ppc64_elf_tdata (ibfd)->relgot;
9768 if (s != NULL)
9769 {
9770 if (s->size == 0)
9771 s->flags |= SEC_EXCLUDE;
9772 else
9773 {
9774 s->contents = bfd_zalloc (ibfd, s->size);
9775 if (s->contents == NULL)
9776 return FALSE;
9777 relocs = TRUE;
9778 s->reloc_count = 0;
9779 }
9780 }
9781 }
9782
9783 if (htab->elf.dynamic_sections_created)
9784 {
9785 /* Add some entries to the .dynamic section. We fill in the
9786 values later, in ppc64_elf_finish_dynamic_sections, but we
9787 must add the entries now so that we get the correct size for
9788 the .dynamic section. The DT_DEBUG entry is filled in by the
9789 dynamic linker and used by the debugger. */
9790 #define add_dynamic_entry(TAG, VAL) \
9791 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
9792
9793 if (info->executable)
9794 {
9795 if (!add_dynamic_entry (DT_DEBUG, 0))
9796 return FALSE;
9797 }
9798
9799 if (htab->plt != NULL && htab->plt->size != 0)
9800 {
9801 if (!add_dynamic_entry (DT_PLTGOT, 0)
9802 || !add_dynamic_entry (DT_PLTRELSZ, 0)
9803 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
9804 || !add_dynamic_entry (DT_JMPREL, 0)
9805 || !add_dynamic_entry (DT_PPC64_GLINK, 0))
9806 return FALSE;
9807 }
9808
9809 if (NO_OPD_RELOCS && abiversion (output_bfd) <= 1)
9810 {
9811 if (!add_dynamic_entry (DT_PPC64_OPD, 0)
9812 || !add_dynamic_entry (DT_PPC64_OPDSZ, 0))
9813 return FALSE;
9814 }
9815
9816 if (!htab->no_tls_get_addr_opt
9817 && htab->tls_get_addr_fd != NULL
9818 && htab->tls_get_addr_fd->elf.plt.plist != NULL
9819 && !add_dynamic_entry (DT_PPC64_TLSOPT, 0))
9820 return FALSE;
9821
9822 if (relocs)
9823 {
9824 if (!add_dynamic_entry (DT_RELA, 0)
9825 || !add_dynamic_entry (DT_RELASZ, 0)
9826 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
9827 return FALSE;
9828
9829 /* If any dynamic relocs apply to a read-only section,
9830 then we need a DT_TEXTREL entry. */
9831 if ((info->flags & DF_TEXTREL) == 0)
9832 elf_link_hash_traverse (&htab->elf, readonly_dynrelocs, info);
9833
9834 if ((info->flags & DF_TEXTREL) != 0)
9835 {
9836 if (!add_dynamic_entry (DT_TEXTREL, 0))
9837 return FALSE;
9838 }
9839 }
9840 }
9841 #undef add_dynamic_entry
9842
9843 return TRUE;
9844 }
9845
9846 /* Determine the type of stub needed, if any, for a call. */
9847
9848 static inline enum ppc_stub_type
9849 ppc_type_of_stub (asection *input_sec,
9850 const Elf_Internal_Rela *rel,
9851 struct ppc_link_hash_entry **hash,
9852 struct plt_entry **plt_ent,
9853 bfd_vma destination,
9854 unsigned long local_off)
9855 {
9856 struct ppc_link_hash_entry *h = *hash;
9857 bfd_vma location;
9858 bfd_vma branch_offset;
9859 bfd_vma max_branch_offset;
9860 enum elf_ppc64_reloc_type r_type;
9861
9862 if (h != NULL)
9863 {
9864 struct plt_entry *ent;
9865 struct ppc_link_hash_entry *fdh = h;
9866 if (h->oh != NULL
9867 && h->oh->is_func_descriptor)
9868 {
9869 fdh = ppc_follow_link (h->oh);
9870 *hash = fdh;
9871 }
9872
9873 for (ent = fdh->elf.plt.plist; ent != NULL; ent = ent->next)
9874 if (ent->addend == rel->r_addend
9875 && ent->plt.offset != (bfd_vma) -1)
9876 {
9877 *plt_ent = ent;
9878 return ppc_stub_plt_call;
9879 }
9880
9881 /* Here, we know we don't have a plt entry. If we don't have a
9882 either a defined function descriptor or a defined entry symbol
9883 in a regular object file, then it is pointless trying to make
9884 any other type of stub. */
9885 if (!is_static_defined (&fdh->elf)
9886 && !is_static_defined (&h->elf))
9887 return ppc_stub_none;
9888 }
9889 else if (elf_local_got_ents (input_sec->owner) != NULL)
9890 {
9891 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (input_sec->owner);
9892 struct plt_entry **local_plt = (struct plt_entry **)
9893 elf_local_got_ents (input_sec->owner) + symtab_hdr->sh_info;
9894 unsigned long r_symndx = ELF64_R_SYM (rel->r_info);
9895
9896 if (local_plt[r_symndx] != NULL)
9897 {
9898 struct plt_entry *ent;
9899
9900 for (ent = local_plt[r_symndx]; ent != NULL; ent = ent->next)
9901 if (ent->addend == rel->r_addend
9902 && ent->plt.offset != (bfd_vma) -1)
9903 {
9904 *plt_ent = ent;
9905 return ppc_stub_plt_call;
9906 }
9907 }
9908 }
9909
9910 /* Determine where the call point is. */
9911 location = (input_sec->output_offset
9912 + input_sec->output_section->vma
9913 + rel->r_offset);
9914
9915 branch_offset = destination - location;
9916 r_type = ELF64_R_TYPE (rel->r_info);
9917
9918 /* Determine if a long branch stub is needed. */
9919 max_branch_offset = 1 << 25;
9920 if (r_type != R_PPC64_REL24)
9921 max_branch_offset = 1 << 15;
9922
9923 if (branch_offset + max_branch_offset >= 2 * max_branch_offset - local_off)
9924 /* We need a stub. Figure out whether a long_branch or plt_branch
9925 is needed later. */
9926 return ppc_stub_long_branch;
9927
9928 return ppc_stub_none;
9929 }
9930
9931 /* With power7 weakly ordered memory model, it is possible for ld.so
9932 to update a plt entry in one thread and have another thread see a
9933 stale zero toc entry. To avoid this we need some sort of acquire
9934 barrier in the call stub. One solution is to make the load of the
9935 toc word seem to appear to depend on the load of the function entry
9936 word. Another solution is to test for r2 being zero, and branch to
9937 the appropriate glink entry if so.
9938
9939 . fake dep barrier compare
9940 . ld 12,xxx(2) ld 12,xxx(2)
9941 . mtctr 12 mtctr 12
9942 . xor 11,12,12 ld 2,xxx+8(2)
9943 . add 2,2,11 cmpldi 2,0
9944 . ld 2,xxx+8(2) bnectr+
9945 . bctr b <glink_entry>
9946
9947 The solution involving the compare turns out to be faster, so
9948 that's what we use unless the branch won't reach. */
9949
9950 #define ALWAYS_USE_FAKE_DEP 0
9951 #define ALWAYS_EMIT_R2SAVE 0
9952
9953 #define PPC_LO(v) ((v) & 0xffff)
9954 #define PPC_HI(v) (((v) >> 16) & 0xffff)
9955 #define PPC_HA(v) PPC_HI ((v) + 0x8000)
9956
9957 static inline unsigned int
9958 plt_stub_size (struct ppc_link_hash_table *htab,
9959 struct ppc_stub_hash_entry *stub_entry,
9960 bfd_vma off)
9961 {
9962 unsigned size = 12;
9963
9964 if (ALWAYS_EMIT_R2SAVE
9965 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
9966 size += 4;
9967 if (PPC_HA (off) != 0)
9968 size += 4;
9969 if (htab->opd_abi)
9970 {
9971 size += 4;
9972 if (htab->plt_static_chain)
9973 size += 4;
9974 if (htab->plt_thread_safe)
9975 size += 8;
9976 if (PPC_HA (off + 8 + 8 * htab->plt_static_chain) != PPC_HA (off))
9977 size += 4;
9978 }
9979 if (stub_entry->h != NULL
9980 && (stub_entry->h == htab->tls_get_addr_fd
9981 || stub_entry->h == htab->tls_get_addr)
9982 && !htab->no_tls_get_addr_opt)
9983 size += 13 * 4;
9984 return size;
9985 }
9986
9987 /* If this stub would cross fewer 2**plt_stub_align boundaries if we align,
9988 then return the padding needed to do so. */
9989 static inline unsigned int
9990 plt_stub_pad (struct ppc_link_hash_table *htab,
9991 struct ppc_stub_hash_entry *stub_entry,
9992 bfd_vma plt_off)
9993 {
9994 int stub_align = 1 << htab->plt_stub_align;
9995 unsigned stub_size = plt_stub_size (htab, stub_entry, plt_off);
9996 bfd_vma stub_off = stub_entry->stub_sec->size;
9997
9998 if (((stub_off + stub_size - 1) & -stub_align) - (stub_off & -stub_align)
9999 > (stub_size & -stub_align))
10000 return stub_align - (stub_off & (stub_align - 1));
10001 return 0;
10002 }
10003
10004 /* Build a .plt call stub. */
10005
10006 static inline bfd_byte *
10007 build_plt_stub (struct ppc_link_hash_table *htab,
10008 struct ppc_stub_hash_entry *stub_entry,
10009 bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
10010 {
10011 bfd *obfd = htab->stub_bfd;
10012 bfd_boolean plt_load_toc = htab->opd_abi;
10013 bfd_boolean plt_static_chain = htab->plt_static_chain;
10014 bfd_boolean plt_thread_safe = htab->plt_thread_safe;
10015 bfd_boolean use_fake_dep = plt_thread_safe;
10016 bfd_vma cmp_branch_off = 0;
10017
10018 if (!ALWAYS_USE_FAKE_DEP
10019 && plt_load_toc
10020 && plt_thread_safe
10021 && !(stub_entry->h != NULL
10022 && (stub_entry->h == htab->tls_get_addr_fd
10023 || stub_entry->h == htab->tls_get_addr)
10024 && !htab->no_tls_get_addr_opt))
10025 {
10026 bfd_vma pltoff = stub_entry->plt_ent->plt.offset & ~1;
10027 bfd_vma pltindex = ((pltoff - PLT_INITIAL_ENTRY_SIZE (htab))
10028 / PLT_ENTRY_SIZE (htab));
10029 bfd_vma glinkoff = GLINK_CALL_STUB_SIZE + pltindex * 8;
10030 bfd_vma to, from;
10031
10032 if (pltindex > 32768)
10033 glinkoff += (pltindex - 32768) * 4;
10034 to = (glinkoff
10035 + htab->glink->output_offset
10036 + htab->glink->output_section->vma);
10037 from = (p - stub_entry->stub_sec->contents
10038 + 4 * (ALWAYS_EMIT_R2SAVE
10039 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10040 + 4 * (PPC_HA (offset) != 0)
10041 + 4 * (PPC_HA (offset + 8 + 8 * plt_static_chain)
10042 != PPC_HA (offset))
10043 + 4 * (plt_static_chain != 0)
10044 + 20
10045 + stub_entry->stub_sec->output_offset
10046 + stub_entry->stub_sec->output_section->vma);
10047 cmp_branch_off = to - from;
10048 use_fake_dep = cmp_branch_off + (1 << 25) >= (1 << 26);
10049 }
10050
10051 if (PPC_HA (offset) != 0)
10052 {
10053 if (r != NULL)
10054 {
10055 if (ALWAYS_EMIT_R2SAVE
10056 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10057 r[0].r_offset += 4;
10058 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
10059 r[1].r_offset = r[0].r_offset + 4;
10060 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10061 r[1].r_addend = r[0].r_addend;
10062 if (plt_load_toc)
10063 {
10064 if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10065 {
10066 r[2].r_offset = r[1].r_offset + 4;
10067 r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO);
10068 r[2].r_addend = r[0].r_addend;
10069 }
10070 else
10071 {
10072 r[2].r_offset = r[1].r_offset + 8 + 8 * use_fake_dep;
10073 r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10074 r[2].r_addend = r[0].r_addend + 8;
10075 if (plt_static_chain)
10076 {
10077 r[3].r_offset = r[2].r_offset + 4;
10078 r[3].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10079 r[3].r_addend = r[0].r_addend + 16;
10080 }
10081 }
10082 }
10083 }
10084 if (ALWAYS_EMIT_R2SAVE
10085 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10086 bfd_put_32 (obfd, STD_R2_40R1, p), p += 4;
10087 bfd_put_32 (obfd, ADDIS_R11_R2 | PPC_HA (offset), p), p += 4;
10088 bfd_put_32 (obfd, LD_R12_0R11 | PPC_LO (offset), p), p += 4;
10089 if (plt_load_toc
10090 && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10091 {
10092 bfd_put_32 (obfd, ADDI_R11_R11 | PPC_LO (offset), p), p += 4;
10093 offset = 0;
10094 }
10095 bfd_put_32 (obfd, MTCTR_R12, p), p += 4;
10096 if (plt_load_toc)
10097 {
10098 if (use_fake_dep)
10099 {
10100 bfd_put_32 (obfd, XOR_R2_R12_R12, p), p += 4;
10101 bfd_put_32 (obfd, ADD_R11_R11_R2, p), p += 4;
10102 }
10103 bfd_put_32 (obfd, LD_R2_0R11 | PPC_LO (offset + 8), p), p += 4;
10104 if (plt_static_chain)
10105 bfd_put_32 (obfd, LD_R11_0R11 | PPC_LO (offset + 16), p), p += 4;
10106 }
10107 }
10108 else
10109 {
10110 if (r != NULL)
10111 {
10112 if (ALWAYS_EMIT_R2SAVE
10113 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10114 r[0].r_offset += 4;
10115 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10116 if (plt_load_toc)
10117 {
10118 if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10119 {
10120 r[1].r_offset = r[0].r_offset + 4;
10121 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16);
10122 r[1].r_addend = r[0].r_addend;
10123 }
10124 else
10125 {
10126 r[1].r_offset = r[0].r_offset + 8 + 8 * use_fake_dep;
10127 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10128 r[1].r_addend = r[0].r_addend + 8 + 8 * plt_static_chain;
10129 if (plt_static_chain)
10130 {
10131 r[2].r_offset = r[1].r_offset + 4;
10132 r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10133 r[2].r_addend = r[0].r_addend + 8;
10134 }
10135 }
10136 }
10137 }
10138 if (ALWAYS_EMIT_R2SAVE
10139 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10140 bfd_put_32 (obfd, STD_R2_40R1, p), p += 4;
10141 bfd_put_32 (obfd, LD_R12_0R2 | PPC_LO (offset), p), p += 4;
10142 if (plt_load_toc
10143 && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10144 {
10145 bfd_put_32 (obfd, ADDI_R2_R2 | PPC_LO (offset), p), p += 4;
10146 offset = 0;
10147 }
10148 bfd_put_32 (obfd, MTCTR_R12, p), p += 4;
10149 if (plt_load_toc)
10150 {
10151 if (use_fake_dep)
10152 {
10153 bfd_put_32 (obfd, XOR_R11_R12_R12, p), p += 4;
10154 bfd_put_32 (obfd, ADD_R2_R2_R11, p), p += 4;
10155 }
10156 if (plt_static_chain)
10157 bfd_put_32 (obfd, LD_R11_0R2 | PPC_LO (offset + 16), p), p += 4;
10158 bfd_put_32 (obfd, LD_R2_0R2 | PPC_LO (offset + 8), p), p += 4;
10159 }
10160 }
10161 if (plt_load_toc && plt_thread_safe && !use_fake_dep)
10162 {
10163 bfd_put_32 (obfd, CMPLDI_R2_0, p), p += 4;
10164 bfd_put_32 (obfd, BNECTR_P4, p), p += 4;
10165 bfd_put_32 (obfd, B_DOT | (cmp_branch_off & 0x3fffffc), p), p += 4;
10166 }
10167 else
10168 bfd_put_32 (obfd, BCTR, p), p += 4;
10169 return p;
10170 }
10171
10172 /* Build a special .plt call stub for __tls_get_addr. */
10173
10174 #define LD_R11_0R3 0xe9630000
10175 #define LD_R12_0R3 0xe9830000
10176 #define MR_R0_R3 0x7c601b78
10177 #define CMPDI_R11_0 0x2c2b0000
10178 #define ADD_R3_R12_R13 0x7c6c6a14
10179 #define BEQLR 0x4d820020
10180 #define MR_R3_R0 0x7c030378
10181 #define MFLR_R11 0x7d6802a6
10182 #define STD_R11_0R1 0xf9610000
10183 #define BCTRL 0x4e800421
10184 #define LD_R11_0R1 0xe9610000
10185 #define LD_R2_0R1 0xe8410000
10186 #define MTLR_R11 0x7d6803a6
10187
10188 static inline bfd_byte *
10189 build_tls_get_addr_stub (struct ppc_link_hash_table *htab,
10190 struct ppc_stub_hash_entry *stub_entry,
10191 bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
10192 {
10193 bfd *obfd = htab->stub_bfd;
10194
10195 bfd_put_32 (obfd, LD_R11_0R3 + 0, p), p += 4;
10196 bfd_put_32 (obfd, LD_R12_0R3 + 8, p), p += 4;
10197 bfd_put_32 (obfd, MR_R0_R3, p), p += 4;
10198 bfd_put_32 (obfd, CMPDI_R11_0, p), p += 4;
10199 bfd_put_32 (obfd, ADD_R3_R12_R13, p), p += 4;
10200 bfd_put_32 (obfd, BEQLR, p), p += 4;
10201 bfd_put_32 (obfd, MR_R3_R0, p), p += 4;
10202 bfd_put_32 (obfd, MFLR_R11, p), p += 4;
10203 bfd_put_32 (obfd, STD_R11_0R1 + 32, p), p += 4;
10204
10205 if (r != NULL)
10206 r[0].r_offset += 9 * 4;
10207 p = build_plt_stub (htab, stub_entry, p, offset, r);
10208 bfd_put_32 (obfd, BCTRL, p - 4);
10209
10210 bfd_put_32 (obfd, LD_R11_0R1 + 32, p), p += 4;
10211 bfd_put_32 (obfd, LD_R2_0R1 + 40, p), p += 4;
10212 bfd_put_32 (obfd, MTLR_R11, p), p += 4;
10213 bfd_put_32 (obfd, BLR, p), p += 4;
10214
10215 return p;
10216 }
10217
10218 static Elf_Internal_Rela *
10219 get_relocs (asection *sec, int count)
10220 {
10221 Elf_Internal_Rela *relocs;
10222 struct bfd_elf_section_data *elfsec_data;
10223
10224 elfsec_data = elf_section_data (sec);
10225 relocs = elfsec_data->relocs;
10226 if (relocs == NULL)
10227 {
10228 bfd_size_type relsize;
10229 relsize = sec->reloc_count * sizeof (*relocs);
10230 relocs = bfd_alloc (sec->owner, relsize);
10231 if (relocs == NULL)
10232 return NULL;
10233 elfsec_data->relocs = relocs;
10234 elfsec_data->rela.hdr = bfd_zalloc (sec->owner,
10235 sizeof (Elf_Internal_Shdr));
10236 if (elfsec_data->rela.hdr == NULL)
10237 return NULL;
10238 elfsec_data->rela.hdr->sh_size = (sec->reloc_count
10239 * sizeof (Elf64_External_Rela));
10240 elfsec_data->rela.hdr->sh_entsize = sizeof (Elf64_External_Rela);
10241 sec->reloc_count = 0;
10242 }
10243 relocs += sec->reloc_count;
10244 sec->reloc_count += count;
10245 return relocs;
10246 }
10247
10248 static bfd_vma
10249 get_r2off (struct bfd_link_info *info,
10250 struct ppc_stub_hash_entry *stub_entry)
10251 {
10252 struct ppc_link_hash_table *htab = ppc_hash_table (info);
10253 bfd_vma r2off = htab->stub_group[stub_entry->target_section->id].toc_off;
10254
10255 if (r2off == 0)
10256 {
10257 /* Support linking -R objects. Get the toc pointer from the
10258 opd entry. */
10259 char buf[8];
10260 if (!htab->opd_abi)
10261 return r2off;
10262 asection *opd = stub_entry->h->elf.root.u.def.section;
10263 bfd_vma opd_off = stub_entry->h->elf.root.u.def.value;
10264
10265 if (strcmp (opd->name, ".opd") != 0
10266 || opd->reloc_count != 0)
10267 {
10268 info->callbacks->einfo (_("%P: cannot find opd entry toc for `%T'\n"),
10269 stub_entry->h->elf.root.root.string);
10270 bfd_set_error (bfd_error_bad_value);
10271 return 0;
10272 }
10273 if (!bfd_get_section_contents (opd->owner, opd, buf, opd_off + 8, 8))
10274 return 0;
10275 r2off = bfd_get_64 (opd->owner, buf);
10276 r2off -= elf_gp (info->output_bfd);
10277 }
10278 r2off -= htab->stub_group[stub_entry->id_sec->id].toc_off;
10279 return r2off;
10280 }
10281
10282 static bfd_boolean
10283 ppc_build_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
10284 {
10285 struct ppc_stub_hash_entry *stub_entry;
10286 struct ppc_branch_hash_entry *br_entry;
10287 struct bfd_link_info *info;
10288 struct ppc_link_hash_table *htab;
10289 bfd_byte *loc;
10290 bfd_byte *p;
10291 bfd_vma dest, off;
10292 int size;
10293 Elf_Internal_Rela *r;
10294 asection *plt;
10295
10296 /* Massage our args to the form they really have. */
10297 stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
10298 info = in_arg;
10299
10300 htab = ppc_hash_table (info);
10301 if (htab == NULL)
10302 return FALSE;
10303
10304 /* Make a note of the offset within the stubs for this entry. */
10305 stub_entry->stub_offset = stub_entry->stub_sec->size;
10306 loc = stub_entry->stub_sec->contents + stub_entry->stub_offset;
10307
10308 htab->stub_count[stub_entry->stub_type - 1] += 1;
10309 switch (stub_entry->stub_type)
10310 {
10311 case ppc_stub_long_branch:
10312 case ppc_stub_long_branch_r2off:
10313 /* Branches are relative. This is where we are going to. */
10314 dest = (stub_entry->target_value
10315 + stub_entry->target_section->output_offset
10316 + stub_entry->target_section->output_section->vma);
10317 dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
10318 off = dest;
10319
10320 /* And this is where we are coming from. */
10321 off -= (stub_entry->stub_offset
10322 + stub_entry->stub_sec->output_offset
10323 + stub_entry->stub_sec->output_section->vma);
10324
10325 size = 4;
10326 if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
10327 {
10328 bfd_vma r2off = get_r2off (info, stub_entry);
10329
10330 if (r2off == 0)
10331 {
10332 htab->stub_error = TRUE;
10333 return FALSE;
10334 }
10335 bfd_put_32 (htab->stub_bfd, STD_R2_40R1, loc);
10336 loc += 4;
10337 size = 12;
10338 if (PPC_HA (r2off) != 0)
10339 {
10340 size = 16;
10341 bfd_put_32 (htab->stub_bfd, ADDIS_R2_R2 | PPC_HA (r2off), loc);
10342 loc += 4;
10343 }
10344 bfd_put_32 (htab->stub_bfd, ADDI_R2_R2 | PPC_LO (r2off), loc);
10345 loc += 4;
10346 off -= size - 4;
10347 }
10348 bfd_put_32 (htab->stub_bfd, B_DOT | (off & 0x3fffffc), loc);
10349
10350 if (off + (1 << 25) >= (bfd_vma) (1 << 26))
10351 {
10352 info->callbacks->einfo
10353 (_("%P: long branch stub `%s' offset overflow\n"),
10354 stub_entry->root.string);
10355 htab->stub_error = TRUE;
10356 return FALSE;
10357 }
10358
10359 if (info->emitrelocations)
10360 {
10361 r = get_relocs (stub_entry->stub_sec, 1);
10362 if (r == NULL)
10363 return FALSE;
10364 r->r_offset = loc - stub_entry->stub_sec->contents;
10365 r->r_info = ELF64_R_INFO (0, R_PPC64_REL24);
10366 r->r_addend = dest;
10367 if (stub_entry->h != NULL)
10368 {
10369 struct elf_link_hash_entry **hashes;
10370 unsigned long symndx;
10371 struct ppc_link_hash_entry *h;
10372
10373 hashes = elf_sym_hashes (htab->stub_bfd);
10374 if (hashes == NULL)
10375 {
10376 bfd_size_type hsize;
10377
10378 hsize = (htab->stub_globals + 1) * sizeof (*hashes);
10379 hashes = bfd_zalloc (htab->stub_bfd, hsize);
10380 if (hashes == NULL)
10381 return FALSE;
10382 elf_sym_hashes (htab->stub_bfd) = hashes;
10383 htab->stub_globals = 1;
10384 }
10385 symndx = htab->stub_globals++;
10386 h = stub_entry->h;
10387 hashes[symndx] = &h->elf;
10388 r->r_info = ELF64_R_INFO (symndx, R_PPC64_REL24);
10389 if (h->oh != NULL && h->oh->is_func)
10390 h = ppc_follow_link (h->oh);
10391 if (h->elf.root.u.def.section != stub_entry->target_section)
10392 /* H is an opd symbol. The addend must be zero. */
10393 r->r_addend = 0;
10394 else
10395 {
10396 off = (h->elf.root.u.def.value
10397 + h->elf.root.u.def.section->output_offset
10398 + h->elf.root.u.def.section->output_section->vma);
10399 r->r_addend -= off;
10400 }
10401 }
10402 }
10403 break;
10404
10405 case ppc_stub_plt_branch:
10406 case ppc_stub_plt_branch_r2off:
10407 br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
10408 stub_entry->root.string + 9,
10409 FALSE, FALSE);
10410 if (br_entry == NULL)
10411 {
10412 info->callbacks->einfo (_("%P: can't find branch stub `%s'\n"),
10413 stub_entry->root.string);
10414 htab->stub_error = TRUE;
10415 return FALSE;
10416 }
10417
10418 dest = (stub_entry->target_value
10419 + stub_entry->target_section->output_offset
10420 + stub_entry->target_section->output_section->vma);
10421 if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
10422 dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
10423
10424 bfd_put_64 (htab->brlt->owner, dest,
10425 htab->brlt->contents + br_entry->offset);
10426
10427 if (br_entry->iter == htab->stub_iteration)
10428 {
10429 br_entry->iter = 0;
10430
10431 if (htab->relbrlt != NULL)
10432 {
10433 /* Create a reloc for the branch lookup table entry. */
10434 Elf_Internal_Rela rela;
10435 bfd_byte *rl;
10436
10437 rela.r_offset = (br_entry->offset
10438 + htab->brlt->output_offset
10439 + htab->brlt->output_section->vma);
10440 rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
10441 rela.r_addend = dest;
10442
10443 rl = htab->relbrlt->contents;
10444 rl += (htab->relbrlt->reloc_count++
10445 * sizeof (Elf64_External_Rela));
10446 bfd_elf64_swap_reloca_out (htab->relbrlt->owner, &rela, rl);
10447 }
10448 else if (info->emitrelocations)
10449 {
10450 r = get_relocs (htab->brlt, 1);
10451 if (r == NULL)
10452 return FALSE;
10453 /* brlt, being SEC_LINKER_CREATED does not go through the
10454 normal reloc processing. Symbols and offsets are not
10455 translated from input file to output file form, so
10456 set up the offset per the output file. */
10457 r->r_offset = (br_entry->offset
10458 + htab->brlt->output_offset
10459 + htab->brlt->output_section->vma);
10460 r->r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
10461 r->r_addend = dest;
10462 }
10463 }
10464
10465 dest = (br_entry->offset
10466 + htab->brlt->output_offset
10467 + htab->brlt->output_section->vma);
10468
10469 off = (dest
10470 - elf_gp (htab->brlt->output_section->owner)
10471 - htab->stub_group[stub_entry->id_sec->id].toc_off);
10472
10473 if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
10474 {
10475 info->callbacks->einfo
10476 (_("%P: linkage table error against `%T'\n"),
10477 stub_entry->root.string);
10478 bfd_set_error (bfd_error_bad_value);
10479 htab->stub_error = TRUE;
10480 return FALSE;
10481 }
10482
10483 if (info->emitrelocations)
10484 {
10485 r = get_relocs (stub_entry->stub_sec, 1 + (PPC_HA (off) != 0));
10486 if (r == NULL)
10487 return FALSE;
10488 r[0].r_offset = loc - stub_entry->stub_sec->contents;
10489 if (bfd_big_endian (info->output_bfd))
10490 r[0].r_offset += 2;
10491 if (stub_entry->stub_type == ppc_stub_plt_branch_r2off
10492 && htab->opd_abi)
10493 r[0].r_offset += 4;
10494 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10495 r[0].r_addend = dest;
10496 if (PPC_HA (off) != 0)
10497 {
10498 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
10499 r[1].r_offset = r[0].r_offset + 4;
10500 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10501 r[1].r_addend = r[0].r_addend;
10502 }
10503 }
10504
10505 if (stub_entry->stub_type != ppc_stub_plt_branch_r2off
10506 || !htab->opd_abi)
10507 {
10508 if (PPC_HA (off) != 0)
10509 {
10510 size = 16;
10511 bfd_put_32 (htab->stub_bfd, ADDIS_R11_R2 | PPC_HA (off), loc);
10512 loc += 4;
10513 bfd_put_32 (htab->stub_bfd, LD_R12_0R11 | PPC_LO (off), loc);
10514 }
10515 else
10516 {
10517 size = 12;
10518 bfd_put_32 (htab->stub_bfd, LD_R12_0R2 | PPC_LO (off), loc);
10519 }
10520 }
10521 else
10522 {
10523 bfd_vma r2off = get_r2off (info, stub_entry);
10524
10525 if (r2off == 0)
10526 {
10527 htab->stub_error = TRUE;
10528 return FALSE;
10529 }
10530
10531 bfd_put_32 (htab->stub_bfd, STD_R2_40R1, loc);
10532 loc += 4;
10533 size = 20;
10534 if (PPC_HA (off) != 0)
10535 {
10536 size += 4;
10537 bfd_put_32 (htab->stub_bfd, ADDIS_R11_R2 | PPC_HA (off), loc);
10538 loc += 4;
10539 bfd_put_32 (htab->stub_bfd, LD_R12_0R11 | PPC_LO (off), loc);
10540 loc += 4;
10541 }
10542 else
10543 {
10544 bfd_put_32 (htab->stub_bfd, LD_R12_0R2 | PPC_LO (off), loc);
10545 loc += 4;
10546 }
10547
10548 if (PPC_HA (r2off) != 0)
10549 {
10550 size += 4;
10551 bfd_put_32 (htab->stub_bfd, ADDIS_R2_R2 | PPC_HA (r2off), loc);
10552 loc += 4;
10553 }
10554 bfd_put_32 (htab->stub_bfd, ADDI_R2_R2 | PPC_LO (r2off), loc);
10555 }
10556 loc += 4;
10557 bfd_put_32 (htab->stub_bfd, MTCTR_R12, loc);
10558 loc += 4;
10559 bfd_put_32 (htab->stub_bfd, BCTR, loc);
10560 break;
10561
10562 case ppc_stub_plt_call:
10563 case ppc_stub_plt_call_r2save:
10564 if (stub_entry->h != NULL
10565 && stub_entry->h->is_func_descriptor
10566 && stub_entry->h->oh != NULL)
10567 {
10568 struct ppc_link_hash_entry *fh = ppc_follow_link (stub_entry->h->oh);
10569
10570 /* If the old-ABI "dot-symbol" is undefined make it weak so
10571 we don't get a link error from RELOC_FOR_GLOBAL_SYMBOL.
10572 FIXME: We used to define the symbol on one of the call
10573 stubs instead, which is why we test symbol section id
10574 against htab->top_id in various places. Likely all
10575 these checks could now disappear. */
10576 if (fh->elf.root.type == bfd_link_hash_undefined)
10577 fh->elf.root.type = bfd_link_hash_undefweak;
10578 /* Stop undo_symbol_twiddle changing it back to undefined. */
10579 fh->was_undefined = 0;
10580 }
10581
10582 /* Now build the stub. */
10583 dest = stub_entry->plt_ent->plt.offset & ~1;
10584 if (dest >= (bfd_vma) -2)
10585 abort ();
10586
10587 plt = htab->plt;
10588 if (!htab->elf.dynamic_sections_created
10589 || stub_entry->h == NULL
10590 || stub_entry->h->elf.dynindx == -1)
10591 plt = htab->iplt;
10592
10593 dest += plt->output_offset + plt->output_section->vma;
10594
10595 if (stub_entry->h == NULL
10596 && (stub_entry->plt_ent->plt.offset & 1) == 0)
10597 {
10598 Elf_Internal_Rela rela;
10599 bfd_byte *rl;
10600
10601 rela.r_offset = dest;
10602 if (htab->opd_abi)
10603 rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
10604 else
10605 rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
10606 rela.r_addend = (stub_entry->target_value
10607 + stub_entry->target_section->output_offset
10608 + stub_entry->target_section->output_section->vma);
10609
10610 rl = (htab->reliplt->contents
10611 + (htab->reliplt->reloc_count++
10612 * sizeof (Elf64_External_Rela)));
10613 bfd_elf64_swap_reloca_out (info->output_bfd, &rela, rl);
10614 stub_entry->plt_ent->plt.offset |= 1;
10615 }
10616
10617 off = (dest
10618 - elf_gp (plt->output_section->owner)
10619 - htab->stub_group[stub_entry->id_sec->id].toc_off);
10620
10621 if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
10622 {
10623 info->callbacks->einfo
10624 (_("%P: linkage table error against `%T'\n"),
10625 stub_entry->h != NULL
10626 ? stub_entry->h->elf.root.root.string
10627 : "<local sym>");
10628 bfd_set_error (bfd_error_bad_value);
10629 htab->stub_error = TRUE;
10630 return FALSE;
10631 }
10632
10633 if (htab->plt_stub_align != 0)
10634 {
10635 unsigned pad = plt_stub_pad (htab, stub_entry, off);
10636
10637 stub_entry->stub_sec->size += pad;
10638 stub_entry->stub_offset = stub_entry->stub_sec->size;
10639 loc += pad;
10640 }
10641
10642 r = NULL;
10643 if (info->emitrelocations)
10644 {
10645 r = get_relocs (stub_entry->stub_sec,
10646 (2
10647 + (PPC_HA (off) != 0)
10648 + (htab->plt_static_chain
10649 && PPC_HA (off + 16) == PPC_HA (off))));
10650 if (r == NULL)
10651 return FALSE;
10652 r[0].r_offset = loc - stub_entry->stub_sec->contents;
10653 if (bfd_big_endian (info->output_bfd))
10654 r[0].r_offset += 2;
10655 r[0].r_addend = dest;
10656 }
10657 if (stub_entry->h != NULL
10658 && (stub_entry->h == htab->tls_get_addr_fd
10659 || stub_entry->h == htab->tls_get_addr)
10660 && !htab->no_tls_get_addr_opt)
10661 p = build_tls_get_addr_stub (htab, stub_entry, loc, off, r);
10662 else
10663 p = build_plt_stub (htab, stub_entry, loc, off, r);
10664 size = p - loc;
10665 break;
10666
10667 default:
10668 BFD_FAIL ();
10669 return FALSE;
10670 }
10671
10672 stub_entry->stub_sec->size += size;
10673
10674 if (htab->emit_stub_syms)
10675 {
10676 struct elf_link_hash_entry *h;
10677 size_t len1, len2;
10678 char *name;
10679 const char *const stub_str[] = { "long_branch",
10680 "long_branch_r2off",
10681 "plt_branch",
10682 "plt_branch_r2off",
10683 "plt_call",
10684 "plt_call" };
10685
10686 len1 = strlen (stub_str[stub_entry->stub_type - 1]);
10687 len2 = strlen (stub_entry->root.string);
10688 name = bfd_malloc (len1 + len2 + 2);
10689 if (name == NULL)
10690 return FALSE;
10691 memcpy (name, stub_entry->root.string, 9);
10692 memcpy (name + 9, stub_str[stub_entry->stub_type - 1], len1);
10693 memcpy (name + len1 + 9, stub_entry->root.string + 8, len2 - 8 + 1);
10694 h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
10695 if (h == NULL)
10696 return FALSE;
10697 if (h->root.type == bfd_link_hash_new)
10698 {
10699 h->root.type = bfd_link_hash_defined;
10700 h->root.u.def.section = stub_entry->stub_sec;
10701 h->root.u.def.value = stub_entry->stub_offset;
10702 h->ref_regular = 1;
10703 h->def_regular = 1;
10704 h->ref_regular_nonweak = 1;
10705 h->forced_local = 1;
10706 h->non_elf = 0;
10707 }
10708 }
10709
10710 return TRUE;
10711 }
10712
10713 /* As above, but don't actually build the stub. Just bump offset so
10714 we know stub section sizes, and select plt_branch stubs where
10715 long_branch stubs won't do. */
10716
10717 static bfd_boolean
10718 ppc_size_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
10719 {
10720 struct ppc_stub_hash_entry *stub_entry;
10721 struct bfd_link_info *info;
10722 struct ppc_link_hash_table *htab;
10723 bfd_vma off;
10724 int size;
10725
10726 /* Massage our args to the form they really have. */
10727 stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
10728 info = in_arg;
10729
10730 htab = ppc_hash_table (info);
10731 if (htab == NULL)
10732 return FALSE;
10733
10734 if (stub_entry->stub_type == ppc_stub_plt_call
10735 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10736 {
10737 asection *plt;
10738 off = stub_entry->plt_ent->plt.offset & ~(bfd_vma) 1;
10739 if (off >= (bfd_vma) -2)
10740 abort ();
10741 plt = htab->plt;
10742 if (!htab->elf.dynamic_sections_created
10743 || stub_entry->h == NULL
10744 || stub_entry->h->elf.dynindx == -1)
10745 plt = htab->iplt;
10746 off += (plt->output_offset
10747 + plt->output_section->vma
10748 - elf_gp (plt->output_section->owner)
10749 - htab->stub_group[stub_entry->id_sec->id].toc_off);
10750
10751 size = plt_stub_size (htab, stub_entry, off);
10752 if (htab->plt_stub_align)
10753 size += plt_stub_pad (htab, stub_entry, off);
10754 if (info->emitrelocations)
10755 {
10756 stub_entry->stub_sec->reloc_count
10757 += ((PPC_HA (off) != 0)
10758 + (htab->opd_abi
10759 ? 2 + (htab->plt_static_chain
10760 && PPC_HA (off + 16) == PPC_HA (off))
10761 : 1));
10762 stub_entry->stub_sec->flags |= SEC_RELOC;
10763 }
10764 }
10765 else
10766 {
10767 /* ppc_stub_long_branch or ppc_stub_plt_branch, or their r2off
10768 variants. */
10769 bfd_vma r2off = 0;
10770 bfd_vma local_off = 0;
10771
10772 off = (stub_entry->target_value
10773 + stub_entry->target_section->output_offset
10774 + stub_entry->target_section->output_section->vma);
10775 off -= (stub_entry->stub_sec->size
10776 + stub_entry->stub_sec->output_offset
10777 + stub_entry->stub_sec->output_section->vma);
10778
10779 /* Reset the stub type from the plt variant in case we now
10780 can reach with a shorter stub. */
10781 if (stub_entry->stub_type >= ppc_stub_plt_branch)
10782 stub_entry->stub_type += ppc_stub_long_branch - ppc_stub_plt_branch;
10783
10784 size = 4;
10785 if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
10786 {
10787 r2off = get_r2off (info, stub_entry);
10788 if (r2off == 0 && htab->opd_abi)
10789 {
10790 htab->stub_error = TRUE;
10791 return FALSE;
10792 }
10793 size = 12;
10794 if (PPC_HA (r2off) != 0)
10795 size = 16;
10796 off -= size - 4;
10797 }
10798
10799 local_off = PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
10800
10801 /* If the branch offset if too big, use a ppc_stub_plt_branch.
10802 Do the same for -R objects without function descriptors. */
10803 if (off + (1 << 25) >= (bfd_vma) (1 << 26) - local_off
10804 || (stub_entry->stub_type == ppc_stub_long_branch_r2off
10805 && r2off == 0))
10806 {
10807 struct ppc_branch_hash_entry *br_entry;
10808
10809 br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
10810 stub_entry->root.string + 9,
10811 TRUE, FALSE);
10812 if (br_entry == NULL)
10813 {
10814 info->callbacks->einfo (_("%P: can't build branch stub `%s'\n"),
10815 stub_entry->root.string);
10816 htab->stub_error = TRUE;
10817 return FALSE;
10818 }
10819
10820 if (br_entry->iter != htab->stub_iteration)
10821 {
10822 br_entry->iter = htab->stub_iteration;
10823 br_entry->offset = htab->brlt->size;
10824 htab->brlt->size += 8;
10825
10826 if (htab->relbrlt != NULL)
10827 htab->relbrlt->size += sizeof (Elf64_External_Rela);
10828 else if (info->emitrelocations)
10829 {
10830 htab->brlt->reloc_count += 1;
10831 htab->brlt->flags |= SEC_RELOC;
10832 }
10833 }
10834
10835 stub_entry->stub_type += ppc_stub_plt_branch - ppc_stub_long_branch;
10836 off = (br_entry->offset
10837 + htab->brlt->output_offset
10838 + htab->brlt->output_section->vma
10839 - elf_gp (htab->brlt->output_section->owner)
10840 - htab->stub_group[stub_entry->id_sec->id].toc_off);
10841
10842 if (info->emitrelocations)
10843 {
10844 stub_entry->stub_sec->reloc_count += 1 + (PPC_HA (off) != 0);
10845 stub_entry->stub_sec->flags |= SEC_RELOC;
10846 }
10847
10848 if (stub_entry->stub_type != ppc_stub_plt_branch_r2off
10849 || !htab->opd_abi)
10850 {
10851 size = 12;
10852 if (PPC_HA (off) != 0)
10853 size = 16;
10854 }
10855 else
10856 {
10857 size = 20;
10858 if (PPC_HA (off) != 0)
10859 size += 4;
10860
10861 if (PPC_HA (r2off) != 0)
10862 size += 4;
10863 }
10864 }
10865 else if (info->emitrelocations)
10866 {
10867 stub_entry->stub_sec->reloc_count += 1;
10868 stub_entry->stub_sec->flags |= SEC_RELOC;
10869 }
10870 }
10871
10872 stub_entry->stub_sec->size += size;
10873 return TRUE;
10874 }
10875
10876 /* Set up various things so that we can make a list of input sections
10877 for each output section included in the link. Returns -1 on error,
10878 0 when no stubs will be needed, and 1 on success. */
10879
10880 int
10881 ppc64_elf_setup_section_lists
10882 (struct bfd_link_info *info,
10883 asection *(*add_stub_section) (const char *, asection *),
10884 void (*layout_sections_again) (void))
10885 {
10886 bfd *input_bfd;
10887 int top_id, top_index, id;
10888 asection *section;
10889 asection **input_list;
10890 bfd_size_type amt;
10891 struct ppc_link_hash_table *htab = ppc_hash_table (info);
10892
10893 if (htab == NULL)
10894 return -1;
10895 /* Stash our params away. */
10896 htab->add_stub_section = add_stub_section;
10897 htab->layout_sections_again = layout_sections_again;
10898
10899 /* Find the top input section id. */
10900 for (input_bfd = info->input_bfds, top_id = 3;
10901 input_bfd != NULL;
10902 input_bfd = input_bfd->link_next)
10903 {
10904 for (section = input_bfd->sections;
10905 section != NULL;
10906 section = section->next)
10907 {
10908 if (top_id < section->id)
10909 top_id = section->id;
10910 }
10911 }
10912
10913 htab->top_id = top_id;
10914 amt = sizeof (struct map_stub) * (top_id + 1);
10915 htab->stub_group = bfd_zmalloc (amt);
10916 if (htab->stub_group == NULL)
10917 return -1;
10918
10919 /* Set toc_off for com, und, abs and ind sections. */
10920 for (id = 0; id < 3; id++)
10921 htab->stub_group[id].toc_off = TOC_BASE_OFF;
10922
10923 /* We can't use output_bfd->section_count here to find the top output
10924 section index as some sections may have been removed, and
10925 strip_excluded_output_sections doesn't renumber the indices. */
10926 for (section = info->output_bfd->sections, top_index = 0;
10927 section != NULL;
10928 section = section->next)
10929 {
10930 if (top_index < section->index)
10931 top_index = section->index;
10932 }
10933
10934 htab->top_index = top_index;
10935 amt = sizeof (asection *) * (top_index + 1);
10936 input_list = bfd_zmalloc (amt);
10937 htab->input_list = input_list;
10938 if (input_list == NULL)
10939 return -1;
10940
10941 return 1;
10942 }
10943
10944 /* Set up for first pass at multitoc partitioning. */
10945
10946 void
10947 ppc64_elf_start_multitoc_partition (struct bfd_link_info *info)
10948 {
10949 struct ppc_link_hash_table *htab = ppc_hash_table (info);
10950
10951 htab->toc_curr = ppc64_elf_set_toc (info, info->output_bfd);
10952 htab->toc_bfd = NULL;
10953 htab->toc_first_sec = NULL;
10954 }
10955
10956 /* The linker repeatedly calls this function for each TOC input section
10957 and linker generated GOT section. Group input bfds such that the toc
10958 within a group is less than 64k in size. */
10959
10960 bfd_boolean
10961 ppc64_elf_next_toc_section (struct bfd_link_info *info, asection *isec)
10962 {
10963 struct ppc_link_hash_table *htab = ppc_hash_table (info);
10964 bfd_vma addr, off, limit;
10965
10966 if (htab == NULL)
10967 return FALSE;
10968
10969 if (!htab->second_toc_pass)
10970 {
10971 /* Keep track of the first .toc or .got section for this input bfd. */
10972 bfd_boolean new_bfd = htab->toc_bfd != isec->owner;
10973
10974 if (new_bfd)
10975 {
10976 htab->toc_bfd = isec->owner;
10977 htab->toc_first_sec = isec;
10978 }
10979
10980 addr = isec->output_offset + isec->output_section->vma;
10981 off = addr - htab->toc_curr;
10982 limit = 0x80008000;
10983 if (ppc64_elf_tdata (isec->owner)->has_small_toc_reloc)
10984 limit = 0x10000;
10985 if (off + isec->size > limit)
10986 {
10987 addr = (htab->toc_first_sec->output_offset
10988 + htab->toc_first_sec->output_section->vma);
10989 htab->toc_curr = addr;
10990 }
10991
10992 /* toc_curr is the base address of this toc group. Set elf_gp
10993 for the input section to be the offset relative to the
10994 output toc base plus 0x8000. Making the input elf_gp an
10995 offset allows us to move the toc as a whole without
10996 recalculating input elf_gp. */
10997 off = htab->toc_curr - elf_gp (isec->output_section->owner);
10998 off += TOC_BASE_OFF;
10999
11000 /* Die if someone uses a linker script that doesn't keep input
11001 file .toc and .got together. */
11002 if (new_bfd
11003 && elf_gp (isec->owner) != 0
11004 && elf_gp (isec->owner) != off)
11005 return FALSE;
11006
11007 elf_gp (isec->owner) = off;
11008 return TRUE;
11009 }
11010
11011 /* During the second pass toc_first_sec points to the start of
11012 a toc group, and toc_curr is used to track the old elf_gp.
11013 We use toc_bfd to ensure we only look at each bfd once. */
11014 if (htab->toc_bfd == isec->owner)
11015 return TRUE;
11016 htab->toc_bfd = isec->owner;
11017
11018 if (htab->toc_first_sec == NULL
11019 || htab->toc_curr != elf_gp (isec->owner))
11020 {
11021 htab->toc_curr = elf_gp (isec->owner);
11022 htab->toc_first_sec = isec;
11023 }
11024 addr = (htab->toc_first_sec->output_offset
11025 + htab->toc_first_sec->output_section->vma);
11026 off = addr - elf_gp (isec->output_section->owner) + TOC_BASE_OFF;
11027 elf_gp (isec->owner) = off;
11028
11029 return TRUE;
11030 }
11031
11032 /* Called via elf_link_hash_traverse to merge GOT entries for global
11033 symbol H. */
11034
11035 static bfd_boolean
11036 merge_global_got (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
11037 {
11038 if (h->root.type == bfd_link_hash_indirect)
11039 return TRUE;
11040
11041 merge_got_entries (&h->got.glist);
11042
11043 return TRUE;
11044 }
11045
11046 /* Called via elf_link_hash_traverse to allocate GOT entries for global
11047 symbol H. */
11048
11049 static bfd_boolean
11050 reallocate_got (struct elf_link_hash_entry *h, void *inf)
11051 {
11052 struct got_entry *gent;
11053
11054 if (h->root.type == bfd_link_hash_indirect)
11055 return TRUE;
11056
11057 for (gent = h->got.glist; gent != NULL; gent = gent->next)
11058 if (!gent->is_indirect)
11059 allocate_got (h, (struct bfd_link_info *) inf, gent);
11060 return TRUE;
11061 }
11062
11063 /* Called on the first multitoc pass after the last call to
11064 ppc64_elf_next_toc_section. This function removes duplicate GOT
11065 entries. */
11066
11067 bfd_boolean
11068 ppc64_elf_layout_multitoc (struct bfd_link_info *info)
11069 {
11070 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11071 struct bfd *ibfd, *ibfd2;
11072 bfd_boolean done_something;
11073
11074 htab->multi_toc_needed = htab->toc_curr != elf_gp (info->output_bfd);
11075
11076 if (!htab->do_multi_toc)
11077 return FALSE;
11078
11079 /* Merge global sym got entries within a toc group. */
11080 elf_link_hash_traverse (&htab->elf, merge_global_got, info);
11081
11082 /* And tlsld_got. */
11083 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
11084 {
11085 struct got_entry *ent, *ent2;
11086
11087 if (!is_ppc64_elf (ibfd))
11088 continue;
11089
11090 ent = ppc64_tlsld_got (ibfd);
11091 if (!ent->is_indirect
11092 && ent->got.offset != (bfd_vma) -1)
11093 {
11094 for (ibfd2 = ibfd->link_next; ibfd2 != NULL; ibfd2 = ibfd2->link_next)
11095 {
11096 if (!is_ppc64_elf (ibfd2))
11097 continue;
11098
11099 ent2 = ppc64_tlsld_got (ibfd2);
11100 if (!ent2->is_indirect
11101 && ent2->got.offset != (bfd_vma) -1
11102 && elf_gp (ibfd2) == elf_gp (ibfd))
11103 {
11104 ent2->is_indirect = TRUE;
11105 ent2->got.ent = ent;
11106 }
11107 }
11108 }
11109 }
11110
11111 /* Zap sizes of got sections. */
11112 htab->reliplt->rawsize = htab->reliplt->size;
11113 htab->reliplt->size -= htab->got_reli_size;
11114 htab->got_reli_size = 0;
11115
11116 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
11117 {
11118 asection *got, *relgot;
11119
11120 if (!is_ppc64_elf (ibfd))
11121 continue;
11122
11123 got = ppc64_elf_tdata (ibfd)->got;
11124 if (got != NULL)
11125 {
11126 got->rawsize = got->size;
11127 got->size = 0;
11128 relgot = ppc64_elf_tdata (ibfd)->relgot;
11129 relgot->rawsize = relgot->size;
11130 relgot->size = 0;
11131 }
11132 }
11133
11134 /* Now reallocate the got, local syms first. We don't need to
11135 allocate section contents again since we never increase size. */
11136 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
11137 {
11138 struct got_entry **lgot_ents;
11139 struct got_entry **end_lgot_ents;
11140 struct plt_entry **local_plt;
11141 struct plt_entry **end_local_plt;
11142 unsigned char *lgot_masks;
11143 bfd_size_type locsymcount;
11144 Elf_Internal_Shdr *symtab_hdr;
11145 asection *s;
11146
11147 if (!is_ppc64_elf (ibfd))
11148 continue;
11149
11150 lgot_ents = elf_local_got_ents (ibfd);
11151 if (!lgot_ents)
11152 continue;
11153
11154 symtab_hdr = &elf_symtab_hdr (ibfd);
11155 locsymcount = symtab_hdr->sh_info;
11156 end_lgot_ents = lgot_ents + locsymcount;
11157 local_plt = (struct plt_entry **) end_lgot_ents;
11158 end_local_plt = local_plt + locsymcount;
11159 lgot_masks = (unsigned char *) end_local_plt;
11160 s = ppc64_elf_tdata (ibfd)->got;
11161 for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
11162 {
11163 struct got_entry *ent;
11164
11165 for (ent = *lgot_ents; ent != NULL; ent = ent->next)
11166 {
11167 unsigned int ent_size = 8;
11168 unsigned int rel_size = sizeof (Elf64_External_Rela);
11169
11170 ent->got.offset = s->size;
11171 if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
11172 {
11173 ent_size *= 2;
11174 rel_size *= 2;
11175 }
11176 s->size += ent_size;
11177 if ((*lgot_masks & PLT_IFUNC) != 0)
11178 {
11179 htab->reliplt->size += rel_size;
11180 htab->got_reli_size += rel_size;
11181 }
11182 else if (info->shared)
11183 {
11184 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
11185 srel->size += rel_size;
11186 }
11187 }
11188 }
11189 }
11190
11191 elf_link_hash_traverse (&htab->elf, reallocate_got, info);
11192
11193 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
11194 {
11195 struct got_entry *ent;
11196
11197 if (!is_ppc64_elf (ibfd))
11198 continue;
11199
11200 ent = ppc64_tlsld_got (ibfd);
11201 if (!ent->is_indirect
11202 && ent->got.offset != (bfd_vma) -1)
11203 {
11204 asection *s = ppc64_elf_tdata (ibfd)->got;
11205 ent->got.offset = s->size;
11206 s->size += 16;
11207 if (info->shared)
11208 {
11209 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
11210 srel->size += sizeof (Elf64_External_Rela);
11211 }
11212 }
11213 }
11214
11215 done_something = htab->reliplt->rawsize != htab->reliplt->size;
11216 if (!done_something)
11217 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
11218 {
11219 asection *got;
11220
11221 if (!is_ppc64_elf (ibfd))
11222 continue;
11223
11224 got = ppc64_elf_tdata (ibfd)->got;
11225 if (got != NULL)
11226 {
11227 done_something = got->rawsize != got->size;
11228 if (done_something)
11229 break;
11230 }
11231 }
11232
11233 if (done_something)
11234 (*htab->layout_sections_again) ();
11235
11236 /* Set up for second pass over toc sections to recalculate elf_gp
11237 on input sections. */
11238 htab->toc_bfd = NULL;
11239 htab->toc_first_sec = NULL;
11240 htab->second_toc_pass = TRUE;
11241 return done_something;
11242 }
11243
11244 /* Called after second pass of multitoc partitioning. */
11245
11246 void
11247 ppc64_elf_finish_multitoc_partition (struct bfd_link_info *info)
11248 {
11249 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11250
11251 /* After the second pass, toc_curr tracks the TOC offset used
11252 for code sections below in ppc64_elf_next_input_section. */
11253 htab->toc_curr = TOC_BASE_OFF;
11254 }
11255
11256 /* No toc references were found in ISEC. If the code in ISEC makes no
11257 calls, then there's no need to use toc adjusting stubs when branching
11258 into ISEC. Actually, indirect calls from ISEC are OK as they will
11259 load r2. Returns -1 on error, 0 for no stub needed, 1 for stub
11260 needed, and 2 if a cyclical call-graph was found but no other reason
11261 for a stub was detected. If called from the top level, a return of
11262 2 means the same as a return of 0. */
11263
11264 static int
11265 toc_adjusting_stub_needed (struct bfd_link_info *info, asection *isec)
11266 {
11267 int ret;
11268
11269 /* Mark this section as checked. */
11270 isec->call_check_done = 1;
11271
11272 /* We know none of our code bearing sections will need toc stubs. */
11273 if ((isec->flags & SEC_LINKER_CREATED) != 0)
11274 return 0;
11275
11276 if (isec->size == 0)
11277 return 0;
11278
11279 if (isec->output_section == NULL)
11280 return 0;
11281
11282 ret = 0;
11283 if (isec->reloc_count != 0)
11284 {
11285 Elf_Internal_Rela *relstart, *rel;
11286 Elf_Internal_Sym *local_syms;
11287 struct ppc_link_hash_table *htab;
11288
11289 relstart = _bfd_elf_link_read_relocs (isec->owner, isec, NULL, NULL,
11290 info->keep_memory);
11291 if (relstart == NULL)
11292 return -1;
11293
11294 /* Look for branches to outside of this section. */
11295 local_syms = NULL;
11296 htab = ppc_hash_table (info);
11297 if (htab == NULL)
11298 return -1;
11299
11300 for (rel = relstart; rel < relstart + isec->reloc_count; ++rel)
11301 {
11302 enum elf_ppc64_reloc_type r_type;
11303 unsigned long r_symndx;
11304 struct elf_link_hash_entry *h;
11305 struct ppc_link_hash_entry *eh;
11306 Elf_Internal_Sym *sym;
11307 asection *sym_sec;
11308 struct _opd_sec_data *opd;
11309 bfd_vma sym_value;
11310 bfd_vma dest;
11311
11312 r_type = ELF64_R_TYPE (rel->r_info);
11313 if (r_type != R_PPC64_REL24
11314 && r_type != R_PPC64_REL14
11315 && r_type != R_PPC64_REL14_BRTAKEN
11316 && r_type != R_PPC64_REL14_BRNTAKEN)
11317 continue;
11318
11319 r_symndx = ELF64_R_SYM (rel->r_info);
11320 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms, r_symndx,
11321 isec->owner))
11322 {
11323 ret = -1;
11324 break;
11325 }
11326
11327 /* Calls to dynamic lib functions go through a plt call stub
11328 that uses r2. */
11329 eh = (struct ppc_link_hash_entry *) h;
11330 if (eh != NULL
11331 && (eh->elf.plt.plist != NULL
11332 || (eh->oh != NULL
11333 && ppc_follow_link (eh->oh)->elf.plt.plist != NULL)))
11334 {
11335 ret = 1;
11336 break;
11337 }
11338
11339 if (sym_sec == NULL)
11340 /* Ignore other undefined symbols. */
11341 continue;
11342
11343 /* Assume branches to other sections not included in the
11344 link need stubs too, to cover -R and absolute syms. */
11345 if (sym_sec->output_section == NULL)
11346 {
11347 ret = 1;
11348 break;
11349 }
11350
11351 if (h == NULL)
11352 sym_value = sym->st_value;
11353 else
11354 {
11355 if (h->root.type != bfd_link_hash_defined
11356 && h->root.type != bfd_link_hash_defweak)
11357 abort ();
11358 sym_value = h->root.u.def.value;
11359 }
11360 sym_value += rel->r_addend;
11361
11362 /* If this branch reloc uses an opd sym, find the code section. */
11363 opd = get_opd_info (sym_sec);
11364 if (opd != NULL)
11365 {
11366 if (h == NULL && opd->adjust != NULL)
11367 {
11368 long adjust;
11369
11370 adjust = opd->adjust[sym->st_value / 8];
11371 if (adjust == -1)
11372 /* Assume deleted functions won't ever be called. */
11373 continue;
11374 sym_value += adjust;
11375 }
11376
11377 dest = opd_entry_value (sym_sec, sym_value,
11378 &sym_sec, NULL, FALSE);
11379 if (dest == (bfd_vma) -1)
11380 continue;
11381 }
11382 else
11383 dest = (sym_value
11384 + sym_sec->output_offset
11385 + sym_sec->output_section->vma);
11386
11387 /* Ignore branch to self. */
11388 if (sym_sec == isec)
11389 continue;
11390
11391 /* If the called function uses the toc, we need a stub. */
11392 if (sym_sec->has_toc_reloc
11393 || sym_sec->makes_toc_func_call)
11394 {
11395 ret = 1;
11396 break;
11397 }
11398
11399 /* Assume any branch that needs a long branch stub might in fact
11400 need a plt_branch stub. A plt_branch stub uses r2. */
11401 else if (dest - (isec->output_offset
11402 + isec->output_section->vma
11403 + rel->r_offset) + (1 << 25)
11404 >= (2u << 25) - PPC64_LOCAL_ENTRY_OFFSET (h
11405 ? h->other
11406 : sym->st_other))
11407 {
11408 ret = 1;
11409 break;
11410 }
11411
11412 /* If calling back to a section in the process of being
11413 tested, we can't say for sure that no toc adjusting stubs
11414 are needed, so don't return zero. */
11415 else if (sym_sec->call_check_in_progress)
11416 ret = 2;
11417
11418 /* Branches to another section that itself doesn't have any TOC
11419 references are OK. Recursively call ourselves to check. */
11420 else if (!sym_sec->call_check_done)
11421 {
11422 int recur;
11423
11424 /* Mark current section as indeterminate, so that other
11425 sections that call back to current won't be marked as
11426 known. */
11427 isec->call_check_in_progress = 1;
11428 recur = toc_adjusting_stub_needed (info, sym_sec);
11429 isec->call_check_in_progress = 0;
11430
11431 if (recur != 0)
11432 {
11433 ret = recur;
11434 if (recur != 2)
11435 break;
11436 }
11437 }
11438 }
11439
11440 if (local_syms != NULL
11441 && (elf_symtab_hdr (isec->owner).contents
11442 != (unsigned char *) local_syms))
11443 free (local_syms);
11444 if (elf_section_data (isec)->relocs != relstart)
11445 free (relstart);
11446 }
11447
11448 if ((ret & 1) == 0
11449 && isec->map_head.s != NULL
11450 && (strcmp (isec->output_section->name, ".init") == 0
11451 || strcmp (isec->output_section->name, ".fini") == 0))
11452 {
11453 if (isec->map_head.s->has_toc_reloc
11454 || isec->map_head.s->makes_toc_func_call)
11455 ret = 1;
11456 else if (!isec->map_head.s->call_check_done)
11457 {
11458 int recur;
11459 isec->call_check_in_progress = 1;
11460 recur = toc_adjusting_stub_needed (info, isec->map_head.s);
11461 isec->call_check_in_progress = 0;
11462 if (recur != 0)
11463 ret = recur;
11464 }
11465 }
11466
11467 if (ret == 1)
11468 isec->makes_toc_func_call = 1;
11469
11470 return ret;
11471 }
11472
11473 /* The linker repeatedly calls this function for each input section,
11474 in the order that input sections are linked into output sections.
11475 Build lists of input sections to determine groupings between which
11476 we may insert linker stubs. */
11477
11478 bfd_boolean
11479 ppc64_elf_next_input_section (struct bfd_link_info *info, asection *isec)
11480 {
11481 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11482
11483 if (htab == NULL)
11484 return FALSE;
11485
11486 if ((isec->output_section->flags & SEC_CODE) != 0
11487 && isec->output_section->index <= htab->top_index)
11488 {
11489 asection **list = htab->input_list + isec->output_section->index;
11490 /* Steal the link_sec pointer for our list. */
11491 #define PREV_SEC(sec) (htab->stub_group[(sec)->id].link_sec)
11492 /* This happens to make the list in reverse order,
11493 which is what we want. */
11494 PREV_SEC (isec) = *list;
11495 *list = isec;
11496 }
11497
11498 if (htab->multi_toc_needed)
11499 {
11500 /* If a code section has a function that uses the TOC then we need
11501 to use the right TOC (obviously). Also, make sure that .opd gets
11502 the correct TOC value for R_PPC64_TOC relocs that don't have or
11503 can't find their function symbol (shouldn't ever happen now).
11504 Also specially treat .fixup for the linux kernel. .fixup
11505 contains branches, but only back to the function that hit an
11506 exception. */
11507 if (isec->has_toc_reloc
11508 || (isec->flags & SEC_CODE) == 0
11509 || strcmp (isec->name, ".fixup") == 0)
11510 {
11511 if (elf_gp (isec->owner) != 0)
11512 htab->toc_curr = elf_gp (isec->owner);
11513 }
11514 else
11515 {
11516 if (!isec->call_check_done
11517 && toc_adjusting_stub_needed (info, isec) < 0)
11518 return FALSE;
11519 /* If we make a local call from this section, ie. a branch
11520 without a following nop, then we have no place to put a
11521 toc restoring insn. We must use the same toc group as
11522 the callee.
11523 Testing makes_toc_func_call actually tests for *any*
11524 calls to functions that need a good toc pointer. A more
11525 precise test would be better, as this one will set
11526 incorrect values for pasted .init/.fini fragments.
11527 (Fixed later in check_pasted_section.) */
11528 if (isec->makes_toc_func_call
11529 && elf_gp (isec->owner) != 0)
11530 htab->toc_curr = elf_gp (isec->owner);
11531 }
11532 }
11533
11534 /* Functions that don't use the TOC can belong in any TOC group.
11535 Use the last TOC base. */
11536 htab->stub_group[isec->id].toc_off = htab->toc_curr;
11537 return TRUE;
11538 }
11539
11540 /* Check that all .init and .fini sections use the same toc, if they
11541 have toc relocs. */
11542
11543 static bfd_boolean
11544 check_pasted_section (struct bfd_link_info *info, const char *name)
11545 {
11546 asection *o = bfd_get_section_by_name (info->output_bfd, name);
11547
11548 if (o != NULL)
11549 {
11550 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11551 bfd_vma toc_off = 0;
11552 asection *i;
11553
11554 for (i = o->map_head.s; i != NULL; i = i->map_head.s)
11555 if (i->has_toc_reloc)
11556 {
11557 if (toc_off == 0)
11558 toc_off = htab->stub_group[i->id].toc_off;
11559 else if (toc_off != htab->stub_group[i->id].toc_off)
11560 return FALSE;
11561 }
11562
11563 if (toc_off == 0)
11564 for (i = o->map_head.s; i != NULL; i = i->map_head.s)
11565 if (i->makes_toc_func_call)
11566 {
11567 toc_off = htab->stub_group[i->id].toc_off;
11568 break;
11569 }
11570
11571 /* Make sure the whole pasted function uses the same toc offset. */
11572 if (toc_off != 0)
11573 for (i = o->map_head.s; i != NULL; i = i->map_head.s)
11574 htab->stub_group[i->id].toc_off = toc_off;
11575 }
11576 return TRUE;
11577 }
11578
11579 bfd_boolean
11580 ppc64_elf_check_init_fini (struct bfd_link_info *info)
11581 {
11582 return (check_pasted_section (info, ".init")
11583 & check_pasted_section (info, ".fini"));
11584 }
11585
11586 /* See whether we can group stub sections together. Grouping stub
11587 sections may result in fewer stubs. More importantly, we need to
11588 put all .init* and .fini* stubs at the beginning of the .init or
11589 .fini output sections respectively, because glibc splits the
11590 _init and _fini functions into multiple parts. Putting a stub in
11591 the middle of a function is not a good idea. */
11592
11593 static void
11594 group_sections (struct ppc_link_hash_table *htab,
11595 bfd_size_type stub_group_size,
11596 bfd_boolean stubs_always_before_branch)
11597 {
11598 asection **list;
11599 bfd_size_type stub14_group_size;
11600 bfd_boolean suppress_size_errors;
11601
11602 suppress_size_errors = FALSE;
11603 stub14_group_size = stub_group_size;
11604 if (stub_group_size == 1)
11605 {
11606 /* Default values. */
11607 if (stubs_always_before_branch)
11608 {
11609 stub_group_size = 0x1e00000;
11610 stub14_group_size = 0x7800;
11611 }
11612 else
11613 {
11614 stub_group_size = 0x1c00000;
11615 stub14_group_size = 0x7000;
11616 }
11617 suppress_size_errors = TRUE;
11618 }
11619
11620 list = htab->input_list + htab->top_index;
11621 do
11622 {
11623 asection *tail = *list;
11624 while (tail != NULL)
11625 {
11626 asection *curr;
11627 asection *prev;
11628 bfd_size_type total;
11629 bfd_boolean big_sec;
11630 bfd_vma curr_toc;
11631
11632 curr = tail;
11633 total = tail->size;
11634 big_sec = total > (ppc64_elf_section_data (tail) != NULL
11635 && ppc64_elf_section_data (tail)->has_14bit_branch
11636 ? stub14_group_size : stub_group_size);
11637 if (big_sec && !suppress_size_errors)
11638 (*_bfd_error_handler) (_("%B section %A exceeds stub group size"),
11639 tail->owner, tail);
11640 curr_toc = htab->stub_group[tail->id].toc_off;
11641
11642 while ((prev = PREV_SEC (curr)) != NULL
11643 && ((total += curr->output_offset - prev->output_offset)
11644 < (ppc64_elf_section_data (prev) != NULL
11645 && ppc64_elf_section_data (prev)->has_14bit_branch
11646 ? stub14_group_size : stub_group_size))
11647 && htab->stub_group[prev->id].toc_off == curr_toc)
11648 curr = prev;
11649
11650 /* OK, the size from the start of CURR to the end is less
11651 than stub_group_size and thus can be handled by one stub
11652 section. (or the tail section is itself larger than
11653 stub_group_size, in which case we may be toast.) We
11654 should really be keeping track of the total size of stubs
11655 added here, as stubs contribute to the final output
11656 section size. That's a little tricky, and this way will
11657 only break if stubs added make the total size more than
11658 2^25, ie. for the default stub_group_size, if stubs total
11659 more than 2097152 bytes, or nearly 75000 plt call stubs. */
11660 do
11661 {
11662 prev = PREV_SEC (tail);
11663 /* Set up this stub group. */
11664 htab->stub_group[tail->id].link_sec = curr;
11665 }
11666 while (tail != curr && (tail = prev) != NULL);
11667
11668 /* But wait, there's more! Input sections up to stub_group_size
11669 bytes before the stub section can be handled by it too.
11670 Don't do this if we have a really large section after the
11671 stubs, as adding more stubs increases the chance that
11672 branches may not reach into the stub section. */
11673 if (!stubs_always_before_branch && !big_sec)
11674 {
11675 total = 0;
11676 while (prev != NULL
11677 && ((total += tail->output_offset - prev->output_offset)
11678 < (ppc64_elf_section_data (prev) != NULL
11679 && ppc64_elf_section_data (prev)->has_14bit_branch
11680 ? stub14_group_size : stub_group_size))
11681 && htab->stub_group[prev->id].toc_off == curr_toc)
11682 {
11683 tail = prev;
11684 prev = PREV_SEC (tail);
11685 htab->stub_group[tail->id].link_sec = curr;
11686 }
11687 }
11688 tail = prev;
11689 }
11690 }
11691 while (list-- != htab->input_list);
11692 free (htab->input_list);
11693 #undef PREV_SEC
11694 }
11695
11696 static const unsigned char glink_eh_frame_cie[] =
11697 {
11698 0, 0, 0, 16, /* length. */
11699 0, 0, 0, 0, /* id. */
11700 1, /* CIE version. */
11701 'z', 'R', 0, /* Augmentation string. */
11702 4, /* Code alignment. */
11703 0x78, /* Data alignment. */
11704 65, /* RA reg. */
11705 1, /* Augmentation size. */
11706 DW_EH_PE_pcrel | DW_EH_PE_sdata4, /* FDE encoding. */
11707 DW_CFA_def_cfa, 1, 0 /* def_cfa: r1 offset 0. */
11708 };
11709
11710 /* Stripping output sections is normally done before dynamic section
11711 symbols have been allocated. This function is called later, and
11712 handles cases like htab->brlt which is mapped to its own output
11713 section. */
11714
11715 static void
11716 maybe_strip_output (struct bfd_link_info *info, asection *isec)
11717 {
11718 if (isec->size == 0
11719 && isec->output_section->size == 0
11720 && !(isec->output_section->flags & SEC_KEEP)
11721 && !bfd_section_removed_from_list (info->output_bfd,
11722 isec->output_section)
11723 && elf_section_data (isec->output_section)->dynindx == 0)
11724 {
11725 isec->output_section->flags |= SEC_EXCLUDE;
11726 bfd_section_list_remove (info->output_bfd, isec->output_section);
11727 info->output_bfd->section_count--;
11728 }
11729 }
11730
11731 /* Determine and set the size of the stub section for a final link.
11732
11733 The basic idea here is to examine all the relocations looking for
11734 PC-relative calls to a target that is unreachable with a "bl"
11735 instruction. */
11736
11737 bfd_boolean
11738 ppc64_elf_size_stubs (struct bfd_link_info *info, bfd_signed_vma group_size,
11739 bfd_boolean plt_static_chain, int plt_thread_safe,
11740 int plt_stub_align)
11741 {
11742 bfd_size_type stub_group_size;
11743 bfd_boolean stubs_always_before_branch;
11744 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11745
11746 if (htab == NULL)
11747 return FALSE;
11748
11749 htab->plt_static_chain = plt_static_chain;
11750 htab->plt_stub_align = plt_stub_align;
11751 if (plt_thread_safe == -1 && !info->executable)
11752 plt_thread_safe = 1;
11753 if (!htab->opd_abi)
11754 plt_thread_safe = 0;
11755 else if (plt_thread_safe == -1)
11756 {
11757 static const char *const thread_starter[] =
11758 {
11759 "pthread_create",
11760 /* libstdc++ */
11761 "_ZNSt6thread15_M_start_threadESt10shared_ptrINS_10_Impl_baseEE",
11762 /* librt */
11763 "aio_init", "aio_read", "aio_write", "aio_fsync", "lio_listio",
11764 "mq_notify", "create_timer",
11765 /* libanl */
11766 "getaddrinfo_a",
11767 /* libgomp */
11768 "GOMP_parallel_start",
11769 "GOMP_parallel_loop_static_start",
11770 "GOMP_parallel_loop_dynamic_start",
11771 "GOMP_parallel_loop_guided_start",
11772 "GOMP_parallel_loop_runtime_start",
11773 "GOMP_parallel_sections_start",
11774 };
11775 unsigned i;
11776
11777 for (i = 0; i < sizeof (thread_starter)/ sizeof (thread_starter[0]); i++)
11778 {
11779 struct elf_link_hash_entry *h;
11780 h = elf_link_hash_lookup (&htab->elf, thread_starter[i],
11781 FALSE, FALSE, TRUE);
11782 plt_thread_safe = h != NULL && h->ref_regular;
11783 if (plt_thread_safe)
11784 break;
11785 }
11786 }
11787 htab->plt_thread_safe = plt_thread_safe;
11788 stubs_always_before_branch = group_size < 0;
11789 if (group_size < 0)
11790 stub_group_size = -group_size;
11791 else
11792 stub_group_size = group_size;
11793
11794 group_sections (htab, stub_group_size, stubs_always_before_branch);
11795
11796 while (1)
11797 {
11798 bfd *input_bfd;
11799 unsigned int bfd_indx;
11800 asection *stub_sec;
11801
11802 htab->stub_iteration += 1;
11803
11804 for (input_bfd = info->input_bfds, bfd_indx = 0;
11805 input_bfd != NULL;
11806 input_bfd = input_bfd->link_next, bfd_indx++)
11807 {
11808 Elf_Internal_Shdr *symtab_hdr;
11809 asection *section;
11810 Elf_Internal_Sym *local_syms = NULL;
11811
11812 if (!is_ppc64_elf (input_bfd))
11813 continue;
11814
11815 /* We'll need the symbol table in a second. */
11816 symtab_hdr = &elf_symtab_hdr (input_bfd);
11817 if (symtab_hdr->sh_info == 0)
11818 continue;
11819
11820 /* Walk over each section attached to the input bfd. */
11821 for (section = input_bfd->sections;
11822 section != NULL;
11823 section = section->next)
11824 {
11825 Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
11826
11827 /* If there aren't any relocs, then there's nothing more
11828 to do. */
11829 if ((section->flags & SEC_RELOC) == 0
11830 || (section->flags & SEC_ALLOC) == 0
11831 || (section->flags & SEC_LOAD) == 0
11832 || (section->flags & SEC_CODE) == 0
11833 || section->reloc_count == 0)
11834 continue;
11835
11836 /* If this section is a link-once section that will be
11837 discarded, then don't create any stubs. */
11838 if (section->output_section == NULL
11839 || section->output_section->owner != info->output_bfd)
11840 continue;
11841
11842 /* Get the relocs. */
11843 internal_relocs
11844 = _bfd_elf_link_read_relocs (input_bfd, section, NULL, NULL,
11845 info->keep_memory);
11846 if (internal_relocs == NULL)
11847 goto error_ret_free_local;
11848
11849 /* Now examine each relocation. */
11850 irela = internal_relocs;
11851 irelaend = irela + section->reloc_count;
11852 for (; irela < irelaend; irela++)
11853 {
11854 enum elf_ppc64_reloc_type r_type;
11855 unsigned int r_indx;
11856 enum ppc_stub_type stub_type;
11857 struct ppc_stub_hash_entry *stub_entry;
11858 asection *sym_sec, *code_sec;
11859 bfd_vma sym_value, code_value;
11860 bfd_vma destination;
11861 unsigned long local_off;
11862 bfd_boolean ok_dest;
11863 struct ppc_link_hash_entry *hash;
11864 struct ppc_link_hash_entry *fdh;
11865 struct elf_link_hash_entry *h;
11866 Elf_Internal_Sym *sym;
11867 char *stub_name;
11868 const asection *id_sec;
11869 struct _opd_sec_data *opd;
11870 struct plt_entry *plt_ent;
11871
11872 r_type = ELF64_R_TYPE (irela->r_info);
11873 r_indx = ELF64_R_SYM (irela->r_info);
11874
11875 if (r_type >= R_PPC64_max)
11876 {
11877 bfd_set_error (bfd_error_bad_value);
11878 goto error_ret_free_internal;
11879 }
11880
11881 /* Only look for stubs on branch instructions. */
11882 if (r_type != R_PPC64_REL24
11883 && r_type != R_PPC64_REL14
11884 && r_type != R_PPC64_REL14_BRTAKEN
11885 && r_type != R_PPC64_REL14_BRNTAKEN)
11886 continue;
11887
11888 /* Now determine the call target, its name, value,
11889 section. */
11890 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
11891 r_indx, input_bfd))
11892 goto error_ret_free_internal;
11893 hash = (struct ppc_link_hash_entry *) h;
11894
11895 ok_dest = FALSE;
11896 fdh = NULL;
11897 sym_value = 0;
11898 if (hash == NULL)
11899 {
11900 sym_value = sym->st_value;
11901 ok_dest = TRUE;
11902 }
11903 else if (hash->elf.root.type == bfd_link_hash_defined
11904 || hash->elf.root.type == bfd_link_hash_defweak)
11905 {
11906 sym_value = hash->elf.root.u.def.value;
11907 if (sym_sec->output_section != NULL)
11908 ok_dest = TRUE;
11909 }
11910 else if (hash->elf.root.type == bfd_link_hash_undefweak
11911 || hash->elf.root.type == bfd_link_hash_undefined)
11912 {
11913 /* Recognise an old ABI func code entry sym, and
11914 use the func descriptor sym instead if it is
11915 defined. */
11916 if (hash->elf.root.root.string[0] == '.'
11917 && (fdh = lookup_fdh (hash, htab)) != NULL)
11918 {
11919 if (fdh->elf.root.type == bfd_link_hash_defined
11920 || fdh->elf.root.type == bfd_link_hash_defweak)
11921 {
11922 sym_sec = fdh->elf.root.u.def.section;
11923 sym_value = fdh->elf.root.u.def.value;
11924 if (sym_sec->output_section != NULL)
11925 ok_dest = TRUE;
11926 }
11927 else
11928 fdh = NULL;
11929 }
11930 }
11931 else
11932 {
11933 bfd_set_error (bfd_error_bad_value);
11934 goto error_ret_free_internal;
11935 }
11936
11937 destination = 0;
11938 local_off = 0;
11939 if (ok_dest)
11940 {
11941 sym_value += irela->r_addend;
11942 destination = (sym_value
11943 + sym_sec->output_offset
11944 + sym_sec->output_section->vma);
11945 local_off = PPC64_LOCAL_ENTRY_OFFSET (hash
11946 ? hash->elf.other
11947 : sym->st_other);
11948 }
11949
11950 code_sec = sym_sec;
11951 code_value = sym_value;
11952 opd = get_opd_info (sym_sec);
11953 if (opd != NULL)
11954 {
11955 bfd_vma dest;
11956
11957 if (hash == NULL && opd->adjust != NULL)
11958 {
11959 long adjust = opd->adjust[sym_value / 8];
11960 if (adjust == -1)
11961 continue;
11962 code_value += adjust;
11963 sym_value += adjust;
11964 }
11965 dest = opd_entry_value (sym_sec, sym_value,
11966 &code_sec, &code_value, FALSE);
11967 if (dest != (bfd_vma) -1)
11968 {
11969 destination = dest;
11970 if (fdh != NULL)
11971 {
11972 /* Fixup old ABI sym to point at code
11973 entry. */
11974 hash->elf.root.type = bfd_link_hash_defweak;
11975 hash->elf.root.u.def.section = code_sec;
11976 hash->elf.root.u.def.value = code_value;
11977 }
11978 }
11979 }
11980
11981 /* Determine what (if any) linker stub is needed. */
11982 plt_ent = NULL;
11983 stub_type = ppc_type_of_stub (section, irela, &hash,
11984 &plt_ent, destination,
11985 local_off);
11986
11987 if (stub_type != ppc_stub_plt_call)
11988 {
11989 /* Check whether we need a TOC adjusting stub.
11990 Since the linker pastes together pieces from
11991 different object files when creating the
11992 _init and _fini functions, it may be that a
11993 call to what looks like a local sym is in
11994 fact a call needing a TOC adjustment. */
11995 if (code_sec != NULL
11996 && code_sec->output_section != NULL
11997 && (htab->stub_group[code_sec->id].toc_off
11998 != htab->stub_group[section->id].toc_off)
11999 && (code_sec->has_toc_reloc
12000 || code_sec->makes_toc_func_call))
12001 stub_type = ppc_stub_long_branch_r2off;
12002 }
12003
12004 if (stub_type == ppc_stub_none)
12005 continue;
12006
12007 /* __tls_get_addr calls might be eliminated. */
12008 if (stub_type != ppc_stub_plt_call
12009 && hash != NULL
12010 && (hash == htab->tls_get_addr
12011 || hash == htab->tls_get_addr_fd)
12012 && section->has_tls_reloc
12013 && irela != internal_relocs)
12014 {
12015 /* Get tls info. */
12016 unsigned char *tls_mask;
12017
12018 if (!get_tls_mask (&tls_mask, NULL, NULL, &local_syms,
12019 irela - 1, input_bfd))
12020 goto error_ret_free_internal;
12021 if (*tls_mask != 0)
12022 continue;
12023 }
12024
12025 if (stub_type == ppc_stub_plt_call
12026 && irela + 1 < irelaend
12027 && irela[1].r_offset == irela->r_offset + 4
12028 && ELF64_R_TYPE (irela[1].r_info) == R_PPC64_TOCSAVE)
12029 {
12030 if (!tocsave_find (htab, INSERT,
12031 &local_syms, irela + 1, input_bfd))
12032 goto error_ret_free_internal;
12033 }
12034 else if (stub_type == ppc_stub_plt_call)
12035 stub_type = ppc_stub_plt_call_r2save;
12036
12037 /* Support for grouping stub sections. */
12038 id_sec = htab->stub_group[section->id].link_sec;
12039
12040 /* Get the name of this stub. */
12041 stub_name = ppc_stub_name (id_sec, sym_sec, hash, irela);
12042 if (!stub_name)
12043 goto error_ret_free_internal;
12044
12045 stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
12046 stub_name, FALSE, FALSE);
12047 if (stub_entry != NULL)
12048 {
12049 /* The proper stub has already been created. */
12050 free (stub_name);
12051 if (stub_type == ppc_stub_plt_call_r2save)
12052 stub_entry->stub_type = stub_type;
12053 continue;
12054 }
12055
12056 stub_entry = ppc_add_stub (stub_name, section, info);
12057 if (stub_entry == NULL)
12058 {
12059 free (stub_name);
12060 error_ret_free_internal:
12061 if (elf_section_data (section)->relocs == NULL)
12062 free (internal_relocs);
12063 error_ret_free_local:
12064 if (local_syms != NULL
12065 && (symtab_hdr->contents
12066 != (unsigned char *) local_syms))
12067 free (local_syms);
12068 return FALSE;
12069 }
12070
12071 stub_entry->stub_type = stub_type;
12072 if (stub_type != ppc_stub_plt_call
12073 && stub_type != ppc_stub_plt_call_r2save)
12074 {
12075 stub_entry->target_value = code_value;
12076 stub_entry->target_section = code_sec;
12077 }
12078 else
12079 {
12080 stub_entry->target_value = sym_value;
12081 stub_entry->target_section = sym_sec;
12082 }
12083 stub_entry->h = hash;
12084 stub_entry->plt_ent = plt_ent;
12085 stub_entry->other = hash ? hash->elf.other : sym->st_other;
12086
12087 if (stub_entry->h != NULL)
12088 htab->stub_globals += 1;
12089 }
12090
12091 /* We're done with the internal relocs, free them. */
12092 if (elf_section_data (section)->relocs != internal_relocs)
12093 free (internal_relocs);
12094 }
12095
12096 if (local_syms != NULL
12097 && symtab_hdr->contents != (unsigned char *) local_syms)
12098 {
12099 if (!info->keep_memory)
12100 free (local_syms);
12101 else
12102 symtab_hdr->contents = (unsigned char *) local_syms;
12103 }
12104 }
12105
12106 /* We may have added some stubs. Find out the new size of the
12107 stub sections. */
12108 for (stub_sec = htab->stub_bfd->sections;
12109 stub_sec != NULL;
12110 stub_sec = stub_sec->next)
12111 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12112 {
12113 stub_sec->rawsize = stub_sec->size;
12114 stub_sec->size = 0;
12115 stub_sec->reloc_count = 0;
12116 stub_sec->flags &= ~SEC_RELOC;
12117 }
12118
12119 htab->brlt->size = 0;
12120 htab->brlt->reloc_count = 0;
12121 htab->brlt->flags &= ~SEC_RELOC;
12122 if (htab->relbrlt != NULL)
12123 htab->relbrlt->size = 0;
12124
12125 bfd_hash_traverse (&htab->stub_hash_table, ppc_size_one_stub, info);
12126
12127 if (info->emitrelocations
12128 && htab->glink != NULL && htab->glink->size != 0)
12129 {
12130 htab->glink->reloc_count = 1;
12131 htab->glink->flags |= SEC_RELOC;
12132 }
12133
12134 if (htab->glink_eh_frame != NULL
12135 && !bfd_is_abs_section (htab->glink_eh_frame->output_section)
12136 && htab->glink_eh_frame->output_section->size != 0)
12137 {
12138 size_t size = 0, align;
12139
12140 for (stub_sec = htab->stub_bfd->sections;
12141 stub_sec != NULL;
12142 stub_sec = stub_sec->next)
12143 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12144 size += 20;
12145 if (htab->glink != NULL && htab->glink->size != 0)
12146 size += 24;
12147 if (size != 0)
12148 size += sizeof (glink_eh_frame_cie);
12149 align = 1;
12150 align <<= htab->glink_eh_frame->output_section->alignment_power;
12151 align -= 1;
12152 size = (size + align) & ~align;
12153 htab->glink_eh_frame->rawsize = htab->glink_eh_frame->size;
12154 htab->glink_eh_frame->size = size;
12155 }
12156
12157 if (htab->plt_stub_align != 0)
12158 for (stub_sec = htab->stub_bfd->sections;
12159 stub_sec != NULL;
12160 stub_sec = stub_sec->next)
12161 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12162 stub_sec->size = ((stub_sec->size + (1 << htab->plt_stub_align) - 1)
12163 & (-1 << htab->plt_stub_align));
12164
12165 for (stub_sec = htab->stub_bfd->sections;
12166 stub_sec != NULL;
12167 stub_sec = stub_sec->next)
12168 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
12169 && stub_sec->rawsize != stub_sec->size)
12170 break;
12171
12172 /* Exit from this loop when no stubs have been added, and no stubs
12173 have changed size. */
12174 if (stub_sec == NULL
12175 && (htab->glink_eh_frame == NULL
12176 || htab->glink_eh_frame->rawsize == htab->glink_eh_frame->size))
12177 break;
12178
12179 /* Ask the linker to do its stuff. */
12180 (*htab->layout_sections_again) ();
12181 }
12182
12183 maybe_strip_output (info, htab->brlt);
12184 if (htab->glink_eh_frame != NULL)
12185 maybe_strip_output (info, htab->glink_eh_frame);
12186
12187 return TRUE;
12188 }
12189
12190 /* Called after we have determined section placement. If sections
12191 move, we'll be called again. Provide a value for TOCstart. */
12192
12193 bfd_vma
12194 ppc64_elf_set_toc (struct bfd_link_info *info, bfd *obfd)
12195 {
12196 asection *s;
12197 bfd_vma TOCstart;
12198
12199 /* The TOC consists of sections .got, .toc, .tocbss, .plt in that
12200 order. The TOC starts where the first of these sections starts. */
12201 s = bfd_get_section_by_name (obfd, ".got");
12202 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12203 s = bfd_get_section_by_name (obfd, ".toc");
12204 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12205 s = bfd_get_section_by_name (obfd, ".tocbss");
12206 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12207 s = bfd_get_section_by_name (obfd, ".plt");
12208 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12209 {
12210 /* This may happen for
12211 o references to TOC base (SYM@toc / TOC[tc0]) without a
12212 .toc directive
12213 o bad linker script
12214 o --gc-sections and empty TOC sections
12215
12216 FIXME: Warn user? */
12217
12218 /* Look for a likely section. We probably won't even be
12219 using TOCstart. */
12220 for (s = obfd->sections; s != NULL; s = s->next)
12221 if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_READONLY
12222 | SEC_EXCLUDE))
12223 == (SEC_ALLOC | SEC_SMALL_DATA))
12224 break;
12225 if (s == NULL)
12226 for (s = obfd->sections; s != NULL; s = s->next)
12227 if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_EXCLUDE))
12228 == (SEC_ALLOC | SEC_SMALL_DATA))
12229 break;
12230 if (s == NULL)
12231 for (s = obfd->sections; s != NULL; s = s->next)
12232 if ((s->flags & (SEC_ALLOC | SEC_READONLY | SEC_EXCLUDE))
12233 == SEC_ALLOC)
12234 break;
12235 if (s == NULL)
12236 for (s = obfd->sections; s != NULL; s = s->next)
12237 if ((s->flags & (SEC_ALLOC | SEC_EXCLUDE)) == SEC_ALLOC)
12238 break;
12239 }
12240
12241 TOCstart = 0;
12242 if (s != NULL)
12243 TOCstart = s->output_section->vma + s->output_offset;
12244
12245 _bfd_set_gp_value (obfd, TOCstart);
12246
12247 if (info != NULL && s != NULL && is_ppc64_elf (obfd))
12248 {
12249 struct ppc_link_hash_table *htab = ppc_hash_table (info);
12250
12251 if (htab != NULL
12252 && htab->elf.hgot != NULL)
12253 {
12254 htab->elf.hgot->type = STT_OBJECT;
12255 htab->elf.hgot->root.type = bfd_link_hash_defined;
12256 htab->elf.hgot->root.u.def.value = TOC_BASE_OFF;
12257 htab->elf.hgot->root.u.def.section = s;
12258 }
12259 }
12260 return TOCstart;
12261 }
12262
12263 /* Build all the stubs associated with the current output file.
12264 The stubs are kept in a hash table attached to the main linker
12265 hash table. This function is called via gldelf64ppc_finish. */
12266
12267 bfd_boolean
12268 ppc64_elf_build_stubs (bfd_boolean emit_stub_syms,
12269 struct bfd_link_info *info,
12270 char **stats)
12271 {
12272 struct ppc_link_hash_table *htab = ppc_hash_table (info);
12273 asection *stub_sec;
12274 bfd_byte *p;
12275 int stub_sec_count = 0;
12276
12277 if (htab == NULL)
12278 return FALSE;
12279
12280 htab->emit_stub_syms = emit_stub_syms;
12281
12282 /* Allocate memory to hold the linker stubs. */
12283 for (stub_sec = htab->stub_bfd->sections;
12284 stub_sec != NULL;
12285 stub_sec = stub_sec->next)
12286 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
12287 && stub_sec->size != 0)
12288 {
12289 stub_sec->contents = bfd_zalloc (htab->stub_bfd, stub_sec->size);
12290 if (stub_sec->contents == NULL)
12291 return FALSE;
12292 /* We want to check that built size is the same as calculated
12293 size. rawsize is a convenient location to use. */
12294 stub_sec->rawsize = stub_sec->size;
12295 stub_sec->size = 0;
12296 }
12297
12298 if (htab->glink != NULL && htab->glink->size != 0)
12299 {
12300 unsigned int indx;
12301 bfd_vma plt0;
12302
12303 /* Build the .glink plt call stub. */
12304 if (htab->emit_stub_syms)
12305 {
12306 struct elf_link_hash_entry *h;
12307 h = elf_link_hash_lookup (&htab->elf, "__glink_PLTresolve",
12308 TRUE, FALSE, FALSE);
12309 if (h == NULL)
12310 return FALSE;
12311 if (h->root.type == bfd_link_hash_new)
12312 {
12313 h->root.type = bfd_link_hash_defined;
12314 h->root.u.def.section = htab->glink;
12315 h->root.u.def.value = 8;
12316 h->ref_regular = 1;
12317 h->def_regular = 1;
12318 h->ref_regular_nonweak = 1;
12319 h->forced_local = 1;
12320 h->non_elf = 0;
12321 }
12322 }
12323 plt0 = htab->plt->output_section->vma + htab->plt->output_offset - 16;
12324 if (info->emitrelocations)
12325 {
12326 Elf_Internal_Rela *r = get_relocs (htab->glink, 1);
12327 if (r == NULL)
12328 return FALSE;
12329 r->r_offset = (htab->glink->output_offset
12330 + htab->glink->output_section->vma);
12331 r->r_info = ELF64_R_INFO (0, R_PPC64_REL64);
12332 r->r_addend = plt0;
12333 }
12334 p = htab->glink->contents;
12335 plt0 -= htab->glink->output_section->vma + htab->glink->output_offset;
12336 bfd_put_64 (htab->glink->owner, plt0, p);
12337 p += 8;
12338 if (htab->opd_abi)
12339 {
12340 bfd_put_32 (htab->glink->owner, MFLR_R12, p);
12341 p += 4;
12342 bfd_put_32 (htab->glink->owner, BCL_20_31, p);
12343 p += 4;
12344 bfd_put_32 (htab->glink->owner, MFLR_R11, p);
12345 p += 4;
12346 bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
12347 p += 4;
12348 bfd_put_32 (htab->glink->owner, MTLR_R12, p);
12349 p += 4;
12350 bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
12351 p += 4;
12352 bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
12353 p += 4;
12354 bfd_put_32 (htab->glink->owner, LD_R2_0R11 | 8, p);
12355 p += 4;
12356 bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
12357 p += 4;
12358 bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 16, p);
12359 p += 4;
12360 }
12361 else
12362 {
12363 bfd_put_32 (htab->glink->owner, MFLR_R0, p);
12364 p += 4;
12365 bfd_put_32 (htab->glink->owner, BCL_20_31, p);
12366 p += 4;
12367 bfd_put_32 (htab->glink->owner, MFLR_R11, p);
12368 p += 4;
12369 bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
12370 p += 4;
12371 bfd_put_32 (htab->glink->owner, MTLR_R0, p);
12372 p += 4;
12373 bfd_put_32 (htab->glink->owner, SUB_R12_R12_R11, p);
12374 p += 4;
12375 bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
12376 p += 4;
12377 bfd_put_32 (htab->glink->owner, ADDI_R0_R12 | (-48 & 0xffff), p);
12378 p += 4;
12379 bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
12380 p += 4;
12381 bfd_put_32 (htab->glink->owner, SRDI_R0_R0_2, p);
12382 p += 4;
12383 bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
12384 p += 4;
12385 bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 8, p);
12386 p += 4;
12387 }
12388 bfd_put_32 (htab->glink->owner, BCTR, p);
12389 p += 4;
12390 while (p - htab->glink->contents < GLINK_CALL_STUB_SIZE)
12391 {
12392 bfd_put_32 (htab->glink->owner, NOP, p);
12393 p += 4;
12394 }
12395
12396 /* Build the .glink lazy link call stubs. */
12397 indx = 0;
12398 while (p < htab->glink->contents + htab->glink->size)
12399 {
12400 if (htab->opd_abi)
12401 {
12402 if (indx < 0x8000)
12403 {
12404 bfd_put_32 (htab->glink->owner, LI_R0_0 | indx, p);
12405 p += 4;
12406 }
12407 else
12408 {
12409 bfd_put_32 (htab->glink->owner, LIS_R0_0 | PPC_HI (indx), p);
12410 p += 4;
12411 bfd_put_32 (htab->glink->owner, ORI_R0_R0_0 | PPC_LO (indx),
12412 p);
12413 p += 4;
12414 }
12415 }
12416 bfd_put_32 (htab->glink->owner,
12417 B_DOT | ((htab->glink->contents - p + 8) & 0x3fffffc), p);
12418 indx++;
12419 p += 4;
12420 }
12421 htab->glink->rawsize = p - htab->glink->contents;
12422 }
12423
12424 if (htab->brlt->size != 0)
12425 {
12426 htab->brlt->contents = bfd_zalloc (htab->brlt->owner,
12427 htab->brlt->size);
12428 if (htab->brlt->contents == NULL)
12429 return FALSE;
12430 }
12431 if (htab->relbrlt != NULL && htab->relbrlt->size != 0)
12432 {
12433 htab->relbrlt->contents = bfd_zalloc (htab->relbrlt->owner,
12434 htab->relbrlt->size);
12435 if (htab->relbrlt->contents == NULL)
12436 return FALSE;
12437 }
12438
12439 if (htab->glink_eh_frame != NULL
12440 && htab->glink_eh_frame->size != 0)
12441 {
12442 bfd_vma val;
12443 bfd_byte *last_fde;
12444 size_t last_fde_len, size, align, pad;
12445
12446 p = bfd_zalloc (htab->glink_eh_frame->owner, htab->glink_eh_frame->size);
12447 if (p == NULL)
12448 return FALSE;
12449 htab->glink_eh_frame->contents = p;
12450 last_fde = p;
12451
12452 htab->glink_eh_frame->rawsize = htab->glink_eh_frame->size;
12453
12454 memcpy (p, glink_eh_frame_cie, sizeof (glink_eh_frame_cie));
12455 /* CIE length (rewrite in case little-endian). */
12456 last_fde_len = sizeof (glink_eh_frame_cie) - 4;
12457 bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
12458 p += sizeof (glink_eh_frame_cie);
12459
12460 for (stub_sec = htab->stub_bfd->sections;
12461 stub_sec != NULL;
12462 stub_sec = stub_sec->next)
12463 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12464 {
12465 last_fde = p;
12466 last_fde_len = 16;
12467 /* FDE length. */
12468 bfd_put_32 (htab->elf.dynobj, 16, p);
12469 p += 4;
12470 /* CIE pointer. */
12471 val = p - htab->glink_eh_frame->contents;
12472 bfd_put_32 (htab->elf.dynobj, val, p);
12473 p += 4;
12474 /* Offset to stub section. */
12475 val = (stub_sec->output_section->vma
12476 + stub_sec->output_offset);
12477 val -= (htab->glink_eh_frame->output_section->vma
12478 + htab->glink_eh_frame->output_offset);
12479 val -= p - htab->glink_eh_frame->contents;
12480 if (val + 0x80000000 > 0xffffffff)
12481 {
12482 info->callbacks->einfo
12483 (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
12484 stub_sec->name);
12485 return FALSE;
12486 }
12487 bfd_put_32 (htab->elf.dynobj, val, p);
12488 p += 4;
12489 /* stub section size. */
12490 bfd_put_32 (htab->elf.dynobj, stub_sec->rawsize, p);
12491 p += 4;
12492 /* Augmentation. */
12493 p += 1;
12494 /* Pad. */
12495 p += 3;
12496 }
12497 if (htab->glink != NULL && htab->glink->size != 0)
12498 {
12499 last_fde = p;
12500 last_fde_len = 20;
12501 /* FDE length. */
12502 bfd_put_32 (htab->elf.dynobj, 20, p);
12503 p += 4;
12504 /* CIE pointer. */
12505 val = p - htab->glink_eh_frame->contents;
12506 bfd_put_32 (htab->elf.dynobj, val, p);
12507 p += 4;
12508 /* Offset to .glink. */
12509 val = (htab->glink->output_section->vma
12510 + htab->glink->output_offset
12511 + 8);
12512 val -= (htab->glink_eh_frame->output_section->vma
12513 + htab->glink_eh_frame->output_offset);
12514 val -= p - htab->glink_eh_frame->contents;
12515 if (val + 0x80000000 > 0xffffffff)
12516 {
12517 info->callbacks->einfo
12518 (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
12519 htab->glink->name);
12520 return FALSE;
12521 }
12522 bfd_put_32 (htab->elf.dynobj, val, p);
12523 p += 4;
12524 /* .glink size. */
12525 bfd_put_32 (htab->elf.dynobj, htab->glink->rawsize - 8, p);
12526 p += 4;
12527 /* Augmentation. */
12528 p += 1;
12529
12530 *p++ = DW_CFA_advance_loc + 1;
12531 *p++ = DW_CFA_register;
12532 *p++ = 65;
12533 *p++ = 12;
12534 *p++ = DW_CFA_advance_loc + 4;
12535 *p++ = DW_CFA_restore_extended;
12536 *p++ = 65;
12537 }
12538 /* Subsume any padding into the last FDE if user .eh_frame
12539 sections are aligned more than glink_eh_frame. Otherwise any
12540 zero padding will be seen as a terminator. */
12541 size = p - htab->glink_eh_frame->contents;
12542 align = 1;
12543 align <<= htab->glink_eh_frame->output_section->alignment_power;
12544 align -= 1;
12545 pad = ((size + align) & ~align) - size;
12546 htab->glink_eh_frame->size = size + pad;
12547 bfd_put_32 (htab->elf.dynobj, last_fde_len + pad, last_fde);
12548 }
12549
12550 /* Build the stubs as directed by the stub hash table. */
12551 bfd_hash_traverse (&htab->stub_hash_table, ppc_build_one_stub, info);
12552
12553 if (htab->relbrlt != NULL)
12554 htab->relbrlt->reloc_count = 0;
12555
12556 if (htab->plt_stub_align != 0)
12557 for (stub_sec = htab->stub_bfd->sections;
12558 stub_sec != NULL;
12559 stub_sec = stub_sec->next)
12560 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12561 stub_sec->size = ((stub_sec->size + (1 << htab->plt_stub_align) - 1)
12562 & (-1 << htab->plt_stub_align));
12563
12564 for (stub_sec = htab->stub_bfd->sections;
12565 stub_sec != NULL;
12566 stub_sec = stub_sec->next)
12567 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12568 {
12569 stub_sec_count += 1;
12570 if (stub_sec->rawsize != stub_sec->size)
12571 break;
12572 }
12573
12574 if (stub_sec != NULL
12575 || htab->glink->rawsize != htab->glink->size
12576 || (htab->glink_eh_frame != NULL
12577 && htab->glink_eh_frame->rawsize != htab->glink_eh_frame->size))
12578 {
12579 htab->stub_error = TRUE;
12580 info->callbacks->einfo (_("%P: stubs don't match calculated size\n"));
12581 }
12582
12583 if (htab->stub_error)
12584 return FALSE;
12585
12586 if (stats != NULL)
12587 {
12588 *stats = bfd_malloc (500);
12589 if (*stats == NULL)
12590 return FALSE;
12591
12592 sprintf (*stats, _("linker stubs in %u group%s\n"
12593 " branch %lu\n"
12594 " toc adjust %lu\n"
12595 " long branch %lu\n"
12596 " long toc adj %lu\n"
12597 " plt call %lu\n"
12598 " plt call toc %lu"),
12599 stub_sec_count,
12600 stub_sec_count == 1 ? "" : "s",
12601 htab->stub_count[ppc_stub_long_branch - 1],
12602 htab->stub_count[ppc_stub_long_branch_r2off - 1],
12603 htab->stub_count[ppc_stub_plt_branch - 1],
12604 htab->stub_count[ppc_stub_plt_branch_r2off - 1],
12605 htab->stub_count[ppc_stub_plt_call - 1],
12606 htab->stub_count[ppc_stub_plt_call_r2save - 1]);
12607 }
12608 return TRUE;
12609 }
12610
12611 /* This function undoes the changes made by add_symbol_adjust. */
12612
12613 static bfd_boolean
12614 undo_symbol_twiddle (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
12615 {
12616 struct ppc_link_hash_entry *eh;
12617
12618 if (h->root.type == bfd_link_hash_indirect)
12619 return TRUE;
12620
12621 eh = (struct ppc_link_hash_entry *) h;
12622 if (eh->elf.root.type != bfd_link_hash_undefweak || !eh->was_undefined)
12623 return TRUE;
12624
12625 eh->elf.root.type = bfd_link_hash_undefined;
12626 return TRUE;
12627 }
12628
12629 void
12630 ppc64_elf_restore_symbols (struct bfd_link_info *info)
12631 {
12632 struct ppc_link_hash_table *htab = ppc_hash_table (info);
12633
12634 if (htab != NULL)
12635 elf_link_hash_traverse (&htab->elf, undo_symbol_twiddle, info);
12636 }
12637
12638 /* What to do when ld finds relocations against symbols defined in
12639 discarded sections. */
12640
12641 static unsigned int
12642 ppc64_elf_action_discarded (asection *sec)
12643 {
12644 if (strcmp (".opd", sec->name) == 0)
12645 return 0;
12646
12647 if (strcmp (".toc", sec->name) == 0)
12648 return 0;
12649
12650 if (strcmp (".toc1", sec->name) == 0)
12651 return 0;
12652
12653 return _bfd_elf_default_action_discarded (sec);
12654 }
12655
12656 /* The RELOCATE_SECTION function is called by the ELF backend linker
12657 to handle the relocations for a section.
12658
12659 The relocs are always passed as Rela structures; if the section
12660 actually uses Rel structures, the r_addend field will always be
12661 zero.
12662
12663 This function is responsible for adjust the section contents as
12664 necessary, and (if using Rela relocs and generating a
12665 relocatable output file) adjusting the reloc addend as
12666 necessary.
12667
12668 This function does not have to worry about setting the reloc
12669 address or the reloc symbol index.
12670
12671 LOCAL_SYMS is a pointer to the swapped in local symbols.
12672
12673 LOCAL_SECTIONS is an array giving the section in the input file
12674 corresponding to the st_shndx field of each local symbol.
12675
12676 The global hash table entry for the global symbols can be found
12677 via elf_sym_hashes (input_bfd).
12678
12679 When generating relocatable output, this function must handle
12680 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
12681 going to be the section symbol corresponding to the output
12682 section, which means that the addend must be adjusted
12683 accordingly. */
12684
12685 static bfd_boolean
12686 ppc64_elf_relocate_section (bfd *output_bfd,
12687 struct bfd_link_info *info,
12688 bfd *input_bfd,
12689 asection *input_section,
12690 bfd_byte *contents,
12691 Elf_Internal_Rela *relocs,
12692 Elf_Internal_Sym *local_syms,
12693 asection **local_sections)
12694 {
12695 struct ppc_link_hash_table *htab;
12696 Elf_Internal_Shdr *symtab_hdr;
12697 struct elf_link_hash_entry **sym_hashes;
12698 Elf_Internal_Rela *rel;
12699 Elf_Internal_Rela *relend;
12700 Elf_Internal_Rela outrel;
12701 bfd_byte *loc;
12702 struct got_entry **local_got_ents;
12703 bfd_vma TOCstart;
12704 bfd_boolean ret = TRUE;
12705 bfd_boolean is_opd;
12706 /* Assume 'at' branch hints. */
12707 bfd_boolean is_isa_v2 = TRUE;
12708 bfd_vma d_offset = (bfd_big_endian (output_bfd) ? 2 : 0);
12709
12710 /* Initialize howto table if needed. */
12711 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
12712 ppc_howto_init ();
12713
12714 htab = ppc_hash_table (info);
12715 if (htab == NULL)
12716 return FALSE;
12717
12718 /* Don't relocate stub sections. */
12719 if (input_section->owner == htab->stub_bfd)
12720 return TRUE;
12721
12722 BFD_ASSERT (is_ppc64_elf (input_bfd));
12723
12724 local_got_ents = elf_local_got_ents (input_bfd);
12725 TOCstart = elf_gp (output_bfd);
12726 symtab_hdr = &elf_symtab_hdr (input_bfd);
12727 sym_hashes = elf_sym_hashes (input_bfd);
12728 is_opd = ppc64_elf_section_data (input_section)->sec_type == sec_opd;
12729
12730 rel = relocs;
12731 relend = relocs + input_section->reloc_count;
12732 for (; rel < relend; rel++)
12733 {
12734 enum elf_ppc64_reloc_type r_type;
12735 bfd_vma addend;
12736 bfd_reloc_status_type r;
12737 Elf_Internal_Sym *sym;
12738 asection *sec;
12739 struct elf_link_hash_entry *h_elf;
12740 struct ppc_link_hash_entry *h;
12741 struct ppc_link_hash_entry *fdh;
12742 const char *sym_name;
12743 unsigned long r_symndx, toc_symndx;
12744 bfd_vma toc_addend;
12745 unsigned char tls_mask, tls_gd, tls_type;
12746 unsigned char sym_type;
12747 bfd_vma relocation;
12748 bfd_boolean unresolved_reloc;
12749 bfd_boolean warned;
12750 enum { DEST_NORMAL, DEST_OPD, DEST_STUB } reloc_dest;
12751 unsigned int insn;
12752 unsigned int mask;
12753 struct ppc_stub_hash_entry *stub_entry;
12754 bfd_vma max_br_offset;
12755 bfd_vma from;
12756 const Elf_Internal_Rela orig_rel = *rel;
12757
12758 r_type = ELF64_R_TYPE (rel->r_info);
12759 r_symndx = ELF64_R_SYM (rel->r_info);
12760
12761 /* For old style R_PPC64_TOC relocs with a zero symbol, use the
12762 symbol of the previous ADDR64 reloc. The symbol gives us the
12763 proper TOC base to use. */
12764 if (rel->r_info == ELF64_R_INFO (0, R_PPC64_TOC)
12765 && rel != relocs
12766 && ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_ADDR64
12767 && is_opd)
12768 r_symndx = ELF64_R_SYM (rel[-1].r_info);
12769
12770 sym = NULL;
12771 sec = NULL;
12772 h_elf = NULL;
12773 sym_name = NULL;
12774 unresolved_reloc = FALSE;
12775 warned = FALSE;
12776
12777 if (r_symndx < symtab_hdr->sh_info)
12778 {
12779 /* It's a local symbol. */
12780 struct _opd_sec_data *opd;
12781
12782 sym = local_syms + r_symndx;
12783 sec = local_sections[r_symndx];
12784 sym_name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym, sec);
12785 sym_type = ELF64_ST_TYPE (sym->st_info);
12786 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
12787 opd = get_opd_info (sec);
12788 if (opd != NULL && opd->adjust != NULL)
12789 {
12790 long adjust = opd->adjust[(sym->st_value + rel->r_addend) / 8];
12791 if (adjust == -1)
12792 relocation = 0;
12793 else
12794 {
12795 /* If this is a relocation against the opd section sym
12796 and we have edited .opd, adjust the reloc addend so
12797 that ld -r and ld --emit-relocs output is correct.
12798 If it is a reloc against some other .opd symbol,
12799 then the symbol value will be adjusted later. */
12800 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
12801 rel->r_addend += adjust;
12802 else
12803 relocation += adjust;
12804 }
12805 }
12806 }
12807 else
12808 {
12809 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
12810 r_symndx, symtab_hdr, sym_hashes,
12811 h_elf, sec, relocation,
12812 unresolved_reloc, warned);
12813 sym_name = h_elf->root.root.string;
12814 sym_type = h_elf->type;
12815 if (sec != NULL
12816 && sec->owner == output_bfd
12817 && strcmp (sec->name, ".opd") == 0)
12818 {
12819 /* This is a symbol defined in a linker script. All
12820 such are defined in output sections, even those
12821 defined by simple assignment from a symbol defined in
12822 an input section. Transfer the symbol to an
12823 appropriate input .opd section, so that a branch to
12824 this symbol will be mapped to the location specified
12825 by the opd entry. */
12826 struct bfd_link_order *lo;
12827 for (lo = sec->map_head.link_order; lo != NULL; lo = lo->next)
12828 if (lo->type == bfd_indirect_link_order)
12829 {
12830 asection *isec = lo->u.indirect.section;
12831 if (h_elf->root.u.def.value >= isec->output_offset
12832 && h_elf->root.u.def.value < (isec->output_offset
12833 + isec->size))
12834 {
12835 h_elf->root.u.def.value -= isec->output_offset;
12836 h_elf->root.u.def.section = isec;
12837 sec = isec;
12838 break;
12839 }
12840 }
12841 }
12842 }
12843 h = (struct ppc_link_hash_entry *) h_elf;
12844
12845 if (sec != NULL && discarded_section (sec))
12846 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
12847 rel, 1, relend,
12848 ppc64_elf_howto_table[r_type], 0,
12849 contents);
12850
12851 if (info->relocatable)
12852 continue;
12853
12854 if (h != NULL && &h->elf == htab->elf.hgot)
12855 {
12856 relocation = (TOCstart
12857 + htab->stub_group[input_section->id].toc_off);
12858 sec = bfd_abs_section_ptr;
12859 unresolved_reloc = FALSE;
12860 }
12861
12862 /* TLS optimizations. Replace instruction sequences and relocs
12863 based on information we collected in tls_optimize. We edit
12864 RELOCS so that --emit-relocs will output something sensible
12865 for the final instruction stream. */
12866 tls_mask = 0;
12867 tls_gd = 0;
12868 toc_symndx = 0;
12869 if (h != NULL)
12870 tls_mask = h->tls_mask;
12871 else if (local_got_ents != NULL)
12872 {
12873 struct plt_entry **local_plt = (struct plt_entry **)
12874 (local_got_ents + symtab_hdr->sh_info);
12875 unsigned char *lgot_masks = (unsigned char *)
12876 (local_plt + symtab_hdr->sh_info);
12877 tls_mask = lgot_masks[r_symndx];
12878 }
12879 if (tls_mask == 0
12880 && (r_type == R_PPC64_TLS
12881 || r_type == R_PPC64_TLSGD
12882 || r_type == R_PPC64_TLSLD))
12883 {
12884 /* Check for toc tls entries. */
12885 unsigned char *toc_tls;
12886
12887 if (!get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
12888 &local_syms, rel, input_bfd))
12889 return FALSE;
12890
12891 if (toc_tls)
12892 tls_mask = *toc_tls;
12893 }
12894
12895 /* Check that tls relocs are used with tls syms, and non-tls
12896 relocs are used with non-tls syms. */
12897 if (r_symndx != STN_UNDEF
12898 && r_type != R_PPC64_NONE
12899 && (h == NULL
12900 || h->elf.root.type == bfd_link_hash_defined
12901 || h->elf.root.type == bfd_link_hash_defweak)
12902 && (IS_PPC64_TLS_RELOC (r_type)
12903 != (sym_type == STT_TLS
12904 || (sym_type == STT_SECTION
12905 && (sec->flags & SEC_THREAD_LOCAL) != 0))))
12906 {
12907 if (tls_mask != 0
12908 && (r_type == R_PPC64_TLS
12909 || r_type == R_PPC64_TLSGD
12910 || r_type == R_PPC64_TLSLD))
12911 /* R_PPC64_TLS is OK against a symbol in the TOC. */
12912 ;
12913 else
12914 info->callbacks->einfo
12915 (!IS_PPC64_TLS_RELOC (r_type)
12916 ? _("%P: %H: %s used with TLS symbol `%T'\n")
12917 : _("%P: %H: %s used with non-TLS symbol `%T'\n"),
12918 input_bfd, input_section, rel->r_offset,
12919 ppc64_elf_howto_table[r_type]->name,
12920 sym_name);
12921 }
12922
12923 /* Ensure reloc mapping code below stays sane. */
12924 if (R_PPC64_TOC16_LO_DS != R_PPC64_TOC16_DS + 1
12925 || R_PPC64_TOC16_LO != R_PPC64_TOC16 + 1
12926 || (R_PPC64_GOT_TLSLD16 & 3) != (R_PPC64_GOT_TLSGD16 & 3)
12927 || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TLSGD16_LO & 3)
12928 || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TLSGD16_HI & 3)
12929 || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TLSGD16_HA & 3)
12930 || (R_PPC64_GOT_TLSLD16 & 3) != (R_PPC64_GOT_TPREL16_DS & 3)
12931 || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TPREL16_LO_DS & 3)
12932 || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TPREL16_HI & 3)
12933 || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TPREL16_HA & 3))
12934 abort ();
12935
12936 switch (r_type)
12937 {
12938 default:
12939 break;
12940
12941 case R_PPC64_LO_DS_OPT:
12942 insn = bfd_get_32 (output_bfd, contents + rel->r_offset - d_offset);
12943 if ((insn & (0x3f << 26)) != 58u << 26)
12944 abort ();
12945 insn += (14u << 26) - (58u << 26);
12946 bfd_put_32 (output_bfd, insn, contents + rel->r_offset - d_offset);
12947 r_type = R_PPC64_TOC16_LO;
12948 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
12949 break;
12950
12951 case R_PPC64_TOC16:
12952 case R_PPC64_TOC16_LO:
12953 case R_PPC64_TOC16_DS:
12954 case R_PPC64_TOC16_LO_DS:
12955 {
12956 /* Check for toc tls entries. */
12957 unsigned char *toc_tls;
12958 int retval;
12959
12960 retval = get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
12961 &local_syms, rel, input_bfd);
12962 if (retval == 0)
12963 return FALSE;
12964
12965 if (toc_tls)
12966 {
12967 tls_mask = *toc_tls;
12968 if (r_type == R_PPC64_TOC16_DS
12969 || r_type == R_PPC64_TOC16_LO_DS)
12970 {
12971 if (tls_mask != 0
12972 && (tls_mask & (TLS_DTPREL | TLS_TPREL)) == 0)
12973 goto toctprel;
12974 }
12975 else
12976 {
12977 /* If we found a GD reloc pair, then we might be
12978 doing a GD->IE transition. */
12979 if (retval == 2)
12980 {
12981 tls_gd = TLS_TPRELGD;
12982 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
12983 goto tls_ldgd_opt;
12984 }
12985 else if (retval == 3)
12986 {
12987 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
12988 goto tls_ldgd_opt;
12989 }
12990 }
12991 }
12992 }
12993 break;
12994
12995 case R_PPC64_GOT_TPREL16_HI:
12996 case R_PPC64_GOT_TPREL16_HA:
12997 if (tls_mask != 0
12998 && (tls_mask & TLS_TPREL) == 0)
12999 {
13000 rel->r_offset -= d_offset;
13001 bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
13002 r_type = R_PPC64_NONE;
13003 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13004 }
13005 break;
13006
13007 case R_PPC64_GOT_TPREL16_DS:
13008 case R_PPC64_GOT_TPREL16_LO_DS:
13009 if (tls_mask != 0
13010 && (tls_mask & TLS_TPREL) == 0)
13011 {
13012 toctprel:
13013 insn = bfd_get_32 (output_bfd, contents + rel->r_offset - d_offset);
13014 insn &= 31 << 21;
13015 insn |= 0x3c0d0000; /* addis 0,13,0 */
13016 bfd_put_32 (output_bfd, insn, contents + rel->r_offset - d_offset);
13017 r_type = R_PPC64_TPREL16_HA;
13018 if (toc_symndx != 0)
13019 {
13020 rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
13021 rel->r_addend = toc_addend;
13022 /* We changed the symbol. Start over in order to
13023 get h, sym, sec etc. right. */
13024 rel--;
13025 continue;
13026 }
13027 else
13028 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13029 }
13030 break;
13031
13032 case R_PPC64_TLS:
13033 if (tls_mask != 0
13034 && (tls_mask & TLS_TPREL) == 0)
13035 {
13036 insn = bfd_get_32 (output_bfd, contents + rel->r_offset);
13037 insn = _bfd_elf_ppc_at_tls_transform (insn, 13);
13038 if (insn == 0)
13039 abort ();
13040 bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
13041 /* Was PPC64_TLS which sits on insn boundary, now
13042 PPC64_TPREL16_LO which is at low-order half-word. */
13043 rel->r_offset += d_offset;
13044 r_type = R_PPC64_TPREL16_LO;
13045 if (toc_symndx != 0)
13046 {
13047 rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
13048 rel->r_addend = toc_addend;
13049 /* We changed the symbol. Start over in order to
13050 get h, sym, sec etc. right. */
13051 rel--;
13052 continue;
13053 }
13054 else
13055 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13056 }
13057 break;
13058
13059 case R_PPC64_GOT_TLSGD16_HI:
13060 case R_PPC64_GOT_TLSGD16_HA:
13061 tls_gd = TLS_TPRELGD;
13062 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13063 goto tls_gdld_hi;
13064 break;
13065
13066 case R_PPC64_GOT_TLSLD16_HI:
13067 case R_PPC64_GOT_TLSLD16_HA:
13068 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13069 {
13070 tls_gdld_hi:
13071 if ((tls_mask & tls_gd) != 0)
13072 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
13073 + R_PPC64_GOT_TPREL16_DS);
13074 else
13075 {
13076 rel->r_offset -= d_offset;
13077 bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
13078 r_type = R_PPC64_NONE;
13079 }
13080 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13081 }
13082 break;
13083
13084 case R_PPC64_GOT_TLSGD16:
13085 case R_PPC64_GOT_TLSGD16_LO:
13086 tls_gd = TLS_TPRELGD;
13087 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13088 goto tls_ldgd_opt;
13089 break;
13090
13091 case R_PPC64_GOT_TLSLD16:
13092 case R_PPC64_GOT_TLSLD16_LO:
13093 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13094 {
13095 unsigned int insn1, insn2, insn3;
13096 bfd_vma offset;
13097
13098 tls_ldgd_opt:
13099 offset = (bfd_vma) -1;
13100 /* If not using the newer R_PPC64_TLSGD/LD to mark
13101 __tls_get_addr calls, we must trust that the call
13102 stays with its arg setup insns, ie. that the next
13103 reloc is the __tls_get_addr call associated with
13104 the current reloc. Edit both insns. */
13105 if (input_section->has_tls_get_addr_call
13106 && rel + 1 < relend
13107 && branch_reloc_hash_match (input_bfd, rel + 1,
13108 htab->tls_get_addr,
13109 htab->tls_get_addr_fd))
13110 offset = rel[1].r_offset;
13111 if ((tls_mask & tls_gd) != 0)
13112 {
13113 /* IE */
13114 insn1 = bfd_get_32 (output_bfd,
13115 contents + rel->r_offset - d_offset);
13116 insn1 &= (1 << 26) - (1 << 2);
13117 insn1 |= 58 << 26; /* ld */
13118 insn2 = 0x7c636a14; /* add 3,3,13 */
13119 if (offset != (bfd_vma) -1)
13120 rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13121 if ((tls_mask & TLS_EXPLICIT) == 0)
13122 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
13123 + R_PPC64_GOT_TPREL16_DS);
13124 else
13125 r_type += R_PPC64_TOC16_DS - R_PPC64_TOC16;
13126 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13127 }
13128 else
13129 {
13130 /* LE */
13131 insn1 = 0x3c6d0000; /* addis 3,13,0 */
13132 insn2 = 0x38630000; /* addi 3,3,0 */
13133 if (tls_gd == 0)
13134 {
13135 /* Was an LD reloc. */
13136 if (toc_symndx)
13137 sec = local_sections[toc_symndx];
13138 for (r_symndx = 0;
13139 r_symndx < symtab_hdr->sh_info;
13140 r_symndx++)
13141 if (local_sections[r_symndx] == sec)
13142 break;
13143 if (r_symndx >= symtab_hdr->sh_info)
13144 r_symndx = STN_UNDEF;
13145 rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
13146 if (r_symndx != STN_UNDEF)
13147 rel->r_addend -= (local_syms[r_symndx].st_value
13148 + sec->output_offset
13149 + sec->output_section->vma);
13150 }
13151 else if (toc_symndx != 0)
13152 {
13153 r_symndx = toc_symndx;
13154 rel->r_addend = toc_addend;
13155 }
13156 r_type = R_PPC64_TPREL16_HA;
13157 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13158 if (offset != (bfd_vma) -1)
13159 {
13160 rel[1].r_info = ELF64_R_INFO (r_symndx,
13161 R_PPC64_TPREL16_LO);
13162 rel[1].r_offset = offset + d_offset;
13163 rel[1].r_addend = rel->r_addend;
13164 }
13165 }
13166 bfd_put_32 (output_bfd, insn1,
13167 contents + rel->r_offset - d_offset);
13168 if (offset != (bfd_vma) -1)
13169 {
13170 insn3 = bfd_get_32 (output_bfd,
13171 contents + offset + 4);
13172 if (insn3 == NOP
13173 || insn3 == CROR_151515 || insn3 == CROR_313131)
13174 {
13175 rel[1].r_offset += 4;
13176 bfd_put_32 (output_bfd, insn2, contents + offset + 4);
13177 insn2 = NOP;
13178 }
13179 bfd_put_32 (output_bfd, insn2, contents + offset);
13180 }
13181 if ((tls_mask & tls_gd) == 0
13182 && (tls_gd == 0 || toc_symndx != 0))
13183 {
13184 /* We changed the symbol. Start over in order
13185 to get h, sym, sec etc. right. */
13186 rel--;
13187 continue;
13188 }
13189 }
13190 break;
13191
13192 case R_PPC64_TLSGD:
13193 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13194 {
13195 unsigned int insn2, insn3;
13196 bfd_vma offset = rel->r_offset;
13197
13198 if ((tls_mask & TLS_TPRELGD) != 0)
13199 {
13200 /* IE */
13201 r_type = R_PPC64_NONE;
13202 insn2 = 0x7c636a14; /* add 3,3,13 */
13203 }
13204 else
13205 {
13206 /* LE */
13207 if (toc_symndx != 0)
13208 {
13209 r_symndx = toc_symndx;
13210 rel->r_addend = toc_addend;
13211 }
13212 r_type = R_PPC64_TPREL16_LO;
13213 rel->r_offset = offset + d_offset;
13214 insn2 = 0x38630000; /* addi 3,3,0 */
13215 }
13216 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13217 /* Zap the reloc on the _tls_get_addr call too. */
13218 BFD_ASSERT (offset == rel[1].r_offset);
13219 rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13220 insn3 = bfd_get_32 (output_bfd,
13221 contents + offset + 4);
13222 if (insn3 == NOP
13223 || insn3 == CROR_151515 || insn3 == CROR_313131)
13224 {
13225 rel->r_offset += 4;
13226 bfd_put_32 (output_bfd, insn2, contents + offset + 4);
13227 insn2 = NOP;
13228 }
13229 bfd_put_32 (output_bfd, insn2, contents + offset);
13230 if ((tls_mask & TLS_TPRELGD) == 0 && toc_symndx != 0)
13231 {
13232 rel--;
13233 continue;
13234 }
13235 }
13236 break;
13237
13238 case R_PPC64_TLSLD:
13239 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13240 {
13241 unsigned int insn2, insn3;
13242 bfd_vma offset = rel->r_offset;
13243
13244 if (toc_symndx)
13245 sec = local_sections[toc_symndx];
13246 for (r_symndx = 0;
13247 r_symndx < symtab_hdr->sh_info;
13248 r_symndx++)
13249 if (local_sections[r_symndx] == sec)
13250 break;
13251 if (r_symndx >= symtab_hdr->sh_info)
13252 r_symndx = STN_UNDEF;
13253 rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
13254 if (r_symndx != STN_UNDEF)
13255 rel->r_addend -= (local_syms[r_symndx].st_value
13256 + sec->output_offset
13257 + sec->output_section->vma);
13258
13259 r_type = R_PPC64_TPREL16_LO;
13260 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13261 rel->r_offset = offset + d_offset;
13262 /* Zap the reloc on the _tls_get_addr call too. */
13263 BFD_ASSERT (offset == rel[1].r_offset);
13264 rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13265 insn2 = 0x38630000; /* addi 3,3,0 */
13266 insn3 = bfd_get_32 (output_bfd,
13267 contents + offset + 4);
13268 if (insn3 == NOP
13269 || insn3 == CROR_151515 || insn3 == CROR_313131)
13270 {
13271 rel->r_offset += 4;
13272 bfd_put_32 (output_bfd, insn2, contents + offset + 4);
13273 insn2 = NOP;
13274 }
13275 bfd_put_32 (output_bfd, insn2, contents + offset);
13276 rel--;
13277 continue;
13278 }
13279 break;
13280
13281 case R_PPC64_DTPMOD64:
13282 if (rel + 1 < relend
13283 && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
13284 && rel[1].r_offset == rel->r_offset + 8)
13285 {
13286 if ((tls_mask & TLS_GD) == 0)
13287 {
13288 rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_NONE);
13289 if ((tls_mask & TLS_TPRELGD) != 0)
13290 r_type = R_PPC64_TPREL64;
13291 else
13292 {
13293 bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
13294 r_type = R_PPC64_NONE;
13295 }
13296 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13297 }
13298 }
13299 else
13300 {
13301 if ((tls_mask & TLS_LD) == 0)
13302 {
13303 bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
13304 r_type = R_PPC64_NONE;
13305 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13306 }
13307 }
13308 break;
13309
13310 case R_PPC64_TPREL64:
13311 if ((tls_mask & TLS_TPREL) == 0)
13312 {
13313 r_type = R_PPC64_NONE;
13314 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13315 }
13316 break;
13317 }
13318
13319 /* Handle other relocations that tweak non-addend part of insn. */
13320 insn = 0;
13321 max_br_offset = 1 << 25;
13322 addend = rel->r_addend;
13323 reloc_dest = DEST_NORMAL;
13324 switch (r_type)
13325 {
13326 default:
13327 break;
13328
13329 case R_PPC64_TOCSAVE:
13330 if (relocation + addend == (rel->r_offset
13331 + input_section->output_offset
13332 + input_section->output_section->vma)
13333 && tocsave_find (htab, NO_INSERT,
13334 &local_syms, rel, input_bfd))
13335 {
13336 insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
13337 if (insn == NOP
13338 || insn == CROR_151515 || insn == CROR_313131)
13339 bfd_put_32 (input_bfd, STD_R2_40R1,
13340 contents + rel->r_offset);
13341 }
13342 break;
13343
13344 /* Branch taken prediction relocations. */
13345 case R_PPC64_ADDR14_BRTAKEN:
13346 case R_PPC64_REL14_BRTAKEN:
13347 insn = 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field. */
13348 /* Fall thru. */
13349
13350 /* Branch not taken prediction relocations. */
13351 case R_PPC64_ADDR14_BRNTAKEN:
13352 case R_PPC64_REL14_BRNTAKEN:
13353 insn |= bfd_get_32 (output_bfd,
13354 contents + rel->r_offset) & ~(0x01 << 21);
13355 /* Fall thru. */
13356
13357 case R_PPC64_REL14:
13358 max_br_offset = 1 << 15;
13359 /* Fall thru. */
13360
13361 case R_PPC64_REL24:
13362 /* Calls to functions with a different TOC, such as calls to
13363 shared objects, need to alter the TOC pointer. This is
13364 done using a linkage stub. A REL24 branching to these
13365 linkage stubs needs to be followed by a nop, as the nop
13366 will be replaced with an instruction to restore the TOC
13367 base pointer. */
13368 fdh = h;
13369 if (h != NULL
13370 && h->oh != NULL
13371 && h->oh->is_func_descriptor)
13372 fdh = ppc_follow_link (h->oh);
13373 stub_entry = ppc_get_stub_entry (input_section, sec, fdh, &orig_rel,
13374 htab);
13375 if (stub_entry != NULL
13376 && (stub_entry->stub_type == ppc_stub_plt_call
13377 || stub_entry->stub_type == ppc_stub_plt_call_r2save
13378 || stub_entry->stub_type == ppc_stub_plt_branch_r2off
13379 || stub_entry->stub_type == ppc_stub_long_branch_r2off))
13380 {
13381 bfd_boolean can_plt_call = FALSE;
13382
13383 /* All of these stubs will modify r2, so there must be a
13384 branch and link followed by a nop. The nop is
13385 replaced by an insn to restore r2. */
13386 if (rel->r_offset + 8 <= input_section->size)
13387 {
13388 unsigned long br;
13389
13390 br = bfd_get_32 (input_bfd,
13391 contents + rel->r_offset);
13392 if ((br & 1) != 0)
13393 {
13394 unsigned long nop;
13395
13396 nop = bfd_get_32 (input_bfd,
13397 contents + rel->r_offset + 4);
13398 if (nop == NOP
13399 || nop == CROR_151515 || nop == CROR_313131)
13400 {
13401 if (h != NULL
13402 && (h == htab->tls_get_addr_fd
13403 || h == htab->tls_get_addr)
13404 && !htab->no_tls_get_addr_opt)
13405 {
13406 /* Special stub used, leave nop alone. */
13407 }
13408 else
13409 bfd_put_32 (input_bfd, LD_R2_40R1,
13410 contents + rel->r_offset + 4);
13411 can_plt_call = TRUE;
13412 }
13413 }
13414 }
13415
13416 if (!can_plt_call && h != NULL)
13417 {
13418 const char *name = h->elf.root.root.string;
13419
13420 if (*name == '.')
13421 ++name;
13422
13423 if (strncmp (name, "__libc_start_main", 17) == 0
13424 && (name[17] == 0 || name[17] == '@'))
13425 {
13426 /* Allow crt1 branch to go via a toc adjusting
13427 stub. Other calls that never return could do
13428 the same, if we could detect such. */
13429 can_plt_call = TRUE;
13430 }
13431 }
13432
13433 if (!can_plt_call)
13434 {
13435 /* g++ as of 20130507 emits self-calls without a
13436 following nop. This is arguably wrong since we
13437 have conflicting information. On the one hand a
13438 global symbol and on the other a local call
13439 sequence, but don't error for this special case.
13440 It isn't possible to cheaply verify we have
13441 exactly such a call. Allow all calls to the same
13442 section. */
13443 asection *code_sec = sec;
13444
13445 if (get_opd_info (sec) != NULL)
13446 {
13447 bfd_vma off = (relocation + addend
13448 - sec->output_section->vma
13449 - sec->output_offset);
13450
13451 opd_entry_value (sec, off, &code_sec, NULL, FALSE);
13452 }
13453 if (code_sec == input_section)
13454 can_plt_call = TRUE;
13455 }
13456
13457 if (!can_plt_call)
13458 {
13459 info->callbacks->einfo
13460 (_("%P: %H: call to `%T' lacks nop, can't restore toc; "
13461 "recompile with -fPIC"),
13462 input_bfd, input_section, rel->r_offset, sym_name);
13463
13464 bfd_set_error (bfd_error_bad_value);
13465 ret = FALSE;
13466 }
13467
13468 if (can_plt_call
13469 && (stub_entry->stub_type == ppc_stub_plt_call
13470 || stub_entry->stub_type == ppc_stub_plt_call_r2save))
13471 unresolved_reloc = FALSE;
13472 }
13473
13474 if ((stub_entry == NULL
13475 || stub_entry->stub_type == ppc_stub_long_branch
13476 || stub_entry->stub_type == ppc_stub_plt_branch)
13477 && get_opd_info (sec) != NULL)
13478 {
13479 /* The branch destination is the value of the opd entry. */
13480 bfd_vma off = (relocation + addend
13481 - sec->output_section->vma
13482 - sec->output_offset);
13483 bfd_vma dest = opd_entry_value (sec, off, NULL, NULL, FALSE);
13484 if (dest != (bfd_vma) -1)
13485 {
13486 relocation = dest;
13487 addend = 0;
13488 reloc_dest = DEST_OPD;
13489 }
13490 }
13491
13492 /* If the branch is out of reach we ought to have a long
13493 branch stub. */
13494 from = (rel->r_offset
13495 + input_section->output_offset
13496 + input_section->output_section->vma);
13497
13498 relocation += PPC64_LOCAL_ENTRY_OFFSET (fdh
13499 ? fdh->elf.other
13500 : sym->st_other);
13501
13502 if (stub_entry != NULL
13503 && (stub_entry->stub_type == ppc_stub_long_branch
13504 || stub_entry->stub_type == ppc_stub_plt_branch)
13505 && (r_type == R_PPC64_ADDR14_BRTAKEN
13506 || r_type == R_PPC64_ADDR14_BRNTAKEN
13507 || (relocation + addend - from + max_br_offset
13508 < 2 * max_br_offset)))
13509 /* Don't use the stub if this branch is in range. */
13510 stub_entry = NULL;
13511
13512 if (stub_entry != NULL)
13513 {
13514 /* Munge up the value and addend so that we call the stub
13515 rather than the procedure directly. */
13516 relocation = (stub_entry->stub_offset
13517 + stub_entry->stub_sec->output_offset
13518 + stub_entry->stub_sec->output_section->vma);
13519 addend = 0;
13520 reloc_dest = DEST_STUB;
13521
13522 if ((stub_entry->stub_type == ppc_stub_plt_call
13523 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
13524 && (ALWAYS_EMIT_R2SAVE
13525 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
13526 && rel + 1 < relend
13527 && rel[1].r_offset == rel->r_offset + 4
13528 && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOCSAVE)
13529 relocation += 4;
13530 }
13531
13532 if (insn != 0)
13533 {
13534 if (is_isa_v2)
13535 {
13536 /* Set 'a' bit. This is 0b00010 in BO field for branch
13537 on CR(BI) insns (BO == 001at or 011at), and 0b01000
13538 for branch on CTR insns (BO == 1a00t or 1a01t). */
13539 if ((insn & (0x14 << 21)) == (0x04 << 21))
13540 insn |= 0x02 << 21;
13541 else if ((insn & (0x14 << 21)) == (0x10 << 21))
13542 insn |= 0x08 << 21;
13543 else
13544 break;
13545 }
13546 else
13547 {
13548 /* Invert 'y' bit if not the default. */
13549 if ((bfd_signed_vma) (relocation + addend - from) < 0)
13550 insn ^= 0x01 << 21;
13551 }
13552
13553 bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
13554 }
13555
13556 /* NOP out calls to undefined weak functions.
13557 We can thus call a weak function without first
13558 checking whether the function is defined. */
13559 else if (h != NULL
13560 && h->elf.root.type == bfd_link_hash_undefweak
13561 && h->elf.dynindx == -1
13562 && r_type == R_PPC64_REL24
13563 && relocation == 0
13564 && addend == 0)
13565 {
13566 bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
13567 continue;
13568 }
13569 break;
13570 }
13571
13572 /* Set `addend'. */
13573 tls_type = 0;
13574 switch (r_type)
13575 {
13576 default:
13577 info->callbacks->einfo
13578 (_("%P: %B: unknown relocation type %d for `%T'\n"),
13579 input_bfd, (int) r_type, sym_name);
13580
13581 bfd_set_error (bfd_error_bad_value);
13582 ret = FALSE;
13583 continue;
13584
13585 case R_PPC64_NONE:
13586 case R_PPC64_TLS:
13587 case R_PPC64_TLSGD:
13588 case R_PPC64_TLSLD:
13589 case R_PPC64_TOCSAVE:
13590 case R_PPC64_GNU_VTINHERIT:
13591 case R_PPC64_GNU_VTENTRY:
13592 continue;
13593
13594 /* GOT16 relocations. Like an ADDR16 using the symbol's
13595 address in the GOT as relocation value instead of the
13596 symbol's value itself. Also, create a GOT entry for the
13597 symbol and put the symbol value there. */
13598 case R_PPC64_GOT_TLSGD16:
13599 case R_PPC64_GOT_TLSGD16_LO:
13600 case R_PPC64_GOT_TLSGD16_HI:
13601 case R_PPC64_GOT_TLSGD16_HA:
13602 tls_type = TLS_TLS | TLS_GD;
13603 goto dogot;
13604
13605 case R_PPC64_GOT_TLSLD16:
13606 case R_PPC64_GOT_TLSLD16_LO:
13607 case R_PPC64_GOT_TLSLD16_HI:
13608 case R_PPC64_GOT_TLSLD16_HA:
13609 tls_type = TLS_TLS | TLS_LD;
13610 goto dogot;
13611
13612 case R_PPC64_GOT_TPREL16_DS:
13613 case R_PPC64_GOT_TPREL16_LO_DS:
13614 case R_PPC64_GOT_TPREL16_HI:
13615 case R_PPC64_GOT_TPREL16_HA:
13616 tls_type = TLS_TLS | TLS_TPREL;
13617 goto dogot;
13618
13619 case R_PPC64_GOT_DTPREL16_DS:
13620 case R_PPC64_GOT_DTPREL16_LO_DS:
13621 case R_PPC64_GOT_DTPREL16_HI:
13622 case R_PPC64_GOT_DTPREL16_HA:
13623 tls_type = TLS_TLS | TLS_DTPREL;
13624 goto dogot;
13625
13626 case R_PPC64_GOT16:
13627 case R_PPC64_GOT16_LO:
13628 case R_PPC64_GOT16_HI:
13629 case R_PPC64_GOT16_HA:
13630 case R_PPC64_GOT16_DS:
13631 case R_PPC64_GOT16_LO_DS:
13632 dogot:
13633 {
13634 /* Relocation is to the entry for this symbol in the global
13635 offset table. */
13636 asection *got;
13637 bfd_vma *offp;
13638 bfd_vma off;
13639 unsigned long indx = 0;
13640 struct got_entry *ent;
13641
13642 if (tls_type == (TLS_TLS | TLS_LD)
13643 && (h == NULL
13644 || !h->elf.def_dynamic))
13645 ent = ppc64_tlsld_got (input_bfd);
13646 else
13647 {
13648
13649 if (h != NULL)
13650 {
13651 bfd_boolean dyn = htab->elf.dynamic_sections_created;
13652 if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared,
13653 &h->elf)
13654 || (info->shared
13655 && SYMBOL_CALLS_LOCAL (info, &h->elf)))
13656 /* This is actually a static link, or it is a
13657 -Bsymbolic link and the symbol is defined
13658 locally, or the symbol was forced to be local
13659 because of a version file. */
13660 ;
13661 else
13662 {
13663 BFD_ASSERT (h->elf.dynindx != -1);
13664 indx = h->elf.dynindx;
13665 unresolved_reloc = FALSE;
13666 }
13667 ent = h->elf.got.glist;
13668 }
13669 else
13670 {
13671 if (local_got_ents == NULL)
13672 abort ();
13673 ent = local_got_ents[r_symndx];
13674 }
13675
13676 for (; ent != NULL; ent = ent->next)
13677 if (ent->addend == orig_rel.r_addend
13678 && ent->owner == input_bfd
13679 && ent->tls_type == tls_type)
13680 break;
13681 }
13682
13683 if (ent == NULL)
13684 abort ();
13685 if (ent->is_indirect)
13686 ent = ent->got.ent;
13687 offp = &ent->got.offset;
13688 got = ppc64_elf_tdata (ent->owner)->got;
13689 if (got == NULL)
13690 abort ();
13691
13692 /* The offset must always be a multiple of 8. We use the
13693 least significant bit to record whether we have already
13694 processed this entry. */
13695 off = *offp;
13696 if ((off & 1) != 0)
13697 off &= ~1;
13698 else
13699 {
13700 /* Generate relocs for the dynamic linker, except in
13701 the case of TLSLD where we'll use one entry per
13702 module. */
13703 asection *relgot;
13704 bfd_boolean ifunc;
13705
13706 *offp = off | 1;
13707 relgot = NULL;
13708 ifunc = (h != NULL
13709 ? h->elf.type == STT_GNU_IFUNC
13710 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC);
13711 if (ifunc)
13712 relgot = htab->reliplt;
13713 else if ((info->shared || indx != 0)
13714 && (h == NULL
13715 || (tls_type == (TLS_TLS | TLS_LD)
13716 && !h->elf.def_dynamic)
13717 || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
13718 || h->elf.root.type != bfd_link_hash_undefweak))
13719 relgot = ppc64_elf_tdata (ent->owner)->relgot;
13720 if (relgot != NULL)
13721 {
13722 outrel.r_offset = (got->output_section->vma
13723 + got->output_offset
13724 + off);
13725 outrel.r_addend = addend;
13726 if (tls_type & (TLS_LD | TLS_GD))
13727 {
13728 outrel.r_addend = 0;
13729 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPMOD64);
13730 if (tls_type == (TLS_TLS | TLS_GD))
13731 {
13732 loc = relgot->contents;
13733 loc += (relgot->reloc_count++
13734 * sizeof (Elf64_External_Rela));
13735 bfd_elf64_swap_reloca_out (output_bfd,
13736 &outrel, loc);
13737 outrel.r_offset += 8;
13738 outrel.r_addend = addend;
13739 outrel.r_info
13740 = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
13741 }
13742 }
13743 else if (tls_type == (TLS_TLS | TLS_DTPREL))
13744 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
13745 else if (tls_type == (TLS_TLS | TLS_TPREL))
13746 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_TPREL64);
13747 else if (indx != 0)
13748 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_GLOB_DAT);
13749 else
13750 {
13751 if (ifunc)
13752 outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
13753 else
13754 outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
13755
13756 /* Write the .got section contents for the sake
13757 of prelink. */
13758 loc = got->contents + off;
13759 bfd_put_64 (output_bfd, outrel.r_addend + relocation,
13760 loc);
13761 }
13762
13763 if (indx == 0 && tls_type != (TLS_TLS | TLS_LD))
13764 {
13765 outrel.r_addend += relocation;
13766 if (tls_type & (TLS_GD | TLS_DTPREL | TLS_TPREL))
13767 outrel.r_addend -= htab->elf.tls_sec->vma;
13768 }
13769 loc = relgot->contents;
13770 loc += (relgot->reloc_count++
13771 * sizeof (Elf64_External_Rela));
13772 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
13773 }
13774
13775 /* Init the .got section contents here if we're not
13776 emitting a reloc. */
13777 else
13778 {
13779 relocation += addend;
13780 if (tls_type == (TLS_TLS | TLS_LD))
13781 relocation = 1;
13782 else if (tls_type != 0)
13783 {
13784 relocation -= htab->elf.tls_sec->vma + DTP_OFFSET;
13785 if (tls_type == (TLS_TLS | TLS_TPREL))
13786 relocation += DTP_OFFSET - TP_OFFSET;
13787
13788 if (tls_type == (TLS_TLS | TLS_GD))
13789 {
13790 bfd_put_64 (output_bfd, relocation,
13791 got->contents + off + 8);
13792 relocation = 1;
13793 }
13794 }
13795
13796 bfd_put_64 (output_bfd, relocation,
13797 got->contents + off);
13798 }
13799 }
13800
13801 if (off >= (bfd_vma) -2)
13802 abort ();
13803
13804 relocation = got->output_section->vma + got->output_offset + off;
13805 addend = -(TOCstart + htab->stub_group[input_section->id].toc_off);
13806 }
13807 break;
13808
13809 case R_PPC64_PLT16_HA:
13810 case R_PPC64_PLT16_HI:
13811 case R_PPC64_PLT16_LO:
13812 case R_PPC64_PLT32:
13813 case R_PPC64_PLT64:
13814 /* Relocation is to the entry for this symbol in the
13815 procedure linkage table. */
13816
13817 /* Resolve a PLT reloc against a local symbol directly,
13818 without using the procedure linkage table. */
13819 if (h == NULL)
13820 break;
13821
13822 /* It's possible that we didn't make a PLT entry for this
13823 symbol. This happens when statically linking PIC code,
13824 or when using -Bsymbolic. Go find a match if there is a
13825 PLT entry. */
13826 if (htab->plt != NULL)
13827 {
13828 struct plt_entry *ent;
13829 for (ent = h->elf.plt.plist; ent != NULL; ent = ent->next)
13830 if (ent->addend == orig_rel.r_addend
13831 && ent->plt.offset != (bfd_vma) -1)
13832 {
13833 relocation = (htab->plt->output_section->vma
13834 + htab->plt->output_offset
13835 + ent->plt.offset);
13836 unresolved_reloc = FALSE;
13837 }
13838 }
13839 break;
13840
13841 case R_PPC64_TOC:
13842 /* Relocation value is TOC base. */
13843 relocation = TOCstart;
13844 if (r_symndx == STN_UNDEF)
13845 relocation += htab->stub_group[input_section->id].toc_off;
13846 else if (unresolved_reloc)
13847 ;
13848 else if (sec != NULL && sec->id <= htab->top_id)
13849 relocation += htab->stub_group[sec->id].toc_off;
13850 else
13851 unresolved_reloc = TRUE;
13852 goto dodyn;
13853
13854 /* TOC16 relocs. We want the offset relative to the TOC base,
13855 which is the address of the start of the TOC plus 0x8000.
13856 The TOC consists of sections .got, .toc, .tocbss, and .plt,
13857 in this order. */
13858 case R_PPC64_TOC16:
13859 case R_PPC64_TOC16_LO:
13860 case R_PPC64_TOC16_HI:
13861 case R_PPC64_TOC16_DS:
13862 case R_PPC64_TOC16_LO_DS:
13863 case R_PPC64_TOC16_HA:
13864 addend -= TOCstart + htab->stub_group[input_section->id].toc_off;
13865 break;
13866
13867 /* Relocate against the beginning of the section. */
13868 case R_PPC64_SECTOFF:
13869 case R_PPC64_SECTOFF_LO:
13870 case R_PPC64_SECTOFF_HI:
13871 case R_PPC64_SECTOFF_DS:
13872 case R_PPC64_SECTOFF_LO_DS:
13873 case R_PPC64_SECTOFF_HA:
13874 if (sec != NULL)
13875 addend -= sec->output_section->vma;
13876 break;
13877
13878 case R_PPC64_REL16:
13879 case R_PPC64_REL16_LO:
13880 case R_PPC64_REL16_HI:
13881 case R_PPC64_REL16_HA:
13882 break;
13883
13884 case R_PPC64_REL14:
13885 case R_PPC64_REL14_BRNTAKEN:
13886 case R_PPC64_REL14_BRTAKEN:
13887 case R_PPC64_REL24:
13888 break;
13889
13890 case R_PPC64_TPREL16:
13891 case R_PPC64_TPREL16_LO:
13892 case R_PPC64_TPREL16_HI:
13893 case R_PPC64_TPREL16_HA:
13894 case R_PPC64_TPREL16_DS:
13895 case R_PPC64_TPREL16_LO_DS:
13896 case R_PPC64_TPREL16_HIGH:
13897 case R_PPC64_TPREL16_HIGHA:
13898 case R_PPC64_TPREL16_HIGHER:
13899 case R_PPC64_TPREL16_HIGHERA:
13900 case R_PPC64_TPREL16_HIGHEST:
13901 case R_PPC64_TPREL16_HIGHESTA:
13902 if (h != NULL
13903 && h->elf.root.type == bfd_link_hash_undefweak
13904 && h->elf.dynindx == -1)
13905 {
13906 /* Make this relocation against an undefined weak symbol
13907 resolve to zero. This is really just a tweak, since
13908 code using weak externs ought to check that they are
13909 defined before using them. */
13910 bfd_byte *p = contents + rel->r_offset - d_offset;
13911
13912 insn = bfd_get_32 (output_bfd, p);
13913 insn = _bfd_elf_ppc_at_tprel_transform (insn, 13);
13914 if (insn != 0)
13915 bfd_put_32 (output_bfd, insn, p);
13916 break;
13917 }
13918 addend -= htab->elf.tls_sec->vma + TP_OFFSET;
13919 if (info->shared)
13920 /* The TPREL16 relocs shouldn't really be used in shared
13921 libs as they will result in DT_TEXTREL being set, but
13922 support them anyway. */
13923 goto dodyn;
13924 break;
13925
13926 case R_PPC64_DTPREL16:
13927 case R_PPC64_DTPREL16_LO:
13928 case R_PPC64_DTPREL16_HI:
13929 case R_PPC64_DTPREL16_HA:
13930 case R_PPC64_DTPREL16_DS:
13931 case R_PPC64_DTPREL16_LO_DS:
13932 case R_PPC64_DTPREL16_HIGH:
13933 case R_PPC64_DTPREL16_HIGHA:
13934 case R_PPC64_DTPREL16_HIGHER:
13935 case R_PPC64_DTPREL16_HIGHERA:
13936 case R_PPC64_DTPREL16_HIGHEST:
13937 case R_PPC64_DTPREL16_HIGHESTA:
13938 addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
13939 break;
13940
13941 case R_PPC64_DTPMOD64:
13942 relocation = 1;
13943 addend = 0;
13944 goto dodyn;
13945
13946 case R_PPC64_TPREL64:
13947 addend -= htab->elf.tls_sec->vma + TP_OFFSET;
13948 goto dodyn;
13949
13950 case R_PPC64_DTPREL64:
13951 addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
13952 /* Fall thru */
13953
13954 /* Relocations that may need to be propagated if this is a
13955 dynamic object. */
13956 case R_PPC64_REL30:
13957 case R_PPC64_REL32:
13958 case R_PPC64_REL64:
13959 case R_PPC64_ADDR14:
13960 case R_PPC64_ADDR14_BRNTAKEN:
13961 case R_PPC64_ADDR14_BRTAKEN:
13962 case R_PPC64_ADDR16:
13963 case R_PPC64_ADDR16_DS:
13964 case R_PPC64_ADDR16_HA:
13965 case R_PPC64_ADDR16_HI:
13966 case R_PPC64_ADDR16_HIGH:
13967 case R_PPC64_ADDR16_HIGHA:
13968 case R_PPC64_ADDR16_HIGHER:
13969 case R_PPC64_ADDR16_HIGHERA:
13970 case R_PPC64_ADDR16_HIGHEST:
13971 case R_PPC64_ADDR16_HIGHESTA:
13972 case R_PPC64_ADDR16_LO:
13973 case R_PPC64_ADDR16_LO_DS:
13974 case R_PPC64_ADDR24:
13975 case R_PPC64_ADDR32:
13976 case R_PPC64_ADDR64:
13977 case R_PPC64_UADDR16:
13978 case R_PPC64_UADDR32:
13979 case R_PPC64_UADDR64:
13980 dodyn:
13981 if ((input_section->flags & SEC_ALLOC) == 0)
13982 break;
13983
13984 if (NO_OPD_RELOCS && is_opd)
13985 break;
13986
13987 if ((info->shared
13988 && (h == NULL
13989 || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
13990 || h->elf.root.type != bfd_link_hash_undefweak)
13991 && (must_be_dyn_reloc (info, r_type)
13992 || !SYMBOL_CALLS_LOCAL (info, &h->elf)))
13993 || (ELIMINATE_COPY_RELOCS
13994 && !info->shared
13995 && h != NULL
13996 && h->elf.dynindx != -1
13997 && !h->elf.non_got_ref
13998 && !h->elf.def_regular)
13999 || (!info->shared
14000 && (h != NULL
14001 ? h->elf.type == STT_GNU_IFUNC
14002 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)))
14003 {
14004 bfd_boolean skip, relocate;
14005 asection *sreloc;
14006 bfd_vma out_off;
14007
14008 /* When generating a dynamic object, these relocations
14009 are copied into the output file to be resolved at run
14010 time. */
14011
14012 skip = FALSE;
14013 relocate = FALSE;
14014
14015 out_off = _bfd_elf_section_offset (output_bfd, info,
14016 input_section, rel->r_offset);
14017 if (out_off == (bfd_vma) -1)
14018 skip = TRUE;
14019 else if (out_off == (bfd_vma) -2)
14020 skip = TRUE, relocate = TRUE;
14021 out_off += (input_section->output_section->vma
14022 + input_section->output_offset);
14023 outrel.r_offset = out_off;
14024 outrel.r_addend = rel->r_addend;
14025
14026 /* Optimize unaligned reloc use. */
14027 if ((r_type == R_PPC64_ADDR64 && (out_off & 7) != 0)
14028 || (r_type == R_PPC64_UADDR64 && (out_off & 7) == 0))
14029 r_type ^= R_PPC64_ADDR64 ^ R_PPC64_UADDR64;
14030 else if ((r_type == R_PPC64_ADDR32 && (out_off & 3) != 0)
14031 || (r_type == R_PPC64_UADDR32 && (out_off & 3) == 0))
14032 r_type ^= R_PPC64_ADDR32 ^ R_PPC64_UADDR32;
14033 else if ((r_type == R_PPC64_ADDR16 && (out_off & 1) != 0)
14034 || (r_type == R_PPC64_UADDR16 && (out_off & 1) == 0))
14035 r_type ^= R_PPC64_ADDR16 ^ R_PPC64_UADDR16;
14036
14037 if (skip)
14038 memset (&outrel, 0, sizeof outrel);
14039 else if (!SYMBOL_CALLS_LOCAL (info, &h->elf)
14040 && !is_opd
14041 && r_type != R_PPC64_TOC)
14042 {
14043 BFD_ASSERT (h->elf.dynindx != -1);
14044 outrel.r_info = ELF64_R_INFO (h->elf.dynindx, r_type);
14045 }
14046 else
14047 {
14048 /* This symbol is local, or marked to become local,
14049 or this is an opd section reloc which must point
14050 at a local function. */
14051 outrel.r_addend += relocation;
14052 if (r_type == R_PPC64_ADDR64 || r_type == R_PPC64_TOC)
14053 {
14054 if (is_opd && h != NULL)
14055 {
14056 /* Lie about opd entries. This case occurs
14057 when building shared libraries and we
14058 reference a function in another shared
14059 lib. The same thing happens for a weak
14060 definition in an application that's
14061 overridden by a strong definition in a
14062 shared lib. (I believe this is a generic
14063 bug in binutils handling of weak syms.)
14064 In these cases we won't use the opd
14065 entry in this lib. */
14066 unresolved_reloc = FALSE;
14067 }
14068 if (!is_opd
14069 && r_type == R_PPC64_ADDR64
14070 && (h != NULL
14071 ? h->elf.type == STT_GNU_IFUNC
14072 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
14073 outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
14074 else
14075 {
14076 outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
14077
14078 /* We need to relocate .opd contents for ld.so.
14079 Prelink also wants simple and consistent rules
14080 for relocs. This make all RELATIVE relocs have
14081 *r_offset equal to r_addend. */
14082 relocate = TRUE;
14083 }
14084 }
14085 else
14086 {
14087 long indx = 0;
14088
14089 if (h != NULL
14090 ? h->elf.type == STT_GNU_IFUNC
14091 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
14092 {
14093 info->callbacks->einfo
14094 (_("%P: %H: %s for indirect "
14095 "function `%T' unsupported\n"),
14096 input_bfd, input_section, rel->r_offset,
14097 ppc64_elf_howto_table[r_type]->name,
14098 sym_name);
14099 ret = FALSE;
14100 }
14101 else if (r_symndx == STN_UNDEF || bfd_is_abs_section (sec))
14102 ;
14103 else if (sec == NULL || sec->owner == NULL)
14104 {
14105 bfd_set_error (bfd_error_bad_value);
14106 return FALSE;
14107 }
14108 else
14109 {
14110 asection *osec;
14111
14112 osec = sec->output_section;
14113 indx = elf_section_data (osec)->dynindx;
14114
14115 if (indx == 0)
14116 {
14117 if ((osec->flags & SEC_READONLY) == 0
14118 && htab->elf.data_index_section != NULL)
14119 osec = htab->elf.data_index_section;
14120 else
14121 osec = htab->elf.text_index_section;
14122 indx = elf_section_data (osec)->dynindx;
14123 }
14124 BFD_ASSERT (indx != 0);
14125
14126 /* We are turning this relocation into one
14127 against a section symbol, so subtract out
14128 the output section's address but not the
14129 offset of the input section in the output
14130 section. */
14131 outrel.r_addend -= osec->vma;
14132 }
14133
14134 outrel.r_info = ELF64_R_INFO (indx, r_type);
14135 }
14136 }
14137
14138 sreloc = elf_section_data (input_section)->sreloc;
14139 if (h != NULL
14140 ? h->elf.type == STT_GNU_IFUNC
14141 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
14142 sreloc = htab->reliplt;
14143 if (sreloc == NULL)
14144 abort ();
14145
14146 if (sreloc->reloc_count * sizeof (Elf64_External_Rela)
14147 >= sreloc->size)
14148 abort ();
14149 loc = sreloc->contents;
14150 loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
14151 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
14152
14153 /* If this reloc is against an external symbol, it will
14154 be computed at runtime, so there's no need to do
14155 anything now. However, for the sake of prelink ensure
14156 that the section contents are a known value. */
14157 if (! relocate)
14158 {
14159 unresolved_reloc = FALSE;
14160 /* The value chosen here is quite arbitrary as ld.so
14161 ignores section contents except for the special
14162 case of .opd where the contents might be accessed
14163 before relocation. Choose zero, as that won't
14164 cause reloc overflow. */
14165 relocation = 0;
14166 addend = 0;
14167 /* Use *r_offset == r_addend for R_PPC64_ADDR64 relocs
14168 to improve backward compatibility with older
14169 versions of ld. */
14170 if (r_type == R_PPC64_ADDR64)
14171 addend = outrel.r_addend;
14172 /* Adjust pc_relative relocs to have zero in *r_offset. */
14173 else if (ppc64_elf_howto_table[r_type]->pc_relative)
14174 addend = (input_section->output_section->vma
14175 + input_section->output_offset
14176 + rel->r_offset);
14177 }
14178 }
14179 break;
14180
14181 case R_PPC64_COPY:
14182 case R_PPC64_GLOB_DAT:
14183 case R_PPC64_JMP_SLOT:
14184 case R_PPC64_JMP_IREL:
14185 case R_PPC64_RELATIVE:
14186 /* We shouldn't ever see these dynamic relocs in relocatable
14187 files. */
14188 /* Fall through. */
14189
14190 case R_PPC64_PLTGOT16:
14191 case R_PPC64_PLTGOT16_DS:
14192 case R_PPC64_PLTGOT16_HA:
14193 case R_PPC64_PLTGOT16_HI:
14194 case R_PPC64_PLTGOT16_LO:
14195 case R_PPC64_PLTGOT16_LO_DS:
14196 case R_PPC64_PLTREL32:
14197 case R_PPC64_PLTREL64:
14198 /* These ones haven't been implemented yet. */
14199
14200 info->callbacks->einfo
14201 (_("%P: %B: %s is not supported for `%T'\n"),
14202 input_bfd,
14203 ppc64_elf_howto_table[r_type]->name, sym_name);
14204
14205 bfd_set_error (bfd_error_invalid_operation);
14206 ret = FALSE;
14207 continue;
14208 }
14209
14210 /* Multi-instruction sequences that access the TOC can be
14211 optimized, eg. addis ra,r2,0; addi rb,ra,x;
14212 to nop; addi rb,r2,x; */
14213 switch (r_type)
14214 {
14215 default:
14216 break;
14217
14218 case R_PPC64_GOT_TLSLD16_HI:
14219 case R_PPC64_GOT_TLSGD16_HI:
14220 case R_PPC64_GOT_TPREL16_HI:
14221 case R_PPC64_GOT_DTPREL16_HI:
14222 case R_PPC64_GOT16_HI:
14223 case R_PPC64_TOC16_HI:
14224 /* These relocs would only be useful if building up an
14225 offset to later add to r2, perhaps in an indexed
14226 addressing mode instruction. Don't try to optimize.
14227 Unfortunately, the possibility of someone building up an
14228 offset like this or even with the HA relocs, means that
14229 we need to check the high insn when optimizing the low
14230 insn. */
14231 break;
14232
14233 case R_PPC64_GOT_TLSLD16_HA:
14234 case R_PPC64_GOT_TLSGD16_HA:
14235 case R_PPC64_GOT_TPREL16_HA:
14236 case R_PPC64_GOT_DTPREL16_HA:
14237 case R_PPC64_GOT16_HA:
14238 case R_PPC64_TOC16_HA:
14239 if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
14240 && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
14241 {
14242 bfd_byte *p = contents + (rel->r_offset & ~3);
14243 bfd_put_32 (input_bfd, NOP, p);
14244 }
14245 break;
14246
14247 case R_PPC64_GOT_TLSLD16_LO:
14248 case R_PPC64_GOT_TLSGD16_LO:
14249 case R_PPC64_GOT_TPREL16_LO_DS:
14250 case R_PPC64_GOT_DTPREL16_LO_DS:
14251 case R_PPC64_GOT16_LO:
14252 case R_PPC64_GOT16_LO_DS:
14253 case R_PPC64_TOC16_LO:
14254 case R_PPC64_TOC16_LO_DS:
14255 if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
14256 && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
14257 {
14258 bfd_byte *p = contents + (rel->r_offset & ~3);
14259 insn = bfd_get_32 (input_bfd, p);
14260 if ((insn & (0x3f << 26)) == 12u << 26 /* addic */)
14261 {
14262 /* Transform addic to addi when we change reg. */
14263 insn &= ~((0x3f << 26) | (0x1f << 16));
14264 insn |= (14u << 26) | (2 << 16);
14265 }
14266 else
14267 {
14268 insn &= ~(0x1f << 16);
14269 insn |= 2 << 16;
14270 }
14271 bfd_put_32 (input_bfd, insn, p);
14272 }
14273 break;
14274 }
14275
14276 /* Do any further special processing. */
14277 switch (r_type)
14278 {
14279 default:
14280 break;
14281
14282 case R_PPC64_REL16_HA:
14283 case R_PPC64_ADDR16_HA:
14284 case R_PPC64_ADDR16_HIGHA:
14285 case R_PPC64_ADDR16_HIGHERA:
14286 case R_PPC64_ADDR16_HIGHESTA:
14287 case R_PPC64_TOC16_HA:
14288 case R_PPC64_SECTOFF_HA:
14289 case R_PPC64_TPREL16_HA:
14290 case R_PPC64_TPREL16_HIGHA:
14291 case R_PPC64_TPREL16_HIGHERA:
14292 case R_PPC64_TPREL16_HIGHESTA:
14293 case R_PPC64_DTPREL16_HA:
14294 case R_PPC64_DTPREL16_HIGHA:
14295 case R_PPC64_DTPREL16_HIGHERA:
14296 case R_PPC64_DTPREL16_HIGHESTA:
14297 /* It's just possible that this symbol is a weak symbol
14298 that's not actually defined anywhere. In that case,
14299 'sec' would be NULL, and we should leave the symbol
14300 alone (it will be set to zero elsewhere in the link). */
14301 if (sec == NULL)
14302 break;
14303 /* Fall thru */
14304
14305 case R_PPC64_GOT16_HA:
14306 case R_PPC64_PLTGOT16_HA:
14307 case R_PPC64_PLT16_HA:
14308 case R_PPC64_GOT_TLSGD16_HA:
14309 case R_PPC64_GOT_TLSLD16_HA:
14310 case R_PPC64_GOT_TPREL16_HA:
14311 case R_PPC64_GOT_DTPREL16_HA:
14312 /* Add 0x10000 if sign bit in 0:15 is set.
14313 Bits 0:15 are not used. */
14314 addend += 0x8000;
14315 break;
14316
14317 case R_PPC64_ADDR16_DS:
14318 case R_PPC64_ADDR16_LO_DS:
14319 case R_PPC64_GOT16_DS:
14320 case R_PPC64_GOT16_LO_DS:
14321 case R_PPC64_PLT16_LO_DS:
14322 case R_PPC64_SECTOFF_DS:
14323 case R_PPC64_SECTOFF_LO_DS:
14324 case R_PPC64_TOC16_DS:
14325 case R_PPC64_TOC16_LO_DS:
14326 case R_PPC64_PLTGOT16_DS:
14327 case R_PPC64_PLTGOT16_LO_DS:
14328 case R_PPC64_GOT_TPREL16_DS:
14329 case R_PPC64_GOT_TPREL16_LO_DS:
14330 case R_PPC64_GOT_DTPREL16_DS:
14331 case R_PPC64_GOT_DTPREL16_LO_DS:
14332 case R_PPC64_TPREL16_DS:
14333 case R_PPC64_TPREL16_LO_DS:
14334 case R_PPC64_DTPREL16_DS:
14335 case R_PPC64_DTPREL16_LO_DS:
14336 insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
14337 mask = 3;
14338 /* If this reloc is against an lq insn, then the value must be
14339 a multiple of 16. This is somewhat of a hack, but the
14340 "correct" way to do this by defining _DQ forms of all the
14341 _DS relocs bloats all reloc switches in this file. It
14342 doesn't seem to make much sense to use any of these relocs
14343 in data, so testing the insn should be safe. */
14344 if ((insn & (0x3f << 26)) == (56u << 26))
14345 mask = 15;
14346 if (((relocation + addend) & mask) != 0)
14347 {
14348 info->callbacks->einfo
14349 (_("%P: %H: error: %s not a multiple of %u\n"),
14350 input_bfd, input_section, rel->r_offset,
14351 ppc64_elf_howto_table[r_type]->name,
14352 mask + 1);
14353 bfd_set_error (bfd_error_bad_value);
14354 ret = FALSE;
14355 continue;
14356 }
14357 break;
14358 }
14359
14360 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
14361 because such sections are not SEC_ALLOC and thus ld.so will
14362 not process them. */
14363 if (unresolved_reloc
14364 && !((input_section->flags & SEC_DEBUGGING) != 0
14365 && h->elf.def_dynamic)
14366 && _bfd_elf_section_offset (output_bfd, info, input_section,
14367 rel->r_offset) != (bfd_vma) -1)
14368 {
14369 info->callbacks->einfo
14370 (_("%P: %H: unresolvable %s against `%T'\n"),
14371 input_bfd, input_section, rel->r_offset,
14372 ppc64_elf_howto_table[(int) r_type]->name,
14373 h->elf.root.root.string);
14374 ret = FALSE;
14375 }
14376
14377 r = _bfd_final_link_relocate (ppc64_elf_howto_table[(int) r_type],
14378 input_bfd,
14379 input_section,
14380 contents,
14381 rel->r_offset,
14382 relocation,
14383 addend);
14384
14385 if (r != bfd_reloc_ok)
14386 {
14387 char *more_info = NULL;
14388 const char *reloc_name = ppc64_elf_howto_table[r_type]->name;
14389
14390 if (reloc_dest != DEST_NORMAL)
14391 {
14392 more_info = bfd_malloc (strlen (reloc_name) + 8);
14393 if (more_info != NULL)
14394 {
14395 strcpy (more_info, reloc_name);
14396 strcat (more_info, (reloc_dest == DEST_OPD
14397 ? " (OPD)" : " (stub)"));
14398 reloc_name = more_info;
14399 }
14400 }
14401
14402 if (r == bfd_reloc_overflow)
14403 {
14404 if (warned)
14405 continue;
14406 if (h != NULL
14407 && h->elf.root.type == bfd_link_hash_undefweak
14408 && ppc64_elf_howto_table[r_type]->pc_relative)
14409 {
14410 /* Assume this is a call protected by other code that
14411 detects the symbol is undefined. If this is the case,
14412 we can safely ignore the overflow. If not, the
14413 program is hosed anyway, and a little warning isn't
14414 going to help. */
14415
14416 continue;
14417 }
14418
14419 if (!((*info->callbacks->reloc_overflow)
14420 (info, &h->elf.root, sym_name,
14421 reloc_name, orig_rel.r_addend,
14422 input_bfd, input_section, rel->r_offset)))
14423 return FALSE;
14424 }
14425 else
14426 {
14427 info->callbacks->einfo
14428 (_("%P: %H: %s against `%T': error %d\n"),
14429 input_bfd, input_section, rel->r_offset,
14430 reloc_name, sym_name, (int) r);
14431 ret = FALSE;
14432 }
14433 if (more_info != NULL)
14434 free (more_info);
14435 }
14436 }
14437
14438 /* If we're emitting relocations, then shortly after this function
14439 returns, reloc offsets and addends for this section will be
14440 adjusted. Worse, reloc symbol indices will be for the output
14441 file rather than the input. Save a copy of the relocs for
14442 opd_entry_value. */
14443 if (is_opd && (info->emitrelocations || info->relocatable))
14444 {
14445 bfd_size_type amt;
14446 amt = input_section->reloc_count * sizeof (Elf_Internal_Rela);
14447 rel = bfd_alloc (input_bfd, amt);
14448 BFD_ASSERT (ppc64_elf_tdata (input_bfd)->opd.relocs == NULL);
14449 ppc64_elf_tdata (input_bfd)->opd.relocs = rel;
14450 if (rel == NULL)
14451 return FALSE;
14452 memcpy (rel, relocs, amt);
14453 }
14454 return ret;
14455 }
14456
14457 /* Adjust the value of any local symbols in opd sections. */
14458
14459 static int
14460 ppc64_elf_output_symbol_hook (struct bfd_link_info *info,
14461 const char *name ATTRIBUTE_UNUSED,
14462 Elf_Internal_Sym *elfsym,
14463 asection *input_sec,
14464 struct elf_link_hash_entry *h)
14465 {
14466 struct _opd_sec_data *opd;
14467 long adjust;
14468 bfd_vma value;
14469
14470 if (h != NULL)
14471 return 1;
14472
14473 opd = get_opd_info (input_sec);
14474 if (opd == NULL || opd->adjust == NULL)
14475 return 1;
14476
14477 value = elfsym->st_value - input_sec->output_offset;
14478 if (!info->relocatable)
14479 value -= input_sec->output_section->vma;
14480
14481 adjust = opd->adjust[value / 8];
14482 if (adjust == -1)
14483 return 2;
14484
14485 elfsym->st_value += adjust;
14486 return 1;
14487 }
14488
14489 /* Finish up dynamic symbol handling. We set the contents of various
14490 dynamic sections here. */
14491
14492 static bfd_boolean
14493 ppc64_elf_finish_dynamic_symbol (bfd *output_bfd,
14494 struct bfd_link_info *info,
14495 struct elf_link_hash_entry *h,
14496 Elf_Internal_Sym *sym ATTRIBUTE_UNUSED)
14497 {
14498 struct ppc_link_hash_table *htab;
14499 struct plt_entry *ent;
14500 Elf_Internal_Rela rela;
14501 bfd_byte *loc;
14502
14503 htab = ppc_hash_table (info);
14504 if (htab == NULL)
14505 return FALSE;
14506
14507 for (ent = h->plt.plist; ent != NULL; ent = ent->next)
14508 if (ent->plt.offset != (bfd_vma) -1)
14509 {
14510 /* This symbol has an entry in the procedure linkage
14511 table. Set it up. */
14512 if (!htab->elf.dynamic_sections_created
14513 || h->dynindx == -1)
14514 {
14515 BFD_ASSERT (h->type == STT_GNU_IFUNC
14516 && h->def_regular
14517 && (h->root.type == bfd_link_hash_defined
14518 || h->root.type == bfd_link_hash_defweak));
14519 rela.r_offset = (htab->iplt->output_section->vma
14520 + htab->iplt->output_offset
14521 + ent->plt.offset);
14522 if (htab->opd_abi)
14523 rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
14524 else
14525 rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
14526 rela.r_addend = (h->root.u.def.value
14527 + h->root.u.def.section->output_offset
14528 + h->root.u.def.section->output_section->vma
14529 + ent->addend);
14530 loc = (htab->reliplt->contents
14531 + (htab->reliplt->reloc_count++
14532 * sizeof (Elf64_External_Rela)));
14533 }
14534 else
14535 {
14536 rela.r_offset = (htab->plt->output_section->vma
14537 + htab->plt->output_offset
14538 + ent->plt.offset);
14539 rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_JMP_SLOT);
14540 rela.r_addend = ent->addend;
14541 loc = (htab->relplt->contents
14542 + ((ent->plt.offset - PLT_INITIAL_ENTRY_SIZE (htab))
14543 / PLT_ENTRY_SIZE (htab) * sizeof (Elf64_External_Rela)));
14544 }
14545 bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
14546 }
14547
14548 if (h->needs_copy)
14549 {
14550 /* This symbol needs a copy reloc. Set it up. */
14551
14552 if (h->dynindx == -1
14553 || (h->root.type != bfd_link_hash_defined
14554 && h->root.type != bfd_link_hash_defweak)
14555 || htab->relbss == NULL)
14556 abort ();
14557
14558 rela.r_offset = (h->root.u.def.value
14559 + h->root.u.def.section->output_section->vma
14560 + h->root.u.def.section->output_offset);
14561 rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_COPY);
14562 rela.r_addend = 0;
14563 loc = htab->relbss->contents;
14564 loc += htab->relbss->reloc_count++ * sizeof (Elf64_External_Rela);
14565 bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
14566 }
14567
14568 return TRUE;
14569 }
14570
14571 /* Used to decide how to sort relocs in an optimal manner for the
14572 dynamic linker, before writing them out. */
14573
14574 static enum elf_reloc_type_class
14575 ppc64_elf_reloc_type_class (const struct bfd_link_info *info,
14576 const asection *rel_sec,
14577 const Elf_Internal_Rela *rela)
14578 {
14579 enum elf_ppc64_reloc_type r_type;
14580 struct ppc_link_hash_table *htab = ppc_hash_table (info);
14581
14582 if (rel_sec == htab->reliplt)
14583 return reloc_class_ifunc;
14584
14585 r_type = ELF64_R_TYPE (rela->r_info);
14586 switch (r_type)
14587 {
14588 case R_PPC64_RELATIVE:
14589 return reloc_class_relative;
14590 case R_PPC64_JMP_SLOT:
14591 return reloc_class_plt;
14592 case R_PPC64_COPY:
14593 return reloc_class_copy;
14594 default:
14595 return reloc_class_normal;
14596 }
14597 }
14598
14599 /* Finish up the dynamic sections. */
14600
14601 static bfd_boolean
14602 ppc64_elf_finish_dynamic_sections (bfd *output_bfd,
14603 struct bfd_link_info *info)
14604 {
14605 struct ppc_link_hash_table *htab;
14606 bfd *dynobj;
14607 asection *sdyn;
14608
14609 htab = ppc_hash_table (info);
14610 if (htab == NULL)
14611 return FALSE;
14612
14613 dynobj = htab->elf.dynobj;
14614 sdyn = bfd_get_linker_section (dynobj, ".dynamic");
14615
14616 if (htab->elf.dynamic_sections_created)
14617 {
14618 Elf64_External_Dyn *dyncon, *dynconend;
14619
14620 if (sdyn == NULL || htab->got == NULL)
14621 abort ();
14622
14623 dyncon = (Elf64_External_Dyn *) sdyn->contents;
14624 dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
14625 for (; dyncon < dynconend; dyncon++)
14626 {
14627 Elf_Internal_Dyn dyn;
14628 asection *s;
14629
14630 bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
14631
14632 switch (dyn.d_tag)
14633 {
14634 default:
14635 continue;
14636
14637 case DT_PPC64_GLINK:
14638 s = htab->glink;
14639 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
14640 /* We stupidly defined DT_PPC64_GLINK to be the start
14641 of glink rather than the first entry point, which is
14642 what ld.so needs, and now have a bigger stub to
14643 support automatic multiple TOCs. */
14644 dyn.d_un.d_ptr += GLINK_CALL_STUB_SIZE - 8 * 4;
14645 break;
14646
14647 case DT_PPC64_OPD:
14648 s = bfd_get_section_by_name (output_bfd, ".opd");
14649 if (s == NULL)
14650 continue;
14651 dyn.d_un.d_ptr = s->vma;
14652 break;
14653
14654 case DT_PPC64_OPDSZ:
14655 s = bfd_get_section_by_name (output_bfd, ".opd");
14656 if (s == NULL)
14657 continue;
14658 dyn.d_un.d_val = s->size;
14659 break;
14660
14661 case DT_PLTGOT:
14662 s = htab->plt;
14663 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
14664 break;
14665
14666 case DT_JMPREL:
14667 s = htab->relplt;
14668 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
14669 break;
14670
14671 case DT_PLTRELSZ:
14672 dyn.d_un.d_val = htab->relplt->size;
14673 break;
14674
14675 case DT_RELASZ:
14676 /* Don't count procedure linkage table relocs in the
14677 overall reloc count. */
14678 s = htab->relplt;
14679 if (s == NULL)
14680 continue;
14681 dyn.d_un.d_val -= s->size;
14682 break;
14683
14684 case DT_RELA:
14685 /* We may not be using the standard ELF linker script.
14686 If .rela.plt is the first .rela section, we adjust
14687 DT_RELA to not include it. */
14688 s = htab->relplt;
14689 if (s == NULL)
14690 continue;
14691 if (dyn.d_un.d_ptr != s->output_section->vma + s->output_offset)
14692 continue;
14693 dyn.d_un.d_ptr += s->size;
14694 break;
14695 }
14696
14697 bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
14698 }
14699 }
14700
14701 if (htab->got != NULL && htab->got->size != 0)
14702 {
14703 /* Fill in the first entry in the global offset table.
14704 We use it to hold the link-time TOCbase. */
14705 bfd_put_64 (output_bfd,
14706 elf_gp (output_bfd) + TOC_BASE_OFF,
14707 htab->got->contents);
14708
14709 /* Set .got entry size. */
14710 elf_section_data (htab->got->output_section)->this_hdr.sh_entsize = 8;
14711 }
14712
14713 if (htab->plt != NULL && htab->plt->size != 0)
14714 {
14715 /* Set .plt entry size. */
14716 elf_section_data (htab->plt->output_section)->this_hdr.sh_entsize
14717 = PLT_ENTRY_SIZE (htab);
14718 }
14719
14720 /* brlt is SEC_LINKER_CREATED, so we need to write out relocs for
14721 brlt ourselves if emitrelocations. */
14722 if (htab->brlt != NULL
14723 && htab->brlt->reloc_count != 0
14724 && !_bfd_elf_link_output_relocs (output_bfd,
14725 htab->brlt,
14726 elf_section_data (htab->brlt)->rela.hdr,
14727 elf_section_data (htab->brlt)->relocs,
14728 NULL))
14729 return FALSE;
14730
14731 if (htab->glink != NULL
14732 && htab->glink->reloc_count != 0
14733 && !_bfd_elf_link_output_relocs (output_bfd,
14734 htab->glink,
14735 elf_section_data (htab->glink)->rela.hdr,
14736 elf_section_data (htab->glink)->relocs,
14737 NULL))
14738 return FALSE;
14739
14740
14741 if (htab->glink_eh_frame != NULL
14742 && htab->glink_eh_frame->sec_info_type == SEC_INFO_TYPE_EH_FRAME
14743 && !_bfd_elf_write_section_eh_frame (output_bfd, info,
14744 htab->glink_eh_frame,
14745 htab->glink_eh_frame->contents))
14746 return FALSE;
14747
14748 /* We need to handle writing out multiple GOT sections ourselves,
14749 since we didn't add them to DYNOBJ. We know dynobj is the first
14750 bfd. */
14751 while ((dynobj = dynobj->link_next) != NULL)
14752 {
14753 asection *s;
14754
14755 if (!is_ppc64_elf (dynobj))
14756 continue;
14757
14758 s = ppc64_elf_tdata (dynobj)->got;
14759 if (s != NULL
14760 && s->size != 0
14761 && s->output_section != bfd_abs_section_ptr
14762 && !bfd_set_section_contents (output_bfd, s->output_section,
14763 s->contents, s->output_offset,
14764 s->size))
14765 return FALSE;
14766 s = ppc64_elf_tdata (dynobj)->relgot;
14767 if (s != NULL
14768 && s->size != 0
14769 && s->output_section != bfd_abs_section_ptr
14770 && !bfd_set_section_contents (output_bfd, s->output_section,
14771 s->contents, s->output_offset,
14772 s->size))
14773 return FALSE;
14774 }
14775
14776 return TRUE;
14777 }
14778
14779 #include "elf64-target.h"
14780
14781 /* FreeBSD support */
14782
14783 #undef TARGET_LITTLE_SYM
14784 #undef TARGET_LITTLE_NAME
14785
14786 #undef TARGET_BIG_SYM
14787 #define TARGET_BIG_SYM bfd_elf64_powerpc_freebsd_vec
14788 #undef TARGET_BIG_NAME
14789 #define TARGET_BIG_NAME "elf64-powerpc-freebsd"
14790
14791 #undef ELF_OSABI
14792 #define ELF_OSABI ELFOSABI_FREEBSD
14793
14794 #undef elf64_bed
14795 #define elf64_bed elf64_powerpc_fbsd_bed
14796
14797 #include "elf64-target.h"
14798
GDB Binutils - Deliverables
This page took 0.341224 seconds and 5 git commands to generate.