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