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


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