projects / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
My patch to the binutils strip-10.d test was wrong. The osabi field should always...
[binutils-gdb.git] / bfd / elf64-ppc.c
1 /* PowerPC64-specific support for 64-bit ELF.
2 Copyright 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008,
3 2009, 2010, 2011, 2012 Free Software Foundation, Inc.
4 Written by Linus Nordberg, Swox AB <info@swox.com>,
5 based on elf32-ppc.c by Ian Lance Taylor.
6 Largely rewritten by Alan Modra.
7
8 This file is part of BFD, the Binary File Descriptor library.
9
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3 of the License, or
13 (at your option) any later version.
14
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
19
20 You should have received a copy of the GNU General Public License along
21 with this program; if not, write to the Free Software Foundation, Inc.,
22 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */
23
24
25 /* The 64-bit PowerPC ELF ABI may be found at
26 http://www.linuxbase.org/spec/ELF/ppc64/PPC-elf64abi.txt, and
27 http://www.linuxbase.org/spec/ELF/ppc64/spec/book1.html */
28
29 #include "sysdep.h"
30 #include <stdarg.h>
31 #include "bfd.h"
32 #include "bfdlink.h"
33 #include "libbfd.h"
34 #include "elf-bfd.h"
35 #include "elf/ppc64.h"
36 #include "elf64-ppc.h"
37 #include "dwarf2.h"
38
39 static bfd_reloc_status_type ppc64_elf_ha_reloc
40 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
41 static bfd_reloc_status_type ppc64_elf_branch_reloc
42 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
43 static bfd_reloc_status_type ppc64_elf_brtaken_reloc
44 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
45 static bfd_reloc_status_type ppc64_elf_sectoff_reloc
46 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
47 static bfd_reloc_status_type ppc64_elf_sectoff_ha_reloc
48 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
49 static bfd_reloc_status_type ppc64_elf_toc_reloc
50 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
51 static bfd_reloc_status_type ppc64_elf_toc_ha_reloc
52 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
53 static bfd_reloc_status_type ppc64_elf_toc64_reloc
54 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
55 static bfd_reloc_status_type ppc64_elf_unhandled_reloc
56 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
57 static bfd_vma opd_entry_value
58 (asection *, bfd_vma, asection **, bfd_vma *, bfd_boolean);
59
60 #define TARGET_LITTLE_SYM bfd_elf64_powerpcle_vec
61 #define TARGET_LITTLE_NAME "elf64-powerpcle"
62 #define TARGET_BIG_SYM bfd_elf64_powerpc_vec
63 #define TARGET_BIG_NAME "elf64-powerpc"
64 #define ELF_ARCH bfd_arch_powerpc
65 #define ELF_TARGET_ID PPC64_ELF_DATA
66 #define ELF_MACHINE_CODE EM_PPC64
67 #define ELF_MAXPAGESIZE 0x10000
68 #define ELF_COMMONPAGESIZE 0x1000
69 #define elf_info_to_howto ppc64_elf_info_to_howto
70
71 #define elf_backend_want_got_sym 0
72 #define elf_backend_want_plt_sym 0
73 #define elf_backend_plt_alignment 3
74 #define elf_backend_plt_not_loaded 1
75 #define elf_backend_got_header_size 8
76 #define elf_backend_can_gc_sections 1
77 #define elf_backend_can_refcount 1
78 #define elf_backend_rela_normal 1
79 #define elf_backend_default_execstack 0
80
81 #define bfd_elf64_mkobject ppc64_elf_mkobject
82 #define bfd_elf64_bfd_reloc_type_lookup ppc64_elf_reloc_type_lookup
83 #define bfd_elf64_bfd_reloc_name_lookup ppc64_elf_reloc_name_lookup
84 #define bfd_elf64_bfd_merge_private_bfd_data ppc64_elf_merge_private_bfd_data
85 #define bfd_elf64_bfd_print_private_bfd_data ppc64_elf_print_private_bfd_data
86 #define bfd_elf64_new_section_hook ppc64_elf_new_section_hook
87 #define bfd_elf64_bfd_link_hash_table_create ppc64_elf_link_hash_table_create
88 #define bfd_elf64_bfd_link_hash_table_free ppc64_elf_link_hash_table_free
89 #define bfd_elf64_get_synthetic_symtab ppc64_elf_get_synthetic_symtab
90 #define bfd_elf64_bfd_link_just_syms ppc64_elf_link_just_syms
91
92 #define elf_backend_object_p ppc64_elf_object_p
93 #define elf_backend_grok_prstatus ppc64_elf_grok_prstatus
94 #define elf_backend_grok_psinfo ppc64_elf_grok_psinfo
95 #define elf_backend_write_core_note ppc64_elf_write_core_note
96 #define elf_backend_create_dynamic_sections ppc64_elf_create_dynamic_sections
97 #define elf_backend_copy_indirect_symbol ppc64_elf_copy_indirect_symbol
98 #define elf_backend_add_symbol_hook ppc64_elf_add_symbol_hook
99 #define elf_backend_check_directives ppc64_elf_process_dot_syms
100 #define elf_backend_notice_as_needed ppc64_elf_notice_as_needed
101 #define elf_backend_archive_symbol_lookup ppc64_elf_archive_symbol_lookup
102 #define elf_backend_check_relocs ppc64_elf_check_relocs
103 #define elf_backend_gc_keep ppc64_elf_gc_keep
104 #define elf_backend_gc_mark_dynamic_ref ppc64_elf_gc_mark_dynamic_ref
105 #define elf_backend_gc_mark_hook ppc64_elf_gc_mark_hook
106 #define elf_backend_gc_sweep_hook ppc64_elf_gc_sweep_hook
107 #define elf_backend_adjust_dynamic_symbol ppc64_elf_adjust_dynamic_symbol
108 #define elf_backend_hide_symbol ppc64_elf_hide_symbol
109 #define elf_backend_maybe_function_sym ppc64_elf_maybe_function_sym
110 #define elf_backend_always_size_sections ppc64_elf_func_desc_adjust
111 #define elf_backend_size_dynamic_sections ppc64_elf_size_dynamic_sections
112 #define elf_backend_hash_symbol ppc64_elf_hash_symbol
113 #define elf_backend_init_index_section _bfd_elf_init_2_index_sections
114 #define elf_backend_action_discarded ppc64_elf_action_discarded
115 #define elf_backend_relocate_section ppc64_elf_relocate_section
116 #define elf_backend_finish_dynamic_symbol ppc64_elf_finish_dynamic_symbol
117 #define elf_backend_reloc_type_class ppc64_elf_reloc_type_class
118 #define elf_backend_finish_dynamic_sections ppc64_elf_finish_dynamic_sections
119 #define elf_backend_link_output_symbol_hook ppc64_elf_output_symbol_hook
120 #define elf_backend_special_sections ppc64_elf_special_sections
121 #define elf_backend_merge_symbol_attribute ppc64_elf_merge_symbol_attribute
122
123 /* The name of the dynamic interpreter. This is put in the .interp
124 section. */
125 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
126
127 /* The size in bytes of an entry in the procedure linkage table. */
128 #define PLT_ENTRY_SIZE(htab) (htab->opd_abi ? 24 : 8)
129
130 /* The initial size of the plt reserved for the dynamic linker. */
131 #define PLT_INITIAL_ENTRY_SIZE(htab) (htab->opd_abi ? 24 : 16)
132
133 /* Offsets to some stack save slots. */
134 #define STK_LR 16
135 #define STK_TOC(htab) (htab->opd_abi ? 40 : 24)
136 /* This one is dodgy. ELFv2 does not have a linker word, so use the
137 CR save slot. Used only by optimised __tls_get_addr call stub,
138 relying on __tls_get_addr_opt not saving CR.. */
139 #define STK_LINKER(htab) (htab->opd_abi ? 32 : 8)
140
141 /* TOC base pointers offset from start of TOC. */
142 #define TOC_BASE_OFF 0x8000
143
144 /* Offset of tp and dtp pointers from start of TLS block. */
145 #define TP_OFFSET 0x7000
146 #define DTP_OFFSET 0x8000
147
148 /* .plt call stub instructions. The normal stub is like this, but
149 sometimes the .plt entry crosses a 64k boundary and we need to
150 insert an addi to adjust r11. */
151 #define STD_R2_0R1 0xf8410000 /* std %r2,0+40(%r1) */
152 #define ADDIS_R11_R2 0x3d620000 /* addis %r11,%r2,xxx@ha */
153 #define LD_R12_0R11 0xe98b0000 /* ld %r12,xxx+0@l(%r11) */
154 #define MTCTR_R12 0x7d8903a6 /* mtctr %r12 */
155 #define LD_R2_0R11 0xe84b0000 /* ld %r2,xxx+8@l(%r11) */
156 #define LD_R11_0R11 0xe96b0000 /* ld %r11,xxx+16@l(%r11) */
157 #define BCTR 0x4e800420 /* bctr */
158
159 #define ADDI_R11_R11 0x396b0000 /* addi %r11,%r11,off@l */
160 #define ADDIS_R2_R2 0x3c420000 /* addis %r2,%r2,off@ha */
161 #define ADDI_R2_R2 0x38420000 /* addi %r2,%r2,off@l */
162
163 #define XOR_R2_R12_R12 0x7d826278 /* xor %r2,%r12,%r12 */
164 #define ADD_R11_R11_R2 0x7d6b1214 /* add %r11,%r11,%r2 */
165 #define XOR_R11_R12_R12 0x7d8b6278 /* xor %r11,%r12,%r12 */
166 #define ADD_R2_R2_R11 0x7c425a14 /* add %r2,%r2,%r11 */
167 #define CMPLDI_R2_0 0x28220000 /* cmpldi %r2,0 */
168 #define BNECTR 0x4ca20420 /* bnectr+ */
169 #define BNECTR_P4 0x4ce20420 /* bnectr+ */
170
171 #define LD_R12_0R2 0xe9820000 /* ld %r12,xxx+0(%r2) */
172 #define LD_R11_0R2 0xe9620000 /* ld %r11,xxx+0(%r2) */
173 #define LD_R2_0R2 0xe8420000 /* ld %r2,xxx+0(%r2) */
174
175 #define LD_R2_0R1 0xe8410000 /* ld %r2,0(%r1) */
176
177 #define ADDIS_R12_R12 0x3d8c0000 /* addis %r12,%r12,xxx@ha */
178 #define LD_R12_0R12 0xe98c0000 /* ld %r12,xxx@l(%r12) */
179
180 /* glink call stub instructions. We enter with the index in R0. */
181 #define GLINK_CALL_STUB_SIZE (16*4)
182 /* 0: */
183 /* .quad plt0-1f */
184 /* __glink: */
185 #define MFLR_R12 0x7d8802a6 /* mflr %12 */
186 #define BCL_20_31 0x429f0005 /* bcl 20,31,1f */
187 /* 1: */
188 #define MFLR_R11 0x7d6802a6 /* mflr %11 */
189 /* ld %2,(0b-1b)(%11) */
190 #define MTLR_R12 0x7d8803a6 /* mtlr %12 */
191 #define ADD_R11_R2_R11 0x7d625a14 /* add %11,%2,%11 */
192 /* ld %12,0(%11) */
193 /* ld %2,8(%11) */
194 /* mtctr %12 */
195 /* ld %11,16(%11) */
196 /* bctr */
197 #define MFLR_R0 0x7c0802a6 /* mflr %r0 */
198 #define MTLR_R0 0x7c0803a6 /* mtlr %r0 */
199 #define SUB_R12_R12_R11 0x7d8b6050 /* subf %r12,%r11,%r12 */
200 #define ADDI_R0_R12 0x380c0000 /* addi %r0,%r12,0 */
201 #define SRDI_R0_R0_2 0x7800f082 /* rldicl %r0,%r0,62,2 */
202
203 /* Pad with this. */
204 #define NOP 0x60000000
205
206 /* Some other nops. */
207 #define CROR_151515 0x4def7b82
208 #define CROR_313131 0x4ffffb82
209
210 /* .glink entries for the first 32k functions are two instructions. */
211 #define LI_R0_0 0x38000000 /* li %r0,0 */
212 #define B_DOT 0x48000000 /* b . */
213
214 /* After that, we need two instructions to load the index, followed by
215 a branch. */
216 #define LIS_R0_0 0x3c000000 /* lis %r0,0 */
217 #define ORI_R0_R0_0 0x60000000 /* ori %r0,%r0,0 */
218
219 /* Instructions used by the save and restore reg functions. */
220 #define STD_R0_0R1 0xf8010000 /* std %r0,0(%r1) */
221 #define STD_R0_0R12 0xf80c0000 /* std %r0,0(%r12) */
222 #define LD_R0_0R1 0xe8010000 /* ld %r0,0(%r1) */
223 #define LD_R0_0R12 0xe80c0000 /* ld %r0,0(%r12) */
224 #define STFD_FR0_0R1 0xd8010000 /* stfd %fr0,0(%r1) */
225 #define LFD_FR0_0R1 0xc8010000 /* lfd %fr0,0(%r1) */
226 #define LI_R12_0 0x39800000 /* li %r12,0 */
227 #define STVX_VR0_R12_R0 0x7c0c01ce /* stvx %v0,%r12,%r0 */
228 #define LVX_VR0_R12_R0 0x7c0c00ce /* lvx %v0,%r12,%r0 */
229 #define MTLR_R0 0x7c0803a6 /* mtlr %r0 */
230 #define BLR 0x4e800020 /* blr */
231
232 /* Since .opd is an array of descriptors and each entry will end up
233 with identical R_PPC64_RELATIVE relocs, there is really no need to
234 propagate .opd relocs; The dynamic linker should be taught to
235 relocate .opd without reloc entries. */
236 #ifndef NO_OPD_RELOCS
237 #define NO_OPD_RELOCS 0
238 #endif
239 \f
240 #define ONES(n) (((bfd_vma) 1 << ((n) - 1) << 1) - 1)
241
242 /* Relocation HOWTO's. */
243 static reloc_howto_type *ppc64_elf_howto_table[(int) R_PPC64_max];
244
245 static reloc_howto_type ppc64_elf_howto_raw[] = {
246 /* This reloc does nothing. */
247 HOWTO (R_PPC64_NONE, /* type */
248 0, /* rightshift */
249 2, /* size (0 = byte, 1 = short, 2 = long) */
250 32, /* bitsize */
251 FALSE, /* pc_relative */
252 0, /* bitpos */
253 complain_overflow_dont, /* complain_on_overflow */
254 bfd_elf_generic_reloc, /* special_function */
255 "R_PPC64_NONE", /* name */
256 FALSE, /* partial_inplace */
257 0, /* src_mask */
258 0, /* dst_mask */
259 FALSE), /* pcrel_offset */
260
261 /* A standard 32 bit relocation. */
262 HOWTO (R_PPC64_ADDR32, /* type */
263 0, /* rightshift */
264 2, /* size (0 = byte, 1 = short, 2 = long) */
265 32, /* bitsize */
266 FALSE, /* pc_relative */
267 0, /* bitpos */
268 complain_overflow_bitfield, /* complain_on_overflow */
269 bfd_elf_generic_reloc, /* special_function */
270 "R_PPC64_ADDR32", /* name */
271 FALSE, /* partial_inplace */
272 0, /* src_mask */
273 0xffffffff, /* dst_mask */
274 FALSE), /* pcrel_offset */
275
276 /* An absolute 26 bit branch; the lower two bits must be zero.
277 FIXME: we don't check that, we just clear them. */
278 HOWTO (R_PPC64_ADDR24, /* type */
279 0, /* rightshift */
280 2, /* size (0 = byte, 1 = short, 2 = long) */
281 26, /* bitsize */
282 FALSE, /* pc_relative */
283 0, /* bitpos */
284 complain_overflow_bitfield, /* complain_on_overflow */
285 bfd_elf_generic_reloc, /* special_function */
286 "R_PPC64_ADDR24", /* name */
287 FALSE, /* partial_inplace */
288 0, /* src_mask */
289 0x03fffffc, /* dst_mask */
290 FALSE), /* pcrel_offset */
291
292 /* A standard 16 bit relocation. */
293 HOWTO (R_PPC64_ADDR16, /* type */
294 0, /* rightshift */
295 1, /* size (0 = byte, 1 = short, 2 = long) */
296 16, /* bitsize */
297 FALSE, /* pc_relative */
298 0, /* bitpos */
299 complain_overflow_bitfield, /* complain_on_overflow */
300 bfd_elf_generic_reloc, /* special_function */
301 "R_PPC64_ADDR16", /* name */
302 FALSE, /* partial_inplace */
303 0, /* src_mask */
304 0xffff, /* dst_mask */
305 FALSE), /* pcrel_offset */
306
307 /* A 16 bit relocation without overflow. */
308 HOWTO (R_PPC64_ADDR16_LO, /* type */
309 0, /* rightshift */
310 1, /* size (0 = byte, 1 = short, 2 = long) */
311 16, /* bitsize */
312 FALSE, /* pc_relative */
313 0, /* bitpos */
314 complain_overflow_dont,/* complain_on_overflow */
315 bfd_elf_generic_reloc, /* special_function */
316 "R_PPC64_ADDR16_LO", /* name */
317 FALSE, /* partial_inplace */
318 0, /* src_mask */
319 0xffff, /* dst_mask */
320 FALSE), /* pcrel_offset */
321
322 /* Bits 16-31 of an address. */
323 HOWTO (R_PPC64_ADDR16_HI, /* type */
324 16, /* rightshift */
325 1, /* size (0 = byte, 1 = short, 2 = long) */
326 16, /* bitsize */
327 FALSE, /* pc_relative */
328 0, /* bitpos */
329 complain_overflow_signed, /* complain_on_overflow */
330 bfd_elf_generic_reloc, /* special_function */
331 "R_PPC64_ADDR16_HI", /* name */
332 FALSE, /* partial_inplace */
333 0, /* src_mask */
334 0xffff, /* dst_mask */
335 FALSE), /* pcrel_offset */
336
337 /* Bits 16-31 of an address, plus 1 if the contents of the low 16
338 bits, treated as a signed number, is negative. */
339 HOWTO (R_PPC64_ADDR16_HA, /* type */
340 16, /* rightshift */
341 1, /* size (0 = byte, 1 = short, 2 = long) */
342 16, /* bitsize */
343 FALSE, /* pc_relative */
344 0, /* bitpos */
345 complain_overflow_signed, /* complain_on_overflow */
346 ppc64_elf_ha_reloc, /* special_function */
347 "R_PPC64_ADDR16_HA", /* name */
348 FALSE, /* partial_inplace */
349 0, /* src_mask */
350 0xffff, /* dst_mask */
351 FALSE), /* pcrel_offset */
352
353 /* An absolute 16 bit branch; the lower two bits must be zero.
354 FIXME: we don't check that, we just clear them. */
355 HOWTO (R_PPC64_ADDR14, /* type */
356 0, /* rightshift */
357 2, /* size (0 = byte, 1 = short, 2 = long) */
358 16, /* bitsize */
359 FALSE, /* pc_relative */
360 0, /* bitpos */
361 complain_overflow_bitfield, /* complain_on_overflow */
362 ppc64_elf_branch_reloc, /* special_function */
363 "R_PPC64_ADDR14", /* name */
364 FALSE, /* partial_inplace */
365 0, /* src_mask */
366 0x0000fffc, /* dst_mask */
367 FALSE), /* pcrel_offset */
368
369 /* An absolute 16 bit branch, for which bit 10 should be set to
370 indicate that the branch is expected to be taken. The lower two
371 bits must be zero. */
372 HOWTO (R_PPC64_ADDR14_BRTAKEN, /* type */
373 0, /* rightshift */
374 2, /* size (0 = byte, 1 = short, 2 = long) */
375 16, /* bitsize */
376 FALSE, /* pc_relative */
377 0, /* bitpos */
378 complain_overflow_bitfield, /* complain_on_overflow */
379 ppc64_elf_brtaken_reloc, /* special_function */
380 "R_PPC64_ADDR14_BRTAKEN",/* name */
381 FALSE, /* partial_inplace */
382 0, /* src_mask */
383 0x0000fffc, /* dst_mask */
384 FALSE), /* pcrel_offset */
385
386 /* An absolute 16 bit branch, for which bit 10 should be set to
387 indicate that the branch is not expected to be taken. The lower
388 two bits must be zero. */
389 HOWTO (R_PPC64_ADDR14_BRNTAKEN, /* type */
390 0, /* rightshift */
391 2, /* size (0 = byte, 1 = short, 2 = long) */
392 16, /* bitsize */
393 FALSE, /* pc_relative */
394 0, /* bitpos */
395 complain_overflow_bitfield, /* complain_on_overflow */
396 ppc64_elf_brtaken_reloc, /* special_function */
397 "R_PPC64_ADDR14_BRNTAKEN",/* name */
398 FALSE, /* partial_inplace */
399 0, /* src_mask */
400 0x0000fffc, /* dst_mask */
401 FALSE), /* pcrel_offset */
402
403 /* A relative 26 bit branch; the lower two bits must be zero. */
404 HOWTO (R_PPC64_REL24, /* type */
405 0, /* rightshift */
406 2, /* size (0 = byte, 1 = short, 2 = long) */
407 26, /* bitsize */
408 TRUE, /* pc_relative */
409 0, /* bitpos */
410 complain_overflow_signed, /* complain_on_overflow */
411 ppc64_elf_branch_reloc, /* special_function */
412 "R_PPC64_REL24", /* name */
413 FALSE, /* partial_inplace */
414 0, /* src_mask */
415 0x03fffffc, /* dst_mask */
416 TRUE), /* pcrel_offset */
417
418 /* A relative 16 bit branch; the lower two bits must be zero. */
419 HOWTO (R_PPC64_REL14, /* type */
420 0, /* rightshift */
421 2, /* size (0 = byte, 1 = short, 2 = long) */
422 16, /* bitsize */
423 TRUE, /* pc_relative */
424 0, /* bitpos */
425 complain_overflow_signed, /* complain_on_overflow */
426 ppc64_elf_branch_reloc, /* special_function */
427 "R_PPC64_REL14", /* name */
428 FALSE, /* partial_inplace */
429 0, /* src_mask */
430 0x0000fffc, /* dst_mask */
431 TRUE), /* pcrel_offset */
432
433 /* A relative 16 bit branch. Bit 10 should be set to indicate that
434 the branch is expected to be taken. The lower two bits must be
435 zero. */
436 HOWTO (R_PPC64_REL14_BRTAKEN, /* type */
437 0, /* rightshift */
438 2, /* size (0 = byte, 1 = short, 2 = long) */
439 16, /* bitsize */
440 TRUE, /* pc_relative */
441 0, /* bitpos */
442 complain_overflow_signed, /* complain_on_overflow */
443 ppc64_elf_brtaken_reloc, /* special_function */
444 "R_PPC64_REL14_BRTAKEN", /* name */
445 FALSE, /* partial_inplace */
446 0, /* src_mask */
447 0x0000fffc, /* dst_mask */
448 TRUE), /* pcrel_offset */
449
450 /* A relative 16 bit branch. Bit 10 should be set to indicate that
451 the branch is not expected to be taken. The lower two bits must
452 be zero. */
453 HOWTO (R_PPC64_REL14_BRNTAKEN, /* type */
454 0, /* rightshift */
455 2, /* size (0 = byte, 1 = short, 2 = long) */
456 16, /* bitsize */
457 TRUE, /* pc_relative */
458 0, /* bitpos */
459 complain_overflow_signed, /* complain_on_overflow */
460 ppc64_elf_brtaken_reloc, /* special_function */
461 "R_PPC64_REL14_BRNTAKEN",/* name */
462 FALSE, /* partial_inplace */
463 0, /* src_mask */
464 0x0000fffc, /* dst_mask */
465 TRUE), /* pcrel_offset */
466
467 /* Like R_PPC64_ADDR16, but referring to the GOT table entry for the
468 symbol. */
469 HOWTO (R_PPC64_GOT16, /* type */
470 0, /* rightshift */
471 1, /* size (0 = byte, 1 = short, 2 = long) */
472 16, /* bitsize */
473 FALSE, /* pc_relative */
474 0, /* bitpos */
475 complain_overflow_signed, /* complain_on_overflow */
476 ppc64_elf_unhandled_reloc, /* special_function */
477 "R_PPC64_GOT16", /* name */
478 FALSE, /* partial_inplace */
479 0, /* src_mask */
480 0xffff, /* dst_mask */
481 FALSE), /* pcrel_offset */
482
483 /* Like R_PPC64_ADDR16_LO, but referring to the GOT table entry for
484 the symbol. */
485 HOWTO (R_PPC64_GOT16_LO, /* type */
486 0, /* rightshift */
487 1, /* size (0 = byte, 1 = short, 2 = long) */
488 16, /* bitsize */
489 FALSE, /* pc_relative */
490 0, /* bitpos */
491 complain_overflow_dont, /* complain_on_overflow */
492 ppc64_elf_unhandled_reloc, /* special_function */
493 "R_PPC64_GOT16_LO", /* name */
494 FALSE, /* partial_inplace */
495 0, /* src_mask */
496 0xffff, /* dst_mask */
497 FALSE), /* pcrel_offset */
498
499 /* Like R_PPC64_ADDR16_HI, but referring to the GOT table entry for
500 the symbol. */
501 HOWTO (R_PPC64_GOT16_HI, /* type */
502 16, /* rightshift */
503 1, /* size (0 = byte, 1 = short, 2 = long) */
504 16, /* bitsize */
505 FALSE, /* pc_relative */
506 0, /* bitpos */
507 complain_overflow_signed,/* complain_on_overflow */
508 ppc64_elf_unhandled_reloc, /* special_function */
509 "R_PPC64_GOT16_HI", /* name */
510 FALSE, /* partial_inplace */
511 0, /* src_mask */
512 0xffff, /* dst_mask */
513 FALSE), /* pcrel_offset */
514
515 /* Like R_PPC64_ADDR16_HA, but referring to the GOT table entry for
516 the symbol. */
517 HOWTO (R_PPC64_GOT16_HA, /* type */
518 16, /* rightshift */
519 1, /* size (0 = byte, 1 = short, 2 = long) */
520 16, /* bitsize */
521 FALSE, /* pc_relative */
522 0, /* bitpos */
523 complain_overflow_signed,/* complain_on_overflow */
524 ppc64_elf_unhandled_reloc, /* special_function */
525 "R_PPC64_GOT16_HA", /* name */
526 FALSE, /* partial_inplace */
527 0, /* src_mask */
528 0xffff, /* dst_mask */
529 FALSE), /* pcrel_offset */
530
531 /* This is used only by the dynamic linker. The symbol should exist
532 both in the object being run and in some shared library. The
533 dynamic linker copies the data addressed by the symbol from the
534 shared library into the object, because the object being
535 run has to have the data at some particular address. */
536 HOWTO (R_PPC64_COPY, /* type */
537 0, /* rightshift */
538 0, /* this one is variable size */
539 0, /* bitsize */
540 FALSE, /* pc_relative */
541 0, /* bitpos */
542 complain_overflow_dont, /* complain_on_overflow */
543 ppc64_elf_unhandled_reloc, /* special_function */
544 "R_PPC64_COPY", /* name */
545 FALSE, /* partial_inplace */
546 0, /* src_mask */
547 0, /* dst_mask */
548 FALSE), /* pcrel_offset */
549
550 /* Like R_PPC64_ADDR64, but used when setting global offset table
551 entries. */
552 HOWTO (R_PPC64_GLOB_DAT, /* type */
553 0, /* rightshift */
554 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
555 64, /* bitsize */
556 FALSE, /* pc_relative */
557 0, /* bitpos */
558 complain_overflow_dont, /* complain_on_overflow */
559 ppc64_elf_unhandled_reloc, /* special_function */
560 "R_PPC64_GLOB_DAT", /* name */
561 FALSE, /* partial_inplace */
562 0, /* src_mask */
563 ONES (64), /* dst_mask */
564 FALSE), /* pcrel_offset */
565
566 /* Created by the link editor. Marks a procedure linkage table
567 entry for a symbol. */
568 HOWTO (R_PPC64_JMP_SLOT, /* type */
569 0, /* rightshift */
570 0, /* size (0 = byte, 1 = short, 2 = long) */
571 0, /* bitsize */
572 FALSE, /* pc_relative */
573 0, /* bitpos */
574 complain_overflow_dont, /* complain_on_overflow */
575 ppc64_elf_unhandled_reloc, /* special_function */
576 "R_PPC64_JMP_SLOT", /* name */
577 FALSE, /* partial_inplace */
578 0, /* src_mask */
579 0, /* dst_mask */
580 FALSE), /* pcrel_offset */
581
582 /* Used only by the dynamic linker. When the object is run, this
583 doubleword64 is set to the load address of the object, plus the
584 addend. */
585 HOWTO (R_PPC64_RELATIVE, /* type */
586 0, /* rightshift */
587 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
588 64, /* bitsize */
589 FALSE, /* pc_relative */
590 0, /* bitpos */
591 complain_overflow_dont, /* complain_on_overflow */
592 bfd_elf_generic_reloc, /* special_function */
593 "R_PPC64_RELATIVE", /* name */
594 FALSE, /* partial_inplace */
595 0, /* src_mask */
596 ONES (64), /* dst_mask */
597 FALSE), /* pcrel_offset */
598
599 /* Like R_PPC64_ADDR32, but may be unaligned. */
600 HOWTO (R_PPC64_UADDR32, /* type */
601 0, /* rightshift */
602 2, /* size (0 = byte, 1 = short, 2 = long) */
603 32, /* bitsize */
604 FALSE, /* pc_relative */
605 0, /* bitpos */
606 complain_overflow_bitfield, /* complain_on_overflow */
607 bfd_elf_generic_reloc, /* special_function */
608 "R_PPC64_UADDR32", /* name */
609 FALSE, /* partial_inplace */
610 0, /* src_mask */
611 0xffffffff, /* dst_mask */
612 FALSE), /* pcrel_offset */
613
614 /* Like R_PPC64_ADDR16, but may be unaligned. */
615 HOWTO (R_PPC64_UADDR16, /* type */
616 0, /* rightshift */
617 1, /* size (0 = byte, 1 = short, 2 = long) */
618 16, /* bitsize */
619 FALSE, /* pc_relative */
620 0, /* bitpos */
621 complain_overflow_bitfield, /* complain_on_overflow */
622 bfd_elf_generic_reloc, /* special_function */
623 "R_PPC64_UADDR16", /* name */
624 FALSE, /* partial_inplace */
625 0, /* src_mask */
626 0xffff, /* dst_mask */
627 FALSE), /* pcrel_offset */
628
629 /* 32-bit PC relative. */
630 HOWTO (R_PPC64_REL32, /* type */
631 0, /* rightshift */
632 2, /* size (0 = byte, 1 = short, 2 = long) */
633 32, /* bitsize */
634 TRUE, /* pc_relative */
635 0, /* bitpos */
636 /* FIXME: Verify. Was complain_overflow_bitfield. */
637 complain_overflow_signed, /* complain_on_overflow */
638 bfd_elf_generic_reloc, /* special_function */
639 "R_PPC64_REL32", /* name */
640 FALSE, /* partial_inplace */
641 0, /* src_mask */
642 0xffffffff, /* dst_mask */
643 TRUE), /* pcrel_offset */
644
645 /* 32-bit relocation to the symbol's procedure linkage table. */
646 HOWTO (R_PPC64_PLT32, /* type */
647 0, /* rightshift */
648 2, /* size (0 = byte, 1 = short, 2 = long) */
649 32, /* bitsize */
650 FALSE, /* pc_relative */
651 0, /* bitpos */
652 complain_overflow_bitfield, /* complain_on_overflow */
653 ppc64_elf_unhandled_reloc, /* special_function */
654 "R_PPC64_PLT32", /* name */
655 FALSE, /* partial_inplace */
656 0, /* src_mask */
657 0xffffffff, /* dst_mask */
658 FALSE), /* pcrel_offset */
659
660 /* 32-bit PC relative relocation to the symbol's procedure linkage table.
661 FIXME: R_PPC64_PLTREL32 not supported. */
662 HOWTO (R_PPC64_PLTREL32, /* type */
663 0, /* rightshift */
664 2, /* size (0 = byte, 1 = short, 2 = long) */
665 32, /* bitsize */
666 TRUE, /* pc_relative */
667 0, /* bitpos */
668 complain_overflow_signed, /* complain_on_overflow */
669 bfd_elf_generic_reloc, /* special_function */
670 "R_PPC64_PLTREL32", /* name */
671 FALSE, /* partial_inplace */
672 0, /* src_mask */
673 0xffffffff, /* dst_mask */
674 TRUE), /* pcrel_offset */
675
676 /* Like R_PPC64_ADDR16_LO, but referring to the PLT table entry for
677 the symbol. */
678 HOWTO (R_PPC64_PLT16_LO, /* type */
679 0, /* rightshift */
680 1, /* size (0 = byte, 1 = short, 2 = long) */
681 16, /* bitsize */
682 FALSE, /* pc_relative */
683 0, /* bitpos */
684 complain_overflow_dont, /* complain_on_overflow */
685 ppc64_elf_unhandled_reloc, /* special_function */
686 "R_PPC64_PLT16_LO", /* name */
687 FALSE, /* partial_inplace */
688 0, /* src_mask */
689 0xffff, /* dst_mask */
690 FALSE), /* pcrel_offset */
691
692 /* Like R_PPC64_ADDR16_HI, but referring to the PLT table entry for
693 the symbol. */
694 HOWTO (R_PPC64_PLT16_HI, /* type */
695 16, /* rightshift */
696 1, /* size (0 = byte, 1 = short, 2 = long) */
697 16, /* bitsize */
698 FALSE, /* pc_relative */
699 0, /* bitpos */
700 complain_overflow_signed, /* complain_on_overflow */
701 ppc64_elf_unhandled_reloc, /* special_function */
702 "R_PPC64_PLT16_HI", /* name */
703 FALSE, /* partial_inplace */
704 0, /* src_mask */
705 0xffff, /* dst_mask */
706 FALSE), /* pcrel_offset */
707
708 /* Like R_PPC64_ADDR16_HA, but referring to the PLT table entry for
709 the symbol. */
710 HOWTO (R_PPC64_PLT16_HA, /* type */
711 16, /* rightshift */
712 1, /* size (0 = byte, 1 = short, 2 = long) */
713 16, /* bitsize */
714 FALSE, /* pc_relative */
715 0, /* bitpos */
716 complain_overflow_signed, /* complain_on_overflow */
717 ppc64_elf_unhandled_reloc, /* special_function */
718 "R_PPC64_PLT16_HA", /* name */
719 FALSE, /* partial_inplace */
720 0, /* src_mask */
721 0xffff, /* dst_mask */
722 FALSE), /* pcrel_offset */
723
724 /* 16-bit section relative relocation. */
725 HOWTO (R_PPC64_SECTOFF, /* type */
726 0, /* rightshift */
727 1, /* size (0 = byte, 1 = short, 2 = long) */
728 16, /* bitsize */
729 FALSE, /* pc_relative */
730 0, /* bitpos */
731 complain_overflow_bitfield, /* complain_on_overflow */
732 ppc64_elf_sectoff_reloc, /* special_function */
733 "R_PPC64_SECTOFF", /* name */
734 FALSE, /* partial_inplace */
735 0, /* src_mask */
736 0xffff, /* dst_mask */
737 FALSE), /* pcrel_offset */
738
739 /* Like R_PPC64_SECTOFF, but no overflow warning. */
740 HOWTO (R_PPC64_SECTOFF_LO, /* type */
741 0, /* rightshift */
742 1, /* size (0 = byte, 1 = short, 2 = long) */
743 16, /* bitsize */
744 FALSE, /* pc_relative */
745 0, /* bitpos */
746 complain_overflow_dont, /* complain_on_overflow */
747 ppc64_elf_sectoff_reloc, /* special_function */
748 "R_PPC64_SECTOFF_LO", /* name */
749 FALSE, /* partial_inplace */
750 0, /* src_mask */
751 0xffff, /* dst_mask */
752 FALSE), /* pcrel_offset */
753
754 /* 16-bit upper half section relative relocation. */
755 HOWTO (R_PPC64_SECTOFF_HI, /* type */
756 16, /* rightshift */
757 1, /* size (0 = byte, 1 = short, 2 = long) */
758 16, /* bitsize */
759 FALSE, /* pc_relative */
760 0, /* bitpos */
761 complain_overflow_signed, /* complain_on_overflow */
762 ppc64_elf_sectoff_reloc, /* special_function */
763 "R_PPC64_SECTOFF_HI", /* name */
764 FALSE, /* partial_inplace */
765 0, /* src_mask */
766 0xffff, /* dst_mask */
767 FALSE), /* pcrel_offset */
768
769 /* 16-bit upper half adjusted section relative relocation. */
770 HOWTO (R_PPC64_SECTOFF_HA, /* type */
771 16, /* rightshift */
772 1, /* size (0 = byte, 1 = short, 2 = long) */
773 16, /* bitsize */
774 FALSE, /* pc_relative */
775 0, /* bitpos */
776 complain_overflow_signed, /* complain_on_overflow */
777 ppc64_elf_sectoff_ha_reloc, /* special_function */
778 "R_PPC64_SECTOFF_HA", /* name */
779 FALSE, /* partial_inplace */
780 0, /* src_mask */
781 0xffff, /* dst_mask */
782 FALSE), /* pcrel_offset */
783
784 /* Like R_PPC64_REL24 without touching the two least significant bits. */
785 HOWTO (R_PPC64_REL30, /* type */
786 2, /* rightshift */
787 2, /* size (0 = byte, 1 = short, 2 = long) */
788 30, /* bitsize */
789 TRUE, /* pc_relative */
790 0, /* bitpos */
791 complain_overflow_dont, /* complain_on_overflow */
792 bfd_elf_generic_reloc, /* special_function */
793 "R_PPC64_REL30", /* name */
794 FALSE, /* partial_inplace */
795 0, /* src_mask */
796 0xfffffffc, /* dst_mask */
797 TRUE), /* pcrel_offset */
798
799 /* Relocs in the 64-bit PowerPC ELF ABI, not in the 32-bit ABI. */
800
801 /* A standard 64-bit relocation. */
802 HOWTO (R_PPC64_ADDR64, /* type */
803 0, /* rightshift */
804 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
805 64, /* bitsize */
806 FALSE, /* pc_relative */
807 0, /* bitpos */
808 complain_overflow_dont, /* complain_on_overflow */
809 bfd_elf_generic_reloc, /* special_function */
810 "R_PPC64_ADDR64", /* name */
811 FALSE, /* partial_inplace */
812 0, /* src_mask */
813 ONES (64), /* dst_mask */
814 FALSE), /* pcrel_offset */
815
816 /* The bits 32-47 of an address. */
817 HOWTO (R_PPC64_ADDR16_HIGHER, /* type */
818 32, /* rightshift */
819 1, /* size (0 = byte, 1 = short, 2 = long) */
820 16, /* bitsize */
821 FALSE, /* pc_relative */
822 0, /* bitpos */
823 complain_overflow_dont, /* complain_on_overflow */
824 bfd_elf_generic_reloc, /* special_function */
825 "R_PPC64_ADDR16_HIGHER", /* name */
826 FALSE, /* partial_inplace */
827 0, /* src_mask */
828 0xffff, /* dst_mask */
829 FALSE), /* pcrel_offset */
830
831 /* The bits 32-47 of an address, plus 1 if the contents of the low
832 16 bits, treated as a signed number, is negative. */
833 HOWTO (R_PPC64_ADDR16_HIGHERA, /* type */
834 32, /* rightshift */
835 1, /* size (0 = byte, 1 = short, 2 = long) */
836 16, /* bitsize */
837 FALSE, /* pc_relative */
838 0, /* bitpos */
839 complain_overflow_dont, /* complain_on_overflow */
840 ppc64_elf_ha_reloc, /* special_function */
841 "R_PPC64_ADDR16_HIGHERA", /* name */
842 FALSE, /* partial_inplace */
843 0, /* src_mask */
844 0xffff, /* dst_mask */
845 FALSE), /* pcrel_offset */
846
847 /* The bits 48-63 of an address. */
848 HOWTO (R_PPC64_ADDR16_HIGHEST,/* type */
849 48, /* rightshift */
850 1, /* size (0 = byte, 1 = short, 2 = long) */
851 16, /* bitsize */
852 FALSE, /* pc_relative */
853 0, /* bitpos */
854 complain_overflow_dont, /* complain_on_overflow */
855 bfd_elf_generic_reloc, /* special_function */
856 "R_PPC64_ADDR16_HIGHEST", /* name */
857 FALSE, /* partial_inplace */
858 0, /* src_mask */
859 0xffff, /* dst_mask */
860 FALSE), /* pcrel_offset */
861
862 /* The bits 48-63 of an address, plus 1 if the contents of the low
863 16 bits, treated as a signed number, is negative. */
864 HOWTO (R_PPC64_ADDR16_HIGHESTA,/* type */
865 48, /* rightshift */
866 1, /* size (0 = byte, 1 = short, 2 = long) */
867 16, /* bitsize */
868 FALSE, /* pc_relative */
869 0, /* bitpos */
870 complain_overflow_dont, /* complain_on_overflow */
871 ppc64_elf_ha_reloc, /* special_function */
872 "R_PPC64_ADDR16_HIGHESTA", /* name */
873 FALSE, /* partial_inplace */
874 0, /* src_mask */
875 0xffff, /* dst_mask */
876 FALSE), /* pcrel_offset */
877
878 /* Like ADDR64, but may be unaligned. */
879 HOWTO (R_PPC64_UADDR64, /* type */
880 0, /* rightshift */
881 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
882 64, /* bitsize */
883 FALSE, /* pc_relative */
884 0, /* bitpos */
885 complain_overflow_dont, /* complain_on_overflow */
886 bfd_elf_generic_reloc, /* special_function */
887 "R_PPC64_UADDR64", /* name */
888 FALSE, /* partial_inplace */
889 0, /* src_mask */
890 ONES (64), /* dst_mask */
891 FALSE), /* pcrel_offset */
892
893 /* 64-bit relative relocation. */
894 HOWTO (R_PPC64_REL64, /* type */
895 0, /* rightshift */
896 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
897 64, /* bitsize */
898 TRUE, /* pc_relative */
899 0, /* bitpos */
900 complain_overflow_dont, /* complain_on_overflow */
901 bfd_elf_generic_reloc, /* special_function */
902 "R_PPC64_REL64", /* name */
903 FALSE, /* partial_inplace */
904 0, /* src_mask */
905 ONES (64), /* dst_mask */
906 TRUE), /* pcrel_offset */
907
908 /* 64-bit relocation to the symbol's procedure linkage table. */
909 HOWTO (R_PPC64_PLT64, /* type */
910 0, /* rightshift */
911 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
912 64, /* bitsize */
913 FALSE, /* pc_relative */
914 0, /* bitpos */
915 complain_overflow_dont, /* complain_on_overflow */
916 ppc64_elf_unhandled_reloc, /* special_function */
917 "R_PPC64_PLT64", /* name */
918 FALSE, /* partial_inplace */
919 0, /* src_mask */
920 ONES (64), /* dst_mask */
921 FALSE), /* pcrel_offset */
922
923 /* 64-bit PC relative relocation to the symbol's procedure linkage
924 table. */
925 /* FIXME: R_PPC64_PLTREL64 not supported. */
926 HOWTO (R_PPC64_PLTREL64, /* type */
927 0, /* rightshift */
928 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
929 64, /* bitsize */
930 TRUE, /* pc_relative */
931 0, /* bitpos */
932 complain_overflow_dont, /* complain_on_overflow */
933 ppc64_elf_unhandled_reloc, /* special_function */
934 "R_PPC64_PLTREL64", /* name */
935 FALSE, /* partial_inplace */
936 0, /* src_mask */
937 ONES (64), /* dst_mask */
938 TRUE), /* pcrel_offset */
939
940 /* 16 bit TOC-relative relocation. */
941
942 /* R_PPC64_TOC16 47 half16* S + A - .TOC. */
943 HOWTO (R_PPC64_TOC16, /* type */
944 0, /* rightshift */
945 1, /* size (0 = byte, 1 = short, 2 = long) */
946 16, /* bitsize */
947 FALSE, /* pc_relative */
948 0, /* bitpos */
949 complain_overflow_signed, /* complain_on_overflow */
950 ppc64_elf_toc_reloc, /* special_function */
951 "R_PPC64_TOC16", /* name */
952 FALSE, /* partial_inplace */
953 0, /* src_mask */
954 0xffff, /* dst_mask */
955 FALSE), /* pcrel_offset */
956
957 /* 16 bit TOC-relative relocation without overflow. */
958
959 /* R_PPC64_TOC16_LO 48 half16 #lo (S + A - .TOC.) */
960 HOWTO (R_PPC64_TOC16_LO, /* type */
961 0, /* rightshift */
962 1, /* size (0 = byte, 1 = short, 2 = long) */
963 16, /* bitsize */
964 FALSE, /* pc_relative */
965 0, /* bitpos */
966 complain_overflow_dont, /* complain_on_overflow */
967 ppc64_elf_toc_reloc, /* special_function */
968 "R_PPC64_TOC16_LO", /* name */
969 FALSE, /* partial_inplace */
970 0, /* src_mask */
971 0xffff, /* dst_mask */
972 FALSE), /* pcrel_offset */
973
974 /* 16 bit TOC-relative relocation, high 16 bits. */
975
976 /* R_PPC64_TOC16_HI 49 half16 #hi (S + A - .TOC.) */
977 HOWTO (R_PPC64_TOC16_HI, /* type */
978 16, /* rightshift */
979 1, /* size (0 = byte, 1 = short, 2 = long) */
980 16, /* bitsize */
981 FALSE, /* pc_relative */
982 0, /* bitpos */
983 complain_overflow_signed, /* complain_on_overflow */
984 ppc64_elf_toc_reloc, /* special_function */
985 "R_PPC64_TOC16_HI", /* name */
986 FALSE, /* partial_inplace */
987 0, /* src_mask */
988 0xffff, /* dst_mask */
989 FALSE), /* pcrel_offset */
990
991 /* 16 bit TOC-relative relocation, high 16 bits, plus 1 if the
992 contents of the low 16 bits, treated as a signed number, is
993 negative. */
994
995 /* R_PPC64_TOC16_HA 50 half16 #ha (S + A - .TOC.) */
996 HOWTO (R_PPC64_TOC16_HA, /* type */
997 16, /* rightshift */
998 1, /* size (0 = byte, 1 = short, 2 = long) */
999 16, /* bitsize */
1000 FALSE, /* pc_relative */
1001 0, /* bitpos */
1002 complain_overflow_signed, /* complain_on_overflow */
1003 ppc64_elf_toc_ha_reloc, /* special_function */
1004 "R_PPC64_TOC16_HA", /* name */
1005 FALSE, /* partial_inplace */
1006 0, /* src_mask */
1007 0xffff, /* dst_mask */
1008 FALSE), /* pcrel_offset */
1009
1010 /* 64-bit relocation; insert value of TOC base (.TOC.). */
1011
1012 /* R_PPC64_TOC 51 doubleword64 .TOC. */
1013 HOWTO (R_PPC64_TOC, /* type */
1014 0, /* rightshift */
1015 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1016 64, /* bitsize */
1017 FALSE, /* pc_relative */
1018 0, /* bitpos */
1019 complain_overflow_bitfield, /* complain_on_overflow */
1020 ppc64_elf_toc64_reloc, /* special_function */
1021 "R_PPC64_TOC", /* name */
1022 FALSE, /* partial_inplace */
1023 0, /* src_mask */
1024 ONES (64), /* dst_mask */
1025 FALSE), /* pcrel_offset */
1026
1027 /* Like R_PPC64_GOT16, but also informs the link editor that the
1028 value to relocate may (!) refer to a PLT entry which the link
1029 editor (a) may replace with the symbol value. If the link editor
1030 is unable to fully resolve the symbol, it may (b) create a PLT
1031 entry and store the address to the new PLT entry in the GOT.
1032 This permits lazy resolution of function symbols at run time.
1033 The link editor may also skip all of this and just (c) emit a
1034 R_PPC64_GLOB_DAT to tie the symbol to the GOT entry. */
1035 /* FIXME: R_PPC64_PLTGOT16 not implemented. */
1036 HOWTO (R_PPC64_PLTGOT16, /* type */
1037 0, /* rightshift */
1038 1, /* size (0 = byte, 1 = short, 2 = long) */
1039 16, /* bitsize */
1040 FALSE, /* pc_relative */
1041 0, /* bitpos */
1042 complain_overflow_signed, /* complain_on_overflow */
1043 ppc64_elf_unhandled_reloc, /* special_function */
1044 "R_PPC64_PLTGOT16", /* name */
1045 FALSE, /* partial_inplace */
1046 0, /* src_mask */
1047 0xffff, /* dst_mask */
1048 FALSE), /* pcrel_offset */
1049
1050 /* Like R_PPC64_PLTGOT16, but without overflow. */
1051 /* FIXME: R_PPC64_PLTGOT16_LO not implemented. */
1052 HOWTO (R_PPC64_PLTGOT16_LO, /* type */
1053 0, /* rightshift */
1054 1, /* size (0 = byte, 1 = short, 2 = long) */
1055 16, /* bitsize */
1056 FALSE, /* pc_relative */
1057 0, /* bitpos */
1058 complain_overflow_dont, /* complain_on_overflow */
1059 ppc64_elf_unhandled_reloc, /* special_function */
1060 "R_PPC64_PLTGOT16_LO", /* name */
1061 FALSE, /* partial_inplace */
1062 0, /* src_mask */
1063 0xffff, /* dst_mask */
1064 FALSE), /* pcrel_offset */
1065
1066 /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address. */
1067 /* FIXME: R_PPC64_PLTGOT16_HI not implemented. */
1068 HOWTO (R_PPC64_PLTGOT16_HI, /* type */
1069 16, /* rightshift */
1070 1, /* size (0 = byte, 1 = short, 2 = long) */
1071 16, /* bitsize */
1072 FALSE, /* pc_relative */
1073 0, /* bitpos */
1074 complain_overflow_signed, /* complain_on_overflow */
1075 ppc64_elf_unhandled_reloc, /* special_function */
1076 "R_PPC64_PLTGOT16_HI", /* name */
1077 FALSE, /* partial_inplace */
1078 0, /* src_mask */
1079 0xffff, /* dst_mask */
1080 FALSE), /* pcrel_offset */
1081
1082 /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address, plus
1083 1 if the contents of the low 16 bits, treated as a signed number,
1084 is negative. */
1085 /* FIXME: R_PPC64_PLTGOT16_HA not implemented. */
1086 HOWTO (R_PPC64_PLTGOT16_HA, /* type */
1087 16, /* rightshift */
1088 1, /* size (0 = byte, 1 = short, 2 = long) */
1089 16, /* bitsize */
1090 FALSE, /* pc_relative */
1091 0, /* bitpos */
1092 complain_overflow_signed, /* complain_on_overflow */
1093 ppc64_elf_unhandled_reloc, /* special_function */
1094 "R_PPC64_PLTGOT16_HA", /* name */
1095 FALSE, /* partial_inplace */
1096 0, /* src_mask */
1097 0xffff, /* dst_mask */
1098 FALSE), /* pcrel_offset */
1099
1100 /* Like R_PPC64_ADDR16, but for instructions with a DS field. */
1101 HOWTO (R_PPC64_ADDR16_DS, /* type */
1102 0, /* rightshift */
1103 1, /* size (0 = byte, 1 = short, 2 = long) */
1104 16, /* bitsize */
1105 FALSE, /* pc_relative */
1106 0, /* bitpos */
1107 complain_overflow_bitfield, /* complain_on_overflow */
1108 bfd_elf_generic_reloc, /* special_function */
1109 "R_PPC64_ADDR16_DS", /* name */
1110 FALSE, /* partial_inplace */
1111 0, /* src_mask */
1112 0xfffc, /* dst_mask */
1113 FALSE), /* pcrel_offset */
1114
1115 /* Like R_PPC64_ADDR16_LO, but for instructions with a DS field. */
1116 HOWTO (R_PPC64_ADDR16_LO_DS, /* type */
1117 0, /* rightshift */
1118 1, /* size (0 = byte, 1 = short, 2 = long) */
1119 16, /* bitsize */
1120 FALSE, /* pc_relative */
1121 0, /* bitpos */
1122 complain_overflow_dont,/* complain_on_overflow */
1123 bfd_elf_generic_reloc, /* special_function */
1124 "R_PPC64_ADDR16_LO_DS",/* name */
1125 FALSE, /* partial_inplace */
1126 0, /* src_mask */
1127 0xfffc, /* dst_mask */
1128 FALSE), /* pcrel_offset */
1129
1130 /* Like R_PPC64_GOT16, but for instructions with a DS field. */
1131 HOWTO (R_PPC64_GOT16_DS, /* type */
1132 0, /* rightshift */
1133 1, /* size (0 = byte, 1 = short, 2 = long) */
1134 16, /* bitsize */
1135 FALSE, /* pc_relative */
1136 0, /* bitpos */
1137 complain_overflow_signed, /* complain_on_overflow */
1138 ppc64_elf_unhandled_reloc, /* special_function */
1139 "R_PPC64_GOT16_DS", /* name */
1140 FALSE, /* partial_inplace */
1141 0, /* src_mask */
1142 0xfffc, /* dst_mask */
1143 FALSE), /* pcrel_offset */
1144
1145 /* Like R_PPC64_GOT16_LO, but for instructions with a DS field. */
1146 HOWTO (R_PPC64_GOT16_LO_DS, /* type */
1147 0, /* rightshift */
1148 1, /* size (0 = byte, 1 = short, 2 = long) */
1149 16, /* bitsize */
1150 FALSE, /* pc_relative */
1151 0, /* bitpos */
1152 complain_overflow_dont, /* complain_on_overflow */
1153 ppc64_elf_unhandled_reloc, /* special_function */
1154 "R_PPC64_GOT16_LO_DS", /* name */
1155 FALSE, /* partial_inplace */
1156 0, /* src_mask */
1157 0xfffc, /* dst_mask */
1158 FALSE), /* pcrel_offset */
1159
1160 /* Like R_PPC64_PLT16_LO, but for instructions with a DS field. */
1161 HOWTO (R_PPC64_PLT16_LO_DS, /* type */
1162 0, /* rightshift */
1163 1, /* size (0 = byte, 1 = short, 2 = long) */
1164 16, /* bitsize */
1165 FALSE, /* pc_relative */
1166 0, /* bitpos */
1167 complain_overflow_dont, /* complain_on_overflow */
1168 ppc64_elf_unhandled_reloc, /* special_function */
1169 "R_PPC64_PLT16_LO_DS", /* name */
1170 FALSE, /* partial_inplace */
1171 0, /* src_mask */
1172 0xfffc, /* dst_mask */
1173 FALSE), /* pcrel_offset */
1174
1175 /* Like R_PPC64_SECTOFF, but for instructions with a DS field. */
1176 HOWTO (R_PPC64_SECTOFF_DS, /* type */
1177 0, /* rightshift */
1178 1, /* size (0 = byte, 1 = short, 2 = long) */
1179 16, /* bitsize */
1180 FALSE, /* pc_relative */
1181 0, /* bitpos */
1182 complain_overflow_bitfield, /* complain_on_overflow */
1183 ppc64_elf_sectoff_reloc, /* special_function */
1184 "R_PPC64_SECTOFF_DS", /* name */
1185 FALSE, /* partial_inplace */
1186 0, /* src_mask */
1187 0xfffc, /* dst_mask */
1188 FALSE), /* pcrel_offset */
1189
1190 /* Like R_PPC64_SECTOFF_LO, but for instructions with a DS field. */
1191 HOWTO (R_PPC64_SECTOFF_LO_DS, /* type */
1192 0, /* rightshift */
1193 1, /* size (0 = byte, 1 = short, 2 = long) */
1194 16, /* bitsize */
1195 FALSE, /* pc_relative */
1196 0, /* bitpos */
1197 complain_overflow_dont, /* complain_on_overflow */
1198 ppc64_elf_sectoff_reloc, /* special_function */
1199 "R_PPC64_SECTOFF_LO_DS",/* name */
1200 FALSE, /* partial_inplace */
1201 0, /* src_mask */
1202 0xfffc, /* dst_mask */
1203 FALSE), /* pcrel_offset */
1204
1205 /* Like R_PPC64_TOC16, but for instructions with a DS field. */
1206 HOWTO (R_PPC64_TOC16_DS, /* type */
1207 0, /* rightshift */
1208 1, /* size (0 = byte, 1 = short, 2 = long) */
1209 16, /* bitsize */
1210 FALSE, /* pc_relative */
1211 0, /* bitpos */
1212 complain_overflow_signed, /* complain_on_overflow */
1213 ppc64_elf_toc_reloc, /* special_function */
1214 "R_PPC64_TOC16_DS", /* name */
1215 FALSE, /* partial_inplace */
1216 0, /* src_mask */
1217 0xfffc, /* dst_mask */
1218 FALSE), /* pcrel_offset */
1219
1220 /* Like R_PPC64_TOC16_LO, but for instructions with a DS field. */
1221 HOWTO (R_PPC64_TOC16_LO_DS, /* type */
1222 0, /* rightshift */
1223 1, /* size (0 = byte, 1 = short, 2 = long) */
1224 16, /* bitsize */
1225 FALSE, /* pc_relative */
1226 0, /* bitpos */
1227 complain_overflow_dont, /* complain_on_overflow */
1228 ppc64_elf_toc_reloc, /* special_function */
1229 "R_PPC64_TOC16_LO_DS", /* name */
1230 FALSE, /* partial_inplace */
1231 0, /* src_mask */
1232 0xfffc, /* dst_mask */
1233 FALSE), /* pcrel_offset */
1234
1235 /* Like R_PPC64_PLTGOT16, but for instructions with a DS field. */
1236 /* FIXME: R_PPC64_PLTGOT16_DS not implemented. */
1237 HOWTO (R_PPC64_PLTGOT16_DS, /* type */
1238 0, /* rightshift */
1239 1, /* size (0 = byte, 1 = short, 2 = long) */
1240 16, /* bitsize */
1241 FALSE, /* pc_relative */
1242 0, /* bitpos */
1243 complain_overflow_signed, /* complain_on_overflow */
1244 ppc64_elf_unhandled_reloc, /* special_function */
1245 "R_PPC64_PLTGOT16_DS", /* name */
1246 FALSE, /* partial_inplace */
1247 0, /* src_mask */
1248 0xfffc, /* dst_mask */
1249 FALSE), /* pcrel_offset */
1250
1251 /* Like R_PPC64_PLTGOT16_LO, but for instructions with a DS field. */
1252 /* FIXME: R_PPC64_PLTGOT16_LO not implemented. */
1253 HOWTO (R_PPC64_PLTGOT16_LO_DS,/* type */
1254 0, /* rightshift */
1255 1, /* size (0 = byte, 1 = short, 2 = long) */
1256 16, /* bitsize */
1257 FALSE, /* pc_relative */
1258 0, /* bitpos */
1259 complain_overflow_dont, /* complain_on_overflow */
1260 ppc64_elf_unhandled_reloc, /* special_function */
1261 "R_PPC64_PLTGOT16_LO_DS",/* name */
1262 FALSE, /* partial_inplace */
1263 0, /* src_mask */
1264 0xfffc, /* dst_mask */
1265 FALSE), /* pcrel_offset */
1266
1267 /* Marker relocs for TLS. */
1268 HOWTO (R_PPC64_TLS,
1269 0, /* rightshift */
1270 2, /* size (0 = byte, 1 = short, 2 = long) */
1271 32, /* bitsize */
1272 FALSE, /* pc_relative */
1273 0, /* bitpos */
1274 complain_overflow_dont, /* complain_on_overflow */
1275 bfd_elf_generic_reloc, /* special_function */
1276 "R_PPC64_TLS", /* name */
1277 FALSE, /* partial_inplace */
1278 0, /* src_mask */
1279 0, /* dst_mask */
1280 FALSE), /* pcrel_offset */
1281
1282 HOWTO (R_PPC64_TLSGD,
1283 0, /* rightshift */
1284 2, /* size (0 = byte, 1 = short, 2 = long) */
1285 32, /* bitsize */
1286 FALSE, /* pc_relative */
1287 0, /* bitpos */
1288 complain_overflow_dont, /* complain_on_overflow */
1289 bfd_elf_generic_reloc, /* special_function */
1290 "R_PPC64_TLSGD", /* name */
1291 FALSE, /* partial_inplace */
1292 0, /* src_mask */
1293 0, /* dst_mask */
1294 FALSE), /* pcrel_offset */
1295
1296 HOWTO (R_PPC64_TLSLD,
1297 0, /* rightshift */
1298 2, /* size (0 = byte, 1 = short, 2 = long) */
1299 32, /* bitsize */
1300 FALSE, /* pc_relative */
1301 0, /* bitpos */
1302 complain_overflow_dont, /* complain_on_overflow */
1303 bfd_elf_generic_reloc, /* special_function */
1304 "R_PPC64_TLSLD", /* name */
1305 FALSE, /* partial_inplace */
1306 0, /* src_mask */
1307 0, /* dst_mask */
1308 FALSE), /* pcrel_offset */
1309
1310 HOWTO (R_PPC64_TOCSAVE,
1311 0, /* rightshift */
1312 2, /* size (0 = byte, 1 = short, 2 = long) */
1313 32, /* bitsize */
1314 FALSE, /* pc_relative */
1315 0, /* bitpos */
1316 complain_overflow_dont, /* complain_on_overflow */
1317 bfd_elf_generic_reloc, /* special_function */
1318 "R_PPC64_TOCSAVE", /* name */
1319 FALSE, /* partial_inplace */
1320 0, /* src_mask */
1321 0, /* dst_mask */
1322 FALSE), /* pcrel_offset */
1323
1324 /* Computes the load module index of the load module that contains the
1325 definition of its TLS sym. */
1326 HOWTO (R_PPC64_DTPMOD64,
1327 0, /* rightshift */
1328 4, /* size (0 = byte, 1 = short, 2 = long) */
1329 64, /* bitsize */
1330 FALSE, /* pc_relative */
1331 0, /* bitpos */
1332 complain_overflow_dont, /* complain_on_overflow */
1333 ppc64_elf_unhandled_reloc, /* special_function */
1334 "R_PPC64_DTPMOD64", /* name */
1335 FALSE, /* partial_inplace */
1336 0, /* src_mask */
1337 ONES (64), /* dst_mask */
1338 FALSE), /* pcrel_offset */
1339
1340 /* Computes a dtv-relative displacement, the difference between the value
1341 of sym+add and the base address of the thread-local storage block that
1342 contains the definition of sym, minus 0x8000. */
1343 HOWTO (R_PPC64_DTPREL64,
1344 0, /* rightshift */
1345 4, /* size (0 = byte, 1 = short, 2 = long) */
1346 64, /* bitsize */
1347 FALSE, /* pc_relative */
1348 0, /* bitpos */
1349 complain_overflow_dont, /* complain_on_overflow */
1350 ppc64_elf_unhandled_reloc, /* special_function */
1351 "R_PPC64_DTPREL64", /* name */
1352 FALSE, /* partial_inplace */
1353 0, /* src_mask */
1354 ONES (64), /* dst_mask */
1355 FALSE), /* pcrel_offset */
1356
1357 /* A 16 bit dtprel reloc. */
1358 HOWTO (R_PPC64_DTPREL16,
1359 0, /* rightshift */
1360 1, /* size (0 = byte, 1 = short, 2 = long) */
1361 16, /* bitsize */
1362 FALSE, /* pc_relative */
1363 0, /* bitpos */
1364 complain_overflow_signed, /* complain_on_overflow */
1365 ppc64_elf_unhandled_reloc, /* special_function */
1366 "R_PPC64_DTPREL16", /* name */
1367 FALSE, /* partial_inplace */
1368 0, /* src_mask */
1369 0xffff, /* dst_mask */
1370 FALSE), /* pcrel_offset */
1371
1372 /* Like DTPREL16, but no overflow. */
1373 HOWTO (R_PPC64_DTPREL16_LO,
1374 0, /* rightshift */
1375 1, /* size (0 = byte, 1 = short, 2 = long) */
1376 16, /* bitsize */
1377 FALSE, /* pc_relative */
1378 0, /* bitpos */
1379 complain_overflow_dont, /* complain_on_overflow */
1380 ppc64_elf_unhandled_reloc, /* special_function */
1381 "R_PPC64_DTPREL16_LO", /* name */
1382 FALSE, /* partial_inplace */
1383 0, /* src_mask */
1384 0xffff, /* dst_mask */
1385 FALSE), /* pcrel_offset */
1386
1387 /* Like DTPREL16_LO, but next higher group of 16 bits. */
1388 HOWTO (R_PPC64_DTPREL16_HI,
1389 16, /* rightshift */
1390 1, /* size (0 = byte, 1 = short, 2 = long) */
1391 16, /* bitsize */
1392 FALSE, /* pc_relative */
1393 0, /* bitpos */
1394 complain_overflow_signed, /* complain_on_overflow */
1395 ppc64_elf_unhandled_reloc, /* special_function */
1396 "R_PPC64_DTPREL16_HI", /* name */
1397 FALSE, /* partial_inplace */
1398 0, /* src_mask */
1399 0xffff, /* dst_mask */
1400 FALSE), /* pcrel_offset */
1401
1402 /* Like DTPREL16_HI, but adjust for low 16 bits. */
1403 HOWTO (R_PPC64_DTPREL16_HA,
1404 16, /* rightshift */
1405 1, /* size (0 = byte, 1 = short, 2 = long) */
1406 16, /* bitsize */
1407 FALSE, /* pc_relative */
1408 0, /* bitpos */
1409 complain_overflow_signed, /* complain_on_overflow */
1410 ppc64_elf_unhandled_reloc, /* special_function */
1411 "R_PPC64_DTPREL16_HA", /* name */
1412 FALSE, /* partial_inplace */
1413 0, /* src_mask */
1414 0xffff, /* dst_mask */
1415 FALSE), /* pcrel_offset */
1416
1417 /* Like DTPREL16_HI, but next higher group of 16 bits. */
1418 HOWTO (R_PPC64_DTPREL16_HIGHER,
1419 32, /* rightshift */
1420 1, /* size (0 = byte, 1 = short, 2 = long) */
1421 16, /* bitsize */
1422 FALSE, /* pc_relative */
1423 0, /* bitpos */
1424 complain_overflow_dont, /* complain_on_overflow */
1425 ppc64_elf_unhandled_reloc, /* special_function */
1426 "R_PPC64_DTPREL16_HIGHER", /* name */
1427 FALSE, /* partial_inplace */
1428 0, /* src_mask */
1429 0xffff, /* dst_mask */
1430 FALSE), /* pcrel_offset */
1431
1432 /* Like DTPREL16_HIGHER, but adjust for low 16 bits. */
1433 HOWTO (R_PPC64_DTPREL16_HIGHERA,
1434 32, /* rightshift */
1435 1, /* size (0 = byte, 1 = short, 2 = long) */
1436 16, /* bitsize */
1437 FALSE, /* pc_relative */
1438 0, /* bitpos */
1439 complain_overflow_dont, /* complain_on_overflow */
1440 ppc64_elf_unhandled_reloc, /* special_function */
1441 "R_PPC64_DTPREL16_HIGHERA", /* name */
1442 FALSE, /* partial_inplace */
1443 0, /* src_mask */
1444 0xffff, /* dst_mask */
1445 FALSE), /* pcrel_offset */
1446
1447 /* Like DTPREL16_HIGHER, but next higher group of 16 bits. */
1448 HOWTO (R_PPC64_DTPREL16_HIGHEST,
1449 48, /* rightshift */
1450 1, /* size (0 = byte, 1 = short, 2 = long) */
1451 16, /* bitsize */
1452 FALSE, /* pc_relative */
1453 0, /* bitpos */
1454 complain_overflow_dont, /* complain_on_overflow */
1455 ppc64_elf_unhandled_reloc, /* special_function */
1456 "R_PPC64_DTPREL16_HIGHEST", /* name */
1457 FALSE, /* partial_inplace */
1458 0, /* src_mask */
1459 0xffff, /* dst_mask */
1460 FALSE), /* pcrel_offset */
1461
1462 /* Like DTPREL16_HIGHEST, but adjust for low 16 bits. */
1463 HOWTO (R_PPC64_DTPREL16_HIGHESTA,
1464 48, /* rightshift */
1465 1, /* size (0 = byte, 1 = short, 2 = long) */
1466 16, /* bitsize */
1467 FALSE, /* pc_relative */
1468 0, /* bitpos */
1469 complain_overflow_dont, /* complain_on_overflow */
1470 ppc64_elf_unhandled_reloc, /* special_function */
1471 "R_PPC64_DTPREL16_HIGHESTA", /* name */
1472 FALSE, /* partial_inplace */
1473 0, /* src_mask */
1474 0xffff, /* dst_mask */
1475 FALSE), /* pcrel_offset */
1476
1477 /* Like DTPREL16, but for insns with a DS field. */
1478 HOWTO (R_PPC64_DTPREL16_DS,
1479 0, /* rightshift */
1480 1, /* size (0 = byte, 1 = short, 2 = long) */
1481 16, /* bitsize */
1482 FALSE, /* pc_relative */
1483 0, /* bitpos */
1484 complain_overflow_signed, /* complain_on_overflow */
1485 ppc64_elf_unhandled_reloc, /* special_function */
1486 "R_PPC64_DTPREL16_DS", /* name */
1487 FALSE, /* partial_inplace */
1488 0, /* src_mask */
1489 0xfffc, /* dst_mask */
1490 FALSE), /* pcrel_offset */
1491
1492 /* Like DTPREL16_DS, but no overflow. */
1493 HOWTO (R_PPC64_DTPREL16_LO_DS,
1494 0, /* rightshift */
1495 1, /* size (0 = byte, 1 = short, 2 = long) */
1496 16, /* bitsize */
1497 FALSE, /* pc_relative */
1498 0, /* bitpos */
1499 complain_overflow_dont, /* complain_on_overflow */
1500 ppc64_elf_unhandled_reloc, /* special_function */
1501 "R_PPC64_DTPREL16_LO_DS", /* name */
1502 FALSE, /* partial_inplace */
1503 0, /* src_mask */
1504 0xfffc, /* dst_mask */
1505 FALSE), /* pcrel_offset */
1506
1507 /* Computes a tp-relative displacement, the difference between the value of
1508 sym+add and the value of the thread pointer (r13). */
1509 HOWTO (R_PPC64_TPREL64,
1510 0, /* rightshift */
1511 4, /* size (0 = byte, 1 = short, 2 = long) */
1512 64, /* bitsize */
1513 FALSE, /* pc_relative */
1514 0, /* bitpos */
1515 complain_overflow_dont, /* complain_on_overflow */
1516 ppc64_elf_unhandled_reloc, /* special_function */
1517 "R_PPC64_TPREL64", /* name */
1518 FALSE, /* partial_inplace */
1519 0, /* src_mask */
1520 ONES (64), /* dst_mask */
1521 FALSE), /* pcrel_offset */
1522
1523 /* A 16 bit tprel reloc. */
1524 HOWTO (R_PPC64_TPREL16,
1525 0, /* rightshift */
1526 1, /* size (0 = byte, 1 = short, 2 = long) */
1527 16, /* bitsize */
1528 FALSE, /* pc_relative */
1529 0, /* bitpos */
1530 complain_overflow_signed, /* complain_on_overflow */
1531 ppc64_elf_unhandled_reloc, /* special_function */
1532 "R_PPC64_TPREL16", /* name */
1533 FALSE, /* partial_inplace */
1534 0, /* src_mask */
1535 0xffff, /* dst_mask */
1536 FALSE), /* pcrel_offset */
1537
1538 /* Like TPREL16, but no overflow. */
1539 HOWTO (R_PPC64_TPREL16_LO,
1540 0, /* rightshift */
1541 1, /* size (0 = byte, 1 = short, 2 = long) */
1542 16, /* bitsize */
1543 FALSE, /* pc_relative */
1544 0, /* bitpos */
1545 complain_overflow_dont, /* complain_on_overflow */
1546 ppc64_elf_unhandled_reloc, /* special_function */
1547 "R_PPC64_TPREL16_LO", /* name */
1548 FALSE, /* partial_inplace */
1549 0, /* src_mask */
1550 0xffff, /* dst_mask */
1551 FALSE), /* pcrel_offset */
1552
1553 /* Like TPREL16_LO, but next higher group of 16 bits. */
1554 HOWTO (R_PPC64_TPREL16_HI,
1555 16, /* rightshift */
1556 1, /* size (0 = byte, 1 = short, 2 = long) */
1557 16, /* bitsize */
1558 FALSE, /* pc_relative */
1559 0, /* bitpos */
1560 complain_overflow_signed, /* complain_on_overflow */
1561 ppc64_elf_unhandled_reloc, /* special_function */
1562 "R_PPC64_TPREL16_HI", /* name */
1563 FALSE, /* partial_inplace */
1564 0, /* src_mask */
1565 0xffff, /* dst_mask */
1566 FALSE), /* pcrel_offset */
1567
1568 /* Like TPREL16_HI, but adjust for low 16 bits. */
1569 HOWTO (R_PPC64_TPREL16_HA,
1570 16, /* rightshift */
1571 1, /* size (0 = byte, 1 = short, 2 = long) */
1572 16, /* bitsize */
1573 FALSE, /* pc_relative */
1574 0, /* bitpos */
1575 complain_overflow_signed, /* complain_on_overflow */
1576 ppc64_elf_unhandled_reloc, /* special_function */
1577 "R_PPC64_TPREL16_HA", /* name */
1578 FALSE, /* partial_inplace */
1579 0, /* src_mask */
1580 0xffff, /* dst_mask */
1581 FALSE), /* pcrel_offset */
1582
1583 /* Like TPREL16_HI, but next higher group of 16 bits. */
1584 HOWTO (R_PPC64_TPREL16_HIGHER,
1585 32, /* rightshift */
1586 1, /* size (0 = byte, 1 = short, 2 = long) */
1587 16, /* bitsize */
1588 FALSE, /* pc_relative */
1589 0, /* bitpos */
1590 complain_overflow_dont, /* complain_on_overflow */
1591 ppc64_elf_unhandled_reloc, /* special_function */
1592 "R_PPC64_TPREL16_HIGHER", /* name */
1593 FALSE, /* partial_inplace */
1594 0, /* src_mask */
1595 0xffff, /* dst_mask */
1596 FALSE), /* pcrel_offset */
1597
1598 /* Like TPREL16_HIGHER, but adjust for low 16 bits. */
1599 HOWTO (R_PPC64_TPREL16_HIGHERA,
1600 32, /* rightshift */
1601 1, /* size (0 = byte, 1 = short, 2 = long) */
1602 16, /* bitsize */
1603 FALSE, /* pc_relative */
1604 0, /* bitpos */
1605 complain_overflow_dont, /* complain_on_overflow */
1606 ppc64_elf_unhandled_reloc, /* special_function */
1607 "R_PPC64_TPREL16_HIGHERA", /* name */
1608 FALSE, /* partial_inplace */
1609 0, /* src_mask */
1610 0xffff, /* dst_mask */
1611 FALSE), /* pcrel_offset */
1612
1613 /* Like TPREL16_HIGHER, but next higher group of 16 bits. */
1614 HOWTO (R_PPC64_TPREL16_HIGHEST,
1615 48, /* rightshift */
1616 1, /* size (0 = byte, 1 = short, 2 = long) */
1617 16, /* bitsize */
1618 FALSE, /* pc_relative */
1619 0, /* bitpos */
1620 complain_overflow_dont, /* complain_on_overflow */
1621 ppc64_elf_unhandled_reloc, /* special_function */
1622 "R_PPC64_TPREL16_HIGHEST", /* name */
1623 FALSE, /* partial_inplace */
1624 0, /* src_mask */
1625 0xffff, /* dst_mask */
1626 FALSE), /* pcrel_offset */
1627
1628 /* Like TPREL16_HIGHEST, but adjust for low 16 bits. */
1629 HOWTO (R_PPC64_TPREL16_HIGHESTA,
1630 48, /* rightshift */
1631 1, /* size (0 = byte, 1 = short, 2 = long) */
1632 16, /* bitsize */
1633 FALSE, /* pc_relative */
1634 0, /* bitpos */
1635 complain_overflow_dont, /* complain_on_overflow */
1636 ppc64_elf_unhandled_reloc, /* special_function */
1637 "R_PPC64_TPREL16_HIGHESTA", /* name */
1638 FALSE, /* partial_inplace */
1639 0, /* src_mask */
1640 0xffff, /* dst_mask */
1641 FALSE), /* pcrel_offset */
1642
1643 /* Like TPREL16, but for insns with a DS field. */
1644 HOWTO (R_PPC64_TPREL16_DS,
1645 0, /* rightshift */
1646 1, /* size (0 = byte, 1 = short, 2 = long) */
1647 16, /* bitsize */
1648 FALSE, /* pc_relative */
1649 0, /* bitpos */
1650 complain_overflow_signed, /* complain_on_overflow */
1651 ppc64_elf_unhandled_reloc, /* special_function */
1652 "R_PPC64_TPREL16_DS", /* name */
1653 FALSE, /* partial_inplace */
1654 0, /* src_mask */
1655 0xfffc, /* dst_mask */
1656 FALSE), /* pcrel_offset */
1657
1658 /* Like TPREL16_DS, but no overflow. */
1659 HOWTO (R_PPC64_TPREL16_LO_DS,
1660 0, /* rightshift */
1661 1, /* size (0 = byte, 1 = short, 2 = long) */
1662 16, /* bitsize */
1663 FALSE, /* pc_relative */
1664 0, /* bitpos */
1665 complain_overflow_dont, /* complain_on_overflow */
1666 ppc64_elf_unhandled_reloc, /* special_function */
1667 "R_PPC64_TPREL16_LO_DS", /* name */
1668 FALSE, /* partial_inplace */
1669 0, /* src_mask */
1670 0xfffc, /* dst_mask */
1671 FALSE), /* pcrel_offset */
1672
1673 /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1674 with values (sym+add)@dtpmod and (sym+add)@dtprel, and computes the offset
1675 to the first entry relative to the TOC base (r2). */
1676 HOWTO (R_PPC64_GOT_TLSGD16,
1677 0, /* rightshift */
1678 1, /* size (0 = byte, 1 = short, 2 = long) */
1679 16, /* bitsize */
1680 FALSE, /* pc_relative */
1681 0, /* bitpos */
1682 complain_overflow_signed, /* complain_on_overflow */
1683 ppc64_elf_unhandled_reloc, /* special_function */
1684 "R_PPC64_GOT_TLSGD16", /* name */
1685 FALSE, /* partial_inplace */
1686 0, /* src_mask */
1687 0xffff, /* dst_mask */
1688 FALSE), /* pcrel_offset */
1689
1690 /* Like GOT_TLSGD16, but no overflow. */
1691 HOWTO (R_PPC64_GOT_TLSGD16_LO,
1692 0, /* rightshift */
1693 1, /* size (0 = byte, 1 = short, 2 = long) */
1694 16, /* bitsize */
1695 FALSE, /* pc_relative */
1696 0, /* bitpos */
1697 complain_overflow_dont, /* complain_on_overflow */
1698 ppc64_elf_unhandled_reloc, /* special_function */
1699 "R_PPC64_GOT_TLSGD16_LO", /* name */
1700 FALSE, /* partial_inplace */
1701 0, /* src_mask */
1702 0xffff, /* dst_mask */
1703 FALSE), /* pcrel_offset */
1704
1705 /* Like GOT_TLSGD16_LO, but next higher group of 16 bits. */
1706 HOWTO (R_PPC64_GOT_TLSGD16_HI,
1707 16, /* rightshift */
1708 1, /* size (0 = byte, 1 = short, 2 = long) */
1709 16, /* bitsize */
1710 FALSE, /* pc_relative */
1711 0, /* bitpos */
1712 complain_overflow_signed, /* complain_on_overflow */
1713 ppc64_elf_unhandled_reloc, /* special_function */
1714 "R_PPC64_GOT_TLSGD16_HI", /* name */
1715 FALSE, /* partial_inplace */
1716 0, /* src_mask */
1717 0xffff, /* dst_mask */
1718 FALSE), /* pcrel_offset */
1719
1720 /* Like GOT_TLSGD16_HI, but adjust for low 16 bits. */
1721 HOWTO (R_PPC64_GOT_TLSGD16_HA,
1722 16, /* rightshift */
1723 1, /* size (0 = byte, 1 = short, 2 = long) */
1724 16, /* bitsize */
1725 FALSE, /* pc_relative */
1726 0, /* bitpos */
1727 complain_overflow_signed, /* complain_on_overflow */
1728 ppc64_elf_unhandled_reloc, /* special_function */
1729 "R_PPC64_GOT_TLSGD16_HA", /* name */
1730 FALSE, /* partial_inplace */
1731 0, /* src_mask */
1732 0xffff, /* dst_mask */
1733 FALSE), /* pcrel_offset */
1734
1735 /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1736 with values (sym+add)@dtpmod and zero, and computes the offset to the
1737 first entry relative to the TOC base (r2). */
1738 HOWTO (R_PPC64_GOT_TLSLD16,
1739 0, /* rightshift */
1740 1, /* size (0 = byte, 1 = short, 2 = long) */
1741 16, /* bitsize */
1742 FALSE, /* pc_relative */
1743 0, /* bitpos */
1744 complain_overflow_signed, /* complain_on_overflow */
1745 ppc64_elf_unhandled_reloc, /* special_function */
1746 "R_PPC64_GOT_TLSLD16", /* name */
1747 FALSE, /* partial_inplace */
1748 0, /* src_mask */
1749 0xffff, /* dst_mask */
1750 FALSE), /* pcrel_offset */
1751
1752 /* Like GOT_TLSLD16, but no overflow. */
1753 HOWTO (R_PPC64_GOT_TLSLD16_LO,
1754 0, /* rightshift */
1755 1, /* size (0 = byte, 1 = short, 2 = long) */
1756 16, /* bitsize */
1757 FALSE, /* pc_relative */
1758 0, /* bitpos */
1759 complain_overflow_dont, /* complain_on_overflow */
1760 ppc64_elf_unhandled_reloc, /* special_function */
1761 "R_PPC64_GOT_TLSLD16_LO", /* name */
1762 FALSE, /* partial_inplace */
1763 0, /* src_mask */
1764 0xffff, /* dst_mask */
1765 FALSE), /* pcrel_offset */
1766
1767 /* Like GOT_TLSLD16_LO, but next higher group of 16 bits. */
1768 HOWTO (R_PPC64_GOT_TLSLD16_HI,
1769 16, /* rightshift */
1770 1, /* size (0 = byte, 1 = short, 2 = long) */
1771 16, /* bitsize */
1772 FALSE, /* pc_relative */
1773 0, /* bitpos */
1774 complain_overflow_signed, /* complain_on_overflow */
1775 ppc64_elf_unhandled_reloc, /* special_function */
1776 "R_PPC64_GOT_TLSLD16_HI", /* name */
1777 FALSE, /* partial_inplace */
1778 0, /* src_mask */
1779 0xffff, /* dst_mask */
1780 FALSE), /* pcrel_offset */
1781
1782 /* Like GOT_TLSLD16_HI, but adjust for low 16 bits. */
1783 HOWTO (R_PPC64_GOT_TLSLD16_HA,
1784 16, /* rightshift */
1785 1, /* size (0 = byte, 1 = short, 2 = long) */
1786 16, /* bitsize */
1787 FALSE, /* pc_relative */
1788 0, /* bitpos */
1789 complain_overflow_signed, /* complain_on_overflow */
1790 ppc64_elf_unhandled_reloc, /* special_function */
1791 "R_PPC64_GOT_TLSLD16_HA", /* name */
1792 FALSE, /* partial_inplace */
1793 0, /* src_mask */
1794 0xffff, /* dst_mask */
1795 FALSE), /* pcrel_offset */
1796
1797 /* Allocates an entry in the GOT with value (sym+add)@dtprel, and computes
1798 the offset to the entry relative to the TOC base (r2). */
1799 HOWTO (R_PPC64_GOT_DTPREL16_DS,
1800 0, /* rightshift */
1801 1, /* size (0 = byte, 1 = short, 2 = long) */
1802 16, /* bitsize */
1803 FALSE, /* pc_relative */
1804 0, /* bitpos */
1805 complain_overflow_signed, /* complain_on_overflow */
1806 ppc64_elf_unhandled_reloc, /* special_function */
1807 "R_PPC64_GOT_DTPREL16_DS", /* name */
1808 FALSE, /* partial_inplace */
1809 0, /* src_mask */
1810 0xfffc, /* dst_mask */
1811 FALSE), /* pcrel_offset */
1812
1813 /* Like GOT_DTPREL16_DS, but no overflow. */
1814 HOWTO (R_PPC64_GOT_DTPREL16_LO_DS,
1815 0, /* rightshift */
1816 1, /* size (0 = byte, 1 = short, 2 = long) */
1817 16, /* bitsize */
1818 FALSE, /* pc_relative */
1819 0, /* bitpos */
1820 complain_overflow_dont, /* complain_on_overflow */
1821 ppc64_elf_unhandled_reloc, /* special_function */
1822 "R_PPC64_GOT_DTPREL16_LO_DS", /* name */
1823 FALSE, /* partial_inplace */
1824 0, /* src_mask */
1825 0xfffc, /* dst_mask */
1826 FALSE), /* pcrel_offset */
1827
1828 /* Like GOT_DTPREL16_LO_DS, but next higher group of 16 bits. */
1829 HOWTO (R_PPC64_GOT_DTPREL16_HI,
1830 16, /* rightshift */
1831 1, /* size (0 = byte, 1 = short, 2 = long) */
1832 16, /* bitsize */
1833 FALSE, /* pc_relative */
1834 0, /* bitpos */
1835 complain_overflow_signed, /* complain_on_overflow */
1836 ppc64_elf_unhandled_reloc, /* special_function */
1837 "R_PPC64_GOT_DTPREL16_HI", /* name */
1838 FALSE, /* partial_inplace */
1839 0, /* src_mask */
1840 0xffff, /* dst_mask */
1841 FALSE), /* pcrel_offset */
1842
1843 /* Like GOT_DTPREL16_HI, but adjust for low 16 bits. */
1844 HOWTO (R_PPC64_GOT_DTPREL16_HA,
1845 16, /* rightshift */
1846 1, /* size (0 = byte, 1 = short, 2 = long) */
1847 16, /* bitsize */
1848 FALSE, /* pc_relative */
1849 0, /* bitpos */
1850 complain_overflow_signed, /* complain_on_overflow */
1851 ppc64_elf_unhandled_reloc, /* special_function */
1852 "R_PPC64_GOT_DTPREL16_HA", /* name */
1853 FALSE, /* partial_inplace */
1854 0, /* src_mask */
1855 0xffff, /* dst_mask */
1856 FALSE), /* pcrel_offset */
1857
1858 /* Allocates an entry in the GOT with value (sym+add)@tprel, and computes the
1859 offset to the entry relative to the TOC base (r2). */
1860 HOWTO (R_PPC64_GOT_TPREL16_DS,
1861 0, /* rightshift */
1862 1, /* size (0 = byte, 1 = short, 2 = long) */
1863 16, /* bitsize */
1864 FALSE, /* pc_relative */
1865 0, /* bitpos */
1866 complain_overflow_signed, /* complain_on_overflow */
1867 ppc64_elf_unhandled_reloc, /* special_function */
1868 "R_PPC64_GOT_TPREL16_DS", /* name */
1869 FALSE, /* partial_inplace */
1870 0, /* src_mask */
1871 0xfffc, /* dst_mask */
1872 FALSE), /* pcrel_offset */
1873
1874 /* Like GOT_TPREL16_DS, but no overflow. */
1875 HOWTO (R_PPC64_GOT_TPREL16_LO_DS,
1876 0, /* rightshift */
1877 1, /* size (0 = byte, 1 = short, 2 = long) */
1878 16, /* bitsize */
1879 FALSE, /* pc_relative */
1880 0, /* bitpos */
1881 complain_overflow_dont, /* complain_on_overflow */
1882 ppc64_elf_unhandled_reloc, /* special_function */
1883 "R_PPC64_GOT_TPREL16_LO_DS", /* name */
1884 FALSE, /* partial_inplace */
1885 0, /* src_mask */
1886 0xfffc, /* dst_mask */
1887 FALSE), /* pcrel_offset */
1888
1889 /* Like GOT_TPREL16_LO_DS, but next higher group of 16 bits. */
1890 HOWTO (R_PPC64_GOT_TPREL16_HI,
1891 16, /* rightshift */
1892 1, /* size (0 = byte, 1 = short, 2 = long) */
1893 16, /* bitsize */
1894 FALSE, /* pc_relative */
1895 0, /* bitpos */
1896 complain_overflow_signed, /* complain_on_overflow */
1897 ppc64_elf_unhandled_reloc, /* special_function */
1898 "R_PPC64_GOT_TPREL16_HI", /* name */
1899 FALSE, /* partial_inplace */
1900 0, /* src_mask */
1901 0xffff, /* dst_mask */
1902 FALSE), /* pcrel_offset */
1903
1904 /* Like GOT_TPREL16_HI, but adjust for low 16 bits. */
1905 HOWTO (R_PPC64_GOT_TPREL16_HA,
1906 16, /* rightshift */
1907 1, /* size (0 = byte, 1 = short, 2 = long) */
1908 16, /* bitsize */
1909 FALSE, /* pc_relative */
1910 0, /* bitpos */
1911 complain_overflow_signed, /* complain_on_overflow */
1912 ppc64_elf_unhandled_reloc, /* special_function */
1913 "R_PPC64_GOT_TPREL16_HA", /* name */
1914 FALSE, /* partial_inplace */
1915 0, /* src_mask */
1916 0xffff, /* dst_mask */
1917 FALSE), /* pcrel_offset */
1918
1919 HOWTO (R_PPC64_JMP_IREL, /* type */
1920 0, /* rightshift */
1921 0, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1922 0, /* bitsize */
1923 FALSE, /* pc_relative */
1924 0, /* bitpos */
1925 complain_overflow_dont, /* complain_on_overflow */
1926 ppc64_elf_unhandled_reloc, /* special_function */
1927 "R_PPC64_JMP_IREL", /* name */
1928 FALSE, /* partial_inplace */
1929 0, /* src_mask */
1930 0, /* dst_mask */
1931 FALSE), /* pcrel_offset */
1932
1933 HOWTO (R_PPC64_IRELATIVE, /* type */
1934 0, /* rightshift */
1935 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1936 64, /* bitsize */
1937 FALSE, /* pc_relative */
1938 0, /* bitpos */
1939 complain_overflow_dont, /* complain_on_overflow */
1940 bfd_elf_generic_reloc, /* special_function */
1941 "R_PPC64_IRELATIVE", /* name */
1942 FALSE, /* partial_inplace */
1943 0, /* src_mask */
1944 ONES (64), /* dst_mask */
1945 FALSE), /* pcrel_offset */
1946
1947 /* A 16 bit relative relocation. */
1948 HOWTO (R_PPC64_REL16, /* type */
1949 0, /* rightshift */
1950 1, /* size (0 = byte, 1 = short, 2 = long) */
1951 16, /* bitsize */
1952 TRUE, /* pc_relative */
1953 0, /* bitpos */
1954 complain_overflow_bitfield, /* complain_on_overflow */
1955 bfd_elf_generic_reloc, /* special_function */
1956 "R_PPC64_REL16", /* name */
1957 FALSE, /* partial_inplace */
1958 0, /* src_mask */
1959 0xffff, /* dst_mask */
1960 TRUE), /* pcrel_offset */
1961
1962 /* A 16 bit relative relocation without overflow. */
1963 HOWTO (R_PPC64_REL16_LO, /* type */
1964 0, /* rightshift */
1965 1, /* size (0 = byte, 1 = short, 2 = long) */
1966 16, /* bitsize */
1967 TRUE, /* pc_relative */
1968 0, /* bitpos */
1969 complain_overflow_dont,/* complain_on_overflow */
1970 bfd_elf_generic_reloc, /* special_function */
1971 "R_PPC64_REL16_LO", /* name */
1972 FALSE, /* partial_inplace */
1973 0, /* src_mask */
1974 0xffff, /* dst_mask */
1975 TRUE), /* pcrel_offset */
1976
1977 /* The high order 16 bits of a relative address. */
1978 HOWTO (R_PPC64_REL16_HI, /* type */
1979 16, /* rightshift */
1980 1, /* size (0 = byte, 1 = short, 2 = long) */
1981 16, /* bitsize */
1982 TRUE, /* pc_relative */
1983 0, /* bitpos */
1984 complain_overflow_signed, /* complain_on_overflow */
1985 bfd_elf_generic_reloc, /* special_function */
1986 "R_PPC64_REL16_HI", /* name */
1987 FALSE, /* partial_inplace */
1988 0, /* src_mask */
1989 0xffff, /* dst_mask */
1990 TRUE), /* pcrel_offset */
1991
1992 /* The high order 16 bits of a relative address, plus 1 if the contents of
1993 the low 16 bits, treated as a signed number, is negative. */
1994 HOWTO (R_PPC64_REL16_HA, /* type */
1995 16, /* rightshift */
1996 1, /* size (0 = byte, 1 = short, 2 = long) */
1997 16, /* bitsize */
1998 TRUE, /* pc_relative */
1999 0, /* bitpos */
2000 complain_overflow_signed, /* complain_on_overflow */
2001 ppc64_elf_ha_reloc, /* special_function */
2002 "R_PPC64_REL16_HA", /* name */
2003 FALSE, /* partial_inplace */
2004 0, /* src_mask */
2005 0xffff, /* dst_mask */
2006 TRUE), /* pcrel_offset */
2007
2008 /* Like R_PPC64_ADDR16_HI, but no overflow. */
2009 HOWTO (R_PPC64_ADDR16_HIGH, /* type */
2010 16, /* rightshift */
2011 1, /* size (0 = byte, 1 = short, 2 = long) */
2012 16, /* bitsize */
2013 FALSE, /* pc_relative */
2014 0, /* bitpos */
2015 complain_overflow_dont, /* complain_on_overflow */
2016 bfd_elf_generic_reloc, /* special_function */
2017 "R_PPC64_ADDR16_HIGH", /* name */
2018 FALSE, /* partial_inplace */
2019 0, /* src_mask */
2020 0xffff, /* dst_mask */
2021 FALSE), /* pcrel_offset */
2022
2023 /* Like R_PPC64_ADDR16_HA, but no overflow. */
2024 HOWTO (R_PPC64_ADDR16_HIGHA, /* type */
2025 16, /* rightshift */
2026 1, /* size (0 = byte, 1 = short, 2 = long) */
2027 16, /* bitsize */
2028 FALSE, /* pc_relative */
2029 0, /* bitpos */
2030 complain_overflow_dont, /* complain_on_overflow */
2031 ppc64_elf_ha_reloc, /* special_function */
2032 "R_PPC64_ADDR16_HIGHA", /* name */
2033 FALSE, /* partial_inplace */
2034 0, /* src_mask */
2035 0xffff, /* dst_mask */
2036 FALSE), /* pcrel_offset */
2037
2038 /* Like R_PPC64_DTPREL16_HI, but no overflow. */
2039 HOWTO (R_PPC64_DTPREL16_HIGH,
2040 16, /* rightshift */
2041 1, /* size (0 = byte, 1 = short, 2 = long) */
2042 16, /* bitsize */
2043 FALSE, /* pc_relative */
2044 0, /* bitpos */
2045 complain_overflow_dont, /* complain_on_overflow */
2046 ppc64_elf_unhandled_reloc, /* special_function */
2047 "R_PPC64_DTPREL16_HIGH", /* name */
2048 FALSE, /* partial_inplace */
2049 0, /* src_mask */
2050 0xffff, /* dst_mask */
2051 FALSE), /* pcrel_offset */
2052
2053 /* Like R_PPC64_DTPREL16_HA, but no overflow. */
2054 HOWTO (R_PPC64_DTPREL16_HIGHA,
2055 16, /* rightshift */
2056 1, /* size (0 = byte, 1 = short, 2 = long) */
2057 16, /* bitsize */
2058 FALSE, /* pc_relative */
2059 0, /* bitpos */
2060 complain_overflow_dont, /* complain_on_overflow */
2061 ppc64_elf_unhandled_reloc, /* special_function */
2062 "R_PPC64_DTPREL16_HIGHA", /* name */
2063 FALSE, /* partial_inplace */
2064 0, /* src_mask */
2065 0xffff, /* dst_mask */
2066 FALSE), /* pcrel_offset */
2067
2068 /* Like R_PPC64_TPREL16_HI, but no overflow. */
2069 HOWTO (R_PPC64_TPREL16_HIGH,
2070 16, /* rightshift */
2071 1, /* size (0 = byte, 1 = short, 2 = long) */
2072 16, /* bitsize */
2073 FALSE, /* pc_relative */
2074 0, /* bitpos */
2075 complain_overflow_dont, /* complain_on_overflow */
2076 ppc64_elf_unhandled_reloc, /* special_function */
2077 "R_PPC64_TPREL16_HIGH", /* name */
2078 FALSE, /* partial_inplace */
2079 0, /* src_mask */
2080 0xffff, /* dst_mask */
2081 FALSE), /* pcrel_offset */
2082
2083 /* Like R_PPC64_TPREL16_HA, but no overflow. */
2084 HOWTO (R_PPC64_TPREL16_HIGHA,
2085 16, /* rightshift */
2086 1, /* size (0 = byte, 1 = short, 2 = long) */
2087 16, /* bitsize */
2088 FALSE, /* pc_relative */
2089 0, /* bitpos */
2090 complain_overflow_dont, /* complain_on_overflow */
2091 ppc64_elf_unhandled_reloc, /* special_function */
2092 "R_PPC64_TPREL16_HIGHA", /* name */
2093 FALSE, /* partial_inplace */
2094 0, /* src_mask */
2095 0xffff, /* dst_mask */
2096 FALSE), /* pcrel_offset */
2097
2098 /* GNU extension to record C++ vtable hierarchy. */
2099 HOWTO (R_PPC64_GNU_VTINHERIT, /* type */
2100 0, /* rightshift */
2101 0, /* size (0 = byte, 1 = short, 2 = long) */
2102 0, /* bitsize */
2103 FALSE, /* pc_relative */
2104 0, /* bitpos */
2105 complain_overflow_dont, /* complain_on_overflow */
2106 NULL, /* special_function */
2107 "R_PPC64_GNU_VTINHERIT", /* name */
2108 FALSE, /* partial_inplace */
2109 0, /* src_mask */
2110 0, /* dst_mask */
2111 FALSE), /* pcrel_offset */
2112
2113 /* GNU extension to record C++ vtable member usage. */
2114 HOWTO (R_PPC64_GNU_VTENTRY, /* type */
2115 0, /* rightshift */
2116 0, /* size (0 = byte, 1 = short, 2 = long) */
2117 0, /* bitsize */
2118 FALSE, /* pc_relative */
2119 0, /* bitpos */
2120 complain_overflow_dont, /* complain_on_overflow */
2121 NULL, /* special_function */
2122 "R_PPC64_GNU_VTENTRY", /* name */
2123 FALSE, /* partial_inplace */
2124 0, /* src_mask */
2125 0, /* dst_mask */
2126 FALSE), /* pcrel_offset */
2127 };
2128
2129 \f
2130 /* Initialize the ppc64_elf_howto_table, so that linear accesses can
2131 be done. */
2132
2133 static void
2134 ppc_howto_init (void)
2135 {
2136 unsigned int i, type;
2137
2138 for (i = 0;
2139 i < sizeof (ppc64_elf_howto_raw) / sizeof (ppc64_elf_howto_raw[0]);
2140 i++)
2141 {
2142 type = ppc64_elf_howto_raw[i].type;
2143 BFD_ASSERT (type < (sizeof (ppc64_elf_howto_table)
2144 / sizeof (ppc64_elf_howto_table[0])));
2145 ppc64_elf_howto_table[type] = &ppc64_elf_howto_raw[i];
2146 }
2147 }
2148
2149 static reloc_howto_type *
2150 ppc64_elf_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2151 bfd_reloc_code_real_type code)
2152 {
2153 enum elf_ppc64_reloc_type r = R_PPC64_NONE;
2154
2155 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2156 /* Initialize howto table if needed. */
2157 ppc_howto_init ();
2158
2159 switch (code)
2160 {
2161 default:
2162 return NULL;
2163
2164 case BFD_RELOC_NONE: r = R_PPC64_NONE;
2165 break;
2166 case BFD_RELOC_32: r = R_PPC64_ADDR32;
2167 break;
2168 case BFD_RELOC_PPC_BA26: r = R_PPC64_ADDR24;
2169 break;
2170 case BFD_RELOC_16: r = R_PPC64_ADDR16;
2171 break;
2172 case BFD_RELOC_LO16: r = R_PPC64_ADDR16_LO;
2173 break;
2174 case BFD_RELOC_HI16: r = R_PPC64_ADDR16_HI;
2175 break;
2176 case BFD_RELOC_PPC64_ADDR16_HIGH: r = R_PPC64_ADDR16_HIGH;
2177 break;
2178 case BFD_RELOC_HI16_S: r = R_PPC64_ADDR16_HA;
2179 break;
2180 case BFD_RELOC_PPC64_ADDR16_HIGHA: r = R_PPC64_ADDR16_HIGHA;
2181 break;
2182 case BFD_RELOC_PPC_BA16: r = R_PPC64_ADDR14;
2183 break;
2184 case BFD_RELOC_PPC_BA16_BRTAKEN: r = R_PPC64_ADDR14_BRTAKEN;
2185 break;
2186 case BFD_RELOC_PPC_BA16_BRNTAKEN: r = R_PPC64_ADDR14_BRNTAKEN;
2187 break;
2188 case BFD_RELOC_PPC_B26: r = R_PPC64_REL24;
2189 break;
2190 case BFD_RELOC_PPC_B16: r = R_PPC64_REL14;
2191 break;
2192 case BFD_RELOC_PPC_B16_BRTAKEN: r = R_PPC64_REL14_BRTAKEN;
2193 break;
2194 case BFD_RELOC_PPC_B16_BRNTAKEN: r = R_PPC64_REL14_BRNTAKEN;
2195 break;
2196 case BFD_RELOC_16_GOTOFF: r = R_PPC64_GOT16;
2197 break;
2198 case BFD_RELOC_LO16_GOTOFF: r = R_PPC64_GOT16_LO;
2199 break;
2200 case BFD_RELOC_HI16_GOTOFF: r = R_PPC64_GOT16_HI;
2201 break;
2202 case BFD_RELOC_HI16_S_GOTOFF: r = R_PPC64_GOT16_HA;
2203 break;
2204 case BFD_RELOC_PPC_COPY: r = R_PPC64_COPY;
2205 break;
2206 case BFD_RELOC_PPC_GLOB_DAT: r = R_PPC64_GLOB_DAT;
2207 break;
2208 case BFD_RELOC_32_PCREL: r = R_PPC64_REL32;
2209 break;
2210 case BFD_RELOC_32_PLTOFF: r = R_PPC64_PLT32;
2211 break;
2212 case BFD_RELOC_32_PLT_PCREL: r = R_PPC64_PLTREL32;
2213 break;
2214 case BFD_RELOC_LO16_PLTOFF: r = R_PPC64_PLT16_LO;
2215 break;
2216 case BFD_RELOC_HI16_PLTOFF: r = R_PPC64_PLT16_HI;
2217 break;
2218 case BFD_RELOC_HI16_S_PLTOFF: r = R_PPC64_PLT16_HA;
2219 break;
2220 case BFD_RELOC_16_BASEREL: r = R_PPC64_SECTOFF;
2221 break;
2222 case BFD_RELOC_LO16_BASEREL: r = R_PPC64_SECTOFF_LO;
2223 break;
2224 case BFD_RELOC_HI16_BASEREL: r = R_PPC64_SECTOFF_HI;
2225 break;
2226 case BFD_RELOC_HI16_S_BASEREL: r = R_PPC64_SECTOFF_HA;
2227 break;
2228 case BFD_RELOC_CTOR: r = R_PPC64_ADDR64;
2229 break;
2230 case BFD_RELOC_64: r = R_PPC64_ADDR64;
2231 break;
2232 case BFD_RELOC_PPC64_HIGHER: r = R_PPC64_ADDR16_HIGHER;
2233 break;
2234 case BFD_RELOC_PPC64_HIGHER_S: r = R_PPC64_ADDR16_HIGHERA;
2235 break;
2236 case BFD_RELOC_PPC64_HIGHEST: r = R_PPC64_ADDR16_HIGHEST;
2237 break;
2238 case BFD_RELOC_PPC64_HIGHEST_S: r = R_PPC64_ADDR16_HIGHESTA;
2239 break;
2240 case BFD_RELOC_64_PCREL: r = R_PPC64_REL64;
2241 break;
2242 case BFD_RELOC_64_PLTOFF: r = R_PPC64_PLT64;
2243 break;
2244 case BFD_RELOC_64_PLT_PCREL: r = R_PPC64_PLTREL64;
2245 break;
2246 case BFD_RELOC_PPC_TOC16: r = R_PPC64_TOC16;
2247 break;
2248 case BFD_RELOC_PPC64_TOC16_LO: r = R_PPC64_TOC16_LO;
2249 break;
2250 case BFD_RELOC_PPC64_TOC16_HI: r = R_PPC64_TOC16_HI;
2251 break;
2252 case BFD_RELOC_PPC64_TOC16_HA: r = R_PPC64_TOC16_HA;
2253 break;
2254 case BFD_RELOC_PPC64_TOC: r = R_PPC64_TOC;
2255 break;
2256 case BFD_RELOC_PPC64_PLTGOT16: r = R_PPC64_PLTGOT16;
2257 break;
2258 case BFD_RELOC_PPC64_PLTGOT16_LO: r = R_PPC64_PLTGOT16_LO;
2259 break;
2260 case BFD_RELOC_PPC64_PLTGOT16_HI: r = R_PPC64_PLTGOT16_HI;
2261 break;
2262 case BFD_RELOC_PPC64_PLTGOT16_HA: r = R_PPC64_PLTGOT16_HA;
2263 break;
2264 case BFD_RELOC_PPC64_ADDR16_DS: r = R_PPC64_ADDR16_DS;
2265 break;
2266 case BFD_RELOC_PPC64_ADDR16_LO_DS: r = R_PPC64_ADDR16_LO_DS;
2267 break;
2268 case BFD_RELOC_PPC64_GOT16_DS: r = R_PPC64_GOT16_DS;
2269 break;
2270 case BFD_RELOC_PPC64_GOT16_LO_DS: r = R_PPC64_GOT16_LO_DS;
2271 break;
2272 case BFD_RELOC_PPC64_PLT16_LO_DS: r = R_PPC64_PLT16_LO_DS;
2273 break;
2274 case BFD_RELOC_PPC64_SECTOFF_DS: r = R_PPC64_SECTOFF_DS;
2275 break;
2276 case BFD_RELOC_PPC64_SECTOFF_LO_DS: r = R_PPC64_SECTOFF_LO_DS;
2277 break;
2278 case BFD_RELOC_PPC64_TOC16_DS: r = R_PPC64_TOC16_DS;
2279 break;
2280 case BFD_RELOC_PPC64_TOC16_LO_DS: r = R_PPC64_TOC16_LO_DS;
2281 break;
2282 case BFD_RELOC_PPC64_PLTGOT16_DS: r = R_PPC64_PLTGOT16_DS;
2283 break;
2284 case BFD_RELOC_PPC64_PLTGOT16_LO_DS: r = R_PPC64_PLTGOT16_LO_DS;
2285 break;
2286 case BFD_RELOC_PPC_TLS: r = R_PPC64_TLS;
2287 break;
2288 case BFD_RELOC_PPC_TLSGD: r = R_PPC64_TLSGD;
2289 break;
2290 case BFD_RELOC_PPC_TLSLD: r = R_PPC64_TLSLD;
2291 break;
2292 case BFD_RELOC_PPC_DTPMOD: r = R_PPC64_DTPMOD64;
2293 break;
2294 case BFD_RELOC_PPC_TPREL16: r = R_PPC64_TPREL16;
2295 break;
2296 case BFD_RELOC_PPC_TPREL16_LO: r = R_PPC64_TPREL16_LO;
2297 break;
2298 case BFD_RELOC_PPC_TPREL16_HI: r = R_PPC64_TPREL16_HI;
2299 break;
2300 case BFD_RELOC_PPC64_TPREL16_HIGH: r = R_PPC64_TPREL16_HIGH;
2301 break;
2302 case BFD_RELOC_PPC_TPREL16_HA: r = R_PPC64_TPREL16_HA;
2303 break;
2304 case BFD_RELOC_PPC64_TPREL16_HIGHA: r = R_PPC64_TPREL16_HIGHA;
2305 break;
2306 case BFD_RELOC_PPC_TPREL: r = R_PPC64_TPREL64;
2307 break;
2308 case BFD_RELOC_PPC_DTPREL16: r = R_PPC64_DTPREL16;
2309 break;
2310 case BFD_RELOC_PPC_DTPREL16_LO: r = R_PPC64_DTPREL16_LO;
2311 break;
2312 case BFD_RELOC_PPC_DTPREL16_HI: r = R_PPC64_DTPREL16_HI;
2313 break;
2314 case BFD_RELOC_PPC64_DTPREL16_HIGH: r = R_PPC64_DTPREL16_HIGH;
2315 break;
2316 case BFD_RELOC_PPC_DTPREL16_HA: r = R_PPC64_DTPREL16_HA;
2317 break;
2318 case BFD_RELOC_PPC64_DTPREL16_HIGHA: r = R_PPC64_DTPREL16_HIGHA;
2319 break;
2320 case BFD_RELOC_PPC_DTPREL: r = R_PPC64_DTPREL64;
2321 break;
2322 case BFD_RELOC_PPC_GOT_TLSGD16: r = R_PPC64_GOT_TLSGD16;
2323 break;
2324 case BFD_RELOC_PPC_GOT_TLSGD16_LO: r = R_PPC64_GOT_TLSGD16_LO;
2325 break;
2326 case BFD_RELOC_PPC_GOT_TLSGD16_HI: r = R_PPC64_GOT_TLSGD16_HI;
2327 break;
2328 case BFD_RELOC_PPC_GOT_TLSGD16_HA: r = R_PPC64_GOT_TLSGD16_HA;
2329 break;
2330 case BFD_RELOC_PPC_GOT_TLSLD16: r = R_PPC64_GOT_TLSLD16;
2331 break;
2332 case BFD_RELOC_PPC_GOT_TLSLD16_LO: r = R_PPC64_GOT_TLSLD16_LO;
2333 break;
2334 case BFD_RELOC_PPC_GOT_TLSLD16_HI: r = R_PPC64_GOT_TLSLD16_HI;
2335 break;
2336 case BFD_RELOC_PPC_GOT_TLSLD16_HA: r = R_PPC64_GOT_TLSLD16_HA;
2337 break;
2338 case BFD_RELOC_PPC_GOT_TPREL16: r = R_PPC64_GOT_TPREL16_DS;
2339 break;
2340 case BFD_RELOC_PPC_GOT_TPREL16_LO: r = R_PPC64_GOT_TPREL16_LO_DS;
2341 break;
2342 case BFD_RELOC_PPC_GOT_TPREL16_HI: r = R_PPC64_GOT_TPREL16_HI;
2343 break;
2344 case BFD_RELOC_PPC_GOT_TPREL16_HA: r = R_PPC64_GOT_TPREL16_HA;
2345 break;
2346 case BFD_RELOC_PPC_GOT_DTPREL16: r = R_PPC64_GOT_DTPREL16_DS;
2347 break;
2348 case BFD_RELOC_PPC_GOT_DTPREL16_LO: r = R_PPC64_GOT_DTPREL16_LO_DS;
2349 break;
2350 case BFD_RELOC_PPC_GOT_DTPREL16_HI: r = R_PPC64_GOT_DTPREL16_HI;
2351 break;
2352 case BFD_RELOC_PPC_GOT_DTPREL16_HA: r = R_PPC64_GOT_DTPREL16_HA;
2353 break;
2354 case BFD_RELOC_PPC64_TPREL16_DS: r = R_PPC64_TPREL16_DS;
2355 break;
2356 case BFD_RELOC_PPC64_TPREL16_LO_DS: r = R_PPC64_TPREL16_LO_DS;
2357 break;
2358 case BFD_RELOC_PPC64_TPREL16_HIGHER: r = R_PPC64_TPREL16_HIGHER;
2359 break;
2360 case BFD_RELOC_PPC64_TPREL16_HIGHERA: r = R_PPC64_TPREL16_HIGHERA;
2361 break;
2362 case BFD_RELOC_PPC64_TPREL16_HIGHEST: r = R_PPC64_TPREL16_HIGHEST;
2363 break;
2364 case BFD_RELOC_PPC64_TPREL16_HIGHESTA: r = R_PPC64_TPREL16_HIGHESTA;
2365 break;
2366 case BFD_RELOC_PPC64_DTPREL16_DS: r = R_PPC64_DTPREL16_DS;
2367 break;
2368 case BFD_RELOC_PPC64_DTPREL16_LO_DS: r = R_PPC64_DTPREL16_LO_DS;
2369 break;
2370 case BFD_RELOC_PPC64_DTPREL16_HIGHER: r = R_PPC64_DTPREL16_HIGHER;
2371 break;
2372 case BFD_RELOC_PPC64_DTPREL16_HIGHERA: r = R_PPC64_DTPREL16_HIGHERA;
2373 break;
2374 case BFD_RELOC_PPC64_DTPREL16_HIGHEST: r = R_PPC64_DTPREL16_HIGHEST;
2375 break;
2376 case BFD_RELOC_PPC64_DTPREL16_HIGHESTA: r = R_PPC64_DTPREL16_HIGHESTA;
2377 break;
2378 case BFD_RELOC_16_PCREL: r = R_PPC64_REL16;
2379 break;
2380 case BFD_RELOC_LO16_PCREL: r = R_PPC64_REL16_LO;
2381 break;
2382 case BFD_RELOC_HI16_PCREL: r = R_PPC64_REL16_HI;
2383 break;
2384 case BFD_RELOC_HI16_S_PCREL: r = R_PPC64_REL16_HA;
2385 break;
2386 case BFD_RELOC_VTABLE_INHERIT: r = R_PPC64_GNU_VTINHERIT;
2387 break;
2388 case BFD_RELOC_VTABLE_ENTRY: r = R_PPC64_GNU_VTENTRY;
2389 break;
2390 }
2391
2392 return ppc64_elf_howto_table[r];
2393 };
2394
2395 static reloc_howto_type *
2396 ppc64_elf_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2397 const char *r_name)
2398 {
2399 unsigned int i;
2400
2401 for (i = 0;
2402 i < sizeof (ppc64_elf_howto_raw) / sizeof (ppc64_elf_howto_raw[0]);
2403 i++)
2404 if (ppc64_elf_howto_raw[i].name != NULL
2405 && strcasecmp (ppc64_elf_howto_raw[i].name, r_name) == 0)
2406 return &ppc64_elf_howto_raw[i];
2407
2408 return NULL;
2409 }
2410
2411 /* Set the howto pointer for a PowerPC ELF reloc. */
2412
2413 static void
2414 ppc64_elf_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr,
2415 Elf_Internal_Rela *dst)
2416 {
2417 unsigned int type;
2418
2419 /* Initialize howto table if needed. */
2420 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2421 ppc_howto_init ();
2422
2423 type = ELF64_R_TYPE (dst->r_info);
2424 if (type >= (sizeof (ppc64_elf_howto_table)
2425 / sizeof (ppc64_elf_howto_table[0])))
2426 {
2427 (*_bfd_error_handler) (_("%B: invalid relocation type %d"),
2428 abfd, (int) type);
2429 type = R_PPC64_NONE;
2430 }
2431 cache_ptr->howto = ppc64_elf_howto_table[type];
2432 }
2433
2434 /* Handle the R_PPC64_ADDR16_HA and similar relocs. */
2435
2436 static bfd_reloc_status_type
2437 ppc64_elf_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2438 void *data, asection *input_section,
2439 bfd *output_bfd, char **error_message)
2440 {
2441 /* If this is a relocatable link (output_bfd test tells us), just
2442 call the generic function. Any adjustment will be done at final
2443 link time. */
2444 if (output_bfd != NULL)
2445 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2446 input_section, output_bfd, error_message);
2447
2448 /* Adjust the addend for sign extension of the low 16 bits.
2449 We won't actually be using the low 16 bits, so trashing them
2450 doesn't matter. */
2451 reloc_entry->addend += 0x8000;
2452 return bfd_reloc_continue;
2453 }
2454
2455 static bfd_reloc_status_type
2456 ppc64_elf_branch_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2457 void *data, asection *input_section,
2458 bfd *output_bfd, char **error_message)
2459 {
2460 if (output_bfd != NULL)
2461 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2462 input_section, output_bfd, error_message);
2463
2464 if (strcmp (symbol->section->name, ".opd") == 0
2465 && (symbol->section->owner->flags & DYNAMIC) == 0)
2466 {
2467 bfd_vma dest = opd_entry_value (symbol->section,
2468 symbol->value + reloc_entry->addend,
2469 NULL, NULL, FALSE);
2470 if (dest != (bfd_vma) -1)
2471 reloc_entry->addend = dest - (symbol->value
2472 + symbol->section->output_section->vma
2473 + symbol->section->output_offset);
2474 }
2475 return bfd_reloc_continue;
2476 }
2477
2478 static bfd_reloc_status_type
2479 ppc64_elf_brtaken_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2480 void *data, asection *input_section,
2481 bfd *output_bfd, char **error_message)
2482 {
2483 long insn;
2484 enum elf_ppc64_reloc_type r_type;
2485 bfd_size_type octets;
2486 /* Assume 'at' branch hints. */
2487 bfd_boolean is_isa_v2 = TRUE;
2488
2489 /* If this is a relocatable link (output_bfd test tells us), just
2490 call the generic function. Any adjustment will be done at final
2491 link time. */
2492 if (output_bfd != NULL)
2493 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2494 input_section, output_bfd, error_message);
2495
2496 octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2497 insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
2498 insn &= ~(0x01 << 21);
2499 r_type = reloc_entry->howto->type;
2500 if (r_type == R_PPC64_ADDR14_BRTAKEN
2501 || r_type == R_PPC64_REL14_BRTAKEN)
2502 insn |= 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field. */
2503
2504 if (is_isa_v2)
2505 {
2506 /* Set 'a' bit. This is 0b00010 in BO field for branch
2507 on CR(BI) insns (BO == 001at or 011at), and 0b01000
2508 for branch on CTR insns (BO == 1a00t or 1a01t). */
2509 if ((insn & (0x14 << 21)) == (0x04 << 21))
2510 insn |= 0x02 << 21;
2511 else if ((insn & (0x14 << 21)) == (0x10 << 21))
2512 insn |= 0x08 << 21;
2513 else
2514 goto out;
2515 }
2516 else
2517 {
2518 bfd_vma target = 0;
2519 bfd_vma from;
2520
2521 if (!bfd_is_com_section (symbol->section))
2522 target = symbol->value;
2523 target += symbol->section->output_section->vma;
2524 target += symbol->section->output_offset;
2525 target += reloc_entry->addend;
2526
2527 from = (reloc_entry->address
2528 + input_section->output_offset
2529 + input_section->output_section->vma);
2530
2531 /* Invert 'y' bit if not the default. */
2532 if ((bfd_signed_vma) (target - from) < 0)
2533 insn ^= 0x01 << 21;
2534 }
2535 bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
2536 out:
2537 return ppc64_elf_branch_reloc (abfd, reloc_entry, symbol, data,
2538 input_section, output_bfd, error_message);
2539 }
2540
2541 static bfd_reloc_status_type
2542 ppc64_elf_sectoff_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2543 void *data, asection *input_section,
2544 bfd *output_bfd, char **error_message)
2545 {
2546 /* If this is a relocatable link (output_bfd test tells us), just
2547 call the generic function. Any adjustment will be done at final
2548 link time. */
2549 if (output_bfd != NULL)
2550 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2551 input_section, output_bfd, error_message);
2552
2553 /* Subtract the symbol section base address. */
2554 reloc_entry->addend -= symbol->section->output_section->vma;
2555 return bfd_reloc_continue;
2556 }
2557
2558 static bfd_reloc_status_type
2559 ppc64_elf_sectoff_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2560 void *data, asection *input_section,
2561 bfd *output_bfd, char **error_message)
2562 {
2563 /* If this is a relocatable link (output_bfd test tells us), just
2564 call the generic function. Any adjustment will be done at final
2565 link time. */
2566 if (output_bfd != NULL)
2567 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2568 input_section, output_bfd, error_message);
2569
2570 /* Subtract the symbol section base address. */
2571 reloc_entry->addend -= symbol->section->output_section->vma;
2572
2573 /* Adjust the addend for sign extension of the low 16 bits. */
2574 reloc_entry->addend += 0x8000;
2575 return bfd_reloc_continue;
2576 }
2577
2578 static bfd_reloc_status_type
2579 ppc64_elf_toc_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2580 void *data, asection *input_section,
2581 bfd *output_bfd, char **error_message)
2582 {
2583 bfd_vma TOCstart;
2584
2585 /* If this is a relocatable link (output_bfd test tells us), just
2586 call the generic function. Any adjustment will be done at final
2587 link time. */
2588 if (output_bfd != NULL)
2589 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2590 input_section, output_bfd, error_message);
2591
2592 TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2593 if (TOCstart == 0)
2594 TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2595
2596 /* Subtract the TOC base address. */
2597 reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2598 return bfd_reloc_continue;
2599 }
2600
2601 static bfd_reloc_status_type
2602 ppc64_elf_toc_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2603 void *data, asection *input_section,
2604 bfd *output_bfd, char **error_message)
2605 {
2606 bfd_vma TOCstart;
2607
2608 /* If this is a relocatable link (output_bfd test tells us), just
2609 call the generic function. Any adjustment will be done at final
2610 link time. */
2611 if (output_bfd != NULL)
2612 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2613 input_section, output_bfd, error_message);
2614
2615 TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2616 if (TOCstart == 0)
2617 TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2618
2619 /* Subtract the TOC base address. */
2620 reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2621
2622 /* Adjust the addend for sign extension of the low 16 bits. */
2623 reloc_entry->addend += 0x8000;
2624 return bfd_reloc_continue;
2625 }
2626
2627 static bfd_reloc_status_type
2628 ppc64_elf_toc64_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2629 void *data, asection *input_section,
2630 bfd *output_bfd, char **error_message)
2631 {
2632 bfd_vma TOCstart;
2633 bfd_size_type octets;
2634
2635 /* If this is a relocatable link (output_bfd test tells us), just
2636 call the generic function. Any adjustment will be done at final
2637 link time. */
2638 if (output_bfd != NULL)
2639 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2640 input_section, output_bfd, error_message);
2641
2642 TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2643 if (TOCstart == 0)
2644 TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2645
2646 octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2647 bfd_put_64 (abfd, TOCstart + TOC_BASE_OFF, (bfd_byte *) data + octets);
2648 return bfd_reloc_ok;
2649 }
2650
2651 static bfd_reloc_status_type
2652 ppc64_elf_unhandled_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2653 void *data, asection *input_section,
2654 bfd *output_bfd, char **error_message)
2655 {
2656 /* If this is a relocatable link (output_bfd test tells us), just
2657 call the generic function. Any adjustment will be done at final
2658 link time. */
2659 if (output_bfd != NULL)
2660 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2661 input_section, output_bfd, error_message);
2662
2663 if (error_message != NULL)
2664 {
2665 static char buf[60];
2666 sprintf (buf, "generic linker can't handle %s",
2667 reloc_entry->howto->name);
2668 *error_message = buf;
2669 }
2670 return bfd_reloc_dangerous;
2671 }
2672
2673 /* Track GOT entries needed for a given symbol. We might need more
2674 than one got entry per symbol. */
2675 struct got_entry
2676 {
2677 struct got_entry *next;
2678
2679 /* The symbol addend that we'll be placing in the GOT. */
2680 bfd_vma addend;
2681
2682 /* Unlike other ELF targets, we use separate GOT entries for the same
2683 symbol referenced from different input files. This is to support
2684 automatic multiple TOC/GOT sections, where the TOC base can vary
2685 from one input file to another. After partitioning into TOC groups
2686 we merge entries within the group.
2687
2688 Point to the BFD owning this GOT entry. */
2689 bfd *owner;
2690
2691 /* Zero for non-tls entries, or TLS_TLS and one of TLS_GD, TLS_LD,
2692 TLS_TPREL or TLS_DTPREL for tls entries. */
2693 unsigned char tls_type;
2694
2695 /* Non-zero if got.ent points to real entry. */
2696 unsigned char is_indirect;
2697
2698 /* Reference count until size_dynamic_sections, GOT offset thereafter. */
2699 union
2700 {
2701 bfd_signed_vma refcount;
2702 bfd_vma offset;
2703 struct got_entry *ent;
2704 } got;
2705 };
2706
2707 /* The same for PLT. */
2708 struct plt_entry
2709 {
2710 struct plt_entry *next;
2711
2712 bfd_vma addend;
2713
2714 union
2715 {
2716 bfd_signed_vma refcount;
2717 bfd_vma offset;
2718 } plt;
2719 };
2720
2721 struct ppc64_elf_obj_tdata
2722 {
2723 struct elf_obj_tdata elf;
2724
2725 /* Shortcuts to dynamic linker sections. */
2726 asection *got;
2727 asection *relgot;
2728
2729 /* Used during garbage collection. We attach global symbols defined
2730 on removed .opd entries to this section so that the sym is removed. */
2731 asection *deleted_section;
2732
2733 /* TLS local dynamic got entry handling. Support for multiple GOT
2734 sections means we potentially need one of these for each input bfd. */
2735 struct got_entry tlsld_got;
2736
2737 union {
2738 /* A copy of relocs before they are modified for --emit-relocs. */
2739 Elf_Internal_Rela *relocs;
2740
2741 /* Section contents. */
2742 bfd_byte *contents;
2743 } opd;
2744
2745 /* Nonzero if this bfd has small toc/got relocs, ie. that expect
2746 the reloc to be in the range -32768 to 32767. */
2747 unsigned int has_small_toc_reloc : 1;
2748
2749 /* Set if toc/got ha relocs detected not using r2, or lo reloc
2750 instruction not one we handle. */
2751 unsigned int unexpected_toc_insn : 1;
2752 };
2753
2754 #define ppc64_elf_tdata(bfd) \
2755 ((struct ppc64_elf_obj_tdata *) (bfd)->tdata.any)
2756
2757 #define ppc64_tlsld_got(bfd) \
2758 (&ppc64_elf_tdata (bfd)->tlsld_got)
2759
2760 #define is_ppc64_elf(bfd) \
2761 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
2762 && elf_object_id (bfd) == PPC64_ELF_DATA)
2763
2764 /* Override the generic function because we store some extras. */
2765
2766 static bfd_boolean
2767 ppc64_elf_mkobject (bfd *abfd)
2768 {
2769 return bfd_elf_allocate_object (abfd, sizeof (struct ppc64_elf_obj_tdata),
2770 PPC64_ELF_DATA);
2771 }
2772
2773 /* Fix bad default arch selected for a 64 bit input bfd when the
2774 default is 32 bit. */
2775
2776 static bfd_boolean
2777 ppc64_elf_object_p (bfd *abfd)
2778 {
2779 if (abfd->arch_info->the_default && abfd->arch_info->bits_per_word == 32)
2780 {
2781 Elf_Internal_Ehdr *i_ehdr = elf_elfheader (abfd);
2782
2783 if (i_ehdr->e_ident[EI_CLASS] == ELFCLASS64)
2784 {
2785 /* Relies on arch after 32 bit default being 64 bit default. */
2786 abfd->arch_info = abfd->arch_info->next;
2787 BFD_ASSERT (abfd->arch_info->bits_per_word == 64);
2788 }
2789 }
2790 return TRUE;
2791 }
2792
2793 /* Support for core dump NOTE sections. */
2794
2795 static bfd_boolean
2796 ppc64_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
2797 {
2798 size_t offset, size;
2799
2800 if (note->descsz != 504)
2801 return FALSE;
2802
2803 /* pr_cursig */
2804 elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
2805
2806 /* pr_pid */
2807 elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 32);
2808
2809 /* pr_reg */
2810 offset = 112;
2811 size = 384;
2812
2813 /* Make a ".reg/999" section. */
2814 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
2815 size, note->descpos + offset);
2816 }
2817
2818 static bfd_boolean
2819 ppc64_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
2820 {
2821 if (note->descsz != 136)
2822 return FALSE;
2823
2824 elf_tdata (abfd)->core->pid
2825 = bfd_get_32 (abfd, note->descdata + 24);
2826 elf_tdata (abfd)->core->program
2827 = _bfd_elfcore_strndup (abfd, note->descdata + 40, 16);
2828 elf_tdata (abfd)->core->command
2829 = _bfd_elfcore_strndup (abfd, note->descdata + 56, 80);
2830
2831 return TRUE;
2832 }
2833
2834 static char *
2835 ppc64_elf_write_core_note (bfd *abfd, char *buf, int *bufsiz, int note_type,
2836 ...)
2837 {
2838 switch (note_type)
2839 {
2840 default:
2841 return NULL;
2842
2843 case NT_PRPSINFO:
2844 {
2845 char data[136];
2846 va_list ap;
2847
2848 va_start (ap, note_type);
2849 memset (data, 0, sizeof (data));
2850 strncpy (data + 40, va_arg (ap, const char *), 16);
2851 strncpy (data + 56, va_arg (ap, const char *), 80);
2852 va_end (ap);
2853 return elfcore_write_note (abfd, buf, bufsiz,
2854 "CORE", note_type, data, sizeof (data));
2855 }
2856
2857 case NT_PRSTATUS:
2858 {
2859 char data[504];
2860 va_list ap;
2861 long pid;
2862 int cursig;
2863 const void *greg;
2864
2865 va_start (ap, note_type);
2866 memset (data, 0, 112);
2867 pid = va_arg (ap, long);
2868 bfd_put_32 (abfd, pid, data + 32);
2869 cursig = va_arg (ap, int);
2870 bfd_put_16 (abfd, cursig, data + 12);
2871 greg = va_arg (ap, const void *);
2872 memcpy (data + 112, greg, 384);
2873 memset (data + 496, 0, 8);
2874 va_end (ap);
2875 return elfcore_write_note (abfd, buf, bufsiz,
2876 "CORE", note_type, data, sizeof (data));
2877 }
2878 }
2879 }
2880
2881 /* Add extra PPC sections. */
2882
2883 static const struct bfd_elf_special_section ppc64_elf_special_sections[]=
2884 {
2885 { STRING_COMMA_LEN (".plt"), 0, SHT_NOBITS, 0 },
2886 { STRING_COMMA_LEN (".sbss"), -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE },
2887 { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2888 { STRING_COMMA_LEN (".toc"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2889 { STRING_COMMA_LEN (".toc1"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2890 { STRING_COMMA_LEN (".tocbss"), 0, SHT_NOBITS, SHF_ALLOC + SHF_WRITE },
2891 { NULL, 0, 0, 0, 0 }
2892 };
2893
2894 enum _ppc64_sec_type {
2895 sec_normal = 0,
2896 sec_opd = 1,
2897 sec_toc = 2
2898 };
2899
2900 struct _ppc64_elf_section_data
2901 {
2902 struct bfd_elf_section_data elf;
2903
2904 union
2905 {
2906 /* An array with one entry for each opd function descriptor. */
2907 struct _opd_sec_data
2908 {
2909 /* Points to the function code section for local opd entries. */
2910 asection **func_sec;
2911
2912 /* After editing .opd, adjust references to opd local syms. */
2913 long *adjust;
2914 } opd;
2915
2916 /* An array for toc sections, indexed by offset/8. */
2917 struct _toc_sec_data
2918 {
2919 /* Specifies the relocation symbol index used at a given toc offset. */
2920 unsigned *symndx;
2921
2922 /* And the relocation addend. */
2923 bfd_vma *add;
2924 } toc;
2925 } u;
2926
2927 enum _ppc64_sec_type sec_type:2;
2928
2929 /* Flag set when small branches are detected. Used to
2930 select suitable defaults for the stub group size. */
2931 unsigned int has_14bit_branch:1;
2932 };
2933
2934 #define ppc64_elf_section_data(sec) \
2935 ((struct _ppc64_elf_section_data *) elf_section_data (sec))
2936
2937 static bfd_boolean
2938 ppc64_elf_new_section_hook (bfd *abfd, asection *sec)
2939 {
2940 if (!sec->used_by_bfd)
2941 {
2942 struct _ppc64_elf_section_data *sdata;
2943 bfd_size_type amt = sizeof (*sdata);
2944
2945 sdata = bfd_zalloc (abfd, amt);
2946 if (sdata == NULL)
2947 return FALSE;
2948 sec->used_by_bfd = sdata;
2949 }
2950
2951 return _bfd_elf_new_section_hook (abfd, sec);
2952 }
2953
2954 static struct _opd_sec_data *
2955 get_opd_info (asection * sec)
2956 {
2957 if (sec != NULL
2958 && ppc64_elf_section_data (sec) != NULL
2959 && ppc64_elf_section_data (sec)->sec_type == sec_opd)
2960 return &ppc64_elf_section_data (sec)->u.opd;
2961 return NULL;
2962 }
2963
2964 static inline int
2965 abiversion (bfd *abfd)
2966 {
2967 return elf_elfheader (abfd)->e_flags & EF_PPC64_ABI;
2968 }
2969
2970 static inline void
2971 set_abiversion (bfd *abfd, int ver)
2972 {
2973 elf_elfheader (abfd)->e_flags &= ~EF_PPC64_ABI;
2974 elf_elfheader (abfd)->e_flags |= ver & EF_PPC64_ABI;
2975 }
2976 \f
2977 /* Parameters for the qsort hook. */
2978 static bfd_boolean synthetic_relocatable;
2979
2980 /* qsort comparison function for ppc64_elf_get_synthetic_symtab. */
2981
2982 static int
2983 compare_symbols (const void *ap, const void *bp)
2984 {
2985 const asymbol *a = * (const asymbol **) ap;
2986 const asymbol *b = * (const asymbol **) bp;
2987
2988 /* Section symbols first. */
2989 if ((a->flags & BSF_SECTION_SYM) && !(b->flags & BSF_SECTION_SYM))
2990 return -1;
2991 if (!(a->flags & BSF_SECTION_SYM) && (b->flags & BSF_SECTION_SYM))
2992 return 1;
2993
2994 /* then .opd symbols. */
2995 if (strcmp (a->section->name, ".opd") == 0
2996 && strcmp (b->section->name, ".opd") != 0)
2997 return -1;
2998 if (strcmp (a->section->name, ".opd") != 0
2999 && strcmp (b->section->name, ".opd") == 0)
3000 return 1;
3001
3002 /* then other code symbols. */
3003 if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3004 == (SEC_CODE | SEC_ALLOC)
3005 && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3006 != (SEC_CODE | SEC_ALLOC))
3007 return -1;
3008
3009 if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3010 != (SEC_CODE | SEC_ALLOC)
3011 && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3012 == (SEC_CODE | SEC_ALLOC))
3013 return 1;
3014
3015 if (synthetic_relocatable)
3016 {
3017 if (a->section->id < b->section->id)
3018 return -1;
3019
3020 if (a->section->id > b->section->id)
3021 return 1;
3022 }
3023
3024 if (a->value + a->section->vma < b->value + b->section->vma)
3025 return -1;
3026
3027 if (a->value + a->section->vma > b->value + b->section->vma)
3028 return 1;
3029
3030 /* For syms with the same value, prefer strong dynamic global function
3031 syms over other syms. */
3032 if ((a->flags & BSF_GLOBAL) != 0 && (b->flags & BSF_GLOBAL) == 0)
3033 return -1;
3034
3035 if ((a->flags & BSF_GLOBAL) == 0 && (b->flags & BSF_GLOBAL) != 0)
3036 return 1;
3037
3038 if ((a->flags & BSF_FUNCTION) != 0 && (b->flags & BSF_FUNCTION) == 0)
3039 return -1;
3040
3041 if ((a->flags & BSF_FUNCTION) == 0 && (b->flags & BSF_FUNCTION) != 0)
3042 return 1;
3043
3044 if ((a->flags & BSF_WEAK) == 0 && (b->flags & BSF_WEAK) != 0)
3045 return -1;
3046
3047 if ((a->flags & BSF_WEAK) != 0 && (b->flags & BSF_WEAK) == 0)
3048 return 1;
3049
3050 if ((a->flags & BSF_DYNAMIC) != 0 && (b->flags & BSF_DYNAMIC) == 0)
3051 return -1;
3052
3053 if ((a->flags & BSF_DYNAMIC) == 0 && (b->flags & BSF_DYNAMIC) != 0)
3054 return 1;
3055
3056 return 0;
3057 }
3058
3059 /* Search SYMS for a symbol of the given VALUE. */
3060
3061 static asymbol *
3062 sym_exists_at (asymbol **syms, long lo, long hi, int id, bfd_vma value)
3063 {
3064 long mid;
3065
3066 if (id == -1)
3067 {
3068 while (lo < hi)
3069 {
3070 mid = (lo + hi) >> 1;
3071 if (syms[mid]->value + syms[mid]->section->vma < value)
3072 lo = mid + 1;
3073 else if (syms[mid]->value + syms[mid]->section->vma > value)
3074 hi = mid;
3075 else
3076 return syms[mid];
3077 }
3078 }
3079 else
3080 {
3081 while (lo < hi)
3082 {
3083 mid = (lo + hi) >> 1;
3084 if (syms[mid]->section->id < id)
3085 lo = mid + 1;
3086 else if (syms[mid]->section->id > id)
3087 hi = mid;
3088 else if (syms[mid]->value < value)
3089 lo = mid + 1;
3090 else if (syms[mid]->value > value)
3091 hi = mid;
3092 else
3093 return syms[mid];
3094 }
3095 }
3096 return NULL;
3097 }
3098
3099 static bfd_boolean
3100 section_covers_vma (bfd *abfd ATTRIBUTE_UNUSED, asection *section, void *ptr)
3101 {
3102 bfd_vma vma = *(bfd_vma *) ptr;
3103 return ((section->flags & SEC_ALLOC) != 0
3104 && section->vma <= vma
3105 && vma < section->vma + section->size);
3106 }
3107
3108 /* Create synthetic symbols, effectively restoring "dot-symbol" function
3109 entry syms. Also generate @plt symbols for the glink branch table. */
3110
3111 static long
3112 ppc64_elf_get_synthetic_symtab (bfd *abfd,
3113 long static_count, asymbol **static_syms,
3114 long dyn_count, asymbol **dyn_syms,
3115 asymbol **ret)
3116 {
3117 asymbol *s;
3118 long i;
3119 long count;
3120 char *names;
3121 long symcount, codesecsym, codesecsymend, secsymend, opdsymend;
3122 asection *opd = NULL;
3123 bfd_boolean relocatable = (abfd->flags & (EXEC_P | DYNAMIC)) == 0;
3124 asymbol **syms;
3125 int abi = abiversion (abfd);
3126
3127 *ret = NULL;
3128
3129 if (abi < 2)
3130 {
3131 opd = bfd_get_section_by_name (abfd, ".opd");
3132 if (opd == NULL && abi == 1)
3133 return 0;
3134 }
3135
3136 symcount = static_count;
3137 if (!relocatable)
3138 symcount += dyn_count;
3139 if (symcount == 0)
3140 return 0;
3141
3142 syms = bfd_malloc ((symcount + 1) * sizeof (*syms));
3143 if (syms == NULL)
3144 return -1;
3145
3146 if (!relocatable && static_count != 0 && dyn_count != 0)
3147 {
3148 /* Use both symbol tables. */
3149 memcpy (syms, static_syms, static_count * sizeof (*syms));
3150 memcpy (syms + static_count, dyn_syms, (dyn_count + 1) * sizeof (*syms));
3151 }
3152 else if (!relocatable && static_count == 0)
3153 memcpy (syms, dyn_syms, (symcount + 1) * sizeof (*syms));
3154 else
3155 memcpy (syms, static_syms, (symcount + 1) * sizeof (*syms));
3156
3157 synthetic_relocatable = relocatable;
3158 qsort (syms, symcount, sizeof (*syms), compare_symbols);
3159
3160 if (!relocatable && symcount > 1)
3161 {
3162 long j;
3163 /* Trim duplicate syms, since we may have merged the normal and
3164 dynamic symbols. Actually, we only care about syms that have
3165 different values, so trim any with the same value. */
3166 for (i = 1, j = 1; i < symcount; ++i)
3167 if (syms[i - 1]->value + syms[i - 1]->section->vma
3168 != syms[i]->value + syms[i]->section->vma)
3169 syms[j++] = syms[i];
3170 symcount = j;
3171 }
3172
3173 i = 0;
3174 if (strcmp (syms[i]->section->name, ".opd") == 0)
3175 ++i;
3176 codesecsym = i;
3177
3178 for (; i < symcount; ++i)
3179 if (((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3180 != (SEC_CODE | SEC_ALLOC))
3181 || (syms[i]->flags & BSF_SECTION_SYM) == 0)
3182 break;
3183 codesecsymend = i;
3184
3185 for (; i < symcount; ++i)
3186 if ((syms[i]->flags & BSF_SECTION_SYM) == 0)
3187 break;
3188 secsymend = i;
3189
3190 for (; i < symcount; ++i)
3191 if (strcmp (syms[i]->section->name, ".opd") != 0)
3192 break;
3193 opdsymend = i;
3194
3195 for (; i < symcount; ++i)
3196 if ((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3197 != (SEC_CODE | SEC_ALLOC))
3198 break;
3199 symcount = i;
3200
3201 count = 0;
3202
3203 if (relocatable)
3204 {
3205 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3206 arelent *r;
3207 size_t size;
3208 long relcount;
3209
3210 if (opdsymend == secsymend)
3211 goto done;
3212
3213 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3214 relcount = (opd->flags & SEC_RELOC) ? opd->reloc_count : 0;
3215 if (relcount == 0)
3216 goto done;
3217
3218 if (!(*slurp_relocs) (abfd, opd, static_syms, FALSE))
3219 {
3220 count = -1;
3221 goto done;
3222 }
3223
3224 size = 0;
3225 for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3226 {
3227 asymbol *sym;
3228
3229 while (r < opd->relocation + relcount
3230 && r->address < syms[i]->value + opd->vma)
3231 ++r;
3232
3233 if (r == opd->relocation + relcount)
3234 break;
3235
3236 if (r->address != syms[i]->value + opd->vma)
3237 continue;
3238
3239 if (r->howto->type != R_PPC64_ADDR64)
3240 continue;
3241
3242 sym = *r->sym_ptr_ptr;
3243 if (!sym_exists_at (syms, opdsymend, symcount,
3244 sym->section->id, sym->value + r->addend))
3245 {
3246 ++count;
3247 size += sizeof (asymbol);
3248 size += strlen (syms[i]->name) + 2;
3249 }
3250 }
3251
3252 s = *ret = bfd_malloc (size);
3253 if (s == NULL)
3254 {
3255 count = -1;
3256 goto done;
3257 }
3258
3259 names = (char *) (s + count);
3260
3261 for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3262 {
3263 asymbol *sym;
3264
3265 while (r < opd->relocation + relcount
3266 && r->address < syms[i]->value + opd->vma)
3267 ++r;
3268
3269 if (r == opd->relocation + relcount)
3270 break;
3271
3272 if (r->address != syms[i]->value + opd->vma)
3273 continue;
3274
3275 if (r->howto->type != R_PPC64_ADDR64)
3276 continue;
3277
3278 sym = *r->sym_ptr_ptr;
3279 if (!sym_exists_at (syms, opdsymend, symcount,
3280 sym->section->id, sym->value + r->addend))
3281 {
3282 size_t len;
3283
3284 *s = *syms[i];
3285 s->flags |= BSF_SYNTHETIC;
3286 s->section = sym->section;
3287 s->value = sym->value + r->addend;
3288 s->name = names;
3289 *names++ = '.';
3290 len = strlen (syms[i]->name);
3291 memcpy (names, syms[i]->name, len + 1);
3292 names += len + 1;
3293 /* Have udata.p point back to the original symbol this
3294 synthetic symbol was derived from. */
3295 s->udata.p = syms[i];
3296 s++;
3297 }
3298 }
3299 }
3300 else
3301 {
3302 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3303 bfd_byte *contents = NULL;
3304 size_t size;
3305 long plt_count = 0;
3306 bfd_vma glink_vma = 0, resolv_vma = 0;
3307 asection *dynamic, *glink = NULL, *relplt = NULL;
3308 arelent *p;
3309
3310 if (opd != NULL && !bfd_malloc_and_get_section (abfd, opd, &contents))
3311 {
3312 free_contents_and_exit:
3313 if (contents)
3314 free (contents);
3315 count = -1;
3316 goto done;
3317 }
3318
3319 size = 0;
3320 for (i = secsymend; i < opdsymend; ++i)
3321 {
3322 bfd_vma ent;
3323
3324 /* Ignore bogus symbols. */
3325 if (syms[i]->value > opd->size - 8)
3326 continue;
3327
3328 ent = bfd_get_64 (abfd, contents + syms[i]->value);
3329 if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3330 {
3331 ++count;
3332 size += sizeof (asymbol);
3333 size += strlen (syms[i]->name) + 2;
3334 }
3335 }
3336
3337 /* Get start of .glink stubs from DT_PPC64_GLINK. */
3338 if (dyn_count != 0
3339 && (dynamic = bfd_get_section_by_name (abfd, ".dynamic")) != NULL)
3340 {
3341 bfd_byte *dynbuf, *extdyn, *extdynend;
3342 size_t extdynsize;
3343 void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *);
3344
3345 if (!bfd_malloc_and_get_section (abfd, dynamic, &dynbuf))
3346 goto free_contents_and_exit;
3347
3348 extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
3349 swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
3350
3351 extdyn = dynbuf;
3352 extdynend = extdyn + dynamic->size;
3353 for (; extdyn < extdynend; extdyn += extdynsize)
3354 {
3355 Elf_Internal_Dyn dyn;
3356 (*swap_dyn_in) (abfd, extdyn, &dyn);
3357
3358 if (dyn.d_tag == DT_NULL)
3359 break;
3360
3361 if (dyn.d_tag == DT_PPC64_GLINK)
3362 {
3363 /* The first glink stub starts at offset 32; see
3364 comment in ppc64_elf_finish_dynamic_sections. */
3365 glink_vma = dyn.d_un.d_val + GLINK_CALL_STUB_SIZE - 8 * 4;
3366 /* The .glink section usually does not survive the final
3367 link; search for the section (usually .text) where the
3368 glink stubs now reside. */
3369 glink = bfd_sections_find_if (abfd, section_covers_vma,
3370 &glink_vma);
3371 break;
3372 }
3373 }
3374
3375 free (dynbuf);
3376 }
3377
3378 if (glink != NULL)
3379 {
3380 /* Determine __glink trampoline by reading the relative branch
3381 from the first glink stub. */
3382 bfd_byte buf[4];
3383 unsigned int off = 0;
3384
3385 while (bfd_get_section_contents (abfd, glink, buf,
3386 glink_vma + off - glink->vma, 4))
3387 {
3388 unsigned int insn = bfd_get_32 (abfd, buf);
3389 insn ^= B_DOT;
3390 if ((insn & ~0x3fffffc) == 0)
3391 {
3392 resolv_vma = glink_vma + off + (insn ^ 0x2000000) - 0x2000000;
3393 break;
3394 }
3395 off += 4;
3396 if (off > 4)
3397 break;
3398 }
3399
3400 if (resolv_vma)
3401 size += sizeof (asymbol) + sizeof ("__glink_PLTresolve");
3402
3403 relplt = bfd_get_section_by_name (abfd, ".rela.plt");
3404 if (relplt != NULL)
3405 {
3406 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3407 if (! (*slurp_relocs) (abfd, relplt, dyn_syms, TRUE))
3408 goto free_contents_and_exit;
3409
3410 plt_count = relplt->size / sizeof (Elf64_External_Rela);
3411 size += plt_count * sizeof (asymbol);
3412
3413 p = relplt->relocation;
3414 for (i = 0; i < plt_count; i++, p++)
3415 {
3416 size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
3417 if (p->addend != 0)
3418 size += sizeof ("+0x") - 1 + 16;
3419 }
3420 }
3421 }
3422
3423 s = *ret = bfd_malloc (size);
3424 if (s == NULL)
3425 goto free_contents_and_exit;
3426
3427 names = (char *) (s + count + plt_count + (resolv_vma != 0));
3428
3429 for (i = secsymend; i < opdsymend; ++i)
3430 {
3431 bfd_vma ent;
3432
3433 if (syms[i]->value > opd->size - 8)
3434 continue;
3435
3436 ent = bfd_get_64 (abfd, contents + syms[i]->value);
3437 if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3438 {
3439 long lo, hi;
3440 size_t len;
3441 asection *sec = abfd->sections;
3442
3443 *s = *syms[i];
3444 lo = codesecsym;
3445 hi = codesecsymend;
3446 while (lo < hi)
3447 {
3448 long mid = (lo + hi) >> 1;
3449 if (syms[mid]->section->vma < ent)
3450 lo = mid + 1;
3451 else if (syms[mid]->section->vma > ent)
3452 hi = mid;
3453 else
3454 {
3455 sec = syms[mid]->section;
3456 break;
3457 }
3458 }
3459
3460 if (lo >= hi && lo > codesecsym)
3461 sec = syms[lo - 1]->section;
3462
3463 for (; sec != NULL; sec = sec->next)
3464 {
3465 if (sec->vma > ent)
3466 break;
3467 /* SEC_LOAD may not be set if SEC is from a separate debug
3468 info file. */
3469 if ((sec->flags & SEC_ALLOC) == 0)
3470 break;
3471 if ((sec->flags & SEC_CODE) != 0)
3472 s->section = sec;
3473 }
3474 s->flags |= BSF_SYNTHETIC;
3475 s->value = ent - s->section->vma;
3476 s->name = names;
3477 *names++ = '.';
3478 len = strlen (syms[i]->name);
3479 memcpy (names, syms[i]->name, len + 1);
3480 names += len + 1;
3481 /* Have udata.p point back to the original symbol this
3482 synthetic symbol was derived from. */
3483 s->udata.p = syms[i];
3484 s++;
3485 }
3486 }
3487 free (contents);
3488
3489 if (glink != NULL && relplt != NULL)
3490 {
3491 if (resolv_vma)
3492 {
3493 /* Add a symbol for the main glink trampoline. */
3494 memset (s, 0, sizeof *s);
3495 s->the_bfd = abfd;
3496 s->flags = BSF_GLOBAL | BSF_SYNTHETIC;
3497 s->section = glink;
3498 s->value = resolv_vma - glink->vma;
3499 s->name = names;
3500 memcpy (names, "__glink_PLTresolve", sizeof ("__glink_PLTresolve"));
3501 names += sizeof ("__glink_PLTresolve");
3502 s++;
3503 count++;
3504 }
3505
3506 /* FIXME: It would be very much nicer to put sym@plt on the
3507 stub rather than on the glink branch table entry. The
3508 objdump disassembler would then use a sensible symbol
3509 name on plt calls. The difficulty in doing so is
3510 a) finding the stubs, and,
3511 b) matching stubs against plt entries, and,
3512 c) there can be multiple stubs for a given plt entry.
3513
3514 Solving (a) could be done by code scanning, but older
3515 ppc64 binaries used different stubs to current code.
3516 (b) is the tricky one since you need to known the toc
3517 pointer for at least one function that uses a pic stub to
3518 be able to calculate the plt address referenced.
3519 (c) means gdb would need to set multiple breakpoints (or
3520 find the glink branch itself) when setting breakpoints
3521 for pending shared library loads. */
3522 p = relplt->relocation;
3523 for (i = 0; i < plt_count; i++, p++)
3524 {
3525 size_t len;
3526
3527 *s = **p->sym_ptr_ptr;
3528 /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set. Since
3529 we are defining a symbol, ensure one of them is set. */
3530 if ((s->flags & BSF_LOCAL) == 0)
3531 s->flags |= BSF_GLOBAL;
3532 s->flags |= BSF_SYNTHETIC;
3533 s->section = glink;
3534 s->value = glink_vma - glink->vma;
3535 s->name = names;
3536 s->udata.p = NULL;
3537 len = strlen ((*p->sym_ptr_ptr)->name);
3538 memcpy (names, (*p->sym_ptr_ptr)->name, len);
3539 names += len;
3540 if (p->addend != 0)
3541 {
3542 memcpy (names, "+0x", sizeof ("+0x") - 1);
3543 names += sizeof ("+0x") - 1;
3544 bfd_sprintf_vma (abfd, names, p->addend);
3545 names += strlen (names);
3546 }
3547 memcpy (names, "@plt", sizeof ("@plt"));
3548 names += sizeof ("@plt");
3549 s++;
3550 if (abi < 2)
3551 {
3552 glink_vma += 8;
3553 if (i >= 0x8000)
3554 glink_vma += 4;
3555 }
3556 else
3557 glink_vma += 4;
3558 }
3559 count += plt_count;
3560 }
3561 }
3562
3563 done:
3564 free (syms);
3565 return count;
3566 }
3567 \f
3568 /* The following functions are specific to the ELF linker, while
3569 functions above are used generally. Those named ppc64_elf_* are
3570 called by the main ELF linker code. They appear in this file more
3571 or less in the order in which they are called. eg.
3572 ppc64_elf_check_relocs is called early in the link process,
3573 ppc64_elf_finish_dynamic_sections is one of the last functions
3574 called.
3575
3576 PowerPC64-ELF uses a similar scheme to PowerPC64-XCOFF in that
3577 functions have both a function code symbol and a function descriptor
3578 symbol. A call to foo in a relocatable object file looks like:
3579
3580 . .text
3581 . x:
3582 . bl .foo
3583 . nop
3584
3585 The function definition in another object file might be:
3586
3587 . .section .opd
3588 . foo: .quad .foo
3589 . .quad .TOC.@tocbase
3590 . .quad 0
3591 .
3592 . .text
3593 . .foo: blr
3594
3595 When the linker resolves the call during a static link, the branch
3596 unsurprisingly just goes to .foo and the .opd information is unused.
3597 If the function definition is in a shared library, things are a little
3598 different: The call goes via a plt call stub, the opd information gets
3599 copied to the plt, and the linker patches the nop.
3600
3601 . x:
3602 . bl .foo_stub
3603 . ld 2,40(1)
3604 .
3605 .
3606 . .foo_stub:
3607 . std 2,40(1) # in practice, the call stub
3608 . addis 11,2,Lfoo@toc@ha # is slightly optimized, but
3609 . addi 11,11,Lfoo@toc@l # this is the general idea
3610 . ld 12,0(11)
3611 . ld 2,8(11)
3612 . mtctr 12
3613 . ld 11,16(11)
3614 . bctr
3615 .
3616 . .section .plt
3617 . Lfoo: reloc (R_PPC64_JMP_SLOT, foo)
3618
3619 The "reloc ()" notation is supposed to indicate that the linker emits
3620 an R_PPC64_JMP_SLOT reloc against foo. The dynamic linker does the opd
3621 copying.
3622
3623 What are the difficulties here? Well, firstly, the relocations
3624 examined by the linker in check_relocs are against the function code
3625 sym .foo, while the dynamic relocation in the plt is emitted against
3626 the function descriptor symbol, foo. Somewhere along the line, we need
3627 to carefully copy dynamic link information from one symbol to the other.
3628 Secondly, the generic part of the elf linker will make .foo a dynamic
3629 symbol as is normal for most other backends. We need foo dynamic
3630 instead, at least for an application final link. However, when
3631 creating a shared library containing foo, we need to have both symbols
3632 dynamic so that references to .foo are satisfied during the early
3633 stages of linking. Otherwise the linker might decide to pull in a
3634 definition from some other object, eg. a static library.
3635
3636 Update: As of August 2004, we support a new convention. Function
3637 calls may use the function descriptor symbol, ie. "bl foo". This
3638 behaves exactly as "bl .foo". */
3639
3640 /* Of those relocs that might be copied as dynamic relocs, this function
3641 selects those that must be copied when linking a shared library,
3642 even when the symbol is local. */
3643
3644 static int
3645 must_be_dyn_reloc (struct bfd_link_info *info,
3646 enum elf_ppc64_reloc_type r_type)
3647 {
3648 switch (r_type)
3649 {
3650 default:
3651 return 1;
3652
3653 case R_PPC64_REL32:
3654 case R_PPC64_REL64:
3655 case R_PPC64_REL30:
3656 return 0;
3657
3658 case R_PPC64_TPREL16:
3659 case R_PPC64_TPREL16_LO:
3660 case R_PPC64_TPREL16_HI:
3661 case R_PPC64_TPREL16_HA:
3662 case R_PPC64_TPREL16_DS:
3663 case R_PPC64_TPREL16_LO_DS:
3664 case R_PPC64_TPREL16_HIGH:
3665 case R_PPC64_TPREL16_HIGHA:
3666 case R_PPC64_TPREL16_HIGHER:
3667 case R_PPC64_TPREL16_HIGHERA:
3668 case R_PPC64_TPREL16_HIGHEST:
3669 case R_PPC64_TPREL16_HIGHESTA:
3670 case R_PPC64_TPREL64:
3671 return !info->executable;
3672 }
3673 }
3674
3675 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
3676 copying dynamic variables from a shared lib into an app's dynbss
3677 section, and instead use a dynamic relocation to point into the
3678 shared lib. With code that gcc generates, it's vital that this be
3679 enabled; In the PowerPC64 ABI, the address of a function is actually
3680 the address of a function descriptor, which resides in the .opd
3681 section. gcc uses the descriptor directly rather than going via the
3682 GOT as some other ABI's do, which means that initialized function
3683 pointers must reference the descriptor. Thus, a function pointer
3684 initialized to the address of a function in a shared library will
3685 either require a copy reloc, or a dynamic reloc. Using a copy reloc
3686 redefines the function descriptor symbol to point to the copy. This
3687 presents a problem as a plt entry for that function is also
3688 initialized from the function descriptor symbol and the copy reloc
3689 may not be initialized first. */
3690 #define ELIMINATE_COPY_RELOCS 1
3691
3692 /* Section name for stubs is the associated section name plus this
3693 string. */
3694 #define STUB_SUFFIX ".stub"
3695
3696 /* Linker stubs.
3697 ppc_stub_long_branch:
3698 Used when a 14 bit branch (or even a 24 bit branch) can't reach its
3699 destination, but a 24 bit branch in a stub section will reach.
3700 . b dest
3701
3702 ppc_stub_plt_branch:
3703 Similar to the above, but a 24 bit branch in the stub section won't
3704 reach its destination.
3705 . addis %r11,%r2,xxx@toc@ha
3706 . ld %r12,xxx@toc@l(%r11)
3707 . mtctr %r12
3708 . bctr
3709
3710 ppc_stub_plt_call:
3711 Used to call a function in a shared library. If it so happens that
3712 the plt entry referenced crosses a 64k boundary, then an extra
3713 "addi %r11,%r11,xxx@toc@l" will be inserted before the "mtctr".
3714 . std %r2,40(%r1)
3715 . addis %r11,%r2,xxx@toc@ha
3716 . ld %r12,xxx+0@toc@l(%r11)
3717 . mtctr %r12
3718 . ld %r2,xxx+8@toc@l(%r11)
3719 . ld %r11,xxx+16@toc@l(%r11)
3720 . bctr
3721
3722 ppc_stub_long_branch and ppc_stub_plt_branch may also have additional
3723 code to adjust the value and save r2 to support multiple toc sections.
3724 A ppc_stub_long_branch with an r2 offset looks like:
3725 . std %r2,40(%r1)
3726 . addis %r2,%r2,off@ha
3727 . addi %r2,%r2,off@l
3728 . b dest
3729
3730 A ppc_stub_plt_branch with an r2 offset looks like:
3731 . std %r2,40(%r1)
3732 . addis %r11,%r2,xxx@toc@ha
3733 . ld %r12,xxx@toc@l(%r11)
3734 . addis %r2,%r2,off@ha
3735 . addi %r2,%r2,off@l
3736 . mtctr %r12
3737 . bctr
3738
3739 In cases where the "addis" instruction would add zero, the "addis" is
3740 omitted and following instructions modified slightly in some cases.
3741 */
3742
3743 enum ppc_stub_type {
3744 ppc_stub_none,
3745 ppc_stub_long_branch,
3746 ppc_stub_long_branch_r2off,
3747 ppc_stub_plt_branch,
3748 ppc_stub_plt_branch_r2off,
3749 ppc_stub_plt_call,
3750 ppc_stub_plt_call_r2save
3751 };
3752
3753 struct ppc_stub_hash_entry {
3754
3755 /* Base hash table entry structure. */
3756 struct bfd_hash_entry root;
3757
3758 enum ppc_stub_type stub_type;
3759
3760 /* The stub section. */
3761 asection *stub_sec;
3762
3763 /* Offset within stub_sec of the beginning of this stub. */
3764 bfd_vma stub_offset;
3765
3766 /* Given the symbol's value and its section we can determine its final
3767 value when building the stubs (so the stub knows where to jump. */
3768 bfd_vma target_value;
3769 asection *target_section;
3770
3771 /* The symbol table entry, if any, that this was derived from. */
3772 struct ppc_link_hash_entry *h;
3773 struct plt_entry *plt_ent;
3774
3775 /* Where this stub is being called from, or, in the case of combined
3776 stub sections, the first input section in the group. */
3777 asection *id_sec;
3778
3779 /* Symbol st_other. */
3780 unsigned char other;
3781 };
3782
3783 struct ppc_branch_hash_entry {
3784
3785 /* Base hash table entry structure. */
3786 struct bfd_hash_entry root;
3787
3788 /* Offset within branch lookup table. */
3789 unsigned int offset;
3790
3791 /* Generation marker. */
3792 unsigned int iter;
3793 };
3794
3795 /* Used to track dynamic relocations for local symbols. */
3796 struct ppc_dyn_relocs
3797 {
3798 struct ppc_dyn_relocs *next;
3799
3800 /* The input section of the reloc. */
3801 asection *sec;
3802
3803 /* Total number of relocs copied for the input section. */
3804 unsigned int count : 31;
3805
3806 /* Whether this entry is for STT_GNU_IFUNC symbols. */
3807 unsigned int ifunc : 1;
3808 };
3809
3810 struct ppc_link_hash_entry
3811 {
3812 struct elf_link_hash_entry elf;
3813
3814 union {
3815 /* A pointer to the most recently used stub hash entry against this
3816 symbol. */
3817 struct ppc_stub_hash_entry *stub_cache;
3818
3819 /* A pointer to the next symbol starting with a '.' */
3820 struct ppc_link_hash_entry *next_dot_sym;
3821 } u;
3822
3823 /* Track dynamic relocs copied for this symbol. */
3824 struct elf_dyn_relocs *dyn_relocs;
3825
3826 /* Link between function code and descriptor symbols. */
3827 struct ppc_link_hash_entry *oh;
3828
3829 /* Flag function code and descriptor symbols. */
3830 unsigned int is_func:1;
3831 unsigned int is_func_descriptor:1;
3832 unsigned int fake:1;
3833
3834 /* Whether global opd/toc sym has been adjusted or not.
3835 After ppc64_elf_edit_opd/ppc64_elf_edit_toc has run, this flag
3836 should be set for all globals defined in any opd/toc section. */
3837 unsigned int adjust_done:1;
3838
3839 /* Set if we twiddled this symbol to weak at some stage. */
3840 unsigned int was_undefined:1;
3841
3842 /* Contexts in which symbol is used in the GOT (or TOC).
3843 TLS_GD .. TLS_EXPLICIT bits are or'd into the mask as the
3844 corresponding relocs are encountered during check_relocs.
3845 tls_optimize clears TLS_GD .. TLS_TPREL when optimizing to
3846 indicate the corresponding GOT entry type is not needed.
3847 tls_optimize may also set TLS_TPRELGD when a GD reloc turns into
3848 a TPREL one. We use a separate flag rather than setting TPREL
3849 just for convenience in distinguishing the two cases. */
3850 #define TLS_GD 1 /* GD reloc. */
3851 #define TLS_LD 2 /* LD reloc. */
3852 #define TLS_TPREL 4 /* TPREL reloc, => IE. */
3853 #define TLS_DTPREL 8 /* DTPREL reloc, => LD. */
3854 #define TLS_TLS 16 /* Any TLS reloc. */
3855 #define TLS_EXPLICIT 32 /* Marks TOC section TLS relocs. */
3856 #define TLS_TPRELGD 64 /* TPREL reloc resulting from GD->IE. */
3857 #define PLT_IFUNC 128 /* STT_GNU_IFUNC. */
3858 unsigned char tls_mask;
3859 };
3860
3861 /* ppc64 ELF linker hash table. */
3862
3863 struct ppc_link_hash_table
3864 {
3865 struct elf_link_hash_table elf;
3866
3867 /* The stub hash table. */
3868 struct bfd_hash_table stub_hash_table;
3869
3870 /* Another hash table for plt_branch stubs. */
3871 struct bfd_hash_table branch_hash_table;
3872
3873 /* Hash table for function prologue tocsave. */
3874 htab_t tocsave_htab;
3875
3876 /* Linker stub bfd. */
3877 bfd *stub_bfd;
3878
3879 /* Linker call-backs. */
3880 asection * (*add_stub_section) (const char *, asection *);
3881 void (*layout_sections_again) (void);
3882
3883 /* Array to keep track of which stub sections have been created, and
3884 information on stub grouping. */
3885 struct map_stub {
3886 /* This is the section to which stubs in the group will be attached. */
3887 asection *link_sec;
3888 /* The stub section. */
3889 asection *stub_sec;
3890 /* Along with elf_gp, specifies the TOC pointer used in this group. */
3891 bfd_vma toc_off;
3892 } *stub_group;
3893
3894 /* Temp used when calculating TOC pointers. */
3895 bfd_vma toc_curr;
3896 bfd *toc_bfd;
3897 asection *toc_first_sec;
3898
3899 /* Highest input section id. */
3900 int top_id;
3901
3902 /* Highest output section index. */
3903 int top_index;
3904
3905 /* Used when adding symbols. */
3906 struct ppc_link_hash_entry *dot_syms;
3907
3908 /* List of input sections for each output section. */
3909 asection **input_list;
3910
3911 /* Shortcuts to get to dynamic linker sections. */
3912 asection *dynbss;
3913 asection *relbss;
3914 asection *glink;
3915 asection *sfpr;
3916 asection *brlt;
3917 asection *relbrlt;
3918 asection *glink_eh_frame;
3919
3920 /* Shortcut to .__tls_get_addr and __tls_get_addr. */
3921 struct ppc_link_hash_entry *tls_get_addr;
3922 struct ppc_link_hash_entry *tls_get_addr_fd;
3923
3924 /* The size of reliplt used by got entry relocs. */
3925 bfd_size_type got_reli_size;
3926
3927 /* Statistics. */
3928 unsigned long stub_count[ppc_stub_plt_call_r2save];
3929
3930 /* Number of stubs against global syms. */
3931 unsigned long stub_globals;
3932
3933 /* Alignment of PLT call stubs. */
3934 unsigned int plt_stub_align:4;
3935
3936 /* Set if we're linking code with function descriptors. */
3937 unsigned int opd_abi:1;
3938
3939 /* Set if PLT call stubs should load r11. */
3940 unsigned int plt_static_chain:1;
3941
3942 /* Set if PLT call stubs need a read-read barrier. */
3943 unsigned int plt_thread_safe:1;
3944
3945 /* Set if we should emit symbols for stubs. */
3946 unsigned int emit_stub_syms:1;
3947
3948 /* Set if __tls_get_addr optimization should not be done. */
3949 unsigned int no_tls_get_addr_opt:1;
3950
3951 /* Support for multiple toc sections. */
3952 unsigned int do_multi_toc:1;
3953 unsigned int multi_toc_needed:1;
3954 unsigned int second_toc_pass:1;
3955 unsigned int do_toc_opt:1;
3956
3957 /* Set on error. */
3958 unsigned int stub_error:1;
3959
3960 /* Temp used by ppc64_elf_process_dot_syms. */
3961 unsigned int twiddled_syms:1;
3962
3963 /* Incremented every time we size stubs. */
3964 unsigned int stub_iteration;
3965
3966 /* Small local sym cache. */
3967 struct sym_cache sym_cache;
3968 };
3969
3970 /* Rename some of the generic section flags to better document how they
3971 are used here. */
3972
3973 /* Nonzero if this section has TLS related relocations. */
3974 #define has_tls_reloc sec_flg0
3975
3976 /* Nonzero if this section has a call to __tls_get_addr. */
3977 #define has_tls_get_addr_call sec_flg1
3978
3979 /* Nonzero if this section has any toc or got relocs. */
3980 #define has_toc_reloc sec_flg2
3981
3982 /* Nonzero if this section has a call to another section that uses
3983 the toc or got. */
3984 #define makes_toc_func_call sec_flg3
3985
3986 /* Recursion protection when determining above flag. */
3987 #define call_check_in_progress sec_flg4
3988 #define call_check_done sec_flg5
3989
3990 /* Get the ppc64 ELF linker hash table from a link_info structure. */
3991
3992 #define ppc_hash_table(p) \
3993 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
3994 == PPC64_ELF_DATA ? ((struct ppc_link_hash_table *) ((p)->hash)) : NULL)
3995
3996 #define ppc_stub_hash_lookup(table, string, create, copy) \
3997 ((struct ppc_stub_hash_entry *) \
3998 bfd_hash_lookup ((table), (string), (create), (copy)))
3999
4000 #define ppc_branch_hash_lookup(table, string, create, copy) \
4001 ((struct ppc_branch_hash_entry *) \
4002 bfd_hash_lookup ((table), (string), (create), (copy)))
4003
4004 /* Create an entry in the stub hash table. */
4005
4006 static struct bfd_hash_entry *
4007 stub_hash_newfunc (struct bfd_hash_entry *entry,
4008 struct bfd_hash_table *table,
4009 const char *string)
4010 {
4011 /* Allocate the structure if it has not already been allocated by a
4012 subclass. */
4013 if (entry == NULL)
4014 {
4015 entry = bfd_hash_allocate (table, sizeof (struct ppc_stub_hash_entry));
4016 if (entry == NULL)
4017 return entry;
4018 }
4019
4020 /* Call the allocation method of the superclass. */
4021 entry = bfd_hash_newfunc (entry, table, string);
4022 if (entry != NULL)
4023 {
4024 struct ppc_stub_hash_entry *eh;
4025
4026 /* Initialize the local fields. */
4027 eh = (struct ppc_stub_hash_entry *) entry;
4028 eh->stub_type = ppc_stub_none;
4029 eh->stub_sec = NULL;
4030 eh->stub_offset = 0;
4031 eh->target_value = 0;
4032 eh->target_section = NULL;
4033 eh->h = NULL;
4034 eh->plt_ent = NULL;
4035 eh->id_sec = NULL;
4036 eh->other = 0;
4037 }
4038
4039 return entry;
4040 }
4041
4042 /* Create an entry in the branch hash table. */
4043
4044 static struct bfd_hash_entry *
4045 branch_hash_newfunc (struct bfd_hash_entry *entry,
4046 struct bfd_hash_table *table,
4047 const char *string)
4048 {
4049 /* Allocate the structure if it has not already been allocated by a
4050 subclass. */
4051 if (entry == NULL)
4052 {
4053 entry = bfd_hash_allocate (table, sizeof (struct ppc_branch_hash_entry));
4054 if (entry == NULL)
4055 return entry;
4056 }
4057
4058 /* Call the allocation method of the superclass. */
4059 entry = bfd_hash_newfunc (entry, table, string);
4060 if (entry != NULL)
4061 {
4062 struct ppc_branch_hash_entry *eh;
4063
4064 /* Initialize the local fields. */
4065 eh = (struct ppc_branch_hash_entry *) entry;
4066 eh->offset = 0;
4067 eh->iter = 0;
4068 }
4069
4070 return entry;
4071 }
4072
4073 /* Create an entry in a ppc64 ELF linker hash table. */
4074
4075 static struct bfd_hash_entry *
4076 link_hash_newfunc (struct bfd_hash_entry *entry,
4077 struct bfd_hash_table *table,
4078 const char *string)
4079 {
4080 /* Allocate the structure if it has not already been allocated by a
4081 subclass. */
4082 if (entry == NULL)
4083 {
4084 entry = bfd_hash_allocate (table, sizeof (struct ppc_link_hash_entry));
4085 if (entry == NULL)
4086 return entry;
4087 }
4088
4089 /* Call the allocation method of the superclass. */
4090 entry = _bfd_elf_link_hash_newfunc (entry, table, string);
4091 if (entry != NULL)
4092 {
4093 struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) entry;
4094
4095 memset (&eh->u.stub_cache, 0,
4096 (sizeof (struct ppc_link_hash_entry)
4097 - offsetof (struct ppc_link_hash_entry, u.stub_cache)));
4098
4099 /* When making function calls, old ABI code references function entry
4100 points (dot symbols), while new ABI code references the function
4101 descriptor symbol. We need to make any combination of reference and
4102 definition work together, without breaking archive linking.
4103
4104 For a defined function "foo" and an undefined call to "bar":
4105 An old object defines "foo" and ".foo", references ".bar" (possibly
4106 "bar" too).
4107 A new object defines "foo" and references "bar".
4108
4109 A new object thus has no problem with its undefined symbols being
4110 satisfied by definitions in an old object. On the other hand, the
4111 old object won't have ".bar" satisfied by a new object.
4112
4113 Keep a list of newly added dot-symbols. */
4114
4115 if (string[0] == '.')
4116 {
4117 struct ppc_link_hash_table *htab;
4118
4119 htab = (struct ppc_link_hash_table *) table;
4120 eh->u.next_dot_sym = htab->dot_syms;
4121 htab->dot_syms = eh;
4122 }
4123 }
4124
4125 return entry;
4126 }
4127
4128 struct tocsave_entry {
4129 asection *sec;
4130 bfd_vma offset;
4131 };
4132
4133 static hashval_t
4134 tocsave_htab_hash (const void *p)
4135 {
4136 const struct tocsave_entry *e = (const struct tocsave_entry *) p;
4137 return ((bfd_vma)(intptr_t) e->sec ^ e->offset) >> 3;
4138 }
4139
4140 static int
4141 tocsave_htab_eq (const void *p1, const void *p2)
4142 {
4143 const struct tocsave_entry *e1 = (const struct tocsave_entry *) p1;
4144 const struct tocsave_entry *e2 = (const struct tocsave_entry *) p2;
4145 return e1->sec == e2->sec && e1->offset == e2->offset;
4146 }
4147
4148 /* Create a ppc64 ELF linker hash table. */
4149
4150 static struct bfd_link_hash_table *
4151 ppc64_elf_link_hash_table_create (bfd *abfd)
4152 {
4153 struct ppc_link_hash_table *htab;
4154 bfd_size_type amt = sizeof (struct ppc_link_hash_table);
4155
4156 htab = bfd_zmalloc (amt);
4157 if (htab == NULL)
4158 return NULL;
4159
4160 if (!_bfd_elf_link_hash_table_init (&htab->elf, abfd, link_hash_newfunc,
4161 sizeof (struct ppc_link_hash_entry),
4162 PPC64_ELF_DATA))
4163 {
4164 free (htab);
4165 return NULL;
4166 }
4167
4168 /* Init the stub hash table too. */
4169 if (!bfd_hash_table_init (&htab->stub_hash_table, stub_hash_newfunc,
4170 sizeof (struct ppc_stub_hash_entry)))
4171 return NULL;
4172
4173 /* And the branch hash table. */
4174 if (!bfd_hash_table_init (&htab->branch_hash_table, branch_hash_newfunc,
4175 sizeof (struct ppc_branch_hash_entry)))
4176 return NULL;
4177
4178 htab->tocsave_htab = htab_try_create (1024,
4179 tocsave_htab_hash,
4180 tocsave_htab_eq,
4181 NULL);
4182 if (htab->tocsave_htab == NULL)
4183 return NULL;
4184
4185 /* Initializing two fields of the union is just cosmetic. We really
4186 only care about glist, but when compiled on a 32-bit host the
4187 bfd_vma fields are larger. Setting the bfd_vma to zero makes
4188 debugger inspection of these fields look nicer. */
4189 htab->elf.init_got_refcount.refcount = 0;
4190 htab->elf.init_got_refcount.glist = NULL;
4191 htab->elf.init_plt_refcount.refcount = 0;
4192 htab->elf.init_plt_refcount.glist = NULL;
4193 htab->elf.init_got_offset.offset = 0;
4194 htab->elf.init_got_offset.glist = NULL;
4195 htab->elf.init_plt_offset.offset = 0;
4196 htab->elf.init_plt_offset.glist = NULL;
4197
4198 return &htab->elf.root;
4199 }
4200
4201 /* Free the derived linker hash table. */
4202
4203 static void
4204 ppc64_elf_link_hash_table_free (struct bfd_link_hash_table *hash)
4205 {
4206 struct ppc_link_hash_table *htab = (struct ppc_link_hash_table *) hash;
4207
4208 bfd_hash_table_free (&htab->stub_hash_table);
4209 bfd_hash_table_free (&htab->branch_hash_table);
4210 if (htab->tocsave_htab)
4211 htab_delete (htab->tocsave_htab);
4212 _bfd_elf_link_hash_table_free (hash);
4213 }
4214
4215 /* Create sections for linker generated code. */
4216
4217 static bfd_boolean
4218 create_linkage_sections (bfd *dynobj, struct bfd_link_info *info)
4219 {
4220 struct ppc_link_hash_table *htab;
4221 flagword flags;
4222
4223 htab = ppc_hash_table (info);
4224
4225 /* Create .sfpr for code to save and restore fp regs. */
4226 flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY
4227 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4228 htab->sfpr = bfd_make_section_anyway_with_flags (dynobj, ".sfpr",
4229 flags);
4230 if (htab->sfpr == NULL
4231 || ! bfd_set_section_alignment (dynobj, htab->sfpr, 2))
4232 return FALSE;
4233
4234 /* Create .glink for lazy dynamic linking support. */
4235 htab->glink = bfd_make_section_anyway_with_flags (dynobj, ".glink",
4236 flags);
4237 if (htab->glink == NULL
4238 || ! bfd_set_section_alignment (dynobj, htab->glink, 3))
4239 return FALSE;
4240
4241 if (!info->no_ld_generated_unwind_info)
4242 {
4243 flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_HAS_CONTENTS
4244 | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4245 htab->glink_eh_frame = bfd_make_section_anyway_with_flags (dynobj,
4246 ".eh_frame",
4247 flags);
4248 if (htab->glink_eh_frame == NULL
4249 || !bfd_set_section_alignment (dynobj, htab->glink_eh_frame, 2))
4250 return FALSE;
4251 }
4252
4253 flags = SEC_ALLOC | SEC_LINKER_CREATED;
4254 htab->elf.iplt = bfd_make_section_anyway_with_flags (dynobj, ".iplt", flags);
4255 if (htab->elf.iplt == NULL
4256 || ! bfd_set_section_alignment (dynobj, htab->elf.iplt, 3))
4257 return FALSE;
4258
4259 flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4260 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4261 htab->elf.irelplt
4262 = bfd_make_section_anyway_with_flags (dynobj, ".rela.iplt", flags);
4263 if (htab->elf.irelplt == NULL
4264 || ! bfd_set_section_alignment (dynobj, htab->elf.irelplt, 3))
4265 return FALSE;
4266
4267 /* Create branch lookup table for plt_branch stubs. */
4268 flags = (SEC_ALLOC | SEC_LOAD
4269 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4270 htab->brlt = bfd_make_section_anyway_with_flags (dynobj, ".branch_lt",
4271 flags);
4272 if (htab->brlt == NULL
4273 || ! bfd_set_section_alignment (dynobj, htab->brlt, 3))
4274 return FALSE;
4275
4276 if (!info->shared)
4277 return TRUE;
4278
4279 flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4280 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4281 htab->relbrlt = bfd_make_section_anyway_with_flags (dynobj,
4282 ".rela.branch_lt",
4283 flags);
4284 if (htab->relbrlt == NULL
4285 || ! bfd_set_section_alignment (dynobj, htab->relbrlt, 3))
4286 return FALSE;
4287
4288 return TRUE;
4289 }
4290
4291 /* Satisfy the ELF linker by filling in some fields in our fake bfd. */
4292
4293 bfd_boolean
4294 ppc64_elf_init_stub_bfd (bfd *abfd, struct bfd_link_info *info)
4295 {
4296 struct ppc_link_hash_table *htab;
4297
4298 elf_elfheader (abfd)->e_ident[EI_CLASS] = ELFCLASS64;
4299
4300 /* Always hook our dynamic sections into the first bfd, which is the
4301 linker created stub bfd. This ensures that the GOT header is at
4302 the start of the output TOC section. */
4303 htab = ppc_hash_table (info);
4304 if (htab == NULL)
4305 return FALSE;
4306 htab->stub_bfd = abfd;
4307 htab->elf.dynobj = abfd;
4308
4309 if (info->relocatable)
4310 return TRUE;
4311
4312 return create_linkage_sections (htab->elf.dynobj, info);
4313 }
4314
4315 /* Build a name for an entry in the stub hash table. */
4316
4317 static char *
4318 ppc_stub_name (const asection *input_section,
4319 const asection *sym_sec,
4320 const struct ppc_link_hash_entry *h,
4321 const Elf_Internal_Rela *rel)
4322 {
4323 char *stub_name;
4324 ssize_t len;
4325
4326 /* rel->r_addend is actually 64 bit, but who uses more than +/- 2^31
4327 offsets from a sym as a branch target? In fact, we could
4328 probably assume the addend is always zero. */
4329 BFD_ASSERT (((int) rel->r_addend & 0xffffffff) == rel->r_addend);
4330
4331 if (h)
4332 {
4333 len = 8 + 1 + strlen (h->elf.root.root.string) + 1 + 8 + 1;
4334 stub_name = bfd_malloc (len);
4335 if (stub_name == NULL)
4336 return stub_name;
4337
4338 len = sprintf (stub_name, "%08x.%s+%x",
4339 input_section->id & 0xffffffff,
4340 h->elf.root.root.string,
4341 (int) rel->r_addend & 0xffffffff);
4342 }
4343 else
4344 {
4345 len = 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1;
4346 stub_name = bfd_malloc (len);
4347 if (stub_name == NULL)
4348 return stub_name;
4349
4350 len = sprintf (stub_name, "%08x.%x:%x+%x",
4351 input_section->id & 0xffffffff,
4352 sym_sec->id & 0xffffffff,
4353 (int) ELF64_R_SYM (rel->r_info) & 0xffffffff,
4354 (int) rel->r_addend & 0xffffffff);
4355 }
4356 if (len > 2 && stub_name[len - 2] == '+' && stub_name[len - 1] == '0')
4357 stub_name[len - 2] = 0;
4358 return stub_name;
4359 }
4360
4361 /* Look up an entry in the stub hash. Stub entries are cached because
4362 creating the stub name takes a bit of time. */
4363
4364 static struct ppc_stub_hash_entry *
4365 ppc_get_stub_entry (const asection *input_section,
4366 const asection *sym_sec,
4367 struct ppc_link_hash_entry *h,
4368 const Elf_Internal_Rela *rel,
4369 struct ppc_link_hash_table *htab)
4370 {
4371 struct ppc_stub_hash_entry *stub_entry;
4372 const asection *id_sec;
4373
4374 /* If this input section is part of a group of sections sharing one
4375 stub section, then use the id of the first section in the group.
4376 Stub names need to include a section id, as there may well be
4377 more than one stub used to reach say, printf, and we need to
4378 distinguish between them. */
4379 id_sec = htab->stub_group[input_section->id].link_sec;
4380
4381 if (h != NULL && h->u.stub_cache != NULL
4382 && h->u.stub_cache->h == h
4383 && h->u.stub_cache->id_sec == id_sec)
4384 {
4385 stub_entry = h->u.stub_cache;
4386 }
4387 else
4388 {
4389 char *stub_name;
4390
4391 stub_name = ppc_stub_name (id_sec, sym_sec, h, rel);
4392 if (stub_name == NULL)
4393 return NULL;
4394
4395 stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
4396 stub_name, FALSE, FALSE);
4397 if (h != NULL)
4398 h->u.stub_cache = stub_entry;
4399
4400 free (stub_name);
4401 }
4402
4403 return stub_entry;
4404 }
4405
4406 /* Add a new stub entry to the stub hash. Not all fields of the new
4407 stub entry are initialised. */
4408
4409 static struct ppc_stub_hash_entry *
4410 ppc_add_stub (const char *stub_name,
4411 asection *section,
4412 struct bfd_link_info *info)
4413 {
4414 struct ppc_link_hash_table *htab = ppc_hash_table (info);
4415 asection *link_sec;
4416 asection *stub_sec;
4417 struct ppc_stub_hash_entry *stub_entry;
4418
4419 link_sec = htab->stub_group[section->id].link_sec;
4420 stub_sec = htab->stub_group[section->id].stub_sec;
4421 if (stub_sec == NULL)
4422 {
4423 stub_sec = htab->stub_group[link_sec->id].stub_sec;
4424 if (stub_sec == NULL)
4425 {
4426 size_t namelen;
4427 bfd_size_type len;
4428 char *s_name;
4429
4430 namelen = strlen (link_sec->name);
4431 len = namelen + sizeof (STUB_SUFFIX);
4432 s_name = bfd_alloc (htab->stub_bfd, len);
4433 if (s_name == NULL)
4434 return NULL;
4435
4436 memcpy (s_name, link_sec->name, namelen);
4437 memcpy (s_name + namelen, STUB_SUFFIX, sizeof (STUB_SUFFIX));
4438 stub_sec = (*htab->add_stub_section) (s_name, link_sec);
4439 if (stub_sec == NULL)
4440 return NULL;
4441 htab->stub_group[link_sec->id].stub_sec = stub_sec;
4442 }
4443 htab->stub_group[section->id].stub_sec = stub_sec;
4444 }
4445
4446 /* Enter this entry into the linker stub hash table. */
4447 stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table, stub_name,
4448 TRUE, FALSE);
4449 if (stub_entry == NULL)
4450 {
4451 info->callbacks->einfo (_("%P: %B: cannot create stub entry %s\n"),
4452 section->owner, stub_name);
4453 return NULL;
4454 }
4455
4456 stub_entry->stub_sec = stub_sec;
4457 stub_entry->stub_offset = 0;
4458 stub_entry->id_sec = link_sec;
4459 return stub_entry;
4460 }
4461
4462 /* Create .got and .rela.got sections in ABFD, and .got in dynobj if
4463 not already done. */
4464
4465 static bfd_boolean
4466 create_got_section (bfd *abfd, struct bfd_link_info *info)
4467 {
4468 asection *got, *relgot;
4469 flagword flags;
4470 struct ppc_link_hash_table *htab = ppc_hash_table (info);
4471
4472 if (!is_ppc64_elf (abfd))
4473 return FALSE;
4474 if (htab == NULL)
4475 return FALSE;
4476
4477 if (!htab->elf.sgot
4478 && !_bfd_elf_create_got_section (htab->elf.dynobj, info))
4479 return FALSE;
4480
4481 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
4482 | SEC_LINKER_CREATED);
4483
4484 got = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
4485 if (!got
4486 || !bfd_set_section_alignment (abfd, got, 3))
4487 return FALSE;
4488
4489 relgot = bfd_make_section_anyway_with_flags (abfd, ".rela.got",
4490 flags | SEC_READONLY);
4491 if (!relgot
4492 || ! bfd_set_section_alignment (abfd, relgot, 3))
4493 return FALSE;
4494
4495 ppc64_elf_tdata (abfd)->got = got;
4496 ppc64_elf_tdata (abfd)->relgot = relgot;
4497 return TRUE;
4498 }
4499
4500 /* Create the dynamic sections, and set up shortcuts. */
4501
4502 static bfd_boolean
4503 ppc64_elf_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
4504 {
4505 struct ppc_link_hash_table *htab;
4506
4507 if (!_bfd_elf_create_dynamic_sections (dynobj, info))
4508 return FALSE;
4509
4510 htab = ppc_hash_table (info);
4511 if (htab == NULL)
4512 return FALSE;
4513
4514 htab->dynbss = bfd_get_linker_section (dynobj, ".dynbss");
4515 if (!info->shared)
4516 htab->relbss = bfd_get_linker_section (dynobj, ".rela.bss");
4517
4518 if (!htab->elf.sgot || !htab->elf.splt || !htab->elf.srelplt || !htab->dynbss
4519 || (!info->shared && !htab->relbss))
4520 abort ();
4521
4522 return TRUE;
4523 }
4524
4525 /* Follow indirect and warning symbol links. */
4526
4527 static inline struct bfd_link_hash_entry *
4528 follow_link (struct bfd_link_hash_entry *h)
4529 {
4530 while (h->type == bfd_link_hash_indirect
4531 || h->type == bfd_link_hash_warning)
4532 h = h->u.i.link;
4533 return h;
4534 }
4535
4536 static inline struct elf_link_hash_entry *
4537 elf_follow_link (struct elf_link_hash_entry *h)
4538 {
4539 return (struct elf_link_hash_entry *) follow_link (&h->root);
4540 }
4541
4542 static inline struct ppc_link_hash_entry *
4543 ppc_follow_link (struct ppc_link_hash_entry *h)
4544 {
4545 return (struct ppc_link_hash_entry *) follow_link (&h->elf.root);
4546 }
4547
4548 /* Merge PLT info on FROM with that on TO. */
4549
4550 static void
4551 move_plt_plist (struct ppc_link_hash_entry *from,
4552 struct ppc_link_hash_entry *to)
4553 {
4554 if (from->elf.plt.plist != NULL)
4555 {
4556 if (to->elf.plt.plist != NULL)
4557 {
4558 struct plt_entry **entp;
4559 struct plt_entry *ent;
4560
4561 for (entp = &from->elf.plt.plist; (ent = *entp) != NULL; )
4562 {
4563 struct plt_entry *dent;
4564
4565 for (dent = to->elf.plt.plist; dent != NULL; dent = dent->next)
4566 if (dent->addend == ent->addend)
4567 {
4568 dent->plt.refcount += ent->plt.refcount;
4569 *entp = ent->next;
4570 break;
4571 }
4572 if (dent == NULL)
4573 entp = &ent->next;
4574 }
4575 *entp = to->elf.plt.plist;
4576 }
4577
4578 to->elf.plt.plist = from->elf.plt.plist;
4579 from->elf.plt.plist = NULL;
4580 }
4581 }
4582
4583 /* Copy the extra info we tack onto an elf_link_hash_entry. */
4584
4585 static void
4586 ppc64_elf_copy_indirect_symbol (struct bfd_link_info *info,
4587 struct elf_link_hash_entry *dir,
4588 struct elf_link_hash_entry *ind)
4589 {
4590 struct ppc_link_hash_entry *edir, *eind;
4591
4592 edir = (struct ppc_link_hash_entry *) dir;
4593 eind = (struct ppc_link_hash_entry *) ind;
4594
4595 edir->is_func |= eind->is_func;
4596 edir->is_func_descriptor |= eind->is_func_descriptor;
4597 edir->tls_mask |= eind->tls_mask;
4598 if (eind->oh != NULL)
4599 edir->oh = ppc_follow_link (eind->oh);
4600
4601 /* If called to transfer flags for a weakdef during processing
4602 of elf_adjust_dynamic_symbol, don't copy NON_GOT_REF.
4603 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
4604 if (!(ELIMINATE_COPY_RELOCS
4605 && eind->elf.root.type != bfd_link_hash_indirect
4606 && edir->elf.dynamic_adjusted))
4607 edir->elf.non_got_ref |= eind->elf.non_got_ref;
4608
4609 edir->elf.ref_dynamic |= eind->elf.ref_dynamic;
4610 edir->elf.ref_regular |= eind->elf.ref_regular;
4611 edir->elf.ref_regular_nonweak |= eind->elf.ref_regular_nonweak;
4612 edir->elf.needs_plt |= eind->elf.needs_plt;
4613 edir->elf.pointer_equality_needed |= eind->elf.pointer_equality_needed;
4614
4615 /* Copy over any dynamic relocs we may have on the indirect sym. */
4616 if (eind->dyn_relocs != NULL)
4617 {
4618 if (edir->dyn_relocs != NULL)
4619 {
4620 struct elf_dyn_relocs **pp;
4621 struct elf_dyn_relocs *p;
4622
4623 /* Add reloc counts against the indirect sym to the direct sym
4624 list. Merge any entries against the same section. */
4625 for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
4626 {
4627 struct elf_dyn_relocs *q;
4628
4629 for (q = edir->dyn_relocs; q != NULL; q = q->next)
4630 if (q->sec == p->sec)
4631 {
4632 q->pc_count += p->pc_count;
4633 q->count += p->count;
4634 *pp = p->next;
4635 break;
4636 }
4637 if (q == NULL)
4638 pp = &p->next;
4639 }
4640 *pp = edir->dyn_relocs;
4641 }
4642
4643 edir->dyn_relocs = eind->dyn_relocs;
4644 eind->dyn_relocs = NULL;
4645 }
4646
4647 /* If we were called to copy over info for a weak sym, that's all.
4648 You might think dyn_relocs need not be copied over; After all,
4649 both syms will be dynamic or both non-dynamic so we're just
4650 moving reloc accounting around. However, ELIMINATE_COPY_RELOCS
4651 code in ppc64_elf_adjust_dynamic_symbol needs to check for
4652 dyn_relocs in read-only sections, and it does so on what is the
4653 DIR sym here. */
4654 if (eind->elf.root.type != bfd_link_hash_indirect)
4655 return;
4656
4657 /* Copy over got entries that we may have already seen to the
4658 symbol which just became indirect. */
4659 if (eind->elf.got.glist != NULL)
4660 {
4661 if (edir->elf.got.glist != NULL)
4662 {
4663 struct got_entry **entp;
4664 struct got_entry *ent;
4665
4666 for (entp = &eind->elf.got.glist; (ent = *entp) != NULL; )
4667 {
4668 struct got_entry *dent;
4669
4670 for (dent = edir->elf.got.glist; dent != NULL; dent = dent->next)
4671 if (dent->addend == ent->addend
4672 && dent->owner == ent->owner
4673 && dent->tls_type == ent->tls_type)
4674 {
4675 dent->got.refcount += ent->got.refcount;
4676 *entp = ent->next;
4677 break;
4678 }
4679 if (dent == NULL)
4680 entp = &ent->next;
4681 }
4682 *entp = edir->elf.got.glist;
4683 }
4684
4685 edir->elf.got.glist = eind->elf.got.glist;
4686 eind->elf.got.glist = NULL;
4687 }
4688
4689 /* And plt entries. */
4690 move_plt_plist (eind, edir);
4691
4692 if (eind->elf.dynindx != -1)
4693 {
4694 if (edir->elf.dynindx != -1)
4695 _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
4696 edir->elf.dynstr_index);
4697 edir->elf.dynindx = eind->elf.dynindx;
4698 edir->elf.dynstr_index = eind->elf.dynstr_index;
4699 eind->elf.dynindx = -1;
4700 eind->elf.dynstr_index = 0;
4701 }
4702 }
4703
4704 /* Find the function descriptor hash entry from the given function code
4705 hash entry FH. Link the entries via their OH fields. */
4706
4707 static struct ppc_link_hash_entry *
4708 lookup_fdh (struct ppc_link_hash_entry *fh, struct ppc_link_hash_table *htab)
4709 {
4710 struct ppc_link_hash_entry *fdh = fh->oh;
4711
4712 if (fdh == NULL)
4713 {
4714 const char *fd_name = fh->elf.root.root.string + 1;
4715
4716 fdh = (struct ppc_link_hash_entry *)
4717 elf_link_hash_lookup (&htab->elf, fd_name, FALSE, FALSE, FALSE);
4718 if (fdh == NULL)
4719 return fdh;
4720
4721 fdh->is_func_descriptor = 1;
4722 fdh->oh = fh;
4723 fh->is_func = 1;
4724 fh->oh = fdh;
4725 }
4726
4727 return ppc_follow_link (fdh);
4728 }
4729
4730 /* Make a fake function descriptor sym for the code sym FH. */
4731
4732 static struct ppc_link_hash_entry *
4733 make_fdh (struct bfd_link_info *info,
4734 struct ppc_link_hash_entry *fh)
4735 {
4736 bfd *abfd;
4737 asymbol *newsym;
4738 struct bfd_link_hash_entry *bh;
4739 struct ppc_link_hash_entry *fdh;
4740
4741 abfd = fh->elf.root.u.undef.abfd;
4742 newsym = bfd_make_empty_symbol (abfd);
4743 newsym->name = fh->elf.root.root.string + 1;
4744 newsym->section = bfd_und_section_ptr;
4745 newsym->value = 0;
4746 newsym->flags = BSF_WEAK;
4747
4748 bh = NULL;
4749 if (!_bfd_generic_link_add_one_symbol (info, abfd, newsym->name,
4750 newsym->flags, newsym->section,
4751 newsym->value, NULL, FALSE, FALSE,
4752 &bh))
4753 return NULL;
4754
4755 fdh = (struct ppc_link_hash_entry *) bh;
4756 fdh->elf.non_elf = 0;
4757 fdh->fake = 1;
4758 fdh->is_func_descriptor = 1;
4759 fdh->oh = fh;
4760 fh->is_func = 1;
4761 fh->oh = fdh;
4762 return fdh;
4763 }
4764
4765 /* Fix function descriptor symbols defined in .opd sections to be
4766 function type. */
4767
4768 static bfd_boolean
4769 ppc64_elf_add_symbol_hook (bfd *ibfd,
4770 struct bfd_link_info *info,
4771 Elf_Internal_Sym *isym,
4772 const char **name,
4773 flagword *flags ATTRIBUTE_UNUSED,
4774 asection **sec,
4775 bfd_vma *value ATTRIBUTE_UNUSED)
4776 {
4777 if ((ibfd->flags & DYNAMIC) == 0
4778 && ELF_ST_BIND (isym->st_info) == STB_GNU_UNIQUE)
4779 elf_tdata (info->output_bfd)->has_gnu_symbols = TRUE;
4780
4781 if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
4782 {
4783 if ((ibfd->flags & DYNAMIC) == 0)
4784 elf_tdata (info->output_bfd)->has_gnu_symbols = TRUE;
4785 }
4786 else if (ELF_ST_TYPE (isym->st_info) == STT_FUNC)
4787 ;
4788 else if (*sec != NULL
4789 && strcmp ((*sec)->name, ".opd") == 0)
4790 isym->st_info = ELF_ST_INFO (ELF_ST_BIND (isym->st_info), STT_FUNC);
4791
4792 if ((STO_PPC64_LOCAL_MASK & isym->st_other) != 0)
4793 {
4794 if (abiversion (ibfd) == 0)
4795 set_abiversion (ibfd, 2);
4796 else if (abiversion (ibfd) == 1)
4797 {
4798 info->callbacks->einfo (_("%P: symbol '%s' has invalid st_other"
4799 " for ABI version 1\n"), name);
4800 bfd_set_error (bfd_error_bad_value);
4801 return FALSE;
4802 }
4803 }
4804
4805 return TRUE;
4806 }
4807
4808 /* Merge non-visibility st_other attributes: local entry point. */
4809
4810 static void
4811 ppc64_elf_merge_symbol_attribute (struct elf_link_hash_entry *h,
4812 const Elf_Internal_Sym *isym,
4813 bfd_boolean definition,
4814 bfd_boolean dynamic)
4815 {
4816 if (definition && !dynamic)
4817 h->other = ((isym->st_other & ~ELF_ST_VISIBILITY (-1))
4818 | ELF_ST_VISIBILITY (h->other));
4819 }
4820
4821 /* This function makes an old ABI object reference to ".bar" cause the
4822 inclusion of a new ABI object archive that defines "bar".
4823 NAME is a symbol defined in an archive. Return a symbol in the hash
4824 table that might be satisfied by the archive symbols. */
4825
4826 static struct elf_link_hash_entry *
4827 ppc64_elf_archive_symbol_lookup (bfd *abfd,
4828 struct bfd_link_info *info,
4829 const char *name)
4830 {
4831 struct elf_link_hash_entry *h;
4832 char *dot_name;
4833 size_t len;
4834
4835 h = _bfd_elf_archive_symbol_lookup (abfd, info, name);
4836 if (h != NULL
4837 /* Don't return this sym if it is a fake function descriptor
4838 created by add_symbol_adjust. */
4839 && !(h->root.type == bfd_link_hash_undefweak
4840 && ((struct ppc_link_hash_entry *) h)->fake))
4841 return h;
4842
4843 if (name[0] == '.')
4844 return h;
4845
4846 len = strlen (name);
4847 dot_name = bfd_alloc (abfd, len + 2);
4848 if (dot_name == NULL)
4849 return (struct elf_link_hash_entry *) 0 - 1;
4850 dot_name[0] = '.';
4851 memcpy (dot_name + 1, name, len + 1);
4852 h = _bfd_elf_archive_symbol_lookup (abfd, info, dot_name);
4853 bfd_release (abfd, dot_name);
4854 return h;
4855 }
4856
4857 /* This function satisfies all old ABI object references to ".bar" if a
4858 new ABI object defines "bar". Well, at least, undefined dot symbols
4859 are made weak. This stops later archive searches from including an
4860 object if we already have a function descriptor definition. It also
4861 prevents the linker complaining about undefined symbols.
4862 We also check and correct mismatched symbol visibility here. The
4863 most restrictive visibility of the function descriptor and the
4864 function entry symbol is used. */
4865
4866 static bfd_boolean
4867 add_symbol_adjust (struct ppc_link_hash_entry *eh, struct bfd_link_info *info)
4868 {
4869 struct ppc_link_hash_table *htab;
4870 struct ppc_link_hash_entry *fdh;
4871
4872 if (eh->elf.root.type == bfd_link_hash_indirect)
4873 return TRUE;
4874
4875 if (eh->elf.root.type == bfd_link_hash_warning)
4876 eh = (struct ppc_link_hash_entry *) eh->elf.root.u.i.link;
4877
4878 if (eh->elf.root.root.string[0] != '.')
4879 abort ();
4880
4881 htab = ppc_hash_table (info);
4882 if (htab == NULL)
4883 return FALSE;
4884
4885 fdh = lookup_fdh (eh, htab);
4886 if (fdh == NULL)
4887 {
4888 if (!info->relocatable
4889 && (eh->elf.root.type == bfd_link_hash_undefined
4890 || eh->elf.root.type == bfd_link_hash_undefweak)
4891 && eh->elf.ref_regular)
4892 {
4893 /* Make an undefweak function descriptor sym, which is enough to
4894 pull in an --as-needed shared lib, but won't cause link
4895 errors. Archives are handled elsewhere. */
4896 fdh = make_fdh (info, eh);
4897 if (fdh == NULL)
4898 return FALSE;
4899 fdh->elf.ref_regular = 1;
4900 }
4901 }
4902 else
4903 {
4904 unsigned entry_vis = ELF_ST_VISIBILITY (eh->elf.other) - 1;
4905 unsigned descr_vis = ELF_ST_VISIBILITY (fdh->elf.other) - 1;
4906 if (entry_vis < descr_vis)
4907 fdh->elf.other += entry_vis - descr_vis;
4908 else if (entry_vis > descr_vis)
4909 eh->elf.other += descr_vis - entry_vis;
4910
4911 if ((fdh->elf.root.type == bfd_link_hash_defined
4912 || fdh->elf.root.type == bfd_link_hash_defweak)
4913 && eh->elf.root.type == bfd_link_hash_undefined)
4914 {
4915 eh->elf.root.type = bfd_link_hash_undefweak;
4916 eh->was_undefined = 1;
4917 htab->twiddled_syms = 1;
4918 }
4919 }
4920
4921 return TRUE;
4922 }
4923
4924 /* Process list of dot-symbols we made in link_hash_newfunc. */
4925
4926 static bfd_boolean
4927 ppc64_elf_process_dot_syms (bfd *ibfd, struct bfd_link_info *info)
4928 {
4929 struct ppc_link_hash_table *htab;
4930 struct ppc_link_hash_entry **p, *eh;
4931
4932 if (!is_ppc64_elf (info->output_bfd))
4933 return TRUE;
4934 htab = ppc_hash_table (info);
4935 if (htab == NULL)
4936 return FALSE;
4937
4938 if (is_ppc64_elf (ibfd))
4939 {
4940 p = &htab->dot_syms;
4941 while ((eh = *p) != NULL)
4942 {
4943 *p = NULL;
4944 if (&eh->elf == htab->elf.hgot)
4945 ;
4946 else if (htab->elf.hgot == NULL
4947 && strcmp (eh->elf.root.root.string, ".TOC.") == 0)
4948 htab->elf.hgot = &eh->elf;
4949 else if (!add_symbol_adjust (eh, info))
4950 return FALSE;
4951 p = &eh->u.next_dot_sym;
4952 }
4953 }
4954
4955 /* Clear the list for non-ppc64 input files. */
4956 p = &htab->dot_syms;
4957 while ((eh = *p) != NULL)
4958 {
4959 *p = NULL;
4960 p = &eh->u.next_dot_sym;
4961 }
4962
4963 /* We need to fix the undefs list for any syms we have twiddled to
4964 undef_weak. */
4965 if (htab->twiddled_syms)
4966 {
4967 bfd_link_repair_undef_list (&htab->elf.root);
4968 htab->twiddled_syms = 0;
4969 }
4970 return TRUE;
4971 }
4972
4973 /* Undo hash table changes when an --as-needed input file is determined
4974 not to be needed. */
4975
4976 static bfd_boolean
4977 ppc64_elf_notice_as_needed (bfd *ibfd,
4978 struct bfd_link_info *info,
4979 enum notice_asneeded_action act)
4980 {
4981 if (act == notice_not_needed)
4982 {
4983 struct ppc_link_hash_table *htab = ppc_hash_table (info);
4984
4985 if (htab == NULL)
4986 return FALSE;
4987
4988 htab->dot_syms = NULL;
4989 }
4990 return _bfd_elf_notice_as_needed (ibfd, info, act);
4991 }
4992
4993 /* If --just-symbols against a final linked binary, then assume we need
4994 toc adjusting stubs when calling functions defined there. */
4995
4996 static void
4997 ppc64_elf_link_just_syms (asection *sec, struct bfd_link_info *info)
4998 {
4999 if ((sec->flags & SEC_CODE) != 0
5000 && (sec->owner->flags & (EXEC_P | DYNAMIC)) != 0
5001 && is_ppc64_elf (sec->owner))
5002 {
5003 if (abiversion (sec->owner) >= 2
5004 || bfd_get_section_by_name (sec->owner, ".opd") != NULL)
5005 sec->has_toc_reloc = 1;
5006 }
5007 _bfd_elf_link_just_syms (sec, info);
5008 }
5009
5010 static struct plt_entry **
5011 update_local_sym_info (bfd *abfd, Elf_Internal_Shdr *symtab_hdr,
5012 unsigned long r_symndx, bfd_vma r_addend, int tls_type)
5013 {
5014 struct got_entry **local_got_ents = elf_local_got_ents (abfd);
5015 struct plt_entry **local_plt;
5016 unsigned char *local_got_tls_masks;
5017
5018 if (local_got_ents == NULL)
5019 {
5020 bfd_size_type size = symtab_hdr->sh_info;
5021
5022 size *= (sizeof (*local_got_ents)
5023 + sizeof (*local_plt)
5024 + sizeof (*local_got_tls_masks));
5025 local_got_ents = bfd_zalloc (abfd, size);
5026 if (local_got_ents == NULL)
5027 return NULL;
5028 elf_local_got_ents (abfd) = local_got_ents;
5029 }
5030
5031 if ((tls_type & (PLT_IFUNC | TLS_EXPLICIT)) == 0)
5032 {
5033 struct got_entry *ent;
5034
5035 for (ent = local_got_ents[r_symndx]; ent != NULL; ent = ent->next)
5036 if (ent->addend == r_addend
5037 && ent->owner == abfd
5038 && ent->tls_type == tls_type)
5039 break;
5040 if (ent == NULL)
5041 {
5042 bfd_size_type amt = sizeof (*ent);
5043 ent = bfd_alloc (abfd, amt);
5044 if (ent == NULL)
5045 return FALSE;
5046 ent->next = local_got_ents[r_symndx];
5047 ent->addend = r_addend;
5048 ent->owner = abfd;
5049 ent->tls_type = tls_type;
5050 ent->is_indirect = FALSE;
5051 ent->got.refcount = 0;
5052 local_got_ents[r_symndx] = ent;
5053 }
5054 ent->got.refcount += 1;
5055 }
5056
5057 local_plt = (struct plt_entry **) (local_got_ents + symtab_hdr->sh_info);
5058 local_got_tls_masks = (unsigned char *) (local_plt + symtab_hdr->sh_info);
5059 local_got_tls_masks[r_symndx] |= tls_type;
5060
5061 return local_plt + r_symndx;
5062 }
5063
5064 static bfd_boolean
5065 update_plt_info (bfd *abfd, struct plt_entry **plist, bfd_vma addend)
5066 {
5067 struct plt_entry *ent;
5068
5069 for (ent = *plist; ent != NULL; ent = ent->next)
5070 if (ent->addend == addend)
5071 break;
5072 if (ent == NULL)
5073 {
5074 bfd_size_type amt = sizeof (*ent);
5075 ent = bfd_alloc (abfd, amt);
5076 if (ent == NULL)
5077 return FALSE;
5078 ent->next = *plist;
5079 ent->addend = addend;
5080 ent->plt.refcount = 0;
5081 *plist = ent;
5082 }
5083 ent->plt.refcount += 1;
5084 return TRUE;
5085 }
5086
5087 static bfd_boolean
5088 is_branch_reloc (enum elf_ppc64_reloc_type r_type)
5089 {
5090 return (r_type == R_PPC64_REL24
5091 || r_type == R_PPC64_REL14
5092 || r_type == R_PPC64_REL14_BRTAKEN
5093 || r_type == R_PPC64_REL14_BRNTAKEN
5094 || r_type == R_PPC64_ADDR24
5095 || r_type == R_PPC64_ADDR14
5096 || r_type == R_PPC64_ADDR14_BRTAKEN
5097 || r_type == R_PPC64_ADDR14_BRNTAKEN);
5098 }
5099
5100 /* Look through the relocs for a section during the first phase, and
5101 calculate needed space in the global offset table, procedure
5102 linkage table, and dynamic reloc sections. */
5103
5104 static bfd_boolean
5105 ppc64_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
5106 asection *sec, const Elf_Internal_Rela *relocs)
5107 {
5108 struct ppc_link_hash_table *htab;
5109 Elf_Internal_Shdr *symtab_hdr;
5110 struct elf_link_hash_entry **sym_hashes;
5111 const Elf_Internal_Rela *rel;
5112 const Elf_Internal_Rela *rel_end;
5113 asection *sreloc;
5114 asection **opd_sym_map;
5115 struct elf_link_hash_entry *tga, *dottga;
5116
5117 if (info->relocatable)
5118 return TRUE;
5119
5120 /* Don't do anything special with non-loaded, non-alloced sections.
5121 In particular, any relocs in such sections should not affect GOT
5122 and PLT reference counting (ie. we don't allow them to create GOT
5123 or PLT entries), there's no possibility or desire to optimize TLS
5124 relocs, and there's not much point in propagating relocs to shared
5125 libs that the dynamic linker won't relocate. */
5126 if ((sec->flags & SEC_ALLOC) == 0)
5127 return TRUE;
5128
5129 BFD_ASSERT (is_ppc64_elf (abfd));
5130
5131 htab = ppc_hash_table (info);
5132 if (htab == NULL)
5133 return FALSE;
5134
5135 tga = elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
5136 FALSE, FALSE, TRUE);
5137 dottga = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
5138 FALSE, FALSE, TRUE);
5139 symtab_hdr = &elf_symtab_hdr (abfd);
5140 sym_hashes = elf_sym_hashes (abfd);
5141 sreloc = NULL;
5142 opd_sym_map = NULL;
5143 if (strcmp (sec->name, ".opd") == 0)
5144 {
5145 /* Garbage collection needs some extra help with .opd sections.
5146 We don't want to necessarily keep everything referenced by
5147 relocs in .opd, as that would keep all functions. Instead,
5148 if we reference an .opd symbol (a function descriptor), we
5149 want to keep the function code symbol's section. This is
5150 easy for global symbols, but for local syms we need to keep
5151 information about the associated function section. */
5152 bfd_size_type amt;
5153
5154 if (abiversion (abfd) == 0)
5155 set_abiversion (abfd, 1);
5156 else if (abiversion (abfd) == 2)
5157 {
5158 info->callbacks->einfo (_("%P: .opd not allowed in ABI version %d\n"),
5159 abiversion (abfd));
5160 bfd_set_error (bfd_error_bad_value);
5161 return FALSE;
5162 }
5163 amt = sec->size * sizeof (*opd_sym_map) / 8;
5164 opd_sym_map = bfd_zalloc (abfd, amt);
5165 if (opd_sym_map == NULL)
5166 return FALSE;
5167 ppc64_elf_section_data (sec)->u.opd.func_sec = opd_sym_map;
5168 BFD_ASSERT (ppc64_elf_section_data (sec)->sec_type == sec_normal);
5169 ppc64_elf_section_data (sec)->sec_type = sec_opd;
5170 }
5171
5172 rel_end = relocs + sec->reloc_count;
5173 for (rel = relocs; rel < rel_end; rel++)
5174 {
5175 unsigned long r_symndx;
5176 struct elf_link_hash_entry *h;
5177 enum elf_ppc64_reloc_type r_type;
5178 int tls_type;
5179 struct _ppc64_elf_section_data *ppc64_sec;
5180 struct plt_entry **ifunc;
5181
5182 r_symndx = ELF64_R_SYM (rel->r_info);
5183 if (r_symndx < symtab_hdr->sh_info)
5184 h = NULL;
5185 else
5186 {
5187 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
5188 h = elf_follow_link (h);
5189
5190 /* PR15323, ref flags aren't set for references in the same
5191 object. */
5192 h->root.non_ir_ref = 1;
5193
5194 if (h == htab->elf.hgot)
5195 sec->has_toc_reloc = 1;
5196 }
5197
5198 tls_type = 0;
5199 ifunc = NULL;
5200 if (h != NULL)
5201 {
5202 if (h->type == STT_GNU_IFUNC)
5203 {
5204 h->needs_plt = 1;
5205 ifunc = &h->plt.plist;
5206 }
5207 }
5208 else
5209 {
5210 Elf_Internal_Sym *isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5211 abfd, r_symndx);
5212 if (isym == NULL)
5213 return FALSE;
5214
5215 if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
5216 {
5217 ifunc = update_local_sym_info (abfd, symtab_hdr, r_symndx,
5218 rel->r_addend, PLT_IFUNC);
5219 if (ifunc == NULL)
5220 return FALSE;
5221 }
5222 }
5223 r_type = ELF64_R_TYPE (rel->r_info);
5224 if (is_branch_reloc (r_type))
5225 {
5226 if (h != NULL && (h == tga || h == dottga))
5227 {
5228 if (rel != relocs
5229 && (ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSGD
5230 || ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSLD))
5231 /* We have a new-style __tls_get_addr call with a marker
5232 reloc. */
5233 ;
5234 else
5235 /* Mark this section as having an old-style call. */
5236 sec->has_tls_get_addr_call = 1;
5237 }
5238
5239 /* STT_GNU_IFUNC symbols must have a PLT entry. */
5240 if (ifunc != NULL
5241 && !update_plt_info (abfd, ifunc, rel->r_addend))
5242 return FALSE;
5243 }
5244
5245 switch (r_type)
5246 {
5247 case R_PPC64_TLSGD:
5248 case R_PPC64_TLSLD:
5249 /* These special tls relocs tie a call to __tls_get_addr with
5250 its parameter symbol. */
5251 break;
5252
5253 case R_PPC64_GOT_TLSLD16:
5254 case R_PPC64_GOT_TLSLD16_LO:
5255 case R_PPC64_GOT_TLSLD16_HI:
5256 case R_PPC64_GOT_TLSLD16_HA:
5257 tls_type = TLS_TLS | TLS_LD;
5258 goto dogottls;
5259
5260 case R_PPC64_GOT_TLSGD16:
5261 case R_PPC64_GOT_TLSGD16_LO:
5262 case R_PPC64_GOT_TLSGD16_HI:
5263 case R_PPC64_GOT_TLSGD16_HA:
5264 tls_type = TLS_TLS | TLS_GD;
5265 goto dogottls;
5266
5267 case R_PPC64_GOT_TPREL16_DS:
5268 case R_PPC64_GOT_TPREL16_LO_DS:
5269 case R_PPC64_GOT_TPREL16_HI:
5270 case R_PPC64_GOT_TPREL16_HA:
5271 if (!info->executable)
5272 info->flags |= DF_STATIC_TLS;
5273 tls_type = TLS_TLS | TLS_TPREL;
5274 goto dogottls;
5275
5276 case R_PPC64_GOT_DTPREL16_DS:
5277 case R_PPC64_GOT_DTPREL16_LO_DS:
5278 case R_PPC64_GOT_DTPREL16_HI:
5279 case R_PPC64_GOT_DTPREL16_HA:
5280 tls_type = TLS_TLS | TLS_DTPREL;
5281 dogottls:
5282 sec->has_tls_reloc = 1;
5283 /* Fall thru */
5284
5285 case R_PPC64_GOT16:
5286 case R_PPC64_GOT16_DS:
5287 case R_PPC64_GOT16_HA:
5288 case R_PPC64_GOT16_HI:
5289 case R_PPC64_GOT16_LO:
5290 case R_PPC64_GOT16_LO_DS:
5291 /* This symbol requires a global offset table entry. */
5292 sec->has_toc_reloc = 1;
5293 if (r_type == R_PPC64_GOT_TLSLD16
5294 || r_type == R_PPC64_GOT_TLSGD16
5295 || r_type == R_PPC64_GOT_TPREL16_DS
5296 || r_type == R_PPC64_GOT_DTPREL16_DS
5297 || r_type == R_PPC64_GOT16
5298 || r_type == R_PPC64_GOT16_DS)
5299 {
5300 htab->do_multi_toc = 1;
5301 ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5302 }
5303
5304 if (ppc64_elf_tdata (abfd)->got == NULL
5305 && !create_got_section (abfd, info))
5306 return FALSE;
5307
5308 if (h != NULL)
5309 {
5310 struct ppc_link_hash_entry *eh;
5311 struct got_entry *ent;
5312
5313 eh = (struct ppc_link_hash_entry *) h;
5314 for (ent = eh->elf.got.glist; ent != NULL; ent = ent->next)
5315 if (ent->addend == rel->r_addend
5316 && ent->owner == abfd
5317 && ent->tls_type == tls_type)
5318 break;
5319 if (ent == NULL)
5320 {
5321 bfd_size_type amt = sizeof (*ent);
5322 ent = bfd_alloc (abfd, amt);
5323 if (ent == NULL)
5324 return FALSE;
5325 ent->next = eh->elf.got.glist;
5326 ent->addend = rel->r_addend;
5327 ent->owner = abfd;
5328 ent->tls_type = tls_type;
5329 ent->is_indirect = FALSE;
5330 ent->got.refcount = 0;
5331 eh->elf.got.glist = ent;
5332 }
5333 ent->got.refcount += 1;
5334 eh->tls_mask |= tls_type;
5335 }
5336 else
5337 /* This is a global offset table entry for a local symbol. */
5338 if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5339 rel->r_addend, tls_type))
5340 return FALSE;
5341
5342 /* We may also need a plt entry if the symbol turns out to be
5343 an ifunc. */
5344 if (h != NULL && !info->shared && abiversion (abfd) == 2)
5345 {
5346 if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5347 return FALSE;
5348 }
5349 break;
5350
5351 case R_PPC64_PLT16_HA:
5352 case R_PPC64_PLT16_HI:
5353 case R_PPC64_PLT16_LO:
5354 case R_PPC64_PLT32:
5355 case R_PPC64_PLT64:
5356 /* This symbol requires a procedure linkage table entry. We
5357 actually build the entry in adjust_dynamic_symbol,
5358 because this might be a case of linking PIC code without
5359 linking in any dynamic objects, in which case we don't
5360 need to generate a procedure linkage table after all. */
5361 if (h == NULL)
5362 {
5363 /* It does not make sense to have a procedure linkage
5364 table entry for a local symbol. */
5365 bfd_set_error (bfd_error_bad_value);
5366 return FALSE;
5367 }
5368 else
5369 {
5370 if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5371 return FALSE;
5372 h->needs_plt = 1;
5373 if (h->root.root.string[0] == '.'
5374 && h->root.root.string[1] != '\0')
5375 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5376 }
5377 break;
5378
5379 /* The following relocations don't need to propagate the
5380 relocation if linking a shared object since they are
5381 section relative. */
5382 case R_PPC64_SECTOFF:
5383 case R_PPC64_SECTOFF_LO:
5384 case R_PPC64_SECTOFF_HI:
5385 case R_PPC64_SECTOFF_HA:
5386 case R_PPC64_SECTOFF_DS:
5387 case R_PPC64_SECTOFF_LO_DS:
5388 case R_PPC64_DTPREL16:
5389 case R_PPC64_DTPREL16_LO:
5390 case R_PPC64_DTPREL16_HI:
5391 case R_PPC64_DTPREL16_HA:
5392 case R_PPC64_DTPREL16_DS:
5393 case R_PPC64_DTPREL16_LO_DS:
5394 case R_PPC64_DTPREL16_HIGH:
5395 case R_PPC64_DTPREL16_HIGHA:
5396 case R_PPC64_DTPREL16_HIGHER:
5397 case R_PPC64_DTPREL16_HIGHERA:
5398 case R_PPC64_DTPREL16_HIGHEST:
5399 case R_PPC64_DTPREL16_HIGHESTA:
5400 break;
5401
5402 /* Nor do these. */
5403 case R_PPC64_REL16:
5404 case R_PPC64_REL16_LO:
5405 case R_PPC64_REL16_HI:
5406 case R_PPC64_REL16_HA:
5407 break;
5408
5409 case R_PPC64_TOC16:
5410 case R_PPC64_TOC16_DS:
5411 htab->do_multi_toc = 1;
5412 ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5413 case R_PPC64_TOC16_LO:
5414 case R_PPC64_TOC16_HI:
5415 case R_PPC64_TOC16_HA:
5416 case R_PPC64_TOC16_LO_DS:
5417 sec->has_toc_reloc = 1;
5418 break;
5419
5420 /* This relocation describes the C++ object vtable hierarchy.
5421 Reconstruct it for later use during GC. */
5422 case R_PPC64_GNU_VTINHERIT:
5423 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
5424 return FALSE;
5425 break;
5426
5427 /* This relocation describes which C++ vtable entries are actually
5428 used. Record for later use during GC. */
5429 case R_PPC64_GNU_VTENTRY:
5430 BFD_ASSERT (h != NULL);
5431 if (h != NULL
5432 && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
5433 return FALSE;
5434 break;
5435
5436 case R_PPC64_REL14:
5437 case R_PPC64_REL14_BRTAKEN:
5438 case R_PPC64_REL14_BRNTAKEN:
5439 {
5440 asection *dest = NULL;
5441
5442 /* Heuristic: If jumping outside our section, chances are
5443 we are going to need a stub. */
5444 if (h != NULL)
5445 {
5446 /* If the sym is weak it may be overridden later, so
5447 don't assume we know where a weak sym lives. */
5448 if (h->root.type == bfd_link_hash_defined)
5449 dest = h->root.u.def.section;
5450 }
5451 else
5452 {
5453 Elf_Internal_Sym *isym;
5454
5455 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5456 abfd, r_symndx);
5457 if (isym == NULL)
5458 return FALSE;
5459
5460 dest = bfd_section_from_elf_index (abfd, isym->st_shndx);
5461 }
5462
5463 if (dest != sec)
5464 ppc64_elf_section_data (sec)->has_14bit_branch = 1;
5465 }
5466 /* Fall through. */
5467
5468 case R_PPC64_REL24:
5469 if (h != NULL && ifunc == NULL)
5470 {
5471 /* We may need a .plt entry if the function this reloc
5472 refers to is in a shared lib. */
5473 if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5474 return FALSE;
5475 h->needs_plt = 1;
5476 if (h->root.root.string[0] == '.'
5477 && h->root.root.string[1] != '\0')
5478 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5479 if (h == tga || h == dottga)
5480 sec->has_tls_reloc = 1;
5481 }
5482 break;
5483
5484 case R_PPC64_TPREL64:
5485 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_TPREL;
5486 if (!info->executable)
5487 info->flags |= DF_STATIC_TLS;
5488 goto dotlstoc;
5489
5490 case R_PPC64_DTPMOD64:
5491 if (rel + 1 < rel_end
5492 && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
5493 && rel[1].r_offset == rel->r_offset + 8)
5494 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_GD;
5495 else
5496 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_LD;
5497 goto dotlstoc;
5498
5499 case R_PPC64_DTPREL64:
5500 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_DTPREL;
5501 if (rel != relocs
5502 && rel[-1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPMOD64)
5503 && rel[-1].r_offset == rel->r_offset - 8)
5504 /* This is the second reloc of a dtpmod, dtprel pair.
5505 Don't mark with TLS_DTPREL. */
5506 goto dodyn;
5507
5508 dotlstoc:
5509 sec->has_tls_reloc = 1;
5510 if (h != NULL)
5511 {
5512 struct ppc_link_hash_entry *eh;
5513 eh = (struct ppc_link_hash_entry *) h;
5514 eh->tls_mask |= tls_type;
5515 }
5516 else
5517 if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5518 rel->r_addend, tls_type))
5519 return FALSE;
5520
5521 ppc64_sec = ppc64_elf_section_data (sec);
5522 if (ppc64_sec->sec_type != sec_toc)
5523 {
5524 bfd_size_type amt;
5525
5526 /* One extra to simplify get_tls_mask. */
5527 amt = sec->size * sizeof (unsigned) / 8 + sizeof (unsigned);
5528 ppc64_sec->u.toc.symndx = bfd_zalloc (abfd, amt);
5529 if (ppc64_sec->u.toc.symndx == NULL)
5530 return FALSE;
5531 amt = sec->size * sizeof (bfd_vma) / 8;
5532 ppc64_sec->u.toc.add = bfd_zalloc (abfd, amt);
5533 if (ppc64_sec->u.toc.add == NULL)
5534 return FALSE;
5535 BFD_ASSERT (ppc64_sec->sec_type == sec_normal);
5536 ppc64_sec->sec_type = sec_toc;
5537 }
5538 BFD_ASSERT (rel->r_offset % 8 == 0);
5539 ppc64_sec->u.toc.symndx[rel->r_offset / 8] = r_symndx;
5540 ppc64_sec->u.toc.add[rel->r_offset / 8] = rel->r_addend;
5541
5542 /* Mark the second slot of a GD or LD entry.
5543 -1 to indicate GD and -2 to indicate LD. */
5544 if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_GD))
5545 ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -1;
5546 else if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_LD))
5547 ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -2;
5548 goto dodyn;
5549
5550 case R_PPC64_TPREL16:
5551 case R_PPC64_TPREL16_LO:
5552 case R_PPC64_TPREL16_HI:
5553 case R_PPC64_TPREL16_HA:
5554 case R_PPC64_TPREL16_DS:
5555 case R_PPC64_TPREL16_LO_DS:
5556 case R_PPC64_TPREL16_HIGH:
5557 case R_PPC64_TPREL16_HIGHA:
5558 case R_PPC64_TPREL16_HIGHER:
5559 case R_PPC64_TPREL16_HIGHERA:
5560 case R_PPC64_TPREL16_HIGHEST:
5561 case R_PPC64_TPREL16_HIGHESTA:
5562 if (info->shared)
5563 {
5564 if (!info->executable)
5565 info->flags |= DF_STATIC_TLS;
5566 goto dodyn;
5567 }
5568 break;
5569
5570 case R_PPC64_ADDR64:
5571 if (opd_sym_map != NULL
5572 && rel + 1 < rel_end
5573 && ELF64_R_TYPE ((rel + 1)->r_info) == R_PPC64_TOC)
5574 {
5575 if (h != NULL)
5576 {
5577 if (h->root.root.string[0] == '.'
5578 && h->root.root.string[1] != 0
5579 && lookup_fdh ((struct ppc_link_hash_entry *) h, htab))
5580 ;
5581 else
5582 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5583 }
5584 else
5585 {
5586 asection *s;
5587 Elf_Internal_Sym *isym;
5588
5589 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5590 abfd, r_symndx);
5591 if (isym == NULL)
5592 return FALSE;
5593
5594 s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5595 if (s != NULL && s != sec)
5596 opd_sym_map[rel->r_offset / 8] = s;
5597 }
5598 }
5599 /* Fall through. */
5600
5601 case R_PPC64_ADDR16:
5602 case R_PPC64_ADDR16_DS:
5603 case R_PPC64_ADDR16_HA:
5604 case R_PPC64_ADDR16_HI:
5605 case R_PPC64_ADDR16_HIGH:
5606 case R_PPC64_ADDR16_HIGHA:
5607 case R_PPC64_ADDR16_HIGHER:
5608 case R_PPC64_ADDR16_HIGHERA:
5609 case R_PPC64_ADDR16_HIGHEST:
5610 case R_PPC64_ADDR16_HIGHESTA:
5611 case R_PPC64_ADDR16_LO:
5612 case R_PPC64_ADDR16_LO_DS:
5613 if (h != NULL && !info->shared && abiversion (abfd) == 2
5614 && rel->r_addend == 0)
5615 {
5616 /* We may need a .plt entry if this reloc refers to a
5617 function in a shared lib. */
5618 if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5619 return FALSE;
5620 h->pointer_equality_needed = 1;
5621 }
5622 /* Fall through. */
5623
5624 case R_PPC64_REL30:
5625 case R_PPC64_REL32:
5626 case R_PPC64_REL64:
5627 case R_PPC64_ADDR14:
5628 case R_PPC64_ADDR14_BRNTAKEN:
5629 case R_PPC64_ADDR14_BRTAKEN:
5630 case R_PPC64_ADDR24:
5631 case R_PPC64_ADDR32:
5632 case R_PPC64_UADDR16:
5633 case R_PPC64_UADDR32:
5634 case R_PPC64_UADDR64:
5635 case R_PPC64_TOC:
5636 if (h != NULL && !info->shared)
5637 /* We may need a copy reloc. */
5638 h->non_got_ref = 1;
5639
5640 /* Don't propagate .opd relocs. */
5641 if (NO_OPD_RELOCS && opd_sym_map != NULL)
5642 break;
5643
5644 /* If we are creating a shared library, and this is a reloc
5645 against a global symbol, or a non PC relative reloc
5646 against a local symbol, then we need to copy the reloc
5647 into the shared library. However, if we are linking with
5648 -Bsymbolic, we do not need to copy a reloc against a
5649 global symbol which is defined in an object we are
5650 including in the link (i.e., DEF_REGULAR is set). At
5651 this point we have not seen all the input files, so it is
5652 possible that DEF_REGULAR is not set now but will be set
5653 later (it is never cleared). In case of a weak definition,
5654 DEF_REGULAR may be cleared later by a strong definition in
5655 a shared library. We account for that possibility below by
5656 storing information in the dyn_relocs field of the hash
5657 table entry. A similar situation occurs when creating
5658 shared libraries and symbol visibility changes render the
5659 symbol local.
5660
5661 If on the other hand, we are creating an executable, we
5662 may need to keep relocations for symbols satisfied by a
5663 dynamic library if we manage to avoid copy relocs for the
5664 symbol. */
5665 dodyn:
5666 if ((info->shared
5667 && (must_be_dyn_reloc (info, r_type)
5668 || (h != NULL
5669 && (!SYMBOLIC_BIND (info, h)
5670 || h->root.type == bfd_link_hash_defweak
5671 || !h->def_regular))))
5672 || (ELIMINATE_COPY_RELOCS
5673 && !info->shared
5674 && h != NULL
5675 && (h->root.type == bfd_link_hash_defweak
5676 || !h->def_regular))
5677 || (!info->shared
5678 && ifunc != NULL))
5679 {
5680 /* We must copy these reloc types into the output file.
5681 Create a reloc section in dynobj and make room for
5682 this reloc. */
5683 if (sreloc == NULL)
5684 {
5685 sreloc = _bfd_elf_make_dynamic_reloc_section
5686 (sec, htab->elf.dynobj, 3, abfd, /*rela?*/ TRUE);
5687
5688 if (sreloc == NULL)
5689 return FALSE;
5690 }
5691
5692 /* If this is a global symbol, we count the number of
5693 relocations we need for this symbol. */
5694 if (h != NULL)
5695 {
5696 struct elf_dyn_relocs *p;
5697 struct elf_dyn_relocs **head;
5698
5699 head = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
5700 p = *head;
5701 if (p == NULL || p->sec != sec)
5702 {
5703 p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5704 if (p == NULL)
5705 return FALSE;
5706 p->next = *head;
5707 *head = p;
5708 p->sec = sec;
5709 p->count = 0;
5710 p->pc_count = 0;
5711 }
5712 p->count += 1;
5713 if (!must_be_dyn_reloc (info, r_type))
5714 p->pc_count += 1;
5715 }
5716 else
5717 {
5718 /* Track dynamic relocs needed for local syms too.
5719 We really need local syms available to do this
5720 easily. Oh well. */
5721 struct ppc_dyn_relocs *p;
5722 struct ppc_dyn_relocs **head;
5723 bfd_boolean is_ifunc;
5724 asection *s;
5725 void *vpp;
5726 Elf_Internal_Sym *isym;
5727
5728 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5729 abfd, r_symndx);
5730 if (isym == NULL)
5731 return FALSE;
5732
5733 s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5734 if (s == NULL)
5735 s = sec;
5736
5737 vpp = &elf_section_data (s)->local_dynrel;
5738 head = (struct ppc_dyn_relocs **) vpp;
5739 is_ifunc = ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC;
5740 p = *head;
5741 if (p != NULL && p->sec == sec && p->ifunc != is_ifunc)
5742 p = p->next;
5743 if (p == NULL || p->sec != sec || p->ifunc != is_ifunc)
5744 {
5745 p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5746 if (p == NULL)
5747 return FALSE;
5748 p->next = *head;
5749 *head = p;
5750 p->sec = sec;
5751 p->ifunc = is_ifunc;
5752 p->count = 0;
5753 }
5754 p->count += 1;
5755 }
5756 }
5757 break;
5758
5759 default:
5760 break;
5761 }
5762 }
5763
5764 return TRUE;
5765 }
5766
5767 /* Merge backend specific data from an object file to the output
5768 object file when linking. */
5769
5770 static bfd_boolean
5771 ppc64_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
5772 {
5773 unsigned long iflags, oflags;
5774
5775 if ((ibfd->flags & BFD_LINKER_CREATED) != 0)
5776 return TRUE;
5777
5778 if (!is_ppc64_elf (ibfd) || !is_ppc64_elf (obfd))
5779 return TRUE;
5780
5781 if (!_bfd_generic_verify_endian_match (ibfd, obfd))
5782 return FALSE;
5783
5784 iflags = elf_elfheader (ibfd)->e_flags;
5785 oflags = elf_elfheader (obfd)->e_flags;
5786
5787 if (!elf_flags_init (obfd) || oflags == 0)
5788 {
5789 elf_flags_init (obfd) = TRUE;
5790 elf_elfheader (obfd)->e_flags = iflags;
5791 }
5792 else if (iflags == oflags || iflags == 0)
5793 ;
5794 else if (iflags & ~EF_PPC64_ABI)
5795 {
5796 (*_bfd_error_handler)
5797 (_("%B uses unknown e_flags 0x%lx"), ibfd, iflags);
5798 bfd_set_error (bfd_error_bad_value);
5799 return FALSE;
5800 }
5801 else
5802 {
5803 (*_bfd_error_handler)
5804 (_("%B: ABI version %ld is not compatible with ABI version %ld output"),
5805 ibfd, iflags, oflags);
5806 bfd_set_error (bfd_error_bad_value);
5807 return FALSE;
5808 }
5809
5810 /* Merge Tag_compatibility attributes and any common GNU ones. */
5811 _bfd_elf_merge_object_attributes (ibfd, obfd);
5812
5813 return TRUE;
5814 }
5815
5816 static bfd_boolean
5817 ppc64_elf_print_private_bfd_data (bfd *abfd, void *ptr)
5818 {
5819 /* Print normal ELF private data. */
5820 _bfd_elf_print_private_bfd_data (abfd, ptr);
5821
5822 if (elf_elfheader (abfd)->e_flags != 0)
5823 {
5824 FILE *file = ptr;
5825
5826 /* xgettext:c-format */
5827 fprintf (file, _("private flags = 0x%lx:"),
5828 elf_elfheader (abfd)->e_flags);
5829
5830 if ((elf_elfheader (abfd)->e_flags & EF_PPC64_ABI) != 0)
5831 fprintf (file, _(" [abiv%ld]"),
5832 elf_elfheader (abfd)->e_flags & EF_PPC64_ABI);
5833 fputc ('\n', file);
5834 }
5835
5836 return TRUE;
5837 }
5838
5839 /* OFFSET in OPD_SEC specifies a function descriptor. Return the address
5840 of the code entry point, and its section. */
5841
5842 static bfd_vma
5843 opd_entry_value (asection *opd_sec,
5844 bfd_vma offset,
5845 asection **code_sec,
5846 bfd_vma *code_off,
5847 bfd_boolean in_code_sec)
5848 {
5849 bfd *opd_bfd = opd_sec->owner;
5850 Elf_Internal_Rela *relocs;
5851 Elf_Internal_Rela *lo, *hi, *look;
5852 bfd_vma val;
5853
5854 /* No relocs implies we are linking a --just-symbols object, or looking
5855 at a final linked executable with addr2line or somesuch. */
5856 if (opd_sec->reloc_count == 0)
5857 {
5858 bfd_byte *contents = ppc64_elf_tdata (opd_bfd)->opd.contents;
5859
5860 if (contents == NULL)
5861 {
5862 if (!bfd_malloc_and_get_section (opd_bfd, opd_sec, &contents))
5863 return (bfd_vma) -1;
5864 ppc64_elf_tdata (opd_bfd)->opd.contents = contents;
5865 }
5866
5867 val = bfd_get_64 (opd_bfd, contents + offset);
5868 if (code_sec != NULL)
5869 {
5870 asection *sec, *likely = NULL;
5871
5872 if (in_code_sec)
5873 {
5874 sec = *code_sec;
5875 if (sec->vma <= val
5876 && val < sec->vma + sec->size)
5877 likely = sec;
5878 else
5879 val = -1;
5880 }
5881 else
5882 for (sec = opd_bfd->sections; sec != NULL; sec = sec->next)
5883 if (sec->vma <= val
5884 && (sec->flags & SEC_LOAD) != 0
5885 && (sec->flags & SEC_ALLOC) != 0)
5886 likely = sec;
5887 if (likely != NULL)
5888 {
5889 *code_sec = likely;
5890 if (code_off != NULL)
5891 *code_off = val - likely->vma;
5892 }
5893 }
5894 return val;
5895 }
5896
5897 BFD_ASSERT (is_ppc64_elf (opd_bfd));
5898
5899 relocs = ppc64_elf_tdata (opd_bfd)->opd.relocs;
5900 if (relocs == NULL)
5901 relocs = _bfd_elf_link_read_relocs (opd_bfd, opd_sec, NULL, NULL, TRUE);
5902
5903 /* Go find the opd reloc at the sym address. */
5904 lo = relocs;
5905 BFD_ASSERT (lo != NULL);
5906 hi = lo + opd_sec->reloc_count - 1; /* ignore last reloc */
5907 val = (bfd_vma) -1;
5908 while (lo < hi)
5909 {
5910 look = lo + (hi - lo) / 2;
5911 if (look->r_offset < offset)
5912 lo = look + 1;
5913 else if (look->r_offset > offset)
5914 hi = look;
5915 else
5916 {
5917 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (opd_bfd);
5918
5919 if (ELF64_R_TYPE (look->r_info) == R_PPC64_ADDR64
5920 && ELF64_R_TYPE ((look + 1)->r_info) == R_PPC64_TOC)
5921 {
5922 unsigned long symndx = ELF64_R_SYM (look->r_info);
5923 asection *sec;
5924
5925 if (symndx < symtab_hdr->sh_info
5926 || elf_sym_hashes (opd_bfd) == NULL)
5927 {
5928 Elf_Internal_Sym *sym;
5929
5930 sym = (Elf_Internal_Sym *) symtab_hdr->contents;
5931 if (sym == NULL)
5932 {
5933 size_t symcnt = symtab_hdr->sh_info;
5934 if (elf_sym_hashes (opd_bfd) == NULL)
5935 symcnt = symtab_hdr->sh_size / symtab_hdr->sh_entsize;
5936 sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr, symcnt,
5937 0, NULL, NULL, NULL);
5938 if (sym == NULL)
5939 break;
5940 symtab_hdr->contents = (bfd_byte *) sym;
5941 }
5942
5943 sym += symndx;
5944 val = sym->st_value;
5945 sec = bfd_section_from_elf_index (opd_bfd, sym->st_shndx);
5946 BFD_ASSERT ((sec->flags & SEC_MERGE) == 0);
5947 }
5948 else
5949 {
5950 struct elf_link_hash_entry **sym_hashes;
5951 struct elf_link_hash_entry *rh;
5952
5953 sym_hashes = elf_sym_hashes (opd_bfd);
5954 rh = sym_hashes[symndx - symtab_hdr->sh_info];
5955 if (rh != NULL)
5956 {
5957 rh = elf_follow_link (rh);
5958 BFD_ASSERT (rh->root.type == bfd_link_hash_defined
5959 || rh->root.type == bfd_link_hash_defweak);
5960 val = rh->root.u.def.value;
5961 sec = rh->root.u.def.section;
5962 }
5963 else
5964 {
5965 /* Handle the odd case where we can be called
5966 during bfd_elf_link_add_symbols before the
5967 symbol hashes have been fully populated. */
5968 Elf_Internal_Sym *sym;
5969
5970 sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr, 1,
5971 symndx, NULL, NULL, NULL);
5972 if (sym == NULL)
5973 break;
5974
5975 val = sym->st_value;
5976 sec = bfd_section_from_elf_index (opd_bfd, sym->st_shndx);
5977 free (sym);
5978 }
5979 }
5980 val += look->r_addend;
5981 if (code_off != NULL)
5982 *code_off = val;
5983 if (code_sec != NULL)
5984 {
5985 if (in_code_sec && *code_sec != sec)
5986 return -1;
5987 else
5988 *code_sec = sec;
5989 }
5990 if (sec != NULL && sec->output_section != NULL)
5991 val += sec->output_section->vma + sec->output_offset;
5992 }
5993 break;
5994 }
5995 }
5996
5997 return val;
5998 }
5999
6000 /* If the ELF symbol SYM might be a function in SEC, return the
6001 function size and set *CODE_OFF to the function's entry point,
6002 otherwise return zero. */
6003
6004 static bfd_size_type
6005 ppc64_elf_maybe_function_sym (const asymbol *sym, asection *sec,
6006 bfd_vma *code_off)
6007 {
6008 bfd_size_type size;
6009
6010 if ((sym->flags & (BSF_SECTION_SYM | BSF_FILE | BSF_OBJECT
6011 | BSF_THREAD_LOCAL | BSF_RELC | BSF_SRELC)) != 0)
6012 return 0;
6013
6014 size = 0;
6015 if (!(sym->flags & BSF_SYNTHETIC))
6016 size = ((elf_symbol_type *) sym)->internal_elf_sym.st_size;
6017
6018 if (strcmp (sym->section->name, ".opd") == 0)
6019 {
6020 if (opd_entry_value (sym->section, sym->value,
6021 &sec, code_off, TRUE) == (bfd_vma) -1)
6022 return 0;
6023 /* An old ABI binary with dot-syms has a size of 24 on the .opd
6024 symbol. This size has nothing to do with the code size of the
6025 function, which is what we're supposed to return, but the
6026 code size isn't available without looking up the dot-sym.
6027 However, doing that would be a waste of time particularly
6028 since elf_find_function will look at the dot-sym anyway.
6029 Now, elf_find_function will keep the largest size of any
6030 function sym found at the code address of interest, so return
6031 1 here to avoid it incorrectly caching a larger function size
6032 for a small function. This does mean we return the wrong
6033 size for a new-ABI function of size 24, but all that does is
6034 disable caching for such functions. */
6035 if (size == 24)
6036 size = 1;
6037 }
6038 else
6039 {
6040 if (sym->section != sec)
6041 return 0;
6042 *code_off = sym->value;
6043 }
6044 if (size == 0)
6045 size = 1;
6046 return size;
6047 }
6048
6049 /* Return true if symbol is defined in a regular object file. */
6050
6051 static bfd_boolean
6052 is_static_defined (struct elf_link_hash_entry *h)
6053 {
6054 return ((h->root.type == bfd_link_hash_defined
6055 || h->root.type == bfd_link_hash_defweak)
6056 && h->root.u.def.section != NULL
6057 && h->root.u.def.section->output_section != NULL);
6058 }
6059
6060 /* If FDH is a function descriptor symbol, return the associated code
6061 entry symbol if it is defined. Return NULL otherwise. */
6062
6063 static struct ppc_link_hash_entry *
6064 defined_code_entry (struct ppc_link_hash_entry *fdh)
6065 {
6066 if (fdh->is_func_descriptor)
6067 {
6068 struct ppc_link_hash_entry *fh = ppc_follow_link (fdh->oh);
6069 if (fh->elf.root.type == bfd_link_hash_defined
6070 || fh->elf.root.type == bfd_link_hash_defweak)
6071 return fh;
6072 }
6073 return NULL;
6074 }
6075
6076 /* If FH is a function code entry symbol, return the associated
6077 function descriptor symbol if it is defined. Return NULL otherwise. */
6078
6079 static struct ppc_link_hash_entry *
6080 defined_func_desc (struct ppc_link_hash_entry *fh)
6081 {
6082 if (fh->oh != NULL
6083 && fh->oh->is_func_descriptor)
6084 {
6085 struct ppc_link_hash_entry *fdh = ppc_follow_link (fh->oh);
6086 if (fdh->elf.root.type == bfd_link_hash_defined
6087 || fdh->elf.root.type == bfd_link_hash_defweak)
6088 return fdh;
6089 }
6090 return NULL;
6091 }
6092
6093 /* Mark all our entry sym sections, both opd and code section. */
6094
6095 static void
6096 ppc64_elf_gc_keep (struct bfd_link_info *info)
6097 {
6098 struct ppc_link_hash_table *htab = ppc_hash_table (info);
6099 struct bfd_sym_chain *sym;
6100
6101 if (htab == NULL)
6102 return;
6103
6104 for (sym = info->gc_sym_list; sym != NULL; sym = sym->next)
6105 {
6106 struct ppc_link_hash_entry *eh, *fh;
6107 asection *sec;
6108
6109 eh = (struct ppc_link_hash_entry *)
6110 elf_link_hash_lookup (&htab->elf, sym->name, FALSE, FALSE, TRUE);
6111 if (eh == NULL)
6112 continue;
6113 if (eh->elf.root.type != bfd_link_hash_defined
6114 && eh->elf.root.type != bfd_link_hash_defweak)
6115 continue;
6116
6117 fh = defined_code_entry (eh);
6118 if (fh != NULL)
6119 {
6120 sec = fh->elf.root.u.def.section;
6121 sec->flags |= SEC_KEEP;
6122 }
6123 else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6124 && opd_entry_value (eh->elf.root.u.def.section,
6125 eh->elf.root.u.def.value,
6126 &sec, NULL, FALSE) != (bfd_vma) -1)
6127 sec->flags |= SEC_KEEP;
6128
6129 sec = eh->elf.root.u.def.section;
6130 sec->flags |= SEC_KEEP;
6131 }
6132 }
6133
6134 /* Mark sections containing dynamically referenced symbols. When
6135 building shared libraries, we must assume that any visible symbol is
6136 referenced. */
6137
6138 static bfd_boolean
6139 ppc64_elf_gc_mark_dynamic_ref (struct elf_link_hash_entry *h, void *inf)
6140 {
6141 struct bfd_link_info *info = (struct bfd_link_info *) inf;
6142 struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
6143 struct ppc_link_hash_entry *fdh;
6144
6145 /* Dynamic linking info is on the func descriptor sym. */
6146 fdh = defined_func_desc (eh);
6147 if (fdh != NULL)
6148 eh = fdh;
6149
6150 if ((eh->elf.root.type == bfd_link_hash_defined
6151 || eh->elf.root.type == bfd_link_hash_defweak)
6152 && (eh->elf.ref_dynamic
6153 || (!info->executable
6154 && eh->elf.def_regular
6155 && ELF_ST_VISIBILITY (eh->elf.other) != STV_INTERNAL
6156 && ELF_ST_VISIBILITY (eh->elf.other) != STV_HIDDEN
6157 && (strchr (eh->elf.root.root.string, ELF_VER_CHR) != NULL
6158 || !bfd_hide_sym_by_version (info->version_info,
6159 eh->elf.root.root.string)))))
6160 {
6161 asection *code_sec;
6162 struct ppc_link_hash_entry *fh;
6163
6164 eh->elf.root.u.def.section->flags |= SEC_KEEP;
6165
6166 /* Function descriptor syms cause the associated
6167 function code sym section to be marked. */
6168 fh = defined_code_entry (eh);
6169 if (fh != NULL)
6170 {
6171 code_sec = fh->elf.root.u.def.section;
6172 code_sec->flags |= SEC_KEEP;
6173 }
6174 else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6175 && opd_entry_value (eh->elf.root.u.def.section,
6176 eh->elf.root.u.def.value,
6177 &code_sec, NULL, FALSE) != (bfd_vma) -1)
6178 code_sec->flags |= SEC_KEEP;
6179 }
6180
6181 return TRUE;
6182 }
6183
6184 /* Return the section that should be marked against GC for a given
6185 relocation. */
6186
6187 static asection *
6188 ppc64_elf_gc_mark_hook (asection *sec,
6189 struct bfd_link_info *info,
6190 Elf_Internal_Rela *rel,
6191 struct elf_link_hash_entry *h,
6192 Elf_Internal_Sym *sym)
6193 {
6194 asection *rsec;
6195
6196 /* Syms return NULL if we're marking .opd, so we avoid marking all
6197 function sections, as all functions are referenced in .opd. */
6198 rsec = NULL;
6199 if (get_opd_info (sec) != NULL)
6200 return rsec;
6201
6202 if (h != NULL)
6203 {
6204 enum elf_ppc64_reloc_type r_type;
6205 struct ppc_link_hash_entry *eh, *fh, *fdh;
6206
6207 r_type = ELF64_R_TYPE (rel->r_info);
6208 switch (r_type)
6209 {
6210 case R_PPC64_GNU_VTINHERIT:
6211 case R_PPC64_GNU_VTENTRY:
6212 break;
6213
6214 default:
6215 switch (h->root.type)
6216 {
6217 case bfd_link_hash_defined:
6218 case bfd_link_hash_defweak:
6219 eh = (struct ppc_link_hash_entry *) h;
6220 fdh = defined_func_desc (eh);
6221 if (fdh != NULL)
6222 eh = fdh;
6223
6224 /* Function descriptor syms cause the associated
6225 function code sym section to be marked. */
6226 fh = defined_code_entry (eh);
6227 if (fh != NULL)
6228 {
6229 /* They also mark their opd section. */
6230 eh->elf.root.u.def.section->gc_mark = 1;
6231
6232 rsec = fh->elf.root.u.def.section;
6233 }
6234 else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6235 && opd_entry_value (eh->elf.root.u.def.section,
6236 eh->elf.root.u.def.value,
6237 &rsec, NULL, FALSE) != (bfd_vma) -1)
6238 eh->elf.root.u.def.section->gc_mark = 1;
6239 else
6240 rsec = h->root.u.def.section;
6241 break;
6242
6243 case bfd_link_hash_common:
6244 rsec = h->root.u.c.p->section;
6245 break;
6246
6247 default:
6248 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
6249 }
6250 }
6251 }
6252 else
6253 {
6254 struct _opd_sec_data *opd;
6255
6256 rsec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
6257 opd = get_opd_info (rsec);
6258 if (opd != NULL && opd->func_sec != NULL)
6259 {
6260 rsec->gc_mark = 1;
6261
6262 rsec = opd->func_sec[(sym->st_value + rel->r_addend) / 8];
6263 }
6264 }
6265
6266 return rsec;
6267 }
6268
6269 /* Update the .got, .plt. and dynamic reloc reference counts for the
6270 section being removed. */
6271
6272 static bfd_boolean
6273 ppc64_elf_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info,
6274 asection *sec, const Elf_Internal_Rela *relocs)
6275 {
6276 struct ppc_link_hash_table *htab;
6277 Elf_Internal_Shdr *symtab_hdr;
6278 struct elf_link_hash_entry **sym_hashes;
6279 struct got_entry **local_got_ents;
6280 const Elf_Internal_Rela *rel, *relend;
6281
6282 if (info->relocatable)
6283 return TRUE;
6284
6285 if ((sec->flags & SEC_ALLOC) == 0)
6286 return TRUE;
6287
6288 elf_section_data (sec)->local_dynrel = NULL;
6289
6290 htab = ppc_hash_table (info);
6291 if (htab == NULL)
6292 return FALSE;
6293
6294 symtab_hdr = &elf_symtab_hdr (abfd);
6295 sym_hashes = elf_sym_hashes (abfd);
6296 local_got_ents = elf_local_got_ents (abfd);
6297
6298 relend = relocs + sec->reloc_count;
6299 for (rel = relocs; rel < relend; rel++)
6300 {
6301 unsigned long r_symndx;
6302 enum elf_ppc64_reloc_type r_type;
6303 struct elf_link_hash_entry *h = NULL;
6304 unsigned char tls_type = 0;
6305
6306 r_symndx = ELF64_R_SYM (rel->r_info);
6307 r_type = ELF64_R_TYPE (rel->r_info);
6308 if (r_symndx >= symtab_hdr->sh_info)
6309 {
6310 struct ppc_link_hash_entry *eh;
6311 struct elf_dyn_relocs **pp;
6312 struct elf_dyn_relocs *p;
6313
6314 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
6315 h = elf_follow_link (h);
6316 eh = (struct ppc_link_hash_entry *) h;
6317
6318 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
6319 if (p->sec == sec)
6320 {
6321 /* Everything must go for SEC. */
6322 *pp = p->next;
6323 break;
6324 }
6325 }
6326
6327 if (is_branch_reloc (r_type))
6328 {
6329 struct plt_entry **ifunc = NULL;
6330 if (h != NULL)
6331 {
6332 if (h->type == STT_GNU_IFUNC)
6333 ifunc = &h->plt.plist;
6334 }
6335 else if (local_got_ents != NULL)
6336 {
6337 struct plt_entry **local_plt = (struct plt_entry **)
6338 (local_got_ents + symtab_hdr->sh_info);
6339 unsigned char *local_got_tls_masks = (unsigned char *)
6340 (local_plt + symtab_hdr->sh_info);
6341 if ((local_got_tls_masks[r_symndx] & PLT_IFUNC) != 0)
6342 ifunc = local_plt + r_symndx;
6343 }
6344 if (ifunc != NULL)
6345 {
6346 struct plt_entry *ent;
6347
6348 for (ent = *ifunc; ent != NULL; ent = ent->next)
6349 if (ent->addend == rel->r_addend)
6350 break;
6351 if (ent == NULL)
6352 abort ();
6353 if (ent->plt.refcount > 0)
6354 ent->plt.refcount -= 1;
6355 continue;
6356 }
6357 }
6358
6359 switch (r_type)
6360 {
6361 case R_PPC64_GOT_TLSLD16:
6362 case R_PPC64_GOT_TLSLD16_LO:
6363 case R_PPC64_GOT_TLSLD16_HI:
6364 case R_PPC64_GOT_TLSLD16_HA:
6365 tls_type = TLS_TLS | TLS_LD;
6366 goto dogot;
6367
6368 case R_PPC64_GOT_TLSGD16:
6369 case R_PPC64_GOT_TLSGD16_LO:
6370 case R_PPC64_GOT_TLSGD16_HI:
6371 case R_PPC64_GOT_TLSGD16_HA:
6372 tls_type = TLS_TLS | TLS_GD;
6373 goto dogot;
6374
6375 case R_PPC64_GOT_TPREL16_DS:
6376 case R_PPC64_GOT_TPREL16_LO_DS:
6377 case R_PPC64_GOT_TPREL16_HI:
6378 case R_PPC64_GOT_TPREL16_HA:
6379 tls_type = TLS_TLS | TLS_TPREL;
6380 goto dogot;
6381
6382 case R_PPC64_GOT_DTPREL16_DS:
6383 case R_PPC64_GOT_DTPREL16_LO_DS:
6384 case R_PPC64_GOT_DTPREL16_HI:
6385 case R_PPC64_GOT_DTPREL16_HA:
6386 tls_type = TLS_TLS | TLS_DTPREL;
6387 goto dogot;
6388
6389 case R_PPC64_GOT16:
6390 case R_PPC64_GOT16_DS:
6391 case R_PPC64_GOT16_HA:
6392 case R_PPC64_GOT16_HI:
6393 case R_PPC64_GOT16_LO:
6394 case R_PPC64_GOT16_LO_DS:
6395 dogot:
6396 {
6397 struct got_entry *ent;
6398
6399 if (h != NULL)
6400 ent = h->got.glist;
6401 else
6402 ent = local_got_ents[r_symndx];
6403
6404 for (; ent != NULL; ent = ent->next)
6405 if (ent->addend == rel->r_addend
6406 && ent->owner == abfd
6407 && ent->tls_type == tls_type)
6408 break;
6409 if (ent == NULL)
6410 abort ();
6411 if (ent->got.refcount > 0)
6412 ent->got.refcount -= 1;
6413 }
6414 break;
6415
6416 case R_PPC64_PLT16_HA:
6417 case R_PPC64_PLT16_HI:
6418 case R_PPC64_PLT16_LO:
6419 case R_PPC64_PLT32:
6420 case R_PPC64_PLT64:
6421 case R_PPC64_REL14:
6422 case R_PPC64_REL14_BRNTAKEN:
6423 case R_PPC64_REL14_BRTAKEN:
6424 case R_PPC64_REL24:
6425 if (h != NULL)
6426 {
6427 struct plt_entry *ent;
6428
6429 for (ent = h->plt.plist; ent != NULL; ent = ent->next)
6430 if (ent->addend == rel->r_addend)
6431 break;
6432 if (ent != NULL && ent->plt.refcount > 0)
6433 ent->plt.refcount -= 1;
6434 }
6435 break;
6436
6437 default:
6438 break;
6439 }
6440 }
6441 return TRUE;
6442 }
6443
6444 /* The maximum size of .sfpr. */
6445 #define SFPR_MAX (218*4)
6446
6447 struct sfpr_def_parms
6448 {
6449 const char name[12];
6450 unsigned char lo, hi;
6451 bfd_byte * (*write_ent) (bfd *, bfd_byte *, int);
6452 bfd_byte * (*write_tail) (bfd *, bfd_byte *, int);
6453 };
6454
6455 /* Auto-generate _save*, _rest* functions in .sfpr. */
6456
6457 static bfd_boolean
6458 sfpr_define (struct bfd_link_info *info, const struct sfpr_def_parms *parm)
6459 {
6460 struct ppc_link_hash_table *htab = ppc_hash_table (info);
6461 unsigned int i;
6462 size_t len = strlen (parm->name);
6463 bfd_boolean writing = FALSE;
6464 char sym[16];
6465
6466 if (htab == NULL)
6467 return FALSE;
6468
6469 memcpy (sym, parm->name, len);
6470 sym[len + 2] = 0;
6471
6472 for (i = parm->lo; i <= parm->hi; i++)
6473 {
6474 struct elf_link_hash_entry *h;
6475
6476 sym[len + 0] = i / 10 + '0';
6477 sym[len + 1] = i % 10 + '0';
6478 h = elf_link_hash_lookup (&htab->elf, sym, FALSE, FALSE, TRUE);
6479 if (h != NULL
6480 && !h->def_regular)
6481 {
6482 h->root.type = bfd_link_hash_defined;
6483 h->root.u.def.section = htab->sfpr;
6484 h->root.u.def.value = htab->sfpr->size;
6485 h->type = STT_FUNC;
6486 h->def_regular = 1;
6487 _bfd_elf_link_hash_hide_symbol (info, h, TRUE);
6488 writing = TRUE;
6489 if (htab->sfpr->contents == NULL)
6490 {
6491 htab->sfpr->contents = bfd_alloc (htab->elf.dynobj, SFPR_MAX);
6492 if (htab->sfpr->contents == NULL)
6493 return FALSE;
6494 }
6495 }
6496 if (writing)
6497 {
6498 bfd_byte *p = htab->sfpr->contents + htab->sfpr->size;
6499 if (i != parm->hi)
6500 p = (*parm->write_ent) (htab->elf.dynobj, p, i);
6501 else
6502 p = (*parm->write_tail) (htab->elf.dynobj, p, i);
6503 htab->sfpr->size = p - htab->sfpr->contents;
6504 }
6505 }
6506
6507 return TRUE;
6508 }
6509
6510 static bfd_byte *
6511 savegpr0 (bfd *abfd, bfd_byte *p, int r)
6512 {
6513 bfd_put_32 (abfd, STD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6514 return p + 4;
6515 }
6516
6517 static bfd_byte *
6518 savegpr0_tail (bfd *abfd, bfd_byte *p, int r)
6519 {
6520 p = savegpr0 (abfd, p, r);
6521 bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
6522 p = p + 4;
6523 bfd_put_32 (abfd, BLR, p);
6524 return p + 4;
6525 }
6526
6527 static bfd_byte *
6528 restgpr0 (bfd *abfd, bfd_byte *p, int r)
6529 {
6530 bfd_put_32 (abfd, LD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6531 return p + 4;
6532 }
6533
6534 static bfd_byte *
6535 restgpr0_tail (bfd *abfd, bfd_byte *p, int r)
6536 {
6537 bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
6538 p = p + 4;
6539 p = restgpr0 (abfd, p, r);
6540 bfd_put_32 (abfd, MTLR_R0, p);
6541 p = p + 4;
6542 if (r == 29)
6543 {
6544 p = restgpr0 (abfd, p, 30);
6545 p = restgpr0 (abfd, p, 31);
6546 }
6547 bfd_put_32 (abfd, BLR, p);
6548 return p + 4;
6549 }
6550
6551 static bfd_byte *
6552 savegpr1 (bfd *abfd, bfd_byte *p, int r)
6553 {
6554 bfd_put_32 (abfd, STD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6555 return p + 4;
6556 }
6557
6558 static bfd_byte *
6559 savegpr1_tail (bfd *abfd, bfd_byte *p, int r)
6560 {
6561 p = savegpr1 (abfd, p, r);
6562 bfd_put_32 (abfd, BLR, p);
6563 return p + 4;
6564 }
6565
6566 static bfd_byte *
6567 restgpr1 (bfd *abfd, bfd_byte *p, int r)
6568 {
6569 bfd_put_32 (abfd, LD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6570 return p + 4;
6571 }
6572
6573 static bfd_byte *
6574 restgpr1_tail (bfd *abfd, bfd_byte *p, int r)
6575 {
6576 p = restgpr1 (abfd, p, r);
6577 bfd_put_32 (abfd, BLR, p);
6578 return p + 4;
6579 }
6580
6581 static bfd_byte *
6582 savefpr (bfd *abfd, bfd_byte *p, int r)
6583 {
6584 bfd_put_32 (abfd, STFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6585 return p + 4;
6586 }
6587
6588 static bfd_byte *
6589 savefpr0_tail (bfd *abfd, bfd_byte *p, int r)
6590 {
6591 p = savefpr (abfd, p, r);
6592 bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
6593 p = p + 4;
6594 bfd_put_32 (abfd, BLR, p);
6595 return p + 4;
6596 }
6597
6598 static bfd_byte *
6599 restfpr (bfd *abfd, bfd_byte *p, int r)
6600 {
6601 bfd_put_32 (abfd, LFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6602 return p + 4;
6603 }
6604
6605 static bfd_byte *
6606 restfpr0_tail (bfd *abfd, bfd_byte *p, int r)
6607 {
6608 bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
6609 p = p + 4;
6610 p = restfpr (abfd, p, r);
6611 bfd_put_32 (abfd, MTLR_R0, p);
6612 p = p + 4;
6613 if (r == 29)
6614 {
6615 p = restfpr (abfd, p, 30);
6616 p = restfpr (abfd, p, 31);
6617 }
6618 bfd_put_32 (abfd, BLR, p);
6619 return p + 4;
6620 }
6621
6622 static bfd_byte *
6623 savefpr1_tail (bfd *abfd, bfd_byte *p, int r)
6624 {
6625 p = savefpr (abfd, p, r);
6626 bfd_put_32 (abfd, BLR, p);
6627 return p + 4;
6628 }
6629
6630 static bfd_byte *
6631 restfpr1_tail (bfd *abfd, bfd_byte *p, int r)
6632 {
6633 p = restfpr (abfd, p, r);
6634 bfd_put_32 (abfd, BLR, p);
6635 return p + 4;
6636 }
6637
6638 static bfd_byte *
6639 savevr (bfd *abfd, bfd_byte *p, int r)
6640 {
6641 bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6642 p = p + 4;
6643 bfd_put_32 (abfd, STVX_VR0_R12_R0 + (r << 21), p);
6644 return p + 4;
6645 }
6646
6647 static bfd_byte *
6648 savevr_tail (bfd *abfd, bfd_byte *p, int r)
6649 {
6650 p = savevr (abfd, p, r);
6651 bfd_put_32 (abfd, BLR, p);
6652 return p + 4;
6653 }
6654
6655 static bfd_byte *
6656 restvr (bfd *abfd, bfd_byte *p, int r)
6657 {
6658 bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6659 p = p + 4;
6660 bfd_put_32 (abfd, LVX_VR0_R12_R0 + (r << 21), p);
6661 return p + 4;
6662 }
6663
6664 static bfd_byte *
6665 restvr_tail (bfd *abfd, bfd_byte *p, int r)
6666 {
6667 p = restvr (abfd, p, r);
6668 bfd_put_32 (abfd, BLR, p);
6669 return p + 4;
6670 }
6671
6672 /* Called via elf_link_hash_traverse to transfer dynamic linking
6673 information on function code symbol entries to their corresponding
6674 function descriptor symbol entries. */
6675
6676 static bfd_boolean
6677 func_desc_adjust (struct elf_link_hash_entry *h, void *inf)
6678 {
6679 struct bfd_link_info *info;
6680 struct ppc_link_hash_table *htab;
6681 struct plt_entry *ent;
6682 struct ppc_link_hash_entry *fh;
6683 struct ppc_link_hash_entry *fdh;
6684 bfd_boolean force_local;
6685
6686 fh = (struct ppc_link_hash_entry *) h;
6687 if (fh->elf.root.type == bfd_link_hash_indirect)
6688 return TRUE;
6689
6690 info = inf;
6691 htab = ppc_hash_table (info);
6692 if (htab == NULL)
6693 return FALSE;
6694
6695 /* Resolve undefined references to dot-symbols as the value
6696 in the function descriptor, if we have one in a regular object.
6697 This is to satisfy cases like ".quad .foo". Calls to functions
6698 in dynamic objects are handled elsewhere. */
6699 if (fh->elf.root.type == bfd_link_hash_undefweak
6700 && fh->was_undefined
6701 && (fdh = defined_func_desc (fh)) != NULL
6702 && get_opd_info (fdh->elf.root.u.def.section) != NULL
6703 && opd_entry_value (fdh->elf.root.u.def.section,
6704 fdh->elf.root.u.def.value,
6705 &fh->elf.root.u.def.section,
6706 &fh->elf.root.u.def.value, FALSE) != (bfd_vma) -1)
6707 {
6708 fh->elf.root.type = fdh->elf.root.type;
6709 fh->elf.forced_local = 1;
6710 fh->elf.def_regular = fdh->elf.def_regular;
6711 fh->elf.def_dynamic = fdh->elf.def_dynamic;
6712 }
6713
6714 /* If this is a function code symbol, transfer dynamic linking
6715 information to the function descriptor symbol. */
6716 if (!fh->is_func)
6717 return TRUE;
6718
6719 for (ent = fh->elf.plt.plist; ent != NULL; ent = ent->next)
6720 if (ent->plt.refcount > 0)
6721 break;
6722 if (ent == NULL
6723 || fh->elf.root.root.string[0] != '.'
6724 || fh->elf.root.root.string[1] == '\0')
6725 return TRUE;
6726
6727 /* Find the corresponding function descriptor symbol. Create it
6728 as undefined if necessary. */
6729
6730 fdh = lookup_fdh (fh, htab);
6731 if (fdh == NULL
6732 && !info->executable
6733 && (fh->elf.root.type == bfd_link_hash_undefined
6734 || fh->elf.root.type == bfd_link_hash_undefweak))
6735 {
6736 fdh = make_fdh (info, fh);
6737 if (fdh == NULL)
6738 return FALSE;
6739 }
6740
6741 /* Fake function descriptors are made undefweak. If the function
6742 code symbol is strong undefined, make the fake sym the same.
6743 If the function code symbol is defined, then force the fake
6744 descriptor local; We can't support overriding of symbols in a
6745 shared library on a fake descriptor. */
6746
6747 if (fdh != NULL
6748 && fdh->fake
6749 && fdh->elf.root.type == bfd_link_hash_undefweak)
6750 {
6751 if (fh->elf.root.type == bfd_link_hash_undefined)
6752 {
6753 fdh->elf.root.type = bfd_link_hash_undefined;
6754 bfd_link_add_undef (&htab->elf.root, &fdh->elf.root);
6755 }
6756 else if (fh->elf.root.type == bfd_link_hash_defined
6757 || fh->elf.root.type == bfd_link_hash_defweak)
6758 {
6759 _bfd_elf_link_hash_hide_symbol (info, &fdh->elf, TRUE);
6760 }
6761 }
6762
6763 if (fdh != NULL
6764 && !fdh->elf.forced_local
6765 && (!info->executable
6766 || fdh->elf.def_dynamic
6767 || fdh->elf.ref_dynamic
6768 || (fdh->elf.root.type == bfd_link_hash_undefweak
6769 && ELF_ST_VISIBILITY (fdh->elf.other) == STV_DEFAULT)))
6770 {
6771 if (fdh->elf.dynindx == -1)
6772 if (! bfd_elf_link_record_dynamic_symbol (info, &fdh->elf))
6773 return FALSE;
6774 fdh->elf.ref_regular |= fh->elf.ref_regular;
6775 fdh->elf.ref_dynamic |= fh->elf.ref_dynamic;
6776 fdh->elf.ref_regular_nonweak |= fh->elf.ref_regular_nonweak;
6777 fdh->elf.non_got_ref |= fh->elf.non_got_ref;
6778 if (ELF_ST_VISIBILITY (fh->elf.other) == STV_DEFAULT)
6779 {
6780 move_plt_plist (fh, fdh);
6781 fdh->elf.needs_plt = 1;
6782 }
6783 fdh->is_func_descriptor = 1;
6784 fdh->oh = fh;
6785 fh->oh = fdh;
6786 }
6787
6788 /* Now that the info is on the function descriptor, clear the
6789 function code sym info. Any function code syms for which we
6790 don't have a definition in a regular file, we force local.
6791 This prevents a shared library from exporting syms that have
6792 been imported from another library. Function code syms that
6793 are really in the library we must leave global to prevent the
6794 linker dragging in a definition from a static library. */
6795 force_local = (!fh->elf.def_regular
6796 || fdh == NULL
6797 || !fdh->elf.def_regular
6798 || fdh->elf.forced_local);
6799 _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
6800
6801 return TRUE;
6802 }
6803
6804 /* Called near the start of bfd_elf_size_dynamic_sections. We use
6805 this hook to a) provide some gcc support functions, and b) transfer
6806 dynamic linking information gathered so far on function code symbol
6807 entries, to their corresponding function descriptor symbol entries. */
6808
6809 static bfd_boolean
6810 ppc64_elf_func_desc_adjust (bfd *obfd ATTRIBUTE_UNUSED,
6811 struct bfd_link_info *info)
6812 {
6813 struct ppc_link_hash_table *htab;
6814 unsigned int i;
6815 static const struct sfpr_def_parms funcs[] =
6816 {
6817 { "_savegpr0_", 14, 31, savegpr0, savegpr0_tail },
6818 { "_restgpr0_", 14, 29, restgpr0, restgpr0_tail },
6819 { "_restgpr0_", 30, 31, restgpr0, restgpr0_tail },
6820 { "_savegpr1_", 14, 31, savegpr1, savegpr1_tail },
6821 { "_restgpr1_", 14, 31, restgpr1, restgpr1_tail },
6822 { "_savefpr_", 14, 31, savefpr, savefpr0_tail },
6823 { "_restfpr_", 14, 29, restfpr, restfpr0_tail },
6824 { "_restfpr_", 30, 31, restfpr, restfpr0_tail },
6825 { "._savef", 14, 31, savefpr, savefpr1_tail },
6826 { "._restf", 14, 31, restfpr, restfpr1_tail },
6827 { "_savevr_", 20, 31, savevr, savevr_tail },
6828 { "_restvr_", 20, 31, restvr, restvr_tail }
6829 };
6830
6831 htab = ppc_hash_table (info);
6832 if (htab == NULL)
6833 return FALSE;
6834
6835 if (!info->relocatable
6836 && htab->elf.hgot != NULL)
6837 {
6838 _bfd_elf_link_hash_hide_symbol (info, htab->elf.hgot, TRUE);
6839 /* Make .TOC. defined so as to prevent it being made dynamic.
6840 The wrong value here is fixed later in ppc64_elf_set_toc. */
6841 htab->elf.hgot->type = STT_OBJECT;
6842 htab->elf.hgot->root.type = bfd_link_hash_defined;
6843 htab->elf.hgot->root.u.def.value = 0;
6844 htab->elf.hgot->root.u.def.section = bfd_abs_section_ptr;
6845 htab->elf.hgot->def_regular = 1;
6846 htab->elf.hgot->other = ((htab->elf.hgot->other & ~ELF_ST_VISIBILITY (-1))
6847 | STV_HIDDEN);
6848 }
6849
6850 if (htab->sfpr == NULL)
6851 /* We don't have any relocs. */
6852 return TRUE;
6853
6854 /* Provide any missing _save* and _rest* functions. */
6855 htab->sfpr->size = 0;
6856 if (!info->relocatable)
6857 for (i = 0; i < sizeof (funcs) / sizeof (funcs[0]); i++)
6858 if (!sfpr_define (info, &funcs[i]))
6859 return FALSE;
6860
6861 elf_link_hash_traverse (&htab->elf, func_desc_adjust, info);
6862
6863 if (htab->sfpr->size == 0)
6864 htab->sfpr->flags |= SEC_EXCLUDE;
6865
6866 return TRUE;
6867 }
6868
6869 /* Return true if we have dynamic relocs that apply to read-only sections. */
6870
6871 static bfd_boolean
6872 readonly_dynrelocs (struct elf_link_hash_entry *h)
6873 {
6874 struct ppc_link_hash_entry *eh;
6875 struct elf_dyn_relocs *p;
6876
6877 eh = (struct ppc_link_hash_entry *) h;
6878 for (p = eh->dyn_relocs; p != NULL; p = p->next)
6879 {
6880 asection *s = p->sec->output_section;
6881
6882 if (s != NULL && (s->flags & SEC_READONLY) != 0)
6883 return TRUE;
6884 }
6885 return FALSE;
6886 }
6887
6888 /* Adjust a symbol defined by a dynamic object and referenced by a
6889 regular object. The current definition is in some section of the
6890 dynamic object, but we're not including those sections. We have to
6891 change the definition to something the rest of the link can
6892 understand. */
6893
6894 static bfd_boolean
6895 ppc64_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
6896 struct elf_link_hash_entry *h)
6897 {
6898 struct ppc_link_hash_table *htab;
6899 asection *s;
6900
6901 htab = ppc_hash_table (info);
6902 if (htab == NULL)
6903 return FALSE;
6904
6905 /* Deal with function syms. */
6906 if (h->type == STT_FUNC
6907 || h->type == STT_GNU_IFUNC
6908 || h->needs_plt)
6909 {
6910 /* Clear procedure linkage table information for any symbol that
6911 won't need a .plt entry. */
6912 struct plt_entry *ent;
6913 for (ent = h->plt.plist; ent != NULL; ent = ent->next)
6914 if (ent->plt.refcount > 0)
6915 break;
6916 if (ent == NULL
6917 || (h->type != STT_GNU_IFUNC
6918 && (SYMBOL_CALLS_LOCAL (info, h)
6919 || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
6920 && h->root.type == bfd_link_hash_undefweak))))
6921 {
6922 h->plt.plist = NULL;
6923 h->needs_plt = 0;
6924 }
6925 else if (abiversion (info->output_bfd) == 2)
6926 {
6927 /* After adjust_dynamic_symbol, non_got_ref set in the
6928 non-shared case means that we have allocated space in
6929 .dynbss for the symbol and thus dyn_relocs for this
6930 symbol should be discarded.
6931 If we get here we know we are making a PLT entry for this
6932 symbol, and in an executable we'd normally resolve
6933 relocations against this symbol to the PLT entry. Allow
6934 dynamic relocs if the reference is weak, and the dynamic
6935 relocs will not cause text relocation. */
6936 if (!h->ref_regular_nonweak
6937 && h->non_got_ref
6938 && h->type != STT_GNU_IFUNC
6939 && !readonly_dynrelocs (h))
6940 h->non_got_ref = 0;
6941
6942 /* If making a plt entry, then we don't need copy relocs. */
6943 return TRUE;
6944 }
6945 }
6946 else
6947 h->plt.plist = NULL;
6948
6949 /* If this is a weak symbol, and there is a real definition, the
6950 processor independent code will have arranged for us to see the
6951 real definition first, and we can just use the same value. */
6952 if (h->u.weakdef != NULL)
6953 {
6954 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
6955 || h->u.weakdef->root.type == bfd_link_hash_defweak);
6956 h->root.u.def.section = h->u.weakdef->root.u.def.section;
6957 h->root.u.def.value = h->u.weakdef->root.u.def.value;
6958 if (ELIMINATE_COPY_RELOCS)
6959 h->non_got_ref = h->u.weakdef->non_got_ref;
6960 return TRUE;
6961 }
6962
6963 /* If we are creating a shared library, we must presume that the
6964 only references to the symbol are via the global offset table.
6965 For such cases we need not do anything here; the relocations will
6966 be handled correctly by relocate_section. */
6967 if (info->shared)
6968 return TRUE;
6969
6970 /* If there are no references to this symbol that do not use the
6971 GOT, we don't need to generate a copy reloc. */
6972 if (!h->non_got_ref)
6973 return TRUE;
6974
6975 /* Don't generate a copy reloc for symbols defined in the executable. */
6976 if (!h->def_dynamic || !h->ref_regular || h->def_regular)
6977 return TRUE;
6978
6979 /* If we didn't find any dynamic relocs in read-only sections, then
6980 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
6981 if (ELIMINATE_COPY_RELOCS && !readonly_dynrelocs (h))
6982 {
6983 h->non_got_ref = 0;
6984 return TRUE;
6985 }
6986
6987 if (h->plt.plist != NULL)
6988 {
6989 /* We should never get here, but unfortunately there are versions
6990 of gcc out there that improperly (for this ABI) put initialized
6991 function pointers, vtable refs and suchlike in read-only
6992 sections. Allow them to proceed, but warn that this might
6993 break at runtime. */
6994 info->callbacks->einfo
6995 (_("%P: copy reloc against `%T' requires lazy plt linking; "
6996 "avoid setting LD_BIND_NOW=1 or upgrade gcc\n"),
6997 h->root.root.string);
6998 }
6999
7000 /* This is a reference to a symbol defined by a dynamic object which
7001 is not a function. */
7002
7003 /* We must allocate the symbol in our .dynbss section, which will
7004 become part of the .bss section of the executable. There will be
7005 an entry for this symbol in the .dynsym section. The dynamic
7006 object will contain position independent code, so all references
7007 from the dynamic object to this symbol will go through the global
7008 offset table. The dynamic linker will use the .dynsym entry to
7009 determine the address it must put in the global offset table, so
7010 both the dynamic object and the regular object will refer to the
7011 same memory location for the variable. */
7012
7013 /* We must generate a R_PPC64_COPY reloc to tell the dynamic linker
7014 to copy the initial value out of the dynamic object and into the
7015 runtime process image. We need to remember the offset into the
7016 .rela.bss section we are going to use. */
7017 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
7018 {
7019 htab->relbss->size += sizeof (Elf64_External_Rela);
7020 h->needs_copy = 1;
7021 }
7022
7023 s = htab->dynbss;
7024
7025 return _bfd_elf_adjust_dynamic_copy (h, s);
7026 }
7027
7028 /* If given a function descriptor symbol, hide both the function code
7029 sym and the descriptor. */
7030 static void
7031 ppc64_elf_hide_symbol (struct bfd_link_info *info,
7032 struct elf_link_hash_entry *h,
7033 bfd_boolean force_local)
7034 {
7035 struct ppc_link_hash_entry *eh;
7036 _bfd_elf_link_hash_hide_symbol (info, h, force_local);
7037
7038 eh = (struct ppc_link_hash_entry *) h;
7039 if (eh->is_func_descriptor)
7040 {
7041 struct ppc_link_hash_entry *fh = eh->oh;
7042
7043 if (fh == NULL)
7044 {
7045 const char *p, *q;
7046 struct ppc_link_hash_table *htab;
7047 char save;
7048
7049 /* We aren't supposed to use alloca in BFD because on
7050 systems which do not have alloca the version in libiberty
7051 calls xmalloc, which might cause the program to crash
7052 when it runs out of memory. This function doesn't have a
7053 return status, so there's no way to gracefully return an
7054 error. So cheat. We know that string[-1] can be safely
7055 accessed; It's either a string in an ELF string table,
7056 or allocated in an objalloc structure. */
7057
7058 p = eh->elf.root.root.string - 1;
7059 save = *p;
7060 *(char *) p = '.';
7061 htab = ppc_hash_table (info);
7062 if (htab == NULL)
7063 return;
7064
7065 fh = (struct ppc_link_hash_entry *)
7066 elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
7067 *(char *) p = save;
7068
7069 /* Unfortunately, if it so happens that the string we were
7070 looking for was allocated immediately before this string,
7071 then we overwrote the string terminator. That's the only
7072 reason the lookup should fail. */
7073 if (fh == NULL)
7074 {
7075 q = eh->elf.root.root.string + strlen (eh->elf.root.root.string);
7076 while (q >= eh->elf.root.root.string && *q == *p)
7077 --q, --p;
7078 if (q < eh->elf.root.root.string && *p == '.')
7079 fh = (struct ppc_link_hash_entry *)
7080 elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
7081 }
7082 if (fh != NULL)
7083 {
7084 eh->oh = fh;
7085 fh->oh = eh;
7086 }
7087 }
7088 if (fh != NULL)
7089 _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
7090 }
7091 }
7092
7093 static bfd_boolean
7094 get_sym_h (struct elf_link_hash_entry **hp,
7095 Elf_Internal_Sym **symp,
7096 asection **symsecp,
7097 unsigned char **tls_maskp,
7098 Elf_Internal_Sym **locsymsp,
7099 unsigned long r_symndx,
7100 bfd *ibfd)
7101 {
7102 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
7103
7104 if (r_symndx >= symtab_hdr->sh_info)
7105 {
7106 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
7107 struct elf_link_hash_entry *h;
7108
7109 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
7110 h = elf_follow_link (h);
7111
7112 if (hp != NULL)
7113 *hp = h;
7114
7115 if (symp != NULL)
7116 *symp = NULL;
7117
7118 if (symsecp != NULL)
7119 {
7120 asection *symsec = NULL;
7121 if (h->root.type == bfd_link_hash_defined
7122 || h->root.type == bfd_link_hash_defweak)
7123 symsec = h->root.u.def.section;
7124 *symsecp = symsec;
7125 }
7126
7127 if (tls_maskp != NULL)
7128 {
7129 struct ppc_link_hash_entry *eh;
7130
7131 eh = (struct ppc_link_hash_entry *) h;
7132 *tls_maskp = &eh->tls_mask;
7133 }
7134 }
7135 else
7136 {
7137 Elf_Internal_Sym *sym;
7138 Elf_Internal_Sym *locsyms = *locsymsp;
7139
7140 if (locsyms == NULL)
7141 {
7142 locsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
7143 if (locsyms == NULL)
7144 locsyms = bfd_elf_get_elf_syms (ibfd, symtab_hdr,
7145 symtab_hdr->sh_info,
7146 0, NULL, NULL, NULL);
7147 if (locsyms == NULL)
7148 return FALSE;
7149 *locsymsp = locsyms;
7150 }
7151 sym = locsyms + r_symndx;
7152
7153 if (hp != NULL)
7154 *hp = NULL;
7155
7156 if (symp != NULL)
7157 *symp = sym;
7158
7159 if (symsecp != NULL)
7160 *symsecp = bfd_section_from_elf_index (ibfd, sym->st_shndx);
7161
7162 if (tls_maskp != NULL)
7163 {
7164 struct got_entry **lgot_ents;
7165 unsigned char *tls_mask;
7166
7167 tls_mask = NULL;
7168 lgot_ents = elf_local_got_ents (ibfd);
7169 if (lgot_ents != NULL)
7170 {
7171 struct plt_entry **local_plt = (struct plt_entry **)
7172 (lgot_ents + symtab_hdr->sh_info);
7173 unsigned char *lgot_masks = (unsigned char *)
7174 (local_plt + symtab_hdr->sh_info);
7175 tls_mask = &lgot_masks[r_symndx];
7176 }
7177 *tls_maskp = tls_mask;
7178 }
7179 }
7180 return TRUE;
7181 }
7182
7183 /* Returns TLS_MASKP for the given REL symbol. Function return is 0 on
7184 error, 2 on a toc GD type suitable for optimization, 3 on a toc LD
7185 type suitable for optimization, and 1 otherwise. */
7186
7187 static int
7188 get_tls_mask (unsigned char **tls_maskp,
7189 unsigned long *toc_symndx,
7190 bfd_vma *toc_addend,
7191 Elf_Internal_Sym **locsymsp,
7192 const Elf_Internal_Rela *rel,
7193 bfd *ibfd)
7194 {
7195 unsigned long r_symndx;
7196 int next_r;
7197 struct elf_link_hash_entry *h;
7198 Elf_Internal_Sym *sym;
7199 asection *sec;
7200 bfd_vma off;
7201
7202 r_symndx = ELF64_R_SYM (rel->r_info);
7203 if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7204 return 0;
7205
7206 if ((*tls_maskp != NULL && **tls_maskp != 0)
7207 || sec == NULL
7208 || ppc64_elf_section_data (sec) == NULL
7209 || ppc64_elf_section_data (sec)->sec_type != sec_toc)
7210 return 1;
7211
7212 /* Look inside a TOC section too. */
7213 if (h != NULL)
7214 {
7215 BFD_ASSERT (h->root.type == bfd_link_hash_defined);
7216 off = h->root.u.def.value;
7217 }
7218 else
7219 off = sym->st_value;
7220 off += rel->r_addend;
7221 BFD_ASSERT (off % 8 == 0);
7222 r_symndx = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8];
7223 next_r = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8 + 1];
7224 if (toc_symndx != NULL)
7225 *toc_symndx = r_symndx;
7226 if (toc_addend != NULL)
7227 *toc_addend = ppc64_elf_section_data (sec)->u.toc.add[off / 8];
7228 if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7229 return 0;
7230 if ((h == NULL || is_static_defined (h))
7231 && (next_r == -1 || next_r == -2))
7232 return 1 - next_r;
7233 return 1;
7234 }
7235
7236 /* Find (or create) an entry in the tocsave hash table. */
7237
7238 static struct tocsave_entry *
7239 tocsave_find (struct ppc_link_hash_table *htab,
7240 enum insert_option insert,
7241 Elf_Internal_Sym **local_syms,
7242 const Elf_Internal_Rela *irela,
7243 bfd *ibfd)
7244 {
7245 unsigned long r_indx;
7246 struct elf_link_hash_entry *h;
7247 Elf_Internal_Sym *sym;
7248 struct tocsave_entry ent, *p;
7249 hashval_t hash;
7250 struct tocsave_entry **slot;
7251
7252 r_indx = ELF64_R_SYM (irela->r_info);
7253 if (!get_sym_h (&h, &sym, &ent.sec, NULL, local_syms, r_indx, ibfd))
7254 return NULL;
7255 if (ent.sec == NULL || ent.sec->output_section == NULL)
7256 {
7257 (*_bfd_error_handler)
7258 (_("%B: undefined symbol on R_PPC64_TOCSAVE relocation"));
7259 return NULL;
7260 }
7261
7262 if (h != NULL)
7263 ent.offset = h->root.u.def.value;
7264 else
7265 ent.offset = sym->st_value;
7266 ent.offset += irela->r_addend;
7267
7268 hash = tocsave_htab_hash (&ent);
7269 slot = ((struct tocsave_entry **)
7270 htab_find_slot_with_hash (htab->tocsave_htab, &ent, hash, insert));
7271 if (slot == NULL)
7272 return NULL;
7273
7274 if (*slot == NULL)
7275 {
7276 p = (struct tocsave_entry *) bfd_alloc (ibfd, sizeof (*p));
7277 if (p == NULL)
7278 return NULL;
7279 *p = ent;
7280 *slot = p;
7281 }
7282 return *slot;
7283 }
7284
7285 /* Adjust all global syms defined in opd sections. In gcc generated
7286 code for the old ABI, these will already have been done. */
7287
7288 static bfd_boolean
7289 adjust_opd_syms (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
7290 {
7291 struct ppc_link_hash_entry *eh;
7292 asection *sym_sec;
7293 struct _opd_sec_data *opd;
7294
7295 if (h->root.type == bfd_link_hash_indirect)
7296 return TRUE;
7297
7298 if (h->root.type != bfd_link_hash_defined
7299 && h->root.type != bfd_link_hash_defweak)
7300 return TRUE;
7301
7302 eh = (struct ppc_link_hash_entry *) h;
7303 if (eh->adjust_done)
7304 return TRUE;
7305
7306 sym_sec = eh->elf.root.u.def.section;
7307 opd = get_opd_info (sym_sec);
7308 if (opd != NULL && opd->adjust != NULL)
7309 {
7310 long adjust = opd->adjust[eh->elf.root.u.def.value / 8];
7311 if (adjust == -1)
7312 {
7313 /* This entry has been deleted. */
7314 asection *dsec = ppc64_elf_tdata (sym_sec->owner)->deleted_section;
7315 if (dsec == NULL)
7316 {
7317 for (dsec = sym_sec->owner->sections; dsec; dsec = dsec->next)
7318 if (discarded_section (dsec))
7319 {
7320 ppc64_elf_tdata (sym_sec->owner)->deleted_section = dsec;
7321 break;
7322 }
7323 }
7324 eh->elf.root.u.def.value = 0;
7325 eh->elf.root.u.def.section = dsec;
7326 }
7327 else
7328 eh->elf.root.u.def.value += adjust;
7329 eh->adjust_done = 1;
7330 }
7331 return TRUE;
7332 }
7333
7334 /* Handles decrementing dynamic reloc counts for the reloc specified by
7335 R_INFO in section SEC. If LOCAL_SYMS is NULL, then H and SYM
7336 have already been determined. */
7337
7338 static bfd_boolean
7339 dec_dynrel_count (bfd_vma r_info,
7340 asection *sec,
7341 struct bfd_link_info *info,
7342 Elf_Internal_Sym **local_syms,
7343 struct elf_link_hash_entry *h,
7344 Elf_Internal_Sym *sym)
7345 {
7346 enum elf_ppc64_reloc_type r_type;
7347 asection *sym_sec = NULL;
7348
7349 /* Can this reloc be dynamic? This switch, and later tests here
7350 should be kept in sync with the code in check_relocs. */
7351 r_type = ELF64_R_TYPE (r_info);
7352 switch (r_type)
7353 {
7354 default:
7355 return TRUE;
7356
7357 case R_PPC64_TPREL16:
7358 case R_PPC64_TPREL16_LO:
7359 case R_PPC64_TPREL16_HI:
7360 case R_PPC64_TPREL16_HA:
7361 case R_PPC64_TPREL16_DS:
7362 case R_PPC64_TPREL16_LO_DS:
7363 case R_PPC64_TPREL16_HIGH:
7364 case R_PPC64_TPREL16_HIGHA:
7365 case R_PPC64_TPREL16_HIGHER:
7366 case R_PPC64_TPREL16_HIGHERA:
7367 case R_PPC64_TPREL16_HIGHEST:
7368 case R_PPC64_TPREL16_HIGHESTA:
7369 if (!info->shared)
7370 return TRUE;
7371
7372 case R_PPC64_TPREL64:
7373 case R_PPC64_DTPMOD64:
7374 case R_PPC64_DTPREL64:
7375 case R_PPC64_ADDR64:
7376 case R_PPC64_REL30:
7377 case R_PPC64_REL32:
7378 case R_PPC64_REL64:
7379 case R_PPC64_ADDR14:
7380 case R_PPC64_ADDR14_BRNTAKEN:
7381 case R_PPC64_ADDR14_BRTAKEN:
7382 case R_PPC64_ADDR16:
7383 case R_PPC64_ADDR16_DS:
7384 case R_PPC64_ADDR16_HA:
7385 case R_PPC64_ADDR16_HI:
7386 case R_PPC64_ADDR16_HIGH:
7387 case R_PPC64_ADDR16_HIGHA:
7388 case R_PPC64_ADDR16_HIGHER:
7389 case R_PPC64_ADDR16_HIGHERA:
7390 case R_PPC64_ADDR16_HIGHEST:
7391 case R_PPC64_ADDR16_HIGHESTA:
7392 case R_PPC64_ADDR16_LO:
7393 case R_PPC64_ADDR16_LO_DS:
7394 case R_PPC64_ADDR24:
7395 case R_PPC64_ADDR32:
7396 case R_PPC64_UADDR16:
7397 case R_PPC64_UADDR32:
7398 case R_PPC64_UADDR64:
7399 case R_PPC64_TOC:
7400 break;
7401 }
7402
7403 if (local_syms != NULL)
7404 {
7405 unsigned long r_symndx;
7406 bfd *ibfd = sec->owner;
7407
7408 r_symndx = ELF64_R_SYM (r_info);
7409 if (!get_sym_h (&h, &sym, &sym_sec, NULL, local_syms, r_symndx, ibfd))
7410 return FALSE;
7411 }
7412
7413 if ((info->shared
7414 && (must_be_dyn_reloc (info, r_type)
7415 || (h != NULL
7416 && (!SYMBOLIC_BIND (info, h)
7417 || h->root.type == bfd_link_hash_defweak
7418 || !h->def_regular))))
7419 || (ELIMINATE_COPY_RELOCS
7420 && !info->shared
7421 && h != NULL
7422 && (h->root.type == bfd_link_hash_defweak
7423 || !h->def_regular)))
7424 ;
7425 else
7426 return TRUE;
7427
7428 if (h != NULL)
7429 {
7430 struct elf_dyn_relocs *p;
7431 struct elf_dyn_relocs **pp;
7432 pp = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
7433
7434 /* elf_gc_sweep may have already removed all dyn relocs associated
7435 with local syms for a given section. Also, symbol flags are
7436 changed by elf_gc_sweep_symbol, confusing the test above. Don't
7437 report a dynreloc miscount. */
7438 if (*pp == NULL && info->gc_sections)
7439 return TRUE;
7440
7441 while ((p = *pp) != NULL)
7442 {
7443 if (p->sec == sec)
7444 {
7445 if (!must_be_dyn_reloc (info, r_type))
7446 p->pc_count -= 1;
7447 p->count -= 1;
7448 if (p->count == 0)
7449 *pp = p->next;
7450 return TRUE;
7451 }
7452 pp = &p->next;
7453 }
7454 }
7455 else
7456 {
7457 struct ppc_dyn_relocs *p;
7458 struct ppc_dyn_relocs **pp;
7459 void *vpp;
7460 bfd_boolean is_ifunc;
7461
7462 if (local_syms == NULL)
7463 sym_sec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
7464 if (sym_sec == NULL)
7465 sym_sec = sec;
7466
7467 vpp = &elf_section_data (sym_sec)->local_dynrel;
7468 pp = (struct ppc_dyn_relocs **) vpp;
7469
7470 if (*pp == NULL && info->gc_sections)
7471 return TRUE;
7472
7473 is_ifunc = ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC;
7474 while ((p = *pp) != NULL)
7475 {
7476 if (p->sec == sec && p->ifunc == is_ifunc)
7477 {
7478 p->count -= 1;
7479 if (p->count == 0)
7480 *pp = p->next;
7481 return TRUE;
7482 }
7483 pp = &p->next;
7484 }
7485 }
7486
7487 info->callbacks->einfo (_("%P: dynreloc miscount for %B, section %A\n"),
7488 sec->owner, sec);
7489 bfd_set_error (bfd_error_bad_value);
7490 return FALSE;
7491 }
7492
7493 /* Remove unused Official Procedure Descriptor entries. Currently we
7494 only remove those associated with functions in discarded link-once
7495 sections, or weakly defined functions that have been overridden. It
7496 would be possible to remove many more entries for statically linked
7497 applications. */
7498
7499 bfd_boolean
7500 ppc64_elf_edit_opd (struct bfd_link_info *info, bfd_boolean non_overlapping)
7501 {
7502 bfd *ibfd;
7503 bfd_boolean some_edited = FALSE;
7504 asection *need_pad = NULL;
7505
7506 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
7507 {
7508 asection *sec;
7509 Elf_Internal_Rela *relstart, *rel, *relend;
7510 Elf_Internal_Shdr *symtab_hdr;
7511 Elf_Internal_Sym *local_syms;
7512 bfd_vma offset;
7513 struct _opd_sec_data *opd;
7514 bfd_boolean need_edit, add_aux_fields;
7515 bfd_size_type cnt_16b = 0;
7516
7517 if (!is_ppc64_elf (ibfd))
7518 continue;
7519
7520 sec = bfd_get_section_by_name (ibfd, ".opd");
7521 if (sec == NULL || sec->size == 0)
7522 continue;
7523
7524 if (sec->sec_info_type == SEC_INFO_TYPE_JUST_SYMS)
7525 continue;
7526
7527 if (sec->output_section == bfd_abs_section_ptr)
7528 continue;
7529
7530 /* Look through the section relocs. */
7531 if ((sec->flags & SEC_RELOC) == 0 || sec->reloc_count == 0)
7532 continue;
7533
7534 local_syms = NULL;
7535 symtab_hdr = &elf_symtab_hdr (ibfd);
7536
7537 /* Read the relocations. */
7538 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
7539 info->keep_memory);
7540 if (relstart == NULL)
7541 return FALSE;
7542
7543 /* First run through the relocs to check they are sane, and to
7544 determine whether we need to edit this opd section. */
7545 need_edit = FALSE;
7546 need_pad = sec;
7547 offset = 0;
7548 relend = relstart + sec->reloc_count;
7549 for (rel = relstart; rel < relend; )
7550 {
7551 enum elf_ppc64_reloc_type r_type;
7552 unsigned long r_symndx;
7553 asection *sym_sec;
7554 struct elf_link_hash_entry *h;
7555 Elf_Internal_Sym *sym;
7556
7557 /* .opd contains a regular array of 16 or 24 byte entries. We're
7558 only interested in the reloc pointing to a function entry
7559 point. */
7560 if (rel->r_offset != offset
7561 || rel + 1 >= relend
7562 || (rel + 1)->r_offset != offset + 8)
7563 {
7564 /* If someone messes with .opd alignment then after a
7565 "ld -r" we might have padding in the middle of .opd.
7566 Also, there's nothing to prevent someone putting
7567 something silly in .opd with the assembler. No .opd
7568 optimization for them! */
7569 broken_opd:
7570 (*_bfd_error_handler)
7571 (_("%B: .opd is not a regular array of opd entries"), ibfd);
7572 need_edit = FALSE;
7573 break;
7574 }
7575
7576 if ((r_type = ELF64_R_TYPE (rel->r_info)) != R_PPC64_ADDR64
7577 || (r_type = ELF64_R_TYPE ((rel + 1)->r_info)) != R_PPC64_TOC)
7578 {
7579 (*_bfd_error_handler)
7580 (_("%B: unexpected reloc type %u in .opd section"),
7581 ibfd, r_type);
7582 need_edit = FALSE;
7583 break;
7584 }
7585
7586 r_symndx = ELF64_R_SYM (rel->r_info);
7587 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7588 r_symndx, ibfd))
7589 goto error_ret;
7590
7591 if (sym_sec == NULL || sym_sec->owner == NULL)
7592 {
7593 const char *sym_name;
7594 if (h != NULL)
7595 sym_name = h->root.root.string;
7596 else
7597 sym_name = bfd_elf_sym_name (ibfd, symtab_hdr, sym,
7598 sym_sec);
7599
7600 (*_bfd_error_handler)
7601 (_("%B: undefined sym `%s' in .opd section"),
7602 ibfd, sym_name);
7603 need_edit = FALSE;
7604 break;
7605 }
7606
7607 /* opd entries are always for functions defined in the
7608 current input bfd. If the symbol isn't defined in the
7609 input bfd, then we won't be using the function in this
7610 bfd; It must be defined in a linkonce section in another
7611 bfd, or is weak. It's also possible that we are
7612 discarding the function due to a linker script /DISCARD/,
7613 which we test for via the output_section. */
7614 if (sym_sec->owner != ibfd
7615 || sym_sec->output_section == bfd_abs_section_ptr)
7616 need_edit = TRUE;
7617
7618 rel += 2;
7619 if (rel == relend
7620 || (rel + 1 == relend && rel->r_offset == offset + 16))
7621 {
7622 if (sec->size == offset + 24)
7623 {
7624 need_pad = NULL;
7625 break;
7626 }
7627 if (rel == relend && sec->size == offset + 16)
7628 {
7629 cnt_16b++;
7630 break;
7631 }
7632 goto broken_opd;
7633 }
7634
7635 if (rel->r_offset == offset + 24)
7636 offset += 24;
7637 else if (rel->r_offset != offset + 16)
7638 goto broken_opd;
7639 else if (rel + 1 < relend
7640 && ELF64_R_TYPE (rel[0].r_info) == R_PPC64_ADDR64
7641 && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOC)
7642 {
7643 offset += 16;
7644 cnt_16b++;
7645 }
7646 else if (rel + 2 < relend
7647 && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_ADDR64
7648 && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_TOC)
7649 {
7650 offset += 24;
7651 rel += 1;
7652 }
7653 else
7654 goto broken_opd;
7655 }
7656
7657 add_aux_fields = non_overlapping && cnt_16b > 0;
7658
7659 if (need_edit || add_aux_fields)
7660 {
7661 Elf_Internal_Rela *write_rel;
7662 Elf_Internal_Shdr *rel_hdr;
7663 bfd_byte *rptr, *wptr;
7664 bfd_byte *new_contents;
7665 bfd_boolean skip;
7666 long opd_ent_size;
7667 bfd_size_type amt;
7668
7669 new_contents = NULL;
7670 amt = sec->size * sizeof (long) / 8;
7671 opd = &ppc64_elf_section_data (sec)->u.opd;
7672 opd->adjust = bfd_zalloc (sec->owner, amt);
7673 if (opd->adjust == NULL)
7674 return FALSE;
7675 ppc64_elf_section_data (sec)->sec_type = sec_opd;
7676
7677 /* This seems a waste of time as input .opd sections are all
7678 zeros as generated by gcc, but I suppose there's no reason
7679 this will always be so. We might start putting something in
7680 the third word of .opd entries. */
7681 if ((sec->flags & SEC_IN_MEMORY) == 0)
7682 {
7683 bfd_byte *loc;
7684 if (!bfd_malloc_and_get_section (ibfd, sec, &loc))
7685 {
7686 if (loc != NULL)
7687 free (loc);
7688 error_ret:
7689 if (local_syms != NULL
7690 && symtab_hdr->contents != (unsigned char *) local_syms)
7691 free (local_syms);
7692 if (elf_section_data (sec)->relocs != relstart)
7693 free (relstart);
7694 return FALSE;
7695 }
7696 sec->contents = loc;
7697 sec->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
7698 }
7699
7700 elf_section_data (sec)->relocs = relstart;
7701
7702 new_contents = sec->contents;
7703 if (add_aux_fields)
7704 {
7705 new_contents = bfd_malloc (sec->size + cnt_16b * 8);
7706 if (new_contents == NULL)
7707 return FALSE;
7708 need_pad = FALSE;
7709 }
7710 wptr = new_contents;
7711 rptr = sec->contents;
7712
7713 write_rel = relstart;
7714 skip = FALSE;
7715 offset = 0;
7716 opd_ent_size = 0;
7717 for (rel = relstart; rel < relend; rel++)
7718 {
7719 unsigned long r_symndx;
7720 asection *sym_sec;
7721 struct elf_link_hash_entry *h;
7722 Elf_Internal_Sym *sym;
7723
7724 r_symndx = ELF64_R_SYM (rel->r_info);
7725 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7726 r_symndx, ibfd))
7727 goto error_ret;
7728
7729 if (rel->r_offset == offset)
7730 {
7731 struct ppc_link_hash_entry *fdh = NULL;
7732
7733 /* See if the .opd entry is full 24 byte or
7734 16 byte (with fd_aux entry overlapped with next
7735 fd_func). */
7736 opd_ent_size = 24;
7737 if ((rel + 2 == relend && sec->size == offset + 16)
7738 || (rel + 3 < relend
7739 && rel[2].r_offset == offset + 16
7740 && rel[3].r_offset == offset + 24
7741 && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_ADDR64
7742 && ELF64_R_TYPE (rel[3].r_info) == R_PPC64_TOC))
7743 opd_ent_size = 16;
7744
7745 if (h != NULL
7746 && h->root.root.string[0] == '.')
7747 {
7748 struct ppc_link_hash_table *htab;
7749
7750 htab = ppc_hash_table (info);
7751 if (htab != NULL)
7752 fdh = lookup_fdh ((struct ppc_link_hash_entry *) h,
7753 htab);
7754 if (fdh != NULL
7755 && fdh->elf.root.type != bfd_link_hash_defined
7756 && fdh->elf.root.type != bfd_link_hash_defweak)
7757 fdh = NULL;
7758 }
7759
7760 skip = (sym_sec->owner != ibfd
7761 || sym_sec->output_section == bfd_abs_section_ptr);
7762 if (skip)
7763 {
7764 if (fdh != NULL && sym_sec->owner == ibfd)
7765 {
7766 /* Arrange for the function descriptor sym
7767 to be dropped. */
7768 fdh->elf.root.u.def.value = 0;
7769 fdh->elf.root.u.def.section = sym_sec;
7770 }
7771 opd->adjust[rel->r_offset / 8] = -1;
7772 }
7773 else
7774 {
7775 /* We'll be keeping this opd entry. */
7776
7777 if (fdh != NULL)
7778 {
7779 /* Redefine the function descriptor symbol to
7780 this location in the opd section. It is
7781 necessary to update the value here rather
7782 than using an array of adjustments as we do
7783 for local symbols, because various places
7784 in the generic ELF code use the value
7785 stored in u.def.value. */
7786 fdh->elf.root.u.def.value = wptr - new_contents;
7787 fdh->adjust_done = 1;
7788 }
7789
7790 /* Local syms are a bit tricky. We could
7791 tweak them as they can be cached, but
7792 we'd need to look through the local syms
7793 for the function descriptor sym which we
7794 don't have at the moment. So keep an
7795 array of adjustments. */
7796 opd->adjust[rel->r_offset / 8]
7797 = (wptr - new_contents) - (rptr - sec->contents);
7798
7799 if (wptr != rptr)
7800 memcpy (wptr, rptr, opd_ent_size);
7801 wptr += opd_ent_size;
7802 if (add_aux_fields && opd_ent_size == 16)
7803 {
7804 memset (wptr, '\0', 8);
7805 wptr += 8;
7806 }
7807 }
7808 rptr += opd_ent_size;
7809 offset += opd_ent_size;
7810 }
7811
7812 if (skip)
7813 {
7814 if (!NO_OPD_RELOCS
7815 && !info->relocatable
7816 && !dec_dynrel_count (rel->r_info, sec, info,
7817 NULL, h, sym))
7818 goto error_ret;
7819 }
7820 else
7821 {
7822 /* We need to adjust any reloc offsets to point to the
7823 new opd entries. While we're at it, we may as well
7824 remove redundant relocs. */
7825 rel->r_offset += opd->adjust[(offset - opd_ent_size) / 8];
7826 if (write_rel != rel)
7827 memcpy (write_rel, rel, sizeof (*rel));
7828 ++write_rel;
7829 }
7830 }
7831
7832 sec->size = wptr - new_contents;
7833 sec->reloc_count = write_rel - relstart;
7834 if (add_aux_fields)
7835 {
7836 free (sec->contents);
7837 sec->contents = new_contents;
7838 }
7839
7840 /* Fudge the header size too, as this is used later in
7841 elf_bfd_final_link if we are emitting relocs. */
7842 rel_hdr = _bfd_elf_single_rel_hdr (sec);
7843 rel_hdr->sh_size = sec->reloc_count * rel_hdr->sh_entsize;
7844 some_edited = TRUE;
7845 }
7846 else if (elf_section_data (sec)->relocs != relstart)
7847 free (relstart);
7848
7849 if (local_syms != NULL
7850 && symtab_hdr->contents != (unsigned char *) local_syms)
7851 {
7852 if (!info->keep_memory)
7853 free (local_syms);
7854 else
7855 symtab_hdr->contents = (unsigned char *) local_syms;
7856 }
7857 }
7858
7859 if (some_edited)
7860 elf_link_hash_traverse (elf_hash_table (info), adjust_opd_syms, NULL);
7861
7862 /* If we are doing a final link and the last .opd entry is just 16 byte
7863 long, add a 8 byte padding after it. */
7864 if (need_pad != NULL && !info->relocatable)
7865 {
7866 bfd_byte *p;
7867
7868 if ((need_pad->flags & SEC_IN_MEMORY) == 0)
7869 {
7870 BFD_ASSERT (need_pad->size > 0);
7871
7872 p = bfd_malloc (need_pad->size + 8);
7873 if (p == NULL)
7874 return FALSE;
7875
7876 if (! bfd_get_section_contents (need_pad->owner, need_pad,
7877 p, 0, need_pad->size))
7878 return FALSE;
7879
7880 need_pad->contents = p;
7881 need_pad->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
7882 }
7883 else
7884 {
7885 p = bfd_realloc (need_pad->contents, need_pad->size + 8);
7886 if (p == NULL)
7887 return FALSE;
7888
7889 need_pad->contents = p;
7890 }
7891
7892 memset (need_pad->contents + need_pad->size, 0, 8);
7893 need_pad->size += 8;
7894 }
7895
7896 return TRUE;
7897 }
7898
7899 /* Set htab->tls_get_addr and call the generic ELF tls_setup function. */
7900
7901 asection *
7902 ppc64_elf_tls_setup (struct bfd_link_info *info,
7903 int no_tls_get_addr_opt,
7904 int *no_multi_toc)
7905 {
7906 struct ppc_link_hash_table *htab;
7907
7908 htab = ppc_hash_table (info);
7909 if (htab == NULL)
7910 return NULL;
7911
7912 if (abiversion (info->output_bfd) == 1)
7913 htab->opd_abi = 1;
7914
7915 if (*no_multi_toc)
7916 htab->do_multi_toc = 0;
7917 else if (!htab->do_multi_toc)
7918 *no_multi_toc = 1;
7919
7920 htab->tls_get_addr = ((struct ppc_link_hash_entry *)
7921 elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
7922 FALSE, FALSE, TRUE));
7923 /* Move dynamic linking info to the function descriptor sym. */
7924 if (htab->tls_get_addr != NULL)
7925 func_desc_adjust (&htab->tls_get_addr->elf, info);
7926 htab->tls_get_addr_fd = ((struct ppc_link_hash_entry *)
7927 elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
7928 FALSE, FALSE, TRUE));
7929 if (!no_tls_get_addr_opt)
7930 {
7931 struct elf_link_hash_entry *opt, *opt_fd, *tga, *tga_fd;
7932
7933 opt = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr_opt",
7934 FALSE, FALSE, TRUE);
7935 if (opt != NULL)
7936 func_desc_adjust (opt, info);
7937 opt_fd = elf_link_hash_lookup (&htab->elf, "__tls_get_addr_opt",
7938 FALSE, FALSE, TRUE);
7939 if (opt_fd != NULL
7940 && (opt_fd->root.type == bfd_link_hash_defined
7941 || opt_fd->root.type == bfd_link_hash_defweak))
7942 {
7943 /* If glibc supports an optimized __tls_get_addr call stub,
7944 signalled by the presence of __tls_get_addr_opt, and we'll
7945 be calling __tls_get_addr via a plt call stub, then
7946 make __tls_get_addr point to __tls_get_addr_opt. */
7947 tga_fd = &htab->tls_get_addr_fd->elf;
7948 if (htab->elf.dynamic_sections_created
7949 && tga_fd != NULL
7950 && (tga_fd->type == STT_FUNC
7951 || tga_fd->needs_plt)
7952 && !(SYMBOL_CALLS_LOCAL (info, tga_fd)
7953 || (ELF_ST_VISIBILITY (tga_fd->other) != STV_DEFAULT
7954 && tga_fd->root.type == bfd_link_hash_undefweak)))
7955 {
7956 struct plt_entry *ent;
7957
7958 for (ent = tga_fd->plt.plist; ent != NULL; ent = ent->next)
7959 if (ent->plt.refcount > 0)
7960 break;
7961 if (ent != NULL)
7962 {
7963 tga_fd->root.type = bfd_link_hash_indirect;
7964 tga_fd->root.u.i.link = &opt_fd->root;
7965 ppc64_elf_copy_indirect_symbol (info, opt_fd, tga_fd);
7966 if (opt_fd->dynindx != -1)
7967 {
7968 /* Use __tls_get_addr_opt in dynamic relocations. */
7969 opt_fd->dynindx = -1;
7970 _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
7971 opt_fd->dynstr_index);
7972 if (!bfd_elf_link_record_dynamic_symbol (info, opt_fd))
7973 return NULL;
7974 }
7975 htab->tls_get_addr_fd = (struct ppc_link_hash_entry *) opt_fd;
7976 tga = &htab->tls_get_addr->elf;
7977 if (opt != NULL && tga != NULL)
7978 {
7979 tga->root.type = bfd_link_hash_indirect;
7980 tga->root.u.i.link = &opt->root;
7981 ppc64_elf_copy_indirect_symbol (info, opt, tga);
7982 _bfd_elf_link_hash_hide_symbol (info, opt,
7983 tga->forced_local);
7984 htab->tls_get_addr = (struct ppc_link_hash_entry *) opt;
7985 }
7986 htab->tls_get_addr_fd->oh = htab->tls_get_addr;
7987 htab->tls_get_addr_fd->is_func_descriptor = 1;
7988 if (htab->tls_get_addr != NULL)
7989 {
7990 htab->tls_get_addr->oh = htab->tls_get_addr_fd;
7991 htab->tls_get_addr->is_func = 1;
7992 }
7993 }
7994 }
7995 }
7996 else
7997 no_tls_get_addr_opt = TRUE;
7998 }
7999 htab->no_tls_get_addr_opt = no_tls_get_addr_opt;
8000 return _bfd_elf_tls_setup (info->output_bfd, info);
8001 }
8002
8003 /* Return TRUE iff REL is a branch reloc with a global symbol matching
8004 HASH1 or HASH2. */
8005
8006 static bfd_boolean
8007 branch_reloc_hash_match (const bfd *ibfd,
8008 const Elf_Internal_Rela *rel,
8009 const struct ppc_link_hash_entry *hash1,
8010 const struct ppc_link_hash_entry *hash2)
8011 {
8012 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
8013 enum elf_ppc64_reloc_type r_type = ELF64_R_TYPE (rel->r_info);
8014 unsigned int r_symndx = ELF64_R_SYM (rel->r_info);
8015
8016 if (r_symndx >= symtab_hdr->sh_info && is_branch_reloc (r_type))
8017 {
8018 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
8019 struct elf_link_hash_entry *h;
8020
8021 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
8022 h = elf_follow_link (h);
8023 if (h == &hash1->elf || h == &hash2->elf)
8024 return TRUE;
8025 }
8026 return FALSE;
8027 }
8028
8029 /* Run through all the TLS relocs looking for optimization
8030 opportunities. The linker has been hacked (see ppc64elf.em) to do
8031 a preliminary section layout so that we know the TLS segment
8032 offsets. We can't optimize earlier because some optimizations need
8033 to know the tp offset, and we need to optimize before allocating
8034 dynamic relocations. */
8035
8036 bfd_boolean
8037 ppc64_elf_tls_optimize (struct bfd_link_info *info)
8038 {
8039 bfd *ibfd;
8040 asection *sec;
8041 struct ppc_link_hash_table *htab;
8042 unsigned char *toc_ref;
8043 int pass;
8044
8045 if (info->relocatable || !info->executable)
8046 return TRUE;
8047
8048 htab = ppc_hash_table (info);
8049 if (htab == NULL)
8050 return FALSE;
8051
8052 /* Make two passes over the relocs. On the first pass, mark toc
8053 entries involved with tls relocs, and check that tls relocs
8054 involved in setting up a tls_get_addr call are indeed followed by
8055 such a call. If they are not, we can't do any tls optimization.
8056 On the second pass twiddle tls_mask flags to notify
8057 relocate_section that optimization can be done, and adjust got
8058 and plt refcounts. */
8059 toc_ref = NULL;
8060 for (pass = 0; pass < 2; ++pass)
8061 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
8062 {
8063 Elf_Internal_Sym *locsyms = NULL;
8064 asection *toc = bfd_get_section_by_name (ibfd, ".toc");
8065
8066 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8067 if (sec->has_tls_reloc && !bfd_is_abs_section (sec->output_section))
8068 {
8069 Elf_Internal_Rela *relstart, *rel, *relend;
8070 bfd_boolean found_tls_get_addr_arg = 0;
8071
8072 /* Read the relocations. */
8073 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8074 info->keep_memory);
8075 if (relstart == NULL)
8076 return FALSE;
8077
8078 relend = relstart + sec->reloc_count;
8079 for (rel = relstart; rel < relend; rel++)
8080 {
8081 enum elf_ppc64_reloc_type r_type;
8082 unsigned long r_symndx;
8083 struct elf_link_hash_entry *h;
8084 Elf_Internal_Sym *sym;
8085 asection *sym_sec;
8086 unsigned char *tls_mask;
8087 unsigned char tls_set, tls_clear, tls_type = 0;
8088 bfd_vma value;
8089 bfd_boolean ok_tprel, is_local;
8090 long toc_ref_index = 0;
8091 int expecting_tls_get_addr = 0;
8092 bfd_boolean ret = FALSE;
8093
8094 r_symndx = ELF64_R_SYM (rel->r_info);
8095 if (!get_sym_h (&h, &sym, &sym_sec, &tls_mask, &locsyms,
8096 r_symndx, ibfd))
8097 {
8098 err_free_rel:
8099 if (elf_section_data (sec)->relocs != relstart)
8100 free (relstart);
8101 if (toc_ref != NULL)
8102 free (toc_ref);
8103 if (locsyms != NULL
8104 && (elf_symtab_hdr (ibfd).contents
8105 != (unsigned char *) locsyms))
8106 free (locsyms);
8107 return ret;
8108 }
8109
8110 if (h != NULL)
8111 {
8112 if (h->root.type == bfd_link_hash_defined
8113 || h->root.type == bfd_link_hash_defweak)
8114 value = h->root.u.def.value;
8115 else if (h->root.type == bfd_link_hash_undefweak)
8116 value = 0;
8117 else
8118 {
8119 found_tls_get_addr_arg = 0;
8120 continue;
8121 }
8122 }
8123 else
8124 /* Symbols referenced by TLS relocs must be of type
8125 STT_TLS. So no need for .opd local sym adjust. */
8126 value = sym->st_value;
8127
8128 ok_tprel = FALSE;
8129 is_local = FALSE;
8130 if (h == NULL
8131 || !h->def_dynamic)
8132 {
8133 is_local = TRUE;
8134 if (h != NULL
8135 && h->root.type == bfd_link_hash_undefweak)
8136 ok_tprel = TRUE;
8137 else
8138 {
8139 value += sym_sec->output_offset;
8140 value += sym_sec->output_section->vma;
8141 value -= htab->elf.tls_sec->vma;
8142 ok_tprel = (value + TP_OFFSET + ((bfd_vma) 1 << 31)
8143 < (bfd_vma) 1 << 32);
8144 }
8145 }
8146
8147 r_type = ELF64_R_TYPE (rel->r_info);
8148 /* If this section has old-style __tls_get_addr calls
8149 without marker relocs, then check that each
8150 __tls_get_addr call reloc is preceded by a reloc
8151 that conceivably belongs to the __tls_get_addr arg
8152 setup insn. If we don't find matching arg setup
8153 relocs, don't do any tls optimization. */
8154 if (pass == 0
8155 && sec->has_tls_get_addr_call
8156 && h != NULL
8157 && (h == &htab->tls_get_addr->elf
8158 || h == &htab->tls_get_addr_fd->elf)
8159 && !found_tls_get_addr_arg
8160 && is_branch_reloc (r_type))
8161 {
8162 info->callbacks->minfo (_("%H __tls_get_addr lost arg, "
8163 "TLS optimization disabled\n"),
8164 ibfd, sec, rel->r_offset);
8165 ret = TRUE;
8166 goto err_free_rel;
8167 }
8168
8169 found_tls_get_addr_arg = 0;
8170 switch (r_type)
8171 {
8172 case R_PPC64_GOT_TLSLD16:
8173 case R_PPC64_GOT_TLSLD16_LO:
8174 expecting_tls_get_addr = 1;
8175 found_tls_get_addr_arg = 1;
8176 /* Fall thru */
8177
8178 case R_PPC64_GOT_TLSLD16_HI:
8179 case R_PPC64_GOT_TLSLD16_HA:
8180 /* These relocs should never be against a symbol
8181 defined in a shared lib. Leave them alone if
8182 that turns out to be the case. */
8183 if (!is_local)
8184 continue;
8185
8186 /* LD -> LE */
8187 tls_set = 0;
8188 tls_clear = TLS_LD;
8189 tls_type = TLS_TLS | TLS_LD;
8190 break;
8191
8192 case R_PPC64_GOT_TLSGD16:
8193 case R_PPC64_GOT_TLSGD16_LO:
8194 expecting_tls_get_addr = 1;
8195 found_tls_get_addr_arg = 1;
8196 /* Fall thru */
8197
8198 case R_PPC64_GOT_TLSGD16_HI:
8199 case R_PPC64_GOT_TLSGD16_HA:
8200 if (ok_tprel)
8201 /* GD -> LE */
8202 tls_set = 0;
8203 else
8204 /* GD -> IE */
8205 tls_set = TLS_TLS | TLS_TPRELGD;
8206 tls_clear = TLS_GD;
8207 tls_type = TLS_TLS | TLS_GD;
8208 break;
8209
8210 case R_PPC64_GOT_TPREL16_DS:
8211 case R_PPC64_GOT_TPREL16_LO_DS:
8212 case R_PPC64_GOT_TPREL16_HI:
8213 case R_PPC64_GOT_TPREL16_HA:
8214 if (ok_tprel)
8215 {
8216 /* IE -> LE */
8217 tls_set = 0;
8218 tls_clear = TLS_TPREL;
8219 tls_type = TLS_TLS | TLS_TPREL;
8220 break;
8221 }
8222 continue;
8223
8224 case R_PPC64_TLSGD:
8225 case R_PPC64_TLSLD:
8226 found_tls_get_addr_arg = 1;
8227 /* Fall thru */
8228
8229 case R_PPC64_TLS:
8230 case R_PPC64_TOC16:
8231 case R_PPC64_TOC16_LO:
8232 if (sym_sec == NULL || sym_sec != toc)
8233 continue;
8234
8235 /* Mark this toc entry as referenced by a TLS
8236 code sequence. We can do that now in the
8237 case of R_PPC64_TLS, and after checking for
8238 tls_get_addr for the TOC16 relocs. */
8239 if (toc_ref == NULL)
8240 toc_ref = bfd_zmalloc (toc->output_section->rawsize / 8);
8241 if (toc_ref == NULL)
8242 goto err_free_rel;
8243
8244 if (h != NULL)
8245 value = h->root.u.def.value;
8246 else
8247 value = sym->st_value;
8248 value += rel->r_addend;
8249 BFD_ASSERT (value < toc->size && value % 8 == 0);
8250 toc_ref_index = (value + toc->output_offset) / 8;
8251 if (r_type == R_PPC64_TLS
8252 || r_type == R_PPC64_TLSGD
8253 || r_type == R_PPC64_TLSLD)
8254 {
8255 toc_ref[toc_ref_index] = 1;
8256 continue;
8257 }
8258
8259 if (pass != 0 && toc_ref[toc_ref_index] == 0)
8260 continue;
8261
8262 tls_set = 0;
8263 tls_clear = 0;
8264 expecting_tls_get_addr = 2;
8265 break;
8266
8267 case R_PPC64_TPREL64:
8268 if (pass == 0
8269 || sec != toc
8270 || toc_ref == NULL
8271 || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
8272 continue;
8273 if (ok_tprel)
8274 {
8275 /* IE -> LE */
8276 tls_set = TLS_EXPLICIT;
8277 tls_clear = TLS_TPREL;
8278 break;
8279 }
8280 continue;
8281
8282 case R_PPC64_DTPMOD64:
8283 if (pass == 0
8284 || sec != toc
8285 || toc_ref == NULL
8286 || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
8287 continue;
8288 if (rel + 1 < relend
8289 && (rel[1].r_info
8290 == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64))
8291 && rel[1].r_offset == rel->r_offset + 8)
8292 {
8293 if (ok_tprel)
8294 /* GD -> LE */
8295 tls_set = TLS_EXPLICIT | TLS_GD;
8296 else
8297 /* GD -> IE */
8298 tls_set = TLS_EXPLICIT | TLS_GD | TLS_TPRELGD;
8299 tls_clear = TLS_GD;
8300 }
8301 else
8302 {
8303 if (!is_local)
8304 continue;
8305
8306 /* LD -> LE */
8307 tls_set = TLS_EXPLICIT;
8308 tls_clear = TLS_LD;
8309 }
8310 break;
8311
8312 default:
8313 continue;
8314 }
8315
8316 if (pass == 0)
8317 {
8318 if (!expecting_tls_get_addr
8319 || !sec->has_tls_get_addr_call)
8320 continue;
8321
8322 if (rel + 1 < relend
8323 && branch_reloc_hash_match (ibfd, rel + 1,
8324 htab->tls_get_addr,
8325 htab->tls_get_addr_fd))
8326 {
8327 if (expecting_tls_get_addr == 2)
8328 {
8329 /* Check for toc tls entries. */
8330 unsigned char *toc_tls;
8331 int retval;
8332
8333 retval = get_tls_mask (&toc_tls, NULL, NULL,
8334 &locsyms,
8335 rel, ibfd);
8336 if (retval == 0)
8337 goto err_free_rel;
8338 if (toc_tls != NULL)
8339 {
8340 if ((*toc_tls & (TLS_GD | TLS_LD)) != 0)
8341 found_tls_get_addr_arg = 1;
8342 if (retval > 1)
8343 toc_ref[toc_ref_index] = 1;
8344 }
8345 }
8346 continue;
8347 }
8348
8349 if (expecting_tls_get_addr != 1)
8350 continue;
8351
8352 /* Uh oh, we didn't find the expected call. We
8353 could just mark this symbol to exclude it
8354 from tls optimization but it's safer to skip
8355 the entire optimization. */
8356 info->callbacks->minfo (_("%H arg lost __tls_get_addr, "
8357 "TLS optimization disabled\n"),
8358 ibfd, sec, rel->r_offset);
8359 ret = TRUE;
8360 goto err_free_rel;
8361 }
8362
8363 if (expecting_tls_get_addr && htab->tls_get_addr != NULL)
8364 {
8365 struct plt_entry *ent;
8366 for (ent = htab->tls_get_addr->elf.plt.plist;
8367 ent != NULL;
8368 ent = ent->next)
8369 if (ent->addend == 0)
8370 {
8371 if (ent->plt.refcount > 0)
8372 {
8373 ent->plt.refcount -= 1;
8374 expecting_tls_get_addr = 0;
8375 }
8376 break;
8377 }
8378 }
8379
8380 if (expecting_tls_get_addr && htab->tls_get_addr_fd != NULL)
8381 {
8382 struct plt_entry *ent;
8383 for (ent = htab->tls_get_addr_fd->elf.plt.plist;
8384 ent != NULL;
8385 ent = ent->next)
8386 if (ent->addend == 0)
8387 {
8388 if (ent->plt.refcount > 0)
8389 ent->plt.refcount -= 1;
8390 break;
8391 }
8392 }
8393
8394 if (tls_clear == 0)
8395 continue;
8396
8397 if ((tls_set & TLS_EXPLICIT) == 0)
8398 {
8399 struct got_entry *ent;
8400
8401 /* Adjust got entry for this reloc. */
8402 if (h != NULL)
8403 ent = h->got.glist;
8404 else
8405 ent = elf_local_got_ents (ibfd)[r_symndx];
8406
8407 for (; ent != NULL; ent = ent->next)
8408 if (ent->addend == rel->r_addend
8409 && ent->owner == ibfd
8410 && ent->tls_type == tls_type)
8411 break;
8412 if (ent == NULL)
8413 abort ();
8414
8415 if (tls_set == 0)
8416 {
8417 /* We managed to get rid of a got entry. */
8418 if (ent->got.refcount > 0)
8419 ent->got.refcount -= 1;
8420 }
8421 }
8422 else
8423 {
8424 /* If we got rid of a DTPMOD/DTPREL reloc pair then
8425 we'll lose one or two dyn relocs. */
8426 if (!dec_dynrel_count (rel->r_info, sec, info,
8427 NULL, h, sym))
8428 return FALSE;
8429
8430 if (tls_set == (TLS_EXPLICIT | TLS_GD))
8431 {
8432 if (!dec_dynrel_count ((rel + 1)->r_info, sec, info,
8433 NULL, h, sym))
8434 return FALSE;
8435 }
8436 }
8437
8438 *tls_mask |= tls_set;
8439 *tls_mask &= ~tls_clear;
8440 }
8441
8442 if (elf_section_data (sec)->relocs != relstart)
8443 free (relstart);
8444 }
8445
8446 if (locsyms != NULL
8447 && (elf_symtab_hdr (ibfd).contents != (unsigned char *) locsyms))
8448 {
8449 if (!info->keep_memory)
8450 free (locsyms);
8451 else
8452 elf_symtab_hdr (ibfd).contents = (unsigned char *) locsyms;
8453 }
8454 }
8455
8456 if (toc_ref != NULL)
8457 free (toc_ref);
8458 return TRUE;
8459 }
8460
8461 /* Called via elf_link_hash_traverse from ppc64_elf_edit_toc to adjust
8462 the values of any global symbols in a toc section that has been
8463 edited. Globals in toc sections should be a rarity, so this function
8464 sets a flag if any are found in toc sections other than the one just
8465 edited, so that futher hash table traversals can be avoided. */
8466
8467 struct adjust_toc_info
8468 {
8469 asection *toc;
8470 unsigned long *skip;
8471 bfd_boolean global_toc_syms;
8472 };
8473
8474 enum toc_skip_enum { ref_from_discarded = 1, can_optimize = 2 };
8475
8476 static bfd_boolean
8477 adjust_toc_syms (struct elf_link_hash_entry *h, void *inf)
8478 {
8479 struct ppc_link_hash_entry *eh;
8480 struct adjust_toc_info *toc_inf = (struct adjust_toc_info *) inf;
8481 unsigned long i;
8482
8483 if (h->root.type != bfd_link_hash_defined
8484 && h->root.type != bfd_link_hash_defweak)
8485 return TRUE;
8486
8487 eh = (struct ppc_link_hash_entry *) h;
8488 if (eh->adjust_done)
8489 return TRUE;
8490
8491 if (eh->elf.root.u.def.section == toc_inf->toc)
8492 {
8493 if (eh->elf.root.u.def.value > toc_inf->toc->rawsize)
8494 i = toc_inf->toc->rawsize >> 3;
8495 else
8496 i = eh->elf.root.u.def.value >> 3;
8497
8498 if ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0)
8499 {
8500 (*_bfd_error_handler)
8501 (_("%s defined on removed toc entry"), eh->elf.root.root.string);
8502 do
8503 ++i;
8504 while ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0);
8505 eh->elf.root.u.def.value = (bfd_vma) i << 3;
8506 }
8507
8508 eh->elf.root.u.def.value -= toc_inf->skip[i];
8509 eh->adjust_done = 1;
8510 }
8511 else if (strcmp (eh->elf.root.u.def.section->name, ".toc") == 0)
8512 toc_inf->global_toc_syms = TRUE;
8513
8514 return TRUE;
8515 }
8516
8517 /* Return TRUE iff INSN is one we expect on a _LO variety toc/got reloc. */
8518
8519 static bfd_boolean
8520 ok_lo_toc_insn (unsigned int insn)
8521 {
8522 return ((insn & (0x3f << 26)) == 14u << 26 /* addi */
8523 || (insn & (0x3f << 26)) == 32u << 26 /* lwz */
8524 || (insn & (0x3f << 26)) == 34u << 26 /* lbz */
8525 || (insn & (0x3f << 26)) == 36u << 26 /* stw */
8526 || (insn & (0x3f << 26)) == 38u << 26 /* stb */
8527 || (insn & (0x3f << 26)) == 40u << 26 /* lhz */
8528 || (insn & (0x3f << 26)) == 42u << 26 /* lha */
8529 || (insn & (0x3f << 26)) == 44u << 26 /* sth */
8530 || (insn & (0x3f << 26)) == 46u << 26 /* lmw */
8531 || (insn & (0x3f << 26)) == 47u << 26 /* stmw */
8532 || (insn & (0x3f << 26)) == 48u << 26 /* lfs */
8533 || (insn & (0x3f << 26)) == 50u << 26 /* lfd */
8534 || (insn & (0x3f << 26)) == 52u << 26 /* stfs */
8535 || (insn & (0x3f << 26)) == 54u << 26 /* stfd */
8536 || ((insn & (0x3f << 26)) == 58u << 26 /* lwa,ld,lmd */
8537 && (insn & 3) != 1)
8538 || ((insn & (0x3f << 26)) == 62u << 26 /* std, stmd */
8539 && ((insn & 3) == 0 || (insn & 3) == 3))
8540 || (insn & (0x3f << 26)) == 12u << 26 /* addic */);
8541 }
8542
8543 /* Examine all relocs referencing .toc sections in order to remove
8544 unused .toc entries. */
8545
8546 bfd_boolean
8547 ppc64_elf_edit_toc (struct bfd_link_info *info)
8548 {
8549 bfd *ibfd;
8550 struct adjust_toc_info toc_inf;
8551 struct ppc_link_hash_table *htab = ppc_hash_table (info);
8552
8553 htab->do_toc_opt = 1;
8554 toc_inf.global_toc_syms = TRUE;
8555 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
8556 {
8557 asection *toc, *sec;
8558 Elf_Internal_Shdr *symtab_hdr;
8559 Elf_Internal_Sym *local_syms;
8560 Elf_Internal_Rela *relstart, *rel, *toc_relocs;
8561 unsigned long *skip, *drop;
8562 unsigned char *used;
8563 unsigned char *keep, last, some_unused;
8564
8565 if (!is_ppc64_elf (ibfd))
8566 continue;
8567
8568 toc = bfd_get_section_by_name (ibfd, ".toc");
8569 if (toc == NULL
8570 || toc->size == 0
8571 || toc->sec_info_type == SEC_INFO_TYPE_JUST_SYMS
8572 || discarded_section (toc))
8573 continue;
8574
8575 toc_relocs = NULL;
8576 local_syms = NULL;
8577 symtab_hdr = &elf_symtab_hdr (ibfd);
8578
8579 /* Look at sections dropped from the final link. */
8580 skip = NULL;
8581 relstart = NULL;
8582 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8583 {
8584 if (sec->reloc_count == 0
8585 || !discarded_section (sec)
8586 || get_opd_info (sec)
8587 || (sec->flags & SEC_ALLOC) == 0
8588 || (sec->flags & SEC_DEBUGGING) != 0)
8589 continue;
8590
8591 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL, FALSE);
8592 if (relstart == NULL)
8593 goto error_ret;
8594
8595 /* Run through the relocs to see which toc entries might be
8596 unused. */
8597 for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
8598 {
8599 enum elf_ppc64_reloc_type r_type;
8600 unsigned long r_symndx;
8601 asection *sym_sec;
8602 struct elf_link_hash_entry *h;
8603 Elf_Internal_Sym *sym;
8604 bfd_vma val;
8605
8606 r_type = ELF64_R_TYPE (rel->r_info);
8607 switch (r_type)
8608 {
8609 default:
8610 continue;
8611
8612 case R_PPC64_TOC16:
8613 case R_PPC64_TOC16_LO:
8614 case R_PPC64_TOC16_HI:
8615 case R_PPC64_TOC16_HA:
8616 case R_PPC64_TOC16_DS:
8617 case R_PPC64_TOC16_LO_DS:
8618 break;
8619 }
8620
8621 r_symndx = ELF64_R_SYM (rel->r_info);
8622 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8623 r_symndx, ibfd))
8624 goto error_ret;
8625
8626 if (sym_sec != toc)
8627 continue;
8628
8629 if (h != NULL)
8630 val = h->root.u.def.value;
8631 else
8632 val = sym->st_value;
8633 val += rel->r_addend;
8634
8635 if (val >= toc->size)
8636 continue;
8637
8638 /* Anything in the toc ought to be aligned to 8 bytes.
8639 If not, don't mark as unused. */
8640 if (val & 7)
8641 continue;
8642
8643 if (skip == NULL)
8644 {
8645 skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
8646 if (skip == NULL)
8647 goto error_ret;
8648 }
8649
8650 skip[val >> 3] = ref_from_discarded;
8651 }
8652
8653 if (elf_section_data (sec)->relocs != relstart)
8654 free (relstart);
8655 }
8656
8657 /* For largetoc loads of address constants, we can convert
8658 . addis rx,2,addr@got@ha
8659 . ld ry,addr@got@l(rx)
8660 to
8661 . addis rx,2,addr@toc@ha
8662 . addi ry,rx,addr@toc@l
8663 when addr is within 2G of the toc pointer. This then means
8664 that the word storing "addr" in the toc is no longer needed. */
8665
8666 if (!ppc64_elf_tdata (ibfd)->has_small_toc_reloc
8667 && toc->output_section->rawsize < (bfd_vma) 1 << 31
8668 && toc->reloc_count != 0)
8669 {
8670 /* Read toc relocs. */
8671 toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
8672 info->keep_memory);
8673 if (toc_relocs == NULL)
8674 goto error_ret;
8675
8676 for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
8677 {
8678 enum elf_ppc64_reloc_type r_type;
8679 unsigned long r_symndx;
8680 asection *sym_sec;
8681 struct elf_link_hash_entry *h;
8682 Elf_Internal_Sym *sym;
8683 bfd_vma val, addr;
8684
8685 r_type = ELF64_R_TYPE (rel->r_info);
8686 if (r_type != R_PPC64_ADDR64)
8687 continue;
8688
8689 r_symndx = ELF64_R_SYM (rel->r_info);
8690 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8691 r_symndx, ibfd))
8692 goto error_ret;
8693
8694 if (sym_sec == NULL
8695 || discarded_section (sym_sec))
8696 continue;
8697
8698 if (!SYMBOL_REFERENCES_LOCAL (info, h))
8699 continue;
8700
8701 if (h != NULL)
8702 {
8703 if (h->type == STT_GNU_IFUNC)
8704 continue;
8705 val = h->root.u.def.value;
8706 }
8707 else
8708 {
8709 if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
8710 continue;
8711 val = sym->st_value;
8712 }
8713 val += rel->r_addend;
8714 val += sym_sec->output_section->vma + sym_sec->output_offset;
8715
8716 /* We don't yet know the exact toc pointer value, but we
8717 know it will be somewhere in the toc section. Don't
8718 optimize if the difference from any possible toc
8719 pointer is outside [ff..f80008000, 7fff7fff]. */
8720 addr = toc->output_section->vma + TOC_BASE_OFF;
8721 if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
8722 continue;
8723
8724 addr = toc->output_section->vma + toc->output_section->rawsize;
8725 if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
8726 continue;
8727
8728 if (skip == NULL)
8729 {
8730 skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
8731 if (skip == NULL)
8732 goto error_ret;
8733 }
8734
8735 skip[rel->r_offset >> 3]
8736 |= can_optimize | ((rel - toc_relocs) << 2);
8737 }
8738 }
8739
8740 if (skip == NULL)
8741 continue;
8742
8743 used = bfd_zmalloc (sizeof (*used) * (toc->size + 7) / 8);
8744 if (used == NULL)
8745 {
8746 error_ret:
8747 if (local_syms != NULL
8748 && symtab_hdr->contents != (unsigned char *) local_syms)
8749 free (local_syms);
8750 if (sec != NULL
8751 && relstart != NULL
8752 && elf_section_data (sec)->relocs != relstart)
8753 free (relstart);
8754 if (toc_relocs != NULL
8755 && elf_section_data (toc)->relocs != toc_relocs)
8756 free (toc_relocs);
8757 if (skip != NULL)
8758 free (skip);
8759 return FALSE;
8760 }
8761
8762 /* Now check all kept sections that might reference the toc.
8763 Check the toc itself last. */
8764 for (sec = (ibfd->sections == toc && toc->next ? toc->next
8765 : ibfd->sections);
8766 sec != NULL;
8767 sec = (sec == toc ? NULL
8768 : sec->next == NULL ? toc
8769 : sec->next == toc && toc->next ? toc->next
8770 : sec->next))
8771 {
8772 int repeat;
8773
8774 if (sec->reloc_count == 0
8775 || discarded_section (sec)
8776 || get_opd_info (sec)
8777 || (sec->flags & SEC_ALLOC) == 0
8778 || (sec->flags & SEC_DEBUGGING) != 0)
8779 continue;
8780
8781 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8782 info->keep_memory);
8783 if (relstart == NULL)
8784 goto error_ret;
8785
8786 /* Mark toc entries referenced as used. */
8787 do
8788 {
8789 repeat = 0;
8790 for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
8791 {
8792 enum elf_ppc64_reloc_type r_type;
8793 unsigned long r_symndx;
8794 asection *sym_sec;
8795 struct elf_link_hash_entry *h;
8796 Elf_Internal_Sym *sym;
8797 bfd_vma val;
8798 enum {no_check, check_lo, check_ha} insn_check;
8799
8800 r_type = ELF64_R_TYPE (rel->r_info);
8801 switch (r_type)
8802 {
8803 default:
8804 insn_check = no_check;
8805 break;
8806
8807 case R_PPC64_GOT_TLSLD16_HA:
8808 case R_PPC64_GOT_TLSGD16_HA:
8809 case R_PPC64_GOT_TPREL16_HA:
8810 case R_PPC64_GOT_DTPREL16_HA:
8811 case R_PPC64_GOT16_HA:
8812 case R_PPC64_TOC16_HA:
8813 insn_check = check_ha;
8814 break;
8815
8816 case R_PPC64_GOT_TLSLD16_LO:
8817 case R_PPC64_GOT_TLSGD16_LO:
8818 case R_PPC64_GOT_TPREL16_LO_DS:
8819 case R_PPC64_GOT_DTPREL16_LO_DS:
8820 case R_PPC64_GOT16_LO:
8821 case R_PPC64_GOT16_LO_DS:
8822 case R_PPC64_TOC16_LO:
8823 case R_PPC64_TOC16_LO_DS:
8824 insn_check = check_lo;
8825 break;
8826 }
8827
8828 if (insn_check != no_check)
8829 {
8830 bfd_vma off = rel->r_offset & ~3;
8831 unsigned char buf[4];
8832 unsigned int insn;
8833
8834 if (!bfd_get_section_contents (ibfd, sec, buf, off, 4))
8835 {
8836 free (used);
8837 goto error_ret;
8838 }
8839 insn = bfd_get_32 (ibfd, buf);
8840 if (insn_check == check_lo
8841 ? !ok_lo_toc_insn (insn)
8842 : ((insn & ((0x3f << 26) | 0x1f << 16))
8843 != ((15u << 26) | (2 << 16)) /* addis rt,2,imm */))
8844 {
8845 char str[12];
8846
8847 ppc64_elf_tdata (ibfd)->unexpected_toc_insn = 1;
8848 sprintf (str, "%#08x", insn);
8849 info->callbacks->einfo
8850 (_("%P: %H: toc optimization is not supported for"
8851 " %s instruction.\n"),
8852 ibfd, sec, rel->r_offset & ~3, str);
8853 }
8854 }
8855
8856 switch (r_type)
8857 {
8858 case R_PPC64_TOC16:
8859 case R_PPC64_TOC16_LO:
8860 case R_PPC64_TOC16_HI:
8861 case R_PPC64_TOC16_HA:
8862 case R_PPC64_TOC16_DS:
8863 case R_PPC64_TOC16_LO_DS:
8864 /* In case we're taking addresses of toc entries. */
8865 case R_PPC64_ADDR64:
8866 break;
8867
8868 default:
8869 continue;
8870 }
8871
8872 r_symndx = ELF64_R_SYM (rel->r_info);
8873 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8874 r_symndx, ibfd))
8875 {
8876 free (used);
8877 goto error_ret;
8878 }
8879
8880 if (sym_sec != toc)
8881 continue;
8882
8883 if (h != NULL)
8884 val = h->root.u.def.value;
8885 else
8886 val = sym->st_value;
8887 val += rel->r_addend;
8888
8889 if (val >= toc->size)
8890 continue;
8891
8892 if ((skip[val >> 3] & can_optimize) != 0)
8893 {
8894 bfd_vma off;
8895 unsigned char opc;
8896
8897 switch (r_type)
8898 {
8899 case R_PPC64_TOC16_HA:
8900 break;
8901
8902 case R_PPC64_TOC16_LO_DS:
8903 off = rel->r_offset;
8904 off += (bfd_big_endian (ibfd) ? -2 : 3);
8905 if (!bfd_get_section_contents (ibfd, sec, &opc,
8906 off, 1))
8907 {
8908 free (used);
8909 goto error_ret;
8910 }
8911 if ((opc & (0x3f << 2)) == (58u << 2))
8912 break;
8913 /* Fall thru */
8914
8915 default:
8916 /* Wrong sort of reloc, or not a ld. We may
8917 as well clear ref_from_discarded too. */
8918 skip[val >> 3] = 0;
8919 }
8920 }
8921
8922 if (sec != toc)
8923 used[val >> 3] = 1;
8924 /* For the toc section, we only mark as used if this
8925 entry itself isn't unused. */
8926 else if ((used[rel->r_offset >> 3]
8927 || !(skip[rel->r_offset >> 3] & ref_from_discarded))
8928 && !used[val >> 3])
8929 {
8930 /* Do all the relocs again, to catch reference
8931 chains. */
8932 repeat = 1;
8933 used[val >> 3] = 1;
8934 }
8935 }
8936 }
8937 while (repeat);
8938
8939 if (elf_section_data (sec)->relocs != relstart)
8940 free (relstart);
8941 }
8942
8943 /* Merge the used and skip arrays. Assume that TOC
8944 doublewords not appearing as either used or unused belong
8945 to to an entry more than one doubleword in size. */
8946 for (drop = skip, keep = used, last = 0, some_unused = 0;
8947 drop < skip + (toc->size + 7) / 8;
8948 ++drop, ++keep)
8949 {
8950 if (*keep)
8951 {
8952 *drop &= ~ref_from_discarded;
8953 if ((*drop & can_optimize) != 0)
8954 some_unused = 1;
8955 last = 0;
8956 }
8957 else if ((*drop & ref_from_discarded) != 0)
8958 {
8959 some_unused = 1;
8960 last = ref_from_discarded;
8961 }
8962 else
8963 *drop = last;
8964 }
8965
8966 free (used);
8967
8968 if (some_unused)
8969 {
8970 bfd_byte *contents, *src;
8971 unsigned long off;
8972 Elf_Internal_Sym *sym;
8973 bfd_boolean local_toc_syms = FALSE;
8974
8975 /* Shuffle the toc contents, and at the same time convert the
8976 skip array from booleans into offsets. */
8977 if (!bfd_malloc_and_get_section (ibfd, toc, &contents))
8978 goto error_ret;
8979
8980 elf_section_data (toc)->this_hdr.contents = contents;
8981
8982 for (src = contents, off = 0, drop = skip;
8983 src < contents + toc->size;
8984 src += 8, ++drop)
8985 {
8986 if ((*drop & (can_optimize | ref_from_discarded)) != 0)
8987 off += 8;
8988 else if (off != 0)
8989 {
8990 *drop = off;
8991 memcpy (src - off, src, 8);
8992 }
8993 }
8994 *drop = off;
8995 toc->rawsize = toc->size;
8996 toc->size = src - contents - off;
8997
8998 /* Adjust addends for relocs against the toc section sym,
8999 and optimize any accesses we can. */
9000 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
9001 {
9002 if (sec->reloc_count == 0
9003 || discarded_section (sec))
9004 continue;
9005
9006 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
9007 info->keep_memory);
9008 if (relstart == NULL)
9009 goto error_ret;
9010
9011 for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9012 {
9013 enum elf_ppc64_reloc_type r_type;
9014 unsigned long r_symndx;
9015 asection *sym_sec;
9016 struct elf_link_hash_entry *h;
9017 bfd_vma val;
9018
9019 r_type = ELF64_R_TYPE (rel->r_info);
9020 switch (r_type)
9021 {
9022 default:
9023 continue;
9024
9025 case R_PPC64_TOC16:
9026 case R_PPC64_TOC16_LO:
9027 case R_PPC64_TOC16_HI:
9028 case R_PPC64_TOC16_HA:
9029 case R_PPC64_TOC16_DS:
9030 case R_PPC64_TOC16_LO_DS:
9031 case R_PPC64_ADDR64:
9032 break;
9033 }
9034
9035 r_symndx = ELF64_R_SYM (rel->r_info);
9036 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9037 r_symndx, ibfd))
9038 goto error_ret;
9039
9040 if (sym_sec != toc)
9041 continue;
9042
9043 if (h != NULL)
9044 val = h->root.u.def.value;
9045 else
9046 {
9047 val = sym->st_value;
9048 if (val != 0)
9049 local_toc_syms = TRUE;
9050 }
9051
9052 val += rel->r_addend;
9053
9054 if (val > toc->rawsize)
9055 val = toc->rawsize;
9056 else if ((skip[val >> 3] & ref_from_discarded) != 0)
9057 continue;
9058 else if ((skip[val >> 3] & can_optimize) != 0)
9059 {
9060 Elf_Internal_Rela *tocrel
9061 = toc_relocs + (skip[val >> 3] >> 2);
9062 unsigned long tsym = ELF64_R_SYM (tocrel->r_info);
9063
9064 switch (r_type)
9065 {
9066 case R_PPC64_TOC16_HA:
9067 rel->r_info = ELF64_R_INFO (tsym, R_PPC64_TOC16_HA);
9068 break;
9069
9070 case R_PPC64_TOC16_LO_DS:
9071 rel->r_info = ELF64_R_INFO (tsym, R_PPC64_LO_DS_OPT);
9072 break;
9073
9074 default:
9075 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
9076 ppc_howto_init ();
9077 info->callbacks->einfo
9078 (_("%P: %H: %s references "
9079 "optimized away TOC entry\n"),
9080 ibfd, sec, rel->r_offset,
9081 ppc64_elf_howto_table[r_type]->name);
9082 bfd_set_error (bfd_error_bad_value);
9083 goto error_ret;
9084 }
9085 rel->r_addend = tocrel->r_addend;
9086 elf_section_data (sec)->relocs = relstart;
9087 continue;
9088 }
9089
9090 if (h != NULL || sym->st_value != 0)
9091 continue;
9092
9093 rel->r_addend -= skip[val >> 3];
9094 elf_section_data (sec)->relocs = relstart;
9095 }
9096
9097 if (elf_section_data (sec)->relocs != relstart)
9098 free (relstart);
9099 }
9100
9101 /* We shouldn't have local or global symbols defined in the TOC,
9102 but handle them anyway. */
9103 if (local_syms != NULL)
9104 for (sym = local_syms;
9105 sym < local_syms + symtab_hdr->sh_info;
9106 ++sym)
9107 if (sym->st_value != 0
9108 && bfd_section_from_elf_index (ibfd, sym->st_shndx) == toc)
9109 {
9110 unsigned long i;
9111
9112 if (sym->st_value > toc->rawsize)
9113 i = toc->rawsize >> 3;
9114 else
9115 i = sym->st_value >> 3;
9116
9117 if ((skip[i] & (ref_from_discarded | can_optimize)) != 0)
9118 {
9119 if (local_toc_syms)
9120 (*_bfd_error_handler)
9121 (_("%s defined on removed toc entry"),
9122 bfd_elf_sym_name (ibfd, symtab_hdr, sym, NULL));
9123 do
9124 ++i;
9125 while ((skip[i] & (ref_from_discarded | can_optimize)));
9126 sym->st_value = (bfd_vma) i << 3;
9127 }
9128
9129 sym->st_value -= skip[i];
9130 symtab_hdr->contents = (unsigned char *) local_syms;
9131 }
9132
9133 /* Adjust any global syms defined in this toc input section. */
9134 if (toc_inf.global_toc_syms)
9135 {
9136 toc_inf.toc = toc;
9137 toc_inf.skip = skip;
9138 toc_inf.global_toc_syms = FALSE;
9139 elf_link_hash_traverse (elf_hash_table (info), adjust_toc_syms,
9140 &toc_inf);
9141 }
9142
9143 if (toc->reloc_count != 0)
9144 {
9145 Elf_Internal_Shdr *rel_hdr;
9146 Elf_Internal_Rela *wrel;
9147 bfd_size_type sz;
9148
9149 /* Remove unused toc relocs, and adjust those we keep. */
9150 if (toc_relocs == NULL)
9151 toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
9152 info->keep_memory);
9153 if (toc_relocs == NULL)
9154 goto error_ret;
9155
9156 wrel = toc_relocs;
9157 for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
9158 if ((skip[rel->r_offset >> 3]
9159 & (ref_from_discarded | can_optimize)) == 0)
9160 {
9161 wrel->r_offset = rel->r_offset - skip[rel->r_offset >> 3];
9162 wrel->r_info = rel->r_info;
9163 wrel->r_addend = rel->r_addend;
9164 ++wrel;
9165 }
9166 else if (!dec_dynrel_count (rel->r_info, toc, info,
9167 &local_syms, NULL, NULL))
9168 goto error_ret;
9169
9170 elf_section_data (toc)->relocs = toc_relocs;
9171 toc->reloc_count = wrel - toc_relocs;
9172 rel_hdr = _bfd_elf_single_rel_hdr (toc);
9173 sz = rel_hdr->sh_entsize;
9174 rel_hdr->sh_size = toc->reloc_count * sz;
9175 }
9176 }
9177 else if (toc_relocs != NULL
9178 && elf_section_data (toc)->relocs != toc_relocs)
9179 free (toc_relocs);
9180
9181 if (local_syms != NULL
9182 && symtab_hdr->contents != (unsigned char *) local_syms)
9183 {
9184 if (!info->keep_memory)
9185 free (local_syms);
9186 else
9187 symtab_hdr->contents = (unsigned char *) local_syms;
9188 }
9189 free (skip);
9190 }
9191
9192 return TRUE;
9193 }
9194
9195 /* Return true iff input section I references the TOC using
9196 instructions limited to +/-32k offsets. */
9197
9198 bfd_boolean
9199 ppc64_elf_has_small_toc_reloc (asection *i)
9200 {
9201 return (is_ppc64_elf (i->owner)
9202 && ppc64_elf_tdata (i->owner)->has_small_toc_reloc);
9203 }
9204
9205 /* Allocate space for one GOT entry. */
9206
9207 static void
9208 allocate_got (struct elf_link_hash_entry *h,
9209 struct bfd_link_info *info,
9210 struct got_entry *gent)
9211 {
9212 struct ppc_link_hash_table *htab = ppc_hash_table (info);
9213 bfd_boolean dyn;
9214 struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
9215 int entsize = (gent->tls_type & eh->tls_mask & (TLS_GD | TLS_LD)
9216 ? 16 : 8);
9217 int rentsize = (gent->tls_type & eh->tls_mask & TLS_GD
9218 ? 2 : 1) * sizeof (Elf64_External_Rela);
9219 asection *got = ppc64_elf_tdata (gent->owner)->got;
9220
9221 gent->got.offset = got->size;
9222 got->size += entsize;
9223
9224 dyn = htab->elf.dynamic_sections_created;
9225 if (h->type == STT_GNU_IFUNC)
9226 {
9227 htab->elf.irelplt->size += rentsize;
9228 htab->got_reli_size += rentsize;
9229 }
9230 else if ((info->shared
9231 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h))
9232 && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
9233 || h->root.type != bfd_link_hash_undefweak))
9234 {
9235 asection *relgot = ppc64_elf_tdata (gent->owner)->relgot;
9236 relgot->size += rentsize;
9237 }
9238 }
9239
9240 /* This function merges got entries in the same toc group. */
9241
9242 static void
9243 merge_got_entries (struct got_entry **pent)
9244 {
9245 struct got_entry *ent, *ent2;
9246
9247 for (ent = *pent; ent != NULL; ent = ent->next)
9248 if (!ent->is_indirect)
9249 for (ent2 = ent->next; ent2 != NULL; ent2 = ent2->next)
9250 if (!ent2->is_indirect
9251 && ent2->addend == ent->addend
9252 && ent2->tls_type == ent->tls_type
9253 && elf_gp (ent2->owner) == elf_gp (ent->owner))
9254 {
9255 ent2->is_indirect = TRUE;
9256 ent2->got.ent = ent;
9257 }
9258 }
9259
9260 /* Allocate space in .plt, .got and associated reloc sections for
9261 dynamic relocs. */
9262
9263 static bfd_boolean
9264 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
9265 {
9266 struct bfd_link_info *info;
9267 struct ppc_link_hash_table *htab;
9268 asection *s;
9269 struct ppc_link_hash_entry *eh;
9270 struct elf_dyn_relocs *p;
9271 struct got_entry **pgent, *gent;
9272
9273 if (h->root.type == bfd_link_hash_indirect)
9274 return TRUE;
9275
9276 info = (struct bfd_link_info *) inf;
9277 htab = ppc_hash_table (info);
9278 if (htab == NULL)
9279 return FALSE;
9280
9281 if ((htab->elf.dynamic_sections_created
9282 && h->dynindx != -1
9283 && WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info->shared, h))
9284 || h->type == STT_GNU_IFUNC)
9285 {
9286 struct plt_entry *pent;
9287 bfd_boolean doneone = FALSE;
9288 for (pent = h->plt.plist; pent != NULL; pent = pent->next)
9289 if (pent->plt.refcount > 0)
9290 {
9291 if (!htab->elf.dynamic_sections_created
9292 || h->dynindx == -1)
9293 {
9294 s = htab->elf.iplt;
9295 pent->plt.offset = s->size;
9296 s->size += PLT_ENTRY_SIZE (htab);
9297 s = htab->elf.irelplt;
9298 }
9299 else
9300 {
9301 /* If this is the first .plt entry, make room for the special
9302 first entry. */
9303 s = htab->elf.splt;
9304 if (s->size == 0)
9305 s->size += PLT_INITIAL_ENTRY_SIZE (htab);
9306
9307 pent->plt.offset = s->size;
9308
9309 /* Make room for this entry. */
9310 s->size += PLT_ENTRY_SIZE (htab);
9311
9312 /* Make room for the .glink code. */
9313 s = htab->glink;
9314 if (s->size == 0)
9315 s->size += GLINK_CALL_STUB_SIZE;
9316 if (htab->opd_abi)
9317 {
9318 /* We need bigger stubs past index 32767. */
9319 if (s->size >= GLINK_CALL_STUB_SIZE + 32768*2*4)
9320 s->size += 4;
9321 s->size += 2*4;
9322 }
9323 else
9324 s->size += 4;
9325
9326 /* We also need to make an entry in the .rela.plt section. */
9327 s = htab->elf.srelplt;
9328 }
9329 s->size += sizeof (Elf64_External_Rela);
9330 doneone = TRUE;
9331 }
9332 else
9333 pent->plt.offset = (bfd_vma) -1;
9334 if (!doneone)
9335 {
9336 h->plt.plist = NULL;
9337 h->needs_plt = 0;
9338 }
9339 }
9340 else
9341 {
9342 h->plt.plist = NULL;
9343 h->needs_plt = 0;
9344 }
9345
9346 eh = (struct ppc_link_hash_entry *) h;
9347 /* Run through the TLS GD got entries first if we're changing them
9348 to TPREL. */
9349 if ((eh->tls_mask & TLS_TPRELGD) != 0)
9350 for (gent = h->got.glist; gent != NULL; gent = gent->next)
9351 if (gent->got.refcount > 0
9352 && (gent->tls_type & TLS_GD) != 0)
9353 {
9354 /* This was a GD entry that has been converted to TPREL. If
9355 there happens to be a TPREL entry we can use that one. */
9356 struct got_entry *ent;
9357 for (ent = h->got.glist; ent != NULL; ent = ent->next)
9358 if (ent->got.refcount > 0
9359 && (ent->tls_type & TLS_TPREL) != 0
9360 && ent->addend == gent->addend
9361 && ent->owner == gent->owner)
9362 {
9363 gent->got.refcount = 0;
9364 break;
9365 }
9366
9367 /* If not, then we'll be using our own TPREL entry. */
9368 if (gent->got.refcount != 0)
9369 gent->tls_type = TLS_TLS | TLS_TPREL;
9370 }
9371
9372 /* Remove any list entry that won't generate a word in the GOT before
9373 we call merge_got_entries. Otherwise we risk merging to empty
9374 entries. */
9375 pgent = &h->got.glist;
9376 while ((gent = *pgent) != NULL)
9377 if (gent->got.refcount > 0)
9378 {
9379 if ((gent->tls_type & TLS_LD) != 0
9380 && !h->def_dynamic)
9381 {
9382 ppc64_tlsld_got (gent->owner)->got.refcount += 1;
9383 *pgent = gent->next;
9384 }
9385 else
9386 pgent = &gent->next;
9387 }
9388 else
9389 *pgent = gent->next;
9390
9391 if (!htab->do_multi_toc)
9392 merge_got_entries (&h->got.glist);
9393
9394 for (gent = h->got.glist; gent != NULL; gent = gent->next)
9395 if (!gent->is_indirect)
9396 {
9397 /* Make sure this symbol is output as a dynamic symbol.
9398 Undefined weak syms won't yet be marked as dynamic,
9399 nor will all TLS symbols. */
9400 if (h->dynindx == -1
9401 && !h->forced_local
9402 && h->type != STT_GNU_IFUNC
9403 && htab->elf.dynamic_sections_created)
9404 {
9405 if (! bfd_elf_link_record_dynamic_symbol (info, h))
9406 return FALSE;
9407 }
9408
9409 if (!is_ppc64_elf (gent->owner))
9410 abort ();
9411
9412 allocate_got (h, info, gent);
9413 }
9414
9415 if (eh->dyn_relocs == NULL
9416 || (!htab->elf.dynamic_sections_created
9417 && h->type != STT_GNU_IFUNC))
9418 return TRUE;
9419
9420 /* In the shared -Bsymbolic case, discard space allocated for
9421 dynamic pc-relative relocs against symbols which turn out to be
9422 defined in regular objects. For the normal shared case, discard
9423 space for relocs that have become local due to symbol visibility
9424 changes. */
9425
9426 if (info->shared)
9427 {
9428 /* Relocs that use pc_count are those that appear on a call insn,
9429 or certain REL relocs (see must_be_dyn_reloc) that can be
9430 generated via assembly. We want calls to protected symbols to
9431 resolve directly to the function rather than going via the plt.
9432 If people want function pointer comparisons to work as expected
9433 then they should avoid writing weird assembly. */
9434 if (SYMBOL_CALLS_LOCAL (info, h))
9435 {
9436 struct elf_dyn_relocs **pp;
9437
9438 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
9439 {
9440 p->count -= p->pc_count;
9441 p->pc_count = 0;
9442 if (p->count == 0)
9443 *pp = p->next;
9444 else
9445 pp = &p->next;
9446 }
9447 }
9448
9449 /* Also discard relocs on undefined weak syms with non-default
9450 visibility. */
9451 if (eh->dyn_relocs != NULL
9452 && h->root.type == bfd_link_hash_undefweak)
9453 {
9454 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
9455 eh->dyn_relocs = NULL;
9456
9457 /* Make sure this symbol is output as a dynamic symbol.
9458 Undefined weak syms won't yet be marked as dynamic. */
9459 else if (h->dynindx == -1
9460 && !h->forced_local)
9461 {
9462 if (! bfd_elf_link_record_dynamic_symbol (info, h))
9463 return FALSE;
9464 }
9465 }
9466 }
9467 else if (h->type == STT_GNU_IFUNC)
9468 {
9469 if (!h->non_got_ref)
9470 eh->dyn_relocs = NULL;
9471 }
9472 else if (ELIMINATE_COPY_RELOCS)
9473 {
9474 /* For the non-shared case, discard space for relocs against
9475 symbols which turn out to need copy relocs or are not
9476 dynamic. */
9477
9478 if (!h->non_got_ref
9479 && !h->def_regular)
9480 {
9481 /* Make sure this symbol is output as a dynamic symbol.
9482 Undefined weak syms won't yet be marked as dynamic. */
9483 if (h->dynindx == -1
9484 && !h->forced_local)
9485 {
9486 if (! bfd_elf_link_record_dynamic_symbol (info, h))
9487 return FALSE;
9488 }
9489
9490 /* If that succeeded, we know we'll be keeping all the
9491 relocs. */
9492 if (h->dynindx != -1)
9493 goto keep;
9494 }
9495
9496 eh->dyn_relocs = NULL;
9497
9498 keep: ;
9499 }
9500
9501 /* Finally, allocate space. */
9502 for (p = eh->dyn_relocs; p != NULL; p = p->next)
9503 {
9504 asection *sreloc = elf_section_data (p->sec)->sreloc;
9505 if (eh->elf.type == STT_GNU_IFUNC)
9506 sreloc = htab->elf.irelplt;
9507 sreloc->size += p->count * sizeof (Elf64_External_Rela);
9508 }
9509
9510 return TRUE;
9511 }
9512
9513 /* Called via elf_link_hash_traverse from ppc64_elf_size_dynamic_sections
9514 to set up space for global entry stubs. These are put in glink,
9515 after the branch table. */
9516
9517 static bfd_boolean
9518 size_global_entry_stubs (struct elf_link_hash_entry *h, void *inf)
9519 {
9520 struct bfd_link_info *info;
9521 struct ppc_link_hash_table *htab;
9522 struct plt_entry *pent;
9523 asection *s;
9524
9525 if (h->root.type == bfd_link_hash_indirect)
9526 return TRUE;
9527
9528 if (!h->pointer_equality_needed)
9529 return TRUE;
9530
9531 if (h->def_regular)
9532 return TRUE;
9533
9534 info = inf;
9535 htab = ppc_hash_table (info);
9536 if (htab == NULL)
9537 return FALSE;
9538
9539 s = htab->glink;
9540 for (pent = h->plt.plist; pent != NULL; pent = pent->next)
9541 if (pent->plt.offset != (bfd_vma) -1
9542 && pent->addend == 0)
9543 {
9544 /* For ELFv2, if this symbol is not defined in a regular file
9545 and we are not generating a shared library or pie, then we
9546 need to define the symbol in the executable on a call stub.
9547 This is to avoid text relocations. */
9548 s->size = (s->size + 15) & -16;
9549 h->root.u.def.section = s;
9550 h->root.u.def.value = s->size;
9551 s->size += 16;
9552 break;
9553 }
9554 return TRUE;
9555 }
9556
9557 /* Set DF_TEXTREL if we find any dynamic relocs that apply to
9558 read-only sections. */
9559
9560 static bfd_boolean
9561 maybe_set_textrel (struct elf_link_hash_entry *h, void *info)
9562 {
9563 if (h->root.type == bfd_link_hash_indirect)
9564 return TRUE;
9565
9566 if (readonly_dynrelocs (h))
9567 {
9568 ((struct bfd_link_info *) info)->flags |= DF_TEXTREL;
9569
9570 /* Not an error, just cut short the traversal. */
9571 return FALSE;
9572 }
9573 return TRUE;
9574 }
9575
9576 /* Set the sizes of the dynamic sections. */
9577
9578 static bfd_boolean
9579 ppc64_elf_size_dynamic_sections (bfd *output_bfd,
9580 struct bfd_link_info *info)
9581 {
9582 struct ppc_link_hash_table *htab;
9583 bfd *dynobj;
9584 asection *s;
9585 bfd_boolean relocs;
9586 bfd *ibfd;
9587 struct got_entry *first_tlsld;
9588
9589 htab = ppc_hash_table (info);
9590 if (htab == NULL)
9591 return FALSE;
9592
9593 dynobj = htab->elf.dynobj;
9594 if (dynobj == NULL)
9595 abort ();
9596
9597 if (htab->elf.dynamic_sections_created)
9598 {
9599 /* Set the contents of the .interp section to the interpreter. */
9600 if (info->executable)
9601 {
9602 s = bfd_get_linker_section (dynobj, ".interp");
9603 if (s == NULL)
9604 abort ();
9605 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
9606 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
9607 }
9608 }
9609
9610 /* Set up .got offsets for local syms, and space for local dynamic
9611 relocs. */
9612 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
9613 {
9614 struct got_entry **lgot_ents;
9615 struct got_entry **end_lgot_ents;
9616 struct plt_entry **local_plt;
9617 struct plt_entry **end_local_plt;
9618 unsigned char *lgot_masks;
9619 bfd_size_type locsymcount;
9620 Elf_Internal_Shdr *symtab_hdr;
9621
9622 if (!is_ppc64_elf (ibfd))
9623 continue;
9624
9625 for (s = ibfd->sections; s != NULL; s = s->next)
9626 {
9627 struct ppc_dyn_relocs *p;
9628
9629 for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
9630 {
9631 if (!bfd_is_abs_section (p->sec)
9632 && bfd_is_abs_section (p->sec->output_section))
9633 {
9634 /* Input section has been discarded, either because
9635 it is a copy of a linkonce section or due to
9636 linker script /DISCARD/, so we'll be discarding
9637 the relocs too. */
9638 }
9639 else if (p->count != 0)
9640 {
9641 asection *srel = elf_section_data (p->sec)->sreloc;
9642 if (p->ifunc)
9643 srel = htab->elf.irelplt;
9644 srel->size += p->count * sizeof (Elf64_External_Rela);
9645 if ((p->sec->output_section->flags & SEC_READONLY) != 0)
9646 info->flags |= DF_TEXTREL;
9647 }
9648 }
9649 }
9650
9651 lgot_ents = elf_local_got_ents (ibfd);
9652 if (!lgot_ents)
9653 continue;
9654
9655 symtab_hdr = &elf_symtab_hdr (ibfd);
9656 locsymcount = symtab_hdr->sh_info;
9657 end_lgot_ents = lgot_ents + locsymcount;
9658 local_plt = (struct plt_entry **) end_lgot_ents;
9659 end_local_plt = local_plt + locsymcount;
9660 lgot_masks = (unsigned char *) end_local_plt;
9661 s = ppc64_elf_tdata (ibfd)->got;
9662 for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
9663 {
9664 struct got_entry **pent, *ent;
9665
9666 pent = lgot_ents;
9667 while ((ent = *pent) != NULL)
9668 if (ent->got.refcount > 0)
9669 {
9670 if ((ent->tls_type & *lgot_masks & TLS_LD) != 0)
9671 {
9672 ppc64_tlsld_got (ibfd)->got.refcount += 1;
9673 *pent = ent->next;
9674 }
9675 else
9676 {
9677 unsigned int ent_size = 8;
9678 unsigned int rel_size = sizeof (Elf64_External_Rela);
9679
9680 ent->got.offset = s->size;
9681 if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
9682 {
9683 ent_size *= 2;
9684 rel_size *= 2;
9685 }
9686 s->size += ent_size;
9687 if ((*lgot_masks & PLT_IFUNC) != 0)
9688 {
9689 htab->elf.irelplt->size += rel_size;
9690 htab->got_reli_size += rel_size;
9691 }
9692 else if (info->shared)
9693 {
9694 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
9695 srel->size += rel_size;
9696 }
9697 pent = &ent->next;
9698 }
9699 }
9700 else
9701 *pent = ent->next;
9702 }
9703
9704 /* Allocate space for calls to local STT_GNU_IFUNC syms in .iplt. */
9705 for (; local_plt < end_local_plt; ++local_plt)
9706 {
9707 struct plt_entry *ent;
9708
9709 for (ent = *local_plt; ent != NULL; ent = ent->next)
9710 if (ent->plt.refcount > 0)
9711 {
9712 s = htab->elf.iplt;
9713 ent->plt.offset = s->size;
9714 s->size += PLT_ENTRY_SIZE (htab);
9715
9716 htab->elf.irelplt->size += sizeof (Elf64_External_Rela);
9717 }
9718 else
9719 ent->plt.offset = (bfd_vma) -1;
9720 }
9721 }
9722
9723 /* Allocate global sym .plt and .got entries, and space for global
9724 sym dynamic relocs. */
9725 elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, info);
9726 /* Stash the end of glink branch table. */
9727 if (htab->glink != NULL)
9728 htab->glink->rawsize = htab->glink->size;
9729
9730 if (!htab->opd_abi && !info->shared)
9731 elf_link_hash_traverse (&htab->elf, size_global_entry_stubs, info);
9732
9733 first_tlsld = NULL;
9734 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
9735 {
9736 struct got_entry *ent;
9737
9738 if (!is_ppc64_elf (ibfd))
9739 continue;
9740
9741 ent = ppc64_tlsld_got (ibfd);
9742 if (ent->got.refcount > 0)
9743 {
9744 if (!htab->do_multi_toc && first_tlsld != NULL)
9745 {
9746 ent->is_indirect = TRUE;
9747 ent->got.ent = first_tlsld;
9748 }
9749 else
9750 {
9751 if (first_tlsld == NULL)
9752 first_tlsld = ent;
9753 s = ppc64_elf_tdata (ibfd)->got;
9754 ent->got.offset = s->size;
9755 ent->owner = ibfd;
9756 s->size += 16;
9757 if (info->shared)
9758 {
9759 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
9760 srel->size += sizeof (Elf64_External_Rela);
9761 }
9762 }
9763 }
9764 else
9765 ent->got.offset = (bfd_vma) -1;
9766 }
9767
9768 /* We now have determined the sizes of the various dynamic sections.
9769 Allocate memory for them. */
9770 relocs = FALSE;
9771 for (s = dynobj->sections; s != NULL; s = s->next)
9772 {
9773 if ((s->flags & SEC_LINKER_CREATED) == 0)
9774 continue;
9775
9776 if (s == htab->brlt || s == htab->relbrlt)
9777 /* These haven't been allocated yet; don't strip. */
9778 continue;
9779 else if (s == htab->elf.sgot
9780 || s == htab->elf.splt
9781 || s == htab->elf.iplt
9782 || s == htab->glink
9783 || s == htab->dynbss)
9784 {
9785 /* Strip this section if we don't need it; see the
9786 comment below. */
9787 }
9788 else if (s == htab->glink_eh_frame)
9789 {
9790 if (!bfd_is_abs_section (s->output_section))
9791 /* Not sized yet. */
9792 continue;
9793 }
9794 else if (CONST_STRNEQ (s->name, ".rela"))
9795 {
9796 if (s->size != 0)
9797 {
9798 if (s != htab->elf.srelplt)
9799 relocs = TRUE;
9800
9801 /* We use the reloc_count field as a counter if we need
9802 to copy relocs into the output file. */
9803 s->reloc_count = 0;
9804 }
9805 }
9806 else
9807 {
9808 /* It's not one of our sections, so don't allocate space. */
9809 continue;
9810 }
9811
9812 if (s->size == 0)
9813 {
9814 /* If we don't need this section, strip it from the
9815 output file. This is mostly to handle .rela.bss and
9816 .rela.plt. We must create both sections in
9817 create_dynamic_sections, because they must be created
9818 before the linker maps input sections to output
9819 sections. The linker does that before
9820 adjust_dynamic_symbol is called, and it is that
9821 function which decides whether anything needs to go
9822 into these sections. */
9823 s->flags |= SEC_EXCLUDE;
9824 continue;
9825 }
9826
9827 if ((s->flags & SEC_HAS_CONTENTS) == 0)
9828 continue;
9829
9830 /* Allocate memory for the section contents. We use bfd_zalloc
9831 here in case unused entries are not reclaimed before the
9832 section's contents are written out. This should not happen,
9833 but this way if it does we get a R_PPC64_NONE reloc in .rela
9834 sections instead of garbage.
9835 We also rely on the section contents being zero when writing
9836 the GOT. */
9837 s->contents = bfd_zalloc (dynobj, s->size);
9838 if (s->contents == NULL)
9839 return FALSE;
9840 }
9841
9842 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
9843 {
9844 if (!is_ppc64_elf (ibfd))
9845 continue;
9846
9847 s = ppc64_elf_tdata (ibfd)->got;
9848 if (s != NULL && s != htab->elf.sgot)
9849 {
9850 if (s->size == 0)
9851 s->flags |= SEC_EXCLUDE;
9852 else
9853 {
9854 s->contents = bfd_zalloc (ibfd, s->size);
9855 if (s->contents == NULL)
9856 return FALSE;
9857 }
9858 }
9859 s = ppc64_elf_tdata (ibfd)->relgot;
9860 if (s != NULL)
9861 {
9862 if (s->size == 0)
9863 s->flags |= SEC_EXCLUDE;
9864 else
9865 {
9866 s->contents = bfd_zalloc (ibfd, s->size);
9867 if (s->contents == NULL)
9868 return FALSE;
9869 relocs = TRUE;
9870 s->reloc_count = 0;
9871 }
9872 }
9873 }
9874
9875 if (htab->elf.dynamic_sections_created)
9876 {
9877 bfd_boolean tls_opt;
9878
9879 /* Add some entries to the .dynamic section. We fill in the
9880 values later, in ppc64_elf_finish_dynamic_sections, but we
9881 must add the entries now so that we get the correct size for
9882 the .dynamic section. The DT_DEBUG entry is filled in by the
9883 dynamic linker and used by the debugger. */
9884 #define add_dynamic_entry(TAG, VAL) \
9885 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
9886
9887 if (info->executable)
9888 {
9889 if (!add_dynamic_entry (DT_DEBUG, 0))
9890 return FALSE;
9891 }
9892
9893 if (htab->elf.splt != NULL && htab->elf.splt->size != 0)
9894 {
9895 if (!add_dynamic_entry (DT_PLTGOT, 0)
9896 || !add_dynamic_entry (DT_PLTRELSZ, 0)
9897 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
9898 || !add_dynamic_entry (DT_JMPREL, 0)
9899 || !add_dynamic_entry (DT_PPC64_GLINK, 0))
9900 return FALSE;
9901 }
9902
9903 if (NO_OPD_RELOCS && abiversion (output_bfd) <= 1)
9904 {
9905 if (!add_dynamic_entry (DT_PPC64_OPD, 0)
9906 || !add_dynamic_entry (DT_PPC64_OPDSZ, 0))
9907 return FALSE;
9908 }
9909
9910 tls_opt = (!htab->no_tls_get_addr_opt
9911 && htab->tls_get_addr_fd != NULL
9912 && htab->tls_get_addr_fd->elf.plt.plist != NULL);
9913 if (tls_opt || !htab->opd_abi)
9914 {
9915 if (!add_dynamic_entry (DT_PPC64_OPT, tls_opt ? PPC64_OPT_TLS : 0))
9916 return FALSE;
9917 }
9918
9919 if (relocs)
9920 {
9921 if (!add_dynamic_entry (DT_RELA, 0)
9922 || !add_dynamic_entry (DT_RELASZ, 0)
9923 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
9924 return FALSE;
9925
9926 /* If any dynamic relocs apply to a read-only section,
9927 then we need a DT_TEXTREL entry. */
9928 if ((info->flags & DF_TEXTREL) == 0)
9929 elf_link_hash_traverse (&htab->elf, maybe_set_textrel, info);
9930
9931 if ((info->flags & DF_TEXTREL) != 0)
9932 {
9933 if (!add_dynamic_entry (DT_TEXTREL, 0))
9934 return FALSE;
9935 }
9936 }
9937 }
9938 #undef add_dynamic_entry
9939
9940 return TRUE;
9941 }
9942
9943 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
9944
9945 static bfd_boolean
9946 ppc64_elf_hash_symbol (struct elf_link_hash_entry *h)
9947 {
9948 if (h->plt.plist != NULL
9949 && !h->def_regular
9950 && !h->pointer_equality_needed)
9951 return FALSE;
9952
9953 return _bfd_elf_hash_symbol (h);
9954 }
9955
9956 /* Determine the type of stub needed, if any, for a call. */
9957
9958 static inline enum ppc_stub_type
9959 ppc_type_of_stub (asection *input_sec,
9960 const Elf_Internal_Rela *rel,
9961 struct ppc_link_hash_entry **hash,
9962 struct plt_entry **plt_ent,
9963 bfd_vma destination,
9964 unsigned long local_off)
9965 {
9966 struct ppc_link_hash_entry *h = *hash;
9967 bfd_vma location;
9968 bfd_vma branch_offset;
9969 bfd_vma max_branch_offset;
9970 enum elf_ppc64_reloc_type r_type;
9971
9972 if (h != NULL)
9973 {
9974 struct plt_entry *ent;
9975 struct ppc_link_hash_entry *fdh = h;
9976 if (h->oh != NULL
9977 && h->oh->is_func_descriptor)
9978 {
9979 fdh = ppc_follow_link (h->oh);
9980 *hash = fdh;
9981 }
9982
9983 for (ent = fdh->elf.plt.plist; ent != NULL; ent = ent->next)
9984 if (ent->addend == rel->r_addend
9985 && ent->plt.offset != (bfd_vma) -1)
9986 {
9987 *plt_ent = ent;
9988 return ppc_stub_plt_call;
9989 }
9990
9991 /* Here, we know we don't have a plt entry. If we don't have a
9992 either a defined function descriptor or a defined entry symbol
9993 in a regular object file, then it is pointless trying to make
9994 any other type of stub. */
9995 if (!is_static_defined (&fdh->elf)
9996 && !is_static_defined (&h->elf))
9997 return ppc_stub_none;
9998 }
9999 else if (elf_local_got_ents (input_sec->owner) != NULL)
10000 {
10001 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (input_sec->owner);
10002 struct plt_entry **local_plt = (struct plt_entry **)
10003 elf_local_got_ents (input_sec->owner) + symtab_hdr->sh_info;
10004 unsigned long r_symndx = ELF64_R_SYM (rel->r_info);
10005
10006 if (local_plt[r_symndx] != NULL)
10007 {
10008 struct plt_entry *ent;
10009
10010 for (ent = local_plt[r_symndx]; ent != NULL; ent = ent->next)
10011 if (ent->addend == rel->r_addend
10012 && ent->plt.offset != (bfd_vma) -1)
10013 {
10014 *plt_ent = ent;
10015 return ppc_stub_plt_call;
10016 }
10017 }
10018 }
10019
10020 /* Determine where the call point is. */
10021 location = (input_sec->output_offset
10022 + input_sec->output_section->vma
10023 + rel->r_offset);
10024
10025 branch_offset = destination - location;
10026 r_type = ELF64_R_TYPE (rel->r_info);
10027
10028 /* Determine if a long branch stub is needed. */
10029 max_branch_offset = 1 << 25;
10030 if (r_type != R_PPC64_REL24)
10031 max_branch_offset = 1 << 15;
10032
10033 if (branch_offset + max_branch_offset >= 2 * max_branch_offset - local_off)
10034 /* We need a stub. Figure out whether a long_branch or plt_branch
10035 is needed later. */
10036 return ppc_stub_long_branch;
10037
10038 return ppc_stub_none;
10039 }
10040
10041 /* With power7 weakly ordered memory model, it is possible for ld.so
10042 to update a plt entry in one thread and have another thread see a
10043 stale zero toc entry. To avoid this we need some sort of acquire
10044 barrier in the call stub. One solution is to make the load of the
10045 toc word seem to appear to depend on the load of the function entry
10046 word. Another solution is to test for r2 being zero, and branch to
10047 the appropriate glink entry if so.
10048
10049 . fake dep barrier compare
10050 . ld 12,xxx(2) ld 12,xxx(2)
10051 . mtctr 12 mtctr 12
10052 . xor 11,12,12 ld 2,xxx+8(2)
10053 . add 2,2,11 cmpldi 2,0
10054 . ld 2,xxx+8(2) bnectr+
10055 . bctr b <glink_entry>
10056
10057 The solution involving the compare turns out to be faster, so
10058 that's what we use unless the branch won't reach. */
10059
10060 #define ALWAYS_USE_FAKE_DEP 0
10061 #define ALWAYS_EMIT_R2SAVE 0
10062
10063 #define PPC_LO(v) ((v) & 0xffff)
10064 #define PPC_HI(v) (((v) >> 16) & 0xffff)
10065 #define PPC_HA(v) PPC_HI ((v) + 0x8000)
10066
10067 static inline unsigned int
10068 plt_stub_size (struct ppc_link_hash_table *htab,
10069 struct ppc_stub_hash_entry *stub_entry,
10070 bfd_vma off)
10071 {
10072 unsigned size = 12;
10073
10074 if (ALWAYS_EMIT_R2SAVE
10075 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10076 size += 4;
10077 if (PPC_HA (off) != 0)
10078 size += 4;
10079 if (htab->opd_abi)
10080 {
10081 size += 4;
10082 if (htab->plt_static_chain)
10083 size += 4;
10084 if (htab->plt_thread_safe)
10085 size += 8;
10086 if (PPC_HA (off + 8 + 8 * htab->plt_static_chain) != PPC_HA (off))
10087 size += 4;
10088 }
10089 if (stub_entry->h != NULL
10090 && (stub_entry->h == htab->tls_get_addr_fd
10091 || stub_entry->h == htab->tls_get_addr)
10092 && !htab->no_tls_get_addr_opt)
10093 size += 13 * 4;
10094 return size;
10095 }
10096
10097 /* If this stub would cross fewer 2**plt_stub_align boundaries if we align,
10098 then return the padding needed to do so. */
10099 static inline unsigned int
10100 plt_stub_pad (struct ppc_link_hash_table *htab,
10101 struct ppc_stub_hash_entry *stub_entry,
10102 bfd_vma plt_off)
10103 {
10104 int stub_align = 1 << htab->plt_stub_align;
10105 unsigned stub_size = plt_stub_size (htab, stub_entry, plt_off);
10106 bfd_vma stub_off = stub_entry->stub_sec->size;
10107
10108 if (((stub_off + stub_size - 1) & -stub_align) - (stub_off & -stub_align)
10109 > (stub_size & -stub_align))
10110 return stub_align - (stub_off & (stub_align - 1));
10111 return 0;
10112 }
10113
10114 /* Build a .plt call stub. */
10115
10116 static inline bfd_byte *
10117 build_plt_stub (struct ppc_link_hash_table *htab,
10118 struct ppc_stub_hash_entry *stub_entry,
10119 bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
10120 {
10121 bfd *obfd = htab->stub_bfd;
10122 bfd_boolean plt_load_toc = htab->opd_abi;
10123 bfd_boolean plt_static_chain = htab->plt_static_chain;
10124 bfd_boolean plt_thread_safe = htab->plt_thread_safe;
10125 bfd_boolean use_fake_dep = plt_thread_safe;
10126 bfd_vma cmp_branch_off = 0;
10127
10128 if (!ALWAYS_USE_FAKE_DEP
10129 && plt_load_toc
10130 && plt_thread_safe
10131 && !(stub_entry->h != NULL
10132 && (stub_entry->h == htab->tls_get_addr_fd
10133 || stub_entry->h == htab->tls_get_addr)
10134 && !htab->no_tls_get_addr_opt))
10135 {
10136 bfd_vma pltoff = stub_entry->plt_ent->plt.offset & ~1;
10137 bfd_vma pltindex = ((pltoff - PLT_INITIAL_ENTRY_SIZE (htab))
10138 / PLT_ENTRY_SIZE (htab));
10139 bfd_vma glinkoff = GLINK_CALL_STUB_SIZE + pltindex * 8;
10140 bfd_vma to, from;
10141
10142 if (pltindex > 32768)
10143 glinkoff += (pltindex - 32768) * 4;
10144 to = (glinkoff
10145 + htab->glink->output_offset
10146 + htab->glink->output_section->vma);
10147 from = (p - stub_entry->stub_sec->contents
10148 + 4 * (ALWAYS_EMIT_R2SAVE
10149 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10150 + 4 * (PPC_HA (offset) != 0)
10151 + 4 * (PPC_HA (offset + 8 + 8 * plt_static_chain)
10152 != PPC_HA (offset))
10153 + 4 * (plt_static_chain != 0)
10154 + 20
10155 + stub_entry->stub_sec->output_offset
10156 + stub_entry->stub_sec->output_section->vma);
10157 cmp_branch_off = to - from;
10158 use_fake_dep = cmp_branch_off + (1 << 25) >= (1 << 26);
10159 }
10160
10161 if (PPC_HA (offset) != 0)
10162 {
10163 if (r != NULL)
10164 {
10165 if (ALWAYS_EMIT_R2SAVE
10166 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10167 r[0].r_offset += 4;
10168 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
10169 r[1].r_offset = r[0].r_offset + 4;
10170 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10171 r[1].r_addend = r[0].r_addend;
10172 if (plt_load_toc)
10173 {
10174 if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10175 {
10176 r[2].r_offset = r[1].r_offset + 4;
10177 r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO);
10178 r[2].r_addend = r[0].r_addend;
10179 }
10180 else
10181 {
10182 r[2].r_offset = r[1].r_offset + 8 + 8 * use_fake_dep;
10183 r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10184 r[2].r_addend = r[0].r_addend + 8;
10185 if (plt_static_chain)
10186 {
10187 r[3].r_offset = r[2].r_offset + 4;
10188 r[3].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10189 r[3].r_addend = r[0].r_addend + 16;
10190 }
10191 }
10192 }
10193 }
10194 if (ALWAYS_EMIT_R2SAVE
10195 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10196 bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p), p += 4;
10197 bfd_put_32 (obfd, ADDIS_R11_R2 | PPC_HA (offset), p), p += 4;
10198 bfd_put_32 (obfd, LD_R12_0R11 | PPC_LO (offset), p), p += 4;
10199 if (plt_load_toc
10200 && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10201 {
10202 bfd_put_32 (obfd, ADDI_R11_R11 | PPC_LO (offset), p), p += 4;
10203 offset = 0;
10204 }
10205 bfd_put_32 (obfd, MTCTR_R12, p), p += 4;
10206 if (plt_load_toc)
10207 {
10208 if (use_fake_dep)
10209 {
10210 bfd_put_32 (obfd, XOR_R2_R12_R12, p), p += 4;
10211 bfd_put_32 (obfd, ADD_R11_R11_R2, p), p += 4;
10212 }
10213 bfd_put_32 (obfd, LD_R2_0R11 | PPC_LO (offset + 8), p), p += 4;
10214 if (plt_static_chain)
10215 bfd_put_32 (obfd, LD_R11_0R11 | PPC_LO (offset + 16), p), p += 4;
10216 }
10217 }
10218 else
10219 {
10220 if (r != NULL)
10221 {
10222 if (ALWAYS_EMIT_R2SAVE
10223 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10224 r[0].r_offset += 4;
10225 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10226 if (plt_load_toc)
10227 {
10228 if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10229 {
10230 r[1].r_offset = r[0].r_offset + 4;
10231 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16);
10232 r[1].r_addend = r[0].r_addend;
10233 }
10234 else
10235 {
10236 r[1].r_offset = r[0].r_offset + 8 + 8 * use_fake_dep;
10237 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10238 r[1].r_addend = r[0].r_addend + 8 + 8 * plt_static_chain;
10239 if (plt_static_chain)
10240 {
10241 r[2].r_offset = r[1].r_offset + 4;
10242 r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10243 r[2].r_addend = r[0].r_addend + 8;
10244 }
10245 }
10246 }
10247 }
10248 if (ALWAYS_EMIT_R2SAVE
10249 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10250 bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p), p += 4;
10251 bfd_put_32 (obfd, LD_R12_0R2 | PPC_LO (offset), p), p += 4;
10252 if (plt_load_toc
10253 && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10254 {
10255 bfd_put_32 (obfd, ADDI_R2_R2 | PPC_LO (offset), p), p += 4;
10256 offset = 0;
10257 }
10258 bfd_put_32 (obfd, MTCTR_R12, p), p += 4;
10259 if (plt_load_toc)
10260 {
10261 if (use_fake_dep)
10262 {
10263 bfd_put_32 (obfd, XOR_R11_R12_R12, p), p += 4;
10264 bfd_put_32 (obfd, ADD_R2_R2_R11, p), p += 4;
10265 }
10266 if (plt_static_chain)
10267 bfd_put_32 (obfd, LD_R11_0R2 | PPC_LO (offset + 16), p), p += 4;
10268 bfd_put_32 (obfd, LD_R2_0R2 | PPC_LO (offset + 8), p), p += 4;
10269 }
10270 }
10271 if (plt_load_toc && plt_thread_safe && !use_fake_dep)
10272 {
10273 bfd_put_32 (obfd, CMPLDI_R2_0, p), p += 4;
10274 bfd_put_32 (obfd, BNECTR_P4, p), p += 4;
10275 bfd_put_32 (obfd, B_DOT | (cmp_branch_off & 0x3fffffc), p), p += 4;
10276 }
10277 else
10278 bfd_put_32 (obfd, BCTR, p), p += 4;
10279 return p;
10280 }
10281
10282 /* Build a special .plt call stub for __tls_get_addr. */
10283
10284 #define LD_R11_0R3 0xe9630000
10285 #define LD_R12_0R3 0xe9830000
10286 #define MR_R0_R3 0x7c601b78
10287 #define CMPDI_R11_0 0x2c2b0000
10288 #define ADD_R3_R12_R13 0x7c6c6a14
10289 #define BEQLR 0x4d820020
10290 #define MR_R3_R0 0x7c030378
10291 #define STD_R11_0R1 0xf9610000
10292 #define BCTRL 0x4e800421
10293 #define LD_R11_0R1 0xe9610000
10294 #define MTLR_R11 0x7d6803a6
10295
10296 static inline bfd_byte *
10297 build_tls_get_addr_stub (struct ppc_link_hash_table *htab,
10298 struct ppc_stub_hash_entry *stub_entry,
10299 bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
10300 {
10301 bfd *obfd = htab->stub_bfd;
10302
10303 bfd_put_32 (obfd, LD_R11_0R3 + 0, p), p += 4;
10304 bfd_put_32 (obfd, LD_R12_0R3 + 8, p), p += 4;
10305 bfd_put_32 (obfd, MR_R0_R3, p), p += 4;
10306 bfd_put_32 (obfd, CMPDI_R11_0, p), p += 4;
10307 bfd_put_32 (obfd, ADD_R3_R12_R13, p), p += 4;
10308 bfd_put_32 (obfd, BEQLR, p), p += 4;
10309 bfd_put_32 (obfd, MR_R3_R0, p), p += 4;
10310 bfd_put_32 (obfd, MFLR_R11, p), p += 4;
10311 bfd_put_32 (obfd, STD_R11_0R1 + STK_LINKER (htab), p), p += 4;
10312
10313 if (r != NULL)
10314 r[0].r_offset += 9 * 4;
10315 p = build_plt_stub (htab, stub_entry, p, offset, r);
10316 bfd_put_32 (obfd, BCTRL, p - 4);
10317
10318 bfd_put_32 (obfd, LD_R11_0R1 + STK_LINKER (htab), p), p += 4;
10319 bfd_put_32 (obfd, LD_R2_0R1 + STK_TOC (htab), p), p += 4;
10320 bfd_put_32 (obfd, MTLR_R11, p), p += 4;
10321 bfd_put_32 (obfd, BLR, p), p += 4;
10322
10323 return p;
10324 }
10325
10326 static Elf_Internal_Rela *
10327 get_relocs (asection *sec, int count)
10328 {
10329 Elf_Internal_Rela *relocs;
10330 struct bfd_elf_section_data *elfsec_data;
10331
10332 elfsec_data = elf_section_data (sec);
10333 relocs = elfsec_data->relocs;
10334 if (relocs == NULL)
10335 {
10336 bfd_size_type relsize;
10337 relsize = sec->reloc_count * sizeof (*relocs);
10338 relocs = bfd_alloc (sec->owner, relsize);
10339 if (relocs == NULL)
10340 return NULL;
10341 elfsec_data->relocs = relocs;
10342 elfsec_data->rela.hdr = bfd_zalloc (sec->owner,
10343 sizeof (Elf_Internal_Shdr));
10344 if (elfsec_data->rela.hdr == NULL)
10345 return NULL;
10346 elfsec_data->rela.hdr->sh_size = (sec->reloc_count
10347 * sizeof (Elf64_External_Rela));
10348 elfsec_data->rela.hdr->sh_entsize = sizeof (Elf64_External_Rela);
10349 sec->reloc_count = 0;
10350 }
10351 relocs += sec->reloc_count;
10352 sec->reloc_count += count;
10353 return relocs;
10354 }
10355
10356 static bfd_vma
10357 get_r2off (struct bfd_link_info *info,
10358 struct ppc_stub_hash_entry *stub_entry)
10359 {
10360 struct ppc_link_hash_table *htab = ppc_hash_table (info);
10361 bfd_vma r2off = htab->stub_group[stub_entry->target_section->id].toc_off;
10362
10363 if (r2off == 0)
10364 {
10365 /* Support linking -R objects. Get the toc pointer from the
10366 opd entry. */
10367 char buf[8];
10368 if (!htab->opd_abi)
10369 return r2off;
10370 asection *opd = stub_entry->h->elf.root.u.def.section;
10371 bfd_vma opd_off = stub_entry->h->elf.root.u.def.value;
10372
10373 if (strcmp (opd->name, ".opd") != 0
10374 || opd->reloc_count != 0)
10375 {
10376 info->callbacks->einfo (_("%P: cannot find opd entry toc for `%T'\n"),
10377 stub_entry->h->elf.root.root.string);
10378 bfd_set_error (bfd_error_bad_value);
10379 return 0;
10380 }
10381 if (!bfd_get_section_contents (opd->owner, opd, buf, opd_off + 8, 8))
10382 return 0;
10383 r2off = bfd_get_64 (opd->owner, buf);
10384 r2off -= elf_gp (info->output_bfd);
10385 }
10386 r2off -= htab->stub_group[stub_entry->id_sec->id].toc_off;
10387 return r2off;
10388 }
10389
10390 static bfd_boolean
10391 ppc_build_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
10392 {
10393 struct ppc_stub_hash_entry *stub_entry;
10394 struct ppc_branch_hash_entry *br_entry;
10395 struct bfd_link_info *info;
10396 struct ppc_link_hash_table *htab;
10397 bfd_byte *loc;
10398 bfd_byte *p;
10399 bfd_vma dest, off;
10400 int size;
10401 Elf_Internal_Rela *r;
10402 asection *plt;
10403
10404 /* Massage our args to the form they really have. */
10405 stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
10406 info = in_arg;
10407
10408 htab = ppc_hash_table (info);
10409 if (htab == NULL)
10410 return FALSE;
10411
10412 /* Make a note of the offset within the stubs for this entry. */
10413 stub_entry->stub_offset = stub_entry->stub_sec->size;
10414 loc = stub_entry->stub_sec->contents + stub_entry->stub_offset;
10415
10416 htab->stub_count[stub_entry->stub_type - 1] += 1;
10417 switch (stub_entry->stub_type)
10418 {
10419 case ppc_stub_long_branch:
10420 case ppc_stub_long_branch_r2off:
10421 /* Branches are relative. This is where we are going to. */
10422 dest = (stub_entry->target_value
10423 + stub_entry->target_section->output_offset
10424 + stub_entry->target_section->output_section->vma);
10425 dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
10426 off = dest;
10427
10428 /* And this is where we are coming from. */
10429 off -= (stub_entry->stub_offset
10430 + stub_entry->stub_sec->output_offset
10431 + stub_entry->stub_sec->output_section->vma);
10432
10433 size = 4;
10434 if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
10435 {
10436 bfd_vma r2off = get_r2off (info, stub_entry);
10437
10438 if (r2off == 0)
10439 {
10440 htab->stub_error = TRUE;
10441 return FALSE;
10442 }
10443 bfd_put_32 (htab->stub_bfd, STD_R2_0R1 + STK_TOC (htab), loc);
10444 loc += 4;
10445 size = 12;
10446 if (PPC_HA (r2off) != 0)
10447 {
10448 size = 16;
10449 bfd_put_32 (htab->stub_bfd, ADDIS_R2_R2 | PPC_HA (r2off), loc);
10450 loc += 4;
10451 }
10452 bfd_put_32 (htab->stub_bfd, ADDI_R2_R2 | PPC_LO (r2off), loc);
10453 loc += 4;
10454 off -= size - 4;
10455 }
10456 bfd_put_32 (htab->stub_bfd, B_DOT | (off & 0x3fffffc), loc);
10457
10458 if (off + (1 << 25) >= (bfd_vma) (1 << 26))
10459 {
10460 info->callbacks->einfo
10461 (_("%P: long branch stub `%s' offset overflow\n"),
10462 stub_entry->root.string);
10463 htab->stub_error = TRUE;
10464 return FALSE;
10465 }
10466
10467 if (info->emitrelocations)
10468 {
10469 r = get_relocs (stub_entry->stub_sec, 1);
10470 if (r == NULL)
10471 return FALSE;
10472 r->r_offset = loc - stub_entry->stub_sec->contents;
10473 r->r_info = ELF64_R_INFO (0, R_PPC64_REL24);
10474 r->r_addend = dest;
10475 if (stub_entry->h != NULL)
10476 {
10477 struct elf_link_hash_entry **hashes;
10478 unsigned long symndx;
10479 struct ppc_link_hash_entry *h;
10480
10481 hashes = elf_sym_hashes (htab->stub_bfd);
10482 if (hashes == NULL)
10483 {
10484 bfd_size_type hsize;
10485
10486 hsize = (htab->stub_globals + 1) * sizeof (*hashes);
10487 hashes = bfd_zalloc (htab->stub_bfd, hsize);
10488 if (hashes == NULL)
10489 return FALSE;
10490 elf_sym_hashes (htab->stub_bfd) = hashes;
10491 htab->stub_globals = 1;
10492 }
10493 symndx = htab->stub_globals++;
10494 h = stub_entry->h;
10495 hashes[symndx] = &h->elf;
10496 r->r_info = ELF64_R_INFO (symndx, R_PPC64_REL24);
10497 if (h->oh != NULL && h->oh->is_func)
10498 h = ppc_follow_link (h->oh);
10499 if (h->elf.root.u.def.section != stub_entry->target_section)
10500 /* H is an opd symbol. The addend must be zero. */
10501 r->r_addend = 0;
10502 else
10503 {
10504 off = (h->elf.root.u.def.value
10505 + h->elf.root.u.def.section->output_offset
10506 + h->elf.root.u.def.section->output_section->vma);
10507 r->r_addend -= off;
10508 }
10509 }
10510 }
10511 break;
10512
10513 case ppc_stub_plt_branch:
10514 case ppc_stub_plt_branch_r2off:
10515 br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
10516 stub_entry->root.string + 9,
10517 FALSE, FALSE);
10518 if (br_entry == NULL)
10519 {
10520 info->callbacks->einfo (_("%P: can't find branch stub `%s'\n"),
10521 stub_entry->root.string);
10522 htab->stub_error = TRUE;
10523 return FALSE;
10524 }
10525
10526 dest = (stub_entry->target_value
10527 + stub_entry->target_section->output_offset
10528 + stub_entry->target_section->output_section->vma);
10529 if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
10530 dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
10531
10532 bfd_put_64 (htab->brlt->owner, dest,
10533 htab->brlt->contents + br_entry->offset);
10534
10535 if (br_entry->iter == htab->stub_iteration)
10536 {
10537 br_entry->iter = 0;
10538
10539 if (htab->relbrlt != NULL)
10540 {
10541 /* Create a reloc for the branch lookup table entry. */
10542 Elf_Internal_Rela rela;
10543 bfd_byte *rl;
10544
10545 rela.r_offset = (br_entry->offset
10546 + htab->brlt->output_offset
10547 + htab->brlt->output_section->vma);
10548 rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
10549 rela.r_addend = dest;
10550
10551 rl = htab->relbrlt->contents;
10552 rl += (htab->relbrlt->reloc_count++
10553 * sizeof (Elf64_External_Rela));
10554 bfd_elf64_swap_reloca_out (htab->relbrlt->owner, &rela, rl);
10555 }
10556 else if (info->emitrelocations)
10557 {
10558 r = get_relocs (htab->brlt, 1);
10559 if (r == NULL)
10560 return FALSE;
10561 /* brlt, being SEC_LINKER_CREATED does not go through the
10562 normal reloc processing. Symbols and offsets are not
10563 translated from input file to output file form, so
10564 set up the offset per the output file. */
10565 r->r_offset = (br_entry->offset
10566 + htab->brlt->output_offset
10567 + htab->brlt->output_section->vma);
10568 r->r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
10569 r->r_addend = dest;
10570 }
10571 }
10572
10573 dest = (br_entry->offset
10574 + htab->brlt->output_offset
10575 + htab->brlt->output_section->vma);
10576
10577 off = (dest
10578 - elf_gp (htab->brlt->output_section->owner)
10579 - htab->stub_group[stub_entry->id_sec->id].toc_off);
10580
10581 if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
10582 {
10583 info->callbacks->einfo
10584 (_("%P: linkage table error against `%T'\n"),
10585 stub_entry->root.string);
10586 bfd_set_error (bfd_error_bad_value);
10587 htab->stub_error = TRUE;
10588 return FALSE;
10589 }
10590
10591 if (info->emitrelocations)
10592 {
10593 r = get_relocs (stub_entry->stub_sec, 1 + (PPC_HA (off) != 0));
10594 if (r == NULL)
10595 return FALSE;
10596 r[0].r_offset = loc - stub_entry->stub_sec->contents;
10597 if (bfd_big_endian (info->output_bfd))
10598 r[0].r_offset += 2;
10599 if (stub_entry->stub_type == ppc_stub_plt_branch_r2off)
10600 r[0].r_offset += 4;
10601 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10602 r[0].r_addend = dest;
10603 if (PPC_HA (off) != 0)
10604 {
10605 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
10606 r[1].r_offset = r[0].r_offset + 4;
10607 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10608 r[1].r_addend = r[0].r_addend;
10609 }
10610 }
10611
10612 if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
10613 {
10614 if (PPC_HA (off) != 0)
10615 {
10616 size = 16;
10617 bfd_put_32 (htab->stub_bfd, ADDIS_R11_R2 | PPC_HA (off), loc);
10618 loc += 4;
10619 bfd_put_32 (htab->stub_bfd, LD_R12_0R11 | PPC_LO (off), loc);
10620 }
10621 else
10622 {
10623 size = 12;
10624 bfd_put_32 (htab->stub_bfd, LD_R12_0R2 | PPC_LO (off), loc);
10625 }
10626 }
10627 else
10628 {
10629 bfd_vma r2off = get_r2off (info, stub_entry);
10630
10631 if (r2off == 0 && htab->opd_abi)
10632 {
10633 htab->stub_error = TRUE;
10634 return FALSE;
10635 }
10636
10637 bfd_put_32 (htab->stub_bfd, STD_R2_0R1 + STK_TOC (htab), loc);
10638 loc += 4;
10639 size = 16;
10640 if (PPC_HA (off) != 0)
10641 {
10642 size += 4;
10643 bfd_put_32 (htab->stub_bfd, ADDIS_R11_R2 | PPC_HA (off), loc);
10644 loc += 4;
10645 bfd_put_32 (htab->stub_bfd, LD_R12_0R11 | PPC_LO (off), loc);
10646 }
10647 else
10648 bfd_put_32 (htab->stub_bfd, LD_R12_0R2 | PPC_LO (off), loc);
10649
10650 if (PPC_HA (r2off) != 0)
10651 {
10652 size += 4;
10653 loc += 4;
10654 bfd_put_32 (htab->stub_bfd, ADDIS_R2_R2 | PPC_HA (r2off), loc);
10655 }
10656 if (PPC_LO (r2off) != 0)
10657 {
10658 size += 4;
10659 loc += 4;
10660 bfd_put_32 (htab->stub_bfd, ADDI_R2_R2 | PPC_LO (r2off), loc);
10661 }
10662 }
10663 loc += 4;
10664 bfd_put_32 (htab->stub_bfd, MTCTR_R12, loc);
10665 loc += 4;
10666 bfd_put_32 (htab->stub_bfd, BCTR, loc);
10667 break;
10668
10669 case ppc_stub_plt_call:
10670 case ppc_stub_plt_call_r2save:
10671 if (stub_entry->h != NULL
10672 && stub_entry->h->is_func_descriptor
10673 && stub_entry->h->oh != NULL)
10674 {
10675 struct ppc_link_hash_entry *fh = ppc_follow_link (stub_entry->h->oh);
10676
10677 /* If the old-ABI "dot-symbol" is undefined make it weak so
10678 we don't get a link error from RELOC_FOR_GLOBAL_SYMBOL.
10679 FIXME: We used to define the symbol on one of the call
10680 stubs instead, which is why we test symbol section id
10681 against htab->top_id in various places. Likely all
10682 these checks could now disappear. */
10683 if (fh->elf.root.type == bfd_link_hash_undefined)
10684 fh->elf.root.type = bfd_link_hash_undefweak;
10685 /* Stop undo_symbol_twiddle changing it back to undefined. */
10686 fh->was_undefined = 0;
10687 }
10688
10689 /* Now build the stub. */
10690 dest = stub_entry->plt_ent->plt.offset & ~1;
10691 if (dest >= (bfd_vma) -2)
10692 abort ();
10693
10694 plt = htab->elf.splt;
10695 if (!htab->elf.dynamic_sections_created
10696 || stub_entry->h == NULL
10697 || stub_entry->h->elf.dynindx == -1)
10698 plt = htab->elf.iplt;
10699
10700 dest += plt->output_offset + plt->output_section->vma;
10701
10702 if (stub_entry->h == NULL
10703 && (stub_entry->plt_ent->plt.offset & 1) == 0)
10704 {
10705 Elf_Internal_Rela rela;
10706 bfd_byte *rl;
10707
10708 rela.r_offset = dest;
10709 if (htab->opd_abi)
10710 rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
10711 else
10712 rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
10713 rela.r_addend = (stub_entry->target_value
10714 + stub_entry->target_section->output_offset
10715 + stub_entry->target_section->output_section->vma);
10716
10717 rl = (htab->elf.irelplt->contents
10718 + (htab->elf.irelplt->reloc_count++
10719 * sizeof (Elf64_External_Rela)));
10720 bfd_elf64_swap_reloca_out (info->output_bfd, &rela, rl);
10721 stub_entry->plt_ent->plt.offset |= 1;
10722 }
10723
10724 off = (dest
10725 - elf_gp (plt->output_section->owner)
10726 - htab->stub_group[stub_entry->id_sec->id].toc_off);
10727
10728 if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
10729 {
10730 info->callbacks->einfo
10731 (_("%P: linkage table error against `%T'\n"),
10732 stub_entry->h != NULL
10733 ? stub_entry->h->elf.root.root.string
10734 : "<local sym>");
10735 bfd_set_error (bfd_error_bad_value);
10736 htab->stub_error = TRUE;
10737 return FALSE;
10738 }
10739
10740 if (htab->plt_stub_align != 0)
10741 {
10742 unsigned pad = plt_stub_pad (htab, stub_entry, off);
10743
10744 stub_entry->stub_sec->size += pad;
10745 stub_entry->stub_offset = stub_entry->stub_sec->size;
10746 loc += pad;
10747 }
10748
10749 r = NULL;
10750 if (info->emitrelocations)
10751 {
10752 r = get_relocs (stub_entry->stub_sec,
10753 ((PPC_HA (off) != 0)
10754 + (htab->opd_abi
10755 ? 2 + (htab->plt_static_chain
10756 && PPC_HA (off + 16) == PPC_HA (off))
10757 : 1)));
10758 if (r == NULL)
10759 return FALSE;
10760 r[0].r_offset = loc - stub_entry->stub_sec->contents;
10761 if (bfd_big_endian (info->output_bfd))
10762 r[0].r_offset += 2;
10763 r[0].r_addend = dest;
10764 }
10765 if (stub_entry->h != NULL
10766 && (stub_entry->h == htab->tls_get_addr_fd
10767 || stub_entry->h == htab->tls_get_addr)
10768 && !htab->no_tls_get_addr_opt)
10769 p = build_tls_get_addr_stub (htab, stub_entry, loc, off, r);
10770 else
10771 p = build_plt_stub (htab, stub_entry, loc, off, r);
10772 size = p - loc;
10773 break;
10774
10775 default:
10776 BFD_FAIL ();
10777 return FALSE;
10778 }
10779
10780 stub_entry->stub_sec->size += size;
10781
10782 if (htab->emit_stub_syms)
10783 {
10784 struct elf_link_hash_entry *h;
10785 size_t len1, len2;
10786 char *name;
10787 const char *const stub_str[] = { "long_branch",
10788 "long_branch_r2off",
10789 "plt_branch",
10790 "plt_branch_r2off",
10791 "plt_call",
10792 "plt_call" };
10793
10794 len1 = strlen (stub_str[stub_entry->stub_type - 1]);
10795 len2 = strlen (stub_entry->root.string);
10796 name = bfd_malloc (len1 + len2 + 2);
10797 if (name == NULL)
10798 return FALSE;
10799 memcpy (name, stub_entry->root.string, 9);
10800 memcpy (name + 9, stub_str[stub_entry->stub_type - 1], len1);
10801 memcpy (name + len1 + 9, stub_entry->root.string + 8, len2 - 8 + 1);
10802 h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
10803 if (h == NULL)
10804 return FALSE;
10805 if (h->root.type == bfd_link_hash_new)
10806 {
10807 h->root.type = bfd_link_hash_defined;
10808 h->root.u.def.section = stub_entry->stub_sec;
10809 h->root.u.def.value = stub_entry->stub_offset;
10810 h->ref_regular = 1;
10811 h->def_regular = 1;
10812 h->ref_regular_nonweak = 1;
10813 h->forced_local = 1;
10814 h->non_elf = 0;
10815 }
10816 }
10817
10818 return TRUE;
10819 }
10820
10821 /* As above, but don't actually build the stub. Just bump offset so
10822 we know stub section sizes, and select plt_branch stubs where
10823 long_branch stubs won't do. */
10824
10825 static bfd_boolean
10826 ppc_size_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
10827 {
10828 struct ppc_stub_hash_entry *stub_entry;
10829 struct bfd_link_info *info;
10830 struct ppc_link_hash_table *htab;
10831 bfd_vma off;
10832 int size;
10833
10834 /* Massage our args to the form they really have. */
10835 stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
10836 info = in_arg;
10837
10838 htab = ppc_hash_table (info);
10839 if (htab == NULL)
10840 return FALSE;
10841
10842 if (stub_entry->stub_type == ppc_stub_plt_call
10843 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10844 {
10845 asection *plt;
10846 off = stub_entry->plt_ent->plt.offset & ~(bfd_vma) 1;
10847 if (off >= (bfd_vma) -2)
10848 abort ();
10849 plt = htab->elf.splt;
10850 if (!htab->elf.dynamic_sections_created
10851 || stub_entry->h == NULL
10852 || stub_entry->h->elf.dynindx == -1)
10853 plt = htab->elf.iplt;
10854 off += (plt->output_offset
10855 + plt->output_section->vma
10856 - elf_gp (plt->output_section->owner)
10857 - htab->stub_group[stub_entry->id_sec->id].toc_off);
10858
10859 size = plt_stub_size (htab, stub_entry, off);
10860 if (htab->plt_stub_align)
10861 size += plt_stub_pad (htab, stub_entry, off);
10862 if (info->emitrelocations)
10863 {
10864 stub_entry->stub_sec->reloc_count
10865 += ((PPC_HA (off) != 0)
10866 + (htab->opd_abi
10867 ? 2 + (htab->plt_static_chain
10868 && PPC_HA (off + 16) == PPC_HA (off))
10869 : 1));
10870 stub_entry->stub_sec->flags |= SEC_RELOC;
10871 }
10872 }
10873 else
10874 {
10875 /* ppc_stub_long_branch or ppc_stub_plt_branch, or their r2off
10876 variants. */
10877 bfd_vma r2off = 0;
10878 bfd_vma local_off = 0;
10879
10880 off = (stub_entry->target_value
10881 + stub_entry->target_section->output_offset
10882 + stub_entry->target_section->output_section->vma);
10883 off -= (stub_entry->stub_sec->size
10884 + stub_entry->stub_sec->output_offset
10885 + stub_entry->stub_sec->output_section->vma);
10886
10887 /* Reset the stub type from the plt variant in case we now
10888 can reach with a shorter stub. */
10889 if (stub_entry->stub_type >= ppc_stub_plt_branch)
10890 stub_entry->stub_type += ppc_stub_long_branch - ppc_stub_plt_branch;
10891
10892 size = 4;
10893 if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
10894 {
10895 r2off = get_r2off (info, stub_entry);
10896 if (r2off == 0 && htab->opd_abi)
10897 {
10898 htab->stub_error = TRUE;
10899 return FALSE;
10900 }
10901 size = 12;
10902 if (PPC_HA (r2off) != 0)
10903 size = 16;
10904 off -= size - 4;
10905 }
10906
10907 local_off = PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
10908
10909 /* If the branch offset if too big, use a ppc_stub_plt_branch.
10910 Do the same for -R objects without function descriptors. */
10911 if (off + (1 << 25) >= (bfd_vma) (1 << 26) - local_off
10912 || (stub_entry->stub_type == ppc_stub_long_branch_r2off
10913 && r2off == 0))
10914 {
10915 struct ppc_branch_hash_entry *br_entry;
10916
10917 br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
10918 stub_entry->root.string + 9,
10919 TRUE, FALSE);
10920 if (br_entry == NULL)
10921 {
10922 info->callbacks->einfo (_("%P: can't build branch stub `%s'\n"),
10923 stub_entry->root.string);
10924 htab->stub_error = TRUE;
10925 return FALSE;
10926 }
10927
10928 if (br_entry->iter != htab->stub_iteration)
10929 {
10930 br_entry->iter = htab->stub_iteration;
10931 br_entry->offset = htab->brlt->size;
10932 htab->brlt->size += 8;
10933
10934 if (htab->relbrlt != NULL)
10935 htab->relbrlt->size += sizeof (Elf64_External_Rela);
10936 else if (info->emitrelocations)
10937 {
10938 htab->brlt->reloc_count += 1;
10939 htab->brlt->flags |= SEC_RELOC;
10940 }
10941 }
10942
10943 stub_entry->stub_type += ppc_stub_plt_branch - ppc_stub_long_branch;
10944 off = (br_entry->offset
10945 + htab->brlt->output_offset
10946 + htab->brlt->output_section->vma
10947 - elf_gp (htab->brlt->output_section->owner)
10948 - htab->stub_group[stub_entry->id_sec->id].toc_off);
10949
10950 if (info->emitrelocations)
10951 {
10952 stub_entry->stub_sec->reloc_count += 1 + (PPC_HA (off) != 0);
10953 stub_entry->stub_sec->flags |= SEC_RELOC;
10954 }
10955
10956 if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
10957 {
10958 size = 12;
10959 if (PPC_HA (off) != 0)
10960 size = 16;
10961 }
10962 else
10963 {
10964 size = 16;
10965 if (PPC_HA (off) != 0)
10966 size += 4;
10967
10968 if (PPC_HA (r2off) != 0)
10969 size += 4;
10970 if (PPC_LO (r2off) != 0)
10971 size += 4;
10972 }
10973 }
10974 else if (info->emitrelocations)
10975 {
10976 stub_entry->stub_sec->reloc_count += 1;
10977 stub_entry->stub_sec->flags |= SEC_RELOC;
10978 }
10979 }
10980
10981 stub_entry->stub_sec->size += size;
10982 return TRUE;
10983 }
10984
10985 /* Set up various things so that we can make a list of input sections
10986 for each output section included in the link. Returns -1 on error,
10987 0 when no stubs will be needed, and 1 on success. */
10988
10989 int
10990 ppc64_elf_setup_section_lists
10991 (struct bfd_link_info *info,
10992 asection *(*add_stub_section) (const char *, asection *),
10993 void (*layout_sections_again) (void))
10994 {
10995 bfd *input_bfd;
10996 int top_id, top_index, id;
10997 asection *section;
10998 asection **input_list;
10999 bfd_size_type amt;
11000 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11001
11002 if (htab == NULL)
11003 return -1;
11004 /* Stash our params away. */
11005 htab->add_stub_section = add_stub_section;
11006 htab->layout_sections_again = layout_sections_again;
11007
11008 /* Find the top input section id. */
11009 for (input_bfd = info->input_bfds, top_id = 3;
11010 input_bfd != NULL;
11011 input_bfd = input_bfd->link_next)
11012 {
11013 for (section = input_bfd->sections;
11014 section != NULL;
11015 section = section->next)
11016 {
11017 if (top_id < section->id)
11018 top_id = section->id;
11019 }
11020 }
11021
11022 htab->top_id = top_id;
11023 amt = sizeof (struct map_stub) * (top_id + 1);
11024 htab->stub_group = bfd_zmalloc (amt);
11025 if (htab->stub_group == NULL)
11026 return -1;
11027
11028 /* Set toc_off for com, und, abs and ind sections. */
11029 for (id = 0; id < 3; id++)
11030 htab->stub_group[id].toc_off = TOC_BASE_OFF;
11031
11032 /* We can't use output_bfd->section_count here to find the top output
11033 section index as some sections may have been removed, and
11034 strip_excluded_output_sections doesn't renumber the indices. */
11035 for (section = info->output_bfd->sections, top_index = 0;
11036 section != NULL;
11037 section = section->next)
11038 {
11039 if (top_index < section->index)
11040 top_index = section->index;
11041 }
11042
11043 htab->top_index = top_index;
11044 amt = sizeof (asection *) * (top_index + 1);
11045 input_list = bfd_zmalloc (amt);
11046 htab->input_list = input_list;
11047 if (input_list == NULL)
11048 return -1;
11049
11050 return 1;
11051 }
11052
11053 /* Set up for first pass at multitoc partitioning. */
11054
11055 void
11056 ppc64_elf_start_multitoc_partition (struct bfd_link_info *info)
11057 {
11058 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11059
11060 htab->toc_curr = ppc64_elf_set_toc (info, info->output_bfd);
11061 htab->toc_bfd = NULL;
11062 htab->toc_first_sec = NULL;
11063 }
11064
11065 /* The linker repeatedly calls this function for each TOC input section
11066 and linker generated GOT section. Group input bfds such that the toc
11067 within a group is less than 64k in size. */
11068
11069 bfd_boolean
11070 ppc64_elf_next_toc_section (struct bfd_link_info *info, asection *isec)
11071 {
11072 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11073 bfd_vma addr, off, limit;
11074
11075 if (htab == NULL)
11076 return FALSE;
11077
11078 if (!htab->second_toc_pass)
11079 {
11080 /* Keep track of the first .toc or .got section for this input bfd. */
11081 bfd_boolean new_bfd = htab->toc_bfd != isec->owner;
11082
11083 if (new_bfd)
11084 {
11085 htab->toc_bfd = isec->owner;
11086 htab->toc_first_sec = isec;
11087 }
11088
11089 addr = isec->output_offset + isec->output_section->vma;
11090 off = addr - htab->toc_curr;
11091 limit = 0x80008000;
11092 if (ppc64_elf_tdata (isec->owner)->has_small_toc_reloc)
11093 limit = 0x10000;
11094 if (off + isec->size > limit)
11095 {
11096 addr = (htab->toc_first_sec->output_offset
11097 + htab->toc_first_sec->output_section->vma);
11098 htab->toc_curr = addr;
11099 }
11100
11101 /* toc_curr is the base address of this toc group. Set elf_gp
11102 for the input section to be the offset relative to the
11103 output toc base plus 0x8000. Making the input elf_gp an
11104 offset allows us to move the toc as a whole without
11105 recalculating input elf_gp. */
11106 off = htab->toc_curr - elf_gp (isec->output_section->owner);
11107 off += TOC_BASE_OFF;
11108
11109 /* Die if someone uses a linker script that doesn't keep input
11110 file .toc and .got together. */
11111 if (new_bfd
11112 && elf_gp (isec->owner) != 0
11113 && elf_gp (isec->owner) != off)
11114 return FALSE;
11115
11116 elf_gp (isec->owner) = off;
11117 return TRUE;
11118 }
11119
11120 /* During the second pass toc_first_sec points to the start of
11121 a toc group, and toc_curr is used to track the old elf_gp.
11122 We use toc_bfd to ensure we only look at each bfd once. */
11123 if (htab->toc_bfd == isec->owner)
11124 return TRUE;
11125 htab->toc_bfd = isec->owner;
11126
11127 if (htab->toc_first_sec == NULL
11128 || htab->toc_curr != elf_gp (isec->owner))
11129 {
11130 htab->toc_curr = elf_gp (isec->owner);
11131 htab->toc_first_sec = isec;
11132 }
11133 addr = (htab->toc_first_sec->output_offset
11134 + htab->toc_first_sec->output_section->vma);
11135 off = addr - elf_gp (isec->output_section->owner) + TOC_BASE_OFF;
11136 elf_gp (isec->owner) = off;
11137
11138 return TRUE;
11139 }
11140
11141 /* Called via elf_link_hash_traverse to merge GOT entries for global
11142 symbol H. */
11143
11144 static bfd_boolean
11145 merge_global_got (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
11146 {
11147 if (h->root.type == bfd_link_hash_indirect)
11148 return TRUE;
11149
11150 merge_got_entries (&h->got.glist);
11151
11152 return TRUE;
11153 }
11154
11155 /* Called via elf_link_hash_traverse to allocate GOT entries for global
11156 symbol H. */
11157
11158 static bfd_boolean
11159 reallocate_got (struct elf_link_hash_entry *h, void *inf)
11160 {
11161 struct got_entry *gent;
11162
11163 if (h->root.type == bfd_link_hash_indirect)
11164 return TRUE;
11165
11166 for (gent = h->got.glist; gent != NULL; gent = gent->next)
11167 if (!gent->is_indirect)
11168 allocate_got (h, (struct bfd_link_info *) inf, gent);
11169 return TRUE;
11170 }
11171
11172 /* Called on the first multitoc pass after the last call to
11173 ppc64_elf_next_toc_section. This function removes duplicate GOT
11174 entries. */
11175
11176 bfd_boolean
11177 ppc64_elf_layout_multitoc (struct bfd_link_info *info)
11178 {
11179 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11180 struct bfd *ibfd, *ibfd2;
11181 bfd_boolean done_something;
11182
11183 htab->multi_toc_needed = htab->toc_curr != elf_gp (info->output_bfd);
11184
11185 if (!htab->do_multi_toc)
11186 return FALSE;
11187
11188 /* Merge global sym got entries within a toc group. */
11189 elf_link_hash_traverse (&htab->elf, merge_global_got, info);
11190
11191 /* And tlsld_got. */
11192 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
11193 {
11194 struct got_entry *ent, *ent2;
11195
11196 if (!is_ppc64_elf (ibfd))
11197 continue;
11198
11199 ent = ppc64_tlsld_got (ibfd);
11200 if (!ent->is_indirect
11201 && ent->got.offset != (bfd_vma) -1)
11202 {
11203 for (ibfd2 = ibfd->link_next; ibfd2 != NULL; ibfd2 = ibfd2->link_next)
11204 {
11205 if (!is_ppc64_elf (ibfd2))
11206 continue;
11207
11208 ent2 = ppc64_tlsld_got (ibfd2);
11209 if (!ent2->is_indirect
11210 && ent2->got.offset != (bfd_vma) -1
11211 && elf_gp (ibfd2) == elf_gp (ibfd))
11212 {
11213 ent2->is_indirect = TRUE;
11214 ent2->got.ent = ent;
11215 }
11216 }
11217 }
11218 }
11219
11220 /* Zap sizes of got sections. */
11221 htab->elf.irelplt->rawsize = htab->elf.irelplt->size;
11222 htab->elf.irelplt->size -= htab->got_reli_size;
11223 htab->got_reli_size = 0;
11224
11225 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
11226 {
11227 asection *got, *relgot;
11228
11229 if (!is_ppc64_elf (ibfd))
11230 continue;
11231
11232 got = ppc64_elf_tdata (ibfd)->got;
11233 if (got != NULL)
11234 {
11235 got->rawsize = got->size;
11236 got->size = 0;
11237 relgot = ppc64_elf_tdata (ibfd)->relgot;
11238 relgot->rawsize = relgot->size;
11239 relgot->size = 0;
11240 }
11241 }
11242
11243 /* Now reallocate the got, local syms first. We don't need to
11244 allocate section contents again since we never increase size. */
11245 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
11246 {
11247 struct got_entry **lgot_ents;
11248 struct got_entry **end_lgot_ents;
11249 struct plt_entry **local_plt;
11250 struct plt_entry **end_local_plt;
11251 unsigned char *lgot_masks;
11252 bfd_size_type locsymcount;
11253 Elf_Internal_Shdr *symtab_hdr;
11254 asection *s;
11255
11256 if (!is_ppc64_elf (ibfd))
11257 continue;
11258
11259 lgot_ents = elf_local_got_ents (ibfd);
11260 if (!lgot_ents)
11261 continue;
11262
11263 symtab_hdr = &elf_symtab_hdr (ibfd);
11264 locsymcount = symtab_hdr->sh_info;
11265 end_lgot_ents = lgot_ents + locsymcount;
11266 local_plt = (struct plt_entry **) end_lgot_ents;
11267 end_local_plt = local_plt + locsymcount;
11268 lgot_masks = (unsigned char *) end_local_plt;
11269 s = ppc64_elf_tdata (ibfd)->got;
11270 for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
11271 {
11272 struct got_entry *ent;
11273
11274 for (ent = *lgot_ents; ent != NULL; ent = ent->next)
11275 {
11276 unsigned int ent_size = 8;
11277 unsigned int rel_size = sizeof (Elf64_External_Rela);
11278
11279 ent->got.offset = s->size;
11280 if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
11281 {
11282 ent_size *= 2;
11283 rel_size *= 2;
11284 }
11285 s->size += ent_size;
11286 if ((*lgot_masks & PLT_IFUNC) != 0)
11287 {
11288 htab->elf.irelplt->size += rel_size;
11289 htab->got_reli_size += rel_size;
11290 }
11291 else if (info->shared)
11292 {
11293 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
11294 srel->size += rel_size;
11295 }
11296 }
11297 }
11298 }
11299
11300 elf_link_hash_traverse (&htab->elf, reallocate_got, info);
11301
11302 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
11303 {
11304 struct got_entry *ent;
11305
11306 if (!is_ppc64_elf (ibfd))
11307 continue;
11308
11309 ent = ppc64_tlsld_got (ibfd);
11310 if (!ent->is_indirect
11311 && ent->got.offset != (bfd_vma) -1)
11312 {
11313 asection *s = ppc64_elf_tdata (ibfd)->got;
11314 ent->got.offset = s->size;
11315 s->size += 16;
11316 if (info->shared)
11317 {
11318 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
11319 srel->size += sizeof (Elf64_External_Rela);
11320 }
11321 }
11322 }
11323
11324 done_something = htab->elf.irelplt->rawsize != htab->elf.irelplt->size;
11325 if (!done_something)
11326 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
11327 {
11328 asection *got;
11329
11330 if (!is_ppc64_elf (ibfd))
11331 continue;
11332
11333 got = ppc64_elf_tdata (ibfd)->got;
11334 if (got != NULL)
11335 {
11336 done_something = got->rawsize != got->size;
11337 if (done_something)
11338 break;
11339 }
11340 }
11341
11342 if (done_something)
11343 (*htab->layout_sections_again) ();
11344
11345 /* Set up for second pass over toc sections to recalculate elf_gp
11346 on input sections. */
11347 htab->toc_bfd = NULL;
11348 htab->toc_first_sec = NULL;
11349 htab->second_toc_pass = TRUE;
11350 return done_something;
11351 }
11352
11353 /* Called after second pass of multitoc partitioning. */
11354
11355 void
11356 ppc64_elf_finish_multitoc_partition (struct bfd_link_info *info)
11357 {
11358 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11359
11360 /* After the second pass, toc_curr tracks the TOC offset used
11361 for code sections below in ppc64_elf_next_input_section. */
11362 htab->toc_curr = TOC_BASE_OFF;
11363 }
11364
11365 /* No toc references were found in ISEC. If the code in ISEC makes no
11366 calls, then there's no need to use toc adjusting stubs when branching
11367 into ISEC. Actually, indirect calls from ISEC are OK as they will
11368 load r2. Returns -1 on error, 0 for no stub needed, 1 for stub
11369 needed, and 2 if a cyclical call-graph was found but no other reason
11370 for a stub was detected. If called from the top level, a return of
11371 2 means the same as a return of 0. */
11372
11373 static int
11374 toc_adjusting_stub_needed (struct bfd_link_info *info, asection *isec)
11375 {
11376 int ret;
11377
11378 /* Mark this section as checked. */
11379 isec->call_check_done = 1;
11380
11381 /* We know none of our code bearing sections will need toc stubs. */
11382 if ((isec->flags & SEC_LINKER_CREATED) != 0)
11383 return 0;
11384
11385 if (isec->size == 0)
11386 return 0;
11387
11388 if (isec->output_section == NULL)
11389 return 0;
11390
11391 ret = 0;
11392 if (isec->reloc_count != 0)
11393 {
11394 Elf_Internal_Rela *relstart, *rel;
11395 Elf_Internal_Sym *local_syms;
11396 struct ppc_link_hash_table *htab;
11397
11398 relstart = _bfd_elf_link_read_relocs (isec->owner, isec, NULL, NULL,
11399 info->keep_memory);
11400 if (relstart == NULL)
11401 return -1;
11402
11403 /* Look for branches to outside of this section. */
11404 local_syms = NULL;
11405 htab = ppc_hash_table (info);
11406 if (htab == NULL)
11407 return -1;
11408
11409 for (rel = relstart; rel < relstart + isec->reloc_count; ++rel)
11410 {
11411 enum elf_ppc64_reloc_type r_type;
11412 unsigned long r_symndx;
11413 struct elf_link_hash_entry *h;
11414 struct ppc_link_hash_entry *eh;
11415 Elf_Internal_Sym *sym;
11416 asection *sym_sec;
11417 struct _opd_sec_data *opd;
11418 bfd_vma sym_value;
11419 bfd_vma dest;
11420
11421 r_type = ELF64_R_TYPE (rel->r_info);
11422 if (r_type != R_PPC64_REL24
11423 && r_type != R_PPC64_REL14
11424 && r_type != R_PPC64_REL14_BRTAKEN
11425 && r_type != R_PPC64_REL14_BRNTAKEN)
11426 continue;
11427
11428 r_symndx = ELF64_R_SYM (rel->r_info);
11429 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms, r_symndx,
11430 isec->owner))
11431 {
11432 ret = -1;
11433 break;
11434 }
11435
11436 /* Calls to dynamic lib functions go through a plt call stub
11437 that uses r2. */
11438 eh = (struct ppc_link_hash_entry *) h;
11439 if (eh != NULL
11440 && (eh->elf.plt.plist != NULL
11441 || (eh->oh != NULL
11442 && ppc_follow_link (eh->oh)->elf.plt.plist != NULL)))
11443 {
11444 ret = 1;
11445 break;
11446 }
11447
11448 if (sym_sec == NULL)
11449 /* Ignore other undefined symbols. */
11450 continue;
11451
11452 /* Assume branches to other sections not included in the
11453 link need stubs too, to cover -R and absolute syms. */
11454 if (sym_sec->output_section == NULL)
11455 {
11456 ret = 1;
11457 break;
11458 }
11459
11460 if (h == NULL)
11461 sym_value = sym->st_value;
11462 else
11463 {
11464 if (h->root.type != bfd_link_hash_defined
11465 && h->root.type != bfd_link_hash_defweak)
11466 abort ();
11467 sym_value = h->root.u.def.value;
11468 }
11469 sym_value += rel->r_addend;
11470
11471 /* If this branch reloc uses an opd sym, find the code section. */
11472 opd = get_opd_info (sym_sec);
11473 if (opd != NULL)
11474 {
11475 if (h == NULL && opd->adjust != NULL)
11476 {
11477 long adjust;
11478
11479 adjust = opd->adjust[sym->st_value / 8];
11480 if (adjust == -1)
11481 /* Assume deleted functions won't ever be called. */
11482 continue;
11483 sym_value += adjust;
11484 }
11485
11486 dest = opd_entry_value (sym_sec, sym_value,
11487 &sym_sec, NULL, FALSE);
11488 if (dest == (bfd_vma) -1)
11489 continue;
11490 }
11491 else
11492 dest = (sym_value
11493 + sym_sec->output_offset
11494 + sym_sec->output_section->vma);
11495
11496 /* Ignore branch to self. */
11497 if (sym_sec == isec)
11498 continue;
11499
11500 /* If the called function uses the toc, we need a stub. */
11501 if (sym_sec->has_toc_reloc
11502 || sym_sec->makes_toc_func_call)
11503 {
11504 ret = 1;
11505 break;
11506 }
11507
11508 /* Assume any branch that needs a long branch stub might in fact
11509 need a plt_branch stub. A plt_branch stub uses r2. */
11510 else if (dest - (isec->output_offset
11511 + isec->output_section->vma
11512 + rel->r_offset) + (1 << 25)
11513 >= (2u << 25) - PPC64_LOCAL_ENTRY_OFFSET (h
11514 ? h->other
11515 : sym->st_other))
11516 {
11517 ret = 1;
11518 break;
11519 }
11520
11521 /* If calling back to a section in the process of being
11522 tested, we can't say for sure that no toc adjusting stubs
11523 are needed, so don't return zero. */
11524 else if (sym_sec->call_check_in_progress)
11525 ret = 2;
11526
11527 /* Branches to another section that itself doesn't have any TOC
11528 references are OK. Recursively call ourselves to check. */
11529 else if (!sym_sec->call_check_done)
11530 {
11531 int recur;
11532
11533 /* Mark current section as indeterminate, so that other
11534 sections that call back to current won't be marked as
11535 known. */
11536 isec->call_check_in_progress = 1;
11537 recur = toc_adjusting_stub_needed (info, sym_sec);
11538 isec->call_check_in_progress = 0;
11539
11540 if (recur != 0)
11541 {
11542 ret = recur;
11543 if (recur != 2)
11544 break;
11545 }
11546 }
11547 }
11548
11549 if (local_syms != NULL
11550 && (elf_symtab_hdr (isec->owner).contents
11551 != (unsigned char *) local_syms))
11552 free (local_syms);
11553 if (elf_section_data (isec)->relocs != relstart)
11554 free (relstart);
11555 }
11556
11557 if ((ret & 1) == 0
11558 && isec->map_head.s != NULL
11559 && (strcmp (isec->output_section->name, ".init") == 0
11560 || strcmp (isec->output_section->name, ".fini") == 0))
11561 {
11562 if (isec->map_head.s->has_toc_reloc
11563 || isec->map_head.s->makes_toc_func_call)
11564 ret = 1;
11565 else if (!isec->map_head.s->call_check_done)
11566 {
11567 int recur;
11568 isec->call_check_in_progress = 1;
11569 recur = toc_adjusting_stub_needed (info, isec->map_head.s);
11570 isec->call_check_in_progress = 0;
11571 if (recur != 0)
11572 ret = recur;
11573 }
11574 }
11575
11576 if (ret == 1)
11577 isec->makes_toc_func_call = 1;
11578
11579 return ret;
11580 }
11581
11582 /* The linker repeatedly calls this function for each input section,
11583 in the order that input sections are linked into output sections.
11584 Build lists of input sections to determine groupings between which
11585 we may insert linker stubs. */
11586
11587 bfd_boolean
11588 ppc64_elf_next_input_section (struct bfd_link_info *info, asection *isec)
11589 {
11590 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11591
11592 if (htab == NULL)
11593 return FALSE;
11594
11595 if ((isec->output_section->flags & SEC_CODE) != 0
11596 && isec->output_section->index <= htab->top_index)
11597 {
11598 asection **list = htab->input_list + isec->output_section->index;
11599 /* Steal the link_sec pointer for our list. */
11600 #define PREV_SEC(sec) (htab->stub_group[(sec)->id].link_sec)
11601 /* This happens to make the list in reverse order,
11602 which is what we want. */
11603 PREV_SEC (isec) = *list;
11604 *list = isec;
11605 }
11606
11607 if (htab->multi_toc_needed)
11608 {
11609 /* Analyse sections that aren't already flagged as needing a
11610 valid toc pointer. Exclude .fixup for the linux kernel.
11611 .fixup contains branches, but only back to the function that
11612 hit an exception. */
11613 if (!(isec->has_toc_reloc
11614 || (isec->flags & SEC_CODE) == 0
11615 || strcmp (isec->name, ".fixup") == 0
11616 || isec->call_check_done))
11617 {
11618 if (toc_adjusting_stub_needed (info, isec) < 0)
11619 return FALSE;
11620 }
11621 /* Make all sections use the TOC assigned for this object file.
11622 This will be wrong for pasted sections; We fix that in
11623 check_pasted_section(). */
11624 if (elf_gp (isec->owner) != 0)
11625 htab->toc_curr = elf_gp (isec->owner);
11626 }
11627
11628 htab->stub_group[isec->id].toc_off = htab->toc_curr;
11629 return TRUE;
11630 }
11631
11632 /* Check that all .init and .fini sections use the same toc, if they
11633 have toc relocs. */
11634
11635 static bfd_boolean
11636 check_pasted_section (struct bfd_link_info *info, const char *name)
11637 {
11638 asection *o = bfd_get_section_by_name (info->output_bfd, name);
11639
11640 if (o != NULL)
11641 {
11642 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11643 bfd_vma toc_off = 0;
11644 asection *i;
11645
11646 for (i = o->map_head.s; i != NULL; i = i->map_head.s)
11647 if (i->has_toc_reloc)
11648 {
11649 if (toc_off == 0)
11650 toc_off = htab->stub_group[i->id].toc_off;
11651 else if (toc_off != htab->stub_group[i->id].toc_off)
11652 return FALSE;
11653 }
11654
11655 if (toc_off == 0)
11656 for (i = o->map_head.s; i != NULL; i = i->map_head.s)
11657 if (i->makes_toc_func_call)
11658 {
11659 toc_off = htab->stub_group[i->id].toc_off;
11660 break;
11661 }
11662
11663 /* Make sure the whole pasted function uses the same toc offset. */
11664 if (toc_off != 0)
11665 for (i = o->map_head.s; i != NULL; i = i->map_head.s)
11666 htab->stub_group[i->id].toc_off = toc_off;
11667 }
11668 return TRUE;
11669 }
11670
11671 bfd_boolean
11672 ppc64_elf_check_init_fini (struct bfd_link_info *info)
11673 {
11674 return (check_pasted_section (info, ".init")
11675 & check_pasted_section (info, ".fini"));
11676 }
11677
11678 /* See whether we can group stub sections together. Grouping stub
11679 sections may result in fewer stubs. More importantly, we need to
11680 put all .init* and .fini* stubs at the beginning of the .init or
11681 .fini output sections respectively, because glibc splits the
11682 _init and _fini functions into multiple parts. Putting a stub in
11683 the middle of a function is not a good idea. */
11684
11685 static void
11686 group_sections (struct ppc_link_hash_table *htab,
11687 bfd_size_type stub_group_size,
11688 bfd_boolean stubs_always_before_branch)
11689 {
11690 asection **list;
11691 bfd_size_type stub14_group_size;
11692 bfd_boolean suppress_size_errors;
11693
11694 suppress_size_errors = FALSE;
11695 stub14_group_size = stub_group_size;
11696 if (stub_group_size == 1)
11697 {
11698 /* Default values. */
11699 if (stubs_always_before_branch)
11700 {
11701 stub_group_size = 0x1e00000;
11702 stub14_group_size = 0x7800;
11703 }
11704 else
11705 {
11706 stub_group_size = 0x1c00000;
11707 stub14_group_size = 0x7000;
11708 }
11709 suppress_size_errors = TRUE;
11710 }
11711
11712 list = htab->input_list + htab->top_index;
11713 do
11714 {
11715 asection *tail = *list;
11716 while (tail != NULL)
11717 {
11718 asection *curr;
11719 asection *prev;
11720 bfd_size_type total;
11721 bfd_boolean big_sec;
11722 bfd_vma curr_toc;
11723
11724 curr = tail;
11725 total = tail->size;
11726 big_sec = total > (ppc64_elf_section_data (tail) != NULL
11727 && ppc64_elf_section_data (tail)->has_14bit_branch
11728 ? stub14_group_size : stub_group_size);
11729 if (big_sec && !suppress_size_errors)
11730 (*_bfd_error_handler) (_("%B section %A exceeds stub group size"),
11731 tail->owner, tail);
11732 curr_toc = htab->stub_group[tail->id].toc_off;
11733
11734 while ((prev = PREV_SEC (curr)) != NULL
11735 && ((total += curr->output_offset - prev->output_offset)
11736 < (ppc64_elf_section_data (prev) != NULL
11737 && ppc64_elf_section_data (prev)->has_14bit_branch
11738 ? stub14_group_size : stub_group_size))
11739 && htab->stub_group[prev->id].toc_off == curr_toc)
11740 curr = prev;
11741
11742 /* OK, the size from the start of CURR to the end is less
11743 than stub_group_size and thus can be handled by one stub
11744 section. (or the tail section is itself larger than
11745 stub_group_size, in which case we may be toast.) We
11746 should really be keeping track of the total size of stubs
11747 added here, as stubs contribute to the final output
11748 section size. That's a little tricky, and this way will
11749 only break if stubs added make the total size more than
11750 2^25, ie. for the default stub_group_size, if stubs total
11751 more than 2097152 bytes, or nearly 75000 plt call stubs. */
11752 do
11753 {
11754 prev = PREV_SEC (tail);
11755 /* Set up this stub group. */
11756 htab->stub_group[tail->id].link_sec = curr;
11757 }
11758 while (tail != curr && (tail = prev) != NULL);
11759
11760 /* But wait, there's more! Input sections up to stub_group_size
11761 bytes before the stub section can be handled by it too.
11762 Don't do this if we have a really large section after the
11763 stubs, as adding more stubs increases the chance that
11764 branches may not reach into the stub section. */
11765 if (!stubs_always_before_branch && !big_sec)
11766 {
11767 total = 0;
11768 while (prev != NULL
11769 && ((total += tail->output_offset - prev->output_offset)
11770 < (ppc64_elf_section_data (prev) != NULL
11771 && ppc64_elf_section_data (prev)->has_14bit_branch
11772 ? stub14_group_size : stub_group_size))
11773 && htab->stub_group[prev->id].toc_off == curr_toc)
11774 {
11775 tail = prev;
11776 prev = PREV_SEC (tail);
11777 htab->stub_group[tail->id].link_sec = curr;
11778 }
11779 }
11780 tail = prev;
11781 }
11782 }
11783 while (list-- != htab->input_list);
11784 free (htab->input_list);
11785 #undef PREV_SEC
11786 }
11787
11788 static const unsigned char glink_eh_frame_cie[] =
11789 {
11790 0, 0, 0, 16, /* length. */
11791 0, 0, 0, 0, /* id. */
11792 1, /* CIE version. */
11793 'z', 'R', 0, /* Augmentation string. */
11794 4, /* Code alignment. */
11795 0x78, /* Data alignment. */
11796 65, /* RA reg. */
11797 1, /* Augmentation size. */
11798 DW_EH_PE_pcrel | DW_EH_PE_sdata4, /* FDE encoding. */
11799 DW_CFA_def_cfa, 1, 0 /* def_cfa: r1 offset 0. */
11800 };
11801
11802 /* Stripping output sections is normally done before dynamic section
11803 symbols have been allocated. This function is called later, and
11804 handles cases like htab->brlt which is mapped to its own output
11805 section. */
11806
11807 static void
11808 maybe_strip_output (struct bfd_link_info *info, asection *isec)
11809 {
11810 if (isec->size == 0
11811 && isec->output_section->size == 0
11812 && !(isec->output_section->flags & SEC_KEEP)
11813 && !bfd_section_removed_from_list (info->output_bfd,
11814 isec->output_section)
11815 && elf_section_data (isec->output_section)->dynindx == 0)
11816 {
11817 isec->output_section->flags |= SEC_EXCLUDE;
11818 bfd_section_list_remove (info->output_bfd, isec->output_section);
11819 info->output_bfd->section_count--;
11820 }
11821 }
11822
11823 /* Determine and set the size of the stub section for a final link.
11824
11825 The basic idea here is to examine all the relocations looking for
11826 PC-relative calls to a target that is unreachable with a "bl"
11827 instruction. */
11828
11829 bfd_boolean
11830 ppc64_elf_size_stubs (struct bfd_link_info *info, bfd_signed_vma group_size,
11831 bfd_boolean plt_static_chain, int plt_thread_safe,
11832 int plt_stub_align)
11833 {
11834 bfd_size_type stub_group_size;
11835 bfd_boolean stubs_always_before_branch;
11836 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11837
11838 if (htab == NULL)
11839 return FALSE;
11840
11841 htab->plt_static_chain = plt_static_chain;
11842 htab->plt_stub_align = plt_stub_align;
11843 if (plt_thread_safe == -1 && !info->executable)
11844 plt_thread_safe = 1;
11845 if (!htab->opd_abi)
11846 plt_thread_safe = 0;
11847 else if (plt_thread_safe == -1)
11848 {
11849 static const char *const thread_starter[] =
11850 {
11851 "pthread_create",
11852 /* libstdc++ */
11853 "_ZNSt6thread15_M_start_threadESt10shared_ptrINS_10_Impl_baseEE",
11854 /* librt */
11855 "aio_init", "aio_read", "aio_write", "aio_fsync", "lio_listio",
11856 "mq_notify", "create_timer",
11857 /* libanl */
11858 "getaddrinfo_a",
11859 /* libgomp */
11860 "GOMP_parallel_start",
11861 "GOMP_parallel_loop_static_start",
11862 "GOMP_parallel_loop_dynamic_start",
11863 "GOMP_parallel_loop_guided_start",
11864 "GOMP_parallel_loop_runtime_start",
11865 "GOMP_parallel_sections_start",
11866 };
11867 unsigned i;
11868
11869 for (i = 0; i < sizeof (thread_starter)/ sizeof (thread_starter[0]); i++)
11870 {
11871 struct elf_link_hash_entry *h;
11872 h = elf_link_hash_lookup (&htab->elf, thread_starter[i],
11873 FALSE, FALSE, TRUE);
11874 plt_thread_safe = h != NULL && h->ref_regular;
11875 if (plt_thread_safe)
11876 break;
11877 }
11878 }
11879 htab->plt_thread_safe = plt_thread_safe;
11880 stubs_always_before_branch = group_size < 0;
11881 if (group_size < 0)
11882 stub_group_size = -group_size;
11883 else
11884 stub_group_size = group_size;
11885
11886 group_sections (htab, stub_group_size, stubs_always_before_branch);
11887
11888 while (1)
11889 {
11890 bfd *input_bfd;
11891 unsigned int bfd_indx;
11892 asection *stub_sec;
11893
11894 htab->stub_iteration += 1;
11895
11896 for (input_bfd = info->input_bfds, bfd_indx = 0;
11897 input_bfd != NULL;
11898 input_bfd = input_bfd->link_next, bfd_indx++)
11899 {
11900 Elf_Internal_Shdr *symtab_hdr;
11901 asection *section;
11902 Elf_Internal_Sym *local_syms = NULL;
11903
11904 if (!is_ppc64_elf (input_bfd))
11905 continue;
11906
11907 /* We'll need the symbol table in a second. */
11908 symtab_hdr = &elf_symtab_hdr (input_bfd);
11909 if (symtab_hdr->sh_info == 0)
11910 continue;
11911
11912 /* Walk over each section attached to the input bfd. */
11913 for (section = input_bfd->sections;
11914 section != NULL;
11915 section = section->next)
11916 {
11917 Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
11918
11919 /* If there aren't any relocs, then there's nothing more
11920 to do. */
11921 if ((section->flags & SEC_RELOC) == 0
11922 || (section->flags & SEC_ALLOC) == 0
11923 || (section->flags & SEC_LOAD) == 0
11924 || (section->flags & SEC_CODE) == 0
11925 || section->reloc_count == 0)
11926 continue;
11927
11928 /* If this section is a link-once section that will be
11929 discarded, then don't create any stubs. */
11930 if (section->output_section == NULL
11931 || section->output_section->owner != info->output_bfd)
11932 continue;
11933
11934 /* Get the relocs. */
11935 internal_relocs
11936 = _bfd_elf_link_read_relocs (input_bfd, section, NULL, NULL,
11937 info->keep_memory);
11938 if (internal_relocs == NULL)
11939 goto error_ret_free_local;
11940
11941 /* Now examine each relocation. */
11942 irela = internal_relocs;
11943 irelaend = irela + section->reloc_count;
11944 for (; irela < irelaend; irela++)
11945 {
11946 enum elf_ppc64_reloc_type r_type;
11947 unsigned int r_indx;
11948 enum ppc_stub_type stub_type;
11949 struct ppc_stub_hash_entry *stub_entry;
11950 asection *sym_sec, *code_sec;
11951 bfd_vma sym_value, code_value;
11952 bfd_vma destination;
11953 unsigned long local_off;
11954 bfd_boolean ok_dest;
11955 struct ppc_link_hash_entry *hash;
11956 struct ppc_link_hash_entry *fdh;
11957 struct elf_link_hash_entry *h;
11958 Elf_Internal_Sym *sym;
11959 char *stub_name;
11960 const asection *id_sec;
11961 struct _opd_sec_data *opd;
11962 struct plt_entry *plt_ent;
11963
11964 r_type = ELF64_R_TYPE (irela->r_info);
11965 r_indx = ELF64_R_SYM (irela->r_info);
11966
11967 if (r_type >= R_PPC64_max)
11968 {
11969 bfd_set_error (bfd_error_bad_value);
11970 goto error_ret_free_internal;
11971 }
11972
11973 /* Only look for stubs on branch instructions. */
11974 if (r_type != R_PPC64_REL24
11975 && r_type != R_PPC64_REL14
11976 && r_type != R_PPC64_REL14_BRTAKEN
11977 && r_type != R_PPC64_REL14_BRNTAKEN)
11978 continue;
11979
11980 /* Now determine the call target, its name, value,
11981 section. */
11982 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
11983 r_indx, input_bfd))
11984 goto error_ret_free_internal;
11985 hash = (struct ppc_link_hash_entry *) h;
11986
11987 ok_dest = FALSE;
11988 fdh = NULL;
11989 sym_value = 0;
11990 if (hash == NULL)
11991 {
11992 sym_value = sym->st_value;
11993 ok_dest = TRUE;
11994 }
11995 else if (hash->elf.root.type == bfd_link_hash_defined
11996 || hash->elf.root.type == bfd_link_hash_defweak)
11997 {
11998 sym_value = hash->elf.root.u.def.value;
11999 if (sym_sec->output_section != NULL)
12000 ok_dest = TRUE;
12001 }
12002 else if (hash->elf.root.type == bfd_link_hash_undefweak
12003 || hash->elf.root.type == bfd_link_hash_undefined)
12004 {
12005 /* Recognise an old ABI func code entry sym, and
12006 use the func descriptor sym instead if it is
12007 defined. */
12008 if (hash->elf.root.root.string[0] == '.'
12009 && (fdh = lookup_fdh (hash, htab)) != NULL)
12010 {
12011 if (fdh->elf.root.type == bfd_link_hash_defined
12012 || fdh->elf.root.type == bfd_link_hash_defweak)
12013 {
12014 sym_sec = fdh->elf.root.u.def.section;
12015 sym_value = fdh->elf.root.u.def.value;
12016 if (sym_sec->output_section != NULL)
12017 ok_dest = TRUE;
12018 }
12019 else
12020 fdh = NULL;
12021 }
12022 }
12023 else
12024 {
12025 bfd_set_error (bfd_error_bad_value);
12026 goto error_ret_free_internal;
12027 }
12028
12029 destination = 0;
12030 local_off = 0;
12031 if (ok_dest)
12032 {
12033 sym_value += irela->r_addend;
12034 destination = (sym_value
12035 + sym_sec->output_offset
12036 + sym_sec->output_section->vma);
12037 local_off = PPC64_LOCAL_ENTRY_OFFSET (hash
12038 ? hash->elf.other
12039 : sym->st_other);
12040 }
12041
12042 code_sec = sym_sec;
12043 code_value = sym_value;
12044 opd = get_opd_info (sym_sec);
12045 if (opd != NULL)
12046 {
12047 bfd_vma dest;
12048
12049 if (hash == NULL && opd->adjust != NULL)
12050 {
12051 long adjust = opd->adjust[sym_value / 8];
12052 if (adjust == -1)
12053 continue;
12054 code_value += adjust;
12055 sym_value += adjust;
12056 }
12057 dest = opd_entry_value (sym_sec, sym_value,
12058 &code_sec, &code_value, FALSE);
12059 if (dest != (bfd_vma) -1)
12060 {
12061 destination = dest;
12062 if (fdh != NULL)
12063 {
12064 /* Fixup old ABI sym to point at code
12065 entry. */
12066 hash->elf.root.type = bfd_link_hash_defweak;
12067 hash->elf.root.u.def.section = code_sec;
12068 hash->elf.root.u.def.value = code_value;
12069 }
12070 }
12071 }
12072
12073 /* Determine what (if any) linker stub is needed. */
12074 plt_ent = NULL;
12075 stub_type = ppc_type_of_stub (section, irela, &hash,
12076 &plt_ent, destination,
12077 local_off);
12078
12079 if (stub_type != ppc_stub_plt_call)
12080 {
12081 /* Check whether we need a TOC adjusting stub.
12082 Since the linker pastes together pieces from
12083 different object files when creating the
12084 _init and _fini functions, it may be that a
12085 call to what looks like a local sym is in
12086 fact a call needing a TOC adjustment. */
12087 if (code_sec != NULL
12088 && code_sec->output_section != NULL
12089 && (htab->stub_group[code_sec->id].toc_off
12090 != htab->stub_group[section->id].toc_off)
12091 && (code_sec->has_toc_reloc
12092 || code_sec->makes_toc_func_call))
12093 stub_type = ppc_stub_long_branch_r2off;
12094 }
12095
12096 if (stub_type == ppc_stub_none)
12097 continue;
12098
12099 /* __tls_get_addr calls might be eliminated. */
12100 if (stub_type != ppc_stub_plt_call
12101 && hash != NULL
12102 && (hash == htab->tls_get_addr
12103 || hash == htab->tls_get_addr_fd)
12104 && section->has_tls_reloc
12105 && irela != internal_relocs)
12106 {
12107 /* Get tls info. */
12108 unsigned char *tls_mask;
12109
12110 if (!get_tls_mask (&tls_mask, NULL, NULL, &local_syms,
12111 irela - 1, input_bfd))
12112 goto error_ret_free_internal;
12113 if (*tls_mask != 0)
12114 continue;
12115 }
12116
12117 if (stub_type == ppc_stub_plt_call
12118 && irela + 1 < irelaend
12119 && irela[1].r_offset == irela->r_offset + 4
12120 && ELF64_R_TYPE (irela[1].r_info) == R_PPC64_TOCSAVE)
12121 {
12122 if (!tocsave_find (htab, INSERT,
12123 &local_syms, irela + 1, input_bfd))
12124 goto error_ret_free_internal;
12125 }
12126 else if (stub_type == ppc_stub_plt_call)
12127 stub_type = ppc_stub_plt_call_r2save;
12128
12129 /* Support for grouping stub sections. */
12130 id_sec = htab->stub_group[section->id].link_sec;
12131
12132 /* Get the name of this stub. */
12133 stub_name = ppc_stub_name (id_sec, sym_sec, hash, irela);
12134 if (!stub_name)
12135 goto error_ret_free_internal;
12136
12137 stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
12138 stub_name, FALSE, FALSE);
12139 if (stub_entry != NULL)
12140 {
12141 /* The proper stub has already been created. */
12142 free (stub_name);
12143 if (stub_type == ppc_stub_plt_call_r2save)
12144 stub_entry->stub_type = stub_type;
12145 continue;
12146 }
12147
12148 stub_entry = ppc_add_stub (stub_name, section, info);
12149 if (stub_entry == NULL)
12150 {
12151 free (stub_name);
12152 error_ret_free_internal:
12153 if (elf_section_data (section)->relocs == NULL)
12154 free (internal_relocs);
12155 error_ret_free_local:
12156 if (local_syms != NULL
12157 && (symtab_hdr->contents
12158 != (unsigned char *) local_syms))
12159 free (local_syms);
12160 return FALSE;
12161 }
12162
12163 stub_entry->stub_type = stub_type;
12164 if (stub_type != ppc_stub_plt_call
12165 && stub_type != ppc_stub_plt_call_r2save)
12166 {
12167 stub_entry->target_value = code_value;
12168 stub_entry->target_section = code_sec;
12169 }
12170 else
12171 {
12172 stub_entry->target_value = sym_value;
12173 stub_entry->target_section = sym_sec;
12174 }
12175 stub_entry->h = hash;
12176 stub_entry->plt_ent = plt_ent;
12177 stub_entry->other = hash ? hash->elf.other : sym->st_other;
12178
12179 if (stub_entry->h != NULL)
12180 htab->stub_globals += 1;
12181 }
12182
12183 /* We're done with the internal relocs, free them. */
12184 if (elf_section_data (section)->relocs != internal_relocs)
12185 free (internal_relocs);
12186 }
12187
12188 if (local_syms != NULL
12189 && symtab_hdr->contents != (unsigned char *) local_syms)
12190 {
12191 if (!info->keep_memory)
12192 free (local_syms);
12193 else
12194 symtab_hdr->contents = (unsigned char *) local_syms;
12195 }
12196 }
12197
12198 /* We may have added some stubs. Find out the new size of the
12199 stub sections. */
12200 for (stub_sec = htab->stub_bfd->sections;
12201 stub_sec != NULL;
12202 stub_sec = stub_sec->next)
12203 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12204 {
12205 stub_sec->rawsize = stub_sec->size;
12206 stub_sec->size = 0;
12207 stub_sec->reloc_count = 0;
12208 stub_sec->flags &= ~SEC_RELOC;
12209 }
12210
12211 htab->brlt->size = 0;
12212 htab->brlt->reloc_count = 0;
12213 htab->brlt->flags &= ~SEC_RELOC;
12214 if (htab->relbrlt != NULL)
12215 htab->relbrlt->size = 0;
12216
12217 bfd_hash_traverse (&htab->stub_hash_table, ppc_size_one_stub, info);
12218
12219 if (info->emitrelocations
12220 && htab->glink != NULL && htab->glink->size != 0)
12221 {
12222 htab->glink->reloc_count = 1;
12223 htab->glink->flags |= SEC_RELOC;
12224 }
12225
12226 if (htab->glink_eh_frame != NULL
12227 && !bfd_is_abs_section (htab->glink_eh_frame->output_section)
12228 && htab->glink_eh_frame->output_section->size != 0)
12229 {
12230 size_t size = 0, align;
12231
12232 for (stub_sec = htab->stub_bfd->sections;
12233 stub_sec != NULL;
12234 stub_sec = stub_sec->next)
12235 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12236 size += 20;
12237 if (htab->glink != NULL && htab->glink->size != 0)
12238 size += 24;
12239 if (size != 0)
12240 size += sizeof (glink_eh_frame_cie);
12241 align = 1;
12242 align <<= htab->glink_eh_frame->output_section->alignment_power;
12243 align -= 1;
12244 size = (size + align) & ~align;
12245 htab->glink_eh_frame->rawsize = htab->glink_eh_frame->size;
12246 htab->glink_eh_frame->size = size;
12247 }
12248
12249 if (htab->plt_stub_align != 0)
12250 for (stub_sec = htab->stub_bfd->sections;
12251 stub_sec != NULL;
12252 stub_sec = stub_sec->next)
12253 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12254 stub_sec->size = ((stub_sec->size + (1 << htab->plt_stub_align) - 1)
12255 & (-1 << htab->plt_stub_align));
12256
12257 for (stub_sec = htab->stub_bfd->sections;
12258 stub_sec != NULL;
12259 stub_sec = stub_sec->next)
12260 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
12261 && stub_sec->rawsize != stub_sec->size)
12262 break;
12263
12264 /* Exit from this loop when no stubs have been added, and no stubs
12265 have changed size. */
12266 if (stub_sec == NULL
12267 && (htab->glink_eh_frame == NULL
12268 || htab->glink_eh_frame->rawsize == htab->glink_eh_frame->size))
12269 break;
12270
12271 /* Ask the linker to do its stuff. */
12272 (*htab->layout_sections_again) ();
12273 }
12274
12275 maybe_strip_output (info, htab->brlt);
12276 if (htab->glink_eh_frame != NULL)
12277 maybe_strip_output (info, htab->glink_eh_frame);
12278
12279 return TRUE;
12280 }
12281
12282 /* Called after we have determined section placement. If sections
12283 move, we'll be called again. Provide a value for TOCstart. */
12284
12285 bfd_vma
12286 ppc64_elf_set_toc (struct bfd_link_info *info, bfd *obfd)
12287 {
12288 asection *s;
12289 bfd_vma TOCstart;
12290
12291 /* The TOC consists of sections .got, .toc, .tocbss, .plt in that
12292 order. The TOC starts where the first of these sections starts. */
12293 s = bfd_get_section_by_name (obfd, ".got");
12294 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12295 s = bfd_get_section_by_name (obfd, ".toc");
12296 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12297 s = bfd_get_section_by_name (obfd, ".tocbss");
12298 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12299 s = bfd_get_section_by_name (obfd, ".plt");
12300 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12301 {
12302 /* This may happen for
12303 o references to TOC base (SYM@toc / TOC[tc0]) without a
12304 .toc directive
12305 o bad linker script
12306 o --gc-sections and empty TOC sections
12307
12308 FIXME: Warn user? */
12309
12310 /* Look for a likely section. We probably won't even be
12311 using TOCstart. */
12312 for (s = obfd->sections; s != NULL; s = s->next)
12313 if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_READONLY
12314 | SEC_EXCLUDE))
12315 == (SEC_ALLOC | SEC_SMALL_DATA))
12316 break;
12317 if (s == NULL)
12318 for (s = obfd->sections; s != NULL; s = s->next)
12319 if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_EXCLUDE))
12320 == (SEC_ALLOC | SEC_SMALL_DATA))
12321 break;
12322 if (s == NULL)
12323 for (s = obfd->sections; s != NULL; s = s->next)
12324 if ((s->flags & (SEC_ALLOC | SEC_READONLY | SEC_EXCLUDE))
12325 == SEC_ALLOC)
12326 break;
12327 if (s == NULL)
12328 for (s = obfd->sections; s != NULL; s = s->next)
12329 if ((s->flags & (SEC_ALLOC | SEC_EXCLUDE)) == SEC_ALLOC)
12330 break;
12331 }
12332
12333 TOCstart = 0;
12334 if (s != NULL)
12335 TOCstart = s->output_section->vma + s->output_offset;
12336
12337 _bfd_set_gp_value (obfd, TOCstart);
12338
12339 if (info != NULL && s != NULL && is_ppc64_elf (obfd))
12340 {
12341 struct ppc_link_hash_table *htab = ppc_hash_table (info);
12342
12343 if (htab != NULL
12344 && htab->elf.hgot != NULL)
12345 {
12346 htab->elf.hgot->root.u.def.value = TOC_BASE_OFF;
12347 htab->elf.hgot->root.u.def.section = s;
12348 }
12349 }
12350 return TOCstart;
12351 }
12352
12353 /* Called via elf_link_hash_traverse from ppc64_elf_build_stubs to
12354 write out any global entry stubs. */
12355
12356 static bfd_boolean
12357 build_global_entry_stubs (struct elf_link_hash_entry *h, void *inf)
12358 {
12359 struct bfd_link_info *info;
12360 struct ppc_link_hash_table *htab;
12361 struct plt_entry *pent;
12362 asection *s;
12363
12364 if (h->root.type == bfd_link_hash_indirect)
12365 return TRUE;
12366
12367 if (!h->pointer_equality_needed)
12368 return TRUE;
12369
12370 if (h->def_regular)
12371 return TRUE;
12372
12373 info = inf;
12374 htab = ppc_hash_table (info);
12375 if (htab == NULL)
12376 return FALSE;
12377
12378 s = htab->glink;
12379 for (pent = h->plt.plist; pent != NULL; pent = pent->next)
12380 if (pent->plt.offset != (bfd_vma) -1
12381 && pent->addend == 0)
12382 {
12383 bfd_byte *p;
12384 asection *plt;
12385 bfd_vma off;
12386
12387 p = s->contents + h->root.u.def.value;
12388 plt = htab->elf.splt;
12389 if (!htab->elf.dynamic_sections_created
12390 || h->dynindx == -1)
12391 plt = htab->elf.iplt;
12392 off = pent->plt.offset + plt->output_offset + plt->output_section->vma;
12393 off -= h->root.u.def.value + s->output_offset + s->output_section->vma;
12394
12395 if (off + 0x80008000 > 0xffffffff || (off & 3) != 0)
12396 {
12397 info->callbacks->einfo
12398 (_("%P: linkage table error against `%T'\n"),
12399 h->root.root.string);
12400 bfd_set_error (bfd_error_bad_value);
12401 htab->stub_error = TRUE;
12402 }
12403
12404 if (PPC_HA (off) != 0)
12405 {
12406 bfd_put_32 (s->owner, ADDIS_R12_R12 | PPC_HA (off), p);
12407 p += 4;
12408 }
12409 bfd_put_32 (s->owner, LD_R12_0R12 | PPC_LO (off), p);
12410 p += 4;
12411 bfd_put_32 (s->owner, MTCTR_R12, p);
12412 p += 4;
12413 bfd_put_32 (s->owner, BCTR, p);
12414 break;
12415 }
12416 return TRUE;
12417 }
12418
12419 /* Build all the stubs associated with the current output file.
12420 The stubs are kept in a hash table attached to the main linker
12421 hash table. This function is called via gldelf64ppc_finish. */
12422
12423 bfd_boolean
12424 ppc64_elf_build_stubs (bfd_boolean emit_stub_syms,
12425 struct bfd_link_info *info,
12426 char **stats)
12427 {
12428 struct ppc_link_hash_table *htab = ppc_hash_table (info);
12429 asection *stub_sec;
12430 bfd_byte *p;
12431 int stub_sec_count = 0;
12432
12433 if (htab == NULL)
12434 return FALSE;
12435
12436 htab->emit_stub_syms = emit_stub_syms;
12437
12438 /* Allocate memory to hold the linker stubs. */
12439 for (stub_sec = htab->stub_bfd->sections;
12440 stub_sec != NULL;
12441 stub_sec = stub_sec->next)
12442 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
12443 && stub_sec->size != 0)
12444 {
12445 stub_sec->contents = bfd_zalloc (htab->stub_bfd, stub_sec->size);
12446 if (stub_sec->contents == NULL)
12447 return FALSE;
12448 /* We want to check that built size is the same as calculated
12449 size. rawsize is a convenient location to use. */
12450 stub_sec->rawsize = stub_sec->size;
12451 stub_sec->size = 0;
12452 }
12453
12454 if (htab->glink != NULL && htab->glink->size != 0)
12455 {
12456 unsigned int indx;
12457 bfd_vma plt0;
12458
12459 /* Build the .glink plt call stub. */
12460 if (htab->emit_stub_syms)
12461 {
12462 struct elf_link_hash_entry *h;
12463 h = elf_link_hash_lookup (&htab->elf, "__glink_PLTresolve",
12464 TRUE, FALSE, FALSE);
12465 if (h == NULL)
12466 return FALSE;
12467 if (h->root.type == bfd_link_hash_new)
12468 {
12469 h->root.type = bfd_link_hash_defined;
12470 h->root.u.def.section = htab->glink;
12471 h->root.u.def.value = 8;
12472 h->ref_regular = 1;
12473 h->def_regular = 1;
12474 h->ref_regular_nonweak = 1;
12475 h->forced_local = 1;
12476 h->non_elf = 0;
12477 }
12478 }
12479 plt0 = (htab->elf.splt->output_section->vma
12480 + htab->elf.splt->output_offset
12481 - 16);
12482 if (info->emitrelocations)
12483 {
12484 Elf_Internal_Rela *r = get_relocs (htab->glink, 1);
12485 if (r == NULL)
12486 return FALSE;
12487 r->r_offset = (htab->glink->output_offset
12488 + htab->glink->output_section->vma);
12489 r->r_info = ELF64_R_INFO (0, R_PPC64_REL64);
12490 r->r_addend = plt0;
12491 }
12492 p = htab->glink->contents;
12493 plt0 -= htab->glink->output_section->vma + htab->glink->output_offset;
12494 bfd_put_64 (htab->glink->owner, plt0, p);
12495 p += 8;
12496 if (htab->opd_abi)
12497 {
12498 bfd_put_32 (htab->glink->owner, MFLR_R12, p);
12499 p += 4;
12500 bfd_put_32 (htab->glink->owner, BCL_20_31, p);
12501 p += 4;
12502 bfd_put_32 (htab->glink->owner, MFLR_R11, p);
12503 p += 4;
12504 bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
12505 p += 4;
12506 bfd_put_32 (htab->glink->owner, MTLR_R12, p);
12507 p += 4;
12508 bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
12509 p += 4;
12510 bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
12511 p += 4;
12512 bfd_put_32 (htab->glink->owner, LD_R2_0R11 | 8, p);
12513 p += 4;
12514 bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
12515 p += 4;
12516 bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 16, p);
12517 p += 4;
12518 }
12519 else
12520 {
12521 bfd_put_32 (htab->glink->owner, MFLR_R0, p);
12522 p += 4;
12523 bfd_put_32 (htab->glink->owner, BCL_20_31, p);
12524 p += 4;
12525 bfd_put_32 (htab->glink->owner, MFLR_R11, p);
12526 p += 4;
12527 bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
12528 p += 4;
12529 bfd_put_32 (htab->glink->owner, MTLR_R0, p);
12530 p += 4;
12531 bfd_put_32 (htab->glink->owner, SUB_R12_R12_R11, p);
12532 p += 4;
12533 bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
12534 p += 4;
12535 bfd_put_32 (htab->glink->owner, ADDI_R0_R12 | (-48 & 0xffff), p);
12536 p += 4;
12537 bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
12538 p += 4;
12539 bfd_put_32 (htab->glink->owner, SRDI_R0_R0_2, p);
12540 p += 4;
12541 bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
12542 p += 4;
12543 bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 8, p);
12544 p += 4;
12545 }
12546 bfd_put_32 (htab->glink->owner, BCTR, p);
12547 p += 4;
12548 while (p - htab->glink->contents < GLINK_CALL_STUB_SIZE)
12549 {
12550 bfd_put_32 (htab->glink->owner, NOP, p);
12551 p += 4;
12552 }
12553
12554 /* Build the .glink lazy link call stubs. */
12555 indx = 0;
12556 while (p < htab->glink->contents + htab->glink->rawsize)
12557 {
12558 if (htab->opd_abi)
12559 {
12560 if (indx < 0x8000)
12561 {
12562 bfd_put_32 (htab->glink->owner, LI_R0_0 | indx, p);
12563 p += 4;
12564 }
12565 else
12566 {
12567 bfd_put_32 (htab->glink->owner, LIS_R0_0 | PPC_HI (indx), p);
12568 p += 4;
12569 bfd_put_32 (htab->glink->owner, ORI_R0_R0_0 | PPC_LO (indx),
12570 p);
12571 p += 4;
12572 }
12573 }
12574 bfd_put_32 (htab->glink->owner,
12575 B_DOT | ((htab->glink->contents - p + 8) & 0x3fffffc), p);
12576 indx++;
12577 p += 4;
12578 }
12579
12580 /* Build .glink global entry stubs. */
12581 if (htab->glink->size > htab->glink->rawsize)
12582 elf_link_hash_traverse (&htab->elf, build_global_entry_stubs, info);
12583 }
12584
12585 if (htab->brlt->size != 0)
12586 {
12587 htab->brlt->contents = bfd_zalloc (htab->brlt->owner,
12588 htab->brlt->size);
12589 if (htab->brlt->contents == NULL)
12590 return FALSE;
12591 }
12592 if (htab->relbrlt != NULL && htab->relbrlt->size != 0)
12593 {
12594 htab->relbrlt->contents = bfd_zalloc (htab->relbrlt->owner,
12595 htab->relbrlt->size);
12596 if (htab->relbrlt->contents == NULL)
12597 return FALSE;
12598 }
12599
12600 if (htab->glink_eh_frame != NULL
12601 && htab->glink_eh_frame->size != 0)
12602 {
12603 bfd_vma val;
12604 bfd_byte *last_fde;
12605 size_t last_fde_len, size, align, pad;
12606
12607 p = bfd_zalloc (htab->glink_eh_frame->owner, htab->glink_eh_frame->size);
12608 if (p == NULL)
12609 return FALSE;
12610 htab->glink_eh_frame->contents = p;
12611 last_fde = p;
12612
12613 htab->glink_eh_frame->rawsize = htab->glink_eh_frame->size;
12614
12615 memcpy (p, glink_eh_frame_cie, sizeof (glink_eh_frame_cie));
12616 /* CIE length (rewrite in case little-endian). */
12617 last_fde_len = sizeof (glink_eh_frame_cie) - 4;
12618 bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
12619 p += sizeof (glink_eh_frame_cie);
12620
12621 for (stub_sec = htab->stub_bfd->sections;
12622 stub_sec != NULL;
12623 stub_sec = stub_sec->next)
12624 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12625 {
12626 last_fde = p;
12627 last_fde_len = 16;
12628 /* FDE length. */
12629 bfd_put_32 (htab->elf.dynobj, 16, p);
12630 p += 4;
12631 /* CIE pointer. */
12632 val = p - htab->glink_eh_frame->contents;
12633 bfd_put_32 (htab->elf.dynobj, val, p);
12634 p += 4;
12635 /* Offset to stub section. */
12636 val = (stub_sec->output_section->vma
12637 + stub_sec->output_offset);
12638 val -= (htab->glink_eh_frame->output_section->vma
12639 + htab->glink_eh_frame->output_offset);
12640 val -= p - htab->glink_eh_frame->contents;
12641 if (val + 0x80000000 > 0xffffffff)
12642 {
12643 info->callbacks->einfo
12644 (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
12645 stub_sec->name);
12646 return FALSE;
12647 }
12648 bfd_put_32 (htab->elf.dynobj, val, p);
12649 p += 4;
12650 /* stub section size. */
12651 bfd_put_32 (htab->elf.dynobj, stub_sec->rawsize, p);
12652 p += 4;
12653 /* Augmentation. */
12654 p += 1;
12655 /* Pad. */
12656 p += 3;
12657 }
12658 if (htab->glink != NULL && htab->glink->size != 0)
12659 {
12660 last_fde = p;
12661 last_fde_len = 20;
12662 /* FDE length. */
12663 bfd_put_32 (htab->elf.dynobj, 20, p);
12664 p += 4;
12665 /* CIE pointer. */
12666 val = p - htab->glink_eh_frame->contents;
12667 bfd_put_32 (htab->elf.dynobj, val, p);
12668 p += 4;
12669 /* Offset to .glink. */
12670 val = (htab->glink->output_section->vma
12671 + htab->glink->output_offset
12672 + 8);
12673 val -= (htab->glink_eh_frame->output_section->vma
12674 + htab->glink_eh_frame->output_offset);
12675 val -= p - htab->glink_eh_frame->contents;
12676 if (val + 0x80000000 > 0xffffffff)
12677 {
12678 info->callbacks->einfo
12679 (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
12680 htab->glink->name);
12681 return FALSE;
12682 }
12683 bfd_put_32 (htab->elf.dynobj, val, p);
12684 p += 4;
12685 /* .glink size. */
12686 bfd_put_32 (htab->elf.dynobj, htab->glink->size - 8, p);
12687 p += 4;
12688 /* Augmentation. */
12689 p += 1;
12690
12691 *p++ = DW_CFA_advance_loc + 1;
12692 *p++ = DW_CFA_register;
12693 *p++ = 65;
12694 *p++ = 12;
12695 *p++ = DW_CFA_advance_loc + 4;
12696 *p++ = DW_CFA_restore_extended;
12697 *p++ = 65;
12698 }
12699 /* Subsume any padding into the last FDE if user .eh_frame
12700 sections are aligned more than glink_eh_frame. Otherwise any
12701 zero padding will be seen as a terminator. */
12702 size = p - htab->glink_eh_frame->contents;
12703 align = 1;
12704 align <<= htab->glink_eh_frame->output_section->alignment_power;
12705 align -= 1;
12706 pad = ((size + align) & ~align) - size;
12707 htab->glink_eh_frame->size = size + pad;
12708 bfd_put_32 (htab->elf.dynobj, last_fde_len + pad, last_fde);
12709 }
12710
12711 /* Build the stubs as directed by the stub hash table. */
12712 bfd_hash_traverse (&htab->stub_hash_table, ppc_build_one_stub, info);
12713
12714 if (htab->relbrlt != NULL)
12715 htab->relbrlt->reloc_count = 0;
12716
12717 if (htab->plt_stub_align != 0)
12718 for (stub_sec = htab->stub_bfd->sections;
12719 stub_sec != NULL;
12720 stub_sec = stub_sec->next)
12721 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12722 stub_sec->size = ((stub_sec->size + (1 << htab->plt_stub_align) - 1)
12723 & (-1 << htab->plt_stub_align));
12724
12725 for (stub_sec = htab->stub_bfd->sections;
12726 stub_sec != NULL;
12727 stub_sec = stub_sec->next)
12728 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12729 {
12730 stub_sec_count += 1;
12731 if (stub_sec->rawsize != stub_sec->size)
12732 break;
12733 }
12734
12735 if (stub_sec != NULL
12736 || (htab->glink_eh_frame != NULL
12737 && htab->glink_eh_frame->rawsize != htab->glink_eh_frame->size))
12738 {
12739 htab->stub_error = TRUE;
12740 info->callbacks->einfo (_("%P: stubs don't match calculated size\n"));
12741 }
12742
12743 if (htab->stub_error)
12744 return FALSE;
12745
12746 if (stats != NULL)
12747 {
12748 *stats = bfd_malloc (500);
12749 if (*stats == NULL)
12750 return FALSE;
12751
12752 sprintf (*stats, _("linker stubs in %u group%s\n"
12753 " branch %lu\n"
12754 " toc adjust %lu\n"
12755 " long branch %lu\n"
12756 " long toc adj %lu\n"
12757 " plt call %lu\n"
12758 " plt call toc %lu"),
12759 stub_sec_count,
12760 stub_sec_count == 1 ? "" : "s",
12761 htab->stub_count[ppc_stub_long_branch - 1],
12762 htab->stub_count[ppc_stub_long_branch_r2off - 1],
12763 htab->stub_count[ppc_stub_plt_branch - 1],
12764 htab->stub_count[ppc_stub_plt_branch_r2off - 1],
12765 htab->stub_count[ppc_stub_plt_call - 1],
12766 htab->stub_count[ppc_stub_plt_call_r2save - 1]);
12767 }
12768 return TRUE;
12769 }
12770
12771 /* This function undoes the changes made by add_symbol_adjust. */
12772
12773 static bfd_boolean
12774 undo_symbol_twiddle (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
12775 {
12776 struct ppc_link_hash_entry *eh;
12777
12778 if (h->root.type == bfd_link_hash_indirect)
12779 return TRUE;
12780
12781 eh = (struct ppc_link_hash_entry *) h;
12782 if (eh->elf.root.type != bfd_link_hash_undefweak || !eh->was_undefined)
12783 return TRUE;
12784
12785 eh->elf.root.type = bfd_link_hash_undefined;
12786 return TRUE;
12787 }
12788
12789 void
12790 ppc64_elf_restore_symbols (struct bfd_link_info *info)
12791 {
12792 struct ppc_link_hash_table *htab = ppc_hash_table (info);
12793
12794 if (htab != NULL)
12795 elf_link_hash_traverse (&htab->elf, undo_symbol_twiddle, info);
12796 }
12797
12798 /* What to do when ld finds relocations against symbols defined in
12799 discarded sections. */
12800
12801 static unsigned int
12802 ppc64_elf_action_discarded (asection *sec)
12803 {
12804 if (strcmp (".opd", sec->name) == 0)
12805 return 0;
12806
12807 if (strcmp (".toc", sec->name) == 0)
12808 return 0;
12809
12810 if (strcmp (".toc1", sec->name) == 0)
12811 return 0;
12812
12813 return _bfd_elf_default_action_discarded (sec);
12814 }
12815
12816 /* The RELOCATE_SECTION function is called by the ELF backend linker
12817 to handle the relocations for a section.
12818
12819 The relocs are always passed as Rela structures; if the section
12820 actually uses Rel structures, the r_addend field will always be
12821 zero.
12822
12823 This function is responsible for adjust the section contents as
12824 necessary, and (if using Rela relocs and generating a
12825 relocatable output file) adjusting the reloc addend as
12826 necessary.
12827
12828 This function does not have to worry about setting the reloc
12829 address or the reloc symbol index.
12830
12831 LOCAL_SYMS is a pointer to the swapped in local symbols.
12832
12833 LOCAL_SECTIONS is an array giving the section in the input file
12834 corresponding to the st_shndx field of each local symbol.
12835
12836 The global hash table entry for the global symbols can be found
12837 via elf_sym_hashes (input_bfd).
12838
12839 When generating relocatable output, this function must handle
12840 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
12841 going to be the section symbol corresponding to the output
12842 section, which means that the addend must be adjusted
12843 accordingly. */
12844
12845 static bfd_boolean
12846 ppc64_elf_relocate_section (bfd *output_bfd,
12847 struct bfd_link_info *info,
12848 bfd *input_bfd,
12849 asection *input_section,
12850 bfd_byte *contents,
12851 Elf_Internal_Rela *relocs,
12852 Elf_Internal_Sym *local_syms,
12853 asection **local_sections)
12854 {
12855 struct ppc_link_hash_table *htab;
12856 Elf_Internal_Shdr *symtab_hdr;
12857 struct elf_link_hash_entry **sym_hashes;
12858 Elf_Internal_Rela *rel;
12859 Elf_Internal_Rela *relend;
12860 Elf_Internal_Rela outrel;
12861 bfd_byte *loc;
12862 struct got_entry **local_got_ents;
12863 bfd_vma TOCstart;
12864 bfd_boolean ret = TRUE;
12865 bfd_boolean is_opd;
12866 /* Assume 'at' branch hints. */
12867 bfd_boolean is_isa_v2 = TRUE;
12868 bfd_vma d_offset = (bfd_big_endian (output_bfd) ? 2 : 0);
12869
12870 /* Initialize howto table if needed. */
12871 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
12872 ppc_howto_init ();
12873
12874 htab = ppc_hash_table (info);
12875 if (htab == NULL)
12876 return FALSE;
12877
12878 /* Don't relocate stub sections. */
12879 if (input_section->owner == htab->stub_bfd)
12880 return TRUE;
12881
12882 BFD_ASSERT (is_ppc64_elf (input_bfd));
12883
12884 local_got_ents = elf_local_got_ents (input_bfd);
12885 TOCstart = elf_gp (output_bfd);
12886 symtab_hdr = &elf_symtab_hdr (input_bfd);
12887 sym_hashes = elf_sym_hashes (input_bfd);
12888 is_opd = ppc64_elf_section_data (input_section)->sec_type == sec_opd;
12889
12890 rel = relocs;
12891 relend = relocs + input_section->reloc_count;
12892 for (; rel < relend; rel++)
12893 {
12894 enum elf_ppc64_reloc_type r_type;
12895 bfd_vma addend;
12896 bfd_reloc_status_type r;
12897 Elf_Internal_Sym *sym;
12898 asection *sec;
12899 struct elf_link_hash_entry *h_elf;
12900 struct ppc_link_hash_entry *h;
12901 struct ppc_link_hash_entry *fdh;
12902 const char *sym_name;
12903 unsigned long r_symndx, toc_symndx;
12904 bfd_vma toc_addend;
12905 unsigned char tls_mask, tls_gd, tls_type;
12906 unsigned char sym_type;
12907 bfd_vma relocation;
12908 bfd_boolean unresolved_reloc;
12909 bfd_boolean warned;
12910 enum { DEST_NORMAL, DEST_OPD, DEST_STUB } reloc_dest;
12911 unsigned int insn;
12912 unsigned int mask;
12913 struct ppc_stub_hash_entry *stub_entry;
12914 bfd_vma max_br_offset;
12915 bfd_vma from;
12916 const Elf_Internal_Rela orig_rel = *rel;
12917
12918 r_type = ELF64_R_TYPE (rel->r_info);
12919 r_symndx = ELF64_R_SYM (rel->r_info);
12920
12921 /* For old style R_PPC64_TOC relocs with a zero symbol, use the
12922 symbol of the previous ADDR64 reloc. The symbol gives us the
12923 proper TOC base to use. */
12924 if (rel->r_info == ELF64_R_INFO (0, R_PPC64_TOC)
12925 && rel != relocs
12926 && ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_ADDR64
12927 && is_opd)
12928 r_symndx = ELF64_R_SYM (rel[-1].r_info);
12929
12930 sym = NULL;
12931 sec = NULL;
12932 h_elf = NULL;
12933 sym_name = NULL;
12934 unresolved_reloc = FALSE;
12935 warned = FALSE;
12936
12937 if (r_symndx < symtab_hdr->sh_info)
12938 {
12939 /* It's a local symbol. */
12940 struct _opd_sec_data *opd;
12941
12942 sym = local_syms + r_symndx;
12943 sec = local_sections[r_symndx];
12944 sym_name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym, sec);
12945 sym_type = ELF64_ST_TYPE (sym->st_info);
12946 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
12947 opd = get_opd_info (sec);
12948 if (opd != NULL && opd->adjust != NULL)
12949 {
12950 long adjust = opd->adjust[(sym->st_value + rel->r_addend) / 8];
12951 if (adjust == -1)
12952 relocation = 0;
12953 else
12954 {
12955 /* If this is a relocation against the opd section sym
12956 and we have edited .opd, adjust the reloc addend so
12957 that ld -r and ld --emit-relocs output is correct.
12958 If it is a reloc against some other .opd symbol,
12959 then the symbol value will be adjusted later. */
12960 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
12961 rel->r_addend += adjust;
12962 else
12963 relocation += adjust;
12964 }
12965 }
12966 }
12967 else
12968 {
12969 bfd_boolean ignored;
12970
12971 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
12972 r_symndx, symtab_hdr, sym_hashes,
12973 h_elf, sec, relocation,
12974 unresolved_reloc, warned, ignored);
12975 sym_name = h_elf->root.root.string;
12976 sym_type = h_elf->type;
12977 if (sec != NULL
12978 && sec->owner == output_bfd
12979 && strcmp (sec->name, ".opd") == 0)
12980 {
12981 /* This is a symbol defined in a linker script. All
12982 such are defined in output sections, even those
12983 defined by simple assignment from a symbol defined in
12984 an input section. Transfer the symbol to an
12985 appropriate input .opd section, so that a branch to
12986 this symbol will be mapped to the location specified
12987 by the opd entry. */
12988 struct bfd_link_order *lo;
12989 for (lo = sec->map_head.link_order; lo != NULL; lo = lo->next)
12990 if (lo->type == bfd_indirect_link_order)
12991 {
12992 asection *isec = lo->u.indirect.section;
12993 if (h_elf->root.u.def.value >= isec->output_offset
12994 && h_elf->root.u.def.value < (isec->output_offset
12995 + isec->size))
12996 {
12997 h_elf->root.u.def.value -= isec->output_offset;
12998 h_elf->root.u.def.section = isec;
12999 sec = isec;
13000 break;
13001 }
13002 }
13003 }
13004 }
13005 h = (struct ppc_link_hash_entry *) h_elf;
13006
13007 if (sec != NULL && discarded_section (sec))
13008 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
13009 rel, 1, relend,
13010 ppc64_elf_howto_table[r_type], 0,
13011 contents);
13012
13013 if (info->relocatable)
13014 continue;
13015
13016 if (h != NULL && &h->elf == htab->elf.hgot)
13017 {
13018 relocation = (TOCstart
13019 + htab->stub_group[input_section->id].toc_off);
13020 sec = bfd_abs_section_ptr;
13021 unresolved_reloc = FALSE;
13022 }
13023
13024 /* TLS optimizations. Replace instruction sequences and relocs
13025 based on information we collected in tls_optimize. We edit
13026 RELOCS so that --emit-relocs will output something sensible
13027 for the final instruction stream. */
13028 tls_mask = 0;
13029 tls_gd = 0;
13030 toc_symndx = 0;
13031 if (h != NULL)
13032 tls_mask = h->tls_mask;
13033 else if (local_got_ents != NULL)
13034 {
13035 struct plt_entry **local_plt = (struct plt_entry **)
13036 (local_got_ents + symtab_hdr->sh_info);
13037 unsigned char *lgot_masks = (unsigned char *)
13038 (local_plt + symtab_hdr->sh_info);
13039 tls_mask = lgot_masks[r_symndx];
13040 }
13041 if (tls_mask == 0
13042 && (r_type == R_PPC64_TLS
13043 || r_type == R_PPC64_TLSGD
13044 || r_type == R_PPC64_TLSLD))
13045 {
13046 /* Check for toc tls entries. */
13047 unsigned char *toc_tls;
13048
13049 if (!get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
13050 &local_syms, rel, input_bfd))
13051 return FALSE;
13052
13053 if (toc_tls)
13054 tls_mask = *toc_tls;
13055 }
13056
13057 /* Check that tls relocs are used with tls syms, and non-tls
13058 relocs are used with non-tls syms. */
13059 if (r_symndx != STN_UNDEF
13060 && r_type != R_PPC64_NONE
13061 && (h == NULL
13062 || h->elf.root.type == bfd_link_hash_defined
13063 || h->elf.root.type == bfd_link_hash_defweak)
13064 && (IS_PPC64_TLS_RELOC (r_type)
13065 != (sym_type == STT_TLS
13066 || (sym_type == STT_SECTION
13067 && (sec->flags & SEC_THREAD_LOCAL) != 0))))
13068 {
13069 if (tls_mask != 0
13070 && (r_type == R_PPC64_TLS
13071 || r_type == R_PPC64_TLSGD
13072 || r_type == R_PPC64_TLSLD))
13073 /* R_PPC64_TLS is OK against a symbol in the TOC. */
13074 ;
13075 else
13076 info->callbacks->einfo
13077 (!IS_PPC64_TLS_RELOC (r_type)
13078 ? _("%P: %H: %s used with TLS symbol `%T'\n")
13079 : _("%P: %H: %s used with non-TLS symbol `%T'\n"),
13080 input_bfd, input_section, rel->r_offset,
13081 ppc64_elf_howto_table[r_type]->name,
13082 sym_name);
13083 }
13084
13085 /* Ensure reloc mapping code below stays sane. */
13086 if (R_PPC64_TOC16_LO_DS != R_PPC64_TOC16_DS + 1
13087 || R_PPC64_TOC16_LO != R_PPC64_TOC16 + 1
13088 || (R_PPC64_GOT_TLSLD16 & 3) != (R_PPC64_GOT_TLSGD16 & 3)
13089 || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TLSGD16_LO & 3)
13090 || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TLSGD16_HI & 3)
13091 || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TLSGD16_HA & 3)
13092 || (R_PPC64_GOT_TLSLD16 & 3) != (R_PPC64_GOT_TPREL16_DS & 3)
13093 || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TPREL16_LO_DS & 3)
13094 || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TPREL16_HI & 3)
13095 || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TPREL16_HA & 3))
13096 abort ();
13097
13098 switch (r_type)
13099 {
13100 default:
13101 break;
13102
13103 case R_PPC64_LO_DS_OPT:
13104 insn = bfd_get_32 (output_bfd, contents + rel->r_offset - d_offset);
13105 if ((insn & (0x3f << 26)) != 58u << 26)
13106 abort ();
13107 insn += (14u << 26) - (58u << 26);
13108 bfd_put_32 (output_bfd, insn, contents + rel->r_offset - d_offset);
13109 r_type = R_PPC64_TOC16_LO;
13110 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13111 break;
13112
13113 case R_PPC64_TOC16:
13114 case R_PPC64_TOC16_LO:
13115 case R_PPC64_TOC16_DS:
13116 case R_PPC64_TOC16_LO_DS:
13117 {
13118 /* Check for toc tls entries. */
13119 unsigned char *toc_tls;
13120 int retval;
13121
13122 retval = get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
13123 &local_syms, rel, input_bfd);
13124 if (retval == 0)
13125 return FALSE;
13126
13127 if (toc_tls)
13128 {
13129 tls_mask = *toc_tls;
13130 if (r_type == R_PPC64_TOC16_DS
13131 || r_type == R_PPC64_TOC16_LO_DS)
13132 {
13133 if (tls_mask != 0
13134 && (tls_mask & (TLS_DTPREL | TLS_TPREL)) == 0)
13135 goto toctprel;
13136 }
13137 else
13138 {
13139 /* If we found a GD reloc pair, then we might be
13140 doing a GD->IE transition. */
13141 if (retval == 2)
13142 {
13143 tls_gd = TLS_TPRELGD;
13144 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13145 goto tls_ldgd_opt;
13146 }
13147 else if (retval == 3)
13148 {
13149 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13150 goto tls_ldgd_opt;
13151 }
13152 }
13153 }
13154 }
13155 break;
13156
13157 case R_PPC64_GOT_TPREL16_HI:
13158 case R_PPC64_GOT_TPREL16_HA:
13159 if (tls_mask != 0
13160 && (tls_mask & TLS_TPREL) == 0)
13161 {
13162 rel->r_offset -= d_offset;
13163 bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
13164 r_type = R_PPC64_NONE;
13165 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13166 }
13167 break;
13168
13169 case R_PPC64_GOT_TPREL16_DS:
13170 case R_PPC64_GOT_TPREL16_LO_DS:
13171 if (tls_mask != 0
13172 && (tls_mask & TLS_TPREL) == 0)
13173 {
13174 toctprel:
13175 insn = bfd_get_32 (output_bfd, contents + rel->r_offset - d_offset);
13176 insn &= 31 << 21;
13177 insn |= 0x3c0d0000; /* addis 0,13,0 */
13178 bfd_put_32 (output_bfd, insn, contents + rel->r_offset - d_offset);
13179 r_type = R_PPC64_TPREL16_HA;
13180 if (toc_symndx != 0)
13181 {
13182 rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
13183 rel->r_addend = toc_addend;
13184 /* We changed the symbol. Start over in order to
13185 get h, sym, sec etc. right. */
13186 rel--;
13187 continue;
13188 }
13189 else
13190 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13191 }
13192 break;
13193
13194 case R_PPC64_TLS:
13195 if (tls_mask != 0
13196 && (tls_mask & TLS_TPREL) == 0)
13197 {
13198 insn = bfd_get_32 (output_bfd, contents + rel->r_offset);
13199 insn = _bfd_elf_ppc_at_tls_transform (insn, 13);
13200 if (insn == 0)
13201 abort ();
13202 bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
13203 /* Was PPC64_TLS which sits on insn boundary, now
13204 PPC64_TPREL16_LO which is at low-order half-word. */
13205 rel->r_offset += d_offset;
13206 r_type = R_PPC64_TPREL16_LO;
13207 if (toc_symndx != 0)
13208 {
13209 rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
13210 rel->r_addend = toc_addend;
13211 /* We changed the symbol. Start over in order to
13212 get h, sym, sec etc. right. */
13213 rel--;
13214 continue;
13215 }
13216 else
13217 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13218 }
13219 break;
13220
13221 case R_PPC64_GOT_TLSGD16_HI:
13222 case R_PPC64_GOT_TLSGD16_HA:
13223 tls_gd = TLS_TPRELGD;
13224 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13225 goto tls_gdld_hi;
13226 break;
13227
13228 case R_PPC64_GOT_TLSLD16_HI:
13229 case R_PPC64_GOT_TLSLD16_HA:
13230 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13231 {
13232 tls_gdld_hi:
13233 if ((tls_mask & tls_gd) != 0)
13234 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
13235 + R_PPC64_GOT_TPREL16_DS);
13236 else
13237 {
13238 rel->r_offset -= d_offset;
13239 bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
13240 r_type = R_PPC64_NONE;
13241 }
13242 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13243 }
13244 break;
13245
13246 case R_PPC64_GOT_TLSGD16:
13247 case R_PPC64_GOT_TLSGD16_LO:
13248 tls_gd = TLS_TPRELGD;
13249 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13250 goto tls_ldgd_opt;
13251 break;
13252
13253 case R_PPC64_GOT_TLSLD16:
13254 case R_PPC64_GOT_TLSLD16_LO:
13255 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13256 {
13257 unsigned int insn1, insn2, insn3;
13258 bfd_vma offset;
13259
13260 tls_ldgd_opt:
13261 offset = (bfd_vma) -1;
13262 /* If not using the newer R_PPC64_TLSGD/LD to mark
13263 __tls_get_addr calls, we must trust that the call
13264 stays with its arg setup insns, ie. that the next
13265 reloc is the __tls_get_addr call associated with
13266 the current reloc. Edit both insns. */
13267 if (input_section->has_tls_get_addr_call
13268 && rel + 1 < relend
13269 && branch_reloc_hash_match (input_bfd, rel + 1,
13270 htab->tls_get_addr,
13271 htab->tls_get_addr_fd))
13272 offset = rel[1].r_offset;
13273 if ((tls_mask & tls_gd) != 0)
13274 {
13275 /* IE */
13276 insn1 = bfd_get_32 (output_bfd,
13277 contents + rel->r_offset - d_offset);
13278 insn1 &= (1 << 26) - (1 << 2);
13279 insn1 |= 58 << 26; /* ld */
13280 insn2 = 0x7c636a14; /* add 3,3,13 */
13281 if (offset != (bfd_vma) -1)
13282 rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13283 if ((tls_mask & TLS_EXPLICIT) == 0)
13284 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
13285 + R_PPC64_GOT_TPREL16_DS);
13286 else
13287 r_type += R_PPC64_TOC16_DS - R_PPC64_TOC16;
13288 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13289 }
13290 else
13291 {
13292 /* LE */
13293 insn1 = 0x3c6d0000; /* addis 3,13,0 */
13294 insn2 = 0x38630000; /* addi 3,3,0 */
13295 if (tls_gd == 0)
13296 {
13297 /* Was an LD reloc. */
13298 if (toc_symndx)
13299 sec = local_sections[toc_symndx];
13300 for (r_symndx = 0;
13301 r_symndx < symtab_hdr->sh_info;
13302 r_symndx++)
13303 if (local_sections[r_symndx] == sec)
13304 break;
13305 if (r_symndx >= symtab_hdr->sh_info)
13306 r_symndx = STN_UNDEF;
13307 rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
13308 if (r_symndx != STN_UNDEF)
13309 rel->r_addend -= (local_syms[r_symndx].st_value
13310 + sec->output_offset
13311 + sec->output_section->vma);
13312 }
13313 else if (toc_symndx != 0)
13314 {
13315 r_symndx = toc_symndx;
13316 rel->r_addend = toc_addend;
13317 }
13318 r_type = R_PPC64_TPREL16_HA;
13319 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13320 if (offset != (bfd_vma) -1)
13321 {
13322 rel[1].r_info = ELF64_R_INFO (r_symndx,
13323 R_PPC64_TPREL16_LO);
13324 rel[1].r_offset = offset + d_offset;
13325 rel[1].r_addend = rel->r_addend;
13326 }
13327 }
13328 bfd_put_32 (output_bfd, insn1,
13329 contents + rel->r_offset - d_offset);
13330 if (offset != (bfd_vma) -1)
13331 {
13332 insn3 = bfd_get_32 (output_bfd,
13333 contents + offset + 4);
13334 if (insn3 == NOP
13335 || insn3 == CROR_151515 || insn3 == CROR_313131)
13336 {
13337 rel[1].r_offset += 4;
13338 bfd_put_32 (output_bfd, insn2, contents + offset + 4);
13339 insn2 = NOP;
13340 }
13341 bfd_put_32 (output_bfd, insn2, contents + offset);
13342 }
13343 if ((tls_mask & tls_gd) == 0
13344 && (tls_gd == 0 || toc_symndx != 0))
13345 {
13346 /* We changed the symbol. Start over in order
13347 to get h, sym, sec etc. right. */
13348 rel--;
13349 continue;
13350 }
13351 }
13352 break;
13353
13354 case R_PPC64_TLSGD:
13355 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13356 {
13357 unsigned int insn2, insn3;
13358 bfd_vma offset = rel->r_offset;
13359
13360 if ((tls_mask & TLS_TPRELGD) != 0)
13361 {
13362 /* IE */
13363 r_type = R_PPC64_NONE;
13364 insn2 = 0x7c636a14; /* add 3,3,13 */
13365 }
13366 else
13367 {
13368 /* LE */
13369 if (toc_symndx != 0)
13370 {
13371 r_symndx = toc_symndx;
13372 rel->r_addend = toc_addend;
13373 }
13374 r_type = R_PPC64_TPREL16_LO;
13375 rel->r_offset = offset + d_offset;
13376 insn2 = 0x38630000; /* addi 3,3,0 */
13377 }
13378 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13379 /* Zap the reloc on the _tls_get_addr call too. */
13380 BFD_ASSERT (offset == rel[1].r_offset);
13381 rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13382 insn3 = bfd_get_32 (output_bfd,
13383 contents + offset + 4);
13384 if (insn3 == NOP
13385 || insn3 == CROR_151515 || insn3 == CROR_313131)
13386 {
13387 rel->r_offset += 4;
13388 bfd_put_32 (output_bfd, insn2, contents + offset + 4);
13389 insn2 = NOP;
13390 }
13391 bfd_put_32 (output_bfd, insn2, contents + offset);
13392 if ((tls_mask & TLS_TPRELGD) == 0 && toc_symndx != 0)
13393 {
13394 rel--;
13395 continue;
13396 }
13397 }
13398 break;
13399
13400 case R_PPC64_TLSLD:
13401 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13402 {
13403 unsigned int insn2, insn3;
13404 bfd_vma offset = rel->r_offset;
13405
13406 if (toc_symndx)
13407 sec = local_sections[toc_symndx];
13408 for (r_symndx = 0;
13409 r_symndx < symtab_hdr->sh_info;
13410 r_symndx++)
13411 if (local_sections[r_symndx] == sec)
13412 break;
13413 if (r_symndx >= symtab_hdr->sh_info)
13414 r_symndx = STN_UNDEF;
13415 rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
13416 if (r_symndx != STN_UNDEF)
13417 rel->r_addend -= (local_syms[r_symndx].st_value
13418 + sec->output_offset
13419 + sec->output_section->vma);
13420
13421 r_type = R_PPC64_TPREL16_LO;
13422 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13423 rel->r_offset = offset + d_offset;
13424 /* Zap the reloc on the _tls_get_addr call too. */
13425 BFD_ASSERT (offset == rel[1].r_offset);
13426 rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13427 insn2 = 0x38630000; /* addi 3,3,0 */
13428 insn3 = bfd_get_32 (output_bfd,
13429 contents + offset + 4);
13430 if (insn3 == NOP
13431 || insn3 == CROR_151515 || insn3 == CROR_313131)
13432 {
13433 rel->r_offset += 4;
13434 bfd_put_32 (output_bfd, insn2, contents + offset + 4);
13435 insn2 = NOP;
13436 }
13437 bfd_put_32 (output_bfd, insn2, contents + offset);
13438 rel--;
13439 continue;
13440 }
13441 break;
13442
13443 case R_PPC64_DTPMOD64:
13444 if (rel + 1 < relend
13445 && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
13446 && rel[1].r_offset == rel->r_offset + 8)
13447 {
13448 if ((tls_mask & TLS_GD) == 0)
13449 {
13450 rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_NONE);
13451 if ((tls_mask & TLS_TPRELGD) != 0)
13452 r_type = R_PPC64_TPREL64;
13453 else
13454 {
13455 bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
13456 r_type = R_PPC64_NONE;
13457 }
13458 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13459 }
13460 }
13461 else
13462 {
13463 if ((tls_mask & TLS_LD) == 0)
13464 {
13465 bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
13466 r_type = R_PPC64_NONE;
13467 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13468 }
13469 }
13470 break;
13471
13472 case R_PPC64_TPREL64:
13473 if ((tls_mask & TLS_TPREL) == 0)
13474 {
13475 r_type = R_PPC64_NONE;
13476 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13477 }
13478 break;
13479
13480 case R_PPC64_REL16_HA:
13481 /* If we are generating a non-PIC executable, edit
13482 . 0: addis 2,12,.TOC.-0b@ha
13483 . addi 2,2,.TOC.-0b@l
13484 used by ELFv2 global entry points to set up r2, to
13485 . lis 2,.TOC.@ha
13486 . addi 2,2,.TOC.@l
13487 if .TOC. is in range. */
13488 if (!info->shared
13489 && h != NULL && &h->elf == htab->elf.hgot
13490 && rel + 1 < relend
13491 && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_REL16_LO)
13492 && rel[1].r_offset == rel->r_offset + 4
13493 && rel[1].r_addend == rel->r_addend + 4
13494 && relocation + 0x80008000 <= 0xffffffff)
13495 {
13496 unsigned int insn1, insn2;
13497 bfd_vma offset = rel->r_offset - d_offset;
13498 insn1 = bfd_get_32 (output_bfd, contents + offset);
13499 insn2 = bfd_get_32 (output_bfd, contents + offset + 4);
13500 if ((insn1 & 0xffff0000) == 0x3c4c0000 /* addis 2,12 */
13501 && (insn2 & 0xffff0000) == 0x38420000 /* addi 2,2 */)
13502 {
13503 r_type = R_PPC64_ADDR16_HA;
13504 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13505 rel->r_addend -= d_offset;
13506 rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_ADDR16_LO);
13507 rel[1].r_addend -= d_offset + 4;
13508 bfd_put_32 (output_bfd, 0x3c400000, contents + offset);
13509 }
13510 }
13511 break;
13512 }
13513
13514 /* Handle other relocations that tweak non-addend part of insn. */
13515 insn = 0;
13516 max_br_offset = 1 << 25;
13517 addend = rel->r_addend;
13518 reloc_dest = DEST_NORMAL;
13519 switch (r_type)
13520 {
13521 default:
13522 break;
13523
13524 case R_PPC64_TOCSAVE:
13525 if (relocation + addend == (rel->r_offset
13526 + input_section->output_offset
13527 + input_section->output_section->vma)
13528 && tocsave_find (htab, NO_INSERT,
13529 &local_syms, rel, input_bfd))
13530 {
13531 insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
13532 if (insn == NOP
13533 || insn == CROR_151515 || insn == CROR_313131)
13534 bfd_put_32 (input_bfd,
13535 STD_R2_0R1 + STK_TOC (htab),
13536 contents + rel->r_offset);
13537 }
13538 break;
13539
13540 /* Branch taken prediction relocations. */
13541 case R_PPC64_ADDR14_BRTAKEN:
13542 case R_PPC64_REL14_BRTAKEN:
13543 insn = 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field. */
13544 /* Fall thru. */
13545
13546 /* Branch not taken prediction relocations. */
13547 case R_PPC64_ADDR14_BRNTAKEN:
13548 case R_PPC64_REL14_BRNTAKEN:
13549 insn |= bfd_get_32 (output_bfd,
13550 contents + rel->r_offset) & ~(0x01 << 21);
13551 /* Fall thru. */
13552
13553 case R_PPC64_REL14:
13554 max_br_offset = 1 << 15;
13555 /* Fall thru. */
13556
13557 case R_PPC64_REL24:
13558 /* Calls to functions with a different TOC, such as calls to
13559 shared objects, need to alter the TOC pointer. This is
13560 done using a linkage stub. A REL24 branching to these
13561 linkage stubs needs to be followed by a nop, as the nop
13562 will be replaced with an instruction to restore the TOC
13563 base pointer. */
13564 fdh = h;
13565 if (h != NULL
13566 && h->oh != NULL
13567 && h->oh->is_func_descriptor)
13568 fdh = ppc_follow_link (h->oh);
13569 stub_entry = ppc_get_stub_entry (input_section, sec, fdh, &orig_rel,
13570 htab);
13571 if (stub_entry != NULL
13572 && (stub_entry->stub_type == ppc_stub_plt_call
13573 || stub_entry->stub_type == ppc_stub_plt_call_r2save
13574 || stub_entry->stub_type == ppc_stub_plt_branch_r2off
13575 || stub_entry->stub_type == ppc_stub_long_branch_r2off))
13576 {
13577 bfd_boolean can_plt_call = FALSE;
13578
13579 /* All of these stubs will modify r2, so there must be a
13580 branch and link followed by a nop. The nop is
13581 replaced by an insn to restore r2. */
13582 if (rel->r_offset + 8 <= input_section->size)
13583 {
13584 unsigned long br;
13585
13586 br = bfd_get_32 (input_bfd,
13587 contents + rel->r_offset);
13588 if ((br & 1) != 0)
13589 {
13590 unsigned long nop;
13591
13592 nop = bfd_get_32 (input_bfd,
13593 contents + rel->r_offset + 4);
13594 if (nop == NOP
13595 || nop == CROR_151515 || nop == CROR_313131)
13596 {
13597 if (h != NULL
13598 && (h == htab->tls_get_addr_fd
13599 || h == htab->tls_get_addr)
13600 && !htab->no_tls_get_addr_opt)
13601 {
13602 /* Special stub used, leave nop alone. */
13603 }
13604 else
13605 bfd_put_32 (input_bfd,
13606 LD_R2_0R1 + STK_TOC (htab),
13607 contents + rel->r_offset + 4);
13608 can_plt_call = TRUE;
13609 }
13610 }
13611 }
13612
13613 if (!can_plt_call && h != NULL)
13614 {
13615 const char *name = h->elf.root.root.string;
13616
13617 if (*name == '.')
13618 ++name;
13619
13620 if (strncmp (name, "__libc_start_main", 17) == 0
13621 && (name[17] == 0 || name[17] == '@'))
13622 {
13623 /* Allow crt1 branch to go via a toc adjusting
13624 stub. Other calls that never return could do
13625 the same, if we could detect such. */
13626 can_plt_call = TRUE;
13627 }
13628 }
13629
13630 if (!can_plt_call)
13631 {
13632 /* g++ as of 20130507 emits self-calls without a
13633 following nop. This is arguably wrong since we
13634 have conflicting information. On the one hand a
13635 global symbol and on the other a local call
13636 sequence, but don't error for this special case.
13637 It isn't possible to cheaply verify we have
13638 exactly such a call. Allow all calls to the same
13639 section. */
13640 asection *code_sec = sec;
13641
13642 if (get_opd_info (sec) != NULL)
13643 {
13644 bfd_vma off = (relocation + addend
13645 - sec->output_section->vma
13646 - sec->output_offset);
13647
13648 opd_entry_value (sec, off, &code_sec, NULL, FALSE);
13649 }
13650 if (code_sec == input_section)
13651 can_plt_call = TRUE;
13652 }
13653
13654 if (!can_plt_call)
13655 {
13656 info->callbacks->einfo
13657 (_("%P: %H: call to `%T' lacks nop, can't restore toc; "
13658 "recompile with -fPIC\n"),
13659 input_bfd, input_section, rel->r_offset, sym_name);
13660
13661 bfd_set_error (bfd_error_bad_value);
13662 ret = FALSE;
13663 }
13664
13665 if (can_plt_call
13666 && (stub_entry->stub_type == ppc_stub_plt_call
13667 || stub_entry->stub_type == ppc_stub_plt_call_r2save))
13668 unresolved_reloc = FALSE;
13669 }
13670
13671 if ((stub_entry == NULL
13672 || stub_entry->stub_type == ppc_stub_long_branch
13673 || stub_entry->stub_type == ppc_stub_plt_branch)
13674 && get_opd_info (sec) != NULL)
13675 {
13676 /* The branch destination is the value of the opd entry. */
13677 bfd_vma off = (relocation + addend
13678 - sec->output_section->vma
13679 - sec->output_offset);
13680 bfd_vma dest = opd_entry_value (sec, off, NULL, NULL, FALSE);
13681 if (dest != (bfd_vma) -1)
13682 {
13683 relocation = dest;
13684 addend = 0;
13685 reloc_dest = DEST_OPD;
13686 }
13687 }
13688
13689 /* If the branch is out of reach we ought to have a long
13690 branch stub. */
13691 from = (rel->r_offset
13692 + input_section->output_offset
13693 + input_section->output_section->vma);
13694
13695 relocation += PPC64_LOCAL_ENTRY_OFFSET (fdh
13696 ? fdh->elf.other
13697 : sym->st_other);
13698
13699 if (stub_entry != NULL
13700 && (stub_entry->stub_type == ppc_stub_long_branch
13701 || stub_entry->stub_type == ppc_stub_plt_branch)
13702 && (r_type == R_PPC64_ADDR14_BRTAKEN
13703 || r_type == R_PPC64_ADDR14_BRNTAKEN
13704 || (relocation + addend - from + max_br_offset
13705 < 2 * max_br_offset)))
13706 /* Don't use the stub if this branch is in range. */
13707 stub_entry = NULL;
13708
13709 if (stub_entry != NULL)
13710 {
13711 /* Munge up the value and addend so that we call the stub
13712 rather than the procedure directly. */
13713 relocation = (stub_entry->stub_offset
13714 + stub_entry->stub_sec->output_offset
13715 + stub_entry->stub_sec->output_section->vma);
13716 addend = 0;
13717 reloc_dest = DEST_STUB;
13718
13719 if ((stub_entry->stub_type == ppc_stub_plt_call
13720 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
13721 && (ALWAYS_EMIT_R2SAVE
13722 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
13723 && rel + 1 < relend
13724 && rel[1].r_offset == rel->r_offset + 4
13725 && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOCSAVE)
13726 relocation += 4;
13727 }
13728
13729 if (insn != 0)
13730 {
13731 if (is_isa_v2)
13732 {
13733 /* Set 'a' bit. This is 0b00010 in BO field for branch
13734 on CR(BI) insns (BO == 001at or 011at), and 0b01000
13735 for branch on CTR insns (BO == 1a00t or 1a01t). */
13736 if ((insn & (0x14 << 21)) == (0x04 << 21))
13737 insn |= 0x02 << 21;
13738 else if ((insn & (0x14 << 21)) == (0x10 << 21))
13739 insn |= 0x08 << 21;
13740 else
13741 break;
13742 }
13743 else
13744 {
13745 /* Invert 'y' bit if not the default. */
13746 if ((bfd_signed_vma) (relocation + addend - from) < 0)
13747 insn ^= 0x01 << 21;
13748 }
13749
13750 bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
13751 }
13752
13753 /* NOP out calls to undefined weak functions.
13754 We can thus call a weak function without first
13755 checking whether the function is defined. */
13756 else if (h != NULL
13757 && h->elf.root.type == bfd_link_hash_undefweak
13758 && h->elf.dynindx == -1
13759 && r_type == R_PPC64_REL24
13760 && relocation == 0
13761 && addend == 0)
13762 {
13763 bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
13764 continue;
13765 }
13766 break;
13767 }
13768
13769 /* Set `addend'. */
13770 tls_type = 0;
13771 switch (r_type)
13772 {
13773 default:
13774 info->callbacks->einfo
13775 (_("%P: %B: unknown relocation type %d for `%T'\n"),
13776 input_bfd, (int) r_type, sym_name);
13777
13778 bfd_set_error (bfd_error_bad_value);
13779 ret = FALSE;
13780 continue;
13781
13782 case R_PPC64_NONE:
13783 case R_PPC64_TLS:
13784 case R_PPC64_TLSGD:
13785 case R_PPC64_TLSLD:
13786 case R_PPC64_TOCSAVE:
13787 case R_PPC64_GNU_VTINHERIT:
13788 case R_PPC64_GNU_VTENTRY:
13789 continue;
13790
13791 /* GOT16 relocations. Like an ADDR16 using the symbol's
13792 address in the GOT as relocation value instead of the
13793 symbol's value itself. Also, create a GOT entry for the
13794 symbol and put the symbol value there. */
13795 case R_PPC64_GOT_TLSGD16:
13796 case R_PPC64_GOT_TLSGD16_LO:
13797 case R_PPC64_GOT_TLSGD16_HI:
13798 case R_PPC64_GOT_TLSGD16_HA:
13799 tls_type = TLS_TLS | TLS_GD;
13800 goto dogot;
13801
13802 case R_PPC64_GOT_TLSLD16:
13803 case R_PPC64_GOT_TLSLD16_LO:
13804 case R_PPC64_GOT_TLSLD16_HI:
13805 case R_PPC64_GOT_TLSLD16_HA:
13806 tls_type = TLS_TLS | TLS_LD;
13807 goto dogot;
13808
13809 case R_PPC64_GOT_TPREL16_DS:
13810 case R_PPC64_GOT_TPREL16_LO_DS:
13811 case R_PPC64_GOT_TPREL16_HI:
13812 case R_PPC64_GOT_TPREL16_HA:
13813 tls_type = TLS_TLS | TLS_TPREL;
13814 goto dogot;
13815
13816 case R_PPC64_GOT_DTPREL16_DS:
13817 case R_PPC64_GOT_DTPREL16_LO_DS:
13818 case R_PPC64_GOT_DTPREL16_HI:
13819 case R_PPC64_GOT_DTPREL16_HA:
13820 tls_type = TLS_TLS | TLS_DTPREL;
13821 goto dogot;
13822
13823 case R_PPC64_GOT16:
13824 case R_PPC64_GOT16_LO:
13825 case R_PPC64_GOT16_HI:
13826 case R_PPC64_GOT16_HA:
13827 case R_PPC64_GOT16_DS:
13828 case R_PPC64_GOT16_LO_DS:
13829 dogot:
13830 {
13831 /* Relocation is to the entry for this symbol in the global
13832 offset table. */
13833 asection *got;
13834 bfd_vma *offp;
13835 bfd_vma off;
13836 unsigned long indx = 0;
13837 struct got_entry *ent;
13838
13839 if (tls_type == (TLS_TLS | TLS_LD)
13840 && (h == NULL
13841 || !h->elf.def_dynamic))
13842 ent = ppc64_tlsld_got (input_bfd);
13843 else
13844 {
13845
13846 if (h != NULL)
13847 {
13848 bfd_boolean dyn = htab->elf.dynamic_sections_created;
13849 if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared,
13850 &h->elf)
13851 || (info->shared
13852 && SYMBOL_REFERENCES_LOCAL (info, &h->elf)))
13853 /* This is actually a static link, or it is a
13854 -Bsymbolic link and the symbol is defined
13855 locally, or the symbol was forced to be local
13856 because of a version file. */
13857 ;
13858 else
13859 {
13860 BFD_ASSERT (h->elf.dynindx != -1);
13861 indx = h->elf.dynindx;
13862 unresolved_reloc = FALSE;
13863 }
13864 ent = h->elf.got.glist;
13865 }
13866 else
13867 {
13868 if (local_got_ents == NULL)
13869 abort ();
13870 ent = local_got_ents[r_symndx];
13871 }
13872
13873 for (; ent != NULL; ent = ent->next)
13874 if (ent->addend == orig_rel.r_addend
13875 && ent->owner == input_bfd
13876 && ent->tls_type == tls_type)
13877 break;
13878 }
13879
13880 if (ent == NULL)
13881 abort ();
13882 if (ent->is_indirect)
13883 ent = ent->got.ent;
13884 offp = &ent->got.offset;
13885 got = ppc64_elf_tdata (ent->owner)->got;
13886 if (got == NULL)
13887 abort ();
13888
13889 /* The offset must always be a multiple of 8. We use the
13890 least significant bit to record whether we have already
13891 processed this entry. */
13892 off = *offp;
13893 if ((off & 1) != 0)
13894 off &= ~1;
13895 else
13896 {
13897 /* Generate relocs for the dynamic linker, except in
13898 the case of TLSLD where we'll use one entry per
13899 module. */
13900 asection *relgot;
13901 bfd_boolean ifunc;
13902
13903 *offp = off | 1;
13904 relgot = NULL;
13905 ifunc = (h != NULL
13906 ? h->elf.type == STT_GNU_IFUNC
13907 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC);
13908 if (ifunc)
13909 relgot = htab->elf.irelplt;
13910 else if ((info->shared || indx != 0)
13911 && (h == NULL
13912 || (tls_type == (TLS_TLS | TLS_LD)
13913 && !h->elf.def_dynamic)
13914 || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
13915 || h->elf.root.type != bfd_link_hash_undefweak))
13916 relgot = ppc64_elf_tdata (ent->owner)->relgot;
13917 if (relgot != NULL)
13918 {
13919 outrel.r_offset = (got->output_section->vma
13920 + got->output_offset
13921 + off);
13922 outrel.r_addend = addend;
13923 if (tls_type & (TLS_LD | TLS_GD))
13924 {
13925 outrel.r_addend = 0;
13926 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPMOD64);
13927 if (tls_type == (TLS_TLS | TLS_GD))
13928 {
13929 loc = relgot->contents;
13930 loc += (relgot->reloc_count++
13931 * sizeof (Elf64_External_Rela));
13932 bfd_elf64_swap_reloca_out (output_bfd,
13933 &outrel, loc);
13934 outrel.r_offset += 8;
13935 outrel.r_addend = addend;
13936 outrel.r_info
13937 = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
13938 }
13939 }
13940 else if (tls_type == (TLS_TLS | TLS_DTPREL))
13941 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
13942 else if (tls_type == (TLS_TLS | TLS_TPREL))
13943 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_TPREL64);
13944 else if (indx != 0)
13945 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_GLOB_DAT);
13946 else
13947 {
13948 if (ifunc)
13949 outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
13950 else
13951 outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
13952
13953 /* Write the .got section contents for the sake
13954 of prelink. */
13955 loc = got->contents + off;
13956 bfd_put_64 (output_bfd, outrel.r_addend + relocation,
13957 loc);
13958 }
13959
13960 if (indx == 0 && tls_type != (TLS_TLS | TLS_LD))
13961 {
13962 outrel.r_addend += relocation;
13963 if (tls_type & (TLS_GD | TLS_DTPREL | TLS_TPREL))
13964 outrel.r_addend -= htab->elf.tls_sec->vma;
13965 }
13966 loc = relgot->contents;
13967 loc += (relgot->reloc_count++
13968 * sizeof (Elf64_External_Rela));
13969 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
13970 }
13971
13972 /* Init the .got section contents here if we're not
13973 emitting a reloc. */
13974 else
13975 {
13976 relocation += addend;
13977 if (tls_type == (TLS_TLS | TLS_LD))
13978 relocation = 1;
13979 else if (tls_type != 0)
13980 {
13981 relocation -= htab->elf.tls_sec->vma + DTP_OFFSET;
13982 if (tls_type == (TLS_TLS | TLS_TPREL))
13983 relocation += DTP_OFFSET - TP_OFFSET;
13984
13985 if (tls_type == (TLS_TLS | TLS_GD))
13986 {
13987 bfd_put_64 (output_bfd, relocation,
13988 got->contents + off + 8);
13989 relocation = 1;
13990 }
13991 }
13992
13993 bfd_put_64 (output_bfd, relocation,
13994 got->contents + off);
13995 }
13996 }
13997
13998 if (off >= (bfd_vma) -2)
13999 abort ();
14000
14001 relocation = got->output_section->vma + got->output_offset + off;
14002 addend = -(TOCstart + htab->stub_group[input_section->id].toc_off);
14003 }
14004 break;
14005
14006 case R_PPC64_PLT16_HA:
14007 case R_PPC64_PLT16_HI:
14008 case R_PPC64_PLT16_LO:
14009 case R_PPC64_PLT32:
14010 case R_PPC64_PLT64:
14011 /* Relocation is to the entry for this symbol in the
14012 procedure linkage table. */
14013
14014 /* Resolve a PLT reloc against a local symbol directly,
14015 without using the procedure linkage table. */
14016 if (h == NULL)
14017 break;
14018
14019 /* It's possible that we didn't make a PLT entry for this
14020 symbol. This happens when statically linking PIC code,
14021 or when using -Bsymbolic. Go find a match if there is a
14022 PLT entry. */
14023 if (htab->elf.splt != NULL)
14024 {
14025 struct plt_entry *ent;
14026 for (ent = h->elf.plt.plist; ent != NULL; ent = ent->next)
14027 if (ent->plt.offset != (bfd_vma) -1
14028 && ent->addend == orig_rel.r_addend)
14029 {
14030 relocation = (htab->elf.splt->output_section->vma
14031 + htab->elf.splt->output_offset
14032 + ent->plt.offset);
14033 unresolved_reloc = FALSE;
14034 break;
14035 }
14036 }
14037 break;
14038
14039 case R_PPC64_TOC:
14040 /* Relocation value is TOC base. */
14041 relocation = TOCstart;
14042 if (r_symndx == STN_UNDEF)
14043 relocation += htab->stub_group[input_section->id].toc_off;
14044 else if (unresolved_reloc)
14045 ;
14046 else if (sec != NULL && sec->id <= htab->top_id)
14047 relocation += htab->stub_group[sec->id].toc_off;
14048 else
14049 unresolved_reloc = TRUE;
14050 goto dodyn;
14051
14052 /* TOC16 relocs. We want the offset relative to the TOC base,
14053 which is the address of the start of the TOC plus 0x8000.
14054 The TOC consists of sections .got, .toc, .tocbss, and .plt,
14055 in this order. */
14056 case R_PPC64_TOC16:
14057 case R_PPC64_TOC16_LO:
14058 case R_PPC64_TOC16_HI:
14059 case R_PPC64_TOC16_DS:
14060 case R_PPC64_TOC16_LO_DS:
14061 case R_PPC64_TOC16_HA:
14062 addend -= TOCstart + htab->stub_group[input_section->id].toc_off;
14063 break;
14064
14065 /* Relocate against the beginning of the section. */
14066 case R_PPC64_SECTOFF:
14067 case R_PPC64_SECTOFF_LO:
14068 case R_PPC64_SECTOFF_HI:
14069 case R_PPC64_SECTOFF_DS:
14070 case R_PPC64_SECTOFF_LO_DS:
14071 case R_PPC64_SECTOFF_HA:
14072 if (sec != NULL)
14073 addend -= sec->output_section->vma;
14074 break;
14075
14076 case R_PPC64_REL16:
14077 case R_PPC64_REL16_LO:
14078 case R_PPC64_REL16_HI:
14079 case R_PPC64_REL16_HA:
14080 break;
14081
14082 case R_PPC64_REL14:
14083 case R_PPC64_REL14_BRNTAKEN:
14084 case R_PPC64_REL14_BRTAKEN:
14085 case R_PPC64_REL24:
14086 break;
14087
14088 case R_PPC64_TPREL16:
14089 case R_PPC64_TPREL16_LO:
14090 case R_PPC64_TPREL16_HI:
14091 case R_PPC64_TPREL16_HA:
14092 case R_PPC64_TPREL16_DS:
14093 case R_PPC64_TPREL16_LO_DS:
14094 case R_PPC64_TPREL16_HIGH:
14095 case R_PPC64_TPREL16_HIGHA:
14096 case R_PPC64_TPREL16_HIGHER:
14097 case R_PPC64_TPREL16_HIGHERA:
14098 case R_PPC64_TPREL16_HIGHEST:
14099 case R_PPC64_TPREL16_HIGHESTA:
14100 if (h != NULL
14101 && h->elf.root.type == bfd_link_hash_undefweak
14102 && h->elf.dynindx == -1)
14103 {
14104 /* Make this relocation against an undefined weak symbol
14105 resolve to zero. This is really just a tweak, since
14106 code using weak externs ought to check that they are
14107 defined before using them. */
14108 bfd_byte *p = contents + rel->r_offset - d_offset;
14109
14110 insn = bfd_get_32 (output_bfd, p);
14111 insn = _bfd_elf_ppc_at_tprel_transform (insn, 13);
14112 if (insn != 0)
14113 bfd_put_32 (output_bfd, insn, p);
14114 break;
14115 }
14116 addend -= htab->elf.tls_sec->vma + TP_OFFSET;
14117 if (info->shared)
14118 /* The TPREL16 relocs shouldn't really be used in shared
14119 libs as they will result in DT_TEXTREL being set, but
14120 support them anyway. */
14121 goto dodyn;
14122 break;
14123
14124 case R_PPC64_DTPREL16:
14125 case R_PPC64_DTPREL16_LO:
14126 case R_PPC64_DTPREL16_HI:
14127 case R_PPC64_DTPREL16_HA:
14128 case R_PPC64_DTPREL16_DS:
14129 case R_PPC64_DTPREL16_LO_DS:
14130 case R_PPC64_DTPREL16_HIGH:
14131 case R_PPC64_DTPREL16_HIGHA:
14132 case R_PPC64_DTPREL16_HIGHER:
14133 case R_PPC64_DTPREL16_HIGHERA:
14134 case R_PPC64_DTPREL16_HIGHEST:
14135 case R_PPC64_DTPREL16_HIGHESTA:
14136 addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
14137 break;
14138
14139 case R_PPC64_DTPMOD64:
14140 relocation = 1;
14141 addend = 0;
14142 goto dodyn;
14143
14144 case R_PPC64_TPREL64:
14145 addend -= htab->elf.tls_sec->vma + TP_OFFSET;
14146 goto dodyn;
14147
14148 case R_PPC64_DTPREL64:
14149 addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
14150 /* Fall thru */
14151
14152 /* Relocations that may need to be propagated if this is a
14153 dynamic object. */
14154 case R_PPC64_REL30:
14155 case R_PPC64_REL32:
14156 case R_PPC64_REL64:
14157 case R_PPC64_ADDR14:
14158 case R_PPC64_ADDR14_BRNTAKEN:
14159 case R_PPC64_ADDR14_BRTAKEN:
14160 case R_PPC64_ADDR16:
14161 case R_PPC64_ADDR16_DS:
14162 case R_PPC64_ADDR16_HA:
14163 case R_PPC64_ADDR16_HI:
14164 case R_PPC64_ADDR16_HIGH:
14165 case R_PPC64_ADDR16_HIGHA:
14166 case R_PPC64_ADDR16_HIGHER:
14167 case R_PPC64_ADDR16_HIGHERA:
14168 case R_PPC64_ADDR16_HIGHEST:
14169 case R_PPC64_ADDR16_HIGHESTA:
14170 case R_PPC64_ADDR16_LO:
14171 case R_PPC64_ADDR16_LO_DS:
14172 case R_PPC64_ADDR24:
14173 case R_PPC64_ADDR32:
14174 case R_PPC64_ADDR64:
14175 case R_PPC64_UADDR16:
14176 case R_PPC64_UADDR32:
14177 case R_PPC64_UADDR64:
14178 dodyn:
14179 if ((input_section->flags & SEC_ALLOC) == 0)
14180 break;
14181
14182 if (NO_OPD_RELOCS && is_opd)
14183 break;
14184
14185 if ((info->shared
14186 && (h == NULL
14187 || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
14188 || h->elf.root.type != bfd_link_hash_undefweak)
14189 && (must_be_dyn_reloc (info, r_type)
14190 || !SYMBOL_CALLS_LOCAL (info, &h->elf)))
14191 || (ELIMINATE_COPY_RELOCS
14192 && !info->shared
14193 && h != NULL
14194 && h->elf.dynindx != -1
14195 && !h->elf.non_got_ref
14196 && !h->elf.def_regular)
14197 || (!info->shared
14198 && (h != NULL
14199 ? h->elf.type == STT_GNU_IFUNC
14200 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)))
14201 {
14202 bfd_boolean skip, relocate;
14203 asection *sreloc;
14204 bfd_vma out_off;
14205
14206 /* When generating a dynamic object, these relocations
14207 are copied into the output file to be resolved at run
14208 time. */
14209
14210 skip = FALSE;
14211 relocate = FALSE;
14212
14213 out_off = _bfd_elf_section_offset (output_bfd, info,
14214 input_section, rel->r_offset);
14215 if (out_off == (bfd_vma) -1)
14216 skip = TRUE;
14217 else if (out_off == (bfd_vma) -2)
14218 skip = TRUE, relocate = TRUE;
14219 out_off += (input_section->output_section->vma
14220 + input_section->output_offset);
14221 outrel.r_offset = out_off;
14222 outrel.r_addend = rel->r_addend;
14223
14224 /* Optimize unaligned reloc use. */
14225 if ((r_type == R_PPC64_ADDR64 && (out_off & 7) != 0)
14226 || (r_type == R_PPC64_UADDR64 && (out_off & 7) == 0))
14227 r_type ^= R_PPC64_ADDR64 ^ R_PPC64_UADDR64;
14228 else if ((r_type == R_PPC64_ADDR32 && (out_off & 3) != 0)
14229 || (r_type == R_PPC64_UADDR32 && (out_off & 3) == 0))
14230 r_type ^= R_PPC64_ADDR32 ^ R_PPC64_UADDR32;
14231 else if ((r_type == R_PPC64_ADDR16 && (out_off & 1) != 0)
14232 || (r_type == R_PPC64_UADDR16 && (out_off & 1) == 0))
14233 r_type ^= R_PPC64_ADDR16 ^ R_PPC64_UADDR16;
14234
14235 if (skip)
14236 memset (&outrel, 0, sizeof outrel);
14237 else if (!SYMBOL_REFERENCES_LOCAL (info, &h->elf)
14238 && !is_opd
14239 && r_type != R_PPC64_TOC)
14240 {
14241 BFD_ASSERT (h->elf.dynindx != -1);
14242 outrel.r_info = ELF64_R_INFO (h->elf.dynindx, r_type);
14243 }
14244 else
14245 {
14246 /* This symbol is local, or marked to become local,
14247 or this is an opd section reloc which must point
14248 at a local function. */
14249 outrel.r_addend += relocation;
14250 if (r_type == R_PPC64_ADDR64 || r_type == R_PPC64_TOC)
14251 {
14252 if (is_opd && h != NULL)
14253 {
14254 /* Lie about opd entries. This case occurs
14255 when building shared libraries and we
14256 reference a function in another shared
14257 lib. The same thing happens for a weak
14258 definition in an application that's
14259 overridden by a strong definition in a
14260 shared lib. (I believe this is a generic
14261 bug in binutils handling of weak syms.)
14262 In these cases we won't use the opd
14263 entry in this lib. */
14264 unresolved_reloc = FALSE;
14265 }
14266 if (!is_opd
14267 && r_type == R_PPC64_ADDR64
14268 && (h != NULL
14269 ? h->elf.type == STT_GNU_IFUNC
14270 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
14271 outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
14272 else
14273 {
14274 outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
14275
14276 /* We need to relocate .opd contents for ld.so.
14277 Prelink also wants simple and consistent rules
14278 for relocs. This make all RELATIVE relocs have
14279 *r_offset equal to r_addend. */
14280 relocate = TRUE;
14281 }
14282 }
14283 else
14284 {
14285 long indx = 0;
14286
14287 if (h != NULL
14288 ? h->elf.type == STT_GNU_IFUNC
14289 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
14290 {
14291 info->callbacks->einfo
14292 (_("%P: %H: %s for indirect "
14293 "function `%T' unsupported\n"),
14294 input_bfd, input_section, rel->r_offset,
14295 ppc64_elf_howto_table[r_type]->name,
14296 sym_name);
14297 ret = FALSE;
14298 }
14299 else if (r_symndx == STN_UNDEF || bfd_is_abs_section (sec))
14300 ;
14301 else if (sec == NULL || sec->owner == NULL)
14302 {
14303 bfd_set_error (bfd_error_bad_value);
14304 return FALSE;
14305 }
14306 else
14307 {
14308 asection *osec;
14309
14310 osec = sec->output_section;
14311 indx = elf_section_data (osec)->dynindx;
14312
14313 if (indx == 0)
14314 {
14315 if ((osec->flags & SEC_READONLY) == 0
14316 && htab->elf.data_index_section != NULL)
14317 osec = htab->elf.data_index_section;
14318 else
14319 osec = htab->elf.text_index_section;
14320 indx = elf_section_data (osec)->dynindx;
14321 }
14322 BFD_ASSERT (indx != 0);
14323
14324 /* We are turning this relocation into one
14325 against a section symbol, so subtract out
14326 the output section's address but not the
14327 offset of the input section in the output
14328 section. */
14329 outrel.r_addend -= osec->vma;
14330 }
14331
14332 outrel.r_info = ELF64_R_INFO (indx, r_type);
14333 }
14334 }
14335
14336 sreloc = elf_section_data (input_section)->sreloc;
14337 if (h != NULL
14338 ? h->elf.type == STT_GNU_IFUNC
14339 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
14340 sreloc = htab->elf.irelplt;
14341 if (sreloc == NULL)
14342 abort ();
14343
14344 if (sreloc->reloc_count * sizeof (Elf64_External_Rela)
14345 >= sreloc->size)
14346 abort ();
14347 loc = sreloc->contents;
14348 loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
14349 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
14350
14351 /* If this reloc is against an external symbol, it will
14352 be computed at runtime, so there's no need to do
14353 anything now. However, for the sake of prelink ensure
14354 that the section contents are a known value. */
14355 if (! relocate)
14356 {
14357 unresolved_reloc = FALSE;
14358 /* The value chosen here is quite arbitrary as ld.so
14359 ignores section contents except for the special
14360 case of .opd where the contents might be accessed
14361 before relocation. Choose zero, as that won't
14362 cause reloc overflow. */
14363 relocation = 0;
14364 addend = 0;
14365 /* Use *r_offset == r_addend for R_PPC64_ADDR64 relocs
14366 to improve backward compatibility with older
14367 versions of ld. */
14368 if (r_type == R_PPC64_ADDR64)
14369 addend = outrel.r_addend;
14370 /* Adjust pc_relative relocs to have zero in *r_offset. */
14371 else if (ppc64_elf_howto_table[r_type]->pc_relative)
14372 addend = (input_section->output_section->vma
14373 + input_section->output_offset
14374 + rel->r_offset);
14375 }
14376 }
14377 break;
14378
14379 case R_PPC64_COPY:
14380 case R_PPC64_GLOB_DAT:
14381 case R_PPC64_JMP_SLOT:
14382 case R_PPC64_JMP_IREL:
14383 case R_PPC64_RELATIVE:
14384 /* We shouldn't ever see these dynamic relocs in relocatable
14385 files. */
14386 /* Fall through. */
14387
14388 case R_PPC64_PLTGOT16:
14389 case R_PPC64_PLTGOT16_DS:
14390 case R_PPC64_PLTGOT16_HA:
14391 case R_PPC64_PLTGOT16_HI:
14392 case R_PPC64_PLTGOT16_LO:
14393 case R_PPC64_PLTGOT16_LO_DS:
14394 case R_PPC64_PLTREL32:
14395 case R_PPC64_PLTREL64:
14396 /* These ones haven't been implemented yet. */
14397
14398 info->callbacks->einfo
14399 (_("%P: %B: %s is not supported for `%T'\n"),
14400 input_bfd,
14401 ppc64_elf_howto_table[r_type]->name, sym_name);
14402
14403 bfd_set_error (bfd_error_invalid_operation);
14404 ret = FALSE;
14405 continue;
14406 }
14407
14408 /* Multi-instruction sequences that access the TOC can be
14409 optimized, eg. addis ra,r2,0; addi rb,ra,x;
14410 to nop; addi rb,r2,x; */
14411 switch (r_type)
14412 {
14413 default:
14414 break;
14415
14416 case R_PPC64_GOT_TLSLD16_HI:
14417 case R_PPC64_GOT_TLSGD16_HI:
14418 case R_PPC64_GOT_TPREL16_HI:
14419 case R_PPC64_GOT_DTPREL16_HI:
14420 case R_PPC64_GOT16_HI:
14421 case R_PPC64_TOC16_HI:
14422 /* These relocs would only be useful if building up an
14423 offset to later add to r2, perhaps in an indexed
14424 addressing mode instruction. Don't try to optimize.
14425 Unfortunately, the possibility of someone building up an
14426 offset like this or even with the HA relocs, means that
14427 we need to check the high insn when optimizing the low
14428 insn. */
14429 break;
14430
14431 case R_PPC64_GOT_TLSLD16_HA:
14432 case R_PPC64_GOT_TLSGD16_HA:
14433 case R_PPC64_GOT_TPREL16_HA:
14434 case R_PPC64_GOT_DTPREL16_HA:
14435 case R_PPC64_GOT16_HA:
14436 case R_PPC64_TOC16_HA:
14437 if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
14438 && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
14439 {
14440 bfd_byte *p = contents + (rel->r_offset & ~3);
14441 bfd_put_32 (input_bfd, NOP, p);
14442 }
14443 break;
14444
14445 case R_PPC64_GOT_TLSLD16_LO:
14446 case R_PPC64_GOT_TLSGD16_LO:
14447 case R_PPC64_GOT_TPREL16_LO_DS:
14448 case R_PPC64_GOT_DTPREL16_LO_DS:
14449 case R_PPC64_GOT16_LO:
14450 case R_PPC64_GOT16_LO_DS:
14451 case R_PPC64_TOC16_LO:
14452 case R_PPC64_TOC16_LO_DS:
14453 if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
14454 && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
14455 {
14456 bfd_byte *p = contents + (rel->r_offset & ~3);
14457 insn = bfd_get_32 (input_bfd, p);
14458 if ((insn & (0x3f << 26)) == 12u << 26 /* addic */)
14459 {
14460 /* Transform addic to addi when we change reg. */
14461 insn &= ~((0x3f << 26) | (0x1f << 16));
14462 insn |= (14u << 26) | (2 << 16);
14463 }
14464 else
14465 {
14466 insn &= ~(0x1f << 16);
14467 insn |= 2 << 16;
14468 }
14469 bfd_put_32 (input_bfd, insn, p);
14470 }
14471 break;
14472 }
14473
14474 /* Do any further special processing. */
14475 switch (r_type)
14476 {
14477 default:
14478 break;
14479
14480 case R_PPC64_REL16_HA:
14481 case R_PPC64_ADDR16_HA:
14482 case R_PPC64_ADDR16_HIGHA:
14483 case R_PPC64_ADDR16_HIGHERA:
14484 case R_PPC64_ADDR16_HIGHESTA:
14485 case R_PPC64_TOC16_HA:
14486 case R_PPC64_SECTOFF_HA:
14487 case R_PPC64_TPREL16_HA:
14488 case R_PPC64_TPREL16_HIGHA:
14489 case R_PPC64_TPREL16_HIGHERA:
14490 case R_PPC64_TPREL16_HIGHESTA:
14491 case R_PPC64_DTPREL16_HA:
14492 case R_PPC64_DTPREL16_HIGHA:
14493 case R_PPC64_DTPREL16_HIGHERA:
14494 case R_PPC64_DTPREL16_HIGHESTA:
14495 /* It's just possible that this symbol is a weak symbol
14496 that's not actually defined anywhere. In that case,
14497 'sec' would be NULL, and we should leave the symbol
14498 alone (it will be set to zero elsewhere in the link). */
14499 if (sec == NULL)
14500 break;
14501 /* Fall thru */
14502
14503 case R_PPC64_GOT16_HA:
14504 case R_PPC64_PLTGOT16_HA:
14505 case R_PPC64_PLT16_HA:
14506 case R_PPC64_GOT_TLSGD16_HA:
14507 case R_PPC64_GOT_TLSLD16_HA:
14508 case R_PPC64_GOT_TPREL16_HA:
14509 case R_PPC64_GOT_DTPREL16_HA:
14510 /* Add 0x10000 if sign bit in 0:15 is set.
14511 Bits 0:15 are not used. */
14512 addend += 0x8000;
14513 break;
14514
14515 case R_PPC64_ADDR16_DS:
14516 case R_PPC64_ADDR16_LO_DS:
14517 case R_PPC64_GOT16_DS:
14518 case R_PPC64_GOT16_LO_DS:
14519 case R_PPC64_PLT16_LO_DS:
14520 case R_PPC64_SECTOFF_DS:
14521 case R_PPC64_SECTOFF_LO_DS:
14522 case R_PPC64_TOC16_DS:
14523 case R_PPC64_TOC16_LO_DS:
14524 case R_PPC64_PLTGOT16_DS:
14525 case R_PPC64_PLTGOT16_LO_DS:
14526 case R_PPC64_GOT_TPREL16_DS:
14527 case R_PPC64_GOT_TPREL16_LO_DS:
14528 case R_PPC64_GOT_DTPREL16_DS:
14529 case R_PPC64_GOT_DTPREL16_LO_DS:
14530 case R_PPC64_TPREL16_DS:
14531 case R_PPC64_TPREL16_LO_DS:
14532 case R_PPC64_DTPREL16_DS:
14533 case R_PPC64_DTPREL16_LO_DS:
14534 insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
14535 mask = 3;
14536 /* If this reloc is against an lq insn, then the value must be
14537 a multiple of 16. This is somewhat of a hack, but the
14538 "correct" way to do this by defining _DQ forms of all the
14539 _DS relocs bloats all reloc switches in this file. It
14540 doesn't seem to make much sense to use any of these relocs
14541 in data, so testing the insn should be safe. */
14542 if ((insn & (0x3f << 26)) == (56u << 26))
14543 mask = 15;
14544 if (((relocation + addend) & mask) != 0)
14545 {
14546 info->callbacks->einfo
14547 (_("%P: %H: error: %s not a multiple of %u\n"),
14548 input_bfd, input_section, rel->r_offset,
14549 ppc64_elf_howto_table[r_type]->name,
14550 mask + 1);
14551 bfd_set_error (bfd_error_bad_value);
14552 ret = FALSE;
14553 continue;
14554 }
14555 break;
14556 }
14557
14558 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
14559 because such sections are not SEC_ALLOC and thus ld.so will
14560 not process them. */
14561 if (unresolved_reloc
14562 && !((input_section->flags & SEC_DEBUGGING) != 0
14563 && h->elf.def_dynamic)
14564 && _bfd_elf_section_offset (output_bfd, info, input_section,
14565 rel->r_offset) != (bfd_vma) -1)
14566 {
14567 info->callbacks->einfo
14568 (_("%P: %H: unresolvable %s against `%T'\n"),
14569 input_bfd, input_section, rel->r_offset,
14570 ppc64_elf_howto_table[(int) r_type]->name,
14571 h->elf.root.root.string);
14572 ret = FALSE;
14573 }
14574
14575 r = _bfd_final_link_relocate (ppc64_elf_howto_table[(int) r_type],
14576 input_bfd,
14577 input_section,
14578 contents,
14579 rel->r_offset,
14580 relocation,
14581 addend);
14582
14583 if (r != bfd_reloc_ok)
14584 {
14585 char *more_info = NULL;
14586 const char *reloc_name = ppc64_elf_howto_table[r_type]->name;
14587
14588 if (reloc_dest != DEST_NORMAL)
14589 {
14590 more_info = bfd_malloc (strlen (reloc_name) + 8);
14591 if (more_info != NULL)
14592 {
14593 strcpy (more_info, reloc_name);
14594 strcat (more_info, (reloc_dest == DEST_OPD
14595 ? " (OPD)" : " (stub)"));
14596 reloc_name = more_info;
14597 }
14598 }
14599
14600 if (r == bfd_reloc_overflow)
14601 {
14602 if (warned)
14603 continue;
14604 if (h != NULL
14605 && h->elf.root.type == bfd_link_hash_undefweak
14606 && ppc64_elf_howto_table[r_type]->pc_relative)
14607 {
14608 /* Assume this is a call protected by other code that
14609 detects the symbol is undefined. If this is the case,
14610 we can safely ignore the overflow. If not, the
14611 program is hosed anyway, and a little warning isn't
14612 going to help. */
14613
14614 continue;
14615 }
14616
14617 if (!((*info->callbacks->reloc_overflow)
14618 (info, &h->elf.root, sym_name,
14619 reloc_name, orig_rel.r_addend,
14620 input_bfd, input_section, rel->r_offset)))
14621 return FALSE;
14622 }
14623 else
14624 {
14625 info->callbacks->einfo
14626 (_("%P: %H: %s against `%T': error %d\n"),
14627 input_bfd, input_section, rel->r_offset,
14628 reloc_name, sym_name, (int) r);
14629 ret = FALSE;
14630 }
14631 if (more_info != NULL)
14632 free (more_info);
14633 }
14634 }
14635
14636 /* If we're emitting relocations, then shortly after this function
14637 returns, reloc offsets and addends for this section will be
14638 adjusted. Worse, reloc symbol indices will be for the output
14639 file rather than the input. Save a copy of the relocs for
14640 opd_entry_value. */
14641 if (is_opd && (info->emitrelocations || info->relocatable))
14642 {
14643 bfd_size_type amt;
14644 amt = input_section->reloc_count * sizeof (Elf_Internal_Rela);
14645 rel = bfd_alloc (input_bfd, amt);
14646 BFD_ASSERT (ppc64_elf_tdata (input_bfd)->opd.relocs == NULL);
14647 ppc64_elf_tdata (input_bfd)->opd.relocs = rel;
14648 if (rel == NULL)
14649 return FALSE;
14650 memcpy (rel, relocs, amt);
14651 }
14652 return ret;
14653 }
14654
14655 /* Adjust the value of any local symbols in opd sections. */
14656
14657 static int
14658 ppc64_elf_output_symbol_hook (struct bfd_link_info *info,
14659 const char *name ATTRIBUTE_UNUSED,
14660 Elf_Internal_Sym *elfsym,
14661 asection *input_sec,
14662 struct elf_link_hash_entry *h)
14663 {
14664 struct _opd_sec_data *opd;
14665 long adjust;
14666 bfd_vma value;
14667
14668 if (h != NULL)
14669 return 1;
14670
14671 opd = get_opd_info (input_sec);
14672 if (opd == NULL || opd->adjust == NULL)
14673 return 1;
14674
14675 value = elfsym->st_value - input_sec->output_offset;
14676 if (!info->relocatable)
14677 value -= input_sec->output_section->vma;
14678
14679 adjust = opd->adjust[value / 8];
14680 if (adjust == -1)
14681 return 2;
14682
14683 elfsym->st_value += adjust;
14684 return 1;
14685 }
14686
14687 /* Finish up dynamic symbol handling. We set the contents of various
14688 dynamic sections here. */
14689
14690 static bfd_boolean
14691 ppc64_elf_finish_dynamic_symbol (bfd *output_bfd,
14692 struct bfd_link_info *info,
14693 struct elf_link_hash_entry *h,
14694 Elf_Internal_Sym *sym ATTRIBUTE_UNUSED)
14695 {
14696 struct ppc_link_hash_table *htab;
14697 struct plt_entry *ent;
14698 Elf_Internal_Rela rela;
14699 bfd_byte *loc;
14700
14701 htab = ppc_hash_table (info);
14702 if (htab == NULL)
14703 return FALSE;
14704
14705 for (ent = h->plt.plist; ent != NULL; ent = ent->next)
14706 if (ent->plt.offset != (bfd_vma) -1)
14707 {
14708 /* This symbol has an entry in the procedure linkage
14709 table. Set it up. */
14710 if (!htab->elf.dynamic_sections_created
14711 || h->dynindx == -1)
14712 {
14713 BFD_ASSERT (h->type == STT_GNU_IFUNC
14714 && h->def_regular
14715 && (h->root.type == bfd_link_hash_defined
14716 || h->root.type == bfd_link_hash_defweak));
14717 rela.r_offset = (htab->elf.iplt->output_section->vma
14718 + htab->elf.iplt->output_offset
14719 + ent->plt.offset);
14720 if (htab->opd_abi)
14721 rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
14722 else
14723 rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
14724 rela.r_addend = (h->root.u.def.value
14725 + h->root.u.def.section->output_offset
14726 + h->root.u.def.section->output_section->vma
14727 + ent->addend);
14728 loc = (htab->elf.irelplt->contents
14729 + (htab->elf.irelplt->reloc_count++
14730 * sizeof (Elf64_External_Rela)));
14731 }
14732 else
14733 {
14734 rela.r_offset = (htab->elf.splt->output_section->vma
14735 + htab->elf.splt->output_offset
14736 + ent->plt.offset);
14737 rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_JMP_SLOT);
14738 rela.r_addend = ent->addend;
14739 loc = (htab->elf.srelplt->contents
14740 + ((ent->plt.offset - PLT_INITIAL_ENTRY_SIZE (htab))
14741 / PLT_ENTRY_SIZE (htab) * sizeof (Elf64_External_Rela)));
14742 }
14743 bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
14744
14745 if (!htab->opd_abi)
14746 {
14747 if (!h->def_regular)
14748 {
14749 /* Mark the symbol as undefined, rather than as
14750 defined in glink. Leave the value if there were
14751 any relocations where pointer equality matters
14752 (this is a clue for the dynamic linker, to make
14753 function pointer comparisons work between an
14754 application and shared library), otherwise set it
14755 to zero. */
14756 sym->st_shndx = SHN_UNDEF;
14757 if (!h->pointer_equality_needed)
14758 sym->st_value = 0;
14759 else if (!h->ref_regular_nonweak)
14760 {
14761 /* This breaks function pointer comparisons, but
14762 that is better than breaking tests for a NULL
14763 function pointer. */
14764 sym->st_value = 0;
14765 }
14766 }
14767 }
14768 }
14769
14770 if (h->needs_copy)
14771 {
14772 /* This symbol needs a copy reloc. Set it up. */
14773
14774 if (h->dynindx == -1
14775 || (h->root.type != bfd_link_hash_defined
14776 && h->root.type != bfd_link_hash_defweak)
14777 || htab->relbss == NULL)
14778 abort ();
14779
14780 rela.r_offset = (h->root.u.def.value
14781 + h->root.u.def.section->output_section->vma
14782 + h->root.u.def.section->output_offset);
14783 rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_COPY);
14784 rela.r_addend = 0;
14785 loc = htab->relbss->contents;
14786 loc += htab->relbss->reloc_count++ * sizeof (Elf64_External_Rela);
14787 bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
14788 }
14789
14790 return TRUE;
14791 }
14792
14793 /* Used to decide how to sort relocs in an optimal manner for the
14794 dynamic linker, before writing them out. */
14795
14796 static enum elf_reloc_type_class
14797 ppc64_elf_reloc_type_class (const struct bfd_link_info *info,
14798 const asection *rel_sec,
14799 const Elf_Internal_Rela *rela)
14800 {
14801 enum elf_ppc64_reloc_type r_type;
14802 struct ppc_link_hash_table *htab = ppc_hash_table (info);
14803
14804 if (rel_sec == htab->elf.irelplt)
14805 return reloc_class_ifunc;
14806
14807 r_type = ELF64_R_TYPE (rela->r_info);
14808 switch (r_type)
14809 {
14810 case R_PPC64_RELATIVE:
14811 return reloc_class_relative;
14812 case R_PPC64_JMP_SLOT:
14813 return reloc_class_plt;
14814 case R_PPC64_COPY:
14815 return reloc_class_copy;
14816 default:
14817 return reloc_class_normal;
14818 }
14819 }
14820
14821 /* Finish up the dynamic sections. */
14822
14823 static bfd_boolean
14824 ppc64_elf_finish_dynamic_sections (bfd *output_bfd,
14825 struct bfd_link_info *info)
14826 {
14827 struct ppc_link_hash_table *htab;
14828 bfd *dynobj;
14829 asection *sdyn;
14830
14831 htab = ppc_hash_table (info);
14832 if (htab == NULL)
14833 return FALSE;
14834
14835 dynobj = htab->elf.dynobj;
14836 sdyn = bfd_get_linker_section (dynobj, ".dynamic");
14837
14838 if (htab->elf.dynamic_sections_created)
14839 {
14840 Elf64_External_Dyn *dyncon, *dynconend;
14841
14842 if (sdyn == NULL || htab->elf.sgot == NULL)
14843 abort ();
14844
14845 dyncon = (Elf64_External_Dyn *) sdyn->contents;
14846 dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
14847 for (; dyncon < dynconend; dyncon++)
14848 {
14849 Elf_Internal_Dyn dyn;
14850 asection *s;
14851
14852 bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
14853
14854 switch (dyn.d_tag)
14855 {
14856 default:
14857 continue;
14858
14859 case DT_PPC64_GLINK:
14860 s = htab->glink;
14861 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
14862 /* We stupidly defined DT_PPC64_GLINK to be the start
14863 of glink rather than the first entry point, which is
14864 what ld.so needs, and now have a bigger stub to
14865 support automatic multiple TOCs. */
14866 dyn.d_un.d_ptr += GLINK_CALL_STUB_SIZE - 8 * 4;
14867 break;
14868
14869 case DT_PPC64_OPD:
14870 s = bfd_get_section_by_name (output_bfd, ".opd");
14871 if (s == NULL)
14872 continue;
14873 dyn.d_un.d_ptr = s->vma;
14874 break;
14875
14876 case DT_PPC64_OPT:
14877 if (htab->do_multi_toc && htab->multi_toc_needed)
14878 dyn.d_un.d_val |= PPC64_OPT_MULTI_TOC;
14879 break;
14880
14881 case DT_PPC64_OPDSZ:
14882 s = bfd_get_section_by_name (output_bfd, ".opd");
14883 if (s == NULL)
14884 continue;
14885 dyn.d_un.d_val = s->size;
14886 break;
14887
14888 case DT_PLTGOT:
14889 s = htab->elf.splt;
14890 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
14891 break;
14892
14893 case DT_JMPREL:
14894 s = htab->elf.srelplt;
14895 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
14896 break;
14897
14898 case DT_PLTRELSZ:
14899 dyn.d_un.d_val = htab->elf.srelplt->size;
14900 break;
14901
14902 case DT_RELASZ:
14903 /* Don't count procedure linkage table relocs in the
14904 overall reloc count. */
14905 s = htab->elf.srelplt;
14906 if (s == NULL)
14907 continue;
14908 dyn.d_un.d_val -= s->size;
14909 break;
14910
14911 case DT_RELA:
14912 /* We may not be using the standard ELF linker script.
14913 If .rela.plt is the first .rela section, we adjust
14914 DT_RELA to not include it. */
14915 s = htab->elf.srelplt;
14916 if (s == NULL)
14917 continue;
14918 if (dyn.d_un.d_ptr != s->output_section->vma + s->output_offset)
14919 continue;
14920 dyn.d_un.d_ptr += s->size;
14921 break;
14922 }
14923
14924 bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
14925 }
14926 }
14927
14928 if (htab->elf.sgot != NULL && htab->elf.sgot->size != 0)
14929 {
14930 /* Fill in the first entry in the global offset table.
14931 We use it to hold the link-time TOCbase. */
14932 bfd_put_64 (output_bfd,
14933 elf_gp (output_bfd) + TOC_BASE_OFF,
14934 htab->elf.sgot->contents);
14935
14936 /* Set .got entry size. */
14937 elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize = 8;
14938 }
14939
14940 if (htab->elf.splt != NULL && htab->elf.splt->size != 0)
14941 {
14942 /* Set .plt entry size. */
14943 elf_section_data (htab->elf.splt->output_section)->this_hdr.sh_entsize
14944 = PLT_ENTRY_SIZE (htab);
14945 }
14946
14947 /* brlt is SEC_LINKER_CREATED, so we need to write out relocs for
14948 brlt ourselves if emitrelocations. */
14949 if (htab->brlt != NULL
14950 && htab->brlt->reloc_count != 0
14951 && !_bfd_elf_link_output_relocs (output_bfd,
14952 htab->brlt,
14953 elf_section_data (htab->brlt)->rela.hdr,
14954 elf_section_data (htab->brlt)->relocs,
14955 NULL))
14956 return FALSE;
14957
14958 if (htab->glink != NULL
14959 && htab->glink->reloc_count != 0
14960 && !_bfd_elf_link_output_relocs (output_bfd,
14961 htab->glink,
14962 elf_section_data (htab->glink)->rela.hdr,
14963 elf_section_data (htab->glink)->relocs,
14964 NULL))
14965 return FALSE;
14966
14967
14968 if (htab->glink_eh_frame != NULL
14969 && htab->glink_eh_frame->sec_info_type == SEC_INFO_TYPE_EH_FRAME
14970 && !_bfd_elf_write_section_eh_frame (output_bfd, info,
14971 htab->glink_eh_frame,
14972 htab->glink_eh_frame->contents))
14973 return FALSE;
14974
14975 /* We need to handle writing out multiple GOT sections ourselves,
14976 since we didn't add them to DYNOBJ. We know dynobj is the first
14977 bfd. */
14978 while ((dynobj = dynobj->link_next) != NULL)
14979 {
14980 asection *s;
14981
14982 if (!is_ppc64_elf (dynobj))
14983 continue;
14984
14985 s = ppc64_elf_tdata (dynobj)->got;
14986 if (s != NULL
14987 && s->size != 0
14988 && s->output_section != bfd_abs_section_ptr
14989 && !bfd_set_section_contents (output_bfd, s->output_section,
14990 s->contents, s->output_offset,
14991 s->size))
14992 return FALSE;
14993 s = ppc64_elf_tdata (dynobj)->relgot;
14994 if (s != NULL
14995 && s->size != 0
14996 && s->output_section != bfd_abs_section_ptr
14997 && !bfd_set_section_contents (output_bfd, s->output_section,
14998 s->contents, s->output_offset,
14999 s->size))
15000 return FALSE;
15001 }
15002
15003 return TRUE;
15004 }
15005
15006 #include "elf64-target.h"
15007
15008 /* FreeBSD support */
15009
15010 #undef TARGET_LITTLE_SYM
15011 #undef TARGET_LITTLE_NAME
15012
15013 #undef TARGET_BIG_SYM
15014 #define TARGET_BIG_SYM bfd_elf64_powerpc_freebsd_vec
15015 #undef TARGET_BIG_NAME
15016 #define TARGET_BIG_NAME "elf64-powerpc-freebsd"
15017
15018 #undef ELF_OSABI
15019 #define ELF_OSABI ELFOSABI_FREEBSD
15020
15021 #undef elf64_bed
15022 #define elf64_bed elf64_powerpc_fbsd_bed
15023
15024 #include "elf64-target.h"
15025