?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
2009-03-03 Tristan Gingold <gingold@adacore.com>
[binutils.git] / bfd / elf64-ppc.c
blob703a2b34cbabd160b615d421954b7825f05b0457
1 /* PowerPC64-specific support for 64-bit ELF.
2 Copyright 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008,
3 2009 Free Software Foundation, Inc.
4 Written by Linus Nordberg, Swox AB <info@swox.com>,
5 based on elf32-ppc.c by Ian Lance Taylor.
6 Largely rewritten by Alan Modra <amodra@bigpond.net.au>
7
8 This file is part of BFD, the Binary File Descriptor library.
9
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3 of the License, or
13 (at your option) any later version.
14
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
19
20 You should have received a copy of the GNU General Public License along
21 with this program; if not, write to the Free Software Foundation, Inc.,
22 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */
23
24
25 /* The 64-bit PowerPC ELF ABI may be found at
26 http://www.linuxbase.org/spec/ELF/ppc64/PPC-elf64abi.txt, and
27 http://www.linuxbase.org/spec/ELF/ppc64/spec/book1.html */
28
29 #include "sysdep.h"
30 #include <stdarg.h>
31 #include "bfd.h"
32 #include "bfdlink.h"
33 #include "libbfd.h"
34 #include "elf-bfd.h"
35 #include "elf/ppc64.h"
36 #include "elf64-ppc.h"
37
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 *);
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_MACHINE_CODE EM_PPC64
65 #define ELF_MAXPAGESIZE 0x10000
66 #define ELF_COMMONPAGESIZE 0x1000
67 #define elf_info_to_howto ppc64_elf_info_to_howto
68
69 #define elf_backend_want_got_sym 0
70 #define elf_backend_want_plt_sym 0
71 #define elf_backend_plt_alignment 3
72 #define elf_backend_plt_not_loaded 1
73 #define elf_backend_got_header_size 8
74 #define elf_backend_can_gc_sections 1
75 #define elf_backend_can_refcount 1
76 #define elf_backend_rela_normal 1
77 #define elf_backend_default_execstack 0
78
79 #define bfd_elf64_mkobject ppc64_elf_mkobject
80 #define bfd_elf64_bfd_reloc_type_lookup ppc64_elf_reloc_type_lookup
81 #define bfd_elf64_bfd_reloc_name_lookup ppc64_elf_reloc_name_lookup
82 #define bfd_elf64_bfd_merge_private_bfd_data ppc64_elf_merge_private_bfd_data
83 #define bfd_elf64_new_section_hook ppc64_elf_new_section_hook
84 #define bfd_elf64_bfd_link_hash_table_create ppc64_elf_link_hash_table_create
85 #define bfd_elf64_bfd_link_hash_table_free ppc64_elf_link_hash_table_free
86 #define bfd_elf64_get_synthetic_symtab ppc64_elf_get_synthetic_symtab
87
88 #define elf_backend_object_p ppc64_elf_object_p
89 #define elf_backend_grok_prstatus ppc64_elf_grok_prstatus
90 #define elf_backend_grok_psinfo ppc64_elf_grok_psinfo
91 #define elf_backend_write_core_note ppc64_elf_write_core_note
92 #define elf_backend_create_dynamic_sections ppc64_elf_create_dynamic_sections
93 #define elf_backend_copy_indirect_symbol ppc64_elf_copy_indirect_symbol
94 #define elf_backend_add_symbol_hook ppc64_elf_add_symbol_hook
95 #define elf_backend_check_directives ppc64_elf_process_dot_syms
96 #define elf_backend_as_needed_cleanup ppc64_elf_as_needed_cleanup
97 #define elf_backend_archive_symbol_lookup ppc64_elf_archive_symbol_lookup
98 #define elf_backend_check_relocs ppc64_elf_check_relocs
99 #define elf_backend_gc_keep ppc64_elf_gc_keep
100 #define elf_backend_gc_mark_dynamic_ref ppc64_elf_gc_mark_dynamic_ref
101 #define elf_backend_gc_mark_hook ppc64_elf_gc_mark_hook
102 #define elf_backend_gc_sweep_hook ppc64_elf_gc_sweep_hook
103 #define elf_backend_adjust_dynamic_symbol ppc64_elf_adjust_dynamic_symbol
104 #define elf_backend_hide_symbol ppc64_elf_hide_symbol
105 #define elf_backend_always_size_sections ppc64_elf_func_desc_adjust
106 #define elf_backend_size_dynamic_sections ppc64_elf_size_dynamic_sections
107 #define elf_backend_init_index_section _bfd_elf_init_2_index_sections
108 #define elf_backend_action_discarded ppc64_elf_action_discarded
109 #define elf_backend_relocate_section ppc64_elf_relocate_section
110 #define elf_backend_finish_dynamic_symbol ppc64_elf_finish_dynamic_symbol
111 #define elf_backend_reloc_type_class ppc64_elf_reloc_type_class
112 #define elf_backend_finish_dynamic_sections ppc64_elf_finish_dynamic_sections
113 #define elf_backend_link_output_symbol_hook ppc64_elf_output_symbol_hook
114 #define elf_backend_special_sections ppc64_elf_special_sections
115
116 /* The name of the dynamic interpreter. This is put in the .interp
117 section. */
118 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
119
120 /* The size in bytes of an entry in the procedure linkage table. */
121 #define PLT_ENTRY_SIZE 24
122
123 /* The initial size of the plt reserved for the dynamic linker. */
124 #define PLT_INITIAL_ENTRY_SIZE PLT_ENTRY_SIZE
125
126 /* TOC base pointers offset from start of TOC. */
127 #define TOC_BASE_OFF 0x8000
128
129 /* Offset of tp and dtp pointers from start of TLS block. */
130 #define TP_OFFSET 0x7000
131 #define DTP_OFFSET 0x8000
132
133 /* .plt call stub instructions. The normal stub is like this, but
134 sometimes the .plt entry crosses a 64k boundary and we need to
135 insert an addi to adjust r12. */
136 #define PLT_CALL_STUB_SIZE (7*4)
137 #define ADDIS_R12_R2 0x3d820000 /* addis %r12,%r2,xxx@ha */
138 #define STD_R2_40R1 0xf8410028 /* std %r2,40(%r1) */
139 #define LD_R11_0R12 0xe96c0000 /* ld %r11,xxx+0@l(%r12) */
140 #define MTCTR_R11 0x7d6903a6 /* mtctr %r11 */
141 #define LD_R2_0R12 0xe84c0000 /* ld %r2,xxx+8@l(%r12) */
142 /* ld %r11,xxx+16@l(%r12) */
143 #define BCTR 0x4e800420 /* bctr */
144
145
146 #define ADDIS_R12_R12 0x3d8c0000 /* addis %r12,%r12,off@ha */
147 #define ADDI_R12_R12 0x398c0000 /* addi %r12,%r12,off@l */
148 #define ADDIS_R2_R2 0x3c420000 /* addis %r2,%r2,off@ha */
149 #define ADDI_R2_R2 0x38420000 /* addi %r2,%r2,off@l */
150
151 #define LD_R11_0R2 0xe9620000 /* ld %r11,xxx+0(%r2) */
152 #define LD_R2_0R2 0xe8420000 /* ld %r2,xxx+0(%r2) */
153
154 #define LD_R2_40R1 0xe8410028 /* ld %r2,40(%r1) */
155
156 /* glink call stub instructions. We enter with the index in R0. */
157 #define GLINK_CALL_STUB_SIZE (16*4)
158 /* 0: */
159 /* .quad plt0-1f */
160 /* __glink: */
161 #define MFLR_R12 0x7d8802a6 /* mflr %12 */
162 #define BCL_20_31 0x429f0005 /* bcl 20,31,1f */
163 /* 1: */
164 #define MFLR_R11 0x7d6802a6 /* mflr %11 */
165 #define LD_R2_M16R11 0xe84bfff0 /* ld %2,(0b-1b)(%11) */
166 #define MTLR_R12 0x7d8803a6 /* mtlr %12 */
167 #define ADD_R12_R2_R11 0x7d825a14 /* add %12,%2,%11 */
168 /* ld %11,0(%12) */
169 /* ld %2,8(%12) */
170 /* mtctr %11 */
171 /* ld %11,16(%12) */
172 /* bctr */
173
174 /* Pad with this. */
175 #define NOP 0x60000000
176
177 /* Some other nops. */
178 #define CROR_151515 0x4def7b82
179 #define CROR_313131 0x4ffffb82
180
181 /* .glink entries for the first 32k functions are two instructions. */
182 #define LI_R0_0 0x38000000 /* li %r0,0 */
183 #define B_DOT 0x48000000 /* b . */
184
185 /* After that, we need two instructions to load the index, followed by
186 a branch. */
187 #define LIS_R0_0 0x3c000000 /* lis %r0,0 */
188 #define ORI_R0_R0_0 0x60000000 /* ori %r0,%r0,0 */
189
190 /* Instructions used by the save and restore reg functions. */
191 #define STD_R0_0R1 0xf8010000 /* std %r0,0(%r1) */
192 #define STD_R0_0R12 0xf80c0000 /* std %r0,0(%r12) */
193 #define LD_R0_0R1 0xe8010000 /* ld %r0,0(%r1) */
194 #define LD_R0_0R12 0xe80c0000 /* ld %r0,0(%r12) */
195 #define STFD_FR0_0R1 0xd8010000 /* stfd %fr0,0(%r1) */
196 #define LFD_FR0_0R1 0xc8010000 /* lfd %fr0,0(%r1) */
197 #define LI_R12_0 0x39800000 /* li %r12,0 */
198 #define STVX_VR0_R12_R0 0x7c0c01ce /* stvx %v0,%r12,%r0 */
199 #define LVX_VR0_R12_R0 0x7c0c00ce /* lvx %v0,%r12,%r0 */
200 #define MTLR_R0 0x7c0803a6 /* mtlr %r0 */
201 #define BLR 0x4e800020 /* blr */
202
203 /* Since .opd is an array of descriptors and each entry will end up
204 with identical R_PPC64_RELATIVE relocs, there is really no need to
205 propagate .opd relocs; The dynamic linker should be taught to
206 relocate .opd without reloc entries. */
207 #ifndef NO_OPD_RELOCS
208 #define NO_OPD_RELOCS 0
209 #endif
210 \f
211 #define ONES(n) (((bfd_vma) 1 << ((n) - 1) << 1) - 1)
212
213 /* Relocation HOWTO's. */
214 static reloc_howto_type *ppc64_elf_howto_table[(int) R_PPC64_max];
215
216 static reloc_howto_type ppc64_elf_howto_raw[] = {
217 /* This reloc does nothing. */
218 HOWTO (R_PPC64_NONE, /* type */
219 0, /* rightshift */
220 2, /* size (0 = byte, 1 = short, 2 = long) */
221 32, /* bitsize */
222 FALSE, /* pc_relative */
223 0, /* bitpos */
224 complain_overflow_dont, /* complain_on_overflow */
225 bfd_elf_generic_reloc, /* special_function */
226 "R_PPC64_NONE", /* name */
227 FALSE, /* partial_inplace */
228 0, /* src_mask */
229 0, /* dst_mask */
230 FALSE), /* pcrel_offset */
231
232 /* A standard 32 bit relocation. */
233 HOWTO (R_PPC64_ADDR32, /* type */
234 0, /* rightshift */
235 2, /* size (0 = byte, 1 = short, 2 = long) */
236 32, /* bitsize */
237 FALSE, /* pc_relative */
238 0, /* bitpos */
239 complain_overflow_bitfield, /* complain_on_overflow */
240 bfd_elf_generic_reloc, /* special_function */
241 "R_PPC64_ADDR32", /* name */
242 FALSE, /* partial_inplace */
243 0, /* src_mask */
244 0xffffffff, /* dst_mask */
245 FALSE), /* pcrel_offset */
246
247 /* An absolute 26 bit branch; the lower two bits must be zero.
248 FIXME: we don't check that, we just clear them. */
249 HOWTO (R_PPC64_ADDR24, /* type */
250 0, /* rightshift */
251 2, /* size (0 = byte, 1 = short, 2 = long) */
252 26, /* bitsize */
253 FALSE, /* pc_relative */
254 0, /* bitpos */
255 complain_overflow_bitfield, /* complain_on_overflow */
256 bfd_elf_generic_reloc, /* special_function */
257 "R_PPC64_ADDR24", /* name */
258 FALSE, /* partial_inplace */
259 0, /* src_mask */
260 0x03fffffc, /* dst_mask */
261 FALSE), /* pcrel_offset */
262
263 /* A standard 16 bit relocation. */
264 HOWTO (R_PPC64_ADDR16, /* type */
265 0, /* rightshift */
266 1, /* size (0 = byte, 1 = short, 2 = long) */
267 16, /* bitsize */
268 FALSE, /* pc_relative */
269 0, /* bitpos */
270 complain_overflow_bitfield, /* complain_on_overflow */
271 bfd_elf_generic_reloc, /* special_function */
272 "R_PPC64_ADDR16", /* name */
273 FALSE, /* partial_inplace */
274 0, /* src_mask */
275 0xffff, /* dst_mask */
276 FALSE), /* pcrel_offset */
277
278 /* A 16 bit relocation without overflow. */
279 HOWTO (R_PPC64_ADDR16_LO, /* type */
280 0, /* rightshift */
281 1, /* size (0 = byte, 1 = short, 2 = long) */
282 16, /* bitsize */
283 FALSE, /* pc_relative */
284 0, /* bitpos */
285 complain_overflow_dont,/* complain_on_overflow */
286 bfd_elf_generic_reloc, /* special_function */
287 "R_PPC64_ADDR16_LO", /* name */
288 FALSE, /* partial_inplace */
289 0, /* src_mask */
290 0xffff, /* dst_mask */
291 FALSE), /* pcrel_offset */
292
293 /* Bits 16-31 of an address. */
294 HOWTO (R_PPC64_ADDR16_HI, /* type */
295 16, /* rightshift */
296 1, /* size (0 = byte, 1 = short, 2 = long) */
297 16, /* bitsize */
298 FALSE, /* pc_relative */
299 0, /* bitpos */
300 complain_overflow_dont, /* complain_on_overflow */
301 bfd_elf_generic_reloc, /* special_function */
302 "R_PPC64_ADDR16_HI", /* name */
303 FALSE, /* partial_inplace */
304 0, /* src_mask */
305 0xffff, /* dst_mask */
306 FALSE), /* pcrel_offset */
307
308 /* Bits 16-31 of an address, plus 1 if the contents of the low 16
309 bits, treated as a signed number, is negative. */
310 HOWTO (R_PPC64_ADDR16_HA, /* type */
311 16, /* rightshift */
312 1, /* size (0 = byte, 1 = short, 2 = long) */
313 16, /* bitsize */
314 FALSE, /* pc_relative */
315 0, /* bitpos */
316 complain_overflow_dont, /* complain_on_overflow */
317 ppc64_elf_ha_reloc, /* special_function */
318 "R_PPC64_ADDR16_HA", /* name */
319 FALSE, /* partial_inplace */
320 0, /* src_mask */
321 0xffff, /* dst_mask */
322 FALSE), /* pcrel_offset */
323
324 /* An absolute 16 bit branch; the lower two bits must be zero.
325 FIXME: we don't check that, we just clear them. */
326 HOWTO (R_PPC64_ADDR14, /* type */
327 0, /* rightshift */
328 2, /* size (0 = byte, 1 = short, 2 = long) */
329 16, /* bitsize */
330 FALSE, /* pc_relative */
331 0, /* bitpos */
332 complain_overflow_bitfield, /* complain_on_overflow */
333 ppc64_elf_branch_reloc, /* special_function */
334 "R_PPC64_ADDR14", /* name */
335 FALSE, /* partial_inplace */
336 0, /* src_mask */
337 0x0000fffc, /* dst_mask */
338 FALSE), /* pcrel_offset */
339
340 /* An absolute 16 bit branch, for which bit 10 should be set to
341 indicate that the branch is expected to be taken. The lower two
342 bits must be zero. */
343 HOWTO (R_PPC64_ADDR14_BRTAKEN, /* type */
344 0, /* rightshift */
345 2, /* size (0 = byte, 1 = short, 2 = long) */
346 16, /* bitsize */
347 FALSE, /* pc_relative */
348 0, /* bitpos */
349 complain_overflow_bitfield, /* complain_on_overflow */
350 ppc64_elf_brtaken_reloc, /* special_function */
351 "R_PPC64_ADDR14_BRTAKEN",/* name */
352 FALSE, /* partial_inplace */
353 0, /* src_mask */
354 0x0000fffc, /* dst_mask */
355 FALSE), /* pcrel_offset */
356
357 /* An absolute 16 bit branch, for which bit 10 should be set to
358 indicate that the branch is not expected to be taken. The lower
359 two bits must be zero. */
360 HOWTO (R_PPC64_ADDR14_BRNTAKEN, /* type */
361 0, /* rightshift */
362 2, /* size (0 = byte, 1 = short, 2 = long) */
363 16, /* bitsize */
364 FALSE, /* pc_relative */
365 0, /* bitpos */
366 complain_overflow_bitfield, /* complain_on_overflow */
367 ppc64_elf_brtaken_reloc, /* special_function */
368 "R_PPC64_ADDR14_BRNTAKEN",/* name */
369 FALSE, /* partial_inplace */
370 0, /* src_mask */
371 0x0000fffc, /* dst_mask */
372 FALSE), /* pcrel_offset */
373
374 /* A relative 26 bit branch; the lower two bits must be zero. */
375 HOWTO (R_PPC64_REL24, /* type */
376 0, /* rightshift */
377 2, /* size (0 = byte, 1 = short, 2 = long) */
378 26, /* bitsize */
379 TRUE, /* pc_relative */
380 0, /* bitpos */
381 complain_overflow_signed, /* complain_on_overflow */
382 ppc64_elf_branch_reloc, /* special_function */
383 "R_PPC64_REL24", /* name */
384 FALSE, /* partial_inplace */
385 0, /* src_mask */
386 0x03fffffc, /* dst_mask */
387 TRUE), /* pcrel_offset */
388
389 /* A relative 16 bit branch; the lower two bits must be zero. */
390 HOWTO (R_PPC64_REL14, /* type */
391 0, /* rightshift */
392 2, /* size (0 = byte, 1 = short, 2 = long) */
393 16, /* bitsize */
394 TRUE, /* pc_relative */
395 0, /* bitpos */
396 complain_overflow_signed, /* complain_on_overflow */
397 ppc64_elf_branch_reloc, /* special_function */
398 "R_PPC64_REL14", /* name */
399 FALSE, /* partial_inplace */
400 0, /* src_mask */
401 0x0000fffc, /* dst_mask */
402 TRUE), /* pcrel_offset */
403
404 /* A relative 16 bit branch. Bit 10 should be set to indicate that
405 the branch is expected to be taken. The lower two bits must be
406 zero. */
407 HOWTO (R_PPC64_REL14_BRTAKEN, /* type */
408 0, /* rightshift */
409 2, /* size (0 = byte, 1 = short, 2 = long) */
410 16, /* bitsize */
411 TRUE, /* pc_relative */
412 0, /* bitpos */
413 complain_overflow_signed, /* complain_on_overflow */
414 ppc64_elf_brtaken_reloc, /* special_function */
415 "R_PPC64_REL14_BRTAKEN", /* name */
416 FALSE, /* partial_inplace */
417 0, /* src_mask */
418 0x0000fffc, /* dst_mask */
419 TRUE), /* pcrel_offset */
420
421 /* A relative 16 bit branch. Bit 10 should be set to indicate that
422 the branch is not expected to be taken. The lower two bits must
423 be zero. */
424 HOWTO (R_PPC64_REL14_BRNTAKEN, /* type */
425 0, /* rightshift */
426 2, /* size (0 = byte, 1 = short, 2 = long) */
427 16, /* bitsize */
428 TRUE, /* pc_relative */
429 0, /* bitpos */
430 complain_overflow_signed, /* complain_on_overflow */
431 ppc64_elf_brtaken_reloc, /* special_function */
432 "R_PPC64_REL14_BRNTAKEN",/* name */
433 FALSE, /* partial_inplace */
434 0, /* src_mask */
435 0x0000fffc, /* dst_mask */
436 TRUE), /* pcrel_offset */
437
438 /* Like R_PPC64_ADDR16, but referring to the GOT table entry for the
439 symbol. */
440 HOWTO (R_PPC64_GOT16, /* type */
441 0, /* rightshift */
442 1, /* size (0 = byte, 1 = short, 2 = long) */
443 16, /* bitsize */
444 FALSE, /* pc_relative */
445 0, /* bitpos */
446 complain_overflow_signed, /* complain_on_overflow */
447 ppc64_elf_unhandled_reloc, /* special_function */
448 "R_PPC64_GOT16", /* name */
449 FALSE, /* partial_inplace */
450 0, /* src_mask */
451 0xffff, /* dst_mask */
452 FALSE), /* pcrel_offset */
453
454 /* Like R_PPC64_ADDR16_LO, but referring to the GOT table entry for
455 the symbol. */
456 HOWTO (R_PPC64_GOT16_LO, /* type */
457 0, /* rightshift */
458 1, /* size (0 = byte, 1 = short, 2 = long) */
459 16, /* bitsize */
460 FALSE, /* pc_relative */
461 0, /* bitpos */
462 complain_overflow_dont, /* complain_on_overflow */
463 ppc64_elf_unhandled_reloc, /* special_function */
464 "R_PPC64_GOT16_LO", /* name */
465 FALSE, /* partial_inplace */
466 0, /* src_mask */
467 0xffff, /* dst_mask */
468 FALSE), /* pcrel_offset */
469
470 /* Like R_PPC64_ADDR16_HI, but referring to the GOT table entry for
471 the symbol. */
472 HOWTO (R_PPC64_GOT16_HI, /* type */
473 16, /* rightshift */
474 1, /* size (0 = byte, 1 = short, 2 = long) */
475 16, /* bitsize */
476 FALSE, /* pc_relative */
477 0, /* bitpos */
478 complain_overflow_dont,/* complain_on_overflow */
479 ppc64_elf_unhandled_reloc, /* special_function */
480 "R_PPC64_GOT16_HI", /* name */
481 FALSE, /* partial_inplace */
482 0, /* src_mask */
483 0xffff, /* dst_mask */
484 FALSE), /* pcrel_offset */
485
486 /* Like R_PPC64_ADDR16_HA, but referring to the GOT table entry for
487 the symbol. */
488 HOWTO (R_PPC64_GOT16_HA, /* type */
489 16, /* rightshift */
490 1, /* size (0 = byte, 1 = short, 2 = long) */
491 16, /* bitsize */
492 FALSE, /* pc_relative */
493 0, /* bitpos */
494 complain_overflow_dont,/* complain_on_overflow */
495 ppc64_elf_unhandled_reloc, /* special_function */
496 "R_PPC64_GOT16_HA", /* name */
497 FALSE, /* partial_inplace */
498 0, /* src_mask */
499 0xffff, /* dst_mask */
500 FALSE), /* pcrel_offset */
501
502 /* This is used only by the dynamic linker. The symbol should exist
503 both in the object being run and in some shared library. The
504 dynamic linker copies the data addressed by the symbol from the
505 shared library into the object, because the object being
506 run has to have the data at some particular address. */
507 HOWTO (R_PPC64_COPY, /* type */
508 0, /* rightshift */
509 0, /* this one is variable size */
510 0, /* bitsize */
511 FALSE, /* pc_relative */
512 0, /* bitpos */
513 complain_overflow_dont, /* complain_on_overflow */
514 ppc64_elf_unhandled_reloc, /* special_function */
515 "R_PPC64_COPY", /* name */
516 FALSE, /* partial_inplace */
517 0, /* src_mask */
518 0, /* dst_mask */
519 FALSE), /* pcrel_offset */
520
521 /* Like R_PPC64_ADDR64, but used when setting global offset table
522 entries. */
523 HOWTO (R_PPC64_GLOB_DAT, /* type */
524 0, /* rightshift */
525 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
526 64, /* bitsize */
527 FALSE, /* pc_relative */
528 0, /* bitpos */
529 complain_overflow_dont, /* complain_on_overflow */
530 ppc64_elf_unhandled_reloc, /* special_function */
531 "R_PPC64_GLOB_DAT", /* name */
532 FALSE, /* partial_inplace */
533 0, /* src_mask */
534 ONES (64), /* dst_mask */
535 FALSE), /* pcrel_offset */
536
537 /* Created by the link editor. Marks a procedure linkage table
538 entry for a symbol. */
539 HOWTO (R_PPC64_JMP_SLOT, /* type */
540 0, /* rightshift */
541 0, /* size (0 = byte, 1 = short, 2 = long) */
542 0, /* bitsize */
543 FALSE, /* pc_relative */
544 0, /* bitpos */
545 complain_overflow_dont, /* complain_on_overflow */
546 ppc64_elf_unhandled_reloc, /* special_function */
547 "R_PPC64_JMP_SLOT", /* name */
548 FALSE, /* partial_inplace */
549 0, /* src_mask */
550 0, /* dst_mask */
551 FALSE), /* pcrel_offset */
552
553 /* Used only by the dynamic linker. When the object is run, this
554 doubleword64 is set to the load address of the object, plus the
555 addend. */
556 HOWTO (R_PPC64_RELATIVE, /* type */
557 0, /* rightshift */
558 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
559 64, /* bitsize */
560 FALSE, /* pc_relative */
561 0, /* bitpos */
562 complain_overflow_dont, /* complain_on_overflow */
563 bfd_elf_generic_reloc, /* special_function */
564 "R_PPC64_RELATIVE", /* name */
565 FALSE, /* partial_inplace */
566 0, /* src_mask */
567 ONES (64), /* dst_mask */
568 FALSE), /* pcrel_offset */
569
570 /* Like R_PPC64_ADDR32, but may be unaligned. */
571 HOWTO (R_PPC64_UADDR32, /* type */
572 0, /* rightshift */
573 2, /* size (0 = byte, 1 = short, 2 = long) */
574 32, /* bitsize */
575 FALSE, /* pc_relative */
576 0, /* bitpos */
577 complain_overflow_bitfield, /* complain_on_overflow */
578 bfd_elf_generic_reloc, /* special_function */
579 "R_PPC64_UADDR32", /* name */
580 FALSE, /* partial_inplace */
581 0, /* src_mask */
582 0xffffffff, /* dst_mask */
583 FALSE), /* pcrel_offset */
584
585 /* Like R_PPC64_ADDR16, but may be unaligned. */
586 HOWTO (R_PPC64_UADDR16, /* type */
587 0, /* rightshift */
588 1, /* size (0 = byte, 1 = short, 2 = long) */
589 16, /* bitsize */
590 FALSE, /* pc_relative */
591 0, /* bitpos */
592 complain_overflow_bitfield, /* complain_on_overflow */
593 bfd_elf_generic_reloc, /* special_function */
594 "R_PPC64_UADDR16", /* name */
595 FALSE, /* partial_inplace */
596 0, /* src_mask */
597 0xffff, /* dst_mask */
598 FALSE), /* pcrel_offset */
599
600 /* 32-bit PC relative. */
601 HOWTO (R_PPC64_REL32, /* type */
602 0, /* rightshift */
603 2, /* size (0 = byte, 1 = short, 2 = long) */
604 32, /* bitsize */
605 TRUE, /* pc_relative */
606 0, /* bitpos */
607 /* FIXME: Verify. Was complain_overflow_bitfield. */
608 complain_overflow_signed, /* complain_on_overflow */
609 bfd_elf_generic_reloc, /* special_function */
610 "R_PPC64_REL32", /* name */
611 FALSE, /* partial_inplace */
612 0, /* src_mask */
613 0xffffffff, /* dst_mask */
614 TRUE), /* pcrel_offset */
615
616 /* 32-bit relocation to the symbol's procedure linkage table. */
617 HOWTO (R_PPC64_PLT32, /* type */
618 0, /* rightshift */
619 2, /* size (0 = byte, 1 = short, 2 = long) */
620 32, /* bitsize */
621 FALSE, /* pc_relative */
622 0, /* bitpos */
623 complain_overflow_bitfield, /* complain_on_overflow */
624 ppc64_elf_unhandled_reloc, /* special_function */
625 "R_PPC64_PLT32", /* name */
626 FALSE, /* partial_inplace */
627 0, /* src_mask */
628 0xffffffff, /* dst_mask */
629 FALSE), /* pcrel_offset */
630
631 /* 32-bit PC relative relocation to the symbol's procedure linkage table.
632 FIXME: R_PPC64_PLTREL32 not supported. */
633 HOWTO (R_PPC64_PLTREL32, /* type */
634 0, /* rightshift */
635 2, /* size (0 = byte, 1 = short, 2 = long) */
636 32, /* bitsize */
637 TRUE, /* pc_relative */
638 0, /* bitpos */
639 complain_overflow_signed, /* complain_on_overflow */
640 bfd_elf_generic_reloc, /* special_function */
641 "R_PPC64_PLTREL32", /* name */
642 FALSE, /* partial_inplace */
643 0, /* src_mask */
644 0xffffffff, /* dst_mask */
645 TRUE), /* pcrel_offset */
646
647 /* Like R_PPC64_ADDR16_LO, but referring to the PLT table entry for
648 the symbol. */
649 HOWTO (R_PPC64_PLT16_LO, /* type */
650 0, /* rightshift */
651 1, /* size (0 = byte, 1 = short, 2 = long) */
652 16, /* bitsize */
653 FALSE, /* pc_relative */
654 0, /* bitpos */
655 complain_overflow_dont, /* complain_on_overflow */
656 ppc64_elf_unhandled_reloc, /* special_function */
657 "R_PPC64_PLT16_LO", /* name */
658 FALSE, /* partial_inplace */
659 0, /* src_mask */
660 0xffff, /* dst_mask */
661 FALSE), /* pcrel_offset */
662
663 /* Like R_PPC64_ADDR16_HI, but referring to the PLT table entry for
664 the symbol. */
665 HOWTO (R_PPC64_PLT16_HI, /* type */
666 16, /* rightshift */
667 1, /* size (0 = byte, 1 = short, 2 = long) */
668 16, /* bitsize */
669 FALSE, /* pc_relative */
670 0, /* bitpos */
671 complain_overflow_dont, /* complain_on_overflow */
672 ppc64_elf_unhandled_reloc, /* special_function */
673 "R_PPC64_PLT16_HI", /* name */
674 FALSE, /* partial_inplace */
675 0, /* src_mask */
676 0xffff, /* dst_mask */
677 FALSE), /* pcrel_offset */
678
679 /* Like R_PPC64_ADDR16_HA, but referring to the PLT table entry for
680 the symbol. */
681 HOWTO (R_PPC64_PLT16_HA, /* type */
682 16, /* rightshift */
683 1, /* size (0 = byte, 1 = short, 2 = long) */
684 16, /* bitsize */
685 FALSE, /* pc_relative */
686 0, /* bitpos */
687 complain_overflow_dont, /* complain_on_overflow */
688 ppc64_elf_unhandled_reloc, /* special_function */
689 "R_PPC64_PLT16_HA", /* name */
690 FALSE, /* partial_inplace */
691 0, /* src_mask */
692 0xffff, /* dst_mask */
693 FALSE), /* pcrel_offset */
694
695 /* 16-bit section relative relocation. */
696 HOWTO (R_PPC64_SECTOFF, /* type */
697 0, /* rightshift */
698 1, /* size (0 = byte, 1 = short, 2 = long) */
699 16, /* bitsize */
700 FALSE, /* pc_relative */
701 0, /* bitpos */
702 complain_overflow_bitfield, /* complain_on_overflow */
703 ppc64_elf_sectoff_reloc, /* special_function */
704 "R_PPC64_SECTOFF", /* name */
705 FALSE, /* partial_inplace */
706 0, /* src_mask */
707 0xffff, /* dst_mask */
708 FALSE), /* pcrel_offset */
709
710 /* Like R_PPC64_SECTOFF, but no overflow warning. */
711 HOWTO (R_PPC64_SECTOFF_LO, /* type */
712 0, /* rightshift */
713 1, /* size (0 = byte, 1 = short, 2 = long) */
714 16, /* bitsize */
715 FALSE, /* pc_relative */
716 0, /* bitpos */
717 complain_overflow_dont, /* complain_on_overflow */
718 ppc64_elf_sectoff_reloc, /* special_function */
719 "R_PPC64_SECTOFF_LO", /* name */
720 FALSE, /* partial_inplace */
721 0, /* src_mask */
722 0xffff, /* dst_mask */
723 FALSE), /* pcrel_offset */
724
725 /* 16-bit upper half section relative relocation. */
726 HOWTO (R_PPC64_SECTOFF_HI, /* type */
727 16, /* rightshift */
728 1, /* size (0 = byte, 1 = short, 2 = long) */
729 16, /* bitsize */
730 FALSE, /* pc_relative */
731 0, /* bitpos */
732 complain_overflow_dont, /* complain_on_overflow */
733 ppc64_elf_sectoff_reloc, /* special_function */
734 "R_PPC64_SECTOFF_HI", /* name */
735 FALSE, /* partial_inplace */
736 0, /* src_mask */
737 0xffff, /* dst_mask */
738 FALSE), /* pcrel_offset */
739
740 /* 16-bit upper half adjusted section relative relocation. */
741 HOWTO (R_PPC64_SECTOFF_HA, /* type */
742 16, /* rightshift */
743 1, /* size (0 = byte, 1 = short, 2 = long) */
744 16, /* bitsize */
745 FALSE, /* pc_relative */
746 0, /* bitpos */
747 complain_overflow_dont, /* complain_on_overflow */
748 ppc64_elf_sectoff_ha_reloc, /* special_function */
749 "R_PPC64_SECTOFF_HA", /* name */
750 FALSE, /* partial_inplace */
751 0, /* src_mask */
752 0xffff, /* dst_mask */
753 FALSE), /* pcrel_offset */
754
755 /* Like R_PPC64_REL24 without touching the two least significant bits. */
756 HOWTO (R_PPC64_REL30, /* type */
757 2, /* rightshift */
758 2, /* size (0 = byte, 1 = short, 2 = long) */
759 30, /* bitsize */
760 TRUE, /* pc_relative */
761 0, /* bitpos */
762 complain_overflow_dont, /* complain_on_overflow */
763 bfd_elf_generic_reloc, /* special_function */
764 "R_PPC64_REL30", /* name */
765 FALSE, /* partial_inplace */
766 0, /* src_mask */
767 0xfffffffc, /* dst_mask */
768 TRUE), /* pcrel_offset */
769
770 /* Relocs in the 64-bit PowerPC ELF ABI, not in the 32-bit ABI. */
771
772 /* A standard 64-bit relocation. */
773 HOWTO (R_PPC64_ADDR64, /* type */
774 0, /* rightshift */
775 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
776 64, /* bitsize */
777 FALSE, /* pc_relative */
778 0, /* bitpos */
779 complain_overflow_dont, /* complain_on_overflow */
780 bfd_elf_generic_reloc, /* special_function */
781 "R_PPC64_ADDR64", /* name */
782 FALSE, /* partial_inplace */
783 0, /* src_mask */
784 ONES (64), /* dst_mask */
785 FALSE), /* pcrel_offset */
786
787 /* The bits 32-47 of an address. */
788 HOWTO (R_PPC64_ADDR16_HIGHER, /* type */
789 32, /* rightshift */
790 1, /* size (0 = byte, 1 = short, 2 = long) */
791 16, /* bitsize */
792 FALSE, /* pc_relative */
793 0, /* bitpos */
794 complain_overflow_dont, /* complain_on_overflow */
795 bfd_elf_generic_reloc, /* special_function */
796 "R_PPC64_ADDR16_HIGHER", /* name */
797 FALSE, /* partial_inplace */
798 0, /* src_mask */
799 0xffff, /* dst_mask */
800 FALSE), /* pcrel_offset */
801
802 /* The bits 32-47 of an address, plus 1 if the contents of the low
803 16 bits, treated as a signed number, is negative. */
804 HOWTO (R_PPC64_ADDR16_HIGHERA, /* type */
805 32, /* rightshift */
806 1, /* size (0 = byte, 1 = short, 2 = long) */
807 16, /* bitsize */
808 FALSE, /* pc_relative */
809 0, /* bitpos */
810 complain_overflow_dont, /* complain_on_overflow */
811 ppc64_elf_ha_reloc, /* special_function */
812 "R_PPC64_ADDR16_HIGHERA", /* name */
813 FALSE, /* partial_inplace */
814 0, /* src_mask */
815 0xffff, /* dst_mask */
816 FALSE), /* pcrel_offset */
817
818 /* The bits 48-63 of an address. */
819 HOWTO (R_PPC64_ADDR16_HIGHEST,/* type */
820 48, /* rightshift */
821 1, /* size (0 = byte, 1 = short, 2 = long) */
822 16, /* bitsize */
823 FALSE, /* pc_relative */
824 0, /* bitpos */
825 complain_overflow_dont, /* complain_on_overflow */
826 bfd_elf_generic_reloc, /* special_function */
827 "R_PPC64_ADDR16_HIGHEST", /* name */
828 FALSE, /* partial_inplace */
829 0, /* src_mask */
830 0xffff, /* dst_mask */
831 FALSE), /* pcrel_offset */
832
833 /* The bits 48-63 of an address, plus 1 if the contents of the low
834 16 bits, treated as a signed number, is negative. */
835 HOWTO (R_PPC64_ADDR16_HIGHESTA,/* type */
836 48, /* rightshift */
837 1, /* size (0 = byte, 1 = short, 2 = long) */
838 16, /* bitsize */
839 FALSE, /* pc_relative */
840 0, /* bitpos */
841 complain_overflow_dont, /* complain_on_overflow */
842 ppc64_elf_ha_reloc, /* special_function */
843 "R_PPC64_ADDR16_HIGHESTA", /* name */
844 FALSE, /* partial_inplace */
845 0, /* src_mask */
846 0xffff, /* dst_mask */
847 FALSE), /* pcrel_offset */
848
849 /* Like ADDR64, but may be unaligned. */
850 HOWTO (R_PPC64_UADDR64, /* type */
851 0, /* rightshift */
852 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
853 64, /* bitsize */
854 FALSE, /* pc_relative */
855 0, /* bitpos */
856 complain_overflow_dont, /* complain_on_overflow */
857 bfd_elf_generic_reloc, /* special_function */
858 "R_PPC64_UADDR64", /* name */
859 FALSE, /* partial_inplace */
860 0, /* src_mask */
861 ONES (64), /* dst_mask */
862 FALSE), /* pcrel_offset */
863
864 /* 64-bit relative relocation. */
865 HOWTO (R_PPC64_REL64, /* type */
866 0, /* rightshift */
867 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
868 64, /* bitsize */
869 TRUE, /* pc_relative */
870 0, /* bitpos */
871 complain_overflow_dont, /* complain_on_overflow */
872 bfd_elf_generic_reloc, /* special_function */
873 "R_PPC64_REL64", /* name */
874 FALSE, /* partial_inplace */
875 0, /* src_mask */
876 ONES (64), /* dst_mask */
877 TRUE), /* pcrel_offset */
878
879 /* 64-bit relocation to the symbol's procedure linkage table. */
880 HOWTO (R_PPC64_PLT64, /* type */
881 0, /* rightshift */
882 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
883 64, /* bitsize */
884 FALSE, /* pc_relative */
885 0, /* bitpos */
886 complain_overflow_dont, /* complain_on_overflow */
887 ppc64_elf_unhandled_reloc, /* special_function */
888 "R_PPC64_PLT64", /* name */
889 FALSE, /* partial_inplace */
890 0, /* src_mask */
891 ONES (64), /* dst_mask */
892 FALSE), /* pcrel_offset */
893
894 /* 64-bit PC relative relocation to the symbol's procedure linkage
895 table. */
896 /* FIXME: R_PPC64_PLTREL64 not supported. */
897 HOWTO (R_PPC64_PLTREL64, /* type */
898 0, /* rightshift */
899 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
900 64, /* bitsize */
901 TRUE, /* pc_relative */
902 0, /* bitpos */
903 complain_overflow_dont, /* complain_on_overflow */
904 ppc64_elf_unhandled_reloc, /* special_function */
905 "R_PPC64_PLTREL64", /* name */
906 FALSE, /* partial_inplace */
907 0, /* src_mask */
908 ONES (64), /* dst_mask */
909 TRUE), /* pcrel_offset */
910
911 /* 16 bit TOC-relative relocation. */
912
913 /* R_PPC64_TOC16 47 half16* S + A - .TOC. */
914 HOWTO (R_PPC64_TOC16, /* type */
915 0, /* rightshift */
916 1, /* size (0 = byte, 1 = short, 2 = long) */
917 16, /* bitsize */
918 FALSE, /* pc_relative */
919 0, /* bitpos */
920 complain_overflow_signed, /* complain_on_overflow */
921 ppc64_elf_toc_reloc, /* special_function */
922 "R_PPC64_TOC16", /* name */
923 FALSE, /* partial_inplace */
924 0, /* src_mask */
925 0xffff, /* dst_mask */
926 FALSE), /* pcrel_offset */
927
928 /* 16 bit TOC-relative relocation without overflow. */
929
930 /* R_PPC64_TOC16_LO 48 half16 #lo (S + A - .TOC.) */
931 HOWTO (R_PPC64_TOC16_LO, /* type */
932 0, /* rightshift */
933 1, /* size (0 = byte, 1 = short, 2 = long) */
934 16, /* bitsize */
935 FALSE, /* pc_relative */
936 0, /* bitpos */
937 complain_overflow_dont, /* complain_on_overflow */
938 ppc64_elf_toc_reloc, /* special_function */
939 "R_PPC64_TOC16_LO", /* name */
940 FALSE, /* partial_inplace */
941 0, /* src_mask */
942 0xffff, /* dst_mask */
943 FALSE), /* pcrel_offset */
944
945 /* 16 bit TOC-relative relocation, high 16 bits. */
946
947 /* R_PPC64_TOC16_HI 49 half16 #hi (S + A - .TOC.) */
948 HOWTO (R_PPC64_TOC16_HI, /* type */
949 16, /* rightshift */
950 1, /* size (0 = byte, 1 = short, 2 = long) */
951 16, /* bitsize */
952 FALSE, /* pc_relative */
953 0, /* bitpos */
954 complain_overflow_dont, /* complain_on_overflow */
955 ppc64_elf_toc_reloc, /* special_function */
956 "R_PPC64_TOC16_HI", /* name */
957 FALSE, /* partial_inplace */
958 0, /* src_mask */
959 0xffff, /* dst_mask */
960 FALSE), /* pcrel_offset */
961
962 /* 16 bit TOC-relative relocation, high 16 bits, plus 1 if the
963 contents of the low 16 bits, treated as a signed number, is
964 negative. */
965
966 /* R_PPC64_TOC16_HA 50 half16 #ha (S + A - .TOC.) */
967 HOWTO (R_PPC64_TOC16_HA, /* type */
968 16, /* rightshift */
969 1, /* size (0 = byte, 1 = short, 2 = long) */
970 16, /* bitsize */
971 FALSE, /* pc_relative */
972 0, /* bitpos */
973 complain_overflow_dont, /* complain_on_overflow */
974 ppc64_elf_toc_ha_reloc, /* special_function */
975 "R_PPC64_TOC16_HA", /* name */
976 FALSE, /* partial_inplace */
977 0, /* src_mask */
978 0xffff, /* dst_mask */
979 FALSE), /* pcrel_offset */
980
981 /* 64-bit relocation; insert value of TOC base (.TOC.). */
982
983 /* R_PPC64_TOC 51 doubleword64 .TOC. */
984 HOWTO (R_PPC64_TOC, /* type */
985 0, /* rightshift */
986 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
987 64, /* bitsize */
988 FALSE, /* pc_relative */
989 0, /* bitpos */
990 complain_overflow_bitfield, /* complain_on_overflow */
991 ppc64_elf_toc64_reloc, /* special_function */
992 "R_PPC64_TOC", /* name */
993 FALSE, /* partial_inplace */
994 0, /* src_mask */
995 ONES (64), /* dst_mask */
996 FALSE), /* pcrel_offset */
997
998 /* Like R_PPC64_GOT16, but also informs the link editor that the
999 value to relocate may (!) refer to a PLT entry which the link
1000 editor (a) may replace with the symbol value. If the link editor
1001 is unable to fully resolve the symbol, it may (b) create a PLT
1002 entry and store the address to the new PLT entry in the GOT.
1003 This permits lazy resolution of function symbols at run time.
1004 The link editor may also skip all of this and just (c) emit a
1005 R_PPC64_GLOB_DAT to tie the symbol to the GOT entry. */
1006 /* FIXME: R_PPC64_PLTGOT16 not implemented. */
1007 HOWTO (R_PPC64_PLTGOT16, /* type */
1008 0, /* rightshift */
1009 1, /* size (0 = byte, 1 = short, 2 = long) */
1010 16, /* bitsize */
1011 FALSE, /* pc_relative */
1012 0, /* bitpos */
1013 complain_overflow_signed, /* complain_on_overflow */
1014 ppc64_elf_unhandled_reloc, /* special_function */
1015 "R_PPC64_PLTGOT16", /* name */
1016 FALSE, /* partial_inplace */
1017 0, /* src_mask */
1018 0xffff, /* dst_mask */
1019 FALSE), /* pcrel_offset */
1020
1021 /* Like R_PPC64_PLTGOT16, but without overflow. */
1022 /* FIXME: R_PPC64_PLTGOT16_LO not implemented. */
1023 HOWTO (R_PPC64_PLTGOT16_LO, /* type */
1024 0, /* rightshift */
1025 1, /* size (0 = byte, 1 = short, 2 = long) */
1026 16, /* bitsize */
1027 FALSE, /* pc_relative */
1028 0, /* bitpos */
1029 complain_overflow_dont, /* complain_on_overflow */
1030 ppc64_elf_unhandled_reloc, /* special_function */
1031 "R_PPC64_PLTGOT16_LO", /* name */
1032 FALSE, /* partial_inplace */
1033 0, /* src_mask */
1034 0xffff, /* dst_mask */
1035 FALSE), /* pcrel_offset */
1036
1037 /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address. */
1038 /* FIXME: R_PPC64_PLTGOT16_HI not implemented. */
1039 HOWTO (R_PPC64_PLTGOT16_HI, /* type */
1040 16, /* rightshift */
1041 1, /* size (0 = byte, 1 = short, 2 = long) */
1042 16, /* bitsize */
1043 FALSE, /* pc_relative */
1044 0, /* bitpos */
1045 complain_overflow_dont, /* complain_on_overflow */
1046 ppc64_elf_unhandled_reloc, /* special_function */
1047 "R_PPC64_PLTGOT16_HI", /* name */
1048 FALSE, /* partial_inplace */
1049 0, /* src_mask */
1050 0xffff, /* dst_mask */
1051 FALSE), /* pcrel_offset */
1052
1053 /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address, plus
1054 1 if the contents of the low 16 bits, treated as a signed number,
1055 is negative. */
1056 /* FIXME: R_PPC64_PLTGOT16_HA not implemented. */
1057 HOWTO (R_PPC64_PLTGOT16_HA, /* type */
1058 16, /* rightshift */
1059 1, /* size (0 = byte, 1 = short, 2 = long) */
1060 16, /* bitsize */
1061 FALSE, /* pc_relative */
1062 0, /* bitpos */
1063 complain_overflow_dont,/* complain_on_overflow */
1064 ppc64_elf_unhandled_reloc, /* special_function */
1065 "R_PPC64_PLTGOT16_HA", /* name */
1066 FALSE, /* partial_inplace */
1067 0, /* src_mask */
1068 0xffff, /* dst_mask */
1069 FALSE), /* pcrel_offset */
1070
1071 /* Like R_PPC64_ADDR16, but for instructions with a DS field. */
1072 HOWTO (R_PPC64_ADDR16_DS, /* type */
1073 0, /* rightshift */
1074 1, /* size (0 = byte, 1 = short, 2 = long) */
1075 16, /* bitsize */
1076 FALSE, /* pc_relative */
1077 0, /* bitpos */
1078 complain_overflow_bitfield, /* complain_on_overflow */
1079 bfd_elf_generic_reloc, /* special_function */
1080 "R_PPC64_ADDR16_DS", /* name */
1081 FALSE, /* partial_inplace */
1082 0, /* src_mask */
1083 0xfffc, /* dst_mask */
1084 FALSE), /* pcrel_offset */
1085
1086 /* Like R_PPC64_ADDR16_LO, but for instructions with a DS field. */
1087 HOWTO (R_PPC64_ADDR16_LO_DS, /* type */
1088 0, /* rightshift */
1089 1, /* size (0 = byte, 1 = short, 2 = long) */
1090 16, /* bitsize */
1091 FALSE, /* pc_relative */
1092 0, /* bitpos */
1093 complain_overflow_dont,/* complain_on_overflow */
1094 bfd_elf_generic_reloc, /* special_function */
1095 "R_PPC64_ADDR16_LO_DS",/* name */
1096 FALSE, /* partial_inplace */
1097 0, /* src_mask */
1098 0xfffc, /* dst_mask */
1099 FALSE), /* pcrel_offset */
1100
1101 /* Like R_PPC64_GOT16, but for instructions with a DS field. */
1102 HOWTO (R_PPC64_GOT16_DS, /* type */
1103 0, /* rightshift */
1104 1, /* size (0 = byte, 1 = short, 2 = long) */
1105 16, /* bitsize */
1106 FALSE, /* pc_relative */
1107 0, /* bitpos */
1108 complain_overflow_signed, /* complain_on_overflow */
1109 ppc64_elf_unhandled_reloc, /* special_function */
1110 "R_PPC64_GOT16_DS", /* name */
1111 FALSE, /* partial_inplace */
1112 0, /* src_mask */
1113 0xfffc, /* dst_mask */
1114 FALSE), /* pcrel_offset */
1115
1116 /* Like R_PPC64_GOT16_LO, but for instructions with a DS field. */
1117 HOWTO (R_PPC64_GOT16_LO_DS, /* type */
1118 0, /* rightshift */
1119 1, /* size (0 = byte, 1 = short, 2 = long) */
1120 16, /* bitsize */
1121 FALSE, /* pc_relative */
1122 0, /* bitpos */
1123 complain_overflow_dont, /* complain_on_overflow */
1124 ppc64_elf_unhandled_reloc, /* special_function */
1125 "R_PPC64_GOT16_LO_DS", /* name */
1126 FALSE, /* partial_inplace */
1127 0, /* src_mask */
1128 0xfffc, /* dst_mask */
1129 FALSE), /* pcrel_offset */
1130
1131 /* Like R_PPC64_PLT16_LO, but for instructions with a DS field. */
1132 HOWTO (R_PPC64_PLT16_LO_DS, /* type */
1133 0, /* rightshift */
1134 1, /* size (0 = byte, 1 = short, 2 = long) */
1135 16, /* bitsize */
1136 FALSE, /* pc_relative */
1137 0, /* bitpos */
1138 complain_overflow_dont, /* complain_on_overflow */
1139 ppc64_elf_unhandled_reloc, /* special_function */
1140 "R_PPC64_PLT16_LO_DS", /* name */
1141 FALSE, /* partial_inplace */
1142 0, /* src_mask */
1143 0xfffc, /* dst_mask */
1144 FALSE), /* pcrel_offset */
1145
1146 /* Like R_PPC64_SECTOFF, but for instructions with a DS field. */
1147 HOWTO (R_PPC64_SECTOFF_DS, /* type */
1148 0, /* rightshift */
1149 1, /* size (0 = byte, 1 = short, 2 = long) */
1150 16, /* bitsize */
1151 FALSE, /* pc_relative */
1152 0, /* bitpos */
1153 complain_overflow_bitfield, /* complain_on_overflow */
1154 ppc64_elf_sectoff_reloc, /* special_function */
1155 "R_PPC64_SECTOFF_DS", /* name */
1156 FALSE, /* partial_inplace */
1157 0, /* src_mask */
1158 0xfffc, /* dst_mask */
1159 FALSE), /* pcrel_offset */
1160
1161 /* Like R_PPC64_SECTOFF_LO, but for instructions with a DS field. */
1162 HOWTO (R_PPC64_SECTOFF_LO_DS, /* type */
1163 0, /* rightshift */
1164 1, /* size (0 = byte, 1 = short, 2 = long) */
1165 16, /* bitsize */
1166 FALSE, /* pc_relative */
1167 0, /* bitpos */
1168 complain_overflow_dont, /* complain_on_overflow */
1169 ppc64_elf_sectoff_reloc, /* special_function */
1170 "R_PPC64_SECTOFF_LO_DS",/* name */
1171 FALSE, /* partial_inplace */
1172 0, /* src_mask */
1173 0xfffc, /* dst_mask */
1174 FALSE), /* pcrel_offset */
1175
1176 /* Like R_PPC64_TOC16, but for instructions with a DS field. */
1177 HOWTO (R_PPC64_TOC16_DS, /* type */
1178 0, /* rightshift */
1179 1, /* size (0 = byte, 1 = short, 2 = long) */
1180 16, /* bitsize */
1181 FALSE, /* pc_relative */
1182 0, /* bitpos */
1183 complain_overflow_signed, /* complain_on_overflow */
1184 ppc64_elf_toc_reloc, /* special_function */
1185 "R_PPC64_TOC16_DS", /* name */
1186 FALSE, /* partial_inplace */
1187 0, /* src_mask */
1188 0xfffc, /* dst_mask */
1189 FALSE), /* pcrel_offset */
1190
1191 /* Like R_PPC64_TOC16_LO, but for instructions with a DS field. */
1192 HOWTO (R_PPC64_TOC16_LO_DS, /* type */
1193 0, /* rightshift */
1194 1, /* size (0 = byte, 1 = short, 2 = long) */
1195 16, /* bitsize */
1196 FALSE, /* pc_relative */
1197 0, /* bitpos */
1198 complain_overflow_dont, /* complain_on_overflow */
1199 ppc64_elf_toc_reloc, /* special_function */
1200 "R_PPC64_TOC16_LO_DS", /* name */
1201 FALSE, /* partial_inplace */
1202 0, /* src_mask */
1203 0xfffc, /* dst_mask */
1204 FALSE), /* pcrel_offset */
1205
1206 /* Like R_PPC64_PLTGOT16, but for instructions with a DS field. */
1207 /* FIXME: R_PPC64_PLTGOT16_DS not implemented. */
1208 HOWTO (R_PPC64_PLTGOT16_DS, /* type */
1209 0, /* rightshift */
1210 1, /* size (0 = byte, 1 = short, 2 = long) */
1211 16, /* bitsize */
1212 FALSE, /* pc_relative */
1213 0, /* bitpos */
1214 complain_overflow_signed, /* complain_on_overflow */
1215 ppc64_elf_unhandled_reloc, /* special_function */
1216 "R_PPC64_PLTGOT16_DS", /* name */
1217 FALSE, /* partial_inplace */
1218 0, /* src_mask */
1219 0xfffc, /* dst_mask */
1220 FALSE), /* pcrel_offset */
1221
1222 /* Like R_PPC64_PLTGOT16_LO, but for instructions with a DS field. */
1223 /* FIXME: R_PPC64_PLTGOT16_LO not implemented. */
1224 HOWTO (R_PPC64_PLTGOT16_LO_DS,/* type */
1225 0, /* rightshift */
1226 1, /* size (0 = byte, 1 = short, 2 = long) */
1227 16, /* bitsize */
1228 FALSE, /* pc_relative */
1229 0, /* bitpos */
1230 complain_overflow_dont, /* complain_on_overflow */
1231 ppc64_elf_unhandled_reloc, /* special_function */
1232 "R_PPC64_PLTGOT16_LO_DS",/* name */
1233 FALSE, /* partial_inplace */
1234 0, /* src_mask */
1235 0xfffc, /* dst_mask */
1236 FALSE), /* pcrel_offset */
1237
1238 /* Marker reloc for TLS. */
1239 HOWTO (R_PPC64_TLS,
1240 0, /* rightshift */
1241 2, /* size (0 = byte, 1 = short, 2 = long) */
1242 32, /* bitsize */
1243 FALSE, /* pc_relative */
1244 0, /* bitpos */
1245 complain_overflow_dont, /* complain_on_overflow */
1246 bfd_elf_generic_reloc, /* special_function */
1247 "R_PPC64_TLS", /* name */
1248 FALSE, /* partial_inplace */
1249 0, /* src_mask */
1250 0, /* dst_mask */
1251 FALSE), /* pcrel_offset */
1252
1253 /* Computes the load module index of the load module that contains the
1254 definition of its TLS sym. */
1255 HOWTO (R_PPC64_DTPMOD64,
1256 0, /* rightshift */
1257 4, /* size (0 = byte, 1 = short, 2 = long) */
1258 64, /* bitsize */
1259 FALSE, /* pc_relative */
1260 0, /* bitpos */
1261 complain_overflow_dont, /* complain_on_overflow */
1262 ppc64_elf_unhandled_reloc, /* special_function */
1263 "R_PPC64_DTPMOD64", /* name */
1264 FALSE, /* partial_inplace */
1265 0, /* src_mask */
1266 ONES (64), /* dst_mask */
1267 FALSE), /* pcrel_offset */
1268
1269 /* Computes a dtv-relative displacement, the difference between the value
1270 of sym+add and the base address of the thread-local storage block that
1271 contains the definition of sym, minus 0x8000. */
1272 HOWTO (R_PPC64_DTPREL64,
1273 0, /* rightshift */
1274 4, /* size (0 = byte, 1 = short, 2 = long) */
1275 64, /* bitsize */
1276 FALSE, /* pc_relative */
1277 0, /* bitpos */
1278 complain_overflow_dont, /* complain_on_overflow */
1279 ppc64_elf_unhandled_reloc, /* special_function */
1280 "R_PPC64_DTPREL64", /* name */
1281 FALSE, /* partial_inplace */
1282 0, /* src_mask */
1283 ONES (64), /* dst_mask */
1284 FALSE), /* pcrel_offset */
1285
1286 /* A 16 bit dtprel reloc. */
1287 HOWTO (R_PPC64_DTPREL16,
1288 0, /* rightshift */
1289 1, /* size (0 = byte, 1 = short, 2 = long) */
1290 16, /* bitsize */
1291 FALSE, /* pc_relative */
1292 0, /* bitpos */
1293 complain_overflow_signed, /* complain_on_overflow */
1294 ppc64_elf_unhandled_reloc, /* special_function */
1295 "R_PPC64_DTPREL16", /* name */
1296 FALSE, /* partial_inplace */
1297 0, /* src_mask */
1298 0xffff, /* dst_mask */
1299 FALSE), /* pcrel_offset */
1300
1301 /* Like DTPREL16, but no overflow. */
1302 HOWTO (R_PPC64_DTPREL16_LO,
1303 0, /* rightshift */
1304 1, /* size (0 = byte, 1 = short, 2 = long) */
1305 16, /* bitsize */
1306 FALSE, /* pc_relative */
1307 0, /* bitpos */
1308 complain_overflow_dont, /* complain_on_overflow */
1309 ppc64_elf_unhandled_reloc, /* special_function */
1310 "R_PPC64_DTPREL16_LO", /* name */
1311 FALSE, /* partial_inplace */
1312 0, /* src_mask */
1313 0xffff, /* dst_mask */
1314 FALSE), /* pcrel_offset */
1315
1316 /* Like DTPREL16_LO, but next higher group of 16 bits. */
1317 HOWTO (R_PPC64_DTPREL16_HI,
1318 16, /* rightshift */
1319 1, /* size (0 = byte, 1 = short, 2 = long) */
1320 16, /* bitsize */
1321 FALSE, /* pc_relative */
1322 0, /* bitpos */
1323 complain_overflow_dont, /* complain_on_overflow */
1324 ppc64_elf_unhandled_reloc, /* special_function */
1325 "R_PPC64_DTPREL16_HI", /* name */
1326 FALSE, /* partial_inplace */
1327 0, /* src_mask */
1328 0xffff, /* dst_mask */
1329 FALSE), /* pcrel_offset */
1330
1331 /* Like DTPREL16_HI, but adjust for low 16 bits. */
1332 HOWTO (R_PPC64_DTPREL16_HA,
1333 16, /* rightshift */
1334 1, /* size (0 = byte, 1 = short, 2 = long) */
1335 16, /* bitsize */
1336 FALSE, /* pc_relative */
1337 0, /* bitpos */
1338 complain_overflow_dont, /* complain_on_overflow */
1339 ppc64_elf_unhandled_reloc, /* special_function */
1340 "R_PPC64_DTPREL16_HA", /* name */
1341 FALSE, /* partial_inplace */
1342 0, /* src_mask */
1343 0xffff, /* dst_mask */
1344 FALSE), /* pcrel_offset */
1345
1346 /* Like DTPREL16_HI, but next higher group of 16 bits. */
1347 HOWTO (R_PPC64_DTPREL16_HIGHER,
1348 32, /* rightshift */
1349 1, /* size (0 = byte, 1 = short, 2 = long) */
1350 16, /* bitsize */
1351 FALSE, /* pc_relative */
1352 0, /* bitpos */
1353 complain_overflow_dont, /* complain_on_overflow */
1354 ppc64_elf_unhandled_reloc, /* special_function */
1355 "R_PPC64_DTPREL16_HIGHER", /* name */
1356 FALSE, /* partial_inplace */
1357 0, /* src_mask */
1358 0xffff, /* dst_mask */
1359 FALSE), /* pcrel_offset */
1360
1361 /* Like DTPREL16_HIGHER, but adjust for low 16 bits. */
1362 HOWTO (R_PPC64_DTPREL16_HIGHERA,
1363 32, /* rightshift */
1364 1, /* size (0 = byte, 1 = short, 2 = long) */
1365 16, /* bitsize */
1366 FALSE, /* pc_relative */
1367 0, /* bitpos */
1368 complain_overflow_dont, /* complain_on_overflow */
1369 ppc64_elf_unhandled_reloc, /* special_function */
1370 "R_PPC64_DTPREL16_HIGHERA", /* name */
1371 FALSE, /* partial_inplace */
1372 0, /* src_mask */
1373 0xffff, /* dst_mask */
1374 FALSE), /* pcrel_offset */
1375
1376 /* Like DTPREL16_HIGHER, but next higher group of 16 bits. */
1377 HOWTO (R_PPC64_DTPREL16_HIGHEST,
1378 48, /* rightshift */
1379 1, /* size (0 = byte, 1 = short, 2 = long) */
1380 16, /* bitsize */
1381 FALSE, /* pc_relative */
1382 0, /* bitpos */
1383 complain_overflow_dont, /* complain_on_overflow */
1384 ppc64_elf_unhandled_reloc, /* special_function */
1385 "R_PPC64_DTPREL16_HIGHEST", /* name */
1386 FALSE, /* partial_inplace */
1387 0, /* src_mask */
1388 0xffff, /* dst_mask */
1389 FALSE), /* pcrel_offset */
1390
1391 /* Like DTPREL16_HIGHEST, but adjust for low 16 bits. */
1392 HOWTO (R_PPC64_DTPREL16_HIGHESTA,
1393 48, /* rightshift */
1394 1, /* size (0 = byte, 1 = short, 2 = long) */
1395 16, /* bitsize */
1396 FALSE, /* pc_relative */
1397 0, /* bitpos */
1398 complain_overflow_dont, /* complain_on_overflow */
1399 ppc64_elf_unhandled_reloc, /* special_function */
1400 "R_PPC64_DTPREL16_HIGHESTA", /* name */
1401 FALSE, /* partial_inplace */
1402 0, /* src_mask */
1403 0xffff, /* dst_mask */
1404 FALSE), /* pcrel_offset */
1405
1406 /* Like DTPREL16, but for insns with a DS field. */
1407 HOWTO (R_PPC64_DTPREL16_DS,
1408 0, /* rightshift */
1409 1, /* size (0 = byte, 1 = short, 2 = long) */
1410 16, /* bitsize */
1411 FALSE, /* pc_relative */
1412 0, /* bitpos */
1413 complain_overflow_signed, /* complain_on_overflow */
1414 ppc64_elf_unhandled_reloc, /* special_function */
1415 "R_PPC64_DTPREL16_DS", /* name */
1416 FALSE, /* partial_inplace */
1417 0, /* src_mask */
1418 0xfffc, /* dst_mask */
1419 FALSE), /* pcrel_offset */
1420
1421 /* Like DTPREL16_DS, but no overflow. */
1422 HOWTO (R_PPC64_DTPREL16_LO_DS,
1423 0, /* rightshift */
1424 1, /* size (0 = byte, 1 = short, 2 = long) */
1425 16, /* bitsize */
1426 FALSE, /* pc_relative */
1427 0, /* bitpos */
1428 complain_overflow_dont, /* complain_on_overflow */
1429 ppc64_elf_unhandled_reloc, /* special_function */
1430 "R_PPC64_DTPREL16_LO_DS", /* name */
1431 FALSE, /* partial_inplace */
1432 0, /* src_mask */
1433 0xfffc, /* dst_mask */
1434 FALSE), /* pcrel_offset */
1435
1436 /* Computes a tp-relative displacement, the difference between the value of
1437 sym+add and the value of the thread pointer (r13). */
1438 HOWTO (R_PPC64_TPREL64,
1439 0, /* rightshift */
1440 4, /* size (0 = byte, 1 = short, 2 = long) */
1441 64, /* bitsize */
1442 FALSE, /* pc_relative */
1443 0, /* bitpos */
1444 complain_overflow_dont, /* complain_on_overflow */
1445 ppc64_elf_unhandled_reloc, /* special_function */
1446 "R_PPC64_TPREL64", /* name */
1447 FALSE, /* partial_inplace */
1448 0, /* src_mask */
1449 ONES (64), /* dst_mask */
1450 FALSE), /* pcrel_offset */
1451
1452 /* A 16 bit tprel reloc. */
1453 HOWTO (R_PPC64_TPREL16,
1454 0, /* rightshift */
1455 1, /* size (0 = byte, 1 = short, 2 = long) */
1456 16, /* bitsize */
1457 FALSE, /* pc_relative */
1458 0, /* bitpos */
1459 complain_overflow_signed, /* complain_on_overflow */
1460 ppc64_elf_unhandled_reloc, /* special_function */
1461 "R_PPC64_TPREL16", /* name */
1462 FALSE, /* partial_inplace */
1463 0, /* src_mask */
1464 0xffff, /* dst_mask */
1465 FALSE), /* pcrel_offset */
1466
1467 /* Like TPREL16, but no overflow. */
1468 HOWTO (R_PPC64_TPREL16_LO,
1469 0, /* rightshift */
1470 1, /* size (0 = byte, 1 = short, 2 = long) */
1471 16, /* bitsize */
1472 FALSE, /* pc_relative */
1473 0, /* bitpos */
1474 complain_overflow_dont, /* complain_on_overflow */
1475 ppc64_elf_unhandled_reloc, /* special_function */
1476 "R_PPC64_TPREL16_LO", /* name */
1477 FALSE, /* partial_inplace */
1478 0, /* src_mask */
1479 0xffff, /* dst_mask */
1480 FALSE), /* pcrel_offset */
1481
1482 /* Like TPREL16_LO, but next higher group of 16 bits. */
1483 HOWTO (R_PPC64_TPREL16_HI,
1484 16, /* rightshift */
1485 1, /* size (0 = byte, 1 = short, 2 = long) */
1486 16, /* bitsize */
1487 FALSE, /* pc_relative */
1488 0, /* bitpos */
1489 complain_overflow_dont, /* complain_on_overflow */
1490 ppc64_elf_unhandled_reloc, /* special_function */
1491 "R_PPC64_TPREL16_HI", /* name */
1492 FALSE, /* partial_inplace */
1493 0, /* src_mask */
1494 0xffff, /* dst_mask */
1495 FALSE), /* pcrel_offset */
1496
1497 /* Like TPREL16_HI, but adjust for low 16 bits. */
1498 HOWTO (R_PPC64_TPREL16_HA,
1499 16, /* rightshift */
1500 1, /* size (0 = byte, 1 = short, 2 = long) */
1501 16, /* bitsize */
1502 FALSE, /* pc_relative */
1503 0, /* bitpos */
1504 complain_overflow_dont, /* complain_on_overflow */
1505 ppc64_elf_unhandled_reloc, /* special_function */
1506 "R_PPC64_TPREL16_HA", /* name */
1507 FALSE, /* partial_inplace */
1508 0, /* src_mask */
1509 0xffff, /* dst_mask */
1510 FALSE), /* pcrel_offset */
1511
1512 /* Like TPREL16_HI, but next higher group of 16 bits. */
1513 HOWTO (R_PPC64_TPREL16_HIGHER,
1514 32, /* rightshift */
1515 1, /* size (0 = byte, 1 = short, 2 = long) */
1516 16, /* bitsize */
1517 FALSE, /* pc_relative */
1518 0, /* bitpos */
1519 complain_overflow_dont, /* complain_on_overflow */
1520 ppc64_elf_unhandled_reloc, /* special_function */
1521 "R_PPC64_TPREL16_HIGHER", /* name */
1522 FALSE, /* partial_inplace */
1523 0, /* src_mask */
1524 0xffff, /* dst_mask */
1525 FALSE), /* pcrel_offset */
1526
1527 /* Like TPREL16_HIGHER, but adjust for low 16 bits. */
1528 HOWTO (R_PPC64_TPREL16_HIGHERA,
1529 32, /* rightshift */
1530 1, /* size (0 = byte, 1 = short, 2 = long) */
1531 16, /* bitsize */
1532 FALSE, /* pc_relative */
1533 0, /* bitpos */
1534 complain_overflow_dont, /* complain_on_overflow */
1535 ppc64_elf_unhandled_reloc, /* special_function */
1536 "R_PPC64_TPREL16_HIGHERA", /* name */
1537 FALSE, /* partial_inplace */
1538 0, /* src_mask */
1539 0xffff, /* dst_mask */
1540 FALSE), /* pcrel_offset */
1541
1542 /* Like TPREL16_HIGHER, but next higher group of 16 bits. */
1543 HOWTO (R_PPC64_TPREL16_HIGHEST,
1544 48, /* rightshift */
1545 1, /* size (0 = byte, 1 = short, 2 = long) */
1546 16, /* bitsize */
1547 FALSE, /* pc_relative */
1548 0, /* bitpos */
1549 complain_overflow_dont, /* complain_on_overflow */
1550 ppc64_elf_unhandled_reloc, /* special_function */
1551 "R_PPC64_TPREL16_HIGHEST", /* name */
1552 FALSE, /* partial_inplace */
1553 0, /* src_mask */
1554 0xffff, /* dst_mask */
1555 FALSE), /* pcrel_offset */
1556
1557 /* Like TPREL16_HIGHEST, but adjust for low 16 bits. */
1558 HOWTO (R_PPC64_TPREL16_HIGHESTA,
1559 48, /* rightshift */
1560 1, /* size (0 = byte, 1 = short, 2 = long) */
1561 16, /* bitsize */
1562 FALSE, /* pc_relative */
1563 0, /* bitpos */
1564 complain_overflow_dont, /* complain_on_overflow */
1565 ppc64_elf_unhandled_reloc, /* special_function */
1566 "R_PPC64_TPREL16_HIGHESTA", /* name */
1567 FALSE, /* partial_inplace */
1568 0, /* src_mask */
1569 0xffff, /* dst_mask */
1570 FALSE), /* pcrel_offset */
1571
1572 /* Like TPREL16, but for insns with a DS field. */
1573 HOWTO (R_PPC64_TPREL16_DS,
1574 0, /* rightshift */
1575 1, /* size (0 = byte, 1 = short, 2 = long) */
1576 16, /* bitsize */
1577 FALSE, /* pc_relative */
1578 0, /* bitpos */
1579 complain_overflow_signed, /* complain_on_overflow */
1580 ppc64_elf_unhandled_reloc, /* special_function */
1581 "R_PPC64_TPREL16_DS", /* name */
1582 FALSE, /* partial_inplace */
1583 0, /* src_mask */
1584 0xfffc, /* dst_mask */
1585 FALSE), /* pcrel_offset */
1586
1587 /* Like TPREL16_DS, but no overflow. */
1588 HOWTO (R_PPC64_TPREL16_LO_DS,
1589 0, /* rightshift */
1590 1, /* size (0 = byte, 1 = short, 2 = long) */
1591 16, /* bitsize */
1592 FALSE, /* pc_relative */
1593 0, /* bitpos */
1594 complain_overflow_dont, /* complain_on_overflow */
1595 ppc64_elf_unhandled_reloc, /* special_function */
1596 "R_PPC64_TPREL16_LO_DS", /* name */
1597 FALSE, /* partial_inplace */
1598 0, /* src_mask */
1599 0xfffc, /* dst_mask */
1600 FALSE), /* pcrel_offset */
1601
1602 /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1603 with values (sym+add)@dtpmod and (sym+add)@dtprel, and computes the offset
1604 to the first entry relative to the TOC base (r2). */
1605 HOWTO (R_PPC64_GOT_TLSGD16,
1606 0, /* rightshift */
1607 1, /* size (0 = byte, 1 = short, 2 = long) */
1608 16, /* bitsize */
1609 FALSE, /* pc_relative */
1610 0, /* bitpos */
1611 complain_overflow_signed, /* complain_on_overflow */
1612 ppc64_elf_unhandled_reloc, /* special_function */
1613 "R_PPC64_GOT_TLSGD16", /* name */
1614 FALSE, /* partial_inplace */
1615 0, /* src_mask */
1616 0xffff, /* dst_mask */
1617 FALSE), /* pcrel_offset */
1618
1619 /* Like GOT_TLSGD16, but no overflow. */
1620 HOWTO (R_PPC64_GOT_TLSGD16_LO,
1621 0, /* rightshift */
1622 1, /* size (0 = byte, 1 = short, 2 = long) */
1623 16, /* bitsize */
1624 FALSE, /* pc_relative */
1625 0, /* bitpos */
1626 complain_overflow_dont, /* complain_on_overflow */
1627 ppc64_elf_unhandled_reloc, /* special_function */
1628 "R_PPC64_GOT_TLSGD16_LO", /* name */
1629 FALSE, /* partial_inplace */
1630 0, /* src_mask */
1631 0xffff, /* dst_mask */
1632 FALSE), /* pcrel_offset */
1633
1634 /* Like GOT_TLSGD16_LO, but next higher group of 16 bits. */
1635 HOWTO (R_PPC64_GOT_TLSGD16_HI,
1636 16, /* rightshift */
1637 1, /* size (0 = byte, 1 = short, 2 = long) */
1638 16, /* bitsize */
1639 FALSE, /* pc_relative */
1640 0, /* bitpos */
1641 complain_overflow_dont, /* complain_on_overflow */
1642 ppc64_elf_unhandled_reloc, /* special_function */
1643 "R_PPC64_GOT_TLSGD16_HI", /* name */
1644 FALSE, /* partial_inplace */
1645 0, /* src_mask */
1646 0xffff, /* dst_mask */
1647 FALSE), /* pcrel_offset */
1648
1649 /* Like GOT_TLSGD16_HI, but adjust for low 16 bits. */
1650 HOWTO (R_PPC64_GOT_TLSGD16_HA,
1651 16, /* rightshift */
1652 1, /* size (0 = byte, 1 = short, 2 = long) */
1653 16, /* bitsize */
1654 FALSE, /* pc_relative */
1655 0, /* bitpos */
1656 complain_overflow_dont, /* complain_on_overflow */
1657 ppc64_elf_unhandled_reloc, /* special_function */
1658 "R_PPC64_GOT_TLSGD16_HA", /* name */
1659 FALSE, /* partial_inplace */
1660 0, /* src_mask */
1661 0xffff, /* dst_mask */
1662 FALSE), /* pcrel_offset */
1663
1664 /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1665 with values (sym+add)@dtpmod and zero, and computes the offset to the
1666 first entry relative to the TOC base (r2). */
1667 HOWTO (R_PPC64_GOT_TLSLD16,
1668 0, /* rightshift */
1669 1, /* size (0 = byte, 1 = short, 2 = long) */
1670 16, /* bitsize */
1671 FALSE, /* pc_relative */
1672 0, /* bitpos */
1673 complain_overflow_signed, /* complain_on_overflow */
1674 ppc64_elf_unhandled_reloc, /* special_function */
1675 "R_PPC64_GOT_TLSLD16", /* name */
1676 FALSE, /* partial_inplace */
1677 0, /* src_mask */
1678 0xffff, /* dst_mask */
1679 FALSE), /* pcrel_offset */
1680
1681 /* Like GOT_TLSLD16, but no overflow. */
1682 HOWTO (R_PPC64_GOT_TLSLD16_LO,
1683 0, /* rightshift */
1684 1, /* size (0 = byte, 1 = short, 2 = long) */
1685 16, /* bitsize */
1686 FALSE, /* pc_relative */
1687 0, /* bitpos */
1688 complain_overflow_dont, /* complain_on_overflow */
1689 ppc64_elf_unhandled_reloc, /* special_function */
1690 "R_PPC64_GOT_TLSLD16_LO", /* name */
1691 FALSE, /* partial_inplace */
1692 0, /* src_mask */
1693 0xffff, /* dst_mask */
1694 FALSE), /* pcrel_offset */
1695
1696 /* Like GOT_TLSLD16_LO, but next higher group of 16 bits. */
1697 HOWTO (R_PPC64_GOT_TLSLD16_HI,
1698 16, /* rightshift */
1699 1, /* size (0 = byte, 1 = short, 2 = long) */
1700 16, /* bitsize */
1701 FALSE, /* pc_relative */
1702 0, /* bitpos */
1703 complain_overflow_dont, /* complain_on_overflow */
1704 ppc64_elf_unhandled_reloc, /* special_function */
1705 "R_PPC64_GOT_TLSLD16_HI", /* name */
1706 FALSE, /* partial_inplace */
1707 0, /* src_mask */
1708 0xffff, /* dst_mask */
1709 FALSE), /* pcrel_offset */
1710
1711 /* Like GOT_TLSLD16_HI, but adjust for low 16 bits. */
1712 HOWTO (R_PPC64_GOT_TLSLD16_HA,
1713 16, /* rightshift */
1714 1, /* size (0 = byte, 1 = short, 2 = long) */
1715 16, /* bitsize */
1716 FALSE, /* pc_relative */
1717 0, /* bitpos */
1718 complain_overflow_dont, /* complain_on_overflow */
1719 ppc64_elf_unhandled_reloc, /* special_function */
1720 "R_PPC64_GOT_TLSLD16_HA", /* name */
1721 FALSE, /* partial_inplace */
1722 0, /* src_mask */
1723 0xffff, /* dst_mask */
1724 FALSE), /* pcrel_offset */
1725
1726 /* Allocates an entry in the GOT with value (sym+add)@dtprel, and computes
1727 the offset to the entry relative to the TOC base (r2). */
1728 HOWTO (R_PPC64_GOT_DTPREL16_DS,
1729 0, /* rightshift */
1730 1, /* size (0 = byte, 1 = short, 2 = long) */
1731 16, /* bitsize */
1732 FALSE, /* pc_relative */
1733 0, /* bitpos */
1734 complain_overflow_signed, /* complain_on_overflow */
1735 ppc64_elf_unhandled_reloc, /* special_function */
1736 "R_PPC64_GOT_DTPREL16_DS", /* name */
1737 FALSE, /* partial_inplace */
1738 0, /* src_mask */
1739 0xfffc, /* dst_mask */
1740 FALSE), /* pcrel_offset */
1741
1742 /* Like GOT_DTPREL16_DS, but no overflow. */
1743 HOWTO (R_PPC64_GOT_DTPREL16_LO_DS,
1744 0, /* rightshift */
1745 1, /* size (0 = byte, 1 = short, 2 = long) */
1746 16, /* bitsize */
1747 FALSE, /* pc_relative */
1748 0, /* bitpos */
1749 complain_overflow_dont, /* complain_on_overflow */
1750 ppc64_elf_unhandled_reloc, /* special_function */
1751 "R_PPC64_GOT_DTPREL16_LO_DS", /* name */
1752 FALSE, /* partial_inplace */
1753 0, /* src_mask */
1754 0xfffc, /* dst_mask */
1755 FALSE), /* pcrel_offset */
1756
1757 /* Like GOT_DTPREL16_LO_DS, but next higher group of 16 bits. */
1758 HOWTO (R_PPC64_GOT_DTPREL16_HI,
1759 16, /* rightshift */
1760 1, /* size (0 = byte, 1 = short, 2 = long) */
1761 16, /* bitsize */
1762 FALSE, /* pc_relative */
1763 0, /* bitpos */
1764 complain_overflow_dont, /* complain_on_overflow */
1765 ppc64_elf_unhandled_reloc, /* special_function */
1766 "R_PPC64_GOT_DTPREL16_HI", /* name */
1767 FALSE, /* partial_inplace */
1768 0, /* src_mask */
1769 0xffff, /* dst_mask */
1770 FALSE), /* pcrel_offset */
1771
1772 /* Like GOT_DTPREL16_HI, but adjust for low 16 bits. */
1773 HOWTO (R_PPC64_GOT_DTPREL16_HA,
1774 16, /* rightshift */
1775 1, /* size (0 = byte, 1 = short, 2 = long) */
1776 16, /* bitsize */
1777 FALSE, /* pc_relative */
1778 0, /* bitpos */
1779 complain_overflow_dont, /* complain_on_overflow */
1780 ppc64_elf_unhandled_reloc, /* special_function */
1781 "R_PPC64_GOT_DTPREL16_HA", /* name */
1782 FALSE, /* partial_inplace */
1783 0, /* src_mask */
1784 0xffff, /* dst_mask */
1785 FALSE), /* pcrel_offset */
1786
1787 /* Allocates an entry in the GOT with value (sym+add)@tprel, and computes the
1788 offset to the entry relative to the TOC base (r2). */
1789 HOWTO (R_PPC64_GOT_TPREL16_DS,
1790 0, /* rightshift */
1791 1, /* size (0 = byte, 1 = short, 2 = long) */
1792 16, /* bitsize */
1793 FALSE, /* pc_relative */
1794 0, /* bitpos */
1795 complain_overflow_signed, /* complain_on_overflow */
1796 ppc64_elf_unhandled_reloc, /* special_function */
1797 "R_PPC64_GOT_TPREL16_DS", /* name */
1798 FALSE, /* partial_inplace */
1799 0, /* src_mask */
1800 0xfffc, /* dst_mask */
1801 FALSE), /* pcrel_offset */
1802
1803 /* Like GOT_TPREL16_DS, but no overflow. */
1804 HOWTO (R_PPC64_GOT_TPREL16_LO_DS,
1805 0, /* rightshift */
1806 1, /* size (0 = byte, 1 = short, 2 = long) */
1807 16, /* bitsize */
1808 FALSE, /* pc_relative */
1809 0, /* bitpos */
1810 complain_overflow_dont, /* complain_on_overflow */
1811 ppc64_elf_unhandled_reloc, /* special_function */
1812 "R_PPC64_GOT_TPREL16_LO_DS", /* name */
1813 FALSE, /* partial_inplace */
1814 0, /* src_mask */
1815 0xfffc, /* dst_mask */
1816 FALSE), /* pcrel_offset */
1817
1818 /* Like GOT_TPREL16_LO_DS, but next higher group of 16 bits. */
1819 HOWTO (R_PPC64_GOT_TPREL16_HI,
1820 16, /* rightshift */
1821 1, /* size (0 = byte, 1 = short, 2 = long) */
1822 16, /* bitsize */
1823 FALSE, /* pc_relative */
1824 0, /* bitpos */
1825 complain_overflow_dont, /* complain_on_overflow */
1826 ppc64_elf_unhandled_reloc, /* special_function */
1827 "R_PPC64_GOT_TPREL16_HI", /* name */
1828 FALSE, /* partial_inplace */
1829 0, /* src_mask */
1830 0xffff, /* dst_mask */
1831 FALSE), /* pcrel_offset */
1832
1833 /* Like GOT_TPREL16_HI, but adjust for low 16 bits. */
1834 HOWTO (R_PPC64_GOT_TPREL16_HA,
1835 16, /* rightshift */
1836 1, /* size (0 = byte, 1 = short, 2 = long) */
1837 16, /* bitsize */
1838 FALSE, /* pc_relative */
1839 0, /* bitpos */
1840 complain_overflow_dont, /* complain_on_overflow */
1841 ppc64_elf_unhandled_reloc, /* special_function */
1842 "R_PPC64_GOT_TPREL16_HA", /* name */
1843 FALSE, /* partial_inplace */
1844 0, /* src_mask */
1845 0xffff, /* dst_mask */
1846 FALSE), /* pcrel_offset */
1847
1848 /* GNU extension to record C++ vtable hierarchy. */
1849 HOWTO (R_PPC64_GNU_VTINHERIT, /* type */
1850 0, /* rightshift */
1851 0, /* size (0 = byte, 1 = short, 2 = long) */
1852 0, /* bitsize */
1853 FALSE, /* pc_relative */
1854 0, /* bitpos */
1855 complain_overflow_dont, /* complain_on_overflow */
1856 NULL, /* special_function */
1857 "R_PPC64_GNU_VTINHERIT", /* name */
1858 FALSE, /* partial_inplace */
1859 0, /* src_mask */
1860 0, /* dst_mask */
1861 FALSE), /* pcrel_offset */
1862
1863 /* GNU extension to record C++ vtable member usage. */
1864 HOWTO (R_PPC64_GNU_VTENTRY, /* type */
1865 0, /* rightshift */
1866 0, /* size (0 = byte, 1 = short, 2 = long) */
1867 0, /* bitsize */
1868 FALSE, /* pc_relative */
1869 0, /* bitpos */
1870 complain_overflow_dont, /* complain_on_overflow */
1871 NULL, /* special_function */
1872 "R_PPC64_GNU_VTENTRY", /* name */
1873 FALSE, /* partial_inplace */
1874 0, /* src_mask */
1875 0, /* dst_mask */
1876 FALSE), /* pcrel_offset */
1877 };
1878
1879 \f
1880 /* Initialize the ppc64_elf_howto_table, so that linear accesses can
1881 be done. */
1882
1883 static void
1884 ppc_howto_init (void)
1885 {
1886 unsigned int i, type;
1887
1888 for (i = 0;
1889 i < sizeof (ppc64_elf_howto_raw) / sizeof (ppc64_elf_howto_raw[0]);
1890 i++)
1891 {
1892 type = ppc64_elf_howto_raw[i].type;
1893 BFD_ASSERT (type < (sizeof (ppc64_elf_howto_table)
1894 / sizeof (ppc64_elf_howto_table[0])));
1895 ppc64_elf_howto_table[type] = &ppc64_elf_howto_raw[i];
1896 }
1897 }
1898
1899 static reloc_howto_type *
1900 ppc64_elf_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
1901 bfd_reloc_code_real_type code)
1902 {
1903 enum elf_ppc64_reloc_type r = R_PPC64_NONE;
1904
1905 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
1906 /* Initialize howto table if needed. */
1907 ppc_howto_init ();
1908
1909 switch (code)
1910 {
1911 default:
1912 return NULL;
1913
1914 case BFD_RELOC_NONE: r = R_PPC64_NONE;
1915 break;
1916 case BFD_RELOC_32: r = R_PPC64_ADDR32;
1917 break;
1918 case BFD_RELOC_PPC_BA26: r = R_PPC64_ADDR24;
1919 break;
1920 case BFD_RELOC_16: r = R_PPC64_ADDR16;
1921 break;
1922 case BFD_RELOC_LO16: r = R_PPC64_ADDR16_LO;
1923 break;
1924 case BFD_RELOC_HI16: r = R_PPC64_ADDR16_HI;
1925 break;
1926 case BFD_RELOC_HI16_S: r = R_PPC64_ADDR16_HA;
1927 break;
1928 case BFD_RELOC_PPC_BA16: r = R_PPC64_ADDR14;
1929 break;
1930 case BFD_RELOC_PPC_BA16_BRTAKEN: r = R_PPC64_ADDR14_BRTAKEN;
1931 break;
1932 case BFD_RELOC_PPC_BA16_BRNTAKEN: r = R_PPC64_ADDR14_BRNTAKEN;
1933 break;
1934 case BFD_RELOC_PPC_B26: r = R_PPC64_REL24;
1935 break;
1936 case BFD_RELOC_PPC_B16: r = R_PPC64_REL14;
1937 break;
1938 case BFD_RELOC_PPC_B16_BRTAKEN: r = R_PPC64_REL14_BRTAKEN;
1939 break;
1940 case BFD_RELOC_PPC_B16_BRNTAKEN: r = R_PPC64_REL14_BRNTAKEN;
1941 break;
1942 case BFD_RELOC_16_GOTOFF: r = R_PPC64_GOT16;
1943 break;
1944 case BFD_RELOC_LO16_GOTOFF: r = R_PPC64_GOT16_LO;
1945 break;
1946 case BFD_RELOC_HI16_GOTOFF: r = R_PPC64_GOT16_HI;
1947 break;
1948 case BFD_RELOC_HI16_S_GOTOFF: r = R_PPC64_GOT16_HA;
1949 break;
1950 case BFD_RELOC_PPC_COPY: r = R_PPC64_COPY;
1951 break;
1952 case BFD_RELOC_PPC_GLOB_DAT: r = R_PPC64_GLOB_DAT;
1953 break;
1954 case BFD_RELOC_32_PCREL: r = R_PPC64_REL32;
1955 break;
1956 case BFD_RELOC_32_PLTOFF: r = R_PPC64_PLT32;
1957 break;
1958 case BFD_RELOC_32_PLT_PCREL: r = R_PPC64_PLTREL32;
1959 break;
1960 case BFD_RELOC_LO16_PLTOFF: r = R_PPC64_PLT16_LO;
1961 break;
1962 case BFD_RELOC_HI16_PLTOFF: r = R_PPC64_PLT16_HI;
1963 break;
1964 case BFD_RELOC_HI16_S_PLTOFF: r = R_PPC64_PLT16_HA;
1965 break;
1966 case BFD_RELOC_16_BASEREL: r = R_PPC64_SECTOFF;
1967 break;
1968 case BFD_RELOC_LO16_BASEREL: r = R_PPC64_SECTOFF_LO;
1969 break;
1970 case BFD_RELOC_HI16_BASEREL: r = R_PPC64_SECTOFF_HI;
1971 break;
1972 case BFD_RELOC_HI16_S_BASEREL: r = R_PPC64_SECTOFF_HA;
1973 break;
1974 case BFD_RELOC_CTOR: r = R_PPC64_ADDR64;
1975 break;
1976 case BFD_RELOC_64: r = R_PPC64_ADDR64;
1977 break;
1978 case BFD_RELOC_PPC64_HIGHER: r = R_PPC64_ADDR16_HIGHER;
1979 break;
1980 case BFD_RELOC_PPC64_HIGHER_S: r = R_PPC64_ADDR16_HIGHERA;
1981 break;
1982 case BFD_RELOC_PPC64_HIGHEST: r = R_PPC64_ADDR16_HIGHEST;
1983 break;
1984 case BFD_RELOC_PPC64_HIGHEST_S: r = R_PPC64_ADDR16_HIGHESTA;
1985 break;
1986 case BFD_RELOC_64_PCREL: r = R_PPC64_REL64;
1987 break;
1988 case BFD_RELOC_64_PLTOFF: r = R_PPC64_PLT64;
1989 break;
1990 case BFD_RELOC_64_PLT_PCREL: r = R_PPC64_PLTREL64;
1991 break;
1992 case BFD_RELOC_PPC_TOC16: r = R_PPC64_TOC16;
1993 break;
1994 case BFD_RELOC_PPC64_TOC16_LO: r = R_PPC64_TOC16_LO;
1995 break;
1996 case BFD_RELOC_PPC64_TOC16_HI: r = R_PPC64_TOC16_HI;
1997 break;
1998 case BFD_RELOC_PPC64_TOC16_HA: r = R_PPC64_TOC16_HA;
1999 break;
2000 case BFD_RELOC_PPC64_TOC: r = R_PPC64_TOC;
2001 break;
2002 case BFD_RELOC_PPC64_PLTGOT16: r = R_PPC64_PLTGOT16;
2003 break;
2004 case BFD_RELOC_PPC64_PLTGOT16_LO: r = R_PPC64_PLTGOT16_LO;
2005 break;
2006 case BFD_RELOC_PPC64_PLTGOT16_HI: r = R_PPC64_PLTGOT16_HI;
2007 break;
2008 case BFD_RELOC_PPC64_PLTGOT16_HA: r = R_PPC64_PLTGOT16_HA;
2009 break;
2010 case BFD_RELOC_PPC64_ADDR16_DS: r = R_PPC64_ADDR16_DS;
2011 break;
2012 case BFD_RELOC_PPC64_ADDR16_LO_DS: r = R_PPC64_ADDR16_LO_DS;
2013 break;
2014 case BFD_RELOC_PPC64_GOT16_DS: r = R_PPC64_GOT16_DS;
2015 break;
2016 case BFD_RELOC_PPC64_GOT16_LO_DS: r = R_PPC64_GOT16_LO_DS;
2017 break;
2018 case BFD_RELOC_PPC64_PLT16_LO_DS: r = R_PPC64_PLT16_LO_DS;
2019 break;
2020 case BFD_RELOC_PPC64_SECTOFF_DS: r = R_PPC64_SECTOFF_DS;
2021 break;
2022 case BFD_RELOC_PPC64_SECTOFF_LO_DS: r = R_PPC64_SECTOFF_LO_DS;
2023 break;
2024 case BFD_RELOC_PPC64_TOC16_DS: r = R_PPC64_TOC16_DS;
2025 break;
2026 case BFD_RELOC_PPC64_TOC16_LO_DS: r = R_PPC64_TOC16_LO_DS;
2027 break;
2028 case BFD_RELOC_PPC64_PLTGOT16_DS: r = R_PPC64_PLTGOT16_DS;
2029 break;
2030 case BFD_RELOC_PPC64_PLTGOT16_LO_DS: r = R_PPC64_PLTGOT16_LO_DS;
2031 break;
2032 case BFD_RELOC_PPC_TLS: r = R_PPC64_TLS;
2033 break;
2034 case BFD_RELOC_PPC_DTPMOD: r = R_PPC64_DTPMOD64;
2035 break;
2036 case BFD_RELOC_PPC_TPREL16: r = R_PPC64_TPREL16;
2037 break;
2038 case BFD_RELOC_PPC_TPREL16_LO: r = R_PPC64_TPREL16_LO;
2039 break;
2040 case BFD_RELOC_PPC_TPREL16_HI: r = R_PPC64_TPREL16_HI;
2041 break;
2042 case BFD_RELOC_PPC_TPREL16_HA: r = R_PPC64_TPREL16_HA;
2043 break;
2044 case BFD_RELOC_PPC_TPREL: r = R_PPC64_TPREL64;
2045 break;
2046 case BFD_RELOC_PPC_DTPREL16: r = R_PPC64_DTPREL16;
2047 break;
2048 case BFD_RELOC_PPC_DTPREL16_LO: r = R_PPC64_DTPREL16_LO;
2049 break;
2050 case BFD_RELOC_PPC_DTPREL16_HI: r = R_PPC64_DTPREL16_HI;
2051 break;
2052 case BFD_RELOC_PPC_DTPREL16_HA: r = R_PPC64_DTPREL16_HA;
2053 break;
2054 case BFD_RELOC_PPC_DTPREL: r = R_PPC64_DTPREL64;
2055 break;
2056 case BFD_RELOC_PPC_GOT_TLSGD16: r = R_PPC64_GOT_TLSGD16;
2057 break;
2058 case BFD_RELOC_PPC_GOT_TLSGD16_LO: r = R_PPC64_GOT_TLSGD16_LO;
2059 break;
2060 case BFD_RELOC_PPC_GOT_TLSGD16_HI: r = R_PPC64_GOT_TLSGD16_HI;
2061 break;
2062 case BFD_RELOC_PPC_GOT_TLSGD16_HA: r = R_PPC64_GOT_TLSGD16_HA;
2063 break;
2064 case BFD_RELOC_PPC_GOT_TLSLD16: r = R_PPC64_GOT_TLSLD16;
2065 break;
2066 case BFD_RELOC_PPC_GOT_TLSLD16_LO: r = R_PPC64_GOT_TLSLD16_LO;
2067 break;
2068 case BFD_RELOC_PPC_GOT_TLSLD16_HI: r = R_PPC64_GOT_TLSLD16_HI;
2069 break;
2070 case BFD_RELOC_PPC_GOT_TLSLD16_HA: r = R_PPC64_GOT_TLSLD16_HA;
2071 break;
2072 case BFD_RELOC_PPC_GOT_TPREL16: r = R_PPC64_GOT_TPREL16_DS;
2073 break;
2074 case BFD_RELOC_PPC_GOT_TPREL16_LO: r = R_PPC64_GOT_TPREL16_LO_DS;
2075 break;
2076 case BFD_RELOC_PPC_GOT_TPREL16_HI: r = R_PPC64_GOT_TPREL16_HI;
2077 break;
2078 case BFD_RELOC_PPC_GOT_TPREL16_HA: r = R_PPC64_GOT_TPREL16_HA;
2079 break;
2080 case BFD_RELOC_PPC_GOT_DTPREL16: r = R_PPC64_GOT_DTPREL16_DS;
2081 break;
2082 case BFD_RELOC_PPC_GOT_DTPREL16_LO: r = R_PPC64_GOT_DTPREL16_LO_DS;
2083 break;
2084 case BFD_RELOC_PPC_GOT_DTPREL16_HI: r = R_PPC64_GOT_DTPREL16_HI;
2085 break;
2086 case BFD_RELOC_PPC_GOT_DTPREL16_HA: r = R_PPC64_GOT_DTPREL16_HA;
2087 break;
2088 case BFD_RELOC_PPC64_TPREL16_DS: r = R_PPC64_TPREL16_DS;
2089 break;
2090 case BFD_RELOC_PPC64_TPREL16_LO_DS: r = R_PPC64_TPREL16_LO_DS;
2091 break;
2092 case BFD_RELOC_PPC64_TPREL16_HIGHER: r = R_PPC64_TPREL16_HIGHER;
2093 break;
2094 case BFD_RELOC_PPC64_TPREL16_HIGHERA: r = R_PPC64_TPREL16_HIGHERA;
2095 break;
2096 case BFD_RELOC_PPC64_TPREL16_HIGHEST: r = R_PPC64_TPREL16_HIGHEST;
2097 break;
2098 case BFD_RELOC_PPC64_TPREL16_HIGHESTA: r = R_PPC64_TPREL16_HIGHESTA;
2099 break;
2100 case BFD_RELOC_PPC64_DTPREL16_DS: r = R_PPC64_DTPREL16_DS;
2101 break;
2102 case BFD_RELOC_PPC64_DTPREL16_LO_DS: r = R_PPC64_DTPREL16_LO_DS;
2103 break;
2104 case BFD_RELOC_PPC64_DTPREL16_HIGHER: r = R_PPC64_DTPREL16_HIGHER;
2105 break;
2106 case BFD_RELOC_PPC64_DTPREL16_HIGHERA: r = R_PPC64_DTPREL16_HIGHERA;
2107 break;
2108 case BFD_RELOC_PPC64_DTPREL16_HIGHEST: r = R_PPC64_DTPREL16_HIGHEST;
2109 break;
2110 case BFD_RELOC_PPC64_DTPREL16_HIGHESTA: r = R_PPC64_DTPREL16_HIGHESTA;
2111 break;
2112 case BFD_RELOC_VTABLE_INHERIT: r = R_PPC64_GNU_VTINHERIT;
2113 break;
2114 case BFD_RELOC_VTABLE_ENTRY: r = R_PPC64_GNU_VTENTRY;
2115 break;
2116 }
2117
2118 return ppc64_elf_howto_table[r];
2119 };
2120
2121 static reloc_howto_type *
2122 ppc64_elf_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2123 const char *r_name)
2124 {
2125 unsigned int i;
2126
2127 for (i = 0;
2128 i < sizeof (ppc64_elf_howto_raw) / sizeof (ppc64_elf_howto_raw[0]);
2129 i++)
2130 if (ppc64_elf_howto_raw[i].name != NULL
2131 && strcasecmp (ppc64_elf_howto_raw[i].name, r_name) == 0)
2132 return &ppc64_elf_howto_raw[i];
2133
2134 return NULL;
2135 }
2136
2137 /* Set the howto pointer for a PowerPC ELF reloc. */
2138
2139 static void
2140 ppc64_elf_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr,
2141 Elf_Internal_Rela *dst)
2142 {
2143 unsigned int type;
2144
2145 /* Initialize howto table if needed. */
2146 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2147 ppc_howto_init ();
2148
2149 type = ELF64_R_TYPE (dst->r_info);
2150 if (type >= (sizeof (ppc64_elf_howto_table)
2151 / sizeof (ppc64_elf_howto_table[0])))
2152 {
2153 (*_bfd_error_handler) (_("%B: invalid relocation type %d"),
2154 abfd, (int) type);
2155 type = R_PPC64_NONE;
2156 }
2157 cache_ptr->howto = ppc64_elf_howto_table[type];
2158 }
2159
2160 /* Handle the R_PPC64_ADDR16_HA and similar relocs. */
2161
2162 static bfd_reloc_status_type
2163 ppc64_elf_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2164 void *data, asection *input_section,
2165 bfd *output_bfd, char **error_message)
2166 {
2167 /* If this is a relocatable link (output_bfd test tells us), just
2168 call the generic function. Any adjustment will be done at final
2169 link time. */
2170 if (output_bfd != NULL)
2171 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2172 input_section, output_bfd, error_message);
2173
2174 /* Adjust the addend for sign extension of the low 16 bits.
2175 We won't actually be using the low 16 bits, so trashing them
2176 doesn't matter. */
2177 reloc_entry->addend += 0x8000;
2178 return bfd_reloc_continue;
2179 }
2180
2181 static bfd_reloc_status_type
2182 ppc64_elf_branch_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2183 void *data, asection *input_section,
2184 bfd *output_bfd, char **error_message)
2185 {
2186 if (output_bfd != NULL)
2187 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2188 input_section, output_bfd, error_message);
2189
2190 if (strcmp (symbol->section->name, ".opd") == 0
2191 && (symbol->section->owner->flags & DYNAMIC) == 0)
2192 {
2193 bfd_vma dest = opd_entry_value (symbol->section,
2194 symbol->value + reloc_entry->addend,
2195 NULL, NULL);
2196 if (dest != (bfd_vma) -1)
2197 reloc_entry->addend = dest - (symbol->value
2198 + symbol->section->output_section->vma
2199 + symbol->section->output_offset);
2200 }
2201 return bfd_reloc_continue;
2202 }
2203
2204 static bfd_reloc_status_type
2205 ppc64_elf_brtaken_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2206 void *data, asection *input_section,
2207 bfd *output_bfd, char **error_message)
2208 {
2209 long insn;
2210 enum elf_ppc64_reloc_type r_type;
2211 bfd_size_type octets;
2212 /* Disabled until we sort out how ld should choose 'y' vs 'at'. */
2213 bfd_boolean is_power4 = FALSE;
2214
2215 /* If this is a relocatable link (output_bfd test tells us), just
2216 call the generic function. Any adjustment will be done at final
2217 link time. */
2218 if (output_bfd != NULL)
2219 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2220 input_section, output_bfd, error_message);
2221
2222 octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2223 insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
2224 insn &= ~(0x01 << 21);
2225 r_type = reloc_entry->howto->type;
2226 if (r_type == R_PPC64_ADDR14_BRTAKEN
2227 || r_type == R_PPC64_REL14_BRTAKEN)
2228 insn |= 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field. */
2229
2230 if (is_power4)
2231 {
2232 /* Set 'a' bit. This is 0b00010 in BO field for branch
2233 on CR(BI) insns (BO == 001at or 011at), and 0b01000
2234 for branch on CTR insns (BO == 1a00t or 1a01t). */
2235 if ((insn & (0x14 << 21)) == (0x04 << 21))
2236 insn |= 0x02 << 21;
2237 else if ((insn & (0x14 << 21)) == (0x10 << 21))
2238 insn |= 0x08 << 21;
2239 else
2240 goto out;
2241 }
2242 else
2243 {
2244 bfd_vma target = 0;
2245 bfd_vma from;
2246
2247 if (!bfd_is_com_section (symbol->section))
2248 target = symbol->value;
2249 target += symbol->section->output_section->vma;
2250 target += symbol->section->output_offset;
2251 target += reloc_entry->addend;
2252
2253 from = (reloc_entry->address
2254 + input_section->output_offset
2255 + input_section->output_section->vma);
2256
2257 /* Invert 'y' bit if not the default. */
2258 if ((bfd_signed_vma) (target - from) < 0)
2259 insn ^= 0x01 << 21;
2260 }
2261 bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
2262 out:
2263 return ppc64_elf_branch_reloc (abfd, reloc_entry, symbol, data,
2264 input_section, output_bfd, error_message);
2265 }
2266
2267 static bfd_reloc_status_type
2268 ppc64_elf_sectoff_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2269 void *data, asection *input_section,
2270 bfd *output_bfd, char **error_message)
2271 {
2272 /* If this is a relocatable link (output_bfd test tells us), just
2273 call the generic function. Any adjustment will be done at final
2274 link time. */
2275 if (output_bfd != NULL)
2276 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2277 input_section, output_bfd, error_message);
2278
2279 /* Subtract the symbol section base address. */
2280 reloc_entry->addend -= symbol->section->output_section->vma;
2281 return bfd_reloc_continue;
2282 }
2283
2284 static bfd_reloc_status_type
2285 ppc64_elf_sectoff_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2286 void *data, asection *input_section,
2287 bfd *output_bfd, char **error_message)
2288 {
2289 /* If this is a relocatable link (output_bfd test tells us), just
2290 call the generic function. Any adjustment will be done at final
2291 link time. */
2292 if (output_bfd != NULL)
2293 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2294 input_section, output_bfd, error_message);
2295
2296 /* Subtract the symbol section base address. */
2297 reloc_entry->addend -= symbol->section->output_section->vma;
2298
2299 /* Adjust the addend for sign extension of the low 16 bits. */
2300 reloc_entry->addend += 0x8000;
2301 return bfd_reloc_continue;
2302 }
2303
2304 static bfd_reloc_status_type
2305 ppc64_elf_toc_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2306 void *data, asection *input_section,
2307 bfd *output_bfd, char **error_message)
2308 {
2309 bfd_vma TOCstart;
2310
2311 /* If this is a relocatable link (output_bfd test tells us), just
2312 call the generic function. Any adjustment will be done at final
2313 link time. */
2314 if (output_bfd != NULL)
2315 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2316 input_section, output_bfd, error_message);
2317
2318 TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2319 if (TOCstart == 0)
2320 TOCstart = ppc64_elf_toc (input_section->output_section->owner);
2321
2322 /* Subtract the TOC base address. */
2323 reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2324 return bfd_reloc_continue;
2325 }
2326
2327 static bfd_reloc_status_type
2328 ppc64_elf_toc_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2329 void *data, asection *input_section,
2330 bfd *output_bfd, char **error_message)
2331 {
2332 bfd_vma TOCstart;
2333
2334 /* If this is a relocatable link (output_bfd test tells us), just
2335 call the generic function. Any adjustment will be done at final
2336 link time. */
2337 if (output_bfd != NULL)
2338 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2339 input_section, output_bfd, error_message);
2340
2341 TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2342 if (TOCstart == 0)
2343 TOCstart = ppc64_elf_toc (input_section->output_section->owner);
2344
2345 /* Subtract the TOC base address. */
2346 reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2347
2348 /* Adjust the addend for sign extension of the low 16 bits. */
2349 reloc_entry->addend += 0x8000;
2350 return bfd_reloc_continue;
2351 }
2352
2353 static bfd_reloc_status_type
2354 ppc64_elf_toc64_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2355 void *data, asection *input_section,
2356 bfd *output_bfd, char **error_message)
2357 {
2358 bfd_vma TOCstart;
2359 bfd_size_type octets;
2360
2361 /* If this is a relocatable link (output_bfd test tells us), just
2362 call the generic function. Any adjustment will be done at final
2363 link time. */
2364 if (output_bfd != NULL)
2365 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2366 input_section, output_bfd, error_message);
2367
2368 TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2369 if (TOCstart == 0)
2370 TOCstart = ppc64_elf_toc (input_section->output_section->owner);
2371
2372 octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2373 bfd_put_64 (abfd, TOCstart + TOC_BASE_OFF, (bfd_byte *) data + octets);
2374 return bfd_reloc_ok;
2375 }
2376
2377 static bfd_reloc_status_type
2378 ppc64_elf_unhandled_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2379 void *data, asection *input_section,
2380 bfd *output_bfd, char **error_message)
2381 {
2382 /* If this is a relocatable link (output_bfd test tells us), just
2383 call the generic function. Any adjustment will be done at final
2384 link time. */
2385 if (output_bfd != NULL)
2386 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2387 input_section, output_bfd, error_message);
2388
2389 if (error_message != NULL)
2390 {
2391 static char buf[60];
2392 sprintf (buf, "generic linker can't handle %s",
2393 reloc_entry->howto->name);
2394 *error_message = buf;
2395 }
2396 return bfd_reloc_dangerous;
2397 }
2398
2399 struct ppc64_elf_obj_tdata
2400 {
2401 struct elf_obj_tdata elf;
2402
2403 /* Shortcuts to dynamic linker sections. */
2404 asection *got;
2405 asection *relgot;
2406
2407 /* Used during garbage collection. We attach global symbols defined
2408 on removed .opd entries to this section so that the sym is removed. */
2409 asection *deleted_section;
2410
2411 /* TLS local dynamic got entry handling. Suppose for multiple GOT
2412 sections means we potentially need one of these for each input bfd. */
2413 union {
2414 bfd_signed_vma refcount;
2415 bfd_vma offset;
2416 } tlsld_got;
2417
2418 /* A copy of relocs before they are modified for --emit-relocs. */
2419 Elf_Internal_Rela *opd_relocs;
2420 };
2421
2422 #define ppc64_elf_tdata(bfd) \
2423 ((struct ppc64_elf_obj_tdata *) (bfd)->tdata.any)
2424
2425 #define ppc64_tlsld_got(bfd) \
2426 (&ppc64_elf_tdata (bfd)->tlsld_got)
2427
2428 #define is_ppc64_elf(bfd) \
2429 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
2430 && elf_object_id (bfd) == PPC64_ELF_TDATA)
2431
2432 /* Override the generic function because we store some extras. */
2433
2434 static bfd_boolean
2435 ppc64_elf_mkobject (bfd *abfd)
2436 {
2437 return bfd_elf_allocate_object (abfd, sizeof (struct ppc64_elf_obj_tdata),
2438 PPC64_ELF_TDATA);
2439 }
2440
2441 /* Fix bad default arch selected for a 64 bit input bfd when the
2442 default is 32 bit. */
2443
2444 static bfd_boolean
2445 ppc64_elf_object_p (bfd *abfd)
2446 {
2447 if (abfd->arch_info->the_default && abfd->arch_info->bits_per_word == 32)
2448 {
2449 Elf_Internal_Ehdr *i_ehdr = elf_elfheader (abfd);
2450
2451 if (i_ehdr->e_ident[EI_CLASS] == ELFCLASS64)
2452 {
2453 /* Relies on arch after 32 bit default being 64 bit default. */
2454 abfd->arch_info = abfd->arch_info->next;
2455 BFD_ASSERT (abfd->arch_info->bits_per_word == 64);
2456 }
2457 }
2458 return TRUE;
2459 }
2460
2461 /* Support for core dump NOTE sections. */
2462
2463 static bfd_boolean
2464 ppc64_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
2465 {
2466 size_t offset, size;
2467
2468 if (note->descsz != 504)
2469 return FALSE;
2470
2471 /* pr_cursig */
2472 elf_tdata (abfd)->core_signal = bfd_get_16 (abfd, note->descdata + 12);
2473
2474 /* pr_pid */
2475 elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, note->descdata + 32);
2476
2477 /* pr_reg */
2478 offset = 112;
2479 size = 384;
2480
2481 /* Make a ".reg/999" section. */
2482 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
2483 size, note->descpos + offset);
2484 }
2485
2486 static bfd_boolean
2487 ppc64_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
2488 {
2489 if (note->descsz != 136)
2490 return FALSE;
2491
2492 elf_tdata (abfd)->core_program
2493 = _bfd_elfcore_strndup (abfd, note->descdata + 40, 16);
2494 elf_tdata (abfd)->core_command
2495 = _bfd_elfcore_strndup (abfd, note->descdata + 56, 80);
2496
2497 return TRUE;
2498 }
2499
2500 static char *
2501 ppc64_elf_write_core_note (bfd *abfd, char *buf, int *bufsiz, int note_type,
2502 ...)
2503 {
2504 switch (note_type)
2505 {
2506 default:
2507 return NULL;
2508
2509 case NT_PRPSINFO:
2510 {
2511 char data[136];
2512 va_list ap;
2513
2514 va_start (ap, note_type);
2515 memset (data, 0, 40);
2516 strncpy (data + 40, va_arg (ap, const char *), 16);
2517 strncpy (data + 56, va_arg (ap, const char *), 80);
2518 va_end (ap);
2519 return elfcore_write_note (abfd, buf, bufsiz,
2520 "CORE", note_type, data, sizeof (data));
2521 }
2522
2523 case NT_PRSTATUS:
2524 {
2525 char data[504];
2526 va_list ap;
2527 long pid;
2528 int cursig;
2529 const void *greg;
2530
2531 va_start (ap, note_type);
2532 memset (data, 0, 112);
2533 pid = va_arg (ap, long);
2534 bfd_put_32 (abfd, pid, data + 32);
2535 cursig = va_arg (ap, int);
2536 bfd_put_16 (abfd, cursig, data + 12);
2537 greg = va_arg (ap, const void *);
2538 memcpy (data + 112, greg, 384);
2539 memset (data + 496, 0, 8);
2540 va_end (ap);
2541 return elfcore_write_note (abfd, buf, bufsiz,
2542 "CORE", note_type, data, sizeof (data));
2543 }
2544 }
2545 }
2546
2547 /* Merge backend specific data from an object file to the output
2548 object file when linking. */
2549
2550 static bfd_boolean
2551 ppc64_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
2552 {
2553 /* Check if we have the same endianess. */
2554 if (ibfd->xvec->byteorder != obfd->xvec->byteorder
2555 && ibfd->xvec->byteorder != BFD_ENDIAN_UNKNOWN
2556 && obfd->xvec->byteorder != BFD_ENDIAN_UNKNOWN)
2557 {
2558 const char *msg;
2559
2560 if (bfd_big_endian (ibfd))
2561 msg = _("%B: compiled for a big endian system "
2562 "and target is little endian");
2563 else
2564 msg = _("%B: compiled for a little endian system "
2565 "and target is big endian");
2566
2567 (*_bfd_error_handler) (msg, ibfd);
2568
2569 bfd_set_error (bfd_error_wrong_format);
2570 return FALSE;
2571 }
2572
2573 return TRUE;
2574 }
2575
2576 /* Add extra PPC sections. */
2577
2578 static const struct bfd_elf_special_section ppc64_elf_special_sections[]=
2579 {
2580 { STRING_COMMA_LEN (".plt"), 0, SHT_NOBITS, 0 },
2581 { STRING_COMMA_LEN (".sbss"), -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE },
2582 { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2583 { STRING_COMMA_LEN (".toc"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2584 { STRING_COMMA_LEN (".toc1"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2585 { STRING_COMMA_LEN (".tocbss"), 0, SHT_NOBITS, SHF_ALLOC + SHF_WRITE },
2586 { NULL, 0, 0, 0, 0 }
2587 };
2588
2589 enum _ppc64_sec_type {
2590 sec_normal = 0,
2591 sec_opd = 1,
2592 sec_toc = 2
2593 };
2594
2595 struct _ppc64_elf_section_data
2596 {
2597 struct bfd_elf_section_data elf;
2598
2599 union
2600 {
2601 /* An array with one entry for each opd function descriptor. */
2602 struct _opd_sec_data
2603 {
2604 /* Points to the function code section for local opd entries. */
2605 asection **func_sec;
2606
2607 /* After editing .opd, adjust references to opd local syms. */
2608 long *adjust;
2609 } opd;
2610
2611 /* An array for toc sections, indexed by offset/8. */
2612 struct _toc_sec_data
2613 {
2614 /* Specifies the relocation symbol index used at a given toc offset. */
2615 unsigned *symndx;
2616
2617 /* And the relocation addend. */
2618 bfd_vma *add;
2619 } toc;
2620 } u;
2621
2622 enum _ppc64_sec_type sec_type:2;
2623
2624 /* Flag set when small branches are detected. Used to
2625 select suitable defaults for the stub group size. */
2626 unsigned int has_14bit_branch:1;
2627 };
2628
2629 #define ppc64_elf_section_data(sec) \
2630 ((struct _ppc64_elf_section_data *) elf_section_data (sec))
2631
2632 static bfd_boolean
2633 ppc64_elf_new_section_hook (bfd *abfd, asection *sec)
2634 {
2635 if (!sec->used_by_bfd)
2636 {
2637 struct _ppc64_elf_section_data *sdata;
2638 bfd_size_type amt = sizeof (*sdata);
2639
2640 sdata = bfd_zalloc (abfd, amt);
2641 if (sdata == NULL)
2642 return FALSE;
2643 sec->used_by_bfd = sdata;
2644 }
2645
2646 return _bfd_elf_new_section_hook (abfd, sec);
2647 }
2648
2649 static struct _opd_sec_data *
2650 get_opd_info (asection * sec)
2651 {
2652 if (sec != NULL
2653 && ppc64_elf_section_data (sec) != NULL
2654 && ppc64_elf_section_data (sec)->sec_type == sec_opd)
2655 return &ppc64_elf_section_data (sec)->u.opd;
2656 return NULL;
2657 }
2658 \f
2659 /* Parameters for the qsort hook. */
2660 static asection *synthetic_opd;
2661 static bfd_boolean synthetic_relocatable;
2662
2663 /* qsort comparison function for ppc64_elf_get_synthetic_symtab. */
2664
2665 static int
2666 compare_symbols (const void *ap, const void *bp)
2667 {
2668 const asymbol *a = * (const asymbol **) ap;
2669 const asymbol *b = * (const asymbol **) bp;
2670
2671 /* Section symbols first. */
2672 if ((a->flags & BSF_SECTION_SYM) && !(b->flags & BSF_SECTION_SYM))
2673 return -1;
2674 if (!(a->flags & BSF_SECTION_SYM) && (b->flags & BSF_SECTION_SYM))
2675 return 1;
2676
2677 /* then .opd symbols. */
2678 if (a->section == synthetic_opd && b->section != synthetic_opd)
2679 return -1;
2680 if (a->section != synthetic_opd && b->section == synthetic_opd)
2681 return 1;
2682
2683 /* then other code symbols. */
2684 if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
2685 == (SEC_CODE | SEC_ALLOC)
2686 && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
2687 != (SEC_CODE | SEC_ALLOC))
2688 return -1;
2689
2690 if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
2691 != (SEC_CODE | SEC_ALLOC)
2692 && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
2693 == (SEC_CODE | SEC_ALLOC))
2694 return 1;
2695
2696 if (synthetic_relocatable)
2697 {
2698 if (a->section->id < b->section->id)
2699 return -1;
2700
2701 if (a->section->id > b->section->id)
2702 return 1;
2703 }
2704
2705 if (a->value + a->section->vma < b->value + b->section->vma)
2706 return -1;
2707
2708 if (a->value + a->section->vma > b->value + b->section->vma)
2709 return 1;
2710
2711 /* For syms with the same value, prefer strong dynamic global function
2712 syms over other syms. */
2713 if ((a->flags & BSF_GLOBAL) != 0 && (b->flags & BSF_GLOBAL) == 0)
2714 return -1;
2715
2716 if ((a->flags & BSF_GLOBAL) == 0 && (b->flags & BSF_GLOBAL) != 0)
2717 return 1;
2718
2719 if ((a->flags & BSF_FUNCTION) != 0 && (b->flags & BSF_FUNCTION) == 0)
2720 return -1;
2721
2722 if ((a->flags & BSF_FUNCTION) == 0 && (b->flags & BSF_FUNCTION) != 0)
2723 return 1;
2724
2725 if ((a->flags & BSF_WEAK) == 0 && (b->flags & BSF_WEAK) != 0)
2726 return -1;
2727
2728 if ((a->flags & BSF_WEAK) != 0 && (b->flags & BSF_WEAK) == 0)
2729 return 1;
2730
2731 if ((a->flags & BSF_DYNAMIC) != 0 && (b->flags & BSF_DYNAMIC) == 0)
2732 return -1;
2733
2734 if ((a->flags & BSF_DYNAMIC) == 0 && (b->flags & BSF_DYNAMIC) != 0)
2735 return 1;
2736
2737 return 0;
2738 }
2739
2740 /* Search SYMS for a symbol of the given VALUE. */
2741
2742 static asymbol *
2743 sym_exists_at (asymbol **syms, long lo, long hi, int id, bfd_vma value)
2744 {
2745 long mid;
2746
2747 if (id == -1)
2748 {
2749 while (lo < hi)
2750 {
2751 mid = (lo + hi) >> 1;
2752 if (syms[mid]->value + syms[mid]->section->vma < value)
2753 lo = mid + 1;
2754 else if (syms[mid]->value + syms[mid]->section->vma > value)
2755 hi = mid;
2756 else
2757 return syms[mid];
2758 }
2759 }
2760 else
2761 {
2762 while (lo < hi)
2763 {
2764 mid = (lo + hi) >> 1;
2765 if (syms[mid]->section->id < id)
2766 lo = mid + 1;
2767 else if (syms[mid]->section->id > id)
2768 hi = mid;
2769 else if (syms[mid]->value < value)
2770 lo = mid + 1;
2771 else if (syms[mid]->value > value)
2772 hi = mid;
2773 else
2774 return syms[mid];
2775 }
2776 }
2777 return NULL;
2778 }
2779
2780 static bfd_boolean
2781 section_covers_vma (bfd *abfd ATTRIBUTE_UNUSED, asection *section, void *ptr)
2782 {
2783 bfd_vma vma = *(bfd_vma *) ptr;
2784 return ((section->flags & SEC_ALLOC) != 0
2785 && section->vma <= vma
2786 && vma < section->vma + section->size);
2787 }
2788
2789 /* Create synthetic symbols, effectively restoring "dot-symbol" function
2790 entry syms. Also generate @plt symbols for the glink branch table. */
2791
2792 static long
2793 ppc64_elf_get_synthetic_symtab (bfd *abfd,
2794 long static_count, asymbol **static_syms,
2795 long dyn_count, asymbol **dyn_syms,
2796 asymbol **ret)
2797 {
2798 asymbol *s;
2799 long i;
2800 long count;
2801 char *names;
2802 long symcount, codesecsym, codesecsymend, secsymend, opdsymend;
2803 asection *opd;
2804 bfd_boolean relocatable = (abfd->flags & (EXEC_P | DYNAMIC)) == 0;
2805 asymbol **syms;
2806
2807 *ret = NULL;
2808
2809 opd = bfd_get_section_by_name (abfd, ".opd");
2810 if (opd == NULL)
2811 return 0;
2812
2813 symcount = static_count;
2814 if (!relocatable)
2815 symcount += dyn_count;
2816 if (symcount == 0)
2817 return 0;
2818
2819 syms = bfd_malloc ((symcount + 1) * sizeof (*syms));
2820 if (syms == NULL)
2821 return -1;
2822
2823 if (!relocatable && static_count != 0 && dyn_count != 0)
2824 {
2825 /* Use both symbol tables. */
2826 memcpy (syms, static_syms, static_count * sizeof (*syms));
2827 memcpy (syms + static_count, dyn_syms, (dyn_count + 1) * sizeof (*syms));
2828 }
2829 else if (!relocatable && static_count == 0)
2830 memcpy (syms, dyn_syms, (symcount + 1) * sizeof (*syms));
2831 else
2832 memcpy (syms, static_syms, (symcount + 1) * sizeof (*syms));
2833
2834 synthetic_opd = opd;
2835 synthetic_relocatable = relocatable;
2836 qsort (syms, symcount, sizeof (*syms), compare_symbols);
2837
2838 if (!relocatable && symcount > 1)
2839 {
2840 long j;
2841 /* Trim duplicate syms, since we may have merged the normal and
2842 dynamic symbols. Actually, we only care about syms that have
2843 different values, so trim any with the same value. */
2844 for (i = 1, j = 1; i < symcount; ++i)
2845 if (syms[i - 1]->value + syms[i - 1]->section->vma
2846 != syms[i]->value + syms[i]->section->vma)
2847 syms[j++] = syms[i];
2848 symcount = j;
2849 }
2850
2851 i = 0;
2852 if (syms[i]->section == opd)
2853 ++i;
2854 codesecsym = i;
2855
2856 for (; i < symcount; ++i)
2857 if (((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
2858 != (SEC_CODE | SEC_ALLOC))
2859 || (syms[i]->flags & BSF_SECTION_SYM) == 0)
2860 break;
2861 codesecsymend = i;
2862
2863 for (; i < symcount; ++i)
2864 if ((syms[i]->flags & BSF_SECTION_SYM) == 0)
2865 break;
2866 secsymend = i;
2867
2868 for (; i < symcount; ++i)
2869 if (syms[i]->section != opd)
2870 break;
2871 opdsymend = i;
2872
2873 for (; i < symcount; ++i)
2874 if ((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
2875 != (SEC_CODE | SEC_ALLOC))
2876 break;
2877 symcount = i;
2878
2879 count = 0;
2880
2881 if (relocatable)
2882 {
2883 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
2884 arelent *r;
2885 size_t size;
2886 long relcount;
2887
2888 if (opdsymend == secsymend)
2889 goto done;
2890
2891 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
2892 relcount = (opd->flags & SEC_RELOC) ? opd->reloc_count : 0;
2893 if (relcount == 0)
2894 goto done;
2895
2896 if (!(*slurp_relocs) (abfd, opd, static_syms, FALSE))
2897 {
2898 count = -1;
2899 goto done;
2900 }
2901
2902 size = 0;
2903 for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
2904 {
2905 asymbol *sym;
2906
2907 while (r < opd->relocation + relcount
2908 && r->address < syms[i]->value + opd->vma)
2909 ++r;
2910
2911 if (r == opd->relocation + relcount)
2912 break;
2913
2914 if (r->address != syms[i]->value + opd->vma)
2915 continue;
2916
2917 if (r->howto->type != R_PPC64_ADDR64)
2918 continue;
2919
2920 sym = *r->sym_ptr_ptr;
2921 if (!sym_exists_at (syms, opdsymend, symcount,
2922 sym->section->id, sym->value + r->addend))
2923 {
2924 ++count;
2925 size += sizeof (asymbol);
2926 size += strlen (syms[i]->name) + 2;
2927 }
2928 }
2929
2930 s = *ret = bfd_malloc (size);
2931 if (s == NULL)
2932 {
2933 count = -1;
2934 goto done;
2935 }
2936
2937 names = (char *) (s + count);
2938
2939 for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
2940 {
2941 asymbol *sym;
2942
2943 while (r < opd->relocation + relcount
2944 && r->address < syms[i]->value + opd->vma)
2945 ++r;
2946
2947 if (r == opd->relocation + relcount)
2948 break;
2949
2950 if (r->address != syms[i]->value + opd->vma)
2951 continue;
2952
2953 if (r->howto->type != R_PPC64_ADDR64)
2954 continue;
2955
2956 sym = *r->sym_ptr_ptr;
2957 if (!sym_exists_at (syms, opdsymend, symcount,
2958 sym->section->id, sym->value + r->addend))
2959 {
2960 size_t len;
2961
2962 *s = *syms[i];
2963 s->flags |= BSF_SYNTHETIC;
2964 s->section = sym->section;
2965 s->value = sym->value + r->addend;
2966 s->name = names;
2967 *names++ = '.';
2968 len = strlen (syms[i]->name);
2969 memcpy (names, syms[i]->name, len + 1);
2970 names += len + 1;
2971 /* Have udata.p point back to the original symbol this
2972 synthetic symbol was derived from. */
2973 s->udata.p = syms[i];
2974 s++;
2975 }
2976 }
2977 }
2978 else
2979 {
2980 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
2981 bfd_byte *contents;
2982 size_t size;
2983 long plt_count = 0;
2984 bfd_vma glink_vma = 0, resolv_vma = 0;
2985 asection *dynamic, *glink = NULL, *relplt = NULL;
2986 arelent *p;
2987
2988 if (!bfd_malloc_and_get_section (abfd, opd, &contents))
2989 {
2990 if (contents)
2991 {
2992 free_contents_and_exit:
2993 free (contents);
2994 }
2995 count = -1;
2996 goto done;
2997 }
2998
2999 size = 0;
3000 for (i = secsymend; i < opdsymend; ++i)
3001 {
3002 bfd_vma ent;
3003
3004 ent = bfd_get_64 (abfd, contents + syms[i]->value);
3005 if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3006 {
3007 ++count;
3008 size += sizeof (asymbol);
3009 size += strlen (syms[i]->name) + 2;
3010 }
3011 }
3012
3013 /* Get start of .glink stubs from DT_PPC64_GLINK. */
3014 if (dyn_count != 0
3015 && (dynamic = bfd_get_section_by_name (abfd, ".dynamic")) != NULL)
3016 {
3017 bfd_byte *dynbuf, *extdyn, *extdynend;
3018 size_t extdynsize;
3019 void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *);
3020
3021 if (!bfd_malloc_and_get_section (abfd, dynamic, &dynbuf))
3022 goto free_contents_and_exit;
3023
3024 extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
3025 swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
3026
3027 extdyn = dynbuf;
3028 extdynend = extdyn + dynamic->size;
3029 for (; extdyn < extdynend; extdyn += extdynsize)
3030 {
3031 Elf_Internal_Dyn dyn;
3032 (*swap_dyn_in) (abfd, extdyn, &dyn);
3033
3034 if (dyn.d_tag == DT_NULL)
3035 break;
3036
3037 if (dyn.d_tag == DT_PPC64_GLINK)
3038 {
3039 /* The first glink stub starts at offset 32; see comment in
3040 ppc64_elf_finish_dynamic_sections. */
3041 glink_vma = dyn.d_un.d_val + 32;
3042 /* The .glink section usually does not survive the final
3043 link; search for the section (usually .text) where the
3044 glink stubs now reside. */
3045 glink = bfd_sections_find_if (abfd, section_covers_vma,
3046 &glink_vma);
3047 break;
3048 }
3049 }
3050
3051 free (dynbuf);
3052 }
3053
3054 if (glink != NULL)
3055 {
3056 /* Determine __glink trampoline by reading the relative branch
3057 from the first glink stub. */
3058 bfd_byte buf[4];
3059 if (bfd_get_section_contents (abfd, glink, buf,
3060 glink_vma + 4 - glink->vma, 4))
3061 {
3062 unsigned int insn = bfd_get_32 (abfd, buf);
3063 insn ^= B_DOT;
3064 if ((insn & ~0x3fffffc) == 0)
3065 resolv_vma = glink_vma + 4 + (insn ^ 0x2000000) - 0x2000000;
3066 }
3067
3068 if (resolv_vma)
3069 size += sizeof (asymbol) + sizeof ("__glink_PLTresolve");
3070
3071 relplt = bfd_get_section_by_name (abfd, ".rela.plt");
3072 if (relplt != NULL)
3073 {
3074 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3075 if (! (*slurp_relocs) (abfd, relplt, dyn_syms, TRUE))
3076 goto free_contents_and_exit;
3077
3078 plt_count = relplt->size / sizeof (Elf64_External_Rela);
3079 size += plt_count * sizeof (asymbol);
3080
3081 p = relplt->relocation;
3082 for (i = 0; i < plt_count; i++, p++)
3083 size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
3084 }
3085 }
3086
3087 s = *ret = bfd_malloc (size);
3088 if (s == NULL)
3089 goto free_contents_and_exit;
3090
3091 names = (char *) (s + count + plt_count + (resolv_vma != 0));
3092
3093 for (i = secsymend; i < opdsymend; ++i)
3094 {
3095 bfd_vma ent;
3096
3097 ent = bfd_get_64 (abfd, contents + syms[i]->value);
3098 if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3099 {
3100 long lo, hi;
3101 size_t len;
3102 asection *sec = abfd->sections;
3103
3104 *s = *syms[i];
3105 lo = codesecsym;
3106 hi = codesecsymend;
3107 while (lo < hi)
3108 {
3109 long mid = (lo + hi) >> 1;
3110 if (syms[mid]->section->vma < ent)
3111 lo = mid + 1;
3112 else if (syms[mid]->section->vma > ent)
3113 hi = mid;
3114 else
3115 {
3116 sec = syms[mid]->section;
3117 break;
3118 }
3119 }
3120
3121 if (lo >= hi && lo > codesecsym)
3122 sec = syms[lo - 1]->section;
3123
3124 for (; sec != NULL; sec = sec->next)
3125 {
3126 if (sec->vma > ent)
3127 break;
3128 if ((sec->flags & SEC_ALLOC) == 0
3129 || (sec->flags & SEC_LOAD) == 0)
3130 break;
3131 if ((sec->flags & SEC_CODE) != 0)
3132 s->section = sec;
3133 }
3134 s->flags |= BSF_SYNTHETIC;
3135 s->value = ent - s->section->vma;
3136 s->name = names;
3137 *names++ = '.';
3138 len = strlen (syms[i]->name);
3139 memcpy (names, syms[i]->name, len + 1);
3140 names += len + 1;
3141 /* Have udata.p point back to the original symbol this
3142 synthetic symbol was derived from. */
3143 s->udata.p = syms[i];
3144 s++;
3145 }
3146 }
3147 free (contents);
3148
3149 if (glink != NULL && relplt != NULL)
3150 {
3151 if (resolv_vma)
3152 {
3153 /* Add a symbol for the main glink trampoline. */
3154 memset (s, 0, sizeof *s);
3155 s->the_bfd = abfd;
3156 s->flags = BSF_GLOBAL | BSF_SYNTHETIC;
3157 s->section = glink;
3158 s->value = resolv_vma - glink->vma;
3159 s->name = names;
3160 memcpy (names, "__glink_PLTresolve", sizeof ("__glink_PLTresolve"));
3161 names += sizeof ("__glink_PLTresolve");
3162 s++;
3163 count++;
3164 }
3165
3166 /* FIXME: It would be very much nicer to put sym@plt on the
3167 stub rather than on the glink branch table entry. The
3168 objdump disassembler would then use a sensible symbol
3169 name on plt calls. The difficulty in doing so is
3170 a) finding the stubs, and,
3171 b) matching stubs against plt entries, and,
3172 c) there can be multiple stubs for a given plt entry.
3173
3174 Solving (a) could be done by code scanning, but older
3175 ppc64 binaries used different stubs to current code.
3176 (b) is the tricky one since you need to known the toc
3177 pointer for at least one function that uses a pic stub to
3178 be able to calculate the plt address referenced.
3179 (c) means gdb would need to set multiple breakpoints (or
3180 find the glink branch itself) when setting breakpoints
3181 for pending shared library loads. */
3182 p = relplt->relocation;
3183 for (i = 0; i < plt_count; i++, p++)
3184 {
3185 size_t len;
3186
3187 *s = **p->sym_ptr_ptr;
3188 /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set. Since
3189 we are defining a symbol, ensure one of them is set. */
3190 if ((s->flags & BSF_LOCAL) == 0)
3191 s->flags |= BSF_GLOBAL;
3192 s->flags |= BSF_SYNTHETIC;
3193 s->section = glink;
3194 s->value = glink_vma - glink->vma;
3195 s->name = names;
3196 s->udata.p = NULL;
3197 len = strlen ((*p->sym_ptr_ptr)->name);
3198 memcpy (names, (*p->sym_ptr_ptr)->name, len);
3199 names += len;
3200 memcpy (names, "@plt", sizeof ("@plt"));
3201 names += sizeof ("@plt");
3202 s++;
3203 glink_vma += 8;
3204 if (i >= 0x8000)
3205 glink_vma += 4;
3206 }
3207 count += plt_count;
3208 }
3209 }
3210
3211 done:
3212 free (syms);
3213 return count;
3214 }
3215 \f
3216 /* The following functions are specific to the ELF linker, while
3217 functions above are used generally. Those named ppc64_elf_* are
3218 called by the main ELF linker code. They appear in this file more
3219 or less in the order in which they are called. eg.
3220 ppc64_elf_check_relocs is called early in the link process,
3221 ppc64_elf_finish_dynamic_sections is one of the last functions
3222 called.
3223
3224 PowerPC64-ELF uses a similar scheme to PowerPC64-XCOFF in that
3225 functions have both a function code symbol and a function descriptor
3226 symbol. A call to foo in a relocatable object file looks like:
3227
3228 . .text
3229 . x:
3230 . bl .foo
3231 . nop
3232
3233 The function definition in another object file might be:
3234
3235 . .section .opd
3236 . foo: .quad .foo
3237 . .quad .TOC.@tocbase
3238 . .quad 0
3239 .
3240 . .text
3241 . .foo: blr
3242
3243 When the linker resolves the call during a static link, the branch
3244 unsurprisingly just goes to .foo and the .opd information is unused.
3245 If the function definition is in a shared library, things are a little
3246 different: The call goes via a plt call stub, the opd information gets
3247 copied to the plt, and the linker patches the nop.
3248
3249 . x:
3250 . bl .foo_stub
3251 . ld 2,40(1)
3252 .
3253 .
3254 . .foo_stub:
3255 . addis 12,2,Lfoo@toc@ha # in practice, the call stub
3256 . addi 12,12,Lfoo@toc@l # is slightly optimized, but
3257 . std 2,40(1) # this is the general idea
3258 . ld 11,0(12)
3259 . ld 2,8(12)
3260 . mtctr 11
3261 . ld 11,16(12)
3262 . bctr
3263 .
3264 . .section .plt
3265 . Lfoo: reloc (R_PPC64_JMP_SLOT, foo)
3266
3267 The "reloc ()" notation is supposed to indicate that the linker emits
3268 an R_PPC64_JMP_SLOT reloc against foo. The dynamic linker does the opd
3269 copying.
3270
3271 What are the difficulties here? Well, firstly, the relocations
3272 examined by the linker in check_relocs are against the function code
3273 sym .foo, while the dynamic relocation in the plt is emitted against
3274 the function descriptor symbol, foo. Somewhere along the line, we need
3275 to carefully copy dynamic link information from one symbol to the other.
3276 Secondly, the generic part of the elf linker will make .foo a dynamic
3277 symbol as is normal for most other backends. We need foo dynamic
3278 instead, at least for an application final link. However, when
3279 creating a shared library containing foo, we need to have both symbols
3280 dynamic so that references to .foo are satisfied during the early
3281 stages of linking. Otherwise the linker might decide to pull in a
3282 definition from some other object, eg. a static library.
3283
3284 Update: As of August 2004, we support a new convention. Function
3285 calls may use the function descriptor symbol, ie. "bl foo". This
3286 behaves exactly as "bl .foo". */
3287
3288 /* The linker needs to keep track of the number of relocs that it
3289 decides to copy as dynamic relocs in check_relocs for each symbol.
3290 This is so that it can later discard them if they are found to be
3291 unnecessary. We store the information in a field extending the
3292 regular ELF linker hash table. */
3293
3294 struct ppc_dyn_relocs
3295 {
3296 struct ppc_dyn_relocs *next;
3297
3298 /* The input section of the reloc. */
3299 asection *sec;
3300
3301 /* Total number of relocs copied for the input section. */
3302 bfd_size_type count;
3303
3304 /* Number of pc-relative relocs copied for the input section. */
3305 bfd_size_type pc_count;
3306 };
3307
3308 /* Track GOT entries needed for a given symbol. We might need more
3309 than one got entry per symbol. */
3310 struct got_entry
3311 {
3312 struct got_entry *next;
3313
3314 /* The symbol addend that we'll be placing in the GOT. */
3315 bfd_vma addend;
3316
3317 /* Unlike other ELF targets, we use separate GOT entries for the same
3318 symbol referenced from different input files. This is to support
3319 automatic multiple TOC/GOT sections, where the TOC base can vary
3320 from one input file to another. FIXME: After group_sections we
3321 ought to merge entries within the group.
3322
3323 Point to the BFD owning this GOT entry. */
3324 bfd *owner;
3325
3326 /* Zero for non-tls entries, or TLS_TLS and one of TLS_GD, TLS_LD,
3327 TLS_TPREL or TLS_DTPREL for tls entries. */
3328 char tls_type;
3329
3330 /* Reference count until size_dynamic_sections, GOT offset thereafter. */
3331 union
3332 {
3333 bfd_signed_vma refcount;
3334 bfd_vma offset;
3335 } got;
3336 };
3337
3338 /* The same for PLT. */
3339 struct plt_entry
3340 {
3341 struct plt_entry *next;
3342
3343 bfd_vma addend;
3344
3345 union
3346 {
3347 bfd_signed_vma refcount;
3348 bfd_vma offset;
3349 } plt;
3350 };
3351
3352 /* Of those relocs that might be copied as dynamic relocs, this function
3353 selects those that must be copied when linking a shared library,
3354 even when the symbol is local. */
3355
3356 static int
3357 must_be_dyn_reloc (struct bfd_link_info *info,
3358 enum elf_ppc64_reloc_type r_type)
3359 {
3360 switch (r_type)
3361 {
3362 default:
3363 return 1;
3364
3365 case R_PPC64_REL32:
3366 case R_PPC64_REL64:
3367 case R_PPC64_REL30:
3368 return 0;
3369
3370 case R_PPC64_TPREL16:
3371 case R_PPC64_TPREL16_LO:
3372 case R_PPC64_TPREL16_HI:
3373 case R_PPC64_TPREL16_HA:
3374 case R_PPC64_TPREL16_DS:
3375 case R_PPC64_TPREL16_LO_DS:
3376 case R_PPC64_TPREL16_HIGHER:
3377 case R_PPC64_TPREL16_HIGHERA:
3378 case R_PPC64_TPREL16_HIGHEST:
3379 case R_PPC64_TPREL16_HIGHESTA:
3380 case R_PPC64_TPREL64:
3381 return !info->executable;
3382 }
3383 }
3384
3385 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
3386 copying dynamic variables from a shared lib into an app's dynbss
3387 section, and instead use a dynamic relocation to point into the
3388 shared lib. With code that gcc generates, it's vital that this be
3389 enabled; In the PowerPC64 ABI, the address of a function is actually
3390 the address of a function descriptor, which resides in the .opd
3391 section. gcc uses the descriptor directly rather than going via the
3392 GOT as some other ABI's do, which means that initialized function
3393 pointers must reference the descriptor. Thus, a function pointer
3394 initialized to the address of a function in a shared library will
3395 either require a copy reloc, or a dynamic reloc. Using a copy reloc
3396 redefines the function descriptor symbol to point to the copy. This
3397 presents a problem as a plt entry for that function is also
3398 initialized from the function descriptor symbol and the copy reloc
3399 may not be initialized first. */
3400 #define ELIMINATE_COPY_RELOCS 1
3401
3402 /* Section name for stubs is the associated section name plus this
3403 string. */
3404 #define STUB_SUFFIX ".stub"
3405
3406 /* Linker stubs.
3407 ppc_stub_long_branch:
3408 Used when a 14 bit branch (or even a 24 bit branch) can't reach its
3409 destination, but a 24 bit branch in a stub section will reach.
3410 . b dest
3411
3412 ppc_stub_plt_branch:
3413 Similar to the above, but a 24 bit branch in the stub section won't
3414 reach its destination.
3415 . addis %r12,%r2,xxx@toc@ha
3416 . ld %r11,xxx@toc@l(%r12)
3417 . mtctr %r11
3418 . bctr
3419
3420 ppc_stub_plt_call:
3421 Used to call a function in a shared library. If it so happens that
3422 the plt entry referenced crosses a 64k boundary, then an extra
3423 "addi %r12,%r12,xxx@toc@l" will be inserted before the "mtctr".
3424 . addis %r12,%r2,xxx@toc@ha
3425 . std %r2,40(%r1)
3426 . ld %r11,xxx+0@toc@l(%r12)
3427 . mtctr %r11
3428 . ld %r2,xxx+8@toc@l(%r12)
3429 . ld %r11,xxx+16@toc@l(%r12)
3430 . bctr
3431
3432 ppc_stub_long_branch and ppc_stub_plt_branch may also have additional
3433 code to adjust the value and save r2 to support multiple toc sections.
3434 A ppc_stub_long_branch with an r2 offset looks like:
3435 . std %r2,40(%r1)
3436 . addis %r2,%r2,off@ha
3437 . addi %r2,%r2,off@l
3438 . b dest
3439
3440 A ppc_stub_plt_branch with an r2 offset looks like:
3441 . std %r2,40(%r1)
3442 . addis %r12,%r2,xxx@toc@ha
3443 . ld %r11,xxx@toc@l(%r12)
3444 . addis %r2,%r2,off@ha
3445 . addi %r2,%r2,off@l
3446 . mtctr %r11
3447 . bctr
3448
3449 In cases where the "addis" instruction would add zero, the "addis" is
3450 omitted and following instructions modified slightly in some cases.
3451 */
3452
3453 enum ppc_stub_type {
3454 ppc_stub_none,
3455 ppc_stub_long_branch,
3456 ppc_stub_long_branch_r2off,
3457 ppc_stub_plt_branch,
3458 ppc_stub_plt_branch_r2off,
3459 ppc_stub_plt_call
3460 };
3461
3462 struct ppc_stub_hash_entry {
3463
3464 /* Base hash table entry structure. */
3465 struct bfd_hash_entry root;
3466
3467 enum ppc_stub_type stub_type;
3468
3469 /* The stub section. */
3470 asection *stub_sec;
3471
3472 /* Offset within stub_sec of the beginning of this stub. */
3473 bfd_vma stub_offset;
3474
3475 /* Given the symbol's value and its section we can determine its final
3476 value when building the stubs (so the stub knows where to jump. */
3477 bfd_vma target_value;
3478 asection *target_section;
3479
3480 /* The symbol table entry, if any, that this was derived from. */
3481 struct ppc_link_hash_entry *h;
3482
3483 /* And the reloc addend that this was derived from. */
3484 bfd_vma addend;
3485
3486 /* Where this stub is being called from, or, in the case of combined
3487 stub sections, the first input section in the group. */
3488 asection *id_sec;
3489 };
3490
3491 struct ppc_branch_hash_entry {
3492
3493 /* Base hash table entry structure. */
3494 struct bfd_hash_entry root;
3495
3496 /* Offset within branch lookup table. */
3497 unsigned int offset;
3498
3499 /* Generation marker. */
3500 unsigned int iter;
3501 };
3502
3503 struct ppc_link_hash_entry
3504 {
3505 struct elf_link_hash_entry elf;
3506
3507 union {
3508 /* A pointer to the most recently used stub hash entry against this
3509 symbol. */
3510 struct ppc_stub_hash_entry *stub_cache;
3511
3512 /* A pointer to the next symbol starting with a '.' */
3513 struct ppc_link_hash_entry *next_dot_sym;
3514 } u;
3515
3516 /* Track dynamic relocs copied for this symbol. */
3517 struct ppc_dyn_relocs *dyn_relocs;
3518
3519 /* Link between function code and descriptor symbols. */
3520 struct ppc_link_hash_entry *oh;
3521
3522 /* Flag function code and descriptor symbols. */
3523 unsigned int is_func:1;
3524 unsigned int is_func_descriptor:1;
3525 unsigned int fake:1;
3526
3527 /* Whether global opd/toc sym has been adjusted or not.
3528 After ppc64_elf_edit_opd/ppc64_elf_edit_toc has run, this flag
3529 should be set for all globals defined in any opd/toc section. */
3530 unsigned int adjust_done:1;
3531
3532 /* Set if we twiddled this symbol to weak at some stage. */
3533 unsigned int was_undefined:1;
3534
3535 /* Contexts in which symbol is used in the GOT (or TOC).
3536 TLS_GD .. TLS_EXPLICIT bits are or'd into the mask as the
3537 corresponding relocs are encountered during check_relocs.
3538 tls_optimize clears TLS_GD .. TLS_TPREL when optimizing to
3539 indicate the corresponding GOT entry type is not needed.
3540 tls_optimize may also set TLS_TPRELGD when a GD reloc turns into
3541 a TPREL one. We use a separate flag rather than setting TPREL
3542 just for convenience in distinguishing the two cases. */
3543 #define TLS_GD 1 /* GD reloc. */
3544 #define TLS_LD 2 /* LD reloc. */
3545 #define TLS_TPREL 4 /* TPREL reloc, => IE. */
3546 #define TLS_DTPREL 8 /* DTPREL reloc, => LD. */
3547 #define TLS_TLS 16 /* Any TLS reloc. */
3548 #define TLS_EXPLICIT 32 /* Marks TOC section TLS relocs. */
3549 #define TLS_TPRELGD 64 /* TPREL reloc resulting from GD->IE. */
3550 char tls_mask;
3551 };
3552
3553 /* ppc64 ELF linker hash table. */
3554
3555 struct ppc_link_hash_table
3556 {
3557 struct elf_link_hash_table elf;
3558
3559 /* The stub hash table. */
3560 struct bfd_hash_table stub_hash_table;
3561
3562 /* Another hash table for plt_branch stubs. */
3563 struct bfd_hash_table branch_hash_table;
3564
3565 /* Linker stub bfd. */
3566 bfd *stub_bfd;
3567
3568 /* Linker call-backs. */
3569 asection * (*add_stub_section) (const char *, asection *);
3570 void (*layout_sections_again) (void);
3571
3572 /* Array to keep track of which stub sections have been created, and
3573 information on stub grouping. */
3574 struct map_stub {
3575 /* This is the section to which stubs in the group will be attached. */
3576 asection *link_sec;
3577 /* The stub section. */
3578 asection *stub_sec;
3579 /* Along with elf_gp, specifies the TOC pointer used in this group. */
3580 bfd_vma toc_off;
3581 } *stub_group;
3582
3583 /* Temp used when calculating TOC pointers. */
3584 bfd_vma toc_curr;
3585
3586 /* Highest input section id. */
3587 int top_id;
3588
3589 /* Highest output section index. */
3590 int top_index;
3591
3592 /* Used when adding symbols. */
3593 struct ppc_link_hash_entry *dot_syms;
3594
3595 /* List of input sections for each output section. */
3596 asection **input_list;
3597
3598 /* Short-cuts to get to dynamic linker sections. */
3599 asection *got;
3600 asection *plt;
3601 asection *relplt;
3602 asection *dynbss;
3603 asection *relbss;
3604 asection *glink;
3605 asection *sfpr;
3606 asection *brlt;
3607 asection *relbrlt;
3608
3609 /* Shortcut to .__tls_get_addr and __tls_get_addr. */
3610 struct ppc_link_hash_entry *tls_get_addr;
3611 struct ppc_link_hash_entry *tls_get_addr_fd;
3612
3613 /* Statistics. */
3614 unsigned long stub_count[ppc_stub_plt_call];
3615
3616 /* Number of stubs against global syms. */
3617 unsigned long stub_globals;
3618
3619 /* Set if we should emit symbols for stubs. */
3620 unsigned int emit_stub_syms:1;
3621
3622 /* Support for multiple toc sections. */
3623 unsigned int no_multi_toc:1;
3624 unsigned int multi_toc_needed:1;
3625
3626 /* Set on error. */
3627 unsigned int stub_error:1;
3628
3629 /* Temp used by ppc64_elf_process_dot_syms. */
3630 unsigned int twiddled_syms:1;
3631
3632 /* Incremented every time we size stubs. */
3633 unsigned int stub_iteration;
3634
3635 /* Small local sym to section mapping cache. */
3636 struct sym_sec_cache sym_sec;
3637 };
3638
3639 /* Rename some of the generic section flags to better document how they
3640 are used here. */
3641 #define has_toc_reloc has_gp_reloc
3642 #define makes_toc_func_call need_finalize_relax
3643 #define call_check_in_progress reloc_done
3644
3645 /* Get the ppc64 ELF linker hash table from a link_info structure. */
3646
3647 #define ppc_hash_table(p) \
3648 ((struct ppc_link_hash_table *) ((p)->hash))
3649
3650 #define ppc_stub_hash_lookup(table, string, create, copy) \
3651 ((struct ppc_stub_hash_entry *) \
3652 bfd_hash_lookup ((table), (string), (create), (copy)))
3653
3654 #define ppc_branch_hash_lookup(table, string, create, copy) \
3655 ((struct ppc_branch_hash_entry *) \
3656 bfd_hash_lookup ((table), (string), (create), (copy)))
3657
3658 /* Create an entry in the stub hash table. */
3659
3660 static struct bfd_hash_entry *
3661 stub_hash_newfunc (struct bfd_hash_entry *entry,
3662 struct bfd_hash_table *table,
3663 const char *string)
3664 {
3665 /* Allocate the structure if it has not already been allocated by a
3666 subclass. */
3667 if (entry == NULL)
3668 {
3669 entry = bfd_hash_allocate (table, sizeof (struct ppc_stub_hash_entry));
3670 if (entry == NULL)
3671 return entry;
3672 }
3673
3674 /* Call the allocation method of the superclass. */
3675 entry = bfd_hash_newfunc (entry, table, string);
3676 if (entry != NULL)
3677 {
3678 struct ppc_stub_hash_entry *eh;
3679
3680 /* Initialize the local fields. */
3681 eh = (struct ppc_stub_hash_entry *) entry;
3682 eh->stub_type = ppc_stub_none;
3683 eh->stub_sec = NULL;
3684 eh->stub_offset = 0;
3685 eh->target_value = 0;
3686 eh->target_section = NULL;
3687 eh->h = NULL;
3688 eh->id_sec = NULL;
3689 }
3690
3691 return entry;
3692 }
3693
3694 /* Create an entry in the branch hash table. */
3695
3696 static struct bfd_hash_entry *
3697 branch_hash_newfunc (struct bfd_hash_entry *entry,
3698 struct bfd_hash_table *table,
3699 const char *string)
3700 {
3701 /* Allocate the structure if it has not already been allocated by a
3702 subclass. */
3703 if (entry == NULL)
3704 {
3705 entry = bfd_hash_allocate (table, sizeof (struct ppc_branch_hash_entry));
3706 if (entry == NULL)
3707 return entry;
3708 }
3709
3710 /* Call the allocation method of the superclass. */
3711 entry = bfd_hash_newfunc (entry, table, string);
3712 if (entry != NULL)
3713 {
3714 struct ppc_branch_hash_entry *eh;
3715
3716 /* Initialize the local fields. */
3717 eh = (struct ppc_branch_hash_entry *) entry;
3718 eh->offset = 0;
3719 eh->iter = 0;
3720 }
3721
3722 return entry;
3723 }
3724
3725 /* Create an entry in a ppc64 ELF linker hash table. */
3726
3727 static struct bfd_hash_entry *
3728 link_hash_newfunc (struct bfd_hash_entry *entry,
3729 struct bfd_hash_table *table,
3730 const char *string)
3731 {
3732 /* Allocate the structure if it has not already been allocated by a
3733 subclass. */
3734 if (entry == NULL)
3735 {
3736 entry = bfd_hash_allocate (table, sizeof (struct ppc_link_hash_entry));
3737 if (entry == NULL)
3738 return entry;
3739 }
3740
3741 /* Call the allocation method of the superclass. */
3742 entry = _bfd_elf_link_hash_newfunc (entry, table, string);
3743 if (entry != NULL)
3744 {
3745 struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) entry;
3746
3747 memset (&eh->u.stub_cache, 0,
3748 (sizeof (struct ppc_link_hash_entry)
3749 - offsetof (struct ppc_link_hash_entry, u.stub_cache)));
3750
3751 /* When making function calls, old ABI code references function entry
3752 points (dot symbols), while new ABI code references the function
3753 descriptor symbol. We need to make any combination of reference and
3754 definition work together, without breaking archive linking.
3755
3756 For a defined function "foo" and an undefined call to "bar":
3757 An old object defines "foo" and ".foo", references ".bar" (possibly
3758 "bar" too).
3759 A new object defines "foo" and references "bar".
3760
3761 A new object thus has no problem with its undefined symbols being
3762 satisfied by definitions in an old object. On the other hand, the
3763 old object won't have ".bar" satisfied by a new object.
3764
3765 Keep a list of newly added dot-symbols. */
3766
3767 if (string[0] == '.')
3768 {
3769 struct ppc_link_hash_table *htab;
3770
3771 htab = (struct ppc_link_hash_table *) table;
3772 eh->u.next_dot_sym = htab->dot_syms;
3773 htab->dot_syms = eh;
3774 }
3775 }
3776
3777 return entry;
3778 }
3779
3780 /* Create a ppc64 ELF linker hash table. */
3781
3782 static struct bfd_link_hash_table *
3783 ppc64_elf_link_hash_table_create (bfd *abfd)
3784 {
3785 struct ppc_link_hash_table *htab;
3786 bfd_size_type amt = sizeof (struct ppc_link_hash_table);
3787
3788 htab = bfd_zmalloc (amt);
3789 if (htab == NULL)
3790 return NULL;
3791
3792 if (!_bfd_elf_link_hash_table_init (&htab->elf, abfd, link_hash_newfunc,
3793 sizeof (struct ppc_link_hash_entry)))
3794 {
3795 free (htab);
3796 return NULL;
3797 }
3798
3799 /* Init the stub hash table too. */
3800 if (!bfd_hash_table_init (&htab->stub_hash_table, stub_hash_newfunc,
3801 sizeof (struct ppc_stub_hash_entry)))
3802 return NULL;
3803
3804 /* And the branch hash table. */
3805 if (!bfd_hash_table_init (&htab->branch_hash_table, branch_hash_newfunc,
3806 sizeof (struct ppc_branch_hash_entry)))
3807 return NULL;
3808
3809 /* Initializing two fields of the union is just cosmetic. We really
3810 only care about glist, but when compiled on a 32-bit host the
3811 bfd_vma fields are larger. Setting the bfd_vma to zero makes
3812 debugger inspection of these fields look nicer. */
3813 htab->elf.init_got_refcount.refcount = 0;
3814 htab->elf.init_got_refcount.glist = NULL;
3815 htab->elf.init_plt_refcount.refcount = 0;
3816 htab->elf.init_plt_refcount.glist = NULL;
3817 htab->elf.init_got_offset.offset = 0;
3818 htab->elf.init_got_offset.glist = NULL;
3819 htab->elf.init_plt_offset.offset = 0;
3820 htab->elf.init_plt_offset.glist = NULL;
3821
3822 return &htab->elf.root;
3823 }
3824
3825 /* Free the derived linker hash table. */
3826
3827 static void
3828 ppc64_elf_link_hash_table_free (struct bfd_link_hash_table *hash)
3829 {
3830 struct ppc_link_hash_table *ret = (struct ppc_link_hash_table *) hash;
3831
3832 bfd_hash_table_free (&ret->stub_hash_table);
3833 bfd_hash_table_free (&ret->branch_hash_table);
3834 _bfd_generic_link_hash_table_free (hash);
3835 }
3836
3837 /* Satisfy the ELF linker by filling in some fields in our fake bfd. */
3838
3839 void
3840 ppc64_elf_init_stub_bfd (bfd *abfd, struct bfd_link_info *info)
3841 {
3842 struct ppc_link_hash_table *htab;
3843
3844 elf_elfheader (abfd)->e_ident[EI_CLASS] = ELFCLASS64;
3845
3846 /* Always hook our dynamic sections into the first bfd, which is the
3847 linker created stub bfd. This ensures that the GOT header is at
3848 the start of the output TOC section. */
3849 htab = ppc_hash_table (info);
3850 htab->stub_bfd = abfd;
3851 htab->elf.dynobj = abfd;
3852 }
3853
3854 /* Build a name for an entry in the stub hash table. */
3855
3856 static char *
3857 ppc_stub_name (const asection *input_section,
3858 const asection *sym_sec,
3859 const struct ppc_link_hash_entry *h,
3860 const Elf_Internal_Rela *rel)
3861 {
3862 char *stub_name;
3863 bfd_size_type len;
3864
3865 /* rel->r_addend is actually 64 bit, but who uses more than +/- 2^31
3866 offsets from a sym as a branch target? In fact, we could
3867 probably assume the addend is always zero. */
3868 BFD_ASSERT (((int) rel->r_addend & 0xffffffff) == rel->r_addend);
3869
3870 if (h)
3871 {
3872 len = 8 + 1 + strlen (h->elf.root.root.string) + 1 + 8 + 1;
3873 stub_name = bfd_malloc (len);
3874 if (stub_name == NULL)
3875 return stub_name;
3876
3877 sprintf (stub_name, "%08x.%s+%x",
3878 input_section->id & 0xffffffff,
3879 h->elf.root.root.string,
3880 (int) rel->r_addend & 0xffffffff);
3881 }
3882 else
3883 {
3884 len = 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1;
3885 stub_name = bfd_malloc (len);
3886 if (stub_name == NULL)
3887 return stub_name;
3888
3889 sprintf (stub_name, "%08x.%x:%x+%x",
3890 input_section->id & 0xffffffff,
3891 sym_sec->id & 0xffffffff,
3892 (int) ELF64_R_SYM (rel->r_info) & 0xffffffff,
3893 (int) rel->r_addend & 0xffffffff);
3894 }
3895 if (stub_name[len - 2] == '+' && stub_name[len - 1] == '0')
3896 stub_name[len - 2] = 0;
3897 return stub_name;
3898 }
3899
3900 /* Look up an entry in the stub hash. Stub entries are cached because
3901 creating the stub name takes a bit of time. */
3902
3903 static struct ppc_stub_hash_entry *
3904 ppc_get_stub_entry (const asection *input_section,
3905 const asection *sym_sec,
3906 struct ppc_link_hash_entry *h,
3907 const Elf_Internal_Rela *rel,
3908 struct ppc_link_hash_table *htab)
3909 {
3910 struct ppc_stub_hash_entry *stub_entry;
3911 const asection *id_sec;
3912
3913 /* If this input section is part of a group of sections sharing one
3914 stub section, then use the id of the first section in the group.
3915 Stub names need to include a section id, as there may well be
3916 more than one stub used to reach say, printf, and we need to
3917 distinguish between them. */
3918 id_sec = htab->stub_group[input_section->id].link_sec;
3919
3920 if (h != NULL && h->u.stub_cache != NULL
3921 && h->u.stub_cache->h == h
3922 && h->u.stub_cache->id_sec == id_sec)
3923 {
3924 stub_entry = h->u.stub_cache;
3925 }
3926 else
3927 {
3928 char *stub_name;
3929
3930 stub_name = ppc_stub_name (id_sec, sym_sec, h, rel);
3931 if (stub_name == NULL)
3932 return NULL;
3933
3934 stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
3935 stub_name, FALSE, FALSE);
3936 if (h != NULL)
3937 h->u.stub_cache = stub_entry;
3938
3939 free (stub_name);
3940 }
3941
3942 return stub_entry;
3943 }
3944
3945 /* Add a new stub entry to the stub hash. Not all fields of the new
3946 stub entry are initialised. */
3947
3948 static struct ppc_stub_hash_entry *
3949 ppc_add_stub (const char *stub_name,
3950 asection *section,
3951 struct ppc_link_hash_table *htab)
3952 {
3953 asection *link_sec;
3954 asection *stub_sec;
3955 struct ppc_stub_hash_entry *stub_entry;
3956
3957 link_sec = htab->stub_group[section->id].link_sec;
3958 stub_sec = htab->stub_group[section->id].stub_sec;
3959 if (stub_sec == NULL)
3960 {
3961 stub_sec = htab->stub_group[link_sec->id].stub_sec;
3962 if (stub_sec == NULL)
3963 {
3964 size_t namelen;
3965 bfd_size_type len;
3966 char *s_name;
3967
3968 namelen = strlen (link_sec->name);
3969 len = namelen + sizeof (STUB_SUFFIX);
3970 s_name = bfd_alloc (htab->stub_bfd, len);
3971 if (s_name == NULL)
3972 return NULL;
3973
3974 memcpy (s_name, link_sec->name, namelen);
3975 memcpy (s_name + namelen, STUB_SUFFIX, sizeof (STUB_SUFFIX));
3976 stub_sec = (*htab->add_stub_section) (s_name, link_sec);
3977 if (stub_sec == NULL)
3978 return NULL;
3979 htab->stub_group[link_sec->id].stub_sec = stub_sec;
3980 }
3981 htab->stub_group[section->id].stub_sec = stub_sec;
3982 }
3983
3984 /* Enter this entry into the linker stub hash table. */
3985 stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table, stub_name,
3986 TRUE, FALSE);
3987 if (stub_entry == NULL)
3988 {
3989 (*_bfd_error_handler) (_("%B: cannot create stub entry %s"),
3990 section->owner, stub_name);
3991 return NULL;
3992 }
3993
3994 stub_entry->stub_sec = stub_sec;
3995 stub_entry->stub_offset = 0;
3996 stub_entry->id_sec = link_sec;
3997 return stub_entry;
3998 }
3999
4000 /* Create sections for linker generated code. */
4001
4002 static bfd_boolean
4003 create_linkage_sections (bfd *dynobj, struct bfd_link_info *info)
4004 {
4005 struct ppc_link_hash_table *htab;
4006 flagword flags;
4007
4008 htab = ppc_hash_table (info);
4009
4010 /* Create .sfpr for code to save and restore fp regs. */
4011 flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY
4012 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4013 htab->sfpr = bfd_make_section_anyway_with_flags (dynobj, ".sfpr",
4014 flags);
4015 if (htab->sfpr == NULL
4016 || ! bfd_set_section_alignment (dynobj, htab->sfpr, 2))
4017 return FALSE;
4018
4019 /* Create .glink for lazy dynamic linking support. */
4020 htab->glink = bfd_make_section_anyway_with_flags (dynobj, ".glink",
4021 flags);
4022 if (htab->glink == NULL
4023 || ! bfd_set_section_alignment (dynobj, htab->glink, 3))
4024 return FALSE;
4025
4026 /* Create branch lookup table for plt_branch stubs. */
4027 flags = (SEC_ALLOC | SEC_LOAD
4028 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4029 htab->brlt = bfd_make_section_anyway_with_flags (dynobj, ".branch_lt",
4030 flags);
4031 if (htab->brlt == NULL
4032 || ! bfd_set_section_alignment (dynobj, htab->brlt, 3))
4033 return FALSE;
4034
4035 if (!info->shared)
4036 return TRUE;
4037
4038 flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4039 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4040 htab->relbrlt = bfd_make_section_anyway_with_flags (dynobj,
4041 ".rela.branch_lt",
4042 flags);
4043 if (!htab->relbrlt
4044 || ! bfd_set_section_alignment (dynobj, htab->relbrlt, 3))
4045 return FALSE;
4046
4047 return TRUE;
4048 }
4049
4050 /* Create .got and .rela.got sections in ABFD, and .got in dynobj if
4051 not already done. */
4052
4053 static bfd_boolean
4054 create_got_section (bfd *abfd, struct bfd_link_info *info)
4055 {
4056 asection *got, *relgot;
4057 flagword flags;
4058 struct ppc_link_hash_table *htab = ppc_hash_table (info);
4059
4060 if (!is_ppc64_elf (abfd))
4061 return FALSE;
4062
4063 if (!htab->got)
4064 {
4065 if (! _bfd_elf_create_got_section (htab->elf.dynobj, info))
4066 return FALSE;
4067
4068 htab->got = bfd_get_section_by_name (htab->elf.dynobj, ".got");
4069 if (!htab->got)
4070 abort ();
4071 }
4072
4073 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
4074 | SEC_LINKER_CREATED);
4075
4076 got = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
4077 if (!got
4078 || !bfd_set_section_alignment (abfd, got, 3))
4079 return FALSE;
4080
4081 relgot = bfd_make_section_anyway_with_flags (abfd, ".rela.got",
4082 flags | SEC_READONLY);
4083 if (!relgot
4084 || ! bfd_set_section_alignment (abfd, relgot, 3))
4085 return FALSE;
4086
4087 ppc64_elf_tdata (abfd)->got = got;
4088 ppc64_elf_tdata (abfd)->relgot = relgot;
4089 return TRUE;
4090 }
4091
4092 /* Create the dynamic sections, and set up shortcuts. */
4093
4094 static bfd_boolean
4095 ppc64_elf_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
4096 {
4097 struct ppc_link_hash_table *htab;
4098
4099 if (!_bfd_elf_create_dynamic_sections (dynobj, info))
4100 return FALSE;
4101
4102 htab = ppc_hash_table (info);
4103 if (!htab->got)
4104 htab->got = bfd_get_section_by_name (dynobj, ".got");
4105 htab->plt = bfd_get_section_by_name (dynobj, ".plt");
4106 htab->relplt = bfd_get_section_by_name (dynobj, ".rela.plt");
4107 htab->dynbss = bfd_get_section_by_name (dynobj, ".dynbss");
4108 if (!info->shared)
4109 htab->relbss = bfd_get_section_by_name (dynobj, ".rela.bss");
4110
4111 if (!htab->got || !htab->plt || !htab->relplt || !htab->dynbss
4112 || (!info->shared && !htab->relbss))
4113 abort ();
4114
4115 return TRUE;
4116 }
4117
4118 /* Merge PLT info on FROM with that on TO. */
4119
4120 static void
4121 move_plt_plist (struct ppc_link_hash_entry *from,
4122 struct ppc_link_hash_entry *to)
4123 {
4124 if (from->elf.plt.plist != NULL)
4125 {
4126 if (to->elf.plt.plist != NULL)
4127 {
4128 struct plt_entry **entp;
4129 struct plt_entry *ent;
4130
4131 for (entp = &from->elf.plt.plist; (ent = *entp) != NULL; )
4132 {
4133 struct plt_entry *dent;
4134
4135 for (dent = to->elf.plt.plist; dent != NULL; dent = dent->next)
4136 if (dent->addend == ent->addend)
4137 {
4138 dent->plt.refcount += ent->plt.refcount;
4139 *entp = ent->next;
4140 break;
4141 }
4142 if (dent == NULL)
4143 entp = &ent->next;
4144 }
4145 *entp = to->elf.plt.plist;
4146 }
4147
4148 to->elf.plt.plist = from->elf.plt.plist;
4149 from->elf.plt.plist = NULL;
4150 }
4151 }
4152
4153 /* Copy the extra info we tack onto an elf_link_hash_entry. */
4154
4155 static void
4156 ppc64_elf_copy_indirect_symbol (struct bfd_link_info *info,
4157 struct elf_link_hash_entry *dir,
4158 struct elf_link_hash_entry *ind)
4159 {
4160 struct ppc_link_hash_entry *edir, *eind;
4161
4162 edir = (struct ppc_link_hash_entry *) dir;
4163 eind = (struct ppc_link_hash_entry *) ind;
4164
4165 /* Copy over any dynamic relocs we may have on the indirect sym. */
4166 if (eind->dyn_relocs != NULL)
4167 {
4168 if (edir->dyn_relocs != NULL)
4169 {
4170 struct ppc_dyn_relocs **pp;
4171 struct ppc_dyn_relocs *p;
4172
4173 /* Add reloc counts against the indirect sym to the direct sym
4174 list. Merge any entries against the same section. */
4175 for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
4176 {
4177 struct ppc_dyn_relocs *q;
4178
4179 for (q = edir->dyn_relocs; q != NULL; q = q->next)
4180 if (q->sec == p->sec)
4181 {
4182 q->pc_count += p->pc_count;
4183 q->count += p->count;
4184 *pp = p->next;
4185 break;
4186 }
4187 if (q == NULL)
4188 pp = &p->next;
4189 }
4190 *pp = edir->dyn_relocs;
4191 }
4192
4193 edir->dyn_relocs = eind->dyn_relocs;
4194 eind->dyn_relocs = NULL;
4195 }
4196
4197 edir->is_func |= eind->is_func;
4198 edir->is_func_descriptor |= eind->is_func_descriptor;
4199 edir->tls_mask |= eind->tls_mask;
4200
4201 /* If called to transfer flags for a weakdef during processing
4202 of elf_adjust_dynamic_symbol, don't copy NON_GOT_REF.
4203 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
4204 if (!(ELIMINATE_COPY_RELOCS
4205 && eind->elf.root.type != bfd_link_hash_indirect
4206 && edir->elf.dynamic_adjusted))
4207 edir->elf.non_got_ref |= eind->elf.non_got_ref;
4208
4209 edir->elf.ref_dynamic |= eind->elf.ref_dynamic;
4210 edir->elf.ref_regular |= eind->elf.ref_regular;
4211 edir->elf.ref_regular_nonweak |= eind->elf.ref_regular_nonweak;
4212 edir->elf.needs_plt |= eind->elf.needs_plt;
4213
4214 /* If we were called to copy over info for a weak sym, that's all. */
4215 if (eind->elf.root.type != bfd_link_hash_indirect)
4216 return;
4217
4218 /* Copy over got entries that we may have already seen to the
4219 symbol which just became indirect. */
4220 if (eind->elf.got.glist != NULL)
4221 {
4222 if (edir->elf.got.glist != NULL)
4223 {
4224 struct got_entry **entp;
4225 struct got_entry *ent;
4226
4227 for (entp = &eind->elf.got.glist; (ent = *entp) != NULL; )
4228 {
4229 struct got_entry *dent;
4230
4231 for (dent = edir->elf.got.glist; dent != NULL; dent = dent->next)
4232 if (dent->addend == ent->addend
4233 && dent->owner == ent->owner
4234 && dent->tls_type == ent->tls_type)
4235 {
4236 dent->got.refcount += ent->got.refcount;
4237 *entp = ent->next;
4238 break;
4239 }
4240 if (dent == NULL)
4241 entp = &ent->next;
4242 }
4243 *entp = edir->elf.got.glist;
4244 }
4245
4246 edir->elf.got.glist = eind->elf.got.glist;
4247 eind->elf.got.glist = NULL;
4248 }
4249
4250 /* And plt entries. */
4251 move_plt_plist (eind, edir);
4252
4253 if (eind->elf.dynindx != -1)
4254 {
4255 if (edir->elf.dynindx != -1)
4256 _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
4257 edir->elf.dynstr_index);
4258 edir->elf.dynindx = eind->elf.dynindx;
4259 edir->elf.dynstr_index = eind->elf.dynstr_index;
4260 eind->elf.dynindx = -1;
4261 eind->elf.dynstr_index = 0;
4262 }
4263 }
4264
4265 /* Find the function descriptor hash entry from the given function code
4266 hash entry FH. Link the entries via their OH fields. */
4267
4268 static struct ppc_link_hash_entry *
4269 get_fdh (struct ppc_link_hash_entry *fh, struct ppc_link_hash_table *htab)
4270 {
4271 struct ppc_link_hash_entry *fdh = fh->oh;
4272
4273 if (fdh == NULL)
4274 {
4275 const char *fd_name = fh->elf.root.root.string + 1;
4276
4277 fdh = (struct ppc_link_hash_entry *)
4278 elf_link_hash_lookup (&htab->elf, fd_name, FALSE, FALSE, FALSE);
4279 if (fdh != NULL)
4280 {
4281 fdh->is_func_descriptor = 1;
4282 fdh->oh = fh;
4283 fh->is_func = 1;
4284 fh->oh = fdh;
4285 }
4286 }
4287
4288 return fdh;
4289 }
4290
4291 /* Make a fake function descriptor sym for the code sym FH. */
4292
4293 static struct ppc_link_hash_entry *
4294 make_fdh (struct bfd_link_info *info,
4295 struct ppc_link_hash_entry *fh)
4296 {
4297 bfd *abfd;
4298 asymbol *newsym;
4299 struct bfd_link_hash_entry *bh;
4300 struct ppc_link_hash_entry *fdh;
4301
4302 abfd = fh->elf.root.u.undef.abfd;
4303 newsym = bfd_make_empty_symbol (abfd);
4304 newsym->name = fh->elf.root.root.string + 1;
4305 newsym->section = bfd_und_section_ptr;
4306 newsym->value = 0;
4307 newsym->flags = BSF_WEAK;
4308
4309 bh = NULL;
4310 if (!_bfd_generic_link_add_one_symbol (info, abfd, newsym->name,
4311 newsym->flags, newsym->section,
4312 newsym->value, NULL, FALSE, FALSE,
4313 &bh))
4314 return NULL;
4315
4316 fdh = (struct ppc_link_hash_entry *) bh;
4317 fdh->elf.non_elf = 0;
4318 fdh->fake = 1;
4319 fdh->is_func_descriptor = 1;
4320 fdh->oh = fh;
4321 fh->is_func = 1;
4322 fh->oh = fdh;
4323 return fdh;
4324 }
4325
4326 /* Fix function descriptor symbols defined in .opd sections to be
4327 function type. */
4328
4329 static bfd_boolean
4330 ppc64_elf_add_symbol_hook (bfd *ibfd ATTRIBUTE_UNUSED,
4331 struct bfd_link_info *info ATTRIBUTE_UNUSED,
4332 Elf_Internal_Sym *isym,
4333 const char **name ATTRIBUTE_UNUSED,
4334 flagword *flags ATTRIBUTE_UNUSED,
4335 asection **sec,
4336 bfd_vma *value ATTRIBUTE_UNUSED)
4337 {
4338 if (*sec != NULL
4339 && strcmp (bfd_get_section_name (ibfd, *sec), ".opd") == 0)
4340 isym->st_info = ELF_ST_INFO (ELF_ST_BIND (isym->st_info), STT_FUNC);
4341
4342 return TRUE;
4343 }
4344
4345 /* This function makes an old ABI object reference to ".bar" cause the
4346 inclusion of a new ABI object archive that defines "bar".
4347 NAME is a symbol defined in an archive. Return a symbol in the hash
4348 table that might be satisfied by the archive symbols. */
4349
4350 static struct elf_link_hash_entry *
4351 ppc64_elf_archive_symbol_lookup (bfd *abfd,
4352 struct bfd_link_info *info,
4353 const char *name)
4354 {
4355 struct elf_link_hash_entry *h;
4356 char *dot_name;
4357 size_t len;
4358
4359 h = _bfd_elf_archive_symbol_lookup (abfd, info, name);
4360 if (h != NULL
4361 /* Don't return this sym if it is a fake function descriptor
4362 created by add_symbol_adjust. */
4363 && !(h->root.type == bfd_link_hash_undefweak
4364 && ((struct ppc_link_hash_entry *) h)->fake))
4365 return h;
4366
4367 if (name[0] == '.')
4368 return h;
4369
4370 len = strlen (name);
4371 dot_name = bfd_alloc (abfd, len + 2);
4372 if (dot_name == NULL)
4373 return (struct elf_link_hash_entry *) 0 - 1;
4374 dot_name[0] = '.';
4375 memcpy (dot_name + 1, name, len + 1);
4376 h = _bfd_elf_archive_symbol_lookup (abfd, info, dot_name);
4377 bfd_release (abfd, dot_name);
4378 return h;
4379 }
4380
4381 /* This function satisfies all old ABI object references to ".bar" if a
4382 new ABI object defines "bar". Well, at least, undefined dot symbols
4383 are made weak. This stops later archive searches from including an
4384 object if we already have a function descriptor definition. It also
4385 prevents the linker complaining about undefined symbols.
4386 We also check and correct mismatched symbol visibility here. The
4387 most restrictive visibility of the function descriptor and the
4388 function entry symbol is used. */
4389
4390 static bfd_boolean
4391 add_symbol_adjust (struct ppc_link_hash_entry *eh, struct bfd_link_info *info)
4392 {
4393 struct ppc_link_hash_table *htab;
4394 struct ppc_link_hash_entry *fdh;
4395
4396 if (eh->elf.root.type == bfd_link_hash_indirect)
4397 return TRUE;
4398
4399 if (eh->elf.root.type == bfd_link_hash_warning)
4400 eh = (struct ppc_link_hash_entry *) eh->elf.root.u.i.link;
4401
4402 if (eh->elf.root.root.string[0] != '.')
4403 abort ();
4404
4405 htab = ppc_hash_table (info);
4406 fdh = get_fdh (eh, htab);
4407 if (fdh == NULL
4408 && !info->relocatable
4409 && (eh->elf.root.type == bfd_link_hash_undefined
4410 || eh->elf.root.type == bfd_link_hash_undefweak)
4411 && eh->elf.ref_regular)
4412 {
4413 /* Make an undefweak function descriptor sym, which is enough to
4414 pull in an --as-needed shared lib, but won't cause link
4415 errors. Archives are handled elsewhere. */
4416 fdh = make_fdh (info, eh);
4417 if (fdh == NULL)
4418 return FALSE;
4419 else
4420 fdh->elf.ref_regular = 1;
4421 }
4422 else if (fdh != NULL)
4423 {
4424 unsigned entry_vis = ELF_ST_VISIBILITY (eh->elf.other) - 1;
4425 unsigned descr_vis = ELF_ST_VISIBILITY (fdh->elf.other) - 1;
4426 if (entry_vis < descr_vis)
4427 fdh->elf.other += entry_vis - descr_vis;
4428 else if (entry_vis > descr_vis)
4429 eh->elf.other += descr_vis - entry_vis;
4430
4431 if ((fdh->elf.root.type == bfd_link_hash_defined
4432 || fdh->elf.root.type == bfd_link_hash_defweak)
4433 && eh->elf.root.type == bfd_link_hash_undefined)
4434 {
4435 eh->elf.root.type = bfd_link_hash_undefweak;
4436 eh->was_undefined = 1;
4437 htab->twiddled_syms = 1;
4438 }
4439 }
4440
4441 return TRUE;
4442 }
4443
4444 /* Process list of dot-symbols we made in link_hash_newfunc. */
4445
4446 static bfd_boolean
4447 ppc64_elf_process_dot_syms (bfd *ibfd, struct bfd_link_info *info)
4448 {
4449 struct ppc_link_hash_table *htab;
4450 struct ppc_link_hash_entry **p, *eh;
4451
4452 htab = ppc_hash_table (info);
4453 if (!is_ppc64_elf (info->output_bfd))
4454 return TRUE;
4455
4456 if (is_ppc64_elf (ibfd))
4457 {
4458 p = &htab->dot_syms;
4459 while ((eh = *p) != NULL)
4460 {
4461 *p = NULL;
4462 if (!add_symbol_adjust (eh, info))
4463 return FALSE;
4464 p = &eh->u.next_dot_sym;
4465 }
4466 }
4467
4468 /* Clear the list for non-ppc64 input files. */
4469 p = &htab->dot_syms;
4470 while ((eh = *p) != NULL)
4471 {
4472 *p = NULL;
4473 p = &eh->u.next_dot_sym;
4474 }
4475
4476 /* We need to fix the undefs list for any syms we have twiddled to
4477 undef_weak. */
4478 if (htab->twiddled_syms)
4479 {
4480 bfd_link_repair_undef_list (&htab->elf.root);
4481 htab->twiddled_syms = 0;
4482 }
4483 return TRUE;
4484 }
4485
4486 /* Undo hash table changes when an --as-needed input file is determined
4487 not to be needed. */
4488
4489 static bfd_boolean
4490 ppc64_elf_as_needed_cleanup (bfd *ibfd ATTRIBUTE_UNUSED,
4491 struct bfd_link_info *info)
4492 {
4493 ppc_hash_table (info)->dot_syms = NULL;
4494 return TRUE;
4495 }
4496
4497 static bfd_boolean
4498 update_local_sym_info (bfd *abfd, Elf_Internal_Shdr *symtab_hdr,
4499 unsigned long r_symndx, bfd_vma r_addend, int tls_type)
4500 {
4501 struct got_entry **local_got_ents = elf_local_got_ents (abfd);
4502 char *local_got_tls_masks;
4503
4504 if (local_got_ents == NULL)
4505 {
4506 bfd_size_type size = symtab_hdr->sh_info;
4507
4508 size *= sizeof (*local_got_ents) + sizeof (*local_got_tls_masks);
4509 local_got_ents = bfd_zalloc (abfd, size);
4510 if (local_got_ents == NULL)
4511 return FALSE;
4512 elf_local_got_ents (abfd) = local_got_ents;
4513 }
4514
4515 if ((tls_type & TLS_EXPLICIT) == 0)
4516 {
4517 struct got_entry *ent;
4518
4519 for (ent = local_got_ents[r_symndx]; ent != NULL; ent = ent->next)
4520 if (ent->addend == r_addend
4521 && ent->owner == abfd
4522 && ent->tls_type == tls_type)
4523 break;
4524 if (ent == NULL)
4525 {
4526 bfd_size_type amt = sizeof (*ent);
4527 ent = bfd_alloc (abfd, amt);
4528 if (ent == NULL)
4529 return FALSE;
4530 ent->next = local_got_ents[r_symndx];
4531 ent->addend = r_addend;
4532 ent->owner = abfd;
4533 ent->tls_type = tls_type;
4534 ent->got.refcount = 0;
4535 local_got_ents[r_symndx] = ent;
4536 }
4537 ent->got.refcount += 1;
4538 }
4539
4540 local_got_tls_masks = (char *) (local_got_ents + symtab_hdr->sh_info);
4541 local_got_tls_masks[r_symndx] |= tls_type;
4542 return TRUE;
4543 }
4544
4545 static bfd_boolean
4546 update_plt_info (bfd *abfd, struct ppc_link_hash_entry *eh, bfd_vma addend)
4547 {
4548 struct plt_entry *ent;
4549
4550 for (ent = eh->elf.plt.plist; ent != NULL; ent = ent->next)
4551 if (ent->addend == addend)
4552 break;
4553 if (ent == NULL)
4554 {
4555 bfd_size_type amt = sizeof (*ent);
4556 ent = bfd_alloc (abfd, amt);
4557 if (ent == NULL)
4558 return FALSE;
4559 ent->next = eh->elf.plt.plist;
4560 ent->addend = addend;
4561 ent->plt.refcount = 0;
4562 eh->elf.plt.plist = ent;
4563 }
4564 ent->plt.refcount += 1;
4565 eh->elf.needs_plt = 1;
4566 if (eh->elf.root.root.string[0] == '.'
4567 && eh->elf.root.root.string[1] != '\0')
4568 eh->is_func = 1;
4569 return TRUE;
4570 }
4571
4572 /* Look through the relocs for a section during the first phase, and
4573 calculate needed space in the global offset table, procedure
4574 linkage table, and dynamic reloc sections. */
4575
4576 static bfd_boolean
4577 ppc64_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
4578 asection *sec, const Elf_Internal_Rela *relocs)
4579 {
4580 struct ppc_link_hash_table *htab;
4581 Elf_Internal_Shdr *symtab_hdr;
4582 struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
4583 const Elf_Internal_Rela *rel;
4584 const Elf_Internal_Rela *rel_end;
4585 asection *sreloc;
4586 asection **opd_sym_map;
4587 struct elf_link_hash_entry *tga, *dottga;
4588
4589 if (info->relocatable)
4590 return TRUE;
4591
4592 /* Don't do anything special with non-loaded, non-alloced sections.
4593 In particular, any relocs in such sections should not affect GOT
4594 and PLT reference counting (ie. we don't allow them to create GOT
4595 or PLT entries), there's no possibility or desire to optimize TLS
4596 relocs, and there's not much point in propagating relocs to shared
4597 libs that the dynamic linker won't relocate. */
4598 if ((sec->flags & SEC_ALLOC) == 0)
4599 return TRUE;
4600
4601 BFD_ASSERT (is_ppc64_elf (abfd));
4602
4603 htab = ppc_hash_table (info);
4604 tga = elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
4605 FALSE, FALSE, TRUE);
4606 dottga = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
4607 FALSE, FALSE, TRUE);
4608 symtab_hdr = &elf_symtab_hdr (abfd);
4609
4610 sym_hashes = elf_sym_hashes (abfd);
4611 sym_hashes_end = (sym_hashes
4612 + symtab_hdr->sh_size / sizeof (Elf64_External_Sym)
4613 - symtab_hdr->sh_info);
4614
4615 sreloc = NULL;
4616 opd_sym_map = NULL;
4617 if (strcmp (bfd_get_section_name (abfd, sec), ".opd") == 0)
4618 {
4619 /* Garbage collection needs some extra help with .opd sections.
4620 We don't want to necessarily keep everything referenced by
4621 relocs in .opd, as that would keep all functions. Instead,
4622 if we reference an .opd symbol (a function descriptor), we
4623 want to keep the function code symbol's section. This is
4624 easy for global symbols, but for local syms we need to keep
4625 information about the associated function section. */
4626 bfd_size_type amt;
4627
4628 amt = sec->size * sizeof (*opd_sym_map) / 8;
4629 opd_sym_map = bfd_zalloc (abfd, amt);
4630 if (opd_sym_map == NULL)
4631 return FALSE;
4632 ppc64_elf_section_data (sec)->u.opd.func_sec = opd_sym_map;
4633 BFD_ASSERT (ppc64_elf_section_data (sec)->sec_type == sec_normal);
4634 ppc64_elf_section_data (sec)->sec_type = sec_opd;
4635 }
4636
4637 if (htab->sfpr == NULL
4638 && !create_linkage_sections (htab->elf.dynobj, info))
4639 return FALSE;
4640
4641 rel_end = relocs + sec->reloc_count;
4642 for (rel = relocs; rel < rel_end; rel++)
4643 {
4644 unsigned long r_symndx;
4645 struct elf_link_hash_entry *h;
4646 enum elf_ppc64_reloc_type r_type;
4647 int tls_type = 0;
4648 struct _ppc64_elf_section_data *ppc64_sec;
4649
4650 r_symndx = ELF64_R_SYM (rel->r_info);
4651 if (r_symndx < symtab_hdr->sh_info)
4652 h = NULL;
4653 else
4654 {
4655 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
4656 while (h->root.type == bfd_link_hash_indirect
4657 || h->root.type == bfd_link_hash_warning)
4658 h = (struct elf_link_hash_entry *) h->root.u.i.link;
4659 }
4660
4661 r_type = ELF64_R_TYPE (rel->r_info);
4662 switch (r_type)
4663 {
4664 case R_PPC64_GOT_TLSLD16:
4665 case R_PPC64_GOT_TLSLD16_LO:
4666 case R_PPC64_GOT_TLSLD16_HI:
4667 case R_PPC64_GOT_TLSLD16_HA:
4668 tls_type = TLS_TLS | TLS_LD;
4669 goto dogottls;
4670
4671 case R_PPC64_GOT_TLSGD16:
4672 case R_PPC64_GOT_TLSGD16_LO:
4673 case R_PPC64_GOT_TLSGD16_HI:
4674 case R_PPC64_GOT_TLSGD16_HA:
4675 tls_type = TLS_TLS | TLS_GD;
4676 goto dogottls;
4677
4678 case R_PPC64_GOT_TPREL16_DS:
4679 case R_PPC64_GOT_TPREL16_LO_DS:
4680 case R_PPC64_GOT_TPREL16_HI:
4681 case R_PPC64_GOT_TPREL16_HA:
4682 if (!info->executable)
4683 info->flags |= DF_STATIC_TLS;
4684 tls_type = TLS_TLS | TLS_TPREL;
4685 goto dogottls;
4686
4687 case R_PPC64_GOT_DTPREL16_DS:
4688 case R_PPC64_GOT_DTPREL16_LO_DS:
4689 case R_PPC64_GOT_DTPREL16_HI:
4690 case R_PPC64_GOT_DTPREL16_HA:
4691 tls_type = TLS_TLS | TLS_DTPREL;
4692 dogottls:
4693 sec->has_tls_reloc = 1;
4694 /* Fall thru */
4695
4696 case R_PPC64_GOT16:
4697 case R_PPC64_GOT16_DS:
4698 case R_PPC64_GOT16_HA:
4699 case R_PPC64_GOT16_HI:
4700 case R_PPC64_GOT16_LO:
4701 case R_PPC64_GOT16_LO_DS:
4702 /* This symbol requires a global offset table entry. */
4703 sec->has_toc_reloc = 1;
4704 if (ppc64_elf_tdata (abfd)->got == NULL
4705 && !create_got_section (abfd, info))
4706 return FALSE;
4707
4708 if (h != NULL)
4709 {
4710 struct ppc_link_hash_entry *eh;
4711 struct got_entry *ent;
4712
4713 eh = (struct ppc_link_hash_entry *) h;
4714 for (ent = eh->elf.got.glist; ent != NULL; ent = ent->next)
4715 if (ent->addend == rel->r_addend
4716 && ent->owner == abfd
4717 && ent->tls_type == tls_type)
4718 break;
4719 if (ent == NULL)
4720 {
4721 bfd_size_type amt = sizeof (*ent);
4722 ent = bfd_alloc (abfd, amt);
4723 if (ent == NULL)
4724 return FALSE;
4725 ent->next = eh->elf.got.glist;
4726 ent->addend = rel->r_addend;
4727 ent->owner = abfd;
4728 ent->tls_type = tls_type;
4729 ent->got.refcount = 0;
4730 eh->elf.got.glist = ent;
4731 }
4732 ent->got.refcount += 1;
4733 eh->tls_mask |= tls_type;
4734 }
4735 else
4736 /* This is a global offset table entry for a local symbol. */
4737 if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
4738 rel->r_addend, tls_type))
4739 return FALSE;
4740 break;
4741
4742 case R_PPC64_PLT16_HA:
4743 case R_PPC64_PLT16_HI:
4744 case R_PPC64_PLT16_LO:
4745 case R_PPC64_PLT32:
4746 case R_PPC64_PLT64:
4747 /* This symbol requires a procedure linkage table entry. We
4748 actually build the entry in adjust_dynamic_symbol,
4749 because this might be a case of linking PIC code without
4750 linking in any dynamic objects, in which case we don't
4751 need to generate a procedure linkage table after all. */
4752 if (h == NULL)
4753 {
4754 /* It does not make sense to have a procedure linkage
4755 table entry for a local symbol. */
4756 bfd_set_error (bfd_error_bad_value);
4757 return FALSE;
4758 }
4759 else
4760 if (!update_plt_info (abfd, (struct ppc_link_hash_entry *) h,
4761 rel->r_addend))
4762 return FALSE;
4763 break;
4764
4765 /* The following relocations don't need to propagate the
4766 relocation if linking a shared object since they are
4767 section relative. */
4768 case R_PPC64_SECTOFF:
4769 case R_PPC64_SECTOFF_LO:
4770 case R_PPC64_SECTOFF_HI:
4771 case R_PPC64_SECTOFF_HA:
4772 case R_PPC64_SECTOFF_DS:
4773 case R_PPC64_SECTOFF_LO_DS:
4774 case R_PPC64_DTPREL16:
4775 case R_PPC64_DTPREL16_LO:
4776 case R_PPC64_DTPREL16_HI:
4777 case R_PPC64_DTPREL16_HA:
4778 case R_PPC64_DTPREL16_DS:
4779 case R_PPC64_DTPREL16_LO_DS:
4780 case R_PPC64_DTPREL16_HIGHER:
4781 case R_PPC64_DTPREL16_HIGHERA:
4782 case R_PPC64_DTPREL16_HIGHEST:
4783 case R_PPC64_DTPREL16_HIGHESTA:
4784 break;
4785
4786 /* Nor do these. */
4787 case R_PPC64_TOC16:
4788 case R_PPC64_TOC16_LO:
4789 case R_PPC64_TOC16_HI:
4790 case R_PPC64_TOC16_HA:
4791 case R_PPC64_TOC16_DS:
4792 case R_PPC64_TOC16_LO_DS:
4793 sec->has_toc_reloc = 1;
4794 break;
4795
4796 /* This relocation describes the C++ object vtable hierarchy.
4797 Reconstruct it for later use during GC. */
4798 case R_PPC64_GNU_VTINHERIT:
4799 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
4800 return FALSE;
4801 break;
4802
4803 /* This relocation describes which C++ vtable entries are actually
4804 used. Record for later use during GC. */
4805 case R_PPC64_GNU_VTENTRY:
4806 BFD_ASSERT (h != NULL);
4807 if (h != NULL
4808 && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
4809 return FALSE;
4810 break;
4811
4812 case R_PPC64_REL14:
4813 case R_PPC64_REL14_BRTAKEN:
4814 case R_PPC64_REL14_BRNTAKEN:
4815 {
4816 asection *dest = NULL;
4817
4818 /* Heuristic: If jumping outside our section, chances are
4819 we are going to need a stub. */
4820 if (h != NULL)
4821 {
4822 /* If the sym is weak it may be overridden later, so
4823 don't assume we know where a weak sym lives. */
4824 if (h->root.type == bfd_link_hash_defined)
4825 dest = h->root.u.def.section;
4826 }
4827 else
4828 dest = bfd_section_from_r_symndx (abfd, &htab->sym_sec,
4829 sec, r_symndx);
4830 if (dest != sec)
4831 ppc64_elf_section_data (sec)->has_14bit_branch = 1;
4832 }
4833 /* Fall through. */
4834
4835 case R_PPC64_REL24:
4836 if (h != NULL)
4837 {
4838 /* We may need a .plt entry if the function this reloc
4839 refers to is in a shared lib. */
4840 if (!update_plt_info (abfd, (struct ppc_link_hash_entry *) h,
4841 rel->r_addend))
4842 return FALSE;
4843 if (h == tga || h == dottga)
4844 sec->has_tls_reloc = 1;
4845 }
4846 break;
4847
4848 case R_PPC64_TPREL64:
4849 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_TPREL;
4850 if (!info->executable)
4851 info->flags |= DF_STATIC_TLS;
4852 goto dotlstoc;
4853
4854 case R_PPC64_DTPMOD64:
4855 if (rel + 1 < rel_end
4856 && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
4857 && rel[1].r_offset == rel->r_offset + 8)
4858 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_GD;
4859 else
4860 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_LD;
4861 goto dotlstoc;
4862
4863 case R_PPC64_DTPREL64:
4864 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_DTPREL;
4865 if (rel != relocs
4866 && rel[-1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPMOD64)
4867 && rel[-1].r_offset == rel->r_offset - 8)
4868 /* This is the second reloc of a dtpmod, dtprel pair.
4869 Don't mark with TLS_DTPREL. */
4870 goto dodyn;
4871
4872 dotlstoc:
4873 sec->has_tls_reloc = 1;
4874 if (h != NULL)
4875 {
4876 struct ppc_link_hash_entry *eh;
4877 eh = (struct ppc_link_hash_entry *) h;
4878 eh->tls_mask |= tls_type;
4879 }
4880 else
4881 if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
4882 rel->r_addend, tls_type))
4883 return FALSE;
4884
4885 ppc64_sec = ppc64_elf_section_data (sec);
4886 if (ppc64_sec->sec_type != sec_toc)
4887 {
4888 bfd_size_type amt;
4889
4890 /* One extra to simplify get_tls_mask. */
4891 amt = sec->size * sizeof (unsigned) / 8 + sizeof (unsigned);
4892 ppc64_sec->u.toc.symndx = bfd_zalloc (abfd, amt);
4893 if (ppc64_sec->u.toc.symndx == NULL)
4894 return FALSE;
4895 amt = sec->size * sizeof (bfd_vma) / 8;
4896 ppc64_sec->u.toc.add = bfd_zalloc (abfd, amt);
4897 if (ppc64_sec->u.toc.add == NULL)
4898 return FALSE;
4899 BFD_ASSERT (ppc64_sec->sec_type == sec_normal);
4900 ppc64_sec->sec_type = sec_toc;
4901 }
4902 BFD_ASSERT (rel->r_offset % 8 == 0);
4903 ppc64_sec->u.toc.symndx[rel->r_offset / 8] = r_symndx;
4904 ppc64_sec->u.toc.add[rel->r_offset / 8] = rel->r_addend;
4905
4906 /* Mark the second slot of a GD or LD entry.
4907 -1 to indicate GD and -2 to indicate LD. */
4908 if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_GD))
4909 ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -1;
4910 else if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_LD))
4911 ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -2;
4912 goto dodyn;
4913
4914 case R_PPC64_TPREL16:
4915 case R_PPC64_TPREL16_LO:
4916 case R_PPC64_TPREL16_HI:
4917 case R_PPC64_TPREL16_HA:
4918 case R_PPC64_TPREL16_DS:
4919 case R_PPC64_TPREL16_LO_DS:
4920 case R_PPC64_TPREL16_HIGHER:
4921 case R_PPC64_TPREL16_HIGHERA:
4922 case R_PPC64_TPREL16_HIGHEST:
4923 case R_PPC64_TPREL16_HIGHESTA:
4924 if (info->shared)
4925 {
4926 if (!info->executable)
4927 info->flags |= DF_STATIC_TLS;
4928 goto dodyn;
4929 }
4930 break;
4931
4932 case R_PPC64_ADDR64:
4933 if (opd_sym_map != NULL
4934 && rel + 1 < rel_end
4935 && ELF64_R_TYPE ((rel + 1)->r_info) == R_PPC64_TOC)
4936 {
4937 if (h != NULL)
4938 {
4939 if (h->root.root.string[0] == '.'
4940 && h->root.root.string[1] != 0
4941 && get_fdh ((struct ppc_link_hash_entry *) h, htab))
4942 ;
4943 else
4944 ((struct ppc_link_hash_entry *) h)->is_func = 1;
4945 }
4946 else
4947 {
4948 asection *s;
4949
4950 s = bfd_section_from_r_symndx (abfd, &htab->sym_sec, sec,
4951 r_symndx);
4952 if (s == NULL)
4953 return FALSE;
4954 else if (s != sec)
4955 opd_sym_map[rel->r_offset / 8] = s;
4956 }
4957 }
4958 /* Fall through. */
4959
4960 case R_PPC64_REL30:
4961 case R_PPC64_REL32:
4962 case R_PPC64_REL64:
4963 case R_PPC64_ADDR14:
4964 case R_PPC64_ADDR14_BRNTAKEN:
4965 case R_PPC64_ADDR14_BRTAKEN:
4966 case R_PPC64_ADDR16:
4967 case R_PPC64_ADDR16_DS:
4968 case R_PPC64_ADDR16_HA:
4969 case R_PPC64_ADDR16_HI:
4970 case R_PPC64_ADDR16_HIGHER:
4971 case R_PPC64_ADDR16_HIGHERA:
4972 case R_PPC64_ADDR16_HIGHEST:
4973 case R_PPC64_ADDR16_HIGHESTA:
4974 case R_PPC64_ADDR16_LO:
4975 case R_PPC64_ADDR16_LO_DS:
4976 case R_PPC64_ADDR24:
4977 case R_PPC64_ADDR32:
4978 case R_PPC64_UADDR16:
4979 case R_PPC64_UADDR32:
4980 case R_PPC64_UADDR64:
4981 case R_PPC64_TOC:
4982 if (h != NULL && !info->shared)
4983 /* We may need a copy reloc. */
4984 h->non_got_ref = 1;
4985
4986 /* Don't propagate .opd relocs. */
4987 if (NO_OPD_RELOCS && opd_sym_map != NULL)
4988 break;
4989
4990 /* If we are creating a shared library, and this is a reloc
4991 against a global symbol, or a non PC relative reloc
4992 against a local symbol, then we need to copy the reloc
4993 into the shared library. However, if we are linking with
4994 -Bsymbolic, we do not need to copy a reloc against a
4995 global symbol which is defined in an object we are
4996 including in the link (i.e., DEF_REGULAR is set). At
4997 this point we have not seen all the input files, so it is
4998 possible that DEF_REGULAR is not set now but will be set
4999 later (it is never cleared). In case of a weak definition,
5000 DEF_REGULAR may be cleared later by a strong definition in
5001 a shared library. We account for that possibility below by
5002 storing information in the dyn_relocs field of the hash
5003 table entry. A similar situation occurs when creating
5004 shared libraries and symbol visibility changes render the
5005 symbol local.
5006
5007 If on the other hand, we are creating an executable, we
5008 may need to keep relocations for symbols satisfied by a
5009 dynamic library if we manage to avoid copy relocs for the
5010 symbol. */
5011 dodyn:
5012 if ((info->shared
5013 && (must_be_dyn_reloc (info, r_type)
5014 || (h != NULL
5015 && (! info->symbolic
5016 || h->root.type == bfd_link_hash_defweak
5017 || !h->def_regular))))
5018 || (ELIMINATE_COPY_RELOCS
5019 && !info->shared
5020 && h != NULL
5021 && (h->root.type == bfd_link_hash_defweak
5022 || !h->def_regular)))
5023 {
5024 struct ppc_dyn_relocs *p;
5025 struct ppc_dyn_relocs **head;
5026
5027 /* We must copy these reloc types into the output file.
5028 Create a reloc section in dynobj and make room for
5029 this reloc. */
5030 if (sreloc == NULL)
5031 {
5032 sreloc = _bfd_elf_make_dynamic_reloc_section
5033 (sec, htab->elf.dynobj, 3, abfd, /*rela?*/ TRUE);
5034
5035 if (sreloc == NULL)
5036 return FALSE;
5037 }
5038
5039 /* If this is a global symbol, we count the number of
5040 relocations we need for this symbol. */
5041 if (h != NULL)
5042 {
5043 head = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
5044 }
5045 else
5046 {
5047 /* Track dynamic relocs needed for local syms too.
5048 We really need local syms available to do this
5049 easily. Oh well. */
5050
5051 asection *s;
5052 void *vpp;
5053
5054 s = bfd_section_from_r_symndx (abfd, &htab->sym_sec,
5055 sec, r_symndx);
5056 if (s == NULL)
5057 return FALSE;
5058
5059 vpp = &elf_section_data (s)->local_dynrel;
5060 head = (struct ppc_dyn_relocs **) vpp;
5061 }
5062
5063 p = *head;
5064 if (p == NULL || p->sec != sec)
5065 {
5066 p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5067 if (p == NULL)
5068 return FALSE;
5069 p->next = *head;
5070 *head = p;
5071 p->sec = sec;
5072 p->count = 0;
5073 p->pc_count = 0;
5074 }
5075
5076 p->count += 1;
5077 if (!must_be_dyn_reloc (info, r_type))
5078 p->pc_count += 1;
5079 }
5080 break;
5081
5082 default:
5083 break;
5084 }
5085 }
5086
5087 return TRUE;
5088 }
5089
5090 /* OFFSET in OPD_SEC specifies a function descriptor. Return the address
5091 of the code entry point, and its section. */
5092
5093 static bfd_vma
5094 opd_entry_value (asection *opd_sec,
5095 bfd_vma offset,
5096 asection **code_sec,
5097 bfd_vma *code_off)
5098 {
5099 bfd *opd_bfd = opd_sec->owner;
5100 Elf_Internal_Rela *relocs;
5101 Elf_Internal_Rela *lo, *hi, *look;
5102 bfd_vma val;
5103
5104 /* No relocs implies we are linking a --just-symbols object. */
5105 if (opd_sec->reloc_count == 0)
5106 {
5107 bfd_vma val;
5108
5109 if (!bfd_get_section_contents (opd_bfd, opd_sec, &val, offset, 8))
5110 return (bfd_vma) -1;
5111
5112 if (code_sec != NULL)
5113 {
5114 asection *sec, *likely = NULL;
5115 for (sec = opd_bfd->sections; sec != NULL; sec = sec->next)
5116 if (sec->vma <= val
5117 && (sec->flags & SEC_LOAD) != 0
5118 && (sec->flags & SEC_ALLOC) != 0)
5119 likely = sec;
5120 if (likely != NULL)
5121 {
5122 *code_sec = likely;
5123 if (code_off != NULL)
5124 *code_off = val - likely->vma;
5125 }
5126 }
5127 return val;
5128 }
5129
5130 BFD_ASSERT (is_ppc64_elf (opd_bfd));
5131
5132 relocs = ppc64_elf_tdata (opd_bfd)->opd_relocs;
5133 if (relocs == NULL)
5134 relocs = _bfd_elf_link_read_relocs (opd_bfd, opd_sec, NULL, NULL, TRUE);
5135
5136 /* Go find the opd reloc at the sym address. */
5137 lo = relocs;
5138 BFD_ASSERT (lo != NULL);
5139 hi = lo + opd_sec->reloc_count - 1; /* ignore last reloc */
5140 val = (bfd_vma) -1;
5141 while (lo < hi)
5142 {
5143 look = lo + (hi - lo) / 2;
5144 if (look->r_offset < offset)
5145 lo = look + 1;
5146 else if (look->r_offset > offset)
5147 hi = look;
5148 else
5149 {
5150 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (opd_bfd);
5151
5152 if (ELF64_R_TYPE (look->r_info) == R_PPC64_ADDR64
5153 && ELF64_R_TYPE ((look + 1)->r_info) == R_PPC64_TOC)
5154 {
5155 unsigned long symndx = ELF64_R_SYM (look->r_info);
5156 asection *sec;
5157
5158 if (symndx < symtab_hdr->sh_info)
5159 {
5160 Elf_Internal_Sym *sym;
5161
5162 sym = (Elf_Internal_Sym *) symtab_hdr->contents;
5163 if (sym == NULL)
5164 {
5165 sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr,
5166 symtab_hdr->sh_info,
5167 0, NULL, NULL, NULL);
5168 if (sym == NULL)
5169 break;
5170 symtab_hdr->contents = (bfd_byte *) sym;
5171 }
5172
5173 sym += symndx;
5174 val = sym->st_value;
5175 sec = bfd_section_from_elf_index (opd_bfd, sym->st_shndx);
5176 BFD_ASSERT ((sec->flags & SEC_MERGE) == 0);
5177 }
5178 else
5179 {
5180 struct elf_link_hash_entry **sym_hashes;
5181 struct elf_link_hash_entry *rh;
5182
5183 sym_hashes = elf_sym_hashes (opd_bfd);
5184 rh = sym_hashes[symndx - symtab_hdr->sh_info];
5185 while (rh->root.type == bfd_link_hash_indirect
5186 || rh->root.type == bfd_link_hash_warning)
5187 rh = ((struct elf_link_hash_entry *) rh->root.u.i.link);
5188 BFD_ASSERT (rh->root.type == bfd_link_hash_defined
5189 || rh->root.type == bfd_link_hash_defweak);
5190 val = rh->root.u.def.value;
5191 sec = rh->root.u.def.section;
5192 }
5193 val += look->r_addend;
5194 if (code_off != NULL)
5195 *code_off = val;
5196 if (code_sec != NULL)
5197 *code_sec = sec;
5198 if (sec != NULL && sec->output_section != NULL)
5199 val += sec->output_section->vma + sec->output_offset;
5200 }
5201 break;
5202 }
5203 }
5204
5205 return val;
5206 }
5207
5208 /* Mark all our entry sym sections, both opd and code section. */
5209
5210 static void
5211 ppc64_elf_gc_keep (struct bfd_link_info *info)
5212 {
5213 struct ppc_link_hash_table *htab = ppc_hash_table (info);
5214 struct bfd_sym_chain *sym;
5215
5216 for (sym = info->gc_sym_list; sym != NULL; sym = sym->next)
5217 {
5218 struct ppc_link_hash_entry *eh;
5219 asection *sec;
5220
5221 eh = (struct ppc_link_hash_entry *)
5222 elf_link_hash_lookup (&htab->elf, sym->name, FALSE, FALSE, FALSE);
5223 if (eh == NULL)
5224 continue;
5225 if (eh->elf.root.type != bfd_link_hash_defined
5226 && eh->elf.root.type != bfd_link_hash_defweak)
5227 continue;
5228
5229 if (eh->is_func_descriptor
5230 && (eh->oh->elf.root.type == bfd_link_hash_defined
5231 || eh->oh->elf.root.type == bfd_link_hash_defweak))
5232 {
5233 sec = eh->oh->elf.root.u.def.section;
5234 sec->flags |= SEC_KEEP;
5235 }
5236 else if (get_opd_info (eh->elf.root.u.def.section) != NULL
5237 && opd_entry_value (eh->elf.root.u.def.section,
5238 eh->elf.root.u.def.value,
5239 &sec, NULL) != (bfd_vma) -1)
5240 sec->flags |= SEC_KEEP;
5241
5242 sec = eh->elf.root.u.def.section;
5243 sec->flags |= SEC_KEEP;
5244 }
5245 }
5246
5247 /* Mark sections containing dynamically referenced symbols. When
5248 building shared libraries, we must assume that any visible symbol is
5249 referenced. */
5250
5251 static bfd_boolean
5252 ppc64_elf_gc_mark_dynamic_ref (struct elf_link_hash_entry *h, void *inf)
5253 {
5254 struct bfd_link_info *info = (struct bfd_link_info *) inf;
5255 struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
5256
5257 if (eh->elf.root.type == bfd_link_hash_warning)
5258 eh = (struct ppc_link_hash_entry *) eh->elf.root.u.i.link;
5259
5260 /* Dynamic linking info is on the func descriptor sym. */
5261 if (eh->oh != NULL
5262 && eh->oh->is_func_descriptor
5263 && (eh->oh->elf.root.type == bfd_link_hash_defined
5264 || eh->oh->elf.root.type == bfd_link_hash_defweak))
5265 eh = eh->oh;
5266
5267 if ((eh->elf.root.type == bfd_link_hash_defined
5268 || eh->elf.root.type == bfd_link_hash_defweak)
5269 && (eh->elf.ref_dynamic
5270 || (!info->executable
5271 && eh->elf.def_regular
5272 && ELF_ST_VISIBILITY (eh->elf.other) != STV_INTERNAL
5273 && ELF_ST_VISIBILITY (eh->elf.other) != STV_HIDDEN)))
5274 {
5275 asection *code_sec;
5276
5277 eh->elf.root.u.def.section->flags |= SEC_KEEP;
5278
5279 /* Function descriptor syms cause the associated
5280 function code sym section to be marked. */
5281 if (eh->is_func_descriptor
5282 && (eh->oh->elf.root.type == bfd_link_hash_defined
5283 || eh->oh->elf.root.type == bfd_link_hash_defweak))
5284 eh->oh->elf.root.u.def.section->flags |= SEC_KEEP;
5285 else if (get_opd_info (eh->elf.root.u.def.section) != NULL
5286 && opd_entry_value (eh->elf.root.u.def.section,
5287 eh->elf.root.u.def.value,
5288 &code_sec, NULL) != (bfd_vma) -1)
5289 code_sec->flags |= SEC_KEEP;
5290 }
5291
5292 return TRUE;
5293 }
5294
5295 /* Return the section that should be marked against GC for a given
5296 relocation. */
5297
5298 static asection *
5299 ppc64_elf_gc_mark_hook (asection *sec,
5300 struct bfd_link_info *info ATTRIBUTE_UNUSED,
5301 Elf_Internal_Rela *rel,
5302 struct elf_link_hash_entry *h,
5303 Elf_Internal_Sym *sym)
5304 {
5305 asection *rsec;
5306
5307 /* Syms return NULL if we're marking .opd, so we avoid marking all
5308 function sections, as all functions are referenced in .opd. */
5309 rsec = NULL;
5310 if (get_opd_info (sec) != NULL)
5311 return rsec;
5312
5313 if (h != NULL)
5314 {
5315 enum elf_ppc64_reloc_type r_type;
5316 struct ppc_link_hash_entry *eh;
5317
5318 r_type = ELF64_R_TYPE (rel->r_info);
5319 switch (r_type)
5320 {
5321 case R_PPC64_GNU_VTINHERIT:
5322 case R_PPC64_GNU_VTENTRY:
5323 break;
5324
5325 default:
5326 switch (h->root.type)
5327 {
5328 case bfd_link_hash_defined:
5329 case bfd_link_hash_defweak:
5330 eh = (struct ppc_link_hash_entry *) h;
5331 if (eh->oh != NULL
5332 && eh->oh->is_func_descriptor
5333 && (eh->oh->elf.root.type == bfd_link_hash_defined
5334 || eh->oh->elf.root.type == bfd_link_hash_defweak))
5335 eh = eh->oh;
5336
5337 /* Function descriptor syms cause the associated
5338 function code sym section to be marked. */
5339 if (eh->is_func_descriptor
5340 && (eh->oh->elf.root.type == bfd_link_hash_defined
5341 || eh->oh->elf.root.type == bfd_link_hash_defweak))
5342 {
5343 /* They also mark their opd section. */
5344 eh->elf.root.u.def.section->gc_mark = 1;
5345
5346 rsec = eh->oh->elf.root.u.def.section;
5347 }
5348 else if (get_opd_info (eh->elf.root.u.def.section) != NULL
5349 && opd_entry_value (eh->elf.root.u.def.section,
5350 eh->elf.root.u.def.value,
5351 &rsec, NULL) != (bfd_vma) -1)
5352 eh->elf.root.u.def.section->gc_mark = 1;
5353 else
5354 rsec = h->root.u.def.section;
5355 break;
5356
5357 case bfd_link_hash_common:
5358 rsec = h->root.u.c.p->section;
5359 break;
5360
5361 default:
5362 break;
5363 }
5364 }
5365 }
5366 else
5367 {
5368 struct _opd_sec_data *opd;
5369
5370 rsec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
5371 opd = get_opd_info (rsec);
5372 if (opd != NULL && opd->func_sec != NULL)
5373 {
5374 rsec->gc_mark = 1;
5375
5376 rsec = opd->func_sec[(sym->st_value + rel->r_addend) / 8];
5377 }
5378 }
5379
5380 return rsec;
5381 }
5382
5383 /* Update the .got, .plt. and dynamic reloc reference counts for the
5384 section being removed. */
5385
5386 static bfd_boolean
5387 ppc64_elf_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info,
5388 asection *sec, const Elf_Internal_Rela *relocs)
5389 {
5390 struct ppc_link_hash_table *htab;
5391 Elf_Internal_Shdr *symtab_hdr;
5392 struct elf_link_hash_entry **sym_hashes;
5393 struct got_entry **local_got_ents;
5394 const Elf_Internal_Rela *rel, *relend;
5395
5396 if (info->relocatable)
5397 return TRUE;
5398
5399 if ((sec->flags & SEC_ALLOC) == 0)
5400 return TRUE;
5401
5402 elf_section_data (sec)->local_dynrel = NULL;
5403
5404 htab = ppc_hash_table (info);
5405 symtab_hdr = &elf_symtab_hdr (abfd);
5406 sym_hashes = elf_sym_hashes (abfd);
5407 local_got_ents = elf_local_got_ents (abfd);
5408
5409 relend = relocs + sec->reloc_count;
5410 for (rel = relocs; rel < relend; rel++)
5411 {
5412 unsigned long r_symndx;
5413 enum elf_ppc64_reloc_type r_type;
5414 struct elf_link_hash_entry *h = NULL;
5415 char tls_type = 0;
5416
5417 r_symndx = ELF64_R_SYM (rel->r_info);
5418 r_type = ELF64_R_TYPE (rel->r_info);
5419 if (r_symndx >= symtab_hdr->sh_info)
5420 {
5421 struct ppc_link_hash_entry *eh;
5422 struct ppc_dyn_relocs **pp;
5423 struct ppc_dyn_relocs *p;
5424
5425 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
5426 while (h->root.type == bfd_link_hash_indirect
5427 || h->root.type == bfd_link_hash_warning)
5428 h = (struct elf_link_hash_entry *) h->root.u.i.link;
5429 eh = (struct ppc_link_hash_entry *) h;
5430
5431 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
5432 if (p->sec == sec)
5433 {
5434 /* Everything must go for SEC. */
5435 *pp = p->next;
5436 break;
5437 }
5438 }
5439
5440 switch (r_type)
5441 {
5442 case R_PPC64_GOT_TLSLD16:
5443 case R_PPC64_GOT_TLSLD16_LO:
5444 case R_PPC64_GOT_TLSLD16_HI:
5445 case R_PPC64_GOT_TLSLD16_HA:
5446 tls_type = TLS_TLS | TLS_LD;
5447 goto dogot;
5448
5449 case R_PPC64_GOT_TLSGD16:
5450 case R_PPC64_GOT_TLSGD16_LO:
5451 case R_PPC64_GOT_TLSGD16_HI:
5452 case R_PPC64_GOT_TLSGD16_HA:
5453 tls_type = TLS_TLS | TLS_GD;
5454 goto dogot;
5455
5456 case R_PPC64_GOT_TPREL16_DS:
5457 case R_PPC64_GOT_TPREL16_LO_DS:
5458 case R_PPC64_GOT_TPREL16_HI:
5459 case R_PPC64_GOT_TPREL16_HA:
5460 tls_type = TLS_TLS | TLS_TPREL;
5461 goto dogot;
5462
5463 case R_PPC64_GOT_DTPREL16_DS:
5464 case R_PPC64_GOT_DTPREL16_LO_DS:
5465 case R_PPC64_GOT_DTPREL16_HI:
5466 case R_PPC64_GOT_DTPREL16_HA:
5467 tls_type = TLS_TLS | TLS_DTPREL;
5468 goto dogot;
5469
5470 case R_PPC64_GOT16:
5471 case R_PPC64_GOT16_DS:
5472 case R_PPC64_GOT16_HA:
5473 case R_PPC64_GOT16_HI:
5474 case R_PPC64_GOT16_LO:
5475 case R_PPC64_GOT16_LO_DS:
5476 dogot:
5477 {
5478 struct got_entry *ent;
5479
5480 if (h != NULL)
5481 ent = h->got.glist;
5482 else
5483 ent = local_got_ents[r_symndx];
5484
5485 for (; ent != NULL; ent = ent->next)
5486 if (ent->addend == rel->r_addend
5487 && ent->owner == abfd
5488 && ent->tls_type == tls_type)
5489 break;
5490 if (ent == NULL)
5491 abort ();
5492 if (ent->got.refcount > 0)
5493 ent->got.refcount -= 1;
5494 }
5495 break;
5496
5497 case R_PPC64_PLT16_HA:
5498 case R_PPC64_PLT16_HI:
5499 case R_PPC64_PLT16_LO:
5500 case R_PPC64_PLT32:
5501 case R_PPC64_PLT64:
5502 case R_PPC64_REL14:
5503 case R_PPC64_REL14_BRNTAKEN:
5504 case R_PPC64_REL14_BRTAKEN:
5505 case R_PPC64_REL24:
5506 if (h != NULL)
5507 {
5508 struct plt_entry *ent;
5509
5510 for (ent = h->plt.plist; ent != NULL; ent = ent->next)
5511 if (ent->addend == rel->r_addend)
5512 break;
5513 if (ent == NULL)
5514 abort ();
5515 if (ent->plt.refcount > 0)
5516 ent->plt.refcount -= 1;
5517 }
5518 break;
5519
5520 default:
5521 break;
5522 }
5523 }
5524 return TRUE;
5525 }
5526
5527 /* The maximum size of .sfpr. */
5528 #define SFPR_MAX (218*4)
5529
5530 struct sfpr_def_parms
5531 {
5532 const char name[12];
5533 unsigned char lo, hi;
5534 bfd_byte * (*write_ent) (bfd *, bfd_byte *, int);
5535 bfd_byte * (*write_tail) (bfd *, bfd_byte *, int);
5536 };
5537
5538 /* Auto-generate _save*, _rest* functions in .sfpr. */
5539
5540 static unsigned int
5541 sfpr_define (struct bfd_link_info *info, const struct sfpr_def_parms *parm)
5542 {
5543 struct ppc_link_hash_table *htab = ppc_hash_table (info);
5544 unsigned int i;
5545 size_t len = strlen (parm->name);
5546 bfd_boolean writing = FALSE;
5547 char sym[16];
5548
5549 memcpy (sym, parm->name, len);
5550 sym[len + 2] = 0;
5551
5552 for (i = parm->lo; i <= parm->hi; i++)
5553 {
5554 struct elf_link_hash_entry *h;
5555
5556 sym[len + 0] = i / 10 + '0';
5557 sym[len + 1] = i % 10 + '0';
5558 h = elf_link_hash_lookup (&htab->elf, sym, FALSE, FALSE, TRUE);
5559 if (h != NULL
5560 && !h->def_regular)
5561 {
5562 h->root.type = bfd_link_hash_defined;
5563 h->root.u.def.section = htab->sfpr;
5564 h->root.u.def.value = htab->sfpr->size;
5565 h->type = STT_FUNC;
5566 h->def_regular = 1;
5567 _bfd_elf_link_hash_hide_symbol (info, h, TRUE);
5568 writing = TRUE;
5569 if (htab->sfpr->contents == NULL)
5570 {
5571 htab->sfpr->contents = bfd_alloc (htab->elf.dynobj, SFPR_MAX);
5572 if (htab->sfpr->contents == NULL)
5573 return FALSE;
5574 }
5575 }
5576 if (writing)
5577 {
5578 bfd_byte *p = htab->sfpr->contents + htab->sfpr->size;
5579 if (i != parm->hi)
5580 p = (*parm->write_ent) (htab->elf.dynobj, p, i);
5581 else
5582 p = (*parm->write_tail) (htab->elf.dynobj, p, i);
5583 htab->sfpr->size = p - htab->sfpr->contents;
5584 }
5585 }
5586
5587 return TRUE;
5588 }
5589
5590 static bfd_byte *
5591 savegpr0 (bfd *abfd, bfd_byte *p, int r)
5592 {
5593 bfd_put_32 (abfd, STD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
5594 return p + 4;
5595 }
5596
5597 static bfd_byte *
5598 savegpr0_tail (bfd *abfd, bfd_byte *p, int r)
5599 {
5600 p = savegpr0 (abfd, p, r);
5601 bfd_put_32 (abfd, STD_R0_0R1 + 16, p);
5602 p = p + 4;
5603 bfd_put_32 (abfd, BLR, p);
5604 return p + 4;
5605 }
5606
5607 static bfd_byte *
5608 restgpr0 (bfd *abfd, bfd_byte *p, int r)
5609 {
5610 bfd_put_32 (abfd, LD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
5611 return p + 4;
5612 }
5613
5614 static bfd_byte *
5615 restgpr0_tail (bfd *abfd, bfd_byte *p, int r)
5616 {
5617 bfd_put_32 (abfd, LD_R0_0R1 + 16, p);
5618 p = p + 4;
5619 p = restgpr0 (abfd, p, r);
5620 bfd_put_32 (abfd, MTLR_R0, p);
5621 p = p + 4;
5622 if (r == 29)
5623 {
5624 p = restgpr0 (abfd, p, 30);
5625 p = restgpr0 (abfd, p, 31);
5626 }
5627 bfd_put_32 (abfd, BLR, p);
5628 return p + 4;
5629 }
5630
5631 static bfd_byte *
5632 savegpr1 (bfd *abfd, bfd_byte *p, int r)
5633 {
5634 bfd_put_32 (abfd, STD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
5635 return p + 4;
5636 }
5637
5638 static bfd_byte *
5639 savegpr1_tail (bfd *abfd, bfd_byte *p, int r)
5640 {
5641 p = savegpr1 (abfd, p, r);
5642 bfd_put_32 (abfd, BLR, p);
5643 return p + 4;
5644 }
5645
5646 static bfd_byte *
5647 restgpr1 (bfd *abfd, bfd_byte *p, int r)
5648 {
5649 bfd_put_32 (abfd, LD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
5650 return p + 4;
5651 }
5652
5653 static bfd_byte *
5654 restgpr1_tail (bfd *abfd, bfd_byte *p, int r)
5655 {
5656 p = restgpr1 (abfd, p, r);
5657 bfd_put_32 (abfd, BLR, p);
5658 return p + 4;
5659 }
5660
5661 static bfd_byte *
5662 savefpr (bfd *abfd, bfd_byte *p, int r)
5663 {
5664 bfd_put_32 (abfd, STFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
5665 return p + 4;
5666 }
5667
5668 static bfd_byte *
5669 savefpr0_tail (bfd *abfd, bfd_byte *p, int r)
5670 {
5671 p = savefpr (abfd, p, r);
5672 bfd_put_32 (abfd, STD_R0_0R1 + 16, p);
5673 p = p + 4;
5674 bfd_put_32 (abfd, BLR, p);
5675 return p + 4;
5676 }
5677
5678 static bfd_byte *
5679 restfpr (bfd *abfd, bfd_byte *p, int r)
5680 {
5681 bfd_put_32 (abfd, LFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
5682 return p + 4;
5683 }
5684
5685 static bfd_byte *
5686 restfpr0_tail (bfd *abfd, bfd_byte *p, int r)
5687 {
5688 bfd_put_32 (abfd, LD_R0_0R1 + 16, p);
5689 p = p + 4;
5690 p = restfpr (abfd, p, r);
5691 bfd_put_32 (abfd, MTLR_R0, p);
5692 p = p + 4;
5693 if (r == 29)
5694 {
5695 p = restfpr (abfd, p, 30);
5696 p = restfpr (abfd, p, 31);
5697 }
5698 bfd_put_32 (abfd, BLR, p);
5699 return p + 4;
5700 }
5701
5702 static bfd_byte *
5703 savefpr1_tail (bfd *abfd, bfd_byte *p, int r)
5704 {
5705 p = savefpr (abfd, p, r);
5706 bfd_put_32 (abfd, BLR, p);
5707 return p + 4;
5708 }
5709
5710 static bfd_byte *
5711 restfpr1_tail (bfd *abfd, bfd_byte *p, int r)
5712 {
5713 p = restfpr (abfd, p, r);
5714 bfd_put_32 (abfd, BLR, p);
5715 return p + 4;
5716 }
5717
5718 static bfd_byte *
5719 savevr (bfd *abfd, bfd_byte *p, int r)
5720 {
5721 bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
5722 p = p + 4;
5723 bfd_put_32 (abfd, STVX_VR0_R12_R0 + (r << 21), p);
5724 return p + 4;
5725 }
5726
5727 static bfd_byte *
5728 savevr_tail (bfd *abfd, bfd_byte *p, int r)
5729 {
5730 p = savevr (abfd, p, r);
5731 bfd_put_32 (abfd, BLR, p);
5732 return p + 4;
5733 }
5734
5735 static bfd_byte *
5736 restvr (bfd *abfd, bfd_byte *p, int r)
5737 {
5738 bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
5739 p = p + 4;
5740 bfd_put_32 (abfd, LVX_VR0_R12_R0 + (r << 21), p);
5741 return p + 4;
5742 }
5743
5744 static bfd_byte *
5745 restvr_tail (bfd *abfd, bfd_byte *p, int r)
5746 {
5747 p = restvr (abfd, p, r);
5748 bfd_put_32 (abfd, BLR, p);
5749 return p + 4;
5750 }
5751
5752 /* Called via elf_link_hash_traverse to transfer dynamic linking
5753 information on function code symbol entries to their corresponding
5754 function descriptor symbol entries. */
5755
5756 static bfd_boolean
5757 func_desc_adjust (struct elf_link_hash_entry *h, void *inf)
5758 {
5759 struct bfd_link_info *info;
5760 struct ppc_link_hash_table *htab;
5761 struct plt_entry *ent;
5762 struct ppc_link_hash_entry *fh;
5763 struct ppc_link_hash_entry *fdh;
5764 bfd_boolean force_local;
5765
5766 fh = (struct ppc_link_hash_entry *) h;
5767 if (fh->elf.root.type == bfd_link_hash_indirect)
5768 return TRUE;
5769
5770 if (fh->elf.root.type == bfd_link_hash_warning)
5771 fh = (struct ppc_link_hash_entry *) fh->elf.root.u.i.link;
5772
5773 info = inf;
5774 htab = ppc_hash_table (info);
5775
5776 /* Resolve undefined references to dot-symbols as the value
5777 in the function descriptor, if we have one in a regular object.
5778 This is to satisfy cases like ".quad .foo". Calls to functions
5779 in dynamic objects are handled elsewhere. */
5780 if (fh->elf.root.type == bfd_link_hash_undefweak
5781 && fh->was_undefined
5782 && (fh->oh->elf.root.type == bfd_link_hash_defined
5783 || fh->oh->elf.root.type == bfd_link_hash_defweak)
5784 && get_opd_info (fh->oh->elf.root.u.def.section) != NULL
5785 && opd_entry_value (fh->oh->elf.root.u.def.section,
5786 fh->oh->elf.root.u.def.value,
5787 &fh->elf.root.u.def.section,
5788 &fh->elf.root.u.def.value) != (bfd_vma) -1)
5789 {
5790 fh->elf.root.type = fh->oh->elf.root.type;
5791 fh->elf.forced_local = 1;
5792 fh->elf.def_regular = fh->oh->elf.def_regular;
5793 fh->elf.def_dynamic = fh->oh->elf.def_dynamic;
5794 }
5795
5796 /* If this is a function code symbol, transfer dynamic linking
5797 information to the function descriptor symbol. */
5798 if (!fh->is_func)
5799 return TRUE;
5800
5801 for (ent = fh->elf.plt.plist; ent != NULL; ent = ent->next)
5802 if (ent->plt.refcount > 0)
5803 break;
5804 if (ent == NULL
5805 || fh->elf.root.root.string[0] != '.'
5806 || fh->elf.root.root.string[1] == '\0')
5807 return TRUE;
5808
5809 /* Find the corresponding function descriptor symbol. Create it
5810 as undefined if necessary. */
5811
5812 fdh = get_fdh (fh, htab);
5813 if (fdh != NULL)
5814 while (fdh->elf.root.type == bfd_link_hash_indirect
5815 || fdh->elf.root.type == bfd_link_hash_warning)
5816 fdh = (struct ppc_link_hash_entry *) fdh->elf.root.u.i.link;
5817
5818 if (fdh == NULL
5819 && !info->executable
5820 && (fh->elf.root.type == bfd_link_hash_undefined
5821 || fh->elf.root.type == bfd_link_hash_undefweak))
5822 {
5823 fdh = make_fdh (info, fh);
5824 if (fdh == NULL)
5825 return FALSE;
5826 }
5827
5828 /* Fake function descriptors are made undefweak. If the function
5829 code symbol is strong undefined, make the fake sym the same.
5830 If the function code symbol is defined, then force the fake
5831 descriptor local; We can't support overriding of symbols in a
5832 shared library on a fake descriptor. */
5833
5834 if (fdh != NULL
5835 && fdh->fake
5836 && fdh->elf.root.type == bfd_link_hash_undefweak)
5837 {
5838 if (fh->elf.root.type == bfd_link_hash_undefined)
5839 {
5840 fdh->elf.root.type = bfd_link_hash_undefined;
5841 bfd_link_add_undef (&htab->elf.root, &fdh->elf.root);
5842 }
5843 else if (fh->elf.root.type == bfd_link_hash_defined
5844 || fh->elf.root.type == bfd_link_hash_defweak)
5845 {
5846 _bfd_elf_link_hash_hide_symbol (info, &fdh->elf, TRUE);
5847 }
5848 }
5849
5850 if (fdh != NULL
5851 && !fdh->elf.forced_local
5852 && (!info->executable
5853 || fdh->elf.def_dynamic
5854 || fdh->elf.ref_dynamic
5855 || (fdh->elf.root.type == bfd_link_hash_undefweak
5856 && ELF_ST_VISIBILITY (fdh->elf.other) == STV_DEFAULT)))
5857 {
5858 if (fdh->elf.dynindx == -1)
5859 if (! bfd_elf_link_record_dynamic_symbol (info, &fdh->elf))
5860 return FALSE;
5861 fdh->elf.ref_regular |= fh->elf.ref_regular;
5862 fdh->elf.ref_dynamic |= fh->elf.ref_dynamic;
5863 fdh->elf.ref_regular_nonweak |= fh->elf.ref_regular_nonweak;
5864 fdh->elf.non_got_ref |= fh->elf.non_got_ref;
5865 if (ELF_ST_VISIBILITY (fh->elf.other) == STV_DEFAULT)
5866 {
5867 move_plt_plist (fh, fdh);
5868 fdh->elf.needs_plt = 1;
5869 }
5870 fdh->is_func_descriptor = 1;
5871 fdh->oh = fh;
5872 fh->oh = fdh;
5873 }
5874
5875 /* Now that the info is on the function descriptor, clear the
5876 function code sym info. Any function code syms for which we
5877 don't have a definition in a regular file, we force local.
5878 This prevents a shared library from exporting syms that have
5879 been imported from another library. Function code syms that
5880 are really in the library we must leave global to prevent the
5881 linker dragging in a definition from a static library. */
5882 force_local = (!fh->elf.def_regular
5883 || fdh == NULL
5884 || !fdh->elf.def_regular
5885 || fdh->elf.forced_local);
5886 _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
5887
5888 return TRUE;
5889 }
5890
5891 /* Called near the start of bfd_elf_size_dynamic_sections. We use
5892 this hook to a) provide some gcc support functions, and b) transfer
5893 dynamic linking information gathered so far on function code symbol
5894 entries, to their corresponding function descriptor symbol entries. */
5895
5896 static bfd_boolean
5897 ppc64_elf_func_desc_adjust (bfd *obfd ATTRIBUTE_UNUSED,
5898 struct bfd_link_info *info)
5899 {
5900 struct ppc_link_hash_table *htab;
5901 unsigned int i;
5902 const struct sfpr_def_parms funcs[] =
5903 {
5904 { "_savegpr0_", 14, 31, savegpr0, savegpr0_tail },
5905 { "_restgpr0_", 14, 29, restgpr0, restgpr0_tail },
5906 { "_restgpr0_", 30, 31, restgpr0, restgpr0_tail },
5907 { "_savegpr1_", 14, 31, savegpr1, savegpr1_tail },
5908 { "_restgpr1_", 14, 31, restgpr1, restgpr1_tail },
5909 { "_savefpr_", 14, 31, savefpr, savefpr0_tail },
5910 { "_restfpr_", 14, 29, restfpr, restfpr0_tail },
5911 { "_restfpr_", 30, 31, restfpr, restfpr0_tail },
5912 { "._savef", 14, 31, savefpr, savefpr1_tail },
5913 { "._restf", 14, 31, restfpr, restfpr1_tail },
5914 { "_savevr_", 20, 31, savevr, savevr_tail },
5915 { "_restvr_", 20, 31, restvr, restvr_tail }
5916 };
5917
5918 htab = ppc_hash_table (info);
5919 if (htab->sfpr == NULL)
5920 /* We don't have any relocs. */
5921 return TRUE;
5922
5923 /* Provide any missing _save* and _rest* functions. */
5924 htab->sfpr->size = 0;
5925 for (i = 0; i < sizeof (funcs) / sizeof (funcs[0]); i++)
5926 if (!sfpr_define (info, &funcs[i]))
5927 return FALSE;
5928
5929 elf_link_hash_traverse (&htab->elf, func_desc_adjust, info);
5930
5931 if (htab->sfpr->size == 0)
5932 htab->sfpr->flags |= SEC_EXCLUDE;
5933
5934 return TRUE;
5935 }
5936
5937 /* Adjust a symbol defined by a dynamic object and referenced by a
5938 regular object. The current definition is in some section of the
5939 dynamic object, but we're not including those sections. We have to
5940 change the definition to something the rest of the link can
5941 understand. */
5942
5943 static bfd_boolean
5944 ppc64_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
5945 struct elf_link_hash_entry *h)
5946 {
5947 struct ppc_link_hash_table *htab;
5948 asection *s;
5949
5950 htab = ppc_hash_table (info);
5951
5952 /* Deal with function syms. */
5953 if (h->type == STT_FUNC
5954 || h->needs_plt)
5955 {
5956 /* Clear procedure linkage table information for any symbol that
5957 won't need a .plt entry. */
5958 struct plt_entry *ent;
5959 for (ent = h->plt.plist; ent != NULL; ent = ent->next)
5960 if (ent->plt.refcount > 0)
5961 break;
5962 if (ent == NULL
5963 || SYMBOL_CALLS_LOCAL (info, h)
5964 || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
5965 && h->root.type == bfd_link_hash_undefweak))
5966 {
5967 h->plt.plist = NULL;
5968 h->needs_plt = 0;
5969 }
5970 }
5971 else
5972 h->plt.plist = NULL;
5973
5974 /* If this is a weak symbol, and there is a real definition, the
5975 processor independent code will have arranged for us to see the
5976 real definition first, and we can just use the same value. */
5977 if (h->u.weakdef != NULL)
5978 {
5979 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
5980 || h->u.weakdef->root.type == bfd_link_hash_defweak);
5981 h->root.u.def.section = h->u.weakdef->root.u.def.section;
5982 h->root.u.def.value = h->u.weakdef->root.u.def.value;
5983 if (ELIMINATE_COPY_RELOCS)
5984 h->non_got_ref = h->u.weakdef->non_got_ref;
5985 return TRUE;
5986 }
5987
5988 /* If we are creating a shared library, we must presume that the
5989 only references to the symbol are via the global offset table.
5990 For such cases we need not do anything here; the relocations will
5991 be handled correctly by relocate_section. */
5992 if (info->shared)
5993 return TRUE;
5994
5995 /* If there are no references to this symbol that do not use the
5996 GOT, we don't need to generate a copy reloc. */
5997 if (!h->non_got_ref)
5998 return TRUE;
5999
6000 /* Don't generate a copy reloc for symbols defined in the executable. */
6001 if (!h->def_dynamic || !h->ref_regular || h->def_regular)
6002 return TRUE;
6003
6004 if (ELIMINATE_COPY_RELOCS)
6005 {
6006 struct ppc_link_hash_entry * eh;
6007 struct ppc_dyn_relocs *p;
6008
6009 eh = (struct ppc_link_hash_entry *) h;
6010 for (p = eh->dyn_relocs; p != NULL; p = p->next)
6011 {
6012 s = p->sec->output_section;
6013 if (s != NULL && (s->flags & SEC_READONLY) != 0)
6014 break;
6015 }
6016
6017 /* If we didn't find any dynamic relocs in read-only sections, then
6018 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
6019 if (p == NULL)
6020 {
6021 h->non_got_ref = 0;
6022 return TRUE;
6023 }
6024 }
6025
6026 if (h->plt.plist != NULL)
6027 {
6028 /* We should never get here, but unfortunately there are versions
6029 of gcc out there that improperly (for this ABI) put initialized
6030 function pointers, vtable refs and suchlike in read-only
6031 sections. Allow them to proceed, but warn that this might
6032 break at runtime. */
6033 (*_bfd_error_handler)
6034 (_("copy reloc against `%s' requires lazy plt linking; "
6035 "avoid setting LD_BIND_NOW=1 or upgrade gcc"),
6036 h->root.root.string);
6037 }
6038
6039 /* This is a reference to a symbol defined by a dynamic object which
6040 is not a function. */
6041
6042 if (h->size == 0)
6043 {
6044 (*_bfd_error_handler) (_("dynamic variable `%s' is zero size"),
6045 h->root.root.string);
6046 return TRUE;
6047 }
6048
6049 /* We must allocate the symbol in our .dynbss section, which will
6050 become part of the .bss section of the executable. There will be
6051 an entry for this symbol in the .dynsym section. The dynamic
6052 object will contain position independent code, so all references
6053 from the dynamic object to this symbol will go through the global
6054 offset table. The dynamic linker will use the .dynsym entry to
6055 determine the address it must put in the global offset table, so
6056 both the dynamic object and the regular object will refer to the
6057 same memory location for the variable. */
6058
6059 /* We must generate a R_PPC64_COPY reloc to tell the dynamic linker
6060 to copy the initial value out of the dynamic object and into the
6061 runtime process image. We need to remember the offset into the
6062 .rela.bss section we are going to use. */
6063 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
6064 {
6065 htab->relbss->size += sizeof (Elf64_External_Rela);
6066 h->needs_copy = 1;
6067 }
6068
6069 s = htab->dynbss;
6070
6071 return _bfd_elf_adjust_dynamic_copy (h, s);
6072 }
6073
6074 /* If given a function descriptor symbol, hide both the function code
6075 sym and the descriptor. */
6076 static void
6077 ppc64_elf_hide_symbol (struct bfd_link_info *info,
6078 struct elf_link_hash_entry *h,
6079 bfd_boolean force_local)
6080 {
6081 struct ppc_link_hash_entry *eh;
6082 _bfd_elf_link_hash_hide_symbol (info, h, force_local);
6083
6084 eh = (struct ppc_link_hash_entry *) h;
6085 if (eh->is_func_descriptor)
6086 {
6087 struct ppc_link_hash_entry *fh = eh->oh;
6088
6089 if (fh == NULL)
6090 {
6091 const char *p, *q;
6092 struct ppc_link_hash_table *htab;
6093 char save;
6094
6095 /* We aren't supposed to use alloca in BFD because on
6096 systems which do not have alloca the version in libiberty
6097 calls xmalloc, which might cause the program to crash
6098 when it runs out of memory. This function doesn't have a
6099 return status, so there's no way to gracefully return an
6100 error. So cheat. We know that string[-1] can be safely
6101 accessed; It's either a string in an ELF string table,
6102 or allocated in an objalloc structure. */
6103
6104 p = eh->elf.root.root.string - 1;
6105 save = *p;
6106 *(char *) p = '.';
6107 htab = ppc_hash_table (info);
6108 fh = (struct ppc_link_hash_entry *)
6109 elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
6110 *(char *) p = save;
6111
6112 /* Unfortunately, if it so happens that the string we were
6113 looking for was allocated immediately before this string,
6114 then we overwrote the string terminator. That's the only
6115 reason the lookup should fail. */
6116 if (fh == NULL)
6117 {
6118 q = eh->elf.root.root.string + strlen (eh->elf.root.root.string);
6119 while (q >= eh->elf.root.root.string && *q == *p)
6120 --q, --p;
6121 if (q < eh->elf.root.root.string && *p == '.')
6122 fh = (struct ppc_link_hash_entry *)
6123 elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
6124 }
6125 if (fh != NULL)
6126 {
6127 eh->oh = fh;
6128 fh->oh = eh;
6129 }
6130 }
6131 if (fh != NULL)
6132 _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
6133 }
6134 }
6135
6136 static bfd_boolean
6137 get_sym_h (struct elf_link_hash_entry **hp,
6138 Elf_Internal_Sym **symp,
6139 asection **symsecp,
6140 char **tls_maskp,
6141 Elf_Internal_Sym **locsymsp,
6142 unsigned long r_symndx,
6143 bfd *ibfd)
6144 {
6145 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
6146
6147 if (r_symndx >= symtab_hdr->sh_info)
6148 {
6149 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
6150 struct elf_link_hash_entry *h;
6151
6152 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
6153 while (h->root.type == bfd_link_hash_indirect
6154 || h->root.type == bfd_link_hash_warning)
6155 h = (struct elf_link_hash_entry *) h->root.u.i.link;
6156
6157 if (hp != NULL)
6158 *hp = h;
6159
6160 if (symp != NULL)
6161 *symp = NULL;
6162
6163 if (symsecp != NULL)
6164 {
6165 asection *symsec = NULL;
6166 if (h->root.type == bfd_link_hash_defined
6167 || h->root.type == bfd_link_hash_defweak)
6168 symsec = h->root.u.def.section;
6169 *symsecp = symsec;
6170 }
6171
6172 if (tls_maskp != NULL)
6173 {
6174 struct ppc_link_hash_entry *eh;
6175
6176 eh = (struct ppc_link_hash_entry *) h;
6177 *tls_maskp = &eh->tls_mask;
6178 }
6179 }
6180 else
6181 {
6182 Elf_Internal_Sym *sym;
6183 Elf_Internal_Sym *locsyms = *locsymsp;
6184
6185 if (locsyms == NULL)
6186 {
6187 locsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
6188 if (locsyms == NULL)
6189 locsyms = bfd_elf_get_elf_syms (ibfd, symtab_hdr,
6190 symtab_hdr->sh_info,
6191 0, NULL, NULL, NULL);
6192 if (locsyms == NULL)
6193 return FALSE;
6194 *locsymsp = locsyms;
6195 }
6196 sym = locsyms + r_symndx;
6197
6198 if (hp != NULL)
6199 *hp = NULL;
6200
6201 if (symp != NULL)
6202 *symp = sym;
6203
6204 if (symsecp != NULL)
6205 *symsecp = bfd_section_from_elf_index (ibfd, sym->st_shndx);
6206
6207 if (tls_maskp != NULL)
6208 {
6209 struct got_entry **lgot_ents;
6210 char *tls_mask;
6211
6212 tls_mask = NULL;
6213 lgot_ents = elf_local_got_ents (ibfd);
6214 if (lgot_ents != NULL)
6215 {
6216 char *lgot_masks = (char *) (lgot_ents + symtab_hdr->sh_info);
6217 tls_mask = &lgot_masks[r_symndx];
6218 }
6219 *tls_maskp = tls_mask;
6220 }
6221 }
6222 return TRUE;
6223 }
6224
6225 /* Returns TLS_MASKP for the given REL symbol. Function return is 0 on
6226 error, 2 on a toc GD type suitable for optimization, 3 on a toc LD
6227 type suitable for optimization, and 1 otherwise. */
6228
6229 static int
6230 get_tls_mask (char **tls_maskp,
6231 unsigned long *toc_symndx,
6232 bfd_vma *toc_addend,
6233 Elf_Internal_Sym **locsymsp,
6234 const Elf_Internal_Rela *rel,
6235 bfd *ibfd)
6236 {
6237 unsigned long r_symndx;
6238 int next_r;
6239 struct elf_link_hash_entry *h;
6240 Elf_Internal_Sym *sym;
6241 asection *sec;
6242 bfd_vma off;
6243
6244 r_symndx = ELF64_R_SYM (rel->r_info);
6245 if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
6246 return 0;
6247
6248 if ((*tls_maskp != NULL && **tls_maskp != 0)
6249 || sec == NULL
6250 || ppc64_elf_section_data (sec)->sec_type != sec_toc)
6251 return 1;
6252
6253 /* Look inside a TOC section too. */
6254 if (h != NULL)
6255 {
6256 BFD_ASSERT (h->root.type == bfd_link_hash_defined);
6257 off = h->root.u.def.value;
6258 }
6259 else
6260 off = sym->st_value;
6261 off += rel->r_addend;
6262 BFD_ASSERT (off % 8 == 0);
6263 r_symndx = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8];
6264 next_r = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8 + 1];
6265 if (toc_symndx != NULL)
6266 *toc_symndx = r_symndx;
6267 if (toc_addend != NULL)
6268 *toc_addend = ppc64_elf_section_data (sec)->u.toc.add[off / 8];
6269 if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
6270 return 0;
6271 if ((h == NULL
6272 || ((h->root.type == bfd_link_hash_defined
6273 || h->root.type == bfd_link_hash_defweak)
6274 && !h->def_dynamic))
6275 && (next_r == -1 || next_r == -2))
6276 return 1 - next_r;
6277 return 1;
6278 }
6279
6280 /* Adjust all global syms defined in opd sections. In gcc generated
6281 code for the old ABI, these will already have been done. */
6282
6283 static bfd_boolean
6284 adjust_opd_syms (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
6285 {
6286 struct ppc_link_hash_entry *eh;
6287 asection *sym_sec;
6288 struct _opd_sec_data *opd;
6289
6290 if (h->root.type == bfd_link_hash_indirect)
6291 return TRUE;
6292
6293 if (h->root.type == bfd_link_hash_warning)
6294 h = (struct elf_link_hash_entry *) h->root.u.i.link;
6295
6296 if (h->root.type != bfd_link_hash_defined
6297 && h->root.type != bfd_link_hash_defweak)
6298 return TRUE;
6299
6300 eh = (struct ppc_link_hash_entry *) h;
6301 if (eh->adjust_done)
6302 return TRUE;
6303
6304 sym_sec = eh->elf.root.u.def.section;
6305 opd = get_opd_info (sym_sec);
6306 if (opd != NULL && opd->adjust != NULL)
6307 {
6308 long adjust = opd->adjust[eh->elf.root.u.def.value / 8];
6309 if (adjust == -1)
6310 {
6311 /* This entry has been deleted. */
6312 asection *dsec = ppc64_elf_tdata (sym_sec->owner)->deleted_section;
6313 if (dsec == NULL)
6314 {
6315 for (dsec = sym_sec->owner->sections; dsec; dsec = dsec->next)
6316 if (elf_discarded_section (dsec))
6317 {
6318 ppc64_elf_tdata (sym_sec->owner)->deleted_section = dsec;
6319 break;
6320 }
6321 }
6322 eh->elf.root.u.def.value = 0;
6323 eh->elf.root.u.def.section = dsec;
6324 }
6325 else
6326 eh->elf.root.u.def.value += adjust;
6327 eh->adjust_done = 1;
6328 }
6329 return TRUE;
6330 }
6331
6332 /* Handles decrementing dynamic reloc counts for the reloc specified by
6333 R_INFO in section SEC. If LOCAL_SYMS is NULL, then H and SYM_SEC
6334 have already been determined. */
6335
6336 static bfd_boolean
6337 dec_dynrel_count (bfd_vma r_info,
6338 asection *sec,
6339 struct bfd_link_info *info,
6340 Elf_Internal_Sym **local_syms,
6341 struct elf_link_hash_entry *h,
6342 asection *sym_sec)
6343 {
6344 enum elf_ppc64_reloc_type r_type;
6345 struct ppc_dyn_relocs *p;
6346 struct ppc_dyn_relocs **pp;
6347
6348 /* Can this reloc be dynamic? This switch, and later tests here
6349 should be kept in sync with the code in check_relocs. */
6350 r_type = ELF64_R_TYPE (r_info);
6351 switch (r_type)
6352 {
6353 default:
6354 return TRUE;
6355
6356 case R_PPC64_TPREL16:
6357 case R_PPC64_TPREL16_LO:
6358 case R_PPC64_TPREL16_HI:
6359 case R_PPC64_TPREL16_HA:
6360 case R_PPC64_TPREL16_DS:
6361 case R_PPC64_TPREL16_LO_DS:
6362 case R_PPC64_TPREL16_HIGHER:
6363 case R_PPC64_TPREL16_HIGHERA:
6364 case R_PPC64_TPREL16_HIGHEST:
6365 case R_PPC64_TPREL16_HIGHESTA:
6366 if (!info->shared)
6367 return TRUE;
6368
6369 case R_PPC64_TPREL64:
6370 case R_PPC64_DTPMOD64:
6371 case R_PPC64_DTPREL64:
6372 case R_PPC64_ADDR64:
6373 case R_PPC64_REL30:
6374 case R_PPC64_REL32:
6375 case R_PPC64_REL64:
6376 case R_PPC64_ADDR14:
6377 case R_PPC64_ADDR14_BRNTAKEN:
6378 case R_PPC64_ADDR14_BRTAKEN:
6379 case R_PPC64_ADDR16:
6380 case R_PPC64_ADDR16_DS:
6381 case R_PPC64_ADDR16_HA:
6382 case R_PPC64_ADDR16_HI:
6383 case R_PPC64_ADDR16_HIGHER:
6384 case R_PPC64_ADDR16_HIGHERA:
6385 case R_PPC64_ADDR16_HIGHEST:
6386 case R_PPC64_ADDR16_HIGHESTA:
6387 case R_PPC64_ADDR16_LO:
6388 case R_PPC64_ADDR16_LO_DS:
6389 case R_PPC64_ADDR24:
6390 case R_PPC64_ADDR32:
6391 case R_PPC64_UADDR16:
6392 case R_PPC64_UADDR32:
6393 case R_PPC64_UADDR64:
6394 case R_PPC64_TOC:
6395 break;
6396 }
6397
6398 if (local_syms != NULL)
6399 {
6400 unsigned long r_symndx;
6401 Elf_Internal_Sym *sym;
6402 bfd *ibfd = sec->owner;
6403
6404 r_symndx = ELF64_R_SYM (r_info);
6405 if (!get_sym_h (&h, &sym, &sym_sec, NULL, local_syms, r_symndx, ibfd))
6406 return FALSE;
6407 }
6408
6409 if ((info->shared
6410 && (must_be_dyn_reloc (info, r_type)
6411 || (h != NULL
6412 && (!info->symbolic
6413 || h->root.type == bfd_link_hash_defweak
6414 || !h->def_regular))))
6415 || (ELIMINATE_COPY_RELOCS
6416 && !info->shared
6417 && h != NULL
6418 && (h->root.type == bfd_link_hash_defweak
6419 || !h->def_regular)))
6420 ;
6421 else
6422 return TRUE;
6423
6424 if (h != NULL)
6425 pp = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
6426 else
6427 {
6428 if (sym_sec != NULL)
6429 {
6430 void *vpp = &elf_section_data (sym_sec)->local_dynrel;
6431 pp = (struct ppc_dyn_relocs **) vpp;
6432 }
6433 else
6434 {
6435 void *vpp = &elf_section_data (sec)->local_dynrel;
6436 pp = (struct ppc_dyn_relocs **) vpp;
6437 }
6438
6439 /* elf_gc_sweep may have already removed all dyn relocs associated
6440 with local syms for a given section. Don't report a dynreloc
6441 miscount. */
6442 if (*pp == NULL)
6443 return TRUE;
6444 }
6445
6446 while ((p = *pp) != NULL)
6447 {
6448 if (p->sec == sec)
6449 {
6450 if (!must_be_dyn_reloc (info, r_type))
6451 p->pc_count -= 1;
6452 p->count -= 1;
6453 if (p->count == 0)
6454 *pp = p->next;
6455 return TRUE;
6456 }
6457 pp = &p->next;
6458 }
6459
6460 (*_bfd_error_handler) (_("dynreloc miscount for %B, section %A"),
6461 sec->owner, sec);
6462 bfd_set_error (bfd_error_bad_value);
6463 return FALSE;
6464 }
6465
6466 /* Remove unused Official Procedure Descriptor entries. Currently we
6467 only remove those associated with functions in discarded link-once
6468 sections, or weakly defined functions that have been overridden. It
6469 would be possible to remove many more entries for statically linked
6470 applications. */
6471
6472 bfd_boolean
6473 ppc64_elf_edit_opd (bfd *obfd, struct bfd_link_info *info,
6474 bfd_boolean non_overlapping)
6475 {
6476 bfd *ibfd;
6477 bfd_boolean some_edited = FALSE;
6478 asection *need_pad = NULL;
6479
6480 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
6481 {
6482 asection *sec;
6483 Elf_Internal_Rela *relstart, *rel, *relend;
6484 Elf_Internal_Shdr *symtab_hdr;
6485 Elf_Internal_Sym *local_syms;
6486 struct elf_link_hash_entry **sym_hashes;
6487 bfd_vma offset;
6488 struct _opd_sec_data *opd;
6489 bfd_boolean need_edit, add_aux_fields;
6490 bfd_size_type cnt_16b = 0;
6491
6492 sec = bfd_get_section_by_name (ibfd, ".opd");
6493 if (sec == NULL || sec->size == 0)
6494 continue;
6495
6496 if (sec->sec_info_type == ELF_INFO_TYPE_JUST_SYMS)
6497 continue;
6498
6499 if (sec->output_section == bfd_abs_section_ptr)
6500 continue;
6501
6502 /* Look through the section relocs. */
6503 if ((sec->flags & SEC_RELOC) == 0 || sec->reloc_count == 0)
6504 continue;
6505
6506 local_syms = NULL;
6507 symtab_hdr = &elf_symtab_hdr (ibfd);
6508 sym_hashes = elf_sym_hashes (ibfd);
6509
6510 /* Read the relocations. */
6511 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
6512 info->keep_memory);
6513 if (relstart == NULL)
6514 return FALSE;
6515
6516 /* First run through the relocs to check they are sane, and to
6517 determine whether we need to edit this opd section. */
6518 need_edit = FALSE;
6519 need_pad = sec;
6520 offset = 0;
6521 relend = relstart + sec->reloc_count;
6522 for (rel = relstart; rel < relend; )
6523 {
6524 enum elf_ppc64_reloc_type r_type;
6525 unsigned long r_symndx;
6526 asection *sym_sec;
6527 struct elf_link_hash_entry *h;
6528 Elf_Internal_Sym *sym;
6529
6530 /* .opd contains a regular array of 16 or 24 byte entries. We're
6531 only interested in the reloc pointing to a function entry
6532 point. */
6533 if (rel->r_offset != offset
6534 || rel + 1 >= relend
6535 || (rel + 1)->r_offset != offset + 8)
6536 {
6537 /* If someone messes with .opd alignment then after a
6538 "ld -r" we might have padding in the middle of .opd.
6539 Also, there's nothing to prevent someone putting
6540 something silly in .opd with the assembler. No .opd
6541 optimization for them! */
6542 broken_opd:
6543 (*_bfd_error_handler)
6544 (_("%B: .opd is not a regular array of opd entries"), ibfd);
6545 need_edit = FALSE;
6546 break;
6547 }
6548
6549 if ((r_type = ELF64_R_TYPE (rel->r_info)) != R_PPC64_ADDR64
6550 || (r_type = ELF64_R_TYPE ((rel + 1)->r_info)) != R_PPC64_TOC)
6551 {
6552 (*_bfd_error_handler)
6553 (_("%B: unexpected reloc type %u in .opd section"),
6554 ibfd, r_type);
6555 need_edit = FALSE;
6556 break;
6557 }
6558
6559 r_symndx = ELF64_R_SYM (rel->r_info);
6560 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
6561 r_symndx, ibfd))
6562 goto error_ret;
6563
6564 if (sym_sec == NULL || sym_sec->owner == NULL)
6565 {
6566 const char *sym_name;
6567 if (h != NULL)
6568 sym_name = h->root.root.string;
6569 else
6570 sym_name = bfd_elf_sym_name (ibfd, symtab_hdr, sym,
6571 sym_sec);
6572
6573 (*_bfd_error_handler)
6574 (_("%B: undefined sym `%s' in .opd section"),
6575 ibfd, sym_name);
6576 need_edit = FALSE;
6577 break;
6578 }
6579
6580 /* opd entries are always for functions defined in the
6581 current input bfd. If the symbol isn't defined in the
6582 input bfd, then we won't be using the function in this
6583 bfd; It must be defined in a linkonce section in another
6584 bfd, or is weak. It's also possible that we are
6585 discarding the function due to a linker script /DISCARD/,
6586 which we test for via the output_section. */
6587 if (sym_sec->owner != ibfd
6588 || sym_sec->output_section == bfd_abs_section_ptr)
6589 need_edit = TRUE;
6590
6591 rel += 2;
6592 if (rel == relend
6593 || (rel + 1 == relend && rel->r_offset == offset + 16))
6594 {
6595 if (sec->size == offset + 24)
6596 {
6597 need_pad = NULL;
6598 break;
6599 }
6600 if (rel == relend && sec->size == offset + 16)
6601 {
6602 cnt_16b++;
6603 break;
6604 }
6605 goto broken_opd;
6606 }
6607
6608 if (rel->r_offset == offset + 24)
6609 offset += 24;
6610 else if (rel->r_offset != offset + 16)
6611 goto broken_opd;
6612 else if (rel + 1 < relend
6613 && ELF64_R_TYPE (rel[0].r_info) == R_PPC64_ADDR64
6614 && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOC)
6615 {
6616 offset += 16;
6617 cnt_16b++;
6618 }
6619 else if (rel + 2 < relend
6620 && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_ADDR64
6621 && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_TOC)
6622 {
6623 offset += 24;
6624 rel += 1;
6625 }
6626 else
6627 goto broken_opd;
6628 }
6629
6630 add_aux_fields = non_overlapping && cnt_16b > 0;
6631
6632 if (need_edit || add_aux_fields)
6633 {
6634 Elf_Internal_Rela *write_rel;
6635 bfd_byte *rptr, *wptr;
6636 bfd_byte *new_contents = NULL;
6637 bfd_boolean skip;
6638 long opd_ent_size;
6639 bfd_size_type amt;
6640
6641 amt = sec->size * sizeof (long) / 8;
6642 opd = &ppc64_elf_section_data (sec)->u.opd;
6643 opd->adjust = bfd_zalloc (obfd, amt);
6644 if (opd->adjust == NULL)
6645 return FALSE;
6646 ppc64_elf_section_data (sec)->sec_type = sec_opd;
6647
6648 /* This seems a waste of time as input .opd sections are all
6649 zeros as generated by gcc, but I suppose there's no reason
6650 this will always be so. We might start putting something in
6651 the third word of .opd entries. */
6652 if ((sec->flags & SEC_IN_MEMORY) == 0)
6653 {
6654 bfd_byte *loc;
6655 if (!bfd_malloc_and_get_section (ibfd, sec, &loc))
6656 {
6657 if (loc != NULL)
6658 free (loc);
6659 error_ret:
6660 if (local_syms != NULL
6661 && symtab_hdr->contents != (unsigned char *) local_syms)
6662 free (local_syms);
6663 if (elf_section_data (sec)->relocs != relstart)
6664 free (relstart);
6665 return FALSE;
6666 }
6667 sec->contents = loc;
6668 sec->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
6669 }
6670
6671 elf_section_data (sec)->relocs = relstart;
6672
6673 new_contents = sec->contents;
6674 if (add_aux_fields)
6675 {
6676 new_contents = bfd_malloc (sec->size + cnt_16b * 8);
6677 if (new_contents == NULL)
6678 return FALSE;
6679 need_pad = FALSE;
6680 }
6681 wptr = new_contents;
6682 rptr = sec->contents;
6683
6684 write_rel = relstart;
6685 skip = FALSE;
6686 offset = 0;
6687 opd_ent_size = 0;
6688 for (rel = relstart; rel < relend; rel++)
6689 {
6690 unsigned long r_symndx;
6691 asection *sym_sec;
6692 struct elf_link_hash_entry *h;
6693 Elf_Internal_Sym *sym;
6694
6695 r_symndx = ELF64_R_SYM (rel->r_info);
6696 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
6697 r_symndx, ibfd))
6698 goto error_ret;
6699
6700 if (rel->r_offset == offset)
6701 {
6702 struct ppc_link_hash_entry *fdh = NULL;
6703
6704 /* See if the .opd entry is full 24 byte or
6705 16 byte (with fd_aux entry overlapped with next
6706 fd_func). */
6707 opd_ent_size = 24;
6708 if ((rel + 2 == relend && sec->size == offset + 16)
6709 || (rel + 3 < relend
6710 && rel[2].r_offset == offset + 16
6711 && rel[3].r_offset == offset + 24
6712 && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_ADDR64
6713 && ELF64_R_TYPE (rel[3].r_info) == R_PPC64_TOC))
6714 opd_ent_size = 16;
6715
6716 if (h != NULL
6717 && h->root.root.string[0] == '.')
6718 {
6719 fdh = get_fdh ((struct ppc_link_hash_entry *) h,
6720 ppc_hash_table (info));
6721 if (fdh != NULL
6722 && fdh->elf.root.type != bfd_link_hash_defined
6723 && fdh->elf.root.type != bfd_link_hash_defweak)
6724 fdh = NULL;
6725 }
6726
6727 skip = (sym_sec->owner != ibfd
6728 || sym_sec->output_section == bfd_abs_section_ptr);
6729 if (skip)
6730 {
6731 if (fdh != NULL && sym_sec->owner == ibfd)
6732 {
6733 /* Arrange for the function descriptor sym
6734 to be dropped. */
6735 fdh->elf.root.u.def.value = 0;
6736 fdh->elf.root.u.def.section = sym_sec;
6737 }
6738 opd->adjust[rel->r_offset / 8] = -1;
6739 }
6740 else
6741 {
6742 /* We'll be keeping this opd entry. */
6743
6744 if (fdh != NULL)
6745 {
6746 /* Redefine the function descriptor symbol to
6747 this location in the opd section. It is
6748 necessary to update the value here rather
6749 than using an array of adjustments as we do
6750 for local symbols, because various places
6751 in the generic ELF code use the value
6752 stored in u.def.value. */
6753 fdh->elf.root.u.def.value = wptr - new_contents;
6754 fdh->adjust_done = 1;
6755 }
6756
6757 /* Local syms are a bit tricky. We could
6758 tweak them as they can be cached, but
6759 we'd need to look through the local syms
6760 for the function descriptor sym which we
6761 don't have at the moment. So keep an
6762 array of adjustments. */
6763 opd->adjust[rel->r_offset / 8]
6764 = (wptr - new_contents) - (rptr - sec->contents);
6765
6766 if (wptr != rptr)
6767 memcpy (wptr, rptr, opd_ent_size);
6768 wptr += opd_ent_size;
6769 if (add_aux_fields && opd_ent_size == 16)
6770 {
6771 memset (wptr, '\0', 8);
6772 wptr += 8;
6773 }
6774 }
6775 rptr += opd_ent_size;
6776 offset += opd_ent_size;
6777 }
6778
6779 if (skip)
6780 {
6781 if (!NO_OPD_RELOCS
6782 && !info->relocatable
6783 && !dec_dynrel_count (rel->r_info, sec, info,
6784 NULL, h, sym_sec))
6785 goto error_ret;
6786 }
6787 else
6788 {
6789 /* We need to adjust any reloc offsets to point to the
6790 new opd entries. While we're at it, we may as well
6791 remove redundant relocs. */
6792 rel->r_offset += opd->adjust[(offset - opd_ent_size) / 8];
6793 if (write_rel != rel)
6794 memcpy (write_rel, rel, sizeof (*rel));
6795 ++write_rel;
6796 }
6797 }
6798
6799 sec->size = wptr - new_contents;
6800 sec->reloc_count = write_rel - relstart;
6801 if (add_aux_fields)
6802 {
6803 free (sec->contents);
6804 sec->contents = new_contents;
6805 }
6806
6807 /* Fudge the header size too, as this is used later in
6808 elf_bfd_final_link if we are emitting relocs. */
6809 elf_section_data (sec)->rel_hdr.sh_size
6810 = sec->reloc_count * elf_section_data (sec)->rel_hdr.sh_entsize;
6811 BFD_ASSERT (elf_section_data (sec)->rel_hdr2 == NULL);
6812 some_edited = TRUE;
6813 }
6814 else if (elf_section_data (sec)->relocs != relstart)
6815 free (relstart);
6816
6817 if (local_syms != NULL
6818 && symtab_hdr->contents != (unsigned char *) local_syms)
6819 {
6820 if (!info->keep_memory)
6821 free (local_syms);
6822 else
6823 symtab_hdr->contents = (unsigned char *) local_syms;
6824 }
6825 }
6826
6827 if (some_edited)
6828 elf_link_hash_traverse (elf_hash_table (info), adjust_opd_syms, NULL);
6829
6830 /* If we are doing a final link and the last .opd entry is just 16 byte
6831 long, add a 8 byte padding after it. */
6832 if (need_pad != NULL && !info->relocatable)
6833 {
6834 bfd_byte *p;
6835
6836 if ((need_pad->flags & SEC_IN_MEMORY) == 0)
6837 {
6838 BFD_ASSERT (need_pad->size > 0);
6839
6840 p = bfd_malloc (need_pad->size + 8);
6841 if (p == NULL)
6842 return FALSE;
6843
6844 if (! bfd_get_section_contents (need_pad->owner, need_pad,
6845 p, 0, need_pad->size))
6846 return FALSE;
6847
6848 need_pad->contents = p;
6849 need_pad->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
6850 }
6851 else
6852 {
6853 p = bfd_realloc (need_pad->contents, need_pad->size + 8);
6854 if (p == NULL)
6855 return FALSE;
6856
6857 need_pad->contents = p;
6858 }
6859
6860 memset (need_pad->contents + need_pad->size, 0, 8);
6861 need_pad->size += 8;
6862 }
6863
6864 return TRUE;
6865 }
6866
6867 /* Set htab->tls_get_addr and call the generic ELF tls_setup function. */
6868
6869 asection *
6870 ppc64_elf_tls_setup (bfd *obfd, struct bfd_link_info *info)
6871 {
6872 struct ppc_link_hash_table *htab;
6873
6874 htab = ppc_hash_table (info);
6875 htab->tls_get_addr = ((struct ppc_link_hash_entry *)
6876 elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
6877 FALSE, FALSE, TRUE));
6878 htab->tls_get_addr_fd = ((struct ppc_link_hash_entry *)
6879 elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
6880 FALSE, FALSE, TRUE));
6881 return _bfd_elf_tls_setup (obfd, info);
6882 }
6883
6884 /* Return TRUE iff REL is a branch reloc with a global symbol matching
6885 HASH1 or HASH2. */
6886
6887 static bfd_boolean
6888 branch_reloc_hash_match (const bfd *ibfd,
6889 const Elf_Internal_Rela *rel,
6890 const struct ppc_link_hash_entry *hash1,
6891 const struct ppc_link_hash_entry *hash2)
6892 {
6893 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
6894 enum elf_ppc64_reloc_type r_type = ELF64_R_TYPE (rel->r_info);
6895 unsigned int r_symndx = ELF64_R_SYM (rel->r_info);
6896
6897 if (r_symndx >= symtab_hdr->sh_info
6898 && (r_type == R_PPC64_REL24
6899 || r_type == R_PPC64_REL14
6900 || r_type == R_PPC64_REL14_BRTAKEN
6901 || r_type == R_PPC64_REL14_BRNTAKEN
6902 || r_type == R_PPC64_ADDR24
6903 || r_type == R_PPC64_ADDR14
6904 || r_type == R_PPC64_ADDR14_BRTAKEN
6905 || r_type == R_PPC64_ADDR14_BRNTAKEN))
6906 {
6907 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
6908 struct elf_link_hash_entry *h;
6909
6910 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
6911 while (h->root.type == bfd_link_hash_indirect
6912 || h->root.type == bfd_link_hash_warning)
6913 h = (struct elf_link_hash_entry *) h->root.u.i.link;
6914 if (h == &hash1->elf || h == &hash2->elf)
6915 return TRUE;
6916 }
6917 return FALSE;
6918 }
6919
6920 /* Run through all the TLS relocs looking for optimization
6921 opportunities. The linker has been hacked (see ppc64elf.em) to do
6922 a preliminary section layout so that we know the TLS segment
6923 offsets. We can't optimize earlier because some optimizations need
6924 to know the tp offset, and we need to optimize before allocating
6925 dynamic relocations. */
6926
6927 bfd_boolean
6928 ppc64_elf_tls_optimize (bfd *obfd ATTRIBUTE_UNUSED, struct bfd_link_info *info)
6929 {
6930 bfd *ibfd;
6931 asection *sec;
6932 struct ppc_link_hash_table *htab;
6933 int pass;
6934
6935 if (info->relocatable || !info->executable)
6936 return TRUE;
6937
6938 htab = ppc_hash_table (info);
6939 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
6940 {
6941 Elf_Internal_Sym *locsyms = NULL;
6942 asection *toc = bfd_get_section_by_name (ibfd, ".toc");
6943 unsigned char *toc_ref = NULL;
6944
6945 /* Look at all the sections for this file. Make two passes over
6946 the relocs. On the first pass, mark toc entries involved
6947 with tls relocs, and check that tls relocs involved in
6948 setting up a tls_get_addr call are indeed followed by such a
6949 call. If they are not, exclude them from the optimizations
6950 done on the second pass. */
6951 for (pass = 0; pass < 2; ++pass)
6952 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
6953 if (sec->has_tls_reloc && !bfd_is_abs_section (sec->output_section))
6954 {
6955 Elf_Internal_Rela *relstart, *rel, *relend;
6956
6957 /* Read the relocations. */
6958 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
6959 info->keep_memory);
6960 if (relstart == NULL)
6961 return FALSE;
6962
6963 relend = relstart + sec->reloc_count;
6964 for (rel = relstart; rel < relend; rel++)
6965 {
6966 enum elf_ppc64_reloc_type r_type;
6967 unsigned long r_symndx;
6968 struct elf_link_hash_entry *h;
6969 Elf_Internal_Sym *sym;
6970 asection *sym_sec;
6971 char *tls_mask;
6972 char tls_set, tls_clear, tls_type = 0;
6973 bfd_vma value;
6974 bfd_boolean ok_tprel, is_local;
6975 long toc_ref_index = 0;
6976 int expecting_tls_get_addr = 0;
6977
6978 r_symndx = ELF64_R_SYM (rel->r_info);
6979 if (!get_sym_h (&h, &sym, &sym_sec, &tls_mask, &locsyms,
6980 r_symndx, ibfd))
6981 {
6982 err_free_rel:
6983 if (elf_section_data (sec)->relocs != relstart)
6984 free (relstart);
6985 if (toc_ref != NULL)
6986 free (toc_ref);
6987 if (locsyms != NULL
6988 && (elf_symtab_hdr (ibfd).contents
6989 != (unsigned char *) locsyms))
6990 free (locsyms);
6991 return FALSE;
6992 }
6993
6994 if (h != NULL)
6995 {
6996 if (h->root.type != bfd_link_hash_defined
6997 && h->root.type != bfd_link_hash_defweak)
6998 continue;
6999 value = h->root.u.def.value;
7000 }
7001 else
7002 /* Symbols referenced by TLS relocs must be of type
7003 STT_TLS. So no need for .opd local sym adjust. */
7004 value = sym->st_value;
7005
7006 ok_tprel = FALSE;
7007 is_local = FALSE;
7008 if (h == NULL
7009 || !h->def_dynamic)
7010 {
7011 is_local = TRUE;
7012 value += sym_sec->output_offset;
7013 value += sym_sec->output_section->vma;
7014 value -= htab->elf.tls_sec->vma;
7015 ok_tprel = (value + TP_OFFSET + ((bfd_vma) 1 << 31)
7016 < (bfd_vma) 1 << 32);
7017 }
7018
7019 r_type = ELF64_R_TYPE (rel->r_info);
7020 switch (r_type)
7021 {
7022 case R_PPC64_GOT_TLSLD16:
7023 case R_PPC64_GOT_TLSLD16_LO:
7024 expecting_tls_get_addr = 1;
7025 /* Fall thru */
7026
7027 case R_PPC64_GOT_TLSLD16_HI:
7028 case R_PPC64_GOT_TLSLD16_HA:
7029 /* These relocs should never be against a symbol
7030 defined in a shared lib. Leave them alone if
7031 that turns out to be the case. */
7032 if (!is_local)
7033 continue;
7034
7035 /* LD -> LE */
7036 tls_set = 0;
7037 tls_clear = TLS_LD;
7038 tls_type = TLS_TLS | TLS_LD;
7039 break;
7040
7041 case R_PPC64_GOT_TLSGD16:
7042 case R_PPC64_GOT_TLSGD16_LO:
7043 expecting_tls_get_addr = 1;
7044 /* Fall thru */
7045
7046 case R_PPC64_GOT_TLSGD16_HI:
7047 case R_PPC64_GOT_TLSGD16_HA:
7048 if (ok_tprel)
7049 /* GD -> LE */
7050 tls_set = 0;
7051 else
7052 /* GD -> IE */
7053 tls_set = TLS_TLS | TLS_TPRELGD;
7054 tls_clear = TLS_GD;
7055 tls_type = TLS_TLS | TLS_GD;
7056 break;
7057
7058 case R_PPC64_GOT_TPREL16_DS:
7059 case R_PPC64_GOT_TPREL16_LO_DS:
7060 case R_PPC64_GOT_TPREL16_HI:
7061 case R_PPC64_GOT_TPREL16_HA:
7062 if (ok_tprel)
7063 {
7064 /* IE -> LE */
7065 tls_set = 0;
7066 tls_clear = TLS_TPREL;
7067 tls_type = TLS_TLS | TLS_TPREL;
7068 break;
7069 }
7070 continue;
7071
7072 case R_PPC64_TOC16:
7073 case R_PPC64_TOC16_LO:
7074 case R_PPC64_TLS:
7075 if (sym_sec == NULL || sym_sec != toc)
7076 continue;
7077
7078 /* Mark this toc entry as referenced by a TLS
7079 code sequence. We can do that now in the
7080 case of R_PPC64_TLS, and after checking for
7081 tls_get_addr for the TOC16 relocs. */
7082 if (toc_ref == NULL)
7083 {
7084 toc_ref = bfd_zmalloc (toc->size / 8);
7085 if (toc_ref == NULL)
7086 goto err_free_rel;
7087 }
7088 if (h != NULL)
7089 value = h->root.u.def.value;
7090 else
7091 value = sym->st_value;
7092 value += rel->r_addend;
7093 BFD_ASSERT (value < toc->size && value % 8 == 0);
7094 toc_ref_index = value / 8;
7095 if (r_type == R_PPC64_TLS)
7096 {
7097 toc_ref[toc_ref_index] = 1;
7098 continue;
7099 }
7100
7101 if (pass != 0 && toc_ref[toc_ref_index] == 0)
7102 continue;
7103
7104 tls_set = 0;
7105 tls_clear = 0;
7106 expecting_tls_get_addr = 2;
7107 break;
7108
7109 case R_PPC64_TPREL64:
7110 if (pass == 0
7111 || sec != toc
7112 || toc_ref == NULL
7113 || !toc_ref[rel->r_offset / 8])
7114 continue;
7115 if (ok_tprel)
7116 {
7117 /* IE -> LE */
7118 tls_set = TLS_EXPLICIT;
7119 tls_clear = TLS_TPREL;
7120 break;
7121 }
7122 continue;
7123
7124 case R_PPC64_DTPMOD64:
7125 if (pass == 0
7126 || sec != toc
7127 || toc_ref == NULL
7128 || !toc_ref[rel->r_offset / 8])
7129 continue;
7130 if (rel + 1 < relend
7131 && (rel[1].r_info
7132 == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64))
7133 && rel[1].r_offset == rel->r_offset + 8)
7134 {
7135 if (ok_tprel)
7136 /* GD -> LE */
7137 tls_set = TLS_EXPLICIT | TLS_GD;
7138 else
7139 /* GD -> IE */
7140 tls_set = TLS_EXPLICIT | TLS_GD | TLS_TPRELGD;
7141 tls_clear = TLS_GD;
7142 }
7143 else
7144 {
7145 if (!is_local)
7146 continue;
7147
7148 /* LD -> LE */
7149 tls_set = TLS_EXPLICIT;
7150 tls_clear = TLS_LD;
7151 }
7152 break;
7153
7154 default:
7155 continue;
7156 }
7157
7158 if (pass == 0)
7159 {
7160 if (!expecting_tls_get_addr)
7161 continue;
7162
7163 if (rel + 1 < relend
7164 && branch_reloc_hash_match (ibfd, rel + 1,
7165 htab->tls_get_addr,
7166 htab->tls_get_addr_fd))
7167 {
7168 if (expecting_tls_get_addr == 2)
7169 {
7170 /* Check for toc tls entries. */
7171 char *toc_tls;
7172 int retval;
7173
7174 retval = get_tls_mask (&toc_tls, NULL, NULL,
7175 &locsyms,
7176 rel, ibfd);
7177 if (retval == 0)
7178 goto err_free_rel;
7179 if (retval > 1 && toc_tls != NULL)
7180 toc_ref[toc_ref_index] = 1;
7181 }
7182 continue;
7183 }
7184
7185 if (expecting_tls_get_addr != 1)
7186 continue;
7187
7188 /* Uh oh, we didn't find the expected call. We
7189 could just mark this symbol to exclude it
7190 from tls optimization but it's safer to skip
7191 the entire section. */
7192 sec->has_tls_reloc = 0;
7193 break;
7194 }
7195
7196 if (expecting_tls_get_addr && htab->tls_get_addr != NULL)
7197 {
7198 struct plt_entry *ent;
7199 for (ent = htab->tls_get_addr->elf.plt.plist;
7200 ent != NULL;
7201 ent = ent->next)
7202 if (ent->addend == 0)
7203 {
7204 if (ent->plt.refcount > 0)
7205 {
7206 ent->plt.refcount -= 1;
7207 expecting_tls_get_addr = 0;
7208 }
7209 break;
7210 }
7211 }
7212
7213 if (expecting_tls_get_addr && htab->tls_get_addr_fd != NULL)
7214 {
7215 struct plt_entry *ent;
7216 for (ent = htab->tls_get_addr_fd->elf.plt.plist;
7217 ent != NULL;
7218 ent = ent->next)
7219 if (ent->addend == 0)
7220 {
7221 if (ent->plt.refcount > 0)
7222 ent->plt.refcount -= 1;
7223 break;
7224 }
7225 }
7226
7227 if (tls_clear == 0)
7228 continue;
7229
7230 if ((tls_set & TLS_EXPLICIT) == 0)
7231 {
7232 struct got_entry *ent;
7233
7234 /* Adjust got entry for this reloc. */
7235 if (h != NULL)
7236 ent = h->got.glist;
7237 else
7238 ent = elf_local_got_ents (ibfd)[r_symndx];
7239
7240 for (; ent != NULL; ent = ent->next)
7241 if (ent->addend == rel->r_addend
7242 && ent->owner == ibfd
7243 && ent->tls_type == tls_type)
7244 break;
7245 if (ent == NULL)
7246 abort ();
7247
7248 if (tls_set == 0)
7249 {
7250 /* We managed to get rid of a got entry. */
7251 if (ent->got.refcount > 0)
7252 ent->got.refcount -= 1;
7253 }
7254 }
7255 else
7256 {
7257 /* If we got rid of a DTPMOD/DTPREL reloc pair then
7258 we'll lose one or two dyn relocs. */
7259 if (!dec_dynrel_count (rel->r_info, sec, info,
7260 NULL, h, sym_sec))
7261 return FALSE;
7262
7263 if (tls_set == (TLS_EXPLICIT | TLS_GD))
7264 {
7265 if (!dec_dynrel_count ((rel + 1)->r_info, sec, info,
7266 NULL, h, sym_sec))
7267 return FALSE;
7268 }
7269 }
7270
7271 *tls_mask |= tls_set;
7272 *tls_mask &= ~tls_clear;
7273 }
7274
7275 if (elf_section_data (sec)->relocs != relstart)
7276 free (relstart);
7277 }
7278
7279 if (toc_ref != NULL)
7280 free (toc_ref);
7281
7282 if (locsyms != NULL
7283 && (elf_symtab_hdr (ibfd).contents != (unsigned char *) locsyms))
7284 {
7285 if (!info->keep_memory)
7286 free (locsyms);
7287 else
7288 elf_symtab_hdr (ibfd).contents = (unsigned char *) locsyms;
7289 }
7290 }
7291 return TRUE;
7292 }
7293
7294 /* Called via elf_link_hash_traverse from ppc64_elf_edit_toc to adjust
7295 the values of any global symbols in a toc section that has been
7296 edited. Globals in toc sections should be a rarity, so this function
7297 sets a flag if any are found in toc sections other than the one just
7298 edited, so that futher hash table traversals can be avoided. */
7299
7300 struct adjust_toc_info
7301 {
7302 asection *toc;
7303 unsigned long *skip;
7304 bfd_boolean global_toc_syms;
7305 };
7306
7307 static bfd_boolean
7308 adjust_toc_syms (struct elf_link_hash_entry *h, void *inf)
7309 {
7310 struct ppc_link_hash_entry *eh;
7311 struct adjust_toc_info *toc_inf = (struct adjust_toc_info *) inf;
7312
7313 if (h->root.type == bfd_link_hash_indirect)
7314 return TRUE;
7315
7316 if (h->root.type == bfd_link_hash_warning)
7317 h = (struct elf_link_hash_entry *) h->root.u.i.link;
7318
7319 if (h->root.type != bfd_link_hash_defined
7320 && h->root.type != bfd_link_hash_defweak)
7321 return TRUE;
7322
7323 eh = (struct ppc_link_hash_entry *) h;
7324 if (eh->adjust_done)
7325 return TRUE;
7326
7327 if (eh->elf.root.u.def.section == toc_inf->toc)
7328 {
7329 unsigned long skip = toc_inf->skip[eh->elf.root.u.def.value >> 3];
7330 if (skip != (unsigned long) -1)
7331 eh->elf.root.u.def.value -= skip;
7332 else
7333 {
7334 (*_bfd_error_handler)
7335 (_("%s defined in removed toc entry"), eh->elf.root.root.string);
7336 eh->elf.root.u.def.section = &bfd_abs_section;
7337 eh->elf.root.u.def.value = 0;
7338 }
7339 eh->adjust_done = 1;
7340 }
7341 else if (strcmp (eh->elf.root.u.def.section->name, ".toc") == 0)
7342 toc_inf->global_toc_syms = TRUE;
7343
7344 return TRUE;
7345 }
7346
7347 /* Examine all relocs referencing .toc sections in order to remove
7348 unused .toc entries. */
7349
7350 bfd_boolean
7351 ppc64_elf_edit_toc (bfd *obfd ATTRIBUTE_UNUSED, struct bfd_link_info *info)
7352 {
7353 bfd *ibfd;
7354 struct adjust_toc_info toc_inf;
7355
7356 toc_inf.global_toc_syms = TRUE;
7357 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
7358 {
7359 asection *toc, *sec;
7360 Elf_Internal_Shdr *symtab_hdr;
7361 Elf_Internal_Sym *local_syms;
7362 struct elf_link_hash_entry **sym_hashes;
7363 Elf_Internal_Rela *relstart, *rel;
7364 unsigned long *skip, *drop;
7365 unsigned char *used;
7366 unsigned char *keep, last, some_unused;
7367
7368 toc = bfd_get_section_by_name (ibfd, ".toc");
7369 if (toc == NULL
7370 || toc->size == 0
7371 || toc->sec_info_type == ELF_INFO_TYPE_JUST_SYMS
7372 || elf_discarded_section (toc))
7373 continue;
7374
7375 local_syms = NULL;
7376 symtab_hdr = &elf_symtab_hdr (ibfd);
7377 sym_hashes = elf_sym_hashes (ibfd);
7378
7379 /* Look at sections dropped from the final link. */
7380 skip = NULL;
7381 relstart = NULL;
7382 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
7383 {
7384 if (sec->reloc_count == 0
7385 || !elf_discarded_section (sec)
7386 || get_opd_info (sec)
7387 || (sec->flags & SEC_ALLOC) == 0
7388 || (sec->flags & SEC_DEBUGGING) != 0)
7389 continue;
7390
7391 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL, FALSE);
7392 if (relstart == NULL)
7393 goto error_ret;
7394
7395 /* Run through the relocs to see which toc entries might be
7396 unused. */
7397 for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
7398 {
7399 enum elf_ppc64_reloc_type r_type;
7400 unsigned long r_symndx;
7401 asection *sym_sec;
7402 struct elf_link_hash_entry *h;
7403 Elf_Internal_Sym *sym;
7404 bfd_vma val;
7405
7406 r_type = ELF64_R_TYPE (rel->r_info);
7407 switch (r_type)
7408 {
7409 default:
7410 continue;
7411
7412 case R_PPC64_TOC16:
7413 case R_PPC64_TOC16_LO:
7414 case R_PPC64_TOC16_HI:
7415 case R_PPC64_TOC16_HA:
7416 case R_PPC64_TOC16_DS:
7417 case R_PPC64_TOC16_LO_DS:
7418 break;
7419 }
7420
7421 r_symndx = ELF64_R_SYM (rel->r_info);
7422 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7423 r_symndx, ibfd))
7424 goto error_ret;
7425
7426 if (sym_sec != toc)
7427 continue;
7428
7429 if (h != NULL)
7430 val = h->root.u.def.value;
7431 else
7432 val = sym->st_value;
7433 val += rel->r_addend;
7434
7435 if (val >= toc->size)
7436 continue;
7437
7438 /* Anything in the toc ought to be aligned to 8 bytes.
7439 If not, don't mark as unused. */
7440 if (val & 7)
7441 continue;
7442
7443 if (skip == NULL)
7444 {
7445 skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 7) / 8);
7446 if (skip == NULL)
7447 goto error_ret;
7448 }
7449
7450 skip[val >> 3] = 1;
7451 }
7452
7453 if (elf_section_data (sec)->relocs != relstart)
7454 free (relstart);
7455 }
7456
7457 if (skip == NULL)
7458 continue;
7459
7460 used = bfd_zmalloc (sizeof (*used) * (toc->size + 7) / 8);
7461 if (used == NULL)
7462 {
7463 error_ret:
7464 if (local_syms != NULL
7465 && symtab_hdr->contents != (unsigned char *) local_syms)
7466 free (local_syms);
7467 if (sec != NULL
7468 && relstart != NULL
7469 && elf_section_data (sec)->relocs != relstart)
7470 free (relstart);
7471 if (skip != NULL)
7472 free (skip);
7473 return FALSE;
7474 }
7475
7476 /* Now check all kept sections that might reference the toc.
7477 Check the toc itself last. */
7478 for (sec = (ibfd->sections == toc && toc->next ? toc->next
7479 : ibfd->sections);
7480 sec != NULL;
7481 sec = (sec == toc ? NULL
7482 : sec->next == NULL ? toc
7483 : sec->next == toc && toc->next ? toc->next
7484 : sec->next))
7485 {
7486 int repeat;
7487
7488 if (sec->reloc_count == 0
7489 || elf_discarded_section (sec)
7490 || get_opd_info (sec)
7491 || (sec->flags & SEC_ALLOC) == 0
7492 || (sec->flags & SEC_DEBUGGING) != 0)
7493 continue;
7494
7495 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL, TRUE);
7496 if (relstart == NULL)
7497 goto error_ret;
7498
7499 /* Mark toc entries referenced as used. */
7500 repeat = 0;
7501 do
7502 for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
7503 {
7504 enum elf_ppc64_reloc_type r_type;
7505 unsigned long r_symndx;
7506 asection *sym_sec;
7507 struct elf_link_hash_entry *h;
7508 Elf_Internal_Sym *sym;
7509 bfd_vma val;
7510
7511 r_type = ELF64_R_TYPE (rel->r_info);
7512 switch (r_type)
7513 {
7514 case R_PPC64_TOC16:
7515 case R_PPC64_TOC16_LO:
7516 case R_PPC64_TOC16_HI:
7517 case R_PPC64_TOC16_HA:
7518 case R_PPC64_TOC16_DS:
7519 case R_PPC64_TOC16_LO_DS:
7520 /* In case we're taking addresses of toc entries. */
7521 case R_PPC64_ADDR64:
7522 break;
7523
7524 default:
7525 continue;
7526 }
7527
7528 r_symndx = ELF64_R_SYM (rel->r_info);
7529 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7530 r_symndx, ibfd))
7531 {
7532 free (used);
7533 goto error_ret;
7534 }
7535
7536 if (sym_sec != toc)
7537 continue;
7538
7539 if (h != NULL)
7540 val = h->root.u.def.value;
7541 else
7542 val = sym->st_value;
7543 val += rel->r_addend;
7544
7545 if (val >= toc->size)
7546 continue;
7547
7548 /* For the toc section, we only mark as used if
7549 this entry itself isn't unused. */
7550 if (sec == toc
7551 && !used[val >> 3]
7552 && (used[rel->r_offset >> 3]
7553 || !skip[rel->r_offset >> 3]))
7554 /* Do all the relocs again, to catch reference
7555 chains. */
7556 repeat = 1;
7557
7558 used[val >> 3] = 1;
7559 }
7560 while (repeat);
7561 }
7562
7563 /* Merge the used and skip arrays. Assume that TOC
7564 doublewords not appearing as either used or unused belong
7565 to to an entry more than one doubleword in size. */
7566 for (drop = skip, keep = used, last = 0, some_unused = 0;
7567 drop < skip + (toc->size + 7) / 8;
7568 ++drop, ++keep)
7569 {
7570 if (*keep)
7571 {
7572 *drop = 0;
7573 last = 0;
7574 }
7575 else if (*drop)
7576 {
7577 some_unused = 1;
7578 last = 1;
7579 }
7580 else
7581 *drop = last;
7582 }
7583
7584 free (used);
7585
7586 if (some_unused)
7587 {
7588 bfd_byte *contents, *src;
7589 unsigned long off;
7590
7591 /* Shuffle the toc contents, and at the same time convert the
7592 skip array from booleans into offsets. */
7593 if (!bfd_malloc_and_get_section (ibfd, toc, &contents))
7594 goto error_ret;
7595
7596 elf_section_data (toc)->this_hdr.contents = contents;
7597
7598 for (src = contents, off = 0, drop = skip;
7599 src < contents + toc->size;
7600 src += 8, ++drop)
7601 {
7602 if (*drop)
7603 {
7604 *drop = (unsigned long) -1;
7605 off += 8;
7606 }
7607 else if (off != 0)
7608 {
7609 *drop = off;
7610 memcpy (src - off, src, 8);
7611 }
7612 }
7613 toc->rawsize = toc->size;
7614 toc->size = src - contents - off;
7615
7616 if (toc->reloc_count != 0)
7617 {
7618 Elf_Internal_Rela *wrel;
7619 bfd_size_type sz;
7620
7621 /* Read toc relocs. */
7622 relstart = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
7623 TRUE);
7624 if (relstart == NULL)
7625 goto error_ret;
7626
7627 /* Remove unused toc relocs, and adjust those we keep. */
7628 wrel = relstart;
7629 for (rel = relstart; rel < relstart + toc->reloc_count; ++rel)
7630 if (skip[rel->r_offset >> 3] != (unsigned long) -1)
7631 {
7632 wrel->r_offset = rel->r_offset - skip[rel->r_offset >> 3];
7633 wrel->r_info = rel->r_info;
7634 wrel->r_addend = rel->r_addend;
7635 ++wrel;
7636 }
7637 else if (!dec_dynrel_count (rel->r_info, toc, info,
7638 &local_syms, NULL, NULL))
7639 goto error_ret;
7640
7641 toc->reloc_count = wrel - relstart;
7642 sz = elf_section_data (toc)->rel_hdr.sh_entsize;
7643 elf_section_data (toc)->rel_hdr.sh_size = toc->reloc_count * sz;
7644 BFD_ASSERT (elf_section_data (toc)->rel_hdr2 == NULL);
7645 }
7646
7647 /* Adjust addends for relocs against the toc section sym. */
7648 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
7649 {
7650 if (sec->reloc_count == 0
7651 || elf_discarded_section (sec))
7652 continue;
7653
7654 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
7655 TRUE);
7656 if (relstart == NULL)
7657 goto error_ret;
7658
7659 for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
7660 {
7661 enum elf_ppc64_reloc_type r_type;
7662 unsigned long r_symndx;
7663 asection *sym_sec;
7664 struct elf_link_hash_entry *h;
7665 Elf_Internal_Sym *sym;
7666
7667 r_type = ELF64_R_TYPE (rel->r_info);
7668 switch (r_type)
7669 {
7670 default:
7671 continue;
7672
7673 case R_PPC64_TOC16:
7674 case R_PPC64_TOC16_LO:
7675 case R_PPC64_TOC16_HI:
7676 case R_PPC64_TOC16_HA:
7677 case R_PPC64_TOC16_DS:
7678 case R_PPC64_TOC16_LO_DS:
7679 case R_PPC64_ADDR64:
7680 break;
7681 }
7682
7683 r_symndx = ELF64_R_SYM (rel->r_info);
7684 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7685 r_symndx, ibfd))
7686 goto error_ret;
7687
7688 if (sym_sec != toc || h != NULL || sym->st_value != 0)
7689 continue;
7690
7691 rel->r_addend -= skip[rel->r_addend >> 3];
7692 }
7693 }
7694
7695 /* We shouldn't have local or global symbols defined in the TOC,
7696 but handle them anyway. */
7697 if (local_syms != NULL)
7698 {
7699 Elf_Internal_Sym *sym;
7700
7701 for (sym = local_syms;
7702 sym < local_syms + symtab_hdr->sh_info;
7703 ++sym)
7704 if (sym->st_value != 0
7705 && bfd_section_from_elf_index (ibfd, sym->st_shndx) == toc)
7706 {
7707 if (skip[sym->st_value >> 3] != (unsigned long) -1)
7708 sym->st_value -= skip[sym->st_value >> 3];
7709 else
7710 {
7711 (*_bfd_error_handler)
7712 (_("%s defined in removed toc entry"),
7713 bfd_elf_sym_name (ibfd, symtab_hdr, sym,
7714 NULL));
7715 sym->st_value = 0;
7716 sym->st_shndx = SHN_ABS;
7717 }
7718 symtab_hdr->contents = (unsigned char *) local_syms;
7719 }
7720 }
7721
7722 /* Finally, adjust any global syms defined in the toc. */
7723 if (toc_inf.global_toc_syms)
7724 {
7725 toc_inf.toc = toc;
7726 toc_inf.skip = skip;
7727 toc_inf.global_toc_syms = FALSE;
7728 elf_link_hash_traverse (elf_hash_table (info), adjust_toc_syms,
7729 &toc_inf);
7730 }
7731 }
7732
7733 if (local_syms != NULL
7734 && symtab_hdr->contents != (unsigned char *) local_syms)
7735 {
7736 if (!info->keep_memory)
7737 free (local_syms);
7738 else
7739 symtab_hdr->contents = (unsigned char *) local_syms;
7740 }
7741 free (skip);
7742 }
7743
7744 return TRUE;
7745 }
7746
7747 /* Allocate space in .plt, .got and associated reloc sections for
7748 dynamic relocs. */
7749
7750 static bfd_boolean
7751 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
7752 {
7753 struct bfd_link_info *info;
7754 struct ppc_link_hash_table *htab;
7755 asection *s;
7756 struct ppc_link_hash_entry *eh;
7757 struct ppc_dyn_relocs *p;
7758 struct got_entry *gent;
7759
7760 if (h->root.type == bfd_link_hash_indirect)
7761 return TRUE;
7762
7763 if (h->root.type == bfd_link_hash_warning)
7764 h = (struct elf_link_hash_entry *) h->root.u.i.link;
7765
7766 info = (struct bfd_link_info *) inf;
7767 htab = ppc_hash_table (info);
7768
7769 if (htab->elf.dynamic_sections_created
7770 && h->dynindx != -1
7771 && WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info->shared, h))
7772 {
7773 struct plt_entry *pent;
7774 bfd_boolean doneone = FALSE;
7775 for (pent = h->plt.plist; pent != NULL; pent = pent->next)
7776 if (pent->plt.refcount > 0)
7777 {
7778 /* If this is the first .plt entry, make room for the special
7779 first entry. */
7780 s = htab->plt;
7781 if (s->size == 0)
7782 s->size += PLT_INITIAL_ENTRY_SIZE;
7783
7784 pent->plt.offset = s->size;
7785
7786 /* Make room for this entry. */
7787 s->size += PLT_ENTRY_SIZE;
7788
7789 /* Make room for the .glink code. */
7790 s = htab->glink;
7791 if (s->size == 0)
7792 s->size += GLINK_CALL_STUB_SIZE;
7793 /* We need bigger stubs past index 32767. */
7794 if (s->size >= GLINK_CALL_STUB_SIZE + 32768*2*4)
7795 s->size += 4;
7796 s->size += 2*4;
7797
7798 /* We also need to make an entry in the .rela.plt section. */
7799 s = htab->relplt;
7800 s->size += sizeof (Elf64_External_Rela);
7801 doneone = TRUE;
7802 }
7803 else
7804 pent->plt.offset = (bfd_vma) -1;
7805 if (!doneone)
7806 {
7807 h->plt.plist = NULL;
7808 h->needs_plt = 0;
7809 }
7810 }
7811 else
7812 {
7813 h->plt.plist = NULL;
7814 h->needs_plt = 0;
7815 }
7816
7817 eh = (struct ppc_link_hash_entry *) h;
7818 /* Run through the TLS GD got entries first if we're changing them
7819 to TPREL. */
7820 if ((eh->tls_mask & TLS_TPRELGD) != 0)
7821 for (gent = h->got.glist; gent != NULL; gent = gent->next)
7822 if (gent->got.refcount > 0
7823 && (gent->tls_type & TLS_GD) != 0)
7824 {
7825 /* This was a GD entry that has been converted to TPREL. If
7826 there happens to be a TPREL entry we can use that one. */
7827 struct got_entry *ent;
7828 for (ent = h->got.glist; ent != NULL; ent = ent->next)
7829 if (ent->got.refcount > 0
7830 && (ent->tls_type & TLS_TPREL) != 0
7831 && ent->addend == gent->addend
7832 && ent->owner == gent->owner)
7833 {
7834 gent->got.refcount = 0;
7835 break;
7836 }
7837
7838 /* If not, then we'll be using our own TPREL entry. */
7839 if (gent->got.refcount != 0)
7840 gent->tls_type = TLS_TLS | TLS_TPREL;
7841 }
7842
7843 for (gent = h->got.glist; gent != NULL; gent = gent->next)
7844 if (gent->got.refcount > 0)
7845 {
7846 bfd_boolean dyn;
7847
7848 /* Make sure this symbol is output as a dynamic symbol.
7849 Undefined weak syms won't yet be marked as dynamic,
7850 nor will all TLS symbols. */
7851 if (h->dynindx == -1
7852 && !h->forced_local
7853 && htab->elf.dynamic_sections_created)
7854 {
7855 if (! bfd_elf_link_record_dynamic_symbol (info, h))
7856 return FALSE;
7857 }
7858
7859 if ((gent->tls_type & TLS_LD) != 0
7860 && !h->def_dynamic)
7861 {
7862 ppc64_tlsld_got (gent->owner)->refcount += 1;
7863 gent->got.offset = (bfd_vma) -1;
7864 continue;
7865 }
7866
7867 if (!is_ppc64_elf (gent->owner))
7868 continue;
7869
7870 s = ppc64_elf_tdata (gent->owner)->got;
7871 gent->got.offset = s->size;
7872 s->size
7873 += (gent->tls_type & eh->tls_mask & (TLS_GD | TLS_LD)) ? 16 : 8;
7874 dyn = htab->elf.dynamic_sections_created;
7875 if ((info->shared
7876 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h))
7877 && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
7878 || h->root.type != bfd_link_hash_undefweak))
7879 ppc64_elf_tdata (gent->owner)->relgot->size
7880 += (gent->tls_type & eh->tls_mask & TLS_GD
7881 ? 2 * sizeof (Elf64_External_Rela)
7882 : sizeof (Elf64_External_Rela));
7883 }
7884 else
7885 gent->got.offset = (bfd_vma) -1;
7886
7887 if (eh->dyn_relocs == NULL
7888 || !htab->elf.dynamic_sections_created)
7889 return TRUE;
7890
7891 /* In the shared -Bsymbolic case, discard space allocated for
7892 dynamic pc-relative relocs against symbols which turn out to be
7893 defined in regular objects. For the normal shared case, discard
7894 space for relocs that have become local due to symbol visibility
7895 changes. */
7896
7897 if (info->shared)
7898 {
7899 /* Relocs that use pc_count are those that appear on a call insn,
7900 or certain REL relocs (see must_be_dyn_reloc) that can be
7901 generated via assembly. We want calls to protected symbols to
7902 resolve directly to the function rather than going via the plt.
7903 If people want function pointer comparisons to work as expected
7904 then they should avoid writing weird assembly. */
7905 if (SYMBOL_CALLS_LOCAL (info, h))
7906 {
7907 struct ppc_dyn_relocs **pp;
7908
7909 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
7910 {
7911 p->count -= p->pc_count;
7912 p->pc_count = 0;
7913 if (p->count == 0)
7914 *pp = p->next;
7915 else
7916 pp = &p->next;
7917 }
7918 }
7919
7920 /* Also discard relocs on undefined weak syms with non-default
7921 visibility. */
7922 if (eh->dyn_relocs != NULL
7923 && h->root.type == bfd_link_hash_undefweak)
7924 {
7925 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
7926 eh->dyn_relocs = NULL;
7927
7928 /* Make sure this symbol is output as a dynamic symbol.
7929 Undefined weak syms won't yet be marked as dynamic. */
7930 else if (h->dynindx == -1
7931 && !h->forced_local)
7932 {
7933 if (! bfd_elf_link_record_dynamic_symbol (info, h))
7934 return FALSE;
7935 }
7936 }
7937 }
7938 else if (ELIMINATE_COPY_RELOCS)
7939 {
7940 /* For the non-shared case, discard space for relocs against
7941 symbols which turn out to need copy relocs or are not
7942 dynamic. */
7943
7944 if (!h->non_got_ref
7945 && !h->def_regular)
7946 {
7947 /* Make sure this symbol is output as a dynamic symbol.
7948 Undefined weak syms won't yet be marked as dynamic. */
7949 if (h->dynindx == -1
7950 && !h->forced_local)
7951 {
7952 if (! bfd_elf_link_record_dynamic_symbol (info, h))
7953 return FALSE;
7954 }
7955
7956 /* If that succeeded, we know we'll be keeping all the
7957 relocs. */
7958 if (h->dynindx != -1)
7959 goto keep;
7960 }
7961
7962 eh->dyn_relocs = NULL;
7963
7964 keep: ;
7965 }
7966
7967 /* Finally, allocate space. */
7968 for (p = eh->dyn_relocs; p != NULL; p = p->next)
7969 {
7970 asection *sreloc = elf_section_data (p->sec)->sreloc;
7971 sreloc->size += p->count * sizeof (Elf64_External_Rela);
7972 }
7973
7974 return TRUE;
7975 }
7976
7977 /* Find any dynamic relocs that apply to read-only sections. */
7978
7979 static bfd_boolean
7980 readonly_dynrelocs (struct elf_link_hash_entry *h, void *inf)
7981 {
7982 struct ppc_link_hash_entry *eh;
7983 struct ppc_dyn_relocs *p;
7984
7985 if (h->root.type == bfd_link_hash_warning)
7986 h = (struct elf_link_hash_entry *) h->root.u.i.link;
7987
7988 eh = (struct ppc_link_hash_entry *) h;
7989 for (p = eh->dyn_relocs; p != NULL; p = p->next)
7990 {
7991 asection *s = p->sec->output_section;
7992
7993 if (s != NULL && (s->flags & SEC_READONLY) != 0)
7994 {
7995 struct bfd_link_info *info = inf;
7996
7997 info->flags |= DF_TEXTREL;
7998
7999 /* Not an error, just cut short the traversal. */
8000 return FALSE;
8001 }
8002 }
8003 return TRUE;
8004 }
8005
8006 /* Set the sizes of the dynamic sections. */
8007
8008 static bfd_boolean
8009 ppc64_elf_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
8010 struct bfd_link_info *info)
8011 {
8012 struct ppc_link_hash_table *htab;
8013 bfd *dynobj;
8014 asection *s;
8015 bfd_boolean relocs;
8016 bfd *ibfd;
8017
8018 htab = ppc_hash_table (info);
8019 dynobj = htab->elf.dynobj;
8020 if (dynobj == NULL)
8021 abort ();
8022
8023 if (htab->elf.dynamic_sections_created)
8024 {
8025 /* Set the contents of the .interp section to the interpreter. */
8026 if (info->executable)
8027 {
8028 s = bfd_get_section_by_name (dynobj, ".interp");
8029 if (s == NULL)
8030 abort ();
8031 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
8032 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
8033 }
8034 }
8035
8036 /* Set up .got offsets for local syms, and space for local dynamic
8037 relocs. */
8038 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
8039 {
8040 struct got_entry **lgot_ents;
8041 struct got_entry **end_lgot_ents;
8042 char *lgot_masks;
8043 bfd_size_type locsymcount;
8044 Elf_Internal_Shdr *symtab_hdr;
8045 asection *srel;
8046
8047 if (!is_ppc64_elf (ibfd))
8048 continue;
8049
8050 for (s = ibfd->sections; s != NULL; s = s->next)
8051 {
8052 struct ppc_dyn_relocs *p;
8053
8054 for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
8055 {
8056 if (!bfd_is_abs_section (p->sec)
8057 && bfd_is_abs_section (p->sec->output_section))
8058 {
8059 /* Input section has been discarded, either because
8060 it is a copy of a linkonce section or due to
8061 linker script /DISCARD/, so we'll be discarding
8062 the relocs too. */
8063 }
8064 else if (p->count != 0)
8065 {
8066 srel = elf_section_data (p->sec)->sreloc;
8067 srel->size += p->count * sizeof (Elf64_External_Rela);
8068 if ((p->sec->output_section->flags & SEC_READONLY) != 0)
8069 info->flags |= DF_TEXTREL;
8070 }
8071 }
8072 }
8073
8074 lgot_ents = elf_local_got_ents (ibfd);
8075 if (!lgot_ents)
8076 continue;
8077
8078 symtab_hdr = &elf_symtab_hdr (ibfd);
8079 locsymcount = symtab_hdr->sh_info;
8080 end_lgot_ents = lgot_ents + locsymcount;
8081 lgot_masks = (char *) end_lgot_ents;
8082 s = ppc64_elf_tdata (ibfd)->got;
8083 srel = ppc64_elf_tdata (ibfd)->relgot;
8084 for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
8085 {
8086 struct got_entry *ent;
8087
8088 for (ent = *lgot_ents; ent != NULL; ent = ent->next)
8089 if (ent->got.refcount > 0)
8090 {
8091 if ((ent->tls_type & *lgot_masks & TLS_LD) != 0)
8092 {
8093 ppc64_tlsld_got (ibfd)->refcount += 1;
8094 ent->got.offset = (bfd_vma) -1;
8095 }
8096 else
8097 {
8098 ent->got.offset = s->size;
8099 if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
8100 {
8101 s->size += 16;
8102 if (info->shared)
8103 srel->size += 2 * sizeof (Elf64_External_Rela);
8104 }
8105 else
8106 {
8107 s->size += 8;
8108 if (info->shared)
8109 srel->size += sizeof (Elf64_External_Rela);
8110 }
8111 }
8112 }
8113 else
8114 ent->got.offset = (bfd_vma) -1;
8115 }
8116 }
8117
8118 /* Allocate global sym .plt and .got entries, and space for global
8119 sym dynamic relocs. */
8120 elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, info);
8121
8122 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
8123 {
8124 if (!is_ppc64_elf (ibfd))
8125 continue;
8126
8127 if (ppc64_tlsld_got (ibfd)->refcount > 0)
8128 {
8129 s = ppc64_elf_tdata (ibfd)->got;
8130 ppc64_tlsld_got (ibfd)->offset = s->size;
8131 s->size += 16;
8132 if (info->shared)
8133 {
8134 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
8135 srel->size += sizeof (Elf64_External_Rela);
8136 }
8137 }
8138 else
8139 ppc64_tlsld_got (ibfd)->offset = (bfd_vma) -1;
8140 }
8141
8142 /* We now have determined the sizes of the various dynamic sections.
8143 Allocate memory for them. */
8144 relocs = FALSE;
8145 for (s = dynobj->sections; s != NULL; s = s->next)
8146 {
8147 if ((s->flags & SEC_LINKER_CREATED) == 0)
8148 continue;
8149
8150 if (s == htab->brlt || s == htab->relbrlt)
8151 /* These haven't been allocated yet; don't strip. */
8152 continue;
8153 else if (s == htab->got
8154 || s == htab->plt
8155 || s == htab->glink
8156 || s == htab->dynbss)
8157 {
8158 /* Strip this section if we don't need it; see the
8159 comment below. */
8160 }
8161 else if (CONST_STRNEQ (bfd_get_section_name (dynobj, s), ".rela"))
8162 {
8163 if (s->size != 0)
8164 {
8165 if (s != htab->relplt)
8166 relocs = TRUE;
8167
8168 /* We use the reloc_count field as a counter if we need
8169 to copy relocs into the output file. */
8170 s->reloc_count = 0;
8171 }
8172 }
8173 else
8174 {
8175 /* It's not one of our sections, so don't allocate space. */
8176 continue;
8177 }
8178
8179 if (s->size == 0)
8180 {
8181 /* If we don't need this section, strip it from the
8182 output file. This is mostly to handle .rela.bss and
8183 .rela.plt. We must create both sections in
8184 create_dynamic_sections, because they must be created
8185 before the linker maps input sections to output
8186 sections. The linker does that before
8187 adjust_dynamic_symbol is called, and it is that
8188 function which decides whether anything needs to go
8189 into these sections. */
8190 s->flags |= SEC_EXCLUDE;
8191 continue;
8192 }
8193
8194 if ((s->flags & SEC_HAS_CONTENTS) == 0)
8195 continue;
8196
8197 /* Allocate memory for the section contents. We use bfd_zalloc
8198 here in case unused entries are not reclaimed before the
8199 section's contents are written out. This should not happen,
8200 but this way if it does we get a R_PPC64_NONE reloc in .rela
8201 sections instead of garbage.
8202 We also rely on the section contents being zero when writing
8203 the GOT. */
8204 s->contents = bfd_zalloc (dynobj, s->size);
8205 if (s->contents == NULL)
8206 return FALSE;
8207 }
8208
8209 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
8210 {
8211 if (!is_ppc64_elf (ibfd))
8212 continue;
8213
8214 s = ppc64_elf_tdata (ibfd)->got;
8215 if (s != NULL && s != htab->got)
8216 {
8217 if (s->size == 0)
8218 s->flags |= SEC_EXCLUDE;
8219 else
8220 {
8221 s->contents = bfd_zalloc (ibfd, s->size);
8222 if (s->contents == NULL)
8223 return FALSE;
8224 }
8225 }
8226 s = ppc64_elf_tdata (ibfd)->relgot;
8227 if (s != NULL)
8228 {
8229 if (s->size == 0)
8230 s->flags |= SEC_EXCLUDE;
8231 else
8232 {
8233 s->contents = bfd_zalloc (ibfd, s->size);
8234 if (s->contents == NULL)
8235 return FALSE;
8236 relocs = TRUE;
8237 s->reloc_count = 0;
8238 }
8239 }
8240 }
8241
8242 if (htab->elf.dynamic_sections_created)
8243 {
8244 /* Add some entries to the .dynamic section. We fill in the
8245 values later, in ppc64_elf_finish_dynamic_sections, but we
8246 must add the entries now so that we get the correct size for
8247 the .dynamic section. The DT_DEBUG entry is filled in by the
8248 dynamic linker and used by the debugger. */
8249 #define add_dynamic_entry(TAG, VAL) \
8250 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
8251
8252 if (info->executable)
8253 {
8254 if (!add_dynamic_entry (DT_DEBUG, 0))
8255 return FALSE;
8256 }
8257
8258 if (htab->plt != NULL && htab->plt->size != 0)
8259 {
8260 if (!add_dynamic_entry (DT_PLTGOT, 0)
8261 || !add_dynamic_entry (DT_PLTRELSZ, 0)
8262 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
8263 || !add_dynamic_entry (DT_JMPREL, 0)
8264 || !add_dynamic_entry (DT_PPC64_GLINK, 0))
8265 return FALSE;
8266 }
8267
8268 if (NO_OPD_RELOCS)
8269 {
8270 if (!add_dynamic_entry (DT_PPC64_OPD, 0)
8271 || !add_dynamic_entry (DT_PPC64_OPDSZ, 0))
8272 return FALSE;
8273 }
8274
8275 if (relocs)
8276 {
8277 if (!add_dynamic_entry (DT_RELA, 0)
8278 || !add_dynamic_entry (DT_RELASZ, 0)
8279 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
8280 return FALSE;
8281
8282 /* If any dynamic relocs apply to a read-only section,
8283 then we need a DT_TEXTREL entry. */
8284 if ((info->flags & DF_TEXTREL) == 0)
8285 elf_link_hash_traverse (&htab->elf, readonly_dynrelocs, info);
8286
8287 if ((info->flags & DF_TEXTREL) != 0)
8288 {
8289 if (!add_dynamic_entry (DT_TEXTREL, 0))
8290 return FALSE;
8291 }
8292 }
8293 }
8294 #undef add_dynamic_entry
8295
8296 return TRUE;
8297 }
8298
8299 /* Determine the type of stub needed, if any, for a call. */
8300
8301 static inline enum ppc_stub_type
8302 ppc_type_of_stub (asection *input_sec,
8303 const Elf_Internal_Rela *rel,
8304 struct ppc_link_hash_entry **hash,
8305 bfd_vma destination)
8306 {
8307 struct ppc_link_hash_entry *h = *hash;
8308 bfd_vma location;
8309 bfd_vma branch_offset;
8310 bfd_vma max_branch_offset;
8311 enum elf_ppc64_reloc_type r_type;
8312
8313 if (h != NULL)
8314 {
8315 struct ppc_link_hash_entry *fdh = h;
8316 if (fdh->oh != NULL
8317 && fdh->oh->is_func_descriptor)
8318 fdh = fdh->oh;
8319
8320 if (fdh->elf.dynindx != -1)
8321 {
8322 struct plt_entry *ent;
8323
8324 for (ent = fdh->elf.plt.plist; ent != NULL; ent = ent->next)
8325 if (ent->addend == rel->r_addend
8326 && ent->plt.offset != (bfd_vma) -1)
8327 {
8328 *hash = fdh;
8329 return ppc_stub_plt_call;
8330 }
8331 }
8332
8333 /* Here, we know we don't have a plt entry. If we don't have a
8334 either a defined function descriptor or a defined entry symbol
8335 in a regular object file, then it is pointless trying to make
8336 any other type of stub. */
8337 if (!((fdh->elf.root.type == bfd_link_hash_defined
8338 || fdh->elf.root.type == bfd_link_hash_defweak)
8339 && fdh->elf.root.u.def.section->output_section != NULL)
8340 && !((h->elf.root.type == bfd_link_hash_defined
8341 || h->elf.root.type == bfd_link_hash_defweak)
8342 && h->elf.root.u.def.section->output_section != NULL))
8343 return ppc_stub_none;
8344 }
8345
8346 /* Determine where the call point is. */
8347 location = (input_sec->output_offset
8348 + input_sec->output_section->vma
8349 + rel->r_offset);
8350
8351 branch_offset = destination - location;
8352 r_type = ELF64_R_TYPE (rel->r_info);
8353
8354 /* Determine if a long branch stub is needed. */
8355 max_branch_offset = 1 << 25;
8356 if (r_type != R_PPC64_REL24)
8357 max_branch_offset = 1 << 15;
8358
8359 if (branch_offset + max_branch_offset >= 2 * max_branch_offset)
8360 /* We need a stub. Figure out whether a long_branch or plt_branch
8361 is needed later. */
8362 return ppc_stub_long_branch;
8363
8364 return ppc_stub_none;
8365 }
8366
8367 /* Build a .plt call stub. */
8368
8369 static inline bfd_byte *
8370 build_plt_stub (bfd *obfd, bfd_byte *p, int offset, Elf_Internal_Rela *r)
8371 {
8372 #define PPC_LO(v) ((v) & 0xffff)
8373 #define PPC_HI(v) (((v) >> 16) & 0xffff)
8374 #define PPC_HA(v) PPC_HI ((v) + 0x8000)
8375
8376 if (PPC_HA (offset) != 0)
8377 {
8378 if (r != NULL)
8379 {
8380 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
8381 r[1].r_offset = r[0].r_offset + 8;
8382 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
8383 r[1].r_addend = r[0].r_addend;
8384 if (PPC_HA (offset + 16) != PPC_HA (offset))
8385 {
8386 r[2].r_offset = r[1].r_offset + 4;
8387 r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO);
8388 r[2].r_addend = r[0].r_addend;
8389 }
8390 else
8391 {
8392 r[2].r_offset = r[1].r_offset + 8;
8393 r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
8394 r[2].r_addend = r[0].r_addend + 8;
8395 r[3].r_offset = r[2].r_offset + 4;
8396 r[3].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
8397 r[3].r_addend = r[0].r_addend + 16;
8398 }
8399 }
8400 bfd_put_32 (obfd, ADDIS_R12_R2 | PPC_HA (offset), p), p += 4;
8401 bfd_put_32 (obfd, STD_R2_40R1, p), p += 4;
8402 bfd_put_32 (obfd, LD_R11_0R12 | PPC_LO (offset), p), p += 4;
8403 if (PPC_HA (offset + 16) != PPC_HA (offset))
8404 {
8405 bfd_put_32 (obfd, ADDI_R12_R12 | PPC_LO (offset), p), p += 4;
8406 offset = 0;
8407 }
8408 bfd_put_32 (obfd, MTCTR_R11, p), p += 4;
8409 bfd_put_32 (obfd, LD_R2_0R12 | PPC_LO (offset + 8), p), p += 4;
8410 bfd_put_32 (obfd, LD_R11_0R12 | PPC_LO (offset + 16), p), p += 4;
8411 bfd_put_32 (obfd, BCTR, p), p += 4;
8412 }
8413 else
8414 {
8415 if (r != NULL)
8416 {
8417 r[0].r_offset += 4;
8418 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
8419 if (PPC_HA (offset + 16) != PPC_HA (offset))
8420 {
8421 r[1].r_offset = r[0].r_offset + 4;
8422 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16);
8423 r[1].r_addend = r[0].r_addend;
8424 }
8425 else
8426 {
8427 r[1].r_offset = r[0].r_offset + 8;
8428 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
8429 r[1].r_addend = r[0].r_addend + 16;
8430 r[2].r_offset = r[1].r_offset + 4;
8431 r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
8432 r[2].r_addend = r[0].r_addend + 8;
8433 }
8434 }
8435 bfd_put_32 (obfd, STD_R2_40R1, p), p += 4;
8436 bfd_put_32 (obfd, LD_R11_0R2 | PPC_LO (offset), p), p += 4;
8437 if (PPC_HA (offset + 16) != PPC_HA (offset))
8438 {
8439 bfd_put_32 (obfd, ADDI_R2_R2 | PPC_LO (offset), p), p += 4;
8440 offset = 0;
8441 }
8442 bfd_put_32 (obfd, MTCTR_R11, p), p += 4;
8443 bfd_put_32 (obfd, LD_R11_0R2 | PPC_LO (offset + 16), p), p += 4;
8444 bfd_put_32 (obfd, LD_R2_0R2 | PPC_LO (offset + 8), p), p += 4;
8445 bfd_put_32 (obfd, BCTR, p), p += 4;
8446 }
8447 return p;
8448 }
8449
8450 static Elf_Internal_Rela *
8451 get_relocs (asection *sec, int count)
8452 {
8453 Elf_Internal_Rela *relocs;
8454 struct bfd_elf_section_data *elfsec_data;
8455
8456 elfsec_data = elf_section_data (sec);
8457 relocs = elfsec_data->relocs;
8458 if (relocs == NULL)
8459 {
8460 bfd_size_type relsize;
8461 relsize = sec->reloc_count * sizeof (*relocs);
8462 relocs = bfd_alloc (sec->owner, relsize);
8463 if (relocs == NULL)
8464 return NULL;
8465 elfsec_data->relocs = relocs;
8466 elfsec_data->rel_hdr.sh_size = (sec->reloc_count
8467 * sizeof (Elf64_External_Rela));
8468 elfsec_data->rel_hdr.sh_entsize = sizeof (Elf64_External_Rela);
8469 sec->reloc_count = 0;
8470 }
8471 relocs += sec->reloc_count;
8472 sec->reloc_count += count;
8473 return relocs;
8474 }
8475
8476 static bfd_boolean
8477 ppc_build_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
8478 {
8479 struct ppc_stub_hash_entry *stub_entry;
8480 struct ppc_branch_hash_entry *br_entry;
8481 struct bfd_link_info *info;
8482 struct ppc_link_hash_table *htab;
8483 bfd_byte *loc;
8484 bfd_byte *p;
8485 struct plt_entry *ent;
8486 bfd_vma dest, off;
8487 int size;
8488 Elf_Internal_Rela *r;
8489
8490 /* Massage our args to the form they really have. */
8491 stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
8492 info = in_arg;
8493
8494 htab = ppc_hash_table (info);
8495
8496 /* Make a note of the offset within the stubs for this entry. */
8497 stub_entry->stub_offset = stub_entry->stub_sec->size;
8498 loc = stub_entry->stub_sec->contents + stub_entry->stub_offset;
8499
8500 htab->stub_count[stub_entry->stub_type - 1] += 1;
8501 switch (stub_entry->stub_type)
8502 {
8503 case ppc_stub_long_branch:
8504 case ppc_stub_long_branch_r2off:
8505 /* Branches are relative. This is where we are going to. */
8506 off = dest = (stub_entry->target_value
8507 + stub_entry->target_section->output_offset
8508 + stub_entry->target_section->output_section->vma);
8509
8510 /* And this is where we are coming from. */
8511 off -= (stub_entry->stub_offset
8512 + stub_entry->stub_sec->output_offset
8513 + stub_entry->stub_sec->output_section->vma);
8514
8515 size = 4;
8516 if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
8517 {
8518 bfd_vma r2off;
8519
8520 r2off = (htab->stub_group[stub_entry->target_section->id].toc_off
8521 - htab->stub_group[stub_entry->id_sec->id].toc_off);
8522 bfd_put_32 (htab->stub_bfd, STD_R2_40R1, loc);
8523 loc += 4;
8524 size = 12;
8525 if (PPC_HA (r2off) != 0)
8526 {
8527 size = 16;
8528 bfd_put_32 (htab->stub_bfd, ADDIS_R2_R2 | PPC_HA (r2off), loc);
8529 loc += 4;
8530 }
8531 bfd_put_32 (htab->stub_bfd, ADDI_R2_R2 | PPC_LO (r2off), loc);
8532 loc += 4;
8533 off -= size - 4;
8534 }
8535 bfd_put_32 (htab->stub_bfd, B_DOT | (off & 0x3fffffc), loc);
8536
8537 if (off + (1 << 25) >= (bfd_vma) (1 << 26))
8538 {
8539 (*_bfd_error_handler) (_("long branch stub `%s' offset overflow"),
8540 stub_entry->root.string);
8541 htab->stub_error = TRUE;
8542 return FALSE;
8543 }
8544
8545 if (info->emitrelocations)
8546 {
8547 r = get_relocs (stub_entry->stub_sec, 1);
8548 if (r == NULL)
8549 return FALSE;
8550 r->r_offset = loc - stub_entry->stub_sec->contents;
8551 r->r_info = ELF64_R_INFO (0, R_PPC64_REL24);
8552 r->r_addend = dest;
8553 if (stub_entry->h != NULL)
8554 {
8555 struct elf_link_hash_entry **hashes;
8556 unsigned long symndx;
8557 struct ppc_link_hash_entry *h;
8558
8559 hashes = elf_sym_hashes (htab->stub_bfd);
8560 if (hashes == NULL)
8561 {
8562 bfd_size_type hsize;
8563
8564 hsize = (htab->stub_globals + 1) * sizeof (*hashes);
8565 hashes = bfd_zalloc (htab->stub_bfd, hsize);
8566 if (hashes == NULL)
8567 return FALSE;
8568 elf_sym_hashes (htab->stub_bfd) = hashes;
8569 htab->stub_globals = 1;
8570 }
8571 symndx = htab->stub_globals++;
8572 h = stub_entry->h;
8573 hashes[symndx] = &h->elf;
8574 r->r_info = ELF64_R_INFO (symndx, R_PPC64_REL24);
8575 if (h->oh != NULL && h->oh->is_func)
8576 h = h->oh;
8577 if (h->elf.root.u.def.section != stub_entry->target_section)
8578 /* H is an opd symbol. The addend must be zero. */
8579 r->r_addend = 0;
8580 else
8581 {
8582 off = (h->elf.root.u.def.value
8583 + h->elf.root.u.def.section->output_offset
8584 + h->elf.root.u.def.section->output_section->vma);
8585 r->r_addend -= off;
8586 }
8587 }
8588 }
8589 break;
8590
8591 case ppc_stub_plt_branch:
8592 case ppc_stub_plt_branch_r2off:
8593 br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
8594 stub_entry->root.string + 9,
8595 FALSE, FALSE);
8596 if (br_entry == NULL)
8597 {
8598 (*_bfd_error_handler) (_("can't find branch stub `%s'"),
8599 stub_entry->root.string);
8600 htab->stub_error = TRUE;
8601 return FALSE;
8602 }
8603
8604 dest = (stub_entry->target_value
8605 + stub_entry->target_section->output_offset
8606 + stub_entry->target_section->output_section->vma);
8607
8608 bfd_put_64 (htab->brlt->owner, dest,
8609 htab->brlt->contents + br_entry->offset);
8610
8611 if (br_entry->iter == htab->stub_iteration)
8612 {
8613 br_entry->iter = 0;
8614
8615 if (htab->relbrlt != NULL)
8616 {
8617 /* Create a reloc for the branch lookup table entry. */
8618 Elf_Internal_Rela rela;
8619 bfd_byte *rl;
8620
8621 rela.r_offset = (br_entry->offset
8622 + htab->brlt->output_offset
8623 + htab->brlt->output_section->vma);
8624 rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
8625 rela.r_addend = dest;
8626
8627 rl = htab->relbrlt->contents;
8628 rl += (htab->relbrlt->reloc_count++
8629 * sizeof (Elf64_External_Rela));
8630 bfd_elf64_swap_reloca_out (htab->relbrlt->owner, &rela, rl);
8631 }
8632 else if (info->emitrelocations)
8633 {
8634 r = get_relocs (htab->brlt, 1);
8635 if (r == NULL)
8636 return FALSE;
8637 /* brlt, being SEC_LINKER_CREATED does not go through the
8638 normal reloc processing. Symbols and offsets are not
8639 translated from input file to output file form, so
8640 set up the offset per the output file. */
8641 r->r_offset = (br_entry->offset
8642 + htab->brlt->output_offset
8643 + htab->brlt->output_section->vma);
8644 r->r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
8645 r->r_addend = dest;
8646 }
8647 }
8648
8649 dest = (br_entry->offset
8650 + htab->brlt->output_offset
8651 + htab->brlt->output_section->vma);
8652
8653 off = (dest
8654 - elf_gp (htab->brlt->output_section->owner)
8655 - htab->stub_group[stub_entry->id_sec->id].toc_off);
8656
8657 if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
8658 {
8659 (*_bfd_error_handler)
8660 (_("linkage table error against `%s'"),
8661 stub_entry->root.string);
8662 bfd_set_error (bfd_error_bad_value);
8663 htab->stub_error = TRUE;
8664 return FALSE;
8665 }
8666
8667 if (info->emitrelocations)
8668 {
8669 r = get_relocs (stub_entry->stub_sec, 1 + (PPC_HA (off) != 0));
8670 if (r == NULL)
8671 return FALSE;
8672 r[0].r_offset = loc - stub_entry->stub_sec->contents;
8673 if (bfd_big_endian (info->output_bfd))
8674 r[0].r_offset += 2;
8675 if (stub_entry->stub_type == ppc_stub_plt_branch_r2off)
8676 r[0].r_offset += 4;
8677 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
8678 r[0].r_addend = dest;
8679 if (PPC_HA (off) != 0)
8680 {
8681 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
8682 r[1].r_offset = r[0].r_offset + 4;
8683 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
8684 r[1].r_addend = r[0].r_addend;
8685 }
8686 }
8687
8688 if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
8689 {
8690 if (PPC_HA (off) != 0)
8691 {
8692 size = 16;
8693 bfd_put_32 (htab->stub_bfd, ADDIS_R12_R2 | PPC_HA (off), loc);
8694 loc += 4;
8695 bfd_put_32 (htab->stub_bfd, LD_R11_0R12 | PPC_LO (off), loc);
8696 }
8697 else
8698 {
8699 size = 12;
8700 bfd_put_32 (htab->stub_bfd, LD_R11_0R2 | PPC_LO (off), loc);
8701 }
8702 }
8703 else
8704 {
8705 bfd_vma r2off;
8706
8707 r2off = (htab->stub_group[stub_entry->target_section->id].toc_off
8708 - htab->stub_group[stub_entry->id_sec->id].toc_off);
8709 bfd_put_32 (htab->stub_bfd, STD_R2_40R1, loc);
8710 loc += 4;
8711 size = 20;
8712 if (PPC_HA (off) != 0)
8713 {
8714 size += 4;
8715 bfd_put_32 (htab->stub_bfd, ADDIS_R12_R2 | PPC_HA (off), loc);
8716 loc += 4;
8717 bfd_put_32 (htab->stub_bfd, LD_R11_0R12 | PPC_LO (off), loc);
8718 loc += 4;
8719 }
8720 else
8721 {
8722 bfd_put_32 (htab->stub_bfd, LD_R11_0R2 | PPC_LO (off), loc);
8723 loc += 4;
8724 }
8725
8726 if (PPC_HA (r2off) != 0)
8727 {
8728 size += 4;
8729 bfd_put_32 (htab->stub_bfd, ADDIS_R2_R2 | PPC_HA (r2off), loc);
8730 loc += 4;
8731 }
8732 bfd_put_32 (htab->stub_bfd, ADDI_R2_R2 | PPC_LO (r2off), loc);
8733 }
8734 loc += 4;
8735 bfd_put_32 (htab->stub_bfd, MTCTR_R11, loc);
8736 loc += 4;
8737 bfd_put_32 (htab->stub_bfd, BCTR, loc);
8738 break;
8739
8740 case ppc_stub_plt_call:
8741 /* Do the best we can for shared libraries built without
8742 exporting ".foo" for each "foo". This can happen when symbol
8743 versioning scripts strip all bar a subset of symbols. */
8744 if (stub_entry->h->oh != NULL
8745 && stub_entry->h->oh->elf.root.type != bfd_link_hash_defined
8746 && stub_entry->h->oh->elf.root.type != bfd_link_hash_defweak)
8747 {
8748 /* Point the symbol at the stub. There may be multiple stubs,
8749 we don't really care; The main thing is to make this sym
8750 defined somewhere. Maybe defining the symbol in the stub
8751 section is a silly idea. If we didn't do this, htab->top_id
8752 could disappear. */
8753 stub_entry->h->oh->elf.root.type = bfd_link_hash_defined;
8754 stub_entry->h->oh->elf.root.u.def.section = stub_entry->stub_sec;
8755 stub_entry->h->oh->elf.root.u.def.value = stub_entry->stub_offset;
8756 }
8757
8758 /* Now build the stub. */
8759 dest = (bfd_vma) -1;
8760 for (ent = stub_entry->h->elf.plt.plist; ent != NULL; ent = ent->next)
8761 if (ent->addend == stub_entry->addend)
8762 {
8763 dest = ent->plt.offset;
8764 break;
8765 }
8766 if (dest >= (bfd_vma) -2)
8767 abort ();
8768
8769 dest &= ~ (bfd_vma) 1;
8770 dest += (htab->plt->output_offset
8771 + htab->plt->output_section->vma);
8772
8773 off = (dest
8774 - elf_gp (htab->plt->output_section->owner)
8775 - htab->stub_group[stub_entry->id_sec->id].toc_off);
8776
8777 if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
8778 {
8779 (*_bfd_error_handler)
8780 (_("linkage table error against `%s'"),
8781 stub_entry->h->elf.root.root.string);
8782 bfd_set_error (bfd_error_bad_value);
8783 htab->stub_error = TRUE;
8784 return FALSE;
8785 }
8786
8787 r = NULL;
8788 if (info->emitrelocations)
8789 {
8790 r = get_relocs (stub_entry->stub_sec,
8791 (2 + (PPC_HA (off) != 0)
8792 + (PPC_HA (off + 16) == PPC_HA (off))));
8793 if (r == NULL)
8794 return FALSE;
8795 r[0].r_offset = loc - stub_entry->stub_sec->contents;
8796 if (bfd_big_endian (info->output_bfd))
8797 r[0].r_offset += 2;
8798 r[0].r_addend = dest;
8799 }
8800 p = build_plt_stub (htab->stub_bfd, loc, off, r);
8801 size = p - loc;
8802 break;
8803
8804 default:
8805 BFD_FAIL ();
8806 return FALSE;
8807 }
8808
8809 stub_entry->stub_sec->size += size;
8810
8811 if (htab->emit_stub_syms)
8812 {
8813 struct elf_link_hash_entry *h;
8814 size_t len1, len2;
8815 char *name;
8816 const char *const stub_str[] = { "long_branch",
8817 "long_branch_r2off",
8818 "plt_branch",
8819 "plt_branch_r2off",
8820 "plt_call" };
8821
8822 len1 = strlen (stub_str[stub_entry->stub_type - 1]);
8823 len2 = strlen (stub_entry->root.string);
8824 name = bfd_malloc (len1 + len2 + 2);
8825 if (name == NULL)
8826 return FALSE;
8827 memcpy (name, stub_entry->root.string, 9);
8828 memcpy (name + 9, stub_str[stub_entry->stub_type - 1], len1);
8829 memcpy (name + len1 + 9, stub_entry->root.string + 8, len2 - 8 + 1);
8830 h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
8831 if (h == NULL)
8832 return FALSE;
8833 if (h->root.type == bfd_link_hash_new)
8834 {
8835 h->root.type = bfd_link_hash_defined;
8836 h->root.u.def.section = stub_entry->stub_sec;
8837 h->root.u.def.value = stub_entry->stub_offset;
8838 h->ref_regular = 1;
8839 h->def_regular = 1;
8840 h->ref_regular_nonweak = 1;
8841 h->forced_local = 1;
8842 h->non_elf = 0;
8843 }
8844 }
8845
8846 return TRUE;
8847 }
8848
8849 /* As above, but don't actually build the stub. Just bump offset so
8850 we know stub section sizes, and select plt_branch stubs where
8851 long_branch stubs won't do. */
8852
8853 static bfd_boolean
8854 ppc_size_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
8855 {
8856 struct ppc_stub_hash_entry *stub_entry;
8857 struct bfd_link_info *info;
8858 struct ppc_link_hash_table *htab;
8859 bfd_vma off;
8860 int size;
8861
8862 /* Massage our args to the form they really have. */
8863 stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
8864 info = in_arg;
8865
8866 htab = ppc_hash_table (info);
8867
8868 if (stub_entry->stub_type == ppc_stub_plt_call)
8869 {
8870 struct plt_entry *ent;
8871 off = (bfd_vma) -1;
8872 for (ent = stub_entry->h->elf.plt.plist; ent != NULL; ent = ent->next)
8873 if (ent->addend == stub_entry->addend)
8874 {
8875 off = ent->plt.offset & ~(bfd_vma) 1;
8876 break;
8877 }
8878 if (off >= (bfd_vma) -2)
8879 abort ();
8880 off += (htab->plt->output_offset
8881 + htab->plt->output_section->vma
8882 - elf_gp (htab->plt->output_section->owner)
8883 - htab->stub_group[stub_entry->id_sec->id].toc_off);
8884
8885 size = PLT_CALL_STUB_SIZE;
8886 if (PPC_HA (off) == 0)
8887 size -= 4;
8888 if (PPC_HA (off + 16) != PPC_HA (off))
8889 size += 4;
8890 if (info->emitrelocations)
8891 {
8892 stub_entry->stub_sec->reloc_count
8893 += 2 + (PPC_HA (off) != 0) + (PPC_HA (off + 16) == PPC_HA (off));
8894 stub_entry->stub_sec->flags |= SEC_RELOC;
8895 }
8896 }
8897 else
8898 {
8899 /* ppc_stub_long_branch or ppc_stub_plt_branch, or their r2off
8900 variants. */
8901 bfd_vma r2off = 0;
8902
8903 off = (stub_entry->target_value
8904 + stub_entry->target_section->output_offset
8905 + stub_entry->target_section->output_section->vma);
8906 off -= (stub_entry->stub_sec->size
8907 + stub_entry->stub_sec->output_offset
8908 + stub_entry->stub_sec->output_section->vma);
8909
8910 /* Reset the stub type from the plt variant in case we now
8911 can reach with a shorter stub. */
8912 if (stub_entry->stub_type >= ppc_stub_plt_branch)
8913 stub_entry->stub_type += ppc_stub_long_branch - ppc_stub_plt_branch;
8914
8915 size = 4;
8916 if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
8917 {
8918 r2off = (htab->stub_group[stub_entry->target_section->id].toc_off
8919 - htab->stub_group[stub_entry->id_sec->id].toc_off);
8920 size = 12;
8921 if (PPC_HA (r2off) != 0)
8922 size = 16;
8923 off -= size - 4;
8924 }
8925
8926 /* If the branch offset if too big, use a ppc_stub_plt_branch. */
8927 if (off + (1 << 25) >= (bfd_vma) (1 << 26))
8928 {
8929 struct ppc_branch_hash_entry *br_entry;
8930
8931 br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
8932 stub_entry->root.string + 9,
8933 TRUE, FALSE);
8934 if (br_entry == NULL)
8935 {
8936 (*_bfd_error_handler) (_("can't build branch stub `%s'"),
8937 stub_entry->root.string);
8938 htab->stub_error = TRUE;
8939 return FALSE;
8940 }
8941
8942 if (br_entry->iter != htab->stub_iteration)
8943 {
8944 br_entry->iter = htab->stub_iteration;
8945 br_entry->offset = htab->brlt->size;
8946 htab->brlt->size += 8;
8947
8948 if (htab->relbrlt != NULL)
8949 htab->relbrlt->size += sizeof (Elf64_External_Rela);
8950 else if (info->emitrelocations)
8951 {
8952 htab->brlt->reloc_count += 1;
8953 htab->brlt->flags |= SEC_RELOC;
8954 }
8955 }
8956
8957 stub_entry->stub_type += ppc_stub_plt_branch - ppc_stub_long_branch;
8958 off = (br_entry->offset
8959 + htab->brlt->output_offset
8960 + htab->brlt->output_section->vma
8961 - elf_gp (htab->brlt->output_section->owner)
8962 - htab->stub_group[stub_entry->id_sec->id].toc_off);
8963
8964 if (info->emitrelocations)
8965 {
8966 stub_entry->stub_sec->reloc_count += 1 + (PPC_HA (off) != 0);
8967 stub_entry->stub_sec->flags |= SEC_RELOC;
8968 }
8969
8970 if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
8971 {
8972 size = 12;
8973 if (PPC_HA (off) != 0)
8974 size = 16;
8975 }
8976 else
8977 {
8978 size = 20;
8979 if (PPC_HA (off) != 0)
8980 size += 4;
8981
8982 if (PPC_HA (r2off) != 0)
8983 size += 4;
8984 }
8985 }
8986 else if (info->emitrelocations)
8987 {
8988 stub_entry->stub_sec->reloc_count += 1;
8989 stub_entry->stub_sec->flags |= SEC_RELOC;
8990 }
8991 }
8992
8993 stub_entry->stub_sec->size += size;
8994 return TRUE;
8995 }
8996
8997 /* Set up various things so that we can make a list of input sections
8998 for each output section included in the link. Returns -1 on error,
8999 0 when no stubs will be needed, and 1 on success. */
9000
9001 int
9002 ppc64_elf_setup_section_lists (bfd *output_bfd,
9003 struct bfd_link_info *info,
9004 int no_multi_toc)
9005 {
9006 bfd *input_bfd;
9007 int top_id, top_index, id;
9008 asection *section;
9009 asection **input_list;
9010 bfd_size_type amt;
9011 struct ppc_link_hash_table *htab = ppc_hash_table (info);
9012
9013 htab->no_multi_toc = no_multi_toc;
9014
9015 if (htab->brlt == NULL)
9016 return 0;
9017
9018 /* Find the top input section id. */
9019 for (input_bfd = info->input_bfds, top_id = 3;
9020 input_bfd != NULL;
9021 input_bfd = input_bfd->link_next)
9022 {
9023 for (section = input_bfd->sections;
9024 section != NULL;
9025 section = section->next)
9026 {
9027 if (top_id < section->id)
9028 top_id = section->id;
9029 }
9030 }
9031
9032 htab->top_id = top_id;
9033 amt = sizeof (struct map_stub) * (top_id + 1);
9034 htab->stub_group = bfd_zmalloc (amt);
9035 if (htab->stub_group == NULL)
9036 return -1;
9037
9038 /* Set toc_off for com, und, abs and ind sections. */
9039 for (id = 0; id < 3; id++)
9040 htab->stub_group[id].toc_off = TOC_BASE_OFF;
9041
9042 elf_gp (output_bfd) = htab->toc_curr = ppc64_elf_toc (output_bfd);
9043
9044 /* We can't use output_bfd->section_count here to find the top output
9045 section index as some sections may have been removed, and
9046 strip_excluded_output_sections doesn't renumber the indices. */
9047 for (section = output_bfd->sections, top_index = 0;
9048 section != NULL;
9049 section = section->next)
9050 {
9051 if (top_index < section->index)
9052 top_index = section->index;
9053 }
9054
9055 htab->top_index = top_index;
9056 amt = sizeof (asection *) * (top_index + 1);
9057 input_list = bfd_zmalloc (amt);
9058 htab->input_list = input_list;
9059 if (input_list == NULL)
9060 return -1;
9061
9062 return 1;
9063 }
9064
9065 /* The linker repeatedly calls this function for each TOC input section
9066 and linker generated GOT section. Group input bfds such that the toc
9067 within a group is less than 64k in size. Will break with cute linker
9068 scripts that play games with dot in the output toc section. */
9069
9070 void
9071 ppc64_elf_next_toc_section (struct bfd_link_info *info, asection *isec)
9072 {
9073 struct ppc_link_hash_table *htab = ppc_hash_table (info);
9074
9075 if (!htab->no_multi_toc)
9076 {
9077 bfd_vma addr = isec->output_offset + isec->output_section->vma;
9078 bfd_vma off = addr - htab->toc_curr;
9079
9080 if (off + isec->size > 0x10000)
9081 htab->toc_curr = addr;
9082
9083 elf_gp (isec->owner) = (htab->toc_curr
9084 - elf_gp (isec->output_section->owner)
9085 + TOC_BASE_OFF);
9086 }
9087 }
9088
9089 /* Called after the last call to the above function. */
9090
9091 void
9092 ppc64_elf_reinit_toc (bfd *output_bfd, struct bfd_link_info *info)
9093 {
9094 struct ppc_link_hash_table *htab = ppc_hash_table (info);
9095
9096 htab->multi_toc_needed = htab->toc_curr != elf_gp (output_bfd);
9097
9098 /* toc_curr tracks the TOC offset used for code sections below in
9099 ppc64_elf_next_input_section. Start off at 0x8000. */
9100 htab->toc_curr = TOC_BASE_OFF;
9101 }
9102
9103 /* No toc references were found in ISEC. If the code in ISEC makes no
9104 calls, then there's no need to use toc adjusting stubs when branching
9105 into ISEC. Actually, indirect calls from ISEC are OK as they will
9106 load r2. Returns -1 on error, 0 for no stub needed, 1 for stub
9107 needed, and 2 if a cyclical call-graph was found but no other reason
9108 for a stub was detected. If called from the top level, a return of
9109 2 means the same as a return of 0. */
9110
9111 static int
9112 toc_adjusting_stub_needed (struct bfd_link_info *info, asection *isec)
9113 {
9114 Elf_Internal_Rela *relstart, *rel;
9115 Elf_Internal_Sym *local_syms;
9116 int ret;
9117 struct ppc_link_hash_table *htab;
9118
9119 /* We know none of our code bearing sections will need toc stubs. */
9120 if ((isec->flags & SEC_LINKER_CREATED) != 0)
9121 return 0;
9122
9123 if (isec->size == 0)
9124 return 0;
9125
9126 if (isec->output_section == NULL)
9127 return 0;
9128
9129 if (isec->reloc_count == 0)
9130 return 0;
9131
9132 relstart = _bfd_elf_link_read_relocs (isec->owner, isec, NULL, NULL,
9133 info->keep_memory);
9134 if (relstart == NULL)
9135 return -1;
9136
9137 /* Look for branches to outside of this section. */
9138 local_syms = NULL;
9139 ret = 0;
9140 htab = ppc_hash_table (info);
9141 for (rel = relstart; rel < relstart + isec->reloc_count; ++rel)
9142 {
9143 enum elf_ppc64_reloc_type r_type;
9144 unsigned long r_symndx;
9145 struct elf_link_hash_entry *h;
9146 struct ppc_link_hash_entry *eh;
9147 Elf_Internal_Sym *sym;
9148 asection *sym_sec;
9149 struct _opd_sec_data *opd;
9150 bfd_vma sym_value;
9151 bfd_vma dest;
9152
9153 r_type = ELF64_R_TYPE (rel->r_info);
9154 if (r_type != R_PPC64_REL24
9155 && r_type != R_PPC64_REL14
9156 && r_type != R_PPC64_REL14_BRTAKEN
9157 && r_type != R_PPC64_REL14_BRNTAKEN)
9158 continue;
9159
9160 r_symndx = ELF64_R_SYM (rel->r_info);
9161 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms, r_symndx,
9162 isec->owner))
9163 {
9164 ret = -1;
9165 break;
9166 }
9167
9168 /* Calls to dynamic lib functions go through a plt call stub
9169 that uses r2. */
9170 eh = (struct ppc_link_hash_entry *) h;
9171 if (eh != NULL
9172 && (eh->elf.plt.plist != NULL
9173 || (eh->oh != NULL
9174 && eh->oh->elf.plt.plist != NULL)))
9175 {
9176 ret = 1;
9177 break;
9178 }
9179
9180 if (sym_sec == NULL)
9181 /* Ignore other undefined symbols. */
9182 continue;
9183
9184 /* Assume branches to other sections not included in the link need
9185 stubs too, to cover -R and absolute syms. */
9186 if (sym_sec->output_section == NULL)
9187 {
9188 ret = 1;
9189 break;
9190 }
9191
9192 if (h == NULL)
9193 sym_value = sym->st_value;
9194 else
9195 {
9196 if (h->root.type != bfd_link_hash_defined
9197 && h->root.type != bfd_link_hash_defweak)
9198 abort ();
9199 sym_value = h->root.u.def.value;
9200 }
9201 sym_value += rel->r_addend;
9202
9203 /* If this branch reloc uses an opd sym, find the code section. */
9204 opd = get_opd_info (sym_sec);
9205 if (opd != NULL)
9206 {
9207 if (h == NULL && opd->adjust != NULL)
9208 {
9209 long adjust;
9210
9211 adjust = opd->adjust[sym->st_value / 8];
9212 if (adjust == -1)
9213 /* Assume deleted functions won't ever be called. */
9214 continue;
9215 sym_value += adjust;
9216 }
9217
9218 dest = opd_entry_value (sym_sec, sym_value, &sym_sec, NULL);
9219 if (dest == (bfd_vma) -1)
9220 continue;
9221 }
9222 else
9223 dest = (sym_value
9224 + sym_sec->output_offset
9225 + sym_sec->output_section->vma);
9226
9227 /* Ignore branch to self. */
9228 if (sym_sec == isec)
9229 continue;
9230
9231 /* If the called function uses the toc, we need a stub. */
9232 if (sym_sec->has_toc_reloc
9233 || sym_sec->makes_toc_func_call)
9234 {
9235 ret = 1;
9236 break;
9237 }
9238
9239 /* Assume any branch that needs a long branch stub might in fact
9240 need a plt_branch stub. A plt_branch stub uses r2. */
9241 else if (dest - (isec->output_offset
9242 + isec->output_section->vma
9243 + rel->r_offset) + (1 << 25) >= (2 << 25))
9244 {
9245 ret = 1;
9246 break;
9247 }
9248
9249 /* If calling back to a section in the process of being tested, we
9250 can't say for sure that no toc adjusting stubs are needed, so
9251 don't return zero. */
9252 else if (sym_sec->call_check_in_progress)
9253 ret = 2;
9254
9255 /* Branches to another section that itself doesn't have any TOC
9256 references are OK. Recursively call ourselves to check. */
9257 else if (sym_sec->id <= htab->top_id
9258 && htab->stub_group[sym_sec->id].toc_off == 0)
9259 {
9260 int recur;
9261
9262 /* Mark current section as indeterminate, so that other
9263 sections that call back to current won't be marked as
9264 known. */
9265 isec->call_check_in_progress = 1;
9266 recur = toc_adjusting_stub_needed (info, sym_sec);
9267 isec->call_check_in_progress = 0;
9268
9269 if (recur < 0)
9270 {
9271 /* An error. Exit. */
9272 ret = -1;
9273 break;
9274 }
9275 else if (recur <= 1)
9276 {
9277 /* Known result. Mark as checked and set section flag. */
9278 htab->stub_group[sym_sec->id].toc_off = 1;
9279 if (recur != 0)
9280 {
9281 sym_sec->makes_toc_func_call = 1;
9282 ret = 1;
9283 break;
9284 }
9285 }
9286 else
9287 {
9288 /* Unknown result. Continue checking. */
9289 ret = 2;
9290 }
9291 }
9292 }
9293
9294 if (local_syms != NULL
9295 && (elf_symtab_hdr (isec->owner).contents != (unsigned char *) local_syms))
9296 free (local_syms);
9297 if (elf_section_data (isec)->relocs != relstart)
9298 free (relstart);
9299
9300 return ret;
9301 }
9302
9303 /* The linker repeatedly calls this function for each input section,
9304 in the order that input sections are linked into output sections.
9305 Build lists of input sections to determine groupings between which
9306 we may insert linker stubs. */
9307
9308 bfd_boolean
9309 ppc64_elf_next_input_section (struct bfd_link_info *info, asection *isec)
9310 {
9311 struct ppc_link_hash_table *htab = ppc_hash_table (info);
9312
9313 if ((isec->output_section->flags & SEC_CODE) != 0
9314 && isec->output_section->index <= htab->top_index)
9315 {
9316 asection **list = htab->input_list + isec->output_section->index;
9317 /* Steal the link_sec pointer for our list. */
9318 #define PREV_SEC(sec) (htab->stub_group[(sec)->id].link_sec)
9319 /* This happens to make the list in reverse order,
9320 which is what we want. */
9321 PREV_SEC (isec) = *list;
9322 *list = isec;
9323 }
9324
9325 if (htab->multi_toc_needed)
9326 {
9327 /* If a code section has a function that uses the TOC then we need
9328 to use the right TOC (obviously). Also, make sure that .opd gets
9329 the correct TOC value for R_PPC64_TOC relocs that don't have or
9330 can't find their function symbol (shouldn't ever happen now).
9331 Also specially treat .fixup for the linux kernel. .fixup
9332 contains branches, but only back to the function that hit an
9333 exception. */
9334 if (isec->has_toc_reloc
9335 || (isec->flags & SEC_CODE) == 0
9336 || strcmp (isec->name, ".fixup") == 0)
9337 {
9338 if (elf_gp (isec->owner) != 0)
9339 htab->toc_curr = elf_gp (isec->owner);
9340 }
9341 else if (htab->stub_group[isec->id].toc_off == 0)
9342 {
9343 int ret = toc_adjusting_stub_needed (info, isec);
9344 if (ret < 0)
9345 return FALSE;
9346 else
9347 isec->makes_toc_func_call = ret & 1;
9348 }
9349 }
9350
9351 /* Functions that don't use the TOC can belong in any TOC group.
9352 Use the last TOC base. This happens to make _init and _fini
9353 pasting work. */
9354 htab->stub_group[isec->id].toc_off = htab->toc_curr;
9355 return TRUE;
9356 }
9357
9358 /* See whether we can group stub sections together. Grouping stub
9359 sections may result in fewer stubs. More importantly, we need to
9360 put all .init* and .fini* stubs at the beginning of the .init or
9361 .fini output sections respectively, because glibc splits the
9362 _init and _fini functions into multiple parts. Putting a stub in
9363 the middle of a function is not a good idea. */
9364
9365 static void
9366 group_sections (struct ppc_link_hash_table *htab,
9367 bfd_size_type stub_group_size,
9368 bfd_boolean stubs_always_before_branch)
9369 {
9370 asection **list;
9371 bfd_size_type stub14_group_size;
9372 bfd_boolean suppress_size_errors;
9373
9374 suppress_size_errors = FALSE;
9375 stub14_group_size = stub_group_size;
9376 if (stub_group_size == 1)
9377 {
9378 /* Default values. */
9379 if (stubs_always_before_branch)
9380 {
9381 stub_group_size = 0x1e00000;
9382 stub14_group_size = 0x7800;
9383 }
9384 else
9385 {
9386 stub_group_size = 0x1c00000;
9387 stub14_group_size = 0x7000;
9388 }
9389 suppress_size_errors = TRUE;
9390 }
9391
9392 list = htab->input_list + htab->top_index;
9393 do
9394 {
9395 asection *tail = *list;
9396 while (tail != NULL)
9397 {
9398 asection *curr;
9399 asection *prev;
9400 bfd_size_type total;
9401 bfd_boolean big_sec;
9402 bfd_vma curr_toc;
9403
9404 curr = tail;
9405 total = tail->size;
9406 big_sec = total > (ppc64_elf_section_data (tail)->has_14bit_branch
9407 ? stub14_group_size : stub_group_size);
9408 if (big_sec && !suppress_size_errors)
9409 (*_bfd_error_handler) (_("%B section %A exceeds stub group size"),
9410 tail->owner, tail);
9411 curr_toc = htab->stub_group[tail->id].toc_off;
9412
9413 while ((prev = PREV_SEC (curr)) != NULL
9414 && ((total += curr->output_offset - prev->output_offset)
9415 < (ppc64_elf_section_data (prev)->has_14bit_branch
9416 ? stub14_group_size : stub_group_size))
9417 && htab->stub_group[prev->id].toc_off == curr_toc)
9418 curr = prev;
9419
9420 /* OK, the size from the start of CURR to the end is less
9421 than stub_group_size and thus can be handled by one stub
9422 section. (or the tail section is itself larger than
9423 stub_group_size, in which case we may be toast.) We
9424 should really be keeping track of the total size of stubs
9425 added here, as stubs contribute to the final output
9426 section size. That's a little tricky, and this way will
9427 only break if stubs added make the total size more than
9428 2^25, ie. for the default stub_group_size, if stubs total
9429 more than 2097152 bytes, or nearly 75000 plt call stubs. */
9430 do
9431 {
9432 prev = PREV_SEC (tail);
9433 /* Set up this stub group. */
9434 htab->stub_group[tail->id].link_sec = curr;
9435 }
9436 while (tail != curr && (tail = prev) != NULL);
9437
9438 /* But wait, there's more! Input sections up to stub_group_size
9439 bytes before the stub section can be handled by it too.
9440 Don't do this if we have a really large section after the
9441 stubs, as adding more stubs increases the chance that
9442 branches may not reach into the stub section. */
9443 if (!stubs_always_before_branch && !big_sec)
9444 {
9445 total = 0;
9446 while (prev != NULL
9447 && ((total += tail->output_offset - prev->output_offset)
9448 < (ppc64_elf_section_data (prev)->has_14bit_branch
9449 ? stub14_group_size : stub_group_size))
9450 && htab->stub_group[prev->id].toc_off == curr_toc)
9451 {
9452 tail = prev;
9453 prev = PREV_SEC (tail);
9454 htab->stub_group[tail->id].link_sec = curr;
9455 }
9456 }
9457 tail = prev;
9458 }
9459 }
9460 while (list-- != htab->input_list);
9461 free (htab->input_list);
9462 #undef PREV_SEC
9463 }
9464
9465 /* Determine and set the size of the stub section for a final link.
9466
9467 The basic idea here is to examine all the relocations looking for
9468 PC-relative calls to a target that is unreachable with a "bl"
9469 instruction. */
9470
9471 bfd_boolean
9472 ppc64_elf_size_stubs (bfd *output_bfd,
9473 struct bfd_link_info *info,
9474 bfd_signed_vma group_size,
9475 asection *(*add_stub_section) (const char *, asection *),
9476 void (*layout_sections_again) (void))
9477 {
9478 bfd_size_type stub_group_size;
9479 bfd_boolean stubs_always_before_branch;
9480 struct ppc_link_hash_table *htab = ppc_hash_table (info);
9481
9482 /* Stash our params away. */
9483 htab->add_stub_section = add_stub_section;
9484 htab->layout_sections_again = layout_sections_again;
9485 stubs_always_before_branch = group_size < 0;
9486 if (group_size < 0)
9487 stub_group_size = -group_size;
9488 else
9489 stub_group_size = group_size;
9490
9491 group_sections (htab, stub_group_size, stubs_always_before_branch);
9492
9493 while (1)
9494 {
9495 bfd *input_bfd;
9496 unsigned int bfd_indx;
9497 asection *stub_sec;
9498
9499 htab->stub_iteration += 1;
9500
9501 for (input_bfd = info->input_bfds, bfd_indx = 0;
9502 input_bfd != NULL;
9503 input_bfd = input_bfd->link_next, bfd_indx++)
9504 {
9505 Elf_Internal_Shdr *symtab_hdr;
9506 asection *section;
9507 Elf_Internal_Sym *local_syms = NULL;
9508
9509 if (!is_ppc64_elf (input_bfd))
9510 continue;
9511
9512 /* We'll need the symbol table in a second. */
9513 symtab_hdr = &elf_symtab_hdr (input_bfd);
9514 if (symtab_hdr->sh_info == 0)
9515 continue;
9516
9517 /* Walk over each section attached to the input bfd. */
9518 for (section = input_bfd->sections;
9519 section != NULL;
9520 section = section->next)
9521 {
9522 Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
9523
9524 /* If there aren't any relocs, then there's nothing more
9525 to do. */
9526 if ((section->flags & SEC_RELOC) == 0
9527 || (section->flags & SEC_ALLOC) == 0
9528 || (section->flags & SEC_LOAD) == 0
9529 || (section->flags & SEC_CODE) == 0
9530 || section->reloc_count == 0)
9531 continue;
9532
9533 /* If this section is a link-once section that will be
9534 discarded, then don't create any stubs. */
9535 if (section->output_section == NULL
9536 || section->output_section->owner != output_bfd)
9537 continue;
9538
9539 /* Get the relocs. */
9540 internal_relocs
9541 = _bfd_elf_link_read_relocs (input_bfd, section, NULL, NULL,
9542 info->keep_memory);
9543 if (internal_relocs == NULL)
9544 goto error_ret_free_local;
9545
9546 /* Now examine each relocation. */
9547 irela = internal_relocs;
9548 irelaend = irela + section->reloc_count;
9549 for (; irela < irelaend; irela++)
9550 {
9551 enum elf_ppc64_reloc_type r_type;
9552 unsigned int r_indx;
9553 enum ppc_stub_type stub_type;
9554 struct ppc_stub_hash_entry *stub_entry;
9555 asection *sym_sec, *code_sec;
9556 bfd_vma sym_value;
9557 bfd_vma destination;
9558 bfd_boolean ok_dest;
9559 struct ppc_link_hash_entry *hash;
9560 struct ppc_link_hash_entry *fdh;
9561 struct elf_link_hash_entry *h;
9562 Elf_Internal_Sym *sym;
9563 char *stub_name;
9564 const asection *id_sec;
9565 struct _opd_sec_data *opd;
9566
9567 r_type = ELF64_R_TYPE (irela->r_info);
9568 r_indx = ELF64_R_SYM (irela->r_info);
9569
9570 if (r_type >= R_PPC64_max)
9571 {
9572 bfd_set_error (bfd_error_bad_value);
9573 goto error_ret_free_internal;
9574 }
9575
9576 /* Only look for stubs on branch instructions. */
9577 if (r_type != R_PPC64_REL24
9578 && r_type != R_PPC64_REL14
9579 && r_type != R_PPC64_REL14_BRTAKEN
9580 && r_type != R_PPC64_REL14_BRNTAKEN)
9581 continue;
9582
9583 /* Now determine the call target, its name, value,
9584 section. */
9585 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9586 r_indx, input_bfd))
9587 goto error_ret_free_internal;
9588 hash = (struct ppc_link_hash_entry *) h;
9589
9590 ok_dest = FALSE;
9591 fdh = NULL;
9592 sym_value = 0;
9593 if (hash == NULL)
9594 {
9595 sym_value = sym->st_value;
9596 ok_dest = TRUE;
9597 }
9598 else if (hash->elf.root.type == bfd_link_hash_defined
9599 || hash->elf.root.type == bfd_link_hash_defweak)
9600 {
9601 sym_value = hash->elf.root.u.def.value;
9602 if (sym_sec->output_section != NULL)
9603 ok_dest = TRUE;
9604 }
9605 else if (hash->elf.root.type == bfd_link_hash_undefweak
9606 || hash->elf.root.type == bfd_link_hash_undefined)
9607 {
9608 /* Recognise an old ABI func code entry sym, and
9609 use the func descriptor sym instead if it is
9610 defined. */
9611 if (hash->elf.root.root.string[0] == '.'
9612 && (fdh = get_fdh (hash, htab)) != NULL)
9613 {
9614 if (fdh->elf.root.type == bfd_link_hash_defined
9615 || fdh->elf.root.type == bfd_link_hash_defweak)
9616 {
9617 sym_sec = fdh->elf.root.u.def.section;
9618 sym_value = fdh->elf.root.u.def.value;
9619 if (sym_sec->output_section != NULL)
9620 ok_dest = TRUE;
9621 }
9622 else
9623 fdh = NULL;
9624 }
9625 }
9626 else
9627 {
9628 bfd_set_error (bfd_error_bad_value);
9629 goto error_ret_free_internal;
9630 }
9631
9632 destination = 0;
9633 if (ok_dest)
9634 {
9635 sym_value += irela->r_addend;
9636 destination = (sym_value
9637 + sym_sec->output_offset
9638 + sym_sec->output_section->vma);
9639 }
9640
9641 code_sec = sym_sec;
9642 opd = get_opd_info (sym_sec);
9643 if (opd != NULL)
9644 {
9645 bfd_vma dest;
9646
9647 if (hash == NULL && opd->adjust != NULL)
9648 {
9649 long adjust = opd->adjust[sym_value / 8];
9650 if (adjust == -1)
9651 continue;
9652 sym_value += adjust;
9653 }
9654 dest = opd_entry_value (sym_sec, sym_value,
9655 &code_sec, &sym_value);
9656 if (dest != (bfd_vma) -1)
9657 {
9658 destination = dest;
9659 if (fdh != NULL)
9660 {
9661 /* Fixup old ABI sym to point at code
9662 entry. */
9663 hash->elf.root.type = bfd_link_hash_defweak;
9664 hash->elf.root.u.def.section = code_sec;
9665 hash->elf.root.u.def.value = sym_value;
9666 }
9667 }
9668 }
9669
9670 /* Determine what (if any) linker stub is needed. */
9671 stub_type = ppc_type_of_stub (section, irela, &hash,
9672 destination);
9673
9674 if (stub_type != ppc_stub_plt_call)
9675 {
9676 /* Check whether we need a TOC adjusting stub.
9677 Since the linker pastes together pieces from
9678 different object files when creating the
9679 _init and _fini functions, it may be that a
9680 call to what looks like a local sym is in
9681 fact a call needing a TOC adjustment. */
9682 if (code_sec != NULL
9683 && code_sec->output_section != NULL
9684 && (htab->stub_group[code_sec->id].toc_off
9685 != htab->stub_group[section->id].toc_off)
9686 && (code_sec->has_toc_reloc
9687 || code_sec->makes_toc_func_call))
9688 stub_type = ppc_stub_long_branch_r2off;
9689 }
9690
9691 if (stub_type == ppc_stub_none)
9692 continue;
9693
9694 /* __tls_get_addr calls might be eliminated. */
9695 if (stub_type != ppc_stub_plt_call
9696 && hash != NULL
9697 && (hash == htab->tls_get_addr
9698 || hash == htab->tls_get_addr_fd)
9699 && section->has_tls_reloc
9700 && irela != internal_relocs)
9701 {
9702 /* Get tls info. */
9703 char *tls_mask;
9704
9705 if (!get_tls_mask (&tls_mask, NULL, NULL, &local_syms,
9706 irela - 1, input_bfd))
9707 goto error_ret_free_internal;
9708 if (*tls_mask != 0)
9709 continue;
9710 }
9711
9712 /* Support for grouping stub sections. */
9713 id_sec = htab->stub_group[section->id].link_sec;
9714
9715 /* Get the name of this stub. */
9716 stub_name = ppc_stub_name (id_sec, sym_sec, hash, irela);
9717 if (!stub_name)
9718 goto error_ret_free_internal;
9719
9720 stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
9721 stub_name, FALSE, FALSE);
9722 if (stub_entry != NULL)
9723 {
9724 /* The proper stub has already been created. */
9725 free (stub_name);
9726 continue;
9727 }
9728
9729 stub_entry = ppc_add_stub (stub_name, section, htab);
9730 if (stub_entry == NULL)
9731 {
9732 free (stub_name);
9733 error_ret_free_internal:
9734 if (elf_section_data (section)->relocs == NULL)
9735 free (internal_relocs);
9736 error_ret_free_local:
9737 if (local_syms != NULL
9738 && (symtab_hdr->contents
9739 != (unsigned char *) local_syms))
9740 free (local_syms);
9741 return FALSE;
9742 }
9743
9744 stub_entry->stub_type = stub_type;
9745 stub_entry->target_value = sym_value;
9746 stub_entry->target_section = code_sec;
9747 stub_entry->h = hash;
9748 stub_entry->addend = irela->r_addend;
9749
9750 if (stub_entry->h != NULL)
9751 htab->stub_globals += 1;
9752 }
9753
9754 /* We're done with the internal relocs, free them. */
9755 if (elf_section_data (section)->relocs != internal_relocs)
9756 free (internal_relocs);
9757 }
9758
9759 if (local_syms != NULL
9760 && symtab_hdr->contents != (unsigned char *) local_syms)
9761 {
9762 if (!info->keep_memory)
9763 free (local_syms);
9764 else
9765 symtab_hdr->contents = (unsigned char *) local_syms;
9766 }
9767 }
9768
9769 /* We may have added some stubs. Find out the new size of the
9770 stub sections. */
9771 for (stub_sec = htab->stub_bfd->sections;
9772 stub_sec != NULL;
9773 stub_sec = stub_sec->next)
9774 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
9775 {
9776 stub_sec->rawsize = stub_sec->size;
9777 stub_sec->size = 0;
9778 stub_sec->reloc_count = 0;
9779 stub_sec->flags &= ~SEC_RELOC;
9780 }
9781
9782 htab->brlt->size = 0;
9783 htab->brlt->reloc_count = 0;
9784 htab->brlt->flags &= ~SEC_RELOC;
9785 if (htab->relbrlt != NULL)
9786 htab->relbrlt->size = 0;
9787
9788 bfd_hash_traverse (&htab->stub_hash_table, ppc_size_one_stub, info);
9789
9790 if (info->emitrelocations
9791 && htab->glink != NULL && htab->glink->size != 0)
9792 {
9793 htab->glink->reloc_count = 1;
9794 htab->glink->flags |= SEC_RELOC;
9795 }
9796
9797 for (stub_sec = htab->stub_bfd->sections;
9798 stub_sec != NULL;
9799 stub_sec = stub_sec->next)
9800 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
9801 && stub_sec->rawsize != stub_sec->size)
9802 break;
9803
9804 /* Exit from this loop when no stubs have been added, and no stubs
9805 have changed size. */
9806 if (stub_sec == NULL)
9807 break;
9808
9809 /* Ask the linker to do its stuff. */
9810 (*htab->layout_sections_again) ();
9811 }
9812
9813 /* It would be nice to strip htab->brlt from the output if the
9814 section is empty, but it's too late. If we strip sections here,
9815 the dynamic symbol table is corrupted since the section symbol
9816 for the stripped section isn't written. */
9817
9818 return TRUE;
9819 }
9820
9821 /* Called after we have determined section placement. If sections
9822 move, we'll be called again. Provide a value for TOCstart. */
9823
9824 bfd_vma
9825 ppc64_elf_toc (bfd *obfd)
9826 {
9827 asection *s;
9828 bfd_vma TOCstart;
9829
9830 /* The TOC consists of sections .got, .toc, .tocbss, .plt in that
9831 order. The TOC starts where the first of these sections starts. */
9832 s = bfd_get_section_by_name (obfd, ".got");
9833 if (s == NULL)
9834 s = bfd_get_section_by_name (obfd, ".toc");
9835 if (s == NULL)
9836 s = bfd_get_section_by_name (obfd, ".tocbss");
9837 if (s == NULL)
9838 s = bfd_get_section_by_name (obfd, ".plt");
9839 if (s == NULL)
9840 {
9841 /* This may happen for
9842 o references to TOC base (SYM@toc / TOC[tc0]) without a
9843 .toc directive
9844 o bad linker script
9845 o --gc-sections and empty TOC sections
9846
9847 FIXME: Warn user? */
9848
9849 /* Look for a likely section. We probably won't even be
9850 using TOCstart. */
9851 for (s = obfd->sections; s != NULL; s = s->next)
9852 if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_READONLY))
9853 == (SEC_ALLOC | SEC_SMALL_DATA))
9854 break;
9855 if (s == NULL)
9856 for (s = obfd->sections; s != NULL; s = s->next)
9857 if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA))
9858 == (SEC_ALLOC | SEC_SMALL_DATA))
9859 break;
9860 if (s == NULL)
9861 for (s = obfd->sections; s != NULL; s = s->next)
9862 if ((s->flags & (SEC_ALLOC | SEC_READONLY)) == SEC_ALLOC)
9863 break;
9864 if (s == NULL)
9865 for (s = obfd->sections; s != NULL; s = s->next)
9866 if ((s->flags & SEC_ALLOC) == SEC_ALLOC)
9867 break;
9868 }
9869
9870 TOCstart = 0;
9871 if (s != NULL)
9872 TOCstart = s->output_section->vma + s->output_offset;
9873
9874 return TOCstart;
9875 }
9876
9877 /* Build all the stubs associated with the current output file.
9878 The stubs are kept in a hash table attached to the main linker
9879 hash table. This function is called via gldelf64ppc_finish. */
9880
9881 bfd_boolean
9882 ppc64_elf_build_stubs (bfd_boolean emit_stub_syms,
9883 struct bfd_link_info *info,
9884 char **stats)
9885 {
9886 struct ppc_link_hash_table *htab = ppc_hash_table (info);
9887 asection *stub_sec;
9888 bfd_byte *p;
9889 int stub_sec_count = 0;
9890
9891 htab->emit_stub_syms = emit_stub_syms;
9892
9893 /* Allocate memory to hold the linker stubs. */
9894 for (stub_sec = htab->stub_bfd->sections;
9895 stub_sec != NULL;
9896 stub_sec = stub_sec->next)
9897 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
9898 && stub_sec->size != 0)
9899 {
9900 stub_sec->contents = bfd_zalloc (htab->stub_bfd, stub_sec->size);
9901 if (stub_sec->contents == NULL)
9902 return FALSE;
9903 /* We want to check that built size is the same as calculated
9904 size. rawsize is a convenient location to use. */
9905 stub_sec->rawsize = stub_sec->size;
9906 stub_sec->size = 0;
9907 }
9908
9909 if (htab->glink != NULL && htab->glink->size != 0)
9910 {
9911 unsigned int indx;
9912 bfd_vma plt0;
9913
9914 /* Build the .glink plt call stub. */
9915 if (htab->emit_stub_syms)
9916 {
9917 struct elf_link_hash_entry *h;
9918 h = elf_link_hash_lookup (&htab->elf, "__glink_PLTresolve",
9919 TRUE, FALSE, FALSE);
9920 if (h == NULL)
9921 return FALSE;
9922 if (h->root.type == bfd_link_hash_new)
9923 {
9924 h->root.type = bfd_link_hash_defined;
9925 h->root.u.def.section = htab->glink;
9926 h->root.u.def.value = 8;
9927 h->ref_regular = 1;
9928 h->def_regular = 1;
9929 h->ref_regular_nonweak = 1;
9930 h->forced_local = 1;
9931 h->non_elf = 0;
9932 }
9933 }
9934 plt0 = htab->plt->output_section->vma + htab->plt->output_offset - 16;
9935 if (info->emitrelocations)
9936 {
9937 Elf_Internal_Rela *r = get_relocs (htab->glink, 1);
9938 if (r == NULL)
9939 return FALSE;
9940 r->r_offset = (htab->glink->output_offset
9941 + htab->glink->output_section->vma);
9942 r->r_info = ELF64_R_INFO (0, R_PPC64_REL64);
9943 r->r_addend = plt0;
9944 }
9945 p = htab->glink->contents;
9946 plt0 -= htab->glink->output_section->vma + htab->glink->output_offset;
9947 bfd_put_64 (htab->glink->owner, plt0, p);
9948 p += 8;
9949 bfd_put_32 (htab->glink->owner, MFLR_R12, p);
9950 p += 4;
9951 bfd_put_32 (htab->glink->owner, BCL_20_31, p);
9952 p += 4;
9953 bfd_put_32 (htab->glink->owner, MFLR_R11, p);
9954 p += 4;
9955 bfd_put_32 (htab->glink->owner, LD_R2_M16R11, p);
9956 p += 4;
9957 bfd_put_32 (htab->glink->owner, MTLR_R12, p);
9958 p += 4;
9959 bfd_put_32 (htab->glink->owner, ADD_R12_R2_R11, p);
9960 p += 4;
9961 bfd_put_32 (htab->glink->owner, LD_R11_0R12, p);
9962 p += 4;
9963 bfd_put_32 (htab->glink->owner, LD_R2_0R12 | 8, p);
9964 p += 4;
9965 bfd_put_32 (htab->glink->owner, MTCTR_R11, p);
9966 p += 4;
9967 bfd_put_32 (htab->glink->owner, LD_R11_0R12 | 16, p);
9968 p += 4;
9969 bfd_put_32 (htab->glink->owner, BCTR, p);
9970 p += 4;
9971 while (p - htab->glink->contents < GLINK_CALL_STUB_SIZE)
9972 {
9973 bfd_put_32 (htab->glink->owner, NOP, p);
9974 p += 4;
9975 }
9976
9977 /* Build the .glink lazy link call stubs. */
9978 indx = 0;
9979 while (p < htab->glink->contents + htab->glink->size)
9980 {
9981 if (indx < 0x8000)
9982 {
9983 bfd_put_32 (htab->glink->owner, LI_R0_0 | indx, p);
9984 p += 4;
9985 }
9986 else
9987 {
9988 bfd_put_32 (htab->glink->owner, LIS_R0_0 | PPC_HI (indx), p);
9989 p += 4;
9990 bfd_put_32 (htab->glink->owner, ORI_R0_R0_0 | PPC_LO (indx), p);
9991 p += 4;
9992 }
9993 bfd_put_32 (htab->glink->owner,
9994 B_DOT | ((htab->glink->contents - p + 8) & 0x3fffffc), p);
9995 indx++;
9996 p += 4;
9997 }
9998 htab->glink->rawsize = p - htab->glink->contents;
9999 }
10000
10001 if (htab->brlt->size != 0)
10002 {
10003 htab->brlt->contents = bfd_zalloc (htab->brlt->owner,
10004 htab->brlt->size);
10005 if (htab->brlt->contents == NULL)
10006 return FALSE;
10007 }
10008 if (htab->relbrlt != NULL && htab->relbrlt->size != 0)
10009 {
10010 htab->relbrlt->contents = bfd_zalloc (htab->relbrlt->owner,
10011 htab->relbrlt->size);
10012 if (htab->relbrlt->contents == NULL)
10013 return FALSE;
10014 }
10015
10016 /* Build the stubs as directed by the stub hash table. */
10017 bfd_hash_traverse (&htab->stub_hash_table, ppc_build_one_stub, info);
10018
10019 if (htab->relbrlt != NULL)
10020 htab->relbrlt->reloc_count = 0;
10021
10022 for (stub_sec = htab->stub_bfd->sections;
10023 stub_sec != NULL;
10024 stub_sec = stub_sec->next)
10025 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
10026 {
10027 stub_sec_count += 1;
10028 if (stub_sec->rawsize != stub_sec->size)
10029 break;
10030 }
10031
10032 if (stub_sec != NULL
10033 || htab->glink->rawsize != htab->glink->size)
10034 {
10035 htab->stub_error = TRUE;
10036 (*_bfd_error_handler) (_("stubs don't match calculated size"));
10037 }
10038
10039 if (htab->stub_error)
10040 return FALSE;
10041
10042 if (stats != NULL)
10043 {
10044 *stats = bfd_malloc (500);
10045 if (*stats == NULL)
10046 return FALSE;
10047
10048 sprintf (*stats, _("linker stubs in %u group%s\n"
10049 " branch %lu\n"
10050 " toc adjust %lu\n"
10051 " long branch %lu\n"
10052 " long toc adj %lu\n"
10053 " plt call %lu"),
10054 stub_sec_count,
10055 stub_sec_count == 1 ? "" : "s",
10056 htab->stub_count[ppc_stub_long_branch - 1],
10057 htab->stub_count[ppc_stub_long_branch_r2off - 1],
10058 htab->stub_count[ppc_stub_plt_branch - 1],
10059 htab->stub_count[ppc_stub_plt_branch_r2off - 1],
10060 htab->stub_count[ppc_stub_plt_call - 1]);
10061 }
10062 return TRUE;
10063 }
10064
10065 /* This function undoes the changes made by add_symbol_adjust. */
10066
10067 static bfd_boolean
10068 undo_symbol_twiddle (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
10069 {
10070 struct ppc_link_hash_entry *eh;
10071
10072 if (h->root.type == bfd_link_hash_indirect)
10073 return TRUE;
10074
10075 if (h->root.type == bfd_link_hash_warning)
10076 h = (struct elf_link_hash_entry *) h->root.u.i.link;
10077
10078 eh = (struct ppc_link_hash_entry *) h;
10079 if (eh->elf.root.type != bfd_link_hash_undefweak || !eh->was_undefined)
10080 return TRUE;
10081
10082 eh->elf.root.type = bfd_link_hash_undefined;
10083 return TRUE;
10084 }
10085
10086 void
10087 ppc64_elf_restore_symbols (struct bfd_link_info *info)
10088 {
10089 struct ppc_link_hash_table *htab = ppc_hash_table (info);
10090 elf_link_hash_traverse (&htab->elf, undo_symbol_twiddle, info);
10091 }
10092
10093 /* What to do when ld finds relocations against symbols defined in
10094 discarded sections. */
10095
10096 static unsigned int
10097 ppc64_elf_action_discarded (asection *sec)
10098 {
10099 if (strcmp (".opd", sec->name) == 0)
10100 return 0;
10101
10102 if (strcmp (".toc", sec->name) == 0)
10103 return 0;
10104
10105 if (strcmp (".toc1", sec->name) == 0)
10106 return 0;
10107
10108 return _bfd_elf_default_action_discarded (sec);
10109 }
10110
10111 /* The RELOCATE_SECTION function is called by the ELF backend linker
10112 to handle the relocations for a section.
10113
10114 The relocs are always passed as Rela structures; if the section
10115 actually uses Rel structures, the r_addend field will always be
10116 zero.
10117
10118 This function is responsible for adjust the section contents as
10119 necessary, and (if using Rela relocs and generating a
10120 relocatable output file) adjusting the reloc addend as
10121 necessary.
10122
10123 This function does not have to worry about setting the reloc
10124 address or the reloc symbol index.
10125
10126 LOCAL_SYMS is a pointer to the swapped in local symbols.
10127
10128 LOCAL_SECTIONS is an array giving the section in the input file
10129 corresponding to the st_shndx field of each local symbol.
10130
10131 The global hash table entry for the global symbols can be found
10132 via elf_sym_hashes (input_bfd).
10133
10134 When generating relocatable output, this function must handle
10135 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
10136 going to be the section symbol corresponding to the output
10137 section, which means that the addend must be adjusted
10138 accordingly. */
10139
10140 static bfd_boolean
10141 ppc64_elf_relocate_section (bfd *output_bfd,
10142 struct bfd_link_info *info,
10143 bfd *input_bfd,
10144 asection *input_section,
10145 bfd_byte *contents,
10146 Elf_Internal_Rela *relocs,
10147 Elf_Internal_Sym *local_syms,
10148 asection **local_sections)
10149 {
10150 struct ppc_link_hash_table *htab;
10151 Elf_Internal_Shdr *symtab_hdr;
10152 struct elf_link_hash_entry **sym_hashes;
10153 Elf_Internal_Rela *rel;
10154 Elf_Internal_Rela *relend;
10155 Elf_Internal_Rela outrel;
10156 bfd_byte *loc;
10157 struct got_entry **local_got_ents;
10158 bfd_vma TOCstart;
10159 bfd_boolean ret = TRUE;
10160 bfd_boolean is_opd;
10161 /* Disabled until we sort out how ld should choose 'y' vs 'at'. */
10162 bfd_boolean is_power4 = FALSE;
10163 bfd_vma d_offset = (bfd_big_endian (output_bfd) ? 2 : 0);
10164
10165 /* Initialize howto table if needed. */
10166 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
10167 ppc_howto_init ();
10168
10169 htab = ppc_hash_table (info);
10170
10171 /* Don't relocate stub sections. */
10172 if (input_section->owner == htab->stub_bfd)
10173 return TRUE;
10174
10175 BFD_ASSERT (is_ppc64_elf (input_bfd));
10176
10177 local_got_ents = elf_local_got_ents (input_bfd);
10178 TOCstart = elf_gp (output_bfd);
10179 symtab_hdr = &elf_symtab_hdr (input_bfd);
10180 sym_hashes = elf_sym_hashes (input_bfd);
10181 is_opd = ppc64_elf_section_data (input_section)->sec_type == sec_opd;
10182
10183 rel = relocs;
10184 relend = relocs + input_section->reloc_count;
10185 for (; rel < relend; rel++)
10186 {
10187 enum elf_ppc64_reloc_type r_type;
10188 bfd_vma addend, orig_addend;
10189 bfd_reloc_status_type r;
10190 Elf_Internal_Sym *sym;
10191 asection *sec;
10192 struct elf_link_hash_entry *h_elf;
10193 struct ppc_link_hash_entry *h;
10194 struct ppc_link_hash_entry *fdh;
10195 const char *sym_name;
10196 unsigned long r_symndx, toc_symndx;
10197 bfd_vma toc_addend;
10198 char tls_mask, tls_gd, tls_type;
10199 char sym_type;
10200 bfd_vma relocation;
10201 bfd_boolean unresolved_reloc;
10202 bfd_boolean warned;
10203 unsigned long insn, mask;
10204 struct ppc_stub_hash_entry *stub_entry;
10205 bfd_vma max_br_offset;
10206 bfd_vma from;
10207
10208 r_type = ELF64_R_TYPE (rel->r_info);
10209 r_symndx = ELF64_R_SYM (rel->r_info);
10210
10211 /* For old style R_PPC64_TOC relocs with a zero symbol, use the
10212 symbol of the previous ADDR64 reloc. The symbol gives us the
10213 proper TOC base to use. */
10214 if (rel->r_info == ELF64_R_INFO (0, R_PPC64_TOC)
10215 && rel != relocs
10216 && ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_ADDR64
10217 && is_opd)
10218 r_symndx = ELF64_R_SYM (rel[-1].r_info);
10219
10220 sym = NULL;
10221 sec = NULL;
10222 h_elf = NULL;
10223 sym_name = NULL;
10224 unresolved_reloc = FALSE;
10225 warned = FALSE;
10226 orig_addend = rel->r_addend;
10227
10228 if (r_symndx < symtab_hdr->sh_info)
10229 {
10230 /* It's a local symbol. */
10231 struct _opd_sec_data *opd;
10232
10233 sym = local_syms + r_symndx;
10234 sec = local_sections[r_symndx];
10235 sym_name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym, sec);
10236 sym_type = ELF64_ST_TYPE (sym->st_info);
10237 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
10238 opd = get_opd_info (sec);
10239 if (opd != NULL && opd->adjust != NULL)
10240 {
10241 long adjust = opd->adjust[(sym->st_value + rel->r_addend) / 8];
10242 if (adjust == -1)
10243 relocation = 0;
10244 else
10245 {
10246 /* If this is a relocation against the opd section sym
10247 and we have edited .opd, adjust the reloc addend so
10248 that ld -r and ld --emit-relocs output is correct.
10249 If it is a reloc against some other .opd symbol,
10250 then the symbol value will be adjusted later. */
10251 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
10252 rel->r_addend += adjust;
10253 else
10254 relocation += adjust;
10255 }
10256 }
10257 }
10258 else
10259 {
10260 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
10261 r_symndx, symtab_hdr, sym_hashes,
10262 h_elf, sec, relocation,
10263 unresolved_reloc, warned);
10264 sym_name = h_elf->root.root.string;
10265 sym_type = h_elf->type;
10266 }
10267 h = (struct ppc_link_hash_entry *) h_elf;
10268
10269 if (sec != NULL && elf_discarded_section (sec))
10270 {
10271 /* For relocs against symbols from removed linkonce sections,
10272 or sections discarded by a linker script, we just want the
10273 section contents zeroed. Avoid any special processing. */
10274 _bfd_clear_contents (ppc64_elf_howto_table[r_type], input_bfd,
10275 contents + rel->r_offset);
10276 rel->r_info = 0;
10277 rel->r_addend = 0;
10278 continue;
10279 }
10280
10281 if (info->relocatable)
10282 continue;
10283
10284 /* TLS optimizations. Replace instruction sequences and relocs
10285 based on information we collected in tls_optimize. We edit
10286 RELOCS so that --emit-relocs will output something sensible
10287 for the final instruction stream. */
10288 tls_mask = 0;
10289 tls_gd = 0;
10290 toc_symndx = 0;
10291 if (IS_PPC64_TLS_RELOC (r_type))
10292 {
10293 if (h != NULL)
10294 tls_mask = h->tls_mask;
10295 else if (local_got_ents != NULL)
10296 {
10297 char *lgot_masks;
10298 lgot_masks = (char *) (local_got_ents + symtab_hdr->sh_info);
10299 tls_mask = lgot_masks[r_symndx];
10300 }
10301 if (tls_mask == 0 && r_type == R_PPC64_TLS)
10302 {
10303 /* Check for toc tls entries. */
10304 char *toc_tls;
10305
10306 if (!get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
10307 &local_syms, rel, input_bfd))
10308 return FALSE;
10309
10310 if (toc_tls)
10311 tls_mask = *toc_tls;
10312 }
10313 }
10314
10315 /* Check that tls relocs are used with tls syms, and non-tls
10316 relocs are used with non-tls syms. */
10317 if (r_symndx != 0
10318 && r_type != R_PPC64_NONE
10319 && (h == NULL
10320 || h->elf.root.type == bfd_link_hash_defined
10321 || h->elf.root.type == bfd_link_hash_defweak)
10322 && (IS_PPC64_TLS_RELOC (r_type)
10323 != (sym_type == STT_TLS
10324 || (sym_type == STT_SECTION
10325 && (sec->flags & SEC_THREAD_LOCAL) != 0))))
10326 {
10327 if (r_type == R_PPC64_TLS && tls_mask != 0)
10328 /* R_PPC64_TLS is OK against a symbol in the TOC. */
10329 ;
10330 else
10331 (*_bfd_error_handler)
10332 (!IS_PPC64_TLS_RELOC (r_type)
10333 ? _("%B(%A+0x%lx): %s used with TLS symbol %s")
10334 : _("%B(%A+0x%lx): %s used with non-TLS symbol %s"),
10335 input_bfd,
10336 input_section,
10337 (long) rel->r_offset,
10338 ppc64_elf_howto_table[r_type]->name,
10339 sym_name);
10340 }
10341
10342 /* Ensure reloc mapping code below stays sane. */
10343 if (R_PPC64_TOC16_LO_DS != R_PPC64_TOC16_DS + 1
10344 || R_PPC64_TOC16_LO != R_PPC64_TOC16 + 1
10345 || (R_PPC64_GOT_TLSLD16 & 3) != (R_PPC64_GOT_TLSGD16 & 3)
10346 || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TLSGD16_LO & 3)
10347 || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TLSGD16_HI & 3)
10348 || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TLSGD16_HA & 3)
10349 || (R_PPC64_GOT_TLSLD16 & 3) != (R_PPC64_GOT_TPREL16_DS & 3)
10350 || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TPREL16_LO_DS & 3)
10351 || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TPREL16_HI & 3)
10352 || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TPREL16_HA & 3))
10353 abort ();
10354
10355 switch (r_type)
10356 {
10357 default:
10358 break;
10359
10360 case R_PPC64_TOC16:
10361 case R_PPC64_TOC16_LO:
10362 case R_PPC64_TOC16_DS:
10363 case R_PPC64_TOC16_LO_DS:
10364 {
10365 /* Check for toc tls entries. */
10366 char *toc_tls;
10367 int retval;
10368
10369 retval = get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
10370 &local_syms, rel, input_bfd);
10371 if (retval == 0)
10372 return FALSE;
10373
10374 if (toc_tls)
10375 {
10376 tls_mask = *toc_tls;
10377 if (r_type == R_PPC64_TOC16_DS
10378 || r_type == R_PPC64_TOC16_LO_DS)
10379 {
10380 if (tls_mask != 0
10381 && (tls_mask & (TLS_DTPREL | TLS_TPREL)) == 0)
10382 goto toctprel;
10383 }
10384 else
10385 {
10386 /* If we found a GD reloc pair, then we might be
10387 doing a GD->IE transition. */
10388 if (retval == 2)
10389 {
10390 tls_gd = TLS_TPRELGD;
10391 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
10392 goto tls_ldgd_opt;
10393 }
10394 else if (retval == 3)
10395 {
10396 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
10397 goto tls_ldgd_opt;
10398 }
10399 }
10400 }
10401 }
10402 break;
10403
10404 case R_PPC64_GOT_TPREL16_DS:
10405 case R_PPC64_GOT_TPREL16_LO_DS:
10406 if (tls_mask != 0
10407 && (tls_mask & TLS_TPREL) == 0)
10408 {
10409 toctprel:
10410 insn = bfd_get_32 (output_bfd, contents + rel->r_offset - d_offset);
10411 insn &= 31 << 21;
10412 insn |= 0x3c0d0000; /* addis 0,13,0 */
10413 bfd_put_32 (output_bfd, insn, contents + rel->r_offset - d_offset);
10414 r_type = R_PPC64_TPREL16_HA;
10415 if (toc_symndx != 0)
10416 {
10417 rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
10418 rel->r_addend = toc_addend;
10419 /* We changed the symbol. Start over in order to
10420 get h, sym, sec etc. right. */
10421 rel--;
10422 continue;
10423 }
10424 else
10425 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
10426 }
10427 break;
10428
10429 case R_PPC64_TLS:
10430 if (tls_mask != 0
10431 && (tls_mask & TLS_TPREL) == 0)
10432 {
10433 bfd_vma rtra;
10434 insn = bfd_get_32 (output_bfd, contents + rel->r_offset);
10435 if ((insn & ((0x3f << 26) | (31 << 11)))
10436 == ((31 << 26) | (13 << 11)))
10437 rtra = insn & ((1 << 26) - (1 << 16));
10438 else if ((insn & ((0x3f << 26) | (31 << 16)))
10439 == ((31 << 26) | (13 << 16)))
10440 rtra = (insn & (31 << 21)) | ((insn & (31 << 11)) << 5);
10441 else
10442 abort ();
10443 if ((insn & ((1 << 11) - (1 << 1))) == 266 << 1)
10444 /* add -> addi. */
10445 insn = 14 << 26;
10446 else if ((insn & (31 << 1)) == 23 << 1
10447 && ((insn & (31 << 6)) < 14 << 6
10448 || ((insn & (31 << 6)) >= 16 << 6
10449 && (insn & (31 << 6)) < 24 << 6)))
10450 /* load and store indexed -> dform. */
10451 insn = (32 | ((insn >> 6) & 31)) << 26;
10452 else if ((insn & (31 << 1)) == 21 << 1
10453 && (insn & (0x1a << 6)) == 0)
10454 /* ldx, ldux, stdx, stdux -> ld, ldu, std, stdu. */
10455 insn = (((58 | ((insn >> 6) & 4)) << 26)
10456 | ((insn >> 6) & 1));
10457 else if ((insn & (31 << 1)) == 21 << 1
10458 && (insn & ((1 << 11) - (1 << 1))) == 341 << 1)
10459 /* lwax -> lwa. */
10460 insn = (58 << 26) | 2;
10461 else
10462 abort ();
10463 insn |= rtra;
10464 bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
10465 /* Was PPC64_TLS which sits on insn boundary, now
10466 PPC64_TPREL16_LO which is at low-order half-word. */
10467 rel->r_offset += d_offset;
10468 r_type = R_PPC64_TPREL16_LO;
10469 if (toc_symndx != 0)
10470 {
10471 rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
10472 rel->r_addend = toc_addend;
10473 /* We changed the symbol. Start over in order to
10474 get h, sym, sec etc. right. */
10475 rel--;
10476 continue;
10477 }
10478 else
10479 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
10480 }
10481 break;
10482
10483 case R_PPC64_GOT_TLSGD16_HI:
10484 case R_PPC64_GOT_TLSGD16_HA:
10485 tls_gd = TLS_TPRELGD;
10486 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
10487 goto tls_gdld_hi;
10488 break;
10489
10490 case R_PPC64_GOT_TLSLD16_HI:
10491 case R_PPC64_GOT_TLSLD16_HA:
10492 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
10493 {
10494 tls_gdld_hi:
10495 if ((tls_mask & tls_gd) != 0)
10496 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
10497 + R_PPC64_GOT_TPREL16_DS);
10498 else
10499 {
10500 bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
10501 rel->r_offset -= d_offset;
10502 r_type = R_PPC64_NONE;
10503 }
10504 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
10505 }
10506 break;
10507
10508 case R_PPC64_GOT_TLSGD16:
10509 case R_PPC64_GOT_TLSGD16_LO:
10510 tls_gd = TLS_TPRELGD;
10511 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
10512 goto tls_ldgd_opt;
10513 break;
10514
10515 case R_PPC64_GOT_TLSLD16:
10516 case R_PPC64_GOT_TLSLD16_LO:
10517 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
10518 {
10519 unsigned int insn1, insn2, insn3;
10520 bfd_vma offset;
10521
10522 tls_ldgd_opt:
10523 /* We know that the next reloc is on a tls_get_addr
10524 call, since ppc64_elf_tls_optimize checks this. */
10525 offset = rel[1].r_offset;
10526 if ((tls_mask & tls_gd) != 0)
10527 {
10528 /* IE */
10529 insn1 = bfd_get_32 (output_bfd,
10530 contents + rel->r_offset - d_offset);
10531 insn1 &= (1 << 26) - (1 << 2);
10532 insn1 |= 58 << 26; /* ld */
10533 insn2 = 0x7c636a14; /* add 3,3,13 */
10534 rel[1].r_info = ELF64_R_INFO (ELF64_R_SYM (rel[1].r_info),
10535 R_PPC64_NONE);
10536 if ((tls_mask & TLS_EXPLICIT) == 0)
10537 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
10538 + R_PPC64_GOT_TPREL16_DS);
10539 else
10540 r_type += R_PPC64_TOC16_DS - R_PPC64_TOC16;
10541 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
10542 }
10543 else
10544 {
10545 /* LE */
10546 insn1 = 0x3c6d0000; /* addis 3,13,0 */
10547 insn2 = 0x38630000; /* addi 3,3,0 */
10548 if (tls_gd == 0)
10549 {
10550 /* Was an LD reloc. */
10551 if (toc_symndx)
10552 sec = local_sections[toc_symndx];
10553 for (r_symndx = 0;
10554 r_symndx < symtab_hdr->sh_info;
10555 r_symndx++)
10556 if (local_sections[r_symndx] == sec)
10557 break;
10558 if (r_symndx >= symtab_hdr->sh_info)
10559 r_symndx = 0;
10560 rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
10561 if (r_symndx != 0)
10562 rel->r_addend -= (local_syms[r_symndx].st_value
10563 + sec->output_offset
10564 + sec->output_section->vma);
10565 }
10566 else if (toc_symndx != 0)
10567 {
10568 r_symndx = toc_symndx;
10569 rel->r_addend = toc_addend;
10570 }
10571 r_type = R_PPC64_TPREL16_HA;
10572 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
10573 rel[1].r_info = ELF64_R_INFO (r_symndx,
10574 R_PPC64_TPREL16_LO);
10575 rel[1].r_offset += d_offset;
10576 rel[1].r_addend = rel->r_addend;
10577 }
10578 bfd_put_32 (output_bfd, insn1,
10579 contents + rel->r_offset - d_offset);
10580 insn3 = bfd_get_32 (output_bfd,
10581 contents + offset + 4);
10582 if (insn3 == NOP
10583 || insn3 == CROR_151515 || insn3 == CROR_313131)
10584 {
10585 rel[1].r_offset += 4;
10586 bfd_put_32 (output_bfd, insn2, contents + offset + 4);
10587 insn2 = NOP;
10588 }
10589 bfd_put_32 (output_bfd, insn2, contents + offset);
10590 if ((tls_mask & tls_gd) == 0
10591 && (tls_gd == 0 || toc_symndx != 0))
10592 {
10593 /* We changed the symbol. Start over in order
10594 to get h, sym, sec etc. right. */
10595 rel--;
10596 continue;
10597 }
10598 }
10599 break;
10600
10601 case R_PPC64_DTPMOD64:
10602 if (rel + 1 < relend
10603 && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
10604 && rel[1].r_offset == rel->r_offset + 8)
10605 {
10606 if ((tls_mask & TLS_GD) == 0)
10607 {
10608 rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_NONE);
10609 if ((tls_mask & TLS_TPRELGD) != 0)
10610 r_type = R_PPC64_TPREL64;
10611 else
10612 {
10613 bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
10614 r_type = R_PPC64_NONE;
10615 }
10616 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
10617 }
10618 }
10619 else
10620 {
10621 if ((tls_mask & TLS_LD) == 0)
10622 {
10623 bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
10624 r_type = R_PPC64_NONE;
10625 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
10626 }
10627 }
10628 break;
10629
10630 case R_PPC64_TPREL64:
10631 if ((tls_mask & TLS_TPREL) == 0)
10632 {
10633 r_type = R_PPC64_NONE;
10634 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
10635 }
10636 break;
10637 }
10638
10639 /* Handle other relocations that tweak non-addend part of insn. */
10640 insn = 0;
10641 max_br_offset = 1 << 25;
10642 addend = rel->r_addend;
10643 switch (r_type)
10644 {
10645 default:
10646 break;
10647
10648 /* Branch taken prediction relocations. */
10649 case R_PPC64_ADDR14_BRTAKEN:
10650 case R_PPC64_REL14_BRTAKEN:
10651 insn = 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field. */
10652 /* Fall thru. */
10653
10654 /* Branch not taken prediction relocations. */
10655 case R_PPC64_ADDR14_BRNTAKEN:
10656 case R_PPC64_REL14_BRNTAKEN:
10657 insn |= bfd_get_32 (output_bfd,
10658 contents + rel->r_offset) & ~(0x01 << 21);
10659 /* Fall thru. */
10660
10661 case R_PPC64_REL14:
10662 max_br_offset = 1 << 15;
10663 /* Fall thru. */
10664
10665 case R_PPC64_REL24:
10666 /* Calls to functions with a different TOC, such as calls to
10667 shared objects, need to alter the TOC pointer. This is
10668 done using a linkage stub. A REL24 branching to these
10669 linkage stubs needs to be followed by a nop, as the nop
10670 will be replaced with an instruction to restore the TOC
10671 base pointer. */
10672 stub_entry = NULL;
10673 fdh = h;
10674 if (((h != NULL
10675 && (((fdh = h->oh) != NULL
10676 && fdh->elf.plt.plist != NULL)
10677 || (fdh = h)->elf.plt.plist != NULL))
10678 || (sec != NULL
10679 && sec->output_section != NULL
10680 && sec->id <= htab->top_id
10681 && (htab->stub_group[sec->id].toc_off
10682 != htab->stub_group[input_section->id].toc_off)))
10683 && (stub_entry = ppc_get_stub_entry (input_section, sec, fdh,
10684 rel, htab)) != NULL
10685 && (stub_entry->stub_type == ppc_stub_plt_call
10686 || stub_entry->stub_type == ppc_stub_plt_branch_r2off
10687 || stub_entry->stub_type == ppc_stub_long_branch_r2off))
10688 {
10689 bfd_boolean can_plt_call = FALSE;
10690
10691 if (rel->r_offset + 8 <= input_section->size)
10692 {
10693 unsigned long nop;
10694 nop = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
10695 if (nop == NOP
10696 || nop == CROR_151515 || nop == CROR_313131)
10697 {
10698 bfd_put_32 (input_bfd, LD_R2_40R1,
10699 contents + rel->r_offset + 4);
10700 can_plt_call = TRUE;
10701 }
10702 }
10703
10704 if (!can_plt_call)
10705 {
10706 if (stub_entry->stub_type == ppc_stub_plt_call)
10707 {
10708 /* If this is a plain branch rather than a branch
10709 and link, don't require a nop. However, don't
10710 allow tail calls in a shared library as they
10711 will result in r2 being corrupted. */
10712 unsigned long br;
10713 br = bfd_get_32 (input_bfd, contents + rel->r_offset);
10714 if (info->executable && (br & 1) == 0)
10715 can_plt_call = TRUE;
10716 else
10717 stub_entry = NULL;
10718 }
10719 else if (h != NULL
10720 && strcmp (h->elf.root.root.string,
10721 ".__libc_start_main") == 0)
10722 {
10723 /* Allow crt1 branch to go via a toc adjusting stub. */
10724 can_plt_call = TRUE;
10725 }
10726 else
10727 {
10728 if (strcmp (input_section->output_section->name,
10729 ".init") == 0
10730 || strcmp (input_section->output_section->name,
10731 ".fini") == 0)
10732 (*_bfd_error_handler)
10733 (_("%B(%A+0x%lx): automatic multiple TOCs "
10734 "not supported using your crt files; "
10735 "recompile with -mminimal-toc or upgrade gcc"),
10736 input_bfd,
10737 input_section,
10738 (long) rel->r_offset);
10739 else
10740 (*_bfd_error_handler)
10741 (_("%B(%A+0x%lx): sibling call optimization to `%s' "
10742 "does not allow automatic multiple TOCs; "
10743 "recompile with -mminimal-toc or "
10744 "-fno-optimize-sibling-calls, "
10745 "or make `%s' extern"),
10746 input_bfd,
10747 input_section,
10748 (long) rel->r_offset,
10749 sym_name,
10750 sym_name);
10751 bfd_set_error (bfd_error_bad_value);
10752 ret = FALSE;
10753 }
10754 }
10755
10756 if (can_plt_call
10757 && stub_entry->stub_type == ppc_stub_plt_call)
10758 unresolved_reloc = FALSE;
10759 }
10760
10761 if (stub_entry == NULL
10762 && get_opd_info (sec) != NULL)
10763 {
10764 /* The branch destination is the value of the opd entry. */
10765 bfd_vma off = (relocation + addend
10766 - sec->output_section->vma
10767 - sec->output_offset);
10768 bfd_vma dest = opd_entry_value (sec, off, NULL, NULL);
10769 if (dest != (bfd_vma) -1)
10770 {
10771 relocation = dest;
10772 addend = 0;
10773 }
10774 }
10775
10776 /* If the branch is out of reach we ought to have a long
10777 branch stub. */
10778 from = (rel->r_offset
10779 + input_section->output_offset
10780 + input_section->output_section->vma);
10781
10782 if (stub_entry == NULL
10783 && (relocation + addend - from + max_br_offset
10784 >= 2 * max_br_offset)
10785 && r_type != R_PPC64_ADDR14_BRTAKEN
10786 && r_type != R_PPC64_ADDR14_BRNTAKEN)
10787 stub_entry = ppc_get_stub_entry (input_section, sec, h, rel,
10788 htab);
10789
10790 if (stub_entry != NULL)
10791 {
10792 /* Munge up the value and addend so that we call the stub
10793 rather than the procedure directly. */
10794 relocation = (stub_entry->stub_offset
10795 + stub_entry->stub_sec->output_offset
10796 + stub_entry->stub_sec->output_section->vma);
10797 addend = 0;
10798 }
10799
10800 if (insn != 0)
10801 {
10802 if (is_power4)
10803 {
10804 /* Set 'a' bit. This is 0b00010 in BO field for branch
10805 on CR(BI) insns (BO == 001at or 011at), and 0b01000
10806 for branch on CTR insns (BO == 1a00t or 1a01t). */
10807 if ((insn & (0x14 << 21)) == (0x04 << 21))
10808 insn |= 0x02 << 21;
10809 else if ((insn & (0x14 << 21)) == (0x10 << 21))
10810 insn |= 0x08 << 21;
10811 else
10812 break;
10813 }
10814 else
10815 {
10816 /* Invert 'y' bit if not the default. */
10817 if ((bfd_signed_vma) (relocation + addend - from) < 0)
10818 insn ^= 0x01 << 21;
10819 }
10820
10821 bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
10822 }
10823
10824 /* NOP out calls to undefined weak functions.
10825 We can thus call a weak function without first
10826 checking whether the function is defined. */
10827 else if (h != NULL
10828 && h->elf.root.type == bfd_link_hash_undefweak
10829 && r_type == R_PPC64_REL24
10830 && relocation == 0
10831 && addend == 0)
10832 {
10833 bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
10834 continue;
10835 }
10836 break;
10837 }
10838
10839 /* Set `addend'. */
10840 tls_type = 0;
10841 switch (r_type)
10842 {
10843 default:
10844 (*_bfd_error_handler)
10845 (_("%B: unknown relocation type %d for symbol %s"),
10846 input_bfd, (int) r_type, sym_name);
10847
10848 bfd_set_error (bfd_error_bad_value);
10849 ret = FALSE;
10850 continue;
10851
10852 case R_PPC64_NONE:
10853 case R_PPC64_TLS:
10854 case R_PPC64_GNU_VTINHERIT:
10855 case R_PPC64_GNU_VTENTRY:
10856 continue;
10857
10858 /* GOT16 relocations. Like an ADDR16 using the symbol's
10859 address in the GOT as relocation value instead of the
10860 symbol's value itself. Also, create a GOT entry for the
10861 symbol and put the symbol value there. */
10862 case R_PPC64_GOT_TLSGD16:
10863 case R_PPC64_GOT_TLSGD16_LO:
10864 case R_PPC64_GOT_TLSGD16_HI:
10865 case R_PPC64_GOT_TLSGD16_HA:
10866 tls_type = TLS_TLS | TLS_GD;
10867 goto dogot;
10868
10869 case R_PPC64_GOT_TLSLD16:
10870 case R_PPC64_GOT_TLSLD16_LO:
10871 case R_PPC64_GOT_TLSLD16_HI:
10872 case R_PPC64_GOT_TLSLD16_HA:
10873 tls_type = TLS_TLS | TLS_LD;
10874 goto dogot;
10875
10876 case R_PPC64_GOT_TPREL16_DS:
10877 case R_PPC64_GOT_TPREL16_LO_DS:
10878 case R_PPC64_GOT_TPREL16_HI:
10879 case R_PPC64_GOT_TPREL16_HA:
10880 tls_type = TLS_TLS | TLS_TPREL;
10881 goto dogot;
10882
10883 case R_PPC64_GOT_DTPREL16_DS:
10884 case R_PPC64_GOT_DTPREL16_LO_DS:
10885 case R_PPC64_GOT_DTPREL16_HI:
10886 case R_PPC64_GOT_DTPREL16_HA:
10887 tls_type = TLS_TLS | TLS_DTPREL;
10888 goto dogot;
10889
10890 case R_PPC64_GOT16:
10891 case R_PPC64_GOT16_LO:
10892 case R_PPC64_GOT16_HI:
10893 case R_PPC64_GOT16_HA:
10894 case R_PPC64_GOT16_DS:
10895 case R_PPC64_GOT16_LO_DS:
10896 dogot:
10897 {
10898 /* Relocation is to the entry for this symbol in the global
10899 offset table. */
10900 asection *got;
10901 bfd_vma *offp;
10902 bfd_vma off;
10903 unsigned long indx = 0;
10904
10905 if (tls_type == (TLS_TLS | TLS_LD)
10906 && (h == NULL
10907 || !h->elf.def_dynamic))
10908 offp = &ppc64_tlsld_got (input_bfd)->offset;
10909 else
10910 {
10911 struct got_entry *ent;
10912
10913 if (h != NULL)
10914 {
10915 bfd_boolean dyn = htab->elf.dynamic_sections_created;
10916 if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared,
10917 &h->elf)
10918 || (info->shared
10919 && SYMBOL_REFERENCES_LOCAL (info, &h->elf)))
10920 /* This is actually a static link, or it is a
10921 -Bsymbolic link and the symbol is defined
10922 locally, or the symbol was forced to be local
10923 because of a version file. */
10924 ;
10925 else
10926 {
10927 indx = h->elf.dynindx;
10928 unresolved_reloc = FALSE;
10929 }
10930 ent = h->elf.got.glist;
10931 }
10932 else
10933 {
10934 if (local_got_ents == NULL)
10935 abort ();
10936 ent = local_got_ents[r_symndx];
10937 }
10938
10939 for (; ent != NULL; ent = ent->next)
10940 if (ent->addend == orig_addend
10941 && ent->owner == input_bfd
10942 && ent->tls_type == tls_type)
10943 break;
10944 if (ent == NULL)
10945 abort ();
10946 offp = &ent->got.offset;
10947 }
10948
10949 got = ppc64_elf_tdata (input_bfd)->got;
10950 if (got == NULL)
10951 abort ();
10952
10953 /* The offset must always be a multiple of 8. We use the
10954 least significant bit to record whether we have already
10955 processed this entry. */
10956 off = *offp;
10957 if ((off & 1) != 0)
10958 off &= ~1;
10959 else
10960 {
10961 /* Generate relocs for the dynamic linker, except in
10962 the case of TLSLD where we'll use one entry per
10963 module. */
10964 asection *relgot = ppc64_elf_tdata (input_bfd)->relgot;
10965
10966 *offp = off | 1;
10967 if ((info->shared || indx != 0)
10968 && (offp == &ppc64_tlsld_got (input_bfd)->offset
10969 || h == NULL
10970 || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
10971 || h->elf.root.type != bfd_link_hash_undefweak))
10972 {
10973 outrel.r_offset = (got->output_section->vma
10974 + got->output_offset
10975 + off);
10976 outrel.r_addend = addend;
10977 if (tls_type & (TLS_LD | TLS_GD))
10978 {
10979 outrel.r_addend = 0;
10980 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPMOD64);
10981 if (tls_type == (TLS_TLS | TLS_GD))
10982 {
10983 loc = relgot->contents;
10984 loc += (relgot->reloc_count++
10985 * sizeof (Elf64_External_Rela));
10986 bfd_elf64_swap_reloca_out (output_bfd,
10987 &outrel, loc);
10988 outrel.r_offset += 8;
10989 outrel.r_addend = addend;
10990 outrel.r_info
10991 = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
10992 }
10993 }
10994 else if (tls_type == (TLS_TLS | TLS_DTPREL))
10995 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
10996 else if (tls_type == (TLS_TLS | TLS_TPREL))
10997 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_TPREL64);
10998 else if (indx == 0)
10999 {
11000 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_RELATIVE);
11001
11002 /* Write the .got section contents for the sake
11003 of prelink. */
11004 loc = got->contents + off;
11005 bfd_put_64 (output_bfd, outrel.r_addend + relocation,
11006 loc);
11007 }
11008 else
11009 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_GLOB_DAT);
11010
11011 if (indx == 0 && tls_type != (TLS_TLS | TLS_LD))
11012 {
11013 outrel.r_addend += relocation;
11014 if (tls_type & (TLS_GD | TLS_DTPREL | TLS_TPREL))
11015 outrel.r_addend -= htab->elf.tls_sec->vma;
11016 }
11017 loc = relgot->contents;
11018 loc += (relgot->reloc_count++
11019 * sizeof (Elf64_External_Rela));
11020 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
11021 }
11022
11023 /* Init the .got section contents here if we're not
11024 emitting a reloc. */
11025 else
11026 {
11027 relocation += addend;
11028 if (tls_type == (TLS_TLS | TLS_LD))
11029 relocation = 1;
11030 else if (tls_type != 0)
11031 {
11032 relocation -= htab->elf.tls_sec->vma + DTP_OFFSET;
11033 if (tls_type == (TLS_TLS | TLS_TPREL))
11034 relocation += DTP_OFFSET - TP_OFFSET;
11035
11036 if (tls_type == (TLS_TLS | TLS_GD))
11037 {
11038 bfd_put_64 (output_bfd, relocation,
11039 got->contents + off + 8);
11040 relocation = 1;
11041 }
11042 }
11043
11044 bfd_put_64 (output_bfd, relocation,
11045 got->contents + off);
11046 }
11047 }
11048
11049 if (off >= (bfd_vma) -2)
11050 abort ();
11051
11052 relocation = got->output_offset + off;
11053
11054 /* TOC base (r2) is TOC start plus 0x8000. */
11055 addend = -TOC_BASE_OFF;
11056 }
11057 break;
11058
11059 case R_PPC64_PLT16_HA:
11060 case R_PPC64_PLT16_HI:
11061 case R_PPC64_PLT16_LO:
11062 case R_PPC64_PLT32:
11063 case R_PPC64_PLT64:
11064 /* Relocation is to the entry for this symbol in the
11065 procedure linkage table. */
11066
11067 /* Resolve a PLT reloc against a local symbol directly,
11068 without using the procedure linkage table. */
11069 if (h == NULL)
11070 break;
11071
11072 /* It's possible that we didn't make a PLT entry for this
11073 symbol. This happens when statically linking PIC code,
11074 or when using -Bsymbolic. Go find a match if there is a
11075 PLT entry. */
11076 if (htab->plt != NULL)
11077 {
11078 struct plt_entry *ent;
11079 for (ent = h->elf.plt.plist; ent != NULL; ent = ent->next)
11080 if (ent->addend == orig_addend
11081 && ent->plt.offset != (bfd_vma) -1)
11082 {
11083 relocation = (htab->plt->output_section->vma
11084 + htab->plt->output_offset
11085 + ent->plt.offset);
11086 unresolved_reloc = FALSE;
11087 }
11088 }
11089 break;
11090
11091 case R_PPC64_TOC:
11092 /* Relocation value is TOC base. */
11093 relocation = TOCstart;
11094 if (r_symndx == 0)
11095 relocation += htab->stub_group[input_section->id].toc_off;
11096 else if (unresolved_reloc)
11097 ;
11098 else if (sec != NULL && sec->id <= htab->top_id)
11099 relocation += htab->stub_group[sec->id].toc_off;
11100 else
11101 unresolved_reloc = TRUE;
11102 goto dodyn;
11103
11104 /* TOC16 relocs. We want the offset relative to the TOC base,
11105 which is the address of the start of the TOC plus 0x8000.
11106 The TOC consists of sections .got, .toc, .tocbss, and .plt,
11107 in this order. */
11108 case R_PPC64_TOC16:
11109 case R_PPC64_TOC16_LO:
11110 case R_PPC64_TOC16_HI:
11111 case R_PPC64_TOC16_DS:
11112 case R_PPC64_TOC16_LO_DS:
11113 case R_PPC64_TOC16_HA:
11114 addend -= TOCstart + htab->stub_group[input_section->id].toc_off;
11115 break;
11116
11117 /* Relocate against the beginning of the section. */
11118 case R_PPC64_SECTOFF:
11119 case R_PPC64_SECTOFF_LO:
11120 case R_PPC64_SECTOFF_HI:
11121 case R_PPC64_SECTOFF_DS:
11122 case R_PPC64_SECTOFF_LO_DS:
11123 case R_PPC64_SECTOFF_HA:
11124 if (sec != NULL)
11125 addend -= sec->output_section->vma;
11126 break;
11127
11128 case R_PPC64_REL14:
11129 case R_PPC64_REL14_BRNTAKEN:
11130 case R_PPC64_REL14_BRTAKEN:
11131 case R_PPC64_REL24:
11132 break;
11133
11134 case R_PPC64_TPREL16:
11135 case R_PPC64_TPREL16_LO:
11136 case R_PPC64_TPREL16_HI:
11137 case R_PPC64_TPREL16_HA:
11138 case R_PPC64_TPREL16_DS:
11139 case R_PPC64_TPREL16_LO_DS:
11140 case R_PPC64_TPREL16_HIGHER:
11141 case R_PPC64_TPREL16_HIGHERA:
11142 case R_PPC64_TPREL16_HIGHEST:
11143 case R_PPC64_TPREL16_HIGHESTA:
11144 addend -= htab->elf.tls_sec->vma + TP_OFFSET;
11145 if (info->shared)
11146 /* The TPREL16 relocs shouldn't really be used in shared
11147 libs as they will result in DT_TEXTREL being set, but
11148 support them anyway. */
11149 goto dodyn;
11150 break;
11151
11152 case R_PPC64_DTPREL16:
11153 case R_PPC64_DTPREL16_LO:
11154 case R_PPC64_DTPREL16_HI:
11155 case R_PPC64_DTPREL16_HA:
11156 case R_PPC64_DTPREL16_DS:
11157 case R_PPC64_DTPREL16_LO_DS:
11158 case R_PPC64_DTPREL16_HIGHER:
11159 case R_PPC64_DTPREL16_HIGHERA:
11160 case R_PPC64_DTPREL16_HIGHEST:
11161 case R_PPC64_DTPREL16_HIGHESTA:
11162 addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
11163 break;
11164
11165 case R_PPC64_DTPMOD64:
11166 relocation = 1;
11167 addend = 0;
11168 goto dodyn;
11169
11170 case R_PPC64_TPREL64:
11171 addend -= htab->elf.tls_sec->vma + TP_OFFSET;
11172 goto dodyn;
11173
11174 case R_PPC64_DTPREL64:
11175 addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
11176 /* Fall thru */
11177
11178 /* Relocations that may need to be propagated if this is a
11179 dynamic object. */
11180 case R_PPC64_REL30:
11181 case R_PPC64_REL32:
11182 case R_PPC64_REL64:
11183 case R_PPC64_ADDR14:
11184 case R_PPC64_ADDR14_BRNTAKEN:
11185 case R_PPC64_ADDR14_BRTAKEN:
11186 case R_PPC64_ADDR16:
11187 case R_PPC64_ADDR16_DS:
11188 case R_PPC64_ADDR16_HA:
11189 case R_PPC64_ADDR16_HI:
11190 case R_PPC64_ADDR16_HIGHER:
11191 case R_PPC64_ADDR16_HIGHERA:
11192 case R_PPC64_ADDR16_HIGHEST:
11193 case R_PPC64_ADDR16_HIGHESTA:
11194 case R_PPC64_ADDR16_LO:
11195 case R_PPC64_ADDR16_LO_DS:
11196 case R_PPC64_ADDR24:
11197 case R_PPC64_ADDR32:
11198 case R_PPC64_ADDR64:
11199 case R_PPC64_UADDR16:
11200 case R_PPC64_UADDR32:
11201 case R_PPC64_UADDR64:
11202 dodyn:
11203 if ((input_section->flags & SEC_ALLOC) == 0)
11204 break;
11205
11206 if (NO_OPD_RELOCS && is_opd)
11207 break;
11208
11209 if ((info->shared
11210 && (h == NULL
11211 || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
11212 || h->elf.root.type != bfd_link_hash_undefweak)
11213 && (must_be_dyn_reloc (info, r_type)
11214 || !SYMBOL_CALLS_LOCAL (info, &h->elf)))
11215 || (ELIMINATE_COPY_RELOCS
11216 && !info->shared
11217 && h != NULL
11218 && h->elf.dynindx != -1
11219 && !h->elf.non_got_ref
11220 && !h->elf.def_regular))
11221 {
11222 Elf_Internal_Rela outrel;
11223 bfd_boolean skip, relocate;
11224 asection *sreloc;
11225 bfd_byte *loc;
11226 bfd_vma out_off;
11227
11228 /* When generating a dynamic object, these relocations
11229 are copied into the output file to be resolved at run
11230 time. */
11231
11232 skip = FALSE;
11233 relocate = FALSE;
11234
11235 out_off = _bfd_elf_section_offset (output_bfd, info,
11236 input_section, rel->r_offset);
11237 if (out_off == (bfd_vma) -1)
11238 skip = TRUE;
11239 else if (out_off == (bfd_vma) -2)
11240 skip = TRUE, relocate = TRUE;
11241 out_off += (input_section->output_section->vma
11242 + input_section->output_offset);
11243 outrel.r_offset = out_off;
11244 outrel.r_addend = rel->r_addend;
11245
11246 /* Optimize unaligned reloc use. */
11247 if ((r_type == R_PPC64_ADDR64 && (out_off & 7) != 0)
11248 || (r_type == R_PPC64_UADDR64 && (out_off & 7) == 0))
11249 r_type ^= R_PPC64_ADDR64 ^ R_PPC64_UADDR64;
11250 else if ((r_type == R_PPC64_ADDR32 && (out_off & 3) != 0)
11251 || (r_type == R_PPC64_UADDR32 && (out_off & 3) == 0))
11252 r_type ^= R_PPC64_ADDR32 ^ R_PPC64_UADDR32;
11253 else if ((r_type == R_PPC64_ADDR16 && (out_off & 1) != 0)
11254 || (r_type == R_PPC64_UADDR16 && (out_off & 1) == 0))
11255 r_type ^= R_PPC64_ADDR16 ^ R_PPC64_UADDR16;
11256
11257 if (skip)
11258 memset (&outrel, 0, sizeof outrel);
11259 else if (!SYMBOL_REFERENCES_LOCAL (info, &h->elf)
11260 && !is_opd
11261 && r_type != R_PPC64_TOC)
11262 outrel.r_info = ELF64_R_INFO (h->elf.dynindx, r_type);
11263 else
11264 {
11265 /* This symbol is local, or marked to become local,
11266 or this is an opd section reloc which must point
11267 at a local function. */
11268 outrel.r_addend += relocation;
11269 if (r_type == R_PPC64_ADDR64 || r_type == R_PPC64_TOC)
11270 {
11271 if (is_opd && h != NULL)
11272 {
11273 /* Lie about opd entries. This case occurs
11274 when building shared libraries and we
11275 reference a function in another shared
11276 lib. The same thing happens for a weak
11277 definition in an application that's
11278 overridden by a strong definition in a
11279 shared lib. (I believe this is a generic
11280 bug in binutils handling of weak syms.)
11281 In these cases we won't use the opd
11282 entry in this lib. */
11283 unresolved_reloc = FALSE;
11284 }
11285 outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
11286
11287 /* We need to relocate .opd contents for ld.so.
11288 Prelink also wants simple and consistent rules
11289 for relocs. This make all RELATIVE relocs have
11290 *r_offset equal to r_addend. */
11291 relocate = TRUE;
11292 }
11293 else
11294 {
11295 long indx = 0;
11296
11297 if (r_symndx == 0 || bfd_is_abs_section (sec))
11298 ;
11299 else if (sec == NULL || sec->owner == NULL)
11300 {
11301 bfd_set_error (bfd_error_bad_value);
11302 return FALSE;
11303 }
11304 else
11305 {
11306 asection *osec;
11307
11308 osec = sec->output_section;
11309 indx = elf_section_data (osec)->dynindx;
11310
11311 if (indx == 0)
11312 {
11313 if ((osec->flags & SEC_READONLY) == 0
11314 && htab->elf.data_index_section != NULL)
11315 osec = htab->elf.data_index_section;
11316 else
11317 osec = htab->elf.text_index_section;
11318 indx = elf_section_data (osec)->dynindx;
11319 }
11320 BFD_ASSERT (indx != 0);
11321
11322 /* We are turning this relocation into one
11323 against a section symbol, so subtract out
11324 the output section's address but not the
11325 offset of the input section in the output
11326 section. */
11327 outrel.r_addend -= osec->vma;
11328 }
11329
11330 outrel.r_info = ELF64_R_INFO (indx, r_type);
11331 }
11332 }
11333
11334 sreloc = elf_section_data (input_section)->sreloc;
11335 if (sreloc == NULL)
11336 abort ();
11337
11338 if (sreloc->reloc_count * sizeof (Elf64_External_Rela)
11339 >= sreloc->size)
11340 abort ();
11341 loc = sreloc->contents;
11342 loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
11343 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
11344
11345 /* If this reloc is against an external symbol, it will
11346 be computed at runtime, so there's no need to do
11347 anything now. However, for the sake of prelink ensure
11348 that the section contents are a known value. */
11349 if (! relocate)
11350 {
11351 unresolved_reloc = FALSE;
11352 /* The value chosen here is quite arbitrary as ld.so
11353 ignores section contents except for the special
11354 case of .opd where the contents might be accessed
11355 before relocation. Choose zero, as that won't
11356 cause reloc overflow. */
11357 relocation = 0;
11358 addend = 0;
11359 /* Use *r_offset == r_addend for R_PPC64_ADDR64 relocs
11360 to improve backward compatibility with older
11361 versions of ld. */
11362 if (r_type == R_PPC64_ADDR64)
11363 addend = outrel.r_addend;
11364 /* Adjust pc_relative relocs to have zero in *r_offset. */
11365 else if (ppc64_elf_howto_table[r_type]->pc_relative)
11366 addend = (input_section->output_section->vma
11367 + input_section->output_offset
11368 + rel->r_offset);
11369 }
11370 }
11371 break;
11372
11373 case R_PPC64_COPY:
11374 case R_PPC64_GLOB_DAT:
11375 case R_PPC64_JMP_SLOT:
11376 case R_PPC64_RELATIVE:
11377 /* We shouldn't ever see these dynamic relocs in relocatable
11378 files. */
11379 /* Fall through. */
11380
11381 case R_PPC64_PLTGOT16:
11382 case R_PPC64_PLTGOT16_DS:
11383 case R_PPC64_PLTGOT16_HA:
11384 case R_PPC64_PLTGOT16_HI:
11385 case R_PPC64_PLTGOT16_LO:
11386 case R_PPC64_PLTGOT16_LO_DS:
11387 case R_PPC64_PLTREL32:
11388 case R_PPC64_PLTREL64:
11389 /* These ones haven't been implemented yet. */
11390
11391 (*_bfd_error_handler)
11392 (_("%B: relocation %s is not supported for symbol %s."),
11393 input_bfd,
11394 ppc64_elf_howto_table[r_type]->name, sym_name);
11395
11396 bfd_set_error (bfd_error_invalid_operation);
11397 ret = FALSE;
11398 continue;
11399 }
11400
11401 /* Do any further special processing. */
11402 switch (r_type)
11403 {
11404 default:
11405 break;
11406
11407 case R_PPC64_ADDR16_HA:
11408 case R_PPC64_ADDR16_HIGHERA:
11409 case R_PPC64_ADDR16_HIGHESTA:
11410 case R_PPC64_TOC16_HA:
11411 case R_PPC64_SECTOFF_HA:
11412 case R_PPC64_TPREL16_HA:
11413 case R_PPC64_DTPREL16_HA:
11414 case R_PPC64_TPREL16_HIGHER:
11415 case R_PPC64_TPREL16_HIGHERA:
11416 case R_PPC64_TPREL16_HIGHEST:
11417 case R_PPC64_TPREL16_HIGHESTA:
11418 case R_PPC64_DTPREL16_HIGHER:
11419 case R_PPC64_DTPREL16_HIGHERA:
11420 case R_PPC64_DTPREL16_HIGHEST:
11421 case R_PPC64_DTPREL16_HIGHESTA:
11422 /* It's just possible that this symbol is a weak symbol
11423 that's not actually defined anywhere. In that case,
11424 'sec' would be NULL, and we should leave the symbol
11425 alone (it will be set to zero elsewhere in the link). */
11426 if (sec == NULL)
11427 break;
11428 /* Fall thru */
11429
11430 case R_PPC64_GOT16_HA:
11431 case R_PPC64_PLTGOT16_HA:
11432 case R_PPC64_PLT16_HA:
11433 case R_PPC64_GOT_TLSGD16_HA:
11434 case R_PPC64_GOT_TLSLD16_HA:
11435 case R_PPC64_GOT_TPREL16_HA:
11436 case R_PPC64_GOT_DTPREL16_HA:
11437 /* Add 0x10000 if sign bit in 0:15 is set.
11438 Bits 0:15 are not used. */
11439 addend += 0x8000;
11440 break;
11441
11442 case R_PPC64_ADDR16_DS:
11443 case R_PPC64_ADDR16_LO_DS:
11444 case R_PPC64_GOT16_DS:
11445 case R_PPC64_GOT16_LO_DS:
11446 case R_PPC64_PLT16_LO_DS:
11447 case R_PPC64_SECTOFF_DS:
11448 case R_PPC64_SECTOFF_LO_DS:
11449 case R_PPC64_TOC16_DS:
11450 case R_PPC64_TOC16_LO_DS:
11451 case R_PPC64_PLTGOT16_DS:
11452 case R_PPC64_PLTGOT16_LO_DS:
11453 case R_PPC64_GOT_TPREL16_DS:
11454 case R_PPC64_GOT_TPREL16_LO_DS:
11455 case R_PPC64_GOT_DTPREL16_DS:
11456 case R_PPC64_GOT_DTPREL16_LO_DS:
11457 case R_PPC64_TPREL16_DS:
11458 case R_PPC64_TPREL16_LO_DS:
11459 case R_PPC64_DTPREL16_DS:
11460 case R_PPC64_DTPREL16_LO_DS:
11461 insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
11462 mask = 3;
11463 /* If this reloc is against an lq insn, then the value must be
11464 a multiple of 16. This is somewhat of a hack, but the
11465 "correct" way to do this by defining _DQ forms of all the
11466 _DS relocs bloats all reloc switches in this file. It
11467 doesn't seem to make much sense to use any of these relocs
11468 in data, so testing the insn should be safe. */
11469 if ((insn & (0x3f << 26)) == (56u << 26))
11470 mask = 15;
11471 if (((relocation + addend) & mask) != 0)
11472 {
11473 (*_bfd_error_handler)
11474 (_("%B: error: relocation %s not a multiple of %d"),
11475 input_bfd,
11476 ppc64_elf_howto_table[r_type]->name,
11477 mask + 1);
11478 bfd_set_error (bfd_error_bad_value);
11479 ret = FALSE;
11480 continue;
11481 }
11482 break;
11483 }
11484
11485 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
11486 because such sections are not SEC_ALLOC and thus ld.so will
11487 not process them. */
11488 if (unresolved_reloc
11489 && !((input_section->flags & SEC_DEBUGGING) != 0
11490 && h->elf.def_dynamic))
11491 {
11492 (*_bfd_error_handler)
11493 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
11494 input_bfd,
11495 input_section,
11496 (long) rel->r_offset,
11497 ppc64_elf_howto_table[(int) r_type]->name,
11498 h->elf.root.root.string);
11499 ret = FALSE;
11500 }
11501
11502 r = _bfd_final_link_relocate (ppc64_elf_howto_table[(int) r_type],
11503 input_bfd,
11504 input_section,
11505 contents,
11506 rel->r_offset,
11507 relocation,
11508 addend);
11509
11510 if (r != bfd_reloc_ok)
11511 {
11512 if (sym_name == NULL)
11513 sym_name = "(null)";
11514 if (r == bfd_reloc_overflow)
11515 {
11516 if (warned)
11517 continue;
11518 if (h != NULL
11519 && h->elf.root.type == bfd_link_hash_undefweak
11520 && ppc64_elf_howto_table[r_type]->pc_relative)
11521 {
11522 /* Assume this is a call protected by other code that
11523 detects the symbol is undefined. If this is the case,
11524 we can safely ignore the overflow. If not, the
11525 program is hosed anyway, and a little warning isn't
11526 going to help. */
11527
11528 continue;
11529 }
11530
11531 if (!((*info->callbacks->reloc_overflow)
11532 (info, (h ? &h->elf.root : NULL), sym_name,
11533 ppc64_elf_howto_table[r_type]->name,
11534 orig_addend, input_bfd, input_section, rel->r_offset)))
11535 return FALSE;
11536 }
11537 else
11538 {
11539 (*_bfd_error_handler)
11540 (_("%B(%A+0x%lx): %s reloc against `%s': error %d"),
11541 input_bfd,
11542 input_section,
11543 (long) rel->r_offset,
11544 ppc64_elf_howto_table[r_type]->name,
11545 sym_name,
11546 (int) r);
11547 ret = FALSE;
11548 }
11549 }
11550 }
11551
11552 /* If we're emitting relocations, then shortly after this function
11553 returns, reloc offsets and addends for this section will be
11554 adjusted. Worse, reloc symbol indices will be for the output
11555 file rather than the input. Save a copy of the relocs for
11556 opd_entry_value. */
11557 if (is_opd && (info->emitrelocations || info->relocatable))
11558 {
11559 bfd_size_type amt;
11560 amt = input_section->reloc_count * sizeof (Elf_Internal_Rela);
11561 rel = bfd_alloc (input_bfd, amt);
11562 BFD_ASSERT (ppc64_elf_tdata (input_bfd)->opd_relocs == NULL);
11563 ppc64_elf_tdata (input_bfd)->opd_relocs = rel;
11564 if (rel == NULL)
11565 return FALSE;
11566 memcpy (rel, relocs, amt);
11567 }
11568 return ret;
11569 }
11570
11571 /* Adjust the value of any local symbols in opd sections. */
11572
11573 static bfd_boolean
11574 ppc64_elf_output_symbol_hook (struct bfd_link_info *info,
11575 const char *name ATTRIBUTE_UNUSED,
11576 Elf_Internal_Sym *elfsym,
11577 asection *input_sec,
11578 struct elf_link_hash_entry *h)
11579 {
11580 struct _opd_sec_data *opd;
11581 long adjust;
11582 bfd_vma value;
11583
11584 if (h != NULL)
11585 return TRUE;
11586
11587 opd = get_opd_info (input_sec);
11588 if (opd == NULL || opd->adjust == NULL)
11589 return TRUE;
11590
11591 value = elfsym->st_value - input_sec->output_offset;
11592 if (!info->relocatable)
11593 value -= input_sec->output_section->vma;
11594
11595 adjust = opd->adjust[value / 8];
11596 if (adjust == -1)
11597 elfsym->st_value = 0;
11598 else
11599 elfsym->st_value += adjust;
11600 return TRUE;
11601 }
11602
11603 /* Finish up dynamic symbol handling. We set the contents of various
11604 dynamic sections here. */
11605
11606 static bfd_boolean
11607 ppc64_elf_finish_dynamic_symbol (bfd *output_bfd,
11608 struct bfd_link_info *info,
11609 struct elf_link_hash_entry *h,
11610 Elf_Internal_Sym *sym)
11611 {
11612 struct ppc_link_hash_table *htab;
11613 struct plt_entry *ent;
11614 Elf_Internal_Rela rela;
11615 bfd_byte *loc;
11616
11617 htab = ppc_hash_table (info);
11618
11619 for (ent = h->plt.plist; ent != NULL; ent = ent->next)
11620 if (ent->plt.offset != (bfd_vma) -1)
11621 {
11622 /* This symbol has an entry in the procedure linkage
11623 table. Set it up. */
11624
11625 if (htab->plt == NULL
11626 || htab->relplt == NULL
11627 || htab->glink == NULL)
11628 abort ();
11629
11630 /* Create a JMP_SLOT reloc to inform the dynamic linker to
11631 fill in the PLT entry. */
11632 rela.r_offset = (htab->plt->output_section->vma
11633 + htab->plt->output_offset
11634 + ent->plt.offset);
11635 rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_JMP_SLOT);
11636 rela.r_addend = ent->addend;
11637
11638 loc = htab->relplt->contents;
11639 loc += ((ent->plt.offset - PLT_INITIAL_ENTRY_SIZE) / PLT_ENTRY_SIZE
11640 * sizeof (Elf64_External_Rela));
11641 bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
11642 }
11643
11644 if (h->needs_copy)
11645 {
11646 Elf_Internal_Rela rela;
11647 bfd_byte *loc;
11648
11649 /* This symbol needs a copy reloc. Set it up. */
11650
11651 if (h->dynindx == -1
11652 || (h->root.type != bfd_link_hash_defined
11653 && h->root.type != bfd_link_hash_defweak)
11654 || htab->relbss == NULL)
11655 abort ();
11656
11657 rela.r_offset = (h->root.u.def.value
11658 + h->root.u.def.section->output_section->vma
11659 + h->root.u.def.section->output_offset);
11660 rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_COPY);
11661 rela.r_addend = 0;
11662 loc = htab->relbss->contents;
11663 loc += htab->relbss->reloc_count++ * sizeof (Elf64_External_Rela);
11664 bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
11665 }
11666
11667 /* Mark some specially defined symbols as absolute. */
11668 if (strcmp (h->root.root.string, "_DYNAMIC") == 0)
11669 sym->st_shndx = SHN_ABS;
11670
11671 return TRUE;
11672 }
11673
11674 /* Used to decide how to sort relocs in an optimal manner for the
11675 dynamic linker, before writing them out. */
11676
11677 static enum elf_reloc_type_class
11678 ppc64_elf_reloc_type_class (const Elf_Internal_Rela *rela)
11679 {
11680 enum elf_ppc64_reloc_type r_type;
11681
11682 r_type = ELF64_R_TYPE (rela->r_info);
11683 switch (r_type)
11684 {
11685 case R_PPC64_RELATIVE:
11686 return reloc_class_relative;
11687 case R_PPC64_JMP_SLOT:
11688 return reloc_class_plt;
11689 case R_PPC64_COPY:
11690 return reloc_class_copy;
11691 default:
11692 return reloc_class_normal;
11693 }
11694 }
11695
11696 /* Finish up the dynamic sections. */
11697
11698 static bfd_boolean
11699 ppc64_elf_finish_dynamic_sections (bfd *output_bfd,
11700 struct bfd_link_info *info)
11701 {
11702 struct ppc_link_hash_table *htab;
11703 bfd *dynobj;
11704 asection *sdyn;
11705
11706 htab = ppc_hash_table (info);
11707 dynobj = htab->elf.dynobj;
11708 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
11709
11710 if (htab->elf.dynamic_sections_created)
11711 {
11712 Elf64_External_Dyn *dyncon, *dynconend;
11713
11714 if (sdyn == NULL || htab->got == NULL)
11715 abort ();
11716
11717 dyncon = (Elf64_External_Dyn *) sdyn->contents;
11718 dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
11719 for (; dyncon < dynconend; dyncon++)
11720 {
11721 Elf_Internal_Dyn dyn;
11722 asection *s;
11723
11724 bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
11725
11726 switch (dyn.d_tag)
11727 {
11728 default:
11729 continue;
11730
11731 case DT_PPC64_GLINK:
11732 s = htab->glink;
11733 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
11734 /* We stupidly defined DT_PPC64_GLINK to be the start
11735 of glink rather than the first entry point, which is
11736 what ld.so needs, and now have a bigger stub to
11737 support automatic multiple TOCs. */
11738 dyn.d_un.d_ptr += GLINK_CALL_STUB_SIZE - 32;
11739 break;
11740
11741 case DT_PPC64_OPD:
11742 s = bfd_get_section_by_name (output_bfd, ".opd");
11743 if (s == NULL)
11744 continue;
11745 dyn.d_un.d_ptr = s->vma;
11746 break;
11747
11748 case DT_PPC64_OPDSZ:
11749 s = bfd_get_section_by_name (output_bfd, ".opd");
11750 if (s == NULL)
11751 continue;
11752 dyn.d_un.d_val = s->size;
11753 break;
11754
11755 case DT_PLTGOT:
11756 s = htab->plt;
11757 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
11758 break;
11759
11760 case DT_JMPREL:
11761 s = htab->relplt;
11762 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
11763 break;
11764
11765 case DT_PLTRELSZ:
11766 dyn.d_un.d_val = htab->relplt->size;
11767 break;
11768
11769 case DT_RELASZ:
11770 /* Don't count procedure linkage table relocs in the
11771 overall reloc count. */
11772 s = htab->relplt;
11773 if (s == NULL)
11774 continue;
11775 dyn.d_un.d_val -= s->size;
11776 break;
11777
11778 case DT_RELA:
11779 /* We may not be using the standard ELF linker script.
11780 If .rela.plt is the first .rela section, we adjust
11781 DT_RELA to not include it. */
11782 s = htab->relplt;
11783 if (s == NULL)
11784 continue;
11785 if (dyn.d_un.d_ptr != s->output_section->vma + s->output_offset)
11786 continue;
11787 dyn.d_un.d_ptr += s->size;
11788 break;
11789 }
11790
11791 bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
11792 }
11793 }
11794
11795 if (htab->got != NULL && htab->got->size != 0)
11796 {
11797 /* Fill in the first entry in the global offset table.
11798 We use it to hold the link-time TOCbase. */
11799 bfd_put_64 (output_bfd,
11800 elf_gp (output_bfd) + TOC_BASE_OFF,
11801 htab->got->contents);
11802
11803 /* Set .got entry size. */
11804 elf_section_data (htab->got->output_section)->this_hdr.sh_entsize = 8;
11805 }
11806
11807 if (htab->plt != NULL && htab->plt->size != 0)
11808 {
11809 /* Set .plt entry size. */
11810 elf_section_data (htab->plt->output_section)->this_hdr.sh_entsize
11811 = PLT_ENTRY_SIZE;
11812 }
11813
11814 /* brlt is SEC_LINKER_CREATED, so we need to write out relocs for
11815 brlt ourselves if emitrelocations. */
11816 if (htab->brlt != NULL
11817 && htab->brlt->reloc_count != 0
11818 && !_bfd_elf_link_output_relocs (output_bfd,
11819 htab->brlt,
11820 &elf_section_data (htab->brlt)->rel_hdr,
11821 elf_section_data (htab->brlt)->relocs,
11822 NULL))
11823 return FALSE;
11824
11825 if (htab->glink != NULL
11826 && htab->glink->reloc_count != 0
11827 && !_bfd_elf_link_output_relocs (output_bfd,
11828 htab->glink,
11829 &elf_section_data (htab->glink)->rel_hdr,
11830 elf_section_data (htab->glink)->relocs,
11831 NULL))
11832 return FALSE;
11833
11834 /* We need to handle writing out multiple GOT sections ourselves,
11835 since we didn't add them to DYNOBJ. We know dynobj is the first
11836 bfd. */
11837 while ((dynobj = dynobj->link_next) != NULL)
11838 {
11839 asection *s;
11840
11841 if (!is_ppc64_elf (dynobj))
11842 continue;
11843
11844 s = ppc64_elf_tdata (dynobj)->got;
11845 if (s != NULL
11846 && s->size != 0
11847 && s->output_section != bfd_abs_section_ptr
11848 && !bfd_set_section_contents (output_bfd, s->output_section,
11849 s->contents, s->output_offset,
11850 s->size))
11851 return FALSE;
11852 s = ppc64_elf_tdata (dynobj)->relgot;
11853 if (s != NULL
11854 && s->size != 0
11855 && s->output_section != bfd_abs_section_ptr
11856 && !bfd_set_section_contents (output_bfd, s->output_section,
11857 s->contents, s->output_offset,
11858 s->size))
11859 return FALSE;
11860 }
11861
11862 return TRUE;
11863 }
11864
11865 #include "elf64-target.h"
git-cvsimport of binutils cvsroot