PR 2434
[binutils.git] / bfd / elf64-ppc.c
blobfc8c182e83da94b31000c62349cd3a9e7d322a2e
1 /* PowerPC64-specific support for 64-bit ELF.
2 Copyright 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006
3 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>
8 This file is part of BFD, the Binary File Descriptor library.
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 2 of the License, or
13 (at your option) any later version.
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.
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. */
24 /* The 64-bit PowerPC ELF ABI may be found at
25 http://www.linuxbase.org/spec/ELF/ppc64/PPC-elf64abi.txt, and
26 http://www.linuxbase.org/spec/ELF/ppc64/spec/book1.html */
28 #include "bfd.h"
29 #include "sysdep.h"
30 #include "bfdlink.h"
31 #include "libbfd.h"
32 #include "elf-bfd.h"
33 #include "elf/ppc64.h"
34 #include "elf64-ppc.h"
36 static bfd_reloc_status_type ppc64_elf_ha_reloc
37 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
38 static bfd_reloc_status_type ppc64_elf_branch_reloc
39 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
40 static bfd_reloc_status_type ppc64_elf_brtaken_reloc
41 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
42 static bfd_reloc_status_type ppc64_elf_sectoff_reloc
43 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
44 static bfd_reloc_status_type ppc64_elf_sectoff_ha_reloc
45 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
46 static bfd_reloc_status_type ppc64_elf_toc_reloc
47 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
48 static bfd_reloc_status_type ppc64_elf_toc_ha_reloc
49 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
50 static bfd_reloc_status_type ppc64_elf_toc64_reloc
51 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
52 static bfd_reloc_status_type ppc64_elf_unhandled_reloc
53 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
54 static bfd_vma opd_entry_value
55 (asection *, bfd_vma, asection **, bfd_vma *);
57 #define TARGET_LITTLE_SYM bfd_elf64_powerpcle_vec
58 #define TARGET_LITTLE_NAME "elf64-powerpcle"
59 #define TARGET_BIG_SYM bfd_elf64_powerpc_vec
60 #define TARGET_BIG_NAME "elf64-powerpc"
61 #define ELF_ARCH bfd_arch_powerpc
62 #define ELF_MACHINE_CODE EM_PPC64
63 #define ELF_MAXPAGESIZE 0x10000
64 #define elf_info_to_howto ppc64_elf_info_to_howto
66 #define elf_backend_want_got_sym 0
67 #define elf_backend_want_plt_sym 0
68 #define elf_backend_plt_alignment 3
69 #define elf_backend_plt_not_loaded 1
70 #define elf_backend_got_header_size 8
71 #define elf_backend_can_gc_sections 1
72 #define elf_backend_can_refcount 1
73 #define elf_backend_rela_normal 1
75 #define bfd_elf64_mkobject ppc64_elf_mkobject
76 #define bfd_elf64_bfd_reloc_type_lookup ppc64_elf_reloc_type_lookup
77 #define bfd_elf64_bfd_merge_private_bfd_data ppc64_elf_merge_private_bfd_data
78 #define bfd_elf64_new_section_hook ppc64_elf_new_section_hook
79 #define bfd_elf64_bfd_link_hash_table_create ppc64_elf_link_hash_table_create
80 #define bfd_elf64_bfd_link_hash_table_free ppc64_elf_link_hash_table_free
81 #define bfd_elf64_get_synthetic_symtab ppc64_elf_get_synthetic_symtab
83 #define elf_backend_object_p ppc64_elf_object_p
84 #define elf_backend_grok_prstatus ppc64_elf_grok_prstatus
85 #define elf_backend_grok_psinfo ppc64_elf_grok_psinfo
86 #define elf_backend_create_dynamic_sections ppc64_elf_create_dynamic_sections
87 #define elf_backend_copy_indirect_symbol ppc64_elf_copy_indirect_symbol
88 #define elf_backend_add_symbol_hook ppc64_elf_add_symbol_hook
89 #define elf_backend_check_directives ppc64_elf_check_directives
90 #define elf_backend_archive_symbol_lookup ppc64_elf_archive_symbol_lookup
91 #define elf_backend_check_relocs ppc64_elf_check_relocs
92 #define elf_backend_gc_mark_dynamic_ref ppc64_elf_gc_mark_dynamic_ref
93 #define elf_backend_gc_mark_hook ppc64_elf_gc_mark_hook
94 #define elf_backend_gc_sweep_hook ppc64_elf_gc_sweep_hook
95 #define elf_backend_adjust_dynamic_symbol ppc64_elf_adjust_dynamic_symbol
96 #define elf_backend_hide_symbol ppc64_elf_hide_symbol
97 #define elf_backend_always_size_sections ppc64_elf_func_desc_adjust
98 #define elf_backend_size_dynamic_sections ppc64_elf_size_dynamic_sections
99 #define elf_backend_action_discarded ppc64_elf_action_discarded
100 #define elf_backend_relocate_section ppc64_elf_relocate_section
101 #define elf_backend_finish_dynamic_symbol ppc64_elf_finish_dynamic_symbol
102 #define elf_backend_reloc_type_class ppc64_elf_reloc_type_class
103 #define elf_backend_finish_dynamic_sections ppc64_elf_finish_dynamic_sections
104 #define elf_backend_link_output_symbol_hook ppc64_elf_output_symbol_hook
105 #define elf_backend_special_sections ppc64_elf_special_sections
107 /* The name of the dynamic interpreter. This is put in the .interp
108 section. */
109 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
111 /* The size in bytes of an entry in the procedure linkage table. */
112 #define PLT_ENTRY_SIZE 24
114 /* The initial size of the plt reserved for the dynamic linker. */
115 #define PLT_INITIAL_ENTRY_SIZE PLT_ENTRY_SIZE
117 /* TOC base pointers offset from start of TOC. */
118 #define TOC_BASE_OFF 0x8000
120 /* Offset of tp and dtp pointers from start of TLS block. */
121 #define TP_OFFSET 0x7000
122 #define DTP_OFFSET 0x8000
124 /* .plt call stub instructions. The normal stub is like this, but
125 sometimes the .plt entry crosses a 64k boundary and we need to
126 insert an addis to adjust r12. */
127 #define PLT_CALL_STUB_SIZE (7*4)
128 #define ADDIS_R12_R2 0x3d820000 /* addis %r12,%r2,xxx@ha */
129 #define STD_R2_40R1 0xf8410028 /* std %r2,40(%r1) */
130 #define LD_R11_0R12 0xe96c0000 /* ld %r11,xxx+0@l(%r12) */
131 #define LD_R2_0R12 0xe84c0000 /* ld %r2,xxx+8@l(%r12) */
132 #define MTCTR_R11 0x7d6903a6 /* mtctr %r11 */
133 /* ld %r11,xxx+16@l(%r12) */
134 #define BCTR 0x4e800420 /* bctr */
137 #define ADDIS_R2_R2 0x3c420000 /* addis %r2,%r2,off@ha */
138 #define ADDI_R2_R2 0x38420000 /* addi %r2,%r2,off@l */
140 #define LD_R2_40R1 0xe8410028 /* ld %r2,40(%r1) */
142 /* glink call stub instructions. We enter with the index in R0, and the
143 address of glink entry in CTR. From that, we can calculate PLT0. */
144 #define GLINK_CALL_STUB_SIZE (16*4)
145 #define MFCTR_R12 0x7d8902a6 /* mfctr %r12 */
146 #define SLDI_R11_R0_3 0x780b1f24 /* sldi %r11,%r0,3 */
147 #define ADDIC_R2_R0_32K 0x34408000 /* addic. %r2,%r0,-32768 */
148 #define SUB_R12_R12_R11 0x7d8b6050 /* sub %r12,%r12,%r11 */
149 #define SRADI_R2_R2_63 0x7c42fe76 /* sradi %r2,%r2,63 */
150 #define SLDI_R11_R0_2 0x780b1764 /* sldi %r11,%r0,2 */
151 #define AND_R2_R2_R11 0x7c425838 /* and %r2,%r2,%r11 */
152 /* sub %r12,%r12,%r11 */
153 #define ADD_R12_R12_R2 0x7d8c1214 /* add %r12,%r12,%r2 */
154 #define ADDIS_R12_R12 0x3d8c0000 /* addis %r12,%r12,xxx@ha */
155 /* ld %r11,xxx@l(%r12) */
156 #define ADDI_R12_R12 0x398c0000 /* addi %r12,%r12,xxx@l */
157 /* ld %r2,8(%r12) */
158 /* mtctr %r11 */
159 /* ld %r11,16(%r12) */
160 /* bctr */
162 /* Pad with this. */
163 #define NOP 0x60000000
165 /* Some other nops. */
166 #define CROR_151515 0x4def7b82
167 #define CROR_313131 0x4ffffb82
169 /* .glink entries for the first 32k functions are two instructions. */
170 #define LI_R0_0 0x38000000 /* li %r0,0 */
171 #define B_DOT 0x48000000 /* b . */
173 /* After that, we need two instructions to load the index, followed by
174 a branch. */
175 #define LIS_R0_0 0x3c000000 /* lis %r0,0 */
176 #define ORI_R0_R0_0 0x60000000 /* ori %r0,%r0,0 */
178 /* Instructions used by the save and restore reg functions. */
179 #define STD_R0_0R1 0xf8010000 /* std %r0,0(%r1) */
180 #define STD_R0_0R12 0xf80c0000 /* std %r0,0(%r12) */
181 #define LD_R0_0R1 0xe8010000 /* ld %r0,0(%r1) */
182 #define LD_R0_0R12 0xe80c0000 /* ld %r0,0(%r12) */
183 #define STFD_FR0_0R1 0xd8010000 /* stfd %fr0,0(%r1) */
184 #define LFD_FR0_0R1 0xc8010000 /* lfd %fr0,0(%r1) */
185 #define LI_R12_0 0x39800000 /* li %r12,0 */
186 #define STVX_VR0_R12_R0 0x7c0c01ce /* stvx %v0,%r12,%r0 */
187 #define LVX_VR0_R12_R0 0x7c0c00ce /* lvx %v0,%r12,%r0 */
188 #define MTLR_R0 0x7c0803a6 /* mtlr %r0 */
189 #define BLR 0x4e800020 /* blr */
191 /* Since .opd is an array of descriptors and each entry will end up
192 with identical R_PPC64_RELATIVE relocs, there is really no need to
193 propagate .opd relocs; The dynamic linker should be taught to
194 relocate .opd without reloc entries. */
195 #ifndef NO_OPD_RELOCS
196 #define NO_OPD_RELOCS 0
197 #endif
199 #define ONES(n) (((bfd_vma) 1 << ((n) - 1) << 1) - 1)
201 /* Relocation HOWTO's. */
202 static reloc_howto_type *ppc64_elf_howto_table[(int) R_PPC64_max];
204 static reloc_howto_type ppc64_elf_howto_raw[] = {
205 /* This reloc does nothing. */
206 HOWTO (R_PPC64_NONE, /* type */
207 0, /* rightshift */
208 2, /* size (0 = byte, 1 = short, 2 = long) */
209 32, /* bitsize */
210 FALSE, /* pc_relative */
211 0, /* bitpos */
212 complain_overflow_dont, /* complain_on_overflow */
213 bfd_elf_generic_reloc, /* special_function */
214 "R_PPC64_NONE", /* name */
215 FALSE, /* partial_inplace */
216 0, /* src_mask */
217 0, /* dst_mask */
218 FALSE), /* pcrel_offset */
220 /* A standard 32 bit relocation. */
221 HOWTO (R_PPC64_ADDR32, /* type */
222 0, /* rightshift */
223 2, /* size (0 = byte, 1 = short, 2 = long) */
224 32, /* bitsize */
225 FALSE, /* pc_relative */
226 0, /* bitpos */
227 complain_overflow_bitfield, /* complain_on_overflow */
228 bfd_elf_generic_reloc, /* special_function */
229 "R_PPC64_ADDR32", /* name */
230 FALSE, /* partial_inplace */
231 0, /* src_mask */
232 0xffffffff, /* dst_mask */
233 FALSE), /* pcrel_offset */
235 /* An absolute 26 bit branch; the lower two bits must be zero.
236 FIXME: we don't check that, we just clear them. */
237 HOWTO (R_PPC64_ADDR24, /* type */
238 0, /* rightshift */
239 2, /* size (0 = byte, 1 = short, 2 = long) */
240 26, /* bitsize */
241 FALSE, /* pc_relative */
242 0, /* bitpos */
243 complain_overflow_bitfield, /* complain_on_overflow */
244 bfd_elf_generic_reloc, /* special_function */
245 "R_PPC64_ADDR24", /* name */
246 FALSE, /* partial_inplace */
247 0, /* src_mask */
248 0x03fffffc, /* dst_mask */
249 FALSE), /* pcrel_offset */
251 /* A standard 16 bit relocation. */
252 HOWTO (R_PPC64_ADDR16, /* type */
253 0, /* rightshift */
254 1, /* size (0 = byte, 1 = short, 2 = long) */
255 16, /* bitsize */
256 FALSE, /* pc_relative */
257 0, /* bitpos */
258 complain_overflow_bitfield, /* complain_on_overflow */
259 bfd_elf_generic_reloc, /* special_function */
260 "R_PPC64_ADDR16", /* name */
261 FALSE, /* partial_inplace */
262 0, /* src_mask */
263 0xffff, /* dst_mask */
264 FALSE), /* pcrel_offset */
266 /* A 16 bit relocation without overflow. */
267 HOWTO (R_PPC64_ADDR16_LO, /* type */
268 0, /* rightshift */
269 1, /* size (0 = byte, 1 = short, 2 = long) */
270 16, /* bitsize */
271 FALSE, /* pc_relative */
272 0, /* bitpos */
273 complain_overflow_dont,/* complain_on_overflow */
274 bfd_elf_generic_reloc, /* special_function */
275 "R_PPC64_ADDR16_LO", /* name */
276 FALSE, /* partial_inplace */
277 0, /* src_mask */
278 0xffff, /* dst_mask */
279 FALSE), /* pcrel_offset */
281 /* Bits 16-31 of an address. */
282 HOWTO (R_PPC64_ADDR16_HI, /* type */
283 16, /* rightshift */
284 1, /* size (0 = byte, 1 = short, 2 = long) */
285 16, /* bitsize */
286 FALSE, /* pc_relative */
287 0, /* bitpos */
288 complain_overflow_dont, /* complain_on_overflow */
289 bfd_elf_generic_reloc, /* special_function */
290 "R_PPC64_ADDR16_HI", /* name */
291 FALSE, /* partial_inplace */
292 0, /* src_mask */
293 0xffff, /* dst_mask */
294 FALSE), /* pcrel_offset */
296 /* Bits 16-31 of an address, plus 1 if the contents of the low 16
297 bits, treated as a signed number, is negative. */
298 HOWTO (R_PPC64_ADDR16_HA, /* type */
299 16, /* rightshift */
300 1, /* size (0 = byte, 1 = short, 2 = long) */
301 16, /* bitsize */
302 FALSE, /* pc_relative */
303 0, /* bitpos */
304 complain_overflow_dont, /* complain_on_overflow */
305 ppc64_elf_ha_reloc, /* special_function */
306 "R_PPC64_ADDR16_HA", /* name */
307 FALSE, /* partial_inplace */
308 0, /* src_mask */
309 0xffff, /* dst_mask */
310 FALSE), /* pcrel_offset */
312 /* An absolute 16 bit branch; the lower two bits must be zero.
313 FIXME: we don't check that, we just clear them. */
314 HOWTO (R_PPC64_ADDR14, /* type */
315 0, /* rightshift */
316 2, /* size (0 = byte, 1 = short, 2 = long) */
317 16, /* bitsize */
318 FALSE, /* pc_relative */
319 0, /* bitpos */
320 complain_overflow_bitfield, /* complain_on_overflow */
321 ppc64_elf_branch_reloc, /* special_function */
322 "R_PPC64_ADDR14", /* name */
323 FALSE, /* partial_inplace */
324 0, /* src_mask */
325 0x0000fffc, /* dst_mask */
326 FALSE), /* pcrel_offset */
328 /* An absolute 16 bit branch, for which bit 10 should be set to
329 indicate that the branch is expected to be taken. The lower two
330 bits must be zero. */
331 HOWTO (R_PPC64_ADDR14_BRTAKEN, /* type */
332 0, /* rightshift */
333 2, /* size (0 = byte, 1 = short, 2 = long) */
334 16, /* bitsize */
335 FALSE, /* pc_relative */
336 0, /* bitpos */
337 complain_overflow_bitfield, /* complain_on_overflow */
338 ppc64_elf_brtaken_reloc, /* special_function */
339 "R_PPC64_ADDR14_BRTAKEN",/* name */
340 FALSE, /* partial_inplace */
341 0, /* src_mask */
342 0x0000fffc, /* dst_mask */
343 FALSE), /* pcrel_offset */
345 /* An absolute 16 bit branch, for which bit 10 should be set to
346 indicate that the branch is not expected to be taken. The lower
347 two bits must be zero. */
348 HOWTO (R_PPC64_ADDR14_BRNTAKEN, /* type */
349 0, /* rightshift */
350 2, /* size (0 = byte, 1 = short, 2 = long) */
351 16, /* bitsize */
352 FALSE, /* pc_relative */
353 0, /* bitpos */
354 complain_overflow_bitfield, /* complain_on_overflow */
355 ppc64_elf_brtaken_reloc, /* special_function */
356 "R_PPC64_ADDR14_BRNTAKEN",/* name */
357 FALSE, /* partial_inplace */
358 0, /* src_mask */
359 0x0000fffc, /* dst_mask */
360 FALSE), /* pcrel_offset */
362 /* A relative 26 bit branch; the lower two bits must be zero. */
363 HOWTO (R_PPC64_REL24, /* type */
364 0, /* rightshift */
365 2, /* size (0 = byte, 1 = short, 2 = long) */
366 26, /* bitsize */
367 TRUE, /* pc_relative */
368 0, /* bitpos */
369 complain_overflow_signed, /* complain_on_overflow */
370 ppc64_elf_branch_reloc, /* special_function */
371 "R_PPC64_REL24", /* name */
372 FALSE, /* partial_inplace */
373 0, /* src_mask */
374 0x03fffffc, /* dst_mask */
375 TRUE), /* pcrel_offset */
377 /* A relative 16 bit branch; the lower two bits must be zero. */
378 HOWTO (R_PPC64_REL14, /* type */
379 0, /* rightshift */
380 2, /* size (0 = byte, 1 = short, 2 = long) */
381 16, /* bitsize */
382 TRUE, /* pc_relative */
383 0, /* bitpos */
384 complain_overflow_signed, /* complain_on_overflow */
385 ppc64_elf_branch_reloc, /* special_function */
386 "R_PPC64_REL14", /* name */
387 FALSE, /* partial_inplace */
388 0, /* src_mask */
389 0x0000fffc, /* dst_mask */
390 TRUE), /* pcrel_offset */
392 /* A relative 16 bit branch. Bit 10 should be set to indicate that
393 the branch is expected to be taken. The lower two bits must be
394 zero. */
395 HOWTO (R_PPC64_REL14_BRTAKEN, /* type */
396 0, /* rightshift */
397 2, /* size (0 = byte, 1 = short, 2 = long) */
398 16, /* bitsize */
399 TRUE, /* pc_relative */
400 0, /* bitpos */
401 complain_overflow_signed, /* complain_on_overflow */
402 ppc64_elf_brtaken_reloc, /* special_function */
403 "R_PPC64_REL14_BRTAKEN", /* name */
404 FALSE, /* partial_inplace */
405 0, /* src_mask */
406 0x0000fffc, /* dst_mask */
407 TRUE), /* pcrel_offset */
409 /* A relative 16 bit branch. Bit 10 should be set to indicate that
410 the branch is not expected to be taken. The lower two bits must
411 be zero. */
412 HOWTO (R_PPC64_REL14_BRNTAKEN, /* type */
413 0, /* rightshift */
414 2, /* size (0 = byte, 1 = short, 2 = long) */
415 16, /* bitsize */
416 TRUE, /* pc_relative */
417 0, /* bitpos */
418 complain_overflow_signed, /* complain_on_overflow */
419 ppc64_elf_brtaken_reloc, /* special_function */
420 "R_PPC64_REL14_BRNTAKEN",/* name */
421 FALSE, /* partial_inplace */
422 0, /* src_mask */
423 0x0000fffc, /* dst_mask */
424 TRUE), /* pcrel_offset */
426 /* Like R_PPC64_ADDR16, but referring to the GOT table entry for the
427 symbol. */
428 HOWTO (R_PPC64_GOT16, /* type */
429 0, /* rightshift */
430 1, /* size (0 = byte, 1 = short, 2 = long) */
431 16, /* bitsize */
432 FALSE, /* pc_relative */
433 0, /* bitpos */
434 complain_overflow_signed, /* complain_on_overflow */
435 ppc64_elf_unhandled_reloc, /* special_function */
436 "R_PPC64_GOT16", /* name */
437 FALSE, /* partial_inplace */
438 0, /* src_mask */
439 0xffff, /* dst_mask */
440 FALSE), /* pcrel_offset */
442 /* Like R_PPC64_ADDR16_LO, but referring to the GOT table entry for
443 the symbol. */
444 HOWTO (R_PPC64_GOT16_LO, /* type */
445 0, /* rightshift */
446 1, /* size (0 = byte, 1 = short, 2 = long) */
447 16, /* bitsize */
448 FALSE, /* pc_relative */
449 0, /* bitpos */
450 complain_overflow_dont, /* complain_on_overflow */
451 ppc64_elf_unhandled_reloc, /* special_function */
452 "R_PPC64_GOT16_LO", /* name */
453 FALSE, /* partial_inplace */
454 0, /* src_mask */
455 0xffff, /* dst_mask */
456 FALSE), /* pcrel_offset */
458 /* Like R_PPC64_ADDR16_HI, but referring to the GOT table entry for
459 the symbol. */
460 HOWTO (R_PPC64_GOT16_HI, /* type */
461 16, /* rightshift */
462 1, /* size (0 = byte, 1 = short, 2 = long) */
463 16, /* bitsize */
464 FALSE, /* pc_relative */
465 0, /* bitpos */
466 complain_overflow_dont,/* complain_on_overflow */
467 ppc64_elf_unhandled_reloc, /* special_function */
468 "R_PPC64_GOT16_HI", /* name */
469 FALSE, /* partial_inplace */
470 0, /* src_mask */
471 0xffff, /* dst_mask */
472 FALSE), /* pcrel_offset */
474 /* Like R_PPC64_ADDR16_HA, but referring to the GOT table entry for
475 the symbol. */
476 HOWTO (R_PPC64_GOT16_HA, /* type */
477 16, /* rightshift */
478 1, /* size (0 = byte, 1 = short, 2 = long) */
479 16, /* bitsize */
480 FALSE, /* pc_relative */
481 0, /* bitpos */
482 complain_overflow_dont,/* complain_on_overflow */
483 ppc64_elf_unhandled_reloc, /* special_function */
484 "R_PPC64_GOT16_HA", /* name */
485 FALSE, /* partial_inplace */
486 0, /* src_mask */
487 0xffff, /* dst_mask */
488 FALSE), /* pcrel_offset */
490 /* This is used only by the dynamic linker. The symbol should exist
491 both in the object being run and in some shared library. The
492 dynamic linker copies the data addressed by the symbol from the
493 shared library into the object, because the object being
494 run has to have the data at some particular address. */
495 HOWTO (R_PPC64_COPY, /* type */
496 0, /* rightshift */
497 0, /* this one is variable size */
498 0, /* bitsize */
499 FALSE, /* pc_relative */
500 0, /* bitpos */
501 complain_overflow_dont, /* complain_on_overflow */
502 ppc64_elf_unhandled_reloc, /* special_function */
503 "R_PPC64_COPY", /* name */
504 FALSE, /* partial_inplace */
505 0, /* src_mask */
506 0, /* dst_mask */
507 FALSE), /* pcrel_offset */
509 /* Like R_PPC64_ADDR64, but used when setting global offset table
510 entries. */
511 HOWTO (R_PPC64_GLOB_DAT, /* type */
512 0, /* rightshift */
513 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
514 64, /* bitsize */
515 FALSE, /* pc_relative */
516 0, /* bitpos */
517 complain_overflow_dont, /* complain_on_overflow */
518 ppc64_elf_unhandled_reloc, /* special_function */
519 "R_PPC64_GLOB_DAT", /* name */
520 FALSE, /* partial_inplace */
521 0, /* src_mask */
522 ONES (64), /* dst_mask */
523 FALSE), /* pcrel_offset */
525 /* Created by the link editor. Marks a procedure linkage table
526 entry for a symbol. */
527 HOWTO (R_PPC64_JMP_SLOT, /* type */
528 0, /* rightshift */
529 0, /* size (0 = byte, 1 = short, 2 = long) */
530 0, /* bitsize */
531 FALSE, /* pc_relative */
532 0, /* bitpos */
533 complain_overflow_dont, /* complain_on_overflow */
534 ppc64_elf_unhandled_reloc, /* special_function */
535 "R_PPC64_JMP_SLOT", /* name */
536 FALSE, /* partial_inplace */
537 0, /* src_mask */
538 0, /* dst_mask */
539 FALSE), /* pcrel_offset */
541 /* Used only by the dynamic linker. When the object is run, this
542 doubleword64 is set to the load address of the object, plus the
543 addend. */
544 HOWTO (R_PPC64_RELATIVE, /* type */
545 0, /* rightshift */
546 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
547 64, /* bitsize */
548 FALSE, /* pc_relative */
549 0, /* bitpos */
550 complain_overflow_dont, /* complain_on_overflow */
551 bfd_elf_generic_reloc, /* special_function */
552 "R_PPC64_RELATIVE", /* name */
553 FALSE, /* partial_inplace */
554 0, /* src_mask */
555 ONES (64), /* dst_mask */
556 FALSE), /* pcrel_offset */
558 /* Like R_PPC64_ADDR32, but may be unaligned. */
559 HOWTO (R_PPC64_UADDR32, /* type */
560 0, /* rightshift */
561 2, /* size (0 = byte, 1 = short, 2 = long) */
562 32, /* bitsize */
563 FALSE, /* pc_relative */
564 0, /* bitpos */
565 complain_overflow_bitfield, /* complain_on_overflow */
566 bfd_elf_generic_reloc, /* special_function */
567 "R_PPC64_UADDR32", /* name */
568 FALSE, /* partial_inplace */
569 0, /* src_mask */
570 0xffffffff, /* dst_mask */
571 FALSE), /* pcrel_offset */
573 /* Like R_PPC64_ADDR16, but may be unaligned. */
574 HOWTO (R_PPC64_UADDR16, /* type */
575 0, /* rightshift */
576 1, /* size (0 = byte, 1 = short, 2 = long) */
577 16, /* bitsize */
578 FALSE, /* pc_relative */
579 0, /* bitpos */
580 complain_overflow_bitfield, /* complain_on_overflow */
581 bfd_elf_generic_reloc, /* special_function */
582 "R_PPC64_UADDR16", /* name */
583 FALSE, /* partial_inplace */
584 0, /* src_mask */
585 0xffff, /* dst_mask */
586 FALSE), /* pcrel_offset */
588 /* 32-bit PC relative. */
589 HOWTO (R_PPC64_REL32, /* type */
590 0, /* rightshift */
591 2, /* size (0 = byte, 1 = short, 2 = long) */
592 32, /* bitsize */
593 TRUE, /* pc_relative */
594 0, /* bitpos */
595 /* FIXME: Verify. Was complain_overflow_bitfield. */
596 complain_overflow_signed, /* complain_on_overflow */
597 bfd_elf_generic_reloc, /* special_function */
598 "R_PPC64_REL32", /* name */
599 FALSE, /* partial_inplace */
600 0, /* src_mask */
601 0xffffffff, /* dst_mask */
602 TRUE), /* pcrel_offset */
604 /* 32-bit relocation to the symbol's procedure linkage table. */
605 HOWTO (R_PPC64_PLT32, /* type */
606 0, /* rightshift */
607 2, /* size (0 = byte, 1 = short, 2 = long) */
608 32, /* bitsize */
609 FALSE, /* pc_relative */
610 0, /* bitpos */
611 complain_overflow_bitfield, /* complain_on_overflow */
612 ppc64_elf_unhandled_reloc, /* special_function */
613 "R_PPC64_PLT32", /* name */
614 FALSE, /* partial_inplace */
615 0, /* src_mask */
616 0xffffffff, /* dst_mask */
617 FALSE), /* pcrel_offset */
619 /* 32-bit PC relative relocation to the symbol's procedure linkage table.
620 FIXME: R_PPC64_PLTREL32 not supported. */
621 HOWTO (R_PPC64_PLTREL32, /* type */
622 0, /* rightshift */
623 2, /* size (0 = byte, 1 = short, 2 = long) */
624 32, /* bitsize */
625 TRUE, /* pc_relative */
626 0, /* bitpos */
627 complain_overflow_signed, /* complain_on_overflow */
628 bfd_elf_generic_reloc, /* special_function */
629 "R_PPC64_PLTREL32", /* name */
630 FALSE, /* partial_inplace */
631 0, /* src_mask */
632 0xffffffff, /* dst_mask */
633 TRUE), /* pcrel_offset */
635 /* Like R_PPC64_ADDR16_LO, but referring to the PLT table entry for
636 the symbol. */
637 HOWTO (R_PPC64_PLT16_LO, /* type */
638 0, /* rightshift */
639 1, /* size (0 = byte, 1 = short, 2 = long) */
640 16, /* bitsize */
641 FALSE, /* pc_relative */
642 0, /* bitpos */
643 complain_overflow_dont, /* complain_on_overflow */
644 ppc64_elf_unhandled_reloc, /* special_function */
645 "R_PPC64_PLT16_LO", /* name */
646 FALSE, /* partial_inplace */
647 0, /* src_mask */
648 0xffff, /* dst_mask */
649 FALSE), /* pcrel_offset */
651 /* Like R_PPC64_ADDR16_HI, but referring to the PLT table entry for
652 the symbol. */
653 HOWTO (R_PPC64_PLT16_HI, /* type */
654 16, /* rightshift */
655 1, /* size (0 = byte, 1 = short, 2 = long) */
656 16, /* bitsize */
657 FALSE, /* pc_relative */
658 0, /* bitpos */
659 complain_overflow_dont, /* complain_on_overflow */
660 ppc64_elf_unhandled_reloc, /* special_function */
661 "R_PPC64_PLT16_HI", /* name */
662 FALSE, /* partial_inplace */
663 0, /* src_mask */
664 0xffff, /* dst_mask */
665 FALSE), /* pcrel_offset */
667 /* Like R_PPC64_ADDR16_HA, but referring to the PLT table entry for
668 the symbol. */
669 HOWTO (R_PPC64_PLT16_HA, /* type */
670 16, /* rightshift */
671 1, /* size (0 = byte, 1 = short, 2 = long) */
672 16, /* bitsize */
673 FALSE, /* pc_relative */
674 0, /* bitpos */
675 complain_overflow_dont, /* complain_on_overflow */
676 ppc64_elf_unhandled_reloc, /* special_function */
677 "R_PPC64_PLT16_HA", /* name */
678 FALSE, /* partial_inplace */
679 0, /* src_mask */
680 0xffff, /* dst_mask */
681 FALSE), /* pcrel_offset */
683 /* 16-bit section relative relocation. */
684 HOWTO (R_PPC64_SECTOFF, /* type */
685 0, /* rightshift */
686 1, /* size (0 = byte, 1 = short, 2 = long) */
687 16, /* bitsize */
688 FALSE, /* pc_relative */
689 0, /* bitpos */
690 complain_overflow_bitfield, /* complain_on_overflow */
691 ppc64_elf_sectoff_reloc, /* special_function */
692 "R_PPC64_SECTOFF", /* name */
693 FALSE, /* partial_inplace */
694 0, /* src_mask */
695 0xffff, /* dst_mask */
696 FALSE), /* pcrel_offset */
698 /* Like R_PPC64_SECTOFF, but no overflow warning. */
699 HOWTO (R_PPC64_SECTOFF_LO, /* type */
700 0, /* rightshift */
701 1, /* size (0 = byte, 1 = short, 2 = long) */
702 16, /* bitsize */
703 FALSE, /* pc_relative */
704 0, /* bitpos */
705 complain_overflow_dont, /* complain_on_overflow */
706 ppc64_elf_sectoff_reloc, /* special_function */
707 "R_PPC64_SECTOFF_LO", /* name */
708 FALSE, /* partial_inplace */
709 0, /* src_mask */
710 0xffff, /* dst_mask */
711 FALSE), /* pcrel_offset */
713 /* 16-bit upper half section relative relocation. */
714 HOWTO (R_PPC64_SECTOFF_HI, /* type */
715 16, /* rightshift */
716 1, /* size (0 = byte, 1 = short, 2 = long) */
717 16, /* bitsize */
718 FALSE, /* pc_relative */
719 0, /* bitpos */
720 complain_overflow_dont, /* complain_on_overflow */
721 ppc64_elf_sectoff_reloc, /* special_function */
722 "R_PPC64_SECTOFF_HI", /* name */
723 FALSE, /* partial_inplace */
724 0, /* src_mask */
725 0xffff, /* dst_mask */
726 FALSE), /* pcrel_offset */
728 /* 16-bit upper half adjusted section relative relocation. */
729 HOWTO (R_PPC64_SECTOFF_HA, /* type */
730 16, /* rightshift */
731 1, /* size (0 = byte, 1 = short, 2 = long) */
732 16, /* bitsize */
733 FALSE, /* pc_relative */
734 0, /* bitpos */
735 complain_overflow_dont, /* complain_on_overflow */
736 ppc64_elf_sectoff_ha_reloc, /* special_function */
737 "R_PPC64_SECTOFF_HA", /* name */
738 FALSE, /* partial_inplace */
739 0, /* src_mask */
740 0xffff, /* dst_mask */
741 FALSE), /* pcrel_offset */
743 /* Like R_PPC64_REL24 without touching the two least significant bits. */
744 HOWTO (R_PPC64_REL30, /* type */
745 2, /* rightshift */
746 2, /* size (0 = byte, 1 = short, 2 = long) */
747 30, /* bitsize */
748 TRUE, /* pc_relative */
749 0, /* bitpos */
750 complain_overflow_dont, /* complain_on_overflow */
751 bfd_elf_generic_reloc, /* special_function */
752 "R_PPC64_REL30", /* name */
753 FALSE, /* partial_inplace */
754 0, /* src_mask */
755 0xfffffffc, /* dst_mask */
756 TRUE), /* pcrel_offset */
758 /* Relocs in the 64-bit PowerPC ELF ABI, not in the 32-bit ABI. */
760 /* A standard 64-bit relocation. */
761 HOWTO (R_PPC64_ADDR64, /* type */
762 0, /* rightshift */
763 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
764 64, /* bitsize */
765 FALSE, /* pc_relative */
766 0, /* bitpos */
767 complain_overflow_dont, /* complain_on_overflow */
768 bfd_elf_generic_reloc, /* special_function */
769 "R_PPC64_ADDR64", /* name */
770 FALSE, /* partial_inplace */
771 0, /* src_mask */
772 ONES (64), /* dst_mask */
773 FALSE), /* pcrel_offset */
775 /* The bits 32-47 of an address. */
776 HOWTO (R_PPC64_ADDR16_HIGHER, /* type */
777 32, /* rightshift */
778 1, /* size (0 = byte, 1 = short, 2 = long) */
779 16, /* bitsize */
780 FALSE, /* pc_relative */
781 0, /* bitpos */
782 complain_overflow_dont, /* complain_on_overflow */
783 bfd_elf_generic_reloc, /* special_function */
784 "R_PPC64_ADDR16_HIGHER", /* name */
785 FALSE, /* partial_inplace */
786 0, /* src_mask */
787 0xffff, /* dst_mask */
788 FALSE), /* pcrel_offset */
790 /* The bits 32-47 of an address, plus 1 if the contents of the low
791 16 bits, treated as a signed number, is negative. */
792 HOWTO (R_PPC64_ADDR16_HIGHERA, /* type */
793 32, /* rightshift */
794 1, /* size (0 = byte, 1 = short, 2 = long) */
795 16, /* bitsize */
796 FALSE, /* pc_relative */
797 0, /* bitpos */
798 complain_overflow_dont, /* complain_on_overflow */
799 ppc64_elf_ha_reloc, /* special_function */
800 "R_PPC64_ADDR16_HIGHERA", /* name */
801 FALSE, /* partial_inplace */
802 0, /* src_mask */
803 0xffff, /* dst_mask */
804 FALSE), /* pcrel_offset */
806 /* The bits 48-63 of an address. */
807 HOWTO (R_PPC64_ADDR16_HIGHEST,/* type */
808 48, /* rightshift */
809 1, /* size (0 = byte, 1 = short, 2 = long) */
810 16, /* bitsize */
811 FALSE, /* pc_relative */
812 0, /* bitpos */
813 complain_overflow_dont, /* complain_on_overflow */
814 bfd_elf_generic_reloc, /* special_function */
815 "R_PPC64_ADDR16_HIGHEST", /* name */
816 FALSE, /* partial_inplace */
817 0, /* src_mask */
818 0xffff, /* dst_mask */
819 FALSE), /* pcrel_offset */
821 /* The bits 48-63 of an address, plus 1 if the contents of the low
822 16 bits, treated as a signed number, is negative. */
823 HOWTO (R_PPC64_ADDR16_HIGHESTA,/* type */
824 48, /* rightshift */
825 1, /* size (0 = byte, 1 = short, 2 = long) */
826 16, /* bitsize */
827 FALSE, /* pc_relative */
828 0, /* bitpos */
829 complain_overflow_dont, /* complain_on_overflow */
830 ppc64_elf_ha_reloc, /* special_function */
831 "R_PPC64_ADDR16_HIGHESTA", /* name */
832 FALSE, /* partial_inplace */
833 0, /* src_mask */
834 0xffff, /* dst_mask */
835 FALSE), /* pcrel_offset */
837 /* Like ADDR64, but may be unaligned. */
838 HOWTO (R_PPC64_UADDR64, /* type */
839 0, /* rightshift */
840 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
841 64, /* bitsize */
842 FALSE, /* pc_relative */
843 0, /* bitpos */
844 complain_overflow_dont, /* complain_on_overflow */
845 bfd_elf_generic_reloc, /* special_function */
846 "R_PPC64_UADDR64", /* name */
847 FALSE, /* partial_inplace */
848 0, /* src_mask */
849 ONES (64), /* dst_mask */
850 FALSE), /* pcrel_offset */
852 /* 64-bit relative relocation. */
853 HOWTO (R_PPC64_REL64, /* type */
854 0, /* rightshift */
855 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
856 64, /* bitsize */
857 TRUE, /* pc_relative */
858 0, /* bitpos */
859 complain_overflow_dont, /* complain_on_overflow */
860 bfd_elf_generic_reloc, /* special_function */
861 "R_PPC64_REL64", /* name */
862 FALSE, /* partial_inplace */
863 0, /* src_mask */
864 ONES (64), /* dst_mask */
865 TRUE), /* pcrel_offset */
867 /* 64-bit relocation to the symbol's procedure linkage table. */
868 HOWTO (R_PPC64_PLT64, /* type */
869 0, /* rightshift */
870 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
871 64, /* bitsize */
872 FALSE, /* pc_relative */
873 0, /* bitpos */
874 complain_overflow_dont, /* complain_on_overflow */
875 ppc64_elf_unhandled_reloc, /* special_function */
876 "R_PPC64_PLT64", /* name */
877 FALSE, /* partial_inplace */
878 0, /* src_mask */
879 ONES (64), /* dst_mask */
880 FALSE), /* pcrel_offset */
882 /* 64-bit PC relative relocation to the symbol's procedure linkage
883 table. */
884 /* FIXME: R_PPC64_PLTREL64 not supported. */
885 HOWTO (R_PPC64_PLTREL64, /* type */
886 0, /* rightshift */
887 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
888 64, /* bitsize */
889 TRUE, /* pc_relative */
890 0, /* bitpos */
891 complain_overflow_dont, /* complain_on_overflow */
892 ppc64_elf_unhandled_reloc, /* special_function */
893 "R_PPC64_PLTREL64", /* name */
894 FALSE, /* partial_inplace */
895 0, /* src_mask */
896 ONES (64), /* dst_mask */
897 TRUE), /* pcrel_offset */
899 /* 16 bit TOC-relative relocation. */
901 /* R_PPC64_TOC16 47 half16* S + A - .TOC. */
902 HOWTO (R_PPC64_TOC16, /* type */
903 0, /* rightshift */
904 1, /* size (0 = byte, 1 = short, 2 = long) */
905 16, /* bitsize */
906 FALSE, /* pc_relative */
907 0, /* bitpos */
908 complain_overflow_signed, /* complain_on_overflow */
909 ppc64_elf_toc_reloc, /* special_function */
910 "R_PPC64_TOC16", /* name */
911 FALSE, /* partial_inplace */
912 0, /* src_mask */
913 0xffff, /* dst_mask */
914 FALSE), /* pcrel_offset */
916 /* 16 bit TOC-relative relocation without overflow. */
918 /* R_PPC64_TOC16_LO 48 half16 #lo (S + A - .TOC.) */
919 HOWTO (R_PPC64_TOC16_LO, /* type */
920 0, /* rightshift */
921 1, /* size (0 = byte, 1 = short, 2 = long) */
922 16, /* bitsize */
923 FALSE, /* pc_relative */
924 0, /* bitpos */
925 complain_overflow_dont, /* complain_on_overflow */
926 ppc64_elf_toc_reloc, /* special_function */
927 "R_PPC64_TOC16_LO", /* name */
928 FALSE, /* partial_inplace */
929 0, /* src_mask */
930 0xffff, /* dst_mask */
931 FALSE), /* pcrel_offset */
933 /* 16 bit TOC-relative relocation, high 16 bits. */
935 /* R_PPC64_TOC16_HI 49 half16 #hi (S + A - .TOC.) */
936 HOWTO (R_PPC64_TOC16_HI, /* type */
937 16, /* rightshift */
938 1, /* size (0 = byte, 1 = short, 2 = long) */
939 16, /* bitsize */
940 FALSE, /* pc_relative */
941 0, /* bitpos */
942 complain_overflow_dont, /* complain_on_overflow */
943 ppc64_elf_toc_reloc, /* special_function */
944 "R_PPC64_TOC16_HI", /* name */
945 FALSE, /* partial_inplace */
946 0, /* src_mask */
947 0xffff, /* dst_mask */
948 FALSE), /* pcrel_offset */
950 /* 16 bit TOC-relative relocation, high 16 bits, plus 1 if the
951 contents of the low 16 bits, treated as a signed number, is
952 negative. */
954 /* R_PPC64_TOC16_HA 50 half16 #ha (S + A - .TOC.) */
955 HOWTO (R_PPC64_TOC16_HA, /* type */
956 16, /* rightshift */
957 1, /* size (0 = byte, 1 = short, 2 = long) */
958 16, /* bitsize */
959 FALSE, /* pc_relative */
960 0, /* bitpos */
961 complain_overflow_dont, /* complain_on_overflow */
962 ppc64_elf_toc_ha_reloc, /* special_function */
963 "R_PPC64_TOC16_HA", /* name */
964 FALSE, /* partial_inplace */
965 0, /* src_mask */
966 0xffff, /* dst_mask */
967 FALSE), /* pcrel_offset */
969 /* 64-bit relocation; insert value of TOC base (.TOC.). */
971 /* R_PPC64_TOC 51 doubleword64 .TOC. */
972 HOWTO (R_PPC64_TOC, /* type */
973 0, /* rightshift */
974 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
975 64, /* bitsize */
976 FALSE, /* pc_relative */
977 0, /* bitpos */
978 complain_overflow_bitfield, /* complain_on_overflow */
979 ppc64_elf_toc64_reloc, /* special_function */
980 "R_PPC64_TOC", /* name */
981 FALSE, /* partial_inplace */
982 0, /* src_mask */
983 ONES (64), /* dst_mask */
984 FALSE), /* pcrel_offset */
986 /* Like R_PPC64_GOT16, but also informs the link editor that the
987 value to relocate may (!) refer to a PLT entry which the link
988 editor (a) may replace with the symbol value. If the link editor
989 is unable to fully resolve the symbol, it may (b) create a PLT
990 entry and store the address to the new PLT entry in the GOT.
991 This permits lazy resolution of function symbols at run time.
992 The link editor may also skip all of this and just (c) emit a
993 R_PPC64_GLOB_DAT to tie the symbol to the GOT entry. */
994 /* FIXME: R_PPC64_PLTGOT16 not implemented. */
995 HOWTO (R_PPC64_PLTGOT16, /* type */
996 0, /* rightshift */
997 1, /* size (0 = byte, 1 = short, 2 = long) */
998 16, /* bitsize */
999 FALSE, /* pc_relative */
1000 0, /* bitpos */
1001 complain_overflow_signed, /* complain_on_overflow */
1002 ppc64_elf_unhandled_reloc, /* special_function */
1003 "R_PPC64_PLTGOT16", /* name */
1004 FALSE, /* partial_inplace */
1005 0, /* src_mask */
1006 0xffff, /* dst_mask */
1007 FALSE), /* pcrel_offset */
1009 /* Like R_PPC64_PLTGOT16, but without overflow. */
1010 /* FIXME: R_PPC64_PLTGOT16_LO not implemented. */
1011 HOWTO (R_PPC64_PLTGOT16_LO, /* type */
1012 0, /* rightshift */
1013 1, /* size (0 = byte, 1 = short, 2 = long) */
1014 16, /* bitsize */
1015 FALSE, /* pc_relative */
1016 0, /* bitpos */
1017 complain_overflow_dont, /* complain_on_overflow */
1018 ppc64_elf_unhandled_reloc, /* special_function */
1019 "R_PPC64_PLTGOT16_LO", /* name */
1020 FALSE, /* partial_inplace */
1021 0, /* src_mask */
1022 0xffff, /* dst_mask */
1023 FALSE), /* pcrel_offset */
1025 /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address. */
1026 /* FIXME: R_PPC64_PLTGOT16_HI not implemented. */
1027 HOWTO (R_PPC64_PLTGOT16_HI, /* type */
1028 16, /* rightshift */
1029 1, /* size (0 = byte, 1 = short, 2 = long) */
1030 16, /* bitsize */
1031 FALSE, /* pc_relative */
1032 0, /* bitpos */
1033 complain_overflow_dont, /* complain_on_overflow */
1034 ppc64_elf_unhandled_reloc, /* special_function */
1035 "R_PPC64_PLTGOT16_HI", /* name */
1036 FALSE, /* partial_inplace */
1037 0, /* src_mask */
1038 0xffff, /* dst_mask */
1039 FALSE), /* pcrel_offset */
1041 /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address, plus
1042 1 if the contents of the low 16 bits, treated as a signed number,
1043 is negative. */
1044 /* FIXME: R_PPC64_PLTGOT16_HA not implemented. */
1045 HOWTO (R_PPC64_PLTGOT16_HA, /* type */
1046 16, /* rightshift */
1047 1, /* size (0 = byte, 1 = short, 2 = long) */
1048 16, /* bitsize */
1049 FALSE, /* pc_relative */
1050 0, /* bitpos */
1051 complain_overflow_dont,/* complain_on_overflow */
1052 ppc64_elf_unhandled_reloc, /* special_function */
1053 "R_PPC64_PLTGOT16_HA", /* name */
1054 FALSE, /* partial_inplace */
1055 0, /* src_mask */
1056 0xffff, /* dst_mask */
1057 FALSE), /* pcrel_offset */
1059 /* Like R_PPC64_ADDR16, but for instructions with a DS field. */
1060 HOWTO (R_PPC64_ADDR16_DS, /* type */
1061 0, /* rightshift */
1062 1, /* size (0 = byte, 1 = short, 2 = long) */
1063 16, /* bitsize */
1064 FALSE, /* pc_relative */
1065 0, /* bitpos */
1066 complain_overflow_bitfield, /* complain_on_overflow */
1067 bfd_elf_generic_reloc, /* special_function */
1068 "R_PPC64_ADDR16_DS", /* name */
1069 FALSE, /* partial_inplace */
1070 0, /* src_mask */
1071 0xfffc, /* dst_mask */
1072 FALSE), /* pcrel_offset */
1074 /* Like R_PPC64_ADDR16_LO, but for instructions with a DS field. */
1075 HOWTO (R_PPC64_ADDR16_LO_DS, /* type */
1076 0, /* rightshift */
1077 1, /* size (0 = byte, 1 = short, 2 = long) */
1078 16, /* bitsize */
1079 FALSE, /* pc_relative */
1080 0, /* bitpos */
1081 complain_overflow_dont,/* complain_on_overflow */
1082 bfd_elf_generic_reloc, /* special_function */
1083 "R_PPC64_ADDR16_LO_DS",/* name */
1084 FALSE, /* partial_inplace */
1085 0, /* src_mask */
1086 0xfffc, /* dst_mask */
1087 FALSE), /* pcrel_offset */
1089 /* Like R_PPC64_GOT16, but for instructions with a DS field. */
1090 HOWTO (R_PPC64_GOT16_DS, /* type */
1091 0, /* rightshift */
1092 1, /* size (0 = byte, 1 = short, 2 = long) */
1093 16, /* bitsize */
1094 FALSE, /* pc_relative */
1095 0, /* bitpos */
1096 complain_overflow_signed, /* complain_on_overflow */
1097 ppc64_elf_unhandled_reloc, /* special_function */
1098 "R_PPC64_GOT16_DS", /* name */
1099 FALSE, /* partial_inplace */
1100 0, /* src_mask */
1101 0xfffc, /* dst_mask */
1102 FALSE), /* pcrel_offset */
1104 /* Like R_PPC64_GOT16_LO, but for instructions with a DS field. */
1105 HOWTO (R_PPC64_GOT16_LO_DS, /* type */
1106 0, /* rightshift */
1107 1, /* size (0 = byte, 1 = short, 2 = long) */
1108 16, /* bitsize */
1109 FALSE, /* pc_relative */
1110 0, /* bitpos */
1111 complain_overflow_dont, /* complain_on_overflow */
1112 ppc64_elf_unhandled_reloc, /* special_function */
1113 "R_PPC64_GOT16_LO_DS", /* name */
1114 FALSE, /* partial_inplace */
1115 0, /* src_mask */
1116 0xfffc, /* dst_mask */
1117 FALSE), /* pcrel_offset */
1119 /* Like R_PPC64_PLT16_LO, but for instructions with a DS field. */
1120 HOWTO (R_PPC64_PLT16_LO_DS, /* type */
1121 0, /* rightshift */
1122 1, /* size (0 = byte, 1 = short, 2 = long) */
1123 16, /* bitsize */
1124 FALSE, /* pc_relative */
1125 0, /* bitpos */
1126 complain_overflow_dont, /* complain_on_overflow */
1127 ppc64_elf_unhandled_reloc, /* special_function */
1128 "R_PPC64_PLT16_LO_DS", /* name */
1129 FALSE, /* partial_inplace */
1130 0, /* src_mask */
1131 0xfffc, /* dst_mask */
1132 FALSE), /* pcrel_offset */
1134 /* Like R_PPC64_SECTOFF, but for instructions with a DS field. */
1135 HOWTO (R_PPC64_SECTOFF_DS, /* type */
1136 0, /* rightshift */
1137 1, /* size (0 = byte, 1 = short, 2 = long) */
1138 16, /* bitsize */
1139 FALSE, /* pc_relative */
1140 0, /* bitpos */
1141 complain_overflow_bitfield, /* complain_on_overflow */
1142 ppc64_elf_sectoff_reloc, /* special_function */
1143 "R_PPC64_SECTOFF_DS", /* name */
1144 FALSE, /* partial_inplace */
1145 0, /* src_mask */
1146 0xfffc, /* dst_mask */
1147 FALSE), /* pcrel_offset */
1149 /* Like R_PPC64_SECTOFF_LO, but for instructions with a DS field. */
1150 HOWTO (R_PPC64_SECTOFF_LO_DS, /* type */
1151 0, /* rightshift */
1152 1, /* size (0 = byte, 1 = short, 2 = long) */
1153 16, /* bitsize */
1154 FALSE, /* pc_relative */
1155 0, /* bitpos */
1156 complain_overflow_dont, /* complain_on_overflow */
1157 ppc64_elf_sectoff_reloc, /* special_function */
1158 "R_PPC64_SECTOFF_LO_DS",/* name */
1159 FALSE, /* partial_inplace */
1160 0, /* src_mask */
1161 0xfffc, /* dst_mask */
1162 FALSE), /* pcrel_offset */
1164 /* Like R_PPC64_TOC16, but for instructions with a DS field. */
1165 HOWTO (R_PPC64_TOC16_DS, /* type */
1166 0, /* rightshift */
1167 1, /* size (0 = byte, 1 = short, 2 = long) */
1168 16, /* bitsize */
1169 FALSE, /* pc_relative */
1170 0, /* bitpos */
1171 complain_overflow_signed, /* complain_on_overflow */
1172 ppc64_elf_toc_reloc, /* special_function */
1173 "R_PPC64_TOC16_DS", /* name */
1174 FALSE, /* partial_inplace */
1175 0, /* src_mask */
1176 0xfffc, /* dst_mask */
1177 FALSE), /* pcrel_offset */
1179 /* Like R_PPC64_TOC16_LO, but for instructions with a DS field. */
1180 HOWTO (R_PPC64_TOC16_LO_DS, /* type */
1181 0, /* rightshift */
1182 1, /* size (0 = byte, 1 = short, 2 = long) */
1183 16, /* bitsize */
1184 FALSE, /* pc_relative */
1185 0, /* bitpos */
1186 complain_overflow_dont, /* complain_on_overflow */
1187 ppc64_elf_toc_reloc, /* special_function */
1188 "R_PPC64_TOC16_LO_DS", /* name */
1189 FALSE, /* partial_inplace */
1190 0, /* src_mask */
1191 0xfffc, /* dst_mask */
1192 FALSE), /* pcrel_offset */
1194 /* Like R_PPC64_PLTGOT16, but for instructions with a DS field. */
1195 /* FIXME: R_PPC64_PLTGOT16_DS not implemented. */
1196 HOWTO (R_PPC64_PLTGOT16_DS, /* type */
1197 0, /* rightshift */
1198 1, /* size (0 = byte, 1 = short, 2 = long) */
1199 16, /* bitsize */
1200 FALSE, /* pc_relative */
1201 0, /* bitpos */
1202 complain_overflow_signed, /* complain_on_overflow */
1203 ppc64_elf_unhandled_reloc, /* special_function */
1204 "R_PPC64_PLTGOT16_DS", /* name */
1205 FALSE, /* partial_inplace */
1206 0, /* src_mask */
1207 0xfffc, /* dst_mask */
1208 FALSE), /* pcrel_offset */
1210 /* Like R_PPC64_PLTGOT16_LO, but for instructions with a DS field. */
1211 /* FIXME: R_PPC64_PLTGOT16_LO not implemented. */
1212 HOWTO (R_PPC64_PLTGOT16_LO_DS,/* type */
1213 0, /* rightshift */
1214 1, /* size (0 = byte, 1 = short, 2 = long) */
1215 16, /* bitsize */
1216 FALSE, /* pc_relative */
1217 0, /* bitpos */
1218 complain_overflow_dont, /* complain_on_overflow */
1219 ppc64_elf_unhandled_reloc, /* special_function */
1220 "R_PPC64_PLTGOT16_LO_DS",/* name */
1221 FALSE, /* partial_inplace */
1222 0, /* src_mask */
1223 0xfffc, /* dst_mask */
1224 FALSE), /* pcrel_offset */
1226 /* Marker reloc for TLS. */
1227 HOWTO (R_PPC64_TLS,
1228 0, /* rightshift */
1229 2, /* size (0 = byte, 1 = short, 2 = long) */
1230 32, /* bitsize */
1231 FALSE, /* pc_relative */
1232 0, /* bitpos */
1233 complain_overflow_dont, /* complain_on_overflow */
1234 bfd_elf_generic_reloc, /* special_function */
1235 "R_PPC64_TLS", /* name */
1236 FALSE, /* partial_inplace */
1237 0, /* src_mask */
1238 0, /* dst_mask */
1239 FALSE), /* pcrel_offset */
1241 /* Computes the load module index of the load module that contains the
1242 definition of its TLS sym. */
1243 HOWTO (R_PPC64_DTPMOD64,
1244 0, /* rightshift */
1245 4, /* size (0 = byte, 1 = short, 2 = long) */
1246 64, /* bitsize */
1247 FALSE, /* pc_relative */
1248 0, /* bitpos */
1249 complain_overflow_dont, /* complain_on_overflow */
1250 ppc64_elf_unhandled_reloc, /* special_function */
1251 "R_PPC64_DTPMOD64", /* name */
1252 FALSE, /* partial_inplace */
1253 0, /* src_mask */
1254 ONES (64), /* dst_mask */
1255 FALSE), /* pcrel_offset */
1257 /* Computes a dtv-relative displacement, the difference between the value
1258 of sym+add and the base address of the thread-local storage block that
1259 contains the definition of sym, minus 0x8000. */
1260 HOWTO (R_PPC64_DTPREL64,
1261 0, /* rightshift */
1262 4, /* size (0 = byte, 1 = short, 2 = long) */
1263 64, /* bitsize */
1264 FALSE, /* pc_relative */
1265 0, /* bitpos */
1266 complain_overflow_dont, /* complain_on_overflow */
1267 ppc64_elf_unhandled_reloc, /* special_function */
1268 "R_PPC64_DTPREL64", /* name */
1269 FALSE, /* partial_inplace */
1270 0, /* src_mask */
1271 ONES (64), /* dst_mask */
1272 FALSE), /* pcrel_offset */
1274 /* A 16 bit dtprel reloc. */
1275 HOWTO (R_PPC64_DTPREL16,
1276 0, /* rightshift */
1277 1, /* size (0 = byte, 1 = short, 2 = long) */
1278 16, /* bitsize */
1279 FALSE, /* pc_relative */
1280 0, /* bitpos */
1281 complain_overflow_signed, /* complain_on_overflow */
1282 ppc64_elf_unhandled_reloc, /* special_function */
1283 "R_PPC64_DTPREL16", /* name */
1284 FALSE, /* partial_inplace */
1285 0, /* src_mask */
1286 0xffff, /* dst_mask */
1287 FALSE), /* pcrel_offset */
1289 /* Like DTPREL16, but no overflow. */
1290 HOWTO (R_PPC64_DTPREL16_LO,
1291 0, /* rightshift */
1292 1, /* size (0 = byte, 1 = short, 2 = long) */
1293 16, /* bitsize */
1294 FALSE, /* pc_relative */
1295 0, /* bitpos */
1296 complain_overflow_dont, /* complain_on_overflow */
1297 ppc64_elf_unhandled_reloc, /* special_function */
1298 "R_PPC64_DTPREL16_LO", /* name */
1299 FALSE, /* partial_inplace */
1300 0, /* src_mask */
1301 0xffff, /* dst_mask */
1302 FALSE), /* pcrel_offset */
1304 /* Like DTPREL16_LO, but next higher group of 16 bits. */
1305 HOWTO (R_PPC64_DTPREL16_HI,
1306 16, /* rightshift */
1307 1, /* size (0 = byte, 1 = short, 2 = long) */
1308 16, /* bitsize */
1309 FALSE, /* pc_relative */
1310 0, /* bitpos */
1311 complain_overflow_dont, /* complain_on_overflow */
1312 ppc64_elf_unhandled_reloc, /* special_function */
1313 "R_PPC64_DTPREL16_HI", /* name */
1314 FALSE, /* partial_inplace */
1315 0, /* src_mask */
1316 0xffff, /* dst_mask */
1317 FALSE), /* pcrel_offset */
1319 /* Like DTPREL16_HI, but adjust for low 16 bits. */
1320 HOWTO (R_PPC64_DTPREL16_HA,
1321 16, /* rightshift */
1322 1, /* size (0 = byte, 1 = short, 2 = long) */
1323 16, /* bitsize */
1324 FALSE, /* pc_relative */
1325 0, /* bitpos */
1326 complain_overflow_dont, /* complain_on_overflow */
1327 ppc64_elf_unhandled_reloc, /* special_function */
1328 "R_PPC64_DTPREL16_HA", /* name */
1329 FALSE, /* partial_inplace */
1330 0, /* src_mask */
1331 0xffff, /* dst_mask */
1332 FALSE), /* pcrel_offset */
1334 /* Like DTPREL16_HI, but next higher group of 16 bits. */
1335 HOWTO (R_PPC64_DTPREL16_HIGHER,
1336 32, /* rightshift */
1337 1, /* size (0 = byte, 1 = short, 2 = long) */
1338 16, /* bitsize */
1339 FALSE, /* pc_relative */
1340 0, /* bitpos */
1341 complain_overflow_dont, /* complain_on_overflow */
1342 ppc64_elf_unhandled_reloc, /* special_function */
1343 "R_PPC64_DTPREL16_HIGHER", /* name */
1344 FALSE, /* partial_inplace */
1345 0, /* src_mask */
1346 0xffff, /* dst_mask */
1347 FALSE), /* pcrel_offset */
1349 /* Like DTPREL16_HIGHER, but adjust for low 16 bits. */
1350 HOWTO (R_PPC64_DTPREL16_HIGHERA,
1351 32, /* rightshift */
1352 1, /* size (0 = byte, 1 = short, 2 = long) */
1353 16, /* bitsize */
1354 FALSE, /* pc_relative */
1355 0, /* bitpos */
1356 complain_overflow_dont, /* complain_on_overflow */
1357 ppc64_elf_unhandled_reloc, /* special_function */
1358 "R_PPC64_DTPREL16_HIGHERA", /* name */
1359 FALSE, /* partial_inplace */
1360 0, /* src_mask */
1361 0xffff, /* dst_mask */
1362 FALSE), /* pcrel_offset */
1364 /* Like DTPREL16_HIGHER, but next higher group of 16 bits. */
1365 HOWTO (R_PPC64_DTPREL16_HIGHEST,
1366 48, /* rightshift */
1367 1, /* size (0 = byte, 1 = short, 2 = long) */
1368 16, /* bitsize */
1369 FALSE, /* pc_relative */
1370 0, /* bitpos */
1371 complain_overflow_dont, /* complain_on_overflow */
1372 ppc64_elf_unhandled_reloc, /* special_function */
1373 "R_PPC64_DTPREL16_HIGHEST", /* name */
1374 FALSE, /* partial_inplace */
1375 0, /* src_mask */
1376 0xffff, /* dst_mask */
1377 FALSE), /* pcrel_offset */
1379 /* Like DTPREL16_HIGHEST, but adjust for low 16 bits. */
1380 HOWTO (R_PPC64_DTPREL16_HIGHESTA,
1381 48, /* rightshift */
1382 1, /* size (0 = byte, 1 = short, 2 = long) */
1383 16, /* bitsize */
1384 FALSE, /* pc_relative */
1385 0, /* bitpos */
1386 complain_overflow_dont, /* complain_on_overflow */
1387 ppc64_elf_unhandled_reloc, /* special_function */
1388 "R_PPC64_DTPREL16_HIGHESTA", /* name */
1389 FALSE, /* partial_inplace */
1390 0, /* src_mask */
1391 0xffff, /* dst_mask */
1392 FALSE), /* pcrel_offset */
1394 /* Like DTPREL16, but for insns with a DS field. */
1395 HOWTO (R_PPC64_DTPREL16_DS,
1396 0, /* rightshift */
1397 1, /* size (0 = byte, 1 = short, 2 = long) */
1398 16, /* bitsize */
1399 FALSE, /* pc_relative */
1400 0, /* bitpos */
1401 complain_overflow_signed, /* complain_on_overflow */
1402 ppc64_elf_unhandled_reloc, /* special_function */
1403 "R_PPC64_DTPREL16_DS", /* name */
1404 FALSE, /* partial_inplace */
1405 0, /* src_mask */
1406 0xfffc, /* dst_mask */
1407 FALSE), /* pcrel_offset */
1409 /* Like DTPREL16_DS, but no overflow. */
1410 HOWTO (R_PPC64_DTPREL16_LO_DS,
1411 0, /* rightshift */
1412 1, /* size (0 = byte, 1 = short, 2 = long) */
1413 16, /* bitsize */
1414 FALSE, /* pc_relative */
1415 0, /* bitpos */
1416 complain_overflow_dont, /* complain_on_overflow */
1417 ppc64_elf_unhandled_reloc, /* special_function */
1418 "R_PPC64_DTPREL16_LO_DS", /* name */
1419 FALSE, /* partial_inplace */
1420 0, /* src_mask */
1421 0xfffc, /* dst_mask */
1422 FALSE), /* pcrel_offset */
1424 /* Computes a tp-relative displacement, the difference between the value of
1425 sym+add and the value of the thread pointer (r13). */
1426 HOWTO (R_PPC64_TPREL64,
1427 0, /* rightshift */
1428 4, /* size (0 = byte, 1 = short, 2 = long) */
1429 64, /* bitsize */
1430 FALSE, /* pc_relative */
1431 0, /* bitpos */
1432 complain_overflow_dont, /* complain_on_overflow */
1433 ppc64_elf_unhandled_reloc, /* special_function */
1434 "R_PPC64_TPREL64", /* name */
1435 FALSE, /* partial_inplace */
1436 0, /* src_mask */
1437 ONES (64), /* dst_mask */
1438 FALSE), /* pcrel_offset */
1440 /* A 16 bit tprel reloc. */
1441 HOWTO (R_PPC64_TPREL16,
1442 0, /* rightshift */
1443 1, /* size (0 = byte, 1 = short, 2 = long) */
1444 16, /* bitsize */
1445 FALSE, /* pc_relative */
1446 0, /* bitpos */
1447 complain_overflow_signed, /* complain_on_overflow */
1448 ppc64_elf_unhandled_reloc, /* special_function */
1449 "R_PPC64_TPREL16", /* name */
1450 FALSE, /* partial_inplace */
1451 0, /* src_mask */
1452 0xffff, /* dst_mask */
1453 FALSE), /* pcrel_offset */
1455 /* Like TPREL16, but no overflow. */
1456 HOWTO (R_PPC64_TPREL16_LO,
1457 0, /* rightshift */
1458 1, /* size (0 = byte, 1 = short, 2 = long) */
1459 16, /* bitsize */
1460 FALSE, /* pc_relative */
1461 0, /* bitpos */
1462 complain_overflow_dont, /* complain_on_overflow */
1463 ppc64_elf_unhandled_reloc, /* special_function */
1464 "R_PPC64_TPREL16_LO", /* name */
1465 FALSE, /* partial_inplace */
1466 0, /* src_mask */
1467 0xffff, /* dst_mask */
1468 FALSE), /* pcrel_offset */
1470 /* Like TPREL16_LO, but next higher group of 16 bits. */
1471 HOWTO (R_PPC64_TPREL16_HI,
1472 16, /* rightshift */
1473 1, /* size (0 = byte, 1 = short, 2 = long) */
1474 16, /* bitsize */
1475 FALSE, /* pc_relative */
1476 0, /* bitpos */
1477 complain_overflow_dont, /* complain_on_overflow */
1478 ppc64_elf_unhandled_reloc, /* special_function */
1479 "R_PPC64_TPREL16_HI", /* name */
1480 FALSE, /* partial_inplace */
1481 0, /* src_mask */
1482 0xffff, /* dst_mask */
1483 FALSE), /* pcrel_offset */
1485 /* Like TPREL16_HI, but adjust for low 16 bits. */
1486 HOWTO (R_PPC64_TPREL16_HA,
1487 16, /* rightshift */
1488 1, /* size (0 = byte, 1 = short, 2 = long) */
1489 16, /* bitsize */
1490 FALSE, /* pc_relative */
1491 0, /* bitpos */
1492 complain_overflow_dont, /* complain_on_overflow */
1493 ppc64_elf_unhandled_reloc, /* special_function */
1494 "R_PPC64_TPREL16_HA", /* name */
1495 FALSE, /* partial_inplace */
1496 0, /* src_mask */
1497 0xffff, /* dst_mask */
1498 FALSE), /* pcrel_offset */
1500 /* Like TPREL16_HI, but next higher group of 16 bits. */
1501 HOWTO (R_PPC64_TPREL16_HIGHER,
1502 32, /* rightshift */
1503 1, /* size (0 = byte, 1 = short, 2 = long) */
1504 16, /* bitsize */
1505 FALSE, /* pc_relative */
1506 0, /* bitpos */
1507 complain_overflow_dont, /* complain_on_overflow */
1508 ppc64_elf_unhandled_reloc, /* special_function */
1509 "R_PPC64_TPREL16_HIGHER", /* name */
1510 FALSE, /* partial_inplace */
1511 0, /* src_mask */
1512 0xffff, /* dst_mask */
1513 FALSE), /* pcrel_offset */
1515 /* Like TPREL16_HIGHER, but adjust for low 16 bits. */
1516 HOWTO (R_PPC64_TPREL16_HIGHERA,
1517 32, /* rightshift */
1518 1, /* size (0 = byte, 1 = short, 2 = long) */
1519 16, /* bitsize */
1520 FALSE, /* pc_relative */
1521 0, /* bitpos */
1522 complain_overflow_dont, /* complain_on_overflow */
1523 ppc64_elf_unhandled_reloc, /* special_function */
1524 "R_PPC64_TPREL16_HIGHERA", /* name */
1525 FALSE, /* partial_inplace */
1526 0, /* src_mask */
1527 0xffff, /* dst_mask */
1528 FALSE), /* pcrel_offset */
1530 /* Like TPREL16_HIGHER, but next higher group of 16 bits. */
1531 HOWTO (R_PPC64_TPREL16_HIGHEST,
1532 48, /* rightshift */
1533 1, /* size (0 = byte, 1 = short, 2 = long) */
1534 16, /* bitsize */
1535 FALSE, /* pc_relative */
1536 0, /* bitpos */
1537 complain_overflow_dont, /* complain_on_overflow */
1538 ppc64_elf_unhandled_reloc, /* special_function */
1539 "R_PPC64_TPREL16_HIGHEST", /* name */
1540 FALSE, /* partial_inplace */
1541 0, /* src_mask */
1542 0xffff, /* dst_mask */
1543 FALSE), /* pcrel_offset */
1545 /* Like TPREL16_HIGHEST, but adjust for low 16 bits. */
1546 HOWTO (R_PPC64_TPREL16_HIGHESTA,
1547 48, /* rightshift */
1548 1, /* size (0 = byte, 1 = short, 2 = long) */
1549 16, /* bitsize */
1550 FALSE, /* pc_relative */
1551 0, /* bitpos */
1552 complain_overflow_dont, /* complain_on_overflow */
1553 ppc64_elf_unhandled_reloc, /* special_function */
1554 "R_PPC64_TPREL16_HIGHESTA", /* name */
1555 FALSE, /* partial_inplace */
1556 0, /* src_mask */
1557 0xffff, /* dst_mask */
1558 FALSE), /* pcrel_offset */
1560 /* Like TPREL16, but for insns with a DS field. */
1561 HOWTO (R_PPC64_TPREL16_DS,
1562 0, /* rightshift */
1563 1, /* size (0 = byte, 1 = short, 2 = long) */
1564 16, /* bitsize */
1565 FALSE, /* pc_relative */
1566 0, /* bitpos */
1567 complain_overflow_signed, /* complain_on_overflow */
1568 ppc64_elf_unhandled_reloc, /* special_function */
1569 "R_PPC64_TPREL16_DS", /* name */
1570 FALSE, /* partial_inplace */
1571 0, /* src_mask */
1572 0xfffc, /* dst_mask */
1573 FALSE), /* pcrel_offset */
1575 /* Like TPREL16_DS, but no overflow. */
1576 HOWTO (R_PPC64_TPREL16_LO_DS,
1577 0, /* rightshift */
1578 1, /* size (0 = byte, 1 = short, 2 = long) */
1579 16, /* bitsize */
1580 FALSE, /* pc_relative */
1581 0, /* bitpos */
1582 complain_overflow_dont, /* complain_on_overflow */
1583 ppc64_elf_unhandled_reloc, /* special_function */
1584 "R_PPC64_TPREL16_LO_DS", /* name */
1585 FALSE, /* partial_inplace */
1586 0, /* src_mask */
1587 0xfffc, /* dst_mask */
1588 FALSE), /* pcrel_offset */
1590 /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1591 with values (sym+add)@dtpmod and (sym+add)@dtprel, and computes the offset
1592 to the first entry relative to the TOC base (r2). */
1593 HOWTO (R_PPC64_GOT_TLSGD16,
1594 0, /* rightshift */
1595 1, /* size (0 = byte, 1 = short, 2 = long) */
1596 16, /* bitsize */
1597 FALSE, /* pc_relative */
1598 0, /* bitpos */
1599 complain_overflow_signed, /* complain_on_overflow */
1600 ppc64_elf_unhandled_reloc, /* special_function */
1601 "R_PPC64_GOT_TLSGD16", /* name */
1602 FALSE, /* partial_inplace */
1603 0, /* src_mask */
1604 0xffff, /* dst_mask */
1605 FALSE), /* pcrel_offset */
1607 /* Like GOT_TLSGD16, but no overflow. */
1608 HOWTO (R_PPC64_GOT_TLSGD16_LO,
1609 0, /* rightshift */
1610 1, /* size (0 = byte, 1 = short, 2 = long) */
1611 16, /* bitsize */
1612 FALSE, /* pc_relative */
1613 0, /* bitpos */
1614 complain_overflow_dont, /* complain_on_overflow */
1615 ppc64_elf_unhandled_reloc, /* special_function */
1616 "R_PPC64_GOT_TLSGD16_LO", /* name */
1617 FALSE, /* partial_inplace */
1618 0, /* src_mask */
1619 0xffff, /* dst_mask */
1620 FALSE), /* pcrel_offset */
1622 /* Like GOT_TLSGD16_LO, but next higher group of 16 bits. */
1623 HOWTO (R_PPC64_GOT_TLSGD16_HI,
1624 16, /* rightshift */
1625 1, /* size (0 = byte, 1 = short, 2 = long) */
1626 16, /* bitsize */
1627 FALSE, /* pc_relative */
1628 0, /* bitpos */
1629 complain_overflow_dont, /* complain_on_overflow */
1630 ppc64_elf_unhandled_reloc, /* special_function */
1631 "R_PPC64_GOT_TLSGD16_HI", /* name */
1632 FALSE, /* partial_inplace */
1633 0, /* src_mask */
1634 0xffff, /* dst_mask */
1635 FALSE), /* pcrel_offset */
1637 /* Like GOT_TLSGD16_HI, but adjust for low 16 bits. */
1638 HOWTO (R_PPC64_GOT_TLSGD16_HA,
1639 16, /* rightshift */
1640 1, /* size (0 = byte, 1 = short, 2 = long) */
1641 16, /* bitsize */
1642 FALSE, /* pc_relative */
1643 0, /* bitpos */
1644 complain_overflow_dont, /* complain_on_overflow */
1645 ppc64_elf_unhandled_reloc, /* special_function */
1646 "R_PPC64_GOT_TLSGD16_HA", /* name */
1647 FALSE, /* partial_inplace */
1648 0, /* src_mask */
1649 0xffff, /* dst_mask */
1650 FALSE), /* pcrel_offset */
1652 /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1653 with values (sym+add)@dtpmod and zero, and computes the offset to the
1654 first entry relative to the TOC base (r2). */
1655 HOWTO (R_PPC64_GOT_TLSLD16,
1656 0, /* rightshift */
1657 1, /* size (0 = byte, 1 = short, 2 = long) */
1658 16, /* bitsize */
1659 FALSE, /* pc_relative */
1660 0, /* bitpos */
1661 complain_overflow_signed, /* complain_on_overflow */
1662 ppc64_elf_unhandled_reloc, /* special_function */
1663 "R_PPC64_GOT_TLSLD16", /* name */
1664 FALSE, /* partial_inplace */
1665 0, /* src_mask */
1666 0xffff, /* dst_mask */
1667 FALSE), /* pcrel_offset */
1669 /* Like GOT_TLSLD16, but no overflow. */
1670 HOWTO (R_PPC64_GOT_TLSLD16_LO,
1671 0, /* rightshift */
1672 1, /* size (0 = byte, 1 = short, 2 = long) */
1673 16, /* bitsize */
1674 FALSE, /* pc_relative */
1675 0, /* bitpos */
1676 complain_overflow_dont, /* complain_on_overflow */
1677 ppc64_elf_unhandled_reloc, /* special_function */
1678 "R_PPC64_GOT_TLSLD16_LO", /* name */
1679 FALSE, /* partial_inplace */
1680 0, /* src_mask */
1681 0xffff, /* dst_mask */
1682 FALSE), /* pcrel_offset */
1684 /* Like GOT_TLSLD16_LO, but next higher group of 16 bits. */
1685 HOWTO (R_PPC64_GOT_TLSLD16_HI,
1686 16, /* rightshift */
1687 1, /* size (0 = byte, 1 = short, 2 = long) */
1688 16, /* bitsize */
1689 FALSE, /* pc_relative */
1690 0, /* bitpos */
1691 complain_overflow_dont, /* complain_on_overflow */
1692 ppc64_elf_unhandled_reloc, /* special_function */
1693 "R_PPC64_GOT_TLSLD16_HI", /* name */
1694 FALSE, /* partial_inplace */
1695 0, /* src_mask */
1696 0xffff, /* dst_mask */
1697 FALSE), /* pcrel_offset */
1699 /* Like GOT_TLSLD16_HI, but adjust for low 16 bits. */
1700 HOWTO (R_PPC64_GOT_TLSLD16_HA,
1701 16, /* rightshift */
1702 1, /* size (0 = byte, 1 = short, 2 = long) */
1703 16, /* bitsize */
1704 FALSE, /* pc_relative */
1705 0, /* bitpos */
1706 complain_overflow_dont, /* complain_on_overflow */
1707 ppc64_elf_unhandled_reloc, /* special_function */
1708 "R_PPC64_GOT_TLSLD16_HA", /* name */
1709 FALSE, /* partial_inplace */
1710 0, /* src_mask */
1711 0xffff, /* dst_mask */
1712 FALSE), /* pcrel_offset */
1714 /* Allocates an entry in the GOT with value (sym+add)@dtprel, and computes
1715 the offset to the entry relative to the TOC base (r2). */
1716 HOWTO (R_PPC64_GOT_DTPREL16_DS,
1717 0, /* rightshift */
1718 1, /* size (0 = byte, 1 = short, 2 = long) */
1719 16, /* bitsize */
1720 FALSE, /* pc_relative */
1721 0, /* bitpos */
1722 complain_overflow_signed, /* complain_on_overflow */
1723 ppc64_elf_unhandled_reloc, /* special_function */
1724 "R_PPC64_GOT_DTPREL16_DS", /* name */
1725 FALSE, /* partial_inplace */
1726 0, /* src_mask */
1727 0xfffc, /* dst_mask */
1728 FALSE), /* pcrel_offset */
1730 /* Like GOT_DTPREL16_DS, but no overflow. */
1731 HOWTO (R_PPC64_GOT_DTPREL16_LO_DS,
1732 0, /* rightshift */
1733 1, /* size (0 = byte, 1 = short, 2 = long) */
1734 16, /* bitsize */
1735 FALSE, /* pc_relative */
1736 0, /* bitpos */
1737 complain_overflow_dont, /* complain_on_overflow */
1738 ppc64_elf_unhandled_reloc, /* special_function */
1739 "R_PPC64_GOT_DTPREL16_LO_DS", /* name */
1740 FALSE, /* partial_inplace */
1741 0, /* src_mask */
1742 0xfffc, /* dst_mask */
1743 FALSE), /* pcrel_offset */
1745 /* Like GOT_DTPREL16_LO_DS, but next higher group of 16 bits. */
1746 HOWTO (R_PPC64_GOT_DTPREL16_HI,
1747 16, /* rightshift */
1748 1, /* size (0 = byte, 1 = short, 2 = long) */
1749 16, /* bitsize */
1750 FALSE, /* pc_relative */
1751 0, /* bitpos */
1752 complain_overflow_dont, /* complain_on_overflow */
1753 ppc64_elf_unhandled_reloc, /* special_function */
1754 "R_PPC64_GOT_DTPREL16_HI", /* name */
1755 FALSE, /* partial_inplace */
1756 0, /* src_mask */
1757 0xffff, /* dst_mask */
1758 FALSE), /* pcrel_offset */
1760 /* Like GOT_DTPREL16_HI, but adjust for low 16 bits. */
1761 HOWTO (R_PPC64_GOT_DTPREL16_HA,
1762 16, /* rightshift */
1763 1, /* size (0 = byte, 1 = short, 2 = long) */
1764 16, /* bitsize */
1765 FALSE, /* pc_relative */
1766 0, /* bitpos */
1767 complain_overflow_dont, /* complain_on_overflow */
1768 ppc64_elf_unhandled_reloc, /* special_function */
1769 "R_PPC64_GOT_DTPREL16_HA", /* name */
1770 FALSE, /* partial_inplace */
1771 0, /* src_mask */
1772 0xffff, /* dst_mask */
1773 FALSE), /* pcrel_offset */
1775 /* Allocates an entry in the GOT with value (sym+add)@tprel, and computes the
1776 offset to the entry relative to the TOC base (r2). */
1777 HOWTO (R_PPC64_GOT_TPREL16_DS,
1778 0, /* rightshift */
1779 1, /* size (0 = byte, 1 = short, 2 = long) */
1780 16, /* bitsize */
1781 FALSE, /* pc_relative */
1782 0, /* bitpos */
1783 complain_overflow_signed, /* complain_on_overflow */
1784 ppc64_elf_unhandled_reloc, /* special_function */
1785 "R_PPC64_GOT_TPREL16_DS", /* name */
1786 FALSE, /* partial_inplace */
1787 0, /* src_mask */
1788 0xfffc, /* dst_mask */
1789 FALSE), /* pcrel_offset */
1791 /* Like GOT_TPREL16_DS, but no overflow. */
1792 HOWTO (R_PPC64_GOT_TPREL16_LO_DS,
1793 0, /* rightshift */
1794 1, /* size (0 = byte, 1 = short, 2 = long) */
1795 16, /* bitsize */
1796 FALSE, /* pc_relative */
1797 0, /* bitpos */
1798 complain_overflow_dont, /* complain_on_overflow */
1799 ppc64_elf_unhandled_reloc, /* special_function */
1800 "R_PPC64_GOT_TPREL16_LO_DS", /* name */
1801 FALSE, /* partial_inplace */
1802 0, /* src_mask */
1803 0xfffc, /* dst_mask */
1804 FALSE), /* pcrel_offset */
1806 /* Like GOT_TPREL16_LO_DS, but next higher group of 16 bits. */
1807 HOWTO (R_PPC64_GOT_TPREL16_HI,
1808 16, /* rightshift */
1809 1, /* size (0 = byte, 1 = short, 2 = long) */
1810 16, /* bitsize */
1811 FALSE, /* pc_relative */
1812 0, /* bitpos */
1813 complain_overflow_dont, /* complain_on_overflow */
1814 ppc64_elf_unhandled_reloc, /* special_function */
1815 "R_PPC64_GOT_TPREL16_HI", /* name */
1816 FALSE, /* partial_inplace */
1817 0, /* src_mask */
1818 0xffff, /* dst_mask */
1819 FALSE), /* pcrel_offset */
1821 /* Like GOT_TPREL16_HI, but adjust for low 16 bits. */
1822 HOWTO (R_PPC64_GOT_TPREL16_HA,
1823 16, /* rightshift */
1824 1, /* size (0 = byte, 1 = short, 2 = long) */
1825 16, /* bitsize */
1826 FALSE, /* pc_relative */
1827 0, /* bitpos */
1828 complain_overflow_dont, /* complain_on_overflow */
1829 ppc64_elf_unhandled_reloc, /* special_function */
1830 "R_PPC64_GOT_TPREL16_HA", /* name */
1831 FALSE, /* partial_inplace */
1832 0, /* src_mask */
1833 0xffff, /* dst_mask */
1834 FALSE), /* pcrel_offset */
1836 /* GNU extension to record C++ vtable hierarchy. */
1837 HOWTO (R_PPC64_GNU_VTINHERIT, /* type */
1838 0, /* rightshift */
1839 0, /* size (0 = byte, 1 = short, 2 = long) */
1840 0, /* bitsize */
1841 FALSE, /* pc_relative */
1842 0, /* bitpos */
1843 complain_overflow_dont, /* complain_on_overflow */
1844 NULL, /* special_function */
1845 "R_PPC64_GNU_VTINHERIT", /* name */
1846 FALSE, /* partial_inplace */
1847 0, /* src_mask */
1848 0, /* dst_mask */
1849 FALSE), /* pcrel_offset */
1851 /* GNU extension to record C++ vtable member usage. */
1852 HOWTO (R_PPC64_GNU_VTENTRY, /* type */
1853 0, /* rightshift */
1854 0, /* size (0 = byte, 1 = short, 2 = long) */
1855 0, /* bitsize */
1856 FALSE, /* pc_relative */
1857 0, /* bitpos */
1858 complain_overflow_dont, /* complain_on_overflow */
1859 NULL, /* special_function */
1860 "R_PPC64_GNU_VTENTRY", /* name */
1861 FALSE, /* partial_inplace */
1862 0, /* src_mask */
1863 0, /* dst_mask */
1864 FALSE), /* pcrel_offset */
1868 /* Initialize the ppc64_elf_howto_table, so that linear accesses can
1869 be done. */
1871 static void
1872 ppc_howto_init (void)
1874 unsigned int i, type;
1876 for (i = 0;
1877 i < sizeof (ppc64_elf_howto_raw) / sizeof (ppc64_elf_howto_raw[0]);
1878 i++)
1880 type = ppc64_elf_howto_raw[i].type;
1881 BFD_ASSERT (type < (sizeof (ppc64_elf_howto_table)
1882 / sizeof (ppc64_elf_howto_table[0])));
1883 ppc64_elf_howto_table[type] = &ppc64_elf_howto_raw[i];
1887 static reloc_howto_type *
1888 ppc64_elf_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
1889 bfd_reloc_code_real_type code)
1891 enum elf_ppc64_reloc_type r = R_PPC64_NONE;
1893 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
1894 /* Initialize howto table if needed. */
1895 ppc_howto_init ();
1897 switch (code)
1899 default:
1900 return NULL;
1902 case BFD_RELOC_NONE: r = R_PPC64_NONE;
1903 break;
1904 case BFD_RELOC_32: r = R_PPC64_ADDR32;
1905 break;
1906 case BFD_RELOC_PPC_BA26: r = R_PPC64_ADDR24;
1907 break;
1908 case BFD_RELOC_16: r = R_PPC64_ADDR16;
1909 break;
1910 case BFD_RELOC_LO16: r = R_PPC64_ADDR16_LO;
1911 break;
1912 case BFD_RELOC_HI16: r = R_PPC64_ADDR16_HI;
1913 break;
1914 case BFD_RELOC_HI16_S: r = R_PPC64_ADDR16_HA;
1915 break;
1916 case BFD_RELOC_PPC_BA16: r = R_PPC64_ADDR14;
1917 break;
1918 case BFD_RELOC_PPC_BA16_BRTAKEN: r = R_PPC64_ADDR14_BRTAKEN;
1919 break;
1920 case BFD_RELOC_PPC_BA16_BRNTAKEN: r = R_PPC64_ADDR14_BRNTAKEN;
1921 break;
1922 case BFD_RELOC_PPC_B26: r = R_PPC64_REL24;
1923 break;
1924 case BFD_RELOC_PPC_B16: r = R_PPC64_REL14;
1925 break;
1926 case BFD_RELOC_PPC_B16_BRTAKEN: r = R_PPC64_REL14_BRTAKEN;
1927 break;
1928 case BFD_RELOC_PPC_B16_BRNTAKEN: r = R_PPC64_REL14_BRNTAKEN;
1929 break;
1930 case BFD_RELOC_16_GOTOFF: r = R_PPC64_GOT16;
1931 break;
1932 case BFD_RELOC_LO16_GOTOFF: r = R_PPC64_GOT16_LO;
1933 break;
1934 case BFD_RELOC_HI16_GOTOFF: r = R_PPC64_GOT16_HI;
1935 break;
1936 case BFD_RELOC_HI16_S_GOTOFF: r = R_PPC64_GOT16_HA;
1937 break;
1938 case BFD_RELOC_PPC_COPY: r = R_PPC64_COPY;
1939 break;
1940 case BFD_RELOC_PPC_GLOB_DAT: r = R_PPC64_GLOB_DAT;
1941 break;
1942 case BFD_RELOC_32_PCREL: r = R_PPC64_REL32;
1943 break;
1944 case BFD_RELOC_32_PLTOFF: r = R_PPC64_PLT32;
1945 break;
1946 case BFD_RELOC_32_PLT_PCREL: r = R_PPC64_PLTREL32;
1947 break;
1948 case BFD_RELOC_LO16_PLTOFF: r = R_PPC64_PLT16_LO;
1949 break;
1950 case BFD_RELOC_HI16_PLTOFF: r = R_PPC64_PLT16_HI;
1951 break;
1952 case BFD_RELOC_HI16_S_PLTOFF: r = R_PPC64_PLT16_HA;
1953 break;
1954 case BFD_RELOC_16_BASEREL: r = R_PPC64_SECTOFF;
1955 break;
1956 case BFD_RELOC_LO16_BASEREL: r = R_PPC64_SECTOFF_LO;
1957 break;
1958 case BFD_RELOC_HI16_BASEREL: r = R_PPC64_SECTOFF_HI;
1959 break;
1960 case BFD_RELOC_HI16_S_BASEREL: r = R_PPC64_SECTOFF_HA;
1961 break;
1962 case BFD_RELOC_CTOR: r = R_PPC64_ADDR64;
1963 break;
1964 case BFD_RELOC_64: r = R_PPC64_ADDR64;
1965 break;
1966 case BFD_RELOC_PPC64_HIGHER: r = R_PPC64_ADDR16_HIGHER;
1967 break;
1968 case BFD_RELOC_PPC64_HIGHER_S: r = R_PPC64_ADDR16_HIGHERA;
1969 break;
1970 case BFD_RELOC_PPC64_HIGHEST: r = R_PPC64_ADDR16_HIGHEST;
1971 break;
1972 case BFD_RELOC_PPC64_HIGHEST_S: r = R_PPC64_ADDR16_HIGHESTA;
1973 break;
1974 case BFD_RELOC_64_PCREL: r = R_PPC64_REL64;
1975 break;
1976 case BFD_RELOC_64_PLTOFF: r = R_PPC64_PLT64;
1977 break;
1978 case BFD_RELOC_64_PLT_PCREL: r = R_PPC64_PLTREL64;
1979 break;
1980 case BFD_RELOC_PPC_TOC16: r = R_PPC64_TOC16;
1981 break;
1982 case BFD_RELOC_PPC64_TOC16_LO: r = R_PPC64_TOC16_LO;
1983 break;
1984 case BFD_RELOC_PPC64_TOC16_HI: r = R_PPC64_TOC16_HI;
1985 break;
1986 case BFD_RELOC_PPC64_TOC16_HA: r = R_PPC64_TOC16_HA;
1987 break;
1988 case BFD_RELOC_PPC64_TOC: r = R_PPC64_TOC;
1989 break;
1990 case BFD_RELOC_PPC64_PLTGOT16: r = R_PPC64_PLTGOT16;
1991 break;
1992 case BFD_RELOC_PPC64_PLTGOT16_LO: r = R_PPC64_PLTGOT16_LO;
1993 break;
1994 case BFD_RELOC_PPC64_PLTGOT16_HI: r = R_PPC64_PLTGOT16_HI;
1995 break;
1996 case BFD_RELOC_PPC64_PLTGOT16_HA: r = R_PPC64_PLTGOT16_HA;
1997 break;
1998 case BFD_RELOC_PPC64_ADDR16_DS: r = R_PPC64_ADDR16_DS;
1999 break;
2000 case BFD_RELOC_PPC64_ADDR16_LO_DS: r = R_PPC64_ADDR16_LO_DS;
2001 break;
2002 case BFD_RELOC_PPC64_GOT16_DS: r = R_PPC64_GOT16_DS;
2003 break;
2004 case BFD_RELOC_PPC64_GOT16_LO_DS: r = R_PPC64_GOT16_LO_DS;
2005 break;
2006 case BFD_RELOC_PPC64_PLT16_LO_DS: r = R_PPC64_PLT16_LO_DS;
2007 break;
2008 case BFD_RELOC_PPC64_SECTOFF_DS: r = R_PPC64_SECTOFF_DS;
2009 break;
2010 case BFD_RELOC_PPC64_SECTOFF_LO_DS: r = R_PPC64_SECTOFF_LO_DS;
2011 break;
2012 case BFD_RELOC_PPC64_TOC16_DS: r = R_PPC64_TOC16_DS;
2013 break;
2014 case BFD_RELOC_PPC64_TOC16_LO_DS: r = R_PPC64_TOC16_LO_DS;
2015 break;
2016 case BFD_RELOC_PPC64_PLTGOT16_DS: r = R_PPC64_PLTGOT16_DS;
2017 break;
2018 case BFD_RELOC_PPC64_PLTGOT16_LO_DS: r = R_PPC64_PLTGOT16_LO_DS;
2019 break;
2020 case BFD_RELOC_PPC_TLS: r = R_PPC64_TLS;
2021 break;
2022 case BFD_RELOC_PPC_DTPMOD: r = R_PPC64_DTPMOD64;
2023 break;
2024 case BFD_RELOC_PPC_TPREL16: r = R_PPC64_TPREL16;
2025 break;
2026 case BFD_RELOC_PPC_TPREL16_LO: r = R_PPC64_TPREL16_LO;
2027 break;
2028 case BFD_RELOC_PPC_TPREL16_HI: r = R_PPC64_TPREL16_HI;
2029 break;
2030 case BFD_RELOC_PPC_TPREL16_HA: r = R_PPC64_TPREL16_HA;
2031 break;
2032 case BFD_RELOC_PPC_TPREL: r = R_PPC64_TPREL64;
2033 break;
2034 case BFD_RELOC_PPC_DTPREL16: r = R_PPC64_DTPREL16;
2035 break;
2036 case BFD_RELOC_PPC_DTPREL16_LO: r = R_PPC64_DTPREL16_LO;
2037 break;
2038 case BFD_RELOC_PPC_DTPREL16_HI: r = R_PPC64_DTPREL16_HI;
2039 break;
2040 case BFD_RELOC_PPC_DTPREL16_HA: r = R_PPC64_DTPREL16_HA;
2041 break;
2042 case BFD_RELOC_PPC_DTPREL: r = R_PPC64_DTPREL64;
2043 break;
2044 case BFD_RELOC_PPC_GOT_TLSGD16: r = R_PPC64_GOT_TLSGD16;
2045 break;
2046 case BFD_RELOC_PPC_GOT_TLSGD16_LO: r = R_PPC64_GOT_TLSGD16_LO;
2047 break;
2048 case BFD_RELOC_PPC_GOT_TLSGD16_HI: r = R_PPC64_GOT_TLSGD16_HI;
2049 break;
2050 case BFD_RELOC_PPC_GOT_TLSGD16_HA: r = R_PPC64_GOT_TLSGD16_HA;
2051 break;
2052 case BFD_RELOC_PPC_GOT_TLSLD16: r = R_PPC64_GOT_TLSLD16;
2053 break;
2054 case BFD_RELOC_PPC_GOT_TLSLD16_LO: r = R_PPC64_GOT_TLSLD16_LO;
2055 break;
2056 case BFD_RELOC_PPC_GOT_TLSLD16_HI: r = R_PPC64_GOT_TLSLD16_HI;
2057 break;
2058 case BFD_RELOC_PPC_GOT_TLSLD16_HA: r = R_PPC64_GOT_TLSLD16_HA;
2059 break;
2060 case BFD_RELOC_PPC_GOT_TPREL16: r = R_PPC64_GOT_TPREL16_DS;
2061 break;
2062 case BFD_RELOC_PPC_GOT_TPREL16_LO: r = R_PPC64_GOT_TPREL16_LO_DS;
2063 break;
2064 case BFD_RELOC_PPC_GOT_TPREL16_HI: r = R_PPC64_GOT_TPREL16_HI;
2065 break;
2066 case BFD_RELOC_PPC_GOT_TPREL16_HA: r = R_PPC64_GOT_TPREL16_HA;
2067 break;
2068 case BFD_RELOC_PPC_GOT_DTPREL16: r = R_PPC64_GOT_DTPREL16_DS;
2069 break;
2070 case BFD_RELOC_PPC_GOT_DTPREL16_LO: r = R_PPC64_GOT_DTPREL16_LO_DS;
2071 break;
2072 case BFD_RELOC_PPC_GOT_DTPREL16_HI: r = R_PPC64_GOT_DTPREL16_HI;
2073 break;
2074 case BFD_RELOC_PPC_GOT_DTPREL16_HA: r = R_PPC64_GOT_DTPREL16_HA;
2075 break;
2076 case BFD_RELOC_PPC64_TPREL16_DS: r = R_PPC64_TPREL16_DS;
2077 break;
2078 case BFD_RELOC_PPC64_TPREL16_LO_DS: r = R_PPC64_TPREL16_LO_DS;
2079 break;
2080 case BFD_RELOC_PPC64_TPREL16_HIGHER: r = R_PPC64_TPREL16_HIGHER;
2081 break;
2082 case BFD_RELOC_PPC64_TPREL16_HIGHERA: r = R_PPC64_TPREL16_HIGHERA;
2083 break;
2084 case BFD_RELOC_PPC64_TPREL16_HIGHEST: r = R_PPC64_TPREL16_HIGHEST;
2085 break;
2086 case BFD_RELOC_PPC64_TPREL16_HIGHESTA: r = R_PPC64_TPREL16_HIGHESTA;
2087 break;
2088 case BFD_RELOC_PPC64_DTPREL16_DS: r = R_PPC64_DTPREL16_DS;
2089 break;
2090 case BFD_RELOC_PPC64_DTPREL16_LO_DS: r = R_PPC64_DTPREL16_LO_DS;
2091 break;
2092 case BFD_RELOC_PPC64_DTPREL16_HIGHER: r = R_PPC64_DTPREL16_HIGHER;
2093 break;
2094 case BFD_RELOC_PPC64_DTPREL16_HIGHERA: r = R_PPC64_DTPREL16_HIGHERA;
2095 break;
2096 case BFD_RELOC_PPC64_DTPREL16_HIGHEST: r = R_PPC64_DTPREL16_HIGHEST;
2097 break;
2098 case BFD_RELOC_PPC64_DTPREL16_HIGHESTA: r = R_PPC64_DTPREL16_HIGHESTA;
2099 break;
2100 case BFD_RELOC_VTABLE_INHERIT: r = R_PPC64_GNU_VTINHERIT;
2101 break;
2102 case BFD_RELOC_VTABLE_ENTRY: r = R_PPC64_GNU_VTENTRY;
2103 break;
2106 return ppc64_elf_howto_table[r];
2109 /* Set the howto pointer for a PowerPC ELF reloc. */
2111 static void
2112 ppc64_elf_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr,
2113 Elf_Internal_Rela *dst)
2115 unsigned int type;
2117 /* Initialize howto table if needed. */
2118 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2119 ppc_howto_init ();
2121 type = ELF64_R_TYPE (dst->r_info);
2122 if (type >= (sizeof (ppc64_elf_howto_table)
2123 / sizeof (ppc64_elf_howto_table[0])))
2125 (*_bfd_error_handler) (_("%B: invalid relocation type %d"),
2126 abfd, (int) type);
2127 type = R_PPC64_NONE;
2129 cache_ptr->howto = ppc64_elf_howto_table[type];
2132 /* Handle the R_PPC64_ADDR16_HA and similar relocs. */
2134 static bfd_reloc_status_type
2135 ppc64_elf_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2136 void *data, asection *input_section,
2137 bfd *output_bfd, char **error_message)
2139 /* If this is a relocatable link (output_bfd test tells us), just
2140 call the generic function. Any adjustment will be done at final
2141 link time. */
2142 if (output_bfd != NULL)
2143 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2144 input_section, output_bfd, error_message);
2146 /* Adjust the addend for sign extension of the low 16 bits.
2147 We won't actually be using the low 16 bits, so trashing them
2148 doesn't matter. */
2149 reloc_entry->addend += 0x8000;
2150 return bfd_reloc_continue;
2153 static bfd_reloc_status_type
2154 ppc64_elf_branch_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2155 void *data, asection *input_section,
2156 bfd *output_bfd, char **error_message)
2158 if (output_bfd != NULL)
2159 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2160 input_section, output_bfd, error_message);
2162 if (strcmp (symbol->section->name, ".opd") == 0
2163 && (symbol->section->owner->flags & DYNAMIC) == 0)
2165 bfd_vma dest = opd_entry_value (symbol->section,
2166 symbol->value + reloc_entry->addend,
2167 NULL, NULL);
2168 if (dest != (bfd_vma) -1)
2169 reloc_entry->addend = dest - (symbol->value
2170 + symbol->section->output_section->vma
2171 + symbol->section->output_offset);
2173 return bfd_reloc_continue;
2176 static bfd_reloc_status_type
2177 ppc64_elf_brtaken_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2178 void *data, asection *input_section,
2179 bfd *output_bfd, char **error_message)
2181 long insn;
2182 enum elf_ppc64_reloc_type r_type;
2183 bfd_size_type octets;
2184 /* Disabled until we sort out how ld should choose 'y' vs 'at'. */
2185 bfd_boolean is_power4 = FALSE;
2187 /* If this is a relocatable link (output_bfd test tells us), just
2188 call the generic function. Any adjustment will be done at final
2189 link time. */
2190 if (output_bfd != NULL)
2191 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2192 input_section, output_bfd, error_message);
2194 octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2195 insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
2196 insn &= ~(0x01 << 21);
2197 r_type = reloc_entry->howto->type;
2198 if (r_type == R_PPC64_ADDR14_BRTAKEN
2199 || r_type == R_PPC64_REL14_BRTAKEN)
2200 insn |= 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field. */
2202 if (is_power4)
2204 /* Set 'a' bit. This is 0b00010 in BO field for branch
2205 on CR(BI) insns (BO == 001at or 011at), and 0b01000
2206 for branch on CTR insns (BO == 1a00t or 1a01t). */
2207 if ((insn & (0x14 << 21)) == (0x04 << 21))
2208 insn |= 0x02 << 21;
2209 else if ((insn & (0x14 << 21)) == (0x10 << 21))
2210 insn |= 0x08 << 21;
2211 else
2212 goto out;
2214 else
2216 bfd_vma target = 0;
2217 bfd_vma from;
2219 if (!bfd_is_com_section (symbol->section))
2220 target = symbol->value;
2221 target += symbol->section->output_section->vma;
2222 target += symbol->section->output_offset;
2223 target += reloc_entry->addend;
2225 from = (reloc_entry->address
2226 + input_section->output_offset
2227 + input_section->output_section->vma);
2229 /* Invert 'y' bit if not the default. */
2230 if ((bfd_signed_vma) (target - from) < 0)
2231 insn ^= 0x01 << 21;
2233 bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
2234 out:
2235 return ppc64_elf_branch_reloc (abfd, reloc_entry, symbol, data,
2236 input_section, output_bfd, error_message);
2239 static bfd_reloc_status_type
2240 ppc64_elf_sectoff_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2241 void *data, asection *input_section,
2242 bfd *output_bfd, char **error_message)
2244 /* If this is a relocatable link (output_bfd test tells us), just
2245 call the generic function. Any adjustment will be done at final
2246 link time. */
2247 if (output_bfd != NULL)
2248 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2249 input_section, output_bfd, error_message);
2251 /* Subtract the symbol section base address. */
2252 reloc_entry->addend -= symbol->section->output_section->vma;
2253 return bfd_reloc_continue;
2256 static bfd_reloc_status_type
2257 ppc64_elf_sectoff_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2258 void *data, asection *input_section,
2259 bfd *output_bfd, char **error_message)
2261 /* If this is a relocatable link (output_bfd test tells us), just
2262 call the generic function. Any adjustment will be done at final
2263 link time. */
2264 if (output_bfd != NULL)
2265 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2266 input_section, output_bfd, error_message);
2268 /* Subtract the symbol section base address. */
2269 reloc_entry->addend -= symbol->section->output_section->vma;
2271 /* Adjust the addend for sign extension of the low 16 bits. */
2272 reloc_entry->addend += 0x8000;
2273 return bfd_reloc_continue;
2276 static bfd_reloc_status_type
2277 ppc64_elf_toc_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2278 void *data, asection *input_section,
2279 bfd *output_bfd, char **error_message)
2281 bfd_vma TOCstart;
2283 /* If this is a relocatable link (output_bfd test tells us), just
2284 call the generic function. Any adjustment will be done at final
2285 link time. */
2286 if (output_bfd != NULL)
2287 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2288 input_section, output_bfd, error_message);
2290 TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2291 if (TOCstart == 0)
2292 TOCstart = ppc64_elf_toc (input_section->output_section->owner);
2294 /* Subtract the TOC base address. */
2295 reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2296 return bfd_reloc_continue;
2299 static bfd_reloc_status_type
2300 ppc64_elf_toc_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2301 void *data, asection *input_section,
2302 bfd *output_bfd, char **error_message)
2304 bfd_vma TOCstart;
2306 /* If this is a relocatable link (output_bfd test tells us), just
2307 call the generic function. Any adjustment will be done at final
2308 link time. */
2309 if (output_bfd != NULL)
2310 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2311 input_section, output_bfd, error_message);
2313 TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2314 if (TOCstart == 0)
2315 TOCstart = ppc64_elf_toc (input_section->output_section->owner);
2317 /* Subtract the TOC base address. */
2318 reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2320 /* Adjust the addend for sign extension of the low 16 bits. */
2321 reloc_entry->addend += 0x8000;
2322 return bfd_reloc_continue;
2325 static bfd_reloc_status_type
2326 ppc64_elf_toc64_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2327 void *data, asection *input_section,
2328 bfd *output_bfd, char **error_message)
2330 bfd_vma TOCstart;
2331 bfd_size_type octets;
2333 /* If this is a relocatable link (output_bfd test tells us), just
2334 call the generic function. Any adjustment will be done at final
2335 link time. */
2336 if (output_bfd != NULL)
2337 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2338 input_section, output_bfd, error_message);
2340 TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2341 if (TOCstart == 0)
2342 TOCstart = ppc64_elf_toc (input_section->output_section->owner);
2344 octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2345 bfd_put_64 (abfd, TOCstart + TOC_BASE_OFF, (bfd_byte *) data + octets);
2346 return bfd_reloc_ok;
2349 static bfd_reloc_status_type
2350 ppc64_elf_unhandled_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2351 void *data, asection *input_section,
2352 bfd *output_bfd, char **error_message)
2354 /* If this is a relocatable link (output_bfd test tells us), just
2355 call the generic function. Any adjustment will be done at final
2356 link time. */
2357 if (output_bfd != NULL)
2358 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2359 input_section, output_bfd, error_message);
2361 if (error_message != NULL)
2363 static char buf[60];
2364 sprintf (buf, "generic linker can't handle %s",
2365 reloc_entry->howto->name);
2366 *error_message = buf;
2368 return bfd_reloc_dangerous;
2371 struct ppc64_elf_obj_tdata
2373 struct elf_obj_tdata elf;
2375 /* Shortcuts to dynamic linker sections. */
2376 asection *got;
2377 asection *relgot;
2379 union {
2380 /* Used during garbage collection. We attach global symbols defined
2381 on removed .opd entries to this section so that the sym is removed. */
2382 asection *deleted_section;
2384 /* Used when adding symbols. */
2385 bfd_boolean has_dotsym;
2386 } u;
2388 /* TLS local dynamic got entry handling. Suppose for multiple GOT
2389 sections means we potentially need one of these for each input bfd. */
2390 union {
2391 bfd_signed_vma refcount;
2392 bfd_vma offset;
2393 } tlsld_got;
2395 /* A copy of relocs before they are modified for --emit-relocs. */
2396 Elf_Internal_Rela *opd_relocs;
2399 #define ppc64_elf_tdata(bfd) \
2400 ((struct ppc64_elf_obj_tdata *) (bfd)->tdata.any)
2402 #define ppc64_tlsld_got(bfd) \
2403 (&ppc64_elf_tdata (bfd)->tlsld_got)
2405 /* Override the generic function because we store some extras. */
2407 static bfd_boolean
2408 ppc64_elf_mkobject (bfd *abfd)
2410 bfd_size_type amt = sizeof (struct ppc64_elf_obj_tdata);
2411 abfd->tdata.any = bfd_zalloc (abfd, amt);
2412 if (abfd->tdata.any == NULL)
2413 return FALSE;
2414 return TRUE;
2417 /* Return 1 if target is one of ours. */
2419 static bfd_boolean
2420 is_ppc64_elf_target (const struct bfd_target *targ)
2422 extern const bfd_target bfd_elf64_powerpc_vec;
2423 extern const bfd_target bfd_elf64_powerpcle_vec;
2425 return targ == &bfd_elf64_powerpc_vec || targ == &bfd_elf64_powerpcle_vec;
2428 /* Fix bad default arch selected for a 64 bit input bfd when the
2429 default is 32 bit. */
2431 static bfd_boolean
2432 ppc64_elf_object_p (bfd *abfd)
2434 if (abfd->arch_info->the_default && abfd->arch_info->bits_per_word == 32)
2436 Elf_Internal_Ehdr *i_ehdr = elf_elfheader (abfd);
2438 if (i_ehdr->e_ident[EI_CLASS] == ELFCLASS64)
2440 /* Relies on arch after 32 bit default being 64 bit default. */
2441 abfd->arch_info = abfd->arch_info->next;
2442 BFD_ASSERT (abfd->arch_info->bits_per_word == 64);
2445 return TRUE;
2448 /* Support for core dump NOTE sections. */
2450 static bfd_boolean
2451 ppc64_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
2453 size_t offset, size;
2455 if (note->descsz != 504)
2456 return FALSE;
2458 /* pr_cursig */
2459 elf_tdata (abfd)->core_signal = bfd_get_16 (abfd, note->descdata + 12);
2461 /* pr_pid */
2462 elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, note->descdata + 32);
2464 /* pr_reg */
2465 offset = 112;
2466 size = 384;
2468 /* Make a ".reg/999" section. */
2469 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
2470 size, note->descpos + offset);
2473 static bfd_boolean
2474 ppc64_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
2476 if (note->descsz != 136)
2477 return FALSE;
2479 elf_tdata (abfd)->core_program
2480 = _bfd_elfcore_strndup (abfd, note->descdata + 40, 16);
2481 elf_tdata (abfd)->core_command
2482 = _bfd_elfcore_strndup (abfd, note->descdata + 56, 80);
2484 return TRUE;
2487 /* Merge backend specific data from an object file to the output
2488 object file when linking. */
2490 static bfd_boolean
2491 ppc64_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
2493 /* Check if we have the same endianess. */
2494 if (ibfd->xvec->byteorder != obfd->xvec->byteorder
2495 && ibfd->xvec->byteorder != BFD_ENDIAN_UNKNOWN
2496 && obfd->xvec->byteorder != BFD_ENDIAN_UNKNOWN)
2498 const char *msg;
2500 if (bfd_big_endian (ibfd))
2501 msg = _("%B: compiled for a big endian system "
2502 "and target is little endian");
2503 else
2504 msg = _("%B: compiled for a little endian system "
2505 "and target is big endian");
2507 (*_bfd_error_handler) (msg, ibfd);
2509 bfd_set_error (bfd_error_wrong_format);
2510 return FALSE;
2513 return TRUE;
2516 /* Add extra PPC sections. */
2518 static const struct bfd_elf_special_section ppc64_elf_special_sections[]=
2520 { ".plt", 4, 0, SHT_NOBITS, 0 },
2521 { ".sbss", 5, -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE },
2522 { ".sdata", 6, -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2523 { ".toc", 4, 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2524 { ".toc1", 5, 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2525 { ".tocbss", 7, 0, SHT_NOBITS, SHF_ALLOC + SHF_WRITE },
2526 { NULL, 0, 0, 0, 0 }
2529 struct _ppc64_elf_section_data
2531 struct bfd_elf_section_data elf;
2533 /* An array with one entry for each opd function descriptor. */
2534 union
2536 /* Points to the function code section for local opd entries. */
2537 asection **func_sec;
2538 /* After editing .opd, adjust references to opd local syms. */
2539 long *adjust;
2540 } opd;
2542 /* An array for toc sections, indexed by offset/8.
2543 Specifies the relocation symbol index used at a given toc offset. */
2544 unsigned *t_symndx;
2547 #define ppc64_elf_section_data(sec) \
2548 ((struct _ppc64_elf_section_data *) elf_section_data (sec))
2550 static bfd_boolean
2551 ppc64_elf_new_section_hook (bfd *abfd, asection *sec)
2553 struct _ppc64_elf_section_data *sdata;
2554 bfd_size_type amt = sizeof (*sdata);
2556 sdata = bfd_zalloc (abfd, amt);
2557 if (sdata == NULL)
2558 return FALSE;
2559 sec->used_by_bfd = sdata;
2561 return _bfd_elf_new_section_hook (abfd, sec);
2564 static void *
2565 get_opd_info (asection * sec)
2567 if (sec != NULL
2568 && ppc64_elf_section_data (sec) != NULL
2569 && ppc64_elf_section_data (sec)->opd.adjust != NULL)
2570 return ppc64_elf_section_data (sec)->opd.adjust;
2571 return NULL;
2574 /* Parameters for the qsort hook. */
2575 static asection *synthetic_opd;
2576 static bfd_boolean synthetic_relocatable;
2578 /* qsort comparison function for ppc64_elf_get_synthetic_symtab. */
2580 static int
2581 compare_symbols (const void *ap, const void *bp)
2583 const asymbol *a = * (const asymbol **) ap;
2584 const asymbol *b = * (const asymbol **) bp;
2586 /* Section symbols first. */
2587 if ((a->flags & BSF_SECTION_SYM) && !(b->flags & BSF_SECTION_SYM))
2588 return -1;
2589 if (!(a->flags & BSF_SECTION_SYM) && (b->flags & BSF_SECTION_SYM))
2590 return 1;
2592 /* then .opd symbols. */
2593 if (a->section == synthetic_opd && b->section != synthetic_opd)
2594 return -1;
2595 if (a->section != synthetic_opd && b->section == synthetic_opd)
2596 return 1;
2598 /* then other code symbols. */
2599 if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
2600 == (SEC_CODE | SEC_ALLOC)
2601 && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
2602 != (SEC_CODE | SEC_ALLOC))
2603 return -1;
2605 if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
2606 != (SEC_CODE | SEC_ALLOC)
2607 && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
2608 == (SEC_CODE | SEC_ALLOC))
2609 return 1;
2611 if (synthetic_relocatable)
2613 if (a->section->id < b->section->id)
2614 return -1;
2616 if (a->section->id > b->section->id)
2617 return 1;
2620 if (a->value + a->section->vma < b->value + b->section->vma)
2621 return -1;
2623 if (a->value + a->section->vma > b->value + b->section->vma)
2624 return 1;
2626 return 0;
2629 /* Search SYMS for a symbol of the given VALUE. */
2631 static asymbol *
2632 sym_exists_at (asymbol **syms, long lo, long hi, int id, bfd_vma value)
2634 long mid;
2636 if (id == -1)
2638 while (lo < hi)
2640 mid = (lo + hi) >> 1;
2641 if (syms[mid]->value + syms[mid]->section->vma < value)
2642 lo = mid + 1;
2643 else if (syms[mid]->value + syms[mid]->section->vma > value)
2644 hi = mid;
2645 else
2646 return syms[mid];
2649 else
2651 while (lo < hi)
2653 mid = (lo + hi) >> 1;
2654 if (syms[mid]->section->id < id)
2655 lo = mid + 1;
2656 else if (syms[mid]->section->id > id)
2657 hi = mid;
2658 else if (syms[mid]->value < value)
2659 lo = mid + 1;
2660 else if (syms[mid]->value > value)
2661 hi = mid;
2662 else
2663 return syms[mid];
2666 return NULL;
2669 /* Create synthetic symbols, effectively restoring "dot-symbol" function
2670 entry syms. */
2672 static long
2673 ppc64_elf_get_synthetic_symtab (bfd *abfd,
2674 long static_count, asymbol **static_syms,
2675 long dyn_count, asymbol **dyn_syms,
2676 asymbol **ret)
2678 asymbol *s;
2679 long i;
2680 long count;
2681 char *names;
2682 long symcount, codesecsym, codesecsymend, secsymend, opdsymend;
2683 asection *opd;
2684 bfd_boolean relocatable = (abfd->flags & (EXEC_P | DYNAMIC)) == 0;
2685 asymbol **syms;
2687 *ret = NULL;
2689 opd = bfd_get_section_by_name (abfd, ".opd");
2690 if (opd == NULL)
2691 return 0;
2693 symcount = static_count;
2694 if (!relocatable)
2695 symcount += dyn_count;
2696 if (symcount == 0)
2697 return 0;
2699 syms = bfd_malloc ((symcount + 1) * sizeof (*syms));
2700 if (syms == NULL)
2701 return -1;
2703 if (!relocatable && static_count != 0 && dyn_count != 0)
2705 /* Use both symbol tables. */
2706 memcpy (syms, static_syms, static_count * sizeof (*syms));
2707 memcpy (syms + static_count, dyn_syms, (dyn_count + 1) * sizeof (*syms));
2709 else if (!relocatable && static_count == 0)
2710 memcpy (syms, dyn_syms, (symcount + 1) * sizeof (*syms));
2711 else
2712 memcpy (syms, static_syms, (symcount + 1) * sizeof (*syms));
2714 synthetic_opd = opd;
2715 synthetic_relocatable = relocatable;
2716 qsort (syms, symcount, sizeof (*syms), compare_symbols);
2718 if (!relocatable && symcount > 1)
2720 long j;
2721 /* Trim duplicate syms, since we may have merged the normal and
2722 dynamic symbols. Actually, we only care about syms that have
2723 different values, so trim any with the same value. */
2724 for (i = 1, j = 1; i < symcount; ++i)
2725 if (syms[i - 1]->value + syms[i - 1]->section->vma
2726 != syms[i]->value + syms[i]->section->vma)
2727 syms[j++] = syms[i];
2728 symcount = j;
2731 i = 0;
2732 if (syms[i]->section == opd)
2733 ++i;
2734 codesecsym = i;
2736 for (; i < symcount; ++i)
2737 if (((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
2738 != (SEC_CODE | SEC_ALLOC))
2739 || (syms[i]->flags & BSF_SECTION_SYM) == 0)
2740 break;
2741 codesecsymend = i;
2743 for (; i < symcount; ++i)
2744 if ((syms[i]->flags & BSF_SECTION_SYM) == 0)
2745 break;
2746 secsymend = i;
2748 for (; i < symcount; ++i)
2749 if (syms[i]->section != opd)
2750 break;
2751 opdsymend = i;
2753 for (; i < symcount; ++i)
2754 if ((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
2755 != (SEC_CODE | SEC_ALLOC))
2756 break;
2757 symcount = i;
2759 count = 0;
2760 if (opdsymend == secsymend)
2761 goto done;
2763 if (relocatable)
2765 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
2766 arelent *r;
2767 size_t size;
2768 long relcount;
2770 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
2771 relcount = (opd->flags & SEC_RELOC) ? opd->reloc_count : 0;
2772 if (relcount == 0)
2773 goto done;
2775 if (!(*slurp_relocs) (abfd, opd, static_syms, FALSE))
2777 count = -1;
2778 goto done;
2781 size = 0;
2782 for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
2784 asymbol *sym;
2786 while (r < opd->relocation + relcount
2787 && r->address < syms[i]->value + opd->vma)
2788 ++r;
2790 if (r == opd->relocation + relcount)
2791 break;
2793 if (r->address != syms[i]->value + opd->vma)
2794 continue;
2796 if (r->howto->type != R_PPC64_ADDR64)
2797 continue;
2799 sym = *r->sym_ptr_ptr;
2800 if (!sym_exists_at (syms, opdsymend, symcount,
2801 sym->section->id, sym->value + r->addend))
2803 ++count;
2804 size += sizeof (asymbol);
2805 size += strlen (syms[i]->name) + 2;
2809 s = *ret = bfd_malloc (size);
2810 if (s == NULL)
2812 count = -1;
2813 goto done;
2816 names = (char *) (s + count);
2818 for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
2820 asymbol *sym;
2822 while (r < opd->relocation + relcount
2823 && r->address < syms[i]->value + opd->vma)
2824 ++r;
2826 if (r == opd->relocation + relcount)
2827 break;
2829 if (r->address != syms[i]->value + opd->vma)
2830 continue;
2832 if (r->howto->type != R_PPC64_ADDR64)
2833 continue;
2835 sym = *r->sym_ptr_ptr;
2836 if (!sym_exists_at (syms, opdsymend, symcount,
2837 sym->section->id, sym->value + r->addend))
2839 size_t len;
2841 *s = *syms[i];
2842 s->section = sym->section;
2843 s->value = sym->value + r->addend;
2844 s->name = names;
2845 *names++ = '.';
2846 len = strlen (syms[i]->name);
2847 memcpy (names, syms[i]->name, len + 1);
2848 names += len + 1;
2849 s++;
2853 else
2855 bfd_byte *contents;
2856 size_t size;
2858 if (!bfd_malloc_and_get_section (abfd, opd, &contents))
2860 if (contents)
2862 free_contents_and_exit:
2863 free (contents);
2865 count = -1;
2866 goto done;
2869 size = 0;
2870 for (i = secsymend; i < opdsymend; ++i)
2872 bfd_vma ent;
2874 ent = bfd_get_64 (abfd, contents + syms[i]->value);
2875 if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
2877 ++count;
2878 size += sizeof (asymbol);
2879 size += strlen (syms[i]->name) + 2;
2883 s = *ret = bfd_malloc (size);
2884 if (s == NULL)
2885 goto free_contents_and_exit;
2887 names = (char *) (s + count);
2889 for (i = secsymend; i < opdsymend; ++i)
2891 bfd_vma ent;
2893 ent = bfd_get_64 (abfd, contents + syms[i]->value);
2894 if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
2896 long lo, hi;
2897 size_t len;
2898 asection *sec = abfd->sections;
2900 *s = *syms[i];
2901 lo = codesecsym;
2902 hi = codesecsymend;
2903 while (lo < hi)
2905 long mid = (lo + hi) >> 1;
2906 if (syms[mid]->section->vma < ent)
2907 lo = mid + 1;
2908 else if (syms[mid]->section->vma > ent)
2909 hi = mid;
2910 else
2912 sec = syms[mid]->section;
2913 break;
2917 if (lo >= hi && lo > codesecsym)
2918 sec = syms[lo - 1]->section;
2920 for (; sec != NULL; sec = sec->next)
2922 if (sec->vma > ent)
2923 break;
2924 if ((sec->flags & SEC_ALLOC) == 0
2925 || (sec->flags & SEC_LOAD) == 0)
2926 break;
2927 if ((sec->flags & SEC_CODE) != 0)
2928 s->section = sec;
2930 s->value = ent - s->section->vma;
2931 s->name = names;
2932 *names++ = '.';
2933 len = strlen (syms[i]->name);
2934 memcpy (names, syms[i]->name, len + 1);
2935 names += len + 1;
2936 s++;
2939 free (contents);
2942 done:
2943 free (syms);
2944 return count;
2947 /* The following functions are specific to the ELF linker, while
2948 functions above are used generally. Those named ppc64_elf_* are
2949 called by the main ELF linker code. They appear in this file more
2950 or less in the order in which they are called. eg.
2951 ppc64_elf_check_relocs is called early in the link process,
2952 ppc64_elf_finish_dynamic_sections is one of the last functions
2953 called.
2955 PowerPC64-ELF uses a similar scheme to PowerPC64-XCOFF in that
2956 functions have both a function code symbol and a function descriptor
2957 symbol. A call to foo in a relocatable object file looks like:
2959 . .text
2960 . x:
2961 . bl .foo
2962 . nop
2964 The function definition in another object file might be:
2966 . .section .opd
2967 . foo: .quad .foo
2968 . .quad .TOC.@tocbase
2969 . .quad 0
2971 . .text
2972 . .foo: blr
2974 When the linker resolves the call during a static link, the branch
2975 unsurprisingly just goes to .foo and the .opd information is unused.
2976 If the function definition is in a shared library, things are a little
2977 different: The call goes via a plt call stub, the opd information gets
2978 copied to the plt, and the linker patches the nop.
2980 . x:
2981 . bl .foo_stub
2982 . ld 2,40(1)
2985 . .foo_stub:
2986 . addis 12,2,Lfoo@toc@ha # in practice, the call stub
2987 . addi 12,12,Lfoo@toc@l # is slightly optimized, but
2988 . std 2,40(1) # this is the general idea
2989 . ld 11,0(12)
2990 . ld 2,8(12)
2991 . mtctr 11
2992 . ld 11,16(12)
2993 . bctr
2995 . .section .plt
2996 . Lfoo: reloc (R_PPC64_JMP_SLOT, foo)
2998 The "reloc ()" notation is supposed to indicate that the linker emits
2999 an R_PPC64_JMP_SLOT reloc against foo. The dynamic linker does the opd
3000 copying.
3002 What are the difficulties here? Well, firstly, the relocations
3003 examined by the linker in check_relocs are against the function code
3004 sym .foo, while the dynamic relocation in the plt is emitted against
3005 the function descriptor symbol, foo. Somewhere along the line, we need
3006 to carefully copy dynamic link information from one symbol to the other.
3007 Secondly, the generic part of the elf linker will make .foo a dynamic
3008 symbol as is normal for most other backends. We need foo dynamic
3009 instead, at least for an application final link. However, when
3010 creating a shared library containing foo, we need to have both symbols
3011 dynamic so that references to .foo are satisfied during the early
3012 stages of linking. Otherwise the linker might decide to pull in a
3013 definition from some other object, eg. a static library.
3015 Update: As of August 2004, we support a new convention. Function
3016 calls may use the function descriptor symbol, ie. "bl foo". This
3017 behaves exactly as "bl .foo". */
3019 /* The linker needs to keep track of the number of relocs that it
3020 decides to copy as dynamic relocs in check_relocs for each symbol.
3021 This is so that it can later discard them if they are found to be
3022 unnecessary. We store the information in a field extending the
3023 regular ELF linker hash table. */
3025 struct ppc_dyn_relocs
3027 struct ppc_dyn_relocs *next;
3029 /* The input section of the reloc. */
3030 asection *sec;
3032 /* Total number of relocs copied for the input section. */
3033 bfd_size_type count;
3035 /* Number of pc-relative relocs copied for the input section. */
3036 bfd_size_type pc_count;
3039 /* Track GOT entries needed for a given symbol. We might need more
3040 than one got entry per symbol. */
3041 struct got_entry
3043 struct got_entry *next;
3045 /* The symbol addend that we'll be placing in the GOT. */
3046 bfd_vma addend;
3048 /* Unlike other ELF targets, we use separate GOT entries for the same
3049 symbol referenced from different input files. This is to support
3050 automatic multiple TOC/GOT sections, where the TOC base can vary
3051 from one input file to another.
3053 Point to the BFD owning this GOT entry. */
3054 bfd *owner;
3056 /* Zero for non-tls entries, or TLS_TLS and one of TLS_GD, TLS_LD,
3057 TLS_TPREL or TLS_DTPREL for tls entries. */
3058 char tls_type;
3060 /* Reference count until size_dynamic_sections, GOT offset thereafter. */
3061 union
3063 bfd_signed_vma refcount;
3064 bfd_vma offset;
3065 } got;
3068 /* The same for PLT. */
3069 struct plt_entry
3071 struct plt_entry *next;
3073 bfd_vma addend;
3075 union
3077 bfd_signed_vma refcount;
3078 bfd_vma offset;
3079 } plt;
3082 /* Of those relocs that might be copied as dynamic relocs, this macro
3083 selects those that must be copied when linking a shared library,
3084 even when the symbol is local. */
3086 #define MUST_BE_DYN_RELOC(RTYPE) \
3087 ((RTYPE) != R_PPC64_REL32 \
3088 && (RTYPE) != R_PPC64_REL64 \
3089 && (RTYPE) != R_PPC64_REL30)
3091 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
3092 copying dynamic variables from a shared lib into an app's dynbss
3093 section, and instead use a dynamic relocation to point into the
3094 shared lib. With code that gcc generates, it's vital that this be
3095 enabled; In the PowerPC64 ABI, the address of a function is actually
3096 the address of a function descriptor, which resides in the .opd
3097 section. gcc uses the descriptor directly rather than going via the
3098 GOT as some other ABI's do, which means that initialized function
3099 pointers must reference the descriptor. Thus, a function pointer
3100 initialized to the address of a function in a shared library will
3101 either require a copy reloc, or a dynamic reloc. Using a copy reloc
3102 redefines the function descriptor symbol to point to the copy. This
3103 presents a problem as a plt entry for that function is also
3104 initialized from the function descriptor symbol and the copy reloc
3105 may not be initialized first. */
3106 #define ELIMINATE_COPY_RELOCS 1
3108 /* Section name for stubs is the associated section name plus this
3109 string. */
3110 #define STUB_SUFFIX ".stub"
3112 /* Linker stubs.
3113 ppc_stub_long_branch:
3114 Used when a 14 bit branch (or even a 24 bit branch) can't reach its
3115 destination, but a 24 bit branch in a stub section will reach.
3116 . b dest
3118 ppc_stub_plt_branch:
3119 Similar to the above, but a 24 bit branch in the stub section won't
3120 reach its destination.
3121 . addis %r12,%r2,xxx@toc@ha
3122 . ld %r11,xxx@toc@l(%r12)
3123 . mtctr %r11
3124 . bctr
3126 ppc_stub_plt_call:
3127 Used to call a function in a shared library. If it so happens that
3128 the plt entry referenced crosses a 64k boundary, then an extra
3129 "addis %r12,%r12,1" will be inserted before the load at xxx+8 or
3130 xxx+16 as appropriate.
3131 . addis %r12,%r2,xxx@toc@ha
3132 . std %r2,40(%r1)
3133 . ld %r11,xxx+0@toc@l(%r12)
3134 . ld %r2,xxx+8@toc@l(%r12)
3135 . mtctr %r11
3136 . ld %r11,xxx+16@toc@l(%r12)
3137 . bctr
3139 ppc_stub_long_branch and ppc_stub_plt_branch may also have additional
3140 code to adjust the value and save r2 to support multiple toc sections.
3141 A ppc_stub_long_branch with an r2 offset looks like:
3142 . std %r2,40(%r1)
3143 . addis %r2,%r2,off@ha
3144 . addi %r2,%r2,off@l
3145 . b dest
3147 A ppc_stub_plt_branch with an r2 offset looks like:
3148 . std %r2,40(%r1)
3149 . addis %r12,%r2,xxx@toc@ha
3150 . ld %r11,xxx@toc@l(%r12)
3151 . addis %r2,%r2,off@ha
3152 . addi %r2,%r2,off@l
3153 . mtctr %r11
3154 . bctr
3157 enum ppc_stub_type {
3158 ppc_stub_none,
3159 ppc_stub_long_branch,
3160 ppc_stub_long_branch_r2off,
3161 ppc_stub_plt_branch,
3162 ppc_stub_plt_branch_r2off,
3163 ppc_stub_plt_call
3166 struct ppc_stub_hash_entry {
3168 /* Base hash table entry structure. */
3169 struct bfd_hash_entry root;
3171 enum ppc_stub_type stub_type;
3173 /* The stub section. */
3174 asection *stub_sec;
3176 /* Offset within stub_sec of the beginning of this stub. */
3177 bfd_vma stub_offset;
3179 /* Given the symbol's value and its section we can determine its final
3180 value when building the stubs (so the stub knows where to jump. */
3181 bfd_vma target_value;
3182 asection *target_section;
3184 /* The symbol table entry, if any, that this was derived from. */
3185 struct ppc_link_hash_entry *h;
3187 /* And the reloc addend that this was derived from. */
3188 bfd_vma addend;
3190 /* Where this stub is being called from, or, in the case of combined
3191 stub sections, the first input section in the group. */
3192 asection *id_sec;
3195 struct ppc_branch_hash_entry {
3197 /* Base hash table entry structure. */
3198 struct bfd_hash_entry root;
3200 /* Offset within branch lookup table. */
3201 unsigned int offset;
3203 /* Generation marker. */
3204 unsigned int iter;
3207 struct ppc_link_hash_entry
3209 struct elf_link_hash_entry elf;
3211 /* A pointer to the most recently used stub hash entry against this
3212 symbol. */
3213 struct ppc_stub_hash_entry *stub_cache;
3215 /* Track dynamic relocs copied for this symbol. */
3216 struct ppc_dyn_relocs *dyn_relocs;
3218 /* Link between function code and descriptor symbols. */
3219 struct ppc_link_hash_entry *oh;
3221 /* Flag function code and descriptor symbols. */
3222 unsigned int is_func:1;
3223 unsigned int is_func_descriptor:1;
3224 unsigned int fake:1;
3226 /* Whether global opd/toc sym has been adjusted or not.
3227 After ppc64_elf_edit_opd/ppc64_elf_edit_toc has run, this flag
3228 should be set for all globals defined in any opd/toc section. */
3229 unsigned int adjust_done:1;
3231 /* Set if we twiddled this symbol to weak at some stage. */
3232 unsigned int was_undefined:1;
3234 /* Contexts in which symbol is used in the GOT (or TOC).
3235 TLS_GD .. TLS_EXPLICIT bits are or'd into the mask as the
3236 corresponding relocs are encountered during check_relocs.
3237 tls_optimize clears TLS_GD .. TLS_TPREL when optimizing to
3238 indicate the corresponding GOT entry type is not needed.
3239 tls_optimize may also set TLS_TPRELGD when a GD reloc turns into
3240 a TPREL one. We use a separate flag rather than setting TPREL
3241 just for convenience in distinguishing the two cases. */
3242 #define TLS_GD 1 /* GD reloc. */
3243 #define TLS_LD 2 /* LD reloc. */
3244 #define TLS_TPREL 4 /* TPREL reloc, => IE. */
3245 #define TLS_DTPREL 8 /* DTPREL reloc, => LD. */
3246 #define TLS_TLS 16 /* Any TLS reloc. */
3247 #define TLS_EXPLICIT 32 /* Marks TOC section TLS relocs. */
3248 #define TLS_TPRELGD 64 /* TPREL reloc resulting from GD->IE. */
3249 char tls_mask;
3252 /* ppc64 ELF linker hash table. */
3254 struct ppc_link_hash_table
3256 struct elf_link_hash_table elf;
3258 /* The stub hash table. */
3259 struct bfd_hash_table stub_hash_table;
3261 /* Another hash table for plt_branch stubs. */
3262 struct bfd_hash_table branch_hash_table;
3264 /* Linker stub bfd. */
3265 bfd *stub_bfd;
3267 /* Linker call-backs. */
3268 asection * (*add_stub_section) (const char *, asection *);
3269 void (*layout_sections_again) (void);
3271 /* Array to keep track of which stub sections have been created, and
3272 information on stub grouping. */
3273 struct map_stub {
3274 /* This is the section to which stubs in the group will be attached. */
3275 asection *link_sec;
3276 /* The stub section. */
3277 asection *stub_sec;
3278 /* Along with elf_gp, specifies the TOC pointer used in this group. */
3279 bfd_vma toc_off;
3280 } *stub_group;
3282 /* Temp used when calculating TOC pointers. */
3283 bfd_vma toc_curr;
3285 /* Highest input section id. */
3286 int top_id;
3288 /* Highest output section index. */
3289 int top_index;
3291 /* List of input sections for each output section. */
3292 asection **input_list;
3294 /* Short-cuts to get to dynamic linker sections. */
3295 asection *got;
3296 asection *plt;
3297 asection *relplt;
3298 asection *dynbss;
3299 asection *relbss;
3300 asection *glink;
3301 asection *sfpr;
3302 asection *brlt;
3303 asection *relbrlt;
3305 /* Shortcut to .__tls_get_addr and __tls_get_addr. */
3306 struct ppc_link_hash_entry *tls_get_addr;
3307 struct ppc_link_hash_entry *tls_get_addr_fd;
3309 /* Statistics. */
3310 unsigned long stub_count[ppc_stub_plt_call];
3312 /* Number of stubs against global syms. */
3313 unsigned long stub_globals;
3315 /* Set if we should emit symbols for stubs. */
3316 unsigned int emit_stub_syms:1;
3318 /* Support for multiple toc sections. */
3319 unsigned int no_multi_toc:1;
3320 unsigned int multi_toc_needed:1;
3322 /* Set on error. */
3323 unsigned int stub_error:1;
3325 /* Flag set when small branches are detected. Used to
3326 select suitable defaults for the stub group size. */
3327 unsigned int has_14bit_branch:1;
3329 /* Temp used by ppc64_elf_check_directives. */
3330 unsigned int twiddled_syms:1;
3332 /* Incremented every time we size stubs. */
3333 unsigned int stub_iteration;
3335 /* Small local sym to section mapping cache. */
3336 struct sym_sec_cache sym_sec;
3339 /* Rename some of the generic section flags to better document how they
3340 are used here. */
3341 #define has_toc_reloc has_gp_reloc
3342 #define makes_toc_func_call need_finalize_relax
3343 #define call_check_in_progress reloc_done
3345 /* Get the ppc64 ELF linker hash table from a link_info structure. */
3347 #define ppc_hash_table(p) \
3348 ((struct ppc_link_hash_table *) ((p)->hash))
3350 #define ppc_stub_hash_lookup(table, string, create, copy) \
3351 ((struct ppc_stub_hash_entry *) \
3352 bfd_hash_lookup ((table), (string), (create), (copy)))
3354 #define ppc_branch_hash_lookup(table, string, create, copy) \
3355 ((struct ppc_branch_hash_entry *) \
3356 bfd_hash_lookup ((table), (string), (create), (copy)))
3358 /* Create an entry in the stub hash table. */
3360 static struct bfd_hash_entry *
3361 stub_hash_newfunc (struct bfd_hash_entry *entry,
3362 struct bfd_hash_table *table,
3363 const char *string)
3365 /* Allocate the structure if it has not already been allocated by a
3366 subclass. */
3367 if (entry == NULL)
3369 entry = bfd_hash_allocate (table, sizeof (struct ppc_stub_hash_entry));
3370 if (entry == NULL)
3371 return entry;
3374 /* Call the allocation method of the superclass. */
3375 entry = bfd_hash_newfunc (entry, table, string);
3376 if (entry != NULL)
3378 struct ppc_stub_hash_entry *eh;
3380 /* Initialize the local fields. */
3381 eh = (struct ppc_stub_hash_entry *) entry;
3382 eh->stub_type = ppc_stub_none;
3383 eh->stub_sec = NULL;
3384 eh->stub_offset = 0;
3385 eh->target_value = 0;
3386 eh->target_section = NULL;
3387 eh->h = NULL;
3388 eh->id_sec = NULL;
3391 return entry;
3394 /* Create an entry in the branch hash table. */
3396 static struct bfd_hash_entry *
3397 branch_hash_newfunc (struct bfd_hash_entry *entry,
3398 struct bfd_hash_table *table,
3399 const char *string)
3401 /* Allocate the structure if it has not already been allocated by a
3402 subclass. */
3403 if (entry == NULL)
3405 entry = bfd_hash_allocate (table, sizeof (struct ppc_branch_hash_entry));
3406 if (entry == NULL)
3407 return entry;
3410 /* Call the allocation method of the superclass. */
3411 entry = bfd_hash_newfunc (entry, table, string);
3412 if (entry != NULL)
3414 struct ppc_branch_hash_entry *eh;
3416 /* Initialize the local fields. */
3417 eh = (struct ppc_branch_hash_entry *) entry;
3418 eh->offset = 0;
3419 eh->iter = 0;
3422 return entry;
3425 /* Create an entry in a ppc64 ELF linker hash table. */
3427 static struct bfd_hash_entry *
3428 link_hash_newfunc (struct bfd_hash_entry *entry,
3429 struct bfd_hash_table *table,
3430 const char *string)
3432 /* Allocate the structure if it has not already been allocated by a
3433 subclass. */
3434 if (entry == NULL)
3436 entry = bfd_hash_allocate (table, sizeof (struct ppc_link_hash_entry));
3437 if (entry == NULL)
3438 return entry;
3441 /* Call the allocation method of the superclass. */
3442 entry = _bfd_elf_link_hash_newfunc (entry, table, string);
3443 if (entry != NULL)
3445 struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) entry;
3447 memset (&eh->stub_cache, 0,
3448 (sizeof (struct ppc_link_hash_entry)
3449 - offsetof (struct ppc_link_hash_entry, stub_cache)));
3452 return entry;
3455 /* Create a ppc64 ELF linker hash table. */
3457 static struct bfd_link_hash_table *
3458 ppc64_elf_link_hash_table_create (bfd *abfd)
3460 struct ppc_link_hash_table *htab;
3461 bfd_size_type amt = sizeof (struct ppc_link_hash_table);
3463 htab = bfd_zmalloc (amt);
3464 if (htab == NULL)
3465 return NULL;
3467 if (!_bfd_elf_link_hash_table_init (&htab->elf, abfd, link_hash_newfunc,
3468 sizeof (struct ppc_link_hash_entry)))
3470 free (htab);
3471 return NULL;
3474 /* Init the stub hash table too. */
3475 if (!bfd_hash_table_init (&htab->stub_hash_table, stub_hash_newfunc,
3476 sizeof (struct ppc_stub_hash_entry)))
3477 return NULL;
3479 /* And the branch hash table. */
3480 if (!bfd_hash_table_init (&htab->branch_hash_table, branch_hash_newfunc,
3481 sizeof (struct ppc_branch_hash_entry)))
3482 return NULL;
3484 /* Initializing two fields of the union is just cosmetic. We really
3485 only care about glist, but when compiled on a 32-bit host the
3486 bfd_vma fields are larger. Setting the bfd_vma to zero makes
3487 debugger inspection of these fields look nicer. */
3488 htab->elf.init_got_refcount.refcount = 0;
3489 htab->elf.init_got_refcount.glist = NULL;
3490 htab->elf.init_plt_refcount.refcount = 0;
3491 htab->elf.init_plt_refcount.glist = NULL;
3492 htab->elf.init_got_offset.offset = 0;
3493 htab->elf.init_got_offset.glist = NULL;
3494 htab->elf.init_plt_offset.offset = 0;
3495 htab->elf.init_plt_offset.glist = NULL;
3497 return &htab->elf.root;
3500 /* Free the derived linker hash table. */
3502 static void
3503 ppc64_elf_link_hash_table_free (struct bfd_link_hash_table *hash)
3505 struct ppc_link_hash_table *ret = (struct ppc_link_hash_table *) hash;
3507 bfd_hash_table_free (&ret->stub_hash_table);
3508 bfd_hash_table_free (&ret->branch_hash_table);
3509 _bfd_generic_link_hash_table_free (hash);
3512 /* Satisfy the ELF linker by filling in some fields in our fake bfd. */
3514 void
3515 ppc64_elf_init_stub_bfd (bfd *abfd, struct bfd_link_info *info)
3517 struct ppc_link_hash_table *htab;
3519 elf_elfheader (abfd)->e_ident[EI_CLASS] = ELFCLASS64;
3521 /* Always hook our dynamic sections into the first bfd, which is the
3522 linker created stub bfd. This ensures that the GOT header is at
3523 the start of the output TOC section. */
3524 htab = ppc_hash_table (info);
3525 htab->stub_bfd = abfd;
3526 htab->elf.dynobj = abfd;
3529 /* Build a name for an entry in the stub hash table. */
3531 static char *
3532 ppc_stub_name (const asection *input_section,
3533 const asection *sym_sec,
3534 const struct ppc_link_hash_entry *h,
3535 const Elf_Internal_Rela *rel)
3537 char *stub_name;
3538 bfd_size_type len;
3540 /* rel->r_addend is actually 64 bit, but who uses more than +/- 2^31
3541 offsets from a sym as a branch target? In fact, we could
3542 probably assume the addend is always zero. */
3543 BFD_ASSERT (((int) rel->r_addend & 0xffffffff) == rel->r_addend);
3545 if (h)
3547 len = 8 + 1 + strlen (h->elf.root.root.string) + 1 + 8 + 1;
3548 stub_name = bfd_malloc (len);
3549 if (stub_name == NULL)
3550 return stub_name;
3552 sprintf (stub_name, "%08x.%s+%x",
3553 input_section->id & 0xffffffff,
3554 h->elf.root.root.string,
3555 (int) rel->r_addend & 0xffffffff);
3557 else
3559 len = 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1;
3560 stub_name = bfd_malloc (len);
3561 if (stub_name == NULL)
3562 return stub_name;
3564 sprintf (stub_name, "%08x.%x:%x+%x",
3565 input_section->id & 0xffffffff,
3566 sym_sec->id & 0xffffffff,
3567 (int) ELF64_R_SYM (rel->r_info) & 0xffffffff,
3568 (int) rel->r_addend & 0xffffffff);
3570 if (stub_name[len - 2] == '+' && stub_name[len - 1] == '0')
3571 stub_name[len - 2] = 0;
3572 return stub_name;
3575 /* Look up an entry in the stub hash. Stub entries are cached because
3576 creating the stub name takes a bit of time. */
3578 static struct ppc_stub_hash_entry *
3579 ppc_get_stub_entry (const asection *input_section,
3580 const asection *sym_sec,
3581 struct ppc_link_hash_entry *h,
3582 const Elf_Internal_Rela *rel,
3583 struct ppc_link_hash_table *htab)
3585 struct ppc_stub_hash_entry *stub_entry;
3586 const asection *id_sec;
3588 /* If this input section is part of a group of sections sharing one
3589 stub section, then use the id of the first section in the group.
3590 Stub names need to include a section id, as there may well be
3591 more than one stub used to reach say, printf, and we need to
3592 distinguish between them. */
3593 id_sec = htab->stub_group[input_section->id].link_sec;
3595 if (h != NULL && h->stub_cache != NULL
3596 && h->stub_cache->h == h
3597 && h->stub_cache->id_sec == id_sec)
3599 stub_entry = h->stub_cache;
3601 else
3603 char *stub_name;
3605 stub_name = ppc_stub_name (id_sec, sym_sec, h, rel);
3606 if (stub_name == NULL)
3607 return NULL;
3609 stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
3610 stub_name, FALSE, FALSE);
3611 if (h != NULL)
3612 h->stub_cache = stub_entry;
3614 free (stub_name);
3617 return stub_entry;
3620 /* Add a new stub entry to the stub hash. Not all fields of the new
3621 stub entry are initialised. */
3623 static struct ppc_stub_hash_entry *
3624 ppc_add_stub (const char *stub_name,
3625 asection *section,
3626 struct ppc_link_hash_table *htab)
3628 asection *link_sec;
3629 asection *stub_sec;
3630 struct ppc_stub_hash_entry *stub_entry;
3632 link_sec = htab->stub_group[section->id].link_sec;
3633 stub_sec = htab->stub_group[section->id].stub_sec;
3634 if (stub_sec == NULL)
3636 stub_sec = htab->stub_group[link_sec->id].stub_sec;
3637 if (stub_sec == NULL)
3639 size_t namelen;
3640 bfd_size_type len;
3641 char *s_name;
3643 namelen = strlen (link_sec->name);
3644 len = namelen + sizeof (STUB_SUFFIX);
3645 s_name = bfd_alloc (htab->stub_bfd, len);
3646 if (s_name == NULL)
3647 return NULL;
3649 memcpy (s_name, link_sec->name, namelen);
3650 memcpy (s_name + namelen, STUB_SUFFIX, sizeof (STUB_SUFFIX));
3651 stub_sec = (*htab->add_stub_section) (s_name, link_sec);
3652 if (stub_sec == NULL)
3653 return NULL;
3654 htab->stub_group[link_sec->id].stub_sec = stub_sec;
3656 htab->stub_group[section->id].stub_sec = stub_sec;
3659 /* Enter this entry into the linker stub hash table. */
3660 stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table, stub_name,
3661 TRUE, FALSE);
3662 if (stub_entry == NULL)
3664 (*_bfd_error_handler) (_("%B: cannot create stub entry %s"),
3665 section->owner, stub_name);
3666 return NULL;
3669 stub_entry->stub_sec = stub_sec;
3670 stub_entry->stub_offset = 0;
3671 stub_entry->id_sec = link_sec;
3672 return stub_entry;
3675 /* Create sections for linker generated code. */
3677 static bfd_boolean
3678 create_linkage_sections (bfd *dynobj, struct bfd_link_info *info)
3680 struct ppc_link_hash_table *htab;
3681 flagword flags;
3683 htab = ppc_hash_table (info);
3685 /* Create .sfpr for code to save and restore fp regs. */
3686 flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY
3687 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
3688 htab->sfpr = bfd_make_section_anyway_with_flags (dynobj, ".sfpr",
3689 flags);
3690 if (htab->sfpr == NULL
3691 || ! bfd_set_section_alignment (dynobj, htab->sfpr, 2))
3692 return FALSE;
3694 /* Create .glink for lazy dynamic linking support. */
3695 htab->glink = bfd_make_section_anyway_with_flags (dynobj, ".glink",
3696 flags);
3697 if (htab->glink == NULL
3698 || ! bfd_set_section_alignment (dynobj, htab->glink, 2))
3699 return FALSE;
3701 /* Create branch lookup table for plt_branch stubs. */
3702 if (info->shared)
3704 flags = (SEC_ALLOC | SEC_LOAD
3705 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
3706 htab->brlt
3707 = bfd_make_section_anyway_with_flags (dynobj, ".data.rel.ro.brlt",
3708 flags);
3710 else
3712 flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
3713 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
3714 htab->brlt
3715 = bfd_make_section_anyway_with_flags (dynobj, ".rodata.brlt", flags);
3718 if (htab->brlt == NULL
3719 || ! bfd_set_section_alignment (dynobj, htab->brlt, 3))
3720 return FALSE;
3722 if (info->shared)
3724 flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
3725 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
3726 htab->relbrlt
3727 = bfd_make_section_anyway_with_flags (dynobj, ".rela.data.rel.ro.brlt",
3728 flags);
3730 else if (info->emitrelocations)
3732 flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
3733 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
3734 htab->relbrlt
3735 = bfd_make_section_anyway_with_flags (dynobj, ".rela.rodata.brlt",
3736 flags);
3738 else
3739 return TRUE;
3741 if (!htab->relbrlt
3742 || ! bfd_set_section_alignment (dynobj, htab->relbrlt, 3))
3743 return FALSE;
3745 return TRUE;
3748 /* Create .got and .rela.got sections in ABFD, and .got in dynobj if
3749 not already done. */
3751 static bfd_boolean
3752 create_got_section (bfd *abfd, struct bfd_link_info *info)
3754 asection *got, *relgot;
3755 flagword flags;
3756 struct ppc_link_hash_table *htab = ppc_hash_table (info);
3758 if (!htab->got)
3760 if (! _bfd_elf_create_got_section (htab->elf.dynobj, info))
3761 return FALSE;
3763 htab->got = bfd_get_section_by_name (htab->elf.dynobj, ".got");
3764 if (!htab->got)
3765 abort ();
3768 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
3769 | SEC_LINKER_CREATED);
3771 got = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
3772 if (!got
3773 || !bfd_set_section_alignment (abfd, got, 3))
3774 return FALSE;
3776 relgot = bfd_make_section_anyway_with_flags (abfd, ".rela.got",
3777 flags | SEC_READONLY);
3778 if (!relgot
3779 || ! bfd_set_section_alignment (abfd, relgot, 3))
3780 return FALSE;
3782 ppc64_elf_tdata (abfd)->got = got;
3783 ppc64_elf_tdata (abfd)->relgot = relgot;
3784 return TRUE;
3787 /* Create the dynamic sections, and set up shortcuts. */
3789 static bfd_boolean
3790 ppc64_elf_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
3792 struct ppc_link_hash_table *htab;
3794 if (!_bfd_elf_create_dynamic_sections (dynobj, info))
3795 return FALSE;
3797 htab = ppc_hash_table (info);
3798 if (!htab->got)
3799 htab->got = bfd_get_section_by_name (dynobj, ".got");
3800 htab->plt = bfd_get_section_by_name (dynobj, ".plt");
3801 htab->relplt = bfd_get_section_by_name (dynobj, ".rela.plt");
3802 htab->dynbss = bfd_get_section_by_name (dynobj, ".dynbss");
3803 if (!info->shared)
3804 htab->relbss = bfd_get_section_by_name (dynobj, ".rela.bss");
3806 if (!htab->got || !htab->plt || !htab->relplt || !htab->dynbss
3807 || (!info->shared && !htab->relbss))
3808 abort ();
3810 return TRUE;
3813 /* Merge PLT info on FROM with that on TO. */
3815 static void
3816 move_plt_plist (struct ppc_link_hash_entry *from,
3817 struct ppc_link_hash_entry *to)
3819 if (from->elf.plt.plist != NULL)
3821 if (to->elf.plt.plist != NULL)
3823 struct plt_entry **entp;
3824 struct plt_entry *ent;
3826 for (entp = &from->elf.plt.plist; (ent = *entp) != NULL; )
3828 struct plt_entry *dent;
3830 for (dent = to->elf.plt.plist; dent != NULL; dent = dent->next)
3831 if (dent->addend == ent->addend)
3833 dent->plt.refcount += ent->plt.refcount;
3834 *entp = ent->next;
3835 break;
3837 if (dent == NULL)
3838 entp = &ent->next;
3840 *entp = to->elf.plt.plist;
3843 to->elf.plt.plist = from->elf.plt.plist;
3844 from->elf.plt.plist = NULL;
3848 /* Copy the extra info we tack onto an elf_link_hash_entry. */
3850 static void
3851 ppc64_elf_copy_indirect_symbol (struct bfd_link_info *info,
3852 struct elf_link_hash_entry *dir,
3853 struct elf_link_hash_entry *ind)
3855 struct ppc_link_hash_entry *edir, *eind;
3857 edir = (struct ppc_link_hash_entry *) dir;
3858 eind = (struct ppc_link_hash_entry *) ind;
3860 /* Copy over any dynamic relocs we may have on the indirect sym. */
3861 if (eind->dyn_relocs != NULL)
3863 if (edir->dyn_relocs != NULL)
3865 struct ppc_dyn_relocs **pp;
3866 struct ppc_dyn_relocs *p;
3868 /* Add reloc counts against the indirect sym to the direct sym
3869 list. Merge any entries against the same section. */
3870 for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
3872 struct ppc_dyn_relocs *q;
3874 for (q = edir->dyn_relocs; q != NULL; q = q->next)
3875 if (q->sec == p->sec)
3877 q->pc_count += p->pc_count;
3878 q->count += p->count;
3879 *pp = p->next;
3880 break;
3882 if (q == NULL)
3883 pp = &p->next;
3885 *pp = edir->dyn_relocs;
3888 edir->dyn_relocs = eind->dyn_relocs;
3889 eind->dyn_relocs = NULL;
3892 edir->is_func |= eind->is_func;
3893 edir->is_func_descriptor |= eind->is_func_descriptor;
3894 edir->tls_mask |= eind->tls_mask;
3896 /* If called to transfer flags for a weakdef during processing
3897 of elf_adjust_dynamic_symbol, don't copy NON_GOT_REF.
3898 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
3899 if (!(ELIMINATE_COPY_RELOCS
3900 && eind->elf.root.type != bfd_link_hash_indirect
3901 && edir->elf.dynamic_adjusted))
3902 edir->elf.non_got_ref |= eind->elf.non_got_ref;
3904 edir->elf.ref_dynamic |= eind->elf.ref_dynamic;
3905 edir->elf.ref_regular |= eind->elf.ref_regular;
3906 edir->elf.ref_regular_nonweak |= eind->elf.ref_regular_nonweak;
3907 edir->elf.needs_plt |= eind->elf.needs_plt;
3909 /* If we were called to copy over info for a weak sym, that's all. */
3910 if (eind->elf.root.type != bfd_link_hash_indirect)
3911 return;
3913 /* Copy over got entries that we may have already seen to the
3914 symbol which just became indirect. */
3915 if (eind->elf.got.glist != NULL)
3917 if (edir->elf.got.glist != NULL)
3919 struct got_entry **entp;
3920 struct got_entry *ent;
3922 for (entp = &eind->elf.got.glist; (ent = *entp) != NULL; )
3924 struct got_entry *dent;
3926 for (dent = edir->elf.got.glist; dent != NULL; dent = dent->next)
3927 if (dent->addend == ent->addend
3928 && dent->owner == ent->owner
3929 && dent->tls_type == ent->tls_type)
3931 dent->got.refcount += ent->got.refcount;
3932 *entp = ent->next;
3933 break;
3935 if (dent == NULL)
3936 entp = &ent->next;
3938 *entp = edir->elf.got.glist;
3941 edir->elf.got.glist = eind->elf.got.glist;
3942 eind->elf.got.glist = NULL;
3945 /* And plt entries. */
3946 move_plt_plist (eind, edir);
3948 if (eind->elf.dynindx != -1)
3950 if (edir->elf.dynindx != -1)
3951 _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
3952 edir->elf.dynstr_index);
3953 edir->elf.dynindx = eind->elf.dynindx;
3954 edir->elf.dynstr_index = eind->elf.dynstr_index;
3955 eind->elf.dynindx = -1;
3956 eind->elf.dynstr_index = 0;
3960 /* Find the function descriptor hash entry from the given function code
3961 hash entry FH. Link the entries via their OH fields. */
3963 static struct ppc_link_hash_entry *
3964 get_fdh (struct ppc_link_hash_entry *fh, struct ppc_link_hash_table *htab)
3966 struct ppc_link_hash_entry *fdh = fh->oh;
3968 if (fdh == NULL)
3970 const char *fd_name = fh->elf.root.root.string + 1;
3972 fdh = (struct ppc_link_hash_entry *)
3973 elf_link_hash_lookup (&htab->elf, fd_name, FALSE, FALSE, FALSE);
3974 if (fdh != NULL)
3976 fdh->is_func_descriptor = 1;
3977 fdh->oh = fh;
3978 fh->is_func = 1;
3979 fh->oh = fdh;
3983 return fdh;
3986 /* Make a fake function descriptor sym for the code sym FH. */
3988 static struct ppc_link_hash_entry *
3989 make_fdh (struct bfd_link_info *info,
3990 struct ppc_link_hash_entry *fh)
3992 bfd *abfd;
3993 asymbol *newsym;
3994 struct bfd_link_hash_entry *bh;
3995 struct ppc_link_hash_entry *fdh;
3997 abfd = fh->elf.root.u.undef.abfd;
3998 newsym = bfd_make_empty_symbol (abfd);
3999 newsym->name = fh->elf.root.root.string + 1;
4000 newsym->section = bfd_und_section_ptr;
4001 newsym->value = 0;
4002 newsym->flags = BSF_WEAK;
4004 bh = NULL;
4005 if (!_bfd_generic_link_add_one_symbol (info, abfd, newsym->name,
4006 newsym->flags, newsym->section,
4007 newsym->value, NULL, FALSE, FALSE,
4008 &bh))
4009 return NULL;
4011 fdh = (struct ppc_link_hash_entry *) bh;
4012 fdh->elf.non_elf = 0;
4013 fdh->fake = 1;
4014 fdh->is_func_descriptor = 1;
4015 fdh->oh = fh;
4016 fh->is_func = 1;
4017 fh->oh = fdh;
4018 return fdh;
4021 /* Hacks to support old ABI code.
4022 When making function calls, old ABI code references function entry
4023 points (dot symbols), while new ABI code references the function
4024 descriptor symbol. We need to make any combination of reference and
4025 definition work together, without breaking archive linking.
4027 For a defined function "foo" and an undefined call to "bar":
4028 An old object defines "foo" and ".foo", references ".bar" (possibly
4029 "bar" too).
4030 A new object defines "foo" and references "bar".
4032 A new object thus has no problem with its undefined symbols being
4033 satisfied by definitions in an old object. On the other hand, the
4034 old object won't have ".bar" satisfied by a new object. */
4036 /* Fix function descriptor symbols defined in .opd sections to be
4037 function type. */
4039 static bfd_boolean
4040 ppc64_elf_add_symbol_hook (bfd *ibfd,
4041 struct bfd_link_info *info ATTRIBUTE_UNUSED,
4042 Elf_Internal_Sym *isym,
4043 const char **name,
4044 flagword *flags ATTRIBUTE_UNUSED,
4045 asection **sec,
4046 bfd_vma *value ATTRIBUTE_UNUSED)
4048 if (*sec != NULL
4049 && strcmp (bfd_get_section_name (ibfd, *sec), ".opd") == 0)
4050 isym->st_info = ELF_ST_INFO (ELF_ST_BIND (isym->st_info), STT_FUNC);
4052 if ((*name)[0] == '.'
4053 && ELF_ST_BIND (isym->st_info) == STB_GLOBAL
4054 && ELF_ST_TYPE (isym->st_info) < STT_SECTION
4055 && is_ppc64_elf_target (ibfd->xvec))
4056 ppc64_elf_tdata (ibfd)->u.has_dotsym = 1;
4058 return TRUE;
4061 /* This function makes an old ABI object reference to ".bar" cause the
4062 inclusion of a new ABI object archive that defines "bar".
4063 NAME is a symbol defined in an archive. Return a symbol in the hash
4064 table that might be satisfied by the archive symbols. */
4066 static struct elf_link_hash_entry *
4067 ppc64_elf_archive_symbol_lookup (bfd *abfd,
4068 struct bfd_link_info *info,
4069 const char *name)
4071 struct elf_link_hash_entry *h;
4072 char *dot_name;
4073 size_t len;
4075 h = _bfd_elf_archive_symbol_lookup (abfd, info, name);
4076 if (h != NULL
4077 /* Don't return this sym if it is a fake function descriptor
4078 created by add_symbol_adjust. */
4079 && !(h->root.type == bfd_link_hash_undefweak
4080 && ((struct ppc_link_hash_entry *) h)->fake))
4081 return h;
4083 if (name[0] == '.')
4084 return h;
4086 len = strlen (name);
4087 dot_name = bfd_alloc (abfd, len + 2);
4088 if (dot_name == NULL)
4089 return (struct elf_link_hash_entry *) 0 - 1;
4090 dot_name[0] = '.';
4091 memcpy (dot_name + 1, name, len + 1);
4092 h = _bfd_elf_archive_symbol_lookup (abfd, info, dot_name);
4093 bfd_release (abfd, dot_name);
4094 return h;
4097 /* This function satisfies all old ABI object references to ".bar" if a
4098 new ABI object defines "bar". Well, at least, undefined dot symbols
4099 are made weak. This stops later archive searches from including an
4100 object if we already have a function descriptor definition. It also
4101 prevents the linker complaining about undefined symbols.
4102 We also check and correct mismatched symbol visibility here. The
4103 most restrictive visibility of the function descriptor and the
4104 function entry symbol is used. */
4106 struct add_symbol_adjust_data
4108 struct bfd_link_info *info;
4109 bfd_boolean ok;
4112 static bfd_boolean
4113 add_symbol_adjust (struct elf_link_hash_entry *h, void *inf)
4115 struct add_symbol_adjust_data *data;
4116 struct ppc_link_hash_table *htab;
4117 struct ppc_link_hash_entry *eh;
4118 struct ppc_link_hash_entry *fdh;
4120 if (h->root.type == bfd_link_hash_indirect)
4121 return TRUE;
4123 if (h->root.type == bfd_link_hash_warning)
4124 h = (struct elf_link_hash_entry *) h->root.u.i.link;
4126 if (h->root.root.string[0] != '.')
4127 return TRUE;
4129 data = inf;
4130 htab = ppc_hash_table (data->info);
4131 eh = (struct ppc_link_hash_entry *) h;
4132 fdh = get_fdh (eh, htab);
4133 if (fdh == NULL
4134 && !data->info->relocatable
4135 && (eh->elf.root.type == bfd_link_hash_undefined
4136 || eh->elf.root.type == bfd_link_hash_undefweak)
4137 && eh->elf.ref_regular)
4139 /* Make an undefweak function descriptor sym, which is enough to
4140 pull in an --as-needed shared lib, but won't cause link
4141 errors. Archives are handled elsewhere. */
4142 fdh = make_fdh (data->info, eh);
4143 if (fdh == NULL)
4144 data->ok = FALSE;
4145 else
4146 fdh->elf.ref_regular = 1;
4148 else if (fdh != NULL)
4150 unsigned entry_vis = ELF_ST_VISIBILITY (eh->elf.other) - 1;
4151 unsigned descr_vis = ELF_ST_VISIBILITY (fdh->elf.other) - 1;
4152 if (entry_vis < descr_vis)
4153 fdh->elf.other += entry_vis - descr_vis;
4154 else if (entry_vis > descr_vis)
4155 eh->elf.other += descr_vis - entry_vis;
4157 if ((fdh->elf.root.type == bfd_link_hash_defined
4158 || fdh->elf.root.type == bfd_link_hash_defweak)
4159 && eh->elf.root.type == bfd_link_hash_undefined)
4161 eh->elf.root.type = bfd_link_hash_undefweak;
4162 eh->was_undefined = 1;
4163 htab->twiddled_syms = 1;
4167 return TRUE;
4170 static bfd_boolean
4171 ppc64_elf_check_directives (bfd *abfd, struct bfd_link_info *info)
4173 struct ppc_link_hash_table *htab;
4174 struct add_symbol_adjust_data data;
4176 if (!is_ppc64_elf_target (abfd->xvec))
4177 return TRUE;
4179 if (!ppc64_elf_tdata (abfd)->u.has_dotsym)
4180 return TRUE;
4181 ppc64_elf_tdata (abfd)->u.deleted_section = NULL;
4183 htab = ppc_hash_table (info);
4184 if (!is_ppc64_elf_target (htab->elf.root.creator))
4185 return TRUE;
4187 data.info = info;
4188 data.ok = TRUE;
4189 elf_link_hash_traverse (&htab->elf, add_symbol_adjust, &data);
4191 /* We need to fix the undefs list for any syms we have twiddled to
4192 undef_weak. */
4193 if (htab->twiddled_syms)
4195 bfd_link_repair_undef_list (&htab->elf.root);
4196 htab->twiddled_syms = 0;
4198 return data.ok;
4201 static bfd_boolean
4202 update_local_sym_info (bfd *abfd, Elf_Internal_Shdr *symtab_hdr,
4203 unsigned long r_symndx, bfd_vma r_addend, int tls_type)
4205 struct got_entry **local_got_ents = elf_local_got_ents (abfd);
4206 char *local_got_tls_masks;
4208 if (local_got_ents == NULL)
4210 bfd_size_type size = symtab_hdr->sh_info;
4212 size *= sizeof (*local_got_ents) + sizeof (*local_got_tls_masks);
4213 local_got_ents = bfd_zalloc (abfd, size);
4214 if (local_got_ents == NULL)
4215 return FALSE;
4216 elf_local_got_ents (abfd) = local_got_ents;
4219 if ((tls_type & TLS_EXPLICIT) == 0)
4221 struct got_entry *ent;
4223 for (ent = local_got_ents[r_symndx]; ent != NULL; ent = ent->next)
4224 if (ent->addend == r_addend
4225 && ent->owner == abfd
4226 && ent->tls_type == tls_type)
4227 break;
4228 if (ent == NULL)
4230 bfd_size_type amt = sizeof (*ent);
4231 ent = bfd_alloc (abfd, amt);
4232 if (ent == NULL)
4233 return FALSE;
4234 ent->next = local_got_ents[r_symndx];
4235 ent->addend = r_addend;
4236 ent->owner = abfd;
4237 ent->tls_type = tls_type;
4238 ent->got.refcount = 0;
4239 local_got_ents[r_symndx] = ent;
4241 ent->got.refcount += 1;
4244 local_got_tls_masks = (char *) (local_got_ents + symtab_hdr->sh_info);
4245 local_got_tls_masks[r_symndx] |= tls_type;
4246 return TRUE;
4249 static bfd_boolean
4250 update_plt_info (bfd *abfd, struct ppc_link_hash_entry *eh, bfd_vma addend)
4252 struct plt_entry *ent;
4254 for (ent = eh->elf.plt.plist; ent != NULL; ent = ent->next)
4255 if (ent->addend == addend)
4256 break;
4257 if (ent == NULL)
4259 bfd_size_type amt = sizeof (*ent);
4260 ent = bfd_alloc (abfd, amt);
4261 if (ent == NULL)
4262 return FALSE;
4263 ent->next = eh->elf.plt.plist;
4264 ent->addend = addend;
4265 ent->plt.refcount = 0;
4266 eh->elf.plt.plist = ent;
4268 ent->plt.refcount += 1;
4269 eh->elf.needs_plt = 1;
4270 if (eh->elf.root.root.string[0] == '.'
4271 && eh->elf.root.root.string[1] != '\0')
4272 eh->is_func = 1;
4273 return TRUE;
4276 /* Look through the relocs for a section during the first phase, and
4277 calculate needed space in the global offset table, procedure
4278 linkage table, and dynamic reloc sections. */
4280 static bfd_boolean
4281 ppc64_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
4282 asection *sec, const Elf_Internal_Rela *relocs)
4284 struct ppc_link_hash_table *htab;
4285 Elf_Internal_Shdr *symtab_hdr;
4286 struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
4287 const Elf_Internal_Rela *rel;
4288 const Elf_Internal_Rela *rel_end;
4289 asection *sreloc;
4290 asection **opd_sym_map;
4292 if (info->relocatable)
4293 return TRUE;
4295 /* Don't do anything special with non-loaded, non-alloced sections.
4296 In particular, any relocs in such sections should not affect GOT
4297 and PLT reference counting (ie. we don't allow them to create GOT
4298 or PLT entries), there's no possibility or desire to optimize TLS
4299 relocs, and there's not much point in propagating relocs to shared
4300 libs that the dynamic linker won't relocate. */
4301 if ((sec->flags & SEC_ALLOC) == 0)
4302 return TRUE;
4304 htab = ppc_hash_table (info);
4305 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
4307 sym_hashes = elf_sym_hashes (abfd);
4308 sym_hashes_end = (sym_hashes
4309 + symtab_hdr->sh_size / sizeof (Elf64_External_Sym)
4310 - symtab_hdr->sh_info);
4312 sreloc = NULL;
4313 opd_sym_map = NULL;
4314 if (strcmp (bfd_get_section_name (abfd, sec), ".opd") == 0)
4316 /* Garbage collection needs some extra help with .opd sections.
4317 We don't want to necessarily keep everything referenced by
4318 relocs in .opd, as that would keep all functions. Instead,
4319 if we reference an .opd symbol (a function descriptor), we
4320 want to keep the function code symbol's section. This is
4321 easy for global symbols, but for local syms we need to keep
4322 information about the associated function section. Later, if
4323 edit_opd deletes entries, we'll use this array to adjust
4324 local syms in .opd. */
4325 union opd_info {
4326 asection *func_section;
4327 long entry_adjust;
4329 bfd_size_type amt;
4331 amt = sec->size * sizeof (union opd_info) / 8;
4332 opd_sym_map = bfd_zalloc (abfd, amt);
4333 if (opd_sym_map == NULL)
4334 return FALSE;
4335 ppc64_elf_section_data (sec)->opd.func_sec = opd_sym_map;
4338 if (htab->sfpr == NULL
4339 && !create_linkage_sections (htab->elf.dynobj, info))
4340 return FALSE;
4342 rel_end = relocs + sec->reloc_count;
4343 for (rel = relocs; rel < rel_end; rel++)
4345 unsigned long r_symndx;
4346 struct elf_link_hash_entry *h;
4347 enum elf_ppc64_reloc_type r_type;
4348 int tls_type = 0;
4350 r_symndx = ELF64_R_SYM (rel->r_info);
4351 if (r_symndx < symtab_hdr->sh_info)
4352 h = NULL;
4353 else
4355 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
4356 while (h->root.type == bfd_link_hash_indirect
4357 || h->root.type == bfd_link_hash_warning)
4358 h = (struct elf_link_hash_entry *) h->root.u.i.link;
4361 r_type = ELF64_R_TYPE (rel->r_info);
4362 switch (r_type)
4364 case R_PPC64_GOT_TLSLD16:
4365 case R_PPC64_GOT_TLSLD16_LO:
4366 case R_PPC64_GOT_TLSLD16_HI:
4367 case R_PPC64_GOT_TLSLD16_HA:
4368 ppc64_tlsld_got (abfd)->refcount += 1;
4369 tls_type = TLS_TLS | TLS_LD;
4370 goto dogottls;
4372 case R_PPC64_GOT_TLSGD16:
4373 case R_PPC64_GOT_TLSGD16_LO:
4374 case R_PPC64_GOT_TLSGD16_HI:
4375 case R_PPC64_GOT_TLSGD16_HA:
4376 tls_type = TLS_TLS | TLS_GD;
4377 goto dogottls;
4379 case R_PPC64_GOT_TPREL16_DS:
4380 case R_PPC64_GOT_TPREL16_LO_DS:
4381 case R_PPC64_GOT_TPREL16_HI:
4382 case R_PPC64_GOT_TPREL16_HA:
4383 if (info->shared)
4384 info->flags |= DF_STATIC_TLS;
4385 tls_type = TLS_TLS | TLS_TPREL;
4386 goto dogottls;
4388 case R_PPC64_GOT_DTPREL16_DS:
4389 case R_PPC64_GOT_DTPREL16_LO_DS:
4390 case R_PPC64_GOT_DTPREL16_HI:
4391 case R_PPC64_GOT_DTPREL16_HA:
4392 tls_type = TLS_TLS | TLS_DTPREL;
4393 dogottls:
4394 sec->has_tls_reloc = 1;
4395 /* Fall thru */
4397 case R_PPC64_GOT16:
4398 case R_PPC64_GOT16_DS:
4399 case R_PPC64_GOT16_HA:
4400 case R_PPC64_GOT16_HI:
4401 case R_PPC64_GOT16_LO:
4402 case R_PPC64_GOT16_LO_DS:
4403 /* This symbol requires a global offset table entry. */
4404 sec->has_toc_reloc = 1;
4405 if (ppc64_elf_tdata (abfd)->got == NULL
4406 && !create_got_section (abfd, info))
4407 return FALSE;
4409 if (h != NULL)
4411 struct ppc_link_hash_entry *eh;
4412 struct got_entry *ent;
4414 eh = (struct ppc_link_hash_entry *) h;
4415 for (ent = eh->elf.got.glist; ent != NULL; ent = ent->next)
4416 if (ent->addend == rel->r_addend
4417 && ent->owner == abfd
4418 && ent->tls_type == tls_type)
4419 break;
4420 if (ent == NULL)
4422 bfd_size_type amt = sizeof (*ent);
4423 ent = bfd_alloc (abfd, amt);
4424 if (ent == NULL)
4425 return FALSE;
4426 ent->next = eh->elf.got.glist;
4427 ent->addend = rel->r_addend;
4428 ent->owner = abfd;
4429 ent->tls_type = tls_type;
4430 ent->got.refcount = 0;
4431 eh->elf.got.glist = ent;
4433 ent->got.refcount += 1;
4434 eh->tls_mask |= tls_type;
4436 else
4437 /* This is a global offset table entry for a local symbol. */
4438 if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
4439 rel->r_addend, tls_type))
4440 return FALSE;
4441 break;
4443 case R_PPC64_PLT16_HA:
4444 case R_PPC64_PLT16_HI:
4445 case R_PPC64_PLT16_LO:
4446 case R_PPC64_PLT32:
4447 case R_PPC64_PLT64:
4448 /* This symbol requires a procedure linkage table entry. We
4449 actually build the entry in adjust_dynamic_symbol,
4450 because this might be a case of linking PIC code without
4451 linking in any dynamic objects, in which case we don't
4452 need to generate a procedure linkage table after all. */
4453 if (h == NULL)
4455 /* It does not make sense to have a procedure linkage
4456 table entry for a local symbol. */
4457 bfd_set_error (bfd_error_bad_value);
4458 return FALSE;
4460 else
4461 if (!update_plt_info (abfd, (struct ppc_link_hash_entry *) h,
4462 rel->r_addend))
4463 return FALSE;
4464 break;
4466 /* The following relocations don't need to propagate the
4467 relocation if linking a shared object since they are
4468 section relative. */
4469 case R_PPC64_SECTOFF:
4470 case R_PPC64_SECTOFF_LO:
4471 case R_PPC64_SECTOFF_HI:
4472 case R_PPC64_SECTOFF_HA:
4473 case R_PPC64_SECTOFF_DS:
4474 case R_PPC64_SECTOFF_LO_DS:
4475 case R_PPC64_DTPREL16:
4476 case R_PPC64_DTPREL16_LO:
4477 case R_PPC64_DTPREL16_HI:
4478 case R_PPC64_DTPREL16_HA:
4479 case R_PPC64_DTPREL16_DS:
4480 case R_PPC64_DTPREL16_LO_DS:
4481 case R_PPC64_DTPREL16_HIGHER:
4482 case R_PPC64_DTPREL16_HIGHERA:
4483 case R_PPC64_DTPREL16_HIGHEST:
4484 case R_PPC64_DTPREL16_HIGHESTA:
4485 break;
4487 /* Nor do these. */
4488 case R_PPC64_TOC16:
4489 case R_PPC64_TOC16_LO:
4490 case R_PPC64_TOC16_HI:
4491 case R_PPC64_TOC16_HA:
4492 case R_PPC64_TOC16_DS:
4493 case R_PPC64_TOC16_LO_DS:
4494 sec->has_toc_reloc = 1;
4495 break;
4497 /* This relocation describes the C++ object vtable hierarchy.
4498 Reconstruct it for later use during GC. */
4499 case R_PPC64_GNU_VTINHERIT:
4500 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
4501 return FALSE;
4502 break;
4504 /* This relocation describes which C++ vtable entries are actually
4505 used. Record for later use during GC. */
4506 case R_PPC64_GNU_VTENTRY:
4507 if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
4508 return FALSE;
4509 break;
4511 case R_PPC64_REL14:
4512 case R_PPC64_REL14_BRTAKEN:
4513 case R_PPC64_REL14_BRNTAKEN:
4515 asection *dest = NULL;
4517 /* Heuristic: If jumping outside our section, chances are
4518 we are going to need a stub. */
4519 if (h != NULL)
4521 /* If the sym is weak it may be overridden later, so
4522 don't assume we know where a weak sym lives. */
4523 if (h->root.type == bfd_link_hash_defined)
4524 dest = h->root.u.def.section;
4526 else
4527 dest = bfd_section_from_r_symndx (abfd, &htab->sym_sec,
4528 sec, r_symndx);
4529 if (dest != sec)
4530 htab->has_14bit_branch = 1;
4532 /* Fall through. */
4534 case R_PPC64_REL24:
4535 if (h != NULL)
4537 /* We may need a .plt entry if the function this reloc
4538 refers to is in a shared lib. */
4539 if (!update_plt_info (abfd, (struct ppc_link_hash_entry *) h,
4540 rel->r_addend))
4541 return FALSE;
4542 if (h == &htab->tls_get_addr->elf
4543 || h == &htab->tls_get_addr_fd->elf)
4544 sec->has_tls_reloc = 1;
4545 else if (htab->tls_get_addr == NULL
4546 && !strncmp (h->root.root.string, ".__tls_get_addr", 15)
4547 && (h->root.root.string[15] == 0
4548 || h->root.root.string[15] == '@'))
4550 htab->tls_get_addr = (struct ppc_link_hash_entry *) h;
4551 sec->has_tls_reloc = 1;
4553 else if (htab->tls_get_addr_fd == NULL
4554 && !strncmp (h->root.root.string, "__tls_get_addr", 14)
4555 && (h->root.root.string[14] == 0
4556 || h->root.root.string[14] == '@'))
4558 htab->tls_get_addr_fd = (struct ppc_link_hash_entry *) h;
4559 sec->has_tls_reloc = 1;
4562 break;
4564 case R_PPC64_TPREL64:
4565 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_TPREL;
4566 if (info->shared)
4567 info->flags |= DF_STATIC_TLS;
4568 goto dotlstoc;
4570 case R_PPC64_DTPMOD64:
4571 if (rel + 1 < rel_end
4572 && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
4573 && rel[1].r_offset == rel->r_offset + 8)
4574 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_GD;
4575 else
4576 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_LD;
4577 goto dotlstoc;
4579 case R_PPC64_DTPREL64:
4580 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_DTPREL;
4581 if (rel != relocs
4582 && rel[-1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPMOD64)
4583 && rel[-1].r_offset == rel->r_offset - 8)
4584 /* This is the second reloc of a dtpmod, dtprel pair.
4585 Don't mark with TLS_DTPREL. */
4586 goto dodyn;
4588 dotlstoc:
4589 sec->has_tls_reloc = 1;
4590 if (h != NULL)
4592 struct ppc_link_hash_entry *eh;
4593 eh = (struct ppc_link_hash_entry *) h;
4594 eh->tls_mask |= tls_type;
4596 else
4597 if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
4598 rel->r_addend, tls_type))
4599 return FALSE;
4601 if (ppc64_elf_section_data (sec)->t_symndx == NULL)
4603 /* One extra to simplify get_tls_mask. */
4604 bfd_size_type amt = sec->size * sizeof (unsigned) / 8 + 1;
4605 ppc64_elf_section_data (sec)->t_symndx = bfd_zalloc (abfd, amt);
4606 if (ppc64_elf_section_data (sec)->t_symndx == NULL)
4607 return FALSE;
4609 BFD_ASSERT (rel->r_offset % 8 == 0);
4610 ppc64_elf_section_data (sec)->t_symndx[rel->r_offset / 8] = r_symndx;
4612 /* Mark the second slot of a GD or LD entry.
4613 -1 to indicate GD and -2 to indicate LD. */
4614 if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_GD))
4615 ppc64_elf_section_data (sec)->t_symndx[rel->r_offset / 8 + 1] = -1;
4616 else if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_LD))
4617 ppc64_elf_section_data (sec)->t_symndx[rel->r_offset / 8 + 1] = -2;
4618 goto dodyn;
4620 case R_PPC64_TPREL16:
4621 case R_PPC64_TPREL16_LO:
4622 case R_PPC64_TPREL16_HI:
4623 case R_PPC64_TPREL16_HA:
4624 case R_PPC64_TPREL16_DS:
4625 case R_PPC64_TPREL16_LO_DS:
4626 case R_PPC64_TPREL16_HIGHER:
4627 case R_PPC64_TPREL16_HIGHERA:
4628 case R_PPC64_TPREL16_HIGHEST:
4629 case R_PPC64_TPREL16_HIGHESTA:
4630 if (info->shared)
4632 info->flags |= DF_STATIC_TLS;
4633 goto dodyn;
4635 break;
4637 case R_PPC64_ADDR64:
4638 if (opd_sym_map != NULL
4639 && rel + 1 < rel_end
4640 && ELF64_R_TYPE ((rel + 1)->r_info) == R_PPC64_TOC)
4642 if (h != NULL)
4644 if (h->root.root.string[0] == '.'
4645 && h->root.root.string[1] != 0
4646 && get_fdh ((struct ppc_link_hash_entry *) h, htab))
4648 else
4649 ((struct ppc_link_hash_entry *) h)->is_func = 1;
4651 else
4653 asection *s;
4655 s = bfd_section_from_r_symndx (abfd, &htab->sym_sec, sec,
4656 r_symndx);
4657 if (s == NULL)
4658 return FALSE;
4659 else if (s != sec)
4660 opd_sym_map[rel->r_offset / 8] = s;
4663 /* Fall through. */
4665 case R_PPC64_REL30:
4666 case R_PPC64_REL32:
4667 case R_PPC64_REL64:
4668 case R_PPC64_ADDR14:
4669 case R_PPC64_ADDR14_BRNTAKEN:
4670 case R_PPC64_ADDR14_BRTAKEN:
4671 case R_PPC64_ADDR16:
4672 case R_PPC64_ADDR16_DS:
4673 case R_PPC64_ADDR16_HA:
4674 case R_PPC64_ADDR16_HI:
4675 case R_PPC64_ADDR16_HIGHER:
4676 case R_PPC64_ADDR16_HIGHERA:
4677 case R_PPC64_ADDR16_HIGHEST:
4678 case R_PPC64_ADDR16_HIGHESTA:
4679 case R_PPC64_ADDR16_LO:
4680 case R_PPC64_ADDR16_LO_DS:
4681 case R_PPC64_ADDR24:
4682 case R_PPC64_ADDR32:
4683 case R_PPC64_UADDR16:
4684 case R_PPC64_UADDR32:
4685 case R_PPC64_UADDR64:
4686 case R_PPC64_TOC:
4687 if (h != NULL && !info->shared)
4688 /* We may need a copy reloc. */
4689 h->non_got_ref = 1;
4691 /* Don't propagate .opd relocs. */
4692 if (NO_OPD_RELOCS && opd_sym_map != NULL)
4693 break;
4695 /* If we are creating a shared library, and this is a reloc
4696 against a global symbol, or a non PC relative reloc
4697 against a local symbol, then we need to copy the reloc
4698 into the shared library. However, if we are linking with
4699 -Bsymbolic, we do not need to copy a reloc against a
4700 global symbol which is defined in an object we are
4701 including in the link (i.e., DEF_REGULAR is set). At
4702 this point we have not seen all the input files, so it is
4703 possible that DEF_REGULAR is not set now but will be set
4704 later (it is never cleared). In case of a weak definition,
4705 DEF_REGULAR may be cleared later by a strong definition in
4706 a shared library. We account for that possibility below by
4707 storing information in the dyn_relocs field of the hash
4708 table entry. A similar situation occurs when creating
4709 shared libraries and symbol visibility changes render the
4710 symbol local.
4712 If on the other hand, we are creating an executable, we
4713 may need to keep relocations for symbols satisfied by a
4714 dynamic library if we manage to avoid copy relocs for the
4715 symbol. */
4716 dodyn:
4717 if ((info->shared
4718 && (MUST_BE_DYN_RELOC (r_type)
4719 || (h != NULL
4720 && (! info->symbolic
4721 || h->root.type == bfd_link_hash_defweak
4722 || !h->def_regular))))
4723 || (ELIMINATE_COPY_RELOCS
4724 && !info->shared
4725 && h != NULL
4726 && (h->root.type == bfd_link_hash_defweak
4727 || !h->def_regular)))
4729 struct ppc_dyn_relocs *p;
4730 struct ppc_dyn_relocs **head;
4732 /* We must copy these reloc types into the output file.
4733 Create a reloc section in dynobj and make room for
4734 this reloc. */
4735 if (sreloc == NULL)
4737 const char *name;
4738 bfd *dynobj;
4740 name = (bfd_elf_string_from_elf_section
4741 (abfd,
4742 elf_elfheader (abfd)->e_shstrndx,
4743 elf_section_data (sec)->rel_hdr.sh_name));
4744 if (name == NULL)
4745 return FALSE;
4747 if (strncmp (name, ".rela", 5) != 0
4748 || strcmp (bfd_get_section_name (abfd, sec),
4749 name + 5) != 0)
4751 (*_bfd_error_handler)
4752 (_("%B: bad relocation section name `%s\'"),
4753 abfd, name);
4754 bfd_set_error (bfd_error_bad_value);
4757 dynobj = htab->elf.dynobj;
4758 sreloc = bfd_get_section_by_name (dynobj, name);
4759 if (sreloc == NULL)
4761 flagword flags;
4763 flags = (SEC_HAS_CONTENTS | SEC_READONLY
4764 | SEC_IN_MEMORY | SEC_LINKER_CREATED
4765 | SEC_ALLOC | SEC_LOAD);
4766 sreloc = bfd_make_section_with_flags (dynobj,
4767 name,
4768 flags);
4769 if (sreloc == NULL
4770 || ! bfd_set_section_alignment (dynobj, sreloc, 3))
4771 return FALSE;
4773 elf_section_data (sec)->sreloc = sreloc;
4776 /* If this is a global symbol, we count the number of
4777 relocations we need for this symbol. */
4778 if (h != NULL)
4780 head = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
4782 else
4784 /* Track dynamic relocs needed for local syms too.
4785 We really need local syms available to do this
4786 easily. Oh well. */
4788 asection *s;
4789 void *vpp;
4791 s = bfd_section_from_r_symndx (abfd, &htab->sym_sec,
4792 sec, r_symndx);
4793 if (s == NULL)
4794 return FALSE;
4796 vpp = &elf_section_data (s)->local_dynrel;
4797 head = (struct ppc_dyn_relocs **) vpp;
4800 p = *head;
4801 if (p == NULL || p->sec != sec)
4803 p = bfd_alloc (htab->elf.dynobj, sizeof *p);
4804 if (p == NULL)
4805 return FALSE;
4806 p->next = *head;
4807 *head = p;
4808 p->sec = sec;
4809 p->count = 0;
4810 p->pc_count = 0;
4813 p->count += 1;
4814 if (!MUST_BE_DYN_RELOC (r_type))
4815 p->pc_count += 1;
4817 break;
4819 default:
4820 break;
4824 return TRUE;
4827 /* OFFSET in OPD_SEC specifies a function descriptor. Return the address
4828 of the code entry point, and its section. */
4830 static bfd_vma
4831 opd_entry_value (asection *opd_sec,
4832 bfd_vma offset,
4833 asection **code_sec,
4834 bfd_vma *code_off)
4836 bfd *opd_bfd = opd_sec->owner;
4837 Elf_Internal_Rela *relocs;
4838 Elf_Internal_Rela *lo, *hi, *look;
4839 bfd_vma val;
4841 /* No relocs implies we are linking a --just-symbols object. */
4842 if (opd_sec->reloc_count == 0)
4844 bfd_vma val;
4846 if (!bfd_get_section_contents (opd_bfd, opd_sec, &val, offset, 8))
4847 return (bfd_vma) -1;
4849 if (code_sec != NULL)
4851 asection *sec, *likely = NULL;
4852 for (sec = opd_bfd->sections; sec != NULL; sec = sec->next)
4853 if (sec->vma <= val
4854 && (sec->flags & SEC_LOAD) != 0
4855 && (sec->flags & SEC_ALLOC) != 0)
4856 likely = sec;
4857 if (likely != NULL)
4859 *code_sec = likely;
4860 if (code_off != NULL)
4861 *code_off = val - likely->vma;
4864 return val;
4867 relocs = ppc64_elf_tdata (opd_bfd)->opd_relocs;
4868 if (relocs == NULL)
4869 relocs = _bfd_elf_link_read_relocs (opd_bfd, opd_sec, NULL, NULL, TRUE);
4871 /* Go find the opd reloc at the sym address. */
4872 lo = relocs;
4873 BFD_ASSERT (lo != NULL);
4874 hi = lo + opd_sec->reloc_count - 1; /* ignore last reloc */
4875 val = (bfd_vma) -1;
4876 while (lo < hi)
4878 look = lo + (hi - lo) / 2;
4879 if (look->r_offset < offset)
4880 lo = look + 1;
4881 else if (look->r_offset > offset)
4882 hi = look;
4883 else
4885 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (opd_bfd)->symtab_hdr;
4886 if (ELF64_R_TYPE (look->r_info) == R_PPC64_ADDR64
4887 && ELF64_R_TYPE ((look + 1)->r_info) == R_PPC64_TOC)
4889 unsigned long symndx = ELF64_R_SYM (look->r_info);
4890 asection *sec;
4892 if (symndx < symtab_hdr->sh_info)
4894 Elf_Internal_Sym *sym;
4896 sym = (Elf_Internal_Sym *) symtab_hdr->contents;
4897 if (sym == NULL)
4899 sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr,
4900 symtab_hdr->sh_info,
4901 0, NULL, NULL, NULL);
4902 if (sym == NULL)
4903 break;
4904 symtab_hdr->contents = (bfd_byte *) sym;
4907 sym += symndx;
4908 val = sym->st_value;
4909 sec = NULL;
4910 if ((sym->st_shndx != SHN_UNDEF
4911 && sym->st_shndx < SHN_LORESERVE)
4912 || sym->st_shndx > SHN_HIRESERVE)
4913 sec = bfd_section_from_elf_index (opd_bfd, sym->st_shndx);
4914 BFD_ASSERT ((sec->flags & SEC_MERGE) == 0);
4916 else
4918 struct elf_link_hash_entry **sym_hashes;
4919 struct elf_link_hash_entry *rh;
4921 sym_hashes = elf_sym_hashes (opd_bfd);
4922 rh = sym_hashes[symndx - symtab_hdr->sh_info];
4923 while (rh->root.type == bfd_link_hash_indirect
4924 || rh->root.type == bfd_link_hash_warning)
4925 rh = ((struct elf_link_hash_entry *) rh->root.u.i.link);
4926 BFD_ASSERT (rh->root.type == bfd_link_hash_defined
4927 || rh->root.type == bfd_link_hash_defweak);
4928 val = rh->root.u.def.value;
4929 sec = rh->root.u.def.section;
4931 val += look->r_addend;
4932 if (code_off != NULL)
4933 *code_off = val;
4934 if (code_sec != NULL)
4935 *code_sec = sec;
4936 if (sec != NULL && sec->output_section != NULL)
4937 val += sec->output_section->vma + sec->output_offset;
4939 break;
4943 return val;
4946 /* Mark sections containing dynamically referenced symbols. When
4947 building shared libraries, we must assume that any visible symbol is
4948 referenced. */
4950 static bfd_boolean
4951 ppc64_elf_gc_mark_dynamic_ref (struct elf_link_hash_entry *h, void *inf)
4953 struct bfd_link_info *info = (struct bfd_link_info *) inf;
4954 struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
4956 if (eh->elf.root.type == bfd_link_hash_warning)
4957 eh = (struct ppc_link_hash_entry *) eh->elf.root.u.i.link;
4959 /* Dynamic linking info is on the func descriptor sym. */
4960 if (eh->oh != NULL
4961 && eh->oh->is_func_descriptor
4962 && (eh->oh->elf.root.type == bfd_link_hash_defined
4963 || eh->oh->elf.root.type == bfd_link_hash_defweak))
4964 eh = eh->oh;
4966 if ((eh->elf.root.type == bfd_link_hash_defined
4967 || eh->elf.root.type == bfd_link_hash_defweak)
4968 && (eh->elf.ref_dynamic
4969 || (!info->executable
4970 && eh->elf.def_regular
4971 && ELF_ST_VISIBILITY (eh->elf.other) != STV_INTERNAL
4972 && ELF_ST_VISIBILITY (eh->elf.other) != STV_HIDDEN)))
4974 asection *code_sec;
4976 eh->elf.root.u.def.section->flags |= SEC_KEEP;
4978 /* Function descriptor syms cause the associated
4979 function code sym section to be marked. */
4980 if (eh->is_func_descriptor
4981 && (eh->oh->elf.root.type == bfd_link_hash_defined
4982 || eh->oh->elf.root.type == bfd_link_hash_defweak))
4983 eh->oh->elf.root.u.def.section->flags |= SEC_KEEP;
4984 else if (get_opd_info (eh->elf.root.u.def.section) != NULL
4985 && opd_entry_value (eh->elf.root.u.def.section,
4986 eh->elf.root.u.def.value,
4987 &code_sec, NULL) != (bfd_vma) -1)
4988 code_sec->flags |= SEC_KEEP;
4991 return TRUE;
4994 /* Return the section that should be marked against GC for a given
4995 relocation. */
4997 static asection *
4998 ppc64_elf_gc_mark_hook (asection *sec,
4999 struct bfd_link_info *info,
5000 Elf_Internal_Rela *rel,
5001 struct elf_link_hash_entry *h,
5002 Elf_Internal_Sym *sym)
5004 asection *rsec;
5006 /* First mark all our entry sym sections. */
5007 if (info->gc_sym_list != NULL)
5009 struct ppc_link_hash_table *htab = ppc_hash_table (info);
5010 struct bfd_sym_chain *sym = info->gc_sym_list;
5012 info->gc_sym_list = NULL;
5013 for (; sym != NULL; sym = sym->next)
5015 struct ppc_link_hash_entry *eh;
5017 eh = (struct ppc_link_hash_entry *)
5018 elf_link_hash_lookup (&htab->elf, sym->name, FALSE, FALSE, FALSE);
5019 if (eh == NULL)
5020 continue;
5021 if (eh->elf.root.type != bfd_link_hash_defined
5022 && eh->elf.root.type != bfd_link_hash_defweak)
5023 continue;
5025 if (eh->is_func_descriptor
5026 && (eh->oh->elf.root.type == bfd_link_hash_defined
5027 || eh->oh->elf.root.type == bfd_link_hash_defweak))
5028 rsec = eh->oh->elf.root.u.def.section;
5029 else if (get_opd_info (eh->elf.root.u.def.section) != NULL
5030 && opd_entry_value (eh->elf.root.u.def.section,
5031 eh->elf.root.u.def.value,
5032 &rsec, NULL) != (bfd_vma) -1)
5034 else
5035 continue;
5037 if (!rsec->gc_mark)
5038 _bfd_elf_gc_mark (info, rsec, ppc64_elf_gc_mark_hook);
5040 rsec = eh->elf.root.u.def.section;
5041 if (!rsec->gc_mark)
5042 _bfd_elf_gc_mark (info, rsec, ppc64_elf_gc_mark_hook);
5046 /* Syms return NULL if we're marking .opd, so we avoid marking all
5047 function sections, as all functions are referenced in .opd. */
5048 rsec = NULL;
5049 if (get_opd_info (sec) != NULL)
5050 return rsec;
5052 if (h != NULL)
5054 enum elf_ppc64_reloc_type r_type;
5055 struct ppc_link_hash_entry *eh;
5057 r_type = ELF64_R_TYPE (rel->r_info);
5058 switch (r_type)
5060 case R_PPC64_GNU_VTINHERIT:
5061 case R_PPC64_GNU_VTENTRY:
5062 break;
5064 default:
5065 switch (h->root.type)
5067 case bfd_link_hash_defined:
5068 case bfd_link_hash_defweak:
5069 eh = (struct ppc_link_hash_entry *) h;
5070 if (eh->oh != NULL
5071 && eh->oh->is_func_descriptor
5072 && (eh->oh->elf.root.type == bfd_link_hash_defined
5073 || eh->oh->elf.root.type == bfd_link_hash_defweak))
5074 eh = eh->oh;
5076 /* Function descriptor syms cause the associated
5077 function code sym section to be marked. */
5078 if (eh->is_func_descriptor
5079 && (eh->oh->elf.root.type == bfd_link_hash_defined
5080 || eh->oh->elf.root.type == bfd_link_hash_defweak))
5082 /* They also mark their opd section. */
5083 if (!eh->elf.root.u.def.section->gc_mark)
5084 _bfd_elf_gc_mark (info, eh->elf.root.u.def.section,
5085 ppc64_elf_gc_mark_hook);
5087 rsec = eh->oh->elf.root.u.def.section;
5089 else if (get_opd_info (eh->elf.root.u.def.section) != NULL
5090 && opd_entry_value (eh->elf.root.u.def.section,
5091 eh->elf.root.u.def.value,
5092 &rsec, NULL) != (bfd_vma) -1)
5094 if (!eh->elf.root.u.def.section->gc_mark)
5095 _bfd_elf_gc_mark (info, eh->elf.root.u.def.section,
5096 ppc64_elf_gc_mark_hook);
5098 else
5099 rsec = h->root.u.def.section;
5100 break;
5102 case bfd_link_hash_common:
5103 rsec = h->root.u.c.p->section;
5104 break;
5106 default:
5107 break;
5111 else
5113 asection **opd_sym_section;
5115 rsec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
5116 opd_sym_section = get_opd_info (rsec);
5117 if (opd_sym_section != NULL)
5119 if (!rsec->gc_mark)
5120 _bfd_elf_gc_mark (info, rsec, ppc64_elf_gc_mark_hook);
5122 rsec = opd_sym_section[(sym->st_value + rel->r_addend) / 8];
5126 return rsec;
5129 /* Update the .got, .plt. and dynamic reloc reference counts for the
5130 section being removed. */
5132 static bfd_boolean
5133 ppc64_elf_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info,
5134 asection *sec, const Elf_Internal_Rela *relocs)
5136 struct ppc_link_hash_table *htab;
5137 Elf_Internal_Shdr *symtab_hdr;
5138 struct elf_link_hash_entry **sym_hashes;
5139 struct got_entry **local_got_ents;
5140 const Elf_Internal_Rela *rel, *relend;
5142 if ((sec->flags & SEC_ALLOC) == 0)
5143 return TRUE;
5145 elf_section_data (sec)->local_dynrel = NULL;
5147 htab = ppc_hash_table (info);
5148 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
5149 sym_hashes = elf_sym_hashes (abfd);
5150 local_got_ents = elf_local_got_ents (abfd);
5152 relend = relocs + sec->reloc_count;
5153 for (rel = relocs; rel < relend; rel++)
5155 unsigned long r_symndx;
5156 enum elf_ppc64_reloc_type r_type;
5157 struct elf_link_hash_entry *h = NULL;
5158 char tls_type = 0;
5160 r_symndx = ELF64_R_SYM (rel->r_info);
5161 r_type = ELF64_R_TYPE (rel->r_info);
5162 if (r_symndx >= symtab_hdr->sh_info)
5164 struct ppc_link_hash_entry *eh;
5165 struct ppc_dyn_relocs **pp;
5166 struct ppc_dyn_relocs *p;
5168 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
5169 while (h->root.type == bfd_link_hash_indirect
5170 || h->root.type == bfd_link_hash_warning)
5171 h = (struct elf_link_hash_entry *) h->root.u.i.link;
5172 eh = (struct ppc_link_hash_entry *) h;
5174 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
5175 if (p->sec == sec)
5177 /* Everything must go for SEC. */
5178 *pp = p->next;
5179 break;
5183 switch (r_type)
5185 case R_PPC64_GOT_TLSLD16:
5186 case R_PPC64_GOT_TLSLD16_LO:
5187 case R_PPC64_GOT_TLSLD16_HI:
5188 case R_PPC64_GOT_TLSLD16_HA:
5189 ppc64_tlsld_got (abfd)->refcount -= 1;
5190 tls_type = TLS_TLS | TLS_LD;
5191 goto dogot;
5193 case R_PPC64_GOT_TLSGD16:
5194 case R_PPC64_GOT_TLSGD16_LO:
5195 case R_PPC64_GOT_TLSGD16_HI:
5196 case R_PPC64_GOT_TLSGD16_HA:
5197 tls_type = TLS_TLS | TLS_GD;
5198 goto dogot;
5200 case R_PPC64_GOT_TPREL16_DS:
5201 case R_PPC64_GOT_TPREL16_LO_DS:
5202 case R_PPC64_GOT_TPREL16_HI:
5203 case R_PPC64_GOT_TPREL16_HA:
5204 tls_type = TLS_TLS | TLS_TPREL;
5205 goto dogot;
5207 case R_PPC64_GOT_DTPREL16_DS:
5208 case R_PPC64_GOT_DTPREL16_LO_DS:
5209 case R_PPC64_GOT_DTPREL16_HI:
5210 case R_PPC64_GOT_DTPREL16_HA:
5211 tls_type = TLS_TLS | TLS_DTPREL;
5212 goto dogot;
5214 case R_PPC64_GOT16:
5215 case R_PPC64_GOT16_DS:
5216 case R_PPC64_GOT16_HA:
5217 case R_PPC64_GOT16_HI:
5218 case R_PPC64_GOT16_LO:
5219 case R_PPC64_GOT16_LO_DS:
5220 dogot:
5222 struct got_entry *ent;
5224 if (h != NULL)
5225 ent = h->got.glist;
5226 else
5227 ent = local_got_ents[r_symndx];
5229 for (; ent != NULL; ent = ent->next)
5230 if (ent->addend == rel->r_addend
5231 && ent->owner == abfd
5232 && ent->tls_type == tls_type)
5233 break;
5234 if (ent == NULL)
5235 abort ();
5236 if (ent->got.refcount > 0)
5237 ent->got.refcount -= 1;
5239 break;
5241 case R_PPC64_PLT16_HA:
5242 case R_PPC64_PLT16_HI:
5243 case R_PPC64_PLT16_LO:
5244 case R_PPC64_PLT32:
5245 case R_PPC64_PLT64:
5246 case R_PPC64_REL14:
5247 case R_PPC64_REL14_BRNTAKEN:
5248 case R_PPC64_REL14_BRTAKEN:
5249 case R_PPC64_REL24:
5250 if (h != NULL)
5252 struct plt_entry *ent;
5254 for (ent = h->plt.plist; ent != NULL; ent = ent->next)
5255 if (ent->addend == rel->r_addend)
5256 break;
5257 if (ent == NULL)
5258 abort ();
5259 if (ent->plt.refcount > 0)
5260 ent->plt.refcount -= 1;
5262 break;
5264 default:
5265 break;
5268 return TRUE;
5271 /* The maximum size of .sfpr. */
5272 #define SFPR_MAX (218*4)
5274 struct sfpr_def_parms
5276 const char name[12];
5277 unsigned char lo, hi;
5278 bfd_byte * (*write_ent) (bfd *, bfd_byte *, int);
5279 bfd_byte * (*write_tail) (bfd *, bfd_byte *, int);
5282 /* Auto-generate _save*, _rest* functions in .sfpr. */
5284 static unsigned int
5285 sfpr_define (struct bfd_link_info *info, const struct sfpr_def_parms *parm)
5287 struct ppc_link_hash_table *htab = ppc_hash_table (info);
5288 unsigned int i;
5289 size_t len = strlen (parm->name);
5290 bfd_boolean writing = FALSE;
5291 char sym[16];
5293 memcpy (sym, parm->name, len);
5294 sym[len + 2] = 0;
5296 for (i = parm->lo; i <= parm->hi; i++)
5298 struct elf_link_hash_entry *h;
5300 sym[len + 0] = i / 10 + '0';
5301 sym[len + 1] = i % 10 + '0';
5302 h = elf_link_hash_lookup (&htab->elf, sym, FALSE, FALSE, TRUE);
5303 if (h != NULL
5304 && !h->def_regular)
5306 h->root.type = bfd_link_hash_defined;
5307 h->root.u.def.section = htab->sfpr;
5308 h->root.u.def.value = htab->sfpr->size;
5309 h->type = STT_FUNC;
5310 h->def_regular = 1;
5311 _bfd_elf_link_hash_hide_symbol (info, h, TRUE);
5312 writing = TRUE;
5313 if (htab->sfpr->contents == NULL)
5315 htab->sfpr->contents = bfd_alloc (htab->elf.dynobj, SFPR_MAX);
5316 if (htab->sfpr->contents == NULL)
5317 return FALSE;
5320 if (writing)
5322 bfd_byte *p = htab->sfpr->contents + htab->sfpr->size;
5323 if (i != parm->hi)
5324 p = (*parm->write_ent) (htab->elf.dynobj, p, i);
5325 else
5326 p = (*parm->write_tail) (htab->elf.dynobj, p, i);
5327 htab->sfpr->size = p - htab->sfpr->contents;
5331 return TRUE;
5334 static bfd_byte *
5335 savegpr0 (bfd *abfd, bfd_byte *p, int r)
5337 bfd_put_32 (abfd, STD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
5338 return p + 4;
5341 static bfd_byte *
5342 savegpr0_tail (bfd *abfd, bfd_byte *p, int r)
5344 p = savegpr0 (abfd, p, r);
5345 bfd_put_32 (abfd, STD_R0_0R1 + 16, p);
5346 p = p + 4;
5347 bfd_put_32 (abfd, BLR, p);
5348 return p + 4;
5351 static bfd_byte *
5352 restgpr0 (bfd *abfd, bfd_byte *p, int r)
5354 bfd_put_32 (abfd, LD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
5355 return p + 4;
5358 static bfd_byte *
5359 restgpr0_tail (bfd *abfd, bfd_byte *p, int r)
5361 bfd_put_32 (abfd, LD_R0_0R1 + 16, p);
5362 p = p + 4;
5363 p = restgpr0 (abfd, p, r);
5364 bfd_put_32 (abfd, MTLR_R0, p);
5365 p = p + 4;
5366 if (r == 29)
5368 p = restgpr0 (abfd, p, 30);
5369 p = restgpr0 (abfd, p, 31);
5371 bfd_put_32 (abfd, BLR, p);
5372 return p + 4;
5375 static bfd_byte *
5376 savegpr1 (bfd *abfd, bfd_byte *p, int r)
5378 bfd_put_32 (abfd, STD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
5379 return p + 4;
5382 static bfd_byte *
5383 savegpr1_tail (bfd *abfd, bfd_byte *p, int r)
5385 p = savegpr1 (abfd, p, r);
5386 bfd_put_32 (abfd, BLR, p);
5387 return p + 4;
5390 static bfd_byte *
5391 restgpr1 (bfd *abfd, bfd_byte *p, int r)
5393 bfd_put_32 (abfd, LD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
5394 return p + 4;
5397 static bfd_byte *
5398 restgpr1_tail (bfd *abfd, bfd_byte *p, int r)
5400 p = restgpr1 (abfd, p, r);
5401 bfd_put_32 (abfd, BLR, p);
5402 return p + 4;
5405 static bfd_byte *
5406 savefpr (bfd *abfd, bfd_byte *p, int r)
5408 bfd_put_32 (abfd, STFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
5409 return p + 4;
5412 static bfd_byte *
5413 savefpr0_tail (bfd *abfd, bfd_byte *p, int r)
5415 p = savefpr (abfd, p, r);
5416 bfd_put_32 (abfd, STD_R0_0R1 + 16, p);
5417 p = p + 4;
5418 bfd_put_32 (abfd, BLR, p);
5419 return p + 4;
5422 static bfd_byte *
5423 restfpr (bfd *abfd, bfd_byte *p, int r)
5425 bfd_put_32 (abfd, LFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
5426 return p + 4;
5429 static bfd_byte *
5430 restfpr0_tail (bfd *abfd, bfd_byte *p, int r)
5432 bfd_put_32 (abfd, LD_R0_0R1 + 16, p);
5433 p = p + 4;
5434 p = restfpr (abfd, p, r);
5435 bfd_put_32 (abfd, MTLR_R0, p);
5436 p = p + 4;
5437 if (r == 29)
5439 p = restfpr (abfd, p, 30);
5440 p = restfpr (abfd, p, 31);
5442 bfd_put_32 (abfd, BLR, p);
5443 return p + 4;
5446 static bfd_byte *
5447 savefpr1_tail (bfd *abfd, bfd_byte *p, int r)
5449 p = savefpr (abfd, p, r);
5450 bfd_put_32 (abfd, BLR, p);
5451 return p + 4;
5454 static bfd_byte *
5455 restfpr1_tail (bfd *abfd, bfd_byte *p, int r)
5457 p = restfpr (abfd, p, r);
5458 bfd_put_32 (abfd, BLR, p);
5459 return p + 4;
5462 static bfd_byte *
5463 savevr (bfd *abfd, bfd_byte *p, int r)
5465 bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
5466 p = p + 4;
5467 bfd_put_32 (abfd, STVX_VR0_R12_R0 + (r << 21), p);
5468 return p + 4;
5471 static bfd_byte *
5472 savevr_tail (bfd *abfd, bfd_byte *p, int r)
5474 p = savevr (abfd, p, r);
5475 bfd_put_32 (abfd, BLR, p);
5476 return p + 4;
5479 static bfd_byte *
5480 restvr (bfd *abfd, bfd_byte *p, int r)
5482 bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
5483 p = p + 4;
5484 bfd_put_32 (abfd, LVX_VR0_R12_R0 + (r << 21), p);
5485 return p + 4;
5488 static bfd_byte *
5489 restvr_tail (bfd *abfd, bfd_byte *p, int r)
5491 p = restvr (abfd, p, r);
5492 bfd_put_32 (abfd, BLR, p);
5493 return p + 4;
5496 /* Called via elf_link_hash_traverse to transfer dynamic linking
5497 information on function code symbol entries to their corresponding
5498 function descriptor symbol entries. */
5500 static bfd_boolean
5501 func_desc_adjust (struct elf_link_hash_entry *h, void *inf)
5503 struct bfd_link_info *info;
5504 struct ppc_link_hash_table *htab;
5505 struct plt_entry *ent;
5506 struct ppc_link_hash_entry *fh;
5507 struct ppc_link_hash_entry *fdh;
5508 bfd_boolean force_local;
5510 fh = (struct ppc_link_hash_entry *) h;
5511 if (fh->elf.root.type == bfd_link_hash_indirect)
5512 return TRUE;
5514 if (fh->elf.root.type == bfd_link_hash_warning)
5515 fh = (struct ppc_link_hash_entry *) fh->elf.root.u.i.link;
5517 info = inf;
5518 htab = ppc_hash_table (info);
5520 /* Resolve undefined references to dot-symbols as the value
5521 in the function descriptor, if we have one in a regular object.
5522 This is to satisfy cases like ".quad .foo". Calls to functions
5523 in dynamic objects are handled elsewhere. */
5524 if (fh->elf.root.type == bfd_link_hash_undefweak
5525 && fh->was_undefined
5526 && (fh->oh->elf.root.type == bfd_link_hash_defined
5527 || fh->oh->elf.root.type == bfd_link_hash_defweak)
5528 && get_opd_info (fh->oh->elf.root.u.def.section) != NULL
5529 && opd_entry_value (fh->oh->elf.root.u.def.section,
5530 fh->oh->elf.root.u.def.value,
5531 &fh->elf.root.u.def.section,
5532 &fh->elf.root.u.def.value) != (bfd_vma) -1)
5534 fh->elf.root.type = fh->oh->elf.root.type;
5535 fh->elf.forced_local = 1;
5538 /* If this is a function code symbol, transfer dynamic linking
5539 information to the function descriptor symbol. */
5540 if (!fh->is_func)
5541 return TRUE;
5543 for (ent = fh->elf.plt.plist; ent != NULL; ent = ent->next)
5544 if (ent->plt.refcount > 0)
5545 break;
5546 if (ent == NULL
5547 || fh->elf.root.root.string[0] != '.'
5548 || fh->elf.root.root.string[1] == '\0')
5549 return TRUE;
5551 /* Find the corresponding function descriptor symbol. Create it
5552 as undefined if necessary. */
5554 fdh = get_fdh (fh, htab);
5555 if (fdh != NULL)
5556 while (fdh->elf.root.type == bfd_link_hash_indirect
5557 || fdh->elf.root.type == bfd_link_hash_warning)
5558 fdh = (struct ppc_link_hash_entry *) fdh->elf.root.u.i.link;
5560 if (fdh == NULL
5561 && info->shared
5562 && (fh->elf.root.type == bfd_link_hash_undefined
5563 || fh->elf.root.type == bfd_link_hash_undefweak))
5565 fdh = make_fdh (info, fh);
5566 if (fdh == NULL)
5567 return FALSE;
5570 /* Fake function descriptors are made undefweak. If the function
5571 code symbol is strong undefined, make the fake sym the same.
5572 If the function code symbol is defined, then force the fake
5573 descriptor local; We can't support overriding of symbols in a
5574 shared library on a fake descriptor. */
5576 if (fdh != NULL
5577 && fdh->fake
5578 && fdh->elf.root.type == bfd_link_hash_undefweak)
5580 if (fh->elf.root.type == bfd_link_hash_undefined)
5582 fdh->elf.root.type = bfd_link_hash_undefined;
5583 bfd_link_add_undef (&htab->elf.root, &fdh->elf.root);
5585 else if (fh->elf.root.type == bfd_link_hash_defined
5586 || fh->elf.root.type == bfd_link_hash_defweak)
5588 _bfd_elf_link_hash_hide_symbol (info, &fdh->elf, TRUE);
5592 if (fdh != NULL
5593 && !fdh->elf.forced_local
5594 && (info->shared
5595 || fdh->elf.def_dynamic
5596 || fdh->elf.ref_dynamic
5597 || (fdh->elf.root.type == bfd_link_hash_undefweak
5598 && ELF_ST_VISIBILITY (fdh->elf.other) == STV_DEFAULT)))
5600 if (fdh->elf.dynindx == -1)
5601 if (! bfd_elf_link_record_dynamic_symbol (info, &fdh->elf))
5602 return FALSE;
5603 fdh->elf.ref_regular |= fh->elf.ref_regular;
5604 fdh->elf.ref_dynamic |= fh->elf.ref_dynamic;
5605 fdh->elf.ref_regular_nonweak |= fh->elf.ref_regular_nonweak;
5606 fdh->elf.non_got_ref |= fh->elf.non_got_ref;
5607 if (ELF_ST_VISIBILITY (fh->elf.other) == STV_DEFAULT)
5609 move_plt_plist (fh, fdh);
5610 fdh->elf.needs_plt = 1;
5612 fdh->is_func_descriptor = 1;
5613 fdh->oh = fh;
5614 fh->oh = fdh;
5617 /* Now that the info is on the function descriptor, clear the
5618 function code sym info. Any function code syms for which we
5619 don't have a definition in a regular file, we force local.
5620 This prevents a shared library from exporting syms that have
5621 been imported from another library. Function code syms that
5622 are really in the library we must leave global to prevent the
5623 linker dragging in a definition from a static library. */
5624 force_local = (!fh->elf.def_regular
5625 || fdh == NULL
5626 || !fdh->elf.def_regular
5627 || fdh->elf.forced_local);
5628 _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
5630 return TRUE;
5633 /* Called near the start of bfd_elf_size_dynamic_sections. We use
5634 this hook to a) provide some gcc support functions, and b) transfer
5635 dynamic linking information gathered so far on function code symbol
5636 entries, to their corresponding function descriptor symbol entries. */
5638 static bfd_boolean
5639 ppc64_elf_func_desc_adjust (bfd *obfd ATTRIBUTE_UNUSED,
5640 struct bfd_link_info *info)
5642 struct ppc_link_hash_table *htab;
5643 unsigned int i;
5644 const struct sfpr_def_parms funcs[] =
5646 { "_savegpr0_", 14, 31, savegpr0, savegpr0_tail },
5647 { "_restgpr0_", 14, 29, restgpr0, restgpr0_tail },
5648 { "_restgpr0_", 30, 31, restgpr0, restgpr0_tail },
5649 { "_savegpr1_", 14, 31, savegpr1, savegpr1_tail },
5650 { "_restgpr1_", 14, 31, restgpr1, restgpr1_tail },
5651 { "_savefpr_", 14, 31, savefpr, savefpr0_tail },
5652 { "_restfpr_", 14, 29, restfpr, restfpr0_tail },
5653 { "_restfpr_", 30, 31, restfpr, restfpr0_tail },
5654 { "._savef", 14, 31, savefpr, savefpr1_tail },
5655 { "._restf", 14, 31, restfpr, restfpr1_tail },
5656 { "_savevr_", 20, 31, savevr, savevr_tail },
5657 { "_restvr_", 20, 31, restvr, restvr_tail }
5660 htab = ppc_hash_table (info);
5661 if (htab->sfpr == NULL)
5662 /* We don't have any relocs. */
5663 return TRUE;
5665 /* Provide any missing _save* and _rest* functions. */
5666 htab->sfpr->size = 0;
5667 for (i = 0; i < sizeof (funcs) / sizeof (funcs[0]); i++)
5668 if (!sfpr_define (info, &funcs[i]))
5669 return FALSE;
5671 elf_link_hash_traverse (&htab->elf, func_desc_adjust, info);
5673 if (htab->sfpr->size == 0)
5674 htab->sfpr->flags |= SEC_EXCLUDE;
5676 return TRUE;
5679 /* Adjust a symbol defined by a dynamic object and referenced by a
5680 regular object. The current definition is in some section of the
5681 dynamic object, but we're not including those sections. We have to
5682 change the definition to something the rest of the link can
5683 understand. */
5685 static bfd_boolean
5686 ppc64_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
5687 struct elf_link_hash_entry *h)
5689 struct ppc_link_hash_table *htab;
5690 asection *s;
5691 unsigned int power_of_two;
5693 htab = ppc_hash_table (info);
5695 /* Deal with function syms. */
5696 if (h->type == STT_FUNC
5697 || h->needs_plt)
5699 /* Clear procedure linkage table information for any symbol that
5700 won't need a .plt entry. */
5701 struct plt_entry *ent;
5702 for (ent = h->plt.plist; ent != NULL; ent = ent->next)
5703 if (ent->plt.refcount > 0)
5704 break;
5705 if (ent == NULL
5706 || SYMBOL_CALLS_LOCAL (info, h)
5707 || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
5708 && h->root.type == bfd_link_hash_undefweak))
5710 h->plt.plist = NULL;
5711 h->needs_plt = 0;
5714 else
5715 h->plt.plist = NULL;
5717 /* If this is a weak symbol, and there is a real definition, the
5718 processor independent code will have arranged for us to see the
5719 real definition first, and we can just use the same value. */
5720 if (h->u.weakdef != NULL)
5722 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
5723 || h->u.weakdef->root.type == bfd_link_hash_defweak);
5724 h->root.u.def.section = h->u.weakdef->root.u.def.section;
5725 h->root.u.def.value = h->u.weakdef->root.u.def.value;
5726 if (ELIMINATE_COPY_RELOCS)
5727 h->non_got_ref = h->u.weakdef->non_got_ref;
5728 return TRUE;
5731 /* If we are creating a shared library, we must presume that the
5732 only references to the symbol are via the global offset table.
5733 For such cases we need not do anything here; the relocations will
5734 be handled correctly by relocate_section. */
5735 if (info->shared)
5736 return TRUE;
5738 /* If there are no references to this symbol that do not use the
5739 GOT, we don't need to generate a copy reloc. */
5740 if (!h->non_got_ref)
5741 return TRUE;
5743 if (ELIMINATE_COPY_RELOCS)
5745 struct ppc_link_hash_entry * eh;
5746 struct ppc_dyn_relocs *p;
5748 eh = (struct ppc_link_hash_entry *) h;
5749 for (p = eh->dyn_relocs; p != NULL; p = p->next)
5751 s = p->sec->output_section;
5752 if (s != NULL && (s->flags & SEC_READONLY) != 0)
5753 break;
5756 /* If we didn't find any dynamic relocs in read-only sections, then
5757 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
5758 if (p == NULL)
5760 h->non_got_ref = 0;
5761 return TRUE;
5765 if (h->plt.plist != NULL)
5767 /* We should never get here, but unfortunately there are versions
5768 of gcc out there that improperly (for this ABI) put initialized
5769 function pointers, vtable refs and suchlike in read-only
5770 sections. Allow them to proceed, but warn that this might
5771 break at runtime. */
5772 (*_bfd_error_handler)
5773 (_("copy reloc against `%s' requires lazy plt linking; "
5774 "avoid setting LD_BIND_NOW=1 or upgrade gcc"),
5775 h->root.root.string);
5778 /* This is a reference to a symbol defined by a dynamic object which
5779 is not a function. */
5781 if (h->size == 0)
5783 (*_bfd_error_handler) (_("dynamic variable `%s' is zero size"),
5784 h->root.root.string);
5785 return TRUE;
5788 /* We must allocate the symbol in our .dynbss section, which will
5789 become part of the .bss section of the executable. There will be
5790 an entry for this symbol in the .dynsym section. The dynamic
5791 object will contain position independent code, so all references
5792 from the dynamic object to this symbol will go through the global
5793 offset table. The dynamic linker will use the .dynsym entry to
5794 determine the address it must put in the global offset table, so
5795 both the dynamic object and the regular object will refer to the
5796 same memory location for the variable. */
5798 /* We must generate a R_PPC64_COPY reloc to tell the dynamic linker
5799 to copy the initial value out of the dynamic object and into the
5800 runtime process image. We need to remember the offset into the
5801 .rela.bss section we are going to use. */
5802 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
5804 htab->relbss->size += sizeof (Elf64_External_Rela);
5805 h->needs_copy = 1;
5808 /* We need to figure out the alignment required for this symbol. I
5809 have no idea how ELF linkers handle this. */
5810 power_of_two = bfd_log2 (h->size);
5811 if (power_of_two > 4)
5812 power_of_two = 4;
5814 /* Apply the required alignment. */
5815 s = htab->dynbss;
5816 s->size = BFD_ALIGN (s->size, (bfd_size_type) (1 << power_of_two));
5817 if (power_of_two > bfd_get_section_alignment (htab->elf.dynobj, s))
5819 if (! bfd_set_section_alignment (htab->elf.dynobj, s, power_of_two))
5820 return FALSE;
5823 /* Define the symbol as being at this point in the section. */
5824 h->root.u.def.section = s;
5825 h->root.u.def.value = s->size;
5827 /* Increment the section size to make room for the symbol. */
5828 s->size += h->size;
5830 return TRUE;
5833 /* If given a function descriptor symbol, hide both the function code
5834 sym and the descriptor. */
5835 static void
5836 ppc64_elf_hide_symbol (struct bfd_link_info *info,
5837 struct elf_link_hash_entry *h,
5838 bfd_boolean force_local)
5840 struct ppc_link_hash_entry *eh;
5841 _bfd_elf_link_hash_hide_symbol (info, h, force_local);
5843 eh = (struct ppc_link_hash_entry *) h;
5844 if (eh->is_func_descriptor)
5846 struct ppc_link_hash_entry *fh = eh->oh;
5848 if (fh == NULL)
5850 const char *p, *q;
5851 struct ppc_link_hash_table *htab;
5852 char save;
5854 /* We aren't supposed to use alloca in BFD because on
5855 systems which do not have alloca the version in libiberty
5856 calls xmalloc, which might cause the program to crash
5857 when it runs out of memory. This function doesn't have a
5858 return status, so there's no way to gracefully return an
5859 error. So cheat. We know that string[-1] can be safely
5860 accessed; It's either a string in an ELF string table,
5861 or allocated in an objalloc structure. */
5863 p = eh->elf.root.root.string - 1;
5864 save = *p;
5865 *(char *) p = '.';
5866 htab = ppc_hash_table (info);
5867 fh = (struct ppc_link_hash_entry *)
5868 elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
5869 *(char *) p = save;
5871 /* Unfortunately, if it so happens that the string we were
5872 looking for was allocated immediately before this string,
5873 then we overwrote the string terminator. That's the only
5874 reason the lookup should fail. */
5875 if (fh == NULL)
5877 q = eh->elf.root.root.string + strlen (eh->elf.root.root.string);
5878 while (q >= eh->elf.root.root.string && *q == *p)
5879 --q, --p;
5880 if (q < eh->elf.root.root.string && *p == '.')
5881 fh = (struct ppc_link_hash_entry *)
5882 elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
5884 if (fh != NULL)
5886 eh->oh = fh;
5887 fh->oh = eh;
5890 if (fh != NULL)
5891 _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
5895 static bfd_boolean
5896 get_sym_h (struct elf_link_hash_entry **hp,
5897 Elf_Internal_Sym **symp,
5898 asection **symsecp,
5899 char **tls_maskp,
5900 Elf_Internal_Sym **locsymsp,
5901 unsigned long r_symndx,
5902 bfd *ibfd)
5904 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
5906 if (r_symndx >= symtab_hdr->sh_info)
5908 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
5909 struct elf_link_hash_entry *h;
5911 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
5912 while (h->root.type == bfd_link_hash_indirect
5913 || h->root.type == bfd_link_hash_warning)
5914 h = (struct elf_link_hash_entry *) h->root.u.i.link;
5916 if (hp != NULL)
5917 *hp = h;
5919 if (symp != NULL)
5920 *symp = NULL;
5922 if (symsecp != NULL)
5924 asection *symsec = NULL;
5925 if (h->root.type == bfd_link_hash_defined
5926 || h->root.type == bfd_link_hash_defweak)
5927 symsec = h->root.u.def.section;
5928 *symsecp = symsec;
5931 if (tls_maskp != NULL)
5933 struct ppc_link_hash_entry *eh;
5935 eh = (struct ppc_link_hash_entry *) h;
5936 *tls_maskp = &eh->tls_mask;
5939 else
5941 Elf_Internal_Sym *sym;
5942 Elf_Internal_Sym *locsyms = *locsymsp;
5944 if (locsyms == NULL)
5946 locsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
5947 if (locsyms == NULL)
5948 locsyms = bfd_elf_get_elf_syms (ibfd, symtab_hdr,
5949 symtab_hdr->sh_info,
5950 0, NULL, NULL, NULL);
5951 if (locsyms == NULL)
5952 return FALSE;
5953 *locsymsp = locsyms;
5955 sym = locsyms + r_symndx;
5957 if (hp != NULL)
5958 *hp = NULL;
5960 if (symp != NULL)
5961 *symp = sym;
5963 if (symsecp != NULL)
5965 asection *symsec = NULL;
5966 if ((sym->st_shndx != SHN_UNDEF
5967 && sym->st_shndx < SHN_LORESERVE)
5968 || sym->st_shndx > SHN_HIRESERVE)
5969 symsec = bfd_section_from_elf_index (ibfd, sym->st_shndx);
5970 *symsecp = symsec;
5973 if (tls_maskp != NULL)
5975 struct got_entry **lgot_ents;
5976 char *tls_mask;
5978 tls_mask = NULL;
5979 lgot_ents = elf_local_got_ents (ibfd);
5980 if (lgot_ents != NULL)
5982 char *lgot_masks = (char *) (lgot_ents + symtab_hdr->sh_info);
5983 tls_mask = &lgot_masks[r_symndx];
5985 *tls_maskp = tls_mask;
5988 return TRUE;
5991 /* Returns TLS_MASKP for the given REL symbol. Function return is 0 on
5992 error, 2 on a toc GD type suitable for optimization, 3 on a toc LD
5993 type suitable for optimization, and 1 otherwise. */
5995 static int
5996 get_tls_mask (char **tls_maskp, unsigned long *toc_symndx,
5997 Elf_Internal_Sym **locsymsp,
5998 const Elf_Internal_Rela *rel, bfd *ibfd)
6000 unsigned long r_symndx;
6001 int next_r;
6002 struct elf_link_hash_entry *h;
6003 Elf_Internal_Sym *sym;
6004 asection *sec;
6005 bfd_vma off;
6007 r_symndx = ELF64_R_SYM (rel->r_info);
6008 if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
6009 return 0;
6011 if ((*tls_maskp != NULL && **tls_maskp != 0)
6012 || sec == NULL
6013 || ppc64_elf_section_data (sec)->t_symndx == NULL)
6014 return 1;
6016 /* Look inside a TOC section too. */
6017 if (h != NULL)
6019 BFD_ASSERT (h->root.type == bfd_link_hash_defined);
6020 off = h->root.u.def.value;
6022 else
6023 off = sym->st_value;
6024 off += rel->r_addend;
6025 BFD_ASSERT (off % 8 == 0);
6026 r_symndx = ppc64_elf_section_data (sec)->t_symndx[off / 8];
6027 next_r = ppc64_elf_section_data (sec)->t_symndx[off / 8 + 1];
6028 if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
6029 return 0;
6030 if (toc_symndx != NULL)
6031 *toc_symndx = r_symndx;
6032 if ((h == NULL
6033 || ((h->root.type == bfd_link_hash_defined
6034 || h->root.type == bfd_link_hash_defweak)
6035 && !h->def_dynamic))
6036 && (next_r == -1 || next_r == -2))
6037 return 1 - next_r;
6038 return 1;
6041 /* Adjust all global syms defined in opd sections. In gcc generated
6042 code for the old ABI, these will already have been done. */
6044 static bfd_boolean
6045 adjust_opd_syms (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
6047 struct ppc_link_hash_entry *eh;
6048 asection *sym_sec;
6049 long *opd_adjust;
6051 if (h->root.type == bfd_link_hash_indirect)
6052 return TRUE;
6054 if (h->root.type == bfd_link_hash_warning)
6055 h = (struct elf_link_hash_entry *) h->root.u.i.link;
6057 if (h->root.type != bfd_link_hash_defined
6058 && h->root.type != bfd_link_hash_defweak)
6059 return TRUE;
6061 eh = (struct ppc_link_hash_entry *) h;
6062 if (eh->adjust_done)
6063 return TRUE;
6065 sym_sec = eh->elf.root.u.def.section;
6066 opd_adjust = get_opd_info (sym_sec);
6067 if (opd_adjust != NULL)
6069 long adjust = opd_adjust[eh->elf.root.u.def.value / 8];
6070 if (adjust == -1)
6072 /* This entry has been deleted. */
6073 asection *dsec = ppc64_elf_tdata (sym_sec->owner)->u.deleted_section;
6074 if (dsec == NULL)
6076 for (dsec = sym_sec->owner->sections; dsec; dsec = dsec->next)
6077 if (elf_discarded_section (dsec))
6079 ppc64_elf_tdata (sym_sec->owner)->u.deleted_section = dsec;
6080 break;
6083 eh->elf.root.u.def.value = 0;
6084 eh->elf.root.u.def.section = dsec;
6086 else
6087 eh->elf.root.u.def.value += adjust;
6088 eh->adjust_done = 1;
6090 return TRUE;
6093 /* Handles decrementing dynamic reloc counts for the reloc specified by
6094 R_INFO in section SEC. If LOCAL_SYMS is NULL, then H and SYM_SEC
6095 have already been determined. */
6097 static bfd_boolean
6098 dec_dynrel_count (bfd_vma r_info,
6099 asection *sec,
6100 struct bfd_link_info *info,
6101 Elf_Internal_Sym **local_syms,
6102 struct elf_link_hash_entry *h,
6103 asection *sym_sec)
6105 enum elf_ppc64_reloc_type r_type;
6106 struct ppc_dyn_relocs *p;
6107 struct ppc_dyn_relocs **pp;
6109 /* Can this reloc be dynamic? This switch, and later tests here
6110 should be kept in sync with the code in check_relocs. */
6111 r_type = ELF64_R_TYPE (r_info);
6112 switch (r_type)
6114 default:
6115 return TRUE;
6117 case R_PPC64_TPREL16:
6118 case R_PPC64_TPREL16_LO:
6119 case R_PPC64_TPREL16_HI:
6120 case R_PPC64_TPREL16_HA:
6121 case R_PPC64_TPREL16_DS:
6122 case R_PPC64_TPREL16_LO_DS:
6123 case R_PPC64_TPREL16_HIGHER:
6124 case R_PPC64_TPREL16_HIGHERA:
6125 case R_PPC64_TPREL16_HIGHEST:
6126 case R_PPC64_TPREL16_HIGHESTA:
6127 if (!info->shared)
6128 return TRUE;
6130 case R_PPC64_TPREL64:
6131 case R_PPC64_DTPMOD64:
6132 case R_PPC64_DTPREL64:
6133 case R_PPC64_ADDR64:
6134 case R_PPC64_REL30:
6135 case R_PPC64_REL32:
6136 case R_PPC64_REL64:
6137 case R_PPC64_ADDR14:
6138 case R_PPC64_ADDR14_BRNTAKEN:
6139 case R_PPC64_ADDR14_BRTAKEN:
6140 case R_PPC64_ADDR16:
6141 case R_PPC64_ADDR16_DS:
6142 case R_PPC64_ADDR16_HA:
6143 case R_PPC64_ADDR16_HI:
6144 case R_PPC64_ADDR16_HIGHER:
6145 case R_PPC64_ADDR16_HIGHERA:
6146 case R_PPC64_ADDR16_HIGHEST:
6147 case R_PPC64_ADDR16_HIGHESTA:
6148 case R_PPC64_ADDR16_LO:
6149 case R_PPC64_ADDR16_LO_DS:
6150 case R_PPC64_ADDR24:
6151 case R_PPC64_ADDR32:
6152 case R_PPC64_UADDR16:
6153 case R_PPC64_UADDR32:
6154 case R_PPC64_UADDR64:
6155 case R_PPC64_TOC:
6156 break;
6159 if (local_syms != NULL)
6161 unsigned long r_symndx;
6162 Elf_Internal_Sym *sym;
6163 bfd *ibfd = sec->owner;
6165 r_symndx = ELF64_R_SYM (r_info);
6166 if (!get_sym_h (&h, &sym, &sym_sec, NULL, local_syms, r_symndx, ibfd))
6167 return FALSE;
6170 if ((info->shared
6171 && (MUST_BE_DYN_RELOC (r_type)
6172 || (h != NULL
6173 && (!info->symbolic
6174 || h->root.type == bfd_link_hash_defweak
6175 || !h->def_regular))))
6176 || (ELIMINATE_COPY_RELOCS
6177 && !info->shared
6178 && h != NULL
6179 && (h->root.type == bfd_link_hash_defweak
6180 || !h->def_regular)))
6182 else
6183 return TRUE;
6185 if (h != NULL)
6186 pp = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
6187 else
6189 if (sym_sec != NULL)
6191 void *vpp = &elf_section_data (sym_sec)->local_dynrel;
6192 pp = (struct ppc_dyn_relocs **) vpp;
6194 else
6196 void *vpp = &elf_section_data (sec)->local_dynrel;
6197 pp = (struct ppc_dyn_relocs **) vpp;
6200 /* elf_gc_sweep may have already removed all dyn relocs associated
6201 with local syms for a given section. Don't report a dynreloc
6202 miscount. */
6203 if (*pp == NULL)
6204 return TRUE;
6207 while ((p = *pp) != NULL)
6209 if (p->sec == sec)
6211 if (!MUST_BE_DYN_RELOC (r_type))
6212 p->pc_count -= 1;
6213 p->count -= 1;
6214 if (p->count == 0)
6215 *pp = p->next;
6216 return TRUE;
6218 pp = &p->next;
6221 (*_bfd_error_handler) (_("dynreloc miscount for %B, section %A"),
6222 sec->owner, sec);
6223 bfd_set_error (bfd_error_bad_value);
6224 return FALSE;
6227 /* Remove unused Official Procedure Descriptor entries. Currently we
6228 only remove those associated with functions in discarded link-once
6229 sections, or weakly defined functions that have been overridden. It
6230 would be possible to remove many more entries for statically linked
6231 applications. */
6233 bfd_boolean
6234 ppc64_elf_edit_opd (bfd *obfd, struct bfd_link_info *info,
6235 bfd_boolean no_opd_opt,
6236 bfd_boolean non_overlapping)
6238 bfd *ibfd;
6239 bfd_boolean some_edited = FALSE;
6240 asection *need_pad = NULL;
6242 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
6244 asection *sec;
6245 Elf_Internal_Rela *relstart, *rel, *relend;
6246 Elf_Internal_Shdr *symtab_hdr;
6247 Elf_Internal_Sym *local_syms;
6248 struct elf_link_hash_entry **sym_hashes;
6249 bfd_vma offset;
6250 bfd_size_type amt;
6251 long *opd_adjust;
6252 bfd_boolean need_edit, add_aux_fields;
6253 bfd_size_type cnt_16b = 0;
6255 sec = bfd_get_section_by_name (ibfd, ".opd");
6256 if (sec == NULL || sec->size == 0)
6257 continue;
6259 amt = sec->size * sizeof (long) / 8;
6260 opd_adjust = get_opd_info (sec);
6261 if (opd_adjust == NULL)
6263 /* check_relocs hasn't been called. Must be a ld -r link
6264 or --just-symbols object. */
6265 opd_adjust = bfd_alloc (obfd, amt);
6266 if (opd_adjust == NULL)
6267 return FALSE;
6268 ppc64_elf_section_data (sec)->opd.adjust = opd_adjust;
6270 memset (opd_adjust, 0, amt);
6272 if (no_opd_opt)
6273 continue;
6275 if (sec->sec_info_type == ELF_INFO_TYPE_JUST_SYMS)
6276 continue;
6278 if (sec->output_section == bfd_abs_section_ptr)
6279 continue;
6281 /* Look through the section relocs. */
6282 if ((sec->flags & SEC_RELOC) == 0 || sec->reloc_count == 0)
6283 continue;
6285 local_syms = NULL;
6286 symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
6287 sym_hashes = elf_sym_hashes (ibfd);
6289 /* Read the relocations. */
6290 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
6291 info->keep_memory);
6292 if (relstart == NULL)
6293 return FALSE;
6295 /* First run through the relocs to check they are sane, and to
6296 determine whether we need to edit this opd section. */
6297 need_edit = FALSE;
6298 need_pad = sec;
6299 offset = 0;
6300 relend = relstart + sec->reloc_count;
6301 for (rel = relstart; rel < relend; )
6303 enum elf_ppc64_reloc_type r_type;
6304 unsigned long r_symndx;
6305 asection *sym_sec;
6306 struct elf_link_hash_entry *h;
6307 Elf_Internal_Sym *sym;
6309 /* .opd contains a regular array of 16 or 24 byte entries. We're
6310 only interested in the reloc pointing to a function entry
6311 point. */
6312 if (rel->r_offset != offset
6313 || rel + 1 >= relend
6314 || (rel + 1)->r_offset != offset + 8)
6316 /* If someone messes with .opd alignment then after a
6317 "ld -r" we might have padding in the middle of .opd.
6318 Also, there's nothing to prevent someone putting
6319 something silly in .opd with the assembler. No .opd
6320 optimization for them! */
6321 broken_opd:
6322 (*_bfd_error_handler)
6323 (_("%B: .opd is not a regular array of opd entries"), ibfd);
6324 need_edit = FALSE;
6325 break;
6328 if ((r_type = ELF64_R_TYPE (rel->r_info)) != R_PPC64_ADDR64
6329 || (r_type = ELF64_R_TYPE ((rel + 1)->r_info)) != R_PPC64_TOC)
6331 (*_bfd_error_handler)
6332 (_("%B: unexpected reloc type %u in .opd section"),
6333 ibfd, r_type);
6334 need_edit = FALSE;
6335 break;
6338 r_symndx = ELF64_R_SYM (rel->r_info);
6339 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
6340 r_symndx, ibfd))
6341 goto error_ret;
6343 if (sym_sec == NULL || sym_sec->owner == NULL)
6345 const char *sym_name;
6346 if (h != NULL)
6347 sym_name = h->root.root.string;
6348 else
6349 sym_name = bfd_elf_sym_name (ibfd, symtab_hdr, sym,
6350 sym_sec);
6352 (*_bfd_error_handler)
6353 (_("%B: undefined sym `%s' in .opd section"),
6354 ibfd, sym_name);
6355 need_edit = FALSE;
6356 break;
6359 /* opd entries are always for functions defined in the
6360 current input bfd. If the symbol isn't defined in the
6361 input bfd, then we won't be using the function in this
6362 bfd; It must be defined in a linkonce section in another
6363 bfd, or is weak. It's also possible that we are
6364 discarding the function due to a linker script /DISCARD/,
6365 which we test for via the output_section. */
6366 if (sym_sec->owner != ibfd
6367 || sym_sec->output_section == bfd_abs_section_ptr)
6368 need_edit = TRUE;
6370 rel += 2;
6371 if (rel == relend
6372 || (rel + 1 == relend && rel->r_offset == offset + 16))
6374 if (sec->size == offset + 24)
6376 need_pad = NULL;
6377 break;
6379 if (rel == relend && sec->size == offset + 16)
6381 cnt_16b++;
6382 break;
6384 goto broken_opd;
6387 if (rel->r_offset == offset + 24)
6388 offset += 24;
6389 else if (rel->r_offset != offset + 16)
6390 goto broken_opd;
6391 else if (rel + 1 < relend
6392 && ELF64_R_TYPE (rel[0].r_info) == R_PPC64_ADDR64
6393 && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOC)
6395 offset += 16;
6396 cnt_16b++;
6398 else if (rel + 2 < relend
6399 && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_ADDR64
6400 && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_TOC)
6402 offset += 24;
6403 rel += 1;
6405 else
6406 goto broken_opd;
6409 add_aux_fields = non_overlapping && cnt_16b > 0;
6411 if (need_edit || add_aux_fields)
6413 Elf_Internal_Rela *write_rel;
6414 bfd_byte *rptr, *wptr;
6415 bfd_byte *new_contents = NULL;
6416 bfd_boolean skip;
6417 long opd_ent_size;
6419 /* This seems a waste of time as input .opd sections are all
6420 zeros as generated by gcc, but I suppose there's no reason
6421 this will always be so. We might start putting something in
6422 the third word of .opd entries. */
6423 if ((sec->flags & SEC_IN_MEMORY) == 0)
6425 bfd_byte *loc;
6426 if (!bfd_malloc_and_get_section (ibfd, sec, &loc))
6428 if (loc != NULL)
6429 free (loc);
6430 error_ret:
6431 if (local_syms != NULL
6432 && symtab_hdr->contents != (unsigned char *) local_syms)
6433 free (local_syms);
6434 if (elf_section_data (sec)->relocs != relstart)
6435 free (relstart);
6436 return FALSE;
6438 sec->contents = loc;
6439 sec->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
6442 elf_section_data (sec)->relocs = relstart;
6444 new_contents = sec->contents;
6445 if (add_aux_fields)
6447 new_contents = bfd_malloc (sec->size + cnt_16b * 8);
6448 if (new_contents == NULL)
6449 return FALSE;
6450 need_pad = FALSE;
6452 wptr = new_contents;
6453 rptr = sec->contents;
6455 write_rel = relstart;
6456 skip = FALSE;
6457 offset = 0;
6458 opd_ent_size = 0;
6459 for (rel = relstart; rel < relend; rel++)
6461 unsigned long r_symndx;
6462 asection *sym_sec;
6463 struct elf_link_hash_entry *h;
6464 Elf_Internal_Sym *sym;
6466 r_symndx = ELF64_R_SYM (rel->r_info);
6467 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
6468 r_symndx, ibfd))
6469 goto error_ret;
6471 if (rel->r_offset == offset)
6473 struct ppc_link_hash_entry *fdh = NULL;
6475 /* See if the .opd entry is full 24 byte or
6476 16 byte (with fd_aux entry overlapped with next
6477 fd_func). */
6478 opd_ent_size = 24;
6479 if ((rel + 2 == relend && sec->size == offset + 16)
6480 || (rel + 3 < relend
6481 && rel[2].r_offset == offset + 16
6482 && rel[3].r_offset == offset + 24
6483 && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_ADDR64
6484 && ELF64_R_TYPE (rel[3].r_info) == R_PPC64_TOC))
6485 opd_ent_size = 16;
6487 if (h != NULL
6488 && h->root.root.string[0] == '.')
6490 fdh = get_fdh ((struct ppc_link_hash_entry *) h,
6491 ppc_hash_table (info));
6492 if (fdh != NULL
6493 && fdh->elf.root.type != bfd_link_hash_defined
6494 && fdh->elf.root.type != bfd_link_hash_defweak)
6495 fdh = NULL;
6498 skip = (sym_sec->owner != ibfd
6499 || sym_sec->output_section == bfd_abs_section_ptr);
6500 if (skip)
6502 if (fdh != NULL && sym_sec->owner == ibfd)
6504 /* Arrange for the function descriptor sym
6505 to be dropped. */
6506 fdh->elf.root.u.def.value = 0;
6507 fdh->elf.root.u.def.section = sym_sec;
6509 opd_adjust[rel->r_offset / 8] = -1;
6511 else
6513 /* We'll be keeping this opd entry. */
6515 if (fdh != NULL)
6517 /* Redefine the function descriptor symbol to
6518 this location in the opd section. It is
6519 necessary to update the value here rather
6520 than using an array of adjustments as we do
6521 for local symbols, because various places
6522 in the generic ELF code use the value
6523 stored in u.def.value. */
6524 fdh->elf.root.u.def.value = wptr - new_contents;
6525 fdh->adjust_done = 1;
6528 /* Local syms are a bit tricky. We could
6529 tweak them as they can be cached, but
6530 we'd need to look through the local syms
6531 for the function descriptor sym which we
6532 don't have at the moment. So keep an
6533 array of adjustments. */
6534 opd_adjust[rel->r_offset / 8]
6535 = (wptr - new_contents) - (rptr - sec->contents);
6537 if (wptr != rptr)
6538 memcpy (wptr, rptr, opd_ent_size);
6539 wptr += opd_ent_size;
6540 if (add_aux_fields && opd_ent_size == 16)
6542 memset (wptr, '\0', 8);
6543 wptr += 8;
6546 rptr += opd_ent_size;
6547 offset += opd_ent_size;
6550 if (skip)
6552 if (!NO_OPD_RELOCS
6553 && !info->relocatable
6554 && !dec_dynrel_count (rel->r_info, sec, info,
6555 NULL, h, sym_sec))
6556 goto error_ret;
6558 else
6560 /* We need to adjust any reloc offsets to point to the
6561 new opd entries. While we're at it, we may as well
6562 remove redundant relocs. */
6563 rel->r_offset += opd_adjust[(offset - opd_ent_size) / 8];
6564 if (write_rel != rel)
6565 memcpy (write_rel, rel, sizeof (*rel));
6566 ++write_rel;
6570 sec->size = wptr - new_contents;
6571 sec->reloc_count = write_rel - relstart;
6572 if (add_aux_fields)
6574 free (sec->contents);
6575 sec->contents = new_contents;
6578 /* Fudge the size too, as this is used later in
6579 elf_bfd_final_link if we are emitting relocs. */
6580 elf_section_data (sec)->rel_hdr.sh_size
6581 = sec->reloc_count * elf_section_data (sec)->rel_hdr.sh_entsize;
6582 BFD_ASSERT (elf_section_data (sec)->rel_hdr2 == NULL);
6583 some_edited = TRUE;
6585 else if (elf_section_data (sec)->relocs != relstart)
6586 free (relstart);
6588 if (local_syms != NULL
6589 && symtab_hdr->contents != (unsigned char *) local_syms)
6591 if (!info->keep_memory)
6592 free (local_syms);
6593 else
6594 symtab_hdr->contents = (unsigned char *) local_syms;
6598 if (some_edited)
6599 elf_link_hash_traverse (elf_hash_table (info), adjust_opd_syms, NULL);
6601 /* If we are doing a final link and the last .opd entry is just 16 byte
6602 long, add a 8 byte padding after it. */
6603 if (need_pad != NULL && !info->relocatable)
6605 bfd_byte *p;
6607 if ((need_pad->flags & SEC_IN_MEMORY) == 0)
6609 BFD_ASSERT (need_pad->size > 0);
6611 p = bfd_malloc (need_pad->size + 8);
6612 if (p == NULL)
6613 return FALSE;
6615 if (! bfd_get_section_contents (need_pad->owner, need_pad,
6616 p, 0, need_pad->size))
6617 return FALSE;
6619 need_pad->contents = p;
6620 need_pad->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
6622 else
6624 p = bfd_realloc (need_pad->contents, need_pad->size + 8);
6625 if (p == NULL)
6626 return FALSE;
6628 need_pad->contents = p;
6631 memset (need_pad->contents + need_pad->size, 0, 8);
6632 need_pad->size += 8;
6635 return TRUE;
6638 /* Set htab->tls_get_addr and call the generic ELF tls_setup function. */
6640 asection *
6641 ppc64_elf_tls_setup (bfd *obfd, struct bfd_link_info *info)
6643 struct ppc_link_hash_table *htab;
6645 htab = ppc_hash_table (info);
6646 if (htab->tls_get_addr != NULL)
6648 struct ppc_link_hash_entry *h = htab->tls_get_addr;
6650 while (h->elf.root.type == bfd_link_hash_indirect
6651 || h->elf.root.type == bfd_link_hash_warning)
6652 h = (struct ppc_link_hash_entry *) h->elf.root.u.i.link;
6654 htab->tls_get_addr = h;
6656 if (htab->tls_get_addr_fd == NULL
6657 && h->oh != NULL
6658 && h->oh->is_func_descriptor
6659 && (h->oh->elf.root.type == bfd_link_hash_defined
6660 || h->oh->elf.root.type == bfd_link_hash_defweak))
6661 htab->tls_get_addr_fd = h->oh;
6664 if (htab->tls_get_addr_fd != NULL)
6666 struct ppc_link_hash_entry *h = htab->tls_get_addr_fd;
6668 while (h->elf.root.type == bfd_link_hash_indirect
6669 || h->elf.root.type == bfd_link_hash_warning)
6670 h = (struct ppc_link_hash_entry *) h->elf.root.u.i.link;
6672 htab->tls_get_addr_fd = h;
6675 return _bfd_elf_tls_setup (obfd, info);
6678 /* Run through all the TLS relocs looking for optimization
6679 opportunities. The linker has been hacked (see ppc64elf.em) to do
6680 a preliminary section layout so that we know the TLS segment
6681 offsets. We can't optimize earlier because some optimizations need
6682 to know the tp offset, and we need to optimize before allocating
6683 dynamic relocations. */
6685 bfd_boolean
6686 ppc64_elf_tls_optimize (bfd *obfd ATTRIBUTE_UNUSED, struct bfd_link_info *info)
6688 bfd *ibfd;
6689 asection *sec;
6690 struct ppc_link_hash_table *htab;
6692 if (info->relocatable || info->shared)
6693 return TRUE;
6695 htab = ppc_hash_table (info);
6696 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
6698 Elf_Internal_Sym *locsyms = NULL;
6700 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
6701 if (sec->has_tls_reloc && !bfd_is_abs_section (sec->output_section))
6703 Elf_Internal_Rela *relstart, *rel, *relend;
6704 int expecting_tls_get_addr;
6706 /* Read the relocations. */
6707 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
6708 info->keep_memory);
6709 if (relstart == NULL)
6710 return FALSE;
6712 expecting_tls_get_addr = 0;
6713 relend = relstart + sec->reloc_count;
6714 for (rel = relstart; rel < relend; rel++)
6716 enum elf_ppc64_reloc_type r_type;
6717 unsigned long r_symndx;
6718 struct elf_link_hash_entry *h;
6719 Elf_Internal_Sym *sym;
6720 asection *sym_sec;
6721 char *tls_mask;
6722 char tls_set, tls_clear, tls_type = 0;
6723 bfd_vma value;
6724 bfd_boolean ok_tprel, is_local;
6726 r_symndx = ELF64_R_SYM (rel->r_info);
6727 if (!get_sym_h (&h, &sym, &sym_sec, &tls_mask, &locsyms,
6728 r_symndx, ibfd))
6730 err_free_rel:
6731 if (elf_section_data (sec)->relocs != relstart)
6732 free (relstart);
6733 if (locsyms != NULL
6734 && (elf_tdata (ibfd)->symtab_hdr.contents
6735 != (unsigned char *) locsyms))
6736 free (locsyms);
6737 return FALSE;
6740 if (h != NULL)
6742 if (h->root.type != bfd_link_hash_defined
6743 && h->root.type != bfd_link_hash_defweak)
6744 continue;
6745 value = h->root.u.def.value;
6747 else
6748 /* Symbols referenced by TLS relocs must be of type
6749 STT_TLS. So no need for .opd local sym adjust. */
6750 value = sym->st_value;
6752 ok_tprel = FALSE;
6753 is_local = FALSE;
6754 if (h == NULL
6755 || !h->def_dynamic)
6757 is_local = TRUE;
6758 value += sym_sec->output_offset;
6759 value += sym_sec->output_section->vma;
6760 value -= htab->elf.tls_sec->vma;
6761 ok_tprel = (value + TP_OFFSET + ((bfd_vma) 1 << 31)
6762 < (bfd_vma) 1 << 32);
6765 r_type = ELF64_R_TYPE (rel->r_info);
6766 switch (r_type)
6768 case R_PPC64_GOT_TLSLD16:
6769 case R_PPC64_GOT_TLSLD16_LO:
6770 case R_PPC64_GOT_TLSLD16_HI:
6771 case R_PPC64_GOT_TLSLD16_HA:
6772 /* These relocs should never be against a symbol
6773 defined in a shared lib. Leave them alone if
6774 that turns out to be the case. */
6775 ppc64_tlsld_got (ibfd)->refcount -= 1;
6776 if (!is_local)
6777 continue;
6779 /* LD -> LE */
6780 tls_set = 0;
6781 tls_clear = TLS_LD;
6782 tls_type = TLS_TLS | TLS_LD;
6783 expecting_tls_get_addr = 1;
6784 break;
6786 case R_PPC64_GOT_TLSGD16:
6787 case R_PPC64_GOT_TLSGD16_LO:
6788 case R_PPC64_GOT_TLSGD16_HI:
6789 case R_PPC64_GOT_TLSGD16_HA:
6790 if (ok_tprel)
6791 /* GD -> LE */
6792 tls_set = 0;
6793 else
6794 /* GD -> IE */
6795 tls_set = TLS_TLS | TLS_TPRELGD;
6796 tls_clear = TLS_GD;
6797 tls_type = TLS_TLS | TLS_GD;
6798 expecting_tls_get_addr = 1;
6799 break;
6801 case R_PPC64_GOT_TPREL16_DS:
6802 case R_PPC64_GOT_TPREL16_LO_DS:
6803 case R_PPC64_GOT_TPREL16_HI:
6804 case R_PPC64_GOT_TPREL16_HA:
6805 expecting_tls_get_addr = 0;
6806 if (ok_tprel)
6808 /* IE -> LE */
6809 tls_set = 0;
6810 tls_clear = TLS_TPREL;
6811 tls_type = TLS_TLS | TLS_TPREL;
6812 break;
6814 else
6815 continue;
6817 case R_PPC64_REL14:
6818 case R_PPC64_REL14_BRTAKEN:
6819 case R_PPC64_REL14_BRNTAKEN:
6820 case R_PPC64_REL24:
6821 if (h != NULL
6822 && (h == &htab->tls_get_addr->elf
6823 || h == &htab->tls_get_addr_fd->elf))
6825 if (!expecting_tls_get_addr
6826 && rel != relstart
6827 && ((ELF64_R_TYPE (rel[-1].r_info)
6828 == R_PPC64_TOC16)
6829 || (ELF64_R_TYPE (rel[-1].r_info)
6830 == R_PPC64_TOC16_LO)))
6832 /* Check for toc tls entries. */
6833 char *toc_tls;
6834 int retval;
6836 retval = get_tls_mask (&toc_tls, NULL, &locsyms,
6837 rel - 1, ibfd);
6838 if (retval == 0)
6839 goto err_free_rel;
6840 if (toc_tls != NULL)
6841 expecting_tls_get_addr = retval > 1;
6844 if (expecting_tls_get_addr)
6846 struct plt_entry *ent;
6847 for (ent = h->plt.plist; ent; ent = ent->next)
6848 if (ent->addend == 0)
6850 if (ent->plt.refcount > 0)
6851 ent->plt.refcount -= 1;
6852 break;
6856 expecting_tls_get_addr = 0;
6857 continue;
6859 case R_PPC64_TPREL64:
6860 expecting_tls_get_addr = 0;
6861 if (ok_tprel)
6863 /* IE -> LE */
6864 tls_set = TLS_EXPLICIT;
6865 tls_clear = TLS_TPREL;
6866 break;
6868 else
6869 continue;
6871 case R_PPC64_DTPMOD64:
6872 expecting_tls_get_addr = 0;
6873 if (rel + 1 < relend
6874 && (rel[1].r_info
6875 == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64))
6876 && rel[1].r_offset == rel->r_offset + 8)
6878 if (ok_tprel)
6879 /* GD -> LE */
6880 tls_set = TLS_EXPLICIT | TLS_GD;
6881 else
6882 /* GD -> IE */
6883 tls_set = TLS_EXPLICIT | TLS_GD | TLS_TPRELGD;
6884 tls_clear = TLS_GD;
6886 else
6888 if (!is_local)
6889 continue;
6891 /* LD -> LE */
6892 tls_set = TLS_EXPLICIT;
6893 tls_clear = TLS_LD;
6895 break;
6897 default:
6898 expecting_tls_get_addr = 0;
6899 continue;
6902 if ((tls_set & TLS_EXPLICIT) == 0)
6904 struct got_entry *ent;
6906 /* Adjust got entry for this reloc. */
6907 if (h != NULL)
6908 ent = h->got.glist;
6909 else
6910 ent = elf_local_got_ents (ibfd)[r_symndx];
6912 for (; ent != NULL; ent = ent->next)
6913 if (ent->addend == rel->r_addend
6914 && ent->owner == ibfd
6915 && ent->tls_type == tls_type)
6916 break;
6917 if (ent == NULL)
6918 abort ();
6920 if (tls_set == 0)
6922 /* We managed to get rid of a got entry. */
6923 if (ent->got.refcount > 0)
6924 ent->got.refcount -= 1;
6927 else
6929 /* If we got rid of a DTPMOD/DTPREL reloc pair then
6930 we'll lose one or two dyn relocs. */
6931 if (!dec_dynrel_count (rel->r_info, sec, info,
6932 NULL, h, sym_sec))
6933 return FALSE;
6935 if (tls_set == (TLS_EXPLICIT | TLS_GD))
6937 if (!dec_dynrel_count ((rel + 1)->r_info, sec, info,
6938 NULL, h, sym_sec))
6939 return FALSE;
6943 *tls_mask |= tls_set;
6944 *tls_mask &= ~tls_clear;
6947 if (elf_section_data (sec)->relocs != relstart)
6948 free (relstart);
6951 if (locsyms != NULL
6952 && (elf_tdata (ibfd)->symtab_hdr.contents
6953 != (unsigned char *) locsyms))
6955 if (!info->keep_memory)
6956 free (locsyms);
6957 else
6958 elf_tdata (ibfd)->symtab_hdr.contents = (unsigned char *) locsyms;
6961 return TRUE;
6964 /* Called via elf_link_hash_traverse from ppc64_elf_edit_toc to adjust
6965 the values of any global symbols in a toc section that has been
6966 edited. Globals in toc sections should be a rarity, so this function
6967 sets a flag if any are found in toc sections other than the one just
6968 edited, so that futher hash table traversals can be avoided. */
6970 struct adjust_toc_info
6972 asection *toc;
6973 unsigned long *skip;
6974 bfd_boolean global_toc_syms;
6977 static bfd_boolean
6978 adjust_toc_syms (struct elf_link_hash_entry *h, void *inf)
6980 struct ppc_link_hash_entry *eh;
6981 struct adjust_toc_info *toc_inf = (struct adjust_toc_info *) inf;
6983 if (h->root.type == bfd_link_hash_indirect)
6984 return TRUE;
6986 if (h->root.type == bfd_link_hash_warning)
6987 h = (struct elf_link_hash_entry *) h->root.u.i.link;
6989 if (h->root.type != bfd_link_hash_defined
6990 && h->root.type != bfd_link_hash_defweak)
6991 return TRUE;
6993 eh = (struct ppc_link_hash_entry *) h;
6994 if (eh->adjust_done)
6995 return TRUE;
6997 if (eh->elf.root.u.def.section == toc_inf->toc)
6999 unsigned long skip = toc_inf->skip[eh->elf.root.u.def.value >> 3];
7000 if (skip != (unsigned long) -1)
7001 eh->elf.root.u.def.value -= skip;
7002 else
7004 (*_bfd_error_handler)
7005 (_("%s defined in removed toc entry"), eh->elf.root.root.string);
7006 eh->elf.root.u.def.section = &bfd_abs_section;
7007 eh->elf.root.u.def.value = 0;
7009 eh->adjust_done = 1;
7011 else if (strcmp (eh->elf.root.u.def.section->name, ".toc") == 0)
7012 toc_inf->global_toc_syms = TRUE;
7014 return TRUE;
7017 /* Examine all relocs referencing .toc sections in order to remove
7018 unused .toc entries. */
7020 bfd_boolean
7021 ppc64_elf_edit_toc (bfd *obfd ATTRIBUTE_UNUSED, struct bfd_link_info *info)
7023 bfd *ibfd;
7024 struct adjust_toc_info toc_inf;
7026 toc_inf.global_toc_syms = TRUE;
7027 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
7029 asection *toc, *sec;
7030 Elf_Internal_Shdr *symtab_hdr;
7031 Elf_Internal_Sym *local_syms;
7032 struct elf_link_hash_entry **sym_hashes;
7033 Elf_Internal_Rela *relstart, *rel;
7034 unsigned long *skip, *drop;
7035 unsigned char *used;
7036 unsigned char *keep, last, some_unused;
7038 toc = bfd_get_section_by_name (ibfd, ".toc");
7039 if (toc == NULL
7040 || toc->size == 0
7041 || toc->sec_info_type == ELF_INFO_TYPE_JUST_SYMS
7042 || elf_discarded_section (toc))
7043 continue;
7045 local_syms = NULL;
7046 symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
7047 sym_hashes = elf_sym_hashes (ibfd);
7049 /* Look at sections dropped from the final link. */
7050 skip = NULL;
7051 relstart = NULL;
7052 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
7054 if (sec->reloc_count == 0
7055 || !elf_discarded_section (sec)
7056 || get_opd_info (sec)
7057 || (sec->flags & SEC_ALLOC) == 0
7058 || (sec->flags & SEC_DEBUGGING) != 0)
7059 continue;
7061 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL, FALSE);
7062 if (relstart == NULL)
7063 goto error_ret;
7065 /* Run through the relocs to see which toc entries might be
7066 unused. */
7067 for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
7069 enum elf_ppc64_reloc_type r_type;
7070 unsigned long r_symndx;
7071 asection *sym_sec;
7072 struct elf_link_hash_entry *h;
7073 Elf_Internal_Sym *sym;
7074 bfd_vma val;
7076 r_type = ELF64_R_TYPE (rel->r_info);
7077 switch (r_type)
7079 default:
7080 continue;
7082 case R_PPC64_TOC16:
7083 case R_PPC64_TOC16_LO:
7084 case R_PPC64_TOC16_HI:
7085 case R_PPC64_TOC16_HA:
7086 case R_PPC64_TOC16_DS:
7087 case R_PPC64_TOC16_LO_DS:
7088 break;
7091 r_symndx = ELF64_R_SYM (rel->r_info);
7092 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7093 r_symndx, ibfd))
7094 goto error_ret;
7096 if (sym_sec != toc)
7097 continue;
7099 if (h != NULL)
7100 val = h->root.u.def.value;
7101 else
7102 val = sym->st_value;
7103 val += rel->r_addend;
7105 if (val >= toc->size)
7106 continue;
7108 /* Anything in the toc ought to be aligned to 8 bytes.
7109 If not, don't mark as unused. */
7110 if (val & 7)
7111 continue;
7113 if (skip == NULL)
7115 skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 7) / 8);
7116 if (skip == NULL)
7117 goto error_ret;
7120 skip[val >> 3] = 1;
7123 if (elf_section_data (sec)->relocs != relstart)
7124 free (relstart);
7127 if (skip == NULL)
7128 continue;
7130 used = bfd_zmalloc (sizeof (*used) * (toc->size + 7) / 8);
7131 if (used == NULL)
7133 error_ret:
7134 if (local_syms != NULL
7135 && symtab_hdr->contents != (unsigned char *) local_syms)
7136 free (local_syms);
7137 if (sec != NULL
7138 && relstart != NULL
7139 && elf_section_data (sec)->relocs != relstart)
7140 free (relstart);
7141 if (skip != NULL)
7142 free (skip);
7143 return FALSE;
7146 /* Now check all kept sections that might reference the toc. */
7147 for (sec = ibfd->sections;
7148 sec != NULL;
7149 /* Check the toc itself last. */
7150 sec = (sec == toc ? NULL
7151 : sec->next == toc && sec->next->next ? sec->next->next
7152 : sec->next == NULL ? toc
7153 : sec->next))
7155 int repeat;
7157 if (sec->reloc_count == 0
7158 || elf_discarded_section (sec)
7159 || get_opd_info (sec)
7160 || (sec->flags & SEC_ALLOC) == 0
7161 || (sec->flags & SEC_DEBUGGING) != 0)
7162 continue;
7164 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL, TRUE);
7165 if (relstart == NULL)
7166 goto error_ret;
7168 /* Mark toc entries referenced as used. */
7169 repeat = 0;
7171 for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
7173 enum elf_ppc64_reloc_type r_type;
7174 unsigned long r_symndx;
7175 asection *sym_sec;
7176 struct elf_link_hash_entry *h;
7177 Elf_Internal_Sym *sym;
7178 bfd_vma val;
7180 r_type = ELF64_R_TYPE (rel->r_info);
7181 switch (r_type)
7183 case R_PPC64_TOC16:
7184 case R_PPC64_TOC16_LO:
7185 case R_PPC64_TOC16_HI:
7186 case R_PPC64_TOC16_HA:
7187 case R_PPC64_TOC16_DS:
7188 case R_PPC64_TOC16_LO_DS:
7189 /* In case we're taking addresses of toc entries. */
7190 case R_PPC64_ADDR64:
7191 break;
7193 default:
7194 continue;
7197 r_symndx = ELF64_R_SYM (rel->r_info);
7198 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7199 r_symndx, ibfd))
7201 free (used);
7202 goto error_ret;
7205 if (sym_sec != toc)
7206 continue;
7208 if (h != NULL)
7209 val = h->root.u.def.value;
7210 else
7211 val = sym->st_value;
7212 val += rel->r_addend;
7214 if (val >= toc->size)
7215 continue;
7217 /* For the toc section, we only mark as used if
7218 this entry itself isn't unused. */
7219 if (sec == toc
7220 && !used[val >> 3]
7221 && (used[rel->r_offset >> 3]
7222 || !skip[rel->r_offset >> 3]))
7223 /* Do all the relocs again, to catch reference
7224 chains. */
7225 repeat = 1;
7227 used[val >> 3] = 1;
7229 while (repeat);
7232 /* Merge the used and skip arrays. Assume that TOC
7233 doublewords not appearing as either used or unused belong
7234 to to an entry more than one doubleword in size. */
7235 for (drop = skip, keep = used, last = 0, some_unused = 0;
7236 drop < skip + (toc->size + 7) / 8;
7237 ++drop, ++keep)
7239 if (*keep)
7241 *drop = 0;
7242 last = 0;
7244 else if (*drop)
7246 some_unused = 1;
7247 last = 1;
7249 else
7250 *drop = last;
7253 free (used);
7255 if (some_unused)
7257 bfd_byte *contents, *src;
7258 unsigned long off;
7260 /* Shuffle the toc contents, and at the same time convert the
7261 skip array from booleans into offsets. */
7262 if (!bfd_malloc_and_get_section (ibfd, toc, &contents))
7263 goto error_ret;
7265 elf_section_data (toc)->this_hdr.contents = contents;
7267 for (src = contents, off = 0, drop = skip;
7268 src < contents + toc->size;
7269 src += 8, ++drop)
7271 if (*drop)
7273 *drop = (unsigned long) -1;
7274 off += 8;
7276 else if (off != 0)
7278 *drop = off;
7279 memcpy (src - off, src, 8);
7282 toc->rawsize = toc->size;
7283 toc->size = src - contents - off;
7285 if (toc->reloc_count != 0)
7287 Elf_Internal_Rela *wrel;
7288 bfd_size_type sz;
7290 /* Read toc relocs. */
7291 relstart = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
7292 TRUE);
7293 if (relstart == NULL)
7294 goto error_ret;
7296 /* Remove unused toc relocs, and adjust those we keep. */
7297 wrel = relstart;
7298 for (rel = relstart; rel < relstart + toc->reloc_count; ++rel)
7299 if (skip[rel->r_offset >> 3] != (unsigned long) -1)
7301 wrel->r_offset = rel->r_offset - skip[rel->r_offset >> 3];
7302 wrel->r_info = rel->r_info;
7303 wrel->r_addend = rel->r_addend;
7304 ++wrel;
7306 else if (!dec_dynrel_count (rel->r_info, toc, info,
7307 &local_syms, NULL, NULL))
7308 goto error_ret;
7310 toc->reloc_count = wrel - relstart;
7311 sz = elf_section_data (toc)->rel_hdr.sh_entsize;
7312 elf_section_data (toc)->rel_hdr.sh_size = toc->reloc_count * sz;
7313 BFD_ASSERT (elf_section_data (toc)->rel_hdr2 == NULL);
7316 /* Adjust addends for relocs against the toc section sym. */
7317 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
7319 if (sec->reloc_count == 0
7320 || elf_discarded_section (sec))
7321 continue;
7323 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
7324 TRUE);
7325 if (relstart == NULL)
7326 goto error_ret;
7328 for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
7330 enum elf_ppc64_reloc_type r_type;
7331 unsigned long r_symndx;
7332 asection *sym_sec;
7333 struct elf_link_hash_entry *h;
7334 Elf_Internal_Sym *sym;
7336 r_type = ELF64_R_TYPE (rel->r_info);
7337 switch (r_type)
7339 default:
7340 continue;
7342 case R_PPC64_TOC16:
7343 case R_PPC64_TOC16_LO:
7344 case R_PPC64_TOC16_HI:
7345 case R_PPC64_TOC16_HA:
7346 case R_PPC64_TOC16_DS:
7347 case R_PPC64_TOC16_LO_DS:
7348 case R_PPC64_ADDR64:
7349 break;
7352 r_symndx = ELF64_R_SYM (rel->r_info);
7353 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7354 r_symndx, ibfd))
7355 goto error_ret;
7357 if (sym_sec != toc || h != NULL || sym->st_value != 0)
7358 continue;
7360 rel->r_addend -= skip[rel->r_addend >> 3];
7364 /* We shouldn't have local or global symbols defined in the TOC,
7365 but handle them anyway. */
7366 if (local_syms != NULL)
7368 Elf_Internal_Sym *sym;
7370 for (sym = local_syms;
7371 sym < local_syms + symtab_hdr->sh_info;
7372 ++sym)
7373 if (sym->st_shndx != SHN_UNDEF
7374 && (sym->st_shndx < SHN_LORESERVE
7375 || sym->st_shndx > SHN_HIRESERVE)
7376 && sym->st_value != 0
7377 && bfd_section_from_elf_index (ibfd, sym->st_shndx) == toc)
7379 if (skip[sym->st_value >> 3] != (unsigned long) -1)
7380 sym->st_value -= skip[sym->st_value >> 3];
7381 else
7383 (*_bfd_error_handler)
7384 (_("%s defined in removed toc entry"),
7385 bfd_elf_sym_name (ibfd, symtab_hdr, sym,
7386 NULL));
7387 sym->st_value = 0;
7388 sym->st_shndx = SHN_ABS;
7390 symtab_hdr->contents = (unsigned char *) local_syms;
7394 /* Finally, adjust any global syms defined in the toc. */
7395 if (toc_inf.global_toc_syms)
7397 toc_inf.toc = toc;
7398 toc_inf.skip = skip;
7399 toc_inf.global_toc_syms = FALSE;
7400 elf_link_hash_traverse (elf_hash_table (info), adjust_toc_syms,
7401 &toc_inf);
7405 if (local_syms != NULL
7406 && symtab_hdr->contents != (unsigned char *) local_syms)
7408 if (!info->keep_memory)
7409 free (local_syms);
7410 else
7411 symtab_hdr->contents = (unsigned char *) local_syms;
7413 free (skip);
7416 return TRUE;
7419 /* Allocate space in .plt, .got and associated reloc sections for
7420 dynamic relocs. */
7422 static bfd_boolean
7423 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
7425 struct bfd_link_info *info;
7426 struct ppc_link_hash_table *htab;
7427 asection *s;
7428 struct ppc_link_hash_entry *eh;
7429 struct ppc_dyn_relocs *p;
7430 struct got_entry *gent;
7432 if (h->root.type == bfd_link_hash_indirect)
7433 return TRUE;
7435 if (h->root.type == bfd_link_hash_warning)
7436 h = (struct elf_link_hash_entry *) h->root.u.i.link;
7438 info = (struct bfd_link_info *) inf;
7439 htab = ppc_hash_table (info);
7441 if (htab->elf.dynamic_sections_created
7442 && h->dynindx != -1
7443 && WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info->shared, h))
7445 struct plt_entry *pent;
7446 bfd_boolean doneone = FALSE;
7447 for (pent = h->plt.plist; pent != NULL; pent = pent->next)
7448 if (pent->plt.refcount > 0)
7450 /* If this is the first .plt entry, make room for the special
7451 first entry. */
7452 s = htab->plt;
7453 if (s->size == 0)
7454 s->size += PLT_INITIAL_ENTRY_SIZE;
7456 pent->plt.offset = s->size;
7458 /* Make room for this entry. */
7459 s->size += PLT_ENTRY_SIZE;
7461 /* Make room for the .glink code. */
7462 s = htab->glink;
7463 if (s->size == 0)
7464 s->size += GLINK_CALL_STUB_SIZE;
7465 /* We need bigger stubs past index 32767. */
7466 if (s->size >= GLINK_CALL_STUB_SIZE + 32768*2*4)
7467 s->size += 4;
7468 s->size += 2*4;
7470 /* We also need to make an entry in the .rela.plt section. */
7471 s = htab->relplt;
7472 s->size += sizeof (Elf64_External_Rela);
7473 doneone = TRUE;
7475 else
7476 pent->plt.offset = (bfd_vma) -1;
7477 if (!doneone)
7479 h->plt.plist = NULL;
7480 h->needs_plt = 0;
7483 else
7485 h->plt.plist = NULL;
7486 h->needs_plt = 0;
7489 eh = (struct ppc_link_hash_entry *) h;
7490 /* Run through the TLS GD got entries first if we're changing them
7491 to TPREL. */
7492 if ((eh->tls_mask & TLS_TPRELGD) != 0)
7493 for (gent = h->got.glist; gent != NULL; gent = gent->next)
7494 if (gent->got.refcount > 0
7495 && (gent->tls_type & TLS_GD) != 0)
7497 /* This was a GD entry that has been converted to TPREL. If
7498 there happens to be a TPREL entry we can use that one. */
7499 struct got_entry *ent;
7500 for (ent = h->got.glist; ent != NULL; ent = ent->next)
7501 if (ent->got.refcount > 0
7502 && (ent->tls_type & TLS_TPREL) != 0
7503 && ent->addend == gent->addend
7504 && ent->owner == gent->owner)
7506 gent->got.refcount = 0;
7507 break;
7510 /* If not, then we'll be using our own TPREL entry. */
7511 if (gent->got.refcount != 0)
7512 gent->tls_type = TLS_TLS | TLS_TPREL;
7515 for (gent = h->got.glist; gent != NULL; gent = gent->next)
7516 if (gent->got.refcount > 0)
7518 bfd_boolean dyn;
7520 /* Make sure this symbol is output as a dynamic symbol.
7521 Undefined weak syms won't yet be marked as dynamic,
7522 nor will all TLS symbols. */
7523 if (h->dynindx == -1
7524 && !h->forced_local)
7526 if (! bfd_elf_link_record_dynamic_symbol (info, h))
7527 return FALSE;
7530 if ((gent->tls_type & TLS_LD) != 0
7531 && !h->def_dynamic)
7533 gent->got.offset = ppc64_tlsld_got (gent->owner)->offset;
7534 continue;
7537 s = ppc64_elf_tdata (gent->owner)->got;
7538 gent->got.offset = s->size;
7539 s->size
7540 += (gent->tls_type & eh->tls_mask & (TLS_GD | TLS_LD)) ? 16 : 8;
7541 dyn = htab->elf.dynamic_sections_created;
7542 if ((info->shared
7543 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h))
7544 && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
7545 || h->root.type != bfd_link_hash_undefweak))
7546 ppc64_elf_tdata (gent->owner)->relgot->size
7547 += (gent->tls_type & eh->tls_mask & TLS_GD
7548 ? 2 * sizeof (Elf64_External_Rela)
7549 : sizeof (Elf64_External_Rela));
7551 else
7552 gent->got.offset = (bfd_vma) -1;
7554 if (eh->dyn_relocs == NULL)
7555 return TRUE;
7557 /* In the shared -Bsymbolic case, discard space allocated for
7558 dynamic pc-relative relocs against symbols which turn out to be
7559 defined in regular objects. For the normal shared case, discard
7560 space for relocs that have become local due to symbol visibility
7561 changes. */
7563 if (info->shared)
7565 /* Relocs that use pc_count are those that appear on a call insn,
7566 or certain REL relocs (see MUST_BE_DYN_RELOC) that can be
7567 generated via assembly. We want calls to protected symbols to
7568 resolve directly to the function rather than going via the plt.
7569 If people want function pointer comparisons to work as expected
7570 then they should avoid writing weird assembly. */
7571 if (SYMBOL_CALLS_LOCAL (info, h))
7573 struct ppc_dyn_relocs **pp;
7575 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
7577 p->count -= p->pc_count;
7578 p->pc_count = 0;
7579 if (p->count == 0)
7580 *pp = p->next;
7581 else
7582 pp = &p->next;
7586 /* Also discard relocs on undefined weak syms with non-default
7587 visibility. */
7588 if (eh->dyn_relocs != NULL
7589 && h->root.type == bfd_link_hash_undefweak)
7591 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
7592 eh->dyn_relocs = NULL;
7594 /* Make sure this symbol is output as a dynamic symbol.
7595 Undefined weak syms won't yet be marked as dynamic. */
7596 else if (h->dynindx == -1
7597 && !h->forced_local)
7599 if (! bfd_elf_link_record_dynamic_symbol (info, h))
7600 return FALSE;
7604 else if (ELIMINATE_COPY_RELOCS)
7606 /* For the non-shared case, discard space for relocs against
7607 symbols which turn out to need copy relocs or are not
7608 dynamic. */
7610 if (!h->non_got_ref
7611 && h->def_dynamic
7612 && !h->def_regular)
7614 /* Make sure this symbol is output as a dynamic symbol.
7615 Undefined weak syms won't yet be marked as dynamic. */
7616 if (h->dynindx == -1
7617 && !h->forced_local)
7619 if (! bfd_elf_link_record_dynamic_symbol (info, h))
7620 return FALSE;
7623 /* If that succeeded, we know we'll be keeping all the
7624 relocs. */
7625 if (h->dynindx != -1)
7626 goto keep;
7629 eh->dyn_relocs = NULL;
7631 keep: ;
7634 /* Finally, allocate space. */
7635 for (p = eh->dyn_relocs; p != NULL; p = p->next)
7637 asection *sreloc = elf_section_data (p->sec)->sreloc;
7638 sreloc->size += p->count * sizeof (Elf64_External_Rela);
7641 return TRUE;
7644 /* Find any dynamic relocs that apply to read-only sections. */
7646 static bfd_boolean
7647 readonly_dynrelocs (struct elf_link_hash_entry *h, void *inf)
7649 struct ppc_link_hash_entry *eh;
7650 struct ppc_dyn_relocs *p;
7652 if (h->root.type == bfd_link_hash_warning)
7653 h = (struct elf_link_hash_entry *) h->root.u.i.link;
7655 eh = (struct ppc_link_hash_entry *) h;
7656 for (p = eh->dyn_relocs; p != NULL; p = p->next)
7658 asection *s = p->sec->output_section;
7660 if (s != NULL && (s->flags & SEC_READONLY) != 0)
7662 struct bfd_link_info *info = inf;
7664 info->flags |= DF_TEXTREL;
7666 /* Not an error, just cut short the traversal. */
7667 return FALSE;
7670 return TRUE;
7673 /* Set the sizes of the dynamic sections. */
7675 static bfd_boolean
7676 ppc64_elf_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
7677 struct bfd_link_info *info)
7679 struct ppc_link_hash_table *htab;
7680 bfd *dynobj;
7681 asection *s;
7682 bfd_boolean relocs;
7683 bfd *ibfd;
7685 htab = ppc_hash_table (info);
7686 dynobj = htab->elf.dynobj;
7687 if (dynobj == NULL)
7688 abort ();
7690 if (htab->elf.dynamic_sections_created)
7692 /* Set the contents of the .interp section to the interpreter. */
7693 if (info->executable)
7695 s = bfd_get_section_by_name (dynobj, ".interp");
7696 if (s == NULL)
7697 abort ();
7698 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
7699 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
7703 /* Set up .got offsets for local syms, and space for local dynamic
7704 relocs. */
7705 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
7707 struct got_entry **lgot_ents;
7708 struct got_entry **end_lgot_ents;
7709 char *lgot_masks;
7710 bfd_size_type locsymcount;
7711 Elf_Internal_Shdr *symtab_hdr;
7712 asection *srel;
7714 if (!is_ppc64_elf_target (ibfd->xvec))
7715 continue;
7717 if (ppc64_tlsld_got (ibfd)->refcount > 0)
7719 s = ppc64_elf_tdata (ibfd)->got;
7720 ppc64_tlsld_got (ibfd)->offset = s->size;
7721 s->size += 16;
7722 if (info->shared)
7724 srel = ppc64_elf_tdata (ibfd)->relgot;
7725 srel->size += sizeof (Elf64_External_Rela);
7728 else
7729 ppc64_tlsld_got (ibfd)->offset = (bfd_vma) -1;
7731 for (s = ibfd->sections; s != NULL; s = s->next)
7733 struct ppc_dyn_relocs *p;
7735 for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
7737 if (!bfd_is_abs_section (p->sec)
7738 && bfd_is_abs_section (p->sec->output_section))
7740 /* Input section has been discarded, either because
7741 it is a copy of a linkonce section or due to
7742 linker script /DISCARD/, so we'll be discarding
7743 the relocs too. */
7745 else if (p->count != 0)
7747 srel = elf_section_data (p->sec)->sreloc;
7748 srel->size += p->count * sizeof (Elf64_External_Rela);
7749 if ((p->sec->output_section->flags & SEC_READONLY) != 0)
7750 info->flags |= DF_TEXTREL;
7755 lgot_ents = elf_local_got_ents (ibfd);
7756 if (!lgot_ents)
7757 continue;
7759 symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
7760 locsymcount = symtab_hdr->sh_info;
7761 end_lgot_ents = lgot_ents + locsymcount;
7762 lgot_masks = (char *) end_lgot_ents;
7763 s = ppc64_elf_tdata (ibfd)->got;
7764 srel = ppc64_elf_tdata (ibfd)->relgot;
7765 for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
7767 struct got_entry *ent;
7769 for (ent = *lgot_ents; ent != NULL; ent = ent->next)
7770 if (ent->got.refcount > 0)
7772 if ((ent->tls_type & *lgot_masks & TLS_LD) != 0)
7774 if (ppc64_tlsld_got (ibfd)->offset == (bfd_vma) -1)
7776 ppc64_tlsld_got (ibfd)->offset = s->size;
7777 s->size += 16;
7778 if (info->shared)
7779 srel->size += sizeof (Elf64_External_Rela);
7781 ent->got.offset = ppc64_tlsld_got (ibfd)->offset;
7783 else
7785 ent->got.offset = s->size;
7786 if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
7788 s->size += 16;
7789 if (info->shared)
7790 srel->size += 2 * sizeof (Elf64_External_Rela);
7792 else
7794 s->size += 8;
7795 if (info->shared)
7796 srel->size += sizeof (Elf64_External_Rela);
7800 else
7801 ent->got.offset = (bfd_vma) -1;
7805 /* Allocate global sym .plt and .got entries, and space for global
7806 sym dynamic relocs. */
7807 elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, info);
7809 /* We now have determined the sizes of the various dynamic sections.
7810 Allocate memory for them. */
7811 relocs = FALSE;
7812 for (s = dynobj->sections; s != NULL; s = s->next)
7814 if ((s->flags & SEC_LINKER_CREATED) == 0)
7815 continue;
7817 if (s == htab->brlt || s == htab->relbrlt)
7818 /* These haven't been allocated yet; don't strip. */
7819 continue;
7820 else if (s == htab->got
7821 || s == htab->plt
7822 || s == htab->glink
7823 || s == htab->dynbss)
7825 /* Strip this section if we don't need it; see the
7826 comment below. */
7828 else if (strncmp (bfd_get_section_name (dynobj, s), ".rela", 5) == 0)
7830 if (s->size != 0)
7832 if (s != htab->relplt)
7833 relocs = TRUE;
7835 /* We use the reloc_count field as a counter if we need
7836 to copy relocs into the output file. */
7837 s->reloc_count = 0;
7840 else
7842 /* It's not one of our sections, so don't allocate space. */
7843 continue;
7846 if (s->size == 0)
7848 /* If we don't need this section, strip it from the
7849 output file. This is mostly to handle .rela.bss and
7850 .rela.plt. We must create both sections in
7851 create_dynamic_sections, because they must be created
7852 before the linker maps input sections to output
7853 sections. The linker does that before
7854 adjust_dynamic_symbol is called, and it is that
7855 function which decides whether anything needs to go
7856 into these sections. */
7857 s->flags |= SEC_EXCLUDE;
7858 continue;
7861 if ((s->flags & SEC_HAS_CONTENTS) == 0)
7862 continue;
7864 /* Allocate memory for the section contents. We use bfd_zalloc
7865 here in case unused entries are not reclaimed before the
7866 section's contents are written out. This should not happen,
7867 but this way if it does we get a R_PPC64_NONE reloc in .rela
7868 sections instead of garbage.
7869 We also rely on the section contents being zero when writing
7870 the GOT. */
7871 s->contents = bfd_zalloc (dynobj, s->size);
7872 if (s->contents == NULL)
7873 return FALSE;
7876 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
7878 if (!is_ppc64_elf_target (ibfd->xvec))
7879 continue;
7881 s = ppc64_elf_tdata (ibfd)->got;
7882 if (s != NULL && s != htab->got)
7884 if (s->size == 0)
7885 s->flags |= SEC_EXCLUDE;
7886 else
7888 s->contents = bfd_zalloc (ibfd, s->size);
7889 if (s->contents == NULL)
7890 return FALSE;
7893 s = ppc64_elf_tdata (ibfd)->relgot;
7894 if (s != NULL)
7896 if (s->size == 0)
7897 s->flags |= SEC_EXCLUDE;
7898 else
7900 s->contents = bfd_zalloc (ibfd, s->size);
7901 if (s->contents == NULL)
7902 return FALSE;
7903 relocs = TRUE;
7904 s->reloc_count = 0;
7909 if (htab->elf.dynamic_sections_created)
7911 /* Add some entries to the .dynamic section. We fill in the
7912 values later, in ppc64_elf_finish_dynamic_sections, but we
7913 must add the entries now so that we get the correct size for
7914 the .dynamic section. The DT_DEBUG entry is filled in by the
7915 dynamic linker and used by the debugger. */
7916 #define add_dynamic_entry(TAG, VAL) \
7917 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
7919 if (info->executable)
7921 if (!add_dynamic_entry (DT_DEBUG, 0))
7922 return FALSE;
7925 if (htab->plt != NULL && htab->plt->size != 0)
7927 if (!add_dynamic_entry (DT_PLTGOT, 0)
7928 || !add_dynamic_entry (DT_PLTRELSZ, 0)
7929 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
7930 || !add_dynamic_entry (DT_JMPREL, 0)
7931 || !add_dynamic_entry (DT_PPC64_GLINK, 0))
7932 return FALSE;
7935 if (NO_OPD_RELOCS)
7937 if (!add_dynamic_entry (DT_PPC64_OPD, 0)
7938 || !add_dynamic_entry (DT_PPC64_OPDSZ, 0))
7939 return FALSE;
7942 if (relocs)
7944 if (!add_dynamic_entry (DT_RELA, 0)
7945 || !add_dynamic_entry (DT_RELASZ, 0)
7946 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
7947 return FALSE;
7949 /* If any dynamic relocs apply to a read-only section,
7950 then we need a DT_TEXTREL entry. */
7951 if ((info->flags & DF_TEXTREL) == 0)
7952 elf_link_hash_traverse (&htab->elf, readonly_dynrelocs, info);
7954 if ((info->flags & DF_TEXTREL) != 0)
7956 if (!add_dynamic_entry (DT_TEXTREL, 0))
7957 return FALSE;
7961 #undef add_dynamic_entry
7963 return TRUE;
7966 /* Determine the type of stub needed, if any, for a call. */
7968 static inline enum ppc_stub_type
7969 ppc_type_of_stub (asection *input_sec,
7970 const Elf_Internal_Rela *rel,
7971 struct ppc_link_hash_entry **hash,
7972 bfd_vma destination)
7974 struct ppc_link_hash_entry *h = *hash;
7975 bfd_vma location;
7976 bfd_vma branch_offset;
7977 bfd_vma max_branch_offset;
7978 enum elf_ppc64_reloc_type r_type;
7980 if (h != NULL)
7982 struct ppc_link_hash_entry *fdh = h;
7983 if (fdh->oh != NULL
7984 && fdh->oh->is_func_descriptor)
7985 fdh = fdh->oh;
7987 if (fdh->elf.dynindx != -1)
7989 struct plt_entry *ent;
7991 for (ent = fdh->elf.plt.plist; ent != NULL; ent = ent->next)
7992 if (ent->addend == rel->r_addend
7993 && ent->plt.offset != (bfd_vma) -1)
7995 *hash = fdh;
7996 return ppc_stub_plt_call;
8000 /* Here, we know we don't have a plt entry. If we don't have a
8001 either a defined function descriptor or a defined entry symbol
8002 in a regular object file, then it is pointless trying to make
8003 any other type of stub. */
8004 if (!((fdh->elf.root.type == bfd_link_hash_defined
8005 || fdh->elf.root.type == bfd_link_hash_defweak)
8006 && fdh->elf.root.u.def.section->output_section != NULL)
8007 && !((h->elf.root.type == bfd_link_hash_defined
8008 || h->elf.root.type == bfd_link_hash_defweak)
8009 && h->elf.root.u.def.section->output_section != NULL))
8010 return ppc_stub_none;
8013 /* Determine where the call point is. */
8014 location = (input_sec->output_offset
8015 + input_sec->output_section->vma
8016 + rel->r_offset);
8018 branch_offset = destination - location;
8019 r_type = ELF64_R_TYPE (rel->r_info);
8021 /* Determine if a long branch stub is needed. */
8022 max_branch_offset = 1 << 25;
8023 if (r_type != R_PPC64_REL24)
8024 max_branch_offset = 1 << 15;
8026 if (branch_offset + max_branch_offset >= 2 * max_branch_offset)
8027 /* We need a stub. Figure out whether a long_branch or plt_branch
8028 is needed later. */
8029 return ppc_stub_long_branch;
8031 return ppc_stub_none;
8034 /* Build a .plt call stub. */
8036 static inline bfd_byte *
8037 build_plt_stub (bfd *obfd, bfd_byte *p, int offset)
8039 #define PPC_LO(v) ((v) & 0xffff)
8040 #define PPC_HI(v) (((v) >> 16) & 0xffff)
8041 #define PPC_HA(v) PPC_HI ((v) + 0x8000)
8043 bfd_put_32 (obfd, ADDIS_R12_R2 | PPC_HA (offset), p), p += 4;
8044 bfd_put_32 (obfd, STD_R2_40R1, p), p += 4;
8045 bfd_put_32 (obfd, LD_R11_0R12 | PPC_LO (offset), p), p += 4;
8046 if (PPC_HA (offset + 8) != PPC_HA (offset))
8047 bfd_put_32 (obfd, ADDIS_R12_R12 | 1, p), p += 4;
8048 offset += 8;
8049 bfd_put_32 (obfd, LD_R2_0R12 | PPC_LO (offset), p), p += 4;
8050 if (PPC_HA (offset + 8) != PPC_HA (offset))
8051 bfd_put_32 (obfd, ADDIS_R12_R12 | 1, p), p += 4;
8052 offset += 8;
8053 bfd_put_32 (obfd, MTCTR_R11, p), p += 4;
8054 bfd_put_32 (obfd, LD_R11_0R12 | PPC_LO (offset), p), p += 4;
8055 bfd_put_32 (obfd, BCTR, p), p += 4;
8056 return p;
8059 static bfd_boolean
8060 ppc_build_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
8062 struct ppc_stub_hash_entry *stub_entry;
8063 struct ppc_branch_hash_entry *br_entry;
8064 struct bfd_link_info *info;
8065 struct ppc_link_hash_table *htab;
8066 bfd_byte *loc;
8067 bfd_byte *p;
8068 unsigned int indx;
8069 struct plt_entry *ent;
8070 bfd_vma dest, off;
8071 int size;
8073 /* Massage our args to the form they really have. */
8074 stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
8075 info = in_arg;
8077 htab = ppc_hash_table (info);
8079 /* Make a note of the offset within the stubs for this entry. */
8080 stub_entry->stub_offset = stub_entry->stub_sec->size;
8081 loc = stub_entry->stub_sec->contents + stub_entry->stub_offset;
8083 htab->stub_count[stub_entry->stub_type - 1] += 1;
8084 switch (stub_entry->stub_type)
8086 case ppc_stub_long_branch:
8087 case ppc_stub_long_branch_r2off:
8088 /* Branches are relative. This is where we are going to. */
8089 off = dest = (stub_entry->target_value
8090 + stub_entry->target_section->output_offset
8091 + stub_entry->target_section->output_section->vma);
8093 /* And this is where we are coming from. */
8094 off -= (stub_entry->stub_offset
8095 + stub_entry->stub_sec->output_offset
8096 + stub_entry->stub_sec->output_section->vma);
8098 if (stub_entry->stub_type != ppc_stub_long_branch_r2off)
8099 size = 4;
8100 else
8102 bfd_vma r2off;
8104 r2off = (htab->stub_group[stub_entry->target_section->id].toc_off
8105 - htab->stub_group[stub_entry->id_sec->id].toc_off);
8106 bfd_put_32 (htab->stub_bfd, STD_R2_40R1, loc);
8107 loc += 4;
8108 bfd_put_32 (htab->stub_bfd, ADDIS_R2_R2 | PPC_HA (r2off), loc);
8109 loc += 4;
8110 bfd_put_32 (htab->stub_bfd, ADDI_R2_R2 | PPC_LO (r2off), loc);
8111 loc += 4;
8112 off -= 12;
8113 size = 16;
8115 bfd_put_32 (htab->stub_bfd, B_DOT | (off & 0x3fffffc), loc);
8117 if (off + (1 << 25) >= (bfd_vma) (1 << 26))
8119 (*_bfd_error_handler) (_("long branch stub `%s' offset overflow"),
8120 stub_entry->root.string);
8121 htab->stub_error = TRUE;
8122 return FALSE;
8125 if (info->emitrelocations)
8127 Elf_Internal_Rela *relocs, *r;
8128 struct bfd_elf_section_data *elfsec_data;
8130 elfsec_data = elf_section_data (stub_entry->stub_sec);
8131 relocs = elfsec_data->relocs;
8132 if (relocs == NULL)
8134 bfd_size_type relsize;
8135 relsize = stub_entry->stub_sec->reloc_count * sizeof (*relocs);
8136 relocs = bfd_alloc (htab->stub_bfd, relsize);
8137 if (relocs == NULL)
8138 return FALSE;
8139 elfsec_data->relocs = relocs;
8140 elfsec_data->rel_hdr.sh_size = relsize;
8141 elfsec_data->rel_hdr.sh_entsize = 24;
8142 stub_entry->stub_sec->reloc_count = 0;
8144 r = relocs + stub_entry->stub_sec->reloc_count;
8145 stub_entry->stub_sec->reloc_count += 1;
8146 r->r_offset = loc - stub_entry->stub_sec->contents;
8147 r->r_info = ELF64_R_INFO (0, R_PPC64_REL24);
8148 r->r_addend = dest;
8149 if (stub_entry->h != NULL)
8151 struct elf_link_hash_entry **hashes;
8152 unsigned long symndx;
8153 struct ppc_link_hash_entry *h;
8155 hashes = elf_sym_hashes (htab->stub_bfd);
8156 if (hashes == NULL)
8158 bfd_size_type hsize;
8160 hsize = (htab->stub_globals + 1) * sizeof (*hashes);
8161 hashes = bfd_zalloc (htab->stub_bfd, hsize);
8162 if (hashes == NULL)
8163 return FALSE;
8164 elf_sym_hashes (htab->stub_bfd) = hashes;
8165 htab->stub_globals = 1;
8167 symndx = htab->stub_globals++;
8168 h = stub_entry->h;
8169 hashes[symndx] = &h->elf;
8170 r->r_info = ELF64_R_INFO (symndx, R_PPC64_REL24);
8171 if (h->oh != NULL && h->oh->is_func)
8172 h = h->oh;
8173 if (h->elf.root.u.def.section != stub_entry->target_section)
8174 /* H is an opd symbol. The addend must be zero. */
8175 r->r_addend = 0;
8176 else
8178 off = (h->elf.root.u.def.value
8179 + h->elf.root.u.def.section->output_offset
8180 + h->elf.root.u.def.section->output_section->vma);
8181 r->r_addend -= off;
8185 break;
8187 case ppc_stub_plt_branch:
8188 case ppc_stub_plt_branch_r2off:
8189 br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
8190 stub_entry->root.string + 9,
8191 FALSE, FALSE);
8192 if (br_entry == NULL)
8194 (*_bfd_error_handler) (_("can't find branch stub `%s'"),
8195 stub_entry->root.string);
8196 htab->stub_error = TRUE;
8197 return FALSE;
8200 off = (stub_entry->target_value
8201 + stub_entry->target_section->output_offset
8202 + stub_entry->target_section->output_section->vma);
8204 bfd_put_64 (htab->brlt->owner, off,
8205 htab->brlt->contents + br_entry->offset);
8207 if (htab->relbrlt != NULL)
8209 /* Create a reloc for the branch lookup table entry. */
8210 Elf_Internal_Rela rela;
8211 bfd_byte *rl;
8213 rela.r_offset = (br_entry->offset
8214 + htab->brlt->output_offset
8215 + htab->brlt->output_section->vma);
8216 rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
8217 rela.r_addend = off;
8219 rl = htab->relbrlt->contents;
8220 rl += htab->relbrlt->reloc_count++ * sizeof (Elf64_External_Rela);
8221 bfd_elf64_swap_reloca_out (htab->relbrlt->owner, &rela, rl);
8224 off = (br_entry->offset
8225 + htab->brlt->output_offset
8226 + htab->brlt->output_section->vma
8227 - elf_gp (htab->brlt->output_section->owner)
8228 - htab->stub_group[stub_entry->id_sec->id].toc_off);
8230 if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
8232 (*_bfd_error_handler)
8233 (_("linkage table error against `%s'"),
8234 stub_entry->root.string);
8235 bfd_set_error (bfd_error_bad_value);
8236 htab->stub_error = TRUE;
8237 return FALSE;
8240 indx = off;
8241 if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
8243 bfd_put_32 (htab->stub_bfd, ADDIS_R12_R2 | PPC_HA (indx), loc);
8244 loc += 4;
8245 bfd_put_32 (htab->stub_bfd, LD_R11_0R12 | PPC_LO (indx), loc);
8246 size = 16;
8248 else
8250 bfd_vma r2off;
8252 r2off = (htab->stub_group[stub_entry->target_section->id].toc_off
8253 - htab->stub_group[stub_entry->id_sec->id].toc_off);
8254 bfd_put_32 (htab->stub_bfd, STD_R2_40R1, loc);
8255 loc += 4;
8256 bfd_put_32 (htab->stub_bfd, ADDIS_R12_R2 | PPC_HA (indx), loc);
8257 loc += 4;
8258 bfd_put_32 (htab->stub_bfd, LD_R11_0R12 | PPC_LO (indx), loc);
8259 loc += 4;
8260 bfd_put_32 (htab->stub_bfd, ADDIS_R2_R2 | PPC_HA (r2off), loc);
8261 loc += 4;
8262 bfd_put_32 (htab->stub_bfd, ADDI_R2_R2 | PPC_LO (r2off), loc);
8263 size = 28;
8265 loc += 4;
8266 bfd_put_32 (htab->stub_bfd, MTCTR_R11, loc);
8267 loc += 4;
8268 bfd_put_32 (htab->stub_bfd, BCTR, loc);
8269 break;
8271 case ppc_stub_plt_call:
8272 /* Do the best we can for shared libraries built without
8273 exporting ".foo" for each "foo". This can happen when symbol
8274 versioning scripts strip all bar a subset of symbols. */
8275 if (stub_entry->h->oh != NULL
8276 && stub_entry->h->oh->elf.root.type != bfd_link_hash_defined
8277 && stub_entry->h->oh->elf.root.type != bfd_link_hash_defweak)
8279 /* Point the symbol at the stub. There may be multiple stubs,
8280 we don't really care; The main thing is to make this sym
8281 defined somewhere. Maybe defining the symbol in the stub
8282 section is a silly idea. If we didn't do this, htab->top_id
8283 could disappear. */
8284 stub_entry->h->oh->elf.root.type = bfd_link_hash_defined;
8285 stub_entry->h->oh->elf.root.u.def.section = stub_entry->stub_sec;
8286 stub_entry->h->oh->elf.root.u.def.value = stub_entry->stub_offset;
8289 /* Now build the stub. */
8290 off = (bfd_vma) -1;
8291 for (ent = stub_entry->h->elf.plt.plist; ent != NULL; ent = ent->next)
8292 if (ent->addend == stub_entry->addend)
8294 off = ent->plt.offset;
8295 break;
8297 if (off >= (bfd_vma) -2)
8298 abort ();
8300 off &= ~ (bfd_vma) 1;
8301 off += (htab->plt->output_offset
8302 + htab->plt->output_section->vma
8303 - elf_gp (htab->plt->output_section->owner)
8304 - htab->stub_group[stub_entry->id_sec->id].toc_off);
8306 if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
8308 (*_bfd_error_handler)
8309 (_("linkage table error against `%s'"),
8310 stub_entry->h->elf.root.root.string);
8311 bfd_set_error (bfd_error_bad_value);
8312 htab->stub_error = TRUE;
8313 return FALSE;
8316 p = build_plt_stub (htab->stub_bfd, loc, off);
8317 size = p - loc;
8318 break;
8320 default:
8321 BFD_FAIL ();
8322 return FALSE;
8325 stub_entry->stub_sec->size += size;
8327 if (htab->emit_stub_syms)
8329 struct elf_link_hash_entry *h;
8330 size_t len1, len2;
8331 char *name;
8332 const char *const stub_str[] = { "long_branch",
8333 "long_branch_r2off",
8334 "plt_branch",
8335 "plt_branch_r2off",
8336 "plt_call" };
8338 len1 = strlen (stub_str[stub_entry->stub_type - 1]);
8339 len2 = strlen (stub_entry->root.string);
8340 name = bfd_malloc (len1 + len2 + 2);
8341 if (name == NULL)
8342 return FALSE;
8343 memcpy (name, stub_entry->root.string, 9);
8344 memcpy (name + 9, stub_str[stub_entry->stub_type - 1], len1);
8345 memcpy (name + len1 + 9, stub_entry->root.string + 8, len2 - 8 + 1);
8346 h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
8347 if (h == NULL)
8348 return FALSE;
8349 if (h->root.type == bfd_link_hash_new)
8351 h->root.type = bfd_link_hash_defined;
8352 h->root.u.def.section = stub_entry->stub_sec;
8353 h->root.u.def.value = stub_entry->stub_offset;
8354 h->ref_regular = 1;
8355 h->def_regular = 1;
8356 h->ref_regular_nonweak = 1;
8357 h->forced_local = 1;
8358 h->non_elf = 0;
8362 return TRUE;
8365 /* As above, but don't actually build the stub. Just bump offset so
8366 we know stub section sizes, and select plt_branch stubs where
8367 long_branch stubs won't do. */
8369 static bfd_boolean
8370 ppc_size_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
8372 struct ppc_stub_hash_entry *stub_entry;
8373 struct bfd_link_info *info;
8374 struct ppc_link_hash_table *htab;
8375 bfd_vma off;
8376 int size;
8378 /* Massage our args to the form they really have. */
8379 stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
8380 info = in_arg;
8382 htab = ppc_hash_table (info);
8384 if (stub_entry->stub_type == ppc_stub_plt_call)
8386 struct plt_entry *ent;
8387 off = (bfd_vma) -1;
8388 for (ent = stub_entry->h->elf.plt.plist; ent != NULL; ent = ent->next)
8389 if (ent->addend == stub_entry->addend)
8391 off = ent->plt.offset & ~(bfd_vma) 1;
8392 break;
8394 if (off >= (bfd_vma) -2)
8395 abort ();
8396 off += (htab->plt->output_offset
8397 + htab->plt->output_section->vma
8398 - elf_gp (htab->plt->output_section->owner)
8399 - htab->stub_group[stub_entry->id_sec->id].toc_off);
8401 size = PLT_CALL_STUB_SIZE;
8402 if (PPC_HA (off + 16) != PPC_HA (off))
8403 size += 4;
8405 else
8407 /* ppc_stub_long_branch or ppc_stub_plt_branch, or their r2off
8408 variants. */
8409 off = (stub_entry->target_value
8410 + stub_entry->target_section->output_offset
8411 + stub_entry->target_section->output_section->vma);
8412 off -= (stub_entry->stub_sec->size
8413 + stub_entry->stub_sec->output_offset
8414 + stub_entry->stub_sec->output_section->vma);
8416 /* Reset the stub type from the plt variant in case we now
8417 can reach with a shorter stub. */
8418 if (stub_entry->stub_type >= ppc_stub_plt_branch)
8419 stub_entry->stub_type += ppc_stub_long_branch - ppc_stub_plt_branch;
8421 size = 4;
8422 if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
8424 off -= 12;
8425 size = 16;
8428 /* If the branch offset if too big, use a ppc_stub_plt_branch. */
8429 if (off + (1 << 25) >= (bfd_vma) (1 << 26))
8431 struct ppc_branch_hash_entry *br_entry;
8433 br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
8434 stub_entry->root.string + 9,
8435 TRUE, FALSE);
8436 if (br_entry == NULL)
8438 (*_bfd_error_handler) (_("can't build branch stub `%s'"),
8439 stub_entry->root.string);
8440 htab->stub_error = TRUE;
8441 return FALSE;
8444 if (br_entry->iter != htab->stub_iteration)
8446 br_entry->iter = htab->stub_iteration;
8447 br_entry->offset = htab->brlt->size;
8448 htab->brlt->size += 8;
8450 if (htab->relbrlt != NULL)
8451 htab->relbrlt->size += sizeof (Elf64_External_Rela);
8454 stub_entry->stub_type += ppc_stub_plt_branch - ppc_stub_long_branch;
8455 size = 16;
8456 if (stub_entry->stub_type != ppc_stub_plt_branch)
8457 size = 28;
8460 if (info->emitrelocations
8461 && (stub_entry->stub_type == ppc_stub_long_branch
8462 || stub_entry->stub_type == ppc_stub_long_branch_r2off))
8463 stub_entry->stub_sec->reloc_count += 1;
8466 stub_entry->stub_sec->size += size;
8467 return TRUE;
8470 /* Set up various things so that we can make a list of input sections
8471 for each output section included in the link. Returns -1 on error,
8472 0 when no stubs will be needed, and 1 on success. */
8475 ppc64_elf_setup_section_lists (bfd *output_bfd,
8476 struct bfd_link_info *info,
8477 int no_multi_toc)
8479 bfd *input_bfd;
8480 int top_id, top_index, id;
8481 asection *section;
8482 asection **input_list;
8483 bfd_size_type amt;
8484 struct ppc_link_hash_table *htab = ppc_hash_table (info);
8486 htab->no_multi_toc = no_multi_toc;
8488 if (htab->brlt == NULL)
8489 return 0;
8491 /* Find the top input section id. */
8492 for (input_bfd = info->input_bfds, top_id = 3;
8493 input_bfd != NULL;
8494 input_bfd = input_bfd->link_next)
8496 for (section = input_bfd->sections;
8497 section != NULL;
8498 section = section->next)
8500 if (top_id < section->id)
8501 top_id = section->id;
8505 htab->top_id = top_id;
8506 amt = sizeof (struct map_stub) * (top_id + 1);
8507 htab->stub_group = bfd_zmalloc (amt);
8508 if (htab->stub_group == NULL)
8509 return -1;
8511 /* Set toc_off for com, und, abs and ind sections. */
8512 for (id = 0; id < 3; id++)
8513 htab->stub_group[id].toc_off = TOC_BASE_OFF;
8515 elf_gp (output_bfd) = htab->toc_curr = ppc64_elf_toc (output_bfd);
8517 /* We can't use output_bfd->section_count here to find the top output
8518 section index as some sections may have been removed, and
8519 strip_excluded_output_sections doesn't renumber the indices. */
8520 for (section = output_bfd->sections, top_index = 0;
8521 section != NULL;
8522 section = section->next)
8524 if (top_index < section->index)
8525 top_index = section->index;
8528 htab->top_index = top_index;
8529 amt = sizeof (asection *) * (top_index + 1);
8530 input_list = bfd_zmalloc (amt);
8531 htab->input_list = input_list;
8532 if (input_list == NULL)
8533 return -1;
8535 return 1;
8538 /* The linker repeatedly calls this function for each TOC input section
8539 and linker generated GOT section. Group input bfds such that the toc
8540 within a group is less than 64k in size. Will break with cute linker
8541 scripts that play games with dot in the output toc section. */
8543 void
8544 ppc64_elf_next_toc_section (struct bfd_link_info *info, asection *isec)
8546 struct ppc_link_hash_table *htab = ppc_hash_table (info);
8548 if (!htab->no_multi_toc)
8550 bfd_vma addr = isec->output_offset + isec->output_section->vma;
8551 bfd_vma off = addr - htab->toc_curr;
8553 if (off + isec->size > 0x10000)
8554 htab->toc_curr = addr;
8556 elf_gp (isec->owner) = (htab->toc_curr
8557 - elf_gp (isec->output_section->owner)
8558 + TOC_BASE_OFF);
8562 /* Called after the last call to the above function. */
8564 void
8565 ppc64_elf_reinit_toc (bfd *output_bfd, struct bfd_link_info *info)
8567 struct ppc_link_hash_table *htab = ppc_hash_table (info);
8569 htab->multi_toc_needed = htab->toc_curr != elf_gp (output_bfd);
8571 /* toc_curr tracks the TOC offset used for code sections below in
8572 ppc64_elf_next_input_section. Start off at 0x8000. */
8573 htab->toc_curr = TOC_BASE_OFF;
8576 /* No toc references were found in ISEC. If the code in ISEC makes no
8577 calls, then there's no need to use toc adjusting stubs when branching
8578 into ISEC. Actually, indirect calls from ISEC are OK as they will
8579 load r2. Returns -1 on error, 0 for no stub needed, 1 for stub
8580 needed, and 2 if a cyclical call-graph was found but no other reason
8581 for a stub was detected. If called from the top level, a return of
8582 2 means the same as a return of 0. */
8584 static int
8585 toc_adjusting_stub_needed (struct bfd_link_info *info, asection *isec)
8587 Elf_Internal_Rela *relstart, *rel;
8588 Elf_Internal_Sym *local_syms;
8589 int ret;
8590 struct ppc_link_hash_table *htab;
8592 /* We know none of our code bearing sections will need toc stubs. */
8593 if ((isec->flags & SEC_LINKER_CREATED) != 0)
8594 return 0;
8596 if (isec->size == 0)
8597 return 0;
8599 if (isec->output_section == NULL)
8600 return 0;
8602 /* Hack for linux kernel. .fixup contains branches, but only back to
8603 the function that hit an exception. */
8604 if (strcmp (isec->name, ".fixup") == 0)
8605 return 0;
8607 if (isec->reloc_count == 0)
8608 return 0;
8610 relstart = _bfd_elf_link_read_relocs (isec->owner, isec, NULL, NULL,
8611 info->keep_memory);
8612 if (relstart == NULL)
8613 return -1;
8615 /* Look for branches to outside of this section. */
8616 local_syms = NULL;
8617 ret = 0;
8618 htab = ppc_hash_table (info);
8619 for (rel = relstart; rel < relstart + isec->reloc_count; ++rel)
8621 enum elf_ppc64_reloc_type r_type;
8622 unsigned long r_symndx;
8623 struct elf_link_hash_entry *h;
8624 Elf_Internal_Sym *sym;
8625 asection *sym_sec;
8626 long *opd_adjust;
8627 bfd_vma sym_value;
8628 bfd_vma dest;
8630 r_type = ELF64_R_TYPE (rel->r_info);
8631 if (r_type != R_PPC64_REL24
8632 && r_type != R_PPC64_REL14
8633 && r_type != R_PPC64_REL14_BRTAKEN
8634 && r_type != R_PPC64_REL14_BRNTAKEN)
8635 continue;
8637 r_symndx = ELF64_R_SYM (rel->r_info);
8638 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms, r_symndx,
8639 isec->owner))
8641 ret = -1;
8642 break;
8645 /* Calls to dynamic lib functions go through a plt call stub
8646 that uses r2. Branches to undefined symbols might be a call
8647 using old-style dot symbols that can be satisfied by a plt
8648 call into a new-style dynamic library. */
8649 if (sym_sec == NULL)
8651 struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
8652 if (eh != NULL
8653 && eh->oh != NULL
8654 && eh->oh->elf.plt.plist != NULL)
8656 ret = 1;
8657 break;
8660 /* Ignore other undefined symbols. */
8661 continue;
8664 /* Assume branches to other sections not included in the link need
8665 stubs too, to cover -R and absolute syms. */
8666 if (sym_sec->output_section == NULL)
8668 ret = 1;
8669 break;
8672 if (h == NULL)
8673 sym_value = sym->st_value;
8674 else
8676 if (h->root.type != bfd_link_hash_defined
8677 && h->root.type != bfd_link_hash_defweak)
8678 abort ();
8679 sym_value = h->root.u.def.value;
8681 sym_value += rel->r_addend;
8683 /* If this branch reloc uses an opd sym, find the code section. */
8684 opd_adjust = get_opd_info (sym_sec);
8685 if (opd_adjust != NULL)
8687 if (h == NULL)
8689 long adjust;
8691 adjust = opd_adjust[sym->st_value / 8];
8692 if (adjust == -1)
8693 /* Assume deleted functions won't ever be called. */
8694 continue;
8695 sym_value += adjust;
8698 dest = opd_entry_value (sym_sec, sym_value, &sym_sec, NULL);
8699 if (dest == (bfd_vma) -1)
8700 continue;
8702 else
8703 dest = (sym_value
8704 + sym_sec->output_offset
8705 + sym_sec->output_section->vma);
8707 /* Ignore branch to self. */
8708 if (sym_sec == isec)
8709 continue;
8711 /* If the called function uses the toc, we need a stub. */
8712 if (sym_sec->has_toc_reloc
8713 || sym_sec->makes_toc_func_call)
8715 ret = 1;
8716 break;
8719 /* Assume any branch that needs a long branch stub might in fact
8720 need a plt_branch stub. A plt_branch stub uses r2. */
8721 else if (dest - (isec->output_offset
8722 + isec->output_section->vma
8723 + rel->r_offset) + (1 << 25) >= (2 << 25))
8725 ret = 1;
8726 break;
8729 /* If calling back to a section in the process of being tested, we
8730 can't say for sure that no toc adjusting stubs are needed, so
8731 don't return zero. */
8732 else if (sym_sec->call_check_in_progress)
8733 ret = 2;
8735 /* Branches to another section that itself doesn't have any TOC
8736 references are OK. Recursively call ourselves to check. */
8737 else if (sym_sec->id <= htab->top_id
8738 && htab->stub_group[sym_sec->id].toc_off == 0)
8740 int recur;
8742 /* Mark current section as indeterminate, so that other
8743 sections that call back to current won't be marked as
8744 known. */
8745 isec->call_check_in_progress = 1;
8746 recur = toc_adjusting_stub_needed (info, sym_sec);
8747 isec->call_check_in_progress = 0;
8749 if (recur < 0)
8751 /* An error. Exit. */
8752 ret = -1;
8753 break;
8755 else if (recur <= 1)
8757 /* Known result. Mark as checked and set section flag. */
8758 htab->stub_group[sym_sec->id].toc_off = 1;
8759 if (recur != 0)
8761 sym_sec->makes_toc_func_call = 1;
8762 ret = 1;
8763 break;
8766 else
8768 /* Unknown result. Continue checking. */
8769 ret = 2;
8774 if (local_syms != NULL
8775 && (elf_tdata (isec->owner)->symtab_hdr.contents
8776 != (unsigned char *) local_syms))
8777 free (local_syms);
8778 if (elf_section_data (isec)->relocs != relstart)
8779 free (relstart);
8781 return ret;
8784 /* The linker repeatedly calls this function for each input section,
8785 in the order that input sections are linked into output sections.
8786 Build lists of input sections to determine groupings between which
8787 we may insert linker stubs. */
8789 bfd_boolean
8790 ppc64_elf_next_input_section (struct bfd_link_info *info, asection *isec)
8792 struct ppc_link_hash_table *htab = ppc_hash_table (info);
8794 if ((isec->output_section->flags & SEC_CODE) != 0
8795 && isec->output_section->index <= htab->top_index)
8797 asection **list = htab->input_list + isec->output_section->index;
8798 /* Steal the link_sec pointer for our list. */
8799 #define PREV_SEC(sec) (htab->stub_group[(sec)->id].link_sec)
8800 /* This happens to make the list in reverse order,
8801 which is what we want. */
8802 PREV_SEC (isec) = *list;
8803 *list = isec;
8806 if (htab->multi_toc_needed)
8808 /* If a code section has a function that uses the TOC then we need
8809 to use the right TOC (obviously). Also, make sure that .opd gets
8810 the correct TOC value for R_PPC64_TOC relocs that don't have or
8811 can't find their function symbol (shouldn't ever happen now). */
8812 if (isec->has_toc_reloc || (isec->flags & SEC_CODE) == 0)
8814 if (elf_gp (isec->owner) != 0)
8815 htab->toc_curr = elf_gp (isec->owner);
8817 else if (htab->stub_group[isec->id].toc_off == 0)
8819 int ret = toc_adjusting_stub_needed (info, isec);
8820 if (ret < 0)
8821 return FALSE;
8822 else
8823 isec->makes_toc_func_call = ret & 1;
8827 /* Functions that don't use the TOC can belong in any TOC group.
8828 Use the last TOC base. This happens to make _init and _fini
8829 pasting work. */
8830 htab->stub_group[isec->id].toc_off = htab->toc_curr;
8831 return TRUE;
8834 /* See whether we can group stub sections together. Grouping stub
8835 sections may result in fewer stubs. More importantly, we need to
8836 put all .init* and .fini* stubs at the beginning of the .init or
8837 .fini output sections respectively, because glibc splits the
8838 _init and _fini functions into multiple parts. Putting a stub in
8839 the middle of a function is not a good idea. */
8841 static void
8842 group_sections (struct ppc_link_hash_table *htab,
8843 bfd_size_type stub_group_size,
8844 bfd_boolean stubs_always_before_branch)
8846 asection **list = htab->input_list + htab->top_index;
8849 asection *tail = *list;
8850 while (tail != NULL)
8852 asection *curr;
8853 asection *prev;
8854 bfd_size_type total;
8855 bfd_boolean big_sec;
8856 bfd_vma curr_toc;
8858 curr = tail;
8859 total = tail->size;
8860 big_sec = total > stub_group_size;
8861 if (big_sec)
8862 (*_bfd_error_handler) (_("%B section %A exceeds stub group size"),
8863 tail->owner, tail);
8864 curr_toc = htab->stub_group[tail->id].toc_off;
8866 while ((prev = PREV_SEC (curr)) != NULL
8867 && ((total += curr->output_offset - prev->output_offset)
8868 < stub_group_size)
8869 && htab->stub_group[prev->id].toc_off == curr_toc)
8870 curr = prev;
8872 /* OK, the size from the start of CURR to the end is less
8873 than stub_group_size and thus can be handled by one stub
8874 section. (or the tail section is itself larger than
8875 stub_group_size, in which case we may be toast.) We
8876 should really be keeping track of the total size of stubs
8877 added here, as stubs contribute to the final output
8878 section size. That's a little tricky, and this way will
8879 only break if stubs added make the total size more than
8880 2^25, ie. for the default stub_group_size, if stubs total
8881 more than 2097152 bytes, or nearly 75000 plt call stubs. */
8884 prev = PREV_SEC (tail);
8885 /* Set up this stub group. */
8886 htab->stub_group[tail->id].link_sec = curr;
8888 while (tail != curr && (tail = prev) != NULL);
8890 /* But wait, there's more! Input sections up to stub_group_size
8891 bytes before the stub section can be handled by it too.
8892 Don't do this if we have a really large section after the
8893 stubs, as adding more stubs increases the chance that
8894 branches may not reach into the stub section. */
8895 if (!stubs_always_before_branch && !big_sec)
8897 total = 0;
8898 while (prev != NULL
8899 && ((total += tail->output_offset - prev->output_offset)
8900 < stub_group_size)
8901 && htab->stub_group[prev->id].toc_off == curr_toc)
8903 tail = prev;
8904 prev = PREV_SEC (tail);
8905 htab->stub_group[tail->id].link_sec = curr;
8908 tail = prev;
8911 while (list-- != htab->input_list);
8912 free (htab->input_list);
8913 #undef PREV_SEC
8916 /* Determine and set the size of the stub section for a final link.
8918 The basic idea here is to examine all the relocations looking for
8919 PC-relative calls to a target that is unreachable with a "bl"
8920 instruction. */
8922 bfd_boolean
8923 ppc64_elf_size_stubs (bfd *output_bfd,
8924 struct bfd_link_info *info,
8925 bfd_signed_vma group_size,
8926 asection *(*add_stub_section) (const char *, asection *),
8927 void (*layout_sections_again) (void))
8929 bfd_size_type stub_group_size;
8930 bfd_boolean stubs_always_before_branch;
8931 struct ppc_link_hash_table *htab = ppc_hash_table (info);
8933 /* Stash our params away. */
8934 htab->add_stub_section = add_stub_section;
8935 htab->layout_sections_again = layout_sections_again;
8936 stubs_always_before_branch = group_size < 0;
8937 if (group_size < 0)
8938 stub_group_size = -group_size;
8939 else
8940 stub_group_size = group_size;
8941 if (stub_group_size == 1)
8943 /* Default values. */
8944 if (stubs_always_before_branch)
8946 stub_group_size = 0x1e00000;
8947 if (htab->has_14bit_branch)
8948 stub_group_size = 0x7800;
8950 else
8952 stub_group_size = 0x1c00000;
8953 if (htab->has_14bit_branch)
8954 stub_group_size = 0x7000;
8958 group_sections (htab, stub_group_size, stubs_always_before_branch);
8960 while (1)
8962 bfd *input_bfd;
8963 unsigned int bfd_indx;
8964 asection *stub_sec;
8966 htab->stub_iteration += 1;
8968 for (input_bfd = info->input_bfds, bfd_indx = 0;
8969 input_bfd != NULL;
8970 input_bfd = input_bfd->link_next, bfd_indx++)
8972 Elf_Internal_Shdr *symtab_hdr;
8973 asection *section;
8974 Elf_Internal_Sym *local_syms = NULL;
8976 if (!is_ppc64_elf_target (input_bfd->xvec))
8977 continue;
8979 /* We'll need the symbol table in a second. */
8980 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
8981 if (symtab_hdr->sh_info == 0)
8982 continue;
8984 /* Walk over each section attached to the input bfd. */
8985 for (section = input_bfd->sections;
8986 section != NULL;
8987 section = section->next)
8989 Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
8991 /* If there aren't any relocs, then there's nothing more
8992 to do. */
8993 if ((section->flags & SEC_RELOC) == 0
8994 || section->reloc_count == 0)
8995 continue;
8997 /* If this section is a link-once section that will be
8998 discarded, then don't create any stubs. */
8999 if (section->output_section == NULL
9000 || section->output_section->owner != output_bfd)
9001 continue;
9003 /* Get the relocs. */
9004 internal_relocs
9005 = _bfd_elf_link_read_relocs (input_bfd, section, NULL, NULL,
9006 info->keep_memory);
9007 if (internal_relocs == NULL)
9008 goto error_ret_free_local;
9010 /* Now examine each relocation. */
9011 irela = internal_relocs;
9012 irelaend = irela + section->reloc_count;
9013 for (; irela < irelaend; irela++)
9015 enum elf_ppc64_reloc_type r_type;
9016 unsigned int r_indx;
9017 enum ppc_stub_type stub_type;
9018 struct ppc_stub_hash_entry *stub_entry;
9019 asection *sym_sec, *code_sec;
9020 bfd_vma sym_value;
9021 bfd_vma destination;
9022 bfd_boolean ok_dest;
9023 struct ppc_link_hash_entry *hash;
9024 struct ppc_link_hash_entry *fdh;
9025 struct elf_link_hash_entry *h;
9026 Elf_Internal_Sym *sym;
9027 char *stub_name;
9028 const asection *id_sec;
9029 long *opd_adjust;
9031 r_type = ELF64_R_TYPE (irela->r_info);
9032 r_indx = ELF64_R_SYM (irela->r_info);
9034 if (r_type >= R_PPC64_max)
9036 bfd_set_error (bfd_error_bad_value);
9037 goto error_ret_free_internal;
9040 /* Only look for stubs on branch instructions. */
9041 if (r_type != R_PPC64_REL24
9042 && r_type != R_PPC64_REL14
9043 && r_type != R_PPC64_REL14_BRTAKEN
9044 && r_type != R_PPC64_REL14_BRNTAKEN)
9045 continue;
9047 /* Now determine the call target, its name, value,
9048 section. */
9049 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9050 r_indx, input_bfd))
9051 goto error_ret_free_internal;
9052 hash = (struct ppc_link_hash_entry *) h;
9054 ok_dest = FALSE;
9055 fdh = NULL;
9056 sym_value = 0;
9057 if (hash == NULL)
9059 sym_value = sym->st_value;
9060 ok_dest = TRUE;
9062 else if (hash->elf.root.type == bfd_link_hash_defined
9063 || hash->elf.root.type == bfd_link_hash_defweak)
9065 sym_value = hash->elf.root.u.def.value;
9066 if (sym_sec->output_section != NULL)
9067 ok_dest = TRUE;
9069 else if (hash->elf.root.type == bfd_link_hash_undefweak
9070 || hash->elf.root.type == bfd_link_hash_undefined)
9072 /* Recognise an old ABI func code entry sym, and
9073 use the func descriptor sym instead if it is
9074 defined. */
9075 if (hash->elf.root.root.string[0] == '.'
9076 && (fdh = get_fdh (hash, htab)) != NULL)
9078 if (fdh->elf.root.type == bfd_link_hash_defined
9079 || fdh->elf.root.type == bfd_link_hash_defweak)
9081 sym_sec = fdh->elf.root.u.def.section;
9082 sym_value = fdh->elf.root.u.def.value;
9083 if (sym_sec->output_section != NULL)
9084 ok_dest = TRUE;
9086 else
9087 fdh = NULL;
9090 else
9092 bfd_set_error (bfd_error_bad_value);
9093 goto error_ret_free_internal;
9096 destination = 0;
9097 if (ok_dest)
9099 sym_value += irela->r_addend;
9100 destination = (sym_value
9101 + sym_sec->output_offset
9102 + sym_sec->output_section->vma);
9105 code_sec = sym_sec;
9106 opd_adjust = get_opd_info (sym_sec);
9107 if (opd_adjust != NULL)
9109 bfd_vma dest;
9111 if (hash == NULL)
9113 long adjust = opd_adjust[sym_value / 8];
9114 if (adjust == -1)
9115 continue;
9116 sym_value += adjust;
9118 dest = opd_entry_value (sym_sec, sym_value,
9119 &code_sec, &sym_value);
9120 if (dest != (bfd_vma) -1)
9122 destination = dest;
9123 if (fdh != NULL)
9125 /* Fixup old ABI sym to point at code
9126 entry. */
9127 hash->elf.root.type = bfd_link_hash_defweak;
9128 hash->elf.root.u.def.section = code_sec;
9129 hash->elf.root.u.def.value = sym_value;
9134 /* Determine what (if any) linker stub is needed. */
9135 stub_type = ppc_type_of_stub (section, irela, &hash,
9136 destination);
9138 if (stub_type != ppc_stub_plt_call)
9140 /* Check whether we need a TOC adjusting stub.
9141 Since the linker pastes together pieces from
9142 different object files when creating the
9143 _init and _fini functions, it may be that a
9144 call to what looks like a local sym is in
9145 fact a call needing a TOC adjustment. */
9146 if (code_sec != NULL
9147 && code_sec->output_section != NULL
9148 && (htab->stub_group[code_sec->id].toc_off
9149 != htab->stub_group[section->id].toc_off)
9150 && (code_sec->has_toc_reloc
9151 || code_sec->makes_toc_func_call))
9152 stub_type = ppc_stub_long_branch_r2off;
9155 if (stub_type == ppc_stub_none)
9156 continue;
9158 /* __tls_get_addr calls might be eliminated. */
9159 if (stub_type != ppc_stub_plt_call
9160 && hash != NULL
9161 && (hash == htab->tls_get_addr
9162 || hash == htab->tls_get_addr_fd)
9163 && section->has_tls_reloc
9164 && irela != internal_relocs)
9166 /* Get tls info. */
9167 char *tls_mask;
9169 if (!get_tls_mask (&tls_mask, NULL, &local_syms,
9170 irela - 1, input_bfd))
9171 goto error_ret_free_internal;
9172 if (*tls_mask != 0)
9173 continue;
9176 /* Support for grouping stub sections. */
9177 id_sec = htab->stub_group[section->id].link_sec;
9179 /* Get the name of this stub. */
9180 stub_name = ppc_stub_name (id_sec, sym_sec, hash, irela);
9181 if (!stub_name)
9182 goto error_ret_free_internal;
9184 stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
9185 stub_name, FALSE, FALSE);
9186 if (stub_entry != NULL)
9188 /* The proper stub has already been created. */
9189 free (stub_name);
9190 continue;
9193 stub_entry = ppc_add_stub (stub_name, section, htab);
9194 if (stub_entry == NULL)
9196 free (stub_name);
9197 error_ret_free_internal:
9198 if (elf_section_data (section)->relocs == NULL)
9199 free (internal_relocs);
9200 error_ret_free_local:
9201 if (local_syms != NULL
9202 && (symtab_hdr->contents
9203 != (unsigned char *) local_syms))
9204 free (local_syms);
9205 return FALSE;
9208 stub_entry->stub_type = stub_type;
9209 stub_entry->target_value = sym_value;
9210 stub_entry->target_section = code_sec;
9211 stub_entry->h = hash;
9212 stub_entry->addend = irela->r_addend;
9214 if (stub_entry->h != NULL)
9215 htab->stub_globals += 1;
9218 /* We're done with the internal relocs, free them. */
9219 if (elf_section_data (section)->relocs != internal_relocs)
9220 free (internal_relocs);
9223 if (local_syms != NULL
9224 && symtab_hdr->contents != (unsigned char *) local_syms)
9226 if (!info->keep_memory)
9227 free (local_syms);
9228 else
9229 symtab_hdr->contents = (unsigned char *) local_syms;
9233 /* We may have added some stubs. Find out the new size of the
9234 stub sections. */
9235 for (stub_sec = htab->stub_bfd->sections;
9236 stub_sec != NULL;
9237 stub_sec = stub_sec->next)
9238 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
9240 stub_sec->rawsize = stub_sec->size;
9241 stub_sec->size = 0;
9242 stub_sec->reloc_count = 0;
9245 htab->brlt->size = 0;
9246 if (htab->relbrlt != NULL)
9247 htab->relbrlt->size = 0;
9249 bfd_hash_traverse (&htab->stub_hash_table, ppc_size_one_stub, info);
9251 for (stub_sec = htab->stub_bfd->sections;
9252 stub_sec != NULL;
9253 stub_sec = stub_sec->next)
9254 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
9255 && stub_sec->rawsize != stub_sec->size)
9256 break;
9258 /* Exit from this loop when no stubs have been added, and no stubs
9259 have changed size. */
9260 if (stub_sec == NULL)
9261 break;
9263 /* Ask the linker to do its stuff. */
9264 (*htab->layout_sections_again) ();
9267 /* It would be nice to strip htab->brlt from the output if the
9268 section is empty, but it's too late. If we strip sections here,
9269 the dynamic symbol table is corrupted since the section symbol
9270 for the stripped section isn't written. */
9272 return TRUE;
9275 /* Called after we have determined section placement. If sections
9276 move, we'll be called again. Provide a value for TOCstart. */
9278 bfd_vma
9279 ppc64_elf_toc (bfd *obfd)
9281 asection *s;
9282 bfd_vma TOCstart;
9284 /* The TOC consists of sections .got, .toc, .tocbss, .plt in that
9285 order. The TOC starts where the first of these sections starts. */
9286 s = bfd_get_section_by_name (obfd, ".got");
9287 if (s == NULL)
9288 s = bfd_get_section_by_name (obfd, ".toc");
9289 if (s == NULL)
9290 s = bfd_get_section_by_name (obfd, ".tocbss");
9291 if (s == NULL)
9292 s = bfd_get_section_by_name (obfd, ".plt");
9293 if (s == NULL)
9295 /* This may happen for
9296 o references to TOC base (SYM@toc / TOC[tc0]) without a
9297 .toc directive
9298 o bad linker script
9299 o --gc-sections and empty TOC sections
9301 FIXME: Warn user? */
9303 /* Look for a likely section. We probably won't even be
9304 using TOCstart. */
9305 for (s = obfd->sections; s != NULL; s = s->next)
9306 if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_READONLY))
9307 == (SEC_ALLOC | SEC_SMALL_DATA))
9308 break;
9309 if (s == NULL)
9310 for (s = obfd->sections; s != NULL; s = s->next)
9311 if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA))
9312 == (SEC_ALLOC | SEC_SMALL_DATA))
9313 break;
9314 if (s == NULL)
9315 for (s = obfd->sections; s != NULL; s = s->next)
9316 if ((s->flags & (SEC_ALLOC | SEC_READONLY)) == SEC_ALLOC)
9317 break;
9318 if (s == NULL)
9319 for (s = obfd->sections; s != NULL; s = s->next)
9320 if ((s->flags & SEC_ALLOC) == SEC_ALLOC)
9321 break;
9324 TOCstart = 0;
9325 if (s != NULL)
9326 TOCstart = s->output_section->vma + s->output_offset;
9328 return TOCstart;
9331 /* Build all the stubs associated with the current output file.
9332 The stubs are kept in a hash table attached to the main linker
9333 hash table. This function is called via gldelf64ppc_finish. */
9335 bfd_boolean
9336 ppc64_elf_build_stubs (bfd_boolean emit_stub_syms,
9337 struct bfd_link_info *info,
9338 char **stats)
9340 struct ppc_link_hash_table *htab = ppc_hash_table (info);
9341 asection *stub_sec;
9342 bfd_byte *p;
9343 int stub_sec_count = 0;
9345 htab->emit_stub_syms = emit_stub_syms;
9347 /* Allocate memory to hold the linker stubs. */
9348 for (stub_sec = htab->stub_bfd->sections;
9349 stub_sec != NULL;
9350 stub_sec = stub_sec->next)
9351 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
9352 && stub_sec->size != 0)
9354 stub_sec->contents = bfd_zalloc (htab->stub_bfd, stub_sec->size);
9355 if (stub_sec->contents == NULL)
9356 return FALSE;
9357 /* We want to check that built size is the same as calculated
9358 size. rawsize is a convenient location to use. */
9359 stub_sec->rawsize = stub_sec->size;
9360 stub_sec->size = 0;
9363 if (htab->plt != NULL)
9365 unsigned int indx;
9366 bfd_vma plt0;
9368 /* Build the .glink plt call stub. */
9369 plt0 = (htab->plt->output_section->vma
9370 + htab->plt->output_offset
9371 - (htab->glink->output_section->vma
9372 + htab->glink->output_offset
9373 + GLINK_CALL_STUB_SIZE));
9374 if (plt0 + 0x80008000 > 0xffffffff)
9376 (*_bfd_error_handler) (_(".glink and .plt too far apart"));
9377 bfd_set_error (bfd_error_bad_value);
9378 return FALSE;
9381 if (htab->emit_stub_syms)
9383 struct elf_link_hash_entry *h;
9384 h = elf_link_hash_lookup (&htab->elf, "__glink", TRUE, FALSE, FALSE);
9385 if (h == NULL)
9386 return FALSE;
9387 if (h->root.type == bfd_link_hash_new)
9389 h->root.type = bfd_link_hash_defined;
9390 h->root.u.def.section = htab->glink;
9391 h->root.u.def.value = 0;
9392 h->ref_regular = 1;
9393 h->def_regular = 1;
9394 h->ref_regular_nonweak = 1;
9395 h->forced_local = 1;
9396 h->non_elf = 0;
9399 p = htab->glink->contents;
9400 bfd_put_32 (htab->glink->owner, MFCTR_R12, p);
9401 p += 4;
9402 bfd_put_32 (htab->glink->owner, SLDI_R11_R0_3, p);
9403 p += 4;
9404 bfd_put_32 (htab->glink->owner, ADDIC_R2_R0_32K, p);
9405 p += 4;
9406 bfd_put_32 (htab->glink->owner, SUB_R12_R12_R11, p);
9407 p += 4;
9408 bfd_put_32 (htab->glink->owner, SRADI_R2_R2_63, p);
9409 p += 4;
9410 bfd_put_32 (htab->glink->owner, SLDI_R11_R0_2, p);
9411 p += 4;
9412 bfd_put_32 (htab->glink->owner, AND_R2_R2_R11, p);
9413 p += 4;
9414 bfd_put_32 (htab->glink->owner, SUB_R12_R12_R11, p);
9415 p += 4;
9416 bfd_put_32 (htab->glink->owner, ADD_R12_R12_R2, p);
9417 p += 4;
9418 bfd_put_32 (htab->glink->owner, ADDIS_R12_R12 | PPC_HA (plt0), p);
9419 p += 4;
9420 bfd_put_32 (htab->glink->owner, LD_R11_0R12 | PPC_LO (plt0), p);
9421 p += 4;
9422 bfd_put_32 (htab->glink->owner, ADDI_R12_R12 | PPC_LO (plt0), p);
9423 p += 4;
9424 bfd_put_32 (htab->glink->owner, LD_R2_0R12 | 8, p);
9425 p += 4;
9426 bfd_put_32 (htab->glink->owner, MTCTR_R11, p);
9427 p += 4;
9428 bfd_put_32 (htab->glink->owner, LD_R11_0R12 | 16, p);
9429 p += 4;
9430 bfd_put_32 (htab->glink->owner, BCTR, p);
9431 p += 4;
9433 /* Build the .glink lazy link call stubs. */
9434 indx = 0;
9435 while (p < htab->glink->contents + htab->glink->size)
9437 if (indx < 0x8000)
9439 bfd_put_32 (htab->glink->owner, LI_R0_0 | indx, p);
9440 p += 4;
9442 else
9444 bfd_put_32 (htab->glink->owner, LIS_R0_0 | PPC_HI (indx), p);
9445 p += 4;
9446 bfd_put_32 (htab->glink->owner, ORI_R0_R0_0 | PPC_LO (indx), p);
9447 p += 4;
9449 bfd_put_32 (htab->glink->owner,
9450 B_DOT | ((htab->glink->contents - p) & 0x3fffffc), p);
9451 indx++;
9452 p += 4;
9454 htab->glink->rawsize = p - htab->glink->contents;
9457 if (htab->brlt->size != 0)
9459 htab->brlt->contents = bfd_zalloc (htab->brlt->owner,
9460 htab->brlt->size);
9461 if (htab->brlt->contents == NULL)
9462 return FALSE;
9464 if (htab->relbrlt != NULL && htab->relbrlt->size != 0)
9466 htab->relbrlt->contents = bfd_zalloc (htab->relbrlt->owner,
9467 htab->relbrlt->size);
9468 if (htab->relbrlt->contents == NULL)
9469 return FALSE;
9472 /* Build the stubs as directed by the stub hash table. */
9473 bfd_hash_traverse (&htab->stub_hash_table, ppc_build_one_stub, info);
9475 for (stub_sec = htab->stub_bfd->sections;
9476 stub_sec != NULL;
9477 stub_sec = stub_sec->next)
9478 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
9480 stub_sec_count += 1;
9481 if (stub_sec->rawsize != stub_sec->size)
9482 break;
9485 if (stub_sec != NULL
9486 || htab->glink->rawsize != htab->glink->size)
9488 htab->stub_error = TRUE;
9489 (*_bfd_error_handler) (_("stubs don't match calculated size"));
9492 if (htab->stub_error)
9493 return FALSE;
9495 if (stats != NULL)
9497 *stats = bfd_malloc (500);
9498 if (*stats == NULL)
9499 return FALSE;
9501 sprintf (*stats, _("linker stubs in %u group%s\n"
9502 " branch %lu\n"
9503 " toc adjust %lu\n"
9504 " long branch %lu\n"
9505 " long toc adj %lu\n"
9506 " plt call %lu"),
9507 stub_sec_count,
9508 stub_sec_count == 1 ? "" : "s",
9509 htab->stub_count[ppc_stub_long_branch - 1],
9510 htab->stub_count[ppc_stub_long_branch_r2off - 1],
9511 htab->stub_count[ppc_stub_plt_branch - 1],
9512 htab->stub_count[ppc_stub_plt_branch_r2off - 1],
9513 htab->stub_count[ppc_stub_plt_call - 1]);
9515 return TRUE;
9518 /* This function undoes the changes made by add_symbol_adjust. */
9520 static bfd_boolean
9521 undo_symbol_twiddle (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
9523 struct ppc_link_hash_entry *eh;
9525 if (h->root.type == bfd_link_hash_indirect)
9526 return TRUE;
9528 if (h->root.type == bfd_link_hash_warning)
9529 h = (struct elf_link_hash_entry *) h->root.u.i.link;
9531 eh = (struct ppc_link_hash_entry *) h;
9532 if (eh->elf.root.type != bfd_link_hash_undefweak || !eh->was_undefined)
9533 return TRUE;
9535 eh->elf.root.type = bfd_link_hash_undefined;
9536 return TRUE;
9539 void
9540 ppc64_elf_restore_symbols (struct bfd_link_info *info)
9542 struct ppc_link_hash_table *htab = ppc_hash_table (info);
9543 elf_link_hash_traverse (&htab->elf, undo_symbol_twiddle, info);
9546 /* What to do when ld finds relocations against symbols defined in
9547 discarded sections. */
9549 static unsigned int
9550 ppc64_elf_action_discarded (asection *sec)
9552 if (strcmp (".opd", sec->name) == 0)
9553 return 0;
9555 if (strcmp (".toc", sec->name) == 0)
9556 return 0;
9558 if (strcmp (".toc1", sec->name) == 0)
9559 return 0;
9561 return _bfd_elf_default_action_discarded (sec);
9564 /* The RELOCATE_SECTION function is called by the ELF backend linker
9565 to handle the relocations for a section.
9567 The relocs are always passed as Rela structures; if the section
9568 actually uses Rel structures, the r_addend field will always be
9569 zero.
9571 This function is responsible for adjust the section contents as
9572 necessary, and (if using Rela relocs and generating a
9573 relocatable output file) adjusting the reloc addend as
9574 necessary.
9576 This function does not have to worry about setting the reloc
9577 address or the reloc symbol index.
9579 LOCAL_SYMS is a pointer to the swapped in local symbols.
9581 LOCAL_SECTIONS is an array giving the section in the input file
9582 corresponding to the st_shndx field of each local symbol.
9584 The global hash table entry for the global symbols can be found
9585 via elf_sym_hashes (input_bfd).
9587 When generating relocatable output, this function must handle
9588 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
9589 going to be the section symbol corresponding to the output
9590 section, which means that the addend must be adjusted
9591 accordingly. */
9593 static bfd_boolean
9594 ppc64_elf_relocate_section (bfd *output_bfd,
9595 struct bfd_link_info *info,
9596 bfd *input_bfd,
9597 asection *input_section,
9598 bfd_byte *contents,
9599 Elf_Internal_Rela *relocs,
9600 Elf_Internal_Sym *local_syms,
9601 asection **local_sections)
9603 struct ppc_link_hash_table *htab;
9604 Elf_Internal_Shdr *symtab_hdr;
9605 struct elf_link_hash_entry **sym_hashes;
9606 Elf_Internal_Rela *rel;
9607 Elf_Internal_Rela *relend;
9608 Elf_Internal_Rela outrel;
9609 bfd_byte *loc;
9610 struct got_entry **local_got_ents;
9611 bfd_vma TOCstart;
9612 bfd_boolean ret = TRUE;
9613 bfd_boolean is_opd;
9614 /* Disabled until we sort out how ld should choose 'y' vs 'at'. */
9615 bfd_boolean is_power4 = FALSE;
9617 /* Initialize howto table if needed. */
9618 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
9619 ppc_howto_init ();
9621 htab = ppc_hash_table (info);
9623 /* Don't relocate stub sections. */
9624 if (input_section->owner == htab->stub_bfd)
9625 return TRUE;
9627 local_got_ents = elf_local_got_ents (input_bfd);
9628 TOCstart = elf_gp (output_bfd);
9629 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
9630 sym_hashes = elf_sym_hashes (input_bfd);
9631 is_opd = ppc64_elf_section_data (input_section)->opd.adjust != NULL;
9633 rel = relocs;
9634 relend = relocs + input_section->reloc_count;
9635 for (; rel < relend; rel++)
9637 enum elf_ppc64_reloc_type r_type;
9638 bfd_vma addend, orig_addend;
9639 bfd_reloc_status_type r;
9640 Elf_Internal_Sym *sym;
9641 asection *sec;
9642 struct elf_link_hash_entry *h_elf;
9643 struct ppc_link_hash_entry *h;
9644 struct ppc_link_hash_entry *fdh;
9645 const char *sym_name;
9646 unsigned long r_symndx, toc_symndx;
9647 char tls_mask, tls_gd, tls_type;
9648 char sym_type;
9649 bfd_vma relocation;
9650 bfd_boolean unresolved_reloc;
9651 bfd_boolean warned;
9652 unsigned long insn, mask;
9653 struct ppc_stub_hash_entry *stub_entry;
9654 bfd_vma max_br_offset;
9655 bfd_vma from;
9657 r_type = ELF64_R_TYPE (rel->r_info);
9658 r_symndx = ELF64_R_SYM (rel->r_info);
9660 /* For old style R_PPC64_TOC relocs with a zero symbol, use the
9661 symbol of the previous ADDR64 reloc. The symbol gives us the
9662 proper TOC base to use. */
9663 if (rel->r_info == ELF64_R_INFO (0, R_PPC64_TOC)
9664 && rel != relocs
9665 && ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_ADDR64
9666 && is_opd)
9667 r_symndx = ELF64_R_SYM (rel[-1].r_info);
9669 sym = NULL;
9670 sec = NULL;
9671 h_elf = NULL;
9672 sym_name = NULL;
9673 unresolved_reloc = FALSE;
9674 warned = FALSE;
9675 orig_addend = rel->r_addend;
9677 if (r_symndx < symtab_hdr->sh_info)
9679 /* It's a local symbol. */
9680 long *opd_adjust;
9682 sym = local_syms + r_symndx;
9683 sec = local_sections[r_symndx];
9684 sym_name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym, sec);
9685 sym_type = ELF64_ST_TYPE (sym->st_info);
9686 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
9687 opd_adjust = get_opd_info (sec);
9688 if (opd_adjust != NULL)
9690 long adjust = opd_adjust[(sym->st_value + rel->r_addend) / 8];
9691 if (adjust == -1)
9692 relocation = 0;
9693 else
9695 /* If this is a relocation against the opd section sym
9696 and we have edited .opd, adjust the reloc addend so
9697 that ld -r and ld --emit-relocs output is correct.
9698 If it is a reloc against some other .opd symbol,
9699 then the symbol value will be adjusted later. */
9700 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
9701 rel->r_addend += adjust;
9702 else
9703 relocation += adjust;
9706 if (info->relocatable)
9707 continue;
9709 else
9711 if (info->relocatable)
9712 continue;
9713 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
9714 r_symndx, symtab_hdr, sym_hashes,
9715 h_elf, sec, relocation,
9716 unresolved_reloc, warned);
9717 sym_name = h_elf->root.root.string;
9718 sym_type = h_elf->type;
9720 h = (struct ppc_link_hash_entry *) h_elf;
9722 /* TLS optimizations. Replace instruction sequences and relocs
9723 based on information we collected in tls_optimize. We edit
9724 RELOCS so that --emit-relocs will output something sensible
9725 for the final instruction stream. */
9726 tls_mask = 0;
9727 tls_gd = 0;
9728 toc_symndx = 0;
9729 if (IS_PPC64_TLS_RELOC (r_type))
9731 if (h != NULL)
9732 tls_mask = h->tls_mask;
9733 else if (local_got_ents != NULL)
9735 char *lgot_masks;
9736 lgot_masks = (char *) (local_got_ents + symtab_hdr->sh_info);
9737 tls_mask = lgot_masks[r_symndx];
9739 if (tls_mask == 0 && r_type == R_PPC64_TLS)
9741 /* Check for toc tls entries. */
9742 char *toc_tls;
9744 if (!get_tls_mask (&toc_tls, &toc_symndx, &local_syms,
9745 rel, input_bfd))
9746 return FALSE;
9748 if (toc_tls)
9749 tls_mask = *toc_tls;
9753 /* Check that tls relocs are used with tls syms, and non-tls
9754 relocs are used with non-tls syms. */
9755 if (r_symndx != 0
9756 && r_type != R_PPC64_NONE
9757 && (h == NULL
9758 || h->elf.root.type == bfd_link_hash_defined
9759 || h->elf.root.type == bfd_link_hash_defweak)
9760 && IS_PPC64_TLS_RELOC (r_type) != (sym_type == STT_TLS))
9762 if (r_type == R_PPC64_TLS && tls_mask != 0)
9763 /* R_PPC64_TLS is OK against a symbol in the TOC. */
9765 else
9766 (*_bfd_error_handler)
9767 (sym_type == STT_TLS
9768 ? _("%B(%A+0x%lx): %s used with TLS symbol %s")
9769 : _("%B(%A+0x%lx): %s used with non-TLS symbol %s"),
9770 input_bfd,
9771 input_section,
9772 (long) rel->r_offset,
9773 ppc64_elf_howto_table[r_type]->name,
9774 sym_name);
9777 /* Ensure reloc mapping code below stays sane. */
9778 if (R_PPC64_TOC16_LO_DS != R_PPC64_TOC16_DS + 1
9779 || R_PPC64_TOC16_LO != R_PPC64_TOC16 + 1
9780 || (R_PPC64_GOT_TLSLD16 & 3) != (R_PPC64_GOT_TLSGD16 & 3)
9781 || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TLSGD16_LO & 3)
9782 || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TLSGD16_HI & 3)
9783 || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TLSGD16_HA & 3)
9784 || (R_PPC64_GOT_TLSLD16 & 3) != (R_PPC64_GOT_TPREL16_DS & 3)
9785 || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TPREL16_LO_DS & 3)
9786 || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TPREL16_HI & 3)
9787 || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TPREL16_HA & 3))
9788 abort ();
9790 switch (r_type)
9792 default:
9793 break;
9795 case R_PPC64_TOC16:
9796 case R_PPC64_TOC16_LO:
9797 case R_PPC64_TOC16_DS:
9798 case R_PPC64_TOC16_LO_DS:
9800 /* Check for toc tls entries. */
9801 char *toc_tls;
9802 int retval;
9804 retval = get_tls_mask (&toc_tls, &toc_symndx, &local_syms,
9805 rel, input_bfd);
9806 if (retval == 0)
9807 return FALSE;
9809 if (toc_tls)
9811 tls_mask = *toc_tls;
9812 if (r_type == R_PPC64_TOC16_DS
9813 || r_type == R_PPC64_TOC16_LO_DS)
9815 if (tls_mask != 0
9816 && (tls_mask & (TLS_DTPREL | TLS_TPREL)) == 0)
9817 goto toctprel;
9819 else
9821 /* If we found a GD reloc pair, then we might be
9822 doing a GD->IE transition. */
9823 if (retval == 2)
9825 tls_gd = TLS_TPRELGD;
9826 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
9827 goto tls_get_addr_check;
9829 else if (retval == 3)
9831 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
9832 goto tls_get_addr_check;
9837 break;
9839 case R_PPC64_GOT_TPREL16_DS:
9840 case R_PPC64_GOT_TPREL16_LO_DS:
9841 if (tls_mask != 0
9842 && (tls_mask & TLS_TPREL) == 0)
9844 toctprel:
9845 insn = bfd_get_32 (output_bfd, contents + rel->r_offset - 2);
9846 insn &= 31 << 21;
9847 insn |= 0x3c0d0000; /* addis 0,13,0 */
9848 bfd_put_32 (output_bfd, insn, contents + rel->r_offset - 2);
9849 r_type = R_PPC64_TPREL16_HA;
9850 if (toc_symndx != 0)
9852 rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
9853 /* We changed the symbol. Start over in order to
9854 get h, sym, sec etc. right. */
9855 rel--;
9856 continue;
9858 else
9859 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
9861 break;
9863 case R_PPC64_TLS:
9864 if (tls_mask != 0
9865 && (tls_mask & TLS_TPREL) == 0)
9867 bfd_vma rtra;
9868 insn = bfd_get_32 (output_bfd, contents + rel->r_offset);
9869 if ((insn & ((0x3f << 26) | (31 << 11)))
9870 == ((31 << 26) | (13 << 11)))
9871 rtra = insn & ((1 << 26) - (1 << 16));
9872 else if ((insn & ((0x3f << 26) | (31 << 16)))
9873 == ((31 << 26) | (13 << 16)))
9874 rtra = (insn & (31 << 21)) | ((insn & (31 << 11)) << 5);
9875 else
9876 abort ();
9877 if ((insn & ((1 << 11) - (1 << 1))) == 266 << 1)
9878 /* add -> addi. */
9879 insn = 14 << 26;
9880 else if ((insn & (31 << 1)) == 23 << 1
9881 && ((insn & (31 << 6)) < 14 << 6
9882 || ((insn & (31 << 6)) >= 16 << 6
9883 && (insn & (31 << 6)) < 24 << 6)))
9884 /* load and store indexed -> dform. */
9885 insn = (32 | ((insn >> 6) & 31)) << 26;
9886 else if ((insn & (31 << 1)) == 21 << 1
9887 && (insn & (0x1a << 6)) == 0)
9888 /* ldx, ldux, stdx, stdux -> ld, ldu, std, stdu. */
9889 insn = (((58 | ((insn >> 6) & 4)) << 26)
9890 | ((insn >> 6) & 1));
9891 else if ((insn & (31 << 1)) == 21 << 1
9892 && (insn & ((1 << 11) - (1 << 1))) == 341 << 1)
9893 /* lwax -> lwa. */
9894 insn = (58 << 26) | 2;
9895 else
9896 abort ();
9897 insn |= rtra;
9898 bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
9899 /* Was PPC64_TLS which sits on insn boundary, now
9900 PPC64_TPREL16_LO which is at insn+2. */
9901 rel->r_offset += 2;
9902 r_type = R_PPC64_TPREL16_LO;
9903 if (toc_symndx != 0)
9905 rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
9906 /* We changed the symbol. Start over in order to
9907 get h, sym, sec etc. right. */
9908 rel--;
9909 continue;
9911 else
9912 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
9914 break;
9916 case R_PPC64_GOT_TLSGD16_HI:
9917 case R_PPC64_GOT_TLSGD16_HA:
9918 tls_gd = TLS_TPRELGD;
9919 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
9920 goto tls_gdld_hi;
9921 break;
9923 case R_PPC64_GOT_TLSLD16_HI:
9924 case R_PPC64_GOT_TLSLD16_HA:
9925 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
9927 tls_gdld_hi:
9928 if ((tls_mask & tls_gd) != 0)
9929 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
9930 + R_PPC64_GOT_TPREL16_DS);
9931 else
9933 bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
9934 rel->r_offset -= 2;
9935 r_type = R_PPC64_NONE;
9937 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
9939 break;
9941 case R_PPC64_GOT_TLSGD16:
9942 case R_PPC64_GOT_TLSGD16_LO:
9943 tls_gd = TLS_TPRELGD;
9944 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
9945 goto tls_get_addr_check;
9946 break;
9948 case R_PPC64_GOT_TLSLD16:
9949 case R_PPC64_GOT_TLSLD16_LO:
9950 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
9952 tls_get_addr_check:
9953 if (rel + 1 < relend)
9955 enum elf_ppc64_reloc_type r_type2;
9956 unsigned long r_symndx2;
9957 struct elf_link_hash_entry *h2;
9958 bfd_vma insn1, insn2, insn3;
9959 bfd_vma offset;
9961 /* The next instruction should be a call to
9962 __tls_get_addr. Peek at the reloc to be sure. */
9963 r_type2 = ELF64_R_TYPE (rel[1].r_info);
9964 r_symndx2 = ELF64_R_SYM (rel[1].r_info);
9965 if (r_symndx2 < symtab_hdr->sh_info
9966 || (r_type2 != R_PPC64_REL14
9967 && r_type2 != R_PPC64_REL14_BRTAKEN
9968 && r_type2 != R_PPC64_REL14_BRNTAKEN
9969 && r_type2 != R_PPC64_REL24))
9970 break;
9972 h2 = sym_hashes[r_symndx2 - symtab_hdr->sh_info];
9973 while (h2->root.type == bfd_link_hash_indirect
9974 || h2->root.type == bfd_link_hash_warning)
9975 h2 = (struct elf_link_hash_entry *) h2->root.u.i.link;
9976 if (h2 == NULL || (h2 != &htab->tls_get_addr->elf
9977 && h2 != &htab->tls_get_addr_fd->elf))
9978 break;
9980 /* OK, it checks out. Replace the call. */
9981 offset = rel[1].r_offset;
9982 insn1 = bfd_get_32 (output_bfd,
9983 contents + rel->r_offset - 2);
9984 insn3 = bfd_get_32 (output_bfd,
9985 contents + offset + 4);
9986 if ((tls_mask & tls_gd) != 0)
9988 /* IE */
9989 insn1 &= (1 << 26) - (1 << 2);
9990 insn1 |= 58 << 26; /* ld */
9991 insn2 = 0x7c636a14; /* add 3,3,13 */
9992 rel[1].r_info = ELF64_R_INFO (r_symndx2, R_PPC64_NONE);
9993 if ((tls_mask & TLS_EXPLICIT) == 0)
9994 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
9995 + R_PPC64_GOT_TPREL16_DS);
9996 else
9997 r_type += R_PPC64_TOC16_DS - R_PPC64_TOC16;
9998 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
10000 else
10002 /* LE */
10003 insn1 = 0x3c6d0000; /* addis 3,13,0 */
10004 insn2 = 0x38630000; /* addi 3,3,0 */
10005 if (tls_gd == 0)
10007 /* Was an LD reloc. */
10008 r_symndx = 0;
10009 rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
10010 rel[1].r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
10012 else if (toc_symndx != 0)
10013 r_symndx = toc_symndx;
10014 r_type = R_PPC64_TPREL16_HA;
10015 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
10016 rel[1].r_info = ELF64_R_INFO (r_symndx,
10017 R_PPC64_TPREL16_LO);
10018 rel[1].r_offset += 2;
10020 if (insn3 == NOP
10021 || insn3 == CROR_151515 || insn3 == CROR_313131)
10023 insn3 = insn2;
10024 insn2 = NOP;
10025 rel[1].r_offset += 4;
10027 bfd_put_32 (output_bfd, insn1, contents + rel->r_offset - 2);
10028 bfd_put_32 (output_bfd, insn2, contents + offset);
10029 bfd_put_32 (output_bfd, insn3, contents + offset + 4);
10030 if (tls_gd == 0 || toc_symndx != 0)
10032 /* We changed the symbol. Start over in order
10033 to get h, sym, sec etc. right. */
10034 rel--;
10035 continue;
10039 break;
10041 case R_PPC64_DTPMOD64:
10042 if (rel + 1 < relend
10043 && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
10044 && rel[1].r_offset == rel->r_offset + 8)
10046 if ((tls_mask & TLS_GD) == 0)
10048 rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_NONE);
10049 if ((tls_mask & TLS_TPRELGD) != 0)
10050 r_type = R_PPC64_TPREL64;
10051 else
10053 bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
10054 r_type = R_PPC64_NONE;
10056 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
10059 else
10061 if ((tls_mask & TLS_LD) == 0)
10063 bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
10064 r_type = R_PPC64_NONE;
10065 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
10068 break;
10070 case R_PPC64_TPREL64:
10071 if ((tls_mask & TLS_TPREL) == 0)
10073 r_type = R_PPC64_NONE;
10074 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
10076 break;
10079 /* Handle other relocations that tweak non-addend part of insn. */
10080 insn = 0;
10081 max_br_offset = 1 << 25;
10082 addend = rel->r_addend;
10083 switch (r_type)
10085 default:
10086 break;
10088 /* Branch taken prediction relocations. */
10089 case R_PPC64_ADDR14_BRTAKEN:
10090 case R_PPC64_REL14_BRTAKEN:
10091 insn = 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field. */
10092 /* Fall thru. */
10094 /* Branch not taken prediction relocations. */
10095 case R_PPC64_ADDR14_BRNTAKEN:
10096 case R_PPC64_REL14_BRNTAKEN:
10097 insn |= bfd_get_32 (output_bfd,
10098 contents + rel->r_offset) & ~(0x01 << 21);
10099 /* Fall thru. */
10101 case R_PPC64_REL14:
10102 max_br_offset = 1 << 15;
10103 /* Fall thru. */
10105 case R_PPC64_REL24:
10106 /* Calls to functions with a different TOC, such as calls to
10107 shared objects, need to alter the TOC pointer. This is
10108 done using a linkage stub. A REL24 branching to these
10109 linkage stubs needs to be followed by a nop, as the nop
10110 will be replaced with an instruction to restore the TOC
10111 base pointer. */
10112 stub_entry = NULL;
10113 fdh = h;
10114 if (((h != NULL
10115 && (((fdh = h->oh) != NULL
10116 && fdh->elf.plt.plist != NULL)
10117 || (fdh = h)->elf.plt.plist != NULL))
10118 || (sec != NULL
10119 && sec->output_section != NULL
10120 && sec->id <= htab->top_id
10121 && (htab->stub_group[sec->id].toc_off
10122 != htab->stub_group[input_section->id].toc_off)))
10123 && (stub_entry = ppc_get_stub_entry (input_section, sec, fdh,
10124 rel, htab)) != NULL
10125 && (stub_entry->stub_type == ppc_stub_plt_call
10126 || stub_entry->stub_type == ppc_stub_plt_branch_r2off
10127 || stub_entry->stub_type == ppc_stub_long_branch_r2off))
10129 bfd_boolean can_plt_call = FALSE;
10131 if (rel->r_offset + 8 <= input_section->size)
10133 unsigned long nop;
10134 nop = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
10135 if (nop == NOP
10136 || nop == CROR_151515 || nop == CROR_313131)
10138 bfd_put_32 (input_bfd, LD_R2_40R1,
10139 contents + rel->r_offset + 4);
10140 can_plt_call = TRUE;
10144 if (!can_plt_call)
10146 if (stub_entry->stub_type == ppc_stub_plt_call)
10148 /* If this is a plain branch rather than a branch
10149 and link, don't require a nop. However, don't
10150 allow tail calls in a shared library as they
10151 will result in r2 being corrupted. */
10152 unsigned long br;
10153 br = bfd_get_32 (input_bfd, contents + rel->r_offset);
10154 if (info->executable && (br & 1) == 0)
10155 can_plt_call = TRUE;
10156 else
10157 stub_entry = NULL;
10159 else if (h != NULL
10160 && strcmp (h->elf.root.root.string,
10161 ".__libc_start_main") == 0)
10163 /* Allow crt1 branch to go via a toc adjusting stub. */
10164 can_plt_call = TRUE;
10166 else
10168 if (strcmp (input_section->output_section->name,
10169 ".init") == 0
10170 || strcmp (input_section->output_section->name,
10171 ".fini") == 0)
10172 (*_bfd_error_handler)
10173 (_("%B(%A+0x%lx): automatic multiple TOCs "
10174 "not supported using your crt files; "
10175 "recompile with -mminimal-toc or upgrade gcc"),
10176 input_bfd,
10177 input_section,
10178 (long) rel->r_offset);
10179 else
10180 (*_bfd_error_handler)
10181 (_("%B(%A+0x%lx): sibling call optimization to `%s' "
10182 "does not allow automatic multiple TOCs; "
10183 "recompile with -mminimal-toc or "
10184 "-fno-optimize-sibling-calls, "
10185 "or make `%s' extern"),
10186 input_bfd,
10187 input_section,
10188 (long) rel->r_offset,
10189 sym_name,
10190 sym_name);
10191 bfd_set_error (bfd_error_bad_value);
10192 ret = FALSE;
10196 if (can_plt_call
10197 && stub_entry->stub_type == ppc_stub_plt_call)
10198 unresolved_reloc = FALSE;
10201 if (stub_entry == NULL
10202 && get_opd_info (sec) != NULL)
10204 /* The branch destination is the value of the opd entry. */
10205 bfd_vma off = (relocation + addend
10206 - sec->output_section->vma
10207 - sec->output_offset);
10208 bfd_vma dest = opd_entry_value (sec, off, NULL, NULL);
10209 if (dest != (bfd_vma) -1)
10211 relocation = dest;
10212 addend = 0;
10216 /* If the branch is out of reach we ought to have a long
10217 branch stub. */
10218 from = (rel->r_offset
10219 + input_section->output_offset
10220 + input_section->output_section->vma);
10222 if (stub_entry == NULL
10223 && (relocation + addend - from + max_br_offset
10224 >= 2 * max_br_offset)
10225 && r_type != R_PPC64_ADDR14_BRTAKEN
10226 && r_type != R_PPC64_ADDR14_BRNTAKEN)
10227 stub_entry = ppc_get_stub_entry (input_section, sec, h, rel,
10228 htab);
10230 if (stub_entry != NULL)
10232 /* Munge up the value and addend so that we call the stub
10233 rather than the procedure directly. */
10234 relocation = (stub_entry->stub_offset
10235 + stub_entry->stub_sec->output_offset
10236 + stub_entry->stub_sec->output_section->vma);
10237 addend = 0;
10240 if (insn != 0)
10242 if (is_power4)
10244 /* Set 'a' bit. This is 0b00010 in BO field for branch
10245 on CR(BI) insns (BO == 001at or 011at), and 0b01000
10246 for branch on CTR insns (BO == 1a00t or 1a01t). */
10247 if ((insn & (0x14 << 21)) == (0x04 << 21))
10248 insn |= 0x02 << 21;
10249 else if ((insn & (0x14 << 21)) == (0x10 << 21))
10250 insn |= 0x08 << 21;
10251 else
10252 break;
10254 else
10256 /* Invert 'y' bit if not the default. */
10257 if ((bfd_signed_vma) (relocation + addend - from) < 0)
10258 insn ^= 0x01 << 21;
10261 bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
10264 /* NOP out calls to undefined weak functions.
10265 We can thus call a weak function without first
10266 checking whether the function is defined. */
10267 else if (h != NULL
10268 && h->elf.root.type == bfd_link_hash_undefweak
10269 && r_type == R_PPC64_REL24
10270 && relocation == 0
10271 && addend == 0)
10273 bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
10274 continue;
10276 break;
10279 /* Set `addend'. */
10280 tls_type = 0;
10281 switch (r_type)
10283 default:
10284 (*_bfd_error_handler)
10285 (_("%B: unknown relocation type %d for symbol %s"),
10286 input_bfd, (int) r_type, sym_name);
10288 bfd_set_error (bfd_error_bad_value);
10289 ret = FALSE;
10290 continue;
10292 case R_PPC64_NONE:
10293 case R_PPC64_TLS:
10294 case R_PPC64_GNU_VTINHERIT:
10295 case R_PPC64_GNU_VTENTRY:
10296 continue;
10298 /* GOT16 relocations. Like an ADDR16 using the symbol's
10299 address in the GOT as relocation value instead of the
10300 symbol's value itself. Also, create a GOT entry for the
10301 symbol and put the symbol value there. */
10302 case R_PPC64_GOT_TLSGD16:
10303 case R_PPC64_GOT_TLSGD16_LO:
10304 case R_PPC64_GOT_TLSGD16_HI:
10305 case R_PPC64_GOT_TLSGD16_HA:
10306 tls_type = TLS_TLS | TLS_GD;
10307 goto dogot;
10309 case R_PPC64_GOT_TLSLD16:
10310 case R_PPC64_GOT_TLSLD16_LO:
10311 case R_PPC64_GOT_TLSLD16_HI:
10312 case R_PPC64_GOT_TLSLD16_HA:
10313 tls_type = TLS_TLS | TLS_LD;
10314 goto dogot;
10316 case R_PPC64_GOT_TPREL16_DS:
10317 case R_PPC64_GOT_TPREL16_LO_DS:
10318 case R_PPC64_GOT_TPREL16_HI:
10319 case R_PPC64_GOT_TPREL16_HA:
10320 tls_type = TLS_TLS | TLS_TPREL;
10321 goto dogot;
10323 case R_PPC64_GOT_DTPREL16_DS:
10324 case R_PPC64_GOT_DTPREL16_LO_DS:
10325 case R_PPC64_GOT_DTPREL16_HI:
10326 case R_PPC64_GOT_DTPREL16_HA:
10327 tls_type = TLS_TLS | TLS_DTPREL;
10328 goto dogot;
10330 case R_PPC64_GOT16:
10331 case R_PPC64_GOT16_LO:
10332 case R_PPC64_GOT16_HI:
10333 case R_PPC64_GOT16_HA:
10334 case R_PPC64_GOT16_DS:
10335 case R_PPC64_GOT16_LO_DS:
10336 dogot:
10338 /* Relocation is to the entry for this symbol in the global
10339 offset table. */
10340 asection *got;
10341 bfd_vma *offp;
10342 bfd_vma off;
10343 unsigned long indx = 0;
10345 if (tls_type == (TLS_TLS | TLS_LD)
10346 && (h == NULL
10347 || !h->elf.def_dynamic))
10348 offp = &ppc64_tlsld_got (input_bfd)->offset;
10349 else
10351 struct got_entry *ent;
10353 if (h != NULL)
10355 bfd_boolean dyn = htab->elf.dynamic_sections_created;
10356 if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared,
10357 &h->elf)
10358 || (info->shared
10359 && SYMBOL_REFERENCES_LOCAL (info, &h->elf)))
10360 /* This is actually a static link, or it is a
10361 -Bsymbolic link and the symbol is defined
10362 locally, or the symbol was forced to be local
10363 because of a version file. */
10365 else
10367 indx = h->elf.dynindx;
10368 unresolved_reloc = FALSE;
10370 ent = h->elf.got.glist;
10372 else
10374 if (local_got_ents == NULL)
10375 abort ();
10376 ent = local_got_ents[r_symndx];
10379 for (; ent != NULL; ent = ent->next)
10380 if (ent->addend == orig_addend
10381 && ent->owner == input_bfd
10382 && ent->tls_type == tls_type)
10383 break;
10384 if (ent == NULL)
10385 abort ();
10386 offp = &ent->got.offset;
10389 got = ppc64_elf_tdata (input_bfd)->got;
10390 if (got == NULL)
10391 abort ();
10393 /* The offset must always be a multiple of 8. We use the
10394 least significant bit to record whether we have already
10395 processed this entry. */
10396 off = *offp;
10397 if ((off & 1) != 0)
10398 off &= ~1;
10399 else
10401 /* Generate relocs for the dynamic linker, except in
10402 the case of TLSLD where we'll use one entry per
10403 module. */
10404 asection *relgot = ppc64_elf_tdata (input_bfd)->relgot;
10406 *offp = off | 1;
10407 if ((info->shared || indx != 0)
10408 && (h == NULL
10409 || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
10410 || h->elf.root.type != bfd_link_hash_undefweak))
10412 outrel.r_offset = (got->output_section->vma
10413 + got->output_offset
10414 + off);
10415 outrel.r_addend = addend;
10416 if (tls_type & (TLS_LD | TLS_GD))
10418 outrel.r_addend = 0;
10419 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPMOD64);
10420 if (tls_type == (TLS_TLS | TLS_GD))
10422 loc = relgot->contents;
10423 loc += (relgot->reloc_count++
10424 * sizeof (Elf64_External_Rela));
10425 bfd_elf64_swap_reloca_out (output_bfd,
10426 &outrel, loc);
10427 outrel.r_offset += 8;
10428 outrel.r_addend = addend;
10429 outrel.r_info
10430 = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
10433 else if (tls_type == (TLS_TLS | TLS_DTPREL))
10434 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
10435 else if (tls_type == (TLS_TLS | TLS_TPREL))
10436 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_TPREL64);
10437 else if (indx == 0)
10439 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_RELATIVE);
10441 /* Write the .got section contents for the sake
10442 of prelink. */
10443 loc = got->contents + off;
10444 bfd_put_64 (output_bfd, outrel.r_addend + relocation,
10445 loc);
10447 else
10448 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_GLOB_DAT);
10450 if (indx == 0 && tls_type != (TLS_TLS | TLS_LD))
10452 outrel.r_addend += relocation;
10453 if (tls_type & (TLS_GD | TLS_DTPREL | TLS_TPREL))
10454 outrel.r_addend -= htab->elf.tls_sec->vma;
10456 loc = relgot->contents;
10457 loc += (relgot->reloc_count++
10458 * sizeof (Elf64_External_Rela));
10459 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
10462 /* Init the .got section contents here if we're not
10463 emitting a reloc. */
10464 else
10466 relocation += addend;
10467 if (tls_type == (TLS_TLS | TLS_LD))
10468 relocation = 1;
10469 else if (tls_type != 0)
10471 relocation -= htab->elf.tls_sec->vma + DTP_OFFSET;
10472 if (tls_type == (TLS_TLS | TLS_TPREL))
10473 relocation += DTP_OFFSET - TP_OFFSET;
10475 if (tls_type == (TLS_TLS | TLS_GD))
10477 bfd_put_64 (output_bfd, relocation,
10478 got->contents + off + 8);
10479 relocation = 1;
10483 bfd_put_64 (output_bfd, relocation,
10484 got->contents + off);
10488 if (off >= (bfd_vma) -2)
10489 abort ();
10491 relocation = got->output_offset + off;
10493 /* TOC base (r2) is TOC start plus 0x8000. */
10494 addend = -TOC_BASE_OFF;
10496 break;
10498 case R_PPC64_PLT16_HA:
10499 case R_PPC64_PLT16_HI:
10500 case R_PPC64_PLT16_LO:
10501 case R_PPC64_PLT32:
10502 case R_PPC64_PLT64:
10503 /* Relocation is to the entry for this symbol in the
10504 procedure linkage table. */
10506 /* Resolve a PLT reloc against a local symbol directly,
10507 without using the procedure linkage table. */
10508 if (h == NULL)
10509 break;
10511 /* It's possible that we didn't make a PLT entry for this
10512 symbol. This happens when statically linking PIC code,
10513 or when using -Bsymbolic. Go find a match if there is a
10514 PLT entry. */
10515 if (htab->plt != NULL)
10517 struct plt_entry *ent;
10518 for (ent = h->elf.plt.plist; ent != NULL; ent = ent->next)
10519 if (ent->addend == orig_addend
10520 && ent->plt.offset != (bfd_vma) -1)
10522 relocation = (htab->plt->output_section->vma
10523 + htab->plt->output_offset
10524 + ent->plt.offset);
10525 unresolved_reloc = FALSE;
10528 break;
10530 case R_PPC64_TOC:
10531 /* Relocation value is TOC base. */
10532 relocation = TOCstart;
10533 if (r_symndx == 0)
10534 relocation += htab->stub_group[input_section->id].toc_off;
10535 else if (unresolved_reloc)
10537 else if (sec != NULL && sec->id <= htab->top_id)
10538 relocation += htab->stub_group[sec->id].toc_off;
10539 else
10540 unresolved_reloc = TRUE;
10541 goto dodyn2;
10543 /* TOC16 relocs. We want the offset relative to the TOC base,
10544 which is the address of the start of the TOC plus 0x8000.
10545 The TOC consists of sections .got, .toc, .tocbss, and .plt,
10546 in this order. */
10547 case R_PPC64_TOC16:
10548 case R_PPC64_TOC16_LO:
10549 case R_PPC64_TOC16_HI:
10550 case R_PPC64_TOC16_DS:
10551 case R_PPC64_TOC16_LO_DS:
10552 case R_PPC64_TOC16_HA:
10553 addend -= TOCstart + htab->stub_group[input_section->id].toc_off;
10554 break;
10556 /* Relocate against the beginning of the section. */
10557 case R_PPC64_SECTOFF:
10558 case R_PPC64_SECTOFF_LO:
10559 case R_PPC64_SECTOFF_HI:
10560 case R_PPC64_SECTOFF_DS:
10561 case R_PPC64_SECTOFF_LO_DS:
10562 case R_PPC64_SECTOFF_HA:
10563 if (sec != NULL)
10564 addend -= sec->output_section->vma;
10565 break;
10567 case R_PPC64_REL14:
10568 case R_PPC64_REL14_BRNTAKEN:
10569 case R_PPC64_REL14_BRTAKEN:
10570 case R_PPC64_REL24:
10571 break;
10573 case R_PPC64_TPREL16:
10574 case R_PPC64_TPREL16_LO:
10575 case R_PPC64_TPREL16_HI:
10576 case R_PPC64_TPREL16_HA:
10577 case R_PPC64_TPREL16_DS:
10578 case R_PPC64_TPREL16_LO_DS:
10579 case R_PPC64_TPREL16_HIGHER:
10580 case R_PPC64_TPREL16_HIGHERA:
10581 case R_PPC64_TPREL16_HIGHEST:
10582 case R_PPC64_TPREL16_HIGHESTA:
10583 addend -= htab->elf.tls_sec->vma + TP_OFFSET;
10584 if (info->shared)
10585 /* The TPREL16 relocs shouldn't really be used in shared
10586 libs as they will result in DT_TEXTREL being set, but
10587 support them anyway. */
10588 goto dodyn;
10589 break;
10591 case R_PPC64_DTPREL16:
10592 case R_PPC64_DTPREL16_LO:
10593 case R_PPC64_DTPREL16_HI:
10594 case R_PPC64_DTPREL16_HA:
10595 case R_PPC64_DTPREL16_DS:
10596 case R_PPC64_DTPREL16_LO_DS:
10597 case R_PPC64_DTPREL16_HIGHER:
10598 case R_PPC64_DTPREL16_HIGHERA:
10599 case R_PPC64_DTPREL16_HIGHEST:
10600 case R_PPC64_DTPREL16_HIGHESTA:
10601 addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
10602 break;
10604 case R_PPC64_DTPMOD64:
10605 relocation = 1;
10606 addend = 0;
10607 goto dodyn;
10609 case R_PPC64_TPREL64:
10610 addend -= htab->elf.tls_sec->vma + TP_OFFSET;
10611 goto dodyn;
10613 case R_PPC64_DTPREL64:
10614 addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
10615 /* Fall thru */
10617 /* Relocations that may need to be propagated if this is a
10618 dynamic object. */
10619 case R_PPC64_REL30:
10620 case R_PPC64_REL32:
10621 case R_PPC64_REL64:
10622 case R_PPC64_ADDR14:
10623 case R_PPC64_ADDR14_BRNTAKEN:
10624 case R_PPC64_ADDR14_BRTAKEN:
10625 case R_PPC64_ADDR16:
10626 case R_PPC64_ADDR16_DS:
10627 case R_PPC64_ADDR16_HA:
10628 case R_PPC64_ADDR16_HI:
10629 case R_PPC64_ADDR16_HIGHER:
10630 case R_PPC64_ADDR16_HIGHERA:
10631 case R_PPC64_ADDR16_HIGHEST:
10632 case R_PPC64_ADDR16_HIGHESTA:
10633 case R_PPC64_ADDR16_LO:
10634 case R_PPC64_ADDR16_LO_DS:
10635 case R_PPC64_ADDR24:
10636 case R_PPC64_ADDR32:
10637 case R_PPC64_ADDR64:
10638 case R_PPC64_UADDR16:
10639 case R_PPC64_UADDR32:
10640 case R_PPC64_UADDR64:
10641 /* r_symndx will be zero only for relocs against symbols
10642 from removed linkonce sections, or sections discarded by
10643 a linker script. */
10644 dodyn:
10645 if (r_symndx == 0)
10646 break;
10647 /* Fall thru. */
10649 dodyn2:
10650 if ((input_section->flags & SEC_ALLOC) == 0)
10651 break;
10653 if (NO_OPD_RELOCS && is_opd)
10654 break;
10656 if ((info->shared
10657 && (h == NULL
10658 || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
10659 || h->elf.root.type != bfd_link_hash_undefweak)
10660 && (MUST_BE_DYN_RELOC (r_type)
10661 || !SYMBOL_CALLS_LOCAL (info, &h->elf)))
10662 || (ELIMINATE_COPY_RELOCS
10663 && !info->shared
10664 && h != NULL
10665 && h->elf.dynindx != -1
10666 && !h->elf.non_got_ref
10667 && h->elf.def_dynamic
10668 && !h->elf.def_regular))
10670 Elf_Internal_Rela outrel;
10671 bfd_boolean skip, relocate;
10672 asection *sreloc;
10673 bfd_byte *loc;
10674 bfd_vma out_off;
10676 /* When generating a dynamic object, these relocations
10677 are copied into the output file to be resolved at run
10678 time. */
10680 skip = FALSE;
10681 relocate = FALSE;
10683 out_off = _bfd_elf_section_offset (output_bfd, info,
10684 input_section, rel->r_offset);
10685 if (out_off == (bfd_vma) -1)
10686 skip = TRUE;
10687 else if (out_off == (bfd_vma) -2)
10688 skip = TRUE, relocate = TRUE;
10689 out_off += (input_section->output_section->vma
10690 + input_section->output_offset);
10691 outrel.r_offset = out_off;
10692 outrel.r_addend = rel->r_addend;
10694 /* Optimize unaligned reloc use. */
10695 if ((r_type == R_PPC64_ADDR64 && (out_off & 7) != 0)
10696 || (r_type == R_PPC64_UADDR64 && (out_off & 7) == 0))
10697 r_type ^= R_PPC64_ADDR64 ^ R_PPC64_UADDR64;
10698 else if ((r_type == R_PPC64_ADDR32 && (out_off & 3) != 0)
10699 || (r_type == R_PPC64_UADDR32 && (out_off & 3) == 0))
10700 r_type ^= R_PPC64_ADDR32 ^ R_PPC64_UADDR32;
10701 else if ((r_type == R_PPC64_ADDR16 && (out_off & 1) != 0)
10702 || (r_type == R_PPC64_UADDR16 && (out_off & 1) == 0))
10703 r_type ^= R_PPC64_ADDR16 ^ R_PPC64_UADDR16;
10705 if (skip)
10706 memset (&outrel, 0, sizeof outrel);
10707 else if (!SYMBOL_REFERENCES_LOCAL (info, &h->elf)
10708 && !is_opd
10709 && r_type != R_PPC64_TOC)
10710 outrel.r_info = ELF64_R_INFO (h->elf.dynindx, r_type);
10711 else
10713 /* This symbol is local, or marked to become local,
10714 or this is an opd section reloc which must point
10715 at a local function. */
10716 outrel.r_addend += relocation;
10717 if (r_type == R_PPC64_ADDR64 || r_type == R_PPC64_TOC)
10719 if (is_opd && h != NULL)
10721 /* Lie about opd entries. This case occurs
10722 when building shared libraries and we
10723 reference a function in another shared
10724 lib. The same thing happens for a weak
10725 definition in an application that's
10726 overridden by a strong definition in a
10727 shared lib. (I believe this is a generic
10728 bug in binutils handling of weak syms.)
10729 In these cases we won't use the opd
10730 entry in this lib. */
10731 unresolved_reloc = FALSE;
10733 outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
10735 /* We need to relocate .opd contents for ld.so.
10736 Prelink also wants simple and consistent rules
10737 for relocs. This make all RELATIVE relocs have
10738 *r_offset equal to r_addend. */
10739 relocate = TRUE;
10741 else
10743 long indx = 0;
10745 if (bfd_is_abs_section (sec))
10747 else if (sec == NULL || sec->owner == NULL)
10749 bfd_set_error (bfd_error_bad_value);
10750 return FALSE;
10752 else
10754 asection *osec;
10756 osec = sec->output_section;
10757 indx = elf_section_data (osec)->dynindx;
10759 /* We are turning this relocation into one
10760 against a section symbol, so subtract out
10761 the output section's address but not the
10762 offset of the input section in the output
10763 section. */
10764 outrel.r_addend -= osec->vma;
10767 outrel.r_info = ELF64_R_INFO (indx, r_type);
10771 sreloc = elf_section_data (input_section)->sreloc;
10772 if (sreloc == NULL)
10773 abort ();
10775 if (sreloc->reloc_count * sizeof (Elf64_External_Rela)
10776 >= sreloc->size)
10777 abort ();
10778 loc = sreloc->contents;
10779 loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
10780 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
10782 /* If this reloc is against an external symbol, it will
10783 be computed at runtime, so there's no need to do
10784 anything now. However, for the sake of prelink ensure
10785 that the section contents are a known value. */
10786 if (! relocate)
10788 unresolved_reloc = FALSE;
10789 /* The value chosen here is quite arbitrary as ld.so
10790 ignores section contents except for the special
10791 case of .opd where the contents might be accessed
10792 before relocation. Choose zero, as that won't
10793 cause reloc overflow. */
10794 relocation = 0;
10795 addend = 0;
10796 /* Use *r_offset == r_addend for R_PPC64_ADDR64 relocs
10797 to improve backward compatibility with older
10798 versions of ld. */
10799 if (r_type == R_PPC64_ADDR64)
10800 addend = outrel.r_addend;
10801 /* Adjust pc_relative relocs to have zero in *r_offset. */
10802 else if (ppc64_elf_howto_table[r_type]->pc_relative)
10803 addend = (input_section->output_section->vma
10804 + input_section->output_offset
10805 + rel->r_offset);
10808 break;
10810 case R_PPC64_COPY:
10811 case R_PPC64_GLOB_DAT:
10812 case R_PPC64_JMP_SLOT:
10813 case R_PPC64_RELATIVE:
10814 /* We shouldn't ever see these dynamic relocs in relocatable
10815 files. */
10816 /* Fall through. */
10818 case R_PPC64_PLTGOT16:
10819 case R_PPC64_PLTGOT16_DS:
10820 case R_PPC64_PLTGOT16_HA:
10821 case R_PPC64_PLTGOT16_HI:
10822 case R_PPC64_PLTGOT16_LO:
10823 case R_PPC64_PLTGOT16_LO_DS:
10824 case R_PPC64_PLTREL32:
10825 case R_PPC64_PLTREL64:
10826 /* These ones haven't been implemented yet. */
10828 (*_bfd_error_handler)
10829 (_("%B: relocation %s is not supported for symbol %s."),
10830 input_bfd,
10831 ppc64_elf_howto_table[r_type]->name, sym_name);
10833 bfd_set_error (bfd_error_invalid_operation);
10834 ret = FALSE;
10835 continue;
10838 /* Do any further special processing. */
10839 switch (r_type)
10841 default:
10842 break;
10844 case R_PPC64_ADDR16_HA:
10845 case R_PPC64_ADDR16_HIGHERA:
10846 case R_PPC64_ADDR16_HIGHESTA:
10847 case R_PPC64_GOT16_HA:
10848 case R_PPC64_PLTGOT16_HA:
10849 case R_PPC64_PLT16_HA:
10850 case R_PPC64_TOC16_HA:
10851 case R_PPC64_SECTOFF_HA:
10852 case R_PPC64_TPREL16_HA:
10853 case R_PPC64_DTPREL16_HA:
10854 case R_PPC64_GOT_TLSGD16_HA:
10855 case R_PPC64_GOT_TLSLD16_HA:
10856 case R_PPC64_GOT_TPREL16_HA:
10857 case R_PPC64_GOT_DTPREL16_HA:
10858 case R_PPC64_TPREL16_HIGHER:
10859 case R_PPC64_TPREL16_HIGHERA:
10860 case R_PPC64_TPREL16_HIGHEST:
10861 case R_PPC64_TPREL16_HIGHESTA:
10862 case R_PPC64_DTPREL16_HIGHER:
10863 case R_PPC64_DTPREL16_HIGHERA:
10864 case R_PPC64_DTPREL16_HIGHEST:
10865 case R_PPC64_DTPREL16_HIGHESTA:
10866 /* It's just possible that this symbol is a weak symbol
10867 that's not actually defined anywhere. In that case,
10868 'sec' would be NULL, and we should leave the symbol
10869 alone (it will be set to zero elsewhere in the link). */
10870 if (sec != NULL)
10871 /* Add 0x10000 if sign bit in 0:15 is set.
10872 Bits 0:15 are not used. */
10873 addend += 0x8000;
10874 break;
10876 case R_PPC64_ADDR16_DS:
10877 case R_PPC64_ADDR16_LO_DS:
10878 case R_PPC64_GOT16_DS:
10879 case R_PPC64_GOT16_LO_DS:
10880 case R_PPC64_PLT16_LO_DS:
10881 case R_PPC64_SECTOFF_DS:
10882 case R_PPC64_SECTOFF_LO_DS:
10883 case R_PPC64_TOC16_DS:
10884 case R_PPC64_TOC16_LO_DS:
10885 case R_PPC64_PLTGOT16_DS:
10886 case R_PPC64_PLTGOT16_LO_DS:
10887 case R_PPC64_GOT_TPREL16_DS:
10888 case R_PPC64_GOT_TPREL16_LO_DS:
10889 case R_PPC64_GOT_DTPREL16_DS:
10890 case R_PPC64_GOT_DTPREL16_LO_DS:
10891 case R_PPC64_TPREL16_DS:
10892 case R_PPC64_TPREL16_LO_DS:
10893 case R_PPC64_DTPREL16_DS:
10894 case R_PPC64_DTPREL16_LO_DS:
10895 insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
10896 mask = 3;
10897 /* If this reloc is against an lq insn, then the value must be
10898 a multiple of 16. This is somewhat of a hack, but the
10899 "correct" way to do this by defining _DQ forms of all the
10900 _DS relocs bloats all reloc switches in this file. It
10901 doesn't seem to make much sense to use any of these relocs
10902 in data, so testing the insn should be safe. */
10903 if ((insn & (0x3f << 26)) == (56u << 26))
10904 mask = 15;
10905 if (((relocation + addend) & mask) != 0)
10907 (*_bfd_error_handler)
10908 (_("%B: error: relocation %s not a multiple of %d"),
10909 input_bfd,
10910 ppc64_elf_howto_table[r_type]->name,
10911 mask + 1);
10912 bfd_set_error (bfd_error_bad_value);
10913 ret = FALSE;
10914 continue;
10916 break;
10919 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
10920 because such sections are not SEC_ALLOC and thus ld.so will
10921 not process them. */
10922 if (unresolved_reloc
10923 && !((input_section->flags & SEC_DEBUGGING) != 0
10924 && h->elf.def_dynamic))
10926 (*_bfd_error_handler)
10927 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
10928 input_bfd,
10929 input_section,
10930 (long) rel->r_offset,
10931 ppc64_elf_howto_table[(int) r_type]->name,
10932 h->elf.root.root.string);
10933 ret = FALSE;
10936 r = _bfd_final_link_relocate (ppc64_elf_howto_table[(int) r_type],
10937 input_bfd,
10938 input_section,
10939 contents,
10940 rel->r_offset,
10941 relocation,
10942 addend);
10944 if (r != bfd_reloc_ok)
10946 if (sym_name == NULL)
10947 sym_name = "(null)";
10948 if (r == bfd_reloc_overflow)
10950 if (warned)
10951 continue;
10952 if (h != NULL
10953 && h->elf.root.type == bfd_link_hash_undefweak
10954 && ppc64_elf_howto_table[r_type]->pc_relative)
10956 /* Assume this is a call protected by other code that
10957 detects the symbol is undefined. If this is the case,
10958 we can safely ignore the overflow. If not, the
10959 program is hosed anyway, and a little warning isn't
10960 going to help. */
10962 continue;
10965 if (!((*info->callbacks->reloc_overflow)
10966 (info, (h ? &h->elf.root : NULL), sym_name,
10967 ppc64_elf_howto_table[r_type]->name,
10968 orig_addend, input_bfd, input_section, rel->r_offset)))
10969 return FALSE;
10971 else
10973 (*_bfd_error_handler)
10974 (_("%B(%A+0x%lx): %s reloc against `%s': error %d"),
10975 input_bfd,
10976 input_section,
10977 (long) rel->r_offset,
10978 ppc64_elf_howto_table[r_type]->name,
10979 sym_name,
10980 (int) r);
10981 ret = FALSE;
10986 /* If we're emitting relocations, then shortly after this function
10987 returns, reloc offsets and addends for this section will be
10988 adjusted. Worse, reloc symbol indices will be for the output
10989 file rather than the input. Save a copy of the relocs for
10990 opd_entry_value. */
10991 if (is_opd && (info->emitrelocations || info->relocatable))
10993 bfd_size_type amt;
10994 amt = input_section->reloc_count * sizeof (Elf_Internal_Rela);
10995 rel = bfd_alloc (input_bfd, amt);
10996 BFD_ASSERT (ppc64_elf_tdata (input_bfd)->opd_relocs == NULL);
10997 ppc64_elf_tdata (input_bfd)->opd_relocs = rel;
10998 if (rel == NULL)
10999 return FALSE;
11000 memcpy (rel, relocs, amt);
11002 return ret;
11005 /* Adjust the value of any local symbols in opd sections. */
11007 static bfd_boolean
11008 ppc64_elf_output_symbol_hook (struct bfd_link_info *info,
11009 const char *name ATTRIBUTE_UNUSED,
11010 Elf_Internal_Sym *elfsym,
11011 asection *input_sec,
11012 struct elf_link_hash_entry *h)
11014 long *opd_adjust, adjust;
11015 bfd_vma value;
11017 if (h != NULL)
11018 return TRUE;
11020 opd_adjust = get_opd_info (input_sec);
11021 if (opd_adjust == NULL)
11022 return TRUE;
11024 value = elfsym->st_value - input_sec->output_offset;
11025 if (!info->relocatable)
11026 value -= input_sec->output_section->vma;
11028 adjust = opd_adjust[value / 8];
11029 if (adjust == -1)
11030 elfsym->st_value = 0;
11031 else
11032 elfsym->st_value += adjust;
11033 return TRUE;
11036 /* Finish up dynamic symbol handling. We set the contents of various
11037 dynamic sections here. */
11039 static bfd_boolean
11040 ppc64_elf_finish_dynamic_symbol (bfd *output_bfd,
11041 struct bfd_link_info *info,
11042 struct elf_link_hash_entry *h,
11043 Elf_Internal_Sym *sym)
11045 struct ppc_link_hash_table *htab;
11046 bfd *dynobj;
11047 struct plt_entry *ent;
11048 Elf_Internal_Rela rela;
11049 bfd_byte *loc;
11051 htab = ppc_hash_table (info);
11052 dynobj = htab->elf.dynobj;
11054 for (ent = h->plt.plist; ent != NULL; ent = ent->next)
11055 if (ent->plt.offset != (bfd_vma) -1)
11057 /* This symbol has an entry in the procedure linkage
11058 table. Set it up. */
11060 if (htab->plt == NULL
11061 || htab->relplt == NULL
11062 || htab->glink == NULL)
11063 abort ();
11065 /* Create a JMP_SLOT reloc to inform the dynamic linker to
11066 fill in the PLT entry. */
11067 rela.r_offset = (htab->plt->output_section->vma
11068 + htab->plt->output_offset
11069 + ent->plt.offset);
11070 rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_JMP_SLOT);
11071 rela.r_addend = ent->addend;
11073 loc = htab->relplt->contents;
11074 loc += ((ent->plt.offset - PLT_INITIAL_ENTRY_SIZE) / PLT_ENTRY_SIZE
11075 * sizeof (Elf64_External_Rela));
11076 bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
11079 if (h->needs_copy)
11081 Elf_Internal_Rela rela;
11082 bfd_byte *loc;
11084 /* This symbol needs a copy reloc. Set it up. */
11086 if (h->dynindx == -1
11087 || (h->root.type != bfd_link_hash_defined
11088 && h->root.type != bfd_link_hash_defweak)
11089 || htab->relbss == NULL)
11090 abort ();
11092 rela.r_offset = (h->root.u.def.value
11093 + h->root.u.def.section->output_section->vma
11094 + h->root.u.def.section->output_offset);
11095 rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_COPY);
11096 rela.r_addend = 0;
11097 loc = htab->relbss->contents;
11098 loc += htab->relbss->reloc_count++ * sizeof (Elf64_External_Rela);
11099 bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
11102 /* Mark some specially defined symbols as absolute. */
11103 if (strcmp (h->root.root.string, "_DYNAMIC") == 0)
11104 sym->st_shndx = SHN_ABS;
11106 return TRUE;
11109 /* Used to decide how to sort relocs in an optimal manner for the
11110 dynamic linker, before writing them out. */
11112 static enum elf_reloc_type_class
11113 ppc64_elf_reloc_type_class (const Elf_Internal_Rela *rela)
11115 enum elf_ppc64_reloc_type r_type;
11117 r_type = ELF64_R_TYPE (rela->r_info);
11118 switch (r_type)
11120 case R_PPC64_RELATIVE:
11121 return reloc_class_relative;
11122 case R_PPC64_JMP_SLOT:
11123 return reloc_class_plt;
11124 case R_PPC64_COPY:
11125 return reloc_class_copy;
11126 default:
11127 return reloc_class_normal;
11131 /* Finish up the dynamic sections. */
11133 static bfd_boolean
11134 ppc64_elf_finish_dynamic_sections (bfd *output_bfd,
11135 struct bfd_link_info *info)
11137 struct ppc_link_hash_table *htab;
11138 bfd *dynobj;
11139 asection *sdyn;
11141 htab = ppc_hash_table (info);
11142 dynobj = htab->elf.dynobj;
11143 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
11145 if (htab->elf.dynamic_sections_created)
11147 Elf64_External_Dyn *dyncon, *dynconend;
11149 if (sdyn == NULL || htab->got == NULL)
11150 abort ();
11152 dyncon = (Elf64_External_Dyn *) sdyn->contents;
11153 dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
11154 for (; dyncon < dynconend; dyncon++)
11156 Elf_Internal_Dyn dyn;
11157 asection *s;
11159 bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
11161 switch (dyn.d_tag)
11163 default:
11164 continue;
11166 case DT_PPC64_GLINK:
11167 s = htab->glink;
11168 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
11169 /* We stupidly defined DT_PPC64_GLINK to be the start
11170 of glink rather than the first entry point, which is
11171 what ld.so needs, and now have a bigger stub to
11172 support automatic multiple TOCs. */
11173 dyn.d_un.d_ptr += GLINK_CALL_STUB_SIZE - 32;
11174 break;
11176 case DT_PPC64_OPD:
11177 s = bfd_get_section_by_name (output_bfd, ".opd");
11178 if (s == NULL)
11179 continue;
11180 dyn.d_un.d_ptr = s->vma;
11181 break;
11183 case DT_PPC64_OPDSZ:
11184 s = bfd_get_section_by_name (output_bfd, ".opd");
11185 if (s == NULL)
11186 continue;
11187 dyn.d_un.d_val = s->size;
11188 break;
11190 case DT_PLTGOT:
11191 s = htab->plt;
11192 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
11193 break;
11195 case DT_JMPREL:
11196 s = htab->relplt;
11197 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
11198 break;
11200 case DT_PLTRELSZ:
11201 dyn.d_un.d_val = htab->relplt->size;
11202 break;
11204 case DT_RELASZ:
11205 /* Don't count procedure linkage table relocs in the
11206 overall reloc count. */
11207 s = htab->relplt;
11208 if (s == NULL)
11209 continue;
11210 dyn.d_un.d_val -= s->size;
11211 break;
11213 case DT_RELA:
11214 /* We may not be using the standard ELF linker script.
11215 If .rela.plt is the first .rela section, we adjust
11216 DT_RELA to not include it. */
11217 s = htab->relplt;
11218 if (s == NULL)
11219 continue;
11220 if (dyn.d_un.d_ptr != s->output_section->vma + s->output_offset)
11221 continue;
11222 dyn.d_un.d_ptr += s->size;
11223 break;
11226 bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
11230 if (htab->got != NULL && htab->got->size != 0)
11232 /* Fill in the first entry in the global offset table.
11233 We use it to hold the link-time TOCbase. */
11234 bfd_put_64 (output_bfd,
11235 elf_gp (output_bfd) + TOC_BASE_OFF,
11236 htab->got->contents);
11238 /* Set .got entry size. */
11239 elf_section_data (htab->got->output_section)->this_hdr.sh_entsize = 8;
11242 if (htab->plt != NULL && htab->plt->size != 0)
11244 /* Set .plt entry size. */
11245 elf_section_data (htab->plt->output_section)->this_hdr.sh_entsize
11246 = PLT_ENTRY_SIZE;
11249 /* We need to handle writing out multiple GOT sections ourselves,
11250 since we didn't add them to DYNOBJ. We know dynobj is the first
11251 bfd. */
11252 while ((dynobj = dynobj->link_next) != NULL)
11254 asection *s;
11256 if (!is_ppc64_elf_target (dynobj->xvec))
11257 continue;
11259 s = ppc64_elf_tdata (dynobj)->got;
11260 if (s != NULL
11261 && s->size != 0
11262 && s->output_section != bfd_abs_section_ptr
11263 && !bfd_set_section_contents (output_bfd, s->output_section,
11264 s->contents, s->output_offset,
11265 s->size))
11266 return FALSE;
11267 s = ppc64_elf_tdata (dynobj)->relgot;
11268 if (s != NULL
11269 && s->size != 0
11270 && s->output_section != bfd_abs_section_ptr
11271 && !bfd_set_section_contents (output_bfd, s->output_section,
11272 s->contents, s->output_offset,
11273 s->size))
11274 return FALSE;
11277 return TRUE;
11280 #include "elf64-target.h"