projects / deliverable / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Update copyright years
[deliverable/binutils-gdb.git] / bfd / elf64-ppc.c
1 /* PowerPC64-specific support for 64-bit ELF.
2 Copyright (C) 1999-2014 Free Software Foundation, Inc.
3 Written by Linus Nordberg, Swox AB <info@swox.com>,
4 based on elf32-ppc.c by Ian Lance Taylor.
5 Largely rewritten by Alan Modra.
6
7 This file is part of BFD, the Binary File Descriptor library.
8
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
13
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
18
19 You should have received a copy of the GNU General Public License along
20 with this program; if not, write to the Free Software Foundation, Inc.,
21 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */
22
23
24 /* The 64-bit PowerPC ELF ABI may be found at
25 http://www.linuxbase.org/spec/ELF/ppc64/PPC-elf64abi.txt, and
26 http://www.linuxbase.org/spec/ELF/ppc64/spec/book1.html */
27
28 #include "sysdep.h"
29 #include <stdarg.h>
30 #include "bfd.h"
31 #include "bfdlink.h"
32 #include "libbfd.h"
33 #include "elf-bfd.h"
34 #include "elf/ppc64.h"
35 #include "elf64-ppc.h"
36 #include "dwarf2.h"
37
38 static bfd_reloc_status_type ppc64_elf_ha_reloc
39 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
40 static bfd_reloc_status_type ppc64_elf_branch_reloc
41 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
42 static bfd_reloc_status_type ppc64_elf_brtaken_reloc
43 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
44 static bfd_reloc_status_type ppc64_elf_sectoff_reloc
45 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
46 static bfd_reloc_status_type ppc64_elf_sectoff_ha_reloc
47 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
48 static bfd_reloc_status_type ppc64_elf_toc_reloc
49 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
50 static bfd_reloc_status_type ppc64_elf_toc_ha_reloc
51 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
52 static bfd_reloc_status_type ppc64_elf_toc64_reloc
53 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
54 static bfd_reloc_status_type ppc64_elf_unhandled_reloc
55 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
56 static bfd_vma opd_entry_value
57 (asection *, bfd_vma, asection **, bfd_vma *, bfd_boolean);
58
59 #define TARGET_LITTLE_SYM bfd_elf64_powerpcle_vec
60 #define TARGET_LITTLE_NAME "elf64-powerpcle"
61 #define TARGET_BIG_SYM bfd_elf64_powerpc_vec
62 #define TARGET_BIG_NAME "elf64-powerpc"
63 #define ELF_ARCH bfd_arch_powerpc
64 #define ELF_TARGET_ID PPC64_ELF_DATA
65 #define ELF_MACHINE_CODE EM_PPC64
66 #define ELF_MAXPAGESIZE 0x10000
67 #define ELF_COMMONPAGESIZE 0x1000
68 #define elf_info_to_howto ppc64_elf_info_to_howto
69
70 #define elf_backend_want_got_sym 0
71 #define elf_backend_want_plt_sym 0
72 #define elf_backend_plt_alignment 3
73 #define elf_backend_plt_not_loaded 1
74 #define elf_backend_got_header_size 8
75 #define elf_backend_can_gc_sections 1
76 #define elf_backend_can_refcount 1
77 #define elf_backend_rela_normal 1
78 #define elf_backend_default_execstack 0
79
80 #define bfd_elf64_mkobject ppc64_elf_mkobject
81 #define bfd_elf64_bfd_reloc_type_lookup ppc64_elf_reloc_type_lookup
82 #define bfd_elf64_bfd_reloc_name_lookup ppc64_elf_reloc_name_lookup
83 #define bfd_elf64_bfd_merge_private_bfd_data ppc64_elf_merge_private_bfd_data
84 #define bfd_elf64_bfd_print_private_bfd_data ppc64_elf_print_private_bfd_data
85 #define bfd_elf64_new_section_hook ppc64_elf_new_section_hook
86 #define bfd_elf64_bfd_link_hash_table_create ppc64_elf_link_hash_table_create
87 #define bfd_elf64_bfd_link_hash_table_free ppc64_elf_link_hash_table_free
88 #define bfd_elf64_get_synthetic_symtab ppc64_elf_get_synthetic_symtab
89 #define bfd_elf64_bfd_link_just_syms ppc64_elf_link_just_syms
90
91 #define elf_backend_object_p ppc64_elf_object_p
92 #define elf_backend_grok_prstatus ppc64_elf_grok_prstatus
93 #define elf_backend_grok_psinfo ppc64_elf_grok_psinfo
94 #define elf_backend_write_core_note ppc64_elf_write_core_note
95 #define elf_backend_create_dynamic_sections ppc64_elf_create_dynamic_sections
96 #define elf_backend_copy_indirect_symbol ppc64_elf_copy_indirect_symbol
97 #define elf_backend_add_symbol_hook ppc64_elf_add_symbol_hook
98 #define elf_backend_check_directives ppc64_elf_process_dot_syms
99 #define elf_backend_notice_as_needed ppc64_elf_notice_as_needed
100 #define elf_backend_archive_symbol_lookup ppc64_elf_archive_symbol_lookup
101 #define elf_backend_check_relocs ppc64_elf_check_relocs
102 #define elf_backend_gc_keep ppc64_elf_gc_keep
103 #define elf_backend_gc_mark_dynamic_ref ppc64_elf_gc_mark_dynamic_ref
104 #define elf_backend_gc_mark_hook ppc64_elf_gc_mark_hook
105 #define elf_backend_gc_sweep_hook ppc64_elf_gc_sweep_hook
106 #define elf_backend_adjust_dynamic_symbol ppc64_elf_adjust_dynamic_symbol
107 #define elf_backend_hide_symbol ppc64_elf_hide_symbol
108 #define elf_backend_maybe_function_sym ppc64_elf_maybe_function_sym
109 #define elf_backend_always_size_sections ppc64_elf_func_desc_adjust
110 #define elf_backend_size_dynamic_sections ppc64_elf_size_dynamic_sections
111 #define elf_backend_hash_symbol ppc64_elf_hash_symbol
112 #define elf_backend_init_index_section _bfd_elf_init_2_index_sections
113 #define elf_backend_action_discarded ppc64_elf_action_discarded
114 #define elf_backend_relocate_section ppc64_elf_relocate_section
115 #define elf_backend_finish_dynamic_symbol ppc64_elf_finish_dynamic_symbol
116 #define elf_backend_reloc_type_class ppc64_elf_reloc_type_class
117 #define elf_backend_finish_dynamic_sections ppc64_elf_finish_dynamic_sections
118 #define elf_backend_link_output_symbol_hook ppc64_elf_output_symbol_hook
119 #define elf_backend_special_sections ppc64_elf_special_sections
120 #define elf_backend_merge_symbol_attribute ppc64_elf_merge_symbol_attribute
121
122 /* The name of the dynamic interpreter. This is put in the .interp
123 section. */
124 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
125
126 /* The size in bytes of an entry in the procedure linkage table. */
127 #define PLT_ENTRY_SIZE(htab) (htab->opd_abi ? 24 : 8)
128
129 /* The initial size of the plt reserved for the dynamic linker. */
130 #define PLT_INITIAL_ENTRY_SIZE(htab) (htab->opd_abi ? 24 : 16)
131
132 /* Offsets to some stack save slots. */
133 #define STK_LR 16
134 #define STK_TOC(htab) (htab->opd_abi ? 40 : 24)
135 /* This one is dodgy. ELFv2 does not have a linker word, so use the
136 CR save slot. Used only by optimised __tls_get_addr call stub,
137 relying on __tls_get_addr_opt not saving CR.. */
138 #define STK_LINKER(htab) (htab->opd_abi ? 32 : 8)
139
140 /* TOC base pointers offset from start of TOC. */
141 #define TOC_BASE_OFF 0x8000
142
143 /* Offset of tp and dtp pointers from start of TLS block. */
144 #define TP_OFFSET 0x7000
145 #define DTP_OFFSET 0x8000
146
147 /* .plt call stub instructions. The normal stub is like this, but
148 sometimes the .plt entry crosses a 64k boundary and we need to
149 insert an addi to adjust r11. */
150 #define STD_R2_0R1 0xf8410000 /* std %r2,0+40(%r1) */
151 #define ADDIS_R11_R2 0x3d620000 /* addis %r11,%r2,xxx@ha */
152 #define LD_R12_0R11 0xe98b0000 /* ld %r12,xxx+0@l(%r11) */
153 #define MTCTR_R12 0x7d8903a6 /* mtctr %r12 */
154 #define LD_R2_0R11 0xe84b0000 /* ld %r2,xxx+8@l(%r11) */
155 #define LD_R11_0R11 0xe96b0000 /* ld %r11,xxx+16@l(%r11) */
156 #define BCTR 0x4e800420 /* bctr */
157
158 #define ADDI_R11_R11 0x396b0000 /* addi %r11,%r11,off@l */
159 #define ADDIS_R2_R2 0x3c420000 /* addis %r2,%r2,off@ha */
160 #define ADDI_R2_R2 0x38420000 /* addi %r2,%r2,off@l */
161
162 #define XOR_R2_R12_R12 0x7d826278 /* xor %r2,%r12,%r12 */
163 #define ADD_R11_R11_R2 0x7d6b1214 /* add %r11,%r11,%r2 */
164 #define XOR_R11_R12_R12 0x7d8b6278 /* xor %r11,%r12,%r12 */
165 #define ADD_R2_R2_R11 0x7c425a14 /* add %r2,%r2,%r11 */
166 #define CMPLDI_R2_0 0x28220000 /* cmpldi %r2,0 */
167 #define BNECTR 0x4ca20420 /* bnectr+ */
168 #define BNECTR_P4 0x4ce20420 /* bnectr+ */
169
170 #define LD_R12_0R2 0xe9820000 /* ld %r12,xxx+0(%r2) */
171 #define LD_R11_0R2 0xe9620000 /* ld %r11,xxx+0(%r2) */
172 #define LD_R2_0R2 0xe8420000 /* ld %r2,xxx+0(%r2) */
173
174 #define LD_R2_0R1 0xe8410000 /* ld %r2,0(%r1) */
175
176 #define ADDIS_R12_R12 0x3d8c0000 /* addis %r12,%r12,xxx@ha */
177 #define LD_R12_0R12 0xe98c0000 /* ld %r12,xxx@l(%r12) */
178
179 /* glink call stub instructions. We enter with the index in R0. */
180 #define GLINK_CALL_STUB_SIZE (16*4)
181 /* 0: */
182 /* .quad plt0-1f */
183 /* __glink: */
184 #define MFLR_R12 0x7d8802a6 /* mflr %12 */
185 #define BCL_20_31 0x429f0005 /* bcl 20,31,1f */
186 /* 1: */
187 #define MFLR_R11 0x7d6802a6 /* mflr %11 */
188 /* ld %2,(0b-1b)(%11) */
189 #define MTLR_R12 0x7d8803a6 /* mtlr %12 */
190 #define ADD_R11_R2_R11 0x7d625a14 /* add %11,%2,%11 */
191 /* ld %12,0(%11) */
192 /* ld %2,8(%11) */
193 /* mtctr %12 */
194 /* ld %11,16(%11) */
195 /* bctr */
196 #define MFLR_R0 0x7c0802a6 /* mflr %r0 */
197 #define MTLR_R0 0x7c0803a6 /* mtlr %r0 */
198 #define SUB_R12_R12_R11 0x7d8b6050 /* subf %r12,%r11,%r12 */
199 #define ADDI_R0_R12 0x380c0000 /* addi %r0,%r12,0 */
200 #define SRDI_R0_R0_2 0x7800f082 /* rldicl %r0,%r0,62,2 */
201
202 /* Pad with this. */
203 #define NOP 0x60000000
204
205 /* Some other nops. */
206 #define CROR_151515 0x4def7b82
207 #define CROR_313131 0x4ffffb82
208
209 /* .glink entries for the first 32k functions are two instructions. */
210 #define LI_R0_0 0x38000000 /* li %r0,0 */
211 #define B_DOT 0x48000000 /* b . */
212
213 /* After that, we need two instructions to load the index, followed by
214 a branch. */
215 #define LIS_R0_0 0x3c000000 /* lis %r0,0 */
216 #define ORI_R0_R0_0 0x60000000 /* ori %r0,%r0,0 */
217
218 /* Instructions used by the save and restore reg functions. */
219 #define STD_R0_0R1 0xf8010000 /* std %r0,0(%r1) */
220 #define STD_R0_0R12 0xf80c0000 /* std %r0,0(%r12) */
221 #define LD_R0_0R1 0xe8010000 /* ld %r0,0(%r1) */
222 #define LD_R0_0R12 0xe80c0000 /* ld %r0,0(%r12) */
223 #define STFD_FR0_0R1 0xd8010000 /* stfd %fr0,0(%r1) */
224 #define LFD_FR0_0R1 0xc8010000 /* lfd %fr0,0(%r1) */
225 #define LI_R12_0 0x39800000 /* li %r12,0 */
226 #define STVX_VR0_R12_R0 0x7c0c01ce /* stvx %v0,%r12,%r0 */
227 #define LVX_VR0_R12_R0 0x7c0c00ce /* lvx %v0,%r12,%r0 */
228 #define MTLR_R0 0x7c0803a6 /* mtlr %r0 */
229 #define BLR 0x4e800020 /* blr */
230
231 /* Since .opd is an array of descriptors and each entry will end up
232 with identical R_PPC64_RELATIVE relocs, there is really no need to
233 propagate .opd relocs; The dynamic linker should be taught to
234 relocate .opd without reloc entries. */
235 #ifndef NO_OPD_RELOCS
236 #define NO_OPD_RELOCS 0
237 #endif
238 \f
239 #define ONES(n) (((bfd_vma) 1 << ((n) - 1) << 1) - 1)
240
241 /* Relocation HOWTO's. */
242 static reloc_howto_type *ppc64_elf_howto_table[(int) R_PPC64_max];
243
244 static reloc_howto_type ppc64_elf_howto_raw[] = {
245 /* This reloc does nothing. */
246 HOWTO (R_PPC64_NONE, /* type */
247 0, /* rightshift */
248 2, /* size (0 = byte, 1 = short, 2 = long) */
249 32, /* bitsize */
250 FALSE, /* pc_relative */
251 0, /* bitpos */
252 complain_overflow_dont, /* complain_on_overflow */
253 bfd_elf_generic_reloc, /* special_function */
254 "R_PPC64_NONE", /* name */
255 FALSE, /* partial_inplace */
256 0, /* src_mask */
257 0, /* dst_mask */
258 FALSE), /* pcrel_offset */
259
260 /* A standard 32 bit relocation. */
261 HOWTO (R_PPC64_ADDR32, /* type */
262 0, /* rightshift */
263 2, /* size (0 = byte, 1 = short, 2 = long) */
264 32, /* bitsize */
265 FALSE, /* pc_relative */
266 0, /* bitpos */
267 complain_overflow_bitfield, /* complain_on_overflow */
268 bfd_elf_generic_reloc, /* special_function */
269 "R_PPC64_ADDR32", /* name */
270 FALSE, /* partial_inplace */
271 0, /* src_mask */
272 0xffffffff, /* dst_mask */
273 FALSE), /* pcrel_offset */
274
275 /* An absolute 26 bit branch; the lower two bits must be zero.
276 FIXME: we don't check that, we just clear them. */
277 HOWTO (R_PPC64_ADDR24, /* type */
278 0, /* rightshift */
279 2, /* size (0 = byte, 1 = short, 2 = long) */
280 26, /* bitsize */
281 FALSE, /* pc_relative */
282 0, /* bitpos */
283 complain_overflow_bitfield, /* complain_on_overflow */
284 bfd_elf_generic_reloc, /* special_function */
285 "R_PPC64_ADDR24", /* name */
286 FALSE, /* partial_inplace */
287 0, /* src_mask */
288 0x03fffffc, /* dst_mask */
289 FALSE), /* pcrel_offset */
290
291 /* A standard 16 bit relocation. */
292 HOWTO (R_PPC64_ADDR16, /* type */
293 0, /* rightshift */
294 1, /* size (0 = byte, 1 = short, 2 = long) */
295 16, /* bitsize */
296 FALSE, /* pc_relative */
297 0, /* bitpos */
298 complain_overflow_bitfield, /* complain_on_overflow */
299 bfd_elf_generic_reloc, /* special_function */
300 "R_PPC64_ADDR16", /* name */
301 FALSE, /* partial_inplace */
302 0, /* src_mask */
303 0xffff, /* dst_mask */
304 FALSE), /* pcrel_offset */
305
306 /* A 16 bit relocation without overflow. */
307 HOWTO (R_PPC64_ADDR16_LO, /* type */
308 0, /* rightshift */
309 1, /* size (0 = byte, 1 = short, 2 = long) */
310 16, /* bitsize */
311 FALSE, /* pc_relative */
312 0, /* bitpos */
313 complain_overflow_dont,/* complain_on_overflow */
314 bfd_elf_generic_reloc, /* special_function */
315 "R_PPC64_ADDR16_LO", /* name */
316 FALSE, /* partial_inplace */
317 0, /* src_mask */
318 0xffff, /* dst_mask */
319 FALSE), /* pcrel_offset */
320
321 /* Bits 16-31 of an address. */
322 HOWTO (R_PPC64_ADDR16_HI, /* type */
323 16, /* rightshift */
324 1, /* size (0 = byte, 1 = short, 2 = long) */
325 16, /* bitsize */
326 FALSE, /* pc_relative */
327 0, /* bitpos */
328 complain_overflow_signed, /* complain_on_overflow */
329 bfd_elf_generic_reloc, /* special_function */
330 "R_PPC64_ADDR16_HI", /* name */
331 FALSE, /* partial_inplace */
332 0, /* src_mask */
333 0xffff, /* dst_mask */
334 FALSE), /* pcrel_offset */
335
336 /* Bits 16-31 of an address, plus 1 if the contents of the low 16
337 bits, treated as a signed number, is negative. */
338 HOWTO (R_PPC64_ADDR16_HA, /* type */
339 16, /* rightshift */
340 1, /* size (0 = byte, 1 = short, 2 = long) */
341 16, /* bitsize */
342 FALSE, /* pc_relative */
343 0, /* bitpos */
344 complain_overflow_signed, /* complain_on_overflow */
345 ppc64_elf_ha_reloc, /* special_function */
346 "R_PPC64_ADDR16_HA", /* name */
347 FALSE, /* partial_inplace */
348 0, /* src_mask */
349 0xffff, /* dst_mask */
350 FALSE), /* pcrel_offset */
351
352 /* An absolute 16 bit branch; the lower two bits must be zero.
353 FIXME: we don't check that, we just clear them. */
354 HOWTO (R_PPC64_ADDR14, /* type */
355 0, /* rightshift */
356 2, /* size (0 = byte, 1 = short, 2 = long) */
357 16, /* bitsize */
358 FALSE, /* pc_relative */
359 0, /* bitpos */
360 complain_overflow_bitfield, /* complain_on_overflow */
361 ppc64_elf_branch_reloc, /* special_function */
362 "R_PPC64_ADDR14", /* name */
363 FALSE, /* partial_inplace */
364 0, /* src_mask */
365 0x0000fffc, /* dst_mask */
366 FALSE), /* pcrel_offset */
367
368 /* An absolute 16 bit branch, for which bit 10 should be set to
369 indicate that the branch is expected to be taken. The lower two
370 bits must be zero. */
371 HOWTO (R_PPC64_ADDR14_BRTAKEN, /* type */
372 0, /* rightshift */
373 2, /* size (0 = byte, 1 = short, 2 = long) */
374 16, /* bitsize */
375 FALSE, /* pc_relative */
376 0, /* bitpos */
377 complain_overflow_bitfield, /* complain_on_overflow */
378 ppc64_elf_brtaken_reloc, /* special_function */
379 "R_PPC64_ADDR14_BRTAKEN",/* name */
380 FALSE, /* partial_inplace */
381 0, /* src_mask */
382 0x0000fffc, /* dst_mask */
383 FALSE), /* pcrel_offset */
384
385 /* An absolute 16 bit branch, for which bit 10 should be set to
386 indicate that the branch is not expected to be taken. The lower
387 two bits must be zero. */
388 HOWTO (R_PPC64_ADDR14_BRNTAKEN, /* type */
389 0, /* rightshift */
390 2, /* size (0 = byte, 1 = short, 2 = long) */
391 16, /* bitsize */
392 FALSE, /* pc_relative */
393 0, /* bitpos */
394 complain_overflow_bitfield, /* complain_on_overflow */
395 ppc64_elf_brtaken_reloc, /* special_function */
396 "R_PPC64_ADDR14_BRNTAKEN",/* name */
397 FALSE, /* partial_inplace */
398 0, /* src_mask */
399 0x0000fffc, /* dst_mask */
400 FALSE), /* pcrel_offset */
401
402 /* A relative 26 bit branch; the lower two bits must be zero. */
403 HOWTO (R_PPC64_REL24, /* type */
404 0, /* rightshift */
405 2, /* size (0 = byte, 1 = short, 2 = long) */
406 26, /* bitsize */
407 TRUE, /* pc_relative */
408 0, /* bitpos */
409 complain_overflow_signed, /* complain_on_overflow */
410 ppc64_elf_branch_reloc, /* special_function */
411 "R_PPC64_REL24", /* name */
412 FALSE, /* partial_inplace */
413 0, /* src_mask */
414 0x03fffffc, /* dst_mask */
415 TRUE), /* pcrel_offset */
416
417 /* A relative 16 bit branch; the lower two bits must be zero. */
418 HOWTO (R_PPC64_REL14, /* type */
419 0, /* rightshift */
420 2, /* size (0 = byte, 1 = short, 2 = long) */
421 16, /* bitsize */
422 TRUE, /* pc_relative */
423 0, /* bitpos */
424 complain_overflow_signed, /* complain_on_overflow */
425 ppc64_elf_branch_reloc, /* special_function */
426 "R_PPC64_REL14", /* name */
427 FALSE, /* partial_inplace */
428 0, /* src_mask */
429 0x0000fffc, /* dst_mask */
430 TRUE), /* pcrel_offset */
431
432 /* A relative 16 bit branch. Bit 10 should be set to indicate that
433 the branch is expected to be taken. The lower two bits must be
434 zero. */
435 HOWTO (R_PPC64_REL14_BRTAKEN, /* type */
436 0, /* rightshift */
437 2, /* size (0 = byte, 1 = short, 2 = long) */
438 16, /* bitsize */
439 TRUE, /* pc_relative */
440 0, /* bitpos */
441 complain_overflow_signed, /* complain_on_overflow */
442 ppc64_elf_brtaken_reloc, /* special_function */
443 "R_PPC64_REL14_BRTAKEN", /* name */
444 FALSE, /* partial_inplace */
445 0, /* src_mask */
446 0x0000fffc, /* dst_mask */
447 TRUE), /* pcrel_offset */
448
449 /* A relative 16 bit branch. Bit 10 should be set to indicate that
450 the branch is not expected to be taken. The lower two bits must
451 be zero. */
452 HOWTO (R_PPC64_REL14_BRNTAKEN, /* type */
453 0, /* rightshift */
454 2, /* size (0 = byte, 1 = short, 2 = long) */
455 16, /* bitsize */
456 TRUE, /* pc_relative */
457 0, /* bitpos */
458 complain_overflow_signed, /* complain_on_overflow */
459 ppc64_elf_brtaken_reloc, /* special_function */
460 "R_PPC64_REL14_BRNTAKEN",/* name */
461 FALSE, /* partial_inplace */
462 0, /* src_mask */
463 0x0000fffc, /* dst_mask */
464 TRUE), /* pcrel_offset */
465
466 /* Like R_PPC64_ADDR16, but referring to the GOT table entry for the
467 symbol. */
468 HOWTO (R_PPC64_GOT16, /* type */
469 0, /* rightshift */
470 1, /* size (0 = byte, 1 = short, 2 = long) */
471 16, /* bitsize */
472 FALSE, /* pc_relative */
473 0, /* bitpos */
474 complain_overflow_signed, /* complain_on_overflow */
475 ppc64_elf_unhandled_reloc, /* special_function */
476 "R_PPC64_GOT16", /* name */
477 FALSE, /* partial_inplace */
478 0, /* src_mask */
479 0xffff, /* dst_mask */
480 FALSE), /* pcrel_offset */
481
482 /* Like R_PPC64_ADDR16_LO, but referring to the GOT table entry for
483 the symbol. */
484 HOWTO (R_PPC64_GOT16_LO, /* type */
485 0, /* rightshift */
486 1, /* size (0 = byte, 1 = short, 2 = long) */
487 16, /* bitsize */
488 FALSE, /* pc_relative */
489 0, /* bitpos */
490 complain_overflow_dont, /* complain_on_overflow */
491 ppc64_elf_unhandled_reloc, /* special_function */
492 "R_PPC64_GOT16_LO", /* name */
493 FALSE, /* partial_inplace */
494 0, /* src_mask */
495 0xffff, /* dst_mask */
496 FALSE), /* pcrel_offset */
497
498 /* Like R_PPC64_ADDR16_HI, but referring to the GOT table entry for
499 the symbol. */
500 HOWTO (R_PPC64_GOT16_HI, /* type */
501 16, /* rightshift */
502 1, /* size (0 = byte, 1 = short, 2 = long) */
503 16, /* bitsize */
504 FALSE, /* pc_relative */
505 0, /* bitpos */
506 complain_overflow_signed,/* complain_on_overflow */
507 ppc64_elf_unhandled_reloc, /* special_function */
508 "R_PPC64_GOT16_HI", /* name */
509 FALSE, /* partial_inplace */
510 0, /* src_mask */
511 0xffff, /* dst_mask */
512 FALSE), /* pcrel_offset */
513
514 /* Like R_PPC64_ADDR16_HA, but referring to the GOT table entry for
515 the symbol. */
516 HOWTO (R_PPC64_GOT16_HA, /* type */
517 16, /* rightshift */
518 1, /* size (0 = byte, 1 = short, 2 = long) */
519 16, /* bitsize */
520 FALSE, /* pc_relative */
521 0, /* bitpos */
522 complain_overflow_signed,/* complain_on_overflow */
523 ppc64_elf_unhandled_reloc, /* special_function */
524 "R_PPC64_GOT16_HA", /* name */
525 FALSE, /* partial_inplace */
526 0, /* src_mask */
527 0xffff, /* dst_mask */
528 FALSE), /* pcrel_offset */
529
530 /* This is used only by the dynamic linker. The symbol should exist
531 both in the object being run and in some shared library. The
532 dynamic linker copies the data addressed by the symbol from the
533 shared library into the object, because the object being
534 run has to have the data at some particular address. */
535 HOWTO (R_PPC64_COPY, /* type */
536 0, /* rightshift */
537 0, /* this one is variable size */
538 0, /* bitsize */
539 FALSE, /* pc_relative */
540 0, /* bitpos */
541 complain_overflow_dont, /* complain_on_overflow */
542 ppc64_elf_unhandled_reloc, /* special_function */
543 "R_PPC64_COPY", /* name */
544 FALSE, /* partial_inplace */
545 0, /* src_mask */
546 0, /* dst_mask */
547 FALSE), /* pcrel_offset */
548
549 /* Like R_PPC64_ADDR64, but used when setting global offset table
550 entries. */
551 HOWTO (R_PPC64_GLOB_DAT, /* type */
552 0, /* rightshift */
553 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
554 64, /* bitsize */
555 FALSE, /* pc_relative */
556 0, /* bitpos */
557 complain_overflow_dont, /* complain_on_overflow */
558 ppc64_elf_unhandled_reloc, /* special_function */
559 "R_PPC64_GLOB_DAT", /* name */
560 FALSE, /* partial_inplace */
561 0, /* src_mask */
562 ONES (64), /* dst_mask */
563 FALSE), /* pcrel_offset */
564
565 /* Created by the link editor. Marks a procedure linkage table
566 entry for a symbol. */
567 HOWTO (R_PPC64_JMP_SLOT, /* type */
568 0, /* rightshift */
569 0, /* size (0 = byte, 1 = short, 2 = long) */
570 0, /* bitsize */
571 FALSE, /* pc_relative */
572 0, /* bitpos */
573 complain_overflow_dont, /* complain_on_overflow */
574 ppc64_elf_unhandled_reloc, /* special_function */
575 "R_PPC64_JMP_SLOT", /* name */
576 FALSE, /* partial_inplace */
577 0, /* src_mask */
578 0, /* dst_mask */
579 FALSE), /* pcrel_offset */
580
581 /* Used only by the dynamic linker. When the object is run, this
582 doubleword64 is set to the load address of the object, plus the
583 addend. */
584 HOWTO (R_PPC64_RELATIVE, /* type */
585 0, /* rightshift */
586 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
587 64, /* bitsize */
588 FALSE, /* pc_relative */
589 0, /* bitpos */
590 complain_overflow_dont, /* complain_on_overflow */
591 bfd_elf_generic_reloc, /* special_function */
592 "R_PPC64_RELATIVE", /* name */
593 FALSE, /* partial_inplace */
594 0, /* src_mask */
595 ONES (64), /* dst_mask */
596 FALSE), /* pcrel_offset */
597
598 /* Like R_PPC64_ADDR32, but may be unaligned. */
599 HOWTO (R_PPC64_UADDR32, /* type */
600 0, /* rightshift */
601 2, /* size (0 = byte, 1 = short, 2 = long) */
602 32, /* bitsize */
603 FALSE, /* pc_relative */
604 0, /* bitpos */
605 complain_overflow_bitfield, /* complain_on_overflow */
606 bfd_elf_generic_reloc, /* special_function */
607 "R_PPC64_UADDR32", /* name */
608 FALSE, /* partial_inplace */
609 0, /* src_mask */
610 0xffffffff, /* dst_mask */
611 FALSE), /* pcrel_offset */
612
613 /* Like R_PPC64_ADDR16, but may be unaligned. */
614 HOWTO (R_PPC64_UADDR16, /* type */
615 0, /* rightshift */
616 1, /* size (0 = byte, 1 = short, 2 = long) */
617 16, /* bitsize */
618 FALSE, /* pc_relative */
619 0, /* bitpos */
620 complain_overflow_bitfield, /* complain_on_overflow */
621 bfd_elf_generic_reloc, /* special_function */
622 "R_PPC64_UADDR16", /* name */
623 FALSE, /* partial_inplace */
624 0, /* src_mask */
625 0xffff, /* dst_mask */
626 FALSE), /* pcrel_offset */
627
628 /* 32-bit PC relative. */
629 HOWTO (R_PPC64_REL32, /* type */
630 0, /* rightshift */
631 2, /* size (0 = byte, 1 = short, 2 = long) */
632 32, /* bitsize */
633 TRUE, /* pc_relative */
634 0, /* bitpos */
635 /* FIXME: Verify. Was complain_overflow_bitfield. */
636 complain_overflow_signed, /* complain_on_overflow */
637 bfd_elf_generic_reloc, /* special_function */
638 "R_PPC64_REL32", /* name */
639 FALSE, /* partial_inplace */
640 0, /* src_mask */
641 0xffffffff, /* dst_mask */
642 TRUE), /* pcrel_offset */
643
644 /* 32-bit relocation to the symbol's procedure linkage table. */
645 HOWTO (R_PPC64_PLT32, /* type */
646 0, /* rightshift */
647 2, /* size (0 = byte, 1 = short, 2 = long) */
648 32, /* bitsize */
649 FALSE, /* pc_relative */
650 0, /* bitpos */
651 complain_overflow_bitfield, /* complain_on_overflow */
652 ppc64_elf_unhandled_reloc, /* special_function */
653 "R_PPC64_PLT32", /* name */
654 FALSE, /* partial_inplace */
655 0, /* src_mask */
656 0xffffffff, /* dst_mask */
657 FALSE), /* pcrel_offset */
658
659 /* 32-bit PC relative relocation to the symbol's procedure linkage table.
660 FIXME: R_PPC64_PLTREL32 not supported. */
661 HOWTO (R_PPC64_PLTREL32, /* type */
662 0, /* rightshift */
663 2, /* size (0 = byte, 1 = short, 2 = long) */
664 32, /* bitsize */
665 TRUE, /* pc_relative */
666 0, /* bitpos */
667 complain_overflow_signed, /* complain_on_overflow */
668 bfd_elf_generic_reloc, /* special_function */
669 "R_PPC64_PLTREL32", /* name */
670 FALSE, /* partial_inplace */
671 0, /* src_mask */
672 0xffffffff, /* dst_mask */
673 TRUE), /* pcrel_offset */
674
675 /* Like R_PPC64_ADDR16_LO, but referring to the PLT table entry for
676 the symbol. */
677 HOWTO (R_PPC64_PLT16_LO, /* type */
678 0, /* rightshift */
679 1, /* size (0 = byte, 1 = short, 2 = long) */
680 16, /* bitsize */
681 FALSE, /* pc_relative */
682 0, /* bitpos */
683 complain_overflow_dont, /* complain_on_overflow */
684 ppc64_elf_unhandled_reloc, /* special_function */
685 "R_PPC64_PLT16_LO", /* name */
686 FALSE, /* partial_inplace */
687 0, /* src_mask */
688 0xffff, /* dst_mask */
689 FALSE), /* pcrel_offset */
690
691 /* Like R_PPC64_ADDR16_HI, but referring to the PLT table entry for
692 the symbol. */
693 HOWTO (R_PPC64_PLT16_HI, /* type */
694 16, /* rightshift */
695 1, /* size (0 = byte, 1 = short, 2 = long) */
696 16, /* bitsize */
697 FALSE, /* pc_relative */
698 0, /* bitpos */
699 complain_overflow_signed, /* complain_on_overflow */
700 ppc64_elf_unhandled_reloc, /* special_function */
701 "R_PPC64_PLT16_HI", /* name */
702 FALSE, /* partial_inplace */
703 0, /* src_mask */
704 0xffff, /* dst_mask */
705 FALSE), /* pcrel_offset */
706
707 /* Like R_PPC64_ADDR16_HA, but referring to the PLT table entry for
708 the symbol. */
709 HOWTO (R_PPC64_PLT16_HA, /* type */
710 16, /* rightshift */
711 1, /* size (0 = byte, 1 = short, 2 = long) */
712 16, /* bitsize */
713 FALSE, /* pc_relative */
714 0, /* bitpos */
715 complain_overflow_signed, /* complain_on_overflow */
716 ppc64_elf_unhandled_reloc, /* special_function */
717 "R_PPC64_PLT16_HA", /* name */
718 FALSE, /* partial_inplace */
719 0, /* src_mask */
720 0xffff, /* dst_mask */
721 FALSE), /* pcrel_offset */
722
723 /* 16-bit section relative relocation. */
724 HOWTO (R_PPC64_SECTOFF, /* type */
725 0, /* rightshift */
726 1, /* size (0 = byte, 1 = short, 2 = long) */
727 16, /* bitsize */
728 FALSE, /* pc_relative */
729 0, /* bitpos */
730 complain_overflow_bitfield, /* complain_on_overflow */
731 ppc64_elf_sectoff_reloc, /* special_function */
732 "R_PPC64_SECTOFF", /* name */
733 FALSE, /* partial_inplace */
734 0, /* src_mask */
735 0xffff, /* dst_mask */
736 FALSE), /* pcrel_offset */
737
738 /* Like R_PPC64_SECTOFF, but no overflow warning. */
739 HOWTO (R_PPC64_SECTOFF_LO, /* type */
740 0, /* rightshift */
741 1, /* size (0 = byte, 1 = short, 2 = long) */
742 16, /* bitsize */
743 FALSE, /* pc_relative */
744 0, /* bitpos */
745 complain_overflow_dont, /* complain_on_overflow */
746 ppc64_elf_sectoff_reloc, /* special_function */
747 "R_PPC64_SECTOFF_LO", /* name */
748 FALSE, /* partial_inplace */
749 0, /* src_mask */
750 0xffff, /* dst_mask */
751 FALSE), /* pcrel_offset */
752
753 /* 16-bit upper half section relative relocation. */
754 HOWTO (R_PPC64_SECTOFF_HI, /* type */
755 16, /* rightshift */
756 1, /* size (0 = byte, 1 = short, 2 = long) */
757 16, /* bitsize */
758 FALSE, /* pc_relative */
759 0, /* bitpos */
760 complain_overflow_signed, /* complain_on_overflow */
761 ppc64_elf_sectoff_reloc, /* special_function */
762 "R_PPC64_SECTOFF_HI", /* name */
763 FALSE, /* partial_inplace */
764 0, /* src_mask */
765 0xffff, /* dst_mask */
766 FALSE), /* pcrel_offset */
767
768 /* 16-bit upper half adjusted section relative relocation. */
769 HOWTO (R_PPC64_SECTOFF_HA, /* type */
770 16, /* rightshift */
771 1, /* size (0 = byte, 1 = short, 2 = long) */
772 16, /* bitsize */
773 FALSE, /* pc_relative */
774 0, /* bitpos */
775 complain_overflow_signed, /* complain_on_overflow */
776 ppc64_elf_sectoff_ha_reloc, /* special_function */
777 "R_PPC64_SECTOFF_HA", /* name */
778 FALSE, /* partial_inplace */
779 0, /* src_mask */
780 0xffff, /* dst_mask */
781 FALSE), /* pcrel_offset */
782
783 /* Like R_PPC64_REL24 without touching the two least significant bits. */
784 HOWTO (R_PPC64_REL30, /* type */
785 2, /* rightshift */
786 2, /* size (0 = byte, 1 = short, 2 = long) */
787 30, /* bitsize */
788 TRUE, /* pc_relative */
789 0, /* bitpos */
790 complain_overflow_dont, /* complain_on_overflow */
791 bfd_elf_generic_reloc, /* special_function */
792 "R_PPC64_REL30", /* name */
793 FALSE, /* partial_inplace */
794 0, /* src_mask */
795 0xfffffffc, /* dst_mask */
796 TRUE), /* pcrel_offset */
797
798 /* Relocs in the 64-bit PowerPC ELF ABI, not in the 32-bit ABI. */
799
800 /* A standard 64-bit relocation. */
801 HOWTO (R_PPC64_ADDR64, /* type */
802 0, /* rightshift */
803 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
804 64, /* bitsize */
805 FALSE, /* pc_relative */
806 0, /* bitpos */
807 complain_overflow_dont, /* complain_on_overflow */
808 bfd_elf_generic_reloc, /* special_function */
809 "R_PPC64_ADDR64", /* name */
810 FALSE, /* partial_inplace */
811 0, /* src_mask */
812 ONES (64), /* dst_mask */
813 FALSE), /* pcrel_offset */
814
815 /* The bits 32-47 of an address. */
816 HOWTO (R_PPC64_ADDR16_HIGHER, /* type */
817 32, /* rightshift */
818 1, /* size (0 = byte, 1 = short, 2 = long) */
819 16, /* bitsize */
820 FALSE, /* pc_relative */
821 0, /* bitpos */
822 complain_overflow_dont, /* complain_on_overflow */
823 bfd_elf_generic_reloc, /* special_function */
824 "R_PPC64_ADDR16_HIGHER", /* name */
825 FALSE, /* partial_inplace */
826 0, /* src_mask */
827 0xffff, /* dst_mask */
828 FALSE), /* pcrel_offset */
829
830 /* The bits 32-47 of an address, plus 1 if the contents of the low
831 16 bits, treated as a signed number, is negative. */
832 HOWTO (R_PPC64_ADDR16_HIGHERA, /* type */
833 32, /* rightshift */
834 1, /* size (0 = byte, 1 = short, 2 = long) */
835 16, /* bitsize */
836 FALSE, /* pc_relative */
837 0, /* bitpos */
838 complain_overflow_dont, /* complain_on_overflow */
839 ppc64_elf_ha_reloc, /* special_function */
840 "R_PPC64_ADDR16_HIGHERA", /* name */
841 FALSE, /* partial_inplace */
842 0, /* src_mask */
843 0xffff, /* dst_mask */
844 FALSE), /* pcrel_offset */
845
846 /* The bits 48-63 of an address. */
847 HOWTO (R_PPC64_ADDR16_HIGHEST,/* type */
848 48, /* rightshift */
849 1, /* size (0 = byte, 1 = short, 2 = long) */
850 16, /* bitsize */
851 FALSE, /* pc_relative */
852 0, /* bitpos */
853 complain_overflow_dont, /* complain_on_overflow */
854 bfd_elf_generic_reloc, /* special_function */
855 "R_PPC64_ADDR16_HIGHEST", /* name */
856 FALSE, /* partial_inplace */
857 0, /* src_mask */
858 0xffff, /* dst_mask */
859 FALSE), /* pcrel_offset */
860
861 /* The bits 48-63 of an address, plus 1 if the contents of the low
862 16 bits, treated as a signed number, is negative. */
863 HOWTO (R_PPC64_ADDR16_HIGHESTA,/* type */
864 48, /* rightshift */
865 1, /* size (0 = byte, 1 = short, 2 = long) */
866 16, /* bitsize */
867 FALSE, /* pc_relative */
868 0, /* bitpos */
869 complain_overflow_dont, /* complain_on_overflow */
870 ppc64_elf_ha_reloc, /* special_function */
871 "R_PPC64_ADDR16_HIGHESTA", /* name */
872 FALSE, /* partial_inplace */
873 0, /* src_mask */
874 0xffff, /* dst_mask */
875 FALSE), /* pcrel_offset */
876
877 /* Like ADDR64, but may be unaligned. */
878 HOWTO (R_PPC64_UADDR64, /* type */
879 0, /* rightshift */
880 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
881 64, /* bitsize */
882 FALSE, /* pc_relative */
883 0, /* bitpos */
884 complain_overflow_dont, /* complain_on_overflow */
885 bfd_elf_generic_reloc, /* special_function */
886 "R_PPC64_UADDR64", /* name */
887 FALSE, /* partial_inplace */
888 0, /* src_mask */
889 ONES (64), /* dst_mask */
890 FALSE), /* pcrel_offset */
891
892 /* 64-bit relative relocation. */
893 HOWTO (R_PPC64_REL64, /* type */
894 0, /* rightshift */
895 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
896 64, /* bitsize */
897 TRUE, /* pc_relative */
898 0, /* bitpos */
899 complain_overflow_dont, /* complain_on_overflow */
900 bfd_elf_generic_reloc, /* special_function */
901 "R_PPC64_REL64", /* name */
902 FALSE, /* partial_inplace */
903 0, /* src_mask */
904 ONES (64), /* dst_mask */
905 TRUE), /* pcrel_offset */
906
907 /* 64-bit relocation to the symbol's procedure linkage table. */
908 HOWTO (R_PPC64_PLT64, /* type */
909 0, /* rightshift */
910 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
911 64, /* bitsize */
912 FALSE, /* pc_relative */
913 0, /* bitpos */
914 complain_overflow_dont, /* complain_on_overflow */
915 ppc64_elf_unhandled_reloc, /* special_function */
916 "R_PPC64_PLT64", /* name */
917 FALSE, /* partial_inplace */
918 0, /* src_mask */
919 ONES (64), /* dst_mask */
920 FALSE), /* pcrel_offset */
921
922 /* 64-bit PC relative relocation to the symbol's procedure linkage
923 table. */
924 /* FIXME: R_PPC64_PLTREL64 not supported. */
925 HOWTO (R_PPC64_PLTREL64, /* type */
926 0, /* rightshift */
927 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
928 64, /* bitsize */
929 TRUE, /* pc_relative */
930 0, /* bitpos */
931 complain_overflow_dont, /* complain_on_overflow */
932 ppc64_elf_unhandled_reloc, /* special_function */
933 "R_PPC64_PLTREL64", /* name */
934 FALSE, /* partial_inplace */
935 0, /* src_mask */
936 ONES (64), /* dst_mask */
937 TRUE), /* pcrel_offset */
938
939 /* 16 bit TOC-relative relocation. */
940
941 /* R_PPC64_TOC16 47 half16* S + A - .TOC. */
942 HOWTO (R_PPC64_TOC16, /* type */
943 0, /* rightshift */
944 1, /* size (0 = byte, 1 = short, 2 = long) */
945 16, /* bitsize */
946 FALSE, /* pc_relative */
947 0, /* bitpos */
948 complain_overflow_signed, /* complain_on_overflow */
949 ppc64_elf_toc_reloc, /* special_function */
950 "R_PPC64_TOC16", /* name */
951 FALSE, /* partial_inplace */
952 0, /* src_mask */
953 0xffff, /* dst_mask */
954 FALSE), /* pcrel_offset */
955
956 /* 16 bit TOC-relative relocation without overflow. */
957
958 /* R_PPC64_TOC16_LO 48 half16 #lo (S + A - .TOC.) */
959 HOWTO (R_PPC64_TOC16_LO, /* type */
960 0, /* rightshift */
961 1, /* size (0 = byte, 1 = short, 2 = long) */
962 16, /* bitsize */
963 FALSE, /* pc_relative */
964 0, /* bitpos */
965 complain_overflow_dont, /* complain_on_overflow */
966 ppc64_elf_toc_reloc, /* special_function */
967 "R_PPC64_TOC16_LO", /* name */
968 FALSE, /* partial_inplace */
969 0, /* src_mask */
970 0xffff, /* dst_mask */
971 FALSE), /* pcrel_offset */
972
973 /* 16 bit TOC-relative relocation, high 16 bits. */
974
975 /* R_PPC64_TOC16_HI 49 half16 #hi (S + A - .TOC.) */
976 HOWTO (R_PPC64_TOC16_HI, /* type */
977 16, /* rightshift */
978 1, /* size (0 = byte, 1 = short, 2 = long) */
979 16, /* bitsize */
980 FALSE, /* pc_relative */
981 0, /* bitpos */
982 complain_overflow_signed, /* complain_on_overflow */
983 ppc64_elf_toc_reloc, /* special_function */
984 "R_PPC64_TOC16_HI", /* name */
985 FALSE, /* partial_inplace */
986 0, /* src_mask */
987 0xffff, /* dst_mask */
988 FALSE), /* pcrel_offset */
989
990 /* 16 bit TOC-relative relocation, high 16 bits, plus 1 if the
991 contents of the low 16 bits, treated as a signed number, is
992 negative. */
993
994 /* R_PPC64_TOC16_HA 50 half16 #ha (S + A - .TOC.) */
995 HOWTO (R_PPC64_TOC16_HA, /* type */
996 16, /* rightshift */
997 1, /* size (0 = byte, 1 = short, 2 = long) */
998 16, /* bitsize */
999 FALSE, /* pc_relative */
1000 0, /* bitpos */
1001 complain_overflow_signed, /* complain_on_overflow */
1002 ppc64_elf_toc_ha_reloc, /* special_function */
1003 "R_PPC64_TOC16_HA", /* name */
1004 FALSE, /* partial_inplace */
1005 0, /* src_mask */
1006 0xffff, /* dst_mask */
1007 FALSE), /* pcrel_offset */
1008
1009 /* 64-bit relocation; insert value of TOC base (.TOC.). */
1010
1011 /* R_PPC64_TOC 51 doubleword64 .TOC. */
1012 HOWTO (R_PPC64_TOC, /* type */
1013 0, /* rightshift */
1014 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1015 64, /* bitsize */
1016 FALSE, /* pc_relative */
1017 0, /* bitpos */
1018 complain_overflow_bitfield, /* complain_on_overflow */
1019 ppc64_elf_toc64_reloc, /* special_function */
1020 "R_PPC64_TOC", /* name */
1021 FALSE, /* partial_inplace */
1022 0, /* src_mask */
1023 ONES (64), /* dst_mask */
1024 FALSE), /* pcrel_offset */
1025
1026 /* Like R_PPC64_GOT16, but also informs the link editor that the
1027 value to relocate may (!) refer to a PLT entry which the link
1028 editor (a) may replace with the symbol value. If the link editor
1029 is unable to fully resolve the symbol, it may (b) create a PLT
1030 entry and store the address to the new PLT entry in the GOT.
1031 This permits lazy resolution of function symbols at run time.
1032 The link editor may also skip all of this and just (c) emit a
1033 R_PPC64_GLOB_DAT to tie the symbol to the GOT entry. */
1034 /* FIXME: R_PPC64_PLTGOT16 not implemented. */
1035 HOWTO (R_PPC64_PLTGOT16, /* type */
1036 0, /* rightshift */
1037 1, /* size (0 = byte, 1 = short, 2 = long) */
1038 16, /* bitsize */
1039 FALSE, /* pc_relative */
1040 0, /* bitpos */
1041 complain_overflow_signed, /* complain_on_overflow */
1042 ppc64_elf_unhandled_reloc, /* special_function */
1043 "R_PPC64_PLTGOT16", /* name */
1044 FALSE, /* partial_inplace */
1045 0, /* src_mask */
1046 0xffff, /* dst_mask */
1047 FALSE), /* pcrel_offset */
1048
1049 /* Like R_PPC64_PLTGOT16, but without overflow. */
1050 /* FIXME: R_PPC64_PLTGOT16_LO not implemented. */
1051 HOWTO (R_PPC64_PLTGOT16_LO, /* type */
1052 0, /* rightshift */
1053 1, /* size (0 = byte, 1 = short, 2 = long) */
1054 16, /* bitsize */
1055 FALSE, /* pc_relative */
1056 0, /* bitpos */
1057 complain_overflow_dont, /* complain_on_overflow */
1058 ppc64_elf_unhandled_reloc, /* special_function */
1059 "R_PPC64_PLTGOT16_LO", /* name */
1060 FALSE, /* partial_inplace */
1061 0, /* src_mask */
1062 0xffff, /* dst_mask */
1063 FALSE), /* pcrel_offset */
1064
1065 /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address. */
1066 /* FIXME: R_PPC64_PLTGOT16_HI not implemented. */
1067 HOWTO (R_PPC64_PLTGOT16_HI, /* type */
1068 16, /* rightshift */
1069 1, /* size (0 = byte, 1 = short, 2 = long) */
1070 16, /* bitsize */
1071 FALSE, /* pc_relative */
1072 0, /* bitpos */
1073 complain_overflow_signed, /* complain_on_overflow */
1074 ppc64_elf_unhandled_reloc, /* special_function */
1075 "R_PPC64_PLTGOT16_HI", /* name */
1076 FALSE, /* partial_inplace */
1077 0, /* src_mask */
1078 0xffff, /* dst_mask */
1079 FALSE), /* pcrel_offset */
1080
1081 /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address, plus
1082 1 if the contents of the low 16 bits, treated as a signed number,
1083 is negative. */
1084 /* FIXME: R_PPC64_PLTGOT16_HA not implemented. */
1085 HOWTO (R_PPC64_PLTGOT16_HA, /* type */
1086 16, /* rightshift */
1087 1, /* size (0 = byte, 1 = short, 2 = long) */
1088 16, /* bitsize */
1089 FALSE, /* pc_relative */
1090 0, /* bitpos */
1091 complain_overflow_signed, /* complain_on_overflow */
1092 ppc64_elf_unhandled_reloc, /* special_function */
1093 "R_PPC64_PLTGOT16_HA", /* name */
1094 FALSE, /* partial_inplace */
1095 0, /* src_mask */
1096 0xffff, /* dst_mask */
1097 FALSE), /* pcrel_offset */
1098
1099 /* Like R_PPC64_ADDR16, but for instructions with a DS field. */
1100 HOWTO (R_PPC64_ADDR16_DS, /* type */
1101 0, /* rightshift */
1102 1, /* size (0 = byte, 1 = short, 2 = long) */
1103 16, /* bitsize */
1104 FALSE, /* pc_relative */
1105 0, /* bitpos */
1106 complain_overflow_bitfield, /* complain_on_overflow */
1107 bfd_elf_generic_reloc, /* special_function */
1108 "R_PPC64_ADDR16_DS", /* name */
1109 FALSE, /* partial_inplace */
1110 0, /* src_mask */
1111 0xfffc, /* dst_mask */
1112 FALSE), /* pcrel_offset */
1113
1114 /* Like R_PPC64_ADDR16_LO, but for instructions with a DS field. */
1115 HOWTO (R_PPC64_ADDR16_LO_DS, /* type */
1116 0, /* rightshift */
1117 1, /* size (0 = byte, 1 = short, 2 = long) */
1118 16, /* bitsize */
1119 FALSE, /* pc_relative */
1120 0, /* bitpos */
1121 complain_overflow_dont,/* complain_on_overflow */
1122 bfd_elf_generic_reloc, /* special_function */
1123 "R_PPC64_ADDR16_LO_DS",/* name */
1124 FALSE, /* partial_inplace */
1125 0, /* src_mask */
1126 0xfffc, /* dst_mask */
1127 FALSE), /* pcrel_offset */
1128
1129 /* Like R_PPC64_GOT16, but for instructions with a DS field. */
1130 HOWTO (R_PPC64_GOT16_DS, /* type */
1131 0, /* rightshift */
1132 1, /* size (0 = byte, 1 = short, 2 = long) */
1133 16, /* bitsize */
1134 FALSE, /* pc_relative */
1135 0, /* bitpos */
1136 complain_overflow_signed, /* complain_on_overflow */
1137 ppc64_elf_unhandled_reloc, /* special_function */
1138 "R_PPC64_GOT16_DS", /* name */
1139 FALSE, /* partial_inplace */
1140 0, /* src_mask */
1141 0xfffc, /* dst_mask */
1142 FALSE), /* pcrel_offset */
1143
1144 /* Like R_PPC64_GOT16_LO, but for instructions with a DS field. */
1145 HOWTO (R_PPC64_GOT16_LO_DS, /* type */
1146 0, /* rightshift */
1147 1, /* size (0 = byte, 1 = short, 2 = long) */
1148 16, /* bitsize */
1149 FALSE, /* pc_relative */
1150 0, /* bitpos */
1151 complain_overflow_dont, /* complain_on_overflow */
1152 ppc64_elf_unhandled_reloc, /* special_function */
1153 "R_PPC64_GOT16_LO_DS", /* name */
1154 FALSE, /* partial_inplace */
1155 0, /* src_mask */
1156 0xfffc, /* dst_mask */
1157 FALSE), /* pcrel_offset */
1158
1159 /* Like R_PPC64_PLT16_LO, but for instructions with a DS field. */
1160 HOWTO (R_PPC64_PLT16_LO_DS, /* type */
1161 0, /* rightshift */
1162 1, /* size (0 = byte, 1 = short, 2 = long) */
1163 16, /* bitsize */
1164 FALSE, /* pc_relative */
1165 0, /* bitpos */
1166 complain_overflow_dont, /* complain_on_overflow */
1167 ppc64_elf_unhandled_reloc, /* special_function */
1168 "R_PPC64_PLT16_LO_DS", /* name */
1169 FALSE, /* partial_inplace */
1170 0, /* src_mask */
1171 0xfffc, /* dst_mask */
1172 FALSE), /* pcrel_offset */
1173
1174 /* Like R_PPC64_SECTOFF, but for instructions with a DS field. */
1175 HOWTO (R_PPC64_SECTOFF_DS, /* type */
1176 0, /* rightshift */
1177 1, /* size (0 = byte, 1 = short, 2 = long) */
1178 16, /* bitsize */
1179 FALSE, /* pc_relative */
1180 0, /* bitpos */
1181 complain_overflow_bitfield, /* complain_on_overflow */
1182 ppc64_elf_sectoff_reloc, /* special_function */
1183 "R_PPC64_SECTOFF_DS", /* name */
1184 FALSE, /* partial_inplace */
1185 0, /* src_mask */
1186 0xfffc, /* dst_mask */
1187 FALSE), /* pcrel_offset */
1188
1189 /* Like R_PPC64_SECTOFF_LO, but for instructions with a DS field. */
1190 HOWTO (R_PPC64_SECTOFF_LO_DS, /* type */
1191 0, /* rightshift */
1192 1, /* size (0 = byte, 1 = short, 2 = long) */
1193 16, /* bitsize */
1194 FALSE, /* pc_relative */
1195 0, /* bitpos */
1196 complain_overflow_dont, /* complain_on_overflow */
1197 ppc64_elf_sectoff_reloc, /* special_function */
1198 "R_PPC64_SECTOFF_LO_DS",/* name */
1199 FALSE, /* partial_inplace */
1200 0, /* src_mask */
1201 0xfffc, /* dst_mask */
1202 FALSE), /* pcrel_offset */
1203
1204 /* Like R_PPC64_TOC16, but for instructions with a DS field. */
1205 HOWTO (R_PPC64_TOC16_DS, /* type */
1206 0, /* rightshift */
1207 1, /* size (0 = byte, 1 = short, 2 = long) */
1208 16, /* bitsize */
1209 FALSE, /* pc_relative */
1210 0, /* bitpos */
1211 complain_overflow_signed, /* complain_on_overflow */
1212 ppc64_elf_toc_reloc, /* special_function */
1213 "R_PPC64_TOC16_DS", /* name */
1214 FALSE, /* partial_inplace */
1215 0, /* src_mask */
1216 0xfffc, /* dst_mask */
1217 FALSE), /* pcrel_offset */
1218
1219 /* Like R_PPC64_TOC16_LO, but for instructions with a DS field. */
1220 HOWTO (R_PPC64_TOC16_LO_DS, /* type */
1221 0, /* rightshift */
1222 1, /* size (0 = byte, 1 = short, 2 = long) */
1223 16, /* bitsize */
1224 FALSE, /* pc_relative */
1225 0, /* bitpos */
1226 complain_overflow_dont, /* complain_on_overflow */
1227 ppc64_elf_toc_reloc, /* special_function */
1228 "R_PPC64_TOC16_LO_DS", /* name */
1229 FALSE, /* partial_inplace */
1230 0, /* src_mask */
1231 0xfffc, /* dst_mask */
1232 FALSE), /* pcrel_offset */
1233
1234 /* Like R_PPC64_PLTGOT16, but for instructions with a DS field. */
1235 /* FIXME: R_PPC64_PLTGOT16_DS not implemented. */
1236 HOWTO (R_PPC64_PLTGOT16_DS, /* type */
1237 0, /* rightshift */
1238 1, /* size (0 = byte, 1 = short, 2 = long) */
1239 16, /* bitsize */
1240 FALSE, /* pc_relative */
1241 0, /* bitpos */
1242 complain_overflow_signed, /* complain_on_overflow */
1243 ppc64_elf_unhandled_reloc, /* special_function */
1244 "R_PPC64_PLTGOT16_DS", /* name */
1245 FALSE, /* partial_inplace */
1246 0, /* src_mask */
1247 0xfffc, /* dst_mask */
1248 FALSE), /* pcrel_offset */
1249
1250 /* Like R_PPC64_PLTGOT16_LO, but for instructions with a DS field. */
1251 /* FIXME: R_PPC64_PLTGOT16_LO not implemented. */
1252 HOWTO (R_PPC64_PLTGOT16_LO_DS,/* type */
1253 0, /* rightshift */
1254 1, /* size (0 = byte, 1 = short, 2 = long) */
1255 16, /* bitsize */
1256 FALSE, /* pc_relative */
1257 0, /* bitpos */
1258 complain_overflow_dont, /* complain_on_overflow */
1259 ppc64_elf_unhandled_reloc, /* special_function */
1260 "R_PPC64_PLTGOT16_LO_DS",/* name */
1261 FALSE, /* partial_inplace */
1262 0, /* src_mask */
1263 0xfffc, /* dst_mask */
1264 FALSE), /* pcrel_offset */
1265
1266 /* Marker relocs for TLS. */
1267 HOWTO (R_PPC64_TLS,
1268 0, /* rightshift */
1269 2, /* size (0 = byte, 1 = short, 2 = long) */
1270 32, /* bitsize */
1271 FALSE, /* pc_relative */
1272 0, /* bitpos */
1273 complain_overflow_dont, /* complain_on_overflow */
1274 bfd_elf_generic_reloc, /* special_function */
1275 "R_PPC64_TLS", /* name */
1276 FALSE, /* partial_inplace */
1277 0, /* src_mask */
1278 0, /* dst_mask */
1279 FALSE), /* pcrel_offset */
1280
1281 HOWTO (R_PPC64_TLSGD,
1282 0, /* rightshift */
1283 2, /* size (0 = byte, 1 = short, 2 = long) */
1284 32, /* bitsize */
1285 FALSE, /* pc_relative */
1286 0, /* bitpos */
1287 complain_overflow_dont, /* complain_on_overflow */
1288 bfd_elf_generic_reloc, /* special_function */
1289 "R_PPC64_TLSGD", /* name */
1290 FALSE, /* partial_inplace */
1291 0, /* src_mask */
1292 0, /* dst_mask */
1293 FALSE), /* pcrel_offset */
1294
1295 HOWTO (R_PPC64_TLSLD,
1296 0, /* rightshift */
1297 2, /* size (0 = byte, 1 = short, 2 = long) */
1298 32, /* bitsize */
1299 FALSE, /* pc_relative */
1300 0, /* bitpos */
1301 complain_overflow_dont, /* complain_on_overflow */
1302 bfd_elf_generic_reloc, /* special_function */
1303 "R_PPC64_TLSLD", /* name */
1304 FALSE, /* partial_inplace */
1305 0, /* src_mask */
1306 0, /* dst_mask */
1307 FALSE), /* pcrel_offset */
1308
1309 HOWTO (R_PPC64_TOCSAVE,
1310 0, /* rightshift */
1311 2, /* size (0 = byte, 1 = short, 2 = long) */
1312 32, /* bitsize */
1313 FALSE, /* pc_relative */
1314 0, /* bitpos */
1315 complain_overflow_dont, /* complain_on_overflow */
1316 bfd_elf_generic_reloc, /* special_function */
1317 "R_PPC64_TOCSAVE", /* name */
1318 FALSE, /* partial_inplace */
1319 0, /* src_mask */
1320 0, /* dst_mask */
1321 FALSE), /* pcrel_offset */
1322
1323 /* Computes the load module index of the load module that contains the
1324 definition of its TLS sym. */
1325 HOWTO (R_PPC64_DTPMOD64,
1326 0, /* rightshift */
1327 4, /* size (0 = byte, 1 = short, 2 = long) */
1328 64, /* bitsize */
1329 FALSE, /* pc_relative */
1330 0, /* bitpos */
1331 complain_overflow_dont, /* complain_on_overflow */
1332 ppc64_elf_unhandled_reloc, /* special_function */
1333 "R_PPC64_DTPMOD64", /* name */
1334 FALSE, /* partial_inplace */
1335 0, /* src_mask */
1336 ONES (64), /* dst_mask */
1337 FALSE), /* pcrel_offset */
1338
1339 /* Computes a dtv-relative displacement, the difference between the value
1340 of sym+add and the base address of the thread-local storage block that
1341 contains the definition of sym, minus 0x8000. */
1342 HOWTO (R_PPC64_DTPREL64,
1343 0, /* rightshift */
1344 4, /* size (0 = byte, 1 = short, 2 = long) */
1345 64, /* bitsize */
1346 FALSE, /* pc_relative */
1347 0, /* bitpos */
1348 complain_overflow_dont, /* complain_on_overflow */
1349 ppc64_elf_unhandled_reloc, /* special_function */
1350 "R_PPC64_DTPREL64", /* name */
1351 FALSE, /* partial_inplace */
1352 0, /* src_mask */
1353 ONES (64), /* dst_mask */
1354 FALSE), /* pcrel_offset */
1355
1356 /* A 16 bit dtprel reloc. */
1357 HOWTO (R_PPC64_DTPREL16,
1358 0, /* rightshift */
1359 1, /* size (0 = byte, 1 = short, 2 = long) */
1360 16, /* bitsize */
1361 FALSE, /* pc_relative */
1362 0, /* bitpos */
1363 complain_overflow_signed, /* complain_on_overflow */
1364 ppc64_elf_unhandled_reloc, /* special_function */
1365 "R_PPC64_DTPREL16", /* name */
1366 FALSE, /* partial_inplace */
1367 0, /* src_mask */
1368 0xffff, /* dst_mask */
1369 FALSE), /* pcrel_offset */
1370
1371 /* Like DTPREL16, but no overflow. */
1372 HOWTO (R_PPC64_DTPREL16_LO,
1373 0, /* rightshift */
1374 1, /* size (0 = byte, 1 = short, 2 = long) */
1375 16, /* bitsize */
1376 FALSE, /* pc_relative */
1377 0, /* bitpos */
1378 complain_overflow_dont, /* complain_on_overflow */
1379 ppc64_elf_unhandled_reloc, /* special_function */
1380 "R_PPC64_DTPREL16_LO", /* name */
1381 FALSE, /* partial_inplace */
1382 0, /* src_mask */
1383 0xffff, /* dst_mask */
1384 FALSE), /* pcrel_offset */
1385
1386 /* Like DTPREL16_LO, but next higher group of 16 bits. */
1387 HOWTO (R_PPC64_DTPREL16_HI,
1388 16, /* rightshift */
1389 1, /* size (0 = byte, 1 = short, 2 = long) */
1390 16, /* bitsize */
1391 FALSE, /* pc_relative */
1392 0, /* bitpos */
1393 complain_overflow_signed, /* complain_on_overflow */
1394 ppc64_elf_unhandled_reloc, /* special_function */
1395 "R_PPC64_DTPREL16_HI", /* name */
1396 FALSE, /* partial_inplace */
1397 0, /* src_mask */
1398 0xffff, /* dst_mask */
1399 FALSE), /* pcrel_offset */
1400
1401 /* Like DTPREL16_HI, but adjust for low 16 bits. */
1402 HOWTO (R_PPC64_DTPREL16_HA,
1403 16, /* rightshift */
1404 1, /* size (0 = byte, 1 = short, 2 = long) */
1405 16, /* bitsize */
1406 FALSE, /* pc_relative */
1407 0, /* bitpos */
1408 complain_overflow_signed, /* complain_on_overflow */
1409 ppc64_elf_unhandled_reloc, /* special_function */
1410 "R_PPC64_DTPREL16_HA", /* name */
1411 FALSE, /* partial_inplace */
1412 0, /* src_mask */
1413 0xffff, /* dst_mask */
1414 FALSE), /* pcrel_offset */
1415
1416 /* Like DTPREL16_HI, but next higher group of 16 bits. */
1417 HOWTO (R_PPC64_DTPREL16_HIGHER,
1418 32, /* rightshift */
1419 1, /* size (0 = byte, 1 = short, 2 = long) */
1420 16, /* bitsize */
1421 FALSE, /* pc_relative */
1422 0, /* bitpos */
1423 complain_overflow_dont, /* complain_on_overflow */
1424 ppc64_elf_unhandled_reloc, /* special_function */
1425 "R_PPC64_DTPREL16_HIGHER", /* name */
1426 FALSE, /* partial_inplace */
1427 0, /* src_mask */
1428 0xffff, /* dst_mask */
1429 FALSE), /* pcrel_offset */
1430
1431 /* Like DTPREL16_HIGHER, but adjust for low 16 bits. */
1432 HOWTO (R_PPC64_DTPREL16_HIGHERA,
1433 32, /* rightshift */
1434 1, /* size (0 = byte, 1 = short, 2 = long) */
1435 16, /* bitsize */
1436 FALSE, /* pc_relative */
1437 0, /* bitpos */
1438 complain_overflow_dont, /* complain_on_overflow */
1439 ppc64_elf_unhandled_reloc, /* special_function */
1440 "R_PPC64_DTPREL16_HIGHERA", /* name */
1441 FALSE, /* partial_inplace */
1442 0, /* src_mask */
1443 0xffff, /* dst_mask */
1444 FALSE), /* pcrel_offset */
1445
1446 /* Like DTPREL16_HIGHER, but next higher group of 16 bits. */
1447 HOWTO (R_PPC64_DTPREL16_HIGHEST,
1448 48, /* rightshift */
1449 1, /* size (0 = byte, 1 = short, 2 = long) */
1450 16, /* bitsize */
1451 FALSE, /* pc_relative */
1452 0, /* bitpos */
1453 complain_overflow_dont, /* complain_on_overflow */
1454 ppc64_elf_unhandled_reloc, /* special_function */
1455 "R_PPC64_DTPREL16_HIGHEST", /* name */
1456 FALSE, /* partial_inplace */
1457 0, /* src_mask */
1458 0xffff, /* dst_mask */
1459 FALSE), /* pcrel_offset */
1460
1461 /* Like DTPREL16_HIGHEST, but adjust for low 16 bits. */
1462 HOWTO (R_PPC64_DTPREL16_HIGHESTA,
1463 48, /* rightshift */
1464 1, /* size (0 = byte, 1 = short, 2 = long) */
1465 16, /* bitsize */
1466 FALSE, /* pc_relative */
1467 0, /* bitpos */
1468 complain_overflow_dont, /* complain_on_overflow */
1469 ppc64_elf_unhandled_reloc, /* special_function */
1470 "R_PPC64_DTPREL16_HIGHESTA", /* name */
1471 FALSE, /* partial_inplace */
1472 0, /* src_mask */
1473 0xffff, /* dst_mask */
1474 FALSE), /* pcrel_offset */
1475
1476 /* Like DTPREL16, but for insns with a DS field. */
1477 HOWTO (R_PPC64_DTPREL16_DS,
1478 0, /* rightshift */
1479 1, /* size (0 = byte, 1 = short, 2 = long) */
1480 16, /* bitsize */
1481 FALSE, /* pc_relative */
1482 0, /* bitpos */
1483 complain_overflow_signed, /* complain_on_overflow */
1484 ppc64_elf_unhandled_reloc, /* special_function */
1485 "R_PPC64_DTPREL16_DS", /* name */
1486 FALSE, /* partial_inplace */
1487 0, /* src_mask */
1488 0xfffc, /* dst_mask */
1489 FALSE), /* pcrel_offset */
1490
1491 /* Like DTPREL16_DS, but no overflow. */
1492 HOWTO (R_PPC64_DTPREL16_LO_DS,
1493 0, /* rightshift */
1494 1, /* size (0 = byte, 1 = short, 2 = long) */
1495 16, /* bitsize */
1496 FALSE, /* pc_relative */
1497 0, /* bitpos */
1498 complain_overflow_dont, /* complain_on_overflow */
1499 ppc64_elf_unhandled_reloc, /* special_function */
1500 "R_PPC64_DTPREL16_LO_DS", /* name */
1501 FALSE, /* partial_inplace */
1502 0, /* src_mask */
1503 0xfffc, /* dst_mask */
1504 FALSE), /* pcrel_offset */
1505
1506 /* Computes a tp-relative displacement, the difference between the value of
1507 sym+add and the value of the thread pointer (r13). */
1508 HOWTO (R_PPC64_TPREL64,
1509 0, /* rightshift */
1510 4, /* size (0 = byte, 1 = short, 2 = long) */
1511 64, /* bitsize */
1512 FALSE, /* pc_relative */
1513 0, /* bitpos */
1514 complain_overflow_dont, /* complain_on_overflow */
1515 ppc64_elf_unhandled_reloc, /* special_function */
1516 "R_PPC64_TPREL64", /* name */
1517 FALSE, /* partial_inplace */
1518 0, /* src_mask */
1519 ONES (64), /* dst_mask */
1520 FALSE), /* pcrel_offset */
1521
1522 /* A 16 bit tprel reloc. */
1523 HOWTO (R_PPC64_TPREL16,
1524 0, /* rightshift */
1525 1, /* size (0 = byte, 1 = short, 2 = long) */
1526 16, /* bitsize */
1527 FALSE, /* pc_relative */
1528 0, /* bitpos */
1529 complain_overflow_signed, /* complain_on_overflow */
1530 ppc64_elf_unhandled_reloc, /* special_function */
1531 "R_PPC64_TPREL16", /* name */
1532 FALSE, /* partial_inplace */
1533 0, /* src_mask */
1534 0xffff, /* dst_mask */
1535 FALSE), /* pcrel_offset */
1536
1537 /* Like TPREL16, but no overflow. */
1538 HOWTO (R_PPC64_TPREL16_LO,
1539 0, /* rightshift */
1540 1, /* size (0 = byte, 1 = short, 2 = long) */
1541 16, /* bitsize */
1542 FALSE, /* pc_relative */
1543 0, /* bitpos */
1544 complain_overflow_dont, /* complain_on_overflow */
1545 ppc64_elf_unhandled_reloc, /* special_function */
1546 "R_PPC64_TPREL16_LO", /* name */
1547 FALSE, /* partial_inplace */
1548 0, /* src_mask */
1549 0xffff, /* dst_mask */
1550 FALSE), /* pcrel_offset */
1551
1552 /* Like TPREL16_LO, but next higher group of 16 bits. */
1553 HOWTO (R_PPC64_TPREL16_HI,
1554 16, /* rightshift */
1555 1, /* size (0 = byte, 1 = short, 2 = long) */
1556 16, /* bitsize */
1557 FALSE, /* pc_relative */
1558 0, /* bitpos */
1559 complain_overflow_signed, /* complain_on_overflow */
1560 ppc64_elf_unhandled_reloc, /* special_function */
1561 "R_PPC64_TPREL16_HI", /* name */
1562 FALSE, /* partial_inplace */
1563 0, /* src_mask */
1564 0xffff, /* dst_mask */
1565 FALSE), /* pcrel_offset */
1566
1567 /* Like TPREL16_HI, but adjust for low 16 bits. */
1568 HOWTO (R_PPC64_TPREL16_HA,
1569 16, /* rightshift */
1570 1, /* size (0 = byte, 1 = short, 2 = long) */
1571 16, /* bitsize */
1572 FALSE, /* pc_relative */
1573 0, /* bitpos */
1574 complain_overflow_signed, /* complain_on_overflow */
1575 ppc64_elf_unhandled_reloc, /* special_function */
1576 "R_PPC64_TPREL16_HA", /* name */
1577 FALSE, /* partial_inplace */
1578 0, /* src_mask */
1579 0xffff, /* dst_mask */
1580 FALSE), /* pcrel_offset */
1581
1582 /* Like TPREL16_HI, but next higher group of 16 bits. */
1583 HOWTO (R_PPC64_TPREL16_HIGHER,
1584 32, /* rightshift */
1585 1, /* size (0 = byte, 1 = short, 2 = long) */
1586 16, /* bitsize */
1587 FALSE, /* pc_relative */
1588 0, /* bitpos */
1589 complain_overflow_dont, /* complain_on_overflow */
1590 ppc64_elf_unhandled_reloc, /* special_function */
1591 "R_PPC64_TPREL16_HIGHER", /* name */
1592 FALSE, /* partial_inplace */
1593 0, /* src_mask */
1594 0xffff, /* dst_mask */
1595 FALSE), /* pcrel_offset */
1596
1597 /* Like TPREL16_HIGHER, but adjust for low 16 bits. */
1598 HOWTO (R_PPC64_TPREL16_HIGHERA,
1599 32, /* rightshift */
1600 1, /* size (0 = byte, 1 = short, 2 = long) */
1601 16, /* bitsize */
1602 FALSE, /* pc_relative */
1603 0, /* bitpos */
1604 complain_overflow_dont, /* complain_on_overflow */
1605 ppc64_elf_unhandled_reloc, /* special_function */
1606 "R_PPC64_TPREL16_HIGHERA", /* name */
1607 FALSE, /* partial_inplace */
1608 0, /* src_mask */
1609 0xffff, /* dst_mask */
1610 FALSE), /* pcrel_offset */
1611
1612 /* Like TPREL16_HIGHER, but next higher group of 16 bits. */
1613 HOWTO (R_PPC64_TPREL16_HIGHEST,
1614 48, /* rightshift */
1615 1, /* size (0 = byte, 1 = short, 2 = long) */
1616 16, /* bitsize */
1617 FALSE, /* pc_relative */
1618 0, /* bitpos */
1619 complain_overflow_dont, /* complain_on_overflow */
1620 ppc64_elf_unhandled_reloc, /* special_function */
1621 "R_PPC64_TPREL16_HIGHEST", /* name */
1622 FALSE, /* partial_inplace */
1623 0, /* src_mask */
1624 0xffff, /* dst_mask */
1625 FALSE), /* pcrel_offset */
1626
1627 /* Like TPREL16_HIGHEST, but adjust for low 16 bits. */
1628 HOWTO (R_PPC64_TPREL16_HIGHESTA,
1629 48, /* rightshift */
1630 1, /* size (0 = byte, 1 = short, 2 = long) */
1631 16, /* bitsize */
1632 FALSE, /* pc_relative */
1633 0, /* bitpos */
1634 complain_overflow_dont, /* complain_on_overflow */
1635 ppc64_elf_unhandled_reloc, /* special_function */
1636 "R_PPC64_TPREL16_HIGHESTA", /* name */
1637 FALSE, /* partial_inplace */
1638 0, /* src_mask */
1639 0xffff, /* dst_mask */
1640 FALSE), /* pcrel_offset */
1641
1642 /* Like TPREL16, but for insns with a DS field. */
1643 HOWTO (R_PPC64_TPREL16_DS,
1644 0, /* rightshift */
1645 1, /* size (0 = byte, 1 = short, 2 = long) */
1646 16, /* bitsize */
1647 FALSE, /* pc_relative */
1648 0, /* bitpos */
1649 complain_overflow_signed, /* complain_on_overflow */
1650 ppc64_elf_unhandled_reloc, /* special_function */
1651 "R_PPC64_TPREL16_DS", /* name */
1652 FALSE, /* partial_inplace */
1653 0, /* src_mask */
1654 0xfffc, /* dst_mask */
1655 FALSE), /* pcrel_offset */
1656
1657 /* Like TPREL16_DS, but no overflow. */
1658 HOWTO (R_PPC64_TPREL16_LO_DS,
1659 0, /* rightshift */
1660 1, /* size (0 = byte, 1 = short, 2 = long) */
1661 16, /* bitsize */
1662 FALSE, /* pc_relative */
1663 0, /* bitpos */
1664 complain_overflow_dont, /* complain_on_overflow */
1665 ppc64_elf_unhandled_reloc, /* special_function */
1666 "R_PPC64_TPREL16_LO_DS", /* name */
1667 FALSE, /* partial_inplace */
1668 0, /* src_mask */
1669 0xfffc, /* dst_mask */
1670 FALSE), /* pcrel_offset */
1671
1672 /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1673 with values (sym+add)@dtpmod and (sym+add)@dtprel, and computes the offset
1674 to the first entry relative to the TOC base (r2). */
1675 HOWTO (R_PPC64_GOT_TLSGD16,
1676 0, /* rightshift */
1677 1, /* size (0 = byte, 1 = short, 2 = long) */
1678 16, /* bitsize */
1679 FALSE, /* pc_relative */
1680 0, /* bitpos */
1681 complain_overflow_signed, /* complain_on_overflow */
1682 ppc64_elf_unhandled_reloc, /* special_function */
1683 "R_PPC64_GOT_TLSGD16", /* name */
1684 FALSE, /* partial_inplace */
1685 0, /* src_mask */
1686 0xffff, /* dst_mask */
1687 FALSE), /* pcrel_offset */
1688
1689 /* Like GOT_TLSGD16, but no overflow. */
1690 HOWTO (R_PPC64_GOT_TLSGD16_LO,
1691 0, /* rightshift */
1692 1, /* size (0 = byte, 1 = short, 2 = long) */
1693 16, /* bitsize */
1694 FALSE, /* pc_relative */
1695 0, /* bitpos */
1696 complain_overflow_dont, /* complain_on_overflow */
1697 ppc64_elf_unhandled_reloc, /* special_function */
1698 "R_PPC64_GOT_TLSGD16_LO", /* name */
1699 FALSE, /* partial_inplace */
1700 0, /* src_mask */
1701 0xffff, /* dst_mask */
1702 FALSE), /* pcrel_offset */
1703
1704 /* Like GOT_TLSGD16_LO, but next higher group of 16 bits. */
1705 HOWTO (R_PPC64_GOT_TLSGD16_HI,
1706 16, /* rightshift */
1707 1, /* size (0 = byte, 1 = short, 2 = long) */
1708 16, /* bitsize */
1709 FALSE, /* pc_relative */
1710 0, /* bitpos */
1711 complain_overflow_signed, /* complain_on_overflow */
1712 ppc64_elf_unhandled_reloc, /* special_function */
1713 "R_PPC64_GOT_TLSGD16_HI", /* name */
1714 FALSE, /* partial_inplace */
1715 0, /* src_mask */
1716 0xffff, /* dst_mask */
1717 FALSE), /* pcrel_offset */
1718
1719 /* Like GOT_TLSGD16_HI, but adjust for low 16 bits. */
1720 HOWTO (R_PPC64_GOT_TLSGD16_HA,
1721 16, /* rightshift */
1722 1, /* size (0 = byte, 1 = short, 2 = long) */
1723 16, /* bitsize */
1724 FALSE, /* pc_relative */
1725 0, /* bitpos */
1726 complain_overflow_signed, /* complain_on_overflow */
1727 ppc64_elf_unhandled_reloc, /* special_function */
1728 "R_PPC64_GOT_TLSGD16_HA", /* name */
1729 FALSE, /* partial_inplace */
1730 0, /* src_mask */
1731 0xffff, /* dst_mask */
1732 FALSE), /* pcrel_offset */
1733
1734 /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1735 with values (sym+add)@dtpmod and zero, and computes the offset to the
1736 first entry relative to the TOC base (r2). */
1737 HOWTO (R_PPC64_GOT_TLSLD16,
1738 0, /* rightshift */
1739 1, /* size (0 = byte, 1 = short, 2 = long) */
1740 16, /* bitsize */
1741 FALSE, /* pc_relative */
1742 0, /* bitpos */
1743 complain_overflow_signed, /* complain_on_overflow */
1744 ppc64_elf_unhandled_reloc, /* special_function */
1745 "R_PPC64_GOT_TLSLD16", /* name */
1746 FALSE, /* partial_inplace */
1747 0, /* src_mask */
1748 0xffff, /* dst_mask */
1749 FALSE), /* pcrel_offset */
1750
1751 /* Like GOT_TLSLD16, but no overflow. */
1752 HOWTO (R_PPC64_GOT_TLSLD16_LO,
1753 0, /* rightshift */
1754 1, /* size (0 = byte, 1 = short, 2 = long) */
1755 16, /* bitsize */
1756 FALSE, /* pc_relative */
1757 0, /* bitpos */
1758 complain_overflow_dont, /* complain_on_overflow */
1759 ppc64_elf_unhandled_reloc, /* special_function */
1760 "R_PPC64_GOT_TLSLD16_LO", /* name */
1761 FALSE, /* partial_inplace */
1762 0, /* src_mask */
1763 0xffff, /* dst_mask */
1764 FALSE), /* pcrel_offset */
1765
1766 /* Like GOT_TLSLD16_LO, but next higher group of 16 bits. */
1767 HOWTO (R_PPC64_GOT_TLSLD16_HI,
1768 16, /* rightshift */
1769 1, /* size (0 = byte, 1 = short, 2 = long) */
1770 16, /* bitsize */
1771 FALSE, /* pc_relative */
1772 0, /* bitpos */
1773 complain_overflow_signed, /* complain_on_overflow */
1774 ppc64_elf_unhandled_reloc, /* special_function */
1775 "R_PPC64_GOT_TLSLD16_HI", /* name */
1776 FALSE, /* partial_inplace */
1777 0, /* src_mask */
1778 0xffff, /* dst_mask */
1779 FALSE), /* pcrel_offset */
1780
1781 /* Like GOT_TLSLD16_HI, but adjust for low 16 bits. */
1782 HOWTO (R_PPC64_GOT_TLSLD16_HA,
1783 16, /* rightshift */
1784 1, /* size (0 = byte, 1 = short, 2 = long) */
1785 16, /* bitsize */
1786 FALSE, /* pc_relative */
1787 0, /* bitpos */
1788 complain_overflow_signed, /* complain_on_overflow */
1789 ppc64_elf_unhandled_reloc, /* special_function */
1790 "R_PPC64_GOT_TLSLD16_HA", /* name */
1791 FALSE, /* partial_inplace */
1792 0, /* src_mask */
1793 0xffff, /* dst_mask */
1794 FALSE), /* pcrel_offset */
1795
1796 /* Allocates an entry in the GOT with value (sym+add)@dtprel, and computes
1797 the offset to the entry relative to the TOC base (r2). */
1798 HOWTO (R_PPC64_GOT_DTPREL16_DS,
1799 0, /* rightshift */
1800 1, /* size (0 = byte, 1 = short, 2 = long) */
1801 16, /* bitsize */
1802 FALSE, /* pc_relative */
1803 0, /* bitpos */
1804 complain_overflow_signed, /* complain_on_overflow */
1805 ppc64_elf_unhandled_reloc, /* special_function */
1806 "R_PPC64_GOT_DTPREL16_DS", /* name */
1807 FALSE, /* partial_inplace */
1808 0, /* src_mask */
1809 0xfffc, /* dst_mask */
1810 FALSE), /* pcrel_offset */
1811
1812 /* Like GOT_DTPREL16_DS, but no overflow. */
1813 HOWTO (R_PPC64_GOT_DTPREL16_LO_DS,
1814 0, /* rightshift */
1815 1, /* size (0 = byte, 1 = short, 2 = long) */
1816 16, /* bitsize */
1817 FALSE, /* pc_relative */
1818 0, /* bitpos */
1819 complain_overflow_dont, /* complain_on_overflow */
1820 ppc64_elf_unhandled_reloc, /* special_function */
1821 "R_PPC64_GOT_DTPREL16_LO_DS", /* name */
1822 FALSE, /* partial_inplace */
1823 0, /* src_mask */
1824 0xfffc, /* dst_mask */
1825 FALSE), /* pcrel_offset */
1826
1827 /* Like GOT_DTPREL16_LO_DS, but next higher group of 16 bits. */
1828 HOWTO (R_PPC64_GOT_DTPREL16_HI,
1829 16, /* rightshift */
1830 1, /* size (0 = byte, 1 = short, 2 = long) */
1831 16, /* bitsize */
1832 FALSE, /* pc_relative */
1833 0, /* bitpos */
1834 complain_overflow_signed, /* complain_on_overflow */
1835 ppc64_elf_unhandled_reloc, /* special_function */
1836 "R_PPC64_GOT_DTPREL16_HI", /* name */
1837 FALSE, /* partial_inplace */
1838 0, /* src_mask */
1839 0xffff, /* dst_mask */
1840 FALSE), /* pcrel_offset */
1841
1842 /* Like GOT_DTPREL16_HI, but adjust for low 16 bits. */
1843 HOWTO (R_PPC64_GOT_DTPREL16_HA,
1844 16, /* rightshift */
1845 1, /* size (0 = byte, 1 = short, 2 = long) */
1846 16, /* bitsize */
1847 FALSE, /* pc_relative */
1848 0, /* bitpos */
1849 complain_overflow_signed, /* complain_on_overflow */
1850 ppc64_elf_unhandled_reloc, /* special_function */
1851 "R_PPC64_GOT_DTPREL16_HA", /* name */
1852 FALSE, /* partial_inplace */
1853 0, /* src_mask */
1854 0xffff, /* dst_mask */
1855 FALSE), /* pcrel_offset */
1856
1857 /* Allocates an entry in the GOT with value (sym+add)@tprel, and computes the
1858 offset to the entry relative to the TOC base (r2). */
1859 HOWTO (R_PPC64_GOT_TPREL16_DS,
1860 0, /* rightshift */
1861 1, /* size (0 = byte, 1 = short, 2 = long) */
1862 16, /* bitsize */
1863 FALSE, /* pc_relative */
1864 0, /* bitpos */
1865 complain_overflow_signed, /* complain_on_overflow */
1866 ppc64_elf_unhandled_reloc, /* special_function */
1867 "R_PPC64_GOT_TPREL16_DS", /* name */
1868 FALSE, /* partial_inplace */
1869 0, /* src_mask */
1870 0xfffc, /* dst_mask */
1871 FALSE), /* pcrel_offset */
1872
1873 /* Like GOT_TPREL16_DS, but no overflow. */
1874 HOWTO (R_PPC64_GOT_TPREL16_LO_DS,
1875 0, /* rightshift */
1876 1, /* size (0 = byte, 1 = short, 2 = long) */
1877 16, /* bitsize */
1878 FALSE, /* pc_relative */
1879 0, /* bitpos */
1880 complain_overflow_dont, /* complain_on_overflow */
1881 ppc64_elf_unhandled_reloc, /* special_function */
1882 "R_PPC64_GOT_TPREL16_LO_DS", /* name */
1883 FALSE, /* partial_inplace */
1884 0, /* src_mask */
1885 0xfffc, /* dst_mask */
1886 FALSE), /* pcrel_offset */
1887
1888 /* Like GOT_TPREL16_LO_DS, but next higher group of 16 bits. */
1889 HOWTO (R_PPC64_GOT_TPREL16_HI,
1890 16, /* rightshift */
1891 1, /* size (0 = byte, 1 = short, 2 = long) */
1892 16, /* bitsize */
1893 FALSE, /* pc_relative */
1894 0, /* bitpos */
1895 complain_overflow_signed, /* complain_on_overflow */
1896 ppc64_elf_unhandled_reloc, /* special_function */
1897 "R_PPC64_GOT_TPREL16_HI", /* name */
1898 FALSE, /* partial_inplace */
1899 0, /* src_mask */
1900 0xffff, /* dst_mask */
1901 FALSE), /* pcrel_offset */
1902
1903 /* Like GOT_TPREL16_HI, but adjust for low 16 bits. */
1904 HOWTO (R_PPC64_GOT_TPREL16_HA,
1905 16, /* rightshift */
1906 1, /* size (0 = byte, 1 = short, 2 = long) */
1907 16, /* bitsize */
1908 FALSE, /* pc_relative */
1909 0, /* bitpos */
1910 complain_overflow_signed, /* complain_on_overflow */
1911 ppc64_elf_unhandled_reloc, /* special_function */
1912 "R_PPC64_GOT_TPREL16_HA", /* name */
1913 FALSE, /* partial_inplace */
1914 0, /* src_mask */
1915 0xffff, /* dst_mask */
1916 FALSE), /* pcrel_offset */
1917
1918 HOWTO (R_PPC64_JMP_IREL, /* type */
1919 0, /* rightshift */
1920 0, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1921 0, /* bitsize */
1922 FALSE, /* pc_relative */
1923 0, /* bitpos */
1924 complain_overflow_dont, /* complain_on_overflow */
1925 ppc64_elf_unhandled_reloc, /* special_function */
1926 "R_PPC64_JMP_IREL", /* name */
1927 FALSE, /* partial_inplace */
1928 0, /* src_mask */
1929 0, /* dst_mask */
1930 FALSE), /* pcrel_offset */
1931
1932 HOWTO (R_PPC64_IRELATIVE, /* type */
1933 0, /* rightshift */
1934 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1935 64, /* bitsize */
1936 FALSE, /* pc_relative */
1937 0, /* bitpos */
1938 complain_overflow_dont, /* complain_on_overflow */
1939 bfd_elf_generic_reloc, /* special_function */
1940 "R_PPC64_IRELATIVE", /* name */
1941 FALSE, /* partial_inplace */
1942 0, /* src_mask */
1943 ONES (64), /* dst_mask */
1944 FALSE), /* pcrel_offset */
1945
1946 /* A 16 bit relative relocation. */
1947 HOWTO (R_PPC64_REL16, /* type */
1948 0, /* rightshift */
1949 1, /* size (0 = byte, 1 = short, 2 = long) */
1950 16, /* bitsize */
1951 TRUE, /* pc_relative */
1952 0, /* bitpos */
1953 complain_overflow_bitfield, /* complain_on_overflow */
1954 bfd_elf_generic_reloc, /* special_function */
1955 "R_PPC64_REL16", /* name */
1956 FALSE, /* partial_inplace */
1957 0, /* src_mask */
1958 0xffff, /* dst_mask */
1959 TRUE), /* pcrel_offset */
1960
1961 /* A 16 bit relative relocation without overflow. */
1962 HOWTO (R_PPC64_REL16_LO, /* type */
1963 0, /* rightshift */
1964 1, /* size (0 = byte, 1 = short, 2 = long) */
1965 16, /* bitsize */
1966 TRUE, /* pc_relative */
1967 0, /* bitpos */
1968 complain_overflow_dont,/* complain_on_overflow */
1969 bfd_elf_generic_reloc, /* special_function */
1970 "R_PPC64_REL16_LO", /* name */
1971 FALSE, /* partial_inplace */
1972 0, /* src_mask */
1973 0xffff, /* dst_mask */
1974 TRUE), /* pcrel_offset */
1975
1976 /* The high order 16 bits of a relative address. */
1977 HOWTO (R_PPC64_REL16_HI, /* type */
1978 16, /* rightshift */
1979 1, /* size (0 = byte, 1 = short, 2 = long) */
1980 16, /* bitsize */
1981 TRUE, /* pc_relative */
1982 0, /* bitpos */
1983 complain_overflow_signed, /* complain_on_overflow */
1984 bfd_elf_generic_reloc, /* special_function */
1985 "R_PPC64_REL16_HI", /* name */
1986 FALSE, /* partial_inplace */
1987 0, /* src_mask */
1988 0xffff, /* dst_mask */
1989 TRUE), /* pcrel_offset */
1990
1991 /* The high order 16 bits of a relative address, plus 1 if the contents of
1992 the low 16 bits, treated as a signed number, is negative. */
1993 HOWTO (R_PPC64_REL16_HA, /* type */
1994 16, /* rightshift */
1995 1, /* size (0 = byte, 1 = short, 2 = long) */
1996 16, /* bitsize */
1997 TRUE, /* pc_relative */
1998 0, /* bitpos */
1999 complain_overflow_signed, /* complain_on_overflow */
2000 ppc64_elf_ha_reloc, /* special_function */
2001 "R_PPC64_REL16_HA", /* name */
2002 FALSE, /* partial_inplace */
2003 0, /* src_mask */
2004 0xffff, /* dst_mask */
2005 TRUE), /* pcrel_offset */
2006
2007 /* Like R_PPC64_ADDR16_HI, but no overflow. */
2008 HOWTO (R_PPC64_ADDR16_HIGH, /* type */
2009 16, /* rightshift */
2010 1, /* size (0 = byte, 1 = short, 2 = long) */
2011 16, /* bitsize */
2012 FALSE, /* pc_relative */
2013 0, /* bitpos */
2014 complain_overflow_dont, /* complain_on_overflow */
2015 bfd_elf_generic_reloc, /* special_function */
2016 "R_PPC64_ADDR16_HIGH", /* name */
2017 FALSE, /* partial_inplace */
2018 0, /* src_mask */
2019 0xffff, /* dst_mask */
2020 FALSE), /* pcrel_offset */
2021
2022 /* Like R_PPC64_ADDR16_HA, but no overflow. */
2023 HOWTO (R_PPC64_ADDR16_HIGHA, /* type */
2024 16, /* rightshift */
2025 1, /* size (0 = byte, 1 = short, 2 = long) */
2026 16, /* bitsize */
2027 FALSE, /* pc_relative */
2028 0, /* bitpos */
2029 complain_overflow_dont, /* complain_on_overflow */
2030 ppc64_elf_ha_reloc, /* special_function */
2031 "R_PPC64_ADDR16_HIGHA", /* name */
2032 FALSE, /* partial_inplace */
2033 0, /* src_mask */
2034 0xffff, /* dst_mask */
2035 FALSE), /* pcrel_offset */
2036
2037 /* Like R_PPC64_DTPREL16_HI, but no overflow. */
2038 HOWTO (R_PPC64_DTPREL16_HIGH,
2039 16, /* rightshift */
2040 1, /* size (0 = byte, 1 = short, 2 = long) */
2041 16, /* bitsize */
2042 FALSE, /* pc_relative */
2043 0, /* bitpos */
2044 complain_overflow_dont, /* complain_on_overflow */
2045 ppc64_elf_unhandled_reloc, /* special_function */
2046 "R_PPC64_DTPREL16_HIGH", /* name */
2047 FALSE, /* partial_inplace */
2048 0, /* src_mask */
2049 0xffff, /* dst_mask */
2050 FALSE), /* pcrel_offset */
2051
2052 /* Like R_PPC64_DTPREL16_HA, but no overflow. */
2053 HOWTO (R_PPC64_DTPREL16_HIGHA,
2054 16, /* rightshift */
2055 1, /* size (0 = byte, 1 = short, 2 = long) */
2056 16, /* bitsize */
2057 FALSE, /* pc_relative */
2058 0, /* bitpos */
2059 complain_overflow_dont, /* complain_on_overflow */
2060 ppc64_elf_unhandled_reloc, /* special_function */
2061 "R_PPC64_DTPREL16_HIGHA", /* name */
2062 FALSE, /* partial_inplace */
2063 0, /* src_mask */
2064 0xffff, /* dst_mask */
2065 FALSE), /* pcrel_offset */
2066
2067 /* Like R_PPC64_TPREL16_HI, but no overflow. */
2068 HOWTO (R_PPC64_TPREL16_HIGH,
2069 16, /* rightshift */
2070 1, /* size (0 = byte, 1 = short, 2 = long) */
2071 16, /* bitsize */
2072 FALSE, /* pc_relative */
2073 0, /* bitpos */
2074 complain_overflow_dont, /* complain_on_overflow */
2075 ppc64_elf_unhandled_reloc, /* special_function */
2076 "R_PPC64_TPREL16_HIGH", /* name */
2077 FALSE, /* partial_inplace */
2078 0, /* src_mask */
2079 0xffff, /* dst_mask */
2080 FALSE), /* pcrel_offset */
2081
2082 /* Like R_PPC64_TPREL16_HA, but no overflow. */
2083 HOWTO (R_PPC64_TPREL16_HIGHA,
2084 16, /* rightshift */
2085 1, /* size (0 = byte, 1 = short, 2 = long) */
2086 16, /* bitsize */
2087 FALSE, /* pc_relative */
2088 0, /* bitpos */
2089 complain_overflow_dont, /* complain_on_overflow */
2090 ppc64_elf_unhandled_reloc, /* special_function */
2091 "R_PPC64_TPREL16_HIGHA", /* name */
2092 FALSE, /* partial_inplace */
2093 0, /* src_mask */
2094 0xffff, /* dst_mask */
2095 FALSE), /* pcrel_offset */
2096
2097 /* Like ADDR64, but use local entry point of function. */
2098 HOWTO (R_PPC64_ADDR64_LOCAL, /* type */
2099 0, /* rightshift */
2100 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
2101 64, /* bitsize */
2102 FALSE, /* pc_relative */
2103 0, /* bitpos */
2104 complain_overflow_dont, /* complain_on_overflow */
2105 bfd_elf_generic_reloc, /* special_function */
2106 "R_PPC64_ADDR64_LOCAL", /* name */
2107 FALSE, /* partial_inplace */
2108 0, /* src_mask */
2109 ONES (64), /* dst_mask */
2110 FALSE), /* pcrel_offset */
2111
2112 /* GNU extension to record C++ vtable hierarchy. */
2113 HOWTO (R_PPC64_GNU_VTINHERIT, /* type */
2114 0, /* rightshift */
2115 0, /* size (0 = byte, 1 = short, 2 = long) */
2116 0, /* bitsize */
2117 FALSE, /* pc_relative */
2118 0, /* bitpos */
2119 complain_overflow_dont, /* complain_on_overflow */
2120 NULL, /* special_function */
2121 "R_PPC64_GNU_VTINHERIT", /* name */
2122 FALSE, /* partial_inplace */
2123 0, /* src_mask */
2124 0, /* dst_mask */
2125 FALSE), /* pcrel_offset */
2126
2127 /* GNU extension to record C++ vtable member usage. */
2128 HOWTO (R_PPC64_GNU_VTENTRY, /* type */
2129 0, /* rightshift */
2130 0, /* size (0 = byte, 1 = short, 2 = long) */
2131 0, /* bitsize */
2132 FALSE, /* pc_relative */
2133 0, /* bitpos */
2134 complain_overflow_dont, /* complain_on_overflow */
2135 NULL, /* special_function */
2136 "R_PPC64_GNU_VTENTRY", /* name */
2137 FALSE, /* partial_inplace */
2138 0, /* src_mask */
2139 0, /* dst_mask */
2140 FALSE), /* pcrel_offset */
2141 };
2142
2143 \f
2144 /* Initialize the ppc64_elf_howto_table, so that linear accesses can
2145 be done. */
2146
2147 static void
2148 ppc_howto_init (void)
2149 {
2150 unsigned int i, type;
2151
2152 for (i = 0;
2153 i < sizeof (ppc64_elf_howto_raw) / sizeof (ppc64_elf_howto_raw[0]);
2154 i++)
2155 {
2156 type = ppc64_elf_howto_raw[i].type;
2157 BFD_ASSERT (type < (sizeof (ppc64_elf_howto_table)
2158 / sizeof (ppc64_elf_howto_table[0])));
2159 ppc64_elf_howto_table[type] = &ppc64_elf_howto_raw[i];
2160 }
2161 }
2162
2163 static reloc_howto_type *
2164 ppc64_elf_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2165 bfd_reloc_code_real_type code)
2166 {
2167 enum elf_ppc64_reloc_type r = R_PPC64_NONE;
2168
2169 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2170 /* Initialize howto table if needed. */
2171 ppc_howto_init ();
2172
2173 switch (code)
2174 {
2175 default:
2176 return NULL;
2177
2178 case BFD_RELOC_NONE: r = R_PPC64_NONE;
2179 break;
2180 case BFD_RELOC_32: r = R_PPC64_ADDR32;
2181 break;
2182 case BFD_RELOC_PPC_BA26: r = R_PPC64_ADDR24;
2183 break;
2184 case BFD_RELOC_16: r = R_PPC64_ADDR16;
2185 break;
2186 case BFD_RELOC_LO16: r = R_PPC64_ADDR16_LO;
2187 break;
2188 case BFD_RELOC_HI16: r = R_PPC64_ADDR16_HI;
2189 break;
2190 case BFD_RELOC_PPC64_ADDR16_HIGH: r = R_PPC64_ADDR16_HIGH;
2191 break;
2192 case BFD_RELOC_HI16_S: r = R_PPC64_ADDR16_HA;
2193 break;
2194 case BFD_RELOC_PPC64_ADDR16_HIGHA: r = R_PPC64_ADDR16_HIGHA;
2195 break;
2196 case BFD_RELOC_PPC_BA16: r = R_PPC64_ADDR14;
2197 break;
2198 case BFD_RELOC_PPC_BA16_BRTAKEN: r = R_PPC64_ADDR14_BRTAKEN;
2199 break;
2200 case BFD_RELOC_PPC_BA16_BRNTAKEN: r = R_PPC64_ADDR14_BRNTAKEN;
2201 break;
2202 case BFD_RELOC_PPC_B26: r = R_PPC64_REL24;
2203 break;
2204 case BFD_RELOC_PPC_B16: r = R_PPC64_REL14;
2205 break;
2206 case BFD_RELOC_PPC_B16_BRTAKEN: r = R_PPC64_REL14_BRTAKEN;
2207 break;
2208 case BFD_RELOC_PPC_B16_BRNTAKEN: r = R_PPC64_REL14_BRNTAKEN;
2209 break;
2210 case BFD_RELOC_16_GOTOFF: r = R_PPC64_GOT16;
2211 break;
2212 case BFD_RELOC_LO16_GOTOFF: r = R_PPC64_GOT16_LO;
2213 break;
2214 case BFD_RELOC_HI16_GOTOFF: r = R_PPC64_GOT16_HI;
2215 break;
2216 case BFD_RELOC_HI16_S_GOTOFF: r = R_PPC64_GOT16_HA;
2217 break;
2218 case BFD_RELOC_PPC_COPY: r = R_PPC64_COPY;
2219 break;
2220 case BFD_RELOC_PPC_GLOB_DAT: r = R_PPC64_GLOB_DAT;
2221 break;
2222 case BFD_RELOC_32_PCREL: r = R_PPC64_REL32;
2223 break;
2224 case BFD_RELOC_32_PLTOFF: r = R_PPC64_PLT32;
2225 break;
2226 case BFD_RELOC_32_PLT_PCREL: r = R_PPC64_PLTREL32;
2227 break;
2228 case BFD_RELOC_LO16_PLTOFF: r = R_PPC64_PLT16_LO;
2229 break;
2230 case BFD_RELOC_HI16_PLTOFF: r = R_PPC64_PLT16_HI;
2231 break;
2232 case BFD_RELOC_HI16_S_PLTOFF: r = R_PPC64_PLT16_HA;
2233 break;
2234 case BFD_RELOC_16_BASEREL: r = R_PPC64_SECTOFF;
2235 break;
2236 case BFD_RELOC_LO16_BASEREL: r = R_PPC64_SECTOFF_LO;
2237 break;
2238 case BFD_RELOC_HI16_BASEREL: r = R_PPC64_SECTOFF_HI;
2239 break;
2240 case BFD_RELOC_HI16_S_BASEREL: r = R_PPC64_SECTOFF_HA;
2241 break;
2242 case BFD_RELOC_CTOR: r = R_PPC64_ADDR64;
2243 break;
2244 case BFD_RELOC_64: r = R_PPC64_ADDR64;
2245 break;
2246 case BFD_RELOC_PPC64_HIGHER: r = R_PPC64_ADDR16_HIGHER;
2247 break;
2248 case BFD_RELOC_PPC64_HIGHER_S: r = R_PPC64_ADDR16_HIGHERA;
2249 break;
2250 case BFD_RELOC_PPC64_HIGHEST: r = R_PPC64_ADDR16_HIGHEST;
2251 break;
2252 case BFD_RELOC_PPC64_HIGHEST_S: r = R_PPC64_ADDR16_HIGHESTA;
2253 break;
2254 case BFD_RELOC_64_PCREL: r = R_PPC64_REL64;
2255 break;
2256 case BFD_RELOC_64_PLTOFF: r = R_PPC64_PLT64;
2257 break;
2258 case BFD_RELOC_64_PLT_PCREL: r = R_PPC64_PLTREL64;
2259 break;
2260 case BFD_RELOC_PPC_TOC16: r = R_PPC64_TOC16;
2261 break;
2262 case BFD_RELOC_PPC64_TOC16_LO: r = R_PPC64_TOC16_LO;
2263 break;
2264 case BFD_RELOC_PPC64_TOC16_HI: r = R_PPC64_TOC16_HI;
2265 break;
2266 case BFD_RELOC_PPC64_TOC16_HA: r = R_PPC64_TOC16_HA;
2267 break;
2268 case BFD_RELOC_PPC64_TOC: r = R_PPC64_TOC;
2269 break;
2270 case BFD_RELOC_PPC64_PLTGOT16: r = R_PPC64_PLTGOT16;
2271 break;
2272 case BFD_RELOC_PPC64_PLTGOT16_LO: r = R_PPC64_PLTGOT16_LO;
2273 break;
2274 case BFD_RELOC_PPC64_PLTGOT16_HI: r = R_PPC64_PLTGOT16_HI;
2275 break;
2276 case BFD_RELOC_PPC64_PLTGOT16_HA: r = R_PPC64_PLTGOT16_HA;
2277 break;
2278 case BFD_RELOC_PPC64_ADDR16_DS: r = R_PPC64_ADDR16_DS;
2279 break;
2280 case BFD_RELOC_PPC64_ADDR16_LO_DS: r = R_PPC64_ADDR16_LO_DS;
2281 break;
2282 case BFD_RELOC_PPC64_GOT16_DS: r = R_PPC64_GOT16_DS;
2283 break;
2284 case BFD_RELOC_PPC64_GOT16_LO_DS: r = R_PPC64_GOT16_LO_DS;
2285 break;
2286 case BFD_RELOC_PPC64_PLT16_LO_DS: r = R_PPC64_PLT16_LO_DS;
2287 break;
2288 case BFD_RELOC_PPC64_SECTOFF_DS: r = R_PPC64_SECTOFF_DS;
2289 break;
2290 case BFD_RELOC_PPC64_SECTOFF_LO_DS: r = R_PPC64_SECTOFF_LO_DS;
2291 break;
2292 case BFD_RELOC_PPC64_TOC16_DS: r = R_PPC64_TOC16_DS;
2293 break;
2294 case BFD_RELOC_PPC64_TOC16_LO_DS: r = R_PPC64_TOC16_LO_DS;
2295 break;
2296 case BFD_RELOC_PPC64_PLTGOT16_DS: r = R_PPC64_PLTGOT16_DS;
2297 break;
2298 case BFD_RELOC_PPC64_PLTGOT16_LO_DS: r = R_PPC64_PLTGOT16_LO_DS;
2299 break;
2300 case BFD_RELOC_PPC_TLS: r = R_PPC64_TLS;
2301 break;
2302 case BFD_RELOC_PPC_TLSGD: r = R_PPC64_TLSGD;
2303 break;
2304 case BFD_RELOC_PPC_TLSLD: r = R_PPC64_TLSLD;
2305 break;
2306 case BFD_RELOC_PPC_DTPMOD: r = R_PPC64_DTPMOD64;
2307 break;
2308 case BFD_RELOC_PPC_TPREL16: r = R_PPC64_TPREL16;
2309 break;
2310 case BFD_RELOC_PPC_TPREL16_LO: r = R_PPC64_TPREL16_LO;
2311 break;
2312 case BFD_RELOC_PPC_TPREL16_HI: r = R_PPC64_TPREL16_HI;
2313 break;
2314 case BFD_RELOC_PPC64_TPREL16_HIGH: r = R_PPC64_TPREL16_HIGH;
2315 break;
2316 case BFD_RELOC_PPC_TPREL16_HA: r = R_PPC64_TPREL16_HA;
2317 break;
2318 case BFD_RELOC_PPC64_TPREL16_HIGHA: r = R_PPC64_TPREL16_HIGHA;
2319 break;
2320 case BFD_RELOC_PPC_TPREL: r = R_PPC64_TPREL64;
2321 break;
2322 case BFD_RELOC_PPC_DTPREL16: r = R_PPC64_DTPREL16;
2323 break;
2324 case BFD_RELOC_PPC_DTPREL16_LO: r = R_PPC64_DTPREL16_LO;
2325 break;
2326 case BFD_RELOC_PPC_DTPREL16_HI: r = R_PPC64_DTPREL16_HI;
2327 break;
2328 case BFD_RELOC_PPC64_DTPREL16_HIGH: r = R_PPC64_DTPREL16_HIGH;
2329 break;
2330 case BFD_RELOC_PPC_DTPREL16_HA: r = R_PPC64_DTPREL16_HA;
2331 break;
2332 case BFD_RELOC_PPC64_DTPREL16_HIGHA: r = R_PPC64_DTPREL16_HIGHA;
2333 break;
2334 case BFD_RELOC_PPC_DTPREL: r = R_PPC64_DTPREL64;
2335 break;
2336 case BFD_RELOC_PPC_GOT_TLSGD16: r = R_PPC64_GOT_TLSGD16;
2337 break;
2338 case BFD_RELOC_PPC_GOT_TLSGD16_LO: r = R_PPC64_GOT_TLSGD16_LO;
2339 break;
2340 case BFD_RELOC_PPC_GOT_TLSGD16_HI: r = R_PPC64_GOT_TLSGD16_HI;
2341 break;
2342 case BFD_RELOC_PPC_GOT_TLSGD16_HA: r = R_PPC64_GOT_TLSGD16_HA;
2343 break;
2344 case BFD_RELOC_PPC_GOT_TLSLD16: r = R_PPC64_GOT_TLSLD16;
2345 break;
2346 case BFD_RELOC_PPC_GOT_TLSLD16_LO: r = R_PPC64_GOT_TLSLD16_LO;
2347 break;
2348 case BFD_RELOC_PPC_GOT_TLSLD16_HI: r = R_PPC64_GOT_TLSLD16_HI;
2349 break;
2350 case BFD_RELOC_PPC_GOT_TLSLD16_HA: r = R_PPC64_GOT_TLSLD16_HA;
2351 break;
2352 case BFD_RELOC_PPC_GOT_TPREL16: r = R_PPC64_GOT_TPREL16_DS;
2353 break;
2354 case BFD_RELOC_PPC_GOT_TPREL16_LO: r = R_PPC64_GOT_TPREL16_LO_DS;
2355 break;
2356 case BFD_RELOC_PPC_GOT_TPREL16_HI: r = R_PPC64_GOT_TPREL16_HI;
2357 break;
2358 case BFD_RELOC_PPC_GOT_TPREL16_HA: r = R_PPC64_GOT_TPREL16_HA;
2359 break;
2360 case BFD_RELOC_PPC_GOT_DTPREL16: r = R_PPC64_GOT_DTPREL16_DS;
2361 break;
2362 case BFD_RELOC_PPC_GOT_DTPREL16_LO: r = R_PPC64_GOT_DTPREL16_LO_DS;
2363 break;
2364 case BFD_RELOC_PPC_GOT_DTPREL16_HI: r = R_PPC64_GOT_DTPREL16_HI;
2365 break;
2366 case BFD_RELOC_PPC_GOT_DTPREL16_HA: r = R_PPC64_GOT_DTPREL16_HA;
2367 break;
2368 case BFD_RELOC_PPC64_TPREL16_DS: r = R_PPC64_TPREL16_DS;
2369 break;
2370 case BFD_RELOC_PPC64_TPREL16_LO_DS: r = R_PPC64_TPREL16_LO_DS;
2371 break;
2372 case BFD_RELOC_PPC64_TPREL16_HIGHER: r = R_PPC64_TPREL16_HIGHER;
2373 break;
2374 case BFD_RELOC_PPC64_TPREL16_HIGHERA: r = R_PPC64_TPREL16_HIGHERA;
2375 break;
2376 case BFD_RELOC_PPC64_TPREL16_HIGHEST: r = R_PPC64_TPREL16_HIGHEST;
2377 break;
2378 case BFD_RELOC_PPC64_TPREL16_HIGHESTA: r = R_PPC64_TPREL16_HIGHESTA;
2379 break;
2380 case BFD_RELOC_PPC64_DTPREL16_DS: r = R_PPC64_DTPREL16_DS;
2381 break;
2382 case BFD_RELOC_PPC64_DTPREL16_LO_DS: r = R_PPC64_DTPREL16_LO_DS;
2383 break;
2384 case BFD_RELOC_PPC64_DTPREL16_HIGHER: r = R_PPC64_DTPREL16_HIGHER;
2385 break;
2386 case BFD_RELOC_PPC64_DTPREL16_HIGHERA: r = R_PPC64_DTPREL16_HIGHERA;
2387 break;
2388 case BFD_RELOC_PPC64_DTPREL16_HIGHEST: r = R_PPC64_DTPREL16_HIGHEST;
2389 break;
2390 case BFD_RELOC_PPC64_DTPREL16_HIGHESTA: r = R_PPC64_DTPREL16_HIGHESTA;
2391 break;
2392 case BFD_RELOC_16_PCREL: r = R_PPC64_REL16;
2393 break;
2394 case BFD_RELOC_LO16_PCREL: r = R_PPC64_REL16_LO;
2395 break;
2396 case BFD_RELOC_HI16_PCREL: r = R_PPC64_REL16_HI;
2397 break;
2398 case BFD_RELOC_HI16_S_PCREL: r = R_PPC64_REL16_HA;
2399 break;
2400 case BFD_RELOC_PPC64_ADDR64_LOCAL: r = R_PPC64_ADDR64_LOCAL;
2401 break;
2402 case BFD_RELOC_VTABLE_INHERIT: r = R_PPC64_GNU_VTINHERIT;
2403 break;
2404 case BFD_RELOC_VTABLE_ENTRY: r = R_PPC64_GNU_VTENTRY;
2405 break;
2406 }
2407
2408 return ppc64_elf_howto_table[r];
2409 };
2410
2411 static reloc_howto_type *
2412 ppc64_elf_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2413 const char *r_name)
2414 {
2415 unsigned int i;
2416
2417 for (i = 0;
2418 i < sizeof (ppc64_elf_howto_raw) / sizeof (ppc64_elf_howto_raw[0]);
2419 i++)
2420 if (ppc64_elf_howto_raw[i].name != NULL
2421 && strcasecmp (ppc64_elf_howto_raw[i].name, r_name) == 0)
2422 return &ppc64_elf_howto_raw[i];
2423
2424 return NULL;
2425 }
2426
2427 /* Set the howto pointer for a PowerPC ELF reloc. */
2428
2429 static void
2430 ppc64_elf_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr,
2431 Elf_Internal_Rela *dst)
2432 {
2433 unsigned int type;
2434
2435 /* Initialize howto table if needed. */
2436 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2437 ppc_howto_init ();
2438
2439 type = ELF64_R_TYPE (dst->r_info);
2440 if (type >= (sizeof (ppc64_elf_howto_table)
2441 / sizeof (ppc64_elf_howto_table[0])))
2442 {
2443 (*_bfd_error_handler) (_("%B: invalid relocation type %d"),
2444 abfd, (int) type);
2445 type = R_PPC64_NONE;
2446 }
2447 cache_ptr->howto = ppc64_elf_howto_table[type];
2448 }
2449
2450 /* Handle the R_PPC64_ADDR16_HA and similar relocs. */
2451
2452 static bfd_reloc_status_type
2453 ppc64_elf_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2454 void *data, asection *input_section,
2455 bfd *output_bfd, char **error_message)
2456 {
2457 /* If this is a relocatable link (output_bfd test tells us), just
2458 call the generic function. Any adjustment will be done at final
2459 link time. */
2460 if (output_bfd != NULL)
2461 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2462 input_section, output_bfd, error_message);
2463
2464 /* Adjust the addend for sign extension of the low 16 bits.
2465 We won't actually be using the low 16 bits, so trashing them
2466 doesn't matter. */
2467 reloc_entry->addend += 0x8000;
2468 return bfd_reloc_continue;
2469 }
2470
2471 static bfd_reloc_status_type
2472 ppc64_elf_branch_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2473 void *data, asection *input_section,
2474 bfd *output_bfd, char **error_message)
2475 {
2476 if (output_bfd != NULL)
2477 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2478 input_section, output_bfd, error_message);
2479
2480 if (strcmp (symbol->section->name, ".opd") == 0
2481 && (symbol->section->owner->flags & DYNAMIC) == 0)
2482 {
2483 bfd_vma dest = opd_entry_value (symbol->section,
2484 symbol->value + reloc_entry->addend,
2485 NULL, NULL, FALSE);
2486 if (dest != (bfd_vma) -1)
2487 reloc_entry->addend = dest - (symbol->value
2488 + symbol->section->output_section->vma
2489 + symbol->section->output_offset);
2490 }
2491 return bfd_reloc_continue;
2492 }
2493
2494 static bfd_reloc_status_type
2495 ppc64_elf_brtaken_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2496 void *data, asection *input_section,
2497 bfd *output_bfd, char **error_message)
2498 {
2499 long insn;
2500 enum elf_ppc64_reloc_type r_type;
2501 bfd_size_type octets;
2502 /* Assume 'at' branch hints. */
2503 bfd_boolean is_isa_v2 = TRUE;
2504
2505 /* If this is a relocatable link (output_bfd test tells us), just
2506 call the generic function. Any adjustment will be done at final
2507 link time. */
2508 if (output_bfd != NULL)
2509 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2510 input_section, output_bfd, error_message);
2511
2512 octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2513 insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
2514 insn &= ~(0x01 << 21);
2515 r_type = reloc_entry->howto->type;
2516 if (r_type == R_PPC64_ADDR14_BRTAKEN
2517 || r_type == R_PPC64_REL14_BRTAKEN)
2518 insn |= 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field. */
2519
2520 if (is_isa_v2)
2521 {
2522 /* Set 'a' bit. This is 0b00010 in BO field for branch
2523 on CR(BI) insns (BO == 001at or 011at), and 0b01000
2524 for branch on CTR insns (BO == 1a00t or 1a01t). */
2525 if ((insn & (0x14 << 21)) == (0x04 << 21))
2526 insn |= 0x02 << 21;
2527 else if ((insn & (0x14 << 21)) == (0x10 << 21))
2528 insn |= 0x08 << 21;
2529 else
2530 goto out;
2531 }
2532 else
2533 {
2534 bfd_vma target = 0;
2535 bfd_vma from;
2536
2537 if (!bfd_is_com_section (symbol->section))
2538 target = symbol->value;
2539 target += symbol->section->output_section->vma;
2540 target += symbol->section->output_offset;
2541 target += reloc_entry->addend;
2542
2543 from = (reloc_entry->address
2544 + input_section->output_offset
2545 + input_section->output_section->vma);
2546
2547 /* Invert 'y' bit if not the default. */
2548 if ((bfd_signed_vma) (target - from) < 0)
2549 insn ^= 0x01 << 21;
2550 }
2551 bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
2552 out:
2553 return ppc64_elf_branch_reloc (abfd, reloc_entry, symbol, data,
2554 input_section, output_bfd, error_message);
2555 }
2556
2557 static bfd_reloc_status_type
2558 ppc64_elf_sectoff_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2559 void *data, asection *input_section,
2560 bfd *output_bfd, char **error_message)
2561 {
2562 /* If this is a relocatable link (output_bfd test tells us), just
2563 call the generic function. Any adjustment will be done at final
2564 link time. */
2565 if (output_bfd != NULL)
2566 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2567 input_section, output_bfd, error_message);
2568
2569 /* Subtract the symbol section base address. */
2570 reloc_entry->addend -= symbol->section->output_section->vma;
2571 return bfd_reloc_continue;
2572 }
2573
2574 static bfd_reloc_status_type
2575 ppc64_elf_sectoff_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2576 void *data, asection *input_section,
2577 bfd *output_bfd, char **error_message)
2578 {
2579 /* If this is a relocatable link (output_bfd test tells us), just
2580 call the generic function. Any adjustment will be done at final
2581 link time. */
2582 if (output_bfd != NULL)
2583 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2584 input_section, output_bfd, error_message);
2585
2586 /* Subtract the symbol section base address. */
2587 reloc_entry->addend -= symbol->section->output_section->vma;
2588
2589 /* Adjust the addend for sign extension of the low 16 bits. */
2590 reloc_entry->addend += 0x8000;
2591 return bfd_reloc_continue;
2592 }
2593
2594 static bfd_reloc_status_type
2595 ppc64_elf_toc_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2596 void *data, asection *input_section,
2597 bfd *output_bfd, char **error_message)
2598 {
2599 bfd_vma TOCstart;
2600
2601 /* If this is a relocatable link (output_bfd test tells us), just
2602 call the generic function. Any adjustment will be done at final
2603 link time. */
2604 if (output_bfd != NULL)
2605 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2606 input_section, output_bfd, error_message);
2607
2608 TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2609 if (TOCstart == 0)
2610 TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2611
2612 /* Subtract the TOC base address. */
2613 reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2614 return bfd_reloc_continue;
2615 }
2616
2617 static bfd_reloc_status_type
2618 ppc64_elf_toc_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2619 void *data, asection *input_section,
2620 bfd *output_bfd, char **error_message)
2621 {
2622 bfd_vma TOCstart;
2623
2624 /* If this is a relocatable link (output_bfd test tells us), just
2625 call the generic function. Any adjustment will be done at final
2626 link time. */
2627 if (output_bfd != NULL)
2628 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2629 input_section, output_bfd, error_message);
2630
2631 TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2632 if (TOCstart == 0)
2633 TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2634
2635 /* Subtract the TOC base address. */
2636 reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2637
2638 /* Adjust the addend for sign extension of the low 16 bits. */
2639 reloc_entry->addend += 0x8000;
2640 return bfd_reloc_continue;
2641 }
2642
2643 static bfd_reloc_status_type
2644 ppc64_elf_toc64_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2645 void *data, asection *input_section,
2646 bfd *output_bfd, char **error_message)
2647 {
2648 bfd_vma TOCstart;
2649 bfd_size_type octets;
2650
2651 /* If this is a relocatable link (output_bfd test tells us), just
2652 call the generic function. Any adjustment will be done at final
2653 link time. */
2654 if (output_bfd != NULL)
2655 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2656 input_section, output_bfd, error_message);
2657
2658 TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2659 if (TOCstart == 0)
2660 TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
2661
2662 octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2663 bfd_put_64 (abfd, TOCstart + TOC_BASE_OFF, (bfd_byte *) data + octets);
2664 return bfd_reloc_ok;
2665 }
2666
2667 static bfd_reloc_status_type
2668 ppc64_elf_unhandled_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2669 void *data, asection *input_section,
2670 bfd *output_bfd, char **error_message)
2671 {
2672 /* If this is a relocatable link (output_bfd test tells us), just
2673 call the generic function. Any adjustment will be done at final
2674 link time. */
2675 if (output_bfd != NULL)
2676 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2677 input_section, output_bfd, error_message);
2678
2679 if (error_message != NULL)
2680 {
2681 static char buf[60];
2682 sprintf (buf, "generic linker can't handle %s",
2683 reloc_entry->howto->name);
2684 *error_message = buf;
2685 }
2686 return bfd_reloc_dangerous;
2687 }
2688
2689 /* Track GOT entries needed for a given symbol. We might need more
2690 than one got entry per symbol. */
2691 struct got_entry
2692 {
2693 struct got_entry *next;
2694
2695 /* The symbol addend that we'll be placing in the GOT. */
2696 bfd_vma addend;
2697
2698 /* Unlike other ELF targets, we use separate GOT entries for the same
2699 symbol referenced from different input files. This is to support
2700 automatic multiple TOC/GOT sections, where the TOC base can vary
2701 from one input file to another. After partitioning into TOC groups
2702 we merge entries within the group.
2703
2704 Point to the BFD owning this GOT entry. */
2705 bfd *owner;
2706
2707 /* Zero for non-tls entries, or TLS_TLS and one of TLS_GD, TLS_LD,
2708 TLS_TPREL or TLS_DTPREL for tls entries. */
2709 unsigned char tls_type;
2710
2711 /* Non-zero if got.ent points to real entry. */
2712 unsigned char is_indirect;
2713
2714 /* Reference count until size_dynamic_sections, GOT offset thereafter. */
2715 union
2716 {
2717 bfd_signed_vma refcount;
2718 bfd_vma offset;
2719 struct got_entry *ent;
2720 } got;
2721 };
2722
2723 /* The same for PLT. */
2724 struct plt_entry
2725 {
2726 struct plt_entry *next;
2727
2728 bfd_vma addend;
2729
2730 union
2731 {
2732 bfd_signed_vma refcount;
2733 bfd_vma offset;
2734 } plt;
2735 };
2736
2737 struct ppc64_elf_obj_tdata
2738 {
2739 struct elf_obj_tdata elf;
2740
2741 /* Shortcuts to dynamic linker sections. */
2742 asection *got;
2743 asection *relgot;
2744
2745 /* Used during garbage collection. We attach global symbols defined
2746 on removed .opd entries to this section so that the sym is removed. */
2747 asection *deleted_section;
2748
2749 /* TLS local dynamic got entry handling. Support for multiple GOT
2750 sections means we potentially need one of these for each input bfd. */
2751 struct got_entry tlsld_got;
2752
2753 union {
2754 /* A copy of relocs before they are modified for --emit-relocs. */
2755 Elf_Internal_Rela *relocs;
2756
2757 /* Section contents. */
2758 bfd_byte *contents;
2759 } opd;
2760
2761 /* Nonzero if this bfd has small toc/got relocs, ie. that expect
2762 the reloc to be in the range -32768 to 32767. */
2763 unsigned int has_small_toc_reloc : 1;
2764
2765 /* Set if toc/got ha relocs detected not using r2, or lo reloc
2766 instruction not one we handle. */
2767 unsigned int unexpected_toc_insn : 1;
2768 };
2769
2770 #define ppc64_elf_tdata(bfd) \
2771 ((struct ppc64_elf_obj_tdata *) (bfd)->tdata.any)
2772
2773 #define ppc64_tlsld_got(bfd) \
2774 (&ppc64_elf_tdata (bfd)->tlsld_got)
2775
2776 #define is_ppc64_elf(bfd) \
2777 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
2778 && elf_object_id (bfd) == PPC64_ELF_DATA)
2779
2780 /* Override the generic function because we store some extras. */
2781
2782 static bfd_boolean
2783 ppc64_elf_mkobject (bfd *abfd)
2784 {
2785 return bfd_elf_allocate_object (abfd, sizeof (struct ppc64_elf_obj_tdata),
2786 PPC64_ELF_DATA);
2787 }
2788
2789 /* Fix bad default arch selected for a 64 bit input bfd when the
2790 default is 32 bit. */
2791
2792 static bfd_boolean
2793 ppc64_elf_object_p (bfd *abfd)
2794 {
2795 if (abfd->arch_info->the_default && abfd->arch_info->bits_per_word == 32)
2796 {
2797 Elf_Internal_Ehdr *i_ehdr = elf_elfheader (abfd);
2798
2799 if (i_ehdr->e_ident[EI_CLASS] == ELFCLASS64)
2800 {
2801 /* Relies on arch after 32 bit default being 64 bit default. */
2802 abfd->arch_info = abfd->arch_info->next;
2803 BFD_ASSERT (abfd->arch_info->bits_per_word == 64);
2804 }
2805 }
2806 return TRUE;
2807 }
2808
2809 /* Support for core dump NOTE sections. */
2810
2811 static bfd_boolean
2812 ppc64_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
2813 {
2814 size_t offset, size;
2815
2816 if (note->descsz != 504)
2817 return FALSE;
2818
2819 /* pr_cursig */
2820 elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
2821
2822 /* pr_pid */
2823 elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 32);
2824
2825 /* pr_reg */
2826 offset = 112;
2827 size = 384;
2828
2829 /* Make a ".reg/999" section. */
2830 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
2831 size, note->descpos + offset);
2832 }
2833
2834 static bfd_boolean
2835 ppc64_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
2836 {
2837 if (note->descsz != 136)
2838 return FALSE;
2839
2840 elf_tdata (abfd)->core->pid
2841 = bfd_get_32 (abfd, note->descdata + 24);
2842 elf_tdata (abfd)->core->program
2843 = _bfd_elfcore_strndup (abfd, note->descdata + 40, 16);
2844 elf_tdata (abfd)->core->command
2845 = _bfd_elfcore_strndup (abfd, note->descdata + 56, 80);
2846
2847 return TRUE;
2848 }
2849
2850 static char *
2851 ppc64_elf_write_core_note (bfd *abfd, char *buf, int *bufsiz, int note_type,
2852 ...)
2853 {
2854 switch (note_type)
2855 {
2856 default:
2857 return NULL;
2858
2859 case NT_PRPSINFO:
2860 {
2861 char data[136];
2862 va_list ap;
2863
2864 va_start (ap, note_type);
2865 memset (data, 0, sizeof (data));
2866 strncpy (data + 40, va_arg (ap, const char *), 16);
2867 strncpy (data + 56, va_arg (ap, const char *), 80);
2868 va_end (ap);
2869 return elfcore_write_note (abfd, buf, bufsiz,
2870 "CORE", note_type, data, sizeof (data));
2871 }
2872
2873 case NT_PRSTATUS:
2874 {
2875 char data[504];
2876 va_list ap;
2877 long pid;
2878 int cursig;
2879 const void *greg;
2880
2881 va_start (ap, note_type);
2882 memset (data, 0, 112);
2883 pid = va_arg (ap, long);
2884 bfd_put_32 (abfd, pid, data + 32);
2885 cursig = va_arg (ap, int);
2886 bfd_put_16 (abfd, cursig, data + 12);
2887 greg = va_arg (ap, const void *);
2888 memcpy (data + 112, greg, 384);
2889 memset (data + 496, 0, 8);
2890 va_end (ap);
2891 return elfcore_write_note (abfd, buf, bufsiz,
2892 "CORE", note_type, data, sizeof (data));
2893 }
2894 }
2895 }
2896
2897 /* Add extra PPC sections. */
2898
2899 static const struct bfd_elf_special_section ppc64_elf_special_sections[]=
2900 {
2901 { STRING_COMMA_LEN (".plt"), 0, SHT_NOBITS, 0 },
2902 { STRING_COMMA_LEN (".sbss"), -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE },
2903 { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2904 { STRING_COMMA_LEN (".toc"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2905 { STRING_COMMA_LEN (".toc1"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2906 { STRING_COMMA_LEN (".tocbss"), 0, SHT_NOBITS, SHF_ALLOC + SHF_WRITE },
2907 { NULL, 0, 0, 0, 0 }
2908 };
2909
2910 enum _ppc64_sec_type {
2911 sec_normal = 0,
2912 sec_opd = 1,
2913 sec_toc = 2
2914 };
2915
2916 struct _ppc64_elf_section_data
2917 {
2918 struct bfd_elf_section_data elf;
2919
2920 union
2921 {
2922 /* An array with one entry for each opd function descriptor. */
2923 struct _opd_sec_data
2924 {
2925 /* Points to the function code section for local opd entries. */
2926 asection **func_sec;
2927
2928 /* After editing .opd, adjust references to opd local syms. */
2929 long *adjust;
2930 } opd;
2931
2932 /* An array for toc sections, indexed by offset/8. */
2933 struct _toc_sec_data
2934 {
2935 /* Specifies the relocation symbol index used at a given toc offset. */
2936 unsigned *symndx;
2937
2938 /* And the relocation addend. */
2939 bfd_vma *add;
2940 } toc;
2941 } u;
2942
2943 enum _ppc64_sec_type sec_type:2;
2944
2945 /* Flag set when small branches are detected. Used to
2946 select suitable defaults for the stub group size. */
2947 unsigned int has_14bit_branch:1;
2948 };
2949
2950 #define ppc64_elf_section_data(sec) \
2951 ((struct _ppc64_elf_section_data *) elf_section_data (sec))
2952
2953 static bfd_boolean
2954 ppc64_elf_new_section_hook (bfd *abfd, asection *sec)
2955 {
2956 if (!sec->used_by_bfd)
2957 {
2958 struct _ppc64_elf_section_data *sdata;
2959 bfd_size_type amt = sizeof (*sdata);
2960
2961 sdata = bfd_zalloc (abfd, amt);
2962 if (sdata == NULL)
2963 return FALSE;
2964 sec->used_by_bfd = sdata;
2965 }
2966
2967 return _bfd_elf_new_section_hook (abfd, sec);
2968 }
2969
2970 static struct _opd_sec_data *
2971 get_opd_info (asection * sec)
2972 {
2973 if (sec != NULL
2974 && ppc64_elf_section_data (sec) != NULL
2975 && ppc64_elf_section_data (sec)->sec_type == sec_opd)
2976 return &ppc64_elf_section_data (sec)->u.opd;
2977 return NULL;
2978 }
2979
2980 static inline int
2981 abiversion (bfd *abfd)
2982 {
2983 return elf_elfheader (abfd)->e_flags & EF_PPC64_ABI;
2984 }
2985
2986 static inline void
2987 set_abiversion (bfd *abfd, int ver)
2988 {
2989 elf_elfheader (abfd)->e_flags &= ~EF_PPC64_ABI;
2990 elf_elfheader (abfd)->e_flags |= ver & EF_PPC64_ABI;
2991 }
2992 \f
2993 /* Parameters for the qsort hook. */
2994 static bfd_boolean synthetic_relocatable;
2995
2996 /* qsort comparison function for ppc64_elf_get_synthetic_symtab. */
2997
2998 static int
2999 compare_symbols (const void *ap, const void *bp)
3000 {
3001 const asymbol *a = * (const asymbol **) ap;
3002 const asymbol *b = * (const asymbol **) bp;
3003
3004 /* Section symbols first. */
3005 if ((a->flags & BSF_SECTION_SYM) && !(b->flags & BSF_SECTION_SYM))
3006 return -1;
3007 if (!(a->flags & BSF_SECTION_SYM) && (b->flags & BSF_SECTION_SYM))
3008 return 1;
3009
3010 /* then .opd symbols. */
3011 if (strcmp (a->section->name, ".opd") == 0
3012 && strcmp (b->section->name, ".opd") != 0)
3013 return -1;
3014 if (strcmp (a->section->name, ".opd") != 0
3015 && strcmp (b->section->name, ".opd") == 0)
3016 return 1;
3017
3018 /* then other code symbols. */
3019 if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3020 == (SEC_CODE | SEC_ALLOC)
3021 && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3022 != (SEC_CODE | SEC_ALLOC))
3023 return -1;
3024
3025 if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3026 != (SEC_CODE | SEC_ALLOC)
3027 && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3028 == (SEC_CODE | SEC_ALLOC))
3029 return 1;
3030
3031 if (synthetic_relocatable)
3032 {
3033 if (a->section->id < b->section->id)
3034 return -1;
3035
3036 if (a->section->id > b->section->id)
3037 return 1;
3038 }
3039
3040 if (a->value + a->section->vma < b->value + b->section->vma)
3041 return -1;
3042
3043 if (a->value + a->section->vma > b->value + b->section->vma)
3044 return 1;
3045
3046 /* For syms with the same value, prefer strong dynamic global function
3047 syms over other syms. */
3048 if ((a->flags & BSF_GLOBAL) != 0 && (b->flags & BSF_GLOBAL) == 0)
3049 return -1;
3050
3051 if ((a->flags & BSF_GLOBAL) == 0 && (b->flags & BSF_GLOBAL) != 0)
3052 return 1;
3053
3054 if ((a->flags & BSF_FUNCTION) != 0 && (b->flags & BSF_FUNCTION) == 0)
3055 return -1;
3056
3057 if ((a->flags & BSF_FUNCTION) == 0 && (b->flags & BSF_FUNCTION) != 0)
3058 return 1;
3059
3060 if ((a->flags & BSF_WEAK) == 0 && (b->flags & BSF_WEAK) != 0)
3061 return -1;
3062
3063 if ((a->flags & BSF_WEAK) != 0 && (b->flags & BSF_WEAK) == 0)
3064 return 1;
3065
3066 if ((a->flags & BSF_DYNAMIC) != 0 && (b->flags & BSF_DYNAMIC) == 0)
3067 return -1;
3068
3069 if ((a->flags & BSF_DYNAMIC) == 0 && (b->flags & BSF_DYNAMIC) != 0)
3070 return 1;
3071
3072 return 0;
3073 }
3074
3075 /* Search SYMS for a symbol of the given VALUE. */
3076
3077 static asymbol *
3078 sym_exists_at (asymbol **syms, long lo, long hi, int id, bfd_vma value)
3079 {
3080 long mid;
3081
3082 if (id == -1)
3083 {
3084 while (lo < hi)
3085 {
3086 mid = (lo + hi) >> 1;
3087 if (syms[mid]->value + syms[mid]->section->vma < value)
3088 lo = mid + 1;
3089 else if (syms[mid]->value + syms[mid]->section->vma > value)
3090 hi = mid;
3091 else
3092 return syms[mid];
3093 }
3094 }
3095 else
3096 {
3097 while (lo < hi)
3098 {
3099 mid = (lo + hi) >> 1;
3100 if (syms[mid]->section->id < id)
3101 lo = mid + 1;
3102 else if (syms[mid]->section->id > id)
3103 hi = mid;
3104 else if (syms[mid]->value < value)
3105 lo = mid + 1;
3106 else if (syms[mid]->value > value)
3107 hi = mid;
3108 else
3109 return syms[mid];
3110 }
3111 }
3112 return NULL;
3113 }
3114
3115 static bfd_boolean
3116 section_covers_vma (bfd *abfd ATTRIBUTE_UNUSED, asection *section, void *ptr)
3117 {
3118 bfd_vma vma = *(bfd_vma *) ptr;
3119 return ((section->flags & SEC_ALLOC) != 0
3120 && section->vma <= vma
3121 && vma < section->vma + section->size);
3122 }
3123
3124 /* Create synthetic symbols, effectively restoring "dot-symbol" function
3125 entry syms. Also generate @plt symbols for the glink branch table. */
3126
3127 static long
3128 ppc64_elf_get_synthetic_symtab (bfd *abfd,
3129 long static_count, asymbol **static_syms,
3130 long dyn_count, asymbol **dyn_syms,
3131 asymbol **ret)
3132 {
3133 asymbol *s;
3134 long i;
3135 long count;
3136 char *names;
3137 long symcount, codesecsym, codesecsymend, secsymend, opdsymend;
3138 asection *opd = NULL;
3139 bfd_boolean relocatable = (abfd->flags & (EXEC_P | DYNAMIC)) == 0;
3140 asymbol **syms;
3141 int abi = abiversion (abfd);
3142
3143 *ret = NULL;
3144
3145 if (abi < 2)
3146 {
3147 opd = bfd_get_section_by_name (abfd, ".opd");
3148 if (opd == NULL && abi == 1)
3149 return 0;
3150 }
3151
3152 symcount = static_count;
3153 if (!relocatable)
3154 symcount += dyn_count;
3155 if (symcount == 0)
3156 return 0;
3157
3158 syms = bfd_malloc ((symcount + 1) * sizeof (*syms));
3159 if (syms == NULL)
3160 return -1;
3161
3162 if (!relocatable && static_count != 0 && dyn_count != 0)
3163 {
3164 /* Use both symbol tables. */
3165 memcpy (syms, static_syms, static_count * sizeof (*syms));
3166 memcpy (syms + static_count, dyn_syms, (dyn_count + 1) * sizeof (*syms));
3167 }
3168 else if (!relocatable && static_count == 0)
3169 memcpy (syms, dyn_syms, (symcount + 1) * sizeof (*syms));
3170 else
3171 memcpy (syms, static_syms, (symcount + 1) * sizeof (*syms));
3172
3173 synthetic_relocatable = relocatable;
3174 qsort (syms, symcount, sizeof (*syms), compare_symbols);
3175
3176 if (!relocatable && symcount > 1)
3177 {
3178 long j;
3179 /* Trim duplicate syms, since we may have merged the normal and
3180 dynamic symbols. Actually, we only care about syms that have
3181 different values, so trim any with the same value. */
3182 for (i = 1, j = 1; i < symcount; ++i)
3183 if (syms[i - 1]->value + syms[i - 1]->section->vma
3184 != syms[i]->value + syms[i]->section->vma)
3185 syms[j++] = syms[i];
3186 symcount = j;
3187 }
3188
3189 i = 0;
3190 if (strcmp (syms[i]->section->name, ".opd") == 0)
3191 ++i;
3192 codesecsym = i;
3193
3194 for (; i < symcount; ++i)
3195 if (((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3196 != (SEC_CODE | SEC_ALLOC))
3197 || (syms[i]->flags & BSF_SECTION_SYM) == 0)
3198 break;
3199 codesecsymend = i;
3200
3201 for (; i < symcount; ++i)
3202 if ((syms[i]->flags & BSF_SECTION_SYM) == 0)
3203 break;
3204 secsymend = i;
3205
3206 for (; i < symcount; ++i)
3207 if (strcmp (syms[i]->section->name, ".opd") != 0)
3208 break;
3209 opdsymend = i;
3210
3211 for (; i < symcount; ++i)
3212 if ((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3213 != (SEC_CODE | SEC_ALLOC))
3214 break;
3215 symcount = i;
3216
3217 count = 0;
3218
3219 if (relocatable)
3220 {
3221 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3222 arelent *r;
3223 size_t size;
3224 long relcount;
3225
3226 if (opdsymend == secsymend)
3227 goto done;
3228
3229 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3230 relcount = (opd->flags & SEC_RELOC) ? opd->reloc_count : 0;
3231 if (relcount == 0)
3232 goto done;
3233
3234 if (!(*slurp_relocs) (abfd, opd, static_syms, FALSE))
3235 {
3236 count = -1;
3237 goto done;
3238 }
3239
3240 size = 0;
3241 for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3242 {
3243 asymbol *sym;
3244
3245 while (r < opd->relocation + relcount
3246 && r->address < syms[i]->value + opd->vma)
3247 ++r;
3248
3249 if (r == opd->relocation + relcount)
3250 break;
3251
3252 if (r->address != syms[i]->value + opd->vma)
3253 continue;
3254
3255 if (r->howto->type != R_PPC64_ADDR64)
3256 continue;
3257
3258 sym = *r->sym_ptr_ptr;
3259 if (!sym_exists_at (syms, opdsymend, symcount,
3260 sym->section->id, sym->value + r->addend))
3261 {
3262 ++count;
3263 size += sizeof (asymbol);
3264 size += strlen (syms[i]->name) + 2;
3265 }
3266 }
3267
3268 s = *ret = bfd_malloc (size);
3269 if (s == NULL)
3270 {
3271 count = -1;
3272 goto done;
3273 }
3274
3275 names = (char *) (s + count);
3276
3277 for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
3278 {
3279 asymbol *sym;
3280
3281 while (r < opd->relocation + relcount
3282 && r->address < syms[i]->value + opd->vma)
3283 ++r;
3284
3285 if (r == opd->relocation + relcount)
3286 break;
3287
3288 if (r->address != syms[i]->value + opd->vma)
3289 continue;
3290
3291 if (r->howto->type != R_PPC64_ADDR64)
3292 continue;
3293
3294 sym = *r->sym_ptr_ptr;
3295 if (!sym_exists_at (syms, opdsymend, symcount,
3296 sym->section->id, sym->value + r->addend))
3297 {
3298 size_t len;
3299
3300 *s = *syms[i];
3301 s->flags |= BSF_SYNTHETIC;
3302 s->section = sym->section;
3303 s->value = sym->value + r->addend;
3304 s->name = names;
3305 *names++ = '.';
3306 len = strlen (syms[i]->name);
3307 memcpy (names, syms[i]->name, len + 1);
3308 names += len + 1;
3309 /* Have udata.p point back to the original symbol this
3310 synthetic symbol was derived from. */
3311 s->udata.p = syms[i];
3312 s++;
3313 }
3314 }
3315 }
3316 else
3317 {
3318 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3319 bfd_byte *contents = NULL;
3320 size_t size;
3321 long plt_count = 0;
3322 bfd_vma glink_vma = 0, resolv_vma = 0;
3323 asection *dynamic, *glink = NULL, *relplt = NULL;
3324 arelent *p;
3325
3326 if (opd != NULL && !bfd_malloc_and_get_section (abfd, opd, &contents))
3327 {
3328 free_contents_and_exit:
3329 if (contents)
3330 free (contents);
3331 count = -1;
3332 goto done;
3333 }
3334
3335 size = 0;
3336 for (i = secsymend; i < opdsymend; ++i)
3337 {
3338 bfd_vma ent;
3339
3340 /* Ignore bogus symbols. */
3341 if (syms[i]->value > opd->size - 8)
3342 continue;
3343
3344 ent = bfd_get_64 (abfd, contents + syms[i]->value);
3345 if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3346 {
3347 ++count;
3348 size += sizeof (asymbol);
3349 size += strlen (syms[i]->name) + 2;
3350 }
3351 }
3352
3353 /* Get start of .glink stubs from DT_PPC64_GLINK. */
3354 if (dyn_count != 0
3355 && (dynamic = bfd_get_section_by_name (abfd, ".dynamic")) != NULL)
3356 {
3357 bfd_byte *dynbuf, *extdyn, *extdynend;
3358 size_t extdynsize;
3359 void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *);
3360
3361 if (!bfd_malloc_and_get_section (abfd, dynamic, &dynbuf))
3362 goto free_contents_and_exit;
3363
3364 extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
3365 swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
3366
3367 extdyn = dynbuf;
3368 extdynend = extdyn + dynamic->size;
3369 for (; extdyn < extdynend; extdyn += extdynsize)
3370 {
3371 Elf_Internal_Dyn dyn;
3372 (*swap_dyn_in) (abfd, extdyn, &dyn);
3373
3374 if (dyn.d_tag == DT_NULL)
3375 break;
3376
3377 if (dyn.d_tag == DT_PPC64_GLINK)
3378 {
3379 /* The first glink stub starts at offset 32; see
3380 comment in ppc64_elf_finish_dynamic_sections. */
3381 glink_vma = dyn.d_un.d_val + GLINK_CALL_STUB_SIZE - 8 * 4;
3382 /* The .glink section usually does not survive the final
3383 link; search for the section (usually .text) where the
3384 glink stubs now reside. */
3385 glink = bfd_sections_find_if (abfd, section_covers_vma,
3386 &glink_vma);
3387 break;
3388 }
3389 }
3390
3391 free (dynbuf);
3392 }
3393
3394 if (glink != NULL)
3395 {
3396 /* Determine __glink trampoline by reading the relative branch
3397 from the first glink stub. */
3398 bfd_byte buf[4];
3399 unsigned int off = 0;
3400
3401 while (bfd_get_section_contents (abfd, glink, buf,
3402 glink_vma + off - glink->vma, 4))
3403 {
3404 unsigned int insn = bfd_get_32 (abfd, buf);
3405 insn ^= B_DOT;
3406 if ((insn & ~0x3fffffc) == 0)
3407 {
3408 resolv_vma = glink_vma + off + (insn ^ 0x2000000) - 0x2000000;
3409 break;
3410 }
3411 off += 4;
3412 if (off > 4)
3413 break;
3414 }
3415
3416 if (resolv_vma)
3417 size += sizeof (asymbol) + sizeof ("__glink_PLTresolve");
3418
3419 relplt = bfd_get_section_by_name (abfd, ".rela.plt");
3420 if (relplt != NULL)
3421 {
3422 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3423 if (! (*slurp_relocs) (abfd, relplt, dyn_syms, TRUE))
3424 goto free_contents_and_exit;
3425
3426 plt_count = relplt->size / sizeof (Elf64_External_Rela);
3427 size += plt_count * sizeof (asymbol);
3428
3429 p = relplt->relocation;
3430 for (i = 0; i < plt_count; i++, p++)
3431 {
3432 size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
3433 if (p->addend != 0)
3434 size += sizeof ("+0x") - 1 + 16;
3435 }
3436 }
3437 }
3438
3439 s = *ret = bfd_malloc (size);
3440 if (s == NULL)
3441 goto free_contents_and_exit;
3442
3443 names = (char *) (s + count + plt_count + (resolv_vma != 0));
3444
3445 for (i = secsymend; i < opdsymend; ++i)
3446 {
3447 bfd_vma ent;
3448
3449 if (syms[i]->value > opd->size - 8)
3450 continue;
3451
3452 ent = bfd_get_64 (abfd, contents + syms[i]->value);
3453 if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3454 {
3455 long lo, hi;
3456 size_t len;
3457 asection *sec = abfd->sections;
3458
3459 *s = *syms[i];
3460 lo = codesecsym;
3461 hi = codesecsymend;
3462 while (lo < hi)
3463 {
3464 long mid = (lo + hi) >> 1;
3465 if (syms[mid]->section->vma < ent)
3466 lo = mid + 1;
3467 else if (syms[mid]->section->vma > ent)
3468 hi = mid;
3469 else
3470 {
3471 sec = syms[mid]->section;
3472 break;
3473 }
3474 }
3475
3476 if (lo >= hi && lo > codesecsym)
3477 sec = syms[lo - 1]->section;
3478
3479 for (; sec != NULL; sec = sec->next)
3480 {
3481 if (sec->vma > ent)
3482 break;
3483 /* SEC_LOAD may not be set if SEC is from a separate debug
3484 info file. */
3485 if ((sec->flags & SEC_ALLOC) == 0)
3486 break;
3487 if ((sec->flags & SEC_CODE) != 0)
3488 s->section = sec;
3489 }
3490 s->flags |= BSF_SYNTHETIC;
3491 s->value = ent - s->section->vma;
3492 s->name = names;
3493 *names++ = '.';
3494 len = strlen (syms[i]->name);
3495 memcpy (names, syms[i]->name, len + 1);
3496 names += len + 1;
3497 /* Have udata.p point back to the original symbol this
3498 synthetic symbol was derived from. */
3499 s->udata.p = syms[i];
3500 s++;
3501 }
3502 }
3503 free (contents);
3504
3505 if (glink != NULL && relplt != NULL)
3506 {
3507 if (resolv_vma)
3508 {
3509 /* Add a symbol for the main glink trampoline. */
3510 memset (s, 0, sizeof *s);
3511 s->the_bfd = abfd;
3512 s->flags = BSF_GLOBAL | BSF_SYNTHETIC;
3513 s->section = glink;
3514 s->value = resolv_vma - glink->vma;
3515 s->name = names;
3516 memcpy (names, "__glink_PLTresolve", sizeof ("__glink_PLTresolve"));
3517 names += sizeof ("__glink_PLTresolve");
3518 s++;
3519 count++;
3520 }
3521
3522 /* FIXME: It would be very much nicer to put sym@plt on the
3523 stub rather than on the glink branch table entry. The
3524 objdump disassembler would then use a sensible symbol
3525 name on plt calls. The difficulty in doing so is
3526 a) finding the stubs, and,
3527 b) matching stubs against plt entries, and,
3528 c) there can be multiple stubs for a given plt entry.
3529
3530 Solving (a) could be done by code scanning, but older
3531 ppc64 binaries used different stubs to current code.
3532 (b) is the tricky one since you need to known the toc
3533 pointer for at least one function that uses a pic stub to
3534 be able to calculate the plt address referenced.
3535 (c) means gdb would need to set multiple breakpoints (or
3536 find the glink branch itself) when setting breakpoints
3537 for pending shared library loads. */
3538 p = relplt->relocation;
3539 for (i = 0; i < plt_count; i++, p++)
3540 {
3541 size_t len;
3542
3543 *s = **p->sym_ptr_ptr;
3544 /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set. Since
3545 we are defining a symbol, ensure one of them is set. */
3546 if ((s->flags & BSF_LOCAL) == 0)
3547 s->flags |= BSF_GLOBAL;
3548 s->flags |= BSF_SYNTHETIC;
3549 s->section = glink;
3550 s->value = glink_vma - glink->vma;
3551 s->name = names;
3552 s->udata.p = NULL;
3553 len = strlen ((*p->sym_ptr_ptr)->name);
3554 memcpy (names, (*p->sym_ptr_ptr)->name, len);
3555 names += len;
3556 if (p->addend != 0)
3557 {
3558 memcpy (names, "+0x", sizeof ("+0x") - 1);
3559 names += sizeof ("+0x") - 1;
3560 bfd_sprintf_vma (abfd, names, p->addend);
3561 names += strlen (names);
3562 }
3563 memcpy (names, "@plt", sizeof ("@plt"));
3564 names += sizeof ("@plt");
3565 s++;
3566 if (abi < 2)
3567 {
3568 glink_vma += 8;
3569 if (i >= 0x8000)
3570 glink_vma += 4;
3571 }
3572 else
3573 glink_vma += 4;
3574 }
3575 count += plt_count;
3576 }
3577 }
3578
3579 done:
3580 free (syms);
3581 return count;
3582 }
3583 \f
3584 /* The following functions are specific to the ELF linker, while
3585 functions above are used generally. Those named ppc64_elf_* are
3586 called by the main ELF linker code. They appear in this file more
3587 or less in the order in which they are called. eg.
3588 ppc64_elf_check_relocs is called early in the link process,
3589 ppc64_elf_finish_dynamic_sections is one of the last functions
3590 called.
3591
3592 PowerPC64-ELF uses a similar scheme to PowerPC64-XCOFF in that
3593 functions have both a function code symbol and a function descriptor
3594 symbol. A call to foo in a relocatable object file looks like:
3595
3596 . .text
3597 . x:
3598 . bl .foo
3599 . nop
3600
3601 The function definition in another object file might be:
3602
3603 . .section .opd
3604 . foo: .quad .foo
3605 . .quad .TOC.@tocbase
3606 . .quad 0
3607 .
3608 . .text
3609 . .foo: blr
3610
3611 When the linker resolves the call during a static link, the branch
3612 unsurprisingly just goes to .foo and the .opd information is unused.
3613 If the function definition is in a shared library, things are a little
3614 different: The call goes via a plt call stub, the opd information gets
3615 copied to the plt, and the linker patches the nop.
3616
3617 . x:
3618 . bl .foo_stub
3619 . ld 2,40(1)
3620 .
3621 .
3622 . .foo_stub:
3623 . std 2,40(1) # in practice, the call stub
3624 . addis 11,2,Lfoo@toc@ha # is slightly optimized, but
3625 . addi 11,11,Lfoo@toc@l # this is the general idea
3626 . ld 12,0(11)
3627 . ld 2,8(11)
3628 . mtctr 12
3629 . ld 11,16(11)
3630 . bctr
3631 .
3632 . .section .plt
3633 . Lfoo: reloc (R_PPC64_JMP_SLOT, foo)
3634
3635 The "reloc ()" notation is supposed to indicate that the linker emits
3636 an R_PPC64_JMP_SLOT reloc against foo. The dynamic linker does the opd
3637 copying.
3638
3639 What are the difficulties here? Well, firstly, the relocations
3640 examined by the linker in check_relocs are against the function code
3641 sym .foo, while the dynamic relocation in the plt is emitted against
3642 the function descriptor symbol, foo. Somewhere along the line, we need
3643 to carefully copy dynamic link information from one symbol to the other.
3644 Secondly, the generic part of the elf linker will make .foo a dynamic
3645 symbol as is normal for most other backends. We need foo dynamic
3646 instead, at least for an application final link. However, when
3647 creating a shared library containing foo, we need to have both symbols
3648 dynamic so that references to .foo are satisfied during the early
3649 stages of linking. Otherwise the linker might decide to pull in a
3650 definition from some other object, eg. a static library.
3651
3652 Update: As of August 2004, we support a new convention. Function
3653 calls may use the function descriptor symbol, ie. "bl foo". This
3654 behaves exactly as "bl .foo". */
3655
3656 /* Of those relocs that might be copied as dynamic relocs, this function
3657 selects those that must be copied when linking a shared library,
3658 even when the symbol is local. */
3659
3660 static int
3661 must_be_dyn_reloc (struct bfd_link_info *info,
3662 enum elf_ppc64_reloc_type r_type)
3663 {
3664 switch (r_type)
3665 {
3666 default:
3667 return 1;
3668
3669 case R_PPC64_REL32:
3670 case R_PPC64_REL64:
3671 case R_PPC64_REL30:
3672 return 0;
3673
3674 case R_PPC64_TPREL16:
3675 case R_PPC64_TPREL16_LO:
3676 case R_PPC64_TPREL16_HI:
3677 case R_PPC64_TPREL16_HA:
3678 case R_PPC64_TPREL16_DS:
3679 case R_PPC64_TPREL16_LO_DS:
3680 case R_PPC64_TPREL16_HIGH:
3681 case R_PPC64_TPREL16_HIGHA:
3682 case R_PPC64_TPREL16_HIGHER:
3683 case R_PPC64_TPREL16_HIGHERA:
3684 case R_PPC64_TPREL16_HIGHEST:
3685 case R_PPC64_TPREL16_HIGHESTA:
3686 case R_PPC64_TPREL64:
3687 return !info->executable;
3688 }
3689 }
3690
3691 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
3692 copying dynamic variables from a shared lib into an app's dynbss
3693 section, and instead use a dynamic relocation to point into the
3694 shared lib. With code that gcc generates, it's vital that this be
3695 enabled; In the PowerPC64 ABI, the address of a function is actually
3696 the address of a function descriptor, which resides in the .opd
3697 section. gcc uses the descriptor directly rather than going via the
3698 GOT as some other ABI's do, which means that initialized function
3699 pointers must reference the descriptor. Thus, a function pointer
3700 initialized to the address of a function in a shared library will
3701 either require a copy reloc, or a dynamic reloc. Using a copy reloc
3702 redefines the function descriptor symbol to point to the copy. This
3703 presents a problem as a plt entry for that function is also
3704 initialized from the function descriptor symbol and the copy reloc
3705 may not be initialized first. */
3706 #define ELIMINATE_COPY_RELOCS 1
3707
3708 /* Section name for stubs is the associated section name plus this
3709 string. */
3710 #define STUB_SUFFIX ".stub"
3711
3712 /* Linker stubs.
3713 ppc_stub_long_branch:
3714 Used when a 14 bit branch (or even a 24 bit branch) can't reach its
3715 destination, but a 24 bit branch in a stub section will reach.
3716 . b dest
3717
3718 ppc_stub_plt_branch:
3719 Similar to the above, but a 24 bit branch in the stub section won't
3720 reach its destination.
3721 . addis %r11,%r2,xxx@toc@ha
3722 . ld %r12,xxx@toc@l(%r11)
3723 . mtctr %r12
3724 . bctr
3725
3726 ppc_stub_plt_call:
3727 Used to call a function in a shared library. If it so happens that
3728 the plt entry referenced crosses a 64k boundary, then an extra
3729 "addi %r11,%r11,xxx@toc@l" will be inserted before the "mtctr".
3730 . std %r2,40(%r1)
3731 . addis %r11,%r2,xxx@toc@ha
3732 . ld %r12,xxx+0@toc@l(%r11)
3733 . mtctr %r12
3734 . ld %r2,xxx+8@toc@l(%r11)
3735 . ld %r11,xxx+16@toc@l(%r11)
3736 . bctr
3737
3738 ppc_stub_long_branch and ppc_stub_plt_branch may also have additional
3739 code to adjust the value and save r2 to support multiple toc sections.
3740 A ppc_stub_long_branch with an r2 offset looks like:
3741 . std %r2,40(%r1)
3742 . addis %r2,%r2,off@ha
3743 . addi %r2,%r2,off@l
3744 . b dest
3745
3746 A ppc_stub_plt_branch with an r2 offset looks like:
3747 . std %r2,40(%r1)
3748 . addis %r11,%r2,xxx@toc@ha
3749 . ld %r12,xxx@toc@l(%r11)
3750 . addis %r2,%r2,off@ha
3751 . addi %r2,%r2,off@l
3752 . mtctr %r12
3753 . bctr
3754
3755 In cases where the "addis" instruction would add zero, the "addis" is
3756 omitted and following instructions modified slightly in some cases.
3757 */
3758
3759 enum ppc_stub_type {
3760 ppc_stub_none,
3761 ppc_stub_long_branch,
3762 ppc_stub_long_branch_r2off,
3763 ppc_stub_plt_branch,
3764 ppc_stub_plt_branch_r2off,
3765 ppc_stub_plt_call,
3766 ppc_stub_plt_call_r2save
3767 };
3768
3769 struct ppc_stub_hash_entry {
3770
3771 /* Base hash table entry structure. */
3772 struct bfd_hash_entry root;
3773
3774 enum ppc_stub_type stub_type;
3775
3776 /* The stub section. */
3777 asection *stub_sec;
3778
3779 /* Offset within stub_sec of the beginning of this stub. */
3780 bfd_vma stub_offset;
3781
3782 /* Given the symbol's value and its section we can determine its final
3783 value when building the stubs (so the stub knows where to jump. */
3784 bfd_vma target_value;
3785 asection *target_section;
3786
3787 /* The symbol table entry, if any, that this was derived from. */
3788 struct ppc_link_hash_entry *h;
3789 struct plt_entry *plt_ent;
3790
3791 /* Where this stub is being called from, or, in the case of combined
3792 stub sections, the first input section in the group. */
3793 asection *id_sec;
3794
3795 /* Symbol st_other. */
3796 unsigned char other;
3797 };
3798
3799 struct ppc_branch_hash_entry {
3800
3801 /* Base hash table entry structure. */
3802 struct bfd_hash_entry root;
3803
3804 /* Offset within branch lookup table. */
3805 unsigned int offset;
3806
3807 /* Generation marker. */
3808 unsigned int iter;
3809 };
3810
3811 /* Used to track dynamic relocations for local symbols. */
3812 struct ppc_dyn_relocs
3813 {
3814 struct ppc_dyn_relocs *next;
3815
3816 /* The input section of the reloc. */
3817 asection *sec;
3818
3819 /* Total number of relocs copied for the input section. */
3820 unsigned int count : 31;
3821
3822 /* Whether this entry is for STT_GNU_IFUNC symbols. */
3823 unsigned int ifunc : 1;
3824 };
3825
3826 struct ppc_link_hash_entry
3827 {
3828 struct elf_link_hash_entry elf;
3829
3830 union {
3831 /* A pointer to the most recently used stub hash entry against this
3832 symbol. */
3833 struct ppc_stub_hash_entry *stub_cache;
3834
3835 /* A pointer to the next symbol starting with a '.' */
3836 struct ppc_link_hash_entry *next_dot_sym;
3837 } u;
3838
3839 /* Track dynamic relocs copied for this symbol. */
3840 struct elf_dyn_relocs *dyn_relocs;
3841
3842 /* Link between function code and descriptor symbols. */
3843 struct ppc_link_hash_entry *oh;
3844
3845 /* Flag function code and descriptor symbols. */
3846 unsigned int is_func:1;
3847 unsigned int is_func_descriptor:1;
3848 unsigned int fake:1;
3849
3850 /* Whether global opd/toc sym has been adjusted or not.
3851 After ppc64_elf_edit_opd/ppc64_elf_edit_toc has run, this flag
3852 should be set for all globals defined in any opd/toc section. */
3853 unsigned int adjust_done:1;
3854
3855 /* Set if we twiddled this symbol to weak at some stage. */
3856 unsigned int was_undefined:1;
3857
3858 /* Contexts in which symbol is used in the GOT (or TOC).
3859 TLS_GD .. TLS_EXPLICIT bits are or'd into the mask as the
3860 corresponding relocs are encountered during check_relocs.
3861 tls_optimize clears TLS_GD .. TLS_TPREL when optimizing to
3862 indicate the corresponding GOT entry type is not needed.
3863 tls_optimize may also set TLS_TPRELGD when a GD reloc turns into
3864 a TPREL one. We use a separate flag rather than setting TPREL
3865 just for convenience in distinguishing the two cases. */
3866 #define TLS_GD 1 /* GD reloc. */
3867 #define TLS_LD 2 /* LD reloc. */
3868 #define TLS_TPREL 4 /* TPREL reloc, => IE. */
3869 #define TLS_DTPREL 8 /* DTPREL reloc, => LD. */
3870 #define TLS_TLS 16 /* Any TLS reloc. */
3871 #define TLS_EXPLICIT 32 /* Marks TOC section TLS relocs. */
3872 #define TLS_TPRELGD 64 /* TPREL reloc resulting from GD->IE. */
3873 #define PLT_IFUNC 128 /* STT_GNU_IFUNC. */
3874 unsigned char tls_mask;
3875 };
3876
3877 /* ppc64 ELF linker hash table. */
3878
3879 struct ppc_link_hash_table
3880 {
3881 struct elf_link_hash_table elf;
3882
3883 /* The stub hash table. */
3884 struct bfd_hash_table stub_hash_table;
3885
3886 /* Another hash table for plt_branch stubs. */
3887 struct bfd_hash_table branch_hash_table;
3888
3889 /* Hash table for function prologue tocsave. */
3890 htab_t tocsave_htab;
3891
3892 /* Various options and other info passed from the linker. */
3893 struct ppc64_elf_params *params;
3894
3895 /* Array to keep track of which stub sections have been created, and
3896 information on stub grouping. */
3897 struct map_stub {
3898 /* This is the section to which stubs in the group will be attached. */
3899 asection *link_sec;
3900 /* The stub section. */
3901 asection *stub_sec;
3902 /* Along with elf_gp, specifies the TOC pointer used in this group. */
3903 bfd_vma toc_off;
3904 } *stub_group;
3905
3906 /* Temp used when calculating TOC pointers. */
3907 bfd_vma toc_curr;
3908 bfd *toc_bfd;
3909 asection *toc_first_sec;
3910
3911 /* Highest input section id. */
3912 int top_id;
3913
3914 /* Highest output section index. */
3915 int top_index;
3916
3917 /* Used when adding symbols. */
3918 struct ppc_link_hash_entry *dot_syms;
3919
3920 /* List of input sections for each output section. */
3921 asection **input_list;
3922
3923 /* Shortcuts to get to dynamic linker sections. */
3924 asection *dynbss;
3925 asection *relbss;
3926 asection *glink;
3927 asection *sfpr;
3928 asection *brlt;
3929 asection *relbrlt;
3930 asection *glink_eh_frame;
3931
3932 /* Shortcut to .__tls_get_addr and __tls_get_addr. */
3933 struct ppc_link_hash_entry *tls_get_addr;
3934 struct ppc_link_hash_entry *tls_get_addr_fd;
3935
3936 /* The size of reliplt used by got entry relocs. */
3937 bfd_size_type got_reli_size;
3938
3939 /* Statistics. */
3940 unsigned long stub_count[ppc_stub_plt_call_r2save];
3941
3942 /* Number of stubs against global syms. */
3943 unsigned long stub_globals;
3944
3945 /* Set if we're linking code with function descriptors. */
3946 unsigned int opd_abi:1;
3947
3948 /* Support for multiple toc sections. */
3949 unsigned int do_multi_toc:1;
3950 unsigned int multi_toc_needed:1;
3951 unsigned int second_toc_pass:1;
3952 unsigned int do_toc_opt:1;
3953
3954 /* Set on error. */
3955 unsigned int stub_error:1;
3956
3957 /* Temp used by ppc64_elf_process_dot_syms. */
3958 unsigned int twiddled_syms:1;
3959
3960 /* Incremented every time we size stubs. */
3961 unsigned int stub_iteration;
3962
3963 /* Small local sym cache. */
3964 struct sym_cache sym_cache;
3965 };
3966
3967 /* Rename some of the generic section flags to better document how they
3968 are used here. */
3969
3970 /* Nonzero if this section has TLS related relocations. */
3971 #define has_tls_reloc sec_flg0
3972
3973 /* Nonzero if this section has a call to __tls_get_addr. */
3974 #define has_tls_get_addr_call sec_flg1
3975
3976 /* Nonzero if this section has any toc or got relocs. */
3977 #define has_toc_reloc sec_flg2
3978
3979 /* Nonzero if this section has a call to another section that uses
3980 the toc or got. */
3981 #define makes_toc_func_call sec_flg3
3982
3983 /* Recursion protection when determining above flag. */
3984 #define call_check_in_progress sec_flg4
3985 #define call_check_done sec_flg5
3986
3987 /* Get the ppc64 ELF linker hash table from a link_info structure. */
3988
3989 #define ppc_hash_table(p) \
3990 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
3991 == PPC64_ELF_DATA ? ((struct ppc_link_hash_table *) ((p)->hash)) : NULL)
3992
3993 #define ppc_stub_hash_lookup(table, string, create, copy) \
3994 ((struct ppc_stub_hash_entry *) \
3995 bfd_hash_lookup ((table), (string), (create), (copy)))
3996
3997 #define ppc_branch_hash_lookup(table, string, create, copy) \
3998 ((struct ppc_branch_hash_entry *) \
3999 bfd_hash_lookup ((table), (string), (create), (copy)))
4000
4001 /* Create an entry in the stub hash table. */
4002
4003 static struct bfd_hash_entry *
4004 stub_hash_newfunc (struct bfd_hash_entry *entry,
4005 struct bfd_hash_table *table,
4006 const char *string)
4007 {
4008 /* Allocate the structure if it has not already been allocated by a
4009 subclass. */
4010 if (entry == NULL)
4011 {
4012 entry = bfd_hash_allocate (table, sizeof (struct ppc_stub_hash_entry));
4013 if (entry == NULL)
4014 return entry;
4015 }
4016
4017 /* Call the allocation method of the superclass. */
4018 entry = bfd_hash_newfunc (entry, table, string);
4019 if (entry != NULL)
4020 {
4021 struct ppc_stub_hash_entry *eh;
4022
4023 /* Initialize the local fields. */
4024 eh = (struct ppc_stub_hash_entry *) entry;
4025 eh->stub_type = ppc_stub_none;
4026 eh->stub_sec = NULL;
4027 eh->stub_offset = 0;
4028 eh->target_value = 0;
4029 eh->target_section = NULL;
4030 eh->h = NULL;
4031 eh->plt_ent = NULL;
4032 eh->id_sec = NULL;
4033 eh->other = 0;
4034 }
4035
4036 return entry;
4037 }
4038
4039 /* Create an entry in the branch hash table. */
4040
4041 static struct bfd_hash_entry *
4042 branch_hash_newfunc (struct bfd_hash_entry *entry,
4043 struct bfd_hash_table *table,
4044 const char *string)
4045 {
4046 /* Allocate the structure if it has not already been allocated by a
4047 subclass. */
4048 if (entry == NULL)
4049 {
4050 entry = bfd_hash_allocate (table, sizeof (struct ppc_branch_hash_entry));
4051 if (entry == NULL)
4052 return entry;
4053 }
4054
4055 /* Call the allocation method of the superclass. */
4056 entry = bfd_hash_newfunc (entry, table, string);
4057 if (entry != NULL)
4058 {
4059 struct ppc_branch_hash_entry *eh;
4060
4061 /* Initialize the local fields. */
4062 eh = (struct ppc_branch_hash_entry *) entry;
4063 eh->offset = 0;
4064 eh->iter = 0;
4065 }
4066
4067 return entry;
4068 }
4069
4070 /* Create an entry in a ppc64 ELF linker hash table. */
4071
4072 static struct bfd_hash_entry *
4073 link_hash_newfunc (struct bfd_hash_entry *entry,
4074 struct bfd_hash_table *table,
4075 const char *string)
4076 {
4077 /* Allocate the structure if it has not already been allocated by a
4078 subclass. */
4079 if (entry == NULL)
4080 {
4081 entry = bfd_hash_allocate (table, sizeof (struct ppc_link_hash_entry));
4082 if (entry == NULL)
4083 return entry;
4084 }
4085
4086 /* Call the allocation method of the superclass. */
4087 entry = _bfd_elf_link_hash_newfunc (entry, table, string);
4088 if (entry != NULL)
4089 {
4090 struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) entry;
4091
4092 memset (&eh->u.stub_cache, 0,
4093 (sizeof (struct ppc_link_hash_entry)
4094 - offsetof (struct ppc_link_hash_entry, u.stub_cache)));
4095
4096 /* When making function calls, old ABI code references function entry
4097 points (dot symbols), while new ABI code references the function
4098 descriptor symbol. We need to make any combination of reference and
4099 definition work together, without breaking archive linking.
4100
4101 For a defined function "foo" and an undefined call to "bar":
4102 An old object defines "foo" and ".foo", references ".bar" (possibly
4103 "bar" too).
4104 A new object defines "foo" and references "bar".
4105
4106 A new object thus has no problem with its undefined symbols being
4107 satisfied by definitions in an old object. On the other hand, the
4108 old object won't have ".bar" satisfied by a new object.
4109
4110 Keep a list of newly added dot-symbols. */
4111
4112 if (string[0] == '.')
4113 {
4114 struct ppc_link_hash_table *htab;
4115
4116 htab = (struct ppc_link_hash_table *) table;
4117 eh->u.next_dot_sym = htab->dot_syms;
4118 htab->dot_syms = eh;
4119 }
4120 }
4121
4122 return entry;
4123 }
4124
4125 struct tocsave_entry {
4126 asection *sec;
4127 bfd_vma offset;
4128 };
4129
4130 static hashval_t
4131 tocsave_htab_hash (const void *p)
4132 {
4133 const struct tocsave_entry *e = (const struct tocsave_entry *) p;
4134 return ((bfd_vma)(intptr_t) e->sec ^ e->offset) >> 3;
4135 }
4136
4137 static int
4138 tocsave_htab_eq (const void *p1, const void *p2)
4139 {
4140 const struct tocsave_entry *e1 = (const struct tocsave_entry *) p1;
4141 const struct tocsave_entry *e2 = (const struct tocsave_entry *) p2;
4142 return e1->sec == e2->sec && e1->offset == e2->offset;
4143 }
4144
4145 /* Create a ppc64 ELF linker hash table. */
4146
4147 static struct bfd_link_hash_table *
4148 ppc64_elf_link_hash_table_create (bfd *abfd)
4149 {
4150 struct ppc_link_hash_table *htab;
4151 bfd_size_type amt = sizeof (struct ppc_link_hash_table);
4152
4153 htab = bfd_zmalloc (amt);
4154 if (htab == NULL)
4155 return NULL;
4156
4157 if (!_bfd_elf_link_hash_table_init (&htab->elf, abfd, link_hash_newfunc,
4158 sizeof (struct ppc_link_hash_entry),
4159 PPC64_ELF_DATA))
4160 {
4161 free (htab);
4162 return NULL;
4163 }
4164
4165 /* Init the stub hash table too. */
4166 if (!bfd_hash_table_init (&htab->stub_hash_table, stub_hash_newfunc,
4167 sizeof (struct ppc_stub_hash_entry)))
4168 {
4169 _bfd_elf_link_hash_table_free ((struct bfd_link_hash_table *) htab);
4170 return NULL;
4171 }
4172
4173 /* And the branch hash table. */
4174 if (!bfd_hash_table_init (&htab->branch_hash_table, branch_hash_newfunc,
4175 sizeof (struct ppc_branch_hash_entry)))
4176 {
4177 bfd_hash_table_free (&htab->stub_hash_table);
4178 _bfd_elf_link_hash_table_free ((struct bfd_link_hash_table *) htab);
4179 return NULL;
4180 }
4181
4182 htab->tocsave_htab = htab_try_create (1024,
4183 tocsave_htab_hash,
4184 tocsave_htab_eq,
4185 NULL);
4186 if (htab->tocsave_htab == NULL)
4187 {
4188 bfd_hash_table_free (&htab->branch_hash_table);
4189 bfd_hash_table_free (&htab->stub_hash_table);
4190 _bfd_elf_link_hash_table_free ((struct bfd_link_hash_table *) htab);
4191 return NULL;
4192 }
4193
4194 /* Initializing two fields of the union is just cosmetic. We really
4195 only care about glist, but when compiled on a 32-bit host the
4196 bfd_vma fields are larger. Setting the bfd_vma to zero makes
4197 debugger inspection of these fields look nicer. */
4198 htab->elf.init_got_refcount.refcount = 0;
4199 htab->elf.init_got_refcount.glist = NULL;
4200 htab->elf.init_plt_refcount.refcount = 0;
4201 htab->elf.init_plt_refcount.glist = NULL;
4202 htab->elf.init_got_offset.offset = 0;
4203 htab->elf.init_got_offset.glist = NULL;
4204 htab->elf.init_plt_offset.offset = 0;
4205 htab->elf.init_plt_offset.glist = NULL;
4206
4207 return &htab->elf.root;
4208 }
4209
4210 /* Free the derived linker hash table. */
4211
4212 static void
4213 ppc64_elf_link_hash_table_free (struct bfd_link_hash_table *hash)
4214 {
4215 struct ppc_link_hash_table *htab = (struct ppc_link_hash_table *) hash;
4216
4217 bfd_hash_table_free (&htab->stub_hash_table);
4218 bfd_hash_table_free (&htab->branch_hash_table);
4219 if (htab->tocsave_htab)
4220 htab_delete (htab->tocsave_htab);
4221 _bfd_elf_link_hash_table_free (hash);
4222 }
4223
4224 /* Create sections for linker generated code. */
4225
4226 static bfd_boolean
4227 create_linkage_sections (bfd *dynobj, struct bfd_link_info *info)
4228 {
4229 struct ppc_link_hash_table *htab;
4230 flagword flags;
4231
4232 htab = ppc_hash_table (info);
4233
4234 /* Create .sfpr for code to save and restore fp regs. */
4235 flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY
4236 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4237 htab->sfpr = bfd_make_section_anyway_with_flags (dynobj, ".sfpr",
4238 flags);
4239 if (htab->sfpr == NULL
4240 || ! bfd_set_section_alignment (dynobj, htab->sfpr, 2))
4241 return FALSE;
4242
4243 /* Create .glink for lazy dynamic linking support. */
4244 htab->glink = bfd_make_section_anyway_with_flags (dynobj, ".glink",
4245 flags);
4246 if (htab->glink == NULL
4247 || ! bfd_set_section_alignment (dynobj, htab->glink, 3))
4248 return FALSE;
4249
4250 if (!info->no_ld_generated_unwind_info)
4251 {
4252 flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_HAS_CONTENTS
4253 | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4254 htab->glink_eh_frame = bfd_make_section_anyway_with_flags (dynobj,
4255 ".eh_frame",
4256 flags);
4257 if (htab->glink_eh_frame == NULL
4258 || !bfd_set_section_alignment (dynobj, htab->glink_eh_frame, 2))
4259 return FALSE;
4260 }
4261
4262 flags = SEC_ALLOC | SEC_LINKER_CREATED;
4263 htab->elf.iplt = bfd_make_section_anyway_with_flags (dynobj, ".iplt", flags);
4264 if (htab->elf.iplt == NULL
4265 || ! bfd_set_section_alignment (dynobj, htab->elf.iplt, 3))
4266 return FALSE;
4267
4268 flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4269 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4270 htab->elf.irelplt
4271 = bfd_make_section_anyway_with_flags (dynobj, ".rela.iplt", flags);
4272 if (htab->elf.irelplt == NULL
4273 || ! bfd_set_section_alignment (dynobj, htab->elf.irelplt, 3))
4274 return FALSE;
4275
4276 /* Create branch lookup table for plt_branch stubs. */
4277 flags = (SEC_ALLOC | SEC_LOAD
4278 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4279 htab->brlt = bfd_make_section_anyway_with_flags (dynobj, ".branch_lt",
4280 flags);
4281 if (htab->brlt == NULL
4282 || ! bfd_set_section_alignment (dynobj, htab->brlt, 3))
4283 return FALSE;
4284
4285 if (!info->shared)
4286 return TRUE;
4287
4288 flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4289 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4290 htab->relbrlt = bfd_make_section_anyway_with_flags (dynobj,
4291 ".rela.branch_lt",
4292 flags);
4293 if (htab->relbrlt == NULL
4294 || ! bfd_set_section_alignment (dynobj, htab->relbrlt, 3))
4295 return FALSE;
4296
4297 return TRUE;
4298 }
4299
4300 /* Satisfy the ELF linker by filling in some fields in our fake bfd. */
4301
4302 bfd_boolean
4303 ppc64_elf_init_stub_bfd (struct bfd_link_info *info,
4304 struct ppc64_elf_params *params)
4305 {
4306 struct ppc_link_hash_table *htab;
4307
4308 elf_elfheader (params->stub_bfd)->e_ident[EI_CLASS] = ELFCLASS64;
4309
4310 /* Always hook our dynamic sections into the first bfd, which is the
4311 linker created stub bfd. This ensures that the GOT header is at
4312 the start of the output TOC section. */
4313 htab = ppc_hash_table (info);
4314 if (htab == NULL)
4315 return FALSE;
4316 htab->elf.dynobj = params->stub_bfd;
4317 htab->params = params;
4318
4319 if (info->relocatable)
4320 return TRUE;
4321
4322 return create_linkage_sections (htab->elf.dynobj, info);
4323 }
4324
4325 /* Build a name for an entry in the stub hash table. */
4326
4327 static char *
4328 ppc_stub_name (const asection *input_section,
4329 const asection *sym_sec,
4330 const struct ppc_link_hash_entry *h,
4331 const Elf_Internal_Rela *rel)
4332 {
4333 char *stub_name;
4334 ssize_t len;
4335
4336 /* rel->r_addend is actually 64 bit, but who uses more than +/- 2^31
4337 offsets from a sym as a branch target? In fact, we could
4338 probably assume the addend is always zero. */
4339 BFD_ASSERT (((int) rel->r_addend & 0xffffffff) == rel->r_addend);
4340
4341 if (h)
4342 {
4343 len = 8 + 1 + strlen (h->elf.root.root.string) + 1 + 8 + 1;
4344 stub_name = bfd_malloc (len);
4345 if (stub_name == NULL)
4346 return stub_name;
4347
4348 len = sprintf (stub_name, "%08x.%s+%x",
4349 input_section->id & 0xffffffff,
4350 h->elf.root.root.string,
4351 (int) rel->r_addend & 0xffffffff);
4352 }
4353 else
4354 {
4355 len = 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1;
4356 stub_name = bfd_malloc (len);
4357 if (stub_name == NULL)
4358 return stub_name;
4359
4360 len = sprintf (stub_name, "%08x.%x:%x+%x",
4361 input_section->id & 0xffffffff,
4362 sym_sec->id & 0xffffffff,
4363 (int) ELF64_R_SYM (rel->r_info) & 0xffffffff,
4364 (int) rel->r_addend & 0xffffffff);
4365 }
4366 if (len > 2 && stub_name[len - 2] == '+' && stub_name[len - 1] == '0')
4367 stub_name[len - 2] = 0;
4368 return stub_name;
4369 }
4370
4371 /* Look up an entry in the stub hash. Stub entries are cached because
4372 creating the stub name takes a bit of time. */
4373
4374 static struct ppc_stub_hash_entry *
4375 ppc_get_stub_entry (const asection *input_section,
4376 const asection *sym_sec,
4377 struct ppc_link_hash_entry *h,
4378 const Elf_Internal_Rela *rel,
4379 struct ppc_link_hash_table *htab)
4380 {
4381 struct ppc_stub_hash_entry *stub_entry;
4382 const asection *id_sec;
4383
4384 /* If this input section is part of a group of sections sharing one
4385 stub section, then use the id of the first section in the group.
4386 Stub names need to include a section id, as there may well be
4387 more than one stub used to reach say, printf, and we need to
4388 distinguish between them. */
4389 id_sec = htab->stub_group[input_section->id].link_sec;
4390
4391 if (h != NULL && h->u.stub_cache != NULL
4392 && h->u.stub_cache->h == h
4393 && h->u.stub_cache->id_sec == id_sec)
4394 {
4395 stub_entry = h->u.stub_cache;
4396 }
4397 else
4398 {
4399 char *stub_name;
4400
4401 stub_name = ppc_stub_name (id_sec, sym_sec, h, rel);
4402 if (stub_name == NULL)
4403 return NULL;
4404
4405 stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
4406 stub_name, FALSE, FALSE);
4407 if (h != NULL)
4408 h->u.stub_cache = stub_entry;
4409
4410 free (stub_name);
4411 }
4412
4413 return stub_entry;
4414 }
4415
4416 /* Add a new stub entry to the stub hash. Not all fields of the new
4417 stub entry are initialised. */
4418
4419 static struct ppc_stub_hash_entry *
4420 ppc_add_stub (const char *stub_name,
4421 asection *section,
4422 struct bfd_link_info *info)
4423 {
4424 struct ppc_link_hash_table *htab = ppc_hash_table (info);
4425 asection *link_sec;
4426 asection *stub_sec;
4427 struct ppc_stub_hash_entry *stub_entry;
4428
4429 link_sec = htab->stub_group[section->id].link_sec;
4430 stub_sec = htab->stub_group[section->id].stub_sec;
4431 if (stub_sec == NULL)
4432 {
4433 stub_sec = htab->stub_group[link_sec->id].stub_sec;
4434 if (stub_sec == NULL)
4435 {
4436 size_t namelen;
4437 bfd_size_type len;
4438 char *s_name;
4439
4440 namelen = strlen (link_sec->name);
4441 len = namelen + sizeof (STUB_SUFFIX);
4442 s_name = bfd_alloc (htab->params->stub_bfd, len);
4443 if (s_name == NULL)
4444 return NULL;
4445
4446 memcpy (s_name, link_sec->name, namelen);
4447 memcpy (s_name + namelen, STUB_SUFFIX, sizeof (STUB_SUFFIX));
4448 stub_sec = (*htab->params->add_stub_section) (s_name, link_sec);
4449 if (stub_sec == NULL)
4450 return NULL;
4451 htab->stub_group[link_sec->id].stub_sec = stub_sec;
4452 }
4453 htab->stub_group[section->id].stub_sec = stub_sec;
4454 }
4455
4456 /* Enter this entry into the linker stub hash table. */
4457 stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table, stub_name,
4458 TRUE, FALSE);
4459 if (stub_entry == NULL)
4460 {
4461 info->callbacks->einfo (_("%P: %B: cannot create stub entry %s\n"),
4462 section->owner, stub_name);
4463 return NULL;
4464 }
4465
4466 stub_entry->stub_sec = stub_sec;
4467 stub_entry->stub_offset = 0;
4468 stub_entry->id_sec = link_sec;
4469 return stub_entry;
4470 }
4471
4472 /* Create .got and .rela.got sections in ABFD, and .got in dynobj if
4473 not already done. */
4474
4475 static bfd_boolean
4476 create_got_section (bfd *abfd, struct bfd_link_info *info)
4477 {
4478 asection *got, *relgot;
4479 flagword flags;
4480 struct ppc_link_hash_table *htab = ppc_hash_table (info);
4481
4482 if (!is_ppc64_elf (abfd))
4483 return FALSE;
4484 if (htab == NULL)
4485 return FALSE;
4486
4487 if (!htab->elf.sgot
4488 && !_bfd_elf_create_got_section (htab->elf.dynobj, info))
4489 return FALSE;
4490
4491 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
4492 | SEC_LINKER_CREATED);
4493
4494 got = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
4495 if (!got
4496 || !bfd_set_section_alignment (abfd, got, 3))
4497 return FALSE;
4498
4499 relgot = bfd_make_section_anyway_with_flags (abfd, ".rela.got",
4500 flags | SEC_READONLY);
4501 if (!relgot
4502 || ! bfd_set_section_alignment (abfd, relgot, 3))
4503 return FALSE;
4504
4505 ppc64_elf_tdata (abfd)->got = got;
4506 ppc64_elf_tdata (abfd)->relgot = relgot;
4507 return TRUE;
4508 }
4509
4510 /* Create the dynamic sections, and set up shortcuts. */
4511
4512 static bfd_boolean
4513 ppc64_elf_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
4514 {
4515 struct ppc_link_hash_table *htab;
4516
4517 if (!_bfd_elf_create_dynamic_sections (dynobj, info))
4518 return FALSE;
4519
4520 htab = ppc_hash_table (info);
4521 if (htab == NULL)
4522 return FALSE;
4523
4524 htab->dynbss = bfd_get_linker_section (dynobj, ".dynbss");
4525 if (!info->shared)
4526 htab->relbss = bfd_get_linker_section (dynobj, ".rela.bss");
4527
4528 if (!htab->elf.sgot || !htab->elf.splt || !htab->elf.srelplt || !htab->dynbss
4529 || (!info->shared && !htab->relbss))
4530 abort ();
4531
4532 return TRUE;
4533 }
4534
4535 /* Follow indirect and warning symbol links. */
4536
4537 static inline struct bfd_link_hash_entry *
4538 follow_link (struct bfd_link_hash_entry *h)
4539 {
4540 while (h->type == bfd_link_hash_indirect
4541 || h->type == bfd_link_hash_warning)
4542 h = h->u.i.link;
4543 return h;
4544 }
4545
4546 static inline struct elf_link_hash_entry *
4547 elf_follow_link (struct elf_link_hash_entry *h)
4548 {
4549 return (struct elf_link_hash_entry *) follow_link (&h->root);
4550 }
4551
4552 static inline struct ppc_link_hash_entry *
4553 ppc_follow_link (struct ppc_link_hash_entry *h)
4554 {
4555 return (struct ppc_link_hash_entry *) follow_link (&h->elf.root);
4556 }
4557
4558 /* Merge PLT info on FROM with that on TO. */
4559
4560 static void
4561 move_plt_plist (struct ppc_link_hash_entry *from,
4562 struct ppc_link_hash_entry *to)
4563 {
4564 if (from->elf.plt.plist != NULL)
4565 {
4566 if (to->elf.plt.plist != NULL)
4567 {
4568 struct plt_entry **entp;
4569 struct plt_entry *ent;
4570
4571 for (entp = &from->elf.plt.plist; (ent = *entp) != NULL; )
4572 {
4573 struct plt_entry *dent;
4574
4575 for (dent = to->elf.plt.plist; dent != NULL; dent = dent->next)
4576 if (dent->addend == ent->addend)
4577 {
4578 dent->plt.refcount += ent->plt.refcount;
4579 *entp = ent->next;
4580 break;
4581 }
4582 if (dent == NULL)
4583 entp = &ent->next;
4584 }
4585 *entp = to->elf.plt.plist;
4586 }
4587
4588 to->elf.plt.plist = from->elf.plt.plist;
4589 from->elf.plt.plist = NULL;
4590 }
4591 }
4592
4593 /* Copy the extra info we tack onto an elf_link_hash_entry. */
4594
4595 static void
4596 ppc64_elf_copy_indirect_symbol (struct bfd_link_info *info,
4597 struct elf_link_hash_entry *dir,
4598 struct elf_link_hash_entry *ind)
4599 {
4600 struct ppc_link_hash_entry *edir, *eind;
4601
4602 edir = (struct ppc_link_hash_entry *) dir;
4603 eind = (struct ppc_link_hash_entry *) ind;
4604
4605 edir->is_func |= eind->is_func;
4606 edir->is_func_descriptor |= eind->is_func_descriptor;
4607 edir->tls_mask |= eind->tls_mask;
4608 if (eind->oh != NULL)
4609 edir->oh = ppc_follow_link (eind->oh);
4610
4611 /* If called to transfer flags for a weakdef during processing
4612 of elf_adjust_dynamic_symbol, don't copy NON_GOT_REF.
4613 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
4614 if (!(ELIMINATE_COPY_RELOCS
4615 && eind->elf.root.type != bfd_link_hash_indirect
4616 && edir->elf.dynamic_adjusted))
4617 edir->elf.non_got_ref |= eind->elf.non_got_ref;
4618
4619 edir->elf.ref_dynamic |= eind->elf.ref_dynamic;
4620 edir->elf.ref_regular |= eind->elf.ref_regular;
4621 edir->elf.ref_regular_nonweak |= eind->elf.ref_regular_nonweak;
4622 edir->elf.needs_plt |= eind->elf.needs_plt;
4623 edir->elf.pointer_equality_needed |= eind->elf.pointer_equality_needed;
4624
4625 /* Copy over any dynamic relocs we may have on the indirect sym. */
4626 if (eind->dyn_relocs != NULL)
4627 {
4628 if (edir->dyn_relocs != NULL)
4629 {
4630 struct elf_dyn_relocs **pp;
4631 struct elf_dyn_relocs *p;
4632
4633 /* Add reloc counts against the indirect sym to the direct sym
4634 list. Merge any entries against the same section. */
4635 for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
4636 {
4637 struct elf_dyn_relocs *q;
4638
4639 for (q = edir->dyn_relocs; q != NULL; q = q->next)
4640 if (q->sec == p->sec)
4641 {
4642 q->pc_count += p->pc_count;
4643 q->count += p->count;
4644 *pp = p->next;
4645 break;
4646 }
4647 if (q == NULL)
4648 pp = &p->next;
4649 }
4650 *pp = edir->dyn_relocs;
4651 }
4652
4653 edir->dyn_relocs = eind->dyn_relocs;
4654 eind->dyn_relocs = NULL;
4655 }
4656
4657 /* If we were called to copy over info for a weak sym, that's all.
4658 You might think dyn_relocs need not be copied over; After all,
4659 both syms will be dynamic or both non-dynamic so we're just
4660 moving reloc accounting around. However, ELIMINATE_COPY_RELOCS
4661 code in ppc64_elf_adjust_dynamic_symbol needs to check for
4662 dyn_relocs in read-only sections, and it does so on what is the
4663 DIR sym here. */
4664 if (eind->elf.root.type != bfd_link_hash_indirect)
4665 return;
4666
4667 /* Copy over got entries that we may have already seen to the
4668 symbol which just became indirect. */
4669 if (eind->elf.got.glist != NULL)
4670 {
4671 if (edir->elf.got.glist != NULL)
4672 {
4673 struct got_entry **entp;
4674 struct got_entry *ent;
4675
4676 for (entp = &eind->elf.got.glist; (ent = *entp) != NULL; )
4677 {
4678 struct got_entry *dent;
4679
4680 for (dent = edir->elf.got.glist; dent != NULL; dent = dent->next)
4681 if (dent->addend == ent->addend
4682 && dent->owner == ent->owner
4683 && dent->tls_type == ent->tls_type)
4684 {
4685 dent->got.refcount += ent->got.refcount;
4686 *entp = ent->next;
4687 break;
4688 }
4689 if (dent == NULL)
4690 entp = &ent->next;
4691 }
4692 *entp = edir->elf.got.glist;
4693 }
4694
4695 edir->elf.got.glist = eind->elf.got.glist;
4696 eind->elf.got.glist = NULL;
4697 }
4698
4699 /* And plt entries. */
4700 move_plt_plist (eind, edir);
4701
4702 if (eind->elf.dynindx != -1)
4703 {
4704 if (edir->elf.dynindx != -1)
4705 _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
4706 edir->elf.dynstr_index);
4707 edir->elf.dynindx = eind->elf.dynindx;
4708 edir->elf.dynstr_index = eind->elf.dynstr_index;
4709 eind->elf.dynindx = -1;
4710 eind->elf.dynstr_index = 0;
4711 }
4712 }
4713
4714 /* Find the function descriptor hash entry from the given function code
4715 hash entry FH. Link the entries via their OH fields. */
4716
4717 static struct ppc_link_hash_entry *
4718 lookup_fdh (struct ppc_link_hash_entry *fh, struct ppc_link_hash_table *htab)
4719 {
4720 struct ppc_link_hash_entry *fdh = fh->oh;
4721
4722 if (fdh == NULL)
4723 {
4724 const char *fd_name = fh->elf.root.root.string + 1;
4725
4726 fdh = (struct ppc_link_hash_entry *)
4727 elf_link_hash_lookup (&htab->elf, fd_name, FALSE, FALSE, FALSE);
4728 if (fdh == NULL)
4729 return fdh;
4730
4731 fdh->is_func_descriptor = 1;
4732 fdh->oh = fh;
4733 fh->is_func = 1;
4734 fh->oh = fdh;
4735 }
4736
4737 return ppc_follow_link (fdh);
4738 }
4739
4740 /* Make a fake function descriptor sym for the code sym FH. */
4741
4742 static struct ppc_link_hash_entry *
4743 make_fdh (struct bfd_link_info *info,
4744 struct ppc_link_hash_entry *fh)
4745 {
4746 bfd *abfd;
4747 asymbol *newsym;
4748 struct bfd_link_hash_entry *bh;
4749 struct ppc_link_hash_entry *fdh;
4750
4751 abfd = fh->elf.root.u.undef.abfd;
4752 newsym = bfd_make_empty_symbol (abfd);
4753 newsym->name = fh->elf.root.root.string + 1;
4754 newsym->section = bfd_und_section_ptr;
4755 newsym->value = 0;
4756 newsym->flags = BSF_WEAK;
4757
4758 bh = NULL;
4759 if (!_bfd_generic_link_add_one_symbol (info, abfd, newsym->name,
4760 newsym->flags, newsym->section,
4761 newsym->value, NULL, FALSE, FALSE,
4762 &bh))
4763 return NULL;
4764
4765 fdh = (struct ppc_link_hash_entry *) bh;
4766 fdh->elf.non_elf = 0;
4767 fdh->fake = 1;
4768 fdh->is_func_descriptor = 1;
4769 fdh->oh = fh;
4770 fh->is_func = 1;
4771 fh->oh = fdh;
4772 return fdh;
4773 }
4774
4775 /* Fix function descriptor symbols defined in .opd sections to be
4776 function type. */
4777
4778 static bfd_boolean
4779 ppc64_elf_add_symbol_hook (bfd *ibfd,
4780 struct bfd_link_info *info,
4781 Elf_Internal_Sym *isym,
4782 const char **name,
4783 flagword *flags ATTRIBUTE_UNUSED,
4784 asection **sec,
4785 bfd_vma *value ATTRIBUTE_UNUSED)
4786 {
4787 if ((ibfd->flags & DYNAMIC) == 0
4788 && ELF_ST_BIND (isym->st_info) == STB_GNU_UNIQUE)
4789 elf_tdata (info->output_bfd)->has_gnu_symbols = TRUE;
4790
4791 if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
4792 {
4793 if ((ibfd->flags & DYNAMIC) == 0)
4794 elf_tdata (info->output_bfd)->has_gnu_symbols = TRUE;
4795 }
4796 else if (ELF_ST_TYPE (isym->st_info) == STT_FUNC)
4797 ;
4798 else if (*sec != NULL
4799 && strcmp ((*sec)->name, ".opd") == 0)
4800 isym->st_info = ELF_ST_INFO (ELF_ST_BIND (isym->st_info), STT_FUNC);
4801
4802 if ((STO_PPC64_LOCAL_MASK & isym->st_other) != 0)
4803 {
4804 if (abiversion (ibfd) == 0)
4805 set_abiversion (ibfd, 2);
4806 else if (abiversion (ibfd) == 1)
4807 {
4808 info->callbacks->einfo (_("%P: symbol '%s' has invalid st_other"
4809 " for ABI version 1\n"), name);
4810 bfd_set_error (bfd_error_bad_value);
4811 return FALSE;
4812 }
4813 }
4814
4815 return TRUE;
4816 }
4817
4818 /* Merge non-visibility st_other attributes: local entry point. */
4819
4820 static void
4821 ppc64_elf_merge_symbol_attribute (struct elf_link_hash_entry *h,
4822 const Elf_Internal_Sym *isym,
4823 bfd_boolean definition,
4824 bfd_boolean dynamic)
4825 {
4826 if (definition && !dynamic)
4827 h->other = ((isym->st_other & ~ELF_ST_VISIBILITY (-1))
4828 | ELF_ST_VISIBILITY (h->other));
4829 }
4830
4831 /* This function makes an old ABI object reference to ".bar" cause the
4832 inclusion of a new ABI object archive that defines "bar".
4833 NAME is a symbol defined in an archive. Return a symbol in the hash
4834 table that might be satisfied by the archive symbols. */
4835
4836 static struct elf_link_hash_entry *
4837 ppc64_elf_archive_symbol_lookup (bfd *abfd,
4838 struct bfd_link_info *info,
4839 const char *name)
4840 {
4841 struct elf_link_hash_entry *h;
4842 char *dot_name;
4843 size_t len;
4844
4845 h = _bfd_elf_archive_symbol_lookup (abfd, info, name);
4846 if (h != NULL
4847 /* Don't return this sym if it is a fake function descriptor
4848 created by add_symbol_adjust. */
4849 && !(h->root.type == bfd_link_hash_undefweak
4850 && ((struct ppc_link_hash_entry *) h)->fake))
4851 return h;
4852
4853 if (name[0] == '.')
4854 return h;
4855
4856 len = strlen (name);
4857 dot_name = bfd_alloc (abfd, len + 2);
4858 if (dot_name == NULL)
4859 return (struct elf_link_hash_entry *) 0 - 1;
4860 dot_name[0] = '.';
4861 memcpy (dot_name + 1, name, len + 1);
4862 h = _bfd_elf_archive_symbol_lookup (abfd, info, dot_name);
4863 bfd_release (abfd, dot_name);
4864 return h;
4865 }
4866
4867 /* This function satisfies all old ABI object references to ".bar" if a
4868 new ABI object defines "bar". Well, at least, undefined dot symbols
4869 are made weak. This stops later archive searches from including an
4870 object if we already have a function descriptor definition. It also
4871 prevents the linker complaining about undefined symbols.
4872 We also check and correct mismatched symbol visibility here. The
4873 most restrictive visibility of the function descriptor and the
4874 function entry symbol is used. */
4875
4876 static bfd_boolean
4877 add_symbol_adjust (struct ppc_link_hash_entry *eh, struct bfd_link_info *info)
4878 {
4879 struct ppc_link_hash_table *htab;
4880 struct ppc_link_hash_entry *fdh;
4881
4882 if (eh->elf.root.type == bfd_link_hash_indirect)
4883 return TRUE;
4884
4885 if (eh->elf.root.type == bfd_link_hash_warning)
4886 eh = (struct ppc_link_hash_entry *) eh->elf.root.u.i.link;
4887
4888 if (eh->elf.root.root.string[0] != '.')
4889 abort ();
4890
4891 htab = ppc_hash_table (info);
4892 if (htab == NULL)
4893 return FALSE;
4894
4895 fdh = lookup_fdh (eh, htab);
4896 if (fdh == NULL)
4897 {
4898 if (!info->relocatable
4899 && (eh->elf.root.type == bfd_link_hash_undefined
4900 || eh->elf.root.type == bfd_link_hash_undefweak)
4901 && eh->elf.ref_regular)
4902 {
4903 /* Make an undefweak function descriptor sym, which is enough to
4904 pull in an --as-needed shared lib, but won't cause link
4905 errors. Archives are handled elsewhere. */
4906 fdh = make_fdh (info, eh);
4907 if (fdh == NULL)
4908 return FALSE;
4909 fdh->elf.ref_regular = 1;
4910 }
4911 }
4912 else
4913 {
4914 unsigned entry_vis = ELF_ST_VISIBILITY (eh->elf.other) - 1;
4915 unsigned descr_vis = ELF_ST_VISIBILITY (fdh->elf.other) - 1;
4916 if (entry_vis < descr_vis)
4917 fdh->elf.other += entry_vis - descr_vis;
4918 else if (entry_vis > descr_vis)
4919 eh->elf.other += descr_vis - entry_vis;
4920
4921 if ((fdh->elf.root.type == bfd_link_hash_defined
4922 || fdh->elf.root.type == bfd_link_hash_defweak)
4923 && eh->elf.root.type == bfd_link_hash_undefined)
4924 {
4925 eh->elf.root.type = bfd_link_hash_undefweak;
4926 eh->was_undefined = 1;
4927 htab->twiddled_syms = 1;
4928 }
4929 }
4930
4931 return TRUE;
4932 }
4933
4934 /* Process list of dot-symbols we made in link_hash_newfunc. */
4935
4936 static bfd_boolean
4937 ppc64_elf_process_dot_syms (bfd *ibfd, struct bfd_link_info *info)
4938 {
4939 struct ppc_link_hash_table *htab;
4940 struct ppc_link_hash_entry **p, *eh;
4941
4942 if (!is_ppc64_elf (info->output_bfd))
4943 return TRUE;
4944 htab = ppc_hash_table (info);
4945 if (htab == NULL)
4946 return FALSE;
4947
4948 if (is_ppc64_elf (ibfd))
4949 {
4950 p = &htab->dot_syms;
4951 while ((eh = *p) != NULL)
4952 {
4953 *p = NULL;
4954 if (&eh->elf == htab->elf.hgot)
4955 ;
4956 else if (htab->elf.hgot == NULL
4957 && strcmp (eh->elf.root.root.string, ".TOC.") == 0)
4958 htab->elf.hgot = &eh->elf;
4959 else if (!add_symbol_adjust (eh, info))
4960 return FALSE;
4961 p = &eh->u.next_dot_sym;
4962 }
4963 }
4964
4965 /* Clear the list for non-ppc64 input files. */
4966 p = &htab->dot_syms;
4967 while ((eh = *p) != NULL)
4968 {
4969 *p = NULL;
4970 p = &eh->u.next_dot_sym;
4971 }
4972
4973 /* We need to fix the undefs list for any syms we have twiddled to
4974 undef_weak. */
4975 if (htab->twiddled_syms)
4976 {
4977 bfd_link_repair_undef_list (&htab->elf.root);
4978 htab->twiddled_syms = 0;
4979 }
4980 return TRUE;
4981 }
4982
4983 /* Undo hash table changes when an --as-needed input file is determined
4984 not to be needed. */
4985
4986 static bfd_boolean
4987 ppc64_elf_notice_as_needed (bfd *ibfd,
4988 struct bfd_link_info *info,
4989 enum notice_asneeded_action act)
4990 {
4991 if (act == notice_not_needed)
4992 {
4993 struct ppc_link_hash_table *htab = ppc_hash_table (info);
4994
4995 if (htab == NULL)
4996 return FALSE;
4997
4998 htab->dot_syms = NULL;
4999 }
5000 return _bfd_elf_notice_as_needed (ibfd, info, act);
5001 }
5002
5003 /* If --just-symbols against a final linked binary, then assume we need
5004 toc adjusting stubs when calling functions defined there. */
5005
5006 static void
5007 ppc64_elf_link_just_syms (asection *sec, struct bfd_link_info *info)
5008 {
5009 if ((sec->flags & SEC_CODE) != 0
5010 && (sec->owner->flags & (EXEC_P | DYNAMIC)) != 0
5011 && is_ppc64_elf (sec->owner))
5012 {
5013 if (abiversion (sec->owner) >= 2
5014 || bfd_get_section_by_name (sec->owner, ".opd") != NULL)
5015 sec->has_toc_reloc = 1;
5016 }
5017 _bfd_elf_link_just_syms (sec, info);
5018 }
5019
5020 static struct plt_entry **
5021 update_local_sym_info (bfd *abfd, Elf_Internal_Shdr *symtab_hdr,
5022 unsigned long r_symndx, bfd_vma r_addend, int tls_type)
5023 {
5024 struct got_entry **local_got_ents = elf_local_got_ents (abfd);
5025 struct plt_entry **local_plt;
5026 unsigned char *local_got_tls_masks;
5027
5028 if (local_got_ents == NULL)
5029 {
5030 bfd_size_type size = symtab_hdr->sh_info;
5031
5032 size *= (sizeof (*local_got_ents)
5033 + sizeof (*local_plt)
5034 + sizeof (*local_got_tls_masks));
5035 local_got_ents = bfd_zalloc (abfd, size);
5036 if (local_got_ents == NULL)
5037 return NULL;
5038 elf_local_got_ents (abfd) = local_got_ents;
5039 }
5040
5041 if ((tls_type & (PLT_IFUNC | TLS_EXPLICIT)) == 0)
5042 {
5043 struct got_entry *ent;
5044
5045 for (ent = local_got_ents[r_symndx]; ent != NULL; ent = ent->next)
5046 if (ent->addend == r_addend
5047 && ent->owner == abfd
5048 && ent->tls_type == tls_type)
5049 break;
5050 if (ent == NULL)
5051 {
5052 bfd_size_type amt = sizeof (*ent);
5053 ent = bfd_alloc (abfd, amt);
5054 if (ent == NULL)
5055 return FALSE;
5056 ent->next = local_got_ents[r_symndx];
5057 ent->addend = r_addend;
5058 ent->owner = abfd;
5059 ent->tls_type = tls_type;
5060 ent->is_indirect = FALSE;
5061 ent->got.refcount = 0;
5062 local_got_ents[r_symndx] = ent;
5063 }
5064 ent->got.refcount += 1;
5065 }
5066
5067 local_plt = (struct plt_entry **) (local_got_ents + symtab_hdr->sh_info);
5068 local_got_tls_masks = (unsigned char *) (local_plt + symtab_hdr->sh_info);
5069 local_got_tls_masks[r_symndx] |= tls_type;
5070
5071 return local_plt + r_symndx;
5072 }
5073
5074 static bfd_boolean
5075 update_plt_info (bfd *abfd, struct plt_entry **plist, bfd_vma addend)
5076 {
5077 struct plt_entry *ent;
5078
5079 for (ent = *plist; ent != NULL; ent = ent->next)
5080 if (ent->addend == addend)
5081 break;
5082 if (ent == NULL)
5083 {
5084 bfd_size_type amt = sizeof (*ent);
5085 ent = bfd_alloc (abfd, amt);
5086 if (ent == NULL)
5087 return FALSE;
5088 ent->next = *plist;
5089 ent->addend = addend;
5090 ent->plt.refcount = 0;
5091 *plist = ent;
5092 }
5093 ent->plt.refcount += 1;
5094 return TRUE;
5095 }
5096
5097 static bfd_boolean
5098 is_branch_reloc (enum elf_ppc64_reloc_type r_type)
5099 {
5100 return (r_type == R_PPC64_REL24
5101 || r_type == R_PPC64_REL14
5102 || r_type == R_PPC64_REL14_BRTAKEN
5103 || r_type == R_PPC64_REL14_BRNTAKEN
5104 || r_type == R_PPC64_ADDR24
5105 || r_type == R_PPC64_ADDR14
5106 || r_type == R_PPC64_ADDR14_BRTAKEN
5107 || r_type == R_PPC64_ADDR14_BRNTAKEN);
5108 }
5109
5110 /* Look through the relocs for a section during the first phase, and
5111 calculate needed space in the global offset table, procedure
5112 linkage table, and dynamic reloc sections. */
5113
5114 static bfd_boolean
5115 ppc64_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
5116 asection *sec, const Elf_Internal_Rela *relocs)
5117 {
5118 struct ppc_link_hash_table *htab;
5119 Elf_Internal_Shdr *symtab_hdr;
5120 struct elf_link_hash_entry **sym_hashes;
5121 const Elf_Internal_Rela *rel;
5122 const Elf_Internal_Rela *rel_end;
5123 asection *sreloc;
5124 asection **opd_sym_map;
5125 struct elf_link_hash_entry *tga, *dottga;
5126
5127 if (info->relocatable)
5128 return TRUE;
5129
5130 /* Don't do anything special with non-loaded, non-alloced sections.
5131 In particular, any relocs in such sections should not affect GOT
5132 and PLT reference counting (ie. we don't allow them to create GOT
5133 or PLT entries), there's no possibility or desire to optimize TLS
5134 relocs, and there's not much point in propagating relocs to shared
5135 libs that the dynamic linker won't relocate. */
5136 if ((sec->flags & SEC_ALLOC) == 0)
5137 return TRUE;
5138
5139 BFD_ASSERT (is_ppc64_elf (abfd));
5140
5141 htab = ppc_hash_table (info);
5142 if (htab == NULL)
5143 return FALSE;
5144
5145 tga = elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
5146 FALSE, FALSE, TRUE);
5147 dottga = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
5148 FALSE, FALSE, TRUE);
5149 symtab_hdr = &elf_symtab_hdr (abfd);
5150 sym_hashes = elf_sym_hashes (abfd);
5151 sreloc = NULL;
5152 opd_sym_map = NULL;
5153 if (strcmp (sec->name, ".opd") == 0)
5154 {
5155 /* Garbage collection needs some extra help with .opd sections.
5156 We don't want to necessarily keep everything referenced by
5157 relocs in .opd, as that would keep all functions. Instead,
5158 if we reference an .opd symbol (a function descriptor), we
5159 want to keep the function code symbol's section. This is
5160 easy for global symbols, but for local syms we need to keep
5161 information about the associated function section. */
5162 bfd_size_type amt;
5163
5164 if (abiversion (abfd) == 0)
5165 set_abiversion (abfd, 1);
5166 else if (abiversion (abfd) == 2)
5167 {
5168 info->callbacks->einfo (_("%P: .opd not allowed in ABI version %d\n"),
5169 abiversion (abfd));
5170 bfd_set_error (bfd_error_bad_value);
5171 return FALSE;
5172 }
5173 amt = sec->size * sizeof (*opd_sym_map) / 8;
5174 opd_sym_map = bfd_zalloc (abfd, amt);
5175 if (opd_sym_map == NULL)
5176 return FALSE;
5177 ppc64_elf_section_data (sec)->u.opd.func_sec = opd_sym_map;
5178 BFD_ASSERT (ppc64_elf_section_data (sec)->sec_type == sec_normal);
5179 ppc64_elf_section_data (sec)->sec_type = sec_opd;
5180 }
5181
5182 rel_end = relocs + sec->reloc_count;
5183 for (rel = relocs; rel < rel_end; rel++)
5184 {
5185 unsigned long r_symndx;
5186 struct elf_link_hash_entry *h;
5187 enum elf_ppc64_reloc_type r_type;
5188 int tls_type;
5189 struct _ppc64_elf_section_data *ppc64_sec;
5190 struct plt_entry **ifunc;
5191
5192 r_symndx = ELF64_R_SYM (rel->r_info);
5193 if (r_symndx < symtab_hdr->sh_info)
5194 h = NULL;
5195 else
5196 {
5197 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
5198 h = elf_follow_link (h);
5199
5200 /* PR15323, ref flags aren't set for references in the same
5201 object. */
5202 h->root.non_ir_ref = 1;
5203
5204 if (h == htab->elf.hgot)
5205 sec->has_toc_reloc = 1;
5206 }
5207
5208 tls_type = 0;
5209 ifunc = NULL;
5210 if (h != NULL)
5211 {
5212 if (h->type == STT_GNU_IFUNC)
5213 {
5214 h->needs_plt = 1;
5215 ifunc = &h->plt.plist;
5216 }
5217 }
5218 else
5219 {
5220 Elf_Internal_Sym *isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5221 abfd, r_symndx);
5222 if (isym == NULL)
5223 return FALSE;
5224
5225 if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
5226 {
5227 ifunc = update_local_sym_info (abfd, symtab_hdr, r_symndx,
5228 rel->r_addend, PLT_IFUNC);
5229 if (ifunc == NULL)
5230 return FALSE;
5231 }
5232 }
5233 r_type = ELF64_R_TYPE (rel->r_info);
5234 if (is_branch_reloc (r_type))
5235 {
5236 if (h != NULL && (h == tga || h == dottga))
5237 {
5238 if (rel != relocs
5239 && (ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSGD
5240 || ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSLD))
5241 /* We have a new-style __tls_get_addr call with a marker
5242 reloc. */
5243 ;
5244 else
5245 /* Mark this section as having an old-style call. */
5246 sec->has_tls_get_addr_call = 1;
5247 }
5248
5249 /* STT_GNU_IFUNC symbols must have a PLT entry. */
5250 if (ifunc != NULL
5251 && !update_plt_info (abfd, ifunc, rel->r_addend))
5252 return FALSE;
5253 }
5254
5255 switch (r_type)
5256 {
5257 case R_PPC64_TLSGD:
5258 case R_PPC64_TLSLD:
5259 /* These special tls relocs tie a call to __tls_get_addr with
5260 its parameter symbol. */
5261 break;
5262
5263 case R_PPC64_GOT_TLSLD16:
5264 case R_PPC64_GOT_TLSLD16_LO:
5265 case R_PPC64_GOT_TLSLD16_HI:
5266 case R_PPC64_GOT_TLSLD16_HA:
5267 tls_type = TLS_TLS | TLS_LD;
5268 goto dogottls;
5269
5270 case R_PPC64_GOT_TLSGD16:
5271 case R_PPC64_GOT_TLSGD16_LO:
5272 case R_PPC64_GOT_TLSGD16_HI:
5273 case R_PPC64_GOT_TLSGD16_HA:
5274 tls_type = TLS_TLS | TLS_GD;
5275 goto dogottls;
5276
5277 case R_PPC64_GOT_TPREL16_DS:
5278 case R_PPC64_GOT_TPREL16_LO_DS:
5279 case R_PPC64_GOT_TPREL16_HI:
5280 case R_PPC64_GOT_TPREL16_HA:
5281 if (!info->executable)
5282 info->flags |= DF_STATIC_TLS;
5283 tls_type = TLS_TLS | TLS_TPREL;
5284 goto dogottls;
5285
5286 case R_PPC64_GOT_DTPREL16_DS:
5287 case R_PPC64_GOT_DTPREL16_LO_DS:
5288 case R_PPC64_GOT_DTPREL16_HI:
5289 case R_PPC64_GOT_DTPREL16_HA:
5290 tls_type = TLS_TLS | TLS_DTPREL;
5291 dogottls:
5292 sec->has_tls_reloc = 1;
5293 /* Fall thru */
5294
5295 case R_PPC64_GOT16:
5296 case R_PPC64_GOT16_DS:
5297 case R_PPC64_GOT16_HA:
5298 case R_PPC64_GOT16_HI:
5299 case R_PPC64_GOT16_LO:
5300 case R_PPC64_GOT16_LO_DS:
5301 /* This symbol requires a global offset table entry. */
5302 sec->has_toc_reloc = 1;
5303 if (r_type == R_PPC64_GOT_TLSLD16
5304 || r_type == R_PPC64_GOT_TLSGD16
5305 || r_type == R_PPC64_GOT_TPREL16_DS
5306 || r_type == R_PPC64_GOT_DTPREL16_DS
5307 || r_type == R_PPC64_GOT16
5308 || r_type == R_PPC64_GOT16_DS)
5309 {
5310 htab->do_multi_toc = 1;
5311 ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5312 }
5313
5314 if (ppc64_elf_tdata (abfd)->got == NULL
5315 && !create_got_section (abfd, info))
5316 return FALSE;
5317
5318 if (h != NULL)
5319 {
5320 struct ppc_link_hash_entry *eh;
5321 struct got_entry *ent;
5322
5323 eh = (struct ppc_link_hash_entry *) h;
5324 for (ent = eh->elf.got.glist; ent != NULL; ent = ent->next)
5325 if (ent->addend == rel->r_addend
5326 && ent->owner == abfd
5327 && ent->tls_type == tls_type)
5328 break;
5329 if (ent == NULL)
5330 {
5331 bfd_size_type amt = sizeof (*ent);
5332 ent = bfd_alloc (abfd, amt);
5333 if (ent == NULL)
5334 return FALSE;
5335 ent->next = eh->elf.got.glist;
5336 ent->addend = rel->r_addend;
5337 ent->owner = abfd;
5338 ent->tls_type = tls_type;
5339 ent->is_indirect = FALSE;
5340 ent->got.refcount = 0;
5341 eh->elf.got.glist = ent;
5342 }
5343 ent->got.refcount += 1;
5344 eh->tls_mask |= tls_type;
5345 }
5346 else
5347 /* This is a global offset table entry for a local symbol. */
5348 if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5349 rel->r_addend, tls_type))
5350 return FALSE;
5351
5352 /* We may also need a plt entry if the symbol turns out to be
5353 an ifunc. */
5354 if (h != NULL && !info->shared && abiversion (abfd) == 2)
5355 {
5356 if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5357 return FALSE;
5358 }
5359 break;
5360
5361 case R_PPC64_PLT16_HA:
5362 case R_PPC64_PLT16_HI:
5363 case R_PPC64_PLT16_LO:
5364 case R_PPC64_PLT32:
5365 case R_PPC64_PLT64:
5366 /* This symbol requires a procedure linkage table entry. We
5367 actually build the entry in adjust_dynamic_symbol,
5368 because this might be a case of linking PIC code without
5369 linking in any dynamic objects, in which case we don't
5370 need to generate a procedure linkage table after all. */
5371 if (h == NULL)
5372 {
5373 /* It does not make sense to have a procedure linkage
5374 table entry for a local symbol. */
5375 bfd_set_error (bfd_error_bad_value);
5376 return FALSE;
5377 }
5378 else
5379 {
5380 if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5381 return FALSE;
5382 h->needs_plt = 1;
5383 if (h->root.root.string[0] == '.'
5384 && h->root.root.string[1] != '\0')
5385 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5386 }
5387 break;
5388
5389 /* The following relocations don't need to propagate the
5390 relocation if linking a shared object since they are
5391 section relative. */
5392 case R_PPC64_SECTOFF:
5393 case R_PPC64_SECTOFF_LO:
5394 case R_PPC64_SECTOFF_HI:
5395 case R_PPC64_SECTOFF_HA:
5396 case R_PPC64_SECTOFF_DS:
5397 case R_PPC64_SECTOFF_LO_DS:
5398 case R_PPC64_DTPREL16:
5399 case R_PPC64_DTPREL16_LO:
5400 case R_PPC64_DTPREL16_HI:
5401 case R_PPC64_DTPREL16_HA:
5402 case R_PPC64_DTPREL16_DS:
5403 case R_PPC64_DTPREL16_LO_DS:
5404 case R_PPC64_DTPREL16_HIGH:
5405 case R_PPC64_DTPREL16_HIGHA:
5406 case R_PPC64_DTPREL16_HIGHER:
5407 case R_PPC64_DTPREL16_HIGHERA:
5408 case R_PPC64_DTPREL16_HIGHEST:
5409 case R_PPC64_DTPREL16_HIGHESTA:
5410 break;
5411
5412 /* Nor do these. */
5413 case R_PPC64_REL16:
5414 case R_PPC64_REL16_LO:
5415 case R_PPC64_REL16_HI:
5416 case R_PPC64_REL16_HA:
5417 break;
5418
5419 /* Not supported as a dynamic relocation. */
5420 case R_PPC64_ADDR64_LOCAL:
5421 if (info->shared)
5422 {
5423 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
5424 ppc_howto_init ();
5425 info->callbacks->einfo (_("%P: %H: %s reloc unsupported "
5426 "in shared libraries and PIEs.\n"),
5427 abfd, sec, rel->r_offset,
5428 ppc64_elf_howto_table[r_type]->name);
5429 bfd_set_error (bfd_error_bad_value);
5430 return FALSE;
5431 }
5432 break;
5433
5434 case R_PPC64_TOC16:
5435 case R_PPC64_TOC16_DS:
5436 htab->do_multi_toc = 1;
5437 ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
5438 case R_PPC64_TOC16_LO:
5439 case R_PPC64_TOC16_HI:
5440 case R_PPC64_TOC16_HA:
5441 case R_PPC64_TOC16_LO_DS:
5442 sec->has_toc_reloc = 1;
5443 break;
5444
5445 /* This relocation describes the C++ object vtable hierarchy.
5446 Reconstruct it for later use during GC. */
5447 case R_PPC64_GNU_VTINHERIT:
5448 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
5449 return FALSE;
5450 break;
5451
5452 /* This relocation describes which C++ vtable entries are actually
5453 used. Record for later use during GC. */
5454 case R_PPC64_GNU_VTENTRY:
5455 BFD_ASSERT (h != NULL);
5456 if (h != NULL
5457 && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
5458 return FALSE;
5459 break;
5460
5461 case R_PPC64_REL14:
5462 case R_PPC64_REL14_BRTAKEN:
5463 case R_PPC64_REL14_BRNTAKEN:
5464 {
5465 asection *dest = NULL;
5466
5467 /* Heuristic: If jumping outside our section, chances are
5468 we are going to need a stub. */
5469 if (h != NULL)
5470 {
5471 /* If the sym is weak it may be overridden later, so
5472 don't assume we know where a weak sym lives. */
5473 if (h->root.type == bfd_link_hash_defined)
5474 dest = h->root.u.def.section;
5475 }
5476 else
5477 {
5478 Elf_Internal_Sym *isym;
5479
5480 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5481 abfd, r_symndx);
5482 if (isym == NULL)
5483 return FALSE;
5484
5485 dest = bfd_section_from_elf_index (abfd, isym->st_shndx);
5486 }
5487
5488 if (dest != sec)
5489 ppc64_elf_section_data (sec)->has_14bit_branch = 1;
5490 }
5491 /* Fall through. */
5492
5493 case R_PPC64_REL24:
5494 if (h != NULL && ifunc == NULL)
5495 {
5496 /* We may need a .plt entry if the function this reloc
5497 refers to is in a shared lib. */
5498 if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5499 return FALSE;
5500 h->needs_plt = 1;
5501 if (h->root.root.string[0] == '.'
5502 && h->root.root.string[1] != '\0')
5503 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5504 if (h == tga || h == dottga)
5505 sec->has_tls_reloc = 1;
5506 }
5507 break;
5508
5509 case R_PPC64_TPREL64:
5510 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_TPREL;
5511 if (!info->executable)
5512 info->flags |= DF_STATIC_TLS;
5513 goto dotlstoc;
5514
5515 case R_PPC64_DTPMOD64:
5516 if (rel + 1 < rel_end
5517 && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
5518 && rel[1].r_offset == rel->r_offset + 8)
5519 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_GD;
5520 else
5521 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_LD;
5522 goto dotlstoc;
5523
5524 case R_PPC64_DTPREL64:
5525 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_DTPREL;
5526 if (rel != relocs
5527 && rel[-1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPMOD64)
5528 && rel[-1].r_offset == rel->r_offset - 8)
5529 /* This is the second reloc of a dtpmod, dtprel pair.
5530 Don't mark with TLS_DTPREL. */
5531 goto dodyn;
5532
5533 dotlstoc:
5534 sec->has_tls_reloc = 1;
5535 if (h != NULL)
5536 {
5537 struct ppc_link_hash_entry *eh;
5538 eh = (struct ppc_link_hash_entry *) h;
5539 eh->tls_mask |= tls_type;
5540 }
5541 else
5542 if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5543 rel->r_addend, tls_type))
5544 return FALSE;
5545
5546 ppc64_sec = ppc64_elf_section_data (sec);
5547 if (ppc64_sec->sec_type != sec_toc)
5548 {
5549 bfd_size_type amt;
5550
5551 /* One extra to simplify get_tls_mask. */
5552 amt = sec->size * sizeof (unsigned) / 8 + sizeof (unsigned);
5553 ppc64_sec->u.toc.symndx = bfd_zalloc (abfd, amt);
5554 if (ppc64_sec->u.toc.symndx == NULL)
5555 return FALSE;
5556 amt = sec->size * sizeof (bfd_vma) / 8;
5557 ppc64_sec->u.toc.add = bfd_zalloc (abfd, amt);
5558 if (ppc64_sec->u.toc.add == NULL)
5559 return FALSE;
5560 BFD_ASSERT (ppc64_sec->sec_type == sec_normal);
5561 ppc64_sec->sec_type = sec_toc;
5562 }
5563 BFD_ASSERT (rel->r_offset % 8 == 0);
5564 ppc64_sec->u.toc.symndx[rel->r_offset / 8] = r_symndx;
5565 ppc64_sec->u.toc.add[rel->r_offset / 8] = rel->r_addend;
5566
5567 /* Mark the second slot of a GD or LD entry.
5568 -1 to indicate GD and -2 to indicate LD. */
5569 if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_GD))
5570 ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -1;
5571 else if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_LD))
5572 ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -2;
5573 goto dodyn;
5574
5575 case R_PPC64_TPREL16:
5576 case R_PPC64_TPREL16_LO:
5577 case R_PPC64_TPREL16_HI:
5578 case R_PPC64_TPREL16_HA:
5579 case R_PPC64_TPREL16_DS:
5580 case R_PPC64_TPREL16_LO_DS:
5581 case R_PPC64_TPREL16_HIGH:
5582 case R_PPC64_TPREL16_HIGHA:
5583 case R_PPC64_TPREL16_HIGHER:
5584 case R_PPC64_TPREL16_HIGHERA:
5585 case R_PPC64_TPREL16_HIGHEST:
5586 case R_PPC64_TPREL16_HIGHESTA:
5587 if (info->shared)
5588 {
5589 if (!info->executable)
5590 info->flags |= DF_STATIC_TLS;
5591 goto dodyn;
5592 }
5593 break;
5594
5595 case R_PPC64_ADDR64:
5596 if (opd_sym_map != NULL
5597 && rel + 1 < rel_end
5598 && ELF64_R_TYPE ((rel + 1)->r_info) == R_PPC64_TOC)
5599 {
5600 if (h != NULL)
5601 {
5602 if (h->root.root.string[0] == '.'
5603 && h->root.root.string[1] != 0
5604 && lookup_fdh ((struct ppc_link_hash_entry *) h, htab))
5605 ;
5606 else
5607 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5608 }
5609 else
5610 {
5611 asection *s;
5612 Elf_Internal_Sym *isym;
5613
5614 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5615 abfd, r_symndx);
5616 if (isym == NULL)
5617 return FALSE;
5618
5619 s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5620 if (s != NULL && s != sec)
5621 opd_sym_map[rel->r_offset / 8] = s;
5622 }
5623 }
5624 /* Fall through. */
5625
5626 case R_PPC64_ADDR16:
5627 case R_PPC64_ADDR16_DS:
5628 case R_PPC64_ADDR16_HA:
5629 case R_PPC64_ADDR16_HI:
5630 case R_PPC64_ADDR16_HIGH:
5631 case R_PPC64_ADDR16_HIGHA:
5632 case R_PPC64_ADDR16_HIGHER:
5633 case R_PPC64_ADDR16_HIGHERA:
5634 case R_PPC64_ADDR16_HIGHEST:
5635 case R_PPC64_ADDR16_HIGHESTA:
5636 case R_PPC64_ADDR16_LO:
5637 case R_PPC64_ADDR16_LO_DS:
5638 if (h != NULL && !info->shared && abiversion (abfd) == 2
5639 && rel->r_addend == 0)
5640 {
5641 /* We may need a .plt entry if this reloc refers to a
5642 function in a shared lib. */
5643 if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5644 return FALSE;
5645 h->pointer_equality_needed = 1;
5646 }
5647 /* Fall through. */
5648
5649 case R_PPC64_REL30:
5650 case R_PPC64_REL32:
5651 case R_PPC64_REL64:
5652 case R_PPC64_ADDR14:
5653 case R_PPC64_ADDR14_BRNTAKEN:
5654 case R_PPC64_ADDR14_BRTAKEN:
5655 case R_PPC64_ADDR24:
5656 case R_PPC64_ADDR32:
5657 case R_PPC64_UADDR16:
5658 case R_PPC64_UADDR32:
5659 case R_PPC64_UADDR64:
5660 case R_PPC64_TOC:
5661 if (h != NULL && !info->shared)
5662 /* We may need a copy reloc. */
5663 h->non_got_ref = 1;
5664
5665 /* Don't propagate .opd relocs. */
5666 if (NO_OPD_RELOCS && opd_sym_map != NULL)
5667 break;
5668
5669 /* If we are creating a shared library, and this is a reloc
5670 against a global symbol, or a non PC relative reloc
5671 against a local symbol, then we need to copy the reloc
5672 into the shared library. However, if we are linking with
5673 -Bsymbolic, we do not need to copy a reloc against a
5674 global symbol which is defined in an object we are
5675 including in the link (i.e., DEF_REGULAR is set). At
5676 this point we have not seen all the input files, so it is
5677 possible that DEF_REGULAR is not set now but will be set
5678 later (it is never cleared). In case of a weak definition,
5679 DEF_REGULAR may be cleared later by a strong definition in
5680 a shared library. We account for that possibility below by
5681 storing information in the dyn_relocs field of the hash
5682 table entry. A similar situation occurs when creating
5683 shared libraries and symbol visibility changes render the
5684 symbol local.
5685
5686 If on the other hand, we are creating an executable, we
5687 may need to keep relocations for symbols satisfied by a
5688 dynamic library if we manage to avoid copy relocs for the
5689 symbol. */
5690 dodyn:
5691 if ((info->shared
5692 && (must_be_dyn_reloc (info, r_type)
5693 || (h != NULL
5694 && (!SYMBOLIC_BIND (info, h)
5695 || h->root.type == bfd_link_hash_defweak
5696 || !h->def_regular))))
5697 || (ELIMINATE_COPY_RELOCS
5698 && !info->shared
5699 && h != NULL
5700 && (h->root.type == bfd_link_hash_defweak
5701 || !h->def_regular))
5702 || (!info->shared
5703 && ifunc != NULL))
5704 {
5705 /* We must copy these reloc types into the output file.
5706 Create a reloc section in dynobj and make room for
5707 this reloc. */
5708 if (sreloc == NULL)
5709 {
5710 sreloc = _bfd_elf_make_dynamic_reloc_section
5711 (sec, htab->elf.dynobj, 3, abfd, /*rela?*/ TRUE);
5712
5713 if (sreloc == NULL)
5714 return FALSE;
5715 }
5716
5717 /* If this is a global symbol, we count the number of
5718 relocations we need for this symbol. */
5719 if (h != NULL)
5720 {
5721 struct elf_dyn_relocs *p;
5722 struct elf_dyn_relocs **head;
5723
5724 head = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
5725 p = *head;
5726 if (p == NULL || p->sec != sec)
5727 {
5728 p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5729 if (p == NULL)
5730 return FALSE;
5731 p->next = *head;
5732 *head = p;
5733 p->sec = sec;
5734 p->count = 0;
5735 p->pc_count = 0;
5736 }
5737 p->count += 1;
5738 if (!must_be_dyn_reloc (info, r_type))
5739 p->pc_count += 1;
5740 }
5741 else
5742 {
5743 /* Track dynamic relocs needed for local syms too.
5744 We really need local syms available to do this
5745 easily. Oh well. */
5746 struct ppc_dyn_relocs *p;
5747 struct ppc_dyn_relocs **head;
5748 bfd_boolean is_ifunc;
5749 asection *s;
5750 void *vpp;
5751 Elf_Internal_Sym *isym;
5752
5753 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5754 abfd, r_symndx);
5755 if (isym == NULL)
5756 return FALSE;
5757
5758 s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5759 if (s == NULL)
5760 s = sec;
5761
5762 vpp = &elf_section_data (s)->local_dynrel;
5763 head = (struct ppc_dyn_relocs **) vpp;
5764 is_ifunc = ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC;
5765 p = *head;
5766 if (p != NULL && p->sec == sec && p->ifunc != is_ifunc)
5767 p = p->next;
5768 if (p == NULL || p->sec != sec || p->ifunc != is_ifunc)
5769 {
5770 p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5771 if (p == NULL)
5772 return FALSE;
5773 p->next = *head;
5774 *head = p;
5775 p->sec = sec;
5776 p->ifunc = is_ifunc;
5777 p->count = 0;
5778 }
5779 p->count += 1;
5780 }
5781 }
5782 break;
5783
5784 default:
5785 break;
5786 }
5787 }
5788
5789 return TRUE;
5790 }
5791
5792 /* Merge backend specific data from an object file to the output
5793 object file when linking. */
5794
5795 static bfd_boolean
5796 ppc64_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
5797 {
5798 unsigned long iflags, oflags;
5799
5800 if ((ibfd->flags & BFD_LINKER_CREATED) != 0)
5801 return TRUE;
5802
5803 if (!is_ppc64_elf (ibfd) || !is_ppc64_elf (obfd))
5804 return TRUE;
5805
5806 if (!_bfd_generic_verify_endian_match (ibfd, obfd))
5807 return FALSE;
5808
5809 iflags = elf_elfheader (ibfd)->e_flags;
5810 oflags = elf_elfheader (obfd)->e_flags;
5811
5812 if (!elf_flags_init (obfd) || oflags == 0)
5813 {
5814 elf_flags_init (obfd) = TRUE;
5815 elf_elfheader (obfd)->e_flags = iflags;
5816 }
5817 else if (iflags == oflags || iflags == 0)
5818 ;
5819 else if (iflags & ~EF_PPC64_ABI)
5820 {
5821 (*_bfd_error_handler)
5822 (_("%B uses unknown e_flags 0x%lx"), ibfd, iflags);
5823 bfd_set_error (bfd_error_bad_value);
5824 return FALSE;
5825 }
5826 else
5827 {
5828 (*_bfd_error_handler)
5829 (_("%B: ABI version %ld is not compatible with ABI version %ld output"),
5830 ibfd, iflags, oflags);
5831 bfd_set_error (bfd_error_bad_value);
5832 return FALSE;
5833 }
5834
5835 /* Merge Tag_compatibility attributes and any common GNU ones. */
5836 _bfd_elf_merge_object_attributes (ibfd, obfd);
5837
5838 return TRUE;
5839 }
5840
5841 static bfd_boolean
5842 ppc64_elf_print_private_bfd_data (bfd *abfd, void *ptr)
5843 {
5844 /* Print normal ELF private data. */
5845 _bfd_elf_print_private_bfd_data (abfd, ptr);
5846
5847 if (elf_elfheader (abfd)->e_flags != 0)
5848 {
5849 FILE *file = ptr;
5850
5851 /* xgettext:c-format */
5852 fprintf (file, _("private flags = 0x%lx:"),
5853 elf_elfheader (abfd)->e_flags);
5854
5855 if ((elf_elfheader (abfd)->e_flags & EF_PPC64_ABI) != 0)
5856 fprintf (file, _(" [abiv%ld]"),
5857 elf_elfheader (abfd)->e_flags & EF_PPC64_ABI);
5858 fputc ('\n', file);
5859 }
5860
5861 return TRUE;
5862 }
5863
5864 /* OFFSET in OPD_SEC specifies a function descriptor. Return the address
5865 of the code entry point, and its section. */
5866
5867 static bfd_vma
5868 opd_entry_value (asection *opd_sec,
5869 bfd_vma offset,
5870 asection **code_sec,
5871 bfd_vma *code_off,
5872 bfd_boolean in_code_sec)
5873 {
5874 bfd *opd_bfd = opd_sec->owner;
5875 Elf_Internal_Rela *relocs;
5876 Elf_Internal_Rela *lo, *hi, *look;
5877 bfd_vma val;
5878
5879 /* No relocs implies we are linking a --just-symbols object, or looking
5880 at a final linked executable with addr2line or somesuch. */
5881 if (opd_sec->reloc_count == 0)
5882 {
5883 bfd_byte *contents = ppc64_elf_tdata (opd_bfd)->opd.contents;
5884
5885 if (contents == NULL)
5886 {
5887 if (!bfd_malloc_and_get_section (opd_bfd, opd_sec, &contents))
5888 return (bfd_vma) -1;
5889 ppc64_elf_tdata (opd_bfd)->opd.contents = contents;
5890 }
5891
5892 val = bfd_get_64 (opd_bfd, contents + offset);
5893 if (code_sec != NULL)
5894 {
5895 asection *sec, *likely = NULL;
5896
5897 if (in_code_sec)
5898 {
5899 sec = *code_sec;
5900 if (sec->vma <= val
5901 && val < sec->vma + sec->size)
5902 likely = sec;
5903 else
5904 val = -1;
5905 }
5906 else
5907 for (sec = opd_bfd->sections; sec != NULL; sec = sec->next)
5908 if (sec->vma <= val
5909 && (sec->flags & SEC_LOAD) != 0
5910 && (sec->flags & SEC_ALLOC) != 0)
5911 likely = sec;
5912 if (likely != NULL)
5913 {
5914 *code_sec = likely;
5915 if (code_off != NULL)
5916 *code_off = val - likely->vma;
5917 }
5918 }
5919 return val;
5920 }
5921
5922 BFD_ASSERT (is_ppc64_elf (opd_bfd));
5923
5924 relocs = ppc64_elf_tdata (opd_bfd)->opd.relocs;
5925 if (relocs == NULL)
5926 relocs = _bfd_elf_link_read_relocs (opd_bfd, opd_sec, NULL, NULL, TRUE);
5927
5928 /* Go find the opd reloc at the sym address. */
5929 lo = relocs;
5930 BFD_ASSERT (lo != NULL);
5931 hi = lo + opd_sec->reloc_count - 1; /* ignore last reloc */
5932 val = (bfd_vma) -1;
5933 while (lo < hi)
5934 {
5935 look = lo + (hi - lo) / 2;
5936 if (look->r_offset < offset)
5937 lo = look + 1;
5938 else if (look->r_offset > offset)
5939 hi = look;
5940 else
5941 {
5942 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (opd_bfd);
5943
5944 if (ELF64_R_TYPE (look->r_info) == R_PPC64_ADDR64
5945 && ELF64_R_TYPE ((look + 1)->r_info) == R_PPC64_TOC)
5946 {
5947 unsigned long symndx = ELF64_R_SYM (look->r_info);
5948 asection *sec;
5949
5950 if (symndx < symtab_hdr->sh_info
5951 || elf_sym_hashes (opd_bfd) == NULL)
5952 {
5953 Elf_Internal_Sym *sym;
5954
5955 sym = (Elf_Internal_Sym *) symtab_hdr->contents;
5956 if (sym == NULL)
5957 {
5958 size_t symcnt = symtab_hdr->sh_info;
5959 if (elf_sym_hashes (opd_bfd) == NULL)
5960 symcnt = symtab_hdr->sh_size / symtab_hdr->sh_entsize;
5961 sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr, symcnt,
5962 0, NULL, NULL, NULL);
5963 if (sym == NULL)
5964 break;
5965 symtab_hdr->contents = (bfd_byte *) sym;
5966 }
5967
5968 sym += symndx;
5969 val = sym->st_value;
5970 sec = bfd_section_from_elf_index (opd_bfd, sym->st_shndx);
5971 BFD_ASSERT ((sec->flags & SEC_MERGE) == 0);
5972 }
5973 else
5974 {
5975 struct elf_link_hash_entry **sym_hashes;
5976 struct elf_link_hash_entry *rh;
5977
5978 sym_hashes = elf_sym_hashes (opd_bfd);
5979 rh = sym_hashes[symndx - symtab_hdr->sh_info];
5980 if (rh != NULL)
5981 {
5982 rh = elf_follow_link (rh);
5983 BFD_ASSERT (rh->root.type == bfd_link_hash_defined
5984 || rh->root.type == bfd_link_hash_defweak);
5985 val = rh->root.u.def.value;
5986 sec = rh->root.u.def.section;
5987 }
5988 else
5989 {
5990 /* Handle the odd case where we can be called
5991 during bfd_elf_link_add_symbols before the
5992 symbol hashes have been fully populated. */
5993 Elf_Internal_Sym *sym;
5994
5995 sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr, 1,
5996 symndx, NULL, NULL, NULL);
5997 if (sym == NULL)
5998 break;
5999
6000 val = sym->st_value;
6001 sec = bfd_section_from_elf_index (opd_bfd, sym->st_shndx);
6002 free (sym);
6003 }
6004 }
6005 val += look->r_addend;
6006 if (code_off != NULL)
6007 *code_off = val;
6008 if (code_sec != NULL)
6009 {
6010 if (in_code_sec && *code_sec != sec)
6011 return -1;
6012 else
6013 *code_sec = sec;
6014 }
6015 if (sec != NULL && sec->output_section != NULL)
6016 val += sec->output_section->vma + sec->output_offset;
6017 }
6018 break;
6019 }
6020 }
6021
6022 return val;
6023 }
6024
6025 /* If the ELF symbol SYM might be a function in SEC, return the
6026 function size and set *CODE_OFF to the function's entry point,
6027 otherwise return zero. */
6028
6029 static bfd_size_type
6030 ppc64_elf_maybe_function_sym (const asymbol *sym, asection *sec,
6031 bfd_vma *code_off)
6032 {
6033 bfd_size_type size;
6034
6035 if ((sym->flags & (BSF_SECTION_SYM | BSF_FILE | BSF_OBJECT
6036 | BSF_THREAD_LOCAL | BSF_RELC | BSF_SRELC)) != 0)
6037 return 0;
6038
6039 size = 0;
6040 if (!(sym->flags & BSF_SYNTHETIC))
6041 size = ((elf_symbol_type *) sym)->internal_elf_sym.st_size;
6042
6043 if (strcmp (sym->section->name, ".opd") == 0)
6044 {
6045 if (opd_entry_value (sym->section, sym->value,
6046 &sec, code_off, TRUE) == (bfd_vma) -1)
6047 return 0;
6048 /* An old ABI binary with dot-syms has a size of 24 on the .opd
6049 symbol. This size has nothing to do with the code size of the
6050 function, which is what we're supposed to return, but the
6051 code size isn't available without looking up the dot-sym.
6052 However, doing that would be a waste of time particularly
6053 since elf_find_function will look at the dot-sym anyway.
6054 Now, elf_find_function will keep the largest size of any
6055 function sym found at the code address of interest, so return
6056 1 here to avoid it incorrectly caching a larger function size
6057 for a small function. This does mean we return the wrong
6058 size for a new-ABI function of size 24, but all that does is
6059 disable caching for such functions. */
6060 if (size == 24)
6061 size = 1;
6062 }
6063 else
6064 {
6065 if (sym->section != sec)
6066 return 0;
6067 *code_off = sym->value;
6068 }
6069 if (size == 0)
6070 size = 1;
6071 return size;
6072 }
6073
6074 /* Return true if symbol is defined in a regular object file. */
6075
6076 static bfd_boolean
6077 is_static_defined (struct elf_link_hash_entry *h)
6078 {
6079 return ((h->root.type == bfd_link_hash_defined
6080 || h->root.type == bfd_link_hash_defweak)
6081 && h->root.u.def.section != NULL
6082 && h->root.u.def.section->output_section != NULL);
6083 }
6084
6085 /* If FDH is a function descriptor symbol, return the associated code
6086 entry symbol if it is defined. Return NULL otherwise. */
6087
6088 static struct ppc_link_hash_entry *
6089 defined_code_entry (struct ppc_link_hash_entry *fdh)
6090 {
6091 if (fdh->is_func_descriptor)
6092 {
6093 struct ppc_link_hash_entry *fh = ppc_follow_link (fdh->oh);
6094 if (fh->elf.root.type == bfd_link_hash_defined
6095 || fh->elf.root.type == bfd_link_hash_defweak)
6096 return fh;
6097 }
6098 return NULL;
6099 }
6100
6101 /* If FH is a function code entry symbol, return the associated
6102 function descriptor symbol if it is defined. Return NULL otherwise. */
6103
6104 static struct ppc_link_hash_entry *
6105 defined_func_desc (struct ppc_link_hash_entry *fh)
6106 {
6107 if (fh->oh != NULL
6108 && fh->oh->is_func_descriptor)
6109 {
6110 struct ppc_link_hash_entry *fdh = ppc_follow_link (fh->oh);
6111 if (fdh->elf.root.type == bfd_link_hash_defined
6112 || fdh->elf.root.type == bfd_link_hash_defweak)
6113 return fdh;
6114 }
6115 return NULL;
6116 }
6117
6118 /* Mark all our entry sym sections, both opd and code section. */
6119
6120 static void
6121 ppc64_elf_gc_keep (struct bfd_link_info *info)
6122 {
6123 struct ppc_link_hash_table *htab = ppc_hash_table (info);
6124 struct bfd_sym_chain *sym;
6125
6126 if (htab == NULL)
6127 return;
6128
6129 for (sym = info->gc_sym_list; sym != NULL; sym = sym->next)
6130 {
6131 struct ppc_link_hash_entry *eh, *fh;
6132 asection *sec;
6133
6134 eh = (struct ppc_link_hash_entry *)
6135 elf_link_hash_lookup (&htab->elf, sym->name, FALSE, FALSE, TRUE);
6136 if (eh == NULL)
6137 continue;
6138 if (eh->elf.root.type != bfd_link_hash_defined
6139 && eh->elf.root.type != bfd_link_hash_defweak)
6140 continue;
6141
6142 fh = defined_code_entry (eh);
6143 if (fh != NULL)
6144 {
6145 sec = fh->elf.root.u.def.section;
6146 sec->flags |= SEC_KEEP;
6147 }
6148 else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6149 && opd_entry_value (eh->elf.root.u.def.section,
6150 eh->elf.root.u.def.value,
6151 &sec, NULL, FALSE) != (bfd_vma) -1)
6152 sec->flags |= SEC_KEEP;
6153
6154 sec = eh->elf.root.u.def.section;
6155 sec->flags |= SEC_KEEP;
6156 }
6157 }
6158
6159 /* Mark sections containing dynamically referenced symbols. When
6160 building shared libraries, we must assume that any visible symbol is
6161 referenced. */
6162
6163 static bfd_boolean
6164 ppc64_elf_gc_mark_dynamic_ref (struct elf_link_hash_entry *h, void *inf)
6165 {
6166 struct bfd_link_info *info = (struct bfd_link_info *) inf;
6167 struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
6168 struct ppc_link_hash_entry *fdh;
6169 struct bfd_elf_dynamic_list *d = info->dynamic_list;
6170
6171 /* Dynamic linking info is on the func descriptor sym. */
6172 fdh = defined_func_desc (eh);
6173 if (fdh != NULL)
6174 eh = fdh;
6175
6176 if ((eh->elf.root.type == bfd_link_hash_defined
6177 || eh->elf.root.type == bfd_link_hash_defweak)
6178 && (eh->elf.ref_dynamic
6179 || (eh->elf.def_regular
6180 && ELF_ST_VISIBILITY (eh->elf.other) != STV_INTERNAL
6181 && ELF_ST_VISIBILITY (eh->elf.other) != STV_HIDDEN
6182 && (!info->executable
6183 || info->export_dynamic
6184 || (eh->elf.dynamic
6185 && d != NULL
6186 && (*d->match) (&d->head, NULL, eh->elf.root.root.string)))
6187 && (strchr (eh->elf.root.root.string, ELF_VER_CHR) != NULL
6188 || !bfd_hide_sym_by_version (info->version_info,
6189 eh->elf.root.root.string)))))
6190 {
6191 asection *code_sec;
6192 struct ppc_link_hash_entry *fh;
6193
6194 eh->elf.root.u.def.section->flags |= SEC_KEEP;
6195
6196 /* Function descriptor syms cause the associated
6197 function code sym section to be marked. */
6198 fh = defined_code_entry (eh);
6199 if (fh != NULL)
6200 {
6201 code_sec = fh->elf.root.u.def.section;
6202 code_sec->flags |= SEC_KEEP;
6203 }
6204 else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6205 && opd_entry_value (eh->elf.root.u.def.section,
6206 eh->elf.root.u.def.value,
6207 &code_sec, NULL, FALSE) != (bfd_vma) -1)
6208 code_sec->flags |= SEC_KEEP;
6209 }
6210
6211 return TRUE;
6212 }
6213
6214 /* Return the section that should be marked against GC for a given
6215 relocation. */
6216
6217 static asection *
6218 ppc64_elf_gc_mark_hook (asection *sec,
6219 struct bfd_link_info *info,
6220 Elf_Internal_Rela *rel,
6221 struct elf_link_hash_entry *h,
6222 Elf_Internal_Sym *sym)
6223 {
6224 asection *rsec;
6225
6226 /* Syms return NULL if we're marking .opd, so we avoid marking all
6227 function sections, as all functions are referenced in .opd. */
6228 rsec = NULL;
6229 if (get_opd_info (sec) != NULL)
6230 return rsec;
6231
6232 if (h != NULL)
6233 {
6234 enum elf_ppc64_reloc_type r_type;
6235 struct ppc_link_hash_entry *eh, *fh, *fdh;
6236
6237 r_type = ELF64_R_TYPE (rel->r_info);
6238 switch (r_type)
6239 {
6240 case R_PPC64_GNU_VTINHERIT:
6241 case R_PPC64_GNU_VTENTRY:
6242 break;
6243
6244 default:
6245 switch (h->root.type)
6246 {
6247 case bfd_link_hash_defined:
6248 case bfd_link_hash_defweak:
6249 eh = (struct ppc_link_hash_entry *) h;
6250 fdh = defined_func_desc (eh);
6251 if (fdh != NULL)
6252 eh = fdh;
6253
6254 /* Function descriptor syms cause the associated
6255 function code sym section to be marked. */
6256 fh = defined_code_entry (eh);
6257 if (fh != NULL)
6258 {
6259 /* They also mark their opd section. */
6260 eh->elf.root.u.def.section->gc_mark = 1;
6261
6262 rsec = fh->elf.root.u.def.section;
6263 }
6264 else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6265 && opd_entry_value (eh->elf.root.u.def.section,
6266 eh->elf.root.u.def.value,
6267 &rsec, NULL, FALSE) != (bfd_vma) -1)
6268 eh->elf.root.u.def.section->gc_mark = 1;
6269 else
6270 rsec = h->root.u.def.section;
6271 break;
6272
6273 case bfd_link_hash_common:
6274 rsec = h->root.u.c.p->section;
6275 break;
6276
6277 default:
6278 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
6279 }
6280 }
6281 }
6282 else
6283 {
6284 struct _opd_sec_data *opd;
6285
6286 rsec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
6287 opd = get_opd_info (rsec);
6288 if (opd != NULL && opd->func_sec != NULL)
6289 {
6290 rsec->gc_mark = 1;
6291
6292 rsec = opd->func_sec[(sym->st_value + rel->r_addend) / 8];
6293 }
6294 }
6295
6296 return rsec;
6297 }
6298
6299 /* Update the .got, .plt. and dynamic reloc reference counts for the
6300 section being removed. */
6301
6302 static bfd_boolean
6303 ppc64_elf_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info,
6304 asection *sec, const Elf_Internal_Rela *relocs)
6305 {
6306 struct ppc_link_hash_table *htab;
6307 Elf_Internal_Shdr *symtab_hdr;
6308 struct elf_link_hash_entry **sym_hashes;
6309 struct got_entry **local_got_ents;
6310 const Elf_Internal_Rela *rel, *relend;
6311
6312 if (info->relocatable)
6313 return TRUE;
6314
6315 if ((sec->flags & SEC_ALLOC) == 0)
6316 return TRUE;
6317
6318 elf_section_data (sec)->local_dynrel = NULL;
6319
6320 htab = ppc_hash_table (info);
6321 if (htab == NULL)
6322 return FALSE;
6323
6324 symtab_hdr = &elf_symtab_hdr (abfd);
6325 sym_hashes = elf_sym_hashes (abfd);
6326 local_got_ents = elf_local_got_ents (abfd);
6327
6328 relend = relocs + sec->reloc_count;
6329 for (rel = relocs; rel < relend; rel++)
6330 {
6331 unsigned long r_symndx;
6332 enum elf_ppc64_reloc_type r_type;
6333 struct elf_link_hash_entry *h = NULL;
6334 unsigned char tls_type = 0;
6335
6336 r_symndx = ELF64_R_SYM (rel->r_info);
6337 r_type = ELF64_R_TYPE (rel->r_info);
6338 if (r_symndx >= symtab_hdr->sh_info)
6339 {
6340 struct ppc_link_hash_entry *eh;
6341 struct elf_dyn_relocs **pp;
6342 struct elf_dyn_relocs *p;
6343
6344 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
6345 h = elf_follow_link (h);
6346 eh = (struct ppc_link_hash_entry *) h;
6347
6348 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
6349 if (p->sec == sec)
6350 {
6351 /* Everything must go for SEC. */
6352 *pp = p->next;
6353 break;
6354 }
6355 }
6356
6357 if (is_branch_reloc (r_type))
6358 {
6359 struct plt_entry **ifunc = NULL;
6360 if (h != NULL)
6361 {
6362 if (h->type == STT_GNU_IFUNC)
6363 ifunc = &h->plt.plist;
6364 }
6365 else if (local_got_ents != NULL)
6366 {
6367 struct plt_entry **local_plt = (struct plt_entry **)
6368 (local_got_ents + symtab_hdr->sh_info);
6369 unsigned char *local_got_tls_masks = (unsigned char *)
6370 (local_plt + symtab_hdr->sh_info);
6371 if ((local_got_tls_masks[r_symndx] & PLT_IFUNC) != 0)
6372 ifunc = local_plt + r_symndx;
6373 }
6374 if (ifunc != NULL)
6375 {
6376 struct plt_entry *ent;
6377
6378 for (ent = *ifunc; ent != NULL; ent = ent->next)
6379 if (ent->addend == rel->r_addend)
6380 break;
6381 if (ent == NULL)
6382 abort ();
6383 if (ent->plt.refcount > 0)
6384 ent->plt.refcount -= 1;
6385 continue;
6386 }
6387 }
6388
6389 switch (r_type)
6390 {
6391 case R_PPC64_GOT_TLSLD16:
6392 case R_PPC64_GOT_TLSLD16_LO:
6393 case R_PPC64_GOT_TLSLD16_HI:
6394 case R_PPC64_GOT_TLSLD16_HA:
6395 tls_type = TLS_TLS | TLS_LD;
6396 goto dogot;
6397
6398 case R_PPC64_GOT_TLSGD16:
6399 case R_PPC64_GOT_TLSGD16_LO:
6400 case R_PPC64_GOT_TLSGD16_HI:
6401 case R_PPC64_GOT_TLSGD16_HA:
6402 tls_type = TLS_TLS | TLS_GD;
6403 goto dogot;
6404
6405 case R_PPC64_GOT_TPREL16_DS:
6406 case R_PPC64_GOT_TPREL16_LO_DS:
6407 case R_PPC64_GOT_TPREL16_HI:
6408 case R_PPC64_GOT_TPREL16_HA:
6409 tls_type = TLS_TLS | TLS_TPREL;
6410 goto dogot;
6411
6412 case R_PPC64_GOT_DTPREL16_DS:
6413 case R_PPC64_GOT_DTPREL16_LO_DS:
6414 case R_PPC64_GOT_DTPREL16_HI:
6415 case R_PPC64_GOT_DTPREL16_HA:
6416 tls_type = TLS_TLS | TLS_DTPREL;
6417 goto dogot;
6418
6419 case R_PPC64_GOT16:
6420 case R_PPC64_GOT16_DS:
6421 case R_PPC64_GOT16_HA:
6422 case R_PPC64_GOT16_HI:
6423 case R_PPC64_GOT16_LO:
6424 case R_PPC64_GOT16_LO_DS:
6425 dogot:
6426 {
6427 struct got_entry *ent;
6428
6429 if (h != NULL)
6430 ent = h->got.glist;
6431 else
6432 ent = local_got_ents[r_symndx];
6433
6434 for (; ent != NULL; ent = ent->next)
6435 if (ent->addend == rel->r_addend
6436 && ent->owner == abfd
6437 && ent->tls_type == tls_type)
6438 break;
6439 if (ent == NULL)
6440 abort ();
6441 if (ent->got.refcount > 0)
6442 ent->got.refcount -= 1;
6443 }
6444 break;
6445
6446 case R_PPC64_PLT16_HA:
6447 case R_PPC64_PLT16_HI:
6448 case R_PPC64_PLT16_LO:
6449 case R_PPC64_PLT32:
6450 case R_PPC64_PLT64:
6451 case R_PPC64_REL14:
6452 case R_PPC64_REL14_BRNTAKEN:
6453 case R_PPC64_REL14_BRTAKEN:
6454 case R_PPC64_REL24:
6455 if (h != NULL)
6456 {
6457 struct plt_entry *ent;
6458
6459 for (ent = h->plt.plist; ent != NULL; ent = ent->next)
6460 if (ent->addend == rel->r_addend)
6461 break;
6462 if (ent != NULL && ent->plt.refcount > 0)
6463 ent->plt.refcount -= 1;
6464 }
6465 break;
6466
6467 default:
6468 break;
6469 }
6470 }
6471 return TRUE;
6472 }
6473
6474 /* The maximum size of .sfpr. */
6475 #define SFPR_MAX (218*4)
6476
6477 struct sfpr_def_parms
6478 {
6479 const char name[12];
6480 unsigned char lo, hi;
6481 bfd_byte * (*write_ent) (bfd *, bfd_byte *, int);
6482 bfd_byte * (*write_tail) (bfd *, bfd_byte *, int);
6483 };
6484
6485 /* Auto-generate _save*, _rest* functions in .sfpr. */
6486
6487 static bfd_boolean
6488 sfpr_define (struct bfd_link_info *info, const struct sfpr_def_parms *parm)
6489 {
6490 struct ppc_link_hash_table *htab = ppc_hash_table (info);
6491 unsigned int i;
6492 size_t len = strlen (parm->name);
6493 bfd_boolean writing = FALSE;
6494 char sym[16];
6495
6496 if (htab == NULL)
6497 return FALSE;
6498
6499 memcpy (sym, parm->name, len);
6500 sym[len + 2] = 0;
6501
6502 for (i = parm->lo; i <= parm->hi; i++)
6503 {
6504 struct elf_link_hash_entry *h;
6505
6506 sym[len + 0] = i / 10 + '0';
6507 sym[len + 1] = i % 10 + '0';
6508 h = elf_link_hash_lookup (&htab->elf, sym, FALSE, FALSE, TRUE);
6509 if (h != NULL
6510 && !h->def_regular)
6511 {
6512 h->root.type = bfd_link_hash_defined;
6513 h->root.u.def.section = htab->sfpr;
6514 h->root.u.def.value = htab->sfpr->size;
6515 h->type = STT_FUNC;
6516 h->def_regular = 1;
6517 _bfd_elf_link_hash_hide_symbol (info, h, TRUE);
6518 writing = TRUE;
6519 if (htab->sfpr->contents == NULL)
6520 {
6521 htab->sfpr->contents = bfd_alloc (htab->elf.dynobj, SFPR_MAX);
6522 if (htab->sfpr->contents == NULL)
6523 return FALSE;
6524 }
6525 }
6526 if (writing)
6527 {
6528 bfd_byte *p = htab->sfpr->contents + htab->sfpr->size;
6529 if (i != parm->hi)
6530 p = (*parm->write_ent) (htab->elf.dynobj, p, i);
6531 else
6532 p = (*parm->write_tail) (htab->elf.dynobj, p, i);
6533 htab->sfpr->size = p - htab->sfpr->contents;
6534 }
6535 }
6536
6537 return TRUE;
6538 }
6539
6540 static bfd_byte *
6541 savegpr0 (bfd *abfd, bfd_byte *p, int r)
6542 {
6543 bfd_put_32 (abfd, STD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6544 return p + 4;
6545 }
6546
6547 static bfd_byte *
6548 savegpr0_tail (bfd *abfd, bfd_byte *p, int r)
6549 {
6550 p = savegpr0 (abfd, p, r);
6551 bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
6552 p = p + 4;
6553 bfd_put_32 (abfd, BLR, p);
6554 return p + 4;
6555 }
6556
6557 static bfd_byte *
6558 restgpr0 (bfd *abfd, bfd_byte *p, int r)
6559 {
6560 bfd_put_32 (abfd, LD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6561 return p + 4;
6562 }
6563
6564 static bfd_byte *
6565 restgpr0_tail (bfd *abfd, bfd_byte *p, int r)
6566 {
6567 bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
6568 p = p + 4;
6569 p = restgpr0 (abfd, p, r);
6570 bfd_put_32 (abfd, MTLR_R0, p);
6571 p = p + 4;
6572 if (r == 29)
6573 {
6574 p = restgpr0 (abfd, p, 30);
6575 p = restgpr0 (abfd, p, 31);
6576 }
6577 bfd_put_32 (abfd, BLR, p);
6578 return p + 4;
6579 }
6580
6581 static bfd_byte *
6582 savegpr1 (bfd *abfd, bfd_byte *p, int r)
6583 {
6584 bfd_put_32 (abfd, STD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6585 return p + 4;
6586 }
6587
6588 static bfd_byte *
6589 savegpr1_tail (bfd *abfd, bfd_byte *p, int r)
6590 {
6591 p = savegpr1 (abfd, p, r);
6592 bfd_put_32 (abfd, BLR, p);
6593 return p + 4;
6594 }
6595
6596 static bfd_byte *
6597 restgpr1 (bfd *abfd, bfd_byte *p, int r)
6598 {
6599 bfd_put_32 (abfd, LD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6600 return p + 4;
6601 }
6602
6603 static bfd_byte *
6604 restgpr1_tail (bfd *abfd, bfd_byte *p, int r)
6605 {
6606 p = restgpr1 (abfd, p, r);
6607 bfd_put_32 (abfd, BLR, p);
6608 return p + 4;
6609 }
6610
6611 static bfd_byte *
6612 savefpr (bfd *abfd, bfd_byte *p, int r)
6613 {
6614 bfd_put_32 (abfd, STFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6615 return p + 4;
6616 }
6617
6618 static bfd_byte *
6619 savefpr0_tail (bfd *abfd, bfd_byte *p, int r)
6620 {
6621 p = savefpr (abfd, p, r);
6622 bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
6623 p = p + 4;
6624 bfd_put_32 (abfd, BLR, p);
6625 return p + 4;
6626 }
6627
6628 static bfd_byte *
6629 restfpr (bfd *abfd, bfd_byte *p, int r)
6630 {
6631 bfd_put_32 (abfd, LFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6632 return p + 4;
6633 }
6634
6635 static bfd_byte *
6636 restfpr0_tail (bfd *abfd, bfd_byte *p, int r)
6637 {
6638 bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
6639 p = p + 4;
6640 p = restfpr (abfd, p, r);
6641 bfd_put_32 (abfd, MTLR_R0, p);
6642 p = p + 4;
6643 if (r == 29)
6644 {
6645 p = restfpr (abfd, p, 30);
6646 p = restfpr (abfd, p, 31);
6647 }
6648 bfd_put_32 (abfd, BLR, p);
6649 return p + 4;
6650 }
6651
6652 static bfd_byte *
6653 savefpr1_tail (bfd *abfd, bfd_byte *p, int r)
6654 {
6655 p = savefpr (abfd, p, r);
6656 bfd_put_32 (abfd, BLR, p);
6657 return p + 4;
6658 }
6659
6660 static bfd_byte *
6661 restfpr1_tail (bfd *abfd, bfd_byte *p, int r)
6662 {
6663 p = restfpr (abfd, p, r);
6664 bfd_put_32 (abfd, BLR, p);
6665 return p + 4;
6666 }
6667
6668 static bfd_byte *
6669 savevr (bfd *abfd, bfd_byte *p, int r)
6670 {
6671 bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6672 p = p + 4;
6673 bfd_put_32 (abfd, STVX_VR0_R12_R0 + (r << 21), p);
6674 return p + 4;
6675 }
6676
6677 static bfd_byte *
6678 savevr_tail (bfd *abfd, bfd_byte *p, int r)
6679 {
6680 p = savevr (abfd, p, r);
6681 bfd_put_32 (abfd, BLR, p);
6682 return p + 4;
6683 }
6684
6685 static bfd_byte *
6686 restvr (bfd *abfd, bfd_byte *p, int r)
6687 {
6688 bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6689 p = p + 4;
6690 bfd_put_32 (abfd, LVX_VR0_R12_R0 + (r << 21), p);
6691 return p + 4;
6692 }
6693
6694 static bfd_byte *
6695 restvr_tail (bfd *abfd, bfd_byte *p, int r)
6696 {
6697 p = restvr (abfd, p, r);
6698 bfd_put_32 (abfd, BLR, p);
6699 return p + 4;
6700 }
6701
6702 /* Called via elf_link_hash_traverse to transfer dynamic linking
6703 information on function code symbol entries to their corresponding
6704 function descriptor symbol entries. */
6705
6706 static bfd_boolean
6707 func_desc_adjust (struct elf_link_hash_entry *h, void *inf)
6708 {
6709 struct bfd_link_info *info;
6710 struct ppc_link_hash_table *htab;
6711 struct plt_entry *ent;
6712 struct ppc_link_hash_entry *fh;
6713 struct ppc_link_hash_entry *fdh;
6714 bfd_boolean force_local;
6715
6716 fh = (struct ppc_link_hash_entry *) h;
6717 if (fh->elf.root.type == bfd_link_hash_indirect)
6718 return TRUE;
6719
6720 info = inf;
6721 htab = ppc_hash_table (info);
6722 if (htab == NULL)
6723 return FALSE;
6724
6725 /* Resolve undefined references to dot-symbols as the value
6726 in the function descriptor, if we have one in a regular object.
6727 This is to satisfy cases like ".quad .foo". Calls to functions
6728 in dynamic objects are handled elsewhere. */
6729 if (fh->elf.root.type == bfd_link_hash_undefweak
6730 && fh->was_undefined
6731 && (fdh = defined_func_desc (fh)) != NULL
6732 && get_opd_info (fdh->elf.root.u.def.section) != NULL
6733 && opd_entry_value (fdh->elf.root.u.def.section,
6734 fdh->elf.root.u.def.value,
6735 &fh->elf.root.u.def.section,
6736 &fh->elf.root.u.def.value, FALSE) != (bfd_vma) -1)
6737 {
6738 fh->elf.root.type = fdh->elf.root.type;
6739 fh->elf.forced_local = 1;
6740 fh->elf.def_regular = fdh->elf.def_regular;
6741 fh->elf.def_dynamic = fdh->elf.def_dynamic;
6742 }
6743
6744 /* If this is a function code symbol, transfer dynamic linking
6745 information to the function descriptor symbol. */
6746 if (!fh->is_func)
6747 return TRUE;
6748
6749 for (ent = fh->elf.plt.plist; ent != NULL; ent = ent->next)
6750 if (ent->plt.refcount > 0)
6751 break;
6752 if (ent == NULL
6753 || fh->elf.root.root.string[0] != '.'
6754 || fh->elf.root.root.string[1] == '\0')
6755 return TRUE;
6756
6757 /* Find the corresponding function descriptor symbol. Create it
6758 as undefined if necessary. */
6759
6760 fdh = lookup_fdh (fh, htab);
6761 if (fdh == NULL
6762 && !info->executable
6763 && (fh->elf.root.type == bfd_link_hash_undefined
6764 || fh->elf.root.type == bfd_link_hash_undefweak))
6765 {
6766 fdh = make_fdh (info, fh);
6767 if (fdh == NULL)
6768 return FALSE;
6769 }
6770
6771 /* Fake function descriptors are made undefweak. If the function
6772 code symbol is strong undefined, make the fake sym the same.
6773 If the function code symbol is defined, then force the fake
6774 descriptor local; We can't support overriding of symbols in a
6775 shared library on a fake descriptor. */
6776
6777 if (fdh != NULL
6778 && fdh->fake
6779 && fdh->elf.root.type == bfd_link_hash_undefweak)
6780 {
6781 if (fh->elf.root.type == bfd_link_hash_undefined)
6782 {
6783 fdh->elf.root.type = bfd_link_hash_undefined;
6784 bfd_link_add_undef (&htab->elf.root, &fdh->elf.root);
6785 }
6786 else if (fh->elf.root.type == bfd_link_hash_defined
6787 || fh->elf.root.type == bfd_link_hash_defweak)
6788 {
6789 _bfd_elf_link_hash_hide_symbol (info, &fdh->elf, TRUE);
6790 }
6791 }
6792
6793 if (fdh != NULL
6794 && !fdh->elf.forced_local
6795 && (!info->executable
6796 || fdh->elf.def_dynamic
6797 || fdh->elf.ref_dynamic
6798 || (fdh->elf.root.type == bfd_link_hash_undefweak
6799 && ELF_ST_VISIBILITY (fdh->elf.other) == STV_DEFAULT)))
6800 {
6801 if (fdh->elf.dynindx == -1)
6802 if (! bfd_elf_link_record_dynamic_symbol (info, &fdh->elf))
6803 return FALSE;
6804 fdh->elf.ref_regular |= fh->elf.ref_regular;
6805 fdh->elf.ref_dynamic |= fh->elf.ref_dynamic;
6806 fdh->elf.ref_regular_nonweak |= fh->elf.ref_regular_nonweak;
6807 fdh->elf.non_got_ref |= fh->elf.non_got_ref;
6808 if (ELF_ST_VISIBILITY (fh->elf.other) == STV_DEFAULT)
6809 {
6810 move_plt_plist (fh, fdh);
6811 fdh->elf.needs_plt = 1;
6812 }
6813 fdh->is_func_descriptor = 1;
6814 fdh->oh = fh;
6815 fh->oh = fdh;
6816 }
6817
6818 /* Now that the info is on the function descriptor, clear the
6819 function code sym info. Any function code syms for which we
6820 don't have a definition in a regular file, we force local.
6821 This prevents a shared library from exporting syms that have
6822 been imported from another library. Function code syms that
6823 are really in the library we must leave global to prevent the
6824 linker dragging in a definition from a static library. */
6825 force_local = (!fh->elf.def_regular
6826 || fdh == NULL
6827 || !fdh->elf.def_regular
6828 || fdh->elf.forced_local);
6829 _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
6830
6831 return TRUE;
6832 }
6833
6834 /* Called near the start of bfd_elf_size_dynamic_sections. We use
6835 this hook to a) provide some gcc support functions, and b) transfer
6836 dynamic linking information gathered so far on function code symbol
6837 entries, to their corresponding function descriptor symbol entries. */
6838
6839 static bfd_boolean
6840 ppc64_elf_func_desc_adjust (bfd *obfd ATTRIBUTE_UNUSED,
6841 struct bfd_link_info *info)
6842 {
6843 struct ppc_link_hash_table *htab;
6844 unsigned int i;
6845 static const struct sfpr_def_parms funcs[] =
6846 {
6847 { "_savegpr0_", 14, 31, savegpr0, savegpr0_tail },
6848 { "_restgpr0_", 14, 29, restgpr0, restgpr0_tail },
6849 { "_restgpr0_", 30, 31, restgpr0, restgpr0_tail },
6850 { "_savegpr1_", 14, 31, savegpr1, savegpr1_tail },
6851 { "_restgpr1_", 14, 31, restgpr1, restgpr1_tail },
6852 { "_savefpr_", 14, 31, savefpr, savefpr0_tail },
6853 { "_restfpr_", 14, 29, restfpr, restfpr0_tail },
6854 { "_restfpr_", 30, 31, restfpr, restfpr0_tail },
6855 { "._savef", 14, 31, savefpr, savefpr1_tail },
6856 { "._restf", 14, 31, restfpr, restfpr1_tail },
6857 { "_savevr_", 20, 31, savevr, savevr_tail },
6858 { "_restvr_", 20, 31, restvr, restvr_tail }
6859 };
6860
6861 htab = ppc_hash_table (info);
6862 if (htab == NULL)
6863 return FALSE;
6864
6865 if (!info->relocatable
6866 && htab->elf.hgot != NULL)
6867 {
6868 _bfd_elf_link_hash_hide_symbol (info, htab->elf.hgot, TRUE);
6869 /* Make .TOC. defined so as to prevent it being made dynamic.
6870 The wrong value here is fixed later in ppc64_elf_set_toc. */
6871 htab->elf.hgot->type = STT_OBJECT;
6872 htab->elf.hgot->root.type = bfd_link_hash_defined;
6873 htab->elf.hgot->root.u.def.value = 0;
6874 htab->elf.hgot->root.u.def.section = bfd_abs_section_ptr;
6875 htab->elf.hgot->def_regular = 1;
6876 htab->elf.hgot->other = ((htab->elf.hgot->other & ~ELF_ST_VISIBILITY (-1))
6877 | STV_HIDDEN);
6878 }
6879
6880 if (htab->sfpr == NULL)
6881 /* We don't have any relocs. */
6882 return TRUE;
6883
6884 /* Provide any missing _save* and _rest* functions. */
6885 htab->sfpr->size = 0;
6886 if (htab->params->save_restore_funcs)
6887 for (i = 0; i < sizeof (funcs) / sizeof (funcs[0]); i++)
6888 if (!sfpr_define (info, &funcs[i]))
6889 return FALSE;
6890
6891 elf_link_hash_traverse (&htab->elf, func_desc_adjust, info);
6892
6893 if (htab->sfpr->size == 0)
6894 htab->sfpr->flags |= SEC_EXCLUDE;
6895
6896 return TRUE;
6897 }
6898
6899 /* Return true if we have dynamic relocs that apply to read-only sections. */
6900
6901 static bfd_boolean
6902 readonly_dynrelocs (struct elf_link_hash_entry *h)
6903 {
6904 struct ppc_link_hash_entry *eh;
6905 struct elf_dyn_relocs *p;
6906
6907 eh = (struct ppc_link_hash_entry *) h;
6908 for (p = eh->dyn_relocs; p != NULL; p = p->next)
6909 {
6910 asection *s = p->sec->output_section;
6911
6912 if (s != NULL && (s->flags & SEC_READONLY) != 0)
6913 return TRUE;
6914 }
6915 return FALSE;
6916 }
6917
6918 /* Adjust a symbol defined by a dynamic object and referenced by a
6919 regular object. The current definition is in some section of the
6920 dynamic object, but we're not including those sections. We have to
6921 change the definition to something the rest of the link can
6922 understand. */
6923
6924 static bfd_boolean
6925 ppc64_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
6926 struct elf_link_hash_entry *h)
6927 {
6928 struct ppc_link_hash_table *htab;
6929 asection *s;
6930
6931 htab = ppc_hash_table (info);
6932 if (htab == NULL)
6933 return FALSE;
6934
6935 /* Deal with function syms. */
6936 if (h->type == STT_FUNC
6937 || h->type == STT_GNU_IFUNC
6938 || h->needs_plt)
6939 {
6940 /* Clear procedure linkage table information for any symbol that
6941 won't need a .plt entry. */
6942 struct plt_entry *ent;
6943 for (ent = h->plt.plist; ent != NULL; ent = ent->next)
6944 if (ent->plt.refcount > 0)
6945 break;
6946 if (ent == NULL
6947 || (h->type != STT_GNU_IFUNC
6948 && (SYMBOL_CALLS_LOCAL (info, h)
6949 || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
6950 && h->root.type == bfd_link_hash_undefweak))))
6951 {
6952 h->plt.plist = NULL;
6953 h->needs_plt = 0;
6954 }
6955 else if (abiversion (info->output_bfd) == 2)
6956 {
6957 /* After adjust_dynamic_symbol, non_got_ref set in the
6958 non-shared case means that we have allocated space in
6959 .dynbss for the symbol and thus dyn_relocs for this
6960 symbol should be discarded.
6961 If we get here we know we are making a PLT entry for this
6962 symbol, and in an executable we'd normally resolve
6963 relocations against this symbol to the PLT entry. Allow
6964 dynamic relocs if the reference is weak, and the dynamic
6965 relocs will not cause text relocation. */
6966 if (!h->ref_regular_nonweak
6967 && h->non_got_ref
6968 && h->type != STT_GNU_IFUNC
6969 && !readonly_dynrelocs (h))
6970 h->non_got_ref = 0;
6971
6972 /* If making a plt entry, then we don't need copy relocs. */
6973 return TRUE;
6974 }
6975 }
6976 else
6977 h->plt.plist = NULL;
6978
6979 /* If this is a weak symbol, and there is a real definition, the
6980 processor independent code will have arranged for us to see the
6981 real definition first, and we can just use the same value. */
6982 if (h->u.weakdef != NULL)
6983 {
6984 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
6985 || h->u.weakdef->root.type == bfd_link_hash_defweak);
6986 h->root.u.def.section = h->u.weakdef->root.u.def.section;
6987 h->root.u.def.value = h->u.weakdef->root.u.def.value;
6988 if (ELIMINATE_COPY_RELOCS)
6989 h->non_got_ref = h->u.weakdef->non_got_ref;
6990 return TRUE;
6991 }
6992
6993 /* If we are creating a shared library, we must presume that the
6994 only references to the symbol are via the global offset table.
6995 For such cases we need not do anything here; the relocations will
6996 be handled correctly by relocate_section. */
6997 if (info->shared)
6998 return TRUE;
6999
7000 /* If there are no references to this symbol that do not use the
7001 GOT, we don't need to generate a copy reloc. */
7002 if (!h->non_got_ref)
7003 return TRUE;
7004
7005 /* Don't generate a copy reloc for symbols defined in the executable. */
7006 if (!h->def_dynamic || !h->ref_regular || h->def_regular)
7007 return TRUE;
7008
7009 /* If we didn't find any dynamic relocs in read-only sections, then
7010 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
7011 if (ELIMINATE_COPY_RELOCS && !readonly_dynrelocs (h))
7012 {
7013 h->non_got_ref = 0;
7014 return TRUE;
7015 }
7016
7017 if (h->plt.plist != NULL)
7018 {
7019 /* We should never get here, but unfortunately there are versions
7020 of gcc out there that improperly (for this ABI) put initialized
7021 function pointers, vtable refs and suchlike in read-only
7022 sections. Allow them to proceed, but warn that this might
7023 break at runtime. */
7024 info->callbacks->einfo
7025 (_("%P: copy reloc against `%T' requires lazy plt linking; "
7026 "avoid setting LD_BIND_NOW=1 or upgrade gcc\n"),
7027 h->root.root.string);
7028 }
7029
7030 /* This is a reference to a symbol defined by a dynamic object which
7031 is not a function. */
7032
7033 /* We must allocate the symbol in our .dynbss section, which will
7034 become part of the .bss section of the executable. There will be
7035 an entry for this symbol in the .dynsym section. The dynamic
7036 object will contain position independent code, so all references
7037 from the dynamic object to this symbol will go through the global
7038 offset table. The dynamic linker will use the .dynsym entry to
7039 determine the address it must put in the global offset table, so
7040 both the dynamic object and the regular object will refer to the
7041 same memory location for the variable. */
7042
7043 /* We must generate a R_PPC64_COPY reloc to tell the dynamic linker
7044 to copy the initial value out of the dynamic object and into the
7045 runtime process image. We need to remember the offset into the
7046 .rela.bss section we are going to use. */
7047 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
7048 {
7049 htab->relbss->size += sizeof (Elf64_External_Rela);
7050 h->needs_copy = 1;
7051 }
7052
7053 s = htab->dynbss;
7054
7055 return _bfd_elf_adjust_dynamic_copy (h, s);
7056 }
7057
7058 /* If given a function descriptor symbol, hide both the function code
7059 sym and the descriptor. */
7060 static void
7061 ppc64_elf_hide_symbol (struct bfd_link_info *info,
7062 struct elf_link_hash_entry *h,
7063 bfd_boolean force_local)
7064 {
7065 struct ppc_link_hash_entry *eh;
7066 _bfd_elf_link_hash_hide_symbol (info, h, force_local);
7067
7068 eh = (struct ppc_link_hash_entry *) h;
7069 if (eh->is_func_descriptor)
7070 {
7071 struct ppc_link_hash_entry *fh = eh->oh;
7072
7073 if (fh == NULL)
7074 {
7075 const char *p, *q;
7076 struct ppc_link_hash_table *htab;
7077 char save;
7078
7079 /* We aren't supposed to use alloca in BFD because on
7080 systems which do not have alloca the version in libiberty
7081 calls xmalloc, which might cause the program to crash
7082 when it runs out of memory. This function doesn't have a
7083 return status, so there's no way to gracefully return an
7084 error. So cheat. We know that string[-1] can be safely
7085 accessed; It's either a string in an ELF string table,
7086 or allocated in an objalloc structure. */
7087
7088 p = eh->elf.root.root.string - 1;
7089 save = *p;
7090 *(char *) p = '.';
7091 htab = ppc_hash_table (info);
7092 if (htab == NULL)
7093 return;
7094
7095 fh = (struct ppc_link_hash_entry *)
7096 elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
7097 *(char *) p = save;
7098
7099 /* Unfortunately, if it so happens that the string we were
7100 looking for was allocated immediately before this string,
7101 then we overwrote the string terminator. That's the only
7102 reason the lookup should fail. */
7103 if (fh == NULL)
7104 {
7105 q = eh->elf.root.root.string + strlen (eh->elf.root.root.string);
7106 while (q >= eh->elf.root.root.string && *q == *p)
7107 --q, --p;
7108 if (q < eh->elf.root.root.string && *p == '.')
7109 fh = (struct ppc_link_hash_entry *)
7110 elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
7111 }
7112 if (fh != NULL)
7113 {
7114 eh->oh = fh;
7115 fh->oh = eh;
7116 }
7117 }
7118 if (fh != NULL)
7119 _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
7120 }
7121 }
7122
7123 static bfd_boolean
7124 get_sym_h (struct elf_link_hash_entry **hp,
7125 Elf_Internal_Sym **symp,
7126 asection **symsecp,
7127 unsigned char **tls_maskp,
7128 Elf_Internal_Sym **locsymsp,
7129 unsigned long r_symndx,
7130 bfd *ibfd)
7131 {
7132 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
7133
7134 if (r_symndx >= symtab_hdr->sh_info)
7135 {
7136 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
7137 struct elf_link_hash_entry *h;
7138
7139 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
7140 h = elf_follow_link (h);
7141
7142 if (hp != NULL)
7143 *hp = h;
7144
7145 if (symp != NULL)
7146 *symp = NULL;
7147
7148 if (symsecp != NULL)
7149 {
7150 asection *symsec = NULL;
7151 if (h->root.type == bfd_link_hash_defined
7152 || h->root.type == bfd_link_hash_defweak)
7153 symsec = h->root.u.def.section;
7154 *symsecp = symsec;
7155 }
7156
7157 if (tls_maskp != NULL)
7158 {
7159 struct ppc_link_hash_entry *eh;
7160
7161 eh = (struct ppc_link_hash_entry *) h;
7162 *tls_maskp = &eh->tls_mask;
7163 }
7164 }
7165 else
7166 {
7167 Elf_Internal_Sym *sym;
7168 Elf_Internal_Sym *locsyms = *locsymsp;
7169
7170 if (locsyms == NULL)
7171 {
7172 locsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
7173 if (locsyms == NULL)
7174 locsyms = bfd_elf_get_elf_syms (ibfd, symtab_hdr,
7175 symtab_hdr->sh_info,
7176 0, NULL, NULL, NULL);
7177 if (locsyms == NULL)
7178 return FALSE;
7179 *locsymsp = locsyms;
7180 }
7181 sym = locsyms + r_symndx;
7182
7183 if (hp != NULL)
7184 *hp = NULL;
7185
7186 if (symp != NULL)
7187 *symp = sym;
7188
7189 if (symsecp != NULL)
7190 *symsecp = bfd_section_from_elf_index (ibfd, sym->st_shndx);
7191
7192 if (tls_maskp != NULL)
7193 {
7194 struct got_entry **lgot_ents;
7195 unsigned char *tls_mask;
7196
7197 tls_mask = NULL;
7198 lgot_ents = elf_local_got_ents (ibfd);
7199 if (lgot_ents != NULL)
7200 {
7201 struct plt_entry **local_plt = (struct plt_entry **)
7202 (lgot_ents + symtab_hdr->sh_info);
7203 unsigned char *lgot_masks = (unsigned char *)
7204 (local_plt + symtab_hdr->sh_info);
7205 tls_mask = &lgot_masks[r_symndx];
7206 }
7207 *tls_maskp = tls_mask;
7208 }
7209 }
7210 return TRUE;
7211 }
7212
7213 /* Returns TLS_MASKP for the given REL symbol. Function return is 0 on
7214 error, 2 on a toc GD type suitable for optimization, 3 on a toc LD
7215 type suitable for optimization, and 1 otherwise. */
7216
7217 static int
7218 get_tls_mask (unsigned char **tls_maskp,
7219 unsigned long *toc_symndx,
7220 bfd_vma *toc_addend,
7221 Elf_Internal_Sym **locsymsp,
7222 const Elf_Internal_Rela *rel,
7223 bfd *ibfd)
7224 {
7225 unsigned long r_symndx;
7226 int next_r;
7227 struct elf_link_hash_entry *h;
7228 Elf_Internal_Sym *sym;
7229 asection *sec;
7230 bfd_vma off;
7231
7232 r_symndx = ELF64_R_SYM (rel->r_info);
7233 if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7234 return 0;
7235
7236 if ((*tls_maskp != NULL && **tls_maskp != 0)
7237 || sec == NULL
7238 || ppc64_elf_section_data (sec) == NULL
7239 || ppc64_elf_section_data (sec)->sec_type != sec_toc)
7240 return 1;
7241
7242 /* Look inside a TOC section too. */
7243 if (h != NULL)
7244 {
7245 BFD_ASSERT (h->root.type == bfd_link_hash_defined);
7246 off = h->root.u.def.value;
7247 }
7248 else
7249 off = sym->st_value;
7250 off += rel->r_addend;
7251 BFD_ASSERT (off % 8 == 0);
7252 r_symndx = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8];
7253 next_r = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8 + 1];
7254 if (toc_symndx != NULL)
7255 *toc_symndx = r_symndx;
7256 if (toc_addend != NULL)
7257 *toc_addend = ppc64_elf_section_data (sec)->u.toc.add[off / 8];
7258 if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7259 return 0;
7260 if ((h == NULL || is_static_defined (h))
7261 && (next_r == -1 || next_r == -2))
7262 return 1 - next_r;
7263 return 1;
7264 }
7265
7266 /* Find (or create) an entry in the tocsave hash table. */
7267
7268 static struct tocsave_entry *
7269 tocsave_find (struct ppc_link_hash_table *htab,
7270 enum insert_option insert,
7271 Elf_Internal_Sym **local_syms,
7272 const Elf_Internal_Rela *irela,
7273 bfd *ibfd)
7274 {
7275 unsigned long r_indx;
7276 struct elf_link_hash_entry *h;
7277 Elf_Internal_Sym *sym;
7278 struct tocsave_entry ent, *p;
7279 hashval_t hash;
7280 struct tocsave_entry **slot;
7281
7282 r_indx = ELF64_R_SYM (irela->r_info);
7283 if (!get_sym_h (&h, &sym, &ent.sec, NULL, local_syms, r_indx, ibfd))
7284 return NULL;
7285 if (ent.sec == NULL || ent.sec->output_section == NULL)
7286 {
7287 (*_bfd_error_handler)
7288 (_("%B: undefined symbol on R_PPC64_TOCSAVE relocation"));
7289 return NULL;
7290 }
7291
7292 if (h != NULL)
7293 ent.offset = h->root.u.def.value;
7294 else
7295 ent.offset = sym->st_value;
7296 ent.offset += irela->r_addend;
7297
7298 hash = tocsave_htab_hash (&ent);
7299 slot = ((struct tocsave_entry **)
7300 htab_find_slot_with_hash (htab->tocsave_htab, &ent, hash, insert));
7301 if (slot == NULL)
7302 return NULL;
7303
7304 if (*slot == NULL)
7305 {
7306 p = (struct tocsave_entry *) bfd_alloc (ibfd, sizeof (*p));
7307 if (p == NULL)
7308 return NULL;
7309 *p = ent;
7310 *slot = p;
7311 }
7312 return *slot;
7313 }
7314
7315 /* Adjust all global syms defined in opd sections. In gcc generated
7316 code for the old ABI, these will already have been done. */
7317
7318 static bfd_boolean
7319 adjust_opd_syms (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
7320 {
7321 struct ppc_link_hash_entry *eh;
7322 asection *sym_sec;
7323 struct _opd_sec_data *opd;
7324
7325 if (h->root.type == bfd_link_hash_indirect)
7326 return TRUE;
7327
7328 if (h->root.type != bfd_link_hash_defined
7329 && h->root.type != bfd_link_hash_defweak)
7330 return TRUE;
7331
7332 eh = (struct ppc_link_hash_entry *) h;
7333 if (eh->adjust_done)
7334 return TRUE;
7335
7336 sym_sec = eh->elf.root.u.def.section;
7337 opd = get_opd_info (sym_sec);
7338 if (opd != NULL && opd->adjust != NULL)
7339 {
7340 long adjust = opd->adjust[eh->elf.root.u.def.value / 8];
7341 if (adjust == -1)
7342 {
7343 /* This entry has been deleted. */
7344 asection *dsec = ppc64_elf_tdata (sym_sec->owner)->deleted_section;
7345 if (dsec == NULL)
7346 {
7347 for (dsec = sym_sec->owner->sections; dsec; dsec = dsec->next)
7348 if (discarded_section (dsec))
7349 {
7350 ppc64_elf_tdata (sym_sec->owner)->deleted_section = dsec;
7351 break;
7352 }
7353 }
7354 eh->elf.root.u.def.value = 0;
7355 eh->elf.root.u.def.section = dsec;
7356 }
7357 else
7358 eh->elf.root.u.def.value += adjust;
7359 eh->adjust_done = 1;
7360 }
7361 return TRUE;
7362 }
7363
7364 /* Handles decrementing dynamic reloc counts for the reloc specified by
7365 R_INFO in section SEC. If LOCAL_SYMS is NULL, then H and SYM
7366 have already been determined. */
7367
7368 static bfd_boolean
7369 dec_dynrel_count (bfd_vma r_info,
7370 asection *sec,
7371 struct bfd_link_info *info,
7372 Elf_Internal_Sym **local_syms,
7373 struct elf_link_hash_entry *h,
7374 Elf_Internal_Sym *sym)
7375 {
7376 enum elf_ppc64_reloc_type r_type;
7377 asection *sym_sec = NULL;
7378
7379 /* Can this reloc be dynamic? This switch, and later tests here
7380 should be kept in sync with the code in check_relocs. */
7381 r_type = ELF64_R_TYPE (r_info);
7382 switch (r_type)
7383 {
7384 default:
7385 return TRUE;
7386
7387 case R_PPC64_TPREL16:
7388 case R_PPC64_TPREL16_LO:
7389 case R_PPC64_TPREL16_HI:
7390 case R_PPC64_TPREL16_HA:
7391 case R_PPC64_TPREL16_DS:
7392 case R_PPC64_TPREL16_LO_DS:
7393 case R_PPC64_TPREL16_HIGH:
7394 case R_PPC64_TPREL16_HIGHA:
7395 case R_PPC64_TPREL16_HIGHER:
7396 case R_PPC64_TPREL16_HIGHERA:
7397 case R_PPC64_TPREL16_HIGHEST:
7398 case R_PPC64_TPREL16_HIGHESTA:
7399 if (!info->shared)
7400 return TRUE;
7401
7402 case R_PPC64_TPREL64:
7403 case R_PPC64_DTPMOD64:
7404 case R_PPC64_DTPREL64:
7405 case R_PPC64_ADDR64:
7406 case R_PPC64_REL30:
7407 case R_PPC64_REL32:
7408 case R_PPC64_REL64:
7409 case R_PPC64_ADDR14:
7410 case R_PPC64_ADDR14_BRNTAKEN:
7411 case R_PPC64_ADDR14_BRTAKEN:
7412 case R_PPC64_ADDR16:
7413 case R_PPC64_ADDR16_DS:
7414 case R_PPC64_ADDR16_HA:
7415 case R_PPC64_ADDR16_HI:
7416 case R_PPC64_ADDR16_HIGH:
7417 case R_PPC64_ADDR16_HIGHA:
7418 case R_PPC64_ADDR16_HIGHER:
7419 case R_PPC64_ADDR16_HIGHERA:
7420 case R_PPC64_ADDR16_HIGHEST:
7421 case R_PPC64_ADDR16_HIGHESTA:
7422 case R_PPC64_ADDR16_LO:
7423 case R_PPC64_ADDR16_LO_DS:
7424 case R_PPC64_ADDR24:
7425 case R_PPC64_ADDR32:
7426 case R_PPC64_UADDR16:
7427 case R_PPC64_UADDR32:
7428 case R_PPC64_UADDR64:
7429 case R_PPC64_TOC:
7430 break;
7431 }
7432
7433 if (local_syms != NULL)
7434 {
7435 unsigned long r_symndx;
7436 bfd *ibfd = sec->owner;
7437
7438 r_symndx = ELF64_R_SYM (r_info);
7439 if (!get_sym_h (&h, &sym, &sym_sec, NULL, local_syms, r_symndx, ibfd))
7440 return FALSE;
7441 }
7442
7443 if ((info->shared
7444 && (must_be_dyn_reloc (info, r_type)
7445 || (h != NULL
7446 && (!SYMBOLIC_BIND (info, h)
7447 || h->root.type == bfd_link_hash_defweak
7448 || !h->def_regular))))
7449 || (ELIMINATE_COPY_RELOCS
7450 && !info->shared
7451 && h != NULL
7452 && (h->root.type == bfd_link_hash_defweak
7453 || !h->def_regular)))
7454 ;
7455 else
7456 return TRUE;
7457
7458 if (h != NULL)
7459 {
7460 struct elf_dyn_relocs *p;
7461 struct elf_dyn_relocs **pp;
7462 pp = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
7463
7464 /* elf_gc_sweep may have already removed all dyn relocs associated
7465 with local syms for a given section. Also, symbol flags are
7466 changed by elf_gc_sweep_symbol, confusing the test above. Don't
7467 report a dynreloc miscount. */
7468 if (*pp == NULL && info->gc_sections)
7469 return TRUE;
7470
7471 while ((p = *pp) != NULL)
7472 {
7473 if (p->sec == sec)
7474 {
7475 if (!must_be_dyn_reloc (info, r_type))
7476 p->pc_count -= 1;
7477 p->count -= 1;
7478 if (p->count == 0)
7479 *pp = p->next;
7480 return TRUE;
7481 }
7482 pp = &p->next;
7483 }
7484 }
7485 else
7486 {
7487 struct ppc_dyn_relocs *p;
7488 struct ppc_dyn_relocs **pp;
7489 void *vpp;
7490 bfd_boolean is_ifunc;
7491
7492 if (local_syms == NULL)
7493 sym_sec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
7494 if (sym_sec == NULL)
7495 sym_sec = sec;
7496
7497 vpp = &elf_section_data (sym_sec)->local_dynrel;
7498 pp = (struct ppc_dyn_relocs **) vpp;
7499
7500 if (*pp == NULL && info->gc_sections)
7501 return TRUE;
7502
7503 is_ifunc = ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC;
7504 while ((p = *pp) != NULL)
7505 {
7506 if (p->sec == sec && p->ifunc == is_ifunc)
7507 {
7508 p->count -= 1;
7509 if (p->count == 0)
7510 *pp = p->next;
7511 return TRUE;
7512 }
7513 pp = &p->next;
7514 }
7515 }
7516
7517 info->callbacks->einfo (_("%P: dynreloc miscount for %B, section %A\n"),
7518 sec->owner, sec);
7519 bfd_set_error (bfd_error_bad_value);
7520 return FALSE;
7521 }
7522
7523 /* Remove unused Official Procedure Descriptor entries. Currently we
7524 only remove those associated with functions in discarded link-once
7525 sections, or weakly defined functions that have been overridden. It
7526 would be possible to remove many more entries for statically linked
7527 applications. */
7528
7529 bfd_boolean
7530 ppc64_elf_edit_opd (struct bfd_link_info *info)
7531 {
7532 bfd *ibfd;
7533 bfd_boolean some_edited = FALSE;
7534 asection *need_pad = NULL;
7535 struct ppc_link_hash_table *htab;
7536
7537 htab = ppc_hash_table (info);
7538 if (htab == NULL)
7539 return FALSE;
7540
7541 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
7542 {
7543 asection *sec;
7544 Elf_Internal_Rela *relstart, *rel, *relend;
7545 Elf_Internal_Shdr *symtab_hdr;
7546 Elf_Internal_Sym *local_syms;
7547 bfd_vma offset;
7548 struct _opd_sec_data *opd;
7549 bfd_boolean need_edit, add_aux_fields;
7550 bfd_size_type cnt_16b = 0;
7551
7552 if (!is_ppc64_elf (ibfd))
7553 continue;
7554
7555 sec = bfd_get_section_by_name (ibfd, ".opd");
7556 if (sec == NULL || sec->size == 0)
7557 continue;
7558
7559 if (sec->sec_info_type == SEC_INFO_TYPE_JUST_SYMS)
7560 continue;
7561
7562 if (sec->output_section == bfd_abs_section_ptr)
7563 continue;
7564
7565 /* Look through the section relocs. */
7566 if ((sec->flags & SEC_RELOC) == 0 || sec->reloc_count == 0)
7567 continue;
7568
7569 local_syms = NULL;
7570 symtab_hdr = &elf_symtab_hdr (ibfd);
7571
7572 /* Read the relocations. */
7573 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
7574 info->keep_memory);
7575 if (relstart == NULL)
7576 return FALSE;
7577
7578 /* First run through the relocs to check they are sane, and to
7579 determine whether we need to edit this opd section. */
7580 need_edit = FALSE;
7581 need_pad = sec;
7582 offset = 0;
7583 relend = relstart + sec->reloc_count;
7584 for (rel = relstart; rel < relend; )
7585 {
7586 enum elf_ppc64_reloc_type r_type;
7587 unsigned long r_symndx;
7588 asection *sym_sec;
7589 struct elf_link_hash_entry *h;
7590 Elf_Internal_Sym *sym;
7591
7592 /* .opd contains a regular array of 16 or 24 byte entries. We're
7593 only interested in the reloc pointing to a function entry
7594 point. */
7595 if (rel->r_offset != offset
7596 || rel + 1 >= relend
7597 || (rel + 1)->r_offset != offset + 8)
7598 {
7599 /* If someone messes with .opd alignment then after a
7600 "ld -r" we might have padding in the middle of .opd.
7601 Also, there's nothing to prevent someone putting
7602 something silly in .opd with the assembler. No .opd
7603 optimization for them! */
7604 broken_opd:
7605 (*_bfd_error_handler)
7606 (_("%B: .opd is not a regular array of opd entries"), ibfd);
7607 need_edit = FALSE;
7608 break;
7609 }
7610
7611 if ((r_type = ELF64_R_TYPE (rel->r_info)) != R_PPC64_ADDR64
7612 || (r_type = ELF64_R_TYPE ((rel + 1)->r_info)) != R_PPC64_TOC)
7613 {
7614 (*_bfd_error_handler)
7615 (_("%B: unexpected reloc type %u in .opd section"),
7616 ibfd, r_type);
7617 need_edit = FALSE;
7618 break;
7619 }
7620
7621 r_symndx = ELF64_R_SYM (rel->r_info);
7622 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7623 r_symndx, ibfd))
7624 goto error_ret;
7625
7626 if (sym_sec == NULL || sym_sec->owner == NULL)
7627 {
7628 const char *sym_name;
7629 if (h != NULL)
7630 sym_name = h->root.root.string;
7631 else
7632 sym_name = bfd_elf_sym_name (ibfd, symtab_hdr, sym,
7633 sym_sec);
7634
7635 (*_bfd_error_handler)
7636 (_("%B: undefined sym `%s' in .opd section"),
7637 ibfd, sym_name);
7638 need_edit = FALSE;
7639 break;
7640 }
7641
7642 /* opd entries are always for functions defined in the
7643 current input bfd. If the symbol isn't defined in the
7644 input bfd, then we won't be using the function in this
7645 bfd; It must be defined in a linkonce section in another
7646 bfd, or is weak. It's also possible that we are
7647 discarding the function due to a linker script /DISCARD/,
7648 which we test for via the output_section. */
7649 if (sym_sec->owner != ibfd
7650 || sym_sec->output_section == bfd_abs_section_ptr)
7651 need_edit = TRUE;
7652
7653 rel += 2;
7654 if (rel == relend
7655 || (rel + 1 == relend && rel->r_offset == offset + 16))
7656 {
7657 if (sec->size == offset + 24)
7658 {
7659 need_pad = NULL;
7660 break;
7661 }
7662 if (rel == relend && sec->size == offset + 16)
7663 {
7664 cnt_16b++;
7665 break;
7666 }
7667 goto broken_opd;
7668 }
7669
7670 if (rel->r_offset == offset + 24)
7671 offset += 24;
7672 else if (rel->r_offset != offset + 16)
7673 goto broken_opd;
7674 else if (rel + 1 < relend
7675 && ELF64_R_TYPE (rel[0].r_info) == R_PPC64_ADDR64
7676 && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOC)
7677 {
7678 offset += 16;
7679 cnt_16b++;
7680 }
7681 else if (rel + 2 < relend
7682 && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_ADDR64
7683 && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_TOC)
7684 {
7685 offset += 24;
7686 rel += 1;
7687 }
7688 else
7689 goto broken_opd;
7690 }
7691
7692 add_aux_fields = htab->params->non_overlapping_opd && cnt_16b > 0;
7693
7694 if (need_edit || add_aux_fields)
7695 {
7696 Elf_Internal_Rela *write_rel;
7697 Elf_Internal_Shdr *rel_hdr;
7698 bfd_byte *rptr, *wptr;
7699 bfd_byte *new_contents;
7700 bfd_boolean skip;
7701 long opd_ent_size;
7702 bfd_size_type amt;
7703
7704 new_contents = NULL;
7705 amt = sec->size * sizeof (long) / 8;
7706 opd = &ppc64_elf_section_data (sec)->u.opd;
7707 opd->adjust = bfd_zalloc (sec->owner, amt);
7708 if (opd->adjust == NULL)
7709 return FALSE;
7710 ppc64_elf_section_data (sec)->sec_type = sec_opd;
7711
7712 /* This seems a waste of time as input .opd sections are all
7713 zeros as generated by gcc, but I suppose there's no reason
7714 this will always be so. We might start putting something in
7715 the third word of .opd entries. */
7716 if ((sec->flags & SEC_IN_MEMORY) == 0)
7717 {
7718 bfd_byte *loc;
7719 if (!bfd_malloc_and_get_section (ibfd, sec, &loc))
7720 {
7721 if (loc != NULL)
7722 free (loc);
7723 error_ret:
7724 if (local_syms != NULL
7725 && symtab_hdr->contents != (unsigned char *) local_syms)
7726 free (local_syms);
7727 if (elf_section_data (sec)->relocs != relstart)
7728 free (relstart);
7729 return FALSE;
7730 }
7731 sec->contents = loc;
7732 sec->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
7733 }
7734
7735 elf_section_data (sec)->relocs = relstart;
7736
7737 new_contents = sec->contents;
7738 if (add_aux_fields)
7739 {
7740 new_contents = bfd_malloc (sec->size + cnt_16b * 8);
7741 if (new_contents == NULL)
7742 return FALSE;
7743 need_pad = FALSE;
7744 }
7745 wptr = new_contents;
7746 rptr = sec->contents;
7747
7748 write_rel = relstart;
7749 skip = FALSE;
7750 offset = 0;
7751 opd_ent_size = 0;
7752 for (rel = relstart; rel < relend; rel++)
7753 {
7754 unsigned long r_symndx;
7755 asection *sym_sec;
7756 struct elf_link_hash_entry *h;
7757 Elf_Internal_Sym *sym;
7758
7759 r_symndx = ELF64_R_SYM (rel->r_info);
7760 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7761 r_symndx, ibfd))
7762 goto error_ret;
7763
7764 if (rel->r_offset == offset)
7765 {
7766 struct ppc_link_hash_entry *fdh = NULL;
7767
7768 /* See if the .opd entry is full 24 byte or
7769 16 byte (with fd_aux entry overlapped with next
7770 fd_func). */
7771 opd_ent_size = 24;
7772 if ((rel + 2 == relend && sec->size == offset + 16)
7773 || (rel + 3 < relend
7774 && rel[2].r_offset == offset + 16
7775 && rel[3].r_offset == offset + 24
7776 && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_ADDR64
7777 && ELF64_R_TYPE (rel[3].r_info) == R_PPC64_TOC))
7778 opd_ent_size = 16;
7779
7780 if (h != NULL
7781 && h->root.root.string[0] == '.')
7782 {
7783 fdh = lookup_fdh ((struct ppc_link_hash_entry *) h, htab);
7784 if (fdh != NULL
7785 && fdh->elf.root.type != bfd_link_hash_defined
7786 && fdh->elf.root.type != bfd_link_hash_defweak)
7787 fdh = NULL;
7788 }
7789
7790 skip = (sym_sec->owner != ibfd
7791 || sym_sec->output_section == bfd_abs_section_ptr);
7792 if (skip)
7793 {
7794 if (fdh != NULL && sym_sec->owner == ibfd)
7795 {
7796 /* Arrange for the function descriptor sym
7797 to be dropped. */
7798 fdh->elf.root.u.def.value = 0;
7799 fdh->elf.root.u.def.section = sym_sec;
7800 }
7801 opd->adjust[rel->r_offset / 8] = -1;
7802 }
7803 else
7804 {
7805 /* We'll be keeping this opd entry. */
7806
7807 if (fdh != NULL)
7808 {
7809 /* Redefine the function descriptor symbol to
7810 this location in the opd section. It is
7811 necessary to update the value here rather
7812 than using an array of adjustments as we do
7813 for local symbols, because various places
7814 in the generic ELF code use the value
7815 stored in u.def.value. */
7816 fdh->elf.root.u.def.value = wptr - new_contents;
7817 fdh->adjust_done = 1;
7818 }
7819
7820 /* Local syms are a bit tricky. We could
7821 tweak them as they can be cached, but
7822 we'd need to look through the local syms
7823 for the function descriptor sym which we
7824 don't have at the moment. So keep an
7825 array of adjustments. */
7826 opd->adjust[rel->r_offset / 8]
7827 = (wptr - new_contents) - (rptr - sec->contents);
7828
7829 if (wptr != rptr)
7830 memcpy (wptr, rptr, opd_ent_size);
7831 wptr += opd_ent_size;
7832 if (add_aux_fields && opd_ent_size == 16)
7833 {
7834 memset (wptr, '\0', 8);
7835 wptr += 8;
7836 }
7837 }
7838 rptr += opd_ent_size;
7839 offset += opd_ent_size;
7840 }
7841
7842 if (skip)
7843 {
7844 if (!NO_OPD_RELOCS
7845 && !info->relocatable
7846 && !dec_dynrel_count (rel->r_info, sec, info,
7847 NULL, h, sym))
7848 goto error_ret;
7849 }
7850 else
7851 {
7852 /* We need to adjust any reloc offsets to point to the
7853 new opd entries. While we're at it, we may as well
7854 remove redundant relocs. */
7855 rel->r_offset += opd->adjust[(offset - opd_ent_size) / 8];
7856 if (write_rel != rel)
7857 memcpy (write_rel, rel, sizeof (*rel));
7858 ++write_rel;
7859 }
7860 }
7861
7862 sec->size = wptr - new_contents;
7863 sec->reloc_count = write_rel - relstart;
7864 if (add_aux_fields)
7865 {
7866 free (sec->contents);
7867 sec->contents = new_contents;
7868 }
7869
7870 /* Fudge the header size too, as this is used later in
7871 elf_bfd_final_link if we are emitting relocs. */
7872 rel_hdr = _bfd_elf_single_rel_hdr (sec);
7873 rel_hdr->sh_size = sec->reloc_count * rel_hdr->sh_entsize;
7874 some_edited = TRUE;
7875 }
7876 else if (elf_section_data (sec)->relocs != relstart)
7877 free (relstart);
7878
7879 if (local_syms != NULL
7880 && symtab_hdr->contents != (unsigned char *) local_syms)
7881 {
7882 if (!info->keep_memory)
7883 free (local_syms);
7884 else
7885 symtab_hdr->contents = (unsigned char *) local_syms;
7886 }
7887 }
7888
7889 if (some_edited)
7890 elf_link_hash_traverse (elf_hash_table (info), adjust_opd_syms, NULL);
7891
7892 /* If we are doing a final link and the last .opd entry is just 16 byte
7893 long, add a 8 byte padding after it. */
7894 if (need_pad != NULL && !info->relocatable)
7895 {
7896 bfd_byte *p;
7897
7898 if ((need_pad->flags & SEC_IN_MEMORY) == 0)
7899 {
7900 BFD_ASSERT (need_pad->size > 0);
7901
7902 p = bfd_malloc (need_pad->size + 8);
7903 if (p == NULL)
7904 return FALSE;
7905
7906 if (! bfd_get_section_contents (need_pad->owner, need_pad,
7907 p, 0, need_pad->size))
7908 return FALSE;
7909
7910 need_pad->contents = p;
7911 need_pad->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
7912 }
7913 else
7914 {
7915 p = bfd_realloc (need_pad->contents, need_pad->size + 8);
7916 if (p == NULL)
7917 return FALSE;
7918
7919 need_pad->contents = p;
7920 }
7921
7922 memset (need_pad->contents + need_pad->size, 0, 8);
7923 need_pad->size += 8;
7924 }
7925
7926 return TRUE;
7927 }
7928
7929 /* Set htab->tls_get_addr and call the generic ELF tls_setup function. */
7930
7931 asection *
7932 ppc64_elf_tls_setup (struct bfd_link_info *info)
7933 {
7934 struct ppc_link_hash_table *htab;
7935
7936 htab = ppc_hash_table (info);
7937 if (htab == NULL)
7938 return NULL;
7939
7940 if (abiversion (info->output_bfd) == 1)
7941 htab->opd_abi = 1;
7942
7943 if (htab->params->no_multi_toc)
7944 htab->do_multi_toc = 0;
7945 else if (!htab->do_multi_toc)
7946 htab->params->no_multi_toc = 1;
7947
7948 htab->tls_get_addr = ((struct ppc_link_hash_entry *)
7949 elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
7950 FALSE, FALSE, TRUE));
7951 /* Move dynamic linking info to the function descriptor sym. */
7952 if (htab->tls_get_addr != NULL)
7953 func_desc_adjust (&htab->tls_get_addr->elf, info);
7954 htab->tls_get_addr_fd = ((struct ppc_link_hash_entry *)
7955 elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
7956 FALSE, FALSE, TRUE));
7957 if (!htab->params->no_tls_get_addr_opt)
7958 {
7959 struct elf_link_hash_entry *opt, *opt_fd, *tga, *tga_fd;
7960
7961 opt = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr_opt",
7962 FALSE, FALSE, TRUE);
7963 if (opt != NULL)
7964 func_desc_adjust (opt, info);
7965 opt_fd = elf_link_hash_lookup (&htab->elf, "__tls_get_addr_opt",
7966 FALSE, FALSE, TRUE);
7967 if (opt_fd != NULL
7968 && (opt_fd->root.type == bfd_link_hash_defined
7969 || opt_fd->root.type == bfd_link_hash_defweak))
7970 {
7971 /* If glibc supports an optimized __tls_get_addr call stub,
7972 signalled by the presence of __tls_get_addr_opt, and we'll
7973 be calling __tls_get_addr via a plt call stub, then
7974 make __tls_get_addr point to __tls_get_addr_opt. */
7975 tga_fd = &htab->tls_get_addr_fd->elf;
7976 if (htab->elf.dynamic_sections_created
7977 && tga_fd != NULL
7978 && (tga_fd->type == STT_FUNC
7979 || tga_fd->needs_plt)
7980 && !(SYMBOL_CALLS_LOCAL (info, tga_fd)
7981 || (ELF_ST_VISIBILITY (tga_fd->other) != STV_DEFAULT
7982 && tga_fd->root.type == bfd_link_hash_undefweak)))
7983 {
7984 struct plt_entry *ent;
7985
7986 for (ent = tga_fd->plt.plist; ent != NULL; ent = ent->next)
7987 if (ent->plt.refcount > 0)
7988 break;
7989 if (ent != NULL)
7990 {
7991 tga_fd->root.type = bfd_link_hash_indirect;
7992 tga_fd->root.u.i.link = &opt_fd->root;
7993 ppc64_elf_copy_indirect_symbol (info, opt_fd, tga_fd);
7994 if (opt_fd->dynindx != -1)
7995 {
7996 /* Use __tls_get_addr_opt in dynamic relocations. */
7997 opt_fd->dynindx = -1;
7998 _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
7999 opt_fd->dynstr_index);
8000 if (!bfd_elf_link_record_dynamic_symbol (info, opt_fd))
8001 return NULL;
8002 }
8003 htab->tls_get_addr_fd = (struct ppc_link_hash_entry *) opt_fd;
8004 tga = &htab->tls_get_addr->elf;
8005 if (opt != NULL && tga != NULL)
8006 {
8007 tga->root.type = bfd_link_hash_indirect;
8008 tga->root.u.i.link = &opt->root;
8009 ppc64_elf_copy_indirect_symbol (info, opt, tga);
8010 _bfd_elf_link_hash_hide_symbol (info, opt,
8011 tga->forced_local);
8012 htab->tls_get_addr = (struct ppc_link_hash_entry *) opt;
8013 }
8014 htab->tls_get_addr_fd->oh = htab->tls_get_addr;
8015 htab->tls_get_addr_fd->is_func_descriptor = 1;
8016 if (htab->tls_get_addr != NULL)
8017 {
8018 htab->tls_get_addr->oh = htab->tls_get_addr_fd;
8019 htab->tls_get_addr->is_func = 1;
8020 }
8021 }
8022 }
8023 }
8024 else
8025 htab->params->no_tls_get_addr_opt = TRUE;
8026 }
8027 return _bfd_elf_tls_setup (info->output_bfd, info);
8028 }
8029
8030 /* Return TRUE iff REL is a branch reloc with a global symbol matching
8031 HASH1 or HASH2. */
8032
8033 static bfd_boolean
8034 branch_reloc_hash_match (const bfd *ibfd,
8035 const Elf_Internal_Rela *rel,
8036 const struct ppc_link_hash_entry *hash1,
8037 const struct ppc_link_hash_entry *hash2)
8038 {
8039 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
8040 enum elf_ppc64_reloc_type r_type = ELF64_R_TYPE (rel->r_info);
8041 unsigned int r_symndx = ELF64_R_SYM (rel->r_info);
8042
8043 if (r_symndx >= symtab_hdr->sh_info && is_branch_reloc (r_type))
8044 {
8045 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
8046 struct elf_link_hash_entry *h;
8047
8048 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
8049 h = elf_follow_link (h);
8050 if (h == &hash1->elf || h == &hash2->elf)
8051 return TRUE;
8052 }
8053 return FALSE;
8054 }
8055
8056 /* Run through all the TLS relocs looking for optimization
8057 opportunities. The linker has been hacked (see ppc64elf.em) to do
8058 a preliminary section layout so that we know the TLS segment
8059 offsets. We can't optimize earlier because some optimizations need
8060 to know the tp offset, and we need to optimize before allocating
8061 dynamic relocations. */
8062
8063 bfd_boolean
8064 ppc64_elf_tls_optimize (struct bfd_link_info *info)
8065 {
8066 bfd *ibfd;
8067 asection *sec;
8068 struct ppc_link_hash_table *htab;
8069 unsigned char *toc_ref;
8070 int pass;
8071
8072 if (info->relocatable || !info->executable)
8073 return TRUE;
8074
8075 htab = ppc_hash_table (info);
8076 if (htab == NULL)
8077 return FALSE;
8078
8079 /* Make two passes over the relocs. On the first pass, mark toc
8080 entries involved with tls relocs, and check that tls relocs
8081 involved in setting up a tls_get_addr call are indeed followed by
8082 such a call. If they are not, we can't do any tls optimization.
8083 On the second pass twiddle tls_mask flags to notify
8084 relocate_section that optimization can be done, and adjust got
8085 and plt refcounts. */
8086 toc_ref = NULL;
8087 for (pass = 0; pass < 2; ++pass)
8088 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
8089 {
8090 Elf_Internal_Sym *locsyms = NULL;
8091 asection *toc = bfd_get_section_by_name (ibfd, ".toc");
8092
8093 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8094 if (sec->has_tls_reloc && !bfd_is_abs_section (sec->output_section))
8095 {
8096 Elf_Internal_Rela *relstart, *rel, *relend;
8097 bfd_boolean found_tls_get_addr_arg = 0;
8098
8099 /* Read the relocations. */
8100 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8101 info->keep_memory);
8102 if (relstart == NULL)
8103 {
8104 free (toc_ref);
8105 return FALSE;
8106 }
8107
8108 relend = relstart + sec->reloc_count;
8109 for (rel = relstart; rel < relend; rel++)
8110 {
8111 enum elf_ppc64_reloc_type r_type;
8112 unsigned long r_symndx;
8113 struct elf_link_hash_entry *h;
8114 Elf_Internal_Sym *sym;
8115 asection *sym_sec;
8116 unsigned char *tls_mask;
8117 unsigned char tls_set, tls_clear, tls_type = 0;
8118 bfd_vma value;
8119 bfd_boolean ok_tprel, is_local;
8120 long toc_ref_index = 0;
8121 int expecting_tls_get_addr = 0;
8122 bfd_boolean ret = FALSE;
8123
8124 r_symndx = ELF64_R_SYM (rel->r_info);
8125 if (!get_sym_h (&h, &sym, &sym_sec, &tls_mask, &locsyms,
8126 r_symndx, ibfd))
8127 {
8128 err_free_rel:
8129 if (elf_section_data (sec)->relocs != relstart)
8130 free (relstart);
8131 if (toc_ref != NULL)
8132 free (toc_ref);
8133 if (locsyms != NULL
8134 && (elf_symtab_hdr (ibfd).contents
8135 != (unsigned char *) locsyms))
8136 free (locsyms);
8137 return ret;
8138 }
8139
8140 if (h != NULL)
8141 {
8142 if (h->root.type == bfd_link_hash_defined
8143 || h->root.type == bfd_link_hash_defweak)
8144 value = h->root.u.def.value;
8145 else if (h->root.type == bfd_link_hash_undefweak)
8146 value = 0;
8147 else
8148 {
8149 found_tls_get_addr_arg = 0;
8150 continue;
8151 }
8152 }
8153 else
8154 /* Symbols referenced by TLS relocs must be of type
8155 STT_TLS. So no need for .opd local sym adjust. */
8156 value = sym->st_value;
8157
8158 ok_tprel = FALSE;
8159 is_local = FALSE;
8160 if (h == NULL
8161 || !h->def_dynamic)
8162 {
8163 is_local = TRUE;
8164 if (h != NULL
8165 && h->root.type == bfd_link_hash_undefweak)
8166 ok_tprel = TRUE;
8167 else
8168 {
8169 value += sym_sec->output_offset;
8170 value += sym_sec->output_section->vma;
8171 value -= htab->elf.tls_sec->vma;
8172 ok_tprel = (value + TP_OFFSET + ((bfd_vma) 1 << 31)
8173 < (bfd_vma) 1 << 32);
8174 }
8175 }
8176
8177 r_type = ELF64_R_TYPE (rel->r_info);
8178 /* If this section has old-style __tls_get_addr calls
8179 without marker relocs, then check that each
8180 __tls_get_addr call reloc is preceded by a reloc
8181 that conceivably belongs to the __tls_get_addr arg
8182 setup insn. If we don't find matching arg setup
8183 relocs, don't do any tls optimization. */
8184 if (pass == 0
8185 && sec->has_tls_get_addr_call
8186 && h != NULL
8187 && (h == &htab->tls_get_addr->elf
8188 || h == &htab->tls_get_addr_fd->elf)
8189 && !found_tls_get_addr_arg
8190 && is_branch_reloc (r_type))
8191 {
8192 info->callbacks->minfo (_("%H __tls_get_addr lost arg, "
8193 "TLS optimization disabled\n"),
8194 ibfd, sec, rel->r_offset);
8195 ret = TRUE;
8196 goto err_free_rel;
8197 }
8198
8199 found_tls_get_addr_arg = 0;
8200 switch (r_type)
8201 {
8202 case R_PPC64_GOT_TLSLD16:
8203 case R_PPC64_GOT_TLSLD16_LO:
8204 expecting_tls_get_addr = 1;
8205 found_tls_get_addr_arg = 1;
8206 /* Fall thru */
8207
8208 case R_PPC64_GOT_TLSLD16_HI:
8209 case R_PPC64_GOT_TLSLD16_HA:
8210 /* These relocs should never be against a symbol
8211 defined in a shared lib. Leave them alone if
8212 that turns out to be the case. */
8213 if (!is_local)
8214 continue;
8215
8216 /* LD -> LE */
8217 tls_set = 0;
8218 tls_clear = TLS_LD;
8219 tls_type = TLS_TLS | TLS_LD;
8220 break;
8221
8222 case R_PPC64_GOT_TLSGD16:
8223 case R_PPC64_GOT_TLSGD16_LO:
8224 expecting_tls_get_addr = 1;
8225 found_tls_get_addr_arg = 1;
8226 /* Fall thru */
8227
8228 case R_PPC64_GOT_TLSGD16_HI:
8229 case R_PPC64_GOT_TLSGD16_HA:
8230 if (ok_tprel)
8231 /* GD -> LE */
8232 tls_set = 0;
8233 else
8234 /* GD -> IE */
8235 tls_set = TLS_TLS | TLS_TPRELGD;
8236 tls_clear = TLS_GD;
8237 tls_type = TLS_TLS | TLS_GD;
8238 break;
8239
8240 case R_PPC64_GOT_TPREL16_DS:
8241 case R_PPC64_GOT_TPREL16_LO_DS:
8242 case R_PPC64_GOT_TPREL16_HI:
8243 case R_PPC64_GOT_TPREL16_HA:
8244 if (ok_tprel)
8245 {
8246 /* IE -> LE */
8247 tls_set = 0;
8248 tls_clear = TLS_TPREL;
8249 tls_type = TLS_TLS | TLS_TPREL;
8250 break;
8251 }
8252 continue;
8253
8254 case R_PPC64_TLSGD:
8255 case R_PPC64_TLSLD:
8256 found_tls_get_addr_arg = 1;
8257 /* Fall thru */
8258
8259 case R_PPC64_TLS:
8260 case R_PPC64_TOC16:
8261 case R_PPC64_TOC16_LO:
8262 if (sym_sec == NULL || sym_sec != toc)
8263 continue;
8264
8265 /* Mark this toc entry as referenced by a TLS
8266 code sequence. We can do that now in the
8267 case of R_PPC64_TLS, and after checking for
8268 tls_get_addr for the TOC16 relocs. */
8269 if (toc_ref == NULL)
8270 toc_ref = bfd_zmalloc (toc->output_section->rawsize / 8);
8271 if (toc_ref == NULL)
8272 goto err_free_rel;
8273
8274 if (h != NULL)
8275 value = h->root.u.def.value;
8276 else
8277 value = sym->st_value;
8278 value += rel->r_addend;
8279 BFD_ASSERT (value < toc->size && value % 8 == 0);
8280 toc_ref_index = (value + toc->output_offset) / 8;
8281 if (r_type == R_PPC64_TLS
8282 || r_type == R_PPC64_TLSGD
8283 || r_type == R_PPC64_TLSLD)
8284 {
8285 toc_ref[toc_ref_index] = 1;
8286 continue;
8287 }
8288
8289 if (pass != 0 && toc_ref[toc_ref_index] == 0)
8290 continue;
8291
8292 tls_set = 0;
8293 tls_clear = 0;
8294 expecting_tls_get_addr = 2;
8295 break;
8296
8297 case R_PPC64_TPREL64:
8298 if (pass == 0
8299 || sec != toc
8300 || toc_ref == NULL
8301 || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
8302 continue;
8303 if (ok_tprel)
8304 {
8305 /* IE -> LE */
8306 tls_set = TLS_EXPLICIT;
8307 tls_clear = TLS_TPREL;
8308 break;
8309 }
8310 continue;
8311
8312 case R_PPC64_DTPMOD64:
8313 if (pass == 0
8314 || sec != toc
8315 || toc_ref == NULL
8316 || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
8317 continue;
8318 if (rel + 1 < relend
8319 && (rel[1].r_info
8320 == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64))
8321 && rel[1].r_offset == rel->r_offset + 8)
8322 {
8323 if (ok_tprel)
8324 /* GD -> LE */
8325 tls_set = TLS_EXPLICIT | TLS_GD;
8326 else
8327 /* GD -> IE */
8328 tls_set = TLS_EXPLICIT | TLS_GD | TLS_TPRELGD;
8329 tls_clear = TLS_GD;
8330 }
8331 else
8332 {
8333 if (!is_local)
8334 continue;
8335
8336 /* LD -> LE */
8337 tls_set = TLS_EXPLICIT;
8338 tls_clear = TLS_LD;
8339 }
8340 break;
8341
8342 default:
8343 continue;
8344 }
8345
8346 if (pass == 0)
8347 {
8348 if (!expecting_tls_get_addr
8349 || !sec->has_tls_get_addr_call)
8350 continue;
8351
8352 if (rel + 1 < relend
8353 && branch_reloc_hash_match (ibfd, rel + 1,
8354 htab->tls_get_addr,
8355 htab->tls_get_addr_fd))
8356 {
8357 if (expecting_tls_get_addr == 2)
8358 {
8359 /* Check for toc tls entries. */
8360 unsigned char *toc_tls;
8361 int retval;
8362
8363 retval = get_tls_mask (&toc_tls, NULL, NULL,
8364 &locsyms,
8365 rel, ibfd);
8366 if (retval == 0)
8367 goto err_free_rel;
8368 if (toc_tls != NULL)
8369 {
8370 if ((*toc_tls & (TLS_GD | TLS_LD)) != 0)
8371 found_tls_get_addr_arg = 1;
8372 if (retval > 1)
8373 toc_ref[toc_ref_index] = 1;
8374 }
8375 }
8376 continue;
8377 }
8378
8379 if (expecting_tls_get_addr != 1)
8380 continue;
8381
8382 /* Uh oh, we didn't find the expected call. We
8383 could just mark this symbol to exclude it
8384 from tls optimization but it's safer to skip
8385 the entire optimization. */
8386 info->callbacks->minfo (_("%H arg lost __tls_get_addr, "
8387 "TLS optimization disabled\n"),
8388 ibfd, sec, rel->r_offset);
8389 ret = TRUE;
8390 goto err_free_rel;
8391 }
8392
8393 if (expecting_tls_get_addr && htab->tls_get_addr != NULL)
8394 {
8395 struct plt_entry *ent;
8396 for (ent = htab->tls_get_addr->elf.plt.plist;
8397 ent != NULL;
8398 ent = ent->next)
8399 if (ent->addend == 0)
8400 {
8401 if (ent->plt.refcount > 0)
8402 {
8403 ent->plt.refcount -= 1;
8404 expecting_tls_get_addr = 0;
8405 }
8406 break;
8407 }
8408 }
8409
8410 if (expecting_tls_get_addr && htab->tls_get_addr_fd != NULL)
8411 {
8412 struct plt_entry *ent;
8413 for (ent = htab->tls_get_addr_fd->elf.plt.plist;
8414 ent != NULL;
8415 ent = ent->next)
8416 if (ent->addend == 0)
8417 {
8418 if (ent->plt.refcount > 0)
8419 ent->plt.refcount -= 1;
8420 break;
8421 }
8422 }
8423
8424 if (tls_clear == 0)
8425 continue;
8426
8427 if ((tls_set & TLS_EXPLICIT) == 0)
8428 {
8429 struct got_entry *ent;
8430
8431 /* Adjust got entry for this reloc. */
8432 if (h != NULL)
8433 ent = h->got.glist;
8434 else
8435 ent = elf_local_got_ents (ibfd)[r_symndx];
8436
8437 for (; ent != NULL; ent = ent->next)
8438 if (ent->addend == rel->r_addend
8439 && ent->owner == ibfd
8440 && ent->tls_type == tls_type)
8441 break;
8442 if (ent == NULL)
8443 abort ();
8444
8445 if (tls_set == 0)
8446 {
8447 /* We managed to get rid of a got entry. */
8448 if (ent->got.refcount > 0)
8449 ent->got.refcount -= 1;
8450 }
8451 }
8452 else
8453 {
8454 /* If we got rid of a DTPMOD/DTPREL reloc pair then
8455 we'll lose one or two dyn relocs. */
8456 if (!dec_dynrel_count (rel->r_info, sec, info,
8457 NULL, h, sym))
8458 return FALSE;
8459
8460 if (tls_set == (TLS_EXPLICIT | TLS_GD))
8461 {
8462 if (!dec_dynrel_count ((rel + 1)->r_info, sec, info,
8463 NULL, h, sym))
8464 return FALSE;
8465 }
8466 }
8467
8468 *tls_mask |= tls_set;
8469 *tls_mask &= ~tls_clear;
8470 }
8471
8472 if (elf_section_data (sec)->relocs != relstart)
8473 free (relstart);
8474 }
8475
8476 if (locsyms != NULL
8477 && (elf_symtab_hdr (ibfd).contents != (unsigned char *) locsyms))
8478 {
8479 if (!info->keep_memory)
8480 free (locsyms);
8481 else
8482 elf_symtab_hdr (ibfd).contents = (unsigned char *) locsyms;
8483 }
8484 }
8485
8486 if (toc_ref != NULL)
8487 free (toc_ref);
8488 return TRUE;
8489 }
8490
8491 /* Called via elf_link_hash_traverse from ppc64_elf_edit_toc to adjust
8492 the values of any global symbols in a toc section that has been
8493 edited. Globals in toc sections should be a rarity, so this function
8494 sets a flag if any are found in toc sections other than the one just
8495 edited, so that futher hash table traversals can be avoided. */
8496
8497 struct adjust_toc_info
8498 {
8499 asection *toc;
8500 unsigned long *skip;
8501 bfd_boolean global_toc_syms;
8502 };
8503
8504 enum toc_skip_enum { ref_from_discarded = 1, can_optimize = 2 };
8505
8506 static bfd_boolean
8507 adjust_toc_syms (struct elf_link_hash_entry *h, void *inf)
8508 {
8509 struct ppc_link_hash_entry *eh;
8510 struct adjust_toc_info *toc_inf = (struct adjust_toc_info *) inf;
8511 unsigned long i;
8512
8513 if (h->root.type != bfd_link_hash_defined
8514 && h->root.type != bfd_link_hash_defweak)
8515 return TRUE;
8516
8517 eh = (struct ppc_link_hash_entry *) h;
8518 if (eh->adjust_done)
8519 return TRUE;
8520
8521 if (eh->elf.root.u.def.section == toc_inf->toc)
8522 {
8523 if (eh->elf.root.u.def.value > toc_inf->toc->rawsize)
8524 i = toc_inf->toc->rawsize >> 3;
8525 else
8526 i = eh->elf.root.u.def.value >> 3;
8527
8528 if ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0)
8529 {
8530 (*_bfd_error_handler)
8531 (_("%s defined on removed toc entry"), eh->elf.root.root.string);
8532 do
8533 ++i;
8534 while ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0);
8535 eh->elf.root.u.def.value = (bfd_vma) i << 3;
8536 }
8537
8538 eh->elf.root.u.def.value -= toc_inf->skip[i];
8539 eh->adjust_done = 1;
8540 }
8541 else if (strcmp (eh->elf.root.u.def.section->name, ".toc") == 0)
8542 toc_inf->global_toc_syms = TRUE;
8543
8544 return TRUE;
8545 }
8546
8547 /* Return TRUE iff INSN is one we expect on a _LO variety toc/got reloc. */
8548
8549 static bfd_boolean
8550 ok_lo_toc_insn (unsigned int insn)
8551 {
8552 return ((insn & (0x3f << 26)) == 14u << 26 /* addi */
8553 || (insn & (0x3f << 26)) == 32u << 26 /* lwz */
8554 || (insn & (0x3f << 26)) == 34u << 26 /* lbz */
8555 || (insn & (0x3f << 26)) == 36u << 26 /* stw */
8556 || (insn & (0x3f << 26)) == 38u << 26 /* stb */
8557 || (insn & (0x3f << 26)) == 40u << 26 /* lhz */
8558 || (insn & (0x3f << 26)) == 42u << 26 /* lha */
8559 || (insn & (0x3f << 26)) == 44u << 26 /* sth */
8560 || (insn & (0x3f << 26)) == 46u << 26 /* lmw */
8561 || (insn & (0x3f << 26)) == 47u << 26 /* stmw */
8562 || (insn & (0x3f << 26)) == 48u << 26 /* lfs */
8563 || (insn & (0x3f << 26)) == 50u << 26 /* lfd */
8564 || (insn & (0x3f << 26)) == 52u << 26 /* stfs */
8565 || (insn & (0x3f << 26)) == 54u << 26 /* stfd */
8566 || ((insn & (0x3f << 26)) == 58u << 26 /* lwa,ld,lmd */
8567 && (insn & 3) != 1)
8568 || ((insn & (0x3f << 26)) == 62u << 26 /* std, stmd */
8569 && ((insn & 3) == 0 || (insn & 3) == 3))
8570 || (insn & (0x3f << 26)) == 12u << 26 /* addic */);
8571 }
8572
8573 /* Examine all relocs referencing .toc sections in order to remove
8574 unused .toc entries. */
8575
8576 bfd_boolean
8577 ppc64_elf_edit_toc (struct bfd_link_info *info)
8578 {
8579 bfd *ibfd;
8580 struct adjust_toc_info toc_inf;
8581 struct ppc_link_hash_table *htab = ppc_hash_table (info);
8582
8583 htab->do_toc_opt = 1;
8584 toc_inf.global_toc_syms = TRUE;
8585 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
8586 {
8587 asection *toc, *sec;
8588 Elf_Internal_Shdr *symtab_hdr;
8589 Elf_Internal_Sym *local_syms;
8590 Elf_Internal_Rela *relstart, *rel, *toc_relocs;
8591 unsigned long *skip, *drop;
8592 unsigned char *used;
8593 unsigned char *keep, last, some_unused;
8594
8595 if (!is_ppc64_elf (ibfd))
8596 continue;
8597
8598 toc = bfd_get_section_by_name (ibfd, ".toc");
8599 if (toc == NULL
8600 || toc->size == 0
8601 || toc->sec_info_type == SEC_INFO_TYPE_JUST_SYMS
8602 || discarded_section (toc))
8603 continue;
8604
8605 toc_relocs = NULL;
8606 local_syms = NULL;
8607 symtab_hdr = &elf_symtab_hdr (ibfd);
8608
8609 /* Look at sections dropped from the final link. */
8610 skip = NULL;
8611 relstart = NULL;
8612 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8613 {
8614 if (sec->reloc_count == 0
8615 || !discarded_section (sec)
8616 || get_opd_info (sec)
8617 || (sec->flags & SEC_ALLOC) == 0
8618 || (sec->flags & SEC_DEBUGGING) != 0)
8619 continue;
8620
8621 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL, FALSE);
8622 if (relstart == NULL)
8623 goto error_ret;
8624
8625 /* Run through the relocs to see which toc entries might be
8626 unused. */
8627 for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
8628 {
8629 enum elf_ppc64_reloc_type r_type;
8630 unsigned long r_symndx;
8631 asection *sym_sec;
8632 struct elf_link_hash_entry *h;
8633 Elf_Internal_Sym *sym;
8634 bfd_vma val;
8635
8636 r_type = ELF64_R_TYPE (rel->r_info);
8637 switch (r_type)
8638 {
8639 default:
8640 continue;
8641
8642 case R_PPC64_TOC16:
8643 case R_PPC64_TOC16_LO:
8644 case R_PPC64_TOC16_HI:
8645 case R_PPC64_TOC16_HA:
8646 case R_PPC64_TOC16_DS:
8647 case R_PPC64_TOC16_LO_DS:
8648 break;
8649 }
8650
8651 r_symndx = ELF64_R_SYM (rel->r_info);
8652 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8653 r_symndx, ibfd))
8654 goto error_ret;
8655
8656 if (sym_sec != toc)
8657 continue;
8658
8659 if (h != NULL)
8660 val = h->root.u.def.value;
8661 else
8662 val = sym->st_value;
8663 val += rel->r_addend;
8664
8665 if (val >= toc->size)
8666 continue;
8667
8668 /* Anything in the toc ought to be aligned to 8 bytes.
8669 If not, don't mark as unused. */
8670 if (val & 7)
8671 continue;
8672
8673 if (skip == NULL)
8674 {
8675 skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
8676 if (skip == NULL)
8677 goto error_ret;
8678 }
8679
8680 skip[val >> 3] = ref_from_discarded;
8681 }
8682
8683 if (elf_section_data (sec)->relocs != relstart)
8684 free (relstart);
8685 }
8686
8687 /* For largetoc loads of address constants, we can convert
8688 . addis rx,2,addr@got@ha
8689 . ld ry,addr@got@l(rx)
8690 to
8691 . addis rx,2,addr@toc@ha
8692 . addi ry,rx,addr@toc@l
8693 when addr is within 2G of the toc pointer. This then means
8694 that the word storing "addr" in the toc is no longer needed. */
8695
8696 if (!ppc64_elf_tdata (ibfd)->has_small_toc_reloc
8697 && toc->output_section->rawsize < (bfd_vma) 1 << 31
8698 && toc->reloc_count != 0)
8699 {
8700 /* Read toc relocs. */
8701 toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
8702 info->keep_memory);
8703 if (toc_relocs == NULL)
8704 goto error_ret;
8705
8706 for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
8707 {
8708 enum elf_ppc64_reloc_type r_type;
8709 unsigned long r_symndx;
8710 asection *sym_sec;
8711 struct elf_link_hash_entry *h;
8712 Elf_Internal_Sym *sym;
8713 bfd_vma val, addr;
8714
8715 r_type = ELF64_R_TYPE (rel->r_info);
8716 if (r_type != R_PPC64_ADDR64)
8717 continue;
8718
8719 r_symndx = ELF64_R_SYM (rel->r_info);
8720 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8721 r_symndx, ibfd))
8722 goto error_ret;
8723
8724 if (sym_sec == NULL
8725 || discarded_section (sym_sec))
8726 continue;
8727
8728 if (!SYMBOL_REFERENCES_LOCAL (info, h))
8729 continue;
8730
8731 if (h != NULL)
8732 {
8733 if (h->type == STT_GNU_IFUNC)
8734 continue;
8735 val = h->root.u.def.value;
8736 }
8737 else
8738 {
8739 if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
8740 continue;
8741 val = sym->st_value;
8742 }
8743 val += rel->r_addend;
8744 val += sym_sec->output_section->vma + sym_sec->output_offset;
8745
8746 /* We don't yet know the exact toc pointer value, but we
8747 know it will be somewhere in the toc section. Don't
8748 optimize if the difference from any possible toc
8749 pointer is outside [ff..f80008000, 7fff7fff]. */
8750 addr = toc->output_section->vma + TOC_BASE_OFF;
8751 if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
8752 continue;
8753
8754 addr = toc->output_section->vma + toc->output_section->rawsize;
8755 if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
8756 continue;
8757
8758 if (skip == NULL)
8759 {
8760 skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
8761 if (skip == NULL)
8762 goto error_ret;
8763 }
8764
8765 skip[rel->r_offset >> 3]
8766 |= can_optimize | ((rel - toc_relocs) << 2);
8767 }
8768 }
8769
8770 if (skip == NULL)
8771 continue;
8772
8773 used = bfd_zmalloc (sizeof (*used) * (toc->size + 7) / 8);
8774 if (used == NULL)
8775 {
8776 error_ret:
8777 if (local_syms != NULL
8778 && symtab_hdr->contents != (unsigned char *) local_syms)
8779 free (local_syms);
8780 if (sec != NULL
8781 && relstart != NULL
8782 && elf_section_data (sec)->relocs != relstart)
8783 free (relstart);
8784 if (toc_relocs != NULL
8785 && elf_section_data (toc)->relocs != toc_relocs)
8786 free (toc_relocs);
8787 if (skip != NULL)
8788 free (skip);
8789 return FALSE;
8790 }
8791
8792 /* Now check all kept sections that might reference the toc.
8793 Check the toc itself last. */
8794 for (sec = (ibfd->sections == toc && toc->next ? toc->next
8795 : ibfd->sections);
8796 sec != NULL;
8797 sec = (sec == toc ? NULL
8798 : sec->next == NULL ? toc
8799 : sec->next == toc && toc->next ? toc->next
8800 : sec->next))
8801 {
8802 int repeat;
8803
8804 if (sec->reloc_count == 0
8805 || discarded_section (sec)
8806 || get_opd_info (sec)
8807 || (sec->flags & SEC_ALLOC) == 0
8808 || (sec->flags & SEC_DEBUGGING) != 0)
8809 continue;
8810
8811 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8812 info->keep_memory);
8813 if (relstart == NULL)
8814 {
8815 free (used);
8816 goto error_ret;
8817 }
8818
8819 /* Mark toc entries referenced as used. */
8820 do
8821 {
8822 repeat = 0;
8823 for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
8824 {
8825 enum elf_ppc64_reloc_type r_type;
8826 unsigned long r_symndx;
8827 asection *sym_sec;
8828 struct elf_link_hash_entry *h;
8829 Elf_Internal_Sym *sym;
8830 bfd_vma val;
8831 enum {no_check, check_lo, check_ha} insn_check;
8832
8833 r_type = ELF64_R_TYPE (rel->r_info);
8834 switch (r_type)
8835 {
8836 default:
8837 insn_check = no_check;
8838 break;
8839
8840 case R_PPC64_GOT_TLSLD16_HA:
8841 case R_PPC64_GOT_TLSGD16_HA:
8842 case R_PPC64_GOT_TPREL16_HA:
8843 case R_PPC64_GOT_DTPREL16_HA:
8844 case R_PPC64_GOT16_HA:
8845 case R_PPC64_TOC16_HA:
8846 insn_check = check_ha;
8847 break;
8848
8849 case R_PPC64_GOT_TLSLD16_LO:
8850 case R_PPC64_GOT_TLSGD16_LO:
8851 case R_PPC64_GOT_TPREL16_LO_DS:
8852 case R_PPC64_GOT_DTPREL16_LO_DS:
8853 case R_PPC64_GOT16_LO:
8854 case R_PPC64_GOT16_LO_DS:
8855 case R_PPC64_TOC16_LO:
8856 case R_PPC64_TOC16_LO_DS:
8857 insn_check = check_lo;
8858 break;
8859 }
8860
8861 if (insn_check != no_check)
8862 {
8863 bfd_vma off = rel->r_offset & ~3;
8864 unsigned char buf[4];
8865 unsigned int insn;
8866
8867 if (!bfd_get_section_contents (ibfd, sec, buf, off, 4))
8868 {
8869 free (used);
8870 goto error_ret;
8871 }
8872 insn = bfd_get_32 (ibfd, buf);
8873 if (insn_check == check_lo
8874 ? !ok_lo_toc_insn (insn)
8875 : ((insn & ((0x3f << 26) | 0x1f << 16))
8876 != ((15u << 26) | (2 << 16)) /* addis rt,2,imm */))
8877 {
8878 char str[12];
8879
8880 ppc64_elf_tdata (ibfd)->unexpected_toc_insn = 1;
8881 sprintf (str, "%#08x", insn);
8882 info->callbacks->einfo
8883 (_("%P: %H: toc optimization is not supported for"
8884 " %s instruction.\n"),
8885 ibfd, sec, rel->r_offset & ~3, str);
8886 }
8887 }
8888
8889 switch (r_type)
8890 {
8891 case R_PPC64_TOC16:
8892 case R_PPC64_TOC16_LO:
8893 case R_PPC64_TOC16_HI:
8894 case R_PPC64_TOC16_HA:
8895 case R_PPC64_TOC16_DS:
8896 case R_PPC64_TOC16_LO_DS:
8897 /* In case we're taking addresses of toc entries. */
8898 case R_PPC64_ADDR64:
8899 break;
8900
8901 default:
8902 continue;
8903 }
8904
8905 r_symndx = ELF64_R_SYM (rel->r_info);
8906 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8907 r_symndx, ibfd))
8908 {
8909 free (used);
8910 goto error_ret;
8911 }
8912
8913 if (sym_sec != toc)
8914 continue;
8915
8916 if (h != NULL)
8917 val = h->root.u.def.value;
8918 else
8919 val = sym->st_value;
8920 val += rel->r_addend;
8921
8922 if (val >= toc->size)
8923 continue;
8924
8925 if ((skip[val >> 3] & can_optimize) != 0)
8926 {
8927 bfd_vma off;
8928 unsigned char opc;
8929
8930 switch (r_type)
8931 {
8932 case R_PPC64_TOC16_HA:
8933 break;
8934
8935 case R_PPC64_TOC16_LO_DS:
8936 off = rel->r_offset;
8937 off += (bfd_big_endian (ibfd) ? -2 : 3);
8938 if (!bfd_get_section_contents (ibfd, sec, &opc,
8939 off, 1))
8940 {
8941 free (used);
8942 goto error_ret;
8943 }
8944 if ((opc & (0x3f << 2)) == (58u << 2))
8945 break;
8946 /* Fall thru */
8947
8948 default:
8949 /* Wrong sort of reloc, or not a ld. We may
8950 as well clear ref_from_discarded too. */
8951 skip[val >> 3] = 0;
8952 }
8953 }
8954
8955 if (sec != toc)
8956 used[val >> 3] = 1;
8957 /* For the toc section, we only mark as used if this
8958 entry itself isn't unused. */
8959 else if ((used[rel->r_offset >> 3]
8960 || !(skip[rel->r_offset >> 3] & ref_from_discarded))
8961 && !used[val >> 3])
8962 {
8963 /* Do all the relocs again, to catch reference
8964 chains. */
8965 repeat = 1;
8966 used[val >> 3] = 1;
8967 }
8968 }
8969 }
8970 while (repeat);
8971
8972 if (elf_section_data (sec)->relocs != relstart)
8973 free (relstart);
8974 }
8975
8976 /* Merge the used and skip arrays. Assume that TOC
8977 doublewords not appearing as either used or unused belong
8978 to to an entry more than one doubleword in size. */
8979 for (drop = skip, keep = used, last = 0, some_unused = 0;
8980 drop < skip + (toc->size + 7) / 8;
8981 ++drop, ++keep)
8982 {
8983 if (*keep)
8984 {
8985 *drop &= ~ref_from_discarded;
8986 if ((*drop & can_optimize) != 0)
8987 some_unused = 1;
8988 last = 0;
8989 }
8990 else if ((*drop & ref_from_discarded) != 0)
8991 {
8992 some_unused = 1;
8993 last = ref_from_discarded;
8994 }
8995 else
8996 *drop = last;
8997 }
8998
8999 free (used);
9000
9001 if (some_unused)
9002 {
9003 bfd_byte *contents, *src;
9004 unsigned long off;
9005 Elf_Internal_Sym *sym;
9006 bfd_boolean local_toc_syms = FALSE;
9007
9008 /* Shuffle the toc contents, and at the same time convert the
9009 skip array from booleans into offsets. */
9010 if (!bfd_malloc_and_get_section (ibfd, toc, &contents))
9011 goto error_ret;
9012
9013 elf_section_data (toc)->this_hdr.contents = contents;
9014
9015 for (src = contents, off = 0, drop = skip;
9016 src < contents + toc->size;
9017 src += 8, ++drop)
9018 {
9019 if ((*drop & (can_optimize | ref_from_discarded)) != 0)
9020 off += 8;
9021 else if (off != 0)
9022 {
9023 *drop = off;
9024 memcpy (src - off, src, 8);
9025 }
9026 }
9027 *drop = off;
9028 toc->rawsize = toc->size;
9029 toc->size = src - contents - off;
9030
9031 /* Adjust addends for relocs against the toc section sym,
9032 and optimize any accesses we can. */
9033 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
9034 {
9035 if (sec->reloc_count == 0
9036 || discarded_section (sec))
9037 continue;
9038
9039 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
9040 info->keep_memory);
9041 if (relstart == NULL)
9042 goto error_ret;
9043
9044 for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9045 {
9046 enum elf_ppc64_reloc_type r_type;
9047 unsigned long r_symndx;
9048 asection *sym_sec;
9049 struct elf_link_hash_entry *h;
9050 bfd_vma val;
9051
9052 r_type = ELF64_R_TYPE (rel->r_info);
9053 switch (r_type)
9054 {
9055 default:
9056 continue;
9057
9058 case R_PPC64_TOC16:
9059 case R_PPC64_TOC16_LO:
9060 case R_PPC64_TOC16_HI:
9061 case R_PPC64_TOC16_HA:
9062 case R_PPC64_TOC16_DS:
9063 case R_PPC64_TOC16_LO_DS:
9064 case R_PPC64_ADDR64:
9065 break;
9066 }
9067
9068 r_symndx = ELF64_R_SYM (rel->r_info);
9069 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9070 r_symndx, ibfd))
9071 goto error_ret;
9072
9073 if (sym_sec != toc)
9074 continue;
9075
9076 if (h != NULL)
9077 val = h->root.u.def.value;
9078 else
9079 {
9080 val = sym->st_value;
9081 if (val != 0)
9082 local_toc_syms = TRUE;
9083 }
9084
9085 val += rel->r_addend;
9086
9087 if (val > toc->rawsize)
9088 val = toc->rawsize;
9089 else if ((skip[val >> 3] & ref_from_discarded) != 0)
9090 continue;
9091 else if ((skip[val >> 3] & can_optimize) != 0)
9092 {
9093 Elf_Internal_Rela *tocrel
9094 = toc_relocs + (skip[val >> 3] >> 2);
9095 unsigned long tsym = ELF64_R_SYM (tocrel->r_info);
9096
9097 switch (r_type)
9098 {
9099 case R_PPC64_TOC16_HA:
9100 rel->r_info = ELF64_R_INFO (tsym, R_PPC64_TOC16_HA);
9101 break;
9102
9103 case R_PPC64_TOC16_LO_DS:
9104 rel->r_info = ELF64_R_INFO (tsym, R_PPC64_LO_DS_OPT);
9105 break;
9106
9107 default:
9108 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
9109 ppc_howto_init ();
9110 info->callbacks->einfo
9111 (_("%P: %H: %s references "
9112 "optimized away TOC entry\n"),
9113 ibfd, sec, rel->r_offset,
9114 ppc64_elf_howto_table[r_type]->name);
9115 bfd_set_error (bfd_error_bad_value);
9116 goto error_ret;
9117 }
9118 rel->r_addend = tocrel->r_addend;
9119 elf_section_data (sec)->relocs = relstart;
9120 continue;
9121 }
9122
9123 if (h != NULL || sym->st_value != 0)
9124 continue;
9125
9126 rel->r_addend -= skip[val >> 3];
9127 elf_section_data (sec)->relocs = relstart;
9128 }
9129
9130 if (elf_section_data (sec)->relocs != relstart)
9131 free (relstart);
9132 }
9133
9134 /* We shouldn't have local or global symbols defined in the TOC,
9135 but handle them anyway. */
9136 if (local_syms != NULL)
9137 for (sym = local_syms;
9138 sym < local_syms + symtab_hdr->sh_info;
9139 ++sym)
9140 if (sym->st_value != 0
9141 && bfd_section_from_elf_index (ibfd, sym->st_shndx) == toc)
9142 {
9143 unsigned long i;
9144
9145 if (sym->st_value > toc->rawsize)
9146 i = toc->rawsize >> 3;
9147 else
9148 i = sym->st_value >> 3;
9149
9150 if ((skip[i] & (ref_from_discarded | can_optimize)) != 0)
9151 {
9152 if (local_toc_syms)
9153 (*_bfd_error_handler)
9154 (_("%s defined on removed toc entry"),
9155 bfd_elf_sym_name (ibfd, symtab_hdr, sym, NULL));
9156 do
9157 ++i;
9158 while ((skip[i] & (ref_from_discarded | can_optimize)));
9159 sym->st_value = (bfd_vma) i << 3;
9160 }
9161
9162 sym->st_value -= skip[i];
9163 symtab_hdr->contents = (unsigned char *) local_syms;
9164 }
9165
9166 /* Adjust any global syms defined in this toc input section. */
9167 if (toc_inf.global_toc_syms)
9168 {
9169 toc_inf.toc = toc;
9170 toc_inf.skip = skip;
9171 toc_inf.global_toc_syms = FALSE;
9172 elf_link_hash_traverse (elf_hash_table (info), adjust_toc_syms,
9173 &toc_inf);
9174 }
9175
9176 if (toc->reloc_count != 0)
9177 {
9178 Elf_Internal_Shdr *rel_hdr;
9179 Elf_Internal_Rela *wrel;
9180 bfd_size_type sz;
9181
9182 /* Remove unused toc relocs, and adjust those we keep. */
9183 if (toc_relocs == NULL)
9184 toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
9185 info->keep_memory);
9186 if (toc_relocs == NULL)
9187 goto error_ret;
9188
9189 wrel = toc_relocs;
9190 for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
9191 if ((skip[rel->r_offset >> 3]
9192 & (ref_from_discarded | can_optimize)) == 0)
9193 {
9194 wrel->r_offset = rel->r_offset - skip[rel->r_offset >> 3];
9195 wrel->r_info = rel->r_info;
9196 wrel->r_addend = rel->r_addend;
9197 ++wrel;
9198 }
9199 else if (!dec_dynrel_count (rel->r_info, toc, info,
9200 &local_syms, NULL, NULL))
9201 goto error_ret;
9202
9203 elf_section_data (toc)->relocs = toc_relocs;
9204 toc->reloc_count = wrel - toc_relocs;
9205 rel_hdr = _bfd_elf_single_rel_hdr (toc);
9206 sz = rel_hdr->sh_entsize;
9207 rel_hdr->sh_size = toc->reloc_count * sz;
9208 }
9209 }
9210 else if (toc_relocs != NULL
9211 && elf_section_data (toc)->relocs != toc_relocs)
9212 free (toc_relocs);
9213
9214 if (local_syms != NULL
9215 && symtab_hdr->contents != (unsigned char *) local_syms)
9216 {
9217 if (!info->keep_memory)
9218 free (local_syms);
9219 else
9220 symtab_hdr->contents = (unsigned char *) local_syms;
9221 }
9222 free (skip);
9223 }
9224
9225 return TRUE;
9226 }
9227
9228 /* Return true iff input section I references the TOC using
9229 instructions limited to +/-32k offsets. */
9230
9231 bfd_boolean
9232 ppc64_elf_has_small_toc_reloc (asection *i)
9233 {
9234 return (is_ppc64_elf (i->owner)
9235 && ppc64_elf_tdata (i->owner)->has_small_toc_reloc);
9236 }
9237
9238 /* Allocate space for one GOT entry. */
9239
9240 static void
9241 allocate_got (struct elf_link_hash_entry *h,
9242 struct bfd_link_info *info,
9243 struct got_entry *gent)
9244 {
9245 struct ppc_link_hash_table *htab = ppc_hash_table (info);
9246 bfd_boolean dyn;
9247 struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
9248 int entsize = (gent->tls_type & eh->tls_mask & (TLS_GD | TLS_LD)
9249 ? 16 : 8);
9250 int rentsize = (gent->tls_type & eh->tls_mask & TLS_GD
9251 ? 2 : 1) * sizeof (Elf64_External_Rela);
9252 asection *got = ppc64_elf_tdata (gent->owner)->got;
9253
9254 gent->got.offset = got->size;
9255 got->size += entsize;
9256
9257 dyn = htab->elf.dynamic_sections_created;
9258 if (h->type == STT_GNU_IFUNC)
9259 {
9260 htab->elf.irelplt->size += rentsize;
9261 htab->got_reli_size += rentsize;
9262 }
9263 else if ((info->shared
9264 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h))
9265 && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
9266 || h->root.type != bfd_link_hash_undefweak))
9267 {
9268 asection *relgot = ppc64_elf_tdata (gent->owner)->relgot;
9269 relgot->size += rentsize;
9270 }
9271 }
9272
9273 /* This function merges got entries in the same toc group. */
9274
9275 static void
9276 merge_got_entries (struct got_entry **pent)
9277 {
9278 struct got_entry *ent, *ent2;
9279
9280 for (ent = *pent; ent != NULL; ent = ent->next)
9281 if (!ent->is_indirect)
9282 for (ent2 = ent->next; ent2 != NULL; ent2 = ent2->next)
9283 if (!ent2->is_indirect
9284 && ent2->addend == ent->addend
9285 && ent2->tls_type == ent->tls_type
9286 && elf_gp (ent2->owner) == elf_gp (ent->owner))
9287 {
9288 ent2->is_indirect = TRUE;
9289 ent2->got.ent = ent;
9290 }
9291 }
9292
9293 /* Allocate space in .plt, .got and associated reloc sections for
9294 dynamic relocs. */
9295
9296 static bfd_boolean
9297 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
9298 {
9299 struct bfd_link_info *info;
9300 struct ppc_link_hash_table *htab;
9301 asection *s;
9302 struct ppc_link_hash_entry *eh;
9303 struct elf_dyn_relocs *p;
9304 struct got_entry **pgent, *gent;
9305
9306 if (h->root.type == bfd_link_hash_indirect)
9307 return TRUE;
9308
9309 info = (struct bfd_link_info *) inf;
9310 htab = ppc_hash_table (info);
9311 if (htab == NULL)
9312 return FALSE;
9313
9314 if ((htab->elf.dynamic_sections_created
9315 && h->dynindx != -1
9316 && WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info->shared, h))
9317 || h->type == STT_GNU_IFUNC)
9318 {
9319 struct plt_entry *pent;
9320 bfd_boolean doneone = FALSE;
9321 for (pent = h->plt.plist; pent != NULL; pent = pent->next)
9322 if (pent->plt.refcount > 0)
9323 {
9324 if (!htab->elf.dynamic_sections_created
9325 || h->dynindx == -1)
9326 {
9327 s = htab->elf.iplt;
9328 pent->plt.offset = s->size;
9329 s->size += PLT_ENTRY_SIZE (htab);
9330 s = htab->elf.irelplt;
9331 }
9332 else
9333 {
9334 /* If this is the first .plt entry, make room for the special
9335 first entry. */
9336 s = htab->elf.splt;
9337 if (s->size == 0)
9338 s->size += PLT_INITIAL_ENTRY_SIZE (htab);
9339
9340 pent->plt.offset = s->size;
9341
9342 /* Make room for this entry. */
9343 s->size += PLT_ENTRY_SIZE (htab);
9344
9345 /* Make room for the .glink code. */
9346 s = htab->glink;
9347 if (s->size == 0)
9348 s->size += GLINK_CALL_STUB_SIZE;
9349 if (htab->opd_abi)
9350 {
9351 /* We need bigger stubs past index 32767. */
9352 if (s->size >= GLINK_CALL_STUB_SIZE + 32768*2*4)
9353 s->size += 4;
9354 s->size += 2*4;
9355 }
9356 else
9357 s->size += 4;
9358
9359 /* We also need to make an entry in the .rela.plt section. */
9360 s = htab->elf.srelplt;
9361 }
9362 s->size += sizeof (Elf64_External_Rela);
9363 doneone = TRUE;
9364 }
9365 else
9366 pent->plt.offset = (bfd_vma) -1;
9367 if (!doneone)
9368 {
9369 h->plt.plist = NULL;
9370 h->needs_plt = 0;
9371 }
9372 }
9373 else
9374 {
9375 h->plt.plist = NULL;
9376 h->needs_plt = 0;
9377 }
9378
9379 eh = (struct ppc_link_hash_entry *) h;
9380 /* Run through the TLS GD got entries first if we're changing them
9381 to TPREL. */
9382 if ((eh->tls_mask & TLS_TPRELGD) != 0)
9383 for (gent = h->got.glist; gent != NULL; gent = gent->next)
9384 if (gent->got.refcount > 0
9385 && (gent->tls_type & TLS_GD) != 0)
9386 {
9387 /* This was a GD entry that has been converted to TPREL. If
9388 there happens to be a TPREL entry we can use that one. */
9389 struct got_entry *ent;
9390 for (ent = h->got.glist; ent != NULL; ent = ent->next)
9391 if (ent->got.refcount > 0
9392 && (ent->tls_type & TLS_TPREL) != 0
9393 && ent->addend == gent->addend
9394 && ent->owner == gent->owner)
9395 {
9396 gent->got.refcount = 0;
9397 break;
9398 }
9399
9400 /* If not, then we'll be using our own TPREL entry. */
9401 if (gent->got.refcount != 0)
9402 gent->tls_type = TLS_TLS | TLS_TPREL;
9403 }
9404
9405 /* Remove any list entry that won't generate a word in the GOT before
9406 we call merge_got_entries. Otherwise we risk merging to empty
9407 entries. */
9408 pgent = &h->got.glist;
9409 while ((gent = *pgent) != NULL)
9410 if (gent->got.refcount > 0)
9411 {
9412 if ((gent->tls_type & TLS_LD) != 0
9413 && !h->def_dynamic)
9414 {
9415 ppc64_tlsld_got (gent->owner)->got.refcount += 1;
9416 *pgent = gent->next;
9417 }
9418 else
9419 pgent = &gent->next;
9420 }
9421 else
9422 *pgent = gent->next;
9423
9424 if (!htab->do_multi_toc)
9425 merge_got_entries (&h->got.glist);
9426
9427 for (gent = h->got.glist; gent != NULL; gent = gent->next)
9428 if (!gent->is_indirect)
9429 {
9430 /* Make sure this symbol is output as a dynamic symbol.
9431 Undefined weak syms won't yet be marked as dynamic,
9432 nor will all TLS symbols. */
9433 if (h->dynindx == -1
9434 && !h->forced_local
9435 && h->type != STT_GNU_IFUNC
9436 && htab->elf.dynamic_sections_created)
9437 {
9438 if (! bfd_elf_link_record_dynamic_symbol (info, h))
9439 return FALSE;
9440 }
9441
9442 if (!is_ppc64_elf (gent->owner))
9443 abort ();
9444
9445 allocate_got (h, info, gent);
9446 }
9447
9448 if (eh->dyn_relocs == NULL
9449 || (!htab->elf.dynamic_sections_created
9450 && h->type != STT_GNU_IFUNC))
9451 return TRUE;
9452
9453 /* In the shared -Bsymbolic case, discard space allocated for
9454 dynamic pc-relative relocs against symbols which turn out to be
9455 defined in regular objects. For the normal shared case, discard
9456 space for relocs that have become local due to symbol visibility
9457 changes. */
9458
9459 if (info->shared)
9460 {
9461 /* Relocs that use pc_count are those that appear on a call insn,
9462 or certain REL relocs (see must_be_dyn_reloc) that can be
9463 generated via assembly. We want calls to protected symbols to
9464 resolve directly to the function rather than going via the plt.
9465 If people want function pointer comparisons to work as expected
9466 then they should avoid writing weird assembly. */
9467 if (SYMBOL_CALLS_LOCAL (info, h))
9468 {
9469 struct elf_dyn_relocs **pp;
9470
9471 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
9472 {
9473 p->count -= p->pc_count;
9474 p->pc_count = 0;
9475 if (p->count == 0)
9476 *pp = p->next;
9477 else
9478 pp = &p->next;
9479 }
9480 }
9481
9482 /* Also discard relocs on undefined weak syms with non-default
9483 visibility. */
9484 if (eh->dyn_relocs != NULL
9485 && h->root.type == bfd_link_hash_undefweak)
9486 {
9487 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
9488 eh->dyn_relocs = NULL;
9489
9490 /* Make sure this symbol is output as a dynamic symbol.
9491 Undefined weak syms won't yet be marked as dynamic. */
9492 else 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 }
9500 else if (h->type == STT_GNU_IFUNC)
9501 {
9502 if (!h->non_got_ref)
9503 eh->dyn_relocs = NULL;
9504 }
9505 else if (ELIMINATE_COPY_RELOCS)
9506 {
9507 /* For the non-shared case, discard space for relocs against
9508 symbols which turn out to need copy relocs or are not
9509 dynamic. */
9510
9511 if (!h->non_got_ref
9512 && !h->def_regular)
9513 {
9514 /* Make sure this symbol is output as a dynamic symbol.
9515 Undefined weak syms won't yet be marked as dynamic. */
9516 if (h->dynindx == -1
9517 && !h->forced_local)
9518 {
9519 if (! bfd_elf_link_record_dynamic_symbol (info, h))
9520 return FALSE;
9521 }
9522
9523 /* If that succeeded, we know we'll be keeping all the
9524 relocs. */
9525 if (h->dynindx != -1)
9526 goto keep;
9527 }
9528
9529 eh->dyn_relocs = NULL;
9530
9531 keep: ;
9532 }
9533
9534 /* Finally, allocate space. */
9535 for (p = eh->dyn_relocs; p != NULL; p = p->next)
9536 {
9537 asection *sreloc = elf_section_data (p->sec)->sreloc;
9538 if (eh->elf.type == STT_GNU_IFUNC)
9539 sreloc = htab->elf.irelplt;
9540 sreloc->size += p->count * sizeof (Elf64_External_Rela);
9541 }
9542
9543 return TRUE;
9544 }
9545
9546 /* Called via elf_link_hash_traverse from ppc64_elf_size_dynamic_sections
9547 to set up space for global entry stubs. These are put in glink,
9548 after the branch table. */
9549
9550 static bfd_boolean
9551 size_global_entry_stubs (struct elf_link_hash_entry *h, void *inf)
9552 {
9553 struct bfd_link_info *info;
9554 struct ppc_link_hash_table *htab;
9555 struct plt_entry *pent;
9556 asection *s;
9557
9558 if (h->root.type == bfd_link_hash_indirect)
9559 return TRUE;
9560
9561 if (!h->pointer_equality_needed)
9562 return TRUE;
9563
9564 if (h->def_regular)
9565 return TRUE;
9566
9567 info = inf;
9568 htab = ppc_hash_table (info);
9569 if (htab == NULL)
9570 return FALSE;
9571
9572 s = htab->glink;
9573 for (pent = h->plt.plist; pent != NULL; pent = pent->next)
9574 if (pent->plt.offset != (bfd_vma) -1
9575 && pent->addend == 0)
9576 {
9577 /* For ELFv2, if this symbol is not defined in a regular file
9578 and we are not generating a shared library or pie, then we
9579 need to define the symbol in the executable on a call stub.
9580 This is to avoid text relocations. */
9581 s->size = (s->size + 15) & -16;
9582 h->root.u.def.section = s;
9583 h->root.u.def.value = s->size;
9584 s->size += 16;
9585 break;
9586 }
9587 return TRUE;
9588 }
9589
9590 /* Set DF_TEXTREL if we find any dynamic relocs that apply to
9591 read-only sections. */
9592
9593 static bfd_boolean
9594 maybe_set_textrel (struct elf_link_hash_entry *h, void *info)
9595 {
9596 if (h->root.type == bfd_link_hash_indirect)
9597 return TRUE;
9598
9599 if (readonly_dynrelocs (h))
9600 {
9601 ((struct bfd_link_info *) info)->flags |= DF_TEXTREL;
9602
9603 /* Not an error, just cut short the traversal. */
9604 return FALSE;
9605 }
9606 return TRUE;
9607 }
9608
9609 /* Set the sizes of the dynamic sections. */
9610
9611 static bfd_boolean
9612 ppc64_elf_size_dynamic_sections (bfd *output_bfd,
9613 struct bfd_link_info *info)
9614 {
9615 struct ppc_link_hash_table *htab;
9616 bfd *dynobj;
9617 asection *s;
9618 bfd_boolean relocs;
9619 bfd *ibfd;
9620 struct got_entry *first_tlsld;
9621
9622 htab = ppc_hash_table (info);
9623 if (htab == NULL)
9624 return FALSE;
9625
9626 dynobj = htab->elf.dynobj;
9627 if (dynobj == NULL)
9628 abort ();
9629
9630 if (htab->elf.dynamic_sections_created)
9631 {
9632 /* Set the contents of the .interp section to the interpreter. */
9633 if (info->executable)
9634 {
9635 s = bfd_get_linker_section (dynobj, ".interp");
9636 if (s == NULL)
9637 abort ();
9638 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
9639 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
9640 }
9641 }
9642
9643 /* Set up .got offsets for local syms, and space for local dynamic
9644 relocs. */
9645 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
9646 {
9647 struct got_entry **lgot_ents;
9648 struct got_entry **end_lgot_ents;
9649 struct plt_entry **local_plt;
9650 struct plt_entry **end_local_plt;
9651 unsigned char *lgot_masks;
9652 bfd_size_type locsymcount;
9653 Elf_Internal_Shdr *symtab_hdr;
9654
9655 if (!is_ppc64_elf (ibfd))
9656 continue;
9657
9658 for (s = ibfd->sections; s != NULL; s = s->next)
9659 {
9660 struct ppc_dyn_relocs *p;
9661
9662 for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
9663 {
9664 if (!bfd_is_abs_section (p->sec)
9665 && bfd_is_abs_section (p->sec->output_section))
9666 {
9667 /* Input section has been discarded, either because
9668 it is a copy of a linkonce section or due to
9669 linker script /DISCARD/, so we'll be discarding
9670 the relocs too. */
9671 }
9672 else if (p->count != 0)
9673 {
9674 asection *srel = elf_section_data (p->sec)->sreloc;
9675 if (p->ifunc)
9676 srel = htab->elf.irelplt;
9677 srel->size += p->count * sizeof (Elf64_External_Rela);
9678 if ((p->sec->output_section->flags & SEC_READONLY) != 0)
9679 info->flags |= DF_TEXTREL;
9680 }
9681 }
9682 }
9683
9684 lgot_ents = elf_local_got_ents (ibfd);
9685 if (!lgot_ents)
9686 continue;
9687
9688 symtab_hdr = &elf_symtab_hdr (ibfd);
9689 locsymcount = symtab_hdr->sh_info;
9690 end_lgot_ents = lgot_ents + locsymcount;
9691 local_plt = (struct plt_entry **) end_lgot_ents;
9692 end_local_plt = local_plt + locsymcount;
9693 lgot_masks = (unsigned char *) end_local_plt;
9694 s = ppc64_elf_tdata (ibfd)->got;
9695 for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
9696 {
9697 struct got_entry **pent, *ent;
9698
9699 pent = lgot_ents;
9700 while ((ent = *pent) != NULL)
9701 if (ent->got.refcount > 0)
9702 {
9703 if ((ent->tls_type & *lgot_masks & TLS_LD) != 0)
9704 {
9705 ppc64_tlsld_got (ibfd)->got.refcount += 1;
9706 *pent = ent->next;
9707 }
9708 else
9709 {
9710 unsigned int ent_size = 8;
9711 unsigned int rel_size = sizeof (Elf64_External_Rela);
9712
9713 ent->got.offset = s->size;
9714 if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
9715 {
9716 ent_size *= 2;
9717 rel_size *= 2;
9718 }
9719 s->size += ent_size;
9720 if ((*lgot_masks & PLT_IFUNC) != 0)
9721 {
9722 htab->elf.irelplt->size += rel_size;
9723 htab->got_reli_size += rel_size;
9724 }
9725 else if (info->shared)
9726 {
9727 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
9728 srel->size += rel_size;
9729 }
9730 pent = &ent->next;
9731 }
9732 }
9733 else
9734 *pent = ent->next;
9735 }
9736
9737 /* Allocate space for calls to local STT_GNU_IFUNC syms in .iplt. */
9738 for (; local_plt < end_local_plt; ++local_plt)
9739 {
9740 struct plt_entry *ent;
9741
9742 for (ent = *local_plt; ent != NULL; ent = ent->next)
9743 if (ent->plt.refcount > 0)
9744 {
9745 s = htab->elf.iplt;
9746 ent->plt.offset = s->size;
9747 s->size += PLT_ENTRY_SIZE (htab);
9748
9749 htab->elf.irelplt->size += sizeof (Elf64_External_Rela);
9750 }
9751 else
9752 ent->plt.offset = (bfd_vma) -1;
9753 }
9754 }
9755
9756 /* Allocate global sym .plt and .got entries, and space for global
9757 sym dynamic relocs. */
9758 elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, info);
9759 /* Stash the end of glink branch table. */
9760 if (htab->glink != NULL)
9761 htab->glink->rawsize = htab->glink->size;
9762
9763 if (!htab->opd_abi && !info->shared)
9764 elf_link_hash_traverse (&htab->elf, size_global_entry_stubs, info);
9765
9766 first_tlsld = NULL;
9767 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
9768 {
9769 struct got_entry *ent;
9770
9771 if (!is_ppc64_elf (ibfd))
9772 continue;
9773
9774 ent = ppc64_tlsld_got (ibfd);
9775 if (ent->got.refcount > 0)
9776 {
9777 if (!htab->do_multi_toc && first_tlsld != NULL)
9778 {
9779 ent->is_indirect = TRUE;
9780 ent->got.ent = first_tlsld;
9781 }
9782 else
9783 {
9784 if (first_tlsld == NULL)
9785 first_tlsld = ent;
9786 s = ppc64_elf_tdata (ibfd)->got;
9787 ent->got.offset = s->size;
9788 ent->owner = ibfd;
9789 s->size += 16;
9790 if (info->shared)
9791 {
9792 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
9793 srel->size += sizeof (Elf64_External_Rela);
9794 }
9795 }
9796 }
9797 else
9798 ent->got.offset = (bfd_vma) -1;
9799 }
9800
9801 /* We now have determined the sizes of the various dynamic sections.
9802 Allocate memory for them. */
9803 relocs = FALSE;
9804 for (s = dynobj->sections; s != NULL; s = s->next)
9805 {
9806 if ((s->flags & SEC_LINKER_CREATED) == 0)
9807 continue;
9808
9809 if (s == htab->brlt || s == htab->relbrlt)
9810 /* These haven't been allocated yet; don't strip. */
9811 continue;
9812 else if (s == htab->elf.sgot
9813 || s == htab->elf.splt
9814 || s == htab->elf.iplt
9815 || s == htab->glink
9816 || s == htab->dynbss)
9817 {
9818 /* Strip this section if we don't need it; see the
9819 comment below. */
9820 }
9821 else if (s == htab->glink_eh_frame)
9822 {
9823 if (!bfd_is_abs_section (s->output_section))
9824 /* Not sized yet. */
9825 continue;
9826 }
9827 else if (CONST_STRNEQ (s->name, ".rela"))
9828 {
9829 if (s->size != 0)
9830 {
9831 if (s != htab->elf.srelplt)
9832 relocs = TRUE;
9833
9834 /* We use the reloc_count field as a counter if we need
9835 to copy relocs into the output file. */
9836 s->reloc_count = 0;
9837 }
9838 }
9839 else
9840 {
9841 /* It's not one of our sections, so don't allocate space. */
9842 continue;
9843 }
9844
9845 if (s->size == 0)
9846 {
9847 /* If we don't need this section, strip it from the
9848 output file. This is mostly to handle .rela.bss and
9849 .rela.plt. We must create both sections in
9850 create_dynamic_sections, because they must be created
9851 before the linker maps input sections to output
9852 sections. The linker does that before
9853 adjust_dynamic_symbol is called, and it is that
9854 function which decides whether anything needs to go
9855 into these sections. */
9856 s->flags |= SEC_EXCLUDE;
9857 continue;
9858 }
9859
9860 if ((s->flags & SEC_HAS_CONTENTS) == 0)
9861 continue;
9862
9863 /* Allocate memory for the section contents. We use bfd_zalloc
9864 here in case unused entries are not reclaimed before the
9865 section's contents are written out. This should not happen,
9866 but this way if it does we get a R_PPC64_NONE reloc in .rela
9867 sections instead of garbage.
9868 We also rely on the section contents being zero when writing
9869 the GOT. */
9870 s->contents = bfd_zalloc (dynobj, s->size);
9871 if (s->contents == NULL)
9872 return FALSE;
9873 }
9874
9875 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
9876 {
9877 if (!is_ppc64_elf (ibfd))
9878 continue;
9879
9880 s = ppc64_elf_tdata (ibfd)->got;
9881 if (s != NULL && s != htab->elf.sgot)
9882 {
9883 if (s->size == 0)
9884 s->flags |= SEC_EXCLUDE;
9885 else
9886 {
9887 s->contents = bfd_zalloc (ibfd, s->size);
9888 if (s->contents == NULL)
9889 return FALSE;
9890 }
9891 }
9892 s = ppc64_elf_tdata (ibfd)->relgot;
9893 if (s != NULL)
9894 {
9895 if (s->size == 0)
9896 s->flags |= SEC_EXCLUDE;
9897 else
9898 {
9899 s->contents = bfd_zalloc (ibfd, s->size);
9900 if (s->contents == NULL)
9901 return FALSE;
9902 relocs = TRUE;
9903 s->reloc_count = 0;
9904 }
9905 }
9906 }
9907
9908 if (htab->elf.dynamic_sections_created)
9909 {
9910 bfd_boolean tls_opt;
9911
9912 /* Add some entries to the .dynamic section. We fill in the
9913 values later, in ppc64_elf_finish_dynamic_sections, but we
9914 must add the entries now so that we get the correct size for
9915 the .dynamic section. The DT_DEBUG entry is filled in by the
9916 dynamic linker and used by the debugger. */
9917 #define add_dynamic_entry(TAG, VAL) \
9918 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
9919
9920 if (info->executable)
9921 {
9922 if (!add_dynamic_entry (DT_DEBUG, 0))
9923 return FALSE;
9924 }
9925
9926 if (htab->elf.splt != NULL && htab->elf.splt->size != 0)
9927 {
9928 if (!add_dynamic_entry (DT_PLTGOT, 0)
9929 || !add_dynamic_entry (DT_PLTRELSZ, 0)
9930 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
9931 || !add_dynamic_entry (DT_JMPREL, 0)
9932 || !add_dynamic_entry (DT_PPC64_GLINK, 0))
9933 return FALSE;
9934 }
9935
9936 if (NO_OPD_RELOCS && abiversion (output_bfd) <= 1)
9937 {
9938 if (!add_dynamic_entry (DT_PPC64_OPD, 0)
9939 || !add_dynamic_entry (DT_PPC64_OPDSZ, 0))
9940 return FALSE;
9941 }
9942
9943 tls_opt = (!htab->params->no_tls_get_addr_opt
9944 && htab->tls_get_addr_fd != NULL
9945 && htab->tls_get_addr_fd->elf.plt.plist != NULL);
9946 if (tls_opt || !htab->opd_abi)
9947 {
9948 if (!add_dynamic_entry (DT_PPC64_OPT, tls_opt ? PPC64_OPT_TLS : 0))
9949 return FALSE;
9950 }
9951
9952 if (relocs)
9953 {
9954 if (!add_dynamic_entry (DT_RELA, 0)
9955 || !add_dynamic_entry (DT_RELASZ, 0)
9956 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
9957 return FALSE;
9958
9959 /* If any dynamic relocs apply to a read-only section,
9960 then we need a DT_TEXTREL entry. */
9961 if ((info->flags & DF_TEXTREL) == 0)
9962 elf_link_hash_traverse (&htab->elf, maybe_set_textrel, info);
9963
9964 if ((info->flags & DF_TEXTREL) != 0)
9965 {
9966 if (!add_dynamic_entry (DT_TEXTREL, 0))
9967 return FALSE;
9968 }
9969 }
9970 }
9971 #undef add_dynamic_entry
9972
9973 return TRUE;
9974 }
9975
9976 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
9977
9978 static bfd_boolean
9979 ppc64_elf_hash_symbol (struct elf_link_hash_entry *h)
9980 {
9981 if (h->plt.plist != NULL
9982 && !h->def_regular
9983 && !h->pointer_equality_needed)
9984 return FALSE;
9985
9986 return _bfd_elf_hash_symbol (h);
9987 }
9988
9989 /* Determine the type of stub needed, if any, for a call. */
9990
9991 static inline enum ppc_stub_type
9992 ppc_type_of_stub (asection *input_sec,
9993 const Elf_Internal_Rela *rel,
9994 struct ppc_link_hash_entry **hash,
9995 struct plt_entry **plt_ent,
9996 bfd_vma destination,
9997 unsigned long local_off)
9998 {
9999 struct ppc_link_hash_entry *h = *hash;
10000 bfd_vma location;
10001 bfd_vma branch_offset;
10002 bfd_vma max_branch_offset;
10003 enum elf_ppc64_reloc_type r_type;
10004
10005 if (h != NULL)
10006 {
10007 struct plt_entry *ent;
10008 struct ppc_link_hash_entry *fdh = h;
10009 if (h->oh != NULL
10010 && h->oh->is_func_descriptor)
10011 {
10012 fdh = ppc_follow_link (h->oh);
10013 *hash = fdh;
10014 }
10015
10016 for (ent = fdh->elf.plt.plist; ent != NULL; ent = ent->next)
10017 if (ent->addend == rel->r_addend
10018 && ent->plt.offset != (bfd_vma) -1)
10019 {
10020 *plt_ent = ent;
10021 return ppc_stub_plt_call;
10022 }
10023
10024 /* Here, we know we don't have a plt entry. If we don't have a
10025 either a defined function descriptor or a defined entry symbol
10026 in a regular object file, then it is pointless trying to make
10027 any other type of stub. */
10028 if (!is_static_defined (&fdh->elf)
10029 && !is_static_defined (&h->elf))
10030 return ppc_stub_none;
10031 }
10032 else if (elf_local_got_ents (input_sec->owner) != NULL)
10033 {
10034 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (input_sec->owner);
10035 struct plt_entry **local_plt = (struct plt_entry **)
10036 elf_local_got_ents (input_sec->owner) + symtab_hdr->sh_info;
10037 unsigned long r_symndx = ELF64_R_SYM (rel->r_info);
10038
10039 if (local_plt[r_symndx] != NULL)
10040 {
10041 struct plt_entry *ent;
10042
10043 for (ent = local_plt[r_symndx]; ent != NULL; ent = ent->next)
10044 if (ent->addend == rel->r_addend
10045 && ent->plt.offset != (bfd_vma) -1)
10046 {
10047 *plt_ent = ent;
10048 return ppc_stub_plt_call;
10049 }
10050 }
10051 }
10052
10053 /* Determine where the call point is. */
10054 location = (input_sec->output_offset
10055 + input_sec->output_section->vma
10056 + rel->r_offset);
10057
10058 branch_offset = destination - location;
10059 r_type = ELF64_R_TYPE (rel->r_info);
10060
10061 /* Determine if a long branch stub is needed. */
10062 max_branch_offset = 1 << 25;
10063 if (r_type != R_PPC64_REL24)
10064 max_branch_offset = 1 << 15;
10065
10066 if (branch_offset + max_branch_offset >= 2 * max_branch_offset - local_off)
10067 /* We need a stub. Figure out whether a long_branch or plt_branch
10068 is needed later. */
10069 return ppc_stub_long_branch;
10070
10071 return ppc_stub_none;
10072 }
10073
10074 /* With power7 weakly ordered memory model, it is possible for ld.so
10075 to update a plt entry in one thread and have another thread see a
10076 stale zero toc entry. To avoid this we need some sort of acquire
10077 barrier in the call stub. One solution is to make the load of the
10078 toc word seem to appear to depend on the load of the function entry
10079 word. Another solution is to test for r2 being zero, and branch to
10080 the appropriate glink entry if so.
10081
10082 . fake dep barrier compare
10083 . ld 12,xxx(2) ld 12,xxx(2)
10084 . mtctr 12 mtctr 12
10085 . xor 11,12,12 ld 2,xxx+8(2)
10086 . add 2,2,11 cmpldi 2,0
10087 . ld 2,xxx+8(2) bnectr+
10088 . bctr b <glink_entry>
10089
10090 The solution involving the compare turns out to be faster, so
10091 that's what we use unless the branch won't reach. */
10092
10093 #define ALWAYS_USE_FAKE_DEP 0
10094 #define ALWAYS_EMIT_R2SAVE 0
10095
10096 #define PPC_LO(v) ((v) & 0xffff)
10097 #define PPC_HI(v) (((v) >> 16) & 0xffff)
10098 #define PPC_HA(v) PPC_HI ((v) + 0x8000)
10099
10100 static inline unsigned int
10101 plt_stub_size (struct ppc_link_hash_table *htab,
10102 struct ppc_stub_hash_entry *stub_entry,
10103 bfd_vma off)
10104 {
10105 unsigned size = 12;
10106
10107 if (ALWAYS_EMIT_R2SAVE
10108 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10109 size += 4;
10110 if (PPC_HA (off) != 0)
10111 size += 4;
10112 if (htab->opd_abi)
10113 {
10114 size += 4;
10115 if (htab->params->plt_static_chain)
10116 size += 4;
10117 if (htab->params->plt_thread_safe)
10118 size += 8;
10119 if (PPC_HA (off + 8 + 8 * htab->params->plt_static_chain) != PPC_HA (off))
10120 size += 4;
10121 }
10122 if (stub_entry->h != NULL
10123 && (stub_entry->h == htab->tls_get_addr_fd
10124 || stub_entry->h == htab->tls_get_addr)
10125 && !htab->params->no_tls_get_addr_opt)
10126 size += 13 * 4;
10127 return size;
10128 }
10129
10130 /* If this stub would cross fewer 2**plt_stub_align boundaries if we align,
10131 then return the padding needed to do so. */
10132 static inline unsigned int
10133 plt_stub_pad (struct ppc_link_hash_table *htab,
10134 struct ppc_stub_hash_entry *stub_entry,
10135 bfd_vma plt_off)
10136 {
10137 int stub_align = 1 << htab->params->plt_stub_align;
10138 unsigned stub_size = plt_stub_size (htab, stub_entry, plt_off);
10139 bfd_vma stub_off = stub_entry->stub_sec->size;
10140
10141 if (((stub_off + stub_size - 1) & -stub_align) - (stub_off & -stub_align)
10142 > (stub_size & -stub_align))
10143 return stub_align - (stub_off & (stub_align - 1));
10144 return 0;
10145 }
10146
10147 /* Build a .plt call stub. */
10148
10149 static inline bfd_byte *
10150 build_plt_stub (struct ppc_link_hash_table *htab,
10151 struct ppc_stub_hash_entry *stub_entry,
10152 bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
10153 {
10154 bfd *obfd = htab->params->stub_bfd;
10155 bfd_boolean plt_load_toc = htab->opd_abi;
10156 bfd_boolean plt_static_chain = htab->params->plt_static_chain;
10157 bfd_boolean plt_thread_safe = htab->params->plt_thread_safe;
10158 bfd_boolean use_fake_dep = plt_thread_safe;
10159 bfd_vma cmp_branch_off = 0;
10160
10161 if (!ALWAYS_USE_FAKE_DEP
10162 && plt_load_toc
10163 && plt_thread_safe
10164 && !(stub_entry->h != NULL
10165 && (stub_entry->h == htab->tls_get_addr_fd
10166 || stub_entry->h == htab->tls_get_addr)
10167 && !htab->params->no_tls_get_addr_opt))
10168 {
10169 bfd_vma pltoff = stub_entry->plt_ent->plt.offset & ~1;
10170 bfd_vma pltindex = ((pltoff - PLT_INITIAL_ENTRY_SIZE (htab))
10171 / PLT_ENTRY_SIZE (htab));
10172 bfd_vma glinkoff = GLINK_CALL_STUB_SIZE + pltindex * 8;
10173 bfd_vma to, from;
10174
10175 if (pltindex > 32768)
10176 glinkoff += (pltindex - 32768) * 4;
10177 to = (glinkoff
10178 + htab->glink->output_offset
10179 + htab->glink->output_section->vma);
10180 from = (p - stub_entry->stub_sec->contents
10181 + 4 * (ALWAYS_EMIT_R2SAVE
10182 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10183 + 4 * (PPC_HA (offset) != 0)
10184 + 4 * (PPC_HA (offset + 8 + 8 * plt_static_chain)
10185 != PPC_HA (offset))
10186 + 4 * (plt_static_chain != 0)
10187 + 20
10188 + stub_entry->stub_sec->output_offset
10189 + stub_entry->stub_sec->output_section->vma);
10190 cmp_branch_off = to - from;
10191 use_fake_dep = cmp_branch_off + (1 << 25) >= (1 << 26);
10192 }
10193
10194 if (PPC_HA (offset) != 0)
10195 {
10196 if (r != NULL)
10197 {
10198 if (ALWAYS_EMIT_R2SAVE
10199 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10200 r[0].r_offset += 4;
10201 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
10202 r[1].r_offset = r[0].r_offset + 4;
10203 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10204 r[1].r_addend = r[0].r_addend;
10205 if (plt_load_toc)
10206 {
10207 if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10208 {
10209 r[2].r_offset = r[1].r_offset + 4;
10210 r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO);
10211 r[2].r_addend = r[0].r_addend;
10212 }
10213 else
10214 {
10215 r[2].r_offset = r[1].r_offset + 8 + 8 * use_fake_dep;
10216 r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10217 r[2].r_addend = r[0].r_addend + 8;
10218 if (plt_static_chain)
10219 {
10220 r[3].r_offset = r[2].r_offset + 4;
10221 r[3].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10222 r[3].r_addend = r[0].r_addend + 16;
10223 }
10224 }
10225 }
10226 }
10227 if (ALWAYS_EMIT_R2SAVE
10228 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10229 bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p), p += 4;
10230 bfd_put_32 (obfd, ADDIS_R11_R2 | PPC_HA (offset), p), p += 4;
10231 bfd_put_32 (obfd, LD_R12_0R11 | PPC_LO (offset), p), p += 4;
10232 if (plt_load_toc
10233 && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10234 {
10235 bfd_put_32 (obfd, ADDI_R11_R11 | PPC_LO (offset), p), p += 4;
10236 offset = 0;
10237 }
10238 bfd_put_32 (obfd, MTCTR_R12, p), p += 4;
10239 if (plt_load_toc)
10240 {
10241 if (use_fake_dep)
10242 {
10243 bfd_put_32 (obfd, XOR_R2_R12_R12, p), p += 4;
10244 bfd_put_32 (obfd, ADD_R11_R11_R2, p), p += 4;
10245 }
10246 bfd_put_32 (obfd, LD_R2_0R11 | PPC_LO (offset + 8), p), p += 4;
10247 if (plt_static_chain)
10248 bfd_put_32 (obfd, LD_R11_0R11 | PPC_LO (offset + 16), p), p += 4;
10249 }
10250 }
10251 else
10252 {
10253 if (r != NULL)
10254 {
10255 if (ALWAYS_EMIT_R2SAVE
10256 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10257 r[0].r_offset += 4;
10258 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10259 if (plt_load_toc)
10260 {
10261 if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10262 {
10263 r[1].r_offset = r[0].r_offset + 4;
10264 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16);
10265 r[1].r_addend = r[0].r_addend;
10266 }
10267 else
10268 {
10269 r[1].r_offset = r[0].r_offset + 8 + 8 * use_fake_dep;
10270 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10271 r[1].r_addend = r[0].r_addend + 8 + 8 * plt_static_chain;
10272 if (plt_static_chain)
10273 {
10274 r[2].r_offset = r[1].r_offset + 4;
10275 r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10276 r[2].r_addend = r[0].r_addend + 8;
10277 }
10278 }
10279 }
10280 }
10281 if (ALWAYS_EMIT_R2SAVE
10282 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10283 bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p), p += 4;
10284 bfd_put_32 (obfd, LD_R12_0R2 | PPC_LO (offset), p), p += 4;
10285 if (plt_load_toc
10286 && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
10287 {
10288 bfd_put_32 (obfd, ADDI_R2_R2 | PPC_LO (offset), p), p += 4;
10289 offset = 0;
10290 }
10291 bfd_put_32 (obfd, MTCTR_R12, p), p += 4;
10292 if (plt_load_toc)
10293 {
10294 if (use_fake_dep)
10295 {
10296 bfd_put_32 (obfd, XOR_R11_R12_R12, p), p += 4;
10297 bfd_put_32 (obfd, ADD_R2_R2_R11, p), p += 4;
10298 }
10299 if (plt_static_chain)
10300 bfd_put_32 (obfd, LD_R11_0R2 | PPC_LO (offset + 16), p), p += 4;
10301 bfd_put_32 (obfd, LD_R2_0R2 | PPC_LO (offset + 8), p), p += 4;
10302 }
10303 }
10304 if (plt_load_toc && plt_thread_safe && !use_fake_dep)
10305 {
10306 bfd_put_32 (obfd, CMPLDI_R2_0, p), p += 4;
10307 bfd_put_32 (obfd, BNECTR_P4, p), p += 4;
10308 bfd_put_32 (obfd, B_DOT | (cmp_branch_off & 0x3fffffc), p), p += 4;
10309 }
10310 else
10311 bfd_put_32 (obfd, BCTR, p), p += 4;
10312 return p;
10313 }
10314
10315 /* Build a special .plt call stub for __tls_get_addr. */
10316
10317 #define LD_R11_0R3 0xe9630000
10318 #define LD_R12_0R3 0xe9830000
10319 #define MR_R0_R3 0x7c601b78
10320 #define CMPDI_R11_0 0x2c2b0000
10321 #define ADD_R3_R12_R13 0x7c6c6a14
10322 #define BEQLR 0x4d820020
10323 #define MR_R3_R0 0x7c030378
10324 #define STD_R11_0R1 0xf9610000
10325 #define BCTRL 0x4e800421
10326 #define LD_R11_0R1 0xe9610000
10327 #define MTLR_R11 0x7d6803a6
10328
10329 static inline bfd_byte *
10330 build_tls_get_addr_stub (struct ppc_link_hash_table *htab,
10331 struct ppc_stub_hash_entry *stub_entry,
10332 bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
10333 {
10334 bfd *obfd = htab->params->stub_bfd;
10335
10336 bfd_put_32 (obfd, LD_R11_0R3 + 0, p), p += 4;
10337 bfd_put_32 (obfd, LD_R12_0R3 + 8, p), p += 4;
10338 bfd_put_32 (obfd, MR_R0_R3, p), p += 4;
10339 bfd_put_32 (obfd, CMPDI_R11_0, p), p += 4;
10340 bfd_put_32 (obfd, ADD_R3_R12_R13, p), p += 4;
10341 bfd_put_32 (obfd, BEQLR, p), p += 4;
10342 bfd_put_32 (obfd, MR_R3_R0, p), p += 4;
10343 bfd_put_32 (obfd, MFLR_R11, p), p += 4;
10344 bfd_put_32 (obfd, STD_R11_0R1 + STK_LINKER (htab), p), p += 4;
10345
10346 if (r != NULL)
10347 r[0].r_offset += 9 * 4;
10348 p = build_plt_stub (htab, stub_entry, p, offset, r);
10349 bfd_put_32 (obfd, BCTRL, p - 4);
10350
10351 bfd_put_32 (obfd, LD_R11_0R1 + STK_LINKER (htab), p), p += 4;
10352 bfd_put_32 (obfd, LD_R2_0R1 + STK_TOC (htab), p), p += 4;
10353 bfd_put_32 (obfd, MTLR_R11, p), p += 4;
10354 bfd_put_32 (obfd, BLR, p), p += 4;
10355
10356 return p;
10357 }
10358
10359 static Elf_Internal_Rela *
10360 get_relocs (asection *sec, int count)
10361 {
10362 Elf_Internal_Rela *relocs;
10363 struct bfd_elf_section_data *elfsec_data;
10364
10365 elfsec_data = elf_section_data (sec);
10366 relocs = elfsec_data->relocs;
10367 if (relocs == NULL)
10368 {
10369 bfd_size_type relsize;
10370 relsize = sec->reloc_count * sizeof (*relocs);
10371 relocs = bfd_alloc (sec->owner, relsize);
10372 if (relocs == NULL)
10373 return NULL;
10374 elfsec_data->relocs = relocs;
10375 elfsec_data->rela.hdr = bfd_zalloc (sec->owner,
10376 sizeof (Elf_Internal_Shdr));
10377 if (elfsec_data->rela.hdr == NULL)
10378 return NULL;
10379 elfsec_data->rela.hdr->sh_size = (sec->reloc_count
10380 * sizeof (Elf64_External_Rela));
10381 elfsec_data->rela.hdr->sh_entsize = sizeof (Elf64_External_Rela);
10382 sec->reloc_count = 0;
10383 }
10384 relocs += sec->reloc_count;
10385 sec->reloc_count += count;
10386 return relocs;
10387 }
10388
10389 static bfd_vma
10390 get_r2off (struct bfd_link_info *info,
10391 struct ppc_stub_hash_entry *stub_entry)
10392 {
10393 struct ppc_link_hash_table *htab = ppc_hash_table (info);
10394 bfd_vma r2off = htab->stub_group[stub_entry->target_section->id].toc_off;
10395
10396 if (r2off == 0)
10397 {
10398 /* Support linking -R objects. Get the toc pointer from the
10399 opd entry. */
10400 char buf[8];
10401 if (!htab->opd_abi)
10402 return r2off;
10403 asection *opd = stub_entry->h->elf.root.u.def.section;
10404 bfd_vma opd_off = stub_entry->h->elf.root.u.def.value;
10405
10406 if (strcmp (opd->name, ".opd") != 0
10407 || opd->reloc_count != 0)
10408 {
10409 info->callbacks->einfo (_("%P: cannot find opd entry toc for `%T'\n"),
10410 stub_entry->h->elf.root.root.string);
10411 bfd_set_error (bfd_error_bad_value);
10412 return 0;
10413 }
10414 if (!bfd_get_section_contents (opd->owner, opd, buf, opd_off + 8, 8))
10415 return 0;
10416 r2off = bfd_get_64 (opd->owner, buf);
10417 r2off -= elf_gp (info->output_bfd);
10418 }
10419 r2off -= htab->stub_group[stub_entry->id_sec->id].toc_off;
10420 return r2off;
10421 }
10422
10423 static bfd_boolean
10424 ppc_build_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
10425 {
10426 struct ppc_stub_hash_entry *stub_entry;
10427 struct ppc_branch_hash_entry *br_entry;
10428 struct bfd_link_info *info;
10429 struct ppc_link_hash_table *htab;
10430 bfd_byte *loc;
10431 bfd_byte *p;
10432 bfd_vma dest, off;
10433 int size;
10434 Elf_Internal_Rela *r;
10435 asection *plt;
10436
10437 /* Massage our args to the form they really have. */
10438 stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
10439 info = in_arg;
10440
10441 htab = ppc_hash_table (info);
10442 if (htab == NULL)
10443 return FALSE;
10444
10445 /* Make a note of the offset within the stubs for this entry. */
10446 stub_entry->stub_offset = stub_entry->stub_sec->size;
10447 loc = stub_entry->stub_sec->contents + stub_entry->stub_offset;
10448
10449 htab->stub_count[stub_entry->stub_type - 1] += 1;
10450 switch (stub_entry->stub_type)
10451 {
10452 case ppc_stub_long_branch:
10453 case ppc_stub_long_branch_r2off:
10454 /* Branches are relative. This is where we are going to. */
10455 dest = (stub_entry->target_value
10456 + stub_entry->target_section->output_offset
10457 + stub_entry->target_section->output_section->vma);
10458 dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
10459 off = dest;
10460
10461 /* And this is where we are coming from. */
10462 off -= (stub_entry->stub_offset
10463 + stub_entry->stub_sec->output_offset
10464 + stub_entry->stub_sec->output_section->vma);
10465
10466 size = 4;
10467 if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
10468 {
10469 bfd_vma r2off = get_r2off (info, stub_entry);
10470
10471 if (r2off == 0)
10472 {
10473 htab->stub_error = TRUE;
10474 return FALSE;
10475 }
10476 bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), loc);
10477 loc += 4;
10478 size = 12;
10479 if (PPC_HA (r2off) != 0)
10480 {
10481 size = 16;
10482 bfd_put_32 (htab->params->stub_bfd,
10483 ADDIS_R2_R2 | PPC_HA (r2off), loc);
10484 loc += 4;
10485 }
10486 bfd_put_32 (htab->params->stub_bfd, ADDI_R2_R2 | PPC_LO (r2off), loc);
10487 loc += 4;
10488 off -= size - 4;
10489 }
10490 bfd_put_32 (htab->params->stub_bfd, B_DOT | (off & 0x3fffffc), loc);
10491
10492 if (off + (1 << 25) >= (bfd_vma) (1 << 26))
10493 {
10494 info->callbacks->einfo
10495 (_("%P: long branch stub `%s' offset overflow\n"),
10496 stub_entry->root.string);
10497 htab->stub_error = TRUE;
10498 return FALSE;
10499 }
10500
10501 if (info->emitrelocations)
10502 {
10503 r = get_relocs (stub_entry->stub_sec, 1);
10504 if (r == NULL)
10505 return FALSE;
10506 r->r_offset = loc - stub_entry->stub_sec->contents;
10507 r->r_info = ELF64_R_INFO (0, R_PPC64_REL24);
10508 r->r_addend = dest;
10509 if (stub_entry->h != NULL)
10510 {
10511 struct elf_link_hash_entry **hashes;
10512 unsigned long symndx;
10513 struct ppc_link_hash_entry *h;
10514
10515 hashes = elf_sym_hashes (htab->params->stub_bfd);
10516 if (hashes == NULL)
10517 {
10518 bfd_size_type hsize;
10519
10520 hsize = (htab->stub_globals + 1) * sizeof (*hashes);
10521 hashes = bfd_zalloc (htab->params->stub_bfd, hsize);
10522 if (hashes == NULL)
10523 return FALSE;
10524 elf_sym_hashes (htab->params->stub_bfd) = hashes;
10525 htab->stub_globals = 1;
10526 }
10527 symndx = htab->stub_globals++;
10528 h = stub_entry->h;
10529 hashes[symndx] = &h->elf;
10530 r->r_info = ELF64_R_INFO (symndx, R_PPC64_REL24);
10531 if (h->oh != NULL && h->oh->is_func)
10532 h = ppc_follow_link (h->oh);
10533 if (h->elf.root.u.def.section != stub_entry->target_section)
10534 /* H is an opd symbol. The addend must be zero. */
10535 r->r_addend = 0;
10536 else
10537 {
10538 off = (h->elf.root.u.def.value
10539 + h->elf.root.u.def.section->output_offset
10540 + h->elf.root.u.def.section->output_section->vma);
10541 r->r_addend -= off;
10542 }
10543 }
10544 }
10545 break;
10546
10547 case ppc_stub_plt_branch:
10548 case ppc_stub_plt_branch_r2off:
10549 br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
10550 stub_entry->root.string + 9,
10551 FALSE, FALSE);
10552 if (br_entry == NULL)
10553 {
10554 info->callbacks->einfo (_("%P: can't find branch stub `%s'\n"),
10555 stub_entry->root.string);
10556 htab->stub_error = TRUE;
10557 return FALSE;
10558 }
10559
10560 dest = (stub_entry->target_value
10561 + stub_entry->target_section->output_offset
10562 + stub_entry->target_section->output_section->vma);
10563 if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
10564 dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
10565
10566 bfd_put_64 (htab->brlt->owner, dest,
10567 htab->brlt->contents + br_entry->offset);
10568
10569 if (br_entry->iter == htab->stub_iteration)
10570 {
10571 br_entry->iter = 0;
10572
10573 if (htab->relbrlt != NULL)
10574 {
10575 /* Create a reloc for the branch lookup table entry. */
10576 Elf_Internal_Rela rela;
10577 bfd_byte *rl;
10578
10579 rela.r_offset = (br_entry->offset
10580 + htab->brlt->output_offset
10581 + htab->brlt->output_section->vma);
10582 rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
10583 rela.r_addend = dest;
10584
10585 rl = htab->relbrlt->contents;
10586 rl += (htab->relbrlt->reloc_count++
10587 * sizeof (Elf64_External_Rela));
10588 bfd_elf64_swap_reloca_out (htab->relbrlt->owner, &rela, rl);
10589 }
10590 else if (info->emitrelocations)
10591 {
10592 r = get_relocs (htab->brlt, 1);
10593 if (r == NULL)
10594 return FALSE;
10595 /* brlt, being SEC_LINKER_CREATED does not go through the
10596 normal reloc processing. Symbols and offsets are not
10597 translated from input file to output file form, so
10598 set up the offset per the output file. */
10599 r->r_offset = (br_entry->offset
10600 + htab->brlt->output_offset
10601 + htab->brlt->output_section->vma);
10602 r->r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
10603 r->r_addend = dest;
10604 }
10605 }
10606
10607 dest = (br_entry->offset
10608 + htab->brlt->output_offset
10609 + htab->brlt->output_section->vma);
10610
10611 off = (dest
10612 - elf_gp (htab->brlt->output_section->owner)
10613 - htab->stub_group[stub_entry->id_sec->id].toc_off);
10614
10615 if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
10616 {
10617 info->callbacks->einfo
10618 (_("%P: linkage table error against `%T'\n"),
10619 stub_entry->root.string);
10620 bfd_set_error (bfd_error_bad_value);
10621 htab->stub_error = TRUE;
10622 return FALSE;
10623 }
10624
10625 if (info->emitrelocations)
10626 {
10627 r = get_relocs (stub_entry->stub_sec, 1 + (PPC_HA (off) != 0));
10628 if (r == NULL)
10629 return FALSE;
10630 r[0].r_offset = loc - stub_entry->stub_sec->contents;
10631 if (bfd_big_endian (info->output_bfd))
10632 r[0].r_offset += 2;
10633 if (stub_entry->stub_type == ppc_stub_plt_branch_r2off)
10634 r[0].r_offset += 4;
10635 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10636 r[0].r_addend = dest;
10637 if (PPC_HA (off) != 0)
10638 {
10639 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
10640 r[1].r_offset = r[0].r_offset + 4;
10641 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10642 r[1].r_addend = r[0].r_addend;
10643 }
10644 }
10645
10646 if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
10647 {
10648 if (PPC_HA (off) != 0)
10649 {
10650 size = 16;
10651 bfd_put_32 (htab->params->stub_bfd,
10652 ADDIS_R11_R2 | PPC_HA (off), loc);
10653 loc += 4;
10654 bfd_put_32 (htab->params->stub_bfd,
10655 LD_R12_0R11 | PPC_LO (off), loc);
10656 }
10657 else
10658 {
10659 size = 12;
10660 bfd_put_32 (htab->params->stub_bfd,
10661 LD_R12_0R2 | PPC_LO (off), loc);
10662 }
10663 }
10664 else
10665 {
10666 bfd_vma r2off = get_r2off (info, stub_entry);
10667
10668 if (r2off == 0 && htab->opd_abi)
10669 {
10670 htab->stub_error = TRUE;
10671 return FALSE;
10672 }
10673
10674 bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), loc);
10675 loc += 4;
10676 size = 16;
10677 if (PPC_HA (off) != 0)
10678 {
10679 size += 4;
10680 bfd_put_32 (htab->params->stub_bfd,
10681 ADDIS_R11_R2 | PPC_HA (off), loc);
10682 loc += 4;
10683 bfd_put_32 (htab->params->stub_bfd,
10684 LD_R12_0R11 | PPC_LO (off), loc);
10685 }
10686 else
10687 bfd_put_32 (htab->params->stub_bfd, LD_R12_0R2 | PPC_LO (off), loc);
10688
10689 if (PPC_HA (r2off) != 0)
10690 {
10691 size += 4;
10692 loc += 4;
10693 bfd_put_32 (htab->params->stub_bfd,
10694 ADDIS_R2_R2 | PPC_HA (r2off), loc);
10695 }
10696 if (PPC_LO (r2off) != 0)
10697 {
10698 size += 4;
10699 loc += 4;
10700 bfd_put_32 (htab->params->stub_bfd,
10701 ADDI_R2_R2 | PPC_LO (r2off), loc);
10702 }
10703 }
10704 loc += 4;
10705 bfd_put_32 (htab->params->stub_bfd, MTCTR_R12, loc);
10706 loc += 4;
10707 bfd_put_32 (htab->params->stub_bfd, BCTR, loc);
10708 break;
10709
10710 case ppc_stub_plt_call:
10711 case ppc_stub_plt_call_r2save:
10712 if (stub_entry->h != NULL
10713 && stub_entry->h->is_func_descriptor
10714 && stub_entry->h->oh != NULL)
10715 {
10716 struct ppc_link_hash_entry *fh = ppc_follow_link (stub_entry->h->oh);
10717
10718 /* If the old-ABI "dot-symbol" is undefined make it weak so
10719 we don't get a link error from RELOC_FOR_GLOBAL_SYMBOL.
10720 FIXME: We used to define the symbol on one of the call
10721 stubs instead, which is why we test symbol section id
10722 against htab->top_id in various places. Likely all
10723 these checks could now disappear. */
10724 if (fh->elf.root.type == bfd_link_hash_undefined)
10725 fh->elf.root.type = bfd_link_hash_undefweak;
10726 /* Stop undo_symbol_twiddle changing it back to undefined. */
10727 fh->was_undefined = 0;
10728 }
10729
10730 /* Now build the stub. */
10731 dest = stub_entry->plt_ent->plt.offset & ~1;
10732 if (dest >= (bfd_vma) -2)
10733 abort ();
10734
10735 plt = htab->elf.splt;
10736 if (!htab->elf.dynamic_sections_created
10737 || stub_entry->h == NULL
10738 || stub_entry->h->elf.dynindx == -1)
10739 plt = htab->elf.iplt;
10740
10741 dest += plt->output_offset + plt->output_section->vma;
10742
10743 if (stub_entry->h == NULL
10744 && (stub_entry->plt_ent->plt.offset & 1) == 0)
10745 {
10746 Elf_Internal_Rela rela;
10747 bfd_byte *rl;
10748
10749 rela.r_offset = dest;
10750 if (htab->opd_abi)
10751 rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
10752 else
10753 rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
10754 rela.r_addend = (stub_entry->target_value
10755 + stub_entry->target_section->output_offset
10756 + stub_entry->target_section->output_section->vma);
10757
10758 rl = (htab->elf.irelplt->contents
10759 + (htab->elf.irelplt->reloc_count++
10760 * sizeof (Elf64_External_Rela)));
10761 bfd_elf64_swap_reloca_out (info->output_bfd, &rela, rl);
10762 stub_entry->plt_ent->plt.offset |= 1;
10763 }
10764
10765 off = (dest
10766 - elf_gp (plt->output_section->owner)
10767 - htab->stub_group[stub_entry->id_sec->id].toc_off);
10768
10769 if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
10770 {
10771 info->callbacks->einfo
10772 (_("%P: linkage table error against `%T'\n"),
10773 stub_entry->h != NULL
10774 ? stub_entry->h->elf.root.root.string
10775 : "<local sym>");
10776 bfd_set_error (bfd_error_bad_value);
10777 htab->stub_error = TRUE;
10778 return FALSE;
10779 }
10780
10781 if (htab->params->plt_stub_align != 0)
10782 {
10783 unsigned pad = plt_stub_pad (htab, stub_entry, off);
10784
10785 stub_entry->stub_sec->size += pad;
10786 stub_entry->stub_offset = stub_entry->stub_sec->size;
10787 loc += pad;
10788 }
10789
10790 r = NULL;
10791 if (info->emitrelocations)
10792 {
10793 r = get_relocs (stub_entry->stub_sec,
10794 ((PPC_HA (off) != 0)
10795 + (htab->opd_abi
10796 ? 2 + (htab->params->plt_static_chain
10797 && PPC_HA (off + 16) == PPC_HA (off))
10798 : 1)));
10799 if (r == NULL)
10800 return FALSE;
10801 r[0].r_offset = loc - stub_entry->stub_sec->contents;
10802 if (bfd_big_endian (info->output_bfd))
10803 r[0].r_offset += 2;
10804 r[0].r_addend = dest;
10805 }
10806 if (stub_entry->h != NULL
10807 && (stub_entry->h == htab->tls_get_addr_fd
10808 || stub_entry->h == htab->tls_get_addr)
10809 && !htab->params->no_tls_get_addr_opt)
10810 p = build_tls_get_addr_stub (htab, stub_entry, loc, off, r);
10811 else
10812 p = build_plt_stub (htab, stub_entry, loc, off, r);
10813 size = p - loc;
10814 break;
10815
10816 default:
10817 BFD_FAIL ();
10818 return FALSE;
10819 }
10820
10821 stub_entry->stub_sec->size += size;
10822
10823 if (htab->params->emit_stub_syms)
10824 {
10825 struct elf_link_hash_entry *h;
10826 size_t len1, len2;
10827 char *name;
10828 const char *const stub_str[] = { "long_branch",
10829 "long_branch_r2off",
10830 "plt_branch",
10831 "plt_branch_r2off",
10832 "plt_call",
10833 "plt_call" };
10834
10835 len1 = strlen (stub_str[stub_entry->stub_type - 1]);
10836 len2 = strlen (stub_entry->root.string);
10837 name = bfd_malloc (len1 + len2 + 2);
10838 if (name == NULL)
10839 return FALSE;
10840 memcpy (name, stub_entry->root.string, 9);
10841 memcpy (name + 9, stub_str[stub_entry->stub_type - 1], len1);
10842 memcpy (name + len1 + 9, stub_entry->root.string + 8, len2 - 8 + 1);
10843 h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
10844 if (h == NULL)
10845 return FALSE;
10846 if (h->root.type == bfd_link_hash_new)
10847 {
10848 h->root.type = bfd_link_hash_defined;
10849 h->root.u.def.section = stub_entry->stub_sec;
10850 h->root.u.def.value = stub_entry->stub_offset;
10851 h->ref_regular = 1;
10852 h->def_regular = 1;
10853 h->ref_regular_nonweak = 1;
10854 h->forced_local = 1;
10855 h->non_elf = 0;
10856 }
10857 }
10858
10859 return TRUE;
10860 }
10861
10862 /* As above, but don't actually build the stub. Just bump offset so
10863 we know stub section sizes, and select plt_branch stubs where
10864 long_branch stubs won't do. */
10865
10866 static bfd_boolean
10867 ppc_size_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
10868 {
10869 struct ppc_stub_hash_entry *stub_entry;
10870 struct bfd_link_info *info;
10871 struct ppc_link_hash_table *htab;
10872 bfd_vma off;
10873 int size;
10874
10875 /* Massage our args to the form they really have. */
10876 stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
10877 info = in_arg;
10878
10879 htab = ppc_hash_table (info);
10880 if (htab == NULL)
10881 return FALSE;
10882
10883 if (stub_entry->stub_type == ppc_stub_plt_call
10884 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10885 {
10886 asection *plt;
10887 off = stub_entry->plt_ent->plt.offset & ~(bfd_vma) 1;
10888 if (off >= (bfd_vma) -2)
10889 abort ();
10890 plt = htab->elf.splt;
10891 if (!htab->elf.dynamic_sections_created
10892 || stub_entry->h == NULL
10893 || stub_entry->h->elf.dynindx == -1)
10894 plt = htab->elf.iplt;
10895 off += (plt->output_offset
10896 + plt->output_section->vma
10897 - elf_gp (plt->output_section->owner)
10898 - htab->stub_group[stub_entry->id_sec->id].toc_off);
10899
10900 size = plt_stub_size (htab, stub_entry, off);
10901 if (htab->params->plt_stub_align)
10902 size += plt_stub_pad (htab, stub_entry, off);
10903 if (info->emitrelocations)
10904 {
10905 stub_entry->stub_sec->reloc_count
10906 += ((PPC_HA (off) != 0)
10907 + (htab->opd_abi
10908 ? 2 + (htab->params->plt_static_chain
10909 && PPC_HA (off + 16) == PPC_HA (off))
10910 : 1));
10911 stub_entry->stub_sec->flags |= SEC_RELOC;
10912 }
10913 }
10914 else
10915 {
10916 /* ppc_stub_long_branch or ppc_stub_plt_branch, or their r2off
10917 variants. */
10918 bfd_vma r2off = 0;
10919 bfd_vma local_off = 0;
10920
10921 off = (stub_entry->target_value
10922 + stub_entry->target_section->output_offset
10923 + stub_entry->target_section->output_section->vma);
10924 off -= (stub_entry->stub_sec->size
10925 + stub_entry->stub_sec->output_offset
10926 + stub_entry->stub_sec->output_section->vma);
10927
10928 /* Reset the stub type from the plt variant in case we now
10929 can reach with a shorter stub. */
10930 if (stub_entry->stub_type >= ppc_stub_plt_branch)
10931 stub_entry->stub_type += ppc_stub_long_branch - ppc_stub_plt_branch;
10932
10933 size = 4;
10934 if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
10935 {
10936 r2off = get_r2off (info, stub_entry);
10937 if (r2off == 0 && htab->opd_abi)
10938 {
10939 htab->stub_error = TRUE;
10940 return FALSE;
10941 }
10942 size = 12;
10943 if (PPC_HA (r2off) != 0)
10944 size = 16;
10945 off -= size - 4;
10946 }
10947
10948 local_off = PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
10949
10950 /* If the branch offset if too big, use a ppc_stub_plt_branch.
10951 Do the same for -R objects without function descriptors. */
10952 if (off + (1 << 25) >= (bfd_vma) (1 << 26) - local_off
10953 || (stub_entry->stub_type == ppc_stub_long_branch_r2off
10954 && r2off == 0))
10955 {
10956 struct ppc_branch_hash_entry *br_entry;
10957
10958 br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
10959 stub_entry->root.string + 9,
10960 TRUE, FALSE);
10961 if (br_entry == NULL)
10962 {
10963 info->callbacks->einfo (_("%P: can't build branch stub `%s'\n"),
10964 stub_entry->root.string);
10965 htab->stub_error = TRUE;
10966 return FALSE;
10967 }
10968
10969 if (br_entry->iter != htab->stub_iteration)
10970 {
10971 br_entry->iter = htab->stub_iteration;
10972 br_entry->offset = htab->brlt->size;
10973 htab->brlt->size += 8;
10974
10975 if (htab->relbrlt != NULL)
10976 htab->relbrlt->size += sizeof (Elf64_External_Rela);
10977 else if (info->emitrelocations)
10978 {
10979 htab->brlt->reloc_count += 1;
10980 htab->brlt->flags |= SEC_RELOC;
10981 }
10982 }
10983
10984 stub_entry->stub_type += ppc_stub_plt_branch - ppc_stub_long_branch;
10985 off = (br_entry->offset
10986 + htab->brlt->output_offset
10987 + htab->brlt->output_section->vma
10988 - elf_gp (htab->brlt->output_section->owner)
10989 - htab->stub_group[stub_entry->id_sec->id].toc_off);
10990
10991 if (info->emitrelocations)
10992 {
10993 stub_entry->stub_sec->reloc_count += 1 + (PPC_HA (off) != 0);
10994 stub_entry->stub_sec->flags |= SEC_RELOC;
10995 }
10996
10997 if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
10998 {
10999 size = 12;
11000 if (PPC_HA (off) != 0)
11001 size = 16;
11002 }
11003 else
11004 {
11005 size = 16;
11006 if (PPC_HA (off) != 0)
11007 size += 4;
11008
11009 if (PPC_HA (r2off) != 0)
11010 size += 4;
11011 if (PPC_LO (r2off) != 0)
11012 size += 4;
11013 }
11014 }
11015 else if (info->emitrelocations)
11016 {
11017 stub_entry->stub_sec->reloc_count += 1;
11018 stub_entry->stub_sec->flags |= SEC_RELOC;
11019 }
11020 }
11021
11022 stub_entry->stub_sec->size += size;
11023 return TRUE;
11024 }
11025
11026 /* Set up various things so that we can make a list of input sections
11027 for each output section included in the link. Returns -1 on error,
11028 0 when no stubs will be needed, and 1 on success. */
11029
11030 int
11031 ppc64_elf_setup_section_lists (struct bfd_link_info *info)
11032 {
11033 bfd *input_bfd;
11034 int top_id, top_index, id;
11035 asection *section;
11036 asection **input_list;
11037 bfd_size_type amt;
11038 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11039
11040 if (htab == NULL)
11041 return -1;
11042
11043 /* Find the top input section id. */
11044 for (input_bfd = info->input_bfds, top_id = 3;
11045 input_bfd != NULL;
11046 input_bfd = input_bfd->link_next)
11047 {
11048 for (section = input_bfd->sections;
11049 section != NULL;
11050 section = section->next)
11051 {
11052 if (top_id < section->id)
11053 top_id = section->id;
11054 }
11055 }
11056
11057 htab->top_id = top_id;
11058 amt = sizeof (struct map_stub) * (top_id + 1);
11059 htab->stub_group = bfd_zmalloc (amt);
11060 if (htab->stub_group == NULL)
11061 return -1;
11062
11063 /* Set toc_off for com, und, abs and ind sections. */
11064 for (id = 0; id < 3; id++)
11065 htab->stub_group[id].toc_off = TOC_BASE_OFF;
11066
11067 /* We can't use output_bfd->section_count here to find the top output
11068 section index as some sections may have been removed, and
11069 strip_excluded_output_sections doesn't renumber the indices. */
11070 for (section = info->output_bfd->sections, top_index = 0;
11071 section != NULL;
11072 section = section->next)
11073 {
11074 if (top_index < section->index)
11075 top_index = section->index;
11076 }
11077
11078 htab->top_index = top_index;
11079 amt = sizeof (asection *) * (top_index + 1);
11080 input_list = bfd_zmalloc (amt);
11081 htab->input_list = input_list;
11082 if (input_list == NULL)
11083 return -1;
11084
11085 return 1;
11086 }
11087
11088 /* Set up for first pass at multitoc partitioning. */
11089
11090 void
11091 ppc64_elf_start_multitoc_partition (struct bfd_link_info *info)
11092 {
11093 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11094
11095 htab->toc_curr = ppc64_elf_set_toc (info, info->output_bfd);
11096 htab->toc_bfd = NULL;
11097 htab->toc_first_sec = NULL;
11098 }
11099
11100 /* The linker repeatedly calls this function for each TOC input section
11101 and linker generated GOT section. Group input bfds such that the toc
11102 within a group is less than 64k in size. */
11103
11104 bfd_boolean
11105 ppc64_elf_next_toc_section (struct bfd_link_info *info, asection *isec)
11106 {
11107 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11108 bfd_vma addr, off, limit;
11109
11110 if (htab == NULL)
11111 return FALSE;
11112
11113 if (!htab->second_toc_pass)
11114 {
11115 /* Keep track of the first .toc or .got section for this input bfd. */
11116 bfd_boolean new_bfd = htab->toc_bfd != isec->owner;
11117
11118 if (new_bfd)
11119 {
11120 htab->toc_bfd = isec->owner;
11121 htab->toc_first_sec = isec;
11122 }
11123
11124 addr = isec->output_offset + isec->output_section->vma;
11125 off = addr - htab->toc_curr;
11126 limit = 0x80008000;
11127 if (ppc64_elf_tdata (isec->owner)->has_small_toc_reloc)
11128 limit = 0x10000;
11129 if (off + isec->size > limit)
11130 {
11131 addr = (htab->toc_first_sec->output_offset
11132 + htab->toc_first_sec->output_section->vma);
11133 htab->toc_curr = addr;
11134 }
11135
11136 /* toc_curr is the base address of this toc group. Set elf_gp
11137 for the input section to be the offset relative to the
11138 output toc base plus 0x8000. Making the input elf_gp an
11139 offset allows us to move the toc as a whole without
11140 recalculating input elf_gp. */
11141 off = htab->toc_curr - elf_gp (isec->output_section->owner);
11142 off += TOC_BASE_OFF;
11143
11144 /* Die if someone uses a linker script that doesn't keep input
11145 file .toc and .got together. */
11146 if (new_bfd
11147 && elf_gp (isec->owner) != 0
11148 && elf_gp (isec->owner) != off)
11149 return FALSE;
11150
11151 elf_gp (isec->owner) = off;
11152 return TRUE;
11153 }
11154
11155 /* During the second pass toc_first_sec points to the start of
11156 a toc group, and toc_curr is used to track the old elf_gp.
11157 We use toc_bfd to ensure we only look at each bfd once. */
11158 if (htab->toc_bfd == isec->owner)
11159 return TRUE;
11160 htab->toc_bfd = isec->owner;
11161
11162 if (htab->toc_first_sec == NULL
11163 || htab->toc_curr != elf_gp (isec->owner))
11164 {
11165 htab->toc_curr = elf_gp (isec->owner);
11166 htab->toc_first_sec = isec;
11167 }
11168 addr = (htab->toc_first_sec->output_offset
11169 + htab->toc_first_sec->output_section->vma);
11170 off = addr - elf_gp (isec->output_section->owner) + TOC_BASE_OFF;
11171 elf_gp (isec->owner) = off;
11172
11173 return TRUE;
11174 }
11175
11176 /* Called via elf_link_hash_traverse to merge GOT entries for global
11177 symbol H. */
11178
11179 static bfd_boolean
11180 merge_global_got (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
11181 {
11182 if (h->root.type == bfd_link_hash_indirect)
11183 return TRUE;
11184
11185 merge_got_entries (&h->got.glist);
11186
11187 return TRUE;
11188 }
11189
11190 /* Called via elf_link_hash_traverse to allocate GOT entries for global
11191 symbol H. */
11192
11193 static bfd_boolean
11194 reallocate_got (struct elf_link_hash_entry *h, void *inf)
11195 {
11196 struct got_entry *gent;
11197
11198 if (h->root.type == bfd_link_hash_indirect)
11199 return TRUE;
11200
11201 for (gent = h->got.glist; gent != NULL; gent = gent->next)
11202 if (!gent->is_indirect)
11203 allocate_got (h, (struct bfd_link_info *) inf, gent);
11204 return TRUE;
11205 }
11206
11207 /* Called on the first multitoc pass after the last call to
11208 ppc64_elf_next_toc_section. This function removes duplicate GOT
11209 entries. */
11210
11211 bfd_boolean
11212 ppc64_elf_layout_multitoc (struct bfd_link_info *info)
11213 {
11214 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11215 struct bfd *ibfd, *ibfd2;
11216 bfd_boolean done_something;
11217
11218 htab->multi_toc_needed = htab->toc_curr != elf_gp (info->output_bfd);
11219
11220 if (!htab->do_multi_toc)
11221 return FALSE;
11222
11223 /* Merge global sym got entries within a toc group. */
11224 elf_link_hash_traverse (&htab->elf, merge_global_got, info);
11225
11226 /* And tlsld_got. */
11227 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
11228 {
11229 struct got_entry *ent, *ent2;
11230
11231 if (!is_ppc64_elf (ibfd))
11232 continue;
11233
11234 ent = ppc64_tlsld_got (ibfd);
11235 if (!ent->is_indirect
11236 && ent->got.offset != (bfd_vma) -1)
11237 {
11238 for (ibfd2 = ibfd->link_next; ibfd2 != NULL; ibfd2 = ibfd2->link_next)
11239 {
11240 if (!is_ppc64_elf (ibfd2))
11241 continue;
11242
11243 ent2 = ppc64_tlsld_got (ibfd2);
11244 if (!ent2->is_indirect
11245 && ent2->got.offset != (bfd_vma) -1
11246 && elf_gp (ibfd2) == elf_gp (ibfd))
11247 {
11248 ent2->is_indirect = TRUE;
11249 ent2->got.ent = ent;
11250 }
11251 }
11252 }
11253 }
11254
11255 /* Zap sizes of got sections. */
11256 htab->elf.irelplt->rawsize = htab->elf.irelplt->size;
11257 htab->elf.irelplt->size -= htab->got_reli_size;
11258 htab->got_reli_size = 0;
11259
11260 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
11261 {
11262 asection *got, *relgot;
11263
11264 if (!is_ppc64_elf (ibfd))
11265 continue;
11266
11267 got = ppc64_elf_tdata (ibfd)->got;
11268 if (got != NULL)
11269 {
11270 got->rawsize = got->size;
11271 got->size = 0;
11272 relgot = ppc64_elf_tdata (ibfd)->relgot;
11273 relgot->rawsize = relgot->size;
11274 relgot->size = 0;
11275 }
11276 }
11277
11278 /* Now reallocate the got, local syms first. We don't need to
11279 allocate section contents again since we never increase size. */
11280 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
11281 {
11282 struct got_entry **lgot_ents;
11283 struct got_entry **end_lgot_ents;
11284 struct plt_entry **local_plt;
11285 struct plt_entry **end_local_plt;
11286 unsigned char *lgot_masks;
11287 bfd_size_type locsymcount;
11288 Elf_Internal_Shdr *symtab_hdr;
11289 asection *s;
11290
11291 if (!is_ppc64_elf (ibfd))
11292 continue;
11293
11294 lgot_ents = elf_local_got_ents (ibfd);
11295 if (!lgot_ents)
11296 continue;
11297
11298 symtab_hdr = &elf_symtab_hdr (ibfd);
11299 locsymcount = symtab_hdr->sh_info;
11300 end_lgot_ents = lgot_ents + locsymcount;
11301 local_plt = (struct plt_entry **) end_lgot_ents;
11302 end_local_plt = local_plt + locsymcount;
11303 lgot_masks = (unsigned char *) end_local_plt;
11304 s = ppc64_elf_tdata (ibfd)->got;
11305 for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
11306 {
11307 struct got_entry *ent;
11308
11309 for (ent = *lgot_ents; ent != NULL; ent = ent->next)
11310 {
11311 unsigned int ent_size = 8;
11312 unsigned int rel_size = sizeof (Elf64_External_Rela);
11313
11314 ent->got.offset = s->size;
11315 if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
11316 {
11317 ent_size *= 2;
11318 rel_size *= 2;
11319 }
11320 s->size += ent_size;
11321 if ((*lgot_masks & PLT_IFUNC) != 0)
11322 {
11323 htab->elf.irelplt->size += rel_size;
11324 htab->got_reli_size += rel_size;
11325 }
11326 else if (info->shared)
11327 {
11328 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
11329 srel->size += rel_size;
11330 }
11331 }
11332 }
11333 }
11334
11335 elf_link_hash_traverse (&htab->elf, reallocate_got, info);
11336
11337 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
11338 {
11339 struct got_entry *ent;
11340
11341 if (!is_ppc64_elf (ibfd))
11342 continue;
11343
11344 ent = ppc64_tlsld_got (ibfd);
11345 if (!ent->is_indirect
11346 && ent->got.offset != (bfd_vma) -1)
11347 {
11348 asection *s = ppc64_elf_tdata (ibfd)->got;
11349 ent->got.offset = s->size;
11350 s->size += 16;
11351 if (info->shared)
11352 {
11353 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
11354 srel->size += sizeof (Elf64_External_Rela);
11355 }
11356 }
11357 }
11358
11359 done_something = htab->elf.irelplt->rawsize != htab->elf.irelplt->size;
11360 if (!done_something)
11361 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
11362 {
11363 asection *got;
11364
11365 if (!is_ppc64_elf (ibfd))
11366 continue;
11367
11368 got = ppc64_elf_tdata (ibfd)->got;
11369 if (got != NULL)
11370 {
11371 done_something = got->rawsize != got->size;
11372 if (done_something)
11373 break;
11374 }
11375 }
11376
11377 if (done_something)
11378 (*htab->params->layout_sections_again) ();
11379
11380 /* Set up for second pass over toc sections to recalculate elf_gp
11381 on input sections. */
11382 htab->toc_bfd = NULL;
11383 htab->toc_first_sec = NULL;
11384 htab->second_toc_pass = TRUE;
11385 return done_something;
11386 }
11387
11388 /* Called after second pass of multitoc partitioning. */
11389
11390 void
11391 ppc64_elf_finish_multitoc_partition (struct bfd_link_info *info)
11392 {
11393 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11394
11395 /* After the second pass, toc_curr tracks the TOC offset used
11396 for code sections below in ppc64_elf_next_input_section. */
11397 htab->toc_curr = TOC_BASE_OFF;
11398 }
11399
11400 /* No toc references were found in ISEC. If the code in ISEC makes no
11401 calls, then there's no need to use toc adjusting stubs when branching
11402 into ISEC. Actually, indirect calls from ISEC are OK as they will
11403 load r2. Returns -1 on error, 0 for no stub needed, 1 for stub
11404 needed, and 2 if a cyclical call-graph was found but no other reason
11405 for a stub was detected. If called from the top level, a return of
11406 2 means the same as a return of 0. */
11407
11408 static int
11409 toc_adjusting_stub_needed (struct bfd_link_info *info, asection *isec)
11410 {
11411 int ret;
11412
11413 /* Mark this section as checked. */
11414 isec->call_check_done = 1;
11415
11416 /* We know none of our code bearing sections will need toc stubs. */
11417 if ((isec->flags & SEC_LINKER_CREATED) != 0)
11418 return 0;
11419
11420 if (isec->size == 0)
11421 return 0;
11422
11423 if (isec->output_section == NULL)
11424 return 0;
11425
11426 ret = 0;
11427 if (isec->reloc_count != 0)
11428 {
11429 Elf_Internal_Rela *relstart, *rel;
11430 Elf_Internal_Sym *local_syms;
11431 struct ppc_link_hash_table *htab;
11432
11433 relstart = _bfd_elf_link_read_relocs (isec->owner, isec, NULL, NULL,
11434 info->keep_memory);
11435 if (relstart == NULL)
11436 return -1;
11437
11438 /* Look for branches to outside of this section. */
11439 local_syms = NULL;
11440 htab = ppc_hash_table (info);
11441 if (htab == NULL)
11442 return -1;
11443
11444 for (rel = relstart; rel < relstart + isec->reloc_count; ++rel)
11445 {
11446 enum elf_ppc64_reloc_type r_type;
11447 unsigned long r_symndx;
11448 struct elf_link_hash_entry *h;
11449 struct ppc_link_hash_entry *eh;
11450 Elf_Internal_Sym *sym;
11451 asection *sym_sec;
11452 struct _opd_sec_data *opd;
11453 bfd_vma sym_value;
11454 bfd_vma dest;
11455
11456 r_type = ELF64_R_TYPE (rel->r_info);
11457 if (r_type != R_PPC64_REL24
11458 && r_type != R_PPC64_REL14
11459 && r_type != R_PPC64_REL14_BRTAKEN
11460 && r_type != R_PPC64_REL14_BRNTAKEN)
11461 continue;
11462
11463 r_symndx = ELF64_R_SYM (rel->r_info);
11464 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms, r_symndx,
11465 isec->owner))
11466 {
11467 ret = -1;
11468 break;
11469 }
11470
11471 /* Calls to dynamic lib functions go through a plt call stub
11472 that uses r2. */
11473 eh = (struct ppc_link_hash_entry *) h;
11474 if (eh != NULL
11475 && (eh->elf.plt.plist != NULL
11476 || (eh->oh != NULL
11477 && ppc_follow_link (eh->oh)->elf.plt.plist != NULL)))
11478 {
11479 ret = 1;
11480 break;
11481 }
11482
11483 if (sym_sec == NULL)
11484 /* Ignore other undefined symbols. */
11485 continue;
11486
11487 /* Assume branches to other sections not included in the
11488 link need stubs too, to cover -R and absolute syms. */
11489 if (sym_sec->output_section == NULL)
11490 {
11491 ret = 1;
11492 break;
11493 }
11494
11495 if (h == NULL)
11496 sym_value = sym->st_value;
11497 else
11498 {
11499 if (h->root.type != bfd_link_hash_defined
11500 && h->root.type != bfd_link_hash_defweak)
11501 abort ();
11502 sym_value = h->root.u.def.value;
11503 }
11504 sym_value += rel->r_addend;
11505
11506 /* If this branch reloc uses an opd sym, find the code section. */
11507 opd = get_opd_info (sym_sec);
11508 if (opd != NULL)
11509 {
11510 if (h == NULL && opd->adjust != NULL)
11511 {
11512 long adjust;
11513
11514 adjust = opd->adjust[sym->st_value / 8];
11515 if (adjust == -1)
11516 /* Assume deleted functions won't ever be called. */
11517 continue;
11518 sym_value += adjust;
11519 }
11520
11521 dest = opd_entry_value (sym_sec, sym_value,
11522 &sym_sec, NULL, FALSE);
11523 if (dest == (bfd_vma) -1)
11524 continue;
11525 }
11526 else
11527 dest = (sym_value
11528 + sym_sec->output_offset
11529 + sym_sec->output_section->vma);
11530
11531 /* Ignore branch to self. */
11532 if (sym_sec == isec)
11533 continue;
11534
11535 /* If the called function uses the toc, we need a stub. */
11536 if (sym_sec->has_toc_reloc
11537 || sym_sec->makes_toc_func_call)
11538 {
11539 ret = 1;
11540 break;
11541 }
11542
11543 /* Assume any branch that needs a long branch stub might in fact
11544 need a plt_branch stub. A plt_branch stub uses r2. */
11545 else if (dest - (isec->output_offset
11546 + isec->output_section->vma
11547 + rel->r_offset) + (1 << 25)
11548 >= (2u << 25) - PPC64_LOCAL_ENTRY_OFFSET (h
11549 ? h->other
11550 : sym->st_other))
11551 {
11552 ret = 1;
11553 break;
11554 }
11555
11556 /* If calling back to a section in the process of being
11557 tested, we can't say for sure that no toc adjusting stubs
11558 are needed, so don't return zero. */
11559 else if (sym_sec->call_check_in_progress)
11560 ret = 2;
11561
11562 /* Branches to another section that itself doesn't have any TOC
11563 references are OK. Recursively call ourselves to check. */
11564 else if (!sym_sec->call_check_done)
11565 {
11566 int recur;
11567
11568 /* Mark current section as indeterminate, so that other
11569 sections that call back to current won't be marked as
11570 known. */
11571 isec->call_check_in_progress = 1;
11572 recur = toc_adjusting_stub_needed (info, sym_sec);
11573 isec->call_check_in_progress = 0;
11574
11575 if (recur != 0)
11576 {
11577 ret = recur;
11578 if (recur != 2)
11579 break;
11580 }
11581 }
11582 }
11583
11584 if (local_syms != NULL
11585 && (elf_symtab_hdr (isec->owner).contents
11586 != (unsigned char *) local_syms))
11587 free (local_syms);
11588 if (elf_section_data (isec)->relocs != relstart)
11589 free (relstart);
11590 }
11591
11592 if ((ret & 1) == 0
11593 && isec->map_head.s != NULL
11594 && (strcmp (isec->output_section->name, ".init") == 0
11595 || strcmp (isec->output_section->name, ".fini") == 0))
11596 {
11597 if (isec->map_head.s->has_toc_reloc
11598 || isec->map_head.s->makes_toc_func_call)
11599 ret = 1;
11600 else if (!isec->map_head.s->call_check_done)
11601 {
11602 int recur;
11603 isec->call_check_in_progress = 1;
11604 recur = toc_adjusting_stub_needed (info, isec->map_head.s);
11605 isec->call_check_in_progress = 0;
11606 if (recur != 0)
11607 ret = recur;
11608 }
11609 }
11610
11611 if (ret == 1)
11612 isec->makes_toc_func_call = 1;
11613
11614 return ret;
11615 }
11616
11617 /* The linker repeatedly calls this function for each input section,
11618 in the order that input sections are linked into output sections.
11619 Build lists of input sections to determine groupings between which
11620 we may insert linker stubs. */
11621
11622 bfd_boolean
11623 ppc64_elf_next_input_section (struct bfd_link_info *info, asection *isec)
11624 {
11625 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11626
11627 if (htab == NULL)
11628 return FALSE;
11629
11630 if ((isec->output_section->flags & SEC_CODE) != 0
11631 && isec->output_section->index <= htab->top_index)
11632 {
11633 asection **list = htab->input_list + isec->output_section->index;
11634 /* Steal the link_sec pointer for our list. */
11635 #define PREV_SEC(sec) (htab->stub_group[(sec)->id].link_sec)
11636 /* This happens to make the list in reverse order,
11637 which is what we want. */
11638 PREV_SEC (isec) = *list;
11639 *list = isec;
11640 }
11641
11642 if (htab->multi_toc_needed)
11643 {
11644 /* Analyse sections that aren't already flagged as needing a
11645 valid toc pointer. Exclude .fixup for the linux kernel.
11646 .fixup contains branches, but only back to the function that
11647 hit an exception. */
11648 if (!(isec->has_toc_reloc
11649 || (isec->flags & SEC_CODE) == 0
11650 || strcmp (isec->name, ".fixup") == 0
11651 || isec->call_check_done))
11652 {
11653 if (toc_adjusting_stub_needed (info, isec) < 0)
11654 return FALSE;
11655 }
11656 /* Make all sections use the TOC assigned for this object file.
11657 This will be wrong for pasted sections; We fix that in
11658 check_pasted_section(). */
11659 if (elf_gp (isec->owner) != 0)
11660 htab->toc_curr = elf_gp (isec->owner);
11661 }
11662
11663 htab->stub_group[isec->id].toc_off = htab->toc_curr;
11664 return TRUE;
11665 }
11666
11667 /* Check that all .init and .fini sections use the same toc, if they
11668 have toc relocs. */
11669
11670 static bfd_boolean
11671 check_pasted_section (struct bfd_link_info *info, const char *name)
11672 {
11673 asection *o = bfd_get_section_by_name (info->output_bfd, name);
11674
11675 if (o != NULL)
11676 {
11677 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11678 bfd_vma toc_off = 0;
11679 asection *i;
11680
11681 for (i = o->map_head.s; i != NULL; i = i->map_head.s)
11682 if (i->has_toc_reloc)
11683 {
11684 if (toc_off == 0)
11685 toc_off = htab->stub_group[i->id].toc_off;
11686 else if (toc_off != htab->stub_group[i->id].toc_off)
11687 return FALSE;
11688 }
11689
11690 if (toc_off == 0)
11691 for (i = o->map_head.s; i != NULL; i = i->map_head.s)
11692 if (i->makes_toc_func_call)
11693 {
11694 toc_off = htab->stub_group[i->id].toc_off;
11695 break;
11696 }
11697
11698 /* Make sure the whole pasted function uses the same toc offset. */
11699 if (toc_off != 0)
11700 for (i = o->map_head.s; i != NULL; i = i->map_head.s)
11701 htab->stub_group[i->id].toc_off = toc_off;
11702 }
11703 return TRUE;
11704 }
11705
11706 bfd_boolean
11707 ppc64_elf_check_init_fini (struct bfd_link_info *info)
11708 {
11709 return (check_pasted_section (info, ".init")
11710 & check_pasted_section (info, ".fini"));
11711 }
11712
11713 /* See whether we can group stub sections together. Grouping stub
11714 sections may result in fewer stubs. More importantly, we need to
11715 put all .init* and .fini* stubs at the beginning of the .init or
11716 .fini output sections respectively, because glibc splits the
11717 _init and _fini functions into multiple parts. Putting a stub in
11718 the middle of a function is not a good idea. */
11719
11720 static void
11721 group_sections (struct ppc_link_hash_table *htab,
11722 bfd_size_type stub_group_size,
11723 bfd_boolean stubs_always_before_branch)
11724 {
11725 asection **list;
11726 bfd_size_type stub14_group_size;
11727 bfd_boolean suppress_size_errors;
11728
11729 suppress_size_errors = FALSE;
11730 stub14_group_size = stub_group_size;
11731 if (stub_group_size == 1)
11732 {
11733 /* Default values. */
11734 if (stubs_always_before_branch)
11735 {
11736 stub_group_size = 0x1e00000;
11737 stub14_group_size = 0x7800;
11738 }
11739 else
11740 {
11741 stub_group_size = 0x1c00000;
11742 stub14_group_size = 0x7000;
11743 }
11744 suppress_size_errors = TRUE;
11745 }
11746
11747 list = htab->input_list + htab->top_index;
11748 do
11749 {
11750 asection *tail = *list;
11751 while (tail != NULL)
11752 {
11753 asection *curr;
11754 asection *prev;
11755 bfd_size_type total;
11756 bfd_boolean big_sec;
11757 bfd_vma curr_toc;
11758
11759 curr = tail;
11760 total = tail->size;
11761 big_sec = total > (ppc64_elf_section_data (tail) != NULL
11762 && ppc64_elf_section_data (tail)->has_14bit_branch
11763 ? stub14_group_size : stub_group_size);
11764 if (big_sec && !suppress_size_errors)
11765 (*_bfd_error_handler) (_("%B section %A exceeds stub group size"),
11766 tail->owner, tail);
11767 curr_toc = htab->stub_group[tail->id].toc_off;
11768
11769 while ((prev = PREV_SEC (curr)) != NULL
11770 && ((total += curr->output_offset - prev->output_offset)
11771 < (ppc64_elf_section_data (prev) != NULL
11772 && ppc64_elf_section_data (prev)->has_14bit_branch
11773 ? stub14_group_size : stub_group_size))
11774 && htab->stub_group[prev->id].toc_off == curr_toc)
11775 curr = prev;
11776
11777 /* OK, the size from the start of CURR to the end is less
11778 than stub_group_size and thus can be handled by one stub
11779 section. (or the tail section is itself larger than
11780 stub_group_size, in which case we may be toast.) We
11781 should really be keeping track of the total size of stubs
11782 added here, as stubs contribute to the final output
11783 section size. That's a little tricky, and this way will
11784 only break if stubs added make the total size more than
11785 2^25, ie. for the default stub_group_size, if stubs total
11786 more than 2097152 bytes, or nearly 75000 plt call stubs. */
11787 do
11788 {
11789 prev = PREV_SEC (tail);
11790 /* Set up this stub group. */
11791 htab->stub_group[tail->id].link_sec = curr;
11792 }
11793 while (tail != curr && (tail = prev) != NULL);
11794
11795 /* But wait, there's more! Input sections up to stub_group_size
11796 bytes before the stub section can be handled by it too.
11797 Don't do this if we have a really large section after the
11798 stubs, as adding more stubs increases the chance that
11799 branches may not reach into the stub section. */
11800 if (!stubs_always_before_branch && !big_sec)
11801 {
11802 total = 0;
11803 while (prev != NULL
11804 && ((total += tail->output_offset - prev->output_offset)
11805 < (ppc64_elf_section_data (prev) != NULL
11806 && ppc64_elf_section_data (prev)->has_14bit_branch
11807 ? stub14_group_size : stub_group_size))
11808 && htab->stub_group[prev->id].toc_off == curr_toc)
11809 {
11810 tail = prev;
11811 prev = PREV_SEC (tail);
11812 htab->stub_group[tail->id].link_sec = curr;
11813 }
11814 }
11815 tail = prev;
11816 }
11817 }
11818 while (list-- != htab->input_list);
11819 free (htab->input_list);
11820 #undef PREV_SEC
11821 }
11822
11823 static const unsigned char glink_eh_frame_cie[] =
11824 {
11825 0, 0, 0, 16, /* length. */
11826 0, 0, 0, 0, /* id. */
11827 1, /* CIE version. */
11828 'z', 'R', 0, /* Augmentation string. */
11829 4, /* Code alignment. */
11830 0x78, /* Data alignment. */
11831 65, /* RA reg. */
11832 1, /* Augmentation size. */
11833 DW_EH_PE_pcrel | DW_EH_PE_sdata4, /* FDE encoding. */
11834 DW_CFA_def_cfa, 1, 0 /* def_cfa: r1 offset 0. */
11835 };
11836
11837 /* Stripping output sections is normally done before dynamic section
11838 symbols have been allocated. This function is called later, and
11839 handles cases like htab->brlt which is mapped to its own output
11840 section. */
11841
11842 static void
11843 maybe_strip_output (struct bfd_link_info *info, asection *isec)
11844 {
11845 if (isec->size == 0
11846 && isec->output_section->size == 0
11847 && !(isec->output_section->flags & SEC_KEEP)
11848 && !bfd_section_removed_from_list (info->output_bfd,
11849 isec->output_section)
11850 && elf_section_data (isec->output_section)->dynindx == 0)
11851 {
11852 isec->output_section->flags |= SEC_EXCLUDE;
11853 bfd_section_list_remove (info->output_bfd, isec->output_section);
11854 info->output_bfd->section_count--;
11855 }
11856 }
11857
11858 /* Determine and set the size of the stub section for a final link.
11859
11860 The basic idea here is to examine all the relocations looking for
11861 PC-relative calls to a target that is unreachable with a "bl"
11862 instruction. */
11863
11864 bfd_boolean
11865 ppc64_elf_size_stubs (struct bfd_link_info *info)
11866 {
11867 bfd_size_type stub_group_size;
11868 bfd_boolean stubs_always_before_branch;
11869 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11870
11871 if (htab == NULL)
11872 return FALSE;
11873
11874 if (htab->params->plt_thread_safe == -1 && !info->executable)
11875 htab->params->plt_thread_safe = 1;
11876 if (!htab->opd_abi)
11877 htab->params->plt_thread_safe = 0;
11878 else if (htab->params->plt_thread_safe == -1)
11879 {
11880 static const char *const thread_starter[] =
11881 {
11882 "pthread_create",
11883 /* libstdc++ */
11884 "_ZNSt6thread15_M_start_threadESt10shared_ptrINS_10_Impl_baseEE",
11885 /* librt */
11886 "aio_init", "aio_read", "aio_write", "aio_fsync", "lio_listio",
11887 "mq_notify", "create_timer",
11888 /* libanl */
11889 "getaddrinfo_a",
11890 /* libgomp */
11891 "GOMP_parallel_start",
11892 "GOMP_parallel_loop_static_start",
11893 "GOMP_parallel_loop_dynamic_start",
11894 "GOMP_parallel_loop_guided_start",
11895 "GOMP_parallel_loop_runtime_start",
11896 "GOMP_parallel_sections_start",
11897 };
11898 unsigned i;
11899
11900 for (i = 0; i < sizeof (thread_starter)/ sizeof (thread_starter[0]); i++)
11901 {
11902 struct elf_link_hash_entry *h;
11903 h = elf_link_hash_lookup (&htab->elf, thread_starter[i],
11904 FALSE, FALSE, TRUE);
11905 htab->params->plt_thread_safe = h != NULL && h->ref_regular;
11906 if (htab->params->plt_thread_safe)
11907 break;
11908 }
11909 }
11910 stubs_always_before_branch = htab->params->group_size < 0;
11911 if (htab->params->group_size < 0)
11912 stub_group_size = -htab->params->group_size;
11913 else
11914 stub_group_size = htab->params->group_size;
11915
11916 group_sections (htab, stub_group_size, stubs_always_before_branch);
11917
11918 while (1)
11919 {
11920 bfd *input_bfd;
11921 unsigned int bfd_indx;
11922 asection *stub_sec;
11923
11924 htab->stub_iteration += 1;
11925
11926 for (input_bfd = info->input_bfds, bfd_indx = 0;
11927 input_bfd != NULL;
11928 input_bfd = input_bfd->link_next, bfd_indx++)
11929 {
11930 Elf_Internal_Shdr *symtab_hdr;
11931 asection *section;
11932 Elf_Internal_Sym *local_syms = NULL;
11933
11934 if (!is_ppc64_elf (input_bfd))
11935 continue;
11936
11937 /* We'll need the symbol table in a second. */
11938 symtab_hdr = &elf_symtab_hdr (input_bfd);
11939 if (symtab_hdr->sh_info == 0)
11940 continue;
11941
11942 /* Walk over each section attached to the input bfd. */
11943 for (section = input_bfd->sections;
11944 section != NULL;
11945 section = section->next)
11946 {
11947 Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
11948
11949 /* If there aren't any relocs, then there's nothing more
11950 to do. */
11951 if ((section->flags & SEC_RELOC) == 0
11952 || (section->flags & SEC_ALLOC) == 0
11953 || (section->flags & SEC_LOAD) == 0
11954 || (section->flags & SEC_CODE) == 0
11955 || section->reloc_count == 0)
11956 continue;
11957
11958 /* If this section is a link-once section that will be
11959 discarded, then don't create any stubs. */
11960 if (section->output_section == NULL
11961 || section->output_section->owner != info->output_bfd)
11962 continue;
11963
11964 /* Get the relocs. */
11965 internal_relocs
11966 = _bfd_elf_link_read_relocs (input_bfd, section, NULL, NULL,
11967 info->keep_memory);
11968 if (internal_relocs == NULL)
11969 goto error_ret_free_local;
11970
11971 /* Now examine each relocation. */
11972 irela = internal_relocs;
11973 irelaend = irela + section->reloc_count;
11974 for (; irela < irelaend; irela++)
11975 {
11976 enum elf_ppc64_reloc_type r_type;
11977 unsigned int r_indx;
11978 enum ppc_stub_type stub_type;
11979 struct ppc_stub_hash_entry *stub_entry;
11980 asection *sym_sec, *code_sec;
11981 bfd_vma sym_value, code_value;
11982 bfd_vma destination;
11983 unsigned long local_off;
11984 bfd_boolean ok_dest;
11985 struct ppc_link_hash_entry *hash;
11986 struct ppc_link_hash_entry *fdh;
11987 struct elf_link_hash_entry *h;
11988 Elf_Internal_Sym *sym;
11989 char *stub_name;
11990 const asection *id_sec;
11991 struct _opd_sec_data *opd;
11992 struct plt_entry *plt_ent;
11993
11994 r_type = ELF64_R_TYPE (irela->r_info);
11995 r_indx = ELF64_R_SYM (irela->r_info);
11996
11997 if (r_type >= R_PPC64_max)
11998 {
11999 bfd_set_error (bfd_error_bad_value);
12000 goto error_ret_free_internal;
12001 }
12002
12003 /* Only look for stubs on branch instructions. */
12004 if (r_type != R_PPC64_REL24
12005 && r_type != R_PPC64_REL14
12006 && r_type != R_PPC64_REL14_BRTAKEN
12007 && r_type != R_PPC64_REL14_BRNTAKEN)
12008 continue;
12009
12010 /* Now determine the call target, its name, value,
12011 section. */
12012 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
12013 r_indx, input_bfd))
12014 goto error_ret_free_internal;
12015 hash = (struct ppc_link_hash_entry *) h;
12016
12017 ok_dest = FALSE;
12018 fdh = NULL;
12019 sym_value = 0;
12020 if (hash == NULL)
12021 {
12022 sym_value = sym->st_value;
12023 ok_dest = TRUE;
12024 }
12025 else if (hash->elf.root.type == bfd_link_hash_defined
12026 || hash->elf.root.type == bfd_link_hash_defweak)
12027 {
12028 sym_value = hash->elf.root.u.def.value;
12029 if (sym_sec->output_section != NULL)
12030 ok_dest = TRUE;
12031 }
12032 else if (hash->elf.root.type == bfd_link_hash_undefweak
12033 || hash->elf.root.type == bfd_link_hash_undefined)
12034 {
12035 /* Recognise an old ABI func code entry sym, and
12036 use the func descriptor sym instead if it is
12037 defined. */
12038 if (hash->elf.root.root.string[0] == '.'
12039 && (fdh = lookup_fdh (hash, htab)) != NULL)
12040 {
12041 if (fdh->elf.root.type == bfd_link_hash_defined
12042 || fdh->elf.root.type == bfd_link_hash_defweak)
12043 {
12044 sym_sec = fdh->elf.root.u.def.section;
12045 sym_value = fdh->elf.root.u.def.value;
12046 if (sym_sec->output_section != NULL)
12047 ok_dest = TRUE;
12048 }
12049 else
12050 fdh = NULL;
12051 }
12052 }
12053 else
12054 {
12055 bfd_set_error (bfd_error_bad_value);
12056 goto error_ret_free_internal;
12057 }
12058
12059 destination = 0;
12060 local_off = 0;
12061 if (ok_dest)
12062 {
12063 sym_value += irela->r_addend;
12064 destination = (sym_value
12065 + sym_sec->output_offset
12066 + sym_sec->output_section->vma);
12067 local_off = PPC64_LOCAL_ENTRY_OFFSET (hash
12068 ? hash->elf.other
12069 : sym->st_other);
12070 }
12071
12072 code_sec = sym_sec;
12073 code_value = sym_value;
12074 opd = get_opd_info (sym_sec);
12075 if (opd != NULL)
12076 {
12077 bfd_vma dest;
12078
12079 if (hash == NULL && opd->adjust != NULL)
12080 {
12081 long adjust = opd->adjust[sym_value / 8];
12082 if (adjust == -1)
12083 continue;
12084 code_value += adjust;
12085 sym_value += adjust;
12086 }
12087 dest = opd_entry_value (sym_sec, sym_value,
12088 &code_sec, &code_value, FALSE);
12089 if (dest != (bfd_vma) -1)
12090 {
12091 destination = dest;
12092 if (fdh != NULL)
12093 {
12094 /* Fixup old ABI sym to point at code
12095 entry. */
12096 hash->elf.root.type = bfd_link_hash_defweak;
12097 hash->elf.root.u.def.section = code_sec;
12098 hash->elf.root.u.def.value = code_value;
12099 }
12100 }
12101 }
12102
12103 /* Determine what (if any) linker stub is needed. */
12104 plt_ent = NULL;
12105 stub_type = ppc_type_of_stub (section, irela, &hash,
12106 &plt_ent, destination,
12107 local_off);
12108
12109 if (stub_type != ppc_stub_plt_call)
12110 {
12111 /* Check whether we need a TOC adjusting stub.
12112 Since the linker pastes together pieces from
12113 different object files when creating the
12114 _init and _fini functions, it may be that a
12115 call to what looks like a local sym is in
12116 fact a call needing a TOC adjustment. */
12117 if (code_sec != NULL
12118 && code_sec->output_section != NULL
12119 && (htab->stub_group[code_sec->id].toc_off
12120 != htab->stub_group[section->id].toc_off)
12121 && (code_sec->has_toc_reloc
12122 || code_sec->makes_toc_func_call))
12123 stub_type = ppc_stub_long_branch_r2off;
12124 }
12125
12126 if (stub_type == ppc_stub_none)
12127 continue;
12128
12129 /* __tls_get_addr calls might be eliminated. */
12130 if (stub_type != ppc_stub_plt_call
12131 && hash != NULL
12132 && (hash == htab->tls_get_addr
12133 || hash == htab->tls_get_addr_fd)
12134 && section->has_tls_reloc
12135 && irela != internal_relocs)
12136 {
12137 /* Get tls info. */
12138 unsigned char *tls_mask;
12139
12140 if (!get_tls_mask (&tls_mask, NULL, NULL, &local_syms,
12141 irela - 1, input_bfd))
12142 goto error_ret_free_internal;
12143 if (*tls_mask != 0)
12144 continue;
12145 }
12146
12147 if (stub_type == ppc_stub_plt_call
12148 && irela + 1 < irelaend
12149 && irela[1].r_offset == irela->r_offset + 4
12150 && ELF64_R_TYPE (irela[1].r_info) == R_PPC64_TOCSAVE)
12151 {
12152 if (!tocsave_find (htab, INSERT,
12153 &local_syms, irela + 1, input_bfd))
12154 goto error_ret_free_internal;
12155 }
12156 else if (stub_type == ppc_stub_plt_call)
12157 stub_type = ppc_stub_plt_call_r2save;
12158
12159 /* Support for grouping stub sections. */
12160 id_sec = htab->stub_group[section->id].link_sec;
12161
12162 /* Get the name of this stub. */
12163 stub_name = ppc_stub_name (id_sec, sym_sec, hash, irela);
12164 if (!stub_name)
12165 goto error_ret_free_internal;
12166
12167 stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
12168 stub_name, FALSE, FALSE);
12169 if (stub_entry != NULL)
12170 {
12171 /* The proper stub has already been created. */
12172 free (stub_name);
12173 if (stub_type == ppc_stub_plt_call_r2save)
12174 stub_entry->stub_type = stub_type;
12175 continue;
12176 }
12177
12178 stub_entry = ppc_add_stub (stub_name, section, info);
12179 if (stub_entry == NULL)
12180 {
12181 free (stub_name);
12182 error_ret_free_internal:
12183 if (elf_section_data (section)->relocs == NULL)
12184 free (internal_relocs);
12185 error_ret_free_local:
12186 if (local_syms != NULL
12187 && (symtab_hdr->contents
12188 != (unsigned char *) local_syms))
12189 free (local_syms);
12190 return FALSE;
12191 }
12192
12193 stub_entry->stub_type = stub_type;
12194 if (stub_type != ppc_stub_plt_call
12195 && stub_type != ppc_stub_plt_call_r2save)
12196 {
12197 stub_entry->target_value = code_value;
12198 stub_entry->target_section = code_sec;
12199 }
12200 else
12201 {
12202 stub_entry->target_value = sym_value;
12203 stub_entry->target_section = sym_sec;
12204 }
12205 stub_entry->h = hash;
12206 stub_entry->plt_ent = plt_ent;
12207 stub_entry->other = hash ? hash->elf.other : sym->st_other;
12208
12209 if (stub_entry->h != NULL)
12210 htab->stub_globals += 1;
12211 }
12212
12213 /* We're done with the internal relocs, free them. */
12214 if (elf_section_data (section)->relocs != internal_relocs)
12215 free (internal_relocs);
12216 }
12217
12218 if (local_syms != NULL
12219 && symtab_hdr->contents != (unsigned char *) local_syms)
12220 {
12221 if (!info->keep_memory)
12222 free (local_syms);
12223 else
12224 symtab_hdr->contents = (unsigned char *) local_syms;
12225 }
12226 }
12227
12228 /* We may have added some stubs. Find out the new size of the
12229 stub sections. */
12230 for (stub_sec = htab->params->stub_bfd->sections;
12231 stub_sec != NULL;
12232 stub_sec = stub_sec->next)
12233 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12234 {
12235 stub_sec->rawsize = stub_sec->size;
12236 stub_sec->size = 0;
12237 stub_sec->reloc_count = 0;
12238 stub_sec->flags &= ~SEC_RELOC;
12239 }
12240
12241 htab->brlt->size = 0;
12242 htab->brlt->reloc_count = 0;
12243 htab->brlt->flags &= ~SEC_RELOC;
12244 if (htab->relbrlt != NULL)
12245 htab->relbrlt->size = 0;
12246
12247 bfd_hash_traverse (&htab->stub_hash_table, ppc_size_one_stub, info);
12248
12249 if (info->emitrelocations
12250 && htab->glink != NULL && htab->glink->size != 0)
12251 {
12252 htab->glink->reloc_count = 1;
12253 htab->glink->flags |= SEC_RELOC;
12254 }
12255
12256 if (htab->glink_eh_frame != NULL
12257 && !bfd_is_abs_section (htab->glink_eh_frame->output_section)
12258 && htab->glink_eh_frame->output_section->size != 0)
12259 {
12260 size_t size = 0, align;
12261
12262 for (stub_sec = htab->params->stub_bfd->sections;
12263 stub_sec != NULL;
12264 stub_sec = stub_sec->next)
12265 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12266 size += 20;
12267 if (htab->glink != NULL && htab->glink->size != 0)
12268 size += 24;
12269 if (size != 0)
12270 size += sizeof (glink_eh_frame_cie);
12271 align = 1;
12272 align <<= htab->glink_eh_frame->output_section->alignment_power;
12273 align -= 1;
12274 size = (size + align) & ~align;
12275 htab->glink_eh_frame->rawsize = htab->glink_eh_frame->size;
12276 htab->glink_eh_frame->size = size;
12277 }
12278
12279 if (htab->params->plt_stub_align != 0)
12280 for (stub_sec = htab->params->stub_bfd->sections;
12281 stub_sec != NULL;
12282 stub_sec = stub_sec->next)
12283 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12284 stub_sec->size = ((stub_sec->size
12285 + (1 << htab->params->plt_stub_align) - 1)
12286 & (-1 << htab->params->plt_stub_align));
12287
12288 for (stub_sec = htab->params->stub_bfd->sections;
12289 stub_sec != NULL;
12290 stub_sec = stub_sec->next)
12291 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
12292 && stub_sec->rawsize != stub_sec->size)
12293 break;
12294
12295 /* Exit from this loop when no stubs have been added, and no stubs
12296 have changed size. */
12297 if (stub_sec == NULL
12298 && (htab->glink_eh_frame == NULL
12299 || htab->glink_eh_frame->rawsize == htab->glink_eh_frame->size))
12300 break;
12301
12302 /* Ask the linker to do its stuff. */
12303 (*htab->params->layout_sections_again) ();
12304 }
12305
12306 maybe_strip_output (info, htab->brlt);
12307 if (htab->glink_eh_frame != NULL)
12308 maybe_strip_output (info, htab->glink_eh_frame);
12309
12310 return TRUE;
12311 }
12312
12313 /* Called after we have determined section placement. If sections
12314 move, we'll be called again. Provide a value for TOCstart. */
12315
12316 bfd_vma
12317 ppc64_elf_set_toc (struct bfd_link_info *info, bfd *obfd)
12318 {
12319 asection *s;
12320 bfd_vma TOCstart;
12321
12322 /* The TOC consists of sections .got, .toc, .tocbss, .plt in that
12323 order. The TOC starts where the first of these sections starts. */
12324 s = bfd_get_section_by_name (obfd, ".got");
12325 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12326 s = bfd_get_section_by_name (obfd, ".toc");
12327 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12328 s = bfd_get_section_by_name (obfd, ".tocbss");
12329 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12330 s = bfd_get_section_by_name (obfd, ".plt");
12331 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
12332 {
12333 /* This may happen for
12334 o references to TOC base (SYM@toc / TOC[tc0]) without a
12335 .toc directive
12336 o bad linker script
12337 o --gc-sections and empty TOC sections
12338
12339 FIXME: Warn user? */
12340
12341 /* Look for a likely section. We probably won't even be
12342 using TOCstart. */
12343 for (s = obfd->sections; s != NULL; s = s->next)
12344 if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_READONLY
12345 | SEC_EXCLUDE))
12346 == (SEC_ALLOC | SEC_SMALL_DATA))
12347 break;
12348 if (s == NULL)
12349 for (s = obfd->sections; s != NULL; s = s->next)
12350 if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_EXCLUDE))
12351 == (SEC_ALLOC | SEC_SMALL_DATA))
12352 break;
12353 if (s == NULL)
12354 for (s = obfd->sections; s != NULL; s = s->next)
12355 if ((s->flags & (SEC_ALLOC | SEC_READONLY | SEC_EXCLUDE))
12356 == SEC_ALLOC)
12357 break;
12358 if (s == NULL)
12359 for (s = obfd->sections; s != NULL; s = s->next)
12360 if ((s->flags & (SEC_ALLOC | SEC_EXCLUDE)) == SEC_ALLOC)
12361 break;
12362 }
12363
12364 TOCstart = 0;
12365 if (s != NULL)
12366 TOCstart = s->output_section->vma + s->output_offset;
12367
12368 _bfd_set_gp_value (obfd, TOCstart);
12369
12370 if (info != NULL && s != NULL && is_ppc64_elf (obfd))
12371 {
12372 struct ppc_link_hash_table *htab = ppc_hash_table (info);
12373
12374 if (htab != NULL
12375 && htab->elf.hgot != NULL)
12376 {
12377 htab->elf.hgot->root.u.def.value = TOC_BASE_OFF;
12378 htab->elf.hgot->root.u.def.section = s;
12379 }
12380 }
12381 return TOCstart;
12382 }
12383
12384 /* Called via elf_link_hash_traverse from ppc64_elf_build_stubs to
12385 write out any global entry stubs. */
12386
12387 static bfd_boolean
12388 build_global_entry_stubs (struct elf_link_hash_entry *h, void *inf)
12389 {
12390 struct bfd_link_info *info;
12391 struct ppc_link_hash_table *htab;
12392 struct plt_entry *pent;
12393 asection *s;
12394
12395 if (h->root.type == bfd_link_hash_indirect)
12396 return TRUE;
12397
12398 if (!h->pointer_equality_needed)
12399 return TRUE;
12400
12401 if (h->def_regular)
12402 return TRUE;
12403
12404 info = inf;
12405 htab = ppc_hash_table (info);
12406 if (htab == NULL)
12407 return FALSE;
12408
12409 s = htab->glink;
12410 for (pent = h->plt.plist; pent != NULL; pent = pent->next)
12411 if (pent->plt.offset != (bfd_vma) -1
12412 && pent->addend == 0)
12413 {
12414 bfd_byte *p;
12415 asection *plt;
12416 bfd_vma off;
12417
12418 p = s->contents + h->root.u.def.value;
12419 plt = htab->elf.splt;
12420 if (!htab->elf.dynamic_sections_created
12421 || h->dynindx == -1)
12422 plt = htab->elf.iplt;
12423 off = pent->plt.offset + plt->output_offset + plt->output_section->vma;
12424 off -= h->root.u.def.value + s->output_offset + s->output_section->vma;
12425
12426 if (off + 0x80008000 > 0xffffffff || (off & 3) != 0)
12427 {
12428 info->callbacks->einfo
12429 (_("%P: linkage table error against `%T'\n"),
12430 h->root.root.string);
12431 bfd_set_error (bfd_error_bad_value);
12432 htab->stub_error = TRUE;
12433 }
12434
12435 if (PPC_HA (off) != 0)
12436 {
12437 bfd_put_32 (s->owner, ADDIS_R12_R12 | PPC_HA (off), p);
12438 p += 4;
12439 }
12440 bfd_put_32 (s->owner, LD_R12_0R12 | PPC_LO (off), p);
12441 p += 4;
12442 bfd_put_32 (s->owner, MTCTR_R12, p);
12443 p += 4;
12444 bfd_put_32 (s->owner, BCTR, p);
12445 break;
12446 }
12447 return TRUE;
12448 }
12449
12450 /* Build all the stubs associated with the current output file.
12451 The stubs are kept in a hash table attached to the main linker
12452 hash table. This function is called via gldelf64ppc_finish. */
12453
12454 bfd_boolean
12455 ppc64_elf_build_stubs (struct bfd_link_info *info,
12456 char **stats)
12457 {
12458 struct ppc_link_hash_table *htab = ppc_hash_table (info);
12459 asection *stub_sec;
12460 bfd_byte *p;
12461 int stub_sec_count = 0;
12462
12463 if (htab == NULL)
12464 return FALSE;
12465
12466 /* Allocate memory to hold the linker stubs. */
12467 for (stub_sec = htab->params->stub_bfd->sections;
12468 stub_sec != NULL;
12469 stub_sec = stub_sec->next)
12470 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
12471 && stub_sec->size != 0)
12472 {
12473 stub_sec->contents = bfd_zalloc (htab->params->stub_bfd, stub_sec->size);
12474 if (stub_sec->contents == NULL)
12475 return FALSE;
12476 /* We want to check that built size is the same as calculated
12477 size. rawsize is a convenient location to use. */
12478 stub_sec->rawsize = stub_sec->size;
12479 stub_sec->size = 0;
12480 }
12481
12482 if (htab->glink != NULL && htab->glink->size != 0)
12483 {
12484 unsigned int indx;
12485 bfd_vma plt0;
12486
12487 /* Build the .glink plt call stub. */
12488 if (htab->params->emit_stub_syms)
12489 {
12490 struct elf_link_hash_entry *h;
12491 h = elf_link_hash_lookup (&htab->elf, "__glink_PLTresolve",
12492 TRUE, FALSE, FALSE);
12493 if (h == NULL)
12494 return FALSE;
12495 if (h->root.type == bfd_link_hash_new)
12496 {
12497 h->root.type = bfd_link_hash_defined;
12498 h->root.u.def.section = htab->glink;
12499 h->root.u.def.value = 8;
12500 h->ref_regular = 1;
12501 h->def_regular = 1;
12502 h->ref_regular_nonweak = 1;
12503 h->forced_local = 1;
12504 h->non_elf = 0;
12505 }
12506 }
12507 plt0 = (htab->elf.splt->output_section->vma
12508 + htab->elf.splt->output_offset
12509 - 16);
12510 if (info->emitrelocations)
12511 {
12512 Elf_Internal_Rela *r = get_relocs (htab->glink, 1);
12513 if (r == NULL)
12514 return FALSE;
12515 r->r_offset = (htab->glink->output_offset
12516 + htab->glink->output_section->vma);
12517 r->r_info = ELF64_R_INFO (0, R_PPC64_REL64);
12518 r->r_addend = plt0;
12519 }
12520 p = htab->glink->contents;
12521 plt0 -= htab->glink->output_section->vma + htab->glink->output_offset;
12522 bfd_put_64 (htab->glink->owner, plt0, p);
12523 p += 8;
12524 if (htab->opd_abi)
12525 {
12526 bfd_put_32 (htab->glink->owner, MFLR_R12, p);
12527 p += 4;
12528 bfd_put_32 (htab->glink->owner, BCL_20_31, p);
12529 p += 4;
12530 bfd_put_32 (htab->glink->owner, MFLR_R11, p);
12531 p += 4;
12532 bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
12533 p += 4;
12534 bfd_put_32 (htab->glink->owner, MTLR_R12, p);
12535 p += 4;
12536 bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
12537 p += 4;
12538 bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
12539 p += 4;
12540 bfd_put_32 (htab->glink->owner, LD_R2_0R11 | 8, p);
12541 p += 4;
12542 bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
12543 p += 4;
12544 bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 16, p);
12545 p += 4;
12546 }
12547 else
12548 {
12549 bfd_put_32 (htab->glink->owner, MFLR_R0, p);
12550 p += 4;
12551 bfd_put_32 (htab->glink->owner, BCL_20_31, p);
12552 p += 4;
12553 bfd_put_32 (htab->glink->owner, MFLR_R11, p);
12554 p += 4;
12555 bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
12556 p += 4;
12557 bfd_put_32 (htab->glink->owner, MTLR_R0, p);
12558 p += 4;
12559 bfd_put_32 (htab->glink->owner, SUB_R12_R12_R11, p);
12560 p += 4;
12561 bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
12562 p += 4;
12563 bfd_put_32 (htab->glink->owner, ADDI_R0_R12 | (-48 & 0xffff), p);
12564 p += 4;
12565 bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
12566 p += 4;
12567 bfd_put_32 (htab->glink->owner, SRDI_R0_R0_2, p);
12568 p += 4;
12569 bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
12570 p += 4;
12571 bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 8, p);
12572 p += 4;
12573 }
12574 bfd_put_32 (htab->glink->owner, BCTR, p);
12575 p += 4;
12576 while (p - htab->glink->contents < GLINK_CALL_STUB_SIZE)
12577 {
12578 bfd_put_32 (htab->glink->owner, NOP, p);
12579 p += 4;
12580 }
12581
12582 /* Build the .glink lazy link call stubs. */
12583 indx = 0;
12584 while (p < htab->glink->contents + htab->glink->rawsize)
12585 {
12586 if (htab->opd_abi)
12587 {
12588 if (indx < 0x8000)
12589 {
12590 bfd_put_32 (htab->glink->owner, LI_R0_0 | indx, p);
12591 p += 4;
12592 }
12593 else
12594 {
12595 bfd_put_32 (htab->glink->owner, LIS_R0_0 | PPC_HI (indx), p);
12596 p += 4;
12597 bfd_put_32 (htab->glink->owner, ORI_R0_R0_0 | PPC_LO (indx),
12598 p);
12599 p += 4;
12600 }
12601 }
12602 bfd_put_32 (htab->glink->owner,
12603 B_DOT | ((htab->glink->contents - p + 8) & 0x3fffffc), p);
12604 indx++;
12605 p += 4;
12606 }
12607
12608 /* Build .glink global entry stubs. */
12609 if (htab->glink->size > htab->glink->rawsize)
12610 elf_link_hash_traverse (&htab->elf, build_global_entry_stubs, info);
12611 }
12612
12613 if (htab->brlt->size != 0)
12614 {
12615 htab->brlt->contents = bfd_zalloc (htab->brlt->owner,
12616 htab->brlt->size);
12617 if (htab->brlt->contents == NULL)
12618 return FALSE;
12619 }
12620 if (htab->relbrlt != NULL && htab->relbrlt->size != 0)
12621 {
12622 htab->relbrlt->contents = bfd_zalloc (htab->relbrlt->owner,
12623 htab->relbrlt->size);
12624 if (htab->relbrlt->contents == NULL)
12625 return FALSE;
12626 }
12627
12628 if (htab->glink_eh_frame != NULL
12629 && htab->glink_eh_frame->size != 0)
12630 {
12631 bfd_vma val;
12632 bfd_byte *last_fde;
12633 size_t last_fde_len, size, align, pad;
12634
12635 p = bfd_zalloc (htab->glink_eh_frame->owner, htab->glink_eh_frame->size);
12636 if (p == NULL)
12637 return FALSE;
12638 htab->glink_eh_frame->contents = p;
12639 last_fde = p;
12640
12641 htab->glink_eh_frame->rawsize = htab->glink_eh_frame->size;
12642
12643 memcpy (p, glink_eh_frame_cie, sizeof (glink_eh_frame_cie));
12644 /* CIE length (rewrite in case little-endian). */
12645 last_fde_len = sizeof (glink_eh_frame_cie) - 4;
12646 bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
12647 p += sizeof (glink_eh_frame_cie);
12648
12649 for (stub_sec = htab->params->stub_bfd->sections;
12650 stub_sec != NULL;
12651 stub_sec = stub_sec->next)
12652 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12653 {
12654 last_fde = p;
12655 last_fde_len = 16;
12656 /* FDE length. */
12657 bfd_put_32 (htab->elf.dynobj, 16, p);
12658 p += 4;
12659 /* CIE pointer. */
12660 val = p - htab->glink_eh_frame->contents;
12661 bfd_put_32 (htab->elf.dynobj, val, p);
12662 p += 4;
12663 /* Offset to stub section. */
12664 val = (stub_sec->output_section->vma
12665 + stub_sec->output_offset);
12666 val -= (htab->glink_eh_frame->output_section->vma
12667 + htab->glink_eh_frame->output_offset);
12668 val -= p - htab->glink_eh_frame->contents;
12669 if (val + 0x80000000 > 0xffffffff)
12670 {
12671 info->callbacks->einfo
12672 (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
12673 stub_sec->name);
12674 return FALSE;
12675 }
12676 bfd_put_32 (htab->elf.dynobj, val, p);
12677 p += 4;
12678 /* stub section size. */
12679 bfd_put_32 (htab->elf.dynobj, stub_sec->rawsize, p);
12680 p += 4;
12681 /* Augmentation. */
12682 p += 1;
12683 /* Pad. */
12684 p += 3;
12685 }
12686 if (htab->glink != NULL && htab->glink->size != 0)
12687 {
12688 last_fde = p;
12689 last_fde_len = 20;
12690 /* FDE length. */
12691 bfd_put_32 (htab->elf.dynobj, 20, p);
12692 p += 4;
12693 /* CIE pointer. */
12694 val = p - htab->glink_eh_frame->contents;
12695 bfd_put_32 (htab->elf.dynobj, val, p);
12696 p += 4;
12697 /* Offset to .glink. */
12698 val = (htab->glink->output_section->vma
12699 + htab->glink->output_offset
12700 + 8);
12701 val -= (htab->glink_eh_frame->output_section->vma
12702 + htab->glink_eh_frame->output_offset);
12703 val -= p - htab->glink_eh_frame->contents;
12704 if (val + 0x80000000 > 0xffffffff)
12705 {
12706 info->callbacks->einfo
12707 (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
12708 htab->glink->name);
12709 return FALSE;
12710 }
12711 bfd_put_32 (htab->elf.dynobj, val, p);
12712 p += 4;
12713 /* .glink size. */
12714 bfd_put_32 (htab->elf.dynobj, htab->glink->size - 8, p);
12715 p += 4;
12716 /* Augmentation. */
12717 p += 1;
12718
12719 *p++ = DW_CFA_advance_loc + 1;
12720 *p++ = DW_CFA_register;
12721 *p++ = 65;
12722 *p++ = 12;
12723 *p++ = DW_CFA_advance_loc + 4;
12724 *p++ = DW_CFA_restore_extended;
12725 *p++ = 65;
12726 }
12727 /* Subsume any padding into the last FDE if user .eh_frame
12728 sections are aligned more than glink_eh_frame. Otherwise any
12729 zero padding will be seen as a terminator. */
12730 size = p - htab->glink_eh_frame->contents;
12731 align = 1;
12732 align <<= htab->glink_eh_frame->output_section->alignment_power;
12733 align -= 1;
12734 pad = ((size + align) & ~align) - size;
12735 htab->glink_eh_frame->size = size + pad;
12736 bfd_put_32 (htab->elf.dynobj, last_fde_len + pad, last_fde);
12737 }
12738
12739 /* Build the stubs as directed by the stub hash table. */
12740 bfd_hash_traverse (&htab->stub_hash_table, ppc_build_one_stub, info);
12741
12742 if (htab->relbrlt != NULL)
12743 htab->relbrlt->reloc_count = 0;
12744
12745 if (htab->params->plt_stub_align != 0)
12746 for (stub_sec = htab->params->stub_bfd->sections;
12747 stub_sec != NULL;
12748 stub_sec = stub_sec->next)
12749 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12750 stub_sec->size = ((stub_sec->size
12751 + (1 << htab->params->plt_stub_align) - 1)
12752 & (-1 << htab->params->plt_stub_align));
12753
12754 for (stub_sec = htab->params->stub_bfd->sections;
12755 stub_sec != NULL;
12756 stub_sec = stub_sec->next)
12757 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12758 {
12759 stub_sec_count += 1;
12760 if (stub_sec->rawsize != stub_sec->size)
12761 break;
12762 }
12763
12764 if (stub_sec != NULL
12765 || (htab->glink_eh_frame != NULL
12766 && htab->glink_eh_frame->rawsize != htab->glink_eh_frame->size))
12767 {
12768 htab->stub_error = TRUE;
12769 info->callbacks->einfo (_("%P: stubs don't match calculated size\n"));
12770 }
12771
12772 if (htab->stub_error)
12773 return FALSE;
12774
12775 if (stats != NULL)
12776 {
12777 *stats = bfd_malloc (500);
12778 if (*stats == NULL)
12779 return FALSE;
12780
12781 sprintf (*stats, _("linker stubs in %u group%s\n"
12782 " branch %lu\n"
12783 " toc adjust %lu\n"
12784 " long branch %lu\n"
12785 " long toc adj %lu\n"
12786 " plt call %lu\n"
12787 " plt call toc %lu"),
12788 stub_sec_count,
12789 stub_sec_count == 1 ? "" : "s",
12790 htab->stub_count[ppc_stub_long_branch - 1],
12791 htab->stub_count[ppc_stub_long_branch_r2off - 1],
12792 htab->stub_count[ppc_stub_plt_branch - 1],
12793 htab->stub_count[ppc_stub_plt_branch_r2off - 1],
12794 htab->stub_count[ppc_stub_plt_call - 1],
12795 htab->stub_count[ppc_stub_plt_call_r2save - 1]);
12796 }
12797 return TRUE;
12798 }
12799
12800 /* This function undoes the changes made by add_symbol_adjust. */
12801
12802 static bfd_boolean
12803 undo_symbol_twiddle (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
12804 {
12805 struct ppc_link_hash_entry *eh;
12806
12807 if (h->root.type == bfd_link_hash_indirect)
12808 return TRUE;
12809
12810 eh = (struct ppc_link_hash_entry *) h;
12811 if (eh->elf.root.type != bfd_link_hash_undefweak || !eh->was_undefined)
12812 return TRUE;
12813
12814 eh->elf.root.type = bfd_link_hash_undefined;
12815 return TRUE;
12816 }
12817
12818 void
12819 ppc64_elf_restore_symbols (struct bfd_link_info *info)
12820 {
12821 struct ppc_link_hash_table *htab = ppc_hash_table (info);
12822
12823 if (htab != NULL)
12824 elf_link_hash_traverse (&htab->elf, undo_symbol_twiddle, info);
12825 }
12826
12827 /* What to do when ld finds relocations against symbols defined in
12828 discarded sections. */
12829
12830 static unsigned int
12831 ppc64_elf_action_discarded (asection *sec)
12832 {
12833 if (strcmp (".opd", sec->name) == 0)
12834 return 0;
12835
12836 if (strcmp (".toc", sec->name) == 0)
12837 return 0;
12838
12839 if (strcmp (".toc1", sec->name) == 0)
12840 return 0;
12841
12842 return _bfd_elf_default_action_discarded (sec);
12843 }
12844
12845 /* The RELOCATE_SECTION function is called by the ELF backend linker
12846 to handle the relocations for a section.
12847
12848 The relocs are always passed as Rela structures; if the section
12849 actually uses Rel structures, the r_addend field will always be
12850 zero.
12851
12852 This function is responsible for adjust the section contents as
12853 necessary, and (if using Rela relocs and generating a
12854 relocatable output file) adjusting the reloc addend as
12855 necessary.
12856
12857 This function does not have to worry about setting the reloc
12858 address or the reloc symbol index.
12859
12860 LOCAL_SYMS is a pointer to the swapped in local symbols.
12861
12862 LOCAL_SECTIONS is an array giving the section in the input file
12863 corresponding to the st_shndx field of each local symbol.
12864
12865 The global hash table entry for the global symbols can be found
12866 via elf_sym_hashes (input_bfd).
12867
12868 When generating relocatable output, this function must handle
12869 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
12870 going to be the section symbol corresponding to the output
12871 section, which means that the addend must be adjusted
12872 accordingly. */
12873
12874 static bfd_boolean
12875 ppc64_elf_relocate_section (bfd *output_bfd,
12876 struct bfd_link_info *info,
12877 bfd *input_bfd,
12878 asection *input_section,
12879 bfd_byte *contents,
12880 Elf_Internal_Rela *relocs,
12881 Elf_Internal_Sym *local_syms,
12882 asection **local_sections)
12883 {
12884 struct ppc_link_hash_table *htab;
12885 Elf_Internal_Shdr *symtab_hdr;
12886 struct elf_link_hash_entry **sym_hashes;
12887 Elf_Internal_Rela *rel;
12888 Elf_Internal_Rela *relend;
12889 Elf_Internal_Rela outrel;
12890 bfd_byte *loc;
12891 struct got_entry **local_got_ents;
12892 bfd_vma TOCstart;
12893 bfd_boolean ret = TRUE;
12894 bfd_boolean is_opd;
12895 /* Assume 'at' branch hints. */
12896 bfd_boolean is_isa_v2 = TRUE;
12897 bfd_vma d_offset = (bfd_big_endian (output_bfd) ? 2 : 0);
12898
12899 /* Initialize howto table if needed. */
12900 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
12901 ppc_howto_init ();
12902
12903 htab = ppc_hash_table (info);
12904 if (htab == NULL)
12905 return FALSE;
12906
12907 /* Don't relocate stub sections. */
12908 if (input_section->owner == htab->params->stub_bfd)
12909 return TRUE;
12910
12911 BFD_ASSERT (is_ppc64_elf (input_bfd));
12912
12913 local_got_ents = elf_local_got_ents (input_bfd);
12914 TOCstart = elf_gp (output_bfd);
12915 symtab_hdr = &elf_symtab_hdr (input_bfd);
12916 sym_hashes = elf_sym_hashes (input_bfd);
12917 is_opd = ppc64_elf_section_data (input_section)->sec_type == sec_opd;
12918
12919 rel = relocs;
12920 relend = relocs + input_section->reloc_count;
12921 for (; rel < relend; rel++)
12922 {
12923 enum elf_ppc64_reloc_type r_type;
12924 bfd_vma addend;
12925 bfd_reloc_status_type r;
12926 Elf_Internal_Sym *sym;
12927 asection *sec;
12928 struct elf_link_hash_entry *h_elf;
12929 struct ppc_link_hash_entry *h;
12930 struct ppc_link_hash_entry *fdh;
12931 const char *sym_name;
12932 unsigned long r_symndx, toc_symndx;
12933 bfd_vma toc_addend;
12934 unsigned char tls_mask, tls_gd, tls_type;
12935 unsigned char sym_type;
12936 bfd_vma relocation;
12937 bfd_boolean unresolved_reloc;
12938 bfd_boolean warned;
12939 enum { DEST_NORMAL, DEST_OPD, DEST_STUB } reloc_dest;
12940 unsigned int insn;
12941 unsigned int mask;
12942 struct ppc_stub_hash_entry *stub_entry;
12943 bfd_vma max_br_offset;
12944 bfd_vma from;
12945 const Elf_Internal_Rela orig_rel = *rel;
12946
12947 r_type = ELF64_R_TYPE (rel->r_info);
12948 r_symndx = ELF64_R_SYM (rel->r_info);
12949
12950 /* For old style R_PPC64_TOC relocs with a zero symbol, use the
12951 symbol of the previous ADDR64 reloc. The symbol gives us the
12952 proper TOC base to use. */
12953 if (rel->r_info == ELF64_R_INFO (0, R_PPC64_TOC)
12954 && rel != relocs
12955 && ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_ADDR64
12956 && is_opd)
12957 r_symndx = ELF64_R_SYM (rel[-1].r_info);
12958
12959 sym = NULL;
12960 sec = NULL;
12961 h_elf = NULL;
12962 sym_name = NULL;
12963 unresolved_reloc = FALSE;
12964 warned = FALSE;
12965
12966 if (r_symndx < symtab_hdr->sh_info)
12967 {
12968 /* It's a local symbol. */
12969 struct _opd_sec_data *opd;
12970
12971 sym = local_syms + r_symndx;
12972 sec = local_sections[r_symndx];
12973 sym_name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym, sec);
12974 sym_type = ELF64_ST_TYPE (sym->st_info);
12975 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
12976 opd = get_opd_info (sec);
12977 if (opd != NULL && opd->adjust != NULL)
12978 {
12979 long adjust = opd->adjust[(sym->st_value + rel->r_addend) / 8];
12980 if (adjust == -1)
12981 relocation = 0;
12982 else
12983 {
12984 /* If this is a relocation against the opd section sym
12985 and we have edited .opd, adjust the reloc addend so
12986 that ld -r and ld --emit-relocs output is correct.
12987 If it is a reloc against some other .opd symbol,
12988 then the symbol value will be adjusted later. */
12989 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
12990 rel->r_addend += adjust;
12991 else
12992 relocation += adjust;
12993 }
12994 }
12995 }
12996 else
12997 {
12998 bfd_boolean ignored;
12999
13000 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
13001 r_symndx, symtab_hdr, sym_hashes,
13002 h_elf, sec, relocation,
13003 unresolved_reloc, warned, ignored);
13004 sym_name = h_elf->root.root.string;
13005 sym_type = h_elf->type;
13006 if (sec != NULL
13007 && sec->owner == output_bfd
13008 && strcmp (sec->name, ".opd") == 0)
13009 {
13010 /* This is a symbol defined in a linker script. All
13011 such are defined in output sections, even those
13012 defined by simple assignment from a symbol defined in
13013 an input section. Transfer the symbol to an
13014 appropriate input .opd section, so that a branch to
13015 this symbol will be mapped to the location specified
13016 by the opd entry. */
13017 struct bfd_link_order *lo;
13018 for (lo = sec->map_head.link_order; lo != NULL; lo = lo->next)
13019 if (lo->type == bfd_indirect_link_order)
13020 {
13021 asection *isec = lo->u.indirect.section;
13022 if (h_elf->root.u.def.value >= isec->output_offset
13023 && h_elf->root.u.def.value < (isec->output_offset
13024 + isec->size))
13025 {
13026 h_elf->root.u.def.value -= isec->output_offset;
13027 h_elf->root.u.def.section = isec;
13028 sec = isec;
13029 break;
13030 }
13031 }
13032 }
13033 }
13034 h = (struct ppc_link_hash_entry *) h_elf;
13035
13036 if (sec != NULL && discarded_section (sec))
13037 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
13038 rel, 1, relend,
13039 ppc64_elf_howto_table[r_type], 0,
13040 contents);
13041
13042 if (info->relocatable)
13043 continue;
13044
13045 if (h != NULL && &h->elf == htab->elf.hgot)
13046 {
13047 relocation = (TOCstart
13048 + htab->stub_group[input_section->id].toc_off);
13049 sec = bfd_abs_section_ptr;
13050 unresolved_reloc = FALSE;
13051 }
13052
13053 /* TLS optimizations. Replace instruction sequences and relocs
13054 based on information we collected in tls_optimize. We edit
13055 RELOCS so that --emit-relocs will output something sensible
13056 for the final instruction stream. */
13057 tls_mask = 0;
13058 tls_gd = 0;
13059 toc_symndx = 0;
13060 if (h != NULL)
13061 tls_mask = h->tls_mask;
13062 else if (local_got_ents != NULL)
13063 {
13064 struct plt_entry **local_plt = (struct plt_entry **)
13065 (local_got_ents + symtab_hdr->sh_info);
13066 unsigned char *lgot_masks = (unsigned char *)
13067 (local_plt + symtab_hdr->sh_info);
13068 tls_mask = lgot_masks[r_symndx];
13069 }
13070 if (tls_mask == 0
13071 && (r_type == R_PPC64_TLS
13072 || r_type == R_PPC64_TLSGD
13073 || r_type == R_PPC64_TLSLD))
13074 {
13075 /* Check for toc tls entries. */
13076 unsigned char *toc_tls;
13077
13078 if (!get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
13079 &local_syms, rel, input_bfd))
13080 return FALSE;
13081
13082 if (toc_tls)
13083 tls_mask = *toc_tls;
13084 }
13085
13086 /* Check that tls relocs are used with tls syms, and non-tls
13087 relocs are used with non-tls syms. */
13088 if (r_symndx != STN_UNDEF
13089 && r_type != R_PPC64_NONE
13090 && (h == NULL
13091 || h->elf.root.type == bfd_link_hash_defined
13092 || h->elf.root.type == bfd_link_hash_defweak)
13093 && (IS_PPC64_TLS_RELOC (r_type)
13094 != (sym_type == STT_TLS
13095 || (sym_type == STT_SECTION
13096 && (sec->flags & SEC_THREAD_LOCAL) != 0))))
13097 {
13098 if (tls_mask != 0
13099 && (r_type == R_PPC64_TLS
13100 || r_type == R_PPC64_TLSGD
13101 || r_type == R_PPC64_TLSLD))
13102 /* R_PPC64_TLS is OK against a symbol in the TOC. */
13103 ;
13104 else
13105 info->callbacks->einfo
13106 (!IS_PPC64_TLS_RELOC (r_type)
13107 ? _("%P: %H: %s used with TLS symbol `%T'\n")
13108 : _("%P: %H: %s used with non-TLS symbol `%T'\n"),
13109 input_bfd, input_section, rel->r_offset,
13110 ppc64_elf_howto_table[r_type]->name,
13111 sym_name);
13112 }
13113
13114 /* Ensure reloc mapping code below stays sane. */
13115 if (R_PPC64_TOC16_LO_DS != R_PPC64_TOC16_DS + 1
13116 || R_PPC64_TOC16_LO != R_PPC64_TOC16 + 1
13117 || (R_PPC64_GOT_TLSLD16 & 3) != (R_PPC64_GOT_TLSGD16 & 3)
13118 || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TLSGD16_LO & 3)
13119 || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TLSGD16_HI & 3)
13120 || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TLSGD16_HA & 3)
13121 || (R_PPC64_GOT_TLSLD16 & 3) != (R_PPC64_GOT_TPREL16_DS & 3)
13122 || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TPREL16_LO_DS & 3)
13123 || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TPREL16_HI & 3)
13124 || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TPREL16_HA & 3))
13125 abort ();
13126
13127 switch (r_type)
13128 {
13129 default:
13130 break;
13131
13132 case R_PPC64_LO_DS_OPT:
13133 insn = bfd_get_32 (output_bfd, contents + rel->r_offset - d_offset);
13134 if ((insn & (0x3f << 26)) != 58u << 26)
13135 abort ();
13136 insn += (14u << 26) - (58u << 26);
13137 bfd_put_32 (output_bfd, insn, contents + rel->r_offset - d_offset);
13138 r_type = R_PPC64_TOC16_LO;
13139 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13140 break;
13141
13142 case R_PPC64_TOC16:
13143 case R_PPC64_TOC16_LO:
13144 case R_PPC64_TOC16_DS:
13145 case R_PPC64_TOC16_LO_DS:
13146 {
13147 /* Check for toc tls entries. */
13148 unsigned char *toc_tls;
13149 int retval;
13150
13151 retval = get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
13152 &local_syms, rel, input_bfd);
13153 if (retval == 0)
13154 return FALSE;
13155
13156 if (toc_tls)
13157 {
13158 tls_mask = *toc_tls;
13159 if (r_type == R_PPC64_TOC16_DS
13160 || r_type == R_PPC64_TOC16_LO_DS)
13161 {
13162 if (tls_mask != 0
13163 && (tls_mask & (TLS_DTPREL | TLS_TPREL)) == 0)
13164 goto toctprel;
13165 }
13166 else
13167 {
13168 /* If we found a GD reloc pair, then we might be
13169 doing a GD->IE transition. */
13170 if (retval == 2)
13171 {
13172 tls_gd = TLS_TPRELGD;
13173 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13174 goto tls_ldgd_opt;
13175 }
13176 else if (retval == 3)
13177 {
13178 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13179 goto tls_ldgd_opt;
13180 }
13181 }
13182 }
13183 }
13184 break;
13185
13186 case R_PPC64_GOT_TPREL16_HI:
13187 case R_PPC64_GOT_TPREL16_HA:
13188 if (tls_mask != 0
13189 && (tls_mask & TLS_TPREL) == 0)
13190 {
13191 rel->r_offset -= d_offset;
13192 bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
13193 r_type = R_PPC64_NONE;
13194 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13195 }
13196 break;
13197
13198 case R_PPC64_GOT_TPREL16_DS:
13199 case R_PPC64_GOT_TPREL16_LO_DS:
13200 if (tls_mask != 0
13201 && (tls_mask & TLS_TPREL) == 0)
13202 {
13203 toctprel:
13204 insn = bfd_get_32 (output_bfd, contents + rel->r_offset - d_offset);
13205 insn &= 31 << 21;
13206 insn |= 0x3c0d0000; /* addis 0,13,0 */
13207 bfd_put_32 (output_bfd, insn, contents + rel->r_offset - d_offset);
13208 r_type = R_PPC64_TPREL16_HA;
13209 if (toc_symndx != 0)
13210 {
13211 rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
13212 rel->r_addend = toc_addend;
13213 /* We changed the symbol. Start over in order to
13214 get h, sym, sec etc. right. */
13215 rel--;
13216 continue;
13217 }
13218 else
13219 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13220 }
13221 break;
13222
13223 case R_PPC64_TLS:
13224 if (tls_mask != 0
13225 && (tls_mask & TLS_TPREL) == 0)
13226 {
13227 insn = bfd_get_32 (output_bfd, contents + rel->r_offset);
13228 insn = _bfd_elf_ppc_at_tls_transform (insn, 13);
13229 if (insn == 0)
13230 abort ();
13231 bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
13232 /* Was PPC64_TLS which sits on insn boundary, now
13233 PPC64_TPREL16_LO which is at low-order half-word. */
13234 rel->r_offset += d_offset;
13235 r_type = R_PPC64_TPREL16_LO;
13236 if (toc_symndx != 0)
13237 {
13238 rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
13239 rel->r_addend = toc_addend;
13240 /* We changed the symbol. Start over in order to
13241 get h, sym, sec etc. right. */
13242 rel--;
13243 continue;
13244 }
13245 else
13246 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13247 }
13248 break;
13249
13250 case R_PPC64_GOT_TLSGD16_HI:
13251 case R_PPC64_GOT_TLSGD16_HA:
13252 tls_gd = TLS_TPRELGD;
13253 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13254 goto tls_gdld_hi;
13255 break;
13256
13257 case R_PPC64_GOT_TLSLD16_HI:
13258 case R_PPC64_GOT_TLSLD16_HA:
13259 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13260 {
13261 tls_gdld_hi:
13262 if ((tls_mask & tls_gd) != 0)
13263 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
13264 + R_PPC64_GOT_TPREL16_DS);
13265 else
13266 {
13267 rel->r_offset -= d_offset;
13268 bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
13269 r_type = R_PPC64_NONE;
13270 }
13271 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13272 }
13273 break;
13274
13275 case R_PPC64_GOT_TLSGD16:
13276 case R_PPC64_GOT_TLSGD16_LO:
13277 tls_gd = TLS_TPRELGD;
13278 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13279 goto tls_ldgd_opt;
13280 break;
13281
13282 case R_PPC64_GOT_TLSLD16:
13283 case R_PPC64_GOT_TLSLD16_LO:
13284 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13285 {
13286 unsigned int insn1, insn2, insn3;
13287 bfd_vma offset;
13288
13289 tls_ldgd_opt:
13290 offset = (bfd_vma) -1;
13291 /* If not using the newer R_PPC64_TLSGD/LD to mark
13292 __tls_get_addr calls, we must trust that the call
13293 stays with its arg setup insns, ie. that the next
13294 reloc is the __tls_get_addr call associated with
13295 the current reloc. Edit both insns. */
13296 if (input_section->has_tls_get_addr_call
13297 && rel + 1 < relend
13298 && branch_reloc_hash_match (input_bfd, rel + 1,
13299 htab->tls_get_addr,
13300 htab->tls_get_addr_fd))
13301 offset = rel[1].r_offset;
13302 if ((tls_mask & tls_gd) != 0)
13303 {
13304 /* IE */
13305 insn1 = bfd_get_32 (output_bfd,
13306 contents + rel->r_offset - d_offset);
13307 insn1 &= (1 << 26) - (1 << 2);
13308 insn1 |= 58 << 26; /* ld */
13309 insn2 = 0x7c636a14; /* add 3,3,13 */
13310 if (offset != (bfd_vma) -1)
13311 rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13312 if ((tls_mask & TLS_EXPLICIT) == 0)
13313 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
13314 + R_PPC64_GOT_TPREL16_DS);
13315 else
13316 r_type += R_PPC64_TOC16_DS - R_PPC64_TOC16;
13317 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13318 }
13319 else
13320 {
13321 /* LE */
13322 insn1 = 0x3c6d0000; /* addis 3,13,0 */
13323 insn2 = 0x38630000; /* addi 3,3,0 */
13324 if (tls_gd == 0)
13325 {
13326 /* Was an LD reloc. */
13327 if (toc_symndx)
13328 sec = local_sections[toc_symndx];
13329 for (r_symndx = 0;
13330 r_symndx < symtab_hdr->sh_info;
13331 r_symndx++)
13332 if (local_sections[r_symndx] == sec)
13333 break;
13334 if (r_symndx >= symtab_hdr->sh_info)
13335 r_symndx = STN_UNDEF;
13336 rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
13337 if (r_symndx != STN_UNDEF)
13338 rel->r_addend -= (local_syms[r_symndx].st_value
13339 + sec->output_offset
13340 + sec->output_section->vma);
13341 }
13342 else if (toc_symndx != 0)
13343 {
13344 r_symndx = toc_symndx;
13345 rel->r_addend = toc_addend;
13346 }
13347 r_type = R_PPC64_TPREL16_HA;
13348 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13349 if (offset != (bfd_vma) -1)
13350 {
13351 rel[1].r_info = ELF64_R_INFO (r_symndx,
13352 R_PPC64_TPREL16_LO);
13353 rel[1].r_offset = offset + d_offset;
13354 rel[1].r_addend = rel->r_addend;
13355 }
13356 }
13357 bfd_put_32 (output_bfd, insn1,
13358 contents + rel->r_offset - d_offset);
13359 if (offset != (bfd_vma) -1)
13360 {
13361 insn3 = bfd_get_32 (output_bfd,
13362 contents + offset + 4);
13363 if (insn3 == NOP
13364 || insn3 == CROR_151515 || insn3 == CROR_313131)
13365 {
13366 rel[1].r_offset += 4;
13367 bfd_put_32 (output_bfd, insn2, contents + offset + 4);
13368 insn2 = NOP;
13369 }
13370 bfd_put_32 (output_bfd, insn2, contents + offset);
13371 }
13372 if ((tls_mask & tls_gd) == 0
13373 && (tls_gd == 0 || toc_symndx != 0))
13374 {
13375 /* We changed the symbol. Start over in order
13376 to get h, sym, sec etc. right. */
13377 rel--;
13378 continue;
13379 }
13380 }
13381 break;
13382
13383 case R_PPC64_TLSGD:
13384 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13385 {
13386 unsigned int insn2, insn3;
13387 bfd_vma offset = rel->r_offset;
13388
13389 if ((tls_mask & TLS_TPRELGD) != 0)
13390 {
13391 /* IE */
13392 r_type = R_PPC64_NONE;
13393 insn2 = 0x7c636a14; /* add 3,3,13 */
13394 }
13395 else
13396 {
13397 /* LE */
13398 if (toc_symndx != 0)
13399 {
13400 r_symndx = toc_symndx;
13401 rel->r_addend = toc_addend;
13402 }
13403 r_type = R_PPC64_TPREL16_LO;
13404 rel->r_offset = offset + d_offset;
13405 insn2 = 0x38630000; /* addi 3,3,0 */
13406 }
13407 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13408 /* Zap the reloc on the _tls_get_addr call too. */
13409 BFD_ASSERT (offset == rel[1].r_offset);
13410 rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13411 insn3 = bfd_get_32 (output_bfd,
13412 contents + offset + 4);
13413 if (insn3 == NOP
13414 || insn3 == CROR_151515 || insn3 == CROR_313131)
13415 {
13416 rel->r_offset += 4;
13417 bfd_put_32 (output_bfd, insn2, contents + offset + 4);
13418 insn2 = NOP;
13419 }
13420 bfd_put_32 (output_bfd, insn2, contents + offset);
13421 if ((tls_mask & TLS_TPRELGD) == 0 && toc_symndx != 0)
13422 {
13423 rel--;
13424 continue;
13425 }
13426 }
13427 break;
13428
13429 case R_PPC64_TLSLD:
13430 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13431 {
13432 unsigned int insn2, insn3;
13433 bfd_vma offset = rel->r_offset;
13434
13435 if (toc_symndx)
13436 sec = local_sections[toc_symndx];
13437 for (r_symndx = 0;
13438 r_symndx < symtab_hdr->sh_info;
13439 r_symndx++)
13440 if (local_sections[r_symndx] == sec)
13441 break;
13442 if (r_symndx >= symtab_hdr->sh_info)
13443 r_symndx = STN_UNDEF;
13444 rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
13445 if (r_symndx != STN_UNDEF)
13446 rel->r_addend -= (local_syms[r_symndx].st_value
13447 + sec->output_offset
13448 + sec->output_section->vma);
13449
13450 r_type = R_PPC64_TPREL16_LO;
13451 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13452 rel->r_offset = offset + d_offset;
13453 /* Zap the reloc on the _tls_get_addr call too. */
13454 BFD_ASSERT (offset == rel[1].r_offset);
13455 rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
13456 insn2 = 0x38630000; /* addi 3,3,0 */
13457 insn3 = bfd_get_32 (output_bfd,
13458 contents + offset + 4);
13459 if (insn3 == NOP
13460 || insn3 == CROR_151515 || insn3 == CROR_313131)
13461 {
13462 rel->r_offset += 4;
13463 bfd_put_32 (output_bfd, insn2, contents + offset + 4);
13464 insn2 = NOP;
13465 }
13466 bfd_put_32 (output_bfd, insn2, contents + offset);
13467 rel--;
13468 continue;
13469 }
13470 break;
13471
13472 case R_PPC64_DTPMOD64:
13473 if (rel + 1 < relend
13474 && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
13475 && rel[1].r_offset == rel->r_offset + 8)
13476 {
13477 if ((tls_mask & TLS_GD) == 0)
13478 {
13479 rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_NONE);
13480 if ((tls_mask & TLS_TPRELGD) != 0)
13481 r_type = R_PPC64_TPREL64;
13482 else
13483 {
13484 bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
13485 r_type = R_PPC64_NONE;
13486 }
13487 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13488 }
13489 }
13490 else
13491 {
13492 if ((tls_mask & TLS_LD) == 0)
13493 {
13494 bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
13495 r_type = R_PPC64_NONE;
13496 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13497 }
13498 }
13499 break;
13500
13501 case R_PPC64_TPREL64:
13502 if ((tls_mask & TLS_TPREL) == 0)
13503 {
13504 r_type = R_PPC64_NONE;
13505 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13506 }
13507 break;
13508
13509 case R_PPC64_REL16_HA:
13510 /* If we are generating a non-PIC executable, edit
13511 . 0: addis 2,12,.TOC.-0b@ha
13512 . addi 2,2,.TOC.-0b@l
13513 used by ELFv2 global entry points to set up r2, to
13514 . lis 2,.TOC.@ha
13515 . addi 2,2,.TOC.@l
13516 if .TOC. is in range. */
13517 if (!info->shared
13518 && h != NULL && &h->elf == htab->elf.hgot
13519 && rel + 1 < relend
13520 && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_REL16_LO)
13521 && rel[1].r_offset == rel->r_offset + 4
13522 && rel[1].r_addend == rel->r_addend + 4
13523 && relocation + 0x80008000 <= 0xffffffff)
13524 {
13525 unsigned int insn1, insn2;
13526 bfd_vma offset = rel->r_offset - d_offset;
13527 insn1 = bfd_get_32 (output_bfd, contents + offset);
13528 insn2 = bfd_get_32 (output_bfd, contents + offset + 4);
13529 if ((insn1 & 0xffff0000) == 0x3c4c0000 /* addis 2,12 */
13530 && (insn2 & 0xffff0000) == 0x38420000 /* addi 2,2 */)
13531 {
13532 r_type = R_PPC64_ADDR16_HA;
13533 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13534 rel->r_addend -= d_offset;
13535 rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_ADDR16_LO);
13536 rel[1].r_addend -= d_offset + 4;
13537 bfd_put_32 (output_bfd, 0x3c400000, contents + offset);
13538 }
13539 }
13540 break;
13541 }
13542
13543 /* Handle other relocations that tweak non-addend part of insn. */
13544 insn = 0;
13545 max_br_offset = 1 << 25;
13546 addend = rel->r_addend;
13547 reloc_dest = DEST_NORMAL;
13548 switch (r_type)
13549 {
13550 default:
13551 break;
13552
13553 case R_PPC64_TOCSAVE:
13554 if (relocation + addend == (rel->r_offset
13555 + input_section->output_offset
13556 + input_section->output_section->vma)
13557 && tocsave_find (htab, NO_INSERT,
13558 &local_syms, rel, input_bfd))
13559 {
13560 insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
13561 if (insn == NOP
13562 || insn == CROR_151515 || insn == CROR_313131)
13563 bfd_put_32 (input_bfd,
13564 STD_R2_0R1 + STK_TOC (htab),
13565 contents + rel->r_offset);
13566 }
13567 break;
13568
13569 /* Branch taken prediction relocations. */
13570 case R_PPC64_ADDR14_BRTAKEN:
13571 case R_PPC64_REL14_BRTAKEN:
13572 insn = 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field. */
13573 /* Fall thru. */
13574
13575 /* Branch not taken prediction relocations. */
13576 case R_PPC64_ADDR14_BRNTAKEN:
13577 case R_PPC64_REL14_BRNTAKEN:
13578 insn |= bfd_get_32 (output_bfd,
13579 contents + rel->r_offset) & ~(0x01 << 21);
13580 /* Fall thru. */
13581
13582 case R_PPC64_REL14:
13583 max_br_offset = 1 << 15;
13584 /* Fall thru. */
13585
13586 case R_PPC64_REL24:
13587 /* Calls to functions with a different TOC, such as calls to
13588 shared objects, need to alter the TOC pointer. This is
13589 done using a linkage stub. A REL24 branching to these
13590 linkage stubs needs to be followed by a nop, as the nop
13591 will be replaced with an instruction to restore the TOC
13592 base pointer. */
13593 fdh = h;
13594 if (h != NULL
13595 && h->oh != NULL
13596 && h->oh->is_func_descriptor)
13597 fdh = ppc_follow_link (h->oh);
13598 stub_entry = ppc_get_stub_entry (input_section, sec, fdh, &orig_rel,
13599 htab);
13600 if (stub_entry != NULL
13601 && (stub_entry->stub_type == ppc_stub_plt_call
13602 || stub_entry->stub_type == ppc_stub_plt_call_r2save
13603 || stub_entry->stub_type == ppc_stub_plt_branch_r2off
13604 || stub_entry->stub_type == ppc_stub_long_branch_r2off))
13605 {
13606 bfd_boolean can_plt_call = FALSE;
13607
13608 /* All of these stubs will modify r2, so there must be a
13609 branch and link followed by a nop. The nop is
13610 replaced by an insn to restore r2. */
13611 if (rel->r_offset + 8 <= input_section->size)
13612 {
13613 unsigned long br;
13614
13615 br = bfd_get_32 (input_bfd,
13616 contents + rel->r_offset);
13617 if ((br & 1) != 0)
13618 {
13619 unsigned long nop;
13620
13621 nop = bfd_get_32 (input_bfd,
13622 contents + rel->r_offset + 4);
13623 if (nop == NOP
13624 || nop == CROR_151515 || nop == CROR_313131)
13625 {
13626 if (h != NULL
13627 && (h == htab->tls_get_addr_fd
13628 || h == htab->tls_get_addr)
13629 && !htab->params->no_tls_get_addr_opt)
13630 {
13631 /* Special stub used, leave nop alone. */
13632 }
13633 else
13634 bfd_put_32 (input_bfd,
13635 LD_R2_0R1 + STK_TOC (htab),
13636 contents + rel->r_offset + 4);
13637 can_plt_call = TRUE;
13638 }
13639 }
13640 }
13641
13642 if (!can_plt_call && h != NULL)
13643 {
13644 const char *name = h->elf.root.root.string;
13645
13646 if (*name == '.')
13647 ++name;
13648
13649 if (strncmp (name, "__libc_start_main", 17) == 0
13650 && (name[17] == 0 || name[17] == '@'))
13651 {
13652 /* Allow crt1 branch to go via a toc adjusting
13653 stub. Other calls that never return could do
13654 the same, if we could detect such. */
13655 can_plt_call = TRUE;
13656 }
13657 }
13658
13659 if (!can_plt_call)
13660 {
13661 /* g++ as of 20130507 emits self-calls without a
13662 following nop. This is arguably wrong since we
13663 have conflicting information. On the one hand a
13664 global symbol and on the other a local call
13665 sequence, but don't error for this special case.
13666 It isn't possible to cheaply verify we have
13667 exactly such a call. Allow all calls to the same
13668 section. */
13669 asection *code_sec = sec;
13670
13671 if (get_opd_info (sec) != NULL)
13672 {
13673 bfd_vma off = (relocation + addend
13674 - sec->output_section->vma
13675 - sec->output_offset);
13676
13677 opd_entry_value (sec, off, &code_sec, NULL, FALSE);
13678 }
13679 if (code_sec == input_section)
13680 can_plt_call = TRUE;
13681 }
13682
13683 if (!can_plt_call)
13684 {
13685 info->callbacks->einfo
13686 (_("%P: %H: call to `%T' lacks nop, can't restore toc; "
13687 "recompile with -fPIC\n"),
13688 input_bfd, input_section, rel->r_offset, sym_name);
13689
13690 bfd_set_error (bfd_error_bad_value);
13691 ret = FALSE;
13692 }
13693
13694 if (can_plt_call
13695 && (stub_entry->stub_type == ppc_stub_plt_call
13696 || stub_entry->stub_type == ppc_stub_plt_call_r2save))
13697 unresolved_reloc = FALSE;
13698 }
13699
13700 if ((stub_entry == NULL
13701 || stub_entry->stub_type == ppc_stub_long_branch
13702 || stub_entry->stub_type == ppc_stub_plt_branch)
13703 && get_opd_info (sec) != NULL)
13704 {
13705 /* The branch destination is the value of the opd entry. */
13706 bfd_vma off = (relocation + addend
13707 - sec->output_section->vma
13708 - sec->output_offset);
13709 bfd_vma dest = opd_entry_value (sec, off, NULL, NULL, FALSE);
13710 if (dest != (bfd_vma) -1)
13711 {
13712 relocation = dest;
13713 addend = 0;
13714 reloc_dest = DEST_OPD;
13715 }
13716 }
13717
13718 /* If the branch is out of reach we ought to have a long
13719 branch stub. */
13720 from = (rel->r_offset
13721 + input_section->output_offset
13722 + input_section->output_section->vma);
13723
13724 relocation += PPC64_LOCAL_ENTRY_OFFSET (fdh
13725 ? fdh->elf.other
13726 : sym->st_other);
13727
13728 if (stub_entry != NULL
13729 && (stub_entry->stub_type == ppc_stub_long_branch
13730 || stub_entry->stub_type == ppc_stub_plt_branch)
13731 && (r_type == R_PPC64_ADDR14_BRTAKEN
13732 || r_type == R_PPC64_ADDR14_BRNTAKEN
13733 || (relocation + addend - from + max_br_offset
13734 < 2 * max_br_offset)))
13735 /* Don't use the stub if this branch is in range. */
13736 stub_entry = NULL;
13737
13738 if (stub_entry != NULL)
13739 {
13740 /* Munge up the value and addend so that we call the stub
13741 rather than the procedure directly. */
13742 relocation = (stub_entry->stub_offset
13743 + stub_entry->stub_sec->output_offset
13744 + stub_entry->stub_sec->output_section->vma);
13745 addend = 0;
13746 reloc_dest = DEST_STUB;
13747
13748 if ((stub_entry->stub_type == ppc_stub_plt_call
13749 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
13750 && (ALWAYS_EMIT_R2SAVE
13751 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
13752 && rel + 1 < relend
13753 && rel[1].r_offset == rel->r_offset + 4
13754 && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOCSAVE)
13755 relocation += 4;
13756 }
13757
13758 if (insn != 0)
13759 {
13760 if (is_isa_v2)
13761 {
13762 /* Set 'a' bit. This is 0b00010 in BO field for branch
13763 on CR(BI) insns (BO == 001at or 011at), and 0b01000
13764 for branch on CTR insns (BO == 1a00t or 1a01t). */
13765 if ((insn & (0x14 << 21)) == (0x04 << 21))
13766 insn |= 0x02 << 21;
13767 else if ((insn & (0x14 << 21)) == (0x10 << 21))
13768 insn |= 0x08 << 21;
13769 else
13770 break;
13771 }
13772 else
13773 {
13774 /* Invert 'y' bit if not the default. */
13775 if ((bfd_signed_vma) (relocation + addend - from) < 0)
13776 insn ^= 0x01 << 21;
13777 }
13778
13779 bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
13780 }
13781
13782 /* NOP out calls to undefined weak functions.
13783 We can thus call a weak function without first
13784 checking whether the function is defined. */
13785 else if (h != NULL
13786 && h->elf.root.type == bfd_link_hash_undefweak
13787 && h->elf.dynindx == -1
13788 && r_type == R_PPC64_REL24
13789 && relocation == 0
13790 && addend == 0)
13791 {
13792 bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
13793 continue;
13794 }
13795 break;
13796 }
13797
13798 /* Set `addend'. */
13799 tls_type = 0;
13800 switch (r_type)
13801 {
13802 default:
13803 info->callbacks->einfo
13804 (_("%P: %B: unknown relocation type %d for `%T'\n"),
13805 input_bfd, (int) r_type, sym_name);
13806
13807 bfd_set_error (bfd_error_bad_value);
13808 ret = FALSE;
13809 continue;
13810
13811 case R_PPC64_NONE:
13812 case R_PPC64_TLS:
13813 case R_PPC64_TLSGD:
13814 case R_PPC64_TLSLD:
13815 case R_PPC64_TOCSAVE:
13816 case R_PPC64_GNU_VTINHERIT:
13817 case R_PPC64_GNU_VTENTRY:
13818 continue;
13819
13820 /* GOT16 relocations. Like an ADDR16 using the symbol's
13821 address in the GOT as relocation value instead of the
13822 symbol's value itself. Also, create a GOT entry for the
13823 symbol and put the symbol value there. */
13824 case R_PPC64_GOT_TLSGD16:
13825 case R_PPC64_GOT_TLSGD16_LO:
13826 case R_PPC64_GOT_TLSGD16_HI:
13827 case R_PPC64_GOT_TLSGD16_HA:
13828 tls_type = TLS_TLS | TLS_GD;
13829 goto dogot;
13830
13831 case R_PPC64_GOT_TLSLD16:
13832 case R_PPC64_GOT_TLSLD16_LO:
13833 case R_PPC64_GOT_TLSLD16_HI:
13834 case R_PPC64_GOT_TLSLD16_HA:
13835 tls_type = TLS_TLS | TLS_LD;
13836 goto dogot;
13837
13838 case R_PPC64_GOT_TPREL16_DS:
13839 case R_PPC64_GOT_TPREL16_LO_DS:
13840 case R_PPC64_GOT_TPREL16_HI:
13841 case R_PPC64_GOT_TPREL16_HA:
13842 tls_type = TLS_TLS | TLS_TPREL;
13843 goto dogot;
13844
13845 case R_PPC64_GOT_DTPREL16_DS:
13846 case R_PPC64_GOT_DTPREL16_LO_DS:
13847 case R_PPC64_GOT_DTPREL16_HI:
13848 case R_PPC64_GOT_DTPREL16_HA:
13849 tls_type = TLS_TLS | TLS_DTPREL;
13850 goto dogot;
13851
13852 case R_PPC64_GOT16:
13853 case R_PPC64_GOT16_LO:
13854 case R_PPC64_GOT16_HI:
13855 case R_PPC64_GOT16_HA:
13856 case R_PPC64_GOT16_DS:
13857 case R_PPC64_GOT16_LO_DS:
13858 dogot:
13859 {
13860 /* Relocation is to the entry for this symbol in the global
13861 offset table. */
13862 asection *got;
13863 bfd_vma *offp;
13864 bfd_vma off;
13865 unsigned long indx = 0;
13866 struct got_entry *ent;
13867
13868 if (tls_type == (TLS_TLS | TLS_LD)
13869 && (h == NULL
13870 || !h->elf.def_dynamic))
13871 ent = ppc64_tlsld_got (input_bfd);
13872 else
13873 {
13874
13875 if (h != NULL)
13876 {
13877 bfd_boolean dyn = htab->elf.dynamic_sections_created;
13878 if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared,
13879 &h->elf)
13880 || (info->shared
13881 && SYMBOL_REFERENCES_LOCAL (info, &h->elf)))
13882 /* This is actually a static link, or it is a
13883 -Bsymbolic link and the symbol is defined
13884 locally, or the symbol was forced to be local
13885 because of a version file. */
13886 ;
13887 else
13888 {
13889 BFD_ASSERT (h->elf.dynindx != -1);
13890 indx = h->elf.dynindx;
13891 unresolved_reloc = FALSE;
13892 }
13893 ent = h->elf.got.glist;
13894 }
13895 else
13896 {
13897 if (local_got_ents == NULL)
13898 abort ();
13899 ent = local_got_ents[r_symndx];
13900 }
13901
13902 for (; ent != NULL; ent = ent->next)
13903 if (ent->addend == orig_rel.r_addend
13904 && ent->owner == input_bfd
13905 && ent->tls_type == tls_type)
13906 break;
13907 }
13908
13909 if (ent == NULL)
13910 abort ();
13911 if (ent->is_indirect)
13912 ent = ent->got.ent;
13913 offp = &ent->got.offset;
13914 got = ppc64_elf_tdata (ent->owner)->got;
13915 if (got == NULL)
13916 abort ();
13917
13918 /* The offset must always be a multiple of 8. We use the
13919 least significant bit to record whether we have already
13920 processed this entry. */
13921 off = *offp;
13922 if ((off & 1) != 0)
13923 off &= ~1;
13924 else
13925 {
13926 /* Generate relocs for the dynamic linker, except in
13927 the case of TLSLD where we'll use one entry per
13928 module. */
13929 asection *relgot;
13930 bfd_boolean ifunc;
13931
13932 *offp = off | 1;
13933 relgot = NULL;
13934 ifunc = (h != NULL
13935 ? h->elf.type == STT_GNU_IFUNC
13936 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC);
13937 if (ifunc)
13938 relgot = htab->elf.irelplt;
13939 else if ((info->shared || indx != 0)
13940 && (h == NULL
13941 || (tls_type == (TLS_TLS | TLS_LD)
13942 && !h->elf.def_dynamic)
13943 || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
13944 || h->elf.root.type != bfd_link_hash_undefweak))
13945 relgot = ppc64_elf_tdata (ent->owner)->relgot;
13946 if (relgot != NULL)
13947 {
13948 outrel.r_offset = (got->output_section->vma
13949 + got->output_offset
13950 + off);
13951 outrel.r_addend = addend;
13952 if (tls_type & (TLS_LD | TLS_GD))
13953 {
13954 outrel.r_addend = 0;
13955 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPMOD64);
13956 if (tls_type == (TLS_TLS | TLS_GD))
13957 {
13958 loc = relgot->contents;
13959 loc += (relgot->reloc_count++
13960 * sizeof (Elf64_External_Rela));
13961 bfd_elf64_swap_reloca_out (output_bfd,
13962 &outrel, loc);
13963 outrel.r_offset += 8;
13964 outrel.r_addend = addend;
13965 outrel.r_info
13966 = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
13967 }
13968 }
13969 else if (tls_type == (TLS_TLS | TLS_DTPREL))
13970 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
13971 else if (tls_type == (TLS_TLS | TLS_TPREL))
13972 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_TPREL64);
13973 else if (indx != 0)
13974 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_GLOB_DAT);
13975 else
13976 {
13977 if (ifunc)
13978 outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
13979 else
13980 outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
13981
13982 /* Write the .got section contents for the sake
13983 of prelink. */
13984 loc = got->contents + off;
13985 bfd_put_64 (output_bfd, outrel.r_addend + relocation,
13986 loc);
13987 }
13988
13989 if (indx == 0 && tls_type != (TLS_TLS | TLS_LD))
13990 {
13991 outrel.r_addend += relocation;
13992 if (tls_type & (TLS_GD | TLS_DTPREL | TLS_TPREL))
13993 outrel.r_addend -= htab->elf.tls_sec->vma;
13994 }
13995 loc = relgot->contents;
13996 loc += (relgot->reloc_count++
13997 * sizeof (Elf64_External_Rela));
13998 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
13999 }
14000
14001 /* Init the .got section contents here if we're not
14002 emitting a reloc. */
14003 else
14004 {
14005 relocation += addend;
14006 if (tls_type == (TLS_TLS | TLS_LD))
14007 relocation = 1;
14008 else if (tls_type != 0)
14009 {
14010 relocation -= htab->elf.tls_sec->vma + DTP_OFFSET;
14011 if (tls_type == (TLS_TLS | TLS_TPREL))
14012 relocation += DTP_OFFSET - TP_OFFSET;
14013
14014 if (tls_type == (TLS_TLS | TLS_GD))
14015 {
14016 bfd_put_64 (output_bfd, relocation,
14017 got->contents + off + 8);
14018 relocation = 1;
14019 }
14020 }
14021
14022 bfd_put_64 (output_bfd, relocation,
14023 got->contents + off);
14024 }
14025 }
14026
14027 if (off >= (bfd_vma) -2)
14028 abort ();
14029
14030 relocation = got->output_section->vma + got->output_offset + off;
14031 addend = -(TOCstart + htab->stub_group[input_section->id].toc_off);
14032 }
14033 break;
14034
14035 case R_PPC64_PLT16_HA:
14036 case R_PPC64_PLT16_HI:
14037 case R_PPC64_PLT16_LO:
14038 case R_PPC64_PLT32:
14039 case R_PPC64_PLT64:
14040 /* Relocation is to the entry for this symbol in the
14041 procedure linkage table. */
14042
14043 /* Resolve a PLT reloc against a local symbol directly,
14044 without using the procedure linkage table. */
14045 if (h == NULL)
14046 break;
14047
14048 /* It's possible that we didn't make a PLT entry for this
14049 symbol. This happens when statically linking PIC code,
14050 or when using -Bsymbolic. Go find a match if there is a
14051 PLT entry. */
14052 if (htab->elf.splt != NULL)
14053 {
14054 struct plt_entry *ent;
14055 for (ent = h->elf.plt.plist; ent != NULL; ent = ent->next)
14056 if (ent->plt.offset != (bfd_vma) -1
14057 && ent->addend == orig_rel.r_addend)
14058 {
14059 relocation = (htab->elf.splt->output_section->vma
14060 + htab->elf.splt->output_offset
14061 + ent->plt.offset);
14062 unresolved_reloc = FALSE;
14063 break;
14064 }
14065 }
14066 break;
14067
14068 case R_PPC64_TOC:
14069 /* Relocation value is TOC base. */
14070 relocation = TOCstart;
14071 if (r_symndx == STN_UNDEF)
14072 relocation += htab->stub_group[input_section->id].toc_off;
14073 else if (unresolved_reloc)
14074 ;
14075 else if (sec != NULL && sec->id <= htab->top_id)
14076 relocation += htab->stub_group[sec->id].toc_off;
14077 else
14078 unresolved_reloc = TRUE;
14079 goto dodyn;
14080
14081 /* TOC16 relocs. We want the offset relative to the TOC base,
14082 which is the address of the start of the TOC plus 0x8000.
14083 The TOC consists of sections .got, .toc, .tocbss, and .plt,
14084 in this order. */
14085 case R_PPC64_TOC16:
14086 case R_PPC64_TOC16_LO:
14087 case R_PPC64_TOC16_HI:
14088 case R_PPC64_TOC16_DS:
14089 case R_PPC64_TOC16_LO_DS:
14090 case R_PPC64_TOC16_HA:
14091 addend -= TOCstart + htab->stub_group[input_section->id].toc_off;
14092 break;
14093
14094 /* Relocate against the beginning of the section. */
14095 case R_PPC64_SECTOFF:
14096 case R_PPC64_SECTOFF_LO:
14097 case R_PPC64_SECTOFF_HI:
14098 case R_PPC64_SECTOFF_DS:
14099 case R_PPC64_SECTOFF_LO_DS:
14100 case R_PPC64_SECTOFF_HA:
14101 if (sec != NULL)
14102 addend -= sec->output_section->vma;
14103 break;
14104
14105 case R_PPC64_REL16:
14106 case R_PPC64_REL16_LO:
14107 case R_PPC64_REL16_HI:
14108 case R_PPC64_REL16_HA:
14109 break;
14110
14111 case R_PPC64_REL14:
14112 case R_PPC64_REL14_BRNTAKEN:
14113 case R_PPC64_REL14_BRTAKEN:
14114 case R_PPC64_REL24:
14115 break;
14116
14117 case R_PPC64_TPREL16:
14118 case R_PPC64_TPREL16_LO:
14119 case R_PPC64_TPREL16_HI:
14120 case R_PPC64_TPREL16_HA:
14121 case R_PPC64_TPREL16_DS:
14122 case R_PPC64_TPREL16_LO_DS:
14123 case R_PPC64_TPREL16_HIGH:
14124 case R_PPC64_TPREL16_HIGHA:
14125 case R_PPC64_TPREL16_HIGHER:
14126 case R_PPC64_TPREL16_HIGHERA:
14127 case R_PPC64_TPREL16_HIGHEST:
14128 case R_PPC64_TPREL16_HIGHESTA:
14129 if (h != NULL
14130 && h->elf.root.type == bfd_link_hash_undefweak
14131 && h->elf.dynindx == -1)
14132 {
14133 /* Make this relocation against an undefined weak symbol
14134 resolve to zero. This is really just a tweak, since
14135 code using weak externs ought to check that they are
14136 defined before using them. */
14137 bfd_byte *p = contents + rel->r_offset - d_offset;
14138
14139 insn = bfd_get_32 (output_bfd, p);
14140 insn = _bfd_elf_ppc_at_tprel_transform (insn, 13);
14141 if (insn != 0)
14142 bfd_put_32 (output_bfd, insn, p);
14143 break;
14144 }
14145 addend -= htab->elf.tls_sec->vma + TP_OFFSET;
14146 if (info->shared)
14147 /* The TPREL16 relocs shouldn't really be used in shared
14148 libs as they will result in DT_TEXTREL being set, but
14149 support them anyway. */
14150 goto dodyn;
14151 break;
14152
14153 case R_PPC64_DTPREL16:
14154 case R_PPC64_DTPREL16_LO:
14155 case R_PPC64_DTPREL16_HI:
14156 case R_PPC64_DTPREL16_HA:
14157 case R_PPC64_DTPREL16_DS:
14158 case R_PPC64_DTPREL16_LO_DS:
14159 case R_PPC64_DTPREL16_HIGH:
14160 case R_PPC64_DTPREL16_HIGHA:
14161 case R_PPC64_DTPREL16_HIGHER:
14162 case R_PPC64_DTPREL16_HIGHERA:
14163 case R_PPC64_DTPREL16_HIGHEST:
14164 case R_PPC64_DTPREL16_HIGHESTA:
14165 addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
14166 break;
14167
14168 case R_PPC64_ADDR64_LOCAL:
14169 addend += PPC64_LOCAL_ENTRY_OFFSET (h != NULL
14170 ? h->elf.other
14171 : sym->st_other);
14172 break;
14173
14174 case R_PPC64_DTPMOD64:
14175 relocation = 1;
14176 addend = 0;
14177 goto dodyn;
14178
14179 case R_PPC64_TPREL64:
14180 addend -= htab->elf.tls_sec->vma + TP_OFFSET;
14181 goto dodyn;
14182
14183 case R_PPC64_DTPREL64:
14184 addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
14185 /* Fall thru */
14186
14187 /* Relocations that may need to be propagated if this is a
14188 dynamic object. */
14189 case R_PPC64_REL30:
14190 case R_PPC64_REL32:
14191 case R_PPC64_REL64:
14192 case R_PPC64_ADDR14:
14193 case R_PPC64_ADDR14_BRNTAKEN:
14194 case R_PPC64_ADDR14_BRTAKEN:
14195 case R_PPC64_ADDR16:
14196 case R_PPC64_ADDR16_DS:
14197 case R_PPC64_ADDR16_HA:
14198 case R_PPC64_ADDR16_HI:
14199 case R_PPC64_ADDR16_HIGH:
14200 case R_PPC64_ADDR16_HIGHA:
14201 case R_PPC64_ADDR16_HIGHER:
14202 case R_PPC64_ADDR16_HIGHERA:
14203 case R_PPC64_ADDR16_HIGHEST:
14204 case R_PPC64_ADDR16_HIGHESTA:
14205 case R_PPC64_ADDR16_LO:
14206 case R_PPC64_ADDR16_LO_DS:
14207 case R_PPC64_ADDR24:
14208 case R_PPC64_ADDR32:
14209 case R_PPC64_ADDR64:
14210 case R_PPC64_UADDR16:
14211 case R_PPC64_UADDR32:
14212 case R_PPC64_UADDR64:
14213 dodyn:
14214 if ((input_section->flags & SEC_ALLOC) == 0)
14215 break;
14216
14217 if (NO_OPD_RELOCS && is_opd)
14218 break;
14219
14220 if ((info->shared
14221 && (h == NULL
14222 || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
14223 || h->elf.root.type != bfd_link_hash_undefweak)
14224 && (must_be_dyn_reloc (info, r_type)
14225 || !SYMBOL_CALLS_LOCAL (info, &h->elf)))
14226 || (ELIMINATE_COPY_RELOCS
14227 && !info->shared
14228 && h != NULL
14229 && h->elf.dynindx != -1
14230 && !h->elf.non_got_ref
14231 && !h->elf.def_regular)
14232 || (!info->shared
14233 && (h != NULL
14234 ? h->elf.type == STT_GNU_IFUNC
14235 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)))
14236 {
14237 bfd_boolean skip, relocate;
14238 asection *sreloc;
14239 bfd_vma out_off;
14240
14241 /* When generating a dynamic object, these relocations
14242 are copied into the output file to be resolved at run
14243 time. */
14244
14245 skip = FALSE;
14246 relocate = FALSE;
14247
14248 out_off = _bfd_elf_section_offset (output_bfd, info,
14249 input_section, rel->r_offset);
14250 if (out_off == (bfd_vma) -1)
14251 skip = TRUE;
14252 else if (out_off == (bfd_vma) -2)
14253 skip = TRUE, relocate = TRUE;
14254 out_off += (input_section->output_section->vma
14255 + input_section->output_offset);
14256 outrel.r_offset = out_off;
14257 outrel.r_addend = rel->r_addend;
14258
14259 /* Optimize unaligned reloc use. */
14260 if ((r_type == R_PPC64_ADDR64 && (out_off & 7) != 0)
14261 || (r_type == R_PPC64_UADDR64 && (out_off & 7) == 0))
14262 r_type ^= R_PPC64_ADDR64 ^ R_PPC64_UADDR64;
14263 else if ((r_type == R_PPC64_ADDR32 && (out_off & 3) != 0)
14264 || (r_type == R_PPC64_UADDR32 && (out_off & 3) == 0))
14265 r_type ^= R_PPC64_ADDR32 ^ R_PPC64_UADDR32;
14266 else if ((r_type == R_PPC64_ADDR16 && (out_off & 1) != 0)
14267 || (r_type == R_PPC64_UADDR16 && (out_off & 1) == 0))
14268 r_type ^= R_PPC64_ADDR16 ^ R_PPC64_UADDR16;
14269
14270 if (skip)
14271 memset (&outrel, 0, sizeof outrel);
14272 else if (!SYMBOL_REFERENCES_LOCAL (info, &h->elf)
14273 && !is_opd
14274 && r_type != R_PPC64_TOC)
14275 {
14276 BFD_ASSERT (h->elf.dynindx != -1);
14277 outrel.r_info = ELF64_R_INFO (h->elf.dynindx, r_type);
14278 }
14279 else
14280 {
14281 /* This symbol is local, or marked to become local,
14282 or this is an opd section reloc which must point
14283 at a local function. */
14284 outrel.r_addend += relocation;
14285 if (r_type == R_PPC64_ADDR64 || r_type == R_PPC64_TOC)
14286 {
14287 if (is_opd && h != NULL)
14288 {
14289 /* Lie about opd entries. This case occurs
14290 when building shared libraries and we
14291 reference a function in another shared
14292 lib. The same thing happens for a weak
14293 definition in an application that's
14294 overridden by a strong definition in a
14295 shared lib. (I believe this is a generic
14296 bug in binutils handling of weak syms.)
14297 In these cases we won't use the opd
14298 entry in this lib. */
14299 unresolved_reloc = FALSE;
14300 }
14301 if (!is_opd
14302 && r_type == R_PPC64_ADDR64
14303 && (h != NULL
14304 ? h->elf.type == STT_GNU_IFUNC
14305 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
14306 outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
14307 else
14308 {
14309 outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
14310
14311 /* We need to relocate .opd contents for ld.so.
14312 Prelink also wants simple and consistent rules
14313 for relocs. This make all RELATIVE relocs have
14314 *r_offset equal to r_addend. */
14315 relocate = TRUE;
14316 }
14317 }
14318 else
14319 {
14320 long indx = 0;
14321
14322 if (h != NULL
14323 ? h->elf.type == STT_GNU_IFUNC
14324 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
14325 {
14326 info->callbacks->einfo
14327 (_("%P: %H: %s for indirect "
14328 "function `%T' unsupported\n"),
14329 input_bfd, input_section, rel->r_offset,
14330 ppc64_elf_howto_table[r_type]->name,
14331 sym_name);
14332 ret = FALSE;
14333 }
14334 else if (r_symndx == STN_UNDEF || bfd_is_abs_section (sec))
14335 ;
14336 else if (sec == NULL || sec->owner == NULL)
14337 {
14338 bfd_set_error (bfd_error_bad_value);
14339 return FALSE;
14340 }
14341 else
14342 {
14343 asection *osec;
14344
14345 osec = sec->output_section;
14346 indx = elf_section_data (osec)->dynindx;
14347
14348 if (indx == 0)
14349 {
14350 if ((osec->flags & SEC_READONLY) == 0
14351 && htab->elf.data_index_section != NULL)
14352 osec = htab->elf.data_index_section;
14353 else
14354 osec = htab->elf.text_index_section;
14355 indx = elf_section_data (osec)->dynindx;
14356 }
14357 BFD_ASSERT (indx != 0);
14358
14359 /* We are turning this relocation into one
14360 against a section symbol, so subtract out
14361 the output section's address but not the
14362 offset of the input section in the output
14363 section. */
14364 outrel.r_addend -= osec->vma;
14365 }
14366
14367 outrel.r_info = ELF64_R_INFO (indx, r_type);
14368 }
14369 }
14370
14371 sreloc = elf_section_data (input_section)->sreloc;
14372 if (h != NULL
14373 ? h->elf.type == STT_GNU_IFUNC
14374 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
14375 sreloc = htab->elf.irelplt;
14376 if (sreloc == NULL)
14377 abort ();
14378
14379 if (sreloc->reloc_count * sizeof (Elf64_External_Rela)
14380 >= sreloc->size)
14381 abort ();
14382 loc = sreloc->contents;
14383 loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
14384 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
14385
14386 /* If this reloc is against an external symbol, it will
14387 be computed at runtime, so there's no need to do
14388 anything now. However, for the sake of prelink ensure
14389 that the section contents are a known value. */
14390 if (! relocate)
14391 {
14392 unresolved_reloc = FALSE;
14393 /* The value chosen here is quite arbitrary as ld.so
14394 ignores section contents except for the special
14395 case of .opd where the contents might be accessed
14396 before relocation. Choose zero, as that won't
14397 cause reloc overflow. */
14398 relocation = 0;
14399 addend = 0;
14400 /* Use *r_offset == r_addend for R_PPC64_ADDR64 relocs
14401 to improve backward compatibility with older
14402 versions of ld. */
14403 if (r_type == R_PPC64_ADDR64)
14404 addend = outrel.r_addend;
14405 /* Adjust pc_relative relocs to have zero in *r_offset. */
14406 else if (ppc64_elf_howto_table[r_type]->pc_relative)
14407 addend = (input_section->output_section->vma
14408 + input_section->output_offset
14409 + rel->r_offset);
14410 }
14411 }
14412 break;
14413
14414 case R_PPC64_COPY:
14415 case R_PPC64_GLOB_DAT:
14416 case R_PPC64_JMP_SLOT:
14417 case R_PPC64_JMP_IREL:
14418 case R_PPC64_RELATIVE:
14419 /* We shouldn't ever see these dynamic relocs in relocatable
14420 files. */
14421 /* Fall through. */
14422
14423 case R_PPC64_PLTGOT16:
14424 case R_PPC64_PLTGOT16_DS:
14425 case R_PPC64_PLTGOT16_HA:
14426 case R_PPC64_PLTGOT16_HI:
14427 case R_PPC64_PLTGOT16_LO:
14428 case R_PPC64_PLTGOT16_LO_DS:
14429 case R_PPC64_PLTREL32:
14430 case R_PPC64_PLTREL64:
14431 /* These ones haven't been implemented yet. */
14432
14433 info->callbacks->einfo
14434 (_("%P: %B: %s is not supported for `%T'\n"),
14435 input_bfd,
14436 ppc64_elf_howto_table[r_type]->name, sym_name);
14437
14438 bfd_set_error (bfd_error_invalid_operation);
14439 ret = FALSE;
14440 continue;
14441 }
14442
14443 /* Multi-instruction sequences that access the TOC can be
14444 optimized, eg. addis ra,r2,0; addi rb,ra,x;
14445 to nop; addi rb,r2,x; */
14446 switch (r_type)
14447 {
14448 default:
14449 break;
14450
14451 case R_PPC64_GOT_TLSLD16_HI:
14452 case R_PPC64_GOT_TLSGD16_HI:
14453 case R_PPC64_GOT_TPREL16_HI:
14454 case R_PPC64_GOT_DTPREL16_HI:
14455 case R_PPC64_GOT16_HI:
14456 case R_PPC64_TOC16_HI:
14457 /* These relocs would only be useful if building up an
14458 offset to later add to r2, perhaps in an indexed
14459 addressing mode instruction. Don't try to optimize.
14460 Unfortunately, the possibility of someone building up an
14461 offset like this or even with the HA relocs, means that
14462 we need to check the high insn when optimizing the low
14463 insn. */
14464 break;
14465
14466 case R_PPC64_GOT_TLSLD16_HA:
14467 case R_PPC64_GOT_TLSGD16_HA:
14468 case R_PPC64_GOT_TPREL16_HA:
14469 case R_PPC64_GOT_DTPREL16_HA:
14470 case R_PPC64_GOT16_HA:
14471 case R_PPC64_TOC16_HA:
14472 if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
14473 && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
14474 {
14475 bfd_byte *p = contents + (rel->r_offset & ~3);
14476 bfd_put_32 (input_bfd, NOP, p);
14477 }
14478 break;
14479
14480 case R_PPC64_GOT_TLSLD16_LO:
14481 case R_PPC64_GOT_TLSGD16_LO:
14482 case R_PPC64_GOT_TPREL16_LO_DS:
14483 case R_PPC64_GOT_DTPREL16_LO_DS:
14484 case R_PPC64_GOT16_LO:
14485 case R_PPC64_GOT16_LO_DS:
14486 case R_PPC64_TOC16_LO:
14487 case R_PPC64_TOC16_LO_DS:
14488 if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
14489 && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
14490 {
14491 bfd_byte *p = contents + (rel->r_offset & ~3);
14492 insn = bfd_get_32 (input_bfd, p);
14493 if ((insn & (0x3f << 26)) == 12u << 26 /* addic */)
14494 {
14495 /* Transform addic to addi when we change reg. */
14496 insn &= ~((0x3f << 26) | (0x1f << 16));
14497 insn |= (14u << 26) | (2 << 16);
14498 }
14499 else
14500 {
14501 insn &= ~(0x1f << 16);
14502 insn |= 2 << 16;
14503 }
14504 bfd_put_32 (input_bfd, insn, p);
14505 }
14506 break;
14507 }
14508
14509 /* Do any further special processing. */
14510 switch (r_type)
14511 {
14512 default:
14513 break;
14514
14515 case R_PPC64_REL16_HA:
14516 case R_PPC64_ADDR16_HA:
14517 case R_PPC64_ADDR16_HIGHA:
14518 case R_PPC64_ADDR16_HIGHERA:
14519 case R_PPC64_ADDR16_HIGHESTA:
14520 case R_PPC64_TOC16_HA:
14521 case R_PPC64_SECTOFF_HA:
14522 case R_PPC64_TPREL16_HA:
14523 case R_PPC64_TPREL16_HIGHA:
14524 case R_PPC64_TPREL16_HIGHERA:
14525 case R_PPC64_TPREL16_HIGHESTA:
14526 case R_PPC64_DTPREL16_HA:
14527 case R_PPC64_DTPREL16_HIGHA:
14528 case R_PPC64_DTPREL16_HIGHERA:
14529 case R_PPC64_DTPREL16_HIGHESTA:
14530 /* It's just possible that this symbol is a weak symbol
14531 that's not actually defined anywhere. In that case,
14532 'sec' would be NULL, and we should leave the symbol
14533 alone (it will be set to zero elsewhere in the link). */
14534 if (sec == NULL)
14535 break;
14536 /* Fall thru */
14537
14538 case R_PPC64_GOT16_HA:
14539 case R_PPC64_PLTGOT16_HA:
14540 case R_PPC64_PLT16_HA:
14541 case R_PPC64_GOT_TLSGD16_HA:
14542 case R_PPC64_GOT_TLSLD16_HA:
14543 case R_PPC64_GOT_TPREL16_HA:
14544 case R_PPC64_GOT_DTPREL16_HA:
14545 /* Add 0x10000 if sign bit in 0:15 is set.
14546 Bits 0:15 are not used. */
14547 addend += 0x8000;
14548 break;
14549
14550 case R_PPC64_ADDR16_DS:
14551 case R_PPC64_ADDR16_LO_DS:
14552 case R_PPC64_GOT16_DS:
14553 case R_PPC64_GOT16_LO_DS:
14554 case R_PPC64_PLT16_LO_DS:
14555 case R_PPC64_SECTOFF_DS:
14556 case R_PPC64_SECTOFF_LO_DS:
14557 case R_PPC64_TOC16_DS:
14558 case R_PPC64_TOC16_LO_DS:
14559 case R_PPC64_PLTGOT16_DS:
14560 case R_PPC64_PLTGOT16_LO_DS:
14561 case R_PPC64_GOT_TPREL16_DS:
14562 case R_PPC64_GOT_TPREL16_LO_DS:
14563 case R_PPC64_GOT_DTPREL16_DS:
14564 case R_PPC64_GOT_DTPREL16_LO_DS:
14565 case R_PPC64_TPREL16_DS:
14566 case R_PPC64_TPREL16_LO_DS:
14567 case R_PPC64_DTPREL16_DS:
14568 case R_PPC64_DTPREL16_LO_DS:
14569 insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
14570 mask = 3;
14571 /* If this reloc is against an lq insn, then the value must be
14572 a multiple of 16. This is somewhat of a hack, but the
14573 "correct" way to do this by defining _DQ forms of all the
14574 _DS relocs bloats all reloc switches in this file. It
14575 doesn't seem to make much sense to use any of these relocs
14576 in data, so testing the insn should be safe. */
14577 if ((insn & (0x3f << 26)) == (56u << 26))
14578 mask = 15;
14579 if (((relocation + addend) & mask) != 0)
14580 {
14581 info->callbacks->einfo
14582 (_("%P: %H: error: %s not a multiple of %u\n"),
14583 input_bfd, input_section, rel->r_offset,
14584 ppc64_elf_howto_table[r_type]->name,
14585 mask + 1);
14586 bfd_set_error (bfd_error_bad_value);
14587 ret = FALSE;
14588 continue;
14589 }
14590 break;
14591 }
14592
14593 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
14594 because such sections are not SEC_ALLOC and thus ld.so will
14595 not process them. */
14596 if (unresolved_reloc
14597 && !((input_section->flags & SEC_DEBUGGING) != 0
14598 && h->elf.def_dynamic)
14599 && _bfd_elf_section_offset (output_bfd, info, input_section,
14600 rel->r_offset) != (bfd_vma) -1)
14601 {
14602 info->callbacks->einfo
14603 (_("%P: %H: unresolvable %s against `%T'\n"),
14604 input_bfd, input_section, rel->r_offset,
14605 ppc64_elf_howto_table[(int) r_type]->name,
14606 h->elf.root.root.string);
14607 ret = FALSE;
14608 }
14609
14610 r = _bfd_final_link_relocate (ppc64_elf_howto_table[(int) r_type],
14611 input_bfd,
14612 input_section,
14613 contents,
14614 rel->r_offset,
14615 relocation,
14616 addend);
14617
14618 if (r != bfd_reloc_ok)
14619 {
14620 char *more_info = NULL;
14621 const char *reloc_name = ppc64_elf_howto_table[r_type]->name;
14622
14623 if (reloc_dest != DEST_NORMAL)
14624 {
14625 more_info = bfd_malloc (strlen (reloc_name) + 8);
14626 if (more_info != NULL)
14627 {
14628 strcpy (more_info, reloc_name);
14629 strcat (more_info, (reloc_dest == DEST_OPD
14630 ? " (OPD)" : " (stub)"));
14631 reloc_name = more_info;
14632 }
14633 }
14634
14635 if (r == bfd_reloc_overflow)
14636 {
14637 if (warned)
14638 continue;
14639 if (h != NULL
14640 && h->elf.root.type == bfd_link_hash_undefweak
14641 && ppc64_elf_howto_table[r_type]->pc_relative)
14642 {
14643 /* Assume this is a call protected by other code that
14644 detects the symbol is undefined. If this is the case,
14645 we can safely ignore the overflow. If not, the
14646 program is hosed anyway, and a little warning isn't
14647 going to help. */
14648
14649 continue;
14650 }
14651
14652 if (!((*info->callbacks->reloc_overflow)
14653 (info, &h->elf.root, sym_name,
14654 reloc_name, orig_rel.r_addend,
14655 input_bfd, input_section, rel->r_offset)))
14656 return FALSE;
14657 }
14658 else
14659 {
14660 info->callbacks->einfo
14661 (_("%P: %H: %s against `%T': error %d\n"),
14662 input_bfd, input_section, rel->r_offset,
14663 reloc_name, sym_name, (int) r);
14664 ret = FALSE;
14665 }
14666 if (more_info != NULL)
14667 free (more_info);
14668 }
14669 }
14670
14671 /* If we're emitting relocations, then shortly after this function
14672 returns, reloc offsets and addends for this section will be
14673 adjusted. Worse, reloc symbol indices will be for the output
14674 file rather than the input. Save a copy of the relocs for
14675 opd_entry_value. */
14676 if (is_opd && (info->emitrelocations || info->relocatable))
14677 {
14678 bfd_size_type amt;
14679 amt = input_section->reloc_count * sizeof (Elf_Internal_Rela);
14680 rel = bfd_alloc (input_bfd, amt);
14681 BFD_ASSERT (ppc64_elf_tdata (input_bfd)->opd.relocs == NULL);
14682 ppc64_elf_tdata (input_bfd)->opd.relocs = rel;
14683 if (rel == NULL)
14684 return FALSE;
14685 memcpy (rel, relocs, amt);
14686 }
14687 return ret;
14688 }
14689
14690 /* Adjust the value of any local symbols in opd sections. */
14691
14692 static int
14693 ppc64_elf_output_symbol_hook (struct bfd_link_info *info,
14694 const char *name ATTRIBUTE_UNUSED,
14695 Elf_Internal_Sym *elfsym,
14696 asection *input_sec,
14697 struct elf_link_hash_entry *h)
14698 {
14699 struct _opd_sec_data *opd;
14700 long adjust;
14701 bfd_vma value;
14702
14703 if (h != NULL)
14704 return 1;
14705
14706 opd = get_opd_info (input_sec);
14707 if (opd == NULL || opd->adjust == NULL)
14708 return 1;
14709
14710 value = elfsym->st_value - input_sec->output_offset;
14711 if (!info->relocatable)
14712 value -= input_sec->output_section->vma;
14713
14714 adjust = opd->adjust[value / 8];
14715 if (adjust == -1)
14716 return 2;
14717
14718 elfsym->st_value += adjust;
14719 return 1;
14720 }
14721
14722 /* Finish up dynamic symbol handling. We set the contents of various
14723 dynamic sections here. */
14724
14725 static bfd_boolean
14726 ppc64_elf_finish_dynamic_symbol (bfd *output_bfd,
14727 struct bfd_link_info *info,
14728 struct elf_link_hash_entry *h,
14729 Elf_Internal_Sym *sym ATTRIBUTE_UNUSED)
14730 {
14731 struct ppc_link_hash_table *htab;
14732 struct plt_entry *ent;
14733 Elf_Internal_Rela rela;
14734 bfd_byte *loc;
14735
14736 htab = ppc_hash_table (info);
14737 if (htab == NULL)
14738 return FALSE;
14739
14740 for (ent = h->plt.plist; ent != NULL; ent = ent->next)
14741 if (ent->plt.offset != (bfd_vma) -1)
14742 {
14743 /* This symbol has an entry in the procedure linkage
14744 table. Set it up. */
14745 if (!htab->elf.dynamic_sections_created
14746 || h->dynindx == -1)
14747 {
14748 BFD_ASSERT (h->type == STT_GNU_IFUNC
14749 && h->def_regular
14750 && (h->root.type == bfd_link_hash_defined
14751 || h->root.type == bfd_link_hash_defweak));
14752 rela.r_offset = (htab->elf.iplt->output_section->vma
14753 + htab->elf.iplt->output_offset
14754 + ent->plt.offset);
14755 if (htab->opd_abi)
14756 rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
14757 else
14758 rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
14759 rela.r_addend = (h->root.u.def.value
14760 + h->root.u.def.section->output_offset
14761 + h->root.u.def.section->output_section->vma
14762 + ent->addend);
14763 loc = (htab->elf.irelplt->contents
14764 + (htab->elf.irelplt->reloc_count++
14765 * sizeof (Elf64_External_Rela)));
14766 }
14767 else
14768 {
14769 rela.r_offset = (htab->elf.splt->output_section->vma
14770 + htab->elf.splt->output_offset
14771 + ent->plt.offset);
14772 rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_JMP_SLOT);
14773 rela.r_addend = ent->addend;
14774 loc = (htab->elf.srelplt->contents
14775 + ((ent->plt.offset - PLT_INITIAL_ENTRY_SIZE (htab))
14776 / PLT_ENTRY_SIZE (htab) * sizeof (Elf64_External_Rela)));
14777 }
14778 bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
14779
14780 if (!htab->opd_abi)
14781 {
14782 if (!h->def_regular)
14783 {
14784 /* Mark the symbol as undefined, rather than as
14785 defined in glink. Leave the value if there were
14786 any relocations where pointer equality matters
14787 (this is a clue for the dynamic linker, to make
14788 function pointer comparisons work between an
14789 application and shared library), otherwise set it
14790 to zero. */
14791 sym->st_shndx = SHN_UNDEF;
14792 if (!h->pointer_equality_needed)
14793 sym->st_value = 0;
14794 else if (!h->ref_regular_nonweak)
14795 {
14796 /* This breaks function pointer comparisons, but
14797 that is better than breaking tests for a NULL
14798 function pointer. */
14799 sym->st_value = 0;
14800 }
14801 }
14802 }
14803 }
14804
14805 if (h->needs_copy)
14806 {
14807 /* This symbol needs a copy reloc. Set it up. */
14808
14809 if (h->dynindx == -1
14810 || (h->root.type != bfd_link_hash_defined
14811 && h->root.type != bfd_link_hash_defweak)
14812 || htab->relbss == NULL)
14813 abort ();
14814
14815 rela.r_offset = (h->root.u.def.value
14816 + h->root.u.def.section->output_section->vma
14817 + h->root.u.def.section->output_offset);
14818 rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_COPY);
14819 rela.r_addend = 0;
14820 loc = htab->relbss->contents;
14821 loc += htab->relbss->reloc_count++ * sizeof (Elf64_External_Rela);
14822 bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
14823 }
14824
14825 return TRUE;
14826 }
14827
14828 /* Used to decide how to sort relocs in an optimal manner for the
14829 dynamic linker, before writing them out. */
14830
14831 static enum elf_reloc_type_class
14832 ppc64_elf_reloc_type_class (const struct bfd_link_info *info,
14833 const asection *rel_sec,
14834 const Elf_Internal_Rela *rela)
14835 {
14836 enum elf_ppc64_reloc_type r_type;
14837 struct ppc_link_hash_table *htab = ppc_hash_table (info);
14838
14839 if (rel_sec == htab->elf.irelplt)
14840 return reloc_class_ifunc;
14841
14842 r_type = ELF64_R_TYPE (rela->r_info);
14843 switch (r_type)
14844 {
14845 case R_PPC64_RELATIVE:
14846 return reloc_class_relative;
14847 case R_PPC64_JMP_SLOT:
14848 return reloc_class_plt;
14849 case R_PPC64_COPY:
14850 return reloc_class_copy;
14851 default:
14852 return reloc_class_normal;
14853 }
14854 }
14855
14856 /* Finish up the dynamic sections. */
14857
14858 static bfd_boolean
14859 ppc64_elf_finish_dynamic_sections (bfd *output_bfd,
14860 struct bfd_link_info *info)
14861 {
14862 struct ppc_link_hash_table *htab;
14863 bfd *dynobj;
14864 asection *sdyn;
14865
14866 htab = ppc_hash_table (info);
14867 if (htab == NULL)
14868 return FALSE;
14869
14870 dynobj = htab->elf.dynobj;
14871 sdyn = bfd_get_linker_section (dynobj, ".dynamic");
14872
14873 if (htab->elf.dynamic_sections_created)
14874 {
14875 Elf64_External_Dyn *dyncon, *dynconend;
14876
14877 if (sdyn == NULL || htab->elf.sgot == NULL)
14878 abort ();
14879
14880 dyncon = (Elf64_External_Dyn *) sdyn->contents;
14881 dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
14882 for (; dyncon < dynconend; dyncon++)
14883 {
14884 Elf_Internal_Dyn dyn;
14885 asection *s;
14886
14887 bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
14888
14889 switch (dyn.d_tag)
14890 {
14891 default:
14892 continue;
14893
14894 case DT_PPC64_GLINK:
14895 s = htab->glink;
14896 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
14897 /* We stupidly defined DT_PPC64_GLINK to be the start
14898 of glink rather than the first entry point, which is
14899 what ld.so needs, and now have a bigger stub to
14900 support automatic multiple TOCs. */
14901 dyn.d_un.d_ptr += GLINK_CALL_STUB_SIZE - 8 * 4;
14902 break;
14903
14904 case DT_PPC64_OPD:
14905 s = bfd_get_section_by_name (output_bfd, ".opd");
14906 if (s == NULL)
14907 continue;
14908 dyn.d_un.d_ptr = s->vma;
14909 break;
14910
14911 case DT_PPC64_OPT:
14912 if (htab->do_multi_toc && htab->multi_toc_needed)
14913 dyn.d_un.d_val |= PPC64_OPT_MULTI_TOC;
14914 break;
14915
14916 case DT_PPC64_OPDSZ:
14917 s = bfd_get_section_by_name (output_bfd, ".opd");
14918 if (s == NULL)
14919 continue;
14920 dyn.d_un.d_val = s->size;
14921 break;
14922
14923 case DT_PLTGOT:
14924 s = htab->elf.splt;
14925 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
14926 break;
14927
14928 case DT_JMPREL:
14929 s = htab->elf.srelplt;
14930 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
14931 break;
14932
14933 case DT_PLTRELSZ:
14934 dyn.d_un.d_val = htab->elf.srelplt->size;
14935 break;
14936
14937 case DT_RELASZ:
14938 /* Don't count procedure linkage table relocs in the
14939 overall reloc count. */
14940 s = htab->elf.srelplt;
14941 if (s == NULL)
14942 continue;
14943 dyn.d_un.d_val -= s->size;
14944 break;
14945
14946 case DT_RELA:
14947 /* We may not be using the standard ELF linker script.
14948 If .rela.plt is the first .rela section, we adjust
14949 DT_RELA to not include it. */
14950 s = htab->elf.srelplt;
14951 if (s == NULL)
14952 continue;
14953 if (dyn.d_un.d_ptr != s->output_section->vma + s->output_offset)
14954 continue;
14955 dyn.d_un.d_ptr += s->size;
14956 break;
14957 }
14958
14959 bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
14960 }
14961 }
14962
14963 if (htab->elf.sgot != NULL && htab->elf.sgot->size != 0)
14964 {
14965 /* Fill in the first entry in the global offset table.
14966 We use it to hold the link-time TOCbase. */
14967 bfd_put_64 (output_bfd,
14968 elf_gp (output_bfd) + TOC_BASE_OFF,
14969 htab->elf.sgot->contents);
14970
14971 /* Set .got entry size. */
14972 elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize = 8;
14973 }
14974
14975 if (htab->elf.splt != NULL && htab->elf.splt->size != 0)
14976 {
14977 /* Set .plt entry size. */
14978 elf_section_data (htab->elf.splt->output_section)->this_hdr.sh_entsize
14979 = PLT_ENTRY_SIZE (htab);
14980 }
14981
14982 /* brlt is SEC_LINKER_CREATED, so we need to write out relocs for
14983 brlt ourselves if emitrelocations. */
14984 if (htab->brlt != NULL
14985 && htab->brlt->reloc_count != 0
14986 && !_bfd_elf_link_output_relocs (output_bfd,
14987 htab->brlt,
14988 elf_section_data (htab->brlt)->rela.hdr,
14989 elf_section_data (htab->brlt)->relocs,
14990 NULL))
14991 return FALSE;
14992
14993 if (htab->glink != NULL
14994 && htab->glink->reloc_count != 0
14995 && !_bfd_elf_link_output_relocs (output_bfd,
14996 htab->glink,
14997 elf_section_data (htab->glink)->rela.hdr,
14998 elf_section_data (htab->glink)->relocs,
14999 NULL))
15000 return FALSE;
15001
15002
15003 if (htab->glink_eh_frame != NULL
15004 && htab->glink_eh_frame->sec_info_type == SEC_INFO_TYPE_EH_FRAME
15005 && !_bfd_elf_write_section_eh_frame (output_bfd, info,
15006 htab->glink_eh_frame,
15007 htab->glink_eh_frame->contents))
15008 return FALSE;
15009
15010 /* We need to handle writing out multiple GOT sections ourselves,
15011 since we didn't add them to DYNOBJ. We know dynobj is the first
15012 bfd. */
15013 while ((dynobj = dynobj->link_next) != NULL)
15014 {
15015 asection *s;
15016
15017 if (!is_ppc64_elf (dynobj))
15018 continue;
15019
15020 s = ppc64_elf_tdata (dynobj)->got;
15021 if (s != NULL
15022 && s->size != 0
15023 && s->output_section != bfd_abs_section_ptr
15024 && !bfd_set_section_contents (output_bfd, s->output_section,
15025 s->contents, s->output_offset,
15026 s->size))
15027 return FALSE;
15028 s = ppc64_elf_tdata (dynobj)->relgot;
15029 if (s != NULL
15030 && s->size != 0
15031 && s->output_section != bfd_abs_section_ptr
15032 && !bfd_set_section_contents (output_bfd, s->output_section,
15033 s->contents, s->output_offset,
15034 s->size))
15035 return FALSE;
15036 }
15037
15038 return TRUE;
15039 }
15040
15041 #include "elf64-target.h"
15042
15043 /* FreeBSD support */
15044
15045 #undef TARGET_LITTLE_SYM
15046 #undef TARGET_LITTLE_NAME
15047
15048 #undef TARGET_BIG_SYM
15049 #define TARGET_BIG_SYM bfd_elf64_powerpc_freebsd_vec
15050 #undef TARGET_BIG_NAME
15051 #define TARGET_BIG_NAME "elf64-powerpc-freebsd"
15052
15053 #undef ELF_OSABI
15054 #define ELF_OSABI ELFOSABI_FREEBSD
15055
15056 #undef elf64_bed
15057 #define elf64_bed elf64_powerpc_fbsd_bed
15058
15059 #include "elf64-target.h"
15060
GDB Binutils - Deliverables
This page took 0.342422 seconds and 4 git commands to generate.