projects / deliverable / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
alpha-bsd-nat: Use ptid from regcache instead of inferior_ptid
[deliverable/binutils-gdb.git] / bfd / elf64-ppc.c
1 /* PowerPC64-specific support for 64-bit ELF.
2 Copyright (C) 1999-2017 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 0x10000
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_want_dynrelro 1
76 #define elf_backend_can_gc_sections 1
77 #define elf_backend_can_refcount 1
78 #define elf_backend_rela_normal 1
79 #define elf_backend_dtrel_excludes_plt 1
80 #define elf_backend_default_execstack 0
81
82 #define bfd_elf64_mkobject ppc64_elf_mkobject
83 #define bfd_elf64_bfd_reloc_type_lookup ppc64_elf_reloc_type_lookup
84 #define bfd_elf64_bfd_reloc_name_lookup ppc64_elf_reloc_name_lookup
85 #define bfd_elf64_bfd_merge_private_bfd_data ppc64_elf_merge_private_bfd_data
86 #define bfd_elf64_bfd_print_private_bfd_data ppc64_elf_print_private_bfd_data
87 #define bfd_elf64_new_section_hook ppc64_elf_new_section_hook
88 #define bfd_elf64_bfd_link_hash_table_create ppc64_elf_link_hash_table_create
89 #define bfd_elf64_get_synthetic_symtab ppc64_elf_get_synthetic_symtab
90 #define bfd_elf64_bfd_link_just_syms ppc64_elf_link_just_syms
91 #define bfd_elf64_bfd_gc_sections ppc64_elf_gc_sections
92
93 #define elf_backend_object_p ppc64_elf_object_p
94 #define elf_backend_grok_prstatus ppc64_elf_grok_prstatus
95 #define elf_backend_grok_psinfo ppc64_elf_grok_psinfo
96 #define elf_backend_write_core_note ppc64_elf_write_core_note
97 #define elf_backend_create_dynamic_sections _bfd_elf_create_dynamic_sections
98 #define elf_backend_copy_indirect_symbol ppc64_elf_copy_indirect_symbol
99 #define elf_backend_add_symbol_hook ppc64_elf_add_symbol_hook
100 #define elf_backend_check_directives ppc64_elf_before_check_relocs
101 #define elf_backend_notice_as_needed ppc64_elf_notice_as_needed
102 #define elf_backend_archive_symbol_lookup ppc64_elf_archive_symbol_lookup
103 #define elf_backend_check_relocs ppc64_elf_check_relocs
104 #define elf_backend_gc_keep ppc64_elf_gc_keep
105 #define elf_backend_gc_mark_dynamic_ref ppc64_elf_gc_mark_dynamic_ref
106 #define elf_backend_gc_mark_hook ppc64_elf_gc_mark_hook
107 #define elf_backend_gc_sweep_hook ppc64_elf_gc_sweep_hook
108 #define elf_backend_adjust_dynamic_symbol ppc64_elf_adjust_dynamic_symbol
109 #define elf_backend_hide_symbol ppc64_elf_hide_symbol
110 #define elf_backend_maybe_function_sym ppc64_elf_maybe_function_sym
111 #define elf_backend_always_size_sections ppc64_elf_func_desc_adjust
112 #define elf_backend_size_dynamic_sections ppc64_elf_size_dynamic_sections
113 #define elf_backend_hash_symbol ppc64_elf_hash_symbol
114 #define elf_backend_init_index_section _bfd_elf_init_2_index_sections
115 #define elf_backend_action_discarded ppc64_elf_action_discarded
116 #define elf_backend_relocate_section ppc64_elf_relocate_section
117 #define elf_backend_finish_dynamic_symbol ppc64_elf_finish_dynamic_symbol
118 #define elf_backend_reloc_type_class ppc64_elf_reloc_type_class
119 #define elf_backend_finish_dynamic_sections ppc64_elf_finish_dynamic_sections
120 #define elf_backend_link_output_symbol_hook ppc64_elf_output_symbol_hook
121 #define elf_backend_special_sections ppc64_elf_special_sections
122 #define elf_backend_merge_symbol_attribute ppc64_elf_merge_symbol_attribute
123 #define elf_backend_merge_symbol ppc64_elf_merge_symbol
124
125 /* The name of the dynamic interpreter. This is put in the .interp
126 section. */
127 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
128
129 /* The size in bytes of an entry in the procedure linkage table. */
130 #define PLT_ENTRY_SIZE(htab) (htab->opd_abi ? 24 : 8)
131
132 /* The initial size of the plt reserved for the dynamic linker. */
133 #define PLT_INITIAL_ENTRY_SIZE(htab) (htab->opd_abi ? 24 : 16)
134
135 /* Offsets to some stack save slots. */
136 #define STK_LR 16
137 #define STK_TOC(htab) (htab->opd_abi ? 40 : 24)
138 /* This one is dodgy. ELFv2 does not have a linker word, so use the
139 CR save slot. Used only by optimised __tls_get_addr call stub,
140 relying on __tls_get_addr_opt not saving CR.. */
141 #define STK_LINKER(htab) (htab->opd_abi ? 32 : 8)
142
143 /* TOC base pointers offset from start of TOC. */
144 #define TOC_BASE_OFF 0x8000
145 /* TOC base alignment. */
146 #define TOC_BASE_ALIGN 256
147
148 /* Offset of tp and dtp pointers from start of TLS block. */
149 #define TP_OFFSET 0x7000
150 #define DTP_OFFSET 0x8000
151
152 /* .plt call stub instructions. The normal stub is like this, but
153 sometimes the .plt entry crosses a 64k boundary and we need to
154 insert an addi to adjust r11. */
155 #define STD_R2_0R1 0xf8410000 /* std %r2,0+40(%r1) */
156 #define ADDIS_R11_R2 0x3d620000 /* addis %r11,%r2,xxx@ha */
157 #define LD_R12_0R11 0xe98b0000 /* ld %r12,xxx+0@l(%r11) */
158 #define MTCTR_R12 0x7d8903a6 /* mtctr %r12 */
159 #define LD_R2_0R11 0xe84b0000 /* ld %r2,xxx+8@l(%r11) */
160 #define LD_R11_0R11 0xe96b0000 /* ld %r11,xxx+16@l(%r11) */
161 #define BCTR 0x4e800420 /* bctr */
162
163 #define ADDI_R11_R11 0x396b0000 /* addi %r11,%r11,off@l */
164 #define ADDIS_R2_R2 0x3c420000 /* addis %r2,%r2,off@ha */
165 #define ADDI_R2_R2 0x38420000 /* addi %r2,%r2,off@l */
166
167 #define XOR_R2_R12_R12 0x7d826278 /* xor %r2,%r12,%r12 */
168 #define ADD_R11_R11_R2 0x7d6b1214 /* add %r11,%r11,%r2 */
169 #define XOR_R11_R12_R12 0x7d8b6278 /* xor %r11,%r12,%r12 */
170 #define ADD_R2_R2_R11 0x7c425a14 /* add %r2,%r2,%r11 */
171 #define CMPLDI_R2_0 0x28220000 /* cmpldi %r2,0 */
172 #define BNECTR 0x4ca20420 /* bnectr+ */
173 #define BNECTR_P4 0x4ce20420 /* bnectr+ */
174
175 #define LD_R12_0R2 0xe9820000 /* ld %r12,xxx+0(%r2) */
176 #define LD_R11_0R2 0xe9620000 /* ld %r11,xxx+0(%r2) */
177 #define LD_R2_0R2 0xe8420000 /* ld %r2,xxx+0(%r2) */
178
179 #define LD_R2_0R1 0xe8410000 /* ld %r2,0(%r1) */
180 #define LD_R2_0R12 0xe84c0000 /* ld %r2,0(%r12) */
181 #define ADD_R2_R2_R12 0x7c426214 /* add %r2,%r2,%r12 */
182
183 #define LIS_R2 0x3c400000 /* lis %r2,xxx@ha */
184 #define ADDIS_R2_R12 0x3c4c0000 /* addis %r2,%r12,xxx@ha */
185 #define ADDIS_R12_R2 0x3d820000 /* addis %r12,%r2,xxx@ha */
186 #define ADDIS_R12_R12 0x3d8c0000 /* addis %r12,%r12,xxx@ha */
187 #define LD_R12_0R12 0xe98c0000 /* ld %r12,xxx@l(%r12) */
188
189 /* glink call stub instructions. We enter with the index in R0. */
190 #define GLINK_CALL_STUB_SIZE (16*4)
191 /* 0: */
192 /* .quad plt0-1f */
193 /* __glink: */
194 #define MFLR_R12 0x7d8802a6 /* mflr %12 */
195 #define BCL_20_31 0x429f0005 /* bcl 20,31,1f */
196 /* 1: */
197 #define MFLR_R11 0x7d6802a6 /* mflr %11 */
198 /* ld %2,(0b-1b)(%11) */
199 #define MTLR_R12 0x7d8803a6 /* mtlr %12 */
200 #define ADD_R11_R2_R11 0x7d625a14 /* add %11,%2,%11 */
201 /* ld %12,0(%11) */
202 /* ld %2,8(%11) */
203 /* mtctr %12 */
204 /* ld %11,16(%11) */
205 /* bctr */
206 #define MFLR_R0 0x7c0802a6 /* mflr %r0 */
207 #define MTLR_R0 0x7c0803a6 /* mtlr %r0 */
208 #define SUB_R12_R12_R11 0x7d8b6050 /* subf %r12,%r11,%r12 */
209 #define ADDI_R0_R12 0x380c0000 /* addi %r0,%r12,0 */
210 #define SRDI_R0_R0_2 0x7800f082 /* rldicl %r0,%r0,62,2 */
211
212 /* Pad with this. */
213 #define NOP 0x60000000
214
215 /* Some other nops. */
216 #define CROR_151515 0x4def7b82
217 #define CROR_313131 0x4ffffb82
218
219 /* .glink entries for the first 32k functions are two instructions. */
220 #define LI_R0_0 0x38000000 /* li %r0,0 */
221 #define B_DOT 0x48000000 /* b . */
222
223 /* After that, we need two instructions to load the index, followed by
224 a branch. */
225 #define LIS_R0_0 0x3c000000 /* lis %r0,0 */
226 #define ORI_R0_R0_0 0x60000000 /* ori %r0,%r0,0 */
227
228 /* Instructions used by the save and restore reg functions. */
229 #define STD_R0_0R1 0xf8010000 /* std %r0,0(%r1) */
230 #define STD_R0_0R12 0xf80c0000 /* std %r0,0(%r12) */
231 #define LD_R0_0R1 0xe8010000 /* ld %r0,0(%r1) */
232 #define LD_R0_0R12 0xe80c0000 /* ld %r0,0(%r12) */
233 #define STFD_FR0_0R1 0xd8010000 /* stfd %fr0,0(%r1) */
234 #define LFD_FR0_0R1 0xc8010000 /* lfd %fr0,0(%r1) */
235 #define LI_R12_0 0x39800000 /* li %r12,0 */
236 #define STVX_VR0_R12_R0 0x7c0c01ce /* stvx %v0,%r12,%r0 */
237 #define LVX_VR0_R12_R0 0x7c0c00ce /* lvx %v0,%r12,%r0 */
238 #define MTLR_R0 0x7c0803a6 /* mtlr %r0 */
239 #define BLR 0x4e800020 /* blr */
240
241 /* Since .opd is an array of descriptors and each entry will end up
242 with identical R_PPC64_RELATIVE relocs, there is really no need to
243 propagate .opd relocs; The dynamic linker should be taught to
244 relocate .opd without reloc entries. */
245 #ifndef NO_OPD_RELOCS
246 #define NO_OPD_RELOCS 0
247 #endif
248
249 #ifndef ARRAY_SIZE
250 #define ARRAY_SIZE(a) (sizeof (a) / sizeof ((a)[0]))
251 #endif
252
253 static inline int
254 abiversion (bfd *abfd)
255 {
256 return elf_elfheader (abfd)->e_flags & EF_PPC64_ABI;
257 }
258
259 static inline void
260 set_abiversion (bfd *abfd, int ver)
261 {
262 elf_elfheader (abfd)->e_flags &= ~EF_PPC64_ABI;
263 elf_elfheader (abfd)->e_flags |= ver & EF_PPC64_ABI;
264 }
265 \f
266 #define ONES(n) (((bfd_vma) 1 << ((n) - 1) << 1) - 1)
267
268 /* Relocation HOWTO's. */
269 static reloc_howto_type *ppc64_elf_howto_table[(int) R_PPC64_max];
270
271 static reloc_howto_type ppc64_elf_howto_raw[] = {
272 /* This reloc does nothing. */
273 HOWTO (R_PPC64_NONE, /* type */
274 0, /* rightshift */
275 3, /* size (0 = byte, 1 = short, 2 = long) */
276 0, /* bitsize */
277 FALSE, /* pc_relative */
278 0, /* bitpos */
279 complain_overflow_dont, /* complain_on_overflow */
280 bfd_elf_generic_reloc, /* special_function */
281 "R_PPC64_NONE", /* name */
282 FALSE, /* partial_inplace */
283 0, /* src_mask */
284 0, /* dst_mask */
285 FALSE), /* pcrel_offset */
286
287 /* A standard 32 bit relocation. */
288 HOWTO (R_PPC64_ADDR32, /* type */
289 0, /* rightshift */
290 2, /* size (0 = byte, 1 = short, 2 = long) */
291 32, /* bitsize */
292 FALSE, /* pc_relative */
293 0, /* bitpos */
294 complain_overflow_bitfield, /* complain_on_overflow */
295 bfd_elf_generic_reloc, /* special_function */
296 "R_PPC64_ADDR32", /* name */
297 FALSE, /* partial_inplace */
298 0, /* src_mask */
299 0xffffffff, /* dst_mask */
300 FALSE), /* pcrel_offset */
301
302 /* An absolute 26 bit branch; the lower two bits must be zero.
303 FIXME: we don't check that, we just clear them. */
304 HOWTO (R_PPC64_ADDR24, /* type */
305 0, /* rightshift */
306 2, /* size (0 = byte, 1 = short, 2 = long) */
307 26, /* bitsize */
308 FALSE, /* pc_relative */
309 0, /* bitpos */
310 complain_overflow_bitfield, /* complain_on_overflow */
311 bfd_elf_generic_reloc, /* special_function */
312 "R_PPC64_ADDR24", /* name */
313 FALSE, /* partial_inplace */
314 0, /* src_mask */
315 0x03fffffc, /* dst_mask */
316 FALSE), /* pcrel_offset */
317
318 /* A standard 16 bit relocation. */
319 HOWTO (R_PPC64_ADDR16, /* type */
320 0, /* rightshift */
321 1, /* size (0 = byte, 1 = short, 2 = long) */
322 16, /* bitsize */
323 FALSE, /* pc_relative */
324 0, /* bitpos */
325 complain_overflow_bitfield, /* complain_on_overflow */
326 bfd_elf_generic_reloc, /* special_function */
327 "R_PPC64_ADDR16", /* name */
328 FALSE, /* partial_inplace */
329 0, /* src_mask */
330 0xffff, /* dst_mask */
331 FALSE), /* pcrel_offset */
332
333 /* A 16 bit relocation without overflow. */
334 HOWTO (R_PPC64_ADDR16_LO, /* type */
335 0, /* rightshift */
336 1, /* size (0 = byte, 1 = short, 2 = long) */
337 16, /* bitsize */
338 FALSE, /* pc_relative */
339 0, /* bitpos */
340 complain_overflow_dont,/* complain_on_overflow */
341 bfd_elf_generic_reloc, /* special_function */
342 "R_PPC64_ADDR16_LO", /* name */
343 FALSE, /* partial_inplace */
344 0, /* src_mask */
345 0xffff, /* dst_mask */
346 FALSE), /* pcrel_offset */
347
348 /* Bits 16-31 of an address. */
349 HOWTO (R_PPC64_ADDR16_HI, /* type */
350 16, /* rightshift */
351 1, /* size (0 = byte, 1 = short, 2 = long) */
352 16, /* bitsize */
353 FALSE, /* pc_relative */
354 0, /* bitpos */
355 complain_overflow_signed, /* complain_on_overflow */
356 bfd_elf_generic_reloc, /* special_function */
357 "R_PPC64_ADDR16_HI", /* name */
358 FALSE, /* partial_inplace */
359 0, /* src_mask */
360 0xffff, /* dst_mask */
361 FALSE), /* pcrel_offset */
362
363 /* Bits 16-31 of an address, plus 1 if the contents of the low 16
364 bits, treated as a signed number, is negative. */
365 HOWTO (R_PPC64_ADDR16_HA, /* type */
366 16, /* rightshift */
367 1, /* size (0 = byte, 1 = short, 2 = long) */
368 16, /* bitsize */
369 FALSE, /* pc_relative */
370 0, /* bitpos */
371 complain_overflow_signed, /* complain_on_overflow */
372 ppc64_elf_ha_reloc, /* special_function */
373 "R_PPC64_ADDR16_HA", /* name */
374 FALSE, /* partial_inplace */
375 0, /* src_mask */
376 0xffff, /* dst_mask */
377 FALSE), /* pcrel_offset */
378
379 /* An absolute 16 bit branch; the lower two bits must be zero.
380 FIXME: we don't check that, we just clear them. */
381 HOWTO (R_PPC64_ADDR14, /* type */
382 0, /* rightshift */
383 2, /* size (0 = byte, 1 = short, 2 = long) */
384 16, /* bitsize */
385 FALSE, /* pc_relative */
386 0, /* bitpos */
387 complain_overflow_signed, /* complain_on_overflow */
388 ppc64_elf_branch_reloc, /* special_function */
389 "R_PPC64_ADDR14", /* name */
390 FALSE, /* partial_inplace */
391 0, /* src_mask */
392 0x0000fffc, /* dst_mask */
393 FALSE), /* pcrel_offset */
394
395 /* An absolute 16 bit branch, for which bit 10 should be set to
396 indicate that the branch is expected to be taken. The lower two
397 bits must be zero. */
398 HOWTO (R_PPC64_ADDR14_BRTAKEN, /* type */
399 0, /* rightshift */
400 2, /* size (0 = byte, 1 = short, 2 = long) */
401 16, /* bitsize */
402 FALSE, /* pc_relative */
403 0, /* bitpos */
404 complain_overflow_signed, /* complain_on_overflow */
405 ppc64_elf_brtaken_reloc, /* special_function */
406 "R_PPC64_ADDR14_BRTAKEN",/* name */
407 FALSE, /* partial_inplace */
408 0, /* src_mask */
409 0x0000fffc, /* dst_mask */
410 FALSE), /* pcrel_offset */
411
412 /* An absolute 16 bit branch, for which bit 10 should be set to
413 indicate that the branch is not expected to be taken. The lower
414 two bits must be zero. */
415 HOWTO (R_PPC64_ADDR14_BRNTAKEN, /* type */
416 0, /* rightshift */
417 2, /* size (0 = byte, 1 = short, 2 = long) */
418 16, /* bitsize */
419 FALSE, /* pc_relative */
420 0, /* bitpos */
421 complain_overflow_signed, /* complain_on_overflow */
422 ppc64_elf_brtaken_reloc, /* special_function */
423 "R_PPC64_ADDR14_BRNTAKEN",/* name */
424 FALSE, /* partial_inplace */
425 0, /* src_mask */
426 0x0000fffc, /* dst_mask */
427 FALSE), /* pcrel_offset */
428
429 /* A relative 26 bit branch; the lower two bits must be zero. */
430 HOWTO (R_PPC64_REL24, /* type */
431 0, /* rightshift */
432 2, /* size (0 = byte, 1 = short, 2 = long) */
433 26, /* bitsize */
434 TRUE, /* pc_relative */
435 0, /* bitpos */
436 complain_overflow_signed, /* complain_on_overflow */
437 ppc64_elf_branch_reloc, /* special_function */
438 "R_PPC64_REL24", /* name */
439 FALSE, /* partial_inplace */
440 0, /* src_mask */
441 0x03fffffc, /* dst_mask */
442 TRUE), /* pcrel_offset */
443
444 /* A relative 16 bit branch; the lower two bits must be zero. */
445 HOWTO (R_PPC64_REL14, /* type */
446 0, /* rightshift */
447 2, /* size (0 = byte, 1 = short, 2 = long) */
448 16, /* bitsize */
449 TRUE, /* pc_relative */
450 0, /* bitpos */
451 complain_overflow_signed, /* complain_on_overflow */
452 ppc64_elf_branch_reloc, /* special_function */
453 "R_PPC64_REL14", /* name */
454 FALSE, /* partial_inplace */
455 0, /* src_mask */
456 0x0000fffc, /* dst_mask */
457 TRUE), /* pcrel_offset */
458
459 /* A relative 16 bit branch. Bit 10 should be set to indicate that
460 the branch is expected to be taken. The lower two bits must be
461 zero. */
462 HOWTO (R_PPC64_REL14_BRTAKEN, /* type */
463 0, /* rightshift */
464 2, /* size (0 = byte, 1 = short, 2 = long) */
465 16, /* bitsize */
466 TRUE, /* pc_relative */
467 0, /* bitpos */
468 complain_overflow_signed, /* complain_on_overflow */
469 ppc64_elf_brtaken_reloc, /* special_function */
470 "R_PPC64_REL14_BRTAKEN", /* name */
471 FALSE, /* partial_inplace */
472 0, /* src_mask */
473 0x0000fffc, /* dst_mask */
474 TRUE), /* pcrel_offset */
475
476 /* A relative 16 bit branch. Bit 10 should be set to indicate that
477 the branch is not expected to be taken. The lower two bits must
478 be zero. */
479 HOWTO (R_PPC64_REL14_BRNTAKEN, /* type */
480 0, /* rightshift */
481 2, /* size (0 = byte, 1 = short, 2 = long) */
482 16, /* bitsize */
483 TRUE, /* pc_relative */
484 0, /* bitpos */
485 complain_overflow_signed, /* complain_on_overflow */
486 ppc64_elf_brtaken_reloc, /* special_function */
487 "R_PPC64_REL14_BRNTAKEN",/* name */
488 FALSE, /* partial_inplace */
489 0, /* src_mask */
490 0x0000fffc, /* dst_mask */
491 TRUE), /* pcrel_offset */
492
493 /* Like R_PPC64_ADDR16, but referring to the GOT table entry for the
494 symbol. */
495 HOWTO (R_PPC64_GOT16, /* type */
496 0, /* rightshift */
497 1, /* size (0 = byte, 1 = short, 2 = long) */
498 16, /* bitsize */
499 FALSE, /* pc_relative */
500 0, /* bitpos */
501 complain_overflow_signed, /* complain_on_overflow */
502 ppc64_elf_unhandled_reloc, /* special_function */
503 "R_PPC64_GOT16", /* name */
504 FALSE, /* partial_inplace */
505 0, /* src_mask */
506 0xffff, /* dst_mask */
507 FALSE), /* pcrel_offset */
508
509 /* Like R_PPC64_ADDR16_LO, but referring to the GOT table entry for
510 the symbol. */
511 HOWTO (R_PPC64_GOT16_LO, /* type */
512 0, /* rightshift */
513 1, /* size (0 = byte, 1 = short, 2 = long) */
514 16, /* bitsize */
515 FALSE, /* pc_relative */
516 0, /* bitpos */
517 complain_overflow_dont, /* complain_on_overflow */
518 ppc64_elf_unhandled_reloc, /* special_function */
519 "R_PPC64_GOT16_LO", /* name */
520 FALSE, /* partial_inplace */
521 0, /* src_mask */
522 0xffff, /* dst_mask */
523 FALSE), /* pcrel_offset */
524
525 /* Like R_PPC64_ADDR16_HI, but referring to the GOT table entry for
526 the symbol. */
527 HOWTO (R_PPC64_GOT16_HI, /* type */
528 16, /* rightshift */
529 1, /* size (0 = byte, 1 = short, 2 = long) */
530 16, /* bitsize */
531 FALSE, /* pc_relative */
532 0, /* bitpos */
533 complain_overflow_signed,/* complain_on_overflow */
534 ppc64_elf_unhandled_reloc, /* special_function */
535 "R_PPC64_GOT16_HI", /* name */
536 FALSE, /* partial_inplace */
537 0, /* src_mask */
538 0xffff, /* dst_mask */
539 FALSE), /* pcrel_offset */
540
541 /* Like R_PPC64_ADDR16_HA, but referring to the GOT table entry for
542 the symbol. */
543 HOWTO (R_PPC64_GOT16_HA, /* type */
544 16, /* rightshift */
545 1, /* size (0 = byte, 1 = short, 2 = long) */
546 16, /* bitsize */
547 FALSE, /* pc_relative */
548 0, /* bitpos */
549 complain_overflow_signed,/* complain_on_overflow */
550 ppc64_elf_unhandled_reloc, /* special_function */
551 "R_PPC64_GOT16_HA", /* name */
552 FALSE, /* partial_inplace */
553 0, /* src_mask */
554 0xffff, /* dst_mask */
555 FALSE), /* pcrel_offset */
556
557 /* This is used only by the dynamic linker. The symbol should exist
558 both in the object being run and in some shared library. The
559 dynamic linker copies the data addressed by the symbol from the
560 shared library into the object, because the object being
561 run has to have the data at some particular address. */
562 HOWTO (R_PPC64_COPY, /* type */
563 0, /* rightshift */
564 0, /* this one is variable size */
565 0, /* bitsize */
566 FALSE, /* pc_relative */
567 0, /* bitpos */
568 complain_overflow_dont, /* complain_on_overflow */
569 ppc64_elf_unhandled_reloc, /* special_function */
570 "R_PPC64_COPY", /* name */
571 FALSE, /* partial_inplace */
572 0, /* src_mask */
573 0, /* dst_mask */
574 FALSE), /* pcrel_offset */
575
576 /* Like R_PPC64_ADDR64, but used when setting global offset table
577 entries. */
578 HOWTO (R_PPC64_GLOB_DAT, /* type */
579 0, /* rightshift */
580 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
581 64, /* bitsize */
582 FALSE, /* pc_relative */
583 0, /* bitpos */
584 complain_overflow_dont, /* complain_on_overflow */
585 ppc64_elf_unhandled_reloc, /* special_function */
586 "R_PPC64_GLOB_DAT", /* name */
587 FALSE, /* partial_inplace */
588 0, /* src_mask */
589 ONES (64), /* dst_mask */
590 FALSE), /* pcrel_offset */
591
592 /* Created by the link editor. Marks a procedure linkage table
593 entry for a symbol. */
594 HOWTO (R_PPC64_JMP_SLOT, /* type */
595 0, /* rightshift */
596 0, /* size (0 = byte, 1 = short, 2 = long) */
597 0, /* bitsize */
598 FALSE, /* pc_relative */
599 0, /* bitpos */
600 complain_overflow_dont, /* complain_on_overflow */
601 ppc64_elf_unhandled_reloc, /* special_function */
602 "R_PPC64_JMP_SLOT", /* name */
603 FALSE, /* partial_inplace */
604 0, /* src_mask */
605 0, /* dst_mask */
606 FALSE), /* pcrel_offset */
607
608 /* Used only by the dynamic linker. When the object is run, this
609 doubleword64 is set to the load address of the object, plus the
610 addend. */
611 HOWTO (R_PPC64_RELATIVE, /* type */
612 0, /* rightshift */
613 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
614 64, /* bitsize */
615 FALSE, /* pc_relative */
616 0, /* bitpos */
617 complain_overflow_dont, /* complain_on_overflow */
618 bfd_elf_generic_reloc, /* special_function */
619 "R_PPC64_RELATIVE", /* name */
620 FALSE, /* partial_inplace */
621 0, /* src_mask */
622 ONES (64), /* dst_mask */
623 FALSE), /* pcrel_offset */
624
625 /* Like R_PPC64_ADDR32, but may be unaligned. */
626 HOWTO (R_PPC64_UADDR32, /* type */
627 0, /* rightshift */
628 2, /* size (0 = byte, 1 = short, 2 = long) */
629 32, /* bitsize */
630 FALSE, /* pc_relative */
631 0, /* bitpos */
632 complain_overflow_bitfield, /* complain_on_overflow */
633 bfd_elf_generic_reloc, /* special_function */
634 "R_PPC64_UADDR32", /* name */
635 FALSE, /* partial_inplace */
636 0, /* src_mask */
637 0xffffffff, /* dst_mask */
638 FALSE), /* pcrel_offset */
639
640 /* Like R_PPC64_ADDR16, but may be unaligned. */
641 HOWTO (R_PPC64_UADDR16, /* type */
642 0, /* rightshift */
643 1, /* size (0 = byte, 1 = short, 2 = long) */
644 16, /* bitsize */
645 FALSE, /* pc_relative */
646 0, /* bitpos */
647 complain_overflow_bitfield, /* complain_on_overflow */
648 bfd_elf_generic_reloc, /* special_function */
649 "R_PPC64_UADDR16", /* name */
650 FALSE, /* partial_inplace */
651 0, /* src_mask */
652 0xffff, /* dst_mask */
653 FALSE), /* pcrel_offset */
654
655 /* 32-bit PC relative. */
656 HOWTO (R_PPC64_REL32, /* type */
657 0, /* rightshift */
658 2, /* size (0 = byte, 1 = short, 2 = long) */
659 32, /* bitsize */
660 TRUE, /* pc_relative */
661 0, /* bitpos */
662 complain_overflow_signed, /* complain_on_overflow */
663 bfd_elf_generic_reloc, /* special_function */
664 "R_PPC64_REL32", /* name */
665 FALSE, /* partial_inplace */
666 0, /* src_mask */
667 0xffffffff, /* dst_mask */
668 TRUE), /* pcrel_offset */
669
670 /* 32-bit relocation to the symbol's procedure linkage table. */
671 HOWTO (R_PPC64_PLT32, /* type */
672 0, /* rightshift */
673 2, /* size (0 = byte, 1 = short, 2 = long) */
674 32, /* bitsize */
675 FALSE, /* pc_relative */
676 0, /* bitpos */
677 complain_overflow_bitfield, /* complain_on_overflow */
678 ppc64_elf_unhandled_reloc, /* special_function */
679 "R_PPC64_PLT32", /* name */
680 FALSE, /* partial_inplace */
681 0, /* src_mask */
682 0xffffffff, /* dst_mask */
683 FALSE), /* pcrel_offset */
684
685 /* 32-bit PC relative relocation to the symbol's procedure linkage table.
686 FIXME: R_PPC64_PLTREL32 not supported. */
687 HOWTO (R_PPC64_PLTREL32, /* type */
688 0, /* rightshift */
689 2, /* size (0 = byte, 1 = short, 2 = long) */
690 32, /* bitsize */
691 TRUE, /* pc_relative */
692 0, /* bitpos */
693 complain_overflow_signed, /* complain_on_overflow */
694 ppc64_elf_unhandled_reloc, /* special_function */
695 "R_PPC64_PLTREL32", /* name */
696 FALSE, /* partial_inplace */
697 0, /* src_mask */
698 0xffffffff, /* dst_mask */
699 TRUE), /* pcrel_offset */
700
701 /* Like R_PPC64_ADDR16_LO, but referring to the PLT table entry for
702 the symbol. */
703 HOWTO (R_PPC64_PLT16_LO, /* type */
704 0, /* rightshift */
705 1, /* size (0 = byte, 1 = short, 2 = long) */
706 16, /* bitsize */
707 FALSE, /* pc_relative */
708 0, /* bitpos */
709 complain_overflow_dont, /* complain_on_overflow */
710 ppc64_elf_unhandled_reloc, /* special_function */
711 "R_PPC64_PLT16_LO", /* name */
712 FALSE, /* partial_inplace */
713 0, /* src_mask */
714 0xffff, /* dst_mask */
715 FALSE), /* pcrel_offset */
716
717 /* Like R_PPC64_ADDR16_HI, but referring to the PLT table entry for
718 the symbol. */
719 HOWTO (R_PPC64_PLT16_HI, /* type */
720 16, /* rightshift */
721 1, /* size (0 = byte, 1 = short, 2 = long) */
722 16, /* bitsize */
723 FALSE, /* pc_relative */
724 0, /* bitpos */
725 complain_overflow_signed, /* complain_on_overflow */
726 ppc64_elf_unhandled_reloc, /* special_function */
727 "R_PPC64_PLT16_HI", /* name */
728 FALSE, /* partial_inplace */
729 0, /* src_mask */
730 0xffff, /* dst_mask */
731 FALSE), /* pcrel_offset */
732
733 /* Like R_PPC64_ADDR16_HA, but referring to the PLT table entry for
734 the symbol. */
735 HOWTO (R_PPC64_PLT16_HA, /* type */
736 16, /* rightshift */
737 1, /* size (0 = byte, 1 = short, 2 = long) */
738 16, /* bitsize */
739 FALSE, /* pc_relative */
740 0, /* bitpos */
741 complain_overflow_signed, /* complain_on_overflow */
742 ppc64_elf_unhandled_reloc, /* special_function */
743 "R_PPC64_PLT16_HA", /* name */
744 FALSE, /* partial_inplace */
745 0, /* src_mask */
746 0xffff, /* dst_mask */
747 FALSE), /* pcrel_offset */
748
749 /* 16-bit section relative relocation. */
750 HOWTO (R_PPC64_SECTOFF, /* type */
751 0, /* rightshift */
752 1, /* size (0 = byte, 1 = short, 2 = long) */
753 16, /* bitsize */
754 FALSE, /* pc_relative */
755 0, /* bitpos */
756 complain_overflow_signed, /* complain_on_overflow */
757 ppc64_elf_sectoff_reloc, /* special_function */
758 "R_PPC64_SECTOFF", /* name */
759 FALSE, /* partial_inplace */
760 0, /* src_mask */
761 0xffff, /* dst_mask */
762 FALSE), /* pcrel_offset */
763
764 /* Like R_PPC64_SECTOFF, but no overflow warning. */
765 HOWTO (R_PPC64_SECTOFF_LO, /* type */
766 0, /* rightshift */
767 1, /* size (0 = byte, 1 = short, 2 = long) */
768 16, /* bitsize */
769 FALSE, /* pc_relative */
770 0, /* bitpos */
771 complain_overflow_dont, /* complain_on_overflow */
772 ppc64_elf_sectoff_reloc, /* special_function */
773 "R_PPC64_SECTOFF_LO", /* name */
774 FALSE, /* partial_inplace */
775 0, /* src_mask */
776 0xffff, /* dst_mask */
777 FALSE), /* pcrel_offset */
778
779 /* 16-bit upper half section relative relocation. */
780 HOWTO (R_PPC64_SECTOFF_HI, /* type */
781 16, /* rightshift */
782 1, /* size (0 = byte, 1 = short, 2 = long) */
783 16, /* bitsize */
784 FALSE, /* pc_relative */
785 0, /* bitpos */
786 complain_overflow_signed, /* complain_on_overflow */
787 ppc64_elf_sectoff_reloc, /* special_function */
788 "R_PPC64_SECTOFF_HI", /* name */
789 FALSE, /* partial_inplace */
790 0, /* src_mask */
791 0xffff, /* dst_mask */
792 FALSE), /* pcrel_offset */
793
794 /* 16-bit upper half adjusted section relative relocation. */
795 HOWTO (R_PPC64_SECTOFF_HA, /* type */
796 16, /* rightshift */
797 1, /* size (0 = byte, 1 = short, 2 = long) */
798 16, /* bitsize */
799 FALSE, /* pc_relative */
800 0, /* bitpos */
801 complain_overflow_signed, /* complain_on_overflow */
802 ppc64_elf_sectoff_ha_reloc, /* special_function */
803 "R_PPC64_SECTOFF_HA", /* name */
804 FALSE, /* partial_inplace */
805 0, /* src_mask */
806 0xffff, /* dst_mask */
807 FALSE), /* pcrel_offset */
808
809 /* Like R_PPC64_REL24 without touching the two least significant bits. */
810 HOWTO (R_PPC64_REL30, /* type */
811 2, /* rightshift */
812 2, /* size (0 = byte, 1 = short, 2 = long) */
813 30, /* bitsize */
814 TRUE, /* pc_relative */
815 0, /* bitpos */
816 complain_overflow_dont, /* complain_on_overflow */
817 bfd_elf_generic_reloc, /* special_function */
818 "R_PPC64_REL30", /* name */
819 FALSE, /* partial_inplace */
820 0, /* src_mask */
821 0xfffffffc, /* dst_mask */
822 TRUE), /* pcrel_offset */
823
824 /* Relocs in the 64-bit PowerPC ELF ABI, not in the 32-bit ABI. */
825
826 /* A standard 64-bit relocation. */
827 HOWTO (R_PPC64_ADDR64, /* type */
828 0, /* rightshift */
829 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
830 64, /* bitsize */
831 FALSE, /* pc_relative */
832 0, /* bitpos */
833 complain_overflow_dont, /* complain_on_overflow */
834 bfd_elf_generic_reloc, /* special_function */
835 "R_PPC64_ADDR64", /* name */
836 FALSE, /* partial_inplace */
837 0, /* src_mask */
838 ONES (64), /* dst_mask */
839 FALSE), /* pcrel_offset */
840
841 /* The bits 32-47 of an address. */
842 HOWTO (R_PPC64_ADDR16_HIGHER, /* type */
843 32, /* rightshift */
844 1, /* size (0 = byte, 1 = short, 2 = long) */
845 16, /* bitsize */
846 FALSE, /* pc_relative */
847 0, /* bitpos */
848 complain_overflow_dont, /* complain_on_overflow */
849 bfd_elf_generic_reloc, /* special_function */
850 "R_PPC64_ADDR16_HIGHER", /* name */
851 FALSE, /* partial_inplace */
852 0, /* src_mask */
853 0xffff, /* dst_mask */
854 FALSE), /* pcrel_offset */
855
856 /* The bits 32-47 of an address, plus 1 if the contents of the low
857 16 bits, treated as a signed number, is negative. */
858 HOWTO (R_PPC64_ADDR16_HIGHERA, /* type */
859 32, /* rightshift */
860 1, /* size (0 = byte, 1 = short, 2 = long) */
861 16, /* bitsize */
862 FALSE, /* pc_relative */
863 0, /* bitpos */
864 complain_overflow_dont, /* complain_on_overflow */
865 ppc64_elf_ha_reloc, /* special_function */
866 "R_PPC64_ADDR16_HIGHERA", /* name */
867 FALSE, /* partial_inplace */
868 0, /* src_mask */
869 0xffff, /* dst_mask */
870 FALSE), /* pcrel_offset */
871
872 /* The bits 48-63 of an address. */
873 HOWTO (R_PPC64_ADDR16_HIGHEST,/* type */
874 48, /* rightshift */
875 1, /* size (0 = byte, 1 = short, 2 = long) */
876 16, /* bitsize */
877 FALSE, /* pc_relative */
878 0, /* bitpos */
879 complain_overflow_dont, /* complain_on_overflow */
880 bfd_elf_generic_reloc, /* special_function */
881 "R_PPC64_ADDR16_HIGHEST", /* name */
882 FALSE, /* partial_inplace */
883 0, /* src_mask */
884 0xffff, /* dst_mask */
885 FALSE), /* pcrel_offset */
886
887 /* The bits 48-63 of an address, plus 1 if the contents of the low
888 16 bits, treated as a signed number, is negative. */
889 HOWTO (R_PPC64_ADDR16_HIGHESTA,/* type */
890 48, /* rightshift */
891 1, /* size (0 = byte, 1 = short, 2 = long) */
892 16, /* bitsize */
893 FALSE, /* pc_relative */
894 0, /* bitpos */
895 complain_overflow_dont, /* complain_on_overflow */
896 ppc64_elf_ha_reloc, /* special_function */
897 "R_PPC64_ADDR16_HIGHESTA", /* name */
898 FALSE, /* partial_inplace */
899 0, /* src_mask */
900 0xffff, /* dst_mask */
901 FALSE), /* pcrel_offset */
902
903 /* Like ADDR64, but may be unaligned. */
904 HOWTO (R_PPC64_UADDR64, /* type */
905 0, /* rightshift */
906 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
907 64, /* bitsize */
908 FALSE, /* pc_relative */
909 0, /* bitpos */
910 complain_overflow_dont, /* complain_on_overflow */
911 bfd_elf_generic_reloc, /* special_function */
912 "R_PPC64_UADDR64", /* name */
913 FALSE, /* partial_inplace */
914 0, /* src_mask */
915 ONES (64), /* dst_mask */
916 FALSE), /* pcrel_offset */
917
918 /* 64-bit relative relocation. */
919 HOWTO (R_PPC64_REL64, /* type */
920 0, /* rightshift */
921 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
922 64, /* bitsize */
923 TRUE, /* pc_relative */
924 0, /* bitpos */
925 complain_overflow_dont, /* complain_on_overflow */
926 bfd_elf_generic_reloc, /* special_function */
927 "R_PPC64_REL64", /* name */
928 FALSE, /* partial_inplace */
929 0, /* src_mask */
930 ONES (64), /* dst_mask */
931 TRUE), /* pcrel_offset */
932
933 /* 64-bit relocation to the symbol's procedure linkage table. */
934 HOWTO (R_PPC64_PLT64, /* type */
935 0, /* rightshift */
936 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
937 64, /* bitsize */
938 FALSE, /* pc_relative */
939 0, /* bitpos */
940 complain_overflow_dont, /* complain_on_overflow */
941 ppc64_elf_unhandled_reloc, /* special_function */
942 "R_PPC64_PLT64", /* name */
943 FALSE, /* partial_inplace */
944 0, /* src_mask */
945 ONES (64), /* dst_mask */
946 FALSE), /* pcrel_offset */
947
948 /* 64-bit PC relative relocation to the symbol's procedure linkage
949 table. */
950 /* FIXME: R_PPC64_PLTREL64 not supported. */
951 HOWTO (R_PPC64_PLTREL64, /* type */
952 0, /* rightshift */
953 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
954 64, /* bitsize */
955 TRUE, /* pc_relative */
956 0, /* bitpos */
957 complain_overflow_dont, /* complain_on_overflow */
958 ppc64_elf_unhandled_reloc, /* special_function */
959 "R_PPC64_PLTREL64", /* name */
960 FALSE, /* partial_inplace */
961 0, /* src_mask */
962 ONES (64), /* dst_mask */
963 TRUE), /* pcrel_offset */
964
965 /* 16 bit TOC-relative relocation. */
966
967 /* R_PPC64_TOC16 47 half16* S + A - .TOC. */
968 HOWTO (R_PPC64_TOC16, /* type */
969 0, /* rightshift */
970 1, /* size (0 = byte, 1 = short, 2 = long) */
971 16, /* bitsize */
972 FALSE, /* pc_relative */
973 0, /* bitpos */
974 complain_overflow_signed, /* complain_on_overflow */
975 ppc64_elf_toc_reloc, /* special_function */
976 "R_PPC64_TOC16", /* name */
977 FALSE, /* partial_inplace */
978 0, /* src_mask */
979 0xffff, /* dst_mask */
980 FALSE), /* pcrel_offset */
981
982 /* 16 bit TOC-relative relocation without overflow. */
983
984 /* R_PPC64_TOC16_LO 48 half16 #lo (S + A - .TOC.) */
985 HOWTO (R_PPC64_TOC16_LO, /* type */
986 0, /* rightshift */
987 1, /* size (0 = byte, 1 = short, 2 = long) */
988 16, /* bitsize */
989 FALSE, /* pc_relative */
990 0, /* bitpos */
991 complain_overflow_dont, /* complain_on_overflow */
992 ppc64_elf_toc_reloc, /* special_function */
993 "R_PPC64_TOC16_LO", /* name */
994 FALSE, /* partial_inplace */
995 0, /* src_mask */
996 0xffff, /* dst_mask */
997 FALSE), /* pcrel_offset */
998
999 /* 16 bit TOC-relative relocation, high 16 bits. */
1000
1001 /* R_PPC64_TOC16_HI 49 half16 #hi (S + A - .TOC.) */
1002 HOWTO (R_PPC64_TOC16_HI, /* type */
1003 16, /* rightshift */
1004 1, /* size (0 = byte, 1 = short, 2 = long) */
1005 16, /* bitsize */
1006 FALSE, /* pc_relative */
1007 0, /* bitpos */
1008 complain_overflow_signed, /* complain_on_overflow */
1009 ppc64_elf_toc_reloc, /* special_function */
1010 "R_PPC64_TOC16_HI", /* name */
1011 FALSE, /* partial_inplace */
1012 0, /* src_mask */
1013 0xffff, /* dst_mask */
1014 FALSE), /* pcrel_offset */
1015
1016 /* 16 bit TOC-relative relocation, high 16 bits, plus 1 if the
1017 contents of the low 16 bits, treated as a signed number, is
1018 negative. */
1019
1020 /* R_PPC64_TOC16_HA 50 half16 #ha (S + A - .TOC.) */
1021 HOWTO (R_PPC64_TOC16_HA, /* type */
1022 16, /* rightshift */
1023 1, /* size (0 = byte, 1 = short, 2 = long) */
1024 16, /* bitsize */
1025 FALSE, /* pc_relative */
1026 0, /* bitpos */
1027 complain_overflow_signed, /* complain_on_overflow */
1028 ppc64_elf_toc_ha_reloc, /* special_function */
1029 "R_PPC64_TOC16_HA", /* name */
1030 FALSE, /* partial_inplace */
1031 0, /* src_mask */
1032 0xffff, /* dst_mask */
1033 FALSE), /* pcrel_offset */
1034
1035 /* 64-bit relocation; insert value of TOC base (.TOC.). */
1036
1037 /* R_PPC64_TOC 51 doubleword64 .TOC. */
1038 HOWTO (R_PPC64_TOC, /* type */
1039 0, /* rightshift */
1040 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1041 64, /* bitsize */
1042 FALSE, /* pc_relative */
1043 0, /* bitpos */
1044 complain_overflow_dont, /* complain_on_overflow */
1045 ppc64_elf_toc64_reloc, /* special_function */
1046 "R_PPC64_TOC", /* name */
1047 FALSE, /* partial_inplace */
1048 0, /* src_mask */
1049 ONES (64), /* dst_mask */
1050 FALSE), /* pcrel_offset */
1051
1052 /* Like R_PPC64_GOT16, but also informs the link editor that the
1053 value to relocate may (!) refer to a PLT entry which the link
1054 editor (a) may replace with the symbol value. If the link editor
1055 is unable to fully resolve the symbol, it may (b) create a PLT
1056 entry and store the address to the new PLT entry in the GOT.
1057 This permits lazy resolution of function symbols at run time.
1058 The link editor may also skip all of this and just (c) emit a
1059 R_PPC64_GLOB_DAT to tie the symbol to the GOT entry. */
1060 /* FIXME: R_PPC64_PLTGOT16 not implemented. */
1061 HOWTO (R_PPC64_PLTGOT16, /* type */
1062 0, /* rightshift */
1063 1, /* size (0 = byte, 1 = short, 2 = long) */
1064 16, /* bitsize */
1065 FALSE, /* pc_relative */
1066 0, /* bitpos */
1067 complain_overflow_signed, /* complain_on_overflow */
1068 ppc64_elf_unhandled_reloc, /* special_function */
1069 "R_PPC64_PLTGOT16", /* name */
1070 FALSE, /* partial_inplace */
1071 0, /* src_mask */
1072 0xffff, /* dst_mask */
1073 FALSE), /* pcrel_offset */
1074
1075 /* Like R_PPC64_PLTGOT16, but without overflow. */
1076 /* FIXME: R_PPC64_PLTGOT16_LO not implemented. */
1077 HOWTO (R_PPC64_PLTGOT16_LO, /* type */
1078 0, /* rightshift */
1079 1, /* size (0 = byte, 1 = short, 2 = long) */
1080 16, /* bitsize */
1081 FALSE, /* pc_relative */
1082 0, /* bitpos */
1083 complain_overflow_dont, /* complain_on_overflow */
1084 ppc64_elf_unhandled_reloc, /* special_function */
1085 "R_PPC64_PLTGOT16_LO", /* name */
1086 FALSE, /* partial_inplace */
1087 0, /* src_mask */
1088 0xffff, /* dst_mask */
1089 FALSE), /* pcrel_offset */
1090
1091 /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address. */
1092 /* FIXME: R_PPC64_PLTGOT16_HI not implemented. */
1093 HOWTO (R_PPC64_PLTGOT16_HI, /* type */
1094 16, /* rightshift */
1095 1, /* size (0 = byte, 1 = short, 2 = long) */
1096 16, /* bitsize */
1097 FALSE, /* pc_relative */
1098 0, /* bitpos */
1099 complain_overflow_signed, /* complain_on_overflow */
1100 ppc64_elf_unhandled_reloc, /* special_function */
1101 "R_PPC64_PLTGOT16_HI", /* name */
1102 FALSE, /* partial_inplace */
1103 0, /* src_mask */
1104 0xffff, /* dst_mask */
1105 FALSE), /* pcrel_offset */
1106
1107 /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address, plus
1108 1 if the contents of the low 16 bits, treated as a signed number,
1109 is negative. */
1110 /* FIXME: R_PPC64_PLTGOT16_HA not implemented. */
1111 HOWTO (R_PPC64_PLTGOT16_HA, /* type */
1112 16, /* rightshift */
1113 1, /* size (0 = byte, 1 = short, 2 = long) */
1114 16, /* bitsize */
1115 FALSE, /* pc_relative */
1116 0, /* bitpos */
1117 complain_overflow_signed, /* complain_on_overflow */
1118 ppc64_elf_unhandled_reloc, /* special_function */
1119 "R_PPC64_PLTGOT16_HA", /* name */
1120 FALSE, /* partial_inplace */
1121 0, /* src_mask */
1122 0xffff, /* dst_mask */
1123 FALSE), /* pcrel_offset */
1124
1125 /* Like R_PPC64_ADDR16, but for instructions with a DS field. */
1126 HOWTO (R_PPC64_ADDR16_DS, /* type */
1127 0, /* rightshift */
1128 1, /* size (0 = byte, 1 = short, 2 = long) */
1129 16, /* bitsize */
1130 FALSE, /* pc_relative */
1131 0, /* bitpos */
1132 complain_overflow_signed, /* complain_on_overflow */
1133 bfd_elf_generic_reloc, /* special_function */
1134 "R_PPC64_ADDR16_DS", /* name */
1135 FALSE, /* partial_inplace */
1136 0, /* src_mask */
1137 0xfffc, /* dst_mask */
1138 FALSE), /* pcrel_offset */
1139
1140 /* Like R_PPC64_ADDR16_LO, but for instructions with a DS field. */
1141 HOWTO (R_PPC64_ADDR16_LO_DS, /* type */
1142 0, /* rightshift */
1143 1, /* size (0 = byte, 1 = short, 2 = long) */
1144 16, /* bitsize */
1145 FALSE, /* pc_relative */
1146 0, /* bitpos */
1147 complain_overflow_dont,/* complain_on_overflow */
1148 bfd_elf_generic_reloc, /* special_function */
1149 "R_PPC64_ADDR16_LO_DS",/* name */
1150 FALSE, /* partial_inplace */
1151 0, /* src_mask */
1152 0xfffc, /* dst_mask */
1153 FALSE), /* pcrel_offset */
1154
1155 /* Like R_PPC64_GOT16, but for instructions with a DS field. */
1156 HOWTO (R_PPC64_GOT16_DS, /* type */
1157 0, /* rightshift */
1158 1, /* size (0 = byte, 1 = short, 2 = long) */
1159 16, /* bitsize */
1160 FALSE, /* pc_relative */
1161 0, /* bitpos */
1162 complain_overflow_signed, /* complain_on_overflow */
1163 ppc64_elf_unhandled_reloc, /* special_function */
1164 "R_PPC64_GOT16_DS", /* name */
1165 FALSE, /* partial_inplace */
1166 0, /* src_mask */
1167 0xfffc, /* dst_mask */
1168 FALSE), /* pcrel_offset */
1169
1170 /* Like R_PPC64_GOT16_LO, but for instructions with a DS field. */
1171 HOWTO (R_PPC64_GOT16_LO_DS, /* type */
1172 0, /* rightshift */
1173 1, /* size (0 = byte, 1 = short, 2 = long) */
1174 16, /* bitsize */
1175 FALSE, /* pc_relative */
1176 0, /* bitpos */
1177 complain_overflow_dont, /* complain_on_overflow */
1178 ppc64_elf_unhandled_reloc, /* special_function */
1179 "R_PPC64_GOT16_LO_DS", /* name */
1180 FALSE, /* partial_inplace */
1181 0, /* src_mask */
1182 0xfffc, /* dst_mask */
1183 FALSE), /* pcrel_offset */
1184
1185 /* Like R_PPC64_PLT16_LO, but for instructions with a DS field. */
1186 HOWTO (R_PPC64_PLT16_LO_DS, /* type */
1187 0, /* rightshift */
1188 1, /* size (0 = byte, 1 = short, 2 = long) */
1189 16, /* bitsize */
1190 FALSE, /* pc_relative */
1191 0, /* bitpos */
1192 complain_overflow_dont, /* complain_on_overflow */
1193 ppc64_elf_unhandled_reloc, /* special_function */
1194 "R_PPC64_PLT16_LO_DS", /* name */
1195 FALSE, /* partial_inplace */
1196 0, /* src_mask */
1197 0xfffc, /* dst_mask */
1198 FALSE), /* pcrel_offset */
1199
1200 /* Like R_PPC64_SECTOFF, but for instructions with a DS field. */
1201 HOWTO (R_PPC64_SECTOFF_DS, /* type */
1202 0, /* rightshift */
1203 1, /* size (0 = byte, 1 = short, 2 = long) */
1204 16, /* bitsize */
1205 FALSE, /* pc_relative */
1206 0, /* bitpos */
1207 complain_overflow_signed, /* complain_on_overflow */
1208 ppc64_elf_sectoff_reloc, /* special_function */
1209 "R_PPC64_SECTOFF_DS", /* name */
1210 FALSE, /* partial_inplace */
1211 0, /* src_mask */
1212 0xfffc, /* dst_mask */
1213 FALSE), /* pcrel_offset */
1214
1215 /* Like R_PPC64_SECTOFF_LO, but for instructions with a DS field. */
1216 HOWTO (R_PPC64_SECTOFF_LO_DS, /* type */
1217 0, /* rightshift */
1218 1, /* size (0 = byte, 1 = short, 2 = long) */
1219 16, /* bitsize */
1220 FALSE, /* pc_relative */
1221 0, /* bitpos */
1222 complain_overflow_dont, /* complain_on_overflow */
1223 ppc64_elf_sectoff_reloc, /* special_function */
1224 "R_PPC64_SECTOFF_LO_DS",/* name */
1225 FALSE, /* partial_inplace */
1226 0, /* src_mask */
1227 0xfffc, /* dst_mask */
1228 FALSE), /* pcrel_offset */
1229
1230 /* Like R_PPC64_TOC16, but for instructions with a DS field. */
1231 HOWTO (R_PPC64_TOC16_DS, /* type */
1232 0, /* rightshift */
1233 1, /* size (0 = byte, 1 = short, 2 = long) */
1234 16, /* bitsize */
1235 FALSE, /* pc_relative */
1236 0, /* bitpos */
1237 complain_overflow_signed, /* complain_on_overflow */
1238 ppc64_elf_toc_reloc, /* special_function */
1239 "R_PPC64_TOC16_DS", /* name */
1240 FALSE, /* partial_inplace */
1241 0, /* src_mask */
1242 0xfffc, /* dst_mask */
1243 FALSE), /* pcrel_offset */
1244
1245 /* Like R_PPC64_TOC16_LO, but for instructions with a DS field. */
1246 HOWTO (R_PPC64_TOC16_LO_DS, /* type */
1247 0, /* rightshift */
1248 1, /* size (0 = byte, 1 = short, 2 = long) */
1249 16, /* bitsize */
1250 FALSE, /* pc_relative */
1251 0, /* bitpos */
1252 complain_overflow_dont, /* complain_on_overflow */
1253 ppc64_elf_toc_reloc, /* special_function */
1254 "R_PPC64_TOC16_LO_DS", /* name */
1255 FALSE, /* partial_inplace */
1256 0, /* src_mask */
1257 0xfffc, /* dst_mask */
1258 FALSE), /* pcrel_offset */
1259
1260 /* Like R_PPC64_PLTGOT16, but for instructions with a DS field. */
1261 /* FIXME: R_PPC64_PLTGOT16_DS not implemented. */
1262 HOWTO (R_PPC64_PLTGOT16_DS, /* type */
1263 0, /* rightshift */
1264 1, /* size (0 = byte, 1 = short, 2 = long) */
1265 16, /* bitsize */
1266 FALSE, /* pc_relative */
1267 0, /* bitpos */
1268 complain_overflow_signed, /* complain_on_overflow */
1269 ppc64_elf_unhandled_reloc, /* special_function */
1270 "R_PPC64_PLTGOT16_DS", /* name */
1271 FALSE, /* partial_inplace */
1272 0, /* src_mask */
1273 0xfffc, /* dst_mask */
1274 FALSE), /* pcrel_offset */
1275
1276 /* Like R_PPC64_PLTGOT16_LO, but for instructions with a DS field. */
1277 /* FIXME: R_PPC64_PLTGOT16_LO not implemented. */
1278 HOWTO (R_PPC64_PLTGOT16_LO_DS,/* type */
1279 0, /* rightshift */
1280 1, /* size (0 = byte, 1 = short, 2 = long) */
1281 16, /* bitsize */
1282 FALSE, /* pc_relative */
1283 0, /* bitpos */
1284 complain_overflow_dont, /* complain_on_overflow */
1285 ppc64_elf_unhandled_reloc, /* special_function */
1286 "R_PPC64_PLTGOT16_LO_DS",/* name */
1287 FALSE, /* partial_inplace */
1288 0, /* src_mask */
1289 0xfffc, /* dst_mask */
1290 FALSE), /* pcrel_offset */
1291
1292 /* Marker relocs for TLS. */
1293 HOWTO (R_PPC64_TLS,
1294 0, /* rightshift */
1295 2, /* size (0 = byte, 1 = short, 2 = long) */
1296 32, /* bitsize */
1297 FALSE, /* pc_relative */
1298 0, /* bitpos */
1299 complain_overflow_dont, /* complain_on_overflow */
1300 bfd_elf_generic_reloc, /* special_function */
1301 "R_PPC64_TLS", /* name */
1302 FALSE, /* partial_inplace */
1303 0, /* src_mask */
1304 0, /* dst_mask */
1305 FALSE), /* pcrel_offset */
1306
1307 HOWTO (R_PPC64_TLSGD,
1308 0, /* rightshift */
1309 2, /* size (0 = byte, 1 = short, 2 = long) */
1310 32, /* bitsize */
1311 FALSE, /* pc_relative */
1312 0, /* bitpos */
1313 complain_overflow_dont, /* complain_on_overflow */
1314 bfd_elf_generic_reloc, /* special_function */
1315 "R_PPC64_TLSGD", /* name */
1316 FALSE, /* partial_inplace */
1317 0, /* src_mask */
1318 0, /* dst_mask */
1319 FALSE), /* pcrel_offset */
1320
1321 HOWTO (R_PPC64_TLSLD,
1322 0, /* rightshift */
1323 2, /* size (0 = byte, 1 = short, 2 = long) */
1324 32, /* bitsize */
1325 FALSE, /* pc_relative */
1326 0, /* bitpos */
1327 complain_overflow_dont, /* complain_on_overflow */
1328 bfd_elf_generic_reloc, /* special_function */
1329 "R_PPC64_TLSLD", /* name */
1330 FALSE, /* partial_inplace */
1331 0, /* src_mask */
1332 0, /* dst_mask */
1333 FALSE), /* pcrel_offset */
1334
1335 HOWTO (R_PPC64_TOCSAVE,
1336 0, /* rightshift */
1337 2, /* size (0 = byte, 1 = short, 2 = long) */
1338 32, /* bitsize */
1339 FALSE, /* pc_relative */
1340 0, /* bitpos */
1341 complain_overflow_dont, /* complain_on_overflow */
1342 bfd_elf_generic_reloc, /* special_function */
1343 "R_PPC64_TOCSAVE", /* name */
1344 FALSE, /* partial_inplace */
1345 0, /* src_mask */
1346 0, /* dst_mask */
1347 FALSE), /* pcrel_offset */
1348
1349 /* Computes the load module index of the load module that contains the
1350 definition of its TLS sym. */
1351 HOWTO (R_PPC64_DTPMOD64,
1352 0, /* rightshift */
1353 4, /* size (0 = byte, 1 = short, 2 = long) */
1354 64, /* bitsize */
1355 FALSE, /* pc_relative */
1356 0, /* bitpos */
1357 complain_overflow_dont, /* complain_on_overflow */
1358 ppc64_elf_unhandled_reloc, /* special_function */
1359 "R_PPC64_DTPMOD64", /* name */
1360 FALSE, /* partial_inplace */
1361 0, /* src_mask */
1362 ONES (64), /* dst_mask */
1363 FALSE), /* pcrel_offset */
1364
1365 /* Computes a dtv-relative displacement, the difference between the value
1366 of sym+add and the base address of the thread-local storage block that
1367 contains the definition of sym, minus 0x8000. */
1368 HOWTO (R_PPC64_DTPREL64,
1369 0, /* rightshift */
1370 4, /* size (0 = byte, 1 = short, 2 = long) */
1371 64, /* bitsize */
1372 FALSE, /* pc_relative */
1373 0, /* bitpos */
1374 complain_overflow_dont, /* complain_on_overflow */
1375 ppc64_elf_unhandled_reloc, /* special_function */
1376 "R_PPC64_DTPREL64", /* name */
1377 FALSE, /* partial_inplace */
1378 0, /* src_mask */
1379 ONES (64), /* dst_mask */
1380 FALSE), /* pcrel_offset */
1381
1382 /* A 16 bit dtprel reloc. */
1383 HOWTO (R_PPC64_DTPREL16,
1384 0, /* rightshift */
1385 1, /* size (0 = byte, 1 = short, 2 = long) */
1386 16, /* bitsize */
1387 FALSE, /* pc_relative */
1388 0, /* bitpos */
1389 complain_overflow_signed, /* complain_on_overflow */
1390 ppc64_elf_unhandled_reloc, /* special_function */
1391 "R_PPC64_DTPREL16", /* name */
1392 FALSE, /* partial_inplace */
1393 0, /* src_mask */
1394 0xffff, /* dst_mask */
1395 FALSE), /* pcrel_offset */
1396
1397 /* Like DTPREL16, but no overflow. */
1398 HOWTO (R_PPC64_DTPREL16_LO,
1399 0, /* rightshift */
1400 1, /* size (0 = byte, 1 = short, 2 = long) */
1401 16, /* bitsize */
1402 FALSE, /* pc_relative */
1403 0, /* bitpos */
1404 complain_overflow_dont, /* complain_on_overflow */
1405 ppc64_elf_unhandled_reloc, /* special_function */
1406 "R_PPC64_DTPREL16_LO", /* name */
1407 FALSE, /* partial_inplace */
1408 0, /* src_mask */
1409 0xffff, /* dst_mask */
1410 FALSE), /* pcrel_offset */
1411
1412 /* Like DTPREL16_LO, but next higher group of 16 bits. */
1413 HOWTO (R_PPC64_DTPREL16_HI,
1414 16, /* rightshift */
1415 1, /* size (0 = byte, 1 = short, 2 = long) */
1416 16, /* bitsize */
1417 FALSE, /* pc_relative */
1418 0, /* bitpos */
1419 complain_overflow_signed, /* complain_on_overflow */
1420 ppc64_elf_unhandled_reloc, /* special_function */
1421 "R_PPC64_DTPREL16_HI", /* name */
1422 FALSE, /* partial_inplace */
1423 0, /* src_mask */
1424 0xffff, /* dst_mask */
1425 FALSE), /* pcrel_offset */
1426
1427 /* Like DTPREL16_HI, but adjust for low 16 bits. */
1428 HOWTO (R_PPC64_DTPREL16_HA,
1429 16, /* rightshift */
1430 1, /* size (0 = byte, 1 = short, 2 = long) */
1431 16, /* bitsize */
1432 FALSE, /* pc_relative */
1433 0, /* bitpos */
1434 complain_overflow_signed, /* complain_on_overflow */
1435 ppc64_elf_unhandled_reloc, /* special_function */
1436 "R_PPC64_DTPREL16_HA", /* name */
1437 FALSE, /* partial_inplace */
1438 0, /* src_mask */
1439 0xffff, /* dst_mask */
1440 FALSE), /* pcrel_offset */
1441
1442 /* Like DTPREL16_HI, but next higher group of 16 bits. */
1443 HOWTO (R_PPC64_DTPREL16_HIGHER,
1444 32, /* rightshift */
1445 1, /* size (0 = byte, 1 = short, 2 = long) */
1446 16, /* bitsize */
1447 FALSE, /* pc_relative */
1448 0, /* bitpos */
1449 complain_overflow_dont, /* complain_on_overflow */
1450 ppc64_elf_unhandled_reloc, /* special_function */
1451 "R_PPC64_DTPREL16_HIGHER", /* name */
1452 FALSE, /* partial_inplace */
1453 0, /* src_mask */
1454 0xffff, /* dst_mask */
1455 FALSE), /* pcrel_offset */
1456
1457 /* Like DTPREL16_HIGHER, but adjust for low 16 bits. */
1458 HOWTO (R_PPC64_DTPREL16_HIGHERA,
1459 32, /* rightshift */
1460 1, /* size (0 = byte, 1 = short, 2 = long) */
1461 16, /* bitsize */
1462 FALSE, /* pc_relative */
1463 0, /* bitpos */
1464 complain_overflow_dont, /* complain_on_overflow */
1465 ppc64_elf_unhandled_reloc, /* special_function */
1466 "R_PPC64_DTPREL16_HIGHERA", /* name */
1467 FALSE, /* partial_inplace */
1468 0, /* src_mask */
1469 0xffff, /* dst_mask */
1470 FALSE), /* pcrel_offset */
1471
1472 /* Like DTPREL16_HIGHER, but next higher group of 16 bits. */
1473 HOWTO (R_PPC64_DTPREL16_HIGHEST,
1474 48, /* rightshift */
1475 1, /* size (0 = byte, 1 = short, 2 = long) */
1476 16, /* bitsize */
1477 FALSE, /* pc_relative */
1478 0, /* bitpos */
1479 complain_overflow_dont, /* complain_on_overflow */
1480 ppc64_elf_unhandled_reloc, /* special_function */
1481 "R_PPC64_DTPREL16_HIGHEST", /* name */
1482 FALSE, /* partial_inplace */
1483 0, /* src_mask */
1484 0xffff, /* dst_mask */
1485 FALSE), /* pcrel_offset */
1486
1487 /* Like DTPREL16_HIGHEST, but adjust for low 16 bits. */
1488 HOWTO (R_PPC64_DTPREL16_HIGHESTA,
1489 48, /* rightshift */
1490 1, /* size (0 = byte, 1 = short, 2 = long) */
1491 16, /* bitsize */
1492 FALSE, /* pc_relative */
1493 0, /* bitpos */
1494 complain_overflow_dont, /* complain_on_overflow */
1495 ppc64_elf_unhandled_reloc, /* special_function */
1496 "R_PPC64_DTPREL16_HIGHESTA", /* name */
1497 FALSE, /* partial_inplace */
1498 0, /* src_mask */
1499 0xffff, /* dst_mask */
1500 FALSE), /* pcrel_offset */
1501
1502 /* Like DTPREL16, but for insns with a DS field. */
1503 HOWTO (R_PPC64_DTPREL16_DS,
1504 0, /* rightshift */
1505 1, /* size (0 = byte, 1 = short, 2 = long) */
1506 16, /* bitsize */
1507 FALSE, /* pc_relative */
1508 0, /* bitpos */
1509 complain_overflow_signed, /* complain_on_overflow */
1510 ppc64_elf_unhandled_reloc, /* special_function */
1511 "R_PPC64_DTPREL16_DS", /* name */
1512 FALSE, /* partial_inplace */
1513 0, /* src_mask */
1514 0xfffc, /* dst_mask */
1515 FALSE), /* pcrel_offset */
1516
1517 /* Like DTPREL16_DS, but no overflow. */
1518 HOWTO (R_PPC64_DTPREL16_LO_DS,
1519 0, /* rightshift */
1520 1, /* size (0 = byte, 1 = short, 2 = long) */
1521 16, /* bitsize */
1522 FALSE, /* pc_relative */
1523 0, /* bitpos */
1524 complain_overflow_dont, /* complain_on_overflow */
1525 ppc64_elf_unhandled_reloc, /* special_function */
1526 "R_PPC64_DTPREL16_LO_DS", /* name */
1527 FALSE, /* partial_inplace */
1528 0, /* src_mask */
1529 0xfffc, /* dst_mask */
1530 FALSE), /* pcrel_offset */
1531
1532 /* Computes a tp-relative displacement, the difference between the value of
1533 sym+add and the value of the thread pointer (r13). */
1534 HOWTO (R_PPC64_TPREL64,
1535 0, /* rightshift */
1536 4, /* size (0 = byte, 1 = short, 2 = long) */
1537 64, /* bitsize */
1538 FALSE, /* pc_relative */
1539 0, /* bitpos */
1540 complain_overflow_dont, /* complain_on_overflow */
1541 ppc64_elf_unhandled_reloc, /* special_function */
1542 "R_PPC64_TPREL64", /* name */
1543 FALSE, /* partial_inplace */
1544 0, /* src_mask */
1545 ONES (64), /* dst_mask */
1546 FALSE), /* pcrel_offset */
1547
1548 /* A 16 bit tprel reloc. */
1549 HOWTO (R_PPC64_TPREL16,
1550 0, /* rightshift */
1551 1, /* size (0 = byte, 1 = short, 2 = long) */
1552 16, /* bitsize */
1553 FALSE, /* pc_relative */
1554 0, /* bitpos */
1555 complain_overflow_signed, /* complain_on_overflow */
1556 ppc64_elf_unhandled_reloc, /* special_function */
1557 "R_PPC64_TPREL16", /* name */
1558 FALSE, /* partial_inplace */
1559 0, /* src_mask */
1560 0xffff, /* dst_mask */
1561 FALSE), /* pcrel_offset */
1562
1563 /* Like TPREL16, but no overflow. */
1564 HOWTO (R_PPC64_TPREL16_LO,
1565 0, /* rightshift */
1566 1, /* size (0 = byte, 1 = short, 2 = long) */
1567 16, /* bitsize */
1568 FALSE, /* pc_relative */
1569 0, /* bitpos */
1570 complain_overflow_dont, /* complain_on_overflow */
1571 ppc64_elf_unhandled_reloc, /* special_function */
1572 "R_PPC64_TPREL16_LO", /* name */
1573 FALSE, /* partial_inplace */
1574 0, /* src_mask */
1575 0xffff, /* dst_mask */
1576 FALSE), /* pcrel_offset */
1577
1578 /* Like TPREL16_LO, but next higher group of 16 bits. */
1579 HOWTO (R_PPC64_TPREL16_HI,
1580 16, /* rightshift */
1581 1, /* size (0 = byte, 1 = short, 2 = long) */
1582 16, /* bitsize */
1583 FALSE, /* pc_relative */
1584 0, /* bitpos */
1585 complain_overflow_signed, /* complain_on_overflow */
1586 ppc64_elf_unhandled_reloc, /* special_function */
1587 "R_PPC64_TPREL16_HI", /* name */
1588 FALSE, /* partial_inplace */
1589 0, /* src_mask */
1590 0xffff, /* dst_mask */
1591 FALSE), /* pcrel_offset */
1592
1593 /* Like TPREL16_HI, but adjust for low 16 bits. */
1594 HOWTO (R_PPC64_TPREL16_HA,
1595 16, /* rightshift */
1596 1, /* size (0 = byte, 1 = short, 2 = long) */
1597 16, /* bitsize */
1598 FALSE, /* pc_relative */
1599 0, /* bitpos */
1600 complain_overflow_signed, /* complain_on_overflow */
1601 ppc64_elf_unhandled_reloc, /* special_function */
1602 "R_PPC64_TPREL16_HA", /* name */
1603 FALSE, /* partial_inplace */
1604 0, /* src_mask */
1605 0xffff, /* dst_mask */
1606 FALSE), /* pcrel_offset */
1607
1608 /* Like TPREL16_HI, but next higher group of 16 bits. */
1609 HOWTO (R_PPC64_TPREL16_HIGHER,
1610 32, /* rightshift */
1611 1, /* size (0 = byte, 1 = short, 2 = long) */
1612 16, /* bitsize */
1613 FALSE, /* pc_relative */
1614 0, /* bitpos */
1615 complain_overflow_dont, /* complain_on_overflow */
1616 ppc64_elf_unhandled_reloc, /* special_function */
1617 "R_PPC64_TPREL16_HIGHER", /* name */
1618 FALSE, /* partial_inplace */
1619 0, /* src_mask */
1620 0xffff, /* dst_mask */
1621 FALSE), /* pcrel_offset */
1622
1623 /* Like TPREL16_HIGHER, but adjust for low 16 bits. */
1624 HOWTO (R_PPC64_TPREL16_HIGHERA,
1625 32, /* rightshift */
1626 1, /* size (0 = byte, 1 = short, 2 = long) */
1627 16, /* bitsize */
1628 FALSE, /* pc_relative */
1629 0, /* bitpos */
1630 complain_overflow_dont, /* complain_on_overflow */
1631 ppc64_elf_unhandled_reloc, /* special_function */
1632 "R_PPC64_TPREL16_HIGHERA", /* name */
1633 FALSE, /* partial_inplace */
1634 0, /* src_mask */
1635 0xffff, /* dst_mask */
1636 FALSE), /* pcrel_offset */
1637
1638 /* Like TPREL16_HIGHER, but next higher group of 16 bits. */
1639 HOWTO (R_PPC64_TPREL16_HIGHEST,
1640 48, /* rightshift */
1641 1, /* size (0 = byte, 1 = short, 2 = long) */
1642 16, /* bitsize */
1643 FALSE, /* pc_relative */
1644 0, /* bitpos */
1645 complain_overflow_dont, /* complain_on_overflow */
1646 ppc64_elf_unhandled_reloc, /* special_function */
1647 "R_PPC64_TPREL16_HIGHEST", /* name */
1648 FALSE, /* partial_inplace */
1649 0, /* src_mask */
1650 0xffff, /* dst_mask */
1651 FALSE), /* pcrel_offset */
1652
1653 /* Like TPREL16_HIGHEST, but adjust for low 16 bits. */
1654 HOWTO (R_PPC64_TPREL16_HIGHESTA,
1655 48, /* rightshift */
1656 1, /* size (0 = byte, 1 = short, 2 = long) */
1657 16, /* bitsize */
1658 FALSE, /* pc_relative */
1659 0, /* bitpos */
1660 complain_overflow_dont, /* complain_on_overflow */
1661 ppc64_elf_unhandled_reloc, /* special_function */
1662 "R_PPC64_TPREL16_HIGHESTA", /* name */
1663 FALSE, /* partial_inplace */
1664 0, /* src_mask */
1665 0xffff, /* dst_mask */
1666 FALSE), /* pcrel_offset */
1667
1668 /* Like TPREL16, but for insns with a DS field. */
1669 HOWTO (R_PPC64_TPREL16_DS,
1670 0, /* rightshift */
1671 1, /* size (0 = byte, 1 = short, 2 = long) */
1672 16, /* bitsize */
1673 FALSE, /* pc_relative */
1674 0, /* bitpos */
1675 complain_overflow_signed, /* complain_on_overflow */
1676 ppc64_elf_unhandled_reloc, /* special_function */
1677 "R_PPC64_TPREL16_DS", /* name */
1678 FALSE, /* partial_inplace */
1679 0, /* src_mask */
1680 0xfffc, /* dst_mask */
1681 FALSE), /* pcrel_offset */
1682
1683 /* Like TPREL16_DS, but no overflow. */
1684 HOWTO (R_PPC64_TPREL16_LO_DS,
1685 0, /* rightshift */
1686 1, /* size (0 = byte, 1 = short, 2 = long) */
1687 16, /* bitsize */
1688 FALSE, /* pc_relative */
1689 0, /* bitpos */
1690 complain_overflow_dont, /* complain_on_overflow */
1691 ppc64_elf_unhandled_reloc, /* special_function */
1692 "R_PPC64_TPREL16_LO_DS", /* name */
1693 FALSE, /* partial_inplace */
1694 0, /* src_mask */
1695 0xfffc, /* dst_mask */
1696 FALSE), /* pcrel_offset */
1697
1698 /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1699 with values (sym+add)@dtpmod and (sym+add)@dtprel, and computes the offset
1700 to the first entry relative to the TOC base (r2). */
1701 HOWTO (R_PPC64_GOT_TLSGD16,
1702 0, /* rightshift */
1703 1, /* size (0 = byte, 1 = short, 2 = long) */
1704 16, /* bitsize */
1705 FALSE, /* pc_relative */
1706 0, /* bitpos */
1707 complain_overflow_signed, /* complain_on_overflow */
1708 ppc64_elf_unhandled_reloc, /* special_function */
1709 "R_PPC64_GOT_TLSGD16", /* name */
1710 FALSE, /* partial_inplace */
1711 0, /* src_mask */
1712 0xffff, /* dst_mask */
1713 FALSE), /* pcrel_offset */
1714
1715 /* Like GOT_TLSGD16, but no overflow. */
1716 HOWTO (R_PPC64_GOT_TLSGD16_LO,
1717 0, /* rightshift */
1718 1, /* size (0 = byte, 1 = short, 2 = long) */
1719 16, /* bitsize */
1720 FALSE, /* pc_relative */
1721 0, /* bitpos */
1722 complain_overflow_dont, /* complain_on_overflow */
1723 ppc64_elf_unhandled_reloc, /* special_function */
1724 "R_PPC64_GOT_TLSGD16_LO", /* name */
1725 FALSE, /* partial_inplace */
1726 0, /* src_mask */
1727 0xffff, /* dst_mask */
1728 FALSE), /* pcrel_offset */
1729
1730 /* Like GOT_TLSGD16_LO, but next higher group of 16 bits. */
1731 HOWTO (R_PPC64_GOT_TLSGD16_HI,
1732 16, /* rightshift */
1733 1, /* size (0 = byte, 1 = short, 2 = long) */
1734 16, /* bitsize */
1735 FALSE, /* pc_relative */
1736 0, /* bitpos */
1737 complain_overflow_signed, /* complain_on_overflow */
1738 ppc64_elf_unhandled_reloc, /* special_function */
1739 "R_PPC64_GOT_TLSGD16_HI", /* name */
1740 FALSE, /* partial_inplace */
1741 0, /* src_mask */
1742 0xffff, /* dst_mask */
1743 FALSE), /* pcrel_offset */
1744
1745 /* Like GOT_TLSGD16_HI, but adjust for low 16 bits. */
1746 HOWTO (R_PPC64_GOT_TLSGD16_HA,
1747 16, /* rightshift */
1748 1, /* size (0 = byte, 1 = short, 2 = long) */
1749 16, /* bitsize */
1750 FALSE, /* pc_relative */
1751 0, /* bitpos */
1752 complain_overflow_signed, /* complain_on_overflow */
1753 ppc64_elf_unhandled_reloc, /* special_function */
1754 "R_PPC64_GOT_TLSGD16_HA", /* name */
1755 FALSE, /* partial_inplace */
1756 0, /* src_mask */
1757 0xffff, /* dst_mask */
1758 FALSE), /* pcrel_offset */
1759
1760 /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1761 with values (sym+add)@dtpmod and zero, and computes the offset to the
1762 first entry relative to the TOC base (r2). */
1763 HOWTO (R_PPC64_GOT_TLSLD16,
1764 0, /* rightshift */
1765 1, /* size (0 = byte, 1 = short, 2 = long) */
1766 16, /* bitsize */
1767 FALSE, /* pc_relative */
1768 0, /* bitpos */
1769 complain_overflow_signed, /* complain_on_overflow */
1770 ppc64_elf_unhandled_reloc, /* special_function */
1771 "R_PPC64_GOT_TLSLD16", /* name */
1772 FALSE, /* partial_inplace */
1773 0, /* src_mask */
1774 0xffff, /* dst_mask */
1775 FALSE), /* pcrel_offset */
1776
1777 /* Like GOT_TLSLD16, but no overflow. */
1778 HOWTO (R_PPC64_GOT_TLSLD16_LO,
1779 0, /* rightshift */
1780 1, /* size (0 = byte, 1 = short, 2 = long) */
1781 16, /* bitsize */
1782 FALSE, /* pc_relative */
1783 0, /* bitpos */
1784 complain_overflow_dont, /* complain_on_overflow */
1785 ppc64_elf_unhandled_reloc, /* special_function */
1786 "R_PPC64_GOT_TLSLD16_LO", /* name */
1787 FALSE, /* partial_inplace */
1788 0, /* src_mask */
1789 0xffff, /* dst_mask */
1790 FALSE), /* pcrel_offset */
1791
1792 /* Like GOT_TLSLD16_LO, but next higher group of 16 bits. */
1793 HOWTO (R_PPC64_GOT_TLSLD16_HI,
1794 16, /* rightshift */
1795 1, /* size (0 = byte, 1 = short, 2 = long) */
1796 16, /* bitsize */
1797 FALSE, /* pc_relative */
1798 0, /* bitpos */
1799 complain_overflow_signed, /* complain_on_overflow */
1800 ppc64_elf_unhandled_reloc, /* special_function */
1801 "R_PPC64_GOT_TLSLD16_HI", /* name */
1802 FALSE, /* partial_inplace */
1803 0, /* src_mask */
1804 0xffff, /* dst_mask */
1805 FALSE), /* pcrel_offset */
1806
1807 /* Like GOT_TLSLD16_HI, but adjust for low 16 bits. */
1808 HOWTO (R_PPC64_GOT_TLSLD16_HA,
1809 16, /* rightshift */
1810 1, /* size (0 = byte, 1 = short, 2 = long) */
1811 16, /* bitsize */
1812 FALSE, /* pc_relative */
1813 0, /* bitpos */
1814 complain_overflow_signed, /* complain_on_overflow */
1815 ppc64_elf_unhandled_reloc, /* special_function */
1816 "R_PPC64_GOT_TLSLD16_HA", /* name */
1817 FALSE, /* partial_inplace */
1818 0, /* src_mask */
1819 0xffff, /* dst_mask */
1820 FALSE), /* pcrel_offset */
1821
1822 /* Allocates an entry in the GOT with value (sym+add)@dtprel, and computes
1823 the offset to the entry relative to the TOC base (r2). */
1824 HOWTO (R_PPC64_GOT_DTPREL16_DS,
1825 0, /* rightshift */
1826 1, /* size (0 = byte, 1 = short, 2 = long) */
1827 16, /* bitsize */
1828 FALSE, /* pc_relative */
1829 0, /* bitpos */
1830 complain_overflow_signed, /* complain_on_overflow */
1831 ppc64_elf_unhandled_reloc, /* special_function */
1832 "R_PPC64_GOT_DTPREL16_DS", /* name */
1833 FALSE, /* partial_inplace */
1834 0, /* src_mask */
1835 0xfffc, /* dst_mask */
1836 FALSE), /* pcrel_offset */
1837
1838 /* Like GOT_DTPREL16_DS, but no overflow. */
1839 HOWTO (R_PPC64_GOT_DTPREL16_LO_DS,
1840 0, /* rightshift */
1841 1, /* size (0 = byte, 1 = short, 2 = long) */
1842 16, /* bitsize */
1843 FALSE, /* pc_relative */
1844 0, /* bitpos */
1845 complain_overflow_dont, /* complain_on_overflow */
1846 ppc64_elf_unhandled_reloc, /* special_function */
1847 "R_PPC64_GOT_DTPREL16_LO_DS", /* name */
1848 FALSE, /* partial_inplace */
1849 0, /* src_mask */
1850 0xfffc, /* dst_mask */
1851 FALSE), /* pcrel_offset */
1852
1853 /* Like GOT_DTPREL16_LO_DS, but next higher group of 16 bits. */
1854 HOWTO (R_PPC64_GOT_DTPREL16_HI,
1855 16, /* rightshift */
1856 1, /* size (0 = byte, 1 = short, 2 = long) */
1857 16, /* bitsize */
1858 FALSE, /* pc_relative */
1859 0, /* bitpos */
1860 complain_overflow_signed, /* complain_on_overflow */
1861 ppc64_elf_unhandled_reloc, /* special_function */
1862 "R_PPC64_GOT_DTPREL16_HI", /* name */
1863 FALSE, /* partial_inplace */
1864 0, /* src_mask */
1865 0xffff, /* dst_mask */
1866 FALSE), /* pcrel_offset */
1867
1868 /* Like GOT_DTPREL16_HI, but adjust for low 16 bits. */
1869 HOWTO (R_PPC64_GOT_DTPREL16_HA,
1870 16, /* rightshift */
1871 1, /* size (0 = byte, 1 = short, 2 = long) */
1872 16, /* bitsize */
1873 FALSE, /* pc_relative */
1874 0, /* bitpos */
1875 complain_overflow_signed, /* complain_on_overflow */
1876 ppc64_elf_unhandled_reloc, /* special_function */
1877 "R_PPC64_GOT_DTPREL16_HA", /* name */
1878 FALSE, /* partial_inplace */
1879 0, /* src_mask */
1880 0xffff, /* dst_mask */
1881 FALSE), /* pcrel_offset */
1882
1883 /* Allocates an entry in the GOT with value (sym+add)@tprel, and computes the
1884 offset to the entry relative to the TOC base (r2). */
1885 HOWTO (R_PPC64_GOT_TPREL16_DS,
1886 0, /* rightshift */
1887 1, /* size (0 = byte, 1 = short, 2 = long) */
1888 16, /* bitsize */
1889 FALSE, /* pc_relative */
1890 0, /* bitpos */
1891 complain_overflow_signed, /* complain_on_overflow */
1892 ppc64_elf_unhandled_reloc, /* special_function */
1893 "R_PPC64_GOT_TPREL16_DS", /* name */
1894 FALSE, /* partial_inplace */
1895 0, /* src_mask */
1896 0xfffc, /* dst_mask */
1897 FALSE), /* pcrel_offset */
1898
1899 /* Like GOT_TPREL16_DS, but no overflow. */
1900 HOWTO (R_PPC64_GOT_TPREL16_LO_DS,
1901 0, /* rightshift */
1902 1, /* size (0 = byte, 1 = short, 2 = long) */
1903 16, /* bitsize */
1904 FALSE, /* pc_relative */
1905 0, /* bitpos */
1906 complain_overflow_dont, /* complain_on_overflow */
1907 ppc64_elf_unhandled_reloc, /* special_function */
1908 "R_PPC64_GOT_TPREL16_LO_DS", /* name */
1909 FALSE, /* partial_inplace */
1910 0, /* src_mask */
1911 0xfffc, /* dst_mask */
1912 FALSE), /* pcrel_offset */
1913
1914 /* Like GOT_TPREL16_LO_DS, but next higher group of 16 bits. */
1915 HOWTO (R_PPC64_GOT_TPREL16_HI,
1916 16, /* rightshift */
1917 1, /* size (0 = byte, 1 = short, 2 = long) */
1918 16, /* bitsize */
1919 FALSE, /* pc_relative */
1920 0, /* bitpos */
1921 complain_overflow_signed, /* complain_on_overflow */
1922 ppc64_elf_unhandled_reloc, /* special_function */
1923 "R_PPC64_GOT_TPREL16_HI", /* name */
1924 FALSE, /* partial_inplace */
1925 0, /* src_mask */
1926 0xffff, /* dst_mask */
1927 FALSE), /* pcrel_offset */
1928
1929 /* Like GOT_TPREL16_HI, but adjust for low 16 bits. */
1930 HOWTO (R_PPC64_GOT_TPREL16_HA,
1931 16, /* rightshift */
1932 1, /* size (0 = byte, 1 = short, 2 = long) */
1933 16, /* bitsize */
1934 FALSE, /* pc_relative */
1935 0, /* bitpos */
1936 complain_overflow_signed, /* complain_on_overflow */
1937 ppc64_elf_unhandled_reloc, /* special_function */
1938 "R_PPC64_GOT_TPREL16_HA", /* name */
1939 FALSE, /* partial_inplace */
1940 0, /* src_mask */
1941 0xffff, /* dst_mask */
1942 FALSE), /* pcrel_offset */
1943
1944 HOWTO (R_PPC64_JMP_IREL, /* type */
1945 0, /* rightshift */
1946 0, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1947 0, /* bitsize */
1948 FALSE, /* pc_relative */
1949 0, /* bitpos */
1950 complain_overflow_dont, /* complain_on_overflow */
1951 ppc64_elf_unhandled_reloc, /* special_function */
1952 "R_PPC64_JMP_IREL", /* name */
1953 FALSE, /* partial_inplace */
1954 0, /* src_mask */
1955 0, /* dst_mask */
1956 FALSE), /* pcrel_offset */
1957
1958 HOWTO (R_PPC64_IRELATIVE, /* type */
1959 0, /* rightshift */
1960 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1961 64, /* bitsize */
1962 FALSE, /* pc_relative */
1963 0, /* bitpos */
1964 complain_overflow_dont, /* complain_on_overflow */
1965 bfd_elf_generic_reloc, /* special_function */
1966 "R_PPC64_IRELATIVE", /* name */
1967 FALSE, /* partial_inplace */
1968 0, /* src_mask */
1969 ONES (64), /* dst_mask */
1970 FALSE), /* pcrel_offset */
1971
1972 /* A 16 bit relative relocation. */
1973 HOWTO (R_PPC64_REL16, /* type */
1974 0, /* rightshift */
1975 1, /* size (0 = byte, 1 = short, 2 = long) */
1976 16, /* bitsize */
1977 TRUE, /* pc_relative */
1978 0, /* bitpos */
1979 complain_overflow_signed, /* complain_on_overflow */
1980 bfd_elf_generic_reloc, /* special_function */
1981 "R_PPC64_REL16", /* name */
1982 FALSE, /* partial_inplace */
1983 0, /* src_mask */
1984 0xffff, /* dst_mask */
1985 TRUE), /* pcrel_offset */
1986
1987 /* A 16 bit relative relocation without overflow. */
1988 HOWTO (R_PPC64_REL16_LO, /* type */
1989 0, /* rightshift */
1990 1, /* size (0 = byte, 1 = short, 2 = long) */
1991 16, /* bitsize */
1992 TRUE, /* pc_relative */
1993 0, /* bitpos */
1994 complain_overflow_dont,/* complain_on_overflow */
1995 bfd_elf_generic_reloc, /* special_function */
1996 "R_PPC64_REL16_LO", /* name */
1997 FALSE, /* partial_inplace */
1998 0, /* src_mask */
1999 0xffff, /* dst_mask */
2000 TRUE), /* pcrel_offset */
2001
2002 /* The high order 16 bits of a relative address. */
2003 HOWTO (R_PPC64_REL16_HI, /* type */
2004 16, /* rightshift */
2005 1, /* size (0 = byte, 1 = short, 2 = long) */
2006 16, /* bitsize */
2007 TRUE, /* pc_relative */
2008 0, /* bitpos */
2009 complain_overflow_signed, /* complain_on_overflow */
2010 bfd_elf_generic_reloc, /* special_function */
2011 "R_PPC64_REL16_HI", /* name */
2012 FALSE, /* partial_inplace */
2013 0, /* src_mask */
2014 0xffff, /* dst_mask */
2015 TRUE), /* pcrel_offset */
2016
2017 /* The high order 16 bits of a relative address, plus 1 if the contents of
2018 the low 16 bits, treated as a signed number, is negative. */
2019 HOWTO (R_PPC64_REL16_HA, /* type */
2020 16, /* rightshift */
2021 1, /* size (0 = byte, 1 = short, 2 = long) */
2022 16, /* bitsize */
2023 TRUE, /* pc_relative */
2024 0, /* bitpos */
2025 complain_overflow_signed, /* complain_on_overflow */
2026 ppc64_elf_ha_reloc, /* special_function */
2027 "R_PPC64_REL16_HA", /* name */
2028 FALSE, /* partial_inplace */
2029 0, /* src_mask */
2030 0xffff, /* dst_mask */
2031 TRUE), /* pcrel_offset */
2032
2033 /* Like R_PPC64_REL16_HA but for split field in addpcis. */
2034 HOWTO (R_PPC64_REL16DX_HA, /* type */
2035 16, /* rightshift */
2036 2, /* size (0 = byte, 1 = short, 2 = long) */
2037 16, /* bitsize */
2038 TRUE, /* pc_relative */
2039 0, /* bitpos */
2040 complain_overflow_signed, /* complain_on_overflow */
2041 ppc64_elf_ha_reloc, /* special_function */
2042 "R_PPC64_REL16DX_HA", /* name */
2043 FALSE, /* partial_inplace */
2044 0, /* src_mask */
2045 0x1fffc1, /* dst_mask */
2046 TRUE), /* pcrel_offset */
2047
2048 /* A split-field reloc for addpcis, non-relative (gas internal use only). */
2049 HOWTO (R_PPC64_16DX_HA, /* type */
2050 16, /* rightshift */
2051 2, /* size (0 = byte, 1 = short, 2 = long) */
2052 16, /* bitsize */
2053 FALSE, /* pc_relative */
2054 0, /* bitpos */
2055 complain_overflow_signed, /* complain_on_overflow */
2056 ppc64_elf_ha_reloc, /* special_function */
2057 "R_PPC64_16DX_HA", /* name */
2058 FALSE, /* partial_inplace */
2059 0, /* src_mask */
2060 0x1fffc1, /* dst_mask */
2061 FALSE), /* pcrel_offset */
2062
2063 /* Like R_PPC64_ADDR16_HI, but no overflow. */
2064 HOWTO (R_PPC64_ADDR16_HIGH, /* type */
2065 16, /* rightshift */
2066 1, /* size (0 = byte, 1 = short, 2 = long) */
2067 16, /* bitsize */
2068 FALSE, /* pc_relative */
2069 0, /* bitpos */
2070 complain_overflow_dont, /* complain_on_overflow */
2071 bfd_elf_generic_reloc, /* special_function */
2072 "R_PPC64_ADDR16_HIGH", /* name */
2073 FALSE, /* partial_inplace */
2074 0, /* src_mask */
2075 0xffff, /* dst_mask */
2076 FALSE), /* pcrel_offset */
2077
2078 /* Like R_PPC64_ADDR16_HA, but no overflow. */
2079 HOWTO (R_PPC64_ADDR16_HIGHA, /* type */
2080 16, /* rightshift */
2081 1, /* size (0 = byte, 1 = short, 2 = long) */
2082 16, /* bitsize */
2083 FALSE, /* pc_relative */
2084 0, /* bitpos */
2085 complain_overflow_dont, /* complain_on_overflow */
2086 ppc64_elf_ha_reloc, /* special_function */
2087 "R_PPC64_ADDR16_HIGHA", /* name */
2088 FALSE, /* partial_inplace */
2089 0, /* src_mask */
2090 0xffff, /* dst_mask */
2091 FALSE), /* pcrel_offset */
2092
2093 /* Like R_PPC64_DTPREL16_HI, but no overflow. */
2094 HOWTO (R_PPC64_DTPREL16_HIGH,
2095 16, /* rightshift */
2096 1, /* size (0 = byte, 1 = short, 2 = long) */
2097 16, /* bitsize */
2098 FALSE, /* pc_relative */
2099 0, /* bitpos */
2100 complain_overflow_dont, /* complain_on_overflow */
2101 ppc64_elf_unhandled_reloc, /* special_function */
2102 "R_PPC64_DTPREL16_HIGH", /* name */
2103 FALSE, /* partial_inplace */
2104 0, /* src_mask */
2105 0xffff, /* dst_mask */
2106 FALSE), /* pcrel_offset */
2107
2108 /* Like R_PPC64_DTPREL16_HA, but no overflow. */
2109 HOWTO (R_PPC64_DTPREL16_HIGHA,
2110 16, /* rightshift */
2111 1, /* size (0 = byte, 1 = short, 2 = long) */
2112 16, /* bitsize */
2113 FALSE, /* pc_relative */
2114 0, /* bitpos */
2115 complain_overflow_dont, /* complain_on_overflow */
2116 ppc64_elf_unhandled_reloc, /* special_function */
2117 "R_PPC64_DTPREL16_HIGHA", /* name */
2118 FALSE, /* partial_inplace */
2119 0, /* src_mask */
2120 0xffff, /* dst_mask */
2121 FALSE), /* pcrel_offset */
2122
2123 /* Like R_PPC64_TPREL16_HI, but no overflow. */
2124 HOWTO (R_PPC64_TPREL16_HIGH,
2125 16, /* rightshift */
2126 1, /* size (0 = byte, 1 = short, 2 = long) */
2127 16, /* bitsize */
2128 FALSE, /* pc_relative */
2129 0, /* bitpos */
2130 complain_overflow_dont, /* complain_on_overflow */
2131 ppc64_elf_unhandled_reloc, /* special_function */
2132 "R_PPC64_TPREL16_HIGH", /* name */
2133 FALSE, /* partial_inplace */
2134 0, /* src_mask */
2135 0xffff, /* dst_mask */
2136 FALSE), /* pcrel_offset */
2137
2138 /* Like R_PPC64_TPREL16_HA, but no overflow. */
2139 HOWTO (R_PPC64_TPREL16_HIGHA,
2140 16, /* rightshift */
2141 1, /* size (0 = byte, 1 = short, 2 = long) */
2142 16, /* bitsize */
2143 FALSE, /* pc_relative */
2144 0, /* bitpos */
2145 complain_overflow_dont, /* complain_on_overflow */
2146 ppc64_elf_unhandled_reloc, /* special_function */
2147 "R_PPC64_TPREL16_HIGHA", /* name */
2148 FALSE, /* partial_inplace */
2149 0, /* src_mask */
2150 0xffff, /* dst_mask */
2151 FALSE), /* pcrel_offset */
2152
2153 /* Marker reloc on ELFv2 large-model function entry. */
2154 HOWTO (R_PPC64_ENTRY,
2155 0, /* rightshift */
2156 2, /* size (0 = byte, 1 = short, 2 = long) */
2157 32, /* bitsize */
2158 FALSE, /* pc_relative */
2159 0, /* bitpos */
2160 complain_overflow_dont, /* complain_on_overflow */
2161 bfd_elf_generic_reloc, /* special_function */
2162 "R_PPC64_ENTRY", /* name */
2163 FALSE, /* partial_inplace */
2164 0, /* src_mask */
2165 0, /* dst_mask */
2166 FALSE), /* pcrel_offset */
2167
2168 /* Like ADDR64, but use local entry point of function. */
2169 HOWTO (R_PPC64_ADDR64_LOCAL, /* type */
2170 0, /* rightshift */
2171 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
2172 64, /* bitsize */
2173 FALSE, /* pc_relative */
2174 0, /* bitpos */
2175 complain_overflow_dont, /* complain_on_overflow */
2176 bfd_elf_generic_reloc, /* special_function */
2177 "R_PPC64_ADDR64_LOCAL", /* name */
2178 FALSE, /* partial_inplace */
2179 0, /* src_mask */
2180 ONES (64), /* dst_mask */
2181 FALSE), /* pcrel_offset */
2182
2183 /* GNU extension to record C++ vtable hierarchy. */
2184 HOWTO (R_PPC64_GNU_VTINHERIT, /* type */
2185 0, /* rightshift */
2186 0, /* size (0 = byte, 1 = short, 2 = long) */
2187 0, /* bitsize */
2188 FALSE, /* pc_relative */
2189 0, /* bitpos */
2190 complain_overflow_dont, /* complain_on_overflow */
2191 NULL, /* special_function */
2192 "R_PPC64_GNU_VTINHERIT", /* name */
2193 FALSE, /* partial_inplace */
2194 0, /* src_mask */
2195 0, /* dst_mask */
2196 FALSE), /* pcrel_offset */
2197
2198 /* GNU extension to record C++ vtable member usage. */
2199 HOWTO (R_PPC64_GNU_VTENTRY, /* type */
2200 0, /* rightshift */
2201 0, /* size (0 = byte, 1 = short, 2 = long) */
2202 0, /* bitsize */
2203 FALSE, /* pc_relative */
2204 0, /* bitpos */
2205 complain_overflow_dont, /* complain_on_overflow */
2206 NULL, /* special_function */
2207 "R_PPC64_GNU_VTENTRY", /* name */
2208 FALSE, /* partial_inplace */
2209 0, /* src_mask */
2210 0, /* dst_mask */
2211 FALSE), /* pcrel_offset */
2212 };
2213
2214 \f
2215 /* Initialize the ppc64_elf_howto_table, so that linear accesses can
2216 be done. */
2217
2218 static void
2219 ppc_howto_init (void)
2220 {
2221 unsigned int i, type;
2222
2223 for (i = 0; i < ARRAY_SIZE (ppc64_elf_howto_raw); i++)
2224 {
2225 type = ppc64_elf_howto_raw[i].type;
2226 BFD_ASSERT (type < ARRAY_SIZE (ppc64_elf_howto_table));
2227 ppc64_elf_howto_table[type] = &ppc64_elf_howto_raw[i];
2228 }
2229 }
2230
2231 static reloc_howto_type *
2232 ppc64_elf_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2233 bfd_reloc_code_real_type code)
2234 {
2235 enum elf_ppc64_reloc_type r = R_PPC64_NONE;
2236
2237 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2238 /* Initialize howto table if needed. */
2239 ppc_howto_init ();
2240
2241 switch (code)
2242 {
2243 default:
2244 return NULL;
2245
2246 case BFD_RELOC_NONE: r = R_PPC64_NONE;
2247 break;
2248 case BFD_RELOC_32: r = R_PPC64_ADDR32;
2249 break;
2250 case BFD_RELOC_PPC_BA26: r = R_PPC64_ADDR24;
2251 break;
2252 case BFD_RELOC_16: r = R_PPC64_ADDR16;
2253 break;
2254 case BFD_RELOC_LO16: r = R_PPC64_ADDR16_LO;
2255 break;
2256 case BFD_RELOC_HI16: r = R_PPC64_ADDR16_HI;
2257 break;
2258 case BFD_RELOC_PPC64_ADDR16_HIGH: r = R_PPC64_ADDR16_HIGH;
2259 break;
2260 case BFD_RELOC_HI16_S: r = R_PPC64_ADDR16_HA;
2261 break;
2262 case BFD_RELOC_PPC64_ADDR16_HIGHA: r = R_PPC64_ADDR16_HIGHA;
2263 break;
2264 case BFD_RELOC_PPC_BA16: r = R_PPC64_ADDR14;
2265 break;
2266 case BFD_RELOC_PPC_BA16_BRTAKEN: r = R_PPC64_ADDR14_BRTAKEN;
2267 break;
2268 case BFD_RELOC_PPC_BA16_BRNTAKEN: r = R_PPC64_ADDR14_BRNTAKEN;
2269 break;
2270 case BFD_RELOC_PPC_B26: r = R_PPC64_REL24;
2271 break;
2272 case BFD_RELOC_PPC_B16: r = R_PPC64_REL14;
2273 break;
2274 case BFD_RELOC_PPC_B16_BRTAKEN: r = R_PPC64_REL14_BRTAKEN;
2275 break;
2276 case BFD_RELOC_PPC_B16_BRNTAKEN: r = R_PPC64_REL14_BRNTAKEN;
2277 break;
2278 case BFD_RELOC_16_GOTOFF: r = R_PPC64_GOT16;
2279 break;
2280 case BFD_RELOC_LO16_GOTOFF: r = R_PPC64_GOT16_LO;
2281 break;
2282 case BFD_RELOC_HI16_GOTOFF: r = R_PPC64_GOT16_HI;
2283 break;
2284 case BFD_RELOC_HI16_S_GOTOFF: r = R_PPC64_GOT16_HA;
2285 break;
2286 case BFD_RELOC_PPC_COPY: r = R_PPC64_COPY;
2287 break;
2288 case BFD_RELOC_PPC_GLOB_DAT: r = R_PPC64_GLOB_DAT;
2289 break;
2290 case BFD_RELOC_32_PCREL: r = R_PPC64_REL32;
2291 break;
2292 case BFD_RELOC_32_PLTOFF: r = R_PPC64_PLT32;
2293 break;
2294 case BFD_RELOC_32_PLT_PCREL: r = R_PPC64_PLTREL32;
2295 break;
2296 case BFD_RELOC_LO16_PLTOFF: r = R_PPC64_PLT16_LO;
2297 break;
2298 case BFD_RELOC_HI16_PLTOFF: r = R_PPC64_PLT16_HI;
2299 break;
2300 case BFD_RELOC_HI16_S_PLTOFF: r = R_PPC64_PLT16_HA;
2301 break;
2302 case BFD_RELOC_16_BASEREL: r = R_PPC64_SECTOFF;
2303 break;
2304 case BFD_RELOC_LO16_BASEREL: r = R_PPC64_SECTOFF_LO;
2305 break;
2306 case BFD_RELOC_HI16_BASEREL: r = R_PPC64_SECTOFF_HI;
2307 break;
2308 case BFD_RELOC_HI16_S_BASEREL: r = R_PPC64_SECTOFF_HA;
2309 break;
2310 case BFD_RELOC_CTOR: r = R_PPC64_ADDR64;
2311 break;
2312 case BFD_RELOC_64: r = R_PPC64_ADDR64;
2313 break;
2314 case BFD_RELOC_PPC64_HIGHER: r = R_PPC64_ADDR16_HIGHER;
2315 break;
2316 case BFD_RELOC_PPC64_HIGHER_S: r = R_PPC64_ADDR16_HIGHERA;
2317 break;
2318 case BFD_RELOC_PPC64_HIGHEST: r = R_PPC64_ADDR16_HIGHEST;
2319 break;
2320 case BFD_RELOC_PPC64_HIGHEST_S: r = R_PPC64_ADDR16_HIGHESTA;
2321 break;
2322 case BFD_RELOC_64_PCREL: r = R_PPC64_REL64;
2323 break;
2324 case BFD_RELOC_64_PLTOFF: r = R_PPC64_PLT64;
2325 break;
2326 case BFD_RELOC_64_PLT_PCREL: r = R_PPC64_PLTREL64;
2327 break;
2328 case BFD_RELOC_PPC_TOC16: r = R_PPC64_TOC16;
2329 break;
2330 case BFD_RELOC_PPC64_TOC16_LO: r = R_PPC64_TOC16_LO;
2331 break;
2332 case BFD_RELOC_PPC64_TOC16_HI: r = R_PPC64_TOC16_HI;
2333 break;
2334 case BFD_RELOC_PPC64_TOC16_HA: r = R_PPC64_TOC16_HA;
2335 break;
2336 case BFD_RELOC_PPC64_TOC: r = R_PPC64_TOC;
2337 break;
2338 case BFD_RELOC_PPC64_PLTGOT16: r = R_PPC64_PLTGOT16;
2339 break;
2340 case BFD_RELOC_PPC64_PLTGOT16_LO: r = R_PPC64_PLTGOT16_LO;
2341 break;
2342 case BFD_RELOC_PPC64_PLTGOT16_HI: r = R_PPC64_PLTGOT16_HI;
2343 break;
2344 case BFD_RELOC_PPC64_PLTGOT16_HA: r = R_PPC64_PLTGOT16_HA;
2345 break;
2346 case BFD_RELOC_PPC64_ADDR16_DS: r = R_PPC64_ADDR16_DS;
2347 break;
2348 case BFD_RELOC_PPC64_ADDR16_LO_DS: r = R_PPC64_ADDR16_LO_DS;
2349 break;
2350 case BFD_RELOC_PPC64_GOT16_DS: r = R_PPC64_GOT16_DS;
2351 break;
2352 case BFD_RELOC_PPC64_GOT16_LO_DS: r = R_PPC64_GOT16_LO_DS;
2353 break;
2354 case BFD_RELOC_PPC64_PLT16_LO_DS: r = R_PPC64_PLT16_LO_DS;
2355 break;
2356 case BFD_RELOC_PPC64_SECTOFF_DS: r = R_PPC64_SECTOFF_DS;
2357 break;
2358 case BFD_RELOC_PPC64_SECTOFF_LO_DS: r = R_PPC64_SECTOFF_LO_DS;
2359 break;
2360 case BFD_RELOC_PPC64_TOC16_DS: r = R_PPC64_TOC16_DS;
2361 break;
2362 case BFD_RELOC_PPC64_TOC16_LO_DS: r = R_PPC64_TOC16_LO_DS;
2363 break;
2364 case BFD_RELOC_PPC64_PLTGOT16_DS: r = R_PPC64_PLTGOT16_DS;
2365 break;
2366 case BFD_RELOC_PPC64_PLTGOT16_LO_DS: r = R_PPC64_PLTGOT16_LO_DS;
2367 break;
2368 case BFD_RELOC_PPC_TLS: r = R_PPC64_TLS;
2369 break;
2370 case BFD_RELOC_PPC_TLSGD: r = R_PPC64_TLSGD;
2371 break;
2372 case BFD_RELOC_PPC_TLSLD: r = R_PPC64_TLSLD;
2373 break;
2374 case BFD_RELOC_PPC_DTPMOD: r = R_PPC64_DTPMOD64;
2375 break;
2376 case BFD_RELOC_PPC_TPREL16: r = R_PPC64_TPREL16;
2377 break;
2378 case BFD_RELOC_PPC_TPREL16_LO: r = R_PPC64_TPREL16_LO;
2379 break;
2380 case BFD_RELOC_PPC_TPREL16_HI: r = R_PPC64_TPREL16_HI;
2381 break;
2382 case BFD_RELOC_PPC64_TPREL16_HIGH: r = R_PPC64_TPREL16_HIGH;
2383 break;
2384 case BFD_RELOC_PPC_TPREL16_HA: r = R_PPC64_TPREL16_HA;
2385 break;
2386 case BFD_RELOC_PPC64_TPREL16_HIGHA: r = R_PPC64_TPREL16_HIGHA;
2387 break;
2388 case BFD_RELOC_PPC_TPREL: r = R_PPC64_TPREL64;
2389 break;
2390 case BFD_RELOC_PPC_DTPREL16: r = R_PPC64_DTPREL16;
2391 break;
2392 case BFD_RELOC_PPC_DTPREL16_LO: r = R_PPC64_DTPREL16_LO;
2393 break;
2394 case BFD_RELOC_PPC_DTPREL16_HI: r = R_PPC64_DTPREL16_HI;
2395 break;
2396 case BFD_RELOC_PPC64_DTPREL16_HIGH: r = R_PPC64_DTPREL16_HIGH;
2397 break;
2398 case BFD_RELOC_PPC_DTPREL16_HA: r = R_PPC64_DTPREL16_HA;
2399 break;
2400 case BFD_RELOC_PPC64_DTPREL16_HIGHA: r = R_PPC64_DTPREL16_HIGHA;
2401 break;
2402 case BFD_RELOC_PPC_DTPREL: r = R_PPC64_DTPREL64;
2403 break;
2404 case BFD_RELOC_PPC_GOT_TLSGD16: r = R_PPC64_GOT_TLSGD16;
2405 break;
2406 case BFD_RELOC_PPC_GOT_TLSGD16_LO: r = R_PPC64_GOT_TLSGD16_LO;
2407 break;
2408 case BFD_RELOC_PPC_GOT_TLSGD16_HI: r = R_PPC64_GOT_TLSGD16_HI;
2409 break;
2410 case BFD_RELOC_PPC_GOT_TLSGD16_HA: r = R_PPC64_GOT_TLSGD16_HA;
2411 break;
2412 case BFD_RELOC_PPC_GOT_TLSLD16: r = R_PPC64_GOT_TLSLD16;
2413 break;
2414 case BFD_RELOC_PPC_GOT_TLSLD16_LO: r = R_PPC64_GOT_TLSLD16_LO;
2415 break;
2416 case BFD_RELOC_PPC_GOT_TLSLD16_HI: r = R_PPC64_GOT_TLSLD16_HI;
2417 break;
2418 case BFD_RELOC_PPC_GOT_TLSLD16_HA: r = R_PPC64_GOT_TLSLD16_HA;
2419 break;
2420 case BFD_RELOC_PPC_GOT_TPREL16: r = R_PPC64_GOT_TPREL16_DS;
2421 break;
2422 case BFD_RELOC_PPC_GOT_TPREL16_LO: r = R_PPC64_GOT_TPREL16_LO_DS;
2423 break;
2424 case BFD_RELOC_PPC_GOT_TPREL16_HI: r = R_PPC64_GOT_TPREL16_HI;
2425 break;
2426 case BFD_RELOC_PPC_GOT_TPREL16_HA: r = R_PPC64_GOT_TPREL16_HA;
2427 break;
2428 case BFD_RELOC_PPC_GOT_DTPREL16: r = R_PPC64_GOT_DTPREL16_DS;
2429 break;
2430 case BFD_RELOC_PPC_GOT_DTPREL16_LO: r = R_PPC64_GOT_DTPREL16_LO_DS;
2431 break;
2432 case BFD_RELOC_PPC_GOT_DTPREL16_HI: r = R_PPC64_GOT_DTPREL16_HI;
2433 break;
2434 case BFD_RELOC_PPC_GOT_DTPREL16_HA: r = R_PPC64_GOT_DTPREL16_HA;
2435 break;
2436 case BFD_RELOC_PPC64_TPREL16_DS: r = R_PPC64_TPREL16_DS;
2437 break;
2438 case BFD_RELOC_PPC64_TPREL16_LO_DS: r = R_PPC64_TPREL16_LO_DS;
2439 break;
2440 case BFD_RELOC_PPC64_TPREL16_HIGHER: r = R_PPC64_TPREL16_HIGHER;
2441 break;
2442 case BFD_RELOC_PPC64_TPREL16_HIGHERA: r = R_PPC64_TPREL16_HIGHERA;
2443 break;
2444 case BFD_RELOC_PPC64_TPREL16_HIGHEST: r = R_PPC64_TPREL16_HIGHEST;
2445 break;
2446 case BFD_RELOC_PPC64_TPREL16_HIGHESTA: r = R_PPC64_TPREL16_HIGHESTA;
2447 break;
2448 case BFD_RELOC_PPC64_DTPREL16_DS: r = R_PPC64_DTPREL16_DS;
2449 break;
2450 case BFD_RELOC_PPC64_DTPREL16_LO_DS: r = R_PPC64_DTPREL16_LO_DS;
2451 break;
2452 case BFD_RELOC_PPC64_DTPREL16_HIGHER: r = R_PPC64_DTPREL16_HIGHER;
2453 break;
2454 case BFD_RELOC_PPC64_DTPREL16_HIGHERA: r = R_PPC64_DTPREL16_HIGHERA;
2455 break;
2456 case BFD_RELOC_PPC64_DTPREL16_HIGHEST: r = R_PPC64_DTPREL16_HIGHEST;
2457 break;
2458 case BFD_RELOC_PPC64_DTPREL16_HIGHESTA: r = R_PPC64_DTPREL16_HIGHESTA;
2459 break;
2460 case BFD_RELOC_16_PCREL: r = R_PPC64_REL16;
2461 break;
2462 case BFD_RELOC_LO16_PCREL: r = R_PPC64_REL16_LO;
2463 break;
2464 case BFD_RELOC_HI16_PCREL: r = R_PPC64_REL16_HI;
2465 break;
2466 case BFD_RELOC_HI16_S_PCREL: r = R_PPC64_REL16_HA;
2467 break;
2468 case BFD_RELOC_PPC_16DX_HA: r = R_PPC64_16DX_HA;
2469 break;
2470 case BFD_RELOC_PPC_REL16DX_HA: r = R_PPC64_REL16DX_HA;
2471 break;
2472 case BFD_RELOC_PPC64_ENTRY: r = R_PPC64_ENTRY;
2473 break;
2474 case BFD_RELOC_PPC64_ADDR64_LOCAL: r = R_PPC64_ADDR64_LOCAL;
2475 break;
2476 case BFD_RELOC_VTABLE_INHERIT: r = R_PPC64_GNU_VTINHERIT;
2477 break;
2478 case BFD_RELOC_VTABLE_ENTRY: r = R_PPC64_GNU_VTENTRY;
2479 break;
2480 }
2481
2482 return ppc64_elf_howto_table[r];
2483 };
2484
2485 static reloc_howto_type *
2486 ppc64_elf_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2487 const char *r_name)
2488 {
2489 unsigned int i;
2490
2491 for (i = 0; i < ARRAY_SIZE (ppc64_elf_howto_raw); i++)
2492 if (ppc64_elf_howto_raw[i].name != NULL
2493 && strcasecmp (ppc64_elf_howto_raw[i].name, r_name) == 0)
2494 return &ppc64_elf_howto_raw[i];
2495
2496 return NULL;
2497 }
2498
2499 /* Set the howto pointer for a PowerPC ELF reloc. */
2500
2501 static void
2502 ppc64_elf_info_to_howto (bfd *abfd, arelent *cache_ptr,
2503 Elf_Internal_Rela *dst)
2504 {
2505 unsigned int type;
2506
2507 /* Initialize howto table if needed. */
2508 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2509 ppc_howto_init ();
2510
2511 type = ELF64_R_TYPE (dst->r_info);
2512 if (type >= ARRAY_SIZE (ppc64_elf_howto_table))
2513 {
2514 /* xgettext:c-format */
2515 _bfd_error_handler (_("%B: invalid relocation type %d"),
2516 abfd, (int) type);
2517 type = R_PPC64_NONE;
2518 }
2519 cache_ptr->howto = ppc64_elf_howto_table[type];
2520 }
2521
2522 /* Handle the R_PPC64_ADDR16_HA and similar relocs. */
2523
2524 static bfd_reloc_status_type
2525 ppc64_elf_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2526 void *data, asection *input_section,
2527 bfd *output_bfd, char **error_message)
2528 {
2529 enum elf_ppc64_reloc_type r_type;
2530 long insn;
2531 bfd_size_type octets;
2532 bfd_vma value;
2533
2534 /* If this is a relocatable link (output_bfd test tells us), just
2535 call the generic function. Any adjustment will be done at final
2536 link time. */
2537 if (output_bfd != NULL)
2538 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2539 input_section, output_bfd, error_message);
2540
2541 /* Adjust the addend for sign extension of the low 16 bits.
2542 We won't actually be using the low 16 bits, so trashing them
2543 doesn't matter. */
2544 reloc_entry->addend += 0x8000;
2545 r_type = reloc_entry->howto->type;
2546 if (r_type != R_PPC64_REL16DX_HA)
2547 return bfd_reloc_continue;
2548
2549 value = 0;
2550 if (!bfd_is_com_section (symbol->section))
2551 value = symbol->value;
2552 value += (reloc_entry->addend
2553 + symbol->section->output_offset
2554 + symbol->section->output_section->vma);
2555 value -= (reloc_entry->address
2556 + input_section->output_offset
2557 + input_section->output_section->vma);
2558 value = (bfd_signed_vma) value >> 16;
2559
2560 octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2561 insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
2562 insn &= ~0x1fffc1;
2563 insn |= (value & 0xffc1) | ((value & 0x3e) << 15);
2564 bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
2565 if (value + 0x8000 > 0xffff)
2566 return bfd_reloc_overflow;
2567 return bfd_reloc_ok;
2568 }
2569
2570 static bfd_reloc_status_type
2571 ppc64_elf_branch_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2572 void *data, asection *input_section,
2573 bfd *output_bfd, char **error_message)
2574 {
2575 if (output_bfd != NULL)
2576 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2577 input_section, output_bfd, error_message);
2578
2579 if (strcmp (symbol->section->name, ".opd") == 0
2580 && (symbol->section->owner->flags & DYNAMIC) == 0)
2581 {
2582 bfd_vma dest = opd_entry_value (symbol->section,
2583 symbol->value + reloc_entry->addend,
2584 NULL, NULL, FALSE);
2585 if (dest != (bfd_vma) -1)
2586 reloc_entry->addend = dest - (symbol->value
2587 + symbol->section->output_section->vma
2588 + symbol->section->output_offset);
2589 }
2590 else
2591 {
2592 elf_symbol_type *elfsym = (elf_symbol_type *) symbol;
2593
2594 if (symbol->section->owner != abfd
2595 && symbol->section->owner != NULL
2596 && abiversion (symbol->section->owner) >= 2)
2597 {
2598 unsigned int i;
2599
2600 for (i = 0; i < symbol->section->owner->symcount; ++i)
2601 {
2602 asymbol *symdef = symbol->section->owner->outsymbols[i];
2603
2604 if (strcmp (symdef->name, symbol->name) == 0)
2605 {
2606 elfsym = (elf_symbol_type *) symdef;
2607 break;
2608 }
2609 }
2610 }
2611 reloc_entry->addend
2612 += PPC64_LOCAL_ENTRY_OFFSET (elfsym->internal_elf_sym.st_other);
2613 }
2614 return bfd_reloc_continue;
2615 }
2616
2617 static bfd_reloc_status_type
2618 ppc64_elf_brtaken_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2619 void *data, asection *input_section,
2620 bfd *output_bfd, char **error_message)
2621 {
2622 long insn;
2623 enum elf_ppc64_reloc_type r_type;
2624 bfd_size_type octets;
2625 /* Assume 'at' branch hints. */
2626 bfd_boolean is_isa_v2 = TRUE;
2627
2628 /* If this is a relocatable link (output_bfd test tells us), just
2629 call the generic function. Any adjustment will be done at final
2630 link time. */
2631 if (output_bfd != NULL)
2632 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2633 input_section, output_bfd, error_message);
2634
2635 octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2636 insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
2637 insn &= ~(0x01 << 21);
2638 r_type = reloc_entry->howto->type;
2639 if (r_type == R_PPC64_ADDR14_BRTAKEN
2640 || r_type == R_PPC64_REL14_BRTAKEN)
2641 insn |= 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field. */
2642
2643 if (is_isa_v2)
2644 {
2645 /* Set 'a' bit. This is 0b00010 in BO field for branch
2646 on CR(BI) insns (BO == 001at or 011at), and 0b01000
2647 for branch on CTR insns (BO == 1a00t or 1a01t). */
2648 if ((insn & (0x14 << 21)) == (0x04 << 21))
2649 insn |= 0x02 << 21;
2650 else if ((insn & (0x14 << 21)) == (0x10 << 21))
2651 insn |= 0x08 << 21;
2652 else
2653 goto out;
2654 }
2655 else
2656 {
2657 bfd_vma target = 0;
2658 bfd_vma from;
2659
2660 if (!bfd_is_com_section (symbol->section))
2661 target = symbol->value;
2662 target += symbol->section->output_section->vma;
2663 target += symbol->section->output_offset;
2664 target += reloc_entry->addend;
2665
2666 from = (reloc_entry->address
2667 + input_section->output_offset
2668 + input_section->output_section->vma);
2669
2670 /* Invert 'y' bit if not the default. */
2671 if ((bfd_signed_vma) (target - from) < 0)
2672 insn ^= 0x01 << 21;
2673 }
2674 bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
2675 out:
2676 return ppc64_elf_branch_reloc (abfd, reloc_entry, symbol, data,
2677 input_section, output_bfd, error_message);
2678 }
2679
2680 static bfd_reloc_status_type
2681 ppc64_elf_sectoff_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2682 void *data, asection *input_section,
2683 bfd *output_bfd, char **error_message)
2684 {
2685 /* If this is a relocatable link (output_bfd test tells us), just
2686 call the generic function. Any adjustment will be done at final
2687 link time. */
2688 if (output_bfd != NULL)
2689 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2690 input_section, output_bfd, error_message);
2691
2692 /* Subtract the symbol section base address. */
2693 reloc_entry->addend -= symbol->section->output_section->vma;
2694 return bfd_reloc_continue;
2695 }
2696
2697 static bfd_reloc_status_type
2698 ppc64_elf_sectoff_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2699 void *data, asection *input_section,
2700 bfd *output_bfd, char **error_message)
2701 {
2702 /* If this is a relocatable link (output_bfd test tells us), just
2703 call the generic function. Any adjustment will be done at final
2704 link time. */
2705 if (output_bfd != NULL)
2706 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2707 input_section, output_bfd, error_message);
2708
2709 /* Subtract the symbol section base address. */
2710 reloc_entry->addend -= symbol->section->output_section->vma;
2711
2712 /* Adjust the addend for sign extension of the low 16 bits. */
2713 reloc_entry->addend += 0x8000;
2714 return bfd_reloc_continue;
2715 }
2716
2717 static bfd_reloc_status_type
2718 ppc64_elf_toc_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2719 void *data, asection *input_section,
2720 bfd *output_bfd, char **error_message)
2721 {
2722 bfd_vma TOCstart;
2723
2724 /* If this is a relocatable link (output_bfd test tells us), just
2725 call the generic function. Any adjustment will be done at final
2726 link time. */
2727 if (output_bfd != NULL)
2728 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2729 input_section, output_bfd, error_message);
2730
2731 TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2732 if (TOCstart == 0)
2733 TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2734
2735 /* Subtract the TOC base address. */
2736 reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2737 return bfd_reloc_continue;
2738 }
2739
2740 static bfd_reloc_status_type
2741 ppc64_elf_toc_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2742 void *data, asection *input_section,
2743 bfd *output_bfd, char **error_message)
2744 {
2745 bfd_vma TOCstart;
2746
2747 /* If this is a relocatable link (output_bfd test tells us), just
2748 call the generic function. Any adjustment will be done at final
2749 link time. */
2750 if (output_bfd != NULL)
2751 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2752 input_section, output_bfd, error_message);
2753
2754 TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2755 if (TOCstart == 0)
2756 TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2757
2758 /* Subtract the TOC base address. */
2759 reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2760
2761 /* Adjust the addend for sign extension of the low 16 bits. */
2762 reloc_entry->addend += 0x8000;
2763 return bfd_reloc_continue;
2764 }
2765
2766 static bfd_reloc_status_type
2767 ppc64_elf_toc64_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2768 void *data, asection *input_section,
2769 bfd *output_bfd, char **error_message)
2770 {
2771 bfd_vma TOCstart;
2772 bfd_size_type octets;
2773
2774 /* If this is a relocatable link (output_bfd test tells us), just
2775 call the generic function. Any adjustment will be done at final
2776 link time. */
2777 if (output_bfd != NULL)
2778 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2779 input_section, output_bfd, error_message);
2780
2781 TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2782 if (TOCstart == 0)
2783 TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2784
2785 octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2786 bfd_put_64 (abfd, TOCstart + TOC_BASE_OFF, (bfd_byte *) data + octets);
2787 return bfd_reloc_ok;
2788 }
2789
2790 static bfd_reloc_status_type
2791 ppc64_elf_unhandled_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2792 void *data, asection *input_section,
2793 bfd *output_bfd, char **error_message)
2794 {
2795 /* If this is a relocatable link (output_bfd test tells us), just
2796 call the generic function. Any adjustment will be done at final
2797 link time. */
2798 if (output_bfd != NULL)
2799 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2800 input_section, output_bfd, error_message);
2801
2802 if (error_message != NULL)
2803 {
2804 static char buf[60];
2805 sprintf (buf, "generic linker can't handle %s",
2806 reloc_entry->howto->name);
2807 *error_message = buf;
2808 }
2809 return bfd_reloc_dangerous;
2810 }
2811
2812 /* Track GOT entries needed for a given symbol. We might need more
2813 than one got entry per symbol. */
2814 struct got_entry
2815 {
2816 struct got_entry *next;
2817
2818 /* The symbol addend that we'll be placing in the GOT. */
2819 bfd_vma addend;
2820
2821 /* Unlike other ELF targets, we use separate GOT entries for the same
2822 symbol referenced from different input files. This is to support
2823 automatic multiple TOC/GOT sections, where the TOC base can vary
2824 from one input file to another. After partitioning into TOC groups
2825 we merge entries within the group.
2826
2827 Point to the BFD owning this GOT entry. */
2828 bfd *owner;
2829
2830 /* Zero for non-tls entries, or TLS_TLS and one of TLS_GD, TLS_LD,
2831 TLS_TPREL or TLS_DTPREL for tls entries. */
2832 unsigned char tls_type;
2833
2834 /* Non-zero if got.ent points to real entry. */
2835 unsigned char is_indirect;
2836
2837 /* Reference count until size_dynamic_sections, GOT offset thereafter. */
2838 union
2839 {
2840 bfd_signed_vma refcount;
2841 bfd_vma offset;
2842 struct got_entry *ent;
2843 } got;
2844 };
2845
2846 /* The same for PLT. */
2847 struct plt_entry
2848 {
2849 struct plt_entry *next;
2850
2851 bfd_vma addend;
2852
2853 union
2854 {
2855 bfd_signed_vma refcount;
2856 bfd_vma offset;
2857 } plt;
2858 };
2859
2860 struct ppc64_elf_obj_tdata
2861 {
2862 struct elf_obj_tdata elf;
2863
2864 /* Shortcuts to dynamic linker sections. */
2865 asection *got;
2866 asection *relgot;
2867
2868 /* Used during garbage collection. We attach global symbols defined
2869 on removed .opd entries to this section so that the sym is removed. */
2870 asection *deleted_section;
2871
2872 /* TLS local dynamic got entry handling. Support for multiple GOT
2873 sections means we potentially need one of these for each input bfd. */
2874 struct got_entry tlsld_got;
2875
2876 union {
2877 /* A copy of relocs before they are modified for --emit-relocs. */
2878 Elf_Internal_Rela *relocs;
2879
2880 /* Section contents. */
2881 bfd_byte *contents;
2882 } opd;
2883
2884 /* Nonzero if this bfd has small toc/got relocs, ie. that expect
2885 the reloc to be in the range -32768 to 32767. */
2886 unsigned int has_small_toc_reloc : 1;
2887
2888 /* Set if toc/got ha relocs detected not using r2, or lo reloc
2889 instruction not one we handle. */
2890 unsigned int unexpected_toc_insn : 1;
2891 };
2892
2893 #define ppc64_elf_tdata(bfd) \
2894 ((struct ppc64_elf_obj_tdata *) (bfd)->tdata.any)
2895
2896 #define ppc64_tlsld_got(bfd) \
2897 (&ppc64_elf_tdata (bfd)->tlsld_got)
2898
2899 #define is_ppc64_elf(bfd) \
2900 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
2901 && elf_object_id (bfd) == PPC64_ELF_DATA)
2902
2903 /* Override the generic function because we store some extras. */
2904
2905 static bfd_boolean
2906 ppc64_elf_mkobject (bfd *abfd)
2907 {
2908 return bfd_elf_allocate_object (abfd, sizeof (struct ppc64_elf_obj_tdata),
2909 PPC64_ELF_DATA);
2910 }
2911
2912 /* Fix bad default arch selected for a 64 bit input bfd when the
2913 default is 32 bit. Also select arch based on apuinfo. */
2914
2915 static bfd_boolean
2916 ppc64_elf_object_p (bfd *abfd)
2917 {
2918 if (!abfd->arch_info->the_default)
2919 return TRUE;
2920
2921 if (abfd->arch_info->bits_per_word == 32)
2922 {
2923 Elf_Internal_Ehdr *i_ehdr = elf_elfheader (abfd);
2924
2925 if (i_ehdr->e_ident[EI_CLASS] == ELFCLASS64)
2926 {
2927 /* Relies on arch after 32 bit default being 64 bit default. */
2928 abfd->arch_info = abfd->arch_info->next;
2929 BFD_ASSERT (abfd->arch_info->bits_per_word == 64);
2930 }
2931 }
2932 return _bfd_elf_ppc_set_arch (abfd);
2933 }
2934
2935 /* Support for core dump NOTE sections. */
2936
2937 static bfd_boolean
2938 ppc64_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
2939 {
2940 size_t offset, size;
2941
2942 if (note->descsz != 504)
2943 return FALSE;
2944
2945 /* pr_cursig */
2946 elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
2947
2948 /* pr_pid */
2949 elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 32);
2950
2951 /* pr_reg */
2952 offset = 112;
2953 size = 384;
2954
2955 /* Make a ".reg/999" section. */
2956 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
2957 size, note->descpos + offset);
2958 }
2959
2960 static bfd_boolean
2961 ppc64_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
2962 {
2963 if (note->descsz != 136)
2964 return FALSE;
2965
2966 elf_tdata (abfd)->core->pid
2967 = bfd_get_32 (abfd, note->descdata + 24);
2968 elf_tdata (abfd)->core->program
2969 = _bfd_elfcore_strndup (abfd, note->descdata + 40, 16);
2970 elf_tdata (abfd)->core->command
2971 = _bfd_elfcore_strndup (abfd, note->descdata + 56, 80);
2972
2973 return TRUE;
2974 }
2975
2976 static char *
2977 ppc64_elf_write_core_note (bfd *abfd, char *buf, int *bufsiz, int note_type,
2978 ...)
2979 {
2980 switch (note_type)
2981 {
2982 default:
2983 return NULL;
2984
2985 case NT_PRPSINFO:
2986 {
2987 char data[136];
2988 va_list ap;
2989
2990 va_start (ap, note_type);
2991 memset (data, 0, sizeof (data));
2992 strncpy (data + 40, va_arg (ap, const char *), 16);
2993 strncpy (data + 56, va_arg (ap, const char *), 80);
2994 va_end (ap);
2995 return elfcore_write_note (abfd, buf, bufsiz,
2996 "CORE", note_type, data, sizeof (data));
2997 }
2998
2999 case NT_PRSTATUS:
3000 {
3001 char data[504];
3002 va_list ap;
3003 long pid;
3004 int cursig;
3005 const void *greg;
3006
3007 va_start (ap, note_type);
3008 memset (data, 0, 112);
3009 pid = va_arg (ap, long);
3010 bfd_put_32 (abfd, pid, data + 32);
3011 cursig = va_arg (ap, int);
3012 bfd_put_16 (abfd, cursig, data + 12);
3013 greg = va_arg (ap, const void *);
3014 memcpy (data + 112, greg, 384);
3015 memset (data + 496, 0, 8);
3016 va_end (ap);
3017 return elfcore_write_note (abfd, buf, bufsiz,
3018 "CORE", note_type, data, sizeof (data));
3019 }
3020 }
3021 }
3022
3023 /* Add extra PPC sections. */
3024
3025 static const struct bfd_elf_special_section ppc64_elf_special_sections[]=
3026 {
3027 { STRING_COMMA_LEN (".plt"), 0, SHT_NOBITS, 0 },
3028 { STRING_COMMA_LEN (".sbss"), -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE },
3029 { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
3030 { STRING_COMMA_LEN (".toc"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
3031 { STRING_COMMA_LEN (".toc1"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
3032 { STRING_COMMA_LEN (".tocbss"), 0, SHT_NOBITS, SHF_ALLOC + SHF_WRITE },
3033 { NULL, 0, 0, 0, 0 }
3034 };
3035
3036 enum _ppc64_sec_type {
3037 sec_normal = 0,
3038 sec_opd = 1,
3039 sec_toc = 2
3040 };
3041
3042 struct _ppc64_elf_section_data
3043 {
3044 struct bfd_elf_section_data elf;
3045
3046 union
3047 {
3048 /* An array with one entry for each opd function descriptor,
3049 and some spares since opd entries may be either 16 or 24 bytes. */
3050 #define OPD_NDX(OFF) ((OFF) >> 4)
3051 struct _opd_sec_data
3052 {
3053 /* Points to the function code section for local opd entries. */
3054 asection **func_sec;
3055
3056 /* After editing .opd, adjust references to opd local syms. */
3057 long *adjust;
3058 } opd;
3059
3060 /* An array for toc sections, indexed by offset/8. */
3061 struct _toc_sec_data
3062 {
3063 /* Specifies the relocation symbol index used at a given toc offset. */
3064 unsigned *symndx;
3065
3066 /* And the relocation addend. */
3067 bfd_vma *add;
3068 } toc;
3069 } u;
3070
3071 enum _ppc64_sec_type sec_type:2;
3072
3073 /* Flag set when small branches are detected. Used to
3074 select suitable defaults for the stub group size. */
3075 unsigned int has_14bit_branch:1;
3076 };
3077
3078 #define ppc64_elf_section_data(sec) \
3079 ((struct _ppc64_elf_section_data *) elf_section_data (sec))
3080
3081 static bfd_boolean
3082 ppc64_elf_new_section_hook (bfd *abfd, asection *sec)
3083 {
3084 if (!sec->used_by_bfd)
3085 {
3086 struct _ppc64_elf_section_data *sdata;
3087 bfd_size_type amt = sizeof (*sdata);
3088
3089 sdata = bfd_zalloc (abfd, amt);
3090 if (sdata == NULL)
3091 return FALSE;
3092 sec->used_by_bfd = sdata;
3093 }
3094
3095 return _bfd_elf_new_section_hook (abfd, sec);
3096 }
3097
3098 static struct _opd_sec_data *
3099 get_opd_info (asection * sec)
3100 {
3101 if (sec != NULL
3102 && ppc64_elf_section_data (sec) != NULL
3103 && ppc64_elf_section_data (sec)->sec_type == sec_opd)
3104 return &ppc64_elf_section_data (sec)->u.opd;
3105 return NULL;
3106 }
3107 \f
3108 /* Parameters for the qsort hook. */
3109 static bfd_boolean synthetic_relocatable;
3110 static asection *synthetic_opd;
3111
3112 /* qsort comparison function for ppc64_elf_get_synthetic_symtab. */
3113
3114 static int
3115 compare_symbols (const void *ap, const void *bp)
3116 {
3117 const asymbol *a = * (const asymbol **) ap;
3118 const asymbol *b = * (const asymbol **) bp;
3119
3120 /* Section symbols first. */
3121 if ((a->flags & BSF_SECTION_SYM) && !(b->flags & BSF_SECTION_SYM))
3122 return -1;
3123 if (!(a->flags & BSF_SECTION_SYM) && (b->flags & BSF_SECTION_SYM))
3124 return 1;
3125
3126 /* then .opd symbols. */
3127 if (synthetic_opd != NULL)
3128 {
3129 if (strcmp (a->section->name, ".opd") == 0
3130 && strcmp (b->section->name, ".opd") != 0)
3131 return -1;
3132 if (strcmp (a->section->name, ".opd") != 0
3133 && strcmp (b->section->name, ".opd") == 0)
3134 return 1;
3135 }
3136
3137 /* then other code symbols. */
3138 if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3139 == (SEC_CODE | SEC_ALLOC)
3140 && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3141 != (SEC_CODE | SEC_ALLOC))
3142 return -1;
3143
3144 if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3145 != (SEC_CODE | SEC_ALLOC)
3146 && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3147 == (SEC_CODE | SEC_ALLOC))
3148 return 1;
3149
3150 if (synthetic_relocatable)
3151 {
3152 if (a->section->id < b->section->id)
3153 return -1;
3154
3155 if (a->section->id > b->section->id)
3156 return 1;
3157 }
3158
3159 if (a->value + a->section->vma < b->value + b->section->vma)
3160 return -1;
3161
3162 if (a->value + a->section->vma > b->value + b->section->vma)
3163 return 1;
3164
3165 /* For syms with the same value, prefer strong dynamic global function
3166 syms over other syms. */
3167 if ((a->flags & BSF_GLOBAL) != 0 && (b->flags & BSF_GLOBAL) == 0)
3168 return -1;
3169
3170 if ((a->flags & BSF_GLOBAL) == 0 && (b->flags & BSF_GLOBAL) != 0)
3171 return 1;
3172
3173 if ((a->flags & BSF_FUNCTION) != 0 && (b->flags & BSF_FUNCTION) == 0)
3174 return -1;
3175
3176 if ((a->flags & BSF_FUNCTION) == 0 && (b->flags & BSF_FUNCTION) != 0)
3177 return 1;
3178
3179 if ((a->flags & BSF_WEAK) == 0 && (b->flags & BSF_WEAK) != 0)
3180 return -1;
3181
3182 if ((a->flags & BSF_WEAK) != 0 && (b->flags & BSF_WEAK) == 0)
3183 return 1;
3184
3185 if ((a->flags & BSF_DYNAMIC) != 0 && (b->flags & BSF_DYNAMIC) == 0)
3186 return -1;
3187
3188 if ((a->flags & BSF_DYNAMIC) == 0 && (b->flags & BSF_DYNAMIC) != 0)
3189 return 1;
3190
3191 return 0;
3192 }
3193
3194 /* Search SYMS for a symbol of the given VALUE. */
3195
3196 static asymbol *
3197 sym_exists_at (asymbol **syms, long lo, long hi, unsigned int id, bfd_vma value)
3198 {
3199 long mid;
3200
3201 if (id == (unsigned) -1)
3202 {
3203 while (lo < hi)
3204 {
3205 mid = (lo + hi) >> 1;
3206 if (syms[mid]->value + syms[mid]->section->vma < value)
3207 lo = mid + 1;
3208 else if (syms[mid]->value + syms[mid]->section->vma > value)
3209 hi = mid;
3210 else
3211 return syms[mid];
3212 }
3213 }
3214 else
3215 {
3216 while (lo < hi)
3217 {
3218 mid = (lo + hi) >> 1;
3219 if (syms[mid]->section->id < id)
3220 lo = mid + 1;
3221 else if (syms[mid]->section->id > id)
3222 hi = mid;
3223 else if (syms[mid]->value < value)
3224 lo = mid + 1;
3225 else if (syms[mid]->value > value)
3226 hi = mid;
3227 else
3228 return syms[mid];
3229 }
3230 }
3231 return NULL;
3232 }
3233
3234 static bfd_boolean
3235 section_covers_vma (bfd *abfd ATTRIBUTE_UNUSED, asection *section, void *ptr)
3236 {
3237 bfd_vma vma = *(bfd_vma *) ptr;
3238 return ((section->flags & SEC_ALLOC) != 0
3239 && section->vma <= vma
3240 && vma < section->vma + section->size);
3241 }
3242
3243 /* Create synthetic symbols, effectively restoring "dot-symbol" function
3244 entry syms. Also generate @plt symbols for the glink branch table.
3245 Returns count of synthetic symbols in RET or -1 on error. */
3246
3247 static long
3248 ppc64_elf_get_synthetic_symtab (bfd *abfd,
3249 long static_count, asymbol **static_syms,
3250 long dyn_count, asymbol **dyn_syms,
3251 asymbol **ret)
3252 {
3253 asymbol *s;
3254 long i;
3255 long count;
3256 char *names;
3257 long symcount, codesecsym, codesecsymend, secsymend, opdsymend;
3258 asection *opd = NULL;
3259 bfd_boolean relocatable = (abfd->flags & (EXEC_P | DYNAMIC)) == 0;
3260 asymbol **syms;
3261 int abi = abiversion (abfd);
3262
3263 *ret = NULL;
3264
3265 if (abi < 2)
3266 {
3267 opd = bfd_get_section_by_name (abfd, ".opd");
3268 if (opd == NULL && abi == 1)
3269 return 0;
3270 }
3271
3272 symcount = static_count;
3273 if (!relocatable)
3274 symcount += dyn_count;
3275 if (symcount == 0)
3276 return 0;
3277
3278 syms = bfd_malloc ((symcount + 1) * sizeof (*syms));
3279 if (syms == NULL)
3280 return -1;
3281
3282 if (!relocatable && static_count != 0 && dyn_count != 0)
3283 {
3284 /* Use both symbol tables. */
3285 memcpy (syms, static_syms, static_count * sizeof (*syms));
3286 memcpy (syms + static_count, dyn_syms, (dyn_count + 1) * sizeof (*syms));
3287 }
3288 else if (!relocatable && static_count == 0)
3289 memcpy (syms, dyn_syms, (symcount + 1) * sizeof (*syms));
3290 else
3291 memcpy (syms, static_syms, (symcount + 1) * sizeof (*syms));
3292
3293 synthetic_relocatable = relocatable;
3294 synthetic_opd = opd;
3295 qsort (syms, symcount, sizeof (*syms), compare_symbols);
3296
3297 if (!relocatable && symcount > 1)
3298 {
3299 long j;
3300 /* Trim duplicate syms, since we may have merged the normal and
3301 dynamic symbols. Actually, we only care about syms that have
3302 different values, so trim any with the same value. */
3303 for (i = 1, j = 1; i < symcount; ++i)
3304 if (syms[i - 1]->value + syms[i - 1]->section->vma
3305 != syms[i]->value + syms[i]->section->vma)
3306 syms[j++] = syms[i];
3307 symcount = j;
3308 }
3309
3310 i = 0;
3311 /* Note that here and in compare_symbols we can't compare opd and
3312 sym->section directly. With separate debug info files, the
3313 symbols will be extracted from the debug file while abfd passed
3314 to this function is the real binary. */
3315 if (opd != NULL && strcmp (syms[i]->section->name, ".opd") == 0)
3316 ++i;
3317 codesecsym = i;
3318
3319 for (; i < symcount; ++i)
3320 if (((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3321 != (SEC_CODE | SEC_ALLOC))
3322 || (syms[i]->flags & BSF_SECTION_SYM) == 0)
3323 break;
3324 codesecsymend = i;
3325
3326 for (; i < symcount; ++i)
3327 if ((syms[i]->flags & BSF_SECTION_SYM) == 0)
3328 break;
3329 secsymend = i;
3330
3331 if (opd != NULL)
3332 for (; i < symcount; ++i)
3333 if (strcmp (syms[i]->section->name, ".opd") != 0)
3334 break;
3335 opdsymend = i;
3336
3337 for (; i < symcount; ++i)
3338 if ((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3339 != (SEC_CODE | SEC_ALLOC))
3340 break;
3341 symcount = i;
3342
3343 count = 0;
3344
3345 if (relocatable)
3346 {
3347 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3348 arelent *r;
3349 size_t size;
3350 long relcount;
3351
3352 if (opdsymend == secsymend)
3353 goto done;
3354
3355 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3356 relcount = (opd->flags & SEC_RELOC) ? opd->reloc_count : 0;
3357 if (relcount == 0)
3358 goto done;
3359
3360 if (!(*slurp_relocs) (abfd, opd, static_syms, FALSE))
3361 {
3362 count = -1;
3363 goto done;
3364 }
3365
3366 size = 0;
3367 for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3368 {
3369 asymbol *sym;
3370
3371 while (r < opd->relocation + relcount
3372 && r->address < syms[i]->value + opd->vma)
3373 ++r;
3374
3375 if (r == opd->relocation + relcount)
3376 break;
3377
3378 if (r->address != syms[i]->value + opd->vma)
3379 continue;
3380
3381 if (r->howto->type != R_PPC64_ADDR64)
3382 continue;
3383
3384 sym = *r->sym_ptr_ptr;
3385 if (!sym_exists_at (syms, opdsymend, symcount,
3386 sym->section->id, sym->value + r->addend))
3387 {
3388 ++count;
3389 size += sizeof (asymbol);
3390 size += strlen (syms[i]->name) + 2;
3391 }
3392 }
3393
3394 if (size == 0)
3395 goto done;
3396 s = *ret = bfd_malloc (size);
3397 if (s == NULL)
3398 {
3399 count = -1;
3400 goto done;
3401 }
3402
3403 names = (char *) (s + count);
3404
3405 for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3406 {
3407 asymbol *sym;
3408
3409 while (r < opd->relocation + relcount
3410 && r->address < syms[i]->value + opd->vma)
3411 ++r;
3412
3413 if (r == opd->relocation + relcount)
3414 break;
3415
3416 if (r->address != syms[i]->value + opd->vma)
3417 continue;
3418
3419 if (r->howto->type != R_PPC64_ADDR64)
3420 continue;
3421
3422 sym = *r->sym_ptr_ptr;
3423 if (!sym_exists_at (syms, opdsymend, symcount,
3424 sym->section->id, sym->value + r->addend))
3425 {
3426 size_t len;
3427
3428 *s = *syms[i];
3429 s->flags |= BSF_SYNTHETIC;
3430 s->section = sym->section;
3431 s->value = sym->value + r->addend;
3432 s->name = names;
3433 *names++ = '.';
3434 len = strlen (syms[i]->name);
3435 memcpy (names, syms[i]->name, len + 1);
3436 names += len + 1;
3437 /* Have udata.p point back to the original symbol this
3438 synthetic symbol was derived from. */
3439 s->udata.p = syms[i];
3440 s++;
3441 }
3442 }
3443 }
3444 else
3445 {
3446 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3447 bfd_byte *contents = NULL;
3448 size_t size;
3449 long plt_count = 0;
3450 bfd_vma glink_vma = 0, resolv_vma = 0;
3451 asection *dynamic, *glink = NULL, *relplt = NULL;
3452 arelent *p;
3453
3454 if (opd != NULL && !bfd_malloc_and_get_section (abfd, opd, &contents))
3455 {
3456 free_contents_and_exit_err:
3457 count = -1;
3458 free_contents_and_exit:
3459 if (contents)
3460 free (contents);
3461 goto done;
3462 }
3463
3464 size = 0;
3465 for (i = secsymend; i < opdsymend; ++i)
3466 {
3467 bfd_vma ent;
3468
3469 /* Ignore bogus symbols. */
3470 if (syms[i]->value > opd->size - 8)
3471 continue;
3472
3473 ent = bfd_get_64 (abfd, contents + syms[i]->value);
3474 if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3475 {
3476 ++count;
3477 size += sizeof (asymbol);
3478 size += strlen (syms[i]->name) + 2;
3479 }
3480 }
3481
3482 /* Get start of .glink stubs from DT_PPC64_GLINK. */
3483 if (dyn_count != 0
3484 && (dynamic = bfd_get_section_by_name (abfd, ".dynamic")) != NULL)
3485 {
3486 bfd_byte *dynbuf, *extdyn, *extdynend;
3487 size_t extdynsize;
3488 void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *);
3489
3490 if (!bfd_malloc_and_get_section (abfd, dynamic, &dynbuf))
3491 goto free_contents_and_exit_err;
3492
3493 extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
3494 swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
3495
3496 extdyn = dynbuf;
3497 extdynend = extdyn + dynamic->size;
3498 for (; extdyn < extdynend; extdyn += extdynsize)
3499 {
3500 Elf_Internal_Dyn dyn;
3501 (*swap_dyn_in) (abfd, extdyn, &dyn);
3502
3503 if (dyn.d_tag == DT_NULL)
3504 break;
3505
3506 if (dyn.d_tag == DT_PPC64_GLINK)
3507 {
3508 /* The first glink stub starts at offset 32; see
3509 comment in ppc64_elf_finish_dynamic_sections. */
3510 glink_vma = dyn.d_un.d_val + GLINK_CALL_STUB_SIZE - 8 * 4;
3511 /* The .glink section usually does not survive the final
3512 link; search for the section (usually .text) where the
3513 glink stubs now reside. */
3514 glink = bfd_sections_find_if (abfd, section_covers_vma,
3515 &glink_vma);
3516 break;
3517 }
3518 }
3519
3520 free (dynbuf);
3521 }
3522
3523 if (glink != NULL)
3524 {
3525 /* Determine __glink trampoline by reading the relative branch
3526 from the first glink stub. */
3527 bfd_byte buf[4];
3528 unsigned int off = 0;
3529
3530 while (bfd_get_section_contents (abfd, glink, buf,
3531 glink_vma + off - glink->vma, 4))
3532 {
3533 unsigned int insn = bfd_get_32 (abfd, buf);
3534 insn ^= B_DOT;
3535 if ((insn & ~0x3fffffc) == 0)
3536 {
3537 resolv_vma = glink_vma + off + (insn ^ 0x2000000) - 0x2000000;
3538 break;
3539 }
3540 off += 4;
3541 if (off > 4)
3542 break;
3543 }
3544
3545 if (resolv_vma)
3546 size += sizeof (asymbol) + sizeof ("__glink_PLTresolve");
3547
3548 relplt = bfd_get_section_by_name (abfd, ".rela.plt");
3549 if (relplt != NULL)
3550 {
3551 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3552 if (! (*slurp_relocs) (abfd, relplt, dyn_syms, TRUE))
3553 goto free_contents_and_exit_err;
3554
3555 plt_count = relplt->size / sizeof (Elf64_External_Rela);
3556 size += plt_count * sizeof (asymbol);
3557
3558 p = relplt->relocation;
3559 for (i = 0; i < plt_count; i++, p++)
3560 {
3561 size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
3562 if (p->addend != 0)
3563 size += sizeof ("+0x") - 1 + 16;
3564 }
3565 }
3566 }
3567
3568 if (size == 0)
3569 goto free_contents_and_exit;
3570 s = *ret = bfd_malloc (size);
3571 if (s == NULL)
3572 goto free_contents_and_exit_err;
3573
3574 names = (char *) (s + count + plt_count + (resolv_vma != 0));
3575
3576 for (i = secsymend; i < opdsymend; ++i)
3577 {
3578 bfd_vma ent;
3579
3580 if (syms[i]->value > opd->size - 8)
3581 continue;
3582
3583 ent = bfd_get_64 (abfd, contents + syms[i]->value);
3584 if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3585 {
3586 long lo, hi;
3587 size_t len;
3588 asection *sec = abfd->sections;
3589
3590 *s = *syms[i];
3591 lo = codesecsym;
3592 hi = codesecsymend;
3593 while (lo < hi)
3594 {
3595 long mid = (lo + hi) >> 1;
3596 if (syms[mid]->section->vma < ent)
3597 lo = mid + 1;
3598 else if (syms[mid]->section->vma > ent)
3599 hi = mid;
3600 else
3601 {
3602 sec = syms[mid]->section;
3603 break;
3604 }
3605 }
3606
3607 if (lo >= hi && lo > codesecsym)
3608 sec = syms[lo - 1]->section;
3609
3610 for (; sec != NULL; sec = sec->next)
3611 {
3612 if (sec->vma > ent)
3613 break;
3614 /* SEC_LOAD may not be set if SEC is from a separate debug
3615 info file. */
3616 if ((sec->flags & SEC_ALLOC) == 0)
3617 break;
3618 if ((sec->flags & SEC_CODE) != 0)
3619 s->section = sec;
3620 }
3621 s->flags |= BSF_SYNTHETIC;
3622 s->value = ent - s->section->vma;
3623 s->name = names;
3624 *names++ = '.';
3625 len = strlen (syms[i]->name);
3626 memcpy (names, syms[i]->name, len + 1);
3627 names += len + 1;
3628 /* Have udata.p point back to the original symbol this
3629 synthetic symbol was derived from. */
3630 s->udata.p = syms[i];
3631 s++;
3632 }
3633 }
3634 free (contents);
3635
3636 if (glink != NULL && relplt != NULL)
3637 {
3638 if (resolv_vma)
3639 {
3640 /* Add a symbol for the main glink trampoline. */
3641 memset (s, 0, sizeof *s);
3642 s->the_bfd = abfd;
3643 s->flags = BSF_GLOBAL | BSF_SYNTHETIC;
3644 s->section = glink;
3645 s->value = resolv_vma - glink->vma;
3646 s->name = names;
3647 memcpy (names, "__glink_PLTresolve", sizeof ("__glink_PLTresolve"));
3648 names += sizeof ("__glink_PLTresolve");
3649 s++;
3650 count++;
3651 }
3652
3653 /* FIXME: It would be very much nicer to put sym@plt on the
3654 stub rather than on the glink branch table entry. The
3655 objdump disassembler would then use a sensible symbol
3656 name on plt calls. The difficulty in doing so is
3657 a) finding the stubs, and,
3658 b) matching stubs against plt entries, and,
3659 c) there can be multiple stubs for a given plt entry.
3660
3661 Solving (a) could be done by code scanning, but older
3662 ppc64 binaries used different stubs to current code.
3663 (b) is the tricky one since you need to known the toc
3664 pointer for at least one function that uses a pic stub to
3665 be able to calculate the plt address referenced.
3666 (c) means gdb would need to set multiple breakpoints (or
3667 find the glink branch itself) when setting breakpoints
3668 for pending shared library loads. */
3669 p = relplt->relocation;
3670 for (i = 0; i < plt_count; i++, p++)
3671 {
3672 size_t len;
3673
3674 *s = **p->sym_ptr_ptr;
3675 /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set. Since
3676 we are defining a symbol, ensure one of them is set. */
3677 if ((s->flags & BSF_LOCAL) == 0)
3678 s->flags |= BSF_GLOBAL;
3679 s->flags |= BSF_SYNTHETIC;
3680 s->section = glink;
3681 s->value = glink_vma - glink->vma;
3682 s->name = names;
3683 s->udata.p = NULL;
3684 len = strlen ((*p->sym_ptr_ptr)->name);
3685 memcpy (names, (*p->sym_ptr_ptr)->name, len);
3686 names += len;
3687 if (p->addend != 0)
3688 {
3689 memcpy (names, "+0x", sizeof ("+0x") - 1);
3690 names += sizeof ("+0x") - 1;
3691 bfd_sprintf_vma (abfd, names, p->addend);
3692 names += strlen (names);
3693 }
3694 memcpy (names, "@plt", sizeof ("@plt"));
3695 names += sizeof ("@plt");
3696 s++;
3697 if (abi < 2)
3698 {
3699 glink_vma += 8;
3700 if (i >= 0x8000)
3701 glink_vma += 4;
3702 }
3703 else
3704 glink_vma += 4;
3705 }
3706 count += plt_count;
3707 }
3708 }
3709
3710 done:
3711 free (syms);
3712 return count;
3713 }
3714 \f
3715 /* The following functions are specific to the ELF linker, while
3716 functions above are used generally. Those named ppc64_elf_* are
3717 called by the main ELF linker code. They appear in this file more
3718 or less in the order in which they are called. eg.
3719 ppc64_elf_check_relocs is called early in the link process,
3720 ppc64_elf_finish_dynamic_sections is one of the last functions
3721 called.
3722
3723 PowerPC64-ELF uses a similar scheme to PowerPC64-XCOFF in that
3724 functions have both a function code symbol and a function descriptor
3725 symbol. A call to foo in a relocatable object file looks like:
3726
3727 . .text
3728 . x:
3729 . bl .foo
3730 . nop
3731
3732 The function definition in another object file might be:
3733
3734 . .section .opd
3735 . foo: .quad .foo
3736 . .quad .TOC.@tocbase
3737 . .quad 0
3738 .
3739 . .text
3740 . .foo: blr
3741
3742 When the linker resolves the call during a static link, the branch
3743 unsurprisingly just goes to .foo and the .opd information is unused.
3744 If the function definition is in a shared library, things are a little
3745 different: The call goes via a plt call stub, the opd information gets
3746 copied to the plt, and the linker patches the nop.
3747
3748 . x:
3749 . bl .foo_stub
3750 . ld 2,40(1)
3751 .
3752 .
3753 . .foo_stub:
3754 . std 2,40(1) # in practice, the call stub
3755 . addis 11,2,Lfoo@toc@ha # is slightly optimized, but
3756 . addi 11,11,Lfoo@toc@l # this is the general idea
3757 . ld 12,0(11)
3758 . ld 2,8(11)
3759 . mtctr 12
3760 . ld 11,16(11)
3761 . bctr
3762 .
3763 . .section .plt
3764 . Lfoo: reloc (R_PPC64_JMP_SLOT, foo)
3765
3766 The "reloc ()" notation is supposed to indicate that the linker emits
3767 an R_PPC64_JMP_SLOT reloc against foo. The dynamic linker does the opd
3768 copying.
3769
3770 What are the difficulties here? Well, firstly, the relocations
3771 examined by the linker in check_relocs are against the function code
3772 sym .foo, while the dynamic relocation in the plt is emitted against
3773 the function descriptor symbol, foo. Somewhere along the line, we need
3774 to carefully copy dynamic link information from one symbol to the other.
3775 Secondly, the generic part of the elf linker will make .foo a dynamic
3776 symbol as is normal for most other backends. We need foo dynamic
3777 instead, at least for an application final link. However, when
3778 creating a shared library containing foo, we need to have both symbols
3779 dynamic so that references to .foo are satisfied during the early
3780 stages of linking. Otherwise the linker might decide to pull in a
3781 definition from some other object, eg. a static library.
3782
3783 Update: As of August 2004, we support a new convention. Function
3784 calls may use the function descriptor symbol, ie. "bl foo". This
3785 behaves exactly as "bl .foo". */
3786
3787 /* Of those relocs that might be copied as dynamic relocs, this function
3788 selects those that must be copied when linking a shared library,
3789 even when the symbol is local. */
3790
3791 static int
3792 must_be_dyn_reloc (struct bfd_link_info *info,
3793 enum elf_ppc64_reloc_type r_type)
3794 {
3795 switch (r_type)
3796 {
3797 default:
3798 return 1;
3799
3800 case R_PPC64_REL32:
3801 case R_PPC64_REL64:
3802 case R_PPC64_REL30:
3803 return 0;
3804
3805 case R_PPC64_TPREL16:
3806 case R_PPC64_TPREL16_LO:
3807 case R_PPC64_TPREL16_HI:
3808 case R_PPC64_TPREL16_HA:
3809 case R_PPC64_TPREL16_DS:
3810 case R_PPC64_TPREL16_LO_DS:
3811 case R_PPC64_TPREL16_HIGH:
3812 case R_PPC64_TPREL16_HIGHA:
3813 case R_PPC64_TPREL16_HIGHER:
3814 case R_PPC64_TPREL16_HIGHERA:
3815 case R_PPC64_TPREL16_HIGHEST:
3816 case R_PPC64_TPREL16_HIGHESTA:
3817 case R_PPC64_TPREL64:
3818 return !bfd_link_executable (info);
3819 }
3820 }
3821
3822 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
3823 copying dynamic variables from a shared lib into an app's dynbss
3824 section, and instead use a dynamic relocation to point into the
3825 shared lib. With code that gcc generates, it's vital that this be
3826 enabled; In the PowerPC64 ABI, the address of a function is actually
3827 the address of a function descriptor, which resides in the .opd
3828 section. gcc uses the descriptor directly rather than going via the
3829 GOT as some other ABI's do, which means that initialized function
3830 pointers must reference the descriptor. Thus, a function pointer
3831 initialized to the address of a function in a shared library will
3832 either require a copy reloc, or a dynamic reloc. Using a copy reloc
3833 redefines the function descriptor symbol to point to the copy. This
3834 presents a problem as a plt entry for that function is also
3835 initialized from the function descriptor symbol and the copy reloc
3836 may not be initialized first. */
3837 #define ELIMINATE_COPY_RELOCS 1
3838
3839 /* Section name for stubs is the associated section name plus this
3840 string. */
3841 #define STUB_SUFFIX ".stub"
3842
3843 /* Linker stubs.
3844 ppc_stub_long_branch:
3845 Used when a 14 bit branch (or even a 24 bit branch) can't reach its
3846 destination, but a 24 bit branch in a stub section will reach.
3847 . b dest
3848
3849 ppc_stub_plt_branch:
3850 Similar to the above, but a 24 bit branch in the stub section won't
3851 reach its destination.
3852 . addis %r11,%r2,xxx@toc@ha
3853 . ld %r12,xxx@toc@l(%r11)
3854 . mtctr %r12
3855 . bctr
3856
3857 ppc_stub_plt_call:
3858 Used to call a function in a shared library. If it so happens that
3859 the plt entry referenced crosses a 64k boundary, then an extra
3860 "addi %r11,%r11,xxx@toc@l" will be inserted before the "mtctr".
3861 . std %r2,40(%r1)
3862 . addis %r11,%r2,xxx@toc@ha
3863 . ld %r12,xxx+0@toc@l(%r11)
3864 . mtctr %r12
3865 . ld %r2,xxx+8@toc@l(%r11)
3866 . ld %r11,xxx+16@toc@l(%r11)
3867 . bctr
3868
3869 ppc_stub_long_branch and ppc_stub_plt_branch may also have additional
3870 code to adjust the value and save r2 to support multiple toc sections.
3871 A ppc_stub_long_branch with an r2 offset looks like:
3872 . std %r2,40(%r1)
3873 . addis %r2,%r2,off@ha
3874 . addi %r2,%r2,off@l
3875 . b dest
3876
3877 A ppc_stub_plt_branch with an r2 offset looks like:
3878 . std %r2,40(%r1)
3879 . addis %r11,%r2,xxx@toc@ha
3880 . ld %r12,xxx@toc@l(%r11)
3881 . addis %r2,%r2,off@ha
3882 . addi %r2,%r2,off@l
3883 . mtctr %r12
3884 . bctr
3885
3886 In cases where the "addis" instruction would add zero, the "addis" is
3887 omitted and following instructions modified slightly in some cases.
3888 */
3889
3890 enum ppc_stub_type {
3891 ppc_stub_none,
3892 ppc_stub_long_branch,
3893 ppc_stub_long_branch_r2off,
3894 ppc_stub_plt_branch,
3895 ppc_stub_plt_branch_r2off,
3896 ppc_stub_plt_call,
3897 ppc_stub_plt_call_r2save,
3898 ppc_stub_global_entry,
3899 ppc_stub_save_res
3900 };
3901
3902 /* Information on stub grouping. */
3903 struct map_stub
3904 {
3905 /* The stub section. */
3906 asection *stub_sec;
3907 /* This is the section to which stubs in the group will be attached. */
3908 asection *link_sec;
3909 /* Next group. */
3910 struct map_stub *next;
3911 /* Whether to emit a copy of register save/restore functions in this
3912 group. */
3913 int needs_save_res;
3914 };
3915
3916 struct ppc_stub_hash_entry {
3917
3918 /* Base hash table entry structure. */
3919 struct bfd_hash_entry root;
3920
3921 enum ppc_stub_type stub_type;
3922
3923 /* Group information. */
3924 struct map_stub *group;
3925
3926 /* Offset within stub_sec of the beginning of this stub. */
3927 bfd_vma stub_offset;
3928
3929 /* Given the symbol's value and its section we can determine its final
3930 value when building the stubs (so the stub knows where to jump. */
3931 bfd_vma target_value;
3932 asection *target_section;
3933
3934 /* The symbol table entry, if any, that this was derived from. */
3935 struct ppc_link_hash_entry *h;
3936 struct plt_entry *plt_ent;
3937
3938 /* Symbol st_other. */
3939 unsigned char other;
3940 };
3941
3942 struct ppc_branch_hash_entry {
3943
3944 /* Base hash table entry structure. */
3945 struct bfd_hash_entry root;
3946
3947 /* Offset within branch lookup table. */
3948 unsigned int offset;
3949
3950 /* Generation marker. */
3951 unsigned int iter;
3952 };
3953
3954 /* Used to track dynamic relocations for local symbols. */
3955 struct ppc_dyn_relocs
3956 {
3957 struct ppc_dyn_relocs *next;
3958
3959 /* The input section of the reloc. */
3960 asection *sec;
3961
3962 /* Total number of relocs copied for the input section. */
3963 unsigned int count : 31;
3964
3965 /* Whether this entry is for STT_GNU_IFUNC symbols. */
3966 unsigned int ifunc : 1;
3967 };
3968
3969 struct ppc_link_hash_entry
3970 {
3971 struct elf_link_hash_entry elf;
3972
3973 union {
3974 /* A pointer to the most recently used stub hash entry against this
3975 symbol. */
3976 struct ppc_stub_hash_entry *stub_cache;
3977
3978 /* A pointer to the next symbol starting with a '.' */
3979 struct ppc_link_hash_entry *next_dot_sym;
3980 } u;
3981
3982 /* Track dynamic relocs copied for this symbol. */
3983 struct elf_dyn_relocs *dyn_relocs;
3984
3985 /* Chain of aliases referring to a weakdef. */
3986 struct ppc_link_hash_entry *weakref;
3987
3988 /* Link between function code and descriptor symbols. */
3989 struct ppc_link_hash_entry *oh;
3990
3991 /* Flag function code and descriptor symbols. */
3992 unsigned int is_func:1;
3993 unsigned int is_func_descriptor:1;
3994 unsigned int fake:1;
3995
3996 /* Whether global opd/toc sym has been adjusted or not.
3997 After ppc64_elf_edit_opd/ppc64_elf_edit_toc has run, this flag
3998 should be set for all globals defined in any opd/toc section. */
3999 unsigned int adjust_done:1;
4000
4001 /* Set if this is an out-of-line register save/restore function,
4002 with non-standard calling convention. */
4003 unsigned int save_res:1;
4004
4005 /* Contexts in which symbol is used in the GOT (or TOC).
4006 TLS_GD .. TLS_EXPLICIT bits are or'd into the mask as the
4007 corresponding relocs are encountered during check_relocs.
4008 tls_optimize clears TLS_GD .. TLS_TPREL when optimizing to
4009 indicate the corresponding GOT entry type is not needed.
4010 tls_optimize may also set TLS_TPRELGD when a GD reloc turns into
4011 a TPREL one. We use a separate flag rather than setting TPREL
4012 just for convenience in distinguishing the two cases. */
4013 #define TLS_GD 1 /* GD reloc. */
4014 #define TLS_LD 2 /* LD reloc. */
4015 #define TLS_TPREL 4 /* TPREL reloc, => IE. */
4016 #define TLS_DTPREL 8 /* DTPREL reloc, => LD. */
4017 #define TLS_TLS 16 /* Any TLS reloc. */
4018 #define TLS_EXPLICIT 32 /* Marks TOC section TLS relocs. */
4019 #define TLS_TPRELGD 64 /* TPREL reloc resulting from GD->IE. */
4020 #define PLT_IFUNC 128 /* STT_GNU_IFUNC. */
4021 unsigned char tls_mask;
4022 };
4023
4024 /* ppc64 ELF linker hash table. */
4025
4026 struct ppc_link_hash_table
4027 {
4028 struct elf_link_hash_table elf;
4029
4030 /* The stub hash table. */
4031 struct bfd_hash_table stub_hash_table;
4032
4033 /* Another hash table for plt_branch stubs. */
4034 struct bfd_hash_table branch_hash_table;
4035
4036 /* Hash table for function prologue tocsave. */
4037 htab_t tocsave_htab;
4038
4039 /* Various options and other info passed from the linker. */
4040 struct ppc64_elf_params *params;
4041
4042 /* The size of sec_info below. */
4043 unsigned int sec_info_arr_size;
4044
4045 /* Per-section array of extra section info. Done this way rather
4046 than as part of ppc64_elf_section_data so we have the info for
4047 non-ppc64 sections. */
4048 struct
4049 {
4050 /* Along with elf_gp, specifies the TOC pointer used by this section. */
4051 bfd_vma toc_off;
4052
4053 union
4054 {
4055 /* The section group that this section belongs to. */
4056 struct map_stub *group;
4057 /* A temp section list pointer. */
4058 asection *list;
4059 } u;
4060 } *sec_info;
4061
4062 /* Linked list of groups. */
4063 struct map_stub *group;
4064
4065 /* Temp used when calculating TOC pointers. */
4066 bfd_vma toc_curr;
4067 bfd *toc_bfd;
4068 asection *toc_first_sec;
4069
4070 /* Used when adding symbols. */
4071 struct ppc_link_hash_entry *dot_syms;
4072
4073 /* Shortcuts to get to dynamic linker sections. */
4074 asection *glink;
4075 asection *sfpr;
4076 asection *brlt;
4077 asection *relbrlt;
4078 asection *glink_eh_frame;
4079
4080 /* Shortcut to .__tls_get_addr and __tls_get_addr. */
4081 struct ppc_link_hash_entry *tls_get_addr;
4082 struct ppc_link_hash_entry *tls_get_addr_fd;
4083
4084 /* The size of reliplt used by got entry relocs. */
4085 bfd_size_type got_reli_size;
4086
4087 /* Statistics. */
4088 unsigned long stub_count[ppc_stub_global_entry];
4089
4090 /* Number of stubs against global syms. */
4091 unsigned long stub_globals;
4092
4093 /* Set if we're linking code with function descriptors. */
4094 unsigned int opd_abi:1;
4095
4096 /* Support for multiple toc sections. */
4097 unsigned int do_multi_toc:1;
4098 unsigned int multi_toc_needed:1;
4099 unsigned int second_toc_pass:1;
4100 unsigned int do_toc_opt:1;
4101
4102 /* Set on error. */
4103 unsigned int stub_error:1;
4104
4105 /* Whether func_desc_adjust needs to be run over symbols. */
4106 unsigned int need_func_desc_adj:1;
4107
4108 /* Incremented every time we size stubs. */
4109 unsigned int stub_iteration;
4110
4111 /* Small local sym cache. */
4112 struct sym_cache sym_cache;
4113 };
4114
4115 /* Rename some of the generic section flags to better document how they
4116 are used here. */
4117
4118 /* Nonzero if this section has TLS related relocations. */
4119 #define has_tls_reloc sec_flg0
4120
4121 /* Nonzero if this section has a call to __tls_get_addr. */
4122 #define has_tls_get_addr_call sec_flg1
4123
4124 /* Nonzero if this section has any toc or got relocs. */
4125 #define has_toc_reloc sec_flg2
4126
4127 /* Nonzero if this section has a call to another section that uses
4128 the toc or got. */
4129 #define makes_toc_func_call sec_flg3
4130
4131 /* Recursion protection when determining above flag. */
4132 #define call_check_in_progress sec_flg4
4133 #define call_check_done sec_flg5
4134
4135 /* Get the ppc64 ELF linker hash table from a link_info structure. */
4136
4137 #define ppc_hash_table(p) \
4138 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
4139 == PPC64_ELF_DATA ? ((struct ppc_link_hash_table *) ((p)->hash)) : NULL)
4140
4141 #define ppc_stub_hash_lookup(table, string, create, copy) \
4142 ((struct ppc_stub_hash_entry *) \
4143 bfd_hash_lookup ((table), (string), (create), (copy)))
4144
4145 #define ppc_branch_hash_lookup(table, string, create, copy) \
4146 ((struct ppc_branch_hash_entry *) \
4147 bfd_hash_lookup ((table), (string), (create), (copy)))
4148
4149 /* Create an entry in the stub hash table. */
4150
4151 static struct bfd_hash_entry *
4152 stub_hash_newfunc (struct bfd_hash_entry *entry,
4153 struct bfd_hash_table *table,
4154 const char *string)
4155 {
4156 /* Allocate the structure if it has not already been allocated by a
4157 subclass. */
4158 if (entry == NULL)
4159 {
4160 entry = bfd_hash_allocate (table, sizeof (struct ppc_stub_hash_entry));
4161 if (entry == NULL)
4162 return entry;
4163 }
4164
4165 /* Call the allocation method of the superclass. */
4166 entry = bfd_hash_newfunc (entry, table, string);
4167 if (entry != NULL)
4168 {
4169 struct ppc_stub_hash_entry *eh;
4170
4171 /* Initialize the local fields. */
4172 eh = (struct ppc_stub_hash_entry *) entry;
4173 eh->stub_type = ppc_stub_none;
4174 eh->group = NULL;
4175 eh->stub_offset = 0;
4176 eh->target_value = 0;
4177 eh->target_section = NULL;
4178 eh->h = NULL;
4179 eh->plt_ent = NULL;
4180 eh->other = 0;
4181 }
4182
4183 return entry;
4184 }
4185
4186 /* Create an entry in the branch hash table. */
4187
4188 static struct bfd_hash_entry *
4189 branch_hash_newfunc (struct bfd_hash_entry *entry,
4190 struct bfd_hash_table *table,
4191 const char *string)
4192 {
4193 /* Allocate the structure if it has not already been allocated by a
4194 subclass. */
4195 if (entry == NULL)
4196 {
4197 entry = bfd_hash_allocate (table, sizeof (struct ppc_branch_hash_entry));
4198 if (entry == NULL)
4199 return entry;
4200 }
4201
4202 /* Call the allocation method of the superclass. */
4203 entry = bfd_hash_newfunc (entry, table, string);
4204 if (entry != NULL)
4205 {
4206 struct ppc_branch_hash_entry *eh;
4207
4208 /* Initialize the local fields. */
4209 eh = (struct ppc_branch_hash_entry *) entry;
4210 eh->offset = 0;
4211 eh->iter = 0;
4212 }
4213
4214 return entry;
4215 }
4216
4217 /* Create an entry in a ppc64 ELF linker hash table. */
4218
4219 static struct bfd_hash_entry *
4220 link_hash_newfunc (struct bfd_hash_entry *entry,
4221 struct bfd_hash_table *table,
4222 const char *string)
4223 {
4224 /* Allocate the structure if it has not already been allocated by a
4225 subclass. */
4226 if (entry == NULL)
4227 {
4228 entry = bfd_hash_allocate (table, sizeof (struct ppc_link_hash_entry));
4229 if (entry == NULL)
4230 return entry;
4231 }
4232
4233 /* Call the allocation method of the superclass. */
4234 entry = _bfd_elf_link_hash_newfunc (entry, table, string);
4235 if (entry != NULL)
4236 {
4237 struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) entry;
4238
4239 memset (&eh->u.stub_cache, 0,
4240 (sizeof (struct ppc_link_hash_entry)
4241 - offsetof (struct ppc_link_hash_entry, u.stub_cache)));
4242
4243 /* When making function calls, old ABI code references function entry
4244 points (dot symbols), while new ABI code references the function
4245 descriptor symbol. We need to make any combination of reference and
4246 definition work together, without breaking archive linking.
4247
4248 For a defined function "foo" and an undefined call to "bar":
4249 An old object defines "foo" and ".foo", references ".bar" (possibly
4250 "bar" too).
4251 A new object defines "foo" and references "bar".
4252
4253 A new object thus has no problem with its undefined symbols being
4254 satisfied by definitions in an old object. On the other hand, the
4255 old object won't have ".bar" satisfied by a new object.
4256
4257 Keep a list of newly added dot-symbols. */
4258
4259 if (string[0] == '.')
4260 {
4261 struct ppc_link_hash_table *htab;
4262
4263 htab = (struct ppc_link_hash_table *) table;
4264 eh->u.next_dot_sym = htab->dot_syms;
4265 htab->dot_syms = eh;
4266 }
4267 }
4268
4269 return entry;
4270 }
4271
4272 struct tocsave_entry {
4273 asection *sec;
4274 bfd_vma offset;
4275 };
4276
4277 static hashval_t
4278 tocsave_htab_hash (const void *p)
4279 {
4280 const struct tocsave_entry *e = (const struct tocsave_entry *) p;
4281 return ((bfd_vma) (intptr_t) e->sec ^ e->offset) >> 3;
4282 }
4283
4284 static int
4285 tocsave_htab_eq (const void *p1, const void *p2)
4286 {
4287 const struct tocsave_entry *e1 = (const struct tocsave_entry *) p1;
4288 const struct tocsave_entry *e2 = (const struct tocsave_entry *) p2;
4289 return e1->sec == e2->sec && e1->offset == e2->offset;
4290 }
4291
4292 /* Destroy a ppc64 ELF linker hash table. */
4293
4294 static void
4295 ppc64_elf_link_hash_table_free (bfd *obfd)
4296 {
4297 struct ppc_link_hash_table *htab;
4298
4299 htab = (struct ppc_link_hash_table *) obfd->link.hash;
4300 if (htab->tocsave_htab)
4301 htab_delete (htab->tocsave_htab);
4302 bfd_hash_table_free (&htab->branch_hash_table);
4303 bfd_hash_table_free (&htab->stub_hash_table);
4304 _bfd_elf_link_hash_table_free (obfd);
4305 }
4306
4307 /* Create a ppc64 ELF linker hash table. */
4308
4309 static struct bfd_link_hash_table *
4310 ppc64_elf_link_hash_table_create (bfd *abfd)
4311 {
4312 struct ppc_link_hash_table *htab;
4313 bfd_size_type amt = sizeof (struct ppc_link_hash_table);
4314
4315 htab = bfd_zmalloc (amt);
4316 if (htab == NULL)
4317 return NULL;
4318
4319 if (!_bfd_elf_link_hash_table_init (&htab->elf, abfd, link_hash_newfunc,
4320 sizeof (struct ppc_link_hash_entry),
4321 PPC64_ELF_DATA))
4322 {
4323 free (htab);
4324 return NULL;
4325 }
4326
4327 /* Init the stub hash table too. */
4328 if (!bfd_hash_table_init (&htab->stub_hash_table, stub_hash_newfunc,
4329 sizeof (struct ppc_stub_hash_entry)))
4330 {
4331 _bfd_elf_link_hash_table_free (abfd);
4332 return NULL;
4333 }
4334
4335 /* And the branch hash table. */
4336 if (!bfd_hash_table_init (&htab->branch_hash_table, branch_hash_newfunc,
4337 sizeof (struct ppc_branch_hash_entry)))
4338 {
4339 bfd_hash_table_free (&htab->stub_hash_table);
4340 _bfd_elf_link_hash_table_free (abfd);
4341 return NULL;
4342 }
4343
4344 htab->tocsave_htab = htab_try_create (1024,
4345 tocsave_htab_hash,
4346 tocsave_htab_eq,
4347 NULL);
4348 if (htab->tocsave_htab == NULL)
4349 {
4350 ppc64_elf_link_hash_table_free (abfd);
4351 return NULL;
4352 }
4353 htab->elf.root.hash_table_free = ppc64_elf_link_hash_table_free;
4354
4355 /* Initializing two fields of the union is just cosmetic. We really
4356 only care about glist, but when compiled on a 32-bit host the
4357 bfd_vma fields are larger. Setting the bfd_vma to zero makes
4358 debugger inspection of these fields look nicer. */
4359 htab->elf.init_got_refcount.refcount = 0;
4360 htab->elf.init_got_refcount.glist = NULL;
4361 htab->elf.init_plt_refcount.refcount = 0;
4362 htab->elf.init_plt_refcount.glist = NULL;
4363 htab->elf.init_got_offset.offset = 0;
4364 htab->elf.init_got_offset.glist = NULL;
4365 htab->elf.init_plt_offset.offset = 0;
4366 htab->elf.init_plt_offset.glist = NULL;
4367
4368 return &htab->elf.root;
4369 }
4370
4371 /* Create sections for linker generated code. */
4372
4373 static bfd_boolean
4374 create_linkage_sections (bfd *dynobj, struct bfd_link_info *info)
4375 {
4376 struct ppc_link_hash_table *htab;
4377 flagword flags;
4378
4379 htab = ppc_hash_table (info);
4380
4381 flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY
4382 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4383 if (htab->params->save_restore_funcs)
4384 {
4385 /* Create .sfpr for code to save and restore fp regs. */
4386 htab->sfpr = bfd_make_section_anyway_with_flags (dynobj, ".sfpr",
4387 flags);
4388 if (htab->sfpr == NULL
4389 || ! bfd_set_section_alignment (dynobj, htab->sfpr, 2))
4390 return FALSE;
4391 }
4392
4393 if (bfd_link_relocatable (info))
4394 return TRUE;
4395
4396 /* Create .glink for lazy dynamic linking support. */
4397 htab->glink = bfd_make_section_anyway_with_flags (dynobj, ".glink",
4398 flags);
4399 if (htab->glink == NULL
4400 || ! bfd_set_section_alignment (dynobj, htab->glink, 3))
4401 return FALSE;
4402
4403 if (!info->no_ld_generated_unwind_info)
4404 {
4405 flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_HAS_CONTENTS
4406 | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4407 htab->glink_eh_frame = bfd_make_section_anyway_with_flags (dynobj,
4408 ".eh_frame",
4409 flags);
4410 if (htab->glink_eh_frame == NULL
4411 || !bfd_set_section_alignment (dynobj, htab->glink_eh_frame, 2))
4412 return FALSE;
4413 }
4414
4415 flags = SEC_ALLOC | SEC_LINKER_CREATED;
4416 htab->elf.iplt = bfd_make_section_anyway_with_flags (dynobj, ".iplt", flags);
4417 if (htab->elf.iplt == NULL
4418 || ! bfd_set_section_alignment (dynobj, htab->elf.iplt, 3))
4419 return FALSE;
4420
4421 flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4422 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4423 htab->elf.irelplt
4424 = bfd_make_section_anyway_with_flags (dynobj, ".rela.iplt", flags);
4425 if (htab->elf.irelplt == NULL
4426 || ! bfd_set_section_alignment (dynobj, htab->elf.irelplt, 3))
4427 return FALSE;
4428
4429 /* Create branch lookup table for plt_branch stubs. */
4430 flags = (SEC_ALLOC | SEC_LOAD
4431 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4432 htab->brlt = bfd_make_section_anyway_with_flags (dynobj, ".branch_lt",
4433 flags);
4434 if (htab->brlt == NULL
4435 || ! bfd_set_section_alignment (dynobj, htab->brlt, 3))
4436 return FALSE;
4437
4438 if (!bfd_link_pic (info))
4439 return TRUE;
4440
4441 flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4442 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4443 htab->relbrlt = bfd_make_section_anyway_with_flags (dynobj,
4444 ".rela.branch_lt",
4445 flags);
4446 if (htab->relbrlt == NULL
4447 || ! bfd_set_section_alignment (dynobj, htab->relbrlt, 3))
4448 return FALSE;
4449
4450 return TRUE;
4451 }
4452
4453 /* Satisfy the ELF linker by filling in some fields in our fake bfd. */
4454
4455 bfd_boolean
4456 ppc64_elf_init_stub_bfd (struct bfd_link_info *info,
4457 struct ppc64_elf_params *params)
4458 {
4459 struct ppc_link_hash_table *htab;
4460
4461 elf_elfheader (params->stub_bfd)->e_ident[EI_CLASS] = ELFCLASS64;
4462
4463 /* Always hook our dynamic sections into the first bfd, which is the
4464 linker created stub bfd. This ensures that the GOT header is at
4465 the start of the output TOC section. */
4466 htab = ppc_hash_table (info);
4467 htab->elf.dynobj = params->stub_bfd;
4468 htab->params = params;
4469
4470 return create_linkage_sections (htab->elf.dynobj, info);
4471 }
4472
4473 /* Build a name for an entry in the stub hash table. */
4474
4475 static char *
4476 ppc_stub_name (const asection *input_section,
4477 const asection *sym_sec,
4478 const struct ppc_link_hash_entry *h,
4479 const Elf_Internal_Rela *rel)
4480 {
4481 char *stub_name;
4482 ssize_t len;
4483
4484 /* rel->r_addend is actually 64 bit, but who uses more than +/- 2^31
4485 offsets from a sym as a branch target? In fact, we could
4486 probably assume the addend is always zero. */
4487 BFD_ASSERT (((int) rel->r_addend & 0xffffffff) == rel->r_addend);
4488
4489 if (h)
4490 {
4491 len = 8 + 1 + strlen (h->elf.root.root.string) + 1 + 8 + 1;
4492 stub_name = bfd_malloc (len);
4493 if (stub_name == NULL)
4494 return stub_name;
4495
4496 len = sprintf (stub_name, "%08x.%s+%x",
4497 input_section->id & 0xffffffff,
4498 h->elf.root.root.string,
4499 (int) rel->r_addend & 0xffffffff);
4500 }
4501 else
4502 {
4503 len = 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1;
4504 stub_name = bfd_malloc (len);
4505 if (stub_name == NULL)
4506 return stub_name;
4507
4508 len = sprintf (stub_name, "%08x.%x:%x+%x",
4509 input_section->id & 0xffffffff,
4510 sym_sec->id & 0xffffffff,
4511 (int) ELF64_R_SYM (rel->r_info) & 0xffffffff,
4512 (int) rel->r_addend & 0xffffffff);
4513 }
4514 if (len > 2 && stub_name[len - 2] == '+' && stub_name[len - 1] == '0')
4515 stub_name[len - 2] = 0;
4516 return stub_name;
4517 }
4518
4519 /* Look up an entry in the stub hash. Stub entries are cached because
4520 creating the stub name takes a bit of time. */
4521
4522 static struct ppc_stub_hash_entry *
4523 ppc_get_stub_entry (const asection *input_section,
4524 const asection *sym_sec,
4525 struct ppc_link_hash_entry *h,
4526 const Elf_Internal_Rela *rel,
4527 struct ppc_link_hash_table *htab)
4528 {
4529 struct ppc_stub_hash_entry *stub_entry;
4530 struct map_stub *group;
4531
4532 /* If this input section is part of a group of sections sharing one
4533 stub section, then use the id of the first section in the group.
4534 Stub names need to include a section id, as there may well be
4535 more than one stub used to reach say, printf, and we need to
4536 distinguish between them. */
4537 group = htab->sec_info[input_section->id].u.group;
4538 if (group == NULL)
4539 return NULL;
4540
4541 if (h != NULL && h->u.stub_cache != NULL
4542 && h->u.stub_cache->h == h
4543 && h->u.stub_cache->group == group)
4544 {
4545 stub_entry = h->u.stub_cache;
4546 }
4547 else
4548 {
4549 char *stub_name;
4550
4551 stub_name = ppc_stub_name (group->link_sec, sym_sec, h, rel);
4552 if (stub_name == NULL)
4553 return NULL;
4554
4555 stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
4556 stub_name, FALSE, FALSE);
4557 if (h != NULL)
4558 h->u.stub_cache = stub_entry;
4559
4560 free (stub_name);
4561 }
4562
4563 return stub_entry;
4564 }
4565
4566 /* Add a new stub entry to the stub hash. Not all fields of the new
4567 stub entry are initialised. */
4568
4569 static struct ppc_stub_hash_entry *
4570 ppc_add_stub (const char *stub_name,
4571 asection *section,
4572 struct bfd_link_info *info)
4573 {
4574 struct ppc_link_hash_table *htab = ppc_hash_table (info);
4575 struct map_stub *group;
4576 asection *link_sec;
4577 asection *stub_sec;
4578 struct ppc_stub_hash_entry *stub_entry;
4579
4580 group = htab->sec_info[section->id].u.group;
4581 link_sec = group->link_sec;
4582 stub_sec = group->stub_sec;
4583 if (stub_sec == NULL)
4584 {
4585 size_t namelen;
4586 bfd_size_type len;
4587 char *s_name;
4588
4589 namelen = strlen (link_sec->name);
4590 len = namelen + sizeof (STUB_SUFFIX);
4591 s_name = bfd_alloc (htab->params->stub_bfd, len);
4592 if (s_name == NULL)
4593 return NULL;
4594
4595 memcpy (s_name, link_sec->name, namelen);
4596 memcpy (s_name + namelen, STUB_SUFFIX, sizeof (STUB_SUFFIX));
4597 stub_sec = (*htab->params->add_stub_section) (s_name, link_sec);
4598 if (stub_sec == NULL)
4599 return NULL;
4600 group->stub_sec = stub_sec;
4601 }
4602
4603 /* Enter this entry into the linker stub hash table. */
4604 stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table, stub_name,
4605 TRUE, FALSE);
4606 if (stub_entry == NULL)
4607 {
4608 /* xgettext:c-format */
4609 info->callbacks->einfo (_("%P: %B: cannot create stub entry %s\n"),
4610 section->owner, stub_name);
4611 return NULL;
4612 }
4613
4614 stub_entry->group = group;
4615 stub_entry->stub_offset = 0;
4616 return stub_entry;
4617 }
4618
4619 /* Create .got and .rela.got sections in ABFD, and .got in dynobj if
4620 not already done. */
4621
4622 static bfd_boolean
4623 create_got_section (bfd *abfd, struct bfd_link_info *info)
4624 {
4625 asection *got, *relgot;
4626 flagword flags;
4627 struct ppc_link_hash_table *htab = ppc_hash_table (info);
4628
4629 if (!is_ppc64_elf (abfd))
4630 return FALSE;
4631 if (htab == NULL)
4632 return FALSE;
4633
4634 if (!htab->elf.sgot
4635 && !_bfd_elf_create_got_section (htab->elf.dynobj, info))
4636 return FALSE;
4637
4638 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
4639 | SEC_LINKER_CREATED);
4640
4641 got = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
4642 if (!got
4643 || !bfd_set_section_alignment (abfd, got, 3))
4644 return FALSE;
4645
4646 relgot = bfd_make_section_anyway_with_flags (abfd, ".rela.got",
4647 flags | SEC_READONLY);
4648 if (!relgot
4649 || ! bfd_set_section_alignment (abfd, relgot, 3))
4650 return FALSE;
4651
4652 ppc64_elf_tdata (abfd)->got = got;
4653 ppc64_elf_tdata (abfd)->relgot = relgot;
4654 return TRUE;
4655 }
4656
4657 /* Follow indirect and warning symbol links. */
4658
4659 static inline struct bfd_link_hash_entry *
4660 follow_link (struct bfd_link_hash_entry *h)
4661 {
4662 while (h->type == bfd_link_hash_indirect
4663 || h->type == bfd_link_hash_warning)
4664 h = h->u.i.link;
4665 return h;
4666 }
4667
4668 static inline struct elf_link_hash_entry *
4669 elf_follow_link (struct elf_link_hash_entry *h)
4670 {
4671 return (struct elf_link_hash_entry *) follow_link (&h->root);
4672 }
4673
4674 static inline struct ppc_link_hash_entry *
4675 ppc_follow_link (struct ppc_link_hash_entry *h)
4676 {
4677 return (struct ppc_link_hash_entry *) follow_link (&h->elf.root);
4678 }
4679
4680 /* Merge PLT info on FROM with that on TO. */
4681
4682 static void
4683 move_plt_plist (struct ppc_link_hash_entry *from,
4684 struct ppc_link_hash_entry *to)
4685 {
4686 if (from->elf.plt.plist != NULL)
4687 {
4688 if (to->elf.plt.plist != NULL)
4689 {
4690 struct plt_entry **entp;
4691 struct plt_entry *ent;
4692
4693 for (entp = &from->elf.plt.plist; (ent = *entp) != NULL; )
4694 {
4695 struct plt_entry *dent;
4696
4697 for (dent = to->elf.plt.plist; dent != NULL; dent = dent->next)
4698 if (dent->addend == ent->addend)
4699 {
4700 dent->plt.refcount += ent->plt.refcount;
4701 *entp = ent->next;
4702 break;
4703 }
4704 if (dent == NULL)
4705 entp = &ent->next;
4706 }
4707 *entp = to->elf.plt.plist;
4708 }
4709
4710 to->elf.plt.plist = from->elf.plt.plist;
4711 from->elf.plt.plist = NULL;
4712 }
4713 }
4714
4715 /* Copy the extra info we tack onto an elf_link_hash_entry. */
4716
4717 static void
4718 ppc64_elf_copy_indirect_symbol (struct bfd_link_info *info,
4719 struct elf_link_hash_entry *dir,
4720 struct elf_link_hash_entry *ind)
4721 {
4722 struct ppc_link_hash_entry *edir, *eind;
4723
4724 edir = (struct ppc_link_hash_entry *) dir;
4725 eind = (struct ppc_link_hash_entry *) ind;
4726
4727 edir->is_func |= eind->is_func;
4728 edir->is_func_descriptor |= eind->is_func_descriptor;
4729 edir->tls_mask |= eind->tls_mask;
4730 if (eind->oh != NULL)
4731 edir->oh = ppc_follow_link (eind->oh);
4732
4733 /* If called to transfer flags for a weakdef during processing
4734 of elf_adjust_dynamic_symbol, don't copy NON_GOT_REF.
4735 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
4736 if (!(ELIMINATE_COPY_RELOCS
4737 && eind->elf.root.type != bfd_link_hash_indirect
4738 && edir->elf.dynamic_adjusted))
4739 edir->elf.non_got_ref |= eind->elf.non_got_ref;
4740
4741 if (edir->elf.versioned != versioned_hidden)
4742 edir->elf.ref_dynamic |= eind->elf.ref_dynamic;
4743 edir->elf.ref_regular |= eind->elf.ref_regular;
4744 edir->elf.ref_regular_nonweak |= eind->elf.ref_regular_nonweak;
4745 edir->elf.needs_plt |= eind->elf.needs_plt;
4746 edir->elf.pointer_equality_needed |= eind->elf.pointer_equality_needed;
4747
4748 /* If we were called to copy over info for a weak sym, don't copy
4749 dyn_relocs, plt/got info, or dynindx. We used to copy dyn_relocs
4750 in order to simplify readonly_dynrelocs and save a field in the
4751 symbol hash entry, but that means dyn_relocs can't be used in any
4752 tests about a specific symbol, or affect other symbol flags which
4753 are then tested.
4754 Chain weakdefs so we can get from the weakdef back to an alias.
4755 The list is circular so that we don't need to use u.weakdef as
4756 well as this list to look at all aliases. */
4757 if (eind->elf.root.type != bfd_link_hash_indirect)
4758 {
4759 struct ppc_link_hash_entry *cur, *add, *next;
4760
4761 add = eind;
4762 do
4763 {
4764 cur = edir->weakref;
4765 if (cur != NULL)
4766 {
4767 do
4768 {
4769 /* We can be called twice for the same symbols.
4770 Don't make multiple loops. */
4771 if (cur == add)
4772 return;
4773 cur = cur->weakref;
4774 } while (cur != edir);
4775 }
4776 next = add->weakref;
4777 if (cur != add)
4778 {
4779 add->weakref = edir->weakref != NULL ? edir->weakref : edir;
4780 edir->weakref = add;
4781 }
4782 add = next;
4783 } while (add != NULL && add != eind);
4784 return;
4785 }
4786
4787 /* Copy over any dynamic relocs we may have on the indirect sym. */
4788 if (eind->dyn_relocs != NULL)
4789 {
4790 if (edir->dyn_relocs != NULL)
4791 {
4792 struct elf_dyn_relocs **pp;
4793 struct elf_dyn_relocs *p;
4794
4795 /* Add reloc counts against the indirect sym to the direct sym
4796 list. Merge any entries against the same section. */
4797 for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
4798 {
4799 struct elf_dyn_relocs *q;
4800
4801 for (q = edir->dyn_relocs; q != NULL; q = q->next)
4802 if (q->sec == p->sec)
4803 {
4804 q->pc_count += p->pc_count;
4805 q->count += p->count;
4806 *pp = p->next;
4807 break;
4808 }
4809 if (q == NULL)
4810 pp = &p->next;
4811 }
4812 *pp = edir->dyn_relocs;
4813 }
4814
4815 edir->dyn_relocs = eind->dyn_relocs;
4816 eind->dyn_relocs = NULL;
4817 }
4818
4819 /* Copy over got entries that we may have already seen to the
4820 symbol which just became indirect. */
4821 if (eind->elf.got.glist != NULL)
4822 {
4823 if (edir->elf.got.glist != NULL)
4824 {
4825 struct got_entry **entp;
4826 struct got_entry *ent;
4827
4828 for (entp = &eind->elf.got.glist; (ent = *entp) != NULL; )
4829 {
4830 struct got_entry *dent;
4831
4832 for (dent = edir->elf.got.glist; dent != NULL; dent = dent->next)
4833 if (dent->addend == ent->addend
4834 && dent->owner == ent->owner
4835 && dent->tls_type == ent->tls_type)
4836 {
4837 dent->got.refcount += ent->got.refcount;
4838 *entp = ent->next;
4839 break;
4840 }
4841 if (dent == NULL)
4842 entp = &ent->next;
4843 }
4844 *entp = edir->elf.got.glist;
4845 }
4846
4847 edir->elf.got.glist = eind->elf.got.glist;
4848 eind->elf.got.glist = NULL;
4849 }
4850
4851 /* And plt entries. */
4852 move_plt_plist (eind, edir);
4853
4854 if (eind->elf.dynindx != -1)
4855 {
4856 if (edir->elf.dynindx != -1)
4857 _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
4858 edir->elf.dynstr_index);
4859 edir->elf.dynindx = eind->elf.dynindx;
4860 edir->elf.dynstr_index = eind->elf.dynstr_index;
4861 eind->elf.dynindx = -1;
4862 eind->elf.dynstr_index = 0;
4863 }
4864 }
4865
4866 /* Find the function descriptor hash entry from the given function code
4867 hash entry FH. Link the entries via their OH fields. */
4868
4869 static struct ppc_link_hash_entry *
4870 lookup_fdh (struct ppc_link_hash_entry *fh, struct ppc_link_hash_table *htab)
4871 {
4872 struct ppc_link_hash_entry *fdh = fh->oh;
4873
4874 if (fdh == NULL)
4875 {
4876 const char *fd_name = fh->elf.root.root.string + 1;
4877
4878 fdh = (struct ppc_link_hash_entry *)
4879 elf_link_hash_lookup (&htab->elf, fd_name, FALSE, FALSE, FALSE);
4880 if (fdh == NULL)
4881 return fdh;
4882
4883 fdh->is_func_descriptor = 1;
4884 fdh->oh = fh;
4885 fh->is_func = 1;
4886 fh->oh = fdh;
4887 }
4888
4889 fdh = ppc_follow_link (fdh);
4890 fdh->is_func_descriptor = 1;
4891 fdh->oh = fh;
4892 return fdh;
4893 }
4894
4895 /* Make a fake function descriptor sym for the undefined code sym FH. */
4896
4897 static struct ppc_link_hash_entry *
4898 make_fdh (struct bfd_link_info *info,
4899 struct ppc_link_hash_entry *fh)
4900 {
4901 bfd *abfd = fh->elf.root.u.undef.abfd;
4902 struct bfd_link_hash_entry *bh = NULL;
4903 struct ppc_link_hash_entry *fdh;
4904 flagword flags = (fh->elf.root.type == bfd_link_hash_undefweak
4905 ? BSF_WEAK
4906 : BSF_GLOBAL);
4907
4908 if (!_bfd_generic_link_add_one_symbol (info, abfd,
4909 fh->elf.root.root.string + 1,
4910 flags, bfd_und_section_ptr, 0,
4911 NULL, FALSE, FALSE, &bh))
4912 return NULL;
4913
4914 fdh = (struct ppc_link_hash_entry *) bh;
4915 fdh->elf.non_elf = 0;
4916 fdh->fake = 1;
4917 fdh->is_func_descriptor = 1;
4918 fdh->oh = fh;
4919 fh->is_func = 1;
4920 fh->oh = fdh;
4921 return fdh;
4922 }
4923
4924 /* Fix function descriptor symbols defined in .opd sections to be
4925 function type. */
4926
4927 static bfd_boolean
4928 ppc64_elf_add_symbol_hook (bfd *ibfd,
4929 struct bfd_link_info *info,
4930 Elf_Internal_Sym *isym,
4931 const char **name,
4932 flagword *flags ATTRIBUTE_UNUSED,
4933 asection **sec,
4934 bfd_vma *value)
4935 {
4936 if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC
4937 && (ibfd->flags & DYNAMIC) == 0
4938 && bfd_get_flavour (info->output_bfd) == bfd_target_elf_flavour)
4939 elf_tdata (info->output_bfd)->has_gnu_symbols |= elf_gnu_symbol_ifunc;
4940
4941 if (*sec != NULL
4942 && strcmp ((*sec)->name, ".opd") == 0)
4943 {
4944 asection *code_sec;
4945
4946 if (!(ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC
4947 || ELF_ST_TYPE (isym->st_info) == STT_FUNC))
4948 isym->st_info = ELF_ST_INFO (ELF_ST_BIND (isym->st_info), STT_FUNC);
4949
4950 /* If the symbol is a function defined in .opd, and the function
4951 code is in a discarded group, let it appear to be undefined. */
4952 if (!bfd_link_relocatable (info)
4953 && (*sec)->reloc_count != 0
4954 && opd_entry_value (*sec, *value, &code_sec, NULL,
4955 FALSE) != (bfd_vma) -1
4956 && discarded_section (code_sec))
4957 {
4958 *sec = bfd_und_section_ptr;
4959 isym->st_shndx = SHN_UNDEF;
4960 }
4961 }
4962 else if (*sec != NULL
4963 && strcmp ((*sec)->name, ".toc") == 0
4964 && ELF_ST_TYPE (isym->st_info) == STT_OBJECT)
4965 {
4966 struct ppc_link_hash_table *htab = ppc_hash_table (info);
4967 if (htab != NULL)
4968 htab->params->object_in_toc = 1;
4969 }
4970
4971 if ((STO_PPC64_LOCAL_MASK & isym->st_other) != 0)
4972 {
4973 if (abiversion (ibfd) == 0)
4974 set_abiversion (ibfd, 2);
4975 else if (abiversion (ibfd) == 1)
4976 {
4977 info->callbacks->einfo (_("%P: symbol '%s' has invalid st_other"
4978 " for ABI version 1\n"), name);
4979 bfd_set_error (bfd_error_bad_value);
4980 return FALSE;
4981 }
4982 }
4983
4984 return TRUE;
4985 }
4986
4987 /* Merge non-visibility st_other attributes: local entry point. */
4988
4989 static void
4990 ppc64_elf_merge_symbol_attribute (struct elf_link_hash_entry *h,
4991 const Elf_Internal_Sym *isym,
4992 bfd_boolean definition,
4993 bfd_boolean dynamic)
4994 {
4995 if (definition && !dynamic)
4996 h->other = ((isym->st_other & ~ELF_ST_VISIBILITY (-1))
4997 | ELF_ST_VISIBILITY (h->other));
4998 }
4999
5000 /* Hook called on merging a symbol. We use this to clear "fake" since
5001 we now have a real symbol. */
5002
5003 static bfd_boolean
5004 ppc64_elf_merge_symbol (struct elf_link_hash_entry *h,
5005 const Elf_Internal_Sym *isym ATTRIBUTE_UNUSED,
5006 asection **psec ATTRIBUTE_UNUSED,
5007 bfd_boolean newdef ATTRIBUTE_UNUSED,
5008 bfd_boolean olddef ATTRIBUTE_UNUSED,
5009 bfd *oldbfd ATTRIBUTE_UNUSED,
5010 const asection *oldsec ATTRIBUTE_UNUSED)
5011 {
5012 ((struct ppc_link_hash_entry *) h)->fake = 0;
5013 return TRUE;
5014 }
5015
5016 /* This function makes an old ABI object reference to ".bar" cause the
5017 inclusion of a new ABI object archive that defines "bar".
5018 NAME is a symbol defined in an archive. Return a symbol in the hash
5019 table that might be satisfied by the archive symbols. */
5020
5021 static struct elf_link_hash_entry *
5022 ppc64_elf_archive_symbol_lookup (bfd *abfd,
5023 struct bfd_link_info *info,
5024 const char *name)
5025 {
5026 struct elf_link_hash_entry *h;
5027 char *dot_name;
5028 size_t len;
5029
5030 h = _bfd_elf_archive_symbol_lookup (abfd, info, name);
5031 if (h != NULL
5032 /* Don't return this sym if it is a fake function descriptor
5033 created by add_symbol_adjust. */
5034 && !((struct ppc_link_hash_entry *) h)->fake)
5035 return h;
5036
5037 if (name[0] == '.')
5038 return h;
5039
5040 len = strlen (name);
5041 dot_name = bfd_alloc (abfd, len + 2);
5042 if (dot_name == NULL)
5043 return (struct elf_link_hash_entry *) 0 - 1;
5044 dot_name[0] = '.';
5045 memcpy (dot_name + 1, name, len + 1);
5046 h = _bfd_elf_archive_symbol_lookup (abfd, info, dot_name);
5047 bfd_release (abfd, dot_name);
5048 return h;
5049 }
5050
5051 /* This function satisfies all old ABI object references to ".bar" if a
5052 new ABI object defines "bar". Well, at least, undefined dot symbols
5053 are made weak. This stops later archive searches from including an
5054 object if we already have a function descriptor definition. It also
5055 prevents the linker complaining about undefined symbols.
5056 We also check and correct mismatched symbol visibility here. The
5057 most restrictive visibility of the function descriptor and the
5058 function entry symbol is used. */
5059
5060 static bfd_boolean
5061 add_symbol_adjust (struct ppc_link_hash_entry *eh, struct bfd_link_info *info)
5062 {
5063 struct ppc_link_hash_table *htab;
5064 struct ppc_link_hash_entry *fdh;
5065
5066 if (eh->elf.root.type == bfd_link_hash_warning)
5067 eh = (struct ppc_link_hash_entry *) eh->elf.root.u.i.link;
5068
5069 if (eh->elf.root.type == bfd_link_hash_indirect)
5070 return TRUE;
5071
5072 if (eh->elf.root.root.string[0] != '.')
5073 abort ();
5074
5075 htab = ppc_hash_table (info);
5076 if (htab == NULL)
5077 return FALSE;
5078
5079 fdh = lookup_fdh (eh, htab);
5080 if (fdh == NULL
5081 && !bfd_link_relocatable (info)
5082 && (eh->elf.root.type == bfd_link_hash_undefined
5083 || eh->elf.root.type == bfd_link_hash_undefweak)
5084 && eh->elf.ref_regular)
5085 {
5086 /* Make an undefined function descriptor sym, in order to
5087 pull in an --as-needed shared lib. Archives are handled
5088 elsewhere. */
5089 fdh = make_fdh (info, eh);
5090 if (fdh == NULL)
5091 return FALSE;
5092 }
5093
5094 if (fdh != NULL)
5095 {
5096 unsigned entry_vis = ELF_ST_VISIBILITY (eh->elf.other) - 1;
5097 unsigned descr_vis = ELF_ST_VISIBILITY (fdh->elf.other) - 1;
5098
5099 /* Make both descriptor and entry symbol have the most
5100 constraining visibility of either symbol. */
5101 if (entry_vis < descr_vis)
5102 fdh->elf.other += entry_vis - descr_vis;
5103 else if (entry_vis > descr_vis)
5104 eh->elf.other += descr_vis - entry_vis;
5105
5106 /* Propagate reference flags from entry symbol to function
5107 descriptor symbol. */
5108 fdh->elf.root.non_ir_ref |= eh->elf.root.non_ir_ref;
5109 fdh->elf.ref_regular |= eh->elf.ref_regular;
5110 fdh->elf.ref_regular_nonweak |= eh->elf.ref_regular_nonweak;
5111
5112 if (!fdh->elf.forced_local
5113 && fdh->elf.dynindx == -1
5114 && fdh->elf.versioned != versioned_hidden
5115 && (bfd_link_dll (info)
5116 || fdh->elf.def_dynamic
5117 || fdh->elf.ref_dynamic)
5118 && (eh->elf.ref_regular
5119 || eh->elf.def_regular))
5120 {
5121 if (! bfd_elf_link_record_dynamic_symbol (info, &fdh->elf))
5122 return FALSE;
5123 }
5124 }
5125
5126 return TRUE;
5127 }
5128
5129 /* Set up opd section info and abiversion for IBFD, and process list
5130 of dot-symbols we made in link_hash_newfunc. */
5131
5132 static bfd_boolean
5133 ppc64_elf_before_check_relocs (bfd *ibfd, struct bfd_link_info *info)
5134 {
5135 struct ppc_link_hash_table *htab;
5136 struct ppc_link_hash_entry **p, *eh;
5137 asection *opd = bfd_get_section_by_name (ibfd, ".opd");
5138
5139 if (opd != NULL && opd->size != 0)
5140 {
5141 if (abiversion (ibfd) == 0)
5142 set_abiversion (ibfd, 1);
5143 else if (abiversion (ibfd) >= 2)
5144 {
5145 /* xgettext:c-format */
5146 info->callbacks->einfo (_("%P: %B .opd not allowed in ABI"
5147 " version %d\n"),
5148 ibfd, abiversion (ibfd));
5149 bfd_set_error (bfd_error_bad_value);
5150 return FALSE;
5151 }
5152
5153 if ((ibfd->flags & DYNAMIC) == 0
5154 && (opd->flags & SEC_RELOC) != 0
5155 && opd->reloc_count != 0
5156 && !bfd_is_abs_section (opd->output_section))
5157 {
5158 /* Garbage collection needs some extra help with .opd sections.
5159 We don't want to necessarily keep everything referenced by
5160 relocs in .opd, as that would keep all functions. Instead,
5161 if we reference an .opd symbol (a function descriptor), we
5162 want to keep the function code symbol's section. This is
5163 easy for global symbols, but for local syms we need to keep
5164 information about the associated function section. */
5165 bfd_size_type amt;
5166 asection **opd_sym_map;
5167
5168 amt = OPD_NDX (opd->size) * sizeof (*opd_sym_map);
5169 opd_sym_map = bfd_zalloc (ibfd, amt);
5170 if (opd_sym_map == NULL)
5171 return FALSE;
5172 ppc64_elf_section_data (opd)->u.opd.func_sec = opd_sym_map;
5173 BFD_ASSERT (ppc64_elf_section_data (opd)->sec_type == sec_normal);
5174 ppc64_elf_section_data (opd)->sec_type = sec_opd;
5175 }
5176 }
5177
5178 if (!is_ppc64_elf (info->output_bfd))
5179 return TRUE;
5180 htab = ppc_hash_table (info);
5181 if (htab == NULL)
5182 return FALSE;
5183
5184 /* For input files without an explicit abiversion in e_flags
5185 we should have flagged any with symbol st_other bits set
5186 as ELFv1 and above flagged those with .opd as ELFv2.
5187 Set the output abiversion if not yet set, and for any input
5188 still ambiguous, take its abiversion from the output.
5189 Differences in ABI are reported later. */
5190 if (abiversion (info->output_bfd) == 0)
5191 set_abiversion (info->output_bfd, abiversion (ibfd));
5192 else if (abiversion (ibfd) == 0)
5193 set_abiversion (ibfd, abiversion (info->output_bfd));
5194
5195 p = &htab->dot_syms;
5196 while ((eh = *p) != NULL)
5197 {
5198 *p = NULL;
5199 if (&eh->elf == htab->elf.hgot)
5200 ;
5201 else if (htab->elf.hgot == NULL
5202 && strcmp (eh->elf.root.root.string, ".TOC.") == 0)
5203 htab->elf.hgot = &eh->elf;
5204 else if (abiversion (ibfd) <= 1)
5205 {
5206 htab->need_func_desc_adj = 1;
5207 if (!add_symbol_adjust (eh, info))
5208 return FALSE;
5209 }
5210 p = &eh->u.next_dot_sym;
5211 }
5212 return TRUE;
5213 }
5214
5215 /* Undo hash table changes when an --as-needed input file is determined
5216 not to be needed. */
5217
5218 static bfd_boolean
5219 ppc64_elf_notice_as_needed (bfd *ibfd,
5220 struct bfd_link_info *info,
5221 enum notice_asneeded_action act)
5222 {
5223 if (act == notice_not_needed)
5224 {
5225 struct ppc_link_hash_table *htab = ppc_hash_table (info);
5226
5227 if (htab == NULL)
5228 return FALSE;
5229
5230 htab->dot_syms = NULL;
5231 }
5232 return _bfd_elf_notice_as_needed (ibfd, info, act);
5233 }
5234
5235 /* If --just-symbols against a final linked binary, then assume we need
5236 toc adjusting stubs when calling functions defined there. */
5237
5238 static void
5239 ppc64_elf_link_just_syms (asection *sec, struct bfd_link_info *info)
5240 {
5241 if ((sec->flags & SEC_CODE) != 0
5242 && (sec->owner->flags & (EXEC_P | DYNAMIC)) != 0
5243 && is_ppc64_elf (sec->owner))
5244 {
5245 if (abiversion (sec->owner) >= 2
5246 || bfd_get_section_by_name (sec->owner, ".opd") != NULL)
5247 sec->has_toc_reloc = 1;
5248 }
5249 _bfd_elf_link_just_syms (sec, info);
5250 }
5251
5252 static struct plt_entry **
5253 update_local_sym_info (bfd *abfd, Elf_Internal_Shdr *symtab_hdr,
5254 unsigned long r_symndx, bfd_vma r_addend, int tls_type)
5255 {
5256 struct got_entry **local_got_ents = elf_local_got_ents (abfd);
5257 struct plt_entry **local_plt;
5258 unsigned char *local_got_tls_masks;
5259
5260 if (local_got_ents == NULL)
5261 {
5262 bfd_size_type size = symtab_hdr->sh_info;
5263
5264 size *= (sizeof (*local_got_ents)
5265 + sizeof (*local_plt)
5266 + sizeof (*local_got_tls_masks));
5267 local_got_ents = bfd_zalloc (abfd, size);
5268 if (local_got_ents == NULL)
5269 return NULL;
5270 elf_local_got_ents (abfd) = local_got_ents;
5271 }
5272
5273 if ((tls_type & (PLT_IFUNC | TLS_EXPLICIT)) == 0)
5274 {
5275 struct got_entry *ent;
5276
5277 for (ent = local_got_ents[r_symndx]; ent != NULL; ent = ent->next)
5278 if (ent->addend == r_addend
5279 && ent->owner == abfd
5280 && ent->tls_type == tls_type)
5281 break;
5282 if (ent == NULL)
5283 {
5284 bfd_size_type amt = sizeof (*ent);
5285 ent = bfd_alloc (abfd, amt);
5286 if (ent == NULL)
5287 return FALSE;
5288 ent->next = local_got_ents[r_symndx];
5289 ent->addend = r_addend;
5290 ent->owner = abfd;
5291 ent->tls_type = tls_type;
5292 ent->is_indirect = FALSE;
5293 ent->got.refcount = 0;
5294 local_got_ents[r_symndx] = ent;
5295 }
5296 ent->got.refcount += 1;
5297 }
5298
5299 local_plt = (struct plt_entry **) (local_got_ents + symtab_hdr->sh_info);
5300 local_got_tls_masks = (unsigned char *) (local_plt + symtab_hdr->sh_info);
5301 local_got_tls_masks[r_symndx] |= tls_type;
5302
5303 return local_plt + r_symndx;
5304 }
5305
5306 static bfd_boolean
5307 update_plt_info (bfd *abfd, struct plt_entry **plist, bfd_vma addend)
5308 {
5309 struct plt_entry *ent;
5310
5311 for (ent = *plist; ent != NULL; ent = ent->next)
5312 if (ent->addend == addend)
5313 break;
5314 if (ent == NULL)
5315 {
5316 bfd_size_type amt = sizeof (*ent);
5317 ent = bfd_alloc (abfd, amt);
5318 if (ent == NULL)
5319 return FALSE;
5320 ent->next = *plist;
5321 ent->addend = addend;
5322 ent->plt.refcount = 0;
5323 *plist = ent;
5324 }
5325 ent->plt.refcount += 1;
5326 return TRUE;
5327 }
5328
5329 static bfd_boolean
5330 is_branch_reloc (enum elf_ppc64_reloc_type r_type)
5331 {
5332 return (r_type == R_PPC64_REL24
5333 || r_type == R_PPC64_REL14
5334 || r_type == R_PPC64_REL14_BRTAKEN
5335 || r_type == R_PPC64_REL14_BRNTAKEN
5336 || r_type == R_PPC64_ADDR24
5337 || r_type == R_PPC64_ADDR14
5338 || r_type == R_PPC64_ADDR14_BRTAKEN
5339 || r_type == R_PPC64_ADDR14_BRNTAKEN);
5340 }
5341
5342 /* Look through the relocs for a section during the first phase, and
5343 calculate needed space in the global offset table, procedure
5344 linkage table, and dynamic reloc sections. */
5345
5346 static bfd_boolean
5347 ppc64_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
5348 asection *sec, const Elf_Internal_Rela *relocs)
5349 {
5350 struct ppc_link_hash_table *htab;
5351 Elf_Internal_Shdr *symtab_hdr;
5352 struct elf_link_hash_entry **sym_hashes;
5353 const Elf_Internal_Rela *rel;
5354 const Elf_Internal_Rela *rel_end;
5355 asection *sreloc;
5356 asection **opd_sym_map;
5357 struct elf_link_hash_entry *tga, *dottga;
5358
5359 if (bfd_link_relocatable (info))
5360 return TRUE;
5361
5362 /* Don't do anything special with non-loaded, non-alloced sections.
5363 In particular, any relocs in such sections should not affect GOT
5364 and PLT reference counting (ie. we don't allow them to create GOT
5365 or PLT entries), there's no possibility or desire to optimize TLS
5366 relocs, and there's not much point in propagating relocs to shared
5367 libs that the dynamic linker won't relocate. */
5368 if ((sec->flags & SEC_ALLOC) == 0)
5369 return TRUE;
5370
5371 BFD_ASSERT (is_ppc64_elf (abfd));
5372
5373 htab = ppc_hash_table (info);
5374 if (htab == NULL)
5375 return FALSE;
5376
5377 tga = elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
5378 FALSE, FALSE, TRUE);
5379 dottga = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
5380 FALSE, FALSE, TRUE);
5381 symtab_hdr = &elf_symtab_hdr (abfd);
5382 sym_hashes = elf_sym_hashes (abfd);
5383 sreloc = NULL;
5384 opd_sym_map = NULL;
5385 if (ppc64_elf_section_data (sec) != NULL
5386 && ppc64_elf_section_data (sec)->sec_type == sec_opd)
5387 opd_sym_map = ppc64_elf_section_data (sec)->u.opd.func_sec;
5388
5389 rel_end = relocs + sec->reloc_count;
5390 for (rel = relocs; rel < rel_end; rel++)
5391 {
5392 unsigned long r_symndx;
5393 struct elf_link_hash_entry *h;
5394 enum elf_ppc64_reloc_type r_type;
5395 int tls_type;
5396 struct _ppc64_elf_section_data *ppc64_sec;
5397 struct plt_entry **ifunc, **plt_list;
5398
5399 r_symndx = ELF64_R_SYM (rel->r_info);
5400 if (r_symndx < symtab_hdr->sh_info)
5401 h = NULL;
5402 else
5403 {
5404 struct ppc_link_hash_entry *eh;
5405
5406 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
5407 h = elf_follow_link (h);
5408 eh = (struct ppc_link_hash_entry *) h;
5409
5410 /* PR15323, ref flags aren't set for references in the same
5411 object. */
5412 h->root.non_ir_ref = 1;
5413 if (eh->is_func && eh->oh != NULL)
5414 eh->oh->elf.root.non_ir_ref = 1;
5415
5416 if (h == htab->elf.hgot)
5417 sec->has_toc_reloc = 1;
5418 }
5419
5420 tls_type = 0;
5421 ifunc = NULL;
5422 if (h != NULL)
5423 {
5424 if (h->type == STT_GNU_IFUNC)
5425 {
5426 h->needs_plt = 1;
5427 ifunc = &h->plt.plist;
5428 }
5429 }
5430 else
5431 {
5432 Elf_Internal_Sym *isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5433 abfd, r_symndx);
5434 if (isym == NULL)
5435 return FALSE;
5436
5437 if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
5438 {
5439 ifunc = update_local_sym_info (abfd, symtab_hdr, r_symndx,
5440 rel->r_addend, PLT_IFUNC);
5441 if (ifunc == NULL)
5442 return FALSE;
5443 }
5444 }
5445
5446 r_type = ELF64_R_TYPE (rel->r_info);
5447 switch (r_type)
5448 {
5449 case R_PPC64_TLSGD:
5450 case R_PPC64_TLSLD:
5451 /* These special tls relocs tie a call to __tls_get_addr with
5452 its parameter symbol. */
5453 break;
5454
5455 case R_PPC64_GOT_TLSLD16:
5456 case R_PPC64_GOT_TLSLD16_LO:
5457 case R_PPC64_GOT_TLSLD16_HI:
5458 case R_PPC64_GOT_TLSLD16_HA:
5459 tls_type = TLS_TLS | TLS_LD;
5460 goto dogottls;
5461
5462 case R_PPC64_GOT_TLSGD16:
5463 case R_PPC64_GOT_TLSGD16_LO:
5464 case R_PPC64_GOT_TLSGD16_HI:
5465 case R_PPC64_GOT_TLSGD16_HA:
5466 tls_type = TLS_TLS | TLS_GD;
5467 goto dogottls;
5468
5469 case R_PPC64_GOT_TPREL16_DS:
5470 case R_PPC64_GOT_TPREL16_LO_DS:
5471 case R_PPC64_GOT_TPREL16_HI:
5472 case R_PPC64_GOT_TPREL16_HA:
5473 if (bfd_link_pic (info))
5474 info->flags |= DF_STATIC_TLS;
5475 tls_type = TLS_TLS | TLS_TPREL;
5476 goto dogottls;
5477
5478 case R_PPC64_GOT_DTPREL16_DS:
5479 case R_PPC64_GOT_DTPREL16_LO_DS:
5480 case R_PPC64_GOT_DTPREL16_HI:
5481 case R_PPC64_GOT_DTPREL16_HA:
5482 tls_type = TLS_TLS | TLS_DTPREL;
5483 dogottls:
5484 sec->has_tls_reloc = 1;
5485 /* Fall through */
5486
5487 case R_PPC64_GOT16:
5488 case R_PPC64_GOT16_DS:
5489 case R_PPC64_GOT16_HA:
5490 case R_PPC64_GOT16_HI:
5491 case R_PPC64_GOT16_LO:
5492 case R_PPC64_GOT16_LO_DS:
5493 /* This symbol requires a global offset table entry. */
5494 sec->has_toc_reloc = 1;
5495 if (r_type == R_PPC64_GOT_TLSLD16
5496 || r_type == R_PPC64_GOT_TLSGD16
5497 || r_type == R_PPC64_GOT_TPREL16_DS
5498 || r_type == R_PPC64_GOT_DTPREL16_DS
5499 || r_type == R_PPC64_GOT16
5500 || r_type == R_PPC64_GOT16_DS)
5501 {
5502 htab->do_multi_toc = 1;
5503 ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5504 }
5505
5506 if (ppc64_elf_tdata (abfd)->got == NULL
5507 && !create_got_section (abfd, info))
5508 return FALSE;
5509
5510 if (h != NULL)
5511 {
5512 struct ppc_link_hash_entry *eh;
5513 struct got_entry *ent;
5514
5515 eh = (struct ppc_link_hash_entry *) h;
5516 for (ent = eh->elf.got.glist; ent != NULL; ent = ent->next)
5517 if (ent->addend == rel->r_addend
5518 && ent->owner == abfd
5519 && ent->tls_type == tls_type)
5520 break;
5521 if (ent == NULL)
5522 {
5523 bfd_size_type amt = sizeof (*ent);
5524 ent = bfd_alloc (abfd, amt);
5525 if (ent == NULL)
5526 return FALSE;
5527 ent->next = eh->elf.got.glist;
5528 ent->addend = rel->r_addend;
5529 ent->owner = abfd;
5530 ent->tls_type = tls_type;
5531 ent->is_indirect = FALSE;
5532 ent->got.refcount = 0;
5533 eh->elf.got.glist = ent;
5534 }
5535 ent->got.refcount += 1;
5536 eh->tls_mask |= tls_type;
5537 }
5538 else
5539 /* This is a global offset table entry for a local symbol. */
5540 if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5541 rel->r_addend, tls_type))
5542 return FALSE;
5543
5544 /* We may also need a plt entry if the symbol turns out to be
5545 an ifunc. */
5546 if (h != NULL && !bfd_link_pic (info) && abiversion (abfd) != 1)
5547 {
5548 if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5549 return FALSE;
5550 }
5551 break;
5552
5553 case R_PPC64_PLT16_HA:
5554 case R_PPC64_PLT16_HI:
5555 case R_PPC64_PLT16_LO:
5556 case R_PPC64_PLT32:
5557 case R_PPC64_PLT64:
5558 /* This symbol requires a procedure linkage table entry. */
5559 plt_list = ifunc;
5560 if (h != NULL)
5561 {
5562 h->needs_plt = 1;
5563 if (h->root.root.string[0] == '.'
5564 && h->root.root.string[1] != '\0')
5565 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5566 plt_list = &h->plt.plist;
5567 }
5568 if (plt_list == NULL)
5569 {
5570 /* It does not make sense to have a procedure linkage
5571 table entry for a non-ifunc local symbol. */
5572 info->callbacks->einfo
5573 /* xgettext:c-format */
5574 (_("%H: %s reloc against local symbol\n"),
5575 abfd, sec, rel->r_offset,
5576 ppc64_elf_howto_table[r_type]->name);
5577 bfd_set_error (bfd_error_bad_value);
5578 return FALSE;
5579 }
5580 if (!update_plt_info (abfd, plt_list, rel->r_addend))
5581 return FALSE;
5582 break;
5583
5584 /* The following relocations don't need to propagate the
5585 relocation if linking a shared object since they are
5586 section relative. */
5587 case R_PPC64_SECTOFF:
5588 case R_PPC64_SECTOFF_LO:
5589 case R_PPC64_SECTOFF_HI:
5590 case R_PPC64_SECTOFF_HA:
5591 case R_PPC64_SECTOFF_DS:
5592 case R_PPC64_SECTOFF_LO_DS:
5593 case R_PPC64_DTPREL16:
5594 case R_PPC64_DTPREL16_LO:
5595 case R_PPC64_DTPREL16_HI:
5596 case R_PPC64_DTPREL16_HA:
5597 case R_PPC64_DTPREL16_DS:
5598 case R_PPC64_DTPREL16_LO_DS:
5599 case R_PPC64_DTPREL16_HIGH:
5600 case R_PPC64_DTPREL16_HIGHA:
5601 case R_PPC64_DTPREL16_HIGHER:
5602 case R_PPC64_DTPREL16_HIGHERA:
5603 case R_PPC64_DTPREL16_HIGHEST:
5604 case R_PPC64_DTPREL16_HIGHESTA:
5605 break;
5606
5607 /* Nor do these. */
5608 case R_PPC64_REL16:
5609 case R_PPC64_REL16_LO:
5610 case R_PPC64_REL16_HI:
5611 case R_PPC64_REL16_HA:
5612 case R_PPC64_REL16DX_HA:
5613 break;
5614
5615 /* Not supported as a dynamic relocation. */
5616 case R_PPC64_ADDR64_LOCAL:
5617 if (bfd_link_pic (info))
5618 {
5619 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
5620 ppc_howto_init ();
5621 /* xgettext:c-format */
5622 info->callbacks->einfo (_("%H: %s reloc unsupported "
5623 "in shared libraries and PIEs.\n"),
5624 abfd, sec, rel->r_offset,
5625 ppc64_elf_howto_table[r_type]->name);
5626 bfd_set_error (bfd_error_bad_value);
5627 return FALSE;
5628 }
5629 break;
5630
5631 case R_PPC64_TOC16:
5632 case R_PPC64_TOC16_DS:
5633 htab->do_multi_toc = 1;
5634 ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5635 /* Fall through. */
5636 case R_PPC64_TOC16_LO:
5637 case R_PPC64_TOC16_HI:
5638 case R_PPC64_TOC16_HA:
5639 case R_PPC64_TOC16_LO_DS:
5640 sec->has_toc_reloc = 1;
5641 break;
5642
5643 /* Marker reloc. */
5644 case R_PPC64_ENTRY:
5645 break;
5646
5647 /* This relocation describes the C++ object vtable hierarchy.
5648 Reconstruct it for later use during GC. */
5649 case R_PPC64_GNU_VTINHERIT:
5650 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
5651 return FALSE;
5652 break;
5653
5654 /* This relocation describes which C++ vtable entries are actually
5655 used. Record for later use during GC. */
5656 case R_PPC64_GNU_VTENTRY:
5657 BFD_ASSERT (h != NULL);
5658 if (h != NULL
5659 && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
5660 return FALSE;
5661 break;
5662
5663 case R_PPC64_REL14:
5664 case R_PPC64_REL14_BRTAKEN:
5665 case R_PPC64_REL14_BRNTAKEN:
5666 {
5667 asection *dest = NULL;
5668
5669 /* Heuristic: If jumping outside our section, chances are
5670 we are going to need a stub. */
5671 if (h != NULL)
5672 {
5673 /* If the sym is weak it may be overridden later, so
5674 don't assume we know where a weak sym lives. */
5675 if (h->root.type == bfd_link_hash_defined)
5676 dest = h->root.u.def.section;
5677 }
5678 else
5679 {
5680 Elf_Internal_Sym *isym;
5681
5682 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5683 abfd, r_symndx);
5684 if (isym == NULL)
5685 return FALSE;
5686
5687 dest = bfd_section_from_elf_index (abfd, isym->st_shndx);
5688 }
5689
5690 if (dest != sec)
5691 ppc64_elf_section_data (sec)->has_14bit_branch = 1;
5692 }
5693 /* Fall through. */
5694
5695 case R_PPC64_REL24:
5696 plt_list = ifunc;
5697 if (h != NULL)
5698 {
5699 h->needs_plt = 1;
5700 if (h->root.root.string[0] == '.'
5701 && h->root.root.string[1] != '\0')
5702 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5703
5704 if (h == tga || h == dottga)
5705 {
5706 sec->has_tls_reloc = 1;
5707 if (rel != relocs
5708 && (ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSGD
5709 || ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSLD))
5710 /* We have a new-style __tls_get_addr call with
5711 a marker reloc. */
5712 ;
5713 else
5714 /* Mark this section as having an old-style call. */
5715 sec->has_tls_get_addr_call = 1;
5716 }
5717 plt_list = &h->plt.plist;
5718 }
5719
5720 /* We may need a .plt entry if the function this reloc
5721 refers to is in a shared lib. */
5722 if (plt_list
5723 && !update_plt_info (abfd, plt_list, rel->r_addend))
5724 return FALSE;
5725 break;
5726
5727 case R_PPC64_ADDR14:
5728 case R_PPC64_ADDR14_BRNTAKEN:
5729 case R_PPC64_ADDR14_BRTAKEN:
5730 case R_PPC64_ADDR24:
5731 goto dodyn;
5732
5733 case R_PPC64_TPREL64:
5734 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_TPREL;
5735 if (bfd_link_pic (info))
5736 info->flags |= DF_STATIC_TLS;
5737 goto dotlstoc;
5738
5739 case R_PPC64_DTPMOD64:
5740 if (rel + 1 < rel_end
5741 && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
5742 && rel[1].r_offset == rel->r_offset + 8)
5743 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_GD;
5744 else
5745 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_LD;
5746 goto dotlstoc;
5747
5748 case R_PPC64_DTPREL64:
5749 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_DTPREL;
5750 if (rel != relocs
5751 && rel[-1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPMOD64)
5752 && rel[-1].r_offset == rel->r_offset - 8)
5753 /* This is the second reloc of a dtpmod, dtprel pair.
5754 Don't mark with TLS_DTPREL. */
5755 goto dodyn;
5756
5757 dotlstoc:
5758 sec->has_tls_reloc = 1;
5759 if (h != NULL)
5760 {
5761 struct ppc_link_hash_entry *eh;
5762 eh = (struct ppc_link_hash_entry *) h;
5763 eh->tls_mask |= tls_type;
5764 }
5765 else
5766 if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5767 rel->r_addend, tls_type))
5768 return FALSE;
5769
5770 ppc64_sec = ppc64_elf_section_data (sec);
5771 if (ppc64_sec->sec_type != sec_toc)
5772 {
5773 bfd_size_type amt;
5774
5775 /* One extra to simplify get_tls_mask. */
5776 amt = sec->size * sizeof (unsigned) / 8 + sizeof (unsigned);
5777 ppc64_sec->u.toc.symndx = bfd_zalloc (abfd, amt);
5778 if (ppc64_sec->u.toc.symndx == NULL)
5779 return FALSE;
5780 amt = sec->size * sizeof (bfd_vma) / 8;
5781 ppc64_sec->u.toc.add = bfd_zalloc (abfd, amt);
5782 if (ppc64_sec->u.toc.add == NULL)
5783 return FALSE;
5784 BFD_ASSERT (ppc64_sec->sec_type == sec_normal);
5785 ppc64_sec->sec_type = sec_toc;
5786 }
5787 BFD_ASSERT (rel->r_offset % 8 == 0);
5788 ppc64_sec->u.toc.symndx[rel->r_offset / 8] = r_symndx;
5789 ppc64_sec->u.toc.add[rel->r_offset / 8] = rel->r_addend;
5790
5791 /* Mark the second slot of a GD or LD entry.
5792 -1 to indicate GD and -2 to indicate LD. */
5793 if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_GD))
5794 ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -1;
5795 else if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_LD))
5796 ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -2;
5797 goto dodyn;
5798
5799 case R_PPC64_TPREL16:
5800 case R_PPC64_TPREL16_LO:
5801 case R_PPC64_TPREL16_HI:
5802 case R_PPC64_TPREL16_HA:
5803 case R_PPC64_TPREL16_DS:
5804 case R_PPC64_TPREL16_LO_DS:
5805 case R_PPC64_TPREL16_HIGH:
5806 case R_PPC64_TPREL16_HIGHA:
5807 case R_PPC64_TPREL16_HIGHER:
5808 case R_PPC64_TPREL16_HIGHERA:
5809 case R_PPC64_TPREL16_HIGHEST:
5810 case R_PPC64_TPREL16_HIGHESTA:
5811 if (bfd_link_pic (info))
5812 {
5813 info->flags |= DF_STATIC_TLS;
5814 goto dodyn;
5815 }
5816 break;
5817
5818 case R_PPC64_ADDR64:
5819 if (opd_sym_map != NULL
5820 && rel + 1 < rel_end
5821 && ELF64_R_TYPE ((rel + 1)->r_info) == R_PPC64_TOC)
5822 {
5823 if (h != NULL)
5824 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5825 else
5826 {
5827 asection *s;
5828 Elf_Internal_Sym *isym;
5829
5830 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5831 abfd, r_symndx);
5832 if (isym == NULL)
5833 return FALSE;
5834
5835 s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5836 if (s != NULL && s != sec)
5837 opd_sym_map[OPD_NDX (rel->r_offset)] = s;
5838 }
5839 }
5840 /* Fall through. */
5841
5842 case R_PPC64_ADDR16:
5843 case R_PPC64_ADDR16_DS:
5844 case R_PPC64_ADDR16_HA:
5845 case R_PPC64_ADDR16_HI:
5846 case R_PPC64_ADDR16_HIGH:
5847 case R_PPC64_ADDR16_HIGHA:
5848 case R_PPC64_ADDR16_HIGHER:
5849 case R_PPC64_ADDR16_HIGHERA:
5850 case R_PPC64_ADDR16_HIGHEST:
5851 case R_PPC64_ADDR16_HIGHESTA:
5852 case R_PPC64_ADDR16_LO:
5853 case R_PPC64_ADDR16_LO_DS:
5854 if (h != NULL && !bfd_link_pic (info) && abiversion (abfd) != 1
5855 && rel->r_addend == 0)
5856 {
5857 /* We may need a .plt entry if this reloc refers to a
5858 function in a shared lib. */
5859 if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5860 return FALSE;
5861 h->pointer_equality_needed = 1;
5862 }
5863 /* Fall through. */
5864
5865 case R_PPC64_REL30:
5866 case R_PPC64_REL32:
5867 case R_PPC64_REL64:
5868 case R_PPC64_ADDR32:
5869 case R_PPC64_UADDR16:
5870 case R_PPC64_UADDR32:
5871 case R_PPC64_UADDR64:
5872 case R_PPC64_TOC:
5873 if (h != NULL && !bfd_link_pic (info))
5874 /* We may need a copy reloc. */
5875 h->non_got_ref = 1;
5876
5877 /* Don't propagate .opd relocs. */
5878 if (NO_OPD_RELOCS && opd_sym_map != NULL)
5879 break;
5880
5881 /* If we are creating a shared library, and this is a reloc
5882 against a global symbol, or a non PC relative reloc
5883 against a local symbol, then we need to copy the reloc
5884 into the shared library. However, if we are linking with
5885 -Bsymbolic, we do not need to copy a reloc against a
5886 global symbol which is defined in an object we are
5887 including in the link (i.e., DEF_REGULAR is set). At
5888 this point we have not seen all the input files, so it is
5889 possible that DEF_REGULAR is not set now but will be set
5890 later (it is never cleared). In case of a weak definition,
5891 DEF_REGULAR may be cleared later by a strong definition in
5892 a shared library. We account for that possibility below by
5893 storing information in the dyn_relocs field of the hash
5894 table entry. A similar situation occurs when creating
5895 shared libraries and symbol visibility changes render the
5896 symbol local.
5897
5898 If on the other hand, we are creating an executable, we
5899 may need to keep relocations for symbols satisfied by a
5900 dynamic library if we manage to avoid copy relocs for the
5901 symbol. */
5902 dodyn:
5903 if ((bfd_link_pic (info)
5904 && (must_be_dyn_reloc (info, r_type)
5905 || (h != NULL
5906 && (!SYMBOLIC_BIND (info, h)
5907 || h->root.type == bfd_link_hash_defweak
5908 || !h->def_regular))))
5909 || (ELIMINATE_COPY_RELOCS
5910 && !bfd_link_pic (info)
5911 && h != NULL
5912 && (h->root.type == bfd_link_hash_defweak
5913 || !h->def_regular))
5914 || (!bfd_link_pic (info)
5915 && ifunc != NULL))
5916 {
5917 /* We must copy these reloc types into the output file.
5918 Create a reloc section in dynobj and make room for
5919 this reloc. */
5920 if (sreloc == NULL)
5921 {
5922 sreloc = _bfd_elf_make_dynamic_reloc_section
5923 (sec, htab->elf.dynobj, 3, abfd, /*rela?*/ TRUE);
5924
5925 if (sreloc == NULL)
5926 return FALSE;
5927 }
5928
5929 /* If this is a global symbol, we count the number of
5930 relocations we need for this symbol. */
5931 if (h != NULL)
5932 {
5933 struct elf_dyn_relocs *p;
5934 struct elf_dyn_relocs **head;
5935
5936 head = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
5937 p = *head;
5938 if (p == NULL || p->sec != sec)
5939 {
5940 p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5941 if (p == NULL)
5942 return FALSE;
5943 p->next = *head;
5944 *head = p;
5945 p->sec = sec;
5946 p->count = 0;
5947 p->pc_count = 0;
5948 }
5949 p->count += 1;
5950 if (!must_be_dyn_reloc (info, r_type))
5951 p->pc_count += 1;
5952 }
5953 else
5954 {
5955 /* Track dynamic relocs needed for local syms too.
5956 We really need local syms available to do this
5957 easily. Oh well. */
5958 struct ppc_dyn_relocs *p;
5959 struct ppc_dyn_relocs **head;
5960 bfd_boolean is_ifunc;
5961 asection *s;
5962 void *vpp;
5963 Elf_Internal_Sym *isym;
5964
5965 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5966 abfd, r_symndx);
5967 if (isym == NULL)
5968 return FALSE;
5969
5970 s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5971 if (s == NULL)
5972 s = sec;
5973
5974 vpp = &elf_section_data (s)->local_dynrel;
5975 head = (struct ppc_dyn_relocs **) vpp;
5976 is_ifunc = ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC;
5977 p = *head;
5978 if (p != NULL && p->sec == sec && p->ifunc != is_ifunc)
5979 p = p->next;
5980 if (p == NULL || p->sec != sec || p->ifunc != is_ifunc)
5981 {
5982 p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5983 if (p == NULL)
5984 return FALSE;
5985 p->next = *head;
5986 *head = p;
5987 p->sec = sec;
5988 p->ifunc = is_ifunc;
5989 p->count = 0;
5990 }
5991 p->count += 1;
5992 }
5993 }
5994 break;
5995
5996 default:
5997 break;
5998 }
5999 }
6000
6001 return TRUE;
6002 }
6003
6004 /* Merge backend specific data from an object file to the output
6005 object file when linking. */
6006
6007 static bfd_boolean
6008 ppc64_elf_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info)
6009 {
6010 bfd *obfd = info->output_bfd;
6011 unsigned long iflags, oflags;
6012
6013 if ((ibfd->flags & BFD_LINKER_CREATED) != 0)
6014 return TRUE;
6015
6016 if (!is_ppc64_elf (ibfd) || !is_ppc64_elf (obfd))
6017 return TRUE;
6018
6019 if (!_bfd_generic_verify_endian_match (ibfd, info))
6020 return FALSE;
6021
6022 iflags = elf_elfheader (ibfd)->e_flags;
6023 oflags = elf_elfheader (obfd)->e_flags;
6024
6025 if (iflags & ~EF_PPC64_ABI)
6026 {
6027 _bfd_error_handler
6028 /* xgettext:c-format */
6029 (_("%B uses unknown e_flags 0x%lx"), ibfd, iflags);
6030 bfd_set_error (bfd_error_bad_value);
6031 return FALSE;
6032 }
6033 else if (iflags != oflags && iflags != 0)
6034 {
6035 _bfd_error_handler
6036 /* xgettext:c-format */
6037 (_("%B: ABI version %ld is not compatible with ABI version %ld output"),
6038 ibfd, iflags, oflags);
6039 bfd_set_error (bfd_error_bad_value);
6040 return FALSE;
6041 }
6042
6043 _bfd_elf_ppc_merge_fp_attributes (ibfd, info);
6044
6045 /* Merge Tag_compatibility attributes and any common GNU ones. */
6046 _bfd_elf_merge_object_attributes (ibfd, info);
6047
6048 return TRUE;
6049 }
6050
6051 static bfd_boolean
6052 ppc64_elf_print_private_bfd_data (bfd *abfd, void *ptr)
6053 {
6054 /* Print normal ELF private data. */
6055 _bfd_elf_print_private_bfd_data (abfd, ptr);
6056
6057 if (elf_elfheader (abfd)->e_flags != 0)
6058 {
6059 FILE *file = ptr;
6060
6061 fprintf (file, _("private flags = 0x%lx:"),
6062 elf_elfheader (abfd)->e_flags);
6063
6064 if ((elf_elfheader (abfd)->e_flags & EF_PPC64_ABI) != 0)
6065 fprintf (file, _(" [abiv%ld]"),
6066 elf_elfheader (abfd)->e_flags & EF_PPC64_ABI);
6067 fputc ('\n', file);
6068 }
6069
6070 return TRUE;
6071 }
6072
6073 /* OFFSET in OPD_SEC specifies a function descriptor. Return the address
6074 of the code entry point, and its section, which must be in the same
6075 object as OPD_SEC. Returns (bfd_vma) -1 on error. */
6076
6077 static bfd_vma
6078 opd_entry_value (asection *opd_sec,
6079 bfd_vma offset,
6080 asection **code_sec,
6081 bfd_vma *code_off,
6082 bfd_boolean in_code_sec)
6083 {
6084 bfd *opd_bfd = opd_sec->owner;
6085 Elf_Internal_Rela *relocs;
6086 Elf_Internal_Rela *lo, *hi, *look;
6087 bfd_vma val;
6088
6089 /* No relocs implies we are linking a --just-symbols object, or looking
6090 at a final linked executable with addr2line or somesuch. */
6091 if (opd_sec->reloc_count == 0)
6092 {
6093 bfd_byte *contents = ppc64_elf_tdata (opd_bfd)->opd.contents;
6094
6095 if (contents == NULL)
6096 {
6097 if (!bfd_malloc_and_get_section (opd_bfd, opd_sec, &contents))
6098 return (bfd_vma) -1;
6099 ppc64_elf_tdata (opd_bfd)->opd.contents = contents;
6100 }
6101
6102 /* PR 17512: file: 64b9dfbb. */
6103 if (offset + 7 >= opd_sec->size || offset + 7 < offset)
6104 return (bfd_vma) -1;
6105
6106 val = bfd_get_64 (opd_bfd, contents + offset);
6107 if (code_sec != NULL)
6108 {
6109 asection *sec, *likely = NULL;
6110
6111 if (in_code_sec)
6112 {
6113 sec = *code_sec;
6114 if (sec->vma <= val
6115 && val < sec->vma + sec->size)
6116 likely = sec;
6117 else
6118 val = -1;
6119 }
6120 else
6121 for (sec = opd_bfd->sections; sec != NULL; sec = sec->next)
6122 if (sec->vma <= val
6123 && (sec->flags & SEC_LOAD) != 0
6124 && (sec->flags & SEC_ALLOC) != 0)
6125 likely = sec;
6126 if (likely != NULL)
6127 {
6128 *code_sec = likely;
6129 if (code_off != NULL)
6130 *code_off = val - likely->vma;
6131 }
6132 }
6133 return val;
6134 }
6135
6136 BFD_ASSERT (is_ppc64_elf (opd_bfd));
6137
6138 relocs = ppc64_elf_tdata (opd_bfd)->opd.relocs;
6139 if (relocs == NULL)
6140 relocs = _bfd_elf_link_read_relocs (opd_bfd, opd_sec, NULL, NULL, TRUE);
6141 /* PR 17512: file: df8e1fd6. */
6142 if (relocs == NULL)
6143 return (bfd_vma) -1;
6144
6145 /* Go find the opd reloc at the sym address. */
6146 lo = relocs;
6147 hi = lo + opd_sec->reloc_count - 1; /* ignore last reloc */
6148 val = (bfd_vma) -1;
6149 while (lo < hi)
6150 {
6151 look = lo + (hi - lo) / 2;
6152 if (look->r_offset < offset)
6153 lo = look + 1;
6154 else if (look->r_offset > offset)
6155 hi = look;
6156 else
6157 {
6158 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (opd_bfd);
6159
6160 if (ELF64_R_TYPE (look->r_info) == R_PPC64_ADDR64
6161 && ELF64_R_TYPE ((look + 1)->r_info) == R_PPC64_TOC)
6162 {
6163 unsigned long symndx = ELF64_R_SYM (look->r_info);
6164 asection *sec = NULL;
6165
6166 if (symndx >= symtab_hdr->sh_info
6167 && elf_sym_hashes (opd_bfd) != NULL)
6168 {
6169 struct elf_link_hash_entry **sym_hashes;
6170 struct elf_link_hash_entry *rh;
6171
6172 sym_hashes = elf_sym_hashes (opd_bfd);
6173 rh = sym_hashes[symndx - symtab_hdr->sh_info];
6174 if (rh != NULL)
6175 {
6176 rh = elf_follow_link (rh);
6177 if (rh->root.type != bfd_link_hash_defined
6178 && rh->root.type != bfd_link_hash_defweak)
6179 break;
6180 if (rh->root.u.def.section->owner == opd_bfd)
6181 {
6182 val = rh->root.u.def.value;
6183 sec = rh->root.u.def.section;
6184 }
6185 }
6186 }
6187
6188 if (sec == NULL)
6189 {
6190 Elf_Internal_Sym *sym;
6191
6192 if (symndx < symtab_hdr->sh_info)
6193 {
6194 sym = (Elf_Internal_Sym *) symtab_hdr->contents;
6195 if (sym == NULL)
6196 {
6197 size_t symcnt = symtab_hdr->sh_info;
6198 sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr,
6199 symcnt, 0,
6200 NULL, NULL, NULL);
6201 if (sym == NULL)
6202 break;
6203 symtab_hdr->contents = (bfd_byte *) sym;
6204 }
6205 sym += symndx;
6206 }
6207 else
6208 {
6209 sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr,
6210 1, symndx,
6211 NULL, NULL, NULL);
6212 if (sym == NULL)
6213 break;
6214 }
6215 sec = bfd_section_from_elf_index (opd_bfd, sym->st_shndx);
6216 if (sec == NULL)
6217 break;
6218 BFD_ASSERT ((sec->flags & SEC_MERGE) == 0);
6219 val = sym->st_value;
6220 }
6221
6222 val += look->r_addend;
6223 if (code_off != NULL)
6224 *code_off = val;
6225 if (code_sec != NULL)
6226 {
6227 if (in_code_sec && *code_sec != sec)
6228 return -1;
6229 else
6230 *code_sec = sec;
6231 }
6232 if (sec->output_section != NULL)
6233 val += sec->output_section->vma + sec->output_offset;
6234 }
6235 break;
6236 }
6237 }
6238
6239 return val;
6240 }
6241
6242 /* If the ELF symbol SYM might be a function in SEC, return the
6243 function size and set *CODE_OFF to the function's entry point,
6244 otherwise return zero. */
6245
6246 static bfd_size_type
6247 ppc64_elf_maybe_function_sym (const asymbol *sym, asection *sec,
6248 bfd_vma *code_off)
6249 {
6250 bfd_size_type size;
6251
6252 if ((sym->flags & (BSF_SECTION_SYM | BSF_FILE | BSF_OBJECT
6253 | BSF_THREAD_LOCAL | BSF_RELC | BSF_SRELC)) != 0)
6254 return 0;
6255
6256 size = 0;
6257 if (!(sym->flags & BSF_SYNTHETIC))
6258 size = ((elf_symbol_type *) sym)->internal_elf_sym.st_size;
6259
6260 if (strcmp (sym->section->name, ".opd") == 0)
6261 {
6262 struct _opd_sec_data *opd = get_opd_info (sym->section);
6263 bfd_vma symval = sym->value;
6264
6265 if (opd != NULL
6266 && opd->adjust != NULL
6267 && elf_section_data (sym->section)->relocs != NULL)
6268 {
6269 /* opd_entry_value will use cached relocs that have been
6270 adjusted, but with raw symbols. That means both local
6271 and global symbols need adjusting. */
6272 long adjust = opd->adjust[OPD_NDX (symval)];
6273 if (adjust == -1)
6274 return 0;
6275 symval += adjust;
6276 }
6277
6278 if (opd_entry_value (sym->section, symval,
6279 &sec, code_off, TRUE) == (bfd_vma) -1)
6280 return 0;
6281 /* An old ABI binary with dot-syms has a size of 24 on the .opd
6282 symbol. This size has nothing to do with the code size of the
6283 function, which is what we're supposed to return, but the
6284 code size isn't available without looking up the dot-sym.
6285 However, doing that would be a waste of time particularly
6286 since elf_find_function will look at the dot-sym anyway.
6287 Now, elf_find_function will keep the largest size of any
6288 function sym found at the code address of interest, so return
6289 1 here to avoid it incorrectly caching a larger function size
6290 for a small function. This does mean we return the wrong
6291 size for a new-ABI function of size 24, but all that does is
6292 disable caching for such functions. */
6293 if (size == 24)
6294 size = 1;
6295 }
6296 else
6297 {
6298 if (sym->section != sec)
6299 return 0;
6300 *code_off = sym->value;
6301 }
6302 if (size == 0)
6303 size = 1;
6304 return size;
6305 }
6306
6307 /* Return true if symbol is defined in a regular object file. */
6308
6309 static bfd_boolean
6310 is_static_defined (struct elf_link_hash_entry *h)
6311 {
6312 return ((h->root.type == bfd_link_hash_defined
6313 || h->root.type == bfd_link_hash_defweak)
6314 && h->root.u.def.section != NULL
6315 && h->root.u.def.section->output_section != NULL);
6316 }
6317
6318 /* If FDH is a function descriptor symbol, return the associated code
6319 entry symbol if it is defined. Return NULL otherwise. */
6320
6321 static struct ppc_link_hash_entry *
6322 defined_code_entry (struct ppc_link_hash_entry *fdh)
6323 {
6324 if (fdh->is_func_descriptor)
6325 {
6326 struct ppc_link_hash_entry *fh = ppc_follow_link (fdh->oh);
6327 if (fh->elf.root.type == bfd_link_hash_defined
6328 || fh->elf.root.type == bfd_link_hash_defweak)
6329 return fh;
6330 }
6331 return NULL;
6332 }
6333
6334 /* If FH is a function code entry symbol, return the associated
6335 function descriptor symbol if it is defined. Return NULL otherwise. */
6336
6337 static struct ppc_link_hash_entry *
6338 defined_func_desc (struct ppc_link_hash_entry *fh)
6339 {
6340 if (fh->oh != NULL
6341 && fh->oh->is_func_descriptor)
6342 {
6343 struct ppc_link_hash_entry *fdh = ppc_follow_link (fh->oh);
6344 if (fdh->elf.root.type == bfd_link_hash_defined
6345 || fdh->elf.root.type == bfd_link_hash_defweak)
6346 return fdh;
6347 }
6348 return NULL;
6349 }
6350
6351 static bfd_boolean func_desc_adjust (struct elf_link_hash_entry *, void *);
6352
6353 /* Garbage collect sections, after first dealing with dot-symbols. */
6354
6355 static bfd_boolean
6356 ppc64_elf_gc_sections (bfd *abfd, struct bfd_link_info *info)
6357 {
6358 struct ppc_link_hash_table *htab = ppc_hash_table (info);
6359
6360 if (htab != NULL && htab->need_func_desc_adj)
6361 {
6362 elf_link_hash_traverse (&htab->elf, func_desc_adjust, info);
6363 htab->need_func_desc_adj = 0;
6364 }
6365 return bfd_elf_gc_sections (abfd, info);
6366 }
6367
6368 /* Mark all our entry sym sections, both opd and code section. */
6369
6370 static void
6371 ppc64_elf_gc_keep (struct bfd_link_info *info)
6372 {
6373 struct ppc_link_hash_table *htab = ppc_hash_table (info);
6374 struct bfd_sym_chain *sym;
6375
6376 if (htab == NULL)
6377 return;
6378
6379 for (sym = info->gc_sym_list; sym != NULL; sym = sym->next)
6380 {
6381 struct ppc_link_hash_entry *eh, *fh;
6382 asection *sec;
6383
6384 eh = (struct ppc_link_hash_entry *)
6385 elf_link_hash_lookup (&htab->elf, sym->name, FALSE, FALSE, TRUE);
6386 if (eh == NULL)
6387 continue;
6388 if (eh->elf.root.type != bfd_link_hash_defined
6389 && eh->elf.root.type != bfd_link_hash_defweak)
6390 continue;
6391
6392 fh = defined_code_entry (eh);
6393 if (fh != NULL)
6394 {
6395 sec = fh->elf.root.u.def.section;
6396 sec->flags |= SEC_KEEP;
6397 }
6398 else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6399 && opd_entry_value (eh->elf.root.u.def.section,
6400 eh->elf.root.u.def.value,
6401 &sec, NULL, FALSE) != (bfd_vma) -1)
6402 sec->flags |= SEC_KEEP;
6403
6404 sec = eh->elf.root.u.def.section;
6405 sec->flags |= SEC_KEEP;
6406 }
6407 }
6408
6409 /* Mark sections containing dynamically referenced symbols. When
6410 building shared libraries, we must assume that any visible symbol is
6411 referenced. */
6412
6413 static bfd_boolean
6414 ppc64_elf_gc_mark_dynamic_ref (struct elf_link_hash_entry *h, void *inf)
6415 {
6416 struct bfd_link_info *info = (struct bfd_link_info *) inf;
6417 struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
6418 struct ppc_link_hash_entry *fdh;
6419 struct bfd_elf_dynamic_list *d = info->dynamic_list;
6420
6421 /* Dynamic linking info is on the func descriptor sym. */
6422 fdh = defined_func_desc (eh);
6423 if (fdh != NULL)
6424 eh = fdh;
6425
6426 if ((eh->elf.root.type == bfd_link_hash_defined
6427 || eh->elf.root.type == bfd_link_hash_defweak)
6428 && (eh->elf.ref_dynamic
6429 || ((eh->elf.def_regular || ELF_COMMON_DEF_P (&eh->elf))
6430 && ELF_ST_VISIBILITY (eh->elf.other) != STV_INTERNAL
6431 && ELF_ST_VISIBILITY (eh->elf.other) != STV_HIDDEN
6432 && (!bfd_link_executable (info)
6433 || info->gc_keep_exported
6434 || info->export_dynamic
6435 || (eh->elf.dynamic
6436 && d != NULL
6437 && (*d->match) (&d->head, NULL, eh->elf.root.root.string)))
6438 && (eh->elf.versioned >= versioned
6439 || !bfd_hide_sym_by_version (info->version_info,
6440 eh->elf.root.root.string)))))
6441 {
6442 asection *code_sec;
6443 struct ppc_link_hash_entry *fh;
6444
6445 eh->elf.root.u.def.section->flags |= SEC_KEEP;
6446
6447 /* Function descriptor syms cause the associated
6448 function code sym section to be marked. */
6449 fh = defined_code_entry (eh);
6450 if (fh != NULL)
6451 {
6452 code_sec = fh->elf.root.u.def.section;
6453 code_sec->flags |= SEC_KEEP;
6454 }
6455 else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6456 && opd_entry_value (eh->elf.root.u.def.section,
6457 eh->elf.root.u.def.value,
6458 &code_sec, NULL, FALSE) != (bfd_vma) -1)
6459 code_sec->flags |= SEC_KEEP;
6460 }
6461
6462 return TRUE;
6463 }
6464
6465 /* Return the section that should be marked against GC for a given
6466 relocation. */
6467
6468 static asection *
6469 ppc64_elf_gc_mark_hook (asection *sec,
6470 struct bfd_link_info *info,
6471 Elf_Internal_Rela *rel,
6472 struct elf_link_hash_entry *h,
6473 Elf_Internal_Sym *sym)
6474 {
6475 asection *rsec;
6476
6477 /* Syms return NULL if we're marking .opd, so we avoid marking all
6478 function sections, as all functions are referenced in .opd. */
6479 rsec = NULL;
6480 if (get_opd_info (sec) != NULL)
6481 return rsec;
6482
6483 if (h != NULL)
6484 {
6485 enum elf_ppc64_reloc_type r_type;
6486 struct ppc_link_hash_entry *eh, *fh, *fdh;
6487
6488 r_type = ELF64_R_TYPE (rel->r_info);
6489 switch (r_type)
6490 {
6491 case R_PPC64_GNU_VTINHERIT:
6492 case R_PPC64_GNU_VTENTRY:
6493 break;
6494
6495 default:
6496 switch (h->root.type)
6497 {
6498 case bfd_link_hash_defined:
6499 case bfd_link_hash_defweak:
6500 eh = (struct ppc_link_hash_entry *) h;
6501 fdh = defined_func_desc (eh);
6502 if (fdh != NULL)
6503 {
6504 /* -mcall-aixdesc code references the dot-symbol on
6505 a call reloc. Mark the function descriptor too
6506 against garbage collection. */
6507 fdh->elf.mark = 1;
6508 if (fdh->elf.u.weakdef != NULL)
6509 fdh->elf.u.weakdef->mark = 1;
6510 eh = fdh;
6511 }
6512
6513 /* Function descriptor syms cause the associated
6514 function code sym section to be marked. */
6515 fh = defined_code_entry (eh);
6516 if (fh != NULL)
6517 {
6518 /* They also mark their opd section. */
6519 eh->elf.root.u.def.section->gc_mark = 1;
6520
6521 rsec = fh->elf.root.u.def.section;
6522 }
6523 else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6524 && opd_entry_value (eh->elf.root.u.def.section,
6525 eh->elf.root.u.def.value,
6526 &rsec, NULL, FALSE) != (bfd_vma) -1)
6527 eh->elf.root.u.def.section->gc_mark = 1;
6528 else
6529 rsec = h->root.u.def.section;
6530 break;
6531
6532 case bfd_link_hash_common:
6533 rsec = h->root.u.c.p->section;
6534 break;
6535
6536 default:
6537 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
6538 }
6539 }
6540 }
6541 else
6542 {
6543 struct _opd_sec_data *opd;
6544
6545 rsec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
6546 opd = get_opd_info (rsec);
6547 if (opd != NULL && opd->func_sec != NULL)
6548 {
6549 rsec->gc_mark = 1;
6550
6551 rsec = opd->func_sec[OPD_NDX (sym->st_value + rel->r_addend)];
6552 }
6553 }
6554
6555 return rsec;
6556 }
6557
6558 /* Update the .got, .plt. and dynamic reloc reference counts for the
6559 section being removed. */
6560
6561 static bfd_boolean
6562 ppc64_elf_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info,
6563 asection *sec, const Elf_Internal_Rela *relocs)
6564 {
6565 struct ppc_link_hash_table *htab;
6566 Elf_Internal_Shdr *symtab_hdr;
6567 struct elf_link_hash_entry **sym_hashes;
6568 struct got_entry **local_got_ents;
6569 const Elf_Internal_Rela *rel, *relend;
6570
6571 if (bfd_link_relocatable (info))
6572 return TRUE;
6573
6574 if ((sec->flags & SEC_ALLOC) == 0)
6575 return TRUE;
6576
6577 elf_section_data (sec)->local_dynrel = NULL;
6578
6579 htab = ppc_hash_table (info);
6580 if (htab == NULL)
6581 return FALSE;
6582
6583 symtab_hdr = &elf_symtab_hdr (abfd);
6584 sym_hashes = elf_sym_hashes (abfd);
6585 local_got_ents = elf_local_got_ents (abfd);
6586
6587 relend = relocs + sec->reloc_count;
6588 for (rel = relocs; rel < relend; rel++)
6589 {
6590 unsigned long r_symndx;
6591 enum elf_ppc64_reloc_type r_type;
6592 struct elf_link_hash_entry *h = NULL;
6593 struct plt_entry **plt_list;
6594 unsigned char tls_type = 0;
6595
6596 r_symndx = ELF64_R_SYM (rel->r_info);
6597 r_type = ELF64_R_TYPE (rel->r_info);
6598 if (r_symndx >= symtab_hdr->sh_info)
6599 {
6600 struct ppc_link_hash_entry *eh;
6601 struct elf_dyn_relocs **pp;
6602 struct elf_dyn_relocs *p;
6603
6604 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
6605 h = elf_follow_link (h);
6606 eh = (struct ppc_link_hash_entry *) h;
6607
6608 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
6609 if (p->sec == sec)
6610 {
6611 /* Everything must go for SEC. */
6612 *pp = p->next;
6613 break;
6614 }
6615 }
6616
6617 switch (r_type)
6618 {
6619 case R_PPC64_GOT_TLSLD16:
6620 case R_PPC64_GOT_TLSLD16_LO:
6621 case R_PPC64_GOT_TLSLD16_HI:
6622 case R_PPC64_GOT_TLSLD16_HA:
6623 tls_type = TLS_TLS | TLS_LD;
6624 goto dogot;
6625
6626 case R_PPC64_GOT_TLSGD16:
6627 case R_PPC64_GOT_TLSGD16_LO:
6628 case R_PPC64_GOT_TLSGD16_HI:
6629 case R_PPC64_GOT_TLSGD16_HA:
6630 tls_type = TLS_TLS | TLS_GD;
6631 goto dogot;
6632
6633 case R_PPC64_GOT_TPREL16_DS:
6634 case R_PPC64_GOT_TPREL16_LO_DS:
6635 case R_PPC64_GOT_TPREL16_HI:
6636 case R_PPC64_GOT_TPREL16_HA:
6637 tls_type = TLS_TLS | TLS_TPREL;
6638 goto dogot;
6639
6640 case R_PPC64_GOT_DTPREL16_DS:
6641 case R_PPC64_GOT_DTPREL16_LO_DS:
6642 case R_PPC64_GOT_DTPREL16_HI:
6643 case R_PPC64_GOT_DTPREL16_HA:
6644 tls_type = TLS_TLS | TLS_DTPREL;
6645 goto dogot;
6646
6647 case R_PPC64_GOT16:
6648 case R_PPC64_GOT16_DS:
6649 case R_PPC64_GOT16_HA:
6650 case R_PPC64_GOT16_HI:
6651 case R_PPC64_GOT16_LO:
6652 case R_PPC64_GOT16_LO_DS:
6653 dogot:
6654 {
6655 struct got_entry *ent;
6656
6657 if (h != NULL)
6658 ent = h->got.glist;
6659 else
6660 ent = local_got_ents[r_symndx];
6661
6662 for (; ent != NULL; ent = ent->next)
6663 if (ent->addend == rel->r_addend
6664 && ent->owner == abfd
6665 && ent->tls_type == tls_type)
6666 break;
6667 if (ent == NULL)
6668 abort ();
6669 if (ent->got.refcount > 0)
6670 ent->got.refcount -= 1;
6671 }
6672 break;
6673
6674 case R_PPC64_PLT16_HA:
6675 case R_PPC64_PLT16_HI:
6676 case R_PPC64_PLT16_LO:
6677 case R_PPC64_PLT32:
6678 case R_PPC64_PLT64:
6679 case R_PPC64_REL14:
6680 case R_PPC64_REL14_BRNTAKEN:
6681 case R_PPC64_REL14_BRTAKEN:
6682 case R_PPC64_REL24:
6683 plt_list = NULL;
6684 if (h != NULL)
6685 plt_list = &h->plt.plist;
6686 else if (local_got_ents != NULL)
6687 {
6688 struct plt_entry **local_plt = (struct plt_entry **)
6689 (local_got_ents + symtab_hdr->sh_info);
6690 unsigned char *local_got_tls_masks = (unsigned char *)
6691 (local_plt + symtab_hdr->sh_info);
6692 if ((local_got_tls_masks[r_symndx] & PLT_IFUNC) != 0)
6693 plt_list = local_plt + r_symndx;
6694 }
6695 if (plt_list)
6696 {
6697 struct plt_entry *ent;
6698
6699 for (ent = *plt_list; ent != NULL; ent = ent->next)
6700 if (ent->addend == rel->r_addend)
6701 break;
6702 if (ent != NULL && ent->plt.refcount > 0)
6703 ent->plt.refcount -= 1;
6704 }
6705 break;
6706
6707 default:
6708 break;
6709 }
6710 }
6711 return TRUE;
6712 }
6713
6714 /* The maximum size of .sfpr. */
6715 #define SFPR_MAX (218*4)
6716
6717 struct sfpr_def_parms
6718 {
6719 const char name[12];
6720 unsigned char lo, hi;
6721 bfd_byte * (*write_ent) (bfd *, bfd_byte *, int);
6722 bfd_byte * (*write_tail) (bfd *, bfd_byte *, int);
6723 };
6724
6725 /* Auto-generate _save*, _rest* functions in .sfpr.
6726 If STUB_SEC is non-null, define alias symbols in STUB_SEC
6727 instead. */
6728
6729 static bfd_boolean
6730 sfpr_define (struct bfd_link_info *info,
6731 const struct sfpr_def_parms *parm,
6732 asection *stub_sec)
6733 {
6734 struct ppc_link_hash_table *htab = ppc_hash_table (info);
6735 unsigned int i;
6736 size_t len = strlen (parm->name);
6737 bfd_boolean writing = FALSE;
6738 char sym[16];
6739
6740 if (htab == NULL)
6741 return FALSE;
6742
6743 memcpy (sym, parm->name, len);
6744 sym[len + 2] = 0;
6745
6746 for (i = parm->lo; i <= parm->hi; i++)
6747 {
6748 struct ppc_link_hash_entry *h;
6749
6750 sym[len + 0] = i / 10 + '0';
6751 sym[len + 1] = i % 10 + '0';
6752 h = (struct ppc_link_hash_entry *)
6753 elf_link_hash_lookup (&htab->elf, sym, writing, TRUE, TRUE);
6754 if (stub_sec != NULL)
6755 {
6756 if (h != NULL
6757 && h->elf.root.type == bfd_link_hash_defined
6758 && h->elf.root.u.def.section == htab->sfpr)
6759 {
6760 struct elf_link_hash_entry *s;
6761 char buf[32];
6762 sprintf (buf, "%08x.%s", stub_sec->id & 0xffffffff, sym);
6763 s = elf_link_hash_lookup (&htab->elf, buf, TRUE, TRUE, FALSE);
6764 if (s == NULL)
6765 return FALSE;
6766 if (s->root.type == bfd_link_hash_new
6767 || (s->root.type = bfd_link_hash_defined
6768 && s->root.u.def.section == stub_sec))
6769 {
6770 s->root.type = bfd_link_hash_defined;
6771 s->root.u.def.section = stub_sec;
6772 s->root.u.def.value = (stub_sec->size
6773 + h->elf.root.u.def.value);
6774 s->ref_regular = 1;
6775 s->def_regular = 1;
6776 s->ref_regular_nonweak = 1;
6777 s->forced_local = 1;
6778 s->non_elf = 0;
6779 s->root.linker_def = 1;
6780 }
6781 }
6782 continue;
6783 }
6784 if (h != NULL)
6785 {
6786 h->save_res = 1;
6787 if (!h->elf.def_regular)
6788 {
6789 h->elf.root.type = bfd_link_hash_defined;
6790 h->elf.root.u.def.section = htab->sfpr;
6791 h->elf.root.u.def.value = htab->sfpr->size;
6792 h->elf.type = STT_FUNC;
6793 h->elf.def_regular = 1;
6794 h->elf.non_elf = 0;
6795 _bfd_elf_link_hash_hide_symbol (info, &h->elf, TRUE);
6796 writing = TRUE;
6797 if (htab->sfpr->contents == NULL)
6798 {
6799 htab->sfpr->contents = bfd_alloc (htab->elf.dynobj, SFPR_MAX);
6800 if (htab->sfpr->contents == NULL)
6801 return FALSE;
6802 }
6803 }
6804 }
6805 if (writing)
6806 {
6807 bfd_byte *p = htab->sfpr->contents + htab->sfpr->size;
6808 if (i != parm->hi)
6809 p = (*parm->write_ent) (htab->elf.dynobj, p, i);
6810 else
6811 p = (*parm->write_tail) (htab->elf.dynobj, p, i);
6812 htab->sfpr->size = p - htab->sfpr->contents;
6813 }
6814 }
6815
6816 return TRUE;
6817 }
6818
6819 static bfd_byte *
6820 savegpr0 (bfd *abfd, bfd_byte *p, int r)
6821 {
6822 bfd_put_32 (abfd, STD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6823 return p + 4;
6824 }
6825
6826 static bfd_byte *
6827 savegpr0_tail (bfd *abfd, bfd_byte *p, int r)
6828 {
6829 p = savegpr0 (abfd, p, r);
6830 bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
6831 p = p + 4;
6832 bfd_put_32 (abfd, BLR, p);
6833 return p + 4;
6834 }
6835
6836 static bfd_byte *
6837 restgpr0 (bfd *abfd, bfd_byte *p, int r)
6838 {
6839 bfd_put_32 (abfd, LD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6840 return p + 4;
6841 }
6842
6843 static bfd_byte *
6844 restgpr0_tail (bfd *abfd, bfd_byte *p, int r)
6845 {
6846 bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
6847 p = p + 4;
6848 p = restgpr0 (abfd, p, r);
6849 bfd_put_32 (abfd, MTLR_R0, p);
6850 p = p + 4;
6851 if (r == 29)
6852 {
6853 p = restgpr0 (abfd, p, 30);
6854 p = restgpr0 (abfd, p, 31);
6855 }
6856 bfd_put_32 (abfd, BLR, p);
6857 return p + 4;
6858 }
6859
6860 static bfd_byte *
6861 savegpr1 (bfd *abfd, bfd_byte *p, int r)
6862 {
6863 bfd_put_32 (abfd, STD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6864 return p + 4;
6865 }
6866
6867 static bfd_byte *
6868 savegpr1_tail (bfd *abfd, bfd_byte *p, int r)
6869 {
6870 p = savegpr1 (abfd, p, r);
6871 bfd_put_32 (abfd, BLR, p);
6872 return p + 4;
6873 }
6874
6875 static bfd_byte *
6876 restgpr1 (bfd *abfd, bfd_byte *p, int r)
6877 {
6878 bfd_put_32 (abfd, LD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6879 return p + 4;
6880 }
6881
6882 static bfd_byte *
6883 restgpr1_tail (bfd *abfd, bfd_byte *p, int r)
6884 {
6885 p = restgpr1 (abfd, p, r);
6886 bfd_put_32 (abfd, BLR, p);
6887 return p + 4;
6888 }
6889
6890 static bfd_byte *
6891 savefpr (bfd *abfd, bfd_byte *p, int r)
6892 {
6893 bfd_put_32 (abfd, STFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6894 return p + 4;
6895 }
6896
6897 static bfd_byte *
6898 savefpr0_tail (bfd *abfd, bfd_byte *p, int r)
6899 {
6900 p = savefpr (abfd, p, r);
6901 bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
6902 p = p + 4;
6903 bfd_put_32 (abfd, BLR, p);
6904 return p + 4;
6905 }
6906
6907 static bfd_byte *
6908 restfpr (bfd *abfd, bfd_byte *p, int r)
6909 {
6910 bfd_put_32 (abfd, LFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6911 return p + 4;
6912 }
6913
6914 static bfd_byte *
6915 restfpr0_tail (bfd *abfd, bfd_byte *p, int r)
6916 {
6917 bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
6918 p = p + 4;
6919 p = restfpr (abfd, p, r);
6920 bfd_put_32 (abfd, MTLR_R0, p);
6921 p = p + 4;
6922 if (r == 29)
6923 {
6924 p = restfpr (abfd, p, 30);
6925 p = restfpr (abfd, p, 31);
6926 }
6927 bfd_put_32 (abfd, BLR, p);
6928 return p + 4;
6929 }
6930
6931 static bfd_byte *
6932 savefpr1_tail (bfd *abfd, bfd_byte *p, int r)
6933 {
6934 p = savefpr (abfd, p, r);
6935 bfd_put_32 (abfd, BLR, p);
6936 return p + 4;
6937 }
6938
6939 static bfd_byte *
6940 restfpr1_tail (bfd *abfd, bfd_byte *p, int r)
6941 {
6942 p = restfpr (abfd, p, r);
6943 bfd_put_32 (abfd, BLR, p);
6944 return p + 4;
6945 }
6946
6947 static bfd_byte *
6948 savevr (bfd *abfd, bfd_byte *p, int r)
6949 {
6950 bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6951 p = p + 4;
6952 bfd_put_32 (abfd, STVX_VR0_R12_R0 + (r << 21), p);
6953 return p + 4;
6954 }
6955
6956 static bfd_byte *
6957 savevr_tail (bfd *abfd, bfd_byte *p, int r)
6958 {
6959 p = savevr (abfd, p, r);
6960 bfd_put_32 (abfd, BLR, p);
6961 return p + 4;
6962 }
6963
6964 static bfd_byte *
6965 restvr (bfd *abfd, bfd_byte *p, int r)
6966 {
6967 bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6968 p = p + 4;
6969 bfd_put_32 (abfd, LVX_VR0_R12_R0 + (r << 21), p);
6970 return p + 4;
6971 }
6972
6973 static bfd_byte *
6974 restvr_tail (bfd *abfd, bfd_byte *p, int r)
6975 {
6976 p = restvr (abfd, p, r);
6977 bfd_put_32 (abfd, BLR, p);
6978 return p + 4;
6979 }
6980
6981 /* Called via elf_link_hash_traverse to transfer dynamic linking
6982 information on function code symbol entries to their corresponding
6983 function descriptor symbol entries. */
6984
6985 static bfd_boolean
6986 func_desc_adjust (struct elf_link_hash_entry *h, void *inf)
6987 {
6988 struct bfd_link_info *info;
6989 struct ppc_link_hash_table *htab;
6990 struct ppc_link_hash_entry *fh;
6991 struct ppc_link_hash_entry *fdh;
6992 bfd_boolean force_local;
6993
6994 fh = (struct ppc_link_hash_entry *) h;
6995 if (fh->elf.root.type == bfd_link_hash_indirect)
6996 return TRUE;
6997
6998 if (!fh->is_func)
6999 return TRUE;
7000
7001 if (fh->elf.root.root.string[0] != '.'
7002 || fh->elf.root.root.string[1] == '\0')
7003 return TRUE;
7004
7005 info = inf;
7006 htab = ppc_hash_table (info);
7007 if (htab == NULL)
7008 return FALSE;
7009
7010 /* Find the corresponding function descriptor symbol. */
7011 fdh = lookup_fdh (fh, htab);
7012
7013 /* Resolve undefined references to dot-symbols as the value
7014 in the function descriptor, if we have one in a regular object.
7015 This is to satisfy cases like ".quad .foo". Calls to functions
7016 in dynamic objects are handled elsewhere. */
7017 if ((fh->elf.root.type == bfd_link_hash_undefined
7018 || fh->elf.root.type == bfd_link_hash_undefweak)
7019 && (fdh->elf.root.type == bfd_link_hash_defined
7020 || fdh->elf.root.type == bfd_link_hash_defweak)
7021 && get_opd_info (fdh->elf.root.u.def.section) != NULL
7022 && opd_entry_value (fdh->elf.root.u.def.section,
7023 fdh->elf.root.u.def.value,
7024 &fh->elf.root.u.def.section,
7025 &fh->elf.root.u.def.value, FALSE) != (bfd_vma) -1)
7026 {
7027 fh->elf.root.type = fdh->elf.root.type;
7028 fh->elf.forced_local = 1;
7029 fh->elf.def_regular = fdh->elf.def_regular;
7030 fh->elf.def_dynamic = fdh->elf.def_dynamic;
7031 }
7032
7033 if (!fh->elf.dynamic)
7034 {
7035 struct plt_entry *ent;
7036
7037 for (ent = fh->elf.plt.plist; ent != NULL; ent = ent->next)
7038 if (ent->plt.refcount > 0)
7039 break;
7040 if (ent == NULL)
7041 return TRUE;
7042 }
7043
7044 /* Create a descriptor as undefined if necessary. */
7045 if (fdh == NULL
7046 && !bfd_link_executable (info)
7047 && (fh->elf.root.type == bfd_link_hash_undefined
7048 || fh->elf.root.type == bfd_link_hash_undefweak))
7049 {
7050 fdh = make_fdh (info, fh);
7051 if (fdh == NULL)
7052 return FALSE;
7053 }
7054
7055 /* We can't support overriding of symbols on a fake descriptor. */
7056 if (fdh != NULL
7057 && fdh->fake
7058 && (fh->elf.root.type == bfd_link_hash_defined
7059 || fh->elf.root.type == bfd_link_hash_defweak))
7060 _bfd_elf_link_hash_hide_symbol (info, &fdh->elf, TRUE);
7061
7062 /* Transfer dynamic linking information to the function descriptor. */
7063 if (fdh != NULL)
7064 {
7065 fdh->elf.ref_regular |= fh->elf.ref_regular;
7066 fdh->elf.ref_dynamic |= fh->elf.ref_dynamic;
7067 fdh->elf.ref_regular_nonweak |= fh->elf.ref_regular_nonweak;
7068 fdh->elf.non_got_ref |= fh->elf.non_got_ref;
7069 fdh->elf.dynamic |= fh->elf.dynamic;
7070 fdh->elf.needs_plt |= (fh->elf.needs_plt
7071 || fh->elf.type == STT_FUNC
7072 || fh->elf.type == STT_GNU_IFUNC);
7073 move_plt_plist (fh, fdh);
7074
7075 if (!fdh->elf.forced_local
7076 && fh->elf.dynindx != -1)
7077 if (!bfd_elf_link_record_dynamic_symbol (info, &fdh->elf))
7078 return FALSE;
7079 }
7080
7081 /* Now that the info is on the function descriptor, clear the
7082 function code sym info. Any function code syms for which we
7083 don't have a definition in a regular file, we force local.
7084 This prevents a shared library from exporting syms that have
7085 been imported from another library. Function code syms that
7086 are really in the library we must leave global to prevent the
7087 linker dragging in a definition from a static library. */
7088 force_local = (!fh->elf.def_regular
7089 || fdh == NULL
7090 || !fdh->elf.def_regular
7091 || fdh->elf.forced_local);
7092 _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
7093
7094 return TRUE;
7095 }
7096
7097 static const struct sfpr_def_parms save_res_funcs[] =
7098 {
7099 { "_savegpr0_", 14, 31, savegpr0, savegpr0_tail },
7100 { "_restgpr0_", 14, 29, restgpr0, restgpr0_tail },
7101 { "_restgpr0_", 30, 31, restgpr0, restgpr0_tail },
7102 { "_savegpr1_", 14, 31, savegpr1, savegpr1_tail },
7103 { "_restgpr1_", 14, 31, restgpr1, restgpr1_tail },
7104 { "_savefpr_", 14, 31, savefpr, savefpr0_tail },
7105 { "_restfpr_", 14, 29, restfpr, restfpr0_tail },
7106 { "_restfpr_", 30, 31, restfpr, restfpr0_tail },
7107 { "._savef", 14, 31, savefpr, savefpr1_tail },
7108 { "._restf", 14, 31, restfpr, restfpr1_tail },
7109 { "_savevr_", 20, 31, savevr, savevr_tail },
7110 { "_restvr_", 20, 31, restvr, restvr_tail }
7111 };
7112
7113 /* Called near the start of bfd_elf_size_dynamic_sections. We use
7114 this hook to a) provide some gcc support functions, and b) transfer
7115 dynamic linking information gathered so far on function code symbol
7116 entries, to their corresponding function descriptor symbol entries. */
7117
7118 static bfd_boolean
7119 ppc64_elf_func_desc_adjust (bfd *obfd ATTRIBUTE_UNUSED,
7120 struct bfd_link_info *info)
7121 {
7122 struct ppc_link_hash_table *htab;
7123
7124 htab = ppc_hash_table (info);
7125 if (htab == NULL)
7126 return FALSE;
7127
7128 /* Provide any missing _save* and _rest* functions. */
7129 if (htab->sfpr != NULL)
7130 {
7131 unsigned int i;
7132
7133 htab->sfpr->size = 0;
7134 for (i = 0; i < ARRAY_SIZE (save_res_funcs); i++)
7135 if (!sfpr_define (info, &save_res_funcs[i], NULL))
7136 return FALSE;
7137 if (htab->sfpr->size == 0)
7138 htab->sfpr->flags |= SEC_EXCLUDE;
7139 }
7140
7141 if (bfd_link_relocatable (info))
7142 return TRUE;
7143
7144 if (htab->elf.hgot != NULL)
7145 {
7146 _bfd_elf_link_hash_hide_symbol (info, htab->elf.hgot, TRUE);
7147 /* Make .TOC. defined so as to prevent it being made dynamic.
7148 The wrong value here is fixed later in ppc64_elf_set_toc. */
7149 if (!htab->elf.hgot->def_regular
7150 || htab->elf.hgot->root.type != bfd_link_hash_defined)
7151 {
7152 htab->elf.hgot->root.type = bfd_link_hash_defined;
7153 htab->elf.hgot->root.u.def.value = 0;
7154 htab->elf.hgot->root.u.def.section = bfd_abs_section_ptr;
7155 htab->elf.hgot->def_regular = 1;
7156 htab->elf.hgot->root.linker_def = 1;
7157 }
7158 htab->elf.hgot->type = STT_OBJECT;
7159 htab->elf.hgot->other = ((htab->elf.hgot->other & ~ELF_ST_VISIBILITY (-1))
7160 | STV_HIDDEN);
7161 }
7162
7163 if (htab->need_func_desc_adj)
7164 {
7165 elf_link_hash_traverse (&htab->elf, func_desc_adjust, info);
7166 htab->need_func_desc_adj = 0;
7167 }
7168
7169 return TRUE;
7170 }
7171
7172 /* Return true if we have dynamic relocs against H that apply to
7173 read-only sections. */
7174
7175 static bfd_boolean
7176 readonly_dynrelocs (struct elf_link_hash_entry *h)
7177 {
7178 struct ppc_link_hash_entry *eh;
7179 struct elf_dyn_relocs *p;
7180
7181 eh = (struct ppc_link_hash_entry *) h;
7182 for (p = eh->dyn_relocs; p != NULL; p = p->next)
7183 {
7184 asection *s = p->sec->output_section;
7185
7186 if (s != NULL && (s->flags & SEC_READONLY) != 0)
7187 return TRUE;
7188 }
7189 return FALSE;
7190 }
7191
7192 /* Return true if we have dynamic relocs against H or any of its weak
7193 aliases, that apply to read-only sections. */
7194
7195 static bfd_boolean
7196 alias_readonly_dynrelocs (struct elf_link_hash_entry *h)
7197 {
7198 struct ppc_link_hash_entry *eh;
7199
7200 eh = (struct ppc_link_hash_entry *) h;
7201 do
7202 {
7203 if (readonly_dynrelocs (&eh->elf))
7204 return TRUE;
7205 eh = eh->weakref;
7206 } while (eh != NULL && &eh->elf != h);
7207
7208 return FALSE;
7209 }
7210
7211 /* Return whether EH has pc-relative dynamic relocs. */
7212
7213 static bfd_boolean
7214 pc_dynrelocs (struct ppc_link_hash_entry *eh)
7215 {
7216 struct elf_dyn_relocs *p;
7217
7218 for (p = eh->dyn_relocs; p != NULL; p = p->next)
7219 if (p->pc_count != 0)
7220 return TRUE;
7221 return FALSE;
7222 }
7223
7224 /* Return true if a global entry stub will be created for H. Valid
7225 for ELFv2 before plt entries have been allocated. */
7226
7227 static bfd_boolean
7228 global_entry_stub (struct elf_link_hash_entry *h)
7229 {
7230 struct plt_entry *pent;
7231
7232 if (!h->pointer_equality_needed
7233 || h->def_regular)
7234 return FALSE;
7235
7236 for (pent = h->plt.plist; pent != NULL; pent = pent->next)
7237 if (pent->plt.refcount > 0
7238 && pent->addend == 0)
7239 return TRUE;
7240
7241 return FALSE;
7242 }
7243
7244 /* Adjust a symbol defined by a dynamic object and referenced by a
7245 regular object. The current definition is in some section of the
7246 dynamic object, but we're not including those sections. We have to
7247 change the definition to something the rest of the link can
7248 understand. */
7249
7250 static bfd_boolean
7251 ppc64_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
7252 struct elf_link_hash_entry *h)
7253 {
7254 struct ppc_link_hash_table *htab;
7255 asection *s, *srel;
7256
7257 htab = ppc_hash_table (info);
7258 if (htab == NULL)
7259 return FALSE;
7260
7261 /* Deal with function syms. */
7262 if (h->type == STT_FUNC
7263 || h->type == STT_GNU_IFUNC
7264 || h->needs_plt)
7265 {
7266 /* Clear procedure linkage table information for any symbol that
7267 won't need a .plt entry. */
7268 struct plt_entry *ent;
7269 for (ent = h->plt.plist; ent != NULL; ent = ent->next)
7270 if (ent->plt.refcount > 0)
7271 break;
7272 if (ent == NULL
7273 || (h->type != STT_GNU_IFUNC
7274 && (SYMBOL_CALLS_LOCAL (info, h)
7275 || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
7276 && h->root.type == bfd_link_hash_undefweak)))
7277 || ((struct ppc_link_hash_entry *) h)->save_res)
7278 {
7279 h->plt.plist = NULL;
7280 h->needs_plt = 0;
7281 h->pointer_equality_needed = 0;
7282 }
7283 else if (abiversion (info->output_bfd) >= 2)
7284 {
7285 /* Taking a function's address in a read/write section
7286 doesn't require us to define the function symbol in the
7287 executable on a global entry stub. A dynamic reloc can
7288 be used instead. The reason we prefer a few more dynamic
7289 relocs is that calling via a global entry stub costs a
7290 few more instructions, and pointer_equality_needed causes
7291 extra work in ld.so when resolving these symbols. */
7292 if (global_entry_stub (h)
7293 && !alias_readonly_dynrelocs (h))
7294 {
7295 h->pointer_equality_needed = 0;
7296 /* After adjust_dynamic_symbol, non_got_ref set in
7297 the non-pic case means that dyn_relocs for this
7298 symbol should be discarded. */
7299 h->non_got_ref = 0;
7300 }
7301
7302 /* If making a plt entry, then we don't need copy relocs. */
7303 return TRUE;
7304 }
7305 }
7306 else
7307 h->plt.plist = NULL;
7308
7309 /* If this is a weak symbol, and there is a real definition, the
7310 processor independent code will have arranged for us to see the
7311 real definition first, and we can just use the same value. */
7312 if (h->u.weakdef != NULL)
7313 {
7314 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
7315 || h->u.weakdef->root.type == bfd_link_hash_defweak);
7316 h->root.u.def.section = h->u.weakdef->root.u.def.section;
7317 h->root.u.def.value = h->u.weakdef->root.u.def.value;
7318 if (ELIMINATE_COPY_RELOCS)
7319 h->non_got_ref = h->u.weakdef->non_got_ref;
7320 return TRUE;
7321 }
7322
7323 /* If we are creating a shared library, we must presume that the
7324 only references to the symbol are via the global offset table.
7325 For such cases we need not do anything here; the relocations will
7326 be handled correctly by relocate_section. */
7327 if (bfd_link_pic (info))
7328 return TRUE;
7329
7330 /* If there are no references to this symbol that do not use the
7331 GOT, we don't need to generate a copy reloc. */
7332 if (!h->non_got_ref)
7333 return TRUE;
7334
7335 /* Don't generate a copy reloc for symbols defined in the executable. */
7336 if (!h->def_dynamic || !h->ref_regular || h->def_regular
7337
7338 /* If -z nocopyreloc was given, don't generate them either. */
7339 || info->nocopyreloc
7340
7341 /* If we didn't find any dynamic relocs in read-only sections, then
7342 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
7343 || (ELIMINATE_COPY_RELOCS && !alias_readonly_dynrelocs (h))
7344
7345 /* Protected variables do not work with .dynbss. The copy in
7346 .dynbss won't be used by the shared library with the protected
7347 definition for the variable. Text relocations are preferable
7348 to an incorrect program. */
7349 || h->protected_def)
7350 {
7351 h->non_got_ref = 0;
7352 return TRUE;
7353 }
7354
7355 if (h->plt.plist != NULL)
7356 {
7357 /* We should never get here, but unfortunately there are versions
7358 of gcc out there that improperly (for this ABI) put initialized
7359 function pointers, vtable refs and suchlike in read-only
7360 sections. Allow them to proceed, but warn that this might
7361 break at runtime. */
7362 info->callbacks->einfo
7363 (_("%P: copy reloc against `%T' requires lazy plt linking; "
7364 "avoid setting LD_BIND_NOW=1 or upgrade gcc\n"),
7365 h->root.root.string);
7366 }
7367
7368 /* This is a reference to a symbol defined by a dynamic object which
7369 is not a function. */
7370
7371 /* We must allocate the symbol in our .dynbss section, which will
7372 become part of the .bss section of the executable. There will be
7373 an entry for this symbol in the .dynsym section. The dynamic
7374 object will contain position independent code, so all references
7375 from the dynamic object to this symbol will go through the global
7376 offset table. The dynamic linker will use the .dynsym entry to
7377 determine the address it must put in the global offset table, so
7378 both the dynamic object and the regular object will refer to the
7379 same memory location for the variable. */
7380
7381 /* We must generate a R_PPC64_COPY reloc to tell the dynamic linker
7382 to copy the initial value out of the dynamic object and into the
7383 runtime process image. We need to remember the offset into the
7384 .rela.bss section we are going to use. */
7385 if ((h->root.u.def.section->flags & SEC_READONLY) != 0)
7386 {
7387 s = htab->elf.sdynrelro;
7388 srel = htab->elf.sreldynrelro;
7389 }
7390 else
7391 {
7392 s = htab->elf.sdynbss;
7393 srel = htab->elf.srelbss;
7394 }
7395 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
7396 {
7397 srel->size += sizeof (Elf64_External_Rela);
7398 h->needs_copy = 1;
7399 }
7400
7401 return _bfd_elf_adjust_dynamic_copy (info, h, s);
7402 }
7403
7404 /* If given a function descriptor symbol, hide both the function code
7405 sym and the descriptor. */
7406 static void
7407 ppc64_elf_hide_symbol (struct bfd_link_info *info,
7408 struct elf_link_hash_entry *h,
7409 bfd_boolean force_local)
7410 {
7411 struct ppc_link_hash_entry *eh;
7412 _bfd_elf_link_hash_hide_symbol (info, h, force_local);
7413
7414 eh = (struct ppc_link_hash_entry *) h;
7415 if (eh->is_func_descriptor)
7416 {
7417 struct ppc_link_hash_entry *fh = eh->oh;
7418
7419 if (fh == NULL)
7420 {
7421 const char *p, *q;
7422 struct elf_link_hash_table *htab = elf_hash_table (info);
7423 char save;
7424
7425 /* We aren't supposed to use alloca in BFD because on
7426 systems which do not have alloca the version in libiberty
7427 calls xmalloc, which might cause the program to crash
7428 when it runs out of memory. This function doesn't have a
7429 return status, so there's no way to gracefully return an
7430 error. So cheat. We know that string[-1] can be safely
7431 accessed; It's either a string in an ELF string table,
7432 or allocated in an objalloc structure. */
7433
7434 p = eh->elf.root.root.string - 1;
7435 save = *p;
7436 *(char *) p = '.';
7437 fh = (struct ppc_link_hash_entry *)
7438 elf_link_hash_lookup (htab, p, FALSE, FALSE, FALSE);
7439 *(char *) p = save;
7440
7441 /* Unfortunately, if it so happens that the string we were
7442 looking for was allocated immediately before this string,
7443 then we overwrote the string terminator. That's the only
7444 reason the lookup should fail. */
7445 if (fh == NULL)
7446 {
7447 q = eh->elf.root.root.string + strlen (eh->elf.root.root.string);
7448 while (q >= eh->elf.root.root.string && *q == *p)
7449 --q, --p;
7450 if (q < eh->elf.root.root.string && *p == '.')
7451 fh = (struct ppc_link_hash_entry *)
7452 elf_link_hash_lookup (htab, p, FALSE, FALSE, FALSE);
7453 }
7454 if (fh != NULL)
7455 {
7456 eh->oh = fh;
7457 fh->oh = eh;
7458 }
7459 }
7460 if (fh != NULL)
7461 _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
7462 }
7463 }
7464
7465 static bfd_boolean
7466 get_sym_h (struct elf_link_hash_entry **hp,
7467 Elf_Internal_Sym **symp,
7468 asection **symsecp,
7469 unsigned char **tls_maskp,
7470 Elf_Internal_Sym **locsymsp,
7471 unsigned long r_symndx,
7472 bfd *ibfd)
7473 {
7474 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
7475
7476 if (r_symndx >= symtab_hdr->sh_info)
7477 {
7478 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
7479 struct elf_link_hash_entry *h;
7480
7481 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
7482 h = elf_follow_link (h);
7483
7484 if (hp != NULL)
7485 *hp = h;
7486
7487 if (symp != NULL)
7488 *symp = NULL;
7489
7490 if (symsecp != NULL)
7491 {
7492 asection *symsec = NULL;
7493 if (h->root.type == bfd_link_hash_defined
7494 || h->root.type == bfd_link_hash_defweak)
7495 symsec = h->root.u.def.section;
7496 *symsecp = symsec;
7497 }
7498
7499 if (tls_maskp != NULL)
7500 {
7501 struct ppc_link_hash_entry *eh;
7502
7503 eh = (struct ppc_link_hash_entry *) h;
7504 *tls_maskp = &eh->tls_mask;
7505 }
7506 }
7507 else
7508 {
7509 Elf_Internal_Sym *sym;
7510 Elf_Internal_Sym *locsyms = *locsymsp;
7511
7512 if (locsyms == NULL)
7513 {
7514 locsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
7515 if (locsyms == NULL)
7516 locsyms = bfd_elf_get_elf_syms (ibfd, symtab_hdr,
7517 symtab_hdr->sh_info,
7518 0, NULL, NULL, NULL);
7519 if (locsyms == NULL)
7520 return FALSE;
7521 *locsymsp = locsyms;
7522 }
7523 sym = locsyms + r_symndx;
7524
7525 if (hp != NULL)
7526 *hp = NULL;
7527
7528 if (symp != NULL)
7529 *symp = sym;
7530
7531 if (symsecp != NULL)
7532 *symsecp = bfd_section_from_elf_index (ibfd, sym->st_shndx);
7533
7534 if (tls_maskp != NULL)
7535 {
7536 struct got_entry **lgot_ents;
7537 unsigned char *tls_mask;
7538
7539 tls_mask = NULL;
7540 lgot_ents = elf_local_got_ents (ibfd);
7541 if (lgot_ents != NULL)
7542 {
7543 struct plt_entry **local_plt = (struct plt_entry **)
7544 (lgot_ents + symtab_hdr->sh_info);
7545 unsigned char *lgot_masks = (unsigned char *)
7546 (local_plt + symtab_hdr->sh_info);
7547 tls_mask = &lgot_masks[r_symndx];
7548 }
7549 *tls_maskp = tls_mask;
7550 }
7551 }
7552 return TRUE;
7553 }
7554
7555 /* Returns TLS_MASKP for the given REL symbol. Function return is 0 on
7556 error, 2 on a toc GD type suitable for optimization, 3 on a toc LD
7557 type suitable for optimization, and 1 otherwise. */
7558
7559 static int
7560 get_tls_mask (unsigned char **tls_maskp,
7561 unsigned long *toc_symndx,
7562 bfd_vma *toc_addend,
7563 Elf_Internal_Sym **locsymsp,
7564 const Elf_Internal_Rela *rel,
7565 bfd *ibfd)
7566 {
7567 unsigned long r_symndx;
7568 int next_r;
7569 struct elf_link_hash_entry *h;
7570 Elf_Internal_Sym *sym;
7571 asection *sec;
7572 bfd_vma off;
7573
7574 r_symndx = ELF64_R_SYM (rel->r_info);
7575 if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7576 return 0;
7577
7578 if ((*tls_maskp != NULL && **tls_maskp != 0)
7579 || sec == NULL
7580 || ppc64_elf_section_data (sec) == NULL
7581 || ppc64_elf_section_data (sec)->sec_type != sec_toc)
7582 return 1;
7583
7584 /* Look inside a TOC section too. */
7585 if (h != NULL)
7586 {
7587 BFD_ASSERT (h->root.type == bfd_link_hash_defined);
7588 off = h->root.u.def.value;
7589 }
7590 else
7591 off = sym->st_value;
7592 off += rel->r_addend;
7593 BFD_ASSERT (off % 8 == 0);
7594 r_symndx = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8];
7595 next_r = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8 + 1];
7596 if (toc_symndx != NULL)
7597 *toc_symndx = r_symndx;
7598 if (toc_addend != NULL)
7599 *toc_addend = ppc64_elf_section_data (sec)->u.toc.add[off / 8];
7600 if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7601 return 0;
7602 if ((h == NULL || is_static_defined (h))
7603 && (next_r == -1 || next_r == -2))
7604 return 1 - next_r;
7605 return 1;
7606 }
7607
7608 /* Find (or create) an entry in the tocsave hash table. */
7609
7610 static struct tocsave_entry *
7611 tocsave_find (struct ppc_link_hash_table *htab,
7612 enum insert_option insert,
7613 Elf_Internal_Sym **local_syms,
7614 const Elf_Internal_Rela *irela,
7615 bfd *ibfd)
7616 {
7617 unsigned long r_indx;
7618 struct elf_link_hash_entry *h;
7619 Elf_Internal_Sym *sym;
7620 struct tocsave_entry ent, *p;
7621 hashval_t hash;
7622 struct tocsave_entry **slot;
7623
7624 r_indx = ELF64_R_SYM (irela->r_info);
7625 if (!get_sym_h (&h, &sym, &ent.sec, NULL, local_syms, r_indx, ibfd))
7626 return NULL;
7627 if (ent.sec == NULL || ent.sec->output_section == NULL)
7628 {
7629 _bfd_error_handler
7630 (_("%B: undefined symbol on R_PPC64_TOCSAVE relocation"));
7631 return NULL;
7632 }
7633
7634 if (h != NULL)
7635 ent.offset = h->root.u.def.value;
7636 else
7637 ent.offset = sym->st_value;
7638 ent.offset += irela->r_addend;
7639
7640 hash = tocsave_htab_hash (&ent);
7641 slot = ((struct tocsave_entry **)
7642 htab_find_slot_with_hash (htab->tocsave_htab, &ent, hash, insert));
7643 if (slot == NULL)
7644 return NULL;
7645
7646 if (*slot == NULL)
7647 {
7648 p = (struct tocsave_entry *) bfd_alloc (ibfd, sizeof (*p));
7649 if (p == NULL)
7650 return NULL;
7651 *p = ent;
7652 *slot = p;
7653 }
7654 return *slot;
7655 }
7656
7657 /* Adjust all global syms defined in opd sections. In gcc generated
7658 code for the old ABI, these will already have been done. */
7659
7660 static bfd_boolean
7661 adjust_opd_syms (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
7662 {
7663 struct ppc_link_hash_entry *eh;
7664 asection *sym_sec;
7665 struct _opd_sec_data *opd;
7666
7667 if (h->root.type == bfd_link_hash_indirect)
7668 return TRUE;
7669
7670 if (h->root.type != bfd_link_hash_defined
7671 && h->root.type != bfd_link_hash_defweak)
7672 return TRUE;
7673
7674 eh = (struct ppc_link_hash_entry *) h;
7675 if (eh->adjust_done)
7676 return TRUE;
7677
7678 sym_sec = eh->elf.root.u.def.section;
7679 opd = get_opd_info (sym_sec);
7680 if (opd != NULL && opd->adjust != NULL)
7681 {
7682 long adjust = opd->adjust[OPD_NDX (eh->elf.root.u.def.value)];
7683 if (adjust == -1)
7684 {
7685 /* This entry has been deleted. */
7686 asection *dsec = ppc64_elf_tdata (sym_sec->owner)->deleted_section;
7687 if (dsec == NULL)
7688 {
7689 for (dsec = sym_sec->owner->sections; dsec; dsec = dsec->next)
7690 if (discarded_section (dsec))
7691 {
7692 ppc64_elf_tdata (sym_sec->owner)->deleted_section = dsec;
7693 break;
7694 }
7695 }
7696 eh->elf.root.u.def.value = 0;
7697 eh->elf.root.u.def.section = dsec;
7698 }
7699 else
7700 eh->elf.root.u.def.value += adjust;
7701 eh->adjust_done = 1;
7702 }
7703 return TRUE;
7704 }
7705
7706 /* Handles decrementing dynamic reloc counts for the reloc specified by
7707 R_INFO in section SEC. If LOCAL_SYMS is NULL, then H and SYM
7708 have already been determined. */
7709
7710 static bfd_boolean
7711 dec_dynrel_count (bfd_vma r_info,
7712 asection *sec,
7713 struct bfd_link_info *info,
7714 Elf_Internal_Sym **local_syms,
7715 struct elf_link_hash_entry *h,
7716 Elf_Internal_Sym *sym)
7717 {
7718 enum elf_ppc64_reloc_type r_type;
7719 asection *sym_sec = NULL;
7720
7721 /* Can this reloc be dynamic? This switch, and later tests here
7722 should be kept in sync with the code in check_relocs. */
7723 r_type = ELF64_R_TYPE (r_info);
7724 switch (r_type)
7725 {
7726 default:
7727 return TRUE;
7728
7729 case R_PPC64_TPREL16:
7730 case R_PPC64_TPREL16_LO:
7731 case R_PPC64_TPREL16_HI:
7732 case R_PPC64_TPREL16_HA:
7733 case R_PPC64_TPREL16_DS:
7734 case R_PPC64_TPREL16_LO_DS:
7735 case R_PPC64_TPREL16_HIGH:
7736 case R_PPC64_TPREL16_HIGHA:
7737 case R_PPC64_TPREL16_HIGHER:
7738 case R_PPC64_TPREL16_HIGHERA:
7739 case R_PPC64_TPREL16_HIGHEST:
7740 case R_PPC64_TPREL16_HIGHESTA:
7741 if (!bfd_link_pic (info))
7742 return TRUE;
7743
7744 case R_PPC64_TPREL64:
7745 case R_PPC64_DTPMOD64:
7746 case R_PPC64_DTPREL64:
7747 case R_PPC64_ADDR64:
7748 case R_PPC64_REL30:
7749 case R_PPC64_REL32:
7750 case R_PPC64_REL64:
7751 case R_PPC64_ADDR14:
7752 case R_PPC64_ADDR14_BRNTAKEN:
7753 case R_PPC64_ADDR14_BRTAKEN:
7754 case R_PPC64_ADDR16:
7755 case R_PPC64_ADDR16_DS:
7756 case R_PPC64_ADDR16_HA:
7757 case R_PPC64_ADDR16_HI:
7758 case R_PPC64_ADDR16_HIGH:
7759 case R_PPC64_ADDR16_HIGHA:
7760 case R_PPC64_ADDR16_HIGHER:
7761 case R_PPC64_ADDR16_HIGHERA:
7762 case R_PPC64_ADDR16_HIGHEST:
7763 case R_PPC64_ADDR16_HIGHESTA:
7764 case R_PPC64_ADDR16_LO:
7765 case R_PPC64_ADDR16_LO_DS:
7766 case R_PPC64_ADDR24:
7767 case R_PPC64_ADDR32:
7768 case R_PPC64_UADDR16:
7769 case R_PPC64_UADDR32:
7770 case R_PPC64_UADDR64:
7771 case R_PPC64_TOC:
7772 break;
7773 }
7774
7775 if (local_syms != NULL)
7776 {
7777 unsigned long r_symndx;
7778 bfd *ibfd = sec->owner;
7779
7780 r_symndx = ELF64_R_SYM (r_info);
7781 if (!get_sym_h (&h, &sym, &sym_sec, NULL, local_syms, r_symndx, ibfd))
7782 return FALSE;
7783 }
7784
7785 if ((bfd_link_pic (info)
7786 && (must_be_dyn_reloc (info, r_type)
7787 || (h != NULL
7788 && (!SYMBOLIC_BIND (info, h)
7789 || h->root.type == bfd_link_hash_defweak
7790 || !h->def_regular))))
7791 || (ELIMINATE_COPY_RELOCS
7792 && !bfd_link_pic (info)
7793 && h != NULL
7794 && (h->root.type == bfd_link_hash_defweak
7795 || !h->def_regular)))
7796 ;
7797 else
7798 return TRUE;
7799
7800 if (h != NULL)
7801 {
7802 struct elf_dyn_relocs *p;
7803 struct elf_dyn_relocs **pp;
7804 pp = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
7805
7806 /* elf_gc_sweep may have already removed all dyn relocs associated
7807 with local syms for a given section. Also, symbol flags are
7808 changed by elf_gc_sweep_symbol, confusing the test above. Don't
7809 report a dynreloc miscount. */
7810 if (*pp == NULL && info->gc_sections)
7811 return TRUE;
7812
7813 while ((p = *pp) != NULL)
7814 {
7815 if (p->sec == sec)
7816 {
7817 if (!must_be_dyn_reloc (info, r_type))
7818 p->pc_count -= 1;
7819 p->count -= 1;
7820 if (p->count == 0)
7821 *pp = p->next;
7822 return TRUE;
7823 }
7824 pp = &p->next;
7825 }
7826 }
7827 else
7828 {
7829 struct ppc_dyn_relocs *p;
7830 struct ppc_dyn_relocs **pp;
7831 void *vpp;
7832 bfd_boolean is_ifunc;
7833
7834 if (local_syms == NULL)
7835 sym_sec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
7836 if (sym_sec == NULL)
7837 sym_sec = sec;
7838
7839 vpp = &elf_section_data (sym_sec)->local_dynrel;
7840 pp = (struct ppc_dyn_relocs **) vpp;
7841
7842 if (*pp == NULL && info->gc_sections)
7843 return TRUE;
7844
7845 is_ifunc = ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC;
7846 while ((p = *pp) != NULL)
7847 {
7848 if (p->sec == sec && p->ifunc == is_ifunc)
7849 {
7850 p->count -= 1;
7851 if (p->count == 0)
7852 *pp = p->next;
7853 return TRUE;
7854 }
7855 pp = &p->next;
7856 }
7857 }
7858
7859 /* xgettext:c-format */
7860 info->callbacks->einfo (_("%P: dynreloc miscount for %B, section %A\n"),
7861 sec->owner, sec);
7862 bfd_set_error (bfd_error_bad_value);
7863 return FALSE;
7864 }
7865
7866 /* Remove unused Official Procedure Descriptor entries. Currently we
7867 only remove those associated with functions in discarded link-once
7868 sections, or weakly defined functions that have been overridden. It
7869 would be possible to remove many more entries for statically linked
7870 applications. */
7871
7872 bfd_boolean
7873 ppc64_elf_edit_opd (struct bfd_link_info *info)
7874 {
7875 bfd *ibfd;
7876 bfd_boolean some_edited = FALSE;
7877 asection *need_pad = NULL;
7878 struct ppc_link_hash_table *htab;
7879
7880 htab = ppc_hash_table (info);
7881 if (htab == NULL)
7882 return FALSE;
7883
7884 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
7885 {
7886 asection *sec;
7887 Elf_Internal_Rela *relstart, *rel, *relend;
7888 Elf_Internal_Shdr *symtab_hdr;
7889 Elf_Internal_Sym *local_syms;
7890 struct _opd_sec_data *opd;
7891 bfd_boolean need_edit, add_aux_fields, broken;
7892 bfd_size_type cnt_16b = 0;
7893
7894 if (!is_ppc64_elf (ibfd))
7895 continue;
7896
7897 sec = bfd_get_section_by_name (ibfd, ".opd");
7898 if (sec == NULL || sec->size == 0)
7899 continue;
7900
7901 if (sec->sec_info_type == SEC_INFO_TYPE_JUST_SYMS)
7902 continue;
7903
7904 if (sec->output_section == bfd_abs_section_ptr)
7905 continue;
7906
7907 /* Look through the section relocs. */
7908 if ((sec->flags & SEC_RELOC) == 0 || sec->reloc_count == 0)
7909 continue;
7910
7911 local_syms = NULL;
7912 symtab_hdr = &elf_symtab_hdr (ibfd);
7913
7914 /* Read the relocations. */
7915 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
7916 info->keep_memory);
7917 if (relstart == NULL)
7918 return FALSE;
7919
7920 /* First run through the relocs to check they are sane, and to
7921 determine whether we need to edit this opd section. */
7922 need_edit = FALSE;
7923 broken = FALSE;
7924 need_pad = sec;
7925 relend = relstart + sec->reloc_count;
7926 for (rel = relstart; rel < relend; )
7927 {
7928 enum elf_ppc64_reloc_type r_type;
7929 unsigned long r_symndx;
7930 asection *sym_sec;
7931 struct elf_link_hash_entry *h;
7932 Elf_Internal_Sym *sym;
7933 bfd_vma offset;
7934
7935 /* .opd contains an array of 16 or 24 byte entries. We're
7936 only interested in the reloc pointing to a function entry
7937 point. */
7938 offset = rel->r_offset;
7939 if (rel + 1 == relend
7940 || rel[1].r_offset != offset + 8)
7941 {
7942 /* If someone messes with .opd alignment then after a
7943 "ld -r" we might have padding in the middle of .opd.
7944 Also, there's nothing to prevent someone putting
7945 something silly in .opd with the assembler. No .opd
7946 optimization for them! */
7947 broken_opd:
7948 _bfd_error_handler
7949 (_("%B: .opd is not a regular array of opd entries"), ibfd);
7950 broken = TRUE;
7951 break;
7952 }
7953
7954 if ((r_type = ELF64_R_TYPE (rel->r_info)) != R_PPC64_ADDR64
7955 || (r_type = ELF64_R_TYPE ((rel + 1)->r_info)) != R_PPC64_TOC)
7956 {
7957 _bfd_error_handler
7958 /* xgettext:c-format */
7959 (_("%B: unexpected reloc type %u in .opd section"),
7960 ibfd, r_type);
7961 broken = TRUE;
7962 break;
7963 }
7964
7965 r_symndx = ELF64_R_SYM (rel->r_info);
7966 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7967 r_symndx, ibfd))
7968 goto error_ret;
7969
7970 if (sym_sec == NULL || sym_sec->owner == NULL)
7971 {
7972 const char *sym_name;
7973 if (h != NULL)
7974 sym_name = h->root.root.string;
7975 else
7976 sym_name = bfd_elf_sym_name (ibfd, symtab_hdr, sym,
7977 sym_sec);
7978
7979 _bfd_error_handler
7980 /* xgettext:c-format */
7981 (_("%B: undefined sym `%s' in .opd section"),
7982 ibfd, sym_name);
7983 broken = TRUE;
7984 break;
7985 }
7986
7987 /* opd entries are always for functions defined in the
7988 current input bfd. If the symbol isn't defined in the
7989 input bfd, then we won't be using the function in this
7990 bfd; It must be defined in a linkonce section in another
7991 bfd, or is weak. It's also possible that we are
7992 discarding the function due to a linker script /DISCARD/,
7993 which we test for via the output_section. */
7994 if (sym_sec->owner != ibfd
7995 || sym_sec->output_section == bfd_abs_section_ptr)
7996 need_edit = TRUE;
7997
7998 rel += 2;
7999 if (rel + 1 == relend
8000 || (rel + 2 < relend
8001 && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_TOC))
8002 ++rel;
8003
8004 if (rel == relend)
8005 {
8006 if (sec->size == offset + 24)
8007 {
8008 need_pad = NULL;
8009 break;
8010 }
8011 if (sec->size == offset + 16)
8012 {
8013 cnt_16b++;
8014 break;
8015 }
8016 goto broken_opd;
8017 }
8018 else if (rel + 1 < relend
8019 && ELF64_R_TYPE (rel[0].r_info) == R_PPC64_ADDR64
8020 && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOC)
8021 {
8022 if (rel[0].r_offset == offset + 16)
8023 cnt_16b++;
8024 else if (rel[0].r_offset != offset + 24)
8025 goto broken_opd;
8026 }
8027 else
8028 goto broken_opd;
8029 }
8030
8031 add_aux_fields = htab->params->non_overlapping_opd && cnt_16b > 0;
8032
8033 if (!broken && (need_edit || add_aux_fields))
8034 {
8035 Elf_Internal_Rela *write_rel;
8036 Elf_Internal_Shdr *rel_hdr;
8037 bfd_byte *rptr, *wptr;
8038 bfd_byte *new_contents;
8039 bfd_size_type amt;
8040
8041 new_contents = NULL;
8042 amt = OPD_NDX (sec->size) * sizeof (long);
8043 opd = &ppc64_elf_section_data (sec)->u.opd;
8044 opd->adjust = bfd_zalloc (sec->owner, amt);
8045 if (opd->adjust == NULL)
8046 return FALSE;
8047 ppc64_elf_section_data (sec)->sec_type = sec_opd;
8048
8049 /* This seems a waste of time as input .opd sections are all
8050 zeros as generated by gcc, but I suppose there's no reason
8051 this will always be so. We might start putting something in
8052 the third word of .opd entries. */
8053 if ((sec->flags & SEC_IN_MEMORY) == 0)
8054 {
8055 bfd_byte *loc;
8056 if (!bfd_malloc_and_get_section (ibfd, sec, &loc))
8057 {
8058 if (loc != NULL)
8059 free (loc);
8060 error_ret:
8061 if (local_syms != NULL
8062 && symtab_hdr->contents != (unsigned char *) local_syms)
8063 free (local_syms);
8064 if (elf_section_data (sec)->relocs != relstart)
8065 free (relstart);
8066 return FALSE;
8067 }
8068 sec->contents = loc;
8069 sec->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
8070 }
8071
8072 elf_section_data (sec)->relocs = relstart;
8073
8074 new_contents = sec->contents;
8075 if (add_aux_fields)
8076 {
8077 new_contents = bfd_malloc (sec->size + cnt_16b * 8);
8078 if (new_contents == NULL)
8079 return FALSE;
8080 need_pad = NULL;
8081 }
8082 wptr = new_contents;
8083 rptr = sec->contents;
8084 write_rel = relstart;
8085 for (rel = relstart; rel < relend; )
8086 {
8087 unsigned long r_symndx;
8088 asection *sym_sec;
8089 struct elf_link_hash_entry *h;
8090 struct ppc_link_hash_entry *fdh = NULL;
8091 Elf_Internal_Sym *sym;
8092 long opd_ent_size;
8093 Elf_Internal_Rela *next_rel;
8094 bfd_boolean skip;
8095
8096 r_symndx = ELF64_R_SYM (rel->r_info);
8097 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8098 r_symndx, ibfd))
8099 goto error_ret;
8100
8101 next_rel = rel + 2;
8102 if (next_rel + 1 == relend
8103 || (next_rel + 2 < relend
8104 && ELF64_R_TYPE (next_rel[2].r_info) == R_PPC64_TOC))
8105 ++next_rel;
8106
8107 /* See if the .opd entry is full 24 byte or
8108 16 byte (with fd_aux entry overlapped with next
8109 fd_func). */
8110 opd_ent_size = 24;
8111 if (next_rel == relend)
8112 {
8113 if (sec->size == rel->r_offset + 16)
8114 opd_ent_size = 16;
8115 }
8116 else if (next_rel->r_offset == rel->r_offset + 16)
8117 opd_ent_size = 16;
8118
8119 if (h != NULL
8120 && h->root.root.string[0] == '.')
8121 {
8122 fdh = ((struct ppc_link_hash_entry *) h)->oh;
8123 if (fdh != NULL)
8124 {
8125 fdh = ppc_follow_link (fdh);
8126 if (fdh->elf.root.type != bfd_link_hash_defined
8127 && fdh->elf.root.type != bfd_link_hash_defweak)
8128 fdh = NULL;
8129 }
8130 }
8131
8132 skip = (sym_sec->owner != ibfd
8133 || sym_sec->output_section == bfd_abs_section_ptr);
8134 if (skip)
8135 {
8136 if (fdh != NULL && sym_sec->owner == ibfd)
8137 {
8138 /* Arrange for the function descriptor sym
8139 to be dropped. */
8140 fdh->elf.root.u.def.value = 0;
8141 fdh->elf.root.u.def.section = sym_sec;
8142 }
8143 opd->adjust[OPD_NDX (rel->r_offset)] = -1;
8144
8145 if (NO_OPD_RELOCS || bfd_link_relocatable (info))
8146 rel = next_rel;
8147 else
8148 while (1)
8149 {
8150 if (!dec_dynrel_count (rel->r_info, sec, info,
8151 NULL, h, sym))
8152 goto error_ret;
8153
8154 if (++rel == next_rel)
8155 break;
8156
8157 r_symndx = ELF64_R_SYM (rel->r_info);
8158 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8159 r_symndx, ibfd))
8160 goto error_ret;
8161 }
8162 }
8163 else
8164 {
8165 /* We'll be keeping this opd entry. */
8166 long adjust;
8167
8168 if (fdh != NULL)
8169 {
8170 /* Redefine the function descriptor symbol to
8171 this location in the opd section. It is
8172 necessary to update the value here rather
8173 than using an array of adjustments as we do
8174 for local symbols, because various places
8175 in the generic ELF code use the value
8176 stored in u.def.value. */
8177 fdh->elf.root.u.def.value = wptr - new_contents;
8178 fdh->adjust_done = 1;
8179 }
8180
8181 /* Local syms are a bit tricky. We could
8182 tweak them as they can be cached, but
8183 we'd need to look through the local syms
8184 for the function descriptor sym which we
8185 don't have at the moment. So keep an
8186 array of adjustments. */
8187 adjust = (wptr - new_contents) - (rptr - sec->contents);
8188 opd->adjust[OPD_NDX (rel->r_offset)] = adjust;
8189
8190 if (wptr != rptr)
8191 memcpy (wptr, rptr, opd_ent_size);
8192 wptr += opd_ent_size;
8193 if (add_aux_fields && opd_ent_size == 16)
8194 {
8195 memset (wptr, '\0', 8);
8196 wptr += 8;
8197 }
8198
8199 /* We need to adjust any reloc offsets to point to the
8200 new opd entries. */
8201 for ( ; rel != next_rel; ++rel)
8202 {
8203 rel->r_offset += adjust;
8204 if (write_rel != rel)
8205 memcpy (write_rel, rel, sizeof (*rel));
8206 ++write_rel;
8207 }
8208 }
8209
8210 rptr += opd_ent_size;
8211 }
8212
8213 sec->size = wptr - new_contents;
8214 sec->reloc_count = write_rel - relstart;
8215 if (add_aux_fields)
8216 {
8217 free (sec->contents);
8218 sec->contents = new_contents;
8219 }
8220
8221 /* Fudge the header size too, as this is used later in
8222 elf_bfd_final_link if we are emitting relocs. */
8223 rel_hdr = _bfd_elf_single_rel_hdr (sec);
8224 rel_hdr->sh_size = sec->reloc_count * rel_hdr->sh_entsize;
8225 some_edited = TRUE;
8226 }
8227 else if (elf_section_data (sec)->relocs != relstart)
8228 free (relstart);
8229
8230 if (local_syms != NULL
8231 && symtab_hdr->contents != (unsigned char *) local_syms)
8232 {
8233 if (!info->keep_memory)
8234 free (local_syms);
8235 else
8236 symtab_hdr->contents = (unsigned char *) local_syms;
8237 }
8238 }
8239
8240 if (some_edited)
8241 elf_link_hash_traverse (elf_hash_table (info), adjust_opd_syms, NULL);
8242
8243 /* If we are doing a final link and the last .opd entry is just 16 byte
8244 long, add a 8 byte padding after it. */
8245 if (need_pad != NULL && !bfd_link_relocatable (info))
8246 {
8247 bfd_byte *p;
8248
8249 if ((need_pad->flags & SEC_IN_MEMORY) == 0)
8250 {
8251 BFD_ASSERT (need_pad->size > 0);
8252
8253 p = bfd_malloc (need_pad->size + 8);
8254 if (p == NULL)
8255 return FALSE;
8256
8257 if (! bfd_get_section_contents (need_pad->owner, need_pad,
8258 p, 0, need_pad->size))
8259 return FALSE;
8260
8261 need_pad->contents = p;
8262 need_pad->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
8263 }
8264 else
8265 {
8266 p = bfd_realloc (need_pad->contents, need_pad->size + 8);
8267 if (p == NULL)
8268 return FALSE;
8269
8270 need_pad->contents = p;
8271 }
8272
8273 memset (need_pad->contents + need_pad->size, 0, 8);
8274 need_pad->size += 8;
8275 }
8276
8277 return TRUE;
8278 }
8279
8280 /* Set htab->tls_get_addr and call the generic ELF tls_setup function. */
8281
8282 asection *
8283 ppc64_elf_tls_setup (struct bfd_link_info *info)
8284 {
8285 struct ppc_link_hash_table *htab;
8286
8287 htab = ppc_hash_table (info);
8288 if (htab == NULL)
8289 return NULL;
8290
8291 if (abiversion (info->output_bfd) == 1)
8292 htab->opd_abi = 1;
8293
8294 if (htab->params->no_multi_toc)
8295 htab->do_multi_toc = 0;
8296 else if (!htab->do_multi_toc)
8297 htab->params->no_multi_toc = 1;
8298
8299 htab->tls_get_addr = ((struct ppc_link_hash_entry *)
8300 elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
8301 FALSE, FALSE, TRUE));
8302 /* Move dynamic linking info to the function descriptor sym. */
8303 if (htab->tls_get_addr != NULL)
8304 func_desc_adjust (&htab->tls_get_addr->elf, info);
8305 htab->tls_get_addr_fd = ((struct ppc_link_hash_entry *)
8306 elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
8307 FALSE, FALSE, TRUE));
8308 if (htab->params->tls_get_addr_opt)
8309 {
8310 struct elf_link_hash_entry *opt, *opt_fd, *tga, *tga_fd;
8311
8312 opt = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr_opt",
8313 FALSE, FALSE, TRUE);
8314 if (opt != NULL)
8315 func_desc_adjust (opt, info);
8316 opt_fd = elf_link_hash_lookup (&htab->elf, "__tls_get_addr_opt",
8317 FALSE, FALSE, TRUE);
8318 if (opt_fd != NULL
8319 && (opt_fd->root.type == bfd_link_hash_defined
8320 || opt_fd->root.type == bfd_link_hash_defweak))
8321 {
8322 /* If glibc supports an optimized __tls_get_addr call stub,
8323 signalled by the presence of __tls_get_addr_opt, and we'll
8324 be calling __tls_get_addr via a plt call stub, then
8325 make __tls_get_addr point to __tls_get_addr_opt. */
8326 tga_fd = &htab->tls_get_addr_fd->elf;
8327 if (htab->elf.dynamic_sections_created
8328 && tga_fd != NULL
8329 && (tga_fd->type == STT_FUNC
8330 || tga_fd->needs_plt)
8331 && !(SYMBOL_CALLS_LOCAL (info, tga_fd)
8332 || (ELF_ST_VISIBILITY (tga_fd->other) != STV_DEFAULT
8333 && tga_fd->root.type == bfd_link_hash_undefweak)))
8334 {
8335 struct plt_entry *ent;
8336
8337 for (ent = tga_fd->plt.plist; ent != NULL; ent = ent->next)
8338 if (ent->plt.refcount > 0)
8339 break;
8340 if (ent != NULL)
8341 {
8342 tga_fd->root.type = bfd_link_hash_indirect;
8343 tga_fd->root.u.i.link = &opt_fd->root;
8344 ppc64_elf_copy_indirect_symbol (info, opt_fd, tga_fd);
8345 opt_fd->mark = 1;
8346 if (opt_fd->dynindx != -1)
8347 {
8348 /* Use __tls_get_addr_opt in dynamic relocations. */
8349 opt_fd->dynindx = -1;
8350 _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
8351 opt_fd->dynstr_index);
8352 if (!bfd_elf_link_record_dynamic_symbol (info, opt_fd))
8353 return NULL;
8354 }
8355 htab->tls_get_addr_fd = (struct ppc_link_hash_entry *) opt_fd;
8356 tga = &htab->tls_get_addr->elf;
8357 if (opt != NULL && tga != NULL)
8358 {
8359 tga->root.type = bfd_link_hash_indirect;
8360 tga->root.u.i.link = &opt->root;
8361 ppc64_elf_copy_indirect_symbol (info, opt, tga);
8362 opt->mark = 1;
8363 _bfd_elf_link_hash_hide_symbol (info, opt,
8364 tga->forced_local);
8365 htab->tls_get_addr = (struct ppc_link_hash_entry *) opt;
8366 }
8367 htab->tls_get_addr_fd->oh = htab->tls_get_addr;
8368 htab->tls_get_addr_fd->is_func_descriptor = 1;
8369 if (htab->tls_get_addr != NULL)
8370 {
8371 htab->tls_get_addr->oh = htab->tls_get_addr_fd;
8372 htab->tls_get_addr->is_func = 1;
8373 }
8374 }
8375 }
8376 }
8377 else if (htab->params->tls_get_addr_opt < 0)
8378 htab->params->tls_get_addr_opt = 0;
8379 }
8380 return _bfd_elf_tls_setup (info->output_bfd, info);
8381 }
8382
8383 /* Return TRUE iff REL is a branch reloc with a global symbol matching
8384 HASH1 or HASH2. */
8385
8386 static bfd_boolean
8387 branch_reloc_hash_match (const bfd *ibfd,
8388 const Elf_Internal_Rela *rel,
8389 const struct ppc_link_hash_entry *hash1,
8390 const struct ppc_link_hash_entry *hash2)
8391 {
8392 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
8393 enum elf_ppc64_reloc_type r_type = ELF64_R_TYPE (rel->r_info);
8394 unsigned int r_symndx = ELF64_R_SYM (rel->r_info);
8395
8396 if (r_symndx >= symtab_hdr->sh_info && is_branch_reloc (r_type))
8397 {
8398 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
8399 struct elf_link_hash_entry *h;
8400
8401 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
8402 h = elf_follow_link (h);
8403 if (h == &hash1->elf || h == &hash2->elf)
8404 return TRUE;
8405 }
8406 return FALSE;
8407 }
8408
8409 /* Run through all the TLS relocs looking for optimization
8410 opportunities. The linker has been hacked (see ppc64elf.em) to do
8411 a preliminary section layout so that we know the TLS segment
8412 offsets. We can't optimize earlier because some optimizations need
8413 to know the tp offset, and we need to optimize before allocating
8414 dynamic relocations. */
8415
8416 bfd_boolean
8417 ppc64_elf_tls_optimize (struct bfd_link_info *info)
8418 {
8419 bfd *ibfd;
8420 asection *sec;
8421 struct ppc_link_hash_table *htab;
8422 unsigned char *toc_ref;
8423 int pass;
8424
8425 if (!bfd_link_executable (info))
8426 return TRUE;
8427
8428 htab = ppc_hash_table (info);
8429 if (htab == NULL)
8430 return FALSE;
8431
8432 /* Make two passes over the relocs. On the first pass, mark toc
8433 entries involved with tls relocs, and check that tls relocs
8434 involved in setting up a tls_get_addr call are indeed followed by
8435 such a call. If they are not, we can't do any tls optimization.
8436 On the second pass twiddle tls_mask flags to notify
8437 relocate_section that optimization can be done, and adjust got
8438 and plt refcounts. */
8439 toc_ref = NULL;
8440 for (pass = 0; pass < 2; ++pass)
8441 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
8442 {
8443 Elf_Internal_Sym *locsyms = NULL;
8444 asection *toc = bfd_get_section_by_name (ibfd, ".toc");
8445
8446 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8447 if (sec->has_tls_reloc && !bfd_is_abs_section (sec->output_section))
8448 {
8449 Elf_Internal_Rela *relstart, *rel, *relend;
8450 bfd_boolean found_tls_get_addr_arg = 0;
8451
8452 /* Read the relocations. */
8453 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8454 info->keep_memory);
8455 if (relstart == NULL)
8456 {
8457 free (toc_ref);
8458 return FALSE;
8459 }
8460
8461 relend = relstart + sec->reloc_count;
8462 for (rel = relstart; rel < relend; rel++)
8463 {
8464 enum elf_ppc64_reloc_type r_type;
8465 unsigned long r_symndx;
8466 struct elf_link_hash_entry *h;
8467 Elf_Internal_Sym *sym;
8468 asection *sym_sec;
8469 unsigned char *tls_mask;
8470 unsigned char tls_set, tls_clear, tls_type = 0;
8471 bfd_vma value;
8472 bfd_boolean ok_tprel, is_local;
8473 long toc_ref_index = 0;
8474 int expecting_tls_get_addr = 0;
8475 bfd_boolean ret = FALSE;
8476
8477 r_symndx = ELF64_R_SYM (rel->r_info);
8478 if (!get_sym_h (&h, &sym, &sym_sec, &tls_mask, &locsyms,
8479 r_symndx, ibfd))
8480 {
8481 err_free_rel:
8482 if (elf_section_data (sec)->relocs != relstart)
8483 free (relstart);
8484 if (toc_ref != NULL)
8485 free (toc_ref);
8486 if (locsyms != NULL
8487 && (elf_symtab_hdr (ibfd).contents
8488 != (unsigned char *) locsyms))
8489 free (locsyms);
8490 return ret;
8491 }
8492
8493 if (h != NULL)
8494 {
8495 if (h->root.type == bfd_link_hash_defined
8496 || h->root.type == bfd_link_hash_defweak)
8497 value = h->root.u.def.value;
8498 else if (h->root.type == bfd_link_hash_undefweak)
8499 value = 0;
8500 else
8501 {
8502 found_tls_get_addr_arg = 0;
8503 continue;
8504 }
8505 }
8506 else
8507 /* Symbols referenced by TLS relocs must be of type
8508 STT_TLS. So no need for .opd local sym adjust. */
8509 value = sym->st_value;
8510
8511 ok_tprel = FALSE;
8512 is_local = FALSE;
8513 if (h == NULL
8514 || !h->def_dynamic)
8515 {
8516 is_local = TRUE;
8517 if (h != NULL
8518 && h->root.type == bfd_link_hash_undefweak)
8519 ok_tprel = TRUE;
8520 else if (sym_sec != NULL
8521 && sym_sec->output_section != NULL)
8522 {
8523 value += sym_sec->output_offset;
8524 value += sym_sec->output_section->vma;
8525 value -= htab->elf.tls_sec->vma;
8526 ok_tprel = (value + TP_OFFSET + ((bfd_vma) 1 << 31)
8527 < (bfd_vma) 1 << 32);
8528 }
8529 }
8530
8531 r_type = ELF64_R_TYPE (rel->r_info);
8532 /* If this section has old-style __tls_get_addr calls
8533 without marker relocs, then check that each
8534 __tls_get_addr call reloc is preceded by a reloc
8535 that conceivably belongs to the __tls_get_addr arg
8536 setup insn. If we don't find matching arg setup
8537 relocs, don't do any tls optimization. */
8538 if (pass == 0
8539 && sec->has_tls_get_addr_call
8540 && h != NULL
8541 && (h == &htab->tls_get_addr->elf
8542 || h == &htab->tls_get_addr_fd->elf)
8543 && !found_tls_get_addr_arg
8544 && is_branch_reloc (r_type))
8545 {
8546 info->callbacks->minfo (_("%H __tls_get_addr lost arg, "
8547 "TLS optimization disabled\n"),
8548 ibfd, sec, rel->r_offset);
8549 ret = TRUE;
8550 goto err_free_rel;
8551 }
8552
8553 found_tls_get_addr_arg = 0;
8554 switch (r_type)
8555 {
8556 case R_PPC64_GOT_TLSLD16:
8557 case R_PPC64_GOT_TLSLD16_LO:
8558 expecting_tls_get_addr = 1;
8559 found_tls_get_addr_arg = 1;
8560 /* Fall through. */
8561
8562 case R_PPC64_GOT_TLSLD16_HI:
8563 case R_PPC64_GOT_TLSLD16_HA:
8564 /* These relocs should never be against a symbol
8565 defined in a shared lib. Leave them alone if
8566 that turns out to be the case. */
8567 if (!is_local)
8568 continue;
8569
8570 /* LD -> LE */
8571 tls_set = 0;
8572 tls_clear = TLS_LD;
8573 tls_type = TLS_TLS | TLS_LD;
8574 break;
8575
8576 case R_PPC64_GOT_TLSGD16:
8577 case R_PPC64_GOT_TLSGD16_LO:
8578 expecting_tls_get_addr = 1;
8579 found_tls_get_addr_arg = 1;
8580 /* Fall through. */
8581
8582 case R_PPC64_GOT_TLSGD16_HI:
8583 case R_PPC64_GOT_TLSGD16_HA:
8584 if (ok_tprel)
8585 /* GD -> LE */
8586 tls_set = 0;
8587 else
8588 /* GD -> IE */
8589 tls_set = TLS_TLS | TLS_TPRELGD;
8590 tls_clear = TLS_GD;
8591 tls_type = TLS_TLS | TLS_GD;
8592 break;
8593
8594 case R_PPC64_GOT_TPREL16_DS:
8595 case R_PPC64_GOT_TPREL16_LO_DS:
8596 case R_PPC64_GOT_TPREL16_HI:
8597 case R_PPC64_GOT_TPREL16_HA:
8598 if (ok_tprel)
8599 {
8600 /* IE -> LE */
8601 tls_set = 0;
8602 tls_clear = TLS_TPREL;
8603 tls_type = TLS_TLS | TLS_TPREL;
8604 break;
8605 }
8606 continue;
8607
8608 case R_PPC64_TLSGD:
8609 case R_PPC64_TLSLD:
8610 found_tls_get_addr_arg = 1;
8611 /* Fall through. */
8612
8613 case R_PPC64_TLS:
8614 case R_PPC64_TOC16:
8615 case R_PPC64_TOC16_LO:
8616 if (sym_sec == NULL || sym_sec != toc)
8617 continue;
8618
8619 /* Mark this toc entry as referenced by a TLS
8620 code sequence. We can do that now in the
8621 case of R_PPC64_TLS, and after checking for
8622 tls_get_addr for the TOC16 relocs. */
8623 if (toc_ref == NULL)
8624 toc_ref = bfd_zmalloc (toc->output_section->rawsize / 8);
8625 if (toc_ref == NULL)
8626 goto err_free_rel;
8627
8628 if (h != NULL)
8629 value = h->root.u.def.value;
8630 else
8631 value = sym->st_value;
8632 value += rel->r_addend;
8633 if (value % 8 != 0)
8634 continue;
8635 BFD_ASSERT (value < toc->size
8636 && toc->output_offset % 8 == 0);
8637 toc_ref_index = (value + toc->output_offset) / 8;
8638 if (r_type == R_PPC64_TLS
8639 || r_type == R_PPC64_TLSGD
8640 || r_type == R_PPC64_TLSLD)
8641 {
8642 toc_ref[toc_ref_index] = 1;
8643 continue;
8644 }
8645
8646 if (pass != 0 && toc_ref[toc_ref_index] == 0)
8647 continue;
8648
8649 tls_set = 0;
8650 tls_clear = 0;
8651 expecting_tls_get_addr = 2;
8652 break;
8653
8654 case R_PPC64_TPREL64:
8655 if (pass == 0
8656 || sec != toc
8657 || toc_ref == NULL
8658 || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
8659 continue;
8660 if (ok_tprel)
8661 {
8662 /* IE -> LE */
8663 tls_set = TLS_EXPLICIT;
8664 tls_clear = TLS_TPREL;
8665 break;
8666 }
8667 continue;
8668
8669 case R_PPC64_DTPMOD64:
8670 if (pass == 0
8671 || sec != toc
8672 || toc_ref == NULL
8673 || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
8674 continue;
8675 if (rel + 1 < relend
8676 && (rel[1].r_info
8677 == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64))
8678 && rel[1].r_offset == rel->r_offset + 8)
8679 {
8680 if (ok_tprel)
8681 /* GD -> LE */
8682 tls_set = TLS_EXPLICIT | TLS_GD;
8683 else
8684 /* GD -> IE */
8685 tls_set = TLS_EXPLICIT | TLS_GD | TLS_TPRELGD;
8686 tls_clear = TLS_GD;
8687 }
8688 else
8689 {
8690 if (!is_local)
8691 continue;
8692
8693 /* LD -> LE */
8694 tls_set = TLS_EXPLICIT;
8695 tls_clear = TLS_LD;
8696 }
8697 break;
8698
8699 default:
8700 continue;
8701 }
8702
8703 if (pass == 0)
8704 {
8705 if (!expecting_tls_get_addr
8706 || !sec->has_tls_get_addr_call)
8707 continue;
8708
8709 if (rel + 1 < relend
8710 && branch_reloc_hash_match (ibfd, rel + 1,
8711 htab->tls_get_addr,
8712 htab->tls_get_addr_fd))
8713 {
8714 if (expecting_tls_get_addr == 2)
8715 {
8716 /* Check for toc tls entries. */
8717 unsigned char *toc_tls;
8718 int retval;
8719
8720 retval = get_tls_mask (&toc_tls, NULL, NULL,
8721 &locsyms,
8722 rel, ibfd);
8723 if (retval == 0)
8724 goto err_free_rel;
8725 if (toc_tls != NULL)
8726 {
8727 if ((*toc_tls & (TLS_GD | TLS_LD)) != 0)
8728 found_tls_get_addr_arg = 1;
8729 if (retval > 1)
8730 toc_ref[toc_ref_index] = 1;
8731 }
8732 }
8733 continue;
8734 }
8735
8736 if (expecting_tls_get_addr != 1)
8737 continue;
8738
8739 /* Uh oh, we didn't find the expected call. We
8740 could just mark this symbol to exclude it
8741 from tls optimization but it's safer to skip
8742 the entire optimization. */
8743 /* xgettext:c-format */
8744 info->callbacks->minfo (_("%H arg lost __tls_get_addr, "
8745 "TLS optimization disabled\n"),
8746 ibfd, sec, rel->r_offset);
8747 ret = TRUE;
8748 goto err_free_rel;
8749 }
8750
8751 if (expecting_tls_get_addr && htab->tls_get_addr != NULL)
8752 {
8753 struct plt_entry *ent;
8754 for (ent = htab->tls_get_addr->elf.plt.plist;
8755 ent != NULL;
8756 ent = ent->next)
8757 if (ent->addend == 0)
8758 {
8759 if (ent->plt.refcount > 0)
8760 {
8761 ent->plt.refcount -= 1;
8762 expecting_tls_get_addr = 0;
8763 }
8764 break;
8765 }
8766 }
8767
8768 if (expecting_tls_get_addr && htab->tls_get_addr_fd != NULL)
8769 {
8770 struct plt_entry *ent;
8771 for (ent = htab->tls_get_addr_fd->elf.plt.plist;
8772 ent != NULL;
8773 ent = ent->next)
8774 if (ent->addend == 0)
8775 {
8776 if (ent->plt.refcount > 0)
8777 ent->plt.refcount -= 1;
8778 break;
8779 }
8780 }
8781
8782 if (tls_clear == 0)
8783 continue;
8784
8785 if ((tls_set & TLS_EXPLICIT) == 0)
8786 {
8787 struct got_entry *ent;
8788
8789 /* Adjust got entry for this reloc. */
8790 if (h != NULL)
8791 ent = h->got.glist;
8792 else
8793 ent = elf_local_got_ents (ibfd)[r_symndx];
8794
8795 for (; ent != NULL; ent = ent->next)
8796 if (ent->addend == rel->r_addend
8797 && ent->owner == ibfd
8798 && ent->tls_type == tls_type)
8799 break;
8800 if (ent == NULL)
8801 abort ();
8802
8803 if (tls_set == 0)
8804 {
8805 /* We managed to get rid of a got entry. */
8806 if (ent->got.refcount > 0)
8807 ent->got.refcount -= 1;
8808 }
8809 }
8810 else
8811 {
8812 /* If we got rid of a DTPMOD/DTPREL reloc pair then
8813 we'll lose one or two dyn relocs. */
8814 if (!dec_dynrel_count (rel->r_info, sec, info,
8815 NULL, h, sym))
8816 return FALSE;
8817
8818 if (tls_set == (TLS_EXPLICIT | TLS_GD))
8819 {
8820 if (!dec_dynrel_count ((rel + 1)->r_info, sec, info,
8821 NULL, h, sym))
8822 return FALSE;
8823 }
8824 }
8825
8826 *tls_mask |= tls_set;
8827 *tls_mask &= ~tls_clear;
8828 }
8829
8830 if (elf_section_data (sec)->relocs != relstart)
8831 free (relstart);
8832 }
8833
8834 if (locsyms != NULL
8835 && (elf_symtab_hdr (ibfd).contents != (unsigned char *) locsyms))
8836 {
8837 if (!info->keep_memory)
8838 free (locsyms);
8839 else
8840 elf_symtab_hdr (ibfd).contents = (unsigned char *) locsyms;
8841 }
8842 }
8843
8844 if (toc_ref != NULL)
8845 free (toc_ref);
8846 return TRUE;
8847 }
8848
8849 /* Called via elf_link_hash_traverse from ppc64_elf_edit_toc to adjust
8850 the values of any global symbols in a toc section that has been
8851 edited. Globals in toc sections should be a rarity, so this function
8852 sets a flag if any are found in toc sections other than the one just
8853 edited, so that futher hash table traversals can be avoided. */
8854
8855 struct adjust_toc_info
8856 {
8857 asection *toc;
8858 unsigned long *skip;
8859 bfd_boolean global_toc_syms;
8860 };
8861
8862 enum toc_skip_enum { ref_from_discarded = 1, can_optimize = 2 };
8863
8864 static bfd_boolean
8865 adjust_toc_syms (struct elf_link_hash_entry *h, void *inf)
8866 {
8867 struct ppc_link_hash_entry *eh;
8868 struct adjust_toc_info *toc_inf = (struct adjust_toc_info *) inf;
8869 unsigned long i;
8870
8871 if (h->root.type != bfd_link_hash_defined
8872 && h->root.type != bfd_link_hash_defweak)
8873 return TRUE;
8874
8875 eh = (struct ppc_link_hash_entry *) h;
8876 if (eh->adjust_done)
8877 return TRUE;
8878
8879 if (eh->elf.root.u.def.section == toc_inf->toc)
8880 {
8881 if (eh->elf.root.u.def.value > toc_inf->toc->rawsize)
8882 i = toc_inf->toc->rawsize >> 3;
8883 else
8884 i = eh->elf.root.u.def.value >> 3;
8885
8886 if ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0)
8887 {
8888 _bfd_error_handler
8889 (_("%s defined on removed toc entry"), eh->elf.root.root.string);
8890 do
8891 ++i;
8892 while ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0);
8893 eh->elf.root.u.def.value = (bfd_vma) i << 3;
8894 }
8895
8896 eh->elf.root.u.def.value -= toc_inf->skip[i];
8897 eh->adjust_done = 1;
8898 }
8899 else if (strcmp (eh->elf.root.u.def.section->name, ".toc") == 0)
8900 toc_inf->global_toc_syms = TRUE;
8901
8902 return TRUE;
8903 }
8904
8905 /* Return TRUE iff INSN with a relocation of R_TYPE is one we expect
8906 on a _LO variety toc/got reloc. */
8907
8908 static bfd_boolean
8909 ok_lo_toc_insn (unsigned int insn, enum elf_ppc64_reloc_type r_type)
8910 {
8911 return ((insn & (0x3f << 26)) == 12u << 26 /* addic */
8912 || (insn & (0x3f << 26)) == 14u << 26 /* addi */
8913 || (insn & (0x3f << 26)) == 32u << 26 /* lwz */
8914 || (insn & (0x3f << 26)) == 34u << 26 /* lbz */
8915 || (insn & (0x3f << 26)) == 36u << 26 /* stw */
8916 || (insn & (0x3f << 26)) == 38u << 26 /* stb */
8917 || (insn & (0x3f << 26)) == 40u << 26 /* lhz */
8918 || (insn & (0x3f << 26)) == 42u << 26 /* lha */
8919 || (insn & (0x3f << 26)) == 44u << 26 /* sth */
8920 || (insn & (0x3f << 26)) == 46u << 26 /* lmw */
8921 || (insn & (0x3f << 26)) == 47u << 26 /* stmw */
8922 || (insn & (0x3f << 26)) == 48u << 26 /* lfs */
8923 || (insn & (0x3f << 26)) == 50u << 26 /* lfd */
8924 || (insn & (0x3f << 26)) == 52u << 26 /* stfs */
8925 || (insn & (0x3f << 26)) == 54u << 26 /* stfd */
8926 || (insn & (0x3f << 26)) == 56u << 26 /* lq,lfq */
8927 || ((insn & (0x3f << 26)) == 57u << 26 /* lxsd,lxssp,lfdp */
8928 /* Exclude lfqu by testing reloc. If relocs are ever
8929 defined for the reduced D field in psq_lu then those
8930 will need testing too. */
8931 && r_type != R_PPC64_TOC16_LO && r_type != R_PPC64_GOT16_LO)
8932 || ((insn & (0x3f << 26)) == 58u << 26 /* ld,lwa */
8933 && (insn & 1) == 0)
8934 || (insn & (0x3f << 26)) == 60u << 26 /* stfq */
8935 || ((insn & (0x3f << 26)) == 61u << 26 /* lxv,stx{v,sd,ssp},stfdp */
8936 /* Exclude stfqu. psq_stu as above for psq_lu. */
8937 && r_type != R_PPC64_TOC16_LO && r_type != R_PPC64_GOT16_LO)
8938 || ((insn & (0x3f << 26)) == 62u << 26 /* std,stq */
8939 && (insn & 1) == 0));
8940 }
8941
8942 /* Examine all relocs referencing .toc sections in order to remove
8943 unused .toc entries. */
8944
8945 bfd_boolean
8946 ppc64_elf_edit_toc (struct bfd_link_info *info)
8947 {
8948 bfd *ibfd;
8949 struct adjust_toc_info toc_inf;
8950 struct ppc_link_hash_table *htab = ppc_hash_table (info);
8951
8952 htab->do_toc_opt = 1;
8953 toc_inf.global_toc_syms = TRUE;
8954 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
8955 {
8956 asection *toc, *sec;
8957 Elf_Internal_Shdr *symtab_hdr;
8958 Elf_Internal_Sym *local_syms;
8959 Elf_Internal_Rela *relstart, *rel, *toc_relocs;
8960 unsigned long *skip, *drop;
8961 unsigned char *used;
8962 unsigned char *keep, last, some_unused;
8963
8964 if (!is_ppc64_elf (ibfd))
8965 continue;
8966
8967 toc = bfd_get_section_by_name (ibfd, ".toc");
8968 if (toc == NULL
8969 || toc->size == 0
8970 || toc->sec_info_type == SEC_INFO_TYPE_JUST_SYMS
8971 || discarded_section (toc))
8972 continue;
8973
8974 toc_relocs = NULL;
8975 local_syms = NULL;
8976 symtab_hdr = &elf_symtab_hdr (ibfd);
8977
8978 /* Look at sections dropped from the final link. */
8979 skip = NULL;
8980 relstart = NULL;
8981 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8982 {
8983 if (sec->reloc_count == 0
8984 || !discarded_section (sec)
8985 || get_opd_info (sec)
8986 || (sec->flags & SEC_ALLOC) == 0
8987 || (sec->flags & SEC_DEBUGGING) != 0)
8988 continue;
8989
8990 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL, FALSE);
8991 if (relstart == NULL)
8992 goto error_ret;
8993
8994 /* Run through the relocs to see which toc entries might be
8995 unused. */
8996 for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
8997 {
8998 enum elf_ppc64_reloc_type r_type;
8999 unsigned long r_symndx;
9000 asection *sym_sec;
9001 struct elf_link_hash_entry *h;
9002 Elf_Internal_Sym *sym;
9003 bfd_vma val;
9004
9005 r_type = ELF64_R_TYPE (rel->r_info);
9006 switch (r_type)
9007 {
9008 default:
9009 continue;
9010
9011 case R_PPC64_TOC16:
9012 case R_PPC64_TOC16_LO:
9013 case R_PPC64_TOC16_HI:
9014 case R_PPC64_TOC16_HA:
9015 case R_PPC64_TOC16_DS:
9016 case R_PPC64_TOC16_LO_DS:
9017 break;
9018 }
9019
9020 r_symndx = ELF64_R_SYM (rel->r_info);
9021 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9022 r_symndx, ibfd))
9023 goto error_ret;
9024
9025 if (sym_sec != toc)
9026 continue;
9027
9028 if (h != NULL)
9029 val = h->root.u.def.value;
9030 else
9031 val = sym->st_value;
9032 val += rel->r_addend;
9033
9034 if (val >= toc->size)
9035 continue;
9036
9037 /* Anything in the toc ought to be aligned to 8 bytes.
9038 If not, don't mark as unused. */
9039 if (val & 7)
9040 continue;
9041
9042 if (skip == NULL)
9043 {
9044 skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
9045 if (skip == NULL)
9046 goto error_ret;
9047 }
9048
9049 skip[val >> 3] = ref_from_discarded;
9050 }
9051
9052 if (elf_section_data (sec)->relocs != relstart)
9053 free (relstart);
9054 }
9055
9056 /* For largetoc loads of address constants, we can convert
9057 . addis rx,2,addr@got@ha
9058 . ld ry,addr@got@l(rx)
9059 to
9060 . addis rx,2,addr@toc@ha
9061 . addi ry,rx,addr@toc@l
9062 when addr is within 2G of the toc pointer. This then means
9063 that the word storing "addr" in the toc is no longer needed. */
9064
9065 if (!ppc64_elf_tdata (ibfd)->has_small_toc_reloc
9066 && toc->output_section->rawsize < (bfd_vma) 1 << 31
9067 && toc->reloc_count != 0)
9068 {
9069 /* Read toc relocs. */
9070 toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
9071 info->keep_memory);
9072 if (toc_relocs == NULL)
9073 goto error_ret;
9074
9075 for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
9076 {
9077 enum elf_ppc64_reloc_type r_type;
9078 unsigned long r_symndx;
9079 asection *sym_sec;
9080 struct elf_link_hash_entry *h;
9081 Elf_Internal_Sym *sym;
9082 bfd_vma val, addr;
9083
9084 r_type = ELF64_R_TYPE (rel->r_info);
9085 if (r_type != R_PPC64_ADDR64)
9086 continue;
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 == NULL
9094 || sym_sec->output_section == NULL
9095 || discarded_section (sym_sec))
9096 continue;
9097
9098 if (!SYMBOL_REFERENCES_LOCAL (info, h))
9099 continue;
9100
9101 if (h != NULL)
9102 {
9103 if (h->type == STT_GNU_IFUNC)
9104 continue;
9105 val = h->root.u.def.value;
9106 }
9107 else
9108 {
9109 if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
9110 continue;
9111 val = sym->st_value;
9112 }
9113 val += rel->r_addend;
9114 val += sym_sec->output_section->vma + sym_sec->output_offset;
9115
9116 /* We don't yet know the exact toc pointer value, but we
9117 know it will be somewhere in the toc section. Don't
9118 optimize if the difference from any possible toc
9119 pointer is outside [ff..f80008000, 7fff7fff]. */
9120 addr = toc->output_section->vma + TOC_BASE_OFF;
9121 if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
9122 continue;
9123
9124 addr = toc->output_section->vma + toc->output_section->rawsize;
9125 if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
9126 continue;
9127
9128 if (skip == NULL)
9129 {
9130 skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
9131 if (skip == NULL)
9132 goto error_ret;
9133 }
9134
9135 skip[rel->r_offset >> 3]
9136 |= can_optimize | ((rel - toc_relocs) << 2);
9137 }
9138 }
9139
9140 if (skip == NULL)
9141 continue;
9142
9143 used = bfd_zmalloc (sizeof (*used) * (toc->size + 7) / 8);
9144 if (used == NULL)
9145 {
9146 error_ret:
9147 if (local_syms != NULL
9148 && symtab_hdr->contents != (unsigned char *) local_syms)
9149 free (local_syms);
9150 if (sec != NULL
9151 && relstart != NULL
9152 && elf_section_data (sec)->relocs != relstart)
9153 free (relstart);
9154 if (toc_relocs != NULL
9155 && elf_section_data (toc)->relocs != toc_relocs)
9156 free (toc_relocs);
9157 if (skip != NULL)
9158 free (skip);
9159 return FALSE;
9160 }
9161
9162 /* Now check all kept sections that might reference the toc.
9163 Check the toc itself last. */
9164 for (sec = (ibfd->sections == toc && toc->next ? toc->next
9165 : ibfd->sections);
9166 sec != NULL;
9167 sec = (sec == toc ? NULL
9168 : sec->next == NULL ? toc
9169 : sec->next == toc && toc->next ? toc->next
9170 : sec->next))
9171 {
9172 int repeat;
9173
9174 if (sec->reloc_count == 0
9175 || discarded_section (sec)
9176 || get_opd_info (sec)
9177 || (sec->flags & SEC_ALLOC) == 0
9178 || (sec->flags & SEC_DEBUGGING) != 0)
9179 continue;
9180
9181 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
9182 info->keep_memory);
9183 if (relstart == NULL)
9184 {
9185 free (used);
9186 goto error_ret;
9187 }
9188
9189 /* Mark toc entries referenced as used. */
9190 do
9191 {
9192 repeat = 0;
9193 for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9194 {
9195 enum elf_ppc64_reloc_type r_type;
9196 unsigned long r_symndx;
9197 asection *sym_sec;
9198 struct elf_link_hash_entry *h;
9199 Elf_Internal_Sym *sym;
9200 bfd_vma val;
9201 enum {no_check, check_lo, check_ha} insn_check;
9202
9203 r_type = ELF64_R_TYPE (rel->r_info);
9204 switch (r_type)
9205 {
9206 default:
9207 insn_check = no_check;
9208 break;
9209
9210 case R_PPC64_GOT_TLSLD16_HA:
9211 case R_PPC64_GOT_TLSGD16_HA:
9212 case R_PPC64_GOT_TPREL16_HA:
9213 case R_PPC64_GOT_DTPREL16_HA:
9214 case R_PPC64_GOT16_HA:
9215 case R_PPC64_TOC16_HA:
9216 insn_check = check_ha;
9217 break;
9218
9219 case R_PPC64_GOT_TLSLD16_LO:
9220 case R_PPC64_GOT_TLSGD16_LO:
9221 case R_PPC64_GOT_TPREL16_LO_DS:
9222 case R_PPC64_GOT_DTPREL16_LO_DS:
9223 case R_PPC64_GOT16_LO:
9224 case R_PPC64_GOT16_LO_DS:
9225 case R_PPC64_TOC16_LO:
9226 case R_PPC64_TOC16_LO_DS:
9227 insn_check = check_lo;
9228 break;
9229 }
9230
9231 if (insn_check != no_check)
9232 {
9233 bfd_vma off = rel->r_offset & ~3;
9234 unsigned char buf[4];
9235 unsigned int insn;
9236
9237 if (!bfd_get_section_contents (ibfd, sec, buf, off, 4))
9238 {
9239 free (used);
9240 goto error_ret;
9241 }
9242 insn = bfd_get_32 (ibfd, buf);
9243 if (insn_check == check_lo
9244 ? !ok_lo_toc_insn (insn, r_type)
9245 : ((insn & ((0x3f << 26) | 0x1f << 16))
9246 != ((15u << 26) | (2 << 16)) /* addis rt,2,imm */))
9247 {
9248 char str[12];
9249
9250 ppc64_elf_tdata (ibfd)->unexpected_toc_insn = 1;
9251 sprintf (str, "%#08x", insn);
9252 info->callbacks->einfo
9253 /* xgettext:c-format */
9254 (_("%H: toc optimization is not supported for"
9255 " %s instruction.\n"),
9256 ibfd, sec, rel->r_offset & ~3, str);
9257 }
9258 }
9259
9260 switch (r_type)
9261 {
9262 case R_PPC64_TOC16:
9263 case R_PPC64_TOC16_LO:
9264 case R_PPC64_TOC16_HI:
9265 case R_PPC64_TOC16_HA:
9266 case R_PPC64_TOC16_DS:
9267 case R_PPC64_TOC16_LO_DS:
9268 /* In case we're taking addresses of toc entries. */
9269 case R_PPC64_ADDR64:
9270 break;
9271
9272 default:
9273 continue;
9274 }
9275
9276 r_symndx = ELF64_R_SYM (rel->r_info);
9277 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9278 r_symndx, ibfd))
9279 {
9280 free (used);
9281 goto error_ret;
9282 }
9283
9284 if (sym_sec != toc)
9285 continue;
9286
9287 if (h != NULL)
9288 val = h->root.u.def.value;
9289 else
9290 val = sym->st_value;
9291 val += rel->r_addend;
9292
9293 if (val >= toc->size)
9294 continue;
9295
9296 if ((skip[val >> 3] & can_optimize) != 0)
9297 {
9298 bfd_vma off;
9299 unsigned char opc;
9300
9301 switch (r_type)
9302 {
9303 case R_PPC64_TOC16_HA:
9304 break;
9305
9306 case R_PPC64_TOC16_LO_DS:
9307 off = rel->r_offset;
9308 off += (bfd_big_endian (ibfd) ? -2 : 3);
9309 if (!bfd_get_section_contents (ibfd, sec, &opc,
9310 off, 1))
9311 {
9312 free (used);
9313 goto error_ret;
9314 }
9315 if ((opc & (0x3f << 2)) == (58u << 2))
9316 break;
9317 /* Fall through. */
9318
9319 default:
9320 /* Wrong sort of reloc, or not a ld. We may
9321 as well clear ref_from_discarded too. */
9322 skip[val >> 3] = 0;
9323 }
9324 }
9325
9326 if (sec != toc)
9327 used[val >> 3] = 1;
9328 /* For the toc section, we only mark as used if this
9329 entry itself isn't unused. */
9330 else if ((used[rel->r_offset >> 3]
9331 || !(skip[rel->r_offset >> 3] & ref_from_discarded))
9332 && !used[val >> 3])
9333 {
9334 /* Do all the relocs again, to catch reference
9335 chains. */
9336 repeat = 1;
9337 used[val >> 3] = 1;
9338 }
9339 }
9340 }
9341 while (repeat);
9342
9343 if (elf_section_data (sec)->relocs != relstart)
9344 free (relstart);
9345 }
9346
9347 /* Merge the used and skip arrays. Assume that TOC
9348 doublewords not appearing as either used or unused belong
9349 to to an entry more than one doubleword in size. */
9350 for (drop = skip, keep = used, last = 0, some_unused = 0;
9351 drop < skip + (toc->size + 7) / 8;
9352 ++drop, ++keep)
9353 {
9354 if (*keep)
9355 {
9356 *drop &= ~ref_from_discarded;
9357 if ((*drop & can_optimize) != 0)
9358 some_unused = 1;
9359 last = 0;
9360 }
9361 else if ((*drop & ref_from_discarded) != 0)
9362 {
9363 some_unused = 1;
9364 last = ref_from_discarded;
9365 }
9366 else
9367 *drop = last;
9368 }
9369
9370 free (used);
9371
9372 if (some_unused)
9373 {
9374 bfd_byte *contents, *src;
9375 unsigned long off;
9376 Elf_Internal_Sym *sym;
9377 bfd_boolean local_toc_syms = FALSE;
9378
9379 /* Shuffle the toc contents, and at the same time convert the
9380 skip array from booleans into offsets. */
9381 if (!bfd_malloc_and_get_section (ibfd, toc, &contents))
9382 goto error_ret;
9383
9384 elf_section_data (toc)->this_hdr.contents = contents;
9385
9386 for (src = contents, off = 0, drop = skip;
9387 src < contents + toc->size;
9388 src += 8, ++drop)
9389 {
9390 if ((*drop & (can_optimize | ref_from_discarded)) != 0)
9391 off += 8;
9392 else if (off != 0)
9393 {
9394 *drop = off;
9395 memcpy (src - off, src, 8);
9396 }
9397 }
9398 *drop = off;
9399 toc->rawsize = toc->size;
9400 toc->size = src - contents - off;
9401
9402 /* Adjust addends for relocs against the toc section sym,
9403 and optimize any accesses we can. */
9404 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
9405 {
9406 if (sec->reloc_count == 0
9407 || discarded_section (sec))
9408 continue;
9409
9410 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
9411 info->keep_memory);
9412 if (relstart == NULL)
9413 goto error_ret;
9414
9415 for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9416 {
9417 enum elf_ppc64_reloc_type r_type;
9418 unsigned long r_symndx;
9419 asection *sym_sec;
9420 struct elf_link_hash_entry *h;
9421 bfd_vma val;
9422
9423 r_type = ELF64_R_TYPE (rel->r_info);
9424 switch (r_type)
9425 {
9426 default:
9427 continue;
9428
9429 case R_PPC64_TOC16:
9430 case R_PPC64_TOC16_LO:
9431 case R_PPC64_TOC16_HI:
9432 case R_PPC64_TOC16_HA:
9433 case R_PPC64_TOC16_DS:
9434 case R_PPC64_TOC16_LO_DS:
9435 case R_PPC64_ADDR64:
9436 break;
9437 }
9438
9439 r_symndx = ELF64_R_SYM (rel->r_info);
9440 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9441 r_symndx, ibfd))
9442 goto error_ret;
9443
9444 if (sym_sec != toc)
9445 continue;
9446
9447 if (h != NULL)
9448 val = h->root.u.def.value;
9449 else
9450 {
9451 val = sym->st_value;
9452 if (val != 0)
9453 local_toc_syms = TRUE;
9454 }
9455
9456 val += rel->r_addend;
9457
9458 if (val > toc->rawsize)
9459 val = toc->rawsize;
9460 else if ((skip[val >> 3] & ref_from_discarded) != 0)
9461 continue;
9462 else if ((skip[val >> 3] & can_optimize) != 0)
9463 {
9464 Elf_Internal_Rela *tocrel
9465 = toc_relocs + (skip[val >> 3] >> 2);
9466 unsigned long tsym = ELF64_R_SYM (tocrel->r_info);
9467
9468 switch (r_type)
9469 {
9470 case R_PPC64_TOC16_HA:
9471 rel->r_info = ELF64_R_INFO (tsym, R_PPC64_TOC16_HA);
9472 break;
9473
9474 case R_PPC64_TOC16_LO_DS:
9475 rel->r_info = ELF64_R_INFO (tsym, R_PPC64_LO_DS_OPT);
9476 break;
9477
9478 default:
9479 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
9480 ppc_howto_init ();
9481 info->callbacks->einfo
9482 /* xgettext:c-format */
9483 (_("%H: %s references "
9484 "optimized away TOC entry\n"),
9485 ibfd, sec, rel->r_offset,
9486 ppc64_elf_howto_table[r_type]->name);
9487 bfd_set_error (bfd_error_bad_value);
9488 goto error_ret;
9489 }
9490 rel->r_addend = tocrel->r_addend;
9491 elf_section_data (sec)->relocs = relstart;
9492 continue;
9493 }
9494
9495 if (h != NULL || sym->st_value != 0)
9496 continue;
9497
9498 rel->r_addend -= skip[val >> 3];
9499 elf_section_data (sec)->relocs = relstart;
9500 }
9501
9502 if (elf_section_data (sec)->relocs != relstart)
9503 free (relstart);
9504 }
9505
9506 /* We shouldn't have local or global symbols defined in the TOC,
9507 but handle them anyway. */
9508 if (local_syms != NULL)
9509 for (sym = local_syms;
9510 sym < local_syms + symtab_hdr->sh_info;
9511 ++sym)
9512 if (sym->st_value != 0
9513 && bfd_section_from_elf_index (ibfd, sym->st_shndx) == toc)
9514 {
9515 unsigned long i;
9516
9517 if (sym->st_value > toc->rawsize)
9518 i = toc->rawsize >> 3;
9519 else
9520 i = sym->st_value >> 3;
9521
9522 if ((skip[i] & (ref_from_discarded | can_optimize)) != 0)
9523 {
9524 if (local_toc_syms)
9525 _bfd_error_handler
9526 (_("%s defined on removed toc entry"),
9527 bfd_elf_sym_name (ibfd, symtab_hdr, sym, NULL));
9528 do
9529 ++i;
9530 while ((skip[i] & (ref_from_discarded | can_optimize)));
9531 sym->st_value = (bfd_vma) i << 3;
9532 }
9533
9534 sym->st_value -= skip[i];
9535 symtab_hdr->contents = (unsigned char *) local_syms;
9536 }
9537
9538 /* Adjust any global syms defined in this toc input section. */
9539 if (toc_inf.global_toc_syms)
9540 {
9541 toc_inf.toc = toc;
9542 toc_inf.skip = skip;
9543 toc_inf.global_toc_syms = FALSE;
9544 elf_link_hash_traverse (elf_hash_table (info), adjust_toc_syms,
9545 &toc_inf);
9546 }
9547
9548 if (toc->reloc_count != 0)
9549 {
9550 Elf_Internal_Shdr *rel_hdr;
9551 Elf_Internal_Rela *wrel;
9552 bfd_size_type sz;
9553
9554 /* Remove unused toc relocs, and adjust those we keep. */
9555 if (toc_relocs == NULL)
9556 toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
9557 info->keep_memory);
9558 if (toc_relocs == NULL)
9559 goto error_ret;
9560
9561 wrel = toc_relocs;
9562 for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
9563 if ((skip[rel->r_offset >> 3]
9564 & (ref_from_discarded | can_optimize)) == 0)
9565 {
9566 wrel->r_offset = rel->r_offset - skip[rel->r_offset >> 3];
9567 wrel->r_info = rel->r_info;
9568 wrel->r_addend = rel->r_addend;
9569 ++wrel;
9570 }
9571 else if (!dec_dynrel_count (rel->r_info, toc, info,
9572 &local_syms, NULL, NULL))
9573 goto error_ret;
9574
9575 elf_section_data (toc)->relocs = toc_relocs;
9576 toc->reloc_count = wrel - toc_relocs;
9577 rel_hdr = _bfd_elf_single_rel_hdr (toc);
9578 sz = rel_hdr->sh_entsize;
9579 rel_hdr->sh_size = toc->reloc_count * sz;
9580 }
9581 }
9582 else if (toc_relocs != NULL
9583 && elf_section_data (toc)->relocs != toc_relocs)
9584 free (toc_relocs);
9585
9586 if (local_syms != NULL
9587 && symtab_hdr->contents != (unsigned char *) local_syms)
9588 {
9589 if (!info->keep_memory)
9590 free (local_syms);
9591 else
9592 symtab_hdr->contents = (unsigned char *) local_syms;
9593 }
9594 free (skip);
9595 }
9596
9597 return TRUE;
9598 }
9599
9600 /* Return true iff input section I references the TOC using
9601 instructions limited to +/-32k offsets. */
9602
9603 bfd_boolean
9604 ppc64_elf_has_small_toc_reloc (asection *i)
9605 {
9606 return (is_ppc64_elf (i->owner)
9607 && ppc64_elf_tdata (i->owner)->has_small_toc_reloc);
9608 }
9609
9610 /* Allocate space for one GOT entry. */
9611
9612 static void
9613 allocate_got (struct elf_link_hash_entry *h,
9614 struct bfd_link_info *info,
9615 struct got_entry *gent)
9616 {
9617 struct ppc_link_hash_table *htab = ppc_hash_table (info);
9618 struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
9619 int entsize = (gent->tls_type & eh->tls_mask & (TLS_GD | TLS_LD)
9620 ? 16 : 8);
9621 int rentsize = (gent->tls_type & eh->tls_mask & TLS_GD
9622 ? 2 : 1) * sizeof (Elf64_External_Rela);
9623 asection *got = ppc64_elf_tdata (gent->owner)->got;
9624
9625 gent->got.offset = got->size;
9626 got->size += entsize;
9627
9628 if (h->type == STT_GNU_IFUNC)
9629 {
9630 htab->elf.irelplt->size += rentsize;
9631 htab->got_reli_size += rentsize;
9632 }
9633 else if ((bfd_link_pic (info)
9634 || (htab->elf.dynamic_sections_created
9635 && h->dynindx != -1
9636 && !SYMBOL_REFERENCES_LOCAL (info, h)))
9637 && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
9638 || h->root.type != bfd_link_hash_undefweak))
9639 {
9640 asection *relgot = ppc64_elf_tdata (gent->owner)->relgot;
9641 relgot->size += rentsize;
9642 }
9643 }
9644
9645 /* This function merges got entries in the same toc group. */
9646
9647 static void
9648 merge_got_entries (struct got_entry **pent)
9649 {
9650 struct got_entry *ent, *ent2;
9651
9652 for (ent = *pent; ent != NULL; ent = ent->next)
9653 if (!ent->is_indirect)
9654 for (ent2 = ent->next; ent2 != NULL; ent2 = ent2->next)
9655 if (!ent2->is_indirect
9656 && ent2->addend == ent->addend
9657 && ent2->tls_type == ent->tls_type
9658 && elf_gp (ent2->owner) == elf_gp (ent->owner))
9659 {
9660 ent2->is_indirect = TRUE;
9661 ent2->got.ent = ent;
9662 }
9663 }
9664
9665 /* If H is undefined weak, make it dynamic if that makes sense. */
9666
9667 static bfd_boolean
9668 ensure_undefweak_dynamic (struct bfd_link_info *info,
9669 struct elf_link_hash_entry *h)
9670 {
9671 struct elf_link_hash_table *htab = elf_hash_table (info);
9672
9673 if (htab->dynamic_sections_created
9674 && h->root.type == bfd_link_hash_undefweak
9675 && h->dynindx == -1
9676 && !h->forced_local
9677 && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
9678 return bfd_elf_link_record_dynamic_symbol (info, h);
9679 return TRUE;
9680 }
9681
9682 /* Allocate space in .plt, .got and associated reloc sections for
9683 dynamic relocs. */
9684
9685 static bfd_boolean
9686 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
9687 {
9688 struct bfd_link_info *info;
9689 struct ppc_link_hash_table *htab;
9690 asection *s;
9691 struct ppc_link_hash_entry *eh;
9692 struct got_entry **pgent, *gent;
9693
9694 if (h->root.type == bfd_link_hash_indirect)
9695 return TRUE;
9696
9697 info = (struct bfd_link_info *) inf;
9698 htab = ppc_hash_table (info);
9699 if (htab == NULL)
9700 return FALSE;
9701
9702 eh = (struct ppc_link_hash_entry *) h;
9703 /* Run through the TLS GD got entries first if we're changing them
9704 to TPREL. */
9705 if ((eh->tls_mask & TLS_TPRELGD) != 0)
9706 for (gent = h->got.glist; gent != NULL; gent = gent->next)
9707 if (gent->got.refcount > 0
9708 && (gent->tls_type & TLS_GD) != 0)
9709 {
9710 /* This was a GD entry that has been converted to TPREL. If
9711 there happens to be a TPREL entry we can use that one. */
9712 struct got_entry *ent;
9713 for (ent = h->got.glist; ent != NULL; ent = ent->next)
9714 if (ent->got.refcount > 0
9715 && (ent->tls_type & TLS_TPREL) != 0
9716 && ent->addend == gent->addend
9717 && ent->owner == gent->owner)
9718 {
9719 gent->got.refcount = 0;
9720 break;
9721 }
9722
9723 /* If not, then we'll be using our own TPREL entry. */
9724 if (gent->got.refcount != 0)
9725 gent->tls_type = TLS_TLS | TLS_TPREL;
9726 }
9727
9728 /* Remove any list entry that won't generate a word in the GOT before
9729 we call merge_got_entries. Otherwise we risk merging to empty
9730 entries. */
9731 pgent = &h->got.glist;
9732 while ((gent = *pgent) != NULL)
9733 if (gent->got.refcount > 0)
9734 {
9735 if ((gent->tls_type & TLS_LD) != 0
9736 && !h->def_dynamic)
9737 {
9738 ppc64_tlsld_got (gent->owner)->got.refcount += 1;
9739 *pgent = gent->next;
9740 }
9741 else
9742 pgent = &gent->next;
9743 }
9744 else
9745 *pgent = gent->next;
9746
9747 if (!htab->do_multi_toc)
9748 merge_got_entries (&h->got.glist);
9749
9750 for (gent = h->got.glist; gent != NULL; gent = gent->next)
9751 if (!gent->is_indirect)
9752 {
9753 /* Make sure this symbol is output as a dynamic symbol.
9754 Undefined weak syms won't yet be marked as dynamic. */
9755 if (!ensure_undefweak_dynamic (info, h))
9756 return FALSE;
9757
9758 if (!is_ppc64_elf (gent->owner))
9759 abort ();
9760
9761 allocate_got (h, info, gent);
9762 }
9763
9764 if (!htab->elf.dynamic_sections_created
9765 && h->type != STT_GNU_IFUNC)
9766 eh->dyn_relocs = NULL;
9767
9768 if (eh->dyn_relocs != NULL)
9769 {
9770 struct elf_dyn_relocs *p, **pp;
9771
9772 /* In the shared -Bsymbolic case, discard space allocated for
9773 dynamic pc-relative relocs against symbols which turn out to
9774 be defined in regular objects. For the normal shared case,
9775 discard space for relocs that have become local due to symbol
9776 visibility changes. */
9777
9778 if (bfd_link_pic (info))
9779 {
9780 /* Relocs that use pc_count are those that appear on a call
9781 insn, or certain REL relocs (see must_be_dyn_reloc) that
9782 can be generated via assembly. We want calls to
9783 protected symbols to resolve directly to the function
9784 rather than going via the plt. If people want function
9785 pointer comparisons to work as expected then they should
9786 avoid writing weird assembly. */
9787 if (SYMBOL_CALLS_LOCAL (info, h))
9788 {
9789 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
9790 {
9791 p->count -= p->pc_count;
9792 p->pc_count = 0;
9793 if (p->count == 0)
9794 *pp = p->next;
9795 else
9796 pp = &p->next;
9797 }
9798 }
9799
9800 /* Also discard relocs on undefined weak syms with
9801 non-default visibility. */
9802 if (eh->dyn_relocs != NULL
9803 && h->root.type == bfd_link_hash_undefweak)
9804 {
9805 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
9806 eh->dyn_relocs = NULL;
9807
9808 /* Make sure this symbol is output as a dynamic symbol.
9809 Undefined weak syms won't yet be marked as dynamic. */
9810 else if (!ensure_undefweak_dynamic (info, h))
9811 return FALSE;
9812 }
9813 }
9814 else if (h->type == STT_GNU_IFUNC)
9815 {
9816 /* A plt entry is always created when making direct calls to
9817 an ifunc, even when building a static executable, but
9818 that doesn't cover all cases. We may have only an ifunc
9819 initialised function pointer for a given ifunc symbol.
9820
9821 For ELFv2, dynamic relocations are not required when
9822 generating a global entry PLT stub. */
9823 if (abiversion (info->output_bfd) >= 2)
9824 {
9825 if (global_entry_stub (h))
9826 eh->dyn_relocs = NULL;
9827 }
9828
9829 /* For ELFv1 we have function descriptors. Descriptors need
9830 to be treated like PLT entries and thus have dynamic
9831 relocations. One exception is when the function
9832 descriptor is copied into .dynbss (which should only
9833 happen with ancient versions of gcc). */
9834 else if (h->needs_copy)
9835 eh->dyn_relocs = NULL;
9836 }
9837 else if (ELIMINATE_COPY_RELOCS)
9838 {
9839 /* For the non-pic case, discard space for relocs against
9840 symbols which turn out to need copy relocs or are not
9841 dynamic. */
9842 if (!h->non_got_ref
9843 && !h->def_regular)
9844 {
9845 /* Make sure this symbol is output as a dynamic symbol.
9846 Undefined weak syms won't yet be marked as dynamic. */
9847 if (!ensure_undefweak_dynamic (info, h))
9848 return FALSE;
9849
9850 if (h->dynindx == -1)
9851 eh->dyn_relocs = NULL;
9852 }
9853 else
9854 eh->dyn_relocs = NULL;
9855 }
9856
9857 /* Finally, allocate space. */
9858 for (p = eh->dyn_relocs; p != NULL; p = p->next)
9859 {
9860 asection *sreloc = elf_section_data (p->sec)->sreloc;
9861 if (eh->elf.type == STT_GNU_IFUNC)
9862 sreloc = htab->elf.irelplt;
9863 sreloc->size += p->count * sizeof (Elf64_External_Rela);
9864 }
9865 }
9866
9867 if ((htab->elf.dynamic_sections_created
9868 && h->dynindx != -1)
9869 || h->type == STT_GNU_IFUNC)
9870 {
9871 struct plt_entry *pent;
9872 bfd_boolean doneone = FALSE;
9873 for (pent = h->plt.plist; pent != NULL; pent = pent->next)
9874 if (pent->plt.refcount > 0)
9875 {
9876 if (!htab->elf.dynamic_sections_created
9877 || h->dynindx == -1)
9878 {
9879 s = htab->elf.iplt;
9880 pent->plt.offset = s->size;
9881 s->size += PLT_ENTRY_SIZE (htab);
9882 s = htab->elf.irelplt;
9883 }
9884 else
9885 {
9886 /* If this is the first .plt entry, make room for the special
9887 first entry. */
9888 s = htab->elf.splt;
9889 if (s->size == 0)
9890 s->size += PLT_INITIAL_ENTRY_SIZE (htab);
9891
9892 pent->plt.offset = s->size;
9893
9894 /* Make room for this entry. */
9895 s->size += PLT_ENTRY_SIZE (htab);
9896
9897 /* Make room for the .glink code. */
9898 s = htab->glink;
9899 if (s->size == 0)
9900 s->size += GLINK_CALL_STUB_SIZE;
9901 if (htab->opd_abi)
9902 {
9903 /* We need bigger stubs past index 32767. */
9904 if (s->size >= GLINK_CALL_STUB_SIZE + 32768*2*4)
9905 s->size += 4;
9906 s->size += 2*4;
9907 }
9908 else
9909 s->size += 4;
9910
9911 /* We also need to make an entry in the .rela.plt section. */
9912 s = htab->elf.srelplt;
9913 }
9914 s->size += sizeof (Elf64_External_Rela);
9915 doneone = TRUE;
9916 }
9917 else
9918 pent->plt.offset = (bfd_vma) -1;
9919 if (!doneone)
9920 {
9921 h->plt.plist = NULL;
9922 h->needs_plt = 0;
9923 }
9924 }
9925 else
9926 {
9927 h->plt.plist = NULL;
9928 h->needs_plt = 0;
9929 }
9930
9931 return TRUE;
9932 }
9933
9934 /* Called via elf_link_hash_traverse from ppc64_elf_size_dynamic_sections
9935 to set up space for global entry stubs. These are put in glink,
9936 after the branch table. */
9937
9938 static bfd_boolean
9939 size_global_entry_stubs (struct elf_link_hash_entry *h, void *inf)
9940 {
9941 struct bfd_link_info *info;
9942 struct ppc_link_hash_table *htab;
9943 struct plt_entry *pent;
9944 asection *s;
9945
9946 if (h->root.type == bfd_link_hash_indirect)
9947 return TRUE;
9948
9949 if (!h->pointer_equality_needed)
9950 return TRUE;
9951
9952 if (h->def_regular)
9953 return TRUE;
9954
9955 info = inf;
9956 htab = ppc_hash_table (info);
9957 if (htab == NULL)
9958 return FALSE;
9959
9960 s = htab->glink;
9961 for (pent = h->plt.plist; pent != NULL; pent = pent->next)
9962 if (pent->plt.offset != (bfd_vma) -1
9963 && pent->addend == 0)
9964 {
9965 /* For ELFv2, if this symbol is not defined in a regular file
9966 and we are not generating a shared library or pie, then we
9967 need to define the symbol in the executable on a call stub.
9968 This is to avoid text relocations. */
9969 s->size = (s->size + 15) & -16;
9970 h->root.type = bfd_link_hash_defined;
9971 h->root.u.def.section = s;
9972 h->root.u.def.value = s->size;
9973 s->size += 16;
9974 break;
9975 }
9976 return TRUE;
9977 }
9978
9979 /* Set DF_TEXTREL if we find any dynamic relocs that apply to
9980 read-only sections. */
9981
9982 static bfd_boolean
9983 maybe_set_textrel (struct elf_link_hash_entry *h, void *info)
9984 {
9985 if (h->root.type == bfd_link_hash_indirect)
9986 return TRUE;
9987
9988 if (readonly_dynrelocs (h))
9989 {
9990 ((struct bfd_link_info *) info)->flags |= DF_TEXTREL;
9991
9992 /* Not an error, just cut short the traversal. */
9993 return FALSE;
9994 }
9995 return TRUE;
9996 }
9997
9998 /* Set the sizes of the dynamic sections. */
9999
10000 static bfd_boolean
10001 ppc64_elf_size_dynamic_sections (bfd *output_bfd,
10002 struct bfd_link_info *info)
10003 {
10004 struct ppc_link_hash_table *htab;
10005 bfd *dynobj;
10006 asection *s;
10007 bfd_boolean relocs;
10008 bfd *ibfd;
10009 struct got_entry *first_tlsld;
10010
10011 htab = ppc_hash_table (info);
10012 if (htab == NULL)
10013 return FALSE;
10014
10015 dynobj = htab->elf.dynobj;
10016 if (dynobj == NULL)
10017 abort ();
10018
10019 if (htab->elf.dynamic_sections_created)
10020 {
10021 /* Set the contents of the .interp section to the interpreter. */
10022 if (bfd_link_executable (info) && !info->nointerp)
10023 {
10024 s = bfd_get_linker_section (dynobj, ".interp");
10025 if (s == NULL)
10026 abort ();
10027 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
10028 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
10029 }
10030 }
10031
10032 /* Set up .got offsets for local syms, and space for local dynamic
10033 relocs. */
10034 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
10035 {
10036 struct got_entry **lgot_ents;
10037 struct got_entry **end_lgot_ents;
10038 struct plt_entry **local_plt;
10039 struct plt_entry **end_local_plt;
10040 unsigned char *lgot_masks;
10041 bfd_size_type locsymcount;
10042 Elf_Internal_Shdr *symtab_hdr;
10043
10044 if (!is_ppc64_elf (ibfd))
10045 continue;
10046
10047 for (s = ibfd->sections; s != NULL; s = s->next)
10048 {
10049 struct ppc_dyn_relocs *p;
10050
10051 for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
10052 {
10053 if (!bfd_is_abs_section (p->sec)
10054 && bfd_is_abs_section (p->sec->output_section))
10055 {
10056 /* Input section has been discarded, either because
10057 it is a copy of a linkonce section or due to
10058 linker script /DISCARD/, so we'll be discarding
10059 the relocs too. */
10060 }
10061 else if (p->count != 0)
10062 {
10063 asection *srel = elf_section_data (p->sec)->sreloc;
10064 if (p->ifunc)
10065 srel = htab->elf.irelplt;
10066 srel->size += p->count * sizeof (Elf64_External_Rela);
10067 if ((p->sec->output_section->flags & SEC_READONLY) != 0)
10068 info->flags |= DF_TEXTREL;
10069 }
10070 }
10071 }
10072
10073 lgot_ents = elf_local_got_ents (ibfd);
10074 if (!lgot_ents)
10075 continue;
10076
10077 symtab_hdr = &elf_symtab_hdr (ibfd);
10078 locsymcount = symtab_hdr->sh_info;
10079 end_lgot_ents = lgot_ents + locsymcount;
10080 local_plt = (struct plt_entry **) end_lgot_ents;
10081 end_local_plt = local_plt + locsymcount;
10082 lgot_masks = (unsigned char *) end_local_plt;
10083 s = ppc64_elf_tdata (ibfd)->got;
10084 for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
10085 {
10086 struct got_entry **pent, *ent;
10087
10088 pent = lgot_ents;
10089 while ((ent = *pent) != NULL)
10090 if (ent->got.refcount > 0)
10091 {
10092 if ((ent->tls_type & *lgot_masks & TLS_LD) != 0)
10093 {
10094 ppc64_tlsld_got (ibfd)->got.refcount += 1;
10095 *pent = ent->next;
10096 }
10097 else
10098 {
10099 unsigned int ent_size = 8;
10100 unsigned int rel_size = sizeof (Elf64_External_Rela);
10101
10102 ent->got.offset = s->size;
10103 if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
10104 {
10105 ent_size *= 2;
10106 rel_size *= 2;
10107 }
10108 s->size += ent_size;
10109 if ((*lgot_masks & PLT_IFUNC) != 0)
10110 {
10111 htab->elf.irelplt->size += rel_size;
10112 htab->got_reli_size += rel_size;
10113 }
10114 else if (bfd_link_pic (info))
10115 {
10116 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
10117 srel->size += rel_size;
10118 }
10119 pent = &ent->next;
10120 }
10121 }
10122 else
10123 *pent = ent->next;
10124 }
10125
10126 /* Allocate space for calls to local STT_GNU_IFUNC syms in .iplt. */
10127 for (; local_plt < end_local_plt; ++local_plt)
10128 {
10129 struct plt_entry *ent;
10130
10131 for (ent = *local_plt; ent != NULL; ent = ent->next)
10132 if (ent->plt.refcount > 0)
10133 {
10134 s = htab->elf.iplt;
10135 ent->plt.offset = s->size;
10136 s->size += PLT_ENTRY_SIZE (htab);
10137
10138 htab->elf.irelplt->size += sizeof (Elf64_External_Rela);
10139 }
10140 else
10141 ent->plt.offset = (bfd_vma) -1;
10142 }
10143 }
10144
10145 /* Allocate global sym .plt and .got entries, and space for global
10146 sym dynamic relocs. */
10147 elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, info);
10148 /* Stash the end of glink branch table. */
10149 if (htab->glink != NULL)
10150 htab->glink->rawsize = htab->glink->size;
10151
10152 if (!htab->opd_abi && !bfd_link_pic (info))
10153 elf_link_hash_traverse (&htab->elf, size_global_entry_stubs, info);
10154
10155 first_tlsld = NULL;
10156 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
10157 {
10158 struct got_entry *ent;
10159
10160 if (!is_ppc64_elf (ibfd))
10161 continue;
10162
10163 ent = ppc64_tlsld_got (ibfd);
10164 if (ent->got.refcount > 0)
10165 {
10166 if (!htab->do_multi_toc && first_tlsld != NULL)
10167 {
10168 ent->is_indirect = TRUE;
10169 ent->got.ent = first_tlsld;
10170 }
10171 else
10172 {
10173 if (first_tlsld == NULL)
10174 first_tlsld = ent;
10175 s = ppc64_elf_tdata (ibfd)->got;
10176 ent->got.offset = s->size;
10177 ent->owner = ibfd;
10178 s->size += 16;
10179 if (bfd_link_pic (info))
10180 {
10181 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
10182 srel->size += sizeof (Elf64_External_Rela);
10183 }
10184 }
10185 }
10186 else
10187 ent->got.offset = (bfd_vma) -1;
10188 }
10189
10190 /* We now have determined the sizes of the various dynamic sections.
10191 Allocate memory for them. */
10192 relocs = FALSE;
10193 for (s = dynobj->sections; s != NULL; s = s->next)
10194 {
10195 if ((s->flags & SEC_LINKER_CREATED) == 0)
10196 continue;
10197
10198 if (s == htab->brlt || s == htab->relbrlt)
10199 /* These haven't been allocated yet; don't strip. */
10200 continue;
10201 else if (s == htab->elf.sgot
10202 || s == htab->elf.splt
10203 || s == htab->elf.iplt
10204 || s == htab->glink
10205 || s == htab->elf.sdynbss
10206 || s == htab->elf.sdynrelro)
10207 {
10208 /* Strip this section if we don't need it; see the
10209 comment below. */
10210 }
10211 else if (s == htab->glink_eh_frame)
10212 {
10213 if (!bfd_is_abs_section (s->output_section))
10214 /* Not sized yet. */
10215 continue;
10216 }
10217 else if (CONST_STRNEQ (s->name, ".rela"))
10218 {
10219 if (s->size != 0)
10220 {
10221 if (s != htab->elf.srelplt)
10222 relocs = TRUE;
10223
10224 /* We use the reloc_count field as a counter if we need
10225 to copy relocs into the output file. */
10226 s->reloc_count = 0;
10227 }
10228 }
10229 else
10230 {
10231 /* It's not one of our sections, so don't allocate space. */
10232 continue;
10233 }
10234
10235 if (s->size == 0)
10236 {
10237 /* If we don't need this section, strip it from the
10238 output file. This is mostly to handle .rela.bss and
10239 .rela.plt. We must create both sections in
10240 create_dynamic_sections, because they must be created
10241 before the linker maps input sections to output
10242 sections. The linker does that before
10243 adjust_dynamic_symbol is called, and it is that
10244 function which decides whether anything needs to go
10245 into these sections. */
10246 s->flags |= SEC_EXCLUDE;
10247 continue;
10248 }
10249
10250 if ((s->flags & SEC_HAS_CONTENTS) == 0)
10251 continue;
10252
10253 /* Allocate memory for the section contents. We use bfd_zalloc
10254 here in case unused entries are not reclaimed before the
10255 section's contents are written out. This should not happen,
10256 but this way if it does we get a R_PPC64_NONE reloc in .rela
10257 sections instead of garbage.
10258 We also rely on the section contents being zero when writing
10259 the GOT and .dynrelro. */
10260 s->contents = bfd_zalloc (dynobj, s->size);
10261 if (s->contents == NULL)
10262 return FALSE;
10263 }
10264
10265 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
10266 {
10267 if (!is_ppc64_elf (ibfd))
10268 continue;
10269
10270 s = ppc64_elf_tdata (ibfd)->got;
10271 if (s != NULL && s != htab->elf.sgot)
10272 {
10273 if (s->size == 0)
10274 s->flags |= SEC_EXCLUDE;
10275 else
10276 {
10277 s->contents = bfd_zalloc (ibfd, s->size);
10278 if (s->contents == NULL)
10279 return FALSE;
10280 }
10281 }
10282 s = ppc64_elf_tdata (ibfd)->relgot;
10283 if (s != NULL)
10284 {
10285 if (s->size == 0)
10286 s->flags |= SEC_EXCLUDE;
10287 else
10288 {
10289 s->contents = bfd_zalloc (ibfd, s->size);
10290 if (s->contents == NULL)
10291 return FALSE;
10292 relocs = TRUE;
10293 s->reloc_count = 0;
10294 }
10295 }
10296 }
10297
10298 if (htab->elf.dynamic_sections_created)
10299 {
10300 bfd_boolean tls_opt;
10301
10302 /* Add some entries to the .dynamic section. We fill in the
10303 values later, in ppc64_elf_finish_dynamic_sections, but we
10304 must add the entries now so that we get the correct size for
10305 the .dynamic section. The DT_DEBUG entry is filled in by the
10306 dynamic linker and used by the debugger. */
10307 #define add_dynamic_entry(TAG, VAL) \
10308 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
10309
10310 if (bfd_link_executable (info))
10311 {
10312 if (!add_dynamic_entry (DT_DEBUG, 0))
10313 return FALSE;
10314 }
10315
10316 if (htab->elf.splt != NULL && htab->elf.splt->size != 0)
10317 {
10318 if (!add_dynamic_entry (DT_PLTGOT, 0)
10319 || !add_dynamic_entry (DT_PLTRELSZ, 0)
10320 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
10321 || !add_dynamic_entry (DT_JMPREL, 0)
10322 || !add_dynamic_entry (DT_PPC64_GLINK, 0))
10323 return FALSE;
10324 }
10325
10326 if (NO_OPD_RELOCS && abiversion (output_bfd) <= 1)
10327 {
10328 if (!add_dynamic_entry (DT_PPC64_OPD, 0)
10329 || !add_dynamic_entry (DT_PPC64_OPDSZ, 0))
10330 return FALSE;
10331 }
10332
10333 tls_opt = (htab->params->tls_get_addr_opt
10334 && htab->tls_get_addr_fd != NULL
10335 && htab->tls_get_addr_fd->elf.plt.plist != NULL);
10336 if (tls_opt || !htab->opd_abi)
10337 {
10338 if (!add_dynamic_entry (DT_PPC64_OPT, tls_opt ? PPC64_OPT_TLS : 0))
10339 return FALSE;
10340 }
10341
10342 if (relocs)
10343 {
10344 if (!add_dynamic_entry (DT_RELA, 0)
10345 || !add_dynamic_entry (DT_RELASZ, 0)
10346 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
10347 return FALSE;
10348
10349 /* If any dynamic relocs apply to a read-only section,
10350 then we need a DT_TEXTREL entry. */
10351 if ((info->flags & DF_TEXTREL) == 0)
10352 elf_link_hash_traverse (&htab->elf, maybe_set_textrel, info);
10353
10354 if ((info->flags & DF_TEXTREL) != 0)
10355 {
10356 if (!add_dynamic_entry (DT_TEXTREL, 0))
10357 return FALSE;
10358 }
10359 }
10360 }
10361 #undef add_dynamic_entry
10362
10363 return TRUE;
10364 }
10365
10366 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
10367
10368 static bfd_boolean
10369 ppc64_elf_hash_symbol (struct elf_link_hash_entry *h)
10370 {
10371 if (h->plt.plist != NULL
10372 && !h->def_regular
10373 && !h->pointer_equality_needed)
10374 return FALSE;
10375
10376 return _bfd_elf_hash_symbol (h);
10377 }
10378
10379 /* Determine the type of stub needed, if any, for a call. */
10380
10381 static inline enum ppc_stub_type
10382 ppc_type_of_stub (asection *input_sec,
10383 const Elf_Internal_Rela *rel,
10384 struct ppc_link_hash_entry **hash,
10385 struct plt_entry **plt_ent,
10386 bfd_vma destination,
10387 unsigned long local_off)
10388 {
10389 struct ppc_link_hash_entry *h = *hash;
10390 bfd_vma location;
10391 bfd_vma branch_offset;
10392 bfd_vma max_branch_offset;
10393 enum elf_ppc64_reloc_type r_type;
10394
10395 if (h != NULL)
10396 {
10397 struct plt_entry *ent;
10398 struct ppc_link_hash_entry *fdh = h;
10399 if (h->oh != NULL
10400 && h->oh->is_func_descriptor)
10401 {
10402 fdh = ppc_follow_link (h->oh);
10403 *hash = fdh;
10404 }
10405
10406 for (ent = fdh->elf.plt.plist; ent != NULL; ent = ent->next)
10407 if (ent->addend == rel->r_addend
10408 && ent->plt.offset != (bfd_vma) -1)
10409 {
10410 *plt_ent = ent;
10411 return ppc_stub_plt_call;
10412 }
10413
10414 /* Here, we know we don't have a plt entry. If we don't have a
10415 either a defined function descriptor or a defined entry symbol
10416 in a regular object file, then it is pointless trying to make
10417 any other type of stub. */
10418 if (!is_static_defined (&fdh->elf)
10419 && !is_static_defined (&h->elf))
10420 return ppc_stub_none;
10421 }
10422 else if (elf_local_got_ents (input_sec->owner) != NULL)
10423 {
10424 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (input_sec->owner);
10425 struct plt_entry **local_plt = (struct plt_entry **)
10426 elf_local_got_ents (input_sec->owner) + symtab_hdr->sh_info;
10427 unsigned long r_symndx = ELF64_R_SYM (rel->r_info);
10428
10429 if (local_plt[r_symndx] != NULL)
10430 {
10431 struct plt_entry *ent;
10432
10433 for (ent = local_plt[r_symndx]; ent != NULL; ent = ent->next)
10434 if (ent->addend == rel->r_addend
10435 && ent->plt.offset != (bfd_vma) -1)
10436 {
10437 *plt_ent = ent;
10438 return ppc_stub_plt_call;
10439 }
10440 }
10441 }
10442
10443 /* Determine where the call point is. */
10444 location = (input_sec->output_offset
10445 + input_sec->output_section->vma
10446 + rel->r_offset);
10447
10448 branch_offset = destination - location;
10449 r_type = ELF64_R_TYPE (rel->r_info);
10450
10451 /* Determine if a long branch stub is needed. */
10452 max_branch_offset = 1 << 25;
10453 if (r_type != R_PPC64_REL24)
10454 max_branch_offset = 1 << 15;
10455
10456 if (branch_offset + max_branch_offset >= 2 * max_branch_offset - local_off)
10457 /* We need a stub. Figure out whether a long_branch or plt_branch
10458 is needed later. */
10459 return ppc_stub_long_branch;
10460
10461 return ppc_stub_none;
10462 }
10463
10464 /* With power7 weakly ordered memory model, it is possible for ld.so
10465 to update a plt entry in one thread and have another thread see a
10466 stale zero toc entry. To avoid this we need some sort of acquire
10467 barrier in the call stub. One solution is to make the load of the
10468 toc word seem to appear to depend on the load of the function entry
10469 word. Another solution is to test for r2 being zero, and branch to
10470 the appropriate glink entry if so.
10471
10472 . fake dep barrier compare
10473 . ld 12,xxx(2) ld 12,xxx(2)
10474 . mtctr 12 mtctr 12
10475 . xor 11,12,12 ld 2,xxx+8(2)
10476 . add 2,2,11 cmpldi 2,0
10477 . ld 2,xxx+8(2) bnectr+
10478 . bctr b <glink_entry>
10479
10480 The solution involving the compare turns out to be faster, so
10481 that's what we use unless the branch won't reach. */
10482
10483 #define ALWAYS_USE_FAKE_DEP 0
10484 #define ALWAYS_EMIT_R2SAVE 0
10485
10486 #define PPC_LO(v) ((v) & 0xffff)
10487 #define PPC_HI(v) (((v) >> 16) & 0xffff)
10488 #define PPC_HA(v) PPC_HI ((v) + 0x8000)
10489
10490 static inline unsigned int
10491 plt_stub_size (struct ppc_link_hash_table *htab,
10492 struct ppc_stub_hash_entry *stub_entry,
10493 bfd_vma off)
10494 {
10495 unsigned size = 12;
10496
10497 if (ALWAYS_EMIT_R2SAVE
10498 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10499 size += 4;
10500 if (PPC_HA (off) != 0)
10501 size += 4;
10502 if (htab->opd_abi)
10503 {
10504 size += 4;
10505 if (htab->params->plt_static_chain)
10506 size += 4;
10507 if (htab->params->plt_thread_safe
10508 && htab->elf.dynamic_sections_created
10509 && stub_entry->h != NULL
10510 && stub_entry->h->elf.dynindx != -1)
10511 size += 8;
10512 if (PPC_HA (off + 8 + 8 * htab->params->plt_static_chain) != PPC_HA (off))
10513 size += 4;
10514 }
10515 if (stub_entry->h != NULL
10516 && (stub_entry->h == htab->tls_get_addr_fd
10517 || stub_entry->h == htab->tls_get_addr)
10518 && htab->params->tls_get_addr_opt)
10519 size += 13 * 4;
10520 return size;
10521 }
10522
10523 /* If this stub would cross fewer 2**plt_stub_align boundaries if we align,
10524 then return the padding needed to do so. */
10525 static inline unsigned int
10526 plt_stub_pad (struct ppc_link_hash_table *htab,
10527 struct ppc_stub_hash_entry *stub_entry,
10528 bfd_vma plt_off)
10529 {
10530 int stub_align = 1 << htab->params->plt_stub_align;
10531 unsigned stub_size = plt_stub_size (htab, stub_entry, plt_off);
10532 bfd_vma stub_off = stub_entry->group->stub_sec->size;
10533
10534 if (((stub_off + stub_size - 1) & -stub_align) - (stub_off & -stub_align)
10535 > ((stub_size - 1) & -stub_align))
10536 return stub_align - (stub_off & (stub_align - 1));
10537 return 0;
10538 }
10539
10540 /* Build a .plt call stub. */
10541
10542 static inline bfd_byte *
10543 build_plt_stub (struct ppc_link_hash_table *htab,
10544 struct ppc_stub_hash_entry *stub_entry,
10545 bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
10546 {
10547 bfd *obfd = htab->params->stub_bfd;
10548 bfd_boolean plt_load_toc = htab->opd_abi;
10549 bfd_boolean plt_static_chain = htab->params->plt_static_chain;
10550 bfd_boolean plt_thread_safe = (htab->params->plt_thread_safe
10551 && htab->elf.dynamic_sections_created
10552 && stub_entry->h != NULL
10553 && stub_entry->h->elf.dynindx != -1);
10554 bfd_boolean use_fake_dep = plt_thread_safe;
10555 bfd_vma cmp_branch_off = 0;
10556
10557 if (!ALWAYS_USE_FAKE_DEP
10558 && plt_load_toc
10559 && plt_thread_safe
10560 && !((stub_entry->h == htab->tls_get_addr_fd
10561 || stub_entry->h == htab->tls_get_addr)
10562 && htab->params->tls_get_addr_opt))
10563 {
10564 bfd_vma pltoff = stub_entry->plt_ent->plt.offset & ~1;
10565 bfd_vma pltindex = ((pltoff - PLT_INITIAL_ENTRY_SIZE (htab))
10566 / PLT_ENTRY_SIZE (htab));
10567 bfd_vma glinkoff = GLINK_CALL_STUB_SIZE + pltindex * 8;
10568 bfd_vma to, from;
10569
10570 if (pltindex > 32768)
10571 glinkoff += (pltindex - 32768) * 4;
10572 to = (glinkoff
10573 + htab->glink->output_offset
10574 + htab->glink->output_section->vma);
10575 from = (p - stub_entry->group->stub_sec->contents
10576 + 4 * (ALWAYS_EMIT_R2SAVE
10577 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10578 + 4 * (PPC_HA (offset) != 0)
10579 + 4 * (PPC_HA (offset + 8 + 8 * plt_static_chain)
10580 != PPC_HA (offset))
10581 + 4 * (plt_static_chain != 0)
10582 + 20
10583 + stub_entry->group->stub_sec->output_offset
10584 + stub_entry->group->stub_sec->output_section->vma);
10585 cmp_branch_off = to - from;
10586 use_fake_dep = cmp_branch_off + (1 << 25) >= (1 << 26);
10587 }
10588
10589 if (PPC_HA (offset) != 0)
10590 {
10591 if (r != NULL)
10592 {
10593 if (ALWAYS_EMIT_R2SAVE
10594 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10595 r[0].r_offset += 4;
10596 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
10597 r[1].r_offset = r[0].r_offset + 4;
10598 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10599 r[1].r_addend = r[0].r_addend;
10600 if (plt_load_toc)
10601 {
10602 if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10603 {
10604 r[2].r_offset = r[1].r_offset + 4;
10605 r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO);
10606 r[2].r_addend = r[0].r_addend;
10607 }
10608 else
10609 {
10610 r[2].r_offset = r[1].r_offset + 8 + 8 * use_fake_dep;
10611 r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10612 r[2].r_addend = r[0].r_addend + 8;
10613 if (plt_static_chain)
10614 {
10615 r[3].r_offset = r[2].r_offset + 4;
10616 r[3].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10617 r[3].r_addend = r[0].r_addend + 16;
10618 }
10619 }
10620 }
10621 }
10622 if (ALWAYS_EMIT_R2SAVE
10623 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10624 bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p), p += 4;
10625 if (plt_load_toc)
10626 {
10627 bfd_put_32 (obfd, ADDIS_R11_R2 | PPC_HA (offset), p), p += 4;
10628 bfd_put_32 (obfd, LD_R12_0R11 | PPC_LO (offset), p), p += 4;
10629 }
10630 else
10631 {
10632 bfd_put_32 (obfd, ADDIS_R12_R2 | PPC_HA (offset), p), p += 4;
10633 bfd_put_32 (obfd, LD_R12_0R12 | PPC_LO (offset), p), p += 4;
10634 }
10635 if (plt_load_toc
10636 && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10637 {
10638 bfd_put_32 (obfd, ADDI_R11_R11 | PPC_LO (offset), p), p += 4;
10639 offset = 0;
10640 }
10641 bfd_put_32 (obfd, MTCTR_R12, p), p += 4;
10642 if (plt_load_toc)
10643 {
10644 if (use_fake_dep)
10645 {
10646 bfd_put_32 (obfd, XOR_R2_R12_R12, p), p += 4;
10647 bfd_put_32 (obfd, ADD_R11_R11_R2, p), p += 4;
10648 }
10649 bfd_put_32 (obfd, LD_R2_0R11 | PPC_LO (offset + 8), p), p += 4;
10650 if (plt_static_chain)
10651 bfd_put_32 (obfd, LD_R11_0R11 | PPC_LO (offset + 16), p), p += 4;
10652 }
10653 }
10654 else
10655 {
10656 if (r != NULL)
10657 {
10658 if (ALWAYS_EMIT_R2SAVE
10659 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10660 r[0].r_offset += 4;
10661 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10662 if (plt_load_toc)
10663 {
10664 if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10665 {
10666 r[1].r_offset = r[0].r_offset + 4;
10667 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16);
10668 r[1].r_addend = r[0].r_addend;
10669 }
10670 else
10671 {
10672 r[1].r_offset = r[0].r_offset + 8 + 8 * use_fake_dep;
10673 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10674 r[1].r_addend = r[0].r_addend + 8 + 8 * plt_static_chain;
10675 if (plt_static_chain)
10676 {
10677 r[2].r_offset = r[1].r_offset + 4;
10678 r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10679 r[2].r_addend = r[0].r_addend + 8;
10680 }
10681 }
10682 }
10683 }
10684 if (ALWAYS_EMIT_R2SAVE
10685 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10686 bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p), p += 4;
10687 bfd_put_32 (obfd, LD_R12_0R2 | PPC_LO (offset), p), p += 4;
10688 if (plt_load_toc
10689 && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10690 {
10691 bfd_put_32 (obfd, ADDI_R2_R2 | PPC_LO (offset), p), p += 4;
10692 offset = 0;
10693 }
10694 bfd_put_32 (obfd, MTCTR_R12, p), p += 4;
10695 if (plt_load_toc)
10696 {
10697 if (use_fake_dep)
10698 {
10699 bfd_put_32 (obfd, XOR_R11_R12_R12, p), p += 4;
10700 bfd_put_32 (obfd, ADD_R2_R2_R11, p), p += 4;
10701 }
10702 if (plt_static_chain)
10703 bfd_put_32 (obfd, LD_R11_0R2 | PPC_LO (offset + 16), p), p += 4;
10704 bfd_put_32 (obfd, LD_R2_0R2 | PPC_LO (offset + 8), p), p += 4;
10705 }
10706 }
10707 if (plt_load_toc && plt_thread_safe && !use_fake_dep)
10708 {
10709 bfd_put_32 (obfd, CMPLDI_R2_0, p), p += 4;
10710 bfd_put_32 (obfd, BNECTR_P4, p), p += 4;
10711 bfd_put_32 (obfd, B_DOT | (cmp_branch_off & 0x3fffffc), p), p += 4;
10712 }
10713 else
10714 bfd_put_32 (obfd, BCTR, p), p += 4;
10715 return p;
10716 }
10717
10718 /* Build a special .plt call stub for __tls_get_addr. */
10719
10720 #define LD_R11_0R3 0xe9630000
10721 #define LD_R12_0R3 0xe9830000
10722 #define MR_R0_R3 0x7c601b78
10723 #define CMPDI_R11_0 0x2c2b0000
10724 #define ADD_R3_R12_R13 0x7c6c6a14
10725 #define BEQLR 0x4d820020
10726 #define MR_R3_R0 0x7c030378
10727 #define STD_R11_0R1 0xf9610000
10728 #define BCTRL 0x4e800421
10729 #define LD_R11_0R1 0xe9610000
10730 #define MTLR_R11 0x7d6803a6
10731
10732 static inline bfd_byte *
10733 build_tls_get_addr_stub (struct ppc_link_hash_table *htab,
10734 struct ppc_stub_hash_entry *stub_entry,
10735 bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
10736 {
10737 bfd *obfd = htab->params->stub_bfd;
10738
10739 bfd_put_32 (obfd, LD_R11_0R3 + 0, p), p += 4;
10740 bfd_put_32 (obfd, LD_R12_0R3 + 8, p), p += 4;
10741 bfd_put_32 (obfd, MR_R0_R3, p), p += 4;
10742 bfd_put_32 (obfd, CMPDI_R11_0, p), p += 4;
10743 bfd_put_32 (obfd, ADD_R3_R12_R13, p), p += 4;
10744 bfd_put_32 (obfd, BEQLR, p), p += 4;
10745 bfd_put_32 (obfd, MR_R3_R0, p), p += 4;
10746 bfd_put_32 (obfd, MFLR_R11, p), p += 4;
10747 bfd_put_32 (obfd, STD_R11_0R1 + STK_LINKER (htab), p), p += 4;
10748
10749 if (r != NULL)
10750 r[0].r_offset += 9 * 4;
10751 p = build_plt_stub (htab, stub_entry, p, offset, r);
10752 bfd_put_32 (obfd, BCTRL, p - 4);
10753
10754 bfd_put_32 (obfd, LD_R2_0R1 + STK_TOC (htab), p), p += 4;
10755 bfd_put_32 (obfd, LD_R11_0R1 + STK_LINKER (htab), p), p += 4;
10756 bfd_put_32 (obfd, MTLR_R11, p), p += 4;
10757 bfd_put_32 (obfd, BLR, p), p += 4;
10758
10759 return p;
10760 }
10761
10762 static Elf_Internal_Rela *
10763 get_relocs (asection *sec, int count)
10764 {
10765 Elf_Internal_Rela *relocs;
10766 struct bfd_elf_section_data *elfsec_data;
10767
10768 elfsec_data = elf_section_data (sec);
10769 relocs = elfsec_data->relocs;
10770 if (relocs == NULL)
10771 {
10772 bfd_size_type relsize;
10773 relsize = sec->reloc_count * sizeof (*relocs);
10774 relocs = bfd_alloc (sec->owner, relsize);
10775 if (relocs == NULL)
10776 return NULL;
10777 elfsec_data->relocs = relocs;
10778 elfsec_data->rela.hdr = bfd_zalloc (sec->owner,
10779 sizeof (Elf_Internal_Shdr));
10780 if (elfsec_data->rela.hdr == NULL)
10781 return NULL;
10782 elfsec_data->rela.hdr->sh_size = (sec->reloc_count
10783 * sizeof (Elf64_External_Rela));
10784 elfsec_data->rela.hdr->sh_entsize = sizeof (Elf64_External_Rela);
10785 sec->reloc_count = 0;
10786 }
10787 relocs += sec->reloc_count;
10788 sec->reloc_count += count;
10789 return relocs;
10790 }
10791
10792 static bfd_vma
10793 get_r2off (struct bfd_link_info *info,
10794 struct ppc_stub_hash_entry *stub_entry)
10795 {
10796 struct ppc_link_hash_table *htab = ppc_hash_table (info);
10797 bfd_vma r2off = htab->sec_info[stub_entry->target_section->id].toc_off;
10798
10799 if (r2off == 0)
10800 {
10801 /* Support linking -R objects. Get the toc pointer from the
10802 opd entry. */
10803 char buf[8];
10804 if (!htab->opd_abi)
10805 return r2off;
10806 asection *opd = stub_entry->h->elf.root.u.def.section;
10807 bfd_vma opd_off = stub_entry->h->elf.root.u.def.value;
10808
10809 if (strcmp (opd->name, ".opd") != 0
10810 || opd->reloc_count != 0)
10811 {
10812 info->callbacks->einfo (_("%P: cannot find opd entry toc for `%T'\n"),
10813 stub_entry->h->elf.root.root.string);
10814 bfd_set_error (bfd_error_bad_value);
10815 return (bfd_vma) -1;
10816 }
10817 if (!bfd_get_section_contents (opd->owner, opd, buf, opd_off + 8, 8))
10818 return (bfd_vma) -1;
10819 r2off = bfd_get_64 (opd->owner, buf);
10820 r2off -= elf_gp (info->output_bfd);
10821 }
10822 r2off -= htab->sec_info[stub_entry->group->link_sec->id].toc_off;
10823 return r2off;
10824 }
10825
10826 static bfd_boolean
10827 ppc_build_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
10828 {
10829 struct ppc_stub_hash_entry *stub_entry;
10830 struct ppc_branch_hash_entry *br_entry;
10831 struct bfd_link_info *info;
10832 struct ppc_link_hash_table *htab;
10833 bfd_byte *loc;
10834 bfd_byte *p;
10835 bfd_vma dest, off;
10836 int size;
10837 Elf_Internal_Rela *r;
10838 asection *plt;
10839
10840 /* Massage our args to the form they really have. */
10841 stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
10842 info = in_arg;
10843
10844 htab = ppc_hash_table (info);
10845 if (htab == NULL)
10846 return FALSE;
10847
10848 /* Make a note of the offset within the stubs for this entry. */
10849 stub_entry->stub_offset = stub_entry->group->stub_sec->size;
10850 loc = stub_entry->group->stub_sec->contents + stub_entry->stub_offset;
10851
10852 htab->stub_count[stub_entry->stub_type - 1] += 1;
10853 switch (stub_entry->stub_type)
10854 {
10855 case ppc_stub_long_branch:
10856 case ppc_stub_long_branch_r2off:
10857 /* Branches are relative. This is where we are going to. */
10858 dest = (stub_entry->target_value
10859 + stub_entry->target_section->output_offset
10860 + stub_entry->target_section->output_section->vma);
10861 dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
10862 off = dest;
10863
10864 /* And this is where we are coming from. */
10865 off -= (stub_entry->stub_offset
10866 + stub_entry->group->stub_sec->output_offset
10867 + stub_entry->group->stub_sec->output_section->vma);
10868
10869 size = 4;
10870 if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
10871 {
10872 bfd_vma r2off = get_r2off (info, stub_entry);
10873
10874 if (r2off == (bfd_vma) -1)
10875 {
10876 htab->stub_error = TRUE;
10877 return FALSE;
10878 }
10879 bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), loc);
10880 loc += 4;
10881 size = 8;
10882 if (PPC_HA (r2off) != 0)
10883 {
10884 bfd_put_32 (htab->params->stub_bfd,
10885 ADDIS_R2_R2 | PPC_HA (r2off), loc);
10886 loc += 4;
10887 size += 4;
10888 }
10889 if (PPC_LO (r2off) != 0)
10890 {
10891 bfd_put_32 (htab->params->stub_bfd,
10892 ADDI_R2_R2 | PPC_LO (r2off), loc);
10893 loc += 4;
10894 size += 4;
10895 }
10896 off -= size - 4;
10897 }
10898 bfd_put_32 (htab->params->stub_bfd, B_DOT | (off & 0x3fffffc), loc);
10899
10900 if (off + (1 << 25) >= (bfd_vma) (1 << 26))
10901 {
10902 info->callbacks->einfo
10903 (_("%P: long branch stub `%s' offset overflow\n"),
10904 stub_entry->root.string);
10905 htab->stub_error = TRUE;
10906 return FALSE;
10907 }
10908
10909 if (info->emitrelocations)
10910 {
10911 r = get_relocs (stub_entry->group->stub_sec, 1);
10912 if (r == NULL)
10913 return FALSE;
10914 r->r_offset = loc - stub_entry->group->stub_sec->contents;
10915 r->r_info = ELF64_R_INFO (0, R_PPC64_REL24);
10916 r->r_addend = dest;
10917 if (stub_entry->h != NULL)
10918 {
10919 struct elf_link_hash_entry **hashes;
10920 unsigned long symndx;
10921 struct ppc_link_hash_entry *h;
10922
10923 hashes = elf_sym_hashes (htab->params->stub_bfd);
10924 if (hashes == NULL)
10925 {
10926 bfd_size_type hsize;
10927
10928 hsize = (htab->stub_globals + 1) * sizeof (*hashes);
10929 hashes = bfd_zalloc (htab->params->stub_bfd, hsize);
10930 if (hashes == NULL)
10931 return FALSE;
10932 elf_sym_hashes (htab->params->stub_bfd) = hashes;
10933 htab->stub_globals = 1;
10934 }
10935 symndx = htab->stub_globals++;
10936 h = stub_entry->h;
10937 hashes[symndx] = &h->elf;
10938 r->r_info = ELF64_R_INFO (symndx, R_PPC64_REL24);
10939 if (h->oh != NULL && h->oh->is_func)
10940 h = ppc_follow_link (h->oh);
10941 if (h->elf.root.u.def.section != stub_entry->target_section)
10942 /* H is an opd symbol. The addend must be zero. */
10943 r->r_addend = 0;
10944 else
10945 {
10946 off = (h->elf.root.u.def.value
10947 + h->elf.root.u.def.section->output_offset
10948 + h->elf.root.u.def.section->output_section->vma);
10949 r->r_addend -= off;
10950 }
10951 }
10952 }
10953 break;
10954
10955 case ppc_stub_plt_branch:
10956 case ppc_stub_plt_branch_r2off:
10957 br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
10958 stub_entry->root.string + 9,
10959 FALSE, FALSE);
10960 if (br_entry == NULL)
10961 {
10962 info->callbacks->einfo (_("%P: can't find branch stub `%s'\n"),
10963 stub_entry->root.string);
10964 htab->stub_error = TRUE;
10965 return FALSE;
10966 }
10967
10968 dest = (stub_entry->target_value
10969 + stub_entry->target_section->output_offset
10970 + stub_entry->target_section->output_section->vma);
10971 if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
10972 dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
10973
10974 bfd_put_64 (htab->brlt->owner, dest,
10975 htab->brlt->contents + br_entry->offset);
10976
10977 if (br_entry->iter == htab->stub_iteration)
10978 {
10979 br_entry->iter = 0;
10980
10981 if (htab->relbrlt != NULL)
10982 {
10983 /* Create a reloc for the branch lookup table entry. */
10984 Elf_Internal_Rela rela;
10985 bfd_byte *rl;
10986
10987 rela.r_offset = (br_entry->offset
10988 + htab->brlt->output_offset
10989 + htab->brlt->output_section->vma);
10990 rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
10991 rela.r_addend = dest;
10992
10993 rl = htab->relbrlt->contents;
10994 rl += (htab->relbrlt->reloc_count++
10995 * sizeof (Elf64_External_Rela));
10996 bfd_elf64_swap_reloca_out (htab->relbrlt->owner, &rela, rl);
10997 }
10998 else if (info->emitrelocations)
10999 {
11000 r = get_relocs (htab->brlt, 1);
11001 if (r == NULL)
11002 return FALSE;
11003 /* brlt, being SEC_LINKER_CREATED does not go through the
11004 normal reloc processing. Symbols and offsets are not
11005 translated from input file to output file form, so
11006 set up the offset per the output file. */
11007 r->r_offset = (br_entry->offset
11008 + htab->brlt->output_offset
11009 + htab->brlt->output_section->vma);
11010 r->r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
11011 r->r_addend = dest;
11012 }
11013 }
11014
11015 dest = (br_entry->offset
11016 + htab->brlt->output_offset
11017 + htab->brlt->output_section->vma);
11018
11019 off = (dest
11020 - elf_gp (htab->brlt->output_section->owner)
11021 - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11022
11023 if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
11024 {
11025 info->callbacks->einfo
11026 (_("%P: linkage table error against `%T'\n"),
11027 stub_entry->root.string);
11028 bfd_set_error (bfd_error_bad_value);
11029 htab->stub_error = TRUE;
11030 return FALSE;
11031 }
11032
11033 if (info->emitrelocations)
11034 {
11035 r = get_relocs (stub_entry->group->stub_sec, 1 + (PPC_HA (off) != 0));
11036 if (r == NULL)
11037 return FALSE;
11038 r[0].r_offset = loc - stub_entry->group->stub_sec->contents;
11039 if (bfd_big_endian (info->output_bfd))
11040 r[0].r_offset += 2;
11041 if (stub_entry->stub_type == ppc_stub_plt_branch_r2off)
11042 r[0].r_offset += 4;
11043 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
11044 r[0].r_addend = dest;
11045 if (PPC_HA (off) != 0)
11046 {
11047 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
11048 r[1].r_offset = r[0].r_offset + 4;
11049 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
11050 r[1].r_addend = r[0].r_addend;
11051 }
11052 }
11053
11054 if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
11055 {
11056 if (PPC_HA (off) != 0)
11057 {
11058 size = 16;
11059 bfd_put_32 (htab->params->stub_bfd,
11060 ADDIS_R12_R2 | PPC_HA (off), loc);
11061 loc += 4;
11062 bfd_put_32 (htab->params->stub_bfd,
11063 LD_R12_0R12 | PPC_LO (off), loc);
11064 }
11065 else
11066 {
11067 size = 12;
11068 bfd_put_32 (htab->params->stub_bfd,
11069 LD_R12_0R2 | PPC_LO (off), loc);
11070 }
11071 }
11072 else
11073 {
11074 bfd_vma r2off = get_r2off (info, stub_entry);
11075
11076 if (r2off == (bfd_vma) -1)
11077 {
11078 htab->stub_error = TRUE;
11079 return FALSE;
11080 }
11081
11082 bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), loc);
11083 loc += 4;
11084 size = 16;
11085 if (PPC_HA (off) != 0)
11086 {
11087 size += 4;
11088 bfd_put_32 (htab->params->stub_bfd,
11089 ADDIS_R12_R2 | PPC_HA (off), loc);
11090 loc += 4;
11091 bfd_put_32 (htab->params->stub_bfd,
11092 LD_R12_0R12 | PPC_LO (off), loc);
11093 }
11094 else
11095 bfd_put_32 (htab->params->stub_bfd, LD_R12_0R2 | PPC_LO (off), loc);
11096
11097 if (PPC_HA (r2off) != 0)
11098 {
11099 size += 4;
11100 loc += 4;
11101 bfd_put_32 (htab->params->stub_bfd,
11102 ADDIS_R2_R2 | PPC_HA (r2off), loc);
11103 }
11104 if (PPC_LO (r2off) != 0)
11105 {
11106 size += 4;
11107 loc += 4;
11108 bfd_put_32 (htab->params->stub_bfd,
11109 ADDI_R2_R2 | PPC_LO (r2off), loc);
11110 }
11111 }
11112 loc += 4;
11113 bfd_put_32 (htab->params->stub_bfd, MTCTR_R12, loc);
11114 loc += 4;
11115 bfd_put_32 (htab->params->stub_bfd, BCTR, loc);
11116 break;
11117
11118 case ppc_stub_plt_call:
11119 case ppc_stub_plt_call_r2save:
11120 if (stub_entry->h != NULL
11121 && stub_entry->h->is_func_descriptor
11122 && stub_entry->h->oh != NULL)
11123 {
11124 struct ppc_link_hash_entry *fh = ppc_follow_link (stub_entry->h->oh);
11125
11126 /* If the old-ABI "dot-symbol" is undefined make it weak so
11127 we don't get a link error from RELOC_FOR_GLOBAL_SYMBOL. */
11128 if (fh->elf.root.type == bfd_link_hash_undefined
11129 && (stub_entry->h->elf.root.type == bfd_link_hash_defined
11130 || stub_entry->h->elf.root.type == bfd_link_hash_defweak))
11131 fh->elf.root.type = bfd_link_hash_undefweak;
11132 }
11133
11134 /* Now build the stub. */
11135 dest = stub_entry->plt_ent->plt.offset & ~1;
11136 if (dest >= (bfd_vma) -2)
11137 abort ();
11138
11139 plt = htab->elf.splt;
11140 if (!htab->elf.dynamic_sections_created
11141 || stub_entry->h == NULL
11142 || stub_entry->h->elf.dynindx == -1)
11143 plt = htab->elf.iplt;
11144
11145 dest += plt->output_offset + plt->output_section->vma;
11146
11147 if (stub_entry->h == NULL
11148 && (stub_entry->plt_ent->plt.offset & 1) == 0)
11149 {
11150 Elf_Internal_Rela rela;
11151 bfd_byte *rl;
11152
11153 rela.r_offset = dest;
11154 if (htab->opd_abi)
11155 rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
11156 else
11157 rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
11158 rela.r_addend = (stub_entry->target_value
11159 + stub_entry->target_section->output_offset
11160 + stub_entry->target_section->output_section->vma);
11161
11162 rl = (htab->elf.irelplt->contents
11163 + (htab->elf.irelplt->reloc_count++
11164 * sizeof (Elf64_External_Rela)));
11165 bfd_elf64_swap_reloca_out (info->output_bfd, &rela, rl);
11166 stub_entry->plt_ent->plt.offset |= 1;
11167 }
11168
11169 off = (dest
11170 - elf_gp (plt->output_section->owner)
11171 - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11172
11173 if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
11174 {
11175 info->callbacks->einfo
11176 /* xgettext:c-format */
11177 (_("%P: linkage table error against `%T'\n"),
11178 stub_entry->h != NULL
11179 ? stub_entry->h->elf.root.root.string
11180 : "<local sym>");
11181 bfd_set_error (bfd_error_bad_value);
11182 htab->stub_error = TRUE;
11183 return FALSE;
11184 }
11185
11186 if (htab->params->plt_stub_align != 0)
11187 {
11188 unsigned pad = plt_stub_pad (htab, stub_entry, off);
11189
11190 stub_entry->group->stub_sec->size += pad;
11191 stub_entry->stub_offset = stub_entry->group->stub_sec->size;
11192 loc += pad;
11193 }
11194
11195 r = NULL;
11196 if (info->emitrelocations)
11197 {
11198 r = get_relocs (stub_entry->group->stub_sec,
11199 ((PPC_HA (off) != 0)
11200 + (htab->opd_abi
11201 ? 2 + (htab->params->plt_static_chain
11202 && PPC_HA (off + 16) == PPC_HA (off))
11203 : 1)));
11204 if (r == NULL)
11205 return FALSE;
11206 r[0].r_offset = loc - stub_entry->group->stub_sec->contents;
11207 if (bfd_big_endian (info->output_bfd))
11208 r[0].r_offset += 2;
11209 r[0].r_addend = dest;
11210 }
11211 if (stub_entry->h != NULL
11212 && (stub_entry->h == htab->tls_get_addr_fd
11213 || stub_entry->h == htab->tls_get_addr)
11214 && htab->params->tls_get_addr_opt)
11215 p = build_tls_get_addr_stub (htab, stub_entry, loc, off, r);
11216 else
11217 p = build_plt_stub (htab, stub_entry, loc, off, r);
11218 size = p - loc;
11219 break;
11220
11221 case ppc_stub_save_res:
11222 return TRUE;
11223
11224 default:
11225 BFD_FAIL ();
11226 return FALSE;
11227 }
11228
11229 stub_entry->group->stub_sec->size += size;
11230
11231 if (htab->params->emit_stub_syms)
11232 {
11233 struct elf_link_hash_entry *h;
11234 size_t len1, len2;
11235 char *name;
11236 const char *const stub_str[] = { "long_branch",
11237 "long_branch_r2off",
11238 "plt_branch",
11239 "plt_branch_r2off",
11240 "plt_call",
11241 "plt_call" };
11242
11243 len1 = strlen (stub_str[stub_entry->stub_type - 1]);
11244 len2 = strlen (stub_entry->root.string);
11245 name = bfd_malloc (len1 + len2 + 2);
11246 if (name == NULL)
11247 return FALSE;
11248 memcpy (name, stub_entry->root.string, 9);
11249 memcpy (name + 9, stub_str[stub_entry->stub_type - 1], len1);
11250 memcpy (name + len1 + 9, stub_entry->root.string + 8, len2 - 8 + 1);
11251 h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
11252 if (h == NULL)
11253 return FALSE;
11254 if (h->root.type == bfd_link_hash_new)
11255 {
11256 h->root.type = bfd_link_hash_defined;
11257 h->root.u.def.section = stub_entry->group->stub_sec;
11258 h->root.u.def.value = stub_entry->stub_offset;
11259 h->ref_regular = 1;
11260 h->def_regular = 1;
11261 h->ref_regular_nonweak = 1;
11262 h->forced_local = 1;
11263 h->non_elf = 0;
11264 h->root.linker_def = 1;
11265 }
11266 }
11267
11268 return TRUE;
11269 }
11270
11271 /* As above, but don't actually build the stub. Just bump offset so
11272 we know stub section sizes, and select plt_branch stubs where
11273 long_branch stubs won't do. */
11274
11275 static bfd_boolean
11276 ppc_size_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
11277 {
11278 struct ppc_stub_hash_entry *stub_entry;
11279 struct bfd_link_info *info;
11280 struct ppc_link_hash_table *htab;
11281 bfd_vma off;
11282 int size;
11283
11284 /* Massage our args to the form they really have. */
11285 stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
11286 info = in_arg;
11287
11288 htab = ppc_hash_table (info);
11289 if (htab == NULL)
11290 return FALSE;
11291
11292 if (stub_entry->h != NULL
11293 && stub_entry->h->save_res
11294 && stub_entry->h->elf.root.type == bfd_link_hash_defined
11295 && stub_entry->h->elf.root.u.def.section == htab->sfpr)
11296 {
11297 /* Don't make stubs to out-of-line register save/restore
11298 functions. Instead, emit copies of the functions. */
11299 stub_entry->group->needs_save_res = 1;
11300 stub_entry->stub_type = ppc_stub_save_res;
11301 return TRUE;
11302 }
11303
11304 if (stub_entry->stub_type == ppc_stub_plt_call
11305 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
11306 {
11307 asection *plt;
11308 off = stub_entry->plt_ent->plt.offset & ~(bfd_vma) 1;
11309 if (off >= (bfd_vma) -2)
11310 abort ();
11311 plt = htab->elf.splt;
11312 if (!htab->elf.dynamic_sections_created
11313 || stub_entry->h == NULL
11314 || stub_entry->h->elf.dynindx == -1)
11315 plt = htab->elf.iplt;
11316 off += (plt->output_offset
11317 + plt->output_section->vma
11318 - elf_gp (plt->output_section->owner)
11319 - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11320
11321 size = plt_stub_size (htab, stub_entry, off);
11322 if (htab->params->plt_stub_align)
11323 size += plt_stub_pad (htab, stub_entry, off);
11324 if (info->emitrelocations)
11325 {
11326 stub_entry->group->stub_sec->reloc_count
11327 += ((PPC_HA (off) != 0)
11328 + (htab->opd_abi
11329 ? 2 + (htab->params->plt_static_chain
11330 && PPC_HA (off + 16) == PPC_HA (off))
11331 : 1));
11332 stub_entry->group->stub_sec->flags |= SEC_RELOC;
11333 }
11334 }
11335 else
11336 {
11337 /* ppc_stub_long_branch or ppc_stub_plt_branch, or their r2off
11338 variants. */
11339 bfd_vma r2off = 0;
11340 bfd_vma local_off = 0;
11341
11342 off = (stub_entry->target_value
11343 + stub_entry->target_section->output_offset
11344 + stub_entry->target_section->output_section->vma);
11345 off -= (stub_entry->group->stub_sec->size
11346 + stub_entry->group->stub_sec->output_offset
11347 + stub_entry->group->stub_sec->output_section->vma);
11348
11349 /* Reset the stub type from the plt variant in case we now
11350 can reach with a shorter stub. */
11351 if (stub_entry->stub_type >= ppc_stub_plt_branch)
11352 stub_entry->stub_type += ppc_stub_long_branch - ppc_stub_plt_branch;
11353
11354 size = 4;
11355 if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
11356 {
11357 r2off = get_r2off (info, stub_entry);
11358 if (r2off == (bfd_vma) -1)
11359 {
11360 htab->stub_error = TRUE;
11361 return FALSE;
11362 }
11363 size = 8;
11364 if (PPC_HA (r2off) != 0)
11365 size += 4;
11366 if (PPC_LO (r2off) != 0)
11367 size += 4;
11368 off -= size - 4;
11369 }
11370
11371 local_off = PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
11372
11373 /* If the branch offset if too big, use a ppc_stub_plt_branch.
11374 Do the same for -R objects without function descriptors. */
11375 if (off + (1 << 25) >= (bfd_vma) (1 << 26) - local_off
11376 || (stub_entry->stub_type == ppc_stub_long_branch_r2off
11377 && r2off == 0
11378 && htab->sec_info[stub_entry->target_section->id].toc_off == 0))
11379 {
11380 struct ppc_branch_hash_entry *br_entry;
11381
11382 br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
11383 stub_entry->root.string + 9,
11384 TRUE, FALSE);
11385 if (br_entry == NULL)
11386 {
11387 info->callbacks->einfo (_("%P: can't build branch stub `%s'\n"),
11388 stub_entry->root.string);
11389 htab->stub_error = TRUE;
11390 return FALSE;
11391 }
11392
11393 if (br_entry->iter != htab->stub_iteration)
11394 {
11395 br_entry->iter = htab->stub_iteration;
11396 br_entry->offset = htab->brlt->size;
11397 htab->brlt->size += 8;
11398
11399 if (htab->relbrlt != NULL)
11400 htab->relbrlt->size += sizeof (Elf64_External_Rela);
11401 else if (info->emitrelocations)
11402 {
11403 htab->brlt->reloc_count += 1;
11404 htab->brlt->flags |= SEC_RELOC;
11405 }
11406 }
11407
11408 stub_entry->stub_type += ppc_stub_plt_branch - ppc_stub_long_branch;
11409 off = (br_entry->offset
11410 + htab->brlt->output_offset
11411 + htab->brlt->output_section->vma
11412 - elf_gp (htab->brlt->output_section->owner)
11413 - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
11414
11415 if (info->emitrelocations)
11416 {
11417 stub_entry->group->stub_sec->reloc_count
11418 += 1 + (PPC_HA (off) != 0);
11419 stub_entry->group->stub_sec->flags |= SEC_RELOC;
11420 }
11421
11422 if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
11423 {
11424 size = 12;
11425 if (PPC_HA (off) != 0)
11426 size = 16;
11427 }
11428 else
11429 {
11430 size = 16;
11431 if (PPC_HA (off) != 0)
11432 size += 4;
11433
11434 if (PPC_HA (r2off) != 0)
11435 size += 4;
11436 if (PPC_LO (r2off) != 0)
11437 size += 4;
11438 }
11439 }
11440 else if (info->emitrelocations)
11441 {
11442 stub_entry->group->stub_sec->reloc_count += 1;
11443 stub_entry->group->stub_sec->flags |= SEC_RELOC;
11444 }
11445 }
11446
11447 stub_entry->group->stub_sec->size += size;
11448 return TRUE;
11449 }
11450
11451 /* Set up various things so that we can make a list of input sections
11452 for each output section included in the link. Returns -1 on error,
11453 0 when no stubs will be needed, and 1 on success. */
11454
11455 int
11456 ppc64_elf_setup_section_lists (struct bfd_link_info *info)
11457 {
11458 unsigned int id;
11459 bfd_size_type amt;
11460 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11461
11462 if (htab == NULL)
11463 return -1;
11464
11465 htab->sec_info_arr_size = bfd_get_next_section_id ();
11466 amt = sizeof (*htab->sec_info) * (htab->sec_info_arr_size);
11467 htab->sec_info = bfd_zmalloc (amt);
11468 if (htab->sec_info == NULL)
11469 return -1;
11470
11471 /* Set toc_off for com, und, abs and ind sections. */
11472 for (id = 0; id < 3; id++)
11473 htab->sec_info[id].toc_off = TOC_BASE_OFF;
11474
11475 return 1;
11476 }
11477
11478 /* Set up for first pass at multitoc partitioning. */
11479
11480 void
11481 ppc64_elf_start_multitoc_partition (struct bfd_link_info *info)
11482 {
11483 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11484
11485 htab->toc_curr = ppc64_elf_set_toc (info, info->output_bfd);
11486 htab->toc_bfd = NULL;
11487 htab->toc_first_sec = NULL;
11488 }
11489
11490 /* The linker repeatedly calls this function for each TOC input section
11491 and linker generated GOT section. Group input bfds such that the toc
11492 within a group is less than 64k in size. */
11493
11494 bfd_boolean
11495 ppc64_elf_next_toc_section (struct bfd_link_info *info, asection *isec)
11496 {
11497 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11498 bfd_vma addr, off, limit;
11499
11500 if (htab == NULL)
11501 return FALSE;
11502
11503 if (!htab->second_toc_pass)
11504 {
11505 /* Keep track of the first .toc or .got section for this input bfd. */
11506 bfd_boolean new_bfd = htab->toc_bfd != isec->owner;
11507
11508 if (new_bfd)
11509 {
11510 htab->toc_bfd = isec->owner;
11511 htab->toc_first_sec = isec;
11512 }
11513
11514 addr = isec->output_offset + isec->output_section->vma;
11515 off = addr - htab->toc_curr;
11516 limit = 0x80008000;
11517 if (ppc64_elf_tdata (isec->owner)->has_small_toc_reloc)
11518 limit = 0x10000;
11519 if (off + isec->size > limit)
11520 {
11521 addr = (htab->toc_first_sec->output_offset
11522 + htab->toc_first_sec->output_section->vma);
11523 htab->toc_curr = addr;
11524 htab->toc_curr &= -TOC_BASE_ALIGN;
11525 }
11526
11527 /* toc_curr is the base address of this toc group. Set elf_gp
11528 for the input section to be the offset relative to the
11529 output toc base plus 0x8000. Making the input elf_gp an
11530 offset allows us to move the toc as a whole without
11531 recalculating input elf_gp. */
11532 off = htab->toc_curr - elf_gp (isec->output_section->owner);
11533 off += TOC_BASE_OFF;
11534
11535 /* Die if someone uses a linker script that doesn't keep input
11536 file .toc and .got together. */
11537 if (new_bfd
11538 && elf_gp (isec->owner) != 0
11539 && elf_gp (isec->owner) != off)
11540 return FALSE;
11541
11542 elf_gp (isec->owner) = off;
11543 return TRUE;
11544 }
11545
11546 /* During the second pass toc_first_sec points to the start of
11547 a toc group, and toc_curr is used to track the old elf_gp.
11548 We use toc_bfd to ensure we only look at each bfd once. */
11549 if (htab->toc_bfd == isec->owner)
11550 return TRUE;
11551 htab->toc_bfd = isec->owner;
11552
11553 if (htab->toc_first_sec == NULL
11554 || htab->toc_curr != elf_gp (isec->owner))
11555 {
11556 htab->toc_curr = elf_gp (isec->owner);
11557 htab->toc_first_sec = isec;
11558 }
11559 addr = (htab->toc_first_sec->output_offset
11560 + htab->toc_first_sec->output_section->vma);
11561 off = addr - elf_gp (isec->output_section->owner) + TOC_BASE_OFF;
11562 elf_gp (isec->owner) = off;
11563
11564 return TRUE;
11565 }
11566
11567 /* Called via elf_link_hash_traverse to merge GOT entries for global
11568 symbol H. */
11569
11570 static bfd_boolean
11571 merge_global_got (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
11572 {
11573 if (h->root.type == bfd_link_hash_indirect)
11574 return TRUE;
11575
11576 merge_got_entries (&h->got.glist);
11577
11578 return TRUE;
11579 }
11580
11581 /* Called via elf_link_hash_traverse to allocate GOT entries for global
11582 symbol H. */
11583
11584 static bfd_boolean
11585 reallocate_got (struct elf_link_hash_entry *h, void *inf)
11586 {
11587 struct got_entry *gent;
11588
11589 if (h->root.type == bfd_link_hash_indirect)
11590 return TRUE;
11591
11592 for (gent = h->got.glist; gent != NULL; gent = gent->next)
11593 if (!gent->is_indirect)
11594 allocate_got (h, (struct bfd_link_info *) inf, gent);
11595 return TRUE;
11596 }
11597
11598 /* Called on the first multitoc pass after the last call to
11599 ppc64_elf_next_toc_section. This function removes duplicate GOT
11600 entries. */
11601
11602 bfd_boolean
11603 ppc64_elf_layout_multitoc (struct bfd_link_info *info)
11604 {
11605 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11606 struct bfd *ibfd, *ibfd2;
11607 bfd_boolean done_something;
11608
11609 htab->multi_toc_needed = htab->toc_curr != elf_gp (info->output_bfd);
11610
11611 if (!htab->do_multi_toc)
11612 return FALSE;
11613
11614 /* Merge global sym got entries within a toc group. */
11615 elf_link_hash_traverse (&htab->elf, merge_global_got, info);
11616
11617 /* And tlsld_got. */
11618 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11619 {
11620 struct got_entry *ent, *ent2;
11621
11622 if (!is_ppc64_elf (ibfd))
11623 continue;
11624
11625 ent = ppc64_tlsld_got (ibfd);
11626 if (!ent->is_indirect
11627 && ent->got.offset != (bfd_vma) -1)
11628 {
11629 for (ibfd2 = ibfd->link.next; ibfd2 != NULL; ibfd2 = ibfd2->link.next)
11630 {
11631 if (!is_ppc64_elf (ibfd2))
11632 continue;
11633
11634 ent2 = ppc64_tlsld_got (ibfd2);
11635 if (!ent2->is_indirect
11636 && ent2->got.offset != (bfd_vma) -1
11637 && elf_gp (ibfd2) == elf_gp (ibfd))
11638 {
11639 ent2->is_indirect = TRUE;
11640 ent2->got.ent = ent;
11641 }
11642 }
11643 }
11644 }
11645
11646 /* Zap sizes of got sections. */
11647 htab->elf.irelplt->rawsize = htab->elf.irelplt->size;
11648 htab->elf.irelplt->size -= htab->got_reli_size;
11649 htab->got_reli_size = 0;
11650
11651 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11652 {
11653 asection *got, *relgot;
11654
11655 if (!is_ppc64_elf (ibfd))
11656 continue;
11657
11658 got = ppc64_elf_tdata (ibfd)->got;
11659 if (got != NULL)
11660 {
11661 got->rawsize = got->size;
11662 got->size = 0;
11663 relgot = ppc64_elf_tdata (ibfd)->relgot;
11664 relgot->rawsize = relgot->size;
11665 relgot->size = 0;
11666 }
11667 }
11668
11669 /* Now reallocate the got, local syms first. We don't need to
11670 allocate section contents again since we never increase size. */
11671 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11672 {
11673 struct got_entry **lgot_ents;
11674 struct got_entry **end_lgot_ents;
11675 struct plt_entry **local_plt;
11676 struct plt_entry **end_local_plt;
11677 unsigned char *lgot_masks;
11678 bfd_size_type locsymcount;
11679 Elf_Internal_Shdr *symtab_hdr;
11680 asection *s;
11681
11682 if (!is_ppc64_elf (ibfd))
11683 continue;
11684
11685 lgot_ents = elf_local_got_ents (ibfd);
11686 if (!lgot_ents)
11687 continue;
11688
11689 symtab_hdr = &elf_symtab_hdr (ibfd);
11690 locsymcount = symtab_hdr->sh_info;
11691 end_lgot_ents = lgot_ents + locsymcount;
11692 local_plt = (struct plt_entry **) end_lgot_ents;
11693 end_local_plt = local_plt + locsymcount;
11694 lgot_masks = (unsigned char *) end_local_plt;
11695 s = ppc64_elf_tdata (ibfd)->got;
11696 for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
11697 {
11698 struct got_entry *ent;
11699
11700 for (ent = *lgot_ents; ent != NULL; ent = ent->next)
11701 {
11702 unsigned int ent_size = 8;
11703 unsigned int rel_size = sizeof (Elf64_External_Rela);
11704
11705 ent->got.offset = s->size;
11706 if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
11707 {
11708 ent_size *= 2;
11709 rel_size *= 2;
11710 }
11711 s->size += ent_size;
11712 if ((*lgot_masks & PLT_IFUNC) != 0)
11713 {
11714 htab->elf.irelplt->size += rel_size;
11715 htab->got_reli_size += rel_size;
11716 }
11717 else if (bfd_link_pic (info))
11718 {
11719 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
11720 srel->size += rel_size;
11721 }
11722 }
11723 }
11724 }
11725
11726 elf_link_hash_traverse (&htab->elf, reallocate_got, info);
11727
11728 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11729 {
11730 struct got_entry *ent;
11731
11732 if (!is_ppc64_elf (ibfd))
11733 continue;
11734
11735 ent = ppc64_tlsld_got (ibfd);
11736 if (!ent->is_indirect
11737 && ent->got.offset != (bfd_vma) -1)
11738 {
11739 asection *s = ppc64_elf_tdata (ibfd)->got;
11740 ent->got.offset = s->size;
11741 s->size += 16;
11742 if (bfd_link_pic (info))
11743 {
11744 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
11745 srel->size += sizeof (Elf64_External_Rela);
11746 }
11747 }
11748 }
11749
11750 done_something = htab->elf.irelplt->rawsize != htab->elf.irelplt->size;
11751 if (!done_something)
11752 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
11753 {
11754 asection *got;
11755
11756 if (!is_ppc64_elf (ibfd))
11757 continue;
11758
11759 got = ppc64_elf_tdata (ibfd)->got;
11760 if (got != NULL)
11761 {
11762 done_something = got->rawsize != got->size;
11763 if (done_something)
11764 break;
11765 }
11766 }
11767
11768 if (done_something)
11769 (*htab->params->layout_sections_again) ();
11770
11771 /* Set up for second pass over toc sections to recalculate elf_gp
11772 on input sections. */
11773 htab->toc_bfd = NULL;
11774 htab->toc_first_sec = NULL;
11775 htab->second_toc_pass = TRUE;
11776 return done_something;
11777 }
11778
11779 /* Called after second pass of multitoc partitioning. */
11780
11781 void
11782 ppc64_elf_finish_multitoc_partition (struct bfd_link_info *info)
11783 {
11784 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11785
11786 /* After the second pass, toc_curr tracks the TOC offset used
11787 for code sections below in ppc64_elf_next_input_section. */
11788 htab->toc_curr = TOC_BASE_OFF;
11789 }
11790
11791 /* No toc references were found in ISEC. If the code in ISEC makes no
11792 calls, then there's no need to use toc adjusting stubs when branching
11793 into ISEC. Actually, indirect calls from ISEC are OK as they will
11794 load r2. Returns -1 on error, 0 for no stub needed, 1 for stub
11795 needed, and 2 if a cyclical call-graph was found but no other reason
11796 for a stub was detected. If called from the top level, a return of
11797 2 means the same as a return of 0. */
11798
11799 static int
11800 toc_adjusting_stub_needed (struct bfd_link_info *info, asection *isec)
11801 {
11802 int ret;
11803
11804 /* Mark this section as checked. */
11805 isec->call_check_done = 1;
11806
11807 /* We know none of our code bearing sections will need toc stubs. */
11808 if ((isec->flags & SEC_LINKER_CREATED) != 0)
11809 return 0;
11810
11811 if (isec->size == 0)
11812 return 0;
11813
11814 if (isec->output_section == NULL)
11815 return 0;
11816
11817 ret = 0;
11818 if (isec->reloc_count != 0)
11819 {
11820 Elf_Internal_Rela *relstart, *rel;
11821 Elf_Internal_Sym *local_syms;
11822 struct ppc_link_hash_table *htab;
11823
11824 relstart = _bfd_elf_link_read_relocs (isec->owner, isec, NULL, NULL,
11825 info->keep_memory);
11826 if (relstart == NULL)
11827 return -1;
11828
11829 /* Look for branches to outside of this section. */
11830 local_syms = NULL;
11831 htab = ppc_hash_table (info);
11832 if (htab == NULL)
11833 return -1;
11834
11835 for (rel = relstart; rel < relstart + isec->reloc_count; ++rel)
11836 {
11837 enum elf_ppc64_reloc_type r_type;
11838 unsigned long r_symndx;
11839 struct elf_link_hash_entry *h;
11840 struct ppc_link_hash_entry *eh;
11841 Elf_Internal_Sym *sym;
11842 asection *sym_sec;
11843 struct _opd_sec_data *opd;
11844 bfd_vma sym_value;
11845 bfd_vma dest;
11846
11847 r_type = ELF64_R_TYPE (rel->r_info);
11848 if (r_type != R_PPC64_REL24
11849 && r_type != R_PPC64_REL14
11850 && r_type != R_PPC64_REL14_BRTAKEN
11851 && r_type != R_PPC64_REL14_BRNTAKEN)
11852 continue;
11853
11854 r_symndx = ELF64_R_SYM (rel->r_info);
11855 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms, r_symndx,
11856 isec->owner))
11857 {
11858 ret = -1;
11859 break;
11860 }
11861
11862 /* Calls to dynamic lib functions go through a plt call stub
11863 that uses r2. */
11864 eh = (struct ppc_link_hash_entry *) h;
11865 if (eh != NULL
11866 && (eh->elf.plt.plist != NULL
11867 || (eh->oh != NULL
11868 && ppc_follow_link (eh->oh)->elf.plt.plist != NULL)))
11869 {
11870 ret = 1;
11871 break;
11872 }
11873
11874 if (sym_sec == NULL)
11875 /* Ignore other undefined symbols. */
11876 continue;
11877
11878 /* Assume branches to other sections not included in the
11879 link need stubs too, to cover -R and absolute syms. */
11880 if (sym_sec->output_section == NULL)
11881 {
11882 ret = 1;
11883 break;
11884 }
11885
11886 if (h == NULL)
11887 sym_value = sym->st_value;
11888 else
11889 {
11890 if (h->root.type != bfd_link_hash_defined
11891 && h->root.type != bfd_link_hash_defweak)
11892 abort ();
11893 sym_value = h->root.u.def.value;
11894 }
11895 sym_value += rel->r_addend;
11896
11897 /* If this branch reloc uses an opd sym, find the code section. */
11898 opd = get_opd_info (sym_sec);
11899 if (opd != NULL)
11900 {
11901 if (h == NULL && opd->adjust != NULL)
11902 {
11903 long adjust;
11904
11905 adjust = opd->adjust[OPD_NDX (sym_value)];
11906 if (adjust == -1)
11907 /* Assume deleted functions won't ever be called. */
11908 continue;
11909 sym_value += adjust;
11910 }
11911
11912 dest = opd_entry_value (sym_sec, sym_value,
11913 &sym_sec, NULL, FALSE);
11914 if (dest == (bfd_vma) -1)
11915 continue;
11916 }
11917 else
11918 dest = (sym_value
11919 + sym_sec->output_offset
11920 + sym_sec->output_section->vma);
11921
11922 /* Ignore branch to self. */
11923 if (sym_sec == isec)
11924 continue;
11925
11926 /* If the called function uses the toc, we need a stub. */
11927 if (sym_sec->has_toc_reloc
11928 || sym_sec->makes_toc_func_call)
11929 {
11930 ret = 1;
11931 break;
11932 }
11933
11934 /* Assume any branch that needs a long branch stub might in fact
11935 need a plt_branch stub. A plt_branch stub uses r2. */
11936 else if (dest - (isec->output_offset
11937 + isec->output_section->vma
11938 + rel->r_offset) + (1 << 25)
11939 >= (2u << 25) - PPC64_LOCAL_ENTRY_OFFSET (h
11940 ? h->other
11941 : sym->st_other))
11942 {
11943 ret = 1;
11944 break;
11945 }
11946
11947 /* If calling back to a section in the process of being
11948 tested, we can't say for sure that no toc adjusting stubs
11949 are needed, so don't return zero. */
11950 else if (sym_sec->call_check_in_progress)
11951 ret = 2;
11952
11953 /* Branches to another section that itself doesn't have any TOC
11954 references are OK. Recursively call ourselves to check. */
11955 else if (!sym_sec->call_check_done)
11956 {
11957 int recur;
11958
11959 /* Mark current section as indeterminate, so that other
11960 sections that call back to current won't be marked as
11961 known. */
11962 isec->call_check_in_progress = 1;
11963 recur = toc_adjusting_stub_needed (info, sym_sec);
11964 isec->call_check_in_progress = 0;
11965
11966 if (recur != 0)
11967 {
11968 ret = recur;
11969 if (recur != 2)
11970 break;
11971 }
11972 }
11973 }
11974
11975 if (local_syms != NULL
11976 && (elf_symtab_hdr (isec->owner).contents
11977 != (unsigned char *) local_syms))
11978 free (local_syms);
11979 if (elf_section_data (isec)->relocs != relstart)
11980 free (relstart);
11981 }
11982
11983 if ((ret & 1) == 0
11984 && isec->map_head.s != NULL
11985 && (strcmp (isec->output_section->name, ".init") == 0
11986 || strcmp (isec->output_section->name, ".fini") == 0))
11987 {
11988 if (isec->map_head.s->has_toc_reloc
11989 || isec->map_head.s->makes_toc_func_call)
11990 ret = 1;
11991 else if (!isec->map_head.s->call_check_done)
11992 {
11993 int recur;
11994 isec->call_check_in_progress = 1;
11995 recur = toc_adjusting_stub_needed (info, isec->map_head.s);
11996 isec->call_check_in_progress = 0;
11997 if (recur != 0)
11998 ret = recur;
11999 }
12000 }
12001
12002 if (ret == 1)
12003 isec->makes_toc_func_call = 1;
12004
12005 return ret;
12006 }
12007
12008 /* The linker repeatedly calls this function for each input section,
12009 in the order that input sections are linked into output sections.
12010 Build lists of input sections to determine groupings between which
12011 we may insert linker stubs. */
12012
12013 bfd_boolean
12014 ppc64_elf_next_input_section (struct bfd_link_info *info, asection *isec)
12015 {
12016 struct ppc_link_hash_table *htab = ppc_hash_table (info);
12017
12018 if (htab == NULL)
12019 return FALSE;
12020
12021 if ((isec->output_section->flags & SEC_CODE) != 0
12022 && isec->output_section->id < htab->sec_info_arr_size)
12023 {
12024 /* This happens to make the list in reverse order,
12025 which is what we want. */
12026 htab->sec_info[isec->id].u.list
12027 = htab->sec_info[isec->output_section->id].u.list;
12028 htab->sec_info[isec->output_section->id].u.list = isec;
12029 }
12030
12031 if (htab->multi_toc_needed)
12032 {
12033 /* Analyse sections that aren't already flagged as needing a
12034 valid toc pointer. Exclude .fixup for the linux kernel.
12035 .fixup contains branches, but only back to the function that
12036 hit an exception. */
12037 if (!(isec->has_toc_reloc
12038 || (isec->flags & SEC_CODE) == 0
12039 || strcmp (isec->name, ".fixup") == 0
12040 || isec->call_check_done))
12041 {
12042 if (toc_adjusting_stub_needed (info, isec) < 0)
12043 return FALSE;
12044 }
12045 /* Make all sections use the TOC assigned for this object file.
12046 This will be wrong for pasted sections; We fix that in
12047 check_pasted_section(). */
12048 if (elf_gp (isec->owner) != 0)
12049 htab->toc_curr = elf_gp (isec->owner);
12050 }
12051
12052 htab->sec_info[isec->id].toc_off = htab->toc_curr;
12053 return TRUE;
12054 }
12055
12056 /* Check that all .init and .fini sections use the same toc, if they
12057 have toc relocs. */
12058
12059 static bfd_boolean
12060 check_pasted_section (struct bfd_link_info *info, const char *name)
12061 {
12062 asection *o = bfd_get_section_by_name (info->output_bfd, name);
12063
12064 if (o != NULL)
12065 {
12066 struct ppc_link_hash_table *htab = ppc_hash_table (info);
12067 bfd_vma toc_off = 0;
12068 asection *i;
12069
12070 for (i = o->map_head.s; i != NULL; i = i->map_head.s)
12071 if (i->has_toc_reloc)
12072 {
12073 if (toc_off == 0)
12074 toc_off = htab->sec_info[i->id].toc_off;
12075 else if (toc_off != htab->sec_info[i->id].toc_off)
12076 return FALSE;
12077 }
12078
12079 if (toc_off == 0)
12080 for (i = o->map_head.s; i != NULL; i = i->map_head.s)
12081 if (i->makes_toc_func_call)
12082 {
12083 toc_off = htab->sec_info[i->id].toc_off;
12084 break;
12085 }
12086
12087 /* Make sure the whole pasted function uses the same toc offset. */
12088 if (toc_off != 0)
12089 for (i = o->map_head.s; i != NULL; i = i->map_head.s)
12090 htab->sec_info[i->id].toc_off = toc_off;
12091 }
12092 return TRUE;
12093 }
12094
12095 bfd_boolean
12096 ppc64_elf_check_init_fini (struct bfd_link_info *info)
12097 {
12098 return (check_pasted_section (info, ".init")
12099 & check_pasted_section (info, ".fini"));
12100 }
12101
12102 /* See whether we can group stub sections together. Grouping stub
12103 sections may result in fewer stubs. More importantly, we need to
12104 put all .init* and .fini* stubs at the beginning of the .init or
12105 .fini output sections respectively, because glibc splits the
12106 _init and _fini functions into multiple parts. Putting a stub in
12107 the middle of a function is not a good idea. */
12108
12109 static bfd_boolean
12110 group_sections (struct bfd_link_info *info,
12111 bfd_size_type stub_group_size,
12112 bfd_boolean stubs_always_before_branch)
12113 {
12114 struct ppc_link_hash_table *htab;
12115 asection *osec;
12116 bfd_boolean suppress_size_errors;
12117
12118 htab = ppc_hash_table (info);
12119 if (htab == NULL)
12120 return FALSE;
12121
12122 suppress_size_errors = FALSE;
12123 if (stub_group_size == 1)
12124 {
12125 /* Default values. */
12126 if (stubs_always_before_branch)
12127 stub_group_size = 0x1e00000;
12128 else
12129 stub_group_size = 0x1c00000;
12130 suppress_size_errors = TRUE;
12131 }
12132
12133 for (osec = info->output_bfd->sections; osec != NULL; osec = osec->next)
12134 {
12135 asection *tail;
12136
12137 if (osec->id >= htab->sec_info_arr_size)
12138 continue;
12139
12140 tail = htab->sec_info[osec->id].u.list;
12141 while (tail != NULL)
12142 {
12143 asection *curr;
12144 asection *prev;
12145 bfd_size_type total;
12146 bfd_boolean big_sec;
12147 bfd_vma curr_toc;
12148 struct map_stub *group;
12149 bfd_size_type group_size;
12150
12151 curr = tail;
12152 total = tail->size;
12153 group_size = (ppc64_elf_section_data (tail) != NULL
12154 && ppc64_elf_section_data (tail)->has_14bit_branch
12155 ? stub_group_size >> 10 : stub_group_size);
12156
12157 big_sec = total > group_size;
12158 if (big_sec && !suppress_size_errors)
12159 /* xgettext:c-format */
12160 _bfd_error_handler (_("%B section %A exceeds stub group size"),
12161 tail->owner, tail);
12162 curr_toc = htab->sec_info[tail->id].toc_off;
12163
12164 while ((prev = htab->sec_info[curr->id].u.list) != NULL
12165 && ((total += curr->output_offset - prev->output_offset)
12166 < (ppc64_elf_section_data (prev) != NULL
12167 && ppc64_elf_section_data (prev)->has_14bit_branch
12168 ? (group_size = stub_group_size >> 10) : group_size))
12169 && htab->sec_info[prev->id].toc_off == curr_toc)
12170 curr = prev;
12171
12172 /* OK, the size from the start of CURR to the end is less
12173 than group_size and thus can be handled by one stub
12174 section. (or the tail section is itself larger than
12175 group_size, in which case we may be toast.) We should
12176 really be keeping track of the total size of stubs added
12177 here, as stubs contribute to the final output section
12178 size. That's a little tricky, and this way will only
12179 break if stubs added make the total size more than 2^25,
12180 ie. for the default stub_group_size, if stubs total more
12181 than 2097152 bytes, or nearly 75000 plt call stubs. */
12182 group = bfd_alloc (curr->owner, sizeof (*group));
12183 if (group == NULL)
12184 return FALSE;
12185 group->link_sec = curr;
12186 group->stub_sec = NULL;
12187 group->needs_save_res = 0;
12188 group->next = htab->group;
12189 htab->group = group;
12190 do
12191 {
12192 prev = htab->sec_info[tail->id].u.list;
12193 /* Set up this stub group. */
12194 htab->sec_info[tail->id].u.group = group;
12195 }
12196 while (tail != curr && (tail = prev) != NULL);
12197
12198 /* But wait, there's more! Input sections up to group_size
12199 bytes before the stub section can be handled by it too.
12200 Don't do this if we have a really large section after the
12201 stubs, as adding more stubs increases the chance that
12202 branches may not reach into the stub section. */
12203 if (!stubs_always_before_branch && !big_sec)
12204 {
12205 total = 0;
12206 while (prev != NULL
12207 && ((total += tail->output_offset - prev->output_offset)
12208 < (ppc64_elf_section_data (prev) != NULL
12209 && ppc64_elf_section_data (prev)->has_14bit_branch
12210 ? (group_size = stub_group_size >> 10) : group_size))
12211 && htab->sec_info[prev->id].toc_off == curr_toc)
12212 {
12213 tail = prev;
12214 prev = htab->sec_info[tail->id].u.list;
12215 htab->sec_info[tail->id].u.group = group;
12216 }
12217 }
12218 tail = prev;
12219 }
12220 }
12221 return TRUE;
12222 }
12223
12224 static const unsigned char glink_eh_frame_cie[] =
12225 {
12226 0, 0, 0, 16, /* length. */
12227 0, 0, 0, 0, /* id. */
12228 1, /* CIE version. */
12229 'z', 'R', 0, /* Augmentation string. */
12230 4, /* Code alignment. */
12231 0x78, /* Data alignment. */
12232 65, /* RA reg. */
12233 1, /* Augmentation size. */
12234 DW_EH_PE_pcrel | DW_EH_PE_sdata4, /* FDE encoding. */
12235 DW_CFA_def_cfa, 1, 0 /* def_cfa: r1 offset 0. */
12236 };
12237
12238 /* Stripping output sections is normally done before dynamic section
12239 symbols have been allocated. This function is called later, and
12240 handles cases like htab->brlt which is mapped to its own output
12241 section. */
12242
12243 static void
12244 maybe_strip_output (struct bfd_link_info *info, asection *isec)
12245 {
12246 if (isec->size == 0
12247 && isec->output_section->size == 0
12248 && !(isec->output_section->flags & SEC_KEEP)
12249 && !bfd_section_removed_from_list (info->output_bfd,
12250 isec->output_section)
12251 && elf_section_data (isec->output_section)->dynindx == 0)
12252 {
12253 isec->output_section->flags |= SEC_EXCLUDE;
12254 bfd_section_list_remove (info->output_bfd, isec->output_section);
12255 info->output_bfd->section_count--;
12256 }
12257 }
12258
12259 /* Determine and set the size of the stub section for a final link.
12260
12261 The basic idea here is to examine all the relocations looking for
12262 PC-relative calls to a target that is unreachable with a "bl"
12263 instruction. */
12264
12265 bfd_boolean
12266 ppc64_elf_size_stubs (struct bfd_link_info *info)
12267 {
12268 bfd_size_type stub_group_size;
12269 bfd_boolean stubs_always_before_branch;
12270 struct ppc_link_hash_table *htab = ppc_hash_table (info);
12271
12272 if (htab == NULL)
12273 return FALSE;
12274
12275 if (htab->params->plt_thread_safe == -1 && !bfd_link_executable (info))
12276 htab->params->plt_thread_safe = 1;
12277 if (!htab->opd_abi)
12278 htab->params->plt_thread_safe = 0;
12279 else if (htab->params->plt_thread_safe == -1)
12280 {
12281 static const char *const thread_starter[] =
12282 {
12283 "pthread_create",
12284 /* libstdc++ */
12285 "_ZNSt6thread15_M_start_threadESt10shared_ptrINS_10_Impl_baseEE",
12286 /* librt */
12287 "aio_init", "aio_read", "aio_write", "aio_fsync", "lio_listio",
12288 "mq_notify", "create_timer",
12289 /* libanl */
12290 "getaddrinfo_a",
12291 /* libgomp */
12292 "GOMP_parallel",
12293 "GOMP_parallel_start",
12294 "GOMP_parallel_loop_static",
12295 "GOMP_parallel_loop_static_start",
12296 "GOMP_parallel_loop_dynamic",
12297 "GOMP_parallel_loop_dynamic_start",
12298 "GOMP_parallel_loop_guided",
12299 "GOMP_parallel_loop_guided_start",
12300 "GOMP_parallel_loop_runtime",
12301 "GOMP_parallel_loop_runtime_start",
12302 "GOMP_parallel_sections",
12303 "GOMP_parallel_sections_start",
12304 /* libgo */
12305 "__go_go",
12306 };
12307 unsigned i;
12308
12309 for (i = 0; i < ARRAY_SIZE (thread_starter); i++)
12310 {
12311 struct elf_link_hash_entry *h;
12312 h = elf_link_hash_lookup (&htab->elf, thread_starter[i],
12313 FALSE, FALSE, TRUE);
12314 htab->params->plt_thread_safe = h != NULL && h->ref_regular;
12315 if (htab->params->plt_thread_safe)
12316 break;
12317 }
12318 }
12319 stubs_always_before_branch = htab->params->group_size < 0;
12320 if (htab->params->group_size < 0)
12321 stub_group_size = -htab->params->group_size;
12322 else
12323 stub_group_size = htab->params->group_size;
12324
12325 if (!group_sections (info, stub_group_size, stubs_always_before_branch))
12326 return FALSE;
12327
12328 #define STUB_SHRINK_ITER 20
12329 /* Loop until no stubs added. After iteration 20 of this loop we may
12330 exit on a stub section shrinking. This is to break out of a
12331 pathological case where adding stubs on one iteration decreases
12332 section gaps (perhaps due to alignment), which then requires
12333 fewer or smaller stubs on the next iteration. */
12334
12335 while (1)
12336 {
12337 bfd *input_bfd;
12338 unsigned int bfd_indx;
12339 struct map_stub *group;
12340 asection *stub_sec;
12341
12342 htab->stub_iteration += 1;
12343
12344 for (input_bfd = info->input_bfds, bfd_indx = 0;
12345 input_bfd != NULL;
12346 input_bfd = input_bfd->link.next, bfd_indx++)
12347 {
12348 Elf_Internal_Shdr *symtab_hdr;
12349 asection *section;
12350 Elf_Internal_Sym *local_syms = NULL;
12351
12352 if (!is_ppc64_elf (input_bfd))
12353 continue;
12354
12355 /* We'll need the symbol table in a second. */
12356 symtab_hdr = &elf_symtab_hdr (input_bfd);
12357 if (symtab_hdr->sh_info == 0)
12358 continue;
12359
12360 /* Walk over each section attached to the input bfd. */
12361 for (section = input_bfd->sections;
12362 section != NULL;
12363 section = section->next)
12364 {
12365 Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
12366
12367 /* If there aren't any relocs, then there's nothing more
12368 to do. */
12369 if ((section->flags & SEC_RELOC) == 0
12370 || (section->flags & SEC_ALLOC) == 0
12371 || (section->flags & SEC_LOAD) == 0
12372 || (section->flags & SEC_CODE) == 0
12373 || section->reloc_count == 0)
12374 continue;
12375
12376 /* If this section is a link-once section that will be
12377 discarded, then don't create any stubs. */
12378 if (section->output_section == NULL
12379 || section->output_section->owner != info->output_bfd)
12380 continue;
12381
12382 /* Get the relocs. */
12383 internal_relocs
12384 = _bfd_elf_link_read_relocs (input_bfd, section, NULL, NULL,
12385 info->keep_memory);
12386 if (internal_relocs == NULL)
12387 goto error_ret_free_local;
12388
12389 /* Now examine each relocation. */
12390 irela = internal_relocs;
12391 irelaend = irela + section->reloc_count;
12392 for (; irela < irelaend; irela++)
12393 {
12394 enum elf_ppc64_reloc_type r_type;
12395 unsigned int r_indx;
12396 enum ppc_stub_type stub_type;
12397 struct ppc_stub_hash_entry *stub_entry;
12398 asection *sym_sec, *code_sec;
12399 bfd_vma sym_value, code_value;
12400 bfd_vma destination;
12401 unsigned long local_off;
12402 bfd_boolean ok_dest;
12403 struct ppc_link_hash_entry *hash;
12404 struct ppc_link_hash_entry *fdh;
12405 struct elf_link_hash_entry *h;
12406 Elf_Internal_Sym *sym;
12407 char *stub_name;
12408 const asection *id_sec;
12409 struct _opd_sec_data *opd;
12410 struct plt_entry *plt_ent;
12411
12412 r_type = ELF64_R_TYPE (irela->r_info);
12413 r_indx = ELF64_R_SYM (irela->r_info);
12414
12415 if (r_type >= R_PPC64_max)
12416 {
12417 bfd_set_error (bfd_error_bad_value);
12418 goto error_ret_free_internal;
12419 }
12420
12421 /* Only look for stubs on branch instructions. */
12422 if (r_type != R_PPC64_REL24
12423 && r_type != R_PPC64_REL14
12424 && r_type != R_PPC64_REL14_BRTAKEN
12425 && r_type != R_PPC64_REL14_BRNTAKEN)
12426 continue;
12427
12428 /* Now determine the call target, its name, value,
12429 section. */
12430 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
12431 r_indx, input_bfd))
12432 goto error_ret_free_internal;
12433 hash = (struct ppc_link_hash_entry *) h;
12434
12435 ok_dest = FALSE;
12436 fdh = NULL;
12437 sym_value = 0;
12438 if (hash == NULL)
12439 {
12440 sym_value = sym->st_value;
12441 if (sym_sec != NULL
12442 && sym_sec->output_section != NULL)
12443 ok_dest = TRUE;
12444 }
12445 else if (hash->elf.root.type == bfd_link_hash_defined
12446 || hash->elf.root.type == bfd_link_hash_defweak)
12447 {
12448 sym_value = hash->elf.root.u.def.value;
12449 if (sym_sec->output_section != NULL)
12450 ok_dest = TRUE;
12451 }
12452 else if (hash->elf.root.type == bfd_link_hash_undefweak
12453 || hash->elf.root.type == bfd_link_hash_undefined)
12454 {
12455 /* Recognise an old ABI func code entry sym, and
12456 use the func descriptor sym instead if it is
12457 defined. */
12458 if (hash->elf.root.root.string[0] == '.'
12459 && hash->oh != NULL)
12460 {
12461 fdh = ppc_follow_link (hash->oh);
12462 if (fdh->elf.root.type == bfd_link_hash_defined
12463 || fdh->elf.root.type == bfd_link_hash_defweak)
12464 {
12465 sym_sec = fdh->elf.root.u.def.section;
12466 sym_value = fdh->elf.root.u.def.value;
12467 if (sym_sec->output_section != NULL)
12468 ok_dest = TRUE;
12469 }
12470 else
12471 fdh = NULL;
12472 }
12473 }
12474 else
12475 {
12476 bfd_set_error (bfd_error_bad_value);
12477 goto error_ret_free_internal;
12478 }
12479
12480 destination = 0;
12481 local_off = 0;
12482 if (ok_dest)
12483 {
12484 sym_value += irela->r_addend;
12485 destination = (sym_value
12486 + sym_sec->output_offset
12487 + sym_sec->output_section->vma);
12488 local_off = PPC64_LOCAL_ENTRY_OFFSET (hash
12489 ? hash->elf.other
12490 : sym->st_other);
12491 }
12492
12493 code_sec = sym_sec;
12494 code_value = sym_value;
12495 opd = get_opd_info (sym_sec);
12496 if (opd != NULL)
12497 {
12498 bfd_vma dest;
12499
12500 if (hash == NULL && opd->adjust != NULL)
12501 {
12502 long adjust = opd->adjust[OPD_NDX (sym_value)];
12503 if (adjust == -1)
12504 continue;
12505 code_value += adjust;
12506 sym_value += adjust;
12507 }
12508 dest = opd_entry_value (sym_sec, sym_value,
12509 &code_sec, &code_value, FALSE);
12510 if (dest != (bfd_vma) -1)
12511 {
12512 destination = dest;
12513 if (fdh != NULL)
12514 {
12515 /* Fixup old ABI sym to point at code
12516 entry. */
12517 hash->elf.root.type = bfd_link_hash_defweak;
12518 hash->elf.root.u.def.section = code_sec;
12519 hash->elf.root.u.def.value = code_value;
12520 }
12521 }
12522 }
12523
12524 /* Determine what (if any) linker stub is needed. */
12525 plt_ent = NULL;
12526 stub_type = ppc_type_of_stub (section, irela, &hash,
12527 &plt_ent, destination,
12528 local_off);
12529
12530 if (stub_type != ppc_stub_plt_call)
12531 {
12532 /* Check whether we need a TOC adjusting stub.
12533 Since the linker pastes together pieces from
12534 different object files when creating the
12535 _init and _fini functions, it may be that a
12536 call to what looks like a local sym is in
12537 fact a call needing a TOC adjustment. */
12538 if (code_sec != NULL
12539 && code_sec->output_section != NULL
12540 && (htab->sec_info[code_sec->id].toc_off
12541 != htab->sec_info[section->id].toc_off)
12542 && (code_sec->has_toc_reloc
12543 || code_sec->makes_toc_func_call))
12544 stub_type = ppc_stub_long_branch_r2off;
12545 }
12546
12547 if (stub_type == ppc_stub_none)
12548 continue;
12549
12550 /* __tls_get_addr calls might be eliminated. */
12551 if (stub_type != ppc_stub_plt_call
12552 && hash != NULL
12553 && (hash == htab->tls_get_addr
12554 || hash == htab->tls_get_addr_fd)
12555 && section->has_tls_reloc
12556 && irela != internal_relocs)
12557 {
12558 /* Get tls info. */
12559 unsigned char *tls_mask;
12560
12561 if (!get_tls_mask (&tls_mask, NULL, NULL, &local_syms,
12562 irela - 1, input_bfd))
12563 goto error_ret_free_internal;
12564 if (*tls_mask != 0)
12565 continue;
12566 }
12567
12568 if (stub_type == ppc_stub_plt_call
12569 && irela + 1 < irelaend
12570 && irela[1].r_offset == irela->r_offset + 4
12571 && ELF64_R_TYPE (irela[1].r_info) == R_PPC64_TOCSAVE)
12572 {
12573 if (!tocsave_find (htab, INSERT,
12574 &local_syms, irela + 1, input_bfd))
12575 goto error_ret_free_internal;
12576 }
12577 else if (stub_type == ppc_stub_plt_call)
12578 stub_type = ppc_stub_plt_call_r2save;
12579
12580 /* Support for grouping stub sections. */
12581 id_sec = htab->sec_info[section->id].u.group->link_sec;
12582
12583 /* Get the name of this stub. */
12584 stub_name = ppc_stub_name (id_sec, sym_sec, hash, irela);
12585 if (!stub_name)
12586 goto error_ret_free_internal;
12587
12588 stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
12589 stub_name, FALSE, FALSE);
12590 if (stub_entry != NULL)
12591 {
12592 /* The proper stub has already been created. */
12593 free (stub_name);
12594 if (stub_type == ppc_stub_plt_call_r2save)
12595 stub_entry->stub_type = stub_type;
12596 continue;
12597 }
12598
12599 stub_entry = ppc_add_stub (stub_name, section, info);
12600 if (stub_entry == NULL)
12601 {
12602 free (stub_name);
12603 error_ret_free_internal:
12604 if (elf_section_data (section)->relocs == NULL)
12605 free (internal_relocs);
12606 error_ret_free_local:
12607 if (local_syms != NULL
12608 && (symtab_hdr->contents
12609 != (unsigned char *) local_syms))
12610 free (local_syms);
12611 return FALSE;
12612 }
12613
12614 stub_entry->stub_type = stub_type;
12615 if (stub_type != ppc_stub_plt_call
12616 && stub_type != ppc_stub_plt_call_r2save)
12617 {
12618 stub_entry->target_value = code_value;
12619 stub_entry->target_section = code_sec;
12620 }
12621 else
12622 {
12623 stub_entry->target_value = sym_value;
12624 stub_entry->target_section = sym_sec;
12625 }
12626 stub_entry->h = hash;
12627 stub_entry->plt_ent = plt_ent;
12628 stub_entry->other = hash ? hash->elf.other : sym->st_other;
12629
12630 if (stub_entry->h != NULL)
12631 htab->stub_globals += 1;
12632 }
12633
12634 /* We're done with the internal relocs, free them. */
12635 if (elf_section_data (section)->relocs != internal_relocs)
12636 free (internal_relocs);
12637 }
12638
12639 if (local_syms != NULL
12640 && symtab_hdr->contents != (unsigned char *) local_syms)
12641 {
12642 if (!info->keep_memory)
12643 free (local_syms);
12644 else
12645 symtab_hdr->contents = (unsigned char *) local_syms;
12646 }
12647 }
12648
12649 /* We may have added some stubs. Find out the new size of the
12650 stub sections. */
12651 for (stub_sec = htab->params->stub_bfd->sections;
12652 stub_sec != NULL;
12653 stub_sec = stub_sec->next)
12654 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12655 {
12656 if (htab->stub_iteration <= STUB_SHRINK_ITER
12657 || stub_sec->rawsize < stub_sec->size)
12658 /* Past STUB_SHRINK_ITER, rawsize is the max size seen. */
12659 stub_sec->rawsize = stub_sec->size;
12660 stub_sec->size = 0;
12661 stub_sec->reloc_count = 0;
12662 stub_sec->flags &= ~SEC_RELOC;
12663 }
12664
12665 htab->brlt->size = 0;
12666 htab->brlt->reloc_count = 0;
12667 htab->brlt->flags &= ~SEC_RELOC;
12668 if (htab->relbrlt != NULL)
12669 htab->relbrlt->size = 0;
12670
12671 bfd_hash_traverse (&htab->stub_hash_table, ppc_size_one_stub, info);
12672
12673 for (group = htab->group; group != NULL; group = group->next)
12674 if (group->needs_save_res)
12675 group->stub_sec->size += htab->sfpr->size;
12676
12677 if (info->emitrelocations
12678 && htab->glink != NULL && htab->glink->size != 0)
12679 {
12680 htab->glink->reloc_count = 1;
12681 htab->glink->flags |= SEC_RELOC;
12682 }
12683
12684 if (htab->glink_eh_frame != NULL
12685 && !bfd_is_abs_section (htab->glink_eh_frame->output_section)
12686 && htab->glink_eh_frame->output_section->size != 0)
12687 {
12688 size_t size = 0, align = 4;
12689
12690 for (stub_sec = htab->params->stub_bfd->sections;
12691 stub_sec != NULL;
12692 stub_sec = stub_sec->next)
12693 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12694 size += (17 + align - 1) & -align;
12695 if (htab->glink != NULL && htab->glink->size != 0)
12696 size += (24 + align - 1) & -align;
12697 if (size != 0)
12698 size += (sizeof (glink_eh_frame_cie) + align - 1) & -align;
12699 align = 1ul << htab->glink_eh_frame->output_section->alignment_power;
12700 size = (size + align - 1) & -align;
12701 htab->glink_eh_frame->rawsize = htab->glink_eh_frame->size;
12702 htab->glink_eh_frame->size = size;
12703 }
12704
12705 if (htab->params->plt_stub_align != 0)
12706 for (stub_sec = htab->params->stub_bfd->sections;
12707 stub_sec != NULL;
12708 stub_sec = stub_sec->next)
12709 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12710 stub_sec->size = ((stub_sec->size
12711 + (1 << htab->params->plt_stub_align) - 1)
12712 & -(1 << htab->params->plt_stub_align));
12713
12714 for (stub_sec = htab->params->stub_bfd->sections;
12715 stub_sec != NULL;
12716 stub_sec = stub_sec->next)
12717 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
12718 && stub_sec->rawsize != stub_sec->size
12719 && (htab->stub_iteration <= STUB_SHRINK_ITER
12720 || stub_sec->rawsize < stub_sec->size))
12721 break;
12722
12723 if (stub_sec == NULL
12724 && (htab->glink_eh_frame == NULL
12725 || htab->glink_eh_frame->rawsize == htab->glink_eh_frame->size))
12726 break;
12727
12728 /* Ask the linker to do its stuff. */
12729 (*htab->params->layout_sections_again) ();
12730 }
12731
12732 if (htab->glink_eh_frame != NULL
12733 && htab->glink_eh_frame->size != 0)
12734 {
12735 bfd_vma val;
12736 bfd_byte *p, *last_fde;
12737 size_t last_fde_len, size, align, pad;
12738 asection *stub_sec;
12739
12740 p = bfd_zalloc (htab->glink_eh_frame->owner, htab->glink_eh_frame->size);
12741 if (p == NULL)
12742 return FALSE;
12743 htab->glink_eh_frame->contents = p;
12744 last_fde = p;
12745 align = 4;
12746
12747 memcpy (p, glink_eh_frame_cie, sizeof (glink_eh_frame_cie));
12748 /* CIE length (rewrite in case little-endian). */
12749 last_fde_len = ((sizeof (glink_eh_frame_cie) + align - 1) & -align) - 4;
12750 bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
12751 p += last_fde_len + 4;
12752
12753 for (stub_sec = htab->params->stub_bfd->sections;
12754 stub_sec != NULL;
12755 stub_sec = stub_sec->next)
12756 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12757 {
12758 last_fde = p;
12759 last_fde_len = ((17 + align - 1) & -align) - 4;
12760 /* FDE length. */
12761 bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
12762 p += 4;
12763 /* CIE pointer. */
12764 val = p - htab->glink_eh_frame->contents;
12765 bfd_put_32 (htab->elf.dynobj, val, p);
12766 p += 4;
12767 /* Offset to stub section, written later. */
12768 p += 4;
12769 /* stub section size. */
12770 bfd_put_32 (htab->elf.dynobj, stub_sec->size, p);
12771 p += 4;
12772 /* Augmentation. */
12773 p += 1;
12774 /* Pad. */
12775 p += ((17 + align - 1) & -align) - 17;
12776 }
12777 if (htab->glink != NULL && htab->glink->size != 0)
12778 {
12779 last_fde = p;
12780 last_fde_len = ((24 + align - 1) & -align) - 4;
12781 /* FDE length. */
12782 bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
12783 p += 4;
12784 /* CIE pointer. */
12785 val = p - htab->glink_eh_frame->contents;
12786 bfd_put_32 (htab->elf.dynobj, val, p);
12787 p += 4;
12788 /* Offset to .glink, written later. */
12789 p += 4;
12790 /* .glink size. */
12791 bfd_put_32 (htab->elf.dynobj, htab->glink->size - 8, p);
12792 p += 4;
12793 /* Augmentation. */
12794 p += 1;
12795
12796 *p++ = DW_CFA_advance_loc + 1;
12797 *p++ = DW_CFA_register;
12798 *p++ = 65;
12799 *p++ = htab->opd_abi ? 12 : 0;
12800 *p++ = DW_CFA_advance_loc + 4;
12801 *p++ = DW_CFA_restore_extended;
12802 *p++ = 65;
12803 p += ((24 + align - 1) & -align) - 24;
12804 }
12805 /* Subsume any padding into the last FDE if user .eh_frame
12806 sections are aligned more than glink_eh_frame. Otherwise any
12807 zero padding will be seen as a terminator. */
12808 align = 1ul << htab->glink_eh_frame->output_section->alignment_power;
12809 size = p - htab->glink_eh_frame->contents;
12810 pad = ((size + align - 1) & -align) - size;
12811 htab->glink_eh_frame->size = size + pad;
12812 bfd_put_32 (htab->elf.dynobj, last_fde_len + pad, last_fde);
12813 }
12814
12815 maybe_strip_output (info, htab->brlt);
12816 if (htab->glink_eh_frame != NULL)
12817 maybe_strip_output (info, htab->glink_eh_frame);
12818
12819 return TRUE;
12820 }
12821
12822 /* Called after we have determined section placement. If sections
12823 move, we'll be called again. Provide a value for TOCstart. */
12824
12825 bfd_vma
12826 ppc64_elf_set_toc (struct bfd_link_info *info, bfd *obfd)
12827 {
12828 asection *s;
12829 bfd_vma TOCstart, adjust;
12830
12831 if (info != NULL)
12832 {
12833 struct elf_link_hash_entry *h;
12834 struct elf_link_hash_table *htab = elf_hash_table (info);
12835
12836 if (is_elf_hash_table (htab)
12837 && htab->hgot != NULL)
12838 h = htab->hgot;
12839 else
12840 {
12841 h = elf_link_hash_lookup (htab, ".TOC.", FALSE, FALSE, TRUE);
12842 if (is_elf_hash_table (htab))
12843 htab->hgot = h;
12844 }
12845 if (h != NULL
12846 && h->root.type == bfd_link_hash_defined
12847 && !h->root.linker_def
12848 && (!is_elf_hash_table (htab)
12849 || h->def_regular))
12850 {
12851 TOCstart = (h->root.u.def.value - TOC_BASE_OFF
12852 + h->root.u.def.section->output_offset
12853 + h->root.u.def.section->output_section->vma);
12854 _bfd_set_gp_value (obfd, TOCstart);
12855 return TOCstart;
12856 }
12857 }
12858
12859 /* The TOC consists of sections .got, .toc, .tocbss, .plt in that
12860 order. The TOC starts where the first of these sections starts. */
12861 s = bfd_get_section_by_name (obfd, ".got");
12862 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12863 s = bfd_get_section_by_name (obfd, ".toc");
12864 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12865 s = bfd_get_section_by_name (obfd, ".tocbss");
12866 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12867 s = bfd_get_section_by_name (obfd, ".plt");
12868 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12869 {
12870 /* This may happen for
12871 o references to TOC base (SYM@toc / TOC[tc0]) without a
12872 .toc directive
12873 o bad linker script
12874 o --gc-sections and empty TOC sections
12875
12876 FIXME: Warn user? */
12877
12878 /* Look for a likely section. We probably won't even be
12879 using TOCstart. */
12880 for (s = obfd->sections; s != NULL; s = s->next)
12881 if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_READONLY
12882 | SEC_EXCLUDE))
12883 == (SEC_ALLOC | SEC_SMALL_DATA))
12884 break;
12885 if (s == NULL)
12886 for (s = obfd->sections; s != NULL; s = s->next)
12887 if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_EXCLUDE))
12888 == (SEC_ALLOC | SEC_SMALL_DATA))
12889 break;
12890 if (s == NULL)
12891 for (s = obfd->sections; s != NULL; s = s->next)
12892 if ((s->flags & (SEC_ALLOC | SEC_READONLY | SEC_EXCLUDE))
12893 == SEC_ALLOC)
12894 break;
12895 if (s == NULL)
12896 for (s = obfd->sections; s != NULL; s = s->next)
12897 if ((s->flags & (SEC_ALLOC | SEC_EXCLUDE)) == SEC_ALLOC)
12898 break;
12899 }
12900
12901 TOCstart = 0;
12902 if (s != NULL)
12903 TOCstart = s->output_section->vma + s->output_offset;
12904
12905 /* Force alignment. */
12906 adjust = TOCstart & (TOC_BASE_ALIGN - 1);
12907 TOCstart -= adjust;
12908 _bfd_set_gp_value (obfd, TOCstart);
12909
12910 if (info != NULL && s != NULL)
12911 {
12912 struct ppc_link_hash_table *htab = ppc_hash_table (info);
12913
12914 if (htab != NULL)
12915 {
12916 if (htab->elf.hgot != NULL)
12917 {
12918 htab->elf.hgot->root.u.def.value = TOC_BASE_OFF - adjust;
12919 htab->elf.hgot->root.u.def.section = s;
12920 }
12921 }
12922 else
12923 {
12924 struct bfd_link_hash_entry *bh = NULL;
12925 _bfd_generic_link_add_one_symbol (info, obfd, ".TOC.", BSF_GLOBAL,
12926 s, TOC_BASE_OFF - adjust,
12927 NULL, FALSE, FALSE, &bh);
12928 }
12929 }
12930 return TOCstart;
12931 }
12932
12933 /* Called via elf_link_hash_traverse from ppc64_elf_build_stubs to
12934 write out any global entry stubs. */
12935
12936 static bfd_boolean
12937 build_global_entry_stubs (struct elf_link_hash_entry *h, void *inf)
12938 {
12939 struct bfd_link_info *info;
12940 struct ppc_link_hash_table *htab;
12941 struct plt_entry *pent;
12942 asection *s;
12943
12944 if (h->root.type == bfd_link_hash_indirect)
12945 return TRUE;
12946
12947 if (!h->pointer_equality_needed)
12948 return TRUE;
12949
12950 if (h->def_regular)
12951 return TRUE;
12952
12953 info = inf;
12954 htab = ppc_hash_table (info);
12955 if (htab == NULL)
12956 return FALSE;
12957
12958 s = htab->glink;
12959 for (pent = h->plt.plist; pent != NULL; pent = pent->next)
12960 if (pent->plt.offset != (bfd_vma) -1
12961 && pent->addend == 0)
12962 {
12963 bfd_byte *p;
12964 asection *plt;
12965 bfd_vma off;
12966
12967 p = s->contents + h->root.u.def.value;
12968 plt = htab->elf.splt;
12969 if (!htab->elf.dynamic_sections_created
12970 || h->dynindx == -1)
12971 plt = htab->elf.iplt;
12972 off = pent->plt.offset + plt->output_offset + plt->output_section->vma;
12973 off -= h->root.u.def.value + s->output_offset + s->output_section->vma;
12974
12975 if (off + 0x80008000 > 0xffffffff || (off & 3) != 0)
12976 {
12977 info->callbacks->einfo
12978 (_("%P: linkage table error against `%T'\n"),
12979 h->root.root.string);
12980 bfd_set_error (bfd_error_bad_value);
12981 htab->stub_error = TRUE;
12982 }
12983
12984 htab->stub_count[ppc_stub_global_entry - 1] += 1;
12985 if (htab->params->emit_stub_syms)
12986 {
12987 size_t len = strlen (h->root.root.string);
12988 char *name = bfd_malloc (sizeof "12345678.global_entry." + len);
12989
12990 if (name == NULL)
12991 return FALSE;
12992
12993 sprintf (name, "%08x.global_entry.%s", s->id, h->root.root.string);
12994 h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
12995 if (h == NULL)
12996 return FALSE;
12997 if (h->root.type == bfd_link_hash_new)
12998 {
12999 h->root.type = bfd_link_hash_defined;
13000 h->root.u.def.section = s;
13001 h->root.u.def.value = p - s->contents;
13002 h->ref_regular = 1;
13003 h->def_regular = 1;
13004 h->ref_regular_nonweak = 1;
13005 h->forced_local = 1;
13006 h->non_elf = 0;
13007 h->root.linker_def = 1;
13008 }
13009 }
13010
13011 if (PPC_HA (off) != 0)
13012 {
13013 bfd_put_32 (s->owner, ADDIS_R12_R12 | PPC_HA (off), p);
13014 p += 4;
13015 }
13016 bfd_put_32 (s->owner, LD_R12_0R12 | PPC_LO (off), p);
13017 p += 4;
13018 bfd_put_32 (s->owner, MTCTR_R12, p);
13019 p += 4;
13020 bfd_put_32 (s->owner, BCTR, p);
13021 break;
13022 }
13023 return TRUE;
13024 }
13025
13026 /* Build all the stubs associated with the current output file.
13027 The stubs are kept in a hash table attached to the main linker
13028 hash table. This function is called via gldelf64ppc_finish. */
13029
13030 bfd_boolean
13031 ppc64_elf_build_stubs (struct bfd_link_info *info,
13032 char **stats)
13033 {
13034 struct ppc_link_hash_table *htab = ppc_hash_table (info);
13035 struct map_stub *group;
13036 asection *stub_sec;
13037 bfd_byte *p;
13038 int stub_sec_count = 0;
13039
13040 if (htab == NULL)
13041 return FALSE;
13042
13043 /* Allocate memory to hold the linker stubs. */
13044 for (stub_sec = htab->params->stub_bfd->sections;
13045 stub_sec != NULL;
13046 stub_sec = stub_sec->next)
13047 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
13048 && stub_sec->size != 0)
13049 {
13050 stub_sec->contents = bfd_zalloc (htab->params->stub_bfd, stub_sec->size);
13051 if (stub_sec->contents == NULL)
13052 return FALSE;
13053 stub_sec->size = 0;
13054 }
13055
13056 if (htab->glink != NULL && htab->glink->size != 0)
13057 {
13058 unsigned int indx;
13059 bfd_vma plt0;
13060
13061 /* Build the .glink plt call stub. */
13062 if (htab->params->emit_stub_syms)
13063 {
13064 struct elf_link_hash_entry *h;
13065 h = elf_link_hash_lookup (&htab->elf, "__glink_PLTresolve",
13066 TRUE, FALSE, FALSE);
13067 if (h == NULL)
13068 return FALSE;
13069 if (h->root.type == bfd_link_hash_new)
13070 {
13071 h->root.type = bfd_link_hash_defined;
13072 h->root.u.def.section = htab->glink;
13073 h->root.u.def.value = 8;
13074 h->ref_regular = 1;
13075 h->def_regular = 1;
13076 h->ref_regular_nonweak = 1;
13077 h->forced_local = 1;
13078 h->non_elf = 0;
13079 h->root.linker_def = 1;
13080 }
13081 }
13082 plt0 = (htab->elf.splt->output_section->vma
13083 + htab->elf.splt->output_offset
13084 - 16);
13085 if (info->emitrelocations)
13086 {
13087 Elf_Internal_Rela *r = get_relocs (htab->glink, 1);
13088 if (r == NULL)
13089 return FALSE;
13090 r->r_offset = (htab->glink->output_offset
13091 + htab->glink->output_section->vma);
13092 r->r_info = ELF64_R_INFO (0, R_PPC64_REL64);
13093 r->r_addend = plt0;
13094 }
13095 p = htab->glink->contents;
13096 plt0 -= htab->glink->output_section->vma + htab->glink->output_offset;
13097 bfd_put_64 (htab->glink->owner, plt0, p);
13098 p += 8;
13099 if (htab->opd_abi)
13100 {
13101 bfd_put_32 (htab->glink->owner, MFLR_R12, p);
13102 p += 4;
13103 bfd_put_32 (htab->glink->owner, BCL_20_31, p);
13104 p += 4;
13105 bfd_put_32 (htab->glink->owner, MFLR_R11, p);
13106 p += 4;
13107 bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
13108 p += 4;
13109 bfd_put_32 (htab->glink->owner, MTLR_R12, p);
13110 p += 4;
13111 bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
13112 p += 4;
13113 bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
13114 p += 4;
13115 bfd_put_32 (htab->glink->owner, LD_R2_0R11 | 8, p);
13116 p += 4;
13117 bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
13118 p += 4;
13119 bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 16, p);
13120 p += 4;
13121 }
13122 else
13123 {
13124 bfd_put_32 (htab->glink->owner, MFLR_R0, p);
13125 p += 4;
13126 bfd_put_32 (htab->glink->owner, BCL_20_31, p);
13127 p += 4;
13128 bfd_put_32 (htab->glink->owner, MFLR_R11, p);
13129 p += 4;
13130 bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
13131 p += 4;
13132 bfd_put_32 (htab->glink->owner, MTLR_R0, p);
13133 p += 4;
13134 bfd_put_32 (htab->glink->owner, SUB_R12_R12_R11, p);
13135 p += 4;
13136 bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
13137 p += 4;
13138 bfd_put_32 (htab->glink->owner, ADDI_R0_R12 | (-48 & 0xffff), p);
13139 p += 4;
13140 bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
13141 p += 4;
13142 bfd_put_32 (htab->glink->owner, SRDI_R0_R0_2, p);
13143 p += 4;
13144 bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
13145 p += 4;
13146 bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 8, p);
13147 p += 4;
13148 }
13149 bfd_put_32 (htab->glink->owner, BCTR, p);
13150 p += 4;
13151 while (p - htab->glink->contents < GLINK_CALL_STUB_SIZE)
13152 {
13153 bfd_put_32 (htab->glink->owner, NOP, p);
13154 p += 4;
13155 }
13156
13157 /* Build the .glink lazy link call stubs. */
13158 indx = 0;
13159 while (p < htab->glink->contents + htab->glink->rawsize)
13160 {
13161 if (htab->opd_abi)
13162 {
13163 if (indx < 0x8000)
13164 {
13165 bfd_put_32 (htab->glink->owner, LI_R0_0 | indx, p);
13166 p += 4;
13167 }
13168 else
13169 {
13170 bfd_put_32 (htab->glink->owner, LIS_R0_0 | PPC_HI (indx), p);
13171 p += 4;
13172 bfd_put_32 (htab->glink->owner, ORI_R0_R0_0 | PPC_LO (indx),
13173 p);
13174 p += 4;
13175 }
13176 }
13177 bfd_put_32 (htab->glink->owner,
13178 B_DOT | ((htab->glink->contents - p + 8) & 0x3fffffc), p);
13179 indx++;
13180 p += 4;
13181 }
13182
13183 /* Build .glink global entry stubs. */
13184 if (htab->glink->size > htab->glink->rawsize)
13185 elf_link_hash_traverse (&htab->elf, build_global_entry_stubs, info);
13186 }
13187
13188 if (htab->brlt != NULL && htab->brlt->size != 0)
13189 {
13190 htab->brlt->contents = bfd_zalloc (htab->brlt->owner,
13191 htab->brlt->size);
13192 if (htab->brlt->contents == NULL)
13193 return FALSE;
13194 }
13195 if (htab->relbrlt != NULL && htab->relbrlt->size != 0)
13196 {
13197 htab->relbrlt->contents = bfd_zalloc (htab->relbrlt->owner,
13198 htab->relbrlt->size);
13199 if (htab->relbrlt->contents == NULL)
13200 return FALSE;
13201 }
13202
13203 /* Build the stubs as directed by the stub hash table. */
13204 bfd_hash_traverse (&htab->stub_hash_table, ppc_build_one_stub, info);
13205
13206 for (group = htab->group; group != NULL; group = group->next)
13207 if (group->needs_save_res)
13208 {
13209 stub_sec = group->stub_sec;
13210 memcpy (stub_sec->contents + stub_sec->size, htab->sfpr->contents,
13211 htab->sfpr->size);
13212 if (htab->params->emit_stub_syms)
13213 {
13214 unsigned int i;
13215
13216 for (i = 0; i < ARRAY_SIZE (save_res_funcs); i++)
13217 if (!sfpr_define (info, &save_res_funcs[i], stub_sec))
13218 return FALSE;
13219 }
13220 stub_sec->size += htab->sfpr->size;
13221 }
13222
13223 if (htab->relbrlt != NULL)
13224 htab->relbrlt->reloc_count = 0;
13225
13226 if (htab->params->plt_stub_align != 0)
13227 for (stub_sec = htab->params->stub_bfd->sections;
13228 stub_sec != NULL;
13229 stub_sec = stub_sec->next)
13230 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
13231 stub_sec->size = ((stub_sec->size
13232 + (1 << htab->params->plt_stub_align) - 1)
13233 & -(1 << htab->params->plt_stub_align));
13234
13235 for (stub_sec = htab->params->stub_bfd->sections;
13236 stub_sec != NULL;
13237 stub_sec = stub_sec->next)
13238 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
13239 {
13240 stub_sec_count += 1;
13241 if (stub_sec->rawsize != stub_sec->size
13242 && (htab->stub_iteration <= STUB_SHRINK_ITER
13243 || stub_sec->rawsize < stub_sec->size))
13244 break;
13245 }
13246
13247 /* Note that the glink_eh_frame check here is not only testing that
13248 the generated size matched the calculated size but also that
13249 bfd_elf_discard_info didn't make any changes to the section. */
13250 if (stub_sec != NULL
13251 || (htab->glink_eh_frame != NULL
13252 && htab->glink_eh_frame->rawsize != htab->glink_eh_frame->size))
13253 {
13254 htab->stub_error = TRUE;
13255 info->callbacks->einfo (_("%P: stubs don't match calculated size\n"));
13256 }
13257
13258 if (htab->stub_error)
13259 return FALSE;
13260
13261 if (stats != NULL)
13262 {
13263 *stats = bfd_malloc (500);
13264 if (*stats == NULL)
13265 return FALSE;
13266
13267 sprintf (*stats, _("linker stubs in %u group%s\n"
13268 " branch %lu\n"
13269 " toc adjust %lu\n"
13270 " long branch %lu\n"
13271 " long toc adj %lu\n"
13272 " plt call %lu\n"
13273 " plt call toc %lu\n"
13274 " global entry %lu"),
13275 stub_sec_count,
13276 stub_sec_count == 1 ? "" : "s",
13277 htab->stub_count[ppc_stub_long_branch - 1],
13278 htab->stub_count[ppc_stub_long_branch_r2off - 1],
13279 htab->stub_count[ppc_stub_plt_branch - 1],
13280 htab->stub_count[ppc_stub_plt_branch_r2off - 1],
13281 htab->stub_count[ppc_stub_plt_call - 1],
13282 htab->stub_count[ppc_stub_plt_call_r2save - 1],
13283 htab->stub_count[ppc_stub_global_entry - 1]);
13284 }
13285 return TRUE;
13286 }
13287
13288 /* What to do when ld finds relocations against symbols defined in
13289 discarded sections. */
13290
13291 static unsigned int
13292 ppc64_elf_action_discarded (asection *sec)
13293 {
13294 if (strcmp (".opd", sec->name) == 0)
13295 return 0;
13296
13297 if (strcmp (".toc", sec->name) == 0)
13298 return 0;
13299
13300 if (strcmp (".toc1", sec->name) == 0)
13301 return 0;
13302
13303 return _bfd_elf_default_action_discarded (sec);
13304 }
13305
13306 /* The RELOCATE_SECTION function is called by the ELF backend linker
13307 to handle the relocations for a section.
13308
13309 The relocs are always passed as Rela structures; if the section
13310 actually uses Rel structures, the r_addend field will always be
13311 zero.
13312
13313 This function is responsible for adjust the section contents as
13314 necessary, and (if using Rela relocs and generating a
13315 relocatable output file) adjusting the reloc addend as
13316 necessary.
13317
13318 This function does not have to worry about setting the reloc
13319 address or the reloc symbol index.
13320
13321 LOCAL_SYMS is a pointer to the swapped in local symbols.
13322
13323 LOCAL_SECTIONS is an array giving the section in the input file
13324 corresponding to the st_shndx field of each local symbol.
13325
13326 The global hash table entry for the global symbols can be found
13327 via elf_sym_hashes (input_bfd).
13328
13329 When generating relocatable output, this function must handle
13330 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
13331 going to be the section symbol corresponding to the output
13332 section, which means that the addend must be adjusted
13333 accordingly. */
13334
13335 static bfd_boolean
13336 ppc64_elf_relocate_section (bfd *output_bfd,
13337 struct bfd_link_info *info,
13338 bfd *input_bfd,
13339 asection *input_section,
13340 bfd_byte *contents,
13341 Elf_Internal_Rela *relocs,
13342 Elf_Internal_Sym *local_syms,
13343 asection **local_sections)
13344 {
13345 struct ppc_link_hash_table *htab;
13346 Elf_Internal_Shdr *symtab_hdr;
13347 struct elf_link_hash_entry **sym_hashes;
13348 Elf_Internal_Rela *rel;
13349 Elf_Internal_Rela *wrel;
13350 Elf_Internal_Rela *relend;
13351 Elf_Internal_Rela outrel;
13352 bfd_byte *loc;
13353 struct got_entry **local_got_ents;
13354 bfd_vma TOCstart;
13355 bfd_boolean ret = TRUE;
13356 bfd_boolean is_opd;
13357 /* Assume 'at' branch hints. */
13358 bfd_boolean is_isa_v2 = TRUE;
13359 bfd_vma d_offset = (bfd_big_endian (input_bfd) ? 2 : 0);
13360
13361 /* Initialize howto table if needed. */
13362 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
13363 ppc_howto_init ();
13364
13365 htab = ppc_hash_table (info);
13366 if (htab == NULL)
13367 return FALSE;
13368
13369 /* Don't relocate stub sections. */
13370 if (input_section->owner == htab->params->stub_bfd)
13371 return TRUE;
13372
13373 BFD_ASSERT (is_ppc64_elf (input_bfd));
13374
13375 local_got_ents = elf_local_got_ents (input_bfd);
13376 TOCstart = elf_gp (output_bfd);
13377 symtab_hdr = &elf_symtab_hdr (input_bfd);
13378 sym_hashes = elf_sym_hashes (input_bfd);
13379 is_opd = ppc64_elf_section_data (input_section)->sec_type == sec_opd;
13380
13381 rel = wrel = relocs;
13382 relend = relocs + input_section->reloc_count;
13383 for (; rel < relend; wrel++, rel++)
13384 {
13385 enum elf_ppc64_reloc_type r_type;
13386 bfd_vma addend;
13387 bfd_reloc_status_type r;
13388 Elf_Internal_Sym *sym;
13389 asection *sec;
13390 struct elf_link_hash_entry *h_elf;
13391 struct ppc_link_hash_entry *h;
13392 struct ppc_link_hash_entry *fdh;
13393 const char *sym_name;
13394 unsigned long r_symndx, toc_symndx;
13395 bfd_vma toc_addend;
13396 unsigned char tls_mask, tls_gd, tls_type;
13397 unsigned char sym_type;
13398 bfd_vma relocation;
13399 bfd_boolean unresolved_reloc;
13400 bfd_boolean warned;
13401 enum { DEST_NORMAL, DEST_OPD, DEST_STUB } reloc_dest;
13402 unsigned int insn;
13403 unsigned int mask;
13404 struct ppc_stub_hash_entry *stub_entry;
13405 bfd_vma max_br_offset;
13406 bfd_vma from;
13407 Elf_Internal_Rela orig_rel;
13408 reloc_howto_type *howto;
13409 struct reloc_howto_struct alt_howto;
13410
13411 again:
13412 orig_rel = *rel;
13413
13414 r_type = ELF64_R_TYPE (rel->r_info);
13415 r_symndx = ELF64_R_SYM (rel->r_info);
13416
13417 /* For old style R_PPC64_TOC relocs with a zero symbol, use the
13418 symbol of the previous ADDR64 reloc. The symbol gives us the
13419 proper TOC base to use. */
13420 if (rel->r_info == ELF64_R_INFO (0, R_PPC64_TOC)
13421 && wrel != relocs
13422 && ELF64_R_TYPE (wrel[-1].r_info) == R_PPC64_ADDR64
13423 && is_opd)
13424 r_symndx = ELF64_R_SYM (wrel[-1].r_info);
13425
13426 sym = NULL;
13427 sec = NULL;
13428 h_elf = NULL;
13429 sym_name = NULL;
13430 unresolved_reloc = FALSE;
13431 warned = FALSE;
13432
13433 if (r_symndx < symtab_hdr->sh_info)
13434 {
13435 /* It's a local symbol. */
13436 struct _opd_sec_data *opd;
13437
13438 sym = local_syms + r_symndx;
13439 sec = local_sections[r_symndx];
13440 sym_name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym, sec);
13441 sym_type = ELF64_ST_TYPE (sym->st_info);
13442 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
13443 opd = get_opd_info (sec);
13444 if (opd != NULL && opd->adjust != NULL)
13445 {
13446 long adjust = opd->adjust[OPD_NDX (sym->st_value
13447 + rel->r_addend)];
13448 if (adjust == -1)
13449 relocation = 0;
13450 else
13451 {
13452 /* If this is a relocation against the opd section sym
13453 and we have edited .opd, adjust the reloc addend so
13454 that ld -r and ld --emit-relocs output is correct.
13455 If it is a reloc against some other .opd symbol,
13456 then the symbol value will be adjusted later. */
13457 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
13458 rel->r_addend += adjust;
13459 else
13460 relocation += adjust;
13461 }
13462 }
13463 }
13464 else
13465 {
13466 bfd_boolean ignored;
13467
13468 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
13469 r_symndx, symtab_hdr, sym_hashes,
13470 h_elf, sec, relocation,
13471 unresolved_reloc, warned, ignored);
13472 sym_name = h_elf->root.root.string;
13473 sym_type = h_elf->type;
13474 if (sec != NULL
13475 && sec->owner == output_bfd
13476 && strcmp (sec->name, ".opd") == 0)
13477 {
13478 /* This is a symbol defined in a linker script. All
13479 such are defined in output sections, even those
13480 defined by simple assignment from a symbol defined in
13481 an input section. Transfer the symbol to an
13482 appropriate input .opd section, so that a branch to
13483 this symbol will be mapped to the location specified
13484 by the opd entry. */
13485 struct bfd_link_order *lo;
13486 for (lo = sec->map_head.link_order; lo != NULL; lo = lo->next)
13487 if (lo->type == bfd_indirect_link_order)
13488 {
13489 asection *isec = lo->u.indirect.section;
13490 if (h_elf->root.u.def.value >= isec->output_offset
13491 && h_elf->root.u.def.value < (isec->output_offset
13492 + isec->size))
13493 {
13494 h_elf->root.u.def.value -= isec->output_offset;
13495 h_elf->root.u.def.section = isec;
13496 sec = isec;
13497 break;
13498 }
13499 }
13500 }
13501 }
13502 h = (struct ppc_link_hash_entry *) h_elf;
13503
13504 if (sec != NULL && discarded_section (sec))
13505 {
13506 _bfd_clear_contents (ppc64_elf_howto_table[r_type],
13507 input_bfd, input_section,
13508 contents + rel->r_offset);
13509 wrel->r_offset = rel->r_offset;
13510 wrel->r_info = 0;
13511 wrel->r_addend = 0;
13512
13513 /* For ld -r, remove relocations in debug sections against
13514 sections defined in discarded sections. Not done for
13515 non-debug to preserve relocs in .eh_frame which the
13516 eh_frame editing code expects to be present. */
13517 if (bfd_link_relocatable (info)
13518 && (input_section->flags & SEC_DEBUGGING))
13519 wrel--;
13520
13521 continue;
13522 }
13523
13524 if (bfd_link_relocatable (info))
13525 goto copy_reloc;
13526
13527 if (h != NULL && &h->elf == htab->elf.hgot)
13528 {
13529 relocation = TOCstart + htab->sec_info[input_section->id].toc_off;
13530 sec = bfd_abs_section_ptr;
13531 unresolved_reloc = FALSE;
13532 }
13533
13534 /* TLS optimizations. Replace instruction sequences and relocs
13535 based on information we collected in tls_optimize. We edit
13536 RELOCS so that --emit-relocs will output something sensible
13537 for the final instruction stream. */
13538 tls_mask = 0;
13539 tls_gd = 0;
13540 toc_symndx = 0;
13541 if (h != NULL)
13542 tls_mask = h->tls_mask;
13543 else if (local_got_ents != NULL)
13544 {
13545 struct plt_entry **local_plt = (struct plt_entry **)
13546 (local_got_ents + symtab_hdr->sh_info);
13547 unsigned char *lgot_masks = (unsigned char *)
13548 (local_plt + symtab_hdr->sh_info);
13549 tls_mask = lgot_masks[r_symndx];
13550 }
13551 if (tls_mask == 0
13552 && (r_type == R_PPC64_TLS
13553 || r_type == R_PPC64_TLSGD
13554 || r_type == R_PPC64_TLSLD))
13555 {
13556 /* Check for toc tls entries. */
13557 unsigned char *toc_tls;
13558
13559 if (!get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
13560 &local_syms, rel, input_bfd))
13561 return FALSE;
13562
13563 if (toc_tls)
13564 tls_mask = *toc_tls;
13565 }
13566
13567 /* Check that tls relocs are used with tls syms, and non-tls
13568 relocs are used with non-tls syms. */
13569 if (r_symndx != STN_UNDEF
13570 && r_type != R_PPC64_NONE
13571 && (h == NULL
13572 || h->elf.root.type == bfd_link_hash_defined
13573 || h->elf.root.type == bfd_link_hash_defweak)
13574 && (IS_PPC64_TLS_RELOC (r_type)
13575 != (sym_type == STT_TLS
13576 || (sym_type == STT_SECTION
13577 && (sec->flags & SEC_THREAD_LOCAL) != 0))))
13578 {
13579 if (tls_mask != 0
13580 && (r_type == R_PPC64_TLS
13581 || r_type == R_PPC64_TLSGD
13582 || r_type == R_PPC64_TLSLD))
13583 /* R_PPC64_TLS is OK against a symbol in the TOC. */
13584 ;
13585 else
13586 info->callbacks->einfo
13587 (!IS_PPC64_TLS_RELOC (r_type)
13588 /* xgettext:c-format */
13589 ? _("%H: %s used with TLS symbol `%T'\n")
13590 /* xgettext:c-format */
13591 : _("%H: %s used with non-TLS symbol `%T'\n"),
13592 input_bfd, input_section, rel->r_offset,
13593 ppc64_elf_howto_table[r_type]->name,
13594 sym_name);
13595 }
13596
13597 /* Ensure reloc mapping code below stays sane. */
13598 if (R_PPC64_TOC16_LO_DS != R_PPC64_TOC16_DS + 1
13599 || R_PPC64_TOC16_LO != R_PPC64_TOC16 + 1
13600 || (R_PPC64_GOT_TLSLD16 & 3) != (R_PPC64_GOT_TLSGD16 & 3)
13601 || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TLSGD16_LO & 3)
13602 || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TLSGD16_HI & 3)
13603 || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TLSGD16_HA & 3)
13604 || (R_PPC64_GOT_TLSLD16 & 3) != (R_PPC64_GOT_TPREL16_DS & 3)
13605 || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TPREL16_LO_DS & 3)
13606 || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TPREL16_HI & 3)
13607 || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TPREL16_HA & 3))
13608 abort ();
13609
13610 switch (r_type)
13611 {
13612 default:
13613 break;
13614
13615 case R_PPC64_LO_DS_OPT:
13616 insn = bfd_get_32 (input_bfd, contents + rel->r_offset - d_offset);
13617 if ((insn & (0x3f << 26)) != 58u << 26)
13618 abort ();
13619 insn += (14u << 26) - (58u << 26);
13620 bfd_put_32 (input_bfd, insn, contents + rel->r_offset - d_offset);
13621 r_type = R_PPC64_TOC16_LO;
13622 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13623 break;
13624
13625 case R_PPC64_TOC16:
13626 case R_PPC64_TOC16_LO:
13627 case R_PPC64_TOC16_DS:
13628 case R_PPC64_TOC16_LO_DS:
13629 {
13630 /* Check for toc tls entries. */
13631 unsigned char *toc_tls;
13632 int retval;
13633
13634 retval = get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
13635 &local_syms, rel, input_bfd);
13636 if (retval == 0)
13637 return FALSE;
13638
13639 if (toc_tls)
13640 {
13641 tls_mask = *toc_tls;
13642 if (r_type == R_PPC64_TOC16_DS
13643 || r_type == R_PPC64_TOC16_LO_DS)
13644 {
13645 if (tls_mask != 0
13646 && (tls_mask & (TLS_DTPREL | TLS_TPREL)) == 0)
13647 goto toctprel;
13648 }
13649 else
13650 {
13651 /* If we found a GD reloc pair, then we might be
13652 doing a GD->IE transition. */
13653 if (retval == 2)
13654 {
13655 tls_gd = TLS_TPRELGD;
13656 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13657 goto tls_ldgd_opt;
13658 }
13659 else if (retval == 3)
13660 {
13661 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13662 goto tls_ldgd_opt;
13663 }
13664 }
13665 }
13666 }
13667 break;
13668
13669 case R_PPC64_GOT_TPREL16_HI:
13670 case R_PPC64_GOT_TPREL16_HA:
13671 if (tls_mask != 0
13672 && (tls_mask & TLS_TPREL) == 0)
13673 {
13674 rel->r_offset -= d_offset;
13675 bfd_put_32 (input_bfd, NOP, contents + rel->r_offset);
13676 r_type = R_PPC64_NONE;
13677 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13678 }
13679 break;
13680
13681 case R_PPC64_GOT_TPREL16_DS:
13682 case R_PPC64_GOT_TPREL16_LO_DS:
13683 if (tls_mask != 0
13684 && (tls_mask & TLS_TPREL) == 0)
13685 {
13686 toctprel:
13687 insn = bfd_get_32 (input_bfd,
13688 contents + rel->r_offset - d_offset);
13689 insn &= 31 << 21;
13690 insn |= 0x3c0d0000; /* addis 0,13,0 */
13691 bfd_put_32 (input_bfd, insn,
13692 contents + rel->r_offset - d_offset);
13693 r_type = R_PPC64_TPREL16_HA;
13694 if (toc_symndx != 0)
13695 {
13696 rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
13697 rel->r_addend = toc_addend;
13698 /* We changed the symbol. Start over in order to
13699 get h, sym, sec etc. right. */
13700 goto again;
13701 }
13702 else
13703 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13704 }
13705 break;
13706
13707 case R_PPC64_TLS:
13708 if (tls_mask != 0
13709 && (tls_mask & TLS_TPREL) == 0)
13710 {
13711 insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
13712 insn = _bfd_elf_ppc_at_tls_transform (insn, 13);
13713 if (insn == 0)
13714 abort ();
13715 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
13716 /* Was PPC64_TLS which sits on insn boundary, now
13717 PPC64_TPREL16_LO which is at low-order half-word. */
13718 rel->r_offset += d_offset;
13719 r_type = R_PPC64_TPREL16_LO;
13720 if (toc_symndx != 0)
13721 {
13722 rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
13723 rel->r_addend = toc_addend;
13724 /* We changed the symbol. Start over in order to
13725 get h, sym, sec etc. right. */
13726 goto again;
13727 }
13728 else
13729 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13730 }
13731 break;
13732
13733 case R_PPC64_GOT_TLSGD16_HI:
13734 case R_PPC64_GOT_TLSGD16_HA:
13735 tls_gd = TLS_TPRELGD;
13736 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13737 goto tls_gdld_hi;
13738 break;
13739
13740 case R_PPC64_GOT_TLSLD16_HI:
13741 case R_PPC64_GOT_TLSLD16_HA:
13742 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13743 {
13744 tls_gdld_hi:
13745 if ((tls_mask & tls_gd) != 0)
13746 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
13747 + R_PPC64_GOT_TPREL16_DS);
13748 else
13749 {
13750 rel->r_offset -= d_offset;
13751 bfd_put_32 (input_bfd, NOP, contents + rel->r_offset);
13752 r_type = R_PPC64_NONE;
13753 }
13754 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13755 }
13756 break;
13757
13758 case R_PPC64_GOT_TLSGD16:
13759 case R_PPC64_GOT_TLSGD16_LO:
13760 tls_gd = TLS_TPRELGD;
13761 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13762 goto tls_ldgd_opt;
13763 break;
13764
13765 case R_PPC64_GOT_TLSLD16:
13766 case R_PPC64_GOT_TLSLD16_LO:
13767 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13768 {
13769 unsigned int insn1, insn2, insn3;
13770 bfd_vma offset;
13771
13772 tls_ldgd_opt:
13773 offset = (bfd_vma) -1;
13774 /* If not using the newer R_PPC64_TLSGD/LD to mark
13775 __tls_get_addr calls, we must trust that the call
13776 stays with its arg setup insns, ie. that the next
13777 reloc is the __tls_get_addr call associated with
13778 the current reloc. Edit both insns. */
13779 if (input_section->has_tls_get_addr_call
13780 && rel + 1 < relend
13781 && branch_reloc_hash_match (input_bfd, rel + 1,
13782 htab->tls_get_addr,
13783 htab->tls_get_addr_fd))
13784 offset = rel[1].r_offset;
13785 /* We read the low GOT_TLS (or TOC16) insn because we
13786 need to keep the destination reg. It may be
13787 something other than the usual r3, and moved to r3
13788 before the call by intervening code. */
13789 insn1 = bfd_get_32 (input_bfd,
13790 contents + rel->r_offset - d_offset);
13791 if ((tls_mask & tls_gd) != 0)
13792 {
13793 /* IE */
13794 insn1 &= (0x1f << 21) | (0x1f << 16);
13795 insn1 |= 58 << 26; /* ld */
13796 insn2 = 0x7c636a14; /* add 3,3,13 */
13797 if (offset != (bfd_vma) -1)
13798 rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13799 if ((tls_mask & TLS_EXPLICIT) == 0)
13800 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
13801 + R_PPC64_GOT_TPREL16_DS);
13802 else
13803 r_type += R_PPC64_TOC16_DS - R_PPC64_TOC16;
13804 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13805 }
13806 else
13807 {
13808 /* LE */
13809 insn1 &= 0x1f << 21;
13810 insn1 |= 0x3c0d0000; /* addis r,13,0 */
13811 insn2 = 0x38630000; /* addi 3,3,0 */
13812 if (tls_gd == 0)
13813 {
13814 /* Was an LD reloc. */
13815 if (toc_symndx)
13816 sec = local_sections[toc_symndx];
13817 for (r_symndx = 0;
13818 r_symndx < symtab_hdr->sh_info;
13819 r_symndx++)
13820 if (local_sections[r_symndx] == sec)
13821 break;
13822 if (r_symndx >= symtab_hdr->sh_info)
13823 r_symndx = STN_UNDEF;
13824 rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
13825 if (r_symndx != STN_UNDEF)
13826 rel->r_addend -= (local_syms[r_symndx].st_value
13827 + sec->output_offset
13828 + sec->output_section->vma);
13829 }
13830 else if (toc_symndx != 0)
13831 {
13832 r_symndx = toc_symndx;
13833 rel->r_addend = toc_addend;
13834 }
13835 r_type = R_PPC64_TPREL16_HA;
13836 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13837 if (offset != (bfd_vma) -1)
13838 {
13839 rel[1].r_info = ELF64_R_INFO (r_symndx,
13840 R_PPC64_TPREL16_LO);
13841 rel[1].r_offset = offset + d_offset;
13842 rel[1].r_addend = rel->r_addend;
13843 }
13844 }
13845 bfd_put_32 (input_bfd, insn1,
13846 contents + rel->r_offset - d_offset);
13847 if (offset != (bfd_vma) -1)
13848 {
13849 insn3 = bfd_get_32 (input_bfd,
13850 contents + offset + 4);
13851 if (insn3 == NOP
13852 || insn3 == CROR_151515 || insn3 == CROR_313131)
13853 {
13854 rel[1].r_offset += 4;
13855 bfd_put_32 (input_bfd, insn2, contents + offset + 4);
13856 insn2 = NOP;
13857 }
13858 bfd_put_32 (input_bfd, insn2, contents + offset);
13859 }
13860 if ((tls_mask & tls_gd) == 0
13861 && (tls_gd == 0 || toc_symndx != 0))
13862 {
13863 /* We changed the symbol. Start over in order
13864 to get h, sym, sec etc. right. */
13865 goto again;
13866 }
13867 }
13868 break;
13869
13870 case R_PPC64_TLSGD:
13871 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13872 {
13873 unsigned int insn2, insn3;
13874 bfd_vma offset = rel->r_offset;
13875
13876 if ((tls_mask & TLS_TPRELGD) != 0)
13877 {
13878 /* IE */
13879 r_type = R_PPC64_NONE;
13880 insn2 = 0x7c636a14; /* add 3,3,13 */
13881 }
13882 else
13883 {
13884 /* LE */
13885 if (toc_symndx != 0)
13886 {
13887 r_symndx = toc_symndx;
13888 rel->r_addend = toc_addend;
13889 }
13890 r_type = R_PPC64_TPREL16_LO;
13891 rel->r_offset = offset + d_offset;
13892 insn2 = 0x38630000; /* addi 3,3,0 */
13893 }
13894 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13895 /* Zap the reloc on the _tls_get_addr call too. */
13896 BFD_ASSERT (offset == rel[1].r_offset);
13897 rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13898 insn3 = bfd_get_32 (input_bfd,
13899 contents + offset + 4);
13900 if (insn3 == NOP
13901 || insn3 == CROR_151515 || insn3 == CROR_313131)
13902 {
13903 rel->r_offset += 4;
13904 bfd_put_32 (input_bfd, insn2, contents + offset + 4);
13905 insn2 = NOP;
13906 }
13907 bfd_put_32 (input_bfd, insn2, contents + offset);
13908 if ((tls_mask & TLS_TPRELGD) == 0 && toc_symndx != 0)
13909 goto again;
13910 }
13911 break;
13912
13913 case R_PPC64_TLSLD:
13914 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13915 {
13916 unsigned int insn2, insn3;
13917 bfd_vma offset = rel->r_offset;
13918
13919 if (toc_symndx)
13920 sec = local_sections[toc_symndx];
13921 for (r_symndx = 0;
13922 r_symndx < symtab_hdr->sh_info;
13923 r_symndx++)
13924 if (local_sections[r_symndx] == sec)
13925 break;
13926 if (r_symndx >= symtab_hdr->sh_info)
13927 r_symndx = STN_UNDEF;
13928 rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
13929 if (r_symndx != STN_UNDEF)
13930 rel->r_addend -= (local_syms[r_symndx].st_value
13931 + sec->output_offset
13932 + sec->output_section->vma);
13933
13934 r_type = R_PPC64_TPREL16_LO;
13935 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13936 rel->r_offset = offset + d_offset;
13937 /* Zap the reloc on the _tls_get_addr call too. */
13938 BFD_ASSERT (offset == rel[1].r_offset);
13939 rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13940 insn2 = 0x38630000; /* addi 3,3,0 */
13941 insn3 = bfd_get_32 (input_bfd,
13942 contents + offset + 4);
13943 if (insn3 == NOP
13944 || insn3 == CROR_151515 || insn3 == CROR_313131)
13945 {
13946 rel->r_offset += 4;
13947 bfd_put_32 (input_bfd, insn2, contents + offset + 4);
13948 insn2 = NOP;
13949 }
13950 bfd_put_32 (input_bfd, insn2, contents + offset);
13951 goto again;
13952 }
13953 break;
13954
13955 case R_PPC64_DTPMOD64:
13956 if (rel + 1 < relend
13957 && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
13958 && rel[1].r_offset == rel->r_offset + 8)
13959 {
13960 if ((tls_mask & TLS_GD) == 0)
13961 {
13962 rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_NONE);
13963 if ((tls_mask & TLS_TPRELGD) != 0)
13964 r_type = R_PPC64_TPREL64;
13965 else
13966 {
13967 bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
13968 r_type = R_PPC64_NONE;
13969 }
13970 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13971 }
13972 }
13973 else
13974 {
13975 if ((tls_mask & TLS_LD) == 0)
13976 {
13977 bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
13978 r_type = R_PPC64_NONE;
13979 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13980 }
13981 }
13982 break;
13983
13984 case R_PPC64_TPREL64:
13985 if ((tls_mask & TLS_TPREL) == 0)
13986 {
13987 r_type = R_PPC64_NONE;
13988 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13989 }
13990 break;
13991
13992 case R_PPC64_ENTRY:
13993 relocation = TOCstart + htab->sec_info[input_section->id].toc_off;
13994 if (!bfd_link_pic (info)
13995 && !info->traditional_format
13996 && relocation + 0x80008000 <= 0xffffffff)
13997 {
13998 unsigned int insn1, insn2;
13999
14000 insn1 = bfd_get_32 (input_bfd, contents + rel->r_offset);
14001 insn2 = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
14002 if ((insn1 & ~0xfffc) == LD_R2_0R12
14003 && insn2 == ADD_R2_R2_R12)
14004 {
14005 bfd_put_32 (input_bfd,
14006 LIS_R2 + PPC_HA (relocation),
14007 contents + rel->r_offset);
14008 bfd_put_32 (input_bfd,
14009 ADDI_R2_R2 + PPC_LO (relocation),
14010 contents + rel->r_offset + 4);
14011 }
14012 }
14013 else
14014 {
14015 relocation -= (rel->r_offset
14016 + input_section->output_offset
14017 + input_section->output_section->vma);
14018 if (relocation + 0x80008000 <= 0xffffffff)
14019 {
14020 unsigned int insn1, insn2;
14021
14022 insn1 = bfd_get_32 (input_bfd, contents + rel->r_offset);
14023 insn2 = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
14024 if ((insn1 & ~0xfffc) == LD_R2_0R12
14025 && insn2 == ADD_R2_R2_R12)
14026 {
14027 bfd_put_32 (input_bfd,
14028 ADDIS_R2_R12 + PPC_HA (relocation),
14029 contents + rel->r_offset);
14030 bfd_put_32 (input_bfd,
14031 ADDI_R2_R2 + PPC_LO (relocation),
14032 contents + rel->r_offset + 4);
14033 }
14034 }
14035 }
14036 break;
14037
14038 case R_PPC64_REL16_HA:
14039 /* If we are generating a non-PIC executable, edit
14040 . 0: addis 2,12,.TOC.-0b@ha
14041 . addi 2,2,.TOC.-0b@l
14042 used by ELFv2 global entry points to set up r2, to
14043 . lis 2,.TOC.@ha
14044 . addi 2,2,.TOC.@l
14045 if .TOC. is in range. */
14046 if (!bfd_link_pic (info)
14047 && !info->traditional_format
14048 && !htab->opd_abi
14049 && rel->r_addend == d_offset
14050 && h != NULL && &h->elf == htab->elf.hgot
14051 && rel + 1 < relend
14052 && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_REL16_LO)
14053 && rel[1].r_offset == rel->r_offset + 4
14054 && rel[1].r_addend == rel->r_addend + 4
14055 && relocation + 0x80008000 <= 0xffffffff)
14056 {
14057 unsigned int insn1, insn2;
14058 bfd_vma offset = rel->r_offset - d_offset;
14059 insn1 = bfd_get_32 (input_bfd, contents + offset);
14060 insn2 = bfd_get_32 (input_bfd, contents + offset + 4);
14061 if ((insn1 & 0xffff0000) == ADDIS_R2_R12
14062 && (insn2 & 0xffff0000) == ADDI_R2_R2)
14063 {
14064 r_type = R_PPC64_ADDR16_HA;
14065 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14066 rel->r_addend -= d_offset;
14067 rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_ADDR16_LO);
14068 rel[1].r_addend -= d_offset + 4;
14069 bfd_put_32 (input_bfd, LIS_R2, contents + offset);
14070 }
14071 }
14072 break;
14073 }
14074
14075 /* Handle other relocations that tweak non-addend part of insn. */
14076 insn = 0;
14077 max_br_offset = 1 << 25;
14078 addend = rel->r_addend;
14079 reloc_dest = DEST_NORMAL;
14080 switch (r_type)
14081 {
14082 default:
14083 break;
14084
14085 case R_PPC64_TOCSAVE:
14086 if (relocation + addend == (rel->r_offset
14087 + input_section->output_offset
14088 + input_section->output_section->vma)
14089 && tocsave_find (htab, NO_INSERT,
14090 &local_syms, rel, input_bfd))
14091 {
14092 insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
14093 if (insn == NOP
14094 || insn == CROR_151515 || insn == CROR_313131)
14095 bfd_put_32 (input_bfd,
14096 STD_R2_0R1 + STK_TOC (htab),
14097 contents + rel->r_offset);
14098 }
14099 break;
14100
14101 /* Branch taken prediction relocations. */
14102 case R_PPC64_ADDR14_BRTAKEN:
14103 case R_PPC64_REL14_BRTAKEN:
14104 insn = 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field. */
14105 /* Fall through. */
14106
14107 /* Branch not taken prediction relocations. */
14108 case R_PPC64_ADDR14_BRNTAKEN:
14109 case R_PPC64_REL14_BRNTAKEN:
14110 insn |= bfd_get_32 (input_bfd,
14111 contents + rel->r_offset) & ~(0x01 << 21);
14112 /* Fall through. */
14113
14114 case R_PPC64_REL14:
14115 max_br_offset = 1 << 15;
14116 /* Fall through. */
14117
14118 case R_PPC64_REL24:
14119 /* Calls to functions with a different TOC, such as calls to
14120 shared objects, need to alter the TOC pointer. This is
14121 done using a linkage stub. A REL24 branching to these
14122 linkage stubs needs to be followed by a nop, as the nop
14123 will be replaced with an instruction to restore the TOC
14124 base pointer. */
14125 fdh = h;
14126 if (h != NULL
14127 && h->oh != NULL
14128 && h->oh->is_func_descriptor)
14129 fdh = ppc_follow_link (h->oh);
14130 stub_entry = ppc_get_stub_entry (input_section, sec, fdh, &orig_rel,
14131 htab);
14132 if (stub_entry != NULL
14133 && (stub_entry->stub_type == ppc_stub_plt_call
14134 || stub_entry->stub_type == ppc_stub_plt_call_r2save
14135 || stub_entry->stub_type == ppc_stub_plt_branch_r2off
14136 || stub_entry->stub_type == ppc_stub_long_branch_r2off))
14137 {
14138 bfd_boolean can_plt_call = FALSE;
14139
14140 /* All of these stubs will modify r2, so there must be a
14141 branch and link followed by a nop. The nop is
14142 replaced by an insn to restore r2. */
14143 if (rel->r_offset + 8 <= input_section->size)
14144 {
14145 unsigned long br;
14146
14147 br = bfd_get_32 (input_bfd,
14148 contents + rel->r_offset);
14149 if ((br & 1) != 0)
14150 {
14151 unsigned long nop;
14152
14153 nop = bfd_get_32 (input_bfd,
14154 contents + rel->r_offset + 4);
14155 if (nop == NOP
14156 || nop == CROR_151515 || nop == CROR_313131)
14157 {
14158 if (h != NULL
14159 && (h == htab->tls_get_addr_fd
14160 || h == htab->tls_get_addr)
14161 && htab->params->tls_get_addr_opt)
14162 {
14163 /* Special stub used, leave nop alone. */
14164 }
14165 else
14166 bfd_put_32 (input_bfd,
14167 LD_R2_0R1 + STK_TOC (htab),
14168 contents + rel->r_offset + 4);
14169 can_plt_call = TRUE;
14170 }
14171 }
14172 }
14173
14174 if (!can_plt_call && h != NULL)
14175 {
14176 const char *name = h->elf.root.root.string;
14177
14178 if (*name == '.')
14179 ++name;
14180
14181 if (strncmp (name, "__libc_start_main", 17) == 0
14182 && (name[17] == 0 || name[17] == '@'))
14183 {
14184 /* Allow crt1 branch to go via a toc adjusting
14185 stub. Other calls that never return could do
14186 the same, if we could detect such. */
14187 can_plt_call = TRUE;
14188 }
14189 }
14190
14191 if (!can_plt_call)
14192 {
14193 /* g++ as of 20130507 emits self-calls without a
14194 following nop. This is arguably wrong since we
14195 have conflicting information. On the one hand a
14196 global symbol and on the other a local call
14197 sequence, but don't error for this special case.
14198 It isn't possible to cheaply verify we have
14199 exactly such a call. Allow all calls to the same
14200 section. */
14201 asection *code_sec = sec;
14202
14203 if (get_opd_info (sec) != NULL)
14204 {
14205 bfd_vma off = (relocation + addend
14206 - sec->output_section->vma
14207 - sec->output_offset);
14208
14209 opd_entry_value (sec, off, &code_sec, NULL, FALSE);
14210 }
14211 if (code_sec == input_section)
14212 can_plt_call = TRUE;
14213 }
14214
14215 if (!can_plt_call)
14216 {
14217 if (stub_entry->stub_type == ppc_stub_plt_call
14218 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
14219 info->callbacks->einfo
14220 /* xgettext:c-format */
14221 (_("%H: call to `%T' lacks nop, can't restore toc; "
14222 "recompile with -fPIC\n"),
14223 input_bfd, input_section, rel->r_offset, sym_name);
14224 else
14225 info->callbacks->einfo
14226 /* xgettext:c-format */
14227 (_("%H: call to `%T' lacks nop, can't restore toc; "
14228 "(-mcmodel=small toc adjust stub)\n"),
14229 input_bfd, input_section, rel->r_offset, sym_name);
14230
14231 bfd_set_error (bfd_error_bad_value);
14232 ret = FALSE;
14233 }
14234
14235 if (can_plt_call
14236 && (stub_entry->stub_type == ppc_stub_plt_call
14237 || stub_entry->stub_type == ppc_stub_plt_call_r2save))
14238 unresolved_reloc = FALSE;
14239 }
14240
14241 if ((stub_entry == NULL
14242 || stub_entry->stub_type == ppc_stub_long_branch
14243 || stub_entry->stub_type == ppc_stub_plt_branch)
14244 && get_opd_info (sec) != NULL)
14245 {
14246 /* The branch destination is the value of the opd entry. */
14247 bfd_vma off = (relocation + addend
14248 - sec->output_section->vma
14249 - sec->output_offset);
14250 bfd_vma dest = opd_entry_value (sec, off, NULL, NULL, FALSE);
14251 if (dest != (bfd_vma) -1)
14252 {
14253 relocation = dest;
14254 addend = 0;
14255 reloc_dest = DEST_OPD;
14256 }
14257 }
14258
14259 /* If the branch is out of reach we ought to have a long
14260 branch stub. */
14261 from = (rel->r_offset
14262 + input_section->output_offset
14263 + input_section->output_section->vma);
14264
14265 relocation += PPC64_LOCAL_ENTRY_OFFSET (fdh
14266 ? fdh->elf.other
14267 : sym->st_other);
14268
14269 if (stub_entry != NULL
14270 && (stub_entry->stub_type == ppc_stub_long_branch
14271 || stub_entry->stub_type == ppc_stub_plt_branch)
14272 && (r_type == R_PPC64_ADDR14_BRTAKEN
14273 || r_type == R_PPC64_ADDR14_BRNTAKEN
14274 || (relocation + addend - from + max_br_offset
14275 < 2 * max_br_offset)))
14276 /* Don't use the stub if this branch is in range. */
14277 stub_entry = NULL;
14278
14279 if (stub_entry != NULL)
14280 {
14281 /* Munge up the value and addend so that we call the stub
14282 rather than the procedure directly. */
14283 asection *stub_sec = stub_entry->group->stub_sec;
14284
14285 if (stub_entry->stub_type == ppc_stub_save_res)
14286 relocation += (stub_sec->output_offset
14287 + stub_sec->output_section->vma
14288 + stub_sec->size - htab->sfpr->size
14289 - htab->sfpr->output_offset
14290 - htab->sfpr->output_section->vma);
14291 else
14292 relocation = (stub_entry->stub_offset
14293 + stub_sec->output_offset
14294 + stub_sec->output_section->vma);
14295 addend = 0;
14296 reloc_dest = DEST_STUB;
14297
14298 if ((stub_entry->stub_type == ppc_stub_plt_call
14299 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
14300 && (ALWAYS_EMIT_R2SAVE
14301 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
14302 && rel + 1 < relend
14303 && rel[1].r_offset == rel->r_offset + 4
14304 && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOCSAVE)
14305 relocation += 4;
14306 }
14307
14308 if (insn != 0)
14309 {
14310 if (is_isa_v2)
14311 {
14312 /* Set 'a' bit. This is 0b00010 in BO field for branch
14313 on CR(BI) insns (BO == 001at or 011at), and 0b01000
14314 for branch on CTR insns (BO == 1a00t or 1a01t). */
14315 if ((insn & (0x14 << 21)) == (0x04 << 21))
14316 insn |= 0x02 << 21;
14317 else if ((insn & (0x14 << 21)) == (0x10 << 21))
14318 insn |= 0x08 << 21;
14319 else
14320 break;
14321 }
14322 else
14323 {
14324 /* Invert 'y' bit if not the default. */
14325 if ((bfd_signed_vma) (relocation + addend - from) < 0)
14326 insn ^= 0x01 << 21;
14327 }
14328
14329 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
14330 }
14331
14332 /* NOP out calls to undefined weak functions.
14333 We can thus call a weak function without first
14334 checking whether the function is defined. */
14335 else if (h != NULL
14336 && h->elf.root.type == bfd_link_hash_undefweak
14337 && h->elf.dynindx == -1
14338 && r_type == R_PPC64_REL24
14339 && relocation == 0
14340 && addend == 0)
14341 {
14342 bfd_put_32 (input_bfd, NOP, contents + rel->r_offset);
14343 goto copy_reloc;
14344 }
14345 break;
14346 }
14347
14348 /* Set `addend'. */
14349 tls_type = 0;
14350 switch (r_type)
14351 {
14352 default:
14353 info->callbacks->einfo
14354 /* xgettext:c-format */
14355 (_("%P: %B: unknown relocation type %d for `%T'\n"),
14356 input_bfd, (int) r_type, sym_name);
14357
14358 bfd_set_error (bfd_error_bad_value);
14359 ret = FALSE;
14360 goto copy_reloc;
14361
14362 case R_PPC64_NONE:
14363 case R_PPC64_TLS:
14364 case R_PPC64_TLSGD:
14365 case R_PPC64_TLSLD:
14366 case R_PPC64_TOCSAVE:
14367 case R_PPC64_GNU_VTINHERIT:
14368 case R_PPC64_GNU_VTENTRY:
14369 case R_PPC64_ENTRY:
14370 goto copy_reloc;
14371
14372 /* GOT16 relocations. Like an ADDR16 using the symbol's
14373 address in the GOT as relocation value instead of the
14374 symbol's value itself. Also, create a GOT entry for the
14375 symbol and put the symbol value there. */
14376 case R_PPC64_GOT_TLSGD16:
14377 case R_PPC64_GOT_TLSGD16_LO:
14378 case R_PPC64_GOT_TLSGD16_HI:
14379 case R_PPC64_GOT_TLSGD16_HA:
14380 tls_type = TLS_TLS | TLS_GD;
14381 goto dogot;
14382
14383 case R_PPC64_GOT_TLSLD16:
14384 case R_PPC64_GOT_TLSLD16_LO:
14385 case R_PPC64_GOT_TLSLD16_HI:
14386 case R_PPC64_GOT_TLSLD16_HA:
14387 tls_type = TLS_TLS | TLS_LD;
14388 goto dogot;
14389
14390 case R_PPC64_GOT_TPREL16_DS:
14391 case R_PPC64_GOT_TPREL16_LO_DS:
14392 case R_PPC64_GOT_TPREL16_HI:
14393 case R_PPC64_GOT_TPREL16_HA:
14394 tls_type = TLS_TLS | TLS_TPREL;
14395 goto dogot;
14396
14397 case R_PPC64_GOT_DTPREL16_DS:
14398 case R_PPC64_GOT_DTPREL16_LO_DS:
14399 case R_PPC64_GOT_DTPREL16_HI:
14400 case R_PPC64_GOT_DTPREL16_HA:
14401 tls_type = TLS_TLS | TLS_DTPREL;
14402 goto dogot;
14403
14404 case R_PPC64_GOT16:
14405 case R_PPC64_GOT16_LO:
14406 case R_PPC64_GOT16_HI:
14407 case R_PPC64_GOT16_HA:
14408 case R_PPC64_GOT16_DS:
14409 case R_PPC64_GOT16_LO_DS:
14410 dogot:
14411 {
14412 /* Relocation is to the entry for this symbol in the global
14413 offset table. */
14414 asection *got;
14415 bfd_vma *offp;
14416 bfd_vma off;
14417 unsigned long indx = 0;
14418 struct got_entry *ent;
14419
14420 if (tls_type == (TLS_TLS | TLS_LD)
14421 && (h == NULL
14422 || !h->elf.def_dynamic))
14423 ent = ppc64_tlsld_got (input_bfd);
14424 else
14425 {
14426 if (h != NULL)
14427 {
14428 if (!htab->elf.dynamic_sections_created
14429 || h->elf.dynindx == -1
14430 || SYMBOL_REFERENCES_LOCAL (info, &h->elf)
14431 || (ELF_ST_VISIBILITY (h->elf.other) != STV_DEFAULT
14432 && h->elf.root.type == bfd_link_hash_undefweak))
14433 /* This is actually a static link, or it is a
14434 -Bsymbolic link and the symbol is defined
14435 locally, or the symbol was forced to be local
14436 because of a version file. */
14437 ;
14438 else
14439 {
14440 indx = h->elf.dynindx;
14441 unresolved_reloc = FALSE;
14442 }
14443 ent = h->elf.got.glist;
14444 }
14445 else
14446 {
14447 if (local_got_ents == NULL)
14448 abort ();
14449 ent = local_got_ents[r_symndx];
14450 }
14451
14452 for (; ent != NULL; ent = ent->next)
14453 if (ent->addend == orig_rel.r_addend
14454 && ent->owner == input_bfd
14455 && ent->tls_type == tls_type)
14456 break;
14457 }
14458
14459 if (ent == NULL)
14460 abort ();
14461 if (ent->is_indirect)
14462 ent = ent->got.ent;
14463 offp = &ent->got.offset;
14464 got = ppc64_elf_tdata (ent->owner)->got;
14465 if (got == NULL)
14466 abort ();
14467
14468 /* The offset must always be a multiple of 8. We use the
14469 least significant bit to record whether we have already
14470 processed this entry. */
14471 off = *offp;
14472 if ((off & 1) != 0)
14473 off &= ~1;
14474 else
14475 {
14476 /* Generate relocs for the dynamic linker, except in
14477 the case of TLSLD where we'll use one entry per
14478 module. */
14479 asection *relgot;
14480 bfd_boolean ifunc;
14481
14482 *offp = off | 1;
14483 relgot = NULL;
14484 ifunc = (h != NULL
14485 ? h->elf.type == STT_GNU_IFUNC
14486 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC);
14487 if (ifunc)
14488 relgot = htab->elf.irelplt;
14489 else if (indx != 0
14490 || (bfd_link_pic (info)
14491 && (h == NULL
14492 || (ELF_ST_VISIBILITY (h->elf.other)
14493 == STV_DEFAULT)
14494 || h->elf.root.type != bfd_link_hash_undefweak
14495 || (tls_type == (TLS_TLS | TLS_LD)
14496 && !h->elf.def_dynamic))))
14497 relgot = ppc64_elf_tdata (ent->owner)->relgot;
14498 if (relgot != NULL)
14499 {
14500 outrel.r_offset = (got->output_section->vma
14501 + got->output_offset
14502 + off);
14503 outrel.r_addend = addend;
14504 if (tls_type & (TLS_LD | TLS_GD))
14505 {
14506 outrel.r_addend = 0;
14507 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPMOD64);
14508 if (tls_type == (TLS_TLS | TLS_GD))
14509 {
14510 loc = relgot->contents;
14511 loc += (relgot->reloc_count++
14512 * sizeof (Elf64_External_Rela));
14513 bfd_elf64_swap_reloca_out (output_bfd,
14514 &outrel, loc);
14515 outrel.r_offset += 8;
14516 outrel.r_addend = addend;
14517 outrel.r_info
14518 = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
14519 }
14520 }
14521 else if (tls_type == (TLS_TLS | TLS_DTPREL))
14522 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
14523 else if (tls_type == (TLS_TLS | TLS_TPREL))
14524 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_TPREL64);
14525 else if (indx != 0)
14526 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_GLOB_DAT);
14527 else
14528 {
14529 if (ifunc)
14530 outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
14531 else
14532 outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
14533
14534 /* Write the .got section contents for the sake
14535 of prelink. */
14536 loc = got->contents + off;
14537 bfd_put_64 (output_bfd, outrel.r_addend + relocation,
14538 loc);
14539 }
14540
14541 if (indx == 0 && tls_type != (TLS_TLS | TLS_LD))
14542 {
14543 outrel.r_addend += relocation;
14544 if (tls_type & (TLS_GD | TLS_DTPREL | TLS_TPREL))
14545 {
14546 if (htab->elf.tls_sec == NULL)
14547 outrel.r_addend = 0;
14548 else
14549 outrel.r_addend -= htab->elf.tls_sec->vma;
14550 }
14551 }
14552 loc = relgot->contents;
14553 loc += (relgot->reloc_count++
14554 * sizeof (Elf64_External_Rela));
14555 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
14556 }
14557
14558 /* Init the .got section contents here if we're not
14559 emitting a reloc. */
14560 else
14561 {
14562 int tlsopt
14563 = (htab->params->tls_get_addr_opt
14564 && htab->tls_get_addr_fd != NULL
14565 && htab->tls_get_addr_fd->elf.plt.plist != NULL);
14566
14567 relocation += addend;
14568 if (tls_type != 0)
14569 {
14570 if (htab->elf.tls_sec == NULL)
14571 relocation = 0;
14572 else
14573 {
14574 if (tls_type & TLS_LD)
14575 relocation = 0;
14576 else
14577 relocation -= htab->elf.tls_sec->vma + DTP_OFFSET;
14578 if ((tls_type & TLS_TPREL)
14579 || (tlsopt && !(tls_type & TLS_DTPREL)))
14580 relocation += DTP_OFFSET - TP_OFFSET;
14581 }
14582
14583 if (tls_type & (TLS_GD | TLS_LD))
14584 {
14585 bfd_put_64 (output_bfd, relocation,
14586 got->contents + off + 8);
14587 relocation = !tlsopt;
14588 }
14589 }
14590 bfd_put_64 (output_bfd, relocation,
14591 got->contents + off);
14592 }
14593 }
14594
14595 if (off >= (bfd_vma) -2)
14596 abort ();
14597
14598 relocation = got->output_section->vma + got->output_offset + off;
14599 addend = -(TOCstart + htab->sec_info[input_section->id].toc_off);
14600 }
14601 break;
14602
14603 case R_PPC64_PLT16_HA:
14604 case R_PPC64_PLT16_HI:
14605 case R_PPC64_PLT16_LO:
14606 case R_PPC64_PLT32:
14607 case R_PPC64_PLT64:
14608 /* Relocation is to the entry for this symbol in the
14609 procedure linkage table. */
14610 {
14611 struct plt_entry **plt_list = NULL;
14612 if (h != NULL)
14613 plt_list = &h->elf.plt.plist;
14614 else if (local_got_ents != NULL)
14615 {
14616 struct plt_entry **local_plt = (struct plt_entry **)
14617 (local_got_ents + symtab_hdr->sh_info);
14618 unsigned char *local_got_tls_masks = (unsigned char *)
14619 (local_plt + symtab_hdr->sh_info);
14620 if ((local_got_tls_masks[r_symndx] & PLT_IFUNC) != 0)
14621 plt_list = local_plt + r_symndx;
14622 }
14623 if (plt_list)
14624 {
14625 struct plt_entry *ent;
14626
14627 for (ent = *plt_list; ent != NULL; ent = ent->next)
14628 if (ent->plt.offset != (bfd_vma) -1
14629 && ent->addend == orig_rel.r_addend)
14630 {
14631 asection *plt;
14632
14633 plt = htab->elf.splt;
14634 if (!htab->elf.dynamic_sections_created
14635 || h == NULL
14636 || h->elf.dynindx == -1)
14637 plt = htab->elf.iplt;
14638 relocation = (plt->output_section->vma
14639 + plt->output_offset
14640 + ent->plt.offset);
14641 addend = 0;
14642 unresolved_reloc = FALSE;
14643 break;
14644 }
14645 }
14646 }
14647 break;
14648
14649 case R_PPC64_TOC:
14650 /* Relocation value is TOC base. */
14651 relocation = TOCstart;
14652 if (r_symndx == STN_UNDEF)
14653 relocation += htab->sec_info[input_section->id].toc_off;
14654 else if (unresolved_reloc)
14655 ;
14656 else if (sec != NULL && sec->id < htab->sec_info_arr_size)
14657 relocation += htab->sec_info[sec->id].toc_off;
14658 else
14659 unresolved_reloc = TRUE;
14660 goto dodyn;
14661
14662 /* TOC16 relocs. We want the offset relative to the TOC base,
14663 which is the address of the start of the TOC plus 0x8000.
14664 The TOC consists of sections .got, .toc, .tocbss, and .plt,
14665 in this order. */
14666 case R_PPC64_TOC16:
14667 case R_PPC64_TOC16_LO:
14668 case R_PPC64_TOC16_HI:
14669 case R_PPC64_TOC16_DS:
14670 case R_PPC64_TOC16_LO_DS:
14671 case R_PPC64_TOC16_HA:
14672 addend -= TOCstart + htab->sec_info[input_section->id].toc_off;
14673 break;
14674
14675 /* Relocate against the beginning of the section. */
14676 case R_PPC64_SECTOFF:
14677 case R_PPC64_SECTOFF_LO:
14678 case R_PPC64_SECTOFF_HI:
14679 case R_PPC64_SECTOFF_DS:
14680 case R_PPC64_SECTOFF_LO_DS:
14681 case R_PPC64_SECTOFF_HA:
14682 if (sec != NULL)
14683 addend -= sec->output_section->vma;
14684 break;
14685
14686 case R_PPC64_REL16:
14687 case R_PPC64_REL16_LO:
14688 case R_PPC64_REL16_HI:
14689 case R_PPC64_REL16_HA:
14690 case R_PPC64_REL16DX_HA:
14691 break;
14692
14693 case R_PPC64_REL14:
14694 case R_PPC64_REL14_BRNTAKEN:
14695 case R_PPC64_REL14_BRTAKEN:
14696 case R_PPC64_REL24:
14697 break;
14698
14699 case R_PPC64_TPREL16:
14700 case R_PPC64_TPREL16_LO:
14701 case R_PPC64_TPREL16_HI:
14702 case R_PPC64_TPREL16_HA:
14703 case R_PPC64_TPREL16_DS:
14704 case R_PPC64_TPREL16_LO_DS:
14705 case R_PPC64_TPREL16_HIGH:
14706 case R_PPC64_TPREL16_HIGHA:
14707 case R_PPC64_TPREL16_HIGHER:
14708 case R_PPC64_TPREL16_HIGHERA:
14709 case R_PPC64_TPREL16_HIGHEST:
14710 case R_PPC64_TPREL16_HIGHESTA:
14711 if (h != NULL
14712 && h->elf.root.type == bfd_link_hash_undefweak
14713 && h->elf.dynindx == -1)
14714 {
14715 /* Make this relocation against an undefined weak symbol
14716 resolve to zero. This is really just a tweak, since
14717 code using weak externs ought to check that they are
14718 defined before using them. */
14719 bfd_byte *p = contents + rel->r_offset - d_offset;
14720
14721 insn = bfd_get_32 (input_bfd, p);
14722 insn = _bfd_elf_ppc_at_tprel_transform (insn, 13);
14723 if (insn != 0)
14724 bfd_put_32 (input_bfd, insn, p);
14725 break;
14726 }
14727 if (htab->elf.tls_sec != NULL)
14728 addend -= htab->elf.tls_sec->vma + TP_OFFSET;
14729 if (bfd_link_pic (info))
14730 /* The TPREL16 relocs shouldn't really be used in shared
14731 libs as they will result in DT_TEXTREL being set, but
14732 support them anyway. */
14733 goto dodyn;
14734 break;
14735
14736 case R_PPC64_DTPREL16:
14737 case R_PPC64_DTPREL16_LO:
14738 case R_PPC64_DTPREL16_HI:
14739 case R_PPC64_DTPREL16_HA:
14740 case R_PPC64_DTPREL16_DS:
14741 case R_PPC64_DTPREL16_LO_DS:
14742 case R_PPC64_DTPREL16_HIGH:
14743 case R_PPC64_DTPREL16_HIGHA:
14744 case R_PPC64_DTPREL16_HIGHER:
14745 case R_PPC64_DTPREL16_HIGHERA:
14746 case R_PPC64_DTPREL16_HIGHEST:
14747 case R_PPC64_DTPREL16_HIGHESTA:
14748 if (htab->elf.tls_sec != NULL)
14749 addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
14750 break;
14751
14752 case R_PPC64_ADDR64_LOCAL:
14753 addend += PPC64_LOCAL_ENTRY_OFFSET (h != NULL
14754 ? h->elf.other
14755 : sym->st_other);
14756 break;
14757
14758 case R_PPC64_DTPMOD64:
14759 relocation = 1;
14760 addend = 0;
14761 goto dodyn;
14762
14763 case R_PPC64_TPREL64:
14764 if (htab->elf.tls_sec != NULL)
14765 addend -= htab->elf.tls_sec->vma + TP_OFFSET;
14766 goto dodyn;
14767
14768 case R_PPC64_DTPREL64:
14769 if (htab->elf.tls_sec != NULL)
14770 addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
14771 /* Fall through. */
14772
14773 /* Relocations that may need to be propagated if this is a
14774 dynamic object. */
14775 case R_PPC64_REL30:
14776 case R_PPC64_REL32:
14777 case R_PPC64_REL64:
14778 case R_PPC64_ADDR14:
14779 case R_PPC64_ADDR14_BRNTAKEN:
14780 case R_PPC64_ADDR14_BRTAKEN:
14781 case R_PPC64_ADDR16:
14782 case R_PPC64_ADDR16_DS:
14783 case R_PPC64_ADDR16_HA:
14784 case R_PPC64_ADDR16_HI:
14785 case R_PPC64_ADDR16_HIGH:
14786 case R_PPC64_ADDR16_HIGHA:
14787 case R_PPC64_ADDR16_HIGHER:
14788 case R_PPC64_ADDR16_HIGHERA:
14789 case R_PPC64_ADDR16_HIGHEST:
14790 case R_PPC64_ADDR16_HIGHESTA:
14791 case R_PPC64_ADDR16_LO:
14792 case R_PPC64_ADDR16_LO_DS:
14793 case R_PPC64_ADDR24:
14794 case R_PPC64_ADDR32:
14795 case R_PPC64_ADDR64:
14796 case R_PPC64_UADDR16:
14797 case R_PPC64_UADDR32:
14798 case R_PPC64_UADDR64:
14799 dodyn:
14800 if ((input_section->flags & SEC_ALLOC) == 0)
14801 break;
14802
14803 if (NO_OPD_RELOCS && is_opd)
14804 break;
14805
14806 if (bfd_link_pic (info)
14807 ? ((h == NULL
14808 || h->dyn_relocs != NULL)
14809 && ((h != NULL && pc_dynrelocs (h))
14810 || must_be_dyn_reloc (info, r_type)))
14811 : (h != NULL
14812 ? h->dyn_relocs != NULL
14813 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
14814 {
14815 bfd_boolean skip, relocate;
14816 asection *sreloc;
14817 bfd_vma out_off;
14818
14819 /* When generating a dynamic object, these relocations
14820 are copied into the output file to be resolved at run
14821 time. */
14822
14823 skip = FALSE;
14824 relocate = FALSE;
14825
14826 out_off = _bfd_elf_section_offset (output_bfd, info,
14827 input_section, rel->r_offset);
14828 if (out_off == (bfd_vma) -1)
14829 skip = TRUE;
14830 else if (out_off == (bfd_vma) -2)
14831 skip = TRUE, relocate = TRUE;
14832 out_off += (input_section->output_section->vma
14833 + input_section->output_offset);
14834 outrel.r_offset = out_off;
14835 outrel.r_addend = rel->r_addend;
14836
14837 /* Optimize unaligned reloc use. */
14838 if ((r_type == R_PPC64_ADDR64 && (out_off & 7) != 0)
14839 || (r_type == R_PPC64_UADDR64 && (out_off & 7) == 0))
14840 r_type ^= R_PPC64_ADDR64 ^ R_PPC64_UADDR64;
14841 else if ((r_type == R_PPC64_ADDR32 && (out_off & 3) != 0)
14842 || (r_type == R_PPC64_UADDR32 && (out_off & 3) == 0))
14843 r_type ^= R_PPC64_ADDR32 ^ R_PPC64_UADDR32;
14844 else if ((r_type == R_PPC64_ADDR16 && (out_off & 1) != 0)
14845 || (r_type == R_PPC64_UADDR16 && (out_off & 1) == 0))
14846 r_type ^= R_PPC64_ADDR16 ^ R_PPC64_UADDR16;
14847
14848 if (skip)
14849 memset (&outrel, 0, sizeof outrel);
14850 else if (!SYMBOL_REFERENCES_LOCAL (info, &h->elf)
14851 && !is_opd
14852 && r_type != R_PPC64_TOC)
14853 {
14854 BFD_ASSERT (h->elf.dynindx != -1);
14855 outrel.r_info = ELF64_R_INFO (h->elf.dynindx, r_type);
14856 }
14857 else
14858 {
14859 /* This symbol is local, or marked to become local,
14860 or this is an opd section reloc which must point
14861 at a local function. */
14862 outrel.r_addend += relocation;
14863 if (r_type == R_PPC64_ADDR64 || r_type == R_PPC64_TOC)
14864 {
14865 if (is_opd && h != NULL)
14866 {
14867 /* Lie about opd entries. This case occurs
14868 when building shared libraries and we
14869 reference a function in another shared
14870 lib. The same thing happens for a weak
14871 definition in an application that's
14872 overridden by a strong definition in a
14873 shared lib. (I believe this is a generic
14874 bug in binutils handling of weak syms.)
14875 In these cases we won't use the opd
14876 entry in this lib. */
14877 unresolved_reloc = FALSE;
14878 }
14879 if (!is_opd
14880 && r_type == R_PPC64_ADDR64
14881 && (h != NULL
14882 ? h->elf.type == STT_GNU_IFUNC
14883 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
14884 outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
14885 else
14886 {
14887 outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
14888
14889 /* We need to relocate .opd contents for ld.so.
14890 Prelink also wants simple and consistent rules
14891 for relocs. This make all RELATIVE relocs have
14892 *r_offset equal to r_addend. */
14893 relocate = TRUE;
14894 }
14895 }
14896 else
14897 {
14898 long indx = 0;
14899
14900 if (h != NULL
14901 ? h->elf.type == STT_GNU_IFUNC
14902 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
14903 {
14904 info->callbacks->einfo
14905 /* xgettext:c-format */
14906 (_("%H: %s for indirect "
14907 "function `%T' unsupported\n"),
14908 input_bfd, input_section, rel->r_offset,
14909 ppc64_elf_howto_table[r_type]->name,
14910 sym_name);
14911 ret = FALSE;
14912 }
14913 else if (r_symndx == STN_UNDEF || bfd_is_abs_section (sec))
14914 ;
14915 else if (sec == NULL || sec->owner == NULL)
14916 {
14917 bfd_set_error (bfd_error_bad_value);
14918 return FALSE;
14919 }
14920 else
14921 {
14922 asection *osec;
14923
14924 osec = sec->output_section;
14925 indx = elf_section_data (osec)->dynindx;
14926
14927 if (indx == 0)
14928 {
14929 if ((osec->flags & SEC_READONLY) == 0
14930 && htab->elf.data_index_section != NULL)
14931 osec = htab->elf.data_index_section;
14932 else
14933 osec = htab->elf.text_index_section;
14934 indx = elf_section_data (osec)->dynindx;
14935 }
14936 BFD_ASSERT (indx != 0);
14937
14938 /* We are turning this relocation into one
14939 against a section symbol, so subtract out
14940 the output section's address but not the
14941 offset of the input section in the output
14942 section. */
14943 outrel.r_addend -= osec->vma;
14944 }
14945
14946 outrel.r_info = ELF64_R_INFO (indx, r_type);
14947 }
14948 }
14949
14950 sreloc = elf_section_data (input_section)->sreloc;
14951 if (h != NULL
14952 ? h->elf.type == STT_GNU_IFUNC
14953 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
14954 sreloc = htab->elf.irelplt;
14955 if (sreloc == NULL)
14956 abort ();
14957
14958 if (sreloc->reloc_count * sizeof (Elf64_External_Rela)
14959 >= sreloc->size)
14960 abort ();
14961 loc = sreloc->contents;
14962 loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
14963 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
14964
14965 /* If this reloc is against an external symbol, it will
14966 be computed at runtime, so there's no need to do
14967 anything now. However, for the sake of prelink ensure
14968 that the section contents are a known value. */
14969 if (! relocate)
14970 {
14971 unresolved_reloc = FALSE;
14972 /* The value chosen here is quite arbitrary as ld.so
14973 ignores section contents except for the special
14974 case of .opd where the contents might be accessed
14975 before relocation. Choose zero, as that won't
14976 cause reloc overflow. */
14977 relocation = 0;
14978 addend = 0;
14979 /* Use *r_offset == r_addend for R_PPC64_ADDR64 relocs
14980 to improve backward compatibility with older
14981 versions of ld. */
14982 if (r_type == R_PPC64_ADDR64)
14983 addend = outrel.r_addend;
14984 /* Adjust pc_relative relocs to have zero in *r_offset. */
14985 else if (ppc64_elf_howto_table[r_type]->pc_relative)
14986 addend = outrel.r_offset;
14987 }
14988 }
14989 else if (r_type == R_PPC64_DTPMOD64
14990 && htab->params->tls_get_addr_opt
14991 && htab->tls_get_addr_fd != NULL
14992 && htab->tls_get_addr_fd->elf.plt.plist != NULL)
14993 {
14994 /* Set up for __tls_get_addr_opt stub, when this entry
14995 does not have dynamic relocs. */
14996 relocation = 0;
14997 /* Set up the next word for local dynamic. If it turns
14998 out to be global dynamic, the reloc will overwrite
14999 this value. */
15000 if (rel->r_offset + 16 <= input_section->size)
15001 bfd_put_64 (input_bfd, DTP_OFFSET - TP_OFFSET,
15002 contents + rel->r_offset + 8);
15003 }
15004 else if (r_type == R_PPC64_DTPREL64
15005 && htab->params->tls_get_addr_opt
15006 && htab->tls_get_addr_fd != NULL
15007 && htab->tls_get_addr_fd->elf.plt.plist != NULL
15008 && rel > relocs
15009 && rel[-1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPMOD64)
15010 && rel[-1].r_offset + 8 == rel->r_offset)
15011 {
15012 /* __tls_get_addr_opt stub value. */
15013 addend += DTP_OFFSET - TP_OFFSET;
15014 }
15015 break;
15016
15017 case R_PPC64_COPY:
15018 case R_PPC64_GLOB_DAT:
15019 case R_PPC64_JMP_SLOT:
15020 case R_PPC64_JMP_IREL:
15021 case R_PPC64_RELATIVE:
15022 /* We shouldn't ever see these dynamic relocs in relocatable
15023 files. */
15024 /* Fall through. */
15025
15026 case R_PPC64_PLTGOT16:
15027 case R_PPC64_PLTGOT16_DS:
15028 case R_PPC64_PLTGOT16_HA:
15029 case R_PPC64_PLTGOT16_HI:
15030 case R_PPC64_PLTGOT16_LO:
15031 case R_PPC64_PLTGOT16_LO_DS:
15032 case R_PPC64_PLTREL32:
15033 case R_PPC64_PLTREL64:
15034 /* These ones haven't been implemented yet. */
15035
15036 info->callbacks->einfo
15037 /* xgettext:c-format */
15038 (_("%P: %B: %s is not supported for `%T'\n"),
15039 input_bfd,
15040 ppc64_elf_howto_table[r_type]->name, sym_name);
15041
15042 bfd_set_error (bfd_error_invalid_operation);
15043 ret = FALSE;
15044 goto copy_reloc;
15045 }
15046
15047 /* Multi-instruction sequences that access the TOC can be
15048 optimized, eg. addis ra,r2,0; addi rb,ra,x;
15049 to nop; addi rb,r2,x; */
15050 switch (r_type)
15051 {
15052 default:
15053 break;
15054
15055 case R_PPC64_GOT_TLSLD16_HI:
15056 case R_PPC64_GOT_TLSGD16_HI:
15057 case R_PPC64_GOT_TPREL16_HI:
15058 case R_PPC64_GOT_DTPREL16_HI:
15059 case R_PPC64_GOT16_HI:
15060 case R_PPC64_TOC16_HI:
15061 /* These relocs would only be useful if building up an
15062 offset to later add to r2, perhaps in an indexed
15063 addressing mode instruction. Don't try to optimize.
15064 Unfortunately, the possibility of someone building up an
15065 offset like this or even with the HA relocs, means that
15066 we need to check the high insn when optimizing the low
15067 insn. */
15068 break;
15069
15070 case R_PPC64_GOT_TLSLD16_HA:
15071 case R_PPC64_GOT_TLSGD16_HA:
15072 case R_PPC64_GOT_TPREL16_HA:
15073 case R_PPC64_GOT_DTPREL16_HA:
15074 case R_PPC64_GOT16_HA:
15075 case R_PPC64_TOC16_HA:
15076 if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
15077 && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
15078 {
15079 bfd_byte *p = contents + (rel->r_offset & ~3);
15080 bfd_put_32 (input_bfd, NOP, p);
15081 }
15082 break;
15083
15084 case R_PPC64_GOT_TLSLD16_LO:
15085 case R_PPC64_GOT_TLSGD16_LO:
15086 case R_PPC64_GOT_TPREL16_LO_DS:
15087 case R_PPC64_GOT_DTPREL16_LO_DS:
15088 case R_PPC64_GOT16_LO:
15089 case R_PPC64_GOT16_LO_DS:
15090 case R_PPC64_TOC16_LO:
15091 case R_PPC64_TOC16_LO_DS:
15092 if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
15093 && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
15094 {
15095 bfd_byte *p = contents + (rel->r_offset & ~3);
15096 insn = bfd_get_32 (input_bfd, p);
15097 if ((insn & (0x3f << 26)) == 12u << 26 /* addic */)
15098 {
15099 /* Transform addic to addi when we change reg. */
15100 insn &= ~((0x3f << 26) | (0x1f << 16));
15101 insn |= (14u << 26) | (2 << 16);
15102 }
15103 else
15104 {
15105 insn &= ~(0x1f << 16);
15106 insn |= 2 << 16;
15107 }
15108 bfd_put_32 (input_bfd, insn, p);
15109 }
15110 break;
15111 }
15112
15113 /* Do any further special processing. */
15114 howto = ppc64_elf_howto_table[(int) r_type];
15115 switch (r_type)
15116 {
15117 default:
15118 break;
15119
15120 case R_PPC64_REL16_HA:
15121 case R_PPC64_REL16DX_HA:
15122 case R_PPC64_ADDR16_HA:
15123 case R_PPC64_ADDR16_HIGHA:
15124 case R_PPC64_ADDR16_HIGHERA:
15125 case R_PPC64_ADDR16_HIGHESTA:
15126 case R_PPC64_TOC16_HA:
15127 case R_PPC64_SECTOFF_HA:
15128 case R_PPC64_TPREL16_HA:
15129 case R_PPC64_TPREL16_HIGHA:
15130 case R_PPC64_TPREL16_HIGHERA:
15131 case R_PPC64_TPREL16_HIGHESTA:
15132 case R_PPC64_DTPREL16_HA:
15133 case R_PPC64_DTPREL16_HIGHA:
15134 case R_PPC64_DTPREL16_HIGHERA:
15135 case R_PPC64_DTPREL16_HIGHESTA:
15136 /* It's just possible that this symbol is a weak symbol
15137 that's not actually defined anywhere. In that case,
15138 'sec' would be NULL, and we should leave the symbol
15139 alone (it will be set to zero elsewhere in the link). */
15140 if (sec == NULL)
15141 break;
15142 /* Fall through. */
15143
15144 case R_PPC64_GOT16_HA:
15145 case R_PPC64_PLTGOT16_HA:
15146 case R_PPC64_PLT16_HA:
15147 case R_PPC64_GOT_TLSGD16_HA:
15148 case R_PPC64_GOT_TLSLD16_HA:
15149 case R_PPC64_GOT_TPREL16_HA:
15150 case R_PPC64_GOT_DTPREL16_HA:
15151 /* Add 0x10000 if sign bit in 0:15 is set.
15152 Bits 0:15 are not used. */
15153 addend += 0x8000;
15154 break;
15155
15156 case R_PPC64_ADDR16_DS:
15157 case R_PPC64_ADDR16_LO_DS:
15158 case R_PPC64_GOT16_DS:
15159 case R_PPC64_GOT16_LO_DS:
15160 case R_PPC64_PLT16_LO_DS:
15161 case R_PPC64_SECTOFF_DS:
15162 case R_PPC64_SECTOFF_LO_DS:
15163 case R_PPC64_TOC16_DS:
15164 case R_PPC64_TOC16_LO_DS:
15165 case R_PPC64_PLTGOT16_DS:
15166 case R_PPC64_PLTGOT16_LO_DS:
15167 case R_PPC64_GOT_TPREL16_DS:
15168 case R_PPC64_GOT_TPREL16_LO_DS:
15169 case R_PPC64_GOT_DTPREL16_DS:
15170 case R_PPC64_GOT_DTPREL16_LO_DS:
15171 case R_PPC64_TPREL16_DS:
15172 case R_PPC64_TPREL16_LO_DS:
15173 case R_PPC64_DTPREL16_DS:
15174 case R_PPC64_DTPREL16_LO_DS:
15175 insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
15176 mask = 3;
15177 /* If this reloc is against an lq, lxv, or stxv insn, then
15178 the value must be a multiple of 16. This is somewhat of
15179 a hack, but the "correct" way to do this by defining _DQ
15180 forms of all the _DS relocs bloats all reloc switches in
15181 this file. It doesn't make much sense to use these
15182 relocs in data, so testing the insn should be safe. */
15183 if ((insn & (0x3f << 26)) == (56u << 26)
15184 || ((insn & (0x3f << 26)) == (61u << 26) && (insn & 3) == 1))
15185 mask = 15;
15186 relocation += addend;
15187 addend = insn & (mask ^ 3);
15188 if ((relocation & mask) != 0)
15189 {
15190 relocation ^= relocation & mask;
15191 info->callbacks->einfo
15192 /* xgettext:c-format */
15193 (_("%H: error: %s not a multiple of %u\n"),
15194 input_bfd, input_section, rel->r_offset,
15195 howto->name,
15196 mask + 1);
15197 bfd_set_error (bfd_error_bad_value);
15198 ret = FALSE;
15199 goto copy_reloc;
15200 }
15201 break;
15202 }
15203
15204 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
15205 because such sections are not SEC_ALLOC and thus ld.so will
15206 not process them. */
15207 if (unresolved_reloc
15208 && !((input_section->flags & SEC_DEBUGGING) != 0
15209 && h->elf.def_dynamic)
15210 && _bfd_elf_section_offset (output_bfd, info, input_section,
15211 rel->r_offset) != (bfd_vma) -1)
15212 {
15213 info->callbacks->einfo
15214 /* xgettext:c-format */
15215 (_("%H: unresolvable %s against `%T'\n"),
15216 input_bfd, input_section, rel->r_offset,
15217 howto->name,
15218 h->elf.root.root.string);
15219 ret = FALSE;
15220 }
15221
15222 /* 16-bit fields in insns mostly have signed values, but a
15223 few insns have 16-bit unsigned values. Really, we should
15224 have different reloc types. */
15225 if (howto->complain_on_overflow != complain_overflow_dont
15226 && howto->dst_mask == 0xffff
15227 && (input_section->flags & SEC_CODE) != 0)
15228 {
15229 enum complain_overflow complain = complain_overflow_signed;
15230
15231 insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
15232 if ((insn & (0x3f << 26)) == 10u << 26 /* cmpli */)
15233 complain = complain_overflow_bitfield;
15234 else if (howto->rightshift == 0
15235 ? ((insn & (0x3f << 26)) == 28u << 26 /* andi */
15236 || (insn & (0x3f << 26)) == 24u << 26 /* ori */
15237 || (insn & (0x3f << 26)) == 26u << 26 /* xori */)
15238 : ((insn & (0x3f << 26)) == 29u << 26 /* andis */
15239 || (insn & (0x3f << 26)) == 25u << 26 /* oris */
15240 || (insn & (0x3f << 26)) == 27u << 26 /* xoris */))
15241 complain = complain_overflow_unsigned;
15242 if (howto->complain_on_overflow != complain)
15243 {
15244 alt_howto = *howto;
15245 alt_howto.complain_on_overflow = complain;
15246 howto = &alt_howto;
15247 }
15248 }
15249
15250 if (r_type == R_PPC64_REL16DX_HA)
15251 {
15252 /* Split field reloc isn't handled by _bfd_final_link_relocate. */
15253 if (rel->r_offset + 4 > input_section->size)
15254 r = bfd_reloc_outofrange;
15255 else
15256 {
15257 relocation += addend;
15258 relocation -= (rel->r_offset
15259 + input_section->output_offset
15260 + input_section->output_section->vma);
15261 relocation = (bfd_signed_vma) relocation >> 16;
15262 insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
15263 insn &= ~0x1fffc1;
15264 insn |= (relocation & 0xffc1) | ((relocation & 0x3e) << 15);
15265 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
15266 r = bfd_reloc_ok;
15267 if (relocation + 0x8000 > 0xffff)
15268 r = bfd_reloc_overflow;
15269 }
15270 }
15271 else
15272 r = _bfd_final_link_relocate (howto, input_bfd, input_section, contents,
15273 rel->r_offset, relocation, addend);
15274
15275 if (r != bfd_reloc_ok)
15276 {
15277 char *more_info = NULL;
15278 const char *reloc_name = howto->name;
15279
15280 if (reloc_dest != DEST_NORMAL)
15281 {
15282 more_info = bfd_malloc (strlen (reloc_name) + 8);
15283 if (more_info != NULL)
15284 {
15285 strcpy (more_info, reloc_name);
15286 strcat (more_info, (reloc_dest == DEST_OPD
15287 ? " (OPD)" : " (stub)"));
15288 reloc_name = more_info;
15289 }
15290 }
15291
15292 if (r == bfd_reloc_overflow)
15293 {
15294 /* On code like "if (foo) foo();" don't report overflow
15295 on a branch to zero when foo is undefined. */
15296 if (!warned
15297 && (reloc_dest == DEST_STUB
15298 || !(h != NULL
15299 && (h->elf.root.type == bfd_link_hash_undefweak
15300 || h->elf.root.type == bfd_link_hash_undefined)
15301 && is_branch_reloc (r_type))))
15302 info->callbacks->reloc_overflow (info, &h->elf.root,
15303 sym_name, reloc_name,
15304 orig_rel.r_addend,
15305 input_bfd, input_section,
15306 rel->r_offset);
15307 }
15308 else
15309 {
15310 info->callbacks->einfo
15311 /* xgettext:c-format */
15312 (_("%H: %s against `%T': error %d\n"),
15313 input_bfd, input_section, rel->r_offset,
15314 reloc_name, sym_name, (int) r);
15315 ret = FALSE;
15316 }
15317 if (more_info != NULL)
15318 free (more_info);
15319 }
15320 copy_reloc:
15321 if (wrel != rel)
15322 *wrel = *rel;
15323 }
15324
15325 if (wrel != rel)
15326 {
15327 Elf_Internal_Shdr *rel_hdr;
15328 size_t deleted = rel - wrel;
15329
15330 rel_hdr = _bfd_elf_single_rel_hdr (input_section->output_section);
15331 rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
15332 if (rel_hdr->sh_size == 0)
15333 {
15334 /* It is too late to remove an empty reloc section. Leave
15335 one NONE reloc.
15336 ??? What is wrong with an empty section??? */
15337 rel_hdr->sh_size = rel_hdr->sh_entsize;
15338 deleted -= 1;
15339 }
15340 rel_hdr = _bfd_elf_single_rel_hdr (input_section);
15341 rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
15342 input_section->reloc_count -= deleted;
15343 }
15344
15345 /* If we're emitting relocations, then shortly after this function
15346 returns, reloc offsets and addends for this section will be
15347 adjusted. Worse, reloc symbol indices will be for the output
15348 file rather than the input. Save a copy of the relocs for
15349 opd_entry_value. */
15350 if (is_opd && (info->emitrelocations || bfd_link_relocatable (info)))
15351 {
15352 bfd_size_type amt;
15353 amt = input_section->reloc_count * sizeof (Elf_Internal_Rela);
15354 rel = bfd_alloc (input_bfd, amt);
15355 BFD_ASSERT (ppc64_elf_tdata (input_bfd)->opd.relocs == NULL);
15356 ppc64_elf_tdata (input_bfd)->opd.relocs = rel;
15357 if (rel == NULL)
15358 return FALSE;
15359 memcpy (rel, relocs, amt);
15360 }
15361 return ret;
15362 }
15363
15364 /* Adjust the value of any local symbols in opd sections. */
15365
15366 static int
15367 ppc64_elf_output_symbol_hook (struct bfd_link_info *info,
15368 const char *name ATTRIBUTE_UNUSED,
15369 Elf_Internal_Sym *elfsym,
15370 asection *input_sec,
15371 struct elf_link_hash_entry *h)
15372 {
15373 struct _opd_sec_data *opd;
15374 long adjust;
15375 bfd_vma value;
15376
15377 if (h != NULL)
15378 return 1;
15379
15380 opd = get_opd_info (input_sec);
15381 if (opd == NULL || opd->adjust == NULL)
15382 return 1;
15383
15384 value = elfsym->st_value - input_sec->output_offset;
15385 if (!bfd_link_relocatable (info))
15386 value -= input_sec->output_section->vma;
15387
15388 adjust = opd->adjust[OPD_NDX (value)];
15389 if (adjust == -1)
15390 return 2;
15391
15392 elfsym->st_value += adjust;
15393 return 1;
15394 }
15395
15396 /* Finish up dynamic symbol handling. We set the contents of various
15397 dynamic sections here. */
15398
15399 static bfd_boolean
15400 ppc64_elf_finish_dynamic_symbol (bfd *output_bfd,
15401 struct bfd_link_info *info,
15402 struct elf_link_hash_entry *h,
15403 Elf_Internal_Sym *sym)
15404 {
15405 struct ppc_link_hash_table *htab;
15406 struct plt_entry *ent;
15407 Elf_Internal_Rela rela;
15408 bfd_byte *loc;
15409
15410 htab = ppc_hash_table (info);
15411 if (htab == NULL)
15412 return FALSE;
15413
15414 for (ent = h->plt.plist; ent != NULL; ent = ent->next)
15415 if (ent->plt.offset != (bfd_vma) -1)
15416 {
15417 /* This symbol has an entry in the procedure linkage
15418 table. Set it up. */
15419 if (!htab->elf.dynamic_sections_created
15420 || h->dynindx == -1)
15421 {
15422 BFD_ASSERT (h->type == STT_GNU_IFUNC
15423 && h->def_regular
15424 && (h->root.type == bfd_link_hash_defined
15425 || h->root.type == bfd_link_hash_defweak));
15426 rela.r_offset = (htab->elf.iplt->output_section->vma
15427 + htab->elf.iplt->output_offset
15428 + ent->plt.offset);
15429 if (htab->opd_abi)
15430 rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
15431 else
15432 rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
15433 rela.r_addend = (h->root.u.def.value
15434 + h->root.u.def.section->output_offset
15435 + h->root.u.def.section->output_section->vma
15436 + ent->addend);
15437 loc = (htab->elf.irelplt->contents
15438 + (htab->elf.irelplt->reloc_count++
15439 * sizeof (Elf64_External_Rela)));
15440 }
15441 else
15442 {
15443 rela.r_offset = (htab->elf.splt->output_section->vma
15444 + htab->elf.splt->output_offset
15445 + ent->plt.offset);
15446 rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_JMP_SLOT);
15447 rela.r_addend = ent->addend;
15448 loc = (htab->elf.srelplt->contents
15449 + ((ent->plt.offset - PLT_INITIAL_ENTRY_SIZE (htab))
15450 / PLT_ENTRY_SIZE (htab) * sizeof (Elf64_External_Rela)));
15451 }
15452 bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
15453
15454 if (!htab->opd_abi)
15455 {
15456 if (!h->def_regular)
15457 {
15458 /* Mark the symbol as undefined, rather than as
15459 defined in glink. Leave the value if there were
15460 any relocations where pointer equality matters
15461 (this is a clue for the dynamic linker, to make
15462 function pointer comparisons work between an
15463 application and shared library), otherwise set it
15464 to zero. */
15465 sym->st_shndx = SHN_UNDEF;
15466 if (!h->pointer_equality_needed)
15467 sym->st_value = 0;
15468 else if (!h->ref_regular_nonweak)
15469 {
15470 /* This breaks function pointer comparisons, but
15471 that is better than breaking tests for a NULL
15472 function pointer. */
15473 sym->st_value = 0;
15474 }
15475 }
15476 }
15477 }
15478
15479 if (h->needs_copy)
15480 {
15481 /* This symbol needs a copy reloc. Set it up. */
15482 asection *srel;
15483
15484 if (h->dynindx == -1
15485 || (h->root.type != bfd_link_hash_defined
15486 && h->root.type != bfd_link_hash_defweak)
15487 || htab->elf.srelbss == NULL
15488 || htab->elf.sreldynrelro == NULL)
15489 abort ();
15490
15491 rela.r_offset = (h->root.u.def.value
15492 + h->root.u.def.section->output_section->vma
15493 + h->root.u.def.section->output_offset);
15494 rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_COPY);
15495 rela.r_addend = 0;
15496 if (h->root.u.def.section == htab->elf.sdynrelro)
15497 srel = htab->elf.sreldynrelro;
15498 else
15499 srel = htab->elf.srelbss;
15500 loc = srel->contents;
15501 loc += srel->reloc_count++ * sizeof (Elf64_External_Rela);
15502 bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
15503 }
15504
15505 return TRUE;
15506 }
15507
15508 /* Used to decide how to sort relocs in an optimal manner for the
15509 dynamic linker, before writing them out. */
15510
15511 static enum elf_reloc_type_class
15512 ppc64_elf_reloc_type_class (const struct bfd_link_info *info,
15513 const asection *rel_sec,
15514 const Elf_Internal_Rela *rela)
15515 {
15516 enum elf_ppc64_reloc_type r_type;
15517 struct ppc_link_hash_table *htab = ppc_hash_table (info);
15518
15519 if (rel_sec == htab->elf.irelplt)
15520 return reloc_class_ifunc;
15521
15522 r_type = ELF64_R_TYPE (rela->r_info);
15523 switch (r_type)
15524 {
15525 case R_PPC64_RELATIVE:
15526 return reloc_class_relative;
15527 case R_PPC64_JMP_SLOT:
15528 return reloc_class_plt;
15529 case R_PPC64_COPY:
15530 return reloc_class_copy;
15531 default:
15532 return reloc_class_normal;
15533 }
15534 }
15535
15536 /* Finish up the dynamic sections. */
15537
15538 static bfd_boolean
15539 ppc64_elf_finish_dynamic_sections (bfd *output_bfd,
15540 struct bfd_link_info *info)
15541 {
15542 struct ppc_link_hash_table *htab;
15543 bfd *dynobj;
15544 asection *sdyn;
15545
15546 htab = ppc_hash_table (info);
15547 if (htab == NULL)
15548 return FALSE;
15549
15550 dynobj = htab->elf.dynobj;
15551 sdyn = bfd_get_linker_section (dynobj, ".dynamic");
15552
15553 if (htab->elf.dynamic_sections_created)
15554 {
15555 Elf64_External_Dyn *dyncon, *dynconend;
15556
15557 if (sdyn == NULL || htab->elf.sgot == NULL)
15558 abort ();
15559
15560 dyncon = (Elf64_External_Dyn *) sdyn->contents;
15561 dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
15562 for (; dyncon < dynconend; dyncon++)
15563 {
15564 Elf_Internal_Dyn dyn;
15565 asection *s;
15566
15567 bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
15568
15569 switch (dyn.d_tag)
15570 {
15571 default:
15572 continue;
15573
15574 case DT_PPC64_GLINK:
15575 s = htab->glink;
15576 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
15577 /* We stupidly defined DT_PPC64_GLINK to be the start
15578 of glink rather than the first entry point, which is
15579 what ld.so needs, and now have a bigger stub to
15580 support automatic multiple TOCs. */
15581 dyn.d_un.d_ptr += GLINK_CALL_STUB_SIZE - 8 * 4;
15582 break;
15583
15584 case DT_PPC64_OPD:
15585 s = bfd_get_section_by_name (output_bfd, ".opd");
15586 if (s == NULL)
15587 continue;
15588 dyn.d_un.d_ptr = s->vma;
15589 break;
15590
15591 case DT_PPC64_OPT:
15592 if (htab->do_multi_toc && htab->multi_toc_needed)
15593 dyn.d_un.d_val |= PPC64_OPT_MULTI_TOC;
15594 break;
15595
15596 case DT_PPC64_OPDSZ:
15597 s = bfd_get_section_by_name (output_bfd, ".opd");
15598 if (s == NULL)
15599 continue;
15600 dyn.d_un.d_val = s->size;
15601 break;
15602
15603 case DT_PLTGOT:
15604 s = htab->elf.splt;
15605 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
15606 break;
15607
15608 case DT_JMPREL:
15609 s = htab->elf.srelplt;
15610 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
15611 break;
15612
15613 case DT_PLTRELSZ:
15614 dyn.d_un.d_val = htab->elf.srelplt->size;
15615 break;
15616 }
15617
15618 bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
15619 }
15620 }
15621
15622 if (htab->elf.sgot != NULL && htab->elf.sgot->size != 0
15623 && htab->elf.sgot->output_section != bfd_abs_section_ptr)
15624 {
15625 /* Fill in the first entry in the global offset table.
15626 We use it to hold the link-time TOCbase. */
15627 bfd_put_64 (output_bfd,
15628 elf_gp (output_bfd) + TOC_BASE_OFF,
15629 htab->elf.sgot->contents);
15630
15631 /* Set .got entry size. */
15632 elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize = 8;
15633 }
15634
15635 if (htab->elf.splt != NULL && htab->elf.splt->size != 0
15636 && htab->elf.splt->output_section != bfd_abs_section_ptr)
15637 {
15638 /* Set .plt entry size. */
15639 elf_section_data (htab->elf.splt->output_section)->this_hdr.sh_entsize
15640 = PLT_ENTRY_SIZE (htab);
15641 }
15642
15643 /* brlt is SEC_LINKER_CREATED, so we need to write out relocs for
15644 brlt ourselves if emitrelocations. */
15645 if (htab->brlt != NULL
15646 && htab->brlt->reloc_count != 0
15647 && !_bfd_elf_link_output_relocs (output_bfd,
15648 htab->brlt,
15649 elf_section_data (htab->brlt)->rela.hdr,
15650 elf_section_data (htab->brlt)->relocs,
15651 NULL))
15652 return FALSE;
15653
15654 if (htab->glink != NULL
15655 && htab->glink->reloc_count != 0
15656 && !_bfd_elf_link_output_relocs (output_bfd,
15657 htab->glink,
15658 elf_section_data (htab->glink)->rela.hdr,
15659 elf_section_data (htab->glink)->relocs,
15660 NULL))
15661 return FALSE;
15662
15663 if (htab->glink_eh_frame != NULL
15664 && htab->glink_eh_frame->size != 0)
15665 {
15666 bfd_vma val;
15667 bfd_byte *p;
15668 asection *stub_sec;
15669 size_t align = 4;
15670
15671 p = htab->glink_eh_frame->contents;
15672 p += (sizeof (glink_eh_frame_cie) + align - 1) & -align;
15673 for (stub_sec = htab->params->stub_bfd->sections;
15674 stub_sec != NULL;
15675 stub_sec = stub_sec->next)
15676 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
15677 {
15678 /* FDE length. */
15679 p += 4;
15680 /* CIE pointer. */
15681 p += 4;
15682 /* Offset to stub section. */
15683 val = (stub_sec->output_section->vma
15684 + stub_sec->output_offset);
15685 val -= (htab->glink_eh_frame->output_section->vma
15686 + htab->glink_eh_frame->output_offset
15687 + (p - htab->glink_eh_frame->contents));
15688 if (val + 0x80000000 > 0xffffffff)
15689 {
15690 info->callbacks->einfo
15691 (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
15692 stub_sec->name);
15693 return FALSE;
15694 }
15695 bfd_put_32 (dynobj, val, p);
15696 p += 4;
15697 /* stub section size. */
15698 p += 4;
15699 /* Augmentation. */
15700 p += 1;
15701 /* Pad. */
15702 p += ((17 + align - 1) & -align) - 17;
15703 }
15704 if (htab->glink != NULL && htab->glink->size != 0)
15705 {
15706 /* FDE length. */
15707 p += 4;
15708 /* CIE pointer. */
15709 p += 4;
15710 /* Offset to .glink. */
15711 val = (htab->glink->output_section->vma
15712 + htab->glink->output_offset
15713 + 8);
15714 val -= (htab->glink_eh_frame->output_section->vma
15715 + htab->glink_eh_frame->output_offset
15716 + (p - htab->glink_eh_frame->contents));
15717 if (val + 0x80000000 > 0xffffffff)
15718 {
15719 info->callbacks->einfo
15720 (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
15721 htab->glink->name);
15722 return FALSE;
15723 }
15724 bfd_put_32 (dynobj, val, p);
15725 p += 4;
15726 /* .glink size. */
15727 p += 4;
15728 /* Augmentation. */
15729 p += 1;
15730 /* Ops. */
15731 p += 7;
15732 p += ((24 + align - 1) & -align) - 24;
15733 }
15734
15735 if (htab->glink_eh_frame->sec_info_type == SEC_INFO_TYPE_EH_FRAME
15736 && !_bfd_elf_write_section_eh_frame (output_bfd, info,
15737 htab->glink_eh_frame,
15738 htab->glink_eh_frame->contents))
15739 return FALSE;
15740 }
15741
15742 /* We need to handle writing out multiple GOT sections ourselves,
15743 since we didn't add them to DYNOBJ. We know dynobj is the first
15744 bfd. */
15745 while ((dynobj = dynobj->link.next) != NULL)
15746 {
15747 asection *s;
15748
15749 if (!is_ppc64_elf (dynobj))
15750 continue;
15751
15752 s = ppc64_elf_tdata (dynobj)->got;
15753 if (s != NULL
15754 && s->size != 0
15755 && s->output_section != bfd_abs_section_ptr
15756 && !bfd_set_section_contents (output_bfd, s->output_section,
15757 s->contents, s->output_offset,
15758 s->size))
15759 return FALSE;
15760 s = ppc64_elf_tdata (dynobj)->relgot;
15761 if (s != NULL
15762 && s->size != 0
15763 && s->output_section != bfd_abs_section_ptr
15764 && !bfd_set_section_contents (output_bfd, s->output_section,
15765 s->contents, s->output_offset,
15766 s->size))
15767 return FALSE;
15768 }
15769
15770 return TRUE;
15771 }
15772
15773 #include "elf64-target.h"
15774
15775 /* FreeBSD support */
15776
15777 #undef TARGET_LITTLE_SYM
15778 #undef TARGET_LITTLE_NAME
15779
15780 #undef TARGET_BIG_SYM
15781 #define TARGET_BIG_SYM powerpc_elf64_fbsd_vec
15782 #undef TARGET_BIG_NAME
15783 #define TARGET_BIG_NAME "elf64-powerpc-freebsd"
15784
15785 #undef ELF_OSABI
15786 #define ELF_OSABI ELFOSABI_FREEBSD
15787
15788 #undef elf64_bed
15789 #define elf64_bed elf64_powerpc_fbsd_bed
15790
15791 #include "elf64-target.h"
15792
GDB Binutils - Deliverables
This page took 0.358468 seconds and 4 git commands to generate.