projects / deliverable / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Make bfd.link_next field a union
[deliverable/binutils-gdb.git] / bfd / elf64-ppc.c
1 /* PowerPC64-specific support for 64-bit ELF.
2 Copyright (C) 1999-2014 Free Software Foundation, Inc.
3 Written by Linus Nordberg, Swox AB <info@swox.com>,
4 based on elf32-ppc.c by Ian Lance Taylor.
5 Largely rewritten by Alan Modra.
6
7 This file is part of BFD, the Binary File Descriptor library.
8
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
13
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
18
19 You should have received a copy of the GNU General Public License along
20 with this program; if not, write to the Free Software Foundation, Inc.,
21 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */
22
23
24 /* The 64-bit PowerPC ELF ABI may be found at
25 http://www.linuxbase.org/spec/ELF/ppc64/PPC-elf64abi.txt, and
26 http://www.linuxbase.org/spec/ELF/ppc64/spec/book1.html */
27
28 #include "sysdep.h"
29 #include <stdarg.h>
30 #include "bfd.h"
31 #include "bfdlink.h"
32 #include "libbfd.h"
33 #include "elf-bfd.h"
34 #include "elf/ppc64.h"
35 #include "elf64-ppc.h"
36 #include "dwarf2.h"
37
38 static bfd_reloc_status_type ppc64_elf_ha_reloc
39 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
40 static bfd_reloc_status_type ppc64_elf_branch_reloc
41 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
42 static bfd_reloc_status_type ppc64_elf_brtaken_reloc
43 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
44 static bfd_reloc_status_type ppc64_elf_sectoff_reloc
45 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
46 static bfd_reloc_status_type ppc64_elf_sectoff_ha_reloc
47 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
48 static bfd_reloc_status_type ppc64_elf_toc_reloc
49 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
50 static bfd_reloc_status_type ppc64_elf_toc_ha_reloc
51 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
52 static bfd_reloc_status_type ppc64_elf_toc64_reloc
53 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
54 static bfd_reloc_status_type ppc64_elf_unhandled_reloc
55 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
56 static bfd_vma opd_entry_value
57 (asection *, bfd_vma, asection **, bfd_vma *, bfd_boolean);
58
59 #define TARGET_LITTLE_SYM powerpc_elf64_le_vec
60 #define TARGET_LITTLE_NAME "elf64-powerpcle"
61 #define TARGET_BIG_SYM powerpc_elf64_vec
62 #define TARGET_BIG_NAME "elf64-powerpc"
63 #define ELF_ARCH bfd_arch_powerpc
64 #define ELF_TARGET_ID PPC64_ELF_DATA
65 #define ELF_MACHINE_CODE EM_PPC64
66 #define ELF_MAXPAGESIZE 0x10000
67 #define ELF_COMMONPAGESIZE 0x1000
68 #define elf_info_to_howto ppc64_elf_info_to_howto
69
70 #define elf_backend_want_got_sym 0
71 #define elf_backend_want_plt_sym 0
72 #define elf_backend_plt_alignment 3
73 #define elf_backend_plt_not_loaded 1
74 #define elf_backend_got_header_size 8
75 #define elf_backend_can_gc_sections 1
76 #define elf_backend_can_refcount 1
77 #define elf_backend_rela_normal 1
78 #define elf_backend_default_execstack 0
79
80 #define bfd_elf64_mkobject ppc64_elf_mkobject
81 #define bfd_elf64_bfd_reloc_type_lookup ppc64_elf_reloc_type_lookup
82 #define bfd_elf64_bfd_reloc_name_lookup ppc64_elf_reloc_name_lookup
83 #define bfd_elf64_bfd_merge_private_bfd_data ppc64_elf_merge_private_bfd_data
84 #define bfd_elf64_bfd_print_private_bfd_data ppc64_elf_print_private_bfd_data
85 #define bfd_elf64_new_section_hook ppc64_elf_new_section_hook
86 #define bfd_elf64_bfd_link_hash_table_create ppc64_elf_link_hash_table_create
87 #define bfd_elf64_bfd_link_hash_table_free ppc64_elf_link_hash_table_free
88 #define bfd_elf64_get_synthetic_symtab ppc64_elf_get_synthetic_symtab
89 #define bfd_elf64_bfd_link_just_syms ppc64_elf_link_just_syms
90
91 #define elf_backend_object_p ppc64_elf_object_p
92 #define elf_backend_grok_prstatus ppc64_elf_grok_prstatus
93 #define elf_backend_grok_psinfo ppc64_elf_grok_psinfo
94 #define elf_backend_write_core_note ppc64_elf_write_core_note
95 #define elf_backend_create_dynamic_sections ppc64_elf_create_dynamic_sections
96 #define elf_backend_copy_indirect_symbol ppc64_elf_copy_indirect_symbol
97 #define elf_backend_add_symbol_hook ppc64_elf_add_symbol_hook
98 #define elf_backend_check_directives ppc64_elf_before_check_relocs
99 #define elf_backend_notice_as_needed ppc64_elf_notice_as_needed
100 #define elf_backend_archive_symbol_lookup ppc64_elf_archive_symbol_lookup
101 #define elf_backend_check_relocs ppc64_elf_check_relocs
102 #define elf_backend_gc_keep ppc64_elf_gc_keep
103 #define elf_backend_gc_mark_dynamic_ref ppc64_elf_gc_mark_dynamic_ref
104 #define elf_backend_gc_mark_hook ppc64_elf_gc_mark_hook
105 #define elf_backend_gc_sweep_hook ppc64_elf_gc_sweep_hook
106 #define elf_backend_adjust_dynamic_symbol ppc64_elf_adjust_dynamic_symbol
107 #define elf_backend_hide_symbol ppc64_elf_hide_symbol
108 #define elf_backend_maybe_function_sym ppc64_elf_maybe_function_sym
109 #define elf_backend_always_size_sections ppc64_elf_func_desc_adjust
110 #define elf_backend_size_dynamic_sections ppc64_elf_size_dynamic_sections
111 #define elf_backend_hash_symbol ppc64_elf_hash_symbol
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_merge_symbol_attribute ppc64_elf_merge_symbol_attribute
121
122 /* The name of the dynamic interpreter. This is put in the .interp
123 section. */
124 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
125
126 /* The size in bytes of an entry in the procedure linkage table. */
127 #define PLT_ENTRY_SIZE(htab) (htab->opd_abi ? 24 : 8)
128
129 /* The initial size of the plt reserved for the dynamic linker. */
130 #define PLT_INITIAL_ENTRY_SIZE(htab) (htab->opd_abi ? 24 : 16)
131
132 /* Offsets to some stack save slots. */
133 #define STK_LR 16
134 #define STK_TOC(htab) (htab->opd_abi ? 40 : 24)
135 /* This one is dodgy. ELFv2 does not have a linker word, so use the
136 CR save slot. Used only by optimised __tls_get_addr call stub,
137 relying on __tls_get_addr_opt not saving CR.. */
138 #define STK_LINKER(htab) (htab->opd_abi ? 32 : 8)
139
140 /* TOC base pointers offset from start of TOC. */
141 #define TOC_BASE_OFF 0x8000
142
143 /* Offset of tp and dtp pointers from start of TLS block. */
144 #define TP_OFFSET 0x7000
145 #define DTP_OFFSET 0x8000
146
147 /* .plt call stub instructions. The normal stub is like this, but
148 sometimes the .plt entry crosses a 64k boundary and we need to
149 insert an addi to adjust r11. */
150 #define STD_R2_0R1 0xf8410000 /* std %r2,0+40(%r1) */
151 #define ADDIS_R11_R2 0x3d620000 /* addis %r11,%r2,xxx@ha */
152 #define LD_R12_0R11 0xe98b0000 /* ld %r12,xxx+0@l(%r11) */
153 #define MTCTR_R12 0x7d8903a6 /* mtctr %r12 */
154 #define LD_R2_0R11 0xe84b0000 /* ld %r2,xxx+8@l(%r11) */
155 #define LD_R11_0R11 0xe96b0000 /* ld %r11,xxx+16@l(%r11) */
156 #define BCTR 0x4e800420 /* bctr */
157
158 #define ADDI_R11_R11 0x396b0000 /* addi %r11,%r11,off@l */
159 #define ADDIS_R2_R2 0x3c420000 /* addis %r2,%r2,off@ha */
160 #define ADDI_R2_R2 0x38420000 /* addi %r2,%r2,off@l */
161
162 #define XOR_R2_R12_R12 0x7d826278 /* xor %r2,%r12,%r12 */
163 #define ADD_R11_R11_R2 0x7d6b1214 /* add %r11,%r11,%r2 */
164 #define XOR_R11_R12_R12 0x7d8b6278 /* xor %r11,%r12,%r12 */
165 #define ADD_R2_R2_R11 0x7c425a14 /* add %r2,%r2,%r11 */
166 #define CMPLDI_R2_0 0x28220000 /* cmpldi %r2,0 */
167 #define BNECTR 0x4ca20420 /* bnectr+ */
168 #define BNECTR_P4 0x4ce20420 /* bnectr+ */
169
170 #define LD_R12_0R2 0xe9820000 /* ld %r12,xxx+0(%r2) */
171 #define LD_R11_0R2 0xe9620000 /* ld %r11,xxx+0(%r2) */
172 #define LD_R2_0R2 0xe8420000 /* ld %r2,xxx+0(%r2) */
173
174 #define LD_R2_0R1 0xe8410000 /* ld %r2,0(%r1) */
175
176 #define ADDIS_R12_R2 0x3d820000 /* addis %r12,%r2,xxx@ha */
177 #define ADDIS_R12_R12 0x3d8c0000 /* addis %r12,%r12,xxx@ha */
178 #define LD_R12_0R12 0xe98c0000 /* ld %r12,xxx@l(%r12) */
179
180 /* glink call stub instructions. We enter with the index in R0. */
181 #define GLINK_CALL_STUB_SIZE (16*4)
182 /* 0: */
183 /* .quad plt0-1f */
184 /* __glink: */
185 #define MFLR_R12 0x7d8802a6 /* mflr %12 */
186 #define BCL_20_31 0x429f0005 /* bcl 20,31,1f */
187 /* 1: */
188 #define MFLR_R11 0x7d6802a6 /* mflr %11 */
189 /* ld %2,(0b-1b)(%11) */
190 #define MTLR_R12 0x7d8803a6 /* mtlr %12 */
191 #define ADD_R11_R2_R11 0x7d625a14 /* add %11,%2,%11 */
192 /* ld %12,0(%11) */
193 /* ld %2,8(%11) */
194 /* mtctr %12 */
195 /* ld %11,16(%11) */
196 /* bctr */
197 #define MFLR_R0 0x7c0802a6 /* mflr %r0 */
198 #define MTLR_R0 0x7c0803a6 /* mtlr %r0 */
199 #define SUB_R12_R12_R11 0x7d8b6050 /* subf %r12,%r11,%r12 */
200 #define ADDI_R0_R12 0x380c0000 /* addi %r0,%r12,0 */
201 #define SRDI_R0_R0_2 0x7800f082 /* rldicl %r0,%r0,62,2 */
202
203 /* Pad with this. */
204 #define NOP 0x60000000
205
206 /* Some other nops. */
207 #define CROR_151515 0x4def7b82
208 #define CROR_313131 0x4ffffb82
209
210 /* .glink entries for the first 32k functions are two instructions. */
211 #define LI_R0_0 0x38000000 /* li %r0,0 */
212 #define B_DOT 0x48000000 /* b . */
213
214 /* After that, we need two instructions to load the index, followed by
215 a branch. */
216 #define LIS_R0_0 0x3c000000 /* lis %r0,0 */
217 #define ORI_R0_R0_0 0x60000000 /* ori %r0,%r0,0 */
218
219 /* Instructions used by the save and restore reg functions. */
220 #define STD_R0_0R1 0xf8010000 /* std %r0,0(%r1) */
221 #define STD_R0_0R12 0xf80c0000 /* std %r0,0(%r12) */
222 #define LD_R0_0R1 0xe8010000 /* ld %r0,0(%r1) */
223 #define LD_R0_0R12 0xe80c0000 /* ld %r0,0(%r12) */
224 #define STFD_FR0_0R1 0xd8010000 /* stfd %fr0,0(%r1) */
225 #define LFD_FR0_0R1 0xc8010000 /* lfd %fr0,0(%r1) */
226 #define LI_R12_0 0x39800000 /* li %r12,0 */
227 #define STVX_VR0_R12_R0 0x7c0c01ce /* stvx %v0,%r12,%r0 */
228 #define LVX_VR0_R12_R0 0x7c0c00ce /* lvx %v0,%r12,%r0 */
229 #define MTLR_R0 0x7c0803a6 /* mtlr %r0 */
230 #define BLR 0x4e800020 /* blr */
231
232 /* Since .opd is an array of descriptors and each entry will end up
233 with identical R_PPC64_RELATIVE relocs, there is really no need to
234 propagate .opd relocs; The dynamic linker should be taught to
235 relocate .opd without reloc entries. */
236 #ifndef NO_OPD_RELOCS
237 #define NO_OPD_RELOCS 0
238 #endif
239 \f
240 #define ONES(n) (((bfd_vma) 1 << ((n) - 1) << 1) - 1)
241
242 /* Relocation HOWTO's. */
243 static reloc_howto_type *ppc64_elf_howto_table[(int) R_PPC64_max];
244
245 static reloc_howto_type ppc64_elf_howto_raw[] = {
246 /* This reloc does nothing. */
247 HOWTO (R_PPC64_NONE, /* type */
248 0, /* rightshift */
249 2, /* size (0 = byte, 1 = short, 2 = long) */
250 32, /* bitsize */
251 FALSE, /* pc_relative */
252 0, /* bitpos */
253 complain_overflow_dont, /* complain_on_overflow */
254 bfd_elf_generic_reloc, /* special_function */
255 "R_PPC64_NONE", /* name */
256 FALSE, /* partial_inplace */
257 0, /* src_mask */
258 0, /* dst_mask */
259 FALSE), /* pcrel_offset */
260
261 /* A standard 32 bit relocation. */
262 HOWTO (R_PPC64_ADDR32, /* type */
263 0, /* rightshift */
264 2, /* size (0 = byte, 1 = short, 2 = long) */
265 32, /* bitsize */
266 FALSE, /* pc_relative */
267 0, /* bitpos */
268 complain_overflow_bitfield, /* complain_on_overflow */
269 bfd_elf_generic_reloc, /* special_function */
270 "R_PPC64_ADDR32", /* name */
271 FALSE, /* partial_inplace */
272 0, /* src_mask */
273 0xffffffff, /* dst_mask */
274 FALSE), /* pcrel_offset */
275
276 /* An absolute 26 bit branch; the lower two bits must be zero.
277 FIXME: we don't check that, we just clear them. */
278 HOWTO (R_PPC64_ADDR24, /* type */
279 0, /* rightshift */
280 2, /* size (0 = byte, 1 = short, 2 = long) */
281 26, /* bitsize */
282 FALSE, /* pc_relative */
283 0, /* bitpos */
284 complain_overflow_bitfield, /* complain_on_overflow */
285 bfd_elf_generic_reloc, /* special_function */
286 "R_PPC64_ADDR24", /* name */
287 FALSE, /* partial_inplace */
288 0, /* src_mask */
289 0x03fffffc, /* dst_mask */
290 FALSE), /* pcrel_offset */
291
292 /* A standard 16 bit relocation. */
293 HOWTO (R_PPC64_ADDR16, /* type */
294 0, /* rightshift */
295 1, /* size (0 = byte, 1 = short, 2 = long) */
296 16, /* bitsize */
297 FALSE, /* pc_relative */
298 0, /* bitpos */
299 complain_overflow_bitfield, /* complain_on_overflow */
300 bfd_elf_generic_reloc, /* special_function */
301 "R_PPC64_ADDR16", /* name */
302 FALSE, /* partial_inplace */
303 0, /* src_mask */
304 0xffff, /* dst_mask */
305 FALSE), /* pcrel_offset */
306
307 /* A 16 bit relocation without overflow. */
308 HOWTO (R_PPC64_ADDR16_LO, /* type */
309 0, /* rightshift */
310 1, /* size (0 = byte, 1 = short, 2 = long) */
311 16, /* bitsize */
312 FALSE, /* pc_relative */
313 0, /* bitpos */
314 complain_overflow_dont,/* complain_on_overflow */
315 bfd_elf_generic_reloc, /* special_function */
316 "R_PPC64_ADDR16_LO", /* name */
317 FALSE, /* partial_inplace */
318 0, /* src_mask */
319 0xffff, /* dst_mask */
320 FALSE), /* pcrel_offset */
321
322 /* Bits 16-31 of an address. */
323 HOWTO (R_PPC64_ADDR16_HI, /* type */
324 16, /* rightshift */
325 1, /* size (0 = byte, 1 = short, 2 = long) */
326 16, /* bitsize */
327 FALSE, /* pc_relative */
328 0, /* bitpos */
329 complain_overflow_signed, /* complain_on_overflow */
330 bfd_elf_generic_reloc, /* special_function */
331 "R_PPC64_ADDR16_HI", /* name */
332 FALSE, /* partial_inplace */
333 0, /* src_mask */
334 0xffff, /* dst_mask */
335 FALSE), /* pcrel_offset */
336
337 /* Bits 16-31 of an address, plus 1 if the contents of the low 16
338 bits, treated as a signed number, is negative. */
339 HOWTO (R_PPC64_ADDR16_HA, /* type */
340 16, /* rightshift */
341 1, /* size (0 = byte, 1 = short, 2 = long) */
342 16, /* bitsize */
343 FALSE, /* pc_relative */
344 0, /* bitpos */
345 complain_overflow_signed, /* complain_on_overflow */
346 ppc64_elf_ha_reloc, /* special_function */
347 "R_PPC64_ADDR16_HA", /* name */
348 FALSE, /* partial_inplace */
349 0, /* src_mask */
350 0xffff, /* dst_mask */
351 FALSE), /* pcrel_offset */
352
353 /* An absolute 16 bit branch; the lower two bits must be zero.
354 FIXME: we don't check that, we just clear them. */
355 HOWTO (R_PPC64_ADDR14, /* type */
356 0, /* rightshift */
357 2, /* size (0 = byte, 1 = short, 2 = long) */
358 16, /* bitsize */
359 FALSE, /* pc_relative */
360 0, /* bitpos */
361 complain_overflow_signed, /* complain_on_overflow */
362 ppc64_elf_branch_reloc, /* special_function */
363 "R_PPC64_ADDR14", /* name */
364 FALSE, /* partial_inplace */
365 0, /* src_mask */
366 0x0000fffc, /* dst_mask */
367 FALSE), /* pcrel_offset */
368
369 /* An absolute 16 bit branch, for which bit 10 should be set to
370 indicate that the branch is expected to be taken. The lower two
371 bits must be zero. */
372 HOWTO (R_PPC64_ADDR14_BRTAKEN, /* type */
373 0, /* rightshift */
374 2, /* size (0 = byte, 1 = short, 2 = long) */
375 16, /* bitsize */
376 FALSE, /* pc_relative */
377 0, /* bitpos */
378 complain_overflow_signed, /* complain_on_overflow */
379 ppc64_elf_brtaken_reloc, /* special_function */
380 "R_PPC64_ADDR14_BRTAKEN",/* name */
381 FALSE, /* partial_inplace */
382 0, /* src_mask */
383 0x0000fffc, /* dst_mask */
384 FALSE), /* pcrel_offset */
385
386 /* An absolute 16 bit branch, for which bit 10 should be set to
387 indicate that the branch is not expected to be taken. The lower
388 two bits must be zero. */
389 HOWTO (R_PPC64_ADDR14_BRNTAKEN, /* type */
390 0, /* rightshift */
391 2, /* size (0 = byte, 1 = short, 2 = long) */
392 16, /* bitsize */
393 FALSE, /* pc_relative */
394 0, /* bitpos */
395 complain_overflow_signed, /* complain_on_overflow */
396 ppc64_elf_brtaken_reloc, /* special_function */
397 "R_PPC64_ADDR14_BRNTAKEN",/* name */
398 FALSE, /* partial_inplace */
399 0, /* src_mask */
400 0x0000fffc, /* dst_mask */
401 FALSE), /* pcrel_offset */
402
403 /* A relative 26 bit branch; the lower two bits must be zero. */
404 HOWTO (R_PPC64_REL24, /* type */
405 0, /* rightshift */
406 2, /* size (0 = byte, 1 = short, 2 = long) */
407 26, /* bitsize */
408 TRUE, /* pc_relative */
409 0, /* bitpos */
410 complain_overflow_signed, /* complain_on_overflow */
411 ppc64_elf_branch_reloc, /* special_function */
412 "R_PPC64_REL24", /* name */
413 FALSE, /* partial_inplace */
414 0, /* src_mask */
415 0x03fffffc, /* dst_mask */
416 TRUE), /* pcrel_offset */
417
418 /* A relative 16 bit branch; the lower two bits must be zero. */
419 HOWTO (R_PPC64_REL14, /* type */
420 0, /* rightshift */
421 2, /* size (0 = byte, 1 = short, 2 = long) */
422 16, /* bitsize */
423 TRUE, /* pc_relative */
424 0, /* bitpos */
425 complain_overflow_signed, /* complain_on_overflow */
426 ppc64_elf_branch_reloc, /* special_function */
427 "R_PPC64_REL14", /* name */
428 FALSE, /* partial_inplace */
429 0, /* src_mask */
430 0x0000fffc, /* dst_mask */
431 TRUE), /* pcrel_offset */
432
433 /* A relative 16 bit branch. Bit 10 should be set to indicate that
434 the branch is expected to be taken. The lower two bits must be
435 zero. */
436 HOWTO (R_PPC64_REL14_BRTAKEN, /* type */
437 0, /* rightshift */
438 2, /* size (0 = byte, 1 = short, 2 = long) */
439 16, /* bitsize */
440 TRUE, /* pc_relative */
441 0, /* bitpos */
442 complain_overflow_signed, /* complain_on_overflow */
443 ppc64_elf_brtaken_reloc, /* special_function */
444 "R_PPC64_REL14_BRTAKEN", /* name */
445 FALSE, /* partial_inplace */
446 0, /* src_mask */
447 0x0000fffc, /* dst_mask */
448 TRUE), /* pcrel_offset */
449
450 /* A relative 16 bit branch. Bit 10 should be set to indicate that
451 the branch is not expected to be taken. The lower two bits must
452 be zero. */
453 HOWTO (R_PPC64_REL14_BRNTAKEN, /* type */
454 0, /* rightshift */
455 2, /* size (0 = byte, 1 = short, 2 = long) */
456 16, /* bitsize */
457 TRUE, /* pc_relative */
458 0, /* bitpos */
459 complain_overflow_signed, /* complain_on_overflow */
460 ppc64_elf_brtaken_reloc, /* special_function */
461 "R_PPC64_REL14_BRNTAKEN",/* name */
462 FALSE, /* partial_inplace */
463 0, /* src_mask */
464 0x0000fffc, /* dst_mask */
465 TRUE), /* pcrel_offset */
466
467 /* Like R_PPC64_ADDR16, but referring to the GOT table entry for the
468 symbol. */
469 HOWTO (R_PPC64_GOT16, /* type */
470 0, /* rightshift */
471 1, /* size (0 = byte, 1 = short, 2 = long) */
472 16, /* bitsize */
473 FALSE, /* pc_relative */
474 0, /* bitpos */
475 complain_overflow_signed, /* complain_on_overflow */
476 ppc64_elf_unhandled_reloc, /* special_function */
477 "R_PPC64_GOT16", /* name */
478 FALSE, /* partial_inplace */
479 0, /* src_mask */
480 0xffff, /* dst_mask */
481 FALSE), /* pcrel_offset */
482
483 /* Like R_PPC64_ADDR16_LO, but referring to the GOT table entry for
484 the symbol. */
485 HOWTO (R_PPC64_GOT16_LO, /* type */
486 0, /* rightshift */
487 1, /* size (0 = byte, 1 = short, 2 = long) */
488 16, /* bitsize */
489 FALSE, /* pc_relative */
490 0, /* bitpos */
491 complain_overflow_dont, /* complain_on_overflow */
492 ppc64_elf_unhandled_reloc, /* special_function */
493 "R_PPC64_GOT16_LO", /* name */
494 FALSE, /* partial_inplace */
495 0, /* src_mask */
496 0xffff, /* dst_mask */
497 FALSE), /* pcrel_offset */
498
499 /* Like R_PPC64_ADDR16_HI, but referring to the GOT table entry for
500 the symbol. */
501 HOWTO (R_PPC64_GOT16_HI, /* type */
502 16, /* rightshift */
503 1, /* size (0 = byte, 1 = short, 2 = long) */
504 16, /* bitsize */
505 FALSE, /* pc_relative */
506 0, /* bitpos */
507 complain_overflow_signed,/* complain_on_overflow */
508 ppc64_elf_unhandled_reloc, /* special_function */
509 "R_PPC64_GOT16_HI", /* name */
510 FALSE, /* partial_inplace */
511 0, /* src_mask */
512 0xffff, /* dst_mask */
513 FALSE), /* pcrel_offset */
514
515 /* Like R_PPC64_ADDR16_HA, but referring to the GOT table entry for
516 the symbol. */
517 HOWTO (R_PPC64_GOT16_HA, /* type */
518 16, /* rightshift */
519 1, /* size (0 = byte, 1 = short, 2 = long) */
520 16, /* bitsize */
521 FALSE, /* pc_relative */
522 0, /* bitpos */
523 complain_overflow_signed,/* complain_on_overflow */
524 ppc64_elf_unhandled_reloc, /* special_function */
525 "R_PPC64_GOT16_HA", /* name */
526 FALSE, /* partial_inplace */
527 0, /* src_mask */
528 0xffff, /* dst_mask */
529 FALSE), /* pcrel_offset */
530
531 /* This is used only by the dynamic linker. The symbol should exist
532 both in the object being run and in some shared library. The
533 dynamic linker copies the data addressed by the symbol from the
534 shared library into the object, because the object being
535 run has to have the data at some particular address. */
536 HOWTO (R_PPC64_COPY, /* type */
537 0, /* rightshift */
538 0, /* this one is variable size */
539 0, /* bitsize */
540 FALSE, /* pc_relative */
541 0, /* bitpos */
542 complain_overflow_dont, /* complain_on_overflow */
543 ppc64_elf_unhandled_reloc, /* special_function */
544 "R_PPC64_COPY", /* name */
545 FALSE, /* partial_inplace */
546 0, /* src_mask */
547 0, /* dst_mask */
548 FALSE), /* pcrel_offset */
549
550 /* Like R_PPC64_ADDR64, but used when setting global offset table
551 entries. */
552 HOWTO (R_PPC64_GLOB_DAT, /* type */
553 0, /* rightshift */
554 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
555 64, /* bitsize */
556 FALSE, /* pc_relative */
557 0, /* bitpos */
558 complain_overflow_dont, /* complain_on_overflow */
559 ppc64_elf_unhandled_reloc, /* special_function */
560 "R_PPC64_GLOB_DAT", /* name */
561 FALSE, /* partial_inplace */
562 0, /* src_mask */
563 ONES (64), /* dst_mask */
564 FALSE), /* pcrel_offset */
565
566 /* Created by the link editor. Marks a procedure linkage table
567 entry for a symbol. */
568 HOWTO (R_PPC64_JMP_SLOT, /* type */
569 0, /* rightshift */
570 0, /* size (0 = byte, 1 = short, 2 = long) */
571 0, /* bitsize */
572 FALSE, /* pc_relative */
573 0, /* bitpos */
574 complain_overflow_dont, /* complain_on_overflow */
575 ppc64_elf_unhandled_reloc, /* special_function */
576 "R_PPC64_JMP_SLOT", /* name */
577 FALSE, /* partial_inplace */
578 0, /* src_mask */
579 0, /* dst_mask */
580 FALSE), /* pcrel_offset */
581
582 /* Used only by the dynamic linker. When the object is run, this
583 doubleword64 is set to the load address of the object, plus the
584 addend. */
585 HOWTO (R_PPC64_RELATIVE, /* type */
586 0, /* rightshift */
587 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
588 64, /* bitsize */
589 FALSE, /* pc_relative */
590 0, /* bitpos */
591 complain_overflow_dont, /* complain_on_overflow */
592 bfd_elf_generic_reloc, /* special_function */
593 "R_PPC64_RELATIVE", /* name */
594 FALSE, /* partial_inplace */
595 0, /* src_mask */
596 ONES (64), /* dst_mask */
597 FALSE), /* pcrel_offset */
598
599 /* Like R_PPC64_ADDR32, but may be unaligned. */
600 HOWTO (R_PPC64_UADDR32, /* type */
601 0, /* rightshift */
602 2, /* size (0 = byte, 1 = short, 2 = long) */
603 32, /* bitsize */
604 FALSE, /* pc_relative */
605 0, /* bitpos */
606 complain_overflow_bitfield, /* complain_on_overflow */
607 bfd_elf_generic_reloc, /* special_function */
608 "R_PPC64_UADDR32", /* name */
609 FALSE, /* partial_inplace */
610 0, /* src_mask */
611 0xffffffff, /* dst_mask */
612 FALSE), /* pcrel_offset */
613
614 /* Like R_PPC64_ADDR16, but may be unaligned. */
615 HOWTO (R_PPC64_UADDR16, /* type */
616 0, /* rightshift */
617 1, /* size (0 = byte, 1 = short, 2 = long) */
618 16, /* bitsize */
619 FALSE, /* pc_relative */
620 0, /* bitpos */
621 complain_overflow_bitfield, /* complain_on_overflow */
622 bfd_elf_generic_reloc, /* special_function */
623 "R_PPC64_UADDR16", /* name */
624 FALSE, /* partial_inplace */
625 0, /* src_mask */
626 0xffff, /* dst_mask */
627 FALSE), /* pcrel_offset */
628
629 /* 32-bit PC relative. */
630 HOWTO (R_PPC64_REL32, /* type */
631 0, /* rightshift */
632 2, /* size (0 = byte, 1 = short, 2 = long) */
633 32, /* bitsize */
634 TRUE, /* pc_relative */
635 0, /* bitpos */
636 complain_overflow_signed, /* complain_on_overflow */
637 bfd_elf_generic_reloc, /* special_function */
638 "R_PPC64_REL32", /* name */
639 FALSE, /* partial_inplace */
640 0, /* src_mask */
641 0xffffffff, /* dst_mask */
642 TRUE), /* pcrel_offset */
643
644 /* 32-bit relocation to the symbol's procedure linkage table. */
645 HOWTO (R_PPC64_PLT32, /* type */
646 0, /* rightshift */
647 2, /* size (0 = byte, 1 = short, 2 = long) */
648 32, /* bitsize */
649 FALSE, /* pc_relative */
650 0, /* bitpos */
651 complain_overflow_bitfield, /* complain_on_overflow */
652 ppc64_elf_unhandled_reloc, /* special_function */
653 "R_PPC64_PLT32", /* name */
654 FALSE, /* partial_inplace */
655 0, /* src_mask */
656 0xffffffff, /* dst_mask */
657 FALSE), /* pcrel_offset */
658
659 /* 32-bit PC relative relocation to the symbol's procedure linkage table.
660 FIXME: R_PPC64_PLTREL32 not supported. */
661 HOWTO (R_PPC64_PLTREL32, /* type */
662 0, /* rightshift */
663 2, /* size (0 = byte, 1 = short, 2 = long) */
664 32, /* bitsize */
665 TRUE, /* pc_relative */
666 0, /* bitpos */
667 complain_overflow_signed, /* complain_on_overflow */
668 bfd_elf_generic_reloc, /* special_function */
669 "R_PPC64_PLTREL32", /* name */
670 FALSE, /* partial_inplace */
671 0, /* src_mask */
672 0xffffffff, /* dst_mask */
673 TRUE), /* pcrel_offset */
674
675 /* Like R_PPC64_ADDR16_LO, but referring to the PLT table entry for
676 the symbol. */
677 HOWTO (R_PPC64_PLT16_LO, /* type */
678 0, /* rightshift */
679 1, /* size (0 = byte, 1 = short, 2 = long) */
680 16, /* bitsize */
681 FALSE, /* pc_relative */
682 0, /* bitpos */
683 complain_overflow_dont, /* complain_on_overflow */
684 ppc64_elf_unhandled_reloc, /* special_function */
685 "R_PPC64_PLT16_LO", /* name */
686 FALSE, /* partial_inplace */
687 0, /* src_mask */
688 0xffff, /* dst_mask */
689 FALSE), /* pcrel_offset */
690
691 /* Like R_PPC64_ADDR16_HI, but referring to the PLT table entry for
692 the symbol. */
693 HOWTO (R_PPC64_PLT16_HI, /* type */
694 16, /* rightshift */
695 1, /* size (0 = byte, 1 = short, 2 = long) */
696 16, /* bitsize */
697 FALSE, /* pc_relative */
698 0, /* bitpos */
699 complain_overflow_signed, /* complain_on_overflow */
700 ppc64_elf_unhandled_reloc, /* special_function */
701 "R_PPC64_PLT16_HI", /* name */
702 FALSE, /* partial_inplace */
703 0, /* src_mask */
704 0xffff, /* dst_mask */
705 FALSE), /* pcrel_offset */
706
707 /* Like R_PPC64_ADDR16_HA, but referring to the PLT table entry for
708 the symbol. */
709 HOWTO (R_PPC64_PLT16_HA, /* type */
710 16, /* rightshift */
711 1, /* size (0 = byte, 1 = short, 2 = long) */
712 16, /* bitsize */
713 FALSE, /* pc_relative */
714 0, /* bitpos */
715 complain_overflow_signed, /* complain_on_overflow */
716 ppc64_elf_unhandled_reloc, /* special_function */
717 "R_PPC64_PLT16_HA", /* name */
718 FALSE, /* partial_inplace */
719 0, /* src_mask */
720 0xffff, /* dst_mask */
721 FALSE), /* pcrel_offset */
722
723 /* 16-bit section relative relocation. */
724 HOWTO (R_PPC64_SECTOFF, /* type */
725 0, /* rightshift */
726 1, /* size (0 = byte, 1 = short, 2 = long) */
727 16, /* bitsize */
728 FALSE, /* pc_relative */
729 0, /* bitpos */
730 complain_overflow_signed, /* complain_on_overflow */
731 ppc64_elf_sectoff_reloc, /* special_function */
732 "R_PPC64_SECTOFF", /* name */
733 FALSE, /* partial_inplace */
734 0, /* src_mask */
735 0xffff, /* dst_mask */
736 FALSE), /* pcrel_offset */
737
738 /* Like R_PPC64_SECTOFF, but no overflow warning. */
739 HOWTO (R_PPC64_SECTOFF_LO, /* type */
740 0, /* rightshift */
741 1, /* size (0 = byte, 1 = short, 2 = long) */
742 16, /* bitsize */
743 FALSE, /* pc_relative */
744 0, /* bitpos */
745 complain_overflow_dont, /* complain_on_overflow */
746 ppc64_elf_sectoff_reloc, /* special_function */
747 "R_PPC64_SECTOFF_LO", /* name */
748 FALSE, /* partial_inplace */
749 0, /* src_mask */
750 0xffff, /* dst_mask */
751 FALSE), /* pcrel_offset */
752
753 /* 16-bit upper half section relative relocation. */
754 HOWTO (R_PPC64_SECTOFF_HI, /* type */
755 16, /* rightshift */
756 1, /* size (0 = byte, 1 = short, 2 = long) */
757 16, /* bitsize */
758 FALSE, /* pc_relative */
759 0, /* bitpos */
760 complain_overflow_signed, /* complain_on_overflow */
761 ppc64_elf_sectoff_reloc, /* special_function */
762 "R_PPC64_SECTOFF_HI", /* name */
763 FALSE, /* partial_inplace */
764 0, /* src_mask */
765 0xffff, /* dst_mask */
766 FALSE), /* pcrel_offset */
767
768 /* 16-bit upper half adjusted section relative relocation. */
769 HOWTO (R_PPC64_SECTOFF_HA, /* type */
770 16, /* rightshift */
771 1, /* size (0 = byte, 1 = short, 2 = long) */
772 16, /* bitsize */
773 FALSE, /* pc_relative */
774 0, /* bitpos */
775 complain_overflow_signed, /* complain_on_overflow */
776 ppc64_elf_sectoff_ha_reloc, /* special_function */
777 "R_PPC64_SECTOFF_HA", /* name */
778 FALSE, /* partial_inplace */
779 0, /* src_mask */
780 0xffff, /* dst_mask */
781 FALSE), /* pcrel_offset */
782
783 /* Like R_PPC64_REL24 without touching the two least significant bits. */
784 HOWTO (R_PPC64_REL30, /* type */
785 2, /* rightshift */
786 2, /* size (0 = byte, 1 = short, 2 = long) */
787 30, /* bitsize */
788 TRUE, /* pc_relative */
789 0, /* bitpos */
790 complain_overflow_dont, /* complain_on_overflow */
791 bfd_elf_generic_reloc, /* special_function */
792 "R_PPC64_REL30", /* name */
793 FALSE, /* partial_inplace */
794 0, /* src_mask */
795 0xfffffffc, /* dst_mask */
796 TRUE), /* pcrel_offset */
797
798 /* Relocs in the 64-bit PowerPC ELF ABI, not in the 32-bit ABI. */
799
800 /* A standard 64-bit relocation. */
801 HOWTO (R_PPC64_ADDR64, /* type */
802 0, /* rightshift */
803 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
804 64, /* bitsize */
805 FALSE, /* pc_relative */
806 0, /* bitpos */
807 complain_overflow_dont, /* complain_on_overflow */
808 bfd_elf_generic_reloc, /* special_function */
809 "R_PPC64_ADDR64", /* name */
810 FALSE, /* partial_inplace */
811 0, /* src_mask */
812 ONES (64), /* dst_mask */
813 FALSE), /* pcrel_offset */
814
815 /* The bits 32-47 of an address. */
816 HOWTO (R_PPC64_ADDR16_HIGHER, /* type */
817 32, /* rightshift */
818 1, /* size (0 = byte, 1 = short, 2 = long) */
819 16, /* bitsize */
820 FALSE, /* pc_relative */
821 0, /* bitpos */
822 complain_overflow_dont, /* complain_on_overflow */
823 bfd_elf_generic_reloc, /* special_function */
824 "R_PPC64_ADDR16_HIGHER", /* name */
825 FALSE, /* partial_inplace */
826 0, /* src_mask */
827 0xffff, /* dst_mask */
828 FALSE), /* pcrel_offset */
829
830 /* The bits 32-47 of an address, plus 1 if the contents of the low
831 16 bits, treated as a signed number, is negative. */
832 HOWTO (R_PPC64_ADDR16_HIGHERA, /* type */
833 32, /* rightshift */
834 1, /* size (0 = byte, 1 = short, 2 = long) */
835 16, /* bitsize */
836 FALSE, /* pc_relative */
837 0, /* bitpos */
838 complain_overflow_dont, /* complain_on_overflow */
839 ppc64_elf_ha_reloc, /* special_function */
840 "R_PPC64_ADDR16_HIGHERA", /* name */
841 FALSE, /* partial_inplace */
842 0, /* src_mask */
843 0xffff, /* dst_mask */
844 FALSE), /* pcrel_offset */
845
846 /* The bits 48-63 of an address. */
847 HOWTO (R_PPC64_ADDR16_HIGHEST,/* type */
848 48, /* rightshift */
849 1, /* size (0 = byte, 1 = short, 2 = long) */
850 16, /* bitsize */
851 FALSE, /* pc_relative */
852 0, /* bitpos */
853 complain_overflow_dont, /* complain_on_overflow */
854 bfd_elf_generic_reloc, /* special_function */
855 "R_PPC64_ADDR16_HIGHEST", /* name */
856 FALSE, /* partial_inplace */
857 0, /* src_mask */
858 0xffff, /* dst_mask */
859 FALSE), /* pcrel_offset */
860
861 /* The bits 48-63 of an address, plus 1 if the contents of the low
862 16 bits, treated as a signed number, is negative. */
863 HOWTO (R_PPC64_ADDR16_HIGHESTA,/* type */
864 48, /* rightshift */
865 1, /* size (0 = byte, 1 = short, 2 = long) */
866 16, /* bitsize */
867 FALSE, /* pc_relative */
868 0, /* bitpos */
869 complain_overflow_dont, /* complain_on_overflow */
870 ppc64_elf_ha_reloc, /* special_function */
871 "R_PPC64_ADDR16_HIGHESTA", /* name */
872 FALSE, /* partial_inplace */
873 0, /* src_mask */
874 0xffff, /* dst_mask */
875 FALSE), /* pcrel_offset */
876
877 /* Like ADDR64, but may be unaligned. */
878 HOWTO (R_PPC64_UADDR64, /* type */
879 0, /* rightshift */
880 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
881 64, /* bitsize */
882 FALSE, /* pc_relative */
883 0, /* bitpos */
884 complain_overflow_dont, /* complain_on_overflow */
885 bfd_elf_generic_reloc, /* special_function */
886 "R_PPC64_UADDR64", /* name */
887 FALSE, /* partial_inplace */
888 0, /* src_mask */
889 ONES (64), /* dst_mask */
890 FALSE), /* pcrel_offset */
891
892 /* 64-bit relative relocation. */
893 HOWTO (R_PPC64_REL64, /* type */
894 0, /* rightshift */
895 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
896 64, /* bitsize */
897 TRUE, /* pc_relative */
898 0, /* bitpos */
899 complain_overflow_dont, /* complain_on_overflow */
900 bfd_elf_generic_reloc, /* special_function */
901 "R_PPC64_REL64", /* name */
902 FALSE, /* partial_inplace */
903 0, /* src_mask */
904 ONES (64), /* dst_mask */
905 TRUE), /* pcrel_offset */
906
907 /* 64-bit relocation to the symbol's procedure linkage table. */
908 HOWTO (R_PPC64_PLT64, /* type */
909 0, /* rightshift */
910 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
911 64, /* bitsize */
912 FALSE, /* pc_relative */
913 0, /* bitpos */
914 complain_overflow_dont, /* complain_on_overflow */
915 ppc64_elf_unhandled_reloc, /* special_function */
916 "R_PPC64_PLT64", /* name */
917 FALSE, /* partial_inplace */
918 0, /* src_mask */
919 ONES (64), /* dst_mask */
920 FALSE), /* pcrel_offset */
921
922 /* 64-bit PC relative relocation to the symbol's procedure linkage
923 table. */
924 /* FIXME: R_PPC64_PLTREL64 not supported. */
925 HOWTO (R_PPC64_PLTREL64, /* type */
926 0, /* rightshift */
927 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
928 64, /* bitsize */
929 TRUE, /* pc_relative */
930 0, /* bitpos */
931 complain_overflow_dont, /* complain_on_overflow */
932 ppc64_elf_unhandled_reloc, /* special_function */
933 "R_PPC64_PLTREL64", /* name */
934 FALSE, /* partial_inplace */
935 0, /* src_mask */
936 ONES (64), /* dst_mask */
937 TRUE), /* pcrel_offset */
938
939 /* 16 bit TOC-relative relocation. */
940
941 /* R_PPC64_TOC16 47 half16* S + A - .TOC. */
942 HOWTO (R_PPC64_TOC16, /* type */
943 0, /* rightshift */
944 1, /* size (0 = byte, 1 = short, 2 = long) */
945 16, /* bitsize */
946 FALSE, /* pc_relative */
947 0, /* bitpos */
948 complain_overflow_signed, /* complain_on_overflow */
949 ppc64_elf_toc_reloc, /* special_function */
950 "R_PPC64_TOC16", /* name */
951 FALSE, /* partial_inplace */
952 0, /* src_mask */
953 0xffff, /* dst_mask */
954 FALSE), /* pcrel_offset */
955
956 /* 16 bit TOC-relative relocation without overflow. */
957
958 /* R_PPC64_TOC16_LO 48 half16 #lo (S + A - .TOC.) */
959 HOWTO (R_PPC64_TOC16_LO, /* type */
960 0, /* rightshift */
961 1, /* size (0 = byte, 1 = short, 2 = long) */
962 16, /* bitsize */
963 FALSE, /* pc_relative */
964 0, /* bitpos */
965 complain_overflow_dont, /* complain_on_overflow */
966 ppc64_elf_toc_reloc, /* special_function */
967 "R_PPC64_TOC16_LO", /* name */
968 FALSE, /* partial_inplace */
969 0, /* src_mask */
970 0xffff, /* dst_mask */
971 FALSE), /* pcrel_offset */
972
973 /* 16 bit TOC-relative relocation, high 16 bits. */
974
975 /* R_PPC64_TOC16_HI 49 half16 #hi (S + A - .TOC.) */
976 HOWTO (R_PPC64_TOC16_HI, /* type */
977 16, /* rightshift */
978 1, /* size (0 = byte, 1 = short, 2 = long) */
979 16, /* bitsize */
980 FALSE, /* pc_relative */
981 0, /* bitpos */
982 complain_overflow_signed, /* complain_on_overflow */
983 ppc64_elf_toc_reloc, /* special_function */
984 "R_PPC64_TOC16_HI", /* name */
985 FALSE, /* partial_inplace */
986 0, /* src_mask */
987 0xffff, /* dst_mask */
988 FALSE), /* pcrel_offset */
989
990 /* 16 bit TOC-relative relocation, high 16 bits, plus 1 if the
991 contents of the low 16 bits, treated as a signed number, is
992 negative. */
993
994 /* R_PPC64_TOC16_HA 50 half16 #ha (S + A - .TOC.) */
995 HOWTO (R_PPC64_TOC16_HA, /* type */
996 16, /* rightshift */
997 1, /* size (0 = byte, 1 = short, 2 = long) */
998 16, /* bitsize */
999 FALSE, /* pc_relative */
1000 0, /* bitpos */
1001 complain_overflow_signed, /* complain_on_overflow */
1002 ppc64_elf_toc_ha_reloc, /* special_function */
1003 "R_PPC64_TOC16_HA", /* name */
1004 FALSE, /* partial_inplace */
1005 0, /* src_mask */
1006 0xffff, /* dst_mask */
1007 FALSE), /* pcrel_offset */
1008
1009 /* 64-bit relocation; insert value of TOC base (.TOC.). */
1010
1011 /* R_PPC64_TOC 51 doubleword64 .TOC. */
1012 HOWTO (R_PPC64_TOC, /* type */
1013 0, /* rightshift */
1014 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1015 64, /* bitsize */
1016 FALSE, /* pc_relative */
1017 0, /* bitpos */
1018 complain_overflow_dont, /* complain_on_overflow */
1019 ppc64_elf_toc64_reloc, /* special_function */
1020 "R_PPC64_TOC", /* name */
1021 FALSE, /* partial_inplace */
1022 0, /* src_mask */
1023 ONES (64), /* dst_mask */
1024 FALSE), /* pcrel_offset */
1025
1026 /* Like R_PPC64_GOT16, but also informs the link editor that the
1027 value to relocate may (!) refer to a PLT entry which the link
1028 editor (a) may replace with the symbol value. If the link editor
1029 is unable to fully resolve the symbol, it may (b) create a PLT
1030 entry and store the address to the new PLT entry in the GOT.
1031 This permits lazy resolution of function symbols at run time.
1032 The link editor may also skip all of this and just (c) emit a
1033 R_PPC64_GLOB_DAT to tie the symbol to the GOT entry. */
1034 /* FIXME: R_PPC64_PLTGOT16 not implemented. */
1035 HOWTO (R_PPC64_PLTGOT16, /* type */
1036 0, /* rightshift */
1037 1, /* size (0 = byte, 1 = short, 2 = long) */
1038 16, /* bitsize */
1039 FALSE, /* pc_relative */
1040 0, /* bitpos */
1041 complain_overflow_signed, /* complain_on_overflow */
1042 ppc64_elf_unhandled_reloc, /* special_function */
1043 "R_PPC64_PLTGOT16", /* name */
1044 FALSE, /* partial_inplace */
1045 0, /* src_mask */
1046 0xffff, /* dst_mask */
1047 FALSE), /* pcrel_offset */
1048
1049 /* Like R_PPC64_PLTGOT16, but without overflow. */
1050 /* FIXME: R_PPC64_PLTGOT16_LO not implemented. */
1051 HOWTO (R_PPC64_PLTGOT16_LO, /* type */
1052 0, /* rightshift */
1053 1, /* size (0 = byte, 1 = short, 2 = long) */
1054 16, /* bitsize */
1055 FALSE, /* pc_relative */
1056 0, /* bitpos */
1057 complain_overflow_dont, /* complain_on_overflow */
1058 ppc64_elf_unhandled_reloc, /* special_function */
1059 "R_PPC64_PLTGOT16_LO", /* name */
1060 FALSE, /* partial_inplace */
1061 0, /* src_mask */
1062 0xffff, /* dst_mask */
1063 FALSE), /* pcrel_offset */
1064
1065 /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address. */
1066 /* FIXME: R_PPC64_PLTGOT16_HI not implemented. */
1067 HOWTO (R_PPC64_PLTGOT16_HI, /* type */
1068 16, /* rightshift */
1069 1, /* size (0 = byte, 1 = short, 2 = long) */
1070 16, /* bitsize */
1071 FALSE, /* pc_relative */
1072 0, /* bitpos */
1073 complain_overflow_signed, /* complain_on_overflow */
1074 ppc64_elf_unhandled_reloc, /* special_function */
1075 "R_PPC64_PLTGOT16_HI", /* name */
1076 FALSE, /* partial_inplace */
1077 0, /* src_mask */
1078 0xffff, /* dst_mask */
1079 FALSE), /* pcrel_offset */
1080
1081 /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address, plus
1082 1 if the contents of the low 16 bits, treated as a signed number,
1083 is negative. */
1084 /* FIXME: R_PPC64_PLTGOT16_HA not implemented. */
1085 HOWTO (R_PPC64_PLTGOT16_HA, /* type */
1086 16, /* rightshift */
1087 1, /* size (0 = byte, 1 = short, 2 = long) */
1088 16, /* bitsize */
1089 FALSE, /* pc_relative */
1090 0, /* bitpos */
1091 complain_overflow_signed, /* complain_on_overflow */
1092 ppc64_elf_unhandled_reloc, /* special_function */
1093 "R_PPC64_PLTGOT16_HA", /* name */
1094 FALSE, /* partial_inplace */
1095 0, /* src_mask */
1096 0xffff, /* dst_mask */
1097 FALSE), /* pcrel_offset */
1098
1099 /* Like R_PPC64_ADDR16, but for instructions with a DS field. */
1100 HOWTO (R_PPC64_ADDR16_DS, /* type */
1101 0, /* rightshift */
1102 1, /* size (0 = byte, 1 = short, 2 = long) */
1103 16, /* bitsize */
1104 FALSE, /* pc_relative */
1105 0, /* bitpos */
1106 complain_overflow_signed, /* complain_on_overflow */
1107 bfd_elf_generic_reloc, /* special_function */
1108 "R_PPC64_ADDR16_DS", /* name */
1109 FALSE, /* partial_inplace */
1110 0, /* src_mask */
1111 0xfffc, /* dst_mask */
1112 FALSE), /* pcrel_offset */
1113
1114 /* Like R_PPC64_ADDR16_LO, but for instructions with a DS field. */
1115 HOWTO (R_PPC64_ADDR16_LO_DS, /* type */
1116 0, /* rightshift */
1117 1, /* size (0 = byte, 1 = short, 2 = long) */
1118 16, /* bitsize */
1119 FALSE, /* pc_relative */
1120 0, /* bitpos */
1121 complain_overflow_dont,/* complain_on_overflow */
1122 bfd_elf_generic_reloc, /* special_function */
1123 "R_PPC64_ADDR16_LO_DS",/* name */
1124 FALSE, /* partial_inplace */
1125 0, /* src_mask */
1126 0xfffc, /* dst_mask */
1127 FALSE), /* pcrel_offset */
1128
1129 /* Like R_PPC64_GOT16, but for instructions with a DS field. */
1130 HOWTO (R_PPC64_GOT16_DS, /* type */
1131 0, /* rightshift */
1132 1, /* size (0 = byte, 1 = short, 2 = long) */
1133 16, /* bitsize */
1134 FALSE, /* pc_relative */
1135 0, /* bitpos */
1136 complain_overflow_signed, /* complain_on_overflow */
1137 ppc64_elf_unhandled_reloc, /* special_function */
1138 "R_PPC64_GOT16_DS", /* name */
1139 FALSE, /* partial_inplace */
1140 0, /* src_mask */
1141 0xfffc, /* dst_mask */
1142 FALSE), /* pcrel_offset */
1143
1144 /* Like R_PPC64_GOT16_LO, but for instructions with a DS field. */
1145 HOWTO (R_PPC64_GOT16_LO_DS, /* type */
1146 0, /* rightshift */
1147 1, /* size (0 = byte, 1 = short, 2 = long) */
1148 16, /* bitsize */
1149 FALSE, /* pc_relative */
1150 0, /* bitpos */
1151 complain_overflow_dont, /* complain_on_overflow */
1152 ppc64_elf_unhandled_reloc, /* special_function */
1153 "R_PPC64_GOT16_LO_DS", /* name */
1154 FALSE, /* partial_inplace */
1155 0, /* src_mask */
1156 0xfffc, /* dst_mask */
1157 FALSE), /* pcrel_offset */
1158
1159 /* Like R_PPC64_PLT16_LO, but for instructions with a DS field. */
1160 HOWTO (R_PPC64_PLT16_LO_DS, /* type */
1161 0, /* rightshift */
1162 1, /* size (0 = byte, 1 = short, 2 = long) */
1163 16, /* bitsize */
1164 FALSE, /* pc_relative */
1165 0, /* bitpos */
1166 complain_overflow_dont, /* complain_on_overflow */
1167 ppc64_elf_unhandled_reloc, /* special_function */
1168 "R_PPC64_PLT16_LO_DS", /* name */
1169 FALSE, /* partial_inplace */
1170 0, /* src_mask */
1171 0xfffc, /* dst_mask */
1172 FALSE), /* pcrel_offset */
1173
1174 /* Like R_PPC64_SECTOFF, but for instructions with a DS field. */
1175 HOWTO (R_PPC64_SECTOFF_DS, /* type */
1176 0, /* rightshift */
1177 1, /* size (0 = byte, 1 = short, 2 = long) */
1178 16, /* bitsize */
1179 FALSE, /* pc_relative */
1180 0, /* bitpos */
1181 complain_overflow_signed, /* complain_on_overflow */
1182 ppc64_elf_sectoff_reloc, /* special_function */
1183 "R_PPC64_SECTOFF_DS", /* name */
1184 FALSE, /* partial_inplace */
1185 0, /* src_mask */
1186 0xfffc, /* dst_mask */
1187 FALSE), /* pcrel_offset */
1188
1189 /* Like R_PPC64_SECTOFF_LO, but for instructions with a DS field. */
1190 HOWTO (R_PPC64_SECTOFF_LO_DS, /* type */
1191 0, /* rightshift */
1192 1, /* size (0 = byte, 1 = short, 2 = long) */
1193 16, /* bitsize */
1194 FALSE, /* pc_relative */
1195 0, /* bitpos */
1196 complain_overflow_dont, /* complain_on_overflow */
1197 ppc64_elf_sectoff_reloc, /* special_function */
1198 "R_PPC64_SECTOFF_LO_DS",/* name */
1199 FALSE, /* partial_inplace */
1200 0, /* src_mask */
1201 0xfffc, /* dst_mask */
1202 FALSE), /* pcrel_offset */
1203
1204 /* Like R_PPC64_TOC16, but for instructions with a DS field. */
1205 HOWTO (R_PPC64_TOC16_DS, /* type */
1206 0, /* rightshift */
1207 1, /* size (0 = byte, 1 = short, 2 = long) */
1208 16, /* bitsize */
1209 FALSE, /* pc_relative */
1210 0, /* bitpos */
1211 complain_overflow_signed, /* complain_on_overflow */
1212 ppc64_elf_toc_reloc, /* special_function */
1213 "R_PPC64_TOC16_DS", /* name */
1214 FALSE, /* partial_inplace */
1215 0, /* src_mask */
1216 0xfffc, /* dst_mask */
1217 FALSE), /* pcrel_offset */
1218
1219 /* Like R_PPC64_TOC16_LO, but for instructions with a DS field. */
1220 HOWTO (R_PPC64_TOC16_LO_DS, /* type */
1221 0, /* rightshift */
1222 1, /* size (0 = byte, 1 = short, 2 = long) */
1223 16, /* bitsize */
1224 FALSE, /* pc_relative */
1225 0, /* bitpos */
1226 complain_overflow_dont, /* complain_on_overflow */
1227 ppc64_elf_toc_reloc, /* special_function */
1228 "R_PPC64_TOC16_LO_DS", /* name */
1229 FALSE, /* partial_inplace */
1230 0, /* src_mask */
1231 0xfffc, /* dst_mask */
1232 FALSE), /* pcrel_offset */
1233
1234 /* Like R_PPC64_PLTGOT16, but for instructions with a DS field. */
1235 /* FIXME: R_PPC64_PLTGOT16_DS not implemented. */
1236 HOWTO (R_PPC64_PLTGOT16_DS, /* type */
1237 0, /* rightshift */
1238 1, /* size (0 = byte, 1 = short, 2 = long) */
1239 16, /* bitsize */
1240 FALSE, /* pc_relative */
1241 0, /* bitpos */
1242 complain_overflow_signed, /* complain_on_overflow */
1243 ppc64_elf_unhandled_reloc, /* special_function */
1244 "R_PPC64_PLTGOT16_DS", /* name */
1245 FALSE, /* partial_inplace */
1246 0, /* src_mask */
1247 0xfffc, /* dst_mask */
1248 FALSE), /* pcrel_offset */
1249
1250 /* Like R_PPC64_PLTGOT16_LO, but for instructions with a DS field. */
1251 /* FIXME: R_PPC64_PLTGOT16_LO not implemented. */
1252 HOWTO (R_PPC64_PLTGOT16_LO_DS,/* type */
1253 0, /* rightshift */
1254 1, /* size (0 = byte, 1 = short, 2 = long) */
1255 16, /* bitsize */
1256 FALSE, /* pc_relative */
1257 0, /* bitpos */
1258 complain_overflow_dont, /* complain_on_overflow */
1259 ppc64_elf_unhandled_reloc, /* special_function */
1260 "R_PPC64_PLTGOT16_LO_DS",/* name */
1261 FALSE, /* partial_inplace */
1262 0, /* src_mask */
1263 0xfffc, /* dst_mask */
1264 FALSE), /* pcrel_offset */
1265
1266 /* Marker relocs for TLS. */
1267 HOWTO (R_PPC64_TLS,
1268 0, /* rightshift */
1269 2, /* size (0 = byte, 1 = short, 2 = long) */
1270 32, /* bitsize */
1271 FALSE, /* pc_relative */
1272 0, /* bitpos */
1273 complain_overflow_dont, /* complain_on_overflow */
1274 bfd_elf_generic_reloc, /* special_function */
1275 "R_PPC64_TLS", /* name */
1276 FALSE, /* partial_inplace */
1277 0, /* src_mask */
1278 0, /* dst_mask */
1279 FALSE), /* pcrel_offset */
1280
1281 HOWTO (R_PPC64_TLSGD,
1282 0, /* rightshift */
1283 2, /* size (0 = byte, 1 = short, 2 = long) */
1284 32, /* bitsize */
1285 FALSE, /* pc_relative */
1286 0, /* bitpos */
1287 complain_overflow_dont, /* complain_on_overflow */
1288 bfd_elf_generic_reloc, /* special_function */
1289 "R_PPC64_TLSGD", /* name */
1290 FALSE, /* partial_inplace */
1291 0, /* src_mask */
1292 0, /* dst_mask */
1293 FALSE), /* pcrel_offset */
1294
1295 HOWTO (R_PPC64_TLSLD,
1296 0, /* rightshift */
1297 2, /* size (0 = byte, 1 = short, 2 = long) */
1298 32, /* bitsize */
1299 FALSE, /* pc_relative */
1300 0, /* bitpos */
1301 complain_overflow_dont, /* complain_on_overflow */
1302 bfd_elf_generic_reloc, /* special_function */
1303 "R_PPC64_TLSLD", /* name */
1304 FALSE, /* partial_inplace */
1305 0, /* src_mask */
1306 0, /* dst_mask */
1307 FALSE), /* pcrel_offset */
1308
1309 HOWTO (R_PPC64_TOCSAVE,
1310 0, /* rightshift */
1311 2, /* size (0 = byte, 1 = short, 2 = long) */
1312 32, /* bitsize */
1313 FALSE, /* pc_relative */
1314 0, /* bitpos */
1315 complain_overflow_dont, /* complain_on_overflow */
1316 bfd_elf_generic_reloc, /* special_function */
1317 "R_PPC64_TOCSAVE", /* name */
1318 FALSE, /* partial_inplace */
1319 0, /* src_mask */
1320 0, /* dst_mask */
1321 FALSE), /* pcrel_offset */
1322
1323 /* Computes the load module index of the load module that contains the
1324 definition of its TLS sym. */
1325 HOWTO (R_PPC64_DTPMOD64,
1326 0, /* rightshift */
1327 4, /* size (0 = byte, 1 = short, 2 = long) */
1328 64, /* bitsize */
1329 FALSE, /* pc_relative */
1330 0, /* bitpos */
1331 complain_overflow_dont, /* complain_on_overflow */
1332 ppc64_elf_unhandled_reloc, /* special_function */
1333 "R_PPC64_DTPMOD64", /* name */
1334 FALSE, /* partial_inplace */
1335 0, /* src_mask */
1336 ONES (64), /* dst_mask */
1337 FALSE), /* pcrel_offset */
1338
1339 /* Computes a dtv-relative displacement, the difference between the value
1340 of sym+add and the base address of the thread-local storage block that
1341 contains the definition of sym, minus 0x8000. */
1342 HOWTO (R_PPC64_DTPREL64,
1343 0, /* rightshift */
1344 4, /* size (0 = byte, 1 = short, 2 = long) */
1345 64, /* bitsize */
1346 FALSE, /* pc_relative */
1347 0, /* bitpos */
1348 complain_overflow_dont, /* complain_on_overflow */
1349 ppc64_elf_unhandled_reloc, /* special_function */
1350 "R_PPC64_DTPREL64", /* name */
1351 FALSE, /* partial_inplace */
1352 0, /* src_mask */
1353 ONES (64), /* dst_mask */
1354 FALSE), /* pcrel_offset */
1355
1356 /* A 16 bit dtprel reloc. */
1357 HOWTO (R_PPC64_DTPREL16,
1358 0, /* rightshift */
1359 1, /* size (0 = byte, 1 = short, 2 = long) */
1360 16, /* bitsize */
1361 FALSE, /* pc_relative */
1362 0, /* bitpos */
1363 complain_overflow_signed, /* complain_on_overflow */
1364 ppc64_elf_unhandled_reloc, /* special_function */
1365 "R_PPC64_DTPREL16", /* name */
1366 FALSE, /* partial_inplace */
1367 0, /* src_mask */
1368 0xffff, /* dst_mask */
1369 FALSE), /* pcrel_offset */
1370
1371 /* Like DTPREL16, but no overflow. */
1372 HOWTO (R_PPC64_DTPREL16_LO,
1373 0, /* rightshift */
1374 1, /* size (0 = byte, 1 = short, 2 = long) */
1375 16, /* bitsize */
1376 FALSE, /* pc_relative */
1377 0, /* bitpos */
1378 complain_overflow_dont, /* complain_on_overflow */
1379 ppc64_elf_unhandled_reloc, /* special_function */
1380 "R_PPC64_DTPREL16_LO", /* name */
1381 FALSE, /* partial_inplace */
1382 0, /* src_mask */
1383 0xffff, /* dst_mask */
1384 FALSE), /* pcrel_offset */
1385
1386 /* Like DTPREL16_LO, but next higher group of 16 bits. */
1387 HOWTO (R_PPC64_DTPREL16_HI,
1388 16, /* rightshift */
1389 1, /* size (0 = byte, 1 = short, 2 = long) */
1390 16, /* bitsize */
1391 FALSE, /* pc_relative */
1392 0, /* bitpos */
1393 complain_overflow_signed, /* complain_on_overflow */
1394 ppc64_elf_unhandled_reloc, /* special_function */
1395 "R_PPC64_DTPREL16_HI", /* name */
1396 FALSE, /* partial_inplace */
1397 0, /* src_mask */
1398 0xffff, /* dst_mask */
1399 FALSE), /* pcrel_offset */
1400
1401 /* Like DTPREL16_HI, but adjust for low 16 bits. */
1402 HOWTO (R_PPC64_DTPREL16_HA,
1403 16, /* rightshift */
1404 1, /* size (0 = byte, 1 = short, 2 = long) */
1405 16, /* bitsize */
1406 FALSE, /* pc_relative */
1407 0, /* bitpos */
1408 complain_overflow_signed, /* complain_on_overflow */
1409 ppc64_elf_unhandled_reloc, /* special_function */
1410 "R_PPC64_DTPREL16_HA", /* name */
1411 FALSE, /* partial_inplace */
1412 0, /* src_mask */
1413 0xffff, /* dst_mask */
1414 FALSE), /* pcrel_offset */
1415
1416 /* Like DTPREL16_HI, but next higher group of 16 bits. */
1417 HOWTO (R_PPC64_DTPREL16_HIGHER,
1418 32, /* rightshift */
1419 1, /* size (0 = byte, 1 = short, 2 = long) */
1420 16, /* bitsize */
1421 FALSE, /* pc_relative */
1422 0, /* bitpos */
1423 complain_overflow_dont, /* complain_on_overflow */
1424 ppc64_elf_unhandled_reloc, /* special_function */
1425 "R_PPC64_DTPREL16_HIGHER", /* name */
1426 FALSE, /* partial_inplace */
1427 0, /* src_mask */
1428 0xffff, /* dst_mask */
1429 FALSE), /* pcrel_offset */
1430
1431 /* Like DTPREL16_HIGHER, but adjust for low 16 bits. */
1432 HOWTO (R_PPC64_DTPREL16_HIGHERA,
1433 32, /* rightshift */
1434 1, /* size (0 = byte, 1 = short, 2 = long) */
1435 16, /* bitsize */
1436 FALSE, /* pc_relative */
1437 0, /* bitpos */
1438 complain_overflow_dont, /* complain_on_overflow */
1439 ppc64_elf_unhandled_reloc, /* special_function */
1440 "R_PPC64_DTPREL16_HIGHERA", /* name */
1441 FALSE, /* partial_inplace */
1442 0, /* src_mask */
1443 0xffff, /* dst_mask */
1444 FALSE), /* pcrel_offset */
1445
1446 /* Like DTPREL16_HIGHER, but next higher group of 16 bits. */
1447 HOWTO (R_PPC64_DTPREL16_HIGHEST,
1448 48, /* rightshift */
1449 1, /* size (0 = byte, 1 = short, 2 = long) */
1450 16, /* bitsize */
1451 FALSE, /* pc_relative */
1452 0, /* bitpos */
1453 complain_overflow_dont, /* complain_on_overflow */
1454 ppc64_elf_unhandled_reloc, /* special_function */
1455 "R_PPC64_DTPREL16_HIGHEST", /* name */
1456 FALSE, /* partial_inplace */
1457 0, /* src_mask */
1458 0xffff, /* dst_mask */
1459 FALSE), /* pcrel_offset */
1460
1461 /* Like DTPREL16_HIGHEST, but adjust for low 16 bits. */
1462 HOWTO (R_PPC64_DTPREL16_HIGHESTA,
1463 48, /* rightshift */
1464 1, /* size (0 = byte, 1 = short, 2 = long) */
1465 16, /* bitsize */
1466 FALSE, /* pc_relative */
1467 0, /* bitpos */
1468 complain_overflow_dont, /* complain_on_overflow */
1469 ppc64_elf_unhandled_reloc, /* special_function */
1470 "R_PPC64_DTPREL16_HIGHESTA", /* name */
1471 FALSE, /* partial_inplace */
1472 0, /* src_mask */
1473 0xffff, /* dst_mask */
1474 FALSE), /* pcrel_offset */
1475
1476 /* Like DTPREL16, but for insns with a DS field. */
1477 HOWTO (R_PPC64_DTPREL16_DS,
1478 0, /* rightshift */
1479 1, /* size (0 = byte, 1 = short, 2 = long) */
1480 16, /* bitsize */
1481 FALSE, /* pc_relative */
1482 0, /* bitpos */
1483 complain_overflow_signed, /* complain_on_overflow */
1484 ppc64_elf_unhandled_reloc, /* special_function */
1485 "R_PPC64_DTPREL16_DS", /* name */
1486 FALSE, /* partial_inplace */
1487 0, /* src_mask */
1488 0xfffc, /* dst_mask */
1489 FALSE), /* pcrel_offset */
1490
1491 /* Like DTPREL16_DS, but no overflow. */
1492 HOWTO (R_PPC64_DTPREL16_LO_DS,
1493 0, /* rightshift */
1494 1, /* size (0 = byte, 1 = short, 2 = long) */
1495 16, /* bitsize */
1496 FALSE, /* pc_relative */
1497 0, /* bitpos */
1498 complain_overflow_dont, /* complain_on_overflow */
1499 ppc64_elf_unhandled_reloc, /* special_function */
1500 "R_PPC64_DTPREL16_LO_DS", /* name */
1501 FALSE, /* partial_inplace */
1502 0, /* src_mask */
1503 0xfffc, /* dst_mask */
1504 FALSE), /* pcrel_offset */
1505
1506 /* Computes a tp-relative displacement, the difference between the value of
1507 sym+add and the value of the thread pointer (r13). */
1508 HOWTO (R_PPC64_TPREL64,
1509 0, /* rightshift */
1510 4, /* size (0 = byte, 1 = short, 2 = long) */
1511 64, /* bitsize */
1512 FALSE, /* pc_relative */
1513 0, /* bitpos */
1514 complain_overflow_dont, /* complain_on_overflow */
1515 ppc64_elf_unhandled_reloc, /* special_function */
1516 "R_PPC64_TPREL64", /* name */
1517 FALSE, /* partial_inplace */
1518 0, /* src_mask */
1519 ONES (64), /* dst_mask */
1520 FALSE), /* pcrel_offset */
1521
1522 /* A 16 bit tprel reloc. */
1523 HOWTO (R_PPC64_TPREL16,
1524 0, /* rightshift */
1525 1, /* size (0 = byte, 1 = short, 2 = long) */
1526 16, /* bitsize */
1527 FALSE, /* pc_relative */
1528 0, /* bitpos */
1529 complain_overflow_signed, /* complain_on_overflow */
1530 ppc64_elf_unhandled_reloc, /* special_function */
1531 "R_PPC64_TPREL16", /* name */
1532 FALSE, /* partial_inplace */
1533 0, /* src_mask */
1534 0xffff, /* dst_mask */
1535 FALSE), /* pcrel_offset */
1536
1537 /* Like TPREL16, but no overflow. */
1538 HOWTO (R_PPC64_TPREL16_LO,
1539 0, /* rightshift */
1540 1, /* size (0 = byte, 1 = short, 2 = long) */
1541 16, /* bitsize */
1542 FALSE, /* pc_relative */
1543 0, /* bitpos */
1544 complain_overflow_dont, /* complain_on_overflow */
1545 ppc64_elf_unhandled_reloc, /* special_function */
1546 "R_PPC64_TPREL16_LO", /* name */
1547 FALSE, /* partial_inplace */
1548 0, /* src_mask */
1549 0xffff, /* dst_mask */
1550 FALSE), /* pcrel_offset */
1551
1552 /* Like TPREL16_LO, but next higher group of 16 bits. */
1553 HOWTO (R_PPC64_TPREL16_HI,
1554 16, /* rightshift */
1555 1, /* size (0 = byte, 1 = short, 2 = long) */
1556 16, /* bitsize */
1557 FALSE, /* pc_relative */
1558 0, /* bitpos */
1559 complain_overflow_signed, /* complain_on_overflow */
1560 ppc64_elf_unhandled_reloc, /* special_function */
1561 "R_PPC64_TPREL16_HI", /* name */
1562 FALSE, /* partial_inplace */
1563 0, /* src_mask */
1564 0xffff, /* dst_mask */
1565 FALSE), /* pcrel_offset */
1566
1567 /* Like TPREL16_HI, but adjust for low 16 bits. */
1568 HOWTO (R_PPC64_TPREL16_HA,
1569 16, /* rightshift */
1570 1, /* size (0 = byte, 1 = short, 2 = long) */
1571 16, /* bitsize */
1572 FALSE, /* pc_relative */
1573 0, /* bitpos */
1574 complain_overflow_signed, /* complain_on_overflow */
1575 ppc64_elf_unhandled_reloc, /* special_function */
1576 "R_PPC64_TPREL16_HA", /* name */
1577 FALSE, /* partial_inplace */
1578 0, /* src_mask */
1579 0xffff, /* dst_mask */
1580 FALSE), /* pcrel_offset */
1581
1582 /* Like TPREL16_HI, but next higher group of 16 bits. */
1583 HOWTO (R_PPC64_TPREL16_HIGHER,
1584 32, /* rightshift */
1585 1, /* size (0 = byte, 1 = short, 2 = long) */
1586 16, /* bitsize */
1587 FALSE, /* pc_relative */
1588 0, /* bitpos */
1589 complain_overflow_dont, /* complain_on_overflow */
1590 ppc64_elf_unhandled_reloc, /* special_function */
1591 "R_PPC64_TPREL16_HIGHER", /* name */
1592 FALSE, /* partial_inplace */
1593 0, /* src_mask */
1594 0xffff, /* dst_mask */
1595 FALSE), /* pcrel_offset */
1596
1597 /* Like TPREL16_HIGHER, but adjust for low 16 bits. */
1598 HOWTO (R_PPC64_TPREL16_HIGHERA,
1599 32, /* rightshift */
1600 1, /* size (0 = byte, 1 = short, 2 = long) */
1601 16, /* bitsize */
1602 FALSE, /* pc_relative */
1603 0, /* bitpos */
1604 complain_overflow_dont, /* complain_on_overflow */
1605 ppc64_elf_unhandled_reloc, /* special_function */
1606 "R_PPC64_TPREL16_HIGHERA", /* name */
1607 FALSE, /* partial_inplace */
1608 0, /* src_mask */
1609 0xffff, /* dst_mask */
1610 FALSE), /* pcrel_offset */
1611
1612 /* Like TPREL16_HIGHER, but next higher group of 16 bits. */
1613 HOWTO (R_PPC64_TPREL16_HIGHEST,
1614 48, /* rightshift */
1615 1, /* size (0 = byte, 1 = short, 2 = long) */
1616 16, /* bitsize */
1617 FALSE, /* pc_relative */
1618 0, /* bitpos */
1619 complain_overflow_dont, /* complain_on_overflow */
1620 ppc64_elf_unhandled_reloc, /* special_function */
1621 "R_PPC64_TPREL16_HIGHEST", /* name */
1622 FALSE, /* partial_inplace */
1623 0, /* src_mask */
1624 0xffff, /* dst_mask */
1625 FALSE), /* pcrel_offset */
1626
1627 /* Like TPREL16_HIGHEST, but adjust for low 16 bits. */
1628 HOWTO (R_PPC64_TPREL16_HIGHESTA,
1629 48, /* rightshift */
1630 1, /* size (0 = byte, 1 = short, 2 = long) */
1631 16, /* bitsize */
1632 FALSE, /* pc_relative */
1633 0, /* bitpos */
1634 complain_overflow_dont, /* complain_on_overflow */
1635 ppc64_elf_unhandled_reloc, /* special_function */
1636 "R_PPC64_TPREL16_HIGHESTA", /* name */
1637 FALSE, /* partial_inplace */
1638 0, /* src_mask */
1639 0xffff, /* dst_mask */
1640 FALSE), /* pcrel_offset */
1641
1642 /* Like TPREL16, but for insns with a DS field. */
1643 HOWTO (R_PPC64_TPREL16_DS,
1644 0, /* rightshift */
1645 1, /* size (0 = byte, 1 = short, 2 = long) */
1646 16, /* bitsize */
1647 FALSE, /* pc_relative */
1648 0, /* bitpos */
1649 complain_overflow_signed, /* complain_on_overflow */
1650 ppc64_elf_unhandled_reloc, /* special_function */
1651 "R_PPC64_TPREL16_DS", /* name */
1652 FALSE, /* partial_inplace */
1653 0, /* src_mask */
1654 0xfffc, /* dst_mask */
1655 FALSE), /* pcrel_offset */
1656
1657 /* Like TPREL16_DS, but no overflow. */
1658 HOWTO (R_PPC64_TPREL16_LO_DS,
1659 0, /* rightshift */
1660 1, /* size (0 = byte, 1 = short, 2 = long) */
1661 16, /* bitsize */
1662 FALSE, /* pc_relative */
1663 0, /* bitpos */
1664 complain_overflow_dont, /* complain_on_overflow */
1665 ppc64_elf_unhandled_reloc, /* special_function */
1666 "R_PPC64_TPREL16_LO_DS", /* name */
1667 FALSE, /* partial_inplace */
1668 0, /* src_mask */
1669 0xfffc, /* dst_mask */
1670 FALSE), /* pcrel_offset */
1671
1672 /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1673 with values (sym+add)@dtpmod and (sym+add)@dtprel, and computes the offset
1674 to the first entry relative to the TOC base (r2). */
1675 HOWTO (R_PPC64_GOT_TLSGD16,
1676 0, /* rightshift */
1677 1, /* size (0 = byte, 1 = short, 2 = long) */
1678 16, /* bitsize */
1679 FALSE, /* pc_relative */
1680 0, /* bitpos */
1681 complain_overflow_signed, /* complain_on_overflow */
1682 ppc64_elf_unhandled_reloc, /* special_function */
1683 "R_PPC64_GOT_TLSGD16", /* name */
1684 FALSE, /* partial_inplace */
1685 0, /* src_mask */
1686 0xffff, /* dst_mask */
1687 FALSE), /* pcrel_offset */
1688
1689 /* Like GOT_TLSGD16, but no overflow. */
1690 HOWTO (R_PPC64_GOT_TLSGD16_LO,
1691 0, /* rightshift */
1692 1, /* size (0 = byte, 1 = short, 2 = long) */
1693 16, /* bitsize */
1694 FALSE, /* pc_relative */
1695 0, /* bitpos */
1696 complain_overflow_dont, /* complain_on_overflow */
1697 ppc64_elf_unhandled_reloc, /* special_function */
1698 "R_PPC64_GOT_TLSGD16_LO", /* name */
1699 FALSE, /* partial_inplace */
1700 0, /* src_mask */
1701 0xffff, /* dst_mask */
1702 FALSE), /* pcrel_offset */
1703
1704 /* Like GOT_TLSGD16_LO, but next higher group of 16 bits. */
1705 HOWTO (R_PPC64_GOT_TLSGD16_HI,
1706 16, /* rightshift */
1707 1, /* size (0 = byte, 1 = short, 2 = long) */
1708 16, /* bitsize */
1709 FALSE, /* pc_relative */
1710 0, /* bitpos */
1711 complain_overflow_signed, /* complain_on_overflow */
1712 ppc64_elf_unhandled_reloc, /* special_function */
1713 "R_PPC64_GOT_TLSGD16_HI", /* name */
1714 FALSE, /* partial_inplace */
1715 0, /* src_mask */
1716 0xffff, /* dst_mask */
1717 FALSE), /* pcrel_offset */
1718
1719 /* Like GOT_TLSGD16_HI, but adjust for low 16 bits. */
1720 HOWTO (R_PPC64_GOT_TLSGD16_HA,
1721 16, /* rightshift */
1722 1, /* size (0 = byte, 1 = short, 2 = long) */
1723 16, /* bitsize */
1724 FALSE, /* pc_relative */
1725 0, /* bitpos */
1726 complain_overflow_signed, /* complain_on_overflow */
1727 ppc64_elf_unhandled_reloc, /* special_function */
1728 "R_PPC64_GOT_TLSGD16_HA", /* name */
1729 FALSE, /* partial_inplace */
1730 0, /* src_mask */
1731 0xffff, /* dst_mask */
1732 FALSE), /* pcrel_offset */
1733
1734 /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1735 with values (sym+add)@dtpmod and zero, and computes the offset to the
1736 first entry relative to the TOC base (r2). */
1737 HOWTO (R_PPC64_GOT_TLSLD16,
1738 0, /* rightshift */
1739 1, /* size (0 = byte, 1 = short, 2 = long) */
1740 16, /* bitsize */
1741 FALSE, /* pc_relative */
1742 0, /* bitpos */
1743 complain_overflow_signed, /* complain_on_overflow */
1744 ppc64_elf_unhandled_reloc, /* special_function */
1745 "R_PPC64_GOT_TLSLD16", /* name */
1746 FALSE, /* partial_inplace */
1747 0, /* src_mask */
1748 0xffff, /* dst_mask */
1749 FALSE), /* pcrel_offset */
1750
1751 /* Like GOT_TLSLD16, but no overflow. */
1752 HOWTO (R_PPC64_GOT_TLSLD16_LO,
1753 0, /* rightshift */
1754 1, /* size (0 = byte, 1 = short, 2 = long) */
1755 16, /* bitsize */
1756 FALSE, /* pc_relative */
1757 0, /* bitpos */
1758 complain_overflow_dont, /* complain_on_overflow */
1759 ppc64_elf_unhandled_reloc, /* special_function */
1760 "R_PPC64_GOT_TLSLD16_LO", /* name */
1761 FALSE, /* partial_inplace */
1762 0, /* src_mask */
1763 0xffff, /* dst_mask */
1764 FALSE), /* pcrel_offset */
1765
1766 /* Like GOT_TLSLD16_LO, but next higher group of 16 bits. */
1767 HOWTO (R_PPC64_GOT_TLSLD16_HI,
1768 16, /* rightshift */
1769 1, /* size (0 = byte, 1 = short, 2 = long) */
1770 16, /* bitsize */
1771 FALSE, /* pc_relative */
1772 0, /* bitpos */
1773 complain_overflow_signed, /* complain_on_overflow */
1774 ppc64_elf_unhandled_reloc, /* special_function */
1775 "R_PPC64_GOT_TLSLD16_HI", /* name */
1776 FALSE, /* partial_inplace */
1777 0, /* src_mask */
1778 0xffff, /* dst_mask */
1779 FALSE), /* pcrel_offset */
1780
1781 /* Like GOT_TLSLD16_HI, but adjust for low 16 bits. */
1782 HOWTO (R_PPC64_GOT_TLSLD16_HA,
1783 16, /* rightshift */
1784 1, /* size (0 = byte, 1 = short, 2 = long) */
1785 16, /* bitsize */
1786 FALSE, /* pc_relative */
1787 0, /* bitpos */
1788 complain_overflow_signed, /* complain_on_overflow */
1789 ppc64_elf_unhandled_reloc, /* special_function */
1790 "R_PPC64_GOT_TLSLD16_HA", /* name */
1791 FALSE, /* partial_inplace */
1792 0, /* src_mask */
1793 0xffff, /* dst_mask */
1794 FALSE), /* pcrel_offset */
1795
1796 /* Allocates an entry in the GOT with value (sym+add)@dtprel, and computes
1797 the offset to the entry relative to the TOC base (r2). */
1798 HOWTO (R_PPC64_GOT_DTPREL16_DS,
1799 0, /* rightshift */
1800 1, /* size (0 = byte, 1 = short, 2 = long) */
1801 16, /* bitsize */
1802 FALSE, /* pc_relative */
1803 0, /* bitpos */
1804 complain_overflow_signed, /* complain_on_overflow */
1805 ppc64_elf_unhandled_reloc, /* special_function */
1806 "R_PPC64_GOT_DTPREL16_DS", /* name */
1807 FALSE, /* partial_inplace */
1808 0, /* src_mask */
1809 0xfffc, /* dst_mask */
1810 FALSE), /* pcrel_offset */
1811
1812 /* Like GOT_DTPREL16_DS, but no overflow. */
1813 HOWTO (R_PPC64_GOT_DTPREL16_LO_DS,
1814 0, /* rightshift */
1815 1, /* size (0 = byte, 1 = short, 2 = long) */
1816 16, /* bitsize */
1817 FALSE, /* pc_relative */
1818 0, /* bitpos */
1819 complain_overflow_dont, /* complain_on_overflow */
1820 ppc64_elf_unhandled_reloc, /* special_function */
1821 "R_PPC64_GOT_DTPREL16_LO_DS", /* name */
1822 FALSE, /* partial_inplace */
1823 0, /* src_mask */
1824 0xfffc, /* dst_mask */
1825 FALSE), /* pcrel_offset */
1826
1827 /* Like GOT_DTPREL16_LO_DS, but next higher group of 16 bits. */
1828 HOWTO (R_PPC64_GOT_DTPREL16_HI,
1829 16, /* rightshift */
1830 1, /* size (0 = byte, 1 = short, 2 = long) */
1831 16, /* bitsize */
1832 FALSE, /* pc_relative */
1833 0, /* bitpos */
1834 complain_overflow_signed, /* complain_on_overflow */
1835 ppc64_elf_unhandled_reloc, /* special_function */
1836 "R_PPC64_GOT_DTPREL16_HI", /* name */
1837 FALSE, /* partial_inplace */
1838 0, /* src_mask */
1839 0xffff, /* dst_mask */
1840 FALSE), /* pcrel_offset */
1841
1842 /* Like GOT_DTPREL16_HI, but adjust for low 16 bits. */
1843 HOWTO (R_PPC64_GOT_DTPREL16_HA,
1844 16, /* rightshift */
1845 1, /* size (0 = byte, 1 = short, 2 = long) */
1846 16, /* bitsize */
1847 FALSE, /* pc_relative */
1848 0, /* bitpos */
1849 complain_overflow_signed, /* complain_on_overflow */
1850 ppc64_elf_unhandled_reloc, /* special_function */
1851 "R_PPC64_GOT_DTPREL16_HA", /* name */
1852 FALSE, /* partial_inplace */
1853 0, /* src_mask */
1854 0xffff, /* dst_mask */
1855 FALSE), /* pcrel_offset */
1856
1857 /* Allocates an entry in the GOT with value (sym+add)@tprel, and computes the
1858 offset to the entry relative to the TOC base (r2). */
1859 HOWTO (R_PPC64_GOT_TPREL16_DS,
1860 0, /* rightshift */
1861 1, /* size (0 = byte, 1 = short, 2 = long) */
1862 16, /* bitsize */
1863 FALSE, /* pc_relative */
1864 0, /* bitpos */
1865 complain_overflow_signed, /* complain_on_overflow */
1866 ppc64_elf_unhandled_reloc, /* special_function */
1867 "R_PPC64_GOT_TPREL16_DS", /* name */
1868 FALSE, /* partial_inplace */
1869 0, /* src_mask */
1870 0xfffc, /* dst_mask */
1871 FALSE), /* pcrel_offset */
1872
1873 /* Like GOT_TPREL16_DS, but no overflow. */
1874 HOWTO (R_PPC64_GOT_TPREL16_LO_DS,
1875 0, /* rightshift */
1876 1, /* size (0 = byte, 1 = short, 2 = long) */
1877 16, /* bitsize */
1878 FALSE, /* pc_relative */
1879 0, /* bitpos */
1880 complain_overflow_dont, /* complain_on_overflow */
1881 ppc64_elf_unhandled_reloc, /* special_function */
1882 "R_PPC64_GOT_TPREL16_LO_DS", /* name */
1883 FALSE, /* partial_inplace */
1884 0, /* src_mask */
1885 0xfffc, /* dst_mask */
1886 FALSE), /* pcrel_offset */
1887
1888 /* Like GOT_TPREL16_LO_DS, but next higher group of 16 bits. */
1889 HOWTO (R_PPC64_GOT_TPREL16_HI,
1890 16, /* rightshift */
1891 1, /* size (0 = byte, 1 = short, 2 = long) */
1892 16, /* bitsize */
1893 FALSE, /* pc_relative */
1894 0, /* bitpos */
1895 complain_overflow_signed, /* complain_on_overflow */
1896 ppc64_elf_unhandled_reloc, /* special_function */
1897 "R_PPC64_GOT_TPREL16_HI", /* name */
1898 FALSE, /* partial_inplace */
1899 0, /* src_mask */
1900 0xffff, /* dst_mask */
1901 FALSE), /* pcrel_offset */
1902
1903 /* Like GOT_TPREL16_HI, but adjust for low 16 bits. */
1904 HOWTO (R_PPC64_GOT_TPREL16_HA,
1905 16, /* rightshift */
1906 1, /* size (0 = byte, 1 = short, 2 = long) */
1907 16, /* bitsize */
1908 FALSE, /* pc_relative */
1909 0, /* bitpos */
1910 complain_overflow_signed, /* complain_on_overflow */
1911 ppc64_elf_unhandled_reloc, /* special_function */
1912 "R_PPC64_GOT_TPREL16_HA", /* name */
1913 FALSE, /* partial_inplace */
1914 0, /* src_mask */
1915 0xffff, /* dst_mask */
1916 FALSE), /* pcrel_offset */
1917
1918 HOWTO (R_PPC64_JMP_IREL, /* type */
1919 0, /* rightshift */
1920 0, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1921 0, /* bitsize */
1922 FALSE, /* pc_relative */
1923 0, /* bitpos */
1924 complain_overflow_dont, /* complain_on_overflow */
1925 ppc64_elf_unhandled_reloc, /* special_function */
1926 "R_PPC64_JMP_IREL", /* name */
1927 FALSE, /* partial_inplace */
1928 0, /* src_mask */
1929 0, /* dst_mask */
1930 FALSE), /* pcrel_offset */
1931
1932 HOWTO (R_PPC64_IRELATIVE, /* type */
1933 0, /* rightshift */
1934 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1935 64, /* bitsize */
1936 FALSE, /* pc_relative */
1937 0, /* bitpos */
1938 complain_overflow_dont, /* complain_on_overflow */
1939 bfd_elf_generic_reloc, /* special_function */
1940 "R_PPC64_IRELATIVE", /* name */
1941 FALSE, /* partial_inplace */
1942 0, /* src_mask */
1943 ONES (64), /* dst_mask */
1944 FALSE), /* pcrel_offset */
1945
1946 /* A 16 bit relative relocation. */
1947 HOWTO (R_PPC64_REL16, /* type */
1948 0, /* rightshift */
1949 1, /* size (0 = byte, 1 = short, 2 = long) */
1950 16, /* bitsize */
1951 TRUE, /* pc_relative */
1952 0, /* bitpos */
1953 complain_overflow_signed, /* complain_on_overflow */
1954 bfd_elf_generic_reloc, /* special_function */
1955 "R_PPC64_REL16", /* name */
1956 FALSE, /* partial_inplace */
1957 0, /* src_mask */
1958 0xffff, /* dst_mask */
1959 TRUE), /* pcrel_offset */
1960
1961 /* A 16 bit relative relocation without overflow. */
1962 HOWTO (R_PPC64_REL16_LO, /* type */
1963 0, /* rightshift */
1964 1, /* size (0 = byte, 1 = short, 2 = long) */
1965 16, /* bitsize */
1966 TRUE, /* pc_relative */
1967 0, /* bitpos */
1968 complain_overflow_dont,/* complain_on_overflow */
1969 bfd_elf_generic_reloc, /* special_function */
1970 "R_PPC64_REL16_LO", /* name */
1971 FALSE, /* partial_inplace */
1972 0, /* src_mask */
1973 0xffff, /* dst_mask */
1974 TRUE), /* pcrel_offset */
1975
1976 /* The high order 16 bits of a relative address. */
1977 HOWTO (R_PPC64_REL16_HI, /* type */
1978 16, /* rightshift */
1979 1, /* size (0 = byte, 1 = short, 2 = long) */
1980 16, /* bitsize */
1981 TRUE, /* pc_relative */
1982 0, /* bitpos */
1983 complain_overflow_signed, /* complain_on_overflow */
1984 bfd_elf_generic_reloc, /* special_function */
1985 "R_PPC64_REL16_HI", /* name */
1986 FALSE, /* partial_inplace */
1987 0, /* src_mask */
1988 0xffff, /* dst_mask */
1989 TRUE), /* pcrel_offset */
1990
1991 /* The high order 16 bits of a relative address, plus 1 if the contents of
1992 the low 16 bits, treated as a signed number, is negative. */
1993 HOWTO (R_PPC64_REL16_HA, /* type */
1994 16, /* rightshift */
1995 1, /* size (0 = byte, 1 = short, 2 = long) */
1996 16, /* bitsize */
1997 TRUE, /* pc_relative */
1998 0, /* bitpos */
1999 complain_overflow_signed, /* complain_on_overflow */
2000 ppc64_elf_ha_reloc, /* special_function */
2001 "R_PPC64_REL16_HA", /* name */
2002 FALSE, /* partial_inplace */
2003 0, /* src_mask */
2004 0xffff, /* dst_mask */
2005 TRUE), /* pcrel_offset */
2006
2007 /* Like R_PPC64_ADDR16_HI, but no overflow. */
2008 HOWTO (R_PPC64_ADDR16_HIGH, /* type */
2009 16, /* rightshift */
2010 1, /* size (0 = byte, 1 = short, 2 = long) */
2011 16, /* bitsize */
2012 FALSE, /* pc_relative */
2013 0, /* bitpos */
2014 complain_overflow_dont, /* complain_on_overflow */
2015 bfd_elf_generic_reloc, /* special_function */
2016 "R_PPC64_ADDR16_HIGH", /* name */
2017 FALSE, /* partial_inplace */
2018 0, /* src_mask */
2019 0xffff, /* dst_mask */
2020 FALSE), /* pcrel_offset */
2021
2022 /* Like R_PPC64_ADDR16_HA, but no overflow. */
2023 HOWTO (R_PPC64_ADDR16_HIGHA, /* type */
2024 16, /* rightshift */
2025 1, /* size (0 = byte, 1 = short, 2 = long) */
2026 16, /* bitsize */
2027 FALSE, /* pc_relative */
2028 0, /* bitpos */
2029 complain_overflow_dont, /* complain_on_overflow */
2030 ppc64_elf_ha_reloc, /* special_function */
2031 "R_PPC64_ADDR16_HIGHA", /* name */
2032 FALSE, /* partial_inplace */
2033 0, /* src_mask */
2034 0xffff, /* dst_mask */
2035 FALSE), /* pcrel_offset */
2036
2037 /* Like R_PPC64_DTPREL16_HI, but no overflow. */
2038 HOWTO (R_PPC64_DTPREL16_HIGH,
2039 16, /* rightshift */
2040 1, /* size (0 = byte, 1 = short, 2 = long) */
2041 16, /* bitsize */
2042 FALSE, /* pc_relative */
2043 0, /* bitpos */
2044 complain_overflow_dont, /* complain_on_overflow */
2045 ppc64_elf_unhandled_reloc, /* special_function */
2046 "R_PPC64_DTPREL16_HIGH", /* name */
2047 FALSE, /* partial_inplace */
2048 0, /* src_mask */
2049 0xffff, /* dst_mask */
2050 FALSE), /* pcrel_offset */
2051
2052 /* Like R_PPC64_DTPREL16_HA, but no overflow. */
2053 HOWTO (R_PPC64_DTPREL16_HIGHA,
2054 16, /* rightshift */
2055 1, /* size (0 = byte, 1 = short, 2 = long) */
2056 16, /* bitsize */
2057 FALSE, /* pc_relative */
2058 0, /* bitpos */
2059 complain_overflow_dont, /* complain_on_overflow */
2060 ppc64_elf_unhandled_reloc, /* special_function */
2061 "R_PPC64_DTPREL16_HIGHA", /* name */
2062 FALSE, /* partial_inplace */
2063 0, /* src_mask */
2064 0xffff, /* dst_mask */
2065 FALSE), /* pcrel_offset */
2066
2067 /* Like R_PPC64_TPREL16_HI, but no overflow. */
2068 HOWTO (R_PPC64_TPREL16_HIGH,
2069 16, /* rightshift */
2070 1, /* size (0 = byte, 1 = short, 2 = long) */
2071 16, /* bitsize */
2072 FALSE, /* pc_relative */
2073 0, /* bitpos */
2074 complain_overflow_dont, /* complain_on_overflow */
2075 ppc64_elf_unhandled_reloc, /* special_function */
2076 "R_PPC64_TPREL16_HIGH", /* name */
2077 FALSE, /* partial_inplace */
2078 0, /* src_mask */
2079 0xffff, /* dst_mask */
2080 FALSE), /* pcrel_offset */
2081
2082 /* Like R_PPC64_TPREL16_HA, but no overflow. */
2083 HOWTO (R_PPC64_TPREL16_HIGHA,
2084 16, /* rightshift */
2085 1, /* size (0 = byte, 1 = short, 2 = long) */
2086 16, /* bitsize */
2087 FALSE, /* pc_relative */
2088 0, /* bitpos */
2089 complain_overflow_dont, /* complain_on_overflow */
2090 ppc64_elf_unhandled_reloc, /* special_function */
2091 "R_PPC64_TPREL16_HIGHA", /* name */
2092 FALSE, /* partial_inplace */
2093 0, /* src_mask */
2094 0xffff, /* dst_mask */
2095 FALSE), /* pcrel_offset */
2096
2097 /* Like ADDR64, but use local entry point of function. */
2098 HOWTO (R_PPC64_ADDR64_LOCAL, /* type */
2099 0, /* rightshift */
2100 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
2101 64, /* bitsize */
2102 FALSE, /* pc_relative */
2103 0, /* bitpos */
2104 complain_overflow_dont, /* complain_on_overflow */
2105 bfd_elf_generic_reloc, /* special_function */
2106 "R_PPC64_ADDR64_LOCAL", /* name */
2107 FALSE, /* partial_inplace */
2108 0, /* src_mask */
2109 ONES (64), /* dst_mask */
2110 FALSE), /* pcrel_offset */
2111
2112 /* GNU extension to record C++ vtable hierarchy. */
2113 HOWTO (R_PPC64_GNU_VTINHERIT, /* type */
2114 0, /* rightshift */
2115 0, /* size (0 = byte, 1 = short, 2 = long) */
2116 0, /* bitsize */
2117 FALSE, /* pc_relative */
2118 0, /* bitpos */
2119 complain_overflow_dont, /* complain_on_overflow */
2120 NULL, /* special_function */
2121 "R_PPC64_GNU_VTINHERIT", /* name */
2122 FALSE, /* partial_inplace */
2123 0, /* src_mask */
2124 0, /* dst_mask */
2125 FALSE), /* pcrel_offset */
2126
2127 /* GNU extension to record C++ vtable member usage. */
2128 HOWTO (R_PPC64_GNU_VTENTRY, /* type */
2129 0, /* rightshift */
2130 0, /* size (0 = byte, 1 = short, 2 = long) */
2131 0, /* bitsize */
2132 FALSE, /* pc_relative */
2133 0, /* bitpos */
2134 complain_overflow_dont, /* complain_on_overflow */
2135 NULL, /* special_function */
2136 "R_PPC64_GNU_VTENTRY", /* name */
2137 FALSE, /* partial_inplace */
2138 0, /* src_mask */
2139 0, /* dst_mask */
2140 FALSE), /* pcrel_offset */
2141 };
2142
2143 \f
2144 /* Initialize the ppc64_elf_howto_table, so that linear accesses can
2145 be done. */
2146
2147 static void
2148 ppc_howto_init (void)
2149 {
2150 unsigned int i, type;
2151
2152 for (i = 0;
2153 i < sizeof (ppc64_elf_howto_raw) / sizeof (ppc64_elf_howto_raw[0]);
2154 i++)
2155 {
2156 type = ppc64_elf_howto_raw[i].type;
2157 BFD_ASSERT (type < (sizeof (ppc64_elf_howto_table)
2158 / sizeof (ppc64_elf_howto_table[0])));
2159 ppc64_elf_howto_table[type] = &ppc64_elf_howto_raw[i];
2160 }
2161 }
2162
2163 static reloc_howto_type *
2164 ppc64_elf_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2165 bfd_reloc_code_real_type code)
2166 {
2167 enum elf_ppc64_reloc_type r = R_PPC64_NONE;
2168
2169 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2170 /* Initialize howto table if needed. */
2171 ppc_howto_init ();
2172
2173 switch (code)
2174 {
2175 default:
2176 return NULL;
2177
2178 case BFD_RELOC_NONE: r = R_PPC64_NONE;
2179 break;
2180 case BFD_RELOC_32: r = R_PPC64_ADDR32;
2181 break;
2182 case BFD_RELOC_PPC_BA26: r = R_PPC64_ADDR24;
2183 break;
2184 case BFD_RELOC_16: r = R_PPC64_ADDR16;
2185 break;
2186 case BFD_RELOC_LO16: r = R_PPC64_ADDR16_LO;
2187 break;
2188 case BFD_RELOC_HI16: r = R_PPC64_ADDR16_HI;
2189 break;
2190 case BFD_RELOC_PPC64_ADDR16_HIGH: r = R_PPC64_ADDR16_HIGH;
2191 break;
2192 case BFD_RELOC_HI16_S: r = R_PPC64_ADDR16_HA;
2193 break;
2194 case BFD_RELOC_PPC64_ADDR16_HIGHA: r = R_PPC64_ADDR16_HIGHA;
2195 break;
2196 case BFD_RELOC_PPC_BA16: r = R_PPC64_ADDR14;
2197 break;
2198 case BFD_RELOC_PPC_BA16_BRTAKEN: r = R_PPC64_ADDR14_BRTAKEN;
2199 break;
2200 case BFD_RELOC_PPC_BA16_BRNTAKEN: r = R_PPC64_ADDR14_BRNTAKEN;
2201 break;
2202 case BFD_RELOC_PPC_B26: r = R_PPC64_REL24;
2203 break;
2204 case BFD_RELOC_PPC_B16: r = R_PPC64_REL14;
2205 break;
2206 case BFD_RELOC_PPC_B16_BRTAKEN: r = R_PPC64_REL14_BRTAKEN;
2207 break;
2208 case BFD_RELOC_PPC_B16_BRNTAKEN: r = R_PPC64_REL14_BRNTAKEN;
2209 break;
2210 case BFD_RELOC_16_GOTOFF: r = R_PPC64_GOT16;
2211 break;
2212 case BFD_RELOC_LO16_GOTOFF: r = R_PPC64_GOT16_LO;
2213 break;
2214 case BFD_RELOC_HI16_GOTOFF: r = R_PPC64_GOT16_HI;
2215 break;
2216 case BFD_RELOC_HI16_S_GOTOFF: r = R_PPC64_GOT16_HA;
2217 break;
2218 case BFD_RELOC_PPC_COPY: r = R_PPC64_COPY;
2219 break;
2220 case BFD_RELOC_PPC_GLOB_DAT: r = R_PPC64_GLOB_DAT;
2221 break;
2222 case BFD_RELOC_32_PCREL: r = R_PPC64_REL32;
2223 break;
2224 case BFD_RELOC_32_PLTOFF: r = R_PPC64_PLT32;
2225 break;
2226 case BFD_RELOC_32_PLT_PCREL: r = R_PPC64_PLTREL32;
2227 break;
2228 case BFD_RELOC_LO16_PLTOFF: r = R_PPC64_PLT16_LO;
2229 break;
2230 case BFD_RELOC_HI16_PLTOFF: r = R_PPC64_PLT16_HI;
2231 break;
2232 case BFD_RELOC_HI16_S_PLTOFF: r = R_PPC64_PLT16_HA;
2233 break;
2234 case BFD_RELOC_16_BASEREL: r = R_PPC64_SECTOFF;
2235 break;
2236 case BFD_RELOC_LO16_BASEREL: r = R_PPC64_SECTOFF_LO;
2237 break;
2238 case BFD_RELOC_HI16_BASEREL: r = R_PPC64_SECTOFF_HI;
2239 break;
2240 case BFD_RELOC_HI16_S_BASEREL: r = R_PPC64_SECTOFF_HA;
2241 break;
2242 case BFD_RELOC_CTOR: r = R_PPC64_ADDR64;
2243 break;
2244 case BFD_RELOC_64: r = R_PPC64_ADDR64;
2245 break;
2246 case BFD_RELOC_PPC64_HIGHER: r = R_PPC64_ADDR16_HIGHER;
2247 break;
2248 case BFD_RELOC_PPC64_HIGHER_S: r = R_PPC64_ADDR16_HIGHERA;
2249 break;
2250 case BFD_RELOC_PPC64_HIGHEST: r = R_PPC64_ADDR16_HIGHEST;
2251 break;
2252 case BFD_RELOC_PPC64_HIGHEST_S: r = R_PPC64_ADDR16_HIGHESTA;
2253 break;
2254 case BFD_RELOC_64_PCREL: r = R_PPC64_REL64;
2255 break;
2256 case BFD_RELOC_64_PLTOFF: r = R_PPC64_PLT64;
2257 break;
2258 case BFD_RELOC_64_PLT_PCREL: r = R_PPC64_PLTREL64;
2259 break;
2260 case BFD_RELOC_PPC_TOC16: r = R_PPC64_TOC16;
2261 break;
2262 case BFD_RELOC_PPC64_TOC16_LO: r = R_PPC64_TOC16_LO;
2263 break;
2264 case BFD_RELOC_PPC64_TOC16_HI: r = R_PPC64_TOC16_HI;
2265 break;
2266 case BFD_RELOC_PPC64_TOC16_HA: r = R_PPC64_TOC16_HA;
2267 break;
2268 case BFD_RELOC_PPC64_TOC: r = R_PPC64_TOC;
2269 break;
2270 case BFD_RELOC_PPC64_PLTGOT16: r = R_PPC64_PLTGOT16;
2271 break;
2272 case BFD_RELOC_PPC64_PLTGOT16_LO: r = R_PPC64_PLTGOT16_LO;
2273 break;
2274 case BFD_RELOC_PPC64_PLTGOT16_HI: r = R_PPC64_PLTGOT16_HI;
2275 break;
2276 case BFD_RELOC_PPC64_PLTGOT16_HA: r = R_PPC64_PLTGOT16_HA;
2277 break;
2278 case BFD_RELOC_PPC64_ADDR16_DS: r = R_PPC64_ADDR16_DS;
2279 break;
2280 case BFD_RELOC_PPC64_ADDR16_LO_DS: r = R_PPC64_ADDR16_LO_DS;
2281 break;
2282 case BFD_RELOC_PPC64_GOT16_DS: r = R_PPC64_GOT16_DS;
2283 break;
2284 case BFD_RELOC_PPC64_GOT16_LO_DS: r = R_PPC64_GOT16_LO_DS;
2285 break;
2286 case BFD_RELOC_PPC64_PLT16_LO_DS: r = R_PPC64_PLT16_LO_DS;
2287 break;
2288 case BFD_RELOC_PPC64_SECTOFF_DS: r = R_PPC64_SECTOFF_DS;
2289 break;
2290 case BFD_RELOC_PPC64_SECTOFF_LO_DS: r = R_PPC64_SECTOFF_LO_DS;
2291 break;
2292 case BFD_RELOC_PPC64_TOC16_DS: r = R_PPC64_TOC16_DS;
2293 break;
2294 case BFD_RELOC_PPC64_TOC16_LO_DS: r = R_PPC64_TOC16_LO_DS;
2295 break;
2296 case BFD_RELOC_PPC64_PLTGOT16_DS: r = R_PPC64_PLTGOT16_DS;
2297 break;
2298 case BFD_RELOC_PPC64_PLTGOT16_LO_DS: r = R_PPC64_PLTGOT16_LO_DS;
2299 break;
2300 case BFD_RELOC_PPC_TLS: r = R_PPC64_TLS;
2301 break;
2302 case BFD_RELOC_PPC_TLSGD: r = R_PPC64_TLSGD;
2303 break;
2304 case BFD_RELOC_PPC_TLSLD: r = R_PPC64_TLSLD;
2305 break;
2306 case BFD_RELOC_PPC_DTPMOD: r = R_PPC64_DTPMOD64;
2307 break;
2308 case BFD_RELOC_PPC_TPREL16: r = R_PPC64_TPREL16;
2309 break;
2310 case BFD_RELOC_PPC_TPREL16_LO: r = R_PPC64_TPREL16_LO;
2311 break;
2312 case BFD_RELOC_PPC_TPREL16_HI: r = R_PPC64_TPREL16_HI;
2313 break;
2314 case BFD_RELOC_PPC64_TPREL16_HIGH: r = R_PPC64_TPREL16_HIGH;
2315 break;
2316 case BFD_RELOC_PPC_TPREL16_HA: r = R_PPC64_TPREL16_HA;
2317 break;
2318 case BFD_RELOC_PPC64_TPREL16_HIGHA: r = R_PPC64_TPREL16_HIGHA;
2319 break;
2320 case BFD_RELOC_PPC_TPREL: r = R_PPC64_TPREL64;
2321 break;
2322 case BFD_RELOC_PPC_DTPREL16: r = R_PPC64_DTPREL16;
2323 break;
2324 case BFD_RELOC_PPC_DTPREL16_LO: r = R_PPC64_DTPREL16_LO;
2325 break;
2326 case BFD_RELOC_PPC_DTPREL16_HI: r = R_PPC64_DTPREL16_HI;
2327 break;
2328 case BFD_RELOC_PPC64_DTPREL16_HIGH: r = R_PPC64_DTPREL16_HIGH;
2329 break;
2330 case BFD_RELOC_PPC_DTPREL16_HA: r = R_PPC64_DTPREL16_HA;
2331 break;
2332 case BFD_RELOC_PPC64_DTPREL16_HIGHA: r = R_PPC64_DTPREL16_HIGHA;
2333 break;
2334 case BFD_RELOC_PPC_DTPREL: r = R_PPC64_DTPREL64;
2335 break;
2336 case BFD_RELOC_PPC_GOT_TLSGD16: r = R_PPC64_GOT_TLSGD16;
2337 break;
2338 case BFD_RELOC_PPC_GOT_TLSGD16_LO: r = R_PPC64_GOT_TLSGD16_LO;
2339 break;
2340 case BFD_RELOC_PPC_GOT_TLSGD16_HI: r = R_PPC64_GOT_TLSGD16_HI;
2341 break;
2342 case BFD_RELOC_PPC_GOT_TLSGD16_HA: r = R_PPC64_GOT_TLSGD16_HA;
2343 break;
2344 case BFD_RELOC_PPC_GOT_TLSLD16: r = R_PPC64_GOT_TLSLD16;
2345 break;
2346 case BFD_RELOC_PPC_GOT_TLSLD16_LO: r = R_PPC64_GOT_TLSLD16_LO;
2347 break;
2348 case BFD_RELOC_PPC_GOT_TLSLD16_HI: r = R_PPC64_GOT_TLSLD16_HI;
2349 break;
2350 case BFD_RELOC_PPC_GOT_TLSLD16_HA: r = R_PPC64_GOT_TLSLD16_HA;
2351 break;
2352 case BFD_RELOC_PPC_GOT_TPREL16: r = R_PPC64_GOT_TPREL16_DS;
2353 break;
2354 case BFD_RELOC_PPC_GOT_TPREL16_LO: r = R_PPC64_GOT_TPREL16_LO_DS;
2355 break;
2356 case BFD_RELOC_PPC_GOT_TPREL16_HI: r = R_PPC64_GOT_TPREL16_HI;
2357 break;
2358 case BFD_RELOC_PPC_GOT_TPREL16_HA: r = R_PPC64_GOT_TPREL16_HA;
2359 break;
2360 case BFD_RELOC_PPC_GOT_DTPREL16: r = R_PPC64_GOT_DTPREL16_DS;
2361 break;
2362 case BFD_RELOC_PPC_GOT_DTPREL16_LO: r = R_PPC64_GOT_DTPREL16_LO_DS;
2363 break;
2364 case BFD_RELOC_PPC_GOT_DTPREL16_HI: r = R_PPC64_GOT_DTPREL16_HI;
2365 break;
2366 case BFD_RELOC_PPC_GOT_DTPREL16_HA: r = R_PPC64_GOT_DTPREL16_HA;
2367 break;
2368 case BFD_RELOC_PPC64_TPREL16_DS: r = R_PPC64_TPREL16_DS;
2369 break;
2370 case BFD_RELOC_PPC64_TPREL16_LO_DS: r = R_PPC64_TPREL16_LO_DS;
2371 break;
2372 case BFD_RELOC_PPC64_TPREL16_HIGHER: r = R_PPC64_TPREL16_HIGHER;
2373 break;
2374 case BFD_RELOC_PPC64_TPREL16_HIGHERA: r = R_PPC64_TPREL16_HIGHERA;
2375 break;
2376 case BFD_RELOC_PPC64_TPREL16_HIGHEST: r = R_PPC64_TPREL16_HIGHEST;
2377 break;
2378 case BFD_RELOC_PPC64_TPREL16_HIGHESTA: r = R_PPC64_TPREL16_HIGHESTA;
2379 break;
2380 case BFD_RELOC_PPC64_DTPREL16_DS: r = R_PPC64_DTPREL16_DS;
2381 break;
2382 case BFD_RELOC_PPC64_DTPREL16_LO_DS: r = R_PPC64_DTPREL16_LO_DS;
2383 break;
2384 case BFD_RELOC_PPC64_DTPREL16_HIGHER: r = R_PPC64_DTPREL16_HIGHER;
2385 break;
2386 case BFD_RELOC_PPC64_DTPREL16_HIGHERA: r = R_PPC64_DTPREL16_HIGHERA;
2387 break;
2388 case BFD_RELOC_PPC64_DTPREL16_HIGHEST: r = R_PPC64_DTPREL16_HIGHEST;
2389 break;
2390 case BFD_RELOC_PPC64_DTPREL16_HIGHESTA: r = R_PPC64_DTPREL16_HIGHESTA;
2391 break;
2392 case BFD_RELOC_16_PCREL: r = R_PPC64_REL16;
2393 break;
2394 case BFD_RELOC_LO16_PCREL: r = R_PPC64_REL16_LO;
2395 break;
2396 case BFD_RELOC_HI16_PCREL: r = R_PPC64_REL16_HI;
2397 break;
2398 case BFD_RELOC_HI16_S_PCREL: r = R_PPC64_REL16_HA;
2399 break;
2400 case BFD_RELOC_PPC64_ADDR64_LOCAL: r = R_PPC64_ADDR64_LOCAL;
2401 break;
2402 case BFD_RELOC_VTABLE_INHERIT: r = R_PPC64_GNU_VTINHERIT;
2403 break;
2404 case BFD_RELOC_VTABLE_ENTRY: r = R_PPC64_GNU_VTENTRY;
2405 break;
2406 }
2407
2408 return ppc64_elf_howto_table[r];
2409 };
2410
2411 static reloc_howto_type *
2412 ppc64_elf_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2413 const char *r_name)
2414 {
2415 unsigned int i;
2416
2417 for (i = 0;
2418 i < sizeof (ppc64_elf_howto_raw) / sizeof (ppc64_elf_howto_raw[0]);
2419 i++)
2420 if (ppc64_elf_howto_raw[i].name != NULL
2421 && strcasecmp (ppc64_elf_howto_raw[i].name, r_name) == 0)
2422 return &ppc64_elf_howto_raw[i];
2423
2424 return NULL;
2425 }
2426
2427 /* Set the howto pointer for a PowerPC ELF reloc. */
2428
2429 static void
2430 ppc64_elf_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr,
2431 Elf_Internal_Rela *dst)
2432 {
2433 unsigned int type;
2434
2435 /* Initialize howto table if needed. */
2436 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2437 ppc_howto_init ();
2438
2439 type = ELF64_R_TYPE (dst->r_info);
2440 if (type >= (sizeof (ppc64_elf_howto_table)
2441 / sizeof (ppc64_elf_howto_table[0])))
2442 {
2443 (*_bfd_error_handler) (_("%B: invalid relocation type %d"),
2444 abfd, (int) type);
2445 type = R_PPC64_NONE;
2446 }
2447 cache_ptr->howto = ppc64_elf_howto_table[type];
2448 }
2449
2450 /* Handle the R_PPC64_ADDR16_HA and similar relocs. */
2451
2452 static bfd_reloc_status_type
2453 ppc64_elf_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2454 void *data, asection *input_section,
2455 bfd *output_bfd, char **error_message)
2456 {
2457 /* If this is a relocatable link (output_bfd test tells us), just
2458 call the generic function. Any adjustment will be done at final
2459 link time. */
2460 if (output_bfd != NULL)
2461 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2462 input_section, output_bfd, error_message);
2463
2464 /* Adjust the addend for sign extension of the low 16 bits.
2465 We won't actually be using the low 16 bits, so trashing them
2466 doesn't matter. */
2467 reloc_entry->addend += 0x8000;
2468 return bfd_reloc_continue;
2469 }
2470
2471 static bfd_reloc_status_type
2472 ppc64_elf_branch_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2473 void *data, asection *input_section,
2474 bfd *output_bfd, char **error_message)
2475 {
2476 if (output_bfd != NULL)
2477 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2478 input_section, output_bfd, error_message);
2479
2480 if (strcmp (symbol->section->name, ".opd") == 0
2481 && (symbol->section->owner->flags & DYNAMIC) == 0)
2482 {
2483 bfd_vma dest = opd_entry_value (symbol->section,
2484 symbol->value + reloc_entry->addend,
2485 NULL, NULL, FALSE);
2486 if (dest != (bfd_vma) -1)
2487 reloc_entry->addend = dest - (symbol->value
2488 + symbol->section->output_section->vma
2489 + symbol->section->output_offset);
2490 }
2491 return bfd_reloc_continue;
2492 }
2493
2494 static bfd_reloc_status_type
2495 ppc64_elf_brtaken_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2496 void *data, asection *input_section,
2497 bfd *output_bfd, char **error_message)
2498 {
2499 long insn;
2500 enum elf_ppc64_reloc_type r_type;
2501 bfd_size_type octets;
2502 /* Assume 'at' branch hints. */
2503 bfd_boolean is_isa_v2 = TRUE;
2504
2505 /* If this is a relocatable link (output_bfd test tells us), just
2506 call the generic function. Any adjustment will be done at final
2507 link time. */
2508 if (output_bfd != NULL)
2509 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2510 input_section, output_bfd, error_message);
2511
2512 octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2513 insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
2514 insn &= ~(0x01 << 21);
2515 r_type = reloc_entry->howto->type;
2516 if (r_type == R_PPC64_ADDR14_BRTAKEN
2517 || r_type == R_PPC64_REL14_BRTAKEN)
2518 insn |= 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field. */
2519
2520 if (is_isa_v2)
2521 {
2522 /* Set 'a' bit. This is 0b00010 in BO field for branch
2523 on CR(BI) insns (BO == 001at or 011at), and 0b01000
2524 for branch on CTR insns (BO == 1a00t or 1a01t). */
2525 if ((insn & (0x14 << 21)) == (0x04 << 21))
2526 insn |= 0x02 << 21;
2527 else if ((insn & (0x14 << 21)) == (0x10 << 21))
2528 insn |= 0x08 << 21;
2529 else
2530 goto out;
2531 }
2532 else
2533 {
2534 bfd_vma target = 0;
2535 bfd_vma from;
2536
2537 if (!bfd_is_com_section (symbol->section))
2538 target = symbol->value;
2539 target += symbol->section->output_section->vma;
2540 target += symbol->section->output_offset;
2541 target += reloc_entry->addend;
2542
2543 from = (reloc_entry->address
2544 + input_section->output_offset
2545 + input_section->output_section->vma);
2546
2547 /* Invert 'y' bit if not the default. */
2548 if ((bfd_signed_vma) (target - from) < 0)
2549 insn ^= 0x01 << 21;
2550 }
2551 bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
2552 out:
2553 return ppc64_elf_branch_reloc (abfd, reloc_entry, symbol, data,
2554 input_section, output_bfd, error_message);
2555 }
2556
2557 static bfd_reloc_status_type
2558 ppc64_elf_sectoff_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2559 void *data, asection *input_section,
2560 bfd *output_bfd, char **error_message)
2561 {
2562 /* If this is a relocatable link (output_bfd test tells us), just
2563 call the generic function. Any adjustment will be done at final
2564 link time. */
2565 if (output_bfd != NULL)
2566 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2567 input_section, output_bfd, error_message);
2568
2569 /* Subtract the symbol section base address. */
2570 reloc_entry->addend -= symbol->section->output_section->vma;
2571 return bfd_reloc_continue;
2572 }
2573
2574 static bfd_reloc_status_type
2575 ppc64_elf_sectoff_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2576 void *data, asection *input_section,
2577 bfd *output_bfd, char **error_message)
2578 {
2579 /* If this is a relocatable link (output_bfd test tells us), just
2580 call the generic function. Any adjustment will be done at final
2581 link time. */
2582 if (output_bfd != NULL)
2583 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2584 input_section, output_bfd, error_message);
2585
2586 /* Subtract the symbol section base address. */
2587 reloc_entry->addend -= symbol->section->output_section->vma;
2588
2589 /* Adjust the addend for sign extension of the low 16 bits. */
2590 reloc_entry->addend += 0x8000;
2591 return bfd_reloc_continue;
2592 }
2593
2594 static bfd_reloc_status_type
2595 ppc64_elf_toc_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2596 void *data, asection *input_section,
2597 bfd *output_bfd, char **error_message)
2598 {
2599 bfd_vma TOCstart;
2600
2601 /* If this is a relocatable link (output_bfd test tells us), just
2602 call the generic function. Any adjustment will be done at final
2603 link time. */
2604 if (output_bfd != NULL)
2605 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2606 input_section, output_bfd, error_message);
2607
2608 TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2609 if (TOCstart == 0)
2610 TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2611
2612 /* Subtract the TOC base address. */
2613 reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2614 return bfd_reloc_continue;
2615 }
2616
2617 static bfd_reloc_status_type
2618 ppc64_elf_toc_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2619 void *data, asection *input_section,
2620 bfd *output_bfd, char **error_message)
2621 {
2622 bfd_vma TOCstart;
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 /* Subtract the TOC base address. */
2636 reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2637
2638 /* Adjust the addend for sign extension of the low 16 bits. */
2639 reloc_entry->addend += 0x8000;
2640 return bfd_reloc_continue;
2641 }
2642
2643 static bfd_reloc_status_type
2644 ppc64_elf_toc64_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2645 void *data, asection *input_section,
2646 bfd *output_bfd, char **error_message)
2647 {
2648 bfd_vma TOCstart;
2649 bfd_size_type octets;
2650
2651 /* If this is a relocatable link (output_bfd test tells us), just
2652 call the generic function. Any adjustment will be done at final
2653 link time. */
2654 if (output_bfd != NULL)
2655 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2656 input_section, output_bfd, error_message);
2657
2658 TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2659 if (TOCstart == 0)
2660 TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2661
2662 octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2663 bfd_put_64 (abfd, TOCstart + TOC_BASE_OFF, (bfd_byte *) data + octets);
2664 return bfd_reloc_ok;
2665 }
2666
2667 static bfd_reloc_status_type
2668 ppc64_elf_unhandled_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2669 void *data, asection *input_section,
2670 bfd *output_bfd, char **error_message)
2671 {
2672 /* If this is a relocatable link (output_bfd test tells us), just
2673 call the generic function. Any adjustment will be done at final
2674 link time. */
2675 if (output_bfd != NULL)
2676 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2677 input_section, output_bfd, error_message);
2678
2679 if (error_message != NULL)
2680 {
2681 static char buf[60];
2682 sprintf (buf, "generic linker can't handle %s",
2683 reloc_entry->howto->name);
2684 *error_message = buf;
2685 }
2686 return bfd_reloc_dangerous;
2687 }
2688
2689 /* Track GOT entries needed for a given symbol. We might need more
2690 than one got entry per symbol. */
2691 struct got_entry
2692 {
2693 struct got_entry *next;
2694
2695 /* The symbol addend that we'll be placing in the GOT. */
2696 bfd_vma addend;
2697
2698 /* Unlike other ELF targets, we use separate GOT entries for the same
2699 symbol referenced from different input files. This is to support
2700 automatic multiple TOC/GOT sections, where the TOC base can vary
2701 from one input file to another. After partitioning into TOC groups
2702 we merge entries within the group.
2703
2704 Point to the BFD owning this GOT entry. */
2705 bfd *owner;
2706
2707 /* Zero for non-tls entries, or TLS_TLS and one of TLS_GD, TLS_LD,
2708 TLS_TPREL or TLS_DTPREL for tls entries. */
2709 unsigned char tls_type;
2710
2711 /* Non-zero if got.ent points to real entry. */
2712 unsigned char is_indirect;
2713
2714 /* Reference count until size_dynamic_sections, GOT offset thereafter. */
2715 union
2716 {
2717 bfd_signed_vma refcount;
2718 bfd_vma offset;
2719 struct got_entry *ent;
2720 } got;
2721 };
2722
2723 /* The same for PLT. */
2724 struct plt_entry
2725 {
2726 struct plt_entry *next;
2727
2728 bfd_vma addend;
2729
2730 union
2731 {
2732 bfd_signed_vma refcount;
2733 bfd_vma offset;
2734 } plt;
2735 };
2736
2737 struct ppc64_elf_obj_tdata
2738 {
2739 struct elf_obj_tdata elf;
2740
2741 /* Shortcuts to dynamic linker sections. */
2742 asection *got;
2743 asection *relgot;
2744
2745 /* Used during garbage collection. We attach global symbols defined
2746 on removed .opd entries to this section so that the sym is removed. */
2747 asection *deleted_section;
2748
2749 /* TLS local dynamic got entry handling. Support for multiple GOT
2750 sections means we potentially need one of these for each input bfd. */
2751 struct got_entry tlsld_got;
2752
2753 union {
2754 /* A copy of relocs before they are modified for --emit-relocs. */
2755 Elf_Internal_Rela *relocs;
2756
2757 /* Section contents. */
2758 bfd_byte *contents;
2759 } opd;
2760
2761 /* Nonzero if this bfd has small toc/got relocs, ie. that expect
2762 the reloc to be in the range -32768 to 32767. */
2763 unsigned int has_small_toc_reloc : 1;
2764
2765 /* Set if toc/got ha relocs detected not using r2, or lo reloc
2766 instruction not one we handle. */
2767 unsigned int unexpected_toc_insn : 1;
2768 };
2769
2770 #define ppc64_elf_tdata(bfd) \
2771 ((struct ppc64_elf_obj_tdata *) (bfd)->tdata.any)
2772
2773 #define ppc64_tlsld_got(bfd) \
2774 (&ppc64_elf_tdata (bfd)->tlsld_got)
2775
2776 #define is_ppc64_elf(bfd) \
2777 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
2778 && elf_object_id (bfd) == PPC64_ELF_DATA)
2779
2780 /* Override the generic function because we store some extras. */
2781
2782 static bfd_boolean
2783 ppc64_elf_mkobject (bfd *abfd)
2784 {
2785 return bfd_elf_allocate_object (abfd, sizeof (struct ppc64_elf_obj_tdata),
2786 PPC64_ELF_DATA);
2787 }
2788
2789 /* Fix bad default arch selected for a 64 bit input bfd when the
2790 default is 32 bit. */
2791
2792 static bfd_boolean
2793 ppc64_elf_object_p (bfd *abfd)
2794 {
2795 if (abfd->arch_info->the_default && abfd->arch_info->bits_per_word == 32)
2796 {
2797 Elf_Internal_Ehdr *i_ehdr = elf_elfheader (abfd);
2798
2799 if (i_ehdr->e_ident[EI_CLASS] == ELFCLASS64)
2800 {
2801 /* Relies on arch after 32 bit default being 64 bit default. */
2802 abfd->arch_info = abfd->arch_info->next;
2803 BFD_ASSERT (abfd->arch_info->bits_per_word == 64);
2804 }
2805 }
2806 return TRUE;
2807 }
2808
2809 /* Support for core dump NOTE sections. */
2810
2811 static bfd_boolean
2812 ppc64_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
2813 {
2814 size_t offset, size;
2815
2816 if (note->descsz != 504)
2817 return FALSE;
2818
2819 /* pr_cursig */
2820 elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
2821
2822 /* pr_pid */
2823 elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 32);
2824
2825 /* pr_reg */
2826 offset = 112;
2827 size = 384;
2828
2829 /* Make a ".reg/999" section. */
2830 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
2831 size, note->descpos + offset);
2832 }
2833
2834 static bfd_boolean
2835 ppc64_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
2836 {
2837 if (note->descsz != 136)
2838 return FALSE;
2839
2840 elf_tdata (abfd)->core->pid
2841 = bfd_get_32 (abfd, note->descdata + 24);
2842 elf_tdata (abfd)->core->program
2843 = _bfd_elfcore_strndup (abfd, note->descdata + 40, 16);
2844 elf_tdata (abfd)->core->command
2845 = _bfd_elfcore_strndup (abfd, note->descdata + 56, 80);
2846
2847 return TRUE;
2848 }
2849
2850 static char *
2851 ppc64_elf_write_core_note (bfd *abfd, char *buf, int *bufsiz, int note_type,
2852 ...)
2853 {
2854 switch (note_type)
2855 {
2856 default:
2857 return NULL;
2858
2859 case NT_PRPSINFO:
2860 {
2861 char data[136];
2862 va_list ap;
2863
2864 va_start (ap, note_type);
2865 memset (data, 0, sizeof (data));
2866 strncpy (data + 40, va_arg (ap, const char *), 16);
2867 strncpy (data + 56, va_arg (ap, const char *), 80);
2868 va_end (ap);
2869 return elfcore_write_note (abfd, buf, bufsiz,
2870 "CORE", note_type, data, sizeof (data));
2871 }
2872
2873 case NT_PRSTATUS:
2874 {
2875 char data[504];
2876 va_list ap;
2877 long pid;
2878 int cursig;
2879 const void *greg;
2880
2881 va_start (ap, note_type);
2882 memset (data, 0, 112);
2883 pid = va_arg (ap, long);
2884 bfd_put_32 (abfd, pid, data + 32);
2885 cursig = va_arg (ap, int);
2886 bfd_put_16 (abfd, cursig, data + 12);
2887 greg = va_arg (ap, const void *);
2888 memcpy (data + 112, greg, 384);
2889 memset (data + 496, 0, 8);
2890 va_end (ap);
2891 return elfcore_write_note (abfd, buf, bufsiz,
2892 "CORE", note_type, data, sizeof (data));
2893 }
2894 }
2895 }
2896
2897 /* Add extra PPC sections. */
2898
2899 static const struct bfd_elf_special_section ppc64_elf_special_sections[]=
2900 {
2901 { STRING_COMMA_LEN (".plt"), 0, SHT_NOBITS, 0 },
2902 { STRING_COMMA_LEN (".sbss"), -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE },
2903 { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2904 { STRING_COMMA_LEN (".toc"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2905 { STRING_COMMA_LEN (".toc1"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2906 { STRING_COMMA_LEN (".tocbss"), 0, SHT_NOBITS, SHF_ALLOC + SHF_WRITE },
2907 { NULL, 0, 0, 0, 0 }
2908 };
2909
2910 enum _ppc64_sec_type {
2911 sec_normal = 0,
2912 sec_opd = 1,
2913 sec_toc = 2
2914 };
2915
2916 struct _ppc64_elf_section_data
2917 {
2918 struct bfd_elf_section_data elf;
2919
2920 union
2921 {
2922 /* An array with one entry for each opd function descriptor. */
2923 struct _opd_sec_data
2924 {
2925 /* Points to the function code section for local opd entries. */
2926 asection **func_sec;
2927
2928 /* After editing .opd, adjust references to opd local syms. */
2929 long *adjust;
2930 } opd;
2931
2932 /* An array for toc sections, indexed by offset/8. */
2933 struct _toc_sec_data
2934 {
2935 /* Specifies the relocation symbol index used at a given toc offset. */
2936 unsigned *symndx;
2937
2938 /* And the relocation addend. */
2939 bfd_vma *add;
2940 } toc;
2941 } u;
2942
2943 enum _ppc64_sec_type sec_type:2;
2944
2945 /* Flag set when small branches are detected. Used to
2946 select suitable defaults for the stub group size. */
2947 unsigned int has_14bit_branch:1;
2948 };
2949
2950 #define ppc64_elf_section_data(sec) \
2951 ((struct _ppc64_elf_section_data *) elf_section_data (sec))
2952
2953 static bfd_boolean
2954 ppc64_elf_new_section_hook (bfd *abfd, asection *sec)
2955 {
2956 if (!sec->used_by_bfd)
2957 {
2958 struct _ppc64_elf_section_data *sdata;
2959 bfd_size_type amt = sizeof (*sdata);
2960
2961 sdata = bfd_zalloc (abfd, amt);
2962 if (sdata == NULL)
2963 return FALSE;
2964 sec->used_by_bfd = sdata;
2965 }
2966
2967 return _bfd_elf_new_section_hook (abfd, sec);
2968 }
2969
2970 static struct _opd_sec_data *
2971 get_opd_info (asection * sec)
2972 {
2973 if (sec != NULL
2974 && ppc64_elf_section_data (sec) != NULL
2975 && ppc64_elf_section_data (sec)->sec_type == sec_opd)
2976 return &ppc64_elf_section_data (sec)->u.opd;
2977 return NULL;
2978 }
2979
2980 static inline int
2981 abiversion (bfd *abfd)
2982 {
2983 return elf_elfheader (abfd)->e_flags & EF_PPC64_ABI;
2984 }
2985
2986 static inline void
2987 set_abiversion (bfd *abfd, int ver)
2988 {
2989 elf_elfheader (abfd)->e_flags &= ~EF_PPC64_ABI;
2990 elf_elfheader (abfd)->e_flags |= ver & EF_PPC64_ABI;
2991 }
2992 \f
2993 /* Parameters for the qsort hook. */
2994 static bfd_boolean synthetic_relocatable;
2995
2996 /* qsort comparison function for ppc64_elf_get_synthetic_symtab. */
2997
2998 static int
2999 compare_symbols (const void *ap, const void *bp)
3000 {
3001 const asymbol *a = * (const asymbol **) ap;
3002 const asymbol *b = * (const asymbol **) bp;
3003
3004 /* Section symbols first. */
3005 if ((a->flags & BSF_SECTION_SYM) && !(b->flags & BSF_SECTION_SYM))
3006 return -1;
3007 if (!(a->flags & BSF_SECTION_SYM) && (b->flags & BSF_SECTION_SYM))
3008 return 1;
3009
3010 /* then .opd symbols. */
3011 if (strcmp (a->section->name, ".opd") == 0
3012 && strcmp (b->section->name, ".opd") != 0)
3013 return -1;
3014 if (strcmp (a->section->name, ".opd") != 0
3015 && strcmp (b->section->name, ".opd") == 0)
3016 return 1;
3017
3018 /* then other code symbols. */
3019 if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3020 == (SEC_CODE | SEC_ALLOC)
3021 && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3022 != (SEC_CODE | SEC_ALLOC))
3023 return -1;
3024
3025 if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3026 != (SEC_CODE | SEC_ALLOC)
3027 && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3028 == (SEC_CODE | SEC_ALLOC))
3029 return 1;
3030
3031 if (synthetic_relocatable)
3032 {
3033 if (a->section->id < b->section->id)
3034 return -1;
3035
3036 if (a->section->id > b->section->id)
3037 return 1;
3038 }
3039
3040 if (a->value + a->section->vma < b->value + b->section->vma)
3041 return -1;
3042
3043 if (a->value + a->section->vma > b->value + b->section->vma)
3044 return 1;
3045
3046 /* For syms with the same value, prefer strong dynamic global function
3047 syms over other syms. */
3048 if ((a->flags & BSF_GLOBAL) != 0 && (b->flags & BSF_GLOBAL) == 0)
3049 return -1;
3050
3051 if ((a->flags & BSF_GLOBAL) == 0 && (b->flags & BSF_GLOBAL) != 0)
3052 return 1;
3053
3054 if ((a->flags & BSF_FUNCTION) != 0 && (b->flags & BSF_FUNCTION) == 0)
3055 return -1;
3056
3057 if ((a->flags & BSF_FUNCTION) == 0 && (b->flags & BSF_FUNCTION) != 0)
3058 return 1;
3059
3060 if ((a->flags & BSF_WEAK) == 0 && (b->flags & BSF_WEAK) != 0)
3061 return -1;
3062
3063 if ((a->flags & BSF_WEAK) != 0 && (b->flags & BSF_WEAK) == 0)
3064 return 1;
3065
3066 if ((a->flags & BSF_DYNAMIC) != 0 && (b->flags & BSF_DYNAMIC) == 0)
3067 return -1;
3068
3069 if ((a->flags & BSF_DYNAMIC) == 0 && (b->flags & BSF_DYNAMIC) != 0)
3070 return 1;
3071
3072 return 0;
3073 }
3074
3075 /* Search SYMS for a symbol of the given VALUE. */
3076
3077 static asymbol *
3078 sym_exists_at (asymbol **syms, long lo, long hi, int id, bfd_vma value)
3079 {
3080 long mid;
3081
3082 if (id == -1)
3083 {
3084 while (lo < hi)
3085 {
3086 mid = (lo + hi) >> 1;
3087 if (syms[mid]->value + syms[mid]->section->vma < value)
3088 lo = mid + 1;
3089 else if (syms[mid]->value + syms[mid]->section->vma > value)
3090 hi = mid;
3091 else
3092 return syms[mid];
3093 }
3094 }
3095 else
3096 {
3097 while (lo < hi)
3098 {
3099 mid = (lo + hi) >> 1;
3100 if (syms[mid]->section->id < id)
3101 lo = mid + 1;
3102 else if (syms[mid]->section->id > id)
3103 hi = mid;
3104 else if (syms[mid]->value < value)
3105 lo = mid + 1;
3106 else if (syms[mid]->value > value)
3107 hi = mid;
3108 else
3109 return syms[mid];
3110 }
3111 }
3112 return NULL;
3113 }
3114
3115 static bfd_boolean
3116 section_covers_vma (bfd *abfd ATTRIBUTE_UNUSED, asection *section, void *ptr)
3117 {
3118 bfd_vma vma = *(bfd_vma *) ptr;
3119 return ((section->flags & SEC_ALLOC) != 0
3120 && section->vma <= vma
3121 && vma < section->vma + section->size);
3122 }
3123
3124 /* Create synthetic symbols, effectively restoring "dot-symbol" function
3125 entry syms. Also generate @plt symbols for the glink branch table. */
3126
3127 static long
3128 ppc64_elf_get_synthetic_symtab (bfd *abfd,
3129 long static_count, asymbol **static_syms,
3130 long dyn_count, asymbol **dyn_syms,
3131 asymbol **ret)
3132 {
3133 asymbol *s;
3134 long i;
3135 long count;
3136 char *names;
3137 long symcount, codesecsym, codesecsymend, secsymend, opdsymend;
3138 asection *opd = NULL;
3139 bfd_boolean relocatable = (abfd->flags & (EXEC_P | DYNAMIC)) == 0;
3140 asymbol **syms;
3141 int abi = abiversion (abfd);
3142
3143 *ret = NULL;
3144
3145 if (abi < 2)
3146 {
3147 opd = bfd_get_section_by_name (abfd, ".opd");
3148 if (opd == NULL && abi == 1)
3149 return 0;
3150 }
3151
3152 symcount = static_count;
3153 if (!relocatable)
3154 symcount += dyn_count;
3155 if (symcount == 0)
3156 return 0;
3157
3158 syms = bfd_malloc ((symcount + 1) * sizeof (*syms));
3159 if (syms == NULL)
3160 return -1;
3161
3162 if (!relocatable && static_count != 0 && dyn_count != 0)
3163 {
3164 /* Use both symbol tables. */
3165 memcpy (syms, static_syms, static_count * sizeof (*syms));
3166 memcpy (syms + static_count, dyn_syms, (dyn_count + 1) * sizeof (*syms));
3167 }
3168 else if (!relocatable && static_count == 0)
3169 memcpy (syms, dyn_syms, (symcount + 1) * sizeof (*syms));
3170 else
3171 memcpy (syms, static_syms, (symcount + 1) * sizeof (*syms));
3172
3173 synthetic_relocatable = relocatable;
3174 qsort (syms, symcount, sizeof (*syms), compare_symbols);
3175
3176 if (!relocatable && symcount > 1)
3177 {
3178 long j;
3179 /* Trim duplicate syms, since we may have merged the normal and
3180 dynamic symbols. Actually, we only care about syms that have
3181 different values, so trim any with the same value. */
3182 for (i = 1, j = 1; i < symcount; ++i)
3183 if (syms[i - 1]->value + syms[i - 1]->section->vma
3184 != syms[i]->value + syms[i]->section->vma)
3185 syms[j++] = syms[i];
3186 symcount = j;
3187 }
3188
3189 i = 0;
3190 if (strcmp (syms[i]->section->name, ".opd") == 0)
3191 ++i;
3192 codesecsym = i;
3193
3194 for (; i < symcount; ++i)
3195 if (((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3196 != (SEC_CODE | SEC_ALLOC))
3197 || (syms[i]->flags & BSF_SECTION_SYM) == 0)
3198 break;
3199 codesecsymend = i;
3200
3201 for (; i < symcount; ++i)
3202 if ((syms[i]->flags & BSF_SECTION_SYM) == 0)
3203 break;
3204 secsymend = i;
3205
3206 for (; i < symcount; ++i)
3207 if (strcmp (syms[i]->section->name, ".opd") != 0)
3208 break;
3209 opdsymend = i;
3210
3211 for (; i < symcount; ++i)
3212 if ((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3213 != (SEC_CODE | SEC_ALLOC))
3214 break;
3215 symcount = i;
3216
3217 count = 0;
3218
3219 if (relocatable)
3220 {
3221 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3222 arelent *r;
3223 size_t size;
3224 long relcount;
3225
3226 if (opdsymend == secsymend)
3227 goto done;
3228
3229 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3230 relcount = (opd->flags & SEC_RELOC) ? opd->reloc_count : 0;
3231 if (relcount == 0)
3232 goto done;
3233
3234 if (!(*slurp_relocs) (abfd, opd, static_syms, FALSE))
3235 {
3236 count = -1;
3237 goto done;
3238 }
3239
3240 size = 0;
3241 for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3242 {
3243 asymbol *sym;
3244
3245 while (r < opd->relocation + relcount
3246 && r->address < syms[i]->value + opd->vma)
3247 ++r;
3248
3249 if (r == opd->relocation + relcount)
3250 break;
3251
3252 if (r->address != syms[i]->value + opd->vma)
3253 continue;
3254
3255 if (r->howto->type != R_PPC64_ADDR64)
3256 continue;
3257
3258 sym = *r->sym_ptr_ptr;
3259 if (!sym_exists_at (syms, opdsymend, symcount,
3260 sym->section->id, sym->value + r->addend))
3261 {
3262 ++count;
3263 size += sizeof (asymbol);
3264 size += strlen (syms[i]->name) + 2;
3265 }
3266 }
3267
3268 s = *ret = bfd_malloc (size);
3269 if (s == NULL)
3270 {
3271 count = -1;
3272 goto done;
3273 }
3274
3275 names = (char *) (s + count);
3276
3277 for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3278 {
3279 asymbol *sym;
3280
3281 while (r < opd->relocation + relcount
3282 && r->address < syms[i]->value + opd->vma)
3283 ++r;
3284
3285 if (r == opd->relocation + relcount)
3286 break;
3287
3288 if (r->address != syms[i]->value + opd->vma)
3289 continue;
3290
3291 if (r->howto->type != R_PPC64_ADDR64)
3292 continue;
3293
3294 sym = *r->sym_ptr_ptr;
3295 if (!sym_exists_at (syms, opdsymend, symcount,
3296 sym->section->id, sym->value + r->addend))
3297 {
3298 size_t len;
3299
3300 *s = *syms[i];
3301 s->flags |= BSF_SYNTHETIC;
3302 s->section = sym->section;
3303 s->value = sym->value + r->addend;
3304 s->name = names;
3305 *names++ = '.';
3306 len = strlen (syms[i]->name);
3307 memcpy (names, syms[i]->name, len + 1);
3308 names += len + 1;
3309 /* Have udata.p point back to the original symbol this
3310 synthetic symbol was derived from. */
3311 s->udata.p = syms[i];
3312 s++;
3313 }
3314 }
3315 }
3316 else
3317 {
3318 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3319 bfd_byte *contents = NULL;
3320 size_t size;
3321 long plt_count = 0;
3322 bfd_vma glink_vma = 0, resolv_vma = 0;
3323 asection *dynamic, *glink = NULL, *relplt = NULL;
3324 arelent *p;
3325
3326 if (opd != NULL && !bfd_malloc_and_get_section (abfd, opd, &contents))
3327 {
3328 free_contents_and_exit:
3329 if (contents)
3330 free (contents);
3331 count = -1;
3332 goto done;
3333 }
3334
3335 size = 0;
3336 for (i = secsymend; i < opdsymend; ++i)
3337 {
3338 bfd_vma ent;
3339
3340 /* Ignore bogus symbols. */
3341 if (syms[i]->value > opd->size - 8)
3342 continue;
3343
3344 ent = bfd_get_64 (abfd, contents + syms[i]->value);
3345 if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3346 {
3347 ++count;
3348 size += sizeof (asymbol);
3349 size += strlen (syms[i]->name) + 2;
3350 }
3351 }
3352
3353 /* Get start of .glink stubs from DT_PPC64_GLINK. */
3354 if (dyn_count != 0
3355 && (dynamic = bfd_get_section_by_name (abfd, ".dynamic")) != NULL)
3356 {
3357 bfd_byte *dynbuf, *extdyn, *extdynend;
3358 size_t extdynsize;
3359 void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *);
3360
3361 if (!bfd_malloc_and_get_section (abfd, dynamic, &dynbuf))
3362 goto free_contents_and_exit;
3363
3364 extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
3365 swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
3366
3367 extdyn = dynbuf;
3368 extdynend = extdyn + dynamic->size;
3369 for (; extdyn < extdynend; extdyn += extdynsize)
3370 {
3371 Elf_Internal_Dyn dyn;
3372 (*swap_dyn_in) (abfd, extdyn, &dyn);
3373
3374 if (dyn.d_tag == DT_NULL)
3375 break;
3376
3377 if (dyn.d_tag == DT_PPC64_GLINK)
3378 {
3379 /* The first glink stub starts at offset 32; see
3380 comment in ppc64_elf_finish_dynamic_sections. */
3381 glink_vma = dyn.d_un.d_val + GLINK_CALL_STUB_SIZE - 8 * 4;
3382 /* The .glink section usually does not survive the final
3383 link; search for the section (usually .text) where the
3384 glink stubs now reside. */
3385 glink = bfd_sections_find_if (abfd, section_covers_vma,
3386 &glink_vma);
3387 break;
3388 }
3389 }
3390
3391 free (dynbuf);
3392 }
3393
3394 if (glink != NULL)
3395 {
3396 /* Determine __glink trampoline by reading the relative branch
3397 from the first glink stub. */
3398 bfd_byte buf[4];
3399 unsigned int off = 0;
3400
3401 while (bfd_get_section_contents (abfd, glink, buf,
3402 glink_vma + off - glink->vma, 4))
3403 {
3404 unsigned int insn = bfd_get_32 (abfd, buf);
3405 insn ^= B_DOT;
3406 if ((insn & ~0x3fffffc) == 0)
3407 {
3408 resolv_vma = glink_vma + off + (insn ^ 0x2000000) - 0x2000000;
3409 break;
3410 }
3411 off += 4;
3412 if (off > 4)
3413 break;
3414 }
3415
3416 if (resolv_vma)
3417 size += sizeof (asymbol) + sizeof ("__glink_PLTresolve");
3418
3419 relplt = bfd_get_section_by_name (abfd, ".rela.plt");
3420 if (relplt != NULL)
3421 {
3422 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3423 if (! (*slurp_relocs) (abfd, relplt, dyn_syms, TRUE))
3424 goto free_contents_and_exit;
3425
3426 plt_count = relplt->size / sizeof (Elf64_External_Rela);
3427 size += plt_count * sizeof (asymbol);
3428
3429 p = relplt->relocation;
3430 for (i = 0; i < plt_count; i++, p++)
3431 {
3432 size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
3433 if (p->addend != 0)
3434 size += sizeof ("+0x") - 1 + 16;
3435 }
3436 }
3437 }
3438
3439 s = *ret = bfd_malloc (size);
3440 if (s == NULL)
3441 goto free_contents_and_exit;
3442
3443 names = (char *) (s + count + plt_count + (resolv_vma != 0));
3444
3445 for (i = secsymend; i < opdsymend; ++i)
3446 {
3447 bfd_vma ent;
3448
3449 if (syms[i]->value > opd->size - 8)
3450 continue;
3451
3452 ent = bfd_get_64 (abfd, contents + syms[i]->value);
3453 if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3454 {
3455 long lo, hi;
3456 size_t len;
3457 asection *sec = abfd->sections;
3458
3459 *s = *syms[i];
3460 lo = codesecsym;
3461 hi = codesecsymend;
3462 while (lo < hi)
3463 {
3464 long mid = (lo + hi) >> 1;
3465 if (syms[mid]->section->vma < ent)
3466 lo = mid + 1;
3467 else if (syms[mid]->section->vma > ent)
3468 hi = mid;
3469 else
3470 {
3471 sec = syms[mid]->section;
3472 break;
3473 }
3474 }
3475
3476 if (lo >= hi && lo > codesecsym)
3477 sec = syms[lo - 1]->section;
3478
3479 for (; sec != NULL; sec = sec->next)
3480 {
3481 if (sec->vma > ent)
3482 break;
3483 /* SEC_LOAD may not be set if SEC is from a separate debug
3484 info file. */
3485 if ((sec->flags & SEC_ALLOC) == 0)
3486 break;
3487 if ((sec->flags & SEC_CODE) != 0)
3488 s->section = sec;
3489 }
3490 s->flags |= BSF_SYNTHETIC;
3491 s->value = ent - s->section->vma;
3492 s->name = names;
3493 *names++ = '.';
3494 len = strlen (syms[i]->name);
3495 memcpy (names, syms[i]->name, len + 1);
3496 names += len + 1;
3497 /* Have udata.p point back to the original symbol this
3498 synthetic symbol was derived from. */
3499 s->udata.p = syms[i];
3500 s++;
3501 }
3502 }
3503 free (contents);
3504
3505 if (glink != NULL && relplt != NULL)
3506 {
3507 if (resolv_vma)
3508 {
3509 /* Add a symbol for the main glink trampoline. */
3510 memset (s, 0, sizeof *s);
3511 s->the_bfd = abfd;
3512 s->flags = BSF_GLOBAL | BSF_SYNTHETIC;
3513 s->section = glink;
3514 s->value = resolv_vma - glink->vma;
3515 s->name = names;
3516 memcpy (names, "__glink_PLTresolve", sizeof ("__glink_PLTresolve"));
3517 names += sizeof ("__glink_PLTresolve");
3518 s++;
3519 count++;
3520 }
3521
3522 /* FIXME: It would be very much nicer to put sym@plt on the
3523 stub rather than on the glink branch table entry. The
3524 objdump disassembler would then use a sensible symbol
3525 name on plt calls. The difficulty in doing so is
3526 a) finding the stubs, and,
3527 b) matching stubs against plt entries, and,
3528 c) there can be multiple stubs for a given plt entry.
3529
3530 Solving (a) could be done by code scanning, but older
3531 ppc64 binaries used different stubs to current code.
3532 (b) is the tricky one since you need to known the toc
3533 pointer for at least one function that uses a pic stub to
3534 be able to calculate the plt address referenced.
3535 (c) means gdb would need to set multiple breakpoints (or
3536 find the glink branch itself) when setting breakpoints
3537 for pending shared library loads. */
3538 p = relplt->relocation;
3539 for (i = 0; i < plt_count; i++, p++)
3540 {
3541 size_t len;
3542
3543 *s = **p->sym_ptr_ptr;
3544 /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set. Since
3545 we are defining a symbol, ensure one of them is set. */
3546 if ((s->flags & BSF_LOCAL) == 0)
3547 s->flags |= BSF_GLOBAL;
3548 s->flags |= BSF_SYNTHETIC;
3549 s->section = glink;
3550 s->value = glink_vma - glink->vma;
3551 s->name = names;
3552 s->udata.p = NULL;
3553 len = strlen ((*p->sym_ptr_ptr)->name);
3554 memcpy (names, (*p->sym_ptr_ptr)->name, len);
3555 names += len;
3556 if (p->addend != 0)
3557 {
3558 memcpy (names, "+0x", sizeof ("+0x") - 1);
3559 names += sizeof ("+0x") - 1;
3560 bfd_sprintf_vma (abfd, names, p->addend);
3561 names += strlen (names);
3562 }
3563 memcpy (names, "@plt", sizeof ("@plt"));
3564 names += sizeof ("@plt");
3565 s++;
3566 if (abi < 2)
3567 {
3568 glink_vma += 8;
3569 if (i >= 0x8000)
3570 glink_vma += 4;
3571 }
3572 else
3573 glink_vma += 4;
3574 }
3575 count += plt_count;
3576 }
3577 }
3578
3579 done:
3580 free (syms);
3581 return count;
3582 }
3583 \f
3584 /* The following functions are specific to the ELF linker, while
3585 functions above are used generally. Those named ppc64_elf_* are
3586 called by the main ELF linker code. They appear in this file more
3587 or less in the order in which they are called. eg.
3588 ppc64_elf_check_relocs is called early in the link process,
3589 ppc64_elf_finish_dynamic_sections is one of the last functions
3590 called.
3591
3592 PowerPC64-ELF uses a similar scheme to PowerPC64-XCOFF in that
3593 functions have both a function code symbol and a function descriptor
3594 symbol. A call to foo in a relocatable object file looks like:
3595
3596 . .text
3597 . x:
3598 . bl .foo
3599 . nop
3600
3601 The function definition in another object file might be:
3602
3603 . .section .opd
3604 . foo: .quad .foo
3605 . .quad .TOC.@tocbase
3606 . .quad 0
3607 .
3608 . .text
3609 . .foo: blr
3610
3611 When the linker resolves the call during a static link, the branch
3612 unsurprisingly just goes to .foo and the .opd information is unused.
3613 If the function definition is in a shared library, things are a little
3614 different: The call goes via a plt call stub, the opd information gets
3615 copied to the plt, and the linker patches the nop.
3616
3617 . x:
3618 . bl .foo_stub
3619 . ld 2,40(1)
3620 .
3621 .
3622 . .foo_stub:
3623 . std 2,40(1) # in practice, the call stub
3624 . addis 11,2,Lfoo@toc@ha # is slightly optimized, but
3625 . addi 11,11,Lfoo@toc@l # this is the general idea
3626 . ld 12,0(11)
3627 . ld 2,8(11)
3628 . mtctr 12
3629 . ld 11,16(11)
3630 . bctr
3631 .
3632 . .section .plt
3633 . Lfoo: reloc (R_PPC64_JMP_SLOT, foo)
3634
3635 The "reloc ()" notation is supposed to indicate that the linker emits
3636 an R_PPC64_JMP_SLOT reloc against foo. The dynamic linker does the opd
3637 copying.
3638
3639 What are the difficulties here? Well, firstly, the relocations
3640 examined by the linker in check_relocs are against the function code
3641 sym .foo, while the dynamic relocation in the plt is emitted against
3642 the function descriptor symbol, foo. Somewhere along the line, we need
3643 to carefully copy dynamic link information from one symbol to the other.
3644 Secondly, the generic part of the elf linker will make .foo a dynamic
3645 symbol as is normal for most other backends. We need foo dynamic
3646 instead, at least for an application final link. However, when
3647 creating a shared library containing foo, we need to have both symbols
3648 dynamic so that references to .foo are satisfied during the early
3649 stages of linking. Otherwise the linker might decide to pull in a
3650 definition from some other object, eg. a static library.
3651
3652 Update: As of August 2004, we support a new convention. Function
3653 calls may use the function descriptor symbol, ie. "bl foo". This
3654 behaves exactly as "bl .foo". */
3655
3656 /* Of those relocs that might be copied as dynamic relocs, this function
3657 selects those that must be copied when linking a shared library,
3658 even when the symbol is local. */
3659
3660 static int
3661 must_be_dyn_reloc (struct bfd_link_info *info,
3662 enum elf_ppc64_reloc_type r_type)
3663 {
3664 switch (r_type)
3665 {
3666 default:
3667 return 1;
3668
3669 case R_PPC64_REL32:
3670 case R_PPC64_REL64:
3671 case R_PPC64_REL30:
3672 return 0;
3673
3674 case R_PPC64_TPREL16:
3675 case R_PPC64_TPREL16_LO:
3676 case R_PPC64_TPREL16_HI:
3677 case R_PPC64_TPREL16_HA:
3678 case R_PPC64_TPREL16_DS:
3679 case R_PPC64_TPREL16_LO_DS:
3680 case R_PPC64_TPREL16_HIGH:
3681 case R_PPC64_TPREL16_HIGHA:
3682 case R_PPC64_TPREL16_HIGHER:
3683 case R_PPC64_TPREL16_HIGHERA:
3684 case R_PPC64_TPREL16_HIGHEST:
3685 case R_PPC64_TPREL16_HIGHESTA:
3686 case R_PPC64_TPREL64:
3687 return !info->executable;
3688 }
3689 }
3690
3691 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
3692 copying dynamic variables from a shared lib into an app's dynbss
3693 section, and instead use a dynamic relocation to point into the
3694 shared lib. With code that gcc generates, it's vital that this be
3695 enabled; In the PowerPC64 ABI, the address of a function is actually
3696 the address of a function descriptor, which resides in the .opd
3697 section. gcc uses the descriptor directly rather than going via the
3698 GOT as some other ABI's do, which means that initialized function
3699 pointers must reference the descriptor. Thus, a function pointer
3700 initialized to the address of a function in a shared library will
3701 either require a copy reloc, or a dynamic reloc. Using a copy reloc
3702 redefines the function descriptor symbol to point to the copy. This
3703 presents a problem as a plt entry for that function is also
3704 initialized from the function descriptor symbol and the copy reloc
3705 may not be initialized first. */
3706 #define ELIMINATE_COPY_RELOCS 1
3707
3708 /* Section name for stubs is the associated section name plus this
3709 string. */
3710 #define STUB_SUFFIX ".stub"
3711
3712 /* Linker stubs.
3713 ppc_stub_long_branch:
3714 Used when a 14 bit branch (or even a 24 bit branch) can't reach its
3715 destination, but a 24 bit branch in a stub section will reach.
3716 . b dest
3717
3718 ppc_stub_plt_branch:
3719 Similar to the above, but a 24 bit branch in the stub section won't
3720 reach its destination.
3721 . addis %r11,%r2,xxx@toc@ha
3722 . ld %r12,xxx@toc@l(%r11)
3723 . mtctr %r12
3724 . bctr
3725
3726 ppc_stub_plt_call:
3727 Used to call a function in a shared library. If it so happens that
3728 the plt entry referenced crosses a 64k boundary, then an extra
3729 "addi %r11,%r11,xxx@toc@l" will be inserted before the "mtctr".
3730 . std %r2,40(%r1)
3731 . addis %r11,%r2,xxx@toc@ha
3732 . ld %r12,xxx+0@toc@l(%r11)
3733 . mtctr %r12
3734 . ld %r2,xxx+8@toc@l(%r11)
3735 . ld %r11,xxx+16@toc@l(%r11)
3736 . bctr
3737
3738 ppc_stub_long_branch and ppc_stub_plt_branch may also have additional
3739 code to adjust the value and save r2 to support multiple toc sections.
3740 A ppc_stub_long_branch with an r2 offset looks like:
3741 . std %r2,40(%r1)
3742 . addis %r2,%r2,off@ha
3743 . addi %r2,%r2,off@l
3744 . b dest
3745
3746 A ppc_stub_plt_branch with an r2 offset looks like:
3747 . std %r2,40(%r1)
3748 . addis %r11,%r2,xxx@toc@ha
3749 . ld %r12,xxx@toc@l(%r11)
3750 . addis %r2,%r2,off@ha
3751 . addi %r2,%r2,off@l
3752 . mtctr %r12
3753 . bctr
3754
3755 In cases where the "addis" instruction would add zero, the "addis" is
3756 omitted and following instructions modified slightly in some cases.
3757 */
3758
3759 enum ppc_stub_type {
3760 ppc_stub_none,
3761 ppc_stub_long_branch,
3762 ppc_stub_long_branch_r2off,
3763 ppc_stub_plt_branch,
3764 ppc_stub_plt_branch_r2off,
3765 ppc_stub_plt_call,
3766 ppc_stub_plt_call_r2save
3767 };
3768
3769 struct ppc_stub_hash_entry {
3770
3771 /* Base hash table entry structure. */
3772 struct bfd_hash_entry root;
3773
3774 enum ppc_stub_type stub_type;
3775
3776 /* The stub section. */
3777 asection *stub_sec;
3778
3779 /* Offset within stub_sec of the beginning of this stub. */
3780 bfd_vma stub_offset;
3781
3782 /* Given the symbol's value and its section we can determine its final
3783 value when building the stubs (so the stub knows where to jump. */
3784 bfd_vma target_value;
3785 asection *target_section;
3786
3787 /* The symbol table entry, if any, that this was derived from. */
3788 struct ppc_link_hash_entry *h;
3789 struct plt_entry *plt_ent;
3790
3791 /* Where this stub is being called from, or, in the case of combined
3792 stub sections, the first input section in the group. */
3793 asection *id_sec;
3794
3795 /* Symbol st_other. */
3796 unsigned char other;
3797 };
3798
3799 struct ppc_branch_hash_entry {
3800
3801 /* Base hash table entry structure. */
3802 struct bfd_hash_entry root;
3803
3804 /* Offset within branch lookup table. */
3805 unsigned int offset;
3806
3807 /* Generation marker. */
3808 unsigned int iter;
3809 };
3810
3811 /* Used to track dynamic relocations for local symbols. */
3812 struct ppc_dyn_relocs
3813 {
3814 struct ppc_dyn_relocs *next;
3815
3816 /* The input section of the reloc. */
3817 asection *sec;
3818
3819 /* Total number of relocs copied for the input section. */
3820 unsigned int count : 31;
3821
3822 /* Whether this entry is for STT_GNU_IFUNC symbols. */
3823 unsigned int ifunc : 1;
3824 };
3825
3826 struct ppc_link_hash_entry
3827 {
3828 struct elf_link_hash_entry elf;
3829
3830 union {
3831 /* A pointer to the most recently used stub hash entry against this
3832 symbol. */
3833 struct ppc_stub_hash_entry *stub_cache;
3834
3835 /* A pointer to the next symbol starting with a '.' */
3836 struct ppc_link_hash_entry *next_dot_sym;
3837 } u;
3838
3839 /* Track dynamic relocs copied for this symbol. */
3840 struct elf_dyn_relocs *dyn_relocs;
3841
3842 /* Link between function code and descriptor symbols. */
3843 struct ppc_link_hash_entry *oh;
3844
3845 /* Flag function code and descriptor symbols. */
3846 unsigned int is_func:1;
3847 unsigned int is_func_descriptor:1;
3848 unsigned int fake:1;
3849
3850 /* Whether global opd/toc sym has been adjusted or not.
3851 After ppc64_elf_edit_opd/ppc64_elf_edit_toc has run, this flag
3852 should be set for all globals defined in any opd/toc section. */
3853 unsigned int adjust_done:1;
3854
3855 /* Set if we twiddled this symbol to weak at some stage. */
3856 unsigned int was_undefined:1;
3857
3858 /* Contexts in which symbol is used in the GOT (or TOC).
3859 TLS_GD .. TLS_EXPLICIT bits are or'd into the mask as the
3860 corresponding relocs are encountered during check_relocs.
3861 tls_optimize clears TLS_GD .. TLS_TPREL when optimizing to
3862 indicate the corresponding GOT entry type is not needed.
3863 tls_optimize may also set TLS_TPRELGD when a GD reloc turns into
3864 a TPREL one. We use a separate flag rather than setting TPREL
3865 just for convenience in distinguishing the two cases. */
3866 #define TLS_GD 1 /* GD reloc. */
3867 #define TLS_LD 2 /* LD reloc. */
3868 #define TLS_TPREL 4 /* TPREL reloc, => IE. */
3869 #define TLS_DTPREL 8 /* DTPREL reloc, => LD. */
3870 #define TLS_TLS 16 /* Any TLS reloc. */
3871 #define TLS_EXPLICIT 32 /* Marks TOC section TLS relocs. */
3872 #define TLS_TPRELGD 64 /* TPREL reloc resulting from GD->IE. */
3873 #define PLT_IFUNC 128 /* STT_GNU_IFUNC. */
3874 unsigned char tls_mask;
3875 };
3876
3877 /* ppc64 ELF linker hash table. */
3878
3879 struct ppc_link_hash_table
3880 {
3881 struct elf_link_hash_table elf;
3882
3883 /* The stub hash table. */
3884 struct bfd_hash_table stub_hash_table;
3885
3886 /* Another hash table for plt_branch stubs. */
3887 struct bfd_hash_table branch_hash_table;
3888
3889 /* Hash table for function prologue tocsave. */
3890 htab_t tocsave_htab;
3891
3892 /* Various options and other info passed from the linker. */
3893 struct ppc64_elf_params *params;
3894
3895 /* Array to keep track of which stub sections have been created, and
3896 information on stub grouping. */
3897 struct map_stub {
3898 /* This is the section to which stubs in the group will be attached. */
3899 asection *link_sec;
3900 /* The stub section. */
3901 asection *stub_sec;
3902 /* Along with elf_gp, specifies the TOC pointer used in this group. */
3903 bfd_vma toc_off;
3904 } *stub_group;
3905
3906 /* Temp used when calculating TOC pointers. */
3907 bfd_vma toc_curr;
3908 bfd *toc_bfd;
3909 asection *toc_first_sec;
3910
3911 /* Highest input section id. */
3912 int top_id;
3913
3914 /* Highest output section index. */
3915 int top_index;
3916
3917 /* Used when adding symbols. */
3918 struct ppc_link_hash_entry *dot_syms;
3919
3920 /* List of input sections for each output section. */
3921 asection **input_list;
3922
3923 /* Shortcuts to get to dynamic linker sections. */
3924 asection *dynbss;
3925 asection *relbss;
3926 asection *glink;
3927 asection *sfpr;
3928 asection *brlt;
3929 asection *relbrlt;
3930 asection *glink_eh_frame;
3931
3932 /* Shortcut to .__tls_get_addr and __tls_get_addr. */
3933 struct ppc_link_hash_entry *tls_get_addr;
3934 struct ppc_link_hash_entry *tls_get_addr_fd;
3935
3936 /* The size of reliplt used by got entry relocs. */
3937 bfd_size_type got_reli_size;
3938
3939 /* Statistics. */
3940 unsigned long stub_count[ppc_stub_plt_call_r2save];
3941
3942 /* Number of stubs against global syms. */
3943 unsigned long stub_globals;
3944
3945 /* Set if we're linking code with function descriptors. */
3946 unsigned int opd_abi:1;
3947
3948 /* Support for multiple toc sections. */
3949 unsigned int do_multi_toc:1;
3950 unsigned int multi_toc_needed:1;
3951 unsigned int second_toc_pass:1;
3952 unsigned int do_toc_opt:1;
3953
3954 /* Set on error. */
3955 unsigned int stub_error:1;
3956
3957 /* Temp used by ppc64_elf_before_check_relocs. */
3958 unsigned int twiddled_syms:1;
3959
3960 /* Incremented every time we size stubs. */
3961 unsigned int stub_iteration;
3962
3963 /* Small local sym cache. */
3964 struct sym_cache sym_cache;
3965 };
3966
3967 /* Rename some of the generic section flags to better document how they
3968 are used here. */
3969
3970 /* Nonzero if this section has TLS related relocations. */
3971 #define has_tls_reloc sec_flg0
3972
3973 /* Nonzero if this section has a call to __tls_get_addr. */
3974 #define has_tls_get_addr_call sec_flg1
3975
3976 /* Nonzero if this section has any toc or got relocs. */
3977 #define has_toc_reloc sec_flg2
3978
3979 /* Nonzero if this section has a call to another section that uses
3980 the toc or got. */
3981 #define makes_toc_func_call sec_flg3
3982
3983 /* Recursion protection when determining above flag. */
3984 #define call_check_in_progress sec_flg4
3985 #define call_check_done sec_flg5
3986
3987 /* Get the ppc64 ELF linker hash table from a link_info structure. */
3988
3989 #define ppc_hash_table(p) \
3990 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
3991 == PPC64_ELF_DATA ? ((struct ppc_link_hash_table *) ((p)->hash)) : NULL)
3992
3993 #define ppc_stub_hash_lookup(table, string, create, copy) \
3994 ((struct ppc_stub_hash_entry *) \
3995 bfd_hash_lookup ((table), (string), (create), (copy)))
3996
3997 #define ppc_branch_hash_lookup(table, string, create, copy) \
3998 ((struct ppc_branch_hash_entry *) \
3999 bfd_hash_lookup ((table), (string), (create), (copy)))
4000
4001 /* Create an entry in the stub hash table. */
4002
4003 static struct bfd_hash_entry *
4004 stub_hash_newfunc (struct bfd_hash_entry *entry,
4005 struct bfd_hash_table *table,
4006 const char *string)
4007 {
4008 /* Allocate the structure if it has not already been allocated by a
4009 subclass. */
4010 if (entry == NULL)
4011 {
4012 entry = bfd_hash_allocate (table, sizeof (struct ppc_stub_hash_entry));
4013 if (entry == NULL)
4014 return entry;
4015 }
4016
4017 /* Call the allocation method of the superclass. */
4018 entry = bfd_hash_newfunc (entry, table, string);
4019 if (entry != NULL)
4020 {
4021 struct ppc_stub_hash_entry *eh;
4022
4023 /* Initialize the local fields. */
4024 eh = (struct ppc_stub_hash_entry *) entry;
4025 eh->stub_type = ppc_stub_none;
4026 eh->stub_sec = NULL;
4027 eh->stub_offset = 0;
4028 eh->target_value = 0;
4029 eh->target_section = NULL;
4030 eh->h = NULL;
4031 eh->plt_ent = NULL;
4032 eh->id_sec = NULL;
4033 eh->other = 0;
4034 }
4035
4036 return entry;
4037 }
4038
4039 /* Create an entry in the branch hash table. */
4040
4041 static struct bfd_hash_entry *
4042 branch_hash_newfunc (struct bfd_hash_entry *entry,
4043 struct bfd_hash_table *table,
4044 const char *string)
4045 {
4046 /* Allocate the structure if it has not already been allocated by a
4047 subclass. */
4048 if (entry == NULL)
4049 {
4050 entry = bfd_hash_allocate (table, sizeof (struct ppc_branch_hash_entry));
4051 if (entry == NULL)
4052 return entry;
4053 }
4054
4055 /* Call the allocation method of the superclass. */
4056 entry = bfd_hash_newfunc (entry, table, string);
4057 if (entry != NULL)
4058 {
4059 struct ppc_branch_hash_entry *eh;
4060
4061 /* Initialize the local fields. */
4062 eh = (struct ppc_branch_hash_entry *) entry;
4063 eh->offset = 0;
4064 eh->iter = 0;
4065 }
4066
4067 return entry;
4068 }
4069
4070 /* Create an entry in a ppc64 ELF linker hash table. */
4071
4072 static struct bfd_hash_entry *
4073 link_hash_newfunc (struct bfd_hash_entry *entry,
4074 struct bfd_hash_table *table,
4075 const char *string)
4076 {
4077 /* Allocate the structure if it has not already been allocated by a
4078 subclass. */
4079 if (entry == NULL)
4080 {
4081 entry = bfd_hash_allocate (table, sizeof (struct ppc_link_hash_entry));
4082 if (entry == NULL)
4083 return entry;
4084 }
4085
4086 /* Call the allocation method of the superclass. */
4087 entry = _bfd_elf_link_hash_newfunc (entry, table, string);
4088 if (entry != NULL)
4089 {
4090 struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) entry;
4091
4092 memset (&eh->u.stub_cache, 0,
4093 (sizeof (struct ppc_link_hash_entry)
4094 - offsetof (struct ppc_link_hash_entry, u.stub_cache)));
4095
4096 /* When making function calls, old ABI code references function entry
4097 points (dot symbols), while new ABI code references the function
4098 descriptor symbol. We need to make any combination of reference and
4099 definition work together, without breaking archive linking.
4100
4101 For a defined function "foo" and an undefined call to "bar":
4102 An old object defines "foo" and ".foo", references ".bar" (possibly
4103 "bar" too).
4104 A new object defines "foo" and references "bar".
4105
4106 A new object thus has no problem with its undefined symbols being
4107 satisfied by definitions in an old object. On the other hand, the
4108 old object won't have ".bar" satisfied by a new object.
4109
4110 Keep a list of newly added dot-symbols. */
4111
4112 if (string[0] == '.')
4113 {
4114 struct ppc_link_hash_table *htab;
4115
4116 htab = (struct ppc_link_hash_table *) table;
4117 eh->u.next_dot_sym = htab->dot_syms;
4118 htab->dot_syms = eh;
4119 }
4120 }
4121
4122 return entry;
4123 }
4124
4125 struct tocsave_entry {
4126 asection *sec;
4127 bfd_vma offset;
4128 };
4129
4130 static hashval_t
4131 tocsave_htab_hash (const void *p)
4132 {
4133 const struct tocsave_entry *e = (const struct tocsave_entry *) p;
4134 return ((bfd_vma)(intptr_t) e->sec ^ e->offset) >> 3;
4135 }
4136
4137 static int
4138 tocsave_htab_eq (const void *p1, const void *p2)
4139 {
4140 const struct tocsave_entry *e1 = (const struct tocsave_entry *) p1;
4141 const struct tocsave_entry *e2 = (const struct tocsave_entry *) p2;
4142 return e1->sec == e2->sec && e1->offset == e2->offset;
4143 }
4144
4145 /* Create a ppc64 ELF linker hash table. */
4146
4147 static struct bfd_link_hash_table *
4148 ppc64_elf_link_hash_table_create (bfd *abfd)
4149 {
4150 struct ppc_link_hash_table *htab;
4151 bfd_size_type amt = sizeof (struct ppc_link_hash_table);
4152
4153 htab = bfd_zmalloc (amt);
4154 if (htab == NULL)
4155 return NULL;
4156
4157 if (!_bfd_elf_link_hash_table_init (&htab->elf, abfd, link_hash_newfunc,
4158 sizeof (struct ppc_link_hash_entry),
4159 PPC64_ELF_DATA))
4160 {
4161 free (htab);
4162 return NULL;
4163 }
4164
4165 /* Init the stub hash table too. */
4166 if (!bfd_hash_table_init (&htab->stub_hash_table, stub_hash_newfunc,
4167 sizeof (struct ppc_stub_hash_entry)))
4168 {
4169 _bfd_elf_link_hash_table_free ((struct bfd_link_hash_table *) htab);
4170 return NULL;
4171 }
4172
4173 /* And the branch hash table. */
4174 if (!bfd_hash_table_init (&htab->branch_hash_table, branch_hash_newfunc,
4175 sizeof (struct ppc_branch_hash_entry)))
4176 {
4177 bfd_hash_table_free (&htab->stub_hash_table);
4178 _bfd_elf_link_hash_table_free ((struct bfd_link_hash_table *) htab);
4179 return NULL;
4180 }
4181
4182 htab->tocsave_htab = htab_try_create (1024,
4183 tocsave_htab_hash,
4184 tocsave_htab_eq,
4185 NULL);
4186 if (htab->tocsave_htab == NULL)
4187 {
4188 bfd_hash_table_free (&htab->branch_hash_table);
4189 bfd_hash_table_free (&htab->stub_hash_table);
4190 _bfd_elf_link_hash_table_free ((struct bfd_link_hash_table *) htab);
4191 return NULL;
4192 }
4193
4194 /* Initializing two fields of the union is just cosmetic. We really
4195 only care about glist, but when compiled on a 32-bit host the
4196 bfd_vma fields are larger. Setting the bfd_vma to zero makes
4197 debugger inspection of these fields look nicer. */
4198 htab->elf.init_got_refcount.refcount = 0;
4199 htab->elf.init_got_refcount.glist = NULL;
4200 htab->elf.init_plt_refcount.refcount = 0;
4201 htab->elf.init_plt_refcount.glist = NULL;
4202 htab->elf.init_got_offset.offset = 0;
4203 htab->elf.init_got_offset.glist = NULL;
4204 htab->elf.init_plt_offset.offset = 0;
4205 htab->elf.init_plt_offset.glist = NULL;
4206
4207 return &htab->elf.root;
4208 }
4209
4210 /* Free the derived linker hash table. */
4211
4212 static void
4213 ppc64_elf_link_hash_table_free (struct bfd_link_hash_table *hash)
4214 {
4215 struct ppc_link_hash_table *htab = (struct ppc_link_hash_table *) hash;
4216
4217 bfd_hash_table_free (&htab->stub_hash_table);
4218 bfd_hash_table_free (&htab->branch_hash_table);
4219 if (htab->tocsave_htab)
4220 htab_delete (htab->tocsave_htab);
4221 _bfd_elf_link_hash_table_free (hash);
4222 }
4223
4224 /* Create sections for linker generated code. */
4225
4226 static bfd_boolean
4227 create_linkage_sections (bfd *dynobj, struct bfd_link_info *info)
4228 {
4229 struct ppc_link_hash_table *htab;
4230 flagword flags;
4231
4232 htab = ppc_hash_table (info);
4233
4234 /* Create .sfpr for code to save and restore fp regs. */
4235 flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY
4236 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4237 htab->sfpr = bfd_make_section_anyway_with_flags (dynobj, ".sfpr",
4238 flags);
4239 if (htab->sfpr == NULL
4240 || ! bfd_set_section_alignment (dynobj, htab->sfpr, 2))
4241 return FALSE;
4242
4243 /* Create .glink for lazy dynamic linking support. */
4244 htab->glink = bfd_make_section_anyway_with_flags (dynobj, ".glink",
4245 flags);
4246 if (htab->glink == NULL
4247 || ! bfd_set_section_alignment (dynobj, htab->glink, 3))
4248 return FALSE;
4249
4250 if (!info->no_ld_generated_unwind_info)
4251 {
4252 flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_HAS_CONTENTS
4253 | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4254 htab->glink_eh_frame = bfd_make_section_anyway_with_flags (dynobj,
4255 ".eh_frame",
4256 flags);
4257 if (htab->glink_eh_frame == NULL
4258 || !bfd_set_section_alignment (dynobj, htab->glink_eh_frame, 2))
4259 return FALSE;
4260 }
4261
4262 flags = SEC_ALLOC | SEC_LINKER_CREATED;
4263 htab->elf.iplt = bfd_make_section_anyway_with_flags (dynobj, ".iplt", flags);
4264 if (htab->elf.iplt == NULL
4265 || ! bfd_set_section_alignment (dynobj, htab->elf.iplt, 3))
4266 return FALSE;
4267
4268 flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4269 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4270 htab->elf.irelplt
4271 = bfd_make_section_anyway_with_flags (dynobj, ".rela.iplt", flags);
4272 if (htab->elf.irelplt == NULL
4273 || ! bfd_set_section_alignment (dynobj, htab->elf.irelplt, 3))
4274 return FALSE;
4275
4276 /* Create branch lookup table for plt_branch stubs. */
4277 flags = (SEC_ALLOC | SEC_LOAD
4278 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4279 htab->brlt = bfd_make_section_anyway_with_flags (dynobj, ".branch_lt",
4280 flags);
4281 if (htab->brlt == NULL
4282 || ! bfd_set_section_alignment (dynobj, htab->brlt, 3))
4283 return FALSE;
4284
4285 if (!info->shared)
4286 return TRUE;
4287
4288 flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4289 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4290 htab->relbrlt = bfd_make_section_anyway_with_flags (dynobj,
4291 ".rela.branch_lt",
4292 flags);
4293 if (htab->relbrlt == NULL
4294 || ! bfd_set_section_alignment (dynobj, htab->relbrlt, 3))
4295 return FALSE;
4296
4297 return TRUE;
4298 }
4299
4300 /* Satisfy the ELF linker by filling in some fields in our fake bfd. */
4301
4302 bfd_boolean
4303 ppc64_elf_init_stub_bfd (struct bfd_link_info *info,
4304 struct ppc64_elf_params *params)
4305 {
4306 struct ppc_link_hash_table *htab;
4307
4308 elf_elfheader (params->stub_bfd)->e_ident[EI_CLASS] = ELFCLASS64;
4309
4310 /* Always hook our dynamic sections into the first bfd, which is the
4311 linker created stub bfd. This ensures that the GOT header is at
4312 the start of the output TOC section. */
4313 htab = ppc_hash_table (info);
4314 if (htab == NULL)
4315 return FALSE;
4316 htab->elf.dynobj = params->stub_bfd;
4317 htab->params = params;
4318
4319 if (info->relocatable)
4320 return TRUE;
4321
4322 return create_linkage_sections (htab->elf.dynobj, info);
4323 }
4324
4325 /* Build a name for an entry in the stub hash table. */
4326
4327 static char *
4328 ppc_stub_name (const asection *input_section,
4329 const asection *sym_sec,
4330 const struct ppc_link_hash_entry *h,
4331 const Elf_Internal_Rela *rel)
4332 {
4333 char *stub_name;
4334 ssize_t len;
4335
4336 /* rel->r_addend is actually 64 bit, but who uses more than +/- 2^31
4337 offsets from a sym as a branch target? In fact, we could
4338 probably assume the addend is always zero. */
4339 BFD_ASSERT (((int) rel->r_addend & 0xffffffff) == rel->r_addend);
4340
4341 if (h)
4342 {
4343 len = 8 + 1 + strlen (h->elf.root.root.string) + 1 + 8 + 1;
4344 stub_name = bfd_malloc (len);
4345 if (stub_name == NULL)
4346 return stub_name;
4347
4348 len = sprintf (stub_name, "%08x.%s+%x",
4349 input_section->id & 0xffffffff,
4350 h->elf.root.root.string,
4351 (int) rel->r_addend & 0xffffffff);
4352 }
4353 else
4354 {
4355 len = 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1;
4356 stub_name = bfd_malloc (len);
4357 if (stub_name == NULL)
4358 return stub_name;
4359
4360 len = sprintf (stub_name, "%08x.%x:%x+%x",
4361 input_section->id & 0xffffffff,
4362 sym_sec->id & 0xffffffff,
4363 (int) ELF64_R_SYM (rel->r_info) & 0xffffffff,
4364 (int) rel->r_addend & 0xffffffff);
4365 }
4366 if (len > 2 && stub_name[len - 2] == '+' && stub_name[len - 1] == '0')
4367 stub_name[len - 2] = 0;
4368 return stub_name;
4369 }
4370
4371 /* Look up an entry in the stub hash. Stub entries are cached because
4372 creating the stub name takes a bit of time. */
4373
4374 static struct ppc_stub_hash_entry *
4375 ppc_get_stub_entry (const asection *input_section,
4376 const asection *sym_sec,
4377 struct ppc_link_hash_entry *h,
4378 const Elf_Internal_Rela *rel,
4379 struct ppc_link_hash_table *htab)
4380 {
4381 struct ppc_stub_hash_entry *stub_entry;
4382 const asection *id_sec;
4383
4384 /* If this input section is part of a group of sections sharing one
4385 stub section, then use the id of the first section in the group.
4386 Stub names need to include a section id, as there may well be
4387 more than one stub used to reach say, printf, and we need to
4388 distinguish between them. */
4389 id_sec = htab->stub_group[input_section->id].link_sec;
4390
4391 if (h != NULL && h->u.stub_cache != NULL
4392 && h->u.stub_cache->h == h
4393 && h->u.stub_cache->id_sec == id_sec)
4394 {
4395 stub_entry = h->u.stub_cache;
4396 }
4397 else
4398 {
4399 char *stub_name;
4400
4401 stub_name = ppc_stub_name (id_sec, sym_sec, h, rel);
4402 if (stub_name == NULL)
4403 return NULL;
4404
4405 stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
4406 stub_name, FALSE, FALSE);
4407 if (h != NULL)
4408 h->u.stub_cache = stub_entry;
4409
4410 free (stub_name);
4411 }
4412
4413 return stub_entry;
4414 }
4415
4416 /* Add a new stub entry to the stub hash. Not all fields of the new
4417 stub entry are initialised. */
4418
4419 static struct ppc_stub_hash_entry *
4420 ppc_add_stub (const char *stub_name,
4421 asection *section,
4422 struct bfd_link_info *info)
4423 {
4424 struct ppc_link_hash_table *htab = ppc_hash_table (info);
4425 asection *link_sec;
4426 asection *stub_sec;
4427 struct ppc_stub_hash_entry *stub_entry;
4428
4429 link_sec = htab->stub_group[section->id].link_sec;
4430 stub_sec = htab->stub_group[section->id].stub_sec;
4431 if (stub_sec == NULL)
4432 {
4433 stub_sec = htab->stub_group[link_sec->id].stub_sec;
4434 if (stub_sec == NULL)
4435 {
4436 size_t namelen;
4437 bfd_size_type len;
4438 char *s_name;
4439
4440 namelen = strlen (link_sec->name);
4441 len = namelen + sizeof (STUB_SUFFIX);
4442 s_name = bfd_alloc (htab->params->stub_bfd, len);
4443 if (s_name == NULL)
4444 return NULL;
4445
4446 memcpy (s_name, link_sec->name, namelen);
4447 memcpy (s_name + namelen, STUB_SUFFIX, sizeof (STUB_SUFFIX));
4448 stub_sec = (*htab->params->add_stub_section) (s_name, link_sec);
4449 if (stub_sec == NULL)
4450 return NULL;
4451 htab->stub_group[link_sec->id].stub_sec = stub_sec;
4452 }
4453 htab->stub_group[section->id].stub_sec = stub_sec;
4454 }
4455
4456 /* Enter this entry into the linker stub hash table. */
4457 stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table, stub_name,
4458 TRUE, FALSE);
4459 if (stub_entry == NULL)
4460 {
4461 info->callbacks->einfo (_("%P: %B: cannot create stub entry %s\n"),
4462 section->owner, stub_name);
4463 return NULL;
4464 }
4465
4466 stub_entry->stub_sec = stub_sec;
4467 stub_entry->stub_offset = 0;
4468 stub_entry->id_sec = link_sec;
4469 return stub_entry;
4470 }
4471
4472 /* Create .got and .rela.got sections in ABFD, and .got in dynobj if
4473 not already done. */
4474
4475 static bfd_boolean
4476 create_got_section (bfd *abfd, struct bfd_link_info *info)
4477 {
4478 asection *got, *relgot;
4479 flagword flags;
4480 struct ppc_link_hash_table *htab = ppc_hash_table (info);
4481
4482 if (!is_ppc64_elf (abfd))
4483 return FALSE;
4484 if (htab == NULL)
4485 return FALSE;
4486
4487 if (!htab->elf.sgot
4488 && !_bfd_elf_create_got_section (htab->elf.dynobj, info))
4489 return FALSE;
4490
4491 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
4492 | SEC_LINKER_CREATED);
4493
4494 got = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
4495 if (!got
4496 || !bfd_set_section_alignment (abfd, got, 3))
4497 return FALSE;
4498
4499 relgot = bfd_make_section_anyway_with_flags (abfd, ".rela.got",
4500 flags | SEC_READONLY);
4501 if (!relgot
4502 || ! bfd_set_section_alignment (abfd, relgot, 3))
4503 return FALSE;
4504
4505 ppc64_elf_tdata (abfd)->got = got;
4506 ppc64_elf_tdata (abfd)->relgot = relgot;
4507 return TRUE;
4508 }
4509
4510 /* Create the dynamic sections, and set up shortcuts. */
4511
4512 static bfd_boolean
4513 ppc64_elf_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
4514 {
4515 struct ppc_link_hash_table *htab;
4516
4517 if (!_bfd_elf_create_dynamic_sections (dynobj, info))
4518 return FALSE;
4519
4520 htab = ppc_hash_table (info);
4521 if (htab == NULL)
4522 return FALSE;
4523
4524 htab->dynbss = bfd_get_linker_section (dynobj, ".dynbss");
4525 if (!info->shared)
4526 htab->relbss = bfd_get_linker_section (dynobj, ".rela.bss");
4527
4528 if (!htab->elf.sgot || !htab->elf.splt || !htab->elf.srelplt || !htab->dynbss
4529 || (!info->shared && !htab->relbss))
4530 abort ();
4531
4532 return TRUE;
4533 }
4534
4535 /* Follow indirect and warning symbol links. */
4536
4537 static inline struct bfd_link_hash_entry *
4538 follow_link (struct bfd_link_hash_entry *h)
4539 {
4540 while (h->type == bfd_link_hash_indirect
4541 || h->type == bfd_link_hash_warning)
4542 h = h->u.i.link;
4543 return h;
4544 }
4545
4546 static inline struct elf_link_hash_entry *
4547 elf_follow_link (struct elf_link_hash_entry *h)
4548 {
4549 return (struct elf_link_hash_entry *) follow_link (&h->root);
4550 }
4551
4552 static inline struct ppc_link_hash_entry *
4553 ppc_follow_link (struct ppc_link_hash_entry *h)
4554 {
4555 return (struct ppc_link_hash_entry *) follow_link (&h->elf.root);
4556 }
4557
4558 /* Merge PLT info on FROM with that on TO. */
4559
4560 static void
4561 move_plt_plist (struct ppc_link_hash_entry *from,
4562 struct ppc_link_hash_entry *to)
4563 {
4564 if (from->elf.plt.plist != NULL)
4565 {
4566 if (to->elf.plt.plist != NULL)
4567 {
4568 struct plt_entry **entp;
4569 struct plt_entry *ent;
4570
4571 for (entp = &from->elf.plt.plist; (ent = *entp) != NULL; )
4572 {
4573 struct plt_entry *dent;
4574
4575 for (dent = to->elf.plt.plist; dent != NULL; dent = dent->next)
4576 if (dent->addend == ent->addend)
4577 {
4578 dent->plt.refcount += ent->plt.refcount;
4579 *entp = ent->next;
4580 break;
4581 }
4582 if (dent == NULL)
4583 entp = &ent->next;
4584 }
4585 *entp = to->elf.plt.plist;
4586 }
4587
4588 to->elf.plt.plist = from->elf.plt.plist;
4589 from->elf.plt.plist = NULL;
4590 }
4591 }
4592
4593 /* Copy the extra info we tack onto an elf_link_hash_entry. */
4594
4595 static void
4596 ppc64_elf_copy_indirect_symbol (struct bfd_link_info *info,
4597 struct elf_link_hash_entry *dir,
4598 struct elf_link_hash_entry *ind)
4599 {
4600 struct ppc_link_hash_entry *edir, *eind;
4601
4602 edir = (struct ppc_link_hash_entry *) dir;
4603 eind = (struct ppc_link_hash_entry *) ind;
4604
4605 edir->is_func |= eind->is_func;
4606 edir->is_func_descriptor |= eind->is_func_descriptor;
4607 edir->tls_mask |= eind->tls_mask;
4608 if (eind->oh != NULL)
4609 edir->oh = ppc_follow_link (eind->oh);
4610
4611 /* If called to transfer flags for a weakdef during processing
4612 of elf_adjust_dynamic_symbol, don't copy NON_GOT_REF.
4613 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
4614 if (!(ELIMINATE_COPY_RELOCS
4615 && eind->elf.root.type != bfd_link_hash_indirect
4616 && edir->elf.dynamic_adjusted))
4617 edir->elf.non_got_ref |= eind->elf.non_got_ref;
4618
4619 edir->elf.ref_dynamic |= eind->elf.ref_dynamic;
4620 edir->elf.ref_regular |= eind->elf.ref_regular;
4621 edir->elf.ref_regular_nonweak |= eind->elf.ref_regular_nonweak;
4622 edir->elf.needs_plt |= eind->elf.needs_plt;
4623 edir->elf.pointer_equality_needed |= eind->elf.pointer_equality_needed;
4624
4625 /* Copy over any dynamic relocs we may have on the indirect sym. */
4626 if (eind->dyn_relocs != NULL)
4627 {
4628 if (edir->dyn_relocs != NULL)
4629 {
4630 struct elf_dyn_relocs **pp;
4631 struct elf_dyn_relocs *p;
4632
4633 /* Add reloc counts against the indirect sym to the direct sym
4634 list. Merge any entries against the same section. */
4635 for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
4636 {
4637 struct elf_dyn_relocs *q;
4638
4639 for (q = edir->dyn_relocs; q != NULL; q = q->next)
4640 if (q->sec == p->sec)
4641 {
4642 q->pc_count += p->pc_count;
4643 q->count += p->count;
4644 *pp = p->next;
4645 break;
4646 }
4647 if (q == NULL)
4648 pp = &p->next;
4649 }
4650 *pp = edir->dyn_relocs;
4651 }
4652
4653 edir->dyn_relocs = eind->dyn_relocs;
4654 eind->dyn_relocs = NULL;
4655 }
4656
4657 /* If we were called to copy over info for a weak sym, that's all.
4658 You might think dyn_relocs need not be copied over; After all,
4659 both syms will be dynamic or both non-dynamic so we're just
4660 moving reloc accounting around. However, ELIMINATE_COPY_RELOCS
4661 code in ppc64_elf_adjust_dynamic_symbol needs to check for
4662 dyn_relocs in read-only sections, and it does so on what is the
4663 DIR sym here. */
4664 if (eind->elf.root.type != bfd_link_hash_indirect)
4665 return;
4666
4667 /* Copy over got entries that we may have already seen to the
4668 symbol which just became indirect. */
4669 if (eind->elf.got.glist != NULL)
4670 {
4671 if (edir->elf.got.glist != NULL)
4672 {
4673 struct got_entry **entp;
4674 struct got_entry *ent;
4675
4676 for (entp = &eind->elf.got.glist; (ent = *entp) != NULL; )
4677 {
4678 struct got_entry *dent;
4679
4680 for (dent = edir->elf.got.glist; dent != NULL; dent = dent->next)
4681 if (dent->addend == ent->addend
4682 && dent->owner == ent->owner
4683 && dent->tls_type == ent->tls_type)
4684 {
4685 dent->got.refcount += ent->got.refcount;
4686 *entp = ent->next;
4687 break;
4688 }
4689 if (dent == NULL)
4690 entp = &ent->next;
4691 }
4692 *entp = edir->elf.got.glist;
4693 }
4694
4695 edir->elf.got.glist = eind->elf.got.glist;
4696 eind->elf.got.glist = NULL;
4697 }
4698
4699 /* And plt entries. */
4700 move_plt_plist (eind, edir);
4701
4702 if (eind->elf.dynindx != -1)
4703 {
4704 if (edir->elf.dynindx != -1)
4705 _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
4706 edir->elf.dynstr_index);
4707 edir->elf.dynindx = eind->elf.dynindx;
4708 edir->elf.dynstr_index = eind->elf.dynstr_index;
4709 eind->elf.dynindx = -1;
4710 eind->elf.dynstr_index = 0;
4711 }
4712 }
4713
4714 /* Find the function descriptor hash entry from the given function code
4715 hash entry FH. Link the entries via their OH fields. */
4716
4717 static struct ppc_link_hash_entry *
4718 lookup_fdh (struct ppc_link_hash_entry *fh, struct ppc_link_hash_table *htab)
4719 {
4720 struct ppc_link_hash_entry *fdh = fh->oh;
4721
4722 if (fdh == NULL)
4723 {
4724 const char *fd_name = fh->elf.root.root.string + 1;
4725
4726 fdh = (struct ppc_link_hash_entry *)
4727 elf_link_hash_lookup (&htab->elf, fd_name, FALSE, FALSE, FALSE);
4728 if (fdh == NULL)
4729 return fdh;
4730
4731 fdh->is_func_descriptor = 1;
4732 fdh->oh = fh;
4733 fh->is_func = 1;
4734 fh->oh = fdh;
4735 }
4736
4737 return ppc_follow_link (fdh);
4738 }
4739
4740 /* Make a fake function descriptor sym for the code sym FH. */
4741
4742 static struct ppc_link_hash_entry *
4743 make_fdh (struct bfd_link_info *info,
4744 struct ppc_link_hash_entry *fh)
4745 {
4746 bfd *abfd;
4747 asymbol *newsym;
4748 struct bfd_link_hash_entry *bh;
4749 struct ppc_link_hash_entry *fdh;
4750
4751 abfd = fh->elf.root.u.undef.abfd;
4752 newsym = bfd_make_empty_symbol (abfd);
4753 newsym->name = fh->elf.root.root.string + 1;
4754 newsym->section = bfd_und_section_ptr;
4755 newsym->value = 0;
4756 newsym->flags = BSF_WEAK;
4757
4758 bh = NULL;
4759 if (!_bfd_generic_link_add_one_symbol (info, abfd, newsym->name,
4760 newsym->flags, newsym->section,
4761 newsym->value, NULL, FALSE, FALSE,
4762 &bh))
4763 return NULL;
4764
4765 fdh = (struct ppc_link_hash_entry *) bh;
4766 fdh->elf.non_elf = 0;
4767 fdh->fake = 1;
4768 fdh->is_func_descriptor = 1;
4769 fdh->oh = fh;
4770 fh->is_func = 1;
4771 fh->oh = fdh;
4772 return fdh;
4773 }
4774
4775 /* Fix function descriptor symbols defined in .opd sections to be
4776 function type. */
4777
4778 static bfd_boolean
4779 ppc64_elf_add_symbol_hook (bfd *ibfd,
4780 struct bfd_link_info *info,
4781 Elf_Internal_Sym *isym,
4782 const char **name,
4783 flagword *flags ATTRIBUTE_UNUSED,
4784 asection **sec,
4785 bfd_vma *value ATTRIBUTE_UNUSED)
4786 {
4787 if ((ibfd->flags & DYNAMIC) == 0
4788 && ELF_ST_BIND (isym->st_info) == STB_GNU_UNIQUE)
4789 elf_tdata (info->output_bfd)->has_gnu_symbols = TRUE;
4790
4791 if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
4792 {
4793 if ((ibfd->flags & DYNAMIC) == 0)
4794 elf_tdata (info->output_bfd)->has_gnu_symbols = TRUE;
4795 }
4796 else if (ELF_ST_TYPE (isym->st_info) == STT_FUNC)
4797 ;
4798 else if (*sec != NULL
4799 && strcmp ((*sec)->name, ".opd") == 0)
4800 isym->st_info = ELF_ST_INFO (ELF_ST_BIND (isym->st_info), STT_FUNC);
4801
4802 if ((STO_PPC64_LOCAL_MASK & isym->st_other) != 0)
4803 {
4804 if (abiversion (ibfd) == 0)
4805 set_abiversion (ibfd, 2);
4806 else if (abiversion (ibfd) == 1)
4807 {
4808 info->callbacks->einfo (_("%P: symbol '%s' has invalid st_other"
4809 " for ABI version 1\n"), name);
4810 bfd_set_error (bfd_error_bad_value);
4811 return FALSE;
4812 }
4813 }
4814
4815 return TRUE;
4816 }
4817
4818 /* Merge non-visibility st_other attributes: local entry point. */
4819
4820 static void
4821 ppc64_elf_merge_symbol_attribute (struct elf_link_hash_entry *h,
4822 const Elf_Internal_Sym *isym,
4823 bfd_boolean definition,
4824 bfd_boolean dynamic)
4825 {
4826 if (definition && !dynamic)
4827 h->other = ((isym->st_other & ~ELF_ST_VISIBILITY (-1))
4828 | ELF_ST_VISIBILITY (h->other));
4829 }
4830
4831 /* This function makes an old ABI object reference to ".bar" cause the
4832 inclusion of a new ABI object archive that defines "bar".
4833 NAME is a symbol defined in an archive. Return a symbol in the hash
4834 table that might be satisfied by the archive symbols. */
4835
4836 static struct elf_link_hash_entry *
4837 ppc64_elf_archive_symbol_lookup (bfd *abfd,
4838 struct bfd_link_info *info,
4839 const char *name)
4840 {
4841 struct elf_link_hash_entry *h;
4842 char *dot_name;
4843 size_t len;
4844
4845 h = _bfd_elf_archive_symbol_lookup (abfd, info, name);
4846 if (h != NULL
4847 /* Don't return this sym if it is a fake function descriptor
4848 created by add_symbol_adjust. */
4849 && !(h->root.type == bfd_link_hash_undefweak
4850 && ((struct ppc_link_hash_entry *) h)->fake))
4851 return h;
4852
4853 if (name[0] == '.')
4854 return h;
4855
4856 len = strlen (name);
4857 dot_name = bfd_alloc (abfd, len + 2);
4858 if (dot_name == NULL)
4859 return (struct elf_link_hash_entry *) 0 - 1;
4860 dot_name[0] = '.';
4861 memcpy (dot_name + 1, name, len + 1);
4862 h = _bfd_elf_archive_symbol_lookup (abfd, info, dot_name);
4863 bfd_release (abfd, dot_name);
4864 return h;
4865 }
4866
4867 /* This function satisfies all old ABI object references to ".bar" if a
4868 new ABI object defines "bar". Well, at least, undefined dot symbols
4869 are made weak. This stops later archive searches from including an
4870 object if we already have a function descriptor definition. It also
4871 prevents the linker complaining about undefined symbols.
4872 We also check and correct mismatched symbol visibility here. The
4873 most restrictive visibility of the function descriptor and the
4874 function entry symbol is used. */
4875
4876 static bfd_boolean
4877 add_symbol_adjust (struct ppc_link_hash_entry *eh, struct bfd_link_info *info)
4878 {
4879 struct ppc_link_hash_table *htab;
4880 struct ppc_link_hash_entry *fdh;
4881
4882 if (eh->elf.root.type == bfd_link_hash_indirect)
4883 return TRUE;
4884
4885 if (eh->elf.root.type == bfd_link_hash_warning)
4886 eh = (struct ppc_link_hash_entry *) eh->elf.root.u.i.link;
4887
4888 if (eh->elf.root.root.string[0] != '.')
4889 abort ();
4890
4891 htab = ppc_hash_table (info);
4892 if (htab == NULL)
4893 return FALSE;
4894
4895 fdh = lookup_fdh (eh, htab);
4896 if (fdh == NULL)
4897 {
4898 if (!info->relocatable
4899 && (eh->elf.root.type == bfd_link_hash_undefined
4900 || eh->elf.root.type == bfd_link_hash_undefweak)
4901 && eh->elf.ref_regular)
4902 {
4903 /* Make an undefweak function descriptor sym, which is enough to
4904 pull in an --as-needed shared lib, but won't cause link
4905 errors. Archives are handled elsewhere. */
4906 fdh = make_fdh (info, eh);
4907 if (fdh == NULL)
4908 return FALSE;
4909 fdh->elf.ref_regular = 1;
4910 }
4911 }
4912 else
4913 {
4914 unsigned entry_vis = ELF_ST_VISIBILITY (eh->elf.other) - 1;
4915 unsigned descr_vis = ELF_ST_VISIBILITY (fdh->elf.other) - 1;
4916 if (entry_vis < descr_vis)
4917 fdh->elf.other += entry_vis - descr_vis;
4918 else if (entry_vis > descr_vis)
4919 eh->elf.other += descr_vis - entry_vis;
4920
4921 if ((fdh->elf.root.type == bfd_link_hash_defined
4922 || fdh->elf.root.type == bfd_link_hash_defweak)
4923 && eh->elf.root.type == bfd_link_hash_undefined)
4924 {
4925 eh->elf.root.type = bfd_link_hash_undefweak;
4926 eh->was_undefined = 1;
4927 htab->twiddled_syms = 1;
4928 }
4929 }
4930
4931 return TRUE;
4932 }
4933
4934 /* Set up opd section info and abiversion for IBFD, and process list
4935 of dot-symbols we made in link_hash_newfunc. */
4936
4937 static bfd_boolean
4938 ppc64_elf_before_check_relocs (bfd *ibfd, struct bfd_link_info *info)
4939 {
4940 struct ppc_link_hash_table *htab;
4941 struct ppc_link_hash_entry **p, *eh;
4942
4943 if (!is_ppc64_elf (info->output_bfd))
4944 return TRUE;
4945 htab = ppc_hash_table (info);
4946 if (htab == NULL)
4947 return FALSE;
4948
4949 if (is_ppc64_elf (ibfd))
4950 {
4951 asection *opd = bfd_get_section_by_name (ibfd, ".opd");
4952
4953 if (opd != NULL && opd->size != 0)
4954 {
4955 if (abiversion (ibfd) == 0)
4956 set_abiversion (ibfd, 1);
4957 else if (abiversion (ibfd) == 2)
4958 {
4959 info->callbacks->einfo (_("%P: %B .opd not allowed in ABI"
4960 " version %d\n"),
4961 ibfd, abiversion (ibfd));
4962 bfd_set_error (bfd_error_bad_value);
4963 return FALSE;
4964 }
4965
4966 if ((ibfd->flags & DYNAMIC) == 0
4967 && (opd->flags & SEC_RELOC) != 0
4968 && opd->reloc_count != 0
4969 && !bfd_is_abs_section (opd->output_section))
4970 {
4971 /* Garbage collection needs some extra help with .opd sections.
4972 We don't want to necessarily keep everything referenced by
4973 relocs in .opd, as that would keep all functions. Instead,
4974 if we reference an .opd symbol (a function descriptor), we
4975 want to keep the function code symbol's section. This is
4976 easy for global symbols, but for local syms we need to keep
4977 information about the associated function section. */
4978 bfd_size_type amt;
4979 asection **opd_sym_map;
4980
4981 amt = opd->size * sizeof (*opd_sym_map) / 8;
4982 opd_sym_map = bfd_zalloc (ibfd, amt);
4983 if (opd_sym_map == NULL)
4984 return FALSE;
4985 ppc64_elf_section_data (opd)->u.opd.func_sec = opd_sym_map;
4986 BFD_ASSERT (ppc64_elf_section_data (opd)->sec_type == sec_normal);
4987 ppc64_elf_section_data (opd)->sec_type = sec_opd;
4988 }
4989 }
4990
4991 /* For input files without an explicit abiversion in e_flags
4992 we should have flagged any with symbol st_other bits set
4993 as ELFv1 and above flagged those with .opd as ELFv2.
4994 Set the output abiversion if not yet set, and for any input
4995 still ambiguous, take its abiversion from the output.
4996 Differences in ABI are reported later. */
4997 if (abiversion (info->output_bfd) == 0)
4998 set_abiversion (info->output_bfd, abiversion (ibfd));
4999 else if (abiversion (ibfd) == 0)
5000 set_abiversion (ibfd, abiversion (info->output_bfd));
5001
5002 p = &htab->dot_syms;
5003 while ((eh = *p) != NULL)
5004 {
5005 *p = NULL;
5006 if (&eh->elf == htab->elf.hgot)
5007 ;
5008 else if (htab->elf.hgot == NULL
5009 && strcmp (eh->elf.root.root.string, ".TOC.") == 0)
5010 htab->elf.hgot = &eh->elf;
5011 else if (!add_symbol_adjust (eh, info))
5012 return FALSE;
5013 p = &eh->u.next_dot_sym;
5014 }
5015 }
5016
5017 /* Clear the list for non-ppc64 input files. */
5018 p = &htab->dot_syms;
5019 while ((eh = *p) != NULL)
5020 {
5021 *p = NULL;
5022 p = &eh->u.next_dot_sym;
5023 }
5024
5025 /* We need to fix the undefs list for any syms we have twiddled to
5026 undef_weak. */
5027 if (htab->twiddled_syms)
5028 {
5029 bfd_link_repair_undef_list (&htab->elf.root);
5030 htab->twiddled_syms = 0;
5031 }
5032 return TRUE;
5033 }
5034
5035 /* Undo hash table changes when an --as-needed input file is determined
5036 not to be needed. */
5037
5038 static bfd_boolean
5039 ppc64_elf_notice_as_needed (bfd *ibfd,
5040 struct bfd_link_info *info,
5041 enum notice_asneeded_action act)
5042 {
5043 if (act == notice_not_needed)
5044 {
5045 struct ppc_link_hash_table *htab = ppc_hash_table (info);
5046
5047 if (htab == NULL)
5048 return FALSE;
5049
5050 htab->dot_syms = NULL;
5051 }
5052 return _bfd_elf_notice_as_needed (ibfd, info, act);
5053 }
5054
5055 /* If --just-symbols against a final linked binary, then assume we need
5056 toc adjusting stubs when calling functions defined there. */
5057
5058 static void
5059 ppc64_elf_link_just_syms (asection *sec, struct bfd_link_info *info)
5060 {
5061 if ((sec->flags & SEC_CODE) != 0
5062 && (sec->owner->flags & (EXEC_P | DYNAMIC)) != 0
5063 && is_ppc64_elf (sec->owner))
5064 {
5065 if (abiversion (sec->owner) >= 2
5066 || bfd_get_section_by_name (sec->owner, ".opd") != NULL)
5067 sec->has_toc_reloc = 1;
5068 }
5069 _bfd_elf_link_just_syms (sec, info);
5070 }
5071
5072 static struct plt_entry **
5073 update_local_sym_info (bfd *abfd, Elf_Internal_Shdr *symtab_hdr,
5074 unsigned long r_symndx, bfd_vma r_addend, int tls_type)
5075 {
5076 struct got_entry **local_got_ents = elf_local_got_ents (abfd);
5077 struct plt_entry **local_plt;
5078 unsigned char *local_got_tls_masks;
5079
5080 if (local_got_ents == NULL)
5081 {
5082 bfd_size_type size = symtab_hdr->sh_info;
5083
5084 size *= (sizeof (*local_got_ents)
5085 + sizeof (*local_plt)
5086 + sizeof (*local_got_tls_masks));
5087 local_got_ents = bfd_zalloc (abfd, size);
5088 if (local_got_ents == NULL)
5089 return NULL;
5090 elf_local_got_ents (abfd) = local_got_ents;
5091 }
5092
5093 if ((tls_type & (PLT_IFUNC | TLS_EXPLICIT)) == 0)
5094 {
5095 struct got_entry *ent;
5096
5097 for (ent = local_got_ents[r_symndx]; ent != NULL; ent = ent->next)
5098 if (ent->addend == r_addend
5099 && ent->owner == abfd
5100 && ent->tls_type == tls_type)
5101 break;
5102 if (ent == NULL)
5103 {
5104 bfd_size_type amt = sizeof (*ent);
5105 ent = bfd_alloc (abfd, amt);
5106 if (ent == NULL)
5107 return FALSE;
5108 ent->next = local_got_ents[r_symndx];
5109 ent->addend = r_addend;
5110 ent->owner = abfd;
5111 ent->tls_type = tls_type;
5112 ent->is_indirect = FALSE;
5113 ent->got.refcount = 0;
5114 local_got_ents[r_symndx] = ent;
5115 }
5116 ent->got.refcount += 1;
5117 }
5118
5119 local_plt = (struct plt_entry **) (local_got_ents + symtab_hdr->sh_info);
5120 local_got_tls_masks = (unsigned char *) (local_plt + symtab_hdr->sh_info);
5121 local_got_tls_masks[r_symndx] |= tls_type;
5122
5123 return local_plt + r_symndx;
5124 }
5125
5126 static bfd_boolean
5127 update_plt_info (bfd *abfd, struct plt_entry **plist, bfd_vma addend)
5128 {
5129 struct plt_entry *ent;
5130
5131 for (ent = *plist; ent != NULL; ent = ent->next)
5132 if (ent->addend == addend)
5133 break;
5134 if (ent == NULL)
5135 {
5136 bfd_size_type amt = sizeof (*ent);
5137 ent = bfd_alloc (abfd, amt);
5138 if (ent == NULL)
5139 return FALSE;
5140 ent->next = *plist;
5141 ent->addend = addend;
5142 ent->plt.refcount = 0;
5143 *plist = ent;
5144 }
5145 ent->plt.refcount += 1;
5146 return TRUE;
5147 }
5148
5149 static bfd_boolean
5150 is_branch_reloc (enum elf_ppc64_reloc_type r_type)
5151 {
5152 return (r_type == R_PPC64_REL24
5153 || r_type == R_PPC64_REL14
5154 || r_type == R_PPC64_REL14_BRTAKEN
5155 || r_type == R_PPC64_REL14_BRNTAKEN
5156 || r_type == R_PPC64_ADDR24
5157 || r_type == R_PPC64_ADDR14
5158 || r_type == R_PPC64_ADDR14_BRTAKEN
5159 || r_type == R_PPC64_ADDR14_BRNTAKEN);
5160 }
5161
5162 /* Look through the relocs for a section during the first phase, and
5163 calculate needed space in the global offset table, procedure
5164 linkage table, and dynamic reloc sections. */
5165
5166 static bfd_boolean
5167 ppc64_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
5168 asection *sec, const Elf_Internal_Rela *relocs)
5169 {
5170 struct ppc_link_hash_table *htab;
5171 Elf_Internal_Shdr *symtab_hdr;
5172 struct elf_link_hash_entry **sym_hashes;
5173 const Elf_Internal_Rela *rel;
5174 const Elf_Internal_Rela *rel_end;
5175 asection *sreloc;
5176 asection **opd_sym_map;
5177 struct elf_link_hash_entry *tga, *dottga;
5178
5179 if (info->relocatable)
5180 return TRUE;
5181
5182 /* Don't do anything special with non-loaded, non-alloced sections.
5183 In particular, any relocs in such sections should not affect GOT
5184 and PLT reference counting (ie. we don't allow them to create GOT
5185 or PLT entries), there's no possibility or desire to optimize TLS
5186 relocs, and there's not much point in propagating relocs to shared
5187 libs that the dynamic linker won't relocate. */
5188 if ((sec->flags & SEC_ALLOC) == 0)
5189 return TRUE;
5190
5191 BFD_ASSERT (is_ppc64_elf (abfd));
5192
5193 htab = ppc_hash_table (info);
5194 if (htab == NULL)
5195 return FALSE;
5196
5197 tga = elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
5198 FALSE, FALSE, TRUE);
5199 dottga = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
5200 FALSE, FALSE, TRUE);
5201 symtab_hdr = &elf_symtab_hdr (abfd);
5202 sym_hashes = elf_sym_hashes (abfd);
5203 sreloc = NULL;
5204 opd_sym_map = NULL;
5205 if (ppc64_elf_section_data (sec) != NULL
5206 && ppc64_elf_section_data (sec)->sec_type == sec_opd)
5207 opd_sym_map = ppc64_elf_section_data (sec)->u.opd.func_sec;
5208
5209 rel_end = relocs + sec->reloc_count;
5210 for (rel = relocs; rel < rel_end; rel++)
5211 {
5212 unsigned long r_symndx;
5213 struct elf_link_hash_entry *h;
5214 enum elf_ppc64_reloc_type r_type;
5215 int tls_type;
5216 struct _ppc64_elf_section_data *ppc64_sec;
5217 struct plt_entry **ifunc;
5218
5219 r_symndx = ELF64_R_SYM (rel->r_info);
5220 if (r_symndx < symtab_hdr->sh_info)
5221 h = NULL;
5222 else
5223 {
5224 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
5225 h = elf_follow_link (h);
5226
5227 /* PR15323, ref flags aren't set for references in the same
5228 object. */
5229 h->root.non_ir_ref = 1;
5230
5231 if (h == htab->elf.hgot)
5232 sec->has_toc_reloc = 1;
5233 }
5234
5235 tls_type = 0;
5236 ifunc = NULL;
5237 if (h != NULL)
5238 {
5239 if (h->type == STT_GNU_IFUNC)
5240 {
5241 h->needs_plt = 1;
5242 ifunc = &h->plt.plist;
5243 }
5244 }
5245 else
5246 {
5247 Elf_Internal_Sym *isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5248 abfd, r_symndx);
5249 if (isym == NULL)
5250 return FALSE;
5251
5252 if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
5253 {
5254 ifunc = update_local_sym_info (abfd, symtab_hdr, r_symndx,
5255 rel->r_addend, PLT_IFUNC);
5256 if (ifunc == NULL)
5257 return FALSE;
5258 }
5259 }
5260 r_type = ELF64_R_TYPE (rel->r_info);
5261 if (is_branch_reloc (r_type))
5262 {
5263 if (h != NULL && (h == tga || h == dottga))
5264 {
5265 if (rel != relocs
5266 && (ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSGD
5267 || ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSLD))
5268 /* We have a new-style __tls_get_addr call with a marker
5269 reloc. */
5270 ;
5271 else
5272 /* Mark this section as having an old-style call. */
5273 sec->has_tls_get_addr_call = 1;
5274 }
5275
5276 /* STT_GNU_IFUNC symbols must have a PLT entry. */
5277 if (ifunc != NULL
5278 && !update_plt_info (abfd, ifunc, rel->r_addend))
5279 return FALSE;
5280 }
5281
5282 switch (r_type)
5283 {
5284 case R_PPC64_TLSGD:
5285 case R_PPC64_TLSLD:
5286 /* These special tls relocs tie a call to __tls_get_addr with
5287 its parameter symbol. */
5288 break;
5289
5290 case R_PPC64_GOT_TLSLD16:
5291 case R_PPC64_GOT_TLSLD16_LO:
5292 case R_PPC64_GOT_TLSLD16_HI:
5293 case R_PPC64_GOT_TLSLD16_HA:
5294 tls_type = TLS_TLS | TLS_LD;
5295 goto dogottls;
5296
5297 case R_PPC64_GOT_TLSGD16:
5298 case R_PPC64_GOT_TLSGD16_LO:
5299 case R_PPC64_GOT_TLSGD16_HI:
5300 case R_PPC64_GOT_TLSGD16_HA:
5301 tls_type = TLS_TLS | TLS_GD;
5302 goto dogottls;
5303
5304 case R_PPC64_GOT_TPREL16_DS:
5305 case R_PPC64_GOT_TPREL16_LO_DS:
5306 case R_PPC64_GOT_TPREL16_HI:
5307 case R_PPC64_GOT_TPREL16_HA:
5308 if (!info->executable)
5309 info->flags |= DF_STATIC_TLS;
5310 tls_type = TLS_TLS | TLS_TPREL;
5311 goto dogottls;
5312
5313 case R_PPC64_GOT_DTPREL16_DS:
5314 case R_PPC64_GOT_DTPREL16_LO_DS:
5315 case R_PPC64_GOT_DTPREL16_HI:
5316 case R_PPC64_GOT_DTPREL16_HA:
5317 tls_type = TLS_TLS | TLS_DTPREL;
5318 dogottls:
5319 sec->has_tls_reloc = 1;
5320 /* Fall thru */
5321
5322 case R_PPC64_GOT16:
5323 case R_PPC64_GOT16_DS:
5324 case R_PPC64_GOT16_HA:
5325 case R_PPC64_GOT16_HI:
5326 case R_PPC64_GOT16_LO:
5327 case R_PPC64_GOT16_LO_DS:
5328 /* This symbol requires a global offset table entry. */
5329 sec->has_toc_reloc = 1;
5330 if (r_type == R_PPC64_GOT_TLSLD16
5331 || r_type == R_PPC64_GOT_TLSGD16
5332 || r_type == R_PPC64_GOT_TPREL16_DS
5333 || r_type == R_PPC64_GOT_DTPREL16_DS
5334 || r_type == R_PPC64_GOT16
5335 || r_type == R_PPC64_GOT16_DS)
5336 {
5337 htab->do_multi_toc = 1;
5338 ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5339 }
5340
5341 if (ppc64_elf_tdata (abfd)->got == NULL
5342 && !create_got_section (abfd, info))
5343 return FALSE;
5344
5345 if (h != NULL)
5346 {
5347 struct ppc_link_hash_entry *eh;
5348 struct got_entry *ent;
5349
5350 eh = (struct ppc_link_hash_entry *) h;
5351 for (ent = eh->elf.got.glist; ent != NULL; ent = ent->next)
5352 if (ent->addend == rel->r_addend
5353 && ent->owner == abfd
5354 && ent->tls_type == tls_type)
5355 break;
5356 if (ent == NULL)
5357 {
5358 bfd_size_type amt = sizeof (*ent);
5359 ent = bfd_alloc (abfd, amt);
5360 if (ent == NULL)
5361 return FALSE;
5362 ent->next = eh->elf.got.glist;
5363 ent->addend = rel->r_addend;
5364 ent->owner = abfd;
5365 ent->tls_type = tls_type;
5366 ent->is_indirect = FALSE;
5367 ent->got.refcount = 0;
5368 eh->elf.got.glist = ent;
5369 }
5370 ent->got.refcount += 1;
5371 eh->tls_mask |= tls_type;
5372 }
5373 else
5374 /* This is a global offset table entry for a local symbol. */
5375 if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5376 rel->r_addend, tls_type))
5377 return FALSE;
5378
5379 /* We may also need a plt entry if the symbol turns out to be
5380 an ifunc. */
5381 if (h != NULL && !info->shared && abiversion (abfd) != 1)
5382 {
5383 if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5384 return FALSE;
5385 }
5386 break;
5387
5388 case R_PPC64_PLT16_HA:
5389 case R_PPC64_PLT16_HI:
5390 case R_PPC64_PLT16_LO:
5391 case R_PPC64_PLT32:
5392 case R_PPC64_PLT64:
5393 /* This symbol requires a procedure linkage table entry. We
5394 actually build the entry in adjust_dynamic_symbol,
5395 because this might be a case of linking PIC code without
5396 linking in any dynamic objects, in which case we don't
5397 need to generate a procedure linkage table after all. */
5398 if (h == NULL)
5399 {
5400 /* It does not make sense to have a procedure linkage
5401 table entry for a local symbol. */
5402 bfd_set_error (bfd_error_bad_value);
5403 return FALSE;
5404 }
5405 else
5406 {
5407 if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5408 return FALSE;
5409 h->needs_plt = 1;
5410 if (h->root.root.string[0] == '.'
5411 && h->root.root.string[1] != '\0')
5412 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5413 }
5414 break;
5415
5416 /* The following relocations don't need to propagate the
5417 relocation if linking a shared object since they are
5418 section relative. */
5419 case R_PPC64_SECTOFF:
5420 case R_PPC64_SECTOFF_LO:
5421 case R_PPC64_SECTOFF_HI:
5422 case R_PPC64_SECTOFF_HA:
5423 case R_PPC64_SECTOFF_DS:
5424 case R_PPC64_SECTOFF_LO_DS:
5425 case R_PPC64_DTPREL16:
5426 case R_PPC64_DTPREL16_LO:
5427 case R_PPC64_DTPREL16_HI:
5428 case R_PPC64_DTPREL16_HA:
5429 case R_PPC64_DTPREL16_DS:
5430 case R_PPC64_DTPREL16_LO_DS:
5431 case R_PPC64_DTPREL16_HIGH:
5432 case R_PPC64_DTPREL16_HIGHA:
5433 case R_PPC64_DTPREL16_HIGHER:
5434 case R_PPC64_DTPREL16_HIGHERA:
5435 case R_PPC64_DTPREL16_HIGHEST:
5436 case R_PPC64_DTPREL16_HIGHESTA:
5437 break;
5438
5439 /* Nor do these. */
5440 case R_PPC64_REL16:
5441 case R_PPC64_REL16_LO:
5442 case R_PPC64_REL16_HI:
5443 case R_PPC64_REL16_HA:
5444 break;
5445
5446 /* Not supported as a dynamic relocation. */
5447 case R_PPC64_ADDR64_LOCAL:
5448 if (info->shared)
5449 {
5450 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
5451 ppc_howto_init ();
5452 info->callbacks->einfo (_("%P: %H: %s reloc unsupported "
5453 "in shared libraries and PIEs.\n"),
5454 abfd, sec, rel->r_offset,
5455 ppc64_elf_howto_table[r_type]->name);
5456 bfd_set_error (bfd_error_bad_value);
5457 return FALSE;
5458 }
5459 break;
5460
5461 case R_PPC64_TOC16:
5462 case R_PPC64_TOC16_DS:
5463 htab->do_multi_toc = 1;
5464 ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5465 case R_PPC64_TOC16_LO:
5466 case R_PPC64_TOC16_HI:
5467 case R_PPC64_TOC16_HA:
5468 case R_PPC64_TOC16_LO_DS:
5469 sec->has_toc_reloc = 1;
5470 break;
5471
5472 /* This relocation describes the C++ object vtable hierarchy.
5473 Reconstruct it for later use during GC. */
5474 case R_PPC64_GNU_VTINHERIT:
5475 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
5476 return FALSE;
5477 break;
5478
5479 /* This relocation describes which C++ vtable entries are actually
5480 used. Record for later use during GC. */
5481 case R_PPC64_GNU_VTENTRY:
5482 BFD_ASSERT (h != NULL);
5483 if (h != NULL
5484 && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
5485 return FALSE;
5486 break;
5487
5488 case R_PPC64_REL14:
5489 case R_PPC64_REL14_BRTAKEN:
5490 case R_PPC64_REL14_BRNTAKEN:
5491 {
5492 asection *dest = NULL;
5493
5494 /* Heuristic: If jumping outside our section, chances are
5495 we are going to need a stub. */
5496 if (h != NULL)
5497 {
5498 /* If the sym is weak it may be overridden later, so
5499 don't assume we know where a weak sym lives. */
5500 if (h->root.type == bfd_link_hash_defined)
5501 dest = h->root.u.def.section;
5502 }
5503 else
5504 {
5505 Elf_Internal_Sym *isym;
5506
5507 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5508 abfd, r_symndx);
5509 if (isym == NULL)
5510 return FALSE;
5511
5512 dest = bfd_section_from_elf_index (abfd, isym->st_shndx);
5513 }
5514
5515 if (dest != sec)
5516 ppc64_elf_section_data (sec)->has_14bit_branch = 1;
5517 }
5518 /* Fall through. */
5519
5520 case R_PPC64_REL24:
5521 if (h != NULL && ifunc == NULL)
5522 {
5523 /* We may need a .plt entry if the function this reloc
5524 refers to is in a shared lib. */
5525 if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5526 return FALSE;
5527 h->needs_plt = 1;
5528 if (h->root.root.string[0] == '.'
5529 && h->root.root.string[1] != '\0')
5530 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5531 if (h == tga || h == dottga)
5532 sec->has_tls_reloc = 1;
5533 }
5534 break;
5535
5536 case R_PPC64_TPREL64:
5537 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_TPREL;
5538 if (!info->executable)
5539 info->flags |= DF_STATIC_TLS;
5540 goto dotlstoc;
5541
5542 case R_PPC64_DTPMOD64:
5543 if (rel + 1 < rel_end
5544 && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
5545 && rel[1].r_offset == rel->r_offset + 8)
5546 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_GD;
5547 else
5548 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_LD;
5549 goto dotlstoc;
5550
5551 case R_PPC64_DTPREL64:
5552 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_DTPREL;
5553 if (rel != relocs
5554 && rel[-1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPMOD64)
5555 && rel[-1].r_offset == rel->r_offset - 8)
5556 /* This is the second reloc of a dtpmod, dtprel pair.
5557 Don't mark with TLS_DTPREL. */
5558 goto dodyn;
5559
5560 dotlstoc:
5561 sec->has_tls_reloc = 1;
5562 if (h != NULL)
5563 {
5564 struct ppc_link_hash_entry *eh;
5565 eh = (struct ppc_link_hash_entry *) h;
5566 eh->tls_mask |= tls_type;
5567 }
5568 else
5569 if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5570 rel->r_addend, tls_type))
5571 return FALSE;
5572
5573 ppc64_sec = ppc64_elf_section_data (sec);
5574 if (ppc64_sec->sec_type != sec_toc)
5575 {
5576 bfd_size_type amt;
5577
5578 /* One extra to simplify get_tls_mask. */
5579 amt = sec->size * sizeof (unsigned) / 8 + sizeof (unsigned);
5580 ppc64_sec->u.toc.symndx = bfd_zalloc (abfd, amt);
5581 if (ppc64_sec->u.toc.symndx == NULL)
5582 return FALSE;
5583 amt = sec->size * sizeof (bfd_vma) / 8;
5584 ppc64_sec->u.toc.add = bfd_zalloc (abfd, amt);
5585 if (ppc64_sec->u.toc.add == NULL)
5586 return FALSE;
5587 BFD_ASSERT (ppc64_sec->sec_type == sec_normal);
5588 ppc64_sec->sec_type = sec_toc;
5589 }
5590 BFD_ASSERT (rel->r_offset % 8 == 0);
5591 ppc64_sec->u.toc.symndx[rel->r_offset / 8] = r_symndx;
5592 ppc64_sec->u.toc.add[rel->r_offset / 8] = rel->r_addend;
5593
5594 /* Mark the second slot of a GD or LD entry.
5595 -1 to indicate GD and -2 to indicate LD. */
5596 if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_GD))
5597 ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -1;
5598 else if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_LD))
5599 ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -2;
5600 goto dodyn;
5601
5602 case R_PPC64_TPREL16:
5603 case R_PPC64_TPREL16_LO:
5604 case R_PPC64_TPREL16_HI:
5605 case R_PPC64_TPREL16_HA:
5606 case R_PPC64_TPREL16_DS:
5607 case R_PPC64_TPREL16_LO_DS:
5608 case R_PPC64_TPREL16_HIGH:
5609 case R_PPC64_TPREL16_HIGHA:
5610 case R_PPC64_TPREL16_HIGHER:
5611 case R_PPC64_TPREL16_HIGHERA:
5612 case R_PPC64_TPREL16_HIGHEST:
5613 case R_PPC64_TPREL16_HIGHESTA:
5614 if (info->shared)
5615 {
5616 if (!info->executable)
5617 info->flags |= DF_STATIC_TLS;
5618 goto dodyn;
5619 }
5620 break;
5621
5622 case R_PPC64_ADDR64:
5623 if (opd_sym_map != NULL
5624 && rel + 1 < rel_end
5625 && ELF64_R_TYPE ((rel + 1)->r_info) == R_PPC64_TOC)
5626 {
5627 if (h != NULL)
5628 {
5629 if (h->root.root.string[0] == '.'
5630 && h->root.root.string[1] != 0
5631 && lookup_fdh ((struct ppc_link_hash_entry *) h, htab))
5632 ;
5633 else
5634 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5635 }
5636 else
5637 {
5638 asection *s;
5639 Elf_Internal_Sym *isym;
5640
5641 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5642 abfd, r_symndx);
5643 if (isym == NULL)
5644 return FALSE;
5645
5646 s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5647 if (s != NULL && s != sec)
5648 opd_sym_map[rel->r_offset / 8] = s;
5649 }
5650 }
5651 /* Fall through. */
5652
5653 case R_PPC64_ADDR16:
5654 case R_PPC64_ADDR16_DS:
5655 case R_PPC64_ADDR16_HA:
5656 case R_PPC64_ADDR16_HI:
5657 case R_PPC64_ADDR16_HIGH:
5658 case R_PPC64_ADDR16_HIGHA:
5659 case R_PPC64_ADDR16_HIGHER:
5660 case R_PPC64_ADDR16_HIGHERA:
5661 case R_PPC64_ADDR16_HIGHEST:
5662 case R_PPC64_ADDR16_HIGHESTA:
5663 case R_PPC64_ADDR16_LO:
5664 case R_PPC64_ADDR16_LO_DS:
5665 if (h != NULL && !info->shared && abiversion (abfd) != 1
5666 && rel->r_addend == 0)
5667 {
5668 /* We may need a .plt entry if this reloc refers to a
5669 function in a shared lib. */
5670 if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5671 return FALSE;
5672 h->pointer_equality_needed = 1;
5673 }
5674 /* Fall through. */
5675
5676 case R_PPC64_REL30:
5677 case R_PPC64_REL32:
5678 case R_PPC64_REL64:
5679 case R_PPC64_ADDR14:
5680 case R_PPC64_ADDR14_BRNTAKEN:
5681 case R_PPC64_ADDR14_BRTAKEN:
5682 case R_PPC64_ADDR24:
5683 case R_PPC64_ADDR32:
5684 case R_PPC64_UADDR16:
5685 case R_PPC64_UADDR32:
5686 case R_PPC64_UADDR64:
5687 case R_PPC64_TOC:
5688 if (h != NULL && !info->shared)
5689 /* We may need a copy reloc. */
5690 h->non_got_ref = 1;
5691
5692 /* Don't propagate .opd relocs. */
5693 if (NO_OPD_RELOCS && opd_sym_map != NULL)
5694 break;
5695
5696 /* If we are creating a shared library, and this is a reloc
5697 against a global symbol, or a non PC relative reloc
5698 against a local symbol, then we need to copy the reloc
5699 into the shared library. However, if we are linking with
5700 -Bsymbolic, we do not need to copy a reloc against a
5701 global symbol which is defined in an object we are
5702 including in the link (i.e., DEF_REGULAR is set). At
5703 this point we have not seen all the input files, so it is
5704 possible that DEF_REGULAR is not set now but will be set
5705 later (it is never cleared). In case of a weak definition,
5706 DEF_REGULAR may be cleared later by a strong definition in
5707 a shared library. We account for that possibility below by
5708 storing information in the dyn_relocs field of the hash
5709 table entry. A similar situation occurs when creating
5710 shared libraries and symbol visibility changes render the
5711 symbol local.
5712
5713 If on the other hand, we are creating an executable, we
5714 may need to keep relocations for symbols satisfied by a
5715 dynamic library if we manage to avoid copy relocs for the
5716 symbol. */
5717 dodyn:
5718 if ((info->shared
5719 && (must_be_dyn_reloc (info, r_type)
5720 || (h != NULL
5721 && (!SYMBOLIC_BIND (info, h)
5722 || h->root.type == bfd_link_hash_defweak
5723 || !h->def_regular))))
5724 || (ELIMINATE_COPY_RELOCS
5725 && !info->shared
5726 && h != NULL
5727 && (h->root.type == bfd_link_hash_defweak
5728 || !h->def_regular))
5729 || (!info->shared
5730 && ifunc != NULL))
5731 {
5732 /* We must copy these reloc types into the output file.
5733 Create a reloc section in dynobj and make room for
5734 this reloc. */
5735 if (sreloc == NULL)
5736 {
5737 sreloc = _bfd_elf_make_dynamic_reloc_section
5738 (sec, htab->elf.dynobj, 3, abfd, /*rela?*/ TRUE);
5739
5740 if (sreloc == NULL)
5741 return FALSE;
5742 }
5743
5744 /* If this is a global symbol, we count the number of
5745 relocations we need for this symbol. */
5746 if (h != NULL)
5747 {
5748 struct elf_dyn_relocs *p;
5749 struct elf_dyn_relocs **head;
5750
5751 head = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
5752 p = *head;
5753 if (p == NULL || p->sec != sec)
5754 {
5755 p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5756 if (p == NULL)
5757 return FALSE;
5758 p->next = *head;
5759 *head = p;
5760 p->sec = sec;
5761 p->count = 0;
5762 p->pc_count = 0;
5763 }
5764 p->count += 1;
5765 if (!must_be_dyn_reloc (info, r_type))
5766 p->pc_count += 1;
5767 }
5768 else
5769 {
5770 /* Track dynamic relocs needed for local syms too.
5771 We really need local syms available to do this
5772 easily. Oh well. */
5773 struct ppc_dyn_relocs *p;
5774 struct ppc_dyn_relocs **head;
5775 bfd_boolean is_ifunc;
5776 asection *s;
5777 void *vpp;
5778 Elf_Internal_Sym *isym;
5779
5780 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5781 abfd, r_symndx);
5782 if (isym == NULL)
5783 return FALSE;
5784
5785 s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5786 if (s == NULL)
5787 s = sec;
5788
5789 vpp = &elf_section_data (s)->local_dynrel;
5790 head = (struct ppc_dyn_relocs **) vpp;
5791 is_ifunc = ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC;
5792 p = *head;
5793 if (p != NULL && p->sec == sec && p->ifunc != is_ifunc)
5794 p = p->next;
5795 if (p == NULL || p->sec != sec || p->ifunc != is_ifunc)
5796 {
5797 p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5798 if (p == NULL)
5799 return FALSE;
5800 p->next = *head;
5801 *head = p;
5802 p->sec = sec;
5803 p->ifunc = is_ifunc;
5804 p->count = 0;
5805 }
5806 p->count += 1;
5807 }
5808 }
5809 break;
5810
5811 default:
5812 break;
5813 }
5814 }
5815
5816 return TRUE;
5817 }
5818
5819 /* Merge backend specific data from an object file to the output
5820 object file when linking. */
5821
5822 static bfd_boolean
5823 ppc64_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
5824 {
5825 unsigned long iflags, oflags;
5826
5827 if ((ibfd->flags & BFD_LINKER_CREATED) != 0)
5828 return TRUE;
5829
5830 if (!is_ppc64_elf (ibfd) || !is_ppc64_elf (obfd))
5831 return TRUE;
5832
5833 if (!_bfd_generic_verify_endian_match (ibfd, obfd))
5834 return FALSE;
5835
5836 iflags = elf_elfheader (ibfd)->e_flags;
5837 oflags = elf_elfheader (obfd)->e_flags;
5838
5839 if (iflags & ~EF_PPC64_ABI)
5840 {
5841 (*_bfd_error_handler)
5842 (_("%B uses unknown e_flags 0x%lx"), ibfd, iflags);
5843 bfd_set_error (bfd_error_bad_value);
5844 return FALSE;
5845 }
5846 else if (iflags != oflags && iflags != 0)
5847 {
5848 (*_bfd_error_handler)
5849 (_("%B: ABI version %ld is not compatible with ABI version %ld output"),
5850 ibfd, iflags, oflags);
5851 bfd_set_error (bfd_error_bad_value);
5852 return FALSE;
5853 }
5854
5855 /* Merge Tag_compatibility attributes and any common GNU ones. */
5856 _bfd_elf_merge_object_attributes (ibfd, obfd);
5857
5858 return TRUE;
5859 }
5860
5861 static bfd_boolean
5862 ppc64_elf_print_private_bfd_data (bfd *abfd, void *ptr)
5863 {
5864 /* Print normal ELF private data. */
5865 _bfd_elf_print_private_bfd_data (abfd, ptr);
5866
5867 if (elf_elfheader (abfd)->e_flags != 0)
5868 {
5869 FILE *file = ptr;
5870
5871 /* xgettext:c-format */
5872 fprintf (file, _("private flags = 0x%lx:"),
5873 elf_elfheader (abfd)->e_flags);
5874
5875 if ((elf_elfheader (abfd)->e_flags & EF_PPC64_ABI) != 0)
5876 fprintf (file, _(" [abiv%ld]"),
5877 elf_elfheader (abfd)->e_flags & EF_PPC64_ABI);
5878 fputc ('\n', file);
5879 }
5880
5881 return TRUE;
5882 }
5883
5884 /* OFFSET in OPD_SEC specifies a function descriptor. Return the address
5885 of the code entry point, and its section. */
5886
5887 static bfd_vma
5888 opd_entry_value (asection *opd_sec,
5889 bfd_vma offset,
5890 asection **code_sec,
5891 bfd_vma *code_off,
5892 bfd_boolean in_code_sec)
5893 {
5894 bfd *opd_bfd = opd_sec->owner;
5895 Elf_Internal_Rela *relocs;
5896 Elf_Internal_Rela *lo, *hi, *look;
5897 bfd_vma val;
5898
5899 /* No relocs implies we are linking a --just-symbols object, or looking
5900 at a final linked executable with addr2line or somesuch. */
5901 if (opd_sec->reloc_count == 0)
5902 {
5903 bfd_byte *contents = ppc64_elf_tdata (opd_bfd)->opd.contents;
5904
5905 if (contents == NULL)
5906 {
5907 if (!bfd_malloc_and_get_section (opd_bfd, opd_sec, &contents))
5908 return (bfd_vma) -1;
5909 ppc64_elf_tdata (opd_bfd)->opd.contents = contents;
5910 }
5911
5912 val = bfd_get_64 (opd_bfd, contents + offset);
5913 if (code_sec != NULL)
5914 {
5915 asection *sec, *likely = NULL;
5916
5917 if (in_code_sec)
5918 {
5919 sec = *code_sec;
5920 if (sec->vma <= val
5921 && val < sec->vma + sec->size)
5922 likely = sec;
5923 else
5924 val = -1;
5925 }
5926 else
5927 for (sec = opd_bfd->sections; sec != NULL; sec = sec->next)
5928 if (sec->vma <= val
5929 && (sec->flags & SEC_LOAD) != 0
5930 && (sec->flags & SEC_ALLOC) != 0)
5931 likely = sec;
5932 if (likely != NULL)
5933 {
5934 *code_sec = likely;
5935 if (code_off != NULL)
5936 *code_off = val - likely->vma;
5937 }
5938 }
5939 return val;
5940 }
5941
5942 BFD_ASSERT (is_ppc64_elf (opd_bfd));
5943
5944 relocs = ppc64_elf_tdata (opd_bfd)->opd.relocs;
5945 if (relocs == NULL)
5946 relocs = _bfd_elf_link_read_relocs (opd_bfd, opd_sec, NULL, NULL, TRUE);
5947
5948 /* Go find the opd reloc at the sym address. */
5949 lo = relocs;
5950 BFD_ASSERT (lo != NULL);
5951 hi = lo + opd_sec->reloc_count - 1; /* ignore last reloc */
5952 val = (bfd_vma) -1;
5953 while (lo < hi)
5954 {
5955 look = lo + (hi - lo) / 2;
5956 if (look->r_offset < offset)
5957 lo = look + 1;
5958 else if (look->r_offset > offset)
5959 hi = look;
5960 else
5961 {
5962 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (opd_bfd);
5963
5964 if (ELF64_R_TYPE (look->r_info) == R_PPC64_ADDR64
5965 && ELF64_R_TYPE ((look + 1)->r_info) == R_PPC64_TOC)
5966 {
5967 unsigned long symndx = ELF64_R_SYM (look->r_info);
5968 asection *sec;
5969
5970 if (symndx < symtab_hdr->sh_info
5971 || elf_sym_hashes (opd_bfd) == NULL)
5972 {
5973 Elf_Internal_Sym *sym;
5974
5975 sym = (Elf_Internal_Sym *) symtab_hdr->contents;
5976 if (sym == NULL)
5977 {
5978 size_t symcnt = symtab_hdr->sh_info;
5979 if (elf_sym_hashes (opd_bfd) == NULL)
5980 symcnt = symtab_hdr->sh_size / symtab_hdr->sh_entsize;
5981 sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr, symcnt,
5982 0, NULL, NULL, NULL);
5983 if (sym == NULL)
5984 break;
5985 symtab_hdr->contents = (bfd_byte *) sym;
5986 }
5987
5988 sym += symndx;
5989 val = sym->st_value;
5990 sec = bfd_section_from_elf_index (opd_bfd, sym->st_shndx);
5991 BFD_ASSERT ((sec->flags & SEC_MERGE) == 0);
5992 }
5993 else
5994 {
5995 struct elf_link_hash_entry **sym_hashes;
5996 struct elf_link_hash_entry *rh;
5997
5998 sym_hashes = elf_sym_hashes (opd_bfd);
5999 rh = sym_hashes[symndx - symtab_hdr->sh_info];
6000 if (rh != NULL)
6001 {
6002 rh = elf_follow_link (rh);
6003 BFD_ASSERT (rh->root.type == bfd_link_hash_defined
6004 || rh->root.type == bfd_link_hash_defweak);
6005 val = rh->root.u.def.value;
6006 sec = rh->root.u.def.section;
6007 }
6008 else
6009 {
6010 /* Handle the odd case where we can be called
6011 during bfd_elf_link_add_symbols before the
6012 symbol hashes have been fully populated. */
6013 Elf_Internal_Sym *sym;
6014
6015 sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr, 1,
6016 symndx, NULL, NULL, NULL);
6017 if (sym == NULL)
6018 break;
6019
6020 val = sym->st_value;
6021 sec = bfd_section_from_elf_index (opd_bfd, sym->st_shndx);
6022 free (sym);
6023 }
6024 }
6025 val += look->r_addend;
6026 if (code_off != NULL)
6027 *code_off = val;
6028 if (code_sec != NULL)
6029 {
6030 if (in_code_sec && *code_sec != sec)
6031 return -1;
6032 else
6033 *code_sec = sec;
6034 }
6035 if (sec != NULL && sec->output_section != NULL)
6036 val += sec->output_section->vma + sec->output_offset;
6037 }
6038 break;
6039 }
6040 }
6041
6042 return val;
6043 }
6044
6045 /* If the ELF symbol SYM might be a function in SEC, return the
6046 function size and set *CODE_OFF to the function's entry point,
6047 otherwise return zero. */
6048
6049 static bfd_size_type
6050 ppc64_elf_maybe_function_sym (const asymbol *sym, asection *sec,
6051 bfd_vma *code_off)
6052 {
6053 bfd_size_type size;
6054
6055 if ((sym->flags & (BSF_SECTION_SYM | BSF_FILE | BSF_OBJECT
6056 | BSF_THREAD_LOCAL | BSF_RELC | BSF_SRELC)) != 0)
6057 return 0;
6058
6059 size = 0;
6060 if (!(sym->flags & BSF_SYNTHETIC))
6061 size = ((elf_symbol_type *) sym)->internal_elf_sym.st_size;
6062
6063 if (strcmp (sym->section->name, ".opd") == 0)
6064 {
6065 if (opd_entry_value (sym->section, sym->value,
6066 &sec, code_off, TRUE) == (bfd_vma) -1)
6067 return 0;
6068 /* An old ABI binary with dot-syms has a size of 24 on the .opd
6069 symbol. This size has nothing to do with the code size of the
6070 function, which is what we're supposed to return, but the
6071 code size isn't available without looking up the dot-sym.
6072 However, doing that would be a waste of time particularly
6073 since elf_find_function will look at the dot-sym anyway.
6074 Now, elf_find_function will keep the largest size of any
6075 function sym found at the code address of interest, so return
6076 1 here to avoid it incorrectly caching a larger function size
6077 for a small function. This does mean we return the wrong
6078 size for a new-ABI function of size 24, but all that does is
6079 disable caching for such functions. */
6080 if (size == 24)
6081 size = 1;
6082 }
6083 else
6084 {
6085 if (sym->section != sec)
6086 return 0;
6087 *code_off = sym->value;
6088 }
6089 if (size == 0)
6090 size = 1;
6091 return size;
6092 }
6093
6094 /* Return true if symbol is defined in a regular object file. */
6095
6096 static bfd_boolean
6097 is_static_defined (struct elf_link_hash_entry *h)
6098 {
6099 return ((h->root.type == bfd_link_hash_defined
6100 || h->root.type == bfd_link_hash_defweak)
6101 && h->root.u.def.section != NULL
6102 && h->root.u.def.section->output_section != NULL);
6103 }
6104
6105 /* If FDH is a function descriptor symbol, return the associated code
6106 entry symbol if it is defined. Return NULL otherwise. */
6107
6108 static struct ppc_link_hash_entry *
6109 defined_code_entry (struct ppc_link_hash_entry *fdh)
6110 {
6111 if (fdh->is_func_descriptor)
6112 {
6113 struct ppc_link_hash_entry *fh = ppc_follow_link (fdh->oh);
6114 if (fh->elf.root.type == bfd_link_hash_defined
6115 || fh->elf.root.type == bfd_link_hash_defweak)
6116 return fh;
6117 }
6118 return NULL;
6119 }
6120
6121 /* If FH is a function code entry symbol, return the associated
6122 function descriptor symbol if it is defined. Return NULL otherwise. */
6123
6124 static struct ppc_link_hash_entry *
6125 defined_func_desc (struct ppc_link_hash_entry *fh)
6126 {
6127 if (fh->oh != NULL
6128 && fh->oh->is_func_descriptor)
6129 {
6130 struct ppc_link_hash_entry *fdh = ppc_follow_link (fh->oh);
6131 if (fdh->elf.root.type == bfd_link_hash_defined
6132 || fdh->elf.root.type == bfd_link_hash_defweak)
6133 return fdh;
6134 }
6135 return NULL;
6136 }
6137
6138 /* Mark all our entry sym sections, both opd and code section. */
6139
6140 static void
6141 ppc64_elf_gc_keep (struct bfd_link_info *info)
6142 {
6143 struct ppc_link_hash_table *htab = ppc_hash_table (info);
6144 struct bfd_sym_chain *sym;
6145
6146 if (htab == NULL)
6147 return;
6148
6149 for (sym = info->gc_sym_list; sym != NULL; sym = sym->next)
6150 {
6151 struct ppc_link_hash_entry *eh, *fh;
6152 asection *sec;
6153
6154 eh = (struct ppc_link_hash_entry *)
6155 elf_link_hash_lookup (&htab->elf, sym->name, FALSE, FALSE, TRUE);
6156 if (eh == NULL)
6157 continue;
6158 if (eh->elf.root.type != bfd_link_hash_defined
6159 && eh->elf.root.type != bfd_link_hash_defweak)
6160 continue;
6161
6162 fh = defined_code_entry (eh);
6163 if (fh != NULL)
6164 {
6165 sec = fh->elf.root.u.def.section;
6166 sec->flags |= SEC_KEEP;
6167 }
6168 else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6169 && opd_entry_value (eh->elf.root.u.def.section,
6170 eh->elf.root.u.def.value,
6171 &sec, NULL, FALSE) != (bfd_vma) -1)
6172 sec->flags |= SEC_KEEP;
6173
6174 sec = eh->elf.root.u.def.section;
6175 sec->flags |= SEC_KEEP;
6176 }
6177 }
6178
6179 /* Mark sections containing dynamically referenced symbols. When
6180 building shared libraries, we must assume that any visible symbol is
6181 referenced. */
6182
6183 static bfd_boolean
6184 ppc64_elf_gc_mark_dynamic_ref (struct elf_link_hash_entry *h, void *inf)
6185 {
6186 struct bfd_link_info *info = (struct bfd_link_info *) inf;
6187 struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
6188 struct ppc_link_hash_entry *fdh;
6189 struct bfd_elf_dynamic_list *d = info->dynamic_list;
6190
6191 /* Dynamic linking info is on the func descriptor sym. */
6192 fdh = defined_func_desc (eh);
6193 if (fdh != NULL)
6194 eh = fdh;
6195
6196 if ((eh->elf.root.type == bfd_link_hash_defined
6197 || eh->elf.root.type == bfd_link_hash_defweak)
6198 && (eh->elf.ref_dynamic
6199 || (eh->elf.def_regular
6200 && ELF_ST_VISIBILITY (eh->elf.other) != STV_INTERNAL
6201 && ELF_ST_VISIBILITY (eh->elf.other) != STV_HIDDEN
6202 && (!info->executable
6203 || info->export_dynamic
6204 || (eh->elf.dynamic
6205 && d != NULL
6206 && (*d->match) (&d->head, NULL, eh->elf.root.root.string)))
6207 && (strchr (eh->elf.root.root.string, ELF_VER_CHR) != NULL
6208 || !bfd_hide_sym_by_version (info->version_info,
6209 eh->elf.root.root.string)))))
6210 {
6211 asection *code_sec;
6212 struct ppc_link_hash_entry *fh;
6213
6214 eh->elf.root.u.def.section->flags |= SEC_KEEP;
6215
6216 /* Function descriptor syms cause the associated
6217 function code sym section to be marked. */
6218 fh = defined_code_entry (eh);
6219 if (fh != NULL)
6220 {
6221 code_sec = fh->elf.root.u.def.section;
6222 code_sec->flags |= SEC_KEEP;
6223 }
6224 else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6225 && opd_entry_value (eh->elf.root.u.def.section,
6226 eh->elf.root.u.def.value,
6227 &code_sec, NULL, FALSE) != (bfd_vma) -1)
6228 code_sec->flags |= SEC_KEEP;
6229 }
6230
6231 return TRUE;
6232 }
6233
6234 /* Return the section that should be marked against GC for a given
6235 relocation. */
6236
6237 static asection *
6238 ppc64_elf_gc_mark_hook (asection *sec,
6239 struct bfd_link_info *info,
6240 Elf_Internal_Rela *rel,
6241 struct elf_link_hash_entry *h,
6242 Elf_Internal_Sym *sym)
6243 {
6244 asection *rsec;
6245
6246 /* Syms return NULL if we're marking .opd, so we avoid marking all
6247 function sections, as all functions are referenced in .opd. */
6248 rsec = NULL;
6249 if (get_opd_info (sec) != NULL)
6250 return rsec;
6251
6252 if (h != NULL)
6253 {
6254 enum elf_ppc64_reloc_type r_type;
6255 struct ppc_link_hash_entry *eh, *fh, *fdh;
6256
6257 r_type = ELF64_R_TYPE (rel->r_info);
6258 switch (r_type)
6259 {
6260 case R_PPC64_GNU_VTINHERIT:
6261 case R_PPC64_GNU_VTENTRY:
6262 break;
6263
6264 default:
6265 switch (h->root.type)
6266 {
6267 case bfd_link_hash_defined:
6268 case bfd_link_hash_defweak:
6269 eh = (struct ppc_link_hash_entry *) h;
6270 fdh = defined_func_desc (eh);
6271 if (fdh != NULL)
6272 eh = fdh;
6273
6274 /* Function descriptor syms cause the associated
6275 function code sym section to be marked. */
6276 fh = defined_code_entry (eh);
6277 if (fh != NULL)
6278 {
6279 /* They also mark their opd section. */
6280 eh->elf.root.u.def.section->gc_mark = 1;
6281
6282 rsec = fh->elf.root.u.def.section;
6283 }
6284 else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6285 && opd_entry_value (eh->elf.root.u.def.section,
6286 eh->elf.root.u.def.value,
6287 &rsec, NULL, FALSE) != (bfd_vma) -1)
6288 eh->elf.root.u.def.section->gc_mark = 1;
6289 else
6290 rsec = h->root.u.def.section;
6291 break;
6292
6293 case bfd_link_hash_common:
6294 rsec = h->root.u.c.p->section;
6295 break;
6296
6297 default:
6298 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
6299 }
6300 }
6301 }
6302 else
6303 {
6304 struct _opd_sec_data *opd;
6305
6306 rsec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
6307 opd = get_opd_info (rsec);
6308 if (opd != NULL && opd->func_sec != NULL)
6309 {
6310 rsec->gc_mark = 1;
6311
6312 rsec = opd->func_sec[(sym->st_value + rel->r_addend) / 8];
6313 }
6314 }
6315
6316 return rsec;
6317 }
6318
6319 /* Update the .got, .plt. and dynamic reloc reference counts for the
6320 section being removed. */
6321
6322 static bfd_boolean
6323 ppc64_elf_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info,
6324 asection *sec, const Elf_Internal_Rela *relocs)
6325 {
6326 struct ppc_link_hash_table *htab;
6327 Elf_Internal_Shdr *symtab_hdr;
6328 struct elf_link_hash_entry **sym_hashes;
6329 struct got_entry **local_got_ents;
6330 const Elf_Internal_Rela *rel, *relend;
6331
6332 if (info->relocatable)
6333 return TRUE;
6334
6335 if ((sec->flags & SEC_ALLOC) == 0)
6336 return TRUE;
6337
6338 elf_section_data (sec)->local_dynrel = NULL;
6339
6340 htab = ppc_hash_table (info);
6341 if (htab == NULL)
6342 return FALSE;
6343
6344 symtab_hdr = &elf_symtab_hdr (abfd);
6345 sym_hashes = elf_sym_hashes (abfd);
6346 local_got_ents = elf_local_got_ents (abfd);
6347
6348 relend = relocs + sec->reloc_count;
6349 for (rel = relocs; rel < relend; rel++)
6350 {
6351 unsigned long r_symndx;
6352 enum elf_ppc64_reloc_type r_type;
6353 struct elf_link_hash_entry *h = NULL;
6354 unsigned char tls_type = 0;
6355
6356 r_symndx = ELF64_R_SYM (rel->r_info);
6357 r_type = ELF64_R_TYPE (rel->r_info);
6358 if (r_symndx >= symtab_hdr->sh_info)
6359 {
6360 struct ppc_link_hash_entry *eh;
6361 struct elf_dyn_relocs **pp;
6362 struct elf_dyn_relocs *p;
6363
6364 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
6365 h = elf_follow_link (h);
6366 eh = (struct ppc_link_hash_entry *) h;
6367
6368 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
6369 if (p->sec == sec)
6370 {
6371 /* Everything must go for SEC. */
6372 *pp = p->next;
6373 break;
6374 }
6375 }
6376
6377 if (is_branch_reloc (r_type))
6378 {
6379 struct plt_entry **ifunc = NULL;
6380 if (h != NULL)
6381 {
6382 if (h->type == STT_GNU_IFUNC)
6383 ifunc = &h->plt.plist;
6384 }
6385 else if (local_got_ents != NULL)
6386 {
6387 struct plt_entry **local_plt = (struct plt_entry **)
6388 (local_got_ents + symtab_hdr->sh_info);
6389 unsigned char *local_got_tls_masks = (unsigned char *)
6390 (local_plt + symtab_hdr->sh_info);
6391 if ((local_got_tls_masks[r_symndx] & PLT_IFUNC) != 0)
6392 ifunc = local_plt + r_symndx;
6393 }
6394 if (ifunc != NULL)
6395 {
6396 struct plt_entry *ent;
6397
6398 for (ent = *ifunc; ent != NULL; ent = ent->next)
6399 if (ent->addend == rel->r_addend)
6400 break;
6401 if (ent == NULL)
6402 abort ();
6403 if (ent->plt.refcount > 0)
6404 ent->plt.refcount -= 1;
6405 continue;
6406 }
6407 }
6408
6409 switch (r_type)
6410 {
6411 case R_PPC64_GOT_TLSLD16:
6412 case R_PPC64_GOT_TLSLD16_LO:
6413 case R_PPC64_GOT_TLSLD16_HI:
6414 case R_PPC64_GOT_TLSLD16_HA:
6415 tls_type = TLS_TLS | TLS_LD;
6416 goto dogot;
6417
6418 case R_PPC64_GOT_TLSGD16:
6419 case R_PPC64_GOT_TLSGD16_LO:
6420 case R_PPC64_GOT_TLSGD16_HI:
6421 case R_PPC64_GOT_TLSGD16_HA:
6422 tls_type = TLS_TLS | TLS_GD;
6423 goto dogot;
6424
6425 case R_PPC64_GOT_TPREL16_DS:
6426 case R_PPC64_GOT_TPREL16_LO_DS:
6427 case R_PPC64_GOT_TPREL16_HI:
6428 case R_PPC64_GOT_TPREL16_HA:
6429 tls_type = TLS_TLS | TLS_TPREL;
6430 goto dogot;
6431
6432 case R_PPC64_GOT_DTPREL16_DS:
6433 case R_PPC64_GOT_DTPREL16_LO_DS:
6434 case R_PPC64_GOT_DTPREL16_HI:
6435 case R_PPC64_GOT_DTPREL16_HA:
6436 tls_type = TLS_TLS | TLS_DTPREL;
6437 goto dogot;
6438
6439 case R_PPC64_GOT16:
6440 case R_PPC64_GOT16_DS:
6441 case R_PPC64_GOT16_HA:
6442 case R_PPC64_GOT16_HI:
6443 case R_PPC64_GOT16_LO:
6444 case R_PPC64_GOT16_LO_DS:
6445 dogot:
6446 {
6447 struct got_entry *ent;
6448
6449 if (h != NULL)
6450 ent = h->got.glist;
6451 else
6452 ent = local_got_ents[r_symndx];
6453
6454 for (; ent != NULL; ent = ent->next)
6455 if (ent->addend == rel->r_addend
6456 && ent->owner == abfd
6457 && ent->tls_type == tls_type)
6458 break;
6459 if (ent == NULL)
6460 abort ();
6461 if (ent->got.refcount > 0)
6462 ent->got.refcount -= 1;
6463 }
6464 break;
6465
6466 case R_PPC64_PLT16_HA:
6467 case R_PPC64_PLT16_HI:
6468 case R_PPC64_PLT16_LO:
6469 case R_PPC64_PLT32:
6470 case R_PPC64_PLT64:
6471 case R_PPC64_REL14:
6472 case R_PPC64_REL14_BRNTAKEN:
6473 case R_PPC64_REL14_BRTAKEN:
6474 case R_PPC64_REL24:
6475 if (h != NULL)
6476 {
6477 struct plt_entry *ent;
6478
6479 for (ent = h->plt.plist; ent != NULL; ent = ent->next)
6480 if (ent->addend == rel->r_addend)
6481 break;
6482 if (ent != NULL && ent->plt.refcount > 0)
6483 ent->plt.refcount -= 1;
6484 }
6485 break;
6486
6487 default:
6488 break;
6489 }
6490 }
6491 return TRUE;
6492 }
6493
6494 /* The maximum size of .sfpr. */
6495 #define SFPR_MAX (218*4)
6496
6497 struct sfpr_def_parms
6498 {
6499 const char name[12];
6500 unsigned char lo, hi;
6501 bfd_byte * (*write_ent) (bfd *, bfd_byte *, int);
6502 bfd_byte * (*write_tail) (bfd *, bfd_byte *, int);
6503 };
6504
6505 /* Auto-generate _save*, _rest* functions in .sfpr. */
6506
6507 static bfd_boolean
6508 sfpr_define (struct bfd_link_info *info, const struct sfpr_def_parms *parm)
6509 {
6510 struct ppc_link_hash_table *htab = ppc_hash_table (info);
6511 unsigned int i;
6512 size_t len = strlen (parm->name);
6513 bfd_boolean writing = FALSE;
6514 char sym[16];
6515
6516 if (htab == NULL)
6517 return FALSE;
6518
6519 memcpy (sym, parm->name, len);
6520 sym[len + 2] = 0;
6521
6522 for (i = parm->lo; i <= parm->hi; i++)
6523 {
6524 struct elf_link_hash_entry *h;
6525
6526 sym[len + 0] = i / 10 + '0';
6527 sym[len + 1] = i % 10 + '0';
6528 h = elf_link_hash_lookup (&htab->elf, sym, FALSE, FALSE, TRUE);
6529 if (h != NULL
6530 && !h->def_regular)
6531 {
6532 h->root.type = bfd_link_hash_defined;
6533 h->root.u.def.section = htab->sfpr;
6534 h->root.u.def.value = htab->sfpr->size;
6535 h->type = STT_FUNC;
6536 h->def_regular = 1;
6537 _bfd_elf_link_hash_hide_symbol (info, h, TRUE);
6538 writing = TRUE;
6539 if (htab->sfpr->contents == NULL)
6540 {
6541 htab->sfpr->contents = bfd_alloc (htab->elf.dynobj, SFPR_MAX);
6542 if (htab->sfpr->contents == NULL)
6543 return FALSE;
6544 }
6545 }
6546 if (writing)
6547 {
6548 bfd_byte *p = htab->sfpr->contents + htab->sfpr->size;
6549 if (i != parm->hi)
6550 p = (*parm->write_ent) (htab->elf.dynobj, p, i);
6551 else
6552 p = (*parm->write_tail) (htab->elf.dynobj, p, i);
6553 htab->sfpr->size = p - htab->sfpr->contents;
6554 }
6555 }
6556
6557 return TRUE;
6558 }
6559
6560 static bfd_byte *
6561 savegpr0 (bfd *abfd, bfd_byte *p, int r)
6562 {
6563 bfd_put_32 (abfd, STD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6564 return p + 4;
6565 }
6566
6567 static bfd_byte *
6568 savegpr0_tail (bfd *abfd, bfd_byte *p, int r)
6569 {
6570 p = savegpr0 (abfd, p, r);
6571 bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
6572 p = p + 4;
6573 bfd_put_32 (abfd, BLR, p);
6574 return p + 4;
6575 }
6576
6577 static bfd_byte *
6578 restgpr0 (bfd *abfd, bfd_byte *p, int r)
6579 {
6580 bfd_put_32 (abfd, LD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6581 return p + 4;
6582 }
6583
6584 static bfd_byte *
6585 restgpr0_tail (bfd *abfd, bfd_byte *p, int r)
6586 {
6587 bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
6588 p = p + 4;
6589 p = restgpr0 (abfd, p, r);
6590 bfd_put_32 (abfd, MTLR_R0, p);
6591 p = p + 4;
6592 if (r == 29)
6593 {
6594 p = restgpr0 (abfd, p, 30);
6595 p = restgpr0 (abfd, p, 31);
6596 }
6597 bfd_put_32 (abfd, BLR, p);
6598 return p + 4;
6599 }
6600
6601 static bfd_byte *
6602 savegpr1 (bfd *abfd, bfd_byte *p, int r)
6603 {
6604 bfd_put_32 (abfd, STD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6605 return p + 4;
6606 }
6607
6608 static bfd_byte *
6609 savegpr1_tail (bfd *abfd, bfd_byte *p, int r)
6610 {
6611 p = savegpr1 (abfd, p, r);
6612 bfd_put_32 (abfd, BLR, p);
6613 return p + 4;
6614 }
6615
6616 static bfd_byte *
6617 restgpr1 (bfd *abfd, bfd_byte *p, int r)
6618 {
6619 bfd_put_32 (abfd, LD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6620 return p + 4;
6621 }
6622
6623 static bfd_byte *
6624 restgpr1_tail (bfd *abfd, bfd_byte *p, int r)
6625 {
6626 p = restgpr1 (abfd, p, r);
6627 bfd_put_32 (abfd, BLR, p);
6628 return p + 4;
6629 }
6630
6631 static bfd_byte *
6632 savefpr (bfd *abfd, bfd_byte *p, int r)
6633 {
6634 bfd_put_32 (abfd, STFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6635 return p + 4;
6636 }
6637
6638 static bfd_byte *
6639 savefpr0_tail (bfd *abfd, bfd_byte *p, int r)
6640 {
6641 p = savefpr (abfd, p, r);
6642 bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
6643 p = p + 4;
6644 bfd_put_32 (abfd, BLR, p);
6645 return p + 4;
6646 }
6647
6648 static bfd_byte *
6649 restfpr (bfd *abfd, bfd_byte *p, int r)
6650 {
6651 bfd_put_32 (abfd, LFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6652 return p + 4;
6653 }
6654
6655 static bfd_byte *
6656 restfpr0_tail (bfd *abfd, bfd_byte *p, int r)
6657 {
6658 bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
6659 p = p + 4;
6660 p = restfpr (abfd, p, r);
6661 bfd_put_32 (abfd, MTLR_R0, p);
6662 p = p + 4;
6663 if (r == 29)
6664 {
6665 p = restfpr (abfd, p, 30);
6666 p = restfpr (abfd, p, 31);
6667 }
6668 bfd_put_32 (abfd, BLR, p);
6669 return p + 4;
6670 }
6671
6672 static bfd_byte *
6673 savefpr1_tail (bfd *abfd, bfd_byte *p, int r)
6674 {
6675 p = savefpr (abfd, p, r);
6676 bfd_put_32 (abfd, BLR, p);
6677 return p + 4;
6678 }
6679
6680 static bfd_byte *
6681 restfpr1_tail (bfd *abfd, bfd_byte *p, int r)
6682 {
6683 p = restfpr (abfd, p, r);
6684 bfd_put_32 (abfd, BLR, p);
6685 return p + 4;
6686 }
6687
6688 static bfd_byte *
6689 savevr (bfd *abfd, bfd_byte *p, int r)
6690 {
6691 bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6692 p = p + 4;
6693 bfd_put_32 (abfd, STVX_VR0_R12_R0 + (r << 21), p);
6694 return p + 4;
6695 }
6696
6697 static bfd_byte *
6698 savevr_tail (bfd *abfd, bfd_byte *p, int r)
6699 {
6700 p = savevr (abfd, p, r);
6701 bfd_put_32 (abfd, BLR, p);
6702 return p + 4;
6703 }
6704
6705 static bfd_byte *
6706 restvr (bfd *abfd, bfd_byte *p, int r)
6707 {
6708 bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6709 p = p + 4;
6710 bfd_put_32 (abfd, LVX_VR0_R12_R0 + (r << 21), p);
6711 return p + 4;
6712 }
6713
6714 static bfd_byte *
6715 restvr_tail (bfd *abfd, bfd_byte *p, int r)
6716 {
6717 p = restvr (abfd, p, r);
6718 bfd_put_32 (abfd, BLR, p);
6719 return p + 4;
6720 }
6721
6722 /* Called via elf_link_hash_traverse to transfer dynamic linking
6723 information on function code symbol entries to their corresponding
6724 function descriptor symbol entries. */
6725
6726 static bfd_boolean
6727 func_desc_adjust (struct elf_link_hash_entry *h, void *inf)
6728 {
6729 struct bfd_link_info *info;
6730 struct ppc_link_hash_table *htab;
6731 struct plt_entry *ent;
6732 struct ppc_link_hash_entry *fh;
6733 struct ppc_link_hash_entry *fdh;
6734 bfd_boolean force_local;
6735
6736 fh = (struct ppc_link_hash_entry *) h;
6737 if (fh->elf.root.type == bfd_link_hash_indirect)
6738 return TRUE;
6739
6740 info = inf;
6741 htab = ppc_hash_table (info);
6742 if (htab == NULL)
6743 return FALSE;
6744
6745 /* Resolve undefined references to dot-symbols as the value
6746 in the function descriptor, if we have one in a regular object.
6747 This is to satisfy cases like ".quad .foo". Calls to functions
6748 in dynamic objects are handled elsewhere. */
6749 if (fh->elf.root.type == bfd_link_hash_undefweak
6750 && fh->was_undefined
6751 && (fdh = defined_func_desc (fh)) != NULL
6752 && get_opd_info (fdh->elf.root.u.def.section) != NULL
6753 && opd_entry_value (fdh->elf.root.u.def.section,
6754 fdh->elf.root.u.def.value,
6755 &fh->elf.root.u.def.section,
6756 &fh->elf.root.u.def.value, FALSE) != (bfd_vma) -1)
6757 {
6758 fh->elf.root.type = fdh->elf.root.type;
6759 fh->elf.forced_local = 1;
6760 fh->elf.def_regular = fdh->elf.def_regular;
6761 fh->elf.def_dynamic = fdh->elf.def_dynamic;
6762 }
6763
6764 /* If this is a function code symbol, transfer dynamic linking
6765 information to the function descriptor symbol. */
6766 if (!fh->is_func)
6767 return TRUE;
6768
6769 for (ent = fh->elf.plt.plist; ent != NULL; ent = ent->next)
6770 if (ent->plt.refcount > 0)
6771 break;
6772 if (ent == NULL
6773 || fh->elf.root.root.string[0] != '.'
6774 || fh->elf.root.root.string[1] == '\0')
6775 return TRUE;
6776
6777 /* Find the corresponding function descriptor symbol. Create it
6778 as undefined if necessary. */
6779
6780 fdh = lookup_fdh (fh, htab);
6781 if (fdh == NULL
6782 && !info->executable
6783 && (fh->elf.root.type == bfd_link_hash_undefined
6784 || fh->elf.root.type == bfd_link_hash_undefweak))
6785 {
6786 fdh = make_fdh (info, fh);
6787 if (fdh == NULL)
6788 return FALSE;
6789 }
6790
6791 /* Fake function descriptors are made undefweak. If the function
6792 code symbol is strong undefined, make the fake sym the same.
6793 If the function code symbol is defined, then force the fake
6794 descriptor local; We can't support overriding of symbols in a
6795 shared library on a fake descriptor. */
6796
6797 if (fdh != NULL
6798 && fdh->fake
6799 && fdh->elf.root.type == bfd_link_hash_undefweak)
6800 {
6801 if (fh->elf.root.type == bfd_link_hash_undefined)
6802 {
6803 fdh->elf.root.type = bfd_link_hash_undefined;
6804 bfd_link_add_undef (&htab->elf.root, &fdh->elf.root);
6805 }
6806 else if (fh->elf.root.type == bfd_link_hash_defined
6807 || fh->elf.root.type == bfd_link_hash_defweak)
6808 {
6809 _bfd_elf_link_hash_hide_symbol (info, &fdh->elf, TRUE);
6810 }
6811 }
6812
6813 if (fdh != NULL
6814 && !fdh->elf.forced_local
6815 && (!info->executable
6816 || fdh->elf.def_dynamic
6817 || fdh->elf.ref_dynamic
6818 || (fdh->elf.root.type == bfd_link_hash_undefweak
6819 && ELF_ST_VISIBILITY (fdh->elf.other) == STV_DEFAULT)))
6820 {
6821 if (fdh->elf.dynindx == -1)
6822 if (! bfd_elf_link_record_dynamic_symbol (info, &fdh->elf))
6823 return FALSE;
6824 fdh->elf.ref_regular |= fh->elf.ref_regular;
6825 fdh->elf.ref_dynamic |= fh->elf.ref_dynamic;
6826 fdh->elf.ref_regular_nonweak |= fh->elf.ref_regular_nonweak;
6827 fdh->elf.non_got_ref |= fh->elf.non_got_ref;
6828 if (ELF_ST_VISIBILITY (fh->elf.other) == STV_DEFAULT)
6829 {
6830 move_plt_plist (fh, fdh);
6831 fdh->elf.needs_plt = 1;
6832 }
6833 fdh->is_func_descriptor = 1;
6834 fdh->oh = fh;
6835 fh->oh = fdh;
6836 }
6837
6838 /* Now that the info is on the function descriptor, clear the
6839 function code sym info. Any function code syms for which we
6840 don't have a definition in a regular file, we force local.
6841 This prevents a shared library from exporting syms that have
6842 been imported from another library. Function code syms that
6843 are really in the library we must leave global to prevent the
6844 linker dragging in a definition from a static library. */
6845 force_local = (!fh->elf.def_regular
6846 || fdh == NULL
6847 || !fdh->elf.def_regular
6848 || fdh->elf.forced_local);
6849 _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
6850
6851 return TRUE;
6852 }
6853
6854 /* Called near the start of bfd_elf_size_dynamic_sections. We use
6855 this hook to a) provide some gcc support functions, and b) transfer
6856 dynamic linking information gathered so far on function code symbol
6857 entries, to their corresponding function descriptor symbol entries. */
6858
6859 static bfd_boolean
6860 ppc64_elf_func_desc_adjust (bfd *obfd ATTRIBUTE_UNUSED,
6861 struct bfd_link_info *info)
6862 {
6863 struct ppc_link_hash_table *htab;
6864 unsigned int i;
6865 static const struct sfpr_def_parms funcs[] =
6866 {
6867 { "_savegpr0_", 14, 31, savegpr0, savegpr0_tail },
6868 { "_restgpr0_", 14, 29, restgpr0, restgpr0_tail },
6869 { "_restgpr0_", 30, 31, restgpr0, restgpr0_tail },
6870 { "_savegpr1_", 14, 31, savegpr1, savegpr1_tail },
6871 { "_restgpr1_", 14, 31, restgpr1, restgpr1_tail },
6872 { "_savefpr_", 14, 31, savefpr, savefpr0_tail },
6873 { "_restfpr_", 14, 29, restfpr, restfpr0_tail },
6874 { "_restfpr_", 30, 31, restfpr, restfpr0_tail },
6875 { "._savef", 14, 31, savefpr, savefpr1_tail },
6876 { "._restf", 14, 31, restfpr, restfpr1_tail },
6877 { "_savevr_", 20, 31, savevr, savevr_tail },
6878 { "_restvr_", 20, 31, restvr, restvr_tail }
6879 };
6880
6881 htab = ppc_hash_table (info);
6882 if (htab == NULL)
6883 return FALSE;
6884
6885 if (!info->relocatable
6886 && htab->elf.hgot != NULL)
6887 {
6888 _bfd_elf_link_hash_hide_symbol (info, htab->elf.hgot, TRUE);
6889 /* Make .TOC. defined so as to prevent it being made dynamic.
6890 The wrong value here is fixed later in ppc64_elf_set_toc. */
6891 htab->elf.hgot->type = STT_OBJECT;
6892 htab->elf.hgot->root.type = bfd_link_hash_defined;
6893 htab->elf.hgot->root.u.def.value = 0;
6894 htab->elf.hgot->root.u.def.section = bfd_abs_section_ptr;
6895 htab->elf.hgot->def_regular = 1;
6896 htab->elf.hgot->other = ((htab->elf.hgot->other & ~ELF_ST_VISIBILITY (-1))
6897 | STV_HIDDEN);
6898 }
6899
6900 if (htab->sfpr == NULL)
6901 /* We don't have any relocs. */
6902 return TRUE;
6903
6904 /* Provide any missing _save* and _rest* functions. */
6905 htab->sfpr->size = 0;
6906 if (htab->params->save_restore_funcs)
6907 for (i = 0; i < sizeof (funcs) / sizeof (funcs[0]); i++)
6908 if (!sfpr_define (info, &funcs[i]))
6909 return FALSE;
6910
6911 elf_link_hash_traverse (&htab->elf, func_desc_adjust, info);
6912
6913 if (htab->sfpr->size == 0)
6914 htab->sfpr->flags |= SEC_EXCLUDE;
6915
6916 return TRUE;
6917 }
6918
6919 /* Return true if we have dynamic relocs that apply to read-only sections. */
6920
6921 static bfd_boolean
6922 readonly_dynrelocs (struct elf_link_hash_entry *h)
6923 {
6924 struct ppc_link_hash_entry *eh;
6925 struct elf_dyn_relocs *p;
6926
6927 eh = (struct ppc_link_hash_entry *) h;
6928 for (p = eh->dyn_relocs; p != NULL; p = p->next)
6929 {
6930 asection *s = p->sec->output_section;
6931
6932 if (s != NULL && (s->flags & SEC_READONLY) != 0)
6933 return TRUE;
6934 }
6935 return FALSE;
6936 }
6937
6938 /* Adjust a symbol defined by a dynamic object and referenced by a
6939 regular object. The current definition is in some section of the
6940 dynamic object, but we're not including those sections. We have to
6941 change the definition to something the rest of the link can
6942 understand. */
6943
6944 static bfd_boolean
6945 ppc64_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
6946 struct elf_link_hash_entry *h)
6947 {
6948 struct ppc_link_hash_table *htab;
6949 asection *s;
6950
6951 htab = ppc_hash_table (info);
6952 if (htab == NULL)
6953 return FALSE;
6954
6955 /* Deal with function syms. */
6956 if (h->type == STT_FUNC
6957 || h->type == STT_GNU_IFUNC
6958 || h->needs_plt)
6959 {
6960 /* Clear procedure linkage table information for any symbol that
6961 won't need a .plt entry. */
6962 struct plt_entry *ent;
6963 for (ent = h->plt.plist; ent != NULL; ent = ent->next)
6964 if (ent->plt.refcount > 0)
6965 break;
6966 if (ent == NULL
6967 || (h->type != STT_GNU_IFUNC
6968 && (SYMBOL_CALLS_LOCAL (info, h)
6969 || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
6970 && h->root.type == bfd_link_hash_undefweak))))
6971 {
6972 h->plt.plist = NULL;
6973 h->needs_plt = 0;
6974 }
6975 else if (abiversion (info->output_bfd) == 2)
6976 {
6977 /* After adjust_dynamic_symbol, non_got_ref set in the
6978 non-shared case means that we have allocated space in
6979 .dynbss for the symbol and thus dyn_relocs for this
6980 symbol should be discarded.
6981 If we get here we know we are making a PLT entry for this
6982 symbol, and in an executable we'd normally resolve
6983 relocations against this symbol to the PLT entry. Allow
6984 dynamic relocs if the reference is weak, and the dynamic
6985 relocs will not cause text relocation. */
6986 if (!h->ref_regular_nonweak
6987 && h->non_got_ref
6988 && h->type != STT_GNU_IFUNC
6989 && !readonly_dynrelocs (h))
6990 h->non_got_ref = 0;
6991
6992 /* If making a plt entry, then we don't need copy relocs. */
6993 return TRUE;
6994 }
6995 }
6996 else
6997 h->plt.plist = NULL;
6998
6999 /* If this is a weak symbol, and there is a real definition, the
7000 processor independent code will have arranged for us to see the
7001 real definition first, and we can just use the same value. */
7002 if (h->u.weakdef != NULL)
7003 {
7004 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
7005 || h->u.weakdef->root.type == bfd_link_hash_defweak);
7006 h->root.u.def.section = h->u.weakdef->root.u.def.section;
7007 h->root.u.def.value = h->u.weakdef->root.u.def.value;
7008 if (ELIMINATE_COPY_RELOCS)
7009 h->non_got_ref = h->u.weakdef->non_got_ref;
7010 return TRUE;
7011 }
7012
7013 /* If we are creating a shared library, we must presume that the
7014 only references to the symbol are via the global offset table.
7015 For such cases we need not do anything here; the relocations will
7016 be handled correctly by relocate_section. */
7017 if (info->shared)
7018 return TRUE;
7019
7020 /* If there are no references to this symbol that do not use the
7021 GOT, we don't need to generate a copy reloc. */
7022 if (!h->non_got_ref)
7023 return TRUE;
7024
7025 /* Don't generate a copy reloc for symbols defined in the executable. */
7026 if (!h->def_dynamic || !h->ref_regular || h->def_regular)
7027 return TRUE;
7028
7029 /* If we didn't find any dynamic relocs in read-only sections, then
7030 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
7031 if (ELIMINATE_COPY_RELOCS && !readonly_dynrelocs (h))
7032 {
7033 h->non_got_ref = 0;
7034 return TRUE;
7035 }
7036
7037 if (h->plt.plist != NULL)
7038 {
7039 /* We should never get here, but unfortunately there are versions
7040 of gcc out there that improperly (for this ABI) put initialized
7041 function pointers, vtable refs and suchlike in read-only
7042 sections. Allow them to proceed, but warn that this might
7043 break at runtime. */
7044 info->callbacks->einfo
7045 (_("%P: copy reloc against `%T' requires lazy plt linking; "
7046 "avoid setting LD_BIND_NOW=1 or upgrade gcc\n"),
7047 h->root.root.string);
7048 }
7049
7050 /* This is a reference to a symbol defined by a dynamic object which
7051 is not a function. */
7052
7053 /* We must allocate the symbol in our .dynbss section, which will
7054 become part of the .bss section of the executable. There will be
7055 an entry for this symbol in the .dynsym section. The dynamic
7056 object will contain position independent code, so all references
7057 from the dynamic object to this symbol will go through the global
7058 offset table. The dynamic linker will use the .dynsym entry to
7059 determine the address it must put in the global offset table, so
7060 both the dynamic object and the regular object will refer to the
7061 same memory location for the variable. */
7062
7063 /* We must generate a R_PPC64_COPY reloc to tell the dynamic linker
7064 to copy the initial value out of the dynamic object and into the
7065 runtime process image. We need to remember the offset into the
7066 .rela.bss section we are going to use. */
7067 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
7068 {
7069 htab->relbss->size += sizeof (Elf64_External_Rela);
7070 h->needs_copy = 1;
7071 }
7072
7073 s = htab->dynbss;
7074
7075 return _bfd_elf_adjust_dynamic_copy (h, s);
7076 }
7077
7078 /* If given a function descriptor symbol, hide both the function code
7079 sym and the descriptor. */
7080 static void
7081 ppc64_elf_hide_symbol (struct bfd_link_info *info,
7082 struct elf_link_hash_entry *h,
7083 bfd_boolean force_local)
7084 {
7085 struct ppc_link_hash_entry *eh;
7086 _bfd_elf_link_hash_hide_symbol (info, h, force_local);
7087
7088 eh = (struct ppc_link_hash_entry *) h;
7089 if (eh->is_func_descriptor)
7090 {
7091 struct ppc_link_hash_entry *fh = eh->oh;
7092
7093 if (fh == NULL)
7094 {
7095 const char *p, *q;
7096 struct ppc_link_hash_table *htab;
7097 char save;
7098
7099 /* We aren't supposed to use alloca in BFD because on
7100 systems which do not have alloca the version in libiberty
7101 calls xmalloc, which might cause the program to crash
7102 when it runs out of memory. This function doesn't have a
7103 return status, so there's no way to gracefully return an
7104 error. So cheat. We know that string[-1] can be safely
7105 accessed; It's either a string in an ELF string table,
7106 or allocated in an objalloc structure. */
7107
7108 p = eh->elf.root.root.string - 1;
7109 save = *p;
7110 *(char *) p = '.';
7111 htab = ppc_hash_table (info);
7112 if (htab == NULL)
7113 return;
7114
7115 fh = (struct ppc_link_hash_entry *)
7116 elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
7117 *(char *) p = save;
7118
7119 /* Unfortunately, if it so happens that the string we were
7120 looking for was allocated immediately before this string,
7121 then we overwrote the string terminator. That's the only
7122 reason the lookup should fail. */
7123 if (fh == NULL)
7124 {
7125 q = eh->elf.root.root.string + strlen (eh->elf.root.root.string);
7126 while (q >= eh->elf.root.root.string && *q == *p)
7127 --q, --p;
7128 if (q < eh->elf.root.root.string && *p == '.')
7129 fh = (struct ppc_link_hash_entry *)
7130 elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
7131 }
7132 if (fh != NULL)
7133 {
7134 eh->oh = fh;
7135 fh->oh = eh;
7136 }
7137 }
7138 if (fh != NULL)
7139 _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
7140 }
7141 }
7142
7143 static bfd_boolean
7144 get_sym_h (struct elf_link_hash_entry **hp,
7145 Elf_Internal_Sym **symp,
7146 asection **symsecp,
7147 unsigned char **tls_maskp,
7148 Elf_Internal_Sym **locsymsp,
7149 unsigned long r_symndx,
7150 bfd *ibfd)
7151 {
7152 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
7153
7154 if (r_symndx >= symtab_hdr->sh_info)
7155 {
7156 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
7157 struct elf_link_hash_entry *h;
7158
7159 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
7160 h = elf_follow_link (h);
7161
7162 if (hp != NULL)
7163 *hp = h;
7164
7165 if (symp != NULL)
7166 *symp = NULL;
7167
7168 if (symsecp != NULL)
7169 {
7170 asection *symsec = NULL;
7171 if (h->root.type == bfd_link_hash_defined
7172 || h->root.type == bfd_link_hash_defweak)
7173 symsec = h->root.u.def.section;
7174 *symsecp = symsec;
7175 }
7176
7177 if (tls_maskp != NULL)
7178 {
7179 struct ppc_link_hash_entry *eh;
7180
7181 eh = (struct ppc_link_hash_entry *) h;
7182 *tls_maskp = &eh->tls_mask;
7183 }
7184 }
7185 else
7186 {
7187 Elf_Internal_Sym *sym;
7188 Elf_Internal_Sym *locsyms = *locsymsp;
7189
7190 if (locsyms == NULL)
7191 {
7192 locsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
7193 if (locsyms == NULL)
7194 locsyms = bfd_elf_get_elf_syms (ibfd, symtab_hdr,
7195 symtab_hdr->sh_info,
7196 0, NULL, NULL, NULL);
7197 if (locsyms == NULL)
7198 return FALSE;
7199 *locsymsp = locsyms;
7200 }
7201 sym = locsyms + r_symndx;
7202
7203 if (hp != NULL)
7204 *hp = NULL;
7205
7206 if (symp != NULL)
7207 *symp = sym;
7208
7209 if (symsecp != NULL)
7210 *symsecp = bfd_section_from_elf_index (ibfd, sym->st_shndx);
7211
7212 if (tls_maskp != NULL)
7213 {
7214 struct got_entry **lgot_ents;
7215 unsigned char *tls_mask;
7216
7217 tls_mask = NULL;
7218 lgot_ents = elf_local_got_ents (ibfd);
7219 if (lgot_ents != NULL)
7220 {
7221 struct plt_entry **local_plt = (struct plt_entry **)
7222 (lgot_ents + symtab_hdr->sh_info);
7223 unsigned char *lgot_masks = (unsigned char *)
7224 (local_plt + symtab_hdr->sh_info);
7225 tls_mask = &lgot_masks[r_symndx];
7226 }
7227 *tls_maskp = tls_mask;
7228 }
7229 }
7230 return TRUE;
7231 }
7232
7233 /* Returns TLS_MASKP for the given REL symbol. Function return is 0 on
7234 error, 2 on a toc GD type suitable for optimization, 3 on a toc LD
7235 type suitable for optimization, and 1 otherwise. */
7236
7237 static int
7238 get_tls_mask (unsigned char **tls_maskp,
7239 unsigned long *toc_symndx,
7240 bfd_vma *toc_addend,
7241 Elf_Internal_Sym **locsymsp,
7242 const Elf_Internal_Rela *rel,
7243 bfd *ibfd)
7244 {
7245 unsigned long r_symndx;
7246 int next_r;
7247 struct elf_link_hash_entry *h;
7248 Elf_Internal_Sym *sym;
7249 asection *sec;
7250 bfd_vma off;
7251
7252 r_symndx = ELF64_R_SYM (rel->r_info);
7253 if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7254 return 0;
7255
7256 if ((*tls_maskp != NULL && **tls_maskp != 0)
7257 || sec == NULL
7258 || ppc64_elf_section_data (sec) == NULL
7259 || ppc64_elf_section_data (sec)->sec_type != sec_toc)
7260 return 1;
7261
7262 /* Look inside a TOC section too. */
7263 if (h != NULL)
7264 {
7265 BFD_ASSERT (h->root.type == bfd_link_hash_defined);
7266 off = h->root.u.def.value;
7267 }
7268 else
7269 off = sym->st_value;
7270 off += rel->r_addend;
7271 BFD_ASSERT (off % 8 == 0);
7272 r_symndx = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8];
7273 next_r = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8 + 1];
7274 if (toc_symndx != NULL)
7275 *toc_symndx = r_symndx;
7276 if (toc_addend != NULL)
7277 *toc_addend = ppc64_elf_section_data (sec)->u.toc.add[off / 8];
7278 if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7279 return 0;
7280 if ((h == NULL || is_static_defined (h))
7281 && (next_r == -1 || next_r == -2))
7282 return 1 - next_r;
7283 return 1;
7284 }
7285
7286 /* Find (or create) an entry in the tocsave hash table. */
7287
7288 static struct tocsave_entry *
7289 tocsave_find (struct ppc_link_hash_table *htab,
7290 enum insert_option insert,
7291 Elf_Internal_Sym **local_syms,
7292 const Elf_Internal_Rela *irela,
7293 bfd *ibfd)
7294 {
7295 unsigned long r_indx;
7296 struct elf_link_hash_entry *h;
7297 Elf_Internal_Sym *sym;
7298 struct tocsave_entry ent, *p;
7299 hashval_t hash;
7300 struct tocsave_entry **slot;
7301
7302 r_indx = ELF64_R_SYM (irela->r_info);
7303 if (!get_sym_h (&h, &sym, &ent.sec, NULL, local_syms, r_indx, ibfd))
7304 return NULL;
7305 if (ent.sec == NULL || ent.sec->output_section == NULL)
7306 {
7307 (*_bfd_error_handler)
7308 (_("%B: undefined symbol on R_PPC64_TOCSAVE relocation"));
7309 return NULL;
7310 }
7311
7312 if (h != NULL)
7313 ent.offset = h->root.u.def.value;
7314 else
7315 ent.offset = sym->st_value;
7316 ent.offset += irela->r_addend;
7317
7318 hash = tocsave_htab_hash (&ent);
7319 slot = ((struct tocsave_entry **)
7320 htab_find_slot_with_hash (htab->tocsave_htab, &ent, hash, insert));
7321 if (slot == NULL)
7322 return NULL;
7323
7324 if (*slot == NULL)
7325 {
7326 p = (struct tocsave_entry *) bfd_alloc (ibfd, sizeof (*p));
7327 if (p == NULL)
7328 return NULL;
7329 *p = ent;
7330 *slot = p;
7331 }
7332 return *slot;
7333 }
7334
7335 /* Adjust all global syms defined in opd sections. In gcc generated
7336 code for the old ABI, these will already have been done. */
7337
7338 static bfd_boolean
7339 adjust_opd_syms (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
7340 {
7341 struct ppc_link_hash_entry *eh;
7342 asection *sym_sec;
7343 struct _opd_sec_data *opd;
7344
7345 if (h->root.type == bfd_link_hash_indirect)
7346 return TRUE;
7347
7348 if (h->root.type != bfd_link_hash_defined
7349 && h->root.type != bfd_link_hash_defweak)
7350 return TRUE;
7351
7352 eh = (struct ppc_link_hash_entry *) h;
7353 if (eh->adjust_done)
7354 return TRUE;
7355
7356 sym_sec = eh->elf.root.u.def.section;
7357 opd = get_opd_info (sym_sec);
7358 if (opd != NULL && opd->adjust != NULL)
7359 {
7360 long adjust = opd->adjust[eh->elf.root.u.def.value / 8];
7361 if (adjust == -1)
7362 {
7363 /* This entry has been deleted. */
7364 asection *dsec = ppc64_elf_tdata (sym_sec->owner)->deleted_section;
7365 if (dsec == NULL)
7366 {
7367 for (dsec = sym_sec->owner->sections; dsec; dsec = dsec->next)
7368 if (discarded_section (dsec))
7369 {
7370 ppc64_elf_tdata (sym_sec->owner)->deleted_section = dsec;
7371 break;
7372 }
7373 }
7374 eh->elf.root.u.def.value = 0;
7375 eh->elf.root.u.def.section = dsec;
7376 }
7377 else
7378 eh->elf.root.u.def.value += adjust;
7379 eh->adjust_done = 1;
7380 }
7381 return TRUE;
7382 }
7383
7384 /* Handles decrementing dynamic reloc counts for the reloc specified by
7385 R_INFO in section SEC. If LOCAL_SYMS is NULL, then H and SYM
7386 have already been determined. */
7387
7388 static bfd_boolean
7389 dec_dynrel_count (bfd_vma r_info,
7390 asection *sec,
7391 struct bfd_link_info *info,
7392 Elf_Internal_Sym **local_syms,
7393 struct elf_link_hash_entry *h,
7394 Elf_Internal_Sym *sym)
7395 {
7396 enum elf_ppc64_reloc_type r_type;
7397 asection *sym_sec = NULL;
7398
7399 /* Can this reloc be dynamic? This switch, and later tests here
7400 should be kept in sync with the code in check_relocs. */
7401 r_type = ELF64_R_TYPE (r_info);
7402 switch (r_type)
7403 {
7404 default:
7405 return TRUE;
7406
7407 case R_PPC64_TPREL16:
7408 case R_PPC64_TPREL16_LO:
7409 case R_PPC64_TPREL16_HI:
7410 case R_PPC64_TPREL16_HA:
7411 case R_PPC64_TPREL16_DS:
7412 case R_PPC64_TPREL16_LO_DS:
7413 case R_PPC64_TPREL16_HIGH:
7414 case R_PPC64_TPREL16_HIGHA:
7415 case R_PPC64_TPREL16_HIGHER:
7416 case R_PPC64_TPREL16_HIGHERA:
7417 case R_PPC64_TPREL16_HIGHEST:
7418 case R_PPC64_TPREL16_HIGHESTA:
7419 if (!info->shared)
7420 return TRUE;
7421
7422 case R_PPC64_TPREL64:
7423 case R_PPC64_DTPMOD64:
7424 case R_PPC64_DTPREL64:
7425 case R_PPC64_ADDR64:
7426 case R_PPC64_REL30:
7427 case R_PPC64_REL32:
7428 case R_PPC64_REL64:
7429 case R_PPC64_ADDR14:
7430 case R_PPC64_ADDR14_BRNTAKEN:
7431 case R_PPC64_ADDR14_BRTAKEN:
7432 case R_PPC64_ADDR16:
7433 case R_PPC64_ADDR16_DS:
7434 case R_PPC64_ADDR16_HA:
7435 case R_PPC64_ADDR16_HI:
7436 case R_PPC64_ADDR16_HIGH:
7437 case R_PPC64_ADDR16_HIGHA:
7438 case R_PPC64_ADDR16_HIGHER:
7439 case R_PPC64_ADDR16_HIGHERA:
7440 case R_PPC64_ADDR16_HIGHEST:
7441 case R_PPC64_ADDR16_HIGHESTA:
7442 case R_PPC64_ADDR16_LO:
7443 case R_PPC64_ADDR16_LO_DS:
7444 case R_PPC64_ADDR24:
7445 case R_PPC64_ADDR32:
7446 case R_PPC64_UADDR16:
7447 case R_PPC64_UADDR32:
7448 case R_PPC64_UADDR64:
7449 case R_PPC64_TOC:
7450 break;
7451 }
7452
7453 if (local_syms != NULL)
7454 {
7455 unsigned long r_symndx;
7456 bfd *ibfd = sec->owner;
7457
7458 r_symndx = ELF64_R_SYM (r_info);
7459 if (!get_sym_h (&h, &sym, &sym_sec, NULL, local_syms, r_symndx, ibfd))
7460 return FALSE;
7461 }
7462
7463 if ((info->shared
7464 && (must_be_dyn_reloc (info, r_type)
7465 || (h != NULL
7466 && (!SYMBOLIC_BIND (info, h)
7467 || h->root.type == bfd_link_hash_defweak
7468 || !h->def_regular))))
7469 || (ELIMINATE_COPY_RELOCS
7470 && !info->shared
7471 && h != NULL
7472 && (h->root.type == bfd_link_hash_defweak
7473 || !h->def_regular)))
7474 ;
7475 else
7476 return TRUE;
7477
7478 if (h != NULL)
7479 {
7480 struct elf_dyn_relocs *p;
7481 struct elf_dyn_relocs **pp;
7482 pp = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
7483
7484 /* elf_gc_sweep may have already removed all dyn relocs associated
7485 with local syms for a given section. Also, symbol flags are
7486 changed by elf_gc_sweep_symbol, confusing the test above. Don't
7487 report a dynreloc miscount. */
7488 if (*pp == NULL && info->gc_sections)
7489 return TRUE;
7490
7491 while ((p = *pp) != NULL)
7492 {
7493 if (p->sec == sec)
7494 {
7495 if (!must_be_dyn_reloc (info, r_type))
7496 p->pc_count -= 1;
7497 p->count -= 1;
7498 if (p->count == 0)
7499 *pp = p->next;
7500 return TRUE;
7501 }
7502 pp = &p->next;
7503 }
7504 }
7505 else
7506 {
7507 struct ppc_dyn_relocs *p;
7508 struct ppc_dyn_relocs **pp;
7509 void *vpp;
7510 bfd_boolean is_ifunc;
7511
7512 if (local_syms == NULL)
7513 sym_sec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
7514 if (sym_sec == NULL)
7515 sym_sec = sec;
7516
7517 vpp = &elf_section_data (sym_sec)->local_dynrel;
7518 pp = (struct ppc_dyn_relocs **) vpp;
7519
7520 if (*pp == NULL && info->gc_sections)
7521 return TRUE;
7522
7523 is_ifunc = ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC;
7524 while ((p = *pp) != NULL)
7525 {
7526 if (p->sec == sec && p->ifunc == is_ifunc)
7527 {
7528 p->count -= 1;
7529 if (p->count == 0)
7530 *pp = p->next;
7531 return TRUE;
7532 }
7533 pp = &p->next;
7534 }
7535 }
7536
7537 info->callbacks->einfo (_("%P: dynreloc miscount for %B, section %A\n"),
7538 sec->owner, sec);
7539 bfd_set_error (bfd_error_bad_value);
7540 return FALSE;
7541 }
7542
7543 /* Remove unused Official Procedure Descriptor entries. Currently we
7544 only remove those associated with functions in discarded link-once
7545 sections, or weakly defined functions that have been overridden. It
7546 would be possible to remove many more entries for statically linked
7547 applications. */
7548
7549 bfd_boolean
7550 ppc64_elf_edit_opd (struct bfd_link_info *info)
7551 {
7552 bfd *ibfd;
7553 bfd_boolean some_edited = FALSE;
7554 asection *need_pad = NULL;
7555 struct ppc_link_hash_table *htab;
7556
7557 htab = ppc_hash_table (info);
7558 if (htab == NULL)
7559 return FALSE;
7560
7561 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
7562 {
7563 asection *sec;
7564 Elf_Internal_Rela *relstart, *rel, *relend;
7565 Elf_Internal_Shdr *symtab_hdr;
7566 Elf_Internal_Sym *local_syms;
7567 bfd_vma offset;
7568 struct _opd_sec_data *opd;
7569 bfd_boolean need_edit, add_aux_fields;
7570 bfd_size_type cnt_16b = 0;
7571
7572 if (!is_ppc64_elf (ibfd))
7573 continue;
7574
7575 sec = bfd_get_section_by_name (ibfd, ".opd");
7576 if (sec == NULL || sec->size == 0)
7577 continue;
7578
7579 if (sec->sec_info_type == SEC_INFO_TYPE_JUST_SYMS)
7580 continue;
7581
7582 if (sec->output_section == bfd_abs_section_ptr)
7583 continue;
7584
7585 /* Look through the section relocs. */
7586 if ((sec->flags & SEC_RELOC) == 0 || sec->reloc_count == 0)
7587 continue;
7588
7589 local_syms = NULL;
7590 symtab_hdr = &elf_symtab_hdr (ibfd);
7591
7592 /* Read the relocations. */
7593 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
7594 info->keep_memory);
7595 if (relstart == NULL)
7596 return FALSE;
7597
7598 /* First run through the relocs to check they are sane, and to
7599 determine whether we need to edit this opd section. */
7600 need_edit = FALSE;
7601 need_pad = sec;
7602 offset = 0;
7603 relend = relstart + sec->reloc_count;
7604 for (rel = relstart; rel < relend; )
7605 {
7606 enum elf_ppc64_reloc_type r_type;
7607 unsigned long r_symndx;
7608 asection *sym_sec;
7609 struct elf_link_hash_entry *h;
7610 Elf_Internal_Sym *sym;
7611
7612 /* .opd contains a regular array of 16 or 24 byte entries. We're
7613 only interested in the reloc pointing to a function entry
7614 point. */
7615 if (rel->r_offset != offset
7616 || rel + 1 >= relend
7617 || (rel + 1)->r_offset != offset + 8)
7618 {
7619 /* If someone messes with .opd alignment then after a
7620 "ld -r" we might have padding in the middle of .opd.
7621 Also, there's nothing to prevent someone putting
7622 something silly in .opd with the assembler. No .opd
7623 optimization for them! */
7624 broken_opd:
7625 (*_bfd_error_handler)
7626 (_("%B: .opd is not a regular array of opd entries"), ibfd);
7627 need_edit = FALSE;
7628 break;
7629 }
7630
7631 if ((r_type = ELF64_R_TYPE (rel->r_info)) != R_PPC64_ADDR64
7632 || (r_type = ELF64_R_TYPE ((rel + 1)->r_info)) != R_PPC64_TOC)
7633 {
7634 (*_bfd_error_handler)
7635 (_("%B: unexpected reloc type %u in .opd section"),
7636 ibfd, r_type);
7637 need_edit = FALSE;
7638 break;
7639 }
7640
7641 r_symndx = ELF64_R_SYM (rel->r_info);
7642 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7643 r_symndx, ibfd))
7644 goto error_ret;
7645
7646 if (sym_sec == NULL || sym_sec->owner == NULL)
7647 {
7648 const char *sym_name;
7649 if (h != NULL)
7650 sym_name = h->root.root.string;
7651 else
7652 sym_name = bfd_elf_sym_name (ibfd, symtab_hdr, sym,
7653 sym_sec);
7654
7655 (*_bfd_error_handler)
7656 (_("%B: undefined sym `%s' in .opd section"),
7657 ibfd, sym_name);
7658 need_edit = FALSE;
7659 break;
7660 }
7661
7662 /* opd entries are always for functions defined in the
7663 current input bfd. If the symbol isn't defined in the
7664 input bfd, then we won't be using the function in this
7665 bfd; It must be defined in a linkonce section in another
7666 bfd, or is weak. It's also possible that we are
7667 discarding the function due to a linker script /DISCARD/,
7668 which we test for via the output_section. */
7669 if (sym_sec->owner != ibfd
7670 || sym_sec->output_section == bfd_abs_section_ptr)
7671 need_edit = TRUE;
7672
7673 rel += 2;
7674 if (rel == relend
7675 || (rel + 1 == relend && rel->r_offset == offset + 16))
7676 {
7677 if (sec->size == offset + 24)
7678 {
7679 need_pad = NULL;
7680 break;
7681 }
7682 if (rel == relend && sec->size == offset + 16)
7683 {
7684 cnt_16b++;
7685 break;
7686 }
7687 goto broken_opd;
7688 }
7689
7690 if (rel->r_offset == offset + 24)
7691 offset += 24;
7692 else if (rel->r_offset != offset + 16)
7693 goto broken_opd;
7694 else if (rel + 1 < relend
7695 && ELF64_R_TYPE (rel[0].r_info) == R_PPC64_ADDR64
7696 && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOC)
7697 {
7698 offset += 16;
7699 cnt_16b++;
7700 }
7701 else if (rel + 2 < relend
7702 && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_ADDR64
7703 && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_TOC)
7704 {
7705 offset += 24;
7706 rel += 1;
7707 }
7708 else
7709 goto broken_opd;
7710 }
7711
7712 add_aux_fields = htab->params->non_overlapping_opd && cnt_16b > 0;
7713
7714 if (need_edit || add_aux_fields)
7715 {
7716 Elf_Internal_Rela *write_rel;
7717 Elf_Internal_Shdr *rel_hdr;
7718 bfd_byte *rptr, *wptr;
7719 bfd_byte *new_contents;
7720 bfd_boolean skip;
7721 long opd_ent_size;
7722 bfd_size_type amt;
7723
7724 new_contents = NULL;
7725 amt = sec->size * sizeof (long) / 8;
7726 opd = &ppc64_elf_section_data (sec)->u.opd;
7727 opd->adjust = bfd_zalloc (sec->owner, amt);
7728 if (opd->adjust == NULL)
7729 return FALSE;
7730 ppc64_elf_section_data (sec)->sec_type = sec_opd;
7731
7732 /* This seems a waste of time as input .opd sections are all
7733 zeros as generated by gcc, but I suppose there's no reason
7734 this will always be so. We might start putting something in
7735 the third word of .opd entries. */
7736 if ((sec->flags & SEC_IN_MEMORY) == 0)
7737 {
7738 bfd_byte *loc;
7739 if (!bfd_malloc_and_get_section (ibfd, sec, &loc))
7740 {
7741 if (loc != NULL)
7742 free (loc);
7743 error_ret:
7744 if (local_syms != NULL
7745 && symtab_hdr->contents != (unsigned char *) local_syms)
7746 free (local_syms);
7747 if (elf_section_data (sec)->relocs != relstart)
7748 free (relstart);
7749 return FALSE;
7750 }
7751 sec->contents = loc;
7752 sec->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
7753 }
7754
7755 elf_section_data (sec)->relocs = relstart;
7756
7757 new_contents = sec->contents;
7758 if (add_aux_fields)
7759 {
7760 new_contents = bfd_malloc (sec->size + cnt_16b * 8);
7761 if (new_contents == NULL)
7762 return FALSE;
7763 need_pad = FALSE;
7764 }
7765 wptr = new_contents;
7766 rptr = sec->contents;
7767
7768 write_rel = relstart;
7769 skip = FALSE;
7770 offset = 0;
7771 opd_ent_size = 0;
7772 for (rel = relstart; rel < relend; rel++)
7773 {
7774 unsigned long r_symndx;
7775 asection *sym_sec;
7776 struct elf_link_hash_entry *h;
7777 Elf_Internal_Sym *sym;
7778
7779 r_symndx = ELF64_R_SYM (rel->r_info);
7780 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7781 r_symndx, ibfd))
7782 goto error_ret;
7783
7784 if (rel->r_offset == offset)
7785 {
7786 struct ppc_link_hash_entry *fdh = NULL;
7787
7788 /* See if the .opd entry is full 24 byte or
7789 16 byte (with fd_aux entry overlapped with next
7790 fd_func). */
7791 opd_ent_size = 24;
7792 if ((rel + 2 == relend && sec->size == offset + 16)
7793 || (rel + 3 < relend
7794 && rel[2].r_offset == offset + 16
7795 && rel[3].r_offset == offset + 24
7796 && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_ADDR64
7797 && ELF64_R_TYPE (rel[3].r_info) == R_PPC64_TOC))
7798 opd_ent_size = 16;
7799
7800 if (h != NULL
7801 && h->root.root.string[0] == '.')
7802 {
7803 fdh = lookup_fdh ((struct ppc_link_hash_entry *) h, htab);
7804 if (fdh != NULL
7805 && fdh->elf.root.type != bfd_link_hash_defined
7806 && fdh->elf.root.type != bfd_link_hash_defweak)
7807 fdh = NULL;
7808 }
7809
7810 skip = (sym_sec->owner != ibfd
7811 || sym_sec->output_section == bfd_abs_section_ptr);
7812 if (skip)
7813 {
7814 if (fdh != NULL && sym_sec->owner == ibfd)
7815 {
7816 /* Arrange for the function descriptor sym
7817 to be dropped. */
7818 fdh->elf.root.u.def.value = 0;
7819 fdh->elf.root.u.def.section = sym_sec;
7820 }
7821 opd->adjust[rel->r_offset / 8] = -1;
7822 }
7823 else
7824 {
7825 /* We'll be keeping this opd entry. */
7826
7827 if (fdh != NULL)
7828 {
7829 /* Redefine the function descriptor symbol to
7830 this location in the opd section. It is
7831 necessary to update the value here rather
7832 than using an array of adjustments as we do
7833 for local symbols, because various places
7834 in the generic ELF code use the value
7835 stored in u.def.value. */
7836 fdh->elf.root.u.def.value = wptr - new_contents;
7837 fdh->adjust_done = 1;
7838 }
7839
7840 /* Local syms are a bit tricky. We could
7841 tweak them as they can be cached, but
7842 we'd need to look through the local syms
7843 for the function descriptor sym which we
7844 don't have at the moment. So keep an
7845 array of adjustments. */
7846 opd->adjust[rel->r_offset / 8]
7847 = (wptr - new_contents) - (rptr - sec->contents);
7848
7849 if (wptr != rptr)
7850 memcpy (wptr, rptr, opd_ent_size);
7851 wptr += opd_ent_size;
7852 if (add_aux_fields && opd_ent_size == 16)
7853 {
7854 memset (wptr, '\0', 8);
7855 wptr += 8;
7856 }
7857 }
7858 rptr += opd_ent_size;
7859 offset += opd_ent_size;
7860 }
7861
7862 if (skip)
7863 {
7864 if (!NO_OPD_RELOCS
7865 && !info->relocatable
7866 && !dec_dynrel_count (rel->r_info, sec, info,
7867 NULL, h, sym))
7868 goto error_ret;
7869 }
7870 else
7871 {
7872 /* We need to adjust any reloc offsets to point to the
7873 new opd entries. While we're at it, we may as well
7874 remove redundant relocs. */
7875 rel->r_offset += opd->adjust[(offset - opd_ent_size) / 8];
7876 if (write_rel != rel)
7877 memcpy (write_rel, rel, sizeof (*rel));
7878 ++write_rel;
7879 }
7880 }
7881
7882 sec->size = wptr - new_contents;
7883 sec->reloc_count = write_rel - relstart;
7884 if (add_aux_fields)
7885 {
7886 free (sec->contents);
7887 sec->contents = new_contents;
7888 }
7889
7890 /* Fudge the header size too, as this is used later in
7891 elf_bfd_final_link if we are emitting relocs. */
7892 rel_hdr = _bfd_elf_single_rel_hdr (sec);
7893 rel_hdr->sh_size = sec->reloc_count * rel_hdr->sh_entsize;
7894 some_edited = TRUE;
7895 }
7896 else if (elf_section_data (sec)->relocs != relstart)
7897 free (relstart);
7898
7899 if (local_syms != NULL
7900 && symtab_hdr->contents != (unsigned char *) local_syms)
7901 {
7902 if (!info->keep_memory)
7903 free (local_syms);
7904 else
7905 symtab_hdr->contents = (unsigned char *) local_syms;
7906 }
7907 }
7908
7909 if (some_edited)
7910 elf_link_hash_traverse (elf_hash_table (info), adjust_opd_syms, NULL);
7911
7912 /* If we are doing a final link and the last .opd entry is just 16 byte
7913 long, add a 8 byte padding after it. */
7914 if (need_pad != NULL && !info->relocatable)
7915 {
7916 bfd_byte *p;
7917
7918 if ((need_pad->flags & SEC_IN_MEMORY) == 0)
7919 {
7920 BFD_ASSERT (need_pad->size > 0);
7921
7922 p = bfd_malloc (need_pad->size + 8);
7923 if (p == NULL)
7924 return FALSE;
7925
7926 if (! bfd_get_section_contents (need_pad->owner, need_pad,
7927 p, 0, need_pad->size))
7928 return FALSE;
7929
7930 need_pad->contents = p;
7931 need_pad->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
7932 }
7933 else
7934 {
7935 p = bfd_realloc (need_pad->contents, need_pad->size + 8);
7936 if (p == NULL)
7937 return FALSE;
7938
7939 need_pad->contents = p;
7940 }
7941
7942 memset (need_pad->contents + need_pad->size, 0, 8);
7943 need_pad->size += 8;
7944 }
7945
7946 return TRUE;
7947 }
7948
7949 /* Set htab->tls_get_addr and call the generic ELF tls_setup function. */
7950
7951 asection *
7952 ppc64_elf_tls_setup (struct bfd_link_info *info)
7953 {
7954 struct ppc_link_hash_table *htab;
7955
7956 htab = ppc_hash_table (info);
7957 if (htab == NULL)
7958 return NULL;
7959
7960 if (abiversion (info->output_bfd) == 1)
7961 htab->opd_abi = 1;
7962
7963 if (htab->params->no_multi_toc)
7964 htab->do_multi_toc = 0;
7965 else if (!htab->do_multi_toc)
7966 htab->params->no_multi_toc = 1;
7967
7968 htab->tls_get_addr = ((struct ppc_link_hash_entry *)
7969 elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
7970 FALSE, FALSE, TRUE));
7971 /* Move dynamic linking info to the function descriptor sym. */
7972 if (htab->tls_get_addr != NULL)
7973 func_desc_adjust (&htab->tls_get_addr->elf, info);
7974 htab->tls_get_addr_fd = ((struct ppc_link_hash_entry *)
7975 elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
7976 FALSE, FALSE, TRUE));
7977 if (!htab->params->no_tls_get_addr_opt)
7978 {
7979 struct elf_link_hash_entry *opt, *opt_fd, *tga, *tga_fd;
7980
7981 opt = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr_opt",
7982 FALSE, FALSE, TRUE);
7983 if (opt != NULL)
7984 func_desc_adjust (opt, info);
7985 opt_fd = elf_link_hash_lookup (&htab->elf, "__tls_get_addr_opt",
7986 FALSE, FALSE, TRUE);
7987 if (opt_fd != NULL
7988 && (opt_fd->root.type == bfd_link_hash_defined
7989 || opt_fd->root.type == bfd_link_hash_defweak))
7990 {
7991 /* If glibc supports an optimized __tls_get_addr call stub,
7992 signalled by the presence of __tls_get_addr_opt, and we'll
7993 be calling __tls_get_addr via a plt call stub, then
7994 make __tls_get_addr point to __tls_get_addr_opt. */
7995 tga_fd = &htab->tls_get_addr_fd->elf;
7996 if (htab->elf.dynamic_sections_created
7997 && tga_fd != NULL
7998 && (tga_fd->type == STT_FUNC
7999 || tga_fd->needs_plt)
8000 && !(SYMBOL_CALLS_LOCAL (info, tga_fd)
8001 || (ELF_ST_VISIBILITY (tga_fd->other) != STV_DEFAULT
8002 && tga_fd->root.type == bfd_link_hash_undefweak)))
8003 {
8004 struct plt_entry *ent;
8005
8006 for (ent = tga_fd->plt.plist; ent != NULL; ent = ent->next)
8007 if (ent->plt.refcount > 0)
8008 break;
8009 if (ent != NULL)
8010 {
8011 tga_fd->root.type = bfd_link_hash_indirect;
8012 tga_fd->root.u.i.link = &opt_fd->root;
8013 ppc64_elf_copy_indirect_symbol (info, opt_fd, tga_fd);
8014 if (opt_fd->dynindx != -1)
8015 {
8016 /* Use __tls_get_addr_opt in dynamic relocations. */
8017 opt_fd->dynindx = -1;
8018 _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
8019 opt_fd->dynstr_index);
8020 if (!bfd_elf_link_record_dynamic_symbol (info, opt_fd))
8021 return NULL;
8022 }
8023 htab->tls_get_addr_fd = (struct ppc_link_hash_entry *) opt_fd;
8024 tga = &htab->tls_get_addr->elf;
8025 if (opt != NULL && tga != NULL)
8026 {
8027 tga->root.type = bfd_link_hash_indirect;
8028 tga->root.u.i.link = &opt->root;
8029 ppc64_elf_copy_indirect_symbol (info, opt, tga);
8030 _bfd_elf_link_hash_hide_symbol (info, opt,
8031 tga->forced_local);
8032 htab->tls_get_addr = (struct ppc_link_hash_entry *) opt;
8033 }
8034 htab->tls_get_addr_fd->oh = htab->tls_get_addr;
8035 htab->tls_get_addr_fd->is_func_descriptor = 1;
8036 if (htab->tls_get_addr != NULL)
8037 {
8038 htab->tls_get_addr->oh = htab->tls_get_addr_fd;
8039 htab->tls_get_addr->is_func = 1;
8040 }
8041 }
8042 }
8043 }
8044 else
8045 htab->params->no_tls_get_addr_opt = TRUE;
8046 }
8047 return _bfd_elf_tls_setup (info->output_bfd, info);
8048 }
8049
8050 /* Return TRUE iff REL is a branch reloc with a global symbol matching
8051 HASH1 or HASH2. */
8052
8053 static bfd_boolean
8054 branch_reloc_hash_match (const bfd *ibfd,
8055 const Elf_Internal_Rela *rel,
8056 const struct ppc_link_hash_entry *hash1,
8057 const struct ppc_link_hash_entry *hash2)
8058 {
8059 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
8060 enum elf_ppc64_reloc_type r_type = ELF64_R_TYPE (rel->r_info);
8061 unsigned int r_symndx = ELF64_R_SYM (rel->r_info);
8062
8063 if (r_symndx >= symtab_hdr->sh_info && is_branch_reloc (r_type))
8064 {
8065 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
8066 struct elf_link_hash_entry *h;
8067
8068 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
8069 h = elf_follow_link (h);
8070 if (h == &hash1->elf || h == &hash2->elf)
8071 return TRUE;
8072 }
8073 return FALSE;
8074 }
8075
8076 /* Run through all the TLS relocs looking for optimization
8077 opportunities. The linker has been hacked (see ppc64elf.em) to do
8078 a preliminary section layout so that we know the TLS segment
8079 offsets. We can't optimize earlier because some optimizations need
8080 to know the tp offset, and we need to optimize before allocating
8081 dynamic relocations. */
8082
8083 bfd_boolean
8084 ppc64_elf_tls_optimize (struct bfd_link_info *info)
8085 {
8086 bfd *ibfd;
8087 asection *sec;
8088 struct ppc_link_hash_table *htab;
8089 unsigned char *toc_ref;
8090 int pass;
8091
8092 if (info->relocatable || !info->executable)
8093 return TRUE;
8094
8095 htab = ppc_hash_table (info);
8096 if (htab == NULL)
8097 return FALSE;
8098
8099 /* Make two passes over the relocs. On the first pass, mark toc
8100 entries involved with tls relocs, and check that tls relocs
8101 involved in setting up a tls_get_addr call are indeed followed by
8102 such a call. If they are not, we can't do any tls optimization.
8103 On the second pass twiddle tls_mask flags to notify
8104 relocate_section that optimization can be done, and adjust got
8105 and plt refcounts. */
8106 toc_ref = NULL;
8107 for (pass = 0; pass < 2; ++pass)
8108 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
8109 {
8110 Elf_Internal_Sym *locsyms = NULL;
8111 asection *toc = bfd_get_section_by_name (ibfd, ".toc");
8112
8113 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8114 if (sec->has_tls_reloc && !bfd_is_abs_section (sec->output_section))
8115 {
8116 Elf_Internal_Rela *relstart, *rel, *relend;
8117 bfd_boolean found_tls_get_addr_arg = 0;
8118
8119 /* Read the relocations. */
8120 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8121 info->keep_memory);
8122 if (relstart == NULL)
8123 {
8124 free (toc_ref);
8125 return FALSE;
8126 }
8127
8128 relend = relstart + sec->reloc_count;
8129 for (rel = relstart; rel < relend; rel++)
8130 {
8131 enum elf_ppc64_reloc_type r_type;
8132 unsigned long r_symndx;
8133 struct elf_link_hash_entry *h;
8134 Elf_Internal_Sym *sym;
8135 asection *sym_sec;
8136 unsigned char *tls_mask;
8137 unsigned char tls_set, tls_clear, tls_type = 0;
8138 bfd_vma value;
8139 bfd_boolean ok_tprel, is_local;
8140 long toc_ref_index = 0;
8141 int expecting_tls_get_addr = 0;
8142 bfd_boolean ret = FALSE;
8143
8144 r_symndx = ELF64_R_SYM (rel->r_info);
8145 if (!get_sym_h (&h, &sym, &sym_sec, &tls_mask, &locsyms,
8146 r_symndx, ibfd))
8147 {
8148 err_free_rel:
8149 if (elf_section_data (sec)->relocs != relstart)
8150 free (relstart);
8151 if (toc_ref != NULL)
8152 free (toc_ref);
8153 if (locsyms != NULL
8154 && (elf_symtab_hdr (ibfd).contents
8155 != (unsigned char *) locsyms))
8156 free (locsyms);
8157 return ret;
8158 }
8159
8160 if (h != NULL)
8161 {
8162 if (h->root.type == bfd_link_hash_defined
8163 || h->root.type == bfd_link_hash_defweak)
8164 value = h->root.u.def.value;
8165 else if (h->root.type == bfd_link_hash_undefweak)
8166 value = 0;
8167 else
8168 {
8169 found_tls_get_addr_arg = 0;
8170 continue;
8171 }
8172 }
8173 else
8174 /* Symbols referenced by TLS relocs must be of type
8175 STT_TLS. So no need for .opd local sym adjust. */
8176 value = sym->st_value;
8177
8178 ok_tprel = FALSE;
8179 is_local = FALSE;
8180 if (h == NULL
8181 || !h->def_dynamic)
8182 {
8183 is_local = TRUE;
8184 if (h != NULL
8185 && h->root.type == bfd_link_hash_undefweak)
8186 ok_tprel = TRUE;
8187 else
8188 {
8189 value += sym_sec->output_offset;
8190 value += sym_sec->output_section->vma;
8191 value -= htab->elf.tls_sec->vma;
8192 ok_tprel = (value + TP_OFFSET + ((bfd_vma) 1 << 31)
8193 < (bfd_vma) 1 << 32);
8194 }
8195 }
8196
8197 r_type = ELF64_R_TYPE (rel->r_info);
8198 /* If this section has old-style __tls_get_addr calls
8199 without marker relocs, then check that each
8200 __tls_get_addr call reloc is preceded by a reloc
8201 that conceivably belongs to the __tls_get_addr arg
8202 setup insn. If we don't find matching arg setup
8203 relocs, don't do any tls optimization. */
8204 if (pass == 0
8205 && sec->has_tls_get_addr_call
8206 && h != NULL
8207 && (h == &htab->tls_get_addr->elf
8208 || h == &htab->tls_get_addr_fd->elf)
8209 && !found_tls_get_addr_arg
8210 && is_branch_reloc (r_type))
8211 {
8212 info->callbacks->minfo (_("%H __tls_get_addr lost arg, "
8213 "TLS optimization disabled\n"),
8214 ibfd, sec, rel->r_offset);
8215 ret = TRUE;
8216 goto err_free_rel;
8217 }
8218
8219 found_tls_get_addr_arg = 0;
8220 switch (r_type)
8221 {
8222 case R_PPC64_GOT_TLSLD16:
8223 case R_PPC64_GOT_TLSLD16_LO:
8224 expecting_tls_get_addr = 1;
8225 found_tls_get_addr_arg = 1;
8226 /* Fall thru */
8227
8228 case R_PPC64_GOT_TLSLD16_HI:
8229 case R_PPC64_GOT_TLSLD16_HA:
8230 /* These relocs should never be against a symbol
8231 defined in a shared lib. Leave them alone if
8232 that turns out to be the case. */
8233 if (!is_local)
8234 continue;
8235
8236 /* LD -> LE */
8237 tls_set = 0;
8238 tls_clear = TLS_LD;
8239 tls_type = TLS_TLS | TLS_LD;
8240 break;
8241
8242 case R_PPC64_GOT_TLSGD16:
8243 case R_PPC64_GOT_TLSGD16_LO:
8244 expecting_tls_get_addr = 1;
8245 found_tls_get_addr_arg = 1;
8246 /* Fall thru */
8247
8248 case R_PPC64_GOT_TLSGD16_HI:
8249 case R_PPC64_GOT_TLSGD16_HA:
8250 if (ok_tprel)
8251 /* GD -> LE */
8252 tls_set = 0;
8253 else
8254 /* GD -> IE */
8255 tls_set = TLS_TLS | TLS_TPRELGD;
8256 tls_clear = TLS_GD;
8257 tls_type = TLS_TLS | TLS_GD;
8258 break;
8259
8260 case R_PPC64_GOT_TPREL16_DS:
8261 case R_PPC64_GOT_TPREL16_LO_DS:
8262 case R_PPC64_GOT_TPREL16_HI:
8263 case R_PPC64_GOT_TPREL16_HA:
8264 if (ok_tprel)
8265 {
8266 /* IE -> LE */
8267 tls_set = 0;
8268 tls_clear = TLS_TPREL;
8269 tls_type = TLS_TLS | TLS_TPREL;
8270 break;
8271 }
8272 continue;
8273
8274 case R_PPC64_TLSGD:
8275 case R_PPC64_TLSLD:
8276 found_tls_get_addr_arg = 1;
8277 /* Fall thru */
8278
8279 case R_PPC64_TLS:
8280 case R_PPC64_TOC16:
8281 case R_PPC64_TOC16_LO:
8282 if (sym_sec == NULL || sym_sec != toc)
8283 continue;
8284
8285 /* Mark this toc entry as referenced by a TLS
8286 code sequence. We can do that now in the
8287 case of R_PPC64_TLS, and after checking for
8288 tls_get_addr for the TOC16 relocs. */
8289 if (toc_ref == NULL)
8290 toc_ref = bfd_zmalloc (toc->output_section->rawsize / 8);
8291 if (toc_ref == NULL)
8292 goto err_free_rel;
8293
8294 if (h != NULL)
8295 value = h->root.u.def.value;
8296 else
8297 value = sym->st_value;
8298 value += rel->r_addend;
8299 BFD_ASSERT (value < toc->size && value % 8 == 0);
8300 toc_ref_index = (value + toc->output_offset) / 8;
8301 if (r_type == R_PPC64_TLS
8302 || r_type == R_PPC64_TLSGD
8303 || r_type == R_PPC64_TLSLD)
8304 {
8305 toc_ref[toc_ref_index] = 1;
8306 continue;
8307 }
8308
8309 if (pass != 0 && toc_ref[toc_ref_index] == 0)
8310 continue;
8311
8312 tls_set = 0;
8313 tls_clear = 0;
8314 expecting_tls_get_addr = 2;
8315 break;
8316
8317 case R_PPC64_TPREL64:
8318 if (pass == 0
8319 || sec != toc
8320 || toc_ref == NULL
8321 || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
8322 continue;
8323 if (ok_tprel)
8324 {
8325 /* IE -> LE */
8326 tls_set = TLS_EXPLICIT;
8327 tls_clear = TLS_TPREL;
8328 break;
8329 }
8330 continue;
8331
8332 case R_PPC64_DTPMOD64:
8333 if (pass == 0
8334 || sec != toc
8335 || toc_ref == NULL
8336 || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
8337 continue;
8338 if (rel + 1 < relend
8339 && (rel[1].r_info
8340 == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64))
8341 && rel[1].r_offset == rel->r_offset + 8)
8342 {
8343 if (ok_tprel)
8344 /* GD -> LE */
8345 tls_set = TLS_EXPLICIT | TLS_GD;
8346 else
8347 /* GD -> IE */
8348 tls_set = TLS_EXPLICIT | TLS_GD | TLS_TPRELGD;
8349 tls_clear = TLS_GD;
8350 }
8351 else
8352 {
8353 if (!is_local)
8354 continue;
8355
8356 /* LD -> LE */
8357 tls_set = TLS_EXPLICIT;
8358 tls_clear = TLS_LD;
8359 }
8360 break;
8361
8362 default:
8363 continue;
8364 }
8365
8366 if (pass == 0)
8367 {
8368 if (!expecting_tls_get_addr
8369 || !sec->has_tls_get_addr_call)
8370 continue;
8371
8372 if (rel + 1 < relend
8373 && branch_reloc_hash_match (ibfd, rel + 1,
8374 htab->tls_get_addr,
8375 htab->tls_get_addr_fd))
8376 {
8377 if (expecting_tls_get_addr == 2)
8378 {
8379 /* Check for toc tls entries. */
8380 unsigned char *toc_tls;
8381 int retval;
8382
8383 retval = get_tls_mask (&toc_tls, NULL, NULL,
8384 &locsyms,
8385 rel, ibfd);
8386 if (retval == 0)
8387 goto err_free_rel;
8388 if (toc_tls != NULL)
8389 {
8390 if ((*toc_tls & (TLS_GD | TLS_LD)) != 0)
8391 found_tls_get_addr_arg = 1;
8392 if (retval > 1)
8393 toc_ref[toc_ref_index] = 1;
8394 }
8395 }
8396 continue;
8397 }
8398
8399 if (expecting_tls_get_addr != 1)
8400 continue;
8401
8402 /* Uh oh, we didn't find the expected call. We
8403 could just mark this symbol to exclude it
8404 from tls optimization but it's safer to skip
8405 the entire optimization. */
8406 info->callbacks->minfo (_("%H arg lost __tls_get_addr, "
8407 "TLS optimization disabled\n"),
8408 ibfd, sec, rel->r_offset);
8409 ret = TRUE;
8410 goto err_free_rel;
8411 }
8412
8413 if (expecting_tls_get_addr && htab->tls_get_addr != NULL)
8414 {
8415 struct plt_entry *ent;
8416 for (ent = htab->tls_get_addr->elf.plt.plist;
8417 ent != NULL;
8418 ent = ent->next)
8419 if (ent->addend == 0)
8420 {
8421 if (ent->plt.refcount > 0)
8422 {
8423 ent->plt.refcount -= 1;
8424 expecting_tls_get_addr = 0;
8425 }
8426 break;
8427 }
8428 }
8429
8430 if (expecting_tls_get_addr && htab->tls_get_addr_fd != NULL)
8431 {
8432 struct plt_entry *ent;
8433 for (ent = htab->tls_get_addr_fd->elf.plt.plist;
8434 ent != NULL;
8435 ent = ent->next)
8436 if (ent->addend == 0)
8437 {
8438 if (ent->plt.refcount > 0)
8439 ent->plt.refcount -= 1;
8440 break;
8441 }
8442 }
8443
8444 if (tls_clear == 0)
8445 continue;
8446
8447 if ((tls_set & TLS_EXPLICIT) == 0)
8448 {
8449 struct got_entry *ent;
8450
8451 /* Adjust got entry for this reloc. */
8452 if (h != NULL)
8453 ent = h->got.glist;
8454 else
8455 ent = elf_local_got_ents (ibfd)[r_symndx];
8456
8457 for (; ent != NULL; ent = ent->next)
8458 if (ent->addend == rel->r_addend
8459 && ent->owner == ibfd
8460 && ent->tls_type == tls_type)
8461 break;
8462 if (ent == NULL)
8463 abort ();
8464
8465 if (tls_set == 0)
8466 {
8467 /* We managed to get rid of a got entry. */
8468 if (ent->got.refcount > 0)
8469 ent->got.refcount -= 1;
8470 }
8471 }
8472 else
8473 {
8474 /* If we got rid of a DTPMOD/DTPREL reloc pair then
8475 we'll lose one or two dyn relocs. */
8476 if (!dec_dynrel_count (rel->r_info, sec, info,
8477 NULL, h, sym))
8478 return FALSE;
8479
8480 if (tls_set == (TLS_EXPLICIT | TLS_GD))
8481 {
8482 if (!dec_dynrel_count ((rel + 1)->r_info, sec, info,
8483 NULL, h, sym))
8484 return FALSE;
8485 }
8486 }
8487
8488 *tls_mask |= tls_set;
8489 *tls_mask &= ~tls_clear;
8490 }
8491
8492 if (elf_section_data (sec)->relocs != relstart)
8493 free (relstart);
8494 }
8495
8496 if (locsyms != NULL
8497 && (elf_symtab_hdr (ibfd).contents != (unsigned char *) locsyms))
8498 {
8499 if (!info->keep_memory)
8500 free (locsyms);
8501 else
8502 elf_symtab_hdr (ibfd).contents = (unsigned char *) locsyms;
8503 }
8504 }
8505
8506 if (toc_ref != NULL)
8507 free (toc_ref);
8508 return TRUE;
8509 }
8510
8511 /* Called via elf_link_hash_traverse from ppc64_elf_edit_toc to adjust
8512 the values of any global symbols in a toc section that has been
8513 edited. Globals in toc sections should be a rarity, so this function
8514 sets a flag if any are found in toc sections other than the one just
8515 edited, so that futher hash table traversals can be avoided. */
8516
8517 struct adjust_toc_info
8518 {
8519 asection *toc;
8520 unsigned long *skip;
8521 bfd_boolean global_toc_syms;
8522 };
8523
8524 enum toc_skip_enum { ref_from_discarded = 1, can_optimize = 2 };
8525
8526 static bfd_boolean
8527 adjust_toc_syms (struct elf_link_hash_entry *h, void *inf)
8528 {
8529 struct ppc_link_hash_entry *eh;
8530 struct adjust_toc_info *toc_inf = (struct adjust_toc_info *) inf;
8531 unsigned long i;
8532
8533 if (h->root.type != bfd_link_hash_defined
8534 && h->root.type != bfd_link_hash_defweak)
8535 return TRUE;
8536
8537 eh = (struct ppc_link_hash_entry *) h;
8538 if (eh->adjust_done)
8539 return TRUE;
8540
8541 if (eh->elf.root.u.def.section == toc_inf->toc)
8542 {
8543 if (eh->elf.root.u.def.value > toc_inf->toc->rawsize)
8544 i = toc_inf->toc->rawsize >> 3;
8545 else
8546 i = eh->elf.root.u.def.value >> 3;
8547
8548 if ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0)
8549 {
8550 (*_bfd_error_handler)
8551 (_("%s defined on removed toc entry"), eh->elf.root.root.string);
8552 do
8553 ++i;
8554 while ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0);
8555 eh->elf.root.u.def.value = (bfd_vma) i << 3;
8556 }
8557
8558 eh->elf.root.u.def.value -= toc_inf->skip[i];
8559 eh->adjust_done = 1;
8560 }
8561 else if (strcmp (eh->elf.root.u.def.section->name, ".toc") == 0)
8562 toc_inf->global_toc_syms = TRUE;
8563
8564 return TRUE;
8565 }
8566
8567 /* Return TRUE iff INSN is one we expect on a _LO variety toc/got reloc. */
8568
8569 static bfd_boolean
8570 ok_lo_toc_insn (unsigned int insn)
8571 {
8572 return ((insn & (0x3f << 26)) == 14u << 26 /* addi */
8573 || (insn & (0x3f << 26)) == 32u << 26 /* lwz */
8574 || (insn & (0x3f << 26)) == 34u << 26 /* lbz */
8575 || (insn & (0x3f << 26)) == 36u << 26 /* stw */
8576 || (insn & (0x3f << 26)) == 38u << 26 /* stb */
8577 || (insn & (0x3f << 26)) == 40u << 26 /* lhz */
8578 || (insn & (0x3f << 26)) == 42u << 26 /* lha */
8579 || (insn & (0x3f << 26)) == 44u << 26 /* sth */
8580 || (insn & (0x3f << 26)) == 46u << 26 /* lmw */
8581 || (insn & (0x3f << 26)) == 47u << 26 /* stmw */
8582 || (insn & (0x3f << 26)) == 48u << 26 /* lfs */
8583 || (insn & (0x3f << 26)) == 50u << 26 /* lfd */
8584 || (insn & (0x3f << 26)) == 52u << 26 /* stfs */
8585 || (insn & (0x3f << 26)) == 54u << 26 /* stfd */
8586 || ((insn & (0x3f << 26)) == 58u << 26 /* lwa,ld,lmd */
8587 && (insn & 3) != 1)
8588 || ((insn & (0x3f << 26)) == 62u << 26 /* std, stmd */
8589 && ((insn & 3) == 0 || (insn & 3) == 3))
8590 || (insn & (0x3f << 26)) == 12u << 26 /* addic */);
8591 }
8592
8593 /* Examine all relocs referencing .toc sections in order to remove
8594 unused .toc entries. */
8595
8596 bfd_boolean
8597 ppc64_elf_edit_toc (struct bfd_link_info *info)
8598 {
8599 bfd *ibfd;
8600 struct adjust_toc_info toc_inf;
8601 struct ppc_link_hash_table *htab = ppc_hash_table (info);
8602
8603 htab->do_toc_opt = 1;
8604 toc_inf.global_toc_syms = TRUE;
8605 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
8606 {
8607 asection *toc, *sec;
8608 Elf_Internal_Shdr *symtab_hdr;
8609 Elf_Internal_Sym *local_syms;
8610 Elf_Internal_Rela *relstart, *rel, *toc_relocs;
8611 unsigned long *skip, *drop;
8612 unsigned char *used;
8613 unsigned char *keep, last, some_unused;
8614
8615 if (!is_ppc64_elf (ibfd))
8616 continue;
8617
8618 toc = bfd_get_section_by_name (ibfd, ".toc");
8619 if (toc == NULL
8620 || toc->size == 0
8621 || toc->sec_info_type == SEC_INFO_TYPE_JUST_SYMS
8622 || discarded_section (toc))
8623 continue;
8624
8625 toc_relocs = NULL;
8626 local_syms = NULL;
8627 symtab_hdr = &elf_symtab_hdr (ibfd);
8628
8629 /* Look at sections dropped from the final link. */
8630 skip = NULL;
8631 relstart = NULL;
8632 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8633 {
8634 if (sec->reloc_count == 0
8635 || !discarded_section (sec)
8636 || get_opd_info (sec)
8637 || (sec->flags & SEC_ALLOC) == 0
8638 || (sec->flags & SEC_DEBUGGING) != 0)
8639 continue;
8640
8641 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL, FALSE);
8642 if (relstart == NULL)
8643 goto error_ret;
8644
8645 /* Run through the relocs to see which toc entries might be
8646 unused. */
8647 for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
8648 {
8649 enum elf_ppc64_reloc_type r_type;
8650 unsigned long r_symndx;
8651 asection *sym_sec;
8652 struct elf_link_hash_entry *h;
8653 Elf_Internal_Sym *sym;
8654 bfd_vma val;
8655
8656 r_type = ELF64_R_TYPE (rel->r_info);
8657 switch (r_type)
8658 {
8659 default:
8660 continue;
8661
8662 case R_PPC64_TOC16:
8663 case R_PPC64_TOC16_LO:
8664 case R_PPC64_TOC16_HI:
8665 case R_PPC64_TOC16_HA:
8666 case R_PPC64_TOC16_DS:
8667 case R_PPC64_TOC16_LO_DS:
8668 break;
8669 }
8670
8671 r_symndx = ELF64_R_SYM (rel->r_info);
8672 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8673 r_symndx, ibfd))
8674 goto error_ret;
8675
8676 if (sym_sec != toc)
8677 continue;
8678
8679 if (h != NULL)
8680 val = h->root.u.def.value;
8681 else
8682 val = sym->st_value;
8683 val += rel->r_addend;
8684
8685 if (val >= toc->size)
8686 continue;
8687
8688 /* Anything in the toc ought to be aligned to 8 bytes.
8689 If not, don't mark as unused. */
8690 if (val & 7)
8691 continue;
8692
8693 if (skip == NULL)
8694 {
8695 skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
8696 if (skip == NULL)
8697 goto error_ret;
8698 }
8699
8700 skip[val >> 3] = ref_from_discarded;
8701 }
8702
8703 if (elf_section_data (sec)->relocs != relstart)
8704 free (relstart);
8705 }
8706
8707 /* For largetoc loads of address constants, we can convert
8708 . addis rx,2,addr@got@ha
8709 . ld ry,addr@got@l(rx)
8710 to
8711 . addis rx,2,addr@toc@ha
8712 . addi ry,rx,addr@toc@l
8713 when addr is within 2G of the toc pointer. This then means
8714 that the word storing "addr" in the toc is no longer needed. */
8715
8716 if (!ppc64_elf_tdata (ibfd)->has_small_toc_reloc
8717 && toc->output_section->rawsize < (bfd_vma) 1 << 31
8718 && toc->reloc_count != 0)
8719 {
8720 /* Read toc relocs. */
8721 toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
8722 info->keep_memory);
8723 if (toc_relocs == NULL)
8724 goto error_ret;
8725
8726 for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
8727 {
8728 enum elf_ppc64_reloc_type r_type;
8729 unsigned long r_symndx;
8730 asection *sym_sec;
8731 struct elf_link_hash_entry *h;
8732 Elf_Internal_Sym *sym;
8733 bfd_vma val, addr;
8734
8735 r_type = ELF64_R_TYPE (rel->r_info);
8736 if (r_type != R_PPC64_ADDR64)
8737 continue;
8738
8739 r_symndx = ELF64_R_SYM (rel->r_info);
8740 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8741 r_symndx, ibfd))
8742 goto error_ret;
8743
8744 if (sym_sec == NULL
8745 || discarded_section (sym_sec))
8746 continue;
8747
8748 if (!SYMBOL_REFERENCES_LOCAL (info, h))
8749 continue;
8750
8751 if (h != NULL)
8752 {
8753 if (h->type == STT_GNU_IFUNC)
8754 continue;
8755 val = h->root.u.def.value;
8756 }
8757 else
8758 {
8759 if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
8760 continue;
8761 val = sym->st_value;
8762 }
8763 val += rel->r_addend;
8764 val += sym_sec->output_section->vma + sym_sec->output_offset;
8765
8766 /* We don't yet know the exact toc pointer value, but we
8767 know it will be somewhere in the toc section. Don't
8768 optimize if the difference from any possible toc
8769 pointer is outside [ff..f80008000, 7fff7fff]. */
8770 addr = toc->output_section->vma + TOC_BASE_OFF;
8771 if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
8772 continue;
8773
8774 addr = toc->output_section->vma + toc->output_section->rawsize;
8775 if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
8776 continue;
8777
8778 if (skip == NULL)
8779 {
8780 skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
8781 if (skip == NULL)
8782 goto error_ret;
8783 }
8784
8785 skip[rel->r_offset >> 3]
8786 |= can_optimize | ((rel - toc_relocs) << 2);
8787 }
8788 }
8789
8790 if (skip == NULL)
8791 continue;
8792
8793 used = bfd_zmalloc (sizeof (*used) * (toc->size + 7) / 8);
8794 if (used == NULL)
8795 {
8796 error_ret:
8797 if (local_syms != NULL
8798 && symtab_hdr->contents != (unsigned char *) local_syms)
8799 free (local_syms);
8800 if (sec != NULL
8801 && relstart != NULL
8802 && elf_section_data (sec)->relocs != relstart)
8803 free (relstart);
8804 if (toc_relocs != NULL
8805 && elf_section_data (toc)->relocs != toc_relocs)
8806 free (toc_relocs);
8807 if (skip != NULL)
8808 free (skip);
8809 return FALSE;
8810 }
8811
8812 /* Now check all kept sections that might reference the toc.
8813 Check the toc itself last. */
8814 for (sec = (ibfd->sections == toc && toc->next ? toc->next
8815 : ibfd->sections);
8816 sec != NULL;
8817 sec = (sec == toc ? NULL
8818 : sec->next == NULL ? toc
8819 : sec->next == toc && toc->next ? toc->next
8820 : sec->next))
8821 {
8822 int repeat;
8823
8824 if (sec->reloc_count == 0
8825 || discarded_section (sec)
8826 || get_opd_info (sec)
8827 || (sec->flags & SEC_ALLOC) == 0
8828 || (sec->flags & SEC_DEBUGGING) != 0)
8829 continue;
8830
8831 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8832 info->keep_memory);
8833 if (relstart == NULL)
8834 {
8835 free (used);
8836 goto error_ret;
8837 }
8838
8839 /* Mark toc entries referenced as used. */
8840 do
8841 {
8842 repeat = 0;
8843 for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
8844 {
8845 enum elf_ppc64_reloc_type r_type;
8846 unsigned long r_symndx;
8847 asection *sym_sec;
8848 struct elf_link_hash_entry *h;
8849 Elf_Internal_Sym *sym;
8850 bfd_vma val;
8851 enum {no_check, check_lo, check_ha} insn_check;
8852
8853 r_type = ELF64_R_TYPE (rel->r_info);
8854 switch (r_type)
8855 {
8856 default:
8857 insn_check = no_check;
8858 break;
8859
8860 case R_PPC64_GOT_TLSLD16_HA:
8861 case R_PPC64_GOT_TLSGD16_HA:
8862 case R_PPC64_GOT_TPREL16_HA:
8863 case R_PPC64_GOT_DTPREL16_HA:
8864 case R_PPC64_GOT16_HA:
8865 case R_PPC64_TOC16_HA:
8866 insn_check = check_ha;
8867 break;
8868
8869 case R_PPC64_GOT_TLSLD16_LO:
8870 case R_PPC64_GOT_TLSGD16_LO:
8871 case R_PPC64_GOT_TPREL16_LO_DS:
8872 case R_PPC64_GOT_DTPREL16_LO_DS:
8873 case R_PPC64_GOT16_LO:
8874 case R_PPC64_GOT16_LO_DS:
8875 case R_PPC64_TOC16_LO:
8876 case R_PPC64_TOC16_LO_DS:
8877 insn_check = check_lo;
8878 break;
8879 }
8880
8881 if (insn_check != no_check)
8882 {
8883 bfd_vma off = rel->r_offset & ~3;
8884 unsigned char buf[4];
8885 unsigned int insn;
8886
8887 if (!bfd_get_section_contents (ibfd, sec, buf, off, 4))
8888 {
8889 free (used);
8890 goto error_ret;
8891 }
8892 insn = bfd_get_32 (ibfd, buf);
8893 if (insn_check == check_lo
8894 ? !ok_lo_toc_insn (insn)
8895 : ((insn & ((0x3f << 26) | 0x1f << 16))
8896 != ((15u << 26) | (2 << 16)) /* addis rt,2,imm */))
8897 {
8898 char str[12];
8899
8900 ppc64_elf_tdata (ibfd)->unexpected_toc_insn = 1;
8901 sprintf (str, "%#08x", insn);
8902 info->callbacks->einfo
8903 (_("%P: %H: toc optimization is not supported for"
8904 " %s instruction.\n"),
8905 ibfd, sec, rel->r_offset & ~3, str);
8906 }
8907 }
8908
8909 switch (r_type)
8910 {
8911 case R_PPC64_TOC16:
8912 case R_PPC64_TOC16_LO:
8913 case R_PPC64_TOC16_HI:
8914 case R_PPC64_TOC16_HA:
8915 case R_PPC64_TOC16_DS:
8916 case R_PPC64_TOC16_LO_DS:
8917 /* In case we're taking addresses of toc entries. */
8918 case R_PPC64_ADDR64:
8919 break;
8920
8921 default:
8922 continue;
8923 }
8924
8925 r_symndx = ELF64_R_SYM (rel->r_info);
8926 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8927 r_symndx, ibfd))
8928 {
8929 free (used);
8930 goto error_ret;
8931 }
8932
8933 if (sym_sec != toc)
8934 continue;
8935
8936 if (h != NULL)
8937 val = h->root.u.def.value;
8938 else
8939 val = sym->st_value;
8940 val += rel->r_addend;
8941
8942 if (val >= toc->size)
8943 continue;
8944
8945 if ((skip[val >> 3] & can_optimize) != 0)
8946 {
8947 bfd_vma off;
8948 unsigned char opc;
8949
8950 switch (r_type)
8951 {
8952 case R_PPC64_TOC16_HA:
8953 break;
8954
8955 case R_PPC64_TOC16_LO_DS:
8956 off = rel->r_offset;
8957 off += (bfd_big_endian (ibfd) ? -2 : 3);
8958 if (!bfd_get_section_contents (ibfd, sec, &opc,
8959 off, 1))
8960 {
8961 free (used);
8962 goto error_ret;
8963 }
8964 if ((opc & (0x3f << 2)) == (58u << 2))
8965 break;
8966 /* Fall thru */
8967
8968 default:
8969 /* Wrong sort of reloc, or not a ld. We may
8970 as well clear ref_from_discarded too. */
8971 skip[val >> 3] = 0;
8972 }
8973 }
8974
8975 if (sec != toc)
8976 used[val >> 3] = 1;
8977 /* For the toc section, we only mark as used if this
8978 entry itself isn't unused. */
8979 else if ((used[rel->r_offset >> 3]
8980 || !(skip[rel->r_offset >> 3] & ref_from_discarded))
8981 && !used[val >> 3])
8982 {
8983 /* Do all the relocs again, to catch reference
8984 chains. */
8985 repeat = 1;
8986 used[val >> 3] = 1;
8987 }
8988 }
8989 }
8990 while (repeat);
8991
8992 if (elf_section_data (sec)->relocs != relstart)
8993 free (relstart);
8994 }
8995
8996 /* Merge the used and skip arrays. Assume that TOC
8997 doublewords not appearing as either used or unused belong
8998 to to an entry more than one doubleword in size. */
8999 for (drop = skip, keep = used, last = 0, some_unused = 0;
9000 drop < skip + (toc->size + 7) / 8;
9001 ++drop, ++keep)
9002 {
9003 if (*keep)
9004 {
9005 *drop &= ~ref_from_discarded;
9006 if ((*drop & can_optimize) != 0)
9007 some_unused = 1;
9008 last = 0;
9009 }
9010 else if ((*drop & ref_from_discarded) != 0)
9011 {
9012 some_unused = 1;
9013 last = ref_from_discarded;
9014 }
9015 else
9016 *drop = last;
9017 }
9018
9019 free (used);
9020
9021 if (some_unused)
9022 {
9023 bfd_byte *contents, *src;
9024 unsigned long off;
9025 Elf_Internal_Sym *sym;
9026 bfd_boolean local_toc_syms = FALSE;
9027
9028 /* Shuffle the toc contents, and at the same time convert the
9029 skip array from booleans into offsets. */
9030 if (!bfd_malloc_and_get_section (ibfd, toc, &contents))
9031 goto error_ret;
9032
9033 elf_section_data (toc)->this_hdr.contents = contents;
9034
9035 for (src = contents, off = 0, drop = skip;
9036 src < contents + toc->size;
9037 src += 8, ++drop)
9038 {
9039 if ((*drop & (can_optimize | ref_from_discarded)) != 0)
9040 off += 8;
9041 else if (off != 0)
9042 {
9043 *drop = off;
9044 memcpy (src - off, src, 8);
9045 }
9046 }
9047 *drop = off;
9048 toc->rawsize = toc->size;
9049 toc->size = src - contents - off;
9050
9051 /* Adjust addends for relocs against the toc section sym,
9052 and optimize any accesses we can. */
9053 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
9054 {
9055 if (sec->reloc_count == 0
9056 || discarded_section (sec))
9057 continue;
9058
9059 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
9060 info->keep_memory);
9061 if (relstart == NULL)
9062 goto error_ret;
9063
9064 for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9065 {
9066 enum elf_ppc64_reloc_type r_type;
9067 unsigned long r_symndx;
9068 asection *sym_sec;
9069 struct elf_link_hash_entry *h;
9070 bfd_vma val;
9071
9072 r_type = ELF64_R_TYPE (rel->r_info);
9073 switch (r_type)
9074 {
9075 default:
9076 continue;
9077
9078 case R_PPC64_TOC16:
9079 case R_PPC64_TOC16_LO:
9080 case R_PPC64_TOC16_HI:
9081 case R_PPC64_TOC16_HA:
9082 case R_PPC64_TOC16_DS:
9083 case R_PPC64_TOC16_LO_DS:
9084 case R_PPC64_ADDR64:
9085 break;
9086 }
9087
9088 r_symndx = ELF64_R_SYM (rel->r_info);
9089 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9090 r_symndx, ibfd))
9091 goto error_ret;
9092
9093 if (sym_sec != toc)
9094 continue;
9095
9096 if (h != NULL)
9097 val = h->root.u.def.value;
9098 else
9099 {
9100 val = sym->st_value;
9101 if (val != 0)
9102 local_toc_syms = TRUE;
9103 }
9104
9105 val += rel->r_addend;
9106
9107 if (val > toc->rawsize)
9108 val = toc->rawsize;
9109 else if ((skip[val >> 3] & ref_from_discarded) != 0)
9110 continue;
9111 else if ((skip[val >> 3] & can_optimize) != 0)
9112 {
9113 Elf_Internal_Rela *tocrel
9114 = toc_relocs + (skip[val >> 3] >> 2);
9115 unsigned long tsym = ELF64_R_SYM (tocrel->r_info);
9116
9117 switch (r_type)
9118 {
9119 case R_PPC64_TOC16_HA:
9120 rel->r_info = ELF64_R_INFO (tsym, R_PPC64_TOC16_HA);
9121 break;
9122
9123 case R_PPC64_TOC16_LO_DS:
9124 rel->r_info = ELF64_R_INFO (tsym, R_PPC64_LO_DS_OPT);
9125 break;
9126
9127 default:
9128 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
9129 ppc_howto_init ();
9130 info->callbacks->einfo
9131 (_("%P: %H: %s references "
9132 "optimized away TOC entry\n"),
9133 ibfd, sec, rel->r_offset,
9134 ppc64_elf_howto_table[r_type]->name);
9135 bfd_set_error (bfd_error_bad_value);
9136 goto error_ret;
9137 }
9138 rel->r_addend = tocrel->r_addend;
9139 elf_section_data (sec)->relocs = relstart;
9140 continue;
9141 }
9142
9143 if (h != NULL || sym->st_value != 0)
9144 continue;
9145
9146 rel->r_addend -= skip[val >> 3];
9147 elf_section_data (sec)->relocs = relstart;
9148 }
9149
9150 if (elf_section_data (sec)->relocs != relstart)
9151 free (relstart);
9152 }
9153
9154 /* We shouldn't have local or global symbols defined in the TOC,
9155 but handle them anyway. */
9156 if (local_syms != NULL)
9157 for (sym = local_syms;
9158 sym < local_syms + symtab_hdr->sh_info;
9159 ++sym)
9160 if (sym->st_value != 0
9161 && bfd_section_from_elf_index (ibfd, sym->st_shndx) == toc)
9162 {
9163 unsigned long i;
9164
9165 if (sym->st_value > toc->rawsize)
9166 i = toc->rawsize >> 3;
9167 else
9168 i = sym->st_value >> 3;
9169
9170 if ((skip[i] & (ref_from_discarded | can_optimize)) != 0)
9171 {
9172 if (local_toc_syms)
9173 (*_bfd_error_handler)
9174 (_("%s defined on removed toc entry"),
9175 bfd_elf_sym_name (ibfd, symtab_hdr, sym, NULL));
9176 do
9177 ++i;
9178 while ((skip[i] & (ref_from_discarded | can_optimize)));
9179 sym->st_value = (bfd_vma) i << 3;
9180 }
9181
9182 sym->st_value -= skip[i];
9183 symtab_hdr->contents = (unsigned char *) local_syms;
9184 }
9185
9186 /* Adjust any global syms defined in this toc input section. */
9187 if (toc_inf.global_toc_syms)
9188 {
9189 toc_inf.toc = toc;
9190 toc_inf.skip = skip;
9191 toc_inf.global_toc_syms = FALSE;
9192 elf_link_hash_traverse (elf_hash_table (info), adjust_toc_syms,
9193 &toc_inf);
9194 }
9195
9196 if (toc->reloc_count != 0)
9197 {
9198 Elf_Internal_Shdr *rel_hdr;
9199 Elf_Internal_Rela *wrel;
9200 bfd_size_type sz;
9201
9202 /* Remove unused toc relocs, and adjust those we keep. */
9203 if (toc_relocs == NULL)
9204 toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
9205 info->keep_memory);
9206 if (toc_relocs == NULL)
9207 goto error_ret;
9208
9209 wrel = toc_relocs;
9210 for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
9211 if ((skip[rel->r_offset >> 3]
9212 & (ref_from_discarded | can_optimize)) == 0)
9213 {
9214 wrel->r_offset = rel->r_offset - skip[rel->r_offset >> 3];
9215 wrel->r_info = rel->r_info;
9216 wrel->r_addend = rel->r_addend;
9217 ++wrel;
9218 }
9219 else if (!dec_dynrel_count (rel->r_info, toc, info,
9220 &local_syms, NULL, NULL))
9221 goto error_ret;
9222
9223 elf_section_data (toc)->relocs = toc_relocs;
9224 toc->reloc_count = wrel - toc_relocs;
9225 rel_hdr = _bfd_elf_single_rel_hdr (toc);
9226 sz = rel_hdr->sh_entsize;
9227 rel_hdr->sh_size = toc->reloc_count * sz;
9228 }
9229 }
9230 else if (toc_relocs != NULL
9231 && elf_section_data (toc)->relocs != toc_relocs)
9232 free (toc_relocs);
9233
9234 if (local_syms != NULL
9235 && symtab_hdr->contents != (unsigned char *) local_syms)
9236 {
9237 if (!info->keep_memory)
9238 free (local_syms);
9239 else
9240 symtab_hdr->contents = (unsigned char *) local_syms;
9241 }
9242 free (skip);
9243 }
9244
9245 return TRUE;
9246 }
9247
9248 /* Return true iff input section I references the TOC using
9249 instructions limited to +/-32k offsets. */
9250
9251 bfd_boolean
9252 ppc64_elf_has_small_toc_reloc (asection *i)
9253 {
9254 return (is_ppc64_elf (i->owner)
9255 && ppc64_elf_tdata (i->owner)->has_small_toc_reloc);
9256 }
9257
9258 /* Allocate space for one GOT entry. */
9259
9260 static void
9261 allocate_got (struct elf_link_hash_entry *h,
9262 struct bfd_link_info *info,
9263 struct got_entry *gent)
9264 {
9265 struct ppc_link_hash_table *htab = ppc_hash_table (info);
9266 bfd_boolean dyn;
9267 struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
9268 int entsize = (gent->tls_type & eh->tls_mask & (TLS_GD | TLS_LD)
9269 ? 16 : 8);
9270 int rentsize = (gent->tls_type & eh->tls_mask & TLS_GD
9271 ? 2 : 1) * sizeof (Elf64_External_Rela);
9272 asection *got = ppc64_elf_tdata (gent->owner)->got;
9273
9274 gent->got.offset = got->size;
9275 got->size += entsize;
9276
9277 dyn = htab->elf.dynamic_sections_created;
9278 if (h->type == STT_GNU_IFUNC)
9279 {
9280 htab->elf.irelplt->size += rentsize;
9281 htab->got_reli_size += rentsize;
9282 }
9283 else if ((info->shared
9284 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h))
9285 && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
9286 || h->root.type != bfd_link_hash_undefweak))
9287 {
9288 asection *relgot = ppc64_elf_tdata (gent->owner)->relgot;
9289 relgot->size += rentsize;
9290 }
9291 }
9292
9293 /* This function merges got entries in the same toc group. */
9294
9295 static void
9296 merge_got_entries (struct got_entry **pent)
9297 {
9298 struct got_entry *ent, *ent2;
9299
9300 for (ent = *pent; ent != NULL; ent = ent->next)
9301 if (!ent->is_indirect)
9302 for (ent2 = ent->next; ent2 != NULL; ent2 = ent2->next)
9303 if (!ent2->is_indirect
9304 && ent2->addend == ent->addend
9305 && ent2->tls_type == ent->tls_type
9306 && elf_gp (ent2->owner) == elf_gp (ent->owner))
9307 {
9308 ent2->is_indirect = TRUE;
9309 ent2->got.ent = ent;
9310 }
9311 }
9312
9313 /* Allocate space in .plt, .got and associated reloc sections for
9314 dynamic relocs. */
9315
9316 static bfd_boolean
9317 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
9318 {
9319 struct bfd_link_info *info;
9320 struct ppc_link_hash_table *htab;
9321 asection *s;
9322 struct ppc_link_hash_entry *eh;
9323 struct elf_dyn_relocs *p;
9324 struct got_entry **pgent, *gent;
9325
9326 if (h->root.type == bfd_link_hash_indirect)
9327 return TRUE;
9328
9329 info = (struct bfd_link_info *) inf;
9330 htab = ppc_hash_table (info);
9331 if (htab == NULL)
9332 return FALSE;
9333
9334 if ((htab->elf.dynamic_sections_created
9335 && h->dynindx != -1
9336 && WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info->shared, h))
9337 || h->type == STT_GNU_IFUNC)
9338 {
9339 struct plt_entry *pent;
9340 bfd_boolean doneone = FALSE;
9341 for (pent = h->plt.plist; pent != NULL; pent = pent->next)
9342 if (pent->plt.refcount > 0)
9343 {
9344 if (!htab->elf.dynamic_sections_created
9345 || h->dynindx == -1)
9346 {
9347 s = htab->elf.iplt;
9348 pent->plt.offset = s->size;
9349 s->size += PLT_ENTRY_SIZE (htab);
9350 s = htab->elf.irelplt;
9351 }
9352 else
9353 {
9354 /* If this is the first .plt entry, make room for the special
9355 first entry. */
9356 s = htab->elf.splt;
9357 if (s->size == 0)
9358 s->size += PLT_INITIAL_ENTRY_SIZE (htab);
9359
9360 pent->plt.offset = s->size;
9361
9362 /* Make room for this entry. */
9363 s->size += PLT_ENTRY_SIZE (htab);
9364
9365 /* Make room for the .glink code. */
9366 s = htab->glink;
9367 if (s->size == 0)
9368 s->size += GLINK_CALL_STUB_SIZE;
9369 if (htab->opd_abi)
9370 {
9371 /* We need bigger stubs past index 32767. */
9372 if (s->size >= GLINK_CALL_STUB_SIZE + 32768*2*4)
9373 s->size += 4;
9374 s->size += 2*4;
9375 }
9376 else
9377 s->size += 4;
9378
9379 /* We also need to make an entry in the .rela.plt section. */
9380 s = htab->elf.srelplt;
9381 }
9382 s->size += sizeof (Elf64_External_Rela);
9383 doneone = TRUE;
9384 }
9385 else
9386 pent->plt.offset = (bfd_vma) -1;
9387 if (!doneone)
9388 {
9389 h->plt.plist = NULL;
9390 h->needs_plt = 0;
9391 }
9392 }
9393 else
9394 {
9395 h->plt.plist = NULL;
9396 h->needs_plt = 0;
9397 }
9398
9399 eh = (struct ppc_link_hash_entry *) h;
9400 /* Run through the TLS GD got entries first if we're changing them
9401 to TPREL. */
9402 if ((eh->tls_mask & TLS_TPRELGD) != 0)
9403 for (gent = h->got.glist; gent != NULL; gent = gent->next)
9404 if (gent->got.refcount > 0
9405 && (gent->tls_type & TLS_GD) != 0)
9406 {
9407 /* This was a GD entry that has been converted to TPREL. If
9408 there happens to be a TPREL entry we can use that one. */
9409 struct got_entry *ent;
9410 for (ent = h->got.glist; ent != NULL; ent = ent->next)
9411 if (ent->got.refcount > 0
9412 && (ent->tls_type & TLS_TPREL) != 0
9413 && ent->addend == gent->addend
9414 && ent->owner == gent->owner)
9415 {
9416 gent->got.refcount = 0;
9417 break;
9418 }
9419
9420 /* If not, then we'll be using our own TPREL entry. */
9421 if (gent->got.refcount != 0)
9422 gent->tls_type = TLS_TLS | TLS_TPREL;
9423 }
9424
9425 /* Remove any list entry that won't generate a word in the GOT before
9426 we call merge_got_entries. Otherwise we risk merging to empty
9427 entries. */
9428 pgent = &h->got.glist;
9429 while ((gent = *pgent) != NULL)
9430 if (gent->got.refcount > 0)
9431 {
9432 if ((gent->tls_type & TLS_LD) != 0
9433 && !h->def_dynamic)
9434 {
9435 ppc64_tlsld_got (gent->owner)->got.refcount += 1;
9436 *pgent = gent->next;
9437 }
9438 else
9439 pgent = &gent->next;
9440 }
9441 else
9442 *pgent = gent->next;
9443
9444 if (!htab->do_multi_toc)
9445 merge_got_entries (&h->got.glist);
9446
9447 for (gent = h->got.glist; gent != NULL; gent = gent->next)
9448 if (!gent->is_indirect)
9449 {
9450 /* Make sure this symbol is output as a dynamic symbol.
9451 Undefined weak syms won't yet be marked as dynamic,
9452 nor will all TLS symbols. */
9453 if (h->dynindx == -1
9454 && !h->forced_local
9455 && h->type != STT_GNU_IFUNC
9456 && htab->elf.dynamic_sections_created)
9457 {
9458 if (! bfd_elf_link_record_dynamic_symbol (info, h))
9459 return FALSE;
9460 }
9461
9462 if (!is_ppc64_elf (gent->owner))
9463 abort ();
9464
9465 allocate_got (h, info, gent);
9466 }
9467
9468 if (eh->dyn_relocs == NULL
9469 || (!htab->elf.dynamic_sections_created
9470 && h->type != STT_GNU_IFUNC))
9471 return TRUE;
9472
9473 /* In the shared -Bsymbolic case, discard space allocated for
9474 dynamic pc-relative relocs against symbols which turn out to be
9475 defined in regular objects. For the normal shared case, discard
9476 space for relocs that have become local due to symbol visibility
9477 changes. */
9478
9479 if (info->shared)
9480 {
9481 /* Relocs that use pc_count are those that appear on a call insn,
9482 or certain REL relocs (see must_be_dyn_reloc) that can be
9483 generated via assembly. We want calls to protected symbols to
9484 resolve directly to the function rather than going via the plt.
9485 If people want function pointer comparisons to work as expected
9486 then they should avoid writing weird assembly. */
9487 if (SYMBOL_CALLS_LOCAL (info, h))
9488 {
9489 struct elf_dyn_relocs **pp;
9490
9491 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
9492 {
9493 p->count -= p->pc_count;
9494 p->pc_count = 0;
9495 if (p->count == 0)
9496 *pp = p->next;
9497 else
9498 pp = &p->next;
9499 }
9500 }
9501
9502 /* Also discard relocs on undefined weak syms with non-default
9503 visibility. */
9504 if (eh->dyn_relocs != NULL
9505 && h->root.type == bfd_link_hash_undefweak)
9506 {
9507 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
9508 eh->dyn_relocs = NULL;
9509
9510 /* Make sure this symbol is output as a dynamic symbol.
9511 Undefined weak syms won't yet be marked as dynamic. */
9512 else if (h->dynindx == -1
9513 && !h->forced_local)
9514 {
9515 if (! bfd_elf_link_record_dynamic_symbol (info, h))
9516 return FALSE;
9517 }
9518 }
9519 }
9520 else if (h->type == STT_GNU_IFUNC)
9521 {
9522 if (!h->non_got_ref)
9523 eh->dyn_relocs = NULL;
9524 }
9525 else if (ELIMINATE_COPY_RELOCS)
9526 {
9527 /* For the non-shared case, discard space for relocs against
9528 symbols which turn out to need copy relocs or are not
9529 dynamic. */
9530
9531 if (!h->non_got_ref
9532 && !h->def_regular)
9533 {
9534 /* Make sure this symbol is output as a dynamic symbol.
9535 Undefined weak syms won't yet be marked as dynamic. */
9536 if (h->dynindx == -1
9537 && !h->forced_local)
9538 {
9539 if (! bfd_elf_link_record_dynamic_symbol (info, h))
9540 return FALSE;
9541 }
9542
9543 /* If that succeeded, we know we'll be keeping all the
9544 relocs. */
9545 if (h->dynindx != -1)
9546 goto keep;
9547 }
9548
9549 eh->dyn_relocs = NULL;
9550
9551 keep: ;
9552 }
9553
9554 /* Finally, allocate space. */
9555 for (p = eh->dyn_relocs; p != NULL; p = p->next)
9556 {
9557 asection *sreloc = elf_section_data (p->sec)->sreloc;
9558 if (eh->elf.type == STT_GNU_IFUNC)
9559 sreloc = htab->elf.irelplt;
9560 sreloc->size += p->count * sizeof (Elf64_External_Rela);
9561 }
9562
9563 return TRUE;
9564 }
9565
9566 /* Called via elf_link_hash_traverse from ppc64_elf_size_dynamic_sections
9567 to set up space for global entry stubs. These are put in glink,
9568 after the branch table. */
9569
9570 static bfd_boolean
9571 size_global_entry_stubs (struct elf_link_hash_entry *h, void *inf)
9572 {
9573 struct bfd_link_info *info;
9574 struct ppc_link_hash_table *htab;
9575 struct plt_entry *pent;
9576 asection *s;
9577
9578 if (h->root.type == bfd_link_hash_indirect)
9579 return TRUE;
9580
9581 if (!h->pointer_equality_needed)
9582 return TRUE;
9583
9584 if (h->def_regular)
9585 return TRUE;
9586
9587 info = inf;
9588 htab = ppc_hash_table (info);
9589 if (htab == NULL)
9590 return FALSE;
9591
9592 s = htab->glink;
9593 for (pent = h->plt.plist; pent != NULL; pent = pent->next)
9594 if (pent->plt.offset != (bfd_vma) -1
9595 && pent->addend == 0)
9596 {
9597 /* For ELFv2, if this symbol is not defined in a regular file
9598 and we are not generating a shared library or pie, then we
9599 need to define the symbol in the executable on a call stub.
9600 This is to avoid text relocations. */
9601 s->size = (s->size + 15) & -16;
9602 h->root.u.def.section = s;
9603 h->root.u.def.value = s->size;
9604 s->size += 16;
9605 break;
9606 }
9607 return TRUE;
9608 }
9609
9610 /* Set DF_TEXTREL if we find any dynamic relocs that apply to
9611 read-only sections. */
9612
9613 static bfd_boolean
9614 maybe_set_textrel (struct elf_link_hash_entry *h, void *info)
9615 {
9616 if (h->root.type == bfd_link_hash_indirect)
9617 return TRUE;
9618
9619 if (readonly_dynrelocs (h))
9620 {
9621 ((struct bfd_link_info *) info)->flags |= DF_TEXTREL;
9622
9623 /* Not an error, just cut short the traversal. */
9624 return FALSE;
9625 }
9626 return TRUE;
9627 }
9628
9629 /* Set the sizes of the dynamic sections. */
9630
9631 static bfd_boolean
9632 ppc64_elf_size_dynamic_sections (bfd *output_bfd,
9633 struct bfd_link_info *info)
9634 {
9635 struct ppc_link_hash_table *htab;
9636 bfd *dynobj;
9637 asection *s;
9638 bfd_boolean relocs;
9639 bfd *ibfd;
9640 struct got_entry *first_tlsld;
9641
9642 htab = ppc_hash_table (info);
9643 if (htab == NULL)
9644 return FALSE;
9645
9646 dynobj = htab->elf.dynobj;
9647 if (dynobj == NULL)
9648 abort ();
9649
9650 if (htab->elf.dynamic_sections_created)
9651 {
9652 /* Set the contents of the .interp section to the interpreter. */
9653 if (info->executable)
9654 {
9655 s = bfd_get_linker_section (dynobj, ".interp");
9656 if (s == NULL)
9657 abort ();
9658 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
9659 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
9660 }
9661 }
9662
9663 /* Set up .got offsets for local syms, and space for local dynamic
9664 relocs. */
9665 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
9666 {
9667 struct got_entry **lgot_ents;
9668 struct got_entry **end_lgot_ents;
9669 struct plt_entry **local_plt;
9670 struct plt_entry **end_local_plt;
9671 unsigned char *lgot_masks;
9672 bfd_size_type locsymcount;
9673 Elf_Internal_Shdr *symtab_hdr;
9674
9675 if (!is_ppc64_elf (ibfd))
9676 continue;
9677
9678 for (s = ibfd->sections; s != NULL; s = s->next)
9679 {
9680 struct ppc_dyn_relocs *p;
9681
9682 for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
9683 {
9684 if (!bfd_is_abs_section (p->sec)
9685 && bfd_is_abs_section (p->sec->output_section))
9686 {
9687 /* Input section has been discarded, either because
9688 it is a copy of a linkonce section or due to
9689 linker script /DISCARD/, so we'll be discarding
9690 the relocs too. */
9691 }
9692 else if (p->count != 0)
9693 {
9694 asection *srel = elf_section_data (p->sec)->sreloc;
9695 if (p->ifunc)
9696 srel = htab->elf.irelplt;
9697 srel->size += p->count * sizeof (Elf64_External_Rela);
9698 if ((p->sec->output_section->flags & SEC_READONLY) != 0)
9699 info->flags |= DF_TEXTREL;
9700 }
9701 }
9702 }
9703
9704 lgot_ents = elf_local_got_ents (ibfd);
9705 if (!lgot_ents)
9706 continue;
9707
9708 symtab_hdr = &elf_symtab_hdr (ibfd);
9709 locsymcount = symtab_hdr->sh_info;
9710 end_lgot_ents = lgot_ents + locsymcount;
9711 local_plt = (struct plt_entry **) end_lgot_ents;
9712 end_local_plt = local_plt + locsymcount;
9713 lgot_masks = (unsigned char *) end_local_plt;
9714 s = ppc64_elf_tdata (ibfd)->got;
9715 for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
9716 {
9717 struct got_entry **pent, *ent;
9718
9719 pent = lgot_ents;
9720 while ((ent = *pent) != NULL)
9721 if (ent->got.refcount > 0)
9722 {
9723 if ((ent->tls_type & *lgot_masks & TLS_LD) != 0)
9724 {
9725 ppc64_tlsld_got (ibfd)->got.refcount += 1;
9726 *pent = ent->next;
9727 }
9728 else
9729 {
9730 unsigned int ent_size = 8;
9731 unsigned int rel_size = sizeof (Elf64_External_Rela);
9732
9733 ent->got.offset = s->size;
9734 if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
9735 {
9736 ent_size *= 2;
9737 rel_size *= 2;
9738 }
9739 s->size += ent_size;
9740 if ((*lgot_masks & PLT_IFUNC) != 0)
9741 {
9742 htab->elf.irelplt->size += rel_size;
9743 htab->got_reli_size += rel_size;
9744 }
9745 else if (info->shared)
9746 {
9747 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
9748 srel->size += rel_size;
9749 }
9750 pent = &ent->next;
9751 }
9752 }
9753 else
9754 *pent = ent->next;
9755 }
9756
9757 /* Allocate space for calls to local STT_GNU_IFUNC syms in .iplt. */
9758 for (; local_plt < end_local_plt; ++local_plt)
9759 {
9760 struct plt_entry *ent;
9761
9762 for (ent = *local_plt; ent != NULL; ent = ent->next)
9763 if (ent->plt.refcount > 0)
9764 {
9765 s = htab->elf.iplt;
9766 ent->plt.offset = s->size;
9767 s->size += PLT_ENTRY_SIZE (htab);
9768
9769 htab->elf.irelplt->size += sizeof (Elf64_External_Rela);
9770 }
9771 else
9772 ent->plt.offset = (bfd_vma) -1;
9773 }
9774 }
9775
9776 /* Allocate global sym .plt and .got entries, and space for global
9777 sym dynamic relocs. */
9778 elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, info);
9779 /* Stash the end of glink branch table. */
9780 if (htab->glink != NULL)
9781 htab->glink->rawsize = htab->glink->size;
9782
9783 if (!htab->opd_abi && !info->shared)
9784 elf_link_hash_traverse (&htab->elf, size_global_entry_stubs, info);
9785
9786 first_tlsld = NULL;
9787 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
9788 {
9789 struct got_entry *ent;
9790
9791 if (!is_ppc64_elf (ibfd))
9792 continue;
9793
9794 ent = ppc64_tlsld_got (ibfd);
9795 if (ent->got.refcount > 0)
9796 {
9797 if (!htab->do_multi_toc && first_tlsld != NULL)
9798 {
9799 ent->is_indirect = TRUE;
9800 ent->got.ent = first_tlsld;
9801 }
9802 else
9803 {
9804 if (first_tlsld == NULL)
9805 first_tlsld = ent;
9806 s = ppc64_elf_tdata (ibfd)->got;
9807 ent->got.offset = s->size;
9808 ent->owner = ibfd;
9809 s->size += 16;
9810 if (info->shared)
9811 {
9812 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
9813 srel->size += sizeof (Elf64_External_Rela);
9814 }
9815 }
9816 }
9817 else
9818 ent->got.offset = (bfd_vma) -1;
9819 }
9820
9821 /* We now have determined the sizes of the various dynamic sections.
9822 Allocate memory for them. */
9823 relocs = FALSE;
9824 for (s = dynobj->sections; s != NULL; s = s->next)
9825 {
9826 if ((s->flags & SEC_LINKER_CREATED) == 0)
9827 continue;
9828
9829 if (s == htab->brlt || s == htab->relbrlt)
9830 /* These haven't been allocated yet; don't strip. */
9831 continue;
9832 else if (s == htab->elf.sgot
9833 || s == htab->elf.splt
9834 || s == htab->elf.iplt
9835 || s == htab->glink
9836 || s == htab->dynbss)
9837 {
9838 /* Strip this section if we don't need it; see the
9839 comment below. */
9840 }
9841 else if (s == htab->glink_eh_frame)
9842 {
9843 if (!bfd_is_abs_section (s->output_section))
9844 /* Not sized yet. */
9845 continue;
9846 }
9847 else if (CONST_STRNEQ (s->name, ".rela"))
9848 {
9849 if (s->size != 0)
9850 {
9851 if (s != htab->elf.srelplt)
9852 relocs = TRUE;
9853
9854 /* We use the reloc_count field as a counter if we need
9855 to copy relocs into the output file. */
9856 s->reloc_count = 0;
9857 }
9858 }
9859 else
9860 {
9861 /* It's not one of our sections, so don't allocate space. */
9862 continue;
9863 }
9864
9865 if (s->size == 0)
9866 {
9867 /* If we don't need this section, strip it from the
9868 output file. This is mostly to handle .rela.bss and
9869 .rela.plt. We must create both sections in
9870 create_dynamic_sections, because they must be created
9871 before the linker maps input sections to output
9872 sections. The linker does that before
9873 adjust_dynamic_symbol is called, and it is that
9874 function which decides whether anything needs to go
9875 into these sections. */
9876 s->flags |= SEC_EXCLUDE;
9877 continue;
9878 }
9879
9880 if ((s->flags & SEC_HAS_CONTENTS) == 0)
9881 continue;
9882
9883 /* Allocate memory for the section contents. We use bfd_zalloc
9884 here in case unused entries are not reclaimed before the
9885 section's contents are written out. This should not happen,
9886 but this way if it does we get a R_PPC64_NONE reloc in .rela
9887 sections instead of garbage.
9888 We also rely on the section contents being zero when writing
9889 the GOT. */
9890 s->contents = bfd_zalloc (dynobj, s->size);
9891 if (s->contents == NULL)
9892 return FALSE;
9893 }
9894
9895 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
9896 {
9897 if (!is_ppc64_elf (ibfd))
9898 continue;
9899
9900 s = ppc64_elf_tdata (ibfd)->got;
9901 if (s != NULL && s != htab->elf.sgot)
9902 {
9903 if (s->size == 0)
9904 s->flags |= SEC_EXCLUDE;
9905 else
9906 {
9907 s->contents = bfd_zalloc (ibfd, s->size);
9908 if (s->contents == NULL)
9909 return FALSE;
9910 }
9911 }
9912 s = ppc64_elf_tdata (ibfd)->relgot;
9913 if (s != NULL)
9914 {
9915 if (s->size == 0)
9916 s->flags |= SEC_EXCLUDE;
9917 else
9918 {
9919 s->contents = bfd_zalloc (ibfd, s->size);
9920 if (s->contents == NULL)
9921 return FALSE;
9922 relocs = TRUE;
9923 s->reloc_count = 0;
9924 }
9925 }
9926 }
9927
9928 if (htab->elf.dynamic_sections_created)
9929 {
9930 bfd_boolean tls_opt;
9931
9932 /* Add some entries to the .dynamic section. We fill in the
9933 values later, in ppc64_elf_finish_dynamic_sections, but we
9934 must add the entries now so that we get the correct size for
9935 the .dynamic section. The DT_DEBUG entry is filled in by the
9936 dynamic linker and used by the debugger. */
9937 #define add_dynamic_entry(TAG, VAL) \
9938 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
9939
9940 if (info->executable)
9941 {
9942 if (!add_dynamic_entry (DT_DEBUG, 0))
9943 return FALSE;
9944 }
9945
9946 if (htab->elf.splt != NULL && htab->elf.splt->size != 0)
9947 {
9948 if (!add_dynamic_entry (DT_PLTGOT, 0)
9949 || !add_dynamic_entry (DT_PLTRELSZ, 0)
9950 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
9951 || !add_dynamic_entry (DT_JMPREL, 0)
9952 || !add_dynamic_entry (DT_PPC64_GLINK, 0))
9953 return FALSE;
9954 }
9955
9956 if (NO_OPD_RELOCS && abiversion (output_bfd) <= 1)
9957 {
9958 if (!add_dynamic_entry (DT_PPC64_OPD, 0)
9959 || !add_dynamic_entry (DT_PPC64_OPDSZ, 0))
9960 return FALSE;
9961 }
9962
9963 tls_opt = (!htab->params->no_tls_get_addr_opt
9964 && htab->tls_get_addr_fd != NULL
9965 && htab->tls_get_addr_fd->elf.plt.plist != NULL);
9966 if (tls_opt || !htab->opd_abi)
9967 {
9968 if (!add_dynamic_entry (DT_PPC64_OPT, tls_opt ? PPC64_OPT_TLS : 0))
9969 return FALSE;
9970 }
9971
9972 if (relocs)
9973 {
9974 if (!add_dynamic_entry (DT_RELA, 0)
9975 || !add_dynamic_entry (DT_RELASZ, 0)
9976 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
9977 return FALSE;
9978
9979 /* If any dynamic relocs apply to a read-only section,
9980 then we need a DT_TEXTREL entry. */
9981 if ((info->flags & DF_TEXTREL) == 0)
9982 elf_link_hash_traverse (&htab->elf, maybe_set_textrel, info);
9983
9984 if ((info->flags & DF_TEXTREL) != 0)
9985 {
9986 if (!add_dynamic_entry (DT_TEXTREL, 0))
9987 return FALSE;
9988 }
9989 }
9990 }
9991 #undef add_dynamic_entry
9992
9993 return TRUE;
9994 }
9995
9996 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
9997
9998 static bfd_boolean
9999 ppc64_elf_hash_symbol (struct elf_link_hash_entry *h)
10000 {
10001 if (h->plt.plist != NULL
10002 && !h->def_regular
10003 && !h->pointer_equality_needed)
10004 return FALSE;
10005
10006 return _bfd_elf_hash_symbol (h);
10007 }
10008
10009 /* Determine the type of stub needed, if any, for a call. */
10010
10011 static inline enum ppc_stub_type
10012 ppc_type_of_stub (asection *input_sec,
10013 const Elf_Internal_Rela *rel,
10014 struct ppc_link_hash_entry **hash,
10015 struct plt_entry **plt_ent,
10016 bfd_vma destination,
10017 unsigned long local_off)
10018 {
10019 struct ppc_link_hash_entry *h = *hash;
10020 bfd_vma location;
10021 bfd_vma branch_offset;
10022 bfd_vma max_branch_offset;
10023 enum elf_ppc64_reloc_type r_type;
10024
10025 if (h != NULL)
10026 {
10027 struct plt_entry *ent;
10028 struct ppc_link_hash_entry *fdh = h;
10029 if (h->oh != NULL
10030 && h->oh->is_func_descriptor)
10031 {
10032 fdh = ppc_follow_link (h->oh);
10033 *hash = fdh;
10034 }
10035
10036 for (ent = fdh->elf.plt.plist; ent != NULL; ent = ent->next)
10037 if (ent->addend == rel->r_addend
10038 && ent->plt.offset != (bfd_vma) -1)
10039 {
10040 *plt_ent = ent;
10041 return ppc_stub_plt_call;
10042 }
10043
10044 /* Here, we know we don't have a plt entry. If we don't have a
10045 either a defined function descriptor or a defined entry symbol
10046 in a regular object file, then it is pointless trying to make
10047 any other type of stub. */
10048 if (!is_static_defined (&fdh->elf)
10049 && !is_static_defined (&h->elf))
10050 return ppc_stub_none;
10051 }
10052 else if (elf_local_got_ents (input_sec->owner) != NULL)
10053 {
10054 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (input_sec->owner);
10055 struct plt_entry **local_plt = (struct plt_entry **)
10056 elf_local_got_ents (input_sec->owner) + symtab_hdr->sh_info;
10057 unsigned long r_symndx = ELF64_R_SYM (rel->r_info);
10058
10059 if (local_plt[r_symndx] != NULL)
10060 {
10061 struct plt_entry *ent;
10062
10063 for (ent = local_plt[r_symndx]; ent != NULL; ent = ent->next)
10064 if (ent->addend == rel->r_addend
10065 && ent->plt.offset != (bfd_vma) -1)
10066 {
10067 *plt_ent = ent;
10068 return ppc_stub_plt_call;
10069 }
10070 }
10071 }
10072
10073 /* Determine where the call point is. */
10074 location = (input_sec->output_offset
10075 + input_sec->output_section->vma
10076 + rel->r_offset);
10077
10078 branch_offset = destination - location;
10079 r_type = ELF64_R_TYPE (rel->r_info);
10080
10081 /* Determine if a long branch stub is needed. */
10082 max_branch_offset = 1 << 25;
10083 if (r_type != R_PPC64_REL24)
10084 max_branch_offset = 1 << 15;
10085
10086 if (branch_offset + max_branch_offset >= 2 * max_branch_offset - local_off)
10087 /* We need a stub. Figure out whether a long_branch or plt_branch
10088 is needed later. */
10089 return ppc_stub_long_branch;
10090
10091 return ppc_stub_none;
10092 }
10093
10094 /* With power7 weakly ordered memory model, it is possible for ld.so
10095 to update a plt entry in one thread and have another thread see a
10096 stale zero toc entry. To avoid this we need some sort of acquire
10097 barrier in the call stub. One solution is to make the load of the
10098 toc word seem to appear to depend on the load of the function entry
10099 word. Another solution is to test for r2 being zero, and branch to
10100 the appropriate glink entry if so.
10101
10102 . fake dep barrier compare
10103 . ld 12,xxx(2) ld 12,xxx(2)
10104 . mtctr 12 mtctr 12
10105 . xor 11,12,12 ld 2,xxx+8(2)
10106 . add 2,2,11 cmpldi 2,0
10107 . ld 2,xxx+8(2) bnectr+
10108 . bctr b <glink_entry>
10109
10110 The solution involving the compare turns out to be faster, so
10111 that's what we use unless the branch won't reach. */
10112
10113 #define ALWAYS_USE_FAKE_DEP 0
10114 #define ALWAYS_EMIT_R2SAVE 0
10115
10116 #define PPC_LO(v) ((v) & 0xffff)
10117 #define PPC_HI(v) (((v) >> 16) & 0xffff)
10118 #define PPC_HA(v) PPC_HI ((v) + 0x8000)
10119
10120 static inline unsigned int
10121 plt_stub_size (struct ppc_link_hash_table *htab,
10122 struct ppc_stub_hash_entry *stub_entry,
10123 bfd_vma off)
10124 {
10125 unsigned size = 12;
10126
10127 if (ALWAYS_EMIT_R2SAVE
10128 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10129 size += 4;
10130 if (PPC_HA (off) != 0)
10131 size += 4;
10132 if (htab->opd_abi)
10133 {
10134 size += 4;
10135 if (htab->params->plt_static_chain)
10136 size += 4;
10137 if (htab->params->plt_thread_safe)
10138 size += 8;
10139 if (PPC_HA (off + 8 + 8 * htab->params->plt_static_chain) != PPC_HA (off))
10140 size += 4;
10141 }
10142 if (stub_entry->h != NULL
10143 && (stub_entry->h == htab->tls_get_addr_fd
10144 || stub_entry->h == htab->tls_get_addr)
10145 && !htab->params->no_tls_get_addr_opt)
10146 size += 13 * 4;
10147 return size;
10148 }
10149
10150 /* If this stub would cross fewer 2**plt_stub_align boundaries if we align,
10151 then return the padding needed to do so. */
10152 static inline unsigned int
10153 plt_stub_pad (struct ppc_link_hash_table *htab,
10154 struct ppc_stub_hash_entry *stub_entry,
10155 bfd_vma plt_off)
10156 {
10157 int stub_align = 1 << htab->params->plt_stub_align;
10158 unsigned stub_size = plt_stub_size (htab, stub_entry, plt_off);
10159 bfd_vma stub_off = stub_entry->stub_sec->size;
10160
10161 if (((stub_off + stub_size - 1) & -stub_align) - (stub_off & -stub_align)
10162 > (stub_size & -stub_align))
10163 return stub_align - (stub_off & (stub_align - 1));
10164 return 0;
10165 }
10166
10167 /* Build a .plt call stub. */
10168
10169 static inline bfd_byte *
10170 build_plt_stub (struct ppc_link_hash_table *htab,
10171 struct ppc_stub_hash_entry *stub_entry,
10172 bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
10173 {
10174 bfd *obfd = htab->params->stub_bfd;
10175 bfd_boolean plt_load_toc = htab->opd_abi;
10176 bfd_boolean plt_static_chain = htab->params->plt_static_chain;
10177 bfd_boolean plt_thread_safe = htab->params->plt_thread_safe;
10178 bfd_boolean use_fake_dep = plt_thread_safe;
10179 bfd_vma cmp_branch_off = 0;
10180
10181 if (!ALWAYS_USE_FAKE_DEP
10182 && plt_load_toc
10183 && plt_thread_safe
10184 && !(stub_entry->h != NULL
10185 && (stub_entry->h == htab->tls_get_addr_fd
10186 || stub_entry->h == htab->tls_get_addr)
10187 && !htab->params->no_tls_get_addr_opt))
10188 {
10189 bfd_vma pltoff = stub_entry->plt_ent->plt.offset & ~1;
10190 bfd_vma pltindex = ((pltoff - PLT_INITIAL_ENTRY_SIZE (htab))
10191 / PLT_ENTRY_SIZE (htab));
10192 bfd_vma glinkoff = GLINK_CALL_STUB_SIZE + pltindex * 8;
10193 bfd_vma to, from;
10194
10195 if (pltindex > 32768)
10196 glinkoff += (pltindex - 32768) * 4;
10197 to = (glinkoff
10198 + htab->glink->output_offset
10199 + htab->glink->output_section->vma);
10200 from = (p - stub_entry->stub_sec->contents
10201 + 4 * (ALWAYS_EMIT_R2SAVE
10202 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10203 + 4 * (PPC_HA (offset) != 0)
10204 + 4 * (PPC_HA (offset + 8 + 8 * plt_static_chain)
10205 != PPC_HA (offset))
10206 + 4 * (plt_static_chain != 0)
10207 + 20
10208 + stub_entry->stub_sec->output_offset
10209 + stub_entry->stub_sec->output_section->vma);
10210 cmp_branch_off = to - from;
10211 use_fake_dep = cmp_branch_off + (1 << 25) >= (1 << 26);
10212 }
10213
10214 if (PPC_HA (offset) != 0)
10215 {
10216 if (r != NULL)
10217 {
10218 if (ALWAYS_EMIT_R2SAVE
10219 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10220 r[0].r_offset += 4;
10221 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
10222 r[1].r_offset = r[0].r_offset + 4;
10223 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10224 r[1].r_addend = r[0].r_addend;
10225 if (plt_load_toc)
10226 {
10227 if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10228 {
10229 r[2].r_offset = r[1].r_offset + 4;
10230 r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO);
10231 r[2].r_addend = r[0].r_addend;
10232 }
10233 else
10234 {
10235 r[2].r_offset = r[1].r_offset + 8 + 8 * use_fake_dep;
10236 r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10237 r[2].r_addend = r[0].r_addend + 8;
10238 if (plt_static_chain)
10239 {
10240 r[3].r_offset = r[2].r_offset + 4;
10241 r[3].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10242 r[3].r_addend = r[0].r_addend + 16;
10243 }
10244 }
10245 }
10246 }
10247 if (ALWAYS_EMIT_R2SAVE
10248 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10249 bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p), p += 4;
10250 if (plt_load_toc)
10251 {
10252 bfd_put_32 (obfd, ADDIS_R11_R2 | PPC_HA (offset), p), p += 4;
10253 bfd_put_32 (obfd, LD_R12_0R11 | PPC_LO (offset), p), p += 4;
10254 }
10255 else
10256 {
10257 bfd_put_32 (obfd, ADDIS_R12_R2 | PPC_HA (offset), p), p += 4;
10258 bfd_put_32 (obfd, LD_R12_0R12 | PPC_LO (offset), p), p += 4;
10259 }
10260 if (plt_load_toc
10261 && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10262 {
10263 bfd_put_32 (obfd, ADDI_R11_R11 | PPC_LO (offset), p), p += 4;
10264 offset = 0;
10265 }
10266 bfd_put_32 (obfd, MTCTR_R12, p), p += 4;
10267 if (plt_load_toc)
10268 {
10269 if (use_fake_dep)
10270 {
10271 bfd_put_32 (obfd, XOR_R2_R12_R12, p), p += 4;
10272 bfd_put_32 (obfd, ADD_R11_R11_R2, p), p += 4;
10273 }
10274 bfd_put_32 (obfd, LD_R2_0R11 | PPC_LO (offset + 8), p), p += 4;
10275 if (plt_static_chain)
10276 bfd_put_32 (obfd, LD_R11_0R11 | PPC_LO (offset + 16), p), p += 4;
10277 }
10278 }
10279 else
10280 {
10281 if (r != NULL)
10282 {
10283 if (ALWAYS_EMIT_R2SAVE
10284 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10285 r[0].r_offset += 4;
10286 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10287 if (plt_load_toc)
10288 {
10289 if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10290 {
10291 r[1].r_offset = r[0].r_offset + 4;
10292 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16);
10293 r[1].r_addend = r[0].r_addend;
10294 }
10295 else
10296 {
10297 r[1].r_offset = r[0].r_offset + 8 + 8 * use_fake_dep;
10298 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10299 r[1].r_addend = r[0].r_addend + 8 + 8 * plt_static_chain;
10300 if (plt_static_chain)
10301 {
10302 r[2].r_offset = r[1].r_offset + 4;
10303 r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10304 r[2].r_addend = r[0].r_addend + 8;
10305 }
10306 }
10307 }
10308 }
10309 if (ALWAYS_EMIT_R2SAVE
10310 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10311 bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p), p += 4;
10312 bfd_put_32 (obfd, LD_R12_0R2 | PPC_LO (offset), p), p += 4;
10313 if (plt_load_toc
10314 && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10315 {
10316 bfd_put_32 (obfd, ADDI_R2_R2 | PPC_LO (offset), p), p += 4;
10317 offset = 0;
10318 }
10319 bfd_put_32 (obfd, MTCTR_R12, p), p += 4;
10320 if (plt_load_toc)
10321 {
10322 if (use_fake_dep)
10323 {
10324 bfd_put_32 (obfd, XOR_R11_R12_R12, p), p += 4;
10325 bfd_put_32 (obfd, ADD_R2_R2_R11, p), p += 4;
10326 }
10327 if (plt_static_chain)
10328 bfd_put_32 (obfd, LD_R11_0R2 | PPC_LO (offset + 16), p), p += 4;
10329 bfd_put_32 (obfd, LD_R2_0R2 | PPC_LO (offset + 8), p), p += 4;
10330 }
10331 }
10332 if (plt_load_toc && plt_thread_safe && !use_fake_dep)
10333 {
10334 bfd_put_32 (obfd, CMPLDI_R2_0, p), p += 4;
10335 bfd_put_32 (obfd, BNECTR_P4, p), p += 4;
10336 bfd_put_32 (obfd, B_DOT | (cmp_branch_off & 0x3fffffc), p), p += 4;
10337 }
10338 else
10339 bfd_put_32 (obfd, BCTR, p), p += 4;
10340 return p;
10341 }
10342
10343 /* Build a special .plt call stub for __tls_get_addr. */
10344
10345 #define LD_R11_0R3 0xe9630000
10346 #define LD_R12_0R3 0xe9830000
10347 #define MR_R0_R3 0x7c601b78
10348 #define CMPDI_R11_0 0x2c2b0000
10349 #define ADD_R3_R12_R13 0x7c6c6a14
10350 #define BEQLR 0x4d820020
10351 #define MR_R3_R0 0x7c030378
10352 #define STD_R11_0R1 0xf9610000
10353 #define BCTRL 0x4e800421
10354 #define LD_R11_0R1 0xe9610000
10355 #define MTLR_R11 0x7d6803a6
10356
10357 static inline bfd_byte *
10358 build_tls_get_addr_stub (struct ppc_link_hash_table *htab,
10359 struct ppc_stub_hash_entry *stub_entry,
10360 bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
10361 {
10362 bfd *obfd = htab->params->stub_bfd;
10363
10364 bfd_put_32 (obfd, LD_R11_0R3 + 0, p), p += 4;
10365 bfd_put_32 (obfd, LD_R12_0R3 + 8, p), p += 4;
10366 bfd_put_32 (obfd, MR_R0_R3, p), p += 4;
10367 bfd_put_32 (obfd, CMPDI_R11_0, p), p += 4;
10368 bfd_put_32 (obfd, ADD_R3_R12_R13, p), p += 4;
10369 bfd_put_32 (obfd, BEQLR, p), p += 4;
10370 bfd_put_32 (obfd, MR_R3_R0, p), p += 4;
10371 bfd_put_32 (obfd, MFLR_R11, p), p += 4;
10372 bfd_put_32 (obfd, STD_R11_0R1 + STK_LINKER (htab), p), p += 4;
10373
10374 if (r != NULL)
10375 r[0].r_offset += 9 * 4;
10376 p = build_plt_stub (htab, stub_entry, p, offset, r);
10377 bfd_put_32 (obfd, BCTRL, p - 4);
10378
10379 bfd_put_32 (obfd, LD_R11_0R1 + STK_LINKER (htab), p), p += 4;
10380 bfd_put_32 (obfd, LD_R2_0R1 + STK_TOC (htab), p), p += 4;
10381 bfd_put_32 (obfd, MTLR_R11, p), p += 4;
10382 bfd_put_32 (obfd, BLR, p), p += 4;
10383
10384 return p;
10385 }
10386
10387 static Elf_Internal_Rela *
10388 get_relocs (asection *sec, int count)
10389 {
10390 Elf_Internal_Rela *relocs;
10391 struct bfd_elf_section_data *elfsec_data;
10392
10393 elfsec_data = elf_section_data (sec);
10394 relocs = elfsec_data->relocs;
10395 if (relocs == NULL)
10396 {
10397 bfd_size_type relsize;
10398 relsize = sec->reloc_count * sizeof (*relocs);
10399 relocs = bfd_alloc (sec->owner, relsize);
10400 if (relocs == NULL)
10401 return NULL;
10402 elfsec_data->relocs = relocs;
10403 elfsec_data->rela.hdr = bfd_zalloc (sec->owner,
10404 sizeof (Elf_Internal_Shdr));
10405 if (elfsec_data->rela.hdr == NULL)
10406 return NULL;
10407 elfsec_data->rela.hdr->sh_size = (sec->reloc_count
10408 * sizeof (Elf64_External_Rela));
10409 elfsec_data->rela.hdr->sh_entsize = sizeof (Elf64_External_Rela);
10410 sec->reloc_count = 0;
10411 }
10412 relocs += sec->reloc_count;
10413 sec->reloc_count += count;
10414 return relocs;
10415 }
10416
10417 static bfd_vma
10418 get_r2off (struct bfd_link_info *info,
10419 struct ppc_stub_hash_entry *stub_entry)
10420 {
10421 struct ppc_link_hash_table *htab = ppc_hash_table (info);
10422 bfd_vma r2off = htab->stub_group[stub_entry->target_section->id].toc_off;
10423
10424 if (r2off == 0)
10425 {
10426 /* Support linking -R objects. Get the toc pointer from the
10427 opd entry. */
10428 char buf[8];
10429 if (!htab->opd_abi)
10430 return r2off;
10431 asection *opd = stub_entry->h->elf.root.u.def.section;
10432 bfd_vma opd_off = stub_entry->h->elf.root.u.def.value;
10433
10434 if (strcmp (opd->name, ".opd") != 0
10435 || opd->reloc_count != 0)
10436 {
10437 info->callbacks->einfo (_("%P: cannot find opd entry toc for `%T'\n"),
10438 stub_entry->h->elf.root.root.string);
10439 bfd_set_error (bfd_error_bad_value);
10440 return 0;
10441 }
10442 if (!bfd_get_section_contents (opd->owner, opd, buf, opd_off + 8, 8))
10443 return 0;
10444 r2off = bfd_get_64 (opd->owner, buf);
10445 r2off -= elf_gp (info->output_bfd);
10446 }
10447 r2off -= htab->stub_group[stub_entry->id_sec->id].toc_off;
10448 return r2off;
10449 }
10450
10451 static bfd_boolean
10452 ppc_build_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
10453 {
10454 struct ppc_stub_hash_entry *stub_entry;
10455 struct ppc_branch_hash_entry *br_entry;
10456 struct bfd_link_info *info;
10457 struct ppc_link_hash_table *htab;
10458 bfd_byte *loc;
10459 bfd_byte *p;
10460 bfd_vma dest, off;
10461 int size;
10462 Elf_Internal_Rela *r;
10463 asection *plt;
10464
10465 /* Massage our args to the form they really have. */
10466 stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
10467 info = in_arg;
10468
10469 htab = ppc_hash_table (info);
10470 if (htab == NULL)
10471 return FALSE;
10472
10473 /* Make a note of the offset within the stubs for this entry. */
10474 stub_entry->stub_offset = stub_entry->stub_sec->size;
10475 loc = stub_entry->stub_sec->contents + stub_entry->stub_offset;
10476
10477 htab->stub_count[stub_entry->stub_type - 1] += 1;
10478 switch (stub_entry->stub_type)
10479 {
10480 case ppc_stub_long_branch:
10481 case ppc_stub_long_branch_r2off:
10482 /* Branches are relative. This is where we are going to. */
10483 dest = (stub_entry->target_value
10484 + stub_entry->target_section->output_offset
10485 + stub_entry->target_section->output_section->vma);
10486 dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
10487 off = dest;
10488
10489 /* And this is where we are coming from. */
10490 off -= (stub_entry->stub_offset
10491 + stub_entry->stub_sec->output_offset
10492 + stub_entry->stub_sec->output_section->vma);
10493
10494 size = 4;
10495 if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
10496 {
10497 bfd_vma r2off = get_r2off (info, stub_entry);
10498
10499 if (r2off == 0)
10500 {
10501 htab->stub_error = TRUE;
10502 return FALSE;
10503 }
10504 bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), loc);
10505 loc += 4;
10506 size = 12;
10507 if (PPC_HA (r2off) != 0)
10508 {
10509 size = 16;
10510 bfd_put_32 (htab->params->stub_bfd,
10511 ADDIS_R2_R2 | PPC_HA (r2off), loc);
10512 loc += 4;
10513 }
10514 bfd_put_32 (htab->params->stub_bfd, ADDI_R2_R2 | PPC_LO (r2off), loc);
10515 loc += 4;
10516 off -= size - 4;
10517 }
10518 bfd_put_32 (htab->params->stub_bfd, B_DOT | (off & 0x3fffffc), loc);
10519
10520 if (off + (1 << 25) >= (bfd_vma) (1 << 26))
10521 {
10522 info->callbacks->einfo
10523 (_("%P: long branch stub `%s' offset overflow\n"),
10524 stub_entry->root.string);
10525 htab->stub_error = TRUE;
10526 return FALSE;
10527 }
10528
10529 if (info->emitrelocations)
10530 {
10531 r = get_relocs (stub_entry->stub_sec, 1);
10532 if (r == NULL)
10533 return FALSE;
10534 r->r_offset = loc - stub_entry->stub_sec->contents;
10535 r->r_info = ELF64_R_INFO (0, R_PPC64_REL24);
10536 r->r_addend = dest;
10537 if (stub_entry->h != NULL)
10538 {
10539 struct elf_link_hash_entry **hashes;
10540 unsigned long symndx;
10541 struct ppc_link_hash_entry *h;
10542
10543 hashes = elf_sym_hashes (htab->params->stub_bfd);
10544 if (hashes == NULL)
10545 {
10546 bfd_size_type hsize;
10547
10548 hsize = (htab->stub_globals + 1) * sizeof (*hashes);
10549 hashes = bfd_zalloc (htab->params->stub_bfd, hsize);
10550 if (hashes == NULL)
10551 return FALSE;
10552 elf_sym_hashes (htab->params->stub_bfd) = hashes;
10553 htab->stub_globals = 1;
10554 }
10555 symndx = htab->stub_globals++;
10556 h = stub_entry->h;
10557 hashes[symndx] = &h->elf;
10558 r->r_info = ELF64_R_INFO (symndx, R_PPC64_REL24);
10559 if (h->oh != NULL && h->oh->is_func)
10560 h = ppc_follow_link (h->oh);
10561 if (h->elf.root.u.def.section != stub_entry->target_section)
10562 /* H is an opd symbol. The addend must be zero. */
10563 r->r_addend = 0;
10564 else
10565 {
10566 off = (h->elf.root.u.def.value
10567 + h->elf.root.u.def.section->output_offset
10568 + h->elf.root.u.def.section->output_section->vma);
10569 r->r_addend -= off;
10570 }
10571 }
10572 }
10573 break;
10574
10575 case ppc_stub_plt_branch:
10576 case ppc_stub_plt_branch_r2off:
10577 br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
10578 stub_entry->root.string + 9,
10579 FALSE, FALSE);
10580 if (br_entry == NULL)
10581 {
10582 info->callbacks->einfo (_("%P: can't find branch stub `%s'\n"),
10583 stub_entry->root.string);
10584 htab->stub_error = TRUE;
10585 return FALSE;
10586 }
10587
10588 dest = (stub_entry->target_value
10589 + stub_entry->target_section->output_offset
10590 + stub_entry->target_section->output_section->vma);
10591 if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
10592 dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
10593
10594 bfd_put_64 (htab->brlt->owner, dest,
10595 htab->brlt->contents + br_entry->offset);
10596
10597 if (br_entry->iter == htab->stub_iteration)
10598 {
10599 br_entry->iter = 0;
10600
10601 if (htab->relbrlt != NULL)
10602 {
10603 /* Create a reloc for the branch lookup table entry. */
10604 Elf_Internal_Rela rela;
10605 bfd_byte *rl;
10606
10607 rela.r_offset = (br_entry->offset
10608 + htab->brlt->output_offset
10609 + htab->brlt->output_section->vma);
10610 rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
10611 rela.r_addend = dest;
10612
10613 rl = htab->relbrlt->contents;
10614 rl += (htab->relbrlt->reloc_count++
10615 * sizeof (Elf64_External_Rela));
10616 bfd_elf64_swap_reloca_out (htab->relbrlt->owner, &rela, rl);
10617 }
10618 else if (info->emitrelocations)
10619 {
10620 r = get_relocs (htab->brlt, 1);
10621 if (r == NULL)
10622 return FALSE;
10623 /* brlt, being SEC_LINKER_CREATED does not go through the
10624 normal reloc processing. Symbols and offsets are not
10625 translated from input file to output file form, so
10626 set up the offset per the output file. */
10627 r->r_offset = (br_entry->offset
10628 + htab->brlt->output_offset
10629 + htab->brlt->output_section->vma);
10630 r->r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
10631 r->r_addend = dest;
10632 }
10633 }
10634
10635 dest = (br_entry->offset
10636 + htab->brlt->output_offset
10637 + htab->brlt->output_section->vma);
10638
10639 off = (dest
10640 - elf_gp (htab->brlt->output_section->owner)
10641 - htab->stub_group[stub_entry->id_sec->id].toc_off);
10642
10643 if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
10644 {
10645 info->callbacks->einfo
10646 (_("%P: linkage table error against `%T'\n"),
10647 stub_entry->root.string);
10648 bfd_set_error (bfd_error_bad_value);
10649 htab->stub_error = TRUE;
10650 return FALSE;
10651 }
10652
10653 if (info->emitrelocations)
10654 {
10655 r = get_relocs (stub_entry->stub_sec, 1 + (PPC_HA (off) != 0));
10656 if (r == NULL)
10657 return FALSE;
10658 r[0].r_offset = loc - stub_entry->stub_sec->contents;
10659 if (bfd_big_endian (info->output_bfd))
10660 r[0].r_offset += 2;
10661 if (stub_entry->stub_type == ppc_stub_plt_branch_r2off)
10662 r[0].r_offset += 4;
10663 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10664 r[0].r_addend = dest;
10665 if (PPC_HA (off) != 0)
10666 {
10667 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
10668 r[1].r_offset = r[0].r_offset + 4;
10669 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10670 r[1].r_addend = r[0].r_addend;
10671 }
10672 }
10673
10674 if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
10675 {
10676 if (PPC_HA (off) != 0)
10677 {
10678 size = 16;
10679 bfd_put_32 (htab->params->stub_bfd,
10680 ADDIS_R12_R2 | PPC_HA (off), loc);
10681 loc += 4;
10682 bfd_put_32 (htab->params->stub_bfd,
10683 LD_R12_0R12 | PPC_LO (off), loc);
10684 }
10685 else
10686 {
10687 size = 12;
10688 bfd_put_32 (htab->params->stub_bfd,
10689 LD_R12_0R2 | PPC_LO (off), loc);
10690 }
10691 }
10692 else
10693 {
10694 bfd_vma r2off = get_r2off (info, stub_entry);
10695
10696 if (r2off == 0 && htab->opd_abi)
10697 {
10698 htab->stub_error = TRUE;
10699 return FALSE;
10700 }
10701
10702 bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), loc);
10703 loc += 4;
10704 size = 16;
10705 if (PPC_HA (off) != 0)
10706 {
10707 size += 4;
10708 bfd_put_32 (htab->params->stub_bfd,
10709 ADDIS_R12_R2 | PPC_HA (off), loc);
10710 loc += 4;
10711 bfd_put_32 (htab->params->stub_bfd,
10712 LD_R12_0R12 | PPC_LO (off), loc);
10713 }
10714 else
10715 bfd_put_32 (htab->params->stub_bfd, LD_R12_0R2 | PPC_LO (off), loc);
10716
10717 if (PPC_HA (r2off) != 0)
10718 {
10719 size += 4;
10720 loc += 4;
10721 bfd_put_32 (htab->params->stub_bfd,
10722 ADDIS_R2_R2 | PPC_HA (r2off), loc);
10723 }
10724 if (PPC_LO (r2off) != 0)
10725 {
10726 size += 4;
10727 loc += 4;
10728 bfd_put_32 (htab->params->stub_bfd,
10729 ADDI_R2_R2 | PPC_LO (r2off), loc);
10730 }
10731 }
10732 loc += 4;
10733 bfd_put_32 (htab->params->stub_bfd, MTCTR_R12, loc);
10734 loc += 4;
10735 bfd_put_32 (htab->params->stub_bfd, BCTR, loc);
10736 break;
10737
10738 case ppc_stub_plt_call:
10739 case ppc_stub_plt_call_r2save:
10740 if (stub_entry->h != NULL
10741 && stub_entry->h->is_func_descriptor
10742 && stub_entry->h->oh != NULL)
10743 {
10744 struct ppc_link_hash_entry *fh = ppc_follow_link (stub_entry->h->oh);
10745
10746 /* If the old-ABI "dot-symbol" is undefined make it weak so
10747 we don't get a link error from RELOC_FOR_GLOBAL_SYMBOL.
10748 FIXME: We used to define the symbol on one of the call
10749 stubs instead, which is why we test symbol section id
10750 against htab->top_id in various places. Likely all
10751 these checks could now disappear. */
10752 if (fh->elf.root.type == bfd_link_hash_undefined)
10753 fh->elf.root.type = bfd_link_hash_undefweak;
10754 /* Stop undo_symbol_twiddle changing it back to undefined. */
10755 fh->was_undefined = 0;
10756 }
10757
10758 /* Now build the stub. */
10759 dest = stub_entry->plt_ent->plt.offset & ~1;
10760 if (dest >= (bfd_vma) -2)
10761 abort ();
10762
10763 plt = htab->elf.splt;
10764 if (!htab->elf.dynamic_sections_created
10765 || stub_entry->h == NULL
10766 || stub_entry->h->elf.dynindx == -1)
10767 plt = htab->elf.iplt;
10768
10769 dest += plt->output_offset + plt->output_section->vma;
10770
10771 if (stub_entry->h == NULL
10772 && (stub_entry->plt_ent->plt.offset & 1) == 0)
10773 {
10774 Elf_Internal_Rela rela;
10775 bfd_byte *rl;
10776
10777 rela.r_offset = dest;
10778 if (htab->opd_abi)
10779 rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
10780 else
10781 rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
10782 rela.r_addend = (stub_entry->target_value
10783 + stub_entry->target_section->output_offset
10784 + stub_entry->target_section->output_section->vma);
10785
10786 rl = (htab->elf.irelplt->contents
10787 + (htab->elf.irelplt->reloc_count++
10788 * sizeof (Elf64_External_Rela)));
10789 bfd_elf64_swap_reloca_out (info->output_bfd, &rela, rl);
10790 stub_entry->plt_ent->plt.offset |= 1;
10791 }
10792
10793 off = (dest
10794 - elf_gp (plt->output_section->owner)
10795 - htab->stub_group[stub_entry->id_sec->id].toc_off);
10796
10797 if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
10798 {
10799 info->callbacks->einfo
10800 (_("%P: linkage table error against `%T'\n"),
10801 stub_entry->h != NULL
10802 ? stub_entry->h->elf.root.root.string
10803 : "<local sym>");
10804 bfd_set_error (bfd_error_bad_value);
10805 htab->stub_error = TRUE;
10806 return FALSE;
10807 }
10808
10809 if (htab->params->plt_stub_align != 0)
10810 {
10811 unsigned pad = plt_stub_pad (htab, stub_entry, off);
10812
10813 stub_entry->stub_sec->size += pad;
10814 stub_entry->stub_offset = stub_entry->stub_sec->size;
10815 loc += pad;
10816 }
10817
10818 r = NULL;
10819 if (info->emitrelocations)
10820 {
10821 r = get_relocs (stub_entry->stub_sec,
10822 ((PPC_HA (off) != 0)
10823 + (htab->opd_abi
10824 ? 2 + (htab->params->plt_static_chain
10825 && PPC_HA (off + 16) == PPC_HA (off))
10826 : 1)));
10827 if (r == NULL)
10828 return FALSE;
10829 r[0].r_offset = loc - stub_entry->stub_sec->contents;
10830 if (bfd_big_endian (info->output_bfd))
10831 r[0].r_offset += 2;
10832 r[0].r_addend = dest;
10833 }
10834 if (stub_entry->h != NULL
10835 && (stub_entry->h == htab->tls_get_addr_fd
10836 || stub_entry->h == htab->tls_get_addr)
10837 && !htab->params->no_tls_get_addr_opt)
10838 p = build_tls_get_addr_stub (htab, stub_entry, loc, off, r);
10839 else
10840 p = build_plt_stub (htab, stub_entry, loc, off, r);
10841 size = p - loc;
10842 break;
10843
10844 default:
10845 BFD_FAIL ();
10846 return FALSE;
10847 }
10848
10849 stub_entry->stub_sec->size += size;
10850
10851 if (htab->params->emit_stub_syms)
10852 {
10853 struct elf_link_hash_entry *h;
10854 size_t len1, len2;
10855 char *name;
10856 const char *const stub_str[] = { "long_branch",
10857 "long_branch_r2off",
10858 "plt_branch",
10859 "plt_branch_r2off",
10860 "plt_call",
10861 "plt_call" };
10862
10863 len1 = strlen (stub_str[stub_entry->stub_type - 1]);
10864 len2 = strlen (stub_entry->root.string);
10865 name = bfd_malloc (len1 + len2 + 2);
10866 if (name == NULL)
10867 return FALSE;
10868 memcpy (name, stub_entry->root.string, 9);
10869 memcpy (name + 9, stub_str[stub_entry->stub_type - 1], len1);
10870 memcpy (name + len1 + 9, stub_entry->root.string + 8, len2 - 8 + 1);
10871 h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
10872 if (h == NULL)
10873 return FALSE;
10874 if (h->root.type == bfd_link_hash_new)
10875 {
10876 h->root.type = bfd_link_hash_defined;
10877 h->root.u.def.section = stub_entry->stub_sec;
10878 h->root.u.def.value = stub_entry->stub_offset;
10879 h->ref_regular = 1;
10880 h->def_regular = 1;
10881 h->ref_regular_nonweak = 1;
10882 h->forced_local = 1;
10883 h->non_elf = 0;
10884 }
10885 }
10886
10887 return TRUE;
10888 }
10889
10890 /* As above, but don't actually build the stub. Just bump offset so
10891 we know stub section sizes, and select plt_branch stubs where
10892 long_branch stubs won't do. */
10893
10894 static bfd_boolean
10895 ppc_size_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
10896 {
10897 struct ppc_stub_hash_entry *stub_entry;
10898 struct bfd_link_info *info;
10899 struct ppc_link_hash_table *htab;
10900 bfd_vma off;
10901 int size;
10902
10903 /* Massage our args to the form they really have. */
10904 stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
10905 info = in_arg;
10906
10907 htab = ppc_hash_table (info);
10908 if (htab == NULL)
10909 return FALSE;
10910
10911 if (stub_entry->stub_type == ppc_stub_plt_call
10912 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10913 {
10914 asection *plt;
10915 off = stub_entry->plt_ent->plt.offset & ~(bfd_vma) 1;
10916 if (off >= (bfd_vma) -2)
10917 abort ();
10918 plt = htab->elf.splt;
10919 if (!htab->elf.dynamic_sections_created
10920 || stub_entry->h == NULL
10921 || stub_entry->h->elf.dynindx == -1)
10922 plt = htab->elf.iplt;
10923 off += (plt->output_offset
10924 + plt->output_section->vma
10925 - elf_gp (plt->output_section->owner)
10926 - htab->stub_group[stub_entry->id_sec->id].toc_off);
10927
10928 size = plt_stub_size (htab, stub_entry, off);
10929 if (htab->params->plt_stub_align)
10930 size += plt_stub_pad (htab, stub_entry, off);
10931 if (info->emitrelocations)
10932 {
10933 stub_entry->stub_sec->reloc_count
10934 += ((PPC_HA (off) != 0)
10935 + (htab->opd_abi
10936 ? 2 + (htab->params->plt_static_chain
10937 && PPC_HA (off + 16) == PPC_HA (off))
10938 : 1));
10939 stub_entry->stub_sec->flags |= SEC_RELOC;
10940 }
10941 }
10942 else
10943 {
10944 /* ppc_stub_long_branch or ppc_stub_plt_branch, or their r2off
10945 variants. */
10946 bfd_vma r2off = 0;
10947 bfd_vma local_off = 0;
10948
10949 off = (stub_entry->target_value
10950 + stub_entry->target_section->output_offset
10951 + stub_entry->target_section->output_section->vma);
10952 off -= (stub_entry->stub_sec->size
10953 + stub_entry->stub_sec->output_offset
10954 + stub_entry->stub_sec->output_section->vma);
10955
10956 /* Reset the stub type from the plt variant in case we now
10957 can reach with a shorter stub. */
10958 if (stub_entry->stub_type >= ppc_stub_plt_branch)
10959 stub_entry->stub_type += ppc_stub_long_branch - ppc_stub_plt_branch;
10960
10961 size = 4;
10962 if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
10963 {
10964 r2off = get_r2off (info, stub_entry);
10965 if (r2off == 0 && htab->opd_abi)
10966 {
10967 htab->stub_error = TRUE;
10968 return FALSE;
10969 }
10970 size = 12;
10971 if (PPC_HA (r2off) != 0)
10972 size = 16;
10973 off -= size - 4;
10974 }
10975
10976 local_off = PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
10977
10978 /* If the branch offset if too big, use a ppc_stub_plt_branch.
10979 Do the same for -R objects without function descriptors. */
10980 if (off + (1 << 25) >= (bfd_vma) (1 << 26) - local_off
10981 || (stub_entry->stub_type == ppc_stub_long_branch_r2off
10982 && r2off == 0))
10983 {
10984 struct ppc_branch_hash_entry *br_entry;
10985
10986 br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
10987 stub_entry->root.string + 9,
10988 TRUE, FALSE);
10989 if (br_entry == NULL)
10990 {
10991 info->callbacks->einfo (_("%P: can't build branch stub `%s'\n"),
10992 stub_entry->root.string);
10993 htab->stub_error = TRUE;
10994 return FALSE;
10995 }
10996
10997 if (br_entry->iter != htab->stub_iteration)
10998 {
10999 br_entry->iter = htab->stub_iteration;
11000 br_entry->offset = htab->brlt->size;
11001 htab->brlt->size += 8;
11002
11003 if (htab->relbrlt != NULL)
11004 htab->relbrlt->size += sizeof (Elf64_External_Rela);
11005 else if (info->emitrelocations)
11006 {
11007 htab->brlt->reloc_count += 1;
11008 htab->brlt->flags |= SEC_RELOC;
11009 }
11010 }
11011
11012 stub_entry->stub_type += ppc_stub_plt_branch - ppc_stub_long_branch;
11013 off = (br_entry->offset
11014 + htab->brlt->output_offset
11015 + htab->brlt->output_section->vma
11016 - elf_gp (htab->brlt->output_section->owner)
11017 - htab->stub_group[stub_entry->id_sec->id].toc_off);
11018
11019 if (info->emitrelocations)
11020 {
11021 stub_entry->stub_sec->reloc_count += 1 + (PPC_HA (off) != 0);
11022 stub_entry->stub_sec->flags |= SEC_RELOC;
11023 }
11024
11025 if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
11026 {
11027 size = 12;
11028 if (PPC_HA (off) != 0)
11029 size = 16;
11030 }
11031 else
11032 {
11033 size = 16;
11034 if (PPC_HA (off) != 0)
11035 size += 4;
11036
11037 if (PPC_HA (r2off) != 0)
11038 size += 4;
11039 if (PPC_LO (r2off) != 0)
11040 size += 4;
11041 }
11042 }
11043 else if (info->emitrelocations)
11044 {
11045 stub_entry->stub_sec->reloc_count += 1;
11046 stub_entry->stub_sec->flags |= SEC_RELOC;
11047 }
11048 }
11049
11050 stub_entry->stub_sec->size += size;
11051 return TRUE;
11052 }
11053
11054 /* Set up various things so that we can make a list of input sections
11055 for each output section included in the link. Returns -1 on error,
11056 0 when no stubs will be needed, and 1 on success. */
11057
11058 int
11059 ppc64_elf_setup_section_lists (struct bfd_link_info *info)
11060 {
11061 bfd *input_bfd;
11062 int top_id, top_index, id;
11063 asection *section;
11064 asection **input_list;
11065 bfd_size_type amt;
11066 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11067
11068 if (htab == NULL)
11069 return -1;
11070
11071 /* Find the top input section id. */
11072 for (input_bfd = info->input_bfds, top_id = 3;
11073 input_bfd != NULL;
11074 input_bfd = input_bfd->link.next)
11075 {
11076 for (section = input_bfd->sections;
11077 section != NULL;
11078 section = section->next)
11079 {
11080 if (top_id < section->id)
11081 top_id = section->id;
11082 }
11083 }
11084
11085 htab->top_id = top_id;
11086 amt = sizeof (struct map_stub) * (top_id + 1);
11087 htab->stub_group = bfd_zmalloc (amt);
11088 if (htab->stub_group == NULL)
11089 return -1;
11090
11091 /* Set toc_off for com, und, abs and ind sections. */
11092 for (id = 0; id < 3; id++)
11093 htab->stub_group[id].toc_off = TOC_BASE_OFF;
11094
11095 /* We can't use output_bfd->section_count here to find the top output
11096 section index as some sections may have been removed, and
11097 strip_excluded_output_sections doesn't renumber the indices. */
11098 for (section = info->output_bfd->sections, top_index = 0;
11099 section != NULL;
11100 section = section->next)
11101 {
11102 if (top_index < section->index)
11103 top_index = section->index;
11104 }
11105
11106 htab->top_index = top_index;
11107 amt = sizeof (asection *) * (top_index + 1);
11108 input_list = bfd_zmalloc (amt);
11109 htab->input_list = input_list;
11110 if (input_list == NULL)
11111 return -1;
11112
11113 return 1;
11114 }
11115
11116 /* Set up for first pass at multitoc partitioning. */
11117
11118 void
11119 ppc64_elf_start_multitoc_partition (struct bfd_link_info *info)
11120 {
11121 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11122
11123 htab->toc_curr = ppc64_elf_set_toc (info, info->output_bfd);
11124 htab->toc_bfd = NULL;
11125 htab->toc_first_sec = NULL;
11126 }
11127
11128 /* The linker repeatedly calls this function for each TOC input section
11129 and linker generated GOT section. Group input bfds such that the toc
11130 within a group is less than 64k in size. */
11131
11132 bfd_boolean
11133 ppc64_elf_next_toc_section (struct bfd_link_info *info, asection *isec)
11134 {
11135 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11136 bfd_vma addr, off, limit;
11137
11138 if (htab == NULL)
11139 return FALSE;
11140
11141 if (!htab->second_toc_pass)
11142 {
11143 /* Keep track of the first .toc or .got section for this input bfd. */
11144 bfd_boolean new_bfd = htab->toc_bfd != isec->owner;
11145
11146 if (new_bfd)
11147 {
11148 htab->toc_bfd = isec->owner;
11149 htab->toc_first_sec = isec;
11150 }
11151
11152 addr = isec->output_offset + isec->output_section->vma;
11153 off = addr - htab->toc_curr;
11154 limit = 0x80008000;
11155 if (ppc64_elf_tdata (isec->owner)->has_small_toc_reloc)
11156 limit = 0x10000;
11157 if (off + isec->size > limit)
11158 {
11159 addr = (htab->toc_first_sec->output_offset
11160 + htab->toc_first_sec->output_section->vma);
11161 htab->toc_curr = addr;
11162 }
11163
11164 /* toc_curr is the base address of this toc group. Set elf_gp
11165 for the input section to be the offset relative to the
11166 output toc base plus 0x8000. Making the input elf_gp an
11167 offset allows us to move the toc as a whole without
11168 recalculating input elf_gp. */
11169 off = htab->toc_curr - elf_gp (isec->output_section->owner);
11170 off += TOC_BASE_OFF;
11171
11172 /* Die if someone uses a linker script that doesn't keep input
11173 file .toc and .got together. */
11174 if (new_bfd
11175 && elf_gp (isec->owner) != 0
11176 && elf_gp (isec->owner) != off)
11177 return FALSE;
11178
11179 elf_gp (isec->owner) = off;
11180 return TRUE;
11181 }
11182
11183 /* During the second pass toc_first_sec points to the start of
11184 a toc group, and toc_curr is used to track the old elf_gp.
11185 We use toc_bfd to ensure we only look at each bfd once. */
11186 if (htab->toc_bfd == isec->owner)
11187 return TRUE;
11188 htab->toc_bfd = isec->owner;
11189
11190 if (htab->toc_first_sec == NULL
11191 || htab->toc_curr != elf_gp (isec->owner))
11192 {
11193 htab->toc_curr = elf_gp (isec->owner);
11194 htab->toc_first_sec = isec;
11195 }
11196 addr = (htab->toc_first_sec->output_offset
11197 + htab->toc_first_sec->output_section->vma);
11198 off = addr - elf_gp (isec->output_section->owner) + TOC_BASE_OFF;
11199 elf_gp (isec->owner) = off;
11200
11201 return TRUE;
11202 }
11203
11204 /* Called via elf_link_hash_traverse to merge GOT entries for global
11205 symbol H. */
11206
11207 static bfd_boolean
11208 merge_global_got (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
11209 {
11210 if (h->root.type == bfd_link_hash_indirect)
11211 return TRUE;
11212
11213 merge_got_entries (&h->got.glist);
11214
11215 return TRUE;
11216 }
11217
11218 /* Called via elf_link_hash_traverse to allocate GOT entries for global
11219 symbol H. */
11220
11221 static bfd_boolean
11222 reallocate_got (struct elf_link_hash_entry *h, void *inf)
11223 {
11224 struct got_entry *gent;
11225
11226 if (h->root.type == bfd_link_hash_indirect)
11227 return TRUE;
11228
11229 for (gent = h->got.glist; gent != NULL; gent = gent->next)
11230 if (!gent->is_indirect)
11231 allocate_got (h, (struct bfd_link_info *) inf, gent);
11232 return TRUE;
11233 }
11234
11235 /* Called on the first multitoc pass after the last call to
11236 ppc64_elf_next_toc_section. This function removes duplicate GOT
11237 entries. */
11238
11239 bfd_boolean
11240 ppc64_elf_layout_multitoc (struct bfd_link_info *info)
11241 {
11242 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11243 struct bfd *ibfd, *ibfd2;
11244 bfd_boolean done_something;
11245
11246 htab->multi_toc_needed = htab->toc_curr != elf_gp (info->output_bfd);
11247
11248 if (!htab->do_multi_toc)
11249 return FALSE;
11250
11251 /* Merge global sym got entries within a toc group. */
11252 elf_link_hash_traverse (&htab->elf, merge_global_got, info);
11253
11254 /* And tlsld_got. */
11255 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11256 {
11257 struct got_entry *ent, *ent2;
11258
11259 if (!is_ppc64_elf (ibfd))
11260 continue;
11261
11262 ent = ppc64_tlsld_got (ibfd);
11263 if (!ent->is_indirect
11264 && ent->got.offset != (bfd_vma) -1)
11265 {
11266 for (ibfd2 = ibfd->link.next; ibfd2 != NULL; ibfd2 = ibfd2->link.next)
11267 {
11268 if (!is_ppc64_elf (ibfd2))
11269 continue;
11270
11271 ent2 = ppc64_tlsld_got (ibfd2);
11272 if (!ent2->is_indirect
11273 && ent2->got.offset != (bfd_vma) -1
11274 && elf_gp (ibfd2) == elf_gp (ibfd))
11275 {
11276 ent2->is_indirect = TRUE;
11277 ent2->got.ent = ent;
11278 }
11279 }
11280 }
11281 }
11282
11283 /* Zap sizes of got sections. */
11284 htab->elf.irelplt->rawsize = htab->elf.irelplt->size;
11285 htab->elf.irelplt->size -= htab->got_reli_size;
11286 htab->got_reli_size = 0;
11287
11288 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11289 {
11290 asection *got, *relgot;
11291
11292 if (!is_ppc64_elf (ibfd))
11293 continue;
11294
11295 got = ppc64_elf_tdata (ibfd)->got;
11296 if (got != NULL)
11297 {
11298 got->rawsize = got->size;
11299 got->size = 0;
11300 relgot = ppc64_elf_tdata (ibfd)->relgot;
11301 relgot->rawsize = relgot->size;
11302 relgot->size = 0;
11303 }
11304 }
11305
11306 /* Now reallocate the got, local syms first. We don't need to
11307 allocate section contents again since we never increase size. */
11308 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11309 {
11310 struct got_entry **lgot_ents;
11311 struct got_entry **end_lgot_ents;
11312 struct plt_entry **local_plt;
11313 struct plt_entry **end_local_plt;
11314 unsigned char *lgot_masks;
11315 bfd_size_type locsymcount;
11316 Elf_Internal_Shdr *symtab_hdr;
11317 asection *s;
11318
11319 if (!is_ppc64_elf (ibfd))
11320 continue;
11321
11322 lgot_ents = elf_local_got_ents (ibfd);
11323 if (!lgot_ents)
11324 continue;
11325
11326 symtab_hdr = &elf_symtab_hdr (ibfd);
11327 locsymcount = symtab_hdr->sh_info;
11328 end_lgot_ents = lgot_ents + locsymcount;
11329 local_plt = (struct plt_entry **) end_lgot_ents;
11330 end_local_plt = local_plt + locsymcount;
11331 lgot_masks = (unsigned char *) end_local_plt;
11332 s = ppc64_elf_tdata (ibfd)->got;
11333 for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
11334 {
11335 struct got_entry *ent;
11336
11337 for (ent = *lgot_ents; ent != NULL; ent = ent->next)
11338 {
11339 unsigned int ent_size = 8;
11340 unsigned int rel_size = sizeof (Elf64_External_Rela);
11341
11342 ent->got.offset = s->size;
11343 if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
11344 {
11345 ent_size *= 2;
11346 rel_size *= 2;
11347 }
11348 s->size += ent_size;
11349 if ((*lgot_masks & PLT_IFUNC) != 0)
11350 {
11351 htab->elf.irelplt->size += rel_size;
11352 htab->got_reli_size += rel_size;
11353 }
11354 else if (info->shared)
11355 {
11356 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
11357 srel->size += rel_size;
11358 }
11359 }
11360 }
11361 }
11362
11363 elf_link_hash_traverse (&htab->elf, reallocate_got, info);
11364
11365 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11366 {
11367 struct got_entry *ent;
11368
11369 if (!is_ppc64_elf (ibfd))
11370 continue;
11371
11372 ent = ppc64_tlsld_got (ibfd);
11373 if (!ent->is_indirect
11374 && ent->got.offset != (bfd_vma) -1)
11375 {
11376 asection *s = ppc64_elf_tdata (ibfd)->got;
11377 ent->got.offset = s->size;
11378 s->size += 16;
11379 if (info->shared)
11380 {
11381 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
11382 srel->size += sizeof (Elf64_External_Rela);
11383 }
11384 }
11385 }
11386
11387 done_something = htab->elf.irelplt->rawsize != htab->elf.irelplt->size;
11388 if (!done_something)
11389 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11390 {
11391 asection *got;
11392
11393 if (!is_ppc64_elf (ibfd))
11394 continue;
11395
11396 got = ppc64_elf_tdata (ibfd)->got;
11397 if (got != NULL)
11398 {
11399 done_something = got->rawsize != got->size;
11400 if (done_something)
11401 break;
11402 }
11403 }
11404
11405 if (done_something)
11406 (*htab->params->layout_sections_again) ();
11407
11408 /* Set up for second pass over toc sections to recalculate elf_gp
11409 on input sections. */
11410 htab->toc_bfd = NULL;
11411 htab->toc_first_sec = NULL;
11412 htab->second_toc_pass = TRUE;
11413 return done_something;
11414 }
11415
11416 /* Called after second pass of multitoc partitioning. */
11417
11418 void
11419 ppc64_elf_finish_multitoc_partition (struct bfd_link_info *info)
11420 {
11421 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11422
11423 /* After the second pass, toc_curr tracks the TOC offset used
11424 for code sections below in ppc64_elf_next_input_section. */
11425 htab->toc_curr = TOC_BASE_OFF;
11426 }
11427
11428 /* No toc references were found in ISEC. If the code in ISEC makes no
11429 calls, then there's no need to use toc adjusting stubs when branching
11430 into ISEC. Actually, indirect calls from ISEC are OK as they will
11431 load r2. Returns -1 on error, 0 for no stub needed, 1 for stub
11432 needed, and 2 if a cyclical call-graph was found but no other reason
11433 for a stub was detected. If called from the top level, a return of
11434 2 means the same as a return of 0. */
11435
11436 static int
11437 toc_adjusting_stub_needed (struct bfd_link_info *info, asection *isec)
11438 {
11439 int ret;
11440
11441 /* Mark this section as checked. */
11442 isec->call_check_done = 1;
11443
11444 /* We know none of our code bearing sections will need toc stubs. */
11445 if ((isec->flags & SEC_LINKER_CREATED) != 0)
11446 return 0;
11447
11448 if (isec->size == 0)
11449 return 0;
11450
11451 if (isec->output_section == NULL)
11452 return 0;
11453
11454 ret = 0;
11455 if (isec->reloc_count != 0)
11456 {
11457 Elf_Internal_Rela *relstart, *rel;
11458 Elf_Internal_Sym *local_syms;
11459 struct ppc_link_hash_table *htab;
11460
11461 relstart = _bfd_elf_link_read_relocs (isec->owner, isec, NULL, NULL,
11462 info->keep_memory);
11463 if (relstart == NULL)
11464 return -1;
11465
11466 /* Look for branches to outside of this section. */
11467 local_syms = NULL;
11468 htab = ppc_hash_table (info);
11469 if (htab == NULL)
11470 return -1;
11471
11472 for (rel = relstart; rel < relstart + isec->reloc_count; ++rel)
11473 {
11474 enum elf_ppc64_reloc_type r_type;
11475 unsigned long r_symndx;
11476 struct elf_link_hash_entry *h;
11477 struct ppc_link_hash_entry *eh;
11478 Elf_Internal_Sym *sym;
11479 asection *sym_sec;
11480 struct _opd_sec_data *opd;
11481 bfd_vma sym_value;
11482 bfd_vma dest;
11483
11484 r_type = ELF64_R_TYPE (rel->r_info);
11485 if (r_type != R_PPC64_REL24
11486 && r_type != R_PPC64_REL14
11487 && r_type != R_PPC64_REL14_BRTAKEN
11488 && r_type != R_PPC64_REL14_BRNTAKEN)
11489 continue;
11490
11491 r_symndx = ELF64_R_SYM (rel->r_info);
11492 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms, r_symndx,
11493 isec->owner))
11494 {
11495 ret = -1;
11496 break;
11497 }
11498
11499 /* Calls to dynamic lib functions go through a plt call stub
11500 that uses r2. */
11501 eh = (struct ppc_link_hash_entry *) h;
11502 if (eh != NULL
11503 && (eh->elf.plt.plist != NULL
11504 || (eh->oh != NULL
11505 && ppc_follow_link (eh->oh)->elf.plt.plist != NULL)))
11506 {
11507 ret = 1;
11508 break;
11509 }
11510
11511 if (sym_sec == NULL)
11512 /* Ignore other undefined symbols. */
11513 continue;
11514
11515 /* Assume branches to other sections not included in the
11516 link need stubs too, to cover -R and absolute syms. */
11517 if (sym_sec->output_section == NULL)
11518 {
11519 ret = 1;
11520 break;
11521 }
11522
11523 if (h == NULL)
11524 sym_value = sym->st_value;
11525 else
11526 {
11527 if (h->root.type != bfd_link_hash_defined
11528 && h->root.type != bfd_link_hash_defweak)
11529 abort ();
11530 sym_value = h->root.u.def.value;
11531 }
11532 sym_value += rel->r_addend;
11533
11534 /* If this branch reloc uses an opd sym, find the code section. */
11535 opd = get_opd_info (sym_sec);
11536 if (opd != NULL)
11537 {
11538 if (h == NULL && opd->adjust != NULL)
11539 {
11540 long adjust;
11541
11542 adjust = opd->adjust[sym->st_value / 8];
11543 if (adjust == -1)
11544 /* Assume deleted functions won't ever be called. */
11545 continue;
11546 sym_value += adjust;
11547 }
11548
11549 dest = opd_entry_value (sym_sec, sym_value,
11550 &sym_sec, NULL, FALSE);
11551 if (dest == (bfd_vma) -1)
11552 continue;
11553 }
11554 else
11555 dest = (sym_value
11556 + sym_sec->output_offset
11557 + sym_sec->output_section->vma);
11558
11559 /* Ignore branch to self. */
11560 if (sym_sec == isec)
11561 continue;
11562
11563 /* If the called function uses the toc, we need a stub. */
11564 if (sym_sec->has_toc_reloc
11565 || sym_sec->makes_toc_func_call)
11566 {
11567 ret = 1;
11568 break;
11569 }
11570
11571 /* Assume any branch that needs a long branch stub might in fact
11572 need a plt_branch stub. A plt_branch stub uses r2. */
11573 else if (dest - (isec->output_offset
11574 + isec->output_section->vma
11575 + rel->r_offset) + (1 << 25)
11576 >= (2u << 25) - PPC64_LOCAL_ENTRY_OFFSET (h
11577 ? h->other
11578 : sym->st_other))
11579 {
11580 ret = 1;
11581 break;
11582 }
11583
11584 /* If calling back to a section in the process of being
11585 tested, we can't say for sure that no toc adjusting stubs
11586 are needed, so don't return zero. */
11587 else if (sym_sec->call_check_in_progress)
11588 ret = 2;
11589
11590 /* Branches to another section that itself doesn't have any TOC
11591 references are OK. Recursively call ourselves to check. */
11592 else if (!sym_sec->call_check_done)
11593 {
11594 int recur;
11595
11596 /* Mark current section as indeterminate, so that other
11597 sections that call back to current won't be marked as
11598 known. */
11599 isec->call_check_in_progress = 1;
11600 recur = toc_adjusting_stub_needed (info, sym_sec);
11601 isec->call_check_in_progress = 0;
11602
11603 if (recur != 0)
11604 {
11605 ret = recur;
11606 if (recur != 2)
11607 break;
11608 }
11609 }
11610 }
11611
11612 if (local_syms != NULL
11613 && (elf_symtab_hdr (isec->owner).contents
11614 != (unsigned char *) local_syms))
11615 free (local_syms);
11616 if (elf_section_data (isec)->relocs != relstart)
11617 free (relstart);
11618 }
11619
11620 if ((ret & 1) == 0
11621 && isec->map_head.s != NULL
11622 && (strcmp (isec->output_section->name, ".init") == 0
11623 || strcmp (isec->output_section->name, ".fini") == 0))
11624 {
11625 if (isec->map_head.s->has_toc_reloc
11626 || isec->map_head.s->makes_toc_func_call)
11627 ret = 1;
11628 else if (!isec->map_head.s->call_check_done)
11629 {
11630 int recur;
11631 isec->call_check_in_progress = 1;
11632 recur = toc_adjusting_stub_needed (info, isec->map_head.s);
11633 isec->call_check_in_progress = 0;
11634 if (recur != 0)
11635 ret = recur;
11636 }
11637 }
11638
11639 if (ret == 1)
11640 isec->makes_toc_func_call = 1;
11641
11642 return ret;
11643 }
11644
11645 /* The linker repeatedly calls this function for each input section,
11646 in the order that input sections are linked into output sections.
11647 Build lists of input sections to determine groupings between which
11648 we may insert linker stubs. */
11649
11650 bfd_boolean
11651 ppc64_elf_next_input_section (struct bfd_link_info *info, asection *isec)
11652 {
11653 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11654
11655 if (htab == NULL)
11656 return FALSE;
11657
11658 if ((isec->output_section->flags & SEC_CODE) != 0
11659 && isec->output_section->index <= htab->top_index)
11660 {
11661 asection **list = htab->input_list + isec->output_section->index;
11662 /* Steal the link_sec pointer for our list. */
11663 #define PREV_SEC(sec) (htab->stub_group[(sec)->id].link_sec)
11664 /* This happens to make the list in reverse order,
11665 which is what we want. */
11666 PREV_SEC (isec) = *list;
11667 *list = isec;
11668 }
11669
11670 if (htab->multi_toc_needed)
11671 {
11672 /* Analyse sections that aren't already flagged as needing a
11673 valid toc pointer. Exclude .fixup for the linux kernel.
11674 .fixup contains branches, but only back to the function that
11675 hit an exception. */
11676 if (!(isec->has_toc_reloc
11677 || (isec->flags & SEC_CODE) == 0
11678 || strcmp (isec->name, ".fixup") == 0
11679 || isec->call_check_done))
11680 {
11681 if (toc_adjusting_stub_needed (info, isec) < 0)
11682 return FALSE;
11683 }
11684 /* Make all sections use the TOC assigned for this object file.
11685 This will be wrong for pasted sections; We fix that in
11686 check_pasted_section(). */
11687 if (elf_gp (isec->owner) != 0)
11688 htab->toc_curr = elf_gp (isec->owner);
11689 }
11690
11691 htab->stub_group[isec->id].toc_off = htab->toc_curr;
11692 return TRUE;
11693 }
11694
11695 /* Check that all .init and .fini sections use the same toc, if they
11696 have toc relocs. */
11697
11698 static bfd_boolean
11699 check_pasted_section (struct bfd_link_info *info, const char *name)
11700 {
11701 asection *o = bfd_get_section_by_name (info->output_bfd, name);
11702
11703 if (o != NULL)
11704 {
11705 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11706 bfd_vma toc_off = 0;
11707 asection *i;
11708
11709 for (i = o->map_head.s; i != NULL; i = i->map_head.s)
11710 if (i->has_toc_reloc)
11711 {
11712 if (toc_off == 0)
11713 toc_off = htab->stub_group[i->id].toc_off;
11714 else if (toc_off != htab->stub_group[i->id].toc_off)
11715 return FALSE;
11716 }
11717
11718 if (toc_off == 0)
11719 for (i = o->map_head.s; i != NULL; i = i->map_head.s)
11720 if (i->makes_toc_func_call)
11721 {
11722 toc_off = htab->stub_group[i->id].toc_off;
11723 break;
11724 }
11725
11726 /* Make sure the whole pasted function uses the same toc offset. */
11727 if (toc_off != 0)
11728 for (i = o->map_head.s; i != NULL; i = i->map_head.s)
11729 htab->stub_group[i->id].toc_off = toc_off;
11730 }
11731 return TRUE;
11732 }
11733
11734 bfd_boolean
11735 ppc64_elf_check_init_fini (struct bfd_link_info *info)
11736 {
11737 return (check_pasted_section (info, ".init")
11738 & check_pasted_section (info, ".fini"));
11739 }
11740
11741 /* See whether we can group stub sections together. Grouping stub
11742 sections may result in fewer stubs. More importantly, we need to
11743 put all .init* and .fini* stubs at the beginning of the .init or
11744 .fini output sections respectively, because glibc splits the
11745 _init and _fini functions into multiple parts. Putting a stub in
11746 the middle of a function is not a good idea. */
11747
11748 static void
11749 group_sections (struct ppc_link_hash_table *htab,
11750 bfd_size_type stub_group_size,
11751 bfd_boolean stubs_always_before_branch)
11752 {
11753 asection **list;
11754 bfd_size_type stub14_group_size;
11755 bfd_boolean suppress_size_errors;
11756
11757 suppress_size_errors = FALSE;
11758 stub14_group_size = stub_group_size;
11759 if (stub_group_size == 1)
11760 {
11761 /* Default values. */
11762 if (stubs_always_before_branch)
11763 {
11764 stub_group_size = 0x1e00000;
11765 stub14_group_size = 0x7800;
11766 }
11767 else
11768 {
11769 stub_group_size = 0x1c00000;
11770 stub14_group_size = 0x7000;
11771 }
11772 suppress_size_errors = TRUE;
11773 }
11774
11775 list = htab->input_list + htab->top_index;
11776 do
11777 {
11778 asection *tail = *list;
11779 while (tail != NULL)
11780 {
11781 asection *curr;
11782 asection *prev;
11783 bfd_size_type total;
11784 bfd_boolean big_sec;
11785 bfd_vma curr_toc;
11786
11787 curr = tail;
11788 total = tail->size;
11789 big_sec = total > (ppc64_elf_section_data (tail) != NULL
11790 && ppc64_elf_section_data (tail)->has_14bit_branch
11791 ? stub14_group_size : stub_group_size);
11792 if (big_sec && !suppress_size_errors)
11793 (*_bfd_error_handler) (_("%B section %A exceeds stub group size"),
11794 tail->owner, tail);
11795 curr_toc = htab->stub_group[tail->id].toc_off;
11796
11797 while ((prev = PREV_SEC (curr)) != NULL
11798 && ((total += curr->output_offset - prev->output_offset)
11799 < (ppc64_elf_section_data (prev) != NULL
11800 && ppc64_elf_section_data (prev)->has_14bit_branch
11801 ? stub14_group_size : stub_group_size))
11802 && htab->stub_group[prev->id].toc_off == curr_toc)
11803 curr = prev;
11804
11805 /* OK, the size from the start of CURR to the end is less
11806 than stub_group_size and thus can be handled by one stub
11807 section. (or the tail section is itself larger than
11808 stub_group_size, in which case we may be toast.) We
11809 should really be keeping track of the total size of stubs
11810 added here, as stubs contribute to the final output
11811 section size. That's a little tricky, and this way will
11812 only break if stubs added make the total size more than
11813 2^25, ie. for the default stub_group_size, if stubs total
11814 more than 2097152 bytes, or nearly 75000 plt call stubs. */
11815 do
11816 {
11817 prev = PREV_SEC (tail);
11818 /* Set up this stub group. */
11819 htab->stub_group[tail->id].link_sec = curr;
11820 }
11821 while (tail != curr && (tail = prev) != NULL);
11822
11823 /* But wait, there's more! Input sections up to stub_group_size
11824 bytes before the stub section can be handled by it too.
11825 Don't do this if we have a really large section after the
11826 stubs, as adding more stubs increases the chance that
11827 branches may not reach into the stub section. */
11828 if (!stubs_always_before_branch && !big_sec)
11829 {
11830 total = 0;
11831 while (prev != NULL
11832 && ((total += tail->output_offset - prev->output_offset)
11833 < (ppc64_elf_section_data (prev) != NULL
11834 && ppc64_elf_section_data (prev)->has_14bit_branch
11835 ? stub14_group_size : stub_group_size))
11836 && htab->stub_group[prev->id].toc_off == curr_toc)
11837 {
11838 tail = prev;
11839 prev = PREV_SEC (tail);
11840 htab->stub_group[tail->id].link_sec = curr;
11841 }
11842 }
11843 tail = prev;
11844 }
11845 }
11846 while (list-- != htab->input_list);
11847 free (htab->input_list);
11848 #undef PREV_SEC
11849 }
11850
11851 static const unsigned char glink_eh_frame_cie[] =
11852 {
11853 0, 0, 0, 16, /* length. */
11854 0, 0, 0, 0, /* id. */
11855 1, /* CIE version. */
11856 'z', 'R', 0, /* Augmentation string. */
11857 4, /* Code alignment. */
11858 0x78, /* Data alignment. */
11859 65, /* RA reg. */
11860 1, /* Augmentation size. */
11861 DW_EH_PE_pcrel | DW_EH_PE_sdata4, /* FDE encoding. */
11862 DW_CFA_def_cfa, 1, 0 /* def_cfa: r1 offset 0. */
11863 };
11864
11865 /* Stripping output sections is normally done before dynamic section
11866 symbols have been allocated. This function is called later, and
11867 handles cases like htab->brlt which is mapped to its own output
11868 section. */
11869
11870 static void
11871 maybe_strip_output (struct bfd_link_info *info, asection *isec)
11872 {
11873 if (isec->size == 0
11874 && isec->output_section->size == 0
11875 && !(isec->output_section->flags & SEC_KEEP)
11876 && !bfd_section_removed_from_list (info->output_bfd,
11877 isec->output_section)
11878 && elf_section_data (isec->output_section)->dynindx == 0)
11879 {
11880 isec->output_section->flags |= SEC_EXCLUDE;
11881 bfd_section_list_remove (info->output_bfd, isec->output_section);
11882 info->output_bfd->section_count--;
11883 }
11884 }
11885
11886 /* Determine and set the size of the stub section for a final link.
11887
11888 The basic idea here is to examine all the relocations looking for
11889 PC-relative calls to a target that is unreachable with a "bl"
11890 instruction. */
11891
11892 bfd_boolean
11893 ppc64_elf_size_stubs (struct bfd_link_info *info)
11894 {
11895 bfd_size_type stub_group_size;
11896 bfd_boolean stubs_always_before_branch;
11897 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11898
11899 if (htab == NULL)
11900 return FALSE;
11901
11902 if (htab->params->plt_thread_safe == -1 && !info->executable)
11903 htab->params->plt_thread_safe = 1;
11904 if (!htab->opd_abi)
11905 htab->params->plt_thread_safe = 0;
11906 else if (htab->params->plt_thread_safe == -1)
11907 {
11908 static const char *const thread_starter[] =
11909 {
11910 "pthread_create",
11911 /* libstdc++ */
11912 "_ZNSt6thread15_M_start_threadESt10shared_ptrINS_10_Impl_baseEE",
11913 /* librt */
11914 "aio_init", "aio_read", "aio_write", "aio_fsync", "lio_listio",
11915 "mq_notify", "create_timer",
11916 /* libanl */
11917 "getaddrinfo_a",
11918 /* libgomp */
11919 "GOMP_parallel_start",
11920 "GOMP_parallel_loop_static_start",
11921 "GOMP_parallel_loop_dynamic_start",
11922 "GOMP_parallel_loop_guided_start",
11923 "GOMP_parallel_loop_runtime_start",
11924 "GOMP_parallel_sections_start",
11925 };
11926 unsigned i;
11927
11928 for (i = 0; i < sizeof (thread_starter)/ sizeof (thread_starter[0]); i++)
11929 {
11930 struct elf_link_hash_entry *h;
11931 h = elf_link_hash_lookup (&htab->elf, thread_starter[i],
11932 FALSE, FALSE, TRUE);
11933 htab->params->plt_thread_safe = h != NULL && h->ref_regular;
11934 if (htab->params->plt_thread_safe)
11935 break;
11936 }
11937 }
11938 stubs_always_before_branch = htab->params->group_size < 0;
11939 if (htab->params->group_size < 0)
11940 stub_group_size = -htab->params->group_size;
11941 else
11942 stub_group_size = htab->params->group_size;
11943
11944 group_sections (htab, stub_group_size, stubs_always_before_branch);
11945
11946 while (1)
11947 {
11948 bfd *input_bfd;
11949 unsigned int bfd_indx;
11950 asection *stub_sec;
11951
11952 htab->stub_iteration += 1;
11953
11954 for (input_bfd = info->input_bfds, bfd_indx = 0;
11955 input_bfd != NULL;
11956 input_bfd = input_bfd->link.next, bfd_indx++)
11957 {
11958 Elf_Internal_Shdr *symtab_hdr;
11959 asection *section;
11960 Elf_Internal_Sym *local_syms = NULL;
11961
11962 if (!is_ppc64_elf (input_bfd))
11963 continue;
11964
11965 /* We'll need the symbol table in a second. */
11966 symtab_hdr = &elf_symtab_hdr (input_bfd);
11967 if (symtab_hdr->sh_info == 0)
11968 continue;
11969
11970 /* Walk over each section attached to the input bfd. */
11971 for (section = input_bfd->sections;
11972 section != NULL;
11973 section = section->next)
11974 {
11975 Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
11976
11977 /* If there aren't any relocs, then there's nothing more
11978 to do. */
11979 if ((section->flags & SEC_RELOC) == 0
11980 || (section->flags & SEC_ALLOC) == 0
11981 || (section->flags & SEC_LOAD) == 0
11982 || (section->flags & SEC_CODE) == 0
11983 || section->reloc_count == 0)
11984 continue;
11985
11986 /* If this section is a link-once section that will be
11987 discarded, then don't create any stubs. */
11988 if (section->output_section == NULL
11989 || section->output_section->owner != info->output_bfd)
11990 continue;
11991
11992 /* Get the relocs. */
11993 internal_relocs
11994 = _bfd_elf_link_read_relocs (input_bfd, section, NULL, NULL,
11995 info->keep_memory);
11996 if (internal_relocs == NULL)
11997 goto error_ret_free_local;
11998
11999 /* Now examine each relocation. */
12000 irela = internal_relocs;
12001 irelaend = irela + section->reloc_count;
12002 for (; irela < irelaend; irela++)
12003 {
12004 enum elf_ppc64_reloc_type r_type;
12005 unsigned int r_indx;
12006 enum ppc_stub_type stub_type;
12007 struct ppc_stub_hash_entry *stub_entry;
12008 asection *sym_sec, *code_sec;
12009 bfd_vma sym_value, code_value;
12010 bfd_vma destination;
12011 unsigned long local_off;
12012 bfd_boolean ok_dest;
12013 struct ppc_link_hash_entry *hash;
12014 struct ppc_link_hash_entry *fdh;
12015 struct elf_link_hash_entry *h;
12016 Elf_Internal_Sym *sym;
12017 char *stub_name;
12018 const asection *id_sec;
12019 struct _opd_sec_data *opd;
12020 struct plt_entry *plt_ent;
12021
12022 r_type = ELF64_R_TYPE (irela->r_info);
12023 r_indx = ELF64_R_SYM (irela->r_info);
12024
12025 if (r_type >= R_PPC64_max)
12026 {
12027 bfd_set_error (bfd_error_bad_value);
12028 goto error_ret_free_internal;
12029 }
12030
12031 /* Only look for stubs on branch instructions. */
12032 if (r_type != R_PPC64_REL24
12033 && r_type != R_PPC64_REL14
12034 && r_type != R_PPC64_REL14_BRTAKEN
12035 && r_type != R_PPC64_REL14_BRNTAKEN)
12036 continue;
12037
12038 /* Now determine the call target, its name, value,
12039 section. */
12040 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
12041 r_indx, input_bfd))
12042 goto error_ret_free_internal;
12043 hash = (struct ppc_link_hash_entry *) h;
12044
12045 ok_dest = FALSE;
12046 fdh = NULL;
12047 sym_value = 0;
12048 if (hash == NULL)
12049 {
12050 sym_value = sym->st_value;
12051 ok_dest = TRUE;
12052 }
12053 else if (hash->elf.root.type == bfd_link_hash_defined
12054 || hash->elf.root.type == bfd_link_hash_defweak)
12055 {
12056 sym_value = hash->elf.root.u.def.value;
12057 if (sym_sec->output_section != NULL)
12058 ok_dest = TRUE;
12059 }
12060 else if (hash->elf.root.type == bfd_link_hash_undefweak
12061 || hash->elf.root.type == bfd_link_hash_undefined)
12062 {
12063 /* Recognise an old ABI func code entry sym, and
12064 use the func descriptor sym instead if it is
12065 defined. */
12066 if (hash->elf.root.root.string[0] == '.'
12067 && (fdh = lookup_fdh (hash, htab)) != NULL)
12068 {
12069 if (fdh->elf.root.type == bfd_link_hash_defined
12070 || fdh->elf.root.type == bfd_link_hash_defweak)
12071 {
12072 sym_sec = fdh->elf.root.u.def.section;
12073 sym_value = fdh->elf.root.u.def.value;
12074 if (sym_sec->output_section != NULL)
12075 ok_dest = TRUE;
12076 }
12077 else
12078 fdh = NULL;
12079 }
12080 }
12081 else
12082 {
12083 bfd_set_error (bfd_error_bad_value);
12084 goto error_ret_free_internal;
12085 }
12086
12087 destination = 0;
12088 local_off = 0;
12089 if (ok_dest)
12090 {
12091 sym_value += irela->r_addend;
12092 destination = (sym_value
12093 + sym_sec->output_offset
12094 + sym_sec->output_section->vma);
12095 local_off = PPC64_LOCAL_ENTRY_OFFSET (hash
12096 ? hash->elf.other
12097 : sym->st_other);
12098 }
12099
12100 code_sec = sym_sec;
12101 code_value = sym_value;
12102 opd = get_opd_info (sym_sec);
12103 if (opd != NULL)
12104 {
12105 bfd_vma dest;
12106
12107 if (hash == NULL && opd->adjust != NULL)
12108 {
12109 long adjust = opd->adjust[sym_value / 8];
12110 if (adjust == -1)
12111 continue;
12112 code_value += adjust;
12113 sym_value += adjust;
12114 }
12115 dest = opd_entry_value (sym_sec, sym_value,
12116 &code_sec, &code_value, FALSE);
12117 if (dest != (bfd_vma) -1)
12118 {
12119 destination = dest;
12120 if (fdh != NULL)
12121 {
12122 /* Fixup old ABI sym to point at code
12123 entry. */
12124 hash->elf.root.type = bfd_link_hash_defweak;
12125 hash->elf.root.u.def.section = code_sec;
12126 hash->elf.root.u.def.value = code_value;
12127 }
12128 }
12129 }
12130
12131 /* Determine what (if any) linker stub is needed. */
12132 plt_ent = NULL;
12133 stub_type = ppc_type_of_stub (section, irela, &hash,
12134 &plt_ent, destination,
12135 local_off);
12136
12137 if (stub_type != ppc_stub_plt_call)
12138 {
12139 /* Check whether we need a TOC adjusting stub.
12140 Since the linker pastes together pieces from
12141 different object files when creating the
12142 _init and _fini functions, it may be that a
12143 call to what looks like a local sym is in
12144 fact a call needing a TOC adjustment. */
12145 if (code_sec != NULL
12146 && code_sec->output_section != NULL
12147 && (htab->stub_group[code_sec->id].toc_off
12148 != htab->stub_group[section->id].toc_off)
12149 && (code_sec->has_toc_reloc
12150 || code_sec->makes_toc_func_call))
12151 stub_type = ppc_stub_long_branch_r2off;
12152 }
12153
12154 if (stub_type == ppc_stub_none)
12155 continue;
12156
12157 /* __tls_get_addr calls might be eliminated. */
12158 if (stub_type != ppc_stub_plt_call
12159 && hash != NULL
12160 && (hash == htab->tls_get_addr
12161 || hash == htab->tls_get_addr_fd)
12162 && section->has_tls_reloc
12163 && irela != internal_relocs)
12164 {
12165 /* Get tls info. */
12166 unsigned char *tls_mask;
12167
12168 if (!get_tls_mask (&tls_mask, NULL, NULL, &local_syms,
12169 irela - 1, input_bfd))
12170 goto error_ret_free_internal;
12171 if (*tls_mask != 0)
12172 continue;
12173 }
12174
12175 if (stub_type == ppc_stub_plt_call
12176 && irela + 1 < irelaend
12177 && irela[1].r_offset == irela->r_offset + 4
12178 && ELF64_R_TYPE (irela[1].r_info) == R_PPC64_TOCSAVE)
12179 {
12180 if (!tocsave_find (htab, INSERT,
12181 &local_syms, irela + 1, input_bfd))
12182 goto error_ret_free_internal;
12183 }
12184 else if (stub_type == ppc_stub_plt_call)
12185 stub_type = ppc_stub_plt_call_r2save;
12186
12187 /* Support for grouping stub sections. */
12188 id_sec = htab->stub_group[section->id].link_sec;
12189
12190 /* Get the name of this stub. */
12191 stub_name = ppc_stub_name (id_sec, sym_sec, hash, irela);
12192 if (!stub_name)
12193 goto error_ret_free_internal;
12194
12195 stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
12196 stub_name, FALSE, FALSE);
12197 if (stub_entry != NULL)
12198 {
12199 /* The proper stub has already been created. */
12200 free (stub_name);
12201 if (stub_type == ppc_stub_plt_call_r2save)
12202 stub_entry->stub_type = stub_type;
12203 continue;
12204 }
12205
12206 stub_entry = ppc_add_stub (stub_name, section, info);
12207 if (stub_entry == NULL)
12208 {
12209 free (stub_name);
12210 error_ret_free_internal:
12211 if (elf_section_data (section)->relocs == NULL)
12212 free (internal_relocs);
12213 error_ret_free_local:
12214 if (local_syms != NULL
12215 && (symtab_hdr->contents
12216 != (unsigned char *) local_syms))
12217 free (local_syms);
12218 return FALSE;
12219 }
12220
12221 stub_entry->stub_type = stub_type;
12222 if (stub_type != ppc_stub_plt_call
12223 && stub_type != ppc_stub_plt_call_r2save)
12224 {
12225 stub_entry->target_value = code_value;
12226 stub_entry->target_section = code_sec;
12227 }
12228 else
12229 {
12230 stub_entry->target_value = sym_value;
12231 stub_entry->target_section = sym_sec;
12232 }
12233 stub_entry->h = hash;
12234 stub_entry->plt_ent = plt_ent;
12235 stub_entry->other = hash ? hash->elf.other : sym->st_other;
12236
12237 if (stub_entry->h != NULL)
12238 htab->stub_globals += 1;
12239 }
12240
12241 /* We're done with the internal relocs, free them. */
12242 if (elf_section_data (section)->relocs != internal_relocs)
12243 free (internal_relocs);
12244 }
12245
12246 if (local_syms != NULL
12247 && symtab_hdr->contents != (unsigned char *) local_syms)
12248 {
12249 if (!info->keep_memory)
12250 free (local_syms);
12251 else
12252 symtab_hdr->contents = (unsigned char *) local_syms;
12253 }
12254 }
12255
12256 /* We may have added some stubs. Find out the new size of the
12257 stub sections. */
12258 for (stub_sec = htab->params->stub_bfd->sections;
12259 stub_sec != NULL;
12260 stub_sec = stub_sec->next)
12261 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12262 {
12263 stub_sec->rawsize = stub_sec->size;
12264 stub_sec->size = 0;
12265 stub_sec->reloc_count = 0;
12266 stub_sec->flags &= ~SEC_RELOC;
12267 }
12268
12269 htab->brlt->size = 0;
12270 htab->brlt->reloc_count = 0;
12271 htab->brlt->flags &= ~SEC_RELOC;
12272 if (htab->relbrlt != NULL)
12273 htab->relbrlt->size = 0;
12274
12275 bfd_hash_traverse (&htab->stub_hash_table, ppc_size_one_stub, info);
12276
12277 if (info->emitrelocations
12278 && htab->glink != NULL && htab->glink->size != 0)
12279 {
12280 htab->glink->reloc_count = 1;
12281 htab->glink->flags |= SEC_RELOC;
12282 }
12283
12284 if (htab->glink_eh_frame != NULL
12285 && !bfd_is_abs_section (htab->glink_eh_frame->output_section)
12286 && htab->glink_eh_frame->output_section->size != 0)
12287 {
12288 size_t size = 0, align;
12289
12290 for (stub_sec = htab->params->stub_bfd->sections;
12291 stub_sec != NULL;
12292 stub_sec = stub_sec->next)
12293 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12294 size += 20;
12295 if (htab->glink != NULL && htab->glink->size != 0)
12296 size += 24;
12297 if (size != 0)
12298 size += sizeof (glink_eh_frame_cie);
12299 align = 1;
12300 align <<= htab->glink_eh_frame->output_section->alignment_power;
12301 align -= 1;
12302 size = (size + align) & ~align;
12303 htab->glink_eh_frame->rawsize = htab->glink_eh_frame->size;
12304 htab->glink_eh_frame->size = size;
12305 }
12306
12307 if (htab->params->plt_stub_align != 0)
12308 for (stub_sec = htab->params->stub_bfd->sections;
12309 stub_sec != NULL;
12310 stub_sec = stub_sec->next)
12311 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12312 stub_sec->size = ((stub_sec->size
12313 + (1 << htab->params->plt_stub_align) - 1)
12314 & (-1 << htab->params->plt_stub_align));
12315
12316 for (stub_sec = htab->params->stub_bfd->sections;
12317 stub_sec != NULL;
12318 stub_sec = stub_sec->next)
12319 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
12320 && stub_sec->rawsize != stub_sec->size)
12321 break;
12322
12323 /* Exit from this loop when no stubs have been added, and no stubs
12324 have changed size. */
12325 if (stub_sec == NULL
12326 && (htab->glink_eh_frame == NULL
12327 || htab->glink_eh_frame->rawsize == htab->glink_eh_frame->size))
12328 break;
12329
12330 /* Ask the linker to do its stuff. */
12331 (*htab->params->layout_sections_again) ();
12332 }
12333
12334 maybe_strip_output (info, htab->brlt);
12335 if (htab->glink_eh_frame != NULL)
12336 maybe_strip_output (info, htab->glink_eh_frame);
12337
12338 return TRUE;
12339 }
12340
12341 /* Called after we have determined section placement. If sections
12342 move, we'll be called again. Provide a value for TOCstart. */
12343
12344 bfd_vma
12345 ppc64_elf_set_toc (struct bfd_link_info *info, bfd *obfd)
12346 {
12347 asection *s;
12348 bfd_vma TOCstart;
12349
12350 /* The TOC consists of sections .got, .toc, .tocbss, .plt in that
12351 order. The TOC starts where the first of these sections starts. */
12352 s = bfd_get_section_by_name (obfd, ".got");
12353 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12354 s = bfd_get_section_by_name (obfd, ".toc");
12355 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12356 s = bfd_get_section_by_name (obfd, ".tocbss");
12357 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12358 s = bfd_get_section_by_name (obfd, ".plt");
12359 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12360 {
12361 /* This may happen for
12362 o references to TOC base (SYM@toc / TOC[tc0]) without a
12363 .toc directive
12364 o bad linker script
12365 o --gc-sections and empty TOC sections
12366
12367 FIXME: Warn user? */
12368
12369 /* Look for a likely section. We probably won't even be
12370 using TOCstart. */
12371 for (s = obfd->sections; s != NULL; s = s->next)
12372 if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_READONLY
12373 | SEC_EXCLUDE))
12374 == (SEC_ALLOC | SEC_SMALL_DATA))
12375 break;
12376 if (s == NULL)
12377 for (s = obfd->sections; s != NULL; s = s->next)
12378 if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_EXCLUDE))
12379 == (SEC_ALLOC | SEC_SMALL_DATA))
12380 break;
12381 if (s == NULL)
12382 for (s = obfd->sections; s != NULL; s = s->next)
12383 if ((s->flags & (SEC_ALLOC | SEC_READONLY | SEC_EXCLUDE))
12384 == SEC_ALLOC)
12385 break;
12386 if (s == NULL)
12387 for (s = obfd->sections; s != NULL; s = s->next)
12388 if ((s->flags & (SEC_ALLOC | SEC_EXCLUDE)) == SEC_ALLOC)
12389 break;
12390 }
12391
12392 TOCstart = 0;
12393 if (s != NULL)
12394 TOCstart = s->output_section->vma + s->output_offset;
12395
12396 _bfd_set_gp_value (obfd, TOCstart);
12397
12398 if (info != NULL && s != NULL && is_ppc64_elf (obfd))
12399 {
12400 struct ppc_link_hash_table *htab = ppc_hash_table (info);
12401
12402 if (htab != NULL
12403 && htab->elf.hgot != NULL)
12404 {
12405 htab->elf.hgot->root.u.def.value = TOC_BASE_OFF;
12406 htab->elf.hgot->root.u.def.section = s;
12407 }
12408 }
12409 return TOCstart;
12410 }
12411
12412 /* Called via elf_link_hash_traverse from ppc64_elf_build_stubs to
12413 write out any global entry stubs. */
12414
12415 static bfd_boolean
12416 build_global_entry_stubs (struct elf_link_hash_entry *h, void *inf)
12417 {
12418 struct bfd_link_info *info;
12419 struct ppc_link_hash_table *htab;
12420 struct plt_entry *pent;
12421 asection *s;
12422
12423 if (h->root.type == bfd_link_hash_indirect)
12424 return TRUE;
12425
12426 if (!h->pointer_equality_needed)
12427 return TRUE;
12428
12429 if (h->def_regular)
12430 return TRUE;
12431
12432 info = inf;
12433 htab = ppc_hash_table (info);
12434 if (htab == NULL)
12435 return FALSE;
12436
12437 s = htab->glink;
12438 for (pent = h->plt.plist; pent != NULL; pent = pent->next)
12439 if (pent->plt.offset != (bfd_vma) -1
12440 && pent->addend == 0)
12441 {
12442 bfd_byte *p;
12443 asection *plt;
12444 bfd_vma off;
12445
12446 p = s->contents + h->root.u.def.value;
12447 plt = htab->elf.splt;
12448 if (!htab->elf.dynamic_sections_created
12449 || h->dynindx == -1)
12450 plt = htab->elf.iplt;
12451 off = pent->plt.offset + plt->output_offset + plt->output_section->vma;
12452 off -= h->root.u.def.value + s->output_offset + s->output_section->vma;
12453
12454 if (off + 0x80008000 > 0xffffffff || (off & 3) != 0)
12455 {
12456 info->callbacks->einfo
12457 (_("%P: linkage table error against `%T'\n"),
12458 h->root.root.string);
12459 bfd_set_error (bfd_error_bad_value);
12460 htab->stub_error = TRUE;
12461 }
12462
12463 if (PPC_HA (off) != 0)
12464 {
12465 bfd_put_32 (s->owner, ADDIS_R12_R12 | PPC_HA (off), p);
12466 p += 4;
12467 }
12468 bfd_put_32 (s->owner, LD_R12_0R12 | PPC_LO (off), p);
12469 p += 4;
12470 bfd_put_32 (s->owner, MTCTR_R12, p);
12471 p += 4;
12472 bfd_put_32 (s->owner, BCTR, p);
12473 break;
12474 }
12475 return TRUE;
12476 }
12477
12478 /* Build all the stubs associated with the current output file.
12479 The stubs are kept in a hash table attached to the main linker
12480 hash table. This function is called via gldelf64ppc_finish. */
12481
12482 bfd_boolean
12483 ppc64_elf_build_stubs (struct bfd_link_info *info,
12484 char **stats)
12485 {
12486 struct ppc_link_hash_table *htab = ppc_hash_table (info);
12487 asection *stub_sec;
12488 bfd_byte *p;
12489 int stub_sec_count = 0;
12490
12491 if (htab == NULL)
12492 return FALSE;
12493
12494 /* Allocate memory to hold the linker stubs. */
12495 for (stub_sec = htab->params->stub_bfd->sections;
12496 stub_sec != NULL;
12497 stub_sec = stub_sec->next)
12498 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
12499 && stub_sec->size != 0)
12500 {
12501 stub_sec->contents = bfd_zalloc (htab->params->stub_bfd, stub_sec->size);
12502 if (stub_sec->contents == NULL)
12503 return FALSE;
12504 /* We want to check that built size is the same as calculated
12505 size. rawsize is a convenient location to use. */
12506 stub_sec->rawsize = stub_sec->size;
12507 stub_sec->size = 0;
12508 }
12509
12510 if (htab->glink != NULL && htab->glink->size != 0)
12511 {
12512 unsigned int indx;
12513 bfd_vma plt0;
12514
12515 /* Build the .glink plt call stub. */
12516 if (htab->params->emit_stub_syms)
12517 {
12518 struct elf_link_hash_entry *h;
12519 h = elf_link_hash_lookup (&htab->elf, "__glink_PLTresolve",
12520 TRUE, FALSE, FALSE);
12521 if (h == NULL)
12522 return FALSE;
12523 if (h->root.type == bfd_link_hash_new)
12524 {
12525 h->root.type = bfd_link_hash_defined;
12526 h->root.u.def.section = htab->glink;
12527 h->root.u.def.value = 8;
12528 h->ref_regular = 1;
12529 h->def_regular = 1;
12530 h->ref_regular_nonweak = 1;
12531 h->forced_local = 1;
12532 h->non_elf = 0;
12533 }
12534 }
12535 plt0 = (htab->elf.splt->output_section->vma
12536 + htab->elf.splt->output_offset
12537 - 16);
12538 if (info->emitrelocations)
12539 {
12540 Elf_Internal_Rela *r = get_relocs (htab->glink, 1);
12541 if (r == NULL)
12542 return FALSE;
12543 r->r_offset = (htab->glink->output_offset
12544 + htab->glink->output_section->vma);
12545 r->r_info = ELF64_R_INFO (0, R_PPC64_REL64);
12546 r->r_addend = plt0;
12547 }
12548 p = htab->glink->contents;
12549 plt0 -= htab->glink->output_section->vma + htab->glink->output_offset;
12550 bfd_put_64 (htab->glink->owner, plt0, p);
12551 p += 8;
12552 if (htab->opd_abi)
12553 {
12554 bfd_put_32 (htab->glink->owner, MFLR_R12, p);
12555 p += 4;
12556 bfd_put_32 (htab->glink->owner, BCL_20_31, p);
12557 p += 4;
12558 bfd_put_32 (htab->glink->owner, MFLR_R11, p);
12559 p += 4;
12560 bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
12561 p += 4;
12562 bfd_put_32 (htab->glink->owner, MTLR_R12, p);
12563 p += 4;
12564 bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
12565 p += 4;
12566 bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
12567 p += 4;
12568 bfd_put_32 (htab->glink->owner, LD_R2_0R11 | 8, p);
12569 p += 4;
12570 bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
12571 p += 4;
12572 bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 16, p);
12573 p += 4;
12574 }
12575 else
12576 {
12577 bfd_put_32 (htab->glink->owner, MFLR_R0, p);
12578 p += 4;
12579 bfd_put_32 (htab->glink->owner, BCL_20_31, p);
12580 p += 4;
12581 bfd_put_32 (htab->glink->owner, MFLR_R11, p);
12582 p += 4;
12583 bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
12584 p += 4;
12585 bfd_put_32 (htab->glink->owner, MTLR_R0, p);
12586 p += 4;
12587 bfd_put_32 (htab->glink->owner, SUB_R12_R12_R11, p);
12588 p += 4;
12589 bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
12590 p += 4;
12591 bfd_put_32 (htab->glink->owner, ADDI_R0_R12 | (-48 & 0xffff), p);
12592 p += 4;
12593 bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
12594 p += 4;
12595 bfd_put_32 (htab->glink->owner, SRDI_R0_R0_2, p);
12596 p += 4;
12597 bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
12598 p += 4;
12599 bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 8, p);
12600 p += 4;
12601 }
12602 bfd_put_32 (htab->glink->owner, BCTR, p);
12603 p += 4;
12604 while (p - htab->glink->contents < GLINK_CALL_STUB_SIZE)
12605 {
12606 bfd_put_32 (htab->glink->owner, NOP, p);
12607 p += 4;
12608 }
12609
12610 /* Build the .glink lazy link call stubs. */
12611 indx = 0;
12612 while (p < htab->glink->contents + htab->glink->rawsize)
12613 {
12614 if (htab->opd_abi)
12615 {
12616 if (indx < 0x8000)
12617 {
12618 bfd_put_32 (htab->glink->owner, LI_R0_0 | indx, p);
12619 p += 4;
12620 }
12621 else
12622 {
12623 bfd_put_32 (htab->glink->owner, LIS_R0_0 | PPC_HI (indx), p);
12624 p += 4;
12625 bfd_put_32 (htab->glink->owner, ORI_R0_R0_0 | PPC_LO (indx),
12626 p);
12627 p += 4;
12628 }
12629 }
12630 bfd_put_32 (htab->glink->owner,
12631 B_DOT | ((htab->glink->contents - p + 8) & 0x3fffffc), p);
12632 indx++;
12633 p += 4;
12634 }
12635
12636 /* Build .glink global entry stubs. */
12637 if (htab->glink->size > htab->glink->rawsize)
12638 elf_link_hash_traverse (&htab->elf, build_global_entry_stubs, info);
12639 }
12640
12641 if (htab->brlt->size != 0)
12642 {
12643 htab->brlt->contents = bfd_zalloc (htab->brlt->owner,
12644 htab->brlt->size);
12645 if (htab->brlt->contents == NULL)
12646 return FALSE;
12647 }
12648 if (htab->relbrlt != NULL && htab->relbrlt->size != 0)
12649 {
12650 htab->relbrlt->contents = bfd_zalloc (htab->relbrlt->owner,
12651 htab->relbrlt->size);
12652 if (htab->relbrlt->contents == NULL)
12653 return FALSE;
12654 }
12655
12656 if (htab->glink_eh_frame != NULL
12657 && htab->glink_eh_frame->size != 0)
12658 {
12659 bfd_vma val;
12660 bfd_byte *last_fde;
12661 size_t last_fde_len, size, align, pad;
12662
12663 p = bfd_zalloc (htab->glink_eh_frame->owner, htab->glink_eh_frame->size);
12664 if (p == NULL)
12665 return FALSE;
12666 htab->glink_eh_frame->contents = p;
12667 last_fde = p;
12668
12669 htab->glink_eh_frame->rawsize = htab->glink_eh_frame->size;
12670
12671 memcpy (p, glink_eh_frame_cie, sizeof (glink_eh_frame_cie));
12672 /* CIE length (rewrite in case little-endian). */
12673 last_fde_len = sizeof (glink_eh_frame_cie) - 4;
12674 bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
12675 p += sizeof (glink_eh_frame_cie);
12676
12677 for (stub_sec = htab->params->stub_bfd->sections;
12678 stub_sec != NULL;
12679 stub_sec = stub_sec->next)
12680 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12681 {
12682 last_fde = p;
12683 last_fde_len = 16;
12684 /* FDE length. */
12685 bfd_put_32 (htab->elf.dynobj, 16, p);
12686 p += 4;
12687 /* CIE pointer. */
12688 val = p - htab->glink_eh_frame->contents;
12689 bfd_put_32 (htab->elf.dynobj, val, p);
12690 p += 4;
12691 /* Offset to stub section. */
12692 val = (stub_sec->output_section->vma
12693 + stub_sec->output_offset);
12694 val -= (htab->glink_eh_frame->output_section->vma
12695 + htab->glink_eh_frame->output_offset);
12696 val -= p - htab->glink_eh_frame->contents;
12697 if (val + 0x80000000 > 0xffffffff)
12698 {
12699 info->callbacks->einfo
12700 (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
12701 stub_sec->name);
12702 return FALSE;
12703 }
12704 bfd_put_32 (htab->elf.dynobj, val, p);
12705 p += 4;
12706 /* stub section size. */
12707 bfd_put_32 (htab->elf.dynobj, stub_sec->rawsize, p);
12708 p += 4;
12709 /* Augmentation. */
12710 p += 1;
12711 /* Pad. */
12712 p += 3;
12713 }
12714 if (htab->glink != NULL && htab->glink->size != 0)
12715 {
12716 last_fde = p;
12717 last_fde_len = 20;
12718 /* FDE length. */
12719 bfd_put_32 (htab->elf.dynobj, 20, p);
12720 p += 4;
12721 /* CIE pointer. */
12722 val = p - htab->glink_eh_frame->contents;
12723 bfd_put_32 (htab->elf.dynobj, val, p);
12724 p += 4;
12725 /* Offset to .glink. */
12726 val = (htab->glink->output_section->vma
12727 + htab->glink->output_offset
12728 + 8);
12729 val -= (htab->glink_eh_frame->output_section->vma
12730 + htab->glink_eh_frame->output_offset);
12731 val -= p - htab->glink_eh_frame->contents;
12732 if (val + 0x80000000 > 0xffffffff)
12733 {
12734 info->callbacks->einfo
12735 (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
12736 htab->glink->name);
12737 return FALSE;
12738 }
12739 bfd_put_32 (htab->elf.dynobj, val, p);
12740 p += 4;
12741 /* .glink size. */
12742 bfd_put_32 (htab->elf.dynobj, htab->glink->size - 8, p);
12743 p += 4;
12744 /* Augmentation. */
12745 p += 1;
12746
12747 *p++ = DW_CFA_advance_loc + 1;
12748 *p++ = DW_CFA_register;
12749 *p++ = 65;
12750 *p++ = 12;
12751 *p++ = DW_CFA_advance_loc + 4;
12752 *p++ = DW_CFA_restore_extended;
12753 *p++ = 65;
12754 }
12755 /* Subsume any padding into the last FDE if user .eh_frame
12756 sections are aligned more than glink_eh_frame. Otherwise any
12757 zero padding will be seen as a terminator. */
12758 size = p - htab->glink_eh_frame->contents;
12759 align = 1;
12760 align <<= htab->glink_eh_frame->output_section->alignment_power;
12761 align -= 1;
12762 pad = ((size + align) & ~align) - size;
12763 htab->glink_eh_frame->size = size + pad;
12764 bfd_put_32 (htab->elf.dynobj, last_fde_len + pad, last_fde);
12765 }
12766
12767 /* Build the stubs as directed by the stub hash table. */
12768 bfd_hash_traverse (&htab->stub_hash_table, ppc_build_one_stub, info);
12769
12770 if (htab->relbrlt != NULL)
12771 htab->relbrlt->reloc_count = 0;
12772
12773 if (htab->params->plt_stub_align != 0)
12774 for (stub_sec = htab->params->stub_bfd->sections;
12775 stub_sec != NULL;
12776 stub_sec = stub_sec->next)
12777 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12778 stub_sec->size = ((stub_sec->size
12779 + (1 << htab->params->plt_stub_align) - 1)
12780 & (-1 << htab->params->plt_stub_align));
12781
12782 for (stub_sec = htab->params->stub_bfd->sections;
12783 stub_sec != NULL;
12784 stub_sec = stub_sec->next)
12785 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12786 {
12787 stub_sec_count += 1;
12788 if (stub_sec->rawsize != stub_sec->size)
12789 break;
12790 }
12791
12792 if (stub_sec != NULL
12793 || (htab->glink_eh_frame != NULL
12794 && htab->glink_eh_frame->rawsize != htab->glink_eh_frame->size))
12795 {
12796 htab->stub_error = TRUE;
12797 info->callbacks->einfo (_("%P: stubs don't match calculated size\n"));
12798 }
12799
12800 if (htab->stub_error)
12801 return FALSE;
12802
12803 if (stats != NULL)
12804 {
12805 *stats = bfd_malloc (500);
12806 if (*stats == NULL)
12807 return FALSE;
12808
12809 sprintf (*stats, _("linker stubs in %u group%s\n"
12810 " branch %lu\n"
12811 " toc adjust %lu\n"
12812 " long branch %lu\n"
12813 " long toc adj %lu\n"
12814 " plt call %lu\n"
12815 " plt call toc %lu"),
12816 stub_sec_count,
12817 stub_sec_count == 1 ? "" : "s",
12818 htab->stub_count[ppc_stub_long_branch - 1],
12819 htab->stub_count[ppc_stub_long_branch_r2off - 1],
12820 htab->stub_count[ppc_stub_plt_branch - 1],
12821 htab->stub_count[ppc_stub_plt_branch_r2off - 1],
12822 htab->stub_count[ppc_stub_plt_call - 1],
12823 htab->stub_count[ppc_stub_plt_call_r2save - 1]);
12824 }
12825 return TRUE;
12826 }
12827
12828 /* This function undoes the changes made by add_symbol_adjust. */
12829
12830 static bfd_boolean
12831 undo_symbol_twiddle (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
12832 {
12833 struct ppc_link_hash_entry *eh;
12834
12835 if (h->root.type == bfd_link_hash_indirect)
12836 return TRUE;
12837
12838 eh = (struct ppc_link_hash_entry *) h;
12839 if (eh->elf.root.type != bfd_link_hash_undefweak || !eh->was_undefined)
12840 return TRUE;
12841
12842 eh->elf.root.type = bfd_link_hash_undefined;
12843 return TRUE;
12844 }
12845
12846 void
12847 ppc64_elf_restore_symbols (struct bfd_link_info *info)
12848 {
12849 struct ppc_link_hash_table *htab = ppc_hash_table (info);
12850
12851 if (htab != NULL)
12852 elf_link_hash_traverse (&htab->elf, undo_symbol_twiddle, info);
12853 }
12854
12855 /* What to do when ld finds relocations against symbols defined in
12856 discarded sections. */
12857
12858 static unsigned int
12859 ppc64_elf_action_discarded (asection *sec)
12860 {
12861 if (strcmp (".opd", sec->name) == 0)
12862 return 0;
12863
12864 if (strcmp (".toc", sec->name) == 0)
12865 return 0;
12866
12867 if (strcmp (".toc1", sec->name) == 0)
12868 return 0;
12869
12870 return _bfd_elf_default_action_discarded (sec);
12871 }
12872
12873 /* The RELOCATE_SECTION function is called by the ELF backend linker
12874 to handle the relocations for a section.
12875
12876 The relocs are always passed as Rela structures; if the section
12877 actually uses Rel structures, the r_addend field will always be
12878 zero.
12879
12880 This function is responsible for adjust the section contents as
12881 necessary, and (if using Rela relocs and generating a
12882 relocatable output file) adjusting the reloc addend as
12883 necessary.
12884
12885 This function does not have to worry about setting the reloc
12886 address or the reloc symbol index.
12887
12888 LOCAL_SYMS is a pointer to the swapped in local symbols.
12889
12890 LOCAL_SECTIONS is an array giving the section in the input file
12891 corresponding to the st_shndx field of each local symbol.
12892
12893 The global hash table entry for the global symbols can be found
12894 via elf_sym_hashes (input_bfd).
12895
12896 When generating relocatable output, this function must handle
12897 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
12898 going to be the section symbol corresponding to the output
12899 section, which means that the addend must be adjusted
12900 accordingly. */
12901
12902 static bfd_boolean
12903 ppc64_elf_relocate_section (bfd *output_bfd,
12904 struct bfd_link_info *info,
12905 bfd *input_bfd,
12906 asection *input_section,
12907 bfd_byte *contents,
12908 Elf_Internal_Rela *relocs,
12909 Elf_Internal_Sym *local_syms,
12910 asection **local_sections)
12911 {
12912 struct ppc_link_hash_table *htab;
12913 Elf_Internal_Shdr *symtab_hdr;
12914 struct elf_link_hash_entry **sym_hashes;
12915 Elf_Internal_Rela *rel;
12916 Elf_Internal_Rela *relend;
12917 Elf_Internal_Rela outrel;
12918 bfd_byte *loc;
12919 struct got_entry **local_got_ents;
12920 bfd_vma TOCstart;
12921 bfd_boolean ret = TRUE;
12922 bfd_boolean is_opd;
12923 /* Assume 'at' branch hints. */
12924 bfd_boolean is_isa_v2 = TRUE;
12925 bfd_vma d_offset = (bfd_big_endian (output_bfd) ? 2 : 0);
12926
12927 /* Initialize howto table if needed. */
12928 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
12929 ppc_howto_init ();
12930
12931 htab = ppc_hash_table (info);
12932 if (htab == NULL)
12933 return FALSE;
12934
12935 /* Don't relocate stub sections. */
12936 if (input_section->owner == htab->params->stub_bfd)
12937 return TRUE;
12938
12939 BFD_ASSERT (is_ppc64_elf (input_bfd));
12940
12941 local_got_ents = elf_local_got_ents (input_bfd);
12942 TOCstart = elf_gp (output_bfd);
12943 symtab_hdr = &elf_symtab_hdr (input_bfd);
12944 sym_hashes = elf_sym_hashes (input_bfd);
12945 is_opd = ppc64_elf_section_data (input_section)->sec_type == sec_opd;
12946
12947 rel = relocs;
12948 relend = relocs + input_section->reloc_count;
12949 for (; rel < relend; rel++)
12950 {
12951 enum elf_ppc64_reloc_type r_type;
12952 bfd_vma addend;
12953 bfd_reloc_status_type r;
12954 Elf_Internal_Sym *sym;
12955 asection *sec;
12956 struct elf_link_hash_entry *h_elf;
12957 struct ppc_link_hash_entry *h;
12958 struct ppc_link_hash_entry *fdh;
12959 const char *sym_name;
12960 unsigned long r_symndx, toc_symndx;
12961 bfd_vma toc_addend;
12962 unsigned char tls_mask, tls_gd, tls_type;
12963 unsigned char sym_type;
12964 bfd_vma relocation;
12965 bfd_boolean unresolved_reloc;
12966 bfd_boolean warned;
12967 enum { DEST_NORMAL, DEST_OPD, DEST_STUB } reloc_dest;
12968 unsigned int insn;
12969 unsigned int mask;
12970 struct ppc_stub_hash_entry *stub_entry;
12971 bfd_vma max_br_offset;
12972 bfd_vma from;
12973 const Elf_Internal_Rela orig_rel = *rel;
12974 reloc_howto_type *howto;
12975 struct reloc_howto_struct alt_howto;
12976
12977 r_type = ELF64_R_TYPE (rel->r_info);
12978 r_symndx = ELF64_R_SYM (rel->r_info);
12979
12980 /* For old style R_PPC64_TOC relocs with a zero symbol, use the
12981 symbol of the previous ADDR64 reloc. The symbol gives us the
12982 proper TOC base to use. */
12983 if (rel->r_info == ELF64_R_INFO (0, R_PPC64_TOC)
12984 && rel != relocs
12985 && ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_ADDR64
12986 && is_opd)
12987 r_symndx = ELF64_R_SYM (rel[-1].r_info);
12988
12989 sym = NULL;
12990 sec = NULL;
12991 h_elf = NULL;
12992 sym_name = NULL;
12993 unresolved_reloc = FALSE;
12994 warned = FALSE;
12995
12996 if (r_symndx < symtab_hdr->sh_info)
12997 {
12998 /* It's a local symbol. */
12999 struct _opd_sec_data *opd;
13000
13001 sym = local_syms + r_symndx;
13002 sec = local_sections[r_symndx];
13003 sym_name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym, sec);
13004 sym_type = ELF64_ST_TYPE (sym->st_info);
13005 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
13006 opd = get_opd_info (sec);
13007 if (opd != NULL && opd->adjust != NULL)
13008 {
13009 long adjust = opd->adjust[(sym->st_value + rel->r_addend) / 8];
13010 if (adjust == -1)
13011 relocation = 0;
13012 else
13013 {
13014 /* If this is a relocation against the opd section sym
13015 and we have edited .opd, adjust the reloc addend so
13016 that ld -r and ld --emit-relocs output is correct.
13017 If it is a reloc against some other .opd symbol,
13018 then the symbol value will be adjusted later. */
13019 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
13020 rel->r_addend += adjust;
13021 else
13022 relocation += adjust;
13023 }
13024 }
13025 }
13026 else
13027 {
13028 bfd_boolean ignored;
13029
13030 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
13031 r_symndx, symtab_hdr, sym_hashes,
13032 h_elf, sec, relocation,
13033 unresolved_reloc, warned, ignored);
13034 sym_name = h_elf->root.root.string;
13035 sym_type = h_elf->type;
13036 if (sec != NULL
13037 && sec->owner == output_bfd
13038 && strcmp (sec->name, ".opd") == 0)
13039 {
13040 /* This is a symbol defined in a linker script. All
13041 such are defined in output sections, even those
13042 defined by simple assignment from a symbol defined in
13043 an input section. Transfer the symbol to an
13044 appropriate input .opd section, so that a branch to
13045 this symbol will be mapped to the location specified
13046 by the opd entry. */
13047 struct bfd_link_order *lo;
13048 for (lo = sec->map_head.link_order; lo != NULL; lo = lo->next)
13049 if (lo->type == bfd_indirect_link_order)
13050 {
13051 asection *isec = lo->u.indirect.section;
13052 if (h_elf->root.u.def.value >= isec->output_offset
13053 && h_elf->root.u.def.value < (isec->output_offset
13054 + isec->size))
13055 {
13056 h_elf->root.u.def.value -= isec->output_offset;
13057 h_elf->root.u.def.section = isec;
13058 sec = isec;
13059 break;
13060 }
13061 }
13062 }
13063 }
13064 h = (struct ppc_link_hash_entry *) h_elf;
13065
13066 if (sec != NULL && discarded_section (sec))
13067 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
13068 rel, 1, relend,
13069 ppc64_elf_howto_table[r_type], 0,
13070 contents);
13071
13072 if (info->relocatable)
13073 continue;
13074
13075 if (h != NULL && &h->elf == htab->elf.hgot)
13076 {
13077 relocation = (TOCstart
13078 + htab->stub_group[input_section->id].toc_off);
13079 sec = bfd_abs_section_ptr;
13080 unresolved_reloc = FALSE;
13081 }
13082
13083 /* TLS optimizations. Replace instruction sequences and relocs
13084 based on information we collected in tls_optimize. We edit
13085 RELOCS so that --emit-relocs will output something sensible
13086 for the final instruction stream. */
13087 tls_mask = 0;
13088 tls_gd = 0;
13089 toc_symndx = 0;
13090 if (h != NULL)
13091 tls_mask = h->tls_mask;
13092 else if (local_got_ents != NULL)
13093 {
13094 struct plt_entry **local_plt = (struct plt_entry **)
13095 (local_got_ents + symtab_hdr->sh_info);
13096 unsigned char *lgot_masks = (unsigned char *)
13097 (local_plt + symtab_hdr->sh_info);
13098 tls_mask = lgot_masks[r_symndx];
13099 }
13100 if (tls_mask == 0
13101 && (r_type == R_PPC64_TLS
13102 || r_type == R_PPC64_TLSGD
13103 || r_type == R_PPC64_TLSLD))
13104 {
13105 /* Check for toc tls entries. */
13106 unsigned char *toc_tls;
13107
13108 if (!get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
13109 &local_syms, rel, input_bfd))
13110 return FALSE;
13111
13112 if (toc_tls)
13113 tls_mask = *toc_tls;
13114 }
13115
13116 /* Check that tls relocs are used with tls syms, and non-tls
13117 relocs are used with non-tls syms. */
13118 if (r_symndx != STN_UNDEF
13119 && r_type != R_PPC64_NONE
13120 && (h == NULL
13121 || h->elf.root.type == bfd_link_hash_defined
13122 || h->elf.root.type == bfd_link_hash_defweak)
13123 && (IS_PPC64_TLS_RELOC (r_type)
13124 != (sym_type == STT_TLS
13125 || (sym_type == STT_SECTION
13126 && (sec->flags & SEC_THREAD_LOCAL) != 0))))
13127 {
13128 if (tls_mask != 0
13129 && (r_type == R_PPC64_TLS
13130 || r_type == R_PPC64_TLSGD
13131 || r_type == R_PPC64_TLSLD))
13132 /* R_PPC64_TLS is OK against a symbol in the TOC. */
13133 ;
13134 else
13135 info->callbacks->einfo
13136 (!IS_PPC64_TLS_RELOC (r_type)
13137 ? _("%P: %H: %s used with TLS symbol `%T'\n")
13138 : _("%P: %H: %s used with non-TLS symbol `%T'\n"),
13139 input_bfd, input_section, rel->r_offset,
13140 ppc64_elf_howto_table[r_type]->name,
13141 sym_name);
13142 }
13143
13144 /* Ensure reloc mapping code below stays sane. */
13145 if (R_PPC64_TOC16_LO_DS != R_PPC64_TOC16_DS + 1
13146 || R_PPC64_TOC16_LO != R_PPC64_TOC16 + 1
13147 || (R_PPC64_GOT_TLSLD16 & 3) != (R_PPC64_GOT_TLSGD16 & 3)
13148 || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TLSGD16_LO & 3)
13149 || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TLSGD16_HI & 3)
13150 || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TLSGD16_HA & 3)
13151 || (R_PPC64_GOT_TLSLD16 & 3) != (R_PPC64_GOT_TPREL16_DS & 3)
13152 || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TPREL16_LO_DS & 3)
13153 || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TPREL16_HI & 3)
13154 || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TPREL16_HA & 3))
13155 abort ();
13156
13157 switch (r_type)
13158 {
13159 default:
13160 break;
13161
13162 case R_PPC64_LO_DS_OPT:
13163 insn = bfd_get_32 (output_bfd, contents + rel->r_offset - d_offset);
13164 if ((insn & (0x3f << 26)) != 58u << 26)
13165 abort ();
13166 insn += (14u << 26) - (58u << 26);
13167 bfd_put_32 (output_bfd, insn, contents + rel->r_offset - d_offset);
13168 r_type = R_PPC64_TOC16_LO;
13169 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13170 break;
13171
13172 case R_PPC64_TOC16:
13173 case R_PPC64_TOC16_LO:
13174 case R_PPC64_TOC16_DS:
13175 case R_PPC64_TOC16_LO_DS:
13176 {
13177 /* Check for toc tls entries. */
13178 unsigned char *toc_tls;
13179 int retval;
13180
13181 retval = get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
13182 &local_syms, rel, input_bfd);
13183 if (retval == 0)
13184 return FALSE;
13185
13186 if (toc_tls)
13187 {
13188 tls_mask = *toc_tls;
13189 if (r_type == R_PPC64_TOC16_DS
13190 || r_type == R_PPC64_TOC16_LO_DS)
13191 {
13192 if (tls_mask != 0
13193 && (tls_mask & (TLS_DTPREL | TLS_TPREL)) == 0)
13194 goto toctprel;
13195 }
13196 else
13197 {
13198 /* If we found a GD reloc pair, then we might be
13199 doing a GD->IE transition. */
13200 if (retval == 2)
13201 {
13202 tls_gd = TLS_TPRELGD;
13203 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13204 goto tls_ldgd_opt;
13205 }
13206 else if (retval == 3)
13207 {
13208 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13209 goto tls_ldgd_opt;
13210 }
13211 }
13212 }
13213 }
13214 break;
13215
13216 case R_PPC64_GOT_TPREL16_HI:
13217 case R_PPC64_GOT_TPREL16_HA:
13218 if (tls_mask != 0
13219 && (tls_mask & TLS_TPREL) == 0)
13220 {
13221 rel->r_offset -= d_offset;
13222 bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
13223 r_type = R_PPC64_NONE;
13224 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13225 }
13226 break;
13227
13228 case R_PPC64_GOT_TPREL16_DS:
13229 case R_PPC64_GOT_TPREL16_LO_DS:
13230 if (tls_mask != 0
13231 && (tls_mask & TLS_TPREL) == 0)
13232 {
13233 toctprel:
13234 insn = bfd_get_32 (output_bfd, contents + rel->r_offset - d_offset);
13235 insn &= 31 << 21;
13236 insn |= 0x3c0d0000; /* addis 0,13,0 */
13237 bfd_put_32 (output_bfd, insn, contents + rel->r_offset - d_offset);
13238 r_type = R_PPC64_TPREL16_HA;
13239 if (toc_symndx != 0)
13240 {
13241 rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
13242 rel->r_addend = toc_addend;
13243 /* We changed the symbol. Start over in order to
13244 get h, sym, sec etc. right. */
13245 rel--;
13246 continue;
13247 }
13248 else
13249 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13250 }
13251 break;
13252
13253 case R_PPC64_TLS:
13254 if (tls_mask != 0
13255 && (tls_mask & TLS_TPREL) == 0)
13256 {
13257 insn = bfd_get_32 (output_bfd, contents + rel->r_offset);
13258 insn = _bfd_elf_ppc_at_tls_transform (insn, 13);
13259 if (insn == 0)
13260 abort ();
13261 bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
13262 /* Was PPC64_TLS which sits on insn boundary, now
13263 PPC64_TPREL16_LO which is at low-order half-word. */
13264 rel->r_offset += d_offset;
13265 r_type = R_PPC64_TPREL16_LO;
13266 if (toc_symndx != 0)
13267 {
13268 rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
13269 rel->r_addend = toc_addend;
13270 /* We changed the symbol. Start over in order to
13271 get h, sym, sec etc. right. */
13272 rel--;
13273 continue;
13274 }
13275 else
13276 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13277 }
13278 break;
13279
13280 case R_PPC64_GOT_TLSGD16_HI:
13281 case R_PPC64_GOT_TLSGD16_HA:
13282 tls_gd = TLS_TPRELGD;
13283 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13284 goto tls_gdld_hi;
13285 break;
13286
13287 case R_PPC64_GOT_TLSLD16_HI:
13288 case R_PPC64_GOT_TLSLD16_HA:
13289 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13290 {
13291 tls_gdld_hi:
13292 if ((tls_mask & tls_gd) != 0)
13293 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
13294 + R_PPC64_GOT_TPREL16_DS);
13295 else
13296 {
13297 rel->r_offset -= d_offset;
13298 bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
13299 r_type = R_PPC64_NONE;
13300 }
13301 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13302 }
13303 break;
13304
13305 case R_PPC64_GOT_TLSGD16:
13306 case R_PPC64_GOT_TLSGD16_LO:
13307 tls_gd = TLS_TPRELGD;
13308 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13309 goto tls_ldgd_opt;
13310 break;
13311
13312 case R_PPC64_GOT_TLSLD16:
13313 case R_PPC64_GOT_TLSLD16_LO:
13314 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13315 {
13316 unsigned int insn1, insn2, insn3;
13317 bfd_vma offset;
13318
13319 tls_ldgd_opt:
13320 offset = (bfd_vma) -1;
13321 /* If not using the newer R_PPC64_TLSGD/LD to mark
13322 __tls_get_addr calls, we must trust that the call
13323 stays with its arg setup insns, ie. that the next
13324 reloc is the __tls_get_addr call associated with
13325 the current reloc. Edit both insns. */
13326 if (input_section->has_tls_get_addr_call
13327 && rel + 1 < relend
13328 && branch_reloc_hash_match (input_bfd, rel + 1,
13329 htab->tls_get_addr,
13330 htab->tls_get_addr_fd))
13331 offset = rel[1].r_offset;
13332 if ((tls_mask & tls_gd) != 0)
13333 {
13334 /* IE */
13335 insn1 = bfd_get_32 (output_bfd,
13336 contents + rel->r_offset - d_offset);
13337 insn1 &= (1 << 26) - (1 << 2);
13338 insn1 |= 58 << 26; /* ld */
13339 insn2 = 0x7c636a14; /* add 3,3,13 */
13340 if (offset != (bfd_vma) -1)
13341 rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13342 if ((tls_mask & TLS_EXPLICIT) == 0)
13343 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
13344 + R_PPC64_GOT_TPREL16_DS);
13345 else
13346 r_type += R_PPC64_TOC16_DS - R_PPC64_TOC16;
13347 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13348 }
13349 else
13350 {
13351 /* LE */
13352 insn1 = 0x3c6d0000; /* addis 3,13,0 */
13353 insn2 = 0x38630000; /* addi 3,3,0 */
13354 if (tls_gd == 0)
13355 {
13356 /* Was an LD reloc. */
13357 if (toc_symndx)
13358 sec = local_sections[toc_symndx];
13359 for (r_symndx = 0;
13360 r_symndx < symtab_hdr->sh_info;
13361 r_symndx++)
13362 if (local_sections[r_symndx] == sec)
13363 break;
13364 if (r_symndx >= symtab_hdr->sh_info)
13365 r_symndx = STN_UNDEF;
13366 rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
13367 if (r_symndx != STN_UNDEF)
13368 rel->r_addend -= (local_syms[r_symndx].st_value
13369 + sec->output_offset
13370 + sec->output_section->vma);
13371 }
13372 else if (toc_symndx != 0)
13373 {
13374 r_symndx = toc_symndx;
13375 rel->r_addend = toc_addend;
13376 }
13377 r_type = R_PPC64_TPREL16_HA;
13378 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13379 if (offset != (bfd_vma) -1)
13380 {
13381 rel[1].r_info = ELF64_R_INFO (r_symndx,
13382 R_PPC64_TPREL16_LO);
13383 rel[1].r_offset = offset + d_offset;
13384 rel[1].r_addend = rel->r_addend;
13385 }
13386 }
13387 bfd_put_32 (output_bfd, insn1,
13388 contents + rel->r_offset - d_offset);
13389 if (offset != (bfd_vma) -1)
13390 {
13391 insn3 = bfd_get_32 (output_bfd,
13392 contents + offset + 4);
13393 if (insn3 == NOP
13394 || insn3 == CROR_151515 || insn3 == CROR_313131)
13395 {
13396 rel[1].r_offset += 4;
13397 bfd_put_32 (output_bfd, insn2, contents + offset + 4);
13398 insn2 = NOP;
13399 }
13400 bfd_put_32 (output_bfd, insn2, contents + offset);
13401 }
13402 if ((tls_mask & tls_gd) == 0
13403 && (tls_gd == 0 || toc_symndx != 0))
13404 {
13405 /* We changed the symbol. Start over in order
13406 to get h, sym, sec etc. right. */
13407 rel--;
13408 continue;
13409 }
13410 }
13411 break;
13412
13413 case R_PPC64_TLSGD:
13414 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13415 {
13416 unsigned int insn2, insn3;
13417 bfd_vma offset = rel->r_offset;
13418
13419 if ((tls_mask & TLS_TPRELGD) != 0)
13420 {
13421 /* IE */
13422 r_type = R_PPC64_NONE;
13423 insn2 = 0x7c636a14; /* add 3,3,13 */
13424 }
13425 else
13426 {
13427 /* LE */
13428 if (toc_symndx != 0)
13429 {
13430 r_symndx = toc_symndx;
13431 rel->r_addend = toc_addend;
13432 }
13433 r_type = R_PPC64_TPREL16_LO;
13434 rel->r_offset = offset + d_offset;
13435 insn2 = 0x38630000; /* addi 3,3,0 */
13436 }
13437 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13438 /* Zap the reloc on the _tls_get_addr call too. */
13439 BFD_ASSERT (offset == rel[1].r_offset);
13440 rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13441 insn3 = bfd_get_32 (output_bfd,
13442 contents + offset + 4);
13443 if (insn3 == NOP
13444 || insn3 == CROR_151515 || insn3 == CROR_313131)
13445 {
13446 rel->r_offset += 4;
13447 bfd_put_32 (output_bfd, insn2, contents + offset + 4);
13448 insn2 = NOP;
13449 }
13450 bfd_put_32 (output_bfd, insn2, contents + offset);
13451 if ((tls_mask & TLS_TPRELGD) == 0 && toc_symndx != 0)
13452 {
13453 rel--;
13454 continue;
13455 }
13456 }
13457 break;
13458
13459 case R_PPC64_TLSLD:
13460 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13461 {
13462 unsigned int insn2, insn3;
13463 bfd_vma offset = rel->r_offset;
13464
13465 if (toc_symndx)
13466 sec = local_sections[toc_symndx];
13467 for (r_symndx = 0;
13468 r_symndx < symtab_hdr->sh_info;
13469 r_symndx++)
13470 if (local_sections[r_symndx] == sec)
13471 break;
13472 if (r_symndx >= symtab_hdr->sh_info)
13473 r_symndx = STN_UNDEF;
13474 rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
13475 if (r_symndx != STN_UNDEF)
13476 rel->r_addend -= (local_syms[r_symndx].st_value
13477 + sec->output_offset
13478 + sec->output_section->vma);
13479
13480 r_type = R_PPC64_TPREL16_LO;
13481 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13482 rel->r_offset = offset + d_offset;
13483 /* Zap the reloc on the _tls_get_addr call too. */
13484 BFD_ASSERT (offset == rel[1].r_offset);
13485 rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13486 insn2 = 0x38630000; /* addi 3,3,0 */
13487 insn3 = bfd_get_32 (output_bfd,
13488 contents + offset + 4);
13489 if (insn3 == NOP
13490 || insn3 == CROR_151515 || insn3 == CROR_313131)
13491 {
13492 rel->r_offset += 4;
13493 bfd_put_32 (output_bfd, insn2, contents + offset + 4);
13494 insn2 = NOP;
13495 }
13496 bfd_put_32 (output_bfd, insn2, contents + offset);
13497 rel--;
13498 continue;
13499 }
13500 break;
13501
13502 case R_PPC64_DTPMOD64:
13503 if (rel + 1 < relend
13504 && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
13505 && rel[1].r_offset == rel->r_offset + 8)
13506 {
13507 if ((tls_mask & TLS_GD) == 0)
13508 {
13509 rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_NONE);
13510 if ((tls_mask & TLS_TPRELGD) != 0)
13511 r_type = R_PPC64_TPREL64;
13512 else
13513 {
13514 bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
13515 r_type = R_PPC64_NONE;
13516 }
13517 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13518 }
13519 }
13520 else
13521 {
13522 if ((tls_mask & TLS_LD) == 0)
13523 {
13524 bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
13525 r_type = R_PPC64_NONE;
13526 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13527 }
13528 }
13529 break;
13530
13531 case R_PPC64_TPREL64:
13532 if ((tls_mask & TLS_TPREL) == 0)
13533 {
13534 r_type = R_PPC64_NONE;
13535 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13536 }
13537 break;
13538
13539 case R_PPC64_REL16_HA:
13540 /* If we are generating a non-PIC executable, edit
13541 . 0: addis 2,12,.TOC.-0b@ha
13542 . addi 2,2,.TOC.-0b@l
13543 used by ELFv2 global entry points to set up r2, to
13544 . lis 2,.TOC.@ha
13545 . addi 2,2,.TOC.@l
13546 if .TOC. is in range. */
13547 if (!info->shared
13548 && h != NULL && &h->elf == htab->elf.hgot
13549 && rel + 1 < relend
13550 && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_REL16_LO)
13551 && rel[1].r_offset == rel->r_offset + 4
13552 && rel[1].r_addend == rel->r_addend + 4
13553 && relocation + 0x80008000 <= 0xffffffff)
13554 {
13555 unsigned int insn1, insn2;
13556 bfd_vma offset = rel->r_offset - d_offset;
13557 insn1 = bfd_get_32 (output_bfd, contents + offset);
13558 insn2 = bfd_get_32 (output_bfd, contents + offset + 4);
13559 if ((insn1 & 0xffff0000) == 0x3c4c0000 /* addis 2,12 */
13560 && (insn2 & 0xffff0000) == 0x38420000 /* addi 2,2 */)
13561 {
13562 r_type = R_PPC64_ADDR16_HA;
13563 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13564 rel->r_addend -= d_offset;
13565 rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_ADDR16_LO);
13566 rel[1].r_addend -= d_offset + 4;
13567 bfd_put_32 (output_bfd, 0x3c400000, contents + offset);
13568 }
13569 }
13570 break;
13571 }
13572
13573 /* Handle other relocations that tweak non-addend part of insn. */
13574 insn = 0;
13575 max_br_offset = 1 << 25;
13576 addend = rel->r_addend;
13577 reloc_dest = DEST_NORMAL;
13578 switch (r_type)
13579 {
13580 default:
13581 break;
13582
13583 case R_PPC64_TOCSAVE:
13584 if (relocation + addend == (rel->r_offset
13585 + input_section->output_offset
13586 + input_section->output_section->vma)
13587 && tocsave_find (htab, NO_INSERT,
13588 &local_syms, rel, input_bfd))
13589 {
13590 insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
13591 if (insn == NOP
13592 || insn == CROR_151515 || insn == CROR_313131)
13593 bfd_put_32 (input_bfd,
13594 STD_R2_0R1 + STK_TOC (htab),
13595 contents + rel->r_offset);
13596 }
13597 break;
13598
13599 /* Branch taken prediction relocations. */
13600 case R_PPC64_ADDR14_BRTAKEN:
13601 case R_PPC64_REL14_BRTAKEN:
13602 insn = 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field. */
13603 /* Fall thru. */
13604
13605 /* Branch not taken prediction relocations. */
13606 case R_PPC64_ADDR14_BRNTAKEN:
13607 case R_PPC64_REL14_BRNTAKEN:
13608 insn |= bfd_get_32 (output_bfd,
13609 contents + rel->r_offset) & ~(0x01 << 21);
13610 /* Fall thru. */
13611
13612 case R_PPC64_REL14:
13613 max_br_offset = 1 << 15;
13614 /* Fall thru. */
13615
13616 case R_PPC64_REL24:
13617 /* Calls to functions with a different TOC, such as calls to
13618 shared objects, need to alter the TOC pointer. This is
13619 done using a linkage stub. A REL24 branching to these
13620 linkage stubs needs to be followed by a nop, as the nop
13621 will be replaced with an instruction to restore the TOC
13622 base pointer. */
13623 fdh = h;
13624 if (h != NULL
13625 && h->oh != NULL
13626 && h->oh->is_func_descriptor)
13627 fdh = ppc_follow_link (h->oh);
13628 stub_entry = ppc_get_stub_entry (input_section, sec, fdh, &orig_rel,
13629 htab);
13630 if (stub_entry != NULL
13631 && (stub_entry->stub_type == ppc_stub_plt_call
13632 || stub_entry->stub_type == ppc_stub_plt_call_r2save
13633 || stub_entry->stub_type == ppc_stub_plt_branch_r2off
13634 || stub_entry->stub_type == ppc_stub_long_branch_r2off))
13635 {
13636 bfd_boolean can_plt_call = FALSE;
13637
13638 /* All of these stubs will modify r2, so there must be a
13639 branch and link followed by a nop. The nop is
13640 replaced by an insn to restore r2. */
13641 if (rel->r_offset + 8 <= input_section->size)
13642 {
13643 unsigned long br;
13644
13645 br = bfd_get_32 (input_bfd,
13646 contents + rel->r_offset);
13647 if ((br & 1) != 0)
13648 {
13649 unsigned long nop;
13650
13651 nop = bfd_get_32 (input_bfd,
13652 contents + rel->r_offset + 4);
13653 if (nop == NOP
13654 || nop == CROR_151515 || nop == CROR_313131)
13655 {
13656 if (h != NULL
13657 && (h == htab->tls_get_addr_fd
13658 || h == htab->tls_get_addr)
13659 && !htab->params->no_tls_get_addr_opt)
13660 {
13661 /* Special stub used, leave nop alone. */
13662 }
13663 else
13664 bfd_put_32 (input_bfd,
13665 LD_R2_0R1 + STK_TOC (htab),
13666 contents + rel->r_offset + 4);
13667 can_plt_call = TRUE;
13668 }
13669 }
13670 }
13671
13672 if (!can_plt_call && h != NULL)
13673 {
13674 const char *name = h->elf.root.root.string;
13675
13676 if (*name == '.')
13677 ++name;
13678
13679 if (strncmp (name, "__libc_start_main", 17) == 0
13680 && (name[17] == 0 || name[17] == '@'))
13681 {
13682 /* Allow crt1 branch to go via a toc adjusting
13683 stub. Other calls that never return could do
13684 the same, if we could detect such. */
13685 can_plt_call = TRUE;
13686 }
13687 }
13688
13689 if (!can_plt_call)
13690 {
13691 /* g++ as of 20130507 emits self-calls without a
13692 following nop. This is arguably wrong since we
13693 have conflicting information. On the one hand a
13694 global symbol and on the other a local call
13695 sequence, but don't error for this special case.
13696 It isn't possible to cheaply verify we have
13697 exactly such a call. Allow all calls to the same
13698 section. */
13699 asection *code_sec = sec;
13700
13701 if (get_opd_info (sec) != NULL)
13702 {
13703 bfd_vma off = (relocation + addend
13704 - sec->output_section->vma
13705 - sec->output_offset);
13706
13707 opd_entry_value (sec, off, &code_sec, NULL, FALSE);
13708 }
13709 if (code_sec == input_section)
13710 can_plt_call = TRUE;
13711 }
13712
13713 if (!can_plt_call)
13714 {
13715 info->callbacks->einfo
13716 (_("%P: %H: call to `%T' lacks nop, can't restore toc; "
13717 "recompile with -fPIC\n"),
13718 input_bfd, input_section, rel->r_offset, sym_name);
13719
13720 bfd_set_error (bfd_error_bad_value);
13721 ret = FALSE;
13722 }
13723
13724 if (can_plt_call
13725 && (stub_entry->stub_type == ppc_stub_plt_call
13726 || stub_entry->stub_type == ppc_stub_plt_call_r2save))
13727 unresolved_reloc = FALSE;
13728 }
13729
13730 if ((stub_entry == NULL
13731 || stub_entry->stub_type == ppc_stub_long_branch
13732 || stub_entry->stub_type == ppc_stub_plt_branch)
13733 && get_opd_info (sec) != NULL)
13734 {
13735 /* The branch destination is the value of the opd entry. */
13736 bfd_vma off = (relocation + addend
13737 - sec->output_section->vma
13738 - sec->output_offset);
13739 bfd_vma dest = opd_entry_value (sec, off, NULL, NULL, FALSE);
13740 if (dest != (bfd_vma) -1)
13741 {
13742 relocation = dest;
13743 addend = 0;
13744 reloc_dest = DEST_OPD;
13745 }
13746 }
13747
13748 /* If the branch is out of reach we ought to have a long
13749 branch stub. */
13750 from = (rel->r_offset
13751 + input_section->output_offset
13752 + input_section->output_section->vma);
13753
13754 relocation += PPC64_LOCAL_ENTRY_OFFSET (fdh
13755 ? fdh->elf.other
13756 : sym->st_other);
13757
13758 if (stub_entry != NULL
13759 && (stub_entry->stub_type == ppc_stub_long_branch
13760 || stub_entry->stub_type == ppc_stub_plt_branch)
13761 && (r_type == R_PPC64_ADDR14_BRTAKEN
13762 || r_type == R_PPC64_ADDR14_BRNTAKEN
13763 || (relocation + addend - from + max_br_offset
13764 < 2 * max_br_offset)))
13765 /* Don't use the stub if this branch is in range. */
13766 stub_entry = NULL;
13767
13768 if (stub_entry != NULL)
13769 {
13770 /* Munge up the value and addend so that we call the stub
13771 rather than the procedure directly. */
13772 relocation = (stub_entry->stub_offset
13773 + stub_entry->stub_sec->output_offset
13774 + stub_entry->stub_sec->output_section->vma);
13775 addend = 0;
13776 reloc_dest = DEST_STUB;
13777
13778 if ((stub_entry->stub_type == ppc_stub_plt_call
13779 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
13780 && (ALWAYS_EMIT_R2SAVE
13781 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
13782 && rel + 1 < relend
13783 && rel[1].r_offset == rel->r_offset + 4
13784 && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOCSAVE)
13785 relocation += 4;
13786 }
13787
13788 if (insn != 0)
13789 {
13790 if (is_isa_v2)
13791 {
13792 /* Set 'a' bit. This is 0b00010 in BO field for branch
13793 on CR(BI) insns (BO == 001at or 011at), and 0b01000
13794 for branch on CTR insns (BO == 1a00t or 1a01t). */
13795 if ((insn & (0x14 << 21)) == (0x04 << 21))
13796 insn |= 0x02 << 21;
13797 else if ((insn & (0x14 << 21)) == (0x10 << 21))
13798 insn |= 0x08 << 21;
13799 else
13800 break;
13801 }
13802 else
13803 {
13804 /* Invert 'y' bit if not the default. */
13805 if ((bfd_signed_vma) (relocation + addend - from) < 0)
13806 insn ^= 0x01 << 21;
13807 }
13808
13809 bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
13810 }
13811
13812 /* NOP out calls to undefined weak functions.
13813 We can thus call a weak function without first
13814 checking whether the function is defined. */
13815 else if (h != NULL
13816 && h->elf.root.type == bfd_link_hash_undefweak
13817 && h->elf.dynindx == -1
13818 && r_type == R_PPC64_REL24
13819 && relocation == 0
13820 && addend == 0)
13821 {
13822 bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
13823 continue;
13824 }
13825 break;
13826 }
13827
13828 /* Set `addend'. */
13829 tls_type = 0;
13830 switch (r_type)
13831 {
13832 default:
13833 info->callbacks->einfo
13834 (_("%P: %B: unknown relocation type %d for `%T'\n"),
13835 input_bfd, (int) r_type, sym_name);
13836
13837 bfd_set_error (bfd_error_bad_value);
13838 ret = FALSE;
13839 continue;
13840
13841 case R_PPC64_NONE:
13842 case R_PPC64_TLS:
13843 case R_PPC64_TLSGD:
13844 case R_PPC64_TLSLD:
13845 case R_PPC64_TOCSAVE:
13846 case R_PPC64_GNU_VTINHERIT:
13847 case R_PPC64_GNU_VTENTRY:
13848 continue;
13849
13850 /* GOT16 relocations. Like an ADDR16 using the symbol's
13851 address in the GOT as relocation value instead of the
13852 symbol's value itself. Also, create a GOT entry for the
13853 symbol and put the symbol value there. */
13854 case R_PPC64_GOT_TLSGD16:
13855 case R_PPC64_GOT_TLSGD16_LO:
13856 case R_PPC64_GOT_TLSGD16_HI:
13857 case R_PPC64_GOT_TLSGD16_HA:
13858 tls_type = TLS_TLS | TLS_GD;
13859 goto dogot;
13860
13861 case R_PPC64_GOT_TLSLD16:
13862 case R_PPC64_GOT_TLSLD16_LO:
13863 case R_PPC64_GOT_TLSLD16_HI:
13864 case R_PPC64_GOT_TLSLD16_HA:
13865 tls_type = TLS_TLS | TLS_LD;
13866 goto dogot;
13867
13868 case R_PPC64_GOT_TPREL16_DS:
13869 case R_PPC64_GOT_TPREL16_LO_DS:
13870 case R_PPC64_GOT_TPREL16_HI:
13871 case R_PPC64_GOT_TPREL16_HA:
13872 tls_type = TLS_TLS | TLS_TPREL;
13873 goto dogot;
13874
13875 case R_PPC64_GOT_DTPREL16_DS:
13876 case R_PPC64_GOT_DTPREL16_LO_DS:
13877 case R_PPC64_GOT_DTPREL16_HI:
13878 case R_PPC64_GOT_DTPREL16_HA:
13879 tls_type = TLS_TLS | TLS_DTPREL;
13880 goto dogot;
13881
13882 case R_PPC64_GOT16:
13883 case R_PPC64_GOT16_LO:
13884 case R_PPC64_GOT16_HI:
13885 case R_PPC64_GOT16_HA:
13886 case R_PPC64_GOT16_DS:
13887 case R_PPC64_GOT16_LO_DS:
13888 dogot:
13889 {
13890 /* Relocation is to the entry for this symbol in the global
13891 offset table. */
13892 asection *got;
13893 bfd_vma *offp;
13894 bfd_vma off;
13895 unsigned long indx = 0;
13896 struct got_entry *ent;
13897
13898 if (tls_type == (TLS_TLS | TLS_LD)
13899 && (h == NULL
13900 || !h->elf.def_dynamic))
13901 ent = ppc64_tlsld_got (input_bfd);
13902 else
13903 {
13904
13905 if (h != NULL)
13906 {
13907 bfd_boolean dyn = htab->elf.dynamic_sections_created;
13908 if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared,
13909 &h->elf)
13910 || (info->shared
13911 && SYMBOL_REFERENCES_LOCAL (info, &h->elf)))
13912 /* This is actually a static link, or it is a
13913 -Bsymbolic link and the symbol is defined
13914 locally, or the symbol was forced to be local
13915 because of a version file. */
13916 ;
13917 else
13918 {
13919 BFD_ASSERT (h->elf.dynindx != -1);
13920 indx = h->elf.dynindx;
13921 unresolved_reloc = FALSE;
13922 }
13923 ent = h->elf.got.glist;
13924 }
13925 else
13926 {
13927 if (local_got_ents == NULL)
13928 abort ();
13929 ent = local_got_ents[r_symndx];
13930 }
13931
13932 for (; ent != NULL; ent = ent->next)
13933 if (ent->addend == orig_rel.r_addend
13934 && ent->owner == input_bfd
13935 && ent->tls_type == tls_type)
13936 break;
13937 }
13938
13939 if (ent == NULL)
13940 abort ();
13941 if (ent->is_indirect)
13942 ent = ent->got.ent;
13943 offp = &ent->got.offset;
13944 got = ppc64_elf_tdata (ent->owner)->got;
13945 if (got == NULL)
13946 abort ();
13947
13948 /* The offset must always be a multiple of 8. We use the
13949 least significant bit to record whether we have already
13950 processed this entry. */
13951 off = *offp;
13952 if ((off & 1) != 0)
13953 off &= ~1;
13954 else
13955 {
13956 /* Generate relocs for the dynamic linker, except in
13957 the case of TLSLD where we'll use one entry per
13958 module. */
13959 asection *relgot;
13960 bfd_boolean ifunc;
13961
13962 *offp = off | 1;
13963 relgot = NULL;
13964 ifunc = (h != NULL
13965 ? h->elf.type == STT_GNU_IFUNC
13966 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC);
13967 if (ifunc)
13968 relgot = htab->elf.irelplt;
13969 else if ((info->shared || indx != 0)
13970 && (h == NULL
13971 || (tls_type == (TLS_TLS | TLS_LD)
13972 && !h->elf.def_dynamic)
13973 || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
13974 || h->elf.root.type != bfd_link_hash_undefweak))
13975 relgot = ppc64_elf_tdata (ent->owner)->relgot;
13976 if (relgot != NULL)
13977 {
13978 outrel.r_offset = (got->output_section->vma
13979 + got->output_offset
13980 + off);
13981 outrel.r_addend = addend;
13982 if (tls_type & (TLS_LD | TLS_GD))
13983 {
13984 outrel.r_addend = 0;
13985 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPMOD64);
13986 if (tls_type == (TLS_TLS | TLS_GD))
13987 {
13988 loc = relgot->contents;
13989 loc += (relgot->reloc_count++
13990 * sizeof (Elf64_External_Rela));
13991 bfd_elf64_swap_reloca_out (output_bfd,
13992 &outrel, loc);
13993 outrel.r_offset += 8;
13994 outrel.r_addend = addend;
13995 outrel.r_info
13996 = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
13997 }
13998 }
13999 else if (tls_type == (TLS_TLS | TLS_DTPREL))
14000 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
14001 else if (tls_type == (TLS_TLS | TLS_TPREL))
14002 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_TPREL64);
14003 else if (indx != 0)
14004 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_GLOB_DAT);
14005 else
14006 {
14007 if (ifunc)
14008 outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
14009 else
14010 outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
14011
14012 /* Write the .got section contents for the sake
14013 of prelink. */
14014 loc = got->contents + off;
14015 bfd_put_64 (output_bfd, outrel.r_addend + relocation,
14016 loc);
14017 }
14018
14019 if (indx == 0 && tls_type != (TLS_TLS | TLS_LD))
14020 {
14021 outrel.r_addend += relocation;
14022 if (tls_type & (TLS_GD | TLS_DTPREL | TLS_TPREL))
14023 outrel.r_addend -= htab->elf.tls_sec->vma;
14024 }
14025 loc = relgot->contents;
14026 loc += (relgot->reloc_count++
14027 * sizeof (Elf64_External_Rela));
14028 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
14029 }
14030
14031 /* Init the .got section contents here if we're not
14032 emitting a reloc. */
14033 else
14034 {
14035 relocation += addend;
14036 if (tls_type == (TLS_TLS | TLS_LD))
14037 relocation = 1;
14038 else if (tls_type != 0)
14039 {
14040 relocation -= htab->elf.tls_sec->vma + DTP_OFFSET;
14041 if (tls_type == (TLS_TLS | TLS_TPREL))
14042 relocation += DTP_OFFSET - TP_OFFSET;
14043
14044 if (tls_type == (TLS_TLS | TLS_GD))
14045 {
14046 bfd_put_64 (output_bfd, relocation,
14047 got->contents + off + 8);
14048 relocation = 1;
14049 }
14050 }
14051
14052 bfd_put_64 (output_bfd, relocation,
14053 got->contents + off);
14054 }
14055 }
14056
14057 if (off >= (bfd_vma) -2)
14058 abort ();
14059
14060 relocation = got->output_section->vma + got->output_offset + off;
14061 addend = -(TOCstart + htab->stub_group[input_section->id].toc_off);
14062 }
14063 break;
14064
14065 case R_PPC64_PLT16_HA:
14066 case R_PPC64_PLT16_HI:
14067 case R_PPC64_PLT16_LO:
14068 case R_PPC64_PLT32:
14069 case R_PPC64_PLT64:
14070 /* Relocation is to the entry for this symbol in the
14071 procedure linkage table. */
14072
14073 /* Resolve a PLT reloc against a local symbol directly,
14074 without using the procedure linkage table. */
14075 if (h == NULL)
14076 break;
14077
14078 /* It's possible that we didn't make a PLT entry for this
14079 symbol. This happens when statically linking PIC code,
14080 or when using -Bsymbolic. Go find a match if there is a
14081 PLT entry. */
14082 if (htab->elf.splt != NULL)
14083 {
14084 struct plt_entry *ent;
14085 for (ent = h->elf.plt.plist; ent != NULL; ent = ent->next)
14086 if (ent->plt.offset != (bfd_vma) -1
14087 && ent->addend == orig_rel.r_addend)
14088 {
14089 relocation = (htab->elf.splt->output_section->vma
14090 + htab->elf.splt->output_offset
14091 + ent->plt.offset);
14092 unresolved_reloc = FALSE;
14093 break;
14094 }
14095 }
14096 break;
14097
14098 case R_PPC64_TOC:
14099 /* Relocation value is TOC base. */
14100 relocation = TOCstart;
14101 if (r_symndx == STN_UNDEF)
14102 relocation += htab->stub_group[input_section->id].toc_off;
14103 else if (unresolved_reloc)
14104 ;
14105 else if (sec != NULL && sec->id <= htab->top_id)
14106 relocation += htab->stub_group[sec->id].toc_off;
14107 else
14108 unresolved_reloc = TRUE;
14109 goto dodyn;
14110
14111 /* TOC16 relocs. We want the offset relative to the TOC base,
14112 which is the address of the start of the TOC plus 0x8000.
14113 The TOC consists of sections .got, .toc, .tocbss, and .plt,
14114 in this order. */
14115 case R_PPC64_TOC16:
14116 case R_PPC64_TOC16_LO:
14117 case R_PPC64_TOC16_HI:
14118 case R_PPC64_TOC16_DS:
14119 case R_PPC64_TOC16_LO_DS:
14120 case R_PPC64_TOC16_HA:
14121 addend -= TOCstart + htab->stub_group[input_section->id].toc_off;
14122 break;
14123
14124 /* Relocate against the beginning of the section. */
14125 case R_PPC64_SECTOFF:
14126 case R_PPC64_SECTOFF_LO:
14127 case R_PPC64_SECTOFF_HI:
14128 case R_PPC64_SECTOFF_DS:
14129 case R_PPC64_SECTOFF_LO_DS:
14130 case R_PPC64_SECTOFF_HA:
14131 if (sec != NULL)
14132 addend -= sec->output_section->vma;
14133 break;
14134
14135 case R_PPC64_REL16:
14136 case R_PPC64_REL16_LO:
14137 case R_PPC64_REL16_HI:
14138 case R_PPC64_REL16_HA:
14139 break;
14140
14141 case R_PPC64_REL14:
14142 case R_PPC64_REL14_BRNTAKEN:
14143 case R_PPC64_REL14_BRTAKEN:
14144 case R_PPC64_REL24:
14145 break;
14146
14147 case R_PPC64_TPREL16:
14148 case R_PPC64_TPREL16_LO:
14149 case R_PPC64_TPREL16_HI:
14150 case R_PPC64_TPREL16_HA:
14151 case R_PPC64_TPREL16_DS:
14152 case R_PPC64_TPREL16_LO_DS:
14153 case R_PPC64_TPREL16_HIGH:
14154 case R_PPC64_TPREL16_HIGHA:
14155 case R_PPC64_TPREL16_HIGHER:
14156 case R_PPC64_TPREL16_HIGHERA:
14157 case R_PPC64_TPREL16_HIGHEST:
14158 case R_PPC64_TPREL16_HIGHESTA:
14159 if (h != NULL
14160 && h->elf.root.type == bfd_link_hash_undefweak
14161 && h->elf.dynindx == -1)
14162 {
14163 /* Make this relocation against an undefined weak symbol
14164 resolve to zero. This is really just a tweak, since
14165 code using weak externs ought to check that they are
14166 defined before using them. */
14167 bfd_byte *p = contents + rel->r_offset - d_offset;
14168
14169 insn = bfd_get_32 (output_bfd, p);
14170 insn = _bfd_elf_ppc_at_tprel_transform (insn, 13);
14171 if (insn != 0)
14172 bfd_put_32 (output_bfd, insn, p);
14173 break;
14174 }
14175 addend -= htab->elf.tls_sec->vma + TP_OFFSET;
14176 if (info->shared)
14177 /* The TPREL16 relocs shouldn't really be used in shared
14178 libs as they will result in DT_TEXTREL being set, but
14179 support them anyway. */
14180 goto dodyn;
14181 break;
14182
14183 case R_PPC64_DTPREL16:
14184 case R_PPC64_DTPREL16_LO:
14185 case R_PPC64_DTPREL16_HI:
14186 case R_PPC64_DTPREL16_HA:
14187 case R_PPC64_DTPREL16_DS:
14188 case R_PPC64_DTPREL16_LO_DS:
14189 case R_PPC64_DTPREL16_HIGH:
14190 case R_PPC64_DTPREL16_HIGHA:
14191 case R_PPC64_DTPREL16_HIGHER:
14192 case R_PPC64_DTPREL16_HIGHERA:
14193 case R_PPC64_DTPREL16_HIGHEST:
14194 case R_PPC64_DTPREL16_HIGHESTA:
14195 addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
14196 break;
14197
14198 case R_PPC64_ADDR64_LOCAL:
14199 addend += PPC64_LOCAL_ENTRY_OFFSET (h != NULL
14200 ? h->elf.other
14201 : sym->st_other);
14202 break;
14203
14204 case R_PPC64_DTPMOD64:
14205 relocation = 1;
14206 addend = 0;
14207 goto dodyn;
14208
14209 case R_PPC64_TPREL64:
14210 addend -= htab->elf.tls_sec->vma + TP_OFFSET;
14211 goto dodyn;
14212
14213 case R_PPC64_DTPREL64:
14214 addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
14215 /* Fall thru */
14216
14217 /* Relocations that may need to be propagated if this is a
14218 dynamic object. */
14219 case R_PPC64_REL30:
14220 case R_PPC64_REL32:
14221 case R_PPC64_REL64:
14222 case R_PPC64_ADDR14:
14223 case R_PPC64_ADDR14_BRNTAKEN:
14224 case R_PPC64_ADDR14_BRTAKEN:
14225 case R_PPC64_ADDR16:
14226 case R_PPC64_ADDR16_DS:
14227 case R_PPC64_ADDR16_HA:
14228 case R_PPC64_ADDR16_HI:
14229 case R_PPC64_ADDR16_HIGH:
14230 case R_PPC64_ADDR16_HIGHA:
14231 case R_PPC64_ADDR16_HIGHER:
14232 case R_PPC64_ADDR16_HIGHERA:
14233 case R_PPC64_ADDR16_HIGHEST:
14234 case R_PPC64_ADDR16_HIGHESTA:
14235 case R_PPC64_ADDR16_LO:
14236 case R_PPC64_ADDR16_LO_DS:
14237 case R_PPC64_ADDR24:
14238 case R_PPC64_ADDR32:
14239 case R_PPC64_ADDR64:
14240 case R_PPC64_UADDR16:
14241 case R_PPC64_UADDR32:
14242 case R_PPC64_UADDR64:
14243 dodyn:
14244 if ((input_section->flags & SEC_ALLOC) == 0)
14245 break;
14246
14247 if (NO_OPD_RELOCS && is_opd)
14248 break;
14249
14250 if ((info->shared
14251 && (h == NULL
14252 || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
14253 || h->elf.root.type != bfd_link_hash_undefweak)
14254 && (must_be_dyn_reloc (info, r_type)
14255 || !SYMBOL_CALLS_LOCAL (info, &h->elf)))
14256 || (ELIMINATE_COPY_RELOCS
14257 && !info->shared
14258 && h != NULL
14259 && h->elf.dynindx != -1
14260 && !h->elf.non_got_ref
14261 && !h->elf.def_regular)
14262 || (!info->shared
14263 && (h != NULL
14264 ? h->elf.type == STT_GNU_IFUNC
14265 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)))
14266 {
14267 bfd_boolean skip, relocate;
14268 asection *sreloc;
14269 bfd_vma out_off;
14270
14271 /* When generating a dynamic object, these relocations
14272 are copied into the output file to be resolved at run
14273 time. */
14274
14275 skip = FALSE;
14276 relocate = FALSE;
14277
14278 out_off = _bfd_elf_section_offset (output_bfd, info,
14279 input_section, rel->r_offset);
14280 if (out_off == (bfd_vma) -1)
14281 skip = TRUE;
14282 else if (out_off == (bfd_vma) -2)
14283 skip = TRUE, relocate = TRUE;
14284 out_off += (input_section->output_section->vma
14285 + input_section->output_offset);
14286 outrel.r_offset = out_off;
14287 outrel.r_addend = rel->r_addend;
14288
14289 /* Optimize unaligned reloc use. */
14290 if ((r_type == R_PPC64_ADDR64 && (out_off & 7) != 0)
14291 || (r_type == R_PPC64_UADDR64 && (out_off & 7) == 0))
14292 r_type ^= R_PPC64_ADDR64 ^ R_PPC64_UADDR64;
14293 else if ((r_type == R_PPC64_ADDR32 && (out_off & 3) != 0)
14294 || (r_type == R_PPC64_UADDR32 && (out_off & 3) == 0))
14295 r_type ^= R_PPC64_ADDR32 ^ R_PPC64_UADDR32;
14296 else if ((r_type == R_PPC64_ADDR16 && (out_off & 1) != 0)
14297 || (r_type == R_PPC64_UADDR16 && (out_off & 1) == 0))
14298 r_type ^= R_PPC64_ADDR16 ^ R_PPC64_UADDR16;
14299
14300 if (skip)
14301 memset (&outrel, 0, sizeof outrel);
14302 else if (!SYMBOL_REFERENCES_LOCAL (info, &h->elf)
14303 && !is_opd
14304 && r_type != R_PPC64_TOC)
14305 {
14306 BFD_ASSERT (h->elf.dynindx != -1);
14307 outrel.r_info = ELF64_R_INFO (h->elf.dynindx, r_type);
14308 }
14309 else
14310 {
14311 /* This symbol is local, or marked to become local,
14312 or this is an opd section reloc which must point
14313 at a local function. */
14314 outrel.r_addend += relocation;
14315 if (r_type == R_PPC64_ADDR64 || r_type == R_PPC64_TOC)
14316 {
14317 if (is_opd && h != NULL)
14318 {
14319 /* Lie about opd entries. This case occurs
14320 when building shared libraries and we
14321 reference a function in another shared
14322 lib. The same thing happens for a weak
14323 definition in an application that's
14324 overridden by a strong definition in a
14325 shared lib. (I believe this is a generic
14326 bug in binutils handling of weak syms.)
14327 In these cases we won't use the opd
14328 entry in this lib. */
14329 unresolved_reloc = FALSE;
14330 }
14331 if (!is_opd
14332 && r_type == R_PPC64_ADDR64
14333 && (h != NULL
14334 ? h->elf.type == STT_GNU_IFUNC
14335 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
14336 outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
14337 else
14338 {
14339 outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
14340
14341 /* We need to relocate .opd contents for ld.so.
14342 Prelink also wants simple and consistent rules
14343 for relocs. This make all RELATIVE relocs have
14344 *r_offset equal to r_addend. */
14345 relocate = TRUE;
14346 }
14347 }
14348 else
14349 {
14350 long indx = 0;
14351
14352 if (h != NULL
14353 ? h->elf.type == STT_GNU_IFUNC
14354 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
14355 {
14356 info->callbacks->einfo
14357 (_("%P: %H: %s for indirect "
14358 "function `%T' unsupported\n"),
14359 input_bfd, input_section, rel->r_offset,
14360 ppc64_elf_howto_table[r_type]->name,
14361 sym_name);
14362 ret = FALSE;
14363 }
14364 else if (r_symndx == STN_UNDEF || bfd_is_abs_section (sec))
14365 ;
14366 else if (sec == NULL || sec->owner == NULL)
14367 {
14368 bfd_set_error (bfd_error_bad_value);
14369 return FALSE;
14370 }
14371 else
14372 {
14373 asection *osec;
14374
14375 osec = sec->output_section;
14376 indx = elf_section_data (osec)->dynindx;
14377
14378 if (indx == 0)
14379 {
14380 if ((osec->flags & SEC_READONLY) == 0
14381 && htab->elf.data_index_section != NULL)
14382 osec = htab->elf.data_index_section;
14383 else
14384 osec = htab->elf.text_index_section;
14385 indx = elf_section_data (osec)->dynindx;
14386 }
14387 BFD_ASSERT (indx != 0);
14388
14389 /* We are turning this relocation into one
14390 against a section symbol, so subtract out
14391 the output section's address but not the
14392 offset of the input section in the output
14393 section. */
14394 outrel.r_addend -= osec->vma;
14395 }
14396
14397 outrel.r_info = ELF64_R_INFO (indx, r_type);
14398 }
14399 }
14400
14401 sreloc = elf_section_data (input_section)->sreloc;
14402 if (h != NULL
14403 ? h->elf.type == STT_GNU_IFUNC
14404 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
14405 sreloc = htab->elf.irelplt;
14406 if (sreloc == NULL)
14407 abort ();
14408
14409 if (sreloc->reloc_count * sizeof (Elf64_External_Rela)
14410 >= sreloc->size)
14411 abort ();
14412 loc = sreloc->contents;
14413 loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
14414 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
14415
14416 /* If this reloc is against an external symbol, it will
14417 be computed at runtime, so there's no need to do
14418 anything now. However, for the sake of prelink ensure
14419 that the section contents are a known value. */
14420 if (! relocate)
14421 {
14422 unresolved_reloc = FALSE;
14423 /* The value chosen here is quite arbitrary as ld.so
14424 ignores section contents except for the special
14425 case of .opd where the contents might be accessed
14426 before relocation. Choose zero, as that won't
14427 cause reloc overflow. */
14428 relocation = 0;
14429 addend = 0;
14430 /* Use *r_offset == r_addend for R_PPC64_ADDR64 relocs
14431 to improve backward compatibility with older
14432 versions of ld. */
14433 if (r_type == R_PPC64_ADDR64)
14434 addend = outrel.r_addend;
14435 /* Adjust pc_relative relocs to have zero in *r_offset. */
14436 else if (ppc64_elf_howto_table[r_type]->pc_relative)
14437 addend = (input_section->output_section->vma
14438 + input_section->output_offset
14439 + rel->r_offset);
14440 }
14441 }
14442 break;
14443
14444 case R_PPC64_COPY:
14445 case R_PPC64_GLOB_DAT:
14446 case R_PPC64_JMP_SLOT:
14447 case R_PPC64_JMP_IREL:
14448 case R_PPC64_RELATIVE:
14449 /* We shouldn't ever see these dynamic relocs in relocatable
14450 files. */
14451 /* Fall through. */
14452
14453 case R_PPC64_PLTGOT16:
14454 case R_PPC64_PLTGOT16_DS:
14455 case R_PPC64_PLTGOT16_HA:
14456 case R_PPC64_PLTGOT16_HI:
14457 case R_PPC64_PLTGOT16_LO:
14458 case R_PPC64_PLTGOT16_LO_DS:
14459 case R_PPC64_PLTREL32:
14460 case R_PPC64_PLTREL64:
14461 /* These ones haven't been implemented yet. */
14462
14463 info->callbacks->einfo
14464 (_("%P: %B: %s is not supported for `%T'\n"),
14465 input_bfd,
14466 ppc64_elf_howto_table[r_type]->name, sym_name);
14467
14468 bfd_set_error (bfd_error_invalid_operation);
14469 ret = FALSE;
14470 continue;
14471 }
14472
14473 /* Multi-instruction sequences that access the TOC can be
14474 optimized, eg. addis ra,r2,0; addi rb,ra,x;
14475 to nop; addi rb,r2,x; */
14476 switch (r_type)
14477 {
14478 default:
14479 break;
14480
14481 case R_PPC64_GOT_TLSLD16_HI:
14482 case R_PPC64_GOT_TLSGD16_HI:
14483 case R_PPC64_GOT_TPREL16_HI:
14484 case R_PPC64_GOT_DTPREL16_HI:
14485 case R_PPC64_GOT16_HI:
14486 case R_PPC64_TOC16_HI:
14487 /* These relocs would only be useful if building up an
14488 offset to later add to r2, perhaps in an indexed
14489 addressing mode instruction. Don't try to optimize.
14490 Unfortunately, the possibility of someone building up an
14491 offset like this or even with the HA relocs, means that
14492 we need to check the high insn when optimizing the low
14493 insn. */
14494 break;
14495
14496 case R_PPC64_GOT_TLSLD16_HA:
14497 case R_PPC64_GOT_TLSGD16_HA:
14498 case R_PPC64_GOT_TPREL16_HA:
14499 case R_PPC64_GOT_DTPREL16_HA:
14500 case R_PPC64_GOT16_HA:
14501 case R_PPC64_TOC16_HA:
14502 if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
14503 && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
14504 {
14505 bfd_byte *p = contents + (rel->r_offset & ~3);
14506 bfd_put_32 (input_bfd, NOP, p);
14507 }
14508 break;
14509
14510 case R_PPC64_GOT_TLSLD16_LO:
14511 case R_PPC64_GOT_TLSGD16_LO:
14512 case R_PPC64_GOT_TPREL16_LO_DS:
14513 case R_PPC64_GOT_DTPREL16_LO_DS:
14514 case R_PPC64_GOT16_LO:
14515 case R_PPC64_GOT16_LO_DS:
14516 case R_PPC64_TOC16_LO:
14517 case R_PPC64_TOC16_LO_DS:
14518 if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
14519 && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
14520 {
14521 bfd_byte *p = contents + (rel->r_offset & ~3);
14522 insn = bfd_get_32 (input_bfd, p);
14523 if ((insn & (0x3f << 26)) == 12u << 26 /* addic */)
14524 {
14525 /* Transform addic to addi when we change reg. */
14526 insn &= ~((0x3f << 26) | (0x1f << 16));
14527 insn |= (14u << 26) | (2 << 16);
14528 }
14529 else
14530 {
14531 insn &= ~(0x1f << 16);
14532 insn |= 2 << 16;
14533 }
14534 bfd_put_32 (input_bfd, insn, p);
14535 }
14536 break;
14537 }
14538
14539 /* Do any further special processing. */
14540 howto = ppc64_elf_howto_table[(int) r_type];
14541 switch (r_type)
14542 {
14543 default:
14544 break;
14545
14546 case R_PPC64_REL16_HA:
14547 case R_PPC64_ADDR16_HA:
14548 case R_PPC64_ADDR16_HIGHA:
14549 case R_PPC64_ADDR16_HIGHERA:
14550 case R_PPC64_ADDR16_HIGHESTA:
14551 case R_PPC64_TOC16_HA:
14552 case R_PPC64_SECTOFF_HA:
14553 case R_PPC64_TPREL16_HA:
14554 case R_PPC64_TPREL16_HIGHA:
14555 case R_PPC64_TPREL16_HIGHERA:
14556 case R_PPC64_TPREL16_HIGHESTA:
14557 case R_PPC64_DTPREL16_HA:
14558 case R_PPC64_DTPREL16_HIGHA:
14559 case R_PPC64_DTPREL16_HIGHERA:
14560 case R_PPC64_DTPREL16_HIGHESTA:
14561 /* It's just possible that this symbol is a weak symbol
14562 that's not actually defined anywhere. In that case,
14563 'sec' would be NULL, and we should leave the symbol
14564 alone (it will be set to zero elsewhere in the link). */
14565 if (sec == NULL)
14566 break;
14567 /* Fall thru */
14568
14569 case R_PPC64_GOT16_HA:
14570 case R_PPC64_PLTGOT16_HA:
14571 case R_PPC64_PLT16_HA:
14572 case R_PPC64_GOT_TLSGD16_HA:
14573 case R_PPC64_GOT_TLSLD16_HA:
14574 case R_PPC64_GOT_TPREL16_HA:
14575 case R_PPC64_GOT_DTPREL16_HA:
14576 /* Add 0x10000 if sign bit in 0:15 is set.
14577 Bits 0:15 are not used. */
14578 addend += 0x8000;
14579 break;
14580
14581 case R_PPC64_ADDR16_DS:
14582 case R_PPC64_ADDR16_LO_DS:
14583 case R_PPC64_GOT16_DS:
14584 case R_PPC64_GOT16_LO_DS:
14585 case R_PPC64_PLT16_LO_DS:
14586 case R_PPC64_SECTOFF_DS:
14587 case R_PPC64_SECTOFF_LO_DS:
14588 case R_PPC64_TOC16_DS:
14589 case R_PPC64_TOC16_LO_DS:
14590 case R_PPC64_PLTGOT16_DS:
14591 case R_PPC64_PLTGOT16_LO_DS:
14592 case R_PPC64_GOT_TPREL16_DS:
14593 case R_PPC64_GOT_TPREL16_LO_DS:
14594 case R_PPC64_GOT_DTPREL16_DS:
14595 case R_PPC64_GOT_DTPREL16_LO_DS:
14596 case R_PPC64_TPREL16_DS:
14597 case R_PPC64_TPREL16_LO_DS:
14598 case R_PPC64_DTPREL16_DS:
14599 case R_PPC64_DTPREL16_LO_DS:
14600 insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
14601 mask = 3;
14602 /* If this reloc is against an lq insn, then the value must be
14603 a multiple of 16. This is somewhat of a hack, but the
14604 "correct" way to do this by defining _DQ forms of all the
14605 _DS relocs bloats all reloc switches in this file. It
14606 doesn't seem to make much sense to use any of these relocs
14607 in data, so testing the insn should be safe. */
14608 if ((insn & (0x3f << 26)) == (56u << 26))
14609 mask = 15;
14610 if (((relocation + addend) & mask) != 0)
14611 {
14612 info->callbacks->einfo
14613 (_("%P: %H: error: %s not a multiple of %u\n"),
14614 input_bfd, input_section, rel->r_offset,
14615 howto->name,
14616 mask + 1);
14617 bfd_set_error (bfd_error_bad_value);
14618 ret = FALSE;
14619 continue;
14620 }
14621 break;
14622 }
14623
14624 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
14625 because such sections are not SEC_ALLOC and thus ld.so will
14626 not process them. */
14627 if (unresolved_reloc
14628 && !((input_section->flags & SEC_DEBUGGING) != 0
14629 && h->elf.def_dynamic)
14630 && _bfd_elf_section_offset (output_bfd, info, input_section,
14631 rel->r_offset) != (bfd_vma) -1)
14632 {
14633 info->callbacks->einfo
14634 (_("%P: %H: unresolvable %s against `%T'\n"),
14635 input_bfd, input_section, rel->r_offset,
14636 howto->name,
14637 h->elf.root.root.string);
14638 ret = FALSE;
14639 }
14640
14641 /* 16-bit fields in insns mostly have signed values, but a
14642 few insns have 16-bit unsigned values. Really, we should
14643 have different reloc types. */
14644 if (howto->complain_on_overflow != complain_overflow_dont
14645 && howto->dst_mask == 0xffff
14646 && (input_section->flags & SEC_CODE) != 0)
14647 {
14648 enum complain_overflow complain = complain_overflow_signed;
14649
14650 insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
14651 if ((insn & (0x3f << 26)) == 10u << 26 /* cmpli */)
14652 complain = complain_overflow_bitfield;
14653 else if (howto->rightshift == 0
14654 ? ((insn & (0x3f << 26)) == 28u << 26 /* andi */
14655 || (insn & (0x3f << 26)) == 24u << 26 /* ori */
14656 || (insn & (0x3f << 26)) == 26u << 26 /* xori */)
14657 : ((insn & (0x3f << 26)) == 29u << 26 /* andis */
14658 || (insn & (0x3f << 26)) == 25u << 26 /* oris */
14659 || (insn & (0x3f << 26)) == 27u << 26 /* xoris */))
14660 complain = complain_overflow_unsigned;
14661 if (howto->complain_on_overflow != complain)
14662 {
14663 alt_howto = *howto;
14664 alt_howto.complain_on_overflow = complain;
14665 howto = &alt_howto;
14666 }
14667 }
14668
14669 r = _bfd_final_link_relocate (howto, input_bfd, input_section, contents,
14670 rel->r_offset, relocation, addend);
14671
14672 if (r != bfd_reloc_ok)
14673 {
14674 char *more_info = NULL;
14675 const char *reloc_name = howto->name;
14676
14677 if (reloc_dest != DEST_NORMAL)
14678 {
14679 more_info = bfd_malloc (strlen (reloc_name) + 8);
14680 if (more_info != NULL)
14681 {
14682 strcpy (more_info, reloc_name);
14683 strcat (more_info, (reloc_dest == DEST_OPD
14684 ? " (OPD)" : " (stub)"));
14685 reloc_name = more_info;
14686 }
14687 }
14688
14689 if (r == bfd_reloc_overflow)
14690 {
14691 if (warned)
14692 continue;
14693 if (h != NULL
14694 && h->elf.root.type == bfd_link_hash_undefweak
14695 && howto->pc_relative)
14696 {
14697 /* Assume this is a call protected by other code that
14698 detects the symbol is undefined. If this is the case,
14699 we can safely ignore the overflow. If not, the
14700 program is hosed anyway, and a little warning isn't
14701 going to help. */
14702
14703 continue;
14704 }
14705
14706 if (!((*info->callbacks->reloc_overflow)
14707 (info, &h->elf.root, sym_name,
14708 reloc_name, orig_rel.r_addend,
14709 input_bfd, input_section, rel->r_offset)))
14710 return FALSE;
14711 }
14712 else
14713 {
14714 info->callbacks->einfo
14715 (_("%P: %H: %s against `%T': error %d\n"),
14716 input_bfd, input_section, rel->r_offset,
14717 reloc_name, sym_name, (int) r);
14718 ret = FALSE;
14719 }
14720 if (more_info != NULL)
14721 free (more_info);
14722 }
14723 }
14724
14725 /* If we're emitting relocations, then shortly after this function
14726 returns, reloc offsets and addends for this section will be
14727 adjusted. Worse, reloc symbol indices will be for the output
14728 file rather than the input. Save a copy of the relocs for
14729 opd_entry_value. */
14730 if (is_opd && (info->emitrelocations || info->relocatable))
14731 {
14732 bfd_size_type amt;
14733 amt = input_section->reloc_count * sizeof (Elf_Internal_Rela);
14734 rel = bfd_alloc (input_bfd, amt);
14735 BFD_ASSERT (ppc64_elf_tdata (input_bfd)->opd.relocs == NULL);
14736 ppc64_elf_tdata (input_bfd)->opd.relocs = rel;
14737 if (rel == NULL)
14738 return FALSE;
14739 memcpy (rel, relocs, amt);
14740 }
14741 return ret;
14742 }
14743
14744 /* Adjust the value of any local symbols in opd sections. */
14745
14746 static int
14747 ppc64_elf_output_symbol_hook (struct bfd_link_info *info,
14748 const char *name ATTRIBUTE_UNUSED,
14749 Elf_Internal_Sym *elfsym,
14750 asection *input_sec,
14751 struct elf_link_hash_entry *h)
14752 {
14753 struct _opd_sec_data *opd;
14754 long adjust;
14755 bfd_vma value;
14756
14757 if (h != NULL)
14758 return 1;
14759
14760 opd = get_opd_info (input_sec);
14761 if (opd == NULL || opd->adjust == NULL)
14762 return 1;
14763
14764 value = elfsym->st_value - input_sec->output_offset;
14765 if (!info->relocatable)
14766 value -= input_sec->output_section->vma;
14767
14768 adjust = opd->adjust[value / 8];
14769 if (adjust == -1)
14770 return 2;
14771
14772 elfsym->st_value += adjust;
14773 return 1;
14774 }
14775
14776 /* Finish up dynamic symbol handling. We set the contents of various
14777 dynamic sections here. */
14778
14779 static bfd_boolean
14780 ppc64_elf_finish_dynamic_symbol (bfd *output_bfd,
14781 struct bfd_link_info *info,
14782 struct elf_link_hash_entry *h,
14783 Elf_Internal_Sym *sym ATTRIBUTE_UNUSED)
14784 {
14785 struct ppc_link_hash_table *htab;
14786 struct plt_entry *ent;
14787 Elf_Internal_Rela rela;
14788 bfd_byte *loc;
14789
14790 htab = ppc_hash_table (info);
14791 if (htab == NULL)
14792 return FALSE;
14793
14794 for (ent = h->plt.plist; ent != NULL; ent = ent->next)
14795 if (ent->plt.offset != (bfd_vma) -1)
14796 {
14797 /* This symbol has an entry in the procedure linkage
14798 table. Set it up. */
14799 if (!htab->elf.dynamic_sections_created
14800 || h->dynindx == -1)
14801 {
14802 BFD_ASSERT (h->type == STT_GNU_IFUNC
14803 && h->def_regular
14804 && (h->root.type == bfd_link_hash_defined
14805 || h->root.type == bfd_link_hash_defweak));
14806 rela.r_offset = (htab->elf.iplt->output_section->vma
14807 + htab->elf.iplt->output_offset
14808 + ent->plt.offset);
14809 if (htab->opd_abi)
14810 rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
14811 else
14812 rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
14813 rela.r_addend = (h->root.u.def.value
14814 + h->root.u.def.section->output_offset
14815 + h->root.u.def.section->output_section->vma
14816 + ent->addend);
14817 loc = (htab->elf.irelplt->contents
14818 + (htab->elf.irelplt->reloc_count++
14819 * sizeof (Elf64_External_Rela)));
14820 }
14821 else
14822 {
14823 rela.r_offset = (htab->elf.splt->output_section->vma
14824 + htab->elf.splt->output_offset
14825 + ent->plt.offset);
14826 rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_JMP_SLOT);
14827 rela.r_addend = ent->addend;
14828 loc = (htab->elf.srelplt->contents
14829 + ((ent->plt.offset - PLT_INITIAL_ENTRY_SIZE (htab))
14830 / PLT_ENTRY_SIZE (htab) * sizeof (Elf64_External_Rela)));
14831 }
14832 bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
14833
14834 if (!htab->opd_abi)
14835 {
14836 if (!h->def_regular)
14837 {
14838 /* Mark the symbol as undefined, rather than as
14839 defined in glink. Leave the value if there were
14840 any relocations where pointer equality matters
14841 (this is a clue for the dynamic linker, to make
14842 function pointer comparisons work between an
14843 application and shared library), otherwise set it
14844 to zero. */
14845 sym->st_shndx = SHN_UNDEF;
14846 if (!h->pointer_equality_needed)
14847 sym->st_value = 0;
14848 else if (!h->ref_regular_nonweak)
14849 {
14850 /* This breaks function pointer comparisons, but
14851 that is better than breaking tests for a NULL
14852 function pointer. */
14853 sym->st_value = 0;
14854 }
14855 }
14856 }
14857 }
14858
14859 if (h->needs_copy)
14860 {
14861 /* This symbol needs a copy reloc. Set it up. */
14862
14863 if (h->dynindx == -1
14864 || (h->root.type != bfd_link_hash_defined
14865 && h->root.type != bfd_link_hash_defweak)
14866 || htab->relbss == NULL)
14867 abort ();
14868
14869 rela.r_offset = (h->root.u.def.value
14870 + h->root.u.def.section->output_section->vma
14871 + h->root.u.def.section->output_offset);
14872 rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_COPY);
14873 rela.r_addend = 0;
14874 loc = htab->relbss->contents;
14875 loc += htab->relbss->reloc_count++ * sizeof (Elf64_External_Rela);
14876 bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
14877 }
14878
14879 return TRUE;
14880 }
14881
14882 /* Used to decide how to sort relocs in an optimal manner for the
14883 dynamic linker, before writing them out. */
14884
14885 static enum elf_reloc_type_class
14886 ppc64_elf_reloc_type_class (const struct bfd_link_info *info,
14887 const asection *rel_sec,
14888 const Elf_Internal_Rela *rela)
14889 {
14890 enum elf_ppc64_reloc_type r_type;
14891 struct ppc_link_hash_table *htab = ppc_hash_table (info);
14892
14893 if (rel_sec == htab->elf.irelplt)
14894 return reloc_class_ifunc;
14895
14896 r_type = ELF64_R_TYPE (rela->r_info);
14897 switch (r_type)
14898 {
14899 case R_PPC64_RELATIVE:
14900 return reloc_class_relative;
14901 case R_PPC64_JMP_SLOT:
14902 return reloc_class_plt;
14903 case R_PPC64_COPY:
14904 return reloc_class_copy;
14905 default:
14906 return reloc_class_normal;
14907 }
14908 }
14909
14910 /* Finish up the dynamic sections. */
14911
14912 static bfd_boolean
14913 ppc64_elf_finish_dynamic_sections (bfd *output_bfd,
14914 struct bfd_link_info *info)
14915 {
14916 struct ppc_link_hash_table *htab;
14917 bfd *dynobj;
14918 asection *sdyn;
14919
14920 htab = ppc_hash_table (info);
14921 if (htab == NULL)
14922 return FALSE;
14923
14924 dynobj = htab->elf.dynobj;
14925 sdyn = bfd_get_linker_section (dynobj, ".dynamic");
14926
14927 if (htab->elf.dynamic_sections_created)
14928 {
14929 Elf64_External_Dyn *dyncon, *dynconend;
14930
14931 if (sdyn == NULL || htab->elf.sgot == NULL)
14932 abort ();
14933
14934 dyncon = (Elf64_External_Dyn *) sdyn->contents;
14935 dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
14936 for (; dyncon < dynconend; dyncon++)
14937 {
14938 Elf_Internal_Dyn dyn;
14939 asection *s;
14940
14941 bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
14942
14943 switch (dyn.d_tag)
14944 {
14945 default:
14946 continue;
14947
14948 case DT_PPC64_GLINK:
14949 s = htab->glink;
14950 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
14951 /* We stupidly defined DT_PPC64_GLINK to be the start
14952 of glink rather than the first entry point, which is
14953 what ld.so needs, and now have a bigger stub to
14954 support automatic multiple TOCs. */
14955 dyn.d_un.d_ptr += GLINK_CALL_STUB_SIZE - 8 * 4;
14956 break;
14957
14958 case DT_PPC64_OPD:
14959 s = bfd_get_section_by_name (output_bfd, ".opd");
14960 if (s == NULL)
14961 continue;
14962 dyn.d_un.d_ptr = s->vma;
14963 break;
14964
14965 case DT_PPC64_OPT:
14966 if (htab->do_multi_toc && htab->multi_toc_needed)
14967 dyn.d_un.d_val |= PPC64_OPT_MULTI_TOC;
14968 break;
14969
14970 case DT_PPC64_OPDSZ:
14971 s = bfd_get_section_by_name (output_bfd, ".opd");
14972 if (s == NULL)
14973 continue;
14974 dyn.d_un.d_val = s->size;
14975 break;
14976
14977 case DT_PLTGOT:
14978 s = htab->elf.splt;
14979 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
14980 break;
14981
14982 case DT_JMPREL:
14983 s = htab->elf.srelplt;
14984 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
14985 break;
14986
14987 case DT_PLTRELSZ:
14988 dyn.d_un.d_val = htab->elf.srelplt->size;
14989 break;
14990
14991 case DT_RELASZ:
14992 /* Don't count procedure linkage table relocs in the
14993 overall reloc count. */
14994 s = htab->elf.srelplt;
14995 if (s == NULL)
14996 continue;
14997 dyn.d_un.d_val -= s->size;
14998 break;
14999
15000 case DT_RELA:
15001 /* We may not be using the standard ELF linker script.
15002 If .rela.plt is the first .rela section, we adjust
15003 DT_RELA to not include it. */
15004 s = htab->elf.srelplt;
15005 if (s == NULL)
15006 continue;
15007 if (dyn.d_un.d_ptr != s->output_section->vma + s->output_offset)
15008 continue;
15009 dyn.d_un.d_ptr += s->size;
15010 break;
15011 }
15012
15013 bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
15014 }
15015 }
15016
15017 if (htab->elf.sgot != NULL && htab->elf.sgot->size != 0)
15018 {
15019 /* Fill in the first entry in the global offset table.
15020 We use it to hold the link-time TOCbase. */
15021 bfd_put_64 (output_bfd,
15022 elf_gp (output_bfd) + TOC_BASE_OFF,
15023 htab->elf.sgot->contents);
15024
15025 /* Set .got entry size. */
15026 elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize = 8;
15027 }
15028
15029 if (htab->elf.splt != NULL && htab->elf.splt->size != 0)
15030 {
15031 /* Set .plt entry size. */
15032 elf_section_data (htab->elf.splt->output_section)->this_hdr.sh_entsize
15033 = PLT_ENTRY_SIZE (htab);
15034 }
15035
15036 /* brlt is SEC_LINKER_CREATED, so we need to write out relocs for
15037 brlt ourselves if emitrelocations. */
15038 if (htab->brlt != NULL
15039 && htab->brlt->reloc_count != 0
15040 && !_bfd_elf_link_output_relocs (output_bfd,
15041 htab->brlt,
15042 elf_section_data (htab->brlt)->rela.hdr,
15043 elf_section_data (htab->brlt)->relocs,
15044 NULL))
15045 return FALSE;
15046
15047 if (htab->glink != NULL
15048 && htab->glink->reloc_count != 0
15049 && !_bfd_elf_link_output_relocs (output_bfd,
15050 htab->glink,
15051 elf_section_data (htab->glink)->rela.hdr,
15052 elf_section_data (htab->glink)->relocs,
15053 NULL))
15054 return FALSE;
15055
15056
15057 if (htab->glink_eh_frame != NULL
15058 && htab->glink_eh_frame->sec_info_type == SEC_INFO_TYPE_EH_FRAME
15059 && !_bfd_elf_write_section_eh_frame (output_bfd, info,
15060 htab->glink_eh_frame,
15061 htab->glink_eh_frame->contents))
15062 return FALSE;
15063
15064 /* We need to handle writing out multiple GOT sections ourselves,
15065 since we didn't add them to DYNOBJ. We know dynobj is the first
15066 bfd. */
15067 while ((dynobj = dynobj->link.next) != NULL)
15068 {
15069 asection *s;
15070
15071 if (!is_ppc64_elf (dynobj))
15072 continue;
15073
15074 s = ppc64_elf_tdata (dynobj)->got;
15075 if (s != NULL
15076 && s->size != 0
15077 && s->output_section != bfd_abs_section_ptr
15078 && !bfd_set_section_contents (output_bfd, s->output_section,
15079 s->contents, s->output_offset,
15080 s->size))
15081 return FALSE;
15082 s = ppc64_elf_tdata (dynobj)->relgot;
15083 if (s != NULL
15084 && s->size != 0
15085 && s->output_section != bfd_abs_section_ptr
15086 && !bfd_set_section_contents (output_bfd, s->output_section,
15087 s->contents, s->output_offset,
15088 s->size))
15089 return FALSE;
15090 }
15091
15092 return TRUE;
15093 }
15094
15095 #include "elf64-target.h"
15096
15097 /* FreeBSD support */
15098
15099 #undef TARGET_LITTLE_SYM
15100 #undef TARGET_LITTLE_NAME
15101
15102 #undef TARGET_BIG_SYM
15103 #define TARGET_BIG_SYM powerpc_elf64_fbsd_vec
15104 #undef TARGET_BIG_NAME
15105 #define TARGET_BIG_NAME "elf64-powerpc-freebsd"
15106
15107 #undef ELF_OSABI
15108 #define ELF_OSABI ELFOSABI_FREEBSD
15109
15110 #undef elf64_bed
15111 #define elf64_bed elf64_powerpc_fbsd_bed
15112
15113 #include "elf64-target.h"
15114
GDB Binutils - Deliverables
This page took 0.392211 seconds and 5 git commands to generate.