1 /* PowerPC64-specific support for 64-bit ELF.
2 Copyright 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
3 Written by Linus Nordberg, Swox AB <info@swox.com>,
4 based on elf32-ppc.c by Ian Lance Taylor.
6 This file is part of BFD, the Binary File Descriptor library.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
22 /* This file is based on the 64-bit PowerPC ELF ABI. It is also based
23 on the file elf32-ppc.c. */
31 #include "elf64-ppc.h"
33 #define USE_RELA /* we want RELA relocations, not REL. */
36 static void ppc_howto_init
38 static reloc_howto_type *ppc64_elf_reloc_type_lookup
39 PARAMS ((bfd *abfd, bfd_reloc_code_real_type code));
40 static void ppc64_elf_info_to_howto
41 PARAMS ((bfd *abfd, arelent *cache_ptr, Elf64_Internal_Rela *dst));
42 static bfd_reloc_status_type ppc64_elf_ha_reloc
43 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
44 static bfd_reloc_status_type ppc64_elf_brtaken_reloc
45 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
46 static bfd_reloc_status_type ppc64_elf_sectoff_reloc
47 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
48 static bfd_reloc_status_type ppc64_elf_sectoff_ha_reloc
49 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
50 static bfd_reloc_status_type ppc64_elf_toc_reloc
51 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
52 static bfd_reloc_status_type ppc64_elf_toc_ha_reloc
53 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
54 static bfd_reloc_status_type ppc64_elf_toc64_reloc
55 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
56 static bfd_reloc_status_type ppc64_elf_unhandled_reloc
57 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
58 static void ppc64_elf_get_symbol_info
59 PARAMS ((bfd *, asymbol *, symbol_info *));
60 static boolean ppc64_elf_set_private_flags
61 PARAMS ((bfd *, flagword));
62 static boolean ppc64_elf_merge_private_bfd_data
63 PARAMS ((bfd *, bfd *));
64 static boolean ppc64_elf_section_from_shdr
65 PARAMS ((bfd *, Elf64_Internal_Shdr *, const char *));
68 /* The name of the dynamic interpreter. This is put in the .interp
70 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
72 /* The size in bytes of an entry in the procedure linkage table. */
73 #define PLT_ENTRY_SIZE 24
75 /* The initial size of the plt reserved for the dynamic linker. */
76 #define PLT_INITIAL_ENTRY_SIZE PLT_ENTRY_SIZE
78 /* TOC base pointers offset from start of TOC. */
79 #define TOC_BASE_OFF (0x8000)
81 /* .plt call stub instructions. */
82 #define ADDIS_R12_R2 0x3d820000 /* addis %r12,%r2,xxx@ha */
83 #define STD_R2_40R1 0xf8410028 /* std %r2,40(%r1) */
84 #define LD_R11_0R12 0xe96c0000 /* ld %r11,xxx+0@l(%r12) */
85 #define LD_R2_0R12 0xe84c0000 /* ld %r2,xxx+8@l(%r12) */
86 #define MTCTR_R11 0x7d6903a6 /* mtctr %r11 */
87 /* ld %r11,xxx+16@l(%r12) */
88 #define BCTR 0x4e800420 /* bctr */
90 /* The normal stub is this size. */
91 #define PLT_CALL_STUB_SIZE (7*4)
93 /* But sometimes the .plt entry crosses a 64k boundary, and we need
94 to adjust the high word with this insn. */
95 #define ADDIS_R12_R12_1 0x3d8c0001 /* addis %r12,%r12,1 */
97 /* The .glink fixup call stub is the same as the .plt call stub, but
98 the first instruction restores r2, and the std is omitted. */
99 #define LD_R2_40R1 0xe8410028 /* ld %r2,40(%r1) */
101 /* Always allow this much space. */
102 #define GLINK_CALL_STUB_SIZE (8*4)
105 #define NOP 0x60000000
107 /* Some other nops. */
108 #define CROR_151515 0x4def7b82
109 #define CROR_313131 0x4ffffb82
111 /* .glink entries for the first 32k functions are two instructions. */
112 #define LI_R0_0 0x38000000 /* li %r0,0 */
113 #define B_DOT 0x48000000 /* b . */
115 /* After that, we need two instructions to load the index, followed by
117 #define LIS_R0_0 0x3c000000 /* lis %r0,0 */
118 #define ORI_R0_R0_0 0x60000000 /* ori %r0,%r0,0 */
120 /* Instructions to save and restore floating point regs. */
121 #define STFD_FR0_0R1 0xd8010000 /* stfd %fr0,0(%r1) */
122 #define LFD_FR0_0R1 0xc8010000 /* lfd %fr0,0(%r1) */
123 #define BLR 0x4e800020 /* blr */
125 /* Since .opd is an array of descriptors and each entry will end up
126 with identical R_PPC64_RELATIVE relocs, there is really no need to
127 propagate .opd relocs; The dynamic linker should be taught to
128 relocate .opd without reloc entries. FIXME: .opd should be trimmed
130 #ifndef NO_OPD_RELOCS
131 #define NO_OPD_RELOCS 0
134 /* Relocation HOWTO's. */
135 static reloc_howto_type *ppc64_elf_howto_table[(int) R_PPC_max];
137 static reloc_howto_type ppc64_elf_howto_raw[] = {
138 /* This reloc does nothing. */
139 HOWTO (R_PPC64_NONE, /* type */
141 2, /* size (0 = byte, 1 = short, 2 = long) */
143 false, /* pc_relative */
145 complain_overflow_bitfield, /* complain_on_overflow */
146 bfd_elf_generic_reloc, /* special_function */
147 "R_PPC64_NONE", /* name */
148 false, /* partial_inplace */
151 false), /* pcrel_offset */
153 /* A standard 32 bit relocation. */
154 HOWTO (R_PPC64_ADDR32, /* type */
156 2, /* size (0 = byte, 1 = short, 2 = long) */
158 false, /* pc_relative */
160 complain_overflow_bitfield, /* complain_on_overflow */
161 bfd_elf_generic_reloc, /* special_function */
162 "R_PPC64_ADDR32", /* name */
163 false, /* partial_inplace */
165 0xffffffff, /* dst_mask */
166 false), /* pcrel_offset */
168 /* An absolute 26 bit branch; the lower two bits must be zero.
169 FIXME: we don't check that, we just clear them. */
170 HOWTO (R_PPC64_ADDR24, /* type */
172 2, /* size (0 = byte, 1 = short, 2 = long) */
174 false, /* pc_relative */
176 complain_overflow_bitfield, /* complain_on_overflow */
177 bfd_elf_generic_reloc, /* special_function */
178 "R_PPC64_ADDR24", /* name */
179 false, /* partial_inplace */
181 0x3fffffc, /* dst_mask */
182 false), /* pcrel_offset */
184 /* A standard 16 bit relocation. */
185 HOWTO (R_PPC64_ADDR16, /* type */
187 1, /* size (0 = byte, 1 = short, 2 = long) */
189 false, /* pc_relative */
191 complain_overflow_bitfield, /* complain_on_overflow */
192 bfd_elf_generic_reloc, /* special_function */
193 "R_PPC64_ADDR16", /* name */
194 false, /* partial_inplace */
196 0xffff, /* dst_mask */
197 false), /* pcrel_offset */
199 /* A 16 bit relocation without overflow. */
200 HOWTO (R_PPC64_ADDR16_LO, /* type */
202 1, /* size (0 = byte, 1 = short, 2 = long) */
204 false, /* pc_relative */
206 complain_overflow_dont,/* complain_on_overflow */
207 bfd_elf_generic_reloc, /* special_function */
208 "R_PPC64_ADDR16_LO", /* name */
209 false, /* partial_inplace */
211 0xffff, /* dst_mask */
212 false), /* pcrel_offset */
214 /* Bits 16-31 of an address. */
215 HOWTO (R_PPC64_ADDR16_HI, /* type */
217 1, /* size (0 = byte, 1 = short, 2 = long) */
219 false, /* pc_relative */
221 complain_overflow_dont, /* complain_on_overflow */
222 bfd_elf_generic_reloc, /* special_function */
223 "R_PPC64_ADDR16_HI", /* name */
224 false, /* partial_inplace */
226 0xffff, /* dst_mask */
227 false), /* pcrel_offset */
229 /* Bits 16-31 of an address, plus 1 if the contents of the low 16
230 bits, treated as a signed number, is negative. */
231 HOWTO (R_PPC64_ADDR16_HA, /* type */
233 1, /* size (0 = byte, 1 = short, 2 = long) */
235 false, /* pc_relative */
237 complain_overflow_dont, /* complain_on_overflow */
238 ppc64_elf_ha_reloc, /* special_function */
239 "R_PPC64_ADDR16_HA", /* name */
240 false, /* partial_inplace */
242 0xffff, /* dst_mask */
243 false), /* pcrel_offset */
245 /* An absolute 16 bit branch; the lower two bits must be zero.
246 FIXME: we don't check that, we just clear them. */
247 HOWTO (R_PPC64_ADDR14, /* type */
249 2, /* size (0 = byte, 1 = short, 2 = long) */
251 false, /* pc_relative */
253 complain_overflow_bitfield, /* complain_on_overflow */
254 bfd_elf_generic_reloc, /* special_function */
255 "R_PPC64_ADDR14", /* name */
256 false, /* partial_inplace */
258 0xfffc, /* dst_mask */
259 false), /* pcrel_offset */
261 /* An absolute 16 bit branch, for which bit 10 should be set to
262 indicate that the branch is expected to be taken. The lower two
263 bits must be zero. */
264 HOWTO (R_PPC64_ADDR14_BRTAKEN, /* type */
266 2, /* size (0 = byte, 1 = short, 2 = long) */
268 false, /* pc_relative */
270 complain_overflow_bitfield, /* complain_on_overflow */
271 ppc64_elf_brtaken_reloc, /* special_function */
272 "R_PPC64_ADDR14_BRTAKEN",/* name */
273 false, /* partial_inplace */
275 0xfffc, /* dst_mask */
276 false), /* pcrel_offset */
278 /* An absolute 16 bit branch, for which bit 10 should be set to
279 indicate that the branch is not expected to be taken. The lower
280 two bits must be zero. */
281 HOWTO (R_PPC64_ADDR14_BRNTAKEN, /* type */
283 2, /* size (0 = byte, 1 = short, 2 = long) */
285 false, /* pc_relative */
287 complain_overflow_bitfield, /* complain_on_overflow */
288 ppc64_elf_brtaken_reloc, /* special_function */
289 "R_PPC64_ADDR14_BRNTAKEN",/* name */
290 false, /* partial_inplace */
292 0xfffc, /* dst_mask */
293 false), /* pcrel_offset */
295 /* A relative 26 bit branch; the lower two bits must be zero. */
296 HOWTO (R_PPC64_REL24, /* type */
298 2, /* size (0 = byte, 1 = short, 2 = long) */
300 true, /* pc_relative */
302 complain_overflow_signed, /* complain_on_overflow */
303 bfd_elf_generic_reloc, /* special_function */
304 "R_PPC64_REL24", /* name */
305 false, /* partial_inplace */
307 0x3fffffc, /* dst_mask */
308 true), /* pcrel_offset */
310 /* A relative 16 bit branch; the lower two bits must be zero. */
311 HOWTO (R_PPC64_REL14, /* type */
313 2, /* size (0 = byte, 1 = short, 2 = long) */
315 true, /* pc_relative */
317 complain_overflow_signed, /* complain_on_overflow */
318 bfd_elf_generic_reloc, /* special_function */
319 "R_PPC64_REL14", /* name */
320 false, /* partial_inplace */
322 0xfffc, /* dst_mask */
323 true), /* pcrel_offset */
325 /* A relative 16 bit branch. Bit 10 should be set to indicate that
326 the branch is expected to be taken. The lower two bits must be
328 HOWTO (R_PPC64_REL14_BRTAKEN, /* type */
330 2, /* size (0 = byte, 1 = short, 2 = long) */
332 true, /* pc_relative */
334 complain_overflow_signed, /* complain_on_overflow */
335 ppc64_elf_brtaken_reloc, /* special_function */
336 "R_PPC64_REL14_BRTAKEN", /* name */
337 false, /* partial_inplace */
339 0xfffc, /* dst_mask */
340 true), /* pcrel_offset */
342 /* A relative 16 bit branch. Bit 10 should be set to indicate that
343 the branch is not expected to be taken. The lower two bits must
345 HOWTO (R_PPC64_REL14_BRNTAKEN, /* type */
347 2, /* size (0 = byte, 1 = short, 2 = long) */
349 true, /* pc_relative */
351 complain_overflow_signed, /* complain_on_overflow */
352 ppc64_elf_brtaken_reloc, /* special_function */
353 "R_PPC64_REL14_BRNTAKEN",/* name */
354 false, /* partial_inplace */
356 0xfffc, /* dst_mask */
357 true), /* pcrel_offset */
359 /* Like R_PPC64_ADDR16, but referring to the GOT table entry for the
361 HOWTO (R_PPC64_GOT16, /* type */
363 1, /* size (0 = byte, 1 = short, 2 = long) */
365 false, /* pc_relative */
367 complain_overflow_signed, /* complain_on_overflow */
368 ppc64_elf_unhandled_reloc, /* special_function */
369 "R_PPC64_GOT16", /* name */
370 false, /* partial_inplace */
372 0xffff, /* dst_mask */
373 false), /* pcrel_offset */
375 /* Like R_PPC64_ADDR16_LO, but referring to the GOT table entry for
377 HOWTO (R_PPC64_GOT16_LO, /* type */
379 1, /* size (0 = byte, 1 = short, 2 = long) */
381 false, /* pc_relative */
383 complain_overflow_dont, /* complain_on_overflow */
384 ppc64_elf_unhandled_reloc, /* special_function */
385 "R_PPC64_GOT16_LO", /* name */
386 false, /* partial_inplace */
388 0xffff, /* dst_mask */
389 false), /* pcrel_offset */
391 /* Like R_PPC64_ADDR16_HI, but referring to the GOT table entry for
393 HOWTO (R_PPC64_GOT16_HI, /* type */
395 1, /* size (0 = byte, 1 = short, 2 = long) */
397 false, /* pc_relative */
399 complain_overflow_dont,/* complain_on_overflow */
400 ppc64_elf_unhandled_reloc, /* special_function */
401 "R_PPC64_GOT16_HI", /* name */
402 false, /* partial_inplace */
404 0xffff, /* dst_mask */
405 false), /* pcrel_offset */
407 /* Like R_PPC64_ADDR16_HA, but referring to the GOT table entry for
409 HOWTO (R_PPC64_GOT16_HA, /* type */
411 1, /* size (0 = byte, 1 = short, 2 = long) */
413 false, /* pc_relative */
415 complain_overflow_dont,/* complain_on_overflow */
416 ppc64_elf_unhandled_reloc, /* special_function */
417 "R_PPC64_GOT16_HA", /* name */
418 false, /* partial_inplace */
420 0xffff, /* dst_mask */
421 false), /* pcrel_offset */
423 /* This is used only by the dynamic linker. The symbol should exist
424 both in the object being run and in some shared library. The
425 dynamic linker copies the data addressed by the symbol from the
426 shared library into the object, because the object being
427 run has to have the data at some particular address. */
428 HOWTO (R_PPC64_COPY, /* type */
430 2, /* size (0 = byte, 1 = short, 2 = long) */
432 false, /* pc_relative */
434 complain_overflow_bitfield, /* complain_on_overflow */
435 ppc64_elf_unhandled_reloc, /* special_function */
436 "R_PPC64_COPY", /* name */
437 false, /* partial_inplace */
440 false), /* pcrel_offset */
442 /* Like R_PPC64_ADDR64, but used when setting global offset table
444 HOWTO (R_PPC64_GLOB_DAT, /* type */
446 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
448 false, /* pc_relative */
450 complain_overflow_dont, /* complain_on_overflow */
451 ppc64_elf_unhandled_reloc, /* special_function */
452 "R_PPC64_GLOB_DAT", /* name */
453 false, /* partial_inplace */
455 0xffffffffffffffff, /* dst_mask */
456 false), /* pcrel_offset */
458 /* Created by the link editor. Marks a procedure linkage table
459 entry for a symbol. */
460 HOWTO (R_PPC64_JMP_SLOT, /* type */
462 0, /* size (0 = byte, 1 = short, 2 = long) */
464 false, /* pc_relative */
466 complain_overflow_dont, /* complain_on_overflow */
467 ppc64_elf_unhandled_reloc, /* special_function */
468 "R_PPC64_JMP_SLOT", /* name */
469 false, /* partial_inplace */
472 false), /* pcrel_offset */
474 /* Used only by the dynamic linker. When the object is run, this
475 doubleword64 is set to the load address of the object, plus the
477 HOWTO (R_PPC64_RELATIVE, /* type */
479 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
481 false, /* pc_relative */
483 complain_overflow_dont, /* complain_on_overflow */
484 bfd_elf_generic_reloc, /* special_function */
485 "R_PPC64_RELATIVE", /* name */
486 false, /* partial_inplace */
488 0xffffffffffffffff, /* dst_mask */
489 false), /* pcrel_offset */
491 /* Like R_PPC64_ADDR32, but may be unaligned. */
492 HOWTO (R_PPC64_UADDR32, /* type */
494 2, /* size (0 = byte, 1 = short, 2 = long) */
496 false, /* pc_relative */
498 complain_overflow_bitfield, /* complain_on_overflow */
499 bfd_elf_generic_reloc, /* special_function */
500 "R_PPC64_UADDR32", /* name */
501 false, /* partial_inplace */
503 0xffffffff, /* dst_mask */
504 false), /* pcrel_offset */
506 /* Like R_PPC64_ADDR16, but may be unaligned. */
507 HOWTO (R_PPC64_UADDR16, /* type */
509 1, /* size (0 = byte, 1 = short, 2 = long) */
511 false, /* pc_relative */
513 complain_overflow_bitfield, /* complain_on_overflow */
514 bfd_elf_generic_reloc, /* special_function */
515 "R_PPC64_UADDR16", /* name */
516 false, /* partial_inplace */
518 0xffff, /* dst_mask */
519 false), /* pcrel_offset */
521 /* 32-bit PC relative. */
522 HOWTO (R_PPC64_REL32, /* type */
524 2, /* size (0 = byte, 1 = short, 2 = long) */
526 true, /* pc_relative */
528 /* FIXME: Verify. Was complain_overflow_bitfield. */
529 complain_overflow_signed, /* complain_on_overflow */
530 bfd_elf_generic_reloc, /* special_function */
531 "R_PPC64_REL32", /* name */
532 false, /* partial_inplace */
534 0xffffffff, /* dst_mask */
535 true), /* pcrel_offset */
537 /* 32-bit relocation to the symbol's procedure linkage table. */
538 HOWTO (R_PPC64_PLT32, /* type */
540 2, /* size (0 = byte, 1 = short, 2 = long) */
542 false, /* pc_relative */
544 complain_overflow_bitfield, /* complain_on_overflow */
545 ppc64_elf_unhandled_reloc, /* special_function */
546 "R_PPC64_PLT32", /* name */
547 false, /* partial_inplace */
550 false), /* pcrel_offset */
552 /* 32-bit PC relative relocation to the symbol's procedure linkage table.
553 FIXME: R_PPC64_PLTREL32 not supported. */
554 HOWTO (R_PPC64_PLTREL32, /* type */
556 2, /* size (0 = byte, 1 = short, 2 = long) */
558 true, /* pc_relative */
560 complain_overflow_signed, /* complain_on_overflow */
561 bfd_elf_generic_reloc, /* special_function */
562 "R_PPC64_PLTREL32", /* name */
563 false, /* partial_inplace */
566 true), /* pcrel_offset */
568 /* Like R_PPC64_ADDR16_LO, but referring to the PLT table entry for
570 HOWTO (R_PPC64_PLT16_LO, /* type */
572 1, /* size (0 = byte, 1 = short, 2 = long) */
574 false, /* pc_relative */
576 complain_overflow_dont, /* complain_on_overflow */
577 ppc64_elf_unhandled_reloc, /* special_function */
578 "R_PPC64_PLT16_LO", /* name */
579 false, /* partial_inplace */
581 0xffff, /* dst_mask */
582 false), /* pcrel_offset */
584 /* Like R_PPC64_ADDR16_HI, but referring to the PLT table entry for
586 HOWTO (R_PPC64_PLT16_HI, /* type */
588 1, /* size (0 = byte, 1 = short, 2 = long) */
590 false, /* pc_relative */
592 complain_overflow_dont, /* complain_on_overflow */
593 ppc64_elf_unhandled_reloc, /* special_function */
594 "R_PPC64_PLT16_HI", /* name */
595 false, /* partial_inplace */
597 0xffff, /* dst_mask */
598 false), /* pcrel_offset */
600 /* Like R_PPC64_ADDR16_HA, but referring to the PLT table entry for
602 HOWTO (R_PPC64_PLT16_HA, /* type */
604 1, /* size (0 = byte, 1 = short, 2 = long) */
606 false, /* pc_relative */
608 complain_overflow_dont, /* complain_on_overflow */
609 ppc64_elf_unhandled_reloc, /* special_function */
610 "R_PPC64_PLT16_HA", /* name */
611 false, /* partial_inplace */
613 0xffff, /* dst_mask */
614 false), /* pcrel_offset */
616 /* 16-bit section relative relocation. */
617 HOWTO (R_PPC64_SECTOFF, /* type */
619 1, /* size (0 = byte, 1 = short, 2 = long) */
621 false, /* pc_relative */
623 complain_overflow_bitfield, /* complain_on_overflow */
624 ppc64_elf_sectoff_reloc, /* special_function */
625 "R_PPC64_SECTOFF", /* name */
626 false, /* partial_inplace */
628 0xffff, /* dst_mask */
629 false), /* pcrel_offset */
631 /* Like R_PPC64_SECTOFF, but no overflow warning. */
632 HOWTO (R_PPC64_SECTOFF_LO, /* type */
634 1, /* size (0 = byte, 1 = short, 2 = long) */
636 false, /* pc_relative */
638 complain_overflow_dont, /* complain_on_overflow */
639 ppc64_elf_sectoff_reloc, /* special_function */
640 "R_PPC64_SECTOFF_LO", /* name */
641 false, /* partial_inplace */
643 0xffff, /* dst_mask */
644 false), /* pcrel_offset */
646 /* 16-bit upper half section relative relocation. */
647 HOWTO (R_PPC64_SECTOFF_HI, /* type */
649 1, /* size (0 = byte, 1 = short, 2 = long) */
651 false, /* pc_relative */
653 complain_overflow_dont, /* complain_on_overflow */
654 ppc64_elf_sectoff_reloc, /* special_function */
655 "R_PPC64_SECTOFF_HI", /* name */
656 false, /* partial_inplace */
658 0xffff, /* dst_mask */
659 false), /* pcrel_offset */
661 /* 16-bit upper half adjusted section relative relocation. */
662 HOWTO (R_PPC64_SECTOFF_HA, /* type */
664 1, /* size (0 = byte, 1 = short, 2 = long) */
666 false, /* pc_relative */
668 complain_overflow_dont, /* complain_on_overflow */
669 ppc64_elf_sectoff_ha_reloc, /* special_function */
670 "R_PPC64_SECTOFF_HA", /* name */
671 false, /* partial_inplace */
673 0xffff, /* dst_mask */
674 false), /* pcrel_offset */
676 /* Like R_PPC64_REL24 without touching the two least significant
677 bits. Should have been named R_PPC64_REL30! */
678 HOWTO (R_PPC64_ADDR30, /* type */
680 2, /* size (0 = byte, 1 = short, 2 = long) */
682 true, /* pc_relative */
684 complain_overflow_dont, /* complain_on_overflow */
685 bfd_elf_generic_reloc, /* special_function */
686 "R_PPC64_ADDR30", /* name */
687 false, /* partial_inplace */
689 0xfffffffc, /* dst_mask */
690 true), /* pcrel_offset */
692 /* Relocs in the 64-bit PowerPC ELF ABI, not in the 32-bit ABI. */
694 /* A standard 64-bit relocation. */
695 HOWTO (R_PPC64_ADDR64, /* type */
697 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
699 false, /* pc_relative */
701 complain_overflow_dont, /* complain_on_overflow */
702 bfd_elf_generic_reloc, /* special_function */
703 "R_PPC64_ADDR64", /* name */
704 false, /* partial_inplace */
706 0xffffffffffffffff, /* dst_mask */
707 false), /* pcrel_offset */
709 /* The bits 32-47 of an address. */
710 HOWTO (R_PPC64_ADDR16_HIGHER, /* type */
712 1, /* size (0 = byte, 1 = short, 2 = long) */
714 false, /* pc_relative */
716 complain_overflow_dont, /* complain_on_overflow */
717 bfd_elf_generic_reloc, /* special_function */
718 "R_PPC64_ADDR16_HIGHER", /* name */
719 false, /* partial_inplace */
721 0xffff, /* dst_mask */
722 false), /* pcrel_offset */
724 /* The bits 32-47 of an address, plus 1 if the contents of the low
725 16 bits, treated as a signed number, is negative. */
726 HOWTO (R_PPC64_ADDR16_HIGHERA, /* type */
728 1, /* size (0 = byte, 1 = short, 2 = long) */
730 false, /* pc_relative */
732 complain_overflow_dont, /* complain_on_overflow */
733 ppc64_elf_ha_reloc, /* special_function */
734 "R_PPC64_ADDR16_HIGHERA", /* name */
735 false, /* partial_inplace */
737 0xffff, /* dst_mask */
738 false), /* pcrel_offset */
740 /* The bits 48-63 of an address. */
741 HOWTO (R_PPC64_ADDR16_HIGHEST,/* type */
743 1, /* size (0 = byte, 1 = short, 2 = long) */
745 false, /* pc_relative */
747 complain_overflow_dont, /* complain_on_overflow */
748 bfd_elf_generic_reloc, /* special_function */
749 "R_PPC64_ADDR16_HIGHEST", /* name */
750 false, /* partial_inplace */
752 0xffff, /* dst_mask */
753 false), /* pcrel_offset */
755 /* The bits 48-63 of an address, plus 1 if the contents of the low
756 16 bits, treated as a signed number, is negative. */
757 HOWTO (R_PPC64_ADDR16_HIGHESTA,/* type */
759 1, /* size (0 = byte, 1 = short, 2 = long) */
761 false, /* pc_relative */
763 complain_overflow_dont, /* complain_on_overflow */
764 ppc64_elf_ha_reloc, /* special_function */
765 "R_PPC64_ADDR16_HIGHESTA", /* name */
766 false, /* partial_inplace */
768 0xffff, /* dst_mask */
769 false), /* pcrel_offset */
771 /* Like ADDR64, but may be unaligned. */
772 HOWTO (R_PPC64_UADDR64, /* type */
774 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
776 false, /* pc_relative */
778 complain_overflow_dont, /* complain_on_overflow */
779 bfd_elf_generic_reloc, /* special_function */
780 "R_PPC64_UADDR64", /* name */
781 false, /* partial_inplace */
783 0xffffffffffffffff, /* dst_mask */
784 false), /* pcrel_offset */
786 /* 64-bit relative relocation. */
787 HOWTO (R_PPC64_REL64, /* type */
789 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
791 true, /* pc_relative */
793 complain_overflow_dont, /* complain_on_overflow */
794 bfd_elf_generic_reloc, /* special_function */
795 "R_PPC64_REL64", /* name */
796 false, /* partial_inplace */
798 0xffffffffffffffff, /* dst_mask */
799 true), /* pcrel_offset */
801 /* 64-bit relocation to the symbol's procedure linkage table. */
802 HOWTO (R_PPC64_PLT64, /* type */
804 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
806 false, /* pc_relative */
808 complain_overflow_dont, /* complain_on_overflow */
809 ppc64_elf_unhandled_reloc, /* special_function */
810 "R_PPC64_PLT64", /* name */
811 false, /* partial_inplace */
814 false), /* pcrel_offset */
816 /* 64-bit PC relative relocation to the symbol's procedure linkage
818 /* FIXME: R_PPC64_PLTREL64 not supported. */
819 HOWTO (R_PPC64_PLTREL64, /* type */
821 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
823 true, /* pc_relative */
825 complain_overflow_dont, /* complain_on_overflow */
826 ppc64_elf_unhandled_reloc, /* special_function */
827 "R_PPC64_PLTREL64", /* name */
828 false, /* partial_inplace */
831 true), /* pcrel_offset */
833 /* 16 bit TOC-relative relocation. */
835 /* R_PPC64_TOC16 47 half16* S + A - .TOC. */
836 HOWTO (R_PPC64_TOC16, /* type */
838 1, /* size (0 = byte, 1 = short, 2 = long) */
840 false, /* pc_relative */
842 complain_overflow_signed, /* complain_on_overflow */
843 ppc64_elf_toc_reloc, /* special_function */
844 "R_PPC64_TOC16", /* name */
845 false, /* partial_inplace */
847 0xffff, /* dst_mask */
848 false), /* pcrel_offset */
850 /* 16 bit TOC-relative relocation without overflow. */
852 /* R_PPC64_TOC16_LO 48 half16 #lo (S + A - .TOC.) */
853 HOWTO (R_PPC64_TOC16_LO, /* type */
855 1, /* size (0 = byte, 1 = short, 2 = long) */
857 false, /* pc_relative */
859 complain_overflow_dont, /* complain_on_overflow */
860 ppc64_elf_toc_reloc, /* special_function */
861 "R_PPC64_TOC16_LO", /* name */
862 false, /* partial_inplace */
864 0xffff, /* dst_mask */
865 false), /* pcrel_offset */
867 /* 16 bit TOC-relative relocation, high 16 bits. */
869 /* R_PPC64_TOC16_HI 49 half16 #hi (S + A - .TOC.) */
870 HOWTO (R_PPC64_TOC16_HI, /* type */
872 1, /* size (0 = byte, 1 = short, 2 = long) */
874 false, /* pc_relative */
876 complain_overflow_dont, /* complain_on_overflow */
877 ppc64_elf_toc_reloc, /* special_function */
878 "R_PPC64_TOC16_HI", /* name */
879 false, /* partial_inplace */
881 0xffff, /* dst_mask */
882 false), /* pcrel_offset */
884 /* 16 bit TOC-relative relocation, high 16 bits, plus 1 if the
885 contents of the low 16 bits, treated as a signed number, is
888 /* R_PPC64_TOC16_HA 50 half16 #ha (S + A - .TOC.) */
889 HOWTO (R_PPC64_TOC16_HA, /* type */
891 1, /* size (0 = byte, 1 = short, 2 = long) */
893 false, /* pc_relative */
895 complain_overflow_dont, /* complain_on_overflow */
896 ppc64_elf_toc_ha_reloc, /* special_function */
897 "R_PPC64_TOC16_HA", /* name */
898 false, /* partial_inplace */
900 0xffff, /* dst_mask */
901 false), /* pcrel_offset */
903 /* 64-bit relocation; insert value of TOC base (.TOC.). */
905 /* R_PPC64_TOC 51 doubleword64 .TOC. */
906 HOWTO (R_PPC64_TOC, /* type */
908 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
910 false, /* pc_relative */
912 complain_overflow_bitfield, /* complain_on_overflow */
913 ppc64_elf_toc64_reloc, /* special_function */
914 "R_PPC64_TOC", /* name */
915 false, /* partial_inplace */
917 0xffffffffffffffff, /* dst_mask */
918 false), /* pcrel_offset */
920 /* Like R_PPC64_GOT16, but also informs the link editor that the
921 value to relocate may (!) refer to a PLT entry which the link
922 editor (a) may replace with the symbol value. If the link editor
923 is unable to fully resolve the symbol, it may (b) create a PLT
924 entry and store the address to the new PLT entry in the GOT.
925 This permits lazy resolution of function symbols at run time.
926 The link editor may also skip all of this and just (c) emit a
927 R_PPC64_GLOB_DAT to tie the symbol to the GOT entry. */
928 /* FIXME: R_PPC64_PLTGOT16 not implemented. */
929 HOWTO (R_PPC64_PLTGOT16, /* type */
931 1, /* size (0 = byte, 1 = short, 2 = long) */
933 false, /* pc_relative */
935 complain_overflow_signed, /* complain_on_overflow */
936 ppc64_elf_unhandled_reloc, /* special_function */
937 "R_PPC64_PLTGOT16", /* name */
938 false, /* partial_inplace */
940 0xffff, /* dst_mask */
941 false), /* pcrel_offset */
943 /* Like R_PPC64_PLTGOT16, but without overflow. */
944 /* FIXME: R_PPC64_PLTGOT16_LO not implemented. */
945 HOWTO (R_PPC64_PLTGOT16_LO, /* type */
947 1, /* size (0 = byte, 1 = short, 2 = long) */
949 false, /* pc_relative */
951 complain_overflow_dont, /* complain_on_overflow */
952 ppc64_elf_unhandled_reloc, /* special_function */
953 "R_PPC64_PLTGOT16_LO", /* name */
954 false, /* partial_inplace */
956 0xffff, /* dst_mask */
957 false), /* pcrel_offset */
959 /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address. */
960 /* FIXME: R_PPC64_PLTGOT16_HI not implemented. */
961 HOWTO (R_PPC64_PLTGOT16_HI, /* type */
963 1, /* size (0 = byte, 1 = short, 2 = long) */
965 false, /* pc_relative */
967 complain_overflow_dont, /* complain_on_overflow */
968 ppc64_elf_unhandled_reloc, /* special_function */
969 "R_PPC64_PLTGOT16_HI", /* name */
970 false, /* partial_inplace */
972 0xffff, /* dst_mask */
973 false), /* pcrel_offset */
975 /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address, plus
976 1 if the contents of the low 16 bits, treated as a signed number,
978 /* FIXME: R_PPC64_PLTGOT16_HA not implemented. */
979 HOWTO (R_PPC64_PLTGOT16_HA, /* type */
981 1, /* size (0 = byte, 1 = short, 2 = long) */
983 false, /* pc_relative */
985 complain_overflow_dont,/* complain_on_overflow */
986 ppc64_elf_unhandled_reloc, /* special_function */
987 "R_PPC64_PLTGOT16_HA", /* name */
988 false, /* partial_inplace */
990 0xffff, /* dst_mask */
991 false), /* pcrel_offset */
993 /* Like R_PPC64_ADDR16, but for instructions with a DS field. */
994 HOWTO (R_PPC64_ADDR16_DS, /* type */
996 1, /* size (0 = byte, 1 = short, 2 = long) */
998 false, /* pc_relative */
1000 complain_overflow_bitfield, /* complain_on_overflow */
1001 bfd_elf_generic_reloc, /* special_function */
1002 "R_PPC64_ADDR16_DS", /* name */
1003 false, /* partial_inplace */
1005 0xfffc, /* dst_mask */
1006 false), /* pcrel_offset */
1008 /* Like R_PPC64_ADDR16_LO, but for instructions with a DS field. */
1009 HOWTO (R_PPC64_ADDR16_LO_DS, /* type */
1011 1, /* size (0 = byte, 1 = short, 2 = long) */
1013 false, /* pc_relative */
1015 complain_overflow_dont,/* complain_on_overflow */
1016 bfd_elf_generic_reloc, /* special_function */
1017 "R_PPC64_ADDR16_LO_DS",/* name */
1018 false, /* partial_inplace */
1020 0xfffc, /* dst_mask */
1021 false), /* pcrel_offset */
1023 /* Like R_PPC64_GOT16, but for instructions with a DS field. */
1024 HOWTO (R_PPC64_GOT16_DS, /* type */
1026 1, /* size (0 = byte, 1 = short, 2 = long) */
1028 false, /* pc_relative */
1030 complain_overflow_signed, /* complain_on_overflow */
1031 ppc64_elf_unhandled_reloc, /* special_function */
1032 "R_PPC64_GOT16_DS", /* name */
1033 false, /* partial_inplace */
1035 0xfffc, /* dst_mask */
1036 false), /* pcrel_offset */
1038 /* Like R_PPC64_GOT16_LO, but for instructions with a DS field. */
1039 HOWTO (R_PPC64_GOT16_LO_DS, /* type */
1041 1, /* size (0 = byte, 1 = short, 2 = long) */
1043 false, /* pc_relative */
1045 complain_overflow_dont, /* complain_on_overflow */
1046 ppc64_elf_unhandled_reloc, /* special_function */
1047 "R_PPC64_GOT16_LO_DS", /* name */
1048 false, /* partial_inplace */
1050 0xfffc, /* dst_mask */
1051 false), /* pcrel_offset */
1053 /* Like R_PPC64_PLT16_LO, but for instructions with a DS field. */
1054 HOWTO (R_PPC64_PLT16_LO_DS, /* type */
1056 1, /* size (0 = byte, 1 = short, 2 = long) */
1058 false, /* pc_relative */
1060 complain_overflow_dont, /* complain_on_overflow */
1061 ppc64_elf_unhandled_reloc, /* special_function */
1062 "R_PPC64_PLT16_LO_DS", /* name */
1063 false, /* partial_inplace */
1065 0xfffc, /* dst_mask */
1066 false), /* pcrel_offset */
1068 /* Like R_PPC64_SECTOFF, but for instructions with a DS field. */
1069 HOWTO (R_PPC64_SECTOFF_DS, /* type */
1071 1, /* size (0 = byte, 1 = short, 2 = long) */
1073 false, /* pc_relative */
1075 complain_overflow_bitfield, /* complain_on_overflow */
1076 ppc64_elf_sectoff_reloc, /* special_function */
1077 "R_PPC64_SECTOFF_DS", /* name */
1078 false, /* partial_inplace */
1080 0xfffc, /* dst_mask */
1081 false), /* pcrel_offset */
1083 /* Like R_PPC64_SECTOFF_LO, but for instructions with a DS field. */
1084 HOWTO (R_PPC64_SECTOFF_LO_DS, /* type */
1086 1, /* size (0 = byte, 1 = short, 2 = long) */
1088 false, /* pc_relative */
1090 complain_overflow_dont, /* complain_on_overflow */
1091 ppc64_elf_sectoff_reloc, /* special_function */
1092 "R_PPC64_SECTOFF_LO_DS",/* name */
1093 false, /* partial_inplace */
1095 0xfffc, /* dst_mask */
1096 false), /* pcrel_offset */
1098 /* Like R_PPC64_TOC16, but for instructions with a DS field. */
1099 HOWTO (R_PPC64_TOC16_DS, /* type */
1101 1, /* size (0 = byte, 1 = short, 2 = long) */
1103 false, /* pc_relative */
1105 complain_overflow_signed, /* complain_on_overflow */
1106 ppc64_elf_toc_reloc, /* special_function */
1107 "R_PPC64_TOC16_DS", /* name */
1108 false, /* partial_inplace */
1110 0xfffc, /* dst_mask */
1111 false), /* pcrel_offset */
1113 /* Like R_PPC64_TOC16_LO, but for instructions with a DS field. */
1114 HOWTO (R_PPC64_TOC16_LO_DS, /* type */
1116 1, /* size (0 = byte, 1 = short, 2 = long) */
1118 false, /* pc_relative */
1120 complain_overflow_dont, /* complain_on_overflow */
1121 ppc64_elf_toc_reloc, /* special_function */
1122 "R_PPC64_TOC16_LO_DS", /* name */
1123 false, /* partial_inplace */
1125 0xfffc, /* dst_mask */
1126 false), /* pcrel_offset */
1128 /* Like R_PPC64_PLTGOT16, but for instructions with a DS field. */
1129 /* FIXME: R_PPC64_PLTGOT16_DS not implemented. */
1130 HOWTO (R_PPC64_PLTGOT16_DS, /* type */
1132 1, /* size (0 = byte, 1 = short, 2 = long) */
1134 false, /* pc_relative */
1136 complain_overflow_signed, /* complain_on_overflow */
1137 ppc64_elf_unhandled_reloc, /* special_function */
1138 "R_PPC64_PLTGOT16_DS", /* name */
1139 false, /* partial_inplace */
1141 0xfffc, /* dst_mask */
1142 false), /* pcrel_offset */
1144 /* Like R_PPC64_PLTGOT16_LO, but for instructions with a DS field. */
1145 /* FIXME: R_PPC64_PLTGOT16_LO not implemented. */
1146 HOWTO (R_PPC64_PLTGOT16_LO_DS,/* type */
1148 1, /* size (0 = byte, 1 = short, 2 = long) */
1150 false, /* pc_relative */
1152 complain_overflow_dont, /* complain_on_overflow */
1153 ppc64_elf_unhandled_reloc, /* special_function */
1154 "R_PPC64_PLTGOT16_LO_DS",/* name */
1155 false, /* partial_inplace */
1157 0xfffc, /* dst_mask */
1158 false), /* pcrel_offset */
1160 /* GNU extension to record C++ vtable hierarchy. */
1161 HOWTO (R_PPC64_GNU_VTINHERIT, /* type */
1163 0, /* size (0 = byte, 1 = short, 2 = long) */
1165 false, /* pc_relative */
1167 complain_overflow_dont, /* complain_on_overflow */
1168 NULL, /* special_function */
1169 "R_PPC64_GNU_VTINHERIT", /* name */
1170 false, /* partial_inplace */
1173 false), /* pcrel_offset */
1175 /* GNU extension to record C++ vtable member usage. */
1176 HOWTO (R_PPC64_GNU_VTENTRY, /* type */
1178 0, /* size (0 = byte, 1 = short, 2 = long) */
1180 false, /* pc_relative */
1182 complain_overflow_dont, /* complain_on_overflow */
1183 NULL, /* special_function */
1184 "R_PPC64_GNU_VTENTRY", /* name */
1185 false, /* partial_inplace */
1188 false), /* pcrel_offset */
1192 /* Initialize the ppc64_elf_howto_table, so that linear accesses can
1198 unsigned int i, type;
1201 i < sizeof (ppc64_elf_howto_raw) / sizeof (ppc64_elf_howto_raw[0]);
1204 type = ppc64_elf_howto_raw[i].type;
1205 BFD_ASSERT (type < (sizeof (ppc64_elf_howto_table)
1206 / sizeof (ppc64_elf_howto_table[0])));
1207 ppc64_elf_howto_table[type] = &ppc64_elf_howto_raw[i];
1211 static reloc_howto_type *
1212 ppc64_elf_reloc_type_lookup (abfd, code)
1213 bfd *abfd ATTRIBUTE_UNUSED;
1214 bfd_reloc_code_real_type code;
1216 enum elf_ppc_reloc_type ppc_reloc = R_PPC_NONE;
1218 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
1219 /* Initialize howto table if needed. */
1225 return (reloc_howto_type *) NULL;
1227 case BFD_RELOC_NONE: ppc_reloc = R_PPC64_NONE;
1229 case BFD_RELOC_32: ppc_reloc = R_PPC64_ADDR32;
1231 case BFD_RELOC_PPC_BA26: ppc_reloc = R_PPC64_ADDR24;
1233 case BFD_RELOC_16: ppc_reloc = R_PPC64_ADDR16;
1235 case BFD_RELOC_LO16: ppc_reloc = R_PPC64_ADDR16_LO;
1237 case BFD_RELOC_HI16: ppc_reloc = R_PPC64_ADDR16_HI;
1239 case BFD_RELOC_HI16_S: ppc_reloc = R_PPC64_ADDR16_HA;
1241 case BFD_RELOC_PPC_BA16: ppc_reloc = R_PPC64_ADDR14;
1243 case BFD_RELOC_PPC_BA16_BRTAKEN: ppc_reloc = R_PPC64_ADDR14_BRTAKEN;
1245 case BFD_RELOC_PPC_BA16_BRNTAKEN: ppc_reloc = R_PPC64_ADDR14_BRNTAKEN;
1247 case BFD_RELOC_PPC_B26: ppc_reloc = R_PPC64_REL24;
1249 case BFD_RELOC_PPC_B16: ppc_reloc = R_PPC64_REL14;
1251 case BFD_RELOC_PPC_B16_BRTAKEN: ppc_reloc = R_PPC64_REL14_BRTAKEN;
1253 case BFD_RELOC_PPC_B16_BRNTAKEN: ppc_reloc = R_PPC64_REL14_BRNTAKEN;
1255 case BFD_RELOC_16_GOTOFF: ppc_reloc = R_PPC64_GOT16;
1257 case BFD_RELOC_LO16_GOTOFF: ppc_reloc = R_PPC64_GOT16_LO;
1259 case BFD_RELOC_HI16_GOTOFF: ppc_reloc = R_PPC64_GOT16_HI;
1261 case BFD_RELOC_HI16_S_GOTOFF: ppc_reloc = R_PPC64_GOT16_HA;
1263 case BFD_RELOC_PPC_COPY: ppc_reloc = R_PPC64_COPY;
1265 case BFD_RELOC_PPC_GLOB_DAT: ppc_reloc = R_PPC64_GLOB_DAT;
1267 case BFD_RELOC_32_PCREL: ppc_reloc = R_PPC64_REL32;
1269 case BFD_RELOC_32_PLTOFF: ppc_reloc = R_PPC64_PLT32;
1271 case BFD_RELOC_32_PLT_PCREL: ppc_reloc = R_PPC64_PLTREL32;
1273 case BFD_RELOC_LO16_PLTOFF: ppc_reloc = R_PPC64_PLT16_LO;
1275 case BFD_RELOC_HI16_PLTOFF: ppc_reloc = R_PPC64_PLT16_HI;
1277 case BFD_RELOC_HI16_S_PLTOFF: ppc_reloc = R_PPC64_PLT16_HA;
1279 case BFD_RELOC_16_BASEREL: ppc_reloc = R_PPC64_SECTOFF;
1281 case BFD_RELOC_LO16_BASEREL: ppc_reloc = R_PPC64_SECTOFF_LO;
1283 case BFD_RELOC_HI16_BASEREL: ppc_reloc = R_PPC64_SECTOFF_HI;
1285 case BFD_RELOC_HI16_S_BASEREL: ppc_reloc = R_PPC64_SECTOFF_HA;
1287 case BFD_RELOC_CTOR: ppc_reloc = R_PPC64_ADDR64;
1289 case BFD_RELOC_64: ppc_reloc = R_PPC64_ADDR64;
1291 case BFD_RELOC_PPC64_HIGHER: ppc_reloc = R_PPC64_ADDR16_HIGHER;
1293 case BFD_RELOC_PPC64_HIGHER_S: ppc_reloc = R_PPC64_ADDR16_HIGHERA;
1295 case BFD_RELOC_PPC64_HIGHEST: ppc_reloc = R_PPC64_ADDR16_HIGHEST;
1297 case BFD_RELOC_PPC64_HIGHEST_S: ppc_reloc = R_PPC64_ADDR16_HIGHESTA;
1299 case BFD_RELOC_64_PCREL: ppc_reloc = R_PPC64_REL64;
1301 case BFD_RELOC_64_PLTOFF: ppc_reloc = R_PPC64_PLT64;
1303 case BFD_RELOC_64_PLT_PCREL: ppc_reloc = R_PPC64_PLTREL64;
1305 case BFD_RELOC_PPC_TOC16: ppc_reloc = R_PPC64_TOC16;
1307 case BFD_RELOC_PPC64_TOC16_LO: ppc_reloc = R_PPC64_TOC16_LO;
1309 case BFD_RELOC_PPC64_TOC16_HI: ppc_reloc = R_PPC64_TOC16_HI;
1311 case BFD_RELOC_PPC64_TOC16_HA: ppc_reloc = R_PPC64_TOC16_HA;
1313 case BFD_RELOC_PPC64_TOC: ppc_reloc = R_PPC64_TOC;
1315 case BFD_RELOC_PPC64_PLTGOT16: ppc_reloc = R_PPC64_PLTGOT16;
1317 case BFD_RELOC_PPC64_PLTGOT16_LO: ppc_reloc = R_PPC64_PLTGOT16_LO;
1319 case BFD_RELOC_PPC64_PLTGOT16_HI: ppc_reloc = R_PPC64_PLTGOT16_HI;
1321 case BFD_RELOC_PPC64_PLTGOT16_HA: ppc_reloc = R_PPC64_PLTGOT16_HA;
1323 case BFD_RELOC_PPC64_ADDR16_DS: ppc_reloc = R_PPC64_ADDR16_DS;
1325 case BFD_RELOC_PPC64_ADDR16_LO_DS: ppc_reloc = R_PPC64_ADDR16_LO_DS;
1327 case BFD_RELOC_PPC64_GOT16_DS: ppc_reloc = R_PPC64_GOT16_DS;
1329 case BFD_RELOC_PPC64_GOT16_LO_DS: ppc_reloc = R_PPC64_GOT16_LO_DS;
1331 case BFD_RELOC_PPC64_PLT16_LO_DS: ppc_reloc = R_PPC64_PLT16_LO_DS;
1333 case BFD_RELOC_PPC64_SECTOFF_DS: ppc_reloc = R_PPC64_SECTOFF_DS;
1335 case BFD_RELOC_PPC64_SECTOFF_LO_DS: ppc_reloc = R_PPC64_SECTOFF_LO_DS;
1337 case BFD_RELOC_PPC64_TOC16_DS: ppc_reloc = R_PPC64_TOC16_DS;
1339 case BFD_RELOC_PPC64_TOC16_LO_DS: ppc_reloc = R_PPC64_TOC16_LO_DS;
1341 case BFD_RELOC_PPC64_PLTGOT16_DS: ppc_reloc = R_PPC64_PLTGOT16_DS;
1343 case BFD_RELOC_PPC64_PLTGOT16_LO_DS: ppc_reloc = R_PPC64_PLTGOT16_LO_DS;
1345 case BFD_RELOC_VTABLE_INHERIT: ppc_reloc = R_PPC64_GNU_VTINHERIT;
1347 case BFD_RELOC_VTABLE_ENTRY: ppc_reloc = R_PPC64_GNU_VTENTRY;
1351 return ppc64_elf_howto_table[(int) ppc_reloc];
1354 /* Set the howto pointer for a PowerPC ELF reloc. */
1357 ppc64_elf_info_to_howto (abfd, cache_ptr, dst)
1358 bfd *abfd ATTRIBUTE_UNUSED;
1360 Elf64_Internal_Rela *dst;
1364 /* Initialize howto table if needed. */
1365 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
1368 type = ELF64_R_TYPE (dst->r_info);
1369 BFD_ASSERT (type < (sizeof (ppc64_elf_howto_table)
1370 / sizeof (ppc64_elf_howto_table[0])));
1371 cache_ptr->howto = ppc64_elf_howto_table[type];
1374 /* Handle the R_PPC_ADDR16_HA and similar relocs. */
1376 static bfd_reloc_status_type
1377 ppc64_elf_ha_reloc (abfd, reloc_entry, symbol, data,
1378 input_section, output_bfd, error_message)
1380 arelent *reloc_entry;
1383 asection *input_section;
1385 char **error_message;
1387 /* If this is a relocatable link (output_bfd test tells us), just
1388 call the generic function. Any adjustment will be done at final
1390 if (output_bfd != NULL)
1391 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
1392 input_section, output_bfd, error_message);
1394 /* Adjust the addend for sign extension of the low 16 bits.
1395 We won't actually be using the low 16 bits, so trashing them
1397 reloc_entry->addend += 0x8000;
1398 return bfd_reloc_continue;
1401 static bfd_reloc_status_type
1402 ppc64_elf_brtaken_reloc (abfd, reloc_entry, symbol, data,
1403 input_section, output_bfd, error_message)
1405 arelent *reloc_entry;
1408 asection *input_section;
1410 char **error_message;
1413 enum elf_ppc_reloc_type r_type;
1414 bfd_size_type octets;
1415 /* Disabled until we sort out how ld should choose 'y' vs 'at'. */
1416 boolean is_power4 = false;
1418 /* If this is a relocatable link (output_bfd test tells us), just
1419 call the generic function. Any adjustment will be done at final
1421 if (output_bfd != NULL)
1422 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
1423 input_section, output_bfd, error_message);
1425 octets = reloc_entry->address * bfd_octets_per_byte (abfd);
1426 insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
1427 insn &= ~(0x01 << 21);
1428 r_type = (enum elf_ppc_reloc_type) reloc_entry->howto->type;
1429 if (r_type == R_PPC64_ADDR14_BRTAKEN
1430 || r_type == R_PPC64_REL14_BRTAKEN)
1431 insn |= 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field. */
1435 /* Set 'a' bit. This is 0b00010 in BO field for branch
1436 on CR(BI) insns (BO == 001at or 011at), and 0b01000
1437 for branch on CTR insns (BO == 1a00t or 1a01t). */
1438 if ((insn & (0x14 << 21)) == (0x04 << 21))
1440 else if ((insn & (0x14 << 21)) == (0x10 << 21))
1443 return bfd_reloc_continue;
1450 if (!bfd_is_com_section (symbol->section))
1451 target = symbol->value;
1452 target += symbol->section->output_section->vma;
1453 target += symbol->section->output_offset;
1454 target += reloc_entry->addend;
1456 from = (reloc_entry->address
1457 + input_section->output_offset
1458 + input_section->output_section->vma);
1460 /* Invert 'y' bit if not the default. */
1461 if ((bfd_signed_vma) (target - from) < 0)
1464 bfd_put_32 (abfd, (bfd_vma) insn, (bfd_byte *) data + octets);
1465 return bfd_reloc_continue;
1468 static bfd_reloc_status_type
1469 ppc64_elf_sectoff_reloc (abfd, reloc_entry, symbol, data,
1470 input_section, output_bfd, error_message)
1472 arelent *reloc_entry;
1475 asection *input_section;
1477 char **error_message;
1479 /* If this is a relocatable link (output_bfd test tells us), just
1480 call the generic function. Any adjustment will be done at final
1482 if (output_bfd != NULL)
1483 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
1484 input_section, output_bfd, error_message);
1486 /* Subtract the symbol section base address. */
1487 reloc_entry->addend -= symbol->section->output_section->vma;
1488 return bfd_reloc_continue;
1491 static bfd_reloc_status_type
1492 ppc64_elf_sectoff_ha_reloc (abfd, reloc_entry, symbol, data,
1493 input_section, output_bfd, error_message)
1495 arelent *reloc_entry;
1498 asection *input_section;
1500 char **error_message;
1502 /* If this is a relocatable link (output_bfd test tells us), just
1503 call the generic function. Any adjustment will be done at final
1505 if (output_bfd != NULL)
1506 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
1507 input_section, output_bfd, error_message);
1509 /* Subtract the symbol section base address. */
1510 reloc_entry->addend -= symbol->section->output_section->vma;
1512 /* Adjust the addend for sign extension of the low 16 bits. */
1513 reloc_entry->addend += 0x8000;
1514 return bfd_reloc_continue;
1517 static bfd_reloc_status_type
1518 ppc64_elf_toc_reloc (abfd, reloc_entry, symbol, data,
1519 input_section, output_bfd, error_message)
1521 arelent *reloc_entry;
1524 asection *input_section;
1526 char **error_message;
1530 /* If this is a relocatable link (output_bfd test tells us), just
1531 call the generic function. Any adjustment will be done at final
1533 if (output_bfd != NULL)
1534 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
1535 input_section, output_bfd, error_message);
1537 TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
1539 TOCstart = ppc64_elf_toc (input_section->output_section->owner);
1541 /* Subtract the TOC base address. */
1542 reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
1543 return bfd_reloc_continue;
1546 static bfd_reloc_status_type
1547 ppc64_elf_toc_ha_reloc (abfd, reloc_entry, symbol, data,
1548 input_section, output_bfd, error_message)
1550 arelent *reloc_entry;
1553 asection *input_section;
1555 char **error_message;
1559 /* If this is a relocatable link (output_bfd test tells us), just
1560 call the generic function. Any adjustment will be done at final
1562 if (output_bfd != NULL)
1563 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
1564 input_section, output_bfd, error_message);
1566 TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
1568 TOCstart = ppc64_elf_toc (input_section->output_section->owner);
1570 /* Subtract the TOC base address. */
1571 reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
1573 /* Adjust the addend for sign extension of the low 16 bits. */
1574 reloc_entry->addend += 0x8000;
1575 return bfd_reloc_continue;
1578 static bfd_reloc_status_type
1579 ppc64_elf_toc64_reloc (abfd, reloc_entry, symbol, data,
1580 input_section, output_bfd, error_message)
1582 arelent *reloc_entry;
1585 asection *input_section;
1587 char **error_message;
1590 bfd_size_type octets;
1592 /* If this is a relocatable link (output_bfd test tells us), just
1593 call the generic function. Any adjustment will be done at final
1595 if (output_bfd != NULL)
1596 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
1597 input_section, output_bfd, error_message);
1599 TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
1601 TOCstart = ppc64_elf_toc (input_section->output_section->owner);
1603 octets = reloc_entry->address * bfd_octets_per_byte (abfd);
1604 bfd_put_64 (abfd, TOCstart + TOC_BASE_OFF, (bfd_byte *) data + octets);
1605 return bfd_reloc_ok;
1608 static bfd_reloc_status_type
1609 ppc64_elf_unhandled_reloc (abfd, reloc_entry, symbol, data,
1610 input_section, output_bfd, error_message)
1612 arelent *reloc_entry;
1615 asection *input_section;
1617 char **error_message;
1619 /* If this is a relocatable link (output_bfd test tells us), just
1620 call the generic function. Any adjustment will be done at final
1622 if (output_bfd != NULL)
1623 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
1624 input_section, output_bfd, error_message);
1626 if (error_message != NULL)
1628 static char buf[60];
1629 sprintf (buf, "generic linker can't handle %s",
1630 reloc_entry->howto->name);
1631 *error_message = buf;
1633 return bfd_reloc_dangerous;
1636 /* Return symbol info as per usual for ELF targets, except that
1637 symbols in .opd are given 'd' or 'D' for type. */
1640 ppc64_elf_get_symbol_info (abfd, symbol, ret)
1645 _bfd_elf_get_symbol_info (abfd, symbol, ret);
1646 if (ret->type == '?'
1647 && (symbol->flags & (BSF_GLOBAL | BSF_LOCAL)) != 0
1648 && strcmp (symbol->section->name, ".opd") == 0)
1649 ret->type = (symbol->flags & BSF_GLOBAL) != 0 ? 'D' : 'd';
1652 /* Function to set whether a module needs the -mrelocatable bit set. */
1655 ppc64_elf_set_private_flags (abfd, flags)
1659 BFD_ASSERT (!elf_flags_init (abfd)
1660 || elf_elfheader (abfd)->e_flags == flags);
1662 elf_elfheader (abfd)->e_flags = flags;
1663 elf_flags_init (abfd) = true;
1667 /* Merge backend specific data from an object file to the output
1668 object file when linking. */
1670 ppc64_elf_merge_private_bfd_data (ibfd, obfd)
1678 /* Check if we have the same endianess. */
1679 if (ibfd->xvec->byteorder != obfd->xvec->byteorder
1680 && obfd->xvec->byteorder != BFD_ENDIAN_UNKNOWN)
1684 if (bfd_big_endian (ibfd))
1685 msg = _("%s: compiled for a big endian system and target is little endian");
1687 msg = _("%s: compiled for a little endian system and target is big endian");
1689 (*_bfd_error_handler) (msg, bfd_archive_filename (ibfd));
1691 bfd_set_error (bfd_error_wrong_format);
1695 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
1696 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
1699 new_flags = elf_elfheader (ibfd)->e_flags;
1700 old_flags = elf_elfheader (obfd)->e_flags;
1701 if (!elf_flags_init (obfd))
1703 /* First call, no flags set. */
1704 elf_flags_init (obfd) = true;
1705 elf_elfheader (obfd)->e_flags = new_flags;
1708 else if (new_flags == old_flags)
1709 /* Compatible flags are ok. */
1714 /* Incompatible flags. Warn about -mrelocatable mismatch.
1715 Allow -mrelocatable-lib to be linked with either. */
1717 if ((new_flags & EF_PPC_RELOCATABLE) != 0
1718 && (old_flags & (EF_PPC_RELOCATABLE | EF_PPC_RELOCATABLE_LIB)) == 0)
1721 (*_bfd_error_handler)
1722 (_("%s: compiled with -mrelocatable and linked with modules compiled normally"),
1723 bfd_archive_filename (ibfd));
1725 else if ((new_flags & (EF_PPC_RELOCATABLE | EF_PPC_RELOCATABLE_LIB)) == 0
1726 && (old_flags & EF_PPC_RELOCATABLE) != 0)
1729 (*_bfd_error_handler)
1730 (_("%s: compiled normally and linked with modules compiled with -mrelocatable"),
1731 bfd_archive_filename (ibfd));
1734 /* The output is -mrelocatable-lib iff both the input files are. */
1735 if (! (new_flags & EF_PPC_RELOCATABLE_LIB))
1736 elf_elfheader (obfd)->e_flags &= ~EF_PPC_RELOCATABLE_LIB;
1738 /* The output is -mrelocatable iff it can't be -mrelocatable-lib,
1739 but each input file is either -mrelocatable or -mrelocatable-lib. */
1740 if (! (elf_elfheader (obfd)->e_flags & EF_PPC_RELOCATABLE_LIB)
1741 && (new_flags & (EF_PPC_RELOCATABLE_LIB | EF_PPC_RELOCATABLE))
1742 && (old_flags & (EF_PPC_RELOCATABLE_LIB | EF_PPC_RELOCATABLE)))
1743 elf_elfheader (obfd)->e_flags |= EF_PPC_RELOCATABLE;
1745 /* Do not warn about eabi vs. V.4 mismatch, just or in the bit
1746 if any module uses it. */
1747 elf_elfheader (obfd)->e_flags |= (new_flags & EF_PPC_EMB);
1749 new_flags &= ~(EF_PPC_RELOCATABLE | EF_PPC_RELOCATABLE_LIB | EF_PPC_EMB);
1750 old_flags &= ~(EF_PPC_RELOCATABLE | EF_PPC_RELOCATABLE_LIB | EF_PPC_EMB);
1752 /* Warn about any other mismatches. */
1753 if (new_flags != old_flags)
1756 (*_bfd_error_handler)
1757 (_("%s: uses different e_flags (0x%lx) fields than previous modules (0x%lx)"),
1758 bfd_archive_filename (ibfd), (long) new_flags, (long) old_flags);
1763 bfd_set_error (bfd_error_bad_value);
1771 /* Handle a PowerPC specific section when reading an object file. This
1772 is called when elfcode.h finds a section with an unknown type. */
1775 ppc64_elf_section_from_shdr (abfd, hdr, name)
1777 Elf64_Internal_Shdr *hdr;
1783 if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name))
1786 newsect = hdr->bfd_section;
1787 flags = bfd_get_section_flags (abfd, newsect);
1788 if (hdr->sh_flags & SHF_EXCLUDE)
1789 flags |= SEC_EXCLUDE;
1791 if (hdr->sh_type == SHT_ORDERED)
1792 flags |= SEC_SORT_ENTRIES;
1794 bfd_set_section_flags (abfd, newsect, flags);
1798 /* The following functions are specific to the ELF linker, while
1799 functions above are used generally. Those named ppc64_elf_* are
1800 called by the main ELF linker code. They appear in this file more
1801 or less in the order in which they are called. eg.
1802 ppc64_elf_check_relocs is called early in the link process,
1803 ppc64_elf_finish_dynamic_sections is one of the last functions
1806 PowerPC64-ELF uses a similar scheme to PowerPC64-XCOFF in that
1807 functions have both a function code symbol and a function descriptor
1808 symbol. A call to foo in a relocatable object file looks like:
1815 The function definition in another object file might be:
1819 . .quad .TOC.@tocbase
1825 When the linker resolves the call during a static link, the branch
1826 unsurprisingly just goes to .foo and the .opd information is unused.
1827 If the function definition is in a shared library, things are a little
1828 different: The call goes via a plt call stub, the opd information gets
1829 copied to the plt, and the linker patches the nop.
1837 . addis 12,2,Lfoo@toc@ha # in practice, the call stub
1838 . addi 12,12,Lfoo@toc@l # is slightly optimised, but
1839 . std 2,40(1) # this is the general idea
1847 . Lfoo: reloc (R_PPC64_JMP_SLOT, foo)
1849 The "reloc ()" notation is supposed to indicate that the linker emits
1850 an R_PPC64_JMP_SLOT reloc against foo. The dynamic linker does the opd
1853 What are the difficulties here? Well, firstly, the relocations
1854 examined by the linker in check_relocs are against the function code
1855 sym .foo, while the dynamic relocation in the plt is emitted against
1856 the function descriptor symbol, foo. Somewhere along the line, we need
1857 to carefully copy dynamic link information from one symbol to the other.
1858 Secondly, the generic part of the elf linker will make .foo a dynamic
1859 symbol as is normal for most other backends. We need foo dynamic
1860 instead, at least for an application final link. However, when
1861 creating a shared library containing foo, we need to have both symbols
1862 dynamic so that references to .foo are satisfied during the early
1863 stages of linking. Otherwise the linker might decide to pull in a
1864 definition from some other object, eg. a static library. */
1866 /* The linker needs to keep track of the number of relocs that it
1867 decides to copy as dynamic relocs in check_relocs for each symbol.
1868 This is so that it can later discard them if they are found to be
1869 unnecessary. We store the information in a field extending the
1870 regular ELF linker hash table. */
1872 struct ppc_dyn_relocs
1874 struct ppc_dyn_relocs *next;
1876 /* The input section of the reloc. */
1879 /* Total number of relocs copied for the input section. */
1880 bfd_size_type count;
1882 /* Number of pc-relative relocs copied for the input section. */
1883 bfd_size_type pc_count;
1886 /* Of those relocs that might be copied as dynamic relocs, this macro
1887 selects between relative and absolute types. */
1889 #define IS_ABSOLUTE_RELOC(RTYPE) \
1890 ((RTYPE) != R_PPC64_REL32 \
1891 && (RTYPE) != R_PPC64_REL64 \
1892 && (RTYPE) != R_PPC64_ADDR30)
1894 /* Section name for stubs is the associated section name plus this
1896 #define STUB_SUFFIX ".stub"
1899 ppc_stub_long_branch:
1900 Used when a 14 bit branch (or even a 24 bit branch) can't reach its
1901 destination, but a 24 bit branch in a stub section will reach.
1904 ppc_stub_plt_branch:
1905 Similar to the above, but a 24 bit branch in the stub section won't
1906 reach its destination.
1907 . addis %r12,%r2,xxx@ha
1908 . ld %r11,xxx@l(%r12)
1913 Used to call a function in a shared library.
1914 . addis %r12,%r2,xxx@ha
1916 . ld %r11,xxx+0@l(%r12)
1917 . ld %r2,xxx+8@l(%r12)
1919 . ld %r11,xxx+16@l(%r12)
1923 enum ppc_stub_type {
1925 ppc_stub_long_branch,
1926 ppc_stub_plt_branch,
1930 struct ppc_stub_hash_entry {
1932 /* Base hash table entry structure. */
1933 struct bfd_hash_entry root;
1935 /* The stub section. */
1938 /* Offset within stub_sec of the beginning of this stub. */
1939 bfd_vma stub_offset;
1941 /* Given the symbol's value and its section we can determine its final
1942 value when building the stubs (so the stub knows where to jump. */
1943 bfd_vma target_value;
1944 asection *target_section;
1946 enum ppc_stub_type stub_type;
1948 /* The symbol table entry, if any, that this was derived from. */
1949 struct ppc_link_hash_entry *h;
1951 /* Where this stub is being called from, or, in the case of combined
1952 stub sections, the first input section in the group. */
1956 struct ppc_branch_hash_entry {
1958 /* Base hash table entry structure. */
1959 struct bfd_hash_entry root;
1961 /* Offset within .branch_lt. */
1962 unsigned int offset;
1964 /* Generation marker. */
1968 struct ppc_link_hash_entry
1970 struct elf_link_hash_entry elf;
1972 /* A pointer to the most recently used stub hash entry against this
1974 struct ppc_stub_hash_entry *stub_cache;
1976 /* Track dynamic relocs copied for this symbol. */
1977 struct ppc_dyn_relocs *dyn_relocs;
1979 /* Link between function code and descriptor symbols. */
1980 struct elf_link_hash_entry *oh;
1982 /* Flag function code and descriptor symbols. */
1983 unsigned int is_func:1;
1984 unsigned int is_func_descriptor:1;
1987 /* ppc64 ELF linker hash table. */
1989 struct ppc_link_hash_table
1991 struct elf_link_hash_table elf;
1993 /* The stub hash table. */
1994 struct bfd_hash_table stub_hash_table;
1996 /* Another hash table for plt_branch stubs. */
1997 struct bfd_hash_table branch_hash_table;
1999 /* Linker stub bfd. */
2002 /* Linker call-backs. */
2003 asection * (*add_stub_section) PARAMS ((const char *, asection *));
2004 void (*layout_sections_again) PARAMS ((void));
2006 /* Array to keep track of which stub sections have been created, and
2007 information on stub grouping. */
2009 /* This is the section to which stubs in the group will be attached. */
2011 /* The stub section. */
2015 /* Assorted information used by ppc64_elf_size_stubs. */
2016 unsigned int bfd_count;
2018 asection **input_list;
2019 Elf_Internal_Sym **all_local_syms;
2021 /* Short-cuts to get to dynamic linker sections. */
2034 unsigned int stub_error;
2036 /* Flag set when small branches are detected. Used to
2037 select suitable defaults for the stub group size. */
2038 unsigned int has_14bit_branch;
2040 /* Set if we detect a reference undefined weak symbol. */
2041 unsigned int have_undefweak;
2043 /* Incremented every time we size stubs. */
2044 unsigned int stub_iteration;
2046 /* Small local sym to section mapping cache. */
2047 struct sym_sec_cache sym_sec;
2050 static struct bfd_hash_entry *stub_hash_newfunc
2051 PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
2052 static struct bfd_hash_entry *branch_hash_newfunc
2053 PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
2054 static struct bfd_hash_entry *link_hash_newfunc
2055 PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
2056 static struct bfd_link_hash_table *ppc64_elf_link_hash_table_create
2058 static void ppc64_elf_link_hash_table_free
2059 PARAMS ((struct bfd_link_hash_table *));
2060 static char *ppc_stub_name
2061 PARAMS ((const asection *, const asection *,
2062 const struct ppc_link_hash_entry *, const Elf_Internal_Rela *));
2063 static struct ppc_stub_hash_entry *ppc_get_stub_entry
2064 PARAMS ((const asection *, const asection *, struct elf_link_hash_entry *,
2065 const Elf_Internal_Rela *, struct ppc_link_hash_table *));
2066 static struct ppc_stub_hash_entry *ppc_add_stub
2067 PARAMS ((const char *, asection *, struct ppc_link_hash_table *));
2068 static boolean create_linkage_sections
2069 PARAMS ((bfd *, struct bfd_link_info *));
2070 static boolean create_got_section
2071 PARAMS ((bfd *, struct bfd_link_info *));
2072 static boolean ppc64_elf_create_dynamic_sections
2073 PARAMS ((bfd *, struct bfd_link_info *));
2074 static void ppc64_elf_copy_indirect_symbol
2075 PARAMS ((struct elf_link_hash_entry *, struct elf_link_hash_entry *));
2076 static boolean ppc64_elf_check_relocs
2077 PARAMS ((bfd *, struct bfd_link_info *, asection *,
2078 const Elf_Internal_Rela *));
2079 static asection * ppc64_elf_gc_mark_hook
2080 PARAMS ((bfd *abfd, struct bfd_link_info *info, Elf_Internal_Rela *rel,
2081 struct elf_link_hash_entry *h, Elf_Internal_Sym *sym));
2082 static boolean ppc64_elf_gc_sweep_hook
2083 PARAMS ((bfd *abfd, struct bfd_link_info *info, asection *sec,
2084 const Elf_Internal_Rela *relocs));
2085 static boolean func_desc_adjust
2086 PARAMS ((struct elf_link_hash_entry *, PTR));
2087 static boolean ppc64_elf_func_desc_adjust
2088 PARAMS ((bfd *, struct bfd_link_info *));
2089 static boolean ppc64_elf_adjust_dynamic_symbol
2090 PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *));
2091 static void ppc64_elf_hide_symbol
2092 PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *, boolean));
2093 static boolean allocate_dynrelocs
2094 PARAMS ((struct elf_link_hash_entry *, PTR));
2095 static boolean readonly_dynrelocs
2096 PARAMS ((struct elf_link_hash_entry *, PTR));
2097 static enum elf_reloc_type_class ppc64_elf_reloc_type_class
2098 PARAMS ((const Elf_Internal_Rela *));
2099 static boolean ppc64_elf_size_dynamic_sections
2100 PARAMS ((bfd *, struct bfd_link_info *));
2101 static INLINE enum ppc_stub_type ppc_type_of_stub
2102 PARAMS ((asection *, const Elf_Internal_Rela *,
2103 struct ppc_link_hash_entry **, bfd_vma));
2104 static bfd_byte *build_plt_stub
2105 PARAMS ((bfd *, bfd_byte *, int, int));
2106 static boolean ppc_build_one_stub
2107 PARAMS ((struct bfd_hash_entry *, PTR));
2108 static boolean ppc_size_one_stub
2109 PARAMS ((struct bfd_hash_entry *, PTR));
2110 static void group_sections
2111 PARAMS ((struct ppc_link_hash_table *, bfd_size_type, boolean));
2112 static boolean get_local_syms
2113 PARAMS ((bfd *, struct ppc_link_hash_table *));
2114 static boolean ppc64_elf_fake_sections
2115 PARAMS ((bfd *, Elf64_Internal_Shdr *, asection *));
2116 static boolean ppc64_elf_relocate_section
2117 PARAMS ((bfd *, struct bfd_link_info *info, bfd *, asection *, bfd_byte *,
2118 Elf_Internal_Rela *relocs, Elf_Internal_Sym *local_syms,
2120 static boolean ppc64_elf_finish_dynamic_symbol
2121 PARAMS ((bfd *, struct bfd_link_info *, struct elf_link_hash_entry *,
2122 Elf_Internal_Sym *));
2123 static boolean ppc64_elf_finish_dynamic_sections
2124 PARAMS ((bfd *, struct bfd_link_info *));
2126 /* Get the ppc64 ELF linker hash table from a link_info structure. */
2128 #define ppc_hash_table(p) \
2129 ((struct ppc_link_hash_table *) ((p)->hash))
2131 #define ppc_stub_hash_lookup(table, string, create, copy) \
2132 ((struct ppc_stub_hash_entry *) \
2133 bfd_hash_lookup ((table), (string), (create), (copy)))
2135 #define ppc_branch_hash_lookup(table, string, create, copy) \
2136 ((struct ppc_branch_hash_entry *) \
2137 bfd_hash_lookup ((table), (string), (create), (copy)))
2139 /* Create an entry in the stub hash table. */
2141 static struct bfd_hash_entry *
2142 stub_hash_newfunc (entry, table, string)
2143 struct bfd_hash_entry *entry;
2144 struct bfd_hash_table *table;
2147 /* Allocate the structure if it has not already been allocated by a
2151 entry = bfd_hash_allocate (table, sizeof (struct ppc_stub_hash_entry));
2156 /* Call the allocation method of the superclass. */
2157 entry = bfd_hash_newfunc (entry, table, string);
2160 struct ppc_stub_hash_entry *eh;
2162 /* Initialize the local fields. */
2163 eh = (struct ppc_stub_hash_entry *) entry;
2164 eh->stub_sec = NULL;
2165 eh->stub_offset = 0;
2166 eh->target_value = 0;
2167 eh->target_section = NULL;
2168 eh->stub_type = ppc_stub_none;
2176 /* Create an entry in the branch hash table. */
2178 static struct bfd_hash_entry *
2179 branch_hash_newfunc (entry, table, string)
2180 struct bfd_hash_entry *entry;
2181 struct bfd_hash_table *table;
2184 /* Allocate the structure if it has not already been allocated by a
2188 entry = bfd_hash_allocate (table, sizeof (struct ppc_branch_hash_entry));
2193 /* Call the allocation method of the superclass. */
2194 entry = bfd_hash_newfunc (entry, table, string);
2197 struct ppc_branch_hash_entry *eh;
2199 /* Initialize the local fields. */
2200 eh = (struct ppc_branch_hash_entry *) entry;
2208 /* Create an entry in a ppc64 ELF linker hash table. */
2210 static struct bfd_hash_entry *
2211 link_hash_newfunc (entry, table, string)
2212 struct bfd_hash_entry *entry;
2213 struct bfd_hash_table *table;
2216 /* Allocate the structure if it has not already been allocated by a
2220 entry = bfd_hash_allocate (table, sizeof (struct ppc_link_hash_entry));
2225 /* Call the allocation method of the superclass. */
2226 entry = _bfd_elf_link_hash_newfunc (entry, table, string);
2229 struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) entry;
2231 eh->stub_cache = NULL;
2232 eh->dyn_relocs = NULL;
2235 eh->is_func_descriptor = 0;
2241 /* Create a ppc64 ELF linker hash table. */
2243 static struct bfd_link_hash_table *
2244 ppc64_elf_link_hash_table_create (abfd)
2247 struct ppc_link_hash_table *htab;
2248 bfd_size_type amt = sizeof (struct ppc_link_hash_table);
2250 htab = (struct ppc_link_hash_table *) bfd_malloc (amt);
2254 if (! _bfd_elf_link_hash_table_init (&htab->elf, abfd, link_hash_newfunc))
2260 /* Init the stub hash table too. */
2261 if (!bfd_hash_table_init (&htab->stub_hash_table, stub_hash_newfunc))
2264 /* And the branch hash table. */
2265 if (!bfd_hash_table_init (&htab->branch_hash_table, branch_hash_newfunc))
2268 htab->stub_bfd = NULL;
2269 htab->add_stub_section = NULL;
2270 htab->layout_sections_again = NULL;
2271 htab->stub_group = NULL;
2273 htab->srelgot = NULL;
2275 htab->srelplt = NULL;
2276 htab->sdynbss = NULL;
2277 htab->srelbss = NULL;
2278 htab->sglink = NULL;
2281 htab->srelbrlt = NULL;
2282 htab->stub_error = 0;
2283 htab->has_14bit_branch = 0;
2284 htab->have_undefweak = 0;
2285 htab->stub_iteration = 0;
2286 htab->sym_sec.abfd = NULL;
2288 return &htab->elf.root;
2291 /* Free the derived linker hash table. */
2294 ppc64_elf_link_hash_table_free (hash)
2295 struct bfd_link_hash_table *hash;
2297 struct ppc_link_hash_table *ret = (struct ppc_link_hash_table *) hash;
2299 bfd_hash_table_free (&ret->stub_hash_table);
2300 bfd_hash_table_free (&ret->branch_hash_table);
2301 _bfd_generic_link_hash_table_free (hash);
2304 /* Build a name for an entry in the stub hash table. */
2307 ppc_stub_name (input_section, sym_sec, h, rel)
2308 const asection *input_section;
2309 const asection *sym_sec;
2310 const struct ppc_link_hash_entry *h;
2311 const Elf_Internal_Rela *rel;
2316 /* rel->r_addend is actually 64 bit, but who uses more than +/- 2^31
2317 offsets from a sym as a branch target? In fact, we could
2318 probably assume the addend is always zero. */
2319 BFD_ASSERT (((int) rel->r_addend & 0xffffffff) == rel->r_addend);
2323 len = 8 + 1 + strlen (h->elf.root.root.string) + 1 + 8 + 1;
2324 stub_name = bfd_malloc (len);
2325 if (stub_name != NULL)
2327 sprintf (stub_name, "%08x_%s+%x",
2328 input_section->id & 0xffffffff,
2329 h->elf.root.root.string,
2330 (int) rel->r_addend & 0xffffffff);
2335 len = 8 + 1 + 8 + 1 + 8 + 1 + 16 + 1;
2336 stub_name = bfd_malloc (len);
2337 if (stub_name != NULL)
2339 sprintf (stub_name, "%08x_%x:%x+%x",
2340 input_section->id & 0xffffffff,
2341 sym_sec->id & 0xffffffff,
2342 (int) ELF64_R_SYM (rel->r_info) & 0xffffffff,
2343 (int) rel->r_addend & 0xffffffff);
2349 /* Look up an entry in the stub hash. Stub entries are cached because
2350 creating the stub name takes a bit of time. */
2352 static struct ppc_stub_hash_entry *
2353 ppc_get_stub_entry (input_section, sym_sec, hash, rel, htab)
2354 const asection *input_section;
2355 const asection *sym_sec;
2356 struct elf_link_hash_entry *hash;
2357 const Elf_Internal_Rela *rel;
2358 struct ppc_link_hash_table *htab;
2360 struct ppc_stub_hash_entry *stub_entry;
2361 struct ppc_link_hash_entry *h = (struct ppc_link_hash_entry *) hash;
2362 const asection *id_sec;
2364 /* If this input section is part of a group of sections sharing one
2365 stub section, then use the id of the first section in the group.
2366 Stub names need to include a section id, as there may well be
2367 more than one stub used to reach say, printf, and we need to
2368 distinguish between them. */
2369 id_sec = htab->stub_group[input_section->id].link_sec;
2371 if (h != NULL && h->stub_cache != NULL
2372 && h->stub_cache->h == h
2373 && h->stub_cache->id_sec == id_sec)
2375 stub_entry = h->stub_cache;
2381 stub_name = ppc_stub_name (id_sec, sym_sec, h, rel);
2382 if (stub_name == NULL)
2385 stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
2386 stub_name, false, false);
2388 h->stub_cache = stub_entry;
2396 /* Add a new stub entry to the stub hash. Not all fields of the new
2397 stub entry are initialised. */
2399 static struct ppc_stub_hash_entry *
2400 ppc_add_stub (stub_name, section, htab)
2401 const char *stub_name;
2403 struct ppc_link_hash_table *htab;
2407 struct ppc_stub_hash_entry *stub_entry;
2409 link_sec = htab->stub_group[section->id].link_sec;
2410 stub_sec = htab->stub_group[section->id].stub_sec;
2411 if (stub_sec == NULL)
2413 stub_sec = htab->stub_group[link_sec->id].stub_sec;
2414 if (stub_sec == NULL)
2419 len = strlen (link_sec->name) + sizeof (STUB_SUFFIX);
2420 s_name = bfd_alloc (htab->stub_bfd, len);
2424 strcpy (s_name, link_sec->name);
2425 strcpy (s_name + len - sizeof (STUB_SUFFIX), STUB_SUFFIX);
2426 stub_sec = (*htab->add_stub_section) (s_name, link_sec);
2427 if (stub_sec == NULL)
2429 htab->stub_group[link_sec->id].stub_sec = stub_sec;
2431 htab->stub_group[section->id].stub_sec = stub_sec;
2434 /* Enter this entry into the linker stub hash table. */
2435 stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table, stub_name,
2437 if (stub_entry == NULL)
2439 (*_bfd_error_handler) (_("%s: cannot create stub entry %s"),
2440 bfd_archive_filename (section->owner),
2445 stub_entry->stub_sec = stub_sec;
2446 stub_entry->stub_offset = 0;
2447 stub_entry->id_sec = link_sec;
2451 /* Create sections for linker generated code. */
2454 create_linkage_sections (dynobj, info)
2456 struct bfd_link_info *info;
2458 struct ppc_link_hash_table *htab;
2461 htab = ppc_hash_table (info);
2463 /* Create .sfpr for code to save and restore fp regs. */
2464 flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY
2465 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
2466 htab->sfpr = bfd_make_section_anyway (dynobj, ".sfpr");
2467 if (htab->sfpr == NULL
2468 || ! bfd_set_section_flags (dynobj, htab->sfpr, flags)
2469 || ! bfd_set_section_alignment (dynobj, htab->sfpr, 2))
2472 /* Create .glink for lazy dynamic linking support. */
2473 htab->sglink = bfd_make_section_anyway (dynobj, ".glink");
2474 if (htab->sglink == NULL
2475 || ! bfd_set_section_flags (dynobj, htab->sglink, flags)
2476 || ! bfd_set_section_alignment (dynobj, htab->sglink, 2))
2479 /* Create .branch_lt for plt_branch stubs. */
2480 flags = (SEC_ALLOC | SEC_LOAD
2481 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
2482 htab->sbrlt = bfd_make_section_anyway (dynobj, ".branch_lt");
2483 if (htab->sbrlt == NULL
2484 || ! bfd_set_section_flags (dynobj, htab->sbrlt, flags)
2485 || ! bfd_set_section_alignment (dynobj, htab->sbrlt, 3))
2490 flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
2491 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
2492 htab->srelbrlt = bfd_make_section (dynobj, ".rela.branch_lt");
2494 || ! bfd_set_section_flags (dynobj, htab->srelbrlt, flags)
2495 || ! bfd_set_section_alignment (dynobj, htab->srelbrlt, 3))
2501 /* Create .got and .rela.got sections in DYNOBJ, and set up
2502 shortcuts to them in our hash table. */
2505 create_got_section (dynobj, info)
2507 struct bfd_link_info *info;
2509 struct ppc_link_hash_table *htab;
2511 if (! _bfd_elf_create_got_section (dynobj, info))
2514 htab = ppc_hash_table (info);
2515 htab->sgot = bfd_get_section_by_name (dynobj, ".got");
2519 htab->srelgot = bfd_make_section (dynobj, ".rela.got");
2521 || ! bfd_set_section_flags (dynobj, htab->srelgot,
2522 (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS
2523 | SEC_IN_MEMORY | SEC_LINKER_CREATED
2525 || ! bfd_set_section_alignment (dynobj, htab->srelgot, 3))
2530 /* Create the dynamic sections, and set up shortcuts. */
2533 ppc64_elf_create_dynamic_sections (dynobj, info)
2535 struct bfd_link_info *info;
2537 struct ppc_link_hash_table *htab;
2539 htab = ppc_hash_table (info);
2540 if (!htab->sgot && !create_got_section (dynobj, info))
2543 if (!_bfd_elf_create_dynamic_sections (dynobj, info))
2546 htab->splt = bfd_get_section_by_name (dynobj, ".plt");
2547 htab->srelplt = bfd_get_section_by_name (dynobj, ".rela.plt");
2548 htab->sdynbss = bfd_get_section_by_name (dynobj, ".dynbss");
2550 htab->srelbss = bfd_get_section_by_name (dynobj, ".rela.bss");
2552 if (!htab->splt || !htab->srelplt || !htab->sdynbss
2553 || (!info->shared && !htab->srelbss))
2559 /* Copy the extra info we tack onto an elf_link_hash_entry. */
2562 ppc64_elf_copy_indirect_symbol (dir, ind)
2563 struct elf_link_hash_entry *dir, *ind;
2565 struct ppc_link_hash_entry *edir, *eind;
2567 edir = (struct ppc_link_hash_entry *) dir;
2568 eind = (struct ppc_link_hash_entry *) ind;
2570 if (eind->dyn_relocs != NULL)
2572 if (edir->dyn_relocs != NULL)
2574 struct ppc_dyn_relocs **pp;
2575 struct ppc_dyn_relocs *p;
2577 if (ind->root.type == bfd_link_hash_indirect)
2580 /* Add reloc counts against the weak sym to the strong sym
2581 list. Merge any entries against the same section. */
2582 for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
2584 struct ppc_dyn_relocs *q;
2586 for (q = edir->dyn_relocs; q != NULL; q = q->next)
2587 if (q->sec == p->sec)
2589 q->pc_count += p->pc_count;
2590 q->count += p->count;
2597 *pp = edir->dyn_relocs;
2600 edir->dyn_relocs = eind->dyn_relocs;
2601 eind->dyn_relocs = NULL;
2604 edir->is_func |= eind->is_func;
2605 edir->is_func_descriptor |= eind->is_func_descriptor;
2607 _bfd_elf_link_hash_copy_indirect (dir, ind);
2610 /* Look through the relocs for a section during the first phase, and
2611 calculate needed space in the global offset table, procedure
2612 linkage table, and dynamic reloc sections. */
2615 ppc64_elf_check_relocs (abfd, info, sec, relocs)
2617 struct bfd_link_info *info;
2619 const Elf_Internal_Rela *relocs;
2621 struct ppc_link_hash_table *htab;
2622 Elf_Internal_Shdr *symtab_hdr;
2623 struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
2624 const Elf_Internal_Rela *rel;
2625 const Elf_Internal_Rela *rel_end;
2629 if (info->relocateable)
2632 htab = ppc_hash_table (info);
2633 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2635 sym_hashes = elf_sym_hashes (abfd);
2636 sym_hashes_end = (sym_hashes
2637 + symtab_hdr->sh_size / sizeof (Elf64_External_Sym));
2638 if (!elf_bad_symtab (abfd))
2639 sym_hashes_end -= symtab_hdr->sh_info;
2642 is_opd = strcmp (bfd_get_section_name (abfd, sec), ".opd") == 0;
2644 if (htab->elf.dynobj == NULL)
2645 htab->elf.dynobj = abfd;
2646 if (htab->sfpr == NULL
2647 && !create_linkage_sections (htab->elf.dynobj, info))
2650 rel_end = relocs + sec->reloc_count;
2651 for (rel = relocs; rel < rel_end; rel++)
2653 unsigned long r_symndx;
2654 struct elf_link_hash_entry *h;
2655 enum elf_ppc_reloc_type r_type;
2657 r_symndx = ELF64_R_SYM (rel->r_info);
2658 if (r_symndx < symtab_hdr->sh_info)
2661 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2663 r_type = (enum elf_ppc_reloc_type) ELF64_R_TYPE (rel->r_info);
2666 /* GOT16 relocations */
2668 case R_PPC64_GOT16_DS:
2669 case R_PPC64_GOT16_HA:
2670 case R_PPC64_GOT16_HI:
2671 case R_PPC64_GOT16_LO:
2672 case R_PPC64_GOT16_LO_DS:
2674 /* This symbol requires a global offset table entry. */
2675 if (htab->sgot == NULL
2676 && !create_got_section (htab->elf.dynobj, info))
2681 h->got.refcount += 1;
2685 bfd_signed_vma *local_got_refcounts;
2687 /* This is a global offset table entry for a local symbol. */
2688 local_got_refcounts = elf_local_got_refcounts (abfd);
2689 if (local_got_refcounts == NULL)
2693 size = symtab_hdr->sh_info;
2694 size *= sizeof (bfd_signed_vma);
2695 local_got_refcounts = ((bfd_signed_vma *)
2696 bfd_zalloc (abfd, size));
2697 if (local_got_refcounts == NULL)
2699 elf_local_got_refcounts (abfd) = local_got_refcounts;
2701 local_got_refcounts[r_symndx] += 1;
2705 case R_PPC64_PLT16_HA:
2706 case R_PPC64_PLT16_HI:
2707 case R_PPC64_PLT16_LO:
2710 /* This symbol requires a procedure linkage table entry. We
2711 actually build the entry in adjust_dynamic_symbol,
2712 because this might be a case of linking PIC code without
2713 linking in any dynamic objects, in which case we don't
2714 need to generate a procedure linkage table after all. */
2717 /* It does not make sense to have a procedure linkage
2718 table entry for a local symbol. */
2719 bfd_set_error (bfd_error_bad_value);
2723 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
2724 h->plt.refcount += 1;
2725 ((struct ppc_link_hash_entry *) h)->is_func = 1;
2728 /* The following relocations don't need to propagate the
2729 relocation if linking a shared object since they are
2730 section relative. */
2731 case R_PPC64_SECTOFF:
2732 case R_PPC64_SECTOFF_LO:
2733 case R_PPC64_SECTOFF_HI:
2734 case R_PPC64_SECTOFF_HA:
2735 case R_PPC64_SECTOFF_DS:
2736 case R_PPC64_SECTOFF_LO_DS:
2738 case R_PPC64_TOC16_LO:
2739 case R_PPC64_TOC16_HI:
2740 case R_PPC64_TOC16_HA:
2741 case R_PPC64_TOC16_DS:
2742 case R_PPC64_TOC16_LO_DS:
2745 /* This relocation describes the C++ object vtable hierarchy.
2746 Reconstruct it for later use during GC. */
2747 case R_PPC64_GNU_VTINHERIT:
2748 if (!_bfd_elf64_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
2752 /* This relocation describes which C++ vtable entries are actually
2753 used. Record for later use during GC. */
2754 case R_PPC64_GNU_VTENTRY:
2755 if (!_bfd_elf64_gc_record_vtentry (abfd, sec, h, rel->r_addend))
2760 case R_PPC64_REL14_BRTAKEN:
2761 case R_PPC64_REL14_BRNTAKEN:
2762 htab->has_14bit_branch = 1;
2767 && h->root.root.string[0] == '.'
2768 && h->root.root.string[1] != 0)
2770 /* We may need a .plt entry if the function this reloc
2771 refers to is in a shared lib. */
2772 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
2773 h->plt.refcount += 1;
2774 ((struct ppc_link_hash_entry *) h)->is_func = 1;
2778 case R_PPC64_ADDR64:
2781 && h->root.root.string[0] == '.'
2782 && h->root.root.string[1] != 0)
2784 struct elf_link_hash_entry *fdh;
2786 fdh = elf_link_hash_lookup (&htab->elf, h->root.root.string + 1,
2787 false, false, false);
2790 ((struct ppc_link_hash_entry *) fdh)->is_func_descriptor = 1;
2791 ((struct ppc_link_hash_entry *) fdh)->oh = h;
2792 ((struct ppc_link_hash_entry *) h)->is_func = 1;
2793 ((struct ppc_link_hash_entry *) h)->oh = fdh;
2800 case R_PPC64_ADDR14:
2801 case R_PPC64_ADDR14_BRNTAKEN:
2802 case R_PPC64_ADDR14_BRTAKEN:
2803 case R_PPC64_ADDR16:
2804 case R_PPC64_ADDR16_DS:
2805 case R_PPC64_ADDR16_HA:
2806 case R_PPC64_ADDR16_HI:
2807 case R_PPC64_ADDR16_HIGHER:
2808 case R_PPC64_ADDR16_HIGHERA:
2809 case R_PPC64_ADDR16_HIGHEST:
2810 case R_PPC64_ADDR16_HIGHESTA:
2811 case R_PPC64_ADDR16_LO:
2812 case R_PPC64_ADDR16_LO_DS:
2813 case R_PPC64_ADDR24:
2814 case R_PPC64_ADDR30:
2815 case R_PPC64_ADDR32:
2816 case R_PPC64_UADDR16:
2817 case R_PPC64_UADDR32:
2818 case R_PPC64_UADDR64:
2820 /* Don't propagate .opd relocs. */
2821 if (NO_OPD_RELOCS && is_opd)
2824 /* If we are creating a shared library, and this is a reloc
2825 against a global symbol, or a non PC relative reloc
2826 against a local symbol, then we need to copy the reloc
2827 into the shared library. However, if we are linking with
2828 -Bsymbolic, we do not need to copy a reloc against a
2829 global symbol which is defined in an object we are
2830 including in the link (i.e., DEF_REGULAR is set). At
2831 this point we have not seen all the input files, so it is
2832 possible that DEF_REGULAR is not set now but will be set
2833 later (it is never cleared). In case of a weak definition,
2834 DEF_REGULAR may be cleared later by a strong definition in
2835 a shared library. We account for that possibility below by
2836 storing information in the relocs_copied field of the hash
2837 table entry. A similar situation occurs when creating
2838 shared libraries and symbol visibility changes render the
2841 If on the other hand, we are creating an executable, we
2842 may need to keep relocations for symbols satisfied by a
2843 dynamic library if we manage to avoid copy relocs for the
2846 && (sec->flags & SEC_ALLOC) != 0
2847 && (IS_ABSOLUTE_RELOC (r_type)
2849 && (! info->symbolic
2850 || h->root.type == bfd_link_hash_defweak
2851 || (h->elf_link_hash_flags
2852 & ELF_LINK_HASH_DEF_REGULAR) == 0))))
2854 && (sec->flags & SEC_ALLOC) != 0
2856 && (h->root.type == bfd_link_hash_defweak
2857 || (h->elf_link_hash_flags
2858 & ELF_LINK_HASH_DEF_REGULAR) == 0)))
2860 struct ppc_dyn_relocs *p;
2861 struct ppc_dyn_relocs **head;
2863 /* We must copy these reloc types into the output file.
2864 Create a reloc section in dynobj and make room for
2871 name = (bfd_elf_string_from_elf_section
2873 elf_elfheader (abfd)->e_shstrndx,
2874 elf_section_data (sec)->rel_hdr.sh_name));
2878 if (strncmp (name, ".rela", 5) != 0
2879 || strcmp (bfd_get_section_name (abfd, sec),
2882 (*_bfd_error_handler)
2883 (_("%s: bad relocation section name `%s\'"),
2884 bfd_archive_filename (abfd), name);
2885 bfd_set_error (bfd_error_bad_value);
2888 dynobj = htab->elf.dynobj;
2889 sreloc = bfd_get_section_by_name (dynobj, name);
2894 sreloc = bfd_make_section (dynobj, name);
2895 flags = (SEC_HAS_CONTENTS | SEC_READONLY
2896 | SEC_IN_MEMORY | SEC_LINKER_CREATED);
2897 if ((sec->flags & SEC_ALLOC) != 0)
2898 flags |= SEC_ALLOC | SEC_LOAD;
2900 || ! bfd_set_section_flags (dynobj, sreloc, flags)
2901 || ! bfd_set_section_alignment (dynobj, sreloc, 3))
2904 elf_section_data (sec)->sreloc = sreloc;
2907 /* If this is a global symbol, we count the number of
2908 relocations we need for this symbol. */
2911 head = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
2915 /* Track dynamic relocs needed for local syms too.
2916 We really need local syms available to do this
2920 s = bfd_section_from_r_symndx (abfd, &htab->sym_sec,
2925 head = ((struct ppc_dyn_relocs **)
2926 &elf_section_data (s)->local_dynrel);
2930 if (p == NULL || p->sec != sec)
2932 p = ((struct ppc_dyn_relocs *)
2933 bfd_alloc (htab->elf.dynobj,
2934 (bfd_size_type) sizeof *p));
2945 if (!IS_ABSOLUTE_RELOC (r_type))
2958 /* Return the section that should be marked against GC for a given
2962 ppc64_elf_gc_mark_hook (abfd, info, rel, h, sym)
2964 struct bfd_link_info *info ATTRIBUTE_UNUSED;
2965 Elf_Internal_Rela *rel;
2966 struct elf_link_hash_entry *h;
2967 Elf_Internal_Sym *sym;
2971 enum elf_ppc_reloc_type r_type;
2973 r_type = (enum elf_ppc_reloc_type) ELF64_R_TYPE (rel->r_info);
2976 case R_PPC64_GNU_VTINHERIT:
2977 case R_PPC64_GNU_VTENTRY:
2981 switch (h->root.type)
2983 case bfd_link_hash_defined:
2984 case bfd_link_hash_defweak:
2985 return h->root.u.def.section;
2987 case bfd_link_hash_common:
2988 return h->root.u.c.p->section;
2997 return bfd_section_from_elf_index (abfd, sym->st_shndx);
3003 /* Update the .got, .plt. and dynamic reloc reference counts for the
3004 section being removed. */
3007 ppc64_elf_gc_sweep_hook (abfd, info, sec, relocs)
3009 struct bfd_link_info *info ATTRIBUTE_UNUSED;
3011 const Elf_Internal_Rela *relocs;
3013 Elf_Internal_Shdr *symtab_hdr;
3014 struct elf_link_hash_entry **sym_hashes;
3015 bfd_signed_vma *local_got_refcounts;
3016 const Elf_Internal_Rela *rel, *relend;
3018 elf_section_data (sec)->local_dynrel = NULL;
3020 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
3021 sym_hashes = elf_sym_hashes (abfd);
3022 local_got_refcounts = elf_local_got_refcounts (abfd);
3024 relend = relocs + sec->reloc_count;
3025 for (rel = relocs; rel < relend; rel++)
3027 unsigned long r_symndx;
3028 enum elf_ppc_reloc_type r_type;
3029 struct elf_link_hash_entry *h;
3031 r_symndx = ELF64_R_SYM (rel->r_info);
3032 r_type = (enum elf_ppc_reloc_type) ELF64_R_TYPE (rel->r_info);
3036 case R_PPC64_GOT16_DS:
3037 case R_PPC64_GOT16_HA:
3038 case R_PPC64_GOT16_HI:
3039 case R_PPC64_GOT16_LO:
3040 case R_PPC64_GOT16_LO_DS:
3041 if (r_symndx >= symtab_hdr->sh_info)
3043 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
3044 if (h->got.refcount > 0)
3049 if (local_got_refcounts[r_symndx] > 0)
3050 local_got_refcounts[r_symndx]--;
3054 case R_PPC64_PLT16_HA:
3055 case R_PPC64_PLT16_HI:
3056 case R_PPC64_PLT16_LO:
3059 if (r_symndx >= symtab_hdr->sh_info)
3061 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
3062 if (h->plt.refcount > 0)
3068 case R_PPC64_REL14_BRNTAKEN:
3069 case R_PPC64_REL14_BRTAKEN:
3071 if (r_symndx >= symtab_hdr->sh_info)
3073 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
3074 if (h->plt.refcount > 0)
3081 if (r_symndx >= symtab_hdr->sh_info)
3083 struct ppc_link_hash_entry *eh;
3084 struct ppc_dyn_relocs **pp;
3085 struct ppc_dyn_relocs *p;
3087 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
3088 eh = (struct ppc_link_hash_entry *) h;
3090 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
3102 case R_PPC64_ADDR14:
3103 case R_PPC64_ADDR14_BRNTAKEN:
3104 case R_PPC64_ADDR14_BRTAKEN:
3105 case R_PPC64_ADDR16:
3106 case R_PPC64_ADDR16_DS:
3107 case R_PPC64_ADDR16_HA:
3108 case R_PPC64_ADDR16_HI:
3109 case R_PPC64_ADDR16_HIGHER:
3110 case R_PPC64_ADDR16_HIGHERA:
3111 case R_PPC64_ADDR16_HIGHEST:
3112 case R_PPC64_ADDR16_HIGHESTA:
3113 case R_PPC64_ADDR16_LO:
3114 case R_PPC64_ADDR16_LO_DS:
3115 case R_PPC64_ADDR24:
3116 case R_PPC64_ADDR30:
3117 case R_PPC64_ADDR32:
3118 case R_PPC64_ADDR64:
3119 case R_PPC64_UADDR16:
3120 case R_PPC64_UADDR32:
3121 case R_PPC64_UADDR64:
3123 if (r_symndx >= symtab_hdr->sh_info)
3125 struct ppc_link_hash_entry *eh;
3126 struct ppc_dyn_relocs **pp;
3127 struct ppc_dyn_relocs *p;
3129 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
3130 eh = (struct ppc_link_hash_entry *) h;
3132 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
3150 /* Called via elf_link_hash_traverse to transfer dynamic linking
3151 information on function code symbol entries to their corresponding
3152 function descriptor symbol entries. */
3154 func_desc_adjust (h, inf)
3155 struct elf_link_hash_entry *h;
3158 struct bfd_link_info *info;
3159 struct ppc_link_hash_table *htab;
3161 if (h->root.type == bfd_link_hash_indirect)
3164 if (h->root.type == bfd_link_hash_warning)
3165 h = (struct elf_link_hash_entry *) h->root.u.i.link;
3167 info = (struct bfd_link_info *) inf;
3168 htab = ppc_hash_table (info);
3170 /* If this is a function code symbol, transfer dynamic linking
3171 information to the function descriptor symbol. */
3172 if (!((struct ppc_link_hash_entry *) h)->is_func)
3175 if (h->root.type == bfd_link_hash_undefweak
3176 && (h->elf_link_hash_flags & ELF_LINK_HASH_REF_REGULAR))
3177 htab->have_undefweak = true;
3179 if (h->plt.refcount > 0
3180 && h->root.root.string[0] == '.'
3181 && h->root.root.string[1] != '\0')
3183 struct elf_link_hash_entry *fdh = ((struct ppc_link_hash_entry *) h)->oh;
3184 boolean force_local;
3186 /* Find the corresponding function descriptor symbol. Create it
3187 as undefined if necessary. */
3190 fdh = elf_link_hash_lookup (&htab->elf, h->root.root.string + 1,
3191 false, false, true);
3195 && (h->root.type == bfd_link_hash_undefined
3196 || h->root.type == bfd_link_hash_undefweak))
3201 abfd = h->root.u.undef.abfd;
3202 newsym = bfd_make_empty_symbol (abfd);
3203 newsym->name = h->root.root.string + 1;
3204 newsym->section = bfd_und_section_ptr;
3206 newsym->flags = BSF_OBJECT;
3207 if (h->root.type == bfd_link_hash_undefweak)
3208 newsym->flags |= BSF_WEAK;
3210 if ( !(_bfd_generic_link_add_one_symbol
3211 (info, abfd, newsym->name, newsym->flags,
3212 newsym->section, newsym->value, NULL, false, false,
3213 (struct bfd_link_hash_entry **) &fdh)))
3217 fdh->elf_link_hash_flags &= ~ELF_LINK_NON_ELF;
3221 && (fdh->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0
3223 || (fdh->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0
3224 || (fdh->elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) != 0))
3226 if (fdh->dynindx == -1)
3227 if (! bfd_elf64_link_record_dynamic_symbol (info, fdh))
3229 fdh->elf_link_hash_flags |= (h->elf_link_hash_flags
3230 & (ELF_LINK_HASH_REF_REGULAR
3231 | ELF_LINK_HASH_REF_DYNAMIC
3232 | ELF_LINK_HASH_REF_REGULAR_NONWEAK
3233 | ELF_LINK_NON_GOT_REF));
3234 if (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
3236 fdh->plt.refcount = h->plt.refcount;
3237 fdh->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
3239 ((struct ppc_link_hash_entry *) fdh)->is_func_descriptor = 1;
3240 ((struct ppc_link_hash_entry *) fdh)->oh = h;
3241 ((struct ppc_link_hash_entry *) h)->oh = fdh;
3244 /* Now that the info is on the function descriptor, clear the
3245 function code sym info. Any function code syms for which we
3246 don't have a definition in a regular file, we force local.
3247 This prevents a shared library from exporting syms that have
3248 been imported from another library. Function code syms that
3249 are really in the library we must leave global to prevent the
3250 linker dragging in a definition from a static library. */
3251 force_local = (info->shared
3252 && ((h->elf_link_hash_flags
3253 & ELF_LINK_HASH_DEF_REGULAR) == 0
3255 || (fdh->elf_link_hash_flags
3256 & ELF_LINK_HASH_DEF_REGULAR) == 0
3257 || (fdh->elf_link_hash_flags
3258 & ELF_LINK_FORCED_LOCAL) != 0));
3259 _bfd_elf_link_hash_hide_symbol (info, h, force_local);
3265 #define MIN_SAVE_FPR 14
3266 #define MAX_SAVE_FPR 31
3268 /* Called near the start of bfd_elf_size_dynamic_sections. We use
3269 this hook to a) provide some gcc support functions, and b) transfer
3270 dynamic linking information gathered so far on function code symbol
3271 entries, to their corresponding function descriptor symbol entries. */
3273 ppc64_elf_func_desc_adjust (obfd, info)
3274 bfd *obfd ATTRIBUTE_UNUSED;
3275 struct bfd_link_info *info;
3277 struct ppc_link_hash_table *htab;
3278 unsigned int lowest_savef = MAX_SAVE_FPR + 2;
3279 unsigned int lowest_restf = MAX_SAVE_FPR + 2;
3281 struct elf_link_hash_entry *h;
3285 htab = ppc_hash_table (info);
3287 if (htab->sfpr == NULL)
3288 /* We don't have any relocs. */
3291 /* First provide any missing ._savef* and ._restf* functions. */
3292 memcpy (sym, "._savef14", 10);
3293 for (i = MIN_SAVE_FPR; i <= MAX_SAVE_FPR; i++)
3295 sym[7] = i / 10 + '0';
3296 sym[8] = i % 10 + '0';
3297 h = elf_link_hash_lookup (&htab->elf, sym, false, false, true);
3299 && h->root.type == bfd_link_hash_undefined)
3301 if (lowest_savef > i)
3303 h->root.type = bfd_link_hash_defined;
3304 h->root.u.def.section = htab->sfpr;
3305 h->root.u.def.value = (i - lowest_savef) * 4;
3307 h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
3308 _bfd_elf_link_hash_hide_symbol (info, h, info->shared);
3312 memcpy (sym, "._restf14", 10);
3313 for (i = MIN_SAVE_FPR; i <= MAX_SAVE_FPR; i++)
3315 sym[7] = i / 10 + '0';
3316 sym[8] = i % 10 + '0';
3317 h = elf_link_hash_lookup (&htab->elf, sym, false, false, true);
3319 && h->root.type == bfd_link_hash_undefined)
3321 if (lowest_restf > i)
3323 h->root.type = bfd_link_hash_defined;
3324 h->root.u.def.section = htab->sfpr;
3325 h->root.u.def.value = ((MAX_SAVE_FPR + 2 - lowest_savef) * 4
3326 + (i - lowest_restf) * 4);
3328 h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
3329 _bfd_elf_link_hash_hide_symbol (info, h, info->shared);
3333 elf_link_hash_traverse (&htab->elf, func_desc_adjust, (PTR) info);
3335 htab->sfpr->_raw_size = ((MAX_SAVE_FPR + 2 - lowest_savef) * 4
3336 + (MAX_SAVE_FPR + 2 - lowest_restf) * 4);
3338 if (htab->sfpr->_raw_size == 0)
3340 if (!htab->have_undefweak)
3342 _bfd_strip_section_from_output (info, htab->sfpr);
3346 htab->sfpr->_raw_size = 4;
3349 p = (bfd_byte *) bfd_alloc (htab->elf.dynobj, htab->sfpr->_raw_size);
3352 htab->sfpr->contents = p;
3354 for (i = lowest_savef; i <= MAX_SAVE_FPR; i++)
3356 unsigned int fpr = i << 21;
3357 unsigned int stackoff = (1 << 16) - (MAX_SAVE_FPR + 1 - i) * 8;
3358 bfd_put_32 (htab->elf.dynobj, STFD_FR0_0R1 + fpr + stackoff, p);
3361 if (lowest_savef <= MAX_SAVE_FPR)
3363 bfd_put_32 (htab->elf.dynobj, BLR, p);
3367 for (i = lowest_restf; i <= MAX_SAVE_FPR; i++)
3369 unsigned int fpr = i << 21;
3370 unsigned int stackoff = (1 << 16) - (MAX_SAVE_FPR + 1 - i) * 8;
3371 bfd_put_32 (htab->elf.dynobj, LFD_FR0_0R1 + fpr + stackoff, p);
3374 if (lowest_restf <= MAX_SAVE_FPR
3375 || htab->sfpr->_raw_size == 4)
3377 bfd_put_32 (htab->elf.dynobj, BLR, p);
3383 /* Adjust a symbol defined by a dynamic object and referenced by a
3384 regular object. The current definition is in some section of the
3385 dynamic object, but we're not including those sections. We have to
3386 change the definition to something the rest of the link can
3390 ppc64_elf_adjust_dynamic_symbol (info, h)
3391 struct bfd_link_info *info;
3392 struct elf_link_hash_entry *h;
3394 struct ppc_link_hash_table *htab;
3395 struct ppc_link_hash_entry * eh;
3396 struct ppc_dyn_relocs *p;
3398 unsigned int power_of_two;
3400 htab = ppc_hash_table (info);
3402 /* Deal with function syms. */
3403 if (h->type == STT_FUNC
3404 || (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0)
3406 /* Clear procedure linkage table information for any symbol that
3407 won't need a .plt entry. */
3408 if (!((struct ppc_link_hash_entry *) h)->is_func_descriptor
3409 || h->plt.refcount <= 0
3410 || (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0
3412 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) == 0
3413 && (h->elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) == 0))
3415 h->plt.offset = (bfd_vma) -1;
3416 h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
3421 h->plt.offset = (bfd_vma) -1;
3423 /* If this is a weak symbol, and there is a real definition, the
3424 processor independent code will have arranged for us to see the
3425 real definition first, and we can just use the same value. */
3426 if (h->weakdef != NULL)
3428 BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
3429 || h->weakdef->root.type == bfd_link_hash_defweak);
3430 h->root.u.def.section = h->weakdef->root.u.def.section;
3431 h->root.u.def.value = h->weakdef->root.u.def.value;
3435 /* This is a reference to a symbol defined by a dynamic object which
3436 is not a function. */
3438 /* If we are creating a shared library, we must presume that the
3439 only references to the symbol are via the global offset table.
3440 For such cases we need not do anything here; the relocations will
3441 be handled correctly by relocate_section. */
3445 /* If there are no references to this symbol that do not use the
3446 GOT, we don't need to generate a copy reloc. */
3447 if ((h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0)
3450 eh = (struct ppc_link_hash_entry *) h;
3451 for (p = eh->dyn_relocs; p != NULL; p = p->next)
3453 s = p->sec->output_section;
3454 if (s != NULL && (s->flags & SEC_READONLY) != 0)
3458 /* If we didn't find any dynamic relocs in read-only sections, then
3459 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
3462 h->elf_link_hash_flags &= ~ELF_LINK_NON_GOT_REF;
3466 /* We must allocate the symbol in our .dynbss section, which will
3467 become part of the .bss section of the executable. There will be
3468 an entry for this symbol in the .dynsym section. The dynamic
3469 object will contain position independent code, so all references
3470 from the dynamic object to this symbol will go through the global
3471 offset table. The dynamic linker will use the .dynsym entry to
3472 determine the address it must put in the global offset table, so
3473 both the dynamic object and the regular object will refer to the
3474 same memory location for the variable. */
3476 /* We must generate a R_PPC_COPY reloc to tell the dynamic linker to
3477 copy the initial value out of the dynamic object and into the
3478 runtime process image. We need to remember the offset into the
3479 .rela.bss section we are going to use. */
3480 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
3482 htab->srelbss->_raw_size += sizeof (Elf64_External_Rela);
3483 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_COPY;
3486 /* We need to figure out the alignment required for this symbol. I
3487 have no idea how ELF linkers handle this. */
3488 power_of_two = bfd_log2 (h->size);
3489 if (power_of_two > 4)
3492 /* Apply the required alignment. */
3494 s->_raw_size = BFD_ALIGN (s->_raw_size, (bfd_size_type) (1 << power_of_two));
3495 if (power_of_two > bfd_get_section_alignment (htab->elf.dynobj, s))
3497 if (! bfd_set_section_alignment (htab->elf.dynobj, s, power_of_two))
3501 /* Define the symbol as being at this point in the section. */
3502 h->root.u.def.section = s;
3503 h->root.u.def.value = s->_raw_size;
3505 /* Increment the section size to make room for the symbol. */
3506 s->_raw_size += h->size;
3511 /* If given a function descriptor symbol, hide both the function code
3512 sym and the descriptor. */
3514 ppc64_elf_hide_symbol (info, h, force_local)
3515 struct bfd_link_info *info;
3516 struct elf_link_hash_entry *h;
3517 boolean force_local;
3519 _bfd_elf_link_hash_hide_symbol (info, h, force_local);
3521 if (((struct ppc_link_hash_entry *) h)->is_func_descriptor)
3523 struct elf_link_hash_entry *fh = ((struct ppc_link_hash_entry *) h)->oh;
3528 struct ppc_link_hash_table *htab;
3531 /* We aren't supposed to use alloca in BFD because on
3532 systems which do not have alloca the version in libiberty
3533 calls xmalloc, which might cause the program to crash
3534 when it runs out of memory. This function doesn't have a
3535 return status, so there's no way to gracefully return an
3536 error. So cheat. We know that string[-1] can be safely
3537 dereferenced; It's either a string in an ELF string
3538 table, or allocated in an objalloc structure. */
3540 p = h->root.root.string - 1;
3543 htab = ppc_hash_table (info);
3544 fh = elf_link_hash_lookup (&htab->elf, p, false, false, false);
3547 /* Unfortunately, if it so happens that the string we were
3548 looking for was allocated immediately before this string,
3549 then we overwrote the string terminator. That's the only
3550 reason the lookup should fail. */
3553 q = h->root.root.string + strlen (h->root.root.string);
3554 while (q >= h->root.root.string && *q == *p)
3556 if (q < h->root.root.string && *p == '.')
3557 fh = elf_link_hash_lookup (&htab->elf, p, false, false, false);
3561 ((struct ppc_link_hash_entry *) h)->oh = fh;
3562 ((struct ppc_link_hash_entry *) fh)->oh = h;
3566 _bfd_elf_link_hash_hide_symbol (info, fh, force_local);
3570 /* This is the condition under which ppc64_elf_finish_dynamic_symbol
3571 will be called from elflink.h. If elflink.h doesn't call our
3572 finish_dynamic_symbol routine, we'll need to do something about
3573 initializing any .plt and .got entries in ppc64_elf_relocate_section. */
3574 #define WILL_CALL_FINISH_DYNAMIC_SYMBOL(DYN, INFO, H) \
3576 && ((INFO)->shared \
3577 || ((H)->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0) \
3578 && ((H)->dynindx != -1 \
3579 || ((H)->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0))
3581 /* Allocate space in .plt, .got and associated reloc sections for
3585 allocate_dynrelocs (h, inf)
3586 struct elf_link_hash_entry *h;
3589 struct bfd_link_info *info;
3590 struct ppc_link_hash_table *htab;
3592 struct ppc_link_hash_entry *eh;
3593 struct ppc_dyn_relocs *p;
3595 if (h->root.type == bfd_link_hash_indirect)
3598 if (h->root.type == bfd_link_hash_warning)
3599 h = (struct elf_link_hash_entry *) h->root.u.i.link;
3601 info = (struct bfd_link_info *) inf;
3602 htab = ppc_hash_table (info);
3604 if (htab->elf.dynamic_sections_created
3605 && h->plt.refcount > 0
3606 && h->dynindx != -1)
3608 BFD_ASSERT (((struct ppc_link_hash_entry *) h)->is_func_descriptor);
3610 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info, h))
3612 /* If this is the first .plt entry, make room for the special
3615 if (s->_raw_size == 0)
3616 s->_raw_size += PLT_INITIAL_ENTRY_SIZE;
3618 h->plt.offset = s->_raw_size;
3620 /* Make room for this entry. */
3621 s->_raw_size += PLT_ENTRY_SIZE;
3623 /* Make room for the .glink code. */
3625 if (s->_raw_size == 0)
3626 s->_raw_size += GLINK_CALL_STUB_SIZE;
3627 /* We need bigger stubs past index 32767. */
3628 if (s->_raw_size >= GLINK_CALL_STUB_SIZE + 32768*2*4)
3630 s->_raw_size += 2*4;
3632 /* We also need to make an entry in the .rela.plt section. */
3634 s->_raw_size += sizeof (Elf64_External_Rela);
3638 h->plt.offset = (bfd_vma) -1;
3639 h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
3644 h->plt.offset = (bfd_vma) -1;
3645 h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
3648 if (h->got.refcount > 0)
3652 /* Make sure this symbol is output as a dynamic symbol.
3653 Undefined weak syms won't yet be marked as dynamic. */
3654 if (h->dynindx == -1
3655 && (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)
3657 if (! bfd_elf64_link_record_dynamic_symbol (info, h))
3662 h->got.offset = s->_raw_size;
3664 dyn = htab->elf.dynamic_sections_created;
3665 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info, h))
3666 htab->srelgot->_raw_size += sizeof (Elf64_External_Rela);
3669 h->got.offset = (bfd_vma) -1;
3671 eh = (struct ppc_link_hash_entry *) h;
3672 if (eh->dyn_relocs == NULL)
3675 /* In the shared -Bsymbolic case, discard space allocated for
3676 dynamic pc-relative relocs against symbols which turn out to be
3677 defined in regular objects. For the normal shared case, discard
3678 space for relocs that have become local due to symbol visibility
3683 if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) != 0
3684 && ((h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0
3687 struct ppc_dyn_relocs **pp;
3689 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
3691 p->count -= p->pc_count;
3702 /* For the non-shared case, discard space for relocs against
3703 symbols which turn out to need copy relocs or are not
3706 if ((h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0
3707 && (((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0
3708 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
3709 || (htab->elf.dynamic_sections_created
3710 && (h->root.type == bfd_link_hash_undefweak
3711 || h->root.type == bfd_link_hash_undefined))))
3713 /* Make sure this symbol is output as a dynamic symbol.
3714 Undefined weak syms won't yet be marked as dynamic. */
3715 if (h->dynindx == -1
3716 && (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)
3718 if (! bfd_elf64_link_record_dynamic_symbol (info, h))
3722 /* If that succeeded, we know we'll be keeping all the
3724 if (h->dynindx != -1)
3728 eh->dyn_relocs = NULL;
3733 /* Finally, allocate space. */
3734 for (p = eh->dyn_relocs; p != NULL; p = p->next)
3736 asection *sreloc = elf_section_data (p->sec)->sreloc;
3737 sreloc->_raw_size += p->count * sizeof (Elf64_External_Rela);
3743 /* Find any dynamic relocs that apply to read-only sections. */
3746 readonly_dynrelocs (h, inf)
3747 struct elf_link_hash_entry *h;
3750 struct ppc_link_hash_entry *eh;
3751 struct ppc_dyn_relocs *p;
3753 if (h->root.type == bfd_link_hash_warning)
3754 h = (struct elf_link_hash_entry *) h->root.u.i.link;
3756 eh = (struct ppc_link_hash_entry *) h;
3757 for (p = eh->dyn_relocs; p != NULL; p = p->next)
3759 asection *s = p->sec->output_section;
3761 if (s != NULL && (s->flags & SEC_READONLY) != 0)
3763 struct bfd_link_info *info = (struct bfd_link_info *) inf;
3765 info->flags |= DF_TEXTREL;
3767 /* Not an error, just cut short the traversal. */
3774 /* Set the sizes of the dynamic sections. */
3777 ppc64_elf_size_dynamic_sections (output_bfd, info)
3778 bfd *output_bfd ATTRIBUTE_UNUSED;
3779 struct bfd_link_info *info;
3781 struct ppc_link_hash_table *htab;
3787 htab = ppc_hash_table (info);
3788 dynobj = htab->elf.dynobj;
3792 if (htab->elf.dynamic_sections_created)
3794 /* Set the contents of the .interp section to the interpreter. */
3797 s = bfd_get_section_by_name (dynobj, ".interp");
3800 s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER;
3801 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
3805 /* Set up .got offsets for local syms, and space for local dynamic
3807 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
3809 bfd_signed_vma *local_got;
3810 bfd_signed_vma *end_local_got;
3811 bfd_size_type locsymcount;
3812 Elf_Internal_Shdr *symtab_hdr;
3815 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
3818 for (s = ibfd->sections; s != NULL; s = s->next)
3820 struct ppc_dyn_relocs *p;
3822 for (p = *((struct ppc_dyn_relocs **)
3823 &elf_section_data (s)->local_dynrel);
3827 if (!bfd_is_abs_section (p->sec)
3828 && bfd_is_abs_section (p->sec->output_section))
3830 /* Input section has been discarded, either because
3831 it is a copy of a linkonce section or due to
3832 linker script /DISCARD/, so we'll be discarding
3835 else if (p->count != 0)
3837 srel = elf_section_data (p->sec)->sreloc;
3838 srel->_raw_size += p->count * sizeof (Elf64_External_Rela);
3839 if ((p->sec->output_section->flags & SEC_READONLY) != 0)
3840 info->flags |= DF_TEXTREL;
3845 local_got = elf_local_got_refcounts (ibfd);
3849 symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
3850 locsymcount = symtab_hdr->sh_info;
3851 end_local_got = local_got + locsymcount;
3853 srel = htab->srelgot;
3854 for (; local_got < end_local_got; ++local_got)
3858 *local_got = s->_raw_size;
3861 srel->_raw_size += sizeof (Elf64_External_Rela);
3864 *local_got = (bfd_vma) -1;
3868 /* Allocate global sym .plt and .got entries, and space for global
3869 sym dynamic relocs. */
3870 elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, (PTR) info);
3872 /* We now have determined the sizes of the various dynamic sections.
3873 Allocate memory for them. */
3875 for (s = dynobj->sections; s != NULL; s = s->next)
3877 if ((s->flags & SEC_LINKER_CREATED) == 0)
3880 if (s == htab->sbrlt || s == htab->srelbrlt)
3881 /* These haven't been allocated yet; don't strip. */
3883 else if (s == htab->splt
3885 || s == htab->sglink)
3887 /* Strip this section if we don't need it; see the
3890 else if (strncmp (bfd_get_section_name (dynobj, s), ".rela", 5) == 0)
3892 if (s->_raw_size == 0)
3894 /* If we don't need this section, strip it from the
3895 output file. This is mostly to handle .rela.bss and
3896 .rela.plt. We must create both sections in
3897 create_dynamic_sections, because they must be created
3898 before the linker maps input sections to output
3899 sections. The linker does that before
3900 adjust_dynamic_symbol is called, and it is that
3901 function which decides whether anything needs to go
3902 into these sections. */
3906 if (s != htab->srelplt)
3909 /* We use the reloc_count field as a counter if we need
3910 to copy relocs into the output file. */
3916 /* It's not one of our sections, so don't allocate space. */
3920 if (s->_raw_size == 0)
3922 _bfd_strip_section_from_output (info, s);
3926 /* .plt is in the bss section. We don't initialise it. */
3927 if ((s->flags & SEC_LOAD) == 0)
3930 /* Allocate memory for the section contents. We use bfd_zalloc
3931 here in case unused entries are not reclaimed before the
3932 section's contents are written out. This should not happen,
3933 but this way if it does, we get a R_PPC64_NONE reloc instead
3935 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->_raw_size);
3936 if (s->contents == NULL)
3940 if (htab->elf.dynamic_sections_created)
3942 /* Add some entries to the .dynamic section. We fill in the
3943 values later, in ppc64_elf_finish_dynamic_sections, but we
3944 must add the entries now so that we get the correct size for
3945 the .dynamic section. The DT_DEBUG entry is filled in by the
3946 dynamic linker and used by the debugger. */
3947 #define add_dynamic_entry(TAG, VAL) \
3948 bfd_elf64_add_dynamic_entry (info, (bfd_vma) (TAG), (bfd_vma) (VAL))
3952 if (!add_dynamic_entry (DT_DEBUG, 0))
3956 if (htab->splt != NULL && htab->splt->_raw_size != 0)
3958 if (!add_dynamic_entry (DT_PLTGOT, 0)
3959 || !add_dynamic_entry (DT_PLTRELSZ, 0)
3960 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
3961 || !add_dynamic_entry (DT_JMPREL, 0)
3962 || !add_dynamic_entry (DT_PPC64_GLINK, 0))
3968 if (!add_dynamic_entry (DT_PPC64_OPD, 0)
3969 || !add_dynamic_entry (DT_PPC64_OPDSZ, 0))
3975 if (!add_dynamic_entry (DT_RELA, 0)
3976 || !add_dynamic_entry (DT_RELASZ, 0)
3977 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
3980 /* If any dynamic relocs apply to a read-only section,
3981 then we need a DT_TEXTREL entry. */
3982 if ((info->flags & DF_TEXTREL) == 0)
3983 elf_link_hash_traverse (&htab->elf, readonly_dynrelocs,
3986 if ((info->flags & DF_TEXTREL) != 0)
3988 if (!add_dynamic_entry (DT_TEXTREL, 0))
3993 #undef add_dynamic_entry
3998 /* Determine the type of stub needed, if any, for a call. */
4000 static INLINE enum ppc_stub_type
4001 ppc_type_of_stub (input_sec, rel, hash, destination)
4002 asection *input_sec;
4003 const Elf_Internal_Rela *rel;
4004 struct ppc_link_hash_entry **hash;
4005 bfd_vma destination;
4007 struct ppc_link_hash_entry *h = *hash;
4009 bfd_vma branch_offset;
4010 bfd_vma max_branch_offset;
4011 unsigned int r_type;
4016 && h->oh->plt.offset != (bfd_vma) -1
4017 && h->oh->dynindx != -1)
4019 *hash = (struct ppc_link_hash_entry *) h->oh;
4020 return ppc_stub_plt_call;
4023 if (h->elf.root.type == bfd_link_hash_undefweak
4024 || h->elf.root.type == bfd_link_hash_undefined)
4025 return ppc_stub_none;
4028 /* Determine where the call point is. */
4029 location = (input_sec->output_offset
4030 + input_sec->output_section->vma
4033 branch_offset = destination - location;
4034 r_type = ELF64_R_TYPE (rel->r_info);
4036 /* Determine if a long branch stub is needed. */
4037 max_branch_offset = 1 << 25;
4038 if (r_type != (unsigned int) R_PPC64_REL24)
4039 max_branch_offset = 1 << 15;
4041 if (branch_offset + max_branch_offset >= 2 * max_branch_offset)
4042 /* We need a stub. Figure out whether a long_branch or plt_branch
4044 return ppc_stub_long_branch;
4046 return ppc_stub_none;
4049 /* Build a .plt call stub. */
4052 build_plt_stub (obfd, p, offset, glink)
4058 #define PPC_LO(v) ((v) & 0xffff)
4059 #define PPC_HI(v) (((v) >> 16) & 0xffff)
4060 #define PPC_HA(v) PPC_HI ((v) + 0x8000)
4063 bfd_put_32 (obfd, LD_R2_40R1, p), p += 4;
4064 bfd_put_32 (obfd, ADDIS_R12_R2 | PPC_HA (offset), p), p += 4;
4066 bfd_put_32 (obfd, STD_R2_40R1, p), p += 4;
4067 bfd_put_32 (obfd, LD_R11_0R12 | PPC_LO (offset), p), p += 4;
4068 if (PPC_HA (offset + 8) != PPC_HA (offset))
4069 bfd_put_32 (obfd, ADDIS_R12_R12_1, p), p += 4;
4071 bfd_put_32 (obfd, LD_R2_0R12 | PPC_LO (offset), p), p += 4;
4072 if (PPC_HA (offset + 8) != PPC_HA (offset))
4073 bfd_put_32 (obfd, ADDIS_R12_R12_1, p), p += 4;
4075 bfd_put_32 (obfd, MTCTR_R11, p), p += 4;
4076 bfd_put_32 (obfd, LD_R11_0R12 | PPC_LO (offset), p), p += 4;
4077 bfd_put_32 (obfd, BCTR, p), p += 4;
4082 ppc_build_one_stub (gen_entry, in_arg)
4083 struct bfd_hash_entry *gen_entry;
4086 struct ppc_stub_hash_entry *stub_entry;
4087 struct ppc_branch_hash_entry *br_entry;
4088 struct bfd_link_info *info;
4089 struct ppc_link_hash_table *htab;
4098 /* Massage our args to the form they really have. */
4099 stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
4100 info = (struct bfd_link_info *) in_arg;
4102 htab = ppc_hash_table (info);
4103 stub_sec = stub_entry->stub_sec;
4105 /* Make a note of the offset within the stubs for this entry. */
4106 stub_entry->stub_offset = stub_sec->_cooked_size;
4107 loc = stub_sec->contents + stub_entry->stub_offset;
4109 stub_bfd = stub_sec->owner;
4111 switch (stub_entry->stub_type)
4113 case ppc_stub_long_branch:
4114 /* Branches are relative. This is where we are going to. */
4115 off = (stub_entry->target_value
4116 + stub_entry->target_section->output_offset
4117 + stub_entry->target_section->output_section->vma);
4119 /* And this is where we are coming from. */
4120 off -= (stub_entry->stub_offset
4121 + stub_sec->output_offset
4122 + stub_sec->output_section->vma);
4124 BFD_ASSERT (off + (1 << 25) < (bfd_vma) (1 << 26));
4126 bfd_put_32 (stub_bfd, (bfd_vma) B_DOT | (off & 0x3fffffc), loc);
4130 case ppc_stub_plt_branch:
4131 br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
4132 stub_entry->root.string + 9,
4134 if (br_entry == NULL)
4136 (*_bfd_error_handler) (_("can't find branch stub `%s'"),
4137 stub_entry->root.string + 9);
4138 htab->stub_error = true;
4142 off = (stub_entry->target_value
4143 + stub_entry->target_section->output_offset
4144 + stub_entry->target_section->output_section->vma);
4146 bfd_put_64 (htab->sbrlt->owner, off,
4147 htab->sbrlt->contents + br_entry->offset);
4151 /* Create a reloc for the branch lookup table entry. */
4152 Elf_Internal_Rela rela;
4153 Elf64_External_Rela *r;
4155 rela.r_offset = (br_entry->offset
4156 + htab->sbrlt->output_offset
4157 + htab->sbrlt->output_section->vma);
4158 rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
4159 rela.r_addend = off;
4161 r = (Elf64_External_Rela *) htab->srelbrlt->contents;
4162 r += htab->srelbrlt->reloc_count++;
4163 bfd_elf64_swap_reloca_out (htab->srelbrlt->owner, &rela, r);
4166 off = (br_entry->offset
4167 + htab->sbrlt->output_offset
4168 + htab->sbrlt->output_section->vma
4169 - elf_gp (htab->sbrlt->output_section->owner)
4172 if (off + 0x80000000 > 0xffffffff || (off & 7) != 0)
4174 (*_bfd_error_handler)
4175 (_("linkage table error against `%s'"),
4176 stub_entry->root.string);
4177 bfd_set_error (bfd_error_bad_value);
4178 htab->stub_error = true;
4183 bfd_put_32 (stub_bfd, (bfd_vma) ADDIS_R12_R2 | PPC_HA (indx), loc);
4184 bfd_put_32 (stub_bfd, (bfd_vma) LD_R11_0R12 | PPC_LO (indx), loc + 4);
4185 bfd_put_32 (stub_bfd, (bfd_vma) MTCTR_R11, loc + 8);
4186 bfd_put_32 (stub_bfd, (bfd_vma) BCTR, loc + 12);
4190 case ppc_stub_plt_call:
4191 /* Build the .glink lazy link call stub. */
4192 p = htab->sglink->contents + htab->sglink->_cooked_size;
4193 indx = htab->sglink->reloc_count;
4196 bfd_put_32 (htab->sglink->owner, LI_R0_0 | indx, p);
4201 bfd_put_32 (htab->sglink->owner, LIS_R0_0 | PPC_HI (indx), p);
4203 bfd_put_32 (htab->sglink->owner, ORI_R0_R0_0 | PPC_LO (indx), p);
4206 bfd_put_32 (htab->sglink->owner,
4207 B_DOT | ((htab->sglink->contents - p) & 0x3fffffc), p);
4209 htab->sglink->_cooked_size = p - htab->sglink->contents;
4210 htab->sglink->reloc_count += 1;
4212 /* Do the best we can for shared libraries built without
4213 exporting ".foo" for each "foo". This can happen when symbol
4214 versioning scripts strip all bar a subset of symbols. */
4215 if (stub_entry->h->oh->root.type != bfd_link_hash_defined
4216 && stub_entry->h->oh->root.type != bfd_link_hash_defweak)
4218 /* Point the symbol at the stub. There may be multiple stubs,
4219 we don't really care; The main thing is to make this sym
4220 defined somewhere. */
4221 stub_entry->h->oh->root.type = bfd_link_hash_defined;
4222 stub_entry->h->oh->root.u.def.section = stub_entry->stub_sec;
4223 stub_entry->h->oh->root.u.def.value = stub_entry->stub_offset;
4226 /* Now build the stub. */
4227 off = stub_entry->h->elf.plt.offset;
4228 if (off >= (bfd_vma) -2)
4231 off &= ~ (bfd_vma) 1;
4232 off += (htab->splt->output_offset
4233 + htab->splt->output_section->vma
4234 - elf_gp (htab->splt->output_section->owner)
4237 if (off + 0x80000000 > 0xffffffff || (off & 7) != 0)
4239 (*_bfd_error_handler)
4240 (_("linkage table error against `%s'"),
4241 stub_entry->h->elf.root.root.string);
4242 bfd_set_error (bfd_error_bad_value);
4243 htab->stub_error = true;
4247 p = build_plt_stub (stub_bfd, loc, (int) off, 0);
4256 stub_sec->_cooked_size += size;
4260 /* As above, but don't actually build the stub. Just bump offset so
4261 we know stub section sizes, and select plt_branch stubs where
4262 long_branch stubs won't do. */
4265 ppc_size_one_stub (gen_entry, in_arg)
4266 struct bfd_hash_entry *gen_entry;
4269 struct ppc_stub_hash_entry *stub_entry;
4270 struct ppc_link_hash_table *htab;
4274 /* Massage our args to the form they really have. */
4275 stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
4276 htab = (struct ppc_link_hash_table *) in_arg;
4278 if (stub_entry->stub_type == ppc_stub_plt_call)
4280 off = stub_entry->h->elf.plt.offset & ~(bfd_vma) 1;
4281 off += (htab->splt->output_offset
4282 + htab->splt->output_section->vma
4283 - elf_gp (htab->splt->output_section->owner)
4287 if (PPC_HA ((int) off + 16) != PPC_HA ((int) off))
4292 /* ppc_stub_long_branch or ppc_stub_plt_branch. */
4293 stub_entry->stub_type = ppc_stub_long_branch;
4296 off = (stub_entry->target_value
4297 + stub_entry->target_section->output_offset
4298 + stub_entry->target_section->output_section->vma);
4299 off -= (stub_entry->stub_sec->_raw_size
4300 + stub_entry->stub_sec->output_offset
4301 + stub_entry->stub_sec->output_section->vma);
4303 if (off + (1 << 25) >= (bfd_vma) (1 << 26))
4305 struct ppc_branch_hash_entry *br_entry;
4307 br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
4308 stub_entry->root.string + 9,
4310 if (br_entry == NULL)
4312 (*_bfd_error_handler) (_("can't build branch stub `%s'"),
4313 stub_entry->root.string + 9);
4314 htab->stub_error = true;
4318 if (br_entry->iter != htab->stub_iteration)
4320 br_entry->iter = htab->stub_iteration;
4321 br_entry->offset = htab->sbrlt->_raw_size;
4322 htab->sbrlt->_raw_size += 8;
4324 stub_entry->stub_type = ppc_stub_plt_branch;
4329 stub_entry->stub_sec->_raw_size += size;
4333 /* Set up various things so that we can make a list of input sections
4334 for each output section included in the link. Returns -1 on error,
4335 0 when no stubs will be needed, and 1 on success. */
4338 ppc64_elf_setup_section_lists (output_bfd, info)
4340 struct bfd_link_info *info;
4343 unsigned int bfd_count;
4344 int top_id, top_index;
4346 asection **input_list, **list;
4348 struct ppc_link_hash_table *htab = ppc_hash_table (info);
4350 if (htab->elf.root.creator->flavour != bfd_target_elf_flavour
4351 || htab->sbrlt == NULL)
4354 /* Count the number of input BFDs and find the top input section id. */
4355 for (input_bfd = info->input_bfds, bfd_count = 0, top_id = 0;
4357 input_bfd = input_bfd->link_next)
4360 for (section = input_bfd->sections;
4362 section = section->next)
4364 if (top_id < section->id)
4365 top_id = section->id;
4368 htab->bfd_count = bfd_count;
4370 amt = sizeof (struct map_stub) * (top_id + 1);
4371 htab->stub_group = (struct map_stub *) bfd_zmalloc (amt);
4372 if (htab->stub_group == NULL)
4375 /* We can't use output_bfd->section_count here to find the top output
4376 section index as some sections may have been removed, and
4377 _bfd_strip_section_from_output doesn't renumber the indices. */
4378 for (section = output_bfd->sections, top_index = 0;
4380 section = section->next)
4382 if (top_index < section->index)
4383 top_index = section->index;
4386 htab->top_index = top_index;
4387 amt = sizeof (asection *) * (top_index + 1);
4388 input_list = (asection **) bfd_malloc (amt);
4389 htab->input_list = input_list;
4390 if (input_list == NULL)
4393 /* For sections we aren't interested in, mark their entries with a
4394 value we can check later. */
4395 list = input_list + top_index;
4397 *list = bfd_abs_section_ptr;
4398 while (list-- != input_list);
4400 for (section = output_bfd->sections;
4402 section = section->next)
4404 if ((section->flags & SEC_CODE) != 0)
4405 input_list[section->index] = NULL;
4411 /* The linker repeatedly calls this function for each input section,
4412 in the order that input sections are linked into output sections.
4413 Build lists of input sections to determine groupings between which
4414 we may insert linker stubs. */
4417 ppc64_elf_next_input_section (info, isec)
4418 struct bfd_link_info *info;
4421 struct ppc_link_hash_table *htab = ppc_hash_table (info);
4423 if (isec->output_section->index <= htab->top_index)
4425 asection **list = htab->input_list + isec->output_section->index;
4426 if (*list != bfd_abs_section_ptr)
4428 /* Steal the link_sec pointer for our list. */
4429 #define PREV_SEC(sec) (htab->stub_group[(sec)->id].link_sec)
4430 /* This happens to make the list in reverse order,
4431 which is what we want. */
4432 PREV_SEC (isec) = *list;
4438 /* See whether we can group stub sections together. Grouping stub
4439 sections may result in fewer stubs. More importantly, we need to
4440 put all .init* and .fini* stubs at the beginning of the .init or
4441 .fini output sections respectively, because glibc splits the
4442 _init and _fini functions into multiple parts. Putting a stub in
4443 the middle of a function is not a good idea. */
4446 group_sections (htab, stub_group_size, stubs_always_before_branch)
4447 struct ppc_link_hash_table *htab;
4448 bfd_size_type stub_group_size;
4449 boolean stubs_always_before_branch;
4451 asection **list = htab->input_list + htab->top_index;
4454 asection *tail = *list;
4455 if (tail == bfd_abs_section_ptr)
4457 while (tail != NULL)
4461 bfd_size_type total;
4464 if (tail->_cooked_size)
4465 total = tail->_cooked_size;
4467 total = tail->_raw_size;
4468 while ((prev = PREV_SEC (curr)) != NULL
4469 && ((total += curr->output_offset - prev->output_offset)
4473 /* OK, the size from the start of CURR to the end is less
4474 than stub_group_size and thus can be handled by one stub
4475 section. (or the tail section is itself larger than
4476 stub_group_size, in which case we may be toast.) We
4477 should really be keeping track of the total size of stubs
4478 added here, as stubs contribute to the final output
4479 section size. That's a little tricky, and this way will
4480 only break if stubs added make the total size more than
4481 2^25, ie. for the default stub_group_size, if stubs total
4482 more than 2834432 bytes, or over 100000 plt call stubs. */
4485 prev = PREV_SEC (tail);
4486 /* Set up this stub group. */
4487 htab->stub_group[tail->id].link_sec = curr;
4489 while (tail != curr && (tail = prev) != NULL);
4491 /* But wait, there's more! Input sections up to stub_group_size
4492 bytes before the stub section can be handled by it too. */
4493 if (!stubs_always_before_branch)
4497 && ((total += tail->output_offset - prev->output_offset)
4501 prev = PREV_SEC (tail);
4502 htab->stub_group[tail->id].link_sec = curr;
4508 while (list-- != htab->input_list);
4509 free (htab->input_list);
4513 /* Read in all local syms for all input bfds. */
4516 get_local_syms (input_bfd, htab)
4518 struct ppc_link_hash_table *htab;
4520 unsigned int bfd_indx;
4521 Elf_Internal_Sym *local_syms, **all_local_syms;
4523 /* We want to read in symbol extension records only once. To do this
4524 we need to read in the local symbols in parallel and save them for
4525 later use; so hold pointers to the local symbols in an array. */
4526 bfd_size_type amt = sizeof (Elf_Internal_Sym *) * htab->bfd_count;
4527 all_local_syms = (Elf_Internal_Sym **) bfd_zmalloc (amt);
4528 htab->all_local_syms = all_local_syms;
4529 if (all_local_syms == NULL)
4532 /* Walk over all the input BFDs, swapping in local symbols.
4533 If we are creating a shared library, create hash entries for the
4537 input_bfd = input_bfd->link_next, bfd_indx++)
4539 Elf_Internal_Shdr *symtab_hdr;
4540 Elf_Internal_Shdr *shndx_hdr;
4541 Elf_Internal_Sym *isym;
4542 Elf64_External_Sym *ext_syms, *esym, *end_sy;
4543 Elf_External_Sym_Shndx *shndx_buf, *shndx;
4544 bfd_size_type sec_size;
4546 /* We'll need the symbol table in a second. */
4547 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
4548 if (symtab_hdr->sh_info == 0)
4551 /* We need an array of the local symbols attached to the input bfd.
4552 Unfortunately, we're going to have to read & swap them in. */
4553 sec_size = symtab_hdr->sh_info;
4554 sec_size *= sizeof (Elf_Internal_Sym);
4555 local_syms = (Elf_Internal_Sym *) bfd_malloc (sec_size);
4556 if (local_syms == NULL)
4559 all_local_syms[bfd_indx] = local_syms;
4560 sec_size = symtab_hdr->sh_info;
4561 sec_size *= sizeof (Elf64_External_Sym);
4562 ext_syms = (Elf64_External_Sym *) bfd_malloc (sec_size);
4563 if (ext_syms == NULL)
4566 if (bfd_seek (input_bfd, symtab_hdr->sh_offset, SEEK_SET) != 0
4567 || bfd_bread ((PTR) ext_syms, sec_size, input_bfd) != sec_size)
4569 error_ret_free_ext_syms:
4575 shndx_hdr = &elf_tdata (input_bfd)->symtab_shndx_hdr;
4576 if (shndx_hdr->sh_size != 0)
4578 sec_size = symtab_hdr->sh_info;
4579 sec_size *= sizeof (Elf_External_Sym_Shndx);
4580 shndx_buf = (Elf_External_Sym_Shndx *) bfd_malloc (sec_size);
4581 if (shndx_buf == NULL)
4582 goto error_ret_free_ext_syms;
4584 if (bfd_seek (input_bfd, shndx_hdr->sh_offset, SEEK_SET) != 0
4585 || bfd_bread ((PTR) shndx_buf, sec_size, input_bfd) != sec_size)
4588 goto error_ret_free_ext_syms;
4592 /* Swap the local symbols in. */
4593 for (esym = ext_syms, end_sy = esym + symtab_hdr->sh_info,
4594 isym = local_syms, shndx = shndx_buf;
4596 esym++, isym++, shndx = (shndx ? shndx + 1 : NULL))
4597 bfd_elf64_swap_symbol_in (input_bfd, (const PTR) esym,
4598 (const PTR) shndx, isym);
4600 /* Now we can free the external symbols. */
4608 /* Determine and set the size of the stub section for a final link.
4610 The basic idea here is to examine all the relocations looking for
4611 PC-relative calls to a target that is unreachable with a "bl"
4615 ppc64_elf_size_stubs (output_bfd, stub_bfd, info, group_size,
4616 add_stub_section, layout_sections_again)
4619 struct bfd_link_info *info;
4620 bfd_signed_vma group_size;
4621 asection * (*add_stub_section) PARAMS ((const char *, asection *));
4622 void (*layout_sections_again) PARAMS ((void));
4624 bfd_size_type stub_group_size;
4625 boolean stubs_always_before_branch;
4626 boolean ret = false;
4627 struct ppc_link_hash_table *htab = ppc_hash_table (info);
4629 /* Stash our params away. */
4630 htab->stub_bfd = stub_bfd;
4631 htab->add_stub_section = add_stub_section;
4632 htab->layout_sections_again = layout_sections_again;
4633 stubs_always_before_branch = group_size < 0;
4635 stub_group_size = -group_size;
4637 stub_group_size = group_size;
4638 if (stub_group_size == 1)
4640 /* Default values. */
4641 stub_group_size = 30720000;
4642 if (htab->has_14bit_branch)
4643 stub_group_size = 30000;
4646 group_sections (htab, stub_group_size, stubs_always_before_branch);
4648 if (! get_local_syms (info->input_bfds, htab))
4650 if (htab->all_local_syms)
4651 goto error_ret_free_local;
4658 unsigned int bfd_indx;
4660 boolean stub_changed;
4662 htab->stub_iteration += 1;
4663 stub_changed = false;
4665 for (input_bfd = info->input_bfds, bfd_indx = 0;
4667 input_bfd = input_bfd->link_next, bfd_indx++)
4669 Elf_Internal_Shdr *symtab_hdr;
4671 Elf_Internal_Sym *local_syms;
4673 /* We'll need the symbol table in a second. */
4674 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
4675 if (symtab_hdr->sh_info == 0)
4678 local_syms = htab->all_local_syms[bfd_indx];
4680 /* Walk over each section attached to the input bfd. */
4681 for (section = input_bfd->sections;
4683 section = section->next)
4685 Elf_Internal_Shdr *input_rel_hdr;
4686 Elf64_External_Rela *external_relocs, *erelaend, *erela;
4687 Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
4690 /* If there aren't any relocs, then there's nothing more
4692 if ((section->flags & SEC_RELOC) == 0
4693 || section->reloc_count == 0)
4696 /* If this section is a link-once section that will be
4697 discarded, then don't create any stubs. */
4698 if (section->output_section == NULL
4699 || section->output_section->owner != output_bfd)
4702 /* Allocate space for the external relocations. */
4703 amt = section->reloc_count;
4704 amt *= sizeof (Elf64_External_Rela);
4705 external_relocs = (Elf64_External_Rela *) bfd_malloc (amt);
4706 if (external_relocs == NULL)
4708 goto error_ret_free_local;
4711 /* Likewise for the internal relocations. */
4712 amt = section->reloc_count;
4713 amt *= sizeof (Elf_Internal_Rela);
4714 internal_relocs = (Elf_Internal_Rela *) bfd_malloc (amt);
4715 if (internal_relocs == NULL)
4717 free (external_relocs);
4718 goto error_ret_free_local;
4721 /* Read in the external relocs. */
4722 input_rel_hdr = &elf_section_data (section)->rel_hdr;
4723 if (bfd_seek (input_bfd, input_rel_hdr->sh_offset, SEEK_SET) != 0
4724 || bfd_bread ((PTR) external_relocs,
4725 input_rel_hdr->sh_size,
4726 input_bfd) != input_rel_hdr->sh_size)
4728 free (external_relocs);
4729 error_ret_free_internal:
4730 free (internal_relocs);
4731 goto error_ret_free_local;
4734 /* Swap in the relocs. */
4735 erela = external_relocs;
4736 erelaend = erela + section->reloc_count;
4737 irela = internal_relocs;
4738 for (; erela < erelaend; erela++, irela++)
4739 bfd_elf64_swap_reloca_in (input_bfd, erela, irela);
4741 /* We're done with the external relocs, free them. */
4742 free (external_relocs);
4744 /* Now examine each relocation. */
4745 irela = internal_relocs;
4746 irelaend = irela + section->reloc_count;
4747 for (; irela < irelaend; irela++)
4749 unsigned int r_type, r_indx;
4750 enum ppc_stub_type stub_type;
4751 struct ppc_stub_hash_entry *stub_entry;
4754 bfd_vma destination;
4755 struct ppc_link_hash_entry *hash;
4757 const asection *id_sec;
4759 r_type = ELF64_R_TYPE (irela->r_info);
4760 r_indx = ELF64_R_SYM (irela->r_info);
4762 if (r_type >= (unsigned int) R_PPC_max)
4764 bfd_set_error (bfd_error_bad_value);
4765 goto error_ret_free_internal;
4768 /* Only look for stubs on branch instructions. */
4769 if (r_type != (unsigned int) R_PPC64_REL24
4770 && r_type != (unsigned int) R_PPC64_REL14
4771 && r_type != (unsigned int) R_PPC64_REL14_BRTAKEN
4772 && r_type != (unsigned int) R_PPC64_REL14_BRNTAKEN)
4775 /* Now determine the call target, its name, value,
4781 if (r_indx < symtab_hdr->sh_info)
4783 /* It's a local symbol. */
4784 Elf_Internal_Sym *sym;
4785 Elf_Internal_Shdr *hdr;
4787 sym = local_syms + r_indx;
4788 hdr = elf_elfsections (input_bfd)[sym->st_shndx];
4789 sym_sec = hdr->bfd_section;
4790 if (ELF_ST_TYPE (sym->st_info) != STT_SECTION)
4791 sym_value = sym->st_value;
4792 destination = (sym_value + irela->r_addend
4793 + sym_sec->output_offset
4794 + sym_sec->output_section->vma);
4798 /* It's an external symbol. */
4801 e_indx = r_indx - symtab_hdr->sh_info;
4802 hash = ((struct ppc_link_hash_entry *)
4803 elf_sym_hashes (input_bfd)[e_indx]);
4805 while (hash->elf.root.type == bfd_link_hash_indirect
4806 || hash->elf.root.type == bfd_link_hash_warning)
4807 hash = ((struct ppc_link_hash_entry *)
4808 hash->elf.root.u.i.link);
4810 if (hash->elf.root.type == bfd_link_hash_defined
4811 || hash->elf.root.type == bfd_link_hash_defweak)
4813 sym_sec = hash->elf.root.u.def.section;
4814 sym_value = hash->elf.root.u.def.value;
4815 if (sym_sec->output_section != NULL)
4816 destination = (sym_value + irela->r_addend
4817 + sym_sec->output_offset
4818 + sym_sec->output_section->vma);
4820 else if (hash->elf.root.type == bfd_link_hash_undefweak)
4822 else if (hash->elf.root.type == bfd_link_hash_undefined)
4826 bfd_set_error (bfd_error_bad_value);
4827 goto error_ret_free_internal;
4831 /* Determine what (if any) linker stub is needed. */
4832 stub_type = ppc_type_of_stub (section, irela, &hash,
4834 if (stub_type == ppc_stub_none)
4837 /* Support for grouping stub sections. */
4838 id_sec = htab->stub_group[section->id].link_sec;
4840 /* Get the name of this stub. */
4841 stub_name = ppc_stub_name (id_sec, sym_sec, hash, irela);
4843 goto error_ret_free_internal;
4845 stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
4846 stub_name, false, false);
4847 if (stub_entry != NULL)
4849 /* The proper stub has already been created. */
4854 stub_entry = ppc_add_stub (stub_name, section, htab);
4855 if (stub_entry == NULL)
4858 goto error_ret_free_local;
4861 stub_entry->target_value = sym_value;
4862 stub_entry->target_section = sym_sec;
4863 stub_entry->stub_type = stub_type;
4864 stub_entry->h = hash;
4865 stub_changed = true;
4868 /* We're done with the internal relocs, free them. */
4869 free (internal_relocs);
4876 /* OK, we've added some stubs. Find out the new size of the
4878 for (stub_sec = htab->stub_bfd->sections;
4880 stub_sec = stub_sec->next)
4882 stub_sec->_raw_size = 0;
4883 stub_sec->_cooked_size = 0;
4885 htab->sbrlt->_raw_size = 0;
4886 htab->sbrlt->_cooked_size = 0;
4888 bfd_hash_traverse (&htab->stub_hash_table, ppc_size_one_stub, htab);
4890 /* Ask the linker to do its stuff. */
4891 (*htab->layout_sections_again) ();
4894 /* It would be nice to strip .branch_lt from the output if the
4895 section is empty, but it's too late. If we strip sections here,
4896 the dynamic symbol table is corrupted since the section symbol
4897 for the stripped section isn't written. */
4901 error_ret_free_local:
4902 while (htab->bfd_count-- > 0)
4903 if (htab->all_local_syms[htab->bfd_count])
4904 free (htab->all_local_syms[htab->bfd_count]);
4905 free (htab->all_local_syms);
4910 /* Called after we have determined section placement. If sections
4911 move, we'll be called again. Provide a value for TOCstart. */
4914 ppc64_elf_toc (obfd)
4920 /* The TOC consists of sections .got, .toc, .tocbss, .plt in that
4921 order. The TOC starts where the first of these sections starts. */
4922 s = bfd_get_section_by_name (obfd, ".got");
4924 s = bfd_get_section_by_name (obfd, ".toc");
4926 s = bfd_get_section_by_name (obfd, ".tocbss");
4928 s = bfd_get_section_by_name (obfd, ".plt");
4931 /* This may happen for
4932 o references to TOC base (SYM@toc / TOC[tc0]) without a
4935 o --gc-sections and empty TOC sections
4937 FIXME: Warn user? */
4939 /* Look for a likely section. We probably won't even be
4941 for (s = obfd->sections; s != NULL; s = s->next)
4942 if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_READONLY))
4943 == (SEC_ALLOC | SEC_SMALL_DATA))
4946 for (s = obfd->sections; s != NULL; s = s->next)
4947 if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA))
4948 == (SEC_ALLOC | SEC_SMALL_DATA))
4951 for (s = obfd->sections; s != NULL; s = s->next)
4952 if ((s->flags & (SEC_ALLOC | SEC_READONLY)) == SEC_ALLOC)
4955 for (s = obfd->sections; s != NULL; s = s->next)
4956 if ((s->flags & SEC_ALLOC) == SEC_ALLOC)
4962 TOCstart = s->output_section->vma + s->output_offset;
4967 /* Build all the stubs associated with the current output file.
4968 The stubs are kept in a hash table attached to the main linker
4969 hash table. This function is called via gldelf64ppc_finish. */
4972 ppc64_elf_build_stubs (info)
4973 struct bfd_link_info *info;
4975 struct ppc_link_hash_table *htab = ppc_hash_table (info);
4980 for (stub_sec = htab->stub_bfd->sections;
4982 stub_sec = stub_sec->next)
4986 /* Allocate memory to hold the linker stubs. */
4987 size = stub_sec->_raw_size;
4990 stub_sec->contents = (bfd_byte *) bfd_zalloc (htab->stub_bfd, size);
4991 if (stub_sec->contents == NULL)
4994 stub_sec->_cooked_size = 0;
4997 if (htab->splt != NULL)
4999 /* Build the .glink plt call stub. */
5000 plt_r2 = (htab->splt->output_offset
5001 + htab->splt->output_section->vma
5002 - elf_gp (htab->splt->output_section->owner)
5004 p = htab->sglink->contents;
5005 p = build_plt_stub (htab->sglink->owner, p, (int) plt_r2, 1);
5006 while (p - htab->sglink->contents < GLINK_CALL_STUB_SIZE)
5008 bfd_put_32 (htab->sglink->owner, NOP, p);
5011 htab->sglink->_cooked_size = p - htab->sglink->contents;
5013 /* Use reloc_count to count entries. */
5014 htab->sglink->reloc_count = 0;
5017 if (htab->sbrlt->_raw_size != 0)
5019 htab->sbrlt->contents = (bfd_byte *) bfd_zalloc (htab->sbrlt->owner,
5020 htab->sbrlt->_raw_size);
5021 if (htab->sbrlt->contents == NULL)
5025 /* Build the stubs as directed by the stub hash table. */
5026 bfd_hash_traverse (&htab->stub_hash_table, ppc_build_one_stub, info);
5027 htab->sglink->reloc_count = 0;
5029 for (stub_sec = htab->stub_bfd->sections;
5031 stub_sec = stub_sec->next)
5033 if (stub_sec->_raw_size != stub_sec->_cooked_size)
5037 if (stub_sec != NULL
5038 || htab->sglink->_raw_size != htab->sglink->_cooked_size)
5040 htab->stub_error = true;
5041 (*_bfd_error_handler) (_("stubs don't match calculated size"));
5044 return !htab->stub_error;
5047 /* Set up any other section flags and such that may be necessary. */
5050 ppc64_elf_fake_sections (abfd, shdr, asect)
5051 bfd *abfd ATTRIBUTE_UNUSED;
5052 Elf64_Internal_Shdr *shdr;
5055 if ((asect->flags & SEC_EXCLUDE) != 0)
5056 shdr->sh_flags |= SHF_EXCLUDE;
5058 if ((asect->flags & SEC_SORT_ENTRIES) != 0)
5059 shdr->sh_type = SHT_ORDERED;
5064 /* The RELOCATE_SECTION function is called by the ELF backend linker
5065 to handle the relocations for a section.
5067 The relocs are always passed as Rela structures; if the section
5068 actually uses Rel structures, the r_addend field will always be
5071 This function is responsible for adjust the section contents as
5072 necessary, and (if using Rela relocs and generating a
5073 relocateable output file) adjusting the reloc addend as
5076 This function does not have to worry about setting the reloc
5077 address or the reloc symbol index.
5079 LOCAL_SYMS is a pointer to the swapped in local symbols.
5081 LOCAL_SECTIONS is an array giving the section in the input file
5082 corresponding to the st_shndx field of each local symbol.
5084 The global hash table entry for the global symbols can be found
5085 via elf_sym_hashes (input_bfd).
5087 When generating relocateable output, this function must handle
5088 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
5089 going to be the section symbol corresponding to the output
5090 section, which means that the addend must be adjusted
5094 ppc64_elf_relocate_section (output_bfd, info, input_bfd, input_section,
5095 contents, relocs, local_syms, local_sections)
5097 struct bfd_link_info *info;
5099 asection *input_section;
5101 Elf_Internal_Rela *relocs;
5102 Elf_Internal_Sym *local_syms;
5103 asection **local_sections;
5105 struct ppc_link_hash_table *htab;
5106 Elf_Internal_Shdr *symtab_hdr;
5107 struct elf_link_hash_entry **sym_hashes;
5108 Elf_Internal_Rela *rel;
5109 Elf_Internal_Rela *relend;
5110 bfd_vma *local_got_offsets;
5114 /* Disabled until we sort out how ld should choose 'y' vs 'at'. */
5115 boolean is_power4 = false;
5117 if (info->relocateable)
5120 /* Initialize howto table if needed. */
5121 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
5124 htab = ppc_hash_table (info);
5125 local_got_offsets = elf_local_got_offsets (input_bfd);
5126 TOCstart = elf_gp (output_bfd);
5127 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
5128 sym_hashes = elf_sym_hashes (input_bfd);
5129 is_opd = strcmp (bfd_get_section_name (abfd, input_section), ".opd") == 0;
5132 relend = relocs + input_section->reloc_count;
5133 for (; rel < relend; rel++)
5135 enum elf_ppc_reloc_type r_type;
5138 bfd_reloc_status_type r;
5139 Elf_Internal_Sym *sym;
5141 struct elf_link_hash_entry *h;
5142 struct elf_link_hash_entry *fdh;
5143 const char *sym_name;
5144 unsigned long r_symndx;
5146 boolean unresolved_reloc;
5149 struct ppc_stub_hash_entry *stub_entry;
5150 bfd_vma max_br_offset;
5153 r_type = (enum elf_ppc_reloc_type) ELF64_R_TYPE (rel->r_info);
5154 r_symndx = ELF64_R_SYM (rel->r_info);
5155 offset = rel->r_offset;
5156 addend = rel->r_addend;
5157 r = bfd_reloc_other;
5158 sym = (Elf_Internal_Sym *) 0;
5159 sec = (asection *) 0;
5160 h = (struct elf_link_hash_entry *) 0;
5161 sym_name = (const char *) 0;
5162 unresolved_reloc = false;
5165 if (r_type == R_PPC64_TOC)
5167 /* Relocation value is TOC base. Symbol is ignored. */
5168 relocation = TOCstart + TOC_BASE_OFF;
5170 else if (r_symndx < symtab_hdr->sh_info)
5172 /* It's a local symbol. */
5173 sym = local_syms + r_symndx;
5174 sec = local_sections[r_symndx];
5175 sym_name = "<local symbol>";
5177 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, sec, rel);
5178 /* rel may have changed, update our copy of addend. */
5179 addend = rel->r_addend;
5183 /* It's a global symbol. */
5184 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
5185 while (h->root.type == bfd_link_hash_indirect
5186 || h->root.type == bfd_link_hash_warning)
5187 h = (struct elf_link_hash_entry *) h->root.u.i.link;
5188 sym_name = h->root.root.string;
5190 if (h->root.type == bfd_link_hash_defined
5191 || h->root.type == bfd_link_hash_defweak)
5193 sec = h->root.u.def.section;
5194 if (sec->output_section == NULL)
5195 /* Set a flag that will be cleared later if we find a
5196 relocation value for this symbol. output_section
5197 is typically NULL for symbols satisfied by a shared
5199 unresolved_reloc = true;
5201 relocation = (h->root.u.def.value
5202 + sec->output_section->vma
5203 + sec->output_offset);
5205 else if (h->root.type == bfd_link_hash_undefweak)
5207 else if (info->shared
5208 && (!info->symbolic || info->allow_shlib_undefined)
5209 && !info->no_undefined
5210 && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
5214 if (! ((*info->callbacks->undefined_symbol)
5215 (info, h->root.root.string, input_bfd, input_section,
5216 offset, (!info->shared
5217 || info->no_undefined
5218 || ELF_ST_VISIBILITY (h->other)))))
5224 /* First handle relocations that tweak non-addend part of insn. */
5231 /* Branch taken prediction relocations. */
5232 case R_PPC64_ADDR14_BRTAKEN:
5233 case R_PPC64_REL14_BRTAKEN:
5234 insn = 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field. */
5237 /* Branch not taken prediction relocations. */
5238 case R_PPC64_ADDR14_BRNTAKEN:
5239 case R_PPC64_REL14_BRNTAKEN:
5240 insn |= bfd_get_32 (output_bfd, contents + offset) & ~(0x01 << 21);
5243 /* Set 'a' bit. This is 0b00010 in BO field for branch
5244 on CR(BI) insns (BO == 001at or 011at), and 0b01000
5245 for branch on CTR insns (BO == 1a00t or 1a01t). */
5246 if ((insn & (0x14 << 21)) == (0x04 << 21))
5248 else if ((insn & (0x14 << 21)) == (0x10 << 21))
5256 + input_section->output_offset
5257 + input_section->output_section->vma);
5259 /* Invert 'y' bit if not the default. */
5260 if ((bfd_signed_vma) (relocation + addend - from) < 0)
5264 bfd_put_32 (output_bfd, (bfd_vma) insn, contents + offset);
5268 /* A REL24 branching to a linkage function is followed by a
5269 nop. We replace the nop with a ld in order to restore
5270 the TOC base pointer. Only calls to shared objects need
5271 to alter the TOC base. These are recognized by their
5272 need for a PLT entry. */
5274 && (fdh = ((struct ppc_link_hash_entry *) h)->oh) != NULL
5275 && fdh->plt.offset != (bfd_vma) -1
5276 && (stub_entry = ppc_get_stub_entry (input_section, sec, fdh,
5277 rel, htab)) != NULL)
5279 boolean can_plt_call = 0;
5281 if (offset + 8 <= input_section->_cooked_size)
5283 insn = bfd_get_32 (input_bfd, contents + offset + 4);
5285 || insn == CROR_151515 || insn == CROR_313131)
5287 bfd_put_32 (input_bfd, (bfd_vma) LD_R2_40R1,
5288 contents + offset + 4);
5295 /* If this is a plain branch rather than a branch
5296 and link, don't require a nop. */
5297 insn = bfd_get_32 (input_bfd, contents + offset);
5298 if ((insn & 1) == 0)
5304 relocation = (stub_entry->stub_offset
5305 + stub_entry->stub_sec->output_offset
5306 + stub_entry->stub_sec->output_section->vma);
5308 unresolved_reloc = false;
5313 && h->root.type == bfd_link_hash_undefweak
5317 /* Tweak calls to undefined weak functions to point at a
5318 blr. We can thus call a weak function without first
5319 checking whether the function is defined. We have a
5320 blr at the end of .sfpr. */
5321 BFD_ASSERT (htab->sfpr->_raw_size != 0);
5322 relocation = (htab->sfpr->_raw_size - 4
5323 + htab->sfpr->output_offset
5324 + htab->sfpr->output_section->vma);
5326 + input_section->output_offset
5327 + input_section->output_section->vma);
5329 /* But let's not be silly about it. If the blr isn't in
5330 reach, just go to the next instruction. */
5331 if (relocation - from + (1 << 25) >= (1 << 26)
5332 || htab->sfpr->_raw_size == 0)
5333 relocation = from + 4;
5342 (*_bfd_error_handler)
5343 (_("%s: unknown relocation type %d for symbol %s"),
5344 bfd_archive_filename (input_bfd), (int) r_type, sym_name);
5346 bfd_set_error (bfd_error_bad_value);
5351 case R_PPC_GNU_VTINHERIT:
5352 case R_PPC_GNU_VTENTRY:
5355 /* GOT16 relocations. Like an ADDR16 using the symbol's
5356 address in the GOT as relocation value instead of the
5357 symbols value itself. Also, create a GOT entry for the
5358 symbol and put the symbol value there. */
5360 case R_PPC64_GOT16_LO:
5361 case R_PPC64_GOT16_HI:
5362 case R_PPC64_GOT16_HA:
5363 case R_PPC64_GOT16_DS:
5364 case R_PPC64_GOT16_LO_DS:
5366 /* Relocation is to the entry for this symbol in the global
5370 if (htab->sgot == NULL)
5377 off = h->got.offset;
5378 dyn = htab->elf.dynamic_sections_created;
5379 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info, h)
5383 || (h->elf_link_hash_flags
5384 & ELF_LINK_FORCED_LOCAL))
5385 && (h->elf_link_hash_flags
5386 & ELF_LINK_HASH_DEF_REGULAR)))
5388 /* This is actually a static link, or it is a
5389 -Bsymbolic link and the symbol is defined
5390 locally, or the symbol was forced to be local
5391 because of a version file. We must initialize
5392 this entry in the global offset table. Since the
5393 offset must always be a multiple of 8, we use the
5394 least significant bit to record whether we have
5395 initialized it already.
5397 When doing a dynamic link, we create a .rel.got
5398 relocation entry to initialize the value. This
5399 is done in the finish_dynamic_symbol routine. */
5404 bfd_put_64 (output_bfd, relocation,
5405 htab->sgot->contents + off);
5410 unresolved_reloc = false;
5414 if (local_got_offsets == NULL)
5417 off = local_got_offsets[r_symndx];
5419 /* The offset must always be a multiple of 8. We use
5420 the least significant bit to record whether we have
5421 already processed this entry. */
5426 bfd_put_64 (output_bfd, relocation,
5427 htab->sgot->contents + off);
5431 Elf_Internal_Rela outrel;
5432 Elf64_External_Rela *loc;
5434 /* We need to generate a R_PPC64_RELATIVE reloc
5435 for the dynamic linker. */
5436 outrel.r_offset = (htab->sgot->output_section->vma
5437 + htab->sgot->output_offset
5439 outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
5440 outrel.r_addend = relocation;
5441 loc = (Elf64_External_Rela *) htab->srelgot->contents;
5442 loc += htab->srelgot->reloc_count++;
5443 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
5446 local_got_offsets[r_symndx] |= 1;
5450 if (off >= (bfd_vma) -2)
5453 relocation = htab->sgot->output_offset + off;
5455 /* TOC base (r2) is TOC start plus 0x8000. */
5456 addend -= TOC_BASE_OFF;
5460 case R_PPC64_PLT16_HA:
5461 case R_PPC64_PLT16_HI:
5462 case R_PPC64_PLT16_LO:
5465 /* Relocation is to the entry for this symbol in the
5466 procedure linkage table. */
5468 /* Resolve a PLT reloc against a local symbol directly,
5469 without using the procedure linkage table. */
5473 if (h->plt.offset == (bfd_vma) -1
5474 || htab->splt == NULL)
5476 /* We didn't make a PLT entry for this symbol. This
5477 happens when statically linking PIC code, or when
5478 using -Bsymbolic. */
5482 relocation = (htab->splt->output_section->vma
5483 + htab->splt->output_offset
5485 unresolved_reloc = false;
5488 /* TOC16 relocs. We want the offset relative to the TOC base,
5489 which is the address of the start of the TOC plus 0x8000.
5490 The TOC consists of sections .got, .toc, .tocbss, and .plt,
5493 case R_PPC64_TOC16_LO:
5494 case R_PPC64_TOC16_HI:
5495 case R_PPC64_TOC16_DS:
5496 case R_PPC64_TOC16_LO_DS:
5497 case R_PPC64_TOC16_HA:
5498 addend -= TOCstart + TOC_BASE_OFF;
5501 /* Relocate against the beginning of the section. */
5502 case R_PPC64_SECTOFF:
5503 case R_PPC64_SECTOFF_LO:
5504 case R_PPC64_SECTOFF_HI:
5505 case R_PPC64_SECTOFF_DS:
5506 case R_PPC64_SECTOFF_LO_DS:
5507 case R_PPC64_SECTOFF_HA:
5508 if (sec != (asection *) 0)
5509 addend -= sec->output_section->vma;
5513 case R_PPC64_REL14_BRNTAKEN:
5514 case R_PPC64_REL14_BRTAKEN:
5518 /* Relocations that may need to be propagated if this is a
5522 case R_PPC64_ADDR14:
5523 case R_PPC64_ADDR14_BRNTAKEN:
5524 case R_PPC64_ADDR14_BRTAKEN:
5525 case R_PPC64_ADDR16:
5526 case R_PPC64_ADDR16_DS:
5527 case R_PPC64_ADDR16_HA:
5528 case R_PPC64_ADDR16_HI:
5529 case R_PPC64_ADDR16_HIGHER:
5530 case R_PPC64_ADDR16_HIGHERA:
5531 case R_PPC64_ADDR16_HIGHEST:
5532 case R_PPC64_ADDR16_HIGHESTA:
5533 case R_PPC64_ADDR16_LO:
5534 case R_PPC64_ADDR16_LO_DS:
5535 case R_PPC64_ADDR24:
5536 case R_PPC64_ADDR30:
5537 case R_PPC64_ADDR32:
5538 case R_PPC64_ADDR64:
5539 case R_PPC64_UADDR16:
5540 case R_PPC64_UADDR32:
5541 case R_PPC64_UADDR64:
5542 /* r_symndx will be zero only for relocs against symbols
5543 from removed linkonce sections, or sections discarded by
5550 if ((input_section->flags & SEC_ALLOC) == 0)
5553 if (NO_OPD_RELOCS && is_opd)
5557 && (IS_ABSOLUTE_RELOC (r_type)
5560 && (! info->symbolic
5561 || (h->elf_link_hash_flags
5562 & ELF_LINK_HASH_DEF_REGULAR) == 0))))
5566 && (h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0
5567 && (((h->elf_link_hash_flags
5568 & ELF_LINK_HASH_DEF_DYNAMIC) != 0
5569 && (h->elf_link_hash_flags
5570 & ELF_LINK_HASH_DEF_REGULAR) == 0)
5571 || h->root.type == bfd_link_hash_undefweak
5572 || h->root.type == bfd_link_hash_undefined)))
5574 Elf_Internal_Rela outrel;
5575 boolean skip, relocate;
5577 Elf64_External_Rela *loc;
5579 /* When generating a dynamic object, these relocations
5580 are copied into the output file to be resolved at run
5587 _bfd_elf_section_offset (output_bfd, info, input_section,
5589 if (outrel.r_offset == (bfd_vma) -1)
5591 else if (outrel.r_offset == (bfd_vma) -2)
5592 skip = true, relocate = true;
5593 outrel.r_offset += (input_section->output_section->vma
5594 + input_section->output_offset);
5595 outrel.r_addend = addend;
5598 memset (&outrel, 0, sizeof outrel);
5602 && (!IS_ABSOLUTE_RELOC (r_type)
5605 || (h->elf_link_hash_flags
5606 & ELF_LINK_HASH_DEF_REGULAR) == 0))
5607 outrel.r_info = ELF64_R_INFO (h->dynindx, r_type);
5610 /* This symbol is local, or marked to become local,
5611 or this is an opd section reloc which must point
5612 at a local function. */
5613 outrel.r_addend += relocation;
5615 if (r_type == R_PPC64_ADDR64 || r_type == R_PPC64_TOC)
5617 if (is_opd && h != NULL)
5619 /* Lie about opd entries. This case occurs
5620 when building shared libraries and we
5621 reference a function in another shared
5622 lib. The same thing happens for a weak
5623 definition in an application that's
5624 overridden by a strong definition in a
5625 shared lib. (I believe this is a generic
5626 bug in binutils handling of weak syms.)
5627 In these cases we won't use the opd
5628 entry in this lib; We ought to edit the
5629 opd section to remove unused entries. */
5630 unresolved_reloc = false;
5632 outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
5638 if (bfd_is_abs_section (sec))
5640 else if (sec == NULL || sec->owner == NULL)
5642 bfd_set_error (bfd_error_bad_value);
5649 osec = sec->output_section;
5650 indx = elf_section_data (osec)->dynindx;
5652 /* We are turning this relocation into one
5653 against a section symbol, so subtract out
5654 the output section's address but not the
5655 offset of the input section in the output
5657 outrel.r_addend -= osec->vma;
5660 outrel.r_info = ELF64_R_INFO (indx, r_type);
5664 sreloc = elf_section_data (input_section)->sreloc;
5668 loc = (Elf64_External_Rela *) sreloc->contents;
5669 loc += sreloc->reloc_count++;
5670 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
5672 /* If this reloc is against an external symbol, it will
5673 be computed at runtime, so there's no need to do
5681 case R_PPC64_GLOB_DAT:
5682 case R_PPC64_JMP_SLOT:
5683 case R_PPC64_RELATIVE:
5684 /* We shouldn't ever see these dynamic relocs in relocatable
5688 case R_PPC64_PLTGOT16:
5689 case R_PPC64_PLTGOT16_DS:
5690 case R_PPC64_PLTGOT16_HA:
5691 case R_PPC64_PLTGOT16_HI:
5692 case R_PPC64_PLTGOT16_LO:
5693 case R_PPC64_PLTGOT16_LO_DS:
5694 case R_PPC64_PLTREL32:
5695 case R_PPC64_PLTREL64:
5696 /* These ones haven't been implemented yet. */
5698 (*_bfd_error_handler)
5699 (_("%s: Relocation %s is not supported for symbol %s."),
5700 bfd_archive_filename (input_bfd),
5701 ppc64_elf_howto_table[(int) r_type]->name, sym_name);
5703 bfd_set_error (bfd_error_invalid_operation);
5708 /* Do any further special processing. */
5714 case R_PPC64_ADDR16_HA:
5715 case R_PPC64_ADDR16_HIGHERA:
5716 case R_PPC64_ADDR16_HIGHESTA:
5717 case R_PPC64_PLT16_HA:
5718 case R_PPC64_TOC16_HA:
5719 case R_PPC64_SECTOFF_HA:
5720 /* It's just possible that this symbol is a weak symbol
5721 that's not actually defined anywhere. In that case,
5722 'sec' would be NULL, and we should leave the symbol
5723 alone (it will be set to zero elsewhere in the link). */
5725 /* Add 0x10000 if sign bit in 0:15 is set. */
5726 addend += ((relocation + addend) & 0x8000) << 1;
5729 case R_PPC64_ADDR16_DS:
5730 case R_PPC64_ADDR16_LO_DS:
5731 case R_PPC64_GOT16_DS:
5732 case R_PPC64_GOT16_LO_DS:
5733 case R_PPC64_PLT16_LO_DS:
5734 case R_PPC64_SECTOFF_DS:
5735 case R_PPC64_SECTOFF_LO_DS:
5736 case R_PPC64_TOC16_DS:
5737 case R_PPC64_TOC16_LO_DS:
5738 case R_PPC64_PLTGOT16_DS:
5739 case R_PPC64_PLTGOT16_LO_DS:
5740 if (((relocation + addend) & 3) != 0)
5742 (*_bfd_error_handler)
5743 (_("%s: error: relocation %s not a multiple of 4"),
5744 bfd_archive_filename (input_bfd),
5745 ppc64_elf_howto_table[(int) r_type]->name);
5746 bfd_set_error (bfd_error_bad_value);
5753 case R_PPC64_REL14_BRNTAKEN:
5754 case R_PPC64_REL14_BRTAKEN:
5755 max_br_offset = 1 << 15;
5759 max_br_offset = 1 << 25;
5762 /* If the branch is out of reach, then redirect the
5763 call to the local stub for this function. */
5765 + input_section->output_offset
5766 + input_section->output_section->vma);
5767 if (relocation + addend - from + max_br_offset >= 2 * max_br_offset
5768 && (stub_entry = ppc_get_stub_entry (input_section, sec, h,
5769 rel, htab)) != NULL)
5771 /* Munge up the value and addend so that we call the stub
5772 rather than the procedure directly. */
5773 relocation = (stub_entry->stub_offset
5774 + stub_entry->stub_sec->output_offset
5775 + stub_entry->stub_sec->output_section->vma);
5781 /* FIXME: Why do we allow debugging sections to escape this error?
5782 More importantly, why do we not emit dynamic relocs above in
5783 debugging sections (which are ! SEC_ALLOC)? If we had
5784 emitted the dynamic reloc, we could remove the fudge here. */
5785 if (unresolved_reloc
5787 && (input_section->flags & SEC_DEBUGGING) != 0
5788 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0))
5790 (*_bfd_error_handler)
5791 (_("%s(%s+0x%lx): unresolvable relocation against symbol `%s'"),
5792 bfd_archive_filename (input_bfd),
5793 bfd_get_section_name (input_bfd, input_section),
5794 (long) rel->r_offset,
5795 h->root.root.string);
5799 r = _bfd_final_link_relocate (ppc64_elf_howto_table[(int) r_type],
5807 if (r != bfd_reloc_ok)
5813 if (h->root.type == bfd_link_hash_undefweak
5814 && ppc64_elf_howto_table[(int) r_type]->pc_relative)
5816 /* Assume this is a call protected by other code that
5817 detects the symbol is undefined. If this is the case,
5818 we can safely ignore the overflow. If not, the
5819 program is hosed anyway, and a little warning isn't
5825 name = h->root.root.string;
5829 name = bfd_elf_string_from_elf_section (input_bfd,
5830 symtab_hdr->sh_link,
5835 name = bfd_section_name (input_bfd, sec);
5838 if (r == bfd_reloc_overflow)
5842 if (!((*info->callbacks->reloc_overflow)
5843 (info, name, ppc64_elf_howto_table[(int) r_type]->name,
5844 rel->r_addend, input_bfd, input_section, offset)))
5849 (*_bfd_error_handler)
5850 (_("%s(%s+0x%lx): reloc against `%s': error %d"),
5851 bfd_archive_filename (input_bfd),
5852 bfd_get_section_name (input_bfd, input_section),
5853 (long) rel->r_offset, name, (int) r);
5862 /* Finish up dynamic symbol handling. We set the contents of various
5863 dynamic sections here. */
5866 ppc64_elf_finish_dynamic_symbol (output_bfd, info, h, sym)
5868 struct bfd_link_info *info;
5869 struct elf_link_hash_entry *h;
5870 Elf_Internal_Sym *sym;
5872 struct ppc_link_hash_table *htab;
5875 htab = ppc_hash_table (info);
5876 dynobj = htab->elf.dynobj;
5878 if (h->plt.offset != (bfd_vma) -1
5879 && ((struct ppc_link_hash_entry *) h)->is_func_descriptor)
5881 Elf_Internal_Rela rela;
5882 Elf64_External_Rela *loc;
5884 /* This symbol has an entry in the procedure linkage table. Set
5887 if (htab->splt == NULL
5888 || htab->srelplt == NULL
5889 || htab->sglink == NULL)
5892 /* Create a JMP_SLOT reloc to inform the dynamic linker to
5893 fill in the PLT entry. */
5895 rela.r_offset = (htab->splt->output_section->vma
5896 + htab->splt->output_offset
5898 rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_JMP_SLOT);
5901 loc = (Elf64_External_Rela *) htab->srelplt->contents;
5902 loc += (h->plt.offset - PLT_INITIAL_ENTRY_SIZE) / PLT_ENTRY_SIZE;
5903 bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
5906 if (h->got.offset != (bfd_vma) -1)
5908 Elf_Internal_Rela rela;
5909 Elf64_External_Rela *loc;
5911 /* This symbol has an entry in the global offset table. Set it
5914 if (htab->sgot == NULL || htab->srelgot == NULL)
5917 rela.r_offset = (htab->sgot->output_section->vma
5918 + htab->sgot->output_offset
5919 + (h->got.offset &~ (bfd_vma) 1));
5921 /* If this is a static link, or it is a -Bsymbolic link and the
5922 symbol is defined locally or was forced to be local because
5923 of a version file, we just want to emit a RELATIVE reloc.
5924 The entry in the global offset table will already have been
5925 initialized in the relocate_section function. */
5929 || (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL))
5930 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))
5932 BFD_ASSERT((h->got.offset & 1) != 0);
5933 rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
5934 rela.r_addend = (h->root.u.def.value
5935 + h->root.u.def.section->output_section->vma
5936 + h->root.u.def.section->output_offset);
5940 BFD_ASSERT ((h->got.offset & 1) == 0);
5941 bfd_put_64 (output_bfd, (bfd_vma) 0,
5942 htab->sgot->contents + h->got.offset);
5943 rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_GLOB_DAT);
5947 loc = (Elf64_External_Rela *) htab->srelgot->contents;
5948 loc += htab->srelgot->reloc_count++;
5949 bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
5952 if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_COPY) != 0)
5954 Elf_Internal_Rela rela;
5955 Elf64_External_Rela *loc;
5957 /* This symbol needs a copy reloc. Set it up. */
5959 if (h->dynindx == -1
5960 || (h->root.type != bfd_link_hash_defined
5961 && h->root.type != bfd_link_hash_defweak)
5962 || htab->srelbss == NULL)
5965 rela.r_offset = (h->root.u.def.value
5966 + h->root.u.def.section->output_section->vma
5967 + h->root.u.def.section->output_offset);
5968 rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_COPY);
5970 loc = (Elf64_External_Rela *) htab->srelbss->contents;
5971 loc += htab->srelbss->reloc_count++;
5972 bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
5975 /* Mark some specially defined symbols as absolute. */
5976 if (strcmp (h->root.root.string, "_DYNAMIC") == 0)
5977 sym->st_shndx = SHN_ABS;
5982 /* Used to decide how to sort relocs in an optimal manner for the
5983 dynamic linker, before writing them out. */
5985 static enum elf_reloc_type_class
5986 ppc64_elf_reloc_type_class (rela)
5987 const Elf_Internal_Rela *rela;
5989 enum elf_ppc_reloc_type r_type;
5991 r_type = (enum elf_ppc_reloc_type) ELF64_R_TYPE (rela->r_info);
5994 case R_PPC64_RELATIVE:
5995 return reloc_class_relative;
5996 case R_PPC64_JMP_SLOT:
5997 return reloc_class_plt;
5999 return reloc_class_copy;
6001 return reloc_class_normal;
6005 /* Finish up the dynamic sections. */
6008 ppc64_elf_finish_dynamic_sections (output_bfd, info)
6010 struct bfd_link_info *info;
6012 struct ppc_link_hash_table *htab;
6016 htab = ppc_hash_table (info);
6017 dynobj = htab->elf.dynobj;
6018 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
6020 if (htab->elf.dynamic_sections_created)
6022 Elf64_External_Dyn *dyncon, *dynconend;
6024 if (sdyn == NULL || htab->sgot == NULL)
6027 dyncon = (Elf64_External_Dyn *) sdyn->contents;
6028 dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
6029 for (; dyncon < dynconend; dyncon++)
6031 Elf_Internal_Dyn dyn;
6034 bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
6041 case DT_PPC64_GLINK:
6042 dyn.d_un.d_ptr = (htab->sglink->output_section->vma
6043 + htab->sglink->output_offset);
6047 s = bfd_get_section_by_name (output_bfd, ".opd");
6049 dyn.d_un.d_ptr = s->vma;
6052 case DT_PPC64_OPDSZ:
6053 s = bfd_get_section_by_name (output_bfd, ".opd");
6055 dyn.d_un.d_val = s->_raw_size;
6059 dyn.d_un.d_ptr = (htab->splt->output_section->vma
6060 + htab->splt->output_offset);
6064 dyn.d_un.d_ptr = (htab->srelplt->output_section->vma
6065 + htab->srelplt->output_offset);
6069 dyn.d_un.d_val = htab->srelplt->_raw_size;
6073 /* Don't count procedure linkage table relocs in the
6074 overall reloc count. */
6075 if (htab->srelplt != NULL)
6076 dyn.d_un.d_val -= htab->srelplt->_raw_size;
6080 bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
6084 if (htab->sgot != NULL && htab->sgot->_raw_size != 0)
6086 /* Fill in the first entry in the global offset table.
6087 We use it to hold the link-time TOCbase. */
6088 bfd_put_64 (output_bfd,
6089 elf_gp (output_bfd) + TOC_BASE_OFF,
6090 htab->sgot->contents);
6092 /* Set .got entry size. */
6093 elf_section_data (htab->sgot->output_section)->this_hdr.sh_entsize = 8;
6096 if (htab->splt != NULL && htab->splt->_raw_size != 0)
6098 /* Set .plt entry size. */
6099 elf_section_data (htab->splt->output_section)->this_hdr.sh_entsize
6106 #define TARGET_LITTLE_SYM bfd_elf64_powerpcle_vec
6107 #define TARGET_LITTLE_NAME "elf64-powerpcle"
6108 #define TARGET_BIG_SYM bfd_elf64_powerpc_vec
6109 #define TARGET_BIG_NAME "elf64-powerpc"
6110 #define ELF_ARCH bfd_arch_powerpc
6111 #define ELF_MACHINE_CODE EM_PPC64
6112 #define ELF_MAXPAGESIZE 0x10000
6113 #define elf_info_to_howto ppc64_elf_info_to_howto
6115 #ifdef EM_CYGNUS_POWERPC
6116 #define ELF_MACHINE_ALT1 EM_CYGNUS_POWERPC
6120 #define ELF_MACHINE_ALT2 EM_PPC_OLD
6123 #define elf_backend_want_got_sym 0
6124 #define elf_backend_want_plt_sym 0
6125 #define elf_backend_plt_alignment 3
6126 #define elf_backend_plt_not_loaded 1
6127 #define elf_backend_got_symbol_offset 0
6128 #define elf_backend_got_header_size 8
6129 #define elf_backend_plt_header_size PLT_INITIAL_ENTRY_SIZE
6130 #define elf_backend_can_gc_sections 1
6131 #define elf_backend_can_refcount 1
6132 #define elf_backend_rela_normal 1
6134 #define bfd_elf64_bfd_reloc_type_lookup ppc64_elf_reloc_type_lookup
6135 #define bfd_elf64_bfd_set_private_flags ppc64_elf_set_private_flags
6136 #define bfd_elf64_bfd_merge_private_bfd_data ppc64_elf_merge_private_bfd_data
6137 #define bfd_elf64_bfd_link_hash_table_create ppc64_elf_link_hash_table_create
6138 #define bfd_elf64_bfd_link_hash_table_free ppc64_elf_link_hash_table_free
6139 #define bfd_elf64_get_symbol_info ppc64_elf_get_symbol_info
6141 #define elf_backend_section_from_shdr ppc64_elf_section_from_shdr
6142 #define elf_backend_create_dynamic_sections ppc64_elf_create_dynamic_sections
6143 #define elf_backend_copy_indirect_symbol ppc64_elf_copy_indirect_symbol
6144 #define elf_backend_check_relocs ppc64_elf_check_relocs
6145 #define elf_backend_gc_mark_hook ppc64_elf_gc_mark_hook
6146 #define elf_backend_gc_sweep_hook ppc64_elf_gc_sweep_hook
6147 #define elf_backend_adjust_dynamic_symbol ppc64_elf_adjust_dynamic_symbol
6148 #define elf_backend_hide_symbol ppc64_elf_hide_symbol
6149 #define elf_backend_always_size_sections ppc64_elf_func_desc_adjust
6150 #define elf_backend_size_dynamic_sections ppc64_elf_size_dynamic_sections
6151 #define elf_backend_fake_sections ppc64_elf_fake_sections
6152 #define elf_backend_relocate_section ppc64_elf_relocate_section
6153 #define elf_backend_finish_dynamic_symbol ppc64_elf_finish_dynamic_symbol
6154 #define elf_backend_reloc_type_class ppc64_elf_reloc_type_class
6155 #define elf_backend_finish_dynamic_sections ppc64_elf_finish_dynamic_sections
6157 #include "elf64-target.h"
projects / external / binutils.git / blob