projects / deliverable / binutils-gdb.git / blob
? search:


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