projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Fix out of bounds memory access when trying to allocate space for a note of size -1.
[deliverable/binutils-gdb.git] / bfd / elf64-ppc.c
CommitLineData
5bd4f169 1/* PowerPC64-specific support for 64-bit ELF.
2571583a 2 Copyright (C) 1999-2017 Free Software Foundation, Inc.
5bd4f169
AM		 3 Written by Linus Nordberg, Swox AB <info@swox.com>,
4 based on elf32-ppc.c by Ian Lance Taylor.
32ca9640 5 Largely rewritten by Alan Modra.
5bd4f169 6
ae9a127f 7 This file is part of BFD, the Binary File Descriptor library.
5bd4f169 8
ae9a127f
NC		 9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
cd123cb7 11 the Free Software Foundation; either version 3 of the License, or
ae9a127f 12 (at your option) any later version.
5bd4f169 13
ae9a127f
NC		 14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
5bd4f169 18
4ce794b7
AM		 19 You should have received a copy of the GNU General Public License along
20 with this program; if not, write to the Free Software Foundation, Inc.,
3e110533 21 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */
5bd4f169 22
cd123cb7 23
4ce794b7
AM		 24/* The 64-bit PowerPC ELF ABI may be found at
25 http://www.linuxbase.org/spec/ELF/ppc64/PPC-elf64abi.txt, and
26 http://www.linuxbase.org/spec/ELF/ppc64/spec/book1.html */
5bd4f169 27
3db64b00 28#include "sysdep.h"
183e98be 29#include <stdarg.h>
5bd4f169 30#include "bfd.h"
5bd4f169
AM		 31#include "bfdlink.h"
32#include "libbfd.h"
33#include "elf-bfd.h"
04c9666a 34#include "elf/ppc64.h"
5d1634d7 35#include "elf64-ppc.h"
58d180e8 36#include "dwarf2.h"
5bd4f169 37
805fc799 38static bfd_reloc_status_type ppc64_elf_ha_reloc
4ce794b7 39 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
2441e016
AM		 40static bfd_reloc_status_type ppc64_elf_branch_reloc
41 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
805fc799 42static bfd_reloc_status_type ppc64_elf_brtaken_reloc
4ce794b7 43 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
805fc799 44static bfd_reloc_status_type ppc64_elf_sectoff_reloc
4ce794b7 45 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
805fc799 46static bfd_reloc_status_type ppc64_elf_sectoff_ha_reloc
4ce794b7 47 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
805fc799 48static bfd_reloc_status_type ppc64_elf_toc_reloc
4ce794b7 49 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
805fc799 50static bfd_reloc_status_type ppc64_elf_toc_ha_reloc
4ce794b7 51 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
805fc799 52static bfd_reloc_status_type ppc64_elf_toc64_reloc
4ce794b7 53 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
805fc799 54static bfd_reloc_status_type ppc64_elf_unhandled_reloc
4ce794b7 55 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
2441e016 56static bfd_vma opd_entry_value
aef36ac1 57 (asection *, bfd_vma, asection **, bfd_vma *, bfd_boolean);
5bd4f169 58
6d00b590 59#define TARGET_LITTLE_SYM powerpc_elf64_le_vec
ad8e1ba5 60#define TARGET_LITTLE_NAME "elf64-powerpcle"
6d00b590 61#define TARGET_BIG_SYM powerpc_elf64_vec
ad8e1ba5
AM		 62#define TARGET_BIG_NAME "elf64-powerpc"
63#define ELF_ARCH bfd_arch_powerpc
ae95ffa6 64#define ELF_TARGET_ID PPC64_ELF_DATA
ad8e1ba5
AM		 65#define ELF_MACHINE_CODE EM_PPC64
66#define ELF_MAXPAGESIZE 0x10000
04c6a44c 67#define ELF_COMMONPAGESIZE 0x10000
ad8e1ba5
AM		 68#define elf_info_to_howto ppc64_elf_info_to_howto
69
70#define elf_backend_want_got_sym 0
71#define elf_backend_want_plt_sym 0
72#define elf_backend_plt_alignment 3
73#define elf_backend_plt_not_loaded 1
ad8e1ba5 74#define elf_backend_got_header_size 8
5474d94f 75#define elf_backend_want_dynrelro 1
ad8e1ba5
AM		 76#define elf_backend_can_gc_sections 1
77#define elf_backend_can_refcount 1
78#define elf_backend_rela_normal 1
64f52338 79#define elf_backend_dtrel_excludes_plt 1
6bfdb61b 80#define elf_backend_default_execstack 0
ad8e1ba5 81
e717da7e 82#define bfd_elf64_mkobject ppc64_elf_mkobject
ad8e1ba5 83#define bfd_elf64_bfd_reloc_type_lookup ppc64_elf_reloc_type_lookup
aa374f67 84#define bfd_elf64_bfd_reloc_name_lookup ppc64_elf_reloc_name_lookup
ee67d69a
AM		 85#define bfd_elf64_bfd_merge_private_bfd_data ppc64_elf_merge_private_bfd_data
86#define bfd_elf64_bfd_print_private_bfd_data ppc64_elf_print_private_bfd_data
ad8e1ba5
AM		 87#define bfd_elf64_new_section_hook ppc64_elf_new_section_hook
88#define bfd_elf64_bfd_link_hash_table_create ppc64_elf_link_hash_table_create
90e3cdf2 89#define bfd_elf64_get_synthetic_symtab ppc64_elf_get_synthetic_symtab
aa374f67 90#define bfd_elf64_bfd_link_just_syms ppc64_elf_link_just_syms
8c5b4e52 91#define bfd_elf64_bfd_gc_sections ppc64_elf_gc_sections
ad8e1ba5
AM		 92
93#define elf_backend_object_p ppc64_elf_object_p
d37c89e5
AM		 94#define elf_backend_grok_prstatus ppc64_elf_grok_prstatus
95#define elf_backend_grok_psinfo ppc64_elf_grok_psinfo
183e98be 96#define elf_backend_write_core_note ppc64_elf_write_core_note
9d19e4fd 97#define elf_backend_create_dynamic_sections _bfd_elf_create_dynamic_sections
ad8e1ba5 98#define elf_backend_copy_indirect_symbol ppc64_elf_copy_indirect_symbol
555cd476 99#define elf_backend_add_symbol_hook ppc64_elf_add_symbol_hook
f6c7c3e8 100#define elf_backend_check_directives ppc64_elf_before_check_relocs
e5034e59 101#define elf_backend_notice_as_needed ppc64_elf_notice_as_needed
8387904d 102#define elf_backend_archive_symbol_lookup ppc64_elf_archive_symbol_lookup
ad8e1ba5 103#define elf_backend_check_relocs ppc64_elf_check_relocs
74f0fb50 104#define elf_backend_gc_keep ppc64_elf_gc_keep
64d03ab5 105#define elf_backend_gc_mark_dynamic_ref ppc64_elf_gc_mark_dynamic_ref
ad8e1ba5
AM		 106#define elf_backend_gc_mark_hook ppc64_elf_gc_mark_hook
107#define elf_backend_gc_sweep_hook ppc64_elf_gc_sweep_hook
108#define elf_backend_adjust_dynamic_symbol ppc64_elf_adjust_dynamic_symbol
109#define elf_backend_hide_symbol ppc64_elf_hide_symbol
9f296da3 110#define elf_backend_maybe_function_sym ppc64_elf_maybe_function_sym
ad8e1ba5
AM		 111#define elf_backend_always_size_sections ppc64_elf_func_desc_adjust
112#define elf_backend_size_dynamic_sections ppc64_elf_size_dynamic_sections
a345bc8d 113#define elf_backend_hash_symbol ppc64_elf_hash_symbol
74541ad4 114#define elf_backend_init_index_section _bfd_elf_init_2_index_sections
60124e18 115#define elf_backend_action_discarded ppc64_elf_action_discarded
ad8e1ba5
AM		 116#define elf_backend_relocate_section ppc64_elf_relocate_section
117#define elf_backend_finish_dynamic_symbol ppc64_elf_finish_dynamic_symbol
118#define elf_backend_reloc_type_class ppc64_elf_reloc_type_class
119#define elf_backend_finish_dynamic_sections ppc64_elf_finish_dynamic_sections
754021d0 120#define elf_backend_link_output_symbol_hook ppc64_elf_output_symbol_hook
29ef7005 121#define elf_backend_special_sections ppc64_elf_special_sections
6911b7dc 122#define elf_backend_merge_symbol_attribute ppc64_elf_merge_symbol_attribute
8c5b4e52 123#define elf_backend_merge_symbol ppc64_elf_merge_symbol
bce964aa 124#define elf_backend_get_reloc_section bfd_get_section_by_name
ad8e1ba5 125
5bd4f169
AM		 126/* The name of the dynamic interpreter. This is put in the .interp
127 section. */
128#define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
129
130/* The size in bytes of an entry in the procedure linkage table. */
b9e5796b 131#define PLT_ENTRY_SIZE(htab) (htab->opd_abi ? 24 : 8)
5bd4f169
AM		 132
133/* The initial size of the plt reserved for the dynamic linker. */
b9e5796b 134#define PLT_INITIAL_ENTRY_SIZE(htab) (htab->opd_abi ? 24 : 16)
5bd4f169 135
a078d95a
AM		 136/* Offsets to some stack save slots. */
137#define STK_LR 16
138#define STK_TOC(htab) (htab->opd_abi ? 40 : 24)
eb8d7fda 139/* This one is dodgy. ELFv2 does not have a linker word, so use the
a078d95a
AM		 140 CR save slot. Used only by optimised __tls_get_addr call stub,
141 relying on __tls_get_addr_opt not saving CR.. */
142#define STK_LINKER(htab) (htab->opd_abi ? 32 : 8)
143
5bd4f169 144/* TOC base pointers offset from start of TOC. */
411e1bfb 145#define TOC_BASE_OFF 0x8000
a27e685f
AM		 146/* TOC base alignment. */
147#define TOC_BASE_ALIGN 256
411e1bfb
AM		 148
149/* Offset of tp and dtp pointers from start of TLS block. */
150#define TP_OFFSET 0x7000
151#define DTP_OFFSET 0x8000
5bd4f169 152
ad8e1ba5
AM		 153/* .plt call stub instructions. The normal stub is like this, but
154 sometimes the .plt entry crosses a 64k boundary and we need to
71a39c98 155 insert an addi to adjust r11. */
a078d95a 156#define STD_R2_0R1 0xf8410000 /* std %r2,0+40(%r1) */
71a39c98
AM		 157#define ADDIS_R11_R2 0x3d620000 /* addis %r11,%r2,xxx@ha */
158#define LD_R12_0R11 0xe98b0000 /* ld %r12,xxx+0@l(%r11) */
159#define MTCTR_R12 0x7d8903a6 /* mtctr %r12 */
160#define LD_R2_0R11 0xe84b0000 /* ld %r2,xxx+8@l(%r11) */
161#define LD_R11_0R11 0xe96b0000 /* ld %r11,xxx+16@l(%r11) */
5d1634d7
AM		 162#define BCTR 0x4e800420 /* bctr */
163
71a39c98 164#define ADDI_R11_R11 0x396b0000 /* addi %r11,%r11,off@l */
ad8e1ba5
AM		 165#define ADDIS_R2_R2 0x3c420000 /* addis %r2,%r2,off@ha */
166#define ADDI_R2_R2 0x38420000 /* addi %r2,%r2,off@l */
167
71a39c98
AM		 168#define XOR_R2_R12_R12 0x7d826278 /* xor %r2,%r12,%r12 */
169#define ADD_R11_R11_R2 0x7d6b1214 /* add %r11,%r11,%r2 */
170#define XOR_R11_R12_R12 0x7d8b6278 /* xor %r11,%r12,%r12 */
794e51c0
AM		 171#define ADD_R2_R2_R11 0x7c425a14 /* add %r2,%r2,%r11 */
172#define CMPLDI_R2_0 0x28220000 /* cmpldi %r2,0 */
173#define BNECTR 0x4ca20420 /* bnectr+ */
174#define BNECTR_P4 0x4ce20420 /* bnectr+ */
175
71a39c98 176#define LD_R12_0R2 0xe9820000 /* ld %r12,xxx+0(%r2) */
ac2df442
AM		 177#define LD_R11_0R2 0xe9620000 /* ld %r11,xxx+0(%r2) */
178#define LD_R2_0R2 0xe8420000 /* ld %r2,xxx+0(%r2) */
179
a078d95a 180#define LD_R2_0R1 0xe8410000 /* ld %r2,0(%r1) */
006589cf
AM		 181#define LD_R2_0R12 0xe84c0000 /* ld %r2,0(%r12) */
182#define ADD_R2_R2_R12 0x7c426214 /* add %r2,%r2,%r12 */
ad8e1ba5 183
006589cf
AM		 184#define LIS_R2 0x3c400000 /* lis %r2,xxx@ha */
185#define ADDIS_R2_R12 0x3c4c0000 /* addis %r2,%r12,xxx@ha */
186#define ADDIS_R12_R2 0x3d820000 /* addis %r12,%r2,xxx@ha */
a345bc8d
AM		 187#define ADDIS_R12_R12 0x3d8c0000 /* addis %r12,%r12,xxx@ha */
188#define LD_R12_0R12 0xe98c0000 /* ld %r12,xxx@l(%r12) */
189
ee4bf8d2 190/* glink call stub instructions. We enter with the index in R0. */
ad8e1ba5 191#define GLINK_CALL_STUB_SIZE (16*4)
ee4bf8d2
AM		 192 /* 0: */
193 /* .quad plt0-1f */
194 /* __glink: */
195#define MFLR_R12 0x7d8802a6 /* mflr %12 */
196#define BCL_20_31 0x429f0005 /* bcl 20,31,1f */
197 /* 1: */
198#define MFLR_R11 0x7d6802a6 /* mflr %11 */
71a39c98 199 /* ld %2,(0b-1b)(%11) */
ee4bf8d2 200#define MTLR_R12 0x7d8803a6 /* mtlr %12 */
71a39c98
AM		 201#define ADD_R11_R2_R11 0x7d625a14 /* add %11,%2,%11 */
202 /* ld %12,0(%11) */
203 /* ld %2,8(%11) */
204 /* mtctr %12 */
205 /* ld %11,16(%11) */
ee4bf8d2 206 /* bctr */
b9e5796b
AM		 207#define MFLR_R0 0x7c0802a6 /* mflr %r0 */
208#define MTLR_R0 0x7c0803a6 /* mtlr %r0 */
209#define SUB_R12_R12_R11 0x7d8b6050 /* subf %r12,%r11,%r12 */
210#define ADDI_R0_R12 0x380c0000 /* addi %r0,%r12,0 */
211#define SRDI_R0_R0_2 0x7800f082 /* rldicl %r0,%r0,62,2 */
5d1634d7
AM		 212
213/* Pad with this. */
214#define NOP 0x60000000
215
721956f4
AM		 216/* Some other nops. */
217#define CROR_151515 0x4def7b82
218#define CROR_313131 0x4ffffb82
219
cedb70c5 220/* .glink entries for the first 32k functions are two instructions. */
5d1634d7
AM		 221#define LI_R0_0 0x38000000 /* li %r0,0 */
222#define B_DOT 0x48000000 /* b . */
223
224/* After that, we need two instructions to load the index, followed by
225 a branch. */
226#define LIS_R0_0 0x3c000000 /* lis %r0,0 */
10ed1bba 227#define ORI_R0_R0_0 0x60000000 /* ori %r0,%r0,0 */
41bd81ab 228
deb0e272
AM		 229/* Instructions used by the save and restore reg functions. */
230#define STD_R0_0R1 0xf8010000 /* std %r0,0(%r1) */
231#define STD_R0_0R12 0xf80c0000 /* std %r0,0(%r12) */
232#define LD_R0_0R1 0xe8010000 /* ld %r0,0(%r1) */
233#define LD_R0_0R12 0xe80c0000 /* ld %r0,0(%r12) */
82bd7b59
AM		 234#define STFD_FR0_0R1 0xd8010000 /* stfd %fr0,0(%r1) */
235#define LFD_FR0_0R1 0xc8010000 /* lfd %fr0,0(%r1) */
deb0e272
AM		 236#define LI_R12_0 0x39800000 /* li %r12,0 */
237#define STVX_VR0_R12_R0 0x7c0c01ce /* stvx %v0,%r12,%r0 */
238#define LVX_VR0_R12_R0 0x7c0c00ce /* lvx %v0,%r12,%r0 */
239#define MTLR_R0 0x7c0803a6 /* mtlr %r0 */
82bd7b59
AM		 240#define BLR 0x4e800020 /* blr */
241
41bd81ab
AM		 242/* Since .opd is an array of descriptors and each entry will end up
243 with identical R_PPC64_RELATIVE relocs, there is really no need to
244 propagate .opd relocs; The dynamic linker should be taught to
1e2f5b6e 245 relocate .opd without reloc entries. */
41bd81ab
AM		 246#ifndef NO_OPD_RELOCS
247#define NO_OPD_RELOCS 0
248#endif
810d4e75 249
a4b6fadd
AM		 250#ifndef ARRAY_SIZE
251#define ARRAY_SIZE(a) (sizeof (a) / sizeof ((a)[0]))
252#endif
253
810d4e75
AM		 254static inline int
255abiversion (bfd *abfd)
256{
257 return elf_elfheader (abfd)->e_flags & EF_PPC64_ABI;
258}
259
260static inline void
261set_abiversion (bfd *abfd, int ver)
262{
263 elf_elfheader (abfd)->e_flags &= ~EF_PPC64_ABI;
264 elf_elfheader (abfd)->e_flags |= ver & EF_PPC64_ABI;
265}
5bd4f169 266\f
f5e87a1d 267#define ONES(n) (((bfd_vma) 1 << ((n) - 1) << 1) - 1)
b34976b6 268
5bd4f169 269/* Relocation HOWTO's. */
04c9666a 270static reloc_howto_type *ppc64_elf_howto_table[(int) R_PPC64_max];
5bd4f169
AM		 271
272static reloc_howto_type ppc64_elf_howto_raw[] = {
273 /* This reloc does nothing. */
274 HOWTO (R_PPC64_NONE, /* type */
275 0, /* rightshift */
6346d5ca
AM		 276 3, /* size (0 = byte, 1 = short, 2 = long) */
277 0, /* bitsize */
b34976b6 278 FALSE, /* pc_relative */
5bd4f169 279 0, /* bitpos */
f5e87a1d 280 complain_overflow_dont, /* complain_on_overflow */
5bd4f169
AM		 281 bfd_elf_generic_reloc, /* special_function */
282 "R_PPC64_NONE", /* name */
b34976b6 283 FALSE, /* partial_inplace */
d006db6c 284 0, /* src_mask */
5bd4f169 285 0, /* dst_mask */
b34976b6 286 FALSE), /* pcrel_offset */
5bd4f169
AM		 287
288 /* A standard 32 bit relocation. */
289 HOWTO (R_PPC64_ADDR32, /* type */
290 0, /* rightshift */
291 2, /* size (0 = byte, 1 = short, 2 = long) */
292 32, /* bitsize */
b34976b6 293 FALSE, /* pc_relative */
5bd4f169
AM		 294 0, /* bitpos */
295 complain_overflow_bitfield, /* complain_on_overflow */
296 bfd_elf_generic_reloc, /* special_function */
297 "R_PPC64_ADDR32", /* name */
b34976b6 298 FALSE, /* partial_inplace */
5bd4f169
AM		 299 0, /* src_mask */
300 0xffffffff, /* dst_mask */
b34976b6 301 FALSE), /* pcrel_offset */
5bd4f169
AM		 302
303 /* An absolute 26 bit branch; the lower two bits must be zero.
304 FIXME: we don't check that, we just clear them. */
305 HOWTO (R_PPC64_ADDR24, /* type */
306 0, /* rightshift */
307 2, /* size (0 = byte, 1 = short, 2 = long) */
308 26, /* bitsize */
b34976b6 309 FALSE, /* pc_relative */
5bd4f169
AM		 310 0, /* bitpos */
311 complain_overflow_bitfield, /* complain_on_overflow */
312 bfd_elf_generic_reloc, /* special_function */
313 "R_PPC64_ADDR24", /* name */
b34976b6 314 FALSE, /* partial_inplace */
d006db6c 315 0, /* src_mask */
f5e87a1d 316 0x03fffffc, /* dst_mask */
b34976b6 317 FALSE), /* pcrel_offset */
5bd4f169
AM		 318
319 /* A standard 16 bit relocation. */
320 HOWTO (R_PPC64_ADDR16, /* type */
321 0, /* rightshift */
322 1, /* size (0 = byte, 1 = short, 2 = long) */
323 16, /* bitsize */
b34976b6 324 FALSE, /* pc_relative */
5bd4f169
AM		 325 0, /* bitpos */
326 complain_overflow_bitfield, /* complain_on_overflow */
327 bfd_elf_generic_reloc, /* special_function */
328 "R_PPC64_ADDR16", /* name */
b34976b6 329 FALSE, /* partial_inplace */
5bd4f169
AM		 330 0, /* src_mask */
331 0xffff, /* dst_mask */
b34976b6 332 FALSE), /* pcrel_offset */
5bd4f169
AM		 333
334 /* A 16 bit relocation without overflow. */
335 HOWTO (R_PPC64_ADDR16_LO, /* type */
336 0, /* rightshift */
337 1, /* size (0 = byte, 1 = short, 2 = long) */
338 16, /* bitsize */
b34976b6 339 FALSE, /* pc_relative */
5bd4f169
AM		 340 0, /* bitpos */
341 complain_overflow_dont,/* complain_on_overflow */
342 bfd_elf_generic_reloc, /* special_function */
343 "R_PPC64_ADDR16_LO", /* name */
b34976b6 344 FALSE, /* partial_inplace */
5bd4f169
AM		 345 0, /* src_mask */
346 0xffff, /* dst_mask */
b34976b6 347 FALSE), /* pcrel_offset */
5bd4f169
AM		 348
349 /* Bits 16-31 of an address. */
350 HOWTO (R_PPC64_ADDR16_HI, /* type */
351 16, /* rightshift */
352 1, /* size (0 = byte, 1 = short, 2 = long) */
353 16, /* bitsize */
b34976b6 354 FALSE, /* pc_relative */
5bd4f169 355 0, /* bitpos */
f9c6b907 356 complain_overflow_signed, /* complain_on_overflow */
5bd4f169
AM		 357 bfd_elf_generic_reloc, /* special_function */
358 "R_PPC64_ADDR16_HI", /* name */
b34976b6 359 FALSE, /* partial_inplace */
5bd4f169
AM		 360 0, /* src_mask */
361 0xffff, /* dst_mask */
b34976b6 362 FALSE), /* pcrel_offset */
5bd4f169
AM		 363
364 /* Bits 16-31 of an address, plus 1 if the contents of the low 16
365 bits, treated as a signed number, is negative. */
366 HOWTO (R_PPC64_ADDR16_HA, /* type */
367 16, /* rightshift */
368 1, /* size (0 = byte, 1 = short, 2 = long) */
369 16, /* bitsize */
b34976b6 370 FALSE, /* pc_relative */
5bd4f169 371 0, /* bitpos */
f9c6b907 372 complain_overflow_signed, /* complain_on_overflow */
805fc799 373 ppc64_elf_ha_reloc, /* special_function */
5bd4f169 374 "R_PPC64_ADDR16_HA", /* name */
b34976b6 375 FALSE, /* partial_inplace */
5bd4f169
AM		 376 0, /* src_mask */
377 0xffff, /* dst_mask */
b34976b6 378 FALSE), /* pcrel_offset */
5bd4f169
AM		 379
380 /* An absolute 16 bit branch; the lower two bits must be zero.
381 FIXME: we don't check that, we just clear them. */
382 HOWTO (R_PPC64_ADDR14, /* type */
383 0, /* rightshift */
384 2, /* size (0 = byte, 1 = short, 2 = long) */
385 16, /* bitsize */
b34976b6 386 FALSE, /* pc_relative */
5bd4f169 387 0, /* bitpos */
b80eed39 388 complain_overflow_signed, /* complain_on_overflow */
2441e016 389 ppc64_elf_branch_reloc, /* special_function */
5bd4f169 390 "R_PPC64_ADDR14", /* name */
b34976b6 391 FALSE, /* partial_inplace */
d006db6c 392 0, /* src_mask */
f5e87a1d 393 0x0000fffc, /* dst_mask */
b34976b6 394 FALSE), /* pcrel_offset */
5bd4f169
AM		 395
396 /* An absolute 16 bit branch, for which bit 10 should be set to
397 indicate that the branch is expected to be taken. The lower two
398 bits must be zero. */
399 HOWTO (R_PPC64_ADDR14_BRTAKEN, /* type */
400 0, /* rightshift */
401 2, /* size (0 = byte, 1 = short, 2 = long) */
402 16, /* bitsize */
b34976b6 403 FALSE, /* pc_relative */
5bd4f169 404 0, /* bitpos */
b80eed39 405 complain_overflow_signed, /* complain_on_overflow */
805fc799 406 ppc64_elf_brtaken_reloc, /* special_function */
5bd4f169 407 "R_PPC64_ADDR14_BRTAKEN",/* name */
b34976b6 408 FALSE, /* partial_inplace */
d006db6c 409 0, /* src_mask */
f5e87a1d 410 0x0000fffc, /* dst_mask */
b34976b6 411 FALSE), /* pcrel_offset */
5bd4f169
AM		 412
413 /* An absolute 16 bit branch, for which bit 10 should be set to
414 indicate that the branch is not expected to be taken. The lower
415 two bits must be zero. */
416 HOWTO (R_PPC64_ADDR14_BRNTAKEN, /* type */
417 0, /* rightshift */
418 2, /* size (0 = byte, 1 = short, 2 = long) */
419 16, /* bitsize */
b34976b6 420 FALSE, /* pc_relative */
5bd4f169 421 0, /* bitpos */
b80eed39 422 complain_overflow_signed, /* complain_on_overflow */
805fc799 423 ppc64_elf_brtaken_reloc, /* special_function */
5bd4f169 424 "R_PPC64_ADDR14_BRNTAKEN",/* name */
b34976b6 425 FALSE, /* partial_inplace */
d006db6c 426 0, /* src_mask */
f5e87a1d 427 0x0000fffc, /* dst_mask */
b34976b6 428 FALSE), /* pcrel_offset */
5bd4f169
AM		 429
430 /* A relative 26 bit branch; the lower two bits must be zero. */
431 HOWTO (R_PPC64_REL24, /* type */
432 0, /* rightshift */
433 2, /* size (0 = byte, 1 = short, 2 = long) */
434 26, /* bitsize */
b34976b6 435 TRUE, /* pc_relative */
5bd4f169
AM		 436 0, /* bitpos */
437 complain_overflow_signed, /* complain_on_overflow */
2441e016 438 ppc64_elf_branch_reloc, /* special_function */
5bd4f169 439 "R_PPC64_REL24", /* name */
b34976b6 440 FALSE, /* partial_inplace */
d006db6c 441 0, /* src_mask */
f5e87a1d 442 0x03fffffc, /* dst_mask */
b34976b6 443 TRUE), /* pcrel_offset */
5bd4f169
AM		 444
445 /* A relative 16 bit branch; the lower two bits must be zero. */
446 HOWTO (R_PPC64_REL14, /* type */
447 0, /* rightshift */
448 2, /* size (0 = byte, 1 = short, 2 = long) */
449 16, /* bitsize */
b34976b6 450 TRUE, /* pc_relative */
5bd4f169
AM		 451 0, /* bitpos */
452 complain_overflow_signed, /* complain_on_overflow */
2441e016 453 ppc64_elf_branch_reloc, /* special_function */
5bd4f169 454 "R_PPC64_REL14", /* name */
b34976b6 455 FALSE, /* partial_inplace */
d006db6c 456 0, /* src_mask */
f5e87a1d 457 0x0000fffc, /* dst_mask */
b34976b6 458 TRUE), /* pcrel_offset */
5bd4f169
AM		 459
460 /* A relative 16 bit branch. Bit 10 should be set to indicate that
461 the branch is expected to be taken. The lower two bits must be
462 zero. */
463 HOWTO (R_PPC64_REL14_BRTAKEN, /* type */
464 0, /* rightshift */
465 2, /* size (0 = byte, 1 = short, 2 = long) */
466 16, /* bitsize */
b34976b6 467 TRUE, /* pc_relative */
5bd4f169
AM		 468 0, /* bitpos */
469 complain_overflow_signed, /* complain_on_overflow */
805fc799 470 ppc64_elf_brtaken_reloc, /* special_function */
5bd4f169 471 "R_PPC64_REL14_BRTAKEN", /* name */
b34976b6 472 FALSE, /* partial_inplace */
d006db6c 473 0, /* src_mask */
f5e87a1d 474 0x0000fffc, /* dst_mask */
b34976b6 475 TRUE), /* pcrel_offset */
5bd4f169
AM		 476
477 /* A relative 16 bit branch. Bit 10 should be set to indicate that
478 the branch is not expected to be taken. The lower two bits must
479 be zero. */
480 HOWTO (R_PPC64_REL14_BRNTAKEN, /* type */
481 0, /* rightshift */
482 2, /* size (0 = byte, 1 = short, 2 = long) */
483 16, /* bitsize */
b34976b6 484 TRUE, /* pc_relative */
5bd4f169
AM		 485 0, /* bitpos */
486 complain_overflow_signed, /* complain_on_overflow */
805fc799 487 ppc64_elf_brtaken_reloc, /* special_function */
5bd4f169 488 "R_PPC64_REL14_BRNTAKEN",/* name */
b34976b6 489 FALSE, /* partial_inplace */
d006db6c 490 0, /* src_mask */
f5e87a1d 491 0x0000fffc, /* dst_mask */
b34976b6 492 TRUE), /* pcrel_offset */
5bd4f169
AM		 493
494 /* Like R_PPC64_ADDR16, but referring to the GOT table entry for the
495 symbol. */
496 HOWTO (R_PPC64_GOT16, /* type */
497 0, /* rightshift */
498 1, /* size (0 = byte, 1 = short, 2 = long) */
499 16, /* bitsize */
b34976b6 500 FALSE, /* pc_relative */
5bd4f169
AM		 501 0, /* bitpos */
502 complain_overflow_signed, /* complain_on_overflow */
805fc799 503 ppc64_elf_unhandled_reloc, /* special_function */
5bd4f169 504 "R_PPC64_GOT16", /* name */
b34976b6 505 FALSE, /* partial_inplace */
5bd4f169
AM		 506 0, /* src_mask */
507 0xffff, /* dst_mask */
b34976b6 508 FALSE), /* pcrel_offset */
5bd4f169
AM		 509
510 /* Like R_PPC64_ADDR16_LO, but referring to the GOT table entry for
511 the symbol. */
512 HOWTO (R_PPC64_GOT16_LO, /* type */
513 0, /* rightshift */
514 1, /* size (0 = byte, 1 = short, 2 = long) */
515 16, /* bitsize */
b34976b6 516 FALSE, /* pc_relative */
5bd4f169
AM		 517 0, /* bitpos */
518 complain_overflow_dont, /* complain_on_overflow */
805fc799 519 ppc64_elf_unhandled_reloc, /* special_function */
5bd4f169 520 "R_PPC64_GOT16_LO", /* name */
b34976b6 521 FALSE, /* partial_inplace */
5bd4f169
AM		 522 0, /* src_mask */
523 0xffff, /* dst_mask */
b34976b6 524 FALSE), /* pcrel_offset */
5bd4f169
AM		 525
526 /* Like R_PPC64_ADDR16_HI, but referring to the GOT table entry for
527 the symbol. */
528 HOWTO (R_PPC64_GOT16_HI, /* type */
529 16, /* rightshift */
530 1, /* size (0 = byte, 1 = short, 2 = long) */
531 16, /* bitsize */
b34976b6 532 FALSE, /* pc_relative */
5bd4f169 533 0, /* bitpos */
f9c6b907 534 complain_overflow_signed,/* complain_on_overflow */
805fc799 535 ppc64_elf_unhandled_reloc, /* special_function */
5bd4f169 536 "R_PPC64_GOT16_HI", /* name */
b34976b6 537 FALSE, /* partial_inplace */
5bd4f169
AM		 538 0, /* src_mask */
539 0xffff, /* dst_mask */
b34976b6 540 FALSE), /* pcrel_offset */
5bd4f169
AM		 541
542 /* Like R_PPC64_ADDR16_HA, but referring to the GOT table entry for
543 the symbol. */
544 HOWTO (R_PPC64_GOT16_HA, /* type */
545 16, /* rightshift */
546 1, /* size (0 = byte, 1 = short, 2 = long) */
547 16, /* bitsize */
b34976b6 548 FALSE, /* pc_relative */
5bd4f169 549 0, /* bitpos */
f9c6b907 550 complain_overflow_signed,/* complain_on_overflow */
805fc799 551 ppc64_elf_unhandled_reloc, /* special_function */
5bd4f169 552 "R_PPC64_GOT16_HA", /* name */
b34976b6 553 FALSE, /* partial_inplace */
5bd4f169
AM		 554 0, /* src_mask */
555 0xffff, /* dst_mask */
b34976b6 556 FALSE), /* pcrel_offset */
5bd4f169
AM		 557
558 /* This is used only by the dynamic linker. The symbol should exist
559 both in the object being run and in some shared library. The
560 dynamic linker copies the data addressed by the symbol from the
561 shared library into the object, because the object being
562 run has to have the data at some particular address. */
563 HOWTO (R_PPC64_COPY, /* type */
564 0, /* rightshift */
f5e87a1d
AM		 565 0, /* this one is variable size */
566 0, /* bitsize */
b34976b6 567 FALSE, /* pc_relative */
5bd4f169 568 0, /* bitpos */
f5e87a1d
AM		 569 complain_overflow_dont, /* complain_on_overflow */
570 ppc64_elf_unhandled_reloc, /* special_function */
5bd4f169 571 "R_PPC64_COPY", /* name */
b34976b6 572 FALSE, /* partial_inplace */
5bd4f169
AM		 573 0, /* src_mask */
574 0, /* dst_mask */
b34976b6 575 FALSE), /* pcrel_offset */
5bd4f169
AM		 576
577 /* Like R_PPC64_ADDR64, but used when setting global offset table
578 entries. */
579 HOWTO (R_PPC64_GLOB_DAT, /* type */
580 0, /* rightshift */
581 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
582 64, /* bitsize */
b34976b6 583 FALSE, /* pc_relative */
5bd4f169
AM		 584 0, /* bitpos */
585 complain_overflow_dont, /* complain_on_overflow */
805fc799 586 ppc64_elf_unhandled_reloc, /* special_function */
5bd4f169 587 "R_PPC64_GLOB_DAT", /* name */
b34976b6 588 FALSE, /* partial_inplace */
5bd4f169 589 0, /* src_mask */
f5e87a1d 590 ONES (64), /* dst_mask */
b34976b6 591 FALSE), /* pcrel_offset */
5bd4f169
AM		 592
593 /* Created by the link editor. Marks a procedure linkage table
594 entry for a symbol. */
595 HOWTO (R_PPC64_JMP_SLOT, /* type */
596 0, /* rightshift */
597 0, /* size (0 = byte, 1 = short, 2 = long) */
598 0, /* bitsize */
b34976b6 599 FALSE, /* pc_relative */
5bd4f169
AM		 600 0, /* bitpos */
601 complain_overflow_dont, /* complain_on_overflow */
805fc799 602 ppc64_elf_unhandled_reloc, /* special_function */
5bd4f169 603 "R_PPC64_JMP_SLOT", /* name */
b34976b6 604 FALSE, /* partial_inplace */
5bd4f169
AM		 605 0, /* src_mask */
606 0, /* dst_mask */
b34976b6 607 FALSE), /* pcrel_offset */
5bd4f169
AM		 608
609 /* Used only by the dynamic linker. When the object is run, this
610 doubleword64 is set to the load address of the object, plus the
611 addend. */
612 HOWTO (R_PPC64_RELATIVE, /* type */
613 0, /* rightshift */
614 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
615 64, /* bitsize */
b34976b6 616 FALSE, /* pc_relative */
5bd4f169
AM		 617 0, /* bitpos */
618 complain_overflow_dont, /* complain_on_overflow */
619 bfd_elf_generic_reloc, /* special_function */
620 "R_PPC64_RELATIVE", /* name */
b34976b6 621 FALSE, /* partial_inplace */
5bd4f169 622 0, /* src_mask */
f5e87a1d 623 ONES (64), /* dst_mask */
b34976b6 624 FALSE), /* pcrel_offset */
5bd4f169
AM		 625
626 /* Like R_PPC64_ADDR32, but may be unaligned. */
627 HOWTO (R_PPC64_UADDR32, /* type */
628 0, /* rightshift */
629 2, /* size (0 = byte, 1 = short, 2 = long) */
630 32, /* bitsize */
b34976b6 631 FALSE, /* pc_relative */
5bd4f169
AM		 632 0, /* bitpos */
633 complain_overflow_bitfield, /* complain_on_overflow */
634 bfd_elf_generic_reloc, /* special_function */
635 "R_PPC64_UADDR32", /* name */
b34976b6 636 FALSE, /* partial_inplace */
5bd4f169
AM		 637 0, /* src_mask */
638 0xffffffff, /* dst_mask */
b34976b6 639 FALSE), /* pcrel_offset */
5bd4f169
AM		 640
641 /* Like R_PPC64_ADDR16, but may be unaligned. */
642 HOWTO (R_PPC64_UADDR16, /* type */
643 0, /* rightshift */
644 1, /* size (0 = byte, 1 = short, 2 = long) */
645 16, /* bitsize */
b34976b6 646 FALSE, /* pc_relative */
5bd4f169
AM		 647 0, /* bitpos */
648 complain_overflow_bitfield, /* complain_on_overflow */
649 bfd_elf_generic_reloc, /* special_function */
650 "R_PPC64_UADDR16", /* name */
b34976b6 651 FALSE, /* partial_inplace */
5bd4f169
AM		 652 0, /* src_mask */
653 0xffff, /* dst_mask */
b34976b6 654 FALSE), /* pcrel_offset */
5bd4f169
AM		 655
656 /* 32-bit PC relative. */
657 HOWTO (R_PPC64_REL32, /* type */
658 0, /* rightshift */
659 2, /* size (0 = byte, 1 = short, 2 = long) */
660 32, /* bitsize */
b34976b6 661 TRUE, /* pc_relative */
5bd4f169 662 0, /* bitpos */
5bd4f169
AM		 663 complain_overflow_signed, /* complain_on_overflow */
664 bfd_elf_generic_reloc, /* special_function */
665 "R_PPC64_REL32", /* name */
b34976b6 666 FALSE, /* partial_inplace */
5bd4f169
AM		 667 0, /* src_mask */
668 0xffffffff, /* dst_mask */
b34976b6 669 TRUE), /* pcrel_offset */
5bd4f169 670
10ed1bba 671 /* 32-bit relocation to the symbol's procedure linkage table. */
5bd4f169
AM		 672 HOWTO (R_PPC64_PLT32, /* type */
673 0, /* rightshift */
674 2, /* size (0 = byte, 1 = short, 2 = long) */
675 32, /* bitsize */
b34976b6 676 FALSE, /* pc_relative */
5bd4f169
AM		 677 0, /* bitpos */
678 complain_overflow_bitfield, /* complain_on_overflow */
805fc799 679 ppc64_elf_unhandled_reloc, /* special_function */
5bd4f169 680 "R_PPC64_PLT32", /* name */
b34976b6 681 FALSE, /* partial_inplace */
5bd4f169 682 0, /* src_mask */
f5e87a1d 683 0xffffffff, /* dst_mask */
b34976b6 684 FALSE), /* pcrel_offset */
5bd4f169
AM		 685
686 /* 32-bit PC relative relocation to the symbol's procedure linkage table.
687 FIXME: R_PPC64_PLTREL32 not supported. */
688 HOWTO (R_PPC64_PLTREL32, /* type */
689 0, /* rightshift */
690 2, /* size (0 = byte, 1 = short, 2 = long) */
691 32, /* bitsize */
b34976b6 692 TRUE, /* pc_relative */
5bd4f169
AM		 693 0, /* bitpos */
694 complain_overflow_signed, /* complain_on_overflow */
3ce51288 695 ppc64_elf_unhandled_reloc, /* special_function */
5bd4f169 696 "R_PPC64_PLTREL32", /* name */
b34976b6 697 FALSE, /* partial_inplace */
5bd4f169 698 0, /* src_mask */
f5e87a1d 699 0xffffffff, /* dst_mask */
b34976b6 700 TRUE), /* pcrel_offset */
5bd4f169
AM		 701
702 /* Like R_PPC64_ADDR16_LO, but referring to the PLT table entry for
703 the symbol. */
704 HOWTO (R_PPC64_PLT16_LO, /* type */
705 0, /* rightshift */
706 1, /* size (0 = byte, 1 = short, 2 = long) */
707 16, /* bitsize */
b34976b6 708 FALSE, /* pc_relative */
5bd4f169
AM		 709 0, /* bitpos */
710 complain_overflow_dont, /* complain_on_overflow */
805fc799 711 ppc64_elf_unhandled_reloc, /* special_function */
5bd4f169 712 "R_PPC64_PLT16_LO", /* name */
b34976b6 713 FALSE, /* partial_inplace */
5bd4f169
AM		 714 0, /* src_mask */
715 0xffff, /* dst_mask */
b34976b6 716 FALSE), /* pcrel_offset */
5bd4f169
AM		 717
718 /* Like R_PPC64_ADDR16_HI, but referring to the PLT table entry for
719 the symbol. */
720 HOWTO (R_PPC64_PLT16_HI, /* type */
721 16, /* rightshift */
722 1, /* size (0 = byte, 1 = short, 2 = long) */
723 16, /* bitsize */
b34976b6 724 FALSE, /* pc_relative */
5bd4f169 725 0, /* bitpos */
f9c6b907 726 complain_overflow_signed, /* complain_on_overflow */
805fc799 727 ppc64_elf_unhandled_reloc, /* special_function */
5bd4f169 728 "R_PPC64_PLT16_HI", /* name */
b34976b6 729 FALSE, /* partial_inplace */
5bd4f169
AM		 730 0, /* src_mask */
731 0xffff, /* dst_mask */
b34976b6 732 FALSE), /* pcrel_offset */
5bd4f169
AM		 733
734 /* Like R_PPC64_ADDR16_HA, but referring to the PLT table entry for
735 the symbol. */
736 HOWTO (R_PPC64_PLT16_HA, /* type */
737 16, /* rightshift */
738 1, /* size (0 = byte, 1 = short, 2 = long) */
739 16, /* bitsize */
b34976b6 740 FALSE, /* pc_relative */
5bd4f169 741 0, /* bitpos */
f9c6b907 742 complain_overflow_signed, /* complain_on_overflow */
805fc799 743 ppc64_elf_unhandled_reloc, /* special_function */
5bd4f169 744 "R_PPC64_PLT16_HA", /* name */
b34976b6 745 FALSE, /* partial_inplace */
5bd4f169
AM		 746 0, /* src_mask */
747 0xffff, /* dst_mask */
b34976b6 748 FALSE), /* pcrel_offset */
5bd4f169 749
c061c2d8 750 /* 16-bit section relative relocation. */
5bd4f169
AM		 751 HOWTO (R_PPC64_SECTOFF, /* type */
752 0, /* rightshift */
c061c2d8
AM		 753 1, /* size (0 = byte, 1 = short, 2 = long) */
754 16, /* bitsize */
b34976b6 755 FALSE, /* pc_relative */
5bd4f169 756 0, /* bitpos */
b80eed39 757 complain_overflow_signed, /* complain_on_overflow */
805fc799 758 ppc64_elf_sectoff_reloc, /* special_function */
5bd4f169 759 "R_PPC64_SECTOFF", /* name */
b34976b6 760 FALSE, /* partial_inplace */
5bd4f169 761 0, /* src_mask */
c061c2d8 762 0xffff, /* dst_mask */
b34976b6 763 FALSE), /* pcrel_offset */
5bd4f169 764
c061c2d8 765 /* Like R_PPC64_SECTOFF, but no overflow warning. */
5bd4f169
AM		 766 HOWTO (R_PPC64_SECTOFF_LO, /* type */
767 0, /* rightshift */
768 1, /* size (0 = byte, 1 = short, 2 = long) */
769 16, /* bitsize */
b34976b6 770 FALSE, /* pc_relative */
5bd4f169
AM		 771 0, /* bitpos */
772 complain_overflow_dont, /* complain_on_overflow */
805fc799 773 ppc64_elf_sectoff_reloc, /* special_function */
5bd4f169 774 "R_PPC64_SECTOFF_LO", /* name */
b34976b6 775 FALSE, /* partial_inplace */
5bd4f169
AM		 776 0, /* src_mask */
777 0xffff, /* dst_mask */
b34976b6 778 FALSE), /* pcrel_offset */
5bd4f169
AM		 779
780 /* 16-bit upper half section relative relocation. */
781 HOWTO (R_PPC64_SECTOFF_HI, /* type */
782 16, /* rightshift */
783 1, /* size (0 = byte, 1 = short, 2 = long) */
784 16, /* bitsize */
b34976b6 785 FALSE, /* pc_relative */
5bd4f169 786 0, /* bitpos */
f9c6b907 787 complain_overflow_signed, /* complain_on_overflow */
805fc799 788 ppc64_elf_sectoff_reloc, /* special_function */
5bd4f169 789 "R_PPC64_SECTOFF_HI", /* name */
b34976b6 790 FALSE, /* partial_inplace */
5bd4f169
AM		 791 0, /* src_mask */
792 0xffff, /* dst_mask */
b34976b6 793 FALSE), /* pcrel_offset */
5bd4f169
AM		 794
795 /* 16-bit upper half adjusted section relative relocation. */
796 HOWTO (R_PPC64_SECTOFF_HA, /* type */
797 16, /* rightshift */
798 1, /* size (0 = byte, 1 = short, 2 = long) */
799 16, /* bitsize */
b34976b6 800 FALSE, /* pc_relative */
5bd4f169 801 0, /* bitpos */
f9c6b907 802 complain_overflow_signed, /* complain_on_overflow */
805fc799 803 ppc64_elf_sectoff_ha_reloc, /* special_function */
5bd4f169 804 "R_PPC64_SECTOFF_HA", /* name */
b34976b6 805 FALSE, /* partial_inplace */
5bd4f169
AM		 806 0, /* src_mask */
807 0xffff, /* dst_mask */
b34976b6 808 FALSE), /* pcrel_offset */
5bd4f169 809
04c9666a
AM		 810 /* Like R_PPC64_REL24 without touching the two least significant bits. */
811 HOWTO (R_PPC64_REL30, /* type */
5bd4f169
AM		 812 2, /* rightshift */
813 2, /* size (0 = byte, 1 = short, 2 = long) */
814 30, /* bitsize */
b34976b6 815 TRUE, /* pc_relative */
5bd4f169
AM		 816 0, /* bitpos */
817 complain_overflow_dont, /* complain_on_overflow */
818 bfd_elf_generic_reloc, /* special_function */
04c9666a 819 "R_PPC64_REL30", /* name */
b34976b6 820 FALSE, /* partial_inplace */
d006db6c 821 0, /* src_mask */
5bd4f169 822 0xfffffffc, /* dst_mask */
b34976b6 823 TRUE), /* pcrel_offset */
5bd4f169
AM		 824
825 /* Relocs in the 64-bit PowerPC ELF ABI, not in the 32-bit ABI. */
826
827 /* A standard 64-bit relocation. */
828 HOWTO (R_PPC64_ADDR64, /* type */
829 0, /* rightshift */
830 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
831 64, /* bitsize */
b34976b6 832 FALSE, /* pc_relative */
5bd4f169
AM		 833 0, /* bitpos */
834 complain_overflow_dont, /* complain_on_overflow */
835 bfd_elf_generic_reloc, /* special_function */
836 "R_PPC64_ADDR64", /* name */
b34976b6 837 FALSE, /* partial_inplace */
5bd4f169 838 0, /* src_mask */
f5e87a1d 839 ONES (64), /* dst_mask */
b34976b6 840 FALSE), /* pcrel_offset */
5bd4f169
AM		 841
842 /* The bits 32-47 of an address. */
843 HOWTO (R_PPC64_ADDR16_HIGHER, /* type */
844 32, /* rightshift */
845 1, /* size (0 = byte, 1 = short, 2 = long) */
846 16, /* bitsize */
b34976b6 847 FALSE, /* pc_relative */
5bd4f169
AM		 848 0, /* bitpos */
849 complain_overflow_dont, /* complain_on_overflow */
850 bfd_elf_generic_reloc, /* special_function */
851 "R_PPC64_ADDR16_HIGHER", /* name */
b34976b6 852 FALSE, /* partial_inplace */
5bd4f169
AM		 853 0, /* src_mask */
854 0xffff, /* dst_mask */
b34976b6 855 FALSE), /* pcrel_offset */
5bd4f169
AM		 856
857 /* The bits 32-47 of an address, plus 1 if the contents of the low
858 16 bits, treated as a signed number, is negative. */
859 HOWTO (R_PPC64_ADDR16_HIGHERA, /* type */
860 32, /* rightshift */
861 1, /* size (0 = byte, 1 = short, 2 = long) */
862 16, /* bitsize */
b34976b6 863 FALSE, /* pc_relative */
5bd4f169
AM		 864 0, /* bitpos */
865 complain_overflow_dont, /* complain_on_overflow */
805fc799 866 ppc64_elf_ha_reloc, /* special_function */
5bd4f169 867 "R_PPC64_ADDR16_HIGHERA", /* name */
b34976b6 868 FALSE, /* partial_inplace */
5bd4f169
AM		 869 0, /* src_mask */
870 0xffff, /* dst_mask */
b34976b6 871 FALSE), /* pcrel_offset */
5bd4f169
AM		 872
873 /* The bits 48-63 of an address. */
874 HOWTO (R_PPC64_ADDR16_HIGHEST,/* type */
875 48, /* rightshift */
876 1, /* size (0 = byte, 1 = short, 2 = long) */
877 16, /* bitsize */
b34976b6 878 FALSE, /* pc_relative */
5bd4f169
AM		 879 0, /* bitpos */
880 complain_overflow_dont, /* complain_on_overflow */
881 bfd_elf_generic_reloc, /* special_function */
882 "R_PPC64_ADDR16_HIGHEST", /* name */
b34976b6 883 FALSE, /* partial_inplace */
5bd4f169
AM		 884 0, /* src_mask */
885 0xffff, /* dst_mask */
b34976b6 886 FALSE), /* pcrel_offset */
5bd4f169
AM		 887
888 /* The bits 48-63 of an address, plus 1 if the contents of the low
889 16 bits, treated as a signed number, is negative. */
890 HOWTO (R_PPC64_ADDR16_HIGHESTA,/* type */
891 48, /* rightshift */
892 1, /* size (0 = byte, 1 = short, 2 = long) */
893 16, /* bitsize */
b34976b6 894 FALSE, /* pc_relative */
5bd4f169
AM		 895 0, /* bitpos */
896 complain_overflow_dont, /* complain_on_overflow */
805fc799 897 ppc64_elf_ha_reloc, /* special_function */
5bd4f169 898 "R_PPC64_ADDR16_HIGHESTA", /* name */
b34976b6 899 FALSE, /* partial_inplace */
5bd4f169
AM		 900 0, /* src_mask */
901 0xffff, /* dst_mask */
b34976b6 902 FALSE), /* pcrel_offset */
5bd4f169
AM		 903
904 /* Like ADDR64, but may be unaligned. */
905 HOWTO (R_PPC64_UADDR64, /* type */
906 0, /* rightshift */
907 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
908 64, /* bitsize */
b34976b6 909 FALSE, /* pc_relative */
5bd4f169
AM		 910 0, /* bitpos */
911 complain_overflow_dont, /* complain_on_overflow */
912 bfd_elf_generic_reloc, /* special_function */
913 "R_PPC64_UADDR64", /* name */
b34976b6 914 FALSE, /* partial_inplace */
5bd4f169 915 0, /* src_mask */
f5e87a1d 916 ONES (64), /* dst_mask */
b34976b6 917 FALSE), /* pcrel_offset */
5bd4f169
AM		 918
919 /* 64-bit relative relocation. */
920 HOWTO (R_PPC64_REL64, /* type */
921 0, /* rightshift */
922 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
923 64, /* bitsize */
b34976b6 924 TRUE, /* pc_relative */
5bd4f169
AM		 925 0, /* bitpos */
926 complain_overflow_dont, /* complain_on_overflow */
927 bfd_elf_generic_reloc, /* special_function */
928 "R_PPC64_REL64", /* name */
b34976b6 929 FALSE, /* partial_inplace */
5bd4f169 930 0, /* src_mask */
f5e87a1d 931 ONES (64), /* dst_mask */
b34976b6 932 TRUE), /* pcrel_offset */
5bd4f169 933
cedb70c5 934 /* 64-bit relocation to the symbol's procedure linkage table. */
5bd4f169
AM		 935 HOWTO (R_PPC64_PLT64, /* type */
936 0, /* rightshift */
937 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
938 64, /* bitsize */
b34976b6 939 FALSE, /* pc_relative */
5bd4f169
AM		 940 0, /* bitpos */
941 complain_overflow_dont, /* complain_on_overflow */
805fc799 942 ppc64_elf_unhandled_reloc, /* special_function */
5bd4f169 943 "R_PPC64_PLT64", /* name */
b34976b6 944 FALSE, /* partial_inplace */
5bd4f169 945 0, /* src_mask */
f5e87a1d 946 ONES (64), /* dst_mask */
b34976b6 947 FALSE), /* pcrel_offset */
5bd4f169
AM		 948
949 /* 64-bit PC relative relocation to the symbol's procedure linkage
950 table. */
951 /* FIXME: R_PPC64_PLTREL64 not supported. */
952 HOWTO (R_PPC64_PLTREL64, /* type */
953 0, /* rightshift */
954 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
955 64, /* bitsize */
b34976b6 956 TRUE, /* pc_relative */
5bd4f169
AM		 957 0, /* bitpos */
958 complain_overflow_dont, /* complain_on_overflow */
805fc799 959 ppc64_elf_unhandled_reloc, /* special_function */
5bd4f169 960 "R_PPC64_PLTREL64", /* name */
b34976b6 961 FALSE, /* partial_inplace */
5bd4f169 962 0, /* src_mask */
f5e87a1d 963 ONES (64), /* dst_mask */
b34976b6 964 TRUE), /* pcrel_offset */
5bd4f169
AM		 965
966 /* 16 bit TOC-relative relocation. */
967
968 /* R_PPC64_TOC16 47 half16* S + A - .TOC. */
969 HOWTO (R_PPC64_TOC16, /* type */
970 0, /* rightshift */
971 1, /* size (0 = byte, 1 = short, 2 = long) */
972 16, /* bitsize */
b34976b6 973 FALSE, /* pc_relative */
5bd4f169
AM		 974 0, /* bitpos */
975 complain_overflow_signed, /* complain_on_overflow */
805fc799 976 ppc64_elf_toc_reloc, /* special_function */
5bd4f169 977 "R_PPC64_TOC16", /* name */
b34976b6 978 FALSE, /* partial_inplace */
5bd4f169
AM		 979 0, /* src_mask */
980 0xffff, /* dst_mask */
b34976b6 981 FALSE), /* pcrel_offset */
5bd4f169
AM		 982
983 /* 16 bit TOC-relative relocation without overflow. */
984
985 /* R_PPC64_TOC16_LO 48 half16 #lo (S + A - .TOC.) */
986 HOWTO (R_PPC64_TOC16_LO, /* type */
987 0, /* rightshift */
988 1, /* size (0 = byte, 1 = short, 2 = long) */
989 16, /* bitsize */
b34976b6 990 FALSE, /* pc_relative */
5bd4f169
AM		 991 0, /* bitpos */
992 complain_overflow_dont, /* complain_on_overflow */
805fc799 993 ppc64_elf_toc_reloc, /* special_function */
5bd4f169 994 "R_PPC64_TOC16_LO", /* name */
b34976b6 995 FALSE, /* partial_inplace */
5bd4f169
AM		 996 0, /* src_mask */
997 0xffff, /* dst_mask */
b34976b6 998 FALSE), /* pcrel_offset */
5bd4f169
AM		 999
1000 /* 16 bit TOC-relative relocation, high 16 bits. */
1001
1002 /* R_PPC64_TOC16_HI 49 half16 #hi (S + A - .TOC.) */
1003 HOWTO (R_PPC64_TOC16_HI, /* type */
1004 16, /* rightshift */
1005 1, /* size (0 = byte, 1 = short, 2 = long) */
1006 16, /* bitsize */
b34976b6 1007 FALSE, /* pc_relative */
5bd4f169 1008 0, /* bitpos */
f9c6b907 1009 complain_overflow_signed, /* complain_on_overflow */
805fc799 1010 ppc64_elf_toc_reloc, /* special_function */
5bd4f169 1011 "R_PPC64_TOC16_HI", /* name */
b34976b6 1012 FALSE, /* partial_inplace */
5bd4f169
AM		 1013 0, /* src_mask */
1014 0xffff, /* dst_mask */
b34976b6 1015 FALSE), /* pcrel_offset */
5bd4f169
AM		 1016
1017 /* 16 bit TOC-relative relocation, high 16 bits, plus 1 if the
1018 contents of the low 16 bits, treated as a signed number, is
1019 negative. */
1020
1021 /* R_PPC64_TOC16_HA 50 half16 #ha (S + A - .TOC.) */
1022 HOWTO (R_PPC64_TOC16_HA, /* type */
1023 16, /* rightshift */
1024 1, /* size (0 = byte, 1 = short, 2 = long) */
1025 16, /* bitsize */
b34976b6 1026 FALSE, /* pc_relative */
5bd4f169 1027 0, /* bitpos */
f9c6b907 1028 complain_overflow_signed, /* complain_on_overflow */
805fc799 1029 ppc64_elf_toc_ha_reloc, /* special_function */
5bd4f169 1030 "R_PPC64_TOC16_HA", /* name */
b34976b6 1031 FALSE, /* partial_inplace */
5bd4f169
AM		 1032 0, /* src_mask */
1033 0xffff, /* dst_mask */
b34976b6 1034 FALSE), /* pcrel_offset */
5bd4f169
AM		 1035
1036 /* 64-bit relocation; insert value of TOC base (.TOC.). */
1037
1038 /* R_PPC64_TOC 51 doubleword64 .TOC. */
1039 HOWTO (R_PPC64_TOC, /* type */
1040 0, /* rightshift */
1041 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1042 64, /* bitsize */
b34976b6 1043 FALSE, /* pc_relative */
5bd4f169 1044 0, /* bitpos */
b80eed39 1045 complain_overflow_dont, /* complain_on_overflow */
805fc799 1046 ppc64_elf_toc64_reloc, /* special_function */
5bd4f169 1047 "R_PPC64_TOC", /* name */
b34976b6 1048 FALSE, /* partial_inplace */
5bd4f169 1049 0, /* src_mask */
f5e87a1d 1050 ONES (64), /* dst_mask */
b34976b6 1051 FALSE), /* pcrel_offset */
5bd4f169
AM		 1052
1053 /* Like R_PPC64_GOT16, but also informs the link editor that the
1054 value to relocate may (!) refer to a PLT entry which the link
1055 editor (a) may replace with the symbol value. If the link editor
1056 is unable to fully resolve the symbol, it may (b) create a PLT
1057 entry and store the address to the new PLT entry in the GOT.
1058 This permits lazy resolution of function symbols at run time.
1059 The link editor may also skip all of this and just (c) emit a
1060 R_PPC64_GLOB_DAT to tie the symbol to the GOT entry. */
1061 /* FIXME: R_PPC64_PLTGOT16 not implemented. */
1062 HOWTO (R_PPC64_PLTGOT16, /* type */
1063 0, /* rightshift */
1064 1, /* size (0 = byte, 1 = short, 2 = long) */
1065 16, /* bitsize */
b34976b6 1066 FALSE, /* pc_relative */
5bd4f169
AM		 1067 0, /* bitpos */
1068 complain_overflow_signed, /* complain_on_overflow */
805fc799 1069 ppc64_elf_unhandled_reloc, /* special_function */
411e1bfb
AM		 1070 "R_PPC64_PLTGOT16", /* name */
1071 FALSE, /* partial_inplace */
1072 0, /* src_mask */
1073 0xffff, /* dst_mask */
1074 FALSE), /* pcrel_offset */
1075
1076 /* Like R_PPC64_PLTGOT16, but without overflow. */
1077 /* FIXME: R_PPC64_PLTGOT16_LO not implemented. */
1078 HOWTO (R_PPC64_PLTGOT16_LO, /* type */
1079 0, /* rightshift */
1080 1, /* size (0 = byte, 1 = short, 2 = long) */
1081 16, /* bitsize */
1082 FALSE, /* pc_relative */
1083 0, /* bitpos */
1084 complain_overflow_dont, /* complain_on_overflow */
1085 ppc64_elf_unhandled_reloc, /* special_function */
1086 "R_PPC64_PLTGOT16_LO", /* name */
1087 FALSE, /* partial_inplace */
1088 0, /* src_mask */
1089 0xffff, /* dst_mask */
1090 FALSE), /* pcrel_offset */
1091
1092 /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address. */
1093 /* FIXME: R_PPC64_PLTGOT16_HI not implemented. */
1094 HOWTO (R_PPC64_PLTGOT16_HI, /* type */
1095 16, /* rightshift */
1096 1, /* size (0 = byte, 1 = short, 2 = long) */
1097 16, /* bitsize */
1098 FALSE, /* pc_relative */
1099 0, /* bitpos */
f9c6b907 1100 complain_overflow_signed, /* complain_on_overflow */
411e1bfb
AM		 1101 ppc64_elf_unhandled_reloc, /* special_function */
1102 "R_PPC64_PLTGOT16_HI", /* name */
1103 FALSE, /* partial_inplace */
1104 0, /* src_mask */
1105 0xffff, /* dst_mask */
1106 FALSE), /* pcrel_offset */
1107
1108 /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address, plus
1109 1 if the contents of the low 16 bits, treated as a signed number,
1110 is negative. */
1111 /* FIXME: R_PPC64_PLTGOT16_HA not implemented. */
1112 HOWTO (R_PPC64_PLTGOT16_HA, /* type */
1113 16, /* rightshift */
1114 1, /* size (0 = byte, 1 = short, 2 = long) */
1115 16, /* bitsize */
1116 FALSE, /* pc_relative */
1117 0, /* bitpos */
f9c6b907 1118 complain_overflow_signed, /* complain_on_overflow */
411e1bfb
AM		 1119 ppc64_elf_unhandled_reloc, /* special_function */
1120 "R_PPC64_PLTGOT16_HA", /* name */
1121 FALSE, /* partial_inplace */
1122 0, /* src_mask */
1123 0xffff, /* dst_mask */
1124 FALSE), /* pcrel_offset */
1125
1126 /* Like R_PPC64_ADDR16, but for instructions with a DS field. */
1127 HOWTO (R_PPC64_ADDR16_DS, /* type */
1128 0, /* rightshift */
1129 1, /* size (0 = byte, 1 = short, 2 = long) */
1130 16, /* bitsize */
1131 FALSE, /* pc_relative */
1132 0, /* bitpos */
b80eed39 1133 complain_overflow_signed, /* complain_on_overflow */
411e1bfb
AM		 1134 bfd_elf_generic_reloc, /* special_function */
1135 "R_PPC64_ADDR16_DS", /* name */
1136 FALSE, /* partial_inplace */
1137 0, /* src_mask */
1138 0xfffc, /* dst_mask */
1139 FALSE), /* pcrel_offset */
1140
1141 /* Like R_PPC64_ADDR16_LO, but for instructions with a DS field. */
1142 HOWTO (R_PPC64_ADDR16_LO_DS, /* type */
1143 0, /* rightshift */
1144 1, /* size (0 = byte, 1 = short, 2 = long) */
1145 16, /* bitsize */
1146 FALSE, /* pc_relative */
1147 0, /* bitpos */
1148 complain_overflow_dont,/* complain_on_overflow */
1149 bfd_elf_generic_reloc, /* special_function */
1150 "R_PPC64_ADDR16_LO_DS",/* name */
1151 FALSE, /* partial_inplace */
1152 0, /* src_mask */
1153 0xfffc, /* dst_mask */
1154 FALSE), /* pcrel_offset */
1155
1156 /* Like R_PPC64_GOT16, but for instructions with a DS field. */
1157 HOWTO (R_PPC64_GOT16_DS, /* type */
1158 0, /* rightshift */
1159 1, /* size (0 = byte, 1 = short, 2 = long) */
1160 16, /* bitsize */
1161 FALSE, /* pc_relative */
1162 0, /* bitpos */
1163 complain_overflow_signed, /* complain_on_overflow */
1164 ppc64_elf_unhandled_reloc, /* special_function */
1165 "R_PPC64_GOT16_DS", /* name */
1166 FALSE, /* partial_inplace */
1167 0, /* src_mask */
1168 0xfffc, /* dst_mask */
1169 FALSE), /* pcrel_offset */
1170
1171 /* Like R_PPC64_GOT16_LO, but for instructions with a DS field. */
1172 HOWTO (R_PPC64_GOT16_LO_DS, /* type */
1173 0, /* rightshift */
1174 1, /* size (0 = byte, 1 = short, 2 = long) */
1175 16, /* bitsize */
1176 FALSE, /* pc_relative */
1177 0, /* bitpos */
1178 complain_overflow_dont, /* complain_on_overflow */
1179 ppc64_elf_unhandled_reloc, /* special_function */
1180 "R_PPC64_GOT16_LO_DS", /* name */
1181 FALSE, /* partial_inplace */
1182 0, /* src_mask */
1183 0xfffc, /* dst_mask */
1184 FALSE), /* pcrel_offset */
1185
1186 /* Like R_PPC64_PLT16_LO, but for instructions with a DS field. */
1187 HOWTO (R_PPC64_PLT16_LO_DS, /* type */
1188 0, /* rightshift */
1189 1, /* size (0 = byte, 1 = short, 2 = long) */
1190 16, /* bitsize */
1191 FALSE, /* pc_relative */
1192 0, /* bitpos */
1193 complain_overflow_dont, /* complain_on_overflow */
1194 ppc64_elf_unhandled_reloc, /* special_function */
1195 "R_PPC64_PLT16_LO_DS", /* name */
1196 FALSE, /* partial_inplace */
1197 0, /* src_mask */
1198 0xfffc, /* dst_mask */
1199 FALSE), /* pcrel_offset */
1200
1201 /* Like R_PPC64_SECTOFF, but for instructions with a DS field. */
1202 HOWTO (R_PPC64_SECTOFF_DS, /* type */
1203 0, /* rightshift */
1204 1, /* size (0 = byte, 1 = short, 2 = long) */
1205 16, /* bitsize */
1206 FALSE, /* pc_relative */
1207 0, /* bitpos */
b80eed39 1208 complain_overflow_signed, /* complain_on_overflow */
411e1bfb
AM		 1209 ppc64_elf_sectoff_reloc, /* special_function */
1210 "R_PPC64_SECTOFF_DS", /* name */
1211 FALSE, /* partial_inplace */
1212 0, /* src_mask */
1213 0xfffc, /* dst_mask */
1214 FALSE), /* pcrel_offset */
1215
1216 /* Like R_PPC64_SECTOFF_LO, but for instructions with a DS field. */
1217 HOWTO (R_PPC64_SECTOFF_LO_DS, /* type */
1218 0, /* rightshift */
1219 1, /* size (0 = byte, 1 = short, 2 = long) */
1220 16, /* bitsize */
1221 FALSE, /* pc_relative */
1222 0, /* bitpos */
1223 complain_overflow_dont, /* complain_on_overflow */
1224 ppc64_elf_sectoff_reloc, /* special_function */
1225 "R_PPC64_SECTOFF_LO_DS",/* name */
1226 FALSE, /* partial_inplace */
1227 0, /* src_mask */
1228 0xfffc, /* dst_mask */
1229 FALSE), /* pcrel_offset */
1230
1231 /* Like R_PPC64_TOC16, but for instructions with a DS field. */
1232 HOWTO (R_PPC64_TOC16_DS, /* type */
1233 0, /* rightshift */
1234 1, /* size (0 = byte, 1 = short, 2 = long) */
1235 16, /* bitsize */
1236 FALSE, /* pc_relative */
1237 0, /* bitpos */
1238 complain_overflow_signed, /* complain_on_overflow */
1239 ppc64_elf_toc_reloc, /* special_function */
1240 "R_PPC64_TOC16_DS", /* name */
1241 FALSE, /* partial_inplace */
1242 0, /* src_mask */
1243 0xfffc, /* dst_mask */
1244 FALSE), /* pcrel_offset */
1245
1246 /* Like R_PPC64_TOC16_LO, but for instructions with a DS field. */
1247 HOWTO (R_PPC64_TOC16_LO_DS, /* type */
1248 0, /* rightshift */
1249 1, /* size (0 = byte, 1 = short, 2 = long) */
1250 16, /* bitsize */
1251 FALSE, /* pc_relative */
1252 0, /* bitpos */
1253 complain_overflow_dont, /* complain_on_overflow */
1254 ppc64_elf_toc_reloc, /* special_function */
1255 "R_PPC64_TOC16_LO_DS", /* name */
1256 FALSE, /* partial_inplace */
1257 0, /* src_mask */
1258 0xfffc, /* dst_mask */
1259 FALSE), /* pcrel_offset */
1260
1261 /* Like R_PPC64_PLTGOT16, but for instructions with a DS field. */
1262 /* FIXME: R_PPC64_PLTGOT16_DS not implemented. */
6bfdb61b 1263 HOWTO (R_PPC64_PLTGOT16_DS, /* type */
411e1bfb
AM		 1264 0, /* rightshift */
1265 1, /* size (0 = byte, 1 = short, 2 = long) */
1266 16, /* bitsize */
1267 FALSE, /* pc_relative */
1268 0, /* bitpos */
1269 complain_overflow_signed, /* complain_on_overflow */
1270 ppc64_elf_unhandled_reloc, /* special_function */
1271 "R_PPC64_PLTGOT16_DS", /* name */
1272 FALSE, /* partial_inplace */
1273 0, /* src_mask */
1274 0xfffc, /* dst_mask */
1275 FALSE), /* pcrel_offset */
1276
1277 /* Like R_PPC64_PLTGOT16_LO, but for instructions with a DS field. */
1278 /* FIXME: R_PPC64_PLTGOT16_LO not implemented. */
1279 HOWTO (R_PPC64_PLTGOT16_LO_DS,/* type */
1280 0, /* rightshift */
1281 1, /* size (0 = byte, 1 = short, 2 = long) */
1282 16, /* bitsize */
1283 FALSE, /* pc_relative */
1284 0, /* bitpos */
1285 complain_overflow_dont, /* complain_on_overflow */
1286 ppc64_elf_unhandled_reloc, /* special_function */
1287 "R_PPC64_PLTGOT16_LO_DS",/* name */
1288 FALSE, /* partial_inplace */
1289 0, /* src_mask */
1290 0xfffc, /* dst_mask */
1291 FALSE), /* pcrel_offset */
1292
727fc41e 1293 /* Marker relocs for TLS. */
411e1bfb
AM		 1294 HOWTO (R_PPC64_TLS,
1295 0, /* rightshift */
1296 2, /* size (0 = byte, 1 = short, 2 = long) */
1297 32, /* bitsize */
1298 FALSE, /* pc_relative */
1299 0, /* bitpos */
1300 complain_overflow_dont, /* complain_on_overflow */
1301 bfd_elf_generic_reloc, /* special_function */
1302 "R_PPC64_TLS", /* name */
1303 FALSE, /* partial_inplace */
1304 0, /* src_mask */
1305 0, /* dst_mask */
1306 FALSE), /* pcrel_offset */
1307
727fc41e
AM		 1308 HOWTO (R_PPC64_TLSGD,
1309 0, /* rightshift */
1310 2, /* size (0 = byte, 1 = short, 2 = long) */
1311 32, /* bitsize */
1312 FALSE, /* pc_relative */
1313 0, /* bitpos */
1314 complain_overflow_dont, /* complain_on_overflow */
1315 bfd_elf_generic_reloc, /* special_function */
1316 "R_PPC64_TLSGD", /* name */
1317 FALSE, /* partial_inplace */
1318 0, /* src_mask */
1319 0, /* dst_mask */
1320 FALSE), /* pcrel_offset */
1321
1322 HOWTO (R_PPC64_TLSLD,
1323 0, /* rightshift */
1324 2, /* size (0 = byte, 1 = short, 2 = long) */
1325 32, /* bitsize */
1326 FALSE, /* pc_relative */
1327 0, /* bitpos */
1328 complain_overflow_dont, /* complain_on_overflow */
1329 bfd_elf_generic_reloc, /* special_function */
1330 "R_PPC64_TLSLD", /* name */
1331 FALSE, /* partial_inplace */
1332 0, /* src_mask */
1333 0, /* dst_mask */
1334 FALSE), /* pcrel_offset */
1335
3b421ab3
AM		 1336 HOWTO (R_PPC64_TOCSAVE,
1337 0, /* rightshift */
1338 2, /* size (0 = byte, 1 = short, 2 = long) */
1339 32, /* bitsize */
1340 FALSE, /* pc_relative */
1341 0, /* bitpos */
1342 complain_overflow_dont, /* complain_on_overflow */
1343 bfd_elf_generic_reloc, /* special_function */
1344 "R_PPC64_TOCSAVE", /* name */
1345 FALSE, /* partial_inplace */
1346 0, /* src_mask */
1347 0, /* dst_mask */
1348 FALSE), /* pcrel_offset */
1349
411e1bfb
AM		 1350 /* Computes the load module index of the load module that contains the
1351 definition of its TLS sym. */
1352 HOWTO (R_PPC64_DTPMOD64,
1353 0, /* rightshift */
1354 4, /* size (0 = byte, 1 = short, 2 = long) */
1355 64, /* bitsize */
1356 FALSE, /* pc_relative */
1357 0, /* bitpos */
1358 complain_overflow_dont, /* complain_on_overflow */
1359 ppc64_elf_unhandled_reloc, /* special_function */
1360 "R_PPC64_DTPMOD64", /* name */
1361 FALSE, /* partial_inplace */
1362 0, /* src_mask */
1363 ONES (64), /* dst_mask */
1364 FALSE), /* pcrel_offset */
1365
1366 /* Computes a dtv-relative displacement, the difference between the value
1367 of sym+add and the base address of the thread-local storage block that
1368 contains the definition of sym, minus 0x8000. */
1369 HOWTO (R_PPC64_DTPREL64,
1370 0, /* rightshift */
1371 4, /* size (0 = byte, 1 = short, 2 = long) */
1372 64, /* bitsize */
1373 FALSE, /* pc_relative */
1374 0, /* bitpos */
1375 complain_overflow_dont, /* complain_on_overflow */
1376 ppc64_elf_unhandled_reloc, /* special_function */
1377 "R_PPC64_DTPREL64", /* name */
1378 FALSE, /* partial_inplace */
1379 0, /* src_mask */
1380 ONES (64), /* dst_mask */
1381 FALSE), /* pcrel_offset */
1382
1383 /* A 16 bit dtprel reloc. */
1384 HOWTO (R_PPC64_DTPREL16,
1385 0, /* rightshift */
1386 1, /* size (0 = byte, 1 = short, 2 = long) */
1387 16, /* bitsize */
1388 FALSE, /* pc_relative */
1389 0, /* bitpos */
1390 complain_overflow_signed, /* complain_on_overflow */
1391 ppc64_elf_unhandled_reloc, /* special_function */
1392 "R_PPC64_DTPREL16", /* name */
1393 FALSE, /* partial_inplace */
1394 0, /* src_mask */
1395 0xffff, /* dst_mask */
1396 FALSE), /* pcrel_offset */
1397
1398 /* Like DTPREL16, but no overflow. */
1399 HOWTO (R_PPC64_DTPREL16_LO,
1400 0, /* rightshift */
1401 1, /* size (0 = byte, 1 = short, 2 = long) */
1402 16, /* bitsize */
1403 FALSE, /* pc_relative */
1404 0, /* bitpos */
1405 complain_overflow_dont, /* complain_on_overflow */
1406 ppc64_elf_unhandled_reloc, /* special_function */
1407 "R_PPC64_DTPREL16_LO", /* name */
1408 FALSE, /* partial_inplace */
1409 0, /* src_mask */
1410 0xffff, /* dst_mask */
1411 FALSE), /* pcrel_offset */
1412
1413 /* Like DTPREL16_LO, but next higher group of 16 bits. */
1414 HOWTO (R_PPC64_DTPREL16_HI,
1415 16, /* rightshift */
1416 1, /* size (0 = byte, 1 = short, 2 = long) */
1417 16, /* bitsize */
1418 FALSE, /* pc_relative */
1419 0, /* bitpos */
f9c6b907 1420 complain_overflow_signed, /* complain_on_overflow */
411e1bfb
AM		 1421 ppc64_elf_unhandled_reloc, /* special_function */
1422 "R_PPC64_DTPREL16_HI", /* name */
1423 FALSE, /* partial_inplace */
1424 0, /* src_mask */
1425 0xffff, /* dst_mask */
1426 FALSE), /* pcrel_offset */
1427
1428 /* Like DTPREL16_HI, but adjust for low 16 bits. */
1429 HOWTO (R_PPC64_DTPREL16_HA,
1430 16, /* rightshift */
1431 1, /* size (0 = byte, 1 = short, 2 = long) */
1432 16, /* bitsize */
1433 FALSE, /* pc_relative */
1434 0, /* bitpos */
f9c6b907 1435 complain_overflow_signed, /* complain_on_overflow */
411e1bfb
AM		 1436 ppc64_elf_unhandled_reloc, /* special_function */
1437 "R_PPC64_DTPREL16_HA", /* name */
1438 FALSE, /* partial_inplace */
1439 0, /* src_mask */
1440 0xffff, /* dst_mask */
1441 FALSE), /* pcrel_offset */
1442
1443 /* Like DTPREL16_HI, but next higher group of 16 bits. */
1444 HOWTO (R_PPC64_DTPREL16_HIGHER,
1445 32, /* rightshift */
1446 1, /* size (0 = byte, 1 = short, 2 = long) */
1447 16, /* bitsize */
1448 FALSE, /* pc_relative */
1449 0, /* bitpos */
1450 complain_overflow_dont, /* complain_on_overflow */
1451 ppc64_elf_unhandled_reloc, /* special_function */
1452 "R_PPC64_DTPREL16_HIGHER", /* name */
1453 FALSE, /* partial_inplace */
1454 0, /* src_mask */
1455 0xffff, /* dst_mask */
1456 FALSE), /* pcrel_offset */
1457
1458 /* Like DTPREL16_HIGHER, but adjust for low 16 bits. */
1459 HOWTO (R_PPC64_DTPREL16_HIGHERA,
1460 32, /* rightshift */
1461 1, /* size (0 = byte, 1 = short, 2 = long) */
1462 16, /* bitsize */
1463 FALSE, /* pc_relative */
1464 0, /* bitpos */
1465 complain_overflow_dont, /* complain_on_overflow */
1466 ppc64_elf_unhandled_reloc, /* special_function */
1467 "R_PPC64_DTPREL16_HIGHERA", /* name */
1468 FALSE, /* partial_inplace */
1469 0, /* src_mask */
1470 0xffff, /* dst_mask */
1471 FALSE), /* pcrel_offset */
1472
1473 /* Like DTPREL16_HIGHER, but next higher group of 16 bits. */
1474 HOWTO (R_PPC64_DTPREL16_HIGHEST,
1475 48, /* rightshift */
1476 1, /* size (0 = byte, 1 = short, 2 = long) */
1477 16, /* bitsize */
1478 FALSE, /* pc_relative */
1479 0, /* bitpos */
1480 complain_overflow_dont, /* complain_on_overflow */
1481 ppc64_elf_unhandled_reloc, /* special_function */
1482 "R_PPC64_DTPREL16_HIGHEST", /* name */
1483 FALSE, /* partial_inplace */
1484 0, /* src_mask */
1485 0xffff, /* dst_mask */
1486 FALSE), /* pcrel_offset */
1487
1488 /* Like DTPREL16_HIGHEST, but adjust for low 16 bits. */
1489 HOWTO (R_PPC64_DTPREL16_HIGHESTA,
1490 48, /* rightshift */
1491 1, /* size (0 = byte, 1 = short, 2 = long) */
1492 16, /* bitsize */
1493 FALSE, /* pc_relative */
1494 0, /* bitpos */
1495 complain_overflow_dont, /* complain_on_overflow */
1496 ppc64_elf_unhandled_reloc, /* special_function */
1497 "R_PPC64_DTPREL16_HIGHESTA", /* name */
1498 FALSE, /* partial_inplace */
1499 0, /* src_mask */
1500 0xffff, /* dst_mask */
1501 FALSE), /* pcrel_offset */
1502
1503 /* Like DTPREL16, but for insns with a DS field. */
1504 HOWTO (R_PPC64_DTPREL16_DS,
1505 0, /* rightshift */
1506 1, /* size (0 = byte, 1 = short, 2 = long) */
1507 16, /* bitsize */
1508 FALSE, /* pc_relative */
1509 0, /* bitpos */
1510 complain_overflow_signed, /* complain_on_overflow */
1511 ppc64_elf_unhandled_reloc, /* special_function */
1512 "R_PPC64_DTPREL16_DS", /* name */
1513 FALSE, /* partial_inplace */
1514 0, /* src_mask */
1515 0xfffc, /* dst_mask */
1516 FALSE), /* pcrel_offset */
1517
1518 /* Like DTPREL16_DS, but no overflow. */
1519 HOWTO (R_PPC64_DTPREL16_LO_DS,
1520 0, /* rightshift */
1521 1, /* size (0 = byte, 1 = short, 2 = long) */
1522 16, /* bitsize */
1523 FALSE, /* pc_relative */
1524 0, /* bitpos */
1525 complain_overflow_dont, /* complain_on_overflow */
1526 ppc64_elf_unhandled_reloc, /* special_function */
1527 "R_PPC64_DTPREL16_LO_DS", /* name */
1528 FALSE, /* partial_inplace */
1529 0, /* src_mask */
1530 0xfffc, /* dst_mask */
1531 FALSE), /* pcrel_offset */
1532
1533 /* Computes a tp-relative displacement, the difference between the value of
1534 sym+add and the value of the thread pointer (r13). */
1535 HOWTO (R_PPC64_TPREL64,
1536 0, /* rightshift */
1537 4, /* size (0 = byte, 1 = short, 2 = long) */
1538 64, /* bitsize */
1539 FALSE, /* pc_relative */
1540 0, /* bitpos */
1541 complain_overflow_dont, /* complain_on_overflow */
1542 ppc64_elf_unhandled_reloc, /* special_function */
1543 "R_PPC64_TPREL64", /* name */
1544 FALSE, /* partial_inplace */
1545 0, /* src_mask */
1546 ONES (64), /* dst_mask */
1547 FALSE), /* pcrel_offset */
1548
1549 /* A 16 bit tprel reloc. */
1550 HOWTO (R_PPC64_TPREL16,
1551 0, /* rightshift */
1552 1, /* size (0 = byte, 1 = short, 2 = long) */
1553 16, /* bitsize */
1554 FALSE, /* pc_relative */
1555 0, /* bitpos */
1556 complain_overflow_signed, /* complain_on_overflow */
1557 ppc64_elf_unhandled_reloc, /* special_function */
1558 "R_PPC64_TPREL16", /* name */
1559 FALSE, /* partial_inplace */
1560 0, /* src_mask */
1561 0xffff, /* dst_mask */
1562 FALSE), /* pcrel_offset */
1563
1564 /* Like TPREL16, but no overflow. */
1565 HOWTO (R_PPC64_TPREL16_LO,
1566 0, /* rightshift */
1567 1, /* size (0 = byte, 1 = short, 2 = long) */
1568 16, /* bitsize */
1569 FALSE, /* pc_relative */
1570 0, /* bitpos */
1571 complain_overflow_dont, /* complain_on_overflow */
1572 ppc64_elf_unhandled_reloc, /* special_function */
1573 "R_PPC64_TPREL16_LO", /* name */
1574 FALSE, /* partial_inplace */
1575 0, /* src_mask */
1576 0xffff, /* dst_mask */
1577 FALSE), /* pcrel_offset */
1578
1579 /* Like TPREL16_LO, but next higher group of 16 bits. */
1580 HOWTO (R_PPC64_TPREL16_HI,
1581 16, /* rightshift */
1582 1, /* size (0 = byte, 1 = short, 2 = long) */
1583 16, /* bitsize */
1584 FALSE, /* pc_relative */
1585 0, /* bitpos */
f9c6b907 1586 complain_overflow_signed, /* complain_on_overflow */
411e1bfb
AM		 1587 ppc64_elf_unhandled_reloc, /* special_function */
1588 "R_PPC64_TPREL16_HI", /* name */
1589 FALSE, /* partial_inplace */
1590 0, /* src_mask */
1591 0xffff, /* dst_mask */
1592 FALSE), /* pcrel_offset */
1593
1594 /* Like TPREL16_HI, but adjust for low 16 bits. */
1595 HOWTO (R_PPC64_TPREL16_HA,
1596 16, /* rightshift */
1597 1, /* size (0 = byte, 1 = short, 2 = long) */
1598 16, /* bitsize */
1599 FALSE, /* pc_relative */
1600 0, /* bitpos */
f9c6b907 1601 complain_overflow_signed, /* complain_on_overflow */
411e1bfb
AM		 1602 ppc64_elf_unhandled_reloc, /* special_function */
1603 "R_PPC64_TPREL16_HA", /* name */
1604 FALSE, /* partial_inplace */
1605 0, /* src_mask */
1606 0xffff, /* dst_mask */
1607 FALSE), /* pcrel_offset */
1608
1609 /* Like TPREL16_HI, but next higher group of 16 bits. */
1610 HOWTO (R_PPC64_TPREL16_HIGHER,
1611 32, /* rightshift */
1612 1, /* size (0 = byte, 1 = short, 2 = long) */
1613 16, /* bitsize */
1614 FALSE, /* pc_relative */
1615 0, /* bitpos */
1616 complain_overflow_dont, /* complain_on_overflow */
1617 ppc64_elf_unhandled_reloc, /* special_function */
1618 "R_PPC64_TPREL16_HIGHER", /* name */
1619 FALSE, /* partial_inplace */
1620 0, /* src_mask */
1621 0xffff, /* dst_mask */
1622 FALSE), /* pcrel_offset */
1623
1624 /* Like TPREL16_HIGHER, but adjust for low 16 bits. */
1625 HOWTO (R_PPC64_TPREL16_HIGHERA,
1626 32, /* rightshift */
1627 1, /* size (0 = byte, 1 = short, 2 = long) */
1628 16, /* bitsize */
1629 FALSE, /* pc_relative */
1630 0, /* bitpos */
1631 complain_overflow_dont, /* complain_on_overflow */
1632 ppc64_elf_unhandled_reloc, /* special_function */
1633 "R_PPC64_TPREL16_HIGHERA", /* name */
1634 FALSE, /* partial_inplace */
1635 0, /* src_mask */
1636 0xffff, /* dst_mask */
1637 FALSE), /* pcrel_offset */
1638
1639 /* Like TPREL16_HIGHER, but next higher group of 16 bits. */
1640 HOWTO (R_PPC64_TPREL16_HIGHEST,
1641 48, /* rightshift */
1642 1, /* size (0 = byte, 1 = short, 2 = long) */
1643 16, /* bitsize */
1644 FALSE, /* pc_relative */
1645 0, /* bitpos */
1646 complain_overflow_dont, /* complain_on_overflow */
1647 ppc64_elf_unhandled_reloc, /* special_function */
1648 "R_PPC64_TPREL16_HIGHEST", /* name */
1649 FALSE, /* partial_inplace */
1650 0, /* src_mask */
1651 0xffff, /* dst_mask */
1652 FALSE), /* pcrel_offset */
1653
1654 /* Like TPREL16_HIGHEST, but adjust for low 16 bits. */
1655 HOWTO (R_PPC64_TPREL16_HIGHESTA,
1656 48, /* rightshift */
1657 1, /* size (0 = byte, 1 = short, 2 = long) */
1658 16, /* bitsize */
1659 FALSE, /* pc_relative */
1660 0, /* bitpos */
1661 complain_overflow_dont, /* complain_on_overflow */
1662 ppc64_elf_unhandled_reloc, /* special_function */
1663 "R_PPC64_TPREL16_HIGHESTA", /* name */
1664 FALSE, /* partial_inplace */
1665 0, /* src_mask */
1666 0xffff, /* dst_mask */
1667 FALSE), /* pcrel_offset */
1668
1669 /* Like TPREL16, but for insns with a DS field. */
1670 HOWTO (R_PPC64_TPREL16_DS,
1671 0, /* rightshift */
1672 1, /* size (0 = byte, 1 = short, 2 = long) */
1673 16, /* bitsize */
1674 FALSE, /* pc_relative */
1675 0, /* bitpos */
1676 complain_overflow_signed, /* complain_on_overflow */
1677 ppc64_elf_unhandled_reloc, /* special_function */
1678 "R_PPC64_TPREL16_DS", /* name */
1679 FALSE, /* partial_inplace */
1680 0, /* src_mask */
1681 0xfffc, /* dst_mask */
1682 FALSE), /* pcrel_offset */
1683
1684 /* Like TPREL16_DS, but no overflow. */
1685 HOWTO (R_PPC64_TPREL16_LO_DS,
1686 0, /* rightshift */
1687 1, /* size (0 = byte, 1 = short, 2 = long) */
1688 16, /* bitsize */
1689 FALSE, /* pc_relative */
1690 0, /* bitpos */
1691 complain_overflow_dont, /* complain_on_overflow */
1692 ppc64_elf_unhandled_reloc, /* special_function */
1693 "R_PPC64_TPREL16_LO_DS", /* name */
1694 FALSE, /* partial_inplace */
1695 0, /* src_mask */
1696 0xfffc, /* dst_mask */
1697 FALSE), /* pcrel_offset */
1698
1699 /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1700 with values (sym+add)@dtpmod and (sym+add)@dtprel, and computes the offset
1701 to the first entry relative to the TOC base (r2). */
1702 HOWTO (R_PPC64_GOT_TLSGD16,
1703 0, /* rightshift */
1704 1, /* size (0 = byte, 1 = short, 2 = long) */
1705 16, /* bitsize */
1706 FALSE, /* pc_relative */
1707 0, /* bitpos */
1708 complain_overflow_signed, /* complain_on_overflow */
1709 ppc64_elf_unhandled_reloc, /* special_function */
1710 "R_PPC64_GOT_TLSGD16", /* name */
b34976b6 1711 FALSE, /* partial_inplace */
5bd4f169
AM		 1712 0, /* src_mask */
1713 0xffff, /* dst_mask */
b34976b6 1714 FALSE), /* pcrel_offset */
5bd4f169 1715
411e1bfb
AM		 1716 /* Like GOT_TLSGD16, but no overflow. */
1717 HOWTO (R_PPC64_GOT_TLSGD16_LO,
5bd4f169
AM		 1718 0, /* rightshift */
1719 1, /* size (0 = byte, 1 = short, 2 = long) */
1720 16, /* bitsize */
b34976b6 1721 FALSE, /* pc_relative */
5bd4f169
AM		 1722 0, /* bitpos */
1723 complain_overflow_dont, /* complain_on_overflow */
805fc799 1724 ppc64_elf_unhandled_reloc, /* special_function */
411e1bfb 1725 "R_PPC64_GOT_TLSGD16_LO", /* name */
b34976b6 1726 FALSE, /* partial_inplace */
5bd4f169
AM		 1727 0, /* src_mask */
1728 0xffff, /* dst_mask */
b34976b6 1729 FALSE), /* pcrel_offset */
5bd4f169 1730
411e1bfb
AM		 1731 /* Like GOT_TLSGD16_LO, but next higher group of 16 bits. */
1732 HOWTO (R_PPC64_GOT_TLSGD16_HI,
5bd4f169
AM		 1733 16, /* rightshift */
1734 1, /* size (0 = byte, 1 = short, 2 = long) */
1735 16, /* bitsize */
b34976b6 1736 FALSE, /* pc_relative */
5bd4f169 1737 0, /* bitpos */
f9c6b907 1738 complain_overflow_signed, /* complain_on_overflow */
805fc799 1739 ppc64_elf_unhandled_reloc, /* special_function */
411e1bfb 1740 "R_PPC64_GOT_TLSGD16_HI", /* name */
b34976b6 1741 FALSE, /* partial_inplace */
5bd4f169
AM		 1742 0, /* src_mask */
1743 0xffff, /* dst_mask */
b34976b6 1744 FALSE), /* pcrel_offset */
5bd4f169 1745
411e1bfb
AM		 1746 /* Like GOT_TLSGD16_HI, but adjust for low 16 bits. */
1747 HOWTO (R_PPC64_GOT_TLSGD16_HA,
5bd4f169
AM		 1748 16, /* rightshift */
1749 1, /* size (0 = byte, 1 = short, 2 = long) */
1750 16, /* bitsize */
b34976b6 1751 FALSE, /* pc_relative */
5bd4f169 1752 0, /* bitpos */
f9c6b907 1753 complain_overflow_signed, /* complain_on_overflow */
805fc799 1754 ppc64_elf_unhandled_reloc, /* special_function */
411e1bfb 1755 "R_PPC64_GOT_TLSGD16_HA", /* name */
b34976b6 1756 FALSE, /* partial_inplace */
5bd4f169
AM		 1757 0, /* src_mask */
1758 0xffff, /* dst_mask */
b34976b6 1759 FALSE), /* pcrel_offset */
5bd4f169 1760
411e1bfb
AM		 1761 /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1762 with values (sym+add)@dtpmod and zero, and computes the offset to the
1763 first entry relative to the TOC base (r2). */
1764 HOWTO (R_PPC64_GOT_TLSLD16,
5bd4f169
AM		 1765 0, /* rightshift */
1766 1, /* size (0 = byte, 1 = short, 2 = long) */
1767 16, /* bitsize */
b34976b6 1768 FALSE, /* pc_relative */
5bd4f169 1769 0, /* bitpos */
411e1bfb
AM		 1770 complain_overflow_signed, /* complain_on_overflow */
1771 ppc64_elf_unhandled_reloc, /* special_function */
1772 "R_PPC64_GOT_TLSLD16", /* name */
b34976b6 1773 FALSE, /* partial_inplace */
d006db6c 1774 0, /* src_mask */
411e1bfb 1775 0xffff, /* dst_mask */
b34976b6 1776 FALSE), /* pcrel_offset */
5bd4f169 1777
411e1bfb
AM		 1778 /* Like GOT_TLSLD16, but no overflow. */
1779 HOWTO (R_PPC64_GOT_TLSLD16_LO,
5bd4f169
AM		 1780 0, /* rightshift */
1781 1, /* size (0 = byte, 1 = short, 2 = long) */
1782 16, /* bitsize */
b34976b6 1783 FALSE, /* pc_relative */
5bd4f169 1784 0, /* bitpos */
411e1bfb
AM		 1785 complain_overflow_dont, /* complain_on_overflow */
1786 ppc64_elf_unhandled_reloc, /* special_function */
1787 "R_PPC64_GOT_TLSLD16_LO", /* name */
b34976b6 1788 FALSE, /* partial_inplace */
d006db6c 1789 0, /* src_mask */
411e1bfb 1790 0xffff, /* dst_mask */
b34976b6 1791 FALSE), /* pcrel_offset */
5bd4f169 1792
411e1bfb
AM		 1793 /* Like GOT_TLSLD16_LO, but next higher group of 16 bits. */
1794 HOWTO (R_PPC64_GOT_TLSLD16_HI,
1795 16, /* rightshift */
5bd4f169
AM		 1796 1, /* size (0 = byte, 1 = short, 2 = long) */
1797 16, /* bitsize */
b34976b6 1798 FALSE, /* pc_relative */
5bd4f169 1799 0, /* bitpos */
f9c6b907 1800 complain_overflow_signed, /* complain_on_overflow */
805fc799 1801 ppc64_elf_unhandled_reloc, /* special_function */
411e1bfb 1802 "R_PPC64_GOT_TLSLD16_HI", /* name */
b34976b6 1803 FALSE, /* partial_inplace */
d006db6c 1804 0, /* src_mask */
411e1bfb 1805 0xffff, /* dst_mask */
b34976b6 1806 FALSE), /* pcrel_offset */
5bd4f169 1807
411e1bfb
AM		 1808 /* Like GOT_TLSLD16_HI, but adjust for low 16 bits. */
1809 HOWTO (R_PPC64_GOT_TLSLD16_HA,
1810 16, /* rightshift */
5bd4f169
AM		 1811 1, /* size (0 = byte, 1 = short, 2 = long) */
1812 16, /* bitsize */
b34976b6 1813 FALSE, /* pc_relative */
5bd4f169 1814 0, /* bitpos */
f9c6b907 1815 complain_overflow_signed, /* complain_on_overflow */
805fc799 1816 ppc64_elf_unhandled_reloc, /* special_function */
411e1bfb 1817 "R_PPC64_GOT_TLSLD16_HA", /* name */
b34976b6 1818 FALSE, /* partial_inplace */
d006db6c 1819 0, /* src_mask */
411e1bfb 1820 0xffff, /* dst_mask */
b34976b6 1821 FALSE), /* pcrel_offset */
5bd4f169 1822
411e1bfb
AM		 1823 /* Allocates an entry in the GOT with value (sym+add)@dtprel, and computes
1824 the offset to the entry relative to the TOC base (r2). */
1825 HOWTO (R_PPC64_GOT_DTPREL16_DS,
5bd4f169
AM		 1826 0, /* rightshift */
1827 1, /* size (0 = byte, 1 = short, 2 = long) */
1828 16, /* bitsize */
b34976b6 1829 FALSE, /* pc_relative */
5bd4f169 1830 0, /* bitpos */
411e1bfb 1831 complain_overflow_signed, /* complain_on_overflow */
805fc799 1832 ppc64_elf_unhandled_reloc, /* special_function */
411e1bfb 1833 "R_PPC64_GOT_DTPREL16_DS", /* name */
b34976b6 1834 FALSE, /* partial_inplace */
d006db6c 1835 0, /* src_mask */
5bd4f169 1836 0xfffc, /* dst_mask */
b34976b6 1837 FALSE), /* pcrel_offset */
5bd4f169 1838
411e1bfb
AM		 1839 /* Like GOT_DTPREL16_DS, but no overflow. */
1840 HOWTO (R_PPC64_GOT_DTPREL16_LO_DS,
5bd4f169 1841 0, /* rightshift */
c061c2d8
AM		 1842 1, /* size (0 = byte, 1 = short, 2 = long) */
1843 16, /* bitsize */
b34976b6 1844 FALSE, /* pc_relative */
5bd4f169 1845 0, /* bitpos */
411e1bfb
AM		 1846 complain_overflow_dont, /* complain_on_overflow */
1847 ppc64_elf_unhandled_reloc, /* special_function */
1848 "R_PPC64_GOT_DTPREL16_LO_DS", /* name */
b34976b6 1849 FALSE, /* partial_inplace */
d006db6c 1850 0, /* src_mask */
c061c2d8 1851 0xfffc, /* dst_mask */
b34976b6 1852 FALSE), /* pcrel_offset */
5bd4f169 1853
411e1bfb
AM		 1854 /* Like GOT_DTPREL16_LO_DS, but next higher group of 16 bits. */
1855 HOWTO (R_PPC64_GOT_DTPREL16_HI,
1856 16, /* rightshift */
5bd4f169
AM		 1857 1, /* size (0 = byte, 1 = short, 2 = long) */
1858 16, /* bitsize */
b34976b6 1859 FALSE, /* pc_relative */
5bd4f169 1860 0, /* bitpos */
f9c6b907 1861 complain_overflow_signed, /* complain_on_overflow */
411e1bfb
AM		 1862 ppc64_elf_unhandled_reloc, /* special_function */
1863 "R_PPC64_GOT_DTPREL16_HI", /* name */
b34976b6 1864 FALSE, /* partial_inplace */
d006db6c 1865 0, /* src_mask */
411e1bfb 1866 0xffff, /* dst_mask */
b34976b6 1867 FALSE), /* pcrel_offset */
5bd4f169 1868
411e1bfb
AM		 1869 /* Like GOT_DTPREL16_HI, but adjust for low 16 bits. */
1870 HOWTO (R_PPC64_GOT_DTPREL16_HA,
1871 16, /* rightshift */
1872 1, /* size (0 = byte, 1 = short, 2 = long) */
1873 16, /* bitsize */
1874 FALSE, /* pc_relative */
1875 0, /* bitpos */
f9c6b907 1876 complain_overflow_signed, /* complain_on_overflow */
411e1bfb
AM		 1877 ppc64_elf_unhandled_reloc, /* special_function */
1878 "R_PPC64_GOT_DTPREL16_HA", /* name */
1879 FALSE, /* partial_inplace */
1880 0, /* src_mask */
1881 0xffff, /* dst_mask */
1882 FALSE), /* pcrel_offset */
1883
1884 /* Allocates an entry in the GOT with value (sym+add)@tprel, and computes the
1885 offset to the entry relative to the TOC base (r2). */
1886 HOWTO (R_PPC64_GOT_TPREL16_DS,
5bd4f169
AM		 1887 0, /* rightshift */
1888 1, /* size (0 = byte, 1 = short, 2 = long) */
1889 16, /* bitsize */
b34976b6 1890 FALSE, /* pc_relative */
5bd4f169
AM		 1891 0, /* bitpos */
1892 complain_overflow_signed, /* complain_on_overflow */
411e1bfb
AM		 1893 ppc64_elf_unhandled_reloc, /* special_function */
1894 "R_PPC64_GOT_TPREL16_DS", /* name */
b34976b6 1895 FALSE, /* partial_inplace */
d006db6c 1896 0, /* src_mask */
ad8e1ba5 1897 0xfffc, /* dst_mask */
b34976b6 1898 FALSE), /* pcrel_offset */
5bd4f169 1899
411e1bfb
AM		 1900 /* Like GOT_TPREL16_DS, but no overflow. */
1901 HOWTO (R_PPC64_GOT_TPREL16_LO_DS,
5bd4f169
AM		 1902 0, /* rightshift */
1903 1, /* size (0 = byte, 1 = short, 2 = long) */
1904 16, /* bitsize */
b34976b6 1905 FALSE, /* pc_relative */
5bd4f169
AM		 1906 0, /* bitpos */
1907 complain_overflow_dont, /* complain_on_overflow */
411e1bfb
AM		 1908 ppc64_elf_unhandled_reloc, /* special_function */
1909 "R_PPC64_GOT_TPREL16_LO_DS", /* name */
b34976b6 1910 FALSE, /* partial_inplace */
d006db6c 1911 0, /* src_mask */
ad8e1ba5 1912 0xfffc, /* dst_mask */
b34976b6 1913 FALSE), /* pcrel_offset */
5bd4f169 1914
411e1bfb
AM		 1915 /* Like GOT_TPREL16_LO_DS, but next higher group of 16 bits. */
1916 HOWTO (R_PPC64_GOT_TPREL16_HI,
1917 16, /* rightshift */
5bd4f169
AM		 1918 1, /* size (0 = byte, 1 = short, 2 = long) */
1919 16, /* bitsize */
b34976b6 1920 FALSE, /* pc_relative */
5bd4f169 1921 0, /* bitpos */
f9c6b907 1922 complain_overflow_signed, /* complain_on_overflow */
805fc799 1923 ppc64_elf_unhandled_reloc, /* special_function */
411e1bfb 1924 "R_PPC64_GOT_TPREL16_HI", /* name */
b34976b6 1925 FALSE, /* partial_inplace */
d006db6c 1926 0, /* src_mask */
411e1bfb 1927 0xffff, /* dst_mask */
b34976b6 1928 FALSE), /* pcrel_offset */
5bd4f169 1929
411e1bfb
AM		 1930 /* Like GOT_TPREL16_HI, but adjust for low 16 bits. */
1931 HOWTO (R_PPC64_GOT_TPREL16_HA,
1932 16, /* rightshift */
5bd4f169
AM		 1933 1, /* size (0 = byte, 1 = short, 2 = long) */
1934 16, /* bitsize */
b34976b6 1935 FALSE, /* pc_relative */
5bd4f169 1936 0, /* bitpos */
f9c6b907 1937 complain_overflow_signed, /* complain_on_overflow */
805fc799 1938 ppc64_elf_unhandled_reloc, /* special_function */
411e1bfb 1939 "R_PPC64_GOT_TPREL16_HA", /* name */
b34976b6 1940 FALSE, /* partial_inplace */
d006db6c 1941 0, /* src_mask */
411e1bfb 1942 0xffff, /* dst_mask */
b34976b6 1943 FALSE), /* pcrel_offset */
5bd4f169 1944
25f23106
AM		 1945 HOWTO (R_PPC64_JMP_IREL, /* type */
1946 0, /* rightshift */
1947 0, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1948 0, /* bitsize */
1949 FALSE, /* pc_relative */
1950 0, /* bitpos */
1951 complain_overflow_dont, /* complain_on_overflow */
1952 ppc64_elf_unhandled_reloc, /* special_function */
1953 "R_PPC64_JMP_IREL", /* name */
1954 FALSE, /* partial_inplace */
1955 0, /* src_mask */
1956 0, /* dst_mask */
1957 FALSE), /* pcrel_offset */
1958
e054468f
AM		 1959 HOWTO (R_PPC64_IRELATIVE, /* type */
1960 0, /* rightshift */
1961 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1962 64, /* bitsize */
1963 FALSE, /* pc_relative */
1964 0, /* bitpos */
1965 complain_overflow_dont, /* complain_on_overflow */
1966 bfd_elf_generic_reloc, /* special_function */
1967 "R_PPC64_IRELATIVE", /* name */
1968 FALSE, /* partial_inplace */
1969 0, /* src_mask */
1970 ONES (64), /* dst_mask */
1971 FALSE), /* pcrel_offset */
1972
25f23106
AM		 1973 /* A 16 bit relative relocation. */
1974 HOWTO (R_PPC64_REL16, /* type */
1975 0, /* rightshift */
1976 1, /* size (0 = byte, 1 = short, 2 = long) */
1977 16, /* bitsize */
1978 TRUE, /* pc_relative */
1979 0, /* bitpos */
b80eed39 1980 complain_overflow_signed, /* complain_on_overflow */
25f23106
AM		 1981 bfd_elf_generic_reloc, /* special_function */
1982 "R_PPC64_REL16", /* name */
1983 FALSE, /* partial_inplace */
1984 0, /* src_mask */
1985 0xffff, /* dst_mask */
1986 TRUE), /* pcrel_offset */
1987
1988 /* A 16 bit relative relocation without overflow. */
1989 HOWTO (R_PPC64_REL16_LO, /* type */
1990 0, /* rightshift */
1991 1, /* size (0 = byte, 1 = short, 2 = long) */
1992 16, /* bitsize */
1993 TRUE, /* pc_relative */
1994 0, /* bitpos */
1995 complain_overflow_dont,/* complain_on_overflow */
1996 bfd_elf_generic_reloc, /* special_function */
1997 "R_PPC64_REL16_LO", /* name */
1998 FALSE, /* partial_inplace */
1999 0, /* src_mask */
2000 0xffff, /* dst_mask */
2001 TRUE), /* pcrel_offset */
2002
2003 /* The high order 16 bits of a relative address. */
2004 HOWTO (R_PPC64_REL16_HI, /* type */
2005 16, /* rightshift */
2006 1, /* size (0 = byte, 1 = short, 2 = long) */
2007 16, /* bitsize */
2008 TRUE, /* pc_relative */
2009 0, /* bitpos */
f9c6b907 2010 complain_overflow_signed, /* complain_on_overflow */
25f23106
AM		 2011 bfd_elf_generic_reloc, /* special_function */
2012 "R_PPC64_REL16_HI", /* name */
2013 FALSE, /* partial_inplace */
2014 0, /* src_mask */
2015 0xffff, /* dst_mask */
2016 TRUE), /* pcrel_offset */
2017
2018 /* The high order 16 bits of a relative address, plus 1 if the contents of
2019 the low 16 bits, treated as a signed number, is negative. */
2020 HOWTO (R_PPC64_REL16_HA, /* type */
2021 16, /* rightshift */
2022 1, /* size (0 = byte, 1 = short, 2 = long) */
2023 16, /* bitsize */
2024 TRUE, /* pc_relative */
2025 0, /* bitpos */
f9c6b907 2026 complain_overflow_signed, /* complain_on_overflow */
25f23106
AM		 2027 ppc64_elf_ha_reloc, /* special_function */
2028 "R_PPC64_REL16_HA", /* name */
2029 FALSE, /* partial_inplace */
2030 0, /* src_mask */
2031 0xffff, /* dst_mask */
2032 TRUE), /* pcrel_offset */
2033
a680de9a
PB		 2034 /* Like R_PPC64_REL16_HA but for split field in addpcis. */
2035 HOWTO (R_PPC64_REL16DX_HA, /* type */
2036 16, /* rightshift */
2037 2, /* size (0 = byte, 1 = short, 2 = long) */
2038 16, /* bitsize */
2039 TRUE, /* pc_relative */
2040 0, /* bitpos */
2041 complain_overflow_signed, /* complain_on_overflow */
2042 ppc64_elf_ha_reloc, /* special_function */
2043 "R_PPC64_REL16DX_HA", /* name */
2044 FALSE, /* partial_inplace */
2045 0, /* src_mask */
2046 0x1fffc1, /* dst_mask */
2047 TRUE), /* pcrel_offset */
2048
7ba71655
AM		 2049 /* A split-field reloc for addpcis, non-relative (gas internal use only). */
2050 HOWTO (R_PPC64_16DX_HA, /* type */
2051 16, /* rightshift */
2052 2, /* size (0 = byte, 1 = short, 2 = long) */
2053 16, /* bitsize */
2054 FALSE, /* pc_relative */
2055 0, /* bitpos */
2056 complain_overflow_signed, /* complain_on_overflow */
2057 ppc64_elf_ha_reloc, /* special_function */
2058 "R_PPC64_16DX_HA", /* name */
2059 FALSE, /* partial_inplace */
2060 0, /* src_mask */
2061 0x1fffc1, /* dst_mask */
2062 FALSE), /* pcrel_offset */
2063
f9c6b907
AM		 2064 /* Like R_PPC64_ADDR16_HI, but no overflow. */
2065 HOWTO (R_PPC64_ADDR16_HIGH, /* type */
2066 16, /* rightshift */
2067 1, /* size (0 = byte, 1 = short, 2 = long) */
2068 16, /* bitsize */
2069 FALSE, /* pc_relative */
2070 0, /* bitpos */
2071 complain_overflow_dont, /* complain_on_overflow */
2072 bfd_elf_generic_reloc, /* special_function */
2073 "R_PPC64_ADDR16_HIGH", /* name */
2074 FALSE, /* partial_inplace */
2075 0, /* src_mask */
2076 0xffff, /* dst_mask */
2077 FALSE), /* pcrel_offset */
2078
2079 /* Like R_PPC64_ADDR16_HA, but no overflow. */
2080 HOWTO (R_PPC64_ADDR16_HIGHA, /* type */
2081 16, /* rightshift */
2082 1, /* size (0 = byte, 1 = short, 2 = long) */
2083 16, /* bitsize */
2084 FALSE, /* pc_relative */
2085 0, /* bitpos */
2086 complain_overflow_dont, /* complain_on_overflow */
2087 ppc64_elf_ha_reloc, /* special_function */
2088 "R_PPC64_ADDR16_HIGHA", /* name */
2089 FALSE, /* partial_inplace */
2090 0, /* src_mask */
2091 0xffff, /* dst_mask */
2092 FALSE), /* pcrel_offset */
2093
2094 /* Like R_PPC64_DTPREL16_HI, but no overflow. */
2095 HOWTO (R_PPC64_DTPREL16_HIGH,
2096 16, /* rightshift */
2097 1, /* size (0 = byte, 1 = short, 2 = long) */
2098 16, /* bitsize */
2099 FALSE, /* pc_relative */
2100 0, /* bitpos */
2101 complain_overflow_dont, /* complain_on_overflow */
2102 ppc64_elf_unhandled_reloc, /* special_function */
2103 "R_PPC64_DTPREL16_HIGH", /* name */
2104 FALSE, /* partial_inplace */
2105 0, /* src_mask */
2106 0xffff, /* dst_mask */
2107 FALSE), /* pcrel_offset */
2108
2109 /* Like R_PPC64_DTPREL16_HA, but no overflow. */
2110 HOWTO (R_PPC64_DTPREL16_HIGHA,
2111 16, /* rightshift */
2112 1, /* size (0 = byte, 1 = short, 2 = long) */
2113 16, /* bitsize */
2114 FALSE, /* pc_relative */
2115 0, /* bitpos */
2116 complain_overflow_dont, /* complain_on_overflow */
2117 ppc64_elf_unhandled_reloc, /* special_function */
2118 "R_PPC64_DTPREL16_HIGHA", /* name */
2119 FALSE, /* partial_inplace */
2120 0, /* src_mask */
2121 0xffff, /* dst_mask */
2122 FALSE), /* pcrel_offset */
2123
2124 /* Like R_PPC64_TPREL16_HI, but no overflow. */
2125 HOWTO (R_PPC64_TPREL16_HIGH,
2126 16, /* rightshift */
2127 1, /* size (0 = byte, 1 = short, 2 = long) */
2128 16, /* bitsize */
2129 FALSE, /* pc_relative */
2130 0, /* bitpos */
2131 complain_overflow_dont, /* complain_on_overflow */
2132 ppc64_elf_unhandled_reloc, /* special_function */
2133 "R_PPC64_TPREL16_HIGH", /* name */
2134 FALSE, /* partial_inplace */
2135 0, /* src_mask */
2136 0xffff, /* dst_mask */
2137 FALSE), /* pcrel_offset */
2138
2139 /* Like R_PPC64_TPREL16_HA, but no overflow. */
2140 HOWTO (R_PPC64_TPREL16_HIGHA,
2141 16, /* rightshift */
2142 1, /* size (0 = byte, 1 = short, 2 = long) */
2143 16, /* bitsize */
2144 FALSE, /* pc_relative */
2145 0, /* bitpos */
2146 complain_overflow_dont, /* complain_on_overflow */
2147 ppc64_elf_unhandled_reloc, /* special_function */
2148 "R_PPC64_TPREL16_HIGHA", /* name */
2149 FALSE, /* partial_inplace */
2150 0, /* src_mask */
2151 0xffff, /* dst_mask */
2152 FALSE), /* pcrel_offset */
2153
006589cf
AM		 2154 /* Marker reloc on ELFv2 large-model function entry. */
2155 HOWTO (R_PPC64_ENTRY,
2156 0, /* rightshift */
2157 2, /* size (0 = byte, 1 = short, 2 = long) */
2158 32, /* bitsize */
2159 FALSE, /* pc_relative */
2160 0, /* bitpos */
2161 complain_overflow_dont, /* complain_on_overflow */
2162 bfd_elf_generic_reloc, /* special_function */
2163 "R_PPC64_ENTRY", /* name */
2164 FALSE, /* partial_inplace */
2165 0, /* src_mask */
2166 0, /* dst_mask */
2167 FALSE), /* pcrel_offset */
2168
45965137
AM		 2169 /* Like ADDR64, but use local entry point of function. */
2170 HOWTO (R_PPC64_ADDR64_LOCAL, /* type */
2171 0, /* rightshift */
2172 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
2173 64, /* bitsize */
2174 FALSE, /* pc_relative */
2175 0, /* bitpos */
2176 complain_overflow_dont, /* complain_on_overflow */
2177 bfd_elf_generic_reloc, /* special_function */
2178 "R_PPC64_ADDR64_LOCAL", /* name */
2179 FALSE, /* partial_inplace */
2180 0, /* src_mask */
2181 ONES (64), /* dst_mask */
2182 FALSE), /* pcrel_offset */
2183
5bd4f169
AM		 2184 /* GNU extension to record C++ vtable hierarchy. */
2185 HOWTO (R_PPC64_GNU_VTINHERIT, /* type */
2186 0, /* rightshift */
2187 0, /* size (0 = byte, 1 = short, 2 = long) */
2188 0, /* bitsize */
b34976b6 2189 FALSE, /* pc_relative */
5bd4f169
AM		 2190 0, /* bitpos */
2191 complain_overflow_dont, /* complain_on_overflow */
2192 NULL, /* special_function */
2193 "R_PPC64_GNU_VTINHERIT", /* name */
b34976b6 2194 FALSE, /* partial_inplace */
5bd4f169
AM		 2195 0, /* src_mask */
2196 0, /* dst_mask */
b34976b6 2197 FALSE), /* pcrel_offset */
5bd4f169
AM		 2198
2199 /* GNU extension to record C++ vtable member usage. */
2200 HOWTO (R_PPC64_GNU_VTENTRY, /* type */
2201 0, /* rightshift */
2202 0, /* size (0 = byte, 1 = short, 2 = long) */
2203 0, /* bitsize */
b34976b6 2204 FALSE, /* pc_relative */
5bd4f169
AM		 2205 0, /* bitpos */
2206 complain_overflow_dont, /* complain_on_overflow */
2207 NULL, /* special_function */
2208 "R_PPC64_GNU_VTENTRY", /* name */
b34976b6 2209 FALSE, /* partial_inplace */
5bd4f169
AM		 2210 0, /* src_mask */
2211 0, /* dst_mask */
b34976b6 2212 FALSE), /* pcrel_offset */
5bd4f169
AM		 2213};
2214
2215\f
2216/* Initialize the ppc64_elf_howto_table, so that linear accesses can
2217 be done. */
2218
2219static void
4ce794b7 2220ppc_howto_init (void)
5bd4f169
AM		 2221{
2222 unsigned int i, type;
2223
a4b6fadd 2224 for (i = 0; i < ARRAY_SIZE (ppc64_elf_howto_raw); i++)
5bd4f169
AM		 2225 {
2226 type = ppc64_elf_howto_raw[i].type;
a4b6fadd 2227 BFD_ASSERT (type < ARRAY_SIZE (ppc64_elf_howto_table));
5bd4f169
AM		 2228 ppc64_elf_howto_table[type] = &ppc64_elf_howto_raw[i];
2229 }
2230}
2231
2232static reloc_howto_type *
4ce794b7
AM		 2233ppc64_elf_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2234 bfd_reloc_code_real_type code)
5bd4f169 2235{
411e1bfb 2236 enum elf_ppc64_reloc_type r = R_PPC64_NONE;
5bd4f169
AM		 2237
2238 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2239 /* Initialize howto table if needed. */
2240 ppc_howto_init ();
2241
4ce794b7 2242 switch (code)
5bd4f169
AM		 2243 {
2244 default:
4ce794b7 2245 return NULL;
5bd4f169 2246
411e1bfb
AM		 2247 case BFD_RELOC_NONE: r = R_PPC64_NONE;
2248 break;
2249 case BFD_RELOC_32: r = R_PPC64_ADDR32;
2250 break;
2251 case BFD_RELOC_PPC_BA26: r = R_PPC64_ADDR24;
2252 break;
2253 case BFD_RELOC_16: r = R_PPC64_ADDR16;
2254 break;
2255 case BFD_RELOC_LO16: r = R_PPC64_ADDR16_LO;
2256 break;
2257 case BFD_RELOC_HI16: r = R_PPC64_ADDR16_HI;
2258 break;
f9c6b907
AM		 2259 case BFD_RELOC_PPC64_ADDR16_HIGH: r = R_PPC64_ADDR16_HIGH;
2260 break;
411e1bfb 2261 case BFD_RELOC_HI16_S: r = R_PPC64_ADDR16_HA;
5bd4f169 2262 break;
f9c6b907
AM		 2263 case BFD_RELOC_PPC64_ADDR16_HIGHA: r = R_PPC64_ADDR16_HIGHA;
2264 break;
411e1bfb 2265 case BFD_RELOC_PPC_BA16: r = R_PPC64_ADDR14;
5bd4f169 2266 break;
411e1bfb 2267 case BFD_RELOC_PPC_BA16_BRTAKEN: r = R_PPC64_ADDR14_BRTAKEN;
5bd4f169 2268 break;
411e1bfb 2269 case BFD_RELOC_PPC_BA16_BRNTAKEN: r = R_PPC64_ADDR14_BRNTAKEN;
5bd4f169 2270 break;
411e1bfb 2271 case BFD_RELOC_PPC_B26: r = R_PPC64_REL24;
5bd4f169 2272 break;
411e1bfb 2273 case BFD_RELOC_PPC_B16: r = R_PPC64_REL14;
5bd4f169 2274 break;
411e1bfb 2275 case BFD_RELOC_PPC_B16_BRTAKEN: r = R_PPC64_REL14_BRTAKEN;
5bd4f169 2276 break;
411e1bfb 2277 case BFD_RELOC_PPC_B16_BRNTAKEN: r = R_PPC64_REL14_BRNTAKEN;
5bd4f169 2278 break;
411e1bfb 2279 case BFD_RELOC_16_GOTOFF: r = R_PPC64_GOT16;
5bd4f169 2280 break;
411e1bfb 2281 case BFD_RELOC_LO16_GOTOFF: r = R_PPC64_GOT16_LO;
5bd4f169 2282 break;
411e1bfb 2283 case BFD_RELOC_HI16_GOTOFF: r = R_PPC64_GOT16_HI;
5bd4f169 2284 break;
411e1bfb 2285 case BFD_RELOC_HI16_S_GOTOFF: r = R_PPC64_GOT16_HA;
5bd4f169 2286 break;
411e1bfb 2287 case BFD_RELOC_PPC_COPY: r = R_PPC64_COPY;
5bd4f169 2288 break;
411e1bfb 2289 case BFD_RELOC_PPC_GLOB_DAT: r = R_PPC64_GLOB_DAT;
5bd4f169 2290 break;
411e1bfb 2291 case BFD_RELOC_32_PCREL: r = R_PPC64_REL32;
5bd4f169 2292 break;
411e1bfb 2293 case BFD_RELOC_32_PLTOFF: r = R_PPC64_PLT32;
5bd4f169 2294 break;
411e1bfb 2295 case BFD_RELOC_32_PLT_PCREL: r = R_PPC64_PLTREL32;
5bd4f169 2296 break;
411e1bfb 2297 case BFD_RELOC_LO16_PLTOFF: r = R_PPC64_PLT16_LO;
5bd4f169 2298 break;
411e1bfb 2299 case BFD_RELOC_HI16_PLTOFF: r = R_PPC64_PLT16_HI;
5bd4f169 2300 break;
411e1bfb 2301 case BFD_RELOC_HI16_S_PLTOFF: r = R_PPC64_PLT16_HA;
5bd4f169 2302 break;
411e1bfb 2303 case BFD_RELOC_16_BASEREL: r = R_PPC64_SECTOFF;
5bd4f169 2304 break;
411e1bfb 2305 case BFD_RELOC_LO16_BASEREL: r = R_PPC64_SECTOFF_LO;
5bd4f169 2306 break;
411e1bfb 2307 case BFD_RELOC_HI16_BASEREL: r = R_PPC64_SECTOFF_HI;
5bd4f169 2308 break;
411e1bfb 2309 case BFD_RELOC_HI16_S_BASEREL: r = R_PPC64_SECTOFF_HA;
5bd4f169 2310 break;
411e1bfb 2311 case BFD_RELOC_CTOR: r = R_PPC64_ADDR64;
5bd4f169 2312 break;
411e1bfb 2313 case BFD_RELOC_64: r = R_PPC64_ADDR64;
5bd4f169 2314 break;
411e1bfb 2315 case BFD_RELOC_PPC64_HIGHER: r = R_PPC64_ADDR16_HIGHER;
5bd4f169 2316 break;
411e1bfb 2317 case BFD_RELOC_PPC64_HIGHER_S: r = R_PPC64_ADDR16_HIGHERA;
5bd4f169 2318 break;
411e1bfb 2319 case BFD_RELOC_PPC64_HIGHEST: r = R_PPC64_ADDR16_HIGHEST;
5bd4f169 2320 break;
411e1bfb 2321 case BFD_RELOC_PPC64_HIGHEST_S: r = R_PPC64_ADDR16_HIGHESTA;
5bd4f169 2322 break;
411e1bfb 2323 case BFD_RELOC_64_PCREL: r = R_PPC64_REL64;
5bd4f169 2324 break;
411e1bfb 2325 case BFD_RELOC_64_PLTOFF: r = R_PPC64_PLT64;
5bd4f169 2326 break;
411e1bfb 2327 case BFD_RELOC_64_PLT_PCREL: r = R_PPC64_PLTREL64;
5bd4f169 2328 break;
411e1bfb 2329 case BFD_RELOC_PPC_TOC16: r = R_PPC64_TOC16;
5bd4f169 2330 break;
411e1bfb 2331 case BFD_RELOC_PPC64_TOC16_LO: r = R_PPC64_TOC16_LO;
5bd4f169 2332 break;
411e1bfb 2333 case BFD_RELOC_PPC64_TOC16_HI: r = R_PPC64_TOC16_HI;
5bd4f169 2334 break;
411e1bfb 2335 case BFD_RELOC_PPC64_TOC16_HA: r = R_PPC64_TOC16_HA;
5bd4f169 2336 break;
411e1bfb 2337 case BFD_RELOC_PPC64_TOC: r = R_PPC64_TOC;
5bd4f169 2338 break;
411e1bfb 2339 case BFD_RELOC_PPC64_PLTGOT16: r = R_PPC64_PLTGOT16;
5bd4f169 2340 break;
411e1bfb 2341 case BFD_RELOC_PPC64_PLTGOT16_LO: r = R_PPC64_PLTGOT16_LO;
5bd4f169 2342 break;
411e1bfb 2343 case BFD_RELOC_PPC64_PLTGOT16_HI: r = R_PPC64_PLTGOT16_HI;
5bd4f169 2344 break;
411e1bfb 2345 case BFD_RELOC_PPC64_PLTGOT16_HA: r = R_PPC64_PLTGOT16_HA;
5bd4f169 2346 break;
411e1bfb 2347 case BFD_RELOC_PPC64_ADDR16_DS: r = R_PPC64_ADDR16_DS;
5bd4f169 2348 break;
411e1bfb 2349 case BFD_RELOC_PPC64_ADDR16_LO_DS: r = R_PPC64_ADDR16_LO_DS;
5bd4f169 2350 break;
411e1bfb 2351 case BFD_RELOC_PPC64_GOT16_DS: r = R_PPC64_GOT16_DS;
5bd4f169 2352 break;
411e1bfb 2353 case BFD_RELOC_PPC64_GOT16_LO_DS: r = R_PPC64_GOT16_LO_DS;
5bd4f169 2354 break;
411e1bfb 2355 case BFD_RELOC_PPC64_PLT16_LO_DS: r = R_PPC64_PLT16_LO_DS;
5bd4f169 2356 break;
411e1bfb 2357 case BFD_RELOC_PPC64_SECTOFF_DS: r = R_PPC64_SECTOFF_DS;
5bd4f169 2358 break;
411e1bfb 2359 case BFD_RELOC_PPC64_SECTOFF_LO_DS: r = R_PPC64_SECTOFF_LO_DS;
5bd4f169 2360 break;
411e1bfb 2361 case BFD_RELOC_PPC64_TOC16_DS: r = R_PPC64_TOC16_DS;
5bd4f169 2362 break;
411e1bfb 2363 case BFD_RELOC_PPC64_TOC16_LO_DS: r = R_PPC64_TOC16_LO_DS;
5bd4f169 2364 break;
411e1bfb 2365 case BFD_RELOC_PPC64_PLTGOT16_DS: r = R_PPC64_PLTGOT16_DS;
5bd4f169 2366 break;
411e1bfb 2367 case BFD_RELOC_PPC64_PLTGOT16_LO_DS: r = R_PPC64_PLTGOT16_LO_DS;
5bd4f169 2368 break;
411e1bfb 2369 case BFD_RELOC_PPC_TLS: r = R_PPC64_TLS;
5bd4f169 2370 break;
727fc41e
AM		 2371 case BFD_RELOC_PPC_TLSGD: r = R_PPC64_TLSGD;
2372 break;
2373 case BFD_RELOC_PPC_TLSLD: r = R_PPC64_TLSLD;
2374 break;
411e1bfb 2375 case BFD_RELOC_PPC_DTPMOD: r = R_PPC64_DTPMOD64;
5bd4f169 2376 break;
411e1bfb 2377 case BFD_RELOC_PPC_TPREL16: r = R_PPC64_TPREL16;
5bd4f169 2378 break;
411e1bfb 2379 case BFD_RELOC_PPC_TPREL16_LO: r = R_PPC64_TPREL16_LO;
5bd4f169 2380 break;
411e1bfb 2381 case BFD_RELOC_PPC_TPREL16_HI: r = R_PPC64_TPREL16_HI;
5bd4f169 2382 break;
f9c6b907
AM		 2383 case BFD_RELOC_PPC64_TPREL16_HIGH: r = R_PPC64_TPREL16_HIGH;
2384 break;
411e1bfb 2385 case BFD_RELOC_PPC_TPREL16_HA: r = R_PPC64_TPREL16_HA;
5bd4f169 2386 break;
f9c6b907
AM		 2387 case BFD_RELOC_PPC64_TPREL16_HIGHA: r = R_PPC64_TPREL16_HIGHA;
2388 break;
411e1bfb 2389 case BFD_RELOC_PPC_TPREL: r = R_PPC64_TPREL64;
5bd4f169 2390 break;
411e1bfb
AM		 2391 case BFD_RELOC_PPC_DTPREL16: r = R_PPC64_DTPREL16;
2392 break;
2393 case BFD_RELOC_PPC_DTPREL16_LO: r = R_PPC64_DTPREL16_LO;
2394 break;
2395 case BFD_RELOC_PPC_DTPREL16_HI: r = R_PPC64_DTPREL16_HI;
2396 break;
f9c6b907
AM		 2397 case BFD_RELOC_PPC64_DTPREL16_HIGH: r = R_PPC64_DTPREL16_HIGH;
2398 break;
411e1bfb
AM		 2399 case BFD_RELOC_PPC_DTPREL16_HA: r = R_PPC64_DTPREL16_HA;
2400 break;
f9c6b907
AM		 2401 case BFD_RELOC_PPC64_DTPREL16_HIGHA: r = R_PPC64_DTPREL16_HIGHA;
2402 break;
411e1bfb
AM		 2403 case BFD_RELOC_PPC_DTPREL: r = R_PPC64_DTPREL64;
2404 break;
2405 case BFD_RELOC_PPC_GOT_TLSGD16: r = R_PPC64_GOT_TLSGD16;
2406 break;
2407 case BFD_RELOC_PPC_GOT_TLSGD16_LO: r = R_PPC64_GOT_TLSGD16_LO;
2408 break;
2409 case BFD_RELOC_PPC_GOT_TLSGD16_HI: r = R_PPC64_GOT_TLSGD16_HI;
2410 break;
2411 case BFD_RELOC_PPC_GOT_TLSGD16_HA: r = R_PPC64_GOT_TLSGD16_HA;
2412 break;
2413 case BFD_RELOC_PPC_GOT_TLSLD16: r = R_PPC64_GOT_TLSLD16;
2414 break;
2415 case BFD_RELOC_PPC_GOT_TLSLD16_LO: r = R_PPC64_GOT_TLSLD16_LO;
2416 break;
2417 case BFD_RELOC_PPC_GOT_TLSLD16_HI: r = R_PPC64_GOT_TLSLD16_HI;
2418 break;
2419 case BFD_RELOC_PPC_GOT_TLSLD16_HA: r = R_PPC64_GOT_TLSLD16_HA;
2420 break;
2421 case BFD_RELOC_PPC_GOT_TPREL16: r = R_PPC64_GOT_TPREL16_DS;
2422 break;
2423 case BFD_RELOC_PPC_GOT_TPREL16_LO: r = R_PPC64_GOT_TPREL16_LO_DS;
2424 break;
2425 case BFD_RELOC_PPC_GOT_TPREL16_HI: r = R_PPC64_GOT_TPREL16_HI;
2426 break;
2427 case BFD_RELOC_PPC_GOT_TPREL16_HA: r = R_PPC64_GOT_TPREL16_HA;
2428 break;
2429 case BFD_RELOC_PPC_GOT_DTPREL16: r = R_PPC64_GOT_DTPREL16_DS;
2430 break;
2431 case BFD_RELOC_PPC_GOT_DTPREL16_LO: r = R_PPC64_GOT_DTPREL16_LO_DS;
2432 break;
2433 case BFD_RELOC_PPC_GOT_DTPREL16_HI: r = R_PPC64_GOT_DTPREL16_HI;
2434 break;
2435 case BFD_RELOC_PPC_GOT_DTPREL16_HA: r = R_PPC64_GOT_DTPREL16_HA;
2436 break;
2437 case BFD_RELOC_PPC64_TPREL16_DS: r = R_PPC64_TPREL16_DS;
2438 break;
2439 case BFD_RELOC_PPC64_TPREL16_LO_DS: r = R_PPC64_TPREL16_LO_DS;
2440 break;
2441 case BFD_RELOC_PPC64_TPREL16_HIGHER: r = R_PPC64_TPREL16_HIGHER;
2442 break;
2443 case BFD_RELOC_PPC64_TPREL16_HIGHERA: r = R_PPC64_TPREL16_HIGHERA;
2444 break;
2445 case BFD_RELOC_PPC64_TPREL16_HIGHEST: r = R_PPC64_TPREL16_HIGHEST;
2446 break;
2447 case BFD_RELOC_PPC64_TPREL16_HIGHESTA: r = R_PPC64_TPREL16_HIGHESTA;
2448 break;
2449 case BFD_RELOC_PPC64_DTPREL16_DS: r = R_PPC64_DTPREL16_DS;
2450 break;
2451 case BFD_RELOC_PPC64_DTPREL16_LO_DS: r = R_PPC64_DTPREL16_LO_DS;
2452 break;
2453 case BFD_RELOC_PPC64_DTPREL16_HIGHER: r = R_PPC64_DTPREL16_HIGHER;
2454 break;
2455 case BFD_RELOC_PPC64_DTPREL16_HIGHERA: r = R_PPC64_DTPREL16_HIGHERA;
2456 break;
2457 case BFD_RELOC_PPC64_DTPREL16_HIGHEST: r = R_PPC64_DTPREL16_HIGHEST;
2458 break;
2459 case BFD_RELOC_PPC64_DTPREL16_HIGHESTA: r = R_PPC64_DTPREL16_HIGHESTA;
2460 break;
25f23106
AM		 2461 case BFD_RELOC_16_PCREL: r = R_PPC64_REL16;
2462 break;
2463 case BFD_RELOC_LO16_PCREL: r = R_PPC64_REL16_LO;
2464 break;
2465 case BFD_RELOC_HI16_PCREL: r = R_PPC64_REL16_HI;
2466 break;
2467 case BFD_RELOC_HI16_S_PCREL: r = R_PPC64_REL16_HA;
2468 break;
7ba71655
AM		 2469 case BFD_RELOC_PPC_16DX_HA: r = R_PPC64_16DX_HA;
2470 break;
a680de9a
PB		 2471 case BFD_RELOC_PPC_REL16DX_HA: r = R_PPC64_REL16DX_HA;
2472 break;
006589cf
AM		 2473 case BFD_RELOC_PPC64_ENTRY: r = R_PPC64_ENTRY;
2474 break;
45965137
AM		 2475 case BFD_RELOC_PPC64_ADDR64_LOCAL: r = R_PPC64_ADDR64_LOCAL;
2476 break;
411e1bfb
AM		 2477 case BFD_RELOC_VTABLE_INHERIT: r = R_PPC64_GNU_VTINHERIT;
2478 break;
2479 case BFD_RELOC_VTABLE_ENTRY: r = R_PPC64_GNU_VTENTRY;
5bd4f169
AM		 2480 break;
2481 }
2482
4ce794b7 2483 return ppc64_elf_howto_table[r];
5bd4f169
AM		 2484};
2485
157090f7
AM		 2486static reloc_howto_type *
2487ppc64_elf_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2488 const char *r_name)
2489{
2490 unsigned int i;
2491
a4b6fadd 2492 for (i = 0; i < ARRAY_SIZE (ppc64_elf_howto_raw); i++)
157090f7
AM		 2493 if (ppc64_elf_howto_raw[i].name != NULL
2494 && strcasecmp (ppc64_elf_howto_raw[i].name, r_name) == 0)
2495 return &ppc64_elf_howto_raw[i];
2496
2497 return NULL;
2498}
2499
5bd4f169
AM		 2500/* Set the howto pointer for a PowerPC ELF reloc. */
2501
2502static void
4aef7643 2503ppc64_elf_info_to_howto (bfd *abfd, arelent *cache_ptr,
4ce794b7 2504 Elf_Internal_Rela *dst)
5bd4f169 2505{
65f38f15
AM		 2506 unsigned int type;
2507
ef60b7ff 2508 /* Initialize howto table if needed. */
5bd4f169 2509 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
5bd4f169
AM		 2510 ppc_howto_init ();
2511
65f38f15 2512 type = ELF64_R_TYPE (dst->r_info);
a4b6fadd 2513 if (type >= ARRAY_SIZE (ppc64_elf_howto_table))
d0fb9a8d 2514 {
695344c0 2515 /* xgettext:c-format */
4eca0228
AM		 2516 _bfd_error_handler (_("%B: invalid relocation type %d"),
2517 abfd, (int) type);
3ec2b351 2518 type = R_PPC64_NONE;
d0fb9a8d 2519 }
65f38f15 2520 cache_ptr->howto = ppc64_elf_howto_table[type];
5bd4f169
AM		 2521}
2522
04c9666a 2523/* Handle the R_PPC64_ADDR16_HA and similar relocs. */
5bd4f169
AM		 2524
2525static bfd_reloc_status_type
4ce794b7
AM		 2526ppc64_elf_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2527 void *data, asection *input_section,
2528 bfd *output_bfd, char **error_message)
5bd4f169 2529{
a680de9a
PB		 2530 enum elf_ppc64_reloc_type r_type;
2531 long insn;
2532 bfd_size_type octets;
3de43e7b 2533 bfd_vma value;
a680de9a 2534
805fc799
AM		 2535 /* If this is a relocatable link (output_bfd test tells us), just
2536 call the generic function. Any adjustment will be done at final
2537 link time. */
2538 if (output_bfd != NULL)
cedb70c5 2539 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
805fc799
AM		 2540 input_section, output_bfd, error_message);
2541
2542 /* Adjust the addend for sign extension of the low 16 bits.
2543 We won't actually be using the low 16 bits, so trashing them
2544 doesn't matter. */
2545 reloc_entry->addend += 0x8000;
a680de9a
PB		 2546 r_type = reloc_entry->howto->type;
2547 if (r_type != R_PPC64_REL16DX_HA)
2548 return bfd_reloc_continue;
2549
2550 value = 0;
2551 if (!bfd_is_com_section (symbol->section))
2552 value = symbol->value;
2553 value += (reloc_entry->addend
2554 + symbol->section->output_offset
2555 + symbol->section->output_section->vma);
2556 value -= (reloc_entry->address
2557 + input_section->output_offset
2558 + input_section->output_section->vma);
3de43e7b 2559 value = (bfd_signed_vma) value >> 16;
a680de9a
PB		 2560
2561 octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2562 insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
2563 insn &= ~0x1fffc1;
3de43e7b 2564 insn |= (value & 0xffc1) | ((value & 0x3e) << 15);
a680de9a 2565 bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
3de43e7b 2566 if (value + 0x8000 > 0xffff)
a680de9a
PB		 2567 return bfd_reloc_overflow;
2568 return bfd_reloc_ok;
805fc799 2569}
5bd4f169 2570
2441e016
AM		 2571static bfd_reloc_status_type
2572ppc64_elf_branch_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2573 void *data, asection *input_section,
2574 bfd *output_bfd, char **error_message)
2575{
2576 if (output_bfd != NULL)
2577 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2578 input_section, output_bfd, error_message);
2579
699733f6
AM		 2580 if (strcmp (symbol->section->name, ".opd") == 0
2581 && (symbol->section->owner->flags & DYNAMIC) == 0)
2441e016
AM		 2582 {
2583 bfd_vma dest = opd_entry_value (symbol->section,
2584 symbol->value + reloc_entry->addend,
aef36ac1 2585 NULL, NULL, FALSE);
2441e016
AM		 2586 if (dest != (bfd_vma) -1)
2587 reloc_entry->addend = dest - (symbol->value
2588 + symbol->section->output_section->vma
2589 + symbol->section->output_offset);
2590 }
810d4e75
AM		 2591 else
2592 {
2593 elf_symbol_type *elfsym = (elf_symbol_type *) symbol;
2594
2595 if (symbol->section->owner != abfd
9f284bf9 2596 && symbol->section->owner != NULL
810d4e75
AM		 2597 && abiversion (symbol->section->owner) >= 2)
2598 {
2599 unsigned int i;
2600
2601 for (i = 0; i < symbol->section->owner->symcount; ++i)
2602 {
2603 asymbol *symdef = symbol->section->owner->outsymbols[i];
2604
2605 if (strcmp (symdef->name, symbol->name) == 0)
2606 {
2607 elfsym = (elf_symbol_type *) symdef;
2608 break;
2609 }
2610 }
2611 }
2612 reloc_entry->addend
2613 += PPC64_LOCAL_ENTRY_OFFSET (elfsym->internal_elf_sym.st_other);
2614 }
2441e016
AM		 2615 return bfd_reloc_continue;
2616}
2617
805fc799 2618static bfd_reloc_status_type
4ce794b7
AM		 2619ppc64_elf_brtaken_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2620 void *data, asection *input_section,
2621 bfd *output_bfd, char **error_message)
805fc799
AM		 2622{
2623 long insn;
04c9666a 2624 enum elf_ppc64_reloc_type r_type;
805fc799 2625 bfd_size_type octets;
794e51c0
AM		 2626 /* Assume 'at' branch hints. */
2627 bfd_boolean is_isa_v2 = TRUE;
805fc799
AM		 2628
2629 /* If this is a relocatable link (output_bfd test tells us), just
2630 call the generic function. Any adjustment will be done at final
2631 link time. */
5bd4f169 2632 if (output_bfd != NULL)
cedb70c5 2633 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
805fc799
AM		 2634 input_section, output_bfd, error_message);
2635
2636 octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2637 insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
2638 insn &= ~(0x01 << 21);
4ce794b7 2639 r_type = reloc_entry->howto->type;
805fc799
AM		 2640 if (r_type == R_PPC64_ADDR14_BRTAKEN
2641 || r_type == R_PPC64_REL14_BRTAKEN)
cedb70c5 2642 insn |= 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field. */
805fc799 2643
794e51c0 2644 if (is_isa_v2)
5bd4f169 2645 {
805fc799
AM		 2646 /* Set 'a' bit. This is 0b00010 in BO field for branch
2647 on CR(BI) insns (BO == 001at or 011at), and 0b01000
2648 for branch on CTR insns (BO == 1a00t or 1a01t). */
2649 if ((insn & (0x14 << 21)) == (0x04 << 21))
2650 insn |= 0x02 << 21;
2651 else if ((insn & (0x14 << 21)) == (0x10 << 21))
2652 insn |= 0x08 << 21;
2653 else
2441e016 2654 goto out;
5bd4f169 2655 }
805fc799
AM		 2656 else
2657 {
2658 bfd_vma target = 0;
2659 bfd_vma from;
5bd4f169 2660
805fc799
AM		 2661 if (!bfd_is_com_section (symbol->section))
2662 target = symbol->value;
2663 target += symbol->section->output_section->vma;
2664 target += symbol->section->output_offset;
2665 target += reloc_entry->addend;
5bd4f169 2666
805fc799
AM		 2667 from = (reloc_entry->address
2668 + input_section->output_offset
2669 + input_section->output_section->vma);
5bd4f169 2670
805fc799
AM		 2671 /* Invert 'y' bit if not the default. */
2672 if ((bfd_signed_vma) (target - from) < 0)
2673 insn ^= 0x01 << 21;
2674 }
4ce794b7 2675 bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
2441e016
AM		 2676 out:
2677 return ppc64_elf_branch_reloc (abfd, reloc_entry, symbol, data,
2678 input_section, output_bfd, error_message);
805fc799 2679}
5bd4f169 2680
805fc799 2681static bfd_reloc_status_type
4ce794b7
AM		 2682ppc64_elf_sectoff_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2683 void *data, asection *input_section,
2684 bfd *output_bfd, char **error_message)
805fc799
AM		 2685{
2686 /* If this is a relocatable link (output_bfd test tells us), just
2687 call the generic function. Any adjustment will be done at final
2688 link time. */
2689 if (output_bfd != NULL)
cedb70c5 2690 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
805fc799 2691 input_section, output_bfd, error_message);
5bd4f169 2692
805fc799
AM		 2693 /* Subtract the symbol section base address. */
2694 reloc_entry->addend -= symbol->section->output_section->vma;
5bd4f169
AM		 2695 return bfd_reloc_continue;
2696}
2697
805fc799 2698static bfd_reloc_status_type
4ce794b7
AM		 2699ppc64_elf_sectoff_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2700 void *data, asection *input_section,
2701 bfd *output_bfd, char **error_message)
805fc799
AM		 2702{
2703 /* If this is a relocatable link (output_bfd test tells us), just
2704 call the generic function. Any adjustment will be done at final
2705 link time. */
2706 if (output_bfd != NULL)
cedb70c5 2707 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
805fc799
AM		 2708 input_section, output_bfd, error_message);
2709
2710 /* Subtract the symbol section base address. */
2711 reloc_entry->addend -= symbol->section->output_section->vma;
2712
2713 /* Adjust the addend for sign extension of the low 16 bits. */
2714 reloc_entry->addend += 0x8000;
2715 return bfd_reloc_continue;
2716}
2717
2718static bfd_reloc_status_type
4ce794b7
AM		 2719ppc64_elf_toc_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2720 void *data, asection *input_section,
2721 bfd *output_bfd, char **error_message)
805fc799
AM		 2722{
2723 bfd_vma TOCstart;
2724
2725 /* If this is a relocatable link (output_bfd test tells us), just
2726 call the generic function. Any adjustment will be done at final
2727 link time. */
2728 if (output_bfd != NULL)
cedb70c5 2729 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
805fc799
AM		 2730 input_section, output_bfd, error_message);
2731
2732 TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2733 if (TOCstart == 0)
1c865ab2 2734 TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
805fc799
AM		 2735
2736 /* Subtract the TOC base address. */
2737 reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2738 return bfd_reloc_continue;
2739}
2740
2741static bfd_reloc_status_type
4ce794b7
AM		 2742ppc64_elf_toc_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2743 void *data, asection *input_section,
2744 bfd *output_bfd, char **error_message)
805fc799
AM		 2745{
2746 bfd_vma TOCstart;
2747
2748 /* If this is a relocatable link (output_bfd test tells us), just
2749 call the generic function. Any adjustment will be done at final
2750 link time. */
2751 if (output_bfd != NULL)
cedb70c5 2752 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
805fc799
AM		 2753 input_section, output_bfd, error_message);
2754
2755 TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2756 if (TOCstart == 0)
1c865ab2 2757 TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
805fc799
AM		 2758
2759 /* Subtract the TOC base address. */
2760 reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2761
2762 /* Adjust the addend for sign extension of the low 16 bits. */
2763 reloc_entry->addend += 0x8000;
2764 return bfd_reloc_continue;
2765}
2766
2767static bfd_reloc_status_type
4ce794b7
AM		 2768ppc64_elf_toc64_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2769 void *data, asection *input_section,
2770 bfd *output_bfd, char **error_message)
805fc799
AM		 2771{
2772 bfd_vma TOCstart;
2773 bfd_size_type octets;
2774
2775 /* If this is a relocatable link (output_bfd test tells us), just
2776 call the generic function. Any adjustment will be done at final
2777 link time. */
2778 if (output_bfd != NULL)
cedb70c5 2779 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
805fc799
AM		 2780 input_section, output_bfd, error_message);
2781
2782 TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2783 if (TOCstart == 0)
1c865ab2 2784 TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
805fc799
AM		 2785
2786 octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2787 bfd_put_64 (abfd, TOCstart + TOC_BASE_OFF, (bfd_byte *) data + octets);
2788 return bfd_reloc_ok;
2789}
2790
2791static bfd_reloc_status_type
4ce794b7
AM		 2792ppc64_elf_unhandled_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2793 void *data, asection *input_section,
2794 bfd *output_bfd, char **error_message)
805fc799
AM		 2795{
2796 /* If this is a relocatable link (output_bfd test tells us), just
2797 call the generic function. Any adjustment will be done at final
2798 link time. */
2799 if (output_bfd != NULL)
cedb70c5 2800 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
805fc799
AM		 2801 input_section, output_bfd, error_message);
2802
2803 if (error_message != NULL)
2804 {
2805 static char buf[60];
2806 sprintf (buf, "generic linker can't handle %s",
2807 reloc_entry->howto->name);
2808 *error_message = buf;
2809 }
2810 return bfd_reloc_dangerous;
2811}
2812
927be08e
AM		 2813/* Track GOT entries needed for a given symbol. We might need more
2814 than one got entry per symbol. */
2815struct got_entry
2816{
2817 struct got_entry *next;
2818
2819 /* The symbol addend that we'll be placing in the GOT. */
2820 bfd_vma addend;
2821
2822 /* Unlike other ELF targets, we use separate GOT entries for the same
2823 symbol referenced from different input files. This is to support
2824 automatic multiple TOC/GOT sections, where the TOC base can vary
2825 from one input file to another. After partitioning into TOC groups
2826 we merge entries within the group.
2827
2828 Point to the BFD owning this GOT entry. */
2829 bfd *owner;
2830
2831 /* Zero for non-tls entries, or TLS_TLS and one of TLS_GD, TLS_LD,
2832 TLS_TPREL or TLS_DTPREL for tls entries. */
f961d9dd 2833 unsigned char tls_type;
927be08e
AM		 2834
2835 /* Non-zero if got.ent points to real entry. */
f961d9dd 2836 unsigned char is_indirect;
927be08e
AM		 2837
2838 /* Reference count until size_dynamic_sections, GOT offset thereafter. */
2839 union
2840 {
2841 bfd_signed_vma refcount;
2842 bfd_vma offset;
2843 struct got_entry *ent;
2844 } got;
2845};
2846
2847/* The same for PLT. */
2848struct plt_entry
2849{
2850 struct plt_entry *next;
2851
2852 bfd_vma addend;
2853
2854 union
2855 {
2856 bfd_signed_vma refcount;
2857 bfd_vma offset;
2858 } plt;
2859};
2860
e717da7e
AM		 2861struct ppc64_elf_obj_tdata
2862{
2863 struct elf_obj_tdata elf;
2864
2865 /* Shortcuts to dynamic linker sections. */
2866 asection *got;
2867 asection *relgot;
2868
b3fac117
AM		 2869 /* Used during garbage collection. We attach global symbols defined
2870 on removed .opd entries to this section so that the sym is removed. */
2871 asection *deleted_section;
81688140 2872
927be08e 2873 /* TLS local dynamic got entry handling. Support for multiple GOT
e717da7e 2874 sections means we potentially need one of these for each input bfd. */
927be08e 2875 struct got_entry tlsld_got;
8860955f 2876
729eabd5
AM		 2877 union {
2878 /* A copy of relocs before they are modified for --emit-relocs. */
2879 Elf_Internal_Rela *relocs;
2880
2881 /* Section contents. */
2882 bfd_byte *contents;
2883 } opd;
d77c8a4b
AM		 2884
2885 /* Nonzero if this bfd has small toc/got relocs, ie. that expect
2886 the reloc to be in the range -32768 to 32767. */
98528052
AM		 2887 unsigned int has_small_toc_reloc : 1;
2888
560c8763
AM		 2889 /* Set if toc/got ha relocs detected not using r2, or lo reloc
2890 instruction not one we handle. */
2891 unsigned int unexpected_toc_insn : 1;
e717da7e
AM		 2892};
2893
2894#define ppc64_elf_tdata(bfd) \
2895 ((struct ppc64_elf_obj_tdata *) (bfd)->tdata.any)
2896
2897#define ppc64_tlsld_got(bfd) \
2898 (&ppc64_elf_tdata (bfd)->tlsld_got)
2899
0c8d6e5c
AM		 2900#define is_ppc64_elf(bfd) \
2901 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
4dfe6ac6 2902 && elf_object_id (bfd) == PPC64_ELF_DATA)
0c8d6e5c 2903
e717da7e
AM		 2904/* Override the generic function because we store some extras. */
2905
2906static bfd_boolean
2907ppc64_elf_mkobject (bfd *abfd)
2908{
0ffa91dd 2909 return bfd_elf_allocate_object (abfd, sizeof (struct ppc64_elf_obj_tdata),
4dfe6ac6 2910 PPC64_ELF_DATA);
e717da7e
AM		 2911}
2912
feee612b 2913/* Fix bad default arch selected for a 64 bit input bfd when the
14b57c7c 2914 default is 32 bit. Also select arch based on apuinfo. */
feee612b 2915
b34976b6 2916static bfd_boolean
4ce794b7 2917ppc64_elf_object_p (bfd *abfd)
feee612b 2918{
14b57c7c
AM		 2919 if (!abfd->arch_info->the_default)
2920 return TRUE;
2921
2922 if (abfd->arch_info->bits_per_word == 32)
feee612b
AM		 2923 {
2924 Elf_Internal_Ehdr *i_ehdr = elf_elfheader (abfd);
2925
2926 if (i_ehdr->e_ident[EI_CLASS] == ELFCLASS64)
2927 {
2928 /* Relies on arch after 32 bit default being 64 bit default. */
2929 abfd->arch_info = abfd->arch_info->next;
2930 BFD_ASSERT (abfd->arch_info->bits_per_word == 64);
2931 }
2932 }
14b57c7c 2933 return _bfd_elf_ppc_set_arch (abfd);
feee612b
AM		 2934}
2935
d37c89e5
AM		 2936/* Support for core dump NOTE sections. */
2937
2938static bfd_boolean
2939ppc64_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
2940{
eea6121a 2941 size_t offset, size;
d37c89e5
AM		 2942
2943 if (note->descsz != 504)
2944 return FALSE;
2945
2946 /* pr_cursig */
228e534f 2947 elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
d37c89e5
AM		 2948
2949 /* pr_pid */
228e534f 2950 elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 32);
d37c89e5
AM		 2951
2952 /* pr_reg */
2953 offset = 112;
eea6121a 2954 size = 384;
d37c89e5
AM		 2955
2956 /* Make a ".reg/999" section. */
2957 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
eea6121a 2958 size, note->descpos + offset);
d37c89e5
AM		 2959}
2960
2961static bfd_boolean
2962ppc64_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
2963{
2964 if (note->descsz != 136)
2965 return FALSE;
2966
228e534f 2967 elf_tdata (abfd)->core->pid
bc989cdc 2968 = bfd_get_32 (abfd, note->descdata + 24);
228e534f 2969 elf_tdata (abfd)->core->program
d37c89e5 2970 = _bfd_elfcore_strndup (abfd, note->descdata + 40, 16);
228e534f 2971 elf_tdata (abfd)->core->command
d37c89e5
AM		 2972 = _bfd_elfcore_strndup (abfd, note->descdata + 56, 80);
2973
2974 return TRUE;
2975}
2976
183e98be
AM		 2977static char *
2978ppc64_elf_write_core_note (bfd *abfd, char *buf, int *bufsiz, int note_type,
2979 ...)
2980{
2981 switch (note_type)
2982 {
2983 default:
2984 return NULL;
2985
2986 case NT_PRPSINFO:
2987 {
2988 char data[136];
2989 va_list ap;
2990
2991 va_start (ap, note_type);
75cd47ed 2992 memset (data, 0, sizeof (data));
183e98be
AM		 2993 strncpy (data + 40, va_arg (ap, const char *), 16);
2994 strncpy (data + 56, va_arg (ap, const char *), 80);
2995 va_end (ap);
2996 return elfcore_write_note (abfd, buf, bufsiz,
2997 "CORE", note_type, data, sizeof (data));
2998 }
2999
3000 case NT_PRSTATUS:
3001 {
3002 char data[504];
3003 va_list ap;
3004 long pid;
3005 int cursig;
3006 const void *greg;
3007
3008 va_start (ap, note_type);
3009 memset (data, 0, 112);
3010 pid = va_arg (ap, long);
3011 bfd_put_32 (abfd, pid, data + 32);
3012 cursig = va_arg (ap, int);
3013 bfd_put_16 (abfd, cursig, data + 12);
3014 greg = va_arg (ap, const void *);
3015 memcpy (data + 112, greg, 384);
3016 memset (data + 496, 0, 8);
3017 va_end (ap);
3018 return elfcore_write_note (abfd, buf, bufsiz,
3019 "CORE", note_type, data, sizeof (data));
3020 }
3021 }
3022}
3023
5d35169e
AM		 3024/* Add extra PPC sections. */
3025
b35d266b 3026static const struct bfd_elf_special_section ppc64_elf_special_sections[]=
7f4d3958 3027{
0112cd26
NC		 3028 { STRING_COMMA_LEN (".plt"), 0, SHT_NOBITS, 0 },
3029 { STRING_COMMA_LEN (".sbss"), -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE },
3030 { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
3031 { STRING_COMMA_LEN (".toc"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
3032 { STRING_COMMA_LEN (".toc1"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
3033 { STRING_COMMA_LEN (".tocbss"), 0, SHT_NOBITS, SHF_ALLOC + SHF_WRITE },
3034 { NULL, 0, 0, 0, 0 }
5d35169e
AM		 3035};
3036
7c8fe5c4
AM		 3037enum _ppc64_sec_type {
3038 sec_normal = 0,
3039 sec_opd = 1,
3040 sec_toc = 2
3041};
3042
f0abc2a1
AM		 3043struct _ppc64_elf_section_data
3044{
3045 struct bfd_elf_section_data elf;
411e1bfb 3046
f0abc2a1
AM		 3047 union
3048 {
51aecdc5
AM		 3049 /* An array with one entry for each opd function descriptor,
3050 and some spares since opd entries may be either 16 or 24 bytes. */
3051#define OPD_NDX(OFF) ((OFF) >> 4)
74f0fb50
AM		 3052 struct _opd_sec_data
3053 {
3054 /* Points to the function code section for local opd entries. */
3055 asection **func_sec;
3056
3057 /* After editing .opd, adjust references to opd local syms. */
3058 long *adjust;
3059 } opd;
7c8fe5c4 3060
3a71aa26
AM		 3061 /* An array for toc sections, indexed by offset/8. */
3062 struct _toc_sec_data
3063 {
3064 /* Specifies the relocation symbol index used at a given toc offset. */
3065 unsigned *symndx;
3066
3067 /* And the relocation addend. */
3068 bfd_vma *add;
3069 } toc;
7c8fe5c4
AM		 3070 } u;
3071
3072 enum _ppc64_sec_type sec_type:2;
411e1bfb 3073
7c8fe5c4
AM		 3074 /* Flag set when small branches are detected. Used to
3075 select suitable defaults for the stub group size. */
3076 unsigned int has_14bit_branch:1;
f0abc2a1
AM		 3077};
3078
3079#define ppc64_elf_section_data(sec) \
411e1bfb 3080 ((struct _ppc64_elf_section_data *) elf_section_data (sec))
f0abc2a1
AM		 3081
3082static bfd_boolean
4ce794b7 3083ppc64_elf_new_section_hook (bfd *abfd, asection *sec)
f0abc2a1 3084{
f592407e
AM		 3085 if (!sec->used_by_bfd)
3086 {
3087 struct _ppc64_elf_section_data *sdata;
3088 bfd_size_type amt = sizeof (*sdata);
f0abc2a1 3089
f592407e
AM		 3090 sdata = bfd_zalloc (abfd, amt);
3091 if (sdata == NULL)
3092 return FALSE;
3093 sec->used_by_bfd = sdata;
3094 }
f0abc2a1
AM		 3095
3096 return _bfd_elf_new_section_hook (abfd, sec);
3097}
4025353c 3098
74f0fb50 3099static struct _opd_sec_data *
4025353c
AM		 3100get_opd_info (asection * sec)
3101{
3102 if (sec != NULL
3103 && ppc64_elf_section_data (sec) != NULL
7c8fe5c4 3104 && ppc64_elf_section_data (sec)->sec_type == sec_opd)
74f0fb50 3105 return &ppc64_elf_section_data (sec)->u.opd;
4025353c
AM		 3106 return NULL;
3107}
90e3cdf2
JJ		 3108\f
3109/* Parameters for the qsort hook. */
90e3cdf2 3110static bfd_boolean synthetic_relocatable;
cd285db5 3111static asection *synthetic_opd;
90e3cdf2 3112
699733f6 3113/* qsort comparison function for ppc64_elf_get_synthetic_symtab. */
90e3cdf2
JJ		 3114
3115static int
3116compare_symbols (const void *ap, const void *bp)
3117{
3118 const asymbol *a = * (const asymbol **) ap;
3119 const asymbol *b = * (const asymbol **) bp;
3120
699733f6
AM		 3121 /* Section symbols first. */
3122 if ((a->flags & BSF_SECTION_SYM) && !(b->flags & BSF_SECTION_SYM))
90e3cdf2 3123 return -1;
699733f6 3124 if (!(a->flags & BSF_SECTION_SYM) && (b->flags & BSF_SECTION_SYM))
90e3cdf2
JJ		 3125 return 1;
3126
699733f6 3127 /* then .opd symbols. */
cd285db5
AM		 3128 if (synthetic_opd != NULL)
3129 {
3130 if (strcmp (a->section->name, ".opd") == 0
3131 && strcmp (b->section->name, ".opd") != 0)
3132 return -1;
3133 if (strcmp (a->section->name, ".opd") != 0
3134 && strcmp (b->section->name, ".opd") == 0)
3135 return 1;
3136 }
90e3cdf2 3137
699733f6 3138 /* then other code symbols. */
90e3cdf2
JJ		 3139 if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3140 == (SEC_CODE | SEC_ALLOC)
3141 && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3142 != (SEC_CODE | SEC_ALLOC))
3143 return -1;
3144
3145 if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3146 != (SEC_CODE | SEC_ALLOC)
3147 && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3148 == (SEC_CODE | SEC_ALLOC))
3149 return 1;
3150
3151 if (synthetic_relocatable)
3152 {
3153 if (a->section->id < b->section->id)
3154 return -1;
3155
3156 if (a->section->id > b->section->id)
3157 return 1;
3158 }
3159
3160 if (a->value + a->section->vma < b->value + b->section->vma)
3161 return -1;
3162
3163 if (a->value + a->section->vma > b->value + b->section->vma)
3164 return 1;
3165
4d35a0aa
AM		 3166 /* For syms with the same value, prefer strong dynamic global function
3167 syms over other syms. */
3168 if ((a->flags & BSF_GLOBAL) != 0 && (b->flags & BSF_GLOBAL) == 0)
3169 return -1;
3170
3171 if ((a->flags & BSF_GLOBAL) == 0 && (b->flags & BSF_GLOBAL) != 0)
3172 return 1;
3173
3174 if ((a->flags & BSF_FUNCTION) != 0 && (b->flags & BSF_FUNCTION) == 0)
3175 return -1;
3176
3177 if ((a->flags & BSF_FUNCTION) == 0 && (b->flags & BSF_FUNCTION) != 0)
3178 return 1;
3179
3180 if ((a->flags & BSF_WEAK) == 0 && (b->flags & BSF_WEAK) != 0)
3181 return -1;
3182
3183 if ((a->flags & BSF_WEAK) != 0 && (b->flags & BSF_WEAK) == 0)
3184 return 1;
3185
3186 if ((a->flags & BSF_DYNAMIC) != 0 && (b->flags & BSF_DYNAMIC) == 0)
3187 return -1;
3188
3189 if ((a->flags & BSF_DYNAMIC) == 0 && (b->flags & BSF_DYNAMIC) != 0)
3190 return 1;
3191
aaed6f5b 3192 return a > b;
90e3cdf2
JJ		 3193}
3194
699733f6 3195/* Search SYMS for a symbol of the given VALUE. */
90e3cdf2 3196
699733f6 3197static asymbol *
7292b3ac 3198sym_exists_at (asymbol **syms, long lo, long hi, unsigned int id, bfd_vma value)
90e3cdf2 3199{
699733f6 3200 long mid;
90e3cdf2 3201
7292b3ac 3202 if (id == (unsigned) -1)
699733f6
AM		 3203 {
3204 while (lo < hi)
3205 {
3206 mid = (lo + hi) >> 1;
3207 if (syms[mid]->value + syms[mid]->section->vma < value)
3208 lo = mid + 1;
3209 else if (syms[mid]->value + syms[mid]->section->vma > value)
3210 hi = mid;
3211 else
3212 return syms[mid];
3213 }
3214 }
3215 else
3216 {
3217 while (lo < hi)
3218 {
3219 mid = (lo + hi) >> 1;
3220 if (syms[mid]->section->id < id)
3221 lo = mid + 1;
3222 else if (syms[mid]->section->id > id)
3223 hi = mid;
3224 else if (syms[mid]->value < value)
3225 lo = mid + 1;
3226 else if (syms[mid]->value > value)
3227 hi = mid;
3228 else
3229 return syms[mid];
3230 }
3231 }
3232 return NULL;
90e3cdf2
JJ		 3233}
3234
468392fb
AM		 3235static bfd_boolean
3236section_covers_vma (bfd *abfd ATTRIBUTE_UNUSED, asection *section, void *ptr)
3237{
3238 bfd_vma vma = *(bfd_vma *) ptr;
3239 return ((section->flags & SEC_ALLOC) != 0
3240 && section->vma <= vma
3241 && vma < section->vma + section->size);
3242}
3243
699733f6 3244/* Create synthetic symbols, effectively restoring "dot-symbol" function
c4b0b099
AM		 3245 entry syms. Also generate @plt symbols for the glink branch table.
3246 Returns count of synthetic symbols in RET or -1 on error. */
90e3cdf2
JJ		 3247
3248static long
a7535cf3
AM		 3249ppc64_elf_get_synthetic_symtab (bfd *abfd,
3250 long static_count, asymbol **static_syms,
3251 long dyn_count, asymbol **dyn_syms,
c9727e01 3252 asymbol **ret)
90e3cdf2
JJ		 3253{
3254 asymbol *s;
699733f6
AM		 3255 long i;
3256 long count;
90e3cdf2 3257 char *names;
a7535cf3 3258 long symcount, codesecsym, codesecsymend, secsymend, opdsymend;
ee67d69a 3259 asection *opd = NULL;
90e3cdf2 3260 bfd_boolean relocatable = (abfd->flags & (EXEC_P | DYNAMIC)) == 0;
a7535cf3 3261 asymbol **syms;
ee67d69a 3262 int abi = abiversion (abfd);
90e3cdf2
JJ		 3263
3264 *ret = NULL;
3265
ee67d69a
AM		 3266 if (abi < 2)
3267 {
3268 opd = bfd_get_section_by_name (abfd, ".opd");
3269 if (opd == NULL && abi == 1)
3270 return 0;
3271 }
90e3cdf2 3272
a7535cf3 3273 symcount = static_count;
c9727e01 3274 if (!relocatable)
a7535cf3 3275 symcount += dyn_count;
90e3cdf2 3276 if (symcount == 0)
c9727e01 3277 return 0;
90e3cdf2 3278
a7535cf3
AM		 3279 syms = bfd_malloc ((symcount + 1) * sizeof (*syms));
3280 if (syms == NULL)
7356fed5 3281 return -1;
a7535cf3
AM		 3282
3283 if (!relocatable && static_count != 0 && dyn_count != 0)
3284 {
3285 /* Use both symbol tables. */
3286 memcpy (syms, static_syms, static_count * sizeof (*syms));
3287 memcpy (syms + static_count, dyn_syms, (dyn_count + 1) * sizeof (*syms));
3288 }
3289 else if (!relocatable && static_count == 0)
3290 memcpy (syms, dyn_syms, (symcount + 1) * sizeof (*syms));
3291 else
3292 memcpy (syms, static_syms, (symcount + 1) * sizeof (*syms));
3293
90e3cdf2 3294 synthetic_relocatable = relocatable;
cd285db5 3295 synthetic_opd = opd;
595da8c5 3296 qsort (syms, symcount, sizeof (*syms), compare_symbols);
90e3cdf2 3297
c9727e01
AM		 3298 if (!relocatable && symcount > 1)
3299 {
3300 long j;
3301 /* Trim duplicate syms, since we may have merged the normal and
3302 dynamic symbols. Actually, we only care about syms that have
3b36f7e6 3303 different values, so trim any with the same value. */
c9727e01
AM		 3304 for (i = 1, j = 1; i < symcount; ++i)
3305 if (syms[i - 1]->value + syms[i - 1]->section->vma
3306 != syms[i]->value + syms[i]->section->vma)
3307 syms[j++] = syms[i];
3308 symcount = j;
3309 }
3310
699733f6 3311 i = 0;
cd285db5
AM		 3312 /* Note that here and in compare_symbols we can't compare opd and
3313 sym->section directly. With separate debug info files, the
3314 symbols will be extracted from the debug file while abfd passed
3315 to this function is the real binary. */
3316 if (opd != NULL && strcmp (syms[i]->section->name, ".opd") == 0)
699733f6
AM		 3317 ++i;
3318 codesecsym = i;
90e3cdf2 3319
699733f6
AM		 3320 for (; i < symcount; ++i)
3321 if (((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3322 != (SEC_CODE | SEC_ALLOC))
3323 || (syms[i]->flags & BSF_SECTION_SYM) == 0)
3324 break;
3325 codesecsymend = i;
90e3cdf2 3326
699733f6
AM		 3327 for (; i < symcount; ++i)
3328 if ((syms[i]->flags & BSF_SECTION_SYM) == 0)
3329 break;
3330 secsymend = i;
90e3cdf2 3331
cd285db5
AM		 3332 if (opd != NULL)
3333 for (; i < symcount; ++i)
3334 if (strcmp (syms[i]->section->name, ".opd") != 0)
3335 break;
699733f6 3336 opdsymend = i;
90e3cdf2 3337
699733f6
AM		 3338 for (; i < symcount; ++i)
3339 if ((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3340 != (SEC_CODE | SEC_ALLOC))
3341 break;
3342 symcount = i;
3343
c9727e01 3344 count = 0;
90e3cdf2 3345
699733f6 3346 if (relocatable)
90e3cdf2 3347 {
699733f6
AM		 3348 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3349 arelent *r;
3350 size_t size;
3351 long relcount;
90e3cdf2 3352
468392fb
AM		 3353 if (opdsymend == secsymend)
3354 goto done;
3355
699733f6 3356 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
90e3cdf2 3357 relcount = (opd->flags & SEC_RELOC) ? opd->reloc_count : 0;
7356fed5 3358 if (relcount == 0)
c9727e01 3359 goto done;
90e3cdf2 3360
7356fed5
AM		 3361 if (!(*slurp_relocs) (abfd, opd, static_syms, FALSE))
3362 {
3363 count = -1;
3364 goto done;
3365 }
3366
699733f6 3367 size = 0;
595da8c5 3368 for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
699733f6
AM		 3369 {
3370 asymbol *sym;
90e3cdf2 3371
595da8c5 3372 while (r < opd->relocation + relcount
699733f6
AM		 3373 && r->address < syms[i]->value + opd->vma)
3374 ++r;
90e3cdf2 3375
595da8c5 3376 if (r == opd->relocation + relcount)
699733f6 3377 break;
90e3cdf2 3378
699733f6
AM		 3379 if (r->address != syms[i]->value + opd->vma)
3380 continue;
90e3cdf2 3381
699733f6
AM		 3382 if (r->howto->type != R_PPC64_ADDR64)
3383 continue;
90e3cdf2 3384
699733f6
AM		 3385 sym = *r->sym_ptr_ptr;
3386 if (!sym_exists_at (syms, opdsymend, symcount,
3387 sym->section->id, sym->value + r->addend))
3388 {
3389 ++count;
3390 size += sizeof (asymbol);
3391 size += strlen (syms[i]->name) + 2;
3392 }
3393 }
90e3cdf2 3394
c4b0b099
AM		 3395 if (size == 0)
3396 goto done;
699733f6
AM		 3397 s = *ret = bfd_malloc (size);
3398 if (s == NULL)
3399 {
7356fed5 3400 count = -1;
c9727e01 3401 goto done;
699733f6 3402 }
90e3cdf2 3403
699733f6 3404 names = (char *) (s + count);
90e3cdf2 3405
595da8c5 3406 for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
90e3cdf2 3407 {
699733f6 3408 asymbol *sym;
90e3cdf2 3409
595da8c5 3410 while (r < opd->relocation + relcount
699733f6
AM		 3411 && r->address < syms[i]->value + opd->vma)
3412 ++r;
90e3cdf2 3413
595da8c5 3414 if (r == opd->relocation + relcount)
699733f6
AM		 3415 break;
3416
3417 if (r->address != syms[i]->value + opd->vma)
3418 continue;
3419
3420 if (r->howto->type != R_PPC64_ADDR64)
3421 continue;
90e3cdf2 3422
699733f6
AM		 3423 sym = *r->sym_ptr_ptr;
3424 if (!sym_exists_at (syms, opdsymend, symcount,
3425 sym->section->id, sym->value + r->addend))
3426 {
3427 size_t len;
3428
3429 *s = *syms[i];
6ba2a415 3430 s->flags |= BSF_SYNTHETIC;
699733f6
AM		 3431 s->section = sym->section;
3432 s->value = sym->value + r->addend;
3433 s->name = names;
3434 *names++ = '.';
3435 len = strlen (syms[i]->name);
3436 memcpy (names, syms[i]->name, len + 1);
3437 names += len + 1;
6f610d07
UW		 3438 /* Have udata.p point back to the original symbol this
3439 synthetic symbol was derived from. */
3440 s->udata.p = syms[i];
699733f6
AM		 3441 s++;
3442 }
3443 }
3444 }
3445 else
90e3cdf2 3446 {
468392fb 3447 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
ee67d69a 3448 bfd_byte *contents = NULL;
699733f6 3449 size_t size;
468392fb
AM		 3450 long plt_count = 0;
3451 bfd_vma glink_vma = 0, resolv_vma = 0;
3452 asection *dynamic, *glink = NULL, *relplt = NULL;
3453 arelent *p;
90e3cdf2 3454
ee67d69a 3455 if (opd != NULL && !bfd_malloc_and_get_section (abfd, opd, &contents))
699733f6 3456 {
c4b0b099
AM		 3457 free_contents_and_exit_err:
3458 count = -1;
ee67d69a 3459 free_contents_and_exit:
699733f6 3460 if (contents)
ee67d69a 3461 free (contents);
c9727e01 3462 goto done;
699733f6 3463 }
90e3cdf2 3464
699733f6
AM		 3465 size = 0;
3466 for (i = secsymend; i < opdsymend; ++i)
3467 {
3468 bfd_vma ent;
90e3cdf2 3469
5ef11c02
AM		 3470 /* Ignore bogus symbols. */
3471 if (syms[i]->value > opd->size - 8)
3472 continue;
3473
699733f6
AM		 3474 ent = bfd_get_64 (abfd, contents + syms[i]->value);
3475 if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3476 {
3477 ++count;
3478 size += sizeof (asymbol);
3479 size += strlen (syms[i]->name) + 2;
3480 }
3481 }
90e3cdf2 3482
468392fb 3483 /* Get start of .glink stubs from DT_PPC64_GLINK. */
066ee829
AM		 3484 if (dyn_count != 0
3485 && (dynamic = bfd_get_section_by_name (abfd, ".dynamic")) != NULL)
468392fb
AM		 3486 {
3487 bfd_byte *dynbuf, *extdyn, *extdynend;
3488 size_t extdynsize;
3489 void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *);
3490
3491 if (!bfd_malloc_and_get_section (abfd, dynamic, &dynbuf))
c4b0b099 3492 goto free_contents_and_exit_err;
468392fb
AM		 3493
3494 extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
3495 swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
3496
3497 extdyn = dynbuf;
3498 extdynend = extdyn + dynamic->size;
3499 for (; extdyn < extdynend; extdyn += extdynsize)
3500 {
3501 Elf_Internal_Dyn dyn;
3502 (*swap_dyn_in) (abfd, extdyn, &dyn);
3503
3504 if (dyn.d_tag == DT_NULL)
3505 break;
3506
3507 if (dyn.d_tag == DT_PPC64_GLINK)
3508 {
b9e5796b
AM		 3509 /* The first glink stub starts at offset 32; see
3510 comment in ppc64_elf_finish_dynamic_sections. */
3511 glink_vma = dyn.d_un.d_val + GLINK_CALL_STUB_SIZE - 8 * 4;
468392fb
AM		 3512 /* The .glink section usually does not survive the final
3513 link; search for the section (usually .text) where the
3514 glink stubs now reside. */
3515 glink = bfd_sections_find_if (abfd, section_covers_vma,
3516 &glink_vma);
3517 break;
3518 }
3519 }
3520
3521 free (dynbuf);
3522 }
3523
3524 if (glink != NULL)
3525 {
3526 /* Determine __glink trampoline by reading the relative branch
3527 from the first glink stub. */
3528 bfd_byte buf[4];
b9e5796b
AM		 3529 unsigned int off = 0;
3530
3531 while (bfd_get_section_contents (abfd, glink, buf,
3532 glink_vma + off - glink->vma, 4))
468392fb
AM		 3533 {
3534 unsigned int insn = bfd_get_32 (abfd, buf);
3535 insn ^= B_DOT;
3536 if ((insn & ~0x3fffffc) == 0)
b9e5796b
AM		 3537 {
3538 resolv_vma = glink_vma + off + (insn ^ 0x2000000) - 0x2000000;
3539 break;
3540 }
3541 off += 4;
3542 if (off > 4)
3543 break;
468392fb
AM		 3544 }
3545
3546 if (resolv_vma)
3547 size += sizeof (asymbol) + sizeof ("__glink_PLTresolve");
468392fb 3548
066ee829
AM		 3549 relplt = bfd_get_section_by_name (abfd, ".rela.plt");
3550 if (relplt != NULL)
3551 {
3552 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3553 if (! (*slurp_relocs) (abfd, relplt, dyn_syms, TRUE))
c4b0b099 3554 goto free_contents_and_exit_err;
68ffbac6 3555
066ee829
AM		 3556 plt_count = relplt->size / sizeof (Elf64_External_Rela);
3557 size += plt_count * sizeof (asymbol);
468392fb 3558
066ee829
AM		 3559 p = relplt->relocation;
3560 for (i = 0; i < plt_count; i++, p++)
e054468f
AM		 3561 {
3562 size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
3563 if (p->addend != 0)
3564 size += sizeof ("+0x") - 1 + 16;
3565 }
066ee829 3566 }
468392fb
AM		 3567 }
3568
c4b0b099
AM		 3569 if (size == 0)
3570 goto free_contents_and_exit;
699733f6
AM		 3571 s = *ret = bfd_malloc (size);
3572 if (s == NULL)
c4b0b099 3573 goto free_contents_and_exit_err;
90e3cdf2 3574
468392fb 3575 names = (char *) (s + count + plt_count + (resolv_vma != 0));
90e3cdf2 3576
699733f6 3577 for (i = secsymend; i < opdsymend; ++i)
90e3cdf2 3578 {
699733f6 3579 bfd_vma ent;
90e3cdf2 3580
5ef11c02
AM		 3581 if (syms[i]->value > opd->size - 8)
3582 continue;
3583
699733f6
AM		 3584 ent = bfd_get_64 (abfd, contents + syms[i]->value);
3585 if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
90e3cdf2 3586 {
c9727e01 3587 long lo, hi;
699733f6 3588 size_t len;
c9727e01 3589 asection *sec = abfd->sections;
90e3cdf2 3590
699733f6
AM		 3591 *s = *syms[i];
3592 lo = codesecsym;
3593 hi = codesecsymend;
3594 while (lo < hi)
3595 {
c9727e01 3596 long mid = (lo + hi) >> 1;
699733f6
AM		 3597 if (syms[mid]->section->vma < ent)
3598 lo = mid + 1;
3599 else if (syms[mid]->section->vma > ent)
3600 hi = mid;
3601 else
c9727e01
AM		 3602 {
3603 sec = syms[mid]->section;
3604 break;
3605 }
699733f6
AM		 3606 }
3607
c9727e01 3608 if (lo >= hi && lo > codesecsym)
699733f6 3609 sec = syms[lo - 1]->section;
699733f6
AM		 3610
3611 for (; sec != NULL; sec = sec->next)
3612 {
3613 if (sec->vma > ent)
3614 break;
63524580
JK		 3615 /* SEC_LOAD may not be set if SEC is from a separate debug
3616 info file. */
3617 if ((sec->flags & SEC_ALLOC) == 0)
699733f6
AM		 3618 break;
3619 if ((sec->flags & SEC_CODE) != 0)
3620 s->section = sec;
3621 }
6ba2a415 3622 s->flags |= BSF_SYNTHETIC;
699733f6
AM		 3623 s->value = ent - s->section->vma;
3624 s->name = names;
3625 *names++ = '.';
3626 len = strlen (syms[i]->name);
3627 memcpy (names, syms[i]->name, len + 1);
3628 names += len + 1;
6f610d07
UW		 3629 /* Have udata.p point back to the original symbol this
3630 synthetic symbol was derived from. */
3631 s->udata.p = syms[i];
699733f6 3632 s++;
90e3cdf2 3633 }
90e3cdf2 3634 }
699733f6 3635 free (contents);
468392fb
AM		 3636
3637 if (glink != NULL && relplt != NULL)
3638 {
3639 if (resolv_vma)
3640 {
3641 /* Add a symbol for the main glink trampoline. */
86a4952b 3642 memset (s, 0, sizeof *s);
468392fb 3643 s->the_bfd = abfd;
6ba2a415 3644 s->flags = BSF_GLOBAL | BSF_SYNTHETIC;
468392fb
AM		 3645 s->section = glink;
3646 s->value = resolv_vma - glink->vma;
3647 s->name = names;
3648 memcpy (names, "__glink_PLTresolve", sizeof ("__glink_PLTresolve"));
3649 names += sizeof ("__glink_PLTresolve");
3650 s++;
3651 count++;
3652 }
3653
3654 /* FIXME: It would be very much nicer to put sym@plt on the
3655 stub rather than on the glink branch table entry. The
3656 objdump disassembler would then use a sensible symbol
3657 name on plt calls. The difficulty in doing so is
3658 a) finding the stubs, and,
3659 b) matching stubs against plt entries, and,
3660 c) there can be multiple stubs for a given plt entry.
3661
3662 Solving (a) could be done by code scanning, but older
3663 ppc64 binaries used different stubs to current code.
3664 (b) is the tricky one since you need to known the toc
3665 pointer for at least one function that uses a pic stub to
3666 be able to calculate the plt address referenced.
3667 (c) means gdb would need to set multiple breakpoints (or
3668 find the glink branch itself) when setting breakpoints
3669 for pending shared library loads. */
3670 p = relplt->relocation;
3671 for (i = 0; i < plt_count; i++, p++)
3672 {
3673 size_t len;
3674
3675 *s = **p->sym_ptr_ptr;
3676 /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set. Since
3677 we are defining a symbol, ensure one of them is set. */
3678 if ((s->flags & BSF_LOCAL) == 0)
3679 s->flags |= BSF_GLOBAL;
6ba2a415 3680 s->flags |= BSF_SYNTHETIC;
468392fb
AM		 3681 s->section = glink;
3682 s->value = glink_vma - glink->vma;
3683 s->name = names;
3684 s->udata.p = NULL;
3685 len = strlen ((*p->sym_ptr_ptr)->name);
3686 memcpy (names, (*p->sym_ptr_ptr)->name, len);
3687 names += len;
e054468f
AM		 3688 if (p->addend != 0)
3689 {
3690 memcpy (names, "+0x", sizeof ("+0x") - 1);
3691 names += sizeof ("+0x") - 1;
3692 bfd_sprintf_vma (abfd, names, p->addend);
3693 names += strlen (names);
3694 }
468392fb
AM		 3695 memcpy (names, "@plt", sizeof ("@plt"));
3696 names += sizeof ("@plt");
3697 s++;
b9e5796b
AM		 3698 if (abi < 2)
3699 {
3700 glink_vma += 8;
3701 if (i >= 0x8000)
3702 glink_vma += 4;
3703 }
3704 else
468392fb
AM		 3705 glink_vma += 4;
3706 }
3707 count += plt_count;
3708 }
90e3cdf2
JJ		 3709 }
3710
c9727e01 3711 done:
a7535cf3 3712 free (syms);
90e3cdf2
JJ		 3713 return count;
3714}
5bd4f169 3715\f
65f38f15
AM		 3716/* The following functions are specific to the ELF linker, while
3717 functions above are used generally. Those named ppc64_elf_* are
3718 called by the main ELF linker code. They appear in this file more
3719 or less in the order in which they are called. eg.
3720 ppc64_elf_check_relocs is called early in the link process,
3721 ppc64_elf_finish_dynamic_sections is one of the last functions
e86ce104
AM		 3722 called.
3723
3724 PowerPC64-ELF uses a similar scheme to PowerPC64-XCOFF in that
3725 functions have both a function code symbol and a function descriptor
3726 symbol. A call to foo in a relocatable object file looks like:
3727
3728 . .text
3729 . x:
3730 . bl .foo
3731 . nop
3732
3733 The function definition in another object file might be:
3734
3735 . .section .opd
3736 . foo: .quad .foo
3737 . .quad .TOC.@tocbase
3738 . .quad 0
3739 .
3740 . .text
3741 . .foo: blr
3742
3743 When the linker resolves the call during a static link, the branch
3744 unsurprisingly just goes to .foo and the .opd information is unused.
3745 If the function definition is in a shared library, things are a little
3746 different: The call goes via a plt call stub, the opd information gets
3747 copied to the plt, and the linker patches the nop.
3748
3749 . x:
3750 . bl .foo_stub
3751 . ld 2,40(1)
3752 .
3753 .
3754 . .foo_stub:
71a39c98
AM		 3755 . std 2,40(1) # in practice, the call stub
3756 . addis 11,2,Lfoo@toc@ha # is slightly optimized, but
3757 . addi 11,11,Lfoo@toc@l # this is the general idea
3758 . ld 12,0(11)
3759 . ld 2,8(11)
3760 . mtctr 12
3761 . ld 11,16(11)
e86ce104
AM		 3762 . bctr
3763 .
3764 . .section .plt
3765 . Lfoo: reloc (R_PPC64_JMP_SLOT, foo)
3766
3767 The "reloc ()" notation is supposed to indicate that the linker emits
3768 an R_PPC64_JMP_SLOT reloc against foo. The dynamic linker does the opd
3769 copying.
3770
3771 What are the difficulties here? Well, firstly, the relocations
3772 examined by the linker in check_relocs are against the function code
3773 sym .foo, while the dynamic relocation in the plt is emitted against
3774 the function descriptor symbol, foo. Somewhere along the line, we need
3775 to carefully copy dynamic link information from one symbol to the other.
3776 Secondly, the generic part of the elf linker will make .foo a dynamic
3777 symbol as is normal for most other backends. We need foo dynamic
3778 instead, at least for an application final link. However, when
3779 creating a shared library containing foo, we need to have both symbols
3780 dynamic so that references to .foo are satisfied during the early
3781 stages of linking. Otherwise the linker might decide to pull in a
8387904d
AM		 3782 definition from some other object, eg. a static library.
3783
3784 Update: As of August 2004, we support a new convention. Function
3785 calls may use the function descriptor symbol, ie. "bl foo". This
3786 behaves exactly as "bl .foo". */
65f38f15 3787
1d483afe 3788/* Of those relocs that might be copied as dynamic relocs, this function
58ac9f71
AM		 3789 selects those that must be copied when linking a shared library,
3790 even when the symbol is local. */
65f38f15 3791
1d483afe
AM		 3792static int
3793must_be_dyn_reloc (struct bfd_link_info *info,
3794 enum elf_ppc64_reloc_type r_type)
3795{
3796 switch (r_type)
3797 {
3798 default:
3799 return 1;
3800
3801 case R_PPC64_REL32:
3802 case R_PPC64_REL64:
3803 case R_PPC64_REL30:
3804 return 0;
3805
3806 case R_PPC64_TPREL16:
3807 case R_PPC64_TPREL16_LO:
3808 case R_PPC64_TPREL16_HI:
3809 case R_PPC64_TPREL16_HA:
3810 case R_PPC64_TPREL16_DS:
3811 case R_PPC64_TPREL16_LO_DS:
f9c6b907
AM		 3812 case R_PPC64_TPREL16_HIGH:
3813 case R_PPC64_TPREL16_HIGHA:
1d483afe
AM		 3814 case R_PPC64_TPREL16_HIGHER:
3815 case R_PPC64_TPREL16_HIGHERA:
3816 case R_PPC64_TPREL16_HIGHEST:
3817 case R_PPC64_TPREL16_HIGHESTA:
3818 case R_PPC64_TPREL64:
0e1862bb 3819 return !bfd_link_executable (info);
1d483afe
AM		 3820 }
3821}
65f38f15 3822
21d68fcd
AM		 3823/* Whether an undefined weak symbol should resolve to its link-time
3824 value, even in PIC or PIE objects. */
3825#define UNDEFWEAK_NO_DYNAMIC_RELOC(INFO, H) \
3826 ((H)->root.type == bfd_link_hash_undefweak \
3827 && (ELF_ST_VISIBILITY ((H)->other) != STV_DEFAULT \
3828 || (INFO)->dynamic_undefined_weak == 0))
3829
f4656909
AM		 3830/* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
3831 copying dynamic variables from a shared lib into an app's dynbss
3832 section, and instead use a dynamic relocation to point into the
5d35169e
AM		 3833 shared lib. With code that gcc generates, it's vital that this be
3834 enabled; In the PowerPC64 ABI, the address of a function is actually
3835 the address of a function descriptor, which resides in the .opd
3836 section. gcc uses the descriptor directly rather than going via the
3837 GOT as some other ABI's do, which means that initialized function
3838 pointers must reference the descriptor. Thus, a function pointer
3839 initialized to the address of a function in a shared library will
3840 either require a copy reloc, or a dynamic reloc. Using a copy reloc
4cc11e76 3841 redefines the function descriptor symbol to point to the copy. This
5d35169e
AM		 3842 presents a problem as a plt entry for that function is also
3843 initialized from the function descriptor symbol and the copy reloc
3844 may not be initialized first. */
a23b6845 3845#define ELIMINATE_COPY_RELOCS 1
f4656909 3846
721956f4 3847/* Section name for stubs is the associated section name plus this
29942be8
NC		 3848 string. */
3849#define STUB_SUFFIX ".stub"
721956f4
AM		 3850
3851/* Linker stubs.
3852 ppc_stub_long_branch:
3853 Used when a 14 bit branch (or even a 24 bit branch) can't reach its
3854 destination, but a 24 bit branch in a stub section will reach.
3855 . b dest
3856
3857 ppc_stub_plt_branch:
3858 Similar to the above, but a 24 bit branch in the stub section won't
3859 reach its destination.
71a39c98
AM		 3860 . addis %r11,%r2,xxx@toc@ha
3861 . ld %r12,xxx@toc@l(%r11)
3862 . mtctr %r12
721956f4
AM		 3863 . bctr
3864
3865 ppc_stub_plt_call:
2c66dc6c
AM		 3866 Used to call a function in a shared library. If it so happens that
3867 the plt entry referenced crosses a 64k boundary, then an extra
71a39c98 3868 "addi %r11,%r11,xxx@toc@l" will be inserted before the "mtctr".
721956f4 3869 . std %r2,40(%r1)
71a39c98
AM		 3870 . addis %r11,%r2,xxx@toc@ha
3871 . ld %r12,xxx+0@toc@l(%r11)
3872 . mtctr %r12
3873 . ld %r2,xxx+8@toc@l(%r11)
3874 . ld %r11,xxx+16@toc@l(%r11)
721956f4 3875 . bctr
ad8e1ba5
AM		 3876
3877 ppc_stub_long_branch and ppc_stub_plt_branch may also have additional
3878 code to adjust the value and save r2 to support multiple toc sections.
3879 A ppc_stub_long_branch with an r2 offset looks like:
3880 . std %r2,40(%r1)
3881 . addis %r2,%r2,off@ha
3882 . addi %r2,%r2,off@l
3883 . b dest
3884
3885 A ppc_stub_plt_branch with an r2 offset looks like:
3886 . std %r2,40(%r1)
71a39c98
AM		 3887 . addis %r11,%r2,xxx@toc@ha
3888 . ld %r12,xxx@toc@l(%r11)
ad8e1ba5
AM		 3889 . addis %r2,%r2,off@ha
3890 . addi %r2,%r2,off@l
71a39c98 3891 . mtctr %r12
ad8e1ba5 3892 . bctr
ac2df442
AM		 3893
3894 In cases where the "addis" instruction would add zero, the "addis" is
3895 omitted and following instructions modified slightly in some cases.
721956f4
AM		 3896*/
3897
3898enum ppc_stub_type {
3899 ppc_stub_none,
3900 ppc_stub_long_branch,
ad8e1ba5 3901 ppc_stub_long_branch_r2off,
721956f4 3902 ppc_stub_plt_branch,
ad8e1ba5 3903 ppc_stub_plt_branch_r2off,
794e51c0 3904 ppc_stub_plt_call,
7341d5e2 3905 ppc_stub_plt_call_r2save,
a4b6fadd
AM		 3906 ppc_stub_global_entry,
3907 ppc_stub_save_res
721956f4
AM		 3908};
3909
6f20ed8a
AM		 3910/* Information on stub grouping. */
3911struct map_stub
3912{
3913 /* The stub section. */
3914 asection *stub_sec;
3915 /* This is the section to which stubs in the group will be attached. */
3916 asection *link_sec;
a4b6fadd
AM		 3917 /* Next group. */
3918 struct map_stub *next;
3919 /* Whether to emit a copy of register save/restore functions in this
3920 group. */
3921 int needs_save_res;
d4aaa2a0
AM		 3922 /* The offset of the __tls_get_addr_opt plt stub bctrl in this group,
3923 or -1u if no such stub with bctrl exists. */
3924 unsigned int tls_get_addr_opt_bctrl;
6f20ed8a
AM		 3925};
3926
721956f4
AM		 3927struct ppc_stub_hash_entry {
3928
3929 /* Base hash table entry structure. */
3930 struct bfd_hash_entry root;
3931
ad8e1ba5
AM		 3932 enum ppc_stub_type stub_type;
3933
6f20ed8a
AM		 3934 /* Group information. */
3935 struct map_stub *group;
721956f4
AM		 3936
3937 /* Offset within stub_sec of the beginning of this stub. */
3938 bfd_vma stub_offset;
3939
3940 /* Given the symbol's value and its section we can determine its final
3941 value when building the stubs (so the stub knows where to jump. */
3942 bfd_vma target_value;
3943 asection *target_section;
3944
721956f4
AM		 3945 /* The symbol table entry, if any, that this was derived from. */
3946 struct ppc_link_hash_entry *h;
e054468f 3947 struct plt_entry *plt_ent;
721956f4 3948
6911b7dc
AM		 3949 /* Symbol st_other. */
3950 unsigned char other;
721956f4
AM		 3951};
3952
3953struct ppc_branch_hash_entry {
3954
3955 /* Base hash table entry structure. */
3956 struct bfd_hash_entry root;
3957
c456f082 3958 /* Offset within branch lookup table. */
721956f4
AM		 3959 unsigned int offset;
3960
3961 /* Generation marker. */
3962 unsigned int iter;
3963};
65f38f15 3964
19e08130
AM		 3965/* Used to track dynamic relocations for local symbols. */
3966struct ppc_dyn_relocs
3967{
3968 struct ppc_dyn_relocs *next;
3969
3970 /* The input section of the reloc. */
3971 asection *sec;
3972
3973 /* Total number of relocs copied for the input section. */
3974 unsigned int count : 31;
3975
3976 /* Whether this entry is for STT_GNU_IFUNC symbols. */
3977 unsigned int ifunc : 1;
3978};
3979
65f38f15
AM		 3980struct ppc_link_hash_entry
3981{
3982 struct elf_link_hash_entry elf;
3983
b3fac117
AM		 3984 union {
3985 /* A pointer to the most recently used stub hash entry against this
3986 symbol. */
3987 struct ppc_stub_hash_entry *stub_cache;
3988
3989 /* A pointer to the next symbol starting with a '.' */
3990 struct ppc_link_hash_entry *next_dot_sym;
3991 } u;
721956f4 3992
65f38f15 3993 /* Track dynamic relocs copied for this symbol. */
6061a67d 3994 struct elf_dyn_relocs *dyn_relocs;
e86ce104 3995
d311bc8b
AM		 3996 /* Chain of aliases referring to a weakdef. */
3997 struct ppc_link_hash_entry *weakref;
3998
721956f4 3999 /* Link between function code and descriptor symbols. */
34814b9f 4000 struct ppc_link_hash_entry *oh;
721956f4 4001
e86ce104
AM		 4002 /* Flag function code and descriptor symbols. */
4003 unsigned int is_func:1;
4004 unsigned int is_func_descriptor:1;
908b32fc 4005 unsigned int fake:1;
411e1bfb 4006
c5614fa4
AM		 4007 /* Whether global opd/toc sym has been adjusted or not.
4008 After ppc64_elf_edit_opd/ppc64_elf_edit_toc has run, this flag
4009 should be set for all globals defined in any opd/toc section. */
754021d0
AM		 4010 unsigned int adjust_done:1;
4011
a4b6fadd
AM		 4012 /* Set if this is an out-of-line register save/restore function,
4013 with non-standard calling convention. */
4014 unsigned int save_res:1;
4015
8b5f1ed8
AM		 4016 /* Set if a duplicate symbol with non-zero localentry is detected,
4017 even when the duplicate symbol does not provide a definition. */
4018 unsigned int non_zero_localentry:1;
4019
411e1bfb 4020 /* Contexts in which symbol is used in the GOT (or TOC).
e7b938ca
AM		 4021 TLS_GD .. TLS_EXPLICIT bits are or'd into the mask as the
4022 corresponding relocs are encountered during check_relocs.
4023 tls_optimize clears TLS_GD .. TLS_TPREL when optimizing to
4024 indicate the corresponding GOT entry type is not needed.
4025 tls_optimize may also set TLS_TPRELGD when a GD reloc turns into
4026 a TPREL one. We use a separate flag rather than setting TPREL
4027 just for convenience in distinguishing the two cases. */
4028#define TLS_GD 1 /* GD reloc. */
4029#define TLS_LD 2 /* LD reloc. */
4030#define TLS_TPREL 4 /* TPREL reloc, => IE. */
4031#define TLS_DTPREL 8 /* DTPREL reloc, => LD. */
4032#define TLS_TLS 16 /* Any TLS reloc. */
4033#define TLS_EXPLICIT 32 /* Marks TOC section TLS relocs. */
4034#define TLS_TPRELGD 64 /* TPREL reloc resulting from GD->IE. */
e054468f 4035#define PLT_IFUNC 128 /* STT_GNU_IFUNC. */
f961d9dd 4036 unsigned char tls_mask;
65f38f15
AM		 4037};
4038
4039/* ppc64 ELF linker hash table. */
4040
4041struct ppc_link_hash_table
4042{
4043 struct elf_link_hash_table elf;
4044
721956f4
AM		 4045 /* The stub hash table. */
4046 struct bfd_hash_table stub_hash_table;
4047
4048 /* Another hash table for plt_branch stubs. */
4049 struct bfd_hash_table branch_hash_table;
4050
3b421ab3
AM		 4051 /* Hash table for function prologue tocsave. */
4052 htab_t tocsave_htab;
4053
e7d1c40c
AM		 4054 /* Various options and other info passed from the linker. */
4055 struct ppc64_elf_params *params;
721956f4 4056
6f20ed8a
AM		 4057 /* The size of sec_info below. */
4058 unsigned int sec_info_arr_size;
4059
4060 /* Per-section array of extra section info. Done this way rather
4061 than as part of ppc64_elf_section_data so we have the info for
4062 non-ppc64 sections. */
4063 struct
4064 {
4065 /* Along with elf_gp, specifies the TOC pointer used by this section. */
ad8e1ba5 4066 bfd_vma toc_off;
6f20ed8a
AM		 4067
4068 union
4069 {
4070 /* The section group that this section belongs to. */
4071 struct map_stub *group;
4072 /* A temp section list pointer. */
4073 asection *list;
4074 } u;
4075 } *sec_info;
721956f4 4076
a4b6fadd
AM		 4077 /* Linked list of groups. */
4078 struct map_stub *group;
4079
ad8e1ba5
AM		 4080 /* Temp used when calculating TOC pointers. */
4081 bfd_vma toc_curr;
bf102f86
AM		 4082 bfd *toc_bfd;
4083 asection *toc_first_sec;
ad8e1ba5 4084
b3fac117
AM		 4085 /* Used when adding symbols. */
4086 struct ppc_link_hash_entry *dot_syms;
4087
33e44f2e 4088 /* Shortcuts to get to dynamic linker sections. */
4ce794b7 4089 asection *glink;
82bd7b59 4090 asection *sfpr;
4ce794b7
AM		 4091 asection *brlt;
4092 asection *relbrlt;
58d180e8 4093 asection *glink_eh_frame;
ec338859 4094
8387904d
AM		 4095 /* Shortcut to .__tls_get_addr and __tls_get_addr. */
4096 struct ppc_link_hash_entry *tls_get_addr;
4097 struct ppc_link_hash_entry *tls_get_addr_fd;
411e1bfb 4098
927be08e
AM		 4099 /* The size of reliplt used by got entry relocs. */
4100 bfd_size_type got_reli_size;
4101
9b5ecbd0 4102 /* Statistics. */
7341d5e2 4103 unsigned long stub_count[ppc_stub_global_entry];
9b5ecbd0 4104
ee75fd95
AM		 4105 /* Number of stubs against global syms. */
4106 unsigned long stub_globals;
4107
ee67d69a
AM		 4108 /* Set if we're linking code with function descriptors. */
4109 unsigned int opd_abi:1;
4110
4c52953f 4111 /* Support for multiple toc sections. */
33c0ec9d 4112 unsigned int do_multi_toc:1;
4c52953f 4113 unsigned int multi_toc_needed:1;
927be08e 4114 unsigned int second_toc_pass:1;
67f0cbdb 4115 unsigned int do_toc_opt:1;
4c52953f 4116
5d1634d7 4117 /* Set on error. */
99877b66 4118 unsigned int stub_error:1;
721956f4 4119
8c5b4e52
AM		 4120 /* Whether func_desc_adjust needs to be run over symbols. */
4121 unsigned int need_func_desc_adj:1;
721956f4 4122
82e66161
AM		 4123 /* Whether there exist local gnu indirect function resolvers,
4124 referenced by dynamic relocations. */
4125 unsigned int local_ifunc_resolver:1;
4126 unsigned int maybe_local_ifunc_resolver:1;
4127
f378ab09
AM		 4128 /* Whether plt calls for ELFv2 localentry:0 funcs have been optimized. */
4129 unsigned int has_plt_localentry0:1;
4130
721956f4
AM		 4131 /* Incremented every time we size stubs. */
4132 unsigned int stub_iteration;
5d1634d7 4133
87d72d41
AM		 4134 /* Small local sym cache. */
4135 struct sym_cache sym_cache;
65f38f15
AM		 4136};
4137
4c52953f
AM		 4138/* Rename some of the generic section flags to better document how they
4139 are used here. */
b0dddeec
AM		 4140
4141/* Nonzero if this section has TLS related relocations. */
4142#define has_tls_reloc sec_flg0
4143
4144/* Nonzero if this section has a call to __tls_get_addr. */
4145#define has_tls_get_addr_call sec_flg1
4146
4147/* Nonzero if this section has any toc or got relocs. */
4148#define has_toc_reloc sec_flg2
4149
4150/* Nonzero if this section has a call to another section that uses
4151 the toc or got. */
d77c8a4b 4152#define makes_toc_func_call sec_flg3
b0dddeec
AM		 4153
4154/* Recursion protection when determining above flag. */
d77c8a4b 4155#define call_check_in_progress sec_flg4
70cc837d 4156#define call_check_done sec_flg5
4c52953f 4157
65f38f15
AM		 4158/* Get the ppc64 ELF linker hash table from a link_info structure. */
4159
4160#define ppc_hash_table(p) \
4dfe6ac6
NC		 4161 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
4162 == PPC64_ELF_DATA ? ((struct ppc_link_hash_table *) ((p)->hash)) : NULL)
65f38f15 4163
721956f4
AM		 4164#define ppc_stub_hash_lookup(table, string, create, copy) \
4165 ((struct ppc_stub_hash_entry *) \
4166 bfd_hash_lookup ((table), (string), (create), (copy)))
4167
4168#define ppc_branch_hash_lookup(table, string, create, copy) \
4169 ((struct ppc_branch_hash_entry *) \
4170 bfd_hash_lookup ((table), (string), (create), (copy)))
4171
4172/* Create an entry in the stub hash table. */
4173
4174static struct bfd_hash_entry *
4ce794b7
AM		 4175stub_hash_newfunc (struct bfd_hash_entry *entry,
4176 struct bfd_hash_table *table,
4177 const char *string)
721956f4
AM		 4178{
4179 /* Allocate the structure if it has not already been allocated by a
4180 subclass. */
4181 if (entry == NULL)
4182 {
4183 entry = bfd_hash_allocate (table, sizeof (struct ppc_stub_hash_entry));
4184 if (entry == NULL)
4185 return entry;
4186 }
4187
4188 /* Call the allocation method of the superclass. */
4189 entry = bfd_hash_newfunc (entry, table, string);
4190 if (entry != NULL)
4191 {
4192 struct ppc_stub_hash_entry *eh;
4193
4194 /* Initialize the local fields. */
4195 eh = (struct ppc_stub_hash_entry *) entry;
ad8e1ba5 4196 eh->stub_type = ppc_stub_none;
6f20ed8a 4197 eh->group = NULL;
721956f4
AM		 4198 eh->stub_offset = 0;
4199 eh->target_value = 0;
4200 eh->target_section = NULL;
721956f4 4201 eh->h = NULL;
6911b7dc 4202 eh->plt_ent = NULL;
6911b7dc 4203 eh->other = 0;
721956f4
AM		 4204 }
4205
4206 return entry;
4207}
4208
4209/* Create an entry in the branch hash table. */
4210
4211static struct bfd_hash_entry *
4ce794b7
AM		 4212branch_hash_newfunc (struct bfd_hash_entry *entry,
4213 struct bfd_hash_table *table,
4214 const char *string)
721956f4
AM		 4215{
4216 /* Allocate the structure if it has not already been allocated by a
4217 subclass. */
4218 if (entry == NULL)
4219 {
4220 entry = bfd_hash_allocate (table, sizeof (struct ppc_branch_hash_entry));
4221 if (entry == NULL)
4222 return entry;
4223 }
4224
4225 /* Call the allocation method of the superclass. */
4226 entry = bfd_hash_newfunc (entry, table, string);
4227 if (entry != NULL)
4228 {
4229 struct ppc_branch_hash_entry *eh;
4230
4231 /* Initialize the local fields. */
4232 eh = (struct ppc_branch_hash_entry *) entry;
4233 eh->offset = 0;
4234 eh->iter = 0;
4235 }
4236
4237 return entry;
4238}
4239
65f38f15
AM		 4240/* Create an entry in a ppc64 ELF linker hash table. */
4241
4242static struct bfd_hash_entry *
4ce794b7
AM		 4243link_hash_newfunc (struct bfd_hash_entry *entry,
4244 struct bfd_hash_table *table,
4245 const char *string)
65f38f15
AM		 4246{
4247 /* Allocate the structure if it has not already been allocated by a
4248 subclass. */
4249 if (entry == NULL)
4250 {
4251 entry = bfd_hash_allocate (table, sizeof (struct ppc_link_hash_entry));
4252 if (entry == NULL)
4253 return entry;
4254 }
4255
4256 /* Call the allocation method of the superclass. */
4257 entry = _bfd_elf_link_hash_newfunc (entry, table, string);
4258 if (entry != NULL)
4259 {
4260 struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) entry;
4261
b3fac117 4262 memset (&eh->u.stub_cache, 0,
908b32fc 4263 (sizeof (struct ppc_link_hash_entry)
b3fac117
AM		 4264 - offsetof (struct ppc_link_hash_entry, u.stub_cache)));
4265
4266 /* When making function calls, old ABI code references function entry
4267 points (dot symbols), while new ABI code references the function
4268 descriptor symbol. We need to make any combination of reference and
4269 definition work together, without breaking archive linking.
4270
4271 For a defined function "foo" and an undefined call to "bar":
4272 An old object defines "foo" and ".foo", references ".bar" (possibly
4273 "bar" too).
4274 A new object defines "foo" and references "bar".
4275
4276 A new object thus has no problem with its undefined symbols being
4277 satisfied by definitions in an old object. On the other hand, the
4278 old object won't have ".bar" satisfied by a new object.
4279
4280 Keep a list of newly added dot-symbols. */
4281
4282 if (string[0] == '.')
4283 {
4284 struct ppc_link_hash_table *htab;
4285
4286 htab = (struct ppc_link_hash_table *) table;
4287 eh->u.next_dot_sym = htab->dot_syms;
4288 htab->dot_syms = eh;
4289 }
65f38f15
AM		 4290 }
4291
4292 return entry;
4293}
4294
3b421ab3
AM		 4295struct tocsave_entry {
4296 asection *sec;
4297 bfd_vma offset;
4298};
4299
4300static hashval_t
4301tocsave_htab_hash (const void *p)
4302{
4303 const struct tocsave_entry *e = (const struct tocsave_entry *) p;
4aef7643 4304 return ((bfd_vma) (intptr_t) e->sec ^ e->offset) >> 3;
3b421ab3
AM		 4305}
4306
4307static int
4308tocsave_htab_eq (const void *p1, const void *p2)
4309{
4310 const struct tocsave_entry *e1 = (const struct tocsave_entry *) p1;
4311 const struct tocsave_entry *e2 = (const struct tocsave_entry *) p2;
4312 return e1->sec == e2->sec && e1->offset == e2->offset;
4313}
4314
68faa637
AM		 4315/* Destroy a ppc64 ELF linker hash table. */
4316
4317static void
d495ab0d 4318ppc64_elf_link_hash_table_free (bfd *obfd)
68faa637 4319{
d495ab0d 4320 struct ppc_link_hash_table *htab;
68faa637 4321
d495ab0d 4322 htab = (struct ppc_link_hash_table *) obfd->link.hash;
68faa637
AM		 4323 if (htab->tocsave_htab)
4324 htab_delete (htab->tocsave_htab);
d495ab0d
AM		 4325 bfd_hash_table_free (&htab->branch_hash_table);
4326 bfd_hash_table_free (&htab->stub_hash_table);
4327 _bfd_elf_link_hash_table_free (obfd);
68faa637
AM		 4328}
4329
65f38f15
AM		 4330/* Create a ppc64 ELF linker hash table. */
4331
4332static struct bfd_link_hash_table *
4ce794b7 4333ppc64_elf_link_hash_table_create (bfd *abfd)
65f38f15
AM		 4334{
4335 struct ppc_link_hash_table *htab;
4336 bfd_size_type amt = sizeof (struct ppc_link_hash_table);
4337
4ce794b7 4338 htab = bfd_zmalloc (amt);
65f38f15
AM		 4339 if (htab == NULL)
4340 return NULL;
4341
66eb6687 4342 if (!_bfd_elf_link_hash_table_init (&htab->elf, abfd, link_hash_newfunc,
4dfe6ac6
NC		 4343 sizeof (struct ppc_link_hash_entry),
4344 PPC64_ELF_DATA))
65f38f15 4345 {
e2d34d7d 4346 free (htab);
65f38f15
AM		 4347 return NULL;
4348 }
4349
721956f4 4350 /* Init the stub hash table too. */
66eb6687
AM		 4351 if (!bfd_hash_table_init (&htab->stub_hash_table, stub_hash_newfunc,
4352 sizeof (struct ppc_stub_hash_entry)))
2915c55b 4353 {
d495ab0d 4354 _bfd_elf_link_hash_table_free (abfd);
2915c55b
JK		 4355 return NULL;
4356 }
721956f4
AM		 4357
4358 /* And the branch hash table. */
66eb6687
AM		 4359 if (!bfd_hash_table_init (&htab->branch_hash_table, branch_hash_newfunc,
4360 sizeof (struct ppc_branch_hash_entry)))
2915c55b
JK		 4361 {
4362 bfd_hash_table_free (&htab->stub_hash_table);
d495ab0d 4363 _bfd_elf_link_hash_table_free (abfd);
2915c55b
JK		 4364 return NULL;
4365 }
721956f4 4366
3b421ab3
AM		 4367 htab->tocsave_htab = htab_try_create (1024,
4368 tocsave_htab_hash,
4369 tocsave_htab_eq,
4370 NULL);
4371 if (htab->tocsave_htab == NULL)
2915c55b 4372 {
d495ab0d 4373 ppc64_elf_link_hash_table_free (abfd);
2915c55b
JK		 4374 return NULL;
4375 }
d495ab0d 4376 htab->elf.root.hash_table_free = ppc64_elf_link_hash_table_free;
3b421ab3 4377
3254fd24
AM		 4378 /* Initializing two fields of the union is just cosmetic. We really
4379 only care about glist, but when compiled on a 32-bit host the
4380 bfd_vma fields are larger. Setting the bfd_vma to zero makes
4381 debugger inspection of these fields look nicer. */
a6aa5195
AM		 4382 htab->elf.init_got_refcount.refcount = 0;
4383 htab->elf.init_got_refcount.glist = NULL;
4384 htab->elf.init_plt_refcount.refcount = 0;
4385 htab->elf.init_plt_refcount.glist = NULL;
4386 htab->elf.init_got_offset.offset = 0;
4387 htab->elf.init_got_offset.glist = NULL;
4388 htab->elf.init_plt_offset.offset = 0;
4389 htab->elf.init_plt_offset.glist = NULL;
3254fd24 4390
65f38f15
AM		 4391 return &htab->elf.root;
4392}
4393
bfeb4a28
AM		 4394/* Create sections for linker generated code. */
4395
4396static bfd_boolean
4397create_linkage_sections (bfd *dynobj, struct bfd_link_info *info)
4398{
4399 struct ppc_link_hash_table *htab;
4400 flagword flags;
4401
4402 htab = ppc_hash_table (info);
4403
bfeb4a28
AM		 4404 flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY
4405 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
b32547cd
AM		 4406 if (htab->params->save_restore_funcs)
4407 {
4408 /* Create .sfpr for code to save and restore fp regs. */
4409 htab->sfpr = bfd_make_section_anyway_with_flags (dynobj, ".sfpr",
4410 flags);
4411 if (htab->sfpr == NULL
4412 || ! bfd_set_section_alignment (dynobj, htab->sfpr, 2))
4413 return FALSE;
4414 }
4415
4416 if (bfd_link_relocatable (info))
4417 return TRUE;
bfeb4a28
AM		 4418
4419 /* Create .glink for lazy dynamic linking support. */
4420 htab->glink = bfd_make_section_anyway_with_flags (dynobj, ".glink",
4421 flags);
4422 if (htab->glink == NULL
4423 || ! bfd_set_section_alignment (dynobj, htab->glink, 3))
4424 return FALSE;
4425
4426 if (!info->no_ld_generated_unwind_info)
4427 {
4428 flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_HAS_CONTENTS
4429 | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4430 htab->glink_eh_frame = bfd_make_section_anyway_with_flags (dynobj,
4431 ".eh_frame",
4432 flags);
4433 if (htab->glink_eh_frame == NULL
4434 || !bfd_set_section_alignment (dynobj, htab->glink_eh_frame, 2))
4435 return FALSE;
4436 }
4437
4438 flags = SEC_ALLOC | SEC_LINKER_CREATED;
33e44f2e
AM		 4439 htab->elf.iplt = bfd_make_section_anyway_with_flags (dynobj, ".iplt", flags);
4440 if (htab->elf.iplt == NULL
4441 || ! bfd_set_section_alignment (dynobj, htab->elf.iplt, 3))
bfeb4a28
AM		 4442 return FALSE;
4443
4444 flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4445 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
33e44f2e
AM		 4446 htab->elf.irelplt
4447 = bfd_make_section_anyway_with_flags (dynobj, ".rela.iplt", flags);
4448 if (htab->elf.irelplt == NULL
4449 || ! bfd_set_section_alignment (dynobj, htab->elf.irelplt, 3))
bfeb4a28
AM		 4450 return FALSE;
4451
4452 /* Create branch lookup table for plt_branch stubs. */
4453 flags = (SEC_ALLOC | SEC_LOAD
4454 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4455 htab->brlt = bfd_make_section_anyway_with_flags (dynobj, ".branch_lt",
4456 flags);
4457 if (htab->brlt == NULL
4458 || ! bfd_set_section_alignment (dynobj, htab->brlt, 3))
4459 return FALSE;
4460
0e1862bb 4461 if (!bfd_link_pic (info))
bfeb4a28
AM		 4462 return TRUE;
4463
4464 flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4465 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4466 htab->relbrlt = bfd_make_section_anyway_with_flags (dynobj,
4467 ".rela.branch_lt",
4468 flags);
4469 if (htab->relbrlt == NULL
4470 || ! bfd_set_section_alignment (dynobj, htab->relbrlt, 3))
4471 return FALSE;
4472
4473 return TRUE;
4474}
4475
e717da7e
AM		 4476/* Satisfy the ELF linker by filling in some fields in our fake bfd. */
4477
bfeb4a28 4478bfd_boolean
e7d1c40c
AM		 4479ppc64_elf_init_stub_bfd (struct bfd_link_info *info,
4480 struct ppc64_elf_params *params)
e717da7e
AM		 4481{
4482 struct ppc_link_hash_table *htab;
4483
e7d1c40c 4484 elf_elfheader (params->stub_bfd)->e_ident[EI_CLASS] = ELFCLASS64;
e717da7e
AM		 4485
4486/* Always hook our dynamic sections into the first bfd, which is the
4487 linker created stub bfd. This ensures that the GOT header is at
4488 the start of the output TOC section. */
4489 htab = ppc_hash_table (info);
e7d1c40c
AM		 4490 htab->elf.dynobj = params->stub_bfd;
4491 htab->params = params;
bfeb4a28 4492
bfeb4a28 4493 return create_linkage_sections (htab->elf.dynobj, info);
e717da7e
AM		 4494}
4495
721956f4
AM		 4496/* Build a name for an entry in the stub hash table. */
4497
4498static char *
4ce794b7
AM		 4499ppc_stub_name (const asection *input_section,
4500 const asection *sym_sec,
4501 const struct ppc_link_hash_entry *h,
4502 const Elf_Internal_Rela *rel)
721956f4
AM		 4503{
4504 char *stub_name;
bcaa2f82 4505 ssize_t len;
721956f4
AM		 4506
4507 /* rel->r_addend is actually 64 bit, but who uses more than +/- 2^31
4508 offsets from a sym as a branch target? In fact, we could
4509 probably assume the addend is always zero. */
4510 BFD_ASSERT (((int) rel->r_addend & 0xffffffff) == rel->r_addend);
4511
4512 if (h)
4513 {
4514 len = 8 + 1 + strlen (h->elf.root.root.string) + 1 + 8 + 1;
4515 stub_name = bfd_malloc (len);
46de2a7c
AM		 4516 if (stub_name == NULL)
4517 return stub_name;
4518
bcaa2f82
AM		 4519 len = sprintf (stub_name, "%08x.%s+%x",
4520 input_section->id & 0xffffffff,
4521 h->elf.root.root.string,
4522 (int) rel->r_addend & 0xffffffff);
721956f4
AM		 4523 }
4524 else
4525 {
ad8e1ba5 4526 len = 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1;
721956f4 4527 stub_name = bfd_malloc (len);
46de2a7c
AM		 4528 if (stub_name == NULL)
4529 return stub_name;
4530
bcaa2f82
AM		 4531 len = sprintf (stub_name, "%08x.%x:%x+%x",
4532 input_section->id & 0xffffffff,
4533 sym_sec->id & 0xffffffff,
4534 (int) ELF64_R_SYM (rel->r_info) & 0xffffffff,
4535 (int) rel->r_addend & 0xffffffff);
721956f4 4536 }
bcaa2f82 4537 if (len > 2 && stub_name[len - 2] == '+' && stub_name[len - 1] == '0')
ee75fd95 4538 stub_name[len - 2] = 0;
721956f4
AM		 4539 return stub_name;
4540}
4541
4542/* Look up an entry in the stub hash. Stub entries are cached because
4543 creating the stub name takes a bit of time. */
4544
4545static struct ppc_stub_hash_entry *
4ce794b7
AM		 4546ppc_get_stub_entry (const asection *input_section,
4547 const asection *sym_sec,
039b3fef 4548 struct ppc_link_hash_entry *h,
4ce794b7
AM		 4549 const Elf_Internal_Rela *rel,
4550 struct ppc_link_hash_table *htab)
721956f4
AM		 4551{
4552 struct ppc_stub_hash_entry *stub_entry;
6f20ed8a 4553 struct map_stub *group;
721956f4
AM		 4554
4555 /* If this input section is part of a group of sections sharing one
4556 stub section, then use the id of the first section in the group.
4557 Stub names need to include a section id, as there may well be
4558 more than one stub used to reach say, printf, and we need to
4559 distinguish between them. */
6f20ed8a 4560 group = htab->sec_info[input_section->id].u.group;
89d77b8a
AM		 4561 if (group == NULL)
4562 return NULL;
721956f4 4563
b3fac117
AM		 4564 if (h != NULL && h->u.stub_cache != NULL
4565 && h->u.stub_cache->h == h
6f20ed8a 4566 && h->u.stub_cache->group == group)
721956f4 4567 {
b3fac117 4568 stub_entry = h->u.stub_cache;
721956f4
AM		 4569 }
4570 else
4571 {
4572 char *stub_name;
4573
6f20ed8a 4574 stub_name = ppc_stub_name (group->link_sec, sym_sec, h, rel);
721956f4
AM		 4575 if (stub_name == NULL)
4576 return NULL;
4577
4578 stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
b34976b6 4579 stub_name, FALSE, FALSE);
721956f4 4580 if (h != NULL)
b3fac117 4581 h->u.stub_cache = stub_entry;
721956f4
AM		 4582
4583 free (stub_name);
4584 }
4585
4586 return stub_entry;
4587}
4588
4589/* Add a new stub entry to the stub hash. Not all fields of the new
4590 stub entry are initialised. */
4591
4592static struct ppc_stub_hash_entry *
4ce794b7
AM		 4593ppc_add_stub (const char *stub_name,
4594 asection *section,
25f53a85 4595 struct bfd_link_info *info)
721956f4 4596{
25f53a85 4597 struct ppc_link_hash_table *htab = ppc_hash_table (info);
6f20ed8a 4598 struct map_stub *group;
721956f4
AM		 4599 asection *link_sec;
4600 asection *stub_sec;
4601 struct ppc_stub_hash_entry *stub_entry;
4602
6f20ed8a
AM		 4603 group = htab->sec_info[section->id].u.group;
4604 link_sec = group->link_sec;
4605 stub_sec = group->stub_sec;
721956f4
AM		 4606 if (stub_sec == NULL)
4607 {
6f20ed8a
AM		 4608 size_t namelen;
4609 bfd_size_type len;
4610 char *s_name;
721956f4 4611
6f20ed8a
AM		 4612 namelen = strlen (link_sec->name);
4613 len = namelen + sizeof (STUB_SUFFIX);
4614 s_name = bfd_alloc (htab->params->stub_bfd, len);
4615 if (s_name == NULL)
4616 return NULL;
721956f4 4617
6f20ed8a
AM		 4618 memcpy (s_name, link_sec->name, namelen);
4619 memcpy (s_name + namelen, STUB_SUFFIX, sizeof (STUB_SUFFIX));
4620 stub_sec = (*htab->params->add_stub_section) (s_name, link_sec);
4621 if (stub_sec == NULL)
4622 return NULL;
4623 group->stub_sec = stub_sec;
721956f4
AM		 4624 }
4625
4626 /* Enter this entry into the linker stub hash table. */
4627 stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table, stub_name,
b34976b6 4628 TRUE, FALSE);
721956f4
AM		 4629 if (stub_entry == NULL)
4630 {
695344c0 4631 /* xgettext:c-format */
8de848d8 4632 info->callbacks->einfo (_("%P: %B: cannot create stub entry %s\n"),
25f53a85 4633 section->owner, stub_name);
721956f4
AM		 4634 return NULL;
4635 }
4636
6f20ed8a 4637 stub_entry->group = group;
721956f4 4638 stub_entry->stub_offset = 0;
721956f4
AM		 4639 return stub_entry;
4640}
4641
e717da7e
AM		 4642/* Create .got and .rela.got sections in ABFD, and .got in dynobj if
4643 not already done. */
65f38f15 4644
b34976b6 4645static bfd_boolean
e717da7e 4646create_got_section (bfd *abfd, struct bfd_link_info *info)
65f38f15 4647{
e717da7e
AM		 4648 asection *got, *relgot;
4649 flagword flags;
4650 struct ppc_link_hash_table *htab = ppc_hash_table (info);
65f38f15 4651
0c8d6e5c 4652 if (!is_ppc64_elf (abfd))
0ffa91dd 4653 return FALSE;
4dfe6ac6
NC		 4654 if (htab == NULL)
4655 return FALSE;
0ffa91dd 4656
33e44f2e
AM		 4657 if (!htab->elf.sgot
4658 && !_bfd_elf_create_got_section (htab->elf.dynobj, info))
4659 return FALSE;
e717da7e
AM		 4660
4661 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
4662 | SEC_LINKER_CREATED);
4663
c456f082 4664 got = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
e717da7e 4665 if (!got
e717da7e
AM		 4666 || !bfd_set_section_alignment (abfd, got, 3))
4667 return FALSE;
65f38f15 4668
c456f082
AM		 4669 relgot = bfd_make_section_anyway_with_flags (abfd, ".rela.got",
4670 flags | SEC_READONLY);
e717da7e 4671 if (!relgot
e717da7e 4672 || ! bfd_set_section_alignment (abfd, relgot, 3))
b34976b6 4673 return FALSE;
e717da7e
AM		 4674
4675 ppc64_elf_tdata (abfd)->got = got;
4676 ppc64_elf_tdata (abfd)->relgot = relgot;
b34976b6 4677 return TRUE;
65f38f15 4678}
5bd4f169 4679
b31867b6
AM		 4680/* Follow indirect and warning symbol links. */
4681
4682static inline struct bfd_link_hash_entry *
4683follow_link (struct bfd_link_hash_entry *h)
4684{
4685 while (h->type == bfd_link_hash_indirect
4686 || h->type == bfd_link_hash_warning)
4687 h = h->u.i.link;
4688 return h;
4689}
4690
4691static inline struct elf_link_hash_entry *
4692elf_follow_link (struct elf_link_hash_entry *h)
4693{
4694 return (struct elf_link_hash_entry *) follow_link (&h->root);
4695}
4696
4697static inline struct ppc_link_hash_entry *
4698ppc_follow_link (struct ppc_link_hash_entry *h)
4699{
4700 return (struct ppc_link_hash_entry *) follow_link (&h->elf.root);
4701}
4702
40d16e0b
AM		 4703/* Merge PLT info on FROM with that on TO. */
4704
4705static void
4706move_plt_plist (struct ppc_link_hash_entry *from,
4707 struct ppc_link_hash_entry *to)
4708{
4709 if (from->elf.plt.plist != NULL)
4710 {
4711 if (to->elf.plt.plist != NULL)
4712 {
4713 struct plt_entry **entp;
4714 struct plt_entry *ent;
4715
4716 for (entp = &from->elf.plt.plist; (ent = *entp) != NULL; )
4717 {
4718 struct plt_entry *dent;
4719
4720 for (dent = to->elf.plt.plist; dent != NULL; dent = dent->next)
4721 if (dent->addend == ent->addend)
4722 {
4723 dent->plt.refcount += ent->plt.refcount;
4724 *entp = ent->next;
4725 break;
4726 }
4727 if (dent == NULL)
4728 entp = &ent->next;
4729 }
4730 *entp = to->elf.plt.plist;
4731 }
4732
4733 to->elf.plt.plist = from->elf.plt.plist;
4734 from->elf.plt.plist = NULL;
4735 }
4736}
4737
65f38f15
AM		 4738/* Copy the extra info we tack onto an elf_link_hash_entry. */
4739
4740static void
fcfa13d2
AM		 4741ppc64_elf_copy_indirect_symbol (struct bfd_link_info *info,
4742 struct elf_link_hash_entry *dir,
4743 struct elf_link_hash_entry *ind)
65f38f15
AM		 4744{
4745 struct ppc_link_hash_entry *edir, *eind;
4746
4747 edir = (struct ppc_link_hash_entry *) dir;
4748 eind = (struct ppc_link_hash_entry *) ind;
4749
c79d6685
AM		 4750 edir->is_func |= eind->is_func;
4751 edir->is_func_descriptor |= eind->is_func_descriptor;
4752 edir->tls_mask |= eind->tls_mask;
4753 if (eind->oh != NULL)
4754 edir->oh = ppc_follow_link (eind->oh);
4755
e81830c5
AM		 4756 /* If called to transfer flags for a weakdef during processing
4757 of elf_adjust_dynamic_symbol, don't copy NON_GOT_REF.
4758 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
4759 if (!(ELIMINATE_COPY_RELOCS
4760 && eind->elf.root.type != bfd_link_hash_indirect
4761 && edir->elf.dynamic_adjusted))
4762 edir->elf.non_got_ref |= eind->elf.non_got_ref;
4763
474436e6 4764 if (edir->elf.versioned != versioned_hidden)
e81830c5
AM		 4765 edir->elf.ref_dynamic |= eind->elf.ref_dynamic;
4766 edir->elf.ref_regular |= eind->elf.ref_regular;
4767 edir->elf.ref_regular_nonweak |= eind->elf.ref_regular_nonweak;
4768 edir->elf.needs_plt |= eind->elf.needs_plt;
4769 edir->elf.pointer_equality_needed |= eind->elf.pointer_equality_needed;
c79d6685 4770
d311bc8b
AM		 4771 /* If we were called to copy over info for a weak sym, don't copy
4772 dyn_relocs, plt/got info, or dynindx. We used to copy dyn_relocs
4773 in order to simplify readonly_dynrelocs and save a field in the
4774 symbol hash entry, but that means dyn_relocs can't be used in any
4775 tests about a specific symbol, or affect other symbol flags which
4776 are then tested.
4777 Chain weakdefs so we can get from the weakdef back to an alias.
4778 The list is circular so that we don't need to use u.weakdef as
4779 well as this list to look at all aliases. */
4780 if (eind->elf.root.type != bfd_link_hash_indirect)
4781 {
4782 struct ppc_link_hash_entry *cur, *add, *next;
4783
4784 add = eind;
4785 do
4786 {
4787 cur = edir->weakref;
4788 if (cur != NULL)
4789 {
4790 do
4791 {
4792 /* We can be called twice for the same symbols.
4793 Don't make multiple loops. */
4794 if (cur == add)
4795 return;
4796 cur = cur->weakref;
4797 } while (cur != edir);
4798 }
4799 next = add->weakref;
4800 if (cur != add)
4801 {
4802 add->weakref = edir->weakref != NULL ? edir->weakref : edir;
4803 edir->weakref = add;
4804 }
4805 add = next;
4806 } while (add != NULL && add != eind);
4807 return;
4808 }
4809
411e1bfb 4810 /* Copy over any dynamic relocs we may have on the indirect sym. */
bbd7ec4a 4811 if (eind->dyn_relocs != NULL)
65f38f15 4812 {
bbd7ec4a
AM		 4813 if (edir->dyn_relocs != NULL)
4814 {
6061a67d
AM		 4815 struct elf_dyn_relocs **pp;
4816 struct elf_dyn_relocs *p;
bbd7ec4a 4817
fcfa13d2 4818 /* Add reloc counts against the indirect sym to the direct sym
bbd7ec4a
AM		 4819 list. Merge any entries against the same section. */
4820 for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
4821 {
6061a67d 4822 struct elf_dyn_relocs *q;
bbd7ec4a
AM		 4823
4824 for (q = edir->dyn_relocs; q != NULL; q = q->next)
4825 if (q->sec == p->sec)
4826 {
4827 q->pc_count += p->pc_count;
4828 q->count += p->count;
4829 *pp = p->next;
4830 break;
4831 }
4832 if (q == NULL)
4833 pp = &p->next;
4834 }
4835 *pp = edir->dyn_relocs;
4836 }
4837
65f38f15
AM		 4838 edir->dyn_relocs = eind->dyn_relocs;
4839 eind->dyn_relocs = NULL;
4840 }
65f38f15 4841
81848ca0
AM		 4842 /* Copy over got entries that we may have already seen to the
4843 symbol which just became indirect. */
411e1bfb
AM		 4844 if (eind->elf.got.glist != NULL)
4845 {
4846 if (edir->elf.got.glist != NULL)
4847 {
4848 struct got_entry **entp;
4849 struct got_entry *ent;
4850
4851 for (entp = &eind->elf.got.glist; (ent = *entp) != NULL; )
4852 {
4853 struct got_entry *dent;
4854
4855 for (dent = edir->elf.got.glist; dent != NULL; dent = dent->next)
4856 if (dent->addend == ent->addend
e717da7e 4857 && dent->owner == ent->owner
411e1bfb
AM		 4858 && dent->tls_type == ent->tls_type)
4859 {
4860 dent->got.refcount += ent->got.refcount;
4861 *entp = ent->next;
4862 break;
4863 }
4864 if (dent == NULL)
4865 entp = &ent->next;
4866 }
4867 *entp = edir->elf.got.glist;
4868 }
4869
4870 edir->elf.got.glist = eind->elf.got.glist;
4871 eind->elf.got.glist = NULL;
4872 }
4873
4874 /* And plt entries. */
40d16e0b 4875 move_plt_plist (eind, edir);
411e1bfb 4876
fcfa13d2 4877 if (eind->elf.dynindx != -1)
411e1bfb 4878 {
fcfa13d2
AM		 4879 if (edir->elf.dynindx != -1)
4880 _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
4881 edir->elf.dynstr_index);
411e1bfb
AM		 4882 edir->elf.dynindx = eind->elf.dynindx;
4883 edir->elf.dynstr_index = eind->elf.dynstr_index;
4884 eind->elf.dynindx = -1;
4885 eind->elf.dynstr_index = 0;
4886 }
411e1bfb
AM		 4887}
4888
8387904d
AM		 4889/* Find the function descriptor hash entry from the given function code
4890 hash entry FH. Link the entries via their OH fields. */
4891
4892static struct ppc_link_hash_entry *
b31867b6 4893lookup_fdh (struct ppc_link_hash_entry *fh, struct ppc_link_hash_table *htab)
8387904d
AM		 4894{
4895 struct ppc_link_hash_entry *fdh = fh->oh;
4896
4897 if (fdh == NULL)
4898 {
4899 const char *fd_name = fh->elf.root.root.string + 1;
4900
4901 fdh = (struct ppc_link_hash_entry *)
4902 elf_link_hash_lookup (&htab->elf, fd_name, FALSE, FALSE, FALSE);
b31867b6
AM		 4903 if (fdh == NULL)
4904 return fdh;
4905
4906 fdh->is_func_descriptor = 1;
4907 fdh->oh = fh;
4908 fh->is_func = 1;
4909 fh->oh = fdh;
8387904d
AM		 4910 }
4911
8c5b4e52
AM		 4912 fdh = ppc_follow_link (fdh);
4913 fdh->is_func_descriptor = 1;
4914 fdh->oh = fh;
4915 return fdh;
8387904d
AM		 4916}
4917
8c5b4e52 4918/* Make a fake function descriptor sym for the undefined code sym FH. */
bb700d78
AM		 4919
4920static struct ppc_link_hash_entry *
4921make_fdh (struct bfd_link_info *info,
908b32fc 4922 struct ppc_link_hash_entry *fh)
bb700d78 4923{
8c5b4e52
AM		 4924 bfd *abfd = fh->elf.root.u.undef.abfd;
4925 struct bfd_link_hash_entry *bh = NULL;
bb700d78 4926 struct ppc_link_hash_entry *fdh;
8c5b4e52
AM		 4927 flagword flags = (fh->elf.root.type == bfd_link_hash_undefweak
4928 ? BSF_WEAK
4929 : BSF_GLOBAL);
4930
4931 if (!_bfd_generic_link_add_one_symbol (info, abfd,
4932 fh->elf.root.root.string + 1,
4933 flags, bfd_und_section_ptr, 0,
4934 NULL, FALSE, FALSE, &bh))
bb700d78
AM		 4935 return NULL;
4936
4937 fdh = (struct ppc_link_hash_entry *) bh;
4938 fdh->elf.non_elf = 0;
908b32fc
AM		 4939 fdh->fake = 1;
4940 fdh->is_func_descriptor = 1;
4941 fdh->oh = fh;
4942 fh->is_func = 1;
4943 fh->oh = fdh;
bb700d78
AM		 4944 return fdh;
4945}
4946
8387904d
AM		 4947/* Fix function descriptor symbols defined in .opd sections to be
4948 function type. */
555cd476
AM		 4949
4950static bfd_boolean
c16153ae 4951ppc64_elf_add_symbol_hook (bfd *ibfd,
e054468f 4952 struct bfd_link_info *info,
555cd476 4953 Elf_Internal_Sym *isym,
6911b7dc 4954 const char **name,
555cd476
AM		 4955 flagword *flags ATTRIBUTE_UNUSED,
4956 asection **sec,
b53dfeb2 4957 bfd_vma *value)
555cd476 4958{
a43942db 4959 if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC
f1885d1e
AM		 4960 && (ibfd->flags & DYNAMIC) == 0
4961 && bfd_get_flavour (info->output_bfd) == bfd_target_elf_flavour)
a43942db 4962 elf_tdata (info->output_bfd)->has_gnu_symbols |= elf_gnu_symbol_ifunc;
f64b2e8d 4963
b53dfeb2 4964 if (*sec != NULL
f1885d1e 4965 && strcmp ((*sec)->name, ".opd") == 0)
b53dfeb2
AM		 4966 {
4967 asection *code_sec;
4968
4969 if (!(ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC
4970 || ELF_ST_TYPE (isym->st_info) == STT_FUNC))
4971 isym->st_info = ELF_ST_INFO (ELF_ST_BIND (isym->st_info), STT_FUNC);
4972
4973 /* If the symbol is a function defined in .opd, and the function
4974 code is in a discarded group, let it appear to be undefined. */
0e1862bb 4975 if (!bfd_link_relocatable (info)
b53dfeb2
AM		 4976 && (*sec)->reloc_count != 0
4977 && opd_entry_value (*sec, *value, &code_sec, NULL,
4978 FALSE) != (bfd_vma) -1
4979 && discarded_section (code_sec))
4980 {
4981 *sec = bfd_und_section_ptr;
4982 isym->st_shndx = SHN_UNDEF;
4983 }
4984 }
dbd1e97e
AM		 4985 else if (*sec != NULL
4986 && strcmp ((*sec)->name, ".toc") == 0
4987 && ELF_ST_TYPE (isym->st_info) == STT_OBJECT)
4988 {
4989 struct ppc_link_hash_table *htab = ppc_hash_table (info);
4990 if (htab != NULL)
4991 htab->params->object_in_toc = 1;
4992 }
433817dd 4993
6911b7dc
AM		 4994 if ((STO_PPC64_LOCAL_MASK & isym->st_other) != 0)
4995 {
4996 if (abiversion (ibfd) == 0)
4997 set_abiversion (ibfd, 2);
4998 else if (abiversion (ibfd) == 1)
4999 {
5000 info->callbacks->einfo (_("%P: symbol '%s' has invalid st_other"
5001 " for ABI version 1\n"), name);
5002 bfd_set_error (bfd_error_bad_value);
5003 return FALSE;
5004 }
5005 }
5006
555cd476
AM		 5007 return TRUE;
5008}
5009
6911b7dc
AM		 5010/* Merge non-visibility st_other attributes: local entry point. */
5011
5012static void
5013ppc64_elf_merge_symbol_attribute (struct elf_link_hash_entry *h,
5014 const Elf_Internal_Sym *isym,
5015 bfd_boolean definition,
5016 bfd_boolean dynamic)
5017{
f378ab09 5018 if (definition && (!dynamic || !h->def_regular))
6911b7dc
AM		 5019 h->other = ((isym->st_other & ~ELF_ST_VISIBILITY (-1))
5020 | ELF_ST_VISIBILITY (h->other));
5021}
5022
8c5b4e52
AM		 5023/* Hook called on merging a symbol. We use this to clear "fake" since
5024 we now have a real symbol. */
5025
5026static bfd_boolean
5027ppc64_elf_merge_symbol (struct elf_link_hash_entry *h,
8b5f1ed8 5028 const Elf_Internal_Sym *isym,
8c5b4e52
AM		 5029 asection **psec ATTRIBUTE_UNUSED,
5030 bfd_boolean newdef ATTRIBUTE_UNUSED,
5031 bfd_boolean olddef ATTRIBUTE_UNUSED,
5032 bfd *oldbfd ATTRIBUTE_UNUSED,
5033 const asection *oldsec ATTRIBUTE_UNUSED)
5034{
5035 ((struct ppc_link_hash_entry *) h)->fake = 0;
8b5f1ed8
AM		 5036 if ((STO_PPC64_LOCAL_MASK & isym->st_other) != 0)
5037 ((struct ppc_link_hash_entry *) h)->non_zero_localentry = 1;
8c5b4e52
AM		 5038 return TRUE;
5039}
5040
8387904d 5041/* This function makes an old ABI object reference to ".bar" cause the
908b32fc
AM		 5042 inclusion of a new ABI object archive that defines "bar".
5043 NAME is a symbol defined in an archive. Return a symbol in the hash
5044 table that might be satisfied by the archive symbols. */
8387904d
AM		 5045
5046static struct elf_link_hash_entry *
5047ppc64_elf_archive_symbol_lookup (bfd *abfd,
5048 struct bfd_link_info *info,
5049 const char *name)
5050{
5051 struct elf_link_hash_entry *h;
5052 char *dot_name;
5053 size_t len;
5054
5055 h = _bfd_elf_archive_symbol_lookup (abfd, info, name);
908b32fc
AM		 5056 if (h != NULL
5057 /* Don't return this sym if it is a fake function descriptor
5058 created by add_symbol_adjust. */
8c5b4e52 5059 && !((struct ppc_link_hash_entry *) h)->fake)
8387904d
AM		 5060 return h;
5061
5062 if (name[0] == '.')
5063 return h;
5064
5065 len = strlen (name);
5066 dot_name = bfd_alloc (abfd, len + 2);
5067 if (dot_name == NULL)
5068 return (struct elf_link_hash_entry *) 0 - 1;
5069 dot_name[0] = '.';
5070 memcpy (dot_name + 1, name, len + 1);
5071 h = _bfd_elf_archive_symbol_lookup (abfd, info, dot_name);
5072 bfd_release (abfd, dot_name);
5073 return h;
5074}
5075
5076/* This function satisfies all old ABI object references to ".bar" if a
99877b66
AM		 5077 new ABI object defines "bar". Well, at least, undefined dot symbols
5078 are made weak. This stops later archive searches from including an
5079 object if we already have a function descriptor definition. It also
35b0ce59
AM		 5080 prevents the linker complaining about undefined symbols.
5081 We also check and correct mismatched symbol visibility here. The
5082 most restrictive visibility of the function descriptor and the
5083 function entry symbol is used. */
8387904d
AM		 5084
5085static bfd_boolean
b3fac117 5086add_symbol_adjust (struct ppc_link_hash_entry *eh, struct bfd_link_info *info)
8387904d 5087{
8387904d
AM		 5088 struct ppc_link_hash_table *htab;
5089 struct ppc_link_hash_entry *fdh;
5090
b3fac117
AM		 5091 if (eh->elf.root.type == bfd_link_hash_warning)
5092 eh = (struct ppc_link_hash_entry *) eh->elf.root.u.i.link;
8387904d 5093
8400d40d
AM		 5094 if (eh->elf.root.type == bfd_link_hash_indirect)
5095 return TRUE;
5096
b3fac117
AM		 5097 if (eh->elf.root.root.string[0] != '.')
5098 abort ();
8387904d 5099
b3fac117 5100 htab = ppc_hash_table (info);
4dfe6ac6
NC		 5101 if (htab == NULL)
5102 return FALSE;
5103
b31867b6 5104 fdh = lookup_fdh (eh, htab);
8c5b4e52
AM		 5105 if (fdh == NULL
5106 && !bfd_link_relocatable (info)
5107 && (eh->elf.root.type == bfd_link_hash_undefined
5108 || eh->elf.root.type == bfd_link_hash_undefweak)
5109 && eh->elf.ref_regular)
5110 {
5111 /* Make an undefined function descriptor sym, in order to
5112 pull in an --as-needed shared lib. Archives are handled
5113 elsewhere. */
5114 fdh = make_fdh (info, eh);
5115 if (fdh == NULL)
5116 return FALSE;
bb700d78 5117 }
8c5b4e52
AM		 5118
5119 if (fdh != NULL)
8387904d 5120 {
35b0ce59
AM		 5121 unsigned entry_vis = ELF_ST_VISIBILITY (eh->elf.other) - 1;
5122 unsigned descr_vis = ELF_ST_VISIBILITY (fdh->elf.other) - 1;
8c5b4e52
AM		 5123
5124 /* Make both descriptor and entry symbol have the most
5125 constraining visibility of either symbol. */
35b0ce59
AM		 5126 if (entry_vis < descr_vis)
5127 fdh->elf.other += entry_vis - descr_vis;
5128 else if (entry_vis > descr_vis)
5129 eh->elf.other += descr_vis - entry_vis;
5130
8c5b4e52
AM		 5131 /* Propagate reference flags from entry symbol to function
5132 descriptor symbol. */
bc4e12de 5133 fdh->elf.root.non_ir_ref_regular |= eh->elf.root.non_ir_ref_regular;
4070765b 5134 fdh->elf.root.non_ir_ref_dynamic |= eh->elf.root.non_ir_ref_dynamic;
8c5b4e52
AM		 5135 fdh->elf.ref_regular |= eh->elf.ref_regular;
5136 fdh->elf.ref_regular_nonweak |= eh->elf.ref_regular_nonweak;
5137
5138 if (!fdh->elf.forced_local
5139 && fdh->elf.dynindx == -1
5140 && fdh->elf.versioned != versioned_hidden
5141 && (bfd_link_dll (info)
5142 || fdh->elf.def_dynamic
5143 || fdh->elf.ref_dynamic)
5144 && (eh->elf.ref_regular
5145 || eh->elf.def_regular))
5146 {
5147 if (! bfd_elf_link_record_dynamic_symbol (info, &fdh->elf))
5148 return FALSE;
35b0ce59 5149 }
8387904d 5150 }
99877b66 5151
8387904d
AM		 5152 return TRUE;
5153}
5154
f6c7c3e8
AM		 5155/* Set up opd section info and abiversion for IBFD, and process list
5156 of dot-symbols we made in link_hash_newfunc. */
b3fac117 5157
8387904d 5158static bfd_boolean
f6c7c3e8 5159ppc64_elf_before_check_relocs (bfd *ibfd, struct bfd_link_info *info)
8387904d 5160{
99877b66 5161 struct ppc_link_hash_table *htab;
b3fac117 5162 struct ppc_link_hash_entry **p, *eh;
459609d6 5163 asection *opd = bfd_get_section_by_name (ibfd, ".opd");
433817dd 5164
459609d6 5165 if (opd != NULL && opd->size != 0)
b3fac117 5166 {
459609d6
AM		 5167 if (abiversion (ibfd) == 0)
5168 set_abiversion (ibfd, 1);
8a2058b5 5169 else if (abiversion (ibfd) >= 2)
f6c7c3e8 5170 {
695344c0 5171 /* xgettext:c-format */
459609d6
AM		 5172 info->callbacks->einfo (_("%P: %B .opd not allowed in ABI"
5173 " version %d\n"),
5174 ibfd, abiversion (ibfd));
5175 bfd_set_error (bfd_error_bad_value);
5176 return FALSE;
f6c7c3e8
AM		 5177 }
5178
459609d6
AM		 5179 if ((ibfd->flags & DYNAMIC) == 0
5180 && (opd->flags & SEC_RELOC) != 0
5181 && opd->reloc_count != 0
5182 && !bfd_is_abs_section (opd->output_section))
b3fac117 5183 {
459609d6
AM		 5184 /* Garbage collection needs some extra help with .opd sections.
5185 We don't want to necessarily keep everything referenced by
5186 relocs in .opd, as that would keep all functions. Instead,
5187 if we reference an .opd symbol (a function descriptor), we
5188 want to keep the function code symbol's section. This is
5189 easy for global symbols, but for local syms we need to keep
5190 information about the associated function section. */
5191 bfd_size_type amt;
5192 asection **opd_sym_map;
5193
51aecdc5 5194 amt = OPD_NDX (opd->size) * sizeof (*opd_sym_map);
459609d6
AM		 5195 opd_sym_map = bfd_zalloc (ibfd, amt);
5196 if (opd_sym_map == NULL)
b3fac117 5197 return FALSE;
459609d6
AM		 5198 ppc64_elf_section_data (opd)->u.opd.func_sec = opd_sym_map;
5199 BFD_ASSERT (ppc64_elf_section_data (opd)->sec_type == sec_normal);
5200 ppc64_elf_section_data (opd)->sec_type = sec_opd;
b3fac117
AM		 5201 }
5202 }
5203
459609d6
AM		 5204 if (!is_ppc64_elf (info->output_bfd))
5205 return TRUE;
5206 htab = ppc_hash_table (info);
5207 if (htab == NULL)
5208 return FALSE;
5209
5210 /* For input files without an explicit abiversion in e_flags
5211 we should have flagged any with symbol st_other bits set
5212 as ELFv1 and above flagged those with .opd as ELFv2.
5213 Set the output abiversion if not yet set, and for any input
5214 still ambiguous, take its abiversion from the output.
5215 Differences in ABI are reported later. */
5216 if (abiversion (info->output_bfd) == 0)
5217 set_abiversion (info->output_bfd, abiversion (ibfd));
5218 else if (abiversion (ibfd) == 0)
5219 set_abiversion (ibfd, abiversion (info->output_bfd));
5220
5221 p = &htab->dot_syms;
5222 while ((eh = *p) != NULL)
5223 {
5224 *p = NULL;
5225 if (&eh->elf == htab->elf.hgot)
5226 ;
5227 else if (htab->elf.hgot == NULL
5228 && strcmp (eh->elf.root.root.string, ".TOC.") == 0)
5229 htab->elf.hgot = &eh->elf;
8c5b4e52
AM		 5230 else if (abiversion (ibfd) <= 1)
5231 {
5232 htab->need_func_desc_adj = 1;
5233 if (!add_symbol_adjust (eh, info))
5234 return FALSE;
5235 }
459609d6
AM		 5236 p = &eh->u.next_dot_sym;
5237 }
b3fac117 5238 return TRUE;
8387904d
AM		 5239}
5240
97fed1c9
JJ		 5241/* Undo hash table changes when an --as-needed input file is determined
5242 not to be needed. */
5243
5244static bfd_boolean
e5034e59
AM		 5245ppc64_elf_notice_as_needed (bfd *ibfd,
5246 struct bfd_link_info *info,
5247 enum notice_asneeded_action act)
97fed1c9 5248{
e5034e59
AM		 5249 if (act == notice_not_needed)
5250 {
5251 struct ppc_link_hash_table *htab = ppc_hash_table (info);
4dfe6ac6 5252
e5034e59
AM		 5253 if (htab == NULL)
5254 return FALSE;
4dfe6ac6 5255
e5034e59
AM		 5256 htab->dot_syms = NULL;
5257 }
5258 return _bfd_elf_notice_as_needed (ibfd, info, act);
97fed1c9
JJ		 5259}
5260
aa374f67
AM		 5261/* If --just-symbols against a final linked binary, then assume we need
5262 toc adjusting stubs when calling functions defined there. */
5263
5264static void
5265ppc64_elf_link_just_syms (asection *sec, struct bfd_link_info *info)
5266{
5267 if ((sec->flags & SEC_CODE) != 0
5268 && (sec->owner->flags & (EXEC_P | DYNAMIC)) != 0
5269 && is_ppc64_elf (sec->owner))
5270 {
2c3f079f
AM		 5271 if (abiversion (sec->owner) >= 2
5272 || bfd_get_section_by_name (sec->owner, ".opd") != NULL)
aa374f67
AM		 5273 sec->has_toc_reloc = 1;
5274 }
5275 _bfd_elf_link_just_syms (sec, info);
5276}
5277
e054468f 5278static struct plt_entry **
4ce794b7
AM		 5279update_local_sym_info (bfd *abfd, Elf_Internal_Shdr *symtab_hdr,
5280 unsigned long r_symndx, bfd_vma r_addend, int tls_type)
411e1bfb
AM		 5281{
5282 struct got_entry **local_got_ents = elf_local_got_ents (abfd);
e054468f 5283 struct plt_entry **local_plt;
f961d9dd 5284 unsigned char *local_got_tls_masks;
411e1bfb
AM		 5285
5286 if (local_got_ents == NULL)
5287 {
5288 bfd_size_type size = symtab_hdr->sh_info;
5289
e054468f
AM		 5290 size *= (sizeof (*local_got_ents)
5291 + sizeof (*local_plt)
5292 + sizeof (*local_got_tls_masks));
4ce794b7 5293 local_got_ents = bfd_zalloc (abfd, size);
411e1bfb 5294 if (local_got_ents == NULL)
e054468f 5295 return NULL;
411e1bfb
AM		 5296 elf_local_got_ents (abfd) = local_got_ents;
5297 }
5298
e054468f 5299 if ((tls_type & (PLT_IFUNC | TLS_EXPLICIT)) == 0)
411e1bfb
AM		 5300 {
5301 struct got_entry *ent;
5302
5303 for (ent = local_got_ents[r_symndx]; ent != NULL; ent = ent->next)
e717da7e
AM		 5304 if (ent->addend == r_addend
5305 && ent->owner == abfd
5306 && ent->tls_type == tls_type)
411e1bfb
AM		 5307 break;
5308 if (ent == NULL)
5309 {
5310 bfd_size_type amt = sizeof (*ent);
4ce794b7 5311 ent = bfd_alloc (abfd, amt);
411e1bfb
AM		 5312 if (ent == NULL)
5313 return FALSE;
5314 ent->next = local_got_ents[r_symndx];
5315 ent->addend = r_addend;
e717da7e 5316 ent->owner = abfd;
411e1bfb 5317 ent->tls_type = tls_type;
927be08e 5318 ent->is_indirect = FALSE;
411e1bfb
AM		 5319 ent->got.refcount = 0;
5320 local_got_ents[r_symndx] = ent;
5321 }
5322 ent->got.refcount += 1;
5323 }
5324
e054468f 5325 local_plt = (struct plt_entry **) (local_got_ents + symtab_hdr->sh_info);
f961d9dd 5326 local_got_tls_masks = (unsigned char *) (local_plt + symtab_hdr->sh_info);
e7b938ca 5327 local_got_tls_masks[r_symndx] |= tls_type;
e054468f
AM		 5328
5329 return local_plt + r_symndx;
65f38f15
AM		 5330}
5331
411e1bfb 5332static bfd_boolean
e054468f 5333update_plt_info (bfd *abfd, struct plt_entry **plist, bfd_vma addend)
1e2f5b6e 5334{
411e1bfb 5335 struct plt_entry *ent;
1e2f5b6e 5336
e054468f 5337 for (ent = *plist; ent != NULL; ent = ent->next)
411e1bfb
AM		 5338 if (ent->addend == addend)
5339 break;
5340 if (ent == NULL)
1e2f5b6e 5341 {
411e1bfb 5342 bfd_size_type amt = sizeof (*ent);
4ce794b7 5343 ent = bfd_alloc (abfd, amt);
411e1bfb
AM		 5344 if (ent == NULL)
5345 return FALSE;
e054468f 5346 ent->next = *plist;
411e1bfb
AM		 5347 ent->addend = addend;
5348 ent->plt.refcount = 0;
e054468f 5349 *plist = ent;
1e2f5b6e 5350 }
411e1bfb 5351 ent->plt.refcount += 1;
b34976b6 5352 return TRUE;
1e2f5b6e
AM		 5353}
5354
e054468f
AM		 5355static bfd_boolean
5356is_branch_reloc (enum elf_ppc64_reloc_type r_type)
5357{
5358 return (r_type == R_PPC64_REL24
5359 || r_type == R_PPC64_REL14
5360 || r_type == R_PPC64_REL14_BRTAKEN
5361 || r_type == R_PPC64_REL14_BRNTAKEN
5362 || r_type == R_PPC64_ADDR24
5363 || r_type == R_PPC64_ADDR14
5364 || r_type == R_PPC64_ADDR14_BRTAKEN
5365 || r_type == R_PPC64_ADDR14_BRNTAKEN);
5366}
5367
5bd4f169 5368/* Look through the relocs for a section during the first phase, and
65f38f15 5369 calculate needed space in the global offset table, procedure
5d1634d7 5370 linkage table, and dynamic reloc sections. */
5bd4f169 5371
b34976b6 5372static bfd_boolean
4ce794b7
AM		 5373ppc64_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
5374 asection *sec, const Elf_Internal_Rela *relocs)
5bd4f169 5375{
65f38f15 5376 struct ppc_link_hash_table *htab;
5bd4f169 5377 Elf_Internal_Shdr *symtab_hdr;
c7e2358a 5378 struct elf_link_hash_entry **sym_hashes;
5bd4f169
AM		 5379 const Elf_Internal_Rela *rel;
5380 const Elf_Internal_Rela *rel_end;
5bd4f169 5381 asection *sreloc;
1e2f5b6e 5382 asection **opd_sym_map;
3a71aa26 5383 struct elf_link_hash_entry *tga, *dottga;
5bd4f169 5384
0e1862bb 5385 if (bfd_link_relocatable (info))
b34976b6 5386 return TRUE;
5bd4f169 5387
680a3378
AM		 5388 /* Don't do anything special with non-loaded, non-alloced sections.
5389 In particular, any relocs in such sections should not affect GOT
5390 and PLT reference counting (ie. we don't allow them to create GOT
5391 or PLT entries), there's no possibility or desire to optimize TLS
5392 relocs, and there's not much point in propagating relocs to shared
5393 libs that the dynamic linker won't relocate. */
5394 if ((sec->flags & SEC_ALLOC) == 0)
5395 return TRUE;
5396
0c8d6e5c 5397 BFD_ASSERT (is_ppc64_elf (abfd));
0ffa91dd 5398
65f38f15 5399 htab = ppc_hash_table (info);
4dfe6ac6
NC		 5400 if (htab == NULL)
5401 return FALSE;
5402
3a71aa26
AM		 5403 tga = elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
5404 FALSE, FALSE, TRUE);
5405 dottga = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
5406 FALSE, FALSE, TRUE);
0ffa91dd 5407 symtab_hdr = &elf_symtab_hdr (abfd);
5bd4f169 5408 sym_hashes = elf_sym_hashes (abfd);
5bd4f169 5409 sreloc = NULL;
1e2f5b6e 5410 opd_sym_map = NULL;
f6c7c3e8
AM		 5411 if (ppc64_elf_section_data (sec) != NULL
5412 && ppc64_elf_section_data (sec)->sec_type == sec_opd)
5413 opd_sym_map = ppc64_elf_section_data (sec)->u.opd.func_sec;
5bd4f169
AM		 5414
5415 rel_end = relocs + sec->reloc_count;
5416 for (rel = relocs; rel < rel_end; rel++)
5417 {
5418 unsigned long r_symndx;
5419 struct elf_link_hash_entry *h;
04c9666a 5420 enum elf_ppc64_reloc_type r_type;
727fc41e 5421 int tls_type;
7c8fe5c4 5422 struct _ppc64_elf_section_data *ppc64_sec;
cbf95972 5423 struct plt_entry **ifunc, **plt_list;
5bd4f169
AM		 5424
5425 r_symndx = ELF64_R_SYM (rel->r_info);
5426 if (r_symndx < symtab_hdr->sh_info)
5427 h = NULL;
5428 else
973a3492 5429 {
8c5b4e52
AM		 5430 struct ppc_link_hash_entry *eh;
5431
973a3492 5432 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
b31867b6 5433 h = elf_follow_link (h);
8c5b4e52 5434 eh = (struct ppc_link_hash_entry *) h;
81fbe831
AM		 5435
5436 /* PR15323, ref flags aren't set for references in the same
5437 object. */
bc4e12de 5438 h->root.non_ir_ref_regular = 1;
8c5b4e52 5439 if (eh->is_func && eh->oh != NULL)
bc4e12de 5440 eh->oh->elf.root.non_ir_ref_regular = 1;
1c865ab2
AM		 5441
5442 if (h == htab->elf.hgot)
5443 sec->has_toc_reloc = 1;
973a3492 5444 }
5bd4f169 5445
727fc41e 5446 tls_type = 0;
e054468f 5447 ifunc = NULL;
25f23106
AM		 5448 if (h != NULL)
5449 {
5450 if (h->type == STT_GNU_IFUNC)
5451 {
5452 h->needs_plt = 1;
5453 ifunc = &h->plt.plist;
5454 }
5455 }
5456 else
5457 {
5458 Elf_Internal_Sym *isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5459 abfd, r_symndx);
5460 if (isym == NULL)
5461 return FALSE;
5462
5463 if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
5464 {
5465 ifunc = update_local_sym_info (abfd, symtab_hdr, r_symndx,
5466 rel->r_addend, PLT_IFUNC);
5467 if (ifunc == NULL)
5468 return FALSE;
5469 }
5470 }
727fc41e 5471
cbf95972 5472 r_type = ELF64_R_TYPE (rel->r_info);
a33d1f77 5473 switch (r_type)
5bd4f169 5474 {
727fc41e
AM		 5475 case R_PPC64_TLSGD:
5476 case R_PPC64_TLSLD:
5477 /* These special tls relocs tie a call to __tls_get_addr with
5478 its parameter symbol. */
5479 break;
5480
411e1bfb
AM		 5481 case R_PPC64_GOT_TLSLD16:
5482 case R_PPC64_GOT_TLSLD16_LO:
5483 case R_PPC64_GOT_TLSLD16_HI:
5484 case R_PPC64_GOT_TLSLD16_HA:
951fd09b 5485 tls_type = TLS_TLS | TLS_LD;
411e1bfb
AM		 5486 goto dogottls;
5487
5488 case R_PPC64_GOT_TLSGD16:
5489 case R_PPC64_GOT_TLSGD16_LO:
5490 case R_PPC64_GOT_TLSGD16_HI:
5491 case R_PPC64_GOT_TLSGD16_HA:
951fd09b 5492 tls_type = TLS_TLS | TLS_GD;
411e1bfb
AM		 5493 goto dogottls;
5494
5495 case R_PPC64_GOT_TPREL16_DS:
5496 case R_PPC64_GOT_TPREL16_LO_DS:
5497 case R_PPC64_GOT_TPREL16_HI:
5498 case R_PPC64_GOT_TPREL16_HA:
0e1862bb 5499 if (bfd_link_pic (info))
411e1bfb
AM		 5500 info->flags |= DF_STATIC_TLS;
5501 tls_type = TLS_TLS | TLS_TPREL;
5502 goto dogottls;
5503
5504 case R_PPC64_GOT_DTPREL16_DS:
5505 case R_PPC64_GOT_DTPREL16_LO_DS:
5506 case R_PPC64_GOT_DTPREL16_HI:
5507 case R_PPC64_GOT_DTPREL16_HA:
5508 tls_type = TLS_TLS | TLS_DTPREL;
5509 dogottls:
5510 sec->has_tls_reloc = 1;
1a0670f3 5511 /* Fall through */
411e1bfb 5512
5bd4f169 5513 case R_PPC64_GOT16:
5bd4f169 5514 case R_PPC64_GOT16_DS:
65f38f15
AM		 5515 case R_PPC64_GOT16_HA:
5516 case R_PPC64_GOT16_HI:
5517 case R_PPC64_GOT16_LO:
5bd4f169 5518 case R_PPC64_GOT16_LO_DS:
65f38f15 5519 /* This symbol requires a global offset table entry. */
4c52953f 5520 sec->has_toc_reloc = 1;
33c0ec9d
AM		 5521 if (r_type == R_PPC64_GOT_TLSLD16
5522 || r_type == R_PPC64_GOT_TLSGD16
5523 || r_type == R_PPC64_GOT_TPREL16_DS
5524 || r_type == R_PPC64_GOT_DTPREL16_DS
5525 || r_type == R_PPC64_GOT16
5526 || r_type == R_PPC64_GOT16_DS)
5527 {
5528 htab->do_multi_toc = 1;
d77c8a4b 5529 ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
33c0ec9d
AM		 5530 }
5531
e717da7e
AM		 5532 if (ppc64_elf_tdata (abfd)->got == NULL
5533 && !create_got_section (abfd, info))
b34976b6 5534 return FALSE;
5bd4f169
AM		 5535
5536 if (h != NULL)
5537 {
411e1bfb
AM		 5538 struct ppc_link_hash_entry *eh;
5539 struct got_entry *ent;
65f38f15 5540
411e1bfb
AM		 5541 eh = (struct ppc_link_hash_entry *) h;
5542 for (ent = eh->elf.got.glist; ent != NULL; ent = ent->next)
5543 if (ent->addend == rel->r_addend
e717da7e 5544 && ent->owner == abfd
411e1bfb
AM		 5545 && ent->tls_type == tls_type)
5546 break;
5547 if (ent == NULL)
5bd4f169 5548 {
411e1bfb 5549 bfd_size_type amt = sizeof (*ent);
4ce794b7 5550 ent = bfd_alloc (abfd, amt);
411e1bfb 5551 if (ent == NULL)
b34976b6 5552 return FALSE;
411e1bfb
AM		 5553 ent->next = eh->elf.got.glist;
5554 ent->addend = rel->r_addend;
e717da7e 5555 ent->owner = abfd;
411e1bfb 5556 ent->tls_type = tls_type;
927be08e 5557 ent->is_indirect = FALSE;
411e1bfb
AM		 5558 ent->got.refcount = 0;
5559 eh->elf.got.glist = ent;
5bd4f169 5560 }
411e1bfb 5561 ent->got.refcount += 1;
e7b938ca 5562 eh->tls_mask |= tls_type;
5bd4f169 5563 }
411e1bfb
AM		 5564 else
5565 /* This is a global offset table entry for a local symbol. */
5566 if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5567 rel->r_addend, tls_type))
5568 return FALSE;
a345bc8d
AM		 5569
5570 /* We may also need a plt entry if the symbol turns out to be
5571 an ifunc. */
0e1862bb 5572 if (h != NULL && !bfd_link_pic (info) && abiversion (abfd) != 1)
a345bc8d
AM		 5573 {
5574 if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5575 return FALSE;
5576 }
5bd4f169
AM		 5577 break;
5578
5bd4f169 5579 case R_PPC64_PLT16_HA:
65f38f15
AM		 5580 case R_PPC64_PLT16_HI:
5581 case R_PPC64_PLT16_LO:
5582 case R_PPC64_PLT32:
5583 case R_PPC64_PLT64:
cbf95972
AM		 5584 /* This symbol requires a procedure linkage table entry. */
5585 plt_list = ifunc;
5586 if (h != NULL)
e054468f 5587 {
e054468f
AM		 5588 h->needs_plt = 1;
5589 if (h->root.root.string[0] == '.'
5590 && h->root.root.string[1] != '\0')
5591 ((struct ppc_link_hash_entry *) h)->is_func = 1;
cbf95972
AM		 5592 plt_list = &h->plt.plist;
5593 }
5594 if (plt_list == NULL)
5595 {
5596 /* It does not make sense to have a procedure linkage
5597 table entry for a non-ifunc local symbol. */
5598 info->callbacks->einfo
695344c0 5599 /* xgettext:c-format */
174d0a74 5600 (_("%H: %s reloc against local symbol\n"),
cbf95972
AM		 5601 abfd, sec, rel->r_offset,
5602 ppc64_elf_howto_table[r_type]->name);
5603 bfd_set_error (bfd_error_bad_value);
5604 return FALSE;
e054468f 5605 }
cbf95972
AM		 5606 if (!update_plt_info (abfd, plt_list, rel->r_addend))
5607 return FALSE;
5bd4f169
AM		 5608 break;
5609
5610 /* The following relocations don't need to propagate the
5611 relocation if linking a shared object since they are
5612 section relative. */
5613 case R_PPC64_SECTOFF:
5614 case R_PPC64_SECTOFF_LO:
5615 case R_PPC64_SECTOFF_HI:
5616 case R_PPC64_SECTOFF_HA:
5617 case R_PPC64_SECTOFF_DS:
5618 case R_PPC64_SECTOFF_LO_DS:
411e1bfb
AM		 5619 case R_PPC64_DTPREL16:
5620 case R_PPC64_DTPREL16_LO:
5621 case R_PPC64_DTPREL16_HI:
5622 case R_PPC64_DTPREL16_HA:
5623 case R_PPC64_DTPREL16_DS:
5624 case R_PPC64_DTPREL16_LO_DS:
f9c6b907
AM		 5625 case R_PPC64_DTPREL16_HIGH:
5626 case R_PPC64_DTPREL16_HIGHA:
411e1bfb
AM		 5627 case R_PPC64_DTPREL16_HIGHER:
5628 case R_PPC64_DTPREL16_HIGHERA:
5629 case R_PPC64_DTPREL16_HIGHEST:
5630 case R_PPC64_DTPREL16_HIGHESTA:
5bd4f169
AM		 5631 break;
5632
ad8e1ba5 5633 /* Nor do these. */
25f23106
AM		 5634 case R_PPC64_REL16:
5635 case R_PPC64_REL16_LO:
5636 case R_PPC64_REL16_HI:
5637 case R_PPC64_REL16_HA:
a680de9a 5638 case R_PPC64_REL16DX_HA:
25f23106
AM		 5639 break;
5640
45965137
AM		 5641 /* Not supported as a dynamic relocation. */
5642 case R_PPC64_ADDR64_LOCAL:
0e1862bb 5643 if (bfd_link_pic (info))
45965137
AM		 5644 {
5645 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
5646 ppc_howto_init ();
695344c0 5647 /* xgettext:c-format */
174d0a74 5648 info->callbacks->einfo (_("%H: %s reloc unsupported "
45965137
AM		 5649 "in shared libraries and PIEs.\n"),
5650 abfd, sec, rel->r_offset,
5651 ppc64_elf_howto_table[r_type]->name);
5652 bfd_set_error (bfd_error_bad_value);
5653 return FALSE;
5654 }
5655 break;
5656
ad8e1ba5 5657 case R_PPC64_TOC16:
33c0ec9d
AM		 5658 case R_PPC64_TOC16_DS:
5659 htab->do_multi_toc = 1;
d77c8a4b 5660 ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
1a0670f3 5661 /* Fall through. */
ad8e1ba5
AM		 5662 case R_PPC64_TOC16_LO:
5663 case R_PPC64_TOC16_HI:
5664 case R_PPC64_TOC16_HA:
ad8e1ba5 5665 case R_PPC64_TOC16_LO_DS:
4c52953f 5666 sec->has_toc_reloc = 1;
ad8e1ba5
AM		 5667 break;
5668
006589cf
AM		 5669 /* Marker reloc. */
5670 case R_PPC64_ENTRY:
5671 break;
5672
5bd4f169
AM		 5673 /* This relocation describes the C++ object vtable hierarchy.
5674 Reconstruct it for later use during GC. */
5675 case R_PPC64_GNU_VTINHERIT:
c152c796 5676 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
b34976b6 5677 return FALSE;
5bd4f169
AM		 5678 break;
5679
5680 /* This relocation describes which C++ vtable entries are actually
5681 used. Record for later use during GC. */
5682 case R_PPC64_GNU_VTENTRY:
d17e0c6e
JB		 5683 BFD_ASSERT (h != NULL);
5684 if (h != NULL
5685 && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
b34976b6 5686 return FALSE;
5bd4f169
AM		 5687 break;
5688
721956f4
AM		 5689 case R_PPC64_REL14:
5690 case R_PPC64_REL14_BRTAKEN:
5691 case R_PPC64_REL14_BRNTAKEN:
220c76dd
AM		 5692 {
5693 asection *dest = NULL;
5694
5695 /* Heuristic: If jumping outside our section, chances are
5696 we are going to need a stub. */
5697 if (h != NULL)
5698 {
5699 /* If the sym is weak it may be overridden later, so
5700 don't assume we know where a weak sym lives. */
5701 if (h->root.type == bfd_link_hash_defined)
5702 dest = h->root.u.def.section;
5703 }
5704 else
87d72d41
AM		 5705 {
5706 Elf_Internal_Sym *isym;
5707
5708 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5709 abfd, r_symndx);
5710 if (isym == NULL)
5711 return FALSE;
5712
5713 dest = bfd_section_from_elf_index (abfd, isym->st_shndx);
5714 }
5715
220c76dd 5716 if (dest != sec)
7c8fe5c4 5717 ppc64_elf_section_data (sec)->has_14bit_branch = 1;
220c76dd 5718 }
721956f4
AM		 5719 /* Fall through. */
5720
5d1634d7 5721 case R_PPC64_REL24:
cbf95972
AM		 5722 plt_list = ifunc;
5723 if (h != NULL)
5d1634d7 5724 {
e054468f
AM		 5725 h->needs_plt = 1;
5726 if (h->root.root.string[0] == '.'
5727 && h->root.root.string[1] != '\0')
5728 ((struct ppc_link_hash_entry *) h)->is_func = 1;
cbf95972 5729
3a71aa26 5730 if (h == tga || h == dottga)
cbf95972
AM		 5731 {
5732 sec->has_tls_reloc = 1;
5733 if (rel != relocs
5734 && (ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSGD
5735 || ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSLD))
5736 /* We have a new-style __tls_get_addr call with
5737 a marker reloc. */
5738 ;
5739 else
5740 /* Mark this section as having an old-style call. */
5741 sec->has_tls_get_addr_call = 1;
5742 }
5743 plt_list = &h->plt.plist;
411e1bfb 5744 }
cbf95972
AM		 5745
5746 /* We may need a .plt entry if the function this reloc
5747 refers to is in a shared lib. */
5748 if (plt_list
5749 && !update_plt_info (abfd, plt_list, rel->r_addend))
5750 return FALSE;
411e1bfb
AM		 5751 break;
5752
cbf95972
AM		 5753 case R_PPC64_ADDR14:
5754 case R_PPC64_ADDR14_BRNTAKEN:
5755 case R_PPC64_ADDR14_BRTAKEN:
5756 case R_PPC64_ADDR24:
5757 goto dodyn;
5758
411e1bfb
AM		 5759 case R_PPC64_TPREL64:
5760 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_TPREL;
0e1862bb 5761 if (bfd_link_pic (info))
411e1bfb
AM		 5762 info->flags |= DF_STATIC_TLS;
5763 goto dotlstoc;
5764
5765 case R_PPC64_DTPMOD64:
5766 if (rel + 1 < rel_end
5767 && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
5768 && rel[1].r_offset == rel->r_offset + 8)
951fd09b 5769 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_GD;
411e1bfb 5770 else
951fd09b 5771 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_LD;
411e1bfb
AM		 5772 goto dotlstoc;
5773
5774 case R_PPC64_DTPREL64:
5775 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_DTPREL;
5776 if (rel != relocs
5777 && rel[-1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPMOD64)
5778 && rel[-1].r_offset == rel->r_offset - 8)
5779 /* This is the second reloc of a dtpmod, dtprel pair.
5780 Don't mark with TLS_DTPREL. */
5781 goto dodyn;
5782
5783 dotlstoc:
5784 sec->has_tls_reloc = 1;
5785 if (h != NULL)
5786 {
5787 struct ppc_link_hash_entry *eh;
5788 eh = (struct ppc_link_hash_entry *) h;
e7b938ca 5789 eh->tls_mask |= tls_type;
411e1bfb
AM		 5790 }
5791 else
5792 if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5793 rel->r_addend, tls_type))
5794 return FALSE;
5795
7c8fe5c4
AM		 5796 ppc64_sec = ppc64_elf_section_data (sec);
5797 if (ppc64_sec->sec_type != sec_toc)
411e1bfb 5798 {
3a71aa26
AM		 5799 bfd_size_type amt;
5800
e7b938ca 5801 /* One extra to simplify get_tls_mask. */
3a71aa26
AM		 5802 amt = sec->size * sizeof (unsigned) / 8 + sizeof (unsigned);
5803 ppc64_sec->u.toc.symndx = bfd_zalloc (abfd, amt);
5804 if (ppc64_sec->u.toc.symndx == NULL)
5805 return FALSE;
5806 amt = sec->size * sizeof (bfd_vma) / 8;
5807 ppc64_sec->u.toc.add = bfd_zalloc (abfd, amt);
5808 if (ppc64_sec->u.toc.add == NULL)
411e1bfb 5809 return FALSE;
7c8fe5c4
AM		 5810 BFD_ASSERT (ppc64_sec->sec_type == sec_normal);
5811 ppc64_sec->sec_type = sec_toc;
411e1bfb
AM		 5812 }
5813 BFD_ASSERT (rel->r_offset % 8 == 0);
3a71aa26
AM		 5814 ppc64_sec->u.toc.symndx[rel->r_offset / 8] = r_symndx;
5815 ppc64_sec->u.toc.add[rel->r_offset / 8] = rel->r_addend;
951fd09b
AM		 5816
5817 /* Mark the second slot of a GD or LD entry.
5818 -1 to indicate GD and -2 to indicate LD. */
5819 if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_GD))
3a71aa26 5820 ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -1;
951fd09b 5821 else if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_LD))
3a71aa26 5822 ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -2;
411e1bfb
AM		 5823 goto dodyn;
5824
5825 case R_PPC64_TPREL16:
5826 case R_PPC64_TPREL16_LO:
5827 case R_PPC64_TPREL16_HI:
5828 case R_PPC64_TPREL16_HA:
5829 case R_PPC64_TPREL16_DS:
5830 case R_PPC64_TPREL16_LO_DS:
f9c6b907
AM		 5831 case R_PPC64_TPREL16_HIGH:
5832 case R_PPC64_TPREL16_HIGHA:
411e1bfb
AM		 5833 case R_PPC64_TPREL16_HIGHER:
5834 case R_PPC64_TPREL16_HIGHERA:
5835 case R_PPC64_TPREL16_HIGHEST:
5836 case R_PPC64_TPREL16_HIGHESTA:
0e1862bb 5837 if (bfd_link_pic (info))
411e1bfb 5838 {
afb93314 5839 info->flags |= DF_STATIC_TLS;
411e1bfb 5840 goto dodyn;
5d1634d7
AM		 5841 }
5842 break;
5843
e86ce104 5844 case R_PPC64_ADDR64:
1e2f5b6e 5845 if (opd_sym_map != NULL
1e2f5b6e 5846 && rel + 1 < rel_end
4ce794b7 5847 && ELF64_R_TYPE ((rel + 1)->r_info) == R_PPC64_TOC)
1e2f5b6e 5848 {
8387904d 5849 if (h != NULL)
8c5b4e52 5850 ((struct ppc_link_hash_entry *) h)->is_func = 1;
8387904d
AM		 5851 else
5852 {
5853 asection *s;
87d72d41 5854 Elf_Internal_Sym *isym;
1e2f5b6e 5855
87d72d41
AM		 5856 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5857 abfd, r_symndx);
5858 if (isym == NULL)
8387904d 5859 return FALSE;
87d72d41
AM		 5860
5861 s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5862 if (s != NULL && s != sec)
51aecdc5 5863 opd_sym_map[OPD_NDX (rel->r_offset)] = s;
8387904d 5864 }
1e2f5b6e 5865 }
e86ce104
AM		 5866 /* Fall through. */
5867
65f38f15
AM		 5868 case R_PPC64_ADDR16:
5869 case R_PPC64_ADDR16_DS:
5870 case R_PPC64_ADDR16_HA:
5871 case R_PPC64_ADDR16_HI:
f9c6b907
AM		 5872 case R_PPC64_ADDR16_HIGH:
5873 case R_PPC64_ADDR16_HIGHA:
65f38f15
AM		 5874 case R_PPC64_ADDR16_HIGHER:
5875 case R_PPC64_ADDR16_HIGHERA:
5876 case R_PPC64_ADDR16_HIGHEST:
5877 case R_PPC64_ADDR16_HIGHESTA:
5878 case R_PPC64_ADDR16_LO:
5879 case R_PPC64_ADDR16_LO_DS:
0e1862bb 5880 if (h != NULL && !bfd_link_pic (info) && abiversion (abfd) != 1
a345bc8d
AM		 5881 && rel->r_addend == 0)
5882 {
5883 /* We may need a .plt entry if this reloc refers to a
5884 function in a shared lib. */
5885 if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5886 return FALSE;
5887 h->pointer_equality_needed = 1;
5888 }
5889 /* Fall through. */
5890
5891 case R_PPC64_REL30:
5892 case R_PPC64_REL32:
5893 case R_PPC64_REL64:
65f38f15 5894 case R_PPC64_ADDR32:
65f38f15
AM		 5895 case R_PPC64_UADDR16:
5896 case R_PPC64_UADDR32:
5897 case R_PPC64_UADDR64:
5bd4f169 5898 case R_PPC64_TOC:
0e1862bb 5899 if (h != NULL && !bfd_link_pic (info))
81848ca0 5900 /* We may need a copy reloc. */
f5385ebf 5901 h->non_got_ref = 1;
81848ca0 5902
41bd81ab 5903 /* Don't propagate .opd relocs. */
1e2f5b6e 5904 if (NO_OPD_RELOCS && opd_sym_map != NULL)
e86ce104 5905 break;
e86ce104 5906
65f38f15
AM		 5907 /* If we are creating a shared library, and this is a reloc
5908 against a global symbol, or a non PC relative reloc
5909 against a local symbol, then we need to copy the reloc
5910 into the shared library. However, if we are linking with
5911 -Bsymbolic, we do not need to copy a reloc against a
5912 global symbol which is defined in an object we are
5913 including in the link (i.e., DEF_REGULAR is set). At
5914 this point we have not seen all the input files, so it is
5915 possible that DEF_REGULAR is not set now but will be set
5916 later (it is never cleared). In case of a weak definition,
5917 DEF_REGULAR may be cleared later by a strong definition in
5918 a shared library. We account for that possibility below by
f4656909 5919 storing information in the dyn_relocs field of the hash
65f38f15
AM		 5920 table entry. A similar situation occurs when creating
5921 shared libraries and symbol visibility changes render the
5922 symbol local.
5923
5924 If on the other hand, we are creating an executable, we
5925 may need to keep relocations for symbols satisfied by a
5926 dynamic library if we manage to avoid copy relocs for the
5927 symbol. */
411e1bfb 5928 dodyn:
0e1862bb 5929 if ((bfd_link_pic (info)
1d483afe 5930 && (must_be_dyn_reloc (info, r_type)
65f38f15 5931 || (h != NULL
198f1157 5932 && (!SYMBOLIC_BIND (info, h)
65f38f15 5933 || h->root.type == bfd_link_hash_defweak
f5385ebf 5934 || !h->def_regular))))
f4656909 5935 || (ELIMINATE_COPY_RELOCS
0e1862bb 5936 && !bfd_link_pic (info)
65f38f15
AM		 5937 && h != NULL
5938 && (h->root.type == bfd_link_hash_defweak
25f23106 5939 || !h->def_regular))
0e1862bb 5940 || (!bfd_link_pic (info)
25f23106 5941 && ifunc != NULL))
5bd4f169 5942 {
65f38f15
AM		 5943 /* We must copy these reloc types into the output file.
5944 Create a reloc section in dynobj and make room for
5945 this reloc. */
5bd4f169
AM		 5946 if (sreloc == NULL)
5947 {
83bac4b0
NC		 5948 sreloc = _bfd_elf_make_dynamic_reloc_section
5949 (sec, htab->elf.dynobj, 3, abfd, /*rela?*/ TRUE);
65f38f15 5950
5bd4f169 5951 if (sreloc == NULL)
83bac4b0 5952 return FALSE;
5bd4f169
AM		 5953 }
5954
65f38f15
AM		 5955 /* If this is a global symbol, we count the number of
5956 relocations we need for this symbol. */
5957 if (h != NULL)
5958 {
19e08130
AM		 5959 struct elf_dyn_relocs *p;
5960 struct elf_dyn_relocs **head;
5961
ec338859 5962 head = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
19e08130
AM		 5963 p = *head;
5964 if (p == NULL || p->sec != sec)
5965 {
5966 p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5967 if (p == NULL)
5968 return FALSE;
5969 p->next = *head;
5970 *head = p;
5971 p->sec = sec;
5972 p->count = 0;
5973 p->pc_count = 0;
5974 }
5975 p->count += 1;
5976 if (!must_be_dyn_reloc (info, r_type))
5977 p->pc_count += 1;
65f38f15
AM		 5978 }
5979 else
5980 {
ec338859
AM		 5981 /* Track dynamic relocs needed for local syms too.
5982 We really need local syms available to do this
5983 easily. Oh well. */
19e08130
AM		 5984 struct ppc_dyn_relocs *p;
5985 struct ppc_dyn_relocs **head;
5986 bfd_boolean is_ifunc;
ec338859 5987 asection *s;
6edfbbad 5988 void *vpp;
87d72d41 5989 Elf_Internal_Sym *isym;
6edfbbad 5990
87d72d41
AM		 5991 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5992 abfd, r_symndx);
5993 if (isym == NULL)
b34976b6 5994 return FALSE;
ec338859 5995
87d72d41
AM		 5996 s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5997 if (s == NULL)
5998 s = sec;
5999
6edfbbad 6000 vpp = &elf_section_data (s)->local_dynrel;
19e08130
AM		 6001 head = (struct ppc_dyn_relocs **) vpp;
6002 is_ifunc = ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC;
6003 p = *head;
6004 if (p != NULL && p->sec == sec && p->ifunc != is_ifunc)
6005 p = p->next;
6006 if (p == NULL || p->sec != sec || p->ifunc != is_ifunc)
6007 {
6008 p = bfd_alloc (htab->elf.dynobj, sizeof *p);
6009 if (p == NULL)
6010 return FALSE;
6011 p->next = *head;
6012 *head = p;
6013 p->sec = sec;
6014 p->ifunc = is_ifunc;
6015 p->count = 0;
6016 }
6017 p->count += 1;
ec338859 6018 }
65f38f15 6019 }
5bd4f169 6020 break;
65f38f15
AM		 6021
6022 default:
96e0dda4 6023 break;
5bd4f169
AM		 6024 }
6025 }
6026
b34976b6 6027 return TRUE;
5bd4f169
AM		 6028}
6029
ee67d69a
AM		 6030/* Merge backend specific data from an object file to the output
6031 object file when linking. */
6032
6033static bfd_boolean
50e03d47 6034ppc64_elf_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info)
ee67d69a 6035{
50e03d47 6036 bfd *obfd = info->output_bfd;
ee67d69a
AM		 6037 unsigned long iflags, oflags;
6038
6039 if ((ibfd->flags & BFD_LINKER_CREATED) != 0)
6040 return TRUE;
6041
6042 if (!is_ppc64_elf (ibfd) || !is_ppc64_elf (obfd))
6043 return TRUE;
6044
50e03d47 6045 if (!_bfd_generic_verify_endian_match (ibfd, info))
ee67d69a
AM		 6046 return FALSE;
6047
6048 iflags = elf_elfheader (ibfd)->e_flags;
6049 oflags = elf_elfheader (obfd)->e_flags;
6050
f6c7c3e8 6051 if (iflags & ~EF_PPC64_ABI)
ee67d69a 6052 {
4eca0228 6053 _bfd_error_handler
695344c0 6054 /* xgettext:c-format */
ee67d69a
AM		 6055 (_("%B uses unknown e_flags 0x%lx"), ibfd, iflags);
6056 bfd_set_error (bfd_error_bad_value);
6057 return FALSE;
6058 }
f6c7c3e8 6059 else if (iflags != oflags && iflags != 0)
ee67d69a 6060 {
4eca0228 6061 _bfd_error_handler
695344c0 6062 /* xgettext:c-format */
ee67d69a
AM		 6063 (_("%B: ABI version %ld is not compatible with ABI version %ld output"),
6064 ibfd, iflags, oflags);
6065 bfd_set_error (bfd_error_bad_value);
6066 return FALSE;
6067 }
6068
50e03d47 6069 _bfd_elf_ppc_merge_fp_attributes (ibfd, info);
005d79fd 6070
ee67d69a 6071 /* Merge Tag_compatibility attributes and any common GNU ones. */
50e03d47 6072 _bfd_elf_merge_object_attributes (ibfd, info);
ee67d69a
AM		 6073
6074 return TRUE;
6075}
6076
6077static bfd_boolean
6078ppc64_elf_print_private_bfd_data (bfd *abfd, void *ptr)
6079{
6080 /* Print normal ELF private data. */
6081 _bfd_elf_print_private_bfd_data (abfd, ptr);
6082
6083 if (elf_elfheader (abfd)->e_flags != 0)
6084 {
6085 FILE *file = ptr;
6086
ee67d69a
AM		 6087 fprintf (file, _("private flags = 0x%lx:"),
6088 elf_elfheader (abfd)->e_flags);
6089
6090 if ((elf_elfheader (abfd)->e_flags & EF_PPC64_ABI) != 0)
6091 fprintf (file, _(" [abiv%ld]"),
6092 elf_elfheader (abfd)->e_flags & EF_PPC64_ABI);
6093 fputc ('\n', file);
6094 }
6095
6096 return TRUE;
6097}
6098
8387904d 6099/* OFFSET in OPD_SEC specifies a function descriptor. Return the address
b53dfeb2
AM		 6100 of the code entry point, and its section, which must be in the same
6101 object as OPD_SEC. Returns (bfd_vma) -1 on error. */
8387904d
AM		 6102
6103static bfd_vma
6104opd_entry_value (asection *opd_sec,
6105 bfd_vma offset,
6106 asection **code_sec,
aef36ac1
AM		 6107 bfd_vma *code_off,
6108 bfd_boolean in_code_sec)
8387904d
AM		 6109{
6110 bfd *opd_bfd = opd_sec->owner;
8860955f 6111 Elf_Internal_Rela *relocs;
8387904d 6112 Elf_Internal_Rela *lo, *hi, *look;
645ea6a9 6113 bfd_vma val;
8387904d 6114
9f296da3
AM		 6115 /* No relocs implies we are linking a --just-symbols object, or looking
6116 at a final linked executable with addr2line or somesuch. */
4b85d634
AM		 6117 if (opd_sec->reloc_count == 0)
6118 {
729eabd5 6119 bfd_byte *contents = ppc64_elf_tdata (opd_bfd)->opd.contents;
3b36f7e6 6120
729eabd5
AM		 6121 if (contents == NULL)
6122 {
6123 if (!bfd_malloc_and_get_section (opd_bfd, opd_sec, &contents))
6124 return (bfd_vma) -1;
6125 ppc64_elf_tdata (opd_bfd)->opd.contents = contents;
6126 }
ee1e4ede 6127
dbb3fbbb 6128 /* PR 17512: file: 64b9dfbb. */
451dfd38 6129 if (offset + 7 >= opd_sec->size || offset + 7 < offset)
dbb3fbbb
NC		 6130 return (bfd_vma) -1;
6131
729eabd5 6132 val = bfd_get_64 (opd_bfd, contents + offset);
aef36ac1
AM		 6133 if (code_sec != NULL)
6134 {
6135 asection *sec, *likely = NULL;
ee1e4ede 6136
aef36ac1 6137 if (in_code_sec)
4b85d634 6138 {
aef36ac1
AM		 6139 sec = *code_sec;
6140 if (sec->vma <= val
6141 && val < sec->vma + sec->size)
6142 likely = sec;
6143 else
6144 val = -1;
6145 }
6146 else
6147 for (sec = opd_bfd->sections; sec != NULL; sec = sec->next)
6148 if (sec->vma <= val
6149 && (sec->flags & SEC_LOAD) != 0
6150 && (sec->flags & SEC_ALLOC) != 0)
6151 likely = sec;
6152 if (likely != NULL)
6153 {
6154 *code_sec = likely;
6155 if (code_off != NULL)
6156 *code_off = val - likely->vma;
4b85d634
AM		 6157 }
6158 }
aef36ac1 6159 return val;
4b85d634
AM		 6160 }
6161
0c8d6e5c 6162 BFD_ASSERT (is_ppc64_elf (opd_bfd));
0ffa91dd 6163
729eabd5 6164 relocs = ppc64_elf_tdata (opd_bfd)->opd.relocs;
8860955f
AM		 6165 if (relocs == NULL)
6166 relocs = _bfd_elf_link_read_relocs (opd_bfd, opd_sec, NULL, NULL, TRUE);
877a8638
NC		 6167 /* PR 17512: file: df8e1fd6. */
6168 if (relocs == NULL)
6169 return (bfd_vma) -1;
645ea6a9 6170
8387904d 6171 /* Go find the opd reloc at the sym address. */
8860955f 6172 lo = relocs;
8387904d 6173 hi = lo + opd_sec->reloc_count - 1; /* ignore last reloc */
645ea6a9 6174 val = (bfd_vma) -1;
8387904d
AM		 6175 while (lo < hi)
6176 {
6177 look = lo + (hi - lo) / 2;
6178 if (look->r_offset < offset)
6179 lo = look + 1;
6180 else if (look->r_offset > offset)
6181 hi = look;
6182 else
6183 {
0ffa91dd
NC		 6184 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (opd_bfd);
6185
8387904d
AM		 6186 if (ELF64_R_TYPE (look->r_info) == R_PPC64_ADDR64
6187 && ELF64_R_TYPE ((look + 1)->r_info) == R_PPC64_TOC)
6188 {
6189 unsigned long symndx = ELF64_R_SYM (look->r_info);
b53dfeb2 6190 asection *sec = NULL;
8387904d 6191
b53dfeb2
AM		 6192 if (symndx >= symtab_hdr->sh_info
6193 && elf_sym_hashes (opd_bfd) != NULL)
8387904d
AM		 6194 {
6195 struct elf_link_hash_entry **sym_hashes;
6196 struct elf_link_hash_entry *rh;
6197
6198 sym_hashes = elf_sym_hashes (opd_bfd);
6199 rh = sym_hashes[symndx - symtab_hdr->sh_info];
128205bb
AM		 6200 if (rh != NULL)
6201 {
6202 rh = elf_follow_link (rh);
bb854a36
AM		 6203 if (rh->root.type != bfd_link_hash_defined
6204 && rh->root.type != bfd_link_hash_defweak)
6205 break;
6206 if (rh->root.u.def.section->owner == opd_bfd)
b53dfeb2 6207 {
bb854a36
AM		 6208 val = rh->root.u.def.value;
6209 sec = rh->root.u.def.section;
b53dfeb2
AM		 6210 }
6211 }
6212 }
6213
6214 if (sec == NULL)
6215 {
6216 Elf_Internal_Sym *sym;
6217
6218 if (symndx < symtab_hdr->sh_info)
6219 {
6220 sym = (Elf_Internal_Sym *) symtab_hdr->contents;
6221 if (sym == NULL)
6222 {
6223 size_t symcnt = symtab_hdr->sh_info;
6224 sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr,
6225 symcnt, 0,
6226 NULL, NULL, NULL);
6227 if (sym == NULL)
6228 break;
6229 symtab_hdr->contents = (bfd_byte *) sym;
6230 }
6231 sym += symndx;
128205bb
AM		 6232 }
6233 else
6234 {
b53dfeb2
AM		 6235 sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr,
6236 1, symndx,
6237 NULL, NULL, NULL);
128205bb
AM		 6238 if (sym == NULL)
6239 break;
128205bb 6240 }
b53dfeb2
AM		 6241 sec = bfd_section_from_elf_index (opd_bfd, sym->st_shndx);
6242 if (sec == NULL)
6243 break;
6244 BFD_ASSERT ((sec->flags & SEC_MERGE) == 0);
6245 val = sym->st_value;
8387904d 6246 }
b53dfeb2 6247
8387904d
AM		 6248 val += look->r_addend;
6249 if (code_off != NULL)
6250 *code_off = val;
6251 if (code_sec != NULL)
aef36ac1
AM		 6252 {
6253 if (in_code_sec && *code_sec != sec)
6254 return -1;
6255 else
6256 *code_sec = sec;
6257 }
b53dfeb2 6258 if (sec->output_section != NULL)
8387904d 6259 val += sec->output_section->vma + sec->output_offset;
8387904d
AM		 6260 }
6261 break;
6262 }
6263 }
645ea6a9 6264
645ea6a9 6265 return val;
8387904d
AM		 6266}
6267
aef36ac1
AM		 6268/* If the ELF symbol SYM might be a function in SEC, return the
6269 function size and set *CODE_OFF to the function's entry point,
6270 otherwise return zero. */
9f296da3 6271
aef36ac1
AM		 6272static bfd_size_type
6273ppc64_elf_maybe_function_sym (const asymbol *sym, asection *sec,
6274 bfd_vma *code_off)
9f296da3 6275{
aef36ac1
AM		 6276 bfd_size_type size;
6277
6278 if ((sym->flags & (BSF_SECTION_SYM | BSF_FILE | BSF_OBJECT
6279 | BSF_THREAD_LOCAL | BSF_RELC | BSF_SRELC)) != 0)
6280 return 0;
6281
6282 size = 0;
6283 if (!(sym->flags & BSF_SYNTHETIC))
6284 size = ((elf_symbol_type *) sym)->internal_elf_sym.st_size;
6285
6286 if (strcmp (sym->section->name, ".opd") == 0)
9f296da3 6287 {
b07bca4e
AM		 6288 struct _opd_sec_data *opd = get_opd_info (sym->section);
6289 bfd_vma symval = sym->value;
6290
6291 if (opd != NULL
6292 && opd->adjust != NULL
6293 && elf_section_data (sym->section)->relocs != NULL)
6294 {
6295 /* opd_entry_value will use cached relocs that have been
6296 adjusted, but with raw symbols. That means both local
6297 and global symbols need adjusting. */
6298 long adjust = opd->adjust[OPD_NDX (symval)];
6299 if (adjust == -1)
6300 return 0;
6301 symval += adjust;
6302 }
6303
6304 if (opd_entry_value (sym->section, symval,
aef36ac1
AM		 6305 &sec, code_off, TRUE) == (bfd_vma) -1)
6306 return 0;
6307 /* An old ABI binary with dot-syms has a size of 24 on the .opd
6308 symbol. This size has nothing to do with the code size of the
6309 function, which is what we're supposed to return, but the
6310 code size isn't available without looking up the dot-sym.
6311 However, doing that would be a waste of time particularly
6312 since elf_find_function will look at the dot-sym anyway.
6313 Now, elf_find_function will keep the largest size of any
6314 function sym found at the code address of interest, so return
6315 1 here to avoid it incorrectly caching a larger function size
6316 for a small function. This does mean we return the wrong
6317 size for a new-ABI function of size 24, but all that does is
6318 disable caching for such functions. */
6319 if (size == 24)
6320 size = 1;
9f296da3 6321 }
aef36ac1
AM		 6322 else
6323 {
6324 if (sym->section != sec)
6325 return 0;
6326 *code_off = sym->value;
6327 }
6328 if (size == 0)
6329 size = 1;
6330 return size;
9f296da3
AM		 6331}
6332
f378ab09
AM		 6333/* Return true if symbol is a strong function defined in an ELFv2
6334 object with st_other localentry bits of zero, ie. its local entry
6335 point coincides with its global entry point. */
6336
6337static bfd_boolean
6338is_elfv2_localentry0 (struct elf_link_hash_entry *h)
6339{
6340 return (h != NULL
6341 && h->type == STT_FUNC
6342 && h->root.type == bfd_link_hash_defined
6343 && (STO_PPC64_LOCAL_MASK & h->other) == 0
8b5f1ed8 6344 && !((struct ppc_link_hash_entry *) h)->non_zero_localentry
f378ab09
AM		 6345 && is_ppc64_elf (h->root.u.def.section->owner)
6346 && abiversion (h->root.u.def.section->owner) >= 2);
6347}
6348
854b41e7
AM		 6349/* Return true if symbol is defined in a regular object file. */
6350
6351static bfd_boolean
6352is_static_defined (struct elf_link_hash_entry *h)
6353{
6354 return ((h->root.type == bfd_link_hash_defined
6355 || h->root.type == bfd_link_hash_defweak)
6356 && h->root.u.def.section != NULL
6357 && h->root.u.def.section->output_section != NULL);
6358}
6359
b31867b6
AM		 6360/* If FDH is a function descriptor symbol, return the associated code
6361 entry symbol if it is defined. Return NULL otherwise. */
6362
6363static struct ppc_link_hash_entry *
6364defined_code_entry (struct ppc_link_hash_entry *fdh)
6365{
6366 if (fdh->is_func_descriptor)
6367 {
6368 struct ppc_link_hash_entry *fh = ppc_follow_link (fdh->oh);
6369 if (fh->elf.root.type == bfd_link_hash_defined
6370 || fh->elf.root.type == bfd_link_hash_defweak)
6371 return fh;
6372 }
6373 return NULL;
6374}
6375
6376/* If FH is a function code entry symbol, return the associated
6377 function descriptor symbol if it is defined. Return NULL otherwise. */
6378
6379static struct ppc_link_hash_entry *
6380defined_func_desc (struct ppc_link_hash_entry *fh)
6381{
6382 if (fh->oh != NULL
6383 && fh->oh->is_func_descriptor)
6384 {
6385 struct ppc_link_hash_entry *fdh = ppc_follow_link (fh->oh);
6386 if (fdh->elf.root.type == bfd_link_hash_defined
6387 || fdh->elf.root.type == bfd_link_hash_defweak)
6388 return fdh;
6389 }
6390 return NULL;
6391}
6392
8c5b4e52
AM		 6393static bfd_boolean func_desc_adjust (struct elf_link_hash_entry *, void *);
6394
6395/* Garbage collect sections, after first dealing with dot-symbols. */
6396
6397static bfd_boolean
6398ppc64_elf_gc_sections (bfd *abfd, struct bfd_link_info *info)
6399{
6400 struct ppc_link_hash_table *htab = ppc_hash_table (info);
6401
6402 if (htab != NULL && htab->need_func_desc_adj)
6403 {
6404 elf_link_hash_traverse (&htab->elf, func_desc_adjust, info);
6405 htab->need_func_desc_adj = 0;
6406 }
6407 return bfd_elf_gc_sections (abfd, info);
6408}
6409
74f0fb50
AM		 6410/* Mark all our entry sym sections, both opd and code section. */
6411
6412static void
6413ppc64_elf_gc_keep (struct bfd_link_info *info)
6414{
6415 struct ppc_link_hash_table *htab = ppc_hash_table (info);
6416 struct bfd_sym_chain *sym;
6417
4dfe6ac6
NC		 6418 if (htab == NULL)
6419 return;
6420
74f0fb50
AM		 6421 for (sym = info->gc_sym_list; sym != NULL; sym = sym->next)
6422 {
b31867b6 6423 struct ppc_link_hash_entry *eh, *fh;
74f0fb50
AM		 6424 asection *sec;
6425
6426 eh = (struct ppc_link_hash_entry *)
b31867b6 6427 elf_link_hash_lookup (&htab->elf, sym->name, FALSE, FALSE, TRUE);
74f0fb50
AM		 6428 if (eh == NULL)
6429 continue;
6430 if (eh->elf.root.type != bfd_link_hash_defined
6431 && eh->elf.root.type != bfd_link_hash_defweak)
6432 continue;
6433
b31867b6
AM		 6434 fh = defined_code_entry (eh);
6435 if (fh != NULL)
74f0fb50 6436 {
b31867b6 6437 sec = fh->elf.root.u.def.section;
74f0fb50
AM		 6438 sec->flags |= SEC_KEEP;
6439 }
6440 else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6441 && opd_entry_value (eh->elf.root.u.def.section,
6442 eh->elf.root.u.def.value,
aef36ac1 6443 &sec, NULL, FALSE) != (bfd_vma) -1)
74f0fb50
AM		 6444 sec->flags |= SEC_KEEP;
6445
6446 sec = eh->elf.root.u.def.section;
6447 sec->flags |= SEC_KEEP;
6448 }
6449}
6450
64d03ab5
AM		 6451/* Mark sections containing dynamically referenced symbols. When
6452 building shared libraries, we must assume that any visible symbol is
6453 referenced. */
6454
6455static bfd_boolean
6456ppc64_elf_gc_mark_dynamic_ref (struct elf_link_hash_entry *h, void *inf)
6457{
6458 struct bfd_link_info *info = (struct bfd_link_info *) inf;
6459 struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
b31867b6 6460 struct ppc_link_hash_entry *fdh;
b407645f 6461 struct bfd_elf_dynamic_list *d = info->dynamic_list;
64d03ab5 6462
64d03ab5 6463 /* Dynamic linking info is on the func descriptor sym. */
b31867b6
AM		 6464 fdh = defined_func_desc (eh);
6465 if (fdh != NULL)
6466 eh = fdh;
64d03ab5
AM		 6467
6468 if ((eh->elf.root.type == bfd_link_hash_defined
6469 || eh->elf.root.type == bfd_link_hash_defweak)
6470 && (eh->elf.ref_dynamic
1c9177d9 6471 || ((eh->elf.def_regular || ELF_COMMON_DEF_P (&eh->elf))
64d03ab5 6472 && ELF_ST_VISIBILITY (eh->elf.other) != STV_INTERNAL
4c58e0d8 6473 && ELF_ST_VISIBILITY (eh->elf.other) != STV_HIDDEN
0e1862bb 6474 && (!bfd_link_executable (info)
e278ae05 6475 || info->gc_keep_exported
b407645f
AM		 6476 || info->export_dynamic
6477 || (eh->elf.dynamic
6478 && d != NULL
6479 && (*d->match) (&d->head, NULL, eh->elf.root.root.string)))
e278ae05 6480 && (eh->elf.versioned >= versioned
4c58e0d8
AM		 6481 || !bfd_hide_sym_by_version (info->version_info,
6482 eh->elf.root.root.string)))))
64d03ab5
AM		 6483 {
6484 asection *code_sec;
b31867b6 6485 struct ppc_link_hash_entry *fh;
64d03ab5
AM		 6486
6487 eh->elf.root.u.def.section->flags |= SEC_KEEP;
6488
6489 /* Function descriptor syms cause the associated
6490 function code sym section to be marked. */
b31867b6
AM		 6491 fh = defined_code_entry (eh);
6492 if (fh != NULL)
6493 {
6494 code_sec = fh->elf.root.u.def.section;
6495 code_sec->flags |= SEC_KEEP;
6496 }
64d03ab5
AM		 6497 else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6498 && opd_entry_value (eh->elf.root.u.def.section,
6499 eh->elf.root.u.def.value,
aef36ac1 6500 &code_sec, NULL, FALSE) != (bfd_vma) -1)
64d03ab5
AM		 6501 code_sec->flags |= SEC_KEEP;
6502 }
6503
6504 return TRUE;
6505}
6506
5bd4f169
AM		 6507/* Return the section that should be marked against GC for a given
6508 relocation. */
6509
6510static asection *
4ce794b7 6511ppc64_elf_gc_mark_hook (asection *sec,
fb34365b 6512 struct bfd_link_info *info,
4ce794b7
AM		 6513 Elf_Internal_Rela *rel,
6514 struct elf_link_hash_entry *h,
6515 Elf_Internal_Sym *sym)
5bd4f169 6516{
ccfa59ea
AM		 6517 asection *rsec;
6518
ccfa59ea
AM		 6519 /* Syms return NULL if we're marking .opd, so we avoid marking all
6520 function sections, as all functions are referenced in .opd. */
6521 rsec = NULL;
6522 if (get_opd_info (sec) != NULL)
6523 return rsec;
1e2f5b6e 6524
5bd4f169
AM		 6525 if (h != NULL)
6526 {
04c9666a 6527 enum elf_ppc64_reloc_type r_type;
b31867b6 6528 struct ppc_link_hash_entry *eh, *fh, *fdh;
a33d1f77 6529
4ce794b7 6530 r_type = ELF64_R_TYPE (rel->r_info);
a33d1f77 6531 switch (r_type)
5bd4f169
AM		 6532 {
6533 case R_PPC64_GNU_VTINHERIT:
6534 case R_PPC64_GNU_VTENTRY:
6535 break;
6536
6537 default:
6538 switch (h->root.type)
6539 {
6540 case bfd_link_hash_defined:
6541 case bfd_link_hash_defweak:
ccfa59ea 6542 eh = (struct ppc_link_hash_entry *) h;
b31867b6
AM		 6543 fdh = defined_func_desc (eh);
6544 if (fdh != NULL)
8c5b4e52
AM		 6545 {
6546 /* -mcall-aixdesc code references the dot-symbol on
6547 a call reloc. Mark the function descriptor too
6548 against garbage collection. */
6549 fdh->elf.mark = 1;
6550 if (fdh->elf.u.weakdef != NULL)
6551 fdh->elf.u.weakdef->mark = 1;
6552 eh = fdh;
6553 }
1e2f5b6e
AM		 6554
6555 /* Function descriptor syms cause the associated
6556 function code sym section to be marked. */
b31867b6
AM		 6557 fh = defined_code_entry (eh);
6558 if (fh != NULL)
ccfa59ea
AM		 6559 {
6560 /* They also mark their opd section. */
74f0fb50 6561 eh->elf.root.u.def.section->gc_mark = 1;
ccfa59ea 6562
b31867b6 6563 rsec = fh->elf.root.u.def.section;
ccfa59ea 6564 }
8387904d
AM		 6565 else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6566 && opd_entry_value (eh->elf.root.u.def.section,
6567 eh->elf.root.u.def.value,
aef36ac1 6568 &rsec, NULL, FALSE) != (bfd_vma) -1)
74f0fb50 6569 eh->elf.root.u.def.section->gc_mark = 1;
ccfa59ea 6570 else
1e2f5b6e
AM		 6571 rsec = h->root.u.def.section;
6572 break;
5bd4f169
AM		 6573
6574 case bfd_link_hash_common:
1e2f5b6e
AM		 6575 rsec = h->root.u.c.p->section;
6576 break;
5bd4f169
AM		 6577
6578 default:
fb34365b 6579 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
5bd4f169
AM		 6580 }
6581 }
6582 }
6583 else
6584 {
74f0fb50 6585 struct _opd_sec_data *opd;
1e2f5b6e
AM		 6586
6587 rsec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
74f0fb50
AM		 6588 opd = get_opd_info (rsec);
6589 if (opd != NULL && opd->func_sec != NULL)
ccfa59ea 6590 {
74f0fb50 6591 rsec->gc_mark = 1;
ccfa59ea 6592
51aecdc5 6593 rsec = opd->func_sec[OPD_NDX (sym->st_value + rel->r_addend)];
ccfa59ea 6594 }
5bd4f169
AM		 6595 }
6596
1e2f5b6e 6597 return rsec;
5bd4f169
AM		 6598}
6599
65f38f15
AM		 6600/* Update the .got, .plt. and dynamic reloc reference counts for the
6601 section being removed. */
5bd4f169 6602
b34976b6 6603static bfd_boolean
4ce794b7
AM		 6604ppc64_elf_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info,
6605 asection *sec, const Elf_Internal_Rela *relocs)
5bd4f169 6606{
411e1bfb 6607 struct ppc_link_hash_table *htab;
5bd4f169
AM		 6608 Elf_Internal_Shdr *symtab_hdr;
6609 struct elf_link_hash_entry **sym_hashes;
411e1bfb 6610 struct got_entry **local_got_ents;
5bd4f169 6611 const Elf_Internal_Rela *rel, *relend;
5bd4f169 6612
0e1862bb 6613 if (bfd_link_relocatable (info))
7dda2462
TG		 6614 return TRUE;
6615
680a3378
AM		 6616 if ((sec->flags & SEC_ALLOC) == 0)
6617 return TRUE;
6618
ec338859
AM		 6619 elf_section_data (sec)->local_dynrel = NULL;
6620
411e1bfb 6621 htab = ppc_hash_table (info);
4dfe6ac6
NC		 6622 if (htab == NULL)
6623 return FALSE;
6624
0ffa91dd 6625 symtab_hdr = &elf_symtab_hdr (abfd);
5bd4f169 6626 sym_hashes = elf_sym_hashes (abfd);
411e1bfb 6627 local_got_ents = elf_local_got_ents (abfd);
5bd4f169
AM		 6628
6629 relend = relocs + sec->reloc_count;
6630 for (rel = relocs; rel < relend; rel++)
a33d1f77
AM		 6631 {
6632 unsigned long r_symndx;
04c9666a 6633 enum elf_ppc64_reloc_type r_type;
58ac9f71 6634 struct elf_link_hash_entry *h = NULL;
8dea77f0 6635 struct plt_entry **plt_list = NULL;
f961d9dd 6636 unsigned char tls_type = 0;
5bd4f169 6637
a33d1f77 6638 r_symndx = ELF64_R_SYM (rel->r_info);
4ce794b7 6639 r_type = ELF64_R_TYPE (rel->r_info);
58ac9f71
AM		 6640 if (r_symndx >= symtab_hdr->sh_info)
6641 {
6642 struct ppc_link_hash_entry *eh;
6061a67d
AM		 6643 struct elf_dyn_relocs **pp;
6644 struct elf_dyn_relocs *p;
58ac9f71
AM		 6645
6646 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
b31867b6 6647 h = elf_follow_link (h);
58ac9f71
AM		 6648 eh = (struct ppc_link_hash_entry *) h;
6649
6650 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
6651 if (p->sec == sec)
6652 {
6653 /* Everything must go for SEC. */
6654 *pp = p->next;
6655 break;
6656 }
6657 }
6658
a33d1f77
AM		 6659 switch (r_type)
6660 {
411e1bfb
AM		 6661 case R_PPC64_GOT_TLSLD16:
6662 case R_PPC64_GOT_TLSLD16_LO:
6663 case R_PPC64_GOT_TLSLD16_HI:
6664 case R_PPC64_GOT_TLSLD16_HA:
951fd09b 6665 tls_type = TLS_TLS | TLS_LD;
411e1bfb
AM		 6666 goto dogot;
6667
6668 case R_PPC64_GOT_TLSGD16:
6669 case R_PPC64_GOT_TLSGD16_LO:
6670 case R_PPC64_GOT_TLSGD16_HI:
6671 case R_PPC64_GOT_TLSGD16_HA:
951fd09b 6672 tls_type = TLS_TLS | TLS_GD;
411e1bfb
AM		 6673 goto dogot;
6674
6675 case R_PPC64_GOT_TPREL16_DS:
6676 case R_PPC64_GOT_TPREL16_LO_DS:
6677 case R_PPC64_GOT_TPREL16_HI:
6678 case R_PPC64_GOT_TPREL16_HA:
6679 tls_type = TLS_TLS | TLS_TPREL;
6680 goto dogot;
6681
6682 case R_PPC64_GOT_DTPREL16_DS:
6683 case R_PPC64_GOT_DTPREL16_LO_DS:
6684 case R_PPC64_GOT_DTPREL16_HI:
6685 case R_PPC64_GOT_DTPREL16_HA:
6686 tls_type = TLS_TLS | TLS_DTPREL;
6687 goto dogot;
6688
a33d1f77
AM		 6689 case R_PPC64_GOT16:
6690 case R_PPC64_GOT16_DS:
6691 case R_PPC64_GOT16_HA:
6692 case R_PPC64_GOT16_HI:
6693 case R_PPC64_GOT16_LO:
6694 case R_PPC64_GOT16_LO_DS:
411e1bfb
AM		 6695 dogot:
6696 {
6697 struct got_entry *ent;
6698
58ac9f71
AM		 6699 if (h != NULL)
6700 ent = h->got.glist;
411e1bfb
AM		 6701 else
6702 ent = local_got_ents[r_symndx];
6703
6704 for (; ent != NULL; ent = ent->next)
6705 if (ent->addend == rel->r_addend
e717da7e 6706 && ent->owner == abfd
411e1bfb
AM		 6707 && ent->tls_type == tls_type)
6708 break;
6709 if (ent == NULL)
6710 abort ();
6711 if (ent->got.refcount > 0)
6712 ent->got.refcount -= 1;
6713 }
8dea77f0
AM		 6714 if (h != NULL && !bfd_link_pic (info) && abiversion (abfd) != 1)
6715 plt_list = &h->plt.plist;
a33d1f77 6716 break;
65f38f15 6717
a33d1f77
AM		 6718 case R_PPC64_PLT16_HA:
6719 case R_PPC64_PLT16_HI:
6720 case R_PPC64_PLT16_LO:
6721 case R_PPC64_PLT32:
6722 case R_PPC64_PLT64:
721956f4
AM		 6723 case R_PPC64_REL14:
6724 case R_PPC64_REL14_BRNTAKEN:
6725 case R_PPC64_REL14_BRTAKEN:
5d1634d7 6726 case R_PPC64_REL24:
58ac9f71 6727 if (h != NULL)
cbf95972
AM		 6728 plt_list = &h->plt.plist;
6729 else if (local_got_ents != NULL)
6730 {
6731 struct plt_entry **local_plt = (struct plt_entry **)
6732 (local_got_ents + symtab_hdr->sh_info);
6733 unsigned char *local_got_tls_masks = (unsigned char *)
6734 (local_plt + symtab_hdr->sh_info);
6735 if ((local_got_tls_masks[r_symndx] & PLT_IFUNC) != 0)
6736 plt_list = local_plt + r_symndx;
6737 }
8dea77f0 6738 break;
411e1bfb 6739
8dea77f0
AM		 6740 case R_PPC64_ADDR64:
6741 case R_PPC64_ADDR16:
6742 case R_PPC64_ADDR16_DS:
6743 case R_PPC64_ADDR16_HA:
6744 case R_PPC64_ADDR16_HI:
6745 case R_PPC64_ADDR16_HIGH:
6746 case R_PPC64_ADDR16_HIGHA:
6747 case R_PPC64_ADDR16_HIGHER:
6748 case R_PPC64_ADDR16_HIGHERA:
6749 case R_PPC64_ADDR16_HIGHEST:
6750 case R_PPC64_ADDR16_HIGHESTA:
6751 case R_PPC64_ADDR16_LO:
6752 case R_PPC64_ADDR16_LO_DS:
6753 if (h != NULL && !bfd_link_pic (info) && abiversion (abfd) != 1
6754 && rel->r_addend == 0)
6755 plt_list = &h->plt.plist;
e86ce104 6756 break;
5d1634d7 6757
a33d1f77
AM		 6758 default:
6759 break;
6760 }
8dea77f0
AM		 6761 if (plt_list != NULL)
6762 {
6763 struct plt_entry *ent;
6764
6765 for (ent = *plt_list; ent != NULL; ent = ent->next)
6766 if (ent->addend == rel->r_addend)
6767 break;
6768 if (ent != NULL && ent->plt.refcount > 0)
6769 ent->plt.refcount -= 1;
6770 }
a33d1f77 6771 }
b34976b6 6772 return TRUE;
5bd4f169
AM		 6773}
6774
deb0e272
AM		 6775/* The maximum size of .sfpr. */
6776#define SFPR_MAX (218*4)
6777
6778struct sfpr_def_parms
6779{
699733f6
AM		 6780 const char name[12];
6781 unsigned char lo, hi;
deb0e272
AM		 6782 bfd_byte * (*write_ent) (bfd *, bfd_byte *, int);
6783 bfd_byte * (*write_tail) (bfd *, bfd_byte *, int);
6784};
6785
a4b6fadd
AM		 6786/* Auto-generate _save*, _rest* functions in .sfpr.
6787 If STUB_SEC is non-null, define alias symbols in STUB_SEC
6788 instead. */
deb0e272 6789
4dfe6ac6 6790static bfd_boolean
a4b6fadd
AM		 6791sfpr_define (struct bfd_link_info *info,
6792 const struct sfpr_def_parms *parm,
6793 asection *stub_sec)
deb0e272
AM		 6794{
6795 struct ppc_link_hash_table *htab = ppc_hash_table (info);
6796 unsigned int i;
6797 size_t len = strlen (parm->name);
6798 bfd_boolean writing = FALSE;
699733f6 6799 char sym[16];
deb0e272 6800
4dfe6ac6
NC		 6801 if (htab == NULL)
6802 return FALSE;
6803
deb0e272
AM		 6804 memcpy (sym, parm->name, len);
6805 sym[len + 2] = 0;
6806
6807 for (i = parm->lo; i <= parm->hi; i++)
6808 {
a4b6fadd 6809 struct ppc_link_hash_entry *h;
deb0e272
AM		 6810
6811 sym[len + 0] = i / 10 + '0';
6812 sym[len + 1] = i % 10 + '0';
a4b6fadd 6813 h = (struct ppc_link_hash_entry *)
b32547cd 6814 elf_link_hash_lookup (&htab->elf, sym, writing, TRUE, TRUE);
a4b6fadd 6815 if (stub_sec != NULL)
deb0e272 6816 {
a4b6fadd
AM		 6817 if (h != NULL
6818 && h->elf.root.type == bfd_link_hash_defined
6819 && h->elf.root.u.def.section == htab->sfpr)
6820 {
6821 struct elf_link_hash_entry *s;
6822 char buf[32];
6823 sprintf (buf, "%08x.%s", stub_sec->id & 0xffffffff, sym);
6824 s = elf_link_hash_lookup (&htab->elf, buf, TRUE, TRUE, FALSE);
6825 if (s == NULL)
6826 return FALSE;
6827 if (s->root.type == bfd_link_hash_new
6828 || (s->root.type = bfd_link_hash_defined
6829 && s->root.u.def.section == stub_sec))
6830 {
6831 s->root.type = bfd_link_hash_defined;
6832 s->root.u.def.section = stub_sec;
6833 s->root.u.def.value = (stub_sec->size
6834 + h->elf.root.u.def.value);
6835 s->ref_regular = 1;
6836 s->def_regular = 1;
6837 s->ref_regular_nonweak = 1;
6838 s->forced_local = 1;
6839 s->non_elf = 0;
6840 s->root.linker_def = 1;
6841 }
6842 }
6843 continue;
6844 }
6845 if (h != NULL)
6846 {
6847 h->save_res = 1;
6848 if (!h->elf.def_regular)
deb0e272 6849 {
a4b6fadd
AM		 6850 h->elf.root.type = bfd_link_hash_defined;
6851 h->elf.root.u.def.section = htab->sfpr;
6852 h->elf.root.u.def.value = htab->sfpr->size;
6853 h->elf.type = STT_FUNC;
6854 h->elf.def_regular = 1;
b32547cd 6855 h->elf.non_elf = 0;
a4b6fadd
AM		 6856 _bfd_elf_link_hash_hide_symbol (info, &h->elf, TRUE);
6857 writing = TRUE;
deb0e272 6858 if (htab->sfpr->contents == NULL)
a4b6fadd
AM		 6859 {
6860 htab->sfpr->contents = bfd_alloc (htab->elf.dynobj, SFPR_MAX);
6861 if (htab->sfpr->contents == NULL)
6862 return FALSE;
6863 }
deb0e272
AM		 6864 }
6865 }
6866 if (writing)
6867 {
6868 bfd_byte *p = htab->sfpr->contents + htab->sfpr->size;
6869 if (i != parm->hi)
6870 p = (*parm->write_ent) (htab->elf.dynobj, p, i);
6871 else
6872 p = (*parm->write_tail) (htab->elf.dynobj, p, i);
6873 htab->sfpr->size = p - htab->sfpr->contents;
6874 }
6875 }
6876
6877 return TRUE;
6878}
6879
6880static bfd_byte *
6881savegpr0 (bfd *abfd, bfd_byte *p, int r)
6882{
6883 bfd_put_32 (abfd, STD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6884 return p + 4;
6885}
6886
6887static bfd_byte *
6888savegpr0_tail (bfd *abfd, bfd_byte *p, int r)
6889{
6890 p = savegpr0 (abfd, p, r);
a078d95a 6891 bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
deb0e272
AM		 6892 p = p + 4;
6893 bfd_put_32 (abfd, BLR, p);
6894 return p + 4;
6895}
6896
6897static bfd_byte *
6898restgpr0 (bfd *abfd, bfd_byte *p, int r)
6899{
6900 bfd_put_32 (abfd, LD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6901 return p + 4;
6902}
6903
6904static bfd_byte *
6905restgpr0_tail (bfd *abfd, bfd_byte *p, int r)
6906{
a078d95a 6907 bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
deb0e272
AM		 6908 p = p + 4;
6909 p = restgpr0 (abfd, p, r);
6910 bfd_put_32 (abfd, MTLR_R0, p);
6911 p = p + 4;
6912 if (r == 29)
6913 {
6914 p = restgpr0 (abfd, p, 30);
6915 p = restgpr0 (abfd, p, 31);
6916 }
6917 bfd_put_32 (abfd, BLR, p);
6918 return p + 4;
6919}
6920
6921static bfd_byte *
6922savegpr1 (bfd *abfd, bfd_byte *p, int r)
6923{
6924 bfd_put_32 (abfd, STD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6925 return p + 4;
6926}
6927
6928static bfd_byte *
6929savegpr1_tail (bfd *abfd, bfd_byte *p, int r)
6930{
6931 p = savegpr1 (abfd, p, r);
6932 bfd_put_32 (abfd, BLR, p);
6933 return p + 4;
6934}
6935
6936static bfd_byte *
6937restgpr1 (bfd *abfd, bfd_byte *p, int r)
6938{
6939 bfd_put_32 (abfd, LD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6940 return p + 4;
6941}
6942
6943static bfd_byte *
6944restgpr1_tail (bfd *abfd, bfd_byte *p, int r)
6945{
6946 p = restgpr1 (abfd, p, r);
6947 bfd_put_32 (abfd, BLR, p);
6948 return p + 4;
6949}
6950
6951static bfd_byte *
6952savefpr (bfd *abfd, bfd_byte *p, int r)
6953{
6954 bfd_put_32 (abfd, STFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6955 return p + 4;
6956}
6957
6958static bfd_byte *
6959savefpr0_tail (bfd *abfd, bfd_byte *p, int r)
6960{
6961 p = savefpr (abfd, p, r);
a078d95a 6962 bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
deb0e272
AM		 6963 p = p + 4;
6964 bfd_put_32 (abfd, BLR, p);
6965 return p + 4;
6966}
6967
6968static bfd_byte *
6969restfpr (bfd *abfd, bfd_byte *p, int r)
6970{
6971 bfd_put_32 (abfd, LFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6972 return p + 4;
6973}
6974
6975static bfd_byte *
6976restfpr0_tail (bfd *abfd, bfd_byte *p, int r)
6977{
a078d95a 6978 bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
deb0e272
AM		 6979 p = p + 4;
6980 p = restfpr (abfd, p, r);
6981 bfd_put_32 (abfd, MTLR_R0, p);
6982 p = p + 4;
6983 if (r == 29)
6984 {
6985 p = restfpr (abfd, p, 30);
6986 p = restfpr (abfd, p, 31);
6987 }
6988 bfd_put_32 (abfd, BLR, p);
6989 return p + 4;
6990}
6991
6992static bfd_byte *
6993savefpr1_tail (bfd *abfd, bfd_byte *p, int r)
6994{
6995 p = savefpr (abfd, p, r);
6996 bfd_put_32 (abfd, BLR, p);
6997 return p + 4;
6998}
6999
7000static bfd_byte *
7001restfpr1_tail (bfd *abfd, bfd_byte *p, int r)
7002{
7003 p = restfpr (abfd, p, r);
7004 bfd_put_32 (abfd, BLR, p);
7005 return p + 4;
7006}
7007
7008static bfd_byte *
7009savevr (bfd *abfd, bfd_byte *p, int r)
7010{
7011 bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
7012 p = p + 4;
7013 bfd_put_32 (abfd, STVX_VR0_R12_R0 + (r << 21), p);
7014 return p + 4;
7015}
7016
7017static bfd_byte *
7018savevr_tail (bfd *abfd, bfd_byte *p, int r)
7019{
7020 p = savevr (abfd, p, r);
7021 bfd_put_32 (abfd, BLR, p);
7022 return p + 4;
7023}
7024
7025static bfd_byte *
7026restvr (bfd *abfd, bfd_byte *p, int r)
7027{
7028 bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
7029 p = p + 4;
7030 bfd_put_32 (abfd, LVX_VR0_R12_R0 + (r << 21), p);
7031 return p + 4;
7032}
7033
7034static bfd_byte *
7035restvr_tail (bfd *abfd, bfd_byte *p, int r)
7036{
7037 p = restvr (abfd, p, r);
7038 bfd_put_32 (abfd, BLR, p);
7039 return p + 4;
7040}
7041
e86ce104
AM		 7042/* Called via elf_link_hash_traverse to transfer dynamic linking
7043 information on function code symbol entries to their corresponding
7044 function descriptor symbol entries. */
deb0e272 7045
b34976b6 7046static bfd_boolean
4ce794b7 7047func_desc_adjust (struct elf_link_hash_entry *h, void *inf)
5bd4f169 7048{
e86ce104 7049 struct bfd_link_info *info;
65f38f15 7050 struct ppc_link_hash_table *htab;
50bc7936
AM		 7051 struct ppc_link_hash_entry *fh;
7052 struct ppc_link_hash_entry *fdh;
7053 bfd_boolean force_local;
5bd4f169 7054
50bc7936
AM		 7055 fh = (struct ppc_link_hash_entry *) h;
7056 if (fh->elf.root.type == bfd_link_hash_indirect)
b34976b6 7057 return TRUE;
e86ce104 7058
8c5b4e52
AM		 7059 if (!fh->is_func)
7060 return TRUE;
7061
7062 if (fh->elf.root.root.string[0] != '.'
7063 || fh->elf.root.root.string[1] == '\0')
7064 return TRUE;
7065
4ce794b7 7066 info = inf;
65f38f15 7067 htab = ppc_hash_table (info);
4dfe6ac6
NC		 7068 if (htab == NULL)
7069 return FALSE;
5bd4f169 7070
8c5b4e52
AM		 7071 /* Find the corresponding function descriptor symbol. */
7072 fdh = lookup_fdh (fh, htab);
7073
c09bdfe5
AM		 7074 /* Resolve undefined references to dot-symbols as the value
7075 in the function descriptor, if we have one in a regular object.
7076 This is to satisfy cases like ".quad .foo". Calls to functions
7077 in dynamic objects are handled elsewhere. */
8c5b4e52
AM		 7078 if ((fh->elf.root.type == bfd_link_hash_undefined
7079 || fh->elf.root.type == bfd_link_hash_undefweak)
7080 && (fdh->elf.root.type == bfd_link_hash_defined
7081 || fdh->elf.root.type == bfd_link_hash_defweak)
b31867b6
AM		 7082 && get_opd_info (fdh->elf.root.u.def.section) != NULL
7083 && opd_entry_value (fdh->elf.root.u.def.section,
7084 fdh->elf.root.u.def.value,
c09bdfe5 7085 &fh->elf.root.u.def.section,
aef36ac1 7086 &fh->elf.root.u.def.value, FALSE) != (bfd_vma) -1)
c09bdfe5 7087 {
b31867b6 7088 fh->elf.root.type = fdh->elf.root.type;
f5385ebf 7089 fh->elf.forced_local = 1;
b31867b6
AM		 7090 fh->elf.def_regular = fdh->elf.def_regular;
7091 fh->elf.def_dynamic = fdh->elf.def_dynamic;
c09bdfe5
AM		 7092 }
7093
8c5b4e52
AM		 7094 if (!fh->elf.dynamic)
7095 {
7096 struct plt_entry *ent;
5bd4f169 7097
8c5b4e52
AM		 7098 for (ent = fh->elf.plt.plist; ent != NULL; ent = ent->next)
7099 if (ent->plt.refcount > 0)
7100 break;
7101 if (ent == NULL)
7102 return TRUE;
7103 }
5bd4f169 7104
8c5b4e52 7105 /* Create a descriptor as undefined if necessary. */
50bc7936 7106 if (fdh == NULL
0e1862bb 7107 && !bfd_link_executable (info)
50bc7936
AM		 7108 && (fh->elf.root.type == bfd_link_hash_undefined
7109 || fh->elf.root.type == bfd_link_hash_undefweak))
7110 {
908b32fc 7111 fdh = make_fdh (info, fh);
bb700d78
AM		 7112 if (fdh == NULL)
7113 return FALSE;
50bc7936 7114 }
648cca2c 7115
8c5b4e52 7116 /* We can't support overriding of symbols on a fake descriptor. */
908b32fc
AM		 7117 if (fdh != NULL
7118 && fdh->fake
8c5b4e52
AM		 7119 && (fh->elf.root.type == bfd_link_hash_defined
7120 || fh->elf.root.type == bfd_link_hash_defweak))
7121 _bfd_elf_link_hash_hide_symbol (info, &fdh->elf, TRUE);
908b32fc 7122
8c5b4e52
AM		 7123 /* Transfer dynamic linking information to the function descriptor. */
7124 if (fdh != NULL)
7125 {
f5385ebf
AM		 7126 fdh->elf.ref_regular |= fh->elf.ref_regular;
7127 fdh->elf.ref_dynamic |= fh->elf.ref_dynamic;
7128 fdh->elf.ref_regular_nonweak |= fh->elf.ref_regular_nonweak;
7129 fdh->elf.non_got_ref |= fh->elf.non_got_ref;
8c5b4e52
AM		 7130 fdh->elf.dynamic |= fh->elf.dynamic;
7131 fdh->elf.needs_plt |= (fh->elf.needs_plt
7132 || fh->elf.type == STT_FUNC
7133 || fh->elf.type == STT_GNU_IFUNC);
7134 move_plt_plist (fh, fdh);
7135
7136 if (!fdh->elf.forced_local
7137 && fh->elf.dynindx != -1)
7138 if (!bfd_elf_link_record_dynamic_symbol (info, &fdh->elf))
7139 return FALSE;
e86ce104
AM		 7140 }
7141
50bc7936
AM		 7142 /* Now that the info is on the function descriptor, clear the
7143 function code sym info. Any function code syms for which we
7144 don't have a definition in a regular file, we force local.
7145 This prevents a shared library from exporting syms that have
7146 been imported from another library. Function code syms that
7147 are really in the library we must leave global to prevent the
7148 linker dragging in a definition from a static library. */
93f3fa99
AM		 7149 force_local = (!fh->elf.def_regular
7150 || fdh == NULL
7151 || !fdh->elf.def_regular
7152 || fdh->elf.forced_local);
50bc7936
AM		 7153 _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
7154
b34976b6 7155 return TRUE;
e86ce104 7156}
40b8271b 7157
a4b6fadd
AM		 7158static const struct sfpr_def_parms save_res_funcs[] =
7159 {
7160 { "_savegpr0_", 14, 31, savegpr0, savegpr0_tail },
7161 { "_restgpr0_", 14, 29, restgpr0, restgpr0_tail },
7162 { "_restgpr0_", 30, 31, restgpr0, restgpr0_tail },
7163 { "_savegpr1_", 14, 31, savegpr1, savegpr1_tail },
7164 { "_restgpr1_", 14, 31, restgpr1, restgpr1_tail },
7165 { "_savefpr_", 14, 31, savefpr, savefpr0_tail },
7166 { "_restfpr_", 14, 29, restfpr, restfpr0_tail },
7167 { "_restfpr_", 30, 31, restfpr, restfpr0_tail },
7168 { "._savef", 14, 31, savefpr, savefpr1_tail },
7169 { "._restf", 14, 31, restfpr, restfpr1_tail },
7170 { "_savevr_", 20, 31, savevr, savevr_tail },
7171 { "_restvr_", 20, 31, restvr, restvr_tail }
7172 };
7173
e86ce104 7174/* Called near the start of bfd_elf_size_dynamic_sections. We use
82bd7b59
AM		 7175 this hook to a) provide some gcc support functions, and b) transfer
7176 dynamic linking information gathered so far on function code symbol
7177 entries, to their corresponding function descriptor symbol entries. */
deb0e272 7178
b34976b6 7179static bfd_boolean
4ce794b7
AM		 7180ppc64_elf_func_desc_adjust (bfd *obfd ATTRIBUTE_UNUSED,
7181 struct bfd_link_info *info)
e86ce104
AM		 7182{
7183 struct ppc_link_hash_table *htab;
7184
7185 htab = ppc_hash_table (info);
4dfe6ac6
NC		 7186 if (htab == NULL)
7187 return FALSE;
7188
b32547cd
AM		 7189 /* Provide any missing _save* and _rest* functions. */
7190 if (htab->sfpr != NULL)
7191 {
7192 unsigned int i;
7193
7194 htab->sfpr->size = 0;
7195 for (i = 0; i < ARRAY_SIZE (save_res_funcs); i++)
7196 if (!sfpr_define (info, &save_res_funcs[i], NULL))
7197 return FALSE;
7198 if (htab->sfpr->size == 0)
7199 htab->sfpr->flags |= SEC_EXCLUDE;
7200 }
7201
7202 if (bfd_link_relocatable (info))
7203 return TRUE;
7204
7205 if (htab->elf.hgot != NULL)
dba6fa9b
AM		 7206 {
7207 _bfd_elf_link_hash_hide_symbol (info, htab->elf.hgot, TRUE);
7208 /* Make .TOC. defined so as to prevent it being made dynamic.
7209 The wrong value here is fixed later in ppc64_elf_set_toc. */
43417696
AM		 7210 if (!htab->elf.hgot->def_regular
7211 || htab->elf.hgot->root.type != bfd_link_hash_defined)
7212 {
7213 htab->elf.hgot->root.type = bfd_link_hash_defined;
7214 htab->elf.hgot->root.u.def.value = 0;
7215 htab->elf.hgot->root.u.def.section = bfd_abs_section_ptr;
7216 htab->elf.hgot->def_regular = 1;
7217 htab->elf.hgot->root.linker_def = 1;
7218 }
dba6fa9b 7219 htab->elf.hgot->type = STT_OBJECT;
dba6fa9b
AM		 7220 htab->elf.hgot->other = ((htab->elf.hgot->other & ~ELF_ST_VISIBILITY (-1))
7221 | STV_HIDDEN);
7222 }
c66bb0ee 7223
8c5b4e52
AM		 7224 if (htab->need_func_desc_adj)
7225 {
7226 elf_link_hash_traverse (&htab->elf, func_desc_adjust, info);
7227 htab->need_func_desc_adj = 0;
7228 }
805fc799 7229
b34976b6 7230 return TRUE;
e86ce104
AM		 7231}
7232
8a2058b5
AM		 7233/* Return true if we have dynamic relocs against H that apply to
7234 read-only sections. */
a345bc8d
AM		 7235
7236static bfd_boolean
7237readonly_dynrelocs (struct elf_link_hash_entry *h)
7238{
7239 struct ppc_link_hash_entry *eh;
7240 struct elf_dyn_relocs *p;
7241
7242 eh = (struct ppc_link_hash_entry *) h;
7243 for (p = eh->dyn_relocs; p != NULL; p = p->next)
7244 {
7245 asection *s = p->sec->output_section;
7246
7247 if (s != NULL && (s->flags & SEC_READONLY) != 0)
7248 return TRUE;
7249 }
7250 return FALSE;
7251}
7252
d311bc8b
AM		 7253/* Return true if we have dynamic relocs against H or any of its weak
7254 aliases, that apply to read-only sections. */
7255
7256static bfd_boolean
7257alias_readonly_dynrelocs (struct elf_link_hash_entry *h)
7258{
7259 struct ppc_link_hash_entry *eh;
7260
7261 eh = (struct ppc_link_hash_entry *) h;
7262 do
7263 {
7264 if (readonly_dynrelocs (&eh->elf))
7265 return TRUE;
7266 eh = eh->weakref;
7267 } while (eh != NULL && &eh->elf != h);
7268
7269 return FALSE;
7270}
8a2058b5 7271
8a9e8e72
AM		 7272/* Return whether EH has pc-relative dynamic relocs. */
7273
7274static bfd_boolean
7275pc_dynrelocs (struct ppc_link_hash_entry *eh)
7276{
7277 struct elf_dyn_relocs *p;
7278
7279 for (p = eh->dyn_relocs; p != NULL; p = p->next)
7280 if (p->pc_count != 0)
7281 return TRUE;
7282 return FALSE;
7283}
7284
8a2058b5
AM		 7285/* Return true if a global entry stub will be created for H. Valid
7286 for ELFv2 before plt entries have been allocated. */
7287
7288static bfd_boolean
7289global_entry_stub (struct elf_link_hash_entry *h)
7290{
7291 struct plt_entry *pent;
7292
7293 if (!h->pointer_equality_needed
7294 || h->def_regular)
7295 return FALSE;
7296
7297 for (pent = h->plt.plist; pent != NULL; pent = pent->next)
7298 if (pent->plt.refcount > 0
7299 && pent->addend == 0)
7300 return TRUE;
7301
7302 return FALSE;
7303}
7304
e86ce104
AM		 7305/* Adjust a symbol defined by a dynamic object and referenced by a
7306 regular object. The current definition is in some section of the
7307 dynamic object, but we're not including those sections. We have to
7308 change the definition to something the rest of the link can
7309 understand. */
7310
b34976b6 7311static bfd_boolean
4ce794b7
AM		 7312ppc64_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
7313 struct elf_link_hash_entry *h)
e86ce104
AM		 7314{
7315 struct ppc_link_hash_table *htab;
5474d94f 7316 asection *s, *srel;
e86ce104
AM		 7317
7318 htab = ppc_hash_table (info);
4dfe6ac6
NC		 7319 if (htab == NULL)
7320 return FALSE;
e86ce104
AM		 7321
7322 /* Deal with function syms. */
7323 if (h->type == STT_FUNC
e054468f 7324 || h->type == STT_GNU_IFUNC
f5385ebf 7325 || h->needs_plt)
e86ce104
AM		 7326 {
7327 /* Clear procedure linkage table information for any symbol that
7328 won't need a .plt entry. */
411e1bfb
AM		 7329 struct plt_entry *ent;
7330 for (ent = h->plt.plist; ent != NULL; ent = ent->next)
7331 if (ent->plt.refcount > 0)
7332 break;
8387904d 7333 if (ent == NULL
e054468f
AM		 7334 || (h->type != STT_GNU_IFUNC
7335 && (SYMBOL_CALLS_LOCAL (info, h)
21d68fcd 7336 || UNDEFWEAK_NO_DYNAMIC_RELOC (info, h)))
a4b6fadd 7337 || ((struct ppc_link_hash_entry *) h)->save_res)
40b8271b 7338 {
411e1bfb 7339 h->plt.plist = NULL;
f5385ebf 7340 h->needs_plt = 0;
d1eca1e4 7341 h->pointer_equality_needed = 0;
40b8271b 7342 }
8a2058b5 7343 else if (abiversion (info->output_bfd) >= 2)
a345bc8d 7344 {
d1eca1e4
AM		 7345 /* Taking a function's address in a read/write section
7346 doesn't require us to define the function symbol in the
7347 executable on a global entry stub. A dynamic reloc can
8a2058b5
AM		 7348 be used instead. The reason we prefer a few more dynamic
7349 relocs is that calling via a global entry stub costs a
7350 few more instructions, and pointer_equality_needed causes
7351 extra work in ld.so when resolving these symbols. */
7352 if (global_entry_stub (h)
d311bc8b 7353 && !alias_readonly_dynrelocs (h))
d1eca1e4
AM		 7354 {
7355 h->pointer_equality_needed = 0;
8a2058b5
AM		 7356 /* After adjust_dynamic_symbol, non_got_ref set in
7357 the non-pic case means that dyn_relocs for this
7358 symbol should be discarded. */
d1eca1e4
AM		 7359 h->non_got_ref = 0;
7360 }
7361
a345bc8d
AM		 7362 /* If making a plt entry, then we don't need copy relocs. */
7363 return TRUE;
7364 }
5bd4f169 7365 }
bbd7ec4a 7366 else
411e1bfb 7367 h->plt.plist = NULL;
5bd4f169
AM		 7368
7369 /* If this is a weak symbol, and there is a real definition, the
7370 processor independent code will have arranged for us to see the
7371 real definition first, and we can just use the same value. */
f6e332e6 7372 if (h->u.weakdef != NULL)
5bd4f169 7373 {
f6e332e6
AM		 7374 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
7375 || h->u.weakdef->root.type == bfd_link_hash_defweak);
7376 h->root.u.def.section = h->u.weakdef->root.u.def.section;
7377 h->root.u.def.value = h->u.weakdef->root.u.def.value;
a23b6845 7378 if (ELIMINATE_COPY_RELOCS)
f6e332e6 7379 h->non_got_ref = h->u.weakdef->non_got_ref;
b34976b6 7380 return TRUE;
5bd4f169
AM		 7381 }
7382
5bd4f169
AM		 7383 /* If we are creating a shared library, we must presume that the
7384 only references to the symbol are via the global offset table.
7385 For such cases we need not do anything here; the relocations will
7386 be handled correctly by relocate_section. */
0e1862bb 7387 if (bfd_link_pic (info))
b34976b6 7388 return TRUE;
5bd4f169 7389
65f38f15
AM		 7390 /* If there are no references to this symbol that do not use the
7391 GOT, we don't need to generate a copy reloc. */
f5385ebf 7392 if (!h->non_got_ref)
b34976b6 7393 return TRUE;
65f38f15 7394
b186458a 7395 /* Don't generate a copy reloc for symbols defined in the executable. */
d93d1c80 7396 if (!h->def_dynamic || !h->ref_regular || h->def_regular
b186458a 7397
d93d1c80
AM		 7398 /* If -z nocopyreloc was given, don't generate them either. */
7399 || info->nocopyreloc
a127494f 7400
d93d1c80
AM		 7401 /* If we didn't find any dynamic relocs in read-only sections, then
7402 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
d311bc8b 7403 || (ELIMINATE_COPY_RELOCS && !alias_readonly_dynrelocs (h))
65f38f15 7404
d93d1c80
AM		 7405 /* Protected variables do not work with .dynbss. The copy in
7406 .dynbss won't be used by the shared library with the protected
7407 definition for the variable. Text relocations are preferable
7408 to an incorrect program. */
7409 || h->protected_def)
a127494f
AM		 7410 {
7411 h->non_got_ref = 0;
7412 return TRUE;
7413 }
7414
5d35169e 7415 if (h->plt.plist != NULL)
97b639ba
AM		 7416 {
7417 /* We should never get here, but unfortunately there are versions
7418 of gcc out there that improperly (for this ABI) put initialized
7419 function pointers, vtable refs and suchlike in read-only
7420 sections. Allow them to proceed, but warn that this might
7421 break at runtime. */
25f53a85 7422 info->callbacks->einfo
bc30df16 7423 (_("%P: copy reloc against `%T' requires lazy plt linking; "
25f53a85 7424 "avoid setting LD_BIND_NOW=1 or upgrade gcc\n"),
97b639ba
AM		 7425 h->root.root.string);
7426 }
5d35169e
AM		 7427
7428 /* This is a reference to a symbol defined by a dynamic object which
7429 is not a function. */
7430
5bd4f169
AM		 7431 /* We must allocate the symbol in our .dynbss section, which will
7432 become part of the .bss section of the executable. There will be
7433 an entry for this symbol in the .dynsym section. The dynamic
7434 object will contain position independent code, so all references
7435 from the dynamic object to this symbol will go through the global
7436 offset table. The dynamic linker will use the .dynsym entry to
7437 determine the address it must put in the global offset table, so
7438 both the dynamic object and the regular object will refer to the
7439 same memory location for the variable. */
5bd4f169 7440
04c9666a
AM		 7441 /* We must generate a R_PPC64_COPY reloc to tell the dynamic linker
7442 to copy the initial value out of the dynamic object and into the
5bd4f169
AM		 7443 runtime process image. We need to remember the offset into the
7444 .rela.bss section we are going to use. */
5474d94f
AM		 7445 if ((h->root.u.def.section->flags & SEC_READONLY) != 0)
7446 {
7447 s = htab->elf.sdynrelro;
7448 srel = htab->elf.sreldynrelro;
7449 }
7450 else
7451 {
7452 s = htab->elf.sdynbss;
7453 srel = htab->elf.srelbss;
7454 }
1d7e9d18 7455 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
5bd4f169 7456 {
5474d94f 7457 srel->size += sizeof (Elf64_External_Rela);
f5385ebf 7458 h->needs_copy = 1;
5bd4f169
AM		 7459 }
7460
6cabe1ea 7461 return _bfd_elf_adjust_dynamic_copy (info, h, s);
5bd4f169
AM		 7462}
7463
e86ce104
AM		 7464/* If given a function descriptor symbol, hide both the function code
7465 sym and the descriptor. */
7466static void
4ce794b7
AM		 7467ppc64_elf_hide_symbol (struct bfd_link_info *info,
7468 struct elf_link_hash_entry *h,
7469 bfd_boolean force_local)
e86ce104 7470{
34814b9f 7471 struct ppc_link_hash_entry *eh;
e86ce104
AM		 7472 _bfd_elf_link_hash_hide_symbol (info, h, force_local);
7473
34814b9f
AM		 7474 eh = (struct ppc_link_hash_entry *) h;
7475 if (eh->is_func_descriptor)
e86ce104 7476 {
34814b9f 7477 struct ppc_link_hash_entry *fh = eh->oh;
e86ce104 7478
721956f4 7479 if (fh == NULL)
d1329ca3
AM		 7480 {
7481 const char *p, *q;
b8ac2841 7482 struct elf_link_hash_table *htab = elf_hash_table (info);
d1329ca3
AM		 7483 char save;
7484
7485 /* We aren't supposed to use alloca in BFD because on
7486 systems which do not have alloca the version in libiberty
7487 calls xmalloc, which might cause the program to crash
7488 when it runs out of memory. This function doesn't have a
7489 return status, so there's no way to gracefully return an
7490 error. So cheat. We know that string[-1] can be safely
34814b9f
AM		 7491 accessed; It's either a string in an ELF string table,
7492 or allocated in an objalloc structure. */
d1329ca3 7493
34814b9f 7494 p = eh->elf.root.root.string - 1;
d1329ca3
AM		 7495 save = *p;
7496 *(char *) p = '.';
34814b9f 7497 fh = (struct ppc_link_hash_entry *)
b8ac2841 7498 elf_link_hash_lookup (htab, p, FALSE, FALSE, FALSE);
d1329ca3
AM		 7499 *(char *) p = save;
7500
7501 /* Unfortunately, if it so happens that the string we were
7502 looking for was allocated immediately before this string,
7503 then we overwrote the string terminator. That's the only
7504 reason the lookup should fail. */
7505 if (fh == NULL)
7506 {
34814b9f
AM		 7507 q = eh->elf.root.root.string + strlen (eh->elf.root.root.string);
7508 while (q >= eh->elf.root.root.string && *q == *p)
d1329ca3 7509 --q, --p;
34814b9f
AM		 7510 if (q < eh->elf.root.root.string && *p == '.')
7511 fh = (struct ppc_link_hash_entry *)
b8ac2841 7512 elf_link_hash_lookup (htab, p, FALSE, FALSE, FALSE);
d1329ca3
AM		 7513 }
7514 if (fh != NULL)
7515 {
34814b9f
AM		 7516 eh->oh = fh;
7517 fh->oh = eh;
d1329ca3
AM		 7518 }
7519 }
e86ce104 7520 if (fh != NULL)
34814b9f 7521 _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
e86ce104
AM		 7522 }
7523}
7524
411e1bfb 7525static bfd_boolean
8843416a
AM		 7526get_sym_h (struct elf_link_hash_entry **hp,
7527 Elf_Internal_Sym **symp,
7528 asection **symsecp,
f961d9dd 7529 unsigned char **tls_maskp,
8843416a
AM		 7530 Elf_Internal_Sym **locsymsp,
7531 unsigned long r_symndx,
7532 bfd *ibfd)
411e1bfb 7533{
0ffa91dd 7534 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
411e1bfb
AM		 7535
7536 if (r_symndx >= symtab_hdr->sh_info)
7537 {
7538 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
7539 struct elf_link_hash_entry *h;
7540
7541 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
b31867b6 7542 h = elf_follow_link (h);
411e1bfb
AM		 7543
7544 if (hp != NULL)
7545 *hp = h;
7546
7547 if (symp != NULL)
7548 *symp = NULL;
7549
7550 if (symsecp != NULL)
7551 {
7552 asection *symsec = NULL;
7553 if (h->root.type == bfd_link_hash_defined
7554 || h->root.type == bfd_link_hash_defweak)
7555 symsec = h->root.u.def.section;
7556 *symsecp = symsec;
7557 }
7558
e7b938ca 7559 if (tls_maskp != NULL)
411e1bfb
AM		 7560 {
7561 struct ppc_link_hash_entry *eh;
7562
7563 eh = (struct ppc_link_hash_entry *) h;
e7b938ca 7564 *tls_maskp = &eh->tls_mask;
411e1bfb
AM		 7565 }
7566 }
7567 else
7568 {
7569 Elf_Internal_Sym *sym;
7570 Elf_Internal_Sym *locsyms = *locsymsp;
7571
7572 if (locsyms == NULL)
7573 {
7574 locsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
7575 if (locsyms == NULL)
7576 locsyms = bfd_elf_get_elf_syms (ibfd, symtab_hdr,
7577 symtab_hdr->sh_info,
7578 0, NULL, NULL, NULL);
7579 if (locsyms == NULL)
7580 return FALSE;
7581 *locsymsp = locsyms;
7582 }
7583 sym = locsyms + r_symndx;
7584
7585 if (hp != NULL)
7586 *hp = NULL;
7587
7588 if (symp != NULL)
7589 *symp = sym;
7590
7591 if (symsecp != NULL)
cb33740c 7592 *symsecp = bfd_section_from_elf_index (ibfd, sym->st_shndx);
411e1bfb 7593
e7b938ca 7594 if (tls_maskp != NULL)
411e1bfb
AM		 7595 {
7596 struct got_entry **lgot_ents;
f961d9dd 7597 unsigned char *tls_mask;
411e1bfb 7598
e7b938ca 7599 tls_mask = NULL;
411e1bfb
AM		 7600 lgot_ents = elf_local_got_ents (ibfd);
7601 if (lgot_ents != NULL)
7602 {
e054468f
AM		 7603 struct plt_entry **local_plt = (struct plt_entry **)
7604 (lgot_ents + symtab_hdr->sh_info);
f961d9dd 7605 unsigned char *lgot_masks = (unsigned char *)
e054468f 7606 (local_plt + symtab_hdr->sh_info);
e7b938ca 7607 tls_mask = &lgot_masks[r_symndx];
411e1bfb 7608 }
e7b938ca 7609 *tls_maskp = tls_mask;
411e1bfb
AM		 7610 }
7611 }
7612 return TRUE;
7613}
7614
e7b938ca 7615/* Returns TLS_MASKP for the given REL symbol. Function return is 0 on
951fd09b 7616 error, 2 on a toc GD type suitable for optimization, 3 on a toc LD
ad8e1ba5 7617 type suitable for optimization, and 1 otherwise. */
951fd09b
AM		 7618
7619static int
f961d9dd 7620get_tls_mask (unsigned char **tls_maskp,
3a71aa26
AM		 7621 unsigned long *toc_symndx,
7622 bfd_vma *toc_addend,
0d4792f7 7623 Elf_Internal_Sym **locsymsp,
3a71aa26
AM		 7624 const Elf_Internal_Rela *rel,
7625 bfd *ibfd)
411e1bfb
AM		 7626{
7627 unsigned long r_symndx;
0d4792f7 7628 int next_r;
411e1bfb
AM		 7629 struct elf_link_hash_entry *h;
7630 Elf_Internal_Sym *sym;
7631 asection *sec;
7632 bfd_vma off;
7633
7634 r_symndx = ELF64_R_SYM (rel->r_info);
e7b938ca 7635 if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
951fd09b 7636 return 0;
411e1bfb 7637
e7b938ca 7638 if ((*tls_maskp != NULL && **tls_maskp != 0)
411e1bfb 7639 || sec == NULL
6bee8834 7640 || ppc64_elf_section_data (sec) == NULL
7c8fe5c4 7641 || ppc64_elf_section_data (sec)->sec_type != sec_toc)
951fd09b 7642 return 1;
411e1bfb
AM		 7643
7644 /* Look inside a TOC section too. */
7645 if (h != NULL)
7646 {
7647 BFD_ASSERT (h->root.type == bfd_link_hash_defined);
7648 off = h->root.u.def.value;
7649 }
7650 else
7651 off = sym->st_value;
7652 off += rel->r_addend;
7653 BFD_ASSERT (off % 8 == 0);
3a71aa26
AM		 7654 r_symndx = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8];
7655 next_r = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8 + 1];
0d4792f7
AM		 7656 if (toc_symndx != NULL)
7657 *toc_symndx = r_symndx;
3a71aa26
AM		 7658 if (toc_addend != NULL)
7659 *toc_addend = ppc64_elf_section_data (sec)->u.toc.add[off / 8];
7660 if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7661 return 0;
854b41e7 7662 if ((h == NULL || is_static_defined (h))
0d4792f7
AM		 7663 && (next_r == -1 || next_r == -2))
7664 return 1 - next_r;
951fd09b 7665 return 1;
411e1bfb
AM		 7666}
7667
3b421ab3
AM		 7668/* Find (or create) an entry in the tocsave hash table. */
7669
7670static struct tocsave_entry *
7671tocsave_find (struct ppc_link_hash_table *htab,
7672 enum insert_option insert,
7673 Elf_Internal_Sym **local_syms,
7674 const Elf_Internal_Rela *irela,
7675 bfd *ibfd)
7676{
7677 unsigned long r_indx;
7678 struct elf_link_hash_entry *h;
7679 Elf_Internal_Sym *sym;
7680 struct tocsave_entry ent, *p;
7681 hashval_t hash;
7682 struct tocsave_entry **slot;
7683
7684 r_indx = ELF64_R_SYM (irela->r_info);
7685 if (!get_sym_h (&h, &sym, &ent.sec, NULL, local_syms, r_indx, ibfd))
7686 return NULL;
7687 if (ent.sec == NULL || ent.sec->output_section == NULL)
7688 {
4eca0228 7689 _bfd_error_handler
10463f39 7690 (_("%B: undefined symbol on R_PPC64_TOCSAVE relocation"), ibfd);
3b421ab3
AM		 7691 return NULL;
7692 }
7693
7694 if (h != NULL)
7695 ent.offset = h->root.u.def.value;
7696 else
7697 ent.offset = sym->st_value;
7698 ent.offset += irela->r_addend;
7699
7700 hash = tocsave_htab_hash (&ent);
7701 slot = ((struct tocsave_entry **)
7702 htab_find_slot_with_hash (htab->tocsave_htab, &ent, hash, insert));
7703 if (slot == NULL)
7704 return NULL;
7705
7706 if (*slot == NULL)
7707 {
7708 p = (struct tocsave_entry *) bfd_alloc (ibfd, sizeof (*p));
7709 if (p == NULL)
7710 return NULL;
7711 *p = ent;
7712 *slot = p;
7713 }
7714 return *slot;
7715}
7716
754021d0 7717/* Adjust all global syms defined in opd sections. In gcc generated
8387904d 7718 code for the old ABI, these will already have been done. */
754021d0
AM		 7719
7720static bfd_boolean
7721adjust_opd_syms (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
7722{
7723 struct ppc_link_hash_entry *eh;
7724 asection *sym_sec;
74f0fb50 7725 struct _opd_sec_data *opd;
754021d0
AM		 7726
7727 if (h->root.type == bfd_link_hash_indirect)
7728 return TRUE;
7729
754021d0
AM		 7730 if (h->root.type != bfd_link_hash_defined
7731 && h->root.type != bfd_link_hash_defweak)
7732 return TRUE;
7733
7734 eh = (struct ppc_link_hash_entry *) h;
7735 if (eh->adjust_done)
7736 return TRUE;
7737
7738 sym_sec = eh->elf.root.u.def.section;
74f0fb50
AM		 7739 opd = get_opd_info (sym_sec);
7740 if (opd != NULL && opd->adjust != NULL)
754021d0 7741 {
51aecdc5 7742 long adjust = opd->adjust[OPD_NDX (eh->elf.root.u.def.value)];
4025353c
AM		 7743 if (adjust == -1)
7744 {
7745 /* This entry has been deleted. */
b3fac117 7746 asection *dsec = ppc64_elf_tdata (sym_sec->owner)->deleted_section;
81688140
AM		 7747 if (dsec == NULL)
7748 {
7749 for (dsec = sym_sec->owner->sections; dsec; dsec = dsec->next)
dbaa2011 7750 if (discarded_section (dsec))
81688140 7751 {
b3fac117 7752 ppc64_elf_tdata (sym_sec->owner)->deleted_section = dsec;
81688140
AM		 7753 break;
7754 }
7755 }
4025353c 7756 eh->elf.root.u.def.value = 0;
81688140 7757 eh->elf.root.u.def.section = dsec;
4025353c
AM		 7758 }
7759 else
7760 eh->elf.root.u.def.value += adjust;
754021d0
AM		 7761 eh->adjust_done = 1;
7762 }
7763 return TRUE;
7764}
7765
8c1d1bb8 7766/* Handles decrementing dynamic reloc counts for the reloc specified by
19e08130 7767 R_INFO in section SEC. If LOCAL_SYMS is NULL, then H and SYM
8c1d1bb8
AM		 7768 have already been determined. */
7769
7770static bfd_boolean
7771dec_dynrel_count (bfd_vma r_info,
7772 asection *sec,
7773 struct bfd_link_info *info,
7774 Elf_Internal_Sym **local_syms,
7775 struct elf_link_hash_entry *h,
19e08130 7776 Elf_Internal_Sym *sym)
8c1d1bb8
AM		 7777{
7778 enum elf_ppc64_reloc_type r_type;
19e08130 7779 asection *sym_sec = NULL;
8c1d1bb8
AM		 7780
7781 /* Can this reloc be dynamic? This switch, and later tests here
7782 should be kept in sync with the code in check_relocs. */
7783 r_type = ELF64_R_TYPE (r_info);
7784 switch (r_type)
7785 {
7786 default:
7787 return TRUE;
7788
7789 case R_PPC64_TPREL16:
7790 case R_PPC64_TPREL16_LO:
7791 case R_PPC64_TPREL16_HI:
7792 case R_PPC64_TPREL16_HA:
7793 case R_PPC64_TPREL16_DS:
7794 case R_PPC64_TPREL16_LO_DS:
f9c6b907
AM		 7795 case R_PPC64_TPREL16_HIGH:
7796 case R_PPC64_TPREL16_HIGHA:
8c1d1bb8
AM		 7797 case R_PPC64_TPREL16_HIGHER:
7798 case R_PPC64_TPREL16_HIGHERA:
7799 case R_PPC64_TPREL16_HIGHEST:
7800 case R_PPC64_TPREL16_HIGHESTA:
0e1862bb 7801 if (!bfd_link_pic (info))
8c1d1bb8
AM		 7802 return TRUE;
7803
7804 case R_PPC64_TPREL64:
7805 case R_PPC64_DTPMOD64:
7806 case R_PPC64_DTPREL64:
7807 case R_PPC64_ADDR64:
7808 case R_PPC64_REL30:
7809 case R_PPC64_REL32:
7810 case R_PPC64_REL64:
7811 case R_PPC64_ADDR14:
7812 case R_PPC64_ADDR14_BRNTAKEN:
7813 case R_PPC64_ADDR14_BRTAKEN:
7814 case R_PPC64_ADDR16:
7815 case R_PPC64_ADDR16_DS:
7816 case R_PPC64_ADDR16_HA:
7817 case R_PPC64_ADDR16_HI:
f9c6b907
AM		 7818 case R_PPC64_ADDR16_HIGH:
7819 case R_PPC64_ADDR16_HIGHA:
8c1d1bb8
AM		 7820 case R_PPC64_ADDR16_HIGHER:
7821 case R_PPC64_ADDR16_HIGHERA:
7822 case R_PPC64_ADDR16_HIGHEST:
7823 case R_PPC64_ADDR16_HIGHESTA:
7824 case R_PPC64_ADDR16_LO:
7825 case R_PPC64_ADDR16_LO_DS:
7826 case R_PPC64_ADDR24:
7827 case R_PPC64_ADDR32:
7828 case R_PPC64_UADDR16:
7829 case R_PPC64_UADDR32:
7830 case R_PPC64_UADDR64:
7831 case R_PPC64_TOC:
7832 break;
7833 }
7834
7835 if (local_syms != NULL)
7836 {
7837 unsigned long r_symndx;
8c1d1bb8
AM		 7838 bfd *ibfd = sec->owner;
7839
7840 r_symndx = ELF64_R_SYM (r_info);
7841 if (!get_sym_h (&h, &sym, &sym_sec, NULL, local_syms, r_symndx, ibfd))
7842 return FALSE;
7843 }
7844
0e1862bb 7845 if ((bfd_link_pic (info)
1d483afe 7846 && (must_be_dyn_reloc (info, r_type)
8c1d1bb8 7847 || (h != NULL
198f1157 7848 && (!SYMBOLIC_BIND (info, h)
8c1d1bb8
AM		 7849 || h->root.type == bfd_link_hash_defweak
7850 || !h->def_regular))))
7851 || (ELIMINATE_COPY_RELOCS
0e1862bb 7852 && !bfd_link_pic (info)
8c1d1bb8
AM		 7853 && h != NULL
7854 && (h->root.type == bfd_link_hash_defweak
7855 || !h->def_regular)))
7856 ;
7857 else
7858 return TRUE;
7859
7860 if (h != NULL)
6edfbbad 7861 {
19e08130
AM		 7862 struct elf_dyn_relocs *p;
7863 struct elf_dyn_relocs **pp;
7864 pp = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
7865
7866 /* elf_gc_sweep may have already removed all dyn relocs associated
7867 with local syms for a given section. Also, symbol flags are
7868 changed by elf_gc_sweep_symbol, confusing the test above. Don't
7869 report a dynreloc miscount. */
7870 if (*pp == NULL && info->gc_sections)
7871 return TRUE;
7872
7873 while ((p = *pp) != NULL)
60124e18 7874 {
19e08130
AM		 7875 if (p->sec == sec)
7876 {
7877 if (!must_be_dyn_reloc (info, r_type))
7878 p->pc_count -= 1;
7879 p->count -= 1;
7880 if (p->count == 0)
7881 *pp = p->next;
7882 return TRUE;
7883 }
7884 pp = &p->next;
60124e18 7885 }
6edfbbad 7886 }
19e08130
AM		 7887 else
7888 {
7889 struct ppc_dyn_relocs *p;
7890 struct ppc_dyn_relocs **pp;
7891 void *vpp;
7892 bfd_boolean is_ifunc;
8c1d1bb8 7893
19e08130
AM		 7894 if (local_syms == NULL)
7895 sym_sec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
7896 if (sym_sec == NULL)
7897 sym_sec = sec;
c57da1a7 7898
19e08130
AM		 7899 vpp = &elf_section_data (sym_sec)->local_dynrel;
7900 pp = (struct ppc_dyn_relocs **) vpp;
7901
7902 if (*pp == NULL && info->gc_sections)
7903 return TRUE;
7904
7905 is_ifunc = ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC;
7906 while ((p = *pp) != NULL)
8c1d1bb8 7907 {
19e08130
AM		 7908 if (p->sec == sec && p->ifunc == is_ifunc)
7909 {
7910 p->count -= 1;
7911 if (p->count == 0)
7912 *pp = p->next;
7913 return TRUE;
7914 }
7915 pp = &p->next;
8c1d1bb8 7916 }
8c1d1bb8
AM		 7917 }
7918
695344c0 7919 /* xgettext:c-format */
8de848d8 7920 info->callbacks->einfo (_("%P: dynreloc miscount for %B, section %A\n"),
25f53a85 7921 sec->owner, sec);
8c1d1bb8
AM		 7922 bfd_set_error (bfd_error_bad_value);
7923 return FALSE;
7924}
7925
754021d0
AM		 7926/* Remove unused Official Procedure Descriptor entries. Currently we
7927 only remove those associated with functions in discarded link-once
7928 sections, or weakly defined functions that have been overridden. It
7929 would be possible to remove many more entries for statically linked
7930 applications. */
7931
b34976b6 7932bfd_boolean
e7d1c40c 7933ppc64_elf_edit_opd (struct bfd_link_info *info)
1e2f5b6e
AM		 7934{
7935 bfd *ibfd;
754021d0 7936 bfd_boolean some_edited = FALSE;
3f764659 7937 asection *need_pad = NULL;
e7d1c40c
AM		 7938 struct ppc_link_hash_table *htab;
7939
7940 htab = ppc_hash_table (info);
7941 if (htab == NULL)
7942 return FALSE;
1e2f5b6e 7943
c72f2fb2 7944 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
1e2f5b6e
AM		 7945 {
7946 asection *sec;
7947 Elf_Internal_Rela *relstart, *rel, *relend;
7948 Elf_Internal_Shdr *symtab_hdr;
6cdc0ccc 7949 Elf_Internal_Sym *local_syms;
74f0fb50 7950 struct _opd_sec_data *opd;
51aecdc5 7951 bfd_boolean need_edit, add_aux_fields, broken;
3f764659 7952 bfd_size_type cnt_16b = 0;
1e2f5b6e 7953
854b41e7
AM		 7954 if (!is_ppc64_elf (ibfd))
7955 continue;
7956
1e2f5b6e 7957 sec = bfd_get_section_by_name (ibfd, ".opd");
46de2a7c 7958 if (sec == NULL || sec->size == 0)
1e2f5b6e
AM		 7959 continue;
7960
dbaa2011 7961 if (sec->sec_info_type == SEC_INFO_TYPE_JUST_SYMS)
4b85d634
AM		 7962 continue;
7963
1e2f5b6e
AM		 7964 if (sec->output_section == bfd_abs_section_ptr)
7965 continue;
7966
7967 /* Look through the section relocs. */
7968 if ((sec->flags & SEC_RELOC) == 0 || sec->reloc_count == 0)
7969 continue;
7970
6cdc0ccc 7971 local_syms = NULL;
0ffa91dd 7972 symtab_hdr = &elf_symtab_hdr (ibfd);
1e2f5b6e
AM		 7973
7974 /* Read the relocations. */
4ce794b7 7975 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
45d6a902 7976 info->keep_memory);
1e2f5b6e 7977 if (relstart == NULL)
b34976b6 7978 return FALSE;
1e2f5b6e
AM		 7979
7980 /* First run through the relocs to check they are sane, and to
7981 determine whether we need to edit this opd section. */
b34976b6 7982 need_edit = FALSE;
51aecdc5 7983 broken = FALSE;
3f764659 7984 need_pad = sec;
1e2f5b6e 7985 relend = relstart + sec->reloc_count;
50bc7936 7986 for (rel = relstart; rel < relend; )
1e2f5b6e 7987 {
04c9666a 7988 enum elf_ppc64_reloc_type r_type;
1e2f5b6e
AM		 7989 unsigned long r_symndx;
7990 asection *sym_sec;
7991 struct elf_link_hash_entry *h;
7992 Elf_Internal_Sym *sym;
51aecdc5 7993 bfd_vma offset;
1e2f5b6e 7994
51aecdc5 7995 /* .opd contains an array of 16 or 24 byte entries. We're
1e2f5b6e
AM		 7996 only interested in the reloc pointing to a function entry
7997 point. */
51aecdc5
AM		 7998 offset = rel->r_offset;
7999 if (rel + 1 == relend
8000 || rel[1].r_offset != offset + 8)
1e2f5b6e
AM		 8001 {
8002 /* If someone messes with .opd alignment then after a
8003 "ld -r" we might have padding in the middle of .opd.
8004 Also, there's nothing to prevent someone putting
8005 something silly in .opd with the assembler. No .opd
b34976b6 8006 optimization for them! */
3f764659 8007 broken_opd:
4eca0228 8008 _bfd_error_handler
d003868e 8009 (_("%B: .opd is not a regular array of opd entries"), ibfd);
51aecdc5 8010 broken = TRUE;
1e2f5b6e
AM		 8011 break;
8012 }
8013
50bc7936
AM		 8014 if ((r_type = ELF64_R_TYPE (rel->r_info)) != R_PPC64_ADDR64
8015 || (r_type = ELF64_R_TYPE ((rel + 1)->r_info)) != R_PPC64_TOC)
8016 {
4eca0228 8017 _bfd_error_handler
695344c0 8018 /* xgettext:c-format */
d003868e
AM		 8019 (_("%B: unexpected reloc type %u in .opd section"),
8020 ibfd, r_type);
51aecdc5 8021 broken = TRUE;
50bc7936
AM		 8022 break;
8023 }
8024
1e2f5b6e 8025 r_symndx = ELF64_R_SYM (rel->r_info);
411e1bfb
AM		 8026 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8027 r_symndx, ibfd))
50bc7936 8028 goto error_ret;
1e2f5b6e
AM		 8029
8030 if (sym_sec == NULL || sym_sec->owner == NULL)
8031 {
411e1bfb
AM		 8032 const char *sym_name;
8033 if (h != NULL)
8034 sym_name = h->root.root.string;
8035 else
26c61ae5
L		 8036 sym_name = bfd_elf_sym_name (ibfd, symtab_hdr, sym,
8037 sym_sec);
411e1bfb 8038
4eca0228 8039 _bfd_error_handler
695344c0 8040 /* xgettext:c-format */
d003868e
AM		 8041 (_("%B: undefined sym `%s' in .opd section"),
8042 ibfd, sym_name);
51aecdc5 8043 broken = TRUE;
1e2f5b6e
AM		 8044 break;
8045 }
8046
51020317
AM		 8047 /* opd entries are always for functions defined in the
8048 current input bfd. If the symbol isn't defined in the
8049 input bfd, then we won't be using the function in this
8050 bfd; It must be defined in a linkonce section in another
8051 bfd, or is weak. It's also possible that we are
8052 discarding the function due to a linker script /DISCARD/,
8053 which we test for via the output_section. */
8054 if (sym_sec->owner != ibfd
8055 || sym_sec->output_section == bfd_abs_section_ptr)
b34976b6 8056 need_edit = TRUE;
1e2f5b6e 8057
50bc7936 8058 rel += 2;
51aecdc5
AM		 8059 if (rel + 1 == relend
8060 || (rel + 2 < relend
8061 && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_TOC))
8062 ++rel;
8063
8064 if (rel == relend)
3f764659
JJ		 8065 {
8066 if (sec->size == offset + 24)
8067 {
8068 need_pad = NULL;
8069 break;
8070 }
51aecdc5 8071 if (sec->size == offset + 16)
3f764659
JJ		 8072 {
8073 cnt_16b++;
8074 break;
8075 }
8076 goto broken_opd;
8077 }
3f764659
JJ		 8078 else if (rel + 1 < relend
8079 && ELF64_R_TYPE (rel[0].r_info) == R_PPC64_ADDR64
8080 && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOC)
8081 {
51aecdc5
AM		 8082 if (rel[0].r_offset == offset + 16)
8083 cnt_16b++;
8084 else if (rel[0].r_offset != offset + 24)
8085 goto broken_opd;
3f764659
JJ		 8086 }
8087 else
8088 goto broken_opd;
1e2f5b6e
AM		 8089 }
8090
e7d1c40c 8091 add_aux_fields = htab->params->non_overlapping_opd && cnt_16b > 0;
3f764659 8092
51aecdc5 8093 if (!broken && (need_edit || add_aux_fields))
1e2f5b6e
AM		 8094 {
8095 Elf_Internal_Rela *write_rel;
d4730f92 8096 Elf_Internal_Shdr *rel_hdr;
1e2f5b6e 8097 bfd_byte *rptr, *wptr;
983bddc8 8098 bfd_byte *new_contents;
74f0fb50
AM		 8099 bfd_size_type amt;
8100
983bddc8 8101 new_contents = NULL;
51aecdc5 8102 amt = OPD_NDX (sec->size) * sizeof (long);
74f0fb50 8103 opd = &ppc64_elf_section_data (sec)->u.opd;
33c0ec9d 8104 opd->adjust = bfd_zalloc (sec->owner, amt);
74f0fb50
AM		 8105 if (opd->adjust == NULL)
8106 return FALSE;
8107 ppc64_elf_section_data (sec)->sec_type = sec_opd;
1e2f5b6e
AM		 8108
8109 /* This seems a waste of time as input .opd sections are all
8110 zeros as generated by gcc, but I suppose there's no reason
8111 this will always be so. We might start putting something in
8112 the third word of .opd entries. */
8113 if ((sec->flags & SEC_IN_MEMORY) == 0)
8114 {
eea6121a
AM		 8115 bfd_byte *loc;
8116 if (!bfd_malloc_and_get_section (ibfd, sec, &loc))
6cdc0ccc 8117 {
eea6121a
AM		 8118 if (loc != NULL)
8119 free (loc);
50bc7936 8120 error_ret:
6cdc0ccc
AM		 8121 if (local_syms != NULL
8122 && symtab_hdr->contents != (unsigned char *) local_syms)
8123 free (local_syms);
6cdc0ccc
AM		 8124 if (elf_section_data (sec)->relocs != relstart)
8125 free (relstart);
b34976b6 8126 return FALSE;
6cdc0ccc 8127 }
1e2f5b6e
AM		 8128 sec->contents = loc;
8129 sec->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
8130 }
8131
8132 elf_section_data (sec)->relocs = relstart;
8133
3f764659 8134 new_contents = sec->contents;
3f764659
JJ		 8135 if (add_aux_fields)
8136 {
8137 new_contents = bfd_malloc (sec->size + cnt_16b * 8);
8138 if (new_contents == NULL)
8139 return FALSE;
51aecdc5 8140 need_pad = NULL;
3f764659 8141 }
b4f4e59f
AM		 8142 wptr = new_contents;
8143 rptr = sec->contents;
1e2f5b6e 8144 write_rel = relstart;
51aecdc5 8145 for (rel = relstart; rel < relend; )
1e2f5b6e 8146 {
50bc7936
AM		 8147 unsigned long r_symndx;
8148 asection *sym_sec;
8149 struct elf_link_hash_entry *h;
51aecdc5 8150 struct ppc_link_hash_entry *fdh = NULL;
50bc7936 8151 Elf_Internal_Sym *sym;
51aecdc5
AM		 8152 long opd_ent_size;
8153 Elf_Internal_Rela *next_rel;
8154 bfd_boolean skip;
50bc7936
AM		 8155
8156 r_symndx = ELF64_R_SYM (rel->r_info);
8157 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
d37c89e5 8158 r_symndx, ibfd))
50bc7936
AM		 8159 goto error_ret;
8160
51aecdc5
AM		 8161 next_rel = rel + 2;
8162 if (next_rel + 1 == relend
8163 || (next_rel + 2 < relend
8164 && ELF64_R_TYPE (next_rel[2].r_info) == R_PPC64_TOC))
8165 ++next_rel;
8166
8167 /* See if the .opd entry is full 24 byte or
8168 16 byte (with fd_aux entry overlapped with next
8169 fd_func). */
8170 opd_ent_size = 24;
8171 if (next_rel == relend)
1e2f5b6e 8172 {
51aecdc5 8173 if (sec->size == rel->r_offset + 16)
3f764659 8174 opd_ent_size = 16;
51aecdc5
AM		 8175 }
8176 else if (next_rel->r_offset == rel->r_offset + 16)
8177 opd_ent_size = 16;
3f764659 8178
51aecdc5
AM		 8179 if (h != NULL
8180 && h->root.root.string[0] == '.')
8181 {
8c5b4e52
AM		 8182 fdh = ((struct ppc_link_hash_entry *) h)->oh;
8183 if (fdh != NULL)
8184 {
8185 fdh = ppc_follow_link (fdh);
8186 if (fdh->elf.root.type != bfd_link_hash_defined
8187 && fdh->elf.root.type != bfd_link_hash_defweak)
8188 fdh = NULL;
8189 }
51aecdc5 8190 }
1e2f5b6e 8191
51aecdc5
AM		 8192 skip = (sym_sec->owner != ibfd
8193 || sym_sec->output_section == bfd_abs_section_ptr);
8194 if (skip)
8195 {
8196 if (fdh != NULL && sym_sec->owner == ibfd)
a4aa0fb7 8197 {
51aecdc5
AM		 8198 /* Arrange for the function descriptor sym
8199 to be dropped. */
8200 fdh->elf.root.u.def.value = 0;
8201 fdh->elf.root.u.def.section = sym_sec;
a4aa0fb7 8202 }
51aecdc5 8203 opd->adjust[OPD_NDX (rel->r_offset)] = -1;
1e2f5b6e 8204
0e1862bb 8205 if (NO_OPD_RELOCS || bfd_link_relocatable (info))
51aecdc5
AM		 8206 rel = next_rel;
8207 else
8208 while (1)
8209 {
8210 if (!dec_dynrel_count (rel->r_info, sec, info,
8211 NULL, h, sym))
8212 goto error_ret;
754021d0 8213
51aecdc5
AM		 8214 if (++rel == next_rel)
8215 break;
1e2f5b6e 8216
51aecdc5
AM		 8217 r_symndx = ELF64_R_SYM (rel->r_info);
8218 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8219 r_symndx, ibfd))
8220 goto error_ret;
8221 }
50bc7936
AM		 8222 }
8223 else
1e2f5b6e 8224 {
51aecdc5
AM		 8225 /* We'll be keeping this opd entry. */
8226 long adjust;
8227
8228 if (fdh != NULL)
8229 {
8230 /* Redefine the function descriptor symbol to
8231 this location in the opd section. It is
8232 necessary to update the value here rather
8233 than using an array of adjustments as we do
8234 for local symbols, because various places
8235 in the generic ELF code use the value
8236 stored in u.def.value. */
8237 fdh->elf.root.u.def.value = wptr - new_contents;
8238 fdh->adjust_done = 1;
8239 }
8240
8241 /* Local syms are a bit tricky. We could
8242 tweak them as they can be cached, but
8243 we'd need to look through the local syms
8244 for the function descriptor sym which we
8245 don't have at the moment. So keep an
8246 array of adjustments. */
8247 adjust = (wptr - new_contents) - (rptr - sec->contents);
8248 opd->adjust[OPD_NDX (rel->r_offset)] = adjust;
8249
8250 if (wptr != rptr)
8251 memcpy (wptr, rptr, opd_ent_size);
8252 wptr += opd_ent_size;
8253 if (add_aux_fields && opd_ent_size == 16)
8254 {
8255 memset (wptr, '\0', 8);
8256 wptr += 8;
8257 }
8258
50bc7936 8259 /* We need to adjust any reloc offsets to point to the
51aecdc5
AM		 8260 new opd entries. */
8261 for ( ; rel != next_rel; ++rel)
8262 {
8263 rel->r_offset += adjust;
8264 if (write_rel != rel)
8265 memcpy (write_rel, rel, sizeof (*rel));
8266 ++write_rel;
8267 }
1e2f5b6e 8268 }
51aecdc5
AM		 8269
8270 rptr += opd_ent_size;
1e2f5b6e
AM		 8271 }
8272
3f764659 8273 sec->size = wptr - new_contents;
1e2f5b6e 8274 sec->reloc_count = write_rel - relstart;
3f764659
JJ		 8275 if (add_aux_fields)
8276 {
8277 free (sec->contents);
8278 sec->contents = new_contents;
8279 }
8280
05bf9422 8281 /* Fudge the header size too, as this is used later in
cdcf6e38 8282 elf_bfd_final_link if we are emitting relocs. */
d4730f92
BS		 8283 rel_hdr = _bfd_elf_single_rel_hdr (sec);
8284 rel_hdr->sh_size = sec->reloc_count * rel_hdr->sh_entsize;
754021d0 8285 some_edited = TRUE;
1e2f5b6e 8286 }
6cdc0ccc 8287 else if (elf_section_data (sec)->relocs != relstart)
1e2f5b6e 8288 free (relstart);
6cdc0ccc 8289
411e1bfb
AM		 8290 if (local_syms != NULL
8291 && symtab_hdr->contents != (unsigned char *) local_syms)
8292 {
8293 if (!info->keep_memory)
8294 free (local_syms);
8295 else
8296 symtab_hdr->contents = (unsigned char *) local_syms;
8297 }
8298 }
8299
754021d0
AM		 8300 if (some_edited)
8301 elf_link_hash_traverse (elf_hash_table (info), adjust_opd_syms, NULL);
8302
3f764659
JJ		 8303 /* If we are doing a final link and the last .opd entry is just 16 byte
8304 long, add a 8 byte padding after it. */
0e1862bb 8305 if (need_pad != NULL && !bfd_link_relocatable (info))
3f764659
JJ		 8306 {
8307 bfd_byte *p;
8308
8309 if ((need_pad->flags & SEC_IN_MEMORY) == 0)
8310 {
8311 BFD_ASSERT (need_pad->size > 0);
8312
8313 p = bfd_malloc (need_pad->size + 8);
8314 if (p == NULL)
8315 return FALSE;
699733f6 8316
3f764659
JJ		 8317 if (! bfd_get_section_contents (need_pad->owner, need_pad,
8318 p, 0, need_pad->size))
8319 return FALSE;
8320
8321 need_pad->contents = p;
8322 need_pad->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
8323 }
8324 else
8325 {
8326 p = bfd_realloc (need_pad->contents, need_pad->size + 8);
8327 if (p == NULL)
8328 return FALSE;
8329
8330 need_pad->contents = p;
8331 }
8332
8333 memset (need_pad->contents + need_pad->size, 0, 8);
8334 need_pad->size += 8;
8335 }
8336
411e1bfb
AM		 8337 return TRUE;
8338}
8339
e1918d23 8340/* Set htab->tls_get_addr and call the generic ELF tls_setup function. */
411e1bfb 8341
e1918d23 8342asection *
e7d1c40c 8343ppc64_elf_tls_setup (struct bfd_link_info *info)
411e1bfb 8344{
411e1bfb
AM		 8345 struct ppc_link_hash_table *htab;
8346
411e1bfb 8347 htab = ppc_hash_table (info);
4dfe6ac6
NC		 8348 if (htab == NULL)
8349 return NULL;
8350
ee67d69a
AM		 8351 if (abiversion (info->output_bfd) == 1)
8352 htab->opd_abi = 1;
8353
e7d1c40c 8354 if (htab->params->no_multi_toc)
33c0ec9d
AM		 8355 htab->do_multi_toc = 0;
8356 else if (!htab->do_multi_toc)
e7d1c40c 8357 htab->params->no_multi_toc = 1;
33c0ec9d 8358
8b5f1ed8
AM		 8359 /* Default to --no-plt-localentry, as this option can cause problems
8360 with symbol interposition. For example, glibc libpthread.so and
8361 libc.so duplicate many pthread symbols, with a fallback
8362 implementation in libc.so. In some cases the fallback does more
8363 work than the pthread implementation. __pthread_condattr_destroy
8364 is one such symbol: the libpthread.so implementation is
8365 localentry:0 while the libc.so implementation is localentry:8.
8366 An app that "cleverly" uses dlopen to only load necessary
8367 libraries at runtime may omit loading libpthread.so when not
8368 running multi-threaded, which then results in the libc.so
8369 fallback symbols being used and ld.so complaining. Now there
8370 are workarounds in ld (see non_zero_localentry) to detect the
8371 pthread situation, but that may not be the only case where
8372 --plt-localentry can cause trouble. */
f378ab09 8373 if (htab->params->plt_localentry0 < 0)
8b5f1ed8 8374 htab->params->plt_localentry0 = 0;
d44c746a
AM		 8375 if (htab->params->plt_localentry0
8376 && elf_link_hash_lookup (&htab->elf, "GLIBC_2.26",
8377 FALSE, FALSE, FALSE) == NULL)
8378 info->callbacks->einfo
8379 (_("%P: warning: --plt-localentry is especially dangerous without "
8380 "ld.so support to detect ABI violations.\n"));
f378ab09 8381
3a71aa26
AM		 8382 htab->tls_get_addr = ((struct ppc_link_hash_entry *)
8383 elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
8384 FALSE, FALSE, TRUE));
a7f2871e
AM		 8385 /* Move dynamic linking info to the function descriptor sym. */
8386 if (htab->tls_get_addr != NULL)
8387 func_desc_adjust (&htab->tls_get_addr->elf, info);
3a71aa26
AM		 8388 htab->tls_get_addr_fd = ((struct ppc_link_hash_entry *)
8389 elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
8390 FALSE, FALSE, TRUE));
7c9cf415 8391 if (htab->params->tls_get_addr_opt)
a7f2871e
AM		 8392 {
8393 struct elf_link_hash_entry *opt, *opt_fd, *tga, *tga_fd;
8394
8395 opt = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr_opt",
8396 FALSE, FALSE, TRUE);
8397 if (opt != NULL)
8398 func_desc_adjust (opt, info);
8399 opt_fd = elf_link_hash_lookup (&htab->elf, "__tls_get_addr_opt",
8400 FALSE, FALSE, TRUE);
8401 if (opt_fd != NULL
8402 && (opt_fd->root.type == bfd_link_hash_defined
8403 || opt_fd->root.type == bfd_link_hash_defweak))
8404 {
8405 /* If glibc supports an optimized __tls_get_addr call stub,
8406 signalled by the presence of __tls_get_addr_opt, and we'll
8407 be calling __tls_get_addr via a plt call stub, then
8408 make __tls_get_addr point to __tls_get_addr_opt. */
8409 tga_fd = &htab->tls_get_addr_fd->elf;
8410 if (htab->elf.dynamic_sections_created
8411 && tga_fd != NULL
8412 && (tga_fd->type == STT_FUNC
8413 || tga_fd->needs_plt)
8414 && !(SYMBOL_CALLS_LOCAL (info, tga_fd)
21d68fcd 8415 || UNDEFWEAK_NO_DYNAMIC_RELOC (info, tga_fd)))
a7f2871e
AM		 8416 {
8417 struct plt_entry *ent;
8418
8419 for (ent = tga_fd->plt.plist; ent != NULL; ent = ent->next)
8420 if (ent->plt.refcount > 0)
8421 break;
8422 if (ent != NULL)
8423 {
8424 tga_fd->root.type = bfd_link_hash_indirect;
8425 tga_fd->root.u.i.link = &opt_fd->root;
8426 ppc64_elf_copy_indirect_symbol (info, opt_fd, tga_fd);
b531344c 8427 opt_fd->mark = 1;
a7f2871e
AM		 8428 if (opt_fd->dynindx != -1)
8429 {
8430 /* Use __tls_get_addr_opt in dynamic relocations. */
8431 opt_fd->dynindx = -1;
8432 _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
8433 opt_fd->dynstr_index);
8434 if (!bfd_elf_link_record_dynamic_symbol (info, opt_fd))
854b41e7 8435 return NULL;
a7f2871e
AM		 8436 }
8437 htab->tls_get_addr_fd = (struct ppc_link_hash_entry *) opt_fd;
8438 tga = &htab->tls_get_addr->elf;
8439 if (opt != NULL && tga != NULL)
8440 {
8441 tga->root.type = bfd_link_hash_indirect;
8442 tga->root.u.i.link = &opt->root;
8443 ppc64_elf_copy_indirect_symbol (info, opt, tga);
b531344c 8444 opt->mark = 1;
a7f2871e
AM		 8445 _bfd_elf_link_hash_hide_symbol (info, opt,
8446 tga->forced_local);
8447 htab->tls_get_addr = (struct ppc_link_hash_entry *) opt;
8448 }
8449 htab->tls_get_addr_fd->oh = htab->tls_get_addr;
8450 htab->tls_get_addr_fd->is_func_descriptor = 1;
8451 if (htab->tls_get_addr != NULL)
8452 {
8453 htab->tls_get_addr->oh = htab->tls_get_addr_fd;
8454 htab->tls_get_addr->is_func = 1;
8455 }
8456 }
8457 }
8458 }
7c9cf415
AM		 8459 else if (htab->params->tls_get_addr_opt < 0)
8460 htab->params->tls_get_addr_opt = 0;
a7f2871e 8461 }
33c0ec9d 8462 return _bfd_elf_tls_setup (info->output_bfd, info);
3a71aa26 8463}
8387904d 8464
3a71aa26
AM		 8465/* Return TRUE iff REL is a branch reloc with a global symbol matching
8466 HASH1 or HASH2. */
8387904d 8467
3a71aa26
AM		 8468static bfd_boolean
8469branch_reloc_hash_match (const bfd *ibfd,
8470 const Elf_Internal_Rela *rel,
8471 const struct ppc_link_hash_entry *hash1,
8472 const struct ppc_link_hash_entry *hash2)
8473{
8474 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
8475 enum elf_ppc64_reloc_type r_type = ELF64_R_TYPE (rel->r_info);
8476 unsigned int r_symndx = ELF64_R_SYM (rel->r_info);
8477
e054468f 8478 if (r_symndx >= symtab_hdr->sh_info && is_branch_reloc (r_type))
8387904d 8479 {
3a71aa26
AM		 8480 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
8481 struct elf_link_hash_entry *h;
8387904d 8482
3a71aa26 8483 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
b31867b6 8484 h = elf_follow_link (h);
3a71aa26
AM		 8485 if (h == &hash1->elf || h == &hash2->elf)
8486 return TRUE;
a48ebf4d 8487 }
3a71aa26 8488 return FALSE;
951fd09b 8489}
411e1bfb 8490
951fd09b
AM		 8491/* Run through all the TLS relocs looking for optimization
8492 opportunities. The linker has been hacked (see ppc64elf.em) to do
8493 a preliminary section layout so that we know the TLS segment
8494 offsets. We can't optimize earlier because some optimizations need
8495 to know the tp offset, and we need to optimize before allocating
8496 dynamic relocations. */
8497
8498bfd_boolean
33c0ec9d 8499ppc64_elf_tls_optimize (struct bfd_link_info *info)
951fd09b
AM		 8500{
8501 bfd *ibfd;
8502 asection *sec;
8503 struct ppc_link_hash_table *htab;
663a1470 8504 unsigned char *toc_ref;
102890f0 8505 int pass;
951fd09b 8506
3cbc1e5e 8507 if (!bfd_link_executable (info))
411e1bfb
AM		 8508 return TRUE;
8509
951fd09b 8510 htab = ppc_hash_table (info);
4dfe6ac6
NC		 8511 if (htab == NULL)
8512 return FALSE;
8513
663a1470
AM		 8514 /* Make two passes over the relocs. On the first pass, mark toc
8515 entries involved with tls relocs, and check that tls relocs
8516 involved in setting up a tls_get_addr call are indeed followed by
8517 such a call. If they are not, we can't do any tls optimization.
8518 On the second pass twiddle tls_mask flags to notify
8519 relocate_section that optimization can be done, and adjust got
8520 and plt refcounts. */
8521 toc_ref = NULL;
8522 for (pass = 0; pass < 2; ++pass)
c72f2fb2 8523 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
663a1470
AM		 8524 {
8525 Elf_Internal_Sym *locsyms = NULL;
8526 asection *toc = bfd_get_section_by_name (ibfd, ".toc");
8527
102890f0
AM		 8528 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8529 if (sec->has_tls_reloc && !bfd_is_abs_section (sec->output_section))
8530 {
8531 Elf_Internal_Rela *relstart, *rel, *relend;
663a1470 8532 bfd_boolean found_tls_get_addr_arg = 0;
411e1bfb 8533
102890f0
AM		 8534 /* Read the relocations. */
8535 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8536 info->keep_memory);
8537 if (relstart == NULL)
2915c55b
JK		 8538 {
8539 free (toc_ref);
8540 return FALSE;
8541 }
411e1bfb 8542
102890f0
AM		 8543 relend = relstart + sec->reloc_count;
8544 for (rel = relstart; rel < relend; rel++)
8545 {
8546 enum elf_ppc64_reloc_type r_type;
8547 unsigned long r_symndx;
8548 struct elf_link_hash_entry *h;
8549 Elf_Internal_Sym *sym;
8550 asection *sym_sec;
f961d9dd
AM		 8551 unsigned char *tls_mask;
8552 unsigned char tls_set, tls_clear, tls_type = 0;
102890f0
AM		 8553 bfd_vma value;
8554 bfd_boolean ok_tprel, is_local;
8555 long toc_ref_index = 0;
8556 int expecting_tls_get_addr = 0;
663a1470 8557 bfd_boolean ret = FALSE;
411e1bfb 8558
102890f0
AM		 8559 r_symndx = ELF64_R_SYM (rel->r_info);
8560 if (!get_sym_h (&h, &sym, &sym_sec, &tls_mask, &locsyms,
8561 r_symndx, ibfd))
8562 {
8563 err_free_rel:
8564 if (elf_section_data (sec)->relocs != relstart)
8565 free (relstart);
8566 if (toc_ref != NULL)
8567 free (toc_ref);
8568 if (locsyms != NULL
0ffa91dd 8569 && (elf_symtab_hdr (ibfd).contents
102890f0
AM		 8570 != (unsigned char *) locsyms))
8571 free (locsyms);
663a1470 8572 return ret;
102890f0 8573 }
411e1bfb 8574
102890f0
AM		 8575 if (h != NULL)
8576 {
766bc656
AM		 8577 if (h->root.type == bfd_link_hash_defined
8578 || h->root.type == bfd_link_hash_defweak)
8579 value = h->root.u.def.value;
8580 else if (h->root.type == bfd_link_hash_undefweak)
8581 value = 0;
8582 else
663a1470
AM		 8583 {
8584 found_tls_get_addr_arg = 0;
8585 continue;
8586 }
102890f0
AM		 8587 }
8588 else
8589 /* Symbols referenced by TLS relocs must be of type
8590 STT_TLS. So no need for .opd local sym adjust. */
8591 value = sym->st_value;
8592
8593 ok_tprel = FALSE;
8594 is_local = FALSE;
8595 if (h == NULL
8596 || !h->def_dynamic)
8597 {
8598 is_local = TRUE;
766bc656
AM		 8599 if (h != NULL
8600 && h->root.type == bfd_link_hash_undefweak)
8601 ok_tprel = TRUE;
c27b8c2a
AM		 8602 else if (sym_sec != NULL
8603 && sym_sec->output_section != NULL)
766bc656
AM		 8604 {
8605 value += sym_sec->output_offset;
8606 value += sym_sec->output_section->vma;
8607 value -= htab->elf.tls_sec->vma;
8608 ok_tprel = (value + TP_OFFSET + ((bfd_vma) 1 << 31)
8609 < (bfd_vma) 1 << 32);
8610 }
102890f0 8611 }
951fd09b 8612
102890f0 8613 r_type = ELF64_R_TYPE (rel->r_info);
663a1470
AM		 8614 /* If this section has old-style __tls_get_addr calls
8615 without marker relocs, then check that each
8616 __tls_get_addr call reloc is preceded by a reloc
8617 that conceivably belongs to the __tls_get_addr arg
8618 setup insn. If we don't find matching arg setup
8619 relocs, don't do any tls optimization. */
8620 if (pass == 0
8621 && sec->has_tls_get_addr_call
8622 && h != NULL
8623 && (h == &htab->tls_get_addr->elf
8624 || h == &htab->tls_get_addr_fd->elf)
8625 && !found_tls_get_addr_arg
8626 && is_branch_reloc (r_type))
8627 {
25f53a85 8628 info->callbacks->minfo (_("%H __tls_get_addr lost arg, "
663a1470
AM		 8629 "TLS optimization disabled\n"),
8630 ibfd, sec, rel->r_offset);
8631 ret = TRUE;
8632 goto err_free_rel;
8633 }
8634
8635 found_tls_get_addr_arg = 0;
102890f0
AM		 8636 switch (r_type)
8637 {
8638 case R_PPC64_GOT_TLSLD16:
8639 case R_PPC64_GOT_TLSLD16_LO:
8640 expecting_tls_get_addr = 1;
663a1470 8641 found_tls_get_addr_arg = 1;
1a0670f3 8642 /* Fall through. */
102890f0
AM		 8643
8644 case R_PPC64_GOT_TLSLD16_HI:
8645 case R_PPC64_GOT_TLSLD16_HA:
8646 /* These relocs should never be against a symbol
8647 defined in a shared lib. Leave them alone if
8648 that turns out to be the case. */
8649 if (!is_local)
8650 continue;
411e1bfb 8651
102890f0 8652 /* LD -> LE */
411e1bfb 8653 tls_set = 0;
102890f0
AM		 8654 tls_clear = TLS_LD;
8655 tls_type = TLS_TLS | TLS_LD;
8656 break;
411e1bfb 8657
102890f0
AM		 8658 case R_PPC64_GOT_TLSGD16:
8659 case R_PPC64_GOT_TLSGD16_LO:
8660 expecting_tls_get_addr = 1;
663a1470 8661 found_tls_get_addr_arg = 1;
1a0670f3 8662 /* Fall through. */
102890f0
AM		 8663
8664 case R_PPC64_GOT_TLSGD16_HI:
8665 case R_PPC64_GOT_TLSGD16_HA:
8666 if (ok_tprel)
8667 /* GD -> LE */
411e1bfb 8668 tls_set = 0;
102890f0
AM		 8669 else
8670 /* GD -> IE */
8671 tls_set = TLS_TLS | TLS_TPRELGD;
8672 tls_clear = TLS_GD;
8673 tls_type = TLS_TLS | TLS_GD;
8674 break;
8675
8676 case R_PPC64_GOT_TPREL16_DS:
8677 case R_PPC64_GOT_TPREL16_LO_DS:
8678 case R_PPC64_GOT_TPREL16_HI:
8679 case R_PPC64_GOT_TPREL16_HA:
8680 if (ok_tprel)
8681 {
8682 /* IE -> LE */
8683 tls_set = 0;
8684 tls_clear = TLS_TPREL;
8685 tls_type = TLS_TLS | TLS_TPREL;
8686 break;
8687 }
411e1bfb
AM		 8688 continue;
8689
727fc41e
AM		 8690 case R_PPC64_TLSGD:
8691 case R_PPC64_TLSLD:
663a1470 8692 found_tls_get_addr_arg = 1;
1a0670f3 8693 /* Fall through. */
663a1470
AM		 8694
8695 case R_PPC64_TLS:
8696 case R_PPC64_TOC16:
8697 case R_PPC64_TOC16_LO:
102890f0
AM		 8698 if (sym_sec == NULL || sym_sec != toc)
8699 continue;
8700
8701 /* Mark this toc entry as referenced by a TLS
8702 code sequence. We can do that now in the
8703 case of R_PPC64_TLS, and after checking for
8704 tls_get_addr for the TOC16 relocs. */
8705 if (toc_ref == NULL)
663a1470
AM		 8706 toc_ref = bfd_zmalloc (toc->output_section->rawsize / 8);
8707 if (toc_ref == NULL)
8708 goto err_free_rel;
8709
102890f0
AM		 8710 if (h != NULL)
8711 value = h->root.u.def.value;
8712 else
8713 value = sym->st_value;
8714 value += rel->r_addend;
73242275
AM		 8715 if (value % 8 != 0)
8716 continue;
8717 BFD_ASSERT (value < toc->size
8718 && toc->output_offset % 8 == 0);
663a1470 8719 toc_ref_index = (value + toc->output_offset) / 8;
727fc41e
AM		 8720 if (r_type == R_PPC64_TLS
8721 || r_type == R_PPC64_TLSGD
8722 || r_type == R_PPC64_TLSLD)
102890f0
AM		 8723 {
8724 toc_ref[toc_ref_index] = 1;
8725 continue;
8726 }
8727
8728 if (pass != 0 && toc_ref[toc_ref_index] == 0)
8729 continue;
8730
8731 tls_set = 0;
8732 tls_clear = 0;
8733 expecting_tls_get_addr = 2;
8734 break;
8735
8736 case R_PPC64_TPREL64:
8737 if (pass == 0
8738 || sec != toc
8739 || toc_ref == NULL
663a1470 8740 || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
102890f0
AM		 8741 continue;
8742 if (ok_tprel)
8743 {
8744 /* IE -> LE */
8745 tls_set = TLS_EXPLICIT;
8746 tls_clear = TLS_TPREL;
8747 break;
8748 }
8749 continue;
8750
8751 case R_PPC64_DTPMOD64:
8752 if (pass == 0
8753 || sec != toc
8754 || toc_ref == NULL
663a1470 8755 || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
102890f0
AM		 8756 continue;
8757 if (rel + 1 < relend
8758 && (rel[1].r_info
8759 == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64))
8760 && rel[1].r_offset == rel->r_offset + 8)
8761 {
8762 if (ok_tprel)
8763 /* GD -> LE */
8764 tls_set = TLS_EXPLICIT | TLS_GD;
8765 else
8766 /* GD -> IE */
8767 tls_set = TLS_EXPLICIT | TLS_GD | TLS_TPRELGD;
8768 tls_clear = TLS_GD;
8769 }
8770 else
8771 {
8772 if (!is_local)
8773 continue;
8774
8775 /* LD -> LE */
8776 tls_set = TLS_EXPLICIT;
8777 tls_clear = TLS_LD;
8778 }
8779 break;
8780
8781 default:
8782 continue;
8783 }
8784
8785 if (pass == 0)
8786 {
727fc41e
AM		 8787 if (!expecting_tls_get_addr
8788 || !sec->has_tls_get_addr_call)
102890f0
AM		 8789 continue;
8790
3a71aa26
AM		 8791 if (rel + 1 < relend
8792 && branch_reloc_hash_match (ibfd, rel + 1,
8793 htab->tls_get_addr,
8794 htab->tls_get_addr_fd))
102890f0 8795 {
3a71aa26 8796 if (expecting_tls_get_addr == 2)
102890f0 8797 {
3a71aa26 8798 /* Check for toc tls entries. */
f961d9dd 8799 unsigned char *toc_tls;
3a71aa26
AM		 8800 int retval;
8801
8802 retval = get_tls_mask (&toc_tls, NULL, NULL,
8803 &locsyms,
8804 rel, ibfd);
8805 if (retval == 0)
8806 goto err_free_rel;
663a1470
AM		 8807 if (toc_tls != NULL)
8808 {
8809 if ((*toc_tls & (TLS_GD | TLS_LD)) != 0)
8810 found_tls_get_addr_arg = 1;
8811 if (retval > 1)
8812 toc_ref[toc_ref_index] = 1;
8813 }
102890f0 8814 }
3a71aa26 8815 continue;
102890f0
AM		 8816 }
8817
8818 if (expecting_tls_get_addr != 1)
8819 continue;
8820
8821 /* Uh oh, we didn't find the expected call. We
8822 could just mark this symbol to exclude it
8823 from tls optimization but it's safer to skip
663a1470 8824 the entire optimization. */
695344c0 8825 /* xgettext:c-format */
25f53a85 8826 info->callbacks->minfo (_("%H arg lost __tls_get_addr, "
663a1470
AM		 8827 "TLS optimization disabled\n"),
8828 ibfd, sec, rel->r_offset);
8829 ret = TRUE;
8830 goto err_free_rel;
102890f0
AM		 8831 }
8832
85f7a9cb 8833 if (expecting_tls_get_addr && htab->tls_get_addr != NULL)
102890f0
AM		 8834 {
8835 struct plt_entry *ent;
8836 for (ent = htab->tls_get_addr->elf.plt.plist;
8837 ent != NULL;
8838 ent = ent->next)
8839 if (ent->addend == 0)
411e1bfb 8840 {
102890f0 8841 if (ent->plt.refcount > 0)
30038c59 8842 {
102890f0
AM		 8843 ent->plt.refcount -= 1;
8844 expecting_tls_get_addr = 0;
30038c59 8845 }
102890f0 8846 break;
411e1bfb 8847 }
102890f0 8848 }
411e1bfb 8849
85f7a9cb 8850 if (expecting_tls_get_addr && htab->tls_get_addr_fd != NULL)
102890f0
AM		 8851 {
8852 struct plt_entry *ent;
8853 for (ent = htab->tls_get_addr_fd->elf.plt.plist;
8854 ent != NULL;
8855 ent = ent->next)
8856 if (ent->addend == 0)
411e1bfb 8857 {
102890f0
AM		 8858 if (ent->plt.refcount > 0)
8859 ent->plt.refcount -= 1;
8860 break;
411e1bfb 8861 }
102890f0 8862 }
411e1bfb 8863
102890f0 8864 if (tls_clear == 0)
30038c59
AM		 8865 continue;
8866
102890f0
AM		 8867 if ((tls_set & TLS_EXPLICIT) == 0)
8868 {
8869 struct got_entry *ent;
411e1bfb 8870
102890f0
AM		 8871 /* Adjust got entry for this reloc. */
8872 if (h != NULL)
8873 ent = h->got.glist;
8874 else
8875 ent = elf_local_got_ents (ibfd)[r_symndx];
411e1bfb 8876
102890f0
AM		 8877 for (; ent != NULL; ent = ent->next)
8878 if (ent->addend == rel->r_addend
8879 && ent->owner == ibfd
8880 && ent->tls_type == tls_type)
8881 break;
8882 if (ent == NULL)
8883 abort ();
411e1bfb 8884
102890f0
AM		 8885 if (tls_set == 0)
8886 {
8887 /* We managed to get rid of a got entry. */
8888 if (ent->got.refcount > 0)
8889 ent->got.refcount -= 1;
8890 }
8891 }
8892 else
8893 {
8894 /* If we got rid of a DTPMOD/DTPREL reloc pair then
8895 we'll lose one or two dyn relocs. */
8896 if (!dec_dynrel_count (rel->r_info, sec, info,
19e08130 8897 NULL, h, sym))
102890f0 8898 return FALSE;
411e1bfb 8899
102890f0
AM		 8900 if (tls_set == (TLS_EXPLICIT | TLS_GD))
8901 {
8902 if (!dec_dynrel_count ((rel + 1)->r_info, sec, info,
19e08130 8903 NULL, h, sym))
102890f0
AM		 8904 return FALSE;
8905 }
8906 }
411e1bfb 8907
102890f0
AM		 8908 *tls_mask |= tls_set;
8909 *tls_mask &= ~tls_clear;
8910 }
8c1d1bb8 8911
102890f0
AM		 8912 if (elf_section_data (sec)->relocs != relstart)
8913 free (relstart);
8914 }
411e1bfb 8915
663a1470
AM		 8916 if (locsyms != NULL
8917 && (elf_symtab_hdr (ibfd).contents != (unsigned char *) locsyms))
8918 {
8919 if (!info->keep_memory)
8920 free (locsyms);
8921 else
8922 elf_symtab_hdr (ibfd).contents = (unsigned char *) locsyms;
8923 }
8924 }
411e1bfb 8925
663a1470
AM		 8926 if (toc_ref != NULL)
8927 free (toc_ref);
b34976b6 8928 return TRUE;
1e2f5b6e 8929}
b34976b6 8930
c5614fa4
AM		 8931/* Called via elf_link_hash_traverse from ppc64_elf_edit_toc to adjust
8932 the values of any global symbols in a toc section that has been
8933 edited. Globals in toc sections should be a rarity, so this function
8934 sets a flag if any are found in toc sections other than the one just
de194d85 8935 edited, so that further hash table traversals can be avoided. */
c5614fa4
AM		 8936
8937struct adjust_toc_info
8938{
8939 asection *toc;
8940 unsigned long *skip;
8941 bfd_boolean global_toc_syms;
8942};
8943
ba761f19
AM		 8944enum toc_skip_enum { ref_from_discarded = 1, can_optimize = 2 };
8945
c5614fa4
AM		 8946static bfd_boolean
8947adjust_toc_syms (struct elf_link_hash_entry *h, void *inf)
8948{
8949 struct ppc_link_hash_entry *eh;
8950 struct adjust_toc_info *toc_inf = (struct adjust_toc_info *) inf;
854b41e7 8951 unsigned long i;
c5614fa4 8952
c5614fa4
AM		 8953 if (h->root.type != bfd_link_hash_defined
8954 && h->root.type != bfd_link_hash_defweak)
8955 return TRUE;
8956
8957 eh = (struct ppc_link_hash_entry *) h;
8958 if (eh->adjust_done)
8959 return TRUE;
8960
8961 if (eh->elf.root.u.def.section == toc_inf->toc)
8962 {
854b41e7
AM		 8963 if (eh->elf.root.u.def.value > toc_inf->toc->rawsize)
8964 i = toc_inf->toc->rawsize >> 3;
c5614fa4 8965 else
854b41e7
AM		 8966 i = eh->elf.root.u.def.value >> 3;
8967
ba761f19 8968 if ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0)
c5614fa4 8969 {
4eca0228 8970 _bfd_error_handler
854b41e7
AM		 8971 (_("%s defined on removed toc entry"), eh->elf.root.root.string);
8972 do
8973 ++i;
ba761f19 8974 while ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0);
854b41e7 8975 eh->elf.root.u.def.value = (bfd_vma) i << 3;
c5614fa4 8976 }
854b41e7
AM		 8977
8978 eh->elf.root.u.def.value -= toc_inf->skip[i];
c5614fa4
AM		 8979 eh->adjust_done = 1;
8980 }
8981 else if (strcmp (eh->elf.root.u.def.section->name, ".toc") == 0)
8982 toc_inf->global_toc_syms = TRUE;
8983
8984 return TRUE;
8985}
8986
39eeab25
AM		 8987/* Return TRUE iff INSN with a relocation of R_TYPE is one we expect
8988 on a _LO variety toc/got reloc. */
560c8763
AM		 8989
8990static bfd_boolean
39eeab25 8991ok_lo_toc_insn (unsigned int insn, enum elf_ppc64_reloc_type r_type)
560c8763 8992{
39eeab25
AM		 8993 return ((insn & (0x3f << 26)) == 12u << 26 /* addic */
8994 || (insn & (0x3f << 26)) == 14u << 26 /* addi */
560c8763
AM		 8995 || (insn & (0x3f << 26)) == 32u << 26 /* lwz */
8996 || (insn & (0x3f << 26)) == 34u << 26 /* lbz */
8997 || (insn & (0x3f << 26)) == 36u << 26 /* stw */
8998 || (insn & (0x3f << 26)) == 38u << 26 /* stb */
8999 || (insn & (0x3f << 26)) == 40u << 26 /* lhz */
9000 || (insn & (0x3f << 26)) == 42u << 26 /* lha */
9001 || (insn & (0x3f << 26)) == 44u << 26 /* sth */
9002 || (insn & (0x3f << 26)) == 46u << 26 /* lmw */
9003 || (insn & (0x3f << 26)) == 47u << 26 /* stmw */
9004 || (insn & (0x3f << 26)) == 48u << 26 /* lfs */
9005 || (insn & (0x3f << 26)) == 50u << 26 /* lfd */
9006 || (insn & (0x3f << 26)) == 52u << 26 /* stfs */
9007 || (insn & (0x3f << 26)) == 54u << 26 /* stfd */
39eeab25
AM		 9008 || (insn & (0x3f << 26)) == 56u << 26 /* lq,lfq */
9009 || ((insn & (0x3f << 26)) == 57u << 26 /* lxsd,lxssp,lfdp */
9010 /* Exclude lfqu by testing reloc. If relocs are ever
9011 defined for the reduced D field in psq_lu then those
9012 will need testing too. */
9013 && r_type != R_PPC64_TOC16_LO && r_type != R_PPC64_GOT16_LO)
9014 || ((insn & (0x3f << 26)) == 58u << 26 /* ld,lwa */
9015 && (insn & 1) == 0)
9016 || (insn & (0x3f << 26)) == 60u << 26 /* stfq */
9017 || ((insn & (0x3f << 26)) == 61u << 26 /* lxv,stx{v,sd,ssp},stfdp */
9018 /* Exclude stfqu. psq_stu as above for psq_lu. */
9019 && r_type != R_PPC64_TOC16_LO && r_type != R_PPC64_GOT16_LO)
9020 || ((insn & (0x3f << 26)) == 62u << 26 /* std,stq */
9021 && (insn & 1) == 0));
560c8763
AM		 9022}
9023
c5614fa4
AM		 9024/* Examine all relocs referencing .toc sections in order to remove
9025 unused .toc entries. */
9026
9027bfd_boolean
33c0ec9d 9028ppc64_elf_edit_toc (struct bfd_link_info *info)
c5614fa4
AM		 9029{
9030 bfd *ibfd;
9031 struct adjust_toc_info toc_inf;
67f0cbdb 9032 struct ppc_link_hash_table *htab = ppc_hash_table (info);
c5614fa4 9033
67f0cbdb 9034 htab->do_toc_opt = 1;
c5614fa4 9035 toc_inf.global_toc_syms = TRUE;
c72f2fb2 9036 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
c5614fa4
AM		 9037 {
9038 asection *toc, *sec;
9039 Elf_Internal_Shdr *symtab_hdr;
9040 Elf_Internal_Sym *local_syms;
425b145b 9041 Elf_Internal_Rela *relstart, *rel, *toc_relocs;
c5614fa4
AM		 9042 unsigned long *skip, *drop;
9043 unsigned char *used;
9044 unsigned char *keep, last, some_unused;
9045
854b41e7
AM		 9046 if (!is_ppc64_elf (ibfd))
9047 continue;
9048
c5614fa4
AM		 9049 toc = bfd_get_section_by_name (ibfd, ".toc");
9050 if (toc == NULL
92b7a70f 9051 || toc->size == 0
dbaa2011
AM		 9052 || toc->sec_info_type == SEC_INFO_TYPE_JUST_SYMS
9053 || discarded_section (toc))
c5614fa4
AM		 9054 continue;
9055
425b145b 9056 toc_relocs = NULL;
c5614fa4 9057 local_syms = NULL;
0ffa91dd 9058 symtab_hdr = &elf_symtab_hdr (ibfd);
c5614fa4
AM		 9059
9060 /* Look at sections dropped from the final link. */
9061 skip = NULL;
9062 relstart = NULL;
9063 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
9064 {
9065 if (sec->reloc_count == 0
dbaa2011 9066 || !discarded_section (sec)
c5614fa4
AM		 9067 || get_opd_info (sec)
9068 || (sec->flags & SEC_ALLOC) == 0
9069 || (sec->flags & SEC_DEBUGGING) != 0)
9070 continue;
9071
9072 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL, FALSE);
9073 if (relstart == NULL)
9074 goto error_ret;
9075
9076 /* Run through the relocs to see which toc entries might be
9077 unused. */
9078 for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9079 {
9080 enum elf_ppc64_reloc_type r_type;
9081 unsigned long r_symndx;
9082 asection *sym_sec;
9083 struct elf_link_hash_entry *h;
9084 Elf_Internal_Sym *sym;
9085 bfd_vma val;
9086
9087 r_type = ELF64_R_TYPE (rel->r_info);
9088 switch (r_type)
9089 {
9090 default:
9091 continue;
9092
9093 case R_PPC64_TOC16:
9094 case R_PPC64_TOC16_LO:
9095 case R_PPC64_TOC16_HI:
9096 case R_PPC64_TOC16_HA:
9097 case R_PPC64_TOC16_DS:
9098 case R_PPC64_TOC16_LO_DS:
9099 break;
9100 }
9101
9102 r_symndx = ELF64_R_SYM (rel->r_info);
9103 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9104 r_symndx, ibfd))
9105 goto error_ret;
9106
9107 if (sym_sec != toc)
9108 continue;
9109
9110 if (h != NULL)
9111 val = h->root.u.def.value;
9112 else
9113 val = sym->st_value;
9114 val += rel->r_addend;
9115
9116 if (val >= toc->size)
9117 continue;
9118
9119 /* Anything in the toc ought to be aligned to 8 bytes.
9120 If not, don't mark as unused. */
9121 if (val & 7)
9122 continue;
9123
9124 if (skip == NULL)
9125 {
854b41e7 9126 skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
c5614fa4
AM		 9127 if (skip == NULL)
9128 goto error_ret;
9129 }
9130
ba761f19 9131 skip[val >> 3] = ref_from_discarded;
c5614fa4
AM		 9132 }
9133
9134 if (elf_section_data (sec)->relocs != relstart)
9135 free (relstart);
9136 }
9137
ba761f19
AM		 9138 /* For largetoc loads of address constants, we can convert
9139 . addis rx,2,addr@got@ha
9140 . ld ry,addr@got@l(rx)
9141 to
9142 . addis rx,2,addr@toc@ha
9143 . addi ry,rx,addr@toc@l
9144 when addr is within 2G of the toc pointer. This then means
9145 that the word storing "addr" in the toc is no longer needed. */
68ffbac6 9146
ba761f19
AM		 9147 if (!ppc64_elf_tdata (ibfd)->has_small_toc_reloc
9148 && toc->output_section->rawsize < (bfd_vma) 1 << 31
9149 && toc->reloc_count != 0)
9150 {
9151 /* Read toc relocs. */
425b145b
AM		 9152 toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
9153 info->keep_memory);
9154 if (toc_relocs == NULL)
ba761f19
AM		 9155 goto error_ret;
9156
425b145b 9157 for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
ba761f19
AM		 9158 {
9159 enum elf_ppc64_reloc_type r_type;
9160 unsigned long r_symndx;
9161 asection *sym_sec;
9162 struct elf_link_hash_entry *h;
9163 Elf_Internal_Sym *sym;
9164 bfd_vma val, addr;
9165
9166 r_type = ELF64_R_TYPE (rel->r_info);
9167 if (r_type != R_PPC64_ADDR64)
9168 continue;
9169
9170 r_symndx = ELF64_R_SYM (rel->r_info);
9171 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9172 r_symndx, ibfd))
9173 goto error_ret;
9174
425b145b 9175 if (sym_sec == NULL
c27b8c2a 9176 || sym_sec->output_section == NULL
dbaa2011 9177 || discarded_section (sym_sec))
425b145b
AM		 9178 continue;
9179
afe397ea 9180 if (!SYMBOL_REFERENCES_LOCAL (info, h))
ba761f19
AM		 9181 continue;
9182
9183 if (h != NULL)
bddc25c9
AM		 9184 {
9185 if (h->type == STT_GNU_IFUNC)
9186 continue;
9187 val = h->root.u.def.value;
9188 }
ba761f19 9189 else
bddc25c9
AM		 9190 {
9191 if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
9192 continue;
9193 val = sym->st_value;
9194 }
ba761f19
AM		 9195 val += rel->r_addend;
9196 val += sym_sec->output_section->vma + sym_sec->output_offset;
9197
9198 /* We don't yet know the exact toc pointer value, but we
9199 know it will be somewhere in the toc section. Don't
9200 optimize if the difference from any possible toc
9201 pointer is outside [ff..f80008000, 7fff7fff]. */
9202 addr = toc->output_section->vma + TOC_BASE_OFF;
9203 if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
9204 continue;
9205
9206 addr = toc->output_section->vma + toc->output_section->rawsize;
9207 if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
9208 continue;
9209
9210 if (skip == NULL)
9211 {
9212 skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
9213 if (skip == NULL)
9214 goto error_ret;
9215 }
9216
9217 skip[rel->r_offset >> 3]
425b145b 9218 |= can_optimize | ((rel - toc_relocs) << 2);
ba761f19 9219 }
ba761f19
AM		 9220 }
9221
c5614fa4
AM		 9222 if (skip == NULL)
9223 continue;
9224
9225 used = bfd_zmalloc (sizeof (*used) * (toc->size + 7) / 8);
9226 if (used == NULL)
9227 {
9228 error_ret:
9229 if (local_syms != NULL
9230 && symtab_hdr->contents != (unsigned char *) local_syms)
9231 free (local_syms);
9232 if (sec != NULL
9233 && relstart != NULL
9234 && elf_section_data (sec)->relocs != relstart)
9235 free (relstart);
425b145b
AM		 9236 if (toc_relocs != NULL
9237 && elf_section_data (toc)->relocs != toc_relocs)
9238 free (toc_relocs);
c5614fa4
AM		 9239 if (skip != NULL)
9240 free (skip);
9241 return FALSE;
9242 }
9243
30038c59
AM		 9244 /* Now check all kept sections that might reference the toc.
9245 Check the toc itself last. */
9246 for (sec = (ibfd->sections == toc && toc->next ? toc->next
9247 : ibfd->sections);
c5614fa4 9248 sec != NULL;
c5614fa4 9249 sec = (sec == toc ? NULL
c5614fa4 9250 : sec->next == NULL ? toc
30038c59 9251 : sec->next == toc && toc->next ? toc->next
c5614fa4
AM		 9252 : sec->next))
9253 {
9254 int repeat;
9255
9256 if (sec->reloc_count == 0
dbaa2011 9257 || discarded_section (sec)
c5614fa4
AM		 9258 || get_opd_info (sec)
9259 || (sec->flags & SEC_ALLOC) == 0
9260 || (sec->flags & SEC_DEBUGGING) != 0)
9261 continue;
9262
854b41e7
AM		 9263 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
9264 info->keep_memory);
c5614fa4 9265 if (relstart == NULL)
2915c55b
JK		 9266 {
9267 free (used);
9268 goto error_ret;
9269 }
c5614fa4
AM		 9270
9271 /* Mark toc entries referenced as used. */
c5614fa4 9272 do
d4f1ee75
AM		 9273 {
9274 repeat = 0;
9275 for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9276 {
9277 enum elf_ppc64_reloc_type r_type;
9278 unsigned long r_symndx;
9279 asection *sym_sec;
9280 struct elf_link_hash_entry *h;
9281 Elf_Internal_Sym *sym;
9282 bfd_vma val;
9283 enum {no_check, check_lo, check_ha} insn_check;
98528052 9284
d4f1ee75
AM		 9285 r_type = ELF64_R_TYPE (rel->r_info);
9286 switch (r_type)
9287 {
9288 default:
9289 insn_check = no_check;
9290 break;
98528052 9291
d4f1ee75
AM		 9292 case R_PPC64_GOT_TLSLD16_HA:
9293 case R_PPC64_GOT_TLSGD16_HA:
9294 case R_PPC64_GOT_TPREL16_HA:
9295 case R_PPC64_GOT_DTPREL16_HA:
9296 case R_PPC64_GOT16_HA:
9297 case R_PPC64_TOC16_HA:
9298 insn_check = check_ha;
9299 break;
98528052 9300
d4f1ee75
AM		 9301 case R_PPC64_GOT_TLSLD16_LO:
9302 case R_PPC64_GOT_TLSGD16_LO:
9303 case R_PPC64_GOT_TPREL16_LO_DS:
9304 case R_PPC64_GOT_DTPREL16_LO_DS:
9305 case R_PPC64_GOT16_LO:
9306 case R_PPC64_GOT16_LO_DS:
9307 case R_PPC64_TOC16_LO:
9308 case R_PPC64_TOC16_LO_DS:
9309 insn_check = check_lo;
9310 break;
9311 }
560c8763 9312
d4f1ee75
AM		 9313 if (insn_check != no_check)
9314 {
9315 bfd_vma off = rel->r_offset & ~3;
9316 unsigned char buf[4];
9317 unsigned int insn;
c5614fa4 9318
d4f1ee75
AM		 9319 if (!bfd_get_section_contents (ibfd, sec, buf, off, 4))
9320 {
9321 free (used);
9322 goto error_ret;
9323 }
9324 insn = bfd_get_32 (ibfd, buf);
9325 if (insn_check == check_lo
39eeab25 9326 ? !ok_lo_toc_insn (insn, r_type)
d4f1ee75
AM		 9327 : ((insn & ((0x3f << 26) | 0x1f << 16))
9328 != ((15u << 26) | (2 << 16)) /* addis rt,2,imm */))
9329 {
9330 char str[12];
9331
9332 ppc64_elf_tdata (ibfd)->unexpected_toc_insn = 1;
9333 sprintf (str, "%#08x", insn);
9334 info->callbacks->einfo
695344c0 9335 /* xgettext:c-format */
174d0a74 9336 (_("%H: toc optimization is not supported for"
d4f1ee75
AM		 9337 " %s instruction.\n"),
9338 ibfd, sec, rel->r_offset & ~3, str);
9339 }
9340 }
c5614fa4 9341
d4f1ee75
AM		 9342 switch (r_type)
9343 {
9344 case R_PPC64_TOC16:
9345 case R_PPC64_TOC16_LO:
9346 case R_PPC64_TOC16_HI:
9347 case R_PPC64_TOC16_HA:
9348 case R_PPC64_TOC16_DS:
9349 case R_PPC64_TOC16_LO_DS:
9350 /* In case we're taking addresses of toc entries. */
9351 case R_PPC64_ADDR64:
9352 break;
c5614fa4 9353
d4f1ee75
AM		 9354 default:
9355 continue;
9356 }
c5614fa4 9357
d4f1ee75
AM		 9358 r_symndx = ELF64_R_SYM (rel->r_info);
9359 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9360 r_symndx, ibfd))
9361 {
9362 free (used);
9363 goto error_ret;
9364 }
c5614fa4 9365
d4f1ee75
AM		 9366 if (sym_sec != toc)
9367 continue;
c5614fa4 9368
d4f1ee75
AM		 9369 if (h != NULL)
9370 val = h->root.u.def.value;
9371 else
9372 val = sym->st_value;
9373 val += rel->r_addend;
ba761f19 9374
d4f1ee75
AM		 9375 if (val >= toc->size)
9376 continue;
ba761f19 9377
d4f1ee75
AM		 9378 if ((skip[val >> 3] & can_optimize) != 0)
9379 {
9380 bfd_vma off;
9381 unsigned char opc;
9382
9383 switch (r_type)
9384 {
9385 case R_PPC64_TOC16_HA:
ba761f19 9386 break;
ba761f19 9387
d4f1ee75
AM		 9388 case R_PPC64_TOC16_LO_DS:
9389 off = rel->r_offset;
9390 off += (bfd_big_endian (ibfd) ? -2 : 3);
9391 if (!bfd_get_section_contents (ibfd, sec, &opc,
9392 off, 1))
9393 {
9394 free (used);
9395 goto error_ret;
9396 }
9397 if ((opc & (0x3f << 2)) == (58u << 2))
9398 break;
1a0670f3 9399 /* Fall through. */
ba761f19 9400
d4f1ee75
AM		 9401 default:
9402 /* Wrong sort of reloc, or not a ld. We may
9403 as well clear ref_from_discarded too. */
9404 skip[val >> 3] = 0;
9405 }
9406 }
9407
9408 if (sec != toc)
9409 used[val >> 3] = 1;
9410 /* For the toc section, we only mark as used if this
9411 entry itself isn't unused. */
9412 else if ((used[rel->r_offset >> 3]
9413 || !(skip[rel->r_offset >> 3] & ref_from_discarded))
9414 && !used[val >> 3])
9415 {
9416 /* Do all the relocs again, to catch reference
9417 chains. */
9418 repeat = 1;
9419 used[val >> 3] = 1;
9420 }
9421 }
9422 }
c5614fa4 9423 while (repeat);
854b41e7
AM		 9424
9425 if (elf_section_data (sec)->relocs != relstart)
9426 free (relstart);
c5614fa4
AM		 9427 }
9428
9429 /* Merge the used and skip arrays. Assume that TOC
9430 doublewords not appearing as either used or unused belong
de194d85 9431 to an entry more than one doubleword in size. */
c5614fa4
AM		 9432 for (drop = skip, keep = used, last = 0, some_unused = 0;
9433 drop < skip + (toc->size + 7) / 8;
9434 ++drop, ++keep)
9435 {
9436 if (*keep)
9437 {
ba761f19
AM		 9438 *drop &= ~ref_from_discarded;
9439 if ((*drop & can_optimize) != 0)
9440 some_unused = 1;
c5614fa4
AM		 9441 last = 0;
9442 }
b140b010 9443 else if ((*drop & ref_from_discarded) != 0)
c5614fa4
AM		 9444 {
9445 some_unused = 1;
ba761f19 9446 last = ref_from_discarded;
c5614fa4
AM		 9447 }
9448 else
9449 *drop = last;
9450 }
9451
9452 free (used);
9453
9454 if (some_unused)
9455 {
9456 bfd_byte *contents, *src;
9457 unsigned long off;
d62b3684 9458 Elf_Internal_Sym *sym;
ba761f19 9459 bfd_boolean local_toc_syms = FALSE;
c5614fa4
AM		 9460
9461 /* Shuffle the toc contents, and at the same time convert the
9462 skip array from booleans into offsets. */
9463 if (!bfd_malloc_and_get_section (ibfd, toc, &contents))
9464 goto error_ret;
9465
9466 elf_section_data (toc)->this_hdr.contents = contents;
9467
9468 for (src = contents, off = 0, drop = skip;
9469 src < contents + toc->size;
9470 src += 8, ++drop)
9471 {
ba761f19
AM		 9472 if ((*drop & (can_optimize | ref_from_discarded)) != 0)
9473 off += 8;
c5614fa4
AM		 9474 else if (off != 0)
9475 {
9476 *drop = off;
9477 memcpy (src - off, src, 8);
9478 }
9479 }
854b41e7 9480 *drop = off;
c5614fa4
AM		 9481 toc->rawsize = toc->size;
9482 toc->size = src - contents - off;
9483
ba761f19
AM		 9484 /* Adjust addends for relocs against the toc section sym,
9485 and optimize any accesses we can. */
c5614fa4
AM		 9486 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
9487 {
9488 if (sec->reloc_count == 0
dbaa2011 9489 || discarded_section (sec))
c5614fa4
AM		 9490 continue;
9491
9492 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
854b41e7 9493 info->keep_memory);
c5614fa4
AM		 9494 if (relstart == NULL)
9495 goto error_ret;
9496
9497 for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9498 {
9499 enum elf_ppc64_reloc_type r_type;
9500 unsigned long r_symndx;
9501 asection *sym_sec;
9502 struct elf_link_hash_entry *h;
854b41e7 9503 bfd_vma val;
c5614fa4
AM		 9504
9505 r_type = ELF64_R_TYPE (rel->r_info);
9506 switch (r_type)
9507 {
9508 default:
9509 continue;
9510
9511 case R_PPC64_TOC16:
9512 case R_PPC64_TOC16_LO:
9513 case R_PPC64_TOC16_HI:
9514 case R_PPC64_TOC16_HA:
9515 case R_PPC64_TOC16_DS:
9516 case R_PPC64_TOC16_LO_DS:
9517 case R_PPC64_ADDR64:
9518 break;
9519 }
9520
9521 r_symndx = ELF64_R_SYM (rel->r_info);
9522 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9523 r_symndx, ibfd))
9524 goto error_ret;
9525
ba761f19 9526 if (sym_sec != toc)
c5614fa4
AM		 9527 continue;
9528
ba761f19
AM		 9529 if (h != NULL)
9530 val = h->root.u.def.value;
9531 else
9532 {
9533 val = sym->st_value;
9534 if (val != 0)
9535 local_toc_syms = TRUE;
9536 }
9537
9538 val += rel->r_addend;
854b41e7
AM		 9539
9540 if (val > toc->rawsize)
9541 val = toc->rawsize;
ba761f19
AM		 9542 else if ((skip[val >> 3] & ref_from_discarded) != 0)
9543 continue;
9544 else if ((skip[val >> 3] & can_optimize) != 0)
9545 {
9546 Elf_Internal_Rela *tocrel
425b145b 9547 = toc_relocs + (skip[val >> 3] >> 2);
ba761f19
AM		 9548 unsigned long tsym = ELF64_R_SYM (tocrel->r_info);
9549
9550 switch (r_type)
9551 {
9552 case R_PPC64_TOC16_HA:
9553 rel->r_info = ELF64_R_INFO (tsym, R_PPC64_TOC16_HA);
9554 break;
9555
9556 case R_PPC64_TOC16_LO_DS:
9557 rel->r_info = ELF64_R_INFO (tsym, R_PPC64_LO_DS_OPT);
9558 break;
9559
9560 default:
28942f62
AM		 9561 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
9562 ppc_howto_init ();
b140b010 9563 info->callbacks->einfo
695344c0 9564 /* xgettext:c-format */
174d0a74 9565 (_("%H: %s references "
b140b010
AM		 9566 "optimized away TOC entry\n"),
9567 ibfd, sec, rel->r_offset,
9568 ppc64_elf_howto_table[r_type]->name);
9569 bfd_set_error (bfd_error_bad_value);
9570 goto error_ret;
ba761f19
AM		 9571 }
9572 rel->r_addend = tocrel->r_addend;
9573 elf_section_data (sec)->relocs = relstart;
9574 continue;
9575 }
9576
9577 if (h != NULL || sym->st_value != 0)
9578 continue;
854b41e7
AM		 9579
9580 rel->r_addend -= skip[val >> 3];
9581 elf_section_data (sec)->relocs = relstart;
c5614fa4 9582 }
854b41e7
AM		 9583
9584 if (elf_section_data (sec)->relocs != relstart)
9585 free (relstart);
c5614fa4
AM		 9586 }
9587
9588 /* We shouldn't have local or global symbols defined in the TOC,
9589 but handle them anyway. */
df22d223
AM		 9590 if (local_syms != NULL)
9591 for (sym = local_syms;
9592 sym < local_syms + symtab_hdr->sh_info;
9593 ++sym)
9594 if (sym->st_value != 0
9595 && bfd_section_from_elf_index (ibfd, sym->st_shndx) == toc)
9596 {
9597 unsigned long i;
854b41e7 9598
df22d223
AM		 9599 if (sym->st_value > toc->rawsize)
9600 i = toc->rawsize >> 3;
9601 else
9602 i = sym->st_value >> 3;
854b41e7 9603
df22d223
AM		 9604 if ((skip[i] & (ref_from_discarded | can_optimize)) != 0)
9605 {
9606 if (local_toc_syms)
4eca0228 9607 _bfd_error_handler
df22d223
AM		 9608 (_("%s defined on removed toc entry"),
9609 bfd_elf_sym_name (ibfd, symtab_hdr, sym, NULL));
9610 do
9611 ++i;
9612 while ((skip[i] & (ref_from_discarded | can_optimize)));
9613 sym->st_value = (bfd_vma) i << 3;
9614 }
d62b3684 9615
df22d223
AM		 9616 sym->st_value -= skip[i];
9617 symtab_hdr->contents = (unsigned char *) local_syms;
9618 }
c5614fa4 9619
854b41e7 9620 /* Adjust any global syms defined in this toc input section. */
c5614fa4
AM		 9621 if (toc_inf.global_toc_syms)
9622 {
9623 toc_inf.toc = toc;
9624 toc_inf.skip = skip;
9625 toc_inf.global_toc_syms = FALSE;
9626 elf_link_hash_traverse (elf_hash_table (info), adjust_toc_syms,
9627 &toc_inf);
9628 }
854b41e7
AM		 9629
9630 if (toc->reloc_count != 0)
9631 {
d4730f92 9632 Elf_Internal_Shdr *rel_hdr;
854b41e7
AM		 9633 Elf_Internal_Rela *wrel;
9634 bfd_size_type sz;
9635
854b41e7 9636 /* Remove unused toc relocs, and adjust those we keep. */
28be611c
AM		 9637 if (toc_relocs == NULL)
9638 toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
9639 info->keep_memory);
9640 if (toc_relocs == NULL)
9641 goto error_ret;
9642
425b145b
AM		 9643 wrel = toc_relocs;
9644 for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
ba761f19
AM		 9645 if ((skip[rel->r_offset >> 3]
9646 & (ref_from_discarded | can_optimize)) == 0)
854b41e7
AM		 9647 {
9648 wrel->r_offset = rel->r_offset - skip[rel->r_offset >> 3];
9649 wrel->r_info = rel->r_info;
9650 wrel->r_addend = rel->r_addend;
9651 ++wrel;
9652 }
9653 else if (!dec_dynrel_count (rel->r_info, toc, info,
9654 &local_syms, NULL, NULL))
9655 goto error_ret;
9656
425b145b
AM		 9657 elf_section_data (toc)->relocs = toc_relocs;
9658 toc->reloc_count = wrel - toc_relocs;
d4730f92
BS		 9659 rel_hdr = _bfd_elf_single_rel_hdr (toc);
9660 sz = rel_hdr->sh_entsize;
9661 rel_hdr->sh_size = toc->reloc_count * sz;
854b41e7 9662 }
c5614fa4 9663 }
28be611c
AM		 9664 else if (toc_relocs != NULL
9665 && elf_section_data (toc)->relocs != toc_relocs)
425b145b 9666 free (toc_relocs);
c5614fa4
AM		 9667
9668 if (local_syms != NULL
9669 && symtab_hdr->contents != (unsigned char *) local_syms)
9670 {
9671 if (!info->keep_memory)
9672 free (local_syms);
9673 else
9674 symtab_hdr->contents = (unsigned char *) local_syms;
9675 }
9676 free (skip);
9677 }
9678
9679 return TRUE;
9680}
9681
1bbe0902
AM		 9682/* Return true iff input section I references the TOC using
9683 instructions limited to +/-32k offsets. */
9684
9685bfd_boolean
9686ppc64_elf_has_small_toc_reloc (asection *i)
9687{
9688 return (is_ppc64_elf (i->owner)
9689 && ppc64_elf_tdata (i->owner)->has_small_toc_reloc);
9690}
9691
927be08e
AM		 9692/* Allocate space for one GOT entry. */
9693
9694static void
9695allocate_got (struct elf_link_hash_entry *h,
9696 struct bfd_link_info *info,
9697 struct got_entry *gent)
9698{
9699 struct ppc_link_hash_table *htab = ppc_hash_table (info);
927be08e
AM		 9700 struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
9701 int entsize = (gent->tls_type & eh->tls_mask & (TLS_GD | TLS_LD)
9702 ? 16 : 8);
9703 int rentsize = (gent->tls_type & eh->tls_mask & TLS_GD
9704 ? 2 : 1) * sizeof (Elf64_External_Rela);
9705 asection *got = ppc64_elf_tdata (gent->owner)->got;
9706
9707 gent->got.offset = got->size;
9708 got->size += entsize;
9709
19e08130 9710 if (h->type == STT_GNU_IFUNC)
927be08e 9711 {
33e44f2e 9712 htab->elf.irelplt->size += rentsize;
19e08130 9713 htab->got_reli_size += rentsize;
927be08e 9714 }
0e1862bb 9715 else if ((bfd_link_pic (info)
f0158f44
AM		 9716 || (htab->elf.dynamic_sections_created
9717 && h->dynindx != -1
9718 && !SYMBOL_REFERENCES_LOCAL (info, h)))
21d68fcd 9719 && !UNDEFWEAK_NO_DYNAMIC_RELOC (info, h))
927be08e 9720 {
19e08130 9721 asection *relgot = ppc64_elf_tdata (gent->owner)->relgot;
927be08e 9722 relgot->size += rentsize;
927be08e
AM		 9723 }
9724}
9725
7865406b
AM		 9726/* This function merges got entries in the same toc group. */
9727
9728static void
9729merge_got_entries (struct got_entry **pent)
9730{
9731 struct got_entry *ent, *ent2;
9732
9733 for (ent = *pent; ent != NULL; ent = ent->next)
9734 if (!ent->is_indirect)
9735 for (ent2 = ent->next; ent2 != NULL; ent2 = ent2->next)
9736 if (!ent2->is_indirect
9737 && ent2->addend == ent->addend
9738 && ent2->tls_type == ent->tls_type
9739 && elf_gp (ent2->owner) == elf_gp (ent->owner))
9740 {
9741 ent2->is_indirect = TRUE;
9742 ent2->got.ent = ent;
9743 }
9744}
9745
f0158f44
AM		 9746/* If H is undefined weak, make it dynamic if that makes sense. */
9747
9748static bfd_boolean
9749ensure_undefweak_dynamic (struct bfd_link_info *info,
9750 struct elf_link_hash_entry *h)
9751{
9752 struct elf_link_hash_table *htab = elf_hash_table (info);
9753
9754 if (htab->dynamic_sections_created
954b63d4 9755 && info->dynamic_undefined_weak != 0
f0158f44
AM		 9756 && h->root.type == bfd_link_hash_undefweak
9757 && h->dynindx == -1
9758 && !h->forced_local
9759 && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
9760 return bfd_elf_link_record_dynamic_symbol (info, h);
9761 return TRUE;
9762}
9763
65f38f15
AM		 9764/* Allocate space in .plt, .got and associated reloc sections for
9765 dynamic relocs. */
5bd4f169 9766
b34976b6 9767static bfd_boolean
4ce794b7 9768allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
5bd4f169 9769{
65f38f15
AM		 9770 struct bfd_link_info *info;
9771 struct ppc_link_hash_table *htab;
5bd4f169 9772 asection *s;
65f38f15 9773 struct ppc_link_hash_entry *eh;
0b8bcf0d 9774 struct got_entry **pgent, *gent;
5bd4f169 9775
e92d460e 9776 if (h->root.type == bfd_link_hash_indirect)
b34976b6 9777 return TRUE;
5bd4f169 9778
65f38f15
AM		 9779 info = (struct bfd_link_info *) inf;
9780 htab = ppc_hash_table (info);
4dfe6ac6
NC		 9781 if (htab == NULL)
9782 return FALSE;
5bd4f169 9783
951fd09b
AM		 9784 eh = (struct ppc_link_hash_entry *) h;
9785 /* Run through the TLS GD got entries first if we're changing them
9786 to TPREL. */
e7b938ca 9787 if ((eh->tls_mask & TLS_TPRELGD) != 0)
951fd09b
AM		 9788 for (gent = h->got.glist; gent != NULL; gent = gent->next)
9789 if (gent->got.refcount > 0
9790 && (gent->tls_type & TLS_GD) != 0)
9791 {
9792 /* This was a GD entry that has been converted to TPREL. If
9793 there happens to be a TPREL entry we can use that one. */
9794 struct got_entry *ent;
9795 for (ent = h->got.glist; ent != NULL; ent = ent->next)
9796 if (ent->got.refcount > 0
9797 && (ent->tls_type & TLS_TPREL) != 0
e717da7e
AM		 9798 && ent->addend == gent->addend
9799 && ent->owner == gent->owner)
951fd09b
AM		 9800 {
9801 gent->got.refcount = 0;
9802 break;
9803 }
9804
9805 /* If not, then we'll be using our own TPREL entry. */
9806 if (gent->got.refcount != 0)
9807 gent->tls_type = TLS_TLS | TLS_TPREL;
9808 }
9809
7865406b
AM		 9810 /* Remove any list entry that won't generate a word in the GOT before
9811 we call merge_got_entries. Otherwise we risk merging to empty
9812 entries. */
0b8bcf0d
AM		 9813 pgent = &h->got.glist;
9814 while ((gent = *pgent) != NULL)
411e1bfb 9815 if (gent->got.refcount > 0)
7865406b
AM		 9816 {
9817 if ((gent->tls_type & TLS_LD) != 0
9818 && !h->def_dynamic)
9819 {
9820 ppc64_tlsld_got (gent->owner)->got.refcount += 1;
9821 *pgent = gent->next;
9822 }
9823 else
9824 pgent = &gent->next;
9825 }
9826 else
9827 *pgent = gent->next;
9828
9829 if (!htab->do_multi_toc)
9830 merge_got_entries (&h->got.glist);
9831
9832 for (gent = h->got.glist; gent != NULL; gent = gent->next)
9833 if (!gent->is_indirect)
411e1bfb
AM		 9834 {
9835 /* Make sure this symbol is output as a dynamic symbol.
f0158f44
AM		 9836 Undefined weak syms won't yet be marked as dynamic. */
9837 if (!ensure_undefweak_dynamic (info, h))
9838 return FALSE;
65f38f15 9839
0c8d6e5c 9840 if (!is_ppc64_elf (gent->owner))
927be08e 9841 abort ();
0ffa91dd 9842
927be08e 9843 allocate_got (h, info, gent);
411e1bfb 9844 }
65f38f15 9845
954b63d4
AM		 9846 /* If no dynamic sections we can't have dynamic relocs, except for
9847 IFUNCs which are handled even in static executables. */
8a2058b5
AM		 9848 if (!htab->elf.dynamic_sections_created
9849 && h->type != STT_GNU_IFUNC)
9850 eh->dyn_relocs = NULL;
9851
954b63d4
AM		 9852 /* Also discard relocs on undefined weak syms with non-default
9853 visibility, or when dynamic_undefined_weak says so. */
21d68fcd 9854 else if (UNDEFWEAK_NO_DYNAMIC_RELOC (info, h))
954b63d4
AM		 9855 eh->dyn_relocs = NULL;
9856
8a2058b5 9857 if (eh->dyn_relocs != NULL)
65f38f15 9858 {
8a2058b5
AM		 9859 struct elf_dyn_relocs *p, **pp;
9860
57e7d118
AM		 9861 /* In the shared -Bsymbolic case, discard space allocated for
9862 dynamic pc-relative relocs against symbols which turn out to
9863 be defined in regular objects. For the normal shared case,
9864 discard space for relocs that have become local due to symbol
9865 visibility changes. */
9866
9867 if (bfd_link_pic (info))
65f38f15 9868 {
57e7d118
AM		 9869 /* Relocs that use pc_count are those that appear on a call
9870 insn, or certain REL relocs (see must_be_dyn_reloc) that
9871 can be generated via assembly. We want calls to
9872 protected symbols to resolve directly to the function
9873 rather than going via the plt. If people want function
9874 pointer comparisons to work as expected then they should
9875 avoid writing weird assembly. */
9876 if (SYMBOL_CALLS_LOCAL (info, h))
9877 {
57e7d118
AM		 9878 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
9879 {
9880 p->count -= p->pc_count;
9881 p->pc_count = 0;
9882 if (p->count == 0)
9883 *pp = p->next;
9884 else
9885 pp = &p->next;
9886 }
9887 }
65f38f15 9888
954b63d4 9889 if (eh->dyn_relocs != NULL)
5bd4f169 9890 {
57e7d118
AM		 9891 /* Make sure this symbol is output as a dynamic symbol.
9892 Undefined weak syms won't yet be marked as dynamic. */
954b63d4 9893 if (!ensure_undefweak_dynamic (info, h))
f0158f44 9894 return FALSE;
5bd4f169 9895 }
65f38f15 9896 }
57e7d118 9897 else if (h->type == STT_GNU_IFUNC)
dfbb6ac9 9898 {
8a2058b5
AM		 9899 /* A plt entry is always created when making direct calls to
9900 an ifunc, even when building a static executable, but
9901 that doesn't cover all cases. We may have only an ifunc
9902 initialised function pointer for a given ifunc symbol.
9903
9904 For ELFv2, dynamic relocations are not required when
9905 generating a global entry PLT stub. */
9906 if (abiversion (info->output_bfd) >= 2)
9907 {
9908 if (global_entry_stub (h))
9909 eh->dyn_relocs = NULL;
9910 }
9911
9912 /* For ELFv1 we have function descriptors. Descriptors need
9913 to be treated like PLT entries and thus have dynamic
9914 relocations. One exception is when the function
9915 descriptor is copied into .dynbss (which should only
9916 happen with ancient versions of gcc). */
9917 else if (h->needs_copy)
dfbb6ac9 9918 eh->dyn_relocs = NULL;
57e7d118
AM		 9919 }
9920 else if (ELIMINATE_COPY_RELOCS)
9921 {
8a2058b5 9922 /* For the non-pic case, discard space for relocs against
57e7d118
AM		 9923 symbols which turn out to need copy relocs or are not
9924 dynamic. */
f0158f44
AM		 9925 if (!h->non_got_ref
9926 && !h->def_regular)
9927 {
9928 /* Make sure this symbol is output as a dynamic symbol.
9929 Undefined weak syms won't yet be marked as dynamic. */
9930 if (!ensure_undefweak_dynamic (info, h))
9931 return FALSE;
dfbb6ac9 9932
f0158f44
AM		 9933 if (h->dynindx == -1)
9934 eh->dyn_relocs = NULL;
9935 }
9936 else
8a2058b5 9937 eh->dyn_relocs = NULL;
57e7d118
AM		 9938 }
9939
9940 /* Finally, allocate space. */
9941 for (p = eh->dyn_relocs; p != NULL; p = p->next)
9942 {
9943 asection *sreloc = elf_section_data (p->sec)->sreloc;
9944 if (eh->elf.type == STT_GNU_IFUNC)
9945 sreloc = htab->elf.irelplt;
9946 sreloc->size += p->count * sizeof (Elf64_External_Rela);
dfbb6ac9 9947 }
65f38f15 9948 }
57e7d118
AM		 9949
9950 if ((htab->elf.dynamic_sections_created
f0158f44 9951 && h->dynindx != -1)
57e7d118 9952 || h->type == STT_GNU_IFUNC)
65f38f15 9953 {
57e7d118
AM		 9954 struct plt_entry *pent;
9955 bfd_boolean doneone = FALSE;
9956 for (pent = h->plt.plist; pent != NULL; pent = pent->next)
9957 if (pent->plt.refcount > 0)
9958 {
9959 if (!htab->elf.dynamic_sections_created
9960 || h->dynindx == -1)
9961 {
9962 s = htab->elf.iplt;
9963 pent->plt.offset = s->size;
9964 s->size += PLT_ENTRY_SIZE (htab);
9965 s = htab->elf.irelplt;
9966 }
9967 else
9968 {
9969 /* If this is the first .plt entry, make room for the special
9970 first entry. */
9971 s = htab->elf.splt;
9972 if (s->size == 0)
9973 s->size += PLT_INITIAL_ENTRY_SIZE (htab);
65f38f15 9974
57e7d118 9975 pent->plt.offset = s->size;
65f38f15 9976
57e7d118
AM		 9977 /* Make room for this entry. */
9978 s->size += PLT_ENTRY_SIZE (htab);
65f38f15 9979
57e7d118
AM		 9980 /* Make room for the .glink code. */
9981 s = htab->glink;
9982 if (s->size == 0)
9983 s->size += GLINK_CALL_STUB_SIZE;
9984 if (htab->opd_abi)
9985 {
9986 /* We need bigger stubs past index 32767. */
9987 if (s->size >= GLINK_CALL_STUB_SIZE + 32768*2*4)
9988 s->size += 4;
9989 s->size += 2*4;
9990 }
9991 else
9992 s->size += 4;
65f38f15 9993
57e7d118
AM		 9994 /* We also need to make an entry in the .rela.plt section. */
9995 s = htab->elf.srelplt;
9996 }
9997 s->size += sizeof (Elf64_External_Rela);
9998 doneone = TRUE;
9999 }
10000 else
10001 pent->plt.offset = (bfd_vma) -1;
10002 if (!doneone)
10003 {
10004 h->plt.plist = NULL;
10005 h->needs_plt = 0;
10006 }
65f38f15 10007 }
57e7d118 10008 else
65f38f15 10009 {
57e7d118
AM		 10010 h->plt.plist = NULL;
10011 h->needs_plt = 0;
65f38f15
AM		 10012 }
10013
b34976b6 10014 return TRUE;
65f38f15
AM		 10015}
10016
a345bc8d
AM		 10017/* Called via elf_link_hash_traverse from ppc64_elf_size_dynamic_sections
10018 to set up space for global entry stubs. These are put in glink,
10019 after the branch table. */
65f38f15 10020
b34976b6 10021static bfd_boolean
a345bc8d 10022size_global_entry_stubs (struct elf_link_hash_entry *h, void *inf)
65f38f15 10023{
a345bc8d
AM		 10024 struct bfd_link_info *info;
10025 struct ppc_link_hash_table *htab;
10026 struct plt_entry *pent;
10027 asection *s;
65f38f15 10028
a345bc8d
AM		 10029 if (h->root.type == bfd_link_hash_indirect)
10030 return TRUE;
65f38f15 10031
a345bc8d
AM		 10032 if (!h->pointer_equality_needed)
10033 return TRUE;
65f38f15 10034
a345bc8d
AM		 10035 if (h->def_regular)
10036 return TRUE;
65f38f15 10037
a345bc8d
AM		 10038 info = inf;
10039 htab = ppc_hash_table (info);
10040 if (htab == NULL)
10041 return FALSE;
10042
10043 s = htab->glink;
10044 for (pent = h->plt.plist; pent != NULL; pent = pent->next)
10045 if (pent->plt.offset != (bfd_vma) -1
10046 && pent->addend == 0)
10047 {
afe397ea
AM		 10048 /* For ELFv2, if this symbol is not defined in a regular file
10049 and we are not generating a shared library or pie, then we
10050 need to define the symbol in the executable on a call stub.
10051 This is to avoid text relocations. */
a345bc8d 10052 s->size = (s->size + 15) & -16;
8a2058b5 10053 h->root.type = bfd_link_hash_defined;
afe397ea
AM		 10054 h->root.u.def.section = s;
10055 h->root.u.def.value = s->size;
a345bc8d
AM		 10056 s->size += 16;
10057 break;
10058 }
10059 return TRUE;
10060}
10061
10062/* Set DF_TEXTREL if we find any dynamic relocs that apply to
10063 read-only sections. */
10064
10065static bfd_boolean
10066maybe_set_textrel (struct elf_link_hash_entry *h, void *info)
10067{
10068 if (h->root.type == bfd_link_hash_indirect)
10069 return TRUE;
10070
10071 if (readonly_dynrelocs (h))
10072 {
10073 ((struct bfd_link_info *) info)->flags |= DF_TEXTREL;
10074
10075 /* Not an error, just cut short the traversal. */
10076 return FALSE;
65f38f15 10077 }
b34976b6 10078 return TRUE;
65f38f15
AM		 10079}
10080
10081/* Set the sizes of the dynamic sections. */
10082
b34976b6 10083static bfd_boolean
ee67d69a 10084ppc64_elf_size_dynamic_sections (bfd *output_bfd,
4ce794b7 10085 struct bfd_link_info *info)
65f38f15
AM		 10086{
10087 struct ppc_link_hash_table *htab;
10088 bfd *dynobj;
10089 asection *s;
b34976b6 10090 bfd_boolean relocs;
65f38f15 10091 bfd *ibfd;
7865406b 10092 struct got_entry *first_tlsld;
65f38f15
AM		 10093
10094 htab = ppc_hash_table (info);
4dfe6ac6
NC		 10095 if (htab == NULL)
10096 return FALSE;
10097
65f38f15
AM		 10098 dynobj = htab->elf.dynobj;
10099 if (dynobj == NULL)
10100 abort ();
10101
10102 if (htab->elf.dynamic_sections_created)
10103 {
10104 /* Set the contents of the .interp section to the interpreter. */
9b8b325a 10105 if (bfd_link_executable (info) && !info->nointerp)
65f38f15 10106 {
3d4d4302 10107 s = bfd_get_linker_section (dynobj, ".interp");
65f38f15
AM		 10108 if (s == NULL)
10109 abort ();
eea6121a 10110 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
65f38f15
AM		 10111 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
10112 }
10113 }
10114
10115 /* Set up .got offsets for local syms, and space for local dynamic
10116 relocs. */
c72f2fb2 10117 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
65f38f15 10118 {
411e1bfb
AM		 10119 struct got_entry **lgot_ents;
10120 struct got_entry **end_lgot_ents;
e054468f
AM		 10121 struct plt_entry **local_plt;
10122 struct plt_entry **end_local_plt;
f961d9dd 10123 unsigned char *lgot_masks;
65f38f15
AM		 10124 bfd_size_type locsymcount;
10125 Elf_Internal_Shdr *symtab_hdr;
65f38f15 10126
0c8d6e5c 10127 if (!is_ppc64_elf (ibfd))
65f38f15
AM		 10128 continue;
10129
10130 for (s = ibfd->sections; s != NULL; s = s->next)
10131 {
19e08130 10132 struct ppc_dyn_relocs *p;
65f38f15 10133
6edfbbad 10134 for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
65f38f15 10135 {
ec338859
AM		 10136 if (!bfd_is_abs_section (p->sec)
10137 && bfd_is_abs_section (p->sec->output_section))
10138 {
10139 /* Input section has been discarded, either because
10140 it is a copy of a linkonce section or due to
10141 linker script /DISCARD/, so we'll be discarding
10142 the relocs too. */
10143 }
248866a8 10144 else if (p->count != 0)
ec338859 10145 {
19e08130
AM		 10146 asection *srel = elf_section_data (p->sec)->sreloc;
10147 if (p->ifunc)
33e44f2e 10148 srel = htab->elf.irelplt;
eea6121a 10149 srel->size += p->count * sizeof (Elf64_External_Rela);
248866a8
AM		 10150 if ((p->sec->output_section->flags & SEC_READONLY) != 0)
10151 info->flags |= DF_TEXTREL;
ec338859 10152 }
65f38f15
AM		 10153 }
10154 }
10155
411e1bfb
AM		 10156 lgot_ents = elf_local_got_ents (ibfd);
10157 if (!lgot_ents)
65f38f15
AM		 10158 continue;
10159
0ffa91dd 10160 symtab_hdr = &elf_symtab_hdr (ibfd);
65f38f15 10161 locsymcount = symtab_hdr->sh_info;
411e1bfb 10162 end_lgot_ents = lgot_ents + locsymcount;
e054468f
AM		 10163 local_plt = (struct plt_entry **) end_lgot_ents;
10164 end_local_plt = local_plt + locsymcount;
f961d9dd 10165 lgot_masks = (unsigned char *) end_local_plt;
e717da7e 10166 s = ppc64_elf_tdata (ibfd)->got;
e7b938ca 10167 for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
65f38f15 10168 {
0b8bcf0d 10169 struct got_entry **pent, *ent;
411e1bfb 10170
0b8bcf0d
AM		 10171 pent = lgot_ents;
10172 while ((ent = *pent) != NULL)
411e1bfb
AM		 10173 if (ent->got.refcount > 0)
10174 {
e7b938ca 10175 if ((ent->tls_type & *lgot_masks & TLS_LD) != 0)
411e1bfb 10176 {
927be08e 10177 ppc64_tlsld_got (ibfd)->got.refcount += 1;
0b8bcf0d 10178 *pent = ent->next;
411e1bfb
AM		 10179 }
10180 else
10181 {
19e08130
AM		 10182 unsigned int ent_size = 8;
10183 unsigned int rel_size = sizeof (Elf64_External_Rela);
10184
eea6121a 10185 ent->got.offset = s->size;
e7b938ca 10186 if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
927be08e 10187 {
19e08130
AM		 10188 ent_size *= 2;
10189 rel_size *= 2;
10190 }
10191 s->size += ent_size;
10192 if ((*lgot_masks & PLT_IFUNC) != 0)
10193 {
33e44f2e 10194 htab->elf.irelplt->size += rel_size;
19e08130
AM		 10195 htab->got_reli_size += rel_size;
10196 }
0e1862bb 10197 else if (bfd_link_pic (info))
19e08130
AM		 10198 {
10199 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
10200 srel->size += rel_size;
927be08e 10201 }
0b8bcf0d 10202 pent = &ent->next;
411e1bfb
AM		 10203 }
10204 }
10205 else
0b8bcf0d 10206 *pent = ent->next;
65f38f15 10207 }
e054468f
AM		 10208
10209 /* Allocate space for calls to local STT_GNU_IFUNC syms in .iplt. */
10210 for (; local_plt < end_local_plt; ++local_plt)
10211 {
10212 struct plt_entry *ent;
10213
10214 for (ent = *local_plt; ent != NULL; ent = ent->next)
10215 if (ent->plt.refcount > 0)
10216 {
33e44f2e 10217 s = htab->elf.iplt;
e054468f 10218 ent->plt.offset = s->size;
b9e5796b 10219 s->size += PLT_ENTRY_SIZE (htab);
e054468f 10220
33e44f2e 10221 htab->elf.irelplt->size += sizeof (Elf64_External_Rela);
e054468f
AM		 10222 }
10223 else
10224 ent->plt.offset = (bfd_vma) -1;
10225 }
65f38f15
AM		 10226 }
10227
10228 /* Allocate global sym .plt and .got entries, and space for global
10229 sym dynamic relocs. */
4ce794b7 10230 elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, info);
a345bc8d
AM		 10231 /* Stash the end of glink branch table. */
10232 if (htab->glink != NULL)
10233 htab->glink->rawsize = htab->glink->size;
10234
0e1862bb 10235 if (!htab->opd_abi && !bfd_link_pic (info))
a345bc8d 10236 elf_link_hash_traverse (&htab->elf, size_global_entry_stubs, info);
65f38f15 10237
7865406b 10238 first_tlsld = NULL;
c72f2fb2 10239 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
102890f0 10240 {
7865406b
AM		 10241 struct got_entry *ent;
10242
0c8d6e5c 10243 if (!is_ppc64_elf (ibfd))
102890f0
AM		 10244 continue;
10245
7865406b
AM		 10246 ent = ppc64_tlsld_got (ibfd);
10247 if (ent->got.refcount > 0)
102890f0 10248 {
7865406b 10249 if (!htab->do_multi_toc && first_tlsld != NULL)
102890f0 10250 {
7865406b
AM		 10251 ent->is_indirect = TRUE;
10252 ent->got.ent = first_tlsld;
10253 }
10254 else
10255 {
10256 if (first_tlsld == NULL)
10257 first_tlsld = ent;
10258 s = ppc64_elf_tdata (ibfd)->got;
10259 ent->got.offset = s->size;
10260 ent->owner = ibfd;
10261 s->size += 16;
0e1862bb 10262 if (bfd_link_pic (info))
7865406b
AM		 10263 {
10264 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
10265 srel->size += sizeof (Elf64_External_Rela);
10266 }
102890f0
AM		 10267 }
10268 }
10269 else
7865406b 10270 ent->got.offset = (bfd_vma) -1;
102890f0
AM		 10271 }
10272
65f38f15
AM		 10273 /* We now have determined the sizes of the various dynamic sections.
10274 Allocate memory for them. */
b34976b6 10275 relocs = FALSE;
65f38f15
AM		 10276 for (s = dynobj->sections; s != NULL; s = s->next)
10277 {
10278 if ((s->flags & SEC_LINKER_CREATED) == 0)
10279 continue;
10280
4ce794b7 10281 if (s == htab->brlt || s == htab->relbrlt)
721956f4
AM		 10282 /* These haven't been allocated yet; don't strip. */
10283 continue;
33e44f2e
AM		 10284 else if (s == htab->elf.sgot
10285 || s == htab->elf.splt
10286 || s == htab->elf.iplt
c456f082 10287 || s == htab->glink
5474d94f
AM		 10288 || s == htab->elf.sdynbss
10289 || s == htab->elf.sdynrelro)
65f38f15
AM		 10290 {
10291 /* Strip this section if we don't need it; see the
10292 comment below. */
5bd4f169 10293 }
58d180e8
AM		 10294 else if (s == htab->glink_eh_frame)
10295 {
10296 if (!bfd_is_abs_section (s->output_section))
10297 /* Not sized yet. */
10298 continue;
10299 }
70cc837d 10300 else if (CONST_STRNEQ (s->name, ".rela"))
5bd4f169 10301 {
c456f082 10302 if (s->size != 0)
5bd4f169 10303 {
33e44f2e 10304 if (s != htab->elf.srelplt)
b34976b6 10305 relocs = TRUE;
5bd4f169
AM		 10306
10307 /* We use the reloc_count field as a counter if we need
10308 to copy relocs into the output file. */
10309 s->reloc_count = 0;
10310 }
10311 }
65f38f15 10312 else
5bd4f169
AM		 10313 {
10314 /* It's not one of our sections, so don't allocate space. */
10315 continue;
10316 }
10317
eea6121a 10318 if (s->size == 0)
5bd4f169 10319 {
c456f082
AM		 10320 /* If we don't need this section, strip it from the
10321 output file. This is mostly to handle .rela.bss and
10322 .rela.plt. We must create both sections in
10323 create_dynamic_sections, because they must be created
10324 before the linker maps input sections to output
10325 sections. The linker does that before
10326 adjust_dynamic_symbol is called, and it is that
10327 function which decides whether anything needs to go
10328 into these sections. */
8423293d 10329 s->flags |= SEC_EXCLUDE;
5bd4f169
AM		 10330 continue;
10331 }
10332
c456f082 10333 if ((s->flags & SEC_HAS_CONTENTS) == 0)
5f333394
AM		 10334 continue;
10335
65f38f15
AM		 10336 /* Allocate memory for the section contents. We use bfd_zalloc
10337 here in case unused entries are not reclaimed before the
10338 section's contents are written out. This should not happen,
411e1bfb
AM		 10339 but this way if it does we get a R_PPC64_NONE reloc in .rela
10340 sections instead of garbage.
10341 We also rely on the section contents being zero when writing
5474d94f 10342 the GOT and .dynrelro. */
eea6121a 10343 s->contents = bfd_zalloc (dynobj, s->size);
65f38f15 10344 if (s->contents == NULL)
b34976b6 10345 return FALSE;
5bd4f169
AM		 10346 }
10347
c72f2fb2 10348 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
e717da7e 10349 {
0c8d6e5c 10350 if (!is_ppc64_elf (ibfd))
7b53ace3
AM		 10351 continue;
10352
e717da7e 10353 s = ppc64_elf_tdata (ibfd)->got;
33e44f2e 10354 if (s != NULL && s != htab->elf.sgot)
e717da7e 10355 {
eea6121a 10356 if (s->size == 0)
8423293d 10357 s->flags |= SEC_EXCLUDE;
e717da7e
AM		 10358 else
10359 {
eea6121a 10360 s->contents = bfd_zalloc (ibfd, s->size);
e717da7e
AM		 10361 if (s->contents == NULL)
10362 return FALSE;
10363 }
10364 }
10365 s = ppc64_elf_tdata (ibfd)->relgot;
10366 if (s != NULL)
10367 {
eea6121a 10368 if (s->size == 0)
8423293d 10369 s->flags |= SEC_EXCLUDE;
e717da7e
AM		 10370 else
10371 {
eea6121a 10372 s->contents = bfd_zalloc (ibfd, s->size);
e717da7e
AM		 10373 if (s->contents == NULL)
10374 return FALSE;
10375 relocs = TRUE;
10376 s->reloc_count = 0;
10377 }
10378 }
10379 }
10380
e86ce104 10381 if (htab->elf.dynamic_sections_created)
5bd4f169 10382 {
e8910a83
AM		 10383 bfd_boolean tls_opt;
10384
5bd4f169
AM		 10385 /* Add some entries to the .dynamic section. We fill in the
10386 values later, in ppc64_elf_finish_dynamic_sections, but we
10387 must add the entries now so that we get the correct size for
10388 the .dynamic section. The DT_DEBUG entry is filled in by the
10389 dynamic linker and used by the debugger. */
dc810e39 10390#define add_dynamic_entry(TAG, VAL) \
5a580b3a 10391 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
dc810e39 10392
0e1862bb 10393 if (bfd_link_executable (info))
5bd4f169 10394 {
dc810e39 10395 if (!add_dynamic_entry (DT_DEBUG, 0))
b34976b6 10396 return FALSE;
5bd4f169
AM		 10397 }
10398
33e44f2e 10399 if (htab->elf.splt != NULL && htab->elf.splt->size != 0)
5bd4f169 10400 {
dc810e39
AM		 10401 if (!add_dynamic_entry (DT_PLTGOT, 0)
10402 || !add_dynamic_entry (DT_PLTRELSZ, 0)
10403 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
5d1634d7
AM		 10404 || !add_dynamic_entry (DT_JMPREL, 0)
10405 || !add_dynamic_entry (DT_PPC64_GLINK, 0))
b34976b6 10406 return FALSE;
5bd4f169
AM		 10407 }
10408
ee67d69a 10409 if (NO_OPD_RELOCS && abiversion (output_bfd) <= 1)
19397422
AM		 10410 {
10411 if (!add_dynamic_entry (DT_PPC64_OPD, 0)
10412 || !add_dynamic_entry (DT_PPC64_OPDSZ, 0))
b34976b6 10413 return FALSE;
19397422
AM		 10414 }
10415
7c9cf415 10416 tls_opt = (htab->params->tls_get_addr_opt
e8910a83
AM		 10417 && htab->tls_get_addr_fd != NULL
10418 && htab->tls_get_addr_fd->elf.plt.plist != NULL);
10419 if (tls_opt || !htab->opd_abi)
10420 {
10421 if (!add_dynamic_entry (DT_PPC64_OPT, tls_opt ? PPC64_OPT_TLS : 0))
10422 return FALSE;
10423 }
a7f2871e 10424
5bd4f169
AM		 10425 if (relocs)
10426 {
dc810e39
AM		 10427 if (!add_dynamic_entry (DT_RELA, 0)
10428 || !add_dynamic_entry (DT_RELASZ, 0)
10429 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
b34976b6 10430 return FALSE;
5bd4f169 10431
65f38f15
AM		 10432 /* If any dynamic relocs apply to a read-only section,
10433 then we need a DT_TEXTREL entry. */
248866a8 10434 if ((info->flags & DF_TEXTREL) == 0)
a345bc8d 10435 elf_link_hash_traverse (&htab->elf, maybe_set_textrel, info);
5bd4f169 10436
65f38f15 10437 if ((info->flags & DF_TEXTREL) != 0)
5bd4f169 10438 {
65f38f15 10439 if (!add_dynamic_entry (DT_TEXTREL, 0))
b34976b6 10440 return FALSE;
5bd4f169 10441 }
5bd4f169 10442 }
5bd4f169 10443 }
65f38f15 10444#undef add_dynamic_entry
5bd4f169 10445
b34976b6 10446 return TRUE;
5bd4f169
AM		 10447}
10448
a345bc8d
AM		 10449/* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
10450
10451static bfd_boolean
10452ppc64_elf_hash_symbol (struct elf_link_hash_entry *h)
10453{
10454 if (h->plt.plist != NULL
10455 && !h->def_regular
10456 && !h->pointer_equality_needed)
10457 return FALSE;
10458
10459 return _bfd_elf_hash_symbol (h);
10460}
10461
721956f4 10462/* Determine the type of stub needed, if any, for a call. */
5bd4f169 10463
4ce794b7
AM		 10464static inline enum ppc_stub_type
10465ppc_type_of_stub (asection *input_sec,
10466 const Elf_Internal_Rela *rel,
10467 struct ppc_link_hash_entry **hash,
e054468f 10468 struct plt_entry **plt_ent,
6911b7dc
AM		 10469 bfd_vma destination,
10470 unsigned long local_off)
5bd4f169 10471{
721956f4
AM		 10472 struct ppc_link_hash_entry *h = *hash;
10473 bfd_vma location;
10474 bfd_vma branch_offset;
10475 bfd_vma max_branch_offset;
4ce794b7 10476 enum elf_ppc64_reloc_type r_type;
5bd4f169 10477
721956f4
AM		 10478 if (h != NULL)
10479 {
e054468f 10480 struct plt_entry *ent;
7fe2b9a6 10481 struct ppc_link_hash_entry *fdh = h;
b31867b6
AM		 10482 if (h->oh != NULL
10483 && h->oh->is_func_descriptor)
7b8f6675
AM		 10484 {
10485 fdh = ppc_follow_link (h->oh);
10486 *hash = fdh;
10487 }
8387904d 10488
e054468f
AM		 10489 for (ent = fdh->elf.plt.plist; ent != NULL; ent = ent->next)
10490 if (ent->addend == rel->r_addend
10491 && ent->plt.offset != (bfd_vma) -1)
10492 {
e054468f
AM		 10493 *plt_ent = ent;
10494 return ppc_stub_plt_call;
10495 }
5bd4f169 10496
7fe2b9a6
AM		 10497 /* Here, we know we don't have a plt entry. If we don't have a
10498 either a defined function descriptor or a defined entry symbol
10499 in a regular object file, then it is pointless trying to make
10500 any other type of stub. */
854b41e7
AM		 10501 if (!is_static_defined (&fdh->elf)
10502 && !is_static_defined (&h->elf))
721956f4 10503 return ppc_stub_none;
5d1634d7 10504 }
e054468f
AM		 10505 else if (elf_local_got_ents (input_sec->owner) != NULL)
10506 {
10507 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (input_sec->owner);
10508 struct plt_entry **local_plt = (struct plt_entry **)
10509 elf_local_got_ents (input_sec->owner) + symtab_hdr->sh_info;
10510 unsigned long r_symndx = ELF64_R_SYM (rel->r_info);
10511
10512 if (local_plt[r_symndx] != NULL)
10513 {
10514 struct plt_entry *ent;
10515
10516 for (ent = local_plt[r_symndx]; ent != NULL; ent = ent->next)
10517 if (ent->addend == rel->r_addend
10518 && ent->plt.offset != (bfd_vma) -1)
10519 {
10520 *plt_ent = ent;
10521 return ppc_stub_plt_call;
10522 }
10523 }
10524 }
5d1634d7 10525
721956f4
AM		 10526 /* Determine where the call point is. */
10527 location = (input_sec->output_offset
10528 + input_sec->output_section->vma
10529 + rel->r_offset);
5d1634d7 10530
721956f4
AM		 10531 branch_offset = destination - location;
10532 r_type = ELF64_R_TYPE (rel->r_info);
5d1634d7 10533
721956f4
AM		 10534 /* Determine if a long branch stub is needed. */
10535 max_branch_offset = 1 << 25;
4ce794b7 10536 if (r_type != R_PPC64_REL24)
721956f4 10537 max_branch_offset = 1 << 15;
5d1634d7 10538
6911b7dc 10539 if (branch_offset + max_branch_offset >= 2 * max_branch_offset - local_off)
721956f4
AM		 10540 /* We need a stub. Figure out whether a long_branch or plt_branch
10541 is needed later. */
10542 return ppc_stub_long_branch;
5d1634d7 10543
721956f4 10544 return ppc_stub_none;
5d1634d7
AM		 10545}
10546
794e51c0
AM		 10547/* With power7 weakly ordered memory model, it is possible for ld.so
10548 to update a plt entry in one thread and have another thread see a
10549 stale zero toc entry. To avoid this we need some sort of acquire
10550 barrier in the call stub. One solution is to make the load of the
10551 toc word seem to appear to depend on the load of the function entry
10552 word. Another solution is to test for r2 being zero, and branch to
10553 the appropriate glink entry if so.
10554
10555 . fake dep barrier compare
71a39c98
AM		 10556 . ld 12,xxx(2) ld 12,xxx(2)
10557 . mtctr 12 mtctr 12
10558 . xor 11,12,12 ld 2,xxx+8(2)
794e51c0
AM		 10559 . add 2,2,11 cmpldi 2,0
10560 . ld 2,xxx+8(2) bnectr+
10561 . bctr b <glink_entry>
10562
10563 The solution involving the compare turns out to be faster, so
10564 that's what we use unless the branch won't reach. */
10565
10566#define ALWAYS_USE_FAKE_DEP 0
10567#define ALWAYS_EMIT_R2SAVE 0
5d1634d7 10568
5d1634d7
AM		 10569#define PPC_LO(v) ((v) & 0xffff)
10570#define PPC_HI(v) (((v) >> 16) & 0xffff)
10571#define PPC_HA(v) PPC_HI ((v) + 0x8000)
10572
794e51c0
AM		 10573static inline unsigned int
10574plt_stub_size (struct ppc_link_hash_table *htab,
10575 struct ppc_stub_hash_entry *stub_entry,
10576 bfd_vma off)
10577{
b9e5796b
AM		 10578 unsigned size = 12;
10579
10580 if (ALWAYS_EMIT_R2SAVE
10581 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10582 size += 4;
10583 if (PPC_HA (off) != 0)
794e51c0 10584 size += 4;
b9e5796b
AM		 10585 if (htab->opd_abi)
10586 {
10587 size += 4;
e7d1c40c 10588 if (htab->params->plt_static_chain)
b9e5796b 10589 size += 4;
bd4d2eaa
AM		 10590 if (htab->params->plt_thread_safe
10591 && htab->elf.dynamic_sections_created
10592 && stub_entry->h != NULL
10593 && stub_entry->h->elf.dynindx != -1)
b9e5796b 10594 size += 8;
e7d1c40c 10595 if (PPC_HA (off + 8 + 8 * htab->params->plt_static_chain) != PPC_HA (off))
b9e5796b
AM		 10596 size += 4;
10597 }
794e51c0
AM		 10598 if (stub_entry->h != NULL
10599 && (stub_entry->h == htab->tls_get_addr_fd
10600 || stub_entry->h == htab->tls_get_addr)
7c9cf415 10601 && htab->params->tls_get_addr_opt)
f378ab09
AM		 10602 {
10603 size += 7 * 4;
10604 if (ALWAYS_EMIT_R2SAVE
10605 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10606 size += 6 * 4;
10607 }
794e51c0
AM		 10608 return size;
10609}
10610
10611/* If this stub would cross fewer 2**plt_stub_align boundaries if we align,
10612 then return the padding needed to do so. */
10613static inline unsigned int
10614plt_stub_pad (struct ppc_link_hash_table *htab,
10615 struct ppc_stub_hash_entry *stub_entry,
10616 bfd_vma plt_off)
10617{
e7d1c40c 10618 int stub_align = 1 << htab->params->plt_stub_align;
794e51c0 10619 unsigned stub_size = plt_stub_size (htab, stub_entry, plt_off);
6f20ed8a 10620 bfd_vma stub_off = stub_entry->group->stub_sec->size;
794e51c0
AM		 10621
10622 if (((stub_off + stub_size - 1) & -stub_align) - (stub_off & -stub_align)
e05fa0ba 10623 > ((stub_size - 1) & -stub_align))
794e51c0
AM		 10624 return stub_align - (stub_off & (stub_align - 1));
10625 return 0;
10626}
10627
10628/* Build a .plt call stub. */
10629
10630static inline bfd_byte *
10631build_plt_stub (struct ppc_link_hash_table *htab,
10632 struct ppc_stub_hash_entry *stub_entry,
10633 bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
10634{
e7d1c40c 10635 bfd *obfd = htab->params->stub_bfd;
b9e5796b 10636 bfd_boolean plt_load_toc = htab->opd_abi;
e7d1c40c 10637 bfd_boolean plt_static_chain = htab->params->plt_static_chain;
bd4d2eaa
AM		 10638 bfd_boolean plt_thread_safe = (htab->params->plt_thread_safe
10639 && htab->elf.dynamic_sections_created
10640 && stub_entry->h != NULL
10641 && stub_entry->h->elf.dynindx != -1);
794e51c0
AM		 10642 bfd_boolean use_fake_dep = plt_thread_safe;
10643 bfd_vma cmp_branch_off = 0;
10644
10645 if (!ALWAYS_USE_FAKE_DEP
b9e5796b 10646 && plt_load_toc
794e51c0 10647 && plt_thread_safe
bd4d2eaa
AM		 10648 && !((stub_entry->h == htab->tls_get_addr_fd
10649 || stub_entry->h == htab->tls_get_addr)
7c9cf415 10650 && htab->params->tls_get_addr_opt))
794e51c0
AM		 10651 {
10652 bfd_vma pltoff = stub_entry->plt_ent->plt.offset & ~1;
b9e5796b
AM		 10653 bfd_vma pltindex = ((pltoff - PLT_INITIAL_ENTRY_SIZE (htab))
10654 / PLT_ENTRY_SIZE (htab));
794e51c0
AM		 10655 bfd_vma glinkoff = GLINK_CALL_STUB_SIZE + pltindex * 8;
10656 bfd_vma to, from;
10657
68d62958
AM		 10658 if (pltindex > 32768)
10659 glinkoff += (pltindex - 32768) * 4;
794e51c0
AM		 10660 to = (glinkoff
10661 + htab->glink->output_offset
10662 + htab->glink->output_section->vma);
6f20ed8a 10663 from = (p - stub_entry->group->stub_sec->contents
794e51c0
AM		 10664 + 4 * (ALWAYS_EMIT_R2SAVE
10665 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10666 + 4 * (PPC_HA (offset) != 0)
10667 + 4 * (PPC_HA (offset + 8 + 8 * plt_static_chain)
10668 != PPC_HA (offset))
10669 + 4 * (plt_static_chain != 0)
10670 + 20
6f20ed8a
AM		 10671 + stub_entry->group->stub_sec->output_offset
10672 + stub_entry->group->stub_sec->output_section->vma);
794e51c0
AM		 10673 cmp_branch_off = to - from;
10674 use_fake_dep = cmp_branch_off + (1 << 25) >= (1 << 26);
10675 }
10676
ac2df442
AM		 10677 if (PPC_HA (offset) != 0)
10678 {
176a0d42
AM		 10679 if (r != NULL)
10680 {
794e51c0
AM		 10681 if (ALWAYS_EMIT_R2SAVE
10682 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10683 r[0].r_offset += 4;
176a0d42 10684 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
3b421ab3 10685 r[1].r_offset = r[0].r_offset + 4;
176a0d42
AM		 10686 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10687 r[1].r_addend = r[0].r_addend;
b9e5796b 10688 if (plt_load_toc)
176a0d42 10689 {
b9e5796b 10690 if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
c7131b65 10691 {
b9e5796b
AM		 10692 r[2].r_offset = r[1].r_offset + 4;
10693 r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO);
10694 r[2].r_addend = r[0].r_addend;
10695 }
10696 else
10697 {
10698 r[2].r_offset = r[1].r_offset + 8 + 8 * use_fake_dep;
10699 r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10700 r[2].r_addend = r[0].r_addend + 8;
10701 if (plt_static_chain)
10702 {
10703 r[3].r_offset = r[2].r_offset + 4;
10704 r[3].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10705 r[3].r_addend = r[0].r_addend + 16;
10706 }
c7131b65 10707 }
176a0d42
AM		 10708 }
10709 }
794e51c0
AM		 10710 if (ALWAYS_EMIT_R2SAVE
10711 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
a078d95a 10712 bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p), p += 4;
397998fc
AM		 10713 if (plt_load_toc)
10714 {
10715 bfd_put_32 (obfd, ADDIS_R11_R2 | PPC_HA (offset), p), p += 4;
10716 bfd_put_32 (obfd, LD_R12_0R11 | PPC_LO (offset), p), p += 4;
10717 }
10718 else
10719 {
10720 bfd_put_32 (obfd, ADDIS_R12_R2 | PPC_HA (offset), p), p += 4;
10721 bfd_put_32 (obfd, LD_R12_0R12 | PPC_LO (offset), p), p += 4;
10722 }
b9e5796b
AM		 10723 if (plt_load_toc
10724 && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
ac2df442 10725 {
71a39c98 10726 bfd_put_32 (obfd, ADDI_R11_R11 | PPC_LO (offset), p), p += 4;
ac2df442
AM		 10727 offset = 0;
10728 }
71a39c98 10729 bfd_put_32 (obfd, MTCTR_R12, p), p += 4;
b9e5796b 10730 if (plt_load_toc)
794e51c0 10731 {
b9e5796b
AM		 10732 if (use_fake_dep)
10733 {
10734 bfd_put_32 (obfd, XOR_R2_R12_R12, p), p += 4;
10735 bfd_put_32 (obfd, ADD_R11_R11_R2, p), p += 4;
10736 }
10737 bfd_put_32 (obfd, LD_R2_0R11 | PPC_LO (offset + 8), p), p += 4;
10738 if (plt_static_chain)
10739 bfd_put_32 (obfd, LD_R11_0R11 | PPC_LO (offset + 16), p), p += 4;
794e51c0 10740 }
ac2df442
AM		 10741 }
10742 else
10743 {
176a0d42
AM		 10744 if (r != NULL)
10745 {
794e51c0
AM		 10746 if (ALWAYS_EMIT_R2SAVE
10747 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10748 r[0].r_offset += 4;
176a0d42 10749 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
b9e5796b 10750 if (plt_load_toc)
176a0d42 10751 {
b9e5796b 10752 if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
c7131b65 10753 {
b9e5796b
AM		 10754 r[1].r_offset = r[0].r_offset + 4;
10755 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16);
10756 r[1].r_addend = r[0].r_addend;
10757 }
10758 else
10759 {
10760 r[1].r_offset = r[0].r_offset + 8 + 8 * use_fake_dep;
10761 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10762 r[1].r_addend = r[0].r_addend + 8 + 8 * plt_static_chain;
10763 if (plt_static_chain)
10764 {
10765 r[2].r_offset = r[1].r_offset + 4;
10766 r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10767 r[2].r_addend = r[0].r_addend + 8;
10768 }
c7131b65 10769 }
176a0d42
AM		 10770 }
10771 }
794e51c0
AM		 10772 if (ALWAYS_EMIT_R2SAVE
10773 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
a078d95a 10774 bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p), p += 4;
71a39c98 10775 bfd_put_32 (obfd, LD_R12_0R2 | PPC_LO (offset), p), p += 4;
b9e5796b
AM		 10776 if (plt_load_toc
10777 && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
ac2df442
AM		 10778 {
10779 bfd_put_32 (obfd, ADDI_R2_R2 | PPC_LO (offset), p), p += 4;
10780 offset = 0;
10781 }
71a39c98 10782 bfd_put_32 (obfd, MTCTR_R12, p), p += 4;
b9e5796b 10783 if (plt_load_toc)
794e51c0 10784 {
b9e5796b
AM		 10785 if (use_fake_dep)
10786 {
10787 bfd_put_32 (obfd, XOR_R11_R12_R12, p), p += 4;
10788 bfd_put_32 (obfd, ADD_R2_R2_R11, p), p += 4;
10789 }
10790 if (plt_static_chain)
10791 bfd_put_32 (obfd, LD_R11_0R2 | PPC_LO (offset + 16), p), p += 4;
10792 bfd_put_32 (obfd, LD_R2_0R2 | PPC_LO (offset + 8), p), p += 4;
794e51c0 10793 }
ac2df442 10794 }
b9e5796b 10795 if (plt_load_toc && plt_thread_safe && !use_fake_dep)
794e51c0
AM		 10796 {
10797 bfd_put_32 (obfd, CMPLDI_R2_0, p), p += 4;
10798 bfd_put_32 (obfd, BNECTR_P4, p), p += 4;
22aa0c7e 10799 bfd_put_32 (obfd, B_DOT | (cmp_branch_off & 0x3fffffc), p), p += 4;
794e51c0
AM		 10800 }
10801 else
10802 bfd_put_32 (obfd, BCTR, p), p += 4;
5d1634d7
AM		 10803 return p;
10804}
10805
a7f2871e
AM		 10806/* Build a special .plt call stub for __tls_get_addr. */
10807
10808#define LD_R11_0R3 0xe9630000
10809#define LD_R12_0R3 0xe9830000
10810#define MR_R0_R3 0x7c601b78
10811#define CMPDI_R11_0 0x2c2b0000
10812#define ADD_R3_R12_R13 0x7c6c6a14
10813#define BEQLR 0x4d820020
10814#define MR_R3_R0 0x7c030378
a7f2871e
AM		 10815#define STD_R11_0R1 0xf9610000
10816#define BCTRL 0x4e800421
10817#define LD_R11_0R1 0xe9610000
a7f2871e
AM		 10818#define MTLR_R11 0x7d6803a6
10819
10820static inline bfd_byte *
794e51c0
AM		 10821build_tls_get_addr_stub (struct ppc_link_hash_table *htab,
10822 struct ppc_stub_hash_entry *stub_entry,
10823 bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
a7f2871e 10824{
e7d1c40c 10825 bfd *obfd = htab->params->stub_bfd;
794e51c0 10826
a7f2871e
AM		 10827 bfd_put_32 (obfd, LD_R11_0R3 + 0, p), p += 4;
10828 bfd_put_32 (obfd, LD_R12_0R3 + 8, p), p += 4;
10829 bfd_put_32 (obfd, MR_R0_R3, p), p += 4;
10830 bfd_put_32 (obfd, CMPDI_R11_0, p), p += 4;
10831 bfd_put_32 (obfd, ADD_R3_R12_R13, p), p += 4;
10832 bfd_put_32 (obfd, BEQLR, p), p += 4;
10833 bfd_put_32 (obfd, MR_R3_R0, p), p += 4;
f378ab09
AM		 10834 if (r != NULL)
10835 r[0].r_offset += 7 * 4;
10836 if (!ALWAYS_EMIT_R2SAVE
10837 && stub_entry->stub_type != ppc_stub_plt_call_r2save)
10838 return build_plt_stub (htab, stub_entry, p, offset, r);
10839
a7f2871e 10840 bfd_put_32 (obfd, MFLR_R11, p), p += 4;
a078d95a 10841 bfd_put_32 (obfd, STD_R11_0R1 + STK_LINKER (htab), p), p += 4;
a7f2871e
AM		 10842
10843 if (r != NULL)
f378ab09 10844 r[0].r_offset += 2 * 4;
794e51c0 10845 p = build_plt_stub (htab, stub_entry, p, offset, r);
a7f2871e
AM		 10846 bfd_put_32 (obfd, BCTRL, p - 4);
10847
a078d95a 10848 bfd_put_32 (obfd, LD_R2_0R1 + STK_TOC (htab), p), p += 4;
bd4d2eaa 10849 bfd_put_32 (obfd, LD_R11_0R1 + STK_LINKER (htab), p), p += 4;
a7f2871e
AM		 10850 bfd_put_32 (obfd, MTLR_R11, p), p += 4;
10851 bfd_put_32 (obfd, BLR, p), p += 4;
10852
10853 return p;
10854}
10855
176a0d42
AM		 10856static Elf_Internal_Rela *
10857get_relocs (asection *sec, int count)
10858{
10859 Elf_Internal_Rela *relocs;
10860 struct bfd_elf_section_data *elfsec_data;
10861
10862 elfsec_data = elf_section_data (sec);
10863 relocs = elfsec_data->relocs;
10864 if (relocs == NULL)
10865 {
10866 bfd_size_type relsize;
10867 relsize = sec->reloc_count * sizeof (*relocs);
10868 relocs = bfd_alloc (sec->owner, relsize);
10869 if (relocs == NULL)
10870 return NULL;
10871 elfsec_data->relocs = relocs;
d4730f92
BS		 10872 elfsec_data->rela.hdr = bfd_zalloc (sec->owner,
10873 sizeof (Elf_Internal_Shdr));
10874 if (elfsec_data->rela.hdr == NULL)
10875 return NULL;
10876 elfsec_data->rela.hdr->sh_size = (sec->reloc_count
10877 * sizeof (Elf64_External_Rela));
10878 elfsec_data->rela.hdr->sh_entsize = sizeof (Elf64_External_Rela);
176a0d42
AM		 10879 sec->reloc_count = 0;
10880 }
10881 relocs += sec->reloc_count;
10882 sec->reloc_count += count;
10883 return relocs;
10884}
10885
aa374f67 10886static bfd_vma
25f53a85 10887get_r2off (struct bfd_link_info *info,
aa374f67
AM		 10888 struct ppc_stub_hash_entry *stub_entry)
10889{
25f53a85 10890 struct ppc_link_hash_table *htab = ppc_hash_table (info);
6f20ed8a 10891 bfd_vma r2off = htab->sec_info[stub_entry->target_section->id].toc_off;
aa374f67
AM		 10892
10893 if (r2off == 0)
10894 {
10895 /* Support linking -R objects. Get the toc pointer from the
10896 opd entry. */
10897 char buf[8];
b9e5796b
AM		 10898 if (!htab->opd_abi)
10899 return r2off;
aa374f67
AM		 10900 asection *opd = stub_entry->h->elf.root.u.def.section;
10901 bfd_vma opd_off = stub_entry->h->elf.root.u.def.value;
10902
10903 if (strcmp (opd->name, ".opd") != 0
10904 || opd->reloc_count != 0)
10905 {
bc30df16 10906 info->callbacks->einfo (_("%P: cannot find opd entry toc for `%T'\n"),
25f53a85 10907 stub_entry->h->elf.root.root.string);
aa374f67 10908 bfd_set_error (bfd_error_bad_value);
a7c49797 10909 return (bfd_vma) -1;
aa374f67
AM		 10910 }
10911 if (!bfd_get_section_contents (opd->owner, opd, buf, opd_off + 8, 8))
a7c49797 10912 return (bfd_vma) -1;
aa374f67 10913 r2off = bfd_get_64 (opd->owner, buf);
25f53a85 10914 r2off -= elf_gp (info->output_bfd);
aa374f67 10915 }
6f20ed8a 10916 r2off -= htab->sec_info[stub_entry->group->link_sec->id].toc_off;
aa374f67
AM		 10917 return r2off;
10918}
10919
b34976b6 10920static bfd_boolean
4ce794b7 10921ppc_build_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
5d1634d7 10922{
721956f4
AM		 10923 struct ppc_stub_hash_entry *stub_entry;
10924 struct ppc_branch_hash_entry *br_entry;
5d1634d7
AM		 10925 struct bfd_link_info *info;
10926 struct ppc_link_hash_table *htab;
721956f4
AM		 10927 bfd_byte *loc;
10928 bfd_byte *p;
ee75fd95 10929 bfd_vma dest, off;
721956f4 10930 int size;
176a0d42 10931 Elf_Internal_Rela *r;
e054468f 10932 asection *plt;
5d1634d7 10933
721956f4
AM		 10934 /* Massage our args to the form they really have. */
10935 stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
4ce794b7 10936 info = in_arg;
5d1634d7 10937
5d1634d7 10938 htab = ppc_hash_table (info);
4dfe6ac6
NC		 10939 if (htab == NULL)
10940 return FALSE;
5d1634d7 10941
721956f4 10942 /* Make a note of the offset within the stubs for this entry. */
6f20ed8a
AM		 10943 stub_entry->stub_offset = stub_entry->group->stub_sec->size;
10944 loc = stub_entry->group->stub_sec->contents + stub_entry->stub_offset;
721956f4 10945
4ce794b7 10946 htab->stub_count[stub_entry->stub_type - 1] += 1;
721956f4 10947 switch (stub_entry->stub_type)
5d1634d7 10948 {
721956f4 10949 case ppc_stub_long_branch:
ad8e1ba5 10950 case ppc_stub_long_branch_r2off:
721956f4 10951 /* Branches are relative. This is where we are going to. */
6911b7dc
AM		 10952 dest = (stub_entry->target_value
10953 + stub_entry->target_section->output_offset
10954 + stub_entry->target_section->output_section->vma);
10955 dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
10956 off = dest;
5d1634d7 10957
721956f4
AM		 10958 /* And this is where we are coming from. */
10959 off -= (stub_entry->stub_offset
6f20ed8a
AM		 10960 + stub_entry->group->stub_sec->output_offset
10961 + stub_entry->group->stub_sec->output_section->vma);
e86ce104 10962
ac2df442
AM		 10963 size = 4;
10964 if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
ad8e1ba5 10965 {
25f53a85 10966 bfd_vma r2off = get_r2off (info, stub_entry);
ad8e1ba5 10967
a7c49797 10968 if (r2off == (bfd_vma) -1)
aa374f67
AM		 10969 {
10970 htab->stub_error = TRUE;
10971 return FALSE;
10972 }
e7d1c40c 10973 bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), loc);
ad8e1ba5 10974 loc += 4;
a7c49797 10975 size = 8;
ac2df442
AM		 10976 if (PPC_HA (r2off) != 0)
10977 {
e7d1c40c
AM		 10978 bfd_put_32 (htab->params->stub_bfd,
10979 ADDIS_R2_R2 | PPC_HA (r2off), loc);
ac2df442 10980 loc += 4;
a7c49797
AM		 10981 size += 4;
10982 }
10983 if (PPC_LO (r2off) != 0)
10984 {
10985 bfd_put_32 (htab->params->stub_bfd,
10986 ADDI_R2_R2 | PPC_LO (r2off), loc);
10987 loc += 4;
10988 size += 4;
ac2df442 10989 }
ac2df442 10990 off -= size - 4;
ad8e1ba5 10991 }
e7d1c40c 10992 bfd_put_32 (htab->params->stub_bfd, B_DOT | (off & 0x3fffffc), loc);
ad8e1ba5 10993
5c3dead3
AM		 10994 if (off + (1 << 25) >= (bfd_vma) (1 << 26))
10995 {
bc30df16
AM		 10996 info->callbacks->einfo
10997 (_("%P: long branch stub `%s' offset overflow\n"),
10998 stub_entry->root.string);
5c3dead3
AM		 10999 htab->stub_error = TRUE;
11000 return FALSE;
11001 }
ee75fd95
AM		 11002
11003 if (info->emitrelocations)
11004 {
6f20ed8a 11005 r = get_relocs (stub_entry->group->stub_sec, 1);
176a0d42
AM		 11006 if (r == NULL)
11007 return FALSE;
6f20ed8a 11008 r->r_offset = loc - stub_entry->group->stub_sec->contents;
ee75fd95
AM		 11009 r->r_info = ELF64_R_INFO (0, R_PPC64_REL24);
11010 r->r_addend = dest;
11011 if (stub_entry->h != NULL)
11012 {
11013 struct elf_link_hash_entry **hashes;
11014 unsigned long symndx;
11015 struct ppc_link_hash_entry *h;
11016
e7d1c40c 11017 hashes = elf_sym_hashes (htab->params->stub_bfd);
ee75fd95
AM		 11018 if (hashes == NULL)
11019 {
11020 bfd_size_type hsize;
11021
11022 hsize = (htab->stub_globals + 1) * sizeof (*hashes);
e7d1c40c 11023 hashes = bfd_zalloc (htab->params->stub_bfd, hsize);
ee75fd95
AM		 11024 if (hashes == NULL)
11025 return FALSE;
e7d1c40c 11026 elf_sym_hashes (htab->params->stub_bfd) = hashes;
ee75fd95
AM		 11027 htab->stub_globals = 1;
11028 }
11029 symndx = htab->stub_globals++;
11030 h = stub_entry->h;
11031 hashes[symndx] = &h->elf;
11032 r->r_info = ELF64_R_INFO (symndx, R_PPC64_REL24);
11033 if (h->oh != NULL && h->oh->is_func)
b31867b6 11034 h = ppc_follow_link (h->oh);
ee75fd95
AM		 11035 if (h->elf.root.u.def.section != stub_entry->target_section)
11036 /* H is an opd symbol. The addend must be zero. */
11037 r->r_addend = 0;
11038 else
11039 {
11040 off = (h->elf.root.u.def.value
11041 + h->elf.root.u.def.section->output_offset
11042 + h->elf.root.u.def.section->output_section->vma);
11043 r->r_addend -= off;
11044 }
11045 }
11046 }
721956f4 11047 break;
e86ce104 11048
721956f4 11049 case ppc_stub_plt_branch:
ad8e1ba5 11050 case ppc_stub_plt_branch_r2off:
721956f4
AM		 11051 br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
11052 stub_entry->root.string + 9,
b34976b6 11053 FALSE, FALSE);
721956f4
AM		 11054 if (br_entry == NULL)
11055 {
8de848d8 11056 info->callbacks->einfo (_("%P: can't find branch stub `%s'\n"),
25f53a85 11057 stub_entry->root.string);
b34976b6
AM		 11058 htab->stub_error = TRUE;
11059 return FALSE;
721956f4
AM		 11060 }
11061
176a0d42
AM		 11062 dest = (stub_entry->target_value
11063 + stub_entry->target_section->output_offset
11064 + stub_entry->target_section->output_section->vma);
6911b7dc
AM		 11065 if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
11066 dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
721956f4 11067
176a0d42 11068 bfd_put_64 (htab->brlt->owner, dest,
4ce794b7 11069 htab->brlt->contents + br_entry->offset);
721956f4 11070
f94498ff 11071 if (br_entry->iter == htab->stub_iteration)
721956f4 11072 {
f94498ff 11073 br_entry->iter = 0;
84f5d08e 11074
f94498ff 11075 if (htab->relbrlt != NULL)
84f5d08e 11076 {
f94498ff
AM		 11077 /* Create a reloc for the branch lookup table entry. */
11078 Elf_Internal_Rela rela;
11079 bfd_byte *rl;
11080
11081 rela.r_offset = (br_entry->offset
11082 + htab->brlt->output_offset
11083 + htab->brlt->output_section->vma);
11084 rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
176a0d42 11085 rela.r_addend = dest;
f94498ff
AM		 11086
11087 rl = htab->relbrlt->contents;
11088 rl += (htab->relbrlt->reloc_count++
11089 * sizeof (Elf64_External_Rela));
11090 bfd_elf64_swap_reloca_out (htab->relbrlt->owner, &rela, rl);
11091 }
11092 else if (info->emitrelocations)
11093 {
176a0d42
AM		 11094 r = get_relocs (htab->brlt, 1);
11095 if (r == NULL)
11096 return FALSE;
11097 /* brlt, being SEC_LINKER_CREATED does not go through the
11098 normal reloc processing. Symbols and offsets are not
11099 translated from input file to output file form, so
11100 set up the offset per the output file. */
f94498ff
AM		 11101 r->r_offset = (br_entry->offset
11102 + htab->brlt->output_offset
11103 + htab->brlt->output_section->vma);
11104 r->r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
176a0d42 11105 r->r_addend = dest;
84f5d08e 11106 }
84f5d08e 11107 }
721956f4 11108
176a0d42
AM		 11109 dest = (br_entry->offset
11110 + htab->brlt->output_offset
11111 + htab->brlt->output_section->vma);
11112
11113 off = (dest
4ce794b7 11114 - elf_gp (htab->brlt->output_section->owner)
6f20ed8a 11115 - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
721956f4 11116
ad8e1ba5 11117 if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
5d1634d7 11118 {
25f53a85 11119 info->callbacks->einfo
bc30df16 11120 (_("%P: linkage table error against `%T'\n"),
721956f4 11121 stub_entry->root.string);
5d1634d7 11122 bfd_set_error (bfd_error_bad_value);
b34976b6
AM		 11123 htab->stub_error = TRUE;
11124 return FALSE;
5d1634d7 11125 }
41bd81ab 11126
176a0d42
AM		 11127 if (info->emitrelocations)
11128 {
6f20ed8a 11129 r = get_relocs (stub_entry->group->stub_sec, 1 + (PPC_HA (off) != 0));
176a0d42
AM		 11130 if (r == NULL)
11131 return FALSE;
6f20ed8a 11132 r[0].r_offset = loc - stub_entry->group->stub_sec->contents;
7cfbafbc
AM		 11133 if (bfd_big_endian (info->output_bfd))
11134 r[0].r_offset += 2;
00f412ee 11135 if (stub_entry->stub_type == ppc_stub_plt_branch_r2off)
176a0d42
AM		 11136 r[0].r_offset += 4;
11137 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
11138 r[0].r_addend = dest;
11139 if (PPC_HA (off) != 0)
11140 {
11141 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
11142 r[1].r_offset = r[0].r_offset + 4;
11143 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
11144 r[1].r_addend = r[0].r_addend;
11145 }
11146 }
11147
00f412ee 11148 if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
ad8e1ba5 11149 {
176a0d42 11150 if (PPC_HA (off) != 0)
ac2df442
AM		 11151 {
11152 size = 16;
e7d1c40c 11153 bfd_put_32 (htab->params->stub_bfd,
397998fc 11154 ADDIS_R12_R2 | PPC_HA (off), loc);
ac2df442 11155 loc += 4;
e7d1c40c 11156 bfd_put_32 (htab->params->stub_bfd,
397998fc 11157 LD_R12_0R12 | PPC_LO (off), loc);
ac2df442
AM		 11158 }
11159 else
11160 {
11161 size = 12;
e7d1c40c
AM		 11162 bfd_put_32 (htab->params->stub_bfd,
11163 LD_R12_0R2 | PPC_LO (off), loc);
ac2df442 11164 }
ad8e1ba5
AM		 11165 }
11166 else
11167 {
25f53a85 11168 bfd_vma r2off = get_r2off (info, stub_entry);
aa374f67 11169
a7c49797 11170 if (r2off == (bfd_vma) -1)
aa374f67
AM		 11171 {
11172 htab->stub_error = TRUE;
11173 return FALSE;
11174 }
ad8e1ba5 11175
e7d1c40c 11176 bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), loc);
ad8e1ba5 11177 loc += 4;
00f412ee 11178 size = 16;
176a0d42 11179 if (PPC_HA (off) != 0)
ac2df442
AM		 11180 {
11181 size += 4;
e7d1c40c 11182 bfd_put_32 (htab->params->stub_bfd,
397998fc 11183 ADDIS_R12_R2 | PPC_HA (off), loc);
ac2df442 11184 loc += 4;
e7d1c40c 11185 bfd_put_32 (htab->params->stub_bfd,
397998fc 11186 LD_R12_0R12 | PPC_LO (off), loc);
ac2df442
AM		 11187 }
11188 else
e7d1c40c 11189 bfd_put_32 (htab->params->stub_bfd, LD_R12_0R2 | PPC_LO (off), loc);
ac2df442
AM		 11190
11191 if (PPC_HA (r2off) != 0)
11192 {
11193 size += 4;
00f412ee 11194 loc += 4;
e7d1c40c
AM		 11195 bfd_put_32 (htab->params->stub_bfd,
11196 ADDIS_R2_R2 | PPC_HA (r2off), loc);
00f412ee
AM		 11197 }
11198 if (PPC_LO (r2off) != 0)
11199 {
11200 size += 4;
ac2df442 11201 loc += 4;
e7d1c40c
AM		 11202 bfd_put_32 (htab->params->stub_bfd,
11203 ADDI_R2_R2 | PPC_LO (r2off), loc);
ac2df442 11204 }
ad8e1ba5
AM		 11205 }
11206 loc += 4;
e7d1c40c 11207 bfd_put_32 (htab->params->stub_bfd, MTCTR_R12, loc);
ad8e1ba5 11208 loc += 4;
e7d1c40c 11209 bfd_put_32 (htab->params->stub_bfd, BCTR, loc);
721956f4 11210 break;
5d1634d7 11211
721956f4 11212 case ppc_stub_plt_call:
794e51c0 11213 case ppc_stub_plt_call_r2save:
e054468f 11214 if (stub_entry->h != NULL
b31867b6
AM		 11215 && stub_entry->h->is_func_descriptor
11216 && stub_entry->h->oh != NULL)
c862ae31 11217 {
b31867b6
AM		 11218 struct ppc_link_hash_entry *fh = ppc_follow_link (stub_entry->h->oh);
11219
11220 /* If the old-ABI "dot-symbol" is undefined make it weak so
6f20ed8a 11221 we don't get a link error from RELOC_FOR_GLOBAL_SYMBOL. */
8c5b4e52
AM		 11222 if (fh->elf.root.type == bfd_link_hash_undefined
11223 && (stub_entry->h->elf.root.type == bfd_link_hash_defined
11224 || stub_entry->h->elf.root.type == bfd_link_hash_defweak))
b31867b6 11225 fh->elf.root.type = bfd_link_hash_undefweak;
c862ae31
AM		 11226 }
11227
721956f4 11228 /* Now build the stub. */
e054468f 11229 dest = stub_entry->plt_ent->plt.offset & ~1;
176a0d42 11230 if (dest >= (bfd_vma) -2)
721956f4
AM		 11231 abort ();
11232
33e44f2e 11233 plt = htab->elf.splt;
25f23106
AM		 11234 if (!htab->elf.dynamic_sections_created
11235 || stub_entry->h == NULL
11236 || stub_entry->h->elf.dynindx == -1)
33e44f2e 11237 plt = htab->elf.iplt;
e054468f
AM		 11238
11239 dest += plt->output_offset + plt->output_section->vma;
11240
11241 if (stub_entry->h == NULL
11242 && (stub_entry->plt_ent->plt.offset & 1) == 0)
11243 {
11244 Elf_Internal_Rela rela;
11245 bfd_byte *rl;
11246
11247 rela.r_offset = dest;
ee67d69a
AM		 11248 if (htab->opd_abi)
11249 rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
11250 else
11251 rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
e054468f
AM		 11252 rela.r_addend = (stub_entry->target_value
11253 + stub_entry->target_section->output_offset
11254 + stub_entry->target_section->output_section->vma);
11255
33e44f2e
AM		 11256 rl = (htab->elf.irelplt->contents
11257 + (htab->elf.irelplt->reloc_count++
25f23106
AM		 11258 * sizeof (Elf64_External_Rela)));
11259 bfd_elf64_swap_reloca_out (info->output_bfd, &rela, rl);
e054468f 11260 stub_entry->plt_ent->plt.offset |= 1;
82e66161 11261 htab->local_ifunc_resolver = 1;
e054468f 11262 }
176a0d42
AM		 11263
11264 off = (dest
e054468f 11265 - elf_gp (plt->output_section->owner)
6f20ed8a 11266 - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
721956f4 11267
ad8e1ba5 11268 if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
721956f4 11269 {
25f53a85 11270 info->callbacks->einfo
695344c0 11271 /* xgettext:c-format */
bc30df16 11272 (_("%P: linkage table error against `%T'\n"),
e054468f
AM		 11273 stub_entry->h != NULL
11274 ? stub_entry->h->elf.root.root.string
11275 : "<local sym>");
721956f4 11276 bfd_set_error (bfd_error_bad_value);
b34976b6
AM		 11277 htab->stub_error = TRUE;
11278 return FALSE;
721956f4
AM		 11279 }
11280
e7d1c40c 11281 if (htab->params->plt_stub_align != 0)
794e51c0
AM		 11282 {
11283 unsigned pad = plt_stub_pad (htab, stub_entry, off);
11284
6f20ed8a
AM		 11285 stub_entry->group->stub_sec->size += pad;
11286 stub_entry->stub_offset = stub_entry->group->stub_sec->size;
794e51c0
AM		 11287 loc += pad;
11288 }
11289
176a0d42
AM		 11290 r = NULL;
11291 if (info->emitrelocations)
11292 {
6f20ed8a 11293 r = get_relocs (stub_entry->group->stub_sec,
3ba720c7
AM		 11294 ((PPC_HA (off) != 0)
11295 + (htab->opd_abi
e7d1c40c 11296 ? 2 + (htab->params->plt_static_chain
3ba720c7
AM		 11297 && PPC_HA (off + 16) == PPC_HA (off))
11298 : 1)));
176a0d42
AM		 11299 if (r == NULL)
11300 return FALSE;
6f20ed8a 11301 r[0].r_offset = loc - stub_entry->group->stub_sec->contents;
7cfbafbc
AM		 11302 if (bfd_big_endian (info->output_bfd))
11303 r[0].r_offset += 2;
176a0d42
AM		 11304 r[0].r_addend = dest;
11305 }
a7f2871e
AM		 11306 if (stub_entry->h != NULL
11307 && (stub_entry->h == htab->tls_get_addr_fd
11308 || stub_entry->h == htab->tls_get_addr)
7c9cf415 11309 && htab->params->tls_get_addr_opt)
794e51c0 11310 p = build_tls_get_addr_stub (htab, stub_entry, loc, off, r);
a7f2871e 11311 else
794e51c0 11312 p = build_plt_stub (htab, stub_entry, loc, off, r);
721956f4
AM		 11313 size = p - loc;
11314 break;
11315
a4b6fadd
AM		 11316 case ppc_stub_save_res:
11317 return TRUE;
11318
721956f4
AM		 11319 default:
11320 BFD_FAIL ();
b34976b6 11321 return FALSE;
721956f4
AM		 11322 }
11323
6f20ed8a 11324 stub_entry->group->stub_sec->size += size;
97b639ba 11325
e7d1c40c 11326 if (htab->params->emit_stub_syms)
97b639ba
AM		 11327 {
11328 struct elf_link_hash_entry *h;
ee75fd95
AM		 11329 size_t len1, len2;
11330 char *name;
11331 const char *const stub_str[] = { "long_branch",
11332 "long_branch_r2off",
11333 "plt_branch",
11334 "plt_branch_r2off",
794e51c0 11335 "plt_call",
ee75fd95
AM		 11336 "plt_call" };
11337
11338 len1 = strlen (stub_str[stub_entry->stub_type - 1]);
11339 len2 = strlen (stub_entry->root.string);
11340 name = bfd_malloc (len1 + len2 + 2);
11341 if (name == NULL)
11342 return FALSE;
11343 memcpy (name, stub_entry->root.string, 9);
11344 memcpy (name + 9, stub_str[stub_entry->stub_type - 1], len1);
11345 memcpy (name + len1 + 9, stub_entry->root.string + 8, len2 - 8 + 1);
11346 h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
97b639ba
AM		 11347 if (h == NULL)
11348 return FALSE;
11349 if (h->root.type == bfd_link_hash_new)
11350 {
11351 h->root.type = bfd_link_hash_defined;
6f20ed8a 11352 h->root.u.def.section = stub_entry->group->stub_sec;
97b639ba 11353 h->root.u.def.value = stub_entry->stub_offset;
f5385ebf
AM		 11354 h->ref_regular = 1;
11355 h->def_regular = 1;
11356 h->ref_regular_nonweak = 1;
11357 h->forced_local = 1;
11358 h->non_elf = 0;
2ec55de3 11359 h->root.linker_def = 1;
97b639ba
AM		 11360 }
11361 }
11362
b34976b6 11363 return TRUE;
721956f4
AM		 11364}
11365
11366/* As above, but don't actually build the stub. Just bump offset so
11367 we know stub section sizes, and select plt_branch stubs where
11368 long_branch stubs won't do. */
11369
b34976b6 11370static bfd_boolean
4ce794b7 11371ppc_size_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
721956f4
AM		 11372{
11373 struct ppc_stub_hash_entry *stub_entry;
63bc6f6c 11374 struct bfd_link_info *info;
721956f4
AM		 11375 struct ppc_link_hash_table *htab;
11376 bfd_vma off;
11377 int size;
11378
11379 /* Massage our args to the form they really have. */
11380 stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
63bc6f6c
AM		 11381 info = in_arg;
11382
11383 htab = ppc_hash_table (info);
4dfe6ac6
NC		 11384 if (htab == NULL)
11385 return FALSE;
721956f4 11386
a4b6fadd
AM		 11387 if (stub_entry->h != NULL
11388 && stub_entry->h->save_res
11389 && stub_entry->h->elf.root.type == bfd_link_hash_defined
11390 && stub_entry->h->elf.root.u.def.section == htab->sfpr)
11391 {
11392 /* Don't make stubs to out-of-line register save/restore
11393 functions. Instead, emit copies of the functions. */
11394 stub_entry->group->needs_save_res = 1;
11395 stub_entry->stub_type = ppc_stub_save_res;
11396 return TRUE;
11397 }
11398
794e51c0
AM		 11399 if (stub_entry->stub_type == ppc_stub_plt_call
11400 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
721956f4 11401 {
e054468f
AM		 11402 asection *plt;
11403 off = stub_entry->plt_ent->plt.offset & ~(bfd_vma) 1;
58ac9f71 11404 if (off >= (bfd_vma) -2)
411e1bfb 11405 abort ();
33e44f2e 11406 plt = htab->elf.splt;
25f23106
AM		 11407 if (!htab->elf.dynamic_sections_created
11408 || stub_entry->h == NULL
11409 || stub_entry->h->elf.dynindx == -1)
33e44f2e 11410 plt = htab->elf.iplt;
e054468f
AM		 11411 off += (plt->output_offset
11412 + plt->output_section->vma
11413 - elf_gp (plt->output_section->owner)
6f20ed8a 11414 - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
721956f4 11415
794e51c0 11416 size = plt_stub_size (htab, stub_entry, off);
d4aaa2a0
AM		 11417 if (stub_entry->h != NULL
11418 && (stub_entry->h == htab->tls_get_addr_fd
11419 || stub_entry->h == htab->tls_get_addr)
11420 && htab->params->tls_get_addr_opt
11421 && (ALWAYS_EMIT_R2SAVE
11422 || stub_entry->stub_type == ppc_stub_plt_call_r2save))
11423 stub_entry->group->tls_get_addr_opt_bctrl
11424 = stub_entry->group->stub_sec->size + size - 5 * 4;
11425
e7d1c40c 11426 if (htab->params->plt_stub_align)
794e51c0 11427 size += plt_stub_pad (htab, stub_entry, off);
176a0d42
AM		 11428 if (info->emitrelocations)
11429 {
6f20ed8a 11430 stub_entry->group->stub_sec->reloc_count
b9e5796b
AM		 11431 += ((PPC_HA (off) != 0)
11432 + (htab->opd_abi
e7d1c40c 11433 ? 2 + (htab->params->plt_static_chain
b9e5796b
AM		 11434 && PPC_HA (off + 16) == PPC_HA (off))
11435 : 1));
6f20ed8a 11436 stub_entry->group->stub_sec->flags |= SEC_RELOC;
176a0d42 11437 }
721956f4
AM		 11438 }
11439 else
11440 {
ad8e1ba5
AM		 11441 /* ppc_stub_long_branch or ppc_stub_plt_branch, or their r2off
11442 variants. */
ac2df442 11443 bfd_vma r2off = 0;
6911b7dc 11444 bfd_vma local_off = 0;
ac2df442 11445
721956f4
AM		 11446 off = (stub_entry->target_value
11447 + stub_entry->target_section->output_offset
11448 + stub_entry->target_section->output_section->vma);
6f20ed8a
AM		 11449 off -= (stub_entry->group->stub_sec->size
11450 + stub_entry->group->stub_sec->output_offset
11451 + stub_entry->group->stub_sec->output_section->vma);
721956f4 11452
ad8e1ba5
AM		 11453 /* Reset the stub type from the plt variant in case we now
11454 can reach with a shorter stub. */
11455 if (stub_entry->stub_type >= ppc_stub_plt_branch)
11456 stub_entry->stub_type += ppc_stub_long_branch - ppc_stub_plt_branch;
11457
11458 size = 4;
11459 if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
11460 {
25f53a85 11461 r2off = get_r2off (info, stub_entry);
a7c49797 11462 if (r2off == (bfd_vma) -1)
aa374f67
AM		 11463 {
11464 htab->stub_error = TRUE;
11465 return FALSE;
11466 }
a7c49797 11467 size = 8;
ac2df442 11468 if (PPC_HA (r2off) != 0)
a7c49797
AM		 11469 size += 4;
11470 if (PPC_LO (r2off) != 0)
11471 size += 4;
ac2df442 11472 off -= size - 4;
ad8e1ba5
AM		 11473 }
11474
6911b7dc
AM		 11475 local_off = PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
11476
b9e5796b
AM		 11477 /* If the branch offset if too big, use a ppc_stub_plt_branch.
11478 Do the same for -R objects without function descriptors. */
11479 if (off + (1 << 25) >= (bfd_vma) (1 << 26) - local_off
11480 || (stub_entry->stub_type == ppc_stub_long_branch_r2off
a7c49797
AM		 11481 && r2off == 0
11482 && htab->sec_info[stub_entry->target_section->id].toc_off == 0))
721956f4
AM		 11483 {
11484 struct ppc_branch_hash_entry *br_entry;
11485
11486 br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
11487 stub_entry->root.string + 9,
b34976b6 11488 TRUE, FALSE);
721956f4
AM		 11489 if (br_entry == NULL)
11490 {
8de848d8 11491 info->callbacks->einfo (_("%P: can't build branch stub `%s'\n"),
25f53a85 11492 stub_entry->root.string);
b34976b6
AM		 11493 htab->stub_error = TRUE;
11494 return FALSE;
721956f4
AM		 11495 }
11496
11497 if (br_entry->iter != htab->stub_iteration)
11498 {
11499 br_entry->iter = htab->stub_iteration;
eea6121a
AM		 11500 br_entry->offset = htab->brlt->size;
11501 htab->brlt->size += 8;
63bc6f6c 11502
ee75fd95 11503 if (htab->relbrlt != NULL)
eea6121a 11504 htab->relbrlt->size += sizeof (Elf64_External_Rela);
84f5d08e
AM		 11505 else if (info->emitrelocations)
11506 {
11507 htab->brlt->reloc_count += 1;
11508 htab->brlt->flags |= SEC_RELOC;
11509 }
721956f4 11510 }
ad8e1ba5
AM		 11511
11512 stub_entry->stub_type += ppc_stub_plt_branch - ppc_stub_long_branch;
ac2df442
AM		 11513 off = (br_entry->offset
11514 + htab->brlt->output_offset
11515 + htab->brlt->output_section->vma
11516 - elf_gp (htab->brlt->output_section->owner)
6f20ed8a 11517 - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
ac2df442 11518
176a0d42
AM		 11519 if (info->emitrelocations)
11520 {
6f20ed8a
AM		 11521 stub_entry->group->stub_sec->reloc_count
11522 += 1 + (PPC_HA (off) != 0);
11523 stub_entry->group->stub_sec->flags |= SEC_RELOC;
176a0d42
AM		 11524 }
11525
00f412ee 11526 if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
ac2df442
AM		 11527 {
11528 size = 12;
176a0d42 11529 if (PPC_HA (off) != 0)
ac2df442
AM		 11530 size = 16;
11531 }
11532 else
11533 {
00f412ee 11534 size = 16;
176a0d42 11535 if (PPC_HA (off) != 0)
ac2df442
AM		 11536 size += 4;
11537
11538 if (PPC_HA (r2off) != 0)
11539 size += 4;
00f412ee
AM		 11540 if (PPC_LO (r2off) != 0)
11541 size += 4;
ac2df442 11542 }
721956f4 11543 }
84f5d08e
AM		 11544 else if (info->emitrelocations)
11545 {
6f20ed8a
AM		 11546 stub_entry->group->stub_sec->reloc_count += 1;
11547 stub_entry->group->stub_sec->flags |= SEC_RELOC;
84f5d08e 11548 }
721956f4
AM		 11549 }
11550
6f20ed8a 11551 stub_entry->group->stub_sec->size += size;
b34976b6 11552 return TRUE;
721956f4
AM		 11553}
11554
11555/* Set up various things so that we can make a list of input sections
11556 for each output section included in the link. Returns -1 on error,
cedb70c5 11557 0 when no stubs will be needed, and 1 on success. */
721956f4
AM		 11558
11559int
e7d1c40c 11560ppc64_elf_setup_section_lists (struct bfd_link_info *info)
721956f4 11561{
6f20ed8a 11562 unsigned int id;
721956f4
AM		 11563 bfd_size_type amt;
11564 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11565
4dfe6ac6
NC		 11566 if (htab == NULL)
11567 return -1;
4c52953f 11568
6f20ed8a
AM		 11569 htab->sec_info_arr_size = bfd_get_next_section_id ();
11570 amt = sizeof (*htab->sec_info) * (htab->sec_info_arr_size);
11571 htab->sec_info = bfd_zmalloc (amt);
11572 if (htab->sec_info == NULL)
721956f4
AM		 11573 return -1;
11574
3d6f9012
AM		 11575 /* Set toc_off for com, und, abs and ind sections. */
11576 for (id = 0; id < 3; id++)
6f20ed8a 11577 htab->sec_info[id].toc_off = TOC_BASE_OFF;
734b6cf9 11578
721956f4
AM		 11579 return 1;
11580}
11581
927be08e
AM		 11582/* Set up for first pass at multitoc partitioning. */
11583
11584void
11585ppc64_elf_start_multitoc_partition (struct bfd_link_info *info)
11586{
11587 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11588
1c865ab2 11589 htab->toc_curr = ppc64_elf_set_toc (info, info->output_bfd);
927be08e
AM		 11590 htab->toc_bfd = NULL;
11591 htab->toc_first_sec = NULL;
11592}
11593
e717da7e
AM		 11594/* The linker repeatedly calls this function for each TOC input section
11595 and linker generated GOT section. Group input bfds such that the toc
927be08e 11596 within a group is less than 64k in size. */
ad8e1ba5 11597
927be08e 11598bfd_boolean
4ce794b7 11599ppc64_elf_next_toc_section (struct bfd_link_info *info, asection *isec)
ad8e1ba5
AM		 11600{
11601 struct ppc_link_hash_table *htab = ppc_hash_table (info);
d77c8a4b 11602 bfd_vma addr, off, limit;
ad8e1ba5 11603
4dfe6ac6
NC		 11604 if (htab == NULL)
11605 return FALSE;
11606
927be08e 11607 if (!htab->second_toc_pass)
4c52953f 11608 {
927be08e 11609 /* Keep track of the first .toc or .got section for this input bfd. */
a4fd3de5
AM		 11610 bfd_boolean new_bfd = htab->toc_bfd != isec->owner;
11611
11612 if (new_bfd)
bf102f86
AM		 11613 {
11614 htab->toc_bfd = isec->owner;
11615 htab->toc_first_sec = isec;
11616 }
927be08e 11617
bf102f86
AM		 11618 addr = isec->output_offset + isec->output_section->vma;
11619 off = addr - htab->toc_curr;
d77c8a4b
AM		 11620 limit = 0x80008000;
11621 if (ppc64_elf_tdata (isec->owner)->has_small_toc_reloc)
11622 limit = 0x10000;
11623 if (off + isec->size > limit)
bf102f86
AM		 11624 {
11625 addr = (htab->toc_first_sec->output_offset
11626 + htab->toc_first_sec->output_section->vma);
11627 htab->toc_curr = addr;
a27e685f 11628 htab->toc_curr &= -TOC_BASE_ALIGN;
bf102f86 11629 }
99877b66 11630
927be08e
AM		 11631 /* toc_curr is the base address of this toc group. Set elf_gp
11632 for the input section to be the offset relative to the
11633 output toc base plus 0x8000. Making the input elf_gp an
11634 offset allows us to move the toc as a whole without
11635 recalculating input elf_gp. */
11636 off = htab->toc_curr - elf_gp (isec->output_section->owner);
11637 off += TOC_BASE_OFF;
11638
11639 /* Die if someone uses a linker script that doesn't keep input
11640 file .toc and .got together. */
a4fd3de5
AM		 11641 if (new_bfd
11642 && elf_gp (isec->owner) != 0
927be08e
AM		 11643 && elf_gp (isec->owner) != off)
11644 return FALSE;
11645
11646 elf_gp (isec->owner) = off;
11647 return TRUE;
4c52953f 11648 }
927be08e
AM		 11649
11650 /* During the second pass toc_first_sec points to the start of
11651 a toc group, and toc_curr is used to track the old elf_gp.
11652 We use toc_bfd to ensure we only look at each bfd once. */
11653 if (htab->toc_bfd == isec->owner)
11654 return TRUE;
11655 htab->toc_bfd = isec->owner;
11656
11657 if (htab->toc_first_sec == NULL
11658 || htab->toc_curr != elf_gp (isec->owner))
11659 {
11660 htab->toc_curr = elf_gp (isec->owner);
11661 htab->toc_first_sec = isec;
11662 }
11663 addr = (htab->toc_first_sec->output_offset
11664 + htab->toc_first_sec->output_section->vma);
11665 off = addr - elf_gp (isec->output_section->owner) + TOC_BASE_OFF;
11666 elf_gp (isec->owner) = off;
11667
11668 return TRUE;
ad8e1ba5
AM		 11669}
11670
927be08e
AM		 11671/* Called via elf_link_hash_traverse to merge GOT entries for global
11672 symbol H. */
11673
11674static bfd_boolean
11675merge_global_got (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
11676{
11677 if (h->root.type == bfd_link_hash_indirect)
11678 return TRUE;
11679
927be08e
AM		 11680 merge_got_entries (&h->got.glist);
11681
11682 return TRUE;
11683}
11684
11685/* Called via elf_link_hash_traverse to allocate GOT entries for global
11686 symbol H. */
11687
11688static bfd_boolean
11689reallocate_got (struct elf_link_hash_entry *h, void *inf)
11690{
11691 struct got_entry *gent;
11692
11693 if (h->root.type == bfd_link_hash_indirect)
11694 return TRUE;
11695
927be08e
AM		 11696 for (gent = h->got.glist; gent != NULL; gent = gent->next)
11697 if (!gent->is_indirect)
11698 allocate_got (h, (struct bfd_link_info *) inf, gent);
11699 return TRUE;
11700}
11701
11702/* Called on the first multitoc pass after the last call to
11703 ppc64_elf_next_toc_section. This function removes duplicate GOT
11704 entries. */
11705
11706bfd_boolean
11707ppc64_elf_layout_multitoc (struct bfd_link_info *info)
ad8e1ba5
AM		 11708{
11709 struct ppc_link_hash_table *htab = ppc_hash_table (info);
927be08e
AM		 11710 struct bfd *ibfd, *ibfd2;
11711 bfd_boolean done_something;
11712
11713 htab->multi_toc_needed = htab->toc_curr != elf_gp (info->output_bfd);
ad8e1ba5 11714
7865406b
AM		 11715 if (!htab->do_multi_toc)
11716 return FALSE;
11717
d0fae19d 11718 /* Merge global sym got entries within a toc group. */
927be08e
AM		 11719 elf_link_hash_traverse (&htab->elf, merge_global_got, info);
11720
11721 /* And tlsld_got. */
c72f2fb2 11722 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
927be08e
AM		 11723 {
11724 struct got_entry *ent, *ent2;
11725
11726 if (!is_ppc64_elf (ibfd))
11727 continue;
11728
11729 ent = ppc64_tlsld_got (ibfd);
11730 if (!ent->is_indirect
11731 && ent->got.offset != (bfd_vma) -1)
11732 {
c72f2fb2 11733 for (ibfd2 = ibfd->link.next; ibfd2 != NULL; ibfd2 = ibfd2->link.next)
927be08e
AM		 11734 {
11735 if (!is_ppc64_elf (ibfd2))
11736 continue;
11737
11738 ent2 = ppc64_tlsld_got (ibfd2);
11739 if (!ent2->is_indirect
11740 && ent2->got.offset != (bfd_vma) -1
11741 && elf_gp (ibfd2) == elf_gp (ibfd))
11742 {
11743 ent2->is_indirect = TRUE;
11744 ent2->got.ent = ent;
11745 }
11746 }
11747 }
11748 }
11749
11750 /* Zap sizes of got sections. */
33e44f2e
AM		 11751 htab->elf.irelplt->rawsize = htab->elf.irelplt->size;
11752 htab->elf.irelplt->size -= htab->got_reli_size;
927be08e
AM		 11753 htab->got_reli_size = 0;
11754
c72f2fb2 11755 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
927be08e
AM		 11756 {
11757 asection *got, *relgot;
11758
11759 if (!is_ppc64_elf (ibfd))
11760 continue;
11761
11762 got = ppc64_elf_tdata (ibfd)->got;
11763 if (got != NULL)
11764 {
11765 got->rawsize = got->size;
11766 got->size = 0;
11767 relgot = ppc64_elf_tdata (ibfd)->relgot;
11768 relgot->rawsize = relgot->size;
11769 relgot->size = 0;
11770 }
11771 }
11772
11773 /* Now reallocate the got, local syms first. We don't need to
11774 allocate section contents again since we never increase size. */
c72f2fb2 11775 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
927be08e
AM		 11776 {
11777 struct got_entry **lgot_ents;
11778 struct got_entry **end_lgot_ents;
11779 struct plt_entry **local_plt;
11780 struct plt_entry **end_local_plt;
f961d9dd 11781 unsigned char *lgot_masks;
927be08e
AM		 11782 bfd_size_type locsymcount;
11783 Elf_Internal_Shdr *symtab_hdr;
19e08130 11784 asection *s;
927be08e
AM		 11785
11786 if (!is_ppc64_elf (ibfd))
11787 continue;
11788
11789 lgot_ents = elf_local_got_ents (ibfd);
11790 if (!lgot_ents)
11791 continue;
11792
11793 symtab_hdr = &elf_symtab_hdr (ibfd);
11794 locsymcount = symtab_hdr->sh_info;
11795 end_lgot_ents = lgot_ents + locsymcount;
11796 local_plt = (struct plt_entry **) end_lgot_ents;
11797 end_local_plt = local_plt + locsymcount;
f961d9dd 11798 lgot_masks = (unsigned char *) end_local_plt;
927be08e 11799 s = ppc64_elf_tdata (ibfd)->got;
927be08e
AM		 11800 for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
11801 {
11802 struct got_entry *ent;
11803
11804 for (ent = *lgot_ents; ent != NULL; ent = ent->next)
d0fae19d 11805 {
19e08130
AM		 11806 unsigned int ent_size = 8;
11807 unsigned int rel_size = sizeof (Elf64_External_Rela);
11808
d0fae19d
AM		 11809 ent->got.offset = s->size;
11810 if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
d0fae19d 11811 {
19e08130
AM		 11812 ent_size *= 2;
11813 rel_size *= 2;
11814 }
11815 s->size += ent_size;
11816 if ((*lgot_masks & PLT_IFUNC) != 0)
11817 {
33e44f2e 11818 htab->elf.irelplt->size += rel_size;
19e08130
AM		 11819 htab->got_reli_size += rel_size;
11820 }
0e1862bb 11821 else if (bfd_link_pic (info))
19e08130
AM		 11822 {
11823 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
11824 srel->size += rel_size;
d0fae19d
AM		 11825 }
11826 }
927be08e
AM		 11827 }
11828 }
11829
11830 elf_link_hash_traverse (&htab->elf, reallocate_got, info);
11831
c72f2fb2 11832 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
927be08e
AM		 11833 {
11834 struct got_entry *ent;
11835
11836 if (!is_ppc64_elf (ibfd))
11837 continue;
11838
11839 ent = ppc64_tlsld_got (ibfd);
11840 if (!ent->is_indirect
11841 && ent->got.offset != (bfd_vma) -1)
11842 {
11843 asection *s = ppc64_elf_tdata (ibfd)->got;
11844 ent->got.offset = s->size;
11845 s->size += 16;
0e1862bb 11846 if (bfd_link_pic (info))
927be08e
AM		 11847 {
11848 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
11849 srel->size += sizeof (Elf64_External_Rela);
11850 }
11851 }
11852 }
11853
33e44f2e 11854 done_something = htab->elf.irelplt->rawsize != htab->elf.irelplt->size;
927be08e 11855 if (!done_something)
c72f2fb2 11856 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
927be08e
AM		 11857 {
11858 asection *got;
11859
11860 if (!is_ppc64_elf (ibfd))
11861 continue;
11862
11863 got = ppc64_elf_tdata (ibfd)->got;
11864 if (got != NULL)
11865 {
11866 done_something = got->rawsize != got->size;
11867 if (done_something)
11868 break;
11869 }
11870 }
11871
11872 if (done_something)
e7d1c40c 11873 (*htab->params->layout_sections_again) ();
927be08e
AM		 11874
11875 /* Set up for second pass over toc sections to recalculate elf_gp
11876 on input sections. */
11877 htab->toc_bfd = NULL;
11878 htab->toc_first_sec = NULL;
11879 htab->second_toc_pass = TRUE;
11880 return done_something;
11881}
11882
11883/* Called after second pass of multitoc partitioning. */
11884
11885void
11886ppc64_elf_finish_multitoc_partition (struct bfd_link_info *info)
11887{
11888 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11889
11890 /* After the second pass, toc_curr tracks the TOC offset used
11891 for code sections below in ppc64_elf_next_input_section. */
3d6f9012 11892 htab->toc_curr = TOC_BASE_OFF;
ad8e1ba5
AM		 11893}
11894
9b5ecbd0
AM		 11895/* No toc references were found in ISEC. If the code in ISEC makes no
11896 calls, then there's no need to use toc adjusting stubs when branching
11897 into ISEC. Actually, indirect calls from ISEC are OK as they will
4c52953f
AM		 11898 load r2. Returns -1 on error, 0 for no stub needed, 1 for stub
11899 needed, and 2 if a cyclical call-graph was found but no other reason
11900 for a stub was detected. If called from the top level, a return of
11901 2 means the same as a return of 0. */
9b5ecbd0
AM		 11902
11903static int
4ce794b7 11904toc_adjusting_stub_needed (struct bfd_link_info *info, asection *isec)
9b5ecbd0 11905{
9b5ecbd0 11906 int ret;
70cc837d
AM		 11907
11908 /* Mark this section as checked. */
11909 isec->call_check_done = 1;
9b5ecbd0 11910
772119ce
AM		 11911 /* We know none of our code bearing sections will need toc stubs. */
11912 if ((isec->flags & SEC_LINKER_CREATED) != 0)
11913 return 0;
11914
eea6121a 11915 if (isec->size == 0)
082c50f8
AM		 11916 return 0;
11917
4c52953f
AM		 11918 if (isec->output_section == NULL)
11919 return 0;
11920
4c52953f 11921 ret = 0;
70cc837d 11922 if (isec->reloc_count != 0)
9b5ecbd0 11923 {
70cc837d
AM		 11924 Elf_Internal_Rela *relstart, *rel;
11925 Elf_Internal_Sym *local_syms;
11926 struct ppc_link_hash_table *htab;
2917689a 11927
70cc837d
AM		 11928 relstart = _bfd_elf_link_read_relocs (isec->owner, isec, NULL, NULL,
11929 info->keep_memory);
11930 if (relstart == NULL)
11931 return -1;
90aecf7a 11932
70cc837d
AM		 11933 /* Look for branches to outside of this section. */
11934 local_syms = NULL;
11935 htab = ppc_hash_table (info);
11936 if (htab == NULL)
11937 return -1;
4c52953f 11938
70cc837d 11939 for (rel = relstart; rel < relstart + isec->reloc_count; ++rel)
4c52953f 11940 {
70cc837d
AM		 11941 enum elf_ppc64_reloc_type r_type;
11942 unsigned long r_symndx;
11943 struct elf_link_hash_entry *h;
11944 struct ppc_link_hash_entry *eh;
11945 Elf_Internal_Sym *sym;
11946 asection *sym_sec;
11947 struct _opd_sec_data *opd;
11948 bfd_vma sym_value;
11949 bfd_vma dest;
11950
11951 r_type = ELF64_R_TYPE (rel->r_info);
11952 if (r_type != R_PPC64_REL24
11953 && r_type != R_PPC64_REL14
11954 && r_type != R_PPC64_REL14_BRTAKEN
11955 && r_type != R_PPC64_REL14_BRNTAKEN)
11956 continue;
4c52953f 11957
70cc837d
AM		 11958 r_symndx = ELF64_R_SYM (rel->r_info);
11959 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms, r_symndx,
11960 isec->owner))
4c52953f 11961 {
70cc837d
AM		 11962 ret = -1;
11963 break;
11964 }
4c52953f 11965
70cc837d
AM		 11966 /* Calls to dynamic lib functions go through a plt call stub
11967 that uses r2. */
11968 eh = (struct ppc_link_hash_entry *) h;
11969 if (eh != NULL
11970 && (eh->elf.plt.plist != NULL
11971 || (eh->oh != NULL
11972 && ppc_follow_link (eh->oh)->elf.plt.plist != NULL)))
11973 {
11974 ret = 1;
11975 break;
4c52953f
AM		 11976 }
11977
70cc837d
AM		 11978 if (sym_sec == NULL)
11979 /* Ignore other undefined symbols. */
4c52953f 11980 continue;
4c52953f 11981
70cc837d
AM		 11982 /* Assume branches to other sections not included in the
11983 link need stubs too, to cover -R and absolute syms. */
11984 if (sym_sec->output_section == NULL)
11985 {
11986 ret = 1;
11987 break;
11988 }
4c52953f 11989
70cc837d
AM		 11990 if (h == NULL)
11991 sym_value = sym->st_value;
11992 else
11993 {
11994 if (h->root.type != bfd_link_hash_defined
11995 && h->root.type != bfd_link_hash_defweak)
11996 abort ();
11997 sym_value = h->root.u.def.value;
11998 }
11999 sym_value += rel->r_addend;
4c52953f 12000
70cc837d
AM		 12001 /* If this branch reloc uses an opd sym, find the code section. */
12002 opd = get_opd_info (sym_sec);
12003 if (opd != NULL)
12004 {
12005 if (h == NULL && opd->adjust != NULL)
12006 {
12007 long adjust;
4c52953f 12008
92a9c616 12009 adjust = opd->adjust[OPD_NDX (sym_value)];
70cc837d
AM		 12010 if (adjust == -1)
12011 /* Assume deleted functions won't ever be called. */
12012 continue;
12013 sym_value += adjust;
12014 }
4c52953f 12015
aef36ac1
AM		 12016 dest = opd_entry_value (sym_sec, sym_value,
12017 &sym_sec, NULL, FALSE);
70cc837d
AM		 12018 if (dest == (bfd_vma) -1)
12019 continue;
12020 }
12021 else
12022 dest = (sym_value
12023 + sym_sec->output_offset
12024 + sym_sec->output_section->vma);
4c52953f 12025
70cc837d
AM		 12026 /* Ignore branch to self. */
12027 if (sym_sec == isec)
12028 continue;
4c52953f 12029
70cc837d
AM		 12030 /* If the called function uses the toc, we need a stub. */
12031 if (sym_sec->has_toc_reloc
12032 || sym_sec->makes_toc_func_call)
4c52953f 12033 {
70cc837d 12034 ret = 1;
4c52953f
AM		 12035 break;
12036 }
70cc837d
AM		 12037
12038 /* Assume any branch that needs a long branch stub might in fact
12039 need a plt_branch stub. A plt_branch stub uses r2. */
12040 else if (dest - (isec->output_offset
12041 + isec->output_section->vma
6911b7dc
AM		 12042 + rel->r_offset) + (1 << 25)
12043 >= (2u << 25) - PPC64_LOCAL_ENTRY_OFFSET (h
12044 ? h->other
12045 : sym->st_other))
4c52953f 12046 {
70cc837d
AM		 12047 ret = 1;
12048 break;
12049 }
12050
12051 /* If calling back to a section in the process of being
12052 tested, we can't say for sure that no toc adjusting stubs
12053 are needed, so don't return zero. */
12054 else if (sym_sec->call_check_in_progress)
12055 ret = 2;
12056
12057 /* Branches to another section that itself doesn't have any TOC
12058 references are OK. Recursively call ourselves to check. */
12059 else if (!sym_sec->call_check_done)
12060 {
12061 int recur;
12062
12063 /* Mark current section as indeterminate, so that other
12064 sections that call back to current won't be marked as
12065 known. */
12066 isec->call_check_in_progress = 1;
12067 recur = toc_adjusting_stub_needed (info, sym_sec);
12068 isec->call_check_in_progress = 0;
12069
4c52953f
AM		 12070 if (recur != 0)
12071 {
70cc837d
AM		 12072 ret = recur;
12073 if (recur != 2)
12074 break;
4c52953f
AM		 12075 }
12076 }
4c52953f 12077 }
70cc837d
AM		 12078
12079 if (local_syms != NULL
12080 && (elf_symtab_hdr (isec->owner).contents
12081 != (unsigned char *) local_syms))
12082 free (local_syms);
12083 if (elf_section_data (isec)->relocs != relstart)
12084 free (relstart);
9b5ecbd0
AM		 12085 }
12086
70cc837d
AM		 12087 if ((ret & 1) == 0
12088 && isec->map_head.s != NULL
12089 && (strcmp (isec->output_section->name, ".init") == 0
12090 || strcmp (isec->output_section->name, ".fini") == 0))
12091 {
12092 if (isec->map_head.s->has_toc_reloc
12093 || isec->map_head.s->makes_toc_func_call)
12094 ret = 1;
12095 else if (!isec->map_head.s->call_check_done)
12096 {
12097 int recur;
12098 isec->call_check_in_progress = 1;
12099 recur = toc_adjusting_stub_needed (info, isec->map_head.s);
12100 isec->call_check_in_progress = 0;
12101 if (recur != 0)
12102 ret = recur;
12103 }
12104 }
12105
12106 if (ret == 1)
12107 isec->makes_toc_func_call = 1;
4c52953f 12108
9b5ecbd0
AM		 12109 return ret;
12110}
12111
721956f4
AM		 12112/* The linker repeatedly calls this function for each input section,
12113 in the order that input sections are linked into output sections.
12114 Build lists of input sections to determine groupings between which
12115 we may insert linker stubs. */
12116
9b5ecbd0 12117bfd_boolean
4ce794b7 12118ppc64_elf_next_input_section (struct bfd_link_info *info, asection *isec)
721956f4
AM		 12119{
12120 struct ppc_link_hash_table *htab = ppc_hash_table (info);
12121
4dfe6ac6
NC		 12122 if (htab == NULL)
12123 return FALSE;
12124
734b6cf9 12125 if ((isec->output_section->flags & SEC_CODE) != 0
6f20ed8a 12126 && isec->output_section->id < htab->sec_info_arr_size)
721956f4 12127 {
3d6f9012
AM		 12128 /* This happens to make the list in reverse order,
12129 which is what we want. */
6f20ed8a
AM		 12130 htab->sec_info[isec->id].u.list
12131 = htab->sec_info[isec->output_section->id].u.list;
12132 htab->sec_info[isec->output_section->id].u.list = isec;
721956f4 12133 }
ad8e1ba5 12134
4c52953f 12135 if (htab->multi_toc_needed)
9b5ecbd0 12136 {
8b974ba3
AM		 12137 /* Analyse sections that aren't already flagged as needing a
12138 valid toc pointer. Exclude .fixup for the linux kernel.
12139 .fixup contains branches, but only back to the function that
12140 hit an exception. */
12141 if (!(isec->has_toc_reloc
12142 || (isec->flags & SEC_CODE) == 0
12143 || strcmp (isec->name, ".fixup") == 0
12144 || isec->call_check_done))
12145 {
12146 if (toc_adjusting_stub_needed (info, isec) < 0)
6683a28d 12147 return FALSE;
8b974ba3
AM		 12148 }
12149 /* Make all sections use the TOC assigned for this object file.
12150 This will be wrong for pasted sections; We fix that in
12151 check_pasted_section(). */
12152 if (elf_gp (isec->owner) != 0)
12153 htab->toc_curr = elf_gp (isec->owner);
12154 }
12155
6f20ed8a 12156 htab->sec_info[isec->id].toc_off = htab->toc_curr;
9b5ecbd0 12157 return TRUE;
721956f4
AM		 12158}
12159
70cc837d
AM		 12160/* Check that all .init and .fini sections use the same toc, if they
12161 have toc relocs. */
12162
12163static bfd_boolean
12164check_pasted_section (struct bfd_link_info *info, const char *name)
12165{
12166 asection *o = bfd_get_section_by_name (info->output_bfd, name);
12167
12168 if (o != NULL)
12169 {
12170 struct ppc_link_hash_table *htab = ppc_hash_table (info);
12171 bfd_vma toc_off = 0;
12172 asection *i;
12173
12174 for (i = o->map_head.s; i != NULL; i = i->map_head.s)
12175 if (i->has_toc_reloc)
12176 {
12177 if (toc_off == 0)
6f20ed8a
AM		 12178 toc_off = htab->sec_info[i->id].toc_off;
12179 else if (toc_off != htab->sec_info[i->id].toc_off)
70cc837d
AM		 12180 return FALSE;
12181 }
6683a28d
AM		 12182
12183 if (toc_off == 0)
12184 for (i = o->map_head.s; i != NULL; i = i->map_head.s)
12185 if (i->makes_toc_func_call)
12186 {
6f20ed8a 12187 toc_off = htab->sec_info[i->id].toc_off;
6683a28d
AM		 12188 break;
12189 }
12190
70cc837d
AM		 12191 /* Make sure the whole pasted function uses the same toc offset. */
12192 if (toc_off != 0)
12193 for (i = o->map_head.s; i != NULL; i = i->map_head.s)
6f20ed8a 12194 htab->sec_info[i->id].toc_off = toc_off;
70cc837d
AM		 12195 }
12196 return TRUE;
12197}
12198
12199bfd_boolean
12200ppc64_elf_check_init_fini (struct bfd_link_info *info)
12201{
12202 return (check_pasted_section (info, ".init")
12203 & check_pasted_section (info, ".fini"));
12204}
12205
721956f4
AM		 12206/* See whether we can group stub sections together. Grouping stub
12207 sections may result in fewer stubs. More importantly, we need to
12208 put all .init* and .fini* stubs at the beginning of the .init or
12209 .fini output sections respectively, because glibc splits the
12210 _init and _fini functions into multiple parts. Putting a stub in
12211 the middle of a function is not a good idea. */
12212
6f20ed8a
AM		 12213static bfd_boolean
12214group_sections (struct bfd_link_info *info,
4ce794b7
AM		 12215 bfd_size_type stub_group_size,
12216 bfd_boolean stubs_always_before_branch)
721956f4 12217{
6f20ed8a
AM		 12218 struct ppc_link_hash_table *htab;
12219 asection *osec;
7c8fe5c4
AM		 12220 bfd_boolean suppress_size_errors;
12221
6f20ed8a
AM		 12222 htab = ppc_hash_table (info);
12223 if (htab == NULL)
12224 return FALSE;
12225
7c8fe5c4 12226 suppress_size_errors = FALSE;
7c8fe5c4
AM		 12227 if (stub_group_size == 1)
12228 {
12229 /* Default values. */
12230 if (stubs_always_before_branch)
09f92717 12231 stub_group_size = 0x1e00000;
7c8fe5c4 12232 else
09f92717 12233 stub_group_size = 0x1c00000;
7c8fe5c4
AM		 12234 suppress_size_errors = TRUE;
12235 }
12236
6f20ed8a 12237 for (osec = info->output_bfd->sections; osec != NULL; osec = osec->next)
721956f4 12238 {
6f20ed8a
AM		 12239 asection *tail;
12240
12241 if (osec->id >= htab->sec_info_arr_size)
12242 continue;
12243
12244 tail = htab->sec_info[osec->id].u.list;
734b6cf9 12245 while (tail != NULL)
721956f4 12246 {
734b6cf9
AM		 12247 asection *curr;
12248 asection *prev;
12249 bfd_size_type total;
12250 bfd_boolean big_sec;
12251 bfd_vma curr_toc;
6f20ed8a 12252 struct map_stub *group;
09f92717 12253 bfd_size_type group_size;
734b6cf9
AM		 12254
12255 curr = tail;
eea6121a 12256 total = tail->size;
09f92717
AM		 12257 group_size = (ppc64_elf_section_data (tail) != NULL
12258 && ppc64_elf_section_data (tail)->has_14bit_branch
12259 ? stub_group_size >> 10 : stub_group_size);
12260
12261 big_sec = total > group_size;
7c8fe5c4 12262 if (big_sec && !suppress_size_errors)
695344c0 12263 /* xgettext:c-format */
4eca0228
AM		 12264 _bfd_error_handler (_("%B section %A exceeds stub group size"),
12265 tail->owner, tail);
6f20ed8a 12266 curr_toc = htab->sec_info[tail->id].toc_off;
734b6cf9 12267
6f20ed8a 12268 while ((prev = htab->sec_info[curr->id].u.list) != NULL
734b6cf9 12269 && ((total += curr->output_offset - prev->output_offset)
6bee8834
AM		 12270 < (ppc64_elf_section_data (prev) != NULL
12271 && ppc64_elf_section_data (prev)->has_14bit_branch
09f92717 12272 ? (group_size = stub_group_size >> 10) : group_size))
6f20ed8a 12273 && htab->sec_info[prev->id].toc_off == curr_toc)
734b6cf9
AM		 12274 curr = prev;
12275
12276 /* OK, the size from the start of CURR to the end is less
09f92717 12277 than group_size and thus can be handled by one stub
734b6cf9 12278 section. (or the tail section is itself larger than
09f92717
AM		 12279 group_size, in which case we may be toast.) We should
12280 really be keeping track of the total size of stubs added
12281 here, as stubs contribute to the final output section
12282 size. That's a little tricky, and this way will only
12283 break if stubs added make the total size more than 2^25,
12284 ie. for the default stub_group_size, if stubs total more
12285 than 2097152 bytes, or nearly 75000 plt call stubs. */
6f20ed8a
AM		 12286 group = bfd_alloc (curr->owner, sizeof (*group));
12287 if (group == NULL)
12288 return FALSE;
12289 group->link_sec = curr;
12290 group->stub_sec = NULL;
a4b6fadd 12291 group->needs_save_res = 0;
d4aaa2a0 12292 group->tls_get_addr_opt_bctrl = -1u;
a4b6fadd
AM		 12293 group->next = htab->group;
12294 htab->group = group;
734b6cf9 12295 do
721956f4 12296 {
6f20ed8a 12297 prev = htab->sec_info[tail->id].u.list;
734b6cf9 12298 /* Set up this stub group. */
6f20ed8a 12299 htab->sec_info[tail->id].u.group = group;
721956f4 12300 }
734b6cf9
AM		 12301 while (tail != curr && (tail = prev) != NULL);
12302
09f92717 12303 /* But wait, there's more! Input sections up to group_size
734b6cf9
AM		 12304 bytes before the stub section can be handled by it too.
12305 Don't do this if we have a really large section after the
12306 stubs, as adding more stubs increases the chance that
12307 branches may not reach into the stub section. */
12308 if (!stubs_always_before_branch && !big_sec)
12309 {
12310 total = 0;
12311 while (prev != NULL
12312 && ((total += tail->output_offset - prev->output_offset)
6bee8834
AM		 12313 < (ppc64_elf_section_data (prev) != NULL
12314 && ppc64_elf_section_data (prev)->has_14bit_branch
09f92717 12315 ? (group_size = stub_group_size >> 10) : group_size))
6f20ed8a 12316 && htab->sec_info[prev->id].toc_off == curr_toc)
734b6cf9
AM		 12317 {
12318 tail = prev;
6f20ed8a
AM		 12319 prev = htab->sec_info[tail->id].u.list;
12320 htab->sec_info[tail->id].u.group = group;
734b6cf9
AM		 12321 }
12322 }
12323 tail = prev;
721956f4
AM		 12324 }
12325 }
6f20ed8a 12326 return TRUE;
721956f4
AM		 12327}
12328
58d180e8
AM		 12329static const unsigned char glink_eh_frame_cie[] =
12330{
12331 0, 0, 0, 16, /* length. */
12332 0, 0, 0, 0, /* id. */
12333 1, /* CIE version. */
12334 'z', 'R', 0, /* Augmentation string. */
12335 4, /* Code alignment. */
12336 0x78, /* Data alignment. */
12337 65, /* RA reg. */
12338 1, /* Augmentation size. */
12339 DW_EH_PE_pcrel | DW_EH_PE_sdata4, /* FDE encoding. */
2e0ce1c8 12340 DW_CFA_def_cfa, 1, 0 /* def_cfa: r1 offset 0. */
58d180e8
AM		 12341};
12342
d4aaa2a0
AM		 12343static size_t
12344stub_eh_frame_size (struct map_stub *group, size_t align)
12345{
12346 size_t this_size = 17;
12347 if (group->tls_get_addr_opt_bctrl != -1u)
12348 {
12349 unsigned int to_bctrl = group->tls_get_addr_opt_bctrl / 4;
12350 if (to_bctrl < 64)
12351 this_size += 1;
12352 else if (to_bctrl < 256)
12353 this_size += 2;
12354 else if (to_bctrl < 65536)
12355 this_size += 3;
12356 else
12357 this_size += 5;
12358 this_size += 6;
12359 }
12360 this_size = (this_size + align - 1) & -align;
12361 return this_size;
12362}
12363
d969d15f
AM		 12364/* Stripping output sections is normally done before dynamic section
12365 symbols have been allocated. This function is called later, and
12366 handles cases like htab->brlt which is mapped to its own output
12367 section. */
12368
12369static void
12370maybe_strip_output (struct bfd_link_info *info, asection *isec)
12371{
12372 if (isec->size == 0
12373 && isec->output_section->size == 0
53d8967a 12374 && !(isec->output_section->flags & SEC_KEEP)
d969d15f
AM		 12375 && !bfd_section_removed_from_list (info->output_bfd,
12376 isec->output_section)
12377 && elf_section_data (isec->output_section)->dynindx == 0)
12378 {
12379 isec->output_section->flags |= SEC_EXCLUDE;
12380 bfd_section_list_remove (info->output_bfd, isec->output_section);
12381 info->output_bfd->section_count--;
12382 }
12383}
12384
721956f4
AM		 12385/* Determine and set the size of the stub section for a final link.
12386
12387 The basic idea here is to examine all the relocations looking for
12388 PC-relative calls to a target that is unreachable with a "bl"
12389 instruction. */
12390
b34976b6 12391bfd_boolean
e7d1c40c 12392ppc64_elf_size_stubs (struct bfd_link_info *info)
721956f4
AM		 12393{
12394 bfd_size_type stub_group_size;
b34976b6 12395 bfd_boolean stubs_always_before_branch;
721956f4
AM		 12396 struct ppc_link_hash_table *htab = ppc_hash_table (info);
12397
4dfe6ac6
NC		 12398 if (htab == NULL)
12399 return FALSE;
12400
0e1862bb 12401 if (htab->params->plt_thread_safe == -1 && !bfd_link_executable (info))
e7d1c40c 12402 htab->params->plt_thread_safe = 1;
b9e5796b 12403 if (!htab->opd_abi)
e7d1c40c
AM		 12404 htab->params->plt_thread_safe = 0;
12405 else if (htab->params->plt_thread_safe == -1)
794e51c0 12406 {
e2458743 12407 static const char *const thread_starter[] =
794e51c0
AM		 12408 {
12409 "pthread_create",
12410 /* libstdc++ */
12411 "_ZNSt6thread15_M_start_threadESt10shared_ptrINS_10_Impl_baseEE",
12412 /* librt */
12413 "aio_init", "aio_read", "aio_write", "aio_fsync", "lio_listio",
12414 "mq_notify", "create_timer",
12415 /* libanl */
12416 "getaddrinfo_a",
12417 /* libgomp */
2300b5a1 12418 "GOMP_parallel",
794e51c0 12419 "GOMP_parallel_start",
2300b5a1 12420 "GOMP_parallel_loop_static",
794e51c0 12421 "GOMP_parallel_loop_static_start",
2300b5a1 12422 "GOMP_parallel_loop_dynamic",
794e51c0 12423 "GOMP_parallel_loop_dynamic_start",
2300b5a1 12424 "GOMP_parallel_loop_guided",
794e51c0 12425 "GOMP_parallel_loop_guided_start",
2300b5a1 12426 "GOMP_parallel_loop_runtime",
794e51c0 12427 "GOMP_parallel_loop_runtime_start",
2300b5a1 12428 "GOMP_parallel_sections",
68ffbac6 12429 "GOMP_parallel_sections_start",
f9dffbf0
AM		 12430 /* libgo */
12431 "__go_go",
794e51c0
AM		 12432 };
12433 unsigned i;
12434
a4b6fadd 12435 for (i = 0; i < ARRAY_SIZE (thread_starter); i++)
794e51c0
AM		 12436 {
12437 struct elf_link_hash_entry *h;
12438 h = elf_link_hash_lookup (&htab->elf, thread_starter[i],
12439 FALSE, FALSE, TRUE);
e7d1c40c
AM		 12440 htab->params->plt_thread_safe = h != NULL && h->ref_regular;
12441 if (htab->params->plt_thread_safe)
794e51c0
AM		 12442 break;
12443 }
12444 }
e7d1c40c
AM		 12445 stubs_always_before_branch = htab->params->group_size < 0;
12446 if (htab->params->group_size < 0)
12447 stub_group_size = -htab->params->group_size;
721956f4 12448 else
e7d1c40c 12449 stub_group_size = htab->params->group_size;
721956f4 12450
6f20ed8a
AM		 12451 if (!group_sections (info, stub_group_size, stubs_always_before_branch))
12452 return FALSE;
721956f4 12453
c9301e31
AM		 12454#define STUB_SHRINK_ITER 20
12455 /* Loop until no stubs added. After iteration 20 of this loop we may
12456 exit on a stub section shrinking. This is to break out of a
12457 pathological case where adding stubs on one iteration decreases
12458 section gaps (perhaps due to alignment), which then requires
12459 fewer or smaller stubs on the next iteration. */
12460
721956f4
AM		 12461 while (1)
12462 {
12463 bfd *input_bfd;
12464 unsigned int bfd_indx;
a4b6fadd 12465 struct map_stub *group;
721956f4
AM		 12466
12467 htab->stub_iteration += 1;
721956f4
AM		 12468
12469 for (input_bfd = info->input_bfds, bfd_indx = 0;
12470 input_bfd != NULL;
c72f2fb2 12471 input_bfd = input_bfd->link.next, bfd_indx++)
721956f4
AM		 12472 {
12473 Elf_Internal_Shdr *symtab_hdr;
12474 asection *section;
6cdc0ccc 12475 Elf_Internal_Sym *local_syms = NULL;
721956f4 12476
0c8d6e5c 12477 if (!is_ppc64_elf (input_bfd))
67f93c31
AM		 12478 continue;
12479
721956f4 12480 /* We'll need the symbol table in a second. */
0ffa91dd 12481 symtab_hdr = &elf_symtab_hdr (input_bfd);
721956f4
AM		 12482 if (symtab_hdr->sh_info == 0)
12483 continue;
12484
721956f4
AM		 12485 /* Walk over each section attached to the input bfd. */
12486 for (section = input_bfd->sections;
12487 section != NULL;
12488 section = section->next)
12489 {
721956f4 12490 Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
721956f4
AM		 12491
12492 /* If there aren't any relocs, then there's nothing more
12493 to do. */
12494 if ((section->flags & SEC_RELOC) == 0
12c0f757
AM		 12495 || (section->flags & SEC_ALLOC) == 0
12496 || (section->flags & SEC_LOAD) == 0
12497 || (section->flags & SEC_CODE) == 0
721956f4
AM		 12498 || section->reloc_count == 0)
12499 continue;
12500
12501 /* If this section is a link-once section that will be
12502 discarded, then don't create any stubs. */
12503 if (section->output_section == NULL
927be08e 12504 || section->output_section->owner != info->output_bfd)
721956f4
AM		 12505 continue;
12506
1e2f5b6e
AM		 12507 /* Get the relocs. */
12508 internal_relocs
4ce794b7 12509 = _bfd_elf_link_read_relocs (input_bfd, section, NULL, NULL,
45d6a902 12510 info->keep_memory);
721956f4 12511 if (internal_relocs == NULL)
1e2f5b6e 12512 goto error_ret_free_local;
721956f4
AM		 12513
12514 /* Now examine each relocation. */
12515 irela = internal_relocs;
12516 irelaend = irela + section->reloc_count;
12517 for (; irela < irelaend; irela++)
12518 {
4ce794b7
AM		 12519 enum elf_ppc64_reloc_type r_type;
12520 unsigned int r_indx;
721956f4
AM		 12521 enum ppc_stub_type stub_type;
12522 struct ppc_stub_hash_entry *stub_entry;
8387904d 12523 asection *sym_sec, *code_sec;
e054468f 12524 bfd_vma sym_value, code_value;
721956f4 12525 bfd_vma destination;
6911b7dc 12526 unsigned long local_off;
8843416a 12527 bfd_boolean ok_dest;
721956f4 12528 struct ppc_link_hash_entry *hash;
8387904d 12529 struct ppc_link_hash_entry *fdh;
411e1bfb
AM		 12530 struct elf_link_hash_entry *h;
12531 Elf_Internal_Sym *sym;
721956f4
AM		 12532 char *stub_name;
12533 const asection *id_sec;
74f0fb50 12534 struct _opd_sec_data *opd;
e054468f 12535 struct plt_entry *plt_ent;
721956f4
AM		 12536
12537 r_type = ELF64_R_TYPE (irela->r_info);
12538 r_indx = ELF64_R_SYM (irela->r_info);
12539
4ce794b7 12540 if (r_type >= R_PPC64_max)
721956f4
AM		 12541 {
12542 bfd_set_error (bfd_error_bad_value);
6cdc0ccc 12543 goto error_ret_free_internal;
721956f4
AM		 12544 }
12545
12546 /* Only look for stubs on branch instructions. */
4ce794b7
AM		 12547 if (r_type != R_PPC64_REL24
12548 && r_type != R_PPC64_REL14
12549 && r_type != R_PPC64_REL14_BRTAKEN
12550 && r_type != R_PPC64_REL14_BRNTAKEN)
721956f4
AM		 12551 continue;
12552
12553 /* Now determine the call target, its name, value,
12554 section. */
411e1bfb
AM		 12555 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
12556 r_indx, input_bfd))
12557 goto error_ret_free_internal;
12558 hash = (struct ppc_link_hash_entry *) h;
12559
8843416a 12560 ok_dest = FALSE;
8387904d 12561 fdh = NULL;
7fe2b9a6 12562 sym_value = 0;
411e1bfb 12563 if (hash == NULL)
721956f4 12564 {
411e1bfb 12565 sym_value = sym->st_value;
c27b8c2a
AM		 12566 if (sym_sec != NULL
12567 && sym_sec->output_section != NULL)
12568 ok_dest = TRUE;
721956f4 12569 }
7fe2b9a6
AM		 12570 else if (hash->elf.root.type == bfd_link_hash_defined
12571 || hash->elf.root.type == bfd_link_hash_defweak)
12572 {
12573 sym_value = hash->elf.root.u.def.value;
12574 if (sym_sec->output_section != NULL)
12575 ok_dest = TRUE;
12576 }
12577 else if (hash->elf.root.type == bfd_link_hash_undefweak
12578 || hash->elf.root.type == bfd_link_hash_undefined)
721956f4 12579 {
99877b66 12580 /* Recognise an old ABI func code entry sym, and
7fe2b9a6
AM		 12581 use the func descriptor sym instead if it is
12582 defined. */
ceb1f1ef 12583 if (hash->elf.root.root.string[0] == '.'
8c5b4e52 12584 && hash->oh != NULL)
8387904d 12585 {
8c5b4e52 12586 fdh = ppc_follow_link (hash->oh);
8387904d
AM		 12587 if (fdh->elf.root.type == bfd_link_hash_defined
12588 || fdh->elf.root.type == bfd_link_hash_defweak)
12589 {
12590 sym_sec = fdh->elf.root.u.def.section;
12591 sym_value = fdh->elf.root.u.def.value;
12592 if (sym_sec->output_section != NULL)
12593 ok_dest = TRUE;
12594 }
99877b66
AM		 12595 else
12596 fdh = NULL;
8387904d 12597 }
7fe2b9a6
AM		 12598 }
12599 else
12600 {
12601 bfd_set_error (bfd_error_bad_value);
12602 goto error_ret_free_internal;
721956f4
AM		 12603 }
12604
8843416a 12605 destination = 0;
6911b7dc 12606 local_off = 0;
8843416a
AM		 12607 if (ok_dest)
12608 {
12609 sym_value += irela->r_addend;
12610 destination = (sym_value
12611 + sym_sec->output_offset
12612 + sym_sec->output_section->vma);
6911b7dc
AM		 12613 local_off = PPC64_LOCAL_ENTRY_OFFSET (hash
12614 ? hash->elf.other
12615 : sym->st_other);
8843416a
AM		 12616 }
12617
8387904d 12618 code_sec = sym_sec;
e054468f 12619 code_value = sym_value;
74f0fb50
AM		 12620 opd = get_opd_info (sym_sec);
12621 if (opd != NULL)
8387904d
AM		 12622 {
12623 bfd_vma dest;
12624
74f0fb50 12625 if (hash == NULL && opd->adjust != NULL)
8387904d 12626 {
51aecdc5 12627 long adjust = opd->adjust[OPD_NDX (sym_value)];
8387904d
AM		 12628 if (adjust == -1)
12629 continue;
e054468f 12630 code_value += adjust;
8387904d
AM		 12631 sym_value += adjust;
12632 }
12633 dest = opd_entry_value (sym_sec, sym_value,
aef36ac1 12634 &code_sec, &code_value, FALSE);
8387904d
AM		 12635 if (dest != (bfd_vma) -1)
12636 {
12637 destination = dest;
12638 if (fdh != NULL)
12639 {
12640 /* Fixup old ABI sym to point at code
12641 entry. */
99877b66 12642 hash->elf.root.type = bfd_link_hash_defweak;
8387904d 12643 hash->elf.root.u.def.section = code_sec;
e054468f 12644 hash->elf.root.u.def.value = code_value;
8387904d
AM		 12645 }
12646 }
12647 }
12648
721956f4 12649 /* Determine what (if any) linker stub is needed. */
e054468f 12650 plt_ent = NULL;
721956f4 12651 stub_type = ppc_type_of_stub (section, irela, &hash,
6911b7dc
AM		 12652 &plt_ent, destination,
12653 local_off);
ad8e1ba5
AM		 12654
12655 if (stub_type != ppc_stub_plt_call)
12656 {
12657 /* Check whether we need a TOC adjusting stub.
12658 Since the linker pastes together pieces from
12659 different object files when creating the
12660 _init and _fini functions, it may be that a
12661 call to what looks like a local sym is in
12662 fact a call needing a TOC adjustment. */
8387904d
AM		 12663 if (code_sec != NULL
12664 && code_sec->output_section != NULL
6f20ed8a
AM		 12665 && (htab->sec_info[code_sec->id].toc_off
12666 != htab->sec_info[section->id].toc_off)
4c52953f
AM		 12667 && (code_sec->has_toc_reloc
12668 || code_sec->makes_toc_func_call))
ad8e1ba5
AM		 12669 stub_type = ppc_stub_long_branch_r2off;
12670 }
12671
721956f4
AM		 12672 if (stub_type == ppc_stub_none)
12673 continue;
12674
411e1bfb
AM		 12675 /* __tls_get_addr calls might be eliminated. */
12676 if (stub_type != ppc_stub_plt_call
12677 && hash != NULL
8387904d
AM		 12678 && (hash == htab->tls_get_addr
12679 || hash == htab->tls_get_addr_fd)
411e1bfb
AM		 12680 && section->has_tls_reloc
12681 && irela != internal_relocs)
12682 {
12683 /* Get tls info. */
f961d9dd 12684 unsigned char *tls_mask;
411e1bfb 12685
3a71aa26 12686 if (!get_tls_mask (&tls_mask, NULL, NULL, &local_syms,
411e1bfb
AM		 12687 irela - 1, input_bfd))
12688 goto error_ret_free_internal;
e7b938ca 12689 if (*tls_mask != 0)
411e1bfb
AM		 12690 continue;
12691 }
12692
f378ab09 12693 if (stub_type == ppc_stub_plt_call)
794e51c0 12694 {
6e1816be
AM		 12695 if (!htab->opd_abi
12696 && htab->params->plt_localentry0 != 0
12697 && is_elfv2_localentry0 (&hash->elf))
12698 htab->has_plt_localentry0 = 1;
12699 else if (irela + 1 < irelaend
12700 && irela[1].r_offset == irela->r_offset + 4
12701 && (ELF64_R_TYPE (irela[1].r_info)
12702 == R_PPC64_TOCSAVE))
f378ab09
AM		 12703 {
12704 if (!tocsave_find (htab, INSERT,
12705 &local_syms, irela + 1, input_bfd))
12706 goto error_ret_free_internal;
12707 }
f378ab09
AM		 12708 else
12709 stub_type = ppc_stub_plt_call_r2save;
794e51c0 12710 }
3b421ab3 12711
721956f4 12712 /* Support for grouping stub sections. */
6f20ed8a 12713 id_sec = htab->sec_info[section->id].u.group->link_sec;
721956f4
AM		 12714
12715 /* Get the name of this stub. */
12716 stub_name = ppc_stub_name (id_sec, sym_sec, hash, irela);
12717 if (!stub_name)
12718 goto error_ret_free_internal;
12719
12720 stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
b34976b6 12721 stub_name, FALSE, FALSE);
721956f4
AM		 12722 if (stub_entry != NULL)
12723 {
12724 /* The proper stub has already been created. */
12725 free (stub_name);
794e51c0
AM		 12726 if (stub_type == ppc_stub_plt_call_r2save)
12727 stub_entry->stub_type = stub_type;
721956f4
AM		 12728 continue;
12729 }
12730
25f53a85 12731 stub_entry = ppc_add_stub (stub_name, section, info);
721956f4
AM		 12732 if (stub_entry == NULL)
12733 {
12734 free (stub_name);
6cdc0ccc
AM		 12735 error_ret_free_internal:
12736 if (elf_section_data (section)->relocs == NULL)
12737 free (internal_relocs);
12738 error_ret_free_local:
12739 if (local_syms != NULL
12740 && (symtab_hdr->contents
12741 != (unsigned char *) local_syms))
12742 free (local_syms);
b34976b6 12743 return FALSE;
721956f4
AM		 12744 }
12745
ad8e1ba5 12746 stub_entry->stub_type = stub_type;
794e51c0
AM		 12747 if (stub_type != ppc_stub_plt_call
12748 && stub_type != ppc_stub_plt_call_r2save)
e054468f
AM		 12749 {
12750 stub_entry->target_value = code_value;
12751 stub_entry->target_section = code_sec;
12752 }
12753 else
12754 {
12755 stub_entry->target_value = sym_value;
12756 stub_entry->target_section = sym_sec;
12757 }
721956f4 12758 stub_entry->h = hash;
e054468f 12759 stub_entry->plt_ent = plt_ent;
6911b7dc 12760 stub_entry->other = hash ? hash->elf.other : sym->st_other;
ee75fd95
AM		 12761
12762 if (stub_entry->h != NULL)
12763 htab->stub_globals += 1;
721956f4
AM		 12764 }
12765
12766 /* We're done with the internal relocs, free them. */
6cdc0ccc 12767 if (elf_section_data (section)->relocs != internal_relocs)
1e2f5b6e 12768 free (internal_relocs);
721956f4 12769 }
6cdc0ccc
AM		 12770
12771 if (local_syms != NULL
12772 && symtab_hdr->contents != (unsigned char *) local_syms)
12773 {
12774 if (!info->keep_memory)
12775 free (local_syms);
12776 else
12777 symtab_hdr->contents = (unsigned char *) local_syms;
12778 }
721956f4
AM		 12779 }
12780
5c3dead3 12781 /* We may have added some stubs. Find out the new size of the
721956f4 12782 stub sections. */
d4aaa2a0
AM		 12783 for (group = htab->group; group != NULL; group = group->next)
12784 if (group->stub_sec != NULL)
ee75fd95 12785 {
d4aaa2a0
AM		 12786 asection *stub_sec = group->stub_sec;
12787
ea3d7d1c
AM		 12788 if (htab->stub_iteration <= STUB_SHRINK_ITER
12789 || stub_sec->rawsize < stub_sec->size)
12790 /* Past STUB_SHRINK_ITER, rawsize is the max size seen. */
12791 stub_sec->rawsize = stub_sec->size;
ee75fd95
AM		 12792 stub_sec->size = 0;
12793 stub_sec->reloc_count = 0;
84f5d08e 12794 stub_sec->flags &= ~SEC_RELOC;
ee75fd95 12795 }
eea6121a
AM		 12796
12797 htab->brlt->size = 0;
84f5d08e
AM		 12798 htab->brlt->reloc_count = 0;
12799 htab->brlt->flags &= ~SEC_RELOC;
ee75fd95 12800 if (htab->relbrlt != NULL)
eea6121a 12801 htab->relbrlt->size = 0;
721956f4 12802
63bc6f6c 12803 bfd_hash_traverse (&htab->stub_hash_table, ppc_size_one_stub, info);
721956f4 12804
a4b6fadd
AM		 12805 for (group = htab->group; group != NULL; group = group->next)
12806 if (group->needs_save_res)
12807 group->stub_sec->size += htab->sfpr->size;
12808
176a0d42
AM		 12809 if (info->emitrelocations
12810 && htab->glink != NULL && htab->glink->size != 0)
12811 {
12812 htab->glink->reloc_count = 1;
12813 htab->glink->flags |= SEC_RELOC;
12814 }
12815
58d180e8
AM		 12816 if (htab->glink_eh_frame != NULL
12817 && !bfd_is_abs_section (htab->glink_eh_frame->output_section)
9a2a56cc 12818 && htab->glink_eh_frame->output_section->size != 0)
58d180e8 12819 {
2e0ce1c8 12820 size_t size = 0, align = 4;
58d180e8 12821
d4aaa2a0
AM		 12822 for (group = htab->group; group != NULL; group = group->next)
12823 if (group->stub_sec != NULL)
12824 size += stub_eh_frame_size (group, align);
58d180e8 12825 if (htab->glink != NULL && htab->glink->size != 0)
2e0ce1c8 12826 size += (24 + align - 1) & -align;
58d180e8 12827 if (size != 0)
2e0ce1c8
AM		 12828 size += (sizeof (glink_eh_frame_cie) + align - 1) & -align;
12829 align = 1ul << htab->glink_eh_frame->output_section->alignment_power;
12830 size = (size + align - 1) & -align;
58d180e8
AM		 12831 htab->glink_eh_frame->rawsize = htab->glink_eh_frame->size;
12832 htab->glink_eh_frame->size = size;
12833 }
12834
e7d1c40c 12835 if (htab->params->plt_stub_align != 0)
d4aaa2a0
AM		 12836 for (group = htab->group; group != NULL; group = group->next)
12837 if (group->stub_sec != NULL)
12838 group->stub_sec->size = ((group->stub_sec->size
12839 + (1 << htab->params->plt_stub_align) - 1)
12840 & -(1 << htab->params->plt_stub_align));
12841
12842 for (group = htab->group; group != NULL; group = group->next)
12843 if (group->stub_sec != NULL
12844 && group->stub_sec->rawsize != group->stub_sec->size
c9301e31 12845 && (htab->stub_iteration <= STUB_SHRINK_ITER
d4aaa2a0 12846 || group->stub_sec->rawsize < group->stub_sec->size))
5c3dead3
AM		 12847 break;
12848
d4aaa2a0 12849 if (group == NULL
58d180e8
AM		 12850 && (htab->glink_eh_frame == NULL
12851 || htab->glink_eh_frame->rawsize == htab->glink_eh_frame->size))
5c3dead3
AM		 12852 break;
12853
721956f4 12854 /* Ask the linker to do its stuff. */
e7d1c40c 12855 (*htab->params->layout_sections_again) ();
721956f4
AM		 12856 }
12857
da44f4e5
AM		 12858 if (htab->glink_eh_frame != NULL
12859 && htab->glink_eh_frame->size != 0)
12860 {
12861 bfd_vma val;
12862 bfd_byte *p, *last_fde;
12863 size_t last_fde_len, size, align, pad;
d4aaa2a0 12864 struct map_stub *group;
da44f4e5
AM		 12865
12866 p = bfd_zalloc (htab->glink_eh_frame->owner, htab->glink_eh_frame->size);
12867 if (p == NULL)
12868 return FALSE;
12869 htab->glink_eh_frame->contents = p;
12870 last_fde = p;
2e0ce1c8 12871 align = 4;
da44f4e5
AM		 12872
12873 memcpy (p, glink_eh_frame_cie, sizeof (glink_eh_frame_cie));
12874 /* CIE length (rewrite in case little-endian). */
2e0ce1c8 12875 last_fde_len = ((sizeof (glink_eh_frame_cie) + align - 1) & -align) - 4;
da44f4e5 12876 bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
2e0ce1c8 12877 p += last_fde_len + 4;
da44f4e5 12878
d4aaa2a0
AM		 12879 for (group = htab->group; group != NULL; group = group->next)
12880 if (group->stub_sec != NULL)
da44f4e5
AM		 12881 {
12882 last_fde = p;
d4aaa2a0 12883 last_fde_len = stub_eh_frame_size (group, align) - 4;
da44f4e5 12884 /* FDE length. */
2e0ce1c8 12885 bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
da44f4e5
AM		 12886 p += 4;
12887 /* CIE pointer. */
12888 val = p - htab->glink_eh_frame->contents;
12889 bfd_put_32 (htab->elf.dynobj, val, p);
12890 p += 4;
12891 /* Offset to stub section, written later. */
12892 p += 4;
12893 /* stub section size. */
d4aaa2a0 12894 bfd_put_32 (htab->elf.dynobj, group->stub_sec->size, p);
da44f4e5
AM		 12895 p += 4;
12896 /* Augmentation. */
12897 p += 1;
d4aaa2a0
AM		 12898 if (group->tls_get_addr_opt_bctrl != -1u)
12899 {
12900 unsigned int to_bctrl = group->tls_get_addr_opt_bctrl / 4;
12901
12902 /* This FDE needs more than just the default.
12903 Describe __tls_get_addr_opt stub LR. */
12904 if (to_bctrl < 64)
12905 *p++ = DW_CFA_advance_loc + to_bctrl;
12906 else if (to_bctrl < 256)
12907 {
12908 *p++ = DW_CFA_advance_loc1;
12909 *p++ = to_bctrl;
12910 }
12911 else if (to_bctrl < 65536)
12912 {
12913 *p++ = DW_CFA_advance_loc2;
12914 bfd_put_16 (htab->elf.dynobj, to_bctrl, p);
12915 p += 2;
12916 }
12917 else
12918 {
12919 *p++ = DW_CFA_advance_loc4;
12920 bfd_put_32 (htab->elf.dynobj, to_bctrl, p);
12921 p += 4;
12922 }
12923 *p++ = DW_CFA_offset_extended_sf;
12924 *p++ = 65;
12925 *p++ = -(STK_LINKER (htab) / 8) & 0x7f;
12926 *p++ = DW_CFA_advance_loc + 4;
12927 *p++ = DW_CFA_restore_extended;
12928 *p++ = 65;
12929 }
da44f4e5 12930 /* Pad. */
d4aaa2a0 12931 p = last_fde + last_fde_len + 4;
da44f4e5
AM		 12932 }
12933 if (htab->glink != NULL && htab->glink->size != 0)
12934 {
12935 last_fde = p;
2e0ce1c8 12936 last_fde_len = ((24 + align - 1) & -align) - 4;
da44f4e5 12937 /* FDE length. */
2e0ce1c8 12938 bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
da44f4e5
AM		 12939 p += 4;
12940 /* CIE pointer. */
12941 val = p - htab->glink_eh_frame->contents;
12942 bfd_put_32 (htab->elf.dynobj, val, p);
12943 p += 4;
12944 /* Offset to .glink, written later. */
12945 p += 4;
12946 /* .glink size. */
12947 bfd_put_32 (htab->elf.dynobj, htab->glink->size - 8, p);
12948 p += 4;
12949 /* Augmentation. */
12950 p += 1;
12951
12952 *p++ = DW_CFA_advance_loc + 1;
12953 *p++ = DW_CFA_register;
12954 *p++ = 65;
9f08fa5c 12955 *p++ = htab->opd_abi ? 12 : 0;
15a3a14f 12956 *p++ = DW_CFA_advance_loc + (htab->opd_abi ? 5 : 7);
da44f4e5
AM		 12957 *p++ = DW_CFA_restore_extended;
12958 *p++ = 65;
2e0ce1c8 12959 p += ((24 + align - 1) & -align) - 24;
da44f4e5
AM		 12960 }
12961 /* Subsume any padding into the last FDE if user .eh_frame
12962 sections are aligned more than glink_eh_frame. Otherwise any
12963 zero padding will be seen as a terminator. */
2e0ce1c8 12964 align = 1ul << htab->glink_eh_frame->output_section->alignment_power;
da44f4e5 12965 size = p - htab->glink_eh_frame->contents;
2e0ce1c8 12966 pad = ((size + align - 1) & -align) - size;
da44f4e5
AM		 12967 htab->glink_eh_frame->size = size + pad;
12968 bfd_put_32 (htab->elf.dynobj, last_fde_len + pad, last_fde);
12969 }
12970
d969d15f
AM		 12971 maybe_strip_output (info, htab->brlt);
12972 if (htab->glink_eh_frame != NULL)
12973 maybe_strip_output (info, htab->glink_eh_frame);
721956f4 12974
b34976b6 12975 return TRUE;
721956f4
AM		 12976}
12977
12978/* Called after we have determined section placement. If sections
805fc799 12979 move, we'll be called again. Provide a value for TOCstart. */
721956f4 12980
805fc799 12981bfd_vma
1c865ab2 12982ppc64_elf_set_toc (struct bfd_link_info *info, bfd *obfd)
721956f4 12983{
805fc799 12984 asection *s;
a27e685f 12985 bfd_vma TOCstart, adjust;
721956f4 12986
43417696
AM		 12987 if (info != NULL)
12988 {
12989 struct elf_link_hash_entry *h;
12990 struct elf_link_hash_table *htab = elf_hash_table (info);
12991
12992 if (is_elf_hash_table (htab)
12993 && htab->hgot != NULL)
12994 h = htab->hgot;
12995 else
12996 {
12997 h = elf_link_hash_lookup (htab, ".TOC.", FALSE, FALSE, TRUE);
12998 if (is_elf_hash_table (htab))
12999 htab->hgot = h;
13000 }
13001 if (h != NULL
13002 && h->root.type == bfd_link_hash_defined
13003 && !h->root.linker_def
13004 && (!is_elf_hash_table (htab)
13005 || h->def_regular))
13006 {
13007 TOCstart = (h->root.u.def.value - TOC_BASE_OFF
13008 + h->root.u.def.section->output_offset
13009 + h->root.u.def.section->output_section->vma);
13010 _bfd_set_gp_value (obfd, TOCstart);
13011 return TOCstart;
13012 }
13013 }
13014
805fc799
AM		 13015 /* The TOC consists of sections .got, .toc, .tocbss, .plt in that
13016 order. The TOC starts where the first of these sections starts. */
13017 s = bfd_get_section_by_name (obfd, ".got");
e054468f 13018 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
805fc799 13019 s = bfd_get_section_by_name (obfd, ".toc");
e054468f 13020 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
805fc799 13021 s = bfd_get_section_by_name (obfd, ".tocbss");
e054468f 13022 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
805fc799 13023 s = bfd_get_section_by_name (obfd, ".plt");
e054468f 13024 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
805fc799
AM		 13025 {
13026 /* This may happen for
13027 o references to TOC base (SYM@toc / TOC[tc0]) without a
13028 .toc directive
13029 o bad linker script
13030 o --gc-sections and empty TOC sections
13031
13032 FIXME: Warn user? */
13033
13034 /* Look for a likely section. We probably won't even be
13035 using TOCstart. */
13036 for (s = obfd->sections; s != NULL; s = s->next)
e054468f
AM		 13037 if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_READONLY
13038 | SEC_EXCLUDE))
805fc799
AM		 13039 == (SEC_ALLOC | SEC_SMALL_DATA))
13040 break;
721956f4 13041 if (s == NULL)
805fc799 13042 for (s = obfd->sections; s != NULL; s = s->next)
e054468f 13043 if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_EXCLUDE))
805fc799
AM		 13044 == (SEC_ALLOC | SEC_SMALL_DATA))
13045 break;
721956f4 13046 if (s == NULL)
805fc799 13047 for (s = obfd->sections; s != NULL; s = s->next)
e054468f
AM		 13048 if ((s->flags & (SEC_ALLOC | SEC_READONLY | SEC_EXCLUDE))
13049 == SEC_ALLOC)
805fc799 13050 break;
721956f4 13051 if (s == NULL)
805fc799 13052 for (s = obfd->sections; s != NULL; s = s->next)
e054468f 13053 if ((s->flags & (SEC_ALLOC | SEC_EXCLUDE)) == SEC_ALLOC)
805fc799
AM		 13054 break;
13055 }
721956f4 13056
805fc799
AM		 13057 TOCstart = 0;
13058 if (s != NULL)
13059 TOCstart = s->output_section->vma + s->output_offset;
721956f4 13060
a27e685f
AM		 13061 /* Force alignment. */
13062 adjust = TOCstart & (TOC_BASE_ALIGN - 1);
13063 TOCstart -= adjust;
1c865ab2
AM		 13064 _bfd_set_gp_value (obfd, TOCstart);
13065
810d4e75 13066 if (info != NULL && s != NULL)
1c865ab2
AM		 13067 {
13068 struct ppc_link_hash_table *htab = ppc_hash_table (info);
13069
810d4e75
AM		 13070 if (htab != NULL)
13071 {
13072 if (htab->elf.hgot != NULL)
13073 {
a27e685f 13074 htab->elf.hgot->root.u.def.value = TOC_BASE_OFF - adjust;
810d4e75
AM		 13075 htab->elf.hgot->root.u.def.section = s;
13076 }
13077 }
13078 else
1c865ab2 13079 {
810d4e75
AM		 13080 struct bfd_link_hash_entry *bh = NULL;
13081 _bfd_generic_link_add_one_symbol (info, obfd, ".TOC.", BSF_GLOBAL,
a27e685f
AM		 13082 s, TOC_BASE_OFF - adjust,
13083 NULL, FALSE, FALSE, &bh);
1c865ab2
AM		 13084 }
13085 }
805fc799 13086 return TOCstart;
721956f4
AM		 13087}
13088
a345bc8d
AM		 13089/* Called via elf_link_hash_traverse from ppc64_elf_build_stubs to
13090 write out any global entry stubs. */
13091
13092static bfd_boolean
13093build_global_entry_stubs (struct elf_link_hash_entry *h, void *inf)
13094{
13095 struct bfd_link_info *info;
13096 struct ppc_link_hash_table *htab;
13097 struct plt_entry *pent;
13098 asection *s;
13099
13100 if (h->root.type == bfd_link_hash_indirect)
13101 return TRUE;
13102
13103 if (!h->pointer_equality_needed)
13104 return TRUE;
13105
13106 if (h->def_regular)
13107 return TRUE;
13108
13109 info = inf;
13110 htab = ppc_hash_table (info);
13111 if (htab == NULL)
13112 return FALSE;
13113
13114 s = htab->glink;
13115 for (pent = h->plt.plist; pent != NULL; pent = pent->next)
13116 if (pent->plt.offset != (bfd_vma) -1
13117 && pent->addend == 0)
13118 {
13119 bfd_byte *p;
13120 asection *plt;
13121 bfd_vma off;
13122
a345bc8d 13123 p = s->contents + h->root.u.def.value;
33e44f2e 13124 plt = htab->elf.splt;
a345bc8d
AM		 13125 if (!htab->elf.dynamic_sections_created
13126 || h->dynindx == -1)
33e44f2e 13127 plt = htab->elf.iplt;
a345bc8d
AM		 13128 off = pent->plt.offset + plt->output_offset + plt->output_section->vma;
13129 off -= h->root.u.def.value + s->output_offset + s->output_section->vma;
13130
13131 if (off + 0x80008000 > 0xffffffff || (off & 3) != 0)
13132 {
13133 info->callbacks->einfo
13134 (_("%P: linkage table error against `%T'\n"),
13135 h->root.root.string);
13136 bfd_set_error (bfd_error_bad_value);
13137 htab->stub_error = TRUE;
13138 }
13139
7341d5e2
AM		 13140 htab->stub_count[ppc_stub_global_entry - 1] += 1;
13141 if (htab->params->emit_stub_syms)
13142 {
13143 size_t len = strlen (h->root.root.string);
13144 char *name = bfd_malloc (sizeof "12345678.global_entry." + len);
13145
13146 if (name == NULL)
13147 return FALSE;
13148
13149 sprintf (name, "%08x.global_entry.%s", s->id, h->root.root.string);
13150 h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
13151 if (h == NULL)
13152 return FALSE;
13153 if (h->root.type == bfd_link_hash_new)
13154 {
13155 h->root.type = bfd_link_hash_defined;
13156 h->root.u.def.section = s;
13157 h->root.u.def.value = p - s->contents;
13158 h->ref_regular = 1;
13159 h->def_regular = 1;
13160 h->ref_regular_nonweak = 1;
13161 h->forced_local = 1;
13162 h->non_elf = 0;
2ec55de3 13163 h->root.linker_def = 1;
7341d5e2
AM		 13164 }
13165 }
13166
a345bc8d
AM		 13167 if (PPC_HA (off) != 0)
13168 {
13169 bfd_put_32 (s->owner, ADDIS_R12_R12 | PPC_HA (off), p);
13170 p += 4;
13171 }
13172 bfd_put_32 (s->owner, LD_R12_0R12 | PPC_LO (off), p);
13173 p += 4;
13174 bfd_put_32 (s->owner, MTCTR_R12, p);
13175 p += 4;
13176 bfd_put_32 (s->owner, BCTR, p);
13177 break;
13178 }
13179 return TRUE;
13180}
13181
721956f4
AM		 13182/* Build all the stubs associated with the current output file.
13183 The stubs are kept in a hash table attached to the main linker
13184 hash table. This function is called via gldelf64ppc_finish. */
13185
b34976b6 13186bfd_boolean
e7d1c40c 13187ppc64_elf_build_stubs (struct bfd_link_info *info,
4ce794b7 13188 char **stats)
5d1634d7
AM		 13189{
13190 struct ppc_link_hash_table *htab = ppc_hash_table (info);
a4b6fadd 13191 struct map_stub *group;
721956f4 13192 asection *stub_sec;
5d1634d7 13193 bfd_byte *p;
e717da7e 13194 int stub_sec_count = 0;
5d1634d7 13195
4dfe6ac6
NC		 13196 if (htab == NULL)
13197 return FALSE;
13198
eea6121a 13199 /* Allocate memory to hold the linker stubs. */
d4aaa2a0
AM		 13200 for (group = htab->group; group != NULL; group = group->next)
13201 if ((stub_sec = group->stub_sec) != NULL
eea6121a 13202 && stub_sec->size != 0)
e717da7e 13203 {
e7d1c40c 13204 stub_sec->contents = bfd_zalloc (htab->params->stub_bfd, stub_sec->size);
eea6121a
AM		 13205 if (stub_sec->contents == NULL)
13206 return FALSE;
eea6121a 13207 stub_sec->size = 0;
e717da7e 13208 }
5d1634d7 13209
23eb7e01 13210 if (htab->glink != NULL && htab->glink->size != 0)
5d1634d7 13211 {
9f951329 13212 unsigned int indx;
ad8e1ba5 13213 bfd_vma plt0;
9f951329 13214
721956f4 13215 /* Build the .glink plt call stub. */
e7d1c40c 13216 if (htab->params->emit_stub_syms)
97b639ba
AM		 13217 {
13218 struct elf_link_hash_entry *h;
468392fb
AM		 13219 h = elf_link_hash_lookup (&htab->elf, "__glink_PLTresolve",
13220 TRUE, FALSE, FALSE);
97b639ba
AM		 13221 if (h == NULL)
13222 return FALSE;
13223 if (h->root.type == bfd_link_hash_new)
13224 {
13225 h->root.type = bfd_link_hash_defined;
13226 h->root.u.def.section = htab->glink;
ee4bf8d2 13227 h->root.u.def.value = 8;
f5385ebf
AM		 13228 h->ref_regular = 1;
13229 h->def_regular = 1;
13230 h->ref_regular_nonweak = 1;
13231 h->forced_local = 1;
13232 h->non_elf = 0;
2ec55de3 13233 h->root.linker_def = 1;
97b639ba
AM		 13234 }
13235 }
33e44f2e
AM		 13236 plt0 = (htab->elf.splt->output_section->vma
13237 + htab->elf.splt->output_offset
13238 - 16);
176a0d42
AM		 13239 if (info->emitrelocations)
13240 {
13241 Elf_Internal_Rela *r = get_relocs (htab->glink, 1);
13242 if (r == NULL)
13243 return FALSE;
13244 r->r_offset = (htab->glink->output_offset
13245 + htab->glink->output_section->vma);
13246 r->r_info = ELF64_R_INFO (0, R_PPC64_REL64);
13247 r->r_addend = plt0;
13248 }
4ce794b7 13249 p = htab->glink->contents;
176a0d42 13250 plt0 -= htab->glink->output_section->vma + htab->glink->output_offset;
ee4bf8d2
AM		 13251 bfd_put_64 (htab->glink->owner, plt0, p);
13252 p += 8;
b9e5796b
AM		 13253 if (htab->opd_abi)
13254 {
13255 bfd_put_32 (htab->glink->owner, MFLR_R12, p);
13256 p += 4;
13257 bfd_put_32 (htab->glink->owner, BCL_20_31, p);
13258 p += 4;
13259 bfd_put_32 (htab->glink->owner, MFLR_R11, p);
13260 p += 4;
13261 bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
13262 p += 4;
13263 bfd_put_32 (htab->glink->owner, MTLR_R12, p);
13264 p += 4;
13265 bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
13266 p += 4;
13267 bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
13268 p += 4;
13269 bfd_put_32 (htab->glink->owner, LD_R2_0R11 | 8, p);
13270 p += 4;
13271 bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
13272 p += 4;
13273 bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 16, p);
13274 p += 4;
13275 }
13276 else
13277 {
13278 bfd_put_32 (htab->glink->owner, MFLR_R0, p);
13279 p += 4;
13280 bfd_put_32 (htab->glink->owner, BCL_20_31, p);
13281 p += 4;
13282 bfd_put_32 (htab->glink->owner, MFLR_R11, p);
13283 p += 4;
f378ab09
AM		 13284 bfd_put_32 (htab->glink->owner, STD_R2_0R1 + 24, p);
13285 p += 4;
b9e5796b
AM		 13286 bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
13287 p += 4;
13288 bfd_put_32 (htab->glink->owner, MTLR_R0, p);
13289 p += 4;
13290 bfd_put_32 (htab->glink->owner, SUB_R12_R12_R11, p);
13291 p += 4;
13292 bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
13293 p += 4;
13294 bfd_put_32 (htab->glink->owner, ADDI_R0_R12 | (-48 & 0xffff), p);
13295 p += 4;
13296 bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
13297 p += 4;
13298 bfd_put_32 (htab->glink->owner, SRDI_R0_R0_2, p);
13299 p += 4;
13300 bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
13301 p += 4;
13302 bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 8, p);
13303 p += 4;
13304 }
4ce794b7 13305 bfd_put_32 (htab->glink->owner, BCTR, p);
ad8e1ba5 13306 p += 4;
ee4bf8d2
AM		 13307 while (p - htab->glink->contents < GLINK_CALL_STUB_SIZE)
13308 {
13309 bfd_put_32 (htab->glink->owner, NOP, p);
13310 p += 4;
13311 }
ad8e1ba5 13312
9f951329
AM		 13313 /* Build the .glink lazy link call stubs. */
13314 indx = 0;
a345bc8d 13315 while (p < htab->glink->contents + htab->glink->rawsize)
9f951329 13316 {
b9e5796b 13317 if (htab->opd_abi)
9f951329 13318 {
b9e5796b
AM		 13319 if (indx < 0x8000)
13320 {
13321 bfd_put_32 (htab->glink->owner, LI_R0_0 | indx, p);
13322 p += 4;
13323 }
13324 else
13325 {
13326 bfd_put_32 (htab->glink->owner, LIS_R0_0 | PPC_HI (indx), p);
13327 p += 4;
13328 bfd_put_32 (htab->glink->owner, ORI_R0_R0_0 | PPC_LO (indx),
13329 p);
13330 p += 4;
13331 }
9f951329 13332 }
4ce794b7 13333 bfd_put_32 (htab->glink->owner,
ee4bf8d2 13334 B_DOT | ((htab->glink->contents - p + 8) & 0x3fffffc), p);
a16d5acb 13335 indx++;
9f951329
AM		 13336 p += 4;
13337 }
a345bc8d
AM		 13338
13339 /* Build .glink global entry stubs. */
13340 if (htab->glink->size > htab->glink->rawsize)
afe397ea 13341 elf_link_hash_traverse (&htab->elf, build_global_entry_stubs, info);
5d1634d7 13342 }
5d1634d7 13343
7341d5e2 13344 if (htab->brlt != NULL && htab->brlt->size != 0)
721956f4 13345 {
4ce794b7 13346 htab->brlt->contents = bfd_zalloc (htab->brlt->owner,
eea6121a 13347 htab->brlt->size);
4ce794b7 13348 if (htab->brlt->contents == NULL)
b34976b6 13349 return FALSE;
721956f4 13350 }
ee75fd95 13351 if (htab->relbrlt != NULL && htab->relbrlt->size != 0)
63bc6f6c
AM		 13352 {
13353 htab->relbrlt->contents = bfd_zalloc (htab->relbrlt->owner,
eea6121a 13354 htab->relbrlt->size);
63bc6f6c
AM		 13355 if (htab->relbrlt->contents == NULL)
13356 return FALSE;
13357 }
5d1634d7 13358
721956f4
AM		 13359 /* Build the stubs as directed by the stub hash table. */
13360 bfd_hash_traverse (&htab->stub_hash_table, ppc_build_one_stub, info);
5d1634d7 13361
a4b6fadd
AM		 13362 for (group = htab->group; group != NULL; group = group->next)
13363 if (group->needs_save_res)
13364 {
13365 stub_sec = group->stub_sec;
13366 memcpy (stub_sec->contents + stub_sec->size, htab->sfpr->contents,
13367 htab->sfpr->size);
13368 if (htab->params->emit_stub_syms)
13369 {
13370 unsigned int i;
13371
13372 for (i = 0; i < ARRAY_SIZE (save_res_funcs); i++)
13373 if (!sfpr_define (info, &save_res_funcs[i], stub_sec))
13374 return FALSE;
13375 }
13376 stub_sec->size += htab->sfpr->size;
13377 }
13378
aa8a7074
AM		 13379 if (htab->relbrlt != NULL)
13380 htab->relbrlt->reloc_count = 0;
13381
e7d1c40c 13382 if (htab->params->plt_stub_align != 0)
d4aaa2a0
AM		 13383 for (group = htab->group; group != NULL; group = group->next)
13384 if ((stub_sec = group->stub_sec) != NULL)
e7d1c40c
AM		 13385 stub_sec->size = ((stub_sec->size
13386 + (1 << htab->params->plt_stub_align) - 1)
29f628db 13387 & -(1 << htab->params->plt_stub_align));
794e51c0 13388
d4aaa2a0
AM		 13389 for (group = htab->group; group != NULL; group = group->next)
13390 if ((stub_sec = group->stub_sec) != NULL)
e717da7e
AM		 13391 {
13392 stub_sec_count += 1;
c9301e31
AM		 13393 if (stub_sec->rawsize != stub_sec->size
13394 && (htab->stub_iteration <= STUB_SHRINK_ITER
13395 || stub_sec->rawsize < stub_sec->size))
e717da7e
AM		 13396 break;
13397 }
5d1634d7 13398
da44f4e5
AM		 13399 /* Note that the glink_eh_frame check here is not only testing that
13400 the generated size matched the calculated size but also that
13401 bfd_elf_discard_info didn't make any changes to the section. */
d4aaa2a0 13402 if (group != NULL
58d180e8
AM		 13403 || (htab->glink_eh_frame != NULL
13404 && htab->glink_eh_frame->rawsize != htab->glink_eh_frame->size))
5d1634d7 13405 {
b34976b6 13406 htab->stub_error = TRUE;
8de848d8 13407 info->callbacks->einfo (_("%P: stubs don't match calculated size\n"));
5d1634d7 13408 }
721956f4 13409
d2a300cf
AM		 13410 if (htab->stub_error)
13411 return FALSE;
13412
13413 if (stats != NULL)
13414 {
13415 *stats = bfd_malloc (500);
13416 if (*stats == NULL)
13417 return FALSE;
13418
ee75fd95 13419 sprintf (*stats, _("linker stubs in %u group%s\n"
d2a300cf
AM		 13420 " branch %lu\n"
13421 " toc adjust %lu\n"
13422 " long branch %lu\n"
13423 " long toc adj %lu\n"
794e51c0 13424 " plt call %lu\n"
7341d5e2
AM		 13425 " plt call toc %lu\n"
13426 " global entry %lu"),
e717da7e 13427 stub_sec_count,
ee75fd95 13428 stub_sec_count == 1 ? "" : "s",
4ce794b7
AM		 13429 htab->stub_count[ppc_stub_long_branch - 1],
13430 htab->stub_count[ppc_stub_long_branch_r2off - 1],
13431 htab->stub_count[ppc_stub_plt_branch - 1],
13432 htab->stub_count[ppc_stub_plt_branch_r2off - 1],
794e51c0 13433 htab->stub_count[ppc_stub_plt_call - 1],
7341d5e2
AM		 13434 htab->stub_count[ppc_stub_plt_call_r2save - 1],
13435 htab->stub_count[ppc_stub_global_entry - 1]);
d2a300cf
AM		 13436 }
13437 return TRUE;
5bd4f169
AM		 13438}
13439
60124e18
AM		 13440/* What to do when ld finds relocations against symbols defined in
13441 discarded sections. */
13442
13443static unsigned int
13444ppc64_elf_action_discarded (asection *sec)
13445{
13446 if (strcmp (".opd", sec->name) == 0)
13447 return 0;
13448
13449 if (strcmp (".toc", sec->name) == 0)
13450 return 0;
13451
bce50a28
JJ		 13452 if (strcmp (".toc1", sec->name) == 0)
13453 return 0;
13454
60124e18
AM		 13455 return _bfd_elf_default_action_discarded (sec);
13456}
13457
5bd4f169
AM		 13458/* The RELOCATE_SECTION function is called by the ELF backend linker
13459 to handle the relocations for a section.
13460
13461 The relocs are always passed as Rela structures; if the section
13462 actually uses Rel structures, the r_addend field will always be
13463 zero.
13464
13465 This function is responsible for adjust the section contents as
13466 necessary, and (if using Rela relocs and generating a
1049f94e 13467 relocatable output file) adjusting the reloc addend as
5bd4f169
AM		 13468 necessary.
13469
13470 This function does not have to worry about setting the reloc
13471 address or the reloc symbol index.
13472
13473 LOCAL_SYMS is a pointer to the swapped in local symbols.
13474
13475 LOCAL_SECTIONS is an array giving the section in the input file
13476 corresponding to the st_shndx field of each local symbol.
13477
13478 The global hash table entry for the global symbols can be found
13479 via elf_sym_hashes (input_bfd).
13480
1049f94e 13481 When generating relocatable output, this function must handle
5bd4f169
AM		 13482 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
13483 going to be the section symbol corresponding to the output
13484 section, which means that the addend must be adjusted
13485 accordingly. */
13486
b34976b6 13487static bfd_boolean
4ce794b7
AM		 13488ppc64_elf_relocate_section (bfd *output_bfd,
13489 struct bfd_link_info *info,
13490 bfd *input_bfd,
13491 asection *input_section,
13492 bfd_byte *contents,
13493 Elf_Internal_Rela *relocs,
13494 Elf_Internal_Sym *local_syms,
13495 asection **local_sections)
5bd4f169 13496{
65f38f15 13497 struct ppc_link_hash_table *htab;
5bd4f169
AM		 13498 Elf_Internal_Shdr *symtab_hdr;
13499 struct elf_link_hash_entry **sym_hashes;
5bd4f169 13500 Elf_Internal_Rela *rel;
c316a17c 13501 Elf_Internal_Rela *wrel;
5bd4f169 13502 Elf_Internal_Rela *relend;
411e1bfb
AM		 13503 Elf_Internal_Rela outrel;
13504 bfd_byte *loc;
411e1bfb 13505 struct got_entry **local_got_ents;
5bd4f169 13506 bfd_vma TOCstart;
b34976b6
AM		 13507 bfd_boolean ret = TRUE;
13508 bfd_boolean is_opd;
794e51c0
AM		 13509 /* Assume 'at' branch hints. */
13510 bfd_boolean is_isa_v2 = TRUE;
95f0d0d2 13511 bfd_vma d_offset = (bfd_big_endian (input_bfd) ? 2 : 0);
5bd4f169 13512
65f38f15 13513 /* Initialize howto table if needed. */
5bd4f169 13514 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
5bd4f169
AM		 13515 ppc_howto_init ();
13516
65f38f15 13517 htab = ppc_hash_table (info);
4dfe6ac6
NC		 13518 if (htab == NULL)
13519 return FALSE;
ee75fd95
AM		 13520
13521 /* Don't relocate stub sections. */
e7d1c40c 13522 if (input_section->owner == htab->params->stub_bfd)
ee75fd95
AM		 13523 return TRUE;
13524
0c8d6e5c 13525 BFD_ASSERT (is_ppc64_elf (input_bfd));
0ffa91dd 13526
411e1bfb 13527 local_got_ents = elf_local_got_ents (input_bfd);
5bd4f169 13528 TOCstart = elf_gp (output_bfd);
0ffa91dd 13529 symtab_hdr = &elf_symtab_hdr (input_bfd);
5bd4f169 13530 sym_hashes = elf_sym_hashes (input_bfd);
7c8fe5c4 13531 is_opd = ppc64_elf_section_data (input_section)->sec_type == sec_opd;
65f38f15 13532
c316a17c 13533 rel = wrel = relocs;
5bd4f169 13534 relend = relocs + input_section->reloc_count;
c316a17c 13535 for (; rel < relend; wrel++, rel++)
5bd4f169 13536 {
04c9666a 13537 enum elf_ppc64_reloc_type r_type;
31c76678 13538 bfd_vma addend;
5bd4f169
AM		 13539 bfd_reloc_status_type r;
13540 Elf_Internal_Sym *sym;
13541 asection *sec;
039b3fef
AM		 13542 struct elf_link_hash_entry *h_elf;
13543 struct ppc_link_hash_entry *h;
13544 struct ppc_link_hash_entry *fdh;
5bd4f169 13545 const char *sym_name;
0d4792f7 13546 unsigned long r_symndx, toc_symndx;
3a71aa26 13547 bfd_vma toc_addend;
f961d9dd
AM		 13548 unsigned char tls_mask, tls_gd, tls_type;
13549 unsigned char sym_type;
5bd4f169 13550 bfd_vma relocation;
b34976b6
AM		 13551 bfd_boolean unresolved_reloc;
13552 bfd_boolean warned;
bc30df16 13553 enum { DEST_NORMAL, DEST_OPD, DEST_STUB } reloc_dest;
67f0cbdb 13554 unsigned int insn;
e11840f9 13555 unsigned int mask;
721956f4
AM		 13556 struct ppc_stub_hash_entry *stub_entry;
13557 bfd_vma max_br_offset;
13558 bfd_vma from;
c316a17c 13559 Elf_Internal_Rela orig_rel;
b80eed39
AM		 13560 reloc_howto_type *howto;
13561 struct reloc_howto_struct alt_howto;
5bd4f169 13562
c316a17c
AM		 13563 again:
13564 orig_rel = *rel;
13565
4ce794b7 13566 r_type = ELF64_R_TYPE (rel->r_info);
5bd4f169 13567 r_symndx = ELF64_R_SYM (rel->r_info);
ee87f2da
AM		 13568
13569 /* For old style R_PPC64_TOC relocs with a zero symbol, use the
13570 symbol of the previous ADDR64 reloc. The symbol gives us the
13571 proper TOC base to use. */
13572 if (rel->r_info == ELF64_R_INFO (0, R_PPC64_TOC)
c316a17c
AM		 13573 && wrel != relocs
13574 && ELF64_R_TYPE (wrel[-1].r_info) == R_PPC64_ADDR64
ee87f2da 13575 && is_opd)
c316a17c 13576 r_symndx = ELF64_R_SYM (wrel[-1].r_info);
ee87f2da 13577
4ce794b7
AM		 13578 sym = NULL;
13579 sec = NULL;
039b3fef 13580 h_elf = NULL;
4ce794b7 13581 sym_name = NULL;
b34976b6
AM		 13582 unresolved_reloc = FALSE;
13583 warned = FALSE;
65f38f15 13584
0b13192e 13585 if (r_symndx < symtab_hdr->sh_info)
5bd4f169
AM		 13586 {
13587 /* It's a local symbol. */
74f0fb50 13588 struct _opd_sec_data *opd;
4025353c 13589
5bd4f169
AM		 13590 sym = local_syms + r_symndx;
13591 sec = local_sections[r_symndx];
26c61ae5 13592 sym_name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym, sec);
0d4792f7 13593 sym_type = ELF64_ST_TYPE (sym->st_info);
8517fae7 13594 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
74f0fb50
AM		 13595 opd = get_opd_info (sec);
13596 if (opd != NULL && opd->adjust != NULL)
1e2f5b6e 13597 {
51aecdc5
AM		 13598 long adjust = opd->adjust[OPD_NDX (sym->st_value
13599 + rel->r_addend)];
4025353c
AM		 13600 if (adjust == -1)
13601 relocation = 0;
13602 else
4cc603a5
AM		 13603 {
13604 /* If this is a relocation against the opd section sym
13605 and we have edited .opd, adjust the reloc addend so
13606 that ld -r and ld --emit-relocs output is correct.
13607 If it is a reloc against some other .opd symbol,
13608 then the symbol value will be adjusted later. */
13609 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
13610 rel->r_addend += adjust;
13611 else
13612 relocation += adjust;
13613 }
1e2f5b6e 13614 }
5bd4f169
AM		 13615 }
13616 else
13617 {
62d887d4
L		 13618 bfd_boolean ignored;
13619
b2a8e766
AM		 13620 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
13621 r_symndx, symtab_hdr, sym_hashes,
039b3fef 13622 h_elf, sec, relocation,
62d887d4 13623 unresolved_reloc, warned, ignored);
039b3fef
AM		 13624 sym_name = h_elf->root.root.string;
13625 sym_type = h_elf->type;
b69fdb4e
AM		 13626 if (sec != NULL
13627 && sec->owner == output_bfd
13628 && strcmp (sec->name, ".opd") == 0)
13629 {
13630 /* This is a symbol defined in a linker script. All
13631 such are defined in output sections, even those
13632 defined by simple assignment from a symbol defined in
13633 an input section. Transfer the symbol to an
13634 appropriate input .opd section, so that a branch to
13635 this symbol will be mapped to the location specified
13636 by the opd entry. */
13637 struct bfd_link_order *lo;
13638 for (lo = sec->map_head.link_order; lo != NULL; lo = lo->next)
13639 if (lo->type == bfd_indirect_link_order)
13640 {
13641 asection *isec = lo->u.indirect.section;
13642 if (h_elf->root.u.def.value >= isec->output_offset
13643 && h_elf->root.u.def.value < (isec->output_offset
13644 + isec->size))
13645 {
13646 h_elf->root.u.def.value -= isec->output_offset;
13647 h_elf->root.u.def.section = isec;
13648 sec = isec;
13649 break;
13650 }
13651 }
13652 }
5bd4f169 13653 }
039b3fef 13654 h = (struct ppc_link_hash_entry *) h_elf;
5bd4f169 13655
dbaa2011 13656 if (sec != NULL && discarded_section (sec))
c316a17c
AM		 13657 {
13658 _bfd_clear_contents (ppc64_elf_howto_table[r_type],
13659 input_bfd, input_section,
13660 contents + rel->r_offset);
13661 wrel->r_offset = rel->r_offset;
13662 wrel->r_info = 0;
13663 wrel->r_addend = 0;
13664
13665 /* For ld -r, remove relocations in debug sections against
13666 sections defined in discarded sections. Not done for
13667 non-debug to preserve relocs in .eh_frame which the
13668 eh_frame editing code expects to be present. */
13669 if (bfd_link_relocatable (info)
13670 && (input_section->flags & SEC_DEBUGGING))
13671 wrel--;
13672
13673 continue;
13674 }
ab96bf03 13675
0e1862bb 13676 if (bfd_link_relocatable (info))
c316a17c 13677 goto copy_reloc;
ab96bf03 13678
f40da81b
AM		 13679 if (h != NULL && &h->elf == htab->elf.hgot)
13680 {
6f20ed8a 13681 relocation = TOCstart + htab->sec_info[input_section->id].toc_off;
f40da81b
AM		 13682 sec = bfd_abs_section_ptr;
13683 unresolved_reloc = FALSE;
13684 }
13685
951fd09b
AM		 13686 /* TLS optimizations. Replace instruction sequences and relocs
13687 based on information we collected in tls_optimize. We edit
13688 RELOCS so that --emit-relocs will output something sensible
13689 for the final instruction stream. */
13690 tls_mask = 0;
13691 tls_gd = 0;
0d4792f7 13692 toc_symndx = 0;
727fc41e
AM		 13693 if (h != NULL)
13694 tls_mask = h->tls_mask;
13695 else if (local_got_ents != NULL)
411e1bfb 13696 {
e054468f
AM		 13697 struct plt_entry **local_plt = (struct plt_entry **)
13698 (local_got_ents + symtab_hdr->sh_info);
f961d9dd 13699 unsigned char *lgot_masks = (unsigned char *)
e054468f 13700 (local_plt + symtab_hdr->sh_info);
727fc41e
AM		 13701 tls_mask = lgot_masks[r_symndx];
13702 }
13703 if (tls_mask == 0
13704 && (r_type == R_PPC64_TLS
13705 || r_type == R_PPC64_TLSGD
13706 || r_type == R_PPC64_TLSLD))
13707 {
13708 /* Check for toc tls entries. */
f961d9dd 13709 unsigned char *toc_tls;
0d4792f7 13710
727fc41e
AM		 13711 if (!get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
13712 &local_syms, rel, input_bfd))
13713 return FALSE;
0d4792f7 13714
727fc41e
AM		 13715 if (toc_tls)
13716 tls_mask = *toc_tls;
0d4792f7
AM		 13717 }
13718
13719 /* Check that tls relocs are used with tls syms, and non-tls
13720 relocs are used with non-tls syms. */
cf35638d 13721 if (r_symndx != STN_UNDEF
0d4792f7
AM		 13722 && r_type != R_PPC64_NONE
13723 && (h == NULL
039b3fef
AM		 13724 || h->elf.root.type == bfd_link_hash_defined
13725 || h->elf.root.type == bfd_link_hash_defweak)
1d483afe
AM		 13726 && (IS_PPC64_TLS_RELOC (r_type)
13727 != (sym_type == STT_TLS
13728 || (sym_type == STT_SECTION
13729 && (sec->flags & SEC_THREAD_LOCAL) != 0))))
0d4792f7 13730 {
727fc41e
AM		 13731 if (tls_mask != 0
13732 && (r_type == R_PPC64_TLS
13733 || r_type == R_PPC64_TLSGD
13734 || r_type == R_PPC64_TLSLD))
0d4792f7
AM		 13735 /* R_PPC64_TLS is OK against a symbol in the TOC. */
13736 ;
13737 else
25f53a85 13738 info->callbacks->einfo
1d483afe 13739 (!IS_PPC64_TLS_RELOC (r_type)
695344c0 13740 /* xgettext:c-format */
174d0a74 13741 ? _("%H: %s used with TLS symbol `%T'\n")
695344c0 13742 /* xgettext:c-format */
174d0a74 13743 : _("%H: %s used with non-TLS symbol `%T'\n"),
25f53a85 13744 input_bfd, input_section, rel->r_offset,
0d4792f7
AM		 13745 ppc64_elf_howto_table[r_type]->name,
13746 sym_name);
411e1bfb
AM		 13747 }
13748
13749 /* Ensure reloc mapping code below stays sane. */
13750 if (R_PPC64_TOC16_LO_DS != R_PPC64_TOC16_DS + 1
13751 || R_PPC64_TOC16_LO != R_PPC64_TOC16 + 1
13752 || (R_PPC64_GOT_TLSLD16 & 3) != (R_PPC64_GOT_TLSGD16 & 3)
13753 || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TLSGD16_LO & 3)
13754 || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TLSGD16_HI & 3)
13755 || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TLSGD16_HA & 3)
13756 || (R_PPC64_GOT_TLSLD16 & 3) != (R_PPC64_GOT_TPREL16_DS & 3)
13757 || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TPREL16_LO_DS & 3)
13758 || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TPREL16_HI & 3)
13759 || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TPREL16_HA & 3))
13760 abort ();
0d4792f7 13761
411e1bfb
AM		 13762 switch (r_type)
13763 {
13764 default:
411e1bfb
AM		 13765 break;
13766
ba761f19 13767 case R_PPC64_LO_DS_OPT:
95f0d0d2 13768 insn = bfd_get_32 (input_bfd, contents + rel->r_offset - d_offset);
ba761f19
AM		 13769 if ((insn & (0x3f << 26)) != 58u << 26)
13770 abort ();
13771 insn += (14u << 26) - (58u << 26);
95f0d0d2 13772 bfd_put_32 (input_bfd, insn, contents + rel->r_offset - d_offset);
ba761f19
AM		 13773 r_type = R_PPC64_TOC16_LO;
13774 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13775 break;
13776
411e1bfb
AM		 13777 case R_PPC64_TOC16:
13778 case R_PPC64_TOC16_LO:
13779 case R_PPC64_TOC16_DS:
13780 case R_PPC64_TOC16_LO_DS:
411e1bfb
AM		 13781 {
13782 /* Check for toc tls entries. */
f961d9dd 13783 unsigned char *toc_tls;
951fd09b 13784 int retval;
411e1bfb 13785
3a71aa26
AM		 13786 retval = get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
13787 &local_syms, rel, input_bfd);
951fd09b 13788 if (retval == 0)
411e1bfb
AM		 13789 return FALSE;
13790
13791 if (toc_tls)
13792 {
951fd09b 13793 tls_mask = *toc_tls;
411e1bfb
AM		 13794 if (r_type == R_PPC64_TOC16_DS
13795 || r_type == R_PPC64_TOC16_LO_DS)
81407a69
AM		 13796 {
13797 if (tls_mask != 0
13798 && (tls_mask & (TLS_DTPREL | TLS_TPREL)) == 0)
13799 goto toctprel;
13800 }
411e1bfb 13801 else
951fd09b
AM		 13802 {
13803 /* If we found a GD reloc pair, then we might be
13804 doing a GD->IE transition. */
13805 if (retval == 2)
13806 {
13807 tls_gd = TLS_TPRELGD;
13808 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
102890f0 13809 goto tls_ldgd_opt;
951fd09b
AM		 13810 }
13811 else if (retval == 3)
13812 {
13813 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
102890f0 13814 goto tls_ldgd_opt;
951fd09b
AM		 13815 }
13816 }
411e1bfb
AM		 13817 }
13818 }
13819 break;
13820
9d6ded02
AM		 13821 case R_PPC64_GOT_TPREL16_HI:
13822 case R_PPC64_GOT_TPREL16_HA:
13823 if (tls_mask != 0
13824 && (tls_mask & TLS_TPREL) == 0)
13825 {
13826 rel->r_offset -= d_offset;
95f0d0d2 13827 bfd_put_32 (input_bfd, NOP, contents + rel->r_offset);
9d6ded02
AM		 13828 r_type = R_PPC64_NONE;
13829 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13830 }
13831 break;
13832
411e1bfb
AM		 13833 case R_PPC64_GOT_TPREL16_DS:
13834 case R_PPC64_GOT_TPREL16_LO_DS:
951fd09b
AM		 13835 if (tls_mask != 0
13836 && (tls_mask & TLS_TPREL) == 0)
411e1bfb 13837 {
81407a69 13838 toctprel:
95f0d0d2 13839 insn = bfd_get_32 (input_bfd,
c316a17c 13840 contents + rel->r_offset - d_offset);
411e1bfb
AM		 13841 insn &= 31 << 21;
13842 insn |= 0x3c0d0000; /* addis 0,13,0 */
95f0d0d2 13843 bfd_put_32 (input_bfd, insn,
c316a17c 13844 contents + rel->r_offset - d_offset);
411e1bfb 13845 r_type = R_PPC64_TPREL16_HA;
0d4792f7
AM		 13846 if (toc_symndx != 0)
13847 {
13848 rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
3a71aa26 13849 rel->r_addend = toc_addend;
0d4792f7
AM		 13850 /* We changed the symbol. Start over in order to
13851 get h, sym, sec etc. right. */
c316a17c 13852 goto again;
0d4792f7
AM		 13853 }
13854 else
13855 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
411e1bfb
AM		 13856 }
13857 break;
13858
13859 case R_PPC64_TLS:
951fd09b
AM		 13860 if (tls_mask != 0
13861 && (tls_mask & TLS_TPREL) == 0)
411e1bfb 13862 {
95f0d0d2 13863 insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
2d0f3896
AM		 13864 insn = _bfd_elf_ppc_at_tls_transform (insn, 13);
13865 if (insn == 0)
411e1bfb 13866 abort ();
95f0d0d2 13867 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
411e1bfb 13868 /* Was PPC64_TLS which sits on insn boundary, now
4fe5ca5b
GM		 13869 PPC64_TPREL16_LO which is at low-order half-word. */
13870 rel->r_offset += d_offset;
0d4792f7
AM		 13871 r_type = R_PPC64_TPREL16_LO;
13872 if (toc_symndx != 0)
13873 {
13874 rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
3a71aa26 13875 rel->r_addend = toc_addend;
0d4792f7
AM		 13876 /* We changed the symbol. Start over in order to
13877 get h, sym, sec etc. right. */
c316a17c 13878 goto again;
0d4792f7
AM		 13879 }
13880 else
13881 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
411e1bfb
AM		 13882 }
13883 break;
13884
411e1bfb
AM		 13885 case R_PPC64_GOT_TLSGD16_HI:
13886 case R_PPC64_GOT_TLSGD16_HA:
951fd09b
AM		 13887 tls_gd = TLS_TPRELGD;
13888 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13889 goto tls_gdld_hi;
13890 break;
13891
411e1bfb
AM		 13892 case R_PPC64_GOT_TLSLD16_HI:
13893 case R_PPC64_GOT_TLSLD16_HA:
951fd09b 13894 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
411e1bfb 13895 {
951fd09b
AM		 13896 tls_gdld_hi:
13897 if ((tls_mask & tls_gd) != 0)
13898 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
13899 + R_PPC64_GOT_TPREL16_DS);
13900 else
411e1bfb 13901 {
4fe5ca5b 13902 rel->r_offset -= d_offset;
95f0d0d2 13903 bfd_put_32 (input_bfd, NOP, contents + rel->r_offset);
951fd09b 13904 r_type = R_PPC64_NONE;
411e1bfb 13905 }
951fd09b 13906 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
411e1bfb
AM		 13907 }
13908 break;
13909
951fd09b
AM		 13910 case R_PPC64_GOT_TLSGD16:
13911 case R_PPC64_GOT_TLSGD16_LO:
13912 tls_gd = TLS_TPRELGD;
13913 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
102890f0 13914 goto tls_ldgd_opt;
951fd09b 13915 break;
411e1bfb 13916
951fd09b
AM		 13917 case R_PPC64_GOT_TLSLD16:
13918 case R_PPC64_GOT_TLSLD16_LO:
13919 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13920 {
3a71aa26 13921 unsigned int insn1, insn2, insn3;
102890f0
AM		 13922 bfd_vma offset;
13923
13924 tls_ldgd_opt:
727fc41e
AM		 13925 offset = (bfd_vma) -1;
13926 /* If not using the newer R_PPC64_TLSGD/LD to mark
13927 __tls_get_addr calls, we must trust that the call
13928 stays with its arg setup insns, ie. that the next
13929 reloc is the __tls_get_addr call associated with
13930 the current reloc. Edit both insns. */
13931 if (input_section->has_tls_get_addr_call
13932 && rel + 1 < relend
13933 && branch_reloc_hash_match (input_bfd, rel + 1,
13934 htab->tls_get_addr,
13935 htab->tls_get_addr_fd))
13936 offset = rel[1].r_offset;
b86ac8e3
AM		 13937 /* We read the low GOT_TLS (or TOC16) insn because we
13938 need to keep the destination reg. It may be
13939 something other than the usual r3, and moved to r3
13940 before the call by intervening code. */
95f0d0d2 13941 insn1 = bfd_get_32 (input_bfd,
b86ac8e3 13942 contents + rel->r_offset - d_offset);
102890f0 13943 if ((tls_mask & tls_gd) != 0)
411e1bfb 13944 {
102890f0 13945 /* IE */
b86ac8e3 13946 insn1 &= (0x1f << 21) | (0x1f << 16);
102890f0
AM		 13947 insn1 |= 58 << 26; /* ld */
13948 insn2 = 0x7c636a14; /* add 3,3,13 */
727fc41e 13949 if (offset != (bfd_vma) -1)
f58d5a2d 13950 rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
102890f0
AM		 13951 if ((tls_mask & TLS_EXPLICIT) == 0)
13952 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
13953 + R_PPC64_GOT_TPREL16_DS);
411e1bfb 13954 else
102890f0
AM		 13955 r_type += R_PPC64_TOC16_DS - R_PPC64_TOC16;
13956 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13957 }
13958 else
13959 {
13960 /* LE */
b86ac8e3
AM		 13961 insn1 &= 0x1f << 21;
13962 insn1 |= 0x3c0d0000; /* addis r,13,0 */
102890f0
AM		 13963 insn2 = 0x38630000; /* addi 3,3,0 */
13964 if (tls_gd == 0)
951fd09b 13965 {
102890f0 13966 /* Was an LD reloc. */
1d483afe
AM		 13967 if (toc_symndx)
13968 sec = local_sections[toc_symndx];
13969 for (r_symndx = 0;
13970 r_symndx < symtab_hdr->sh_info;
13971 r_symndx++)
13972 if (local_sections[r_symndx] == sec)
13973 break;
13974 if (r_symndx >= symtab_hdr->sh_info)
cf35638d 13975 r_symndx = STN_UNDEF;
102890f0 13976 rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
cf35638d 13977 if (r_symndx != STN_UNDEF)
1d483afe
AM		 13978 rel->r_addend -= (local_syms[r_symndx].st_value
13979 + sec->output_offset
13980 + sec->output_section->vma);
951fd09b 13981 }
102890f0 13982 else if (toc_symndx != 0)
3a71aa26
AM		 13983 {
13984 r_symndx = toc_symndx;
13985 rel->r_addend = toc_addend;
13986 }
102890f0
AM		 13987 r_type = R_PPC64_TPREL16_HA;
13988 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
727fc41e
AM		 13989 if (offset != (bfd_vma) -1)
13990 {
13991 rel[1].r_info = ELF64_R_INFO (r_symndx,
13992 R_PPC64_TPREL16_LO);
13993 rel[1].r_offset = offset + d_offset;
13994 rel[1].r_addend = rel->r_addend;
13995 }
102890f0 13996 }
95f0d0d2 13997 bfd_put_32 (input_bfd, insn1,
3a71aa26 13998 contents + rel->r_offset - d_offset);
727fc41e
AM		 13999 if (offset != (bfd_vma) -1)
14000 {
95f0d0d2 14001 insn3 = bfd_get_32 (input_bfd,
727fc41e
AM		 14002 contents + offset + 4);
14003 if (insn3 == NOP
14004 || insn3 == CROR_151515 || insn3 == CROR_313131)
14005 {
14006 rel[1].r_offset += 4;
95f0d0d2 14007 bfd_put_32 (input_bfd, insn2, contents + offset + 4);
727fc41e
AM		 14008 insn2 = NOP;
14009 }
95f0d0d2 14010 bfd_put_32 (input_bfd, insn2, contents + offset);
727fc41e
AM		 14011 }
14012 if ((tls_mask & tls_gd) == 0
14013 && (tls_gd == 0 || toc_symndx != 0))
14014 {
14015 /* We changed the symbol. Start over in order
14016 to get h, sym, sec etc. right. */
c316a17c 14017 goto again;
727fc41e
AM		 14018 }
14019 }
14020 break;
14021
14022 case R_PPC64_TLSGD:
14023 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
14024 {
14025 unsigned int insn2, insn3;
14026 bfd_vma offset = rel->r_offset;
14027
14028 if ((tls_mask & TLS_TPRELGD) != 0)
14029 {
14030 /* IE */
14031 r_type = R_PPC64_NONE;
14032 insn2 = 0x7c636a14; /* add 3,3,13 */
14033 }
14034 else
14035 {
14036 /* LE */
14037 if (toc_symndx != 0)
14038 {
14039 r_symndx = toc_symndx;
14040 rel->r_addend = toc_addend;
14041 }
14042 r_type = R_PPC64_TPREL16_LO;
14043 rel->r_offset = offset + d_offset;
14044 insn2 = 0x38630000; /* addi 3,3,0 */
14045 }
14046 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14047 /* Zap the reloc on the _tls_get_addr call too. */
14048 BFD_ASSERT (offset == rel[1].r_offset);
f58d5a2d 14049 rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
95f0d0d2 14050 insn3 = bfd_get_32 (input_bfd,
3a71aa26 14051 contents + offset + 4);
102890f0
AM		 14052 if (insn3 == NOP
14053 || insn3 == CROR_151515 || insn3 == CROR_313131)
14054 {
727fc41e 14055 rel->r_offset += 4;
95f0d0d2 14056 bfd_put_32 (input_bfd, insn2, contents + offset + 4);
3a71aa26 14057 insn2 = NOP;
102890f0 14058 }
95f0d0d2 14059 bfd_put_32 (input_bfd, insn2, contents + offset);
727fc41e 14060 if ((tls_mask & TLS_TPRELGD) == 0 && toc_symndx != 0)
c316a17c 14061 goto again;
411e1bfb 14062 }
411e1bfb
AM		 14063 break;
14064
727fc41e
AM		 14065 case R_PPC64_TLSLD:
14066 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
14067 {
14068 unsigned int insn2, insn3;
14069 bfd_vma offset = rel->r_offset;
14070
14071 if (toc_symndx)
14072 sec = local_sections[toc_symndx];
14073 for (r_symndx = 0;
14074 r_symndx < symtab_hdr->sh_info;
14075 r_symndx++)
14076 if (local_sections[r_symndx] == sec)
14077 break;
14078 if (r_symndx >= symtab_hdr->sh_info)
cf35638d 14079 r_symndx = STN_UNDEF;
727fc41e 14080 rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
cf35638d 14081 if (r_symndx != STN_UNDEF)
727fc41e
AM		 14082 rel->r_addend -= (local_syms[r_symndx].st_value
14083 + sec->output_offset
14084 + sec->output_section->vma);
14085
14086 r_type = R_PPC64_TPREL16_LO;
14087 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14088 rel->r_offset = offset + d_offset;
14089 /* Zap the reloc on the _tls_get_addr call too. */
14090 BFD_ASSERT (offset == rel[1].r_offset);
f58d5a2d 14091 rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
727fc41e 14092 insn2 = 0x38630000; /* addi 3,3,0 */
95f0d0d2 14093 insn3 = bfd_get_32 (input_bfd,
727fc41e
AM		 14094 contents + offset + 4);
14095 if (insn3 == NOP
14096 || insn3 == CROR_151515 || insn3 == CROR_313131)
14097 {
14098 rel->r_offset += 4;
95f0d0d2 14099 bfd_put_32 (input_bfd, insn2, contents + offset + 4);
727fc41e
AM		 14100 insn2 = NOP;
14101 }
95f0d0d2 14102 bfd_put_32 (input_bfd, insn2, contents + offset);
c316a17c 14103 goto again;
727fc41e
AM		 14104 }
14105 break;
14106
411e1bfb 14107 case R_PPC64_DTPMOD64:
951fd09b
AM		 14108 if (rel + 1 < relend
14109 && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
14110 && rel[1].r_offset == rel->r_offset + 8)
411e1bfb 14111 {
951fd09b
AM		 14112 if ((tls_mask & TLS_GD) == 0)
14113 {
14114 rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_NONE);
14115 if ((tls_mask & TLS_TPRELGD) != 0)
14116 r_type = R_PPC64_TPREL64;
14117 else
14118 {
4ce794b7 14119 bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
951fd09b
AM		 14120 r_type = R_PPC64_NONE;
14121 }
14122 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14123 }
14124 }
14125 else
14126 {
14127 if ((tls_mask & TLS_LD) == 0)
411e1bfb 14128 {
4ce794b7 14129 bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
411e1bfb 14130 r_type = R_PPC64_NONE;
951fd09b 14131 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
411e1bfb 14132 }
411e1bfb
AM		 14133 }
14134 break;
14135
14136 case R_PPC64_TPREL64:
951fd09b 14137 if ((tls_mask & TLS_TPREL) == 0)
411e1bfb
AM		 14138 {
14139 r_type = R_PPC64_NONE;
14140 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14141 }
14142 break;
52a82034 14143
006589cf
AM		 14144 case R_PPC64_ENTRY:
14145 relocation = TOCstart + htab->sec_info[input_section->id].toc_off;
14146 if (!bfd_link_pic (info)
14147 && !info->traditional_format
14148 && relocation + 0x80008000 <= 0xffffffff)
14149 {
14150 unsigned int insn1, insn2;
14151
14152 insn1 = bfd_get_32 (input_bfd, contents + rel->r_offset);
14153 insn2 = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
14154 if ((insn1 & ~0xfffc) == LD_R2_0R12
14155 && insn2 == ADD_R2_R2_R12)
14156 {
95f0d0d2 14157 bfd_put_32 (input_bfd,
006589cf
AM		 14158 LIS_R2 + PPC_HA (relocation),
14159 contents + rel->r_offset);
95f0d0d2 14160 bfd_put_32 (input_bfd,
006589cf
AM		 14161 ADDI_R2_R2 + PPC_LO (relocation),
14162 contents + rel->r_offset + 4);
14163 }
14164 }
14165 else
14166 {
14167 relocation -= (rel->r_offset
14168 + input_section->output_offset
14169 + input_section->output_section->vma);
14170 if (relocation + 0x80008000 <= 0xffffffff)
14171 {
14172 unsigned int insn1, insn2;
14173
14174 insn1 = bfd_get_32 (input_bfd, contents + rel->r_offset);
14175 insn2 = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
14176 if ((insn1 & ~0xfffc) == LD_R2_0R12
14177 && insn2 == ADD_R2_R2_R12)
14178 {
95f0d0d2 14179 bfd_put_32 (input_bfd,
006589cf
AM		 14180 ADDIS_R2_R12 + PPC_HA (relocation),
14181 contents + rel->r_offset);
95f0d0d2 14182 bfd_put_32 (input_bfd,
006589cf
AM		 14183 ADDI_R2_R2 + PPC_LO (relocation),
14184 contents + rel->r_offset + 4);
14185 }
14186 }
14187 }
14188 break;
14189
52a82034
AM		 14190 case R_PPC64_REL16_HA:
14191 /* If we are generating a non-PIC executable, edit
14192 . 0: addis 2,12,.TOC.-0b@ha
14193 . addi 2,2,.TOC.-0b@l
14194 used by ELFv2 global entry points to set up r2, to
14195 . lis 2,.TOC.@ha
14196 . addi 2,2,.TOC.@l
14197 if .TOC. is in range. */
0e1862bb 14198 if (!bfd_link_pic (info)
810d4e75 14199 && !info->traditional_format
006589cf 14200 && !htab->opd_abi
4f038ee5 14201 && rel->r_addend == d_offset
52a82034
AM		 14202 && h != NULL && &h->elf == htab->elf.hgot
14203 && rel + 1 < relend
14204 && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_REL16_LO)
14205 && rel[1].r_offset == rel->r_offset + 4
14206 && rel[1].r_addend == rel->r_addend + 4
14207 && relocation + 0x80008000 <= 0xffffffff)
14208 {
14209 unsigned int insn1, insn2;
14210 bfd_vma offset = rel->r_offset - d_offset;
95f0d0d2
AM		 14211 insn1 = bfd_get_32 (input_bfd, contents + offset);
14212 insn2 = bfd_get_32 (input_bfd, contents + offset + 4);
006589cf
AM		 14213 if ((insn1 & 0xffff0000) == ADDIS_R2_R12
14214 && (insn2 & 0xffff0000) == ADDI_R2_R2)
52a82034
AM		 14215 {
14216 r_type = R_PPC64_ADDR16_HA;
14217 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14218 rel->r_addend -= d_offset;
14219 rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_ADDR16_LO);
14220 rel[1].r_addend -= d_offset + 4;
95f0d0d2 14221 bfd_put_32 (input_bfd, LIS_R2, contents + offset);
52a82034
AM		 14222 }
14223 }
14224 break;
411e1bfb
AM		 14225 }
14226
14227 /* Handle other relocations that tweak non-addend part of insn. */
86c76c7b 14228 insn = 0;
b25116a9
AM		 14229 max_br_offset = 1 << 25;
14230 addend = rel->r_addend;
bc30df16 14231 reloc_dest = DEST_NORMAL;
65f38f15 14232 switch (r_type)
5bd4f169
AM		 14233 {
14234 default:
65f38f15 14235 break;
5bd4f169 14236
3b421ab3
AM		 14237 case R_PPC64_TOCSAVE:
14238 if (relocation + addend == (rel->r_offset
14239 + input_section->output_offset
14240 + input_section->output_section->vma)
14241 && tocsave_find (htab, NO_INSERT,
14242 &local_syms, rel, input_bfd))
14243 {
14244 insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
14245 if (insn == NOP
14246 || insn == CROR_151515 || insn == CROR_313131)
a078d95a
AM		 14247 bfd_put_32 (input_bfd,
14248 STD_R2_0R1 + STK_TOC (htab),
3b421ab3
AM		 14249 contents + rel->r_offset);
14250 }
14251 break;
14252
65f38f15
AM		 14253 /* Branch taken prediction relocations. */
14254 case R_PPC64_ADDR14_BRTAKEN:
14255 case R_PPC64_REL14_BRTAKEN:
cedb70c5 14256 insn = 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field. */
1a0670f3 14257 /* Fall through. */
65f38f15 14258
86c76c7b 14259 /* Branch not taken prediction relocations. */
65f38f15
AM		 14260 case R_PPC64_ADDR14_BRNTAKEN:
14261 case R_PPC64_REL14_BRNTAKEN:
95f0d0d2 14262 insn |= bfd_get_32 (input_bfd,
411e1bfb 14263 contents + rel->r_offset) & ~(0x01 << 21);
1a0670f3 14264 /* Fall through. */
86c76c7b 14265
b25116a9
AM		 14266 case R_PPC64_REL14:
14267 max_br_offset = 1 << 15;
1a0670f3 14268 /* Fall through. */
5bd4f169 14269
65f38f15 14270 case R_PPC64_REL24:
ad8e1ba5
AM		 14271 /* Calls to functions with a different TOC, such as calls to
14272 shared objects, need to alter the TOC pointer. This is
14273 done using a linkage stub. A REL24 branching to these
14274 linkage stubs needs to be followed by a nop, as the nop
14275 will be replaced with an instruction to restore the TOC
14276 base pointer. */
8387904d 14277 fdh = h;
b31867b6
AM		 14278 if (h != NULL
14279 && h->oh != NULL
14280 && h->oh->is_func_descriptor)
14281 fdh = ppc_follow_link (h->oh);
31c76678
DK		 14282 stub_entry = ppc_get_stub_entry (input_section, sec, fdh, &orig_rel,
14283 htab);
6abec6bc 14284 if (stub_entry != NULL
ad8e1ba5 14285 && (stub_entry->stub_type == ppc_stub_plt_call
794e51c0 14286 || stub_entry->stub_type == ppc_stub_plt_call_r2save
ad8e1ba5
AM		 14287 || stub_entry->stub_type == ppc_stub_plt_branch_r2off
14288 || stub_entry->stub_type == ppc_stub_long_branch_r2off))
41bd81ab 14289 {
b25116a9 14290 bfd_boolean can_plt_call = FALSE;
721956f4 14291
6e1816be
AM		 14292 if (stub_entry->stub_type == ppc_stub_plt_call
14293 && !htab->opd_abi
14294 && htab->params->plt_localentry0 != 0
14295 && is_elfv2_localentry0 (&h->elf))
14296 {
14297 /* The function doesn't use or change r2. */
14298 can_plt_call = TRUE;
14299 }
14300
f378ab09 14301 /* All of these stubs may modify r2, so there must be a
ba8ca3e7
AM		 14302 branch and link followed by a nop. The nop is
14303 replaced by an insn to restore r2. */
6e1816be 14304 else if (rel->r_offset + 8 <= input_section->size)
41bd81ab 14305 {
ba8ca3e7
AM		 14306 unsigned long br;
14307
14308 br = bfd_get_32 (input_bfd,
14309 contents + rel->r_offset);
14310 if ((br & 1) != 0)
41bd81ab 14311 {
ba8ca3e7
AM		 14312 unsigned long nop;
14313
14314 nop = bfd_get_32 (input_bfd,
14315 contents + rel->r_offset + 4);
14316 if (nop == NOP
14317 || nop == CROR_151515 || nop == CROR_313131)
a7f2871e 14318 {
ba8ca3e7
AM		 14319 if (h != NULL
14320 && (h == htab->tls_get_addr_fd
14321 || h == htab->tls_get_addr)
7c9cf415 14322 && htab->params->tls_get_addr_opt)
ba8ca3e7
AM		 14323 {
14324 /* Special stub used, leave nop alone. */
14325 }
14326 else
a078d95a
AM		 14327 bfd_put_32 (input_bfd,
14328 LD_R2_0R1 + STK_TOC (htab),
ba8ca3e7
AM		 14329 contents + rel->r_offset + 4);
14330 can_plt_call = TRUE;
a7f2871e 14331 }
41bd81ab 14332 }
5bd4f169 14333 }
721956f4 14334
ba8ca3e7 14335 if (!can_plt_call && h != NULL)
721956f4 14336 {
ba8ca3e7
AM		 14337 const char *name = h->elf.root.root.string;
14338
14339 if (*name == '.')
14340 ++name;
14341
14342 if (strncmp (name, "__libc_start_main", 17) == 0
14343 && (name[17] == 0 || name[17] == '@'))
6ab189d5 14344 {
ba8ca3e7
AM		 14345 /* Allow crt1 branch to go via a toc adjusting
14346 stub. Other calls that never return could do
14347 the same, if we could detect such. */
b25116a9 14348 can_plt_call = TRUE;
6ab189d5 14349 }
ba8ca3e7
AM		 14350 }
14351
14352 if (!can_plt_call)
14353 {
14354 /* g++ as of 20130507 emits self-calls without a
14355 following nop. This is arguably wrong since we
14356 have conflicting information. On the one hand a
14357 global symbol and on the other a local call
14358 sequence, but don't error for this special case.
14359 It isn't possible to cheaply verify we have
14360 exactly such a call. Allow all calls to the same
14361 section. */
14362 asection *code_sec = sec;
14363
14364 if (get_opd_info (sec) != NULL)
ad8e1ba5 14365 {
ba8ca3e7
AM		 14366 bfd_vma off = (relocation + addend
14367 - sec->output_section->vma
14368 - sec->output_offset);
bc30df16 14369
ba8ca3e7 14370 opd_entry_value (sec, off, &code_sec, NULL, FALSE);
ad8e1ba5 14371 }
ba8ca3e7
AM		 14372 if (code_sec == input_section)
14373 can_plt_call = TRUE;
14374 }
14375
14376 if (!can_plt_call)
14377 {
4805fc55
AM		 14378 if (stub_entry->stub_type == ppc_stub_plt_call
14379 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
14380 info->callbacks->einfo
695344c0 14381 /* xgettext:c-format */
174d0a74 14382 (_("%H: call to `%T' lacks nop, can't restore toc; "
4805fc55
AM		 14383 "recompile with -fPIC\n"),
14384 input_bfd, input_section, rel->r_offset, sym_name);
14385 else
14386 info->callbacks->einfo
695344c0 14387 /* xgettext:c-format */
174d0a74 14388 (_("%H: call to `%T' lacks nop, can't restore toc; "
4805fc55
AM		 14389 "(-mcmodel=small toc adjust stub)\n"),
14390 input_bfd, input_section, rel->r_offset, sym_name);
ba8ca3e7
AM		 14391
14392 bfd_set_error (bfd_error_bad_value);
14393 ret = FALSE;
721956f4
AM		 14394 }
14395
b25116a9 14396 if (can_plt_call
794e51c0
AM		 14397 && (stub_entry->stub_type == ppc_stub_plt_call
14398 || stub_entry->stub_type == ppc_stub_plt_call_r2save))
b25116a9
AM		 14399 unresolved_reloc = FALSE;
14400 }
14401
6abec6bc
AM		 14402 if ((stub_entry == NULL
14403 || stub_entry->stub_type == ppc_stub_long_branch
14404 || stub_entry->stub_type == ppc_stub_plt_branch)
8387904d
AM		 14405 && get_opd_info (sec) != NULL)
14406 {
14407 /* The branch destination is the value of the opd entry. */
4cc603a5
AM		 14408 bfd_vma off = (relocation + addend
14409 - sec->output_section->vma
14410 - sec->output_offset);
aef36ac1 14411 bfd_vma dest = opd_entry_value (sec, off, NULL, NULL, FALSE);
8387904d
AM		 14412 if (dest != (bfd_vma) -1)
14413 {
14414 relocation = dest;
14415 addend = 0;
bc30df16 14416 reloc_dest = DEST_OPD;
8387904d
AM		 14417 }
14418 }
14419
b25116a9
AM		 14420 /* If the branch is out of reach we ought to have a long
14421 branch stub. */
14422 from = (rel->r_offset
14423 + input_section->output_offset
14424 + input_section->output_section->vma);
14425
6911b7dc
AM		 14426 relocation += PPC64_LOCAL_ENTRY_OFFSET (fdh
14427 ? fdh->elf.other
14428 : sym->st_other);
14429
6abec6bc
AM		 14430 if (stub_entry != NULL
14431 && (stub_entry->stub_type == ppc_stub_long_branch
14432 || stub_entry->stub_type == ppc_stub_plt_branch)
14433 && (r_type == R_PPC64_ADDR14_BRTAKEN
14434 || r_type == R_PPC64_ADDR14_BRNTAKEN
14435 || (relocation + addend - from + max_br_offset
14436 < 2 * max_br_offset)))
14437 /* Don't use the stub if this branch is in range. */
14438 stub_entry = NULL;
b25116a9
AM		 14439
14440 if (stub_entry != NULL)
14441 {
14442 /* Munge up the value and addend so that we call the stub
14443 rather than the procedure directly. */
a4b6fadd
AM		 14444 asection *stub_sec = stub_entry->group->stub_sec;
14445
14446 if (stub_entry->stub_type == ppc_stub_save_res)
14447 relocation += (stub_sec->output_offset
14448 + stub_sec->output_section->vma
14449 + stub_sec->size - htab->sfpr->size
14450 - htab->sfpr->output_offset
14451 - htab->sfpr->output_section->vma);
14452 else
14453 relocation = (stub_entry->stub_offset
14454 + stub_sec->output_offset
14455 + stub_sec->output_section->vma);
b25116a9 14456 addend = 0;
bc30df16 14457 reloc_dest = DEST_STUB;
3b421ab3 14458
954b63d4 14459 if ((stub_entry->stub_type == ppc_stub_plt_call
794e51c0
AM		 14460 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
14461 && (ALWAYS_EMIT_R2SAVE
14462 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
3b421ab3
AM		 14463 && rel + 1 < relend
14464 && rel[1].r_offset == rel->r_offset + 4
14465 && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOCSAVE)
14466 relocation += 4;
b25116a9
AM		 14467 }
14468
14469 if (insn != 0)
14470 {
794e51c0 14471 if (is_isa_v2)
721956f4 14472 {
b25116a9
AM		 14473 /* Set 'a' bit. This is 0b00010 in BO field for branch
14474 on CR(BI) insns (BO == 001at or 011at), and 0b01000
14475 for branch on CTR insns (BO == 1a00t or 1a01t). */
14476 if ((insn & (0x14 << 21)) == (0x04 << 21))
14477 insn |= 0x02 << 21;
14478 else if ((insn & (0x14 << 21)) == (0x10 << 21))
14479 insn |= 0x08 << 21;
14480 else
14481 break;
14482 }
14483 else
14484 {
14485 /* Invert 'y' bit if not the default. */
4cc603a5 14486 if ((bfd_signed_vma) (relocation + addend - from) < 0)
b25116a9 14487 insn ^= 0x01 << 21;
721956f4 14488 }
b25116a9 14489
95f0d0d2 14490 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
5bd4f169 14491 }
e86ce104 14492
06da1e8e
AM		 14493 /* NOP out calls to undefined weak functions.
14494 We can thus call a weak function without first
14495 checking whether the function is defined. */
b25116a9 14496 else if (h != NULL
039b3fef 14497 && h->elf.root.type == bfd_link_hash_undefweak
766bc656 14498 && h->elf.dynindx == -1
b25116a9
AM		 14499 && r_type == R_PPC64_REL24
14500 && relocation == 0
4cc603a5 14501 && addend == 0)
e86ce104 14502 {
95f0d0d2 14503 bfd_put_32 (input_bfd, NOP, contents + rel->r_offset);
c316a17c 14504 goto copy_reloc;
e86ce104 14505 }
65f38f15
AM		 14506 break;
14507 }
5bd4f169 14508
65f38f15 14509 /* Set `addend'. */
411e1bfb 14510 tls_type = 0;
65f38f15
AM		 14511 switch (r_type)
14512 {
14513 default:
25f53a85 14514 info->callbacks->einfo
695344c0 14515 /* xgettext:c-format */
bc30df16 14516 (_("%P: %B: unknown relocation type %d for `%T'\n"),
d003868e 14517 input_bfd, (int) r_type, sym_name);
5bd4f169 14518
65f38f15 14519 bfd_set_error (bfd_error_bad_value);
b34976b6 14520 ret = FALSE;
c316a17c 14521 goto copy_reloc;
5bd4f169 14522
65f38f15 14523 case R_PPC64_NONE:
411e1bfb 14524 case R_PPC64_TLS:
727fc41e
AM		 14525 case R_PPC64_TLSGD:
14526 case R_PPC64_TLSLD:
3b421ab3 14527 case R_PPC64_TOCSAVE:
04c9666a
AM		 14528 case R_PPC64_GNU_VTINHERIT:
14529 case R_PPC64_GNU_VTENTRY:
006589cf 14530 case R_PPC64_ENTRY:
c316a17c 14531 goto copy_reloc;
5bd4f169
AM		 14532
14533 /* GOT16 relocations. Like an ADDR16 using the symbol's
14534 address in the GOT as relocation value instead of the
411e1bfb 14535 symbol's value itself. Also, create a GOT entry for the
5bd4f169 14536 symbol and put the symbol value there. */
411e1bfb
AM		 14537 case R_PPC64_GOT_TLSGD16:
14538 case R_PPC64_GOT_TLSGD16_LO:
14539 case R_PPC64_GOT_TLSGD16_HI:
14540 case R_PPC64_GOT_TLSGD16_HA:
951fd09b 14541 tls_type = TLS_TLS | TLS_GD;
411e1bfb
AM		 14542 goto dogot;
14543
14544 case R_PPC64_GOT_TLSLD16:
14545 case R_PPC64_GOT_TLSLD16_LO:
14546 case R_PPC64_GOT_TLSLD16_HI:
14547 case R_PPC64_GOT_TLSLD16_HA:
951fd09b 14548 tls_type = TLS_TLS | TLS_LD;
411e1bfb
AM		 14549 goto dogot;
14550
14551 case R_PPC64_GOT_TPREL16_DS:
14552 case R_PPC64_GOT_TPREL16_LO_DS:
14553 case R_PPC64_GOT_TPREL16_HI:
14554 case R_PPC64_GOT_TPREL16_HA:
14555 tls_type = TLS_TLS | TLS_TPREL;
14556 goto dogot;
14557
14558 case R_PPC64_GOT_DTPREL16_DS:
14559 case R_PPC64_GOT_DTPREL16_LO_DS:
14560 case R_PPC64_GOT_DTPREL16_HI:
14561 case R_PPC64_GOT_DTPREL16_HA:
14562 tls_type = TLS_TLS | TLS_DTPREL;
14563 goto dogot;
14564
65f38f15
AM		 14565 case R_PPC64_GOT16:
14566 case R_PPC64_GOT16_LO:
14567 case R_PPC64_GOT16_HI:
14568 case R_PPC64_GOT16_HA:
14569 case R_PPC64_GOT16_DS:
14570 case R_PPC64_GOT16_LO_DS:
411e1bfb 14571 dogot:
5bd4f169
AM		 14572 {
14573 /* Relocation is to the entry for this symbol in the global
14574 offset table. */
e717da7e 14575 asection *got;
d881513a 14576 bfd_vma *offp;
5bd4f169 14577 bfd_vma off;
d881513a 14578 unsigned long indx = 0;
927be08e 14579 struct got_entry *ent;
65f38f15 14580
d881513a
AM		 14581 if (tls_type == (TLS_TLS | TLS_LD)
14582 && (h == NULL
f5385ebf 14583 || !h->elf.def_dynamic))
927be08e 14584 ent = ppc64_tlsld_got (input_bfd);
411e1bfb 14585 else
5bd4f169 14586 {
d881513a
AM		 14587 if (h != NULL)
14588 {
f0158f44
AM		 14589 if (!htab->elf.dynamic_sections_created
14590 || h->elf.dynindx == -1
14591 || SYMBOL_REFERENCES_LOCAL (info, &h->elf)
21d68fcd 14592 || UNDEFWEAK_NO_DYNAMIC_RELOC (info, &h->elf))
d881513a
AM		 14593 /* This is actually a static link, or it is a
14594 -Bsymbolic link and the symbol is defined
14595 locally, or the symbol was forced to be local
14596 because of a version file. */
14597 ;
14598 else
14599 {
039b3fef 14600 indx = h->elf.dynindx;
d881513a
AM		 14601 unresolved_reloc = FALSE;
14602 }
039b3fef 14603 ent = h->elf.got.glist;
d881513a 14604 }
411e1bfb 14605 else
5bd4f169 14606 {
d881513a
AM		 14607 if (local_got_ents == NULL)
14608 abort ();
14609 ent = local_got_ents[r_symndx];
5bd4f169 14610 }
d881513a
AM		 14611
14612 for (; ent != NULL; ent = ent->next)
31c76678 14613 if (ent->addend == orig_rel.r_addend
e717da7e 14614 && ent->owner == input_bfd
d881513a
AM		 14615 && ent->tls_type == tls_type)
14616 break;
5bd4f169 14617 }
411e1bfb 14618
927be08e
AM		 14619 if (ent == NULL)
14620 abort ();
14621 if (ent->is_indirect)
14622 ent = ent->got.ent;
14623 offp = &ent->got.offset;
14624 got = ppc64_elf_tdata (ent->owner)->got;
e717da7e
AM		 14625 if (got == NULL)
14626 abort ();
14627
411e1bfb
AM		 14628 /* The offset must always be a multiple of 8. We use the
14629 least significant bit to record whether we have already
14630 processed this entry. */
d881513a 14631 off = *offp;
411e1bfb
AM		 14632 if ((off & 1) != 0)
14633 off &= ~1;
5bd4f169
AM		 14634 else
14635 {
411e1bfb
AM		 14636 /* Generate relocs for the dynamic linker, except in
14637 the case of TLSLD where we'll use one entry per
14638 module. */
25f23106
AM		 14639 asection *relgot;
14640 bfd_boolean ifunc;
e717da7e 14641
d881513a 14642 *offp = off | 1;
25f23106
AM		 14643 relgot = NULL;
14644 ifunc = (h != NULL
14645 ? h->elf.type == STT_GNU_IFUNC
14646 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC);
19e08130 14647 if (ifunc)
82e66161
AM		 14648 {
14649 relgot = htab->elf.irelplt;
14650 if (indx == 0)
14651 htab->local_ifunc_resolver = 1;
14652 else if (is_static_defined (&h->elf))
14653 htab->maybe_local_ifunc_resolver = 1;
14654 }
f0158f44
AM		 14655 else if (indx != 0
14656 || (bfd_link_pic (info)
14657 && (h == NULL
21d68fcd 14658 || !UNDEFWEAK_NO_DYNAMIC_RELOC (info, &h->elf)
f0158f44
AM		 14659 || (tls_type == (TLS_TLS | TLS_LD)
14660 && !h->elf.def_dynamic))))
19e08130 14661 relgot = ppc64_elf_tdata (ent->owner)->relgot;
25f23106 14662 if (relgot != NULL)
5bd4f169 14663 {
e717da7e
AM		 14664 outrel.r_offset = (got->output_section->vma
14665 + got->output_offset
411e1bfb 14666 + off);
4cc603a5 14667 outrel.r_addend = addend;
d881513a 14668 if (tls_type & (TLS_LD | TLS_GD))
5bd4f169 14669 {
411e1bfb 14670 outrel.r_addend = 0;
e515b051 14671 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPMOD64);
d881513a
AM		 14672 if (tls_type == (TLS_TLS | TLS_GD))
14673 {
e717da7e
AM		 14674 loc = relgot->contents;
14675 loc += (relgot->reloc_count++
d881513a
AM		 14676 * sizeof (Elf64_External_Rela));
14677 bfd_elf64_swap_reloca_out (output_bfd,
14678 &outrel, loc);
e515b051 14679 outrel.r_offset += 8;
4cc603a5 14680 outrel.r_addend = addend;
d881513a
AM		 14681 outrel.r_info
14682 = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
d881513a 14683 }
411e1bfb 14684 }
951fd09b 14685 else if (tls_type == (TLS_TLS | TLS_DTPREL))
411e1bfb 14686 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
951fd09b 14687 else if (tls_type == (TLS_TLS | TLS_TPREL))
411e1bfb 14688 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_TPREL64);
25f23106
AM		 14689 else if (indx != 0)
14690 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_GLOB_DAT);
14691 else
81407a69 14692 {
25f23106
AM		 14693 if (ifunc)
14694 outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
14695 else
14696 outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
81407a69
AM		 14697
14698 /* Write the .got section contents for the sake
14699 of prelink. */
e717da7e 14700 loc = got->contents + off;
23fbd6fa
JJ		 14701 bfd_put_64 (output_bfd, outrel.r_addend + relocation,
14702 loc);
81407a69 14703 }
81407a69
AM		 14704
14705 if (indx == 0 && tls_type != (TLS_TLS | TLS_LD))
e515b051
AM		 14706 {
14707 outrel.r_addend += relocation;
14708 if (tls_type & (TLS_GD | TLS_DTPREL | TLS_TPREL))
989f9879
AM		 14709 {
14710 if (htab->elf.tls_sec == NULL)
14711 outrel.r_addend = 0;
14712 else
14713 outrel.r_addend -= htab->elf.tls_sec->vma;
14714 }
e515b051 14715 }
e717da7e
AM		 14716 loc = relgot->contents;
14717 loc += (relgot->reloc_count++
411e1bfb
AM		 14718 * sizeof (Elf64_External_Rela));
14719 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
14720 }
14721
ad8e1ba5 14722 /* Init the .got section contents here if we're not
81407a69 14723 emitting a reloc. */
d881513a 14724 else
411e1bfb 14725 {
4cc603a5 14726 relocation += addend;
f0158f44 14727 if (tls_type != 0)
411e1bfb 14728 {
989f9879
AM		 14729 if (htab->elf.tls_sec == NULL)
14730 relocation = 0;
14731 else
14732 {
f0158f44
AM		 14733 if (tls_type & TLS_LD)
14734 relocation = 0;
14735 else
14736 relocation -= htab->elf.tls_sec->vma + DTP_OFFSET;
676ee2b5 14737 if (tls_type & TLS_TPREL)
989f9879
AM		 14738 relocation += DTP_OFFSET - TP_OFFSET;
14739 }
5bd4f169 14740
f0158f44 14741 if (tls_type & (TLS_GD | TLS_LD))
7b609f53
AM		 14742 {
14743 bfd_put_64 (output_bfd, relocation,
e717da7e 14744 got->contents + off + 8);
676ee2b5 14745 relocation = 1;
7b609f53 14746 }
411e1bfb
AM		 14747 }
14748 bfd_put_64 (output_bfd, relocation,
e717da7e 14749 got->contents + off);
5bd4f169
AM		 14750 }
14751 }
14752
65f38f15
AM		 14753 if (off >= (bfd_vma) -2)
14754 abort ();
14755
bf102f86 14756 relocation = got->output_section->vma + got->output_offset + off;
6f20ed8a 14757 addend = -(TOCstart + htab->sec_info[input_section->id].toc_off);
5bd4f169 14758 }
65f38f15
AM		 14759 break;
14760
14761 case R_PPC64_PLT16_HA:
14762 case R_PPC64_PLT16_HI:
14763 case R_PPC64_PLT16_LO:
14764 case R_PPC64_PLT32:
14765 case R_PPC64_PLT64:
14766 /* Relocation is to the entry for this symbol in the
14767 procedure linkage table. */
cbf95972
AM		 14768 {
14769 struct plt_entry **plt_list = NULL;
14770 if (h != NULL)
14771 plt_list = &h->elf.plt.plist;
14772 else if (local_got_ents != NULL)
14773 {
14774 struct plt_entry **local_plt = (struct plt_entry **)
14775 (local_got_ents + symtab_hdr->sh_info);
14776 unsigned char *local_got_tls_masks = (unsigned char *)
14777 (local_plt + symtab_hdr->sh_info);
14778 if ((local_got_tls_masks[r_symndx] & PLT_IFUNC) != 0)
14779 plt_list = local_plt + r_symndx;
14780 }
14781 if (plt_list)
14782 {
14783 struct plt_entry *ent;
65f38f15 14784
cbf95972
AM		 14785 for (ent = *plt_list; ent != NULL; ent = ent->next)
14786 if (ent->plt.offset != (bfd_vma) -1
14787 && ent->addend == orig_rel.r_addend)
14788 {
14789 asection *plt;
14790
14791 plt = htab->elf.splt;
14792 if (!htab->elf.dynamic_sections_created
14793 || h == NULL
14794 || h->elf.dynindx == -1)
14795 plt = htab->elf.iplt;
14796 relocation = (plt->output_section->vma
14797 + plt->output_offset
14798 + ent->plt.offset);
14799 addend = 0;
14800 unresolved_reloc = FALSE;
14801 break;
14802 }
14803 }
14804 }
65f38f15 14805 break;
5bd4f169 14806
0b13192e
AM		 14807 case R_PPC64_TOC:
14808 /* Relocation value is TOC base. */
14809 relocation = TOCstart;
cf35638d 14810 if (r_symndx == STN_UNDEF)
6f20ed8a 14811 relocation += htab->sec_info[input_section->id].toc_off;
8517fae7
AM		 14812 else if (unresolved_reloc)
14813 ;
6f20ed8a
AM		 14814 else if (sec != NULL && sec->id < htab->sec_info_arr_size)
14815 relocation += htab->sec_info[sec->id].toc_off;
0b13192e
AM		 14816 else
14817 unresolved_reloc = TRUE;
ab96bf03 14818 goto dodyn;
0b13192e 14819
5bd4f169
AM		 14820 /* TOC16 relocs. We want the offset relative to the TOC base,
14821 which is the address of the start of the TOC plus 0x8000.
14822 The TOC consists of sections .got, .toc, .tocbss, and .plt,
14823 in this order. */
65f38f15
AM		 14824 case R_PPC64_TOC16:
14825 case R_PPC64_TOC16_LO:
14826 case R_PPC64_TOC16_HI:
14827 case R_PPC64_TOC16_DS:
14828 case R_PPC64_TOC16_LO_DS:
14829 case R_PPC64_TOC16_HA:
6f20ed8a 14830 addend -= TOCstart + htab->sec_info[input_section->id].toc_off;
5bd4f169
AM		 14831 break;
14832
14833 /* Relocate against the beginning of the section. */
65f38f15
AM		 14834 case R_PPC64_SECTOFF:
14835 case R_PPC64_SECTOFF_LO:
14836 case R_PPC64_SECTOFF_HI:
14837 case R_PPC64_SECTOFF_DS:
14838 case R_PPC64_SECTOFF_LO_DS:
14839 case R_PPC64_SECTOFF_HA:
4ce794b7 14840 if (sec != NULL)
65f38f15 14841 addend -= sec->output_section->vma;
5bd4f169
AM		 14842 break;
14843
25f23106
AM		 14844 case R_PPC64_REL16:
14845 case R_PPC64_REL16_LO:
14846 case R_PPC64_REL16_HI:
14847 case R_PPC64_REL16_HA:
a680de9a 14848 case R_PPC64_REL16DX_HA:
25f23106
AM		 14849 break;
14850
721956f4
AM		 14851 case R_PPC64_REL14:
14852 case R_PPC64_REL14_BRNTAKEN:
14853 case R_PPC64_REL14_BRTAKEN:
5d1634d7
AM		 14854 case R_PPC64_REL24:
14855 break;
14856
411e1bfb
AM		 14857 case R_PPC64_TPREL16:
14858 case R_PPC64_TPREL16_LO:
14859 case R_PPC64_TPREL16_HI:
14860 case R_PPC64_TPREL16_HA:
14861 case R_PPC64_TPREL16_DS:
14862 case R_PPC64_TPREL16_LO_DS:
f9c6b907
AM		 14863 case R_PPC64_TPREL16_HIGH:
14864 case R_PPC64_TPREL16_HIGHA:
411e1bfb
AM		 14865 case R_PPC64_TPREL16_HIGHER:
14866 case R_PPC64_TPREL16_HIGHERA:
14867 case R_PPC64_TPREL16_HIGHEST:
14868 case R_PPC64_TPREL16_HIGHESTA:
766bc656
AM		 14869 if (h != NULL
14870 && h->elf.root.type == bfd_link_hash_undefweak
14871 && h->elf.dynindx == -1)
14872 {
14873 /* Make this relocation against an undefined weak symbol
14874 resolve to zero. This is really just a tweak, since
14875 code using weak externs ought to check that they are
14876 defined before using them. */
14877 bfd_byte *p = contents + rel->r_offset - d_offset;
14878
95f0d0d2 14879 insn = bfd_get_32 (input_bfd, p);
766bc656
AM		 14880 insn = _bfd_elf_ppc_at_tprel_transform (insn, 13);
14881 if (insn != 0)
95f0d0d2 14882 bfd_put_32 (input_bfd, insn, p);
766bc656
AM		 14883 break;
14884 }
989f9879
AM		 14885 if (htab->elf.tls_sec != NULL)
14886 addend -= htab->elf.tls_sec->vma + TP_OFFSET;
0e1862bb 14887 if (bfd_link_pic (info))
411e1bfb
AM		 14888 /* The TPREL16 relocs shouldn't really be used in shared
14889 libs as they will result in DT_TEXTREL being set, but
14890 support them anyway. */
14891 goto dodyn;
14892 break;
14893
14894 case R_PPC64_DTPREL16:
14895 case R_PPC64_DTPREL16_LO:
14896 case R_PPC64_DTPREL16_HI:
14897 case R_PPC64_DTPREL16_HA:
14898 case R_PPC64_DTPREL16_DS:
14899 case R_PPC64_DTPREL16_LO_DS:
f9c6b907
AM		 14900 case R_PPC64_DTPREL16_HIGH:
14901 case R_PPC64_DTPREL16_HIGHA:
411e1bfb
AM		 14902 case R_PPC64_DTPREL16_HIGHER:
14903 case R_PPC64_DTPREL16_HIGHERA:
14904 case R_PPC64_DTPREL16_HIGHEST:
14905 case R_PPC64_DTPREL16_HIGHESTA:
989f9879
AM		 14906 if (htab->elf.tls_sec != NULL)
14907 addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
411e1bfb
AM		 14908 break;
14909
45965137
AM		 14910 case R_PPC64_ADDR64_LOCAL:
14911 addend += PPC64_LOCAL_ENTRY_OFFSET (h != NULL
14912 ? h->elf.other
14913 : sym->st_other);
14914 break;
14915
e515b051
AM		 14916 case R_PPC64_DTPMOD64:
14917 relocation = 1;
14918 addend = 0;
14919 goto dodyn;
14920
411e1bfb 14921 case R_PPC64_TPREL64:
989f9879
AM		 14922 if (htab->elf.tls_sec != NULL)
14923 addend -= htab->elf.tls_sec->vma + TP_OFFSET;
411e1bfb
AM		 14924 goto dodyn;
14925
14926 case R_PPC64_DTPREL64:
989f9879
AM		 14927 if (htab->elf.tls_sec != NULL)
14928 addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
1a0670f3 14929 /* Fall through. */
411e1bfb 14930
65f38f15
AM		 14931 /* Relocations that may need to be propagated if this is a
14932 dynamic object. */
04c9666a 14933 case R_PPC64_REL30:
65f38f15
AM		 14934 case R_PPC64_REL32:
14935 case R_PPC64_REL64:
14936 case R_PPC64_ADDR14:
14937 case R_PPC64_ADDR14_BRNTAKEN:
14938 case R_PPC64_ADDR14_BRTAKEN:
14939 case R_PPC64_ADDR16:
14940 case R_PPC64_ADDR16_DS:
14941 case R_PPC64_ADDR16_HA:
14942 case R_PPC64_ADDR16_HI:
f9c6b907
AM		 14943 case R_PPC64_ADDR16_HIGH:
14944 case R_PPC64_ADDR16_HIGHA:
65f38f15
AM		 14945 case R_PPC64_ADDR16_HIGHER:
14946 case R_PPC64_ADDR16_HIGHERA:
14947 case R_PPC64_ADDR16_HIGHEST:
14948 case R_PPC64_ADDR16_HIGHESTA:
14949 case R_PPC64_ADDR16_LO:
14950 case R_PPC64_ADDR16_LO_DS:
14951 case R_PPC64_ADDR24:
65f38f15
AM		 14952 case R_PPC64_ADDR32:
14953 case R_PPC64_ADDR64:
14954 case R_PPC64_UADDR16:
14955 case R_PPC64_UADDR32:
14956 case R_PPC64_UADDR64:
411e1bfb 14957 dodyn:
5d1634d7 14958 if ((input_section->flags & SEC_ALLOC) == 0)
ec338859
AM		 14959 break;
14960
41bd81ab
AM		 14961 if (NO_OPD_RELOCS && is_opd)
14962 break;
14963
8a9e8e72 14964 if (bfd_link_pic (info)
b1b07054
AM		 14965 ? ((h == NULL
14966 || h->dyn_relocs != NULL)
14967 && ((h != NULL && pc_dynrelocs (h))
14968 || must_be_dyn_reloc (info, r_type)))
8a9e8e72
AM		 14969 : (h != NULL
14970 ? h->dyn_relocs != NULL
d311bc8b 14971 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
65f38f15 14972 {
b34976b6 14973 bfd_boolean skip, relocate;
65f38f15 14974 asection *sreloc;
1cf1f670 14975 bfd_vma out_off;
82e66161 14976 long indx = 0;
65f38f15
AM		 14977
14978 /* When generating a dynamic object, these relocations
14979 are copied into the output file to be resolved at run
14980 time. */
14981
b34976b6
AM		 14982 skip = FALSE;
14983 relocate = FALSE;
65f38f15 14984
1cf1f670
AM		 14985 out_off = _bfd_elf_section_offset (output_bfd, info,
14986 input_section, rel->r_offset);
14987 if (out_off == (bfd_vma) -1)
b34976b6 14988 skip = TRUE;
1cf1f670 14989 else if (out_off == (bfd_vma) -2)
b34976b6 14990 skip = TRUE, relocate = TRUE;
1cf1f670
AM		 14991 out_off += (input_section->output_section->vma
14992 + input_section->output_offset);
14993 outrel.r_offset = out_off;
411e1bfb 14994 outrel.r_addend = rel->r_addend;
65f38f15 14995
1cf1f670
AM		 14996 /* Optimize unaligned reloc use. */
14997 if ((r_type == R_PPC64_ADDR64 && (out_off & 7) != 0)
14998 || (r_type == R_PPC64_UADDR64 && (out_off & 7) == 0))
14999 r_type ^= R_PPC64_ADDR64 ^ R_PPC64_UADDR64;
15000 else if ((r_type == R_PPC64_ADDR32 && (out_off & 3) != 0)
15001 || (r_type == R_PPC64_UADDR32 && (out_off & 3) == 0))
15002 r_type ^= R_PPC64_ADDR32 ^ R_PPC64_UADDR32;
15003 else if ((r_type == R_PPC64_ADDR16 && (out_off & 1) != 0)
15004 || (r_type == R_PPC64_UADDR16 && (out_off & 1) == 0))
15005 r_type ^= R_PPC64_ADDR16 ^ R_PPC64_UADDR16;
15006
65f38f15 15007 if (skip)
0bb2d96a 15008 memset (&outrel, 0, sizeof outrel);
afe397ea 15009 else if (!SYMBOL_REFERENCES_LOCAL (info, &h->elf)
0b13192e
AM		 15010 && !is_opd
15011 && r_type != R_PPC64_TOC)
14acf4dc 15012 {
82e66161
AM		 15013 indx = h->elf.dynindx;
15014 BFD_ASSERT (indx != -1);
15015 outrel.r_info = ELF64_R_INFO (indx, r_type);
14acf4dc 15016 }
65f38f15
AM		 15017 else
15018 {
41bd81ab
AM		 15019 /* This symbol is local, or marked to become local,
15020 or this is an opd section reloc which must point
15021 at a local function. */
65f38f15 15022 outrel.r_addend += relocation;
e86ce104 15023 if (r_type == R_PPC64_ADDR64 || r_type == R_PPC64_TOC)
65f38f15 15024 {
3fad3c7c 15025 if (is_opd && h != NULL)
afbe61cf
AM		 15026 {
15027 /* Lie about opd entries. This case occurs
15028 when building shared libraries and we
15029 reference a function in another shared
3fad3c7c
AM		 15030 lib. The same thing happens for a weak
15031 definition in an application that's
15032 overridden by a strong definition in a
15033 shared lib. (I believe this is a generic
15034 bug in binutils handling of weak syms.)
15035 In these cases we won't use the opd
1e2f5b6e 15036 entry in this lib. */
b34976b6 15037 unresolved_reloc = FALSE;
afbe61cf 15038 }
25f23106
AM		 15039 if (!is_opd
15040 && r_type == R_PPC64_ADDR64
15041 && (h != NULL
15042 ? h->elf.type == STT_GNU_IFUNC
15043 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
15044 outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
15045 else
15046 {
15047 outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
81407a69 15048
25f23106
AM		 15049 /* We need to relocate .opd contents for ld.so.
15050 Prelink also wants simple and consistent rules
15051 for relocs. This make all RELATIVE relocs have
15052 *r_offset equal to r_addend. */
15053 relocate = TRUE;
15054 }
65f38f15
AM		 15055 }
15056 else
15057 {
25f23106
AM		 15058 if (h != NULL
15059 ? h->elf.type == STT_GNU_IFUNC
15060 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
15061 {
25f53a85 15062 info->callbacks->einfo
695344c0 15063 /* xgettext:c-format */
174d0a74 15064 (_("%H: %s for indirect "
bc30df16 15065 "function `%T' unsupported\n"),
25f53a85 15066 input_bfd, input_section, rel->r_offset,
25f23106
AM		 15067 ppc64_elf_howto_table[r_type]->name,
15068 sym_name);
15069 ret = FALSE;
15070 }
cf35638d 15071 else if (r_symndx == STN_UNDEF || bfd_is_abs_section (sec))
65f38f15
AM		 15072 ;
15073 else if (sec == NULL || sec->owner == NULL)
15074 {
15075 bfd_set_error (bfd_error_bad_value);
b34976b6 15076 return FALSE;
65f38f15
AM		 15077 }
15078 else
15079 {
15080 asection *osec;
15081
15082 osec = sec->output_section;
15083 indx = elf_section_data (osec)->dynindx;
15084
74541ad4
AM		 15085 if (indx == 0)
15086 {
15087 if ((osec->flags & SEC_READONLY) == 0
15088 && htab->elf.data_index_section != NULL)
15089 osec = htab->elf.data_index_section;
15090 else
15091 osec = htab->elf.text_index_section;
15092 indx = elf_section_data (osec)->dynindx;
15093 }
15094 BFD_ASSERT (indx != 0);
15095
65f38f15
AM		 15096 /* We are turning this relocation into one
15097 against a section symbol, so subtract out
15098 the output section's address but not the
15099 offset of the input section in the output
15100 section. */
15101 outrel.r_addend -= osec->vma;
15102 }
15103
15104 outrel.r_info = ELF64_R_INFO (indx, r_type);
15105 }
15106 }
15107
15108 sreloc = elf_section_data (input_section)->sreloc;
19e08130
AM		 15109 if (h != NULL
15110 ? h->elf.type == STT_GNU_IFUNC
15111 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
82e66161
AM		 15112 {
15113 sreloc = htab->elf.irelplt;
15114 if (indx == 0)
15115 htab->local_ifunc_resolver = 1;
15116 else if (is_static_defined (&h->elf))
15117 htab->maybe_local_ifunc_resolver = 1;
15118 }
65f38f15
AM		 15119 if (sreloc == NULL)
15120 abort ();
15121
dfbb6ac9
AM		 15122 if (sreloc->reloc_count * sizeof (Elf64_External_Rela)
15123 >= sreloc->size)
15124 abort ();
947216bf
AM		 15125 loc = sreloc->contents;
15126 loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
65f38f15
AM		 15127 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
15128
15129 /* If this reloc is against an external symbol, it will
15130 be computed at runtime, so there's no need to do
81407a69
AM		 15131 anything now. However, for the sake of prelink ensure
15132 that the section contents are a known value. */
65f38f15 15133 if (! relocate)
81407a69
AM		 15134 {
15135 unresolved_reloc = FALSE;
15136 /* The value chosen here is quite arbitrary as ld.so
15137 ignores section contents except for the special
15138 case of .opd where the contents might be accessed
15139 before relocation. Choose zero, as that won't
15140 cause reloc overflow. */
15141 relocation = 0;
15142 addend = 0;
15143 /* Use *r_offset == r_addend for R_PPC64_ADDR64 relocs
15144 to improve backward compatibility with older
15145 versions of ld. */
15146 if (r_type == R_PPC64_ADDR64)
15147 addend = outrel.r_addend;
15148 /* Adjust pc_relative relocs to have zero in *r_offset. */
4ce794b7 15149 else if (ppc64_elf_howto_table[r_type]->pc_relative)
f0158f44 15150 addend = outrel.r_offset;
81407a69 15151 }
65f38f15 15152 }
5bd4f169
AM		 15153 break;
15154
65f38f15
AM		 15155 case R_PPC64_COPY:
15156 case R_PPC64_GLOB_DAT:
15157 case R_PPC64_JMP_SLOT:
25f23106 15158 case R_PPC64_JMP_IREL:
65f38f15
AM		 15159 case R_PPC64_RELATIVE:
15160 /* We shouldn't ever see these dynamic relocs in relocatable
15161 files. */
ae9a127f 15162 /* Fall through. */
65f38f15
AM		 15163
15164 case R_PPC64_PLTGOT16:
15165 case R_PPC64_PLTGOT16_DS:
15166 case R_PPC64_PLTGOT16_HA:
15167 case R_PPC64_PLTGOT16_HI:
15168 case R_PPC64_PLTGOT16_LO:
15169 case R_PPC64_PLTGOT16_LO_DS:
15170 case R_PPC64_PLTREL32:
15171 case R_PPC64_PLTREL64:
15172 /* These ones haven't been implemented yet. */
15173
25f53a85 15174 info->callbacks->einfo
695344c0 15175 /* xgettext:c-format */
bc30df16 15176 (_("%P: %B: %s is not supported for `%T'\n"),
d003868e 15177 input_bfd,
4ce794b7 15178 ppc64_elf_howto_table[r_type]->name, sym_name);
5bd4f169
AM		 15179
15180 bfd_set_error (bfd_error_invalid_operation);
b34976b6 15181 ret = FALSE;
c316a17c 15182 goto copy_reloc;
65f38f15 15183 }
5bd4f169 15184
67f0cbdb
AM		 15185 /* Multi-instruction sequences that access the TOC can be
15186 optimized, eg. addis ra,r2,0; addi rb,ra,x;
15187 to nop; addi rb,r2,x; */
15188 switch (r_type)
15189 {
15190 default:
15191 break;
15192
15193 case R_PPC64_GOT_TLSLD16_HI:
15194 case R_PPC64_GOT_TLSGD16_HI:
15195 case R_PPC64_GOT_TPREL16_HI:
15196 case R_PPC64_GOT_DTPREL16_HI:
15197 case R_PPC64_GOT16_HI:
15198 case R_PPC64_TOC16_HI:
15199 /* These relocs would only be useful if building up an
15200 offset to later add to r2, perhaps in an indexed
15201 addressing mode instruction. Don't try to optimize.
15202 Unfortunately, the possibility of someone building up an
15203 offset like this or even with the HA relocs, means that
15204 we need to check the high insn when optimizing the low
15205 insn. */
15206 break;
15207
15208 case R_PPC64_GOT_TLSLD16_HA:
15209 case R_PPC64_GOT_TLSGD16_HA:
15210 case R_PPC64_GOT_TPREL16_HA:
15211 case R_PPC64_GOT_DTPREL16_HA:
15212 case R_PPC64_GOT16_HA:
15213 case R_PPC64_TOC16_HA:
98528052 15214 if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
560c8763 15215 && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
98528052
AM		 15216 {
15217 bfd_byte *p = contents + (rel->r_offset & ~3);
15218 bfd_put_32 (input_bfd, NOP, p);
15219 }
67f0cbdb
AM		 15220 break;
15221
15222 case R_PPC64_GOT_TLSLD16_LO:
15223 case R_PPC64_GOT_TLSGD16_LO:
15224 case R_PPC64_GOT_TPREL16_LO_DS:
15225 case R_PPC64_GOT_DTPREL16_LO_DS:
15226 case R_PPC64_GOT16_LO:
15227 case R_PPC64_GOT16_LO_DS:
15228 case R_PPC64_TOC16_LO:
15229 case R_PPC64_TOC16_LO_DS:
98528052 15230 if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
560c8763 15231 && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
67f0cbdb
AM		 15232 {
15233 bfd_byte *p = contents + (rel->r_offset & ~3);
15234 insn = bfd_get_32 (input_bfd, p);
560c8763
AM		 15235 if ((insn & (0x3f << 26)) == 12u << 26 /* addic */)
15236 {
15237 /* Transform addic to addi when we change reg. */
15238 insn &= ~((0x3f << 26) | (0x1f << 16));
15239 insn |= (14u << 26) | (2 << 16);
15240 }
15241 else
67f0cbdb 15242 {
98528052
AM		 15243 insn &= ~(0x1f << 16);
15244 insn |= 2 << 16;
67f0cbdb 15245 }
560c8763 15246 bfd_put_32 (input_bfd, insn, p);
67f0cbdb
AM		 15247 }
15248 break;
15249 }
15250
65f38f15 15251 /* Do any further special processing. */
b80eed39 15252 howto = ppc64_elf_howto_table[(int) r_type];
65f38f15
AM		 15253 switch (r_type)
15254 {
15255 default:
15256 break;
15257
25f23106 15258 case R_PPC64_REL16_HA:
a680de9a 15259 case R_PPC64_REL16DX_HA:
f9c6b907
AM		 15260 case R_PPC64_ADDR16_HA:
15261 case R_PPC64_ADDR16_HIGHA:
65f38f15
AM		 15262 case R_PPC64_ADDR16_HIGHERA:
15263 case R_PPC64_ADDR16_HIGHESTA:
65f38f15
AM		 15264 case R_PPC64_TOC16_HA:
15265 case R_PPC64_SECTOFF_HA:
411e1bfb 15266 case R_PPC64_TPREL16_HA:
f9c6b907 15267 case R_PPC64_TPREL16_HIGHA:
411e1bfb 15268 case R_PPC64_TPREL16_HIGHERA:
411e1bfb 15269 case R_PPC64_TPREL16_HIGHESTA:
f9c6b907
AM		 15270 case R_PPC64_DTPREL16_HA:
15271 case R_PPC64_DTPREL16_HIGHA:
411e1bfb 15272 case R_PPC64_DTPREL16_HIGHERA:
411e1bfb 15273 case R_PPC64_DTPREL16_HIGHESTA:
65f38f15
AM		 15274 /* It's just possible that this symbol is a weak symbol
15275 that's not actually defined anywhere. In that case,
15276 'sec' would be NULL, and we should leave the symbol
15277 alone (it will be set to zero elsewhere in the link). */
5c5f6e17
AM		 15278 if (sec == NULL)
15279 break;
1a0670f3 15280 /* Fall through. */
5c5f6e17
AM		 15281
15282 case R_PPC64_GOT16_HA:
15283 case R_PPC64_PLTGOT16_HA:
15284 case R_PPC64_PLT16_HA:
15285 case R_PPC64_GOT_TLSGD16_HA:
15286 case R_PPC64_GOT_TLSLD16_HA:
15287 case R_PPC64_GOT_TPREL16_HA:
15288 case R_PPC64_GOT_DTPREL16_HA:
15289 /* Add 0x10000 if sign bit in 0:15 is set.
15290 Bits 0:15 are not used. */
15291 addend += 0x8000;
65f38f15
AM		 15292 break;
15293
15294 case R_PPC64_ADDR16_DS:
15295 case R_PPC64_ADDR16_LO_DS:
15296 case R_PPC64_GOT16_DS:
15297 case R_PPC64_GOT16_LO_DS:
15298 case R_PPC64_PLT16_LO_DS:
15299 case R_PPC64_SECTOFF_DS:
15300 case R_PPC64_SECTOFF_LO_DS:
15301 case R_PPC64_TOC16_DS:
15302 case R_PPC64_TOC16_LO_DS:
15303 case R_PPC64_PLTGOT16_DS:
15304 case R_PPC64_PLTGOT16_LO_DS:
411e1bfb
AM		 15305 case R_PPC64_GOT_TPREL16_DS:
15306 case R_PPC64_GOT_TPREL16_LO_DS:
15307 case R_PPC64_GOT_DTPREL16_DS:
15308 case R_PPC64_GOT_DTPREL16_LO_DS:
15309 case R_PPC64_TPREL16_DS:
15310 case R_PPC64_TPREL16_LO_DS:
15311 case R_PPC64_DTPREL16_DS:
15312 case R_PPC64_DTPREL16_LO_DS:
adadcc0c
AM		 15313 insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
15314 mask = 3;
a680de9a
PB		 15315 /* If this reloc is against an lq, lxv, or stxv insn, then
15316 the value must be a multiple of 16. This is somewhat of
15317 a hack, but the "correct" way to do this by defining _DQ
15318 forms of all the _DS relocs bloats all reloc switches in
15319 this file. It doesn't make much sense to use these
15320 relocs in data, so testing the insn should be safe. */
15321 if ((insn & (0x3f << 26)) == (56u << 26)
15322 || ((insn & (0x3f << 26)) == (61u << 26) && (insn & 3) == 1))
adadcc0c 15323 mask = 15;
a680de9a
PB		 15324 relocation += addend;
15325 addend = insn & (mask ^ 3);
15326 if ((relocation & mask) != 0)
65f38f15 15327 {
a680de9a 15328 relocation ^= relocation & mask;
25f53a85 15329 info->callbacks->einfo
695344c0 15330 /* xgettext:c-format */
174d0a74 15331 (_("%H: error: %s not a multiple of %u\n"),
25f53a85 15332 input_bfd, input_section, rel->r_offset,
b80eed39 15333 howto->name,
adadcc0c 15334 mask + 1);
65f38f15 15335 bfd_set_error (bfd_error_bad_value);
b34976b6 15336 ret = FALSE;
c316a17c 15337 goto copy_reloc;
65f38f15
AM		 15338 }
15339 break;
5bd4f169
AM		 15340 }
15341
239e1f3a
AM		 15342 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
15343 because such sections are not SEC_ALLOC and thus ld.so will
15344 not process them. */
65f38f15 15345 if (unresolved_reloc
239e1f3a 15346 && !((input_section->flags & SEC_DEBUGGING) != 0
1d5316ab
AM		 15347 && h->elf.def_dynamic)
15348 && _bfd_elf_section_offset (output_bfd, info, input_section,
15349 rel->r_offset) != (bfd_vma) -1)
9c07fe7c 15350 {
25f53a85 15351 info->callbacks->einfo
695344c0 15352 /* xgettext:c-format */
174d0a74 15353 (_("%H: unresolvable %s against `%T'\n"),
25f53a85 15354 input_bfd, input_section, rel->r_offset,
b80eed39 15355 howto->name,
039b3fef 15356 h->elf.root.root.string);
b34976b6 15357 ret = FALSE;
9c07fe7c 15358 }
5bd4f169 15359
b80eed39
AM		 15360 /* 16-bit fields in insns mostly have signed values, but a
15361 few insns have 16-bit unsigned values. Really, we should
15362 have different reloc types. */
15363 if (howto->complain_on_overflow != complain_overflow_dont
15364 && howto->dst_mask == 0xffff
15365 && (input_section->flags & SEC_CODE) != 0)
15366 {
15367 enum complain_overflow complain = complain_overflow_signed;
15368
15369 insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
a47622ac
AM		 15370 if ((insn & (0x3f << 26)) == 10u << 26 /* cmpli */)
15371 complain = complain_overflow_bitfield;
15372 else if (howto->rightshift == 0
15373 ? ((insn & (0x3f << 26)) == 28u << 26 /* andi */
15374 || (insn & (0x3f << 26)) == 24u << 26 /* ori */
15375 || (insn & (0x3f << 26)) == 26u << 26 /* xori */)
15376 : ((insn & (0x3f << 26)) == 29u << 26 /* andis */
15377 || (insn & (0x3f << 26)) == 25u << 26 /* oris */
15378 || (insn & (0x3f << 26)) == 27u << 26 /* xoris */))
b80eed39
AM		 15379 complain = complain_overflow_unsigned;
15380 if (howto->complain_on_overflow != complain)
15381 {
15382 alt_howto = *howto;
15383 alt_howto.complain_on_overflow = complain;
15384 howto = &alt_howto;
15385 }
15386 }
15387
a680de9a
PB		 15388 if (r_type == R_PPC64_REL16DX_HA)
15389 {
15390 /* Split field reloc isn't handled by _bfd_final_link_relocate. */
15391 if (rel->r_offset + 4 > input_section->size)
15392 r = bfd_reloc_outofrange;
15393 else
15394 {
15395 relocation += addend;
15396 relocation -= (rel->r_offset
15397 + input_section->output_offset
15398 + input_section->output_section->vma);
3de43e7b 15399 relocation = (bfd_signed_vma) relocation >> 16;
a680de9a
PB		 15400 insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
15401 insn &= ~0x1fffc1;
3de43e7b 15402 insn |= (relocation & 0xffc1) | ((relocation & 0x3e) << 15);
a680de9a
PB		 15403 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
15404 r = bfd_reloc_ok;
3de43e7b 15405 if (relocation + 0x8000 > 0xffff)
a680de9a
PB		 15406 r = bfd_reloc_overflow;
15407 }
15408 }
15409 else
15410 r = _bfd_final_link_relocate (howto, input_bfd, input_section, contents,
15411 rel->r_offset, relocation, addend);
5bd4f169 15412
ef60b7ff 15413 if (r != bfd_reloc_ok)
5bd4f169 15414 {
bc30df16 15415 char *more_info = NULL;
b80eed39 15416 const char *reloc_name = howto->name;
bc30df16
AM		 15417
15418 if (reloc_dest != DEST_NORMAL)
15419 {
15420 more_info = bfd_malloc (strlen (reloc_name) + 8);
15421 if (more_info != NULL)
15422 {
15423 strcpy (more_info, reloc_name);
15424 strcat (more_info, (reloc_dest == DEST_OPD
15425 ? " (OPD)" : " (stub)"));
15426 reloc_name = more_info;
15427 }
15428 }
15429
cd27b276 15430 if (r == bfd_reloc_overflow)
5bd4f169 15431 {
8131c122
AM		 15432 /* On code like "if (foo) foo();" don't report overflow
15433 on a branch to zero when foo is undefined. */
15434 if (!warned
15435 && (reloc_dest == DEST_STUB
15436 || !(h != NULL
15437 && (h->elf.root.type == bfd_link_hash_undefweak
15438 || h->elf.root.type == bfd_link_hash_undefined)
15439 && is_branch_reloc (r_type))))
1a72702b
AM		 15440 info->callbacks->reloc_overflow (info, &h->elf.root,
15441 sym_name, reloc_name,
15442 orig_rel.r_addend,
15443 input_bfd, input_section,
15444 rel->r_offset);
ef60b7ff
AM		 15445 }
15446 else
15447 {
25f53a85 15448 info->callbacks->einfo
695344c0 15449 /* xgettext:c-format */
174d0a74 15450 (_("%H: %s against `%T': error %d\n"),
25f53a85 15451 input_bfd, input_section, rel->r_offset,
bc30df16 15452 reloc_name, sym_name, (int) r);
b34976b6 15453 ret = FALSE;
ef60b7ff 15454 }
bc30df16
AM		 15455 if (more_info != NULL)
15456 free (more_info);
5bd4f169 15457 }
c316a17c
AM		 15458 copy_reloc:
15459 if (wrel != rel)
15460 *wrel = *rel;
15461 }
15462
15463 if (wrel != rel)
15464 {
15465 Elf_Internal_Shdr *rel_hdr;
15466 size_t deleted = rel - wrel;
15467
15468 rel_hdr = _bfd_elf_single_rel_hdr (input_section->output_section);
15469 rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
15470 if (rel_hdr->sh_size == 0)
15471 {
15472 /* It is too late to remove an empty reloc section. Leave
15473 one NONE reloc.
15474 ??? What is wrong with an empty section??? */
15475 rel_hdr->sh_size = rel_hdr->sh_entsize;
15476 deleted -= 1;
15477 }
15478 rel_hdr = _bfd_elf_single_rel_hdr (input_section);
15479 rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
15480 input_section->reloc_count -= deleted;
5bd4f169
AM		 15481 }
15482
645ea6a9
AM		 15483 /* If we're emitting relocations, then shortly after this function
15484 returns, reloc offsets and addends for this section will be
15485 adjusted. Worse, reloc symbol indices will be for the output
8860955f
AM		 15486 file rather than the input. Save a copy of the relocs for
15487 opd_entry_value. */
0e1862bb 15488 if (is_opd && (info->emitrelocations || bfd_link_relocatable (info)))
8860955f
AM		 15489 {
15490 bfd_size_type amt;
15491 amt = input_section->reloc_count * sizeof (Elf_Internal_Rela);
15492 rel = bfd_alloc (input_bfd, amt);
729eabd5
AM		 15493 BFD_ASSERT (ppc64_elf_tdata (input_bfd)->opd.relocs == NULL);
15494 ppc64_elf_tdata (input_bfd)->opd.relocs = rel;
8860955f
AM		 15495 if (rel == NULL)
15496 return FALSE;
15497 memcpy (rel, relocs, amt);
15498 }
5bd4f169
AM		 15499 return ret;
15500}
15501
754021d0
AM		 15502/* Adjust the value of any local symbols in opd sections. */
15503
6e0b88f1 15504static int
754021d0
AM		 15505ppc64_elf_output_symbol_hook (struct bfd_link_info *info,
15506 const char *name ATTRIBUTE_UNUSED,
15507 Elf_Internal_Sym *elfsym,
15508 asection *input_sec,
15509 struct elf_link_hash_entry *h)
15510{
74f0fb50
AM		 15511 struct _opd_sec_data *opd;
15512 long adjust;
754021d0
AM		 15513 bfd_vma value;
15514
4025353c 15515 if (h != NULL)
6e0b88f1 15516 return 1;
4025353c 15517
74f0fb50
AM		 15518 opd = get_opd_info (input_sec);
15519 if (opd == NULL || opd->adjust == NULL)
6e0b88f1 15520 return 1;
754021d0
AM		 15521
15522 value = elfsym->st_value - input_sec->output_offset;
0e1862bb 15523 if (!bfd_link_relocatable (info))
754021d0
AM		 15524 value -= input_sec->output_section->vma;
15525
51aecdc5 15526 adjust = opd->adjust[OPD_NDX (value)];
4025353c 15527 if (adjust == -1)
6e0b88f1
AM		 15528 return 2;
15529
15530 elfsym->st_value += adjust;
15531 return 1;
754021d0
AM		 15532}
15533
5bd4f169
AM		 15534/* Finish up dynamic symbol handling. We set the contents of various
15535 dynamic sections here. */
15536
b34976b6 15537static bfd_boolean
4ce794b7
AM		 15538ppc64_elf_finish_dynamic_symbol (bfd *output_bfd,
15539 struct bfd_link_info *info,
15540 struct elf_link_hash_entry *h,
4aef7643 15541 Elf_Internal_Sym *sym)
5bd4f169 15542{
65f38f15 15543 struct ppc_link_hash_table *htab;
8387904d
AM		 15544 struct plt_entry *ent;
15545 Elf_Internal_Rela rela;
15546 bfd_byte *loc;
5bd4f169 15547
65f38f15 15548 htab = ppc_hash_table (info);
4dfe6ac6
NC		 15549 if (htab == NULL)
15550 return FALSE;
5bd4f169 15551
8387904d
AM		 15552 for (ent = h->plt.plist; ent != NULL; ent = ent->next)
15553 if (ent->plt.offset != (bfd_vma) -1)
15554 {
15555 /* This symbol has an entry in the procedure linkage
15556 table. Set it up. */
e054468f
AM		 15557 if (!htab->elf.dynamic_sections_created
15558 || h->dynindx == -1)
15559 {
15560 BFD_ASSERT (h->type == STT_GNU_IFUNC
15561 && h->def_regular
15562 && (h->root.type == bfd_link_hash_defined
15563 || h->root.type == bfd_link_hash_defweak));
33e44f2e
AM		 15564 rela.r_offset = (htab->elf.iplt->output_section->vma
15565 + htab->elf.iplt->output_offset
25f23106 15566 + ent->plt.offset);
ee67d69a
AM		 15567 if (htab->opd_abi)
15568 rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
15569 else
15570 rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
e054468f
AM		 15571 rela.r_addend = (h->root.u.def.value
15572 + h->root.u.def.section->output_offset
15573 + h->root.u.def.section->output_section->vma
15574 + ent->addend);
33e44f2e
AM		 15575 loc = (htab->elf.irelplt->contents
15576 + (htab->elf.irelplt->reloc_count++
25f23106 15577 * sizeof (Elf64_External_Rela)));
82e66161 15578 htab->local_ifunc_resolver = 1;
e054468f
AM		 15579 }
15580 else
15581 {
33e44f2e
AM		 15582 rela.r_offset = (htab->elf.splt->output_section->vma
15583 + htab->elf.splt->output_offset
25f23106 15584 + ent->plt.offset);
e054468f
AM		 15585 rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_JMP_SLOT);
15586 rela.r_addend = ent->addend;
33e44f2e 15587 loc = (htab->elf.srelplt->contents
b9e5796b
AM		 15588 + ((ent->plt.offset - PLT_INITIAL_ENTRY_SIZE (htab))
15589 / PLT_ENTRY_SIZE (htab) * sizeof (Elf64_External_Rela)));
82e66161
AM		 15590 if (h->type == STT_GNU_IFUNC && is_static_defined (h))
15591 htab->maybe_local_ifunc_resolver = 1;
e054468f 15592 }
8387904d 15593 bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
a345bc8d
AM		 15594
15595 if (!htab->opd_abi)
15596 {
15597 if (!h->def_regular)
15598 {
15599 /* Mark the symbol as undefined, rather than as
15600 defined in glink. Leave the value if there were
15601 any relocations where pointer equality matters
15602 (this is a clue for the dynamic linker, to make
15603 function pointer comparisons work between an
15604 application and shared library), otherwise set it
15605 to zero. */
15606 sym->st_shndx = SHN_UNDEF;
15607 if (!h->pointer_equality_needed)
15608 sym->st_value = 0;
15609 else if (!h->ref_regular_nonweak)
15610 {
15611 /* This breaks function pointer comparisons, but
15612 that is better than breaking tests for a NULL
15613 function pointer. */
15614 sym->st_value = 0;
15615 }
15616 }
15617 }
8387904d 15618 }
5bd4f169 15619
f5385ebf 15620 if (h->needs_copy)
5bd4f169 15621 {
65f38f15 15622 /* This symbol needs a copy reloc. Set it up. */
5474d94f 15623 asection *srel;
5bd4f169 15624
65f38f15
AM		 15625 if (h->dynindx == -1
15626 || (h->root.type != bfd_link_hash_defined
15627 && h->root.type != bfd_link_hash_defweak)
5474d94f
AM		 15628 || htab->elf.srelbss == NULL
15629 || htab->elf.sreldynrelro == NULL)
65f38f15 15630 abort ();
5bd4f169
AM		 15631
15632 rela.r_offset = (h->root.u.def.value
15633 + h->root.u.def.section->output_section->vma
15634 + h->root.u.def.section->output_offset);
15635 rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_COPY);
15636 rela.r_addend = 0;
afbf7e8e 15637 if (h->root.u.def.section == htab->elf.sdynrelro)
5474d94f
AM		 15638 srel = htab->elf.sreldynrelro;
15639 else
15640 srel = htab->elf.srelbss;
15641 loc = srel->contents;
15642 loc += srel->reloc_count++ * sizeof (Elf64_External_Rela);
65f38f15 15643 bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
5bd4f169
AM		 15644 }
15645
b34976b6 15646 return TRUE;
5bd4f169
AM		 15647}
15648
65f38f15
AM		 15649/* Used to decide how to sort relocs in an optimal manner for the
15650 dynamic linker, before writing them out. */
15651
15652static enum elf_reloc_type_class
7e612e98
AM		 15653ppc64_elf_reloc_type_class (const struct bfd_link_info *info,
15654 const asection *rel_sec,
15655 const Elf_Internal_Rela *rela)
65f38f15 15656{
04c9666a 15657 enum elf_ppc64_reloc_type r_type;
7e612e98
AM		 15658 struct ppc_link_hash_table *htab = ppc_hash_table (info);
15659
33e44f2e 15660 if (rel_sec == htab->elf.irelplt)
7e612e98 15661 return reloc_class_ifunc;
a33d1f77 15662
4ce794b7 15663 r_type = ELF64_R_TYPE (rela->r_info);
a33d1f77 15664 switch (r_type)
65f38f15
AM		 15665 {
15666 case R_PPC64_RELATIVE:
15667 return reloc_class_relative;
15668 case R_PPC64_JMP_SLOT:
15669 return reloc_class_plt;
15670 case R_PPC64_COPY:
15671 return reloc_class_copy;
15672 default:
15673 return reloc_class_normal;
15674 }
15675}
15676
5bd4f169
AM		 15677/* Finish up the dynamic sections. */
15678
b34976b6 15679static bfd_boolean
4ce794b7
AM		 15680ppc64_elf_finish_dynamic_sections (bfd *output_bfd,
15681 struct bfd_link_info *info)
5bd4f169 15682{
65f38f15
AM		 15683 struct ppc_link_hash_table *htab;
15684 bfd *dynobj;
5bd4f169 15685 asection *sdyn;
5bd4f169 15686
65f38f15 15687 htab = ppc_hash_table (info);
4dfe6ac6
NC		 15688 if (htab == NULL)
15689 return FALSE;
15690
65f38f15 15691 dynobj = htab->elf.dynobj;
3d4d4302 15692 sdyn = bfd_get_linker_section (dynobj, ".dynamic");
5bd4f169 15693
65f38f15 15694 if (htab->elf.dynamic_sections_created)
5bd4f169 15695 {
5bd4f169
AM		 15696 Elf64_External_Dyn *dyncon, *dynconend;
15697
33e44f2e 15698 if (sdyn == NULL || htab->elf.sgot == NULL)
65f38f15 15699 abort ();
5bd4f169
AM		 15700
15701 dyncon = (Elf64_External_Dyn *) sdyn->contents;
eea6121a 15702 dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
5bd4f169
AM		 15703 for (; dyncon < dynconend; dyncon++)
15704 {
15705 Elf_Internal_Dyn dyn;
19397422 15706 asection *s;
5bd4f169
AM		 15707
15708 bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
15709
15710 switch (dyn.d_tag)
15711 {
65f38f15
AM		 15712 default:
15713 continue;
5bd4f169 15714
5d1634d7 15715 case DT_PPC64_GLINK:
4ce794b7 15716 s = htab->glink;
6348e046 15717 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
ad8e1ba5
AM		 15718 /* We stupidly defined DT_PPC64_GLINK to be the start
15719 of glink rather than the first entry point, which is
15720 what ld.so needs, and now have a bigger stub to
15721 support automatic multiple TOCs. */
b9e5796b 15722 dyn.d_un.d_ptr += GLINK_CALL_STUB_SIZE - 8 * 4;
5d1634d7
AM		 15723 break;
15724
19397422
AM		 15725 case DT_PPC64_OPD:
15726 s = bfd_get_section_by_name (output_bfd, ".opd");
6348e046
AM		 15727 if (s == NULL)
15728 continue;
15729 dyn.d_un.d_ptr = s->vma;
19397422
AM		 15730 break;
15731
e8910a83
AM		 15732 case DT_PPC64_OPT:
15733 if (htab->do_multi_toc && htab->multi_toc_needed)
15734 dyn.d_un.d_val |= PPC64_OPT_MULTI_TOC;
f378ab09
AM		 15735 if (htab->has_plt_localentry0)
15736 dyn.d_un.d_val |= PPC64_OPT_LOCALENTRY;
e8910a83
AM		 15737 break;
15738
19397422
AM		 15739 case DT_PPC64_OPDSZ:
15740 s = bfd_get_section_by_name (output_bfd, ".opd");
6348e046
AM		 15741 if (s == NULL)
15742 continue;
eea6121a 15743 dyn.d_un.d_val = s->size;
19397422
AM		 15744 break;
15745
65f38f15 15746 case DT_PLTGOT:
33e44f2e 15747 s = htab->elf.splt;
6348e046 15748 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
65f38f15
AM		 15749 break;
15750
15751 case DT_JMPREL:
33e44f2e 15752 s = htab->elf.srelplt;
6348e046 15753 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
65f38f15 15754 break;
5bd4f169 15755
65f38f15 15756 case DT_PLTRELSZ:
33e44f2e 15757 dyn.d_un.d_val = htab->elf.srelplt->size;
5d1634d7 15758 break;
82e66161
AM		 15759
15760 case DT_TEXTREL:
15761 if (htab->local_ifunc_resolver)
15762 info->callbacks->einfo
15763 (_("%X%P: text relocations and GNU indirect "
15764 "functions will result in a segfault at runtime\n"));
15765 else if (htab->maybe_local_ifunc_resolver)
15766 info->callbacks->einfo
15767 (_("%P: warning: text relocations and GNU indirect "
15768 "functions may result in a segfault at runtime\n"));
15769 continue;
5bd4f169 15770 }
5bd4f169 15771
65f38f15 15772 bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
5bd4f169 15773 }
5bd4f169
AM		 15774 }
15775
6528b6eb
AM		 15776 if (htab->elf.sgot != NULL && htab->elf.sgot->size != 0
15777 && htab->elf.sgot->output_section != bfd_abs_section_ptr)
5d1634d7
AM		 15778 {
15779 /* Fill in the first entry in the global offset table.
15780 We use it to hold the link-time TOCbase. */
15781 bfd_put_64 (output_bfd,
60ee0d4a 15782 elf_gp (output_bfd) + TOC_BASE_OFF,
33e44f2e 15783 htab->elf.sgot->contents);
5d1634d7
AM		 15784
15785 /* Set .got entry size. */
33e44f2e 15786 elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize = 8;
5d1634d7
AM		 15787 }
15788
6528b6eb
AM		 15789 if (htab->elf.splt != NULL && htab->elf.splt->size != 0
15790 && htab->elf.splt->output_section != bfd_abs_section_ptr)
5d1634d7
AM		 15791 {
15792 /* Set .plt entry size. */
33e44f2e 15793 elf_section_data (htab->elf.splt->output_section)->this_hdr.sh_entsize
b9e5796b 15794 = PLT_ENTRY_SIZE (htab);
5d1634d7
AM		 15795 }
15796
84f5d08e
AM		 15797 /* brlt is SEC_LINKER_CREATED, so we need to write out relocs for
15798 brlt ourselves if emitrelocations. */
15799 if (htab->brlt != NULL
15800 && htab->brlt->reloc_count != 0
15801 && !_bfd_elf_link_output_relocs (output_bfd,
15802 htab->brlt,
d4730f92 15803 elf_section_data (htab->brlt)->rela.hdr,
84f5d08e
AM		 15804 elf_section_data (htab->brlt)->relocs,
15805 NULL))
15806 return FALSE;
15807
176a0d42
AM		 15808 if (htab->glink != NULL
15809 && htab->glink->reloc_count != 0
15810 && !_bfd_elf_link_output_relocs (output_bfd,
15811 htab->glink,
d4730f92 15812 elf_section_data (htab->glink)->rela.hdr,
176a0d42
AM		 15813 elf_section_data (htab->glink)->relocs,
15814 NULL))
15815 return FALSE;
15816
58d180e8 15817 if (htab->glink_eh_frame != NULL
da44f4e5
AM		 15818 && htab->glink_eh_frame->size != 0)
15819 {
15820 bfd_vma val;
15821 bfd_byte *p;
d4aaa2a0 15822 struct map_stub *group;
2e0ce1c8 15823 size_t align = 4;
da44f4e5 15824
2e0ce1c8
AM		 15825 p = htab->glink_eh_frame->contents;
15826 p += (sizeof (glink_eh_frame_cie) + align - 1) & -align;
d4aaa2a0
AM		 15827
15828 for (group = htab->group; group != NULL; group = group->next)
15829 if (group->stub_sec != NULL)
da44f4e5 15830 {
da44f4e5 15831 /* Offset to stub section. */
d4aaa2a0
AM		 15832 val = (group->stub_sec->output_section->vma
15833 + group->stub_sec->output_offset);
da44f4e5
AM		 15834 val -= (htab->glink_eh_frame->output_section->vma
15835 + htab->glink_eh_frame->output_offset
d4aaa2a0 15836 + (p + 8 - htab->glink_eh_frame->contents));
da44f4e5
AM		 15837 if (val + 0x80000000 > 0xffffffff)
15838 {
15839 info->callbacks->einfo
15840 (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
d4aaa2a0 15841 group->stub_sec->name);
da44f4e5
AM		 15842 return FALSE;
15843 }
d4aaa2a0
AM		 15844 bfd_put_32 (dynobj, val, p + 8);
15845 p += stub_eh_frame_size (group, align);
da44f4e5
AM		 15846 }
15847 if (htab->glink != NULL && htab->glink->size != 0)
15848 {
da44f4e5
AM		 15849 /* Offset to .glink. */
15850 val = (htab->glink->output_section->vma
15851 + htab->glink->output_offset
15852 + 8);
15853 val -= (htab->glink_eh_frame->output_section->vma
15854 + htab->glink_eh_frame->output_offset
d4aaa2a0 15855 + (p + 8 - htab->glink_eh_frame->contents));
da44f4e5
AM		 15856 if (val + 0x80000000 > 0xffffffff)
15857 {
15858 info->callbacks->einfo
15859 (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
15860 htab->glink->name);
15861 return FALSE;
15862 }
d4aaa2a0
AM		 15863 bfd_put_32 (dynobj, val, p + 8);
15864 p += (24 + align - 1) & -align;
da44f4e5
AM		 15865 }
15866
15867 if (htab->glink_eh_frame->sec_info_type == SEC_INFO_TYPE_EH_FRAME
15868 && !_bfd_elf_write_section_eh_frame (output_bfd, info,
15869 htab->glink_eh_frame,
15870 htab->glink_eh_frame->contents))
15871 return FALSE;
15872 }
58d180e8 15873
e717da7e 15874 /* We need to handle writing out multiple GOT sections ourselves,
7b53ace3
AM		 15875 since we didn't add them to DYNOBJ. We know dynobj is the first
15876 bfd. */
c72f2fb2 15877 while ((dynobj = dynobj->link.next) != NULL)
e717da7e
AM		 15878 {
15879 asection *s;
7b53ace3 15880
0c8d6e5c 15881 if (!is_ppc64_elf (dynobj))
7b53ace3
AM		 15882 continue;
15883
e717da7e
AM		 15884 s = ppc64_elf_tdata (dynobj)->got;
15885 if (s != NULL
eea6121a 15886 && s->size != 0
e717da7e
AM		 15887 && s->output_section != bfd_abs_section_ptr
15888 && !bfd_set_section_contents (output_bfd, s->output_section,
15889 s->contents, s->output_offset,
eea6121a 15890 s->size))
e717da7e
AM		 15891 return FALSE;
15892 s = ppc64_elf_tdata (dynobj)->relgot;
15893 if (s != NULL
eea6121a 15894 && s->size != 0
e717da7e
AM		 15895 && s->output_section != bfd_abs_section_ptr
15896 && !bfd_set_section_contents (output_bfd, s->output_section,
15897 s->contents, s->output_offset,
eea6121a 15898 s->size))
e717da7e
AM		 15899 return FALSE;
15900 }
f6c52c13 15901
b34976b6 15902 return TRUE;
5bd4f169
AM		 15903}
15904
5bd4f169 15905#include "elf64-target.h"
7b8e7dad
AM		 15906
15907/* FreeBSD support */
15908
15909#undef TARGET_LITTLE_SYM
15910#undef TARGET_LITTLE_NAME
15911
15912#undef TARGET_BIG_SYM
6d00b590 15913#define TARGET_BIG_SYM powerpc_elf64_fbsd_vec
7b8e7dad
AM		 15914#undef TARGET_BIG_NAME
15915#define TARGET_BIG_NAME "elf64-powerpc-freebsd"
15916
15917#undef ELF_OSABI
15918#define ELF_OSABI ELFOSABI_FREEBSD
15919
15920#undef elf64_bed
15921#define elf64_bed elf64_powerpc_fbsd_bed
15922
15923#include "elf64-target.h"
GDB Binutils - Deliverables
This page took 3.00516 seconds and 4 git commands to generate.