projects / deliverable / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
PowerPC64 linking of --just-symbols objects (klibc)
[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_post_process_headers _bfd_elf_set_osabi
122 #define elf_backend_merge_symbol_attribute ppc64_elf_merge_symbol_attribute
123
124 /* The name of the dynamic interpreter. This is put in the .interp
125 section. */
126 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
127
128 /* The size in bytes of an entry in the procedure linkage table. */
129 #define PLT_ENTRY_SIZE(htab) (htab->opd_abi ? 24 : 8)
130
131 /* The initial size of the plt reserved for the dynamic linker. */
132 #define PLT_INITIAL_ENTRY_SIZE(htab) (htab->opd_abi ? 24 : 16)
133
134 /* Offsets to some stack save slots. */
135 #define STK_LR 16
136 #define STK_TOC(htab) (htab->opd_abi ? 40 : 24)
137 /* This one is dodgy. ABIv2 does not have a linker word, so use the
138 CR save slot. Used only by optimised __tls_get_addr call stub,
139 relying on __tls_get_addr_opt not saving CR.. */
140 #define STK_LINKER(htab) (htab->opd_abi ? 32 : 8)
141
142 /* TOC base pointers offset from start of TOC. */
143 #define TOC_BASE_OFF 0x8000
144
145 /* Offset of tp and dtp pointers from start of TLS block. */
146 #define TP_OFFSET 0x7000
147 #define DTP_OFFSET 0x8000
148
149 /* .plt call stub instructions. The normal stub is like this, but
150 sometimes the .plt entry crosses a 64k boundary and we need to
151 insert an addi to adjust r11. */
152 #define STD_R2_0R1 0xf8410000 /* std %r2,0+40(%r1) */
153 #define ADDIS_R11_R2 0x3d620000 /* addis %r11,%r2,xxx@ha */
154 #define LD_R12_0R11 0xe98b0000 /* ld %r12,xxx+0@l(%r11) */
155 #define MTCTR_R12 0x7d8903a6 /* mtctr %r12 */
156 #define LD_R2_0R11 0xe84b0000 /* ld %r2,xxx+8@l(%r11) */
157 #define LD_R11_0R11 0xe96b0000 /* ld %r11,xxx+16@l(%r11) */
158 #define BCTR 0x4e800420 /* bctr */
159
160 #define ADDI_R11_R11 0x396b0000 /* addi %r11,%r11,off@l */
161 #define ADDIS_R2_R2 0x3c420000 /* addis %r2,%r2,off@ha */
162 #define ADDI_R2_R2 0x38420000 /* addi %r2,%r2,off@l */
163
164 #define XOR_R2_R12_R12 0x7d826278 /* xor %r2,%r12,%r12 */
165 #define ADD_R11_R11_R2 0x7d6b1214 /* add %r11,%r11,%r2 */
166 #define XOR_R11_R12_R12 0x7d8b6278 /* xor %r11,%r12,%r12 */
167 #define ADD_R2_R2_R11 0x7c425a14 /* add %r2,%r2,%r11 */
168 #define CMPLDI_R2_0 0x28220000 /* cmpldi %r2,0 */
169 #define BNECTR 0x4ca20420 /* bnectr+ */
170 #define BNECTR_P4 0x4ce20420 /* bnectr+ */
171
172 #define LD_R12_0R2 0xe9820000 /* ld %r12,xxx+0(%r2) */
173 #define LD_R11_0R2 0xe9620000 /* ld %r11,xxx+0(%r2) */
174 #define LD_R2_0R2 0xe8420000 /* ld %r2,xxx+0(%r2) */
175
176 #define LD_R2_0R1 0xe8410000 /* ld %r2,0(%r1) */
177
178 #define ADDIS_R12_R12 0x3d8c0000 /* addis %r12,%r12,xxx@ha */
179 #define LD_R12_0R12 0xe98c0000 /* ld %r12,xxx@l(%r12) */
180
181 /* glink call stub instructions. We enter with the index in R0. */
182 #define GLINK_CALL_STUB_SIZE (16*4)
183 /* 0: */
184 /* .quad plt0-1f */
185 /* __glink: */
186 #define MFLR_R12 0x7d8802a6 /* mflr %12 */
187 #define BCL_20_31 0x429f0005 /* bcl 20,31,1f */
188 /* 1: */
189 #define MFLR_R11 0x7d6802a6 /* mflr %11 */
190 /* ld %2,(0b-1b)(%11) */
191 #define MTLR_R12 0x7d8803a6 /* mtlr %12 */
192 #define ADD_R11_R2_R11 0x7d625a14 /* add %11,%2,%11 */
193 /* ld %12,0(%11) */
194 /* ld %2,8(%11) */
195 /* mtctr %12 */
196 /* ld %11,16(%11) */
197 /* bctr */
198 #define MFLR_R0 0x7c0802a6 /* mflr %r0 */
199 #define MTLR_R0 0x7c0803a6 /* mtlr %r0 */
200 #define SUB_R12_R12_R11 0x7d8b6050 /* subf %r12,%r11,%r12 */
201 #define ADDI_R0_R12 0x380c0000 /* addi %r0,%r12,0 */
202 #define SRDI_R0_R0_2 0x7800f082 /* rldicl %r0,%r0,62,2 */
203
204 /* Pad with this. */
205 #define NOP 0x60000000
206
207 /* Some other nops. */
208 #define CROR_151515 0x4def7b82
209 #define CROR_313131 0x4ffffb82
210
211 /* .glink entries for the first 32k functions are two instructions. */
212 #define LI_R0_0 0x38000000 /* li %r0,0 */
213 #define B_DOT 0x48000000 /* b . */
214
215 /* After that, we need two instructions to load the index, followed by
216 a branch. */
217 #define LIS_R0_0 0x3c000000 /* lis %r0,0 */
218 #define ORI_R0_R0_0 0x60000000 /* ori %r0,%r0,0 */
219
220 /* Instructions used by the save and restore reg functions. */
221 #define STD_R0_0R1 0xf8010000 /* std %r0,0(%r1) */
222 #define STD_R0_0R12 0xf80c0000 /* std %r0,0(%r12) */
223 #define LD_R0_0R1 0xe8010000 /* ld %r0,0(%r1) */
224 #define LD_R0_0R12 0xe80c0000 /* ld %r0,0(%r12) */
225 #define STFD_FR0_0R1 0xd8010000 /* stfd %fr0,0(%r1) */
226 #define LFD_FR0_0R1 0xc8010000 /* lfd %fr0,0(%r1) */
227 #define LI_R12_0 0x39800000 /* li %r12,0 */
228 #define STVX_VR0_R12_R0 0x7c0c01ce /* stvx %v0,%r12,%r0 */
229 #define LVX_VR0_R12_R0 0x7c0c00ce /* lvx %v0,%r12,%r0 */
230 #define MTLR_R0 0x7c0803a6 /* mtlr %r0 */
231 #define BLR 0x4e800020 /* blr */
232
233 /* Since .opd is an array of descriptors and each entry will end up
234 with identical R_PPC64_RELATIVE relocs, there is really no need to
235 propagate .opd relocs; The dynamic linker should be taught to
236 relocate .opd without reloc entries. */
237 #ifndef NO_OPD_RELOCS
238 #define NO_OPD_RELOCS 0
239 #endif
240 \f
241 #define ONES(n) (((bfd_vma) 1 << ((n) - 1) << 1) - 1)
242
243 /* Relocation HOWTO's. */
244 static reloc_howto_type *ppc64_elf_howto_table[(int) R_PPC64_max];
245
246 static reloc_howto_type ppc64_elf_howto_raw[] = {
247 /* This reloc does nothing. */
248 HOWTO (R_PPC64_NONE, /* type */
249 0, /* rightshift */
250 2, /* size (0 = byte, 1 = short, 2 = long) */
251 32, /* bitsize */
252 FALSE, /* pc_relative */
253 0, /* bitpos */
254 complain_overflow_dont, /* complain_on_overflow */
255 bfd_elf_generic_reloc, /* special_function */
256 "R_PPC64_NONE", /* name */
257 FALSE, /* partial_inplace */
258 0, /* src_mask */
259 0, /* dst_mask */
260 FALSE), /* pcrel_offset */
261
262 /* A standard 32 bit relocation. */
263 HOWTO (R_PPC64_ADDR32, /* type */
264 0, /* rightshift */
265 2, /* size (0 = byte, 1 = short, 2 = long) */
266 32, /* bitsize */
267 FALSE, /* pc_relative */
268 0, /* bitpos */
269 complain_overflow_bitfield, /* complain_on_overflow */
270 bfd_elf_generic_reloc, /* special_function */
271 "R_PPC64_ADDR32", /* name */
272 FALSE, /* partial_inplace */
273 0, /* src_mask */
274 0xffffffff, /* dst_mask */
275 FALSE), /* pcrel_offset */
276
277 /* An absolute 26 bit branch; the lower two bits must be zero.
278 FIXME: we don't check that, we just clear them. */
279 HOWTO (R_PPC64_ADDR24, /* type */
280 0, /* rightshift */
281 2, /* size (0 = byte, 1 = short, 2 = long) */
282 26, /* bitsize */
283 FALSE, /* pc_relative */
284 0, /* bitpos */
285 complain_overflow_bitfield, /* complain_on_overflow */
286 bfd_elf_generic_reloc, /* special_function */
287 "R_PPC64_ADDR24", /* name */
288 FALSE, /* partial_inplace */
289 0, /* src_mask */
290 0x03fffffc, /* dst_mask */
291 FALSE), /* pcrel_offset */
292
293 /* A standard 16 bit relocation. */
294 HOWTO (R_PPC64_ADDR16, /* type */
295 0, /* rightshift */
296 1, /* size (0 = byte, 1 = short, 2 = long) */
297 16, /* bitsize */
298 FALSE, /* pc_relative */
299 0, /* bitpos */
300 complain_overflow_bitfield, /* complain_on_overflow */
301 bfd_elf_generic_reloc, /* special_function */
302 "R_PPC64_ADDR16", /* name */
303 FALSE, /* partial_inplace */
304 0, /* src_mask */
305 0xffff, /* dst_mask */
306 FALSE), /* pcrel_offset */
307
308 /* A 16 bit relocation without overflow. */
309 HOWTO (R_PPC64_ADDR16_LO, /* type */
310 0, /* rightshift */
311 1, /* size (0 = byte, 1 = short, 2 = long) */
312 16, /* bitsize */
313 FALSE, /* pc_relative */
314 0, /* bitpos */
315 complain_overflow_dont,/* complain_on_overflow */
316 bfd_elf_generic_reloc, /* special_function */
317 "R_PPC64_ADDR16_LO", /* name */
318 FALSE, /* partial_inplace */
319 0, /* src_mask */
320 0xffff, /* dst_mask */
321 FALSE), /* pcrel_offset */
322
323 /* Bits 16-31 of an address. */
324 HOWTO (R_PPC64_ADDR16_HI, /* type */
325 16, /* rightshift */
326 1, /* size (0 = byte, 1 = short, 2 = long) */
327 16, /* bitsize */
328 FALSE, /* pc_relative */
329 0, /* bitpos */
330 complain_overflow_signed, /* complain_on_overflow */
331 bfd_elf_generic_reloc, /* special_function */
332 "R_PPC64_ADDR16_HI", /* name */
333 FALSE, /* partial_inplace */
334 0, /* src_mask */
335 0xffff, /* dst_mask */
336 FALSE), /* pcrel_offset */
337
338 /* Bits 16-31 of an address, plus 1 if the contents of the low 16
339 bits, treated as a signed number, is negative. */
340 HOWTO (R_PPC64_ADDR16_HA, /* type */
341 16, /* rightshift */
342 1, /* size (0 = byte, 1 = short, 2 = long) */
343 16, /* bitsize */
344 FALSE, /* pc_relative */
345 0, /* bitpos */
346 complain_overflow_signed, /* complain_on_overflow */
347 ppc64_elf_ha_reloc, /* special_function */
348 "R_PPC64_ADDR16_HA", /* name */
349 FALSE, /* partial_inplace */
350 0, /* src_mask */
351 0xffff, /* dst_mask */
352 FALSE), /* pcrel_offset */
353
354 /* An absolute 16 bit branch; the lower two bits must be zero.
355 FIXME: we don't check that, we just clear them. */
356 HOWTO (R_PPC64_ADDR14, /* type */
357 0, /* rightshift */
358 2, /* size (0 = byte, 1 = short, 2 = long) */
359 16, /* bitsize */
360 FALSE, /* pc_relative */
361 0, /* bitpos */
362 complain_overflow_bitfield, /* complain_on_overflow */
363 ppc64_elf_branch_reloc, /* special_function */
364 "R_PPC64_ADDR14", /* name */
365 FALSE, /* partial_inplace */
366 0, /* src_mask */
367 0x0000fffc, /* dst_mask */
368 FALSE), /* pcrel_offset */
369
370 /* An absolute 16 bit branch, for which bit 10 should be set to
371 indicate that the branch is expected to be taken. The lower two
372 bits must be zero. */
373 HOWTO (R_PPC64_ADDR14_BRTAKEN, /* type */
374 0, /* rightshift */
375 2, /* size (0 = byte, 1 = short, 2 = long) */
376 16, /* bitsize */
377 FALSE, /* pc_relative */
378 0, /* bitpos */
379 complain_overflow_bitfield, /* complain_on_overflow */
380 ppc64_elf_brtaken_reloc, /* special_function */
381 "R_PPC64_ADDR14_BRTAKEN",/* name */
382 FALSE, /* partial_inplace */
383 0, /* src_mask */
384 0x0000fffc, /* dst_mask */
385 FALSE), /* pcrel_offset */
386
387 /* An absolute 16 bit branch, for which bit 10 should be set to
388 indicate that the branch is not expected to be taken. The lower
389 two bits must be zero. */
390 HOWTO (R_PPC64_ADDR14_BRNTAKEN, /* type */
391 0, /* rightshift */
392 2, /* size (0 = byte, 1 = short, 2 = long) */
393 16, /* bitsize */
394 FALSE, /* pc_relative */
395 0, /* bitpos */
396 complain_overflow_bitfield, /* complain_on_overflow */
397 ppc64_elf_brtaken_reloc, /* special_function */
398 "R_PPC64_ADDR14_BRNTAKEN",/* name */
399 FALSE, /* partial_inplace */
400 0, /* src_mask */
401 0x0000fffc, /* dst_mask */
402 FALSE), /* pcrel_offset */
403
404 /* A relative 26 bit branch; the lower two bits must be zero. */
405 HOWTO (R_PPC64_REL24, /* type */
406 0, /* rightshift */
407 2, /* size (0 = byte, 1 = short, 2 = long) */
408 26, /* bitsize */
409 TRUE, /* pc_relative */
410 0, /* bitpos */
411 complain_overflow_signed, /* complain_on_overflow */
412 ppc64_elf_branch_reloc, /* special_function */
413 "R_PPC64_REL24", /* name */
414 FALSE, /* partial_inplace */
415 0, /* src_mask */
416 0x03fffffc, /* dst_mask */
417 TRUE), /* pcrel_offset */
418
419 /* A relative 16 bit branch; the lower two bits must be zero. */
420 HOWTO (R_PPC64_REL14, /* type */
421 0, /* rightshift */
422 2, /* size (0 = byte, 1 = short, 2 = long) */
423 16, /* bitsize */
424 TRUE, /* pc_relative */
425 0, /* bitpos */
426 complain_overflow_signed, /* complain_on_overflow */
427 ppc64_elf_branch_reloc, /* special_function */
428 "R_PPC64_REL14", /* name */
429 FALSE, /* partial_inplace */
430 0, /* src_mask */
431 0x0000fffc, /* dst_mask */
432 TRUE), /* pcrel_offset */
433
434 /* A relative 16 bit branch. Bit 10 should be set to indicate that
435 the branch is expected to be taken. The lower two bits must be
436 zero. */
437 HOWTO (R_PPC64_REL14_BRTAKEN, /* type */
438 0, /* rightshift */
439 2, /* size (0 = byte, 1 = short, 2 = long) */
440 16, /* bitsize */
441 TRUE, /* pc_relative */
442 0, /* bitpos */
443 complain_overflow_signed, /* complain_on_overflow */
444 ppc64_elf_brtaken_reloc, /* special_function */
445 "R_PPC64_REL14_BRTAKEN", /* name */
446 FALSE, /* partial_inplace */
447 0, /* src_mask */
448 0x0000fffc, /* dst_mask */
449 TRUE), /* pcrel_offset */
450
451 /* A relative 16 bit branch. Bit 10 should be set to indicate that
452 the branch is not expected to be taken. The lower two bits must
453 be zero. */
454 HOWTO (R_PPC64_REL14_BRNTAKEN, /* type */
455 0, /* rightshift */
456 2, /* size (0 = byte, 1 = short, 2 = long) */
457 16, /* bitsize */
458 TRUE, /* pc_relative */
459 0, /* bitpos */
460 complain_overflow_signed, /* complain_on_overflow */
461 ppc64_elf_brtaken_reloc, /* special_function */
462 "R_PPC64_REL14_BRNTAKEN",/* name */
463 FALSE, /* partial_inplace */
464 0, /* src_mask */
465 0x0000fffc, /* dst_mask */
466 TRUE), /* pcrel_offset */
467
468 /* Like R_PPC64_ADDR16, but referring to the GOT table entry for the
469 symbol. */
470 HOWTO (R_PPC64_GOT16, /* type */
471 0, /* rightshift */
472 1, /* size (0 = byte, 1 = short, 2 = long) */
473 16, /* bitsize */
474 FALSE, /* pc_relative */
475 0, /* bitpos */
476 complain_overflow_signed, /* complain_on_overflow */
477 ppc64_elf_unhandled_reloc, /* special_function */
478 "R_PPC64_GOT16", /* name */
479 FALSE, /* partial_inplace */
480 0, /* src_mask */
481 0xffff, /* dst_mask */
482 FALSE), /* pcrel_offset */
483
484 /* Like R_PPC64_ADDR16_LO, but referring to the GOT table entry for
485 the symbol. */
486 HOWTO (R_PPC64_GOT16_LO, /* type */
487 0, /* rightshift */
488 1, /* size (0 = byte, 1 = short, 2 = long) */
489 16, /* bitsize */
490 FALSE, /* pc_relative */
491 0, /* bitpos */
492 complain_overflow_dont, /* complain_on_overflow */
493 ppc64_elf_unhandled_reloc, /* special_function */
494 "R_PPC64_GOT16_LO", /* name */
495 FALSE, /* partial_inplace */
496 0, /* src_mask */
497 0xffff, /* dst_mask */
498 FALSE), /* pcrel_offset */
499
500 /* Like R_PPC64_ADDR16_HI, but referring to the GOT table entry for
501 the symbol. */
502 HOWTO (R_PPC64_GOT16_HI, /* type */
503 16, /* rightshift */
504 1, /* size (0 = byte, 1 = short, 2 = long) */
505 16, /* bitsize */
506 FALSE, /* pc_relative */
507 0, /* bitpos */
508 complain_overflow_signed,/* complain_on_overflow */
509 ppc64_elf_unhandled_reloc, /* special_function */
510 "R_PPC64_GOT16_HI", /* name */
511 FALSE, /* partial_inplace */
512 0, /* src_mask */
513 0xffff, /* dst_mask */
514 FALSE), /* pcrel_offset */
515
516 /* Like R_PPC64_ADDR16_HA, but referring to the GOT table entry for
517 the symbol. */
518 HOWTO (R_PPC64_GOT16_HA, /* type */
519 16, /* rightshift */
520 1, /* size (0 = byte, 1 = short, 2 = long) */
521 16, /* bitsize */
522 FALSE, /* pc_relative */
523 0, /* bitpos */
524 complain_overflow_signed,/* complain_on_overflow */
525 ppc64_elf_unhandled_reloc, /* special_function */
526 "R_PPC64_GOT16_HA", /* name */
527 FALSE, /* partial_inplace */
528 0, /* src_mask */
529 0xffff, /* dst_mask */
530 FALSE), /* pcrel_offset */
531
532 /* This is used only by the dynamic linker. The symbol should exist
533 both in the object being run and in some shared library. The
534 dynamic linker copies the data addressed by the symbol from the
535 shared library into the object, because the object being
536 run has to have the data at some particular address. */
537 HOWTO (R_PPC64_COPY, /* type */
538 0, /* rightshift */
539 0, /* this one is variable size */
540 0, /* bitsize */
541 FALSE, /* pc_relative */
542 0, /* bitpos */
543 complain_overflow_dont, /* complain_on_overflow */
544 ppc64_elf_unhandled_reloc, /* special_function */
545 "R_PPC64_COPY", /* name */
546 FALSE, /* partial_inplace */
547 0, /* src_mask */
548 0, /* dst_mask */
549 FALSE), /* pcrel_offset */
550
551 /* Like R_PPC64_ADDR64, but used when setting global offset table
552 entries. */
553 HOWTO (R_PPC64_GLOB_DAT, /* type */
554 0, /* rightshift */
555 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
556 64, /* bitsize */
557 FALSE, /* pc_relative */
558 0, /* bitpos */
559 complain_overflow_dont, /* complain_on_overflow */
560 ppc64_elf_unhandled_reloc, /* special_function */
561 "R_PPC64_GLOB_DAT", /* name */
562 FALSE, /* partial_inplace */
563 0, /* src_mask */
564 ONES (64), /* dst_mask */
565 FALSE), /* pcrel_offset */
566
567 /* Created by the link editor. Marks a procedure linkage table
568 entry for a symbol. */
569 HOWTO (R_PPC64_JMP_SLOT, /* type */
570 0, /* rightshift */
571 0, /* size (0 = byte, 1 = short, 2 = long) */
572 0, /* bitsize */
573 FALSE, /* pc_relative */
574 0, /* bitpos */
575 complain_overflow_dont, /* complain_on_overflow */
576 ppc64_elf_unhandled_reloc, /* special_function */
577 "R_PPC64_JMP_SLOT", /* name */
578 FALSE, /* partial_inplace */
579 0, /* src_mask */
580 0, /* dst_mask */
581 FALSE), /* pcrel_offset */
582
583 /* Used only by the dynamic linker. When the object is run, this
584 doubleword64 is set to the load address of the object, plus the
585 addend. */
586 HOWTO (R_PPC64_RELATIVE, /* type */
587 0, /* rightshift */
588 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
589 64, /* bitsize */
590 FALSE, /* pc_relative */
591 0, /* bitpos */
592 complain_overflow_dont, /* complain_on_overflow */
593 bfd_elf_generic_reloc, /* special_function */
594 "R_PPC64_RELATIVE", /* name */
595 FALSE, /* partial_inplace */
596 0, /* src_mask */
597 ONES (64), /* dst_mask */
598 FALSE), /* pcrel_offset */
599
600 /* Like R_PPC64_ADDR32, but may be unaligned. */
601 HOWTO (R_PPC64_UADDR32, /* type */
602 0, /* rightshift */
603 2, /* size (0 = byte, 1 = short, 2 = long) */
604 32, /* bitsize */
605 FALSE, /* pc_relative */
606 0, /* bitpos */
607 complain_overflow_bitfield, /* complain_on_overflow */
608 bfd_elf_generic_reloc, /* special_function */
609 "R_PPC64_UADDR32", /* name */
610 FALSE, /* partial_inplace */
611 0, /* src_mask */
612 0xffffffff, /* dst_mask */
613 FALSE), /* pcrel_offset */
614
615 /* Like R_PPC64_ADDR16, but may be unaligned. */
616 HOWTO (R_PPC64_UADDR16, /* type */
617 0, /* rightshift */
618 1, /* size (0 = byte, 1 = short, 2 = long) */
619 16, /* bitsize */
620 FALSE, /* pc_relative */
621 0, /* bitpos */
622 complain_overflow_bitfield, /* complain_on_overflow */
623 bfd_elf_generic_reloc, /* special_function */
624 "R_PPC64_UADDR16", /* name */
625 FALSE, /* partial_inplace */
626 0, /* src_mask */
627 0xffff, /* dst_mask */
628 FALSE), /* pcrel_offset */
629
630 /* 32-bit PC relative. */
631 HOWTO (R_PPC64_REL32, /* type */
632 0, /* rightshift */
633 2, /* size (0 = byte, 1 = short, 2 = long) */
634 32, /* bitsize */
635 TRUE, /* pc_relative */
636 0, /* bitpos */
637 /* FIXME: Verify. Was complain_overflow_bitfield. */
638 complain_overflow_signed, /* complain_on_overflow */
639 bfd_elf_generic_reloc, /* special_function */
640 "R_PPC64_REL32", /* name */
641 FALSE, /* partial_inplace */
642 0, /* src_mask */
643 0xffffffff, /* dst_mask */
644 TRUE), /* pcrel_offset */
645
646 /* 32-bit relocation to the symbol's procedure linkage table. */
647 HOWTO (R_PPC64_PLT32, /* type */
648 0, /* rightshift */
649 2, /* size (0 = byte, 1 = short, 2 = long) */
650 32, /* bitsize */
651 FALSE, /* pc_relative */
652 0, /* bitpos */
653 complain_overflow_bitfield, /* complain_on_overflow */
654 ppc64_elf_unhandled_reloc, /* special_function */
655 "R_PPC64_PLT32", /* name */
656 FALSE, /* partial_inplace */
657 0, /* src_mask */
658 0xffffffff, /* dst_mask */
659 FALSE), /* pcrel_offset */
660
661 /* 32-bit PC relative relocation to the symbol's procedure linkage table.
662 FIXME: R_PPC64_PLTREL32 not supported. */
663 HOWTO (R_PPC64_PLTREL32, /* type */
664 0, /* rightshift */
665 2, /* size (0 = byte, 1 = short, 2 = long) */
666 32, /* bitsize */
667 TRUE, /* pc_relative */
668 0, /* bitpos */
669 complain_overflow_signed, /* complain_on_overflow */
670 bfd_elf_generic_reloc, /* special_function */
671 "R_PPC64_PLTREL32", /* name */
672 FALSE, /* partial_inplace */
673 0, /* src_mask */
674 0xffffffff, /* dst_mask */
675 TRUE), /* pcrel_offset */
676
677 /* Like R_PPC64_ADDR16_LO, but referring to the PLT table entry for
678 the symbol. */
679 HOWTO (R_PPC64_PLT16_LO, /* type */
680 0, /* rightshift */
681 1, /* size (0 = byte, 1 = short, 2 = long) */
682 16, /* bitsize */
683 FALSE, /* pc_relative */
684 0, /* bitpos */
685 complain_overflow_dont, /* complain_on_overflow */
686 ppc64_elf_unhandled_reloc, /* special_function */
687 "R_PPC64_PLT16_LO", /* name */
688 FALSE, /* partial_inplace */
689 0, /* src_mask */
690 0xffff, /* dst_mask */
691 FALSE), /* pcrel_offset */
692
693 /* Like R_PPC64_ADDR16_HI, but referring to the PLT table entry for
694 the symbol. */
695 HOWTO (R_PPC64_PLT16_HI, /* type */
696 16, /* rightshift */
697 1, /* size (0 = byte, 1 = short, 2 = long) */
698 16, /* bitsize */
699 FALSE, /* pc_relative */
700 0, /* bitpos */
701 complain_overflow_signed, /* complain_on_overflow */
702 ppc64_elf_unhandled_reloc, /* special_function */
703 "R_PPC64_PLT16_HI", /* name */
704 FALSE, /* partial_inplace */
705 0, /* src_mask */
706 0xffff, /* dst_mask */
707 FALSE), /* pcrel_offset */
708
709 /* Like R_PPC64_ADDR16_HA, but referring to the PLT table entry for
710 the symbol. */
711 HOWTO (R_PPC64_PLT16_HA, /* type */
712 16, /* rightshift */
713 1, /* size (0 = byte, 1 = short, 2 = long) */
714 16, /* bitsize */
715 FALSE, /* pc_relative */
716 0, /* bitpos */
717 complain_overflow_signed, /* complain_on_overflow */
718 ppc64_elf_unhandled_reloc, /* special_function */
719 "R_PPC64_PLT16_HA", /* name */
720 FALSE, /* partial_inplace */
721 0, /* src_mask */
722 0xffff, /* dst_mask */
723 FALSE), /* pcrel_offset */
724
725 /* 16-bit section relative relocation. */
726 HOWTO (R_PPC64_SECTOFF, /* type */
727 0, /* rightshift */
728 1, /* size (0 = byte, 1 = short, 2 = long) */
729 16, /* bitsize */
730 FALSE, /* pc_relative */
731 0, /* bitpos */
732 complain_overflow_bitfield, /* complain_on_overflow */
733 ppc64_elf_sectoff_reloc, /* special_function */
734 "R_PPC64_SECTOFF", /* name */
735 FALSE, /* partial_inplace */
736 0, /* src_mask */
737 0xffff, /* dst_mask */
738 FALSE), /* pcrel_offset */
739
740 /* Like R_PPC64_SECTOFF, but no overflow warning. */
741 HOWTO (R_PPC64_SECTOFF_LO, /* type */
742 0, /* rightshift */
743 1, /* size (0 = byte, 1 = short, 2 = long) */
744 16, /* bitsize */
745 FALSE, /* pc_relative */
746 0, /* bitpos */
747 complain_overflow_dont, /* complain_on_overflow */
748 ppc64_elf_sectoff_reloc, /* special_function */
749 "R_PPC64_SECTOFF_LO", /* name */
750 FALSE, /* partial_inplace */
751 0, /* src_mask */
752 0xffff, /* dst_mask */
753 FALSE), /* pcrel_offset */
754
755 /* 16-bit upper half section relative relocation. */
756 HOWTO (R_PPC64_SECTOFF_HI, /* type */
757 16, /* rightshift */
758 1, /* size (0 = byte, 1 = short, 2 = long) */
759 16, /* bitsize */
760 FALSE, /* pc_relative */
761 0, /* bitpos */
762 complain_overflow_signed, /* complain_on_overflow */
763 ppc64_elf_sectoff_reloc, /* special_function */
764 "R_PPC64_SECTOFF_HI", /* name */
765 FALSE, /* partial_inplace */
766 0, /* src_mask */
767 0xffff, /* dst_mask */
768 FALSE), /* pcrel_offset */
769
770 /* 16-bit upper half adjusted section relative relocation. */
771 HOWTO (R_PPC64_SECTOFF_HA, /* type */
772 16, /* rightshift */
773 1, /* size (0 = byte, 1 = short, 2 = long) */
774 16, /* bitsize */
775 FALSE, /* pc_relative */
776 0, /* bitpos */
777 complain_overflow_signed, /* complain_on_overflow */
778 ppc64_elf_sectoff_ha_reloc, /* special_function */
779 "R_PPC64_SECTOFF_HA", /* name */
780 FALSE, /* partial_inplace */
781 0, /* src_mask */
782 0xffff, /* dst_mask */
783 FALSE), /* pcrel_offset */
784
785 /* Like R_PPC64_REL24 without touching the two least significant bits. */
786 HOWTO (R_PPC64_REL30, /* type */
787 2, /* rightshift */
788 2, /* size (0 = byte, 1 = short, 2 = long) */
789 30, /* bitsize */
790 TRUE, /* pc_relative */
791 0, /* bitpos */
792 complain_overflow_dont, /* complain_on_overflow */
793 bfd_elf_generic_reloc, /* special_function */
794 "R_PPC64_REL30", /* name */
795 FALSE, /* partial_inplace */
796 0, /* src_mask */
797 0xfffffffc, /* dst_mask */
798 TRUE), /* pcrel_offset */
799
800 /* Relocs in the 64-bit PowerPC ELF ABI, not in the 32-bit ABI. */
801
802 /* A standard 64-bit relocation. */
803 HOWTO (R_PPC64_ADDR64, /* type */
804 0, /* rightshift */
805 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
806 64, /* bitsize */
807 FALSE, /* pc_relative */
808 0, /* bitpos */
809 complain_overflow_dont, /* complain_on_overflow */
810 bfd_elf_generic_reloc, /* special_function */
811 "R_PPC64_ADDR64", /* name */
812 FALSE, /* partial_inplace */
813 0, /* src_mask */
814 ONES (64), /* dst_mask */
815 FALSE), /* pcrel_offset */
816
817 /* The bits 32-47 of an address. */
818 HOWTO (R_PPC64_ADDR16_HIGHER, /* type */
819 32, /* rightshift */
820 1, /* size (0 = byte, 1 = short, 2 = long) */
821 16, /* bitsize */
822 FALSE, /* pc_relative */
823 0, /* bitpos */
824 complain_overflow_dont, /* complain_on_overflow */
825 bfd_elf_generic_reloc, /* special_function */
826 "R_PPC64_ADDR16_HIGHER", /* name */
827 FALSE, /* partial_inplace */
828 0, /* src_mask */
829 0xffff, /* dst_mask */
830 FALSE), /* pcrel_offset */
831
832 /* The bits 32-47 of an address, plus 1 if the contents of the low
833 16 bits, treated as a signed number, is negative. */
834 HOWTO (R_PPC64_ADDR16_HIGHERA, /* type */
835 32, /* rightshift */
836 1, /* size (0 = byte, 1 = short, 2 = long) */
837 16, /* bitsize */
838 FALSE, /* pc_relative */
839 0, /* bitpos */
840 complain_overflow_dont, /* complain_on_overflow */
841 ppc64_elf_ha_reloc, /* special_function */
842 "R_PPC64_ADDR16_HIGHERA", /* name */
843 FALSE, /* partial_inplace */
844 0, /* src_mask */
845 0xffff, /* dst_mask */
846 FALSE), /* pcrel_offset */
847
848 /* The bits 48-63 of an address. */
849 HOWTO (R_PPC64_ADDR16_HIGHEST,/* type */
850 48, /* rightshift */
851 1, /* size (0 = byte, 1 = short, 2 = long) */
852 16, /* bitsize */
853 FALSE, /* pc_relative */
854 0, /* bitpos */
855 complain_overflow_dont, /* complain_on_overflow */
856 bfd_elf_generic_reloc, /* special_function */
857 "R_PPC64_ADDR16_HIGHEST", /* name */
858 FALSE, /* partial_inplace */
859 0, /* src_mask */
860 0xffff, /* dst_mask */
861 FALSE), /* pcrel_offset */
862
863 /* The bits 48-63 of an address, plus 1 if the contents of the low
864 16 bits, treated as a signed number, is negative. */
865 HOWTO (R_PPC64_ADDR16_HIGHESTA,/* type */
866 48, /* rightshift */
867 1, /* size (0 = byte, 1 = short, 2 = long) */
868 16, /* bitsize */
869 FALSE, /* pc_relative */
870 0, /* bitpos */
871 complain_overflow_dont, /* complain_on_overflow */
872 ppc64_elf_ha_reloc, /* special_function */
873 "R_PPC64_ADDR16_HIGHESTA", /* name */
874 FALSE, /* partial_inplace */
875 0, /* src_mask */
876 0xffff, /* dst_mask */
877 FALSE), /* pcrel_offset */
878
879 /* Like ADDR64, but may be unaligned. */
880 HOWTO (R_PPC64_UADDR64, /* type */
881 0, /* rightshift */
882 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
883 64, /* bitsize */
884 FALSE, /* pc_relative */
885 0, /* bitpos */
886 complain_overflow_dont, /* complain_on_overflow */
887 bfd_elf_generic_reloc, /* special_function */
888 "R_PPC64_UADDR64", /* name */
889 FALSE, /* partial_inplace */
890 0, /* src_mask */
891 ONES (64), /* dst_mask */
892 FALSE), /* pcrel_offset */
893
894 /* 64-bit relative relocation. */
895 HOWTO (R_PPC64_REL64, /* type */
896 0, /* rightshift */
897 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
898 64, /* bitsize */
899 TRUE, /* pc_relative */
900 0, /* bitpos */
901 complain_overflow_dont, /* complain_on_overflow */
902 bfd_elf_generic_reloc, /* special_function */
903 "R_PPC64_REL64", /* name */
904 FALSE, /* partial_inplace */
905 0, /* src_mask */
906 ONES (64), /* dst_mask */
907 TRUE), /* pcrel_offset */
908
909 /* 64-bit relocation to the symbol's procedure linkage table. */
910 HOWTO (R_PPC64_PLT64, /* type */
911 0, /* rightshift */
912 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
913 64, /* bitsize */
914 FALSE, /* pc_relative */
915 0, /* bitpos */
916 complain_overflow_dont, /* complain_on_overflow */
917 ppc64_elf_unhandled_reloc, /* special_function */
918 "R_PPC64_PLT64", /* name */
919 FALSE, /* partial_inplace */
920 0, /* src_mask */
921 ONES (64), /* dst_mask */
922 FALSE), /* pcrel_offset */
923
924 /* 64-bit PC relative relocation to the symbol's procedure linkage
925 table. */
926 /* FIXME: R_PPC64_PLTREL64 not supported. */
927 HOWTO (R_PPC64_PLTREL64, /* type */
928 0, /* rightshift */
929 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
930 64, /* bitsize */
931 TRUE, /* pc_relative */
932 0, /* bitpos */
933 complain_overflow_dont, /* complain_on_overflow */
934 ppc64_elf_unhandled_reloc, /* special_function */
935 "R_PPC64_PLTREL64", /* name */
936 FALSE, /* partial_inplace */
937 0, /* src_mask */
938 ONES (64), /* dst_mask */
939 TRUE), /* pcrel_offset */
940
941 /* 16 bit TOC-relative relocation. */
942
943 /* R_PPC64_TOC16 47 half16* S + A - .TOC. */
944 HOWTO (R_PPC64_TOC16, /* type */
945 0, /* rightshift */
946 1, /* size (0 = byte, 1 = short, 2 = long) */
947 16, /* bitsize */
948 FALSE, /* pc_relative */
949 0, /* bitpos */
950 complain_overflow_signed, /* complain_on_overflow */
951 ppc64_elf_toc_reloc, /* special_function */
952 "R_PPC64_TOC16", /* name */
953 FALSE, /* partial_inplace */
954 0, /* src_mask */
955 0xffff, /* dst_mask */
956 FALSE), /* pcrel_offset */
957
958 /* 16 bit TOC-relative relocation without overflow. */
959
960 /* R_PPC64_TOC16_LO 48 half16 #lo (S + A - .TOC.) */
961 HOWTO (R_PPC64_TOC16_LO, /* type */
962 0, /* rightshift */
963 1, /* size (0 = byte, 1 = short, 2 = long) */
964 16, /* bitsize */
965 FALSE, /* pc_relative */
966 0, /* bitpos */
967 complain_overflow_dont, /* complain_on_overflow */
968 ppc64_elf_toc_reloc, /* special_function */
969 "R_PPC64_TOC16_LO", /* name */
970 FALSE, /* partial_inplace */
971 0, /* src_mask */
972 0xffff, /* dst_mask */
973 FALSE), /* pcrel_offset */
974
975 /* 16 bit TOC-relative relocation, high 16 bits. */
976
977 /* R_PPC64_TOC16_HI 49 half16 #hi (S + A - .TOC.) */
978 HOWTO (R_PPC64_TOC16_HI, /* type */
979 16, /* rightshift */
980 1, /* size (0 = byte, 1 = short, 2 = long) */
981 16, /* bitsize */
982 FALSE, /* pc_relative */
983 0, /* bitpos */
984 complain_overflow_signed, /* complain_on_overflow */
985 ppc64_elf_toc_reloc, /* special_function */
986 "R_PPC64_TOC16_HI", /* name */
987 FALSE, /* partial_inplace */
988 0, /* src_mask */
989 0xffff, /* dst_mask */
990 FALSE), /* pcrel_offset */
991
992 /* 16 bit TOC-relative relocation, high 16 bits, plus 1 if the
993 contents of the low 16 bits, treated as a signed number, is
994 negative. */
995
996 /* R_PPC64_TOC16_HA 50 half16 #ha (S + A - .TOC.) */
997 HOWTO (R_PPC64_TOC16_HA, /* type */
998 16, /* rightshift */
999 1, /* size (0 = byte, 1 = short, 2 = long) */
1000 16, /* bitsize */
1001 FALSE, /* pc_relative */
1002 0, /* bitpos */
1003 complain_overflow_signed, /* complain_on_overflow */
1004 ppc64_elf_toc_ha_reloc, /* special_function */
1005 "R_PPC64_TOC16_HA", /* name */
1006 FALSE, /* partial_inplace */
1007 0, /* src_mask */
1008 0xffff, /* dst_mask */
1009 FALSE), /* pcrel_offset */
1010
1011 /* 64-bit relocation; insert value of TOC base (.TOC.). */
1012
1013 /* R_PPC64_TOC 51 doubleword64 .TOC. */
1014 HOWTO (R_PPC64_TOC, /* type */
1015 0, /* rightshift */
1016 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1017 64, /* bitsize */
1018 FALSE, /* pc_relative */
1019 0, /* bitpos */
1020 complain_overflow_bitfield, /* complain_on_overflow */
1021 ppc64_elf_toc64_reloc, /* special_function */
1022 "R_PPC64_TOC", /* name */
1023 FALSE, /* partial_inplace */
1024 0, /* src_mask */
1025 ONES (64), /* dst_mask */
1026 FALSE), /* pcrel_offset */
1027
1028 /* Like R_PPC64_GOT16, but also informs the link editor that the
1029 value to relocate may (!) refer to a PLT entry which the link
1030 editor (a) may replace with the symbol value. If the link editor
1031 is unable to fully resolve the symbol, it may (b) create a PLT
1032 entry and store the address to the new PLT entry in the GOT.
1033 This permits lazy resolution of function symbols at run time.
1034 The link editor may also skip all of this and just (c) emit a
1035 R_PPC64_GLOB_DAT to tie the symbol to the GOT entry. */
1036 /* FIXME: R_PPC64_PLTGOT16 not implemented. */
1037 HOWTO (R_PPC64_PLTGOT16, /* type */
1038 0, /* rightshift */
1039 1, /* size (0 = byte, 1 = short, 2 = long) */
1040 16, /* bitsize */
1041 FALSE, /* pc_relative */
1042 0, /* bitpos */
1043 complain_overflow_signed, /* complain_on_overflow */
1044 ppc64_elf_unhandled_reloc, /* special_function */
1045 "R_PPC64_PLTGOT16", /* name */
1046 FALSE, /* partial_inplace */
1047 0, /* src_mask */
1048 0xffff, /* dst_mask */
1049 FALSE), /* pcrel_offset */
1050
1051 /* Like R_PPC64_PLTGOT16, but without overflow. */
1052 /* FIXME: R_PPC64_PLTGOT16_LO not implemented. */
1053 HOWTO (R_PPC64_PLTGOT16_LO, /* type */
1054 0, /* rightshift */
1055 1, /* size (0 = byte, 1 = short, 2 = long) */
1056 16, /* bitsize */
1057 FALSE, /* pc_relative */
1058 0, /* bitpos */
1059 complain_overflow_dont, /* complain_on_overflow */
1060 ppc64_elf_unhandled_reloc, /* special_function */
1061 "R_PPC64_PLTGOT16_LO", /* name */
1062 FALSE, /* partial_inplace */
1063 0, /* src_mask */
1064 0xffff, /* dst_mask */
1065 FALSE), /* pcrel_offset */
1066
1067 /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address. */
1068 /* FIXME: R_PPC64_PLTGOT16_HI not implemented. */
1069 HOWTO (R_PPC64_PLTGOT16_HI, /* type */
1070 16, /* rightshift */
1071 1, /* size (0 = byte, 1 = short, 2 = long) */
1072 16, /* bitsize */
1073 FALSE, /* pc_relative */
1074 0, /* bitpos */
1075 complain_overflow_signed, /* complain_on_overflow */
1076 ppc64_elf_unhandled_reloc, /* special_function */
1077 "R_PPC64_PLTGOT16_HI", /* name */
1078 FALSE, /* partial_inplace */
1079 0, /* src_mask */
1080 0xffff, /* dst_mask */
1081 FALSE), /* pcrel_offset */
1082
1083 /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address, plus
1084 1 if the contents of the low 16 bits, treated as a signed number,
1085 is negative. */
1086 /* FIXME: R_PPC64_PLTGOT16_HA not implemented. */
1087 HOWTO (R_PPC64_PLTGOT16_HA, /* type */
1088 16, /* rightshift */
1089 1, /* size (0 = byte, 1 = short, 2 = long) */
1090 16, /* bitsize */
1091 FALSE, /* pc_relative */
1092 0, /* bitpos */
1093 complain_overflow_signed, /* complain_on_overflow */
1094 ppc64_elf_unhandled_reloc, /* special_function */
1095 "R_PPC64_PLTGOT16_HA", /* name */
1096 FALSE, /* partial_inplace */
1097 0, /* src_mask */
1098 0xffff, /* dst_mask */
1099 FALSE), /* pcrel_offset */
1100
1101 /* Like R_PPC64_ADDR16, but for instructions with a DS field. */
1102 HOWTO (R_PPC64_ADDR16_DS, /* type */
1103 0, /* rightshift */
1104 1, /* size (0 = byte, 1 = short, 2 = long) */
1105 16, /* bitsize */
1106 FALSE, /* pc_relative */
1107 0, /* bitpos */
1108 complain_overflow_bitfield, /* complain_on_overflow */
1109 bfd_elf_generic_reloc, /* special_function */
1110 "R_PPC64_ADDR16_DS", /* name */
1111 FALSE, /* partial_inplace */
1112 0, /* src_mask */
1113 0xfffc, /* dst_mask */
1114 FALSE), /* pcrel_offset */
1115
1116 /* Like R_PPC64_ADDR16_LO, but for instructions with a DS field. */
1117 HOWTO (R_PPC64_ADDR16_LO_DS, /* type */
1118 0, /* rightshift */
1119 1, /* size (0 = byte, 1 = short, 2 = long) */
1120 16, /* bitsize */
1121 FALSE, /* pc_relative */
1122 0, /* bitpos */
1123 complain_overflow_dont,/* complain_on_overflow */
1124 bfd_elf_generic_reloc, /* special_function */
1125 "R_PPC64_ADDR16_LO_DS",/* name */
1126 FALSE, /* partial_inplace */
1127 0, /* src_mask */
1128 0xfffc, /* dst_mask */
1129 FALSE), /* pcrel_offset */
1130
1131 /* Like R_PPC64_GOT16, but for instructions with a DS field. */
1132 HOWTO (R_PPC64_GOT16_DS, /* type */
1133 0, /* rightshift */
1134 1, /* size (0 = byte, 1 = short, 2 = long) */
1135 16, /* bitsize */
1136 FALSE, /* pc_relative */
1137 0, /* bitpos */
1138 complain_overflow_signed, /* complain_on_overflow */
1139 ppc64_elf_unhandled_reloc, /* special_function */
1140 "R_PPC64_GOT16_DS", /* name */
1141 FALSE, /* partial_inplace */
1142 0, /* src_mask */
1143 0xfffc, /* dst_mask */
1144 FALSE), /* pcrel_offset */
1145
1146 /* Like R_PPC64_GOT16_LO, but for instructions with a DS field. */
1147 HOWTO (R_PPC64_GOT16_LO_DS, /* type */
1148 0, /* rightshift */
1149 1, /* size (0 = byte, 1 = short, 2 = long) */
1150 16, /* bitsize */
1151 FALSE, /* pc_relative */
1152 0, /* bitpos */
1153 complain_overflow_dont, /* complain_on_overflow */
1154 ppc64_elf_unhandled_reloc, /* special_function */
1155 "R_PPC64_GOT16_LO_DS", /* name */
1156 FALSE, /* partial_inplace */
1157 0, /* src_mask */
1158 0xfffc, /* dst_mask */
1159 FALSE), /* pcrel_offset */
1160
1161 /* Like R_PPC64_PLT16_LO, but for instructions with a DS field. */
1162 HOWTO (R_PPC64_PLT16_LO_DS, /* type */
1163 0, /* rightshift */
1164 1, /* size (0 = byte, 1 = short, 2 = long) */
1165 16, /* bitsize */
1166 FALSE, /* pc_relative */
1167 0, /* bitpos */
1168 complain_overflow_dont, /* complain_on_overflow */
1169 ppc64_elf_unhandled_reloc, /* special_function */
1170 "R_PPC64_PLT16_LO_DS", /* name */
1171 FALSE, /* partial_inplace */
1172 0, /* src_mask */
1173 0xfffc, /* dst_mask */
1174 FALSE), /* pcrel_offset */
1175
1176 /* Like R_PPC64_SECTOFF, but for instructions with a DS field. */
1177 HOWTO (R_PPC64_SECTOFF_DS, /* type */
1178 0, /* rightshift */
1179 1, /* size (0 = byte, 1 = short, 2 = long) */
1180 16, /* bitsize */
1181 FALSE, /* pc_relative */
1182 0, /* bitpos */
1183 complain_overflow_bitfield, /* complain_on_overflow */
1184 ppc64_elf_sectoff_reloc, /* special_function */
1185 "R_PPC64_SECTOFF_DS", /* name */
1186 FALSE, /* partial_inplace */
1187 0, /* src_mask */
1188 0xfffc, /* dst_mask */
1189 FALSE), /* pcrel_offset */
1190
1191 /* Like R_PPC64_SECTOFF_LO, but for instructions with a DS field. */
1192 HOWTO (R_PPC64_SECTOFF_LO_DS, /* type */
1193 0, /* rightshift */
1194 1, /* size (0 = byte, 1 = short, 2 = long) */
1195 16, /* bitsize */
1196 FALSE, /* pc_relative */
1197 0, /* bitpos */
1198 complain_overflow_dont, /* complain_on_overflow */
1199 ppc64_elf_sectoff_reloc, /* special_function */
1200 "R_PPC64_SECTOFF_LO_DS",/* name */
1201 FALSE, /* partial_inplace */
1202 0, /* src_mask */
1203 0xfffc, /* dst_mask */
1204 FALSE), /* pcrel_offset */
1205
1206 /* Like R_PPC64_TOC16, but for instructions with a DS field. */
1207 HOWTO (R_PPC64_TOC16_DS, /* type */
1208 0, /* rightshift */
1209 1, /* size (0 = byte, 1 = short, 2 = long) */
1210 16, /* bitsize */
1211 FALSE, /* pc_relative */
1212 0, /* bitpos */
1213 complain_overflow_signed, /* complain_on_overflow */
1214 ppc64_elf_toc_reloc, /* special_function */
1215 "R_PPC64_TOC16_DS", /* name */
1216 FALSE, /* partial_inplace */
1217 0, /* src_mask */
1218 0xfffc, /* dst_mask */
1219 FALSE), /* pcrel_offset */
1220
1221 /* Like R_PPC64_TOC16_LO, but for instructions with a DS field. */
1222 HOWTO (R_PPC64_TOC16_LO_DS, /* type */
1223 0, /* rightshift */
1224 1, /* size (0 = byte, 1 = short, 2 = long) */
1225 16, /* bitsize */
1226 FALSE, /* pc_relative */
1227 0, /* bitpos */
1228 complain_overflow_dont, /* complain_on_overflow */
1229 ppc64_elf_toc_reloc, /* special_function */
1230 "R_PPC64_TOC16_LO_DS", /* name */
1231 FALSE, /* partial_inplace */
1232 0, /* src_mask */
1233 0xfffc, /* dst_mask */
1234 FALSE), /* pcrel_offset */
1235
1236 /* Like R_PPC64_PLTGOT16, but for instructions with a DS field. */
1237 /* FIXME: R_PPC64_PLTGOT16_DS not implemented. */
1238 HOWTO (R_PPC64_PLTGOT16_DS, /* type */
1239 0, /* rightshift */
1240 1, /* size (0 = byte, 1 = short, 2 = long) */
1241 16, /* bitsize */
1242 FALSE, /* pc_relative */
1243 0, /* bitpos */
1244 complain_overflow_signed, /* complain_on_overflow */
1245 ppc64_elf_unhandled_reloc, /* special_function */
1246 "R_PPC64_PLTGOT16_DS", /* name */
1247 FALSE, /* partial_inplace */
1248 0, /* src_mask */
1249 0xfffc, /* dst_mask */
1250 FALSE), /* pcrel_offset */
1251
1252 /* Like R_PPC64_PLTGOT16_LO, but for instructions with a DS field. */
1253 /* FIXME: R_PPC64_PLTGOT16_LO not implemented. */
1254 HOWTO (R_PPC64_PLTGOT16_LO_DS,/* type */
1255 0, /* rightshift */
1256 1, /* size (0 = byte, 1 = short, 2 = long) */
1257 16, /* bitsize */
1258 FALSE, /* pc_relative */
1259 0, /* bitpos */
1260 complain_overflow_dont, /* complain_on_overflow */
1261 ppc64_elf_unhandled_reloc, /* special_function */
1262 "R_PPC64_PLTGOT16_LO_DS",/* name */
1263 FALSE, /* partial_inplace */
1264 0, /* src_mask */
1265 0xfffc, /* dst_mask */
1266 FALSE), /* pcrel_offset */
1267
1268 /* Marker relocs for TLS. */
1269 HOWTO (R_PPC64_TLS,
1270 0, /* rightshift */
1271 2, /* size (0 = byte, 1 = short, 2 = long) */
1272 32, /* bitsize */
1273 FALSE, /* pc_relative */
1274 0, /* bitpos */
1275 complain_overflow_dont, /* complain_on_overflow */
1276 bfd_elf_generic_reloc, /* special_function */
1277 "R_PPC64_TLS", /* name */
1278 FALSE, /* partial_inplace */
1279 0, /* src_mask */
1280 0, /* dst_mask */
1281 FALSE), /* pcrel_offset */
1282
1283 HOWTO (R_PPC64_TLSGD,
1284 0, /* rightshift */
1285 2, /* size (0 = byte, 1 = short, 2 = long) */
1286 32, /* bitsize */
1287 FALSE, /* pc_relative */
1288 0, /* bitpos */
1289 complain_overflow_dont, /* complain_on_overflow */
1290 bfd_elf_generic_reloc, /* special_function */
1291 "R_PPC64_TLSGD", /* name */
1292 FALSE, /* partial_inplace */
1293 0, /* src_mask */
1294 0, /* dst_mask */
1295 FALSE), /* pcrel_offset */
1296
1297 HOWTO (R_PPC64_TLSLD,
1298 0, /* rightshift */
1299 2, /* size (0 = byte, 1 = short, 2 = long) */
1300 32, /* bitsize */
1301 FALSE, /* pc_relative */
1302 0, /* bitpos */
1303 complain_overflow_dont, /* complain_on_overflow */
1304 bfd_elf_generic_reloc, /* special_function */
1305 "R_PPC64_TLSLD", /* name */
1306 FALSE, /* partial_inplace */
1307 0, /* src_mask */
1308 0, /* dst_mask */
1309 FALSE), /* pcrel_offset */
1310
1311 HOWTO (R_PPC64_TOCSAVE,
1312 0, /* rightshift */
1313 2, /* size (0 = byte, 1 = short, 2 = long) */
1314 32, /* bitsize */
1315 FALSE, /* pc_relative */
1316 0, /* bitpos */
1317 complain_overflow_dont, /* complain_on_overflow */
1318 bfd_elf_generic_reloc, /* special_function */
1319 "R_PPC64_TOCSAVE", /* name */
1320 FALSE, /* partial_inplace */
1321 0, /* src_mask */
1322 0, /* dst_mask */
1323 FALSE), /* pcrel_offset */
1324
1325 /* Computes the load module index of the load module that contains the
1326 definition of its TLS sym. */
1327 HOWTO (R_PPC64_DTPMOD64,
1328 0, /* rightshift */
1329 4, /* size (0 = byte, 1 = short, 2 = long) */
1330 64, /* bitsize */
1331 FALSE, /* pc_relative */
1332 0, /* bitpos */
1333 complain_overflow_dont, /* complain_on_overflow */
1334 ppc64_elf_unhandled_reloc, /* special_function */
1335 "R_PPC64_DTPMOD64", /* name */
1336 FALSE, /* partial_inplace */
1337 0, /* src_mask */
1338 ONES (64), /* dst_mask */
1339 FALSE), /* pcrel_offset */
1340
1341 /* Computes a dtv-relative displacement, the difference between the value
1342 of sym+add and the base address of the thread-local storage block that
1343 contains the definition of sym, minus 0x8000. */
1344 HOWTO (R_PPC64_DTPREL64,
1345 0, /* rightshift */
1346 4, /* size (0 = byte, 1 = short, 2 = long) */
1347 64, /* bitsize */
1348 FALSE, /* pc_relative */
1349 0, /* bitpos */
1350 complain_overflow_dont, /* complain_on_overflow */
1351 ppc64_elf_unhandled_reloc, /* special_function */
1352 "R_PPC64_DTPREL64", /* name */
1353 FALSE, /* partial_inplace */
1354 0, /* src_mask */
1355 ONES (64), /* dst_mask */
1356 FALSE), /* pcrel_offset */
1357
1358 /* A 16 bit dtprel reloc. */
1359 HOWTO (R_PPC64_DTPREL16,
1360 0, /* rightshift */
1361 1, /* size (0 = byte, 1 = short, 2 = long) */
1362 16, /* bitsize */
1363 FALSE, /* pc_relative */
1364 0, /* bitpos */
1365 complain_overflow_signed, /* complain_on_overflow */
1366 ppc64_elf_unhandled_reloc, /* special_function */
1367 "R_PPC64_DTPREL16", /* name */
1368 FALSE, /* partial_inplace */
1369 0, /* src_mask */
1370 0xffff, /* dst_mask */
1371 FALSE), /* pcrel_offset */
1372
1373 /* Like DTPREL16, but no overflow. */
1374 HOWTO (R_PPC64_DTPREL16_LO,
1375 0, /* rightshift */
1376 1, /* size (0 = byte, 1 = short, 2 = long) */
1377 16, /* bitsize */
1378 FALSE, /* pc_relative */
1379 0, /* bitpos */
1380 complain_overflow_dont, /* complain_on_overflow */
1381 ppc64_elf_unhandled_reloc, /* special_function */
1382 "R_PPC64_DTPREL16_LO", /* name */
1383 FALSE, /* partial_inplace */
1384 0, /* src_mask */
1385 0xffff, /* dst_mask */
1386 FALSE), /* pcrel_offset */
1387
1388 /* Like DTPREL16_LO, but next higher group of 16 bits. */
1389 HOWTO (R_PPC64_DTPREL16_HI,
1390 16, /* rightshift */
1391 1, /* size (0 = byte, 1 = short, 2 = long) */
1392 16, /* bitsize */
1393 FALSE, /* pc_relative */
1394 0, /* bitpos */
1395 complain_overflow_signed, /* complain_on_overflow */
1396 ppc64_elf_unhandled_reloc, /* special_function */
1397 "R_PPC64_DTPREL16_HI", /* name */
1398 FALSE, /* partial_inplace */
1399 0, /* src_mask */
1400 0xffff, /* dst_mask */
1401 FALSE), /* pcrel_offset */
1402
1403 /* Like DTPREL16_HI, but adjust for low 16 bits. */
1404 HOWTO (R_PPC64_DTPREL16_HA,
1405 16, /* rightshift */
1406 1, /* size (0 = byte, 1 = short, 2 = long) */
1407 16, /* bitsize */
1408 FALSE, /* pc_relative */
1409 0, /* bitpos */
1410 complain_overflow_signed, /* complain_on_overflow */
1411 ppc64_elf_unhandled_reloc, /* special_function */
1412 "R_PPC64_DTPREL16_HA", /* name */
1413 FALSE, /* partial_inplace */
1414 0, /* src_mask */
1415 0xffff, /* dst_mask */
1416 FALSE), /* pcrel_offset */
1417
1418 /* Like DTPREL16_HI, but next higher group of 16 bits. */
1419 HOWTO (R_PPC64_DTPREL16_HIGHER,
1420 32, /* rightshift */
1421 1, /* size (0 = byte, 1 = short, 2 = long) */
1422 16, /* bitsize */
1423 FALSE, /* pc_relative */
1424 0, /* bitpos */
1425 complain_overflow_dont, /* complain_on_overflow */
1426 ppc64_elf_unhandled_reloc, /* special_function */
1427 "R_PPC64_DTPREL16_HIGHER", /* name */
1428 FALSE, /* partial_inplace */
1429 0, /* src_mask */
1430 0xffff, /* dst_mask */
1431 FALSE), /* pcrel_offset */
1432
1433 /* Like DTPREL16_HIGHER, but adjust for low 16 bits. */
1434 HOWTO (R_PPC64_DTPREL16_HIGHERA,
1435 32, /* rightshift */
1436 1, /* size (0 = byte, 1 = short, 2 = long) */
1437 16, /* bitsize */
1438 FALSE, /* pc_relative */
1439 0, /* bitpos */
1440 complain_overflow_dont, /* complain_on_overflow */
1441 ppc64_elf_unhandled_reloc, /* special_function */
1442 "R_PPC64_DTPREL16_HIGHERA", /* name */
1443 FALSE, /* partial_inplace */
1444 0, /* src_mask */
1445 0xffff, /* dst_mask */
1446 FALSE), /* pcrel_offset */
1447
1448 /* Like DTPREL16_HIGHER, but next higher group of 16 bits. */
1449 HOWTO (R_PPC64_DTPREL16_HIGHEST,
1450 48, /* rightshift */
1451 1, /* size (0 = byte, 1 = short, 2 = long) */
1452 16, /* bitsize */
1453 FALSE, /* pc_relative */
1454 0, /* bitpos */
1455 complain_overflow_dont, /* complain_on_overflow */
1456 ppc64_elf_unhandled_reloc, /* special_function */
1457 "R_PPC64_DTPREL16_HIGHEST", /* name */
1458 FALSE, /* partial_inplace */
1459 0, /* src_mask */
1460 0xffff, /* dst_mask */
1461 FALSE), /* pcrel_offset */
1462
1463 /* Like DTPREL16_HIGHEST, but adjust for low 16 bits. */
1464 HOWTO (R_PPC64_DTPREL16_HIGHESTA,
1465 48, /* rightshift */
1466 1, /* size (0 = byte, 1 = short, 2 = long) */
1467 16, /* bitsize */
1468 FALSE, /* pc_relative */
1469 0, /* bitpos */
1470 complain_overflow_dont, /* complain_on_overflow */
1471 ppc64_elf_unhandled_reloc, /* special_function */
1472 "R_PPC64_DTPREL16_HIGHESTA", /* name */
1473 FALSE, /* partial_inplace */
1474 0, /* src_mask */
1475 0xffff, /* dst_mask */
1476 FALSE), /* pcrel_offset */
1477
1478 /* Like DTPREL16, but for insns with a DS field. */
1479 HOWTO (R_PPC64_DTPREL16_DS,
1480 0, /* rightshift */
1481 1, /* size (0 = byte, 1 = short, 2 = long) */
1482 16, /* bitsize */
1483 FALSE, /* pc_relative */
1484 0, /* bitpos */
1485 complain_overflow_signed, /* complain_on_overflow */
1486 ppc64_elf_unhandled_reloc, /* special_function */
1487 "R_PPC64_DTPREL16_DS", /* name */
1488 FALSE, /* partial_inplace */
1489 0, /* src_mask */
1490 0xfffc, /* dst_mask */
1491 FALSE), /* pcrel_offset */
1492
1493 /* Like DTPREL16_DS, but no overflow. */
1494 HOWTO (R_PPC64_DTPREL16_LO_DS,
1495 0, /* rightshift */
1496 1, /* size (0 = byte, 1 = short, 2 = long) */
1497 16, /* bitsize */
1498 FALSE, /* pc_relative */
1499 0, /* bitpos */
1500 complain_overflow_dont, /* complain_on_overflow */
1501 ppc64_elf_unhandled_reloc, /* special_function */
1502 "R_PPC64_DTPREL16_LO_DS", /* name */
1503 FALSE, /* partial_inplace */
1504 0, /* src_mask */
1505 0xfffc, /* dst_mask */
1506 FALSE), /* pcrel_offset */
1507
1508 /* Computes a tp-relative displacement, the difference between the value of
1509 sym+add and the value of the thread pointer (r13). */
1510 HOWTO (R_PPC64_TPREL64,
1511 0, /* rightshift */
1512 4, /* size (0 = byte, 1 = short, 2 = long) */
1513 64, /* bitsize */
1514 FALSE, /* pc_relative */
1515 0, /* bitpos */
1516 complain_overflow_dont, /* complain_on_overflow */
1517 ppc64_elf_unhandled_reloc, /* special_function */
1518 "R_PPC64_TPREL64", /* name */
1519 FALSE, /* partial_inplace */
1520 0, /* src_mask */
1521 ONES (64), /* dst_mask */
1522 FALSE), /* pcrel_offset */
1523
1524 /* A 16 bit tprel reloc. */
1525 HOWTO (R_PPC64_TPREL16,
1526 0, /* rightshift */
1527 1, /* size (0 = byte, 1 = short, 2 = long) */
1528 16, /* bitsize */
1529 FALSE, /* pc_relative */
1530 0, /* bitpos */
1531 complain_overflow_signed, /* complain_on_overflow */
1532 ppc64_elf_unhandled_reloc, /* special_function */
1533 "R_PPC64_TPREL16", /* name */
1534 FALSE, /* partial_inplace */
1535 0, /* src_mask */
1536 0xffff, /* dst_mask */
1537 FALSE), /* pcrel_offset */
1538
1539 /* Like TPREL16, but no overflow. */
1540 HOWTO (R_PPC64_TPREL16_LO,
1541 0, /* rightshift */
1542 1, /* size (0 = byte, 1 = short, 2 = long) */
1543 16, /* bitsize */
1544 FALSE, /* pc_relative */
1545 0, /* bitpos */
1546 complain_overflow_dont, /* complain_on_overflow */
1547 ppc64_elf_unhandled_reloc, /* special_function */
1548 "R_PPC64_TPREL16_LO", /* name */
1549 FALSE, /* partial_inplace */
1550 0, /* src_mask */
1551 0xffff, /* dst_mask */
1552 FALSE), /* pcrel_offset */
1553
1554 /* Like TPREL16_LO, but next higher group of 16 bits. */
1555 HOWTO (R_PPC64_TPREL16_HI,
1556 16, /* rightshift */
1557 1, /* size (0 = byte, 1 = short, 2 = long) */
1558 16, /* bitsize */
1559 FALSE, /* pc_relative */
1560 0, /* bitpos */
1561 complain_overflow_signed, /* complain_on_overflow */
1562 ppc64_elf_unhandled_reloc, /* special_function */
1563 "R_PPC64_TPREL16_HI", /* name */
1564 FALSE, /* partial_inplace */
1565 0, /* src_mask */
1566 0xffff, /* dst_mask */
1567 FALSE), /* pcrel_offset */
1568
1569 /* Like TPREL16_HI, but adjust for low 16 bits. */
1570 HOWTO (R_PPC64_TPREL16_HA,
1571 16, /* rightshift */
1572 1, /* size (0 = byte, 1 = short, 2 = long) */
1573 16, /* bitsize */
1574 FALSE, /* pc_relative */
1575 0, /* bitpos */
1576 complain_overflow_signed, /* complain_on_overflow */
1577 ppc64_elf_unhandled_reloc, /* special_function */
1578 "R_PPC64_TPREL16_HA", /* name */
1579 FALSE, /* partial_inplace */
1580 0, /* src_mask */
1581 0xffff, /* dst_mask */
1582 FALSE), /* pcrel_offset */
1583
1584 /* Like TPREL16_HI, but next higher group of 16 bits. */
1585 HOWTO (R_PPC64_TPREL16_HIGHER,
1586 32, /* rightshift */
1587 1, /* size (0 = byte, 1 = short, 2 = long) */
1588 16, /* bitsize */
1589 FALSE, /* pc_relative */
1590 0, /* bitpos */
1591 complain_overflow_dont, /* complain_on_overflow */
1592 ppc64_elf_unhandled_reloc, /* special_function */
1593 "R_PPC64_TPREL16_HIGHER", /* name */
1594 FALSE, /* partial_inplace */
1595 0, /* src_mask */
1596 0xffff, /* dst_mask */
1597 FALSE), /* pcrel_offset */
1598
1599 /* Like TPREL16_HIGHER, but adjust for low 16 bits. */
1600 HOWTO (R_PPC64_TPREL16_HIGHERA,
1601 32, /* rightshift */
1602 1, /* size (0 = byte, 1 = short, 2 = long) */
1603 16, /* bitsize */
1604 FALSE, /* pc_relative */
1605 0, /* bitpos */
1606 complain_overflow_dont, /* complain_on_overflow */
1607 ppc64_elf_unhandled_reloc, /* special_function */
1608 "R_PPC64_TPREL16_HIGHERA", /* name */
1609 FALSE, /* partial_inplace */
1610 0, /* src_mask */
1611 0xffff, /* dst_mask */
1612 FALSE), /* pcrel_offset */
1613
1614 /* Like TPREL16_HIGHER, but next higher group of 16 bits. */
1615 HOWTO (R_PPC64_TPREL16_HIGHEST,
1616 48, /* rightshift */
1617 1, /* size (0 = byte, 1 = short, 2 = long) */
1618 16, /* bitsize */
1619 FALSE, /* pc_relative */
1620 0, /* bitpos */
1621 complain_overflow_dont, /* complain_on_overflow */
1622 ppc64_elf_unhandled_reloc, /* special_function */
1623 "R_PPC64_TPREL16_HIGHEST", /* name */
1624 FALSE, /* partial_inplace */
1625 0, /* src_mask */
1626 0xffff, /* dst_mask */
1627 FALSE), /* pcrel_offset */
1628
1629 /* Like TPREL16_HIGHEST, but adjust for low 16 bits. */
1630 HOWTO (R_PPC64_TPREL16_HIGHESTA,
1631 48, /* rightshift */
1632 1, /* size (0 = byte, 1 = short, 2 = long) */
1633 16, /* bitsize */
1634 FALSE, /* pc_relative */
1635 0, /* bitpos */
1636 complain_overflow_dont, /* complain_on_overflow */
1637 ppc64_elf_unhandled_reloc, /* special_function */
1638 "R_PPC64_TPREL16_HIGHESTA", /* name */
1639 FALSE, /* partial_inplace */
1640 0, /* src_mask */
1641 0xffff, /* dst_mask */
1642 FALSE), /* pcrel_offset */
1643
1644 /* Like TPREL16, but for insns with a DS field. */
1645 HOWTO (R_PPC64_TPREL16_DS,
1646 0, /* rightshift */
1647 1, /* size (0 = byte, 1 = short, 2 = long) */
1648 16, /* bitsize */
1649 FALSE, /* pc_relative */
1650 0, /* bitpos */
1651 complain_overflow_signed, /* complain_on_overflow */
1652 ppc64_elf_unhandled_reloc, /* special_function */
1653 "R_PPC64_TPREL16_DS", /* name */
1654 FALSE, /* partial_inplace */
1655 0, /* src_mask */
1656 0xfffc, /* dst_mask */
1657 FALSE), /* pcrel_offset */
1658
1659 /* Like TPREL16_DS, but no overflow. */
1660 HOWTO (R_PPC64_TPREL16_LO_DS,
1661 0, /* rightshift */
1662 1, /* size (0 = byte, 1 = short, 2 = long) */
1663 16, /* bitsize */
1664 FALSE, /* pc_relative */
1665 0, /* bitpos */
1666 complain_overflow_dont, /* complain_on_overflow */
1667 ppc64_elf_unhandled_reloc, /* special_function */
1668 "R_PPC64_TPREL16_LO_DS", /* name */
1669 FALSE, /* partial_inplace */
1670 0, /* src_mask */
1671 0xfffc, /* dst_mask */
1672 FALSE), /* pcrel_offset */
1673
1674 /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1675 with values (sym+add)@dtpmod and (sym+add)@dtprel, and computes the offset
1676 to the first entry relative to the TOC base (r2). */
1677 HOWTO (R_PPC64_GOT_TLSGD16,
1678 0, /* rightshift */
1679 1, /* size (0 = byte, 1 = short, 2 = long) */
1680 16, /* bitsize */
1681 FALSE, /* pc_relative */
1682 0, /* bitpos */
1683 complain_overflow_signed, /* complain_on_overflow */
1684 ppc64_elf_unhandled_reloc, /* special_function */
1685 "R_PPC64_GOT_TLSGD16", /* name */
1686 FALSE, /* partial_inplace */
1687 0, /* src_mask */
1688 0xffff, /* dst_mask */
1689 FALSE), /* pcrel_offset */
1690
1691 /* Like GOT_TLSGD16, but no overflow. */
1692 HOWTO (R_PPC64_GOT_TLSGD16_LO,
1693 0, /* rightshift */
1694 1, /* size (0 = byte, 1 = short, 2 = long) */
1695 16, /* bitsize */
1696 FALSE, /* pc_relative */
1697 0, /* bitpos */
1698 complain_overflow_dont, /* complain_on_overflow */
1699 ppc64_elf_unhandled_reloc, /* special_function */
1700 "R_PPC64_GOT_TLSGD16_LO", /* name */
1701 FALSE, /* partial_inplace */
1702 0, /* src_mask */
1703 0xffff, /* dst_mask */
1704 FALSE), /* pcrel_offset */
1705
1706 /* Like GOT_TLSGD16_LO, but next higher group of 16 bits. */
1707 HOWTO (R_PPC64_GOT_TLSGD16_HI,
1708 16, /* rightshift */
1709 1, /* size (0 = byte, 1 = short, 2 = long) */
1710 16, /* bitsize */
1711 FALSE, /* pc_relative */
1712 0, /* bitpos */
1713 complain_overflow_signed, /* complain_on_overflow */
1714 ppc64_elf_unhandled_reloc, /* special_function */
1715 "R_PPC64_GOT_TLSGD16_HI", /* name */
1716 FALSE, /* partial_inplace */
1717 0, /* src_mask */
1718 0xffff, /* dst_mask */
1719 FALSE), /* pcrel_offset */
1720
1721 /* Like GOT_TLSGD16_HI, but adjust for low 16 bits. */
1722 HOWTO (R_PPC64_GOT_TLSGD16_HA,
1723 16, /* rightshift */
1724 1, /* size (0 = byte, 1 = short, 2 = long) */
1725 16, /* bitsize */
1726 FALSE, /* pc_relative */
1727 0, /* bitpos */
1728 complain_overflow_signed, /* complain_on_overflow */
1729 ppc64_elf_unhandled_reloc, /* special_function */
1730 "R_PPC64_GOT_TLSGD16_HA", /* name */
1731 FALSE, /* partial_inplace */
1732 0, /* src_mask */
1733 0xffff, /* dst_mask */
1734 FALSE), /* pcrel_offset */
1735
1736 /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1737 with values (sym+add)@dtpmod and zero, and computes the offset to the
1738 first entry relative to the TOC base (r2). */
1739 HOWTO (R_PPC64_GOT_TLSLD16,
1740 0, /* rightshift */
1741 1, /* size (0 = byte, 1 = short, 2 = long) */
1742 16, /* bitsize */
1743 FALSE, /* pc_relative */
1744 0, /* bitpos */
1745 complain_overflow_signed, /* complain_on_overflow */
1746 ppc64_elf_unhandled_reloc, /* special_function */
1747 "R_PPC64_GOT_TLSLD16", /* name */
1748 FALSE, /* partial_inplace */
1749 0, /* src_mask */
1750 0xffff, /* dst_mask */
1751 FALSE), /* pcrel_offset */
1752
1753 /* Like GOT_TLSLD16, but no overflow. */
1754 HOWTO (R_PPC64_GOT_TLSLD16_LO,
1755 0, /* rightshift */
1756 1, /* size (0 = byte, 1 = short, 2 = long) */
1757 16, /* bitsize */
1758 FALSE, /* pc_relative */
1759 0, /* bitpos */
1760 complain_overflow_dont, /* complain_on_overflow */
1761 ppc64_elf_unhandled_reloc, /* special_function */
1762 "R_PPC64_GOT_TLSLD16_LO", /* name */
1763 FALSE, /* partial_inplace */
1764 0, /* src_mask */
1765 0xffff, /* dst_mask */
1766 FALSE), /* pcrel_offset */
1767
1768 /* Like GOT_TLSLD16_LO, but next higher group of 16 bits. */
1769 HOWTO (R_PPC64_GOT_TLSLD16_HI,
1770 16, /* rightshift */
1771 1, /* size (0 = byte, 1 = short, 2 = long) */
1772 16, /* bitsize */
1773 FALSE, /* pc_relative */
1774 0, /* bitpos */
1775 complain_overflow_signed, /* complain_on_overflow */
1776 ppc64_elf_unhandled_reloc, /* special_function */
1777 "R_PPC64_GOT_TLSLD16_HI", /* name */
1778 FALSE, /* partial_inplace */
1779 0, /* src_mask */
1780 0xffff, /* dst_mask */
1781 FALSE), /* pcrel_offset */
1782
1783 /* Like GOT_TLSLD16_HI, but adjust for low 16 bits. */
1784 HOWTO (R_PPC64_GOT_TLSLD16_HA,
1785 16, /* rightshift */
1786 1, /* size (0 = byte, 1 = short, 2 = long) */
1787 16, /* bitsize */
1788 FALSE, /* pc_relative */
1789 0, /* bitpos */
1790 complain_overflow_signed, /* complain_on_overflow */
1791 ppc64_elf_unhandled_reloc, /* special_function */
1792 "R_PPC64_GOT_TLSLD16_HA", /* name */
1793 FALSE, /* partial_inplace */
1794 0, /* src_mask */
1795 0xffff, /* dst_mask */
1796 FALSE), /* pcrel_offset */
1797
1798 /* Allocates an entry in the GOT with value (sym+add)@dtprel, and computes
1799 the offset to the entry relative to the TOC base (r2). */
1800 HOWTO (R_PPC64_GOT_DTPREL16_DS,
1801 0, /* rightshift */
1802 1, /* size (0 = byte, 1 = short, 2 = long) */
1803 16, /* bitsize */
1804 FALSE, /* pc_relative */
1805 0, /* bitpos */
1806 complain_overflow_signed, /* complain_on_overflow */
1807 ppc64_elf_unhandled_reloc, /* special_function */
1808 "R_PPC64_GOT_DTPREL16_DS", /* name */
1809 FALSE, /* partial_inplace */
1810 0, /* src_mask */
1811 0xfffc, /* dst_mask */
1812 FALSE), /* pcrel_offset */
1813
1814 /* Like GOT_DTPREL16_DS, but no overflow. */
1815 HOWTO (R_PPC64_GOT_DTPREL16_LO_DS,
1816 0, /* rightshift */
1817 1, /* size (0 = byte, 1 = short, 2 = long) */
1818 16, /* bitsize */
1819 FALSE, /* pc_relative */
1820 0, /* bitpos */
1821 complain_overflow_dont, /* complain_on_overflow */
1822 ppc64_elf_unhandled_reloc, /* special_function */
1823 "R_PPC64_GOT_DTPREL16_LO_DS", /* name */
1824 FALSE, /* partial_inplace */
1825 0, /* src_mask */
1826 0xfffc, /* dst_mask */
1827 FALSE), /* pcrel_offset */
1828
1829 /* Like GOT_DTPREL16_LO_DS, but next higher group of 16 bits. */
1830 HOWTO (R_PPC64_GOT_DTPREL16_HI,
1831 16, /* rightshift */
1832 1, /* size (0 = byte, 1 = short, 2 = long) */
1833 16, /* bitsize */
1834 FALSE, /* pc_relative */
1835 0, /* bitpos */
1836 complain_overflow_signed, /* complain_on_overflow */
1837 ppc64_elf_unhandled_reloc, /* special_function */
1838 "R_PPC64_GOT_DTPREL16_HI", /* name */
1839 FALSE, /* partial_inplace */
1840 0, /* src_mask */
1841 0xffff, /* dst_mask */
1842 FALSE), /* pcrel_offset */
1843
1844 /* Like GOT_DTPREL16_HI, but adjust for low 16 bits. */
1845 HOWTO (R_PPC64_GOT_DTPREL16_HA,
1846 16, /* rightshift */
1847 1, /* size (0 = byte, 1 = short, 2 = long) */
1848 16, /* bitsize */
1849 FALSE, /* pc_relative */
1850 0, /* bitpos */
1851 complain_overflow_signed, /* complain_on_overflow */
1852 ppc64_elf_unhandled_reloc, /* special_function */
1853 "R_PPC64_GOT_DTPREL16_HA", /* name */
1854 FALSE, /* partial_inplace */
1855 0, /* src_mask */
1856 0xffff, /* dst_mask */
1857 FALSE), /* pcrel_offset */
1858
1859 /* Allocates an entry in the GOT with value (sym+add)@tprel, and computes the
1860 offset to the entry relative to the TOC base (r2). */
1861 HOWTO (R_PPC64_GOT_TPREL16_DS,
1862 0, /* rightshift */
1863 1, /* size (0 = byte, 1 = short, 2 = long) */
1864 16, /* bitsize */
1865 FALSE, /* pc_relative */
1866 0, /* bitpos */
1867 complain_overflow_signed, /* complain_on_overflow */
1868 ppc64_elf_unhandled_reloc, /* special_function */
1869 "R_PPC64_GOT_TPREL16_DS", /* name */
1870 FALSE, /* partial_inplace */
1871 0, /* src_mask */
1872 0xfffc, /* dst_mask */
1873 FALSE), /* pcrel_offset */
1874
1875 /* Like GOT_TPREL16_DS, but no overflow. */
1876 HOWTO (R_PPC64_GOT_TPREL16_LO_DS,
1877 0, /* rightshift */
1878 1, /* size (0 = byte, 1 = short, 2 = long) */
1879 16, /* bitsize */
1880 FALSE, /* pc_relative */
1881 0, /* bitpos */
1882 complain_overflow_dont, /* complain_on_overflow */
1883 ppc64_elf_unhandled_reloc, /* special_function */
1884 "R_PPC64_GOT_TPREL16_LO_DS", /* name */
1885 FALSE, /* partial_inplace */
1886 0, /* src_mask */
1887 0xfffc, /* dst_mask */
1888 FALSE), /* pcrel_offset */
1889
1890 /* Like GOT_TPREL16_LO_DS, but next higher group of 16 bits. */
1891 HOWTO (R_PPC64_GOT_TPREL16_HI,
1892 16, /* rightshift */
1893 1, /* size (0 = byte, 1 = short, 2 = long) */
1894 16, /* bitsize */
1895 FALSE, /* pc_relative */
1896 0, /* bitpos */
1897 complain_overflow_signed, /* complain_on_overflow */
1898 ppc64_elf_unhandled_reloc, /* special_function */
1899 "R_PPC64_GOT_TPREL16_HI", /* name */
1900 FALSE, /* partial_inplace */
1901 0, /* src_mask */
1902 0xffff, /* dst_mask */
1903 FALSE), /* pcrel_offset */
1904
1905 /* Like GOT_TPREL16_HI, but adjust for low 16 bits. */
1906 HOWTO (R_PPC64_GOT_TPREL16_HA,
1907 16, /* rightshift */
1908 1, /* size (0 = byte, 1 = short, 2 = long) */
1909 16, /* bitsize */
1910 FALSE, /* pc_relative */
1911 0, /* bitpos */
1912 complain_overflow_signed, /* complain_on_overflow */
1913 ppc64_elf_unhandled_reloc, /* special_function */
1914 "R_PPC64_GOT_TPREL16_HA", /* name */
1915 FALSE, /* partial_inplace */
1916 0, /* src_mask */
1917 0xffff, /* dst_mask */
1918 FALSE), /* pcrel_offset */
1919
1920 HOWTO (R_PPC64_JMP_IREL, /* type */
1921 0, /* rightshift */
1922 0, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1923 0, /* bitsize */
1924 FALSE, /* pc_relative */
1925 0, /* bitpos */
1926 complain_overflow_dont, /* complain_on_overflow */
1927 ppc64_elf_unhandled_reloc, /* special_function */
1928 "R_PPC64_JMP_IREL", /* name */
1929 FALSE, /* partial_inplace */
1930 0, /* src_mask */
1931 0, /* dst_mask */
1932 FALSE), /* pcrel_offset */
1933
1934 HOWTO (R_PPC64_IRELATIVE, /* type */
1935 0, /* rightshift */
1936 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1937 64, /* bitsize */
1938 FALSE, /* pc_relative */
1939 0, /* bitpos */
1940 complain_overflow_dont, /* complain_on_overflow */
1941 bfd_elf_generic_reloc, /* special_function */
1942 "R_PPC64_IRELATIVE", /* name */
1943 FALSE, /* partial_inplace */
1944 0, /* src_mask */
1945 ONES (64), /* dst_mask */
1946 FALSE), /* pcrel_offset */
1947
1948 /* A 16 bit relative relocation. */
1949 HOWTO (R_PPC64_REL16, /* type */
1950 0, /* rightshift */
1951 1, /* size (0 = byte, 1 = short, 2 = long) */
1952 16, /* bitsize */
1953 TRUE, /* pc_relative */
1954 0, /* bitpos */
1955 complain_overflow_bitfield, /* complain_on_overflow */
1956 bfd_elf_generic_reloc, /* special_function */
1957 "R_PPC64_REL16", /* name */
1958 FALSE, /* partial_inplace */
1959 0, /* src_mask */
1960 0xffff, /* dst_mask */
1961 TRUE), /* pcrel_offset */
1962
1963 /* A 16 bit relative relocation without overflow. */
1964 HOWTO (R_PPC64_REL16_LO, /* type */
1965 0, /* rightshift */
1966 1, /* size (0 = byte, 1 = short, 2 = long) */
1967 16, /* bitsize */
1968 TRUE, /* pc_relative */
1969 0, /* bitpos */
1970 complain_overflow_dont,/* complain_on_overflow */
1971 bfd_elf_generic_reloc, /* special_function */
1972 "R_PPC64_REL16_LO", /* name */
1973 FALSE, /* partial_inplace */
1974 0, /* src_mask */
1975 0xffff, /* dst_mask */
1976 TRUE), /* pcrel_offset */
1977
1978 /* The high order 16 bits of a relative address. */
1979 HOWTO (R_PPC64_REL16_HI, /* type */
1980 16, /* rightshift */
1981 1, /* size (0 = byte, 1 = short, 2 = long) */
1982 16, /* bitsize */
1983 TRUE, /* pc_relative */
1984 0, /* bitpos */
1985 complain_overflow_signed, /* complain_on_overflow */
1986 bfd_elf_generic_reloc, /* special_function */
1987 "R_PPC64_REL16_HI", /* name */
1988 FALSE, /* partial_inplace */
1989 0, /* src_mask */
1990 0xffff, /* dst_mask */
1991 TRUE), /* pcrel_offset */
1992
1993 /* The high order 16 bits of a relative address, plus 1 if the contents of
1994 the low 16 bits, treated as a signed number, is negative. */
1995 HOWTO (R_PPC64_REL16_HA, /* type */
1996 16, /* rightshift */
1997 1, /* size (0 = byte, 1 = short, 2 = long) */
1998 16, /* bitsize */
1999 TRUE, /* pc_relative */
2000 0, /* bitpos */
2001 complain_overflow_signed, /* complain_on_overflow */
2002 ppc64_elf_ha_reloc, /* special_function */
2003 "R_PPC64_REL16_HA", /* name */
2004 FALSE, /* partial_inplace */
2005 0, /* src_mask */
2006 0xffff, /* dst_mask */
2007 TRUE), /* pcrel_offset */
2008
2009 /* Like R_PPC64_ADDR16_HI, but no overflow. */
2010 HOWTO (R_PPC64_ADDR16_HIGH, /* type */
2011 16, /* rightshift */
2012 1, /* size (0 = byte, 1 = short, 2 = long) */
2013 16, /* bitsize */
2014 FALSE, /* pc_relative */
2015 0, /* bitpos */
2016 complain_overflow_dont, /* complain_on_overflow */
2017 bfd_elf_generic_reloc, /* special_function */
2018 "R_PPC64_ADDR16_HIGH", /* name */
2019 FALSE, /* partial_inplace */
2020 0, /* src_mask */
2021 0xffff, /* dst_mask */
2022 FALSE), /* pcrel_offset */
2023
2024 /* Like R_PPC64_ADDR16_HA, but no overflow. */
2025 HOWTO (R_PPC64_ADDR16_HIGHA, /* type */
2026 16, /* rightshift */
2027 1, /* size (0 = byte, 1 = short, 2 = long) */
2028 16, /* bitsize */
2029 FALSE, /* pc_relative */
2030 0, /* bitpos */
2031 complain_overflow_dont, /* complain_on_overflow */
2032 ppc64_elf_ha_reloc, /* special_function */
2033 "R_PPC64_ADDR16_HIGHA", /* name */
2034 FALSE, /* partial_inplace */
2035 0, /* src_mask */
2036 0xffff, /* dst_mask */
2037 FALSE), /* pcrel_offset */
2038
2039 /* Like R_PPC64_DTPREL16_HI, but no overflow. */
2040 HOWTO (R_PPC64_DTPREL16_HIGH,
2041 16, /* rightshift */
2042 1, /* size (0 = byte, 1 = short, 2 = long) */
2043 16, /* bitsize */
2044 FALSE, /* pc_relative */
2045 0, /* bitpos */
2046 complain_overflow_dont, /* complain_on_overflow */
2047 ppc64_elf_unhandled_reloc, /* special_function */
2048 "R_PPC64_DTPREL16_HIGH", /* name */
2049 FALSE, /* partial_inplace */
2050 0, /* src_mask */
2051 0xffff, /* dst_mask */
2052 FALSE), /* pcrel_offset */
2053
2054 /* Like R_PPC64_DTPREL16_HA, but no overflow. */
2055 HOWTO (R_PPC64_DTPREL16_HIGHA,
2056 16, /* rightshift */
2057 1, /* size (0 = byte, 1 = short, 2 = long) */
2058 16, /* bitsize */
2059 FALSE, /* pc_relative */
2060 0, /* bitpos */
2061 complain_overflow_dont, /* complain_on_overflow */
2062 ppc64_elf_unhandled_reloc, /* special_function */
2063 "R_PPC64_DTPREL16_HIGHA", /* name */
2064 FALSE, /* partial_inplace */
2065 0, /* src_mask */
2066 0xffff, /* dst_mask */
2067 FALSE), /* pcrel_offset */
2068
2069 /* Like R_PPC64_TPREL16_HI, but no overflow. */
2070 HOWTO (R_PPC64_TPREL16_HIGH,
2071 16, /* rightshift */
2072 1, /* size (0 = byte, 1 = short, 2 = long) */
2073 16, /* bitsize */
2074 FALSE, /* pc_relative */
2075 0, /* bitpos */
2076 complain_overflow_dont, /* complain_on_overflow */
2077 ppc64_elf_unhandled_reloc, /* special_function */
2078 "R_PPC64_TPREL16_HIGH", /* name */
2079 FALSE, /* partial_inplace */
2080 0, /* src_mask */
2081 0xffff, /* dst_mask */
2082 FALSE), /* pcrel_offset */
2083
2084 /* Like R_PPC64_TPREL16_HA, but no overflow. */
2085 HOWTO (R_PPC64_TPREL16_HIGHA,
2086 16, /* rightshift */
2087 1, /* size (0 = byte, 1 = short, 2 = long) */
2088 16, /* bitsize */
2089 FALSE, /* pc_relative */
2090 0, /* bitpos */
2091 complain_overflow_dont, /* complain_on_overflow */
2092 ppc64_elf_unhandled_reloc, /* special_function */
2093 "R_PPC64_TPREL16_HIGHA", /* name */
2094 FALSE, /* partial_inplace */
2095 0, /* src_mask */
2096 0xffff, /* dst_mask */
2097 FALSE), /* pcrel_offset */
2098
2099 /* GNU extension to record C++ vtable hierarchy. */
2100 HOWTO (R_PPC64_GNU_VTINHERIT, /* type */
2101 0, /* rightshift */
2102 0, /* size (0 = byte, 1 = short, 2 = long) */
2103 0, /* bitsize */
2104 FALSE, /* pc_relative */
2105 0, /* bitpos */
2106 complain_overflow_dont, /* complain_on_overflow */
2107 NULL, /* special_function */
2108 "R_PPC64_GNU_VTINHERIT", /* name */
2109 FALSE, /* partial_inplace */
2110 0, /* src_mask */
2111 0, /* dst_mask */
2112 FALSE), /* pcrel_offset */
2113
2114 /* GNU extension to record C++ vtable member usage. */
2115 HOWTO (R_PPC64_GNU_VTENTRY, /* type */
2116 0, /* rightshift */
2117 0, /* size (0 = byte, 1 = short, 2 = long) */
2118 0, /* bitsize */
2119 FALSE, /* pc_relative */
2120 0, /* bitpos */
2121 complain_overflow_dont, /* complain_on_overflow */
2122 NULL, /* special_function */
2123 "R_PPC64_GNU_VTENTRY", /* name */
2124 FALSE, /* partial_inplace */
2125 0, /* src_mask */
2126 0, /* dst_mask */
2127 FALSE), /* pcrel_offset */
2128 };
2129
2130 \f
2131 /* Initialize the ppc64_elf_howto_table, so that linear accesses can
2132 be done. */
2133
2134 static void
2135 ppc_howto_init (void)
2136 {
2137 unsigned int i, type;
2138
2139 for (i = 0;
2140 i < sizeof (ppc64_elf_howto_raw) / sizeof (ppc64_elf_howto_raw[0]);
2141 i++)
2142 {
2143 type = ppc64_elf_howto_raw[i].type;
2144 BFD_ASSERT (type < (sizeof (ppc64_elf_howto_table)
2145 / sizeof (ppc64_elf_howto_table[0])));
2146 ppc64_elf_howto_table[type] = &ppc64_elf_howto_raw[i];
2147 }
2148 }
2149
2150 static reloc_howto_type *
2151 ppc64_elf_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2152 bfd_reloc_code_real_type code)
2153 {
2154 enum elf_ppc64_reloc_type r = R_PPC64_NONE;
2155
2156 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2157 /* Initialize howto table if needed. */
2158 ppc_howto_init ();
2159
2160 switch (code)
2161 {
2162 default:
2163 return NULL;
2164
2165 case BFD_RELOC_NONE: r = R_PPC64_NONE;
2166 break;
2167 case BFD_RELOC_32: r = R_PPC64_ADDR32;
2168 break;
2169 case BFD_RELOC_PPC_BA26: r = R_PPC64_ADDR24;
2170 break;
2171 case BFD_RELOC_16: r = R_PPC64_ADDR16;
2172 break;
2173 case BFD_RELOC_LO16: r = R_PPC64_ADDR16_LO;
2174 break;
2175 case BFD_RELOC_HI16: r = R_PPC64_ADDR16_HI;
2176 break;
2177 case BFD_RELOC_PPC64_ADDR16_HIGH: r = R_PPC64_ADDR16_HIGH;
2178 break;
2179 case BFD_RELOC_HI16_S: r = R_PPC64_ADDR16_HA;
2180 break;
2181 case BFD_RELOC_PPC64_ADDR16_HIGHA: r = R_PPC64_ADDR16_HIGHA;
2182 break;
2183 case BFD_RELOC_PPC_BA16: r = R_PPC64_ADDR14;
2184 break;
2185 case BFD_RELOC_PPC_BA16_BRTAKEN: r = R_PPC64_ADDR14_BRTAKEN;
2186 break;
2187 case BFD_RELOC_PPC_BA16_BRNTAKEN: r = R_PPC64_ADDR14_BRNTAKEN;
2188 break;
2189 case BFD_RELOC_PPC_B26: r = R_PPC64_REL24;
2190 break;
2191 case BFD_RELOC_PPC_B16: r = R_PPC64_REL14;
2192 break;
2193 case BFD_RELOC_PPC_B16_BRTAKEN: r = R_PPC64_REL14_BRTAKEN;
2194 break;
2195 case BFD_RELOC_PPC_B16_BRNTAKEN: r = R_PPC64_REL14_BRNTAKEN;
2196 break;
2197 case BFD_RELOC_16_GOTOFF: r = R_PPC64_GOT16;
2198 break;
2199 case BFD_RELOC_LO16_GOTOFF: r = R_PPC64_GOT16_LO;
2200 break;
2201 case BFD_RELOC_HI16_GOTOFF: r = R_PPC64_GOT16_HI;
2202 break;
2203 case BFD_RELOC_HI16_S_GOTOFF: r = R_PPC64_GOT16_HA;
2204 break;
2205 case BFD_RELOC_PPC_COPY: r = R_PPC64_COPY;
2206 break;
2207 case BFD_RELOC_PPC_GLOB_DAT: r = R_PPC64_GLOB_DAT;
2208 break;
2209 case BFD_RELOC_32_PCREL: r = R_PPC64_REL32;
2210 break;
2211 case BFD_RELOC_32_PLTOFF: r = R_PPC64_PLT32;
2212 break;
2213 case BFD_RELOC_32_PLT_PCREL: r = R_PPC64_PLTREL32;
2214 break;
2215 case BFD_RELOC_LO16_PLTOFF: r = R_PPC64_PLT16_LO;
2216 break;
2217 case BFD_RELOC_HI16_PLTOFF: r = R_PPC64_PLT16_HI;
2218 break;
2219 case BFD_RELOC_HI16_S_PLTOFF: r = R_PPC64_PLT16_HA;
2220 break;
2221 case BFD_RELOC_16_BASEREL: r = R_PPC64_SECTOFF;
2222 break;
2223 case BFD_RELOC_LO16_BASEREL: r = R_PPC64_SECTOFF_LO;
2224 break;
2225 case BFD_RELOC_HI16_BASEREL: r = R_PPC64_SECTOFF_HI;
2226 break;
2227 case BFD_RELOC_HI16_S_BASEREL: r = R_PPC64_SECTOFF_HA;
2228 break;
2229 case BFD_RELOC_CTOR: r = R_PPC64_ADDR64;
2230 break;
2231 case BFD_RELOC_64: r = R_PPC64_ADDR64;
2232 break;
2233 case BFD_RELOC_PPC64_HIGHER: r = R_PPC64_ADDR16_HIGHER;
2234 break;
2235 case BFD_RELOC_PPC64_HIGHER_S: r = R_PPC64_ADDR16_HIGHERA;
2236 break;
2237 case BFD_RELOC_PPC64_HIGHEST: r = R_PPC64_ADDR16_HIGHEST;
2238 break;
2239 case BFD_RELOC_PPC64_HIGHEST_S: r = R_PPC64_ADDR16_HIGHESTA;
2240 break;
2241 case BFD_RELOC_64_PCREL: r = R_PPC64_REL64;
2242 break;
2243 case BFD_RELOC_64_PLTOFF: r = R_PPC64_PLT64;
2244 break;
2245 case BFD_RELOC_64_PLT_PCREL: r = R_PPC64_PLTREL64;
2246 break;
2247 case BFD_RELOC_PPC_TOC16: r = R_PPC64_TOC16;
2248 break;
2249 case BFD_RELOC_PPC64_TOC16_LO: r = R_PPC64_TOC16_LO;
2250 break;
2251 case BFD_RELOC_PPC64_TOC16_HI: r = R_PPC64_TOC16_HI;
2252 break;
2253 case BFD_RELOC_PPC64_TOC16_HA: r = R_PPC64_TOC16_HA;
2254 break;
2255 case BFD_RELOC_PPC64_TOC: r = R_PPC64_TOC;
2256 break;
2257 case BFD_RELOC_PPC64_PLTGOT16: r = R_PPC64_PLTGOT16;
2258 break;
2259 case BFD_RELOC_PPC64_PLTGOT16_LO: r = R_PPC64_PLTGOT16_LO;
2260 break;
2261 case BFD_RELOC_PPC64_PLTGOT16_HI: r = R_PPC64_PLTGOT16_HI;
2262 break;
2263 case BFD_RELOC_PPC64_PLTGOT16_HA: r = R_PPC64_PLTGOT16_HA;
2264 break;
2265 case BFD_RELOC_PPC64_ADDR16_DS: r = R_PPC64_ADDR16_DS;
2266 break;
2267 case BFD_RELOC_PPC64_ADDR16_LO_DS: r = R_PPC64_ADDR16_LO_DS;
2268 break;
2269 case BFD_RELOC_PPC64_GOT16_DS: r = R_PPC64_GOT16_DS;
2270 break;
2271 case BFD_RELOC_PPC64_GOT16_LO_DS: r = R_PPC64_GOT16_LO_DS;
2272 break;
2273 case BFD_RELOC_PPC64_PLT16_LO_DS: r = R_PPC64_PLT16_LO_DS;
2274 break;
2275 case BFD_RELOC_PPC64_SECTOFF_DS: r = R_PPC64_SECTOFF_DS;
2276 break;
2277 case BFD_RELOC_PPC64_SECTOFF_LO_DS: r = R_PPC64_SECTOFF_LO_DS;
2278 break;
2279 case BFD_RELOC_PPC64_TOC16_DS: r = R_PPC64_TOC16_DS;
2280 break;
2281 case BFD_RELOC_PPC64_TOC16_LO_DS: r = R_PPC64_TOC16_LO_DS;
2282 break;
2283 case BFD_RELOC_PPC64_PLTGOT16_DS: r = R_PPC64_PLTGOT16_DS;
2284 break;
2285 case BFD_RELOC_PPC64_PLTGOT16_LO_DS: r = R_PPC64_PLTGOT16_LO_DS;
2286 break;
2287 case BFD_RELOC_PPC_TLS: r = R_PPC64_TLS;
2288 break;
2289 case BFD_RELOC_PPC_TLSGD: r = R_PPC64_TLSGD;
2290 break;
2291 case BFD_RELOC_PPC_TLSLD: r = R_PPC64_TLSLD;
2292 break;
2293 case BFD_RELOC_PPC_DTPMOD: r = R_PPC64_DTPMOD64;
2294 break;
2295 case BFD_RELOC_PPC_TPREL16: r = R_PPC64_TPREL16;
2296 break;
2297 case BFD_RELOC_PPC_TPREL16_LO: r = R_PPC64_TPREL16_LO;
2298 break;
2299 case BFD_RELOC_PPC_TPREL16_HI: r = R_PPC64_TPREL16_HI;
2300 break;
2301 case BFD_RELOC_PPC64_TPREL16_HIGH: r = R_PPC64_TPREL16_HIGH;
2302 break;
2303 case BFD_RELOC_PPC_TPREL16_HA: r = R_PPC64_TPREL16_HA;
2304 break;
2305 case BFD_RELOC_PPC64_TPREL16_HIGHA: r = R_PPC64_TPREL16_HIGHA;
2306 break;
2307 case BFD_RELOC_PPC_TPREL: r = R_PPC64_TPREL64;
2308 break;
2309 case BFD_RELOC_PPC_DTPREL16: r = R_PPC64_DTPREL16;
2310 break;
2311 case BFD_RELOC_PPC_DTPREL16_LO: r = R_PPC64_DTPREL16_LO;
2312 break;
2313 case BFD_RELOC_PPC_DTPREL16_HI: r = R_PPC64_DTPREL16_HI;
2314 break;
2315 case BFD_RELOC_PPC64_DTPREL16_HIGH: r = R_PPC64_DTPREL16_HIGH;
2316 break;
2317 case BFD_RELOC_PPC_DTPREL16_HA: r = R_PPC64_DTPREL16_HA;
2318 break;
2319 case BFD_RELOC_PPC64_DTPREL16_HIGHA: r = R_PPC64_DTPREL16_HIGHA;
2320 break;
2321 case BFD_RELOC_PPC_DTPREL: r = R_PPC64_DTPREL64;
2322 break;
2323 case BFD_RELOC_PPC_GOT_TLSGD16: r = R_PPC64_GOT_TLSGD16;
2324 break;
2325 case BFD_RELOC_PPC_GOT_TLSGD16_LO: r = R_PPC64_GOT_TLSGD16_LO;
2326 break;
2327 case BFD_RELOC_PPC_GOT_TLSGD16_HI: r = R_PPC64_GOT_TLSGD16_HI;
2328 break;
2329 case BFD_RELOC_PPC_GOT_TLSGD16_HA: r = R_PPC64_GOT_TLSGD16_HA;
2330 break;
2331 case BFD_RELOC_PPC_GOT_TLSLD16: r = R_PPC64_GOT_TLSLD16;
2332 break;
2333 case BFD_RELOC_PPC_GOT_TLSLD16_LO: r = R_PPC64_GOT_TLSLD16_LO;
2334 break;
2335 case BFD_RELOC_PPC_GOT_TLSLD16_HI: r = R_PPC64_GOT_TLSLD16_HI;
2336 break;
2337 case BFD_RELOC_PPC_GOT_TLSLD16_HA: r = R_PPC64_GOT_TLSLD16_HA;
2338 break;
2339 case BFD_RELOC_PPC_GOT_TPREL16: r = R_PPC64_GOT_TPREL16_DS;
2340 break;
2341 case BFD_RELOC_PPC_GOT_TPREL16_LO: r = R_PPC64_GOT_TPREL16_LO_DS;
2342 break;
2343 case BFD_RELOC_PPC_GOT_TPREL16_HI: r = R_PPC64_GOT_TPREL16_HI;
2344 break;
2345 case BFD_RELOC_PPC_GOT_TPREL16_HA: r = R_PPC64_GOT_TPREL16_HA;
2346 break;
2347 case BFD_RELOC_PPC_GOT_DTPREL16: r = R_PPC64_GOT_DTPREL16_DS;
2348 break;
2349 case BFD_RELOC_PPC_GOT_DTPREL16_LO: r = R_PPC64_GOT_DTPREL16_LO_DS;
2350 break;
2351 case BFD_RELOC_PPC_GOT_DTPREL16_HI: r = R_PPC64_GOT_DTPREL16_HI;
2352 break;
2353 case BFD_RELOC_PPC_GOT_DTPREL16_HA: r = R_PPC64_GOT_DTPREL16_HA;
2354 break;
2355 case BFD_RELOC_PPC64_TPREL16_DS: r = R_PPC64_TPREL16_DS;
2356 break;
2357 case BFD_RELOC_PPC64_TPREL16_LO_DS: r = R_PPC64_TPREL16_LO_DS;
2358 break;
2359 case BFD_RELOC_PPC64_TPREL16_HIGHER: r = R_PPC64_TPREL16_HIGHER;
2360 break;
2361 case BFD_RELOC_PPC64_TPREL16_HIGHERA: r = R_PPC64_TPREL16_HIGHERA;
2362 break;
2363 case BFD_RELOC_PPC64_TPREL16_HIGHEST: r = R_PPC64_TPREL16_HIGHEST;
2364 break;
2365 case BFD_RELOC_PPC64_TPREL16_HIGHESTA: r = R_PPC64_TPREL16_HIGHESTA;
2366 break;
2367 case BFD_RELOC_PPC64_DTPREL16_DS: r = R_PPC64_DTPREL16_DS;
2368 break;
2369 case BFD_RELOC_PPC64_DTPREL16_LO_DS: r = R_PPC64_DTPREL16_LO_DS;
2370 break;
2371 case BFD_RELOC_PPC64_DTPREL16_HIGHER: r = R_PPC64_DTPREL16_HIGHER;
2372 break;
2373 case BFD_RELOC_PPC64_DTPREL16_HIGHERA: r = R_PPC64_DTPREL16_HIGHERA;
2374 break;
2375 case BFD_RELOC_PPC64_DTPREL16_HIGHEST: r = R_PPC64_DTPREL16_HIGHEST;
2376 break;
2377 case BFD_RELOC_PPC64_DTPREL16_HIGHESTA: r = R_PPC64_DTPREL16_HIGHESTA;
2378 break;
2379 case BFD_RELOC_16_PCREL: r = R_PPC64_REL16;
2380 break;
2381 case BFD_RELOC_LO16_PCREL: r = R_PPC64_REL16_LO;
2382 break;
2383 case BFD_RELOC_HI16_PCREL: r = R_PPC64_REL16_HI;
2384 break;
2385 case BFD_RELOC_HI16_S_PCREL: r = R_PPC64_REL16_HA;
2386 break;
2387 case BFD_RELOC_VTABLE_INHERIT: r = R_PPC64_GNU_VTINHERIT;
2388 break;
2389 case BFD_RELOC_VTABLE_ENTRY: r = R_PPC64_GNU_VTENTRY;
2390 break;
2391 }
2392
2393 return ppc64_elf_howto_table[r];
2394 };
2395
2396 static reloc_howto_type *
2397 ppc64_elf_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2398 const char *r_name)
2399 {
2400 unsigned int i;
2401
2402 for (i = 0;
2403 i < sizeof (ppc64_elf_howto_raw) / sizeof (ppc64_elf_howto_raw[0]);
2404 i++)
2405 if (ppc64_elf_howto_raw[i].name != NULL
2406 && strcasecmp (ppc64_elf_howto_raw[i].name, r_name) == 0)
2407 return &ppc64_elf_howto_raw[i];
2408
2409 return NULL;
2410 }
2411
2412 /* Set the howto pointer for a PowerPC ELF reloc. */
2413
2414 static void
2415 ppc64_elf_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr,
2416 Elf_Internal_Rela *dst)
2417 {
2418 unsigned int type;
2419
2420 /* Initialize howto table if needed. */
2421 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2422 ppc_howto_init ();
2423
2424 type = ELF64_R_TYPE (dst->r_info);
2425 if (type >= (sizeof (ppc64_elf_howto_table)
2426 / sizeof (ppc64_elf_howto_table[0])))
2427 {
2428 (*_bfd_error_handler) (_("%B: invalid relocation type %d"),
2429 abfd, (int) type);
2430 type = R_PPC64_NONE;
2431 }
2432 cache_ptr->howto = ppc64_elf_howto_table[type];
2433 }
2434
2435 /* Handle the R_PPC64_ADDR16_HA and similar relocs. */
2436
2437 static bfd_reloc_status_type
2438 ppc64_elf_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2439 void *data, asection *input_section,
2440 bfd *output_bfd, char **error_message)
2441 {
2442 /* If this is a relocatable link (output_bfd test tells us), just
2443 call the generic function. Any adjustment will be done at final
2444 link time. */
2445 if (output_bfd != NULL)
2446 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2447 input_section, output_bfd, error_message);
2448
2449 /* Adjust the addend for sign extension of the low 16 bits.
2450 We won't actually be using the low 16 bits, so trashing them
2451 doesn't matter. */
2452 reloc_entry->addend += 0x8000;
2453 return bfd_reloc_continue;
2454 }
2455
2456 static bfd_reloc_status_type
2457 ppc64_elf_branch_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2458 void *data, asection *input_section,
2459 bfd *output_bfd, char **error_message)
2460 {
2461 if (output_bfd != NULL)
2462 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2463 input_section, output_bfd, error_message);
2464
2465 if (strcmp (symbol->section->name, ".opd") == 0
2466 && (symbol->section->owner->flags & DYNAMIC) == 0)
2467 {
2468 bfd_vma dest = opd_entry_value (symbol->section,
2469 symbol->value + reloc_entry->addend,
2470 NULL, NULL, FALSE);
2471 if (dest != (bfd_vma) -1)
2472 reloc_entry->addend = dest - (symbol->value
2473 + symbol->section->output_section->vma
2474 + symbol->section->output_offset);
2475 }
2476 return bfd_reloc_continue;
2477 }
2478
2479 static bfd_reloc_status_type
2480 ppc64_elf_brtaken_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2481 void *data, asection *input_section,
2482 bfd *output_bfd, char **error_message)
2483 {
2484 long insn;
2485 enum elf_ppc64_reloc_type r_type;
2486 bfd_size_type octets;
2487 /* Assume 'at' branch hints. */
2488 bfd_boolean is_isa_v2 = TRUE;
2489
2490 /* If this is a relocatable link (output_bfd test tells us), just
2491 call the generic function. Any adjustment will be done at final
2492 link time. */
2493 if (output_bfd != NULL)
2494 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2495 input_section, output_bfd, error_message);
2496
2497 octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2498 insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
2499 insn &= ~(0x01 << 21);
2500 r_type = reloc_entry->howto->type;
2501 if (r_type == R_PPC64_ADDR14_BRTAKEN
2502 || r_type == R_PPC64_REL14_BRTAKEN)
2503 insn |= 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field. */
2504
2505 if (is_isa_v2)
2506 {
2507 /* Set 'a' bit. This is 0b00010 in BO field for branch
2508 on CR(BI) insns (BO == 001at or 011at), and 0b01000
2509 for branch on CTR insns (BO == 1a00t or 1a01t). */
2510 if ((insn & (0x14 << 21)) == (0x04 << 21))
2511 insn |= 0x02 << 21;
2512 else if ((insn & (0x14 << 21)) == (0x10 << 21))
2513 insn |= 0x08 << 21;
2514 else
2515 goto out;
2516 }
2517 else
2518 {
2519 bfd_vma target = 0;
2520 bfd_vma from;
2521
2522 if (!bfd_is_com_section (symbol->section))
2523 target = symbol->value;
2524 target += symbol->section->output_section->vma;
2525 target += symbol->section->output_offset;
2526 target += reloc_entry->addend;
2527
2528 from = (reloc_entry->address
2529 + input_section->output_offset
2530 + input_section->output_section->vma);
2531
2532 /* Invert 'y' bit if not the default. */
2533 if ((bfd_signed_vma) (target - from) < 0)
2534 insn ^= 0x01 << 21;
2535 }
2536 bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
2537 out:
2538 return ppc64_elf_branch_reloc (abfd, reloc_entry, symbol, data,
2539 input_section, output_bfd, error_message);
2540 }
2541
2542 static bfd_reloc_status_type
2543 ppc64_elf_sectoff_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2544 void *data, asection *input_section,
2545 bfd *output_bfd, char **error_message)
2546 {
2547 /* If this is a relocatable link (output_bfd test tells us), just
2548 call the generic function. Any adjustment will be done at final
2549 link time. */
2550 if (output_bfd != NULL)
2551 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2552 input_section, output_bfd, error_message);
2553
2554 /* Subtract the symbol section base address. */
2555 reloc_entry->addend -= symbol->section->output_section->vma;
2556 return bfd_reloc_continue;
2557 }
2558
2559 static bfd_reloc_status_type
2560 ppc64_elf_sectoff_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2561 void *data, asection *input_section,
2562 bfd *output_bfd, char **error_message)
2563 {
2564 /* If this is a relocatable link (output_bfd test tells us), just
2565 call the generic function. Any adjustment will be done at final
2566 link time. */
2567 if (output_bfd != NULL)
2568 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2569 input_section, output_bfd, error_message);
2570
2571 /* Subtract the symbol section base address. */
2572 reloc_entry->addend -= symbol->section->output_section->vma;
2573
2574 /* Adjust the addend for sign extension of the low 16 bits. */
2575 reloc_entry->addend += 0x8000;
2576 return bfd_reloc_continue;
2577 }
2578
2579 static bfd_reloc_status_type
2580 ppc64_elf_toc_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2581 void *data, asection *input_section,
2582 bfd *output_bfd, char **error_message)
2583 {
2584 bfd_vma TOCstart;
2585
2586 /* If this is a relocatable link (output_bfd test tells us), just
2587 call the generic function. Any adjustment will be done at final
2588 link time. */
2589 if (output_bfd != NULL)
2590 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2591 input_section, output_bfd, error_message);
2592
2593 TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2594 if (TOCstart == 0)
2595 TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2596
2597 /* Subtract the TOC base address. */
2598 reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2599 return bfd_reloc_continue;
2600 }
2601
2602 static bfd_reloc_status_type
2603 ppc64_elf_toc_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2604 void *data, asection *input_section,
2605 bfd *output_bfd, char **error_message)
2606 {
2607 bfd_vma TOCstart;
2608
2609 /* If this is a relocatable link (output_bfd test tells us), just
2610 call the generic function. Any adjustment will be done at final
2611 link time. */
2612 if (output_bfd != NULL)
2613 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2614 input_section, output_bfd, error_message);
2615
2616 TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2617 if (TOCstart == 0)
2618 TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2619
2620 /* Subtract the TOC base address. */
2621 reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2622
2623 /* Adjust the addend for sign extension of the low 16 bits. */
2624 reloc_entry->addend += 0x8000;
2625 return bfd_reloc_continue;
2626 }
2627
2628 static bfd_reloc_status_type
2629 ppc64_elf_toc64_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2630 void *data, asection *input_section,
2631 bfd *output_bfd, char **error_message)
2632 {
2633 bfd_vma TOCstart;
2634 bfd_size_type octets;
2635
2636 /* If this is a relocatable link (output_bfd test tells us), just
2637 call the generic function. Any adjustment will be done at final
2638 link time. */
2639 if (output_bfd != NULL)
2640 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2641 input_section, output_bfd, error_message);
2642
2643 TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2644 if (TOCstart == 0)
2645 TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2646
2647 octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2648 bfd_put_64 (abfd, TOCstart + TOC_BASE_OFF, (bfd_byte *) data + octets);
2649 return bfd_reloc_ok;
2650 }
2651
2652 static bfd_reloc_status_type
2653 ppc64_elf_unhandled_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2654 void *data, asection *input_section,
2655 bfd *output_bfd, char **error_message)
2656 {
2657 /* If this is a relocatable link (output_bfd test tells us), just
2658 call the generic function. Any adjustment will be done at final
2659 link time. */
2660 if (output_bfd != NULL)
2661 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2662 input_section, output_bfd, error_message);
2663
2664 if (error_message != NULL)
2665 {
2666 static char buf[60];
2667 sprintf (buf, "generic linker can't handle %s",
2668 reloc_entry->howto->name);
2669 *error_message = buf;
2670 }
2671 return bfd_reloc_dangerous;
2672 }
2673
2674 /* Track GOT entries needed for a given symbol. We might need more
2675 than one got entry per symbol. */
2676 struct got_entry
2677 {
2678 struct got_entry *next;
2679
2680 /* The symbol addend that we'll be placing in the GOT. */
2681 bfd_vma addend;
2682
2683 /* Unlike other ELF targets, we use separate GOT entries for the same
2684 symbol referenced from different input files. This is to support
2685 automatic multiple TOC/GOT sections, where the TOC base can vary
2686 from one input file to another. After partitioning into TOC groups
2687 we merge entries within the group.
2688
2689 Point to the BFD owning this GOT entry. */
2690 bfd *owner;
2691
2692 /* Zero for non-tls entries, or TLS_TLS and one of TLS_GD, TLS_LD,
2693 TLS_TPREL or TLS_DTPREL for tls entries. */
2694 unsigned char tls_type;
2695
2696 /* Non-zero if got.ent points to real entry. */
2697 unsigned char is_indirect;
2698
2699 /* Reference count until size_dynamic_sections, GOT offset thereafter. */
2700 union
2701 {
2702 bfd_signed_vma refcount;
2703 bfd_vma offset;
2704 struct got_entry *ent;
2705 } got;
2706 };
2707
2708 /* The same for PLT. */
2709 struct plt_entry
2710 {
2711 struct plt_entry *next;
2712
2713 bfd_vma addend;
2714
2715 union
2716 {
2717 bfd_signed_vma refcount;
2718 bfd_vma offset;
2719 } plt;
2720 };
2721
2722 struct ppc64_elf_obj_tdata
2723 {
2724 struct elf_obj_tdata elf;
2725
2726 /* Shortcuts to dynamic linker sections. */
2727 asection *got;
2728 asection *relgot;
2729
2730 /* Used during garbage collection. We attach global symbols defined
2731 on removed .opd entries to this section so that the sym is removed. */
2732 asection *deleted_section;
2733
2734 /* TLS local dynamic got entry handling. Support for multiple GOT
2735 sections means we potentially need one of these for each input bfd. */
2736 struct got_entry tlsld_got;
2737
2738 union {
2739 /* A copy of relocs before they are modified for --emit-relocs. */
2740 Elf_Internal_Rela *relocs;
2741
2742 /* Section contents. */
2743 bfd_byte *contents;
2744 } opd;
2745
2746 /* Nonzero if this bfd has small toc/got relocs, ie. that expect
2747 the reloc to be in the range -32768 to 32767. */
2748 unsigned int has_small_toc_reloc : 1;
2749
2750 /* Set if toc/got ha relocs detected not using r2, or lo reloc
2751 instruction not one we handle. */
2752 unsigned int unexpected_toc_insn : 1;
2753 };
2754
2755 #define ppc64_elf_tdata(bfd) \
2756 ((struct ppc64_elf_obj_tdata *) (bfd)->tdata.any)
2757
2758 #define ppc64_tlsld_got(bfd) \
2759 (&ppc64_elf_tdata (bfd)->tlsld_got)
2760
2761 #define is_ppc64_elf(bfd) \
2762 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
2763 && elf_object_id (bfd) == PPC64_ELF_DATA)
2764
2765 /* Override the generic function because we store some extras. */
2766
2767 static bfd_boolean
2768 ppc64_elf_mkobject (bfd *abfd)
2769 {
2770 return bfd_elf_allocate_object (abfd, sizeof (struct ppc64_elf_obj_tdata),
2771 PPC64_ELF_DATA);
2772 }
2773
2774 /* Fix bad default arch selected for a 64 bit input bfd when the
2775 default is 32 bit. */
2776
2777 static bfd_boolean
2778 ppc64_elf_object_p (bfd *abfd)
2779 {
2780 if (abfd->arch_info->the_default && abfd->arch_info->bits_per_word == 32)
2781 {
2782 Elf_Internal_Ehdr *i_ehdr = elf_elfheader (abfd);
2783
2784 if (i_ehdr->e_ident[EI_CLASS] == ELFCLASS64)
2785 {
2786 /* Relies on arch after 32 bit default being 64 bit default. */
2787 abfd->arch_info = abfd->arch_info->next;
2788 BFD_ASSERT (abfd->arch_info->bits_per_word == 64);
2789 }
2790 }
2791 return TRUE;
2792 }
2793
2794 /* Support for core dump NOTE sections. */
2795
2796 static bfd_boolean
2797 ppc64_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
2798 {
2799 size_t offset, size;
2800
2801 if (note->descsz != 504)
2802 return FALSE;
2803
2804 /* pr_cursig */
2805 elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
2806
2807 /* pr_pid */
2808 elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 32);
2809
2810 /* pr_reg */
2811 offset = 112;
2812 size = 384;
2813
2814 /* Make a ".reg/999" section. */
2815 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
2816 size, note->descpos + offset);
2817 }
2818
2819 static bfd_boolean
2820 ppc64_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
2821 {
2822 if (note->descsz != 136)
2823 return FALSE;
2824
2825 elf_tdata (abfd)->core->pid
2826 = bfd_get_32 (abfd, note->descdata + 24);
2827 elf_tdata (abfd)->core->program
2828 = _bfd_elfcore_strndup (abfd, note->descdata + 40, 16);
2829 elf_tdata (abfd)->core->command
2830 = _bfd_elfcore_strndup (abfd, note->descdata + 56, 80);
2831
2832 return TRUE;
2833 }
2834
2835 static char *
2836 ppc64_elf_write_core_note (bfd *abfd, char *buf, int *bufsiz, int note_type,
2837 ...)
2838 {
2839 switch (note_type)
2840 {
2841 default:
2842 return NULL;
2843
2844 case NT_PRPSINFO:
2845 {
2846 char data[136];
2847 va_list ap;
2848
2849 va_start (ap, note_type);
2850 memset (data, 0, sizeof (data));
2851 strncpy (data + 40, va_arg (ap, const char *), 16);
2852 strncpy (data + 56, va_arg (ap, const char *), 80);
2853 va_end (ap);
2854 return elfcore_write_note (abfd, buf, bufsiz,
2855 "CORE", note_type, data, sizeof (data));
2856 }
2857
2858 case NT_PRSTATUS:
2859 {
2860 char data[504];
2861 va_list ap;
2862 long pid;
2863 int cursig;
2864 const void *greg;
2865
2866 va_start (ap, note_type);
2867 memset (data, 0, 112);
2868 pid = va_arg (ap, long);
2869 bfd_put_32 (abfd, pid, data + 32);
2870 cursig = va_arg (ap, int);
2871 bfd_put_16 (abfd, cursig, data + 12);
2872 greg = va_arg (ap, const void *);
2873 memcpy (data + 112, greg, 384);
2874 memset (data + 496, 0, 8);
2875 va_end (ap);
2876 return elfcore_write_note (abfd, buf, bufsiz,
2877 "CORE", note_type, data, sizeof (data));
2878 }
2879 }
2880 }
2881
2882 /* Add extra PPC sections. */
2883
2884 static const struct bfd_elf_special_section ppc64_elf_special_sections[]=
2885 {
2886 { STRING_COMMA_LEN (".plt"), 0, SHT_NOBITS, 0 },
2887 { STRING_COMMA_LEN (".sbss"), -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE },
2888 { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2889 { STRING_COMMA_LEN (".toc"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2890 { STRING_COMMA_LEN (".toc1"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2891 { STRING_COMMA_LEN (".tocbss"), 0, SHT_NOBITS, SHF_ALLOC + SHF_WRITE },
2892 { NULL, 0, 0, 0, 0 }
2893 };
2894
2895 enum _ppc64_sec_type {
2896 sec_normal = 0,
2897 sec_opd = 1,
2898 sec_toc = 2
2899 };
2900
2901 struct _ppc64_elf_section_data
2902 {
2903 struct bfd_elf_section_data elf;
2904
2905 union
2906 {
2907 /* An array with one entry for each opd function descriptor. */
2908 struct _opd_sec_data
2909 {
2910 /* Points to the function code section for local opd entries. */
2911 asection **func_sec;
2912
2913 /* After editing .opd, adjust references to opd local syms. */
2914 long *adjust;
2915 } opd;
2916
2917 /* An array for toc sections, indexed by offset/8. */
2918 struct _toc_sec_data
2919 {
2920 /* Specifies the relocation symbol index used at a given toc offset. */
2921 unsigned *symndx;
2922
2923 /* And the relocation addend. */
2924 bfd_vma *add;
2925 } toc;
2926 } u;
2927
2928 enum _ppc64_sec_type sec_type:2;
2929
2930 /* Flag set when small branches are detected. Used to
2931 select suitable defaults for the stub group size. */
2932 unsigned int has_14bit_branch:1;
2933 };
2934
2935 #define ppc64_elf_section_data(sec) \
2936 ((struct _ppc64_elf_section_data *) elf_section_data (sec))
2937
2938 static bfd_boolean
2939 ppc64_elf_new_section_hook (bfd *abfd, asection *sec)
2940 {
2941 if (!sec->used_by_bfd)
2942 {
2943 struct _ppc64_elf_section_data *sdata;
2944 bfd_size_type amt = sizeof (*sdata);
2945
2946 sdata = bfd_zalloc (abfd, amt);
2947 if (sdata == NULL)
2948 return FALSE;
2949 sec->used_by_bfd = sdata;
2950 }
2951
2952 return _bfd_elf_new_section_hook (abfd, sec);
2953 }
2954
2955 static struct _opd_sec_data *
2956 get_opd_info (asection * sec)
2957 {
2958 if (sec != NULL
2959 && ppc64_elf_section_data (sec) != NULL
2960 && ppc64_elf_section_data (sec)->sec_type == sec_opd)
2961 return &ppc64_elf_section_data (sec)->u.opd;
2962 return NULL;
2963 }
2964
2965 static inline int
2966 abiversion (bfd *abfd)
2967 {
2968 return elf_elfheader (abfd)->e_flags & EF_PPC64_ABI;
2969 }
2970
2971 static inline void
2972 set_abiversion (bfd *abfd, int ver)
2973 {
2974 elf_elfheader (abfd)->e_flags &= ~EF_PPC64_ABI;
2975 elf_elfheader (abfd)->e_flags |= ver & EF_PPC64_ABI;
2976 }
2977 \f
2978 /* Parameters for the qsort hook. */
2979 static bfd_boolean synthetic_relocatable;
2980
2981 /* qsort comparison function for ppc64_elf_get_synthetic_symtab. */
2982
2983 static int
2984 compare_symbols (const void *ap, const void *bp)
2985 {
2986 const asymbol *a = * (const asymbol **) ap;
2987 const asymbol *b = * (const asymbol **) bp;
2988
2989 /* Section symbols first. */
2990 if ((a->flags & BSF_SECTION_SYM) && !(b->flags & BSF_SECTION_SYM))
2991 return -1;
2992 if (!(a->flags & BSF_SECTION_SYM) && (b->flags & BSF_SECTION_SYM))
2993 return 1;
2994
2995 /* then .opd symbols. */
2996 if (strcmp (a->section->name, ".opd") == 0
2997 && strcmp (b->section->name, ".opd") != 0)
2998 return -1;
2999 if (strcmp (a->section->name, ".opd") != 0
3000 && strcmp (b->section->name, ".opd") == 0)
3001 return 1;
3002
3003 /* then other code symbols. */
3004 if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3005 == (SEC_CODE | SEC_ALLOC)
3006 && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3007 != (SEC_CODE | SEC_ALLOC))
3008 return -1;
3009
3010 if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3011 != (SEC_CODE | SEC_ALLOC)
3012 && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3013 == (SEC_CODE | SEC_ALLOC))
3014 return 1;
3015
3016 if (synthetic_relocatable)
3017 {
3018 if (a->section->id < b->section->id)
3019 return -1;
3020
3021 if (a->section->id > b->section->id)
3022 return 1;
3023 }
3024
3025 if (a->value + a->section->vma < b->value + b->section->vma)
3026 return -1;
3027
3028 if (a->value + a->section->vma > b->value + b->section->vma)
3029 return 1;
3030
3031 /* For syms with the same value, prefer strong dynamic global function
3032 syms over other syms. */
3033 if ((a->flags & BSF_GLOBAL) != 0 && (b->flags & BSF_GLOBAL) == 0)
3034 return -1;
3035
3036 if ((a->flags & BSF_GLOBAL) == 0 && (b->flags & BSF_GLOBAL) != 0)
3037 return 1;
3038
3039 if ((a->flags & BSF_FUNCTION) != 0 && (b->flags & BSF_FUNCTION) == 0)
3040 return -1;
3041
3042 if ((a->flags & BSF_FUNCTION) == 0 && (b->flags & BSF_FUNCTION) != 0)
3043 return 1;
3044
3045 if ((a->flags & BSF_WEAK) == 0 && (b->flags & BSF_WEAK) != 0)
3046 return -1;
3047
3048 if ((a->flags & BSF_WEAK) != 0 && (b->flags & BSF_WEAK) == 0)
3049 return 1;
3050
3051 if ((a->flags & BSF_DYNAMIC) != 0 && (b->flags & BSF_DYNAMIC) == 0)
3052 return -1;
3053
3054 if ((a->flags & BSF_DYNAMIC) == 0 && (b->flags & BSF_DYNAMIC) != 0)
3055 return 1;
3056
3057 return 0;
3058 }
3059
3060 /* Search SYMS for a symbol of the given VALUE. */
3061
3062 static asymbol *
3063 sym_exists_at (asymbol **syms, long lo, long hi, int id, bfd_vma value)
3064 {
3065 long mid;
3066
3067 if (id == -1)
3068 {
3069 while (lo < hi)
3070 {
3071 mid = (lo + hi) >> 1;
3072 if (syms[mid]->value + syms[mid]->section->vma < value)
3073 lo = mid + 1;
3074 else if (syms[mid]->value + syms[mid]->section->vma > value)
3075 hi = mid;
3076 else
3077 return syms[mid];
3078 }
3079 }
3080 else
3081 {
3082 while (lo < hi)
3083 {
3084 mid = (lo + hi) >> 1;
3085 if (syms[mid]->section->id < id)
3086 lo = mid + 1;
3087 else if (syms[mid]->section->id > id)
3088 hi = mid;
3089 else if (syms[mid]->value < value)
3090 lo = mid + 1;
3091 else if (syms[mid]->value > value)
3092 hi = mid;
3093 else
3094 return syms[mid];
3095 }
3096 }
3097 return NULL;
3098 }
3099
3100 static bfd_boolean
3101 section_covers_vma (bfd *abfd ATTRIBUTE_UNUSED, asection *section, void *ptr)
3102 {
3103 bfd_vma vma = *(bfd_vma *) ptr;
3104 return ((section->flags & SEC_ALLOC) != 0
3105 && section->vma <= vma
3106 && vma < section->vma + section->size);
3107 }
3108
3109 /* Create synthetic symbols, effectively restoring "dot-symbol" function
3110 entry syms. Also generate @plt symbols for the glink branch table. */
3111
3112 static long
3113 ppc64_elf_get_synthetic_symtab (bfd *abfd,
3114 long static_count, asymbol **static_syms,
3115 long dyn_count, asymbol **dyn_syms,
3116 asymbol **ret)
3117 {
3118 asymbol *s;
3119 long i;
3120 long count;
3121 char *names;
3122 long symcount, codesecsym, codesecsymend, secsymend, opdsymend;
3123 asection *opd = NULL;
3124 bfd_boolean relocatable = (abfd->flags & (EXEC_P | DYNAMIC)) == 0;
3125 asymbol **syms;
3126 int abi = abiversion (abfd);
3127
3128 *ret = NULL;
3129
3130 if (abi < 2)
3131 {
3132 opd = bfd_get_section_by_name (abfd, ".opd");
3133 if (opd == NULL && abi == 1)
3134 return 0;
3135 }
3136
3137 symcount = static_count;
3138 if (!relocatable)
3139 symcount += dyn_count;
3140 if (symcount == 0)
3141 return 0;
3142
3143 syms = bfd_malloc ((symcount + 1) * sizeof (*syms));
3144 if (syms == NULL)
3145 return -1;
3146
3147 if (!relocatable && static_count != 0 && dyn_count != 0)
3148 {
3149 /* Use both symbol tables. */
3150 memcpy (syms, static_syms, static_count * sizeof (*syms));
3151 memcpy (syms + static_count, dyn_syms, (dyn_count + 1) * sizeof (*syms));
3152 }
3153 else if (!relocatable && static_count == 0)
3154 memcpy (syms, dyn_syms, (symcount + 1) * sizeof (*syms));
3155 else
3156 memcpy (syms, static_syms, (symcount + 1) * sizeof (*syms));
3157
3158 synthetic_relocatable = relocatable;
3159 qsort (syms, symcount, sizeof (*syms), compare_symbols);
3160
3161 if (!relocatable && symcount > 1)
3162 {
3163 long j;
3164 /* Trim duplicate syms, since we may have merged the normal and
3165 dynamic symbols. Actually, we only care about syms that have
3166 different values, so trim any with the same value. */
3167 for (i = 1, j = 1; i < symcount; ++i)
3168 if (syms[i - 1]->value + syms[i - 1]->section->vma
3169 != syms[i]->value + syms[i]->section->vma)
3170 syms[j++] = syms[i];
3171 symcount = j;
3172 }
3173
3174 i = 0;
3175 if (strcmp (syms[i]->section->name, ".opd") == 0)
3176 ++i;
3177 codesecsym = i;
3178
3179 for (; i < symcount; ++i)
3180 if (((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3181 != (SEC_CODE | SEC_ALLOC))
3182 || (syms[i]->flags & BSF_SECTION_SYM) == 0)
3183 break;
3184 codesecsymend = i;
3185
3186 for (; i < symcount; ++i)
3187 if ((syms[i]->flags & BSF_SECTION_SYM) == 0)
3188 break;
3189 secsymend = i;
3190
3191 for (; i < symcount; ++i)
3192 if (strcmp (syms[i]->section->name, ".opd") != 0)
3193 break;
3194 opdsymend = i;
3195
3196 for (; i < symcount; ++i)
3197 if ((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3198 != (SEC_CODE | SEC_ALLOC))
3199 break;
3200 symcount = i;
3201
3202 count = 0;
3203
3204 if (relocatable)
3205 {
3206 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3207 arelent *r;
3208 size_t size;
3209 long relcount;
3210
3211 if (opdsymend == secsymend)
3212 goto done;
3213
3214 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3215 relcount = (opd->flags & SEC_RELOC) ? opd->reloc_count : 0;
3216 if (relcount == 0)
3217 goto done;
3218
3219 if (!(*slurp_relocs) (abfd, opd, static_syms, FALSE))
3220 {
3221 count = -1;
3222 goto done;
3223 }
3224
3225 size = 0;
3226 for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3227 {
3228 asymbol *sym;
3229
3230 while (r < opd->relocation + relcount
3231 && r->address < syms[i]->value + opd->vma)
3232 ++r;
3233
3234 if (r == opd->relocation + relcount)
3235 break;
3236
3237 if (r->address != syms[i]->value + opd->vma)
3238 continue;
3239
3240 if (r->howto->type != R_PPC64_ADDR64)
3241 continue;
3242
3243 sym = *r->sym_ptr_ptr;
3244 if (!sym_exists_at (syms, opdsymend, symcount,
3245 sym->section->id, sym->value + r->addend))
3246 {
3247 ++count;
3248 size += sizeof (asymbol);
3249 size += strlen (syms[i]->name) + 2;
3250 }
3251 }
3252
3253 s = *ret = bfd_malloc (size);
3254 if (s == NULL)
3255 {
3256 count = -1;
3257 goto done;
3258 }
3259
3260 names = (char *) (s + count);
3261
3262 for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3263 {
3264 asymbol *sym;
3265
3266 while (r < opd->relocation + relcount
3267 && r->address < syms[i]->value + opd->vma)
3268 ++r;
3269
3270 if (r == opd->relocation + relcount)
3271 break;
3272
3273 if (r->address != syms[i]->value + opd->vma)
3274 continue;
3275
3276 if (r->howto->type != R_PPC64_ADDR64)
3277 continue;
3278
3279 sym = *r->sym_ptr_ptr;
3280 if (!sym_exists_at (syms, opdsymend, symcount,
3281 sym->section->id, sym->value + r->addend))
3282 {
3283 size_t len;
3284
3285 *s = *syms[i];
3286 s->flags |= BSF_SYNTHETIC;
3287 s->section = sym->section;
3288 s->value = sym->value + r->addend;
3289 s->name = names;
3290 *names++ = '.';
3291 len = strlen (syms[i]->name);
3292 memcpy (names, syms[i]->name, len + 1);
3293 names += len + 1;
3294 /* Have udata.p point back to the original symbol this
3295 synthetic symbol was derived from. */
3296 s->udata.p = syms[i];
3297 s++;
3298 }
3299 }
3300 }
3301 else
3302 {
3303 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3304 bfd_byte *contents = NULL;
3305 size_t size;
3306 long plt_count = 0;
3307 bfd_vma glink_vma = 0, resolv_vma = 0;
3308 asection *dynamic, *glink = NULL, *relplt = NULL;
3309 arelent *p;
3310
3311 if (opd != NULL && !bfd_malloc_and_get_section (abfd, opd, &contents))
3312 {
3313 free_contents_and_exit:
3314 if (contents)
3315 free (contents);
3316 count = -1;
3317 goto done;
3318 }
3319
3320 size = 0;
3321 for (i = secsymend; i < opdsymend; ++i)
3322 {
3323 bfd_vma ent;
3324
3325 /* Ignore bogus symbols. */
3326 if (syms[i]->value > opd->size - 8)
3327 continue;
3328
3329 ent = bfd_get_64 (abfd, contents + syms[i]->value);
3330 if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3331 {
3332 ++count;
3333 size += sizeof (asymbol);
3334 size += strlen (syms[i]->name) + 2;
3335 }
3336 }
3337
3338 /* Get start of .glink stubs from DT_PPC64_GLINK. */
3339 if (dyn_count != 0
3340 && (dynamic = bfd_get_section_by_name (abfd, ".dynamic")) != NULL)
3341 {
3342 bfd_byte *dynbuf, *extdyn, *extdynend;
3343 size_t extdynsize;
3344 void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *);
3345
3346 if (!bfd_malloc_and_get_section (abfd, dynamic, &dynbuf))
3347 goto free_contents_and_exit;
3348
3349 extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
3350 swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
3351
3352 extdyn = dynbuf;
3353 extdynend = extdyn + dynamic->size;
3354 for (; extdyn < extdynend; extdyn += extdynsize)
3355 {
3356 Elf_Internal_Dyn dyn;
3357 (*swap_dyn_in) (abfd, extdyn, &dyn);
3358
3359 if (dyn.d_tag == DT_NULL)
3360 break;
3361
3362 if (dyn.d_tag == DT_PPC64_GLINK)
3363 {
3364 /* The first glink stub starts at offset 32; see
3365 comment in ppc64_elf_finish_dynamic_sections. */
3366 glink_vma = dyn.d_un.d_val + GLINK_CALL_STUB_SIZE - 8 * 4;
3367 /* The .glink section usually does not survive the final
3368 link; search for the section (usually .text) where the
3369 glink stubs now reside. */
3370 glink = bfd_sections_find_if (abfd, section_covers_vma,
3371 &glink_vma);
3372 break;
3373 }
3374 }
3375
3376 free (dynbuf);
3377 }
3378
3379 if (glink != NULL)
3380 {
3381 /* Determine __glink trampoline by reading the relative branch
3382 from the first glink stub. */
3383 bfd_byte buf[4];
3384 unsigned int off = 0;
3385
3386 while (bfd_get_section_contents (abfd, glink, buf,
3387 glink_vma + off - glink->vma, 4))
3388 {
3389 unsigned int insn = bfd_get_32 (abfd, buf);
3390 insn ^= B_DOT;
3391 if ((insn & ~0x3fffffc) == 0)
3392 {
3393 resolv_vma = glink_vma + off + (insn ^ 0x2000000) - 0x2000000;
3394 break;
3395 }
3396 off += 4;
3397 if (off > 4)
3398 break;
3399 }
3400
3401 if (resolv_vma)
3402 size += sizeof (asymbol) + sizeof ("__glink_PLTresolve");
3403
3404 relplt = bfd_get_section_by_name (abfd, ".rela.plt");
3405 if (relplt != NULL)
3406 {
3407 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3408 if (! (*slurp_relocs) (abfd, relplt, dyn_syms, TRUE))
3409 goto free_contents_and_exit;
3410
3411 plt_count = relplt->size / sizeof (Elf64_External_Rela);
3412 size += plt_count * sizeof (asymbol);
3413
3414 p = relplt->relocation;
3415 for (i = 0; i < plt_count; i++, p++)
3416 {
3417 size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
3418 if (p->addend != 0)
3419 size += sizeof ("+0x") - 1 + 16;
3420 }
3421 }
3422 }
3423
3424 s = *ret = bfd_malloc (size);
3425 if (s == NULL)
3426 goto free_contents_and_exit;
3427
3428 names = (char *) (s + count + plt_count + (resolv_vma != 0));
3429
3430 for (i = secsymend; i < opdsymend; ++i)
3431 {
3432 bfd_vma ent;
3433
3434 if (syms[i]->value > opd->size - 8)
3435 continue;
3436
3437 ent = bfd_get_64 (abfd, contents + syms[i]->value);
3438 if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3439 {
3440 long lo, hi;
3441 size_t len;
3442 asection *sec = abfd->sections;
3443
3444 *s = *syms[i];
3445 lo = codesecsym;
3446 hi = codesecsymend;
3447 while (lo < hi)
3448 {
3449 long mid = (lo + hi) >> 1;
3450 if (syms[mid]->section->vma < ent)
3451 lo = mid + 1;
3452 else if (syms[mid]->section->vma > ent)
3453 hi = mid;
3454 else
3455 {
3456 sec = syms[mid]->section;
3457 break;
3458 }
3459 }
3460
3461 if (lo >= hi && lo > codesecsym)
3462 sec = syms[lo - 1]->section;
3463
3464 for (; sec != NULL; sec = sec->next)
3465 {
3466 if (sec->vma > ent)
3467 break;
3468 /* SEC_LOAD may not be set if SEC is from a separate debug
3469 info file. */
3470 if ((sec->flags & SEC_ALLOC) == 0)
3471 break;
3472 if ((sec->flags & SEC_CODE) != 0)
3473 s->section = sec;
3474 }
3475 s->flags |= BSF_SYNTHETIC;
3476 s->value = ent - s->section->vma;
3477 s->name = names;
3478 *names++ = '.';
3479 len = strlen (syms[i]->name);
3480 memcpy (names, syms[i]->name, len + 1);
3481 names += len + 1;
3482 /* Have udata.p point back to the original symbol this
3483 synthetic symbol was derived from. */
3484 s->udata.p = syms[i];
3485 s++;
3486 }
3487 }
3488 free (contents);
3489
3490 if (glink != NULL && relplt != NULL)
3491 {
3492 if (resolv_vma)
3493 {
3494 /* Add a symbol for the main glink trampoline. */
3495 memset (s, 0, sizeof *s);
3496 s->the_bfd = abfd;
3497 s->flags = BSF_GLOBAL | BSF_SYNTHETIC;
3498 s->section = glink;
3499 s->value = resolv_vma - glink->vma;
3500 s->name = names;
3501 memcpy (names, "__glink_PLTresolve", sizeof ("__glink_PLTresolve"));
3502 names += sizeof ("__glink_PLTresolve");
3503 s++;
3504 count++;
3505 }
3506
3507 /* FIXME: It would be very much nicer to put sym@plt on the
3508 stub rather than on the glink branch table entry. The
3509 objdump disassembler would then use a sensible symbol
3510 name on plt calls. The difficulty in doing so is
3511 a) finding the stubs, and,
3512 b) matching stubs against plt entries, and,
3513 c) there can be multiple stubs for a given plt entry.
3514
3515 Solving (a) could be done by code scanning, but older
3516 ppc64 binaries used different stubs to current code.
3517 (b) is the tricky one since you need to known the toc
3518 pointer for at least one function that uses a pic stub to
3519 be able to calculate the plt address referenced.
3520 (c) means gdb would need to set multiple breakpoints (or
3521 find the glink branch itself) when setting breakpoints
3522 for pending shared library loads. */
3523 p = relplt->relocation;
3524 for (i = 0; i < plt_count; i++, p++)
3525 {
3526 size_t len;
3527
3528 *s = **p->sym_ptr_ptr;
3529 /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set. Since
3530 we are defining a symbol, ensure one of them is set. */
3531 if ((s->flags & BSF_LOCAL) == 0)
3532 s->flags |= BSF_GLOBAL;
3533 s->flags |= BSF_SYNTHETIC;
3534 s->section = glink;
3535 s->value = glink_vma - glink->vma;
3536 s->name = names;
3537 s->udata.p = NULL;
3538 len = strlen ((*p->sym_ptr_ptr)->name);
3539 memcpy (names, (*p->sym_ptr_ptr)->name, len);
3540 names += len;
3541 if (p->addend != 0)
3542 {
3543 memcpy (names, "+0x", sizeof ("+0x") - 1);
3544 names += sizeof ("+0x") - 1;
3545 bfd_sprintf_vma (abfd, names, p->addend);
3546 names += strlen (names);
3547 }
3548 memcpy (names, "@plt", sizeof ("@plt"));
3549 names += sizeof ("@plt");
3550 s++;
3551 if (abi < 2)
3552 {
3553 glink_vma += 8;
3554 if (i >= 0x8000)
3555 glink_vma += 4;
3556 }
3557 else
3558 glink_vma += 4;
3559 }
3560 count += plt_count;
3561 }
3562 }
3563
3564 done:
3565 free (syms);
3566 return count;
3567 }
3568 \f
3569 /* The following functions are specific to the ELF linker, while
3570 functions above are used generally. Those named ppc64_elf_* are
3571 called by the main ELF linker code. They appear in this file more
3572 or less in the order in which they are called. eg.
3573 ppc64_elf_check_relocs is called early in the link process,
3574 ppc64_elf_finish_dynamic_sections is one of the last functions
3575 called.
3576
3577 PowerPC64-ELF uses a similar scheme to PowerPC64-XCOFF in that
3578 functions have both a function code symbol and a function descriptor
3579 symbol. A call to foo in a relocatable object file looks like:
3580
3581 . .text
3582 . x:
3583 . bl .foo
3584 . nop
3585
3586 The function definition in another object file might be:
3587
3588 . .section .opd
3589 . foo: .quad .foo
3590 . .quad .TOC.@tocbase
3591 . .quad 0
3592 .
3593 . .text
3594 . .foo: blr
3595
3596 When the linker resolves the call during a static link, the branch
3597 unsurprisingly just goes to .foo and the .opd information is unused.
3598 If the function definition is in a shared library, things are a little
3599 different: The call goes via a plt call stub, the opd information gets
3600 copied to the plt, and the linker patches the nop.
3601
3602 . x:
3603 . bl .foo_stub
3604 . ld 2,40(1)
3605 .
3606 .
3607 . .foo_stub:
3608 . std 2,40(1) # in practice, the call stub
3609 . addis 11,2,Lfoo@toc@ha # is slightly optimized, but
3610 . addi 11,11,Lfoo@toc@l # this is the general idea
3611 . ld 12,0(11)
3612 . ld 2,8(11)
3613 . mtctr 12
3614 . ld 11,16(11)
3615 . bctr
3616 .
3617 . .section .plt
3618 . Lfoo: reloc (R_PPC64_JMP_SLOT, foo)
3619
3620 The "reloc ()" notation is supposed to indicate that the linker emits
3621 an R_PPC64_JMP_SLOT reloc against foo. The dynamic linker does the opd
3622 copying.
3623
3624 What are the difficulties here? Well, firstly, the relocations
3625 examined by the linker in check_relocs are against the function code
3626 sym .foo, while the dynamic relocation in the plt is emitted against
3627 the function descriptor symbol, foo. Somewhere along the line, we need
3628 to carefully copy dynamic link information from one symbol to the other.
3629 Secondly, the generic part of the elf linker will make .foo a dynamic
3630 symbol as is normal for most other backends. We need foo dynamic
3631 instead, at least for an application final link. However, when
3632 creating a shared library containing foo, we need to have both symbols
3633 dynamic so that references to .foo are satisfied during the early
3634 stages of linking. Otherwise the linker might decide to pull in a
3635 definition from some other object, eg. a static library.
3636
3637 Update: As of August 2004, we support a new convention. Function
3638 calls may use the function descriptor symbol, ie. "bl foo". This
3639 behaves exactly as "bl .foo". */
3640
3641 /* Of those relocs that might be copied as dynamic relocs, this function
3642 selects those that must be copied when linking a shared library,
3643 even when the symbol is local. */
3644
3645 static int
3646 must_be_dyn_reloc (struct bfd_link_info *info,
3647 enum elf_ppc64_reloc_type r_type)
3648 {
3649 switch (r_type)
3650 {
3651 default:
3652 return 1;
3653
3654 case R_PPC64_REL32:
3655 case R_PPC64_REL64:
3656 case R_PPC64_REL30:
3657 return 0;
3658
3659 case R_PPC64_TPREL16:
3660 case R_PPC64_TPREL16_LO:
3661 case R_PPC64_TPREL16_HI:
3662 case R_PPC64_TPREL16_HA:
3663 case R_PPC64_TPREL16_DS:
3664 case R_PPC64_TPREL16_LO_DS:
3665 case R_PPC64_TPREL16_HIGH:
3666 case R_PPC64_TPREL16_HIGHA:
3667 case R_PPC64_TPREL16_HIGHER:
3668 case R_PPC64_TPREL16_HIGHERA:
3669 case R_PPC64_TPREL16_HIGHEST:
3670 case R_PPC64_TPREL16_HIGHESTA:
3671 case R_PPC64_TPREL64:
3672 return !info->executable;
3673 }
3674 }
3675
3676 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
3677 copying dynamic variables from a shared lib into an app's dynbss
3678 section, and instead use a dynamic relocation to point into the
3679 shared lib. With code that gcc generates, it's vital that this be
3680 enabled; In the PowerPC64 ABI, the address of a function is actually
3681 the address of a function descriptor, which resides in the .opd
3682 section. gcc uses the descriptor directly rather than going via the
3683 GOT as some other ABI's do, which means that initialized function
3684 pointers must reference the descriptor. Thus, a function pointer
3685 initialized to the address of a function in a shared library will
3686 either require a copy reloc, or a dynamic reloc. Using a copy reloc
3687 redefines the function descriptor symbol to point to the copy. This
3688 presents a problem as a plt entry for that function is also
3689 initialized from the function descriptor symbol and the copy reloc
3690 may not be initialized first. */
3691 #define ELIMINATE_COPY_RELOCS 1
3692
3693 /* Section name for stubs is the associated section name plus this
3694 string. */
3695 #define STUB_SUFFIX ".stub"
3696
3697 /* Linker stubs.
3698 ppc_stub_long_branch:
3699 Used when a 14 bit branch (or even a 24 bit branch) can't reach its
3700 destination, but a 24 bit branch in a stub section will reach.
3701 . b dest
3702
3703 ppc_stub_plt_branch:
3704 Similar to the above, but a 24 bit branch in the stub section won't
3705 reach its destination.
3706 . addis %r11,%r2,xxx@toc@ha
3707 . ld %r12,xxx@toc@l(%r11)
3708 . mtctr %r12
3709 . bctr
3710
3711 ppc_stub_plt_call:
3712 Used to call a function in a shared library. If it so happens that
3713 the plt entry referenced crosses a 64k boundary, then an extra
3714 "addi %r11,%r11,xxx@toc@l" will be inserted before the "mtctr".
3715 . std %r2,40(%r1)
3716 . addis %r11,%r2,xxx@toc@ha
3717 . ld %r12,xxx+0@toc@l(%r11)
3718 . mtctr %r12
3719 . ld %r2,xxx+8@toc@l(%r11)
3720 . ld %r11,xxx+16@toc@l(%r11)
3721 . bctr
3722
3723 ppc_stub_long_branch and ppc_stub_plt_branch may also have additional
3724 code to adjust the value and save r2 to support multiple toc sections.
3725 A ppc_stub_long_branch with an r2 offset looks like:
3726 . std %r2,40(%r1)
3727 . addis %r2,%r2,off@ha
3728 . addi %r2,%r2,off@l
3729 . b dest
3730
3731 A ppc_stub_plt_branch with an r2 offset looks like:
3732 . std %r2,40(%r1)
3733 . addis %r11,%r2,xxx@toc@ha
3734 . ld %r12,xxx@toc@l(%r11)
3735 . addis %r2,%r2,off@ha
3736 . addi %r2,%r2,off@l
3737 . mtctr %r12
3738 . bctr
3739
3740 In cases where the "addis" instruction would add zero, the "addis" is
3741 omitted and following instructions modified slightly in some cases.
3742 */
3743
3744 enum ppc_stub_type {
3745 ppc_stub_none,
3746 ppc_stub_long_branch,
3747 ppc_stub_long_branch_r2off,
3748 ppc_stub_plt_branch,
3749 ppc_stub_plt_branch_r2off,
3750 ppc_stub_plt_call,
3751 ppc_stub_plt_call_r2save
3752 };
3753
3754 struct ppc_stub_hash_entry {
3755
3756 /* Base hash table entry structure. */
3757 struct bfd_hash_entry root;
3758
3759 enum ppc_stub_type stub_type;
3760
3761 /* The stub section. */
3762 asection *stub_sec;
3763
3764 /* Offset within stub_sec of the beginning of this stub. */
3765 bfd_vma stub_offset;
3766
3767 /* Given the symbol's value and its section we can determine its final
3768 value when building the stubs (so the stub knows where to jump. */
3769 bfd_vma target_value;
3770 asection *target_section;
3771
3772 /* The symbol table entry, if any, that this was derived from. */
3773 struct ppc_link_hash_entry *h;
3774 struct plt_entry *plt_ent;
3775
3776 /* Where this stub is being called from, or, in the case of combined
3777 stub sections, the first input section in the group. */
3778 asection *id_sec;
3779
3780 /* Symbol st_other. */
3781 unsigned char other;
3782 };
3783
3784 struct ppc_branch_hash_entry {
3785
3786 /* Base hash table entry structure. */
3787 struct bfd_hash_entry root;
3788
3789 /* Offset within branch lookup table. */
3790 unsigned int offset;
3791
3792 /* Generation marker. */
3793 unsigned int iter;
3794 };
3795
3796 /* Used to track dynamic relocations for local symbols. */
3797 struct ppc_dyn_relocs
3798 {
3799 struct ppc_dyn_relocs *next;
3800
3801 /* The input section of the reloc. */
3802 asection *sec;
3803
3804 /* Total number of relocs copied for the input section. */
3805 unsigned int count : 31;
3806
3807 /* Whether this entry is for STT_GNU_IFUNC symbols. */
3808 unsigned int ifunc : 1;
3809 };
3810
3811 struct ppc_link_hash_entry
3812 {
3813 struct elf_link_hash_entry elf;
3814
3815 union {
3816 /* A pointer to the most recently used stub hash entry against this
3817 symbol. */
3818 struct ppc_stub_hash_entry *stub_cache;
3819
3820 /* A pointer to the next symbol starting with a '.' */
3821 struct ppc_link_hash_entry *next_dot_sym;
3822 } u;
3823
3824 /* Track dynamic relocs copied for this symbol. */
3825 struct elf_dyn_relocs *dyn_relocs;
3826
3827 /* Link between function code and descriptor symbols. */
3828 struct ppc_link_hash_entry *oh;
3829
3830 /* Flag function code and descriptor symbols. */
3831 unsigned int is_func:1;
3832 unsigned int is_func_descriptor:1;
3833 unsigned int fake:1;
3834
3835 /* Whether global opd/toc sym has been adjusted or not.
3836 After ppc64_elf_edit_opd/ppc64_elf_edit_toc has run, this flag
3837 should be set for all globals defined in any opd/toc section. */
3838 unsigned int adjust_done:1;
3839
3840 /* Set if we twiddled this symbol to weak at some stage. */
3841 unsigned int was_undefined:1;
3842
3843 /* Contexts in which symbol is used in the GOT (or TOC).
3844 TLS_GD .. TLS_EXPLICIT bits are or'd into the mask as the
3845 corresponding relocs are encountered during check_relocs.
3846 tls_optimize clears TLS_GD .. TLS_TPREL when optimizing to
3847 indicate the corresponding GOT entry type is not needed.
3848 tls_optimize may also set TLS_TPRELGD when a GD reloc turns into
3849 a TPREL one. We use a separate flag rather than setting TPREL
3850 just for convenience in distinguishing the two cases. */
3851 #define TLS_GD 1 /* GD reloc. */
3852 #define TLS_LD 2 /* LD reloc. */
3853 #define TLS_TPREL 4 /* TPREL reloc, => IE. */
3854 #define TLS_DTPREL 8 /* DTPREL reloc, => LD. */
3855 #define TLS_TLS 16 /* Any TLS reloc. */
3856 #define TLS_EXPLICIT 32 /* Marks TOC section TLS relocs. */
3857 #define TLS_TPRELGD 64 /* TPREL reloc resulting from GD->IE. */
3858 #define PLT_IFUNC 128 /* STT_GNU_IFUNC. */
3859 unsigned char tls_mask;
3860 };
3861
3862 /* ppc64 ELF linker hash table. */
3863
3864 struct ppc_link_hash_table
3865 {
3866 struct elf_link_hash_table elf;
3867
3868 /* The stub hash table. */
3869 struct bfd_hash_table stub_hash_table;
3870
3871 /* Another hash table for plt_branch stubs. */
3872 struct bfd_hash_table branch_hash_table;
3873
3874 /* Hash table for function prologue tocsave. */
3875 htab_t tocsave_htab;
3876
3877 /* Linker stub bfd. */
3878 bfd *stub_bfd;
3879
3880 /* Linker call-backs. */
3881 asection * (*add_stub_section) (const char *, asection *);
3882 void (*layout_sections_again) (void);
3883
3884 /* Array to keep track of which stub sections have been created, and
3885 information on stub grouping. */
3886 struct map_stub {
3887 /* This is the section to which stubs in the group will be attached. */
3888 asection *link_sec;
3889 /* The stub section. */
3890 asection *stub_sec;
3891 /* Along with elf_gp, specifies the TOC pointer used in this group. */
3892 bfd_vma toc_off;
3893 } *stub_group;
3894
3895 /* Temp used when calculating TOC pointers. */
3896 bfd_vma toc_curr;
3897 bfd *toc_bfd;
3898 asection *toc_first_sec;
3899
3900 /* Highest input section id. */
3901 int top_id;
3902
3903 /* Highest output section index. */
3904 int top_index;
3905
3906 /* Used when adding symbols. */
3907 struct ppc_link_hash_entry *dot_syms;
3908
3909 /* List of input sections for each output section. */
3910 asection **input_list;
3911
3912 /* Shortcuts to get to dynamic linker sections. */
3913 asection *dynbss;
3914 asection *relbss;
3915 asection *glink;
3916 asection *sfpr;
3917 asection *brlt;
3918 asection *relbrlt;
3919 asection *glink_eh_frame;
3920
3921 /* Shortcut to .__tls_get_addr and __tls_get_addr. */
3922 struct ppc_link_hash_entry *tls_get_addr;
3923 struct ppc_link_hash_entry *tls_get_addr_fd;
3924
3925 /* The size of reliplt used by got entry relocs. */
3926 bfd_size_type got_reli_size;
3927
3928 /* Statistics. */
3929 unsigned long stub_count[ppc_stub_plt_call_r2save];
3930
3931 /* Number of stubs against global syms. */
3932 unsigned long stub_globals;
3933
3934 /* Alignment of PLT call stubs. */
3935 unsigned int plt_stub_align:4;
3936
3937 /* Set if we're linking code with function descriptors. */
3938 unsigned int opd_abi:1;
3939
3940 /* Set if PLT call stubs should load r11. */
3941 unsigned int plt_static_chain:1;
3942
3943 /* Set if PLT call stubs need a read-read barrier. */
3944 unsigned int plt_thread_safe:1;
3945
3946 /* Set if we should emit symbols for stubs. */
3947 unsigned int emit_stub_syms:1;
3948
3949 /* Set if __tls_get_addr optimization should not be done. */
3950 unsigned int no_tls_get_addr_opt:1;
3951
3952 /* Support for multiple toc sections. */
3953 unsigned int do_multi_toc:1;
3954 unsigned int multi_toc_needed:1;
3955 unsigned int second_toc_pass:1;
3956 unsigned int do_toc_opt:1;
3957
3958 /* Set on error. */
3959 unsigned int stub_error:1;
3960
3961 /* Temp used by ppc64_elf_process_dot_syms. */
3962 unsigned int twiddled_syms:1;
3963
3964 /* Incremented every time we size stubs. */
3965 unsigned int stub_iteration;
3966
3967 /* Small local sym cache. */
3968 struct sym_cache sym_cache;
3969 };
3970
3971 /* Rename some of the generic section flags to better document how they
3972 are used here. */
3973
3974 /* Nonzero if this section has TLS related relocations. */
3975 #define has_tls_reloc sec_flg0
3976
3977 /* Nonzero if this section has a call to __tls_get_addr. */
3978 #define has_tls_get_addr_call sec_flg1
3979
3980 /* Nonzero if this section has any toc or got relocs. */
3981 #define has_toc_reloc sec_flg2
3982
3983 /* Nonzero if this section has a call to another section that uses
3984 the toc or got. */
3985 #define makes_toc_func_call sec_flg3
3986
3987 /* Recursion protection when determining above flag. */
3988 #define call_check_in_progress sec_flg4
3989 #define call_check_done sec_flg5
3990
3991 /* Get the ppc64 ELF linker hash table from a link_info structure. */
3992
3993 #define ppc_hash_table(p) \
3994 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
3995 == PPC64_ELF_DATA ? ((struct ppc_link_hash_table *) ((p)->hash)) : NULL)
3996
3997 #define ppc_stub_hash_lookup(table, string, create, copy) \
3998 ((struct ppc_stub_hash_entry *) \
3999 bfd_hash_lookup ((table), (string), (create), (copy)))
4000
4001 #define ppc_branch_hash_lookup(table, string, create, copy) \
4002 ((struct ppc_branch_hash_entry *) \
4003 bfd_hash_lookup ((table), (string), (create), (copy)))
4004
4005 /* Create an entry in the stub hash table. */
4006
4007 static struct bfd_hash_entry *
4008 stub_hash_newfunc (struct bfd_hash_entry *entry,
4009 struct bfd_hash_table *table,
4010 const char *string)
4011 {
4012 /* Allocate the structure if it has not already been allocated by a
4013 subclass. */
4014 if (entry == NULL)
4015 {
4016 entry = bfd_hash_allocate (table, sizeof (struct ppc_stub_hash_entry));
4017 if (entry == NULL)
4018 return entry;
4019 }
4020
4021 /* Call the allocation method of the superclass. */
4022 entry = bfd_hash_newfunc (entry, table, string);
4023 if (entry != NULL)
4024 {
4025 struct ppc_stub_hash_entry *eh;
4026
4027 /* Initialize the local fields. */
4028 eh = (struct ppc_stub_hash_entry *) entry;
4029 eh->stub_type = ppc_stub_none;
4030 eh->stub_sec = NULL;
4031 eh->stub_offset = 0;
4032 eh->target_value = 0;
4033 eh->target_section = NULL;
4034 eh->h = NULL;
4035 eh->plt_ent = NULL;
4036 eh->id_sec = NULL;
4037 eh->other = 0;
4038 }
4039
4040 return entry;
4041 }
4042
4043 /* Create an entry in the branch hash table. */
4044
4045 static struct bfd_hash_entry *
4046 branch_hash_newfunc (struct bfd_hash_entry *entry,
4047 struct bfd_hash_table *table,
4048 const char *string)
4049 {
4050 /* Allocate the structure if it has not already been allocated by a
4051 subclass. */
4052 if (entry == NULL)
4053 {
4054 entry = bfd_hash_allocate (table, sizeof (struct ppc_branch_hash_entry));
4055 if (entry == NULL)
4056 return entry;
4057 }
4058
4059 /* Call the allocation method of the superclass. */
4060 entry = bfd_hash_newfunc (entry, table, string);
4061 if (entry != NULL)
4062 {
4063 struct ppc_branch_hash_entry *eh;
4064
4065 /* Initialize the local fields. */
4066 eh = (struct ppc_branch_hash_entry *) entry;
4067 eh->offset = 0;
4068 eh->iter = 0;
4069 }
4070
4071 return entry;
4072 }
4073
4074 /* Create an entry in a ppc64 ELF linker hash table. */
4075
4076 static struct bfd_hash_entry *
4077 link_hash_newfunc (struct bfd_hash_entry *entry,
4078 struct bfd_hash_table *table,
4079 const char *string)
4080 {
4081 /* Allocate the structure if it has not already been allocated by a
4082 subclass. */
4083 if (entry == NULL)
4084 {
4085 entry = bfd_hash_allocate (table, sizeof (struct ppc_link_hash_entry));
4086 if (entry == NULL)
4087 return entry;
4088 }
4089
4090 /* Call the allocation method of the superclass. */
4091 entry = _bfd_elf_link_hash_newfunc (entry, table, string);
4092 if (entry != NULL)
4093 {
4094 struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) entry;
4095
4096 memset (&eh->u.stub_cache, 0,
4097 (sizeof (struct ppc_link_hash_entry)
4098 - offsetof (struct ppc_link_hash_entry, u.stub_cache)));
4099
4100 /* When making function calls, old ABI code references function entry
4101 points (dot symbols), while new ABI code references the function
4102 descriptor symbol. We need to make any combination of reference and
4103 definition work together, without breaking archive linking.
4104
4105 For a defined function "foo" and an undefined call to "bar":
4106 An old object defines "foo" and ".foo", references ".bar" (possibly
4107 "bar" too).
4108 A new object defines "foo" and references "bar".
4109
4110 A new object thus has no problem with its undefined symbols being
4111 satisfied by definitions in an old object. On the other hand, the
4112 old object won't have ".bar" satisfied by a new object.
4113
4114 Keep a list of newly added dot-symbols. */
4115
4116 if (string[0] == '.')
4117 {
4118 struct ppc_link_hash_table *htab;
4119
4120 htab = (struct ppc_link_hash_table *) table;
4121 eh->u.next_dot_sym = htab->dot_syms;
4122 htab->dot_syms = eh;
4123 }
4124 }
4125
4126 return entry;
4127 }
4128
4129 struct tocsave_entry {
4130 asection *sec;
4131 bfd_vma offset;
4132 };
4133
4134 static hashval_t
4135 tocsave_htab_hash (const void *p)
4136 {
4137 const struct tocsave_entry *e = (const struct tocsave_entry *) p;
4138 return ((bfd_vma)(intptr_t) e->sec ^ e->offset) >> 3;
4139 }
4140
4141 static int
4142 tocsave_htab_eq (const void *p1, const void *p2)
4143 {
4144 const struct tocsave_entry *e1 = (const struct tocsave_entry *) p1;
4145 const struct tocsave_entry *e2 = (const struct tocsave_entry *) p2;
4146 return e1->sec == e2->sec && e1->offset == e2->offset;
4147 }
4148
4149 /* Create a ppc64 ELF linker hash table. */
4150
4151 static struct bfd_link_hash_table *
4152 ppc64_elf_link_hash_table_create (bfd *abfd)
4153 {
4154 struct ppc_link_hash_table *htab;
4155 bfd_size_type amt = sizeof (struct ppc_link_hash_table);
4156
4157 htab = bfd_zmalloc (amt);
4158 if (htab == NULL)
4159 return NULL;
4160
4161 if (!_bfd_elf_link_hash_table_init (&htab->elf, abfd, link_hash_newfunc,
4162 sizeof (struct ppc_link_hash_entry),
4163 PPC64_ELF_DATA))
4164 {
4165 free (htab);
4166 return NULL;
4167 }
4168
4169 /* Init the stub hash table too. */
4170 if (!bfd_hash_table_init (&htab->stub_hash_table, stub_hash_newfunc,
4171 sizeof (struct ppc_stub_hash_entry)))
4172 return NULL;
4173
4174 /* And the branch hash table. */
4175 if (!bfd_hash_table_init (&htab->branch_hash_table, branch_hash_newfunc,
4176 sizeof (struct ppc_branch_hash_entry)))
4177 return NULL;
4178
4179 htab->tocsave_htab = htab_try_create (1024,
4180 tocsave_htab_hash,
4181 tocsave_htab_eq,
4182 NULL);
4183 if (htab->tocsave_htab == NULL)
4184 return NULL;
4185
4186 /* Initializing two fields of the union is just cosmetic. We really
4187 only care about glist, but when compiled on a 32-bit host the
4188 bfd_vma fields are larger. Setting the bfd_vma to zero makes
4189 debugger inspection of these fields look nicer. */
4190 htab->elf.init_got_refcount.refcount = 0;
4191 htab->elf.init_got_refcount.glist = NULL;
4192 htab->elf.init_plt_refcount.refcount = 0;
4193 htab->elf.init_plt_refcount.glist = NULL;
4194 htab->elf.init_got_offset.offset = 0;
4195 htab->elf.init_got_offset.glist = NULL;
4196 htab->elf.init_plt_offset.offset = 0;
4197 htab->elf.init_plt_offset.glist = NULL;
4198
4199 return &htab->elf.root;
4200 }
4201
4202 /* Free the derived linker hash table. */
4203
4204 static void
4205 ppc64_elf_link_hash_table_free (struct bfd_link_hash_table *hash)
4206 {
4207 struct ppc_link_hash_table *htab = (struct ppc_link_hash_table *) hash;
4208
4209 bfd_hash_table_free (&htab->stub_hash_table);
4210 bfd_hash_table_free (&htab->branch_hash_table);
4211 if (htab->tocsave_htab)
4212 htab_delete (htab->tocsave_htab);
4213 _bfd_elf_link_hash_table_free (hash);
4214 }
4215
4216 /* Create sections for linker generated code. */
4217
4218 static bfd_boolean
4219 create_linkage_sections (bfd *dynobj, struct bfd_link_info *info)
4220 {
4221 struct ppc_link_hash_table *htab;
4222 flagword flags;
4223
4224 htab = ppc_hash_table (info);
4225
4226 /* Create .sfpr for code to save and restore fp regs. */
4227 flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY
4228 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4229 htab->sfpr = bfd_make_section_anyway_with_flags (dynobj, ".sfpr",
4230 flags);
4231 if (htab->sfpr == NULL
4232 || ! bfd_set_section_alignment (dynobj, htab->sfpr, 2))
4233 return FALSE;
4234
4235 /* Create .glink for lazy dynamic linking support. */
4236 htab->glink = bfd_make_section_anyway_with_flags (dynobj, ".glink",
4237 flags);
4238 if (htab->glink == NULL
4239 || ! bfd_set_section_alignment (dynobj, htab->glink, 3))
4240 return FALSE;
4241
4242 if (!info->no_ld_generated_unwind_info)
4243 {
4244 flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_HAS_CONTENTS
4245 | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4246 htab->glink_eh_frame = bfd_make_section_anyway_with_flags (dynobj,
4247 ".eh_frame",
4248 flags);
4249 if (htab->glink_eh_frame == NULL
4250 || !bfd_set_section_alignment (dynobj, htab->glink_eh_frame, 2))
4251 return FALSE;
4252 }
4253
4254 flags = SEC_ALLOC | SEC_LINKER_CREATED;
4255 htab->elf.iplt = bfd_make_section_anyway_with_flags (dynobj, ".iplt", flags);
4256 if (htab->elf.iplt == NULL
4257 || ! bfd_set_section_alignment (dynobj, htab->elf.iplt, 3))
4258 return FALSE;
4259
4260 flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4261 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4262 htab->elf.irelplt
4263 = bfd_make_section_anyway_with_flags (dynobj, ".rela.iplt", flags);
4264 if (htab->elf.irelplt == NULL
4265 || ! bfd_set_section_alignment (dynobj, htab->elf.irelplt, 3))
4266 return FALSE;
4267
4268 /* Create branch lookup table for plt_branch stubs. */
4269 flags = (SEC_ALLOC | SEC_LOAD
4270 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4271 htab->brlt = bfd_make_section_anyway_with_flags (dynobj, ".branch_lt",
4272 flags);
4273 if (htab->brlt == NULL
4274 || ! bfd_set_section_alignment (dynobj, htab->brlt, 3))
4275 return FALSE;
4276
4277 if (!info->shared)
4278 return TRUE;
4279
4280 flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4281 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4282 htab->relbrlt = bfd_make_section_anyway_with_flags (dynobj,
4283 ".rela.branch_lt",
4284 flags);
4285 if (htab->relbrlt == NULL
4286 || ! bfd_set_section_alignment (dynobj, htab->relbrlt, 3))
4287 return FALSE;
4288
4289 return TRUE;
4290 }
4291
4292 /* Satisfy the ELF linker by filling in some fields in our fake bfd. */
4293
4294 bfd_boolean
4295 ppc64_elf_init_stub_bfd (bfd *abfd, struct bfd_link_info *info)
4296 {
4297 struct ppc_link_hash_table *htab;
4298
4299 elf_elfheader (abfd)->e_ident[EI_CLASS] = ELFCLASS64;
4300
4301 /* Always hook our dynamic sections into the first bfd, which is the
4302 linker created stub bfd. This ensures that the GOT header is at
4303 the start of the output TOC section. */
4304 htab = ppc_hash_table (info);
4305 if (htab == NULL)
4306 return FALSE;
4307 htab->stub_bfd = abfd;
4308 htab->elf.dynobj = abfd;
4309
4310 if (info->relocatable)
4311 return TRUE;
4312
4313 return create_linkage_sections (htab->elf.dynobj, info);
4314 }
4315
4316 /* Build a name for an entry in the stub hash table. */
4317
4318 static char *
4319 ppc_stub_name (const asection *input_section,
4320 const asection *sym_sec,
4321 const struct ppc_link_hash_entry *h,
4322 const Elf_Internal_Rela *rel)
4323 {
4324 char *stub_name;
4325 ssize_t len;
4326
4327 /* rel->r_addend is actually 64 bit, but who uses more than +/- 2^31
4328 offsets from a sym as a branch target? In fact, we could
4329 probably assume the addend is always zero. */
4330 BFD_ASSERT (((int) rel->r_addend & 0xffffffff) == rel->r_addend);
4331
4332 if (h)
4333 {
4334 len = 8 + 1 + strlen (h->elf.root.root.string) + 1 + 8 + 1;
4335 stub_name = bfd_malloc (len);
4336 if (stub_name == NULL)
4337 return stub_name;
4338
4339 len = sprintf (stub_name, "%08x.%s+%x",
4340 input_section->id & 0xffffffff,
4341 h->elf.root.root.string,
4342 (int) rel->r_addend & 0xffffffff);
4343 }
4344 else
4345 {
4346 len = 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1;
4347 stub_name = bfd_malloc (len);
4348 if (stub_name == NULL)
4349 return stub_name;
4350
4351 len = sprintf (stub_name, "%08x.%x:%x+%x",
4352 input_section->id & 0xffffffff,
4353 sym_sec->id & 0xffffffff,
4354 (int) ELF64_R_SYM (rel->r_info) & 0xffffffff,
4355 (int) rel->r_addend & 0xffffffff);
4356 }
4357 if (len > 2 && stub_name[len - 2] == '+' && stub_name[len - 1] == '0')
4358 stub_name[len - 2] = 0;
4359 return stub_name;
4360 }
4361
4362 /* Look up an entry in the stub hash. Stub entries are cached because
4363 creating the stub name takes a bit of time. */
4364
4365 static struct ppc_stub_hash_entry *
4366 ppc_get_stub_entry (const asection *input_section,
4367 const asection *sym_sec,
4368 struct ppc_link_hash_entry *h,
4369 const Elf_Internal_Rela *rel,
4370 struct ppc_link_hash_table *htab)
4371 {
4372 struct ppc_stub_hash_entry *stub_entry;
4373 const asection *id_sec;
4374
4375 /* If this input section is part of a group of sections sharing one
4376 stub section, then use the id of the first section in the group.
4377 Stub names need to include a section id, as there may well be
4378 more than one stub used to reach say, printf, and we need to
4379 distinguish between them. */
4380 id_sec = htab->stub_group[input_section->id].link_sec;
4381
4382 if (h != NULL && h->u.stub_cache != NULL
4383 && h->u.stub_cache->h == h
4384 && h->u.stub_cache->id_sec == id_sec)
4385 {
4386 stub_entry = h->u.stub_cache;
4387 }
4388 else
4389 {
4390 char *stub_name;
4391
4392 stub_name = ppc_stub_name (id_sec, sym_sec, h, rel);
4393 if (stub_name == NULL)
4394 return NULL;
4395
4396 stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
4397 stub_name, FALSE, FALSE);
4398 if (h != NULL)
4399 h->u.stub_cache = stub_entry;
4400
4401 free (stub_name);
4402 }
4403
4404 return stub_entry;
4405 }
4406
4407 /* Add a new stub entry to the stub hash. Not all fields of the new
4408 stub entry are initialised. */
4409
4410 static struct ppc_stub_hash_entry *
4411 ppc_add_stub (const char *stub_name,
4412 asection *section,
4413 struct bfd_link_info *info)
4414 {
4415 struct ppc_link_hash_table *htab = ppc_hash_table (info);
4416 asection *link_sec;
4417 asection *stub_sec;
4418 struct ppc_stub_hash_entry *stub_entry;
4419
4420 link_sec = htab->stub_group[section->id].link_sec;
4421 stub_sec = htab->stub_group[section->id].stub_sec;
4422 if (stub_sec == NULL)
4423 {
4424 stub_sec = htab->stub_group[link_sec->id].stub_sec;
4425 if (stub_sec == NULL)
4426 {
4427 size_t namelen;
4428 bfd_size_type len;
4429 char *s_name;
4430
4431 namelen = strlen (link_sec->name);
4432 len = namelen + sizeof (STUB_SUFFIX);
4433 s_name = bfd_alloc (htab->stub_bfd, len);
4434 if (s_name == NULL)
4435 return NULL;
4436
4437 memcpy (s_name, link_sec->name, namelen);
4438 memcpy (s_name + namelen, STUB_SUFFIX, sizeof (STUB_SUFFIX));
4439 stub_sec = (*htab->add_stub_section) (s_name, link_sec);
4440 if (stub_sec == NULL)
4441 return NULL;
4442 htab->stub_group[link_sec->id].stub_sec = stub_sec;
4443 }
4444 htab->stub_group[section->id].stub_sec = stub_sec;
4445 }
4446
4447 /* Enter this entry into the linker stub hash table. */
4448 stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table, stub_name,
4449 TRUE, FALSE);
4450 if (stub_entry == NULL)
4451 {
4452 info->callbacks->einfo (_("%P: %B: cannot create stub entry %s\n"),
4453 section->owner, stub_name);
4454 return NULL;
4455 }
4456
4457 stub_entry->stub_sec = stub_sec;
4458 stub_entry->stub_offset = 0;
4459 stub_entry->id_sec = link_sec;
4460 return stub_entry;
4461 }
4462
4463 /* Create .got and .rela.got sections in ABFD, and .got in dynobj if
4464 not already done. */
4465
4466 static bfd_boolean
4467 create_got_section (bfd *abfd, struct bfd_link_info *info)
4468 {
4469 asection *got, *relgot;
4470 flagword flags;
4471 struct ppc_link_hash_table *htab = ppc_hash_table (info);
4472
4473 if (!is_ppc64_elf (abfd))
4474 return FALSE;
4475 if (htab == NULL)
4476 return FALSE;
4477
4478 if (!htab->elf.sgot
4479 && !_bfd_elf_create_got_section (htab->elf.dynobj, info))
4480 return FALSE;
4481
4482 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
4483 | SEC_LINKER_CREATED);
4484
4485 got = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
4486 if (!got
4487 || !bfd_set_section_alignment (abfd, got, 3))
4488 return FALSE;
4489
4490 relgot = bfd_make_section_anyway_with_flags (abfd, ".rela.got",
4491 flags | SEC_READONLY);
4492 if (!relgot
4493 || ! bfd_set_section_alignment (abfd, relgot, 3))
4494 return FALSE;
4495
4496 ppc64_elf_tdata (abfd)->got = got;
4497 ppc64_elf_tdata (abfd)->relgot = relgot;
4498 return TRUE;
4499 }
4500
4501 /* Create the dynamic sections, and set up shortcuts. */
4502
4503 static bfd_boolean
4504 ppc64_elf_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
4505 {
4506 struct ppc_link_hash_table *htab;
4507
4508 if (!_bfd_elf_create_dynamic_sections (dynobj, info))
4509 return FALSE;
4510
4511 htab = ppc_hash_table (info);
4512 if (htab == NULL)
4513 return FALSE;
4514
4515 htab->dynbss = bfd_get_linker_section (dynobj, ".dynbss");
4516 if (!info->shared)
4517 htab->relbss = bfd_get_linker_section (dynobj, ".rela.bss");
4518
4519 if (!htab->elf.sgot || !htab->elf.splt || !htab->elf.srelplt || !htab->dynbss
4520 || (!info->shared && !htab->relbss))
4521 abort ();
4522
4523 return TRUE;
4524 }
4525
4526 /* Follow indirect and warning symbol links. */
4527
4528 static inline struct bfd_link_hash_entry *
4529 follow_link (struct bfd_link_hash_entry *h)
4530 {
4531 while (h->type == bfd_link_hash_indirect
4532 || h->type == bfd_link_hash_warning)
4533 h = h->u.i.link;
4534 return h;
4535 }
4536
4537 static inline struct elf_link_hash_entry *
4538 elf_follow_link (struct elf_link_hash_entry *h)
4539 {
4540 return (struct elf_link_hash_entry *) follow_link (&h->root);
4541 }
4542
4543 static inline struct ppc_link_hash_entry *
4544 ppc_follow_link (struct ppc_link_hash_entry *h)
4545 {
4546 return (struct ppc_link_hash_entry *) follow_link (&h->elf.root);
4547 }
4548
4549 /* Merge PLT info on FROM with that on TO. */
4550
4551 static void
4552 move_plt_plist (struct ppc_link_hash_entry *from,
4553 struct ppc_link_hash_entry *to)
4554 {
4555 if (from->elf.plt.plist != NULL)
4556 {
4557 if (to->elf.plt.plist != NULL)
4558 {
4559 struct plt_entry **entp;
4560 struct plt_entry *ent;
4561
4562 for (entp = &from->elf.plt.plist; (ent = *entp) != NULL; )
4563 {
4564 struct plt_entry *dent;
4565
4566 for (dent = to->elf.plt.plist; dent != NULL; dent = dent->next)
4567 if (dent->addend == ent->addend)
4568 {
4569 dent->plt.refcount += ent->plt.refcount;
4570 *entp = ent->next;
4571 break;
4572 }
4573 if (dent == NULL)
4574 entp = &ent->next;
4575 }
4576 *entp = to->elf.plt.plist;
4577 }
4578
4579 to->elf.plt.plist = from->elf.plt.plist;
4580 from->elf.plt.plist = NULL;
4581 }
4582 }
4583
4584 /* Copy the extra info we tack onto an elf_link_hash_entry. */
4585
4586 static void
4587 ppc64_elf_copy_indirect_symbol (struct bfd_link_info *info,
4588 struct elf_link_hash_entry *dir,
4589 struct elf_link_hash_entry *ind)
4590 {
4591 struct ppc_link_hash_entry *edir, *eind;
4592
4593 edir = (struct ppc_link_hash_entry *) dir;
4594 eind = (struct ppc_link_hash_entry *) ind;
4595
4596 edir->is_func |= eind->is_func;
4597 edir->is_func_descriptor |= eind->is_func_descriptor;
4598 edir->tls_mask |= eind->tls_mask;
4599 if (eind->oh != NULL)
4600 edir->oh = ppc_follow_link (eind->oh);
4601
4602 /* If called to transfer flags for a weakdef during processing
4603 of elf_adjust_dynamic_symbol, don't copy NON_GOT_REF.
4604 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
4605 if (!(ELIMINATE_COPY_RELOCS
4606 && eind->elf.root.type != bfd_link_hash_indirect
4607 && edir->elf.dynamic_adjusted))
4608 edir->elf.non_got_ref |= eind->elf.non_got_ref;
4609
4610 edir->elf.ref_dynamic |= eind->elf.ref_dynamic;
4611 edir->elf.ref_regular |= eind->elf.ref_regular;
4612 edir->elf.ref_regular_nonweak |= eind->elf.ref_regular_nonweak;
4613 edir->elf.needs_plt |= eind->elf.needs_plt;
4614 edir->elf.pointer_equality_needed |= eind->elf.pointer_equality_needed;
4615
4616 /* Copy over any dynamic relocs we may have on the indirect sym. */
4617 if (eind->dyn_relocs != NULL)
4618 {
4619 if (edir->dyn_relocs != NULL)
4620 {
4621 struct elf_dyn_relocs **pp;
4622 struct elf_dyn_relocs *p;
4623
4624 /* Add reloc counts against the indirect sym to the direct sym
4625 list. Merge any entries against the same section. */
4626 for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
4627 {
4628 struct elf_dyn_relocs *q;
4629
4630 for (q = edir->dyn_relocs; q != NULL; q = q->next)
4631 if (q->sec == p->sec)
4632 {
4633 q->pc_count += p->pc_count;
4634 q->count += p->count;
4635 *pp = p->next;
4636 break;
4637 }
4638 if (q == NULL)
4639 pp = &p->next;
4640 }
4641 *pp = edir->dyn_relocs;
4642 }
4643
4644 edir->dyn_relocs = eind->dyn_relocs;
4645 eind->dyn_relocs = NULL;
4646 }
4647
4648 /* If we were called to copy over info for a weak sym, that's all.
4649 You might think dyn_relocs need not be copied over; After all,
4650 both syms will be dynamic or both non-dynamic so we're just
4651 moving reloc accounting around. However, ELIMINATE_COPY_RELOCS
4652 code in ppc64_elf_adjust_dynamic_symbol needs to check for
4653 dyn_relocs in read-only sections, and it does so on what is the
4654 DIR sym here. */
4655 if (eind->elf.root.type != bfd_link_hash_indirect)
4656 return;
4657
4658 /* Copy over got entries that we may have already seen to the
4659 symbol which just became indirect. */
4660 if (eind->elf.got.glist != NULL)
4661 {
4662 if (edir->elf.got.glist != NULL)
4663 {
4664 struct got_entry **entp;
4665 struct got_entry *ent;
4666
4667 for (entp = &eind->elf.got.glist; (ent = *entp) != NULL; )
4668 {
4669 struct got_entry *dent;
4670
4671 for (dent = edir->elf.got.glist; dent != NULL; dent = dent->next)
4672 if (dent->addend == ent->addend
4673 && dent->owner == ent->owner
4674 && dent->tls_type == ent->tls_type)
4675 {
4676 dent->got.refcount += ent->got.refcount;
4677 *entp = ent->next;
4678 break;
4679 }
4680 if (dent == NULL)
4681 entp = &ent->next;
4682 }
4683 *entp = edir->elf.got.glist;
4684 }
4685
4686 edir->elf.got.glist = eind->elf.got.glist;
4687 eind->elf.got.glist = NULL;
4688 }
4689
4690 /* And plt entries. */
4691 move_plt_plist (eind, edir);
4692
4693 if (eind->elf.dynindx != -1)
4694 {
4695 if (edir->elf.dynindx != -1)
4696 _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
4697 edir->elf.dynstr_index);
4698 edir->elf.dynindx = eind->elf.dynindx;
4699 edir->elf.dynstr_index = eind->elf.dynstr_index;
4700 eind->elf.dynindx = -1;
4701 eind->elf.dynstr_index = 0;
4702 }
4703 }
4704
4705 /* Find the function descriptor hash entry from the given function code
4706 hash entry FH. Link the entries via their OH fields. */
4707
4708 static struct ppc_link_hash_entry *
4709 lookup_fdh (struct ppc_link_hash_entry *fh, struct ppc_link_hash_table *htab)
4710 {
4711 struct ppc_link_hash_entry *fdh = fh->oh;
4712
4713 if (fdh == NULL)
4714 {
4715 const char *fd_name = fh->elf.root.root.string + 1;
4716
4717 fdh = (struct ppc_link_hash_entry *)
4718 elf_link_hash_lookup (&htab->elf, fd_name, FALSE, FALSE, FALSE);
4719 if (fdh == NULL)
4720 return fdh;
4721
4722 fdh->is_func_descriptor = 1;
4723 fdh->oh = fh;
4724 fh->is_func = 1;
4725 fh->oh = fdh;
4726 }
4727
4728 return ppc_follow_link (fdh);
4729 }
4730
4731 /* Make a fake function descriptor sym for the code sym FH. */
4732
4733 static struct ppc_link_hash_entry *
4734 make_fdh (struct bfd_link_info *info,
4735 struct ppc_link_hash_entry *fh)
4736 {
4737 bfd *abfd;
4738 asymbol *newsym;
4739 struct bfd_link_hash_entry *bh;
4740 struct ppc_link_hash_entry *fdh;
4741
4742 abfd = fh->elf.root.u.undef.abfd;
4743 newsym = bfd_make_empty_symbol (abfd);
4744 newsym->name = fh->elf.root.root.string + 1;
4745 newsym->section = bfd_und_section_ptr;
4746 newsym->value = 0;
4747 newsym->flags = BSF_WEAK;
4748
4749 bh = NULL;
4750 if (!_bfd_generic_link_add_one_symbol (info, abfd, newsym->name,
4751 newsym->flags, newsym->section,
4752 newsym->value, NULL, FALSE, FALSE,
4753 &bh))
4754 return NULL;
4755
4756 fdh = (struct ppc_link_hash_entry *) bh;
4757 fdh->elf.non_elf = 0;
4758 fdh->fake = 1;
4759 fdh->is_func_descriptor = 1;
4760 fdh->oh = fh;
4761 fh->is_func = 1;
4762 fh->oh = fdh;
4763 return fdh;
4764 }
4765
4766 /* Fix function descriptor symbols defined in .opd sections to be
4767 function type. */
4768
4769 static bfd_boolean
4770 ppc64_elf_add_symbol_hook (bfd *ibfd,
4771 struct bfd_link_info *info,
4772 Elf_Internal_Sym *isym,
4773 const char **name,
4774 flagword *flags ATTRIBUTE_UNUSED,
4775 asection **sec,
4776 bfd_vma *value ATTRIBUTE_UNUSED)
4777 {
4778 if ((ibfd->flags & DYNAMIC) == 0
4779 && ELF_ST_BIND (isym->st_info) == STB_GNU_UNIQUE)
4780 elf_tdata (info->output_bfd)->has_gnu_symbols = TRUE;
4781
4782 if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
4783 {
4784 if ((ibfd->flags & DYNAMIC) == 0)
4785 elf_tdata (info->output_bfd)->has_gnu_symbols = TRUE;
4786 }
4787 else if (ELF_ST_TYPE (isym->st_info) == STT_FUNC)
4788 ;
4789 else if (*sec != NULL
4790 && strcmp ((*sec)->name, ".opd") == 0)
4791 isym->st_info = ELF_ST_INFO (ELF_ST_BIND (isym->st_info), STT_FUNC);
4792
4793 if ((STO_PPC64_LOCAL_MASK & isym->st_other) != 0)
4794 {
4795 if (abiversion (ibfd) == 0)
4796 set_abiversion (ibfd, 2);
4797 else if (abiversion (ibfd) == 1)
4798 {
4799 info->callbacks->einfo (_("%P: symbol '%s' has invalid st_other"
4800 " for ABI version 1\n"), name);
4801 bfd_set_error (bfd_error_bad_value);
4802 return FALSE;
4803 }
4804 }
4805
4806 return TRUE;
4807 }
4808
4809 /* Merge non-visibility st_other attributes: local entry point. */
4810
4811 static void
4812 ppc64_elf_merge_symbol_attribute (struct elf_link_hash_entry *h,
4813 const Elf_Internal_Sym *isym,
4814 bfd_boolean definition,
4815 bfd_boolean dynamic)
4816 {
4817 if (definition && !dynamic)
4818 h->other = ((isym->st_other & ~ELF_ST_VISIBILITY (-1))
4819 | ELF_ST_VISIBILITY (h->other));
4820 }
4821
4822 /* This function makes an old ABI object reference to ".bar" cause the
4823 inclusion of a new ABI object archive that defines "bar".
4824 NAME is a symbol defined in an archive. Return a symbol in the hash
4825 table that might be satisfied by the archive symbols. */
4826
4827 static struct elf_link_hash_entry *
4828 ppc64_elf_archive_symbol_lookup (bfd *abfd,
4829 struct bfd_link_info *info,
4830 const char *name)
4831 {
4832 struct elf_link_hash_entry *h;
4833 char *dot_name;
4834 size_t len;
4835
4836 h = _bfd_elf_archive_symbol_lookup (abfd, info, name);
4837 if (h != NULL
4838 /* Don't return this sym if it is a fake function descriptor
4839 created by add_symbol_adjust. */
4840 && !(h->root.type == bfd_link_hash_undefweak
4841 && ((struct ppc_link_hash_entry *) h)->fake))
4842 return h;
4843
4844 if (name[0] == '.')
4845 return h;
4846
4847 len = strlen (name);
4848 dot_name = bfd_alloc (abfd, len + 2);
4849 if (dot_name == NULL)
4850 return (struct elf_link_hash_entry *) 0 - 1;
4851 dot_name[0] = '.';
4852 memcpy (dot_name + 1, name, len + 1);
4853 h = _bfd_elf_archive_symbol_lookup (abfd, info, dot_name);
4854 bfd_release (abfd, dot_name);
4855 return h;
4856 }
4857
4858 /* This function satisfies all old ABI object references to ".bar" if a
4859 new ABI object defines "bar". Well, at least, undefined dot symbols
4860 are made weak. This stops later archive searches from including an
4861 object if we already have a function descriptor definition. It also
4862 prevents the linker complaining about undefined symbols.
4863 We also check and correct mismatched symbol visibility here. The
4864 most restrictive visibility of the function descriptor and the
4865 function entry symbol is used. */
4866
4867 static bfd_boolean
4868 add_symbol_adjust (struct ppc_link_hash_entry *eh, struct bfd_link_info *info)
4869 {
4870 struct ppc_link_hash_table *htab;
4871 struct ppc_link_hash_entry *fdh;
4872
4873 if (eh->elf.root.type == bfd_link_hash_indirect)
4874 return TRUE;
4875
4876 if (eh->elf.root.type == bfd_link_hash_warning)
4877 eh = (struct ppc_link_hash_entry *) eh->elf.root.u.i.link;
4878
4879 if (eh->elf.root.root.string[0] != '.')
4880 abort ();
4881
4882 htab = ppc_hash_table (info);
4883 if (htab == NULL)
4884 return FALSE;
4885
4886 fdh = lookup_fdh (eh, htab);
4887 if (fdh == NULL)
4888 {
4889 if (!info->relocatable
4890 && (eh->elf.root.type == bfd_link_hash_undefined
4891 || eh->elf.root.type == bfd_link_hash_undefweak)
4892 && eh->elf.ref_regular)
4893 {
4894 /* Make an undefweak function descriptor sym, which is enough to
4895 pull in an --as-needed shared lib, but won't cause link
4896 errors. Archives are handled elsewhere. */
4897 fdh = make_fdh (info, eh);
4898 if (fdh == NULL)
4899 return FALSE;
4900 fdh->elf.ref_regular = 1;
4901 }
4902 }
4903 else
4904 {
4905 unsigned entry_vis = ELF_ST_VISIBILITY (eh->elf.other) - 1;
4906 unsigned descr_vis = ELF_ST_VISIBILITY (fdh->elf.other) - 1;
4907 if (entry_vis < descr_vis)
4908 fdh->elf.other += entry_vis - descr_vis;
4909 else if (entry_vis > descr_vis)
4910 eh->elf.other += descr_vis - entry_vis;
4911
4912 if ((fdh->elf.root.type == bfd_link_hash_defined
4913 || fdh->elf.root.type == bfd_link_hash_defweak)
4914 && eh->elf.root.type == bfd_link_hash_undefined)
4915 {
4916 eh->elf.root.type = bfd_link_hash_undefweak;
4917 eh->was_undefined = 1;
4918 htab->twiddled_syms = 1;
4919 }
4920 }
4921
4922 return TRUE;
4923 }
4924
4925 /* Process list of dot-symbols we made in link_hash_newfunc. */
4926
4927 static bfd_boolean
4928 ppc64_elf_process_dot_syms (bfd *ibfd, struct bfd_link_info *info)
4929 {
4930 struct ppc_link_hash_table *htab;
4931 struct ppc_link_hash_entry **p, *eh;
4932
4933 if (!is_ppc64_elf (info->output_bfd))
4934 return TRUE;
4935 htab = ppc_hash_table (info);
4936 if (htab == NULL)
4937 return FALSE;
4938
4939 if (is_ppc64_elf (ibfd))
4940 {
4941 p = &htab->dot_syms;
4942 while ((eh = *p) != NULL)
4943 {
4944 *p = NULL;
4945 if (&eh->elf == htab->elf.hgot)
4946 ;
4947 else if (htab->elf.hgot == NULL
4948 && strcmp (eh->elf.root.root.string, ".TOC.") == 0)
4949 htab->elf.hgot = &eh->elf;
4950 else if (!add_symbol_adjust (eh, info))
4951 return FALSE;
4952 p = &eh->u.next_dot_sym;
4953 }
4954 }
4955
4956 /* Clear the list for non-ppc64 input files. */
4957 p = &htab->dot_syms;
4958 while ((eh = *p) != NULL)
4959 {
4960 *p = NULL;
4961 p = &eh->u.next_dot_sym;
4962 }
4963
4964 /* We need to fix the undefs list for any syms we have twiddled to
4965 undef_weak. */
4966 if (htab->twiddled_syms)
4967 {
4968 bfd_link_repair_undef_list (&htab->elf.root);
4969 htab->twiddled_syms = 0;
4970 }
4971 return TRUE;
4972 }
4973
4974 /* Undo hash table changes when an --as-needed input file is determined
4975 not to be needed. */
4976
4977 static bfd_boolean
4978 ppc64_elf_notice_as_needed (bfd *ibfd,
4979 struct bfd_link_info *info,
4980 enum notice_asneeded_action act)
4981 {
4982 if (act == notice_not_needed)
4983 {
4984 struct ppc_link_hash_table *htab = ppc_hash_table (info);
4985
4986 if (htab == NULL)
4987 return FALSE;
4988
4989 htab->dot_syms = NULL;
4990 }
4991 return _bfd_elf_notice_as_needed (ibfd, info, act);
4992 }
4993
4994 /* If --just-symbols against a final linked binary, then assume we need
4995 toc adjusting stubs when calling functions defined there. */
4996
4997 static void
4998 ppc64_elf_link_just_syms (asection *sec, struct bfd_link_info *info)
4999 {
5000 if ((sec->flags & SEC_CODE) != 0
5001 && (sec->owner->flags & (EXEC_P | DYNAMIC)) != 0
5002 && is_ppc64_elf (sec->owner))
5003 {
5004 if (abiversion (sec->owner) >= 2
5005 || bfd_get_section_by_name (sec->owner, ".opd") != NULL)
5006 sec->has_toc_reloc = 1;
5007 }
5008 _bfd_elf_link_just_syms (sec, info);
5009 }
5010
5011 static struct plt_entry **
5012 update_local_sym_info (bfd *abfd, Elf_Internal_Shdr *symtab_hdr,
5013 unsigned long r_symndx, bfd_vma r_addend, int tls_type)
5014 {
5015 struct got_entry **local_got_ents = elf_local_got_ents (abfd);
5016 struct plt_entry **local_plt;
5017 unsigned char *local_got_tls_masks;
5018
5019 if (local_got_ents == NULL)
5020 {
5021 bfd_size_type size = symtab_hdr->sh_info;
5022
5023 size *= (sizeof (*local_got_ents)
5024 + sizeof (*local_plt)
5025 + sizeof (*local_got_tls_masks));
5026 local_got_ents = bfd_zalloc (abfd, size);
5027 if (local_got_ents == NULL)
5028 return NULL;
5029 elf_local_got_ents (abfd) = local_got_ents;
5030 }
5031
5032 if ((tls_type & (PLT_IFUNC | TLS_EXPLICIT)) == 0)
5033 {
5034 struct got_entry *ent;
5035
5036 for (ent = local_got_ents[r_symndx]; ent != NULL; ent = ent->next)
5037 if (ent->addend == r_addend
5038 && ent->owner == abfd
5039 && ent->tls_type == tls_type)
5040 break;
5041 if (ent == NULL)
5042 {
5043 bfd_size_type amt = sizeof (*ent);
5044 ent = bfd_alloc (abfd, amt);
5045 if (ent == NULL)
5046 return FALSE;
5047 ent->next = local_got_ents[r_symndx];
5048 ent->addend = r_addend;
5049 ent->owner = abfd;
5050 ent->tls_type = tls_type;
5051 ent->is_indirect = FALSE;
5052 ent->got.refcount = 0;
5053 local_got_ents[r_symndx] = ent;
5054 }
5055 ent->got.refcount += 1;
5056 }
5057
5058 local_plt = (struct plt_entry **) (local_got_ents + symtab_hdr->sh_info);
5059 local_got_tls_masks = (unsigned char *) (local_plt + symtab_hdr->sh_info);
5060 local_got_tls_masks[r_symndx] |= tls_type;
5061
5062 return local_plt + r_symndx;
5063 }
5064
5065 static bfd_boolean
5066 update_plt_info (bfd *abfd, struct plt_entry **plist, bfd_vma addend)
5067 {
5068 struct plt_entry *ent;
5069
5070 for (ent = *plist; ent != NULL; ent = ent->next)
5071 if (ent->addend == addend)
5072 break;
5073 if (ent == NULL)
5074 {
5075 bfd_size_type amt = sizeof (*ent);
5076 ent = bfd_alloc (abfd, amt);
5077 if (ent == NULL)
5078 return FALSE;
5079 ent->next = *plist;
5080 ent->addend = addend;
5081 ent->plt.refcount = 0;
5082 *plist = ent;
5083 }
5084 ent->plt.refcount += 1;
5085 return TRUE;
5086 }
5087
5088 static bfd_boolean
5089 is_branch_reloc (enum elf_ppc64_reloc_type r_type)
5090 {
5091 return (r_type == R_PPC64_REL24
5092 || r_type == R_PPC64_REL14
5093 || r_type == R_PPC64_REL14_BRTAKEN
5094 || r_type == R_PPC64_REL14_BRNTAKEN
5095 || r_type == R_PPC64_ADDR24
5096 || r_type == R_PPC64_ADDR14
5097 || r_type == R_PPC64_ADDR14_BRTAKEN
5098 || r_type == R_PPC64_ADDR14_BRNTAKEN);
5099 }
5100
5101 /* Look through the relocs for a section during the first phase, and
5102 calculate needed space in the global offset table, procedure
5103 linkage table, and dynamic reloc sections. */
5104
5105 static bfd_boolean
5106 ppc64_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
5107 asection *sec, const Elf_Internal_Rela *relocs)
5108 {
5109 struct ppc_link_hash_table *htab;
5110 Elf_Internal_Shdr *symtab_hdr;
5111 struct elf_link_hash_entry **sym_hashes;
5112 const Elf_Internal_Rela *rel;
5113 const Elf_Internal_Rela *rel_end;
5114 asection *sreloc;
5115 asection **opd_sym_map;
5116 struct elf_link_hash_entry *tga, *dottga;
5117
5118 if (info->relocatable)
5119 return TRUE;
5120
5121 /* Don't do anything special with non-loaded, non-alloced sections.
5122 In particular, any relocs in such sections should not affect GOT
5123 and PLT reference counting (ie. we don't allow them to create GOT
5124 or PLT entries), there's no possibility or desire to optimize TLS
5125 relocs, and there's not much point in propagating relocs to shared
5126 libs that the dynamic linker won't relocate. */
5127 if ((sec->flags & SEC_ALLOC) == 0)
5128 return TRUE;
5129
5130 BFD_ASSERT (is_ppc64_elf (abfd));
5131
5132 htab = ppc_hash_table (info);
5133 if (htab == NULL)
5134 return FALSE;
5135
5136 tga = elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
5137 FALSE, FALSE, TRUE);
5138 dottga = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
5139 FALSE, FALSE, TRUE);
5140 symtab_hdr = &elf_symtab_hdr (abfd);
5141 sym_hashes = elf_sym_hashes (abfd);
5142 sreloc = NULL;
5143 opd_sym_map = NULL;
5144 if (strcmp (sec->name, ".opd") == 0)
5145 {
5146 /* Garbage collection needs some extra help with .opd sections.
5147 We don't want to necessarily keep everything referenced by
5148 relocs in .opd, as that would keep all functions. Instead,
5149 if we reference an .opd symbol (a function descriptor), we
5150 want to keep the function code symbol's section. This is
5151 easy for global symbols, but for local syms we need to keep
5152 information about the associated function section. */
5153 bfd_size_type amt;
5154
5155 if (abiversion (abfd) == 0)
5156 set_abiversion (abfd, 1);
5157 else if (abiversion (abfd) == 2)
5158 {
5159 info->callbacks->einfo (_("%P: .opd not allowed in ABI version %d\n"),
5160 abiversion (abfd));
5161 bfd_set_error (bfd_error_bad_value);
5162 return FALSE;
5163 }
5164 amt = sec->size * sizeof (*opd_sym_map) / 8;
5165 opd_sym_map = bfd_zalloc (abfd, amt);
5166 if (opd_sym_map == NULL)
5167 return FALSE;
5168 ppc64_elf_section_data (sec)->u.opd.func_sec = opd_sym_map;
5169 BFD_ASSERT (ppc64_elf_section_data (sec)->sec_type == sec_normal);
5170 ppc64_elf_section_data (sec)->sec_type = sec_opd;
5171 }
5172
5173 rel_end = relocs + sec->reloc_count;
5174 for (rel = relocs; rel < rel_end; rel++)
5175 {
5176 unsigned long r_symndx;
5177 struct elf_link_hash_entry *h;
5178 enum elf_ppc64_reloc_type r_type;
5179 int tls_type;
5180 struct _ppc64_elf_section_data *ppc64_sec;
5181 struct plt_entry **ifunc;
5182
5183 r_symndx = ELF64_R_SYM (rel->r_info);
5184 if (r_symndx < symtab_hdr->sh_info)
5185 h = NULL;
5186 else
5187 {
5188 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
5189 h = elf_follow_link (h);
5190
5191 /* PR15323, ref flags aren't set for references in the same
5192 object. */
5193 h->root.non_ir_ref = 1;
5194
5195 if (h == htab->elf.hgot)
5196 sec->has_toc_reloc = 1;
5197 }
5198
5199 tls_type = 0;
5200 ifunc = NULL;
5201 if (h != NULL)
5202 {
5203 if (h->type == STT_GNU_IFUNC)
5204 {
5205 h->needs_plt = 1;
5206 ifunc = &h->plt.plist;
5207 }
5208 }
5209 else
5210 {
5211 Elf_Internal_Sym *isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5212 abfd, r_symndx);
5213 if (isym == NULL)
5214 return FALSE;
5215
5216 if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
5217 {
5218 ifunc = update_local_sym_info (abfd, symtab_hdr, r_symndx,
5219 rel->r_addend, PLT_IFUNC);
5220 if (ifunc == NULL)
5221 return FALSE;
5222 }
5223 }
5224 r_type = ELF64_R_TYPE (rel->r_info);
5225 if (is_branch_reloc (r_type))
5226 {
5227 if (h != NULL && (h == tga || h == dottga))
5228 {
5229 if (rel != relocs
5230 && (ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSGD
5231 || ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSLD))
5232 /* We have a new-style __tls_get_addr call with a marker
5233 reloc. */
5234 ;
5235 else
5236 /* Mark this section as having an old-style call. */
5237 sec->has_tls_get_addr_call = 1;
5238 }
5239
5240 /* STT_GNU_IFUNC symbols must have a PLT entry. */
5241 if (ifunc != NULL
5242 && !update_plt_info (abfd, ifunc, rel->r_addend))
5243 return FALSE;
5244 }
5245
5246 switch (r_type)
5247 {
5248 case R_PPC64_TLSGD:
5249 case R_PPC64_TLSLD:
5250 /* These special tls relocs tie a call to __tls_get_addr with
5251 its parameter symbol. */
5252 break;
5253
5254 case R_PPC64_GOT_TLSLD16:
5255 case R_PPC64_GOT_TLSLD16_LO:
5256 case R_PPC64_GOT_TLSLD16_HI:
5257 case R_PPC64_GOT_TLSLD16_HA:
5258 tls_type = TLS_TLS | TLS_LD;
5259 goto dogottls;
5260
5261 case R_PPC64_GOT_TLSGD16:
5262 case R_PPC64_GOT_TLSGD16_LO:
5263 case R_PPC64_GOT_TLSGD16_HI:
5264 case R_PPC64_GOT_TLSGD16_HA:
5265 tls_type = TLS_TLS | TLS_GD;
5266 goto dogottls;
5267
5268 case R_PPC64_GOT_TPREL16_DS:
5269 case R_PPC64_GOT_TPREL16_LO_DS:
5270 case R_PPC64_GOT_TPREL16_HI:
5271 case R_PPC64_GOT_TPREL16_HA:
5272 if (!info->executable)
5273 info->flags |= DF_STATIC_TLS;
5274 tls_type = TLS_TLS | TLS_TPREL;
5275 goto dogottls;
5276
5277 case R_PPC64_GOT_DTPREL16_DS:
5278 case R_PPC64_GOT_DTPREL16_LO_DS:
5279 case R_PPC64_GOT_DTPREL16_HI:
5280 case R_PPC64_GOT_DTPREL16_HA:
5281 tls_type = TLS_TLS | TLS_DTPREL;
5282 dogottls:
5283 sec->has_tls_reloc = 1;
5284 /* Fall thru */
5285
5286 case R_PPC64_GOT16:
5287 case R_PPC64_GOT16_DS:
5288 case R_PPC64_GOT16_HA:
5289 case R_PPC64_GOT16_HI:
5290 case R_PPC64_GOT16_LO:
5291 case R_PPC64_GOT16_LO_DS:
5292 /* This symbol requires a global offset table entry. */
5293 sec->has_toc_reloc = 1;
5294 if (r_type == R_PPC64_GOT_TLSLD16
5295 || r_type == R_PPC64_GOT_TLSGD16
5296 || r_type == R_PPC64_GOT_TPREL16_DS
5297 || r_type == R_PPC64_GOT_DTPREL16_DS
5298 || r_type == R_PPC64_GOT16
5299 || r_type == R_PPC64_GOT16_DS)
5300 {
5301 htab->do_multi_toc = 1;
5302 ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5303 }
5304
5305 if (ppc64_elf_tdata (abfd)->got == NULL
5306 && !create_got_section (abfd, info))
5307 return FALSE;
5308
5309 if (h != NULL)
5310 {
5311 struct ppc_link_hash_entry *eh;
5312 struct got_entry *ent;
5313
5314 eh = (struct ppc_link_hash_entry *) h;
5315 for (ent = eh->elf.got.glist; ent != NULL; ent = ent->next)
5316 if (ent->addend == rel->r_addend
5317 && ent->owner == abfd
5318 && ent->tls_type == tls_type)
5319 break;
5320 if (ent == NULL)
5321 {
5322 bfd_size_type amt = sizeof (*ent);
5323 ent = bfd_alloc (abfd, amt);
5324 if (ent == NULL)
5325 return FALSE;
5326 ent->next = eh->elf.got.glist;
5327 ent->addend = rel->r_addend;
5328 ent->owner = abfd;
5329 ent->tls_type = tls_type;
5330 ent->is_indirect = FALSE;
5331 ent->got.refcount = 0;
5332 eh->elf.got.glist = ent;
5333 }
5334 ent->got.refcount += 1;
5335 eh->tls_mask |= tls_type;
5336 }
5337 else
5338 /* This is a global offset table entry for a local symbol. */
5339 if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5340 rel->r_addend, tls_type))
5341 return FALSE;
5342
5343 /* We may also need a plt entry if the symbol turns out to be
5344 an ifunc. */
5345 if (h != NULL && !info->shared && abiversion (abfd) == 2)
5346 {
5347 if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5348 return FALSE;
5349 }
5350 break;
5351
5352 case R_PPC64_PLT16_HA:
5353 case R_PPC64_PLT16_HI:
5354 case R_PPC64_PLT16_LO:
5355 case R_PPC64_PLT32:
5356 case R_PPC64_PLT64:
5357 /* This symbol requires a procedure linkage table entry. We
5358 actually build the entry in adjust_dynamic_symbol,
5359 because this might be a case of linking PIC code without
5360 linking in any dynamic objects, in which case we don't
5361 need to generate a procedure linkage table after all. */
5362 if (h == NULL)
5363 {
5364 /* It does not make sense to have a procedure linkage
5365 table entry for a local symbol. */
5366 bfd_set_error (bfd_error_bad_value);
5367 return FALSE;
5368 }
5369 else
5370 {
5371 if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5372 return FALSE;
5373 h->needs_plt = 1;
5374 if (h->root.root.string[0] == '.'
5375 && h->root.root.string[1] != '\0')
5376 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5377 }
5378 break;
5379
5380 /* The following relocations don't need to propagate the
5381 relocation if linking a shared object since they are
5382 section relative. */
5383 case R_PPC64_SECTOFF:
5384 case R_PPC64_SECTOFF_LO:
5385 case R_PPC64_SECTOFF_HI:
5386 case R_PPC64_SECTOFF_HA:
5387 case R_PPC64_SECTOFF_DS:
5388 case R_PPC64_SECTOFF_LO_DS:
5389 case R_PPC64_DTPREL16:
5390 case R_PPC64_DTPREL16_LO:
5391 case R_PPC64_DTPREL16_HI:
5392 case R_PPC64_DTPREL16_HA:
5393 case R_PPC64_DTPREL16_DS:
5394 case R_PPC64_DTPREL16_LO_DS:
5395 case R_PPC64_DTPREL16_HIGH:
5396 case R_PPC64_DTPREL16_HIGHA:
5397 case R_PPC64_DTPREL16_HIGHER:
5398 case R_PPC64_DTPREL16_HIGHERA:
5399 case R_PPC64_DTPREL16_HIGHEST:
5400 case R_PPC64_DTPREL16_HIGHESTA:
5401 break;
5402
5403 /* Nor do these. */
5404 case R_PPC64_REL16:
5405 case R_PPC64_REL16_LO:
5406 case R_PPC64_REL16_HI:
5407 case R_PPC64_REL16_HA:
5408 break;
5409
5410 case R_PPC64_TOC16:
5411 case R_PPC64_TOC16_DS:
5412 htab->do_multi_toc = 1;
5413 ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5414 case R_PPC64_TOC16_LO:
5415 case R_PPC64_TOC16_HI:
5416 case R_PPC64_TOC16_HA:
5417 case R_PPC64_TOC16_LO_DS:
5418 sec->has_toc_reloc = 1;
5419 break;
5420
5421 /* This relocation describes the C++ object vtable hierarchy.
5422 Reconstruct it for later use during GC. */
5423 case R_PPC64_GNU_VTINHERIT:
5424 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
5425 return FALSE;
5426 break;
5427
5428 /* This relocation describes which C++ vtable entries are actually
5429 used. Record for later use during GC. */
5430 case R_PPC64_GNU_VTENTRY:
5431 BFD_ASSERT (h != NULL);
5432 if (h != NULL
5433 && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
5434 return FALSE;
5435 break;
5436
5437 case R_PPC64_REL14:
5438 case R_PPC64_REL14_BRTAKEN:
5439 case R_PPC64_REL14_BRNTAKEN:
5440 {
5441 asection *dest = NULL;
5442
5443 /* Heuristic: If jumping outside our section, chances are
5444 we are going to need a stub. */
5445 if (h != NULL)
5446 {
5447 /* If the sym is weak it may be overridden later, so
5448 don't assume we know where a weak sym lives. */
5449 if (h->root.type == bfd_link_hash_defined)
5450 dest = h->root.u.def.section;
5451 }
5452 else
5453 {
5454 Elf_Internal_Sym *isym;
5455
5456 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5457 abfd, r_symndx);
5458 if (isym == NULL)
5459 return FALSE;
5460
5461 dest = bfd_section_from_elf_index (abfd, isym->st_shndx);
5462 }
5463
5464 if (dest != sec)
5465 ppc64_elf_section_data (sec)->has_14bit_branch = 1;
5466 }
5467 /* Fall through. */
5468
5469 case R_PPC64_REL24:
5470 if (h != NULL && ifunc == NULL)
5471 {
5472 /* We may need a .plt entry if the function this reloc
5473 refers to is in a shared lib. */
5474 if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5475 return FALSE;
5476 h->needs_plt = 1;
5477 if (h->root.root.string[0] == '.'
5478 && h->root.root.string[1] != '\0')
5479 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5480 if (h == tga || h == dottga)
5481 sec->has_tls_reloc = 1;
5482 }
5483 break;
5484
5485 case R_PPC64_TPREL64:
5486 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_TPREL;
5487 if (!info->executable)
5488 info->flags |= DF_STATIC_TLS;
5489 goto dotlstoc;
5490
5491 case R_PPC64_DTPMOD64:
5492 if (rel + 1 < rel_end
5493 && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
5494 && rel[1].r_offset == rel->r_offset + 8)
5495 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_GD;
5496 else
5497 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_LD;
5498 goto dotlstoc;
5499
5500 case R_PPC64_DTPREL64:
5501 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_DTPREL;
5502 if (rel != relocs
5503 && rel[-1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPMOD64)
5504 && rel[-1].r_offset == rel->r_offset - 8)
5505 /* This is the second reloc of a dtpmod, dtprel pair.
5506 Don't mark with TLS_DTPREL. */
5507 goto dodyn;
5508
5509 dotlstoc:
5510 sec->has_tls_reloc = 1;
5511 if (h != NULL)
5512 {
5513 struct ppc_link_hash_entry *eh;
5514 eh = (struct ppc_link_hash_entry *) h;
5515 eh->tls_mask |= tls_type;
5516 }
5517 else
5518 if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5519 rel->r_addend, tls_type))
5520 return FALSE;
5521
5522 ppc64_sec = ppc64_elf_section_data (sec);
5523 if (ppc64_sec->sec_type != sec_toc)
5524 {
5525 bfd_size_type amt;
5526
5527 /* One extra to simplify get_tls_mask. */
5528 amt = sec->size * sizeof (unsigned) / 8 + sizeof (unsigned);
5529 ppc64_sec->u.toc.symndx = bfd_zalloc (abfd, amt);
5530 if (ppc64_sec->u.toc.symndx == NULL)
5531 return FALSE;
5532 amt = sec->size * sizeof (bfd_vma) / 8;
5533 ppc64_sec->u.toc.add = bfd_zalloc (abfd, amt);
5534 if (ppc64_sec->u.toc.add == NULL)
5535 return FALSE;
5536 BFD_ASSERT (ppc64_sec->sec_type == sec_normal);
5537 ppc64_sec->sec_type = sec_toc;
5538 }
5539 BFD_ASSERT (rel->r_offset % 8 == 0);
5540 ppc64_sec->u.toc.symndx[rel->r_offset / 8] = r_symndx;
5541 ppc64_sec->u.toc.add[rel->r_offset / 8] = rel->r_addend;
5542
5543 /* Mark the second slot of a GD or LD entry.
5544 -1 to indicate GD and -2 to indicate LD. */
5545 if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_GD))
5546 ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -1;
5547 else if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_LD))
5548 ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -2;
5549 goto dodyn;
5550
5551 case R_PPC64_TPREL16:
5552 case R_PPC64_TPREL16_LO:
5553 case R_PPC64_TPREL16_HI:
5554 case R_PPC64_TPREL16_HA:
5555 case R_PPC64_TPREL16_DS:
5556 case R_PPC64_TPREL16_LO_DS:
5557 case R_PPC64_TPREL16_HIGH:
5558 case R_PPC64_TPREL16_HIGHA:
5559 case R_PPC64_TPREL16_HIGHER:
5560 case R_PPC64_TPREL16_HIGHERA:
5561 case R_PPC64_TPREL16_HIGHEST:
5562 case R_PPC64_TPREL16_HIGHESTA:
5563 if (info->shared)
5564 {
5565 if (!info->executable)
5566 info->flags |= DF_STATIC_TLS;
5567 goto dodyn;
5568 }
5569 break;
5570
5571 case R_PPC64_ADDR64:
5572 if (opd_sym_map != NULL
5573 && rel + 1 < rel_end
5574 && ELF64_R_TYPE ((rel + 1)->r_info) == R_PPC64_TOC)
5575 {
5576 if (h != NULL)
5577 {
5578 if (h->root.root.string[0] == '.'
5579 && h->root.root.string[1] != 0
5580 && lookup_fdh ((struct ppc_link_hash_entry *) h, htab))
5581 ;
5582 else
5583 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5584 }
5585 else
5586 {
5587 asection *s;
5588 Elf_Internal_Sym *isym;
5589
5590 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5591 abfd, r_symndx);
5592 if (isym == NULL)
5593 return FALSE;
5594
5595 s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5596 if (s != NULL && s != sec)
5597 opd_sym_map[rel->r_offset / 8] = s;
5598 }
5599 }
5600 /* Fall through. */
5601
5602 case R_PPC64_ADDR16:
5603 case R_PPC64_ADDR16_DS:
5604 case R_PPC64_ADDR16_HA:
5605 case R_PPC64_ADDR16_HI:
5606 case R_PPC64_ADDR16_HIGH:
5607 case R_PPC64_ADDR16_HIGHA:
5608 case R_PPC64_ADDR16_HIGHER:
5609 case R_PPC64_ADDR16_HIGHERA:
5610 case R_PPC64_ADDR16_HIGHEST:
5611 case R_PPC64_ADDR16_HIGHESTA:
5612 case R_PPC64_ADDR16_LO:
5613 case R_PPC64_ADDR16_LO_DS:
5614 if (h != NULL && !info->shared && abiversion (abfd) == 2
5615 && rel->r_addend == 0)
5616 {
5617 /* We may need a .plt entry if this reloc refers to a
5618 function in a shared lib. */
5619 if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5620 return FALSE;
5621 h->pointer_equality_needed = 1;
5622 }
5623 /* Fall through. */
5624
5625 case R_PPC64_REL30:
5626 case R_PPC64_REL32:
5627 case R_PPC64_REL64:
5628 case R_PPC64_ADDR14:
5629 case R_PPC64_ADDR14_BRNTAKEN:
5630 case R_PPC64_ADDR14_BRTAKEN:
5631 case R_PPC64_ADDR24:
5632 case R_PPC64_ADDR32:
5633 case R_PPC64_UADDR16:
5634 case R_PPC64_UADDR32:
5635 case R_PPC64_UADDR64:
5636 case R_PPC64_TOC:
5637 if (h != NULL && !info->shared)
5638 /* We may need a copy reloc. */
5639 h->non_got_ref = 1;
5640
5641 /* Don't propagate .opd relocs. */
5642 if (NO_OPD_RELOCS && opd_sym_map != NULL)
5643 break;
5644
5645 /* If we are creating a shared library, and this is a reloc
5646 against a global symbol, or a non PC relative reloc
5647 against a local symbol, then we need to copy the reloc
5648 into the shared library. However, if we are linking with
5649 -Bsymbolic, we do not need to copy a reloc against a
5650 global symbol which is defined in an object we are
5651 including in the link (i.e., DEF_REGULAR is set). At
5652 this point we have not seen all the input files, so it is
5653 possible that DEF_REGULAR is not set now but will be set
5654 later (it is never cleared). In case of a weak definition,
5655 DEF_REGULAR may be cleared later by a strong definition in
5656 a shared library. We account for that possibility below by
5657 storing information in the dyn_relocs field of the hash
5658 table entry. A similar situation occurs when creating
5659 shared libraries and symbol visibility changes render the
5660 symbol local.
5661
5662 If on the other hand, we are creating an executable, we
5663 may need to keep relocations for symbols satisfied by a
5664 dynamic library if we manage to avoid copy relocs for the
5665 symbol. */
5666 dodyn:
5667 if ((info->shared
5668 && (must_be_dyn_reloc (info, r_type)
5669 || (h != NULL
5670 && (!SYMBOLIC_BIND (info, h)
5671 || h->root.type == bfd_link_hash_defweak
5672 || !h->def_regular))))
5673 || (ELIMINATE_COPY_RELOCS
5674 && !info->shared
5675 && h != NULL
5676 && (h->root.type == bfd_link_hash_defweak
5677 || !h->def_regular))
5678 || (!info->shared
5679 && ifunc != NULL))
5680 {
5681 /* We must copy these reloc types into the output file.
5682 Create a reloc section in dynobj and make room for
5683 this reloc. */
5684 if (sreloc == NULL)
5685 {
5686 sreloc = _bfd_elf_make_dynamic_reloc_section
5687 (sec, htab->elf.dynobj, 3, abfd, /*rela?*/ TRUE);
5688
5689 if (sreloc == NULL)
5690 return FALSE;
5691 }
5692
5693 /* If this is a global symbol, we count the number of
5694 relocations we need for this symbol. */
5695 if (h != NULL)
5696 {
5697 struct elf_dyn_relocs *p;
5698 struct elf_dyn_relocs **head;
5699
5700 head = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
5701 p = *head;
5702 if (p == NULL || p->sec != sec)
5703 {
5704 p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5705 if (p == NULL)
5706 return FALSE;
5707 p->next = *head;
5708 *head = p;
5709 p->sec = sec;
5710 p->count = 0;
5711 p->pc_count = 0;
5712 }
5713 p->count += 1;
5714 if (!must_be_dyn_reloc (info, r_type))
5715 p->pc_count += 1;
5716 }
5717 else
5718 {
5719 /* Track dynamic relocs needed for local syms too.
5720 We really need local syms available to do this
5721 easily. Oh well. */
5722 struct ppc_dyn_relocs *p;
5723 struct ppc_dyn_relocs **head;
5724 bfd_boolean is_ifunc;
5725 asection *s;
5726 void *vpp;
5727 Elf_Internal_Sym *isym;
5728
5729 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5730 abfd, r_symndx);
5731 if (isym == NULL)
5732 return FALSE;
5733
5734 s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5735 if (s == NULL)
5736 s = sec;
5737
5738 vpp = &elf_section_data (s)->local_dynrel;
5739 head = (struct ppc_dyn_relocs **) vpp;
5740 is_ifunc = ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC;
5741 p = *head;
5742 if (p != NULL && p->sec == sec && p->ifunc != is_ifunc)
5743 p = p->next;
5744 if (p == NULL || p->sec != sec || p->ifunc != is_ifunc)
5745 {
5746 p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5747 if (p == NULL)
5748 return FALSE;
5749 p->next = *head;
5750 *head = p;
5751 p->sec = sec;
5752 p->ifunc = is_ifunc;
5753 p->count = 0;
5754 }
5755 p->count += 1;
5756 }
5757 }
5758 break;
5759
5760 default:
5761 break;
5762 }
5763 }
5764
5765 return TRUE;
5766 }
5767
5768 /* Merge backend specific data from an object file to the output
5769 object file when linking. */
5770
5771 static bfd_boolean
5772 ppc64_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
5773 {
5774 unsigned long iflags, oflags;
5775
5776 if ((ibfd->flags & BFD_LINKER_CREATED) != 0)
5777 return TRUE;
5778
5779 if (!is_ppc64_elf (ibfd) || !is_ppc64_elf (obfd))
5780 return TRUE;
5781
5782 if (!_bfd_generic_verify_endian_match (ibfd, obfd))
5783 return FALSE;
5784
5785 iflags = elf_elfheader (ibfd)->e_flags;
5786 oflags = elf_elfheader (obfd)->e_flags;
5787
5788 if (!elf_flags_init (obfd) || oflags == 0)
5789 {
5790 elf_flags_init (obfd) = TRUE;
5791 elf_elfheader (obfd)->e_flags = iflags;
5792 }
5793 else if (iflags == oflags || iflags == 0)
5794 ;
5795 else if (iflags & ~EF_PPC64_ABI)
5796 {
5797 (*_bfd_error_handler)
5798 (_("%B uses unknown e_flags 0x%lx"), ibfd, iflags);
5799 bfd_set_error (bfd_error_bad_value);
5800 return FALSE;
5801 }
5802 else
5803 {
5804 (*_bfd_error_handler)
5805 (_("%B: ABI version %ld is not compatible with ABI version %ld output"),
5806 ibfd, iflags, oflags);
5807 bfd_set_error (bfd_error_bad_value);
5808 return FALSE;
5809 }
5810
5811 /* Merge Tag_compatibility attributes and any common GNU ones. */
5812 _bfd_elf_merge_object_attributes (ibfd, obfd);
5813
5814 return TRUE;
5815 }
5816
5817 static bfd_boolean
5818 ppc64_elf_print_private_bfd_data (bfd *abfd, void *ptr)
5819 {
5820 /* Print normal ELF private data. */
5821 _bfd_elf_print_private_bfd_data (abfd, ptr);
5822
5823 if (elf_elfheader (abfd)->e_flags != 0)
5824 {
5825 FILE *file = ptr;
5826
5827 /* xgettext:c-format */
5828 fprintf (file, _("private flags = 0x%lx:"),
5829 elf_elfheader (abfd)->e_flags);
5830
5831 if ((elf_elfheader (abfd)->e_flags & EF_PPC64_ABI) != 0)
5832 fprintf (file, _(" [abiv%ld]"),
5833 elf_elfheader (abfd)->e_flags & EF_PPC64_ABI);
5834 fputc ('\n', file);
5835 }
5836
5837 return TRUE;
5838 }
5839
5840 /* OFFSET in OPD_SEC specifies a function descriptor. Return the address
5841 of the code entry point, and its section. */
5842
5843 static bfd_vma
5844 opd_entry_value (asection *opd_sec,
5845 bfd_vma offset,
5846 asection **code_sec,
5847 bfd_vma *code_off,
5848 bfd_boolean in_code_sec)
5849 {
5850 bfd *opd_bfd = opd_sec->owner;
5851 Elf_Internal_Rela *relocs;
5852 Elf_Internal_Rela *lo, *hi, *look;
5853 bfd_vma val;
5854
5855 /* No relocs implies we are linking a --just-symbols object, or looking
5856 at a final linked executable with addr2line or somesuch. */
5857 if (opd_sec->reloc_count == 0)
5858 {
5859 bfd_byte *contents = ppc64_elf_tdata (opd_bfd)->opd.contents;
5860
5861 if (contents == NULL)
5862 {
5863 if (!bfd_malloc_and_get_section (opd_bfd, opd_sec, &contents))
5864 return (bfd_vma) -1;
5865 ppc64_elf_tdata (opd_bfd)->opd.contents = contents;
5866 }
5867
5868 val = bfd_get_64 (opd_bfd, contents + offset);
5869 if (code_sec != NULL)
5870 {
5871 asection *sec, *likely = NULL;
5872
5873 if (in_code_sec)
5874 {
5875 sec = *code_sec;
5876 if (sec->vma <= val
5877 && val < sec->vma + sec->size)
5878 likely = sec;
5879 else
5880 val = -1;
5881 }
5882 else
5883 for (sec = opd_bfd->sections; sec != NULL; sec = sec->next)
5884 if (sec->vma <= val
5885 && (sec->flags & SEC_LOAD) != 0
5886 && (sec->flags & SEC_ALLOC) != 0)
5887 likely = sec;
5888 if (likely != NULL)
5889 {
5890 *code_sec = likely;
5891 if (code_off != NULL)
5892 *code_off = val - likely->vma;
5893 }
5894 }
5895 return val;
5896 }
5897
5898 BFD_ASSERT (is_ppc64_elf (opd_bfd));
5899
5900 relocs = ppc64_elf_tdata (opd_bfd)->opd.relocs;
5901 if (relocs == NULL)
5902 relocs = _bfd_elf_link_read_relocs (opd_bfd, opd_sec, NULL, NULL, TRUE);
5903
5904 /* Go find the opd reloc at the sym address. */
5905 lo = relocs;
5906 BFD_ASSERT (lo != NULL);
5907 hi = lo + opd_sec->reloc_count - 1; /* ignore last reloc */
5908 val = (bfd_vma) -1;
5909 while (lo < hi)
5910 {
5911 look = lo + (hi - lo) / 2;
5912 if (look->r_offset < offset)
5913 lo = look + 1;
5914 else if (look->r_offset > offset)
5915 hi = look;
5916 else
5917 {
5918 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (opd_bfd);
5919
5920 if (ELF64_R_TYPE (look->r_info) == R_PPC64_ADDR64
5921 && ELF64_R_TYPE ((look + 1)->r_info) == R_PPC64_TOC)
5922 {
5923 unsigned long symndx = ELF64_R_SYM (look->r_info);
5924 asection *sec;
5925
5926 if (symndx < symtab_hdr->sh_info
5927 || elf_sym_hashes (opd_bfd) == NULL)
5928 {
5929 Elf_Internal_Sym *sym;
5930
5931 sym = (Elf_Internal_Sym *) symtab_hdr->contents;
5932 if (sym == NULL)
5933 {
5934 size_t symcnt = symtab_hdr->sh_info;
5935 if (elf_sym_hashes (opd_bfd) == NULL)
5936 symcnt = symtab_hdr->sh_size / symtab_hdr->sh_entsize;
5937 sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr, symcnt,
5938 0, NULL, NULL, NULL);
5939 if (sym == NULL)
5940 break;
5941 symtab_hdr->contents = (bfd_byte *) sym;
5942 }
5943
5944 sym += symndx;
5945 val = sym->st_value;
5946 sec = bfd_section_from_elf_index (opd_bfd, sym->st_shndx);
5947 BFD_ASSERT ((sec->flags & SEC_MERGE) == 0);
5948 }
5949 else
5950 {
5951 struct elf_link_hash_entry **sym_hashes;
5952 struct elf_link_hash_entry *rh;
5953
5954 sym_hashes = elf_sym_hashes (opd_bfd);
5955 rh = sym_hashes[symndx - symtab_hdr->sh_info];
5956 if (rh != NULL)
5957 {
5958 rh = elf_follow_link (rh);
5959 BFD_ASSERT (rh->root.type == bfd_link_hash_defined
5960 || rh->root.type == bfd_link_hash_defweak);
5961 val = rh->root.u.def.value;
5962 sec = rh->root.u.def.section;
5963 }
5964 else
5965 {
5966 /* Handle the odd case where we can be called
5967 during bfd_elf_link_add_symbols before the
5968 symbol hashes have been fully populated. */
5969 Elf_Internal_Sym *sym;
5970
5971 sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr, 1,
5972 symndx, NULL, NULL, NULL);
5973 if (sym == NULL)
5974 break;
5975
5976 val = sym->st_value;
5977 sec = bfd_section_from_elf_index (opd_bfd, sym->st_shndx);
5978 free (sym);
5979 }
5980 }
5981 val += look->r_addend;
5982 if (code_off != NULL)
5983 *code_off = val;
5984 if (code_sec != NULL)
5985 {
5986 if (in_code_sec && *code_sec != sec)
5987 return -1;
5988 else
5989 *code_sec = sec;
5990 }
5991 if (sec != NULL && sec->output_section != NULL)
5992 val += sec->output_section->vma + sec->output_offset;
5993 }
5994 break;
5995 }
5996 }
5997
5998 return val;
5999 }
6000
6001 /* If the ELF symbol SYM might be a function in SEC, return the
6002 function size and set *CODE_OFF to the function's entry point,
6003 otherwise return zero. */
6004
6005 static bfd_size_type
6006 ppc64_elf_maybe_function_sym (const asymbol *sym, asection *sec,
6007 bfd_vma *code_off)
6008 {
6009 bfd_size_type size;
6010
6011 if ((sym->flags & (BSF_SECTION_SYM | BSF_FILE | BSF_OBJECT
6012 | BSF_THREAD_LOCAL | BSF_RELC | BSF_SRELC)) != 0)
6013 return 0;
6014
6015 size = 0;
6016 if (!(sym->flags & BSF_SYNTHETIC))
6017 size = ((elf_symbol_type *) sym)->internal_elf_sym.st_size;
6018
6019 if (strcmp (sym->section->name, ".opd") == 0)
6020 {
6021 if (opd_entry_value (sym->section, sym->value,
6022 &sec, code_off, TRUE) == (bfd_vma) -1)
6023 return 0;
6024 /* An old ABI binary with dot-syms has a size of 24 on the .opd
6025 symbol. This size has nothing to do with the code size of the
6026 function, which is what we're supposed to return, but the
6027 code size isn't available without looking up the dot-sym.
6028 However, doing that would be a waste of time particularly
6029 since elf_find_function will look at the dot-sym anyway.
6030 Now, elf_find_function will keep the largest size of any
6031 function sym found at the code address of interest, so return
6032 1 here to avoid it incorrectly caching a larger function size
6033 for a small function. This does mean we return the wrong
6034 size for a new-ABI function of size 24, but all that does is
6035 disable caching for such functions. */
6036 if (size == 24)
6037 size = 1;
6038 }
6039 else
6040 {
6041 if (sym->section != sec)
6042 return 0;
6043 *code_off = sym->value;
6044 }
6045 if (size == 0)
6046 size = 1;
6047 return size;
6048 }
6049
6050 /* Return true if symbol is defined in a regular object file. */
6051
6052 static bfd_boolean
6053 is_static_defined (struct elf_link_hash_entry *h)
6054 {
6055 return ((h->root.type == bfd_link_hash_defined
6056 || h->root.type == bfd_link_hash_defweak)
6057 && h->root.u.def.section != NULL
6058 && h->root.u.def.section->output_section != NULL);
6059 }
6060
6061 /* If FDH is a function descriptor symbol, return the associated code
6062 entry symbol if it is defined. Return NULL otherwise. */
6063
6064 static struct ppc_link_hash_entry *
6065 defined_code_entry (struct ppc_link_hash_entry *fdh)
6066 {
6067 if (fdh->is_func_descriptor)
6068 {
6069 struct ppc_link_hash_entry *fh = ppc_follow_link (fdh->oh);
6070 if (fh->elf.root.type == bfd_link_hash_defined
6071 || fh->elf.root.type == bfd_link_hash_defweak)
6072 return fh;
6073 }
6074 return NULL;
6075 }
6076
6077 /* If FH is a function code entry symbol, return the associated
6078 function descriptor symbol if it is defined. Return NULL otherwise. */
6079
6080 static struct ppc_link_hash_entry *
6081 defined_func_desc (struct ppc_link_hash_entry *fh)
6082 {
6083 if (fh->oh != NULL
6084 && fh->oh->is_func_descriptor)
6085 {
6086 struct ppc_link_hash_entry *fdh = ppc_follow_link (fh->oh);
6087 if (fdh->elf.root.type == bfd_link_hash_defined
6088 || fdh->elf.root.type == bfd_link_hash_defweak)
6089 return fdh;
6090 }
6091 return NULL;
6092 }
6093
6094 /* Mark all our entry sym sections, both opd and code section. */
6095
6096 static void
6097 ppc64_elf_gc_keep (struct bfd_link_info *info)
6098 {
6099 struct ppc_link_hash_table *htab = ppc_hash_table (info);
6100 struct bfd_sym_chain *sym;
6101
6102 if (htab == NULL)
6103 return;
6104
6105 for (sym = info->gc_sym_list; sym != NULL; sym = sym->next)
6106 {
6107 struct ppc_link_hash_entry *eh, *fh;
6108 asection *sec;
6109
6110 eh = (struct ppc_link_hash_entry *)
6111 elf_link_hash_lookup (&htab->elf, sym->name, FALSE, FALSE, TRUE);
6112 if (eh == NULL)
6113 continue;
6114 if (eh->elf.root.type != bfd_link_hash_defined
6115 && eh->elf.root.type != bfd_link_hash_defweak)
6116 continue;
6117
6118 fh = defined_code_entry (eh);
6119 if (fh != NULL)
6120 {
6121 sec = fh->elf.root.u.def.section;
6122 sec->flags |= SEC_KEEP;
6123 }
6124 else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6125 && opd_entry_value (eh->elf.root.u.def.section,
6126 eh->elf.root.u.def.value,
6127 &sec, NULL, FALSE) != (bfd_vma) -1)
6128 sec->flags |= SEC_KEEP;
6129
6130 sec = eh->elf.root.u.def.section;
6131 sec->flags |= SEC_KEEP;
6132 }
6133 }
6134
6135 /* Mark sections containing dynamically referenced symbols. When
6136 building shared libraries, we must assume that any visible symbol is
6137 referenced. */
6138
6139 static bfd_boolean
6140 ppc64_elf_gc_mark_dynamic_ref (struct elf_link_hash_entry *h, void *inf)
6141 {
6142 struct bfd_link_info *info = (struct bfd_link_info *) inf;
6143 struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
6144 struct ppc_link_hash_entry *fdh;
6145
6146 /* Dynamic linking info is on the func descriptor sym. */
6147 fdh = defined_func_desc (eh);
6148 if (fdh != NULL)
6149 eh = fdh;
6150
6151 if ((eh->elf.root.type == bfd_link_hash_defined
6152 || eh->elf.root.type == bfd_link_hash_defweak)
6153 && (eh->elf.ref_dynamic
6154 || (!info->executable
6155 && eh->elf.def_regular
6156 && ELF_ST_VISIBILITY (eh->elf.other) != STV_INTERNAL
6157 && ELF_ST_VISIBILITY (eh->elf.other) != STV_HIDDEN
6158 && (strchr (eh->elf.root.root.string, ELF_VER_CHR) != NULL
6159 || !bfd_hide_sym_by_version (info->version_info,
6160 eh->elf.root.root.string)))))
6161 {
6162 asection *code_sec;
6163 struct ppc_link_hash_entry *fh;
6164
6165 eh->elf.root.u.def.section->flags |= SEC_KEEP;
6166
6167 /* Function descriptor syms cause the associated
6168 function code sym section to be marked. */
6169 fh = defined_code_entry (eh);
6170 if (fh != NULL)
6171 {
6172 code_sec = fh->elf.root.u.def.section;
6173 code_sec->flags |= SEC_KEEP;
6174 }
6175 else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6176 && opd_entry_value (eh->elf.root.u.def.section,
6177 eh->elf.root.u.def.value,
6178 &code_sec, NULL, FALSE) != (bfd_vma) -1)
6179 code_sec->flags |= SEC_KEEP;
6180 }
6181
6182 return TRUE;
6183 }
6184
6185 /* Return the section that should be marked against GC for a given
6186 relocation. */
6187
6188 static asection *
6189 ppc64_elf_gc_mark_hook (asection *sec,
6190 struct bfd_link_info *info,
6191 Elf_Internal_Rela *rel,
6192 struct elf_link_hash_entry *h,
6193 Elf_Internal_Sym *sym)
6194 {
6195 asection *rsec;
6196
6197 /* Syms return NULL if we're marking .opd, so we avoid marking all
6198 function sections, as all functions are referenced in .opd. */
6199 rsec = NULL;
6200 if (get_opd_info (sec) != NULL)
6201 return rsec;
6202
6203 if (h != NULL)
6204 {
6205 enum elf_ppc64_reloc_type r_type;
6206 struct ppc_link_hash_entry *eh, *fh, *fdh;
6207
6208 r_type = ELF64_R_TYPE (rel->r_info);
6209 switch (r_type)
6210 {
6211 case R_PPC64_GNU_VTINHERIT:
6212 case R_PPC64_GNU_VTENTRY:
6213 break;
6214
6215 default:
6216 switch (h->root.type)
6217 {
6218 case bfd_link_hash_defined:
6219 case bfd_link_hash_defweak:
6220 eh = (struct ppc_link_hash_entry *) h;
6221 fdh = defined_func_desc (eh);
6222 if (fdh != NULL)
6223 eh = fdh;
6224
6225 /* Function descriptor syms cause the associated
6226 function code sym section to be marked. */
6227 fh = defined_code_entry (eh);
6228 if (fh != NULL)
6229 {
6230 /* They also mark their opd section. */
6231 eh->elf.root.u.def.section->gc_mark = 1;
6232
6233 rsec = fh->elf.root.u.def.section;
6234 }
6235 else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6236 && opd_entry_value (eh->elf.root.u.def.section,
6237 eh->elf.root.u.def.value,
6238 &rsec, NULL, FALSE) != (bfd_vma) -1)
6239 eh->elf.root.u.def.section->gc_mark = 1;
6240 else
6241 rsec = h->root.u.def.section;
6242 break;
6243
6244 case bfd_link_hash_common:
6245 rsec = h->root.u.c.p->section;
6246 break;
6247
6248 default:
6249 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
6250 }
6251 }
6252 }
6253 else
6254 {
6255 struct _opd_sec_data *opd;
6256
6257 rsec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
6258 opd = get_opd_info (rsec);
6259 if (opd != NULL && opd->func_sec != NULL)
6260 {
6261 rsec->gc_mark = 1;
6262
6263 rsec = opd->func_sec[(sym->st_value + rel->r_addend) / 8];
6264 }
6265 }
6266
6267 return rsec;
6268 }
6269
6270 /* Update the .got, .plt. and dynamic reloc reference counts for the
6271 section being removed. */
6272
6273 static bfd_boolean
6274 ppc64_elf_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info,
6275 asection *sec, const Elf_Internal_Rela *relocs)
6276 {
6277 struct ppc_link_hash_table *htab;
6278 Elf_Internal_Shdr *symtab_hdr;
6279 struct elf_link_hash_entry **sym_hashes;
6280 struct got_entry **local_got_ents;
6281 const Elf_Internal_Rela *rel, *relend;
6282
6283 if (info->relocatable)
6284 return TRUE;
6285
6286 if ((sec->flags & SEC_ALLOC) == 0)
6287 return TRUE;
6288
6289 elf_section_data (sec)->local_dynrel = NULL;
6290
6291 htab = ppc_hash_table (info);
6292 if (htab == NULL)
6293 return FALSE;
6294
6295 symtab_hdr = &elf_symtab_hdr (abfd);
6296 sym_hashes = elf_sym_hashes (abfd);
6297 local_got_ents = elf_local_got_ents (abfd);
6298
6299 relend = relocs + sec->reloc_count;
6300 for (rel = relocs; rel < relend; rel++)
6301 {
6302 unsigned long r_symndx;
6303 enum elf_ppc64_reloc_type r_type;
6304 struct elf_link_hash_entry *h = NULL;
6305 unsigned char tls_type = 0;
6306
6307 r_symndx = ELF64_R_SYM (rel->r_info);
6308 r_type = ELF64_R_TYPE (rel->r_info);
6309 if (r_symndx >= symtab_hdr->sh_info)
6310 {
6311 struct ppc_link_hash_entry *eh;
6312 struct elf_dyn_relocs **pp;
6313 struct elf_dyn_relocs *p;
6314
6315 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
6316 h = elf_follow_link (h);
6317 eh = (struct ppc_link_hash_entry *) h;
6318
6319 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
6320 if (p->sec == sec)
6321 {
6322 /* Everything must go for SEC. */
6323 *pp = p->next;
6324 break;
6325 }
6326 }
6327
6328 if (is_branch_reloc (r_type))
6329 {
6330 struct plt_entry **ifunc = NULL;
6331 if (h != NULL)
6332 {
6333 if (h->type == STT_GNU_IFUNC)
6334 ifunc = &h->plt.plist;
6335 }
6336 else if (local_got_ents != NULL)
6337 {
6338 struct plt_entry **local_plt = (struct plt_entry **)
6339 (local_got_ents + symtab_hdr->sh_info);
6340 unsigned char *local_got_tls_masks = (unsigned char *)
6341 (local_plt + symtab_hdr->sh_info);
6342 if ((local_got_tls_masks[r_symndx] & PLT_IFUNC) != 0)
6343 ifunc = local_plt + r_symndx;
6344 }
6345 if (ifunc != NULL)
6346 {
6347 struct plt_entry *ent;
6348
6349 for (ent = *ifunc; ent != NULL; ent = ent->next)
6350 if (ent->addend == rel->r_addend)
6351 break;
6352 if (ent == NULL)
6353 abort ();
6354 if (ent->plt.refcount > 0)
6355 ent->plt.refcount -= 1;
6356 continue;
6357 }
6358 }
6359
6360 switch (r_type)
6361 {
6362 case R_PPC64_GOT_TLSLD16:
6363 case R_PPC64_GOT_TLSLD16_LO:
6364 case R_PPC64_GOT_TLSLD16_HI:
6365 case R_PPC64_GOT_TLSLD16_HA:
6366 tls_type = TLS_TLS | TLS_LD;
6367 goto dogot;
6368
6369 case R_PPC64_GOT_TLSGD16:
6370 case R_PPC64_GOT_TLSGD16_LO:
6371 case R_PPC64_GOT_TLSGD16_HI:
6372 case R_PPC64_GOT_TLSGD16_HA:
6373 tls_type = TLS_TLS | TLS_GD;
6374 goto dogot;
6375
6376 case R_PPC64_GOT_TPREL16_DS:
6377 case R_PPC64_GOT_TPREL16_LO_DS:
6378 case R_PPC64_GOT_TPREL16_HI:
6379 case R_PPC64_GOT_TPREL16_HA:
6380 tls_type = TLS_TLS | TLS_TPREL;
6381 goto dogot;
6382
6383 case R_PPC64_GOT_DTPREL16_DS:
6384 case R_PPC64_GOT_DTPREL16_LO_DS:
6385 case R_PPC64_GOT_DTPREL16_HI:
6386 case R_PPC64_GOT_DTPREL16_HA:
6387 tls_type = TLS_TLS | TLS_DTPREL;
6388 goto dogot;
6389
6390 case R_PPC64_GOT16:
6391 case R_PPC64_GOT16_DS:
6392 case R_PPC64_GOT16_HA:
6393 case R_PPC64_GOT16_HI:
6394 case R_PPC64_GOT16_LO:
6395 case R_PPC64_GOT16_LO_DS:
6396 dogot:
6397 {
6398 struct got_entry *ent;
6399
6400 if (h != NULL)
6401 ent = h->got.glist;
6402 else
6403 ent = local_got_ents[r_symndx];
6404
6405 for (; ent != NULL; ent = ent->next)
6406 if (ent->addend == rel->r_addend
6407 && ent->owner == abfd
6408 && ent->tls_type == tls_type)
6409 break;
6410 if (ent == NULL)
6411 abort ();
6412 if (ent->got.refcount > 0)
6413 ent->got.refcount -= 1;
6414 }
6415 break;
6416
6417 case R_PPC64_PLT16_HA:
6418 case R_PPC64_PLT16_HI:
6419 case R_PPC64_PLT16_LO:
6420 case R_PPC64_PLT32:
6421 case R_PPC64_PLT64:
6422 case R_PPC64_REL14:
6423 case R_PPC64_REL14_BRNTAKEN:
6424 case R_PPC64_REL14_BRTAKEN:
6425 case R_PPC64_REL24:
6426 if (h != NULL)
6427 {
6428 struct plt_entry *ent;
6429
6430 for (ent = h->plt.plist; ent != NULL; ent = ent->next)
6431 if (ent->addend == rel->r_addend)
6432 break;
6433 if (ent != NULL && ent->plt.refcount > 0)
6434 ent->plt.refcount -= 1;
6435 }
6436 break;
6437
6438 default:
6439 break;
6440 }
6441 }
6442 return TRUE;
6443 }
6444
6445 /* The maximum size of .sfpr. */
6446 #define SFPR_MAX (218*4)
6447
6448 struct sfpr_def_parms
6449 {
6450 const char name[12];
6451 unsigned char lo, hi;
6452 bfd_byte * (*write_ent) (bfd *, bfd_byte *, int);
6453 bfd_byte * (*write_tail) (bfd *, bfd_byte *, int);
6454 };
6455
6456 /* Auto-generate _save*, _rest* functions in .sfpr. */
6457
6458 static bfd_boolean
6459 sfpr_define (struct bfd_link_info *info, const struct sfpr_def_parms *parm)
6460 {
6461 struct ppc_link_hash_table *htab = ppc_hash_table (info);
6462 unsigned int i;
6463 size_t len = strlen (parm->name);
6464 bfd_boolean writing = FALSE;
6465 char sym[16];
6466
6467 if (htab == NULL)
6468 return FALSE;
6469
6470 memcpy (sym, parm->name, len);
6471 sym[len + 2] = 0;
6472
6473 for (i = parm->lo; i <= parm->hi; i++)
6474 {
6475 struct elf_link_hash_entry *h;
6476
6477 sym[len + 0] = i / 10 + '0';
6478 sym[len + 1] = i % 10 + '0';
6479 h = elf_link_hash_lookup (&htab->elf, sym, FALSE, FALSE, TRUE);
6480 if (h != NULL
6481 && !h->def_regular)
6482 {
6483 h->root.type = bfd_link_hash_defined;
6484 h->root.u.def.section = htab->sfpr;
6485 h->root.u.def.value = htab->sfpr->size;
6486 h->type = STT_FUNC;
6487 h->def_regular = 1;
6488 _bfd_elf_link_hash_hide_symbol (info, h, TRUE);
6489 writing = TRUE;
6490 if (htab->sfpr->contents == NULL)
6491 {
6492 htab->sfpr->contents = bfd_alloc (htab->elf.dynobj, SFPR_MAX);
6493 if (htab->sfpr->contents == NULL)
6494 return FALSE;
6495 }
6496 }
6497 if (writing)
6498 {
6499 bfd_byte *p = htab->sfpr->contents + htab->sfpr->size;
6500 if (i != parm->hi)
6501 p = (*parm->write_ent) (htab->elf.dynobj, p, i);
6502 else
6503 p = (*parm->write_tail) (htab->elf.dynobj, p, i);
6504 htab->sfpr->size = p - htab->sfpr->contents;
6505 }
6506 }
6507
6508 return TRUE;
6509 }
6510
6511 static bfd_byte *
6512 savegpr0 (bfd *abfd, bfd_byte *p, int r)
6513 {
6514 bfd_put_32 (abfd, STD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6515 return p + 4;
6516 }
6517
6518 static bfd_byte *
6519 savegpr0_tail (bfd *abfd, bfd_byte *p, int r)
6520 {
6521 p = savegpr0 (abfd, p, r);
6522 bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
6523 p = p + 4;
6524 bfd_put_32 (abfd, BLR, p);
6525 return p + 4;
6526 }
6527
6528 static bfd_byte *
6529 restgpr0 (bfd *abfd, bfd_byte *p, int r)
6530 {
6531 bfd_put_32 (abfd, LD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6532 return p + 4;
6533 }
6534
6535 static bfd_byte *
6536 restgpr0_tail (bfd *abfd, bfd_byte *p, int r)
6537 {
6538 bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
6539 p = p + 4;
6540 p = restgpr0 (abfd, p, r);
6541 bfd_put_32 (abfd, MTLR_R0, p);
6542 p = p + 4;
6543 if (r == 29)
6544 {
6545 p = restgpr0 (abfd, p, 30);
6546 p = restgpr0 (abfd, p, 31);
6547 }
6548 bfd_put_32 (abfd, BLR, p);
6549 return p + 4;
6550 }
6551
6552 static bfd_byte *
6553 savegpr1 (bfd *abfd, bfd_byte *p, int r)
6554 {
6555 bfd_put_32 (abfd, STD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6556 return p + 4;
6557 }
6558
6559 static bfd_byte *
6560 savegpr1_tail (bfd *abfd, bfd_byte *p, int r)
6561 {
6562 p = savegpr1 (abfd, p, r);
6563 bfd_put_32 (abfd, BLR, p);
6564 return p + 4;
6565 }
6566
6567 static bfd_byte *
6568 restgpr1 (bfd *abfd, bfd_byte *p, int r)
6569 {
6570 bfd_put_32 (abfd, LD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6571 return p + 4;
6572 }
6573
6574 static bfd_byte *
6575 restgpr1_tail (bfd *abfd, bfd_byte *p, int r)
6576 {
6577 p = restgpr1 (abfd, p, r);
6578 bfd_put_32 (abfd, BLR, p);
6579 return p + 4;
6580 }
6581
6582 static bfd_byte *
6583 savefpr (bfd *abfd, bfd_byte *p, int r)
6584 {
6585 bfd_put_32 (abfd, STFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6586 return p + 4;
6587 }
6588
6589 static bfd_byte *
6590 savefpr0_tail (bfd *abfd, bfd_byte *p, int r)
6591 {
6592 p = savefpr (abfd, p, r);
6593 bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
6594 p = p + 4;
6595 bfd_put_32 (abfd, BLR, p);
6596 return p + 4;
6597 }
6598
6599 static bfd_byte *
6600 restfpr (bfd *abfd, bfd_byte *p, int r)
6601 {
6602 bfd_put_32 (abfd, LFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6603 return p + 4;
6604 }
6605
6606 static bfd_byte *
6607 restfpr0_tail (bfd *abfd, bfd_byte *p, int r)
6608 {
6609 bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
6610 p = p + 4;
6611 p = restfpr (abfd, p, r);
6612 bfd_put_32 (abfd, MTLR_R0, p);
6613 p = p + 4;
6614 if (r == 29)
6615 {
6616 p = restfpr (abfd, p, 30);
6617 p = restfpr (abfd, p, 31);
6618 }
6619 bfd_put_32 (abfd, BLR, p);
6620 return p + 4;
6621 }
6622
6623 static bfd_byte *
6624 savefpr1_tail (bfd *abfd, bfd_byte *p, int r)
6625 {
6626 p = savefpr (abfd, p, r);
6627 bfd_put_32 (abfd, BLR, p);
6628 return p + 4;
6629 }
6630
6631 static bfd_byte *
6632 restfpr1_tail (bfd *abfd, bfd_byte *p, int r)
6633 {
6634 p = restfpr (abfd, p, r);
6635 bfd_put_32 (abfd, BLR, p);
6636 return p + 4;
6637 }
6638
6639 static bfd_byte *
6640 savevr (bfd *abfd, bfd_byte *p, int r)
6641 {
6642 bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6643 p = p + 4;
6644 bfd_put_32 (abfd, STVX_VR0_R12_R0 + (r << 21), p);
6645 return p + 4;
6646 }
6647
6648 static bfd_byte *
6649 savevr_tail (bfd *abfd, bfd_byte *p, int r)
6650 {
6651 p = savevr (abfd, p, r);
6652 bfd_put_32 (abfd, BLR, p);
6653 return p + 4;
6654 }
6655
6656 static bfd_byte *
6657 restvr (bfd *abfd, bfd_byte *p, int r)
6658 {
6659 bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6660 p = p + 4;
6661 bfd_put_32 (abfd, LVX_VR0_R12_R0 + (r << 21), p);
6662 return p + 4;
6663 }
6664
6665 static bfd_byte *
6666 restvr_tail (bfd *abfd, bfd_byte *p, int r)
6667 {
6668 p = restvr (abfd, p, r);
6669 bfd_put_32 (abfd, BLR, p);
6670 return p + 4;
6671 }
6672
6673 /* Called via elf_link_hash_traverse to transfer dynamic linking
6674 information on function code symbol entries to their corresponding
6675 function descriptor symbol entries. */
6676
6677 static bfd_boolean
6678 func_desc_adjust (struct elf_link_hash_entry *h, void *inf)
6679 {
6680 struct bfd_link_info *info;
6681 struct ppc_link_hash_table *htab;
6682 struct plt_entry *ent;
6683 struct ppc_link_hash_entry *fh;
6684 struct ppc_link_hash_entry *fdh;
6685 bfd_boolean force_local;
6686
6687 fh = (struct ppc_link_hash_entry *) h;
6688 if (fh->elf.root.type == bfd_link_hash_indirect)
6689 return TRUE;
6690
6691 info = inf;
6692 htab = ppc_hash_table (info);
6693 if (htab == NULL)
6694 return FALSE;
6695
6696 /* Resolve undefined references to dot-symbols as the value
6697 in the function descriptor, if we have one in a regular object.
6698 This is to satisfy cases like ".quad .foo". Calls to functions
6699 in dynamic objects are handled elsewhere. */
6700 if (fh->elf.root.type == bfd_link_hash_undefweak
6701 && fh->was_undefined
6702 && (fdh = defined_func_desc (fh)) != NULL
6703 && get_opd_info (fdh->elf.root.u.def.section) != NULL
6704 && opd_entry_value (fdh->elf.root.u.def.section,
6705 fdh->elf.root.u.def.value,
6706 &fh->elf.root.u.def.section,
6707 &fh->elf.root.u.def.value, FALSE) != (bfd_vma) -1)
6708 {
6709 fh->elf.root.type = fdh->elf.root.type;
6710 fh->elf.forced_local = 1;
6711 fh->elf.def_regular = fdh->elf.def_regular;
6712 fh->elf.def_dynamic = fdh->elf.def_dynamic;
6713 }
6714
6715 /* If this is a function code symbol, transfer dynamic linking
6716 information to the function descriptor symbol. */
6717 if (!fh->is_func)
6718 return TRUE;
6719
6720 for (ent = fh->elf.plt.plist; ent != NULL; ent = ent->next)
6721 if (ent->plt.refcount > 0)
6722 break;
6723 if (ent == NULL
6724 || fh->elf.root.root.string[0] != '.'
6725 || fh->elf.root.root.string[1] == '\0')
6726 return TRUE;
6727
6728 /* Find the corresponding function descriptor symbol. Create it
6729 as undefined if necessary. */
6730
6731 fdh = lookup_fdh (fh, htab);
6732 if (fdh == NULL
6733 && !info->executable
6734 && (fh->elf.root.type == bfd_link_hash_undefined
6735 || fh->elf.root.type == bfd_link_hash_undefweak))
6736 {
6737 fdh = make_fdh (info, fh);
6738 if (fdh == NULL)
6739 return FALSE;
6740 }
6741
6742 /* Fake function descriptors are made undefweak. If the function
6743 code symbol is strong undefined, make the fake sym the same.
6744 If the function code symbol is defined, then force the fake
6745 descriptor local; We can't support overriding of symbols in a
6746 shared library on a fake descriptor. */
6747
6748 if (fdh != NULL
6749 && fdh->fake
6750 && fdh->elf.root.type == bfd_link_hash_undefweak)
6751 {
6752 if (fh->elf.root.type == bfd_link_hash_undefined)
6753 {
6754 fdh->elf.root.type = bfd_link_hash_undefined;
6755 bfd_link_add_undef (&htab->elf.root, &fdh->elf.root);
6756 }
6757 else if (fh->elf.root.type == bfd_link_hash_defined
6758 || fh->elf.root.type == bfd_link_hash_defweak)
6759 {
6760 _bfd_elf_link_hash_hide_symbol (info, &fdh->elf, TRUE);
6761 }
6762 }
6763
6764 if (fdh != NULL
6765 && !fdh->elf.forced_local
6766 && (!info->executable
6767 || fdh->elf.def_dynamic
6768 || fdh->elf.ref_dynamic
6769 || (fdh->elf.root.type == bfd_link_hash_undefweak
6770 && ELF_ST_VISIBILITY (fdh->elf.other) == STV_DEFAULT)))
6771 {
6772 if (fdh->elf.dynindx == -1)
6773 if (! bfd_elf_link_record_dynamic_symbol (info, &fdh->elf))
6774 return FALSE;
6775 fdh->elf.ref_regular |= fh->elf.ref_regular;
6776 fdh->elf.ref_dynamic |= fh->elf.ref_dynamic;
6777 fdh->elf.ref_regular_nonweak |= fh->elf.ref_regular_nonweak;
6778 fdh->elf.non_got_ref |= fh->elf.non_got_ref;
6779 if (ELF_ST_VISIBILITY (fh->elf.other) == STV_DEFAULT)
6780 {
6781 move_plt_plist (fh, fdh);
6782 fdh->elf.needs_plt = 1;
6783 }
6784 fdh->is_func_descriptor = 1;
6785 fdh->oh = fh;
6786 fh->oh = fdh;
6787 }
6788
6789 /* Now that the info is on the function descriptor, clear the
6790 function code sym info. Any function code syms for which we
6791 don't have a definition in a regular file, we force local.
6792 This prevents a shared library from exporting syms that have
6793 been imported from another library. Function code syms that
6794 are really in the library we must leave global to prevent the
6795 linker dragging in a definition from a static library. */
6796 force_local = (!fh->elf.def_regular
6797 || fdh == NULL
6798 || !fdh->elf.def_regular
6799 || fdh->elf.forced_local);
6800 _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
6801
6802 return TRUE;
6803 }
6804
6805 /* Called near the start of bfd_elf_size_dynamic_sections. We use
6806 this hook to a) provide some gcc support functions, and b) transfer
6807 dynamic linking information gathered so far on function code symbol
6808 entries, to their corresponding function descriptor symbol entries. */
6809
6810 static bfd_boolean
6811 ppc64_elf_func_desc_adjust (bfd *obfd ATTRIBUTE_UNUSED,
6812 struct bfd_link_info *info)
6813 {
6814 struct ppc_link_hash_table *htab;
6815 unsigned int i;
6816 static const struct sfpr_def_parms funcs[] =
6817 {
6818 { "_savegpr0_", 14, 31, savegpr0, savegpr0_tail },
6819 { "_restgpr0_", 14, 29, restgpr0, restgpr0_tail },
6820 { "_restgpr0_", 30, 31, restgpr0, restgpr0_tail },
6821 { "_savegpr1_", 14, 31, savegpr1, savegpr1_tail },
6822 { "_restgpr1_", 14, 31, restgpr1, restgpr1_tail },
6823 { "_savefpr_", 14, 31, savefpr, savefpr0_tail },
6824 { "_restfpr_", 14, 29, restfpr, restfpr0_tail },
6825 { "_restfpr_", 30, 31, restfpr, restfpr0_tail },
6826 { "._savef", 14, 31, savefpr, savefpr1_tail },
6827 { "._restf", 14, 31, restfpr, restfpr1_tail },
6828 { "_savevr_", 20, 31, savevr, savevr_tail },
6829 { "_restvr_", 20, 31, restvr, restvr_tail }
6830 };
6831
6832 htab = ppc_hash_table (info);
6833 if (htab == NULL)
6834 return FALSE;
6835
6836 if (!info->relocatable
6837 && htab->elf.hgot != NULL)
6838 {
6839 _bfd_elf_link_hash_hide_symbol (info, htab->elf.hgot, TRUE);
6840 /* Make .TOC. defined so as to prevent it being made dynamic.
6841 The wrong value here is fixed later in ppc64_elf_set_toc. */
6842 htab->elf.hgot->type = STT_OBJECT;
6843 htab->elf.hgot->root.type = bfd_link_hash_defined;
6844 htab->elf.hgot->root.u.def.value = 0;
6845 htab->elf.hgot->root.u.def.section = bfd_abs_section_ptr;
6846 htab->elf.hgot->def_regular = 1;
6847 htab->elf.hgot->other = ((htab->elf.hgot->other & ~ELF_ST_VISIBILITY (-1))
6848 | STV_HIDDEN);
6849 }
6850
6851 if (htab->sfpr == NULL)
6852 /* We don't have any relocs. */
6853 return TRUE;
6854
6855 /* Provide any missing _save* and _rest* functions. */
6856 htab->sfpr->size = 0;
6857 if (!info->relocatable)
6858 for (i = 0; i < sizeof (funcs) / sizeof (funcs[0]); i++)
6859 if (!sfpr_define (info, &funcs[i]))
6860 return FALSE;
6861
6862 elf_link_hash_traverse (&htab->elf, func_desc_adjust, info);
6863
6864 if (htab->sfpr->size == 0)
6865 htab->sfpr->flags |= SEC_EXCLUDE;
6866
6867 return TRUE;
6868 }
6869
6870 /* Return true if we have dynamic relocs that apply to read-only sections. */
6871
6872 static bfd_boolean
6873 readonly_dynrelocs (struct elf_link_hash_entry *h)
6874 {
6875 struct ppc_link_hash_entry *eh;
6876 struct elf_dyn_relocs *p;
6877
6878 eh = (struct ppc_link_hash_entry *) h;
6879 for (p = eh->dyn_relocs; p != NULL; p = p->next)
6880 {
6881 asection *s = p->sec->output_section;
6882
6883 if (s != NULL && (s->flags & SEC_READONLY) != 0)
6884 return TRUE;
6885 }
6886 return FALSE;
6887 }
6888
6889 /* Adjust a symbol defined by a dynamic object and referenced by a
6890 regular object. The current definition is in some section of the
6891 dynamic object, but we're not including those sections. We have to
6892 change the definition to something the rest of the link can
6893 understand. */
6894
6895 static bfd_boolean
6896 ppc64_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
6897 struct elf_link_hash_entry *h)
6898 {
6899 struct ppc_link_hash_table *htab;
6900 asection *s;
6901
6902 htab = ppc_hash_table (info);
6903 if (htab == NULL)
6904 return FALSE;
6905
6906 /* Deal with function syms. */
6907 if (h->type == STT_FUNC
6908 || h->type == STT_GNU_IFUNC
6909 || h->needs_plt)
6910 {
6911 /* Clear procedure linkage table information for any symbol that
6912 won't need a .plt entry. */
6913 struct plt_entry *ent;
6914 for (ent = h->plt.plist; ent != NULL; ent = ent->next)
6915 if (ent->plt.refcount > 0)
6916 break;
6917 if (ent == NULL
6918 || (h->type != STT_GNU_IFUNC
6919 && (SYMBOL_CALLS_LOCAL (info, h)
6920 || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
6921 && h->root.type == bfd_link_hash_undefweak))))
6922 {
6923 h->plt.plist = NULL;
6924 h->needs_plt = 0;
6925 }
6926 else if (abiversion (info->output_bfd) == 2)
6927 {
6928 /* After adjust_dynamic_symbol, non_got_ref set in the
6929 non-shared case means that we have allocated space in
6930 .dynbss for the symbol and thus dyn_relocs for this
6931 symbol should be discarded.
6932 If we get here we know we are making a PLT entry for this
6933 symbol, and in an executable we'd normally resolve
6934 relocations against this symbol to the PLT entry. Allow
6935 dynamic relocs if the reference is weak, and the dynamic
6936 relocs will not cause text relocation. */
6937 if (!h->ref_regular_nonweak
6938 && h->non_got_ref
6939 && h->type != STT_GNU_IFUNC
6940 && !readonly_dynrelocs (h))
6941 h->non_got_ref = 0;
6942
6943 /* If making a plt entry, then we don't need copy relocs. */
6944 return TRUE;
6945 }
6946 }
6947 else
6948 h->plt.plist = NULL;
6949
6950 /* If this is a weak symbol, and there is a real definition, the
6951 processor independent code will have arranged for us to see the
6952 real definition first, and we can just use the same value. */
6953 if (h->u.weakdef != NULL)
6954 {
6955 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
6956 || h->u.weakdef->root.type == bfd_link_hash_defweak);
6957 h->root.u.def.section = h->u.weakdef->root.u.def.section;
6958 h->root.u.def.value = h->u.weakdef->root.u.def.value;
6959 if (ELIMINATE_COPY_RELOCS)
6960 h->non_got_ref = h->u.weakdef->non_got_ref;
6961 return TRUE;
6962 }
6963
6964 /* If we are creating a shared library, we must presume that the
6965 only references to the symbol are via the global offset table.
6966 For such cases we need not do anything here; the relocations will
6967 be handled correctly by relocate_section. */
6968 if (info->shared)
6969 return TRUE;
6970
6971 /* If there are no references to this symbol that do not use the
6972 GOT, we don't need to generate a copy reloc. */
6973 if (!h->non_got_ref)
6974 return TRUE;
6975
6976 /* Don't generate a copy reloc for symbols defined in the executable. */
6977 if (!h->def_dynamic || !h->ref_regular || h->def_regular)
6978 return TRUE;
6979
6980 /* If we didn't find any dynamic relocs in read-only sections, then
6981 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
6982 if (ELIMINATE_COPY_RELOCS && !readonly_dynrelocs (h))
6983 {
6984 h->non_got_ref = 0;
6985 return TRUE;
6986 }
6987
6988 if (h->plt.plist != NULL)
6989 {
6990 /* We should never get here, but unfortunately there are versions
6991 of gcc out there that improperly (for this ABI) put initialized
6992 function pointers, vtable refs and suchlike in read-only
6993 sections. Allow them to proceed, but warn that this might
6994 break at runtime. */
6995 info->callbacks->einfo
6996 (_("%P: copy reloc against `%T' requires lazy plt linking; "
6997 "avoid setting LD_BIND_NOW=1 or upgrade gcc\n"),
6998 h->root.root.string);
6999 }
7000
7001 /* This is a reference to a symbol defined by a dynamic object which
7002 is not a function. */
7003
7004 /* We must allocate the symbol in our .dynbss section, which will
7005 become part of the .bss section of the executable. There will be
7006 an entry for this symbol in the .dynsym section. The dynamic
7007 object will contain position independent code, so all references
7008 from the dynamic object to this symbol will go through the global
7009 offset table. The dynamic linker will use the .dynsym entry to
7010 determine the address it must put in the global offset table, so
7011 both the dynamic object and the regular object will refer to the
7012 same memory location for the variable. */
7013
7014 /* We must generate a R_PPC64_COPY reloc to tell the dynamic linker
7015 to copy the initial value out of the dynamic object and into the
7016 runtime process image. We need to remember the offset into the
7017 .rela.bss section we are going to use. */
7018 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
7019 {
7020 htab->relbss->size += sizeof (Elf64_External_Rela);
7021 h->needs_copy = 1;
7022 }
7023
7024 s = htab->dynbss;
7025
7026 return _bfd_elf_adjust_dynamic_copy (h, s);
7027 }
7028
7029 /* If given a function descriptor symbol, hide both the function code
7030 sym and the descriptor. */
7031 static void
7032 ppc64_elf_hide_symbol (struct bfd_link_info *info,
7033 struct elf_link_hash_entry *h,
7034 bfd_boolean force_local)
7035 {
7036 struct ppc_link_hash_entry *eh;
7037 _bfd_elf_link_hash_hide_symbol (info, h, force_local);
7038
7039 eh = (struct ppc_link_hash_entry *) h;
7040 if (eh->is_func_descriptor)
7041 {
7042 struct ppc_link_hash_entry *fh = eh->oh;
7043
7044 if (fh == NULL)
7045 {
7046 const char *p, *q;
7047 struct ppc_link_hash_table *htab;
7048 char save;
7049
7050 /* We aren't supposed to use alloca in BFD because on
7051 systems which do not have alloca the version in libiberty
7052 calls xmalloc, which might cause the program to crash
7053 when it runs out of memory. This function doesn't have a
7054 return status, so there's no way to gracefully return an
7055 error. So cheat. We know that string[-1] can be safely
7056 accessed; It's either a string in an ELF string table,
7057 or allocated in an objalloc structure. */
7058
7059 p = eh->elf.root.root.string - 1;
7060 save = *p;
7061 *(char *) p = '.';
7062 htab = ppc_hash_table (info);
7063 if (htab == NULL)
7064 return;
7065
7066 fh = (struct ppc_link_hash_entry *)
7067 elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
7068 *(char *) p = save;
7069
7070 /* Unfortunately, if it so happens that the string we were
7071 looking for was allocated immediately before this string,
7072 then we overwrote the string terminator. That's the only
7073 reason the lookup should fail. */
7074 if (fh == NULL)
7075 {
7076 q = eh->elf.root.root.string + strlen (eh->elf.root.root.string);
7077 while (q >= eh->elf.root.root.string && *q == *p)
7078 --q, --p;
7079 if (q < eh->elf.root.root.string && *p == '.')
7080 fh = (struct ppc_link_hash_entry *)
7081 elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
7082 }
7083 if (fh != NULL)
7084 {
7085 eh->oh = fh;
7086 fh->oh = eh;
7087 }
7088 }
7089 if (fh != NULL)
7090 _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
7091 }
7092 }
7093
7094 static bfd_boolean
7095 get_sym_h (struct elf_link_hash_entry **hp,
7096 Elf_Internal_Sym **symp,
7097 asection **symsecp,
7098 unsigned char **tls_maskp,
7099 Elf_Internal_Sym **locsymsp,
7100 unsigned long r_symndx,
7101 bfd *ibfd)
7102 {
7103 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
7104
7105 if (r_symndx >= symtab_hdr->sh_info)
7106 {
7107 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
7108 struct elf_link_hash_entry *h;
7109
7110 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
7111 h = elf_follow_link (h);
7112
7113 if (hp != NULL)
7114 *hp = h;
7115
7116 if (symp != NULL)
7117 *symp = NULL;
7118
7119 if (symsecp != NULL)
7120 {
7121 asection *symsec = NULL;
7122 if (h->root.type == bfd_link_hash_defined
7123 || h->root.type == bfd_link_hash_defweak)
7124 symsec = h->root.u.def.section;
7125 *symsecp = symsec;
7126 }
7127
7128 if (tls_maskp != NULL)
7129 {
7130 struct ppc_link_hash_entry *eh;
7131
7132 eh = (struct ppc_link_hash_entry *) h;
7133 *tls_maskp = &eh->tls_mask;
7134 }
7135 }
7136 else
7137 {
7138 Elf_Internal_Sym *sym;
7139 Elf_Internal_Sym *locsyms = *locsymsp;
7140
7141 if (locsyms == NULL)
7142 {
7143 locsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
7144 if (locsyms == NULL)
7145 locsyms = bfd_elf_get_elf_syms (ibfd, symtab_hdr,
7146 symtab_hdr->sh_info,
7147 0, NULL, NULL, NULL);
7148 if (locsyms == NULL)
7149 return FALSE;
7150 *locsymsp = locsyms;
7151 }
7152 sym = locsyms + r_symndx;
7153
7154 if (hp != NULL)
7155 *hp = NULL;
7156
7157 if (symp != NULL)
7158 *symp = sym;
7159
7160 if (symsecp != NULL)
7161 *symsecp = bfd_section_from_elf_index (ibfd, sym->st_shndx);
7162
7163 if (tls_maskp != NULL)
7164 {
7165 struct got_entry **lgot_ents;
7166 unsigned char *tls_mask;
7167
7168 tls_mask = NULL;
7169 lgot_ents = elf_local_got_ents (ibfd);
7170 if (lgot_ents != NULL)
7171 {
7172 struct plt_entry **local_plt = (struct plt_entry **)
7173 (lgot_ents + symtab_hdr->sh_info);
7174 unsigned char *lgot_masks = (unsigned char *)
7175 (local_plt + symtab_hdr->sh_info);
7176 tls_mask = &lgot_masks[r_symndx];
7177 }
7178 *tls_maskp = tls_mask;
7179 }
7180 }
7181 return TRUE;
7182 }
7183
7184 /* Returns TLS_MASKP for the given REL symbol. Function return is 0 on
7185 error, 2 on a toc GD type suitable for optimization, 3 on a toc LD
7186 type suitable for optimization, and 1 otherwise. */
7187
7188 static int
7189 get_tls_mask (unsigned char **tls_maskp,
7190 unsigned long *toc_symndx,
7191 bfd_vma *toc_addend,
7192 Elf_Internal_Sym **locsymsp,
7193 const Elf_Internal_Rela *rel,
7194 bfd *ibfd)
7195 {
7196 unsigned long r_symndx;
7197 int next_r;
7198 struct elf_link_hash_entry *h;
7199 Elf_Internal_Sym *sym;
7200 asection *sec;
7201 bfd_vma off;
7202
7203 r_symndx = ELF64_R_SYM (rel->r_info);
7204 if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7205 return 0;
7206
7207 if ((*tls_maskp != NULL && **tls_maskp != 0)
7208 || sec == NULL
7209 || ppc64_elf_section_data (sec) == NULL
7210 || ppc64_elf_section_data (sec)->sec_type != sec_toc)
7211 return 1;
7212
7213 /* Look inside a TOC section too. */
7214 if (h != NULL)
7215 {
7216 BFD_ASSERT (h->root.type == bfd_link_hash_defined);
7217 off = h->root.u.def.value;
7218 }
7219 else
7220 off = sym->st_value;
7221 off += rel->r_addend;
7222 BFD_ASSERT (off % 8 == 0);
7223 r_symndx = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8];
7224 next_r = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8 + 1];
7225 if (toc_symndx != NULL)
7226 *toc_symndx = r_symndx;
7227 if (toc_addend != NULL)
7228 *toc_addend = ppc64_elf_section_data (sec)->u.toc.add[off / 8];
7229 if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7230 return 0;
7231 if ((h == NULL || is_static_defined (h))
7232 && (next_r == -1 || next_r == -2))
7233 return 1 - next_r;
7234 return 1;
7235 }
7236
7237 /* Find (or create) an entry in the tocsave hash table. */
7238
7239 static struct tocsave_entry *
7240 tocsave_find (struct ppc_link_hash_table *htab,
7241 enum insert_option insert,
7242 Elf_Internal_Sym **local_syms,
7243 const Elf_Internal_Rela *irela,
7244 bfd *ibfd)
7245 {
7246 unsigned long r_indx;
7247 struct elf_link_hash_entry *h;
7248 Elf_Internal_Sym *sym;
7249 struct tocsave_entry ent, *p;
7250 hashval_t hash;
7251 struct tocsave_entry **slot;
7252
7253 r_indx = ELF64_R_SYM (irela->r_info);
7254 if (!get_sym_h (&h, &sym, &ent.sec, NULL, local_syms, r_indx, ibfd))
7255 return NULL;
7256 if (ent.sec == NULL || ent.sec->output_section == NULL)
7257 {
7258 (*_bfd_error_handler)
7259 (_("%B: undefined symbol on R_PPC64_TOCSAVE relocation"));
7260 return NULL;
7261 }
7262
7263 if (h != NULL)
7264 ent.offset = h->root.u.def.value;
7265 else
7266 ent.offset = sym->st_value;
7267 ent.offset += irela->r_addend;
7268
7269 hash = tocsave_htab_hash (&ent);
7270 slot = ((struct tocsave_entry **)
7271 htab_find_slot_with_hash (htab->tocsave_htab, &ent, hash, insert));
7272 if (slot == NULL)
7273 return NULL;
7274
7275 if (*slot == NULL)
7276 {
7277 p = (struct tocsave_entry *) bfd_alloc (ibfd, sizeof (*p));
7278 if (p == NULL)
7279 return NULL;
7280 *p = ent;
7281 *slot = p;
7282 }
7283 return *slot;
7284 }
7285
7286 /* Adjust all global syms defined in opd sections. In gcc generated
7287 code for the old ABI, these will already have been done. */
7288
7289 static bfd_boolean
7290 adjust_opd_syms (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
7291 {
7292 struct ppc_link_hash_entry *eh;
7293 asection *sym_sec;
7294 struct _opd_sec_data *opd;
7295
7296 if (h->root.type == bfd_link_hash_indirect)
7297 return TRUE;
7298
7299 if (h->root.type != bfd_link_hash_defined
7300 && h->root.type != bfd_link_hash_defweak)
7301 return TRUE;
7302
7303 eh = (struct ppc_link_hash_entry *) h;
7304 if (eh->adjust_done)
7305 return TRUE;
7306
7307 sym_sec = eh->elf.root.u.def.section;
7308 opd = get_opd_info (sym_sec);
7309 if (opd != NULL && opd->adjust != NULL)
7310 {
7311 long adjust = opd->adjust[eh->elf.root.u.def.value / 8];
7312 if (adjust == -1)
7313 {
7314 /* This entry has been deleted. */
7315 asection *dsec = ppc64_elf_tdata (sym_sec->owner)->deleted_section;
7316 if (dsec == NULL)
7317 {
7318 for (dsec = sym_sec->owner->sections; dsec; dsec = dsec->next)
7319 if (discarded_section (dsec))
7320 {
7321 ppc64_elf_tdata (sym_sec->owner)->deleted_section = dsec;
7322 break;
7323 }
7324 }
7325 eh->elf.root.u.def.value = 0;
7326 eh->elf.root.u.def.section = dsec;
7327 }
7328 else
7329 eh->elf.root.u.def.value += adjust;
7330 eh->adjust_done = 1;
7331 }
7332 return TRUE;
7333 }
7334
7335 /* Handles decrementing dynamic reloc counts for the reloc specified by
7336 R_INFO in section SEC. If LOCAL_SYMS is NULL, then H and SYM
7337 have already been determined. */
7338
7339 static bfd_boolean
7340 dec_dynrel_count (bfd_vma r_info,
7341 asection *sec,
7342 struct bfd_link_info *info,
7343 Elf_Internal_Sym **local_syms,
7344 struct elf_link_hash_entry *h,
7345 Elf_Internal_Sym *sym)
7346 {
7347 enum elf_ppc64_reloc_type r_type;
7348 asection *sym_sec = NULL;
7349
7350 /* Can this reloc be dynamic? This switch, and later tests here
7351 should be kept in sync with the code in check_relocs. */
7352 r_type = ELF64_R_TYPE (r_info);
7353 switch (r_type)
7354 {
7355 default:
7356 return TRUE;
7357
7358 case R_PPC64_TPREL16:
7359 case R_PPC64_TPREL16_LO:
7360 case R_PPC64_TPREL16_HI:
7361 case R_PPC64_TPREL16_HA:
7362 case R_PPC64_TPREL16_DS:
7363 case R_PPC64_TPREL16_LO_DS:
7364 case R_PPC64_TPREL16_HIGH:
7365 case R_PPC64_TPREL16_HIGHA:
7366 case R_PPC64_TPREL16_HIGHER:
7367 case R_PPC64_TPREL16_HIGHERA:
7368 case R_PPC64_TPREL16_HIGHEST:
7369 case R_PPC64_TPREL16_HIGHESTA:
7370 if (!info->shared)
7371 return TRUE;
7372
7373 case R_PPC64_TPREL64:
7374 case R_PPC64_DTPMOD64:
7375 case R_PPC64_DTPREL64:
7376 case R_PPC64_ADDR64:
7377 case R_PPC64_REL30:
7378 case R_PPC64_REL32:
7379 case R_PPC64_REL64:
7380 case R_PPC64_ADDR14:
7381 case R_PPC64_ADDR14_BRNTAKEN:
7382 case R_PPC64_ADDR14_BRTAKEN:
7383 case R_PPC64_ADDR16:
7384 case R_PPC64_ADDR16_DS:
7385 case R_PPC64_ADDR16_HA:
7386 case R_PPC64_ADDR16_HI:
7387 case R_PPC64_ADDR16_HIGH:
7388 case R_PPC64_ADDR16_HIGHA:
7389 case R_PPC64_ADDR16_HIGHER:
7390 case R_PPC64_ADDR16_HIGHERA:
7391 case R_PPC64_ADDR16_HIGHEST:
7392 case R_PPC64_ADDR16_HIGHESTA:
7393 case R_PPC64_ADDR16_LO:
7394 case R_PPC64_ADDR16_LO_DS:
7395 case R_PPC64_ADDR24:
7396 case R_PPC64_ADDR32:
7397 case R_PPC64_UADDR16:
7398 case R_PPC64_UADDR32:
7399 case R_PPC64_UADDR64:
7400 case R_PPC64_TOC:
7401 break;
7402 }
7403
7404 if (local_syms != NULL)
7405 {
7406 unsigned long r_symndx;
7407 bfd *ibfd = sec->owner;
7408
7409 r_symndx = ELF64_R_SYM (r_info);
7410 if (!get_sym_h (&h, &sym, &sym_sec, NULL, local_syms, r_symndx, ibfd))
7411 return FALSE;
7412 }
7413
7414 if ((info->shared
7415 && (must_be_dyn_reloc (info, r_type)
7416 || (h != NULL
7417 && (!SYMBOLIC_BIND (info, h)
7418 || h->root.type == bfd_link_hash_defweak
7419 || !h->def_regular))))
7420 || (ELIMINATE_COPY_RELOCS
7421 && !info->shared
7422 && h != NULL
7423 && (h->root.type == bfd_link_hash_defweak
7424 || !h->def_regular)))
7425 ;
7426 else
7427 return TRUE;
7428
7429 if (h != NULL)
7430 {
7431 struct elf_dyn_relocs *p;
7432 struct elf_dyn_relocs **pp;
7433 pp = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
7434
7435 /* elf_gc_sweep may have already removed all dyn relocs associated
7436 with local syms for a given section. Also, symbol flags are
7437 changed by elf_gc_sweep_symbol, confusing the test above. Don't
7438 report a dynreloc miscount. */
7439 if (*pp == NULL && info->gc_sections)
7440 return TRUE;
7441
7442 while ((p = *pp) != NULL)
7443 {
7444 if (p->sec == sec)
7445 {
7446 if (!must_be_dyn_reloc (info, r_type))
7447 p->pc_count -= 1;
7448 p->count -= 1;
7449 if (p->count == 0)
7450 *pp = p->next;
7451 return TRUE;
7452 }
7453 pp = &p->next;
7454 }
7455 }
7456 else
7457 {
7458 struct ppc_dyn_relocs *p;
7459 struct ppc_dyn_relocs **pp;
7460 void *vpp;
7461 bfd_boolean is_ifunc;
7462
7463 if (local_syms == NULL)
7464 sym_sec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
7465 if (sym_sec == NULL)
7466 sym_sec = sec;
7467
7468 vpp = &elf_section_data (sym_sec)->local_dynrel;
7469 pp = (struct ppc_dyn_relocs **) vpp;
7470
7471 if (*pp == NULL && info->gc_sections)
7472 return TRUE;
7473
7474 is_ifunc = ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC;
7475 while ((p = *pp) != NULL)
7476 {
7477 if (p->sec == sec && p->ifunc == is_ifunc)
7478 {
7479 p->count -= 1;
7480 if (p->count == 0)
7481 *pp = p->next;
7482 return TRUE;
7483 }
7484 pp = &p->next;
7485 }
7486 }
7487
7488 info->callbacks->einfo (_("%P: dynreloc miscount for %B, section %A\n"),
7489 sec->owner, sec);
7490 bfd_set_error (bfd_error_bad_value);
7491 return FALSE;
7492 }
7493
7494 /* Remove unused Official Procedure Descriptor entries. Currently we
7495 only remove those associated with functions in discarded link-once
7496 sections, or weakly defined functions that have been overridden. It
7497 would be possible to remove many more entries for statically linked
7498 applications. */
7499
7500 bfd_boolean
7501 ppc64_elf_edit_opd (struct bfd_link_info *info, bfd_boolean non_overlapping)
7502 {
7503 bfd *ibfd;
7504 bfd_boolean some_edited = FALSE;
7505 asection *need_pad = NULL;
7506
7507 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
7508 {
7509 asection *sec;
7510 Elf_Internal_Rela *relstart, *rel, *relend;
7511 Elf_Internal_Shdr *symtab_hdr;
7512 Elf_Internal_Sym *local_syms;
7513 bfd_vma offset;
7514 struct _opd_sec_data *opd;
7515 bfd_boolean need_edit, add_aux_fields;
7516 bfd_size_type cnt_16b = 0;
7517
7518 if (!is_ppc64_elf (ibfd))
7519 continue;
7520
7521 sec = bfd_get_section_by_name (ibfd, ".opd");
7522 if (sec == NULL || sec->size == 0)
7523 continue;
7524
7525 if (sec->sec_info_type == SEC_INFO_TYPE_JUST_SYMS)
7526 continue;
7527
7528 if (sec->output_section == bfd_abs_section_ptr)
7529 continue;
7530
7531 /* Look through the section relocs. */
7532 if ((sec->flags & SEC_RELOC) == 0 || sec->reloc_count == 0)
7533 continue;
7534
7535 local_syms = NULL;
7536 symtab_hdr = &elf_symtab_hdr (ibfd);
7537
7538 /* Read the relocations. */
7539 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
7540 info->keep_memory);
7541 if (relstart == NULL)
7542 return FALSE;
7543
7544 /* First run through the relocs to check they are sane, and to
7545 determine whether we need to edit this opd section. */
7546 need_edit = FALSE;
7547 need_pad = sec;
7548 offset = 0;
7549 relend = relstart + sec->reloc_count;
7550 for (rel = relstart; rel < relend; )
7551 {
7552 enum elf_ppc64_reloc_type r_type;
7553 unsigned long r_symndx;
7554 asection *sym_sec;
7555 struct elf_link_hash_entry *h;
7556 Elf_Internal_Sym *sym;
7557
7558 /* .opd contains a regular array of 16 or 24 byte entries. We're
7559 only interested in the reloc pointing to a function entry
7560 point. */
7561 if (rel->r_offset != offset
7562 || rel + 1 >= relend
7563 || (rel + 1)->r_offset != offset + 8)
7564 {
7565 /* If someone messes with .opd alignment then after a
7566 "ld -r" we might have padding in the middle of .opd.
7567 Also, there's nothing to prevent someone putting
7568 something silly in .opd with the assembler. No .opd
7569 optimization for them! */
7570 broken_opd:
7571 (*_bfd_error_handler)
7572 (_("%B: .opd is not a regular array of opd entries"), ibfd);
7573 need_edit = FALSE;
7574 break;
7575 }
7576
7577 if ((r_type = ELF64_R_TYPE (rel->r_info)) != R_PPC64_ADDR64
7578 || (r_type = ELF64_R_TYPE ((rel + 1)->r_info)) != R_PPC64_TOC)
7579 {
7580 (*_bfd_error_handler)
7581 (_("%B: unexpected reloc type %u in .opd section"),
7582 ibfd, r_type);
7583 need_edit = FALSE;
7584 break;
7585 }
7586
7587 r_symndx = ELF64_R_SYM (rel->r_info);
7588 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7589 r_symndx, ibfd))
7590 goto error_ret;
7591
7592 if (sym_sec == NULL || sym_sec->owner == NULL)
7593 {
7594 const char *sym_name;
7595 if (h != NULL)
7596 sym_name = h->root.root.string;
7597 else
7598 sym_name = bfd_elf_sym_name (ibfd, symtab_hdr, sym,
7599 sym_sec);
7600
7601 (*_bfd_error_handler)
7602 (_("%B: undefined sym `%s' in .opd section"),
7603 ibfd, sym_name);
7604 need_edit = FALSE;
7605 break;
7606 }
7607
7608 /* opd entries are always for functions defined in the
7609 current input bfd. If the symbol isn't defined in the
7610 input bfd, then we won't be using the function in this
7611 bfd; It must be defined in a linkonce section in another
7612 bfd, or is weak. It's also possible that we are
7613 discarding the function due to a linker script /DISCARD/,
7614 which we test for via the output_section. */
7615 if (sym_sec->owner != ibfd
7616 || sym_sec->output_section == bfd_abs_section_ptr)
7617 need_edit = TRUE;
7618
7619 rel += 2;
7620 if (rel == relend
7621 || (rel + 1 == relend && rel->r_offset == offset + 16))
7622 {
7623 if (sec->size == offset + 24)
7624 {
7625 need_pad = NULL;
7626 break;
7627 }
7628 if (rel == relend && sec->size == offset + 16)
7629 {
7630 cnt_16b++;
7631 break;
7632 }
7633 goto broken_opd;
7634 }
7635
7636 if (rel->r_offset == offset + 24)
7637 offset += 24;
7638 else if (rel->r_offset != offset + 16)
7639 goto broken_opd;
7640 else if (rel + 1 < relend
7641 && ELF64_R_TYPE (rel[0].r_info) == R_PPC64_ADDR64
7642 && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOC)
7643 {
7644 offset += 16;
7645 cnt_16b++;
7646 }
7647 else if (rel + 2 < relend
7648 && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_ADDR64
7649 && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_TOC)
7650 {
7651 offset += 24;
7652 rel += 1;
7653 }
7654 else
7655 goto broken_opd;
7656 }
7657
7658 add_aux_fields = non_overlapping && cnt_16b > 0;
7659
7660 if (need_edit || add_aux_fields)
7661 {
7662 Elf_Internal_Rela *write_rel;
7663 Elf_Internal_Shdr *rel_hdr;
7664 bfd_byte *rptr, *wptr;
7665 bfd_byte *new_contents;
7666 bfd_boolean skip;
7667 long opd_ent_size;
7668 bfd_size_type amt;
7669
7670 new_contents = NULL;
7671 amt = sec->size * sizeof (long) / 8;
7672 opd = &ppc64_elf_section_data (sec)->u.opd;
7673 opd->adjust = bfd_zalloc (sec->owner, amt);
7674 if (opd->adjust == NULL)
7675 return FALSE;
7676 ppc64_elf_section_data (sec)->sec_type = sec_opd;
7677
7678 /* This seems a waste of time as input .opd sections are all
7679 zeros as generated by gcc, but I suppose there's no reason
7680 this will always be so. We might start putting something in
7681 the third word of .opd entries. */
7682 if ((sec->flags & SEC_IN_MEMORY) == 0)
7683 {
7684 bfd_byte *loc;
7685 if (!bfd_malloc_and_get_section (ibfd, sec, &loc))
7686 {
7687 if (loc != NULL)
7688 free (loc);
7689 error_ret:
7690 if (local_syms != NULL
7691 && symtab_hdr->contents != (unsigned char *) local_syms)
7692 free (local_syms);
7693 if (elf_section_data (sec)->relocs != relstart)
7694 free (relstart);
7695 return FALSE;
7696 }
7697 sec->contents = loc;
7698 sec->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
7699 }
7700
7701 elf_section_data (sec)->relocs = relstart;
7702
7703 new_contents = sec->contents;
7704 if (add_aux_fields)
7705 {
7706 new_contents = bfd_malloc (sec->size + cnt_16b * 8);
7707 if (new_contents == NULL)
7708 return FALSE;
7709 need_pad = FALSE;
7710 }
7711 wptr = new_contents;
7712 rptr = sec->contents;
7713
7714 write_rel = relstart;
7715 skip = FALSE;
7716 offset = 0;
7717 opd_ent_size = 0;
7718 for (rel = relstart; rel < relend; rel++)
7719 {
7720 unsigned long r_symndx;
7721 asection *sym_sec;
7722 struct elf_link_hash_entry *h;
7723 Elf_Internal_Sym *sym;
7724
7725 r_symndx = ELF64_R_SYM (rel->r_info);
7726 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7727 r_symndx, ibfd))
7728 goto error_ret;
7729
7730 if (rel->r_offset == offset)
7731 {
7732 struct ppc_link_hash_entry *fdh = NULL;
7733
7734 /* See if the .opd entry is full 24 byte or
7735 16 byte (with fd_aux entry overlapped with next
7736 fd_func). */
7737 opd_ent_size = 24;
7738 if ((rel + 2 == relend && sec->size == offset + 16)
7739 || (rel + 3 < relend
7740 && rel[2].r_offset == offset + 16
7741 && rel[3].r_offset == offset + 24
7742 && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_ADDR64
7743 && ELF64_R_TYPE (rel[3].r_info) == R_PPC64_TOC))
7744 opd_ent_size = 16;
7745
7746 if (h != NULL
7747 && h->root.root.string[0] == '.')
7748 {
7749 struct ppc_link_hash_table *htab;
7750
7751 htab = ppc_hash_table (info);
7752 if (htab != NULL)
7753 fdh = lookup_fdh ((struct ppc_link_hash_entry *) h,
7754 htab);
7755 if (fdh != NULL
7756 && fdh->elf.root.type != bfd_link_hash_defined
7757 && fdh->elf.root.type != bfd_link_hash_defweak)
7758 fdh = NULL;
7759 }
7760
7761 skip = (sym_sec->owner != ibfd
7762 || sym_sec->output_section == bfd_abs_section_ptr);
7763 if (skip)
7764 {
7765 if (fdh != NULL && sym_sec->owner == ibfd)
7766 {
7767 /* Arrange for the function descriptor sym
7768 to be dropped. */
7769 fdh->elf.root.u.def.value = 0;
7770 fdh->elf.root.u.def.section = sym_sec;
7771 }
7772 opd->adjust[rel->r_offset / 8] = -1;
7773 }
7774 else
7775 {
7776 /* We'll be keeping this opd entry. */
7777
7778 if (fdh != NULL)
7779 {
7780 /* Redefine the function descriptor symbol to
7781 this location in the opd section. It is
7782 necessary to update the value here rather
7783 than using an array of adjustments as we do
7784 for local symbols, because various places
7785 in the generic ELF code use the value
7786 stored in u.def.value. */
7787 fdh->elf.root.u.def.value = wptr - new_contents;
7788 fdh->adjust_done = 1;
7789 }
7790
7791 /* Local syms are a bit tricky. We could
7792 tweak them as they can be cached, but
7793 we'd need to look through the local syms
7794 for the function descriptor sym which we
7795 don't have at the moment. So keep an
7796 array of adjustments. */
7797 opd->adjust[rel->r_offset / 8]
7798 = (wptr - new_contents) - (rptr - sec->contents);
7799
7800 if (wptr != rptr)
7801 memcpy (wptr, rptr, opd_ent_size);
7802 wptr += opd_ent_size;
7803 if (add_aux_fields && opd_ent_size == 16)
7804 {
7805 memset (wptr, '\0', 8);
7806 wptr += 8;
7807 }
7808 }
7809 rptr += opd_ent_size;
7810 offset += opd_ent_size;
7811 }
7812
7813 if (skip)
7814 {
7815 if (!NO_OPD_RELOCS
7816 && !info->relocatable
7817 && !dec_dynrel_count (rel->r_info, sec, info,
7818 NULL, h, sym))
7819 goto error_ret;
7820 }
7821 else
7822 {
7823 /* We need to adjust any reloc offsets to point to the
7824 new opd entries. While we're at it, we may as well
7825 remove redundant relocs. */
7826 rel->r_offset += opd->adjust[(offset - opd_ent_size) / 8];
7827 if (write_rel != rel)
7828 memcpy (write_rel, rel, sizeof (*rel));
7829 ++write_rel;
7830 }
7831 }
7832
7833 sec->size = wptr - new_contents;
7834 sec->reloc_count = write_rel - relstart;
7835 if (add_aux_fields)
7836 {
7837 free (sec->contents);
7838 sec->contents = new_contents;
7839 }
7840
7841 /* Fudge the header size too, as this is used later in
7842 elf_bfd_final_link if we are emitting relocs. */
7843 rel_hdr = _bfd_elf_single_rel_hdr (sec);
7844 rel_hdr->sh_size = sec->reloc_count * rel_hdr->sh_entsize;
7845 some_edited = TRUE;
7846 }
7847 else if (elf_section_data (sec)->relocs != relstart)
7848 free (relstart);
7849
7850 if (local_syms != NULL
7851 && symtab_hdr->contents != (unsigned char *) local_syms)
7852 {
7853 if (!info->keep_memory)
7854 free (local_syms);
7855 else
7856 symtab_hdr->contents = (unsigned char *) local_syms;
7857 }
7858 }
7859
7860 if (some_edited)
7861 elf_link_hash_traverse (elf_hash_table (info), adjust_opd_syms, NULL);
7862
7863 /* If we are doing a final link and the last .opd entry is just 16 byte
7864 long, add a 8 byte padding after it. */
7865 if (need_pad != NULL && !info->relocatable)
7866 {
7867 bfd_byte *p;
7868
7869 if ((need_pad->flags & SEC_IN_MEMORY) == 0)
7870 {
7871 BFD_ASSERT (need_pad->size > 0);
7872
7873 p = bfd_malloc (need_pad->size + 8);
7874 if (p == NULL)
7875 return FALSE;
7876
7877 if (! bfd_get_section_contents (need_pad->owner, need_pad,
7878 p, 0, need_pad->size))
7879 return FALSE;
7880
7881 need_pad->contents = p;
7882 need_pad->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
7883 }
7884 else
7885 {
7886 p = bfd_realloc (need_pad->contents, need_pad->size + 8);
7887 if (p == NULL)
7888 return FALSE;
7889
7890 need_pad->contents = p;
7891 }
7892
7893 memset (need_pad->contents + need_pad->size, 0, 8);
7894 need_pad->size += 8;
7895 }
7896
7897 return TRUE;
7898 }
7899
7900 /* Set htab->tls_get_addr and call the generic ELF tls_setup function. */
7901
7902 asection *
7903 ppc64_elf_tls_setup (struct bfd_link_info *info,
7904 int no_tls_get_addr_opt,
7905 int *no_multi_toc)
7906 {
7907 struct ppc_link_hash_table *htab;
7908
7909 htab = ppc_hash_table (info);
7910 if (htab == NULL)
7911 return NULL;
7912
7913 if (abiversion (info->output_bfd) == 1)
7914 htab->opd_abi = 1;
7915
7916 if (*no_multi_toc)
7917 htab->do_multi_toc = 0;
7918 else if (!htab->do_multi_toc)
7919 *no_multi_toc = 1;
7920
7921 htab->tls_get_addr = ((struct ppc_link_hash_entry *)
7922 elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
7923 FALSE, FALSE, TRUE));
7924 /* Move dynamic linking info to the function descriptor sym. */
7925 if (htab->tls_get_addr != NULL)
7926 func_desc_adjust (&htab->tls_get_addr->elf, info);
7927 htab->tls_get_addr_fd = ((struct ppc_link_hash_entry *)
7928 elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
7929 FALSE, FALSE, TRUE));
7930 if (!no_tls_get_addr_opt)
7931 {
7932 struct elf_link_hash_entry *opt, *opt_fd, *tga, *tga_fd;
7933
7934 opt = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr_opt",
7935 FALSE, FALSE, TRUE);
7936 if (opt != NULL)
7937 func_desc_adjust (opt, info);
7938 opt_fd = elf_link_hash_lookup (&htab->elf, "__tls_get_addr_opt",
7939 FALSE, FALSE, TRUE);
7940 if (opt_fd != NULL
7941 && (opt_fd->root.type == bfd_link_hash_defined
7942 || opt_fd->root.type == bfd_link_hash_defweak))
7943 {
7944 /* If glibc supports an optimized __tls_get_addr call stub,
7945 signalled by the presence of __tls_get_addr_opt, and we'll
7946 be calling __tls_get_addr via a plt call stub, then
7947 make __tls_get_addr point to __tls_get_addr_opt. */
7948 tga_fd = &htab->tls_get_addr_fd->elf;
7949 if (htab->elf.dynamic_sections_created
7950 && tga_fd != NULL
7951 && (tga_fd->type == STT_FUNC
7952 || tga_fd->needs_plt)
7953 && !(SYMBOL_CALLS_LOCAL (info, tga_fd)
7954 || (ELF_ST_VISIBILITY (tga_fd->other) != STV_DEFAULT
7955 && tga_fd->root.type == bfd_link_hash_undefweak)))
7956 {
7957 struct plt_entry *ent;
7958
7959 for (ent = tga_fd->plt.plist; ent != NULL; ent = ent->next)
7960 if (ent->plt.refcount > 0)
7961 break;
7962 if (ent != NULL)
7963 {
7964 tga_fd->root.type = bfd_link_hash_indirect;
7965 tga_fd->root.u.i.link = &opt_fd->root;
7966 ppc64_elf_copy_indirect_symbol (info, opt_fd, tga_fd);
7967 if (opt_fd->dynindx != -1)
7968 {
7969 /* Use __tls_get_addr_opt in dynamic relocations. */
7970 opt_fd->dynindx = -1;
7971 _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
7972 opt_fd->dynstr_index);
7973 if (!bfd_elf_link_record_dynamic_symbol (info, opt_fd))
7974 return NULL;
7975 }
7976 htab->tls_get_addr_fd = (struct ppc_link_hash_entry *) opt_fd;
7977 tga = &htab->tls_get_addr->elf;
7978 if (opt != NULL && tga != NULL)
7979 {
7980 tga->root.type = bfd_link_hash_indirect;
7981 tga->root.u.i.link = &opt->root;
7982 ppc64_elf_copy_indirect_symbol (info, opt, tga);
7983 _bfd_elf_link_hash_hide_symbol (info, opt,
7984 tga->forced_local);
7985 htab->tls_get_addr = (struct ppc_link_hash_entry *) opt;
7986 }
7987 htab->tls_get_addr_fd->oh = htab->tls_get_addr;
7988 htab->tls_get_addr_fd->is_func_descriptor = 1;
7989 if (htab->tls_get_addr != NULL)
7990 {
7991 htab->tls_get_addr->oh = htab->tls_get_addr_fd;
7992 htab->tls_get_addr->is_func = 1;
7993 }
7994 }
7995 }
7996 }
7997 else
7998 no_tls_get_addr_opt = TRUE;
7999 }
8000 htab->no_tls_get_addr_opt = no_tls_get_addr_opt;
8001 return _bfd_elf_tls_setup (info->output_bfd, info);
8002 }
8003
8004 /* Return TRUE iff REL is a branch reloc with a global symbol matching
8005 HASH1 or HASH2. */
8006
8007 static bfd_boolean
8008 branch_reloc_hash_match (const bfd *ibfd,
8009 const Elf_Internal_Rela *rel,
8010 const struct ppc_link_hash_entry *hash1,
8011 const struct ppc_link_hash_entry *hash2)
8012 {
8013 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
8014 enum elf_ppc64_reloc_type r_type = ELF64_R_TYPE (rel->r_info);
8015 unsigned int r_symndx = ELF64_R_SYM (rel->r_info);
8016
8017 if (r_symndx >= symtab_hdr->sh_info && is_branch_reloc (r_type))
8018 {
8019 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
8020 struct elf_link_hash_entry *h;
8021
8022 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
8023 h = elf_follow_link (h);
8024 if (h == &hash1->elf || h == &hash2->elf)
8025 return TRUE;
8026 }
8027 return FALSE;
8028 }
8029
8030 /* Run through all the TLS relocs looking for optimization
8031 opportunities. The linker has been hacked (see ppc64elf.em) to do
8032 a preliminary section layout so that we know the TLS segment
8033 offsets. We can't optimize earlier because some optimizations need
8034 to know the tp offset, and we need to optimize before allocating
8035 dynamic relocations. */
8036
8037 bfd_boolean
8038 ppc64_elf_tls_optimize (struct bfd_link_info *info)
8039 {
8040 bfd *ibfd;
8041 asection *sec;
8042 struct ppc_link_hash_table *htab;
8043 unsigned char *toc_ref;
8044 int pass;
8045
8046 if (info->relocatable || !info->executable)
8047 return TRUE;
8048
8049 htab = ppc_hash_table (info);
8050 if (htab == NULL)
8051 return FALSE;
8052
8053 /* Make two passes over the relocs. On the first pass, mark toc
8054 entries involved with tls relocs, and check that tls relocs
8055 involved in setting up a tls_get_addr call are indeed followed by
8056 such a call. If they are not, we can't do any tls optimization.
8057 On the second pass twiddle tls_mask flags to notify
8058 relocate_section that optimization can be done, and adjust got
8059 and plt refcounts. */
8060 toc_ref = NULL;
8061 for (pass = 0; pass < 2; ++pass)
8062 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
8063 {
8064 Elf_Internal_Sym *locsyms = NULL;
8065 asection *toc = bfd_get_section_by_name (ibfd, ".toc");
8066
8067 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8068 if (sec->has_tls_reloc && !bfd_is_abs_section (sec->output_section))
8069 {
8070 Elf_Internal_Rela *relstart, *rel, *relend;
8071 bfd_boolean found_tls_get_addr_arg = 0;
8072
8073 /* Read the relocations. */
8074 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8075 info->keep_memory);
8076 if (relstart == NULL)
8077 return FALSE;
8078
8079 relend = relstart + sec->reloc_count;
8080 for (rel = relstart; rel < relend; rel++)
8081 {
8082 enum elf_ppc64_reloc_type r_type;
8083 unsigned long r_symndx;
8084 struct elf_link_hash_entry *h;
8085 Elf_Internal_Sym *sym;
8086 asection *sym_sec;
8087 unsigned char *tls_mask;
8088 unsigned char tls_set, tls_clear, tls_type = 0;
8089 bfd_vma value;
8090 bfd_boolean ok_tprel, is_local;
8091 long toc_ref_index = 0;
8092 int expecting_tls_get_addr = 0;
8093 bfd_boolean ret = FALSE;
8094
8095 r_symndx = ELF64_R_SYM (rel->r_info);
8096 if (!get_sym_h (&h, &sym, &sym_sec, &tls_mask, &locsyms,
8097 r_symndx, ibfd))
8098 {
8099 err_free_rel:
8100 if (elf_section_data (sec)->relocs != relstart)
8101 free (relstart);
8102 if (toc_ref != NULL)
8103 free (toc_ref);
8104 if (locsyms != NULL
8105 && (elf_symtab_hdr (ibfd).contents
8106 != (unsigned char *) locsyms))
8107 free (locsyms);
8108 return ret;
8109 }
8110
8111 if (h != NULL)
8112 {
8113 if (h->root.type == bfd_link_hash_defined
8114 || h->root.type == bfd_link_hash_defweak)
8115 value = h->root.u.def.value;
8116 else if (h->root.type == bfd_link_hash_undefweak)
8117 value = 0;
8118 else
8119 {
8120 found_tls_get_addr_arg = 0;
8121 continue;
8122 }
8123 }
8124 else
8125 /* Symbols referenced by TLS relocs must be of type
8126 STT_TLS. So no need for .opd local sym adjust. */
8127 value = sym->st_value;
8128
8129 ok_tprel = FALSE;
8130 is_local = FALSE;
8131 if (h == NULL
8132 || !h->def_dynamic)
8133 {
8134 is_local = TRUE;
8135 if (h != NULL
8136 && h->root.type == bfd_link_hash_undefweak)
8137 ok_tprel = TRUE;
8138 else
8139 {
8140 value += sym_sec->output_offset;
8141 value += sym_sec->output_section->vma;
8142 value -= htab->elf.tls_sec->vma;
8143 ok_tprel = (value + TP_OFFSET + ((bfd_vma) 1 << 31)
8144 < (bfd_vma) 1 << 32);
8145 }
8146 }
8147
8148 r_type = ELF64_R_TYPE (rel->r_info);
8149 /* If this section has old-style __tls_get_addr calls
8150 without marker relocs, then check that each
8151 __tls_get_addr call reloc is preceded by a reloc
8152 that conceivably belongs to the __tls_get_addr arg
8153 setup insn. If we don't find matching arg setup
8154 relocs, don't do any tls optimization. */
8155 if (pass == 0
8156 && sec->has_tls_get_addr_call
8157 && h != NULL
8158 && (h == &htab->tls_get_addr->elf
8159 || h == &htab->tls_get_addr_fd->elf)
8160 && !found_tls_get_addr_arg
8161 && is_branch_reloc (r_type))
8162 {
8163 info->callbacks->minfo (_("%H __tls_get_addr lost arg, "
8164 "TLS optimization disabled\n"),
8165 ibfd, sec, rel->r_offset);
8166 ret = TRUE;
8167 goto err_free_rel;
8168 }
8169
8170 found_tls_get_addr_arg = 0;
8171 switch (r_type)
8172 {
8173 case R_PPC64_GOT_TLSLD16:
8174 case R_PPC64_GOT_TLSLD16_LO:
8175 expecting_tls_get_addr = 1;
8176 found_tls_get_addr_arg = 1;
8177 /* Fall thru */
8178
8179 case R_PPC64_GOT_TLSLD16_HI:
8180 case R_PPC64_GOT_TLSLD16_HA:
8181 /* These relocs should never be against a symbol
8182 defined in a shared lib. Leave them alone if
8183 that turns out to be the case. */
8184 if (!is_local)
8185 continue;
8186
8187 /* LD -> LE */
8188 tls_set = 0;
8189 tls_clear = TLS_LD;
8190 tls_type = TLS_TLS | TLS_LD;
8191 break;
8192
8193 case R_PPC64_GOT_TLSGD16:
8194 case R_PPC64_GOT_TLSGD16_LO:
8195 expecting_tls_get_addr = 1;
8196 found_tls_get_addr_arg = 1;
8197 /* Fall thru */
8198
8199 case R_PPC64_GOT_TLSGD16_HI:
8200 case R_PPC64_GOT_TLSGD16_HA:
8201 if (ok_tprel)
8202 /* GD -> LE */
8203 tls_set = 0;
8204 else
8205 /* GD -> IE */
8206 tls_set = TLS_TLS | TLS_TPRELGD;
8207 tls_clear = TLS_GD;
8208 tls_type = TLS_TLS | TLS_GD;
8209 break;
8210
8211 case R_PPC64_GOT_TPREL16_DS:
8212 case R_PPC64_GOT_TPREL16_LO_DS:
8213 case R_PPC64_GOT_TPREL16_HI:
8214 case R_PPC64_GOT_TPREL16_HA:
8215 if (ok_tprel)
8216 {
8217 /* IE -> LE */
8218 tls_set = 0;
8219 tls_clear = TLS_TPREL;
8220 tls_type = TLS_TLS | TLS_TPREL;
8221 break;
8222 }
8223 continue;
8224
8225 case R_PPC64_TLSGD:
8226 case R_PPC64_TLSLD:
8227 found_tls_get_addr_arg = 1;
8228 /* Fall thru */
8229
8230 case R_PPC64_TLS:
8231 case R_PPC64_TOC16:
8232 case R_PPC64_TOC16_LO:
8233 if (sym_sec == NULL || sym_sec != toc)
8234 continue;
8235
8236 /* Mark this toc entry as referenced by a TLS
8237 code sequence. We can do that now in the
8238 case of R_PPC64_TLS, and after checking for
8239 tls_get_addr for the TOC16 relocs. */
8240 if (toc_ref == NULL)
8241 toc_ref = bfd_zmalloc (toc->output_section->rawsize / 8);
8242 if (toc_ref == NULL)
8243 goto err_free_rel;
8244
8245 if (h != NULL)
8246 value = h->root.u.def.value;
8247 else
8248 value = sym->st_value;
8249 value += rel->r_addend;
8250 BFD_ASSERT (value < toc->size && value % 8 == 0);
8251 toc_ref_index = (value + toc->output_offset) / 8;
8252 if (r_type == R_PPC64_TLS
8253 || r_type == R_PPC64_TLSGD
8254 || r_type == R_PPC64_TLSLD)
8255 {
8256 toc_ref[toc_ref_index] = 1;
8257 continue;
8258 }
8259
8260 if (pass != 0 && toc_ref[toc_ref_index] == 0)
8261 continue;
8262
8263 tls_set = 0;
8264 tls_clear = 0;
8265 expecting_tls_get_addr = 2;
8266 break;
8267
8268 case R_PPC64_TPREL64:
8269 if (pass == 0
8270 || sec != toc
8271 || toc_ref == NULL
8272 || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
8273 continue;
8274 if (ok_tprel)
8275 {
8276 /* IE -> LE */
8277 tls_set = TLS_EXPLICIT;
8278 tls_clear = TLS_TPREL;
8279 break;
8280 }
8281 continue;
8282
8283 case R_PPC64_DTPMOD64:
8284 if (pass == 0
8285 || sec != toc
8286 || toc_ref == NULL
8287 || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
8288 continue;
8289 if (rel + 1 < relend
8290 && (rel[1].r_info
8291 == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64))
8292 && rel[1].r_offset == rel->r_offset + 8)
8293 {
8294 if (ok_tprel)
8295 /* GD -> LE */
8296 tls_set = TLS_EXPLICIT | TLS_GD;
8297 else
8298 /* GD -> IE */
8299 tls_set = TLS_EXPLICIT | TLS_GD | TLS_TPRELGD;
8300 tls_clear = TLS_GD;
8301 }
8302 else
8303 {
8304 if (!is_local)
8305 continue;
8306
8307 /* LD -> LE */
8308 tls_set = TLS_EXPLICIT;
8309 tls_clear = TLS_LD;
8310 }
8311 break;
8312
8313 default:
8314 continue;
8315 }
8316
8317 if (pass == 0)
8318 {
8319 if (!expecting_tls_get_addr
8320 || !sec->has_tls_get_addr_call)
8321 continue;
8322
8323 if (rel + 1 < relend
8324 && branch_reloc_hash_match (ibfd, rel + 1,
8325 htab->tls_get_addr,
8326 htab->tls_get_addr_fd))
8327 {
8328 if (expecting_tls_get_addr == 2)
8329 {
8330 /* Check for toc tls entries. */
8331 unsigned char *toc_tls;
8332 int retval;
8333
8334 retval = get_tls_mask (&toc_tls, NULL, NULL,
8335 &locsyms,
8336 rel, ibfd);
8337 if (retval == 0)
8338 goto err_free_rel;
8339 if (toc_tls != NULL)
8340 {
8341 if ((*toc_tls & (TLS_GD | TLS_LD)) != 0)
8342 found_tls_get_addr_arg = 1;
8343 if (retval > 1)
8344 toc_ref[toc_ref_index] = 1;
8345 }
8346 }
8347 continue;
8348 }
8349
8350 if (expecting_tls_get_addr != 1)
8351 continue;
8352
8353 /* Uh oh, we didn't find the expected call. We
8354 could just mark this symbol to exclude it
8355 from tls optimization but it's safer to skip
8356 the entire optimization. */
8357 info->callbacks->minfo (_("%H arg lost __tls_get_addr, "
8358 "TLS optimization disabled\n"),
8359 ibfd, sec, rel->r_offset);
8360 ret = TRUE;
8361 goto err_free_rel;
8362 }
8363
8364 if (expecting_tls_get_addr && htab->tls_get_addr != NULL)
8365 {
8366 struct plt_entry *ent;
8367 for (ent = htab->tls_get_addr->elf.plt.plist;
8368 ent != NULL;
8369 ent = ent->next)
8370 if (ent->addend == 0)
8371 {
8372 if (ent->plt.refcount > 0)
8373 {
8374 ent->plt.refcount -= 1;
8375 expecting_tls_get_addr = 0;
8376 }
8377 break;
8378 }
8379 }
8380
8381 if (expecting_tls_get_addr && htab->tls_get_addr_fd != NULL)
8382 {
8383 struct plt_entry *ent;
8384 for (ent = htab->tls_get_addr_fd->elf.plt.plist;
8385 ent != NULL;
8386 ent = ent->next)
8387 if (ent->addend == 0)
8388 {
8389 if (ent->plt.refcount > 0)
8390 ent->plt.refcount -= 1;
8391 break;
8392 }
8393 }
8394
8395 if (tls_clear == 0)
8396 continue;
8397
8398 if ((tls_set & TLS_EXPLICIT) == 0)
8399 {
8400 struct got_entry *ent;
8401
8402 /* Adjust got entry for this reloc. */
8403 if (h != NULL)
8404 ent = h->got.glist;
8405 else
8406 ent = elf_local_got_ents (ibfd)[r_symndx];
8407
8408 for (; ent != NULL; ent = ent->next)
8409 if (ent->addend == rel->r_addend
8410 && ent->owner == ibfd
8411 && ent->tls_type == tls_type)
8412 break;
8413 if (ent == NULL)
8414 abort ();
8415
8416 if (tls_set == 0)
8417 {
8418 /* We managed to get rid of a got entry. */
8419 if (ent->got.refcount > 0)
8420 ent->got.refcount -= 1;
8421 }
8422 }
8423 else
8424 {
8425 /* If we got rid of a DTPMOD/DTPREL reloc pair then
8426 we'll lose one or two dyn relocs. */
8427 if (!dec_dynrel_count (rel->r_info, sec, info,
8428 NULL, h, sym))
8429 return FALSE;
8430
8431 if (tls_set == (TLS_EXPLICIT | TLS_GD))
8432 {
8433 if (!dec_dynrel_count ((rel + 1)->r_info, sec, info,
8434 NULL, h, sym))
8435 return FALSE;
8436 }
8437 }
8438
8439 *tls_mask |= tls_set;
8440 *tls_mask &= ~tls_clear;
8441 }
8442
8443 if (elf_section_data (sec)->relocs != relstart)
8444 free (relstart);
8445 }
8446
8447 if (locsyms != NULL
8448 && (elf_symtab_hdr (ibfd).contents != (unsigned char *) locsyms))
8449 {
8450 if (!info->keep_memory)
8451 free (locsyms);
8452 else
8453 elf_symtab_hdr (ibfd).contents = (unsigned char *) locsyms;
8454 }
8455 }
8456
8457 if (toc_ref != NULL)
8458 free (toc_ref);
8459 return TRUE;
8460 }
8461
8462 /* Called via elf_link_hash_traverse from ppc64_elf_edit_toc to adjust
8463 the values of any global symbols in a toc section that has been
8464 edited. Globals in toc sections should be a rarity, so this function
8465 sets a flag if any are found in toc sections other than the one just
8466 edited, so that futher hash table traversals can be avoided. */
8467
8468 struct adjust_toc_info
8469 {
8470 asection *toc;
8471 unsigned long *skip;
8472 bfd_boolean global_toc_syms;
8473 };
8474
8475 enum toc_skip_enum { ref_from_discarded = 1, can_optimize = 2 };
8476
8477 static bfd_boolean
8478 adjust_toc_syms (struct elf_link_hash_entry *h, void *inf)
8479 {
8480 struct ppc_link_hash_entry *eh;
8481 struct adjust_toc_info *toc_inf = (struct adjust_toc_info *) inf;
8482 unsigned long i;
8483
8484 if (h->root.type != bfd_link_hash_defined
8485 && h->root.type != bfd_link_hash_defweak)
8486 return TRUE;
8487
8488 eh = (struct ppc_link_hash_entry *) h;
8489 if (eh->adjust_done)
8490 return TRUE;
8491
8492 if (eh->elf.root.u.def.section == toc_inf->toc)
8493 {
8494 if (eh->elf.root.u.def.value > toc_inf->toc->rawsize)
8495 i = toc_inf->toc->rawsize >> 3;
8496 else
8497 i = eh->elf.root.u.def.value >> 3;
8498
8499 if ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0)
8500 {
8501 (*_bfd_error_handler)
8502 (_("%s defined on removed toc entry"), eh->elf.root.root.string);
8503 do
8504 ++i;
8505 while ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0);
8506 eh->elf.root.u.def.value = (bfd_vma) i << 3;
8507 }
8508
8509 eh->elf.root.u.def.value -= toc_inf->skip[i];
8510 eh->adjust_done = 1;
8511 }
8512 else if (strcmp (eh->elf.root.u.def.section->name, ".toc") == 0)
8513 toc_inf->global_toc_syms = TRUE;
8514
8515 return TRUE;
8516 }
8517
8518 /* Return TRUE iff INSN is one we expect on a _LO variety toc/got reloc. */
8519
8520 static bfd_boolean
8521 ok_lo_toc_insn (unsigned int insn)
8522 {
8523 return ((insn & (0x3f << 26)) == 14u << 26 /* addi */
8524 || (insn & (0x3f << 26)) == 32u << 26 /* lwz */
8525 || (insn & (0x3f << 26)) == 34u << 26 /* lbz */
8526 || (insn & (0x3f << 26)) == 36u << 26 /* stw */
8527 || (insn & (0x3f << 26)) == 38u << 26 /* stb */
8528 || (insn & (0x3f << 26)) == 40u << 26 /* lhz */
8529 || (insn & (0x3f << 26)) == 42u << 26 /* lha */
8530 || (insn & (0x3f << 26)) == 44u << 26 /* sth */
8531 || (insn & (0x3f << 26)) == 46u << 26 /* lmw */
8532 || (insn & (0x3f << 26)) == 47u << 26 /* stmw */
8533 || (insn & (0x3f << 26)) == 48u << 26 /* lfs */
8534 || (insn & (0x3f << 26)) == 50u << 26 /* lfd */
8535 || (insn & (0x3f << 26)) == 52u << 26 /* stfs */
8536 || (insn & (0x3f << 26)) == 54u << 26 /* stfd */
8537 || ((insn & (0x3f << 26)) == 58u << 26 /* lwa,ld,lmd */
8538 && (insn & 3) != 1)
8539 || ((insn & (0x3f << 26)) == 62u << 26 /* std, stmd */
8540 && ((insn & 3) == 0 || (insn & 3) == 3))
8541 || (insn & (0x3f << 26)) == 12u << 26 /* addic */);
8542 }
8543
8544 /* Examine all relocs referencing .toc sections in order to remove
8545 unused .toc entries. */
8546
8547 bfd_boolean
8548 ppc64_elf_edit_toc (struct bfd_link_info *info)
8549 {
8550 bfd *ibfd;
8551 struct adjust_toc_info toc_inf;
8552 struct ppc_link_hash_table *htab = ppc_hash_table (info);
8553
8554 htab->do_toc_opt = 1;
8555 toc_inf.global_toc_syms = TRUE;
8556 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
8557 {
8558 asection *toc, *sec;
8559 Elf_Internal_Shdr *symtab_hdr;
8560 Elf_Internal_Sym *local_syms;
8561 Elf_Internal_Rela *relstart, *rel, *toc_relocs;
8562 unsigned long *skip, *drop;
8563 unsigned char *used;
8564 unsigned char *keep, last, some_unused;
8565
8566 if (!is_ppc64_elf (ibfd))
8567 continue;
8568
8569 toc = bfd_get_section_by_name (ibfd, ".toc");
8570 if (toc == NULL
8571 || toc->size == 0
8572 || toc->sec_info_type == SEC_INFO_TYPE_JUST_SYMS
8573 || discarded_section (toc))
8574 continue;
8575
8576 toc_relocs = NULL;
8577 local_syms = NULL;
8578 symtab_hdr = &elf_symtab_hdr (ibfd);
8579
8580 /* Look at sections dropped from the final link. */
8581 skip = NULL;
8582 relstart = NULL;
8583 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8584 {
8585 if (sec->reloc_count == 0
8586 || !discarded_section (sec)
8587 || get_opd_info (sec)
8588 || (sec->flags & SEC_ALLOC) == 0
8589 || (sec->flags & SEC_DEBUGGING) != 0)
8590 continue;
8591
8592 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL, FALSE);
8593 if (relstart == NULL)
8594 goto error_ret;
8595
8596 /* Run through the relocs to see which toc entries might be
8597 unused. */
8598 for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
8599 {
8600 enum elf_ppc64_reloc_type r_type;
8601 unsigned long r_symndx;
8602 asection *sym_sec;
8603 struct elf_link_hash_entry *h;
8604 Elf_Internal_Sym *sym;
8605 bfd_vma val;
8606
8607 r_type = ELF64_R_TYPE (rel->r_info);
8608 switch (r_type)
8609 {
8610 default:
8611 continue;
8612
8613 case R_PPC64_TOC16:
8614 case R_PPC64_TOC16_LO:
8615 case R_PPC64_TOC16_HI:
8616 case R_PPC64_TOC16_HA:
8617 case R_PPC64_TOC16_DS:
8618 case R_PPC64_TOC16_LO_DS:
8619 break;
8620 }
8621
8622 r_symndx = ELF64_R_SYM (rel->r_info);
8623 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8624 r_symndx, ibfd))
8625 goto error_ret;
8626
8627 if (sym_sec != toc)
8628 continue;
8629
8630 if (h != NULL)
8631 val = h->root.u.def.value;
8632 else
8633 val = sym->st_value;
8634 val += rel->r_addend;
8635
8636 if (val >= toc->size)
8637 continue;
8638
8639 /* Anything in the toc ought to be aligned to 8 bytes.
8640 If not, don't mark as unused. */
8641 if (val & 7)
8642 continue;
8643
8644 if (skip == NULL)
8645 {
8646 skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
8647 if (skip == NULL)
8648 goto error_ret;
8649 }
8650
8651 skip[val >> 3] = ref_from_discarded;
8652 }
8653
8654 if (elf_section_data (sec)->relocs != relstart)
8655 free (relstart);
8656 }
8657
8658 /* For largetoc loads of address constants, we can convert
8659 . addis rx,2,addr@got@ha
8660 . ld ry,addr@got@l(rx)
8661 to
8662 . addis rx,2,addr@toc@ha
8663 . addi ry,rx,addr@toc@l
8664 when addr is within 2G of the toc pointer. This then means
8665 that the word storing "addr" in the toc is no longer needed. */
8666
8667 if (!ppc64_elf_tdata (ibfd)->has_small_toc_reloc
8668 && toc->output_section->rawsize < (bfd_vma) 1 << 31
8669 && toc->reloc_count != 0)
8670 {
8671 /* Read toc relocs. */
8672 toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
8673 info->keep_memory);
8674 if (toc_relocs == NULL)
8675 goto error_ret;
8676
8677 for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
8678 {
8679 enum elf_ppc64_reloc_type r_type;
8680 unsigned long r_symndx;
8681 asection *sym_sec;
8682 struct elf_link_hash_entry *h;
8683 Elf_Internal_Sym *sym;
8684 bfd_vma val, addr;
8685
8686 r_type = ELF64_R_TYPE (rel->r_info);
8687 if (r_type != R_PPC64_ADDR64)
8688 continue;
8689
8690 r_symndx = ELF64_R_SYM (rel->r_info);
8691 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8692 r_symndx, ibfd))
8693 goto error_ret;
8694
8695 if (sym_sec == NULL
8696 || discarded_section (sym_sec))
8697 continue;
8698
8699 if (!SYMBOL_REFERENCES_LOCAL (info, h))
8700 continue;
8701
8702 if (h != NULL)
8703 {
8704 if (h->type == STT_GNU_IFUNC)
8705 continue;
8706 val = h->root.u.def.value;
8707 }
8708 else
8709 {
8710 if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
8711 continue;
8712 val = sym->st_value;
8713 }
8714 val += rel->r_addend;
8715 val += sym_sec->output_section->vma + sym_sec->output_offset;
8716
8717 /* We don't yet know the exact toc pointer value, but we
8718 know it will be somewhere in the toc section. Don't
8719 optimize if the difference from any possible toc
8720 pointer is outside [ff..f80008000, 7fff7fff]. */
8721 addr = toc->output_section->vma + TOC_BASE_OFF;
8722 if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
8723 continue;
8724
8725 addr = toc->output_section->vma + toc->output_section->rawsize;
8726 if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
8727 continue;
8728
8729 if (skip == NULL)
8730 {
8731 skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
8732 if (skip == NULL)
8733 goto error_ret;
8734 }
8735
8736 skip[rel->r_offset >> 3]
8737 |= can_optimize | ((rel - toc_relocs) << 2);
8738 }
8739 }
8740
8741 if (skip == NULL)
8742 continue;
8743
8744 used = bfd_zmalloc (sizeof (*used) * (toc->size + 7) / 8);
8745 if (used == NULL)
8746 {
8747 error_ret:
8748 if (local_syms != NULL
8749 && symtab_hdr->contents != (unsigned char *) local_syms)
8750 free (local_syms);
8751 if (sec != NULL
8752 && relstart != NULL
8753 && elf_section_data (sec)->relocs != relstart)
8754 free (relstart);
8755 if (toc_relocs != NULL
8756 && elf_section_data (toc)->relocs != toc_relocs)
8757 free (toc_relocs);
8758 if (skip != NULL)
8759 free (skip);
8760 return FALSE;
8761 }
8762
8763 /* Now check all kept sections that might reference the toc.
8764 Check the toc itself last. */
8765 for (sec = (ibfd->sections == toc && toc->next ? toc->next
8766 : ibfd->sections);
8767 sec != NULL;
8768 sec = (sec == toc ? NULL
8769 : sec->next == NULL ? toc
8770 : sec->next == toc && toc->next ? toc->next
8771 : sec->next))
8772 {
8773 int repeat;
8774
8775 if (sec->reloc_count == 0
8776 || discarded_section (sec)
8777 || get_opd_info (sec)
8778 || (sec->flags & SEC_ALLOC) == 0
8779 || (sec->flags & SEC_DEBUGGING) != 0)
8780 continue;
8781
8782 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8783 info->keep_memory);
8784 if (relstart == NULL)
8785 goto error_ret;
8786
8787 /* Mark toc entries referenced as used. */
8788 do
8789 {
8790 repeat = 0;
8791 for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
8792 {
8793 enum elf_ppc64_reloc_type r_type;
8794 unsigned long r_symndx;
8795 asection *sym_sec;
8796 struct elf_link_hash_entry *h;
8797 Elf_Internal_Sym *sym;
8798 bfd_vma val;
8799 enum {no_check, check_lo, check_ha} insn_check;
8800
8801 r_type = ELF64_R_TYPE (rel->r_info);
8802 switch (r_type)
8803 {
8804 default:
8805 insn_check = no_check;
8806 break;
8807
8808 case R_PPC64_GOT_TLSLD16_HA:
8809 case R_PPC64_GOT_TLSGD16_HA:
8810 case R_PPC64_GOT_TPREL16_HA:
8811 case R_PPC64_GOT_DTPREL16_HA:
8812 case R_PPC64_GOT16_HA:
8813 case R_PPC64_TOC16_HA:
8814 insn_check = check_ha;
8815 break;
8816
8817 case R_PPC64_GOT_TLSLD16_LO:
8818 case R_PPC64_GOT_TLSGD16_LO:
8819 case R_PPC64_GOT_TPREL16_LO_DS:
8820 case R_PPC64_GOT_DTPREL16_LO_DS:
8821 case R_PPC64_GOT16_LO:
8822 case R_PPC64_GOT16_LO_DS:
8823 case R_PPC64_TOC16_LO:
8824 case R_PPC64_TOC16_LO_DS:
8825 insn_check = check_lo;
8826 break;
8827 }
8828
8829 if (insn_check != no_check)
8830 {
8831 bfd_vma off = rel->r_offset & ~3;
8832 unsigned char buf[4];
8833 unsigned int insn;
8834
8835 if (!bfd_get_section_contents (ibfd, sec, buf, off, 4))
8836 {
8837 free (used);
8838 goto error_ret;
8839 }
8840 insn = bfd_get_32 (ibfd, buf);
8841 if (insn_check == check_lo
8842 ? !ok_lo_toc_insn (insn)
8843 : ((insn & ((0x3f << 26) | 0x1f << 16))
8844 != ((15u << 26) | (2 << 16)) /* addis rt,2,imm */))
8845 {
8846 char str[12];
8847
8848 ppc64_elf_tdata (ibfd)->unexpected_toc_insn = 1;
8849 sprintf (str, "%#08x", insn);
8850 info->callbacks->einfo
8851 (_("%P: %H: toc optimization is not supported for"
8852 " %s instruction.\n"),
8853 ibfd, sec, rel->r_offset & ~3, str);
8854 }
8855 }
8856
8857 switch (r_type)
8858 {
8859 case R_PPC64_TOC16:
8860 case R_PPC64_TOC16_LO:
8861 case R_PPC64_TOC16_HI:
8862 case R_PPC64_TOC16_HA:
8863 case R_PPC64_TOC16_DS:
8864 case R_PPC64_TOC16_LO_DS:
8865 /* In case we're taking addresses of toc entries. */
8866 case R_PPC64_ADDR64:
8867 break;
8868
8869 default:
8870 continue;
8871 }
8872
8873 r_symndx = ELF64_R_SYM (rel->r_info);
8874 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8875 r_symndx, ibfd))
8876 {
8877 free (used);
8878 goto error_ret;
8879 }
8880
8881 if (sym_sec != toc)
8882 continue;
8883
8884 if (h != NULL)
8885 val = h->root.u.def.value;
8886 else
8887 val = sym->st_value;
8888 val += rel->r_addend;
8889
8890 if (val >= toc->size)
8891 continue;
8892
8893 if ((skip[val >> 3] & can_optimize) != 0)
8894 {
8895 bfd_vma off;
8896 unsigned char opc;
8897
8898 switch (r_type)
8899 {
8900 case R_PPC64_TOC16_HA:
8901 break;
8902
8903 case R_PPC64_TOC16_LO_DS:
8904 off = rel->r_offset;
8905 off += (bfd_big_endian (ibfd) ? -2 : 3);
8906 if (!bfd_get_section_contents (ibfd, sec, &opc,
8907 off, 1))
8908 {
8909 free (used);
8910 goto error_ret;
8911 }
8912 if ((opc & (0x3f << 2)) == (58u << 2))
8913 break;
8914 /* Fall thru */
8915
8916 default:
8917 /* Wrong sort of reloc, or not a ld. We may
8918 as well clear ref_from_discarded too. */
8919 skip[val >> 3] = 0;
8920 }
8921 }
8922
8923 if (sec != toc)
8924 used[val >> 3] = 1;
8925 /* For the toc section, we only mark as used if this
8926 entry itself isn't unused. */
8927 else if ((used[rel->r_offset >> 3]
8928 || !(skip[rel->r_offset >> 3] & ref_from_discarded))
8929 && !used[val >> 3])
8930 {
8931 /* Do all the relocs again, to catch reference
8932 chains. */
8933 repeat = 1;
8934 used[val >> 3] = 1;
8935 }
8936 }
8937 }
8938 while (repeat);
8939
8940 if (elf_section_data (sec)->relocs != relstart)
8941 free (relstart);
8942 }
8943
8944 /* Merge the used and skip arrays. Assume that TOC
8945 doublewords not appearing as either used or unused belong
8946 to to an entry more than one doubleword in size. */
8947 for (drop = skip, keep = used, last = 0, some_unused = 0;
8948 drop < skip + (toc->size + 7) / 8;
8949 ++drop, ++keep)
8950 {
8951 if (*keep)
8952 {
8953 *drop &= ~ref_from_discarded;
8954 if ((*drop & can_optimize) != 0)
8955 some_unused = 1;
8956 last = 0;
8957 }
8958 else if ((*drop & ref_from_discarded) != 0)
8959 {
8960 some_unused = 1;
8961 last = ref_from_discarded;
8962 }
8963 else
8964 *drop = last;
8965 }
8966
8967 free (used);
8968
8969 if (some_unused)
8970 {
8971 bfd_byte *contents, *src;
8972 unsigned long off;
8973 Elf_Internal_Sym *sym;
8974 bfd_boolean local_toc_syms = FALSE;
8975
8976 /* Shuffle the toc contents, and at the same time convert the
8977 skip array from booleans into offsets. */
8978 if (!bfd_malloc_and_get_section (ibfd, toc, &contents))
8979 goto error_ret;
8980
8981 elf_section_data (toc)->this_hdr.contents = contents;
8982
8983 for (src = contents, off = 0, drop = skip;
8984 src < contents + toc->size;
8985 src += 8, ++drop)
8986 {
8987 if ((*drop & (can_optimize | ref_from_discarded)) != 0)
8988 off += 8;
8989 else if (off != 0)
8990 {
8991 *drop = off;
8992 memcpy (src - off, src, 8);
8993 }
8994 }
8995 *drop = off;
8996 toc->rawsize = toc->size;
8997 toc->size = src - contents - off;
8998
8999 /* Adjust addends for relocs against the toc section sym,
9000 and optimize any accesses we can. */
9001 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
9002 {
9003 if (sec->reloc_count == 0
9004 || discarded_section (sec))
9005 continue;
9006
9007 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
9008 info->keep_memory);
9009 if (relstart == NULL)
9010 goto error_ret;
9011
9012 for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9013 {
9014 enum elf_ppc64_reloc_type r_type;
9015 unsigned long r_symndx;
9016 asection *sym_sec;
9017 struct elf_link_hash_entry *h;
9018 bfd_vma val;
9019
9020 r_type = ELF64_R_TYPE (rel->r_info);
9021 switch (r_type)
9022 {
9023 default:
9024 continue;
9025
9026 case R_PPC64_TOC16:
9027 case R_PPC64_TOC16_LO:
9028 case R_PPC64_TOC16_HI:
9029 case R_PPC64_TOC16_HA:
9030 case R_PPC64_TOC16_DS:
9031 case R_PPC64_TOC16_LO_DS:
9032 case R_PPC64_ADDR64:
9033 break;
9034 }
9035
9036 r_symndx = ELF64_R_SYM (rel->r_info);
9037 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9038 r_symndx, ibfd))
9039 goto error_ret;
9040
9041 if (sym_sec != toc)
9042 continue;
9043
9044 if (h != NULL)
9045 val = h->root.u.def.value;
9046 else
9047 {
9048 val = sym->st_value;
9049 if (val != 0)
9050 local_toc_syms = TRUE;
9051 }
9052
9053 val += rel->r_addend;
9054
9055 if (val > toc->rawsize)
9056 val = toc->rawsize;
9057 else if ((skip[val >> 3] & ref_from_discarded) != 0)
9058 continue;
9059 else if ((skip[val >> 3] & can_optimize) != 0)
9060 {
9061 Elf_Internal_Rela *tocrel
9062 = toc_relocs + (skip[val >> 3] >> 2);
9063 unsigned long tsym = ELF64_R_SYM (tocrel->r_info);
9064
9065 switch (r_type)
9066 {
9067 case R_PPC64_TOC16_HA:
9068 rel->r_info = ELF64_R_INFO (tsym, R_PPC64_TOC16_HA);
9069 break;
9070
9071 case R_PPC64_TOC16_LO_DS:
9072 rel->r_info = ELF64_R_INFO (tsym, R_PPC64_LO_DS_OPT);
9073 break;
9074
9075 default:
9076 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
9077 ppc_howto_init ();
9078 info->callbacks->einfo
9079 (_("%P: %H: %s references "
9080 "optimized away TOC entry\n"),
9081 ibfd, sec, rel->r_offset,
9082 ppc64_elf_howto_table[r_type]->name);
9083 bfd_set_error (bfd_error_bad_value);
9084 goto error_ret;
9085 }
9086 rel->r_addend = tocrel->r_addend;
9087 elf_section_data (sec)->relocs = relstart;
9088 continue;
9089 }
9090
9091 if (h != NULL || sym->st_value != 0)
9092 continue;
9093
9094 rel->r_addend -= skip[val >> 3];
9095 elf_section_data (sec)->relocs = relstart;
9096 }
9097
9098 if (elf_section_data (sec)->relocs != relstart)
9099 free (relstart);
9100 }
9101
9102 /* We shouldn't have local or global symbols defined in the TOC,
9103 but handle them anyway. */
9104 if (local_syms != NULL)
9105 for (sym = local_syms;
9106 sym < local_syms + symtab_hdr->sh_info;
9107 ++sym)
9108 if (sym->st_value != 0
9109 && bfd_section_from_elf_index (ibfd, sym->st_shndx) == toc)
9110 {
9111 unsigned long i;
9112
9113 if (sym->st_value > toc->rawsize)
9114 i = toc->rawsize >> 3;
9115 else
9116 i = sym->st_value >> 3;
9117
9118 if ((skip[i] & (ref_from_discarded | can_optimize)) != 0)
9119 {
9120 if (local_toc_syms)
9121 (*_bfd_error_handler)
9122 (_("%s defined on removed toc entry"),
9123 bfd_elf_sym_name (ibfd, symtab_hdr, sym, NULL));
9124 do
9125 ++i;
9126 while ((skip[i] & (ref_from_discarded | can_optimize)));
9127 sym->st_value = (bfd_vma) i << 3;
9128 }
9129
9130 sym->st_value -= skip[i];
9131 symtab_hdr->contents = (unsigned char *) local_syms;
9132 }
9133
9134 /* Adjust any global syms defined in this toc input section. */
9135 if (toc_inf.global_toc_syms)
9136 {
9137 toc_inf.toc = toc;
9138 toc_inf.skip = skip;
9139 toc_inf.global_toc_syms = FALSE;
9140 elf_link_hash_traverse (elf_hash_table (info), adjust_toc_syms,
9141 &toc_inf);
9142 }
9143
9144 if (toc->reloc_count != 0)
9145 {
9146 Elf_Internal_Shdr *rel_hdr;
9147 Elf_Internal_Rela *wrel;
9148 bfd_size_type sz;
9149
9150 /* Remove unused toc relocs, and adjust those we keep. */
9151 if (toc_relocs == NULL)
9152 toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
9153 info->keep_memory);
9154 if (toc_relocs == NULL)
9155 goto error_ret;
9156
9157 wrel = toc_relocs;
9158 for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
9159 if ((skip[rel->r_offset >> 3]
9160 & (ref_from_discarded | can_optimize)) == 0)
9161 {
9162 wrel->r_offset = rel->r_offset - skip[rel->r_offset >> 3];
9163 wrel->r_info = rel->r_info;
9164 wrel->r_addend = rel->r_addend;
9165 ++wrel;
9166 }
9167 else if (!dec_dynrel_count (rel->r_info, toc, info,
9168 &local_syms, NULL, NULL))
9169 goto error_ret;
9170
9171 elf_section_data (toc)->relocs = toc_relocs;
9172 toc->reloc_count = wrel - toc_relocs;
9173 rel_hdr = _bfd_elf_single_rel_hdr (toc);
9174 sz = rel_hdr->sh_entsize;
9175 rel_hdr->sh_size = toc->reloc_count * sz;
9176 }
9177 }
9178 else if (toc_relocs != NULL
9179 && elf_section_data (toc)->relocs != toc_relocs)
9180 free (toc_relocs);
9181
9182 if (local_syms != NULL
9183 && symtab_hdr->contents != (unsigned char *) local_syms)
9184 {
9185 if (!info->keep_memory)
9186 free (local_syms);
9187 else
9188 symtab_hdr->contents = (unsigned char *) local_syms;
9189 }
9190 free (skip);
9191 }
9192
9193 return TRUE;
9194 }
9195
9196 /* Return true iff input section I references the TOC using
9197 instructions limited to +/-32k offsets. */
9198
9199 bfd_boolean
9200 ppc64_elf_has_small_toc_reloc (asection *i)
9201 {
9202 return (is_ppc64_elf (i->owner)
9203 && ppc64_elf_tdata (i->owner)->has_small_toc_reloc);
9204 }
9205
9206 /* Allocate space for one GOT entry. */
9207
9208 static void
9209 allocate_got (struct elf_link_hash_entry *h,
9210 struct bfd_link_info *info,
9211 struct got_entry *gent)
9212 {
9213 struct ppc_link_hash_table *htab = ppc_hash_table (info);
9214 bfd_boolean dyn;
9215 struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
9216 int entsize = (gent->tls_type & eh->tls_mask & (TLS_GD | TLS_LD)
9217 ? 16 : 8);
9218 int rentsize = (gent->tls_type & eh->tls_mask & TLS_GD
9219 ? 2 : 1) * sizeof (Elf64_External_Rela);
9220 asection *got = ppc64_elf_tdata (gent->owner)->got;
9221
9222 gent->got.offset = got->size;
9223 got->size += entsize;
9224
9225 dyn = htab->elf.dynamic_sections_created;
9226 if (h->type == STT_GNU_IFUNC)
9227 {
9228 htab->elf.irelplt->size += rentsize;
9229 htab->got_reli_size += rentsize;
9230 }
9231 else if ((info->shared
9232 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h))
9233 && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
9234 || h->root.type != bfd_link_hash_undefweak))
9235 {
9236 asection *relgot = ppc64_elf_tdata (gent->owner)->relgot;
9237 relgot->size += rentsize;
9238 }
9239 }
9240
9241 /* This function merges got entries in the same toc group. */
9242
9243 static void
9244 merge_got_entries (struct got_entry **pent)
9245 {
9246 struct got_entry *ent, *ent2;
9247
9248 for (ent = *pent; ent != NULL; ent = ent->next)
9249 if (!ent->is_indirect)
9250 for (ent2 = ent->next; ent2 != NULL; ent2 = ent2->next)
9251 if (!ent2->is_indirect
9252 && ent2->addend == ent->addend
9253 && ent2->tls_type == ent->tls_type
9254 && elf_gp (ent2->owner) == elf_gp (ent->owner))
9255 {
9256 ent2->is_indirect = TRUE;
9257 ent2->got.ent = ent;
9258 }
9259 }
9260
9261 /* Allocate space in .plt, .got and associated reloc sections for
9262 dynamic relocs. */
9263
9264 static bfd_boolean
9265 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
9266 {
9267 struct bfd_link_info *info;
9268 struct ppc_link_hash_table *htab;
9269 asection *s;
9270 struct ppc_link_hash_entry *eh;
9271 struct elf_dyn_relocs *p;
9272 struct got_entry **pgent, *gent;
9273
9274 if (h->root.type == bfd_link_hash_indirect)
9275 return TRUE;
9276
9277 info = (struct bfd_link_info *) inf;
9278 htab = ppc_hash_table (info);
9279 if (htab == NULL)
9280 return FALSE;
9281
9282 if ((htab->elf.dynamic_sections_created
9283 && h->dynindx != -1
9284 && WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info->shared, h))
9285 || h->type == STT_GNU_IFUNC)
9286 {
9287 struct plt_entry *pent;
9288 bfd_boolean doneone = FALSE;
9289 for (pent = h->plt.plist; pent != NULL; pent = pent->next)
9290 if (pent->plt.refcount > 0)
9291 {
9292 if (!htab->elf.dynamic_sections_created
9293 || h->dynindx == -1)
9294 {
9295 s = htab->elf.iplt;
9296 pent->plt.offset = s->size;
9297 s->size += PLT_ENTRY_SIZE (htab);
9298 s = htab->elf.irelplt;
9299 }
9300 else
9301 {
9302 /* If this is the first .plt entry, make room for the special
9303 first entry. */
9304 s = htab->elf.splt;
9305 if (s->size == 0)
9306 s->size += PLT_INITIAL_ENTRY_SIZE (htab);
9307
9308 pent->plt.offset = s->size;
9309
9310 /* Make room for this entry. */
9311 s->size += PLT_ENTRY_SIZE (htab);
9312
9313 /* Make room for the .glink code. */
9314 s = htab->glink;
9315 if (s->size == 0)
9316 s->size += GLINK_CALL_STUB_SIZE;
9317 if (htab->opd_abi)
9318 {
9319 /* We need bigger stubs past index 32767. */
9320 if (s->size >= GLINK_CALL_STUB_SIZE + 32768*2*4)
9321 s->size += 4;
9322 s->size += 2*4;
9323 }
9324 else
9325 s->size += 4;
9326
9327 /* We also need to make an entry in the .rela.plt section. */
9328 s = htab->elf.srelplt;
9329 }
9330 s->size += sizeof (Elf64_External_Rela);
9331 doneone = TRUE;
9332 }
9333 else
9334 pent->plt.offset = (bfd_vma) -1;
9335 if (!doneone)
9336 {
9337 h->plt.plist = NULL;
9338 h->needs_plt = 0;
9339 }
9340 }
9341 else
9342 {
9343 h->plt.plist = NULL;
9344 h->needs_plt = 0;
9345 }
9346
9347 eh = (struct ppc_link_hash_entry *) h;
9348 /* Run through the TLS GD got entries first if we're changing them
9349 to TPREL. */
9350 if ((eh->tls_mask & TLS_TPRELGD) != 0)
9351 for (gent = h->got.glist; gent != NULL; gent = gent->next)
9352 if (gent->got.refcount > 0
9353 && (gent->tls_type & TLS_GD) != 0)
9354 {
9355 /* This was a GD entry that has been converted to TPREL. If
9356 there happens to be a TPREL entry we can use that one. */
9357 struct got_entry *ent;
9358 for (ent = h->got.glist; ent != NULL; ent = ent->next)
9359 if (ent->got.refcount > 0
9360 && (ent->tls_type & TLS_TPREL) != 0
9361 && ent->addend == gent->addend
9362 && ent->owner == gent->owner)
9363 {
9364 gent->got.refcount = 0;
9365 break;
9366 }
9367
9368 /* If not, then we'll be using our own TPREL entry. */
9369 if (gent->got.refcount != 0)
9370 gent->tls_type = TLS_TLS | TLS_TPREL;
9371 }
9372
9373 /* Remove any list entry that won't generate a word in the GOT before
9374 we call merge_got_entries. Otherwise we risk merging to empty
9375 entries. */
9376 pgent = &h->got.glist;
9377 while ((gent = *pgent) != NULL)
9378 if (gent->got.refcount > 0)
9379 {
9380 if ((gent->tls_type & TLS_LD) != 0
9381 && !h->def_dynamic)
9382 {
9383 ppc64_tlsld_got (gent->owner)->got.refcount += 1;
9384 *pgent = gent->next;
9385 }
9386 else
9387 pgent = &gent->next;
9388 }
9389 else
9390 *pgent = gent->next;
9391
9392 if (!htab->do_multi_toc)
9393 merge_got_entries (&h->got.glist);
9394
9395 for (gent = h->got.glist; gent != NULL; gent = gent->next)
9396 if (!gent->is_indirect)
9397 {
9398 /* Make sure this symbol is output as a dynamic symbol.
9399 Undefined weak syms won't yet be marked as dynamic,
9400 nor will all TLS symbols. */
9401 if (h->dynindx == -1
9402 && !h->forced_local
9403 && h->type != STT_GNU_IFUNC
9404 && htab->elf.dynamic_sections_created)
9405 {
9406 if (! bfd_elf_link_record_dynamic_symbol (info, h))
9407 return FALSE;
9408 }
9409
9410 if (!is_ppc64_elf (gent->owner))
9411 abort ();
9412
9413 allocate_got (h, info, gent);
9414 }
9415
9416 if (eh->dyn_relocs == NULL
9417 || (!htab->elf.dynamic_sections_created
9418 && h->type != STT_GNU_IFUNC))
9419 return TRUE;
9420
9421 /* In the shared -Bsymbolic case, discard space allocated for
9422 dynamic pc-relative relocs against symbols which turn out to be
9423 defined in regular objects. For the normal shared case, discard
9424 space for relocs that have become local due to symbol visibility
9425 changes. */
9426
9427 if (info->shared)
9428 {
9429 /* Relocs that use pc_count are those that appear on a call insn,
9430 or certain REL relocs (see must_be_dyn_reloc) that can be
9431 generated via assembly. We want calls to protected symbols to
9432 resolve directly to the function rather than going via the plt.
9433 If people want function pointer comparisons to work as expected
9434 then they should avoid writing weird assembly. */
9435 if (SYMBOL_CALLS_LOCAL (info, h))
9436 {
9437 struct elf_dyn_relocs **pp;
9438
9439 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
9440 {
9441 p->count -= p->pc_count;
9442 p->pc_count = 0;
9443 if (p->count == 0)
9444 *pp = p->next;
9445 else
9446 pp = &p->next;
9447 }
9448 }
9449
9450 /* Also discard relocs on undefined weak syms with non-default
9451 visibility. */
9452 if (eh->dyn_relocs != NULL
9453 && h->root.type == bfd_link_hash_undefweak)
9454 {
9455 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
9456 eh->dyn_relocs = NULL;
9457
9458 /* Make sure this symbol is output as a dynamic symbol.
9459 Undefined weak syms won't yet be marked as dynamic. */
9460 else if (h->dynindx == -1
9461 && !h->forced_local)
9462 {
9463 if (! bfd_elf_link_record_dynamic_symbol (info, h))
9464 return FALSE;
9465 }
9466 }
9467 }
9468 else if (h->type == STT_GNU_IFUNC)
9469 {
9470 if (!h->non_got_ref)
9471 eh->dyn_relocs = NULL;
9472 }
9473 else if (ELIMINATE_COPY_RELOCS)
9474 {
9475 /* For the non-shared case, discard space for relocs against
9476 symbols which turn out to need copy relocs or are not
9477 dynamic. */
9478
9479 if (!h->non_got_ref
9480 && !h->def_regular)
9481 {
9482 /* Make sure this symbol is output as a dynamic symbol.
9483 Undefined weak syms won't yet be marked as dynamic. */
9484 if (h->dynindx == -1
9485 && !h->forced_local)
9486 {
9487 if (! bfd_elf_link_record_dynamic_symbol (info, h))
9488 return FALSE;
9489 }
9490
9491 /* If that succeeded, we know we'll be keeping all the
9492 relocs. */
9493 if (h->dynindx != -1)
9494 goto keep;
9495 }
9496
9497 eh->dyn_relocs = NULL;
9498
9499 keep: ;
9500 }
9501
9502 /* Finally, allocate space. */
9503 for (p = eh->dyn_relocs; p != NULL; p = p->next)
9504 {
9505 asection *sreloc = elf_section_data (p->sec)->sreloc;
9506 if (eh->elf.type == STT_GNU_IFUNC)
9507 sreloc = htab->elf.irelplt;
9508 sreloc->size += p->count * sizeof (Elf64_External_Rela);
9509 }
9510
9511 return TRUE;
9512 }
9513
9514 /* Called via elf_link_hash_traverse from ppc64_elf_size_dynamic_sections
9515 to set up space for global entry stubs. These are put in glink,
9516 after the branch table. */
9517
9518 static bfd_boolean
9519 size_global_entry_stubs (struct elf_link_hash_entry *h, void *inf)
9520 {
9521 struct bfd_link_info *info;
9522 struct ppc_link_hash_table *htab;
9523 struct plt_entry *pent;
9524 asection *s;
9525
9526 if (h->root.type == bfd_link_hash_indirect)
9527 return TRUE;
9528
9529 if (!h->pointer_equality_needed)
9530 return TRUE;
9531
9532 if (h->def_regular)
9533 return TRUE;
9534
9535 info = inf;
9536 htab = ppc_hash_table (info);
9537 if (htab == NULL)
9538 return FALSE;
9539
9540 s = htab->glink;
9541 for (pent = h->plt.plist; pent != NULL; pent = pent->next)
9542 if (pent->plt.offset != (bfd_vma) -1
9543 && pent->addend == 0)
9544 {
9545 /* For ELFv2, if this symbol is not defined in a regular file
9546 and we are not generating a shared library or pie, then we
9547 need to define the symbol in the executable on a call stub.
9548 This is to avoid text relocations. */
9549 s->size = (s->size + 15) & -16;
9550 h->root.u.def.section = s;
9551 h->root.u.def.value = s->size;
9552 s->size += 16;
9553 break;
9554 }
9555 return TRUE;
9556 }
9557
9558 /* Set DF_TEXTREL if we find any dynamic relocs that apply to
9559 read-only sections. */
9560
9561 static bfd_boolean
9562 maybe_set_textrel (struct elf_link_hash_entry *h, void *info)
9563 {
9564 if (h->root.type == bfd_link_hash_indirect)
9565 return TRUE;
9566
9567 if (readonly_dynrelocs (h))
9568 {
9569 ((struct bfd_link_info *) info)->flags |= DF_TEXTREL;
9570
9571 /* Not an error, just cut short the traversal. */
9572 return FALSE;
9573 }
9574 return TRUE;
9575 }
9576
9577 /* Set the sizes of the dynamic sections. */
9578
9579 static bfd_boolean
9580 ppc64_elf_size_dynamic_sections (bfd *output_bfd,
9581 struct bfd_link_info *info)
9582 {
9583 struct ppc_link_hash_table *htab;
9584 bfd *dynobj;
9585 asection *s;
9586 bfd_boolean relocs;
9587 bfd *ibfd;
9588 struct got_entry *first_tlsld;
9589
9590 htab = ppc_hash_table (info);
9591 if (htab == NULL)
9592 return FALSE;
9593
9594 dynobj = htab->elf.dynobj;
9595 if (dynobj == NULL)
9596 abort ();
9597
9598 if (htab->elf.dynamic_sections_created)
9599 {
9600 /* Set the contents of the .interp section to the interpreter. */
9601 if (info->executable)
9602 {
9603 s = bfd_get_linker_section (dynobj, ".interp");
9604 if (s == NULL)
9605 abort ();
9606 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
9607 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
9608 }
9609 }
9610
9611 /* Set up .got offsets for local syms, and space for local dynamic
9612 relocs. */
9613 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
9614 {
9615 struct got_entry **lgot_ents;
9616 struct got_entry **end_lgot_ents;
9617 struct plt_entry **local_plt;
9618 struct plt_entry **end_local_plt;
9619 unsigned char *lgot_masks;
9620 bfd_size_type locsymcount;
9621 Elf_Internal_Shdr *symtab_hdr;
9622
9623 if (!is_ppc64_elf (ibfd))
9624 continue;
9625
9626 for (s = ibfd->sections; s != NULL; s = s->next)
9627 {
9628 struct ppc_dyn_relocs *p;
9629
9630 for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
9631 {
9632 if (!bfd_is_abs_section (p->sec)
9633 && bfd_is_abs_section (p->sec->output_section))
9634 {
9635 /* Input section has been discarded, either because
9636 it is a copy of a linkonce section or due to
9637 linker script /DISCARD/, so we'll be discarding
9638 the relocs too. */
9639 }
9640 else if (p->count != 0)
9641 {
9642 asection *srel = elf_section_data (p->sec)->sreloc;
9643 if (p->ifunc)
9644 srel = htab->elf.irelplt;
9645 srel->size += p->count * sizeof (Elf64_External_Rela);
9646 if ((p->sec->output_section->flags & SEC_READONLY) != 0)
9647 info->flags |= DF_TEXTREL;
9648 }
9649 }
9650 }
9651
9652 lgot_ents = elf_local_got_ents (ibfd);
9653 if (!lgot_ents)
9654 continue;
9655
9656 symtab_hdr = &elf_symtab_hdr (ibfd);
9657 locsymcount = symtab_hdr->sh_info;
9658 end_lgot_ents = lgot_ents + locsymcount;
9659 local_plt = (struct plt_entry **) end_lgot_ents;
9660 end_local_plt = local_plt + locsymcount;
9661 lgot_masks = (unsigned char *) end_local_plt;
9662 s = ppc64_elf_tdata (ibfd)->got;
9663 for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
9664 {
9665 struct got_entry **pent, *ent;
9666
9667 pent = lgot_ents;
9668 while ((ent = *pent) != NULL)
9669 if (ent->got.refcount > 0)
9670 {
9671 if ((ent->tls_type & *lgot_masks & TLS_LD) != 0)
9672 {
9673 ppc64_tlsld_got (ibfd)->got.refcount += 1;
9674 *pent = ent->next;
9675 }
9676 else
9677 {
9678 unsigned int ent_size = 8;
9679 unsigned int rel_size = sizeof (Elf64_External_Rela);
9680
9681 ent->got.offset = s->size;
9682 if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
9683 {
9684 ent_size *= 2;
9685 rel_size *= 2;
9686 }
9687 s->size += ent_size;
9688 if ((*lgot_masks & PLT_IFUNC) != 0)
9689 {
9690 htab->elf.irelplt->size += rel_size;
9691 htab->got_reli_size += rel_size;
9692 }
9693 else if (info->shared)
9694 {
9695 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
9696 srel->size += rel_size;
9697 }
9698 pent = &ent->next;
9699 }
9700 }
9701 else
9702 *pent = ent->next;
9703 }
9704
9705 /* Allocate space for calls to local STT_GNU_IFUNC syms in .iplt. */
9706 for (; local_plt < end_local_plt; ++local_plt)
9707 {
9708 struct plt_entry *ent;
9709
9710 for (ent = *local_plt; ent != NULL; ent = ent->next)
9711 if (ent->plt.refcount > 0)
9712 {
9713 s = htab->elf.iplt;
9714 ent->plt.offset = s->size;
9715 s->size += PLT_ENTRY_SIZE (htab);
9716
9717 htab->elf.irelplt->size += sizeof (Elf64_External_Rela);
9718 }
9719 else
9720 ent->plt.offset = (bfd_vma) -1;
9721 }
9722 }
9723
9724 /* Allocate global sym .plt and .got entries, and space for global
9725 sym dynamic relocs. */
9726 elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, info);
9727 /* Stash the end of glink branch table. */
9728 if (htab->glink != NULL)
9729 htab->glink->rawsize = htab->glink->size;
9730
9731 if (!htab->opd_abi && !info->shared)
9732 elf_link_hash_traverse (&htab->elf, size_global_entry_stubs, info);
9733
9734 first_tlsld = NULL;
9735 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
9736 {
9737 struct got_entry *ent;
9738
9739 if (!is_ppc64_elf (ibfd))
9740 continue;
9741
9742 ent = ppc64_tlsld_got (ibfd);
9743 if (ent->got.refcount > 0)
9744 {
9745 if (!htab->do_multi_toc && first_tlsld != NULL)
9746 {
9747 ent->is_indirect = TRUE;
9748 ent->got.ent = first_tlsld;
9749 }
9750 else
9751 {
9752 if (first_tlsld == NULL)
9753 first_tlsld = ent;
9754 s = ppc64_elf_tdata (ibfd)->got;
9755 ent->got.offset = s->size;
9756 ent->owner = ibfd;
9757 s->size += 16;
9758 if (info->shared)
9759 {
9760 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
9761 srel->size += sizeof (Elf64_External_Rela);
9762 }
9763 }
9764 }
9765 else
9766 ent->got.offset = (bfd_vma) -1;
9767 }
9768
9769 /* We now have determined the sizes of the various dynamic sections.
9770 Allocate memory for them. */
9771 relocs = FALSE;
9772 for (s = dynobj->sections; s != NULL; s = s->next)
9773 {
9774 if ((s->flags & SEC_LINKER_CREATED) == 0)
9775 continue;
9776
9777 if (s == htab->brlt || s == htab->relbrlt)
9778 /* These haven't been allocated yet; don't strip. */
9779 continue;
9780 else if (s == htab->elf.sgot
9781 || s == htab->elf.splt
9782 || s == htab->elf.iplt
9783 || s == htab->glink
9784 || s == htab->dynbss)
9785 {
9786 /* Strip this section if we don't need it; see the
9787 comment below. */
9788 }
9789 else if (s == htab->glink_eh_frame)
9790 {
9791 if (!bfd_is_abs_section (s->output_section))
9792 /* Not sized yet. */
9793 continue;
9794 }
9795 else if (CONST_STRNEQ (s->name, ".rela"))
9796 {
9797 if (s->size != 0)
9798 {
9799 if (s != htab->elf.srelplt)
9800 relocs = TRUE;
9801
9802 /* We use the reloc_count field as a counter if we need
9803 to copy relocs into the output file. */
9804 s->reloc_count = 0;
9805 }
9806 }
9807 else
9808 {
9809 /* It's not one of our sections, so don't allocate space. */
9810 continue;
9811 }
9812
9813 if (s->size == 0)
9814 {
9815 /* If we don't need this section, strip it from the
9816 output file. This is mostly to handle .rela.bss and
9817 .rela.plt. We must create both sections in
9818 create_dynamic_sections, because they must be created
9819 before the linker maps input sections to output
9820 sections. The linker does that before
9821 adjust_dynamic_symbol is called, and it is that
9822 function which decides whether anything needs to go
9823 into these sections. */
9824 s->flags |= SEC_EXCLUDE;
9825 continue;
9826 }
9827
9828 if ((s->flags & SEC_HAS_CONTENTS) == 0)
9829 continue;
9830
9831 /* Allocate memory for the section contents. We use bfd_zalloc
9832 here in case unused entries are not reclaimed before the
9833 section's contents are written out. This should not happen,
9834 but this way if it does we get a R_PPC64_NONE reloc in .rela
9835 sections instead of garbage.
9836 We also rely on the section contents being zero when writing
9837 the GOT. */
9838 s->contents = bfd_zalloc (dynobj, s->size);
9839 if (s->contents == NULL)
9840 return FALSE;
9841 }
9842
9843 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
9844 {
9845 if (!is_ppc64_elf (ibfd))
9846 continue;
9847
9848 s = ppc64_elf_tdata (ibfd)->got;
9849 if (s != NULL && s != htab->elf.sgot)
9850 {
9851 if (s->size == 0)
9852 s->flags |= SEC_EXCLUDE;
9853 else
9854 {
9855 s->contents = bfd_zalloc (ibfd, s->size);
9856 if (s->contents == NULL)
9857 return FALSE;
9858 }
9859 }
9860 s = ppc64_elf_tdata (ibfd)->relgot;
9861 if (s != NULL)
9862 {
9863 if (s->size == 0)
9864 s->flags |= SEC_EXCLUDE;
9865 else
9866 {
9867 s->contents = bfd_zalloc (ibfd, s->size);
9868 if (s->contents == NULL)
9869 return FALSE;
9870 relocs = TRUE;
9871 s->reloc_count = 0;
9872 }
9873 }
9874 }
9875
9876 if (htab->elf.dynamic_sections_created)
9877 {
9878 bfd_boolean tls_opt;
9879
9880 /* Add some entries to the .dynamic section. We fill in the
9881 values later, in ppc64_elf_finish_dynamic_sections, but we
9882 must add the entries now so that we get the correct size for
9883 the .dynamic section. The DT_DEBUG entry is filled in by the
9884 dynamic linker and used by the debugger. */
9885 #define add_dynamic_entry(TAG, VAL) \
9886 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
9887
9888 if (info->executable)
9889 {
9890 if (!add_dynamic_entry (DT_DEBUG, 0))
9891 return FALSE;
9892 }
9893
9894 if (htab->elf.splt != NULL && htab->elf.splt->size != 0)
9895 {
9896 if (!add_dynamic_entry (DT_PLTGOT, 0)
9897 || !add_dynamic_entry (DT_PLTRELSZ, 0)
9898 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
9899 || !add_dynamic_entry (DT_JMPREL, 0)
9900 || !add_dynamic_entry (DT_PPC64_GLINK, 0))
9901 return FALSE;
9902 }
9903
9904 if (NO_OPD_RELOCS && abiversion (output_bfd) <= 1)
9905 {
9906 if (!add_dynamic_entry (DT_PPC64_OPD, 0)
9907 || !add_dynamic_entry (DT_PPC64_OPDSZ, 0))
9908 return FALSE;
9909 }
9910
9911 tls_opt = (!htab->no_tls_get_addr_opt
9912 && htab->tls_get_addr_fd != NULL
9913 && htab->tls_get_addr_fd->elf.plt.plist != NULL);
9914 if (tls_opt || !htab->opd_abi)
9915 {
9916 if (!add_dynamic_entry (DT_PPC64_OPT, tls_opt ? PPC64_OPT_TLS : 0))
9917 return FALSE;
9918 }
9919
9920 if (relocs)
9921 {
9922 if (!add_dynamic_entry (DT_RELA, 0)
9923 || !add_dynamic_entry (DT_RELASZ, 0)
9924 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
9925 return FALSE;
9926
9927 /* If any dynamic relocs apply to a read-only section,
9928 then we need a DT_TEXTREL entry. */
9929 if ((info->flags & DF_TEXTREL) == 0)
9930 elf_link_hash_traverse (&htab->elf, maybe_set_textrel, info);
9931
9932 if ((info->flags & DF_TEXTREL) != 0)
9933 {
9934 if (!add_dynamic_entry (DT_TEXTREL, 0))
9935 return FALSE;
9936 }
9937 }
9938 }
9939 #undef add_dynamic_entry
9940
9941 return TRUE;
9942 }
9943
9944 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
9945
9946 static bfd_boolean
9947 ppc64_elf_hash_symbol (struct elf_link_hash_entry *h)
9948 {
9949 if (h->plt.plist != NULL
9950 && !h->def_regular
9951 && !h->pointer_equality_needed)
9952 return FALSE;
9953
9954 return _bfd_elf_hash_symbol (h);
9955 }
9956
9957 /* Determine the type of stub needed, if any, for a call. */
9958
9959 static inline enum ppc_stub_type
9960 ppc_type_of_stub (asection *input_sec,
9961 const Elf_Internal_Rela *rel,
9962 struct ppc_link_hash_entry **hash,
9963 struct plt_entry **plt_ent,
9964 bfd_vma destination,
9965 unsigned long local_off)
9966 {
9967 struct ppc_link_hash_entry *h = *hash;
9968 bfd_vma location;
9969 bfd_vma branch_offset;
9970 bfd_vma max_branch_offset;
9971 enum elf_ppc64_reloc_type r_type;
9972
9973 if (h != NULL)
9974 {
9975 struct plt_entry *ent;
9976 struct ppc_link_hash_entry *fdh = h;
9977 if (h->oh != NULL
9978 && h->oh->is_func_descriptor)
9979 {
9980 fdh = ppc_follow_link (h->oh);
9981 *hash = fdh;
9982 }
9983
9984 for (ent = fdh->elf.plt.plist; ent != NULL; ent = ent->next)
9985 if (ent->addend == rel->r_addend
9986 && ent->plt.offset != (bfd_vma) -1)
9987 {
9988 *plt_ent = ent;
9989 return ppc_stub_plt_call;
9990 }
9991
9992 /* Here, we know we don't have a plt entry. If we don't have a
9993 either a defined function descriptor or a defined entry symbol
9994 in a regular object file, then it is pointless trying to make
9995 any other type of stub. */
9996 if (!is_static_defined (&fdh->elf)
9997 && !is_static_defined (&h->elf))
9998 return ppc_stub_none;
9999 }
10000 else if (elf_local_got_ents (input_sec->owner) != NULL)
10001 {
10002 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (input_sec->owner);
10003 struct plt_entry **local_plt = (struct plt_entry **)
10004 elf_local_got_ents (input_sec->owner) + symtab_hdr->sh_info;
10005 unsigned long r_symndx = ELF64_R_SYM (rel->r_info);
10006
10007 if (local_plt[r_symndx] != NULL)
10008 {
10009 struct plt_entry *ent;
10010
10011 for (ent = local_plt[r_symndx]; ent != NULL; ent = ent->next)
10012 if (ent->addend == rel->r_addend
10013 && ent->plt.offset != (bfd_vma) -1)
10014 {
10015 *plt_ent = ent;
10016 return ppc_stub_plt_call;
10017 }
10018 }
10019 }
10020
10021 /* Determine where the call point is. */
10022 location = (input_sec->output_offset
10023 + input_sec->output_section->vma
10024 + rel->r_offset);
10025
10026 branch_offset = destination - location;
10027 r_type = ELF64_R_TYPE (rel->r_info);
10028
10029 /* Determine if a long branch stub is needed. */
10030 max_branch_offset = 1 << 25;
10031 if (r_type != R_PPC64_REL24)
10032 max_branch_offset = 1 << 15;
10033
10034 if (branch_offset + max_branch_offset >= 2 * max_branch_offset - local_off)
10035 /* We need a stub. Figure out whether a long_branch or plt_branch
10036 is needed later. */
10037 return ppc_stub_long_branch;
10038
10039 return ppc_stub_none;
10040 }
10041
10042 /* With power7 weakly ordered memory model, it is possible for ld.so
10043 to update a plt entry in one thread and have another thread see a
10044 stale zero toc entry. To avoid this we need some sort of acquire
10045 barrier in the call stub. One solution is to make the load of the
10046 toc word seem to appear to depend on the load of the function entry
10047 word. Another solution is to test for r2 being zero, and branch to
10048 the appropriate glink entry if so.
10049
10050 . fake dep barrier compare
10051 . ld 12,xxx(2) ld 12,xxx(2)
10052 . mtctr 12 mtctr 12
10053 . xor 11,12,12 ld 2,xxx+8(2)
10054 . add 2,2,11 cmpldi 2,0
10055 . ld 2,xxx+8(2) bnectr+
10056 . bctr b <glink_entry>
10057
10058 The solution involving the compare turns out to be faster, so
10059 that's what we use unless the branch won't reach. */
10060
10061 #define ALWAYS_USE_FAKE_DEP 0
10062 #define ALWAYS_EMIT_R2SAVE 0
10063
10064 #define PPC_LO(v) ((v) & 0xffff)
10065 #define PPC_HI(v) (((v) >> 16) & 0xffff)
10066 #define PPC_HA(v) PPC_HI ((v) + 0x8000)
10067
10068 static inline unsigned int
10069 plt_stub_size (struct ppc_link_hash_table *htab,
10070 struct ppc_stub_hash_entry *stub_entry,
10071 bfd_vma off)
10072 {
10073 unsigned size = 12;
10074
10075 if (ALWAYS_EMIT_R2SAVE
10076 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10077 size += 4;
10078 if (PPC_HA (off) != 0)
10079 size += 4;
10080 if (htab->opd_abi)
10081 {
10082 size += 4;
10083 if (htab->plt_static_chain)
10084 size += 4;
10085 if (htab->plt_thread_safe)
10086 size += 8;
10087 if (PPC_HA (off + 8 + 8 * htab->plt_static_chain) != PPC_HA (off))
10088 size += 4;
10089 }
10090 if (stub_entry->h != NULL
10091 && (stub_entry->h == htab->tls_get_addr_fd
10092 || stub_entry->h == htab->tls_get_addr)
10093 && !htab->no_tls_get_addr_opt)
10094 size += 13 * 4;
10095 return size;
10096 }
10097
10098 /* If this stub would cross fewer 2**plt_stub_align boundaries if we align,
10099 then return the padding needed to do so. */
10100 static inline unsigned int
10101 plt_stub_pad (struct ppc_link_hash_table *htab,
10102 struct ppc_stub_hash_entry *stub_entry,
10103 bfd_vma plt_off)
10104 {
10105 int stub_align = 1 << htab->plt_stub_align;
10106 unsigned stub_size = plt_stub_size (htab, stub_entry, plt_off);
10107 bfd_vma stub_off = stub_entry->stub_sec->size;
10108
10109 if (((stub_off + stub_size - 1) & -stub_align) - (stub_off & -stub_align)
10110 > (stub_size & -stub_align))
10111 return stub_align - (stub_off & (stub_align - 1));
10112 return 0;
10113 }
10114
10115 /* Build a .plt call stub. */
10116
10117 static inline bfd_byte *
10118 build_plt_stub (struct ppc_link_hash_table *htab,
10119 struct ppc_stub_hash_entry *stub_entry,
10120 bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
10121 {
10122 bfd *obfd = htab->stub_bfd;
10123 bfd_boolean plt_load_toc = htab->opd_abi;
10124 bfd_boolean plt_static_chain = htab->plt_static_chain;
10125 bfd_boolean plt_thread_safe = htab->plt_thread_safe;
10126 bfd_boolean use_fake_dep = plt_thread_safe;
10127 bfd_vma cmp_branch_off = 0;
10128
10129 if (!ALWAYS_USE_FAKE_DEP
10130 && plt_load_toc
10131 && plt_thread_safe
10132 && !(stub_entry->h != NULL
10133 && (stub_entry->h == htab->tls_get_addr_fd
10134 || stub_entry->h == htab->tls_get_addr)
10135 && !htab->no_tls_get_addr_opt))
10136 {
10137 bfd_vma pltoff = stub_entry->plt_ent->plt.offset & ~1;
10138 bfd_vma pltindex = ((pltoff - PLT_INITIAL_ENTRY_SIZE (htab))
10139 / PLT_ENTRY_SIZE (htab));
10140 bfd_vma glinkoff = GLINK_CALL_STUB_SIZE + pltindex * 8;
10141 bfd_vma to, from;
10142
10143 if (pltindex > 32768)
10144 glinkoff += (pltindex - 32768) * 4;
10145 to = (glinkoff
10146 + htab->glink->output_offset
10147 + htab->glink->output_section->vma);
10148 from = (p - stub_entry->stub_sec->contents
10149 + 4 * (ALWAYS_EMIT_R2SAVE
10150 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10151 + 4 * (PPC_HA (offset) != 0)
10152 + 4 * (PPC_HA (offset + 8 + 8 * plt_static_chain)
10153 != PPC_HA (offset))
10154 + 4 * (plt_static_chain != 0)
10155 + 20
10156 + stub_entry->stub_sec->output_offset
10157 + stub_entry->stub_sec->output_section->vma);
10158 cmp_branch_off = to - from;
10159 use_fake_dep = cmp_branch_off + (1 << 25) >= (1 << 26);
10160 }
10161
10162 if (PPC_HA (offset) != 0)
10163 {
10164 if (r != NULL)
10165 {
10166 if (ALWAYS_EMIT_R2SAVE
10167 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10168 r[0].r_offset += 4;
10169 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
10170 r[1].r_offset = r[0].r_offset + 4;
10171 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10172 r[1].r_addend = r[0].r_addend;
10173 if (plt_load_toc)
10174 {
10175 if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10176 {
10177 r[2].r_offset = r[1].r_offset + 4;
10178 r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO);
10179 r[2].r_addend = r[0].r_addend;
10180 }
10181 else
10182 {
10183 r[2].r_offset = r[1].r_offset + 8 + 8 * use_fake_dep;
10184 r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10185 r[2].r_addend = r[0].r_addend + 8;
10186 if (plt_static_chain)
10187 {
10188 r[3].r_offset = r[2].r_offset + 4;
10189 r[3].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10190 r[3].r_addend = r[0].r_addend + 16;
10191 }
10192 }
10193 }
10194 }
10195 if (ALWAYS_EMIT_R2SAVE
10196 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10197 bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p), p += 4;
10198 bfd_put_32 (obfd, ADDIS_R11_R2 | PPC_HA (offset), p), p += 4;
10199 bfd_put_32 (obfd, LD_R12_0R11 | PPC_LO (offset), p), p += 4;
10200 if (plt_load_toc
10201 && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10202 {
10203 bfd_put_32 (obfd, ADDI_R11_R11 | PPC_LO (offset), p), p += 4;
10204 offset = 0;
10205 }
10206 bfd_put_32 (obfd, MTCTR_R12, p), p += 4;
10207 if (plt_load_toc)
10208 {
10209 if (use_fake_dep)
10210 {
10211 bfd_put_32 (obfd, XOR_R2_R12_R12, p), p += 4;
10212 bfd_put_32 (obfd, ADD_R11_R11_R2, p), p += 4;
10213 }
10214 bfd_put_32 (obfd, LD_R2_0R11 | PPC_LO (offset + 8), p), p += 4;
10215 if (plt_static_chain)
10216 bfd_put_32 (obfd, LD_R11_0R11 | PPC_LO (offset + 16), p), p += 4;
10217 }
10218 }
10219 else
10220 {
10221 if (r != NULL)
10222 {
10223 if (ALWAYS_EMIT_R2SAVE
10224 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10225 r[0].r_offset += 4;
10226 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10227 if (plt_load_toc)
10228 {
10229 if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10230 {
10231 r[1].r_offset = r[0].r_offset + 4;
10232 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16);
10233 r[1].r_addend = r[0].r_addend;
10234 }
10235 else
10236 {
10237 r[1].r_offset = r[0].r_offset + 8 + 8 * use_fake_dep;
10238 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10239 r[1].r_addend = r[0].r_addend + 8 + 8 * plt_static_chain;
10240 if (plt_static_chain)
10241 {
10242 r[2].r_offset = r[1].r_offset + 4;
10243 r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10244 r[2].r_addend = r[0].r_addend + 8;
10245 }
10246 }
10247 }
10248 }
10249 if (ALWAYS_EMIT_R2SAVE
10250 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10251 bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p), p += 4;
10252 bfd_put_32 (obfd, LD_R12_0R2 | PPC_LO (offset), p), p += 4;
10253 if (plt_load_toc
10254 && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10255 {
10256 bfd_put_32 (obfd, ADDI_R2_R2 | PPC_LO (offset), p), p += 4;
10257 offset = 0;
10258 }
10259 bfd_put_32 (obfd, MTCTR_R12, p), p += 4;
10260 if (plt_load_toc)
10261 {
10262 if (use_fake_dep)
10263 {
10264 bfd_put_32 (obfd, XOR_R11_R12_R12, p), p += 4;
10265 bfd_put_32 (obfd, ADD_R2_R2_R11, p), p += 4;
10266 }
10267 if (plt_static_chain)
10268 bfd_put_32 (obfd, LD_R11_0R2 | PPC_LO (offset + 16), p), p += 4;
10269 bfd_put_32 (obfd, LD_R2_0R2 | PPC_LO (offset + 8), p), p += 4;
10270 }
10271 }
10272 if (plt_load_toc && plt_thread_safe && !use_fake_dep)
10273 {
10274 bfd_put_32 (obfd, CMPLDI_R2_0, p), p += 4;
10275 bfd_put_32 (obfd, BNECTR_P4, p), p += 4;
10276 bfd_put_32 (obfd, B_DOT | (cmp_branch_off & 0x3fffffc), p), p += 4;
10277 }
10278 else
10279 bfd_put_32 (obfd, BCTR, p), p += 4;
10280 return p;
10281 }
10282
10283 /* Build a special .plt call stub for __tls_get_addr. */
10284
10285 #define LD_R11_0R3 0xe9630000
10286 #define LD_R12_0R3 0xe9830000
10287 #define MR_R0_R3 0x7c601b78
10288 #define CMPDI_R11_0 0x2c2b0000
10289 #define ADD_R3_R12_R13 0x7c6c6a14
10290 #define BEQLR 0x4d820020
10291 #define MR_R3_R0 0x7c030378
10292 #define STD_R11_0R1 0xf9610000
10293 #define BCTRL 0x4e800421
10294 #define LD_R11_0R1 0xe9610000
10295 #define MTLR_R11 0x7d6803a6
10296
10297 static inline bfd_byte *
10298 build_tls_get_addr_stub (struct ppc_link_hash_table *htab,
10299 struct ppc_stub_hash_entry *stub_entry,
10300 bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
10301 {
10302 bfd *obfd = htab->stub_bfd;
10303
10304 bfd_put_32 (obfd, LD_R11_0R3 + 0, p), p += 4;
10305 bfd_put_32 (obfd, LD_R12_0R3 + 8, p), p += 4;
10306 bfd_put_32 (obfd, MR_R0_R3, p), p += 4;
10307 bfd_put_32 (obfd, CMPDI_R11_0, p), p += 4;
10308 bfd_put_32 (obfd, ADD_R3_R12_R13, p), p += 4;
10309 bfd_put_32 (obfd, BEQLR, p), p += 4;
10310 bfd_put_32 (obfd, MR_R3_R0, p), p += 4;
10311 bfd_put_32 (obfd, MFLR_R11, p), p += 4;
10312 bfd_put_32 (obfd, STD_R11_0R1 + STK_LINKER (htab), p), p += 4;
10313
10314 if (r != NULL)
10315 r[0].r_offset += 9 * 4;
10316 p = build_plt_stub (htab, stub_entry, p, offset, r);
10317 bfd_put_32 (obfd, BCTRL, p - 4);
10318
10319 bfd_put_32 (obfd, LD_R11_0R1 + STK_LINKER (htab), p), p += 4;
10320 bfd_put_32 (obfd, LD_R2_0R1 + STK_TOC (htab), p), p += 4;
10321 bfd_put_32 (obfd, MTLR_R11, p), p += 4;
10322 bfd_put_32 (obfd, BLR, p), p += 4;
10323
10324 return p;
10325 }
10326
10327 static Elf_Internal_Rela *
10328 get_relocs (asection *sec, int count)
10329 {
10330 Elf_Internal_Rela *relocs;
10331 struct bfd_elf_section_data *elfsec_data;
10332
10333 elfsec_data = elf_section_data (sec);
10334 relocs = elfsec_data->relocs;
10335 if (relocs == NULL)
10336 {
10337 bfd_size_type relsize;
10338 relsize = sec->reloc_count * sizeof (*relocs);
10339 relocs = bfd_alloc (sec->owner, relsize);
10340 if (relocs == NULL)
10341 return NULL;
10342 elfsec_data->relocs = relocs;
10343 elfsec_data->rela.hdr = bfd_zalloc (sec->owner,
10344 sizeof (Elf_Internal_Shdr));
10345 if (elfsec_data->rela.hdr == NULL)
10346 return NULL;
10347 elfsec_data->rela.hdr->sh_size = (sec->reloc_count
10348 * sizeof (Elf64_External_Rela));
10349 elfsec_data->rela.hdr->sh_entsize = sizeof (Elf64_External_Rela);
10350 sec->reloc_count = 0;
10351 }
10352 relocs += sec->reloc_count;
10353 sec->reloc_count += count;
10354 return relocs;
10355 }
10356
10357 static bfd_vma
10358 get_r2off (struct bfd_link_info *info,
10359 struct ppc_stub_hash_entry *stub_entry)
10360 {
10361 struct ppc_link_hash_table *htab = ppc_hash_table (info);
10362 bfd_vma r2off = htab->stub_group[stub_entry->target_section->id].toc_off;
10363
10364 if (r2off == 0)
10365 {
10366 /* Support linking -R objects. Get the toc pointer from the
10367 opd entry. */
10368 char buf[8];
10369 if (!htab->opd_abi)
10370 return r2off;
10371 asection *opd = stub_entry->h->elf.root.u.def.section;
10372 bfd_vma opd_off = stub_entry->h->elf.root.u.def.value;
10373
10374 if (strcmp (opd->name, ".opd") != 0
10375 || opd->reloc_count != 0)
10376 {
10377 info->callbacks->einfo (_("%P: cannot find opd entry toc for `%T'\n"),
10378 stub_entry->h->elf.root.root.string);
10379 bfd_set_error (bfd_error_bad_value);
10380 return 0;
10381 }
10382 if (!bfd_get_section_contents (opd->owner, opd, buf, opd_off + 8, 8))
10383 return 0;
10384 r2off = bfd_get_64 (opd->owner, buf);
10385 r2off -= elf_gp (info->output_bfd);
10386 }
10387 r2off -= htab->stub_group[stub_entry->id_sec->id].toc_off;
10388 return r2off;
10389 }
10390
10391 static bfd_boolean
10392 ppc_build_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
10393 {
10394 struct ppc_stub_hash_entry *stub_entry;
10395 struct ppc_branch_hash_entry *br_entry;
10396 struct bfd_link_info *info;
10397 struct ppc_link_hash_table *htab;
10398 bfd_byte *loc;
10399 bfd_byte *p;
10400 bfd_vma dest, off;
10401 int size;
10402 Elf_Internal_Rela *r;
10403 asection *plt;
10404
10405 /* Massage our args to the form they really have. */
10406 stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
10407 info = in_arg;
10408
10409 htab = ppc_hash_table (info);
10410 if (htab == NULL)
10411 return FALSE;
10412
10413 /* Make a note of the offset within the stubs for this entry. */
10414 stub_entry->stub_offset = stub_entry->stub_sec->size;
10415 loc = stub_entry->stub_sec->contents + stub_entry->stub_offset;
10416
10417 htab->stub_count[stub_entry->stub_type - 1] += 1;
10418 switch (stub_entry->stub_type)
10419 {
10420 case ppc_stub_long_branch:
10421 case ppc_stub_long_branch_r2off:
10422 /* Branches are relative. This is where we are going to. */
10423 dest = (stub_entry->target_value
10424 + stub_entry->target_section->output_offset
10425 + stub_entry->target_section->output_section->vma);
10426 dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
10427 off = dest;
10428
10429 /* And this is where we are coming from. */
10430 off -= (stub_entry->stub_offset
10431 + stub_entry->stub_sec->output_offset
10432 + stub_entry->stub_sec->output_section->vma);
10433
10434 size = 4;
10435 if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
10436 {
10437 bfd_vma r2off = get_r2off (info, stub_entry);
10438
10439 if (r2off == 0)
10440 {
10441 htab->stub_error = TRUE;
10442 return FALSE;
10443 }
10444 bfd_put_32 (htab->stub_bfd, STD_R2_0R1 + STK_TOC (htab), loc);
10445 loc += 4;
10446 size = 12;
10447 if (PPC_HA (r2off) != 0)
10448 {
10449 size = 16;
10450 bfd_put_32 (htab->stub_bfd, ADDIS_R2_R2 | PPC_HA (r2off), loc);
10451 loc += 4;
10452 }
10453 bfd_put_32 (htab->stub_bfd, ADDI_R2_R2 | PPC_LO (r2off), loc);
10454 loc += 4;
10455 off -= size - 4;
10456 }
10457 bfd_put_32 (htab->stub_bfd, B_DOT | (off & 0x3fffffc), loc);
10458
10459 if (off + (1 << 25) >= (bfd_vma) (1 << 26))
10460 {
10461 info->callbacks->einfo
10462 (_("%P: long branch stub `%s' offset overflow\n"),
10463 stub_entry->root.string);
10464 htab->stub_error = TRUE;
10465 return FALSE;
10466 }
10467
10468 if (info->emitrelocations)
10469 {
10470 r = get_relocs (stub_entry->stub_sec, 1);
10471 if (r == NULL)
10472 return FALSE;
10473 r->r_offset = loc - stub_entry->stub_sec->contents;
10474 r->r_info = ELF64_R_INFO (0, R_PPC64_REL24);
10475 r->r_addend = dest;
10476 if (stub_entry->h != NULL)
10477 {
10478 struct elf_link_hash_entry **hashes;
10479 unsigned long symndx;
10480 struct ppc_link_hash_entry *h;
10481
10482 hashes = elf_sym_hashes (htab->stub_bfd);
10483 if (hashes == NULL)
10484 {
10485 bfd_size_type hsize;
10486
10487 hsize = (htab->stub_globals + 1) * sizeof (*hashes);
10488 hashes = bfd_zalloc (htab->stub_bfd, hsize);
10489 if (hashes == NULL)
10490 return FALSE;
10491 elf_sym_hashes (htab->stub_bfd) = hashes;
10492 htab->stub_globals = 1;
10493 }
10494 symndx = htab->stub_globals++;
10495 h = stub_entry->h;
10496 hashes[symndx] = &h->elf;
10497 r->r_info = ELF64_R_INFO (symndx, R_PPC64_REL24);
10498 if (h->oh != NULL && h->oh->is_func)
10499 h = ppc_follow_link (h->oh);
10500 if (h->elf.root.u.def.section != stub_entry->target_section)
10501 /* H is an opd symbol. The addend must be zero. */
10502 r->r_addend = 0;
10503 else
10504 {
10505 off = (h->elf.root.u.def.value
10506 + h->elf.root.u.def.section->output_offset
10507 + h->elf.root.u.def.section->output_section->vma);
10508 r->r_addend -= off;
10509 }
10510 }
10511 }
10512 break;
10513
10514 case ppc_stub_plt_branch:
10515 case ppc_stub_plt_branch_r2off:
10516 br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
10517 stub_entry->root.string + 9,
10518 FALSE, FALSE);
10519 if (br_entry == NULL)
10520 {
10521 info->callbacks->einfo (_("%P: can't find branch stub `%s'\n"),
10522 stub_entry->root.string);
10523 htab->stub_error = TRUE;
10524 return FALSE;
10525 }
10526
10527 dest = (stub_entry->target_value
10528 + stub_entry->target_section->output_offset
10529 + stub_entry->target_section->output_section->vma);
10530 if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
10531 dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
10532
10533 bfd_put_64 (htab->brlt->owner, dest,
10534 htab->brlt->contents + br_entry->offset);
10535
10536 if (br_entry->iter == htab->stub_iteration)
10537 {
10538 br_entry->iter = 0;
10539
10540 if (htab->relbrlt != NULL)
10541 {
10542 /* Create a reloc for the branch lookup table entry. */
10543 Elf_Internal_Rela rela;
10544 bfd_byte *rl;
10545
10546 rela.r_offset = (br_entry->offset
10547 + htab->brlt->output_offset
10548 + htab->brlt->output_section->vma);
10549 rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
10550 rela.r_addend = dest;
10551
10552 rl = htab->relbrlt->contents;
10553 rl += (htab->relbrlt->reloc_count++
10554 * sizeof (Elf64_External_Rela));
10555 bfd_elf64_swap_reloca_out (htab->relbrlt->owner, &rela, rl);
10556 }
10557 else if (info->emitrelocations)
10558 {
10559 r = get_relocs (htab->brlt, 1);
10560 if (r == NULL)
10561 return FALSE;
10562 /* brlt, being SEC_LINKER_CREATED does not go through the
10563 normal reloc processing. Symbols and offsets are not
10564 translated from input file to output file form, so
10565 set up the offset per the output file. */
10566 r->r_offset = (br_entry->offset
10567 + htab->brlt->output_offset
10568 + htab->brlt->output_section->vma);
10569 r->r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
10570 r->r_addend = dest;
10571 }
10572 }
10573
10574 dest = (br_entry->offset
10575 + htab->brlt->output_offset
10576 + htab->brlt->output_section->vma);
10577
10578 off = (dest
10579 - elf_gp (htab->brlt->output_section->owner)
10580 - htab->stub_group[stub_entry->id_sec->id].toc_off);
10581
10582 if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
10583 {
10584 info->callbacks->einfo
10585 (_("%P: linkage table error against `%T'\n"),
10586 stub_entry->root.string);
10587 bfd_set_error (bfd_error_bad_value);
10588 htab->stub_error = TRUE;
10589 return FALSE;
10590 }
10591
10592 if (info->emitrelocations)
10593 {
10594 r = get_relocs (stub_entry->stub_sec, 1 + (PPC_HA (off) != 0));
10595 if (r == NULL)
10596 return FALSE;
10597 r[0].r_offset = loc - stub_entry->stub_sec->contents;
10598 if (bfd_big_endian (info->output_bfd))
10599 r[0].r_offset += 2;
10600 if (stub_entry->stub_type == ppc_stub_plt_branch_r2off
10601 && htab->opd_abi)
10602 r[0].r_offset += 4;
10603 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10604 r[0].r_addend = dest;
10605 if (PPC_HA (off) != 0)
10606 {
10607 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
10608 r[1].r_offset = r[0].r_offset + 4;
10609 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10610 r[1].r_addend = r[0].r_addend;
10611 }
10612 }
10613
10614 if (stub_entry->stub_type != ppc_stub_plt_branch_r2off
10615 || !htab->opd_abi)
10616 {
10617 if (PPC_HA (off) != 0)
10618 {
10619 size = 16;
10620 bfd_put_32 (htab->stub_bfd, ADDIS_R11_R2 | PPC_HA (off), loc);
10621 loc += 4;
10622 bfd_put_32 (htab->stub_bfd, LD_R12_0R11 | PPC_LO (off), loc);
10623 }
10624 else
10625 {
10626 size = 12;
10627 bfd_put_32 (htab->stub_bfd, LD_R12_0R2 | PPC_LO (off), loc);
10628 }
10629 }
10630 else
10631 {
10632 bfd_vma r2off = get_r2off (info, stub_entry);
10633
10634 if (r2off == 0)
10635 {
10636 htab->stub_error = TRUE;
10637 return FALSE;
10638 }
10639
10640 bfd_put_32 (htab->stub_bfd, STD_R2_0R1 + STK_TOC (htab), loc);
10641 loc += 4;
10642 size = 20;
10643 if (PPC_HA (off) != 0)
10644 {
10645 size += 4;
10646 bfd_put_32 (htab->stub_bfd, ADDIS_R11_R2 | PPC_HA (off), loc);
10647 loc += 4;
10648 bfd_put_32 (htab->stub_bfd, LD_R12_0R11 | PPC_LO (off), loc);
10649 loc += 4;
10650 }
10651 else
10652 {
10653 bfd_put_32 (htab->stub_bfd, LD_R12_0R2 | PPC_LO (off), loc);
10654 loc += 4;
10655 }
10656
10657 if (PPC_HA (r2off) != 0)
10658 {
10659 size += 4;
10660 bfd_put_32 (htab->stub_bfd, ADDIS_R2_R2 | PPC_HA (r2off), loc);
10661 loc += 4;
10662 }
10663 bfd_put_32 (htab->stub_bfd, ADDI_R2_R2 | PPC_LO (r2off), loc);
10664 }
10665 loc += 4;
10666 bfd_put_32 (htab->stub_bfd, MTCTR_R12, loc);
10667 loc += 4;
10668 bfd_put_32 (htab->stub_bfd, BCTR, loc);
10669 break;
10670
10671 case ppc_stub_plt_call:
10672 case ppc_stub_plt_call_r2save:
10673 if (stub_entry->h != NULL
10674 && stub_entry->h->is_func_descriptor
10675 && stub_entry->h->oh != NULL)
10676 {
10677 struct ppc_link_hash_entry *fh = ppc_follow_link (stub_entry->h->oh);
10678
10679 /* If the old-ABI "dot-symbol" is undefined make it weak so
10680 we don't get a link error from RELOC_FOR_GLOBAL_SYMBOL.
10681 FIXME: We used to define the symbol on one of the call
10682 stubs instead, which is why we test symbol section id
10683 against htab->top_id in various places. Likely all
10684 these checks could now disappear. */
10685 if (fh->elf.root.type == bfd_link_hash_undefined)
10686 fh->elf.root.type = bfd_link_hash_undefweak;
10687 /* Stop undo_symbol_twiddle changing it back to undefined. */
10688 fh->was_undefined = 0;
10689 }
10690
10691 /* Now build the stub. */
10692 dest = stub_entry->plt_ent->plt.offset & ~1;
10693 if (dest >= (bfd_vma) -2)
10694 abort ();
10695
10696 plt = htab->elf.splt;
10697 if (!htab->elf.dynamic_sections_created
10698 || stub_entry->h == NULL
10699 || stub_entry->h->elf.dynindx == -1)
10700 plt = htab->elf.iplt;
10701
10702 dest += plt->output_offset + plt->output_section->vma;
10703
10704 if (stub_entry->h == NULL
10705 && (stub_entry->plt_ent->plt.offset & 1) == 0)
10706 {
10707 Elf_Internal_Rela rela;
10708 bfd_byte *rl;
10709
10710 rela.r_offset = dest;
10711 if (htab->opd_abi)
10712 rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
10713 else
10714 rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
10715 rela.r_addend = (stub_entry->target_value
10716 + stub_entry->target_section->output_offset
10717 + stub_entry->target_section->output_section->vma);
10718
10719 rl = (htab->elf.irelplt->contents
10720 + (htab->elf.irelplt->reloc_count++
10721 * sizeof (Elf64_External_Rela)));
10722 bfd_elf64_swap_reloca_out (info->output_bfd, &rela, rl);
10723 stub_entry->plt_ent->plt.offset |= 1;
10724 }
10725
10726 off = (dest
10727 - elf_gp (plt->output_section->owner)
10728 - htab->stub_group[stub_entry->id_sec->id].toc_off);
10729
10730 if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
10731 {
10732 info->callbacks->einfo
10733 (_("%P: linkage table error against `%T'\n"),
10734 stub_entry->h != NULL
10735 ? stub_entry->h->elf.root.root.string
10736 : "<local sym>");
10737 bfd_set_error (bfd_error_bad_value);
10738 htab->stub_error = TRUE;
10739 return FALSE;
10740 }
10741
10742 if (htab->plt_stub_align != 0)
10743 {
10744 unsigned pad = plt_stub_pad (htab, stub_entry, off);
10745
10746 stub_entry->stub_sec->size += pad;
10747 stub_entry->stub_offset = stub_entry->stub_sec->size;
10748 loc += pad;
10749 }
10750
10751 r = NULL;
10752 if (info->emitrelocations)
10753 {
10754 r = get_relocs (stub_entry->stub_sec,
10755 (2
10756 + (PPC_HA (off) != 0)
10757 + (htab->plt_static_chain
10758 && PPC_HA (off + 16) == PPC_HA (off))));
10759 if (r == NULL)
10760 return FALSE;
10761 r[0].r_offset = loc - stub_entry->stub_sec->contents;
10762 if (bfd_big_endian (info->output_bfd))
10763 r[0].r_offset += 2;
10764 r[0].r_addend = dest;
10765 }
10766 if (stub_entry->h != NULL
10767 && (stub_entry->h == htab->tls_get_addr_fd
10768 || stub_entry->h == htab->tls_get_addr)
10769 && !htab->no_tls_get_addr_opt)
10770 p = build_tls_get_addr_stub (htab, stub_entry, loc, off, r);
10771 else
10772 p = build_plt_stub (htab, stub_entry, loc, off, r);
10773 size = p - loc;
10774 break;
10775
10776 default:
10777 BFD_FAIL ();
10778 return FALSE;
10779 }
10780
10781 stub_entry->stub_sec->size += size;
10782
10783 if (htab->emit_stub_syms)
10784 {
10785 struct elf_link_hash_entry *h;
10786 size_t len1, len2;
10787 char *name;
10788 const char *const stub_str[] = { "long_branch",
10789 "long_branch_r2off",
10790 "plt_branch",
10791 "plt_branch_r2off",
10792 "plt_call",
10793 "plt_call" };
10794
10795 len1 = strlen (stub_str[stub_entry->stub_type - 1]);
10796 len2 = strlen (stub_entry->root.string);
10797 name = bfd_malloc (len1 + len2 + 2);
10798 if (name == NULL)
10799 return FALSE;
10800 memcpy (name, stub_entry->root.string, 9);
10801 memcpy (name + 9, stub_str[stub_entry->stub_type - 1], len1);
10802 memcpy (name + len1 + 9, stub_entry->root.string + 8, len2 - 8 + 1);
10803 h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
10804 if (h == NULL)
10805 return FALSE;
10806 if (h->root.type == bfd_link_hash_new)
10807 {
10808 h->root.type = bfd_link_hash_defined;
10809 h->root.u.def.section = stub_entry->stub_sec;
10810 h->root.u.def.value = stub_entry->stub_offset;
10811 h->ref_regular = 1;
10812 h->def_regular = 1;
10813 h->ref_regular_nonweak = 1;
10814 h->forced_local = 1;
10815 h->non_elf = 0;
10816 }
10817 }
10818
10819 return TRUE;
10820 }
10821
10822 /* As above, but don't actually build the stub. Just bump offset so
10823 we know stub section sizes, and select plt_branch stubs where
10824 long_branch stubs won't do. */
10825
10826 static bfd_boolean
10827 ppc_size_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
10828 {
10829 struct ppc_stub_hash_entry *stub_entry;
10830 struct bfd_link_info *info;
10831 struct ppc_link_hash_table *htab;
10832 bfd_vma off;
10833 int size;
10834
10835 /* Massage our args to the form they really have. */
10836 stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
10837 info = in_arg;
10838
10839 htab = ppc_hash_table (info);
10840 if (htab == NULL)
10841 return FALSE;
10842
10843 if (stub_entry->stub_type == ppc_stub_plt_call
10844 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10845 {
10846 asection *plt;
10847 off = stub_entry->plt_ent->plt.offset & ~(bfd_vma) 1;
10848 if (off >= (bfd_vma) -2)
10849 abort ();
10850 plt = htab->elf.splt;
10851 if (!htab->elf.dynamic_sections_created
10852 || stub_entry->h == NULL
10853 || stub_entry->h->elf.dynindx == -1)
10854 plt = htab->elf.iplt;
10855 off += (plt->output_offset
10856 + plt->output_section->vma
10857 - elf_gp (plt->output_section->owner)
10858 - htab->stub_group[stub_entry->id_sec->id].toc_off);
10859
10860 size = plt_stub_size (htab, stub_entry, off);
10861 if (htab->plt_stub_align)
10862 size += plt_stub_pad (htab, stub_entry, off);
10863 if (info->emitrelocations)
10864 {
10865 stub_entry->stub_sec->reloc_count
10866 += ((PPC_HA (off) != 0)
10867 + (htab->opd_abi
10868 ? 2 + (htab->plt_static_chain
10869 && PPC_HA (off + 16) == PPC_HA (off))
10870 : 1));
10871 stub_entry->stub_sec->flags |= SEC_RELOC;
10872 }
10873 }
10874 else
10875 {
10876 /* ppc_stub_long_branch or ppc_stub_plt_branch, or their r2off
10877 variants. */
10878 bfd_vma r2off = 0;
10879 bfd_vma local_off = 0;
10880
10881 off = (stub_entry->target_value
10882 + stub_entry->target_section->output_offset
10883 + stub_entry->target_section->output_section->vma);
10884 off -= (stub_entry->stub_sec->size
10885 + stub_entry->stub_sec->output_offset
10886 + stub_entry->stub_sec->output_section->vma);
10887
10888 /* Reset the stub type from the plt variant in case we now
10889 can reach with a shorter stub. */
10890 if (stub_entry->stub_type >= ppc_stub_plt_branch)
10891 stub_entry->stub_type += ppc_stub_long_branch - ppc_stub_plt_branch;
10892
10893 size = 4;
10894 if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
10895 {
10896 r2off = get_r2off (info, stub_entry);
10897 if (r2off == 0 && htab->opd_abi)
10898 {
10899 htab->stub_error = TRUE;
10900 return FALSE;
10901 }
10902 size = 12;
10903 if (PPC_HA (r2off) != 0)
10904 size = 16;
10905 off -= size - 4;
10906 }
10907
10908 local_off = PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
10909
10910 /* If the branch offset if too big, use a ppc_stub_plt_branch.
10911 Do the same for -R objects without function descriptors. */
10912 if (off + (1 << 25) >= (bfd_vma) (1 << 26) - local_off
10913 || (stub_entry->stub_type == ppc_stub_long_branch_r2off
10914 && r2off == 0))
10915 {
10916 struct ppc_branch_hash_entry *br_entry;
10917
10918 br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
10919 stub_entry->root.string + 9,
10920 TRUE, FALSE);
10921 if (br_entry == NULL)
10922 {
10923 info->callbacks->einfo (_("%P: can't build branch stub `%s'\n"),
10924 stub_entry->root.string);
10925 htab->stub_error = TRUE;
10926 return FALSE;
10927 }
10928
10929 if (br_entry->iter != htab->stub_iteration)
10930 {
10931 br_entry->iter = htab->stub_iteration;
10932 br_entry->offset = htab->brlt->size;
10933 htab->brlt->size += 8;
10934
10935 if (htab->relbrlt != NULL)
10936 htab->relbrlt->size += sizeof (Elf64_External_Rela);
10937 else if (info->emitrelocations)
10938 {
10939 htab->brlt->reloc_count += 1;
10940 htab->brlt->flags |= SEC_RELOC;
10941 }
10942 }
10943
10944 stub_entry->stub_type += ppc_stub_plt_branch - ppc_stub_long_branch;
10945 off = (br_entry->offset
10946 + htab->brlt->output_offset
10947 + htab->brlt->output_section->vma
10948 - elf_gp (htab->brlt->output_section->owner)
10949 - htab->stub_group[stub_entry->id_sec->id].toc_off);
10950
10951 if (info->emitrelocations)
10952 {
10953 stub_entry->stub_sec->reloc_count += 1 + (PPC_HA (off) != 0);
10954 stub_entry->stub_sec->flags |= SEC_RELOC;
10955 }
10956
10957 if (stub_entry->stub_type != ppc_stub_plt_branch_r2off
10958 || !htab->opd_abi)
10959 {
10960 size = 12;
10961 if (PPC_HA (off) != 0)
10962 size = 16;
10963 }
10964 else
10965 {
10966 size = 20;
10967 if (PPC_HA (off) != 0)
10968 size += 4;
10969
10970 if (PPC_HA (r2off) != 0)
10971 size += 4;
10972 }
10973 }
10974 else if (info->emitrelocations)
10975 {
10976 stub_entry->stub_sec->reloc_count += 1;
10977 stub_entry->stub_sec->flags |= SEC_RELOC;
10978 }
10979 }
10980
10981 stub_entry->stub_sec->size += size;
10982 return TRUE;
10983 }
10984
10985 /* Set up various things so that we can make a list of input sections
10986 for each output section included in the link. Returns -1 on error,
10987 0 when no stubs will be needed, and 1 on success. */
10988
10989 int
10990 ppc64_elf_setup_section_lists
10991 (struct bfd_link_info *info,
10992 asection *(*add_stub_section) (const char *, asection *),
10993 void (*layout_sections_again) (void))
10994 {
10995 bfd *input_bfd;
10996 int top_id, top_index, id;
10997 asection *section;
10998 asection **input_list;
10999 bfd_size_type amt;
11000 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11001
11002 if (htab == NULL)
11003 return -1;
11004 /* Stash our params away. */
11005 htab->add_stub_section = add_stub_section;
11006 htab->layout_sections_again = layout_sections_again;
11007
11008 /* Find the top input section id. */
11009 for (input_bfd = info->input_bfds, top_id = 3;
11010 input_bfd != NULL;
11011 input_bfd = input_bfd->link_next)
11012 {
11013 for (section = input_bfd->sections;
11014 section != NULL;
11015 section = section->next)
11016 {
11017 if (top_id < section->id)
11018 top_id = section->id;
11019 }
11020 }
11021
11022 htab->top_id = top_id;
11023 amt = sizeof (struct map_stub) * (top_id + 1);
11024 htab->stub_group = bfd_zmalloc (amt);
11025 if (htab->stub_group == NULL)
11026 return -1;
11027
11028 /* Set toc_off for com, und, abs and ind sections. */
11029 for (id = 0; id < 3; id++)
11030 htab->stub_group[id].toc_off = TOC_BASE_OFF;
11031
11032 /* We can't use output_bfd->section_count here to find the top output
11033 section index as some sections may have been removed, and
11034 strip_excluded_output_sections doesn't renumber the indices. */
11035 for (section = info->output_bfd->sections, top_index = 0;
11036 section != NULL;
11037 section = section->next)
11038 {
11039 if (top_index < section->index)
11040 top_index = section->index;
11041 }
11042
11043 htab->top_index = top_index;
11044 amt = sizeof (asection *) * (top_index + 1);
11045 input_list = bfd_zmalloc (amt);
11046 htab->input_list = input_list;
11047 if (input_list == NULL)
11048 return -1;
11049
11050 return 1;
11051 }
11052
11053 /* Set up for first pass at multitoc partitioning. */
11054
11055 void
11056 ppc64_elf_start_multitoc_partition (struct bfd_link_info *info)
11057 {
11058 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11059
11060 htab->toc_curr = ppc64_elf_set_toc (info, info->output_bfd);
11061 htab->toc_bfd = NULL;
11062 htab->toc_first_sec = NULL;
11063 }
11064
11065 /* The linker repeatedly calls this function for each TOC input section
11066 and linker generated GOT section. Group input bfds such that the toc
11067 within a group is less than 64k in size. */
11068
11069 bfd_boolean
11070 ppc64_elf_next_toc_section (struct bfd_link_info *info, asection *isec)
11071 {
11072 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11073 bfd_vma addr, off, limit;
11074
11075 if (htab == NULL)
11076 return FALSE;
11077
11078 if (!htab->second_toc_pass)
11079 {
11080 /* Keep track of the first .toc or .got section for this input bfd. */
11081 bfd_boolean new_bfd = htab->toc_bfd != isec->owner;
11082
11083 if (new_bfd)
11084 {
11085 htab->toc_bfd = isec->owner;
11086 htab->toc_first_sec = isec;
11087 }
11088
11089 addr = isec->output_offset + isec->output_section->vma;
11090 off = addr - htab->toc_curr;
11091 limit = 0x80008000;
11092 if (ppc64_elf_tdata (isec->owner)->has_small_toc_reloc)
11093 limit = 0x10000;
11094 if (off + isec->size > limit)
11095 {
11096 addr = (htab->toc_first_sec->output_offset
11097 + htab->toc_first_sec->output_section->vma);
11098 htab->toc_curr = addr;
11099 }
11100
11101 /* toc_curr is the base address of this toc group. Set elf_gp
11102 for the input section to be the offset relative to the
11103 output toc base plus 0x8000. Making the input elf_gp an
11104 offset allows us to move the toc as a whole without
11105 recalculating input elf_gp. */
11106 off = htab->toc_curr - elf_gp (isec->output_section->owner);
11107 off += TOC_BASE_OFF;
11108
11109 /* Die if someone uses a linker script that doesn't keep input
11110 file .toc and .got together. */
11111 if (new_bfd
11112 && elf_gp (isec->owner) != 0
11113 && elf_gp (isec->owner) != off)
11114 return FALSE;
11115
11116 elf_gp (isec->owner) = off;
11117 return TRUE;
11118 }
11119
11120 /* During the second pass toc_first_sec points to the start of
11121 a toc group, and toc_curr is used to track the old elf_gp.
11122 We use toc_bfd to ensure we only look at each bfd once. */
11123 if (htab->toc_bfd == isec->owner)
11124 return TRUE;
11125 htab->toc_bfd = isec->owner;
11126
11127 if (htab->toc_first_sec == NULL
11128 || htab->toc_curr != elf_gp (isec->owner))
11129 {
11130 htab->toc_curr = elf_gp (isec->owner);
11131 htab->toc_first_sec = isec;
11132 }
11133 addr = (htab->toc_first_sec->output_offset
11134 + htab->toc_first_sec->output_section->vma);
11135 off = addr - elf_gp (isec->output_section->owner) + TOC_BASE_OFF;
11136 elf_gp (isec->owner) = off;
11137
11138 return TRUE;
11139 }
11140
11141 /* Called via elf_link_hash_traverse to merge GOT entries for global
11142 symbol H. */
11143
11144 static bfd_boolean
11145 merge_global_got (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
11146 {
11147 if (h->root.type == bfd_link_hash_indirect)
11148 return TRUE;
11149
11150 merge_got_entries (&h->got.glist);
11151
11152 return TRUE;
11153 }
11154
11155 /* Called via elf_link_hash_traverse to allocate GOT entries for global
11156 symbol H. */
11157
11158 static bfd_boolean
11159 reallocate_got (struct elf_link_hash_entry *h, void *inf)
11160 {
11161 struct got_entry *gent;
11162
11163 if (h->root.type == bfd_link_hash_indirect)
11164 return TRUE;
11165
11166 for (gent = h->got.glist; gent != NULL; gent = gent->next)
11167 if (!gent->is_indirect)
11168 allocate_got (h, (struct bfd_link_info *) inf, gent);
11169 return TRUE;
11170 }
11171
11172 /* Called on the first multitoc pass after the last call to
11173 ppc64_elf_next_toc_section. This function removes duplicate GOT
11174 entries. */
11175
11176 bfd_boolean
11177 ppc64_elf_layout_multitoc (struct bfd_link_info *info)
11178 {
11179 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11180 struct bfd *ibfd, *ibfd2;
11181 bfd_boolean done_something;
11182
11183 htab->multi_toc_needed = htab->toc_curr != elf_gp (info->output_bfd);
11184
11185 if (!htab->do_multi_toc)
11186 return FALSE;
11187
11188 /* Merge global sym got entries within a toc group. */
11189 elf_link_hash_traverse (&htab->elf, merge_global_got, info);
11190
11191 /* And tlsld_got. */
11192 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
11193 {
11194 struct got_entry *ent, *ent2;
11195
11196 if (!is_ppc64_elf (ibfd))
11197 continue;
11198
11199 ent = ppc64_tlsld_got (ibfd);
11200 if (!ent->is_indirect
11201 && ent->got.offset != (bfd_vma) -1)
11202 {
11203 for (ibfd2 = ibfd->link_next; ibfd2 != NULL; ibfd2 = ibfd2->link_next)
11204 {
11205 if (!is_ppc64_elf (ibfd2))
11206 continue;
11207
11208 ent2 = ppc64_tlsld_got (ibfd2);
11209 if (!ent2->is_indirect
11210 && ent2->got.offset != (bfd_vma) -1
11211 && elf_gp (ibfd2) == elf_gp (ibfd))
11212 {
11213 ent2->is_indirect = TRUE;
11214 ent2->got.ent = ent;
11215 }
11216 }
11217 }
11218 }
11219
11220 /* Zap sizes of got sections. */
11221 htab->elf.irelplt->rawsize = htab->elf.irelplt->size;
11222 htab->elf.irelplt->size -= htab->got_reli_size;
11223 htab->got_reli_size = 0;
11224
11225 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
11226 {
11227 asection *got, *relgot;
11228
11229 if (!is_ppc64_elf (ibfd))
11230 continue;
11231
11232 got = ppc64_elf_tdata (ibfd)->got;
11233 if (got != NULL)
11234 {
11235 got->rawsize = got->size;
11236 got->size = 0;
11237 relgot = ppc64_elf_tdata (ibfd)->relgot;
11238 relgot->rawsize = relgot->size;
11239 relgot->size = 0;
11240 }
11241 }
11242
11243 /* Now reallocate the got, local syms first. We don't need to
11244 allocate section contents again since we never increase size. */
11245 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
11246 {
11247 struct got_entry **lgot_ents;
11248 struct got_entry **end_lgot_ents;
11249 struct plt_entry **local_plt;
11250 struct plt_entry **end_local_plt;
11251 unsigned char *lgot_masks;
11252 bfd_size_type locsymcount;
11253 Elf_Internal_Shdr *symtab_hdr;
11254 asection *s;
11255
11256 if (!is_ppc64_elf (ibfd))
11257 continue;
11258
11259 lgot_ents = elf_local_got_ents (ibfd);
11260 if (!lgot_ents)
11261 continue;
11262
11263 symtab_hdr = &elf_symtab_hdr (ibfd);
11264 locsymcount = symtab_hdr->sh_info;
11265 end_lgot_ents = lgot_ents + locsymcount;
11266 local_plt = (struct plt_entry **) end_lgot_ents;
11267 end_local_plt = local_plt + locsymcount;
11268 lgot_masks = (unsigned char *) end_local_plt;
11269 s = ppc64_elf_tdata (ibfd)->got;
11270 for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
11271 {
11272 struct got_entry *ent;
11273
11274 for (ent = *lgot_ents; ent != NULL; ent = ent->next)
11275 {
11276 unsigned int ent_size = 8;
11277 unsigned int rel_size = sizeof (Elf64_External_Rela);
11278
11279 ent->got.offset = s->size;
11280 if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
11281 {
11282 ent_size *= 2;
11283 rel_size *= 2;
11284 }
11285 s->size += ent_size;
11286 if ((*lgot_masks & PLT_IFUNC) != 0)
11287 {
11288 htab->elf.irelplt->size += rel_size;
11289 htab->got_reli_size += rel_size;
11290 }
11291 else if (info->shared)
11292 {
11293 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
11294 srel->size += rel_size;
11295 }
11296 }
11297 }
11298 }
11299
11300 elf_link_hash_traverse (&htab->elf, reallocate_got, info);
11301
11302 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
11303 {
11304 struct got_entry *ent;
11305
11306 if (!is_ppc64_elf (ibfd))
11307 continue;
11308
11309 ent = ppc64_tlsld_got (ibfd);
11310 if (!ent->is_indirect
11311 && ent->got.offset != (bfd_vma) -1)
11312 {
11313 asection *s = ppc64_elf_tdata (ibfd)->got;
11314 ent->got.offset = s->size;
11315 s->size += 16;
11316 if (info->shared)
11317 {
11318 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
11319 srel->size += sizeof (Elf64_External_Rela);
11320 }
11321 }
11322 }
11323
11324 done_something = htab->elf.irelplt->rawsize != htab->elf.irelplt->size;
11325 if (!done_something)
11326 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
11327 {
11328 asection *got;
11329
11330 if (!is_ppc64_elf (ibfd))
11331 continue;
11332
11333 got = ppc64_elf_tdata (ibfd)->got;
11334 if (got != NULL)
11335 {
11336 done_something = got->rawsize != got->size;
11337 if (done_something)
11338 break;
11339 }
11340 }
11341
11342 if (done_something)
11343 (*htab->layout_sections_again) ();
11344
11345 /* Set up for second pass over toc sections to recalculate elf_gp
11346 on input sections. */
11347 htab->toc_bfd = NULL;
11348 htab->toc_first_sec = NULL;
11349 htab->second_toc_pass = TRUE;
11350 return done_something;
11351 }
11352
11353 /* Called after second pass of multitoc partitioning. */
11354
11355 void
11356 ppc64_elf_finish_multitoc_partition (struct bfd_link_info *info)
11357 {
11358 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11359
11360 /* After the second pass, toc_curr tracks the TOC offset used
11361 for code sections below in ppc64_elf_next_input_section. */
11362 htab->toc_curr = TOC_BASE_OFF;
11363 }
11364
11365 /* No toc references were found in ISEC. If the code in ISEC makes no
11366 calls, then there's no need to use toc adjusting stubs when branching
11367 into ISEC. Actually, indirect calls from ISEC are OK as they will
11368 load r2. Returns -1 on error, 0 for no stub needed, 1 for stub
11369 needed, and 2 if a cyclical call-graph was found but no other reason
11370 for a stub was detected. If called from the top level, a return of
11371 2 means the same as a return of 0. */
11372
11373 static int
11374 toc_adjusting_stub_needed (struct bfd_link_info *info, asection *isec)
11375 {
11376 int ret;
11377
11378 /* Mark this section as checked. */
11379 isec->call_check_done = 1;
11380
11381 /* We know none of our code bearing sections will need toc stubs. */
11382 if ((isec->flags & SEC_LINKER_CREATED) != 0)
11383 return 0;
11384
11385 if (isec->size == 0)
11386 return 0;
11387
11388 if (isec->output_section == NULL)
11389 return 0;
11390
11391 ret = 0;
11392 if (isec->reloc_count != 0)
11393 {
11394 Elf_Internal_Rela *relstart, *rel;
11395 Elf_Internal_Sym *local_syms;
11396 struct ppc_link_hash_table *htab;
11397
11398 relstart = _bfd_elf_link_read_relocs (isec->owner, isec, NULL, NULL,
11399 info->keep_memory);
11400 if (relstart == NULL)
11401 return -1;
11402
11403 /* Look for branches to outside of this section. */
11404 local_syms = NULL;
11405 htab = ppc_hash_table (info);
11406 if (htab == NULL)
11407 return -1;
11408
11409 for (rel = relstart; rel < relstart + isec->reloc_count; ++rel)
11410 {
11411 enum elf_ppc64_reloc_type r_type;
11412 unsigned long r_symndx;
11413 struct elf_link_hash_entry *h;
11414 struct ppc_link_hash_entry *eh;
11415 Elf_Internal_Sym *sym;
11416 asection *sym_sec;
11417 struct _opd_sec_data *opd;
11418 bfd_vma sym_value;
11419 bfd_vma dest;
11420
11421 r_type = ELF64_R_TYPE (rel->r_info);
11422 if (r_type != R_PPC64_REL24
11423 && r_type != R_PPC64_REL14
11424 && r_type != R_PPC64_REL14_BRTAKEN
11425 && r_type != R_PPC64_REL14_BRNTAKEN)
11426 continue;
11427
11428 r_symndx = ELF64_R_SYM (rel->r_info);
11429 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms, r_symndx,
11430 isec->owner))
11431 {
11432 ret = -1;
11433 break;
11434 }
11435
11436 /* Calls to dynamic lib functions go through a plt call stub
11437 that uses r2. */
11438 eh = (struct ppc_link_hash_entry *) h;
11439 if (eh != NULL
11440 && (eh->elf.plt.plist != NULL
11441 || (eh->oh != NULL
11442 && ppc_follow_link (eh->oh)->elf.plt.plist != NULL)))
11443 {
11444 ret = 1;
11445 break;
11446 }
11447
11448 if (sym_sec == NULL)
11449 /* Ignore other undefined symbols. */
11450 continue;
11451
11452 /* Assume branches to other sections not included in the
11453 link need stubs too, to cover -R and absolute syms. */
11454 if (sym_sec->output_section == NULL)
11455 {
11456 ret = 1;
11457 break;
11458 }
11459
11460 if (h == NULL)
11461 sym_value = sym->st_value;
11462 else
11463 {
11464 if (h->root.type != bfd_link_hash_defined
11465 && h->root.type != bfd_link_hash_defweak)
11466 abort ();
11467 sym_value = h->root.u.def.value;
11468 }
11469 sym_value += rel->r_addend;
11470
11471 /* If this branch reloc uses an opd sym, find the code section. */
11472 opd = get_opd_info (sym_sec);
11473 if (opd != NULL)
11474 {
11475 if (h == NULL && opd->adjust != NULL)
11476 {
11477 long adjust;
11478
11479 adjust = opd->adjust[sym->st_value / 8];
11480 if (adjust == -1)
11481 /* Assume deleted functions won't ever be called. */
11482 continue;
11483 sym_value += adjust;
11484 }
11485
11486 dest = opd_entry_value (sym_sec, sym_value,
11487 &sym_sec, NULL, FALSE);
11488 if (dest == (bfd_vma) -1)
11489 continue;
11490 }
11491 else
11492 dest = (sym_value
11493 + sym_sec->output_offset
11494 + sym_sec->output_section->vma);
11495
11496 /* Ignore branch to self. */
11497 if (sym_sec == isec)
11498 continue;
11499
11500 /* If the called function uses the toc, we need a stub. */
11501 if (sym_sec->has_toc_reloc
11502 || sym_sec->makes_toc_func_call)
11503 {
11504 ret = 1;
11505 break;
11506 }
11507
11508 /* Assume any branch that needs a long branch stub might in fact
11509 need a plt_branch stub. A plt_branch stub uses r2. */
11510 else if (dest - (isec->output_offset
11511 + isec->output_section->vma
11512 + rel->r_offset) + (1 << 25)
11513 >= (2u << 25) - PPC64_LOCAL_ENTRY_OFFSET (h
11514 ? h->other
11515 : sym->st_other))
11516 {
11517 ret = 1;
11518 break;
11519 }
11520
11521 /* If calling back to a section in the process of being
11522 tested, we can't say for sure that no toc adjusting stubs
11523 are needed, so don't return zero. */
11524 else if (sym_sec->call_check_in_progress)
11525 ret = 2;
11526
11527 /* Branches to another section that itself doesn't have any TOC
11528 references are OK. Recursively call ourselves to check. */
11529 else if (!sym_sec->call_check_done)
11530 {
11531 int recur;
11532
11533 /* Mark current section as indeterminate, so that other
11534 sections that call back to current won't be marked as
11535 known. */
11536 isec->call_check_in_progress = 1;
11537 recur = toc_adjusting_stub_needed (info, sym_sec);
11538 isec->call_check_in_progress = 0;
11539
11540 if (recur != 0)
11541 {
11542 ret = recur;
11543 if (recur != 2)
11544 break;
11545 }
11546 }
11547 }
11548
11549 if (local_syms != NULL
11550 && (elf_symtab_hdr (isec->owner).contents
11551 != (unsigned char *) local_syms))
11552 free (local_syms);
11553 if (elf_section_data (isec)->relocs != relstart)
11554 free (relstart);
11555 }
11556
11557 if ((ret & 1) == 0
11558 && isec->map_head.s != NULL
11559 && (strcmp (isec->output_section->name, ".init") == 0
11560 || strcmp (isec->output_section->name, ".fini") == 0))
11561 {
11562 if (isec->map_head.s->has_toc_reloc
11563 || isec->map_head.s->makes_toc_func_call)
11564 ret = 1;
11565 else if (!isec->map_head.s->call_check_done)
11566 {
11567 int recur;
11568 isec->call_check_in_progress = 1;
11569 recur = toc_adjusting_stub_needed (info, isec->map_head.s);
11570 isec->call_check_in_progress = 0;
11571 if (recur != 0)
11572 ret = recur;
11573 }
11574 }
11575
11576 if (ret == 1)
11577 isec->makes_toc_func_call = 1;
11578
11579 return ret;
11580 }
11581
11582 /* The linker repeatedly calls this function for each input section,
11583 in the order that input sections are linked into output sections.
11584 Build lists of input sections to determine groupings between which
11585 we may insert linker stubs. */
11586
11587 bfd_boolean
11588 ppc64_elf_next_input_section (struct bfd_link_info *info, asection *isec)
11589 {
11590 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11591
11592 if (htab == NULL)
11593 return FALSE;
11594
11595 if ((isec->output_section->flags & SEC_CODE) != 0
11596 && isec->output_section->index <= htab->top_index)
11597 {
11598 asection **list = htab->input_list + isec->output_section->index;
11599 /* Steal the link_sec pointer for our list. */
11600 #define PREV_SEC(sec) (htab->stub_group[(sec)->id].link_sec)
11601 /* This happens to make the list in reverse order,
11602 which is what we want. */
11603 PREV_SEC (isec) = *list;
11604 *list = isec;
11605 }
11606
11607 if (htab->multi_toc_needed)
11608 {
11609 /* Analyse sections that aren't already flagged as needing a
11610 valid toc pointer. Exclude .fixup for the linux kernel.
11611 .fixup contains branches, but only back to the function that
11612 hit an exception. */
11613 if (!(isec->has_toc_reloc
11614 || (isec->flags & SEC_CODE) == 0
11615 || strcmp (isec->name, ".fixup") == 0
11616 || isec->call_check_done))
11617 {
11618 if (toc_adjusting_stub_needed (info, isec) < 0)
11619 return FALSE;
11620 }
11621 /* Make all sections use the TOC assigned for this object file.
11622 This will be wrong for pasted sections; We fix that in
11623 check_pasted_section(). */
11624 if (elf_gp (isec->owner) != 0)
11625 htab->toc_curr = elf_gp (isec->owner);
11626 }
11627
11628 htab->stub_group[isec->id].toc_off = htab->toc_curr;
11629 return TRUE;
11630 }
11631
11632 /* Check that all .init and .fini sections use the same toc, if they
11633 have toc relocs. */
11634
11635 static bfd_boolean
11636 check_pasted_section (struct bfd_link_info *info, const char *name)
11637 {
11638 asection *o = bfd_get_section_by_name (info->output_bfd, name);
11639
11640 if (o != NULL)
11641 {
11642 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11643 bfd_vma toc_off = 0;
11644 asection *i;
11645
11646 for (i = o->map_head.s; i != NULL; i = i->map_head.s)
11647 if (i->has_toc_reloc)
11648 {
11649 if (toc_off == 0)
11650 toc_off = htab->stub_group[i->id].toc_off;
11651 else if (toc_off != htab->stub_group[i->id].toc_off)
11652 return FALSE;
11653 }
11654
11655 if (toc_off == 0)
11656 for (i = o->map_head.s; i != NULL; i = i->map_head.s)
11657 if (i->makes_toc_func_call)
11658 {
11659 toc_off = htab->stub_group[i->id].toc_off;
11660 break;
11661 }
11662
11663 /* Make sure the whole pasted function uses the same toc offset. */
11664 if (toc_off != 0)
11665 for (i = o->map_head.s; i != NULL; i = i->map_head.s)
11666 htab->stub_group[i->id].toc_off = toc_off;
11667 }
11668 return TRUE;
11669 }
11670
11671 bfd_boolean
11672 ppc64_elf_check_init_fini (struct bfd_link_info *info)
11673 {
11674 return (check_pasted_section (info, ".init")
11675 & check_pasted_section (info, ".fini"));
11676 }
11677
11678 /* See whether we can group stub sections together. Grouping stub
11679 sections may result in fewer stubs. More importantly, we need to
11680 put all .init* and .fini* stubs at the beginning of the .init or
11681 .fini output sections respectively, because glibc splits the
11682 _init and _fini functions into multiple parts. Putting a stub in
11683 the middle of a function is not a good idea. */
11684
11685 static void
11686 group_sections (struct ppc_link_hash_table *htab,
11687 bfd_size_type stub_group_size,
11688 bfd_boolean stubs_always_before_branch)
11689 {
11690 asection **list;
11691 bfd_size_type stub14_group_size;
11692 bfd_boolean suppress_size_errors;
11693
11694 suppress_size_errors = FALSE;
11695 stub14_group_size = stub_group_size;
11696 if (stub_group_size == 1)
11697 {
11698 /* Default values. */
11699 if (stubs_always_before_branch)
11700 {
11701 stub_group_size = 0x1e00000;
11702 stub14_group_size = 0x7800;
11703 }
11704 else
11705 {
11706 stub_group_size = 0x1c00000;
11707 stub14_group_size = 0x7000;
11708 }
11709 suppress_size_errors = TRUE;
11710 }
11711
11712 list = htab->input_list + htab->top_index;
11713 do
11714 {
11715 asection *tail = *list;
11716 while (tail != NULL)
11717 {
11718 asection *curr;
11719 asection *prev;
11720 bfd_size_type total;
11721 bfd_boolean big_sec;
11722 bfd_vma curr_toc;
11723
11724 curr = tail;
11725 total = tail->size;
11726 big_sec = total > (ppc64_elf_section_data (tail) != NULL
11727 && ppc64_elf_section_data (tail)->has_14bit_branch
11728 ? stub14_group_size : stub_group_size);
11729 if (big_sec && !suppress_size_errors)
11730 (*_bfd_error_handler) (_("%B section %A exceeds stub group size"),
11731 tail->owner, tail);
11732 curr_toc = htab->stub_group[tail->id].toc_off;
11733
11734 while ((prev = PREV_SEC (curr)) != NULL
11735 && ((total += curr->output_offset - prev->output_offset)
11736 < (ppc64_elf_section_data (prev) != NULL
11737 && ppc64_elf_section_data (prev)->has_14bit_branch
11738 ? stub14_group_size : stub_group_size))
11739 && htab->stub_group[prev->id].toc_off == curr_toc)
11740 curr = prev;
11741
11742 /* OK, the size from the start of CURR to the end is less
11743 than stub_group_size and thus can be handled by one stub
11744 section. (or the tail section is itself larger than
11745 stub_group_size, in which case we may be toast.) We
11746 should really be keeping track of the total size of stubs
11747 added here, as stubs contribute to the final output
11748 section size. That's a little tricky, and this way will
11749 only break if stubs added make the total size more than
11750 2^25, ie. for the default stub_group_size, if stubs total
11751 more than 2097152 bytes, or nearly 75000 plt call stubs. */
11752 do
11753 {
11754 prev = PREV_SEC (tail);
11755 /* Set up this stub group. */
11756 htab->stub_group[tail->id].link_sec = curr;
11757 }
11758 while (tail != curr && (tail = prev) != NULL);
11759
11760 /* But wait, there's more! Input sections up to stub_group_size
11761 bytes before the stub section can be handled by it too.
11762 Don't do this if we have a really large section after the
11763 stubs, as adding more stubs increases the chance that
11764 branches may not reach into the stub section. */
11765 if (!stubs_always_before_branch && !big_sec)
11766 {
11767 total = 0;
11768 while (prev != NULL
11769 && ((total += tail->output_offset - prev->output_offset)
11770 < (ppc64_elf_section_data (prev) != NULL
11771 && ppc64_elf_section_data (prev)->has_14bit_branch
11772 ? stub14_group_size : stub_group_size))
11773 && htab->stub_group[prev->id].toc_off == curr_toc)
11774 {
11775 tail = prev;
11776 prev = PREV_SEC (tail);
11777 htab->stub_group[tail->id].link_sec = curr;
11778 }
11779 }
11780 tail = prev;
11781 }
11782 }
11783 while (list-- != htab->input_list);
11784 free (htab->input_list);
11785 #undef PREV_SEC
11786 }
11787
11788 static const unsigned char glink_eh_frame_cie[] =
11789 {
11790 0, 0, 0, 16, /* length. */
11791 0, 0, 0, 0, /* id. */
11792 1, /* CIE version. */
11793 'z', 'R', 0, /* Augmentation string. */
11794 4, /* Code alignment. */
11795 0x78, /* Data alignment. */
11796 65, /* RA reg. */
11797 1, /* Augmentation size. */
11798 DW_EH_PE_pcrel | DW_EH_PE_sdata4, /* FDE encoding. */
11799 DW_CFA_def_cfa, 1, 0 /* def_cfa: r1 offset 0. */
11800 };
11801
11802 /* Stripping output sections is normally done before dynamic section
11803 symbols have been allocated. This function is called later, and
11804 handles cases like htab->brlt which is mapped to its own output
11805 section. */
11806
11807 static void
11808 maybe_strip_output (struct bfd_link_info *info, asection *isec)
11809 {
11810 if (isec->size == 0
11811 && isec->output_section->size == 0
11812 && !(isec->output_section->flags & SEC_KEEP)
11813 && !bfd_section_removed_from_list (info->output_bfd,
11814 isec->output_section)
11815 && elf_section_data (isec->output_section)->dynindx == 0)
11816 {
11817 isec->output_section->flags |= SEC_EXCLUDE;
11818 bfd_section_list_remove (info->output_bfd, isec->output_section);
11819 info->output_bfd->section_count--;
11820 }
11821 }
11822
11823 /* Determine and set the size of the stub section for a final link.
11824
11825 The basic idea here is to examine all the relocations looking for
11826 PC-relative calls to a target that is unreachable with a "bl"
11827 instruction. */
11828
11829 bfd_boolean
11830 ppc64_elf_size_stubs (struct bfd_link_info *info, bfd_signed_vma group_size,
11831 bfd_boolean plt_static_chain, int plt_thread_safe,
11832 int plt_stub_align)
11833 {
11834 bfd_size_type stub_group_size;
11835 bfd_boolean stubs_always_before_branch;
11836 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11837
11838 if (htab == NULL)
11839 return FALSE;
11840
11841 htab->plt_static_chain = plt_static_chain;
11842 htab->plt_stub_align = plt_stub_align;
11843 if (plt_thread_safe == -1 && !info->executable)
11844 plt_thread_safe = 1;
11845 if (!htab->opd_abi)
11846 plt_thread_safe = 0;
11847 else if (plt_thread_safe == -1)
11848 {
11849 static const char *const thread_starter[] =
11850 {
11851 "pthread_create",
11852 /* libstdc++ */
11853 "_ZNSt6thread15_M_start_threadESt10shared_ptrINS_10_Impl_baseEE",
11854 /* librt */
11855 "aio_init", "aio_read", "aio_write", "aio_fsync", "lio_listio",
11856 "mq_notify", "create_timer",
11857 /* libanl */
11858 "getaddrinfo_a",
11859 /* libgomp */
11860 "GOMP_parallel_start",
11861 "GOMP_parallel_loop_static_start",
11862 "GOMP_parallel_loop_dynamic_start",
11863 "GOMP_parallel_loop_guided_start",
11864 "GOMP_parallel_loop_runtime_start",
11865 "GOMP_parallel_sections_start",
11866 };
11867 unsigned i;
11868
11869 for (i = 0; i < sizeof (thread_starter)/ sizeof (thread_starter[0]); i++)
11870 {
11871 struct elf_link_hash_entry *h;
11872 h = elf_link_hash_lookup (&htab->elf, thread_starter[i],
11873 FALSE, FALSE, TRUE);
11874 plt_thread_safe = h != NULL && h->ref_regular;
11875 if (plt_thread_safe)
11876 break;
11877 }
11878 }
11879 htab->plt_thread_safe = plt_thread_safe;
11880 stubs_always_before_branch = group_size < 0;
11881 if (group_size < 0)
11882 stub_group_size = -group_size;
11883 else
11884 stub_group_size = group_size;
11885
11886 group_sections (htab, stub_group_size, stubs_always_before_branch);
11887
11888 while (1)
11889 {
11890 bfd *input_bfd;
11891 unsigned int bfd_indx;
11892 asection *stub_sec;
11893
11894 htab->stub_iteration += 1;
11895
11896 for (input_bfd = info->input_bfds, bfd_indx = 0;
11897 input_bfd != NULL;
11898 input_bfd = input_bfd->link_next, bfd_indx++)
11899 {
11900 Elf_Internal_Shdr *symtab_hdr;
11901 asection *section;
11902 Elf_Internal_Sym *local_syms = NULL;
11903
11904 if (!is_ppc64_elf (input_bfd))
11905 continue;
11906
11907 /* We'll need the symbol table in a second. */
11908 symtab_hdr = &elf_symtab_hdr (input_bfd);
11909 if (symtab_hdr->sh_info == 0)
11910 continue;
11911
11912 /* Walk over each section attached to the input bfd. */
11913 for (section = input_bfd->sections;
11914 section != NULL;
11915 section = section->next)
11916 {
11917 Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
11918
11919 /* If there aren't any relocs, then there's nothing more
11920 to do. */
11921 if ((section->flags & SEC_RELOC) == 0
11922 || (section->flags & SEC_ALLOC) == 0
11923 || (section->flags & SEC_LOAD) == 0
11924 || (section->flags & SEC_CODE) == 0
11925 || section->reloc_count == 0)
11926 continue;
11927
11928 /* If this section is a link-once section that will be
11929 discarded, then don't create any stubs. */
11930 if (section->output_section == NULL
11931 || section->output_section->owner != info->output_bfd)
11932 continue;
11933
11934 /* Get the relocs. */
11935 internal_relocs
11936 = _bfd_elf_link_read_relocs (input_bfd, section, NULL, NULL,
11937 info->keep_memory);
11938 if (internal_relocs == NULL)
11939 goto error_ret_free_local;
11940
11941 /* Now examine each relocation. */
11942 irela = internal_relocs;
11943 irelaend = irela + section->reloc_count;
11944 for (; irela < irelaend; irela++)
11945 {
11946 enum elf_ppc64_reloc_type r_type;
11947 unsigned int r_indx;
11948 enum ppc_stub_type stub_type;
11949 struct ppc_stub_hash_entry *stub_entry;
11950 asection *sym_sec, *code_sec;
11951 bfd_vma sym_value, code_value;
11952 bfd_vma destination;
11953 unsigned long local_off;
11954 bfd_boolean ok_dest;
11955 struct ppc_link_hash_entry *hash;
11956 struct ppc_link_hash_entry *fdh;
11957 struct elf_link_hash_entry *h;
11958 Elf_Internal_Sym *sym;
11959 char *stub_name;
11960 const asection *id_sec;
11961 struct _opd_sec_data *opd;
11962 struct plt_entry *plt_ent;
11963
11964 r_type = ELF64_R_TYPE (irela->r_info);
11965 r_indx = ELF64_R_SYM (irela->r_info);
11966
11967 if (r_type >= R_PPC64_max)
11968 {
11969 bfd_set_error (bfd_error_bad_value);
11970 goto error_ret_free_internal;
11971 }
11972
11973 /* Only look for stubs on branch instructions. */
11974 if (r_type != R_PPC64_REL24
11975 && r_type != R_PPC64_REL14
11976 && r_type != R_PPC64_REL14_BRTAKEN
11977 && r_type != R_PPC64_REL14_BRNTAKEN)
11978 continue;
11979
11980 /* Now determine the call target, its name, value,
11981 section. */
11982 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
11983 r_indx, input_bfd))
11984 goto error_ret_free_internal;
11985 hash = (struct ppc_link_hash_entry *) h;
11986
11987 ok_dest = FALSE;
11988 fdh = NULL;
11989 sym_value = 0;
11990 if (hash == NULL)
11991 {
11992 sym_value = sym->st_value;
11993 ok_dest = TRUE;
11994 }
11995 else if (hash->elf.root.type == bfd_link_hash_defined
11996 || hash->elf.root.type == bfd_link_hash_defweak)
11997 {
11998 sym_value = hash->elf.root.u.def.value;
11999 if (sym_sec->output_section != NULL)
12000 ok_dest = TRUE;
12001 }
12002 else if (hash->elf.root.type == bfd_link_hash_undefweak
12003 || hash->elf.root.type == bfd_link_hash_undefined)
12004 {
12005 /* Recognise an old ABI func code entry sym, and
12006 use the func descriptor sym instead if it is
12007 defined. */
12008 if (hash->elf.root.root.string[0] == '.'
12009 && (fdh = lookup_fdh (hash, htab)) != NULL)
12010 {
12011 if (fdh->elf.root.type == bfd_link_hash_defined
12012 || fdh->elf.root.type == bfd_link_hash_defweak)
12013 {
12014 sym_sec = fdh->elf.root.u.def.section;
12015 sym_value = fdh->elf.root.u.def.value;
12016 if (sym_sec->output_section != NULL)
12017 ok_dest = TRUE;
12018 }
12019 else
12020 fdh = NULL;
12021 }
12022 }
12023 else
12024 {
12025 bfd_set_error (bfd_error_bad_value);
12026 goto error_ret_free_internal;
12027 }
12028
12029 destination = 0;
12030 local_off = 0;
12031 if (ok_dest)
12032 {
12033 sym_value += irela->r_addend;
12034 destination = (sym_value
12035 + sym_sec->output_offset
12036 + sym_sec->output_section->vma);
12037 local_off = PPC64_LOCAL_ENTRY_OFFSET (hash
12038 ? hash->elf.other
12039 : sym->st_other);
12040 }
12041
12042 code_sec = sym_sec;
12043 code_value = sym_value;
12044 opd = get_opd_info (sym_sec);
12045 if (opd != NULL)
12046 {
12047 bfd_vma dest;
12048
12049 if (hash == NULL && opd->adjust != NULL)
12050 {
12051 long adjust = opd->adjust[sym_value / 8];
12052 if (adjust == -1)
12053 continue;
12054 code_value += adjust;
12055 sym_value += adjust;
12056 }
12057 dest = opd_entry_value (sym_sec, sym_value,
12058 &code_sec, &code_value, FALSE);
12059 if (dest != (bfd_vma) -1)
12060 {
12061 destination = dest;
12062 if (fdh != NULL)
12063 {
12064 /* Fixup old ABI sym to point at code
12065 entry. */
12066 hash->elf.root.type = bfd_link_hash_defweak;
12067 hash->elf.root.u.def.section = code_sec;
12068 hash->elf.root.u.def.value = code_value;
12069 }
12070 }
12071 }
12072
12073 /* Determine what (if any) linker stub is needed. */
12074 plt_ent = NULL;
12075 stub_type = ppc_type_of_stub (section, irela, &hash,
12076 &plt_ent, destination,
12077 local_off);
12078
12079 if (stub_type != ppc_stub_plt_call)
12080 {
12081 /* Check whether we need a TOC adjusting stub.
12082 Since the linker pastes together pieces from
12083 different object files when creating the
12084 _init and _fini functions, it may be that a
12085 call to what looks like a local sym is in
12086 fact a call needing a TOC adjustment. */
12087 if (code_sec != NULL
12088 && code_sec->output_section != NULL
12089 && (htab->stub_group[code_sec->id].toc_off
12090 != htab->stub_group[section->id].toc_off)
12091 && (code_sec->has_toc_reloc
12092 || code_sec->makes_toc_func_call))
12093 stub_type = ppc_stub_long_branch_r2off;
12094 }
12095
12096 if (stub_type == ppc_stub_none)
12097 continue;
12098
12099 /* __tls_get_addr calls might be eliminated. */
12100 if (stub_type != ppc_stub_plt_call
12101 && hash != NULL
12102 && (hash == htab->tls_get_addr
12103 || hash == htab->tls_get_addr_fd)
12104 && section->has_tls_reloc
12105 && irela != internal_relocs)
12106 {
12107 /* Get tls info. */
12108 unsigned char *tls_mask;
12109
12110 if (!get_tls_mask (&tls_mask, NULL, NULL, &local_syms,
12111 irela - 1, input_bfd))
12112 goto error_ret_free_internal;
12113 if (*tls_mask != 0)
12114 continue;
12115 }
12116
12117 if (stub_type == ppc_stub_plt_call
12118 && irela + 1 < irelaend
12119 && irela[1].r_offset == irela->r_offset + 4
12120 && ELF64_R_TYPE (irela[1].r_info) == R_PPC64_TOCSAVE)
12121 {
12122 if (!tocsave_find (htab, INSERT,
12123 &local_syms, irela + 1, input_bfd))
12124 goto error_ret_free_internal;
12125 }
12126 else if (stub_type == ppc_stub_plt_call)
12127 stub_type = ppc_stub_plt_call_r2save;
12128
12129 /* Support for grouping stub sections. */
12130 id_sec = htab->stub_group[section->id].link_sec;
12131
12132 /* Get the name of this stub. */
12133 stub_name = ppc_stub_name (id_sec, sym_sec, hash, irela);
12134 if (!stub_name)
12135 goto error_ret_free_internal;
12136
12137 stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
12138 stub_name, FALSE, FALSE);
12139 if (stub_entry != NULL)
12140 {
12141 /* The proper stub has already been created. */
12142 free (stub_name);
12143 if (stub_type == ppc_stub_plt_call_r2save)
12144 stub_entry->stub_type = stub_type;
12145 continue;
12146 }
12147
12148 stub_entry = ppc_add_stub (stub_name, section, info);
12149 if (stub_entry == NULL)
12150 {
12151 free (stub_name);
12152 error_ret_free_internal:
12153 if (elf_section_data (section)->relocs == NULL)
12154 free (internal_relocs);
12155 error_ret_free_local:
12156 if (local_syms != NULL
12157 && (symtab_hdr->contents
12158 != (unsigned char *) local_syms))
12159 free (local_syms);
12160 return FALSE;
12161 }
12162
12163 stub_entry->stub_type = stub_type;
12164 if (stub_type != ppc_stub_plt_call
12165 && stub_type != ppc_stub_plt_call_r2save)
12166 {
12167 stub_entry->target_value = code_value;
12168 stub_entry->target_section = code_sec;
12169 }
12170 else
12171 {
12172 stub_entry->target_value = sym_value;
12173 stub_entry->target_section = sym_sec;
12174 }
12175 stub_entry->h = hash;
12176 stub_entry->plt_ent = plt_ent;
12177 stub_entry->other = hash ? hash->elf.other : sym->st_other;
12178
12179 if (stub_entry->h != NULL)
12180 htab->stub_globals += 1;
12181 }
12182
12183 /* We're done with the internal relocs, free them. */
12184 if (elf_section_data (section)->relocs != internal_relocs)
12185 free (internal_relocs);
12186 }
12187
12188 if (local_syms != NULL
12189 && symtab_hdr->contents != (unsigned char *) local_syms)
12190 {
12191 if (!info->keep_memory)
12192 free (local_syms);
12193 else
12194 symtab_hdr->contents = (unsigned char *) local_syms;
12195 }
12196 }
12197
12198 /* We may have added some stubs. Find out the new size of the
12199 stub sections. */
12200 for (stub_sec = htab->stub_bfd->sections;
12201 stub_sec != NULL;
12202 stub_sec = stub_sec->next)
12203 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12204 {
12205 stub_sec->rawsize = stub_sec->size;
12206 stub_sec->size = 0;
12207 stub_sec->reloc_count = 0;
12208 stub_sec->flags &= ~SEC_RELOC;
12209 }
12210
12211 htab->brlt->size = 0;
12212 htab->brlt->reloc_count = 0;
12213 htab->brlt->flags &= ~SEC_RELOC;
12214 if (htab->relbrlt != NULL)
12215 htab->relbrlt->size = 0;
12216
12217 bfd_hash_traverse (&htab->stub_hash_table, ppc_size_one_stub, info);
12218
12219 if (info->emitrelocations
12220 && htab->glink != NULL && htab->glink->size != 0)
12221 {
12222 htab->glink->reloc_count = 1;
12223 htab->glink->flags |= SEC_RELOC;
12224 }
12225
12226 if (htab->glink_eh_frame != NULL
12227 && !bfd_is_abs_section (htab->glink_eh_frame->output_section)
12228 && htab->glink_eh_frame->output_section->size != 0)
12229 {
12230 size_t size = 0, align;
12231
12232 for (stub_sec = htab->stub_bfd->sections;
12233 stub_sec != NULL;
12234 stub_sec = stub_sec->next)
12235 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12236 size += 20;
12237 if (htab->glink != NULL && htab->glink->size != 0)
12238 size += 24;
12239 if (size != 0)
12240 size += sizeof (glink_eh_frame_cie);
12241 align = 1;
12242 align <<= htab->glink_eh_frame->output_section->alignment_power;
12243 align -= 1;
12244 size = (size + align) & ~align;
12245 htab->glink_eh_frame->rawsize = htab->glink_eh_frame->size;
12246 htab->glink_eh_frame->size = size;
12247 }
12248
12249 if (htab->plt_stub_align != 0)
12250 for (stub_sec = htab->stub_bfd->sections;
12251 stub_sec != NULL;
12252 stub_sec = stub_sec->next)
12253 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12254 stub_sec->size = ((stub_sec->size + (1 << htab->plt_stub_align) - 1)
12255 & (-1 << htab->plt_stub_align));
12256
12257 for (stub_sec = htab->stub_bfd->sections;
12258 stub_sec != NULL;
12259 stub_sec = stub_sec->next)
12260 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
12261 && stub_sec->rawsize != stub_sec->size)
12262 break;
12263
12264 /* Exit from this loop when no stubs have been added, and no stubs
12265 have changed size. */
12266 if (stub_sec == NULL
12267 && (htab->glink_eh_frame == NULL
12268 || htab->glink_eh_frame->rawsize == htab->glink_eh_frame->size))
12269 break;
12270
12271 /* Ask the linker to do its stuff. */
12272 (*htab->layout_sections_again) ();
12273 }
12274
12275 maybe_strip_output (info, htab->brlt);
12276 if (htab->glink_eh_frame != NULL)
12277 maybe_strip_output (info, htab->glink_eh_frame);
12278
12279 return TRUE;
12280 }
12281
12282 /* Called after we have determined section placement. If sections
12283 move, we'll be called again. Provide a value for TOCstart. */
12284
12285 bfd_vma
12286 ppc64_elf_set_toc (struct bfd_link_info *info, bfd *obfd)
12287 {
12288 asection *s;
12289 bfd_vma TOCstart;
12290
12291 /* The TOC consists of sections .got, .toc, .tocbss, .plt in that
12292 order. The TOC starts where the first of these sections starts. */
12293 s = bfd_get_section_by_name (obfd, ".got");
12294 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12295 s = bfd_get_section_by_name (obfd, ".toc");
12296 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12297 s = bfd_get_section_by_name (obfd, ".tocbss");
12298 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12299 s = bfd_get_section_by_name (obfd, ".plt");
12300 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12301 {
12302 /* This may happen for
12303 o references to TOC base (SYM@toc / TOC[tc0]) without a
12304 .toc directive
12305 o bad linker script
12306 o --gc-sections and empty TOC sections
12307
12308 FIXME: Warn user? */
12309
12310 /* Look for a likely section. We probably won't even be
12311 using TOCstart. */
12312 for (s = obfd->sections; s != NULL; s = s->next)
12313 if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_READONLY
12314 | SEC_EXCLUDE))
12315 == (SEC_ALLOC | SEC_SMALL_DATA))
12316 break;
12317 if (s == NULL)
12318 for (s = obfd->sections; s != NULL; s = s->next)
12319 if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_EXCLUDE))
12320 == (SEC_ALLOC | SEC_SMALL_DATA))
12321 break;
12322 if (s == NULL)
12323 for (s = obfd->sections; s != NULL; s = s->next)
12324 if ((s->flags & (SEC_ALLOC | SEC_READONLY | SEC_EXCLUDE))
12325 == SEC_ALLOC)
12326 break;
12327 if (s == NULL)
12328 for (s = obfd->sections; s != NULL; s = s->next)
12329 if ((s->flags & (SEC_ALLOC | SEC_EXCLUDE)) == SEC_ALLOC)
12330 break;
12331 }
12332
12333 TOCstart = 0;
12334 if (s != NULL)
12335 TOCstart = s->output_section->vma + s->output_offset;
12336
12337 _bfd_set_gp_value (obfd, TOCstart);
12338
12339 if (info != NULL && s != NULL && is_ppc64_elf (obfd))
12340 {
12341 struct ppc_link_hash_table *htab = ppc_hash_table (info);
12342
12343 if (htab != NULL
12344 && htab->elf.hgot != NULL)
12345 {
12346 htab->elf.hgot->root.u.def.value = TOC_BASE_OFF;
12347 htab->elf.hgot->root.u.def.section = s;
12348 }
12349 }
12350 return TOCstart;
12351 }
12352
12353 /* Called via elf_link_hash_traverse from ppc64_elf_build_stubs to
12354 write out any global entry stubs. */
12355
12356 static bfd_boolean
12357 build_global_entry_stubs (struct elf_link_hash_entry *h, void *inf)
12358 {
12359 struct bfd_link_info *info;
12360 struct ppc_link_hash_table *htab;
12361 struct plt_entry *pent;
12362 asection *s;
12363
12364 if (h->root.type == bfd_link_hash_indirect)
12365 return TRUE;
12366
12367 if (!h->pointer_equality_needed)
12368 return TRUE;
12369
12370 if (h->def_regular)
12371 return TRUE;
12372
12373 info = inf;
12374 htab = ppc_hash_table (info);
12375 if (htab == NULL)
12376 return FALSE;
12377
12378 s = htab->glink;
12379 for (pent = h->plt.plist; pent != NULL; pent = pent->next)
12380 if (pent->plt.offset != (bfd_vma) -1
12381 && pent->addend == 0)
12382 {
12383 bfd_byte *p;
12384 asection *plt;
12385 bfd_vma off;
12386
12387 p = s->contents + h->root.u.def.value;
12388 plt = htab->elf.splt;
12389 if (!htab->elf.dynamic_sections_created
12390 || h->dynindx == -1)
12391 plt = htab->elf.iplt;
12392 off = pent->plt.offset + plt->output_offset + plt->output_section->vma;
12393 off -= h->root.u.def.value + s->output_offset + s->output_section->vma;
12394
12395 if (off + 0x80008000 > 0xffffffff || (off & 3) != 0)
12396 {
12397 info->callbacks->einfo
12398 (_("%P: linkage table error against `%T'\n"),
12399 h->root.root.string);
12400 bfd_set_error (bfd_error_bad_value);
12401 htab->stub_error = TRUE;
12402 }
12403
12404 if (PPC_HA (off) != 0)
12405 {
12406 bfd_put_32 (s->owner, ADDIS_R12_R12 | PPC_HA (off), p);
12407 p += 4;
12408 }
12409 bfd_put_32 (s->owner, LD_R12_0R12 | PPC_LO (off), p);
12410 p += 4;
12411 bfd_put_32 (s->owner, MTCTR_R12, p);
12412 p += 4;
12413 bfd_put_32 (s->owner, BCTR, p);
12414 break;
12415 }
12416 return TRUE;
12417 }
12418
12419 /* Build all the stubs associated with the current output file.
12420 The stubs are kept in a hash table attached to the main linker
12421 hash table. This function is called via gldelf64ppc_finish. */
12422
12423 bfd_boolean
12424 ppc64_elf_build_stubs (bfd_boolean emit_stub_syms,
12425 struct bfd_link_info *info,
12426 char **stats)
12427 {
12428 struct ppc_link_hash_table *htab = ppc_hash_table (info);
12429 asection *stub_sec;
12430 bfd_byte *p;
12431 int stub_sec_count = 0;
12432
12433 if (htab == NULL)
12434 return FALSE;
12435
12436 htab->emit_stub_syms = emit_stub_syms;
12437
12438 /* Allocate memory to hold the linker stubs. */
12439 for (stub_sec = htab->stub_bfd->sections;
12440 stub_sec != NULL;
12441 stub_sec = stub_sec->next)
12442 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
12443 && stub_sec->size != 0)
12444 {
12445 stub_sec->contents = bfd_zalloc (htab->stub_bfd, stub_sec->size);
12446 if (stub_sec->contents == NULL)
12447 return FALSE;
12448 /* We want to check that built size is the same as calculated
12449 size. rawsize is a convenient location to use. */
12450 stub_sec->rawsize = stub_sec->size;
12451 stub_sec->size = 0;
12452 }
12453
12454 if (htab->glink != NULL && htab->glink->size != 0)
12455 {
12456 unsigned int indx;
12457 bfd_vma plt0;
12458
12459 /* Build the .glink plt call stub. */
12460 if (htab->emit_stub_syms)
12461 {
12462 struct elf_link_hash_entry *h;
12463 h = elf_link_hash_lookup (&htab->elf, "__glink_PLTresolve",
12464 TRUE, FALSE, FALSE);
12465 if (h == NULL)
12466 return FALSE;
12467 if (h->root.type == bfd_link_hash_new)
12468 {
12469 h->root.type = bfd_link_hash_defined;
12470 h->root.u.def.section = htab->glink;
12471 h->root.u.def.value = 8;
12472 h->ref_regular = 1;
12473 h->def_regular = 1;
12474 h->ref_regular_nonweak = 1;
12475 h->forced_local = 1;
12476 h->non_elf = 0;
12477 }
12478 }
12479 plt0 = (htab->elf.splt->output_section->vma
12480 + htab->elf.splt->output_offset
12481 - 16);
12482 if (info->emitrelocations)
12483 {
12484 Elf_Internal_Rela *r = get_relocs (htab->glink, 1);
12485 if (r == NULL)
12486 return FALSE;
12487 r->r_offset = (htab->glink->output_offset
12488 + htab->glink->output_section->vma);
12489 r->r_info = ELF64_R_INFO (0, R_PPC64_REL64);
12490 r->r_addend = plt0;
12491 }
12492 p = htab->glink->contents;
12493 plt0 -= htab->glink->output_section->vma + htab->glink->output_offset;
12494 bfd_put_64 (htab->glink->owner, plt0, p);
12495 p += 8;
12496 if (htab->opd_abi)
12497 {
12498 bfd_put_32 (htab->glink->owner, MFLR_R12, p);
12499 p += 4;
12500 bfd_put_32 (htab->glink->owner, BCL_20_31, p);
12501 p += 4;
12502 bfd_put_32 (htab->glink->owner, MFLR_R11, p);
12503 p += 4;
12504 bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
12505 p += 4;
12506 bfd_put_32 (htab->glink->owner, MTLR_R12, p);
12507 p += 4;
12508 bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
12509 p += 4;
12510 bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
12511 p += 4;
12512 bfd_put_32 (htab->glink->owner, LD_R2_0R11 | 8, p);
12513 p += 4;
12514 bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
12515 p += 4;
12516 bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 16, p);
12517 p += 4;
12518 }
12519 else
12520 {
12521 bfd_put_32 (htab->glink->owner, MFLR_R0, p);
12522 p += 4;
12523 bfd_put_32 (htab->glink->owner, BCL_20_31, p);
12524 p += 4;
12525 bfd_put_32 (htab->glink->owner, MFLR_R11, p);
12526 p += 4;
12527 bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
12528 p += 4;
12529 bfd_put_32 (htab->glink->owner, MTLR_R0, p);
12530 p += 4;
12531 bfd_put_32 (htab->glink->owner, SUB_R12_R12_R11, p);
12532 p += 4;
12533 bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
12534 p += 4;
12535 bfd_put_32 (htab->glink->owner, ADDI_R0_R12 | (-48 & 0xffff), p);
12536 p += 4;
12537 bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
12538 p += 4;
12539 bfd_put_32 (htab->glink->owner, SRDI_R0_R0_2, p);
12540 p += 4;
12541 bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
12542 p += 4;
12543 bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 8, p);
12544 p += 4;
12545 }
12546 bfd_put_32 (htab->glink->owner, BCTR, p);
12547 p += 4;
12548 while (p - htab->glink->contents < GLINK_CALL_STUB_SIZE)
12549 {
12550 bfd_put_32 (htab->glink->owner, NOP, p);
12551 p += 4;
12552 }
12553
12554 /* Build the .glink lazy link call stubs. */
12555 indx = 0;
12556 while (p < htab->glink->contents + htab->glink->rawsize)
12557 {
12558 if (htab->opd_abi)
12559 {
12560 if (indx < 0x8000)
12561 {
12562 bfd_put_32 (htab->glink->owner, LI_R0_0 | indx, p);
12563 p += 4;
12564 }
12565 else
12566 {
12567 bfd_put_32 (htab->glink->owner, LIS_R0_0 | PPC_HI (indx), p);
12568 p += 4;
12569 bfd_put_32 (htab->glink->owner, ORI_R0_R0_0 | PPC_LO (indx),
12570 p);
12571 p += 4;
12572 }
12573 }
12574 bfd_put_32 (htab->glink->owner,
12575 B_DOT | ((htab->glink->contents - p + 8) & 0x3fffffc), p);
12576 indx++;
12577 p += 4;
12578 }
12579
12580 /* Build .glink global entry stubs. */
12581 if (htab->glink->size > htab->glink->rawsize)
12582 elf_link_hash_traverse (&htab->elf, build_global_entry_stubs, info);
12583 }
12584
12585 if (htab->brlt->size != 0)
12586 {
12587 htab->brlt->contents = bfd_zalloc (htab->brlt->owner,
12588 htab->brlt->size);
12589 if (htab->brlt->contents == NULL)
12590 return FALSE;
12591 }
12592 if (htab->relbrlt != NULL && htab->relbrlt->size != 0)
12593 {
12594 htab->relbrlt->contents = bfd_zalloc (htab->relbrlt->owner,
12595 htab->relbrlt->size);
12596 if (htab->relbrlt->contents == NULL)
12597 return FALSE;
12598 }
12599
12600 if (htab->glink_eh_frame != NULL
12601 && htab->glink_eh_frame->size != 0)
12602 {
12603 bfd_vma val;
12604 bfd_byte *last_fde;
12605 size_t last_fde_len, size, align, pad;
12606
12607 p = bfd_zalloc (htab->glink_eh_frame->owner, htab->glink_eh_frame->size);
12608 if (p == NULL)
12609 return FALSE;
12610 htab->glink_eh_frame->contents = p;
12611 last_fde = p;
12612
12613 htab->glink_eh_frame->rawsize = htab->glink_eh_frame->size;
12614
12615 memcpy (p, glink_eh_frame_cie, sizeof (glink_eh_frame_cie));
12616 /* CIE length (rewrite in case little-endian). */
12617 last_fde_len = sizeof (glink_eh_frame_cie) - 4;
12618 bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
12619 p += sizeof (glink_eh_frame_cie);
12620
12621 for (stub_sec = htab->stub_bfd->sections;
12622 stub_sec != NULL;
12623 stub_sec = stub_sec->next)
12624 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12625 {
12626 last_fde = p;
12627 last_fde_len = 16;
12628 /* FDE length. */
12629 bfd_put_32 (htab->elf.dynobj, 16, p);
12630 p += 4;
12631 /* CIE pointer. */
12632 val = p - htab->glink_eh_frame->contents;
12633 bfd_put_32 (htab->elf.dynobj, val, p);
12634 p += 4;
12635 /* Offset to stub section. */
12636 val = (stub_sec->output_section->vma
12637 + stub_sec->output_offset);
12638 val -= (htab->glink_eh_frame->output_section->vma
12639 + htab->glink_eh_frame->output_offset);
12640 val -= p - htab->glink_eh_frame->contents;
12641 if (val + 0x80000000 > 0xffffffff)
12642 {
12643 info->callbacks->einfo
12644 (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
12645 stub_sec->name);
12646 return FALSE;
12647 }
12648 bfd_put_32 (htab->elf.dynobj, val, p);
12649 p += 4;
12650 /* stub section size. */
12651 bfd_put_32 (htab->elf.dynobj, stub_sec->rawsize, p);
12652 p += 4;
12653 /* Augmentation. */
12654 p += 1;
12655 /* Pad. */
12656 p += 3;
12657 }
12658 if (htab->glink != NULL && htab->glink->size != 0)
12659 {
12660 last_fde = p;
12661 last_fde_len = 20;
12662 /* FDE length. */
12663 bfd_put_32 (htab->elf.dynobj, 20, p);
12664 p += 4;
12665 /* CIE pointer. */
12666 val = p - htab->glink_eh_frame->contents;
12667 bfd_put_32 (htab->elf.dynobj, val, p);
12668 p += 4;
12669 /* Offset to .glink. */
12670 val = (htab->glink->output_section->vma
12671 + htab->glink->output_offset
12672 + 8);
12673 val -= (htab->glink_eh_frame->output_section->vma
12674 + htab->glink_eh_frame->output_offset);
12675 val -= p - htab->glink_eh_frame->contents;
12676 if (val + 0x80000000 > 0xffffffff)
12677 {
12678 info->callbacks->einfo
12679 (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
12680 htab->glink->name);
12681 return FALSE;
12682 }
12683 bfd_put_32 (htab->elf.dynobj, val, p);
12684 p += 4;
12685 /* .glink size. */
12686 bfd_put_32 (htab->elf.dynobj, htab->glink->size - 8, p);
12687 p += 4;
12688 /* Augmentation. */
12689 p += 1;
12690
12691 *p++ = DW_CFA_advance_loc + 1;
12692 *p++ = DW_CFA_register;
12693 *p++ = 65;
12694 *p++ = 12;
12695 *p++ = DW_CFA_advance_loc + 4;
12696 *p++ = DW_CFA_restore_extended;
12697 *p++ = 65;
12698 }
12699 /* Subsume any padding into the last FDE if user .eh_frame
12700 sections are aligned more than glink_eh_frame. Otherwise any
12701 zero padding will be seen as a terminator. */
12702 size = p - htab->glink_eh_frame->contents;
12703 align = 1;
12704 align <<= htab->glink_eh_frame->output_section->alignment_power;
12705 align -= 1;
12706 pad = ((size + align) & ~align) - size;
12707 htab->glink_eh_frame->size = size + pad;
12708 bfd_put_32 (htab->elf.dynobj, last_fde_len + pad, last_fde);
12709 }
12710
12711 /* Build the stubs as directed by the stub hash table. */
12712 bfd_hash_traverse (&htab->stub_hash_table, ppc_build_one_stub, info);
12713
12714 if (htab->relbrlt != NULL)
12715 htab->relbrlt->reloc_count = 0;
12716
12717 if (htab->plt_stub_align != 0)
12718 for (stub_sec = htab->stub_bfd->sections;
12719 stub_sec != NULL;
12720 stub_sec = stub_sec->next)
12721 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12722 stub_sec->size = ((stub_sec->size + (1 << htab->plt_stub_align) - 1)
12723 & (-1 << htab->plt_stub_align));
12724
12725 for (stub_sec = htab->stub_bfd->sections;
12726 stub_sec != NULL;
12727 stub_sec = stub_sec->next)
12728 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12729 {
12730 stub_sec_count += 1;
12731 if (stub_sec->rawsize != stub_sec->size)
12732 break;
12733 }
12734
12735 if (stub_sec != NULL
12736 || (htab->glink_eh_frame != NULL
12737 && htab->glink_eh_frame->rawsize != htab->glink_eh_frame->size))
12738 {
12739 htab->stub_error = TRUE;
12740 info->callbacks->einfo (_("%P: stubs don't match calculated size\n"));
12741 }
12742
12743 if (htab->stub_error)
12744 return FALSE;
12745
12746 if (stats != NULL)
12747 {
12748 *stats = bfd_malloc (500);
12749 if (*stats == NULL)
12750 return FALSE;
12751
12752 sprintf (*stats, _("linker stubs in %u group%s\n"
12753 " branch %lu\n"
12754 " toc adjust %lu\n"
12755 " long branch %lu\n"
12756 " long toc adj %lu\n"
12757 " plt call %lu\n"
12758 " plt call toc %lu"),
12759 stub_sec_count,
12760 stub_sec_count == 1 ? "" : "s",
12761 htab->stub_count[ppc_stub_long_branch - 1],
12762 htab->stub_count[ppc_stub_long_branch_r2off - 1],
12763 htab->stub_count[ppc_stub_plt_branch - 1],
12764 htab->stub_count[ppc_stub_plt_branch_r2off - 1],
12765 htab->stub_count[ppc_stub_plt_call - 1],
12766 htab->stub_count[ppc_stub_plt_call_r2save - 1]);
12767 }
12768 return TRUE;
12769 }
12770
12771 /* This function undoes the changes made by add_symbol_adjust. */
12772
12773 static bfd_boolean
12774 undo_symbol_twiddle (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
12775 {
12776 struct ppc_link_hash_entry *eh;
12777
12778 if (h->root.type == bfd_link_hash_indirect)
12779 return TRUE;
12780
12781 eh = (struct ppc_link_hash_entry *) h;
12782 if (eh->elf.root.type != bfd_link_hash_undefweak || !eh->was_undefined)
12783 return TRUE;
12784
12785 eh->elf.root.type = bfd_link_hash_undefined;
12786 return TRUE;
12787 }
12788
12789 void
12790 ppc64_elf_restore_symbols (struct bfd_link_info *info)
12791 {
12792 struct ppc_link_hash_table *htab = ppc_hash_table (info);
12793
12794 if (htab != NULL)
12795 elf_link_hash_traverse (&htab->elf, undo_symbol_twiddle, info);
12796 }
12797
12798 /* What to do when ld finds relocations against symbols defined in
12799 discarded sections. */
12800
12801 static unsigned int
12802 ppc64_elf_action_discarded (asection *sec)
12803 {
12804 if (strcmp (".opd", sec->name) == 0)
12805 return 0;
12806
12807 if (strcmp (".toc", sec->name) == 0)
12808 return 0;
12809
12810 if (strcmp (".toc1", sec->name) == 0)
12811 return 0;
12812
12813 return _bfd_elf_default_action_discarded (sec);
12814 }
12815
12816 /* The RELOCATE_SECTION function is called by the ELF backend linker
12817 to handle the relocations for a section.
12818
12819 The relocs are always passed as Rela structures; if the section
12820 actually uses Rel structures, the r_addend field will always be
12821 zero.
12822
12823 This function is responsible for adjust the section contents as
12824 necessary, and (if using Rela relocs and generating a
12825 relocatable output file) adjusting the reloc addend as
12826 necessary.
12827
12828 This function does not have to worry about setting the reloc
12829 address or the reloc symbol index.
12830
12831 LOCAL_SYMS is a pointer to the swapped in local symbols.
12832
12833 LOCAL_SECTIONS is an array giving the section in the input file
12834 corresponding to the st_shndx field of each local symbol.
12835
12836 The global hash table entry for the global symbols can be found
12837 via elf_sym_hashes (input_bfd).
12838
12839 When generating relocatable output, this function must handle
12840 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
12841 going to be the section symbol corresponding to the output
12842 section, which means that the addend must be adjusted
12843 accordingly. */
12844
12845 static bfd_boolean
12846 ppc64_elf_relocate_section (bfd *output_bfd,
12847 struct bfd_link_info *info,
12848 bfd *input_bfd,
12849 asection *input_section,
12850 bfd_byte *contents,
12851 Elf_Internal_Rela *relocs,
12852 Elf_Internal_Sym *local_syms,
12853 asection **local_sections)
12854 {
12855 struct ppc_link_hash_table *htab;
12856 Elf_Internal_Shdr *symtab_hdr;
12857 struct elf_link_hash_entry **sym_hashes;
12858 Elf_Internal_Rela *rel;
12859 Elf_Internal_Rela *relend;
12860 Elf_Internal_Rela outrel;
12861 bfd_byte *loc;
12862 struct got_entry **local_got_ents;
12863 bfd_vma TOCstart;
12864 bfd_boolean ret = TRUE;
12865 bfd_boolean is_opd;
12866 /* Assume 'at' branch hints. */
12867 bfd_boolean is_isa_v2 = TRUE;
12868 bfd_vma d_offset = (bfd_big_endian (output_bfd) ? 2 : 0);
12869
12870 /* Initialize howto table if needed. */
12871 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
12872 ppc_howto_init ();
12873
12874 htab = ppc_hash_table (info);
12875 if (htab == NULL)
12876 return FALSE;
12877
12878 /* Don't relocate stub sections. */
12879 if (input_section->owner == htab->stub_bfd)
12880 return TRUE;
12881
12882 BFD_ASSERT (is_ppc64_elf (input_bfd));
12883
12884 local_got_ents = elf_local_got_ents (input_bfd);
12885 TOCstart = elf_gp (output_bfd);
12886 symtab_hdr = &elf_symtab_hdr (input_bfd);
12887 sym_hashes = elf_sym_hashes (input_bfd);
12888 is_opd = ppc64_elf_section_data (input_section)->sec_type == sec_opd;
12889
12890 rel = relocs;
12891 relend = relocs + input_section->reloc_count;
12892 for (; rel < relend; rel++)
12893 {
12894 enum elf_ppc64_reloc_type r_type;
12895 bfd_vma addend;
12896 bfd_reloc_status_type r;
12897 Elf_Internal_Sym *sym;
12898 asection *sec;
12899 struct elf_link_hash_entry *h_elf;
12900 struct ppc_link_hash_entry *h;
12901 struct ppc_link_hash_entry *fdh;
12902 const char *sym_name;
12903 unsigned long r_symndx, toc_symndx;
12904 bfd_vma toc_addend;
12905 unsigned char tls_mask, tls_gd, tls_type;
12906 unsigned char sym_type;
12907 bfd_vma relocation;
12908 bfd_boolean unresolved_reloc;
12909 bfd_boolean warned;
12910 enum { DEST_NORMAL, DEST_OPD, DEST_STUB } reloc_dest;
12911 unsigned int insn;
12912 unsigned int mask;
12913 struct ppc_stub_hash_entry *stub_entry;
12914 bfd_vma max_br_offset;
12915 bfd_vma from;
12916 const Elf_Internal_Rela orig_rel = *rel;
12917
12918 r_type = ELF64_R_TYPE (rel->r_info);
12919 r_symndx = ELF64_R_SYM (rel->r_info);
12920
12921 /* For old style R_PPC64_TOC relocs with a zero symbol, use the
12922 symbol of the previous ADDR64 reloc. The symbol gives us the
12923 proper TOC base to use. */
12924 if (rel->r_info == ELF64_R_INFO (0, R_PPC64_TOC)
12925 && rel != relocs
12926 && ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_ADDR64
12927 && is_opd)
12928 r_symndx = ELF64_R_SYM (rel[-1].r_info);
12929
12930 sym = NULL;
12931 sec = NULL;
12932 h_elf = NULL;
12933 sym_name = NULL;
12934 unresolved_reloc = FALSE;
12935 warned = FALSE;
12936
12937 if (r_symndx < symtab_hdr->sh_info)
12938 {
12939 /* It's a local symbol. */
12940 struct _opd_sec_data *opd;
12941
12942 sym = local_syms + r_symndx;
12943 sec = local_sections[r_symndx];
12944 sym_name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym, sec);
12945 sym_type = ELF64_ST_TYPE (sym->st_info);
12946 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
12947 opd = get_opd_info (sec);
12948 if (opd != NULL && opd->adjust != NULL)
12949 {
12950 long adjust = opd->adjust[(sym->st_value + rel->r_addend) / 8];
12951 if (adjust == -1)
12952 relocation = 0;
12953 else
12954 {
12955 /* If this is a relocation against the opd section sym
12956 and we have edited .opd, adjust the reloc addend so
12957 that ld -r and ld --emit-relocs output is correct.
12958 If it is a reloc against some other .opd symbol,
12959 then the symbol value will be adjusted later. */
12960 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
12961 rel->r_addend += adjust;
12962 else
12963 relocation += adjust;
12964 }
12965 }
12966 }
12967 else
12968 {
12969 bfd_boolean ignored;
12970
12971 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
12972 r_symndx, symtab_hdr, sym_hashes,
12973 h_elf, sec, relocation,
12974 unresolved_reloc, warned, ignored);
12975 sym_name = h_elf->root.root.string;
12976 sym_type = h_elf->type;
12977 if (sec != NULL
12978 && sec->owner == output_bfd
12979 && strcmp (sec->name, ".opd") == 0)
12980 {
12981 /* This is a symbol defined in a linker script. All
12982 such are defined in output sections, even those
12983 defined by simple assignment from a symbol defined in
12984 an input section. Transfer the symbol to an
12985 appropriate input .opd section, so that a branch to
12986 this symbol will be mapped to the location specified
12987 by the opd entry. */
12988 struct bfd_link_order *lo;
12989 for (lo = sec->map_head.link_order; lo != NULL; lo = lo->next)
12990 if (lo->type == bfd_indirect_link_order)
12991 {
12992 asection *isec = lo->u.indirect.section;
12993 if (h_elf->root.u.def.value >= isec->output_offset
12994 && h_elf->root.u.def.value < (isec->output_offset
12995 + isec->size))
12996 {
12997 h_elf->root.u.def.value -= isec->output_offset;
12998 h_elf->root.u.def.section = isec;
12999 sec = isec;
13000 break;
13001 }
13002 }
13003 }
13004 }
13005 h = (struct ppc_link_hash_entry *) h_elf;
13006
13007 if (sec != NULL && discarded_section (sec))
13008 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
13009 rel, 1, relend,
13010 ppc64_elf_howto_table[r_type], 0,
13011 contents);
13012
13013 if (info->relocatable)
13014 continue;
13015
13016 if (h != NULL && &h->elf == htab->elf.hgot)
13017 {
13018 relocation = (TOCstart
13019 + htab->stub_group[input_section->id].toc_off);
13020 sec = bfd_abs_section_ptr;
13021 unresolved_reloc = FALSE;
13022 }
13023
13024 /* TLS optimizations. Replace instruction sequences and relocs
13025 based on information we collected in tls_optimize. We edit
13026 RELOCS so that --emit-relocs will output something sensible
13027 for the final instruction stream. */
13028 tls_mask = 0;
13029 tls_gd = 0;
13030 toc_symndx = 0;
13031 if (h != NULL)
13032 tls_mask = h->tls_mask;
13033 else if (local_got_ents != NULL)
13034 {
13035 struct plt_entry **local_plt = (struct plt_entry **)
13036 (local_got_ents + symtab_hdr->sh_info);
13037 unsigned char *lgot_masks = (unsigned char *)
13038 (local_plt + symtab_hdr->sh_info);
13039 tls_mask = lgot_masks[r_symndx];
13040 }
13041 if (tls_mask == 0
13042 && (r_type == R_PPC64_TLS
13043 || r_type == R_PPC64_TLSGD
13044 || r_type == R_PPC64_TLSLD))
13045 {
13046 /* Check for toc tls entries. */
13047 unsigned char *toc_tls;
13048
13049 if (!get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
13050 &local_syms, rel, input_bfd))
13051 return FALSE;
13052
13053 if (toc_tls)
13054 tls_mask = *toc_tls;
13055 }
13056
13057 /* Check that tls relocs are used with tls syms, and non-tls
13058 relocs are used with non-tls syms. */
13059 if (r_symndx != STN_UNDEF
13060 && r_type != R_PPC64_NONE
13061 && (h == NULL
13062 || h->elf.root.type == bfd_link_hash_defined
13063 || h->elf.root.type == bfd_link_hash_defweak)
13064 && (IS_PPC64_TLS_RELOC (r_type)
13065 != (sym_type == STT_TLS
13066 || (sym_type == STT_SECTION
13067 && (sec->flags & SEC_THREAD_LOCAL) != 0))))
13068 {
13069 if (tls_mask != 0
13070 && (r_type == R_PPC64_TLS
13071 || r_type == R_PPC64_TLSGD
13072 || r_type == R_PPC64_TLSLD))
13073 /* R_PPC64_TLS is OK against a symbol in the TOC. */
13074 ;
13075 else
13076 info->callbacks->einfo
13077 (!IS_PPC64_TLS_RELOC (r_type)
13078 ? _("%P: %H: %s used with TLS symbol `%T'\n")
13079 : _("%P: %H: %s used with non-TLS symbol `%T'\n"),
13080 input_bfd, input_section, rel->r_offset,
13081 ppc64_elf_howto_table[r_type]->name,
13082 sym_name);
13083 }
13084
13085 /* Ensure reloc mapping code below stays sane. */
13086 if (R_PPC64_TOC16_LO_DS != R_PPC64_TOC16_DS + 1
13087 || R_PPC64_TOC16_LO != R_PPC64_TOC16 + 1
13088 || (R_PPC64_GOT_TLSLD16 & 3) != (R_PPC64_GOT_TLSGD16 & 3)
13089 || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TLSGD16_LO & 3)
13090 || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TLSGD16_HI & 3)
13091 || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TLSGD16_HA & 3)
13092 || (R_PPC64_GOT_TLSLD16 & 3) != (R_PPC64_GOT_TPREL16_DS & 3)
13093 || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TPREL16_LO_DS & 3)
13094 || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TPREL16_HI & 3)
13095 || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TPREL16_HA & 3))
13096 abort ();
13097
13098 switch (r_type)
13099 {
13100 default:
13101 break;
13102
13103 case R_PPC64_LO_DS_OPT:
13104 insn = bfd_get_32 (output_bfd, contents + rel->r_offset - d_offset);
13105 if ((insn & (0x3f << 26)) != 58u << 26)
13106 abort ();
13107 insn += (14u << 26) - (58u << 26);
13108 bfd_put_32 (output_bfd, insn, contents + rel->r_offset - d_offset);
13109 r_type = R_PPC64_TOC16_LO;
13110 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13111 break;
13112
13113 case R_PPC64_TOC16:
13114 case R_PPC64_TOC16_LO:
13115 case R_PPC64_TOC16_DS:
13116 case R_PPC64_TOC16_LO_DS:
13117 {
13118 /* Check for toc tls entries. */
13119 unsigned char *toc_tls;
13120 int retval;
13121
13122 retval = get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
13123 &local_syms, rel, input_bfd);
13124 if (retval == 0)
13125 return FALSE;
13126
13127 if (toc_tls)
13128 {
13129 tls_mask = *toc_tls;
13130 if (r_type == R_PPC64_TOC16_DS
13131 || r_type == R_PPC64_TOC16_LO_DS)
13132 {
13133 if (tls_mask != 0
13134 && (tls_mask & (TLS_DTPREL | TLS_TPREL)) == 0)
13135 goto toctprel;
13136 }
13137 else
13138 {
13139 /* If we found a GD reloc pair, then we might be
13140 doing a GD->IE transition. */
13141 if (retval == 2)
13142 {
13143 tls_gd = TLS_TPRELGD;
13144 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13145 goto tls_ldgd_opt;
13146 }
13147 else if (retval == 3)
13148 {
13149 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13150 goto tls_ldgd_opt;
13151 }
13152 }
13153 }
13154 }
13155 break;
13156
13157 case R_PPC64_GOT_TPREL16_HI:
13158 case R_PPC64_GOT_TPREL16_HA:
13159 if (tls_mask != 0
13160 && (tls_mask & TLS_TPREL) == 0)
13161 {
13162 rel->r_offset -= d_offset;
13163 bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
13164 r_type = R_PPC64_NONE;
13165 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13166 }
13167 break;
13168
13169 case R_PPC64_GOT_TPREL16_DS:
13170 case R_PPC64_GOT_TPREL16_LO_DS:
13171 if (tls_mask != 0
13172 && (tls_mask & TLS_TPREL) == 0)
13173 {
13174 toctprel:
13175 insn = bfd_get_32 (output_bfd, contents + rel->r_offset - d_offset);
13176 insn &= 31 << 21;
13177 insn |= 0x3c0d0000; /* addis 0,13,0 */
13178 bfd_put_32 (output_bfd, insn, contents + rel->r_offset - d_offset);
13179 r_type = R_PPC64_TPREL16_HA;
13180 if (toc_symndx != 0)
13181 {
13182 rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
13183 rel->r_addend = toc_addend;
13184 /* We changed the symbol. Start over in order to
13185 get h, sym, sec etc. right. */
13186 rel--;
13187 continue;
13188 }
13189 else
13190 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13191 }
13192 break;
13193
13194 case R_PPC64_TLS:
13195 if (tls_mask != 0
13196 && (tls_mask & TLS_TPREL) == 0)
13197 {
13198 insn = bfd_get_32 (output_bfd, contents + rel->r_offset);
13199 insn = _bfd_elf_ppc_at_tls_transform (insn, 13);
13200 if (insn == 0)
13201 abort ();
13202 bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
13203 /* Was PPC64_TLS which sits on insn boundary, now
13204 PPC64_TPREL16_LO which is at low-order half-word. */
13205 rel->r_offset += d_offset;
13206 r_type = R_PPC64_TPREL16_LO;
13207 if (toc_symndx != 0)
13208 {
13209 rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
13210 rel->r_addend = toc_addend;
13211 /* We changed the symbol. Start over in order to
13212 get h, sym, sec etc. right. */
13213 rel--;
13214 continue;
13215 }
13216 else
13217 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13218 }
13219 break;
13220
13221 case R_PPC64_GOT_TLSGD16_HI:
13222 case R_PPC64_GOT_TLSGD16_HA:
13223 tls_gd = TLS_TPRELGD;
13224 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13225 goto tls_gdld_hi;
13226 break;
13227
13228 case R_PPC64_GOT_TLSLD16_HI:
13229 case R_PPC64_GOT_TLSLD16_HA:
13230 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13231 {
13232 tls_gdld_hi:
13233 if ((tls_mask & tls_gd) != 0)
13234 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
13235 + R_PPC64_GOT_TPREL16_DS);
13236 else
13237 {
13238 rel->r_offset -= d_offset;
13239 bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
13240 r_type = R_PPC64_NONE;
13241 }
13242 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13243 }
13244 break;
13245
13246 case R_PPC64_GOT_TLSGD16:
13247 case R_PPC64_GOT_TLSGD16_LO:
13248 tls_gd = TLS_TPRELGD;
13249 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13250 goto tls_ldgd_opt;
13251 break;
13252
13253 case R_PPC64_GOT_TLSLD16:
13254 case R_PPC64_GOT_TLSLD16_LO:
13255 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13256 {
13257 unsigned int insn1, insn2, insn3;
13258 bfd_vma offset;
13259
13260 tls_ldgd_opt:
13261 offset = (bfd_vma) -1;
13262 /* If not using the newer R_PPC64_TLSGD/LD to mark
13263 __tls_get_addr calls, we must trust that the call
13264 stays with its arg setup insns, ie. that the next
13265 reloc is the __tls_get_addr call associated with
13266 the current reloc. Edit both insns. */
13267 if (input_section->has_tls_get_addr_call
13268 && rel + 1 < relend
13269 && branch_reloc_hash_match (input_bfd, rel + 1,
13270 htab->tls_get_addr,
13271 htab->tls_get_addr_fd))
13272 offset = rel[1].r_offset;
13273 if ((tls_mask & tls_gd) != 0)
13274 {
13275 /* IE */
13276 insn1 = bfd_get_32 (output_bfd,
13277 contents + rel->r_offset - d_offset);
13278 insn1 &= (1 << 26) - (1 << 2);
13279 insn1 |= 58 << 26; /* ld */
13280 insn2 = 0x7c636a14; /* add 3,3,13 */
13281 if (offset != (bfd_vma) -1)
13282 rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13283 if ((tls_mask & TLS_EXPLICIT) == 0)
13284 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
13285 + R_PPC64_GOT_TPREL16_DS);
13286 else
13287 r_type += R_PPC64_TOC16_DS - R_PPC64_TOC16;
13288 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13289 }
13290 else
13291 {
13292 /* LE */
13293 insn1 = 0x3c6d0000; /* addis 3,13,0 */
13294 insn2 = 0x38630000; /* addi 3,3,0 */
13295 if (tls_gd == 0)
13296 {
13297 /* Was an LD reloc. */
13298 if (toc_symndx)
13299 sec = local_sections[toc_symndx];
13300 for (r_symndx = 0;
13301 r_symndx < symtab_hdr->sh_info;
13302 r_symndx++)
13303 if (local_sections[r_symndx] == sec)
13304 break;
13305 if (r_symndx >= symtab_hdr->sh_info)
13306 r_symndx = STN_UNDEF;
13307 rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
13308 if (r_symndx != STN_UNDEF)
13309 rel->r_addend -= (local_syms[r_symndx].st_value
13310 + sec->output_offset
13311 + sec->output_section->vma);
13312 }
13313 else if (toc_symndx != 0)
13314 {
13315 r_symndx = toc_symndx;
13316 rel->r_addend = toc_addend;
13317 }
13318 r_type = R_PPC64_TPREL16_HA;
13319 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13320 if (offset != (bfd_vma) -1)
13321 {
13322 rel[1].r_info = ELF64_R_INFO (r_symndx,
13323 R_PPC64_TPREL16_LO);
13324 rel[1].r_offset = offset + d_offset;
13325 rel[1].r_addend = rel->r_addend;
13326 }
13327 }
13328 bfd_put_32 (output_bfd, insn1,
13329 contents + rel->r_offset - d_offset);
13330 if (offset != (bfd_vma) -1)
13331 {
13332 insn3 = bfd_get_32 (output_bfd,
13333 contents + offset + 4);
13334 if (insn3 == NOP
13335 || insn3 == CROR_151515 || insn3 == CROR_313131)
13336 {
13337 rel[1].r_offset += 4;
13338 bfd_put_32 (output_bfd, insn2, contents + offset + 4);
13339 insn2 = NOP;
13340 }
13341 bfd_put_32 (output_bfd, insn2, contents + offset);
13342 }
13343 if ((tls_mask & tls_gd) == 0
13344 && (tls_gd == 0 || toc_symndx != 0))
13345 {
13346 /* We changed the symbol. Start over in order
13347 to get h, sym, sec etc. right. */
13348 rel--;
13349 continue;
13350 }
13351 }
13352 break;
13353
13354 case R_PPC64_TLSGD:
13355 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13356 {
13357 unsigned int insn2, insn3;
13358 bfd_vma offset = rel->r_offset;
13359
13360 if ((tls_mask & TLS_TPRELGD) != 0)
13361 {
13362 /* IE */
13363 r_type = R_PPC64_NONE;
13364 insn2 = 0x7c636a14; /* add 3,3,13 */
13365 }
13366 else
13367 {
13368 /* LE */
13369 if (toc_symndx != 0)
13370 {
13371 r_symndx = toc_symndx;
13372 rel->r_addend = toc_addend;
13373 }
13374 r_type = R_PPC64_TPREL16_LO;
13375 rel->r_offset = offset + d_offset;
13376 insn2 = 0x38630000; /* addi 3,3,0 */
13377 }
13378 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13379 /* Zap the reloc on the _tls_get_addr call too. */
13380 BFD_ASSERT (offset == rel[1].r_offset);
13381 rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13382 insn3 = bfd_get_32 (output_bfd,
13383 contents + offset + 4);
13384 if (insn3 == NOP
13385 || insn3 == CROR_151515 || insn3 == CROR_313131)
13386 {
13387 rel->r_offset += 4;
13388 bfd_put_32 (output_bfd, insn2, contents + offset + 4);
13389 insn2 = NOP;
13390 }
13391 bfd_put_32 (output_bfd, insn2, contents + offset);
13392 if ((tls_mask & TLS_TPRELGD) == 0 && toc_symndx != 0)
13393 {
13394 rel--;
13395 continue;
13396 }
13397 }
13398 break;
13399
13400 case R_PPC64_TLSLD:
13401 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13402 {
13403 unsigned int insn2, insn3;
13404 bfd_vma offset = rel->r_offset;
13405
13406 if (toc_symndx)
13407 sec = local_sections[toc_symndx];
13408 for (r_symndx = 0;
13409 r_symndx < symtab_hdr->sh_info;
13410 r_symndx++)
13411 if (local_sections[r_symndx] == sec)
13412 break;
13413 if (r_symndx >= symtab_hdr->sh_info)
13414 r_symndx = STN_UNDEF;
13415 rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
13416 if (r_symndx != STN_UNDEF)
13417 rel->r_addend -= (local_syms[r_symndx].st_value
13418 + sec->output_offset
13419 + sec->output_section->vma);
13420
13421 r_type = R_PPC64_TPREL16_LO;
13422 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13423 rel->r_offset = offset + d_offset;
13424 /* Zap the reloc on the _tls_get_addr call too. */
13425 BFD_ASSERT (offset == rel[1].r_offset);
13426 rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13427 insn2 = 0x38630000; /* addi 3,3,0 */
13428 insn3 = bfd_get_32 (output_bfd,
13429 contents + offset + 4);
13430 if (insn3 == NOP
13431 || insn3 == CROR_151515 || insn3 == CROR_313131)
13432 {
13433 rel->r_offset += 4;
13434 bfd_put_32 (output_bfd, insn2, contents + offset + 4);
13435 insn2 = NOP;
13436 }
13437 bfd_put_32 (output_bfd, insn2, contents + offset);
13438 rel--;
13439 continue;
13440 }
13441 break;
13442
13443 case R_PPC64_DTPMOD64:
13444 if (rel + 1 < relend
13445 && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
13446 && rel[1].r_offset == rel->r_offset + 8)
13447 {
13448 if ((tls_mask & TLS_GD) == 0)
13449 {
13450 rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_NONE);
13451 if ((tls_mask & TLS_TPRELGD) != 0)
13452 r_type = R_PPC64_TPREL64;
13453 else
13454 {
13455 bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
13456 r_type = R_PPC64_NONE;
13457 }
13458 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13459 }
13460 }
13461 else
13462 {
13463 if ((tls_mask & TLS_LD) == 0)
13464 {
13465 bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
13466 r_type = R_PPC64_NONE;
13467 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13468 }
13469 }
13470 break;
13471
13472 case R_PPC64_TPREL64:
13473 if ((tls_mask & TLS_TPREL) == 0)
13474 {
13475 r_type = R_PPC64_NONE;
13476 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13477 }
13478 break;
13479
13480 case R_PPC64_REL16_HA:
13481 /* If we are generating a non-PIC executable, edit
13482 . 0: addis 2,12,.TOC.-0b@ha
13483 . addi 2,2,.TOC.-0b@l
13484 used by ELFv2 global entry points to set up r2, to
13485 . lis 2,.TOC.@ha
13486 . addi 2,2,.TOC.@l
13487 if .TOC. is in range. */
13488 if (!info->shared
13489 && h != NULL && &h->elf == htab->elf.hgot
13490 && rel + 1 < relend
13491 && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_REL16_LO)
13492 && rel[1].r_offset == rel->r_offset + 4
13493 && rel[1].r_addend == rel->r_addend + 4
13494 && relocation + 0x80008000 <= 0xffffffff)
13495 {
13496 unsigned int insn1, insn2;
13497 bfd_vma offset = rel->r_offset - d_offset;
13498 insn1 = bfd_get_32 (output_bfd, contents + offset);
13499 insn2 = bfd_get_32 (output_bfd, contents + offset + 4);
13500 if ((insn1 & 0xffff0000) == 0x3c4c0000 /* addis 2,12 */
13501 && (insn2 & 0xffff0000) == 0x38420000 /* addi 2,2 */)
13502 {
13503 r_type = R_PPC64_ADDR16_HA;
13504 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13505 rel->r_addend -= d_offset;
13506 rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_ADDR16_LO);
13507 rel[1].r_addend -= d_offset + 4;
13508 bfd_put_32 (output_bfd, 0x3c400000, contents + offset);
13509 }
13510 }
13511 break;
13512 }
13513
13514 /* Handle other relocations that tweak non-addend part of insn. */
13515 insn = 0;
13516 max_br_offset = 1 << 25;
13517 addend = rel->r_addend;
13518 reloc_dest = DEST_NORMAL;
13519 switch (r_type)
13520 {
13521 default:
13522 break;
13523
13524 case R_PPC64_TOCSAVE:
13525 if (relocation + addend == (rel->r_offset
13526 + input_section->output_offset
13527 + input_section->output_section->vma)
13528 && tocsave_find (htab, NO_INSERT,
13529 &local_syms, rel, input_bfd))
13530 {
13531 insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
13532 if (insn == NOP
13533 || insn == CROR_151515 || insn == CROR_313131)
13534 bfd_put_32 (input_bfd,
13535 STD_R2_0R1 + STK_TOC (htab),
13536 contents + rel->r_offset);
13537 }
13538 break;
13539
13540 /* Branch taken prediction relocations. */
13541 case R_PPC64_ADDR14_BRTAKEN:
13542 case R_PPC64_REL14_BRTAKEN:
13543 insn = 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field. */
13544 /* Fall thru. */
13545
13546 /* Branch not taken prediction relocations. */
13547 case R_PPC64_ADDR14_BRNTAKEN:
13548 case R_PPC64_REL14_BRNTAKEN:
13549 insn |= bfd_get_32 (output_bfd,
13550 contents + rel->r_offset) & ~(0x01 << 21);
13551 /* Fall thru. */
13552
13553 case R_PPC64_REL14:
13554 max_br_offset = 1 << 15;
13555 /* Fall thru. */
13556
13557 case R_PPC64_REL24:
13558 /* Calls to functions with a different TOC, such as calls to
13559 shared objects, need to alter the TOC pointer. This is
13560 done using a linkage stub. A REL24 branching to these
13561 linkage stubs needs to be followed by a nop, as the nop
13562 will be replaced with an instruction to restore the TOC
13563 base pointer. */
13564 fdh = h;
13565 if (h != NULL
13566 && h->oh != NULL
13567 && h->oh->is_func_descriptor)
13568 fdh = ppc_follow_link (h->oh);
13569 stub_entry = ppc_get_stub_entry (input_section, sec, fdh, &orig_rel,
13570 htab);
13571 if (stub_entry != NULL
13572 && (stub_entry->stub_type == ppc_stub_plt_call
13573 || stub_entry->stub_type == ppc_stub_plt_call_r2save
13574 || stub_entry->stub_type == ppc_stub_plt_branch_r2off
13575 || stub_entry->stub_type == ppc_stub_long_branch_r2off))
13576 {
13577 bfd_boolean can_plt_call = FALSE;
13578
13579 /* All of these stubs will modify r2, so there must be a
13580 branch and link followed by a nop. The nop is
13581 replaced by an insn to restore r2. */
13582 if (rel->r_offset + 8 <= input_section->size)
13583 {
13584 unsigned long br;
13585
13586 br = bfd_get_32 (input_bfd,
13587 contents + rel->r_offset);
13588 if ((br & 1) != 0)
13589 {
13590 unsigned long nop;
13591
13592 nop = bfd_get_32 (input_bfd,
13593 contents + rel->r_offset + 4);
13594 if (nop == NOP
13595 || nop == CROR_151515 || nop == CROR_313131)
13596 {
13597 if (h != NULL
13598 && (h == htab->tls_get_addr_fd
13599 || h == htab->tls_get_addr)
13600 && !htab->no_tls_get_addr_opt)
13601 {
13602 /* Special stub used, leave nop alone. */
13603 }
13604 else
13605 bfd_put_32 (input_bfd,
13606 LD_R2_0R1 + STK_TOC (htab),
13607 contents + rel->r_offset + 4);
13608 can_plt_call = TRUE;
13609 }
13610 }
13611 }
13612
13613 if (!can_plt_call && h != NULL)
13614 {
13615 const char *name = h->elf.root.root.string;
13616
13617 if (*name == '.')
13618 ++name;
13619
13620 if (strncmp (name, "__libc_start_main", 17) == 0
13621 && (name[17] == 0 || name[17] == '@'))
13622 {
13623 /* Allow crt1 branch to go via a toc adjusting
13624 stub. Other calls that never return could do
13625 the same, if we could detect such. */
13626 can_plt_call = TRUE;
13627 }
13628 }
13629
13630 if (!can_plt_call)
13631 {
13632 /* g++ as of 20130507 emits self-calls without a
13633 following nop. This is arguably wrong since we
13634 have conflicting information. On the one hand a
13635 global symbol and on the other a local call
13636 sequence, but don't error for this special case.
13637 It isn't possible to cheaply verify we have
13638 exactly such a call. Allow all calls to the same
13639 section. */
13640 asection *code_sec = sec;
13641
13642 if (get_opd_info (sec) != NULL)
13643 {
13644 bfd_vma off = (relocation + addend
13645 - sec->output_section->vma
13646 - sec->output_offset);
13647
13648 opd_entry_value (sec, off, &code_sec, NULL, FALSE);
13649 }
13650 if (code_sec == input_section)
13651 can_plt_call = TRUE;
13652 }
13653
13654 if (!can_plt_call)
13655 {
13656 info->callbacks->einfo
13657 (_("%P: %H: call to `%T' lacks nop, can't restore toc; "
13658 "recompile with -fPIC"),
13659 input_bfd, input_section, rel->r_offset, sym_name);
13660
13661 bfd_set_error (bfd_error_bad_value);
13662 ret = FALSE;
13663 }
13664
13665 if (can_plt_call
13666 && (stub_entry->stub_type == ppc_stub_plt_call
13667 || stub_entry->stub_type == ppc_stub_plt_call_r2save))
13668 unresolved_reloc = FALSE;
13669 }
13670
13671 if ((stub_entry == NULL
13672 || stub_entry->stub_type == ppc_stub_long_branch
13673 || stub_entry->stub_type == ppc_stub_plt_branch)
13674 && get_opd_info (sec) != NULL)
13675 {
13676 /* The branch destination is the value of the opd entry. */
13677 bfd_vma off = (relocation + addend
13678 - sec->output_section->vma
13679 - sec->output_offset);
13680 bfd_vma dest = opd_entry_value (sec, off, NULL, NULL, FALSE);
13681 if (dest != (bfd_vma) -1)
13682 {
13683 relocation = dest;
13684 addend = 0;
13685 reloc_dest = DEST_OPD;
13686 }
13687 }
13688
13689 /* If the branch is out of reach we ought to have a long
13690 branch stub. */
13691 from = (rel->r_offset
13692 + input_section->output_offset
13693 + input_section->output_section->vma);
13694
13695 relocation += PPC64_LOCAL_ENTRY_OFFSET (fdh
13696 ? fdh->elf.other
13697 : sym->st_other);
13698
13699 if (stub_entry != NULL
13700 && (stub_entry->stub_type == ppc_stub_long_branch
13701 || stub_entry->stub_type == ppc_stub_plt_branch)
13702 && (r_type == R_PPC64_ADDR14_BRTAKEN
13703 || r_type == R_PPC64_ADDR14_BRNTAKEN
13704 || (relocation + addend - from + max_br_offset
13705 < 2 * max_br_offset)))
13706 /* Don't use the stub if this branch is in range. */
13707 stub_entry = NULL;
13708
13709 if (stub_entry != NULL)
13710 {
13711 /* Munge up the value and addend so that we call the stub
13712 rather than the procedure directly. */
13713 relocation = (stub_entry->stub_offset
13714 + stub_entry->stub_sec->output_offset
13715 + stub_entry->stub_sec->output_section->vma);
13716 addend = 0;
13717 reloc_dest = DEST_STUB;
13718
13719 if ((stub_entry->stub_type == ppc_stub_plt_call
13720 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
13721 && (ALWAYS_EMIT_R2SAVE
13722 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
13723 && rel + 1 < relend
13724 && rel[1].r_offset == rel->r_offset + 4
13725 && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOCSAVE)
13726 relocation += 4;
13727 }
13728
13729 if (insn != 0)
13730 {
13731 if (is_isa_v2)
13732 {
13733 /* Set 'a' bit. This is 0b00010 in BO field for branch
13734 on CR(BI) insns (BO == 001at or 011at), and 0b01000
13735 for branch on CTR insns (BO == 1a00t or 1a01t). */
13736 if ((insn & (0x14 << 21)) == (0x04 << 21))
13737 insn |= 0x02 << 21;
13738 else if ((insn & (0x14 << 21)) == (0x10 << 21))
13739 insn |= 0x08 << 21;
13740 else
13741 break;
13742 }
13743 else
13744 {
13745 /* Invert 'y' bit if not the default. */
13746 if ((bfd_signed_vma) (relocation + addend - from) < 0)
13747 insn ^= 0x01 << 21;
13748 }
13749
13750 bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
13751 }
13752
13753 /* NOP out calls to undefined weak functions.
13754 We can thus call a weak function without first
13755 checking whether the function is defined. */
13756 else if (h != NULL
13757 && h->elf.root.type == bfd_link_hash_undefweak
13758 && h->elf.dynindx == -1
13759 && r_type == R_PPC64_REL24
13760 && relocation == 0
13761 && addend == 0)
13762 {
13763 bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
13764 continue;
13765 }
13766 break;
13767 }
13768
13769 /* Set `addend'. */
13770 tls_type = 0;
13771 switch (r_type)
13772 {
13773 default:
13774 info->callbacks->einfo
13775 (_("%P: %B: unknown relocation type %d for `%T'\n"),
13776 input_bfd, (int) r_type, sym_name);
13777
13778 bfd_set_error (bfd_error_bad_value);
13779 ret = FALSE;
13780 continue;
13781
13782 case R_PPC64_NONE:
13783 case R_PPC64_TLS:
13784 case R_PPC64_TLSGD:
13785 case R_PPC64_TLSLD:
13786 case R_PPC64_TOCSAVE:
13787 case R_PPC64_GNU_VTINHERIT:
13788 case R_PPC64_GNU_VTENTRY:
13789 continue;
13790
13791 /* GOT16 relocations. Like an ADDR16 using the symbol's
13792 address in the GOT as relocation value instead of the
13793 symbol's value itself. Also, create a GOT entry for the
13794 symbol and put the symbol value there. */
13795 case R_PPC64_GOT_TLSGD16:
13796 case R_PPC64_GOT_TLSGD16_LO:
13797 case R_PPC64_GOT_TLSGD16_HI:
13798 case R_PPC64_GOT_TLSGD16_HA:
13799 tls_type = TLS_TLS | TLS_GD;
13800 goto dogot;
13801
13802 case R_PPC64_GOT_TLSLD16:
13803 case R_PPC64_GOT_TLSLD16_LO:
13804 case R_PPC64_GOT_TLSLD16_HI:
13805 case R_PPC64_GOT_TLSLD16_HA:
13806 tls_type = TLS_TLS | TLS_LD;
13807 goto dogot;
13808
13809 case R_PPC64_GOT_TPREL16_DS:
13810 case R_PPC64_GOT_TPREL16_LO_DS:
13811 case R_PPC64_GOT_TPREL16_HI:
13812 case R_PPC64_GOT_TPREL16_HA:
13813 tls_type = TLS_TLS | TLS_TPREL;
13814 goto dogot;
13815
13816 case R_PPC64_GOT_DTPREL16_DS:
13817 case R_PPC64_GOT_DTPREL16_LO_DS:
13818 case R_PPC64_GOT_DTPREL16_HI:
13819 case R_PPC64_GOT_DTPREL16_HA:
13820 tls_type = TLS_TLS | TLS_DTPREL;
13821 goto dogot;
13822
13823 case R_PPC64_GOT16:
13824 case R_PPC64_GOT16_LO:
13825 case R_PPC64_GOT16_HI:
13826 case R_PPC64_GOT16_HA:
13827 case R_PPC64_GOT16_DS:
13828 case R_PPC64_GOT16_LO_DS:
13829 dogot:
13830 {
13831 /* Relocation is to the entry for this symbol in the global
13832 offset table. */
13833 asection *got;
13834 bfd_vma *offp;
13835 bfd_vma off;
13836 unsigned long indx = 0;
13837 struct got_entry *ent;
13838
13839 if (tls_type == (TLS_TLS | TLS_LD)
13840 && (h == NULL
13841 || !h->elf.def_dynamic))
13842 ent = ppc64_tlsld_got (input_bfd);
13843 else
13844 {
13845
13846 if (h != NULL)
13847 {
13848 bfd_boolean dyn = htab->elf.dynamic_sections_created;
13849 if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared,
13850 &h->elf)
13851 || (info->shared
13852 && SYMBOL_REFERENCES_LOCAL (info, &h->elf)))
13853 /* This is actually a static link, or it is a
13854 -Bsymbolic link and the symbol is defined
13855 locally, or the symbol was forced to be local
13856 because of a version file. */
13857 ;
13858 else
13859 {
13860 BFD_ASSERT (h->elf.dynindx != -1);
13861 indx = h->elf.dynindx;
13862 unresolved_reloc = FALSE;
13863 }
13864 ent = h->elf.got.glist;
13865 }
13866 else
13867 {
13868 if (local_got_ents == NULL)
13869 abort ();
13870 ent = local_got_ents[r_symndx];
13871 }
13872
13873 for (; ent != NULL; ent = ent->next)
13874 if (ent->addend == orig_rel.r_addend
13875 && ent->owner == input_bfd
13876 && ent->tls_type == tls_type)
13877 break;
13878 }
13879
13880 if (ent == NULL)
13881 abort ();
13882 if (ent->is_indirect)
13883 ent = ent->got.ent;
13884 offp = &ent->got.offset;
13885 got = ppc64_elf_tdata (ent->owner)->got;
13886 if (got == NULL)
13887 abort ();
13888
13889 /* The offset must always be a multiple of 8. We use the
13890 least significant bit to record whether we have already
13891 processed this entry. */
13892 off = *offp;
13893 if ((off & 1) != 0)
13894 off &= ~1;
13895 else
13896 {
13897 /* Generate relocs for the dynamic linker, except in
13898 the case of TLSLD where we'll use one entry per
13899 module. */
13900 asection *relgot;
13901 bfd_boolean ifunc;
13902
13903 *offp = off | 1;
13904 relgot = NULL;
13905 ifunc = (h != NULL
13906 ? h->elf.type == STT_GNU_IFUNC
13907 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC);
13908 if (ifunc)
13909 relgot = htab->elf.irelplt;
13910 else if ((info->shared || indx != 0)
13911 && (h == NULL
13912 || (tls_type == (TLS_TLS | TLS_LD)
13913 && !h->elf.def_dynamic)
13914 || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
13915 || h->elf.root.type != bfd_link_hash_undefweak))
13916 relgot = ppc64_elf_tdata (ent->owner)->relgot;
13917 if (relgot != NULL)
13918 {
13919 outrel.r_offset = (got->output_section->vma
13920 + got->output_offset
13921 + off);
13922 outrel.r_addend = addend;
13923 if (tls_type & (TLS_LD | TLS_GD))
13924 {
13925 outrel.r_addend = 0;
13926 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPMOD64);
13927 if (tls_type == (TLS_TLS | TLS_GD))
13928 {
13929 loc = relgot->contents;
13930 loc += (relgot->reloc_count++
13931 * sizeof (Elf64_External_Rela));
13932 bfd_elf64_swap_reloca_out (output_bfd,
13933 &outrel, loc);
13934 outrel.r_offset += 8;
13935 outrel.r_addend = addend;
13936 outrel.r_info
13937 = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
13938 }
13939 }
13940 else if (tls_type == (TLS_TLS | TLS_DTPREL))
13941 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
13942 else if (tls_type == (TLS_TLS | TLS_TPREL))
13943 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_TPREL64);
13944 else if (indx != 0)
13945 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_GLOB_DAT);
13946 else
13947 {
13948 if (ifunc)
13949 outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
13950 else
13951 outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
13952
13953 /* Write the .got section contents for the sake
13954 of prelink. */
13955 loc = got->contents + off;
13956 bfd_put_64 (output_bfd, outrel.r_addend + relocation,
13957 loc);
13958 }
13959
13960 if (indx == 0 && tls_type != (TLS_TLS | TLS_LD))
13961 {
13962 outrel.r_addend += relocation;
13963 if (tls_type & (TLS_GD | TLS_DTPREL | TLS_TPREL))
13964 outrel.r_addend -= htab->elf.tls_sec->vma;
13965 }
13966 loc = relgot->contents;
13967 loc += (relgot->reloc_count++
13968 * sizeof (Elf64_External_Rela));
13969 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
13970 }
13971
13972 /* Init the .got section contents here if we're not
13973 emitting a reloc. */
13974 else
13975 {
13976 relocation += addend;
13977 if (tls_type == (TLS_TLS | TLS_LD))
13978 relocation = 1;
13979 else if (tls_type != 0)
13980 {
13981 relocation -= htab->elf.tls_sec->vma + DTP_OFFSET;
13982 if (tls_type == (TLS_TLS | TLS_TPREL))
13983 relocation += DTP_OFFSET - TP_OFFSET;
13984
13985 if (tls_type == (TLS_TLS | TLS_GD))
13986 {
13987 bfd_put_64 (output_bfd, relocation,
13988 got->contents + off + 8);
13989 relocation = 1;
13990 }
13991 }
13992
13993 bfd_put_64 (output_bfd, relocation,
13994 got->contents + off);
13995 }
13996 }
13997
13998 if (off >= (bfd_vma) -2)
13999 abort ();
14000
14001 relocation = got->output_section->vma + got->output_offset + off;
14002 addend = -(TOCstart + htab->stub_group[input_section->id].toc_off);
14003 }
14004 break;
14005
14006 case R_PPC64_PLT16_HA:
14007 case R_PPC64_PLT16_HI:
14008 case R_PPC64_PLT16_LO:
14009 case R_PPC64_PLT32:
14010 case R_PPC64_PLT64:
14011 /* Relocation is to the entry for this symbol in the
14012 procedure linkage table. */
14013
14014 /* Resolve a PLT reloc against a local symbol directly,
14015 without using the procedure linkage table. */
14016 if (h == NULL)
14017 break;
14018
14019 /* It's possible that we didn't make a PLT entry for this
14020 symbol. This happens when statically linking PIC code,
14021 or when using -Bsymbolic. Go find a match if there is a
14022 PLT entry. */
14023 if (htab->elf.splt != NULL)
14024 {
14025 struct plt_entry *ent;
14026 for (ent = h->elf.plt.plist; ent != NULL; ent = ent->next)
14027 if (ent->plt.offset != (bfd_vma) -1
14028 && ent->addend == orig_rel.r_addend)
14029 {
14030 relocation = (htab->elf.splt->output_section->vma
14031 + htab->elf.splt->output_offset
14032 + ent->plt.offset);
14033 unresolved_reloc = FALSE;
14034 break;
14035 }
14036 }
14037 break;
14038
14039 case R_PPC64_TOC:
14040 /* Relocation value is TOC base. */
14041 relocation = TOCstart;
14042 if (r_symndx == STN_UNDEF)
14043 relocation += htab->stub_group[input_section->id].toc_off;
14044 else if (unresolved_reloc)
14045 ;
14046 else if (sec != NULL && sec->id <= htab->top_id)
14047 relocation += htab->stub_group[sec->id].toc_off;
14048 else
14049 unresolved_reloc = TRUE;
14050 goto dodyn;
14051
14052 /* TOC16 relocs. We want the offset relative to the TOC base,
14053 which is the address of the start of the TOC plus 0x8000.
14054 The TOC consists of sections .got, .toc, .tocbss, and .plt,
14055 in this order. */
14056 case R_PPC64_TOC16:
14057 case R_PPC64_TOC16_LO:
14058 case R_PPC64_TOC16_HI:
14059 case R_PPC64_TOC16_DS:
14060 case R_PPC64_TOC16_LO_DS:
14061 case R_PPC64_TOC16_HA:
14062 addend -= TOCstart + htab->stub_group[input_section->id].toc_off;
14063 break;
14064
14065 /* Relocate against the beginning of the section. */
14066 case R_PPC64_SECTOFF:
14067 case R_PPC64_SECTOFF_LO:
14068 case R_PPC64_SECTOFF_HI:
14069 case R_PPC64_SECTOFF_DS:
14070 case R_PPC64_SECTOFF_LO_DS:
14071 case R_PPC64_SECTOFF_HA:
14072 if (sec != NULL)
14073 addend -= sec->output_section->vma;
14074 break;
14075
14076 case R_PPC64_REL16:
14077 case R_PPC64_REL16_LO:
14078 case R_PPC64_REL16_HI:
14079 case R_PPC64_REL16_HA:
14080 break;
14081
14082 case R_PPC64_REL14:
14083 case R_PPC64_REL14_BRNTAKEN:
14084 case R_PPC64_REL14_BRTAKEN:
14085 case R_PPC64_REL24:
14086 break;
14087
14088 case R_PPC64_TPREL16:
14089 case R_PPC64_TPREL16_LO:
14090 case R_PPC64_TPREL16_HI:
14091 case R_PPC64_TPREL16_HA:
14092 case R_PPC64_TPREL16_DS:
14093 case R_PPC64_TPREL16_LO_DS:
14094 case R_PPC64_TPREL16_HIGH:
14095 case R_PPC64_TPREL16_HIGHA:
14096 case R_PPC64_TPREL16_HIGHER:
14097 case R_PPC64_TPREL16_HIGHERA:
14098 case R_PPC64_TPREL16_HIGHEST:
14099 case R_PPC64_TPREL16_HIGHESTA:
14100 if (h != NULL
14101 && h->elf.root.type == bfd_link_hash_undefweak
14102 && h->elf.dynindx == -1)
14103 {
14104 /* Make this relocation against an undefined weak symbol
14105 resolve to zero. This is really just a tweak, since
14106 code using weak externs ought to check that they are
14107 defined before using them. */
14108 bfd_byte *p = contents + rel->r_offset - d_offset;
14109
14110 insn = bfd_get_32 (output_bfd, p);
14111 insn = _bfd_elf_ppc_at_tprel_transform (insn, 13);
14112 if (insn != 0)
14113 bfd_put_32 (output_bfd, insn, p);
14114 break;
14115 }
14116 addend -= htab->elf.tls_sec->vma + TP_OFFSET;
14117 if (info->shared)
14118 /* The TPREL16 relocs shouldn't really be used in shared
14119 libs as they will result in DT_TEXTREL being set, but
14120 support them anyway. */
14121 goto dodyn;
14122 break;
14123
14124 case R_PPC64_DTPREL16:
14125 case R_PPC64_DTPREL16_LO:
14126 case R_PPC64_DTPREL16_HI:
14127 case R_PPC64_DTPREL16_HA:
14128 case R_PPC64_DTPREL16_DS:
14129 case R_PPC64_DTPREL16_LO_DS:
14130 case R_PPC64_DTPREL16_HIGH:
14131 case R_PPC64_DTPREL16_HIGHA:
14132 case R_PPC64_DTPREL16_HIGHER:
14133 case R_PPC64_DTPREL16_HIGHERA:
14134 case R_PPC64_DTPREL16_HIGHEST:
14135 case R_PPC64_DTPREL16_HIGHESTA:
14136 addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
14137 break;
14138
14139 case R_PPC64_DTPMOD64:
14140 relocation = 1;
14141 addend = 0;
14142 goto dodyn;
14143
14144 case R_PPC64_TPREL64:
14145 addend -= htab->elf.tls_sec->vma + TP_OFFSET;
14146 goto dodyn;
14147
14148 case R_PPC64_DTPREL64:
14149 addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
14150 /* Fall thru */
14151
14152 /* Relocations that may need to be propagated if this is a
14153 dynamic object. */
14154 case R_PPC64_REL30:
14155 case R_PPC64_REL32:
14156 case R_PPC64_REL64:
14157 case R_PPC64_ADDR14:
14158 case R_PPC64_ADDR14_BRNTAKEN:
14159 case R_PPC64_ADDR14_BRTAKEN:
14160 case R_PPC64_ADDR16:
14161 case R_PPC64_ADDR16_DS:
14162 case R_PPC64_ADDR16_HA:
14163 case R_PPC64_ADDR16_HI:
14164 case R_PPC64_ADDR16_HIGH:
14165 case R_PPC64_ADDR16_HIGHA:
14166 case R_PPC64_ADDR16_HIGHER:
14167 case R_PPC64_ADDR16_HIGHERA:
14168 case R_PPC64_ADDR16_HIGHEST:
14169 case R_PPC64_ADDR16_HIGHESTA:
14170 case R_PPC64_ADDR16_LO:
14171 case R_PPC64_ADDR16_LO_DS:
14172 case R_PPC64_ADDR24:
14173 case R_PPC64_ADDR32:
14174 case R_PPC64_ADDR64:
14175 case R_PPC64_UADDR16:
14176 case R_PPC64_UADDR32:
14177 case R_PPC64_UADDR64:
14178 dodyn:
14179 if ((input_section->flags & SEC_ALLOC) == 0)
14180 break;
14181
14182 if (NO_OPD_RELOCS && is_opd)
14183 break;
14184
14185 if ((info->shared
14186 && (h == NULL
14187 || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
14188 || h->elf.root.type != bfd_link_hash_undefweak)
14189 && (must_be_dyn_reloc (info, r_type)
14190 || !SYMBOL_CALLS_LOCAL (info, &h->elf)))
14191 || (ELIMINATE_COPY_RELOCS
14192 && !info->shared
14193 && h != NULL
14194 && h->elf.dynindx != -1
14195 && !h->elf.non_got_ref
14196 && !h->elf.def_regular)
14197 || (!info->shared
14198 && (h != NULL
14199 ? h->elf.type == STT_GNU_IFUNC
14200 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)))
14201 {
14202 bfd_boolean skip, relocate;
14203 asection *sreloc;
14204 bfd_vma out_off;
14205
14206 /* When generating a dynamic object, these relocations
14207 are copied into the output file to be resolved at run
14208 time. */
14209
14210 skip = FALSE;
14211 relocate = FALSE;
14212
14213 out_off = _bfd_elf_section_offset (output_bfd, info,
14214 input_section, rel->r_offset);
14215 if (out_off == (bfd_vma) -1)
14216 skip = TRUE;
14217 else if (out_off == (bfd_vma) -2)
14218 skip = TRUE, relocate = TRUE;
14219 out_off += (input_section->output_section->vma
14220 + input_section->output_offset);
14221 outrel.r_offset = out_off;
14222 outrel.r_addend = rel->r_addend;
14223
14224 /* Optimize unaligned reloc use. */
14225 if ((r_type == R_PPC64_ADDR64 && (out_off & 7) != 0)
14226 || (r_type == R_PPC64_UADDR64 && (out_off & 7) == 0))
14227 r_type ^= R_PPC64_ADDR64 ^ R_PPC64_UADDR64;
14228 else if ((r_type == R_PPC64_ADDR32 && (out_off & 3) != 0)
14229 || (r_type == R_PPC64_UADDR32 && (out_off & 3) == 0))
14230 r_type ^= R_PPC64_ADDR32 ^ R_PPC64_UADDR32;
14231 else if ((r_type == R_PPC64_ADDR16 && (out_off & 1) != 0)
14232 || (r_type == R_PPC64_UADDR16 && (out_off & 1) == 0))
14233 r_type ^= R_PPC64_ADDR16 ^ R_PPC64_UADDR16;
14234
14235 if (skip)
14236 memset (&outrel, 0, sizeof outrel);
14237 else if (!SYMBOL_REFERENCES_LOCAL (info, &h->elf)
14238 && !is_opd
14239 && r_type != R_PPC64_TOC)
14240 {
14241 BFD_ASSERT (h->elf.dynindx != -1);
14242 outrel.r_info = ELF64_R_INFO (h->elf.dynindx, r_type);
14243 }
14244 else
14245 {
14246 /* This symbol is local, or marked to become local,
14247 or this is an opd section reloc which must point
14248 at a local function. */
14249 outrel.r_addend += relocation;
14250 if (r_type == R_PPC64_ADDR64 || r_type == R_PPC64_TOC)
14251 {
14252 if (is_opd && h != NULL)
14253 {
14254 /* Lie about opd entries. This case occurs
14255 when building shared libraries and we
14256 reference a function in another shared
14257 lib. The same thing happens for a weak
14258 definition in an application that's
14259 overridden by a strong definition in a
14260 shared lib. (I believe this is a generic
14261 bug in binutils handling of weak syms.)
14262 In these cases we won't use the opd
14263 entry in this lib. */
14264 unresolved_reloc = FALSE;
14265 }
14266 if (!is_opd
14267 && r_type == R_PPC64_ADDR64
14268 && (h != NULL
14269 ? h->elf.type == STT_GNU_IFUNC
14270 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
14271 outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
14272 else
14273 {
14274 outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
14275
14276 /* We need to relocate .opd contents for ld.so.
14277 Prelink also wants simple and consistent rules
14278 for relocs. This make all RELATIVE relocs have
14279 *r_offset equal to r_addend. */
14280 relocate = TRUE;
14281 }
14282 }
14283 else
14284 {
14285 long indx = 0;
14286
14287 if (h != NULL
14288 ? h->elf.type == STT_GNU_IFUNC
14289 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
14290 {
14291 info->callbacks->einfo
14292 (_("%P: %H: %s for indirect "
14293 "function `%T' unsupported\n"),
14294 input_bfd, input_section, rel->r_offset,
14295 ppc64_elf_howto_table[r_type]->name,
14296 sym_name);
14297 ret = FALSE;
14298 }
14299 else if (r_symndx == STN_UNDEF || bfd_is_abs_section (sec))
14300 ;
14301 else if (sec == NULL || sec->owner == NULL)
14302 {
14303 bfd_set_error (bfd_error_bad_value);
14304 return FALSE;
14305 }
14306 else
14307 {
14308 asection *osec;
14309
14310 osec = sec->output_section;
14311 indx = elf_section_data (osec)->dynindx;
14312
14313 if (indx == 0)
14314 {
14315 if ((osec->flags & SEC_READONLY) == 0
14316 && htab->elf.data_index_section != NULL)
14317 osec = htab->elf.data_index_section;
14318 else
14319 osec = htab->elf.text_index_section;
14320 indx = elf_section_data (osec)->dynindx;
14321 }
14322 BFD_ASSERT (indx != 0);
14323
14324 /* We are turning this relocation into one
14325 against a section symbol, so subtract out
14326 the output section's address but not the
14327 offset of the input section in the output
14328 section. */
14329 outrel.r_addend -= osec->vma;
14330 }
14331
14332 outrel.r_info = ELF64_R_INFO (indx, r_type);
14333 }
14334 }
14335
14336 sreloc = elf_section_data (input_section)->sreloc;
14337 if (h != NULL
14338 ? h->elf.type == STT_GNU_IFUNC
14339 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
14340 sreloc = htab->elf.irelplt;
14341 if (sreloc == NULL)
14342 abort ();
14343
14344 if (sreloc->reloc_count * sizeof (Elf64_External_Rela)
14345 >= sreloc->size)
14346 abort ();
14347 loc = sreloc->contents;
14348 loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
14349 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
14350
14351 /* If this reloc is against an external symbol, it will
14352 be computed at runtime, so there's no need to do
14353 anything now. However, for the sake of prelink ensure
14354 that the section contents are a known value. */
14355 if (! relocate)
14356 {
14357 unresolved_reloc = FALSE;
14358 /* The value chosen here is quite arbitrary as ld.so
14359 ignores section contents except for the special
14360 case of .opd where the contents might be accessed
14361 before relocation. Choose zero, as that won't
14362 cause reloc overflow. */
14363 relocation = 0;
14364 addend = 0;
14365 /* Use *r_offset == r_addend for R_PPC64_ADDR64 relocs
14366 to improve backward compatibility with older
14367 versions of ld. */
14368 if (r_type == R_PPC64_ADDR64)
14369 addend = outrel.r_addend;
14370 /* Adjust pc_relative relocs to have zero in *r_offset. */
14371 else if (ppc64_elf_howto_table[r_type]->pc_relative)
14372 addend = (input_section->output_section->vma
14373 + input_section->output_offset
14374 + rel->r_offset);
14375 }
14376 }
14377 break;
14378
14379 case R_PPC64_COPY:
14380 case R_PPC64_GLOB_DAT:
14381 case R_PPC64_JMP_SLOT:
14382 case R_PPC64_JMP_IREL:
14383 case R_PPC64_RELATIVE:
14384 /* We shouldn't ever see these dynamic relocs in relocatable
14385 files. */
14386 /* Fall through. */
14387
14388 case R_PPC64_PLTGOT16:
14389 case R_PPC64_PLTGOT16_DS:
14390 case R_PPC64_PLTGOT16_HA:
14391 case R_PPC64_PLTGOT16_HI:
14392 case R_PPC64_PLTGOT16_LO:
14393 case R_PPC64_PLTGOT16_LO_DS:
14394 case R_PPC64_PLTREL32:
14395 case R_PPC64_PLTREL64:
14396 /* These ones haven't been implemented yet. */
14397
14398 info->callbacks->einfo
14399 (_("%P: %B: %s is not supported for `%T'\n"),
14400 input_bfd,
14401 ppc64_elf_howto_table[r_type]->name, sym_name);
14402
14403 bfd_set_error (bfd_error_invalid_operation);
14404 ret = FALSE;
14405 continue;
14406 }
14407
14408 /* Multi-instruction sequences that access the TOC can be
14409 optimized, eg. addis ra,r2,0; addi rb,ra,x;
14410 to nop; addi rb,r2,x; */
14411 switch (r_type)
14412 {
14413 default:
14414 break;
14415
14416 case R_PPC64_GOT_TLSLD16_HI:
14417 case R_PPC64_GOT_TLSGD16_HI:
14418 case R_PPC64_GOT_TPREL16_HI:
14419 case R_PPC64_GOT_DTPREL16_HI:
14420 case R_PPC64_GOT16_HI:
14421 case R_PPC64_TOC16_HI:
14422 /* These relocs would only be useful if building up an
14423 offset to later add to r2, perhaps in an indexed
14424 addressing mode instruction. Don't try to optimize.
14425 Unfortunately, the possibility of someone building up an
14426 offset like this or even with the HA relocs, means that
14427 we need to check the high insn when optimizing the low
14428 insn. */
14429 break;
14430
14431 case R_PPC64_GOT_TLSLD16_HA:
14432 case R_PPC64_GOT_TLSGD16_HA:
14433 case R_PPC64_GOT_TPREL16_HA:
14434 case R_PPC64_GOT_DTPREL16_HA:
14435 case R_PPC64_GOT16_HA:
14436 case R_PPC64_TOC16_HA:
14437 if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
14438 && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
14439 {
14440 bfd_byte *p = contents + (rel->r_offset & ~3);
14441 bfd_put_32 (input_bfd, NOP, p);
14442 }
14443 break;
14444
14445 case R_PPC64_GOT_TLSLD16_LO:
14446 case R_PPC64_GOT_TLSGD16_LO:
14447 case R_PPC64_GOT_TPREL16_LO_DS:
14448 case R_PPC64_GOT_DTPREL16_LO_DS:
14449 case R_PPC64_GOT16_LO:
14450 case R_PPC64_GOT16_LO_DS:
14451 case R_PPC64_TOC16_LO:
14452 case R_PPC64_TOC16_LO_DS:
14453 if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
14454 && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
14455 {
14456 bfd_byte *p = contents + (rel->r_offset & ~3);
14457 insn = bfd_get_32 (input_bfd, p);
14458 if ((insn & (0x3f << 26)) == 12u << 26 /* addic */)
14459 {
14460 /* Transform addic to addi when we change reg. */
14461 insn &= ~((0x3f << 26) | (0x1f << 16));
14462 insn |= (14u << 26) | (2 << 16);
14463 }
14464 else
14465 {
14466 insn &= ~(0x1f << 16);
14467 insn |= 2 << 16;
14468 }
14469 bfd_put_32 (input_bfd, insn, p);
14470 }
14471 break;
14472 }
14473
14474 /* Do any further special processing. */
14475 switch (r_type)
14476 {
14477 default:
14478 break;
14479
14480 case R_PPC64_REL16_HA:
14481 case R_PPC64_ADDR16_HA:
14482 case R_PPC64_ADDR16_HIGHA:
14483 case R_PPC64_ADDR16_HIGHERA:
14484 case R_PPC64_ADDR16_HIGHESTA:
14485 case R_PPC64_TOC16_HA:
14486 case R_PPC64_SECTOFF_HA:
14487 case R_PPC64_TPREL16_HA:
14488 case R_PPC64_TPREL16_HIGHA:
14489 case R_PPC64_TPREL16_HIGHERA:
14490 case R_PPC64_TPREL16_HIGHESTA:
14491 case R_PPC64_DTPREL16_HA:
14492 case R_PPC64_DTPREL16_HIGHA:
14493 case R_PPC64_DTPREL16_HIGHERA:
14494 case R_PPC64_DTPREL16_HIGHESTA:
14495 /* It's just possible that this symbol is a weak symbol
14496 that's not actually defined anywhere. In that case,
14497 'sec' would be NULL, and we should leave the symbol
14498 alone (it will be set to zero elsewhere in the link). */
14499 if (sec == NULL)
14500 break;
14501 /* Fall thru */
14502
14503 case R_PPC64_GOT16_HA:
14504 case R_PPC64_PLTGOT16_HA:
14505 case R_PPC64_PLT16_HA:
14506 case R_PPC64_GOT_TLSGD16_HA:
14507 case R_PPC64_GOT_TLSLD16_HA:
14508 case R_PPC64_GOT_TPREL16_HA:
14509 case R_PPC64_GOT_DTPREL16_HA:
14510 /* Add 0x10000 if sign bit in 0:15 is set.
14511 Bits 0:15 are not used. */
14512 addend += 0x8000;
14513 break;
14514
14515 case R_PPC64_ADDR16_DS:
14516 case R_PPC64_ADDR16_LO_DS:
14517 case R_PPC64_GOT16_DS:
14518 case R_PPC64_GOT16_LO_DS:
14519 case R_PPC64_PLT16_LO_DS:
14520 case R_PPC64_SECTOFF_DS:
14521 case R_PPC64_SECTOFF_LO_DS:
14522 case R_PPC64_TOC16_DS:
14523 case R_PPC64_TOC16_LO_DS:
14524 case R_PPC64_PLTGOT16_DS:
14525 case R_PPC64_PLTGOT16_LO_DS:
14526 case R_PPC64_GOT_TPREL16_DS:
14527 case R_PPC64_GOT_TPREL16_LO_DS:
14528 case R_PPC64_GOT_DTPREL16_DS:
14529 case R_PPC64_GOT_DTPREL16_LO_DS:
14530 case R_PPC64_TPREL16_DS:
14531 case R_PPC64_TPREL16_LO_DS:
14532 case R_PPC64_DTPREL16_DS:
14533 case R_PPC64_DTPREL16_LO_DS:
14534 insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
14535 mask = 3;
14536 /* If this reloc is against an lq insn, then the value must be
14537 a multiple of 16. This is somewhat of a hack, but the
14538 "correct" way to do this by defining _DQ forms of all the
14539 _DS relocs bloats all reloc switches in this file. It
14540 doesn't seem to make much sense to use any of these relocs
14541 in data, so testing the insn should be safe. */
14542 if ((insn & (0x3f << 26)) == (56u << 26))
14543 mask = 15;
14544 if (((relocation + addend) & mask) != 0)
14545 {
14546 info->callbacks->einfo
14547 (_("%P: %H: error: %s not a multiple of %u\n"),
14548 input_bfd, input_section, rel->r_offset,
14549 ppc64_elf_howto_table[r_type]->name,
14550 mask + 1);
14551 bfd_set_error (bfd_error_bad_value);
14552 ret = FALSE;
14553 continue;
14554 }
14555 break;
14556 }
14557
14558 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
14559 because such sections are not SEC_ALLOC and thus ld.so will
14560 not process them. */
14561 if (unresolved_reloc
14562 && !((input_section->flags & SEC_DEBUGGING) != 0
14563 && h->elf.def_dynamic)
14564 && _bfd_elf_section_offset (output_bfd, info, input_section,
14565 rel->r_offset) != (bfd_vma) -1)
14566 {
14567 info->callbacks->einfo
14568 (_("%P: %H: unresolvable %s against `%T'\n"),
14569 input_bfd, input_section, rel->r_offset,
14570 ppc64_elf_howto_table[(int) r_type]->name,
14571 h->elf.root.root.string);
14572 ret = FALSE;
14573 }
14574
14575 r = _bfd_final_link_relocate (ppc64_elf_howto_table[(int) r_type],
14576 input_bfd,
14577 input_section,
14578 contents,
14579 rel->r_offset,
14580 relocation,
14581 addend);
14582
14583 if (r != bfd_reloc_ok)
14584 {
14585 char *more_info = NULL;
14586 const char *reloc_name = ppc64_elf_howto_table[r_type]->name;
14587
14588 if (reloc_dest != DEST_NORMAL)
14589 {
14590 more_info = bfd_malloc (strlen (reloc_name) + 8);
14591 if (more_info != NULL)
14592 {
14593 strcpy (more_info, reloc_name);
14594 strcat (more_info, (reloc_dest == DEST_OPD
14595 ? " (OPD)" : " (stub)"));
14596 reloc_name = more_info;
14597 }
14598 }
14599
14600 if (r == bfd_reloc_overflow)
14601 {
14602 if (warned)
14603 continue;
14604 if (h != NULL
14605 && h->elf.root.type == bfd_link_hash_undefweak
14606 && ppc64_elf_howto_table[r_type]->pc_relative)
14607 {
14608 /* Assume this is a call protected by other code that
14609 detects the symbol is undefined. If this is the case,
14610 we can safely ignore the overflow. If not, the
14611 program is hosed anyway, and a little warning isn't
14612 going to help. */
14613
14614 continue;
14615 }
14616
14617 if (!((*info->callbacks->reloc_overflow)
14618 (info, &h->elf.root, sym_name,
14619 reloc_name, orig_rel.r_addend,
14620 input_bfd, input_section, rel->r_offset)))
14621 return FALSE;
14622 }
14623 else
14624 {
14625 info->callbacks->einfo
14626 (_("%P: %H: %s against `%T': error %d\n"),
14627 input_bfd, input_section, rel->r_offset,
14628 reloc_name, sym_name, (int) r);
14629 ret = FALSE;
14630 }
14631 if (more_info != NULL)
14632 free (more_info);
14633 }
14634 }
14635
14636 /* If we're emitting relocations, then shortly after this function
14637 returns, reloc offsets and addends for this section will be
14638 adjusted. Worse, reloc symbol indices will be for the output
14639 file rather than the input. Save a copy of the relocs for
14640 opd_entry_value. */
14641 if (is_opd && (info->emitrelocations || info->relocatable))
14642 {
14643 bfd_size_type amt;
14644 amt = input_section->reloc_count * sizeof (Elf_Internal_Rela);
14645 rel = bfd_alloc (input_bfd, amt);
14646 BFD_ASSERT (ppc64_elf_tdata (input_bfd)->opd.relocs == NULL);
14647 ppc64_elf_tdata (input_bfd)->opd.relocs = rel;
14648 if (rel == NULL)
14649 return FALSE;
14650 memcpy (rel, relocs, amt);
14651 }
14652 return ret;
14653 }
14654
14655 /* Adjust the value of any local symbols in opd sections. */
14656
14657 static int
14658 ppc64_elf_output_symbol_hook (struct bfd_link_info *info,
14659 const char *name ATTRIBUTE_UNUSED,
14660 Elf_Internal_Sym *elfsym,
14661 asection *input_sec,
14662 struct elf_link_hash_entry *h)
14663 {
14664 struct _opd_sec_data *opd;
14665 long adjust;
14666 bfd_vma value;
14667
14668 if (h != NULL)
14669 return 1;
14670
14671 opd = get_opd_info (input_sec);
14672 if (opd == NULL || opd->adjust == NULL)
14673 return 1;
14674
14675 value = elfsym->st_value - input_sec->output_offset;
14676 if (!info->relocatable)
14677 value -= input_sec->output_section->vma;
14678
14679 adjust = opd->adjust[value / 8];
14680 if (adjust == -1)
14681 return 2;
14682
14683 elfsym->st_value += adjust;
14684 return 1;
14685 }
14686
14687 /* Finish up dynamic symbol handling. We set the contents of various
14688 dynamic sections here. */
14689
14690 static bfd_boolean
14691 ppc64_elf_finish_dynamic_symbol (bfd *output_bfd,
14692 struct bfd_link_info *info,
14693 struct elf_link_hash_entry *h,
14694 Elf_Internal_Sym *sym ATTRIBUTE_UNUSED)
14695 {
14696 struct ppc_link_hash_table *htab;
14697 struct plt_entry *ent;
14698 Elf_Internal_Rela rela;
14699 bfd_byte *loc;
14700
14701 htab = ppc_hash_table (info);
14702 if (htab == NULL)
14703 return FALSE;
14704
14705 for (ent = h->plt.plist; ent != NULL; ent = ent->next)
14706 if (ent->plt.offset != (bfd_vma) -1)
14707 {
14708 /* This symbol has an entry in the procedure linkage
14709 table. Set it up. */
14710 if (!htab->elf.dynamic_sections_created
14711 || h->dynindx == -1)
14712 {
14713 BFD_ASSERT (h->type == STT_GNU_IFUNC
14714 && h->def_regular
14715 && (h->root.type == bfd_link_hash_defined
14716 || h->root.type == bfd_link_hash_defweak));
14717 rela.r_offset = (htab->elf.iplt->output_section->vma
14718 + htab->elf.iplt->output_offset
14719 + ent->plt.offset);
14720 if (htab->opd_abi)
14721 rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
14722 else
14723 rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
14724 rela.r_addend = (h->root.u.def.value
14725 + h->root.u.def.section->output_offset
14726 + h->root.u.def.section->output_section->vma
14727 + ent->addend);
14728 loc = (htab->elf.irelplt->contents
14729 + (htab->elf.irelplt->reloc_count++
14730 * sizeof (Elf64_External_Rela)));
14731 }
14732 else
14733 {
14734 rela.r_offset = (htab->elf.splt->output_section->vma
14735 + htab->elf.splt->output_offset
14736 + ent->plt.offset);
14737 rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_JMP_SLOT);
14738 rela.r_addend = ent->addend;
14739 loc = (htab->elf.srelplt->contents
14740 + ((ent->plt.offset - PLT_INITIAL_ENTRY_SIZE (htab))
14741 / PLT_ENTRY_SIZE (htab) * sizeof (Elf64_External_Rela)));
14742 }
14743 bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
14744
14745 if (!htab->opd_abi)
14746 {
14747 if (!h->def_regular)
14748 {
14749 /* Mark the symbol as undefined, rather than as
14750 defined in glink. Leave the value if there were
14751 any relocations where pointer equality matters
14752 (this is a clue for the dynamic linker, to make
14753 function pointer comparisons work between an
14754 application and shared library), otherwise set it
14755 to zero. */
14756 sym->st_shndx = SHN_UNDEF;
14757 if (!h->pointer_equality_needed)
14758 sym->st_value = 0;
14759 else if (!h->ref_regular_nonweak)
14760 {
14761 /* This breaks function pointer comparisons, but
14762 that is better than breaking tests for a NULL
14763 function pointer. */
14764 sym->st_value = 0;
14765 }
14766 }
14767 }
14768 }
14769
14770 if (h->needs_copy)
14771 {
14772 /* This symbol needs a copy reloc. Set it up. */
14773
14774 if (h->dynindx == -1
14775 || (h->root.type != bfd_link_hash_defined
14776 && h->root.type != bfd_link_hash_defweak)
14777 || htab->relbss == NULL)
14778 abort ();
14779
14780 rela.r_offset = (h->root.u.def.value
14781 + h->root.u.def.section->output_section->vma
14782 + h->root.u.def.section->output_offset);
14783 rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_COPY);
14784 rela.r_addend = 0;
14785 loc = htab->relbss->contents;
14786 loc += htab->relbss->reloc_count++ * sizeof (Elf64_External_Rela);
14787 bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
14788 }
14789
14790 return TRUE;
14791 }
14792
14793 /* Used to decide how to sort relocs in an optimal manner for the
14794 dynamic linker, before writing them out. */
14795
14796 static enum elf_reloc_type_class
14797 ppc64_elf_reloc_type_class (const struct bfd_link_info *info,
14798 const asection *rel_sec,
14799 const Elf_Internal_Rela *rela)
14800 {
14801 enum elf_ppc64_reloc_type r_type;
14802 struct ppc_link_hash_table *htab = ppc_hash_table (info);
14803
14804 if (rel_sec == htab->elf.irelplt)
14805 return reloc_class_ifunc;
14806
14807 r_type = ELF64_R_TYPE (rela->r_info);
14808 switch (r_type)
14809 {
14810 case R_PPC64_RELATIVE:
14811 return reloc_class_relative;
14812 case R_PPC64_JMP_SLOT:
14813 return reloc_class_plt;
14814 case R_PPC64_COPY:
14815 return reloc_class_copy;
14816 default:
14817 return reloc_class_normal;
14818 }
14819 }
14820
14821 /* Finish up the dynamic sections. */
14822
14823 static bfd_boolean
14824 ppc64_elf_finish_dynamic_sections (bfd *output_bfd,
14825 struct bfd_link_info *info)
14826 {
14827 struct ppc_link_hash_table *htab;
14828 bfd *dynobj;
14829 asection *sdyn;
14830
14831 htab = ppc_hash_table (info);
14832 if (htab == NULL)
14833 return FALSE;
14834
14835 dynobj = htab->elf.dynobj;
14836 sdyn = bfd_get_linker_section (dynobj, ".dynamic");
14837
14838 if (htab->elf.dynamic_sections_created)
14839 {
14840 Elf64_External_Dyn *dyncon, *dynconend;
14841
14842 if (sdyn == NULL || htab->elf.sgot == NULL)
14843 abort ();
14844
14845 dyncon = (Elf64_External_Dyn *) sdyn->contents;
14846 dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
14847 for (; dyncon < dynconend; dyncon++)
14848 {
14849 Elf_Internal_Dyn dyn;
14850 asection *s;
14851
14852 bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
14853
14854 switch (dyn.d_tag)
14855 {
14856 default:
14857 continue;
14858
14859 case DT_PPC64_GLINK:
14860 s = htab->glink;
14861 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
14862 /* We stupidly defined DT_PPC64_GLINK to be the start
14863 of glink rather than the first entry point, which is
14864 what ld.so needs, and now have a bigger stub to
14865 support automatic multiple TOCs. */
14866 dyn.d_un.d_ptr += GLINK_CALL_STUB_SIZE - 8 * 4;
14867 break;
14868
14869 case DT_PPC64_OPD:
14870 s = bfd_get_section_by_name (output_bfd, ".opd");
14871 if (s == NULL)
14872 continue;
14873 dyn.d_un.d_ptr = s->vma;
14874 break;
14875
14876 case DT_PPC64_OPT:
14877 if (htab->do_multi_toc && htab->multi_toc_needed)
14878 dyn.d_un.d_val |= PPC64_OPT_MULTI_TOC;
14879 break;
14880
14881 case DT_PPC64_OPDSZ:
14882 s = bfd_get_section_by_name (output_bfd, ".opd");
14883 if (s == NULL)
14884 continue;
14885 dyn.d_un.d_val = s->size;
14886 break;
14887
14888 case DT_PLTGOT:
14889 s = htab->elf.splt;
14890 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
14891 break;
14892
14893 case DT_JMPREL:
14894 s = htab->elf.srelplt;
14895 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
14896 break;
14897
14898 case DT_PLTRELSZ:
14899 dyn.d_un.d_val = htab->elf.srelplt->size;
14900 break;
14901
14902 case DT_RELASZ:
14903 /* Don't count procedure linkage table relocs in the
14904 overall reloc count. */
14905 s = htab->elf.srelplt;
14906 if (s == NULL)
14907 continue;
14908 dyn.d_un.d_val -= s->size;
14909 break;
14910
14911 case DT_RELA:
14912 /* We may not be using the standard ELF linker script.
14913 If .rela.plt is the first .rela section, we adjust
14914 DT_RELA to not include it. */
14915 s = htab->elf.srelplt;
14916 if (s == NULL)
14917 continue;
14918 if (dyn.d_un.d_ptr != s->output_section->vma + s->output_offset)
14919 continue;
14920 dyn.d_un.d_ptr += s->size;
14921 break;
14922 }
14923
14924 bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
14925 }
14926 }
14927
14928 if (htab->elf.sgot != NULL && htab->elf.sgot->size != 0)
14929 {
14930 /* Fill in the first entry in the global offset table.
14931 We use it to hold the link-time TOCbase. */
14932 bfd_put_64 (output_bfd,
14933 elf_gp (output_bfd) + TOC_BASE_OFF,
14934 htab->elf.sgot->contents);
14935
14936 /* Set .got entry size. */
14937 elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize = 8;
14938 }
14939
14940 if (htab->elf.splt != NULL && htab->elf.splt->size != 0)
14941 {
14942 /* Set .plt entry size. */
14943 elf_section_data (htab->elf.splt->output_section)->this_hdr.sh_entsize
14944 = PLT_ENTRY_SIZE (htab);
14945 }
14946
14947 /* brlt is SEC_LINKER_CREATED, so we need to write out relocs for
14948 brlt ourselves if emitrelocations. */
14949 if (htab->brlt != NULL
14950 && htab->brlt->reloc_count != 0
14951 && !_bfd_elf_link_output_relocs (output_bfd,
14952 htab->brlt,
14953 elf_section_data (htab->brlt)->rela.hdr,
14954 elf_section_data (htab->brlt)->relocs,
14955 NULL))
14956 return FALSE;
14957
14958 if (htab->glink != NULL
14959 && htab->glink->reloc_count != 0
14960 && !_bfd_elf_link_output_relocs (output_bfd,
14961 htab->glink,
14962 elf_section_data (htab->glink)->rela.hdr,
14963 elf_section_data (htab->glink)->relocs,
14964 NULL))
14965 return FALSE;
14966
14967
14968 if (htab->glink_eh_frame != NULL
14969 && htab->glink_eh_frame->sec_info_type == SEC_INFO_TYPE_EH_FRAME
14970 && !_bfd_elf_write_section_eh_frame (output_bfd, info,
14971 htab->glink_eh_frame,
14972 htab->glink_eh_frame->contents))
14973 return FALSE;
14974
14975 /* We need to handle writing out multiple GOT sections ourselves,
14976 since we didn't add them to DYNOBJ. We know dynobj is the first
14977 bfd. */
14978 while ((dynobj = dynobj->link_next) != NULL)
14979 {
14980 asection *s;
14981
14982 if (!is_ppc64_elf (dynobj))
14983 continue;
14984
14985 s = ppc64_elf_tdata (dynobj)->got;
14986 if (s != NULL
14987 && s->size != 0
14988 && s->output_section != bfd_abs_section_ptr
14989 && !bfd_set_section_contents (output_bfd, s->output_section,
14990 s->contents, s->output_offset,
14991 s->size))
14992 return FALSE;
14993 s = ppc64_elf_tdata (dynobj)->relgot;
14994 if (s != NULL
14995 && s->size != 0
14996 && s->output_section != bfd_abs_section_ptr
14997 && !bfd_set_section_contents (output_bfd, s->output_section,
14998 s->contents, s->output_offset,
14999 s->size))
15000 return FALSE;
15001 }
15002
15003 return TRUE;
15004 }
15005
15006 #include "elf64-target.h"
15007
15008 /* FreeBSD support */
15009
15010 #undef TARGET_LITTLE_SYM
15011 #undef TARGET_LITTLE_NAME
15012
15013 #undef TARGET_BIG_SYM
15014 #define TARGET_BIG_SYM bfd_elf64_powerpc_freebsd_vec
15015 #undef TARGET_BIG_NAME
15016 #define TARGET_BIG_NAME "elf64-powerpc-freebsd"
15017
15018 #undef ELF_OSABI
15019 #define ELF_OSABI ELFOSABI_FREEBSD
15020
15021 #undef elf64_bed
15022 #define elf64_bed elf64_powerpc_fbsd_bed
15023
15024 #include "elf64-target.h"
15025
GDB Binutils - Deliverables
This page took 0.381021 seconds and 4 git commands to generate.