projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
remove param "dispp" from ada-lang.c::ada_lookup_struct_elt_type
[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
46434633 9746/* If H is undefined, make it dynamic if that makes sense. */
f0158f44
AM		 9747
9748static bfd_boolean
46434633
AM		 9749ensure_undef_dynamic (struct bfd_link_info *info,
9750 struct elf_link_hash_entry *h)
f0158f44
AM		 9751{
9752 struct elf_link_hash_table *htab = elf_hash_table (info);
9753
9754 if (htab->dynamic_sections_created
46434633
AM		 9755 && ((info->dynamic_undefined_weak != 0
9756 && h->root.type == bfd_link_hash_undefweak)
9757 || h->root.type == bfd_link_hash_undefined)
f0158f44
AM		 9758 && h->dynindx == -1
9759 && !h->forced_local
9760 && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
9761 return bfd_elf_link_record_dynamic_symbol (info, h);
9762 return TRUE;
9763}
9764
65f38f15
AM		 9765/* Allocate space in .plt, .got and associated reloc sections for
9766 dynamic relocs. */
5bd4f169 9767
b34976b6 9768static bfd_boolean
4ce794b7 9769allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
5bd4f169 9770{
65f38f15
AM		 9771 struct bfd_link_info *info;
9772 struct ppc_link_hash_table *htab;
5bd4f169 9773 asection *s;
65f38f15 9774 struct ppc_link_hash_entry *eh;
0b8bcf0d 9775 struct got_entry **pgent, *gent;
5bd4f169 9776
e92d460e 9777 if (h->root.type == bfd_link_hash_indirect)
b34976b6 9778 return TRUE;
5bd4f169 9779
65f38f15
AM		 9780 info = (struct bfd_link_info *) inf;
9781 htab = ppc_hash_table (info);
4dfe6ac6
NC		 9782 if (htab == NULL)
9783 return FALSE;
5bd4f169 9784
951fd09b
AM		 9785 eh = (struct ppc_link_hash_entry *) h;
9786 /* Run through the TLS GD got entries first if we're changing them
9787 to TPREL. */
e7b938ca 9788 if ((eh->tls_mask & TLS_TPRELGD) != 0)
951fd09b
AM		 9789 for (gent = h->got.glist; gent != NULL; gent = gent->next)
9790 if (gent->got.refcount > 0
9791 && (gent->tls_type & TLS_GD) != 0)
9792 {
9793 /* This was a GD entry that has been converted to TPREL. If
9794 there happens to be a TPREL entry we can use that one. */
9795 struct got_entry *ent;
9796 for (ent = h->got.glist; ent != NULL; ent = ent->next)
9797 if (ent->got.refcount > 0
9798 && (ent->tls_type & TLS_TPREL) != 0
e717da7e
AM		 9799 && ent->addend == gent->addend
9800 && ent->owner == gent->owner)
951fd09b
AM		 9801 {
9802 gent->got.refcount = 0;
9803 break;
9804 }
9805
9806 /* If not, then we'll be using our own TPREL entry. */
9807 if (gent->got.refcount != 0)
9808 gent->tls_type = TLS_TLS | TLS_TPREL;
9809 }
9810
7865406b
AM		 9811 /* Remove any list entry that won't generate a word in the GOT before
9812 we call merge_got_entries. Otherwise we risk merging to empty
9813 entries. */
0b8bcf0d
AM		 9814 pgent = &h->got.glist;
9815 while ((gent = *pgent) != NULL)
411e1bfb 9816 if (gent->got.refcount > 0)
7865406b
AM		 9817 {
9818 if ((gent->tls_type & TLS_LD) != 0
9819 && !h->def_dynamic)
9820 {
9821 ppc64_tlsld_got (gent->owner)->got.refcount += 1;
9822 *pgent = gent->next;
9823 }
9824 else
9825 pgent = &gent->next;
9826 }
9827 else
9828 *pgent = gent->next;
9829
9830 if (!htab->do_multi_toc)
9831 merge_got_entries (&h->got.glist);
9832
9833 for (gent = h->got.glist; gent != NULL; gent = gent->next)
9834 if (!gent->is_indirect)
411e1bfb 9835 {
46434633
AM		 9836 /* Make sure this symbol is output as a dynamic symbol. */
9837 if (!ensure_undef_dynamic (info, h))
f0158f44 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 {
46434633
AM		 9891 /* Make sure this symbol is output as a dynamic symbol. */
9892 if (!ensure_undef_dynamic (info, h))
f0158f44 9893 return FALSE;
5bd4f169 9894 }
65f38f15 9895 }
57e7d118 9896 else if (h->type == STT_GNU_IFUNC)
dfbb6ac9 9897 {
8a2058b5
AM		 9898 /* A plt entry is always created when making direct calls to
9899 an ifunc, even when building a static executable, but
9900 that doesn't cover all cases. We may have only an ifunc
9901 initialised function pointer for a given ifunc symbol.
9902
9903 For ELFv2, dynamic relocations are not required when
9904 generating a global entry PLT stub. */
9905 if (abiversion (info->output_bfd) >= 2)
9906 {
9907 if (global_entry_stub (h))
9908 eh->dyn_relocs = NULL;
9909 }
9910
9911 /* For ELFv1 we have function descriptors. Descriptors need
9912 to be treated like PLT entries and thus have dynamic
9913 relocations. One exception is when the function
9914 descriptor is copied into .dynbss (which should only
9915 happen with ancient versions of gcc). */
9916 else if (h->needs_copy)
dfbb6ac9 9917 eh->dyn_relocs = NULL;
57e7d118
AM		 9918 }
9919 else if (ELIMINATE_COPY_RELOCS)
9920 {
8a2058b5 9921 /* For the non-pic case, discard space for relocs against
57e7d118
AM		 9922 symbols which turn out to need copy relocs or are not
9923 dynamic. */
f0158f44
AM		 9924 if (!h->non_got_ref
9925 && !h->def_regular)
9926 {
46434633
AM		 9927 /* Make sure this symbol is output as a dynamic symbol. */
9928 if (!ensure_undef_dynamic (info, h))
f0158f44 9929 return FALSE;
dfbb6ac9 9930
f0158f44
AM		 9931 if (h->dynindx == -1)
9932 eh->dyn_relocs = NULL;
9933 }
9934 else
8a2058b5 9935 eh->dyn_relocs = NULL;
57e7d118
AM		 9936 }
9937
9938 /* Finally, allocate space. */
9939 for (p = eh->dyn_relocs; p != NULL; p = p->next)
9940 {
9941 asection *sreloc = elf_section_data (p->sec)->sreloc;
9942 if (eh->elf.type == STT_GNU_IFUNC)
9943 sreloc = htab->elf.irelplt;
9944 sreloc->size += p->count * sizeof (Elf64_External_Rela);
dfbb6ac9 9945 }
65f38f15 9946 }
57e7d118
AM		 9947
9948 if ((htab->elf.dynamic_sections_created
f0158f44 9949 && h->dynindx != -1)
57e7d118 9950 || h->type == STT_GNU_IFUNC)
65f38f15 9951 {
57e7d118
AM		 9952 struct plt_entry *pent;
9953 bfd_boolean doneone = FALSE;
9954 for (pent = h->plt.plist; pent != NULL; pent = pent->next)
9955 if (pent->plt.refcount > 0)
9956 {
9957 if (!htab->elf.dynamic_sections_created
9958 || h->dynindx == -1)
9959 {
9960 s = htab->elf.iplt;
9961 pent->plt.offset = s->size;
9962 s->size += PLT_ENTRY_SIZE (htab);
9963 s = htab->elf.irelplt;
9964 }
9965 else
9966 {
9967 /* If this is the first .plt entry, make room for the special
9968 first entry. */
9969 s = htab->elf.splt;
9970 if (s->size == 0)
9971 s->size += PLT_INITIAL_ENTRY_SIZE (htab);
65f38f15 9972
57e7d118 9973 pent->plt.offset = s->size;
65f38f15 9974
57e7d118
AM		 9975 /* Make room for this entry. */
9976 s->size += PLT_ENTRY_SIZE (htab);
65f38f15 9977
57e7d118
AM		 9978 /* Make room for the .glink code. */
9979 s = htab->glink;
9980 if (s->size == 0)
9981 s->size += GLINK_CALL_STUB_SIZE;
9982 if (htab->opd_abi)
9983 {
9984 /* We need bigger stubs past index 32767. */
9985 if (s->size >= GLINK_CALL_STUB_SIZE + 32768*2*4)
9986 s->size += 4;
9987 s->size += 2*4;
9988 }
9989 else
9990 s->size += 4;
65f38f15 9991
57e7d118
AM		 9992 /* We also need to make an entry in the .rela.plt section. */
9993 s = htab->elf.srelplt;
9994 }
9995 s->size += sizeof (Elf64_External_Rela);
9996 doneone = TRUE;
9997 }
9998 else
9999 pent->plt.offset = (bfd_vma) -1;
10000 if (!doneone)
10001 {
10002 h->plt.plist = NULL;
10003 h->needs_plt = 0;
10004 }
65f38f15 10005 }
57e7d118 10006 else
65f38f15 10007 {
57e7d118
AM		 10008 h->plt.plist = NULL;
10009 h->needs_plt = 0;
65f38f15
AM		 10010 }
10011
b34976b6 10012 return TRUE;
65f38f15
AM		 10013}
10014
a345bc8d
AM		 10015/* Called via elf_link_hash_traverse from ppc64_elf_size_dynamic_sections
10016 to set up space for global entry stubs. These are put in glink,
10017 after the branch table. */
65f38f15 10018
b34976b6 10019static bfd_boolean
a345bc8d 10020size_global_entry_stubs (struct elf_link_hash_entry *h, void *inf)
65f38f15 10021{
a345bc8d
AM		 10022 struct bfd_link_info *info;
10023 struct ppc_link_hash_table *htab;
10024 struct plt_entry *pent;
10025 asection *s;
65f38f15 10026
a345bc8d
AM		 10027 if (h->root.type == bfd_link_hash_indirect)
10028 return TRUE;
65f38f15 10029
a345bc8d
AM		 10030 if (!h->pointer_equality_needed)
10031 return TRUE;
65f38f15 10032
a345bc8d
AM		 10033 if (h->def_regular)
10034 return TRUE;
65f38f15 10035
a345bc8d
AM		 10036 info = inf;
10037 htab = ppc_hash_table (info);
10038 if (htab == NULL)
10039 return FALSE;
10040
10041 s = htab->glink;
10042 for (pent = h->plt.plist; pent != NULL; pent = pent->next)
10043 if (pent->plt.offset != (bfd_vma) -1
10044 && pent->addend == 0)
10045 {
afe397ea
AM		 10046 /* For ELFv2, if this symbol is not defined in a regular file
10047 and we are not generating a shared library or pie, then we
10048 need to define the symbol in the executable on a call stub.
10049 This is to avoid text relocations. */
a345bc8d 10050 s->size = (s->size + 15) & -16;
8a2058b5 10051 h->root.type = bfd_link_hash_defined;
afe397ea
AM		 10052 h->root.u.def.section = s;
10053 h->root.u.def.value = s->size;
a345bc8d
AM		 10054 s->size += 16;
10055 break;
10056 }
10057 return TRUE;
10058}
10059
10060/* Set DF_TEXTREL if we find any dynamic relocs that apply to
10061 read-only sections. */
10062
10063static bfd_boolean
10064maybe_set_textrel (struct elf_link_hash_entry *h, void *info)
10065{
10066 if (h->root.type == bfd_link_hash_indirect)
10067 return TRUE;
10068
10069 if (readonly_dynrelocs (h))
10070 {
10071 ((struct bfd_link_info *) info)->flags |= DF_TEXTREL;
10072
10073 /* Not an error, just cut short the traversal. */
10074 return FALSE;
65f38f15 10075 }
b34976b6 10076 return TRUE;
65f38f15
AM		 10077}
10078
10079/* Set the sizes of the dynamic sections. */
10080
b34976b6 10081static bfd_boolean
ee67d69a 10082ppc64_elf_size_dynamic_sections (bfd *output_bfd,
4ce794b7 10083 struct bfd_link_info *info)
65f38f15
AM		 10084{
10085 struct ppc_link_hash_table *htab;
10086 bfd *dynobj;
10087 asection *s;
b34976b6 10088 bfd_boolean relocs;
65f38f15 10089 bfd *ibfd;
7865406b 10090 struct got_entry *first_tlsld;
65f38f15
AM		 10091
10092 htab = ppc_hash_table (info);
4dfe6ac6
NC		 10093 if (htab == NULL)
10094 return FALSE;
10095
65f38f15
AM		 10096 dynobj = htab->elf.dynobj;
10097 if (dynobj == NULL)
10098 abort ();
10099
10100 if (htab->elf.dynamic_sections_created)
10101 {
10102 /* Set the contents of the .interp section to the interpreter. */
9b8b325a 10103 if (bfd_link_executable (info) && !info->nointerp)
65f38f15 10104 {
3d4d4302 10105 s = bfd_get_linker_section (dynobj, ".interp");
65f38f15
AM		 10106 if (s == NULL)
10107 abort ();
eea6121a 10108 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
65f38f15
AM		 10109 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
10110 }
10111 }
10112
10113 /* Set up .got offsets for local syms, and space for local dynamic
10114 relocs. */
c72f2fb2 10115 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
65f38f15 10116 {
411e1bfb
AM		 10117 struct got_entry **lgot_ents;
10118 struct got_entry **end_lgot_ents;
e054468f
AM		 10119 struct plt_entry **local_plt;
10120 struct plt_entry **end_local_plt;
f961d9dd 10121 unsigned char *lgot_masks;
65f38f15
AM		 10122 bfd_size_type locsymcount;
10123 Elf_Internal_Shdr *symtab_hdr;
65f38f15 10124
0c8d6e5c 10125 if (!is_ppc64_elf (ibfd))
65f38f15
AM		 10126 continue;
10127
10128 for (s = ibfd->sections; s != NULL; s = s->next)
10129 {
19e08130 10130 struct ppc_dyn_relocs *p;
65f38f15 10131
6edfbbad 10132 for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
65f38f15 10133 {
ec338859
AM		 10134 if (!bfd_is_abs_section (p->sec)
10135 && bfd_is_abs_section (p->sec->output_section))
10136 {
10137 /* Input section has been discarded, either because
10138 it is a copy of a linkonce section or due to
10139 linker script /DISCARD/, so we'll be discarding
10140 the relocs too. */
10141 }
248866a8 10142 else if (p->count != 0)
ec338859 10143 {
19e08130
AM		 10144 asection *srel = elf_section_data (p->sec)->sreloc;
10145 if (p->ifunc)
33e44f2e 10146 srel = htab->elf.irelplt;
eea6121a 10147 srel->size += p->count * sizeof (Elf64_External_Rela);
248866a8
AM		 10148 if ((p->sec->output_section->flags & SEC_READONLY) != 0)
10149 info->flags |= DF_TEXTREL;
ec338859 10150 }
65f38f15
AM		 10151 }
10152 }
10153
411e1bfb
AM		 10154 lgot_ents = elf_local_got_ents (ibfd);
10155 if (!lgot_ents)
65f38f15
AM		 10156 continue;
10157
0ffa91dd 10158 symtab_hdr = &elf_symtab_hdr (ibfd);
65f38f15 10159 locsymcount = symtab_hdr->sh_info;
411e1bfb 10160 end_lgot_ents = lgot_ents + locsymcount;
e054468f
AM		 10161 local_plt = (struct plt_entry **) end_lgot_ents;
10162 end_local_plt = local_plt + locsymcount;
f961d9dd 10163 lgot_masks = (unsigned char *) end_local_plt;
e717da7e 10164 s = ppc64_elf_tdata (ibfd)->got;
e7b938ca 10165 for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
65f38f15 10166 {
0b8bcf0d 10167 struct got_entry **pent, *ent;
411e1bfb 10168
0b8bcf0d
AM		 10169 pent = lgot_ents;
10170 while ((ent = *pent) != NULL)
411e1bfb
AM		 10171 if (ent->got.refcount > 0)
10172 {
e7b938ca 10173 if ((ent->tls_type & *lgot_masks & TLS_LD) != 0)
411e1bfb 10174 {
927be08e 10175 ppc64_tlsld_got (ibfd)->got.refcount += 1;
0b8bcf0d 10176 *pent = ent->next;
411e1bfb
AM		 10177 }
10178 else
10179 {
19e08130
AM		 10180 unsigned int ent_size = 8;
10181 unsigned int rel_size = sizeof (Elf64_External_Rela);
10182
eea6121a 10183 ent->got.offset = s->size;
e7b938ca 10184 if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
927be08e 10185 {
19e08130
AM		 10186 ent_size *= 2;
10187 rel_size *= 2;
10188 }
10189 s->size += ent_size;
10190 if ((*lgot_masks & PLT_IFUNC) != 0)
10191 {
33e44f2e 10192 htab->elf.irelplt->size += rel_size;
19e08130
AM		 10193 htab->got_reli_size += rel_size;
10194 }
0e1862bb 10195 else if (bfd_link_pic (info))
19e08130
AM		 10196 {
10197 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
10198 srel->size += rel_size;
927be08e 10199 }
0b8bcf0d 10200 pent = &ent->next;
411e1bfb
AM		 10201 }
10202 }
10203 else
0b8bcf0d 10204 *pent = ent->next;
65f38f15 10205 }
e054468f
AM		 10206
10207 /* Allocate space for calls to local STT_GNU_IFUNC syms in .iplt. */
10208 for (; local_plt < end_local_plt; ++local_plt)
10209 {
10210 struct plt_entry *ent;
10211
10212 for (ent = *local_plt; ent != NULL; ent = ent->next)
10213 if (ent->plt.refcount > 0)
10214 {
33e44f2e 10215 s = htab->elf.iplt;
e054468f 10216 ent->plt.offset = s->size;
b9e5796b 10217 s->size += PLT_ENTRY_SIZE (htab);
e054468f 10218
33e44f2e 10219 htab->elf.irelplt->size += sizeof (Elf64_External_Rela);
e054468f
AM		 10220 }
10221 else
10222 ent->plt.offset = (bfd_vma) -1;
10223 }
65f38f15
AM		 10224 }
10225
10226 /* Allocate global sym .plt and .got entries, and space for global
10227 sym dynamic relocs. */
4ce794b7 10228 elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, info);
a345bc8d
AM		 10229 /* Stash the end of glink branch table. */
10230 if (htab->glink != NULL)
10231 htab->glink->rawsize = htab->glink->size;
10232
0e1862bb 10233 if (!htab->opd_abi && !bfd_link_pic (info))
a345bc8d 10234 elf_link_hash_traverse (&htab->elf, size_global_entry_stubs, info);
65f38f15 10235
7865406b 10236 first_tlsld = NULL;
c72f2fb2 10237 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
102890f0 10238 {
7865406b
AM		 10239 struct got_entry *ent;
10240
0c8d6e5c 10241 if (!is_ppc64_elf (ibfd))
102890f0
AM		 10242 continue;
10243
7865406b
AM		 10244 ent = ppc64_tlsld_got (ibfd);
10245 if (ent->got.refcount > 0)
102890f0 10246 {
7865406b 10247 if (!htab->do_multi_toc && first_tlsld != NULL)
102890f0 10248 {
7865406b
AM		 10249 ent->is_indirect = TRUE;
10250 ent->got.ent = first_tlsld;
10251 }
10252 else
10253 {
10254 if (first_tlsld == NULL)
10255 first_tlsld = ent;
10256 s = ppc64_elf_tdata (ibfd)->got;
10257 ent->got.offset = s->size;
10258 ent->owner = ibfd;
10259 s->size += 16;
0e1862bb 10260 if (bfd_link_pic (info))
7865406b
AM		 10261 {
10262 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
10263 srel->size += sizeof (Elf64_External_Rela);
10264 }
102890f0
AM		 10265 }
10266 }
10267 else
7865406b 10268 ent->got.offset = (bfd_vma) -1;
102890f0
AM		 10269 }
10270
65f38f15
AM		 10271 /* We now have determined the sizes of the various dynamic sections.
10272 Allocate memory for them. */
b34976b6 10273 relocs = FALSE;
65f38f15
AM		 10274 for (s = dynobj->sections; s != NULL; s = s->next)
10275 {
10276 if ((s->flags & SEC_LINKER_CREATED) == 0)
10277 continue;
10278
4ce794b7 10279 if (s == htab->brlt || s == htab->relbrlt)
721956f4
AM		 10280 /* These haven't been allocated yet; don't strip. */
10281 continue;
33e44f2e
AM		 10282 else if (s == htab->elf.sgot
10283 || s == htab->elf.splt
10284 || s == htab->elf.iplt
c456f082 10285 || s == htab->glink
5474d94f
AM		 10286 || s == htab->elf.sdynbss
10287 || s == htab->elf.sdynrelro)
65f38f15
AM		 10288 {
10289 /* Strip this section if we don't need it; see the
10290 comment below. */
5bd4f169 10291 }
58d180e8
AM		 10292 else if (s == htab->glink_eh_frame)
10293 {
10294 if (!bfd_is_abs_section (s->output_section))
10295 /* Not sized yet. */
10296 continue;
10297 }
70cc837d 10298 else if (CONST_STRNEQ (s->name, ".rela"))
5bd4f169 10299 {
c456f082 10300 if (s->size != 0)
5bd4f169 10301 {
33e44f2e 10302 if (s != htab->elf.srelplt)
b34976b6 10303 relocs = TRUE;
5bd4f169
AM		 10304
10305 /* We use the reloc_count field as a counter if we need
10306 to copy relocs into the output file. */
10307 s->reloc_count = 0;
10308 }
10309 }
65f38f15 10310 else
5bd4f169
AM		 10311 {
10312 /* It's not one of our sections, so don't allocate space. */
10313 continue;
10314 }
10315
eea6121a 10316 if (s->size == 0)
5bd4f169 10317 {
c456f082
AM		 10318 /* If we don't need this section, strip it from the
10319 output file. This is mostly to handle .rela.bss and
10320 .rela.plt. We must create both sections in
10321 create_dynamic_sections, because they must be created
10322 before the linker maps input sections to output
10323 sections. The linker does that before
10324 adjust_dynamic_symbol is called, and it is that
10325 function which decides whether anything needs to go
10326 into these sections. */
8423293d 10327 s->flags |= SEC_EXCLUDE;
5bd4f169
AM		 10328 continue;
10329 }
10330
c456f082 10331 if ((s->flags & SEC_HAS_CONTENTS) == 0)
5f333394
AM		 10332 continue;
10333
65f38f15
AM		 10334 /* Allocate memory for the section contents. We use bfd_zalloc
10335 here in case unused entries are not reclaimed before the
10336 section's contents are written out. This should not happen,
411e1bfb
AM		 10337 but this way if it does we get a R_PPC64_NONE reloc in .rela
10338 sections instead of garbage.
10339 We also rely on the section contents being zero when writing
5474d94f 10340 the GOT and .dynrelro. */
eea6121a 10341 s->contents = bfd_zalloc (dynobj, s->size);
65f38f15 10342 if (s->contents == NULL)
b34976b6 10343 return FALSE;
5bd4f169
AM		 10344 }
10345
c72f2fb2 10346 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
e717da7e 10347 {
0c8d6e5c 10348 if (!is_ppc64_elf (ibfd))
7b53ace3
AM		 10349 continue;
10350
e717da7e 10351 s = ppc64_elf_tdata (ibfd)->got;
33e44f2e 10352 if (s != NULL && s != htab->elf.sgot)
e717da7e 10353 {
eea6121a 10354 if (s->size == 0)
8423293d 10355 s->flags |= SEC_EXCLUDE;
e717da7e
AM		 10356 else
10357 {
eea6121a 10358 s->contents = bfd_zalloc (ibfd, s->size);
e717da7e
AM		 10359 if (s->contents == NULL)
10360 return FALSE;
10361 }
10362 }
10363 s = ppc64_elf_tdata (ibfd)->relgot;
10364 if (s != NULL)
10365 {
eea6121a 10366 if (s->size == 0)
8423293d 10367 s->flags |= SEC_EXCLUDE;
e717da7e
AM		 10368 else
10369 {
eea6121a 10370 s->contents = bfd_zalloc (ibfd, s->size);
e717da7e
AM		 10371 if (s->contents == NULL)
10372 return FALSE;
10373 relocs = TRUE;
10374 s->reloc_count = 0;
10375 }
10376 }
10377 }
10378
e86ce104 10379 if (htab->elf.dynamic_sections_created)
5bd4f169 10380 {
e8910a83
AM		 10381 bfd_boolean tls_opt;
10382
5bd4f169
AM		 10383 /* Add some entries to the .dynamic section. We fill in the
10384 values later, in ppc64_elf_finish_dynamic_sections, but we
10385 must add the entries now so that we get the correct size for
10386 the .dynamic section. The DT_DEBUG entry is filled in by the
10387 dynamic linker and used by the debugger. */
dc810e39 10388#define add_dynamic_entry(TAG, VAL) \
5a580b3a 10389 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
dc810e39 10390
0e1862bb 10391 if (bfd_link_executable (info))
5bd4f169 10392 {
dc810e39 10393 if (!add_dynamic_entry (DT_DEBUG, 0))
b34976b6 10394 return FALSE;
5bd4f169
AM		 10395 }
10396
33e44f2e 10397 if (htab->elf.splt != NULL && htab->elf.splt->size != 0)
5bd4f169 10398 {
dc810e39
AM		 10399 if (!add_dynamic_entry (DT_PLTGOT, 0)
10400 || !add_dynamic_entry (DT_PLTRELSZ, 0)
10401 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
5d1634d7
AM		 10402 || !add_dynamic_entry (DT_JMPREL, 0)
10403 || !add_dynamic_entry (DT_PPC64_GLINK, 0))
b34976b6 10404 return FALSE;
5bd4f169
AM		 10405 }
10406
ee67d69a 10407 if (NO_OPD_RELOCS && abiversion (output_bfd) <= 1)
19397422
AM		 10408 {
10409 if (!add_dynamic_entry (DT_PPC64_OPD, 0)
10410 || !add_dynamic_entry (DT_PPC64_OPDSZ, 0))
b34976b6 10411 return FALSE;
19397422
AM		 10412 }
10413
7c9cf415 10414 tls_opt = (htab->params->tls_get_addr_opt
e8910a83
AM		 10415 && htab->tls_get_addr_fd != NULL
10416 && htab->tls_get_addr_fd->elf.plt.plist != NULL);
10417 if (tls_opt || !htab->opd_abi)
10418 {
10419 if (!add_dynamic_entry (DT_PPC64_OPT, tls_opt ? PPC64_OPT_TLS : 0))
10420 return FALSE;
10421 }
a7f2871e 10422
5bd4f169
AM		 10423 if (relocs)
10424 {
dc810e39
AM		 10425 if (!add_dynamic_entry (DT_RELA, 0)
10426 || !add_dynamic_entry (DT_RELASZ, 0)
10427 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
b34976b6 10428 return FALSE;
5bd4f169 10429
65f38f15
AM		 10430 /* If any dynamic relocs apply to a read-only section,
10431 then we need a DT_TEXTREL entry. */
248866a8 10432 if ((info->flags & DF_TEXTREL) == 0)
a345bc8d 10433 elf_link_hash_traverse (&htab->elf, maybe_set_textrel, info);
5bd4f169 10434
65f38f15 10435 if ((info->flags & DF_TEXTREL) != 0)
5bd4f169 10436 {
65f38f15 10437 if (!add_dynamic_entry (DT_TEXTREL, 0))
b34976b6 10438 return FALSE;
5bd4f169 10439 }
5bd4f169 10440 }
5bd4f169 10441 }
65f38f15 10442#undef add_dynamic_entry
5bd4f169 10443
b34976b6 10444 return TRUE;
5bd4f169
AM		 10445}
10446
a345bc8d
AM		 10447/* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
10448
10449static bfd_boolean
10450ppc64_elf_hash_symbol (struct elf_link_hash_entry *h)
10451{
10452 if (h->plt.plist != NULL
10453 && !h->def_regular
10454 && !h->pointer_equality_needed)
10455 return FALSE;
10456
10457 return _bfd_elf_hash_symbol (h);
10458}
10459
721956f4 10460/* Determine the type of stub needed, if any, for a call. */
5bd4f169 10461
4ce794b7
AM		 10462static inline enum ppc_stub_type
10463ppc_type_of_stub (asection *input_sec,
10464 const Elf_Internal_Rela *rel,
10465 struct ppc_link_hash_entry **hash,
e054468f 10466 struct plt_entry **plt_ent,
6911b7dc
AM		 10467 bfd_vma destination,
10468 unsigned long local_off)
5bd4f169 10469{
721956f4
AM		 10470 struct ppc_link_hash_entry *h = *hash;
10471 bfd_vma location;
10472 bfd_vma branch_offset;
10473 bfd_vma max_branch_offset;
4ce794b7 10474 enum elf_ppc64_reloc_type r_type;
5bd4f169 10475
721956f4
AM		 10476 if (h != NULL)
10477 {
e054468f 10478 struct plt_entry *ent;
7fe2b9a6 10479 struct ppc_link_hash_entry *fdh = h;
b31867b6
AM		 10480 if (h->oh != NULL
10481 && h->oh->is_func_descriptor)
7b8f6675
AM		 10482 {
10483 fdh = ppc_follow_link (h->oh);
10484 *hash = fdh;
10485 }
8387904d 10486
e054468f
AM		 10487 for (ent = fdh->elf.plt.plist; ent != NULL; ent = ent->next)
10488 if (ent->addend == rel->r_addend
10489 && ent->plt.offset != (bfd_vma) -1)
10490 {
e054468f
AM		 10491 *plt_ent = ent;
10492 return ppc_stub_plt_call;
10493 }
5bd4f169 10494
7fe2b9a6
AM		 10495 /* Here, we know we don't have a plt entry. If we don't have a
10496 either a defined function descriptor or a defined entry symbol
10497 in a regular object file, then it is pointless trying to make
10498 any other type of stub. */
854b41e7
AM		 10499 if (!is_static_defined (&fdh->elf)
10500 && !is_static_defined (&h->elf))
721956f4 10501 return ppc_stub_none;
5d1634d7 10502 }
e054468f
AM		 10503 else if (elf_local_got_ents (input_sec->owner) != NULL)
10504 {
10505 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (input_sec->owner);
10506 struct plt_entry **local_plt = (struct plt_entry **)
10507 elf_local_got_ents (input_sec->owner) + symtab_hdr->sh_info;
10508 unsigned long r_symndx = ELF64_R_SYM (rel->r_info);
10509
10510 if (local_plt[r_symndx] != NULL)
10511 {
10512 struct plt_entry *ent;
10513
10514 for (ent = local_plt[r_symndx]; ent != NULL; ent = ent->next)
10515 if (ent->addend == rel->r_addend
10516 && ent->plt.offset != (bfd_vma) -1)
10517 {
10518 *plt_ent = ent;
10519 return ppc_stub_plt_call;
10520 }
10521 }
10522 }
5d1634d7 10523
721956f4
AM		 10524 /* Determine where the call point is. */
10525 location = (input_sec->output_offset
10526 + input_sec->output_section->vma
10527 + rel->r_offset);
5d1634d7 10528
721956f4
AM		 10529 branch_offset = destination - location;
10530 r_type = ELF64_R_TYPE (rel->r_info);
5d1634d7 10531
721956f4
AM		 10532 /* Determine if a long branch stub is needed. */
10533 max_branch_offset = 1 << 25;
4ce794b7 10534 if (r_type != R_PPC64_REL24)
721956f4 10535 max_branch_offset = 1 << 15;
5d1634d7 10536
6911b7dc 10537 if (branch_offset + max_branch_offset >= 2 * max_branch_offset - local_off)
721956f4
AM		 10538 /* We need a stub. Figure out whether a long_branch or plt_branch
10539 is needed later. */
10540 return ppc_stub_long_branch;
5d1634d7 10541
721956f4 10542 return ppc_stub_none;
5d1634d7
AM		 10543}
10544
794e51c0
AM		 10545/* With power7 weakly ordered memory model, it is possible for ld.so
10546 to update a plt entry in one thread and have another thread see a
10547 stale zero toc entry. To avoid this we need some sort of acquire
10548 barrier in the call stub. One solution is to make the load of the
10549 toc word seem to appear to depend on the load of the function entry
10550 word. Another solution is to test for r2 being zero, and branch to
10551 the appropriate glink entry if so.
10552
10553 . fake dep barrier compare
71a39c98
AM		 10554 . ld 12,xxx(2) ld 12,xxx(2)
10555 . mtctr 12 mtctr 12
10556 . xor 11,12,12 ld 2,xxx+8(2)
794e51c0
AM		 10557 . add 2,2,11 cmpldi 2,0
10558 . ld 2,xxx+8(2) bnectr+
10559 . bctr b <glink_entry>
10560
10561 The solution involving the compare turns out to be faster, so
10562 that's what we use unless the branch won't reach. */
10563
10564#define ALWAYS_USE_FAKE_DEP 0
10565#define ALWAYS_EMIT_R2SAVE 0
5d1634d7 10566
5d1634d7
AM		 10567#define PPC_LO(v) ((v) & 0xffff)
10568#define PPC_HI(v) (((v) >> 16) & 0xffff)
10569#define PPC_HA(v) PPC_HI ((v) + 0x8000)
10570
794e51c0
AM		 10571static inline unsigned int
10572plt_stub_size (struct ppc_link_hash_table *htab,
10573 struct ppc_stub_hash_entry *stub_entry,
10574 bfd_vma off)
10575{
b9e5796b
AM		 10576 unsigned size = 12;
10577
10578 if (ALWAYS_EMIT_R2SAVE
10579 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10580 size += 4;
10581 if (PPC_HA (off) != 0)
794e51c0 10582 size += 4;
b9e5796b
AM		 10583 if (htab->opd_abi)
10584 {
10585 size += 4;
e7d1c40c 10586 if (htab->params->plt_static_chain)
b9e5796b 10587 size += 4;
bd4d2eaa
AM		 10588 if (htab->params->plt_thread_safe
10589 && htab->elf.dynamic_sections_created
10590 && stub_entry->h != NULL
10591 && stub_entry->h->elf.dynindx != -1)
b9e5796b 10592 size += 8;
e7d1c40c 10593 if (PPC_HA (off + 8 + 8 * htab->params->plt_static_chain) != PPC_HA (off))
b9e5796b
AM		 10594 size += 4;
10595 }
794e51c0
AM		 10596 if (stub_entry->h != NULL
10597 && (stub_entry->h == htab->tls_get_addr_fd
10598 || stub_entry->h == htab->tls_get_addr)
7c9cf415 10599 && htab->params->tls_get_addr_opt)
f378ab09
AM		 10600 {
10601 size += 7 * 4;
10602 if (ALWAYS_EMIT_R2SAVE
10603 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10604 size += 6 * 4;
10605 }
794e51c0
AM		 10606 return size;
10607}
10608
10609/* If this stub would cross fewer 2**plt_stub_align boundaries if we align,
10610 then return the padding needed to do so. */
10611static inline unsigned int
10612plt_stub_pad (struct ppc_link_hash_table *htab,
10613 struct ppc_stub_hash_entry *stub_entry,
10614 bfd_vma plt_off)
10615{
e7d1c40c 10616 int stub_align = 1 << htab->params->plt_stub_align;
794e51c0 10617 unsigned stub_size = plt_stub_size (htab, stub_entry, plt_off);
6f20ed8a 10618 bfd_vma stub_off = stub_entry->group->stub_sec->size;
794e51c0
AM		 10619
10620 if (((stub_off + stub_size - 1) & -stub_align) - (stub_off & -stub_align)
e05fa0ba 10621 > ((stub_size - 1) & -stub_align))
794e51c0
AM		 10622 return stub_align - (stub_off & (stub_align - 1));
10623 return 0;
10624}
10625
10626/* Build a .plt call stub. */
10627
10628static inline bfd_byte *
10629build_plt_stub (struct ppc_link_hash_table *htab,
10630 struct ppc_stub_hash_entry *stub_entry,
10631 bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
10632{
e7d1c40c 10633 bfd *obfd = htab->params->stub_bfd;
b9e5796b 10634 bfd_boolean plt_load_toc = htab->opd_abi;
e7d1c40c 10635 bfd_boolean plt_static_chain = htab->params->plt_static_chain;
bd4d2eaa
AM		 10636 bfd_boolean plt_thread_safe = (htab->params->plt_thread_safe
10637 && htab->elf.dynamic_sections_created
10638 && stub_entry->h != NULL
10639 && stub_entry->h->elf.dynindx != -1);
794e51c0
AM		 10640 bfd_boolean use_fake_dep = plt_thread_safe;
10641 bfd_vma cmp_branch_off = 0;
10642
10643 if (!ALWAYS_USE_FAKE_DEP
b9e5796b 10644 && plt_load_toc
794e51c0 10645 && plt_thread_safe
bd4d2eaa
AM		 10646 && !((stub_entry->h == htab->tls_get_addr_fd
10647 || stub_entry->h == htab->tls_get_addr)
7c9cf415 10648 && htab->params->tls_get_addr_opt))
794e51c0
AM		 10649 {
10650 bfd_vma pltoff = stub_entry->plt_ent->plt.offset & ~1;
b9e5796b
AM		 10651 bfd_vma pltindex = ((pltoff - PLT_INITIAL_ENTRY_SIZE (htab))
10652 / PLT_ENTRY_SIZE (htab));
794e51c0
AM		 10653 bfd_vma glinkoff = GLINK_CALL_STUB_SIZE + pltindex * 8;
10654 bfd_vma to, from;
10655
68d62958
AM		 10656 if (pltindex > 32768)
10657 glinkoff += (pltindex - 32768) * 4;
794e51c0
AM		 10658 to = (glinkoff
10659 + htab->glink->output_offset
10660 + htab->glink->output_section->vma);
6f20ed8a 10661 from = (p - stub_entry->group->stub_sec->contents
794e51c0
AM		 10662 + 4 * (ALWAYS_EMIT_R2SAVE
10663 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10664 + 4 * (PPC_HA (offset) != 0)
10665 + 4 * (PPC_HA (offset + 8 + 8 * plt_static_chain)
10666 != PPC_HA (offset))
10667 + 4 * (plt_static_chain != 0)
10668 + 20
6f20ed8a
AM		 10669 + stub_entry->group->stub_sec->output_offset
10670 + stub_entry->group->stub_sec->output_section->vma);
794e51c0
AM		 10671 cmp_branch_off = to - from;
10672 use_fake_dep = cmp_branch_off + (1 << 25) >= (1 << 26);
10673 }
10674
ac2df442
AM		 10675 if (PPC_HA (offset) != 0)
10676 {
176a0d42
AM		 10677 if (r != NULL)
10678 {
794e51c0
AM		 10679 if (ALWAYS_EMIT_R2SAVE
10680 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10681 r[0].r_offset += 4;
176a0d42 10682 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
3b421ab3 10683 r[1].r_offset = r[0].r_offset + 4;
176a0d42
AM		 10684 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10685 r[1].r_addend = r[0].r_addend;
b9e5796b 10686 if (plt_load_toc)
176a0d42 10687 {
b9e5796b 10688 if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
c7131b65 10689 {
b9e5796b
AM		 10690 r[2].r_offset = r[1].r_offset + 4;
10691 r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO);
10692 r[2].r_addend = r[0].r_addend;
10693 }
10694 else
10695 {
10696 r[2].r_offset = r[1].r_offset + 8 + 8 * use_fake_dep;
10697 r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10698 r[2].r_addend = r[0].r_addend + 8;
10699 if (plt_static_chain)
10700 {
10701 r[3].r_offset = r[2].r_offset + 4;
10702 r[3].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10703 r[3].r_addend = r[0].r_addend + 16;
10704 }
c7131b65 10705 }
176a0d42
AM		 10706 }
10707 }
794e51c0
AM		 10708 if (ALWAYS_EMIT_R2SAVE
10709 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
a078d95a 10710 bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p), p += 4;
397998fc
AM		 10711 if (plt_load_toc)
10712 {
10713 bfd_put_32 (obfd, ADDIS_R11_R2 | PPC_HA (offset), p), p += 4;
10714 bfd_put_32 (obfd, LD_R12_0R11 | PPC_LO (offset), p), p += 4;
10715 }
10716 else
10717 {
10718 bfd_put_32 (obfd, ADDIS_R12_R2 | PPC_HA (offset), p), p += 4;
10719 bfd_put_32 (obfd, LD_R12_0R12 | PPC_LO (offset), p), p += 4;
10720 }
b9e5796b
AM		 10721 if (plt_load_toc
10722 && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
ac2df442 10723 {
71a39c98 10724 bfd_put_32 (obfd, ADDI_R11_R11 | PPC_LO (offset), p), p += 4;
ac2df442
AM		 10725 offset = 0;
10726 }
71a39c98 10727 bfd_put_32 (obfd, MTCTR_R12, p), p += 4;
b9e5796b 10728 if (plt_load_toc)
794e51c0 10729 {
b9e5796b
AM		 10730 if (use_fake_dep)
10731 {
10732 bfd_put_32 (obfd, XOR_R2_R12_R12, p), p += 4;
10733 bfd_put_32 (obfd, ADD_R11_R11_R2, p), p += 4;
10734 }
10735 bfd_put_32 (obfd, LD_R2_0R11 | PPC_LO (offset + 8), p), p += 4;
10736 if (plt_static_chain)
10737 bfd_put_32 (obfd, LD_R11_0R11 | PPC_LO (offset + 16), p), p += 4;
794e51c0 10738 }
ac2df442
AM		 10739 }
10740 else
10741 {
176a0d42
AM		 10742 if (r != NULL)
10743 {
794e51c0
AM		 10744 if (ALWAYS_EMIT_R2SAVE
10745 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10746 r[0].r_offset += 4;
176a0d42 10747 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
b9e5796b 10748 if (plt_load_toc)
176a0d42 10749 {
b9e5796b 10750 if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
c7131b65 10751 {
b9e5796b
AM		 10752 r[1].r_offset = r[0].r_offset + 4;
10753 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16);
10754 r[1].r_addend = r[0].r_addend;
10755 }
10756 else
10757 {
10758 r[1].r_offset = r[0].r_offset + 8 + 8 * use_fake_dep;
10759 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10760 r[1].r_addend = r[0].r_addend + 8 + 8 * plt_static_chain;
10761 if (plt_static_chain)
10762 {
10763 r[2].r_offset = r[1].r_offset + 4;
10764 r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10765 r[2].r_addend = r[0].r_addend + 8;
10766 }
c7131b65 10767 }
176a0d42
AM		 10768 }
10769 }
794e51c0
AM		 10770 if (ALWAYS_EMIT_R2SAVE
10771 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
a078d95a 10772 bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p), p += 4;
71a39c98 10773 bfd_put_32 (obfd, LD_R12_0R2 | PPC_LO (offset), p), p += 4;
b9e5796b
AM		 10774 if (plt_load_toc
10775 && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
ac2df442
AM		 10776 {
10777 bfd_put_32 (obfd, ADDI_R2_R2 | PPC_LO (offset), p), p += 4;
10778 offset = 0;
10779 }
71a39c98 10780 bfd_put_32 (obfd, MTCTR_R12, p), p += 4;
b9e5796b 10781 if (plt_load_toc)
794e51c0 10782 {
b9e5796b
AM		 10783 if (use_fake_dep)
10784 {
10785 bfd_put_32 (obfd, XOR_R11_R12_R12, p), p += 4;
10786 bfd_put_32 (obfd, ADD_R2_R2_R11, p), p += 4;
10787 }
10788 if (plt_static_chain)
10789 bfd_put_32 (obfd, LD_R11_0R2 | PPC_LO (offset + 16), p), p += 4;
10790 bfd_put_32 (obfd, LD_R2_0R2 | PPC_LO (offset + 8), p), p += 4;
794e51c0 10791 }
ac2df442 10792 }
b9e5796b 10793 if (plt_load_toc && plt_thread_safe && !use_fake_dep)
794e51c0
AM		 10794 {
10795 bfd_put_32 (obfd, CMPLDI_R2_0, p), p += 4;
10796 bfd_put_32 (obfd, BNECTR_P4, p), p += 4;
22aa0c7e 10797 bfd_put_32 (obfd, B_DOT | (cmp_branch_off & 0x3fffffc), p), p += 4;
794e51c0
AM		 10798 }
10799 else
10800 bfd_put_32 (obfd, BCTR, p), p += 4;
5d1634d7
AM		 10801 return p;
10802}
10803
a7f2871e
AM		 10804/* Build a special .plt call stub for __tls_get_addr. */
10805
10806#define LD_R11_0R3 0xe9630000
10807#define LD_R12_0R3 0xe9830000
10808#define MR_R0_R3 0x7c601b78
10809#define CMPDI_R11_0 0x2c2b0000
10810#define ADD_R3_R12_R13 0x7c6c6a14
10811#define BEQLR 0x4d820020
10812#define MR_R3_R0 0x7c030378
a7f2871e
AM		 10813#define STD_R11_0R1 0xf9610000
10814#define BCTRL 0x4e800421
10815#define LD_R11_0R1 0xe9610000
a7f2871e
AM		 10816#define MTLR_R11 0x7d6803a6
10817
10818static inline bfd_byte *
794e51c0
AM		 10819build_tls_get_addr_stub (struct ppc_link_hash_table *htab,
10820 struct ppc_stub_hash_entry *stub_entry,
10821 bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
a7f2871e 10822{
e7d1c40c 10823 bfd *obfd = htab->params->stub_bfd;
794e51c0 10824
a7f2871e
AM		 10825 bfd_put_32 (obfd, LD_R11_0R3 + 0, p), p += 4;
10826 bfd_put_32 (obfd, LD_R12_0R3 + 8, p), p += 4;
10827 bfd_put_32 (obfd, MR_R0_R3, p), p += 4;
10828 bfd_put_32 (obfd, CMPDI_R11_0, p), p += 4;
10829 bfd_put_32 (obfd, ADD_R3_R12_R13, p), p += 4;
10830 bfd_put_32 (obfd, BEQLR, p), p += 4;
10831 bfd_put_32 (obfd, MR_R3_R0, p), p += 4;
f378ab09
AM		 10832 if (r != NULL)
10833 r[0].r_offset += 7 * 4;
10834 if (!ALWAYS_EMIT_R2SAVE
10835 && stub_entry->stub_type != ppc_stub_plt_call_r2save)
10836 return build_plt_stub (htab, stub_entry, p, offset, r);
10837
a7f2871e 10838 bfd_put_32 (obfd, MFLR_R11, p), p += 4;
a078d95a 10839 bfd_put_32 (obfd, STD_R11_0R1 + STK_LINKER (htab), p), p += 4;
a7f2871e
AM		 10840
10841 if (r != NULL)
f378ab09 10842 r[0].r_offset += 2 * 4;
794e51c0 10843 p = build_plt_stub (htab, stub_entry, p, offset, r);
a7f2871e
AM		 10844 bfd_put_32 (obfd, BCTRL, p - 4);
10845
a078d95a 10846 bfd_put_32 (obfd, LD_R2_0R1 + STK_TOC (htab), p), p += 4;
bd4d2eaa 10847 bfd_put_32 (obfd, LD_R11_0R1 + STK_LINKER (htab), p), p += 4;
a7f2871e
AM		 10848 bfd_put_32 (obfd, MTLR_R11, p), p += 4;
10849 bfd_put_32 (obfd, BLR, p), p += 4;
10850
10851 return p;
10852}
10853
176a0d42
AM		 10854static Elf_Internal_Rela *
10855get_relocs (asection *sec, int count)
10856{
10857 Elf_Internal_Rela *relocs;
10858 struct bfd_elf_section_data *elfsec_data;
10859
10860 elfsec_data = elf_section_data (sec);
10861 relocs = elfsec_data->relocs;
10862 if (relocs == NULL)
10863 {
10864 bfd_size_type relsize;
10865 relsize = sec->reloc_count * sizeof (*relocs);
10866 relocs = bfd_alloc (sec->owner, relsize);
10867 if (relocs == NULL)
10868 return NULL;
10869 elfsec_data->relocs = relocs;
d4730f92
BS		 10870 elfsec_data->rela.hdr = bfd_zalloc (sec->owner,
10871 sizeof (Elf_Internal_Shdr));
10872 if (elfsec_data->rela.hdr == NULL)
10873 return NULL;
10874 elfsec_data->rela.hdr->sh_size = (sec->reloc_count
10875 * sizeof (Elf64_External_Rela));
10876 elfsec_data->rela.hdr->sh_entsize = sizeof (Elf64_External_Rela);
176a0d42
AM		 10877 sec->reloc_count = 0;
10878 }
10879 relocs += sec->reloc_count;
10880 sec->reloc_count += count;
10881 return relocs;
10882}
10883
aa374f67 10884static bfd_vma
25f53a85 10885get_r2off (struct bfd_link_info *info,
aa374f67
AM		 10886 struct ppc_stub_hash_entry *stub_entry)
10887{
25f53a85 10888 struct ppc_link_hash_table *htab = ppc_hash_table (info);
6f20ed8a 10889 bfd_vma r2off = htab->sec_info[stub_entry->target_section->id].toc_off;
aa374f67
AM		 10890
10891 if (r2off == 0)
10892 {
10893 /* Support linking -R objects. Get the toc pointer from the
10894 opd entry. */
10895 char buf[8];
b9e5796b
AM		 10896 if (!htab->opd_abi)
10897 return r2off;
aa374f67
AM		 10898 asection *opd = stub_entry->h->elf.root.u.def.section;
10899 bfd_vma opd_off = stub_entry->h->elf.root.u.def.value;
10900
10901 if (strcmp (opd->name, ".opd") != 0
10902 || opd->reloc_count != 0)
10903 {
bc30df16 10904 info->callbacks->einfo (_("%P: cannot find opd entry toc for `%T'\n"),
25f53a85 10905 stub_entry->h->elf.root.root.string);
aa374f67 10906 bfd_set_error (bfd_error_bad_value);
a7c49797 10907 return (bfd_vma) -1;
aa374f67
AM		 10908 }
10909 if (!bfd_get_section_contents (opd->owner, opd, buf, opd_off + 8, 8))
a7c49797 10910 return (bfd_vma) -1;
aa374f67 10911 r2off = bfd_get_64 (opd->owner, buf);
25f53a85 10912 r2off -= elf_gp (info->output_bfd);
aa374f67 10913 }
6f20ed8a 10914 r2off -= htab->sec_info[stub_entry->group->link_sec->id].toc_off;
aa374f67
AM		 10915 return r2off;
10916}
10917
b34976b6 10918static bfd_boolean
4ce794b7 10919ppc_build_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
5d1634d7 10920{
721956f4
AM		 10921 struct ppc_stub_hash_entry *stub_entry;
10922 struct ppc_branch_hash_entry *br_entry;
5d1634d7
AM		 10923 struct bfd_link_info *info;
10924 struct ppc_link_hash_table *htab;
721956f4
AM		 10925 bfd_byte *loc;
10926 bfd_byte *p;
ee75fd95 10927 bfd_vma dest, off;
721956f4 10928 int size;
176a0d42 10929 Elf_Internal_Rela *r;
e054468f 10930 asection *plt;
5d1634d7 10931
721956f4
AM		 10932 /* Massage our args to the form they really have. */
10933 stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
4ce794b7 10934 info = in_arg;
5d1634d7 10935
5d1634d7 10936 htab = ppc_hash_table (info);
4dfe6ac6
NC		 10937 if (htab == NULL)
10938 return FALSE;
5d1634d7 10939
721956f4 10940 /* Make a note of the offset within the stubs for this entry. */
6f20ed8a
AM		 10941 stub_entry->stub_offset = stub_entry->group->stub_sec->size;
10942 loc = stub_entry->group->stub_sec->contents + stub_entry->stub_offset;
721956f4 10943
4ce794b7 10944 htab->stub_count[stub_entry->stub_type - 1] += 1;
721956f4 10945 switch (stub_entry->stub_type)
5d1634d7 10946 {
721956f4 10947 case ppc_stub_long_branch:
ad8e1ba5 10948 case ppc_stub_long_branch_r2off:
721956f4 10949 /* Branches are relative. This is where we are going to. */
6911b7dc
AM		 10950 dest = (stub_entry->target_value
10951 + stub_entry->target_section->output_offset
10952 + stub_entry->target_section->output_section->vma);
10953 dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
10954 off = dest;
5d1634d7 10955
721956f4
AM		 10956 /* And this is where we are coming from. */
10957 off -= (stub_entry->stub_offset
6f20ed8a
AM		 10958 + stub_entry->group->stub_sec->output_offset
10959 + stub_entry->group->stub_sec->output_section->vma);
e86ce104 10960
ac2df442
AM		 10961 size = 4;
10962 if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
ad8e1ba5 10963 {
25f53a85 10964 bfd_vma r2off = get_r2off (info, stub_entry);
ad8e1ba5 10965
a7c49797 10966 if (r2off == (bfd_vma) -1)
aa374f67
AM		 10967 {
10968 htab->stub_error = TRUE;
10969 return FALSE;
10970 }
e7d1c40c 10971 bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), loc);
ad8e1ba5 10972 loc += 4;
a7c49797 10973 size = 8;
ac2df442
AM		 10974 if (PPC_HA (r2off) != 0)
10975 {
e7d1c40c
AM		 10976 bfd_put_32 (htab->params->stub_bfd,
10977 ADDIS_R2_R2 | PPC_HA (r2off), loc);
ac2df442 10978 loc += 4;
a7c49797
AM		 10979 size += 4;
10980 }
10981 if (PPC_LO (r2off) != 0)
10982 {
10983 bfd_put_32 (htab->params->stub_bfd,
10984 ADDI_R2_R2 | PPC_LO (r2off), loc);
10985 loc += 4;
10986 size += 4;
ac2df442 10987 }
ac2df442 10988 off -= size - 4;
ad8e1ba5 10989 }
e7d1c40c 10990 bfd_put_32 (htab->params->stub_bfd, B_DOT | (off & 0x3fffffc), loc);
ad8e1ba5 10991
5c3dead3
AM		 10992 if (off + (1 << 25) >= (bfd_vma) (1 << 26))
10993 {
bc30df16
AM		 10994 info->callbacks->einfo
10995 (_("%P: long branch stub `%s' offset overflow\n"),
10996 stub_entry->root.string);
5c3dead3
AM		 10997 htab->stub_error = TRUE;
10998 return FALSE;
10999 }
ee75fd95
AM		 11000
11001 if (info->emitrelocations)
11002 {
6f20ed8a 11003 r = get_relocs (stub_entry->group->stub_sec, 1);
176a0d42
AM		 11004 if (r == NULL)
11005 return FALSE;
6f20ed8a 11006 r->r_offset = loc - stub_entry->group->stub_sec->contents;
ee75fd95
AM		 11007 r->r_info = ELF64_R_INFO (0, R_PPC64_REL24);
11008 r->r_addend = dest;
11009 if (stub_entry->h != NULL)
11010 {
11011 struct elf_link_hash_entry **hashes;
11012 unsigned long symndx;
11013 struct ppc_link_hash_entry *h;
11014
e7d1c40c 11015 hashes = elf_sym_hashes (htab->params->stub_bfd);
ee75fd95
AM		 11016 if (hashes == NULL)
11017 {
11018 bfd_size_type hsize;
11019
11020 hsize = (htab->stub_globals + 1) * sizeof (*hashes);
e7d1c40c 11021 hashes = bfd_zalloc (htab->params->stub_bfd, hsize);
ee75fd95
AM		 11022 if (hashes == NULL)
11023 return FALSE;
e7d1c40c 11024 elf_sym_hashes (htab->params->stub_bfd) = hashes;
ee75fd95
AM		 11025 htab->stub_globals = 1;
11026 }
11027 symndx = htab->stub_globals++;
11028 h = stub_entry->h;
11029 hashes[symndx] = &h->elf;
11030 r->r_info = ELF64_R_INFO (symndx, R_PPC64_REL24);
11031 if (h->oh != NULL && h->oh->is_func)
b31867b6 11032 h = ppc_follow_link (h->oh);
ee75fd95
AM		 11033 if (h->elf.root.u.def.section != stub_entry->target_section)
11034 /* H is an opd symbol. The addend must be zero. */
11035 r->r_addend = 0;
11036 else
11037 {
11038 off = (h->elf.root.u.def.value
11039 + h->elf.root.u.def.section->output_offset
11040 + h->elf.root.u.def.section->output_section->vma);
11041 r->r_addend -= off;
11042 }
11043 }
11044 }
721956f4 11045 break;
e86ce104 11046
721956f4 11047 case ppc_stub_plt_branch:
ad8e1ba5 11048 case ppc_stub_plt_branch_r2off:
721956f4
AM		 11049 br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
11050 stub_entry->root.string + 9,
b34976b6 11051 FALSE, FALSE);
721956f4
AM		 11052 if (br_entry == NULL)
11053 {
8de848d8 11054 info->callbacks->einfo (_("%P: can't find branch stub `%s'\n"),
25f53a85 11055 stub_entry->root.string);
b34976b6
AM		 11056 htab->stub_error = TRUE;
11057 return FALSE;
721956f4
AM		 11058 }
11059
176a0d42
AM		 11060 dest = (stub_entry->target_value
11061 + stub_entry->target_section->output_offset
11062 + stub_entry->target_section->output_section->vma);
6911b7dc
AM		 11063 if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
11064 dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
721956f4 11065
176a0d42 11066 bfd_put_64 (htab->brlt->owner, dest,
4ce794b7 11067 htab->brlt->contents + br_entry->offset);
721956f4 11068
f94498ff 11069 if (br_entry->iter == htab->stub_iteration)
721956f4 11070 {
f94498ff 11071 br_entry->iter = 0;
84f5d08e 11072
f94498ff 11073 if (htab->relbrlt != NULL)
84f5d08e 11074 {
f94498ff
AM		 11075 /* Create a reloc for the branch lookup table entry. */
11076 Elf_Internal_Rela rela;
11077 bfd_byte *rl;
11078
11079 rela.r_offset = (br_entry->offset
11080 + htab->brlt->output_offset
11081 + htab->brlt->output_section->vma);
11082 rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
176a0d42 11083 rela.r_addend = dest;
f94498ff
AM		 11084
11085 rl = htab->relbrlt->contents;
11086 rl += (htab->relbrlt->reloc_count++
11087 * sizeof (Elf64_External_Rela));
11088 bfd_elf64_swap_reloca_out (htab->relbrlt->owner, &rela, rl);
11089 }
11090 else if (info->emitrelocations)
11091 {
176a0d42
AM		 11092 r = get_relocs (htab->brlt, 1);
11093 if (r == NULL)
11094 return FALSE;
11095 /* brlt, being SEC_LINKER_CREATED does not go through the
11096 normal reloc processing. Symbols and offsets are not
11097 translated from input file to output file form, so
11098 set up the offset per the output file. */
f94498ff
AM		 11099 r->r_offset = (br_entry->offset
11100 + htab->brlt->output_offset
11101 + htab->brlt->output_section->vma);
11102 r->r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
176a0d42 11103 r->r_addend = dest;
84f5d08e 11104 }
84f5d08e 11105 }
721956f4 11106
176a0d42
AM		 11107 dest = (br_entry->offset
11108 + htab->brlt->output_offset
11109 + htab->brlt->output_section->vma);
11110
11111 off = (dest
4ce794b7 11112 - elf_gp (htab->brlt->output_section->owner)
6f20ed8a 11113 - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
721956f4 11114
ad8e1ba5 11115 if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
5d1634d7 11116 {
25f53a85 11117 info->callbacks->einfo
bc30df16 11118 (_("%P: linkage table error against `%T'\n"),
721956f4 11119 stub_entry->root.string);
5d1634d7 11120 bfd_set_error (bfd_error_bad_value);
b34976b6
AM		 11121 htab->stub_error = TRUE;
11122 return FALSE;
5d1634d7 11123 }
41bd81ab 11124
176a0d42
AM		 11125 if (info->emitrelocations)
11126 {
6f20ed8a 11127 r = get_relocs (stub_entry->group->stub_sec, 1 + (PPC_HA (off) != 0));
176a0d42
AM		 11128 if (r == NULL)
11129 return FALSE;
6f20ed8a 11130 r[0].r_offset = loc - stub_entry->group->stub_sec->contents;
7cfbafbc
AM		 11131 if (bfd_big_endian (info->output_bfd))
11132 r[0].r_offset += 2;
00f412ee 11133 if (stub_entry->stub_type == ppc_stub_plt_branch_r2off)
176a0d42
AM		 11134 r[0].r_offset += 4;
11135 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
11136 r[0].r_addend = dest;
11137 if (PPC_HA (off) != 0)
11138 {
11139 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
11140 r[1].r_offset = r[0].r_offset + 4;
11141 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
11142 r[1].r_addend = r[0].r_addend;
11143 }
11144 }
11145
00f412ee 11146 if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
ad8e1ba5 11147 {
176a0d42 11148 if (PPC_HA (off) != 0)
ac2df442
AM		 11149 {
11150 size = 16;
e7d1c40c 11151 bfd_put_32 (htab->params->stub_bfd,
397998fc 11152 ADDIS_R12_R2 | PPC_HA (off), loc);
ac2df442 11153 loc += 4;
e7d1c40c 11154 bfd_put_32 (htab->params->stub_bfd,
397998fc 11155 LD_R12_0R12 | PPC_LO (off), loc);
ac2df442
AM		 11156 }
11157 else
11158 {
11159 size = 12;
e7d1c40c
AM		 11160 bfd_put_32 (htab->params->stub_bfd,
11161 LD_R12_0R2 | PPC_LO (off), loc);
ac2df442 11162 }
ad8e1ba5
AM		 11163 }
11164 else
11165 {
25f53a85 11166 bfd_vma r2off = get_r2off (info, stub_entry);
aa374f67 11167
a7c49797 11168 if (r2off == (bfd_vma) -1)
aa374f67
AM		 11169 {
11170 htab->stub_error = TRUE;
11171 return FALSE;
11172 }
ad8e1ba5 11173
e7d1c40c 11174 bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), loc);
ad8e1ba5 11175 loc += 4;
00f412ee 11176 size = 16;
176a0d42 11177 if (PPC_HA (off) != 0)
ac2df442
AM		 11178 {
11179 size += 4;
e7d1c40c 11180 bfd_put_32 (htab->params->stub_bfd,
397998fc 11181 ADDIS_R12_R2 | PPC_HA (off), loc);
ac2df442 11182 loc += 4;
e7d1c40c 11183 bfd_put_32 (htab->params->stub_bfd,
397998fc 11184 LD_R12_0R12 | PPC_LO (off), loc);
ac2df442
AM		 11185 }
11186 else
e7d1c40c 11187 bfd_put_32 (htab->params->stub_bfd, LD_R12_0R2 | PPC_LO (off), loc);
ac2df442
AM		 11188
11189 if (PPC_HA (r2off) != 0)
11190 {
11191 size += 4;
00f412ee 11192 loc += 4;
e7d1c40c
AM		 11193 bfd_put_32 (htab->params->stub_bfd,
11194 ADDIS_R2_R2 | PPC_HA (r2off), loc);
00f412ee
AM		 11195 }
11196 if (PPC_LO (r2off) != 0)
11197 {
11198 size += 4;
ac2df442 11199 loc += 4;
e7d1c40c
AM		 11200 bfd_put_32 (htab->params->stub_bfd,
11201 ADDI_R2_R2 | PPC_LO (r2off), loc);
ac2df442 11202 }
ad8e1ba5
AM		 11203 }
11204 loc += 4;
e7d1c40c 11205 bfd_put_32 (htab->params->stub_bfd, MTCTR_R12, loc);
ad8e1ba5 11206 loc += 4;
e7d1c40c 11207 bfd_put_32 (htab->params->stub_bfd, BCTR, loc);
721956f4 11208 break;
5d1634d7 11209
721956f4 11210 case ppc_stub_plt_call:
794e51c0 11211 case ppc_stub_plt_call_r2save:
e054468f 11212 if (stub_entry->h != NULL
b31867b6
AM		 11213 && stub_entry->h->is_func_descriptor
11214 && stub_entry->h->oh != NULL)
c862ae31 11215 {
b31867b6
AM		 11216 struct ppc_link_hash_entry *fh = ppc_follow_link (stub_entry->h->oh);
11217
11218 /* If the old-ABI "dot-symbol" is undefined make it weak so
6f20ed8a 11219 we don't get a link error from RELOC_FOR_GLOBAL_SYMBOL. */
8c5b4e52
AM		 11220 if (fh->elf.root.type == bfd_link_hash_undefined
11221 && (stub_entry->h->elf.root.type == bfd_link_hash_defined
11222 || stub_entry->h->elf.root.type == bfd_link_hash_defweak))
b31867b6 11223 fh->elf.root.type = bfd_link_hash_undefweak;
c862ae31
AM		 11224 }
11225
721956f4 11226 /* Now build the stub. */
e054468f 11227 dest = stub_entry->plt_ent->plt.offset & ~1;
176a0d42 11228 if (dest >= (bfd_vma) -2)
721956f4
AM		 11229 abort ();
11230
33e44f2e 11231 plt = htab->elf.splt;
25f23106
AM		 11232 if (!htab->elf.dynamic_sections_created
11233 || stub_entry->h == NULL
11234 || stub_entry->h->elf.dynindx == -1)
33e44f2e 11235 plt = htab->elf.iplt;
e054468f
AM		 11236
11237 dest += plt->output_offset + plt->output_section->vma;
11238
11239 if (stub_entry->h == NULL
11240 && (stub_entry->plt_ent->plt.offset & 1) == 0)
11241 {
11242 Elf_Internal_Rela rela;
11243 bfd_byte *rl;
11244
11245 rela.r_offset = dest;
ee67d69a
AM		 11246 if (htab->opd_abi)
11247 rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
11248 else
11249 rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
e054468f
AM		 11250 rela.r_addend = (stub_entry->target_value
11251 + stub_entry->target_section->output_offset
11252 + stub_entry->target_section->output_section->vma);
11253
33e44f2e
AM		 11254 rl = (htab->elf.irelplt->contents
11255 + (htab->elf.irelplt->reloc_count++
25f23106
AM		 11256 * sizeof (Elf64_External_Rela)));
11257 bfd_elf64_swap_reloca_out (info->output_bfd, &rela, rl);
e054468f 11258 stub_entry->plt_ent->plt.offset |= 1;
82e66161 11259 htab->local_ifunc_resolver = 1;
e054468f 11260 }
176a0d42
AM		 11261
11262 off = (dest
e054468f 11263 - elf_gp (plt->output_section->owner)
6f20ed8a 11264 - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
721956f4 11265
ad8e1ba5 11266 if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
721956f4 11267 {
25f53a85 11268 info->callbacks->einfo
695344c0 11269 /* xgettext:c-format */
bc30df16 11270 (_("%P: linkage table error against `%T'\n"),
e054468f
AM		 11271 stub_entry->h != NULL
11272 ? stub_entry->h->elf.root.root.string
11273 : "<local sym>");
721956f4 11274 bfd_set_error (bfd_error_bad_value);
b34976b6
AM		 11275 htab->stub_error = TRUE;
11276 return FALSE;
721956f4
AM		 11277 }
11278
e7d1c40c 11279 if (htab->params->plt_stub_align != 0)
794e51c0
AM		 11280 {
11281 unsigned pad = plt_stub_pad (htab, stub_entry, off);
11282
6f20ed8a
AM		 11283 stub_entry->group->stub_sec->size += pad;
11284 stub_entry->stub_offset = stub_entry->group->stub_sec->size;
794e51c0
AM		 11285 loc += pad;
11286 }
11287
176a0d42
AM		 11288 r = NULL;
11289 if (info->emitrelocations)
11290 {
6f20ed8a 11291 r = get_relocs (stub_entry->group->stub_sec,
3ba720c7
AM		 11292 ((PPC_HA (off) != 0)
11293 + (htab->opd_abi
e7d1c40c 11294 ? 2 + (htab->params->plt_static_chain
3ba720c7
AM		 11295 && PPC_HA (off + 16) == PPC_HA (off))
11296 : 1)));
176a0d42
AM		 11297 if (r == NULL)
11298 return FALSE;
6f20ed8a 11299 r[0].r_offset = loc - stub_entry->group->stub_sec->contents;
7cfbafbc
AM		 11300 if (bfd_big_endian (info->output_bfd))
11301 r[0].r_offset += 2;
176a0d42
AM		 11302 r[0].r_addend = dest;
11303 }
a7f2871e
AM		 11304 if (stub_entry->h != NULL
11305 && (stub_entry->h == htab->tls_get_addr_fd
11306 || stub_entry->h == htab->tls_get_addr)
7c9cf415 11307 && htab->params->tls_get_addr_opt)
794e51c0 11308 p = build_tls_get_addr_stub (htab, stub_entry, loc, off, r);
a7f2871e 11309 else
794e51c0 11310 p = build_plt_stub (htab, stub_entry, loc, off, r);
721956f4
AM		 11311 size = p - loc;
11312 break;
11313
a4b6fadd
AM		 11314 case ppc_stub_save_res:
11315 return TRUE;
11316
721956f4
AM		 11317 default:
11318 BFD_FAIL ();
b34976b6 11319 return FALSE;
721956f4
AM		 11320 }
11321
6f20ed8a 11322 stub_entry->group->stub_sec->size += size;
97b639ba 11323
e7d1c40c 11324 if (htab->params->emit_stub_syms)
97b639ba
AM		 11325 {
11326 struct elf_link_hash_entry *h;
ee75fd95
AM		 11327 size_t len1, len2;
11328 char *name;
11329 const char *const stub_str[] = { "long_branch",
11330 "long_branch_r2off",
11331 "plt_branch",
11332 "plt_branch_r2off",
794e51c0 11333 "plt_call",
ee75fd95
AM		 11334 "plt_call" };
11335
11336 len1 = strlen (stub_str[stub_entry->stub_type - 1]);
11337 len2 = strlen (stub_entry->root.string);
11338 name = bfd_malloc (len1 + len2 + 2);
11339 if (name == NULL)
11340 return FALSE;
11341 memcpy (name, stub_entry->root.string, 9);
11342 memcpy (name + 9, stub_str[stub_entry->stub_type - 1], len1);
11343 memcpy (name + len1 + 9, stub_entry->root.string + 8, len2 - 8 + 1);
11344 h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
97b639ba
AM		 11345 if (h == NULL)
11346 return FALSE;
11347 if (h->root.type == bfd_link_hash_new)
11348 {
11349 h->root.type = bfd_link_hash_defined;
6f20ed8a 11350 h->root.u.def.section = stub_entry->group->stub_sec;
97b639ba 11351 h->root.u.def.value = stub_entry->stub_offset;
f5385ebf
AM		 11352 h->ref_regular = 1;
11353 h->def_regular = 1;
11354 h->ref_regular_nonweak = 1;
11355 h->forced_local = 1;
11356 h->non_elf = 0;
2ec55de3 11357 h->root.linker_def = 1;
97b639ba
AM		 11358 }
11359 }
11360
b34976b6 11361 return TRUE;
721956f4
AM		 11362}
11363
11364/* As above, but don't actually build the stub. Just bump offset so
11365 we know stub section sizes, and select plt_branch stubs where
11366 long_branch stubs won't do. */
11367
b34976b6 11368static bfd_boolean
4ce794b7 11369ppc_size_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
721956f4
AM		 11370{
11371 struct ppc_stub_hash_entry *stub_entry;
63bc6f6c 11372 struct bfd_link_info *info;
721956f4
AM		 11373 struct ppc_link_hash_table *htab;
11374 bfd_vma off;
11375 int size;
11376
11377 /* Massage our args to the form they really have. */
11378 stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
63bc6f6c
AM		 11379 info = in_arg;
11380
11381 htab = ppc_hash_table (info);
4dfe6ac6
NC		 11382 if (htab == NULL)
11383 return FALSE;
721956f4 11384
a4b6fadd
AM		 11385 if (stub_entry->h != NULL
11386 && stub_entry->h->save_res
11387 && stub_entry->h->elf.root.type == bfd_link_hash_defined
11388 && stub_entry->h->elf.root.u.def.section == htab->sfpr)
11389 {
11390 /* Don't make stubs to out-of-line register save/restore
11391 functions. Instead, emit copies of the functions. */
11392 stub_entry->group->needs_save_res = 1;
11393 stub_entry->stub_type = ppc_stub_save_res;
11394 return TRUE;
11395 }
11396
794e51c0
AM		 11397 if (stub_entry->stub_type == ppc_stub_plt_call
11398 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
721956f4 11399 {
e054468f
AM		 11400 asection *plt;
11401 off = stub_entry->plt_ent->plt.offset & ~(bfd_vma) 1;
58ac9f71 11402 if (off >= (bfd_vma) -2)
411e1bfb 11403 abort ();
33e44f2e 11404 plt = htab->elf.splt;
25f23106
AM		 11405 if (!htab->elf.dynamic_sections_created
11406 || stub_entry->h == NULL
11407 || stub_entry->h->elf.dynindx == -1)
33e44f2e 11408 plt = htab->elf.iplt;
e054468f
AM		 11409 off += (plt->output_offset
11410 + plt->output_section->vma
11411 - elf_gp (plt->output_section->owner)
6f20ed8a 11412 - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
721956f4 11413
794e51c0 11414 size = plt_stub_size (htab, stub_entry, off);
d4aaa2a0
AM		 11415 if (stub_entry->h != NULL
11416 && (stub_entry->h == htab->tls_get_addr_fd
11417 || stub_entry->h == htab->tls_get_addr)
11418 && htab->params->tls_get_addr_opt
11419 && (ALWAYS_EMIT_R2SAVE
11420 || stub_entry->stub_type == ppc_stub_plt_call_r2save))
11421 stub_entry->group->tls_get_addr_opt_bctrl
11422 = stub_entry->group->stub_sec->size + size - 5 * 4;
11423
e7d1c40c 11424 if (htab->params->plt_stub_align)
794e51c0 11425 size += plt_stub_pad (htab, stub_entry, off);
176a0d42
AM		 11426 if (info->emitrelocations)
11427 {
6f20ed8a 11428 stub_entry->group->stub_sec->reloc_count
b9e5796b
AM		 11429 += ((PPC_HA (off) != 0)
11430 + (htab->opd_abi
e7d1c40c 11431 ? 2 + (htab->params->plt_static_chain
b9e5796b
AM		 11432 && PPC_HA (off + 16) == PPC_HA (off))
11433 : 1));
6f20ed8a 11434 stub_entry->group->stub_sec->flags |= SEC_RELOC;
176a0d42 11435 }
721956f4
AM		 11436 }
11437 else
11438 {
ad8e1ba5
AM		 11439 /* ppc_stub_long_branch or ppc_stub_plt_branch, or their r2off
11440 variants. */
ac2df442 11441 bfd_vma r2off = 0;
6911b7dc 11442 bfd_vma local_off = 0;
ac2df442 11443
721956f4
AM		 11444 off = (stub_entry->target_value
11445 + stub_entry->target_section->output_offset
11446 + stub_entry->target_section->output_section->vma);
6f20ed8a
AM		 11447 off -= (stub_entry->group->stub_sec->size
11448 + stub_entry->group->stub_sec->output_offset
11449 + stub_entry->group->stub_sec->output_section->vma);
721956f4 11450
ad8e1ba5
AM		 11451 /* Reset the stub type from the plt variant in case we now
11452 can reach with a shorter stub. */
11453 if (stub_entry->stub_type >= ppc_stub_plt_branch)
11454 stub_entry->stub_type += ppc_stub_long_branch - ppc_stub_plt_branch;
11455
11456 size = 4;
11457 if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
11458 {
25f53a85 11459 r2off = get_r2off (info, stub_entry);
a7c49797 11460 if (r2off == (bfd_vma) -1)
aa374f67
AM		 11461 {
11462 htab->stub_error = TRUE;
11463 return FALSE;
11464 }
a7c49797 11465 size = 8;
ac2df442 11466 if (PPC_HA (r2off) != 0)
a7c49797
AM		 11467 size += 4;
11468 if (PPC_LO (r2off) != 0)
11469 size += 4;
ac2df442 11470 off -= size - 4;
ad8e1ba5
AM		 11471 }
11472
6911b7dc
AM		 11473 local_off = PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
11474
b9e5796b
AM		 11475 /* If the branch offset if too big, use a ppc_stub_plt_branch.
11476 Do the same for -R objects without function descriptors. */
11477 if (off + (1 << 25) >= (bfd_vma) (1 << 26) - local_off
11478 || (stub_entry->stub_type == ppc_stub_long_branch_r2off
a7c49797
AM		 11479 && r2off == 0
11480 && htab->sec_info[stub_entry->target_section->id].toc_off == 0))
721956f4
AM		 11481 {
11482 struct ppc_branch_hash_entry *br_entry;
11483
11484 br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
11485 stub_entry->root.string + 9,
b34976b6 11486 TRUE, FALSE);
721956f4
AM		 11487 if (br_entry == NULL)
11488 {
8de848d8 11489 info->callbacks->einfo (_("%P: can't build branch stub `%s'\n"),
25f53a85 11490 stub_entry->root.string);
b34976b6
AM		 11491 htab->stub_error = TRUE;
11492 return FALSE;
721956f4
AM		 11493 }
11494
11495 if (br_entry->iter != htab->stub_iteration)
11496 {
11497 br_entry->iter = htab->stub_iteration;
eea6121a
AM		 11498 br_entry->offset = htab->brlt->size;
11499 htab->brlt->size += 8;
63bc6f6c 11500
ee75fd95 11501 if (htab->relbrlt != NULL)
eea6121a 11502 htab->relbrlt->size += sizeof (Elf64_External_Rela);
84f5d08e
AM		 11503 else if (info->emitrelocations)
11504 {
11505 htab->brlt->reloc_count += 1;
11506 htab->brlt->flags |= SEC_RELOC;
11507 }
721956f4 11508 }
ad8e1ba5
AM		 11509
11510 stub_entry->stub_type += ppc_stub_plt_branch - ppc_stub_long_branch;
ac2df442
AM		 11511 off = (br_entry->offset
11512 + htab->brlt->output_offset
11513 + htab->brlt->output_section->vma
11514 - elf_gp (htab->brlt->output_section->owner)
6f20ed8a 11515 - htab->sec_info[stub_entry->group->link_sec->id].toc_off);
ac2df442 11516
176a0d42
AM		 11517 if (info->emitrelocations)
11518 {
6f20ed8a
AM		 11519 stub_entry->group->stub_sec->reloc_count
11520 += 1 + (PPC_HA (off) != 0);
11521 stub_entry->group->stub_sec->flags |= SEC_RELOC;
176a0d42
AM		 11522 }
11523
00f412ee 11524 if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
ac2df442
AM		 11525 {
11526 size = 12;
176a0d42 11527 if (PPC_HA (off) != 0)
ac2df442
AM		 11528 size = 16;
11529 }
11530 else
11531 {
00f412ee 11532 size = 16;
176a0d42 11533 if (PPC_HA (off) != 0)
ac2df442
AM		 11534 size += 4;
11535
11536 if (PPC_HA (r2off) != 0)
11537 size += 4;
00f412ee
AM		 11538 if (PPC_LO (r2off) != 0)
11539 size += 4;
ac2df442 11540 }
721956f4 11541 }
84f5d08e
AM		 11542 else if (info->emitrelocations)
11543 {
6f20ed8a
AM		 11544 stub_entry->group->stub_sec->reloc_count += 1;
11545 stub_entry->group->stub_sec->flags |= SEC_RELOC;
84f5d08e 11546 }
721956f4
AM		 11547 }
11548
6f20ed8a 11549 stub_entry->group->stub_sec->size += size;
b34976b6 11550 return TRUE;
721956f4
AM		 11551}
11552
11553/* Set up various things so that we can make a list of input sections
11554 for each output section included in the link. Returns -1 on error,
cedb70c5 11555 0 when no stubs will be needed, and 1 on success. */
721956f4
AM		 11556
11557int
e7d1c40c 11558ppc64_elf_setup_section_lists (struct bfd_link_info *info)
721956f4 11559{
6f20ed8a 11560 unsigned int id;
721956f4
AM		 11561 bfd_size_type amt;
11562 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11563
4dfe6ac6
NC		 11564 if (htab == NULL)
11565 return -1;
4c52953f 11566
6f20ed8a
AM		 11567 htab->sec_info_arr_size = bfd_get_next_section_id ();
11568 amt = sizeof (*htab->sec_info) * (htab->sec_info_arr_size);
11569 htab->sec_info = bfd_zmalloc (amt);
11570 if (htab->sec_info == NULL)
721956f4
AM		 11571 return -1;
11572
3d6f9012
AM		 11573 /* Set toc_off for com, und, abs and ind sections. */
11574 for (id = 0; id < 3; id++)
6f20ed8a 11575 htab->sec_info[id].toc_off = TOC_BASE_OFF;
734b6cf9 11576
721956f4
AM		 11577 return 1;
11578}
11579
927be08e
AM		 11580/* Set up for first pass at multitoc partitioning. */
11581
11582void
11583ppc64_elf_start_multitoc_partition (struct bfd_link_info *info)
11584{
11585 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11586
1c865ab2 11587 htab->toc_curr = ppc64_elf_set_toc (info, info->output_bfd);
927be08e
AM		 11588 htab->toc_bfd = NULL;
11589 htab->toc_first_sec = NULL;
11590}
11591
e717da7e
AM		 11592/* The linker repeatedly calls this function for each TOC input section
11593 and linker generated GOT section. Group input bfds such that the toc
927be08e 11594 within a group is less than 64k in size. */
ad8e1ba5 11595
927be08e 11596bfd_boolean
4ce794b7 11597ppc64_elf_next_toc_section (struct bfd_link_info *info, asection *isec)
ad8e1ba5
AM		 11598{
11599 struct ppc_link_hash_table *htab = ppc_hash_table (info);
d77c8a4b 11600 bfd_vma addr, off, limit;
ad8e1ba5 11601
4dfe6ac6
NC		 11602 if (htab == NULL)
11603 return FALSE;
11604
927be08e 11605 if (!htab->second_toc_pass)
4c52953f 11606 {
927be08e 11607 /* Keep track of the first .toc or .got section for this input bfd. */
a4fd3de5
AM		 11608 bfd_boolean new_bfd = htab->toc_bfd != isec->owner;
11609
11610 if (new_bfd)
bf102f86
AM		 11611 {
11612 htab->toc_bfd = isec->owner;
11613 htab->toc_first_sec = isec;
11614 }
927be08e 11615
bf102f86
AM		 11616 addr = isec->output_offset + isec->output_section->vma;
11617 off = addr - htab->toc_curr;
d77c8a4b
AM		 11618 limit = 0x80008000;
11619 if (ppc64_elf_tdata (isec->owner)->has_small_toc_reloc)
11620 limit = 0x10000;
11621 if (off + isec->size > limit)
bf102f86
AM		 11622 {
11623 addr = (htab->toc_first_sec->output_offset
11624 + htab->toc_first_sec->output_section->vma);
11625 htab->toc_curr = addr;
a27e685f 11626 htab->toc_curr &= -TOC_BASE_ALIGN;
bf102f86 11627 }
99877b66 11628
927be08e
AM		 11629 /* toc_curr is the base address of this toc group. Set elf_gp
11630 for the input section to be the offset relative to the
11631 output toc base plus 0x8000. Making the input elf_gp an
11632 offset allows us to move the toc as a whole without
11633 recalculating input elf_gp. */
11634 off = htab->toc_curr - elf_gp (isec->output_section->owner);
11635 off += TOC_BASE_OFF;
11636
11637 /* Die if someone uses a linker script that doesn't keep input
11638 file .toc and .got together. */
a4fd3de5
AM		 11639 if (new_bfd
11640 && elf_gp (isec->owner) != 0
927be08e
AM		 11641 && elf_gp (isec->owner) != off)
11642 return FALSE;
11643
11644 elf_gp (isec->owner) = off;
11645 return TRUE;
4c52953f 11646 }
927be08e
AM		 11647
11648 /* During the second pass toc_first_sec points to the start of
11649 a toc group, and toc_curr is used to track the old elf_gp.
11650 We use toc_bfd to ensure we only look at each bfd once. */
11651 if (htab->toc_bfd == isec->owner)
11652 return TRUE;
11653 htab->toc_bfd = isec->owner;
11654
11655 if (htab->toc_first_sec == NULL
11656 || htab->toc_curr != elf_gp (isec->owner))
11657 {
11658 htab->toc_curr = elf_gp (isec->owner);
11659 htab->toc_first_sec = isec;
11660 }
11661 addr = (htab->toc_first_sec->output_offset
11662 + htab->toc_first_sec->output_section->vma);
11663 off = addr - elf_gp (isec->output_section->owner) + TOC_BASE_OFF;
11664 elf_gp (isec->owner) = off;
11665
11666 return TRUE;
ad8e1ba5
AM		 11667}
11668
927be08e
AM		 11669/* Called via elf_link_hash_traverse to merge GOT entries for global
11670 symbol H. */
11671
11672static bfd_boolean
11673merge_global_got (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
11674{
11675 if (h->root.type == bfd_link_hash_indirect)
11676 return TRUE;
11677
927be08e
AM		 11678 merge_got_entries (&h->got.glist);
11679
11680 return TRUE;
11681}
11682
11683/* Called via elf_link_hash_traverse to allocate GOT entries for global
11684 symbol H. */
11685
11686static bfd_boolean
11687reallocate_got (struct elf_link_hash_entry *h, void *inf)
11688{
11689 struct got_entry *gent;
11690
11691 if (h->root.type == bfd_link_hash_indirect)
11692 return TRUE;
11693
927be08e
AM		 11694 for (gent = h->got.glist; gent != NULL; gent = gent->next)
11695 if (!gent->is_indirect)
11696 allocate_got (h, (struct bfd_link_info *) inf, gent);
11697 return TRUE;
11698}
11699
11700/* Called on the first multitoc pass after the last call to
11701 ppc64_elf_next_toc_section. This function removes duplicate GOT
11702 entries. */
11703
11704bfd_boolean
11705ppc64_elf_layout_multitoc (struct bfd_link_info *info)
ad8e1ba5
AM		 11706{
11707 struct ppc_link_hash_table *htab = ppc_hash_table (info);
927be08e
AM		 11708 struct bfd *ibfd, *ibfd2;
11709 bfd_boolean done_something;
11710
11711 htab->multi_toc_needed = htab->toc_curr != elf_gp (info->output_bfd);
ad8e1ba5 11712
7865406b
AM		 11713 if (!htab->do_multi_toc)
11714 return FALSE;
11715
d0fae19d 11716 /* Merge global sym got entries within a toc group. */
927be08e
AM		 11717 elf_link_hash_traverse (&htab->elf, merge_global_got, info);
11718
11719 /* And tlsld_got. */
c72f2fb2 11720 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
927be08e
AM		 11721 {
11722 struct got_entry *ent, *ent2;
11723
11724 if (!is_ppc64_elf (ibfd))
11725 continue;
11726
11727 ent = ppc64_tlsld_got (ibfd);
11728 if (!ent->is_indirect
11729 && ent->got.offset != (bfd_vma) -1)
11730 {
c72f2fb2 11731 for (ibfd2 = ibfd->link.next; ibfd2 != NULL; ibfd2 = ibfd2->link.next)
927be08e
AM		 11732 {
11733 if (!is_ppc64_elf (ibfd2))
11734 continue;
11735
11736 ent2 = ppc64_tlsld_got (ibfd2);
11737 if (!ent2->is_indirect
11738 && ent2->got.offset != (bfd_vma) -1
11739 && elf_gp (ibfd2) == elf_gp (ibfd))
11740 {
11741 ent2->is_indirect = TRUE;
11742 ent2->got.ent = ent;
11743 }
11744 }
11745 }
11746 }
11747
11748 /* Zap sizes of got sections. */
33e44f2e
AM		 11749 htab->elf.irelplt->rawsize = htab->elf.irelplt->size;
11750 htab->elf.irelplt->size -= htab->got_reli_size;
927be08e
AM		 11751 htab->got_reli_size = 0;
11752
c72f2fb2 11753 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
927be08e
AM		 11754 {
11755 asection *got, *relgot;
11756
11757 if (!is_ppc64_elf (ibfd))
11758 continue;
11759
11760 got = ppc64_elf_tdata (ibfd)->got;
11761 if (got != NULL)
11762 {
11763 got->rawsize = got->size;
11764 got->size = 0;
11765 relgot = ppc64_elf_tdata (ibfd)->relgot;
11766 relgot->rawsize = relgot->size;
11767 relgot->size = 0;
11768 }
11769 }
11770
11771 /* Now reallocate the got, local syms first. We don't need to
11772 allocate section contents again since we never increase size. */
c72f2fb2 11773 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
927be08e
AM		 11774 {
11775 struct got_entry **lgot_ents;
11776 struct got_entry **end_lgot_ents;
11777 struct plt_entry **local_plt;
11778 struct plt_entry **end_local_plt;
f961d9dd 11779 unsigned char *lgot_masks;
927be08e
AM		 11780 bfd_size_type locsymcount;
11781 Elf_Internal_Shdr *symtab_hdr;
19e08130 11782 asection *s;
927be08e
AM		 11783
11784 if (!is_ppc64_elf (ibfd))
11785 continue;
11786
11787 lgot_ents = elf_local_got_ents (ibfd);
11788 if (!lgot_ents)
11789 continue;
11790
11791 symtab_hdr = &elf_symtab_hdr (ibfd);
11792 locsymcount = symtab_hdr->sh_info;
11793 end_lgot_ents = lgot_ents + locsymcount;
11794 local_plt = (struct plt_entry **) end_lgot_ents;
11795 end_local_plt = local_plt + locsymcount;
f961d9dd 11796 lgot_masks = (unsigned char *) end_local_plt;
927be08e 11797 s = ppc64_elf_tdata (ibfd)->got;
927be08e
AM		 11798 for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
11799 {
11800 struct got_entry *ent;
11801
11802 for (ent = *lgot_ents; ent != NULL; ent = ent->next)
d0fae19d 11803 {
19e08130
AM		 11804 unsigned int ent_size = 8;
11805 unsigned int rel_size = sizeof (Elf64_External_Rela);
11806
d0fae19d
AM		 11807 ent->got.offset = s->size;
11808 if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
d0fae19d 11809 {
19e08130
AM		 11810 ent_size *= 2;
11811 rel_size *= 2;
11812 }
11813 s->size += ent_size;
11814 if ((*lgot_masks & PLT_IFUNC) != 0)
11815 {
33e44f2e 11816 htab->elf.irelplt->size += rel_size;
19e08130
AM		 11817 htab->got_reli_size += rel_size;
11818 }
0e1862bb 11819 else if (bfd_link_pic (info))
19e08130
AM		 11820 {
11821 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
11822 srel->size += rel_size;
d0fae19d
AM		 11823 }
11824 }
927be08e
AM		 11825 }
11826 }
11827
11828 elf_link_hash_traverse (&htab->elf, reallocate_got, info);
11829
c72f2fb2 11830 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
927be08e
AM		 11831 {
11832 struct got_entry *ent;
11833
11834 if (!is_ppc64_elf (ibfd))
11835 continue;
11836
11837 ent = ppc64_tlsld_got (ibfd);
11838 if (!ent->is_indirect
11839 && ent->got.offset != (bfd_vma) -1)
11840 {
11841 asection *s = ppc64_elf_tdata (ibfd)->got;
11842 ent->got.offset = s->size;
11843 s->size += 16;
0e1862bb 11844 if (bfd_link_pic (info))
927be08e
AM		 11845 {
11846 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
11847 srel->size += sizeof (Elf64_External_Rela);
11848 }
11849 }
11850 }
11851
33e44f2e 11852 done_something = htab->elf.irelplt->rawsize != htab->elf.irelplt->size;
927be08e 11853 if (!done_something)
c72f2fb2 11854 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
927be08e
AM		 11855 {
11856 asection *got;
11857
11858 if (!is_ppc64_elf (ibfd))
11859 continue;
11860
11861 got = ppc64_elf_tdata (ibfd)->got;
11862 if (got != NULL)
11863 {
11864 done_something = got->rawsize != got->size;
11865 if (done_something)
11866 break;
11867 }
11868 }
11869
11870 if (done_something)
e7d1c40c 11871 (*htab->params->layout_sections_again) ();
927be08e
AM		 11872
11873 /* Set up for second pass over toc sections to recalculate elf_gp
11874 on input sections. */
11875 htab->toc_bfd = NULL;
11876 htab->toc_first_sec = NULL;
11877 htab->second_toc_pass = TRUE;
11878 return done_something;
11879}
11880
11881/* Called after second pass of multitoc partitioning. */
11882
11883void
11884ppc64_elf_finish_multitoc_partition (struct bfd_link_info *info)
11885{
11886 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11887
11888 /* After the second pass, toc_curr tracks the TOC offset used
11889 for code sections below in ppc64_elf_next_input_section. */
3d6f9012 11890 htab->toc_curr = TOC_BASE_OFF;
ad8e1ba5
AM		 11891}
11892
9b5ecbd0
AM		 11893/* No toc references were found in ISEC. If the code in ISEC makes no
11894 calls, then there's no need to use toc adjusting stubs when branching
11895 into ISEC. Actually, indirect calls from ISEC are OK as they will
4c52953f
AM		 11896 load r2. Returns -1 on error, 0 for no stub needed, 1 for stub
11897 needed, and 2 if a cyclical call-graph was found but no other reason
11898 for a stub was detected. If called from the top level, a return of
11899 2 means the same as a return of 0. */
9b5ecbd0
AM		 11900
11901static int
4ce794b7 11902toc_adjusting_stub_needed (struct bfd_link_info *info, asection *isec)
9b5ecbd0 11903{
9b5ecbd0 11904 int ret;
70cc837d
AM		 11905
11906 /* Mark this section as checked. */
11907 isec->call_check_done = 1;
9b5ecbd0 11908
772119ce
AM		 11909 /* We know none of our code bearing sections will need toc stubs. */
11910 if ((isec->flags & SEC_LINKER_CREATED) != 0)
11911 return 0;
11912
eea6121a 11913 if (isec->size == 0)
082c50f8
AM		 11914 return 0;
11915
4c52953f
AM		 11916 if (isec->output_section == NULL)
11917 return 0;
11918
4c52953f 11919 ret = 0;
70cc837d 11920 if (isec->reloc_count != 0)
9b5ecbd0 11921 {
70cc837d
AM		 11922 Elf_Internal_Rela *relstart, *rel;
11923 Elf_Internal_Sym *local_syms;
11924 struct ppc_link_hash_table *htab;
2917689a 11925
70cc837d
AM		 11926 relstart = _bfd_elf_link_read_relocs (isec->owner, isec, NULL, NULL,
11927 info->keep_memory);
11928 if (relstart == NULL)
11929 return -1;
90aecf7a 11930
70cc837d
AM		 11931 /* Look for branches to outside of this section. */
11932 local_syms = NULL;
11933 htab = ppc_hash_table (info);
11934 if (htab == NULL)
11935 return -1;
4c52953f 11936
70cc837d 11937 for (rel = relstart; rel < relstart + isec->reloc_count; ++rel)
4c52953f 11938 {
70cc837d
AM		 11939 enum elf_ppc64_reloc_type r_type;
11940 unsigned long r_symndx;
11941 struct elf_link_hash_entry *h;
11942 struct ppc_link_hash_entry *eh;
11943 Elf_Internal_Sym *sym;
11944 asection *sym_sec;
11945 struct _opd_sec_data *opd;
11946 bfd_vma sym_value;
11947 bfd_vma dest;
11948
11949 r_type = ELF64_R_TYPE (rel->r_info);
11950 if (r_type != R_PPC64_REL24
11951 && r_type != R_PPC64_REL14
11952 && r_type != R_PPC64_REL14_BRTAKEN
11953 && r_type != R_PPC64_REL14_BRNTAKEN)
11954 continue;
4c52953f 11955
70cc837d
AM		 11956 r_symndx = ELF64_R_SYM (rel->r_info);
11957 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms, r_symndx,
11958 isec->owner))
4c52953f 11959 {
70cc837d
AM		 11960 ret = -1;
11961 break;
11962 }
4c52953f 11963
70cc837d
AM		 11964 /* Calls to dynamic lib functions go through a plt call stub
11965 that uses r2. */
11966 eh = (struct ppc_link_hash_entry *) h;
11967 if (eh != NULL
11968 && (eh->elf.plt.plist != NULL
11969 || (eh->oh != NULL
11970 && ppc_follow_link (eh->oh)->elf.plt.plist != NULL)))
11971 {
11972 ret = 1;
11973 break;
4c52953f
AM		 11974 }
11975
70cc837d
AM		 11976 if (sym_sec == NULL)
11977 /* Ignore other undefined symbols. */
4c52953f 11978 continue;
4c52953f 11979
70cc837d
AM		 11980 /* Assume branches to other sections not included in the
11981 link need stubs too, to cover -R and absolute syms. */
11982 if (sym_sec->output_section == NULL)
11983 {
11984 ret = 1;
11985 break;
11986 }
4c52953f 11987
70cc837d
AM		 11988 if (h == NULL)
11989 sym_value = sym->st_value;
11990 else
11991 {
11992 if (h->root.type != bfd_link_hash_defined
11993 && h->root.type != bfd_link_hash_defweak)
11994 abort ();
11995 sym_value = h->root.u.def.value;
11996 }
11997 sym_value += rel->r_addend;
4c52953f 11998
70cc837d
AM		 11999 /* If this branch reloc uses an opd sym, find the code section. */
12000 opd = get_opd_info (sym_sec);
12001 if (opd != NULL)
12002 {
12003 if (h == NULL && opd->adjust != NULL)
12004 {
12005 long adjust;
4c52953f 12006
92a9c616 12007 adjust = opd->adjust[OPD_NDX (sym_value)];
70cc837d
AM		 12008 if (adjust == -1)
12009 /* Assume deleted functions won't ever be called. */
12010 continue;
12011 sym_value += adjust;
12012 }
4c52953f 12013
aef36ac1
AM		 12014 dest = opd_entry_value (sym_sec, sym_value,
12015 &sym_sec, NULL, FALSE);
70cc837d
AM		 12016 if (dest == (bfd_vma) -1)
12017 continue;
12018 }
12019 else
12020 dest = (sym_value
12021 + sym_sec->output_offset
12022 + sym_sec->output_section->vma);
4c52953f 12023
70cc837d
AM		 12024 /* Ignore branch to self. */
12025 if (sym_sec == isec)
12026 continue;
4c52953f 12027
70cc837d
AM		 12028 /* If the called function uses the toc, we need a stub. */
12029 if (sym_sec->has_toc_reloc
12030 || sym_sec->makes_toc_func_call)
4c52953f 12031 {
70cc837d 12032 ret = 1;
4c52953f
AM		 12033 break;
12034 }
70cc837d
AM		 12035
12036 /* Assume any branch that needs a long branch stub might in fact
12037 need a plt_branch stub. A plt_branch stub uses r2. */
12038 else if (dest - (isec->output_offset
12039 + isec->output_section->vma
6911b7dc
AM		 12040 + rel->r_offset) + (1 << 25)
12041 >= (2u << 25) - PPC64_LOCAL_ENTRY_OFFSET (h
12042 ? h->other
12043 : sym->st_other))
4c52953f 12044 {
70cc837d
AM		 12045 ret = 1;
12046 break;
12047 }
12048
12049 /* If calling back to a section in the process of being
12050 tested, we can't say for sure that no toc adjusting stubs
12051 are needed, so don't return zero. */
12052 else if (sym_sec->call_check_in_progress)
12053 ret = 2;
12054
12055 /* Branches to another section that itself doesn't have any TOC
12056 references are OK. Recursively call ourselves to check. */
12057 else if (!sym_sec->call_check_done)
12058 {
12059 int recur;
12060
12061 /* Mark current section as indeterminate, so that other
12062 sections that call back to current won't be marked as
12063 known. */
12064 isec->call_check_in_progress = 1;
12065 recur = toc_adjusting_stub_needed (info, sym_sec);
12066 isec->call_check_in_progress = 0;
12067
4c52953f
AM		 12068 if (recur != 0)
12069 {
70cc837d
AM		 12070 ret = recur;
12071 if (recur != 2)
12072 break;
4c52953f
AM		 12073 }
12074 }
4c52953f 12075 }
70cc837d
AM		 12076
12077 if (local_syms != NULL
12078 && (elf_symtab_hdr (isec->owner).contents
12079 != (unsigned char *) local_syms))
12080 free (local_syms);
12081 if (elf_section_data (isec)->relocs != relstart)
12082 free (relstart);
9b5ecbd0
AM		 12083 }
12084
70cc837d
AM		 12085 if ((ret & 1) == 0
12086 && isec->map_head.s != NULL
12087 && (strcmp (isec->output_section->name, ".init") == 0
12088 || strcmp (isec->output_section->name, ".fini") == 0))
12089 {
12090 if (isec->map_head.s->has_toc_reloc
12091 || isec->map_head.s->makes_toc_func_call)
12092 ret = 1;
12093 else if (!isec->map_head.s->call_check_done)
12094 {
12095 int recur;
12096 isec->call_check_in_progress = 1;
12097 recur = toc_adjusting_stub_needed (info, isec->map_head.s);
12098 isec->call_check_in_progress = 0;
12099 if (recur != 0)
12100 ret = recur;
12101 }
12102 }
12103
12104 if (ret == 1)
12105 isec->makes_toc_func_call = 1;
4c52953f 12106
9b5ecbd0
AM		 12107 return ret;
12108}
12109
721956f4
AM		 12110/* The linker repeatedly calls this function for each input section,
12111 in the order that input sections are linked into output sections.
12112 Build lists of input sections to determine groupings between which
12113 we may insert linker stubs. */
12114
9b5ecbd0 12115bfd_boolean
4ce794b7 12116ppc64_elf_next_input_section (struct bfd_link_info *info, asection *isec)
721956f4
AM		 12117{
12118 struct ppc_link_hash_table *htab = ppc_hash_table (info);
12119
4dfe6ac6
NC		 12120 if (htab == NULL)
12121 return FALSE;
12122
734b6cf9 12123 if ((isec->output_section->flags & SEC_CODE) != 0
6f20ed8a 12124 && isec->output_section->id < htab->sec_info_arr_size)
721956f4 12125 {
3d6f9012
AM		 12126 /* This happens to make the list in reverse order,
12127 which is what we want. */
6f20ed8a
AM		 12128 htab->sec_info[isec->id].u.list
12129 = htab->sec_info[isec->output_section->id].u.list;
12130 htab->sec_info[isec->output_section->id].u.list = isec;
721956f4 12131 }
ad8e1ba5 12132
4c52953f 12133 if (htab->multi_toc_needed)
9b5ecbd0 12134 {
8b974ba3
AM		 12135 /* Analyse sections that aren't already flagged as needing a
12136 valid toc pointer. Exclude .fixup for the linux kernel.
12137 .fixup contains branches, but only back to the function that
12138 hit an exception. */
12139 if (!(isec->has_toc_reloc
12140 || (isec->flags & SEC_CODE) == 0
12141 || strcmp (isec->name, ".fixup") == 0
12142 || isec->call_check_done))
12143 {
12144 if (toc_adjusting_stub_needed (info, isec) < 0)
6683a28d 12145 return FALSE;
8b974ba3
AM		 12146 }
12147 /* Make all sections use the TOC assigned for this object file.
12148 This will be wrong for pasted sections; We fix that in
12149 check_pasted_section(). */
12150 if (elf_gp (isec->owner) != 0)
12151 htab->toc_curr = elf_gp (isec->owner);
12152 }
12153
6f20ed8a 12154 htab->sec_info[isec->id].toc_off = htab->toc_curr;
9b5ecbd0 12155 return TRUE;
721956f4
AM		 12156}
12157
70cc837d
AM		 12158/* Check that all .init and .fini sections use the same toc, if they
12159 have toc relocs. */
12160
12161static bfd_boolean
12162check_pasted_section (struct bfd_link_info *info, const char *name)
12163{
12164 asection *o = bfd_get_section_by_name (info->output_bfd, name);
12165
12166 if (o != NULL)
12167 {
12168 struct ppc_link_hash_table *htab = ppc_hash_table (info);
12169 bfd_vma toc_off = 0;
12170 asection *i;
12171
12172 for (i = o->map_head.s; i != NULL; i = i->map_head.s)
12173 if (i->has_toc_reloc)
12174 {
12175 if (toc_off == 0)
6f20ed8a
AM		 12176 toc_off = htab->sec_info[i->id].toc_off;
12177 else if (toc_off != htab->sec_info[i->id].toc_off)
70cc837d
AM		 12178 return FALSE;
12179 }
6683a28d
AM		 12180
12181 if (toc_off == 0)
12182 for (i = o->map_head.s; i != NULL; i = i->map_head.s)
12183 if (i->makes_toc_func_call)
12184 {
6f20ed8a 12185 toc_off = htab->sec_info[i->id].toc_off;
6683a28d
AM		 12186 break;
12187 }
12188
70cc837d
AM		 12189 /* Make sure the whole pasted function uses the same toc offset. */
12190 if (toc_off != 0)
12191 for (i = o->map_head.s; i != NULL; i = i->map_head.s)
6f20ed8a 12192 htab->sec_info[i->id].toc_off = toc_off;
70cc837d
AM		 12193 }
12194 return TRUE;
12195}
12196
12197bfd_boolean
12198ppc64_elf_check_init_fini (struct bfd_link_info *info)
12199{
12200 return (check_pasted_section (info, ".init")
12201 & check_pasted_section (info, ".fini"));
12202}
12203
721956f4
AM		 12204/* See whether we can group stub sections together. Grouping stub
12205 sections may result in fewer stubs. More importantly, we need to
12206 put all .init* and .fini* stubs at the beginning of the .init or
12207 .fini output sections respectively, because glibc splits the
12208 _init and _fini functions into multiple parts. Putting a stub in
12209 the middle of a function is not a good idea. */
12210
6f20ed8a
AM		 12211static bfd_boolean
12212group_sections (struct bfd_link_info *info,
4ce794b7
AM		 12213 bfd_size_type stub_group_size,
12214 bfd_boolean stubs_always_before_branch)
721956f4 12215{
6f20ed8a
AM		 12216 struct ppc_link_hash_table *htab;
12217 asection *osec;
7c8fe5c4
AM		 12218 bfd_boolean suppress_size_errors;
12219
6f20ed8a
AM		 12220 htab = ppc_hash_table (info);
12221 if (htab == NULL)
12222 return FALSE;
12223
7c8fe5c4 12224 suppress_size_errors = FALSE;
7c8fe5c4
AM		 12225 if (stub_group_size == 1)
12226 {
12227 /* Default values. */
12228 if (stubs_always_before_branch)
09f92717 12229 stub_group_size = 0x1e00000;
7c8fe5c4 12230 else
09f92717 12231 stub_group_size = 0x1c00000;
7c8fe5c4
AM		 12232 suppress_size_errors = TRUE;
12233 }
12234
6f20ed8a 12235 for (osec = info->output_bfd->sections; osec != NULL; osec = osec->next)
721956f4 12236 {
6f20ed8a
AM		 12237 asection *tail;
12238
12239 if (osec->id >= htab->sec_info_arr_size)
12240 continue;
12241
12242 tail = htab->sec_info[osec->id].u.list;
734b6cf9 12243 while (tail != NULL)
721956f4 12244 {
734b6cf9
AM		 12245 asection *curr;
12246 asection *prev;
12247 bfd_size_type total;
12248 bfd_boolean big_sec;
12249 bfd_vma curr_toc;
6f20ed8a 12250 struct map_stub *group;
09f92717 12251 bfd_size_type group_size;
734b6cf9
AM		 12252
12253 curr = tail;
eea6121a 12254 total = tail->size;
09f92717
AM		 12255 group_size = (ppc64_elf_section_data (tail) != NULL
12256 && ppc64_elf_section_data (tail)->has_14bit_branch
12257 ? stub_group_size >> 10 : stub_group_size);
12258
12259 big_sec = total > group_size;
7c8fe5c4 12260 if (big_sec && !suppress_size_errors)
695344c0 12261 /* xgettext:c-format */
4eca0228
AM		 12262 _bfd_error_handler (_("%B section %A exceeds stub group size"),
12263 tail->owner, tail);
6f20ed8a 12264 curr_toc = htab->sec_info[tail->id].toc_off;
734b6cf9 12265
6f20ed8a 12266 while ((prev = htab->sec_info[curr->id].u.list) != NULL
734b6cf9 12267 && ((total += curr->output_offset - prev->output_offset)
6bee8834
AM		 12268 < (ppc64_elf_section_data (prev) != NULL
12269 && ppc64_elf_section_data (prev)->has_14bit_branch
09f92717 12270 ? (group_size = stub_group_size >> 10) : group_size))
6f20ed8a 12271 && htab->sec_info[prev->id].toc_off == curr_toc)
734b6cf9
AM		 12272 curr = prev;
12273
12274 /* OK, the size from the start of CURR to the end is less
09f92717 12275 than group_size and thus can be handled by one stub
734b6cf9 12276 section. (or the tail section is itself larger than
09f92717
AM		 12277 group_size, in which case we may be toast.) We should
12278 really be keeping track of the total size of stubs added
12279 here, as stubs contribute to the final output section
12280 size. That's a little tricky, and this way will only
12281 break if stubs added make the total size more than 2^25,
12282 ie. for the default stub_group_size, if stubs total more
12283 than 2097152 bytes, or nearly 75000 plt call stubs. */
6f20ed8a
AM		 12284 group = bfd_alloc (curr->owner, sizeof (*group));
12285 if (group == NULL)
12286 return FALSE;
12287 group->link_sec = curr;
12288 group->stub_sec = NULL;
a4b6fadd 12289 group->needs_save_res = 0;
d4aaa2a0 12290 group->tls_get_addr_opt_bctrl = -1u;
a4b6fadd
AM		 12291 group->next = htab->group;
12292 htab->group = group;
734b6cf9 12293 do
721956f4 12294 {
6f20ed8a 12295 prev = htab->sec_info[tail->id].u.list;
734b6cf9 12296 /* Set up this stub group. */
6f20ed8a 12297 htab->sec_info[tail->id].u.group = group;
721956f4 12298 }
734b6cf9
AM		 12299 while (tail != curr && (tail = prev) != NULL);
12300
09f92717 12301 /* But wait, there's more! Input sections up to group_size
734b6cf9
AM		 12302 bytes before the stub section can be handled by it too.
12303 Don't do this if we have a really large section after the
12304 stubs, as adding more stubs increases the chance that
12305 branches may not reach into the stub section. */
12306 if (!stubs_always_before_branch && !big_sec)
12307 {
12308 total = 0;
12309 while (prev != NULL
12310 && ((total += tail->output_offset - prev->output_offset)
6bee8834
AM		 12311 < (ppc64_elf_section_data (prev) != NULL
12312 && ppc64_elf_section_data (prev)->has_14bit_branch
09f92717 12313 ? (group_size = stub_group_size >> 10) : group_size))
6f20ed8a 12314 && htab->sec_info[prev->id].toc_off == curr_toc)
734b6cf9
AM		 12315 {
12316 tail = prev;
6f20ed8a
AM		 12317 prev = htab->sec_info[tail->id].u.list;
12318 htab->sec_info[tail->id].u.group = group;
734b6cf9
AM		 12319 }
12320 }
12321 tail = prev;
721956f4
AM		 12322 }
12323 }
6f20ed8a 12324 return TRUE;
721956f4
AM		 12325}
12326
58d180e8
AM		 12327static const unsigned char glink_eh_frame_cie[] =
12328{
12329 0, 0, 0, 16, /* length. */
12330 0, 0, 0, 0, /* id. */
12331 1, /* CIE version. */
12332 'z', 'R', 0, /* Augmentation string. */
12333 4, /* Code alignment. */
12334 0x78, /* Data alignment. */
12335 65, /* RA reg. */
12336 1, /* Augmentation size. */
12337 DW_EH_PE_pcrel | DW_EH_PE_sdata4, /* FDE encoding. */
2e0ce1c8 12338 DW_CFA_def_cfa, 1, 0 /* def_cfa: r1 offset 0. */
58d180e8
AM		 12339};
12340
d4aaa2a0
AM		 12341static size_t
12342stub_eh_frame_size (struct map_stub *group, size_t align)
12343{
12344 size_t this_size = 17;
12345 if (group->tls_get_addr_opt_bctrl != -1u)
12346 {
12347 unsigned int to_bctrl = group->tls_get_addr_opt_bctrl / 4;
12348 if (to_bctrl < 64)
12349 this_size += 1;
12350 else if (to_bctrl < 256)
12351 this_size += 2;
12352 else if (to_bctrl < 65536)
12353 this_size += 3;
12354 else
12355 this_size += 5;
12356 this_size += 6;
12357 }
12358 this_size = (this_size + align - 1) & -align;
12359 return this_size;
12360}
12361
d969d15f
AM		 12362/* Stripping output sections is normally done before dynamic section
12363 symbols have been allocated. This function is called later, and
12364 handles cases like htab->brlt which is mapped to its own output
12365 section. */
12366
12367static void
12368maybe_strip_output (struct bfd_link_info *info, asection *isec)
12369{
12370 if (isec->size == 0
12371 && isec->output_section->size == 0
53d8967a 12372 && !(isec->output_section->flags & SEC_KEEP)
d969d15f
AM		 12373 && !bfd_section_removed_from_list (info->output_bfd,
12374 isec->output_section)
12375 && elf_section_data (isec->output_section)->dynindx == 0)
12376 {
12377 isec->output_section->flags |= SEC_EXCLUDE;
12378 bfd_section_list_remove (info->output_bfd, isec->output_section);
12379 info->output_bfd->section_count--;
12380 }
12381}
12382
721956f4
AM		 12383/* Determine and set the size of the stub section for a final link.
12384
12385 The basic idea here is to examine all the relocations looking for
12386 PC-relative calls to a target that is unreachable with a "bl"
12387 instruction. */
12388
b34976b6 12389bfd_boolean
e7d1c40c 12390ppc64_elf_size_stubs (struct bfd_link_info *info)
721956f4
AM		 12391{
12392 bfd_size_type stub_group_size;
b34976b6 12393 bfd_boolean stubs_always_before_branch;
721956f4
AM		 12394 struct ppc_link_hash_table *htab = ppc_hash_table (info);
12395
4dfe6ac6
NC		 12396 if (htab == NULL)
12397 return FALSE;
12398
0e1862bb 12399 if (htab->params->plt_thread_safe == -1 && !bfd_link_executable (info))
e7d1c40c 12400 htab->params->plt_thread_safe = 1;
b9e5796b 12401 if (!htab->opd_abi)
e7d1c40c
AM		 12402 htab->params->plt_thread_safe = 0;
12403 else if (htab->params->plt_thread_safe == -1)
794e51c0 12404 {
e2458743 12405 static const char *const thread_starter[] =
794e51c0
AM		 12406 {
12407 "pthread_create",
12408 /* libstdc++ */
12409 "_ZNSt6thread15_M_start_threadESt10shared_ptrINS_10_Impl_baseEE",
12410 /* librt */
12411 "aio_init", "aio_read", "aio_write", "aio_fsync", "lio_listio",
12412 "mq_notify", "create_timer",
12413 /* libanl */
12414 "getaddrinfo_a",
12415 /* libgomp */
2300b5a1 12416 "GOMP_parallel",
794e51c0 12417 "GOMP_parallel_start",
2300b5a1 12418 "GOMP_parallel_loop_static",
794e51c0 12419 "GOMP_parallel_loop_static_start",
2300b5a1 12420 "GOMP_parallel_loop_dynamic",
794e51c0 12421 "GOMP_parallel_loop_dynamic_start",
2300b5a1 12422 "GOMP_parallel_loop_guided",
794e51c0 12423 "GOMP_parallel_loop_guided_start",
2300b5a1 12424 "GOMP_parallel_loop_runtime",
794e51c0 12425 "GOMP_parallel_loop_runtime_start",
2300b5a1 12426 "GOMP_parallel_sections",
68ffbac6 12427 "GOMP_parallel_sections_start",
f9dffbf0
AM		 12428 /* libgo */
12429 "__go_go",
794e51c0
AM		 12430 };
12431 unsigned i;
12432
a4b6fadd 12433 for (i = 0; i < ARRAY_SIZE (thread_starter); i++)
794e51c0
AM		 12434 {
12435 struct elf_link_hash_entry *h;
12436 h = elf_link_hash_lookup (&htab->elf, thread_starter[i],
12437 FALSE, FALSE, TRUE);
e7d1c40c
AM		 12438 htab->params->plt_thread_safe = h != NULL && h->ref_regular;
12439 if (htab->params->plt_thread_safe)
794e51c0
AM		 12440 break;
12441 }
12442 }
e7d1c40c
AM		 12443 stubs_always_before_branch = htab->params->group_size < 0;
12444 if (htab->params->group_size < 0)
12445 stub_group_size = -htab->params->group_size;
721956f4 12446 else
e7d1c40c 12447 stub_group_size = htab->params->group_size;
721956f4 12448
6f20ed8a
AM		 12449 if (!group_sections (info, stub_group_size, stubs_always_before_branch))
12450 return FALSE;
721956f4 12451
c9301e31
AM		 12452#define STUB_SHRINK_ITER 20
12453 /* Loop until no stubs added. After iteration 20 of this loop we may
12454 exit on a stub section shrinking. This is to break out of a
12455 pathological case where adding stubs on one iteration decreases
12456 section gaps (perhaps due to alignment), which then requires
12457 fewer or smaller stubs on the next iteration. */
12458
721956f4
AM		 12459 while (1)
12460 {
12461 bfd *input_bfd;
12462 unsigned int bfd_indx;
a4b6fadd 12463 struct map_stub *group;
721956f4
AM		 12464
12465 htab->stub_iteration += 1;
721956f4
AM		 12466
12467 for (input_bfd = info->input_bfds, bfd_indx = 0;
12468 input_bfd != NULL;
c72f2fb2 12469 input_bfd = input_bfd->link.next, bfd_indx++)
721956f4
AM		 12470 {
12471 Elf_Internal_Shdr *symtab_hdr;
12472 asection *section;
6cdc0ccc 12473 Elf_Internal_Sym *local_syms = NULL;
721956f4 12474
0c8d6e5c 12475 if (!is_ppc64_elf (input_bfd))
67f93c31
AM		 12476 continue;
12477
721956f4 12478 /* We'll need the symbol table in a second. */
0ffa91dd 12479 symtab_hdr = &elf_symtab_hdr (input_bfd);
721956f4
AM		 12480 if (symtab_hdr->sh_info == 0)
12481 continue;
12482
721956f4
AM		 12483 /* Walk over each section attached to the input bfd. */
12484 for (section = input_bfd->sections;
12485 section != NULL;
12486 section = section->next)
12487 {
721956f4 12488 Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
721956f4
AM		 12489
12490 /* If there aren't any relocs, then there's nothing more
12491 to do. */
12492 if ((section->flags & SEC_RELOC) == 0
12c0f757
AM		 12493 || (section->flags & SEC_ALLOC) == 0
12494 || (section->flags & SEC_LOAD) == 0
12495 || (section->flags & SEC_CODE) == 0
721956f4
AM		 12496 || section->reloc_count == 0)
12497 continue;
12498
12499 /* If this section is a link-once section that will be
12500 discarded, then don't create any stubs. */
12501 if (section->output_section == NULL
927be08e 12502 || section->output_section->owner != info->output_bfd)
721956f4
AM		 12503 continue;
12504
1e2f5b6e
AM		 12505 /* Get the relocs. */
12506 internal_relocs
4ce794b7 12507 = _bfd_elf_link_read_relocs (input_bfd, section, NULL, NULL,
45d6a902 12508 info->keep_memory);
721956f4 12509 if (internal_relocs == NULL)
1e2f5b6e 12510 goto error_ret_free_local;
721956f4
AM		 12511
12512 /* Now examine each relocation. */
12513 irela = internal_relocs;
12514 irelaend = irela + section->reloc_count;
12515 for (; irela < irelaend; irela++)
12516 {
4ce794b7
AM		 12517 enum elf_ppc64_reloc_type r_type;
12518 unsigned int r_indx;
721956f4
AM		 12519 enum ppc_stub_type stub_type;
12520 struct ppc_stub_hash_entry *stub_entry;
8387904d 12521 asection *sym_sec, *code_sec;
e054468f 12522 bfd_vma sym_value, code_value;
721956f4 12523 bfd_vma destination;
6911b7dc 12524 unsigned long local_off;
8843416a 12525 bfd_boolean ok_dest;
721956f4 12526 struct ppc_link_hash_entry *hash;
8387904d 12527 struct ppc_link_hash_entry *fdh;
411e1bfb
AM		 12528 struct elf_link_hash_entry *h;
12529 Elf_Internal_Sym *sym;
721956f4
AM		 12530 char *stub_name;
12531 const asection *id_sec;
74f0fb50 12532 struct _opd_sec_data *opd;
e054468f 12533 struct plt_entry *plt_ent;
721956f4
AM		 12534
12535 r_type = ELF64_R_TYPE (irela->r_info);
12536 r_indx = ELF64_R_SYM (irela->r_info);
12537
4ce794b7 12538 if (r_type >= R_PPC64_max)
721956f4
AM		 12539 {
12540 bfd_set_error (bfd_error_bad_value);
6cdc0ccc 12541 goto error_ret_free_internal;
721956f4
AM		 12542 }
12543
12544 /* Only look for stubs on branch instructions. */
4ce794b7
AM		 12545 if (r_type != R_PPC64_REL24
12546 && r_type != R_PPC64_REL14
12547 && r_type != R_PPC64_REL14_BRTAKEN
12548 && r_type != R_PPC64_REL14_BRNTAKEN)
721956f4
AM		 12549 continue;
12550
12551 /* Now determine the call target, its name, value,
12552 section. */
411e1bfb
AM		 12553 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
12554 r_indx, input_bfd))
12555 goto error_ret_free_internal;
12556 hash = (struct ppc_link_hash_entry *) h;
12557
8843416a 12558 ok_dest = FALSE;
8387904d 12559 fdh = NULL;
7fe2b9a6 12560 sym_value = 0;
411e1bfb 12561 if (hash == NULL)
721956f4 12562 {
411e1bfb 12563 sym_value = sym->st_value;
c27b8c2a
AM		 12564 if (sym_sec != NULL
12565 && sym_sec->output_section != NULL)
12566 ok_dest = TRUE;
721956f4 12567 }
7fe2b9a6
AM		 12568 else if (hash->elf.root.type == bfd_link_hash_defined
12569 || hash->elf.root.type == bfd_link_hash_defweak)
12570 {
12571 sym_value = hash->elf.root.u.def.value;
12572 if (sym_sec->output_section != NULL)
12573 ok_dest = TRUE;
12574 }
12575 else if (hash->elf.root.type == bfd_link_hash_undefweak
12576 || hash->elf.root.type == bfd_link_hash_undefined)
721956f4 12577 {
99877b66 12578 /* Recognise an old ABI func code entry sym, and
7fe2b9a6
AM		 12579 use the func descriptor sym instead if it is
12580 defined. */
ceb1f1ef 12581 if (hash->elf.root.root.string[0] == '.'
8c5b4e52 12582 && hash->oh != NULL)
8387904d 12583 {
8c5b4e52 12584 fdh = ppc_follow_link (hash->oh);
8387904d
AM		 12585 if (fdh->elf.root.type == bfd_link_hash_defined
12586 || fdh->elf.root.type == bfd_link_hash_defweak)
12587 {
12588 sym_sec = fdh->elf.root.u.def.section;
12589 sym_value = fdh->elf.root.u.def.value;
12590 if (sym_sec->output_section != NULL)
12591 ok_dest = TRUE;
12592 }
99877b66
AM		 12593 else
12594 fdh = NULL;
8387904d 12595 }
7fe2b9a6
AM		 12596 }
12597 else
12598 {
12599 bfd_set_error (bfd_error_bad_value);
12600 goto error_ret_free_internal;
721956f4
AM		 12601 }
12602
8843416a 12603 destination = 0;
6911b7dc 12604 local_off = 0;
8843416a
AM		 12605 if (ok_dest)
12606 {
12607 sym_value += irela->r_addend;
12608 destination = (sym_value
12609 + sym_sec->output_offset
12610 + sym_sec->output_section->vma);
6911b7dc
AM		 12611 local_off = PPC64_LOCAL_ENTRY_OFFSET (hash
12612 ? hash->elf.other
12613 : sym->st_other);
8843416a
AM		 12614 }
12615
8387904d 12616 code_sec = sym_sec;
e054468f 12617 code_value = sym_value;
74f0fb50
AM		 12618 opd = get_opd_info (sym_sec);
12619 if (opd != NULL)
8387904d
AM		 12620 {
12621 bfd_vma dest;
12622
74f0fb50 12623 if (hash == NULL && opd->adjust != NULL)
8387904d 12624 {
51aecdc5 12625 long adjust = opd->adjust[OPD_NDX (sym_value)];
8387904d
AM		 12626 if (adjust == -1)
12627 continue;
e054468f 12628 code_value += adjust;
8387904d
AM		 12629 sym_value += adjust;
12630 }
12631 dest = opd_entry_value (sym_sec, sym_value,
aef36ac1 12632 &code_sec, &code_value, FALSE);
8387904d
AM		 12633 if (dest != (bfd_vma) -1)
12634 {
12635 destination = dest;
12636 if (fdh != NULL)
12637 {
12638 /* Fixup old ABI sym to point at code
12639 entry. */
99877b66 12640 hash->elf.root.type = bfd_link_hash_defweak;
8387904d 12641 hash->elf.root.u.def.section = code_sec;
e054468f 12642 hash->elf.root.u.def.value = code_value;
8387904d
AM		 12643 }
12644 }
12645 }
12646
721956f4 12647 /* Determine what (if any) linker stub is needed. */
e054468f 12648 plt_ent = NULL;
721956f4 12649 stub_type = ppc_type_of_stub (section, irela, &hash,
6911b7dc
AM		 12650 &plt_ent, destination,
12651 local_off);
ad8e1ba5
AM		 12652
12653 if (stub_type != ppc_stub_plt_call)
12654 {
12655 /* Check whether we need a TOC adjusting stub.
12656 Since the linker pastes together pieces from
12657 different object files when creating the
12658 _init and _fini functions, it may be that a
12659 call to what looks like a local sym is in
12660 fact a call needing a TOC adjustment. */
8387904d
AM		 12661 if (code_sec != NULL
12662 && code_sec->output_section != NULL
6f20ed8a
AM		 12663 && (htab->sec_info[code_sec->id].toc_off
12664 != htab->sec_info[section->id].toc_off)
4c52953f
AM		 12665 && (code_sec->has_toc_reloc
12666 || code_sec->makes_toc_func_call))
ad8e1ba5
AM		 12667 stub_type = ppc_stub_long_branch_r2off;
12668 }
12669
721956f4
AM		 12670 if (stub_type == ppc_stub_none)
12671 continue;
12672
411e1bfb
AM		 12673 /* __tls_get_addr calls might be eliminated. */
12674 if (stub_type != ppc_stub_plt_call
12675 && hash != NULL
8387904d
AM		 12676 && (hash == htab->tls_get_addr
12677 || hash == htab->tls_get_addr_fd)
411e1bfb
AM		 12678 && section->has_tls_reloc
12679 && irela != internal_relocs)
12680 {
12681 /* Get tls info. */
f961d9dd 12682 unsigned char *tls_mask;
411e1bfb 12683
3a71aa26 12684 if (!get_tls_mask (&tls_mask, NULL, NULL, &local_syms,
411e1bfb
AM		 12685 irela - 1, input_bfd))
12686 goto error_ret_free_internal;
e7b938ca 12687 if (*tls_mask != 0)
411e1bfb
AM		 12688 continue;
12689 }
12690
f378ab09 12691 if (stub_type == ppc_stub_plt_call)
794e51c0 12692 {
6e1816be
AM		 12693 if (!htab->opd_abi
12694 && htab->params->plt_localentry0 != 0
12695 && is_elfv2_localentry0 (&hash->elf))
12696 htab->has_plt_localentry0 = 1;
12697 else if (irela + 1 < irelaend
12698 && irela[1].r_offset == irela->r_offset + 4
12699 && (ELF64_R_TYPE (irela[1].r_info)
12700 == R_PPC64_TOCSAVE))
f378ab09
AM		 12701 {
12702 if (!tocsave_find (htab, INSERT,
12703 &local_syms, irela + 1, input_bfd))
12704 goto error_ret_free_internal;
12705 }
f378ab09
AM		 12706 else
12707 stub_type = ppc_stub_plt_call_r2save;
794e51c0 12708 }
3b421ab3 12709
721956f4 12710 /* Support for grouping stub sections. */
6f20ed8a 12711 id_sec = htab->sec_info[section->id].u.group->link_sec;
721956f4
AM		 12712
12713 /* Get the name of this stub. */
12714 stub_name = ppc_stub_name (id_sec, sym_sec, hash, irela);
12715 if (!stub_name)
12716 goto error_ret_free_internal;
12717
12718 stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
b34976b6 12719 stub_name, FALSE, FALSE);
721956f4
AM		 12720 if (stub_entry != NULL)
12721 {
12722 /* The proper stub has already been created. */
12723 free (stub_name);
794e51c0
AM		 12724 if (stub_type == ppc_stub_plt_call_r2save)
12725 stub_entry->stub_type = stub_type;
721956f4
AM		 12726 continue;
12727 }
12728
25f53a85 12729 stub_entry = ppc_add_stub (stub_name, section, info);
721956f4
AM		 12730 if (stub_entry == NULL)
12731 {
12732 free (stub_name);
6cdc0ccc
AM		 12733 error_ret_free_internal:
12734 if (elf_section_data (section)->relocs == NULL)
12735 free (internal_relocs);
12736 error_ret_free_local:
12737 if (local_syms != NULL
12738 && (symtab_hdr->contents
12739 != (unsigned char *) local_syms))
12740 free (local_syms);
b34976b6 12741 return FALSE;
721956f4
AM		 12742 }
12743
ad8e1ba5 12744 stub_entry->stub_type = stub_type;
794e51c0
AM		 12745 if (stub_type != ppc_stub_plt_call
12746 && stub_type != ppc_stub_plt_call_r2save)
e054468f
AM		 12747 {
12748 stub_entry->target_value = code_value;
12749 stub_entry->target_section = code_sec;
12750 }
12751 else
12752 {
12753 stub_entry->target_value = sym_value;
12754 stub_entry->target_section = sym_sec;
12755 }
721956f4 12756 stub_entry->h = hash;
e054468f 12757 stub_entry->plt_ent = plt_ent;
6911b7dc 12758 stub_entry->other = hash ? hash->elf.other : sym->st_other;
ee75fd95
AM		 12759
12760 if (stub_entry->h != NULL)
12761 htab->stub_globals += 1;
721956f4
AM		 12762 }
12763
12764 /* We're done with the internal relocs, free them. */
6cdc0ccc 12765 if (elf_section_data (section)->relocs != internal_relocs)
1e2f5b6e 12766 free (internal_relocs);
721956f4 12767 }
6cdc0ccc
AM		 12768
12769 if (local_syms != NULL
12770 && symtab_hdr->contents != (unsigned char *) local_syms)
12771 {
12772 if (!info->keep_memory)
12773 free (local_syms);
12774 else
12775 symtab_hdr->contents = (unsigned char *) local_syms;
12776 }
721956f4
AM		 12777 }
12778
5c3dead3 12779 /* We may have added some stubs. Find out the new size of the
721956f4 12780 stub sections. */
d4aaa2a0
AM		 12781 for (group = htab->group; group != NULL; group = group->next)
12782 if (group->stub_sec != NULL)
ee75fd95 12783 {
d4aaa2a0
AM		 12784 asection *stub_sec = group->stub_sec;
12785
ea3d7d1c
AM		 12786 if (htab->stub_iteration <= STUB_SHRINK_ITER
12787 || stub_sec->rawsize < stub_sec->size)
12788 /* Past STUB_SHRINK_ITER, rawsize is the max size seen. */
12789 stub_sec->rawsize = stub_sec->size;
ee75fd95
AM		 12790 stub_sec->size = 0;
12791 stub_sec->reloc_count = 0;
84f5d08e 12792 stub_sec->flags &= ~SEC_RELOC;
ee75fd95 12793 }
eea6121a
AM		 12794
12795 htab->brlt->size = 0;
84f5d08e
AM		 12796 htab->brlt->reloc_count = 0;
12797 htab->brlt->flags &= ~SEC_RELOC;
ee75fd95 12798 if (htab->relbrlt != NULL)
eea6121a 12799 htab->relbrlt->size = 0;
721956f4 12800
63bc6f6c 12801 bfd_hash_traverse (&htab->stub_hash_table, ppc_size_one_stub, info);
721956f4 12802
a4b6fadd
AM		 12803 for (group = htab->group; group != NULL; group = group->next)
12804 if (group->needs_save_res)
12805 group->stub_sec->size += htab->sfpr->size;
12806
176a0d42
AM		 12807 if (info->emitrelocations
12808 && htab->glink != NULL && htab->glink->size != 0)
12809 {
12810 htab->glink->reloc_count = 1;
12811 htab->glink->flags |= SEC_RELOC;
12812 }
12813
58d180e8
AM		 12814 if (htab->glink_eh_frame != NULL
12815 && !bfd_is_abs_section (htab->glink_eh_frame->output_section)
9a2a56cc 12816 && htab->glink_eh_frame->output_section->size != 0)
58d180e8 12817 {
2e0ce1c8 12818 size_t size = 0, align = 4;
58d180e8 12819
d4aaa2a0
AM		 12820 for (group = htab->group; group != NULL; group = group->next)
12821 if (group->stub_sec != NULL)
12822 size += stub_eh_frame_size (group, align);
58d180e8 12823 if (htab->glink != NULL && htab->glink->size != 0)
2e0ce1c8 12824 size += (24 + align - 1) & -align;
58d180e8 12825 if (size != 0)
2e0ce1c8
AM		 12826 size += (sizeof (glink_eh_frame_cie) + align - 1) & -align;
12827 align = 1ul << htab->glink_eh_frame->output_section->alignment_power;
12828 size = (size + align - 1) & -align;
58d180e8
AM		 12829 htab->glink_eh_frame->rawsize = htab->glink_eh_frame->size;
12830 htab->glink_eh_frame->size = size;
12831 }
12832
e7d1c40c 12833 if (htab->params->plt_stub_align != 0)
d4aaa2a0
AM		 12834 for (group = htab->group; group != NULL; group = group->next)
12835 if (group->stub_sec != NULL)
12836 group->stub_sec->size = ((group->stub_sec->size
12837 + (1 << htab->params->plt_stub_align) - 1)
12838 & -(1 << htab->params->plt_stub_align));
12839
12840 for (group = htab->group; group != NULL; group = group->next)
12841 if (group->stub_sec != NULL
12842 && group->stub_sec->rawsize != group->stub_sec->size
c9301e31 12843 && (htab->stub_iteration <= STUB_SHRINK_ITER
d4aaa2a0 12844 || group->stub_sec->rawsize < group->stub_sec->size))
5c3dead3
AM		 12845 break;
12846
d4aaa2a0 12847 if (group == NULL
58d180e8
AM		 12848 && (htab->glink_eh_frame == NULL
12849 || htab->glink_eh_frame->rawsize == htab->glink_eh_frame->size))
5c3dead3
AM		 12850 break;
12851
721956f4 12852 /* Ask the linker to do its stuff. */
e7d1c40c 12853 (*htab->params->layout_sections_again) ();
721956f4
AM		 12854 }
12855
da44f4e5
AM		 12856 if (htab->glink_eh_frame != NULL
12857 && htab->glink_eh_frame->size != 0)
12858 {
12859 bfd_vma val;
12860 bfd_byte *p, *last_fde;
12861 size_t last_fde_len, size, align, pad;
d4aaa2a0 12862 struct map_stub *group;
da44f4e5
AM		 12863
12864 p = bfd_zalloc (htab->glink_eh_frame->owner, htab->glink_eh_frame->size);
12865 if (p == NULL)
12866 return FALSE;
12867 htab->glink_eh_frame->contents = p;
12868 last_fde = p;
2e0ce1c8 12869 align = 4;
da44f4e5
AM		 12870
12871 memcpy (p, glink_eh_frame_cie, sizeof (glink_eh_frame_cie));
12872 /* CIE length (rewrite in case little-endian). */
2e0ce1c8 12873 last_fde_len = ((sizeof (glink_eh_frame_cie) + align - 1) & -align) - 4;
da44f4e5 12874 bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
2e0ce1c8 12875 p += last_fde_len + 4;
da44f4e5 12876
d4aaa2a0
AM		 12877 for (group = htab->group; group != NULL; group = group->next)
12878 if (group->stub_sec != NULL)
da44f4e5
AM		 12879 {
12880 last_fde = p;
d4aaa2a0 12881 last_fde_len = stub_eh_frame_size (group, align) - 4;
da44f4e5 12882 /* FDE length. */
2e0ce1c8 12883 bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
da44f4e5
AM		 12884 p += 4;
12885 /* CIE pointer. */
12886 val = p - htab->glink_eh_frame->contents;
12887 bfd_put_32 (htab->elf.dynobj, val, p);
12888 p += 4;
12889 /* Offset to stub section, written later. */
12890 p += 4;
12891 /* stub section size. */
d4aaa2a0 12892 bfd_put_32 (htab->elf.dynobj, group->stub_sec->size, p);
da44f4e5
AM		 12893 p += 4;
12894 /* Augmentation. */
12895 p += 1;
d4aaa2a0
AM		 12896 if (group->tls_get_addr_opt_bctrl != -1u)
12897 {
12898 unsigned int to_bctrl = group->tls_get_addr_opt_bctrl / 4;
12899
12900 /* This FDE needs more than just the default.
12901 Describe __tls_get_addr_opt stub LR. */
12902 if (to_bctrl < 64)
12903 *p++ = DW_CFA_advance_loc + to_bctrl;
12904 else if (to_bctrl < 256)
12905 {
12906 *p++ = DW_CFA_advance_loc1;
12907 *p++ = to_bctrl;
12908 }
12909 else if (to_bctrl < 65536)
12910 {
12911 *p++ = DW_CFA_advance_loc2;
12912 bfd_put_16 (htab->elf.dynobj, to_bctrl, p);
12913 p += 2;
12914 }
12915 else
12916 {
12917 *p++ = DW_CFA_advance_loc4;
12918 bfd_put_32 (htab->elf.dynobj, to_bctrl, p);
12919 p += 4;
12920 }
12921 *p++ = DW_CFA_offset_extended_sf;
12922 *p++ = 65;
12923 *p++ = -(STK_LINKER (htab) / 8) & 0x7f;
12924 *p++ = DW_CFA_advance_loc + 4;
12925 *p++ = DW_CFA_restore_extended;
12926 *p++ = 65;
12927 }
da44f4e5 12928 /* Pad. */
d4aaa2a0 12929 p = last_fde + last_fde_len + 4;
da44f4e5
AM		 12930 }
12931 if (htab->glink != NULL && htab->glink->size != 0)
12932 {
12933 last_fde = p;
2e0ce1c8 12934 last_fde_len = ((24 + align - 1) & -align) - 4;
da44f4e5 12935 /* FDE length. */
2e0ce1c8 12936 bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
da44f4e5
AM		 12937 p += 4;
12938 /* CIE pointer. */
12939 val = p - htab->glink_eh_frame->contents;
12940 bfd_put_32 (htab->elf.dynobj, val, p);
12941 p += 4;
12942 /* Offset to .glink, written later. */
12943 p += 4;
12944 /* .glink size. */
12945 bfd_put_32 (htab->elf.dynobj, htab->glink->size - 8, p);
12946 p += 4;
12947 /* Augmentation. */
12948 p += 1;
12949
12950 *p++ = DW_CFA_advance_loc + 1;
12951 *p++ = DW_CFA_register;
12952 *p++ = 65;
9f08fa5c 12953 *p++ = htab->opd_abi ? 12 : 0;
15a3a14f 12954 *p++ = DW_CFA_advance_loc + (htab->opd_abi ? 5 : 7);
da44f4e5
AM		 12955 *p++ = DW_CFA_restore_extended;
12956 *p++ = 65;
2e0ce1c8 12957 p += ((24 + align - 1) & -align) - 24;
da44f4e5
AM		 12958 }
12959 /* Subsume any padding into the last FDE if user .eh_frame
12960 sections are aligned more than glink_eh_frame. Otherwise any
12961 zero padding will be seen as a terminator. */
2e0ce1c8 12962 align = 1ul << htab->glink_eh_frame->output_section->alignment_power;
da44f4e5 12963 size = p - htab->glink_eh_frame->contents;
2e0ce1c8 12964 pad = ((size + align - 1) & -align) - size;
da44f4e5
AM		 12965 htab->glink_eh_frame->size = size + pad;
12966 bfd_put_32 (htab->elf.dynobj, last_fde_len + pad, last_fde);
12967 }
12968
d969d15f
AM		 12969 maybe_strip_output (info, htab->brlt);
12970 if (htab->glink_eh_frame != NULL)
12971 maybe_strip_output (info, htab->glink_eh_frame);
721956f4 12972
b34976b6 12973 return TRUE;
721956f4
AM		 12974}
12975
12976/* Called after we have determined section placement. If sections
805fc799 12977 move, we'll be called again. Provide a value for TOCstart. */
721956f4 12978
805fc799 12979bfd_vma
1c865ab2 12980ppc64_elf_set_toc (struct bfd_link_info *info, bfd *obfd)
721956f4 12981{
805fc799 12982 asection *s;
a27e685f 12983 bfd_vma TOCstart, adjust;
721956f4 12984
43417696
AM		 12985 if (info != NULL)
12986 {
12987 struct elf_link_hash_entry *h;
12988 struct elf_link_hash_table *htab = elf_hash_table (info);
12989
12990 if (is_elf_hash_table (htab)
12991 && htab->hgot != NULL)
12992 h = htab->hgot;
12993 else
12994 {
12995 h = elf_link_hash_lookup (htab, ".TOC.", FALSE, FALSE, TRUE);
12996 if (is_elf_hash_table (htab))
12997 htab->hgot = h;
12998 }
12999 if (h != NULL
13000 && h->root.type == bfd_link_hash_defined
13001 && !h->root.linker_def
13002 && (!is_elf_hash_table (htab)
13003 || h->def_regular))
13004 {
13005 TOCstart = (h->root.u.def.value - TOC_BASE_OFF
13006 + h->root.u.def.section->output_offset
13007 + h->root.u.def.section->output_section->vma);
13008 _bfd_set_gp_value (obfd, TOCstart);
13009 return TOCstart;
13010 }
13011 }
13012
805fc799
AM		 13013 /* The TOC consists of sections .got, .toc, .tocbss, .plt in that
13014 order. The TOC starts where the first of these sections starts. */
13015 s = bfd_get_section_by_name (obfd, ".got");
e054468f 13016 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
805fc799 13017 s = bfd_get_section_by_name (obfd, ".toc");
e054468f 13018 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
805fc799 13019 s = bfd_get_section_by_name (obfd, ".tocbss");
e054468f 13020 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
805fc799 13021 s = bfd_get_section_by_name (obfd, ".plt");
e054468f 13022 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
805fc799
AM		 13023 {
13024 /* This may happen for
13025 o references to TOC base (SYM@toc / TOC[tc0]) without a
13026 .toc directive
13027 o bad linker script
13028 o --gc-sections and empty TOC sections
13029
13030 FIXME: Warn user? */
13031
13032 /* Look for a likely section. We probably won't even be
13033 using TOCstart. */
13034 for (s = obfd->sections; s != NULL; s = s->next)
e054468f
AM		 13035 if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_READONLY
13036 | SEC_EXCLUDE))
805fc799
AM		 13037 == (SEC_ALLOC | SEC_SMALL_DATA))
13038 break;
721956f4 13039 if (s == NULL)
805fc799 13040 for (s = obfd->sections; s != NULL; s = s->next)
e054468f 13041 if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_EXCLUDE))
805fc799
AM		 13042 == (SEC_ALLOC | SEC_SMALL_DATA))
13043 break;
721956f4 13044 if (s == NULL)
805fc799 13045 for (s = obfd->sections; s != NULL; s = s->next)
e054468f
AM		 13046 if ((s->flags & (SEC_ALLOC | SEC_READONLY | SEC_EXCLUDE))
13047 == SEC_ALLOC)
805fc799 13048 break;
721956f4 13049 if (s == NULL)
805fc799 13050 for (s = obfd->sections; s != NULL; s = s->next)
e054468f 13051 if ((s->flags & (SEC_ALLOC | SEC_EXCLUDE)) == SEC_ALLOC)
805fc799
AM		 13052 break;
13053 }
721956f4 13054
805fc799
AM		 13055 TOCstart = 0;
13056 if (s != NULL)
13057 TOCstart = s->output_section->vma + s->output_offset;
721956f4 13058
a27e685f
AM		 13059 /* Force alignment. */
13060 adjust = TOCstart & (TOC_BASE_ALIGN - 1);
13061 TOCstart -= adjust;
1c865ab2
AM		 13062 _bfd_set_gp_value (obfd, TOCstart);
13063
810d4e75 13064 if (info != NULL && s != NULL)
1c865ab2
AM		 13065 {
13066 struct ppc_link_hash_table *htab = ppc_hash_table (info);
13067
810d4e75
AM		 13068 if (htab != NULL)
13069 {
13070 if (htab->elf.hgot != NULL)
13071 {
a27e685f 13072 htab->elf.hgot->root.u.def.value = TOC_BASE_OFF - adjust;
810d4e75
AM		 13073 htab->elf.hgot->root.u.def.section = s;
13074 }
13075 }
13076 else
1c865ab2 13077 {
810d4e75
AM		 13078 struct bfd_link_hash_entry *bh = NULL;
13079 _bfd_generic_link_add_one_symbol (info, obfd, ".TOC.", BSF_GLOBAL,
a27e685f
AM		 13080 s, TOC_BASE_OFF - adjust,
13081 NULL, FALSE, FALSE, &bh);
1c865ab2
AM		 13082 }
13083 }
805fc799 13084 return TOCstart;
721956f4
AM		 13085}
13086
a345bc8d
AM		 13087/* Called via elf_link_hash_traverse from ppc64_elf_build_stubs to
13088 write out any global entry stubs. */
13089
13090static bfd_boolean
13091build_global_entry_stubs (struct elf_link_hash_entry *h, void *inf)
13092{
13093 struct bfd_link_info *info;
13094 struct ppc_link_hash_table *htab;
13095 struct plt_entry *pent;
13096 asection *s;
13097
13098 if (h->root.type == bfd_link_hash_indirect)
13099 return TRUE;
13100
13101 if (!h->pointer_equality_needed)
13102 return TRUE;
13103
13104 if (h->def_regular)
13105 return TRUE;
13106
13107 info = inf;
13108 htab = ppc_hash_table (info);
13109 if (htab == NULL)
13110 return FALSE;
13111
13112 s = htab->glink;
13113 for (pent = h->plt.plist; pent != NULL; pent = pent->next)
13114 if (pent->plt.offset != (bfd_vma) -1
13115 && pent->addend == 0)
13116 {
13117 bfd_byte *p;
13118 asection *plt;
13119 bfd_vma off;
13120
a345bc8d 13121 p = s->contents + h->root.u.def.value;
33e44f2e 13122 plt = htab->elf.splt;
a345bc8d
AM		 13123 if (!htab->elf.dynamic_sections_created
13124 || h->dynindx == -1)
33e44f2e 13125 plt = htab->elf.iplt;
a345bc8d
AM		 13126 off = pent->plt.offset + plt->output_offset + plt->output_section->vma;
13127 off -= h->root.u.def.value + s->output_offset + s->output_section->vma;
13128
13129 if (off + 0x80008000 > 0xffffffff || (off & 3) != 0)
13130 {
13131 info->callbacks->einfo
13132 (_("%P: linkage table error against `%T'\n"),
13133 h->root.root.string);
13134 bfd_set_error (bfd_error_bad_value);
13135 htab->stub_error = TRUE;
13136 }
13137
7341d5e2
AM		 13138 htab->stub_count[ppc_stub_global_entry - 1] += 1;
13139 if (htab->params->emit_stub_syms)
13140 {
13141 size_t len = strlen (h->root.root.string);
13142 char *name = bfd_malloc (sizeof "12345678.global_entry." + len);
13143
13144 if (name == NULL)
13145 return FALSE;
13146
13147 sprintf (name, "%08x.global_entry.%s", s->id, h->root.root.string);
13148 h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
13149 if (h == NULL)
13150 return FALSE;
13151 if (h->root.type == bfd_link_hash_new)
13152 {
13153 h->root.type = bfd_link_hash_defined;
13154 h->root.u.def.section = s;
13155 h->root.u.def.value = p - s->contents;
13156 h->ref_regular = 1;
13157 h->def_regular = 1;
13158 h->ref_regular_nonweak = 1;
13159 h->forced_local = 1;
13160 h->non_elf = 0;
2ec55de3 13161 h->root.linker_def = 1;
7341d5e2
AM		 13162 }
13163 }
13164
a345bc8d
AM		 13165 if (PPC_HA (off) != 0)
13166 {
13167 bfd_put_32 (s->owner, ADDIS_R12_R12 | PPC_HA (off), p);
13168 p += 4;
13169 }
13170 bfd_put_32 (s->owner, LD_R12_0R12 | PPC_LO (off), p);
13171 p += 4;
13172 bfd_put_32 (s->owner, MTCTR_R12, p);
13173 p += 4;
13174 bfd_put_32 (s->owner, BCTR, p);
13175 break;
13176 }
13177 return TRUE;
13178}
13179
721956f4
AM		 13180/* Build all the stubs associated with the current output file.
13181 The stubs are kept in a hash table attached to the main linker
13182 hash table. This function is called via gldelf64ppc_finish. */
13183
b34976b6 13184bfd_boolean
e7d1c40c 13185ppc64_elf_build_stubs (struct bfd_link_info *info,
4ce794b7 13186 char **stats)
5d1634d7
AM		 13187{
13188 struct ppc_link_hash_table *htab = ppc_hash_table (info);
a4b6fadd 13189 struct map_stub *group;
721956f4 13190 asection *stub_sec;
5d1634d7 13191 bfd_byte *p;
e717da7e 13192 int stub_sec_count = 0;
5d1634d7 13193
4dfe6ac6
NC		 13194 if (htab == NULL)
13195 return FALSE;
13196
eea6121a 13197 /* Allocate memory to hold the linker stubs. */
d4aaa2a0
AM		 13198 for (group = htab->group; group != NULL; group = group->next)
13199 if ((stub_sec = group->stub_sec) != NULL
eea6121a 13200 && stub_sec->size != 0)
e717da7e 13201 {
e7d1c40c 13202 stub_sec->contents = bfd_zalloc (htab->params->stub_bfd, stub_sec->size);
eea6121a
AM		 13203 if (stub_sec->contents == NULL)
13204 return FALSE;
eea6121a 13205 stub_sec->size = 0;
e717da7e 13206 }
5d1634d7 13207
23eb7e01 13208 if (htab->glink != NULL && htab->glink->size != 0)
5d1634d7 13209 {
9f951329 13210 unsigned int indx;
ad8e1ba5 13211 bfd_vma plt0;
9f951329 13212
721956f4 13213 /* Build the .glink plt call stub. */
e7d1c40c 13214 if (htab->params->emit_stub_syms)
97b639ba
AM		 13215 {
13216 struct elf_link_hash_entry *h;
468392fb
AM		 13217 h = elf_link_hash_lookup (&htab->elf, "__glink_PLTresolve",
13218 TRUE, FALSE, FALSE);
97b639ba
AM		 13219 if (h == NULL)
13220 return FALSE;
13221 if (h->root.type == bfd_link_hash_new)
13222 {
13223 h->root.type = bfd_link_hash_defined;
13224 h->root.u.def.section = htab->glink;
ee4bf8d2 13225 h->root.u.def.value = 8;
f5385ebf
AM		 13226 h->ref_regular = 1;
13227 h->def_regular = 1;
13228 h->ref_regular_nonweak = 1;
13229 h->forced_local = 1;
13230 h->non_elf = 0;
2ec55de3 13231 h->root.linker_def = 1;
97b639ba
AM		 13232 }
13233 }
33e44f2e
AM		 13234 plt0 = (htab->elf.splt->output_section->vma
13235 + htab->elf.splt->output_offset
13236 - 16);
176a0d42
AM		 13237 if (info->emitrelocations)
13238 {
13239 Elf_Internal_Rela *r = get_relocs (htab->glink, 1);
13240 if (r == NULL)
13241 return FALSE;
13242 r->r_offset = (htab->glink->output_offset
13243 + htab->glink->output_section->vma);
13244 r->r_info = ELF64_R_INFO (0, R_PPC64_REL64);
13245 r->r_addend = plt0;
13246 }
4ce794b7 13247 p = htab->glink->contents;
176a0d42 13248 plt0 -= htab->glink->output_section->vma + htab->glink->output_offset;
ee4bf8d2
AM		 13249 bfd_put_64 (htab->glink->owner, plt0, p);
13250 p += 8;
b9e5796b
AM		 13251 if (htab->opd_abi)
13252 {
13253 bfd_put_32 (htab->glink->owner, MFLR_R12, p);
13254 p += 4;
13255 bfd_put_32 (htab->glink->owner, BCL_20_31, p);
13256 p += 4;
13257 bfd_put_32 (htab->glink->owner, MFLR_R11, p);
13258 p += 4;
13259 bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
13260 p += 4;
13261 bfd_put_32 (htab->glink->owner, MTLR_R12, p);
13262 p += 4;
13263 bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
13264 p += 4;
13265 bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
13266 p += 4;
13267 bfd_put_32 (htab->glink->owner, LD_R2_0R11 | 8, p);
13268 p += 4;
13269 bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
13270 p += 4;
13271 bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 16, p);
13272 p += 4;
13273 }
13274 else
13275 {
13276 bfd_put_32 (htab->glink->owner, MFLR_R0, p);
13277 p += 4;
13278 bfd_put_32 (htab->glink->owner, BCL_20_31, p);
13279 p += 4;
13280 bfd_put_32 (htab->glink->owner, MFLR_R11, p);
13281 p += 4;
f378ab09
AM		 13282 bfd_put_32 (htab->glink->owner, STD_R2_0R1 + 24, p);
13283 p += 4;
b9e5796b
AM		 13284 bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
13285 p += 4;
13286 bfd_put_32 (htab->glink->owner, MTLR_R0, p);
13287 p += 4;
13288 bfd_put_32 (htab->glink->owner, SUB_R12_R12_R11, p);
13289 p += 4;
13290 bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
13291 p += 4;
13292 bfd_put_32 (htab->glink->owner, ADDI_R0_R12 | (-48 & 0xffff), p);
13293 p += 4;
13294 bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
13295 p += 4;
13296 bfd_put_32 (htab->glink->owner, SRDI_R0_R0_2, p);
13297 p += 4;
13298 bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
13299 p += 4;
13300 bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 8, p);
13301 p += 4;
13302 }
4ce794b7 13303 bfd_put_32 (htab->glink->owner, BCTR, p);
ad8e1ba5 13304 p += 4;
ee4bf8d2
AM		 13305 while (p - htab->glink->contents < GLINK_CALL_STUB_SIZE)
13306 {
13307 bfd_put_32 (htab->glink->owner, NOP, p);
13308 p += 4;
13309 }
ad8e1ba5 13310
9f951329
AM		 13311 /* Build the .glink lazy link call stubs. */
13312 indx = 0;
a345bc8d 13313 while (p < htab->glink->contents + htab->glink->rawsize)
9f951329 13314 {
b9e5796b 13315 if (htab->opd_abi)
9f951329 13316 {
b9e5796b
AM		 13317 if (indx < 0x8000)
13318 {
13319 bfd_put_32 (htab->glink->owner, LI_R0_0 | indx, p);
13320 p += 4;
13321 }
13322 else
13323 {
13324 bfd_put_32 (htab->glink->owner, LIS_R0_0 | PPC_HI (indx), p);
13325 p += 4;
13326 bfd_put_32 (htab->glink->owner, ORI_R0_R0_0 | PPC_LO (indx),
13327 p);
13328 p += 4;
13329 }
9f951329 13330 }
4ce794b7 13331 bfd_put_32 (htab->glink->owner,
ee4bf8d2 13332 B_DOT | ((htab->glink->contents - p + 8) & 0x3fffffc), p);
a16d5acb 13333 indx++;
9f951329
AM		 13334 p += 4;
13335 }
a345bc8d
AM		 13336
13337 /* Build .glink global entry stubs. */
13338 if (htab->glink->size > htab->glink->rawsize)
afe397ea 13339 elf_link_hash_traverse (&htab->elf, build_global_entry_stubs, info);
5d1634d7 13340 }
5d1634d7 13341
7341d5e2 13342 if (htab->brlt != NULL && htab->brlt->size != 0)
721956f4 13343 {
4ce794b7 13344 htab->brlt->contents = bfd_zalloc (htab->brlt->owner,
eea6121a 13345 htab->brlt->size);
4ce794b7 13346 if (htab->brlt->contents == NULL)
b34976b6 13347 return FALSE;
721956f4 13348 }
ee75fd95 13349 if (htab->relbrlt != NULL && htab->relbrlt->size != 0)
63bc6f6c
AM		 13350 {
13351 htab->relbrlt->contents = bfd_zalloc (htab->relbrlt->owner,
eea6121a 13352 htab->relbrlt->size);
63bc6f6c
AM		 13353 if (htab->relbrlt->contents == NULL)
13354 return FALSE;
13355 }
5d1634d7 13356
721956f4
AM		 13357 /* Build the stubs as directed by the stub hash table. */
13358 bfd_hash_traverse (&htab->stub_hash_table, ppc_build_one_stub, info);
5d1634d7 13359
a4b6fadd
AM		 13360 for (group = htab->group; group != NULL; group = group->next)
13361 if (group->needs_save_res)
13362 {
13363 stub_sec = group->stub_sec;
13364 memcpy (stub_sec->contents + stub_sec->size, htab->sfpr->contents,
13365 htab->sfpr->size);
13366 if (htab->params->emit_stub_syms)
13367 {
13368 unsigned int i;
13369
13370 for (i = 0; i < ARRAY_SIZE (save_res_funcs); i++)
13371 if (!sfpr_define (info, &save_res_funcs[i], stub_sec))
13372 return FALSE;
13373 }
13374 stub_sec->size += htab->sfpr->size;
13375 }
13376
aa8a7074
AM		 13377 if (htab->relbrlt != NULL)
13378 htab->relbrlt->reloc_count = 0;
13379
e7d1c40c 13380 if (htab->params->plt_stub_align != 0)
d4aaa2a0
AM		 13381 for (group = htab->group; group != NULL; group = group->next)
13382 if ((stub_sec = group->stub_sec) != NULL)
e7d1c40c
AM		 13383 stub_sec->size = ((stub_sec->size
13384 + (1 << htab->params->plt_stub_align) - 1)
29f628db 13385 & -(1 << htab->params->plt_stub_align));
794e51c0 13386
d4aaa2a0
AM		 13387 for (group = htab->group; group != NULL; group = group->next)
13388 if ((stub_sec = group->stub_sec) != NULL)
e717da7e
AM		 13389 {
13390 stub_sec_count += 1;
c9301e31
AM		 13391 if (stub_sec->rawsize != stub_sec->size
13392 && (htab->stub_iteration <= STUB_SHRINK_ITER
13393 || stub_sec->rawsize < stub_sec->size))
e717da7e
AM		 13394 break;
13395 }
5d1634d7 13396
da44f4e5
AM		 13397 /* Note that the glink_eh_frame check here is not only testing that
13398 the generated size matched the calculated size but also that
13399 bfd_elf_discard_info didn't make any changes to the section. */
d4aaa2a0 13400 if (group != NULL
58d180e8
AM		 13401 || (htab->glink_eh_frame != NULL
13402 && htab->glink_eh_frame->rawsize != htab->glink_eh_frame->size))
5d1634d7 13403 {
b34976b6 13404 htab->stub_error = TRUE;
8de848d8 13405 info->callbacks->einfo (_("%P: stubs don't match calculated size\n"));
5d1634d7 13406 }
721956f4 13407
d2a300cf
AM		 13408 if (htab->stub_error)
13409 return FALSE;
13410
13411 if (stats != NULL)
13412 {
13413 *stats = bfd_malloc (500);
13414 if (*stats == NULL)
13415 return FALSE;
13416
ee75fd95 13417 sprintf (*stats, _("linker stubs in %u group%s\n"
d2a300cf
AM		 13418 " branch %lu\n"
13419 " toc adjust %lu\n"
13420 " long branch %lu\n"
13421 " long toc adj %lu\n"
794e51c0 13422 " plt call %lu\n"
7341d5e2
AM		 13423 " plt call toc %lu\n"
13424 " global entry %lu"),
e717da7e 13425 stub_sec_count,
ee75fd95 13426 stub_sec_count == 1 ? "" : "s",
4ce794b7
AM		 13427 htab->stub_count[ppc_stub_long_branch - 1],
13428 htab->stub_count[ppc_stub_long_branch_r2off - 1],
13429 htab->stub_count[ppc_stub_plt_branch - 1],
13430 htab->stub_count[ppc_stub_plt_branch_r2off - 1],
794e51c0 13431 htab->stub_count[ppc_stub_plt_call - 1],
7341d5e2
AM		 13432 htab->stub_count[ppc_stub_plt_call_r2save - 1],
13433 htab->stub_count[ppc_stub_global_entry - 1]);
d2a300cf
AM		 13434 }
13435 return TRUE;
5bd4f169
AM		 13436}
13437
60124e18
AM		 13438/* What to do when ld finds relocations against symbols defined in
13439 discarded sections. */
13440
13441static unsigned int
13442ppc64_elf_action_discarded (asection *sec)
13443{
13444 if (strcmp (".opd", sec->name) == 0)
13445 return 0;
13446
13447 if (strcmp (".toc", sec->name) == 0)
13448 return 0;
13449
bce50a28
JJ		 13450 if (strcmp (".toc1", sec->name) == 0)
13451 return 0;
13452
60124e18
AM		 13453 return _bfd_elf_default_action_discarded (sec);
13454}
13455
5bd4f169
AM		 13456/* The RELOCATE_SECTION function is called by the ELF backend linker
13457 to handle the relocations for a section.
13458
13459 The relocs are always passed as Rela structures; if the section
13460 actually uses Rel structures, the r_addend field will always be
13461 zero.
13462
13463 This function is responsible for adjust the section contents as
13464 necessary, and (if using Rela relocs and generating a
1049f94e 13465 relocatable output file) adjusting the reloc addend as
5bd4f169
AM		 13466 necessary.
13467
13468 This function does not have to worry about setting the reloc
13469 address or the reloc symbol index.
13470
13471 LOCAL_SYMS is a pointer to the swapped in local symbols.
13472
13473 LOCAL_SECTIONS is an array giving the section in the input file
13474 corresponding to the st_shndx field of each local symbol.
13475
13476 The global hash table entry for the global symbols can be found
13477 via elf_sym_hashes (input_bfd).
13478
1049f94e 13479 When generating relocatable output, this function must handle
5bd4f169
AM		 13480 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
13481 going to be the section symbol corresponding to the output
13482 section, which means that the addend must be adjusted
13483 accordingly. */
13484
b34976b6 13485static bfd_boolean
4ce794b7
AM		 13486ppc64_elf_relocate_section (bfd *output_bfd,
13487 struct bfd_link_info *info,
13488 bfd *input_bfd,
13489 asection *input_section,
13490 bfd_byte *contents,
13491 Elf_Internal_Rela *relocs,
13492 Elf_Internal_Sym *local_syms,
13493 asection **local_sections)
5bd4f169 13494{
65f38f15 13495 struct ppc_link_hash_table *htab;
5bd4f169
AM		 13496 Elf_Internal_Shdr *symtab_hdr;
13497 struct elf_link_hash_entry **sym_hashes;
5bd4f169 13498 Elf_Internal_Rela *rel;
c316a17c 13499 Elf_Internal_Rela *wrel;
5bd4f169 13500 Elf_Internal_Rela *relend;
411e1bfb
AM		 13501 Elf_Internal_Rela outrel;
13502 bfd_byte *loc;
411e1bfb 13503 struct got_entry **local_got_ents;
5bd4f169 13504 bfd_vma TOCstart;
b34976b6
AM		 13505 bfd_boolean ret = TRUE;
13506 bfd_boolean is_opd;
794e51c0
AM		 13507 /* Assume 'at' branch hints. */
13508 bfd_boolean is_isa_v2 = TRUE;
95f0d0d2 13509 bfd_vma d_offset = (bfd_big_endian (input_bfd) ? 2 : 0);
5bd4f169 13510
65f38f15 13511 /* Initialize howto table if needed. */
5bd4f169 13512 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
5bd4f169
AM		 13513 ppc_howto_init ();
13514
65f38f15 13515 htab = ppc_hash_table (info);
4dfe6ac6
NC		 13516 if (htab == NULL)
13517 return FALSE;
ee75fd95
AM		 13518
13519 /* Don't relocate stub sections. */
e7d1c40c 13520 if (input_section->owner == htab->params->stub_bfd)
ee75fd95
AM		 13521 return TRUE;
13522
0c8d6e5c 13523 BFD_ASSERT (is_ppc64_elf (input_bfd));
0ffa91dd 13524
411e1bfb 13525 local_got_ents = elf_local_got_ents (input_bfd);
5bd4f169 13526 TOCstart = elf_gp (output_bfd);
0ffa91dd 13527 symtab_hdr = &elf_symtab_hdr (input_bfd);
5bd4f169 13528 sym_hashes = elf_sym_hashes (input_bfd);
7c8fe5c4 13529 is_opd = ppc64_elf_section_data (input_section)->sec_type == sec_opd;
65f38f15 13530
c316a17c 13531 rel = wrel = relocs;
5bd4f169 13532 relend = relocs + input_section->reloc_count;
c316a17c 13533 for (; rel < relend; wrel++, rel++)
5bd4f169 13534 {
04c9666a 13535 enum elf_ppc64_reloc_type r_type;
31c76678 13536 bfd_vma addend;
5bd4f169
AM		 13537 bfd_reloc_status_type r;
13538 Elf_Internal_Sym *sym;
13539 asection *sec;
039b3fef
AM		 13540 struct elf_link_hash_entry *h_elf;
13541 struct ppc_link_hash_entry *h;
13542 struct ppc_link_hash_entry *fdh;
5bd4f169 13543 const char *sym_name;
0d4792f7 13544 unsigned long r_symndx, toc_symndx;
3a71aa26 13545 bfd_vma toc_addend;
f961d9dd
AM		 13546 unsigned char tls_mask, tls_gd, tls_type;
13547 unsigned char sym_type;
5bd4f169 13548 bfd_vma relocation;
b34976b6
AM		 13549 bfd_boolean unresolved_reloc;
13550 bfd_boolean warned;
bc30df16 13551 enum { DEST_NORMAL, DEST_OPD, DEST_STUB } reloc_dest;
67f0cbdb 13552 unsigned int insn;
e11840f9 13553 unsigned int mask;
721956f4
AM		 13554 struct ppc_stub_hash_entry *stub_entry;
13555 bfd_vma max_br_offset;
13556 bfd_vma from;
c316a17c 13557 Elf_Internal_Rela orig_rel;
b80eed39
AM		 13558 reloc_howto_type *howto;
13559 struct reloc_howto_struct alt_howto;
5bd4f169 13560
c316a17c
AM		 13561 again:
13562 orig_rel = *rel;
13563
4ce794b7 13564 r_type = ELF64_R_TYPE (rel->r_info);
5bd4f169 13565 r_symndx = ELF64_R_SYM (rel->r_info);
ee87f2da
AM		 13566
13567 /* For old style R_PPC64_TOC relocs with a zero symbol, use the
13568 symbol of the previous ADDR64 reloc. The symbol gives us the
13569 proper TOC base to use. */
13570 if (rel->r_info == ELF64_R_INFO (0, R_PPC64_TOC)
c316a17c
AM		 13571 && wrel != relocs
13572 && ELF64_R_TYPE (wrel[-1].r_info) == R_PPC64_ADDR64
ee87f2da 13573 && is_opd)
c316a17c 13574 r_symndx = ELF64_R_SYM (wrel[-1].r_info);
ee87f2da 13575
4ce794b7
AM		 13576 sym = NULL;
13577 sec = NULL;
039b3fef 13578 h_elf = NULL;
4ce794b7 13579 sym_name = NULL;
b34976b6
AM		 13580 unresolved_reloc = FALSE;
13581 warned = FALSE;
65f38f15 13582
0b13192e 13583 if (r_symndx < symtab_hdr->sh_info)
5bd4f169
AM		 13584 {
13585 /* It's a local symbol. */
74f0fb50 13586 struct _opd_sec_data *opd;
4025353c 13587
5bd4f169
AM		 13588 sym = local_syms + r_symndx;
13589 sec = local_sections[r_symndx];
26c61ae5 13590 sym_name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym, sec);
0d4792f7 13591 sym_type = ELF64_ST_TYPE (sym->st_info);
8517fae7 13592 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
74f0fb50
AM		 13593 opd = get_opd_info (sec);
13594 if (opd != NULL && opd->adjust != NULL)
1e2f5b6e 13595 {
51aecdc5
AM		 13596 long adjust = opd->adjust[OPD_NDX (sym->st_value
13597 + rel->r_addend)];
4025353c
AM		 13598 if (adjust == -1)
13599 relocation = 0;
13600 else
4cc603a5
AM		 13601 {
13602 /* If this is a relocation against the opd section sym
13603 and we have edited .opd, adjust the reloc addend so
13604 that ld -r and ld --emit-relocs output is correct.
13605 If it is a reloc against some other .opd symbol,
13606 then the symbol value will be adjusted later. */
13607 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
13608 rel->r_addend += adjust;
13609 else
13610 relocation += adjust;
13611 }
1e2f5b6e 13612 }
5bd4f169
AM		 13613 }
13614 else
13615 {
62d887d4
L		 13616 bfd_boolean ignored;
13617
b2a8e766
AM		 13618 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
13619 r_symndx, symtab_hdr, sym_hashes,
039b3fef 13620 h_elf, sec, relocation,
62d887d4 13621 unresolved_reloc, warned, ignored);
039b3fef
AM		 13622 sym_name = h_elf->root.root.string;
13623 sym_type = h_elf->type;
b69fdb4e
AM		 13624 if (sec != NULL
13625 && sec->owner == output_bfd
13626 && strcmp (sec->name, ".opd") == 0)
13627 {
13628 /* This is a symbol defined in a linker script. All
13629 such are defined in output sections, even those
13630 defined by simple assignment from a symbol defined in
13631 an input section. Transfer the symbol to an
13632 appropriate input .opd section, so that a branch to
13633 this symbol will be mapped to the location specified
13634 by the opd entry. */
13635 struct bfd_link_order *lo;
13636 for (lo = sec->map_head.link_order; lo != NULL; lo = lo->next)
13637 if (lo->type == bfd_indirect_link_order)
13638 {
13639 asection *isec = lo->u.indirect.section;
13640 if (h_elf->root.u.def.value >= isec->output_offset
13641 && h_elf->root.u.def.value < (isec->output_offset
13642 + isec->size))
13643 {
13644 h_elf->root.u.def.value -= isec->output_offset;
13645 h_elf->root.u.def.section = isec;
13646 sec = isec;
13647 break;
13648 }
13649 }
13650 }
5bd4f169 13651 }
039b3fef 13652 h = (struct ppc_link_hash_entry *) h_elf;
5bd4f169 13653
dbaa2011 13654 if (sec != NULL && discarded_section (sec))
c316a17c
AM		 13655 {
13656 _bfd_clear_contents (ppc64_elf_howto_table[r_type],
13657 input_bfd, input_section,
13658 contents + rel->r_offset);
13659 wrel->r_offset = rel->r_offset;
13660 wrel->r_info = 0;
13661 wrel->r_addend = 0;
13662
13663 /* For ld -r, remove relocations in debug sections against
13664 sections defined in discarded sections. Not done for
13665 non-debug to preserve relocs in .eh_frame which the
13666 eh_frame editing code expects to be present. */
13667 if (bfd_link_relocatable (info)
13668 && (input_section->flags & SEC_DEBUGGING))
13669 wrel--;
13670
13671 continue;
13672 }
ab96bf03 13673
0e1862bb 13674 if (bfd_link_relocatable (info))
c316a17c 13675 goto copy_reloc;
ab96bf03 13676
f40da81b
AM		 13677 if (h != NULL && &h->elf == htab->elf.hgot)
13678 {
6f20ed8a 13679 relocation = TOCstart + htab->sec_info[input_section->id].toc_off;
f40da81b
AM		 13680 sec = bfd_abs_section_ptr;
13681 unresolved_reloc = FALSE;
13682 }
13683
951fd09b
AM		 13684 /* TLS optimizations. Replace instruction sequences and relocs
13685 based on information we collected in tls_optimize. We edit
13686 RELOCS so that --emit-relocs will output something sensible
13687 for the final instruction stream. */
13688 tls_mask = 0;
13689 tls_gd = 0;
0d4792f7 13690 toc_symndx = 0;
727fc41e
AM		 13691 if (h != NULL)
13692 tls_mask = h->tls_mask;
13693 else if (local_got_ents != NULL)
411e1bfb 13694 {
e054468f
AM		 13695 struct plt_entry **local_plt = (struct plt_entry **)
13696 (local_got_ents + symtab_hdr->sh_info);
f961d9dd 13697 unsigned char *lgot_masks = (unsigned char *)
e054468f 13698 (local_plt + symtab_hdr->sh_info);
727fc41e
AM		 13699 tls_mask = lgot_masks[r_symndx];
13700 }
13701 if (tls_mask == 0
13702 && (r_type == R_PPC64_TLS
13703 || r_type == R_PPC64_TLSGD
13704 || r_type == R_PPC64_TLSLD))
13705 {
13706 /* Check for toc tls entries. */
f961d9dd 13707 unsigned char *toc_tls;
0d4792f7 13708
727fc41e
AM		 13709 if (!get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
13710 &local_syms, rel, input_bfd))
13711 return FALSE;
0d4792f7 13712
727fc41e
AM		 13713 if (toc_tls)
13714 tls_mask = *toc_tls;
0d4792f7
AM		 13715 }
13716
13717 /* Check that tls relocs are used with tls syms, and non-tls
13718 relocs are used with non-tls syms. */
cf35638d 13719 if (r_symndx != STN_UNDEF
0d4792f7
AM		 13720 && r_type != R_PPC64_NONE
13721 && (h == NULL
039b3fef
AM		 13722 || h->elf.root.type == bfd_link_hash_defined
13723 || h->elf.root.type == bfd_link_hash_defweak)
1d483afe
AM		 13724 && (IS_PPC64_TLS_RELOC (r_type)
13725 != (sym_type == STT_TLS
13726 || (sym_type == STT_SECTION
13727 && (sec->flags & SEC_THREAD_LOCAL) != 0))))
0d4792f7 13728 {
727fc41e
AM		 13729 if (tls_mask != 0
13730 && (r_type == R_PPC64_TLS
13731 || r_type == R_PPC64_TLSGD
13732 || r_type == R_PPC64_TLSLD))
0d4792f7
AM		 13733 /* R_PPC64_TLS is OK against a symbol in the TOC. */
13734 ;
13735 else
25f53a85 13736 info->callbacks->einfo
1d483afe 13737 (!IS_PPC64_TLS_RELOC (r_type)
695344c0 13738 /* xgettext:c-format */
174d0a74 13739 ? _("%H: %s used with TLS symbol `%T'\n")
695344c0 13740 /* xgettext:c-format */
174d0a74 13741 : _("%H: %s used with non-TLS symbol `%T'\n"),
25f53a85 13742 input_bfd, input_section, rel->r_offset,
0d4792f7
AM		 13743 ppc64_elf_howto_table[r_type]->name,
13744 sym_name);
411e1bfb
AM		 13745 }
13746
13747 /* Ensure reloc mapping code below stays sane. */
13748 if (R_PPC64_TOC16_LO_DS != R_PPC64_TOC16_DS + 1
13749 || R_PPC64_TOC16_LO != R_PPC64_TOC16 + 1
13750 || (R_PPC64_GOT_TLSLD16 & 3) != (R_PPC64_GOT_TLSGD16 & 3)
13751 || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TLSGD16_LO & 3)
13752 || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TLSGD16_HI & 3)
13753 || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TLSGD16_HA & 3)
13754 || (R_PPC64_GOT_TLSLD16 & 3) != (R_PPC64_GOT_TPREL16_DS & 3)
13755 || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TPREL16_LO_DS & 3)
13756 || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TPREL16_HI & 3)
13757 || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TPREL16_HA & 3))
13758 abort ();
0d4792f7 13759
411e1bfb
AM		 13760 switch (r_type)
13761 {
13762 default:
411e1bfb
AM		 13763 break;
13764
ba761f19 13765 case R_PPC64_LO_DS_OPT:
95f0d0d2 13766 insn = bfd_get_32 (input_bfd, contents + rel->r_offset - d_offset);
ba761f19
AM		 13767 if ((insn & (0x3f << 26)) != 58u << 26)
13768 abort ();
13769 insn += (14u << 26) - (58u << 26);
95f0d0d2 13770 bfd_put_32 (input_bfd, insn, contents + rel->r_offset - d_offset);
ba761f19
AM		 13771 r_type = R_PPC64_TOC16_LO;
13772 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13773 break;
13774
411e1bfb
AM		 13775 case R_PPC64_TOC16:
13776 case R_PPC64_TOC16_LO:
13777 case R_PPC64_TOC16_DS:
13778 case R_PPC64_TOC16_LO_DS:
411e1bfb
AM		 13779 {
13780 /* Check for toc tls entries. */
f961d9dd 13781 unsigned char *toc_tls;
951fd09b 13782 int retval;
411e1bfb 13783
3a71aa26
AM		 13784 retval = get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
13785 &local_syms, rel, input_bfd);
951fd09b 13786 if (retval == 0)
411e1bfb
AM		 13787 return FALSE;
13788
13789 if (toc_tls)
13790 {
951fd09b 13791 tls_mask = *toc_tls;
411e1bfb
AM		 13792 if (r_type == R_PPC64_TOC16_DS
13793 || r_type == R_PPC64_TOC16_LO_DS)
81407a69
AM		 13794 {
13795 if (tls_mask != 0
13796 && (tls_mask & (TLS_DTPREL | TLS_TPREL)) == 0)
13797 goto toctprel;
13798 }
411e1bfb 13799 else
951fd09b
AM		 13800 {
13801 /* If we found a GD reloc pair, then we might be
13802 doing a GD->IE transition. */
13803 if (retval == 2)
13804 {
13805 tls_gd = TLS_TPRELGD;
13806 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
102890f0 13807 goto tls_ldgd_opt;
951fd09b
AM		 13808 }
13809 else if (retval == 3)
13810 {
13811 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
102890f0 13812 goto tls_ldgd_opt;
951fd09b
AM		 13813 }
13814 }
411e1bfb
AM		 13815 }
13816 }
13817 break;
13818
9d6ded02
AM		 13819 case R_PPC64_GOT_TPREL16_HI:
13820 case R_PPC64_GOT_TPREL16_HA:
13821 if (tls_mask != 0
13822 && (tls_mask & TLS_TPREL) == 0)
13823 {
13824 rel->r_offset -= d_offset;
95f0d0d2 13825 bfd_put_32 (input_bfd, NOP, contents + rel->r_offset);
9d6ded02
AM		 13826 r_type = R_PPC64_NONE;
13827 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13828 }
13829 break;
13830
411e1bfb
AM		 13831 case R_PPC64_GOT_TPREL16_DS:
13832 case R_PPC64_GOT_TPREL16_LO_DS:
951fd09b
AM		 13833 if (tls_mask != 0
13834 && (tls_mask & TLS_TPREL) == 0)
411e1bfb 13835 {
81407a69 13836 toctprel:
95f0d0d2 13837 insn = bfd_get_32 (input_bfd,
c316a17c 13838 contents + rel->r_offset - d_offset);
411e1bfb
AM		 13839 insn &= 31 << 21;
13840 insn |= 0x3c0d0000; /* addis 0,13,0 */
95f0d0d2 13841 bfd_put_32 (input_bfd, insn,
c316a17c 13842 contents + rel->r_offset - d_offset);
411e1bfb 13843 r_type = R_PPC64_TPREL16_HA;
0d4792f7
AM		 13844 if (toc_symndx != 0)
13845 {
13846 rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
3a71aa26 13847 rel->r_addend = toc_addend;
0d4792f7
AM		 13848 /* We changed the symbol. Start over in order to
13849 get h, sym, sec etc. right. */
c316a17c 13850 goto again;
0d4792f7
AM		 13851 }
13852 else
13853 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
411e1bfb
AM		 13854 }
13855 break;
13856
13857 case R_PPC64_TLS:
951fd09b
AM		 13858 if (tls_mask != 0
13859 && (tls_mask & TLS_TPREL) == 0)
411e1bfb 13860 {
95f0d0d2 13861 insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
2d0f3896
AM		 13862 insn = _bfd_elf_ppc_at_tls_transform (insn, 13);
13863 if (insn == 0)
411e1bfb 13864 abort ();
95f0d0d2 13865 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
411e1bfb 13866 /* Was PPC64_TLS which sits on insn boundary, now
4fe5ca5b
GM		 13867 PPC64_TPREL16_LO which is at low-order half-word. */
13868 rel->r_offset += d_offset;
0d4792f7
AM		 13869 r_type = R_PPC64_TPREL16_LO;
13870 if (toc_symndx != 0)
13871 {
13872 rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
3a71aa26 13873 rel->r_addend = toc_addend;
0d4792f7
AM		 13874 /* We changed the symbol. Start over in order to
13875 get h, sym, sec etc. right. */
c316a17c 13876 goto again;
0d4792f7
AM		 13877 }
13878 else
13879 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
411e1bfb
AM		 13880 }
13881 break;
13882
411e1bfb
AM		 13883 case R_PPC64_GOT_TLSGD16_HI:
13884 case R_PPC64_GOT_TLSGD16_HA:
951fd09b
AM		 13885 tls_gd = TLS_TPRELGD;
13886 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13887 goto tls_gdld_hi;
13888 break;
13889
411e1bfb
AM		 13890 case R_PPC64_GOT_TLSLD16_HI:
13891 case R_PPC64_GOT_TLSLD16_HA:
951fd09b 13892 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
411e1bfb 13893 {
951fd09b
AM		 13894 tls_gdld_hi:
13895 if ((tls_mask & tls_gd) != 0)
13896 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
13897 + R_PPC64_GOT_TPREL16_DS);
13898 else
411e1bfb 13899 {
4fe5ca5b 13900 rel->r_offset -= d_offset;
95f0d0d2 13901 bfd_put_32 (input_bfd, NOP, contents + rel->r_offset);
951fd09b 13902 r_type = R_PPC64_NONE;
411e1bfb 13903 }
951fd09b 13904 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
411e1bfb
AM		 13905 }
13906 break;
13907
951fd09b
AM		 13908 case R_PPC64_GOT_TLSGD16:
13909 case R_PPC64_GOT_TLSGD16_LO:
13910 tls_gd = TLS_TPRELGD;
13911 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
102890f0 13912 goto tls_ldgd_opt;
951fd09b 13913 break;
411e1bfb 13914
951fd09b
AM		 13915 case R_PPC64_GOT_TLSLD16:
13916 case R_PPC64_GOT_TLSLD16_LO:
13917 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13918 {
3a71aa26 13919 unsigned int insn1, insn2, insn3;
102890f0
AM		 13920 bfd_vma offset;
13921
13922 tls_ldgd_opt:
727fc41e
AM		 13923 offset = (bfd_vma) -1;
13924 /* If not using the newer R_PPC64_TLSGD/LD to mark
13925 __tls_get_addr calls, we must trust that the call
13926 stays with its arg setup insns, ie. that the next
13927 reloc is the __tls_get_addr call associated with
13928 the current reloc. Edit both insns. */
13929 if (input_section->has_tls_get_addr_call
13930 && rel + 1 < relend
13931 && branch_reloc_hash_match (input_bfd, rel + 1,
13932 htab->tls_get_addr,
13933 htab->tls_get_addr_fd))
13934 offset = rel[1].r_offset;
b86ac8e3
AM		 13935 /* We read the low GOT_TLS (or TOC16) insn because we
13936 need to keep the destination reg. It may be
13937 something other than the usual r3, and moved to r3
13938 before the call by intervening code. */
95f0d0d2 13939 insn1 = bfd_get_32 (input_bfd,
b86ac8e3 13940 contents + rel->r_offset - d_offset);
102890f0 13941 if ((tls_mask & tls_gd) != 0)
411e1bfb 13942 {
102890f0 13943 /* IE */
b86ac8e3 13944 insn1 &= (0x1f << 21) | (0x1f << 16);
102890f0
AM		 13945 insn1 |= 58 << 26; /* ld */
13946 insn2 = 0x7c636a14; /* add 3,3,13 */
727fc41e 13947 if (offset != (bfd_vma) -1)
f58d5a2d 13948 rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
102890f0
AM		 13949 if ((tls_mask & TLS_EXPLICIT) == 0)
13950 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
13951 + R_PPC64_GOT_TPREL16_DS);
411e1bfb 13952 else
102890f0
AM		 13953 r_type += R_PPC64_TOC16_DS - R_PPC64_TOC16;
13954 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13955 }
13956 else
13957 {
13958 /* LE */
b86ac8e3
AM		 13959 insn1 &= 0x1f << 21;
13960 insn1 |= 0x3c0d0000; /* addis r,13,0 */
102890f0
AM		 13961 insn2 = 0x38630000; /* addi 3,3,0 */
13962 if (tls_gd == 0)
951fd09b 13963 {
102890f0 13964 /* Was an LD reloc. */
1d483afe
AM		 13965 if (toc_symndx)
13966 sec = local_sections[toc_symndx];
13967 for (r_symndx = 0;
13968 r_symndx < symtab_hdr->sh_info;
13969 r_symndx++)
13970 if (local_sections[r_symndx] == sec)
13971 break;
13972 if (r_symndx >= symtab_hdr->sh_info)
cf35638d 13973 r_symndx = STN_UNDEF;
102890f0 13974 rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
cf35638d 13975 if (r_symndx != STN_UNDEF)
1d483afe
AM		 13976 rel->r_addend -= (local_syms[r_symndx].st_value
13977 + sec->output_offset
13978 + sec->output_section->vma);
951fd09b 13979 }
102890f0 13980 else if (toc_symndx != 0)
3a71aa26
AM		 13981 {
13982 r_symndx = toc_symndx;
13983 rel->r_addend = toc_addend;
13984 }
102890f0
AM		 13985 r_type = R_PPC64_TPREL16_HA;
13986 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
727fc41e
AM		 13987 if (offset != (bfd_vma) -1)
13988 {
13989 rel[1].r_info = ELF64_R_INFO (r_symndx,
13990 R_PPC64_TPREL16_LO);
13991 rel[1].r_offset = offset + d_offset;
13992 rel[1].r_addend = rel->r_addend;
13993 }
102890f0 13994 }
95f0d0d2 13995 bfd_put_32 (input_bfd, insn1,
3a71aa26 13996 contents + rel->r_offset - d_offset);
727fc41e
AM		 13997 if (offset != (bfd_vma) -1)
13998 {
95f0d0d2 13999 insn3 = bfd_get_32 (input_bfd,
727fc41e
AM		 14000 contents + offset + 4);
14001 if (insn3 == NOP
14002 || insn3 == CROR_151515 || insn3 == CROR_313131)
14003 {
14004 rel[1].r_offset += 4;
95f0d0d2 14005 bfd_put_32 (input_bfd, insn2, contents + offset + 4);
727fc41e
AM		 14006 insn2 = NOP;
14007 }
95f0d0d2 14008 bfd_put_32 (input_bfd, insn2, contents + offset);
727fc41e
AM		 14009 }
14010 if ((tls_mask & tls_gd) == 0
14011 && (tls_gd == 0 || toc_symndx != 0))
14012 {
14013 /* We changed the symbol. Start over in order
14014 to get h, sym, sec etc. right. */
c316a17c 14015 goto again;
727fc41e
AM		 14016 }
14017 }
14018 break;
14019
14020 case R_PPC64_TLSGD:
14021 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
14022 {
14023 unsigned int insn2, insn3;
14024 bfd_vma offset = rel->r_offset;
14025
14026 if ((tls_mask & TLS_TPRELGD) != 0)
14027 {
14028 /* IE */
14029 r_type = R_PPC64_NONE;
14030 insn2 = 0x7c636a14; /* add 3,3,13 */
14031 }
14032 else
14033 {
14034 /* LE */
14035 if (toc_symndx != 0)
14036 {
14037 r_symndx = toc_symndx;
14038 rel->r_addend = toc_addend;
14039 }
14040 r_type = R_PPC64_TPREL16_LO;
14041 rel->r_offset = offset + d_offset;
14042 insn2 = 0x38630000; /* addi 3,3,0 */
14043 }
14044 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14045 /* Zap the reloc on the _tls_get_addr call too. */
14046 BFD_ASSERT (offset == rel[1].r_offset);
f58d5a2d 14047 rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
95f0d0d2 14048 insn3 = bfd_get_32 (input_bfd,
3a71aa26 14049 contents + offset + 4);
102890f0
AM		 14050 if (insn3 == NOP
14051 || insn3 == CROR_151515 || insn3 == CROR_313131)
14052 {
727fc41e 14053 rel->r_offset += 4;
95f0d0d2 14054 bfd_put_32 (input_bfd, insn2, contents + offset + 4);
3a71aa26 14055 insn2 = NOP;
102890f0 14056 }
95f0d0d2 14057 bfd_put_32 (input_bfd, insn2, contents + offset);
727fc41e 14058 if ((tls_mask & TLS_TPRELGD) == 0 && toc_symndx != 0)
c316a17c 14059 goto again;
411e1bfb 14060 }
411e1bfb
AM		 14061 break;
14062
727fc41e
AM		 14063 case R_PPC64_TLSLD:
14064 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
14065 {
14066 unsigned int insn2, insn3;
14067 bfd_vma offset = rel->r_offset;
14068
14069 if (toc_symndx)
14070 sec = local_sections[toc_symndx];
14071 for (r_symndx = 0;
14072 r_symndx < symtab_hdr->sh_info;
14073 r_symndx++)
14074 if (local_sections[r_symndx] == sec)
14075 break;
14076 if (r_symndx >= symtab_hdr->sh_info)
cf35638d 14077 r_symndx = STN_UNDEF;
727fc41e 14078 rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
cf35638d 14079 if (r_symndx != STN_UNDEF)
727fc41e
AM		 14080 rel->r_addend -= (local_syms[r_symndx].st_value
14081 + sec->output_offset
14082 + sec->output_section->vma);
14083
14084 r_type = R_PPC64_TPREL16_LO;
14085 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14086 rel->r_offset = offset + d_offset;
14087 /* Zap the reloc on the _tls_get_addr call too. */
14088 BFD_ASSERT (offset == rel[1].r_offset);
f58d5a2d 14089 rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
727fc41e 14090 insn2 = 0x38630000; /* addi 3,3,0 */
95f0d0d2 14091 insn3 = bfd_get_32 (input_bfd,
727fc41e
AM		 14092 contents + offset + 4);
14093 if (insn3 == NOP
14094 || insn3 == CROR_151515 || insn3 == CROR_313131)
14095 {
14096 rel->r_offset += 4;
95f0d0d2 14097 bfd_put_32 (input_bfd, insn2, contents + offset + 4);
727fc41e
AM		 14098 insn2 = NOP;
14099 }
95f0d0d2 14100 bfd_put_32 (input_bfd, insn2, contents + offset);
c316a17c 14101 goto again;
727fc41e
AM		 14102 }
14103 break;
14104
411e1bfb 14105 case R_PPC64_DTPMOD64:
951fd09b
AM		 14106 if (rel + 1 < relend
14107 && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
14108 && rel[1].r_offset == rel->r_offset + 8)
411e1bfb 14109 {
951fd09b
AM		 14110 if ((tls_mask & TLS_GD) == 0)
14111 {
14112 rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_NONE);
14113 if ((tls_mask & TLS_TPRELGD) != 0)
14114 r_type = R_PPC64_TPREL64;
14115 else
14116 {
4ce794b7 14117 bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
951fd09b
AM		 14118 r_type = R_PPC64_NONE;
14119 }
14120 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14121 }
14122 }
14123 else
14124 {
14125 if ((tls_mask & TLS_LD) == 0)
411e1bfb 14126 {
4ce794b7 14127 bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
411e1bfb 14128 r_type = R_PPC64_NONE;
951fd09b 14129 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
411e1bfb 14130 }
411e1bfb
AM		 14131 }
14132 break;
14133
14134 case R_PPC64_TPREL64:
951fd09b 14135 if ((tls_mask & TLS_TPREL) == 0)
411e1bfb
AM		 14136 {
14137 r_type = R_PPC64_NONE;
14138 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14139 }
14140 break;
52a82034 14141
006589cf
AM		 14142 case R_PPC64_ENTRY:
14143 relocation = TOCstart + htab->sec_info[input_section->id].toc_off;
14144 if (!bfd_link_pic (info)
14145 && !info->traditional_format
14146 && relocation + 0x80008000 <= 0xffffffff)
14147 {
14148 unsigned int insn1, insn2;
14149
14150 insn1 = bfd_get_32 (input_bfd, contents + rel->r_offset);
14151 insn2 = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
14152 if ((insn1 & ~0xfffc) == LD_R2_0R12
14153 && insn2 == ADD_R2_R2_R12)
14154 {
95f0d0d2 14155 bfd_put_32 (input_bfd,
006589cf
AM		 14156 LIS_R2 + PPC_HA (relocation),
14157 contents + rel->r_offset);
95f0d0d2 14158 bfd_put_32 (input_bfd,
006589cf
AM		 14159 ADDI_R2_R2 + PPC_LO (relocation),
14160 contents + rel->r_offset + 4);
14161 }
14162 }
14163 else
14164 {
14165 relocation -= (rel->r_offset
14166 + input_section->output_offset
14167 + input_section->output_section->vma);
14168 if (relocation + 0x80008000 <= 0xffffffff)
14169 {
14170 unsigned int insn1, insn2;
14171
14172 insn1 = bfd_get_32 (input_bfd, contents + rel->r_offset);
14173 insn2 = bfd_get_32 (input_bfd, contents + rel->r_offset + 4);
14174 if ((insn1 & ~0xfffc) == LD_R2_0R12
14175 && insn2 == ADD_R2_R2_R12)
14176 {
95f0d0d2 14177 bfd_put_32 (input_bfd,
006589cf
AM		 14178 ADDIS_R2_R12 + PPC_HA (relocation),
14179 contents + rel->r_offset);
95f0d0d2 14180 bfd_put_32 (input_bfd,
006589cf
AM		 14181 ADDI_R2_R2 + PPC_LO (relocation),
14182 contents + rel->r_offset + 4);
14183 }
14184 }
14185 }
14186 break;
14187
52a82034
AM		 14188 case R_PPC64_REL16_HA:
14189 /* If we are generating a non-PIC executable, edit
14190 . 0: addis 2,12,.TOC.-0b@ha
14191 . addi 2,2,.TOC.-0b@l
14192 used by ELFv2 global entry points to set up r2, to
14193 . lis 2,.TOC.@ha
14194 . addi 2,2,.TOC.@l
14195 if .TOC. is in range. */
0e1862bb 14196 if (!bfd_link_pic (info)
810d4e75 14197 && !info->traditional_format
006589cf 14198 && !htab->opd_abi
4f038ee5 14199 && rel->r_addend == d_offset
52a82034
AM		 14200 && h != NULL && &h->elf == htab->elf.hgot
14201 && rel + 1 < relend
14202 && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_REL16_LO)
14203 && rel[1].r_offset == rel->r_offset + 4
14204 && rel[1].r_addend == rel->r_addend + 4
14205 && relocation + 0x80008000 <= 0xffffffff)
14206 {
14207 unsigned int insn1, insn2;
14208 bfd_vma offset = rel->r_offset - d_offset;
95f0d0d2
AM		 14209 insn1 = bfd_get_32 (input_bfd, contents + offset);
14210 insn2 = bfd_get_32 (input_bfd, contents + offset + 4);
006589cf
AM		 14211 if ((insn1 & 0xffff0000) == ADDIS_R2_R12
14212 && (insn2 & 0xffff0000) == ADDI_R2_R2)
52a82034
AM		 14213 {
14214 r_type = R_PPC64_ADDR16_HA;
14215 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
14216 rel->r_addend -= d_offset;
14217 rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_ADDR16_LO);
14218 rel[1].r_addend -= d_offset + 4;
95f0d0d2 14219 bfd_put_32 (input_bfd, LIS_R2, contents + offset);
52a82034
AM		 14220 }
14221 }
14222 break;
411e1bfb
AM		 14223 }
14224
14225 /* Handle other relocations that tweak non-addend part of insn. */
86c76c7b 14226 insn = 0;
b25116a9
AM		 14227 max_br_offset = 1 << 25;
14228 addend = rel->r_addend;
bc30df16 14229 reloc_dest = DEST_NORMAL;
65f38f15 14230 switch (r_type)
5bd4f169
AM		 14231 {
14232 default:
65f38f15 14233 break;
5bd4f169 14234
3b421ab3
AM		 14235 case R_PPC64_TOCSAVE:
14236 if (relocation + addend == (rel->r_offset
14237 + input_section->output_offset
14238 + input_section->output_section->vma)
14239 && tocsave_find (htab, NO_INSERT,
14240 &local_syms, rel, input_bfd))
14241 {
14242 insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
14243 if (insn == NOP
14244 || insn == CROR_151515 || insn == CROR_313131)
a078d95a
AM		 14245 bfd_put_32 (input_bfd,
14246 STD_R2_0R1 + STK_TOC (htab),
3b421ab3
AM		 14247 contents + rel->r_offset);
14248 }
14249 break;
14250
65f38f15
AM		 14251 /* Branch taken prediction relocations. */
14252 case R_PPC64_ADDR14_BRTAKEN:
14253 case R_PPC64_REL14_BRTAKEN:
cedb70c5 14254 insn = 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field. */
1a0670f3 14255 /* Fall through. */
65f38f15 14256
86c76c7b 14257 /* Branch not taken prediction relocations. */
65f38f15
AM		 14258 case R_PPC64_ADDR14_BRNTAKEN:
14259 case R_PPC64_REL14_BRNTAKEN:
95f0d0d2 14260 insn |= bfd_get_32 (input_bfd,
411e1bfb 14261 contents + rel->r_offset) & ~(0x01 << 21);
1a0670f3 14262 /* Fall through. */
86c76c7b 14263
b25116a9
AM		 14264 case R_PPC64_REL14:
14265 max_br_offset = 1 << 15;
1a0670f3 14266 /* Fall through. */
5bd4f169 14267
65f38f15 14268 case R_PPC64_REL24:
ad8e1ba5
AM		 14269 /* Calls to functions with a different TOC, such as calls to
14270 shared objects, need to alter the TOC pointer. This is
14271 done using a linkage stub. A REL24 branching to these
14272 linkage stubs needs to be followed by a nop, as the nop
14273 will be replaced with an instruction to restore the TOC
14274 base pointer. */
8387904d 14275 fdh = h;
b31867b6
AM		 14276 if (h != NULL
14277 && h->oh != NULL
14278 && h->oh->is_func_descriptor)
14279 fdh = ppc_follow_link (h->oh);
31c76678
DK		 14280 stub_entry = ppc_get_stub_entry (input_section, sec, fdh, &orig_rel,
14281 htab);
6abec6bc 14282 if (stub_entry != NULL
ad8e1ba5 14283 && (stub_entry->stub_type == ppc_stub_plt_call
794e51c0 14284 || stub_entry->stub_type == ppc_stub_plt_call_r2save
ad8e1ba5
AM		 14285 || stub_entry->stub_type == ppc_stub_plt_branch_r2off
14286 || stub_entry->stub_type == ppc_stub_long_branch_r2off))
41bd81ab 14287 {
b25116a9 14288 bfd_boolean can_plt_call = FALSE;
721956f4 14289
6e1816be
AM		 14290 if (stub_entry->stub_type == ppc_stub_plt_call
14291 && !htab->opd_abi
14292 && htab->params->plt_localentry0 != 0
14293 && is_elfv2_localentry0 (&h->elf))
14294 {
14295 /* The function doesn't use or change r2. */
14296 can_plt_call = TRUE;
14297 }
14298
f378ab09 14299 /* All of these stubs may modify r2, so there must be a
ba8ca3e7
AM		 14300 branch and link followed by a nop. The nop is
14301 replaced by an insn to restore r2. */
6e1816be 14302 else if (rel->r_offset + 8 <= input_section->size)
41bd81ab 14303 {
ba8ca3e7
AM		 14304 unsigned long br;
14305
14306 br = bfd_get_32 (input_bfd,
14307 contents + rel->r_offset);
14308 if ((br & 1) != 0)
41bd81ab 14309 {
ba8ca3e7
AM		 14310 unsigned long nop;
14311
14312 nop = bfd_get_32 (input_bfd,
14313 contents + rel->r_offset + 4);
14314 if (nop == NOP
14315 || nop == CROR_151515 || nop == CROR_313131)
a7f2871e 14316 {
ba8ca3e7
AM		 14317 if (h != NULL
14318 && (h == htab->tls_get_addr_fd
14319 || h == htab->tls_get_addr)
7c9cf415 14320 && htab->params->tls_get_addr_opt)
ba8ca3e7
AM		 14321 {
14322 /* Special stub used, leave nop alone. */
14323 }
14324 else
a078d95a
AM		 14325 bfd_put_32 (input_bfd,
14326 LD_R2_0R1 + STK_TOC (htab),
ba8ca3e7
AM		 14327 contents + rel->r_offset + 4);
14328 can_plt_call = TRUE;
a7f2871e 14329 }
41bd81ab 14330 }
5bd4f169 14331 }
721956f4 14332
ba8ca3e7 14333 if (!can_plt_call && h != NULL)
721956f4 14334 {
ba8ca3e7
AM		 14335 const char *name = h->elf.root.root.string;
14336
14337 if (*name == '.')
14338 ++name;
14339
14340 if (strncmp (name, "__libc_start_main", 17) == 0
14341 && (name[17] == 0 || name[17] == '@'))
6ab189d5 14342 {
ba8ca3e7
AM		 14343 /* Allow crt1 branch to go via a toc adjusting
14344 stub. Other calls that never return could do
14345 the same, if we could detect such. */
b25116a9 14346 can_plt_call = TRUE;
6ab189d5 14347 }
ba8ca3e7
AM		 14348 }
14349
14350 if (!can_plt_call)
14351 {
14352 /* g++ as of 20130507 emits self-calls without a
14353 following nop. This is arguably wrong since we
14354 have conflicting information. On the one hand a
14355 global symbol and on the other a local call
14356 sequence, but don't error for this special case.
14357 It isn't possible to cheaply verify we have
14358 exactly such a call. Allow all calls to the same
14359 section. */
14360 asection *code_sec = sec;
14361
14362 if (get_opd_info (sec) != NULL)
ad8e1ba5 14363 {
ba8ca3e7
AM		 14364 bfd_vma off = (relocation + addend
14365 - sec->output_section->vma
14366 - sec->output_offset);
bc30df16 14367
ba8ca3e7 14368 opd_entry_value (sec, off, &code_sec, NULL, FALSE);
ad8e1ba5 14369 }
ba8ca3e7
AM		 14370 if (code_sec == input_section)
14371 can_plt_call = TRUE;
14372 }
14373
14374 if (!can_plt_call)
14375 {
4805fc55
AM		 14376 if (stub_entry->stub_type == ppc_stub_plt_call
14377 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
14378 info->callbacks->einfo
695344c0 14379 /* xgettext:c-format */
174d0a74 14380 (_("%H: call to `%T' lacks nop, can't restore toc; "
4805fc55
AM		 14381 "recompile with -fPIC\n"),
14382 input_bfd, input_section, rel->r_offset, sym_name);
14383 else
14384 info->callbacks->einfo
695344c0 14385 /* xgettext:c-format */
174d0a74 14386 (_("%H: call to `%T' lacks nop, can't restore toc; "
4805fc55
AM		 14387 "(-mcmodel=small toc adjust stub)\n"),
14388 input_bfd, input_section, rel->r_offset, sym_name);
ba8ca3e7
AM		 14389
14390 bfd_set_error (bfd_error_bad_value);
14391 ret = FALSE;
721956f4
AM		 14392 }
14393
b25116a9 14394 if (can_plt_call
794e51c0
AM		 14395 && (stub_entry->stub_type == ppc_stub_plt_call
14396 || stub_entry->stub_type == ppc_stub_plt_call_r2save))
b25116a9
AM		 14397 unresolved_reloc = FALSE;
14398 }
14399
6abec6bc
AM		 14400 if ((stub_entry == NULL
14401 || stub_entry->stub_type == ppc_stub_long_branch
14402 || stub_entry->stub_type == ppc_stub_plt_branch)
8387904d
AM		 14403 && get_opd_info (sec) != NULL)
14404 {
14405 /* The branch destination is the value of the opd entry. */
4cc603a5
AM		 14406 bfd_vma off = (relocation + addend
14407 - sec->output_section->vma
14408 - sec->output_offset);
aef36ac1 14409 bfd_vma dest = opd_entry_value (sec, off, NULL, NULL, FALSE);
8387904d
AM		 14410 if (dest != (bfd_vma) -1)
14411 {
14412 relocation = dest;
14413 addend = 0;
bc30df16 14414 reloc_dest = DEST_OPD;
8387904d
AM		 14415 }
14416 }
14417
b25116a9
AM		 14418 /* If the branch is out of reach we ought to have a long
14419 branch stub. */
14420 from = (rel->r_offset
14421 + input_section->output_offset
14422 + input_section->output_section->vma);
14423
6911b7dc
AM		 14424 relocation += PPC64_LOCAL_ENTRY_OFFSET (fdh
14425 ? fdh->elf.other
14426 : sym->st_other);
14427
6abec6bc
AM		 14428 if (stub_entry != NULL
14429 && (stub_entry->stub_type == ppc_stub_long_branch
14430 || stub_entry->stub_type == ppc_stub_plt_branch)
14431 && (r_type == R_PPC64_ADDR14_BRTAKEN
14432 || r_type == R_PPC64_ADDR14_BRNTAKEN
14433 || (relocation + addend - from + max_br_offset
14434 < 2 * max_br_offset)))
14435 /* Don't use the stub if this branch is in range. */
14436 stub_entry = NULL;
b25116a9
AM		 14437
14438 if (stub_entry != NULL)
14439 {
14440 /* Munge up the value and addend so that we call the stub
14441 rather than the procedure directly. */
a4b6fadd
AM		 14442 asection *stub_sec = stub_entry->group->stub_sec;
14443
14444 if (stub_entry->stub_type == ppc_stub_save_res)
14445 relocation += (stub_sec->output_offset
14446 + stub_sec->output_section->vma
14447 + stub_sec->size - htab->sfpr->size
14448 - htab->sfpr->output_offset
14449 - htab->sfpr->output_section->vma);
14450 else
14451 relocation = (stub_entry->stub_offset
14452 + stub_sec->output_offset
14453 + stub_sec->output_section->vma);
b25116a9 14454 addend = 0;
bc30df16 14455 reloc_dest = DEST_STUB;
3b421ab3 14456
954b63d4 14457 if ((stub_entry->stub_type == ppc_stub_plt_call
794e51c0
AM		 14458 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
14459 && (ALWAYS_EMIT_R2SAVE
14460 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
3b421ab3
AM		 14461 && rel + 1 < relend
14462 && rel[1].r_offset == rel->r_offset + 4
14463 && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOCSAVE)
14464 relocation += 4;
b25116a9
AM		 14465 }
14466
14467 if (insn != 0)
14468 {
794e51c0 14469 if (is_isa_v2)
721956f4 14470 {
b25116a9
AM		 14471 /* Set 'a' bit. This is 0b00010 in BO field for branch
14472 on CR(BI) insns (BO == 001at or 011at), and 0b01000
14473 for branch on CTR insns (BO == 1a00t or 1a01t). */
14474 if ((insn & (0x14 << 21)) == (0x04 << 21))
14475 insn |= 0x02 << 21;
14476 else if ((insn & (0x14 << 21)) == (0x10 << 21))
14477 insn |= 0x08 << 21;
14478 else
14479 break;
14480 }
14481 else
14482 {
14483 /* Invert 'y' bit if not the default. */
4cc603a5 14484 if ((bfd_signed_vma) (relocation + addend - from) < 0)
b25116a9 14485 insn ^= 0x01 << 21;
721956f4 14486 }
b25116a9 14487
95f0d0d2 14488 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
5bd4f169 14489 }
e86ce104 14490
06da1e8e
AM		 14491 /* NOP out calls to undefined weak functions.
14492 We can thus call a weak function without first
14493 checking whether the function is defined. */
b25116a9 14494 else if (h != NULL
039b3fef 14495 && h->elf.root.type == bfd_link_hash_undefweak
766bc656 14496 && h->elf.dynindx == -1
b25116a9
AM		 14497 && r_type == R_PPC64_REL24
14498 && relocation == 0
4cc603a5 14499 && addend == 0)
e86ce104 14500 {
95f0d0d2 14501 bfd_put_32 (input_bfd, NOP, contents + rel->r_offset);
c316a17c 14502 goto copy_reloc;
e86ce104 14503 }
65f38f15
AM		 14504 break;
14505 }
5bd4f169 14506
65f38f15 14507 /* Set `addend'. */
411e1bfb 14508 tls_type = 0;
65f38f15
AM		 14509 switch (r_type)
14510 {
14511 default:
25f53a85 14512 info->callbacks->einfo
695344c0 14513 /* xgettext:c-format */
bc30df16 14514 (_("%P: %B: unknown relocation type %d for `%T'\n"),
d003868e 14515 input_bfd, (int) r_type, sym_name);
5bd4f169 14516
65f38f15 14517 bfd_set_error (bfd_error_bad_value);
b34976b6 14518 ret = FALSE;
c316a17c 14519 goto copy_reloc;
5bd4f169 14520
65f38f15 14521 case R_PPC64_NONE:
411e1bfb 14522 case R_PPC64_TLS:
727fc41e
AM		 14523 case R_PPC64_TLSGD:
14524 case R_PPC64_TLSLD:
3b421ab3 14525 case R_PPC64_TOCSAVE:
04c9666a
AM		 14526 case R_PPC64_GNU_VTINHERIT:
14527 case R_PPC64_GNU_VTENTRY:
006589cf 14528 case R_PPC64_ENTRY:
c316a17c 14529 goto copy_reloc;
5bd4f169
AM		 14530
14531 /* GOT16 relocations. Like an ADDR16 using the symbol's
14532 address in the GOT as relocation value instead of the
411e1bfb 14533 symbol's value itself. Also, create a GOT entry for the
5bd4f169 14534 symbol and put the symbol value there. */
411e1bfb
AM		 14535 case R_PPC64_GOT_TLSGD16:
14536 case R_PPC64_GOT_TLSGD16_LO:
14537 case R_PPC64_GOT_TLSGD16_HI:
14538 case R_PPC64_GOT_TLSGD16_HA:
951fd09b 14539 tls_type = TLS_TLS | TLS_GD;
411e1bfb
AM		 14540 goto dogot;
14541
14542 case R_PPC64_GOT_TLSLD16:
14543 case R_PPC64_GOT_TLSLD16_LO:
14544 case R_PPC64_GOT_TLSLD16_HI:
14545 case R_PPC64_GOT_TLSLD16_HA:
951fd09b 14546 tls_type = TLS_TLS | TLS_LD;
411e1bfb
AM		 14547 goto dogot;
14548
14549 case R_PPC64_GOT_TPREL16_DS:
14550 case R_PPC64_GOT_TPREL16_LO_DS:
14551 case R_PPC64_GOT_TPREL16_HI:
14552 case R_PPC64_GOT_TPREL16_HA:
14553 tls_type = TLS_TLS | TLS_TPREL;
14554 goto dogot;
14555
14556 case R_PPC64_GOT_DTPREL16_DS:
14557 case R_PPC64_GOT_DTPREL16_LO_DS:
14558 case R_PPC64_GOT_DTPREL16_HI:
14559 case R_PPC64_GOT_DTPREL16_HA:
14560 tls_type = TLS_TLS | TLS_DTPREL;
14561 goto dogot;
14562
65f38f15
AM		 14563 case R_PPC64_GOT16:
14564 case R_PPC64_GOT16_LO:
14565 case R_PPC64_GOT16_HI:
14566 case R_PPC64_GOT16_HA:
14567 case R_PPC64_GOT16_DS:
14568 case R_PPC64_GOT16_LO_DS:
411e1bfb 14569 dogot:
5bd4f169
AM		 14570 {
14571 /* Relocation is to the entry for this symbol in the global
14572 offset table. */
e717da7e 14573 asection *got;
d881513a 14574 bfd_vma *offp;
5bd4f169 14575 bfd_vma off;
d881513a 14576 unsigned long indx = 0;
927be08e 14577 struct got_entry *ent;
65f38f15 14578
d881513a
AM		 14579 if (tls_type == (TLS_TLS | TLS_LD)
14580 && (h == NULL
f5385ebf 14581 || !h->elf.def_dynamic))
927be08e 14582 ent = ppc64_tlsld_got (input_bfd);
411e1bfb 14583 else
5bd4f169 14584 {
d881513a
AM		 14585 if (h != NULL)
14586 {
f0158f44
AM		 14587 if (!htab->elf.dynamic_sections_created
14588 || h->elf.dynindx == -1
14589 || SYMBOL_REFERENCES_LOCAL (info, &h->elf)
21d68fcd 14590 || UNDEFWEAK_NO_DYNAMIC_RELOC (info, &h->elf))
d881513a
AM		 14591 /* This is actually a static link, or it is a
14592 -Bsymbolic link and the symbol is defined
14593 locally, or the symbol was forced to be local
14594 because of a version file. */
14595 ;
14596 else
14597 {
039b3fef 14598 indx = h->elf.dynindx;
d881513a
AM		 14599 unresolved_reloc = FALSE;
14600 }
039b3fef 14601 ent = h->elf.got.glist;
d881513a 14602 }
411e1bfb 14603 else
5bd4f169 14604 {
d881513a
AM		 14605 if (local_got_ents == NULL)
14606 abort ();
14607 ent = local_got_ents[r_symndx];
5bd4f169 14608 }
d881513a
AM		 14609
14610 for (; ent != NULL; ent = ent->next)
31c76678 14611 if (ent->addend == orig_rel.r_addend
e717da7e 14612 && ent->owner == input_bfd
d881513a
AM		 14613 && ent->tls_type == tls_type)
14614 break;
5bd4f169 14615 }
411e1bfb 14616
927be08e
AM		 14617 if (ent == NULL)
14618 abort ();
14619 if (ent->is_indirect)
14620 ent = ent->got.ent;
14621 offp = &ent->got.offset;
14622 got = ppc64_elf_tdata (ent->owner)->got;
e717da7e
AM		 14623 if (got == NULL)
14624 abort ();
14625
411e1bfb
AM		 14626 /* The offset must always be a multiple of 8. We use the
14627 least significant bit to record whether we have already
14628 processed this entry. */
d881513a 14629 off = *offp;
411e1bfb
AM		 14630 if ((off & 1) != 0)
14631 off &= ~1;
5bd4f169
AM		 14632 else
14633 {
411e1bfb
AM		 14634 /* Generate relocs for the dynamic linker, except in
14635 the case of TLSLD where we'll use one entry per
14636 module. */
25f23106
AM		 14637 asection *relgot;
14638 bfd_boolean ifunc;
e717da7e 14639
d881513a 14640 *offp = off | 1;
25f23106
AM		 14641 relgot = NULL;
14642 ifunc = (h != NULL
14643 ? h->elf.type == STT_GNU_IFUNC
14644 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC);
19e08130 14645 if (ifunc)
82e66161
AM		 14646 {
14647 relgot = htab->elf.irelplt;
14648 if (indx == 0)
14649 htab->local_ifunc_resolver = 1;
14650 else if (is_static_defined (&h->elf))
14651 htab->maybe_local_ifunc_resolver = 1;
14652 }
f0158f44
AM		 14653 else if (indx != 0
14654 || (bfd_link_pic (info)
14655 && (h == NULL
21d68fcd 14656 || !UNDEFWEAK_NO_DYNAMIC_RELOC (info, &h->elf)
f0158f44
AM		 14657 || (tls_type == (TLS_TLS | TLS_LD)
14658 && !h->elf.def_dynamic))))
19e08130 14659 relgot = ppc64_elf_tdata (ent->owner)->relgot;
25f23106 14660 if (relgot != NULL)
5bd4f169 14661 {
e717da7e
AM		 14662 outrel.r_offset = (got->output_section->vma
14663 + got->output_offset
411e1bfb 14664 + off);
4cc603a5 14665 outrel.r_addend = addend;
d881513a 14666 if (tls_type & (TLS_LD | TLS_GD))
5bd4f169 14667 {
411e1bfb 14668 outrel.r_addend = 0;
e515b051 14669 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPMOD64);
d881513a
AM		 14670 if (tls_type == (TLS_TLS | TLS_GD))
14671 {
e717da7e
AM		 14672 loc = relgot->contents;
14673 loc += (relgot->reloc_count++
d881513a
AM		 14674 * sizeof (Elf64_External_Rela));
14675 bfd_elf64_swap_reloca_out (output_bfd,
14676 &outrel, loc);
e515b051 14677 outrel.r_offset += 8;
4cc603a5 14678 outrel.r_addend = addend;
d881513a
AM		 14679 outrel.r_info
14680 = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
d881513a 14681 }
411e1bfb 14682 }
951fd09b 14683 else if (tls_type == (TLS_TLS | TLS_DTPREL))
411e1bfb 14684 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
951fd09b 14685 else if (tls_type == (TLS_TLS | TLS_TPREL))
411e1bfb 14686 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_TPREL64);
25f23106
AM		 14687 else if (indx != 0)
14688 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_GLOB_DAT);
14689 else
81407a69 14690 {
25f23106
AM		 14691 if (ifunc)
14692 outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
14693 else
14694 outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
81407a69
AM		 14695
14696 /* Write the .got section contents for the sake
14697 of prelink. */
e717da7e 14698 loc = got->contents + off;
23fbd6fa
JJ		 14699 bfd_put_64 (output_bfd, outrel.r_addend + relocation,
14700 loc);
81407a69 14701 }
81407a69
AM		 14702
14703 if (indx == 0 && tls_type != (TLS_TLS | TLS_LD))
e515b051
AM		 14704 {
14705 outrel.r_addend += relocation;
14706 if (tls_type & (TLS_GD | TLS_DTPREL | TLS_TPREL))
989f9879
AM		 14707 {
14708 if (htab->elf.tls_sec == NULL)
14709 outrel.r_addend = 0;
14710 else
14711 outrel.r_addend -= htab->elf.tls_sec->vma;
14712 }
e515b051 14713 }
e717da7e
AM		 14714 loc = relgot->contents;
14715 loc += (relgot->reloc_count++
411e1bfb
AM		 14716 * sizeof (Elf64_External_Rela));
14717 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
14718 }
14719
ad8e1ba5 14720 /* Init the .got section contents here if we're not
81407a69 14721 emitting a reloc. */
d881513a 14722 else
411e1bfb 14723 {
4cc603a5 14724 relocation += addend;
f0158f44 14725 if (tls_type != 0)
411e1bfb 14726 {
989f9879
AM		 14727 if (htab->elf.tls_sec == NULL)
14728 relocation = 0;
14729 else
14730 {
f0158f44
AM		 14731 if (tls_type & TLS_LD)
14732 relocation = 0;
14733 else
14734 relocation -= htab->elf.tls_sec->vma + DTP_OFFSET;
676ee2b5 14735 if (tls_type & TLS_TPREL)
989f9879
AM		 14736 relocation += DTP_OFFSET - TP_OFFSET;
14737 }
5bd4f169 14738
f0158f44 14739 if (tls_type & (TLS_GD | TLS_LD))
7b609f53
AM		 14740 {
14741 bfd_put_64 (output_bfd, relocation,
e717da7e 14742 got->contents + off + 8);
676ee2b5 14743 relocation = 1;
7b609f53 14744 }
411e1bfb
AM		 14745 }
14746 bfd_put_64 (output_bfd, relocation,
e717da7e 14747 got->contents + off);
5bd4f169
AM		 14748 }
14749 }
14750
65f38f15
AM		 14751 if (off >= (bfd_vma) -2)
14752 abort ();
14753
bf102f86 14754 relocation = got->output_section->vma + got->output_offset + off;
6f20ed8a 14755 addend = -(TOCstart + htab->sec_info[input_section->id].toc_off);
5bd4f169 14756 }
65f38f15
AM		 14757 break;
14758
14759 case R_PPC64_PLT16_HA:
14760 case R_PPC64_PLT16_HI:
14761 case R_PPC64_PLT16_LO:
14762 case R_PPC64_PLT32:
14763 case R_PPC64_PLT64:
14764 /* Relocation is to the entry for this symbol in the
14765 procedure linkage table. */
cbf95972
AM		 14766 {
14767 struct plt_entry **plt_list = NULL;
14768 if (h != NULL)
14769 plt_list = &h->elf.plt.plist;
14770 else if (local_got_ents != NULL)
14771 {
14772 struct plt_entry **local_plt = (struct plt_entry **)
14773 (local_got_ents + symtab_hdr->sh_info);
14774 unsigned char *local_got_tls_masks = (unsigned char *)
14775 (local_plt + symtab_hdr->sh_info);
14776 if ((local_got_tls_masks[r_symndx] & PLT_IFUNC) != 0)
14777 plt_list = local_plt + r_symndx;
14778 }
14779 if (plt_list)
14780 {
14781 struct plt_entry *ent;
65f38f15 14782
cbf95972
AM		 14783 for (ent = *plt_list; ent != NULL; ent = ent->next)
14784 if (ent->plt.offset != (bfd_vma) -1
14785 && ent->addend == orig_rel.r_addend)
14786 {
14787 asection *plt;
14788
14789 plt = htab->elf.splt;
14790 if (!htab->elf.dynamic_sections_created
14791 || h == NULL
14792 || h->elf.dynindx == -1)
14793 plt = htab->elf.iplt;
14794 relocation = (plt->output_section->vma
14795 + plt->output_offset
14796 + ent->plt.offset);
14797 addend = 0;
14798 unresolved_reloc = FALSE;
14799 break;
14800 }
14801 }
14802 }
65f38f15 14803 break;
5bd4f169 14804
0b13192e
AM		 14805 case R_PPC64_TOC:
14806 /* Relocation value is TOC base. */
14807 relocation = TOCstart;
cf35638d 14808 if (r_symndx == STN_UNDEF)
6f20ed8a 14809 relocation += htab->sec_info[input_section->id].toc_off;
8517fae7
AM		 14810 else if (unresolved_reloc)
14811 ;
6f20ed8a
AM		 14812 else if (sec != NULL && sec->id < htab->sec_info_arr_size)
14813 relocation += htab->sec_info[sec->id].toc_off;
0b13192e
AM		 14814 else
14815 unresolved_reloc = TRUE;
ab96bf03 14816 goto dodyn;
0b13192e 14817
5bd4f169
AM		 14818 /* TOC16 relocs. We want the offset relative to the TOC base,
14819 which is the address of the start of the TOC plus 0x8000.
14820 The TOC consists of sections .got, .toc, .tocbss, and .plt,
14821 in this order. */
65f38f15
AM		 14822 case R_PPC64_TOC16:
14823 case R_PPC64_TOC16_LO:
14824 case R_PPC64_TOC16_HI:
14825 case R_PPC64_TOC16_DS:
14826 case R_PPC64_TOC16_LO_DS:
14827 case R_PPC64_TOC16_HA:
6f20ed8a 14828 addend -= TOCstart + htab->sec_info[input_section->id].toc_off;
5bd4f169
AM		 14829 break;
14830
14831 /* Relocate against the beginning of the section. */
65f38f15
AM		 14832 case R_PPC64_SECTOFF:
14833 case R_PPC64_SECTOFF_LO:
14834 case R_PPC64_SECTOFF_HI:
14835 case R_PPC64_SECTOFF_DS:
14836 case R_PPC64_SECTOFF_LO_DS:
14837 case R_PPC64_SECTOFF_HA:
4ce794b7 14838 if (sec != NULL)
65f38f15 14839 addend -= sec->output_section->vma;
5bd4f169
AM		 14840 break;
14841
25f23106
AM		 14842 case R_PPC64_REL16:
14843 case R_PPC64_REL16_LO:
14844 case R_PPC64_REL16_HI:
14845 case R_PPC64_REL16_HA:
a680de9a 14846 case R_PPC64_REL16DX_HA:
25f23106
AM		 14847 break;
14848
721956f4
AM		 14849 case R_PPC64_REL14:
14850 case R_PPC64_REL14_BRNTAKEN:
14851 case R_PPC64_REL14_BRTAKEN:
5d1634d7
AM		 14852 case R_PPC64_REL24:
14853 break;
14854
411e1bfb
AM		 14855 case R_PPC64_TPREL16:
14856 case R_PPC64_TPREL16_LO:
14857 case R_PPC64_TPREL16_HI:
14858 case R_PPC64_TPREL16_HA:
14859 case R_PPC64_TPREL16_DS:
14860 case R_PPC64_TPREL16_LO_DS:
f9c6b907
AM		 14861 case R_PPC64_TPREL16_HIGH:
14862 case R_PPC64_TPREL16_HIGHA:
411e1bfb
AM		 14863 case R_PPC64_TPREL16_HIGHER:
14864 case R_PPC64_TPREL16_HIGHERA:
14865 case R_PPC64_TPREL16_HIGHEST:
14866 case R_PPC64_TPREL16_HIGHESTA:
766bc656
AM		 14867 if (h != NULL
14868 && h->elf.root.type == bfd_link_hash_undefweak
14869 && h->elf.dynindx == -1)
14870 {
14871 /* Make this relocation against an undefined weak symbol
14872 resolve to zero. This is really just a tweak, since
14873 code using weak externs ought to check that they are
14874 defined before using them. */
14875 bfd_byte *p = contents + rel->r_offset - d_offset;
14876
95f0d0d2 14877 insn = bfd_get_32 (input_bfd, p);
766bc656
AM		 14878 insn = _bfd_elf_ppc_at_tprel_transform (insn, 13);
14879 if (insn != 0)
95f0d0d2 14880 bfd_put_32 (input_bfd, insn, p);
766bc656
AM		 14881 break;
14882 }
989f9879
AM		 14883 if (htab->elf.tls_sec != NULL)
14884 addend -= htab->elf.tls_sec->vma + TP_OFFSET;
0e1862bb 14885 if (bfd_link_pic (info))
411e1bfb
AM		 14886 /* The TPREL16 relocs shouldn't really be used in shared
14887 libs as they will result in DT_TEXTREL being set, but
14888 support them anyway. */
14889 goto dodyn;
14890 break;
14891
14892 case R_PPC64_DTPREL16:
14893 case R_PPC64_DTPREL16_LO:
14894 case R_PPC64_DTPREL16_HI:
14895 case R_PPC64_DTPREL16_HA:
14896 case R_PPC64_DTPREL16_DS:
14897 case R_PPC64_DTPREL16_LO_DS:
f9c6b907
AM		 14898 case R_PPC64_DTPREL16_HIGH:
14899 case R_PPC64_DTPREL16_HIGHA:
411e1bfb
AM		 14900 case R_PPC64_DTPREL16_HIGHER:
14901 case R_PPC64_DTPREL16_HIGHERA:
14902 case R_PPC64_DTPREL16_HIGHEST:
14903 case R_PPC64_DTPREL16_HIGHESTA:
989f9879
AM		 14904 if (htab->elf.tls_sec != NULL)
14905 addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
411e1bfb
AM		 14906 break;
14907
45965137
AM		 14908 case R_PPC64_ADDR64_LOCAL:
14909 addend += PPC64_LOCAL_ENTRY_OFFSET (h != NULL
14910 ? h->elf.other
14911 : sym->st_other);
14912 break;
14913
e515b051
AM		 14914 case R_PPC64_DTPMOD64:
14915 relocation = 1;
14916 addend = 0;
14917 goto dodyn;
14918
411e1bfb 14919 case R_PPC64_TPREL64:
989f9879
AM		 14920 if (htab->elf.tls_sec != NULL)
14921 addend -= htab->elf.tls_sec->vma + TP_OFFSET;
411e1bfb
AM		 14922 goto dodyn;
14923
14924 case R_PPC64_DTPREL64:
989f9879
AM		 14925 if (htab->elf.tls_sec != NULL)
14926 addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
1a0670f3 14927 /* Fall through. */
411e1bfb 14928
65f38f15
AM		 14929 /* Relocations that may need to be propagated if this is a
14930 dynamic object. */
04c9666a 14931 case R_PPC64_REL30:
65f38f15
AM		 14932 case R_PPC64_REL32:
14933 case R_PPC64_REL64:
14934 case R_PPC64_ADDR14:
14935 case R_PPC64_ADDR14_BRNTAKEN:
14936 case R_PPC64_ADDR14_BRTAKEN:
14937 case R_PPC64_ADDR16:
14938 case R_PPC64_ADDR16_DS:
14939 case R_PPC64_ADDR16_HA:
14940 case R_PPC64_ADDR16_HI:
f9c6b907
AM		 14941 case R_PPC64_ADDR16_HIGH:
14942 case R_PPC64_ADDR16_HIGHA:
65f38f15
AM		 14943 case R_PPC64_ADDR16_HIGHER:
14944 case R_PPC64_ADDR16_HIGHERA:
14945 case R_PPC64_ADDR16_HIGHEST:
14946 case R_PPC64_ADDR16_HIGHESTA:
14947 case R_PPC64_ADDR16_LO:
14948 case R_PPC64_ADDR16_LO_DS:
14949 case R_PPC64_ADDR24:
65f38f15
AM		 14950 case R_PPC64_ADDR32:
14951 case R_PPC64_ADDR64:
14952 case R_PPC64_UADDR16:
14953 case R_PPC64_UADDR32:
14954 case R_PPC64_UADDR64:
411e1bfb 14955 dodyn:
5d1634d7 14956 if ((input_section->flags & SEC_ALLOC) == 0)
ec338859
AM		 14957 break;
14958
41bd81ab
AM		 14959 if (NO_OPD_RELOCS && is_opd)
14960 break;
14961
8a9e8e72 14962 if (bfd_link_pic (info)
b1b07054
AM		 14963 ? ((h == NULL
14964 || h->dyn_relocs != NULL)
14965 && ((h != NULL && pc_dynrelocs (h))
14966 || must_be_dyn_reloc (info, r_type)))
8a9e8e72
AM		 14967 : (h != NULL
14968 ? h->dyn_relocs != NULL
d311bc8b 14969 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
65f38f15 14970 {
b34976b6 14971 bfd_boolean skip, relocate;
65f38f15 14972 asection *sreloc;
1cf1f670 14973 bfd_vma out_off;
82e66161 14974 long indx = 0;
65f38f15
AM		 14975
14976 /* When generating a dynamic object, these relocations
14977 are copied into the output file to be resolved at run
14978 time. */
14979
b34976b6
AM		 14980 skip = FALSE;
14981 relocate = FALSE;
65f38f15 14982
1cf1f670
AM		 14983 out_off = _bfd_elf_section_offset (output_bfd, info,
14984 input_section, rel->r_offset);
14985 if (out_off == (bfd_vma) -1)
b34976b6 14986 skip = TRUE;
1cf1f670 14987 else if (out_off == (bfd_vma) -2)
b34976b6 14988 skip = TRUE, relocate = TRUE;
1cf1f670
AM		 14989 out_off += (input_section->output_section->vma
14990 + input_section->output_offset);
14991 outrel.r_offset = out_off;
411e1bfb 14992 outrel.r_addend = rel->r_addend;
65f38f15 14993
1cf1f670
AM		 14994 /* Optimize unaligned reloc use. */
14995 if ((r_type == R_PPC64_ADDR64 && (out_off & 7) != 0)
14996 || (r_type == R_PPC64_UADDR64 && (out_off & 7) == 0))
14997 r_type ^= R_PPC64_ADDR64 ^ R_PPC64_UADDR64;
14998 else if ((r_type == R_PPC64_ADDR32 && (out_off & 3) != 0)
14999 || (r_type == R_PPC64_UADDR32 && (out_off & 3) == 0))
15000 r_type ^= R_PPC64_ADDR32 ^ R_PPC64_UADDR32;
15001 else if ((r_type == R_PPC64_ADDR16 && (out_off & 1) != 0)
15002 || (r_type == R_PPC64_UADDR16 && (out_off & 1) == 0))
15003 r_type ^= R_PPC64_ADDR16 ^ R_PPC64_UADDR16;
15004
65f38f15 15005 if (skip)
0bb2d96a 15006 memset (&outrel, 0, sizeof outrel);
afe397ea 15007 else if (!SYMBOL_REFERENCES_LOCAL (info, &h->elf)
0b13192e
AM		 15008 && !is_opd
15009 && r_type != R_PPC64_TOC)
14acf4dc 15010 {
82e66161
AM		 15011 indx = h->elf.dynindx;
15012 BFD_ASSERT (indx != -1);
15013 outrel.r_info = ELF64_R_INFO (indx, r_type);
14acf4dc 15014 }
65f38f15
AM		 15015 else
15016 {
41bd81ab
AM		 15017 /* This symbol is local, or marked to become local,
15018 or this is an opd section reloc which must point
15019 at a local function. */
65f38f15 15020 outrel.r_addend += relocation;
e86ce104 15021 if (r_type == R_PPC64_ADDR64 || r_type == R_PPC64_TOC)
65f38f15 15022 {
3fad3c7c 15023 if (is_opd && h != NULL)
afbe61cf
AM		 15024 {
15025 /* Lie about opd entries. This case occurs
15026 when building shared libraries and we
15027 reference a function in another shared
3fad3c7c
AM		 15028 lib. The same thing happens for a weak
15029 definition in an application that's
15030 overridden by a strong definition in a
15031 shared lib. (I believe this is a generic
15032 bug in binutils handling of weak syms.)
15033 In these cases we won't use the opd
1e2f5b6e 15034 entry in this lib. */
b34976b6 15035 unresolved_reloc = FALSE;
afbe61cf 15036 }
25f23106
AM		 15037 if (!is_opd
15038 && r_type == R_PPC64_ADDR64
15039 && (h != NULL
15040 ? h->elf.type == STT_GNU_IFUNC
15041 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
15042 outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
15043 else
15044 {
15045 outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
81407a69 15046
25f23106
AM		 15047 /* We need to relocate .opd contents for ld.so.
15048 Prelink also wants simple and consistent rules
15049 for relocs. This make all RELATIVE relocs have
15050 *r_offset equal to r_addend. */
15051 relocate = TRUE;
15052 }
65f38f15
AM		 15053 }
15054 else
15055 {
25f23106
AM		 15056 if (h != NULL
15057 ? h->elf.type == STT_GNU_IFUNC
15058 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
15059 {
25f53a85 15060 info->callbacks->einfo
695344c0 15061 /* xgettext:c-format */
174d0a74 15062 (_("%H: %s for indirect "
bc30df16 15063 "function `%T' unsupported\n"),
25f53a85 15064 input_bfd, input_section, rel->r_offset,
25f23106
AM		 15065 ppc64_elf_howto_table[r_type]->name,
15066 sym_name);
15067 ret = FALSE;
15068 }
cf35638d 15069 else if (r_symndx == STN_UNDEF || bfd_is_abs_section (sec))
65f38f15
AM		 15070 ;
15071 else if (sec == NULL || sec->owner == NULL)
15072 {
15073 bfd_set_error (bfd_error_bad_value);
b34976b6 15074 return FALSE;
65f38f15
AM		 15075 }
15076 else
15077 {
15078 asection *osec;
15079
15080 osec = sec->output_section;
15081 indx = elf_section_data (osec)->dynindx;
15082
74541ad4
AM		 15083 if (indx == 0)
15084 {
15085 if ((osec->flags & SEC_READONLY) == 0
15086 && htab->elf.data_index_section != NULL)
15087 osec = htab->elf.data_index_section;
15088 else
15089 osec = htab->elf.text_index_section;
15090 indx = elf_section_data (osec)->dynindx;
15091 }
15092 BFD_ASSERT (indx != 0);
15093
65f38f15
AM		 15094 /* We are turning this relocation into one
15095 against a section symbol, so subtract out
15096 the output section's address but not the
15097 offset of the input section in the output
15098 section. */
15099 outrel.r_addend -= osec->vma;
15100 }
15101
15102 outrel.r_info = ELF64_R_INFO (indx, r_type);
15103 }
15104 }
15105
15106 sreloc = elf_section_data (input_section)->sreloc;
19e08130
AM		 15107 if (h != NULL
15108 ? h->elf.type == STT_GNU_IFUNC
15109 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
82e66161
AM		 15110 {
15111 sreloc = htab->elf.irelplt;
15112 if (indx == 0)
15113 htab->local_ifunc_resolver = 1;
15114 else if (is_static_defined (&h->elf))
15115 htab->maybe_local_ifunc_resolver = 1;
15116 }
65f38f15
AM		 15117 if (sreloc == NULL)
15118 abort ();
15119
dfbb6ac9
AM		 15120 if (sreloc->reloc_count * sizeof (Elf64_External_Rela)
15121 >= sreloc->size)
15122 abort ();
947216bf
AM		 15123 loc = sreloc->contents;
15124 loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
65f38f15
AM		 15125 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
15126
15127 /* If this reloc is against an external symbol, it will
15128 be computed at runtime, so there's no need to do
81407a69
AM		 15129 anything now. However, for the sake of prelink ensure
15130 that the section contents are a known value. */
65f38f15 15131 if (! relocate)
81407a69
AM		 15132 {
15133 unresolved_reloc = FALSE;
15134 /* The value chosen here is quite arbitrary as ld.so
15135 ignores section contents except for the special
15136 case of .opd where the contents might be accessed
15137 before relocation. Choose zero, as that won't
15138 cause reloc overflow. */
15139 relocation = 0;
15140 addend = 0;
15141 /* Use *r_offset == r_addend for R_PPC64_ADDR64 relocs
15142 to improve backward compatibility with older
15143 versions of ld. */
15144 if (r_type == R_PPC64_ADDR64)
15145 addend = outrel.r_addend;
15146 /* Adjust pc_relative relocs to have zero in *r_offset. */
4ce794b7 15147 else if (ppc64_elf_howto_table[r_type]->pc_relative)
f0158f44 15148 addend = outrel.r_offset;
81407a69 15149 }
65f38f15 15150 }
5bd4f169
AM		 15151 break;
15152
65f38f15
AM		 15153 case R_PPC64_COPY:
15154 case R_PPC64_GLOB_DAT:
15155 case R_PPC64_JMP_SLOT:
25f23106 15156 case R_PPC64_JMP_IREL:
65f38f15
AM		 15157 case R_PPC64_RELATIVE:
15158 /* We shouldn't ever see these dynamic relocs in relocatable
15159 files. */
ae9a127f 15160 /* Fall through. */
65f38f15
AM		 15161
15162 case R_PPC64_PLTGOT16:
15163 case R_PPC64_PLTGOT16_DS:
15164 case R_PPC64_PLTGOT16_HA:
15165 case R_PPC64_PLTGOT16_HI:
15166 case R_PPC64_PLTGOT16_LO:
15167 case R_PPC64_PLTGOT16_LO_DS:
15168 case R_PPC64_PLTREL32:
15169 case R_PPC64_PLTREL64:
15170 /* These ones haven't been implemented yet. */
15171
25f53a85 15172 info->callbacks->einfo
695344c0 15173 /* xgettext:c-format */
bc30df16 15174 (_("%P: %B: %s is not supported for `%T'\n"),
d003868e 15175 input_bfd,
4ce794b7 15176 ppc64_elf_howto_table[r_type]->name, sym_name);
5bd4f169
AM		 15177
15178 bfd_set_error (bfd_error_invalid_operation);
b34976b6 15179 ret = FALSE;
c316a17c 15180 goto copy_reloc;
65f38f15 15181 }
5bd4f169 15182
67f0cbdb
AM		 15183 /* Multi-instruction sequences that access the TOC can be
15184 optimized, eg. addis ra,r2,0; addi rb,ra,x;
15185 to nop; addi rb,r2,x; */
15186 switch (r_type)
15187 {
15188 default:
15189 break;
15190
15191 case R_PPC64_GOT_TLSLD16_HI:
15192 case R_PPC64_GOT_TLSGD16_HI:
15193 case R_PPC64_GOT_TPREL16_HI:
15194 case R_PPC64_GOT_DTPREL16_HI:
15195 case R_PPC64_GOT16_HI:
15196 case R_PPC64_TOC16_HI:
15197 /* These relocs would only be useful if building up an
15198 offset to later add to r2, perhaps in an indexed
15199 addressing mode instruction. Don't try to optimize.
15200 Unfortunately, the possibility of someone building up an
15201 offset like this or even with the HA relocs, means that
15202 we need to check the high insn when optimizing the low
15203 insn. */
15204 break;
15205
15206 case R_PPC64_GOT_TLSLD16_HA:
15207 case R_PPC64_GOT_TLSGD16_HA:
15208 case R_PPC64_GOT_TPREL16_HA:
15209 case R_PPC64_GOT_DTPREL16_HA:
15210 case R_PPC64_GOT16_HA:
15211 case R_PPC64_TOC16_HA:
98528052 15212 if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
560c8763 15213 && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
98528052
AM		 15214 {
15215 bfd_byte *p = contents + (rel->r_offset & ~3);
15216 bfd_put_32 (input_bfd, NOP, p);
15217 }
67f0cbdb
AM		 15218 break;
15219
15220 case R_PPC64_GOT_TLSLD16_LO:
15221 case R_PPC64_GOT_TLSGD16_LO:
15222 case R_PPC64_GOT_TPREL16_LO_DS:
15223 case R_PPC64_GOT_DTPREL16_LO_DS:
15224 case R_PPC64_GOT16_LO:
15225 case R_PPC64_GOT16_LO_DS:
15226 case R_PPC64_TOC16_LO:
15227 case R_PPC64_TOC16_LO_DS:
98528052 15228 if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
560c8763 15229 && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
67f0cbdb
AM		 15230 {
15231 bfd_byte *p = contents + (rel->r_offset & ~3);
15232 insn = bfd_get_32 (input_bfd, p);
560c8763
AM		 15233 if ((insn & (0x3f << 26)) == 12u << 26 /* addic */)
15234 {
15235 /* Transform addic to addi when we change reg. */
15236 insn &= ~((0x3f << 26) | (0x1f << 16));
15237 insn |= (14u << 26) | (2 << 16);
15238 }
15239 else
67f0cbdb 15240 {
98528052
AM		 15241 insn &= ~(0x1f << 16);
15242 insn |= 2 << 16;
67f0cbdb 15243 }
560c8763 15244 bfd_put_32 (input_bfd, insn, p);
67f0cbdb
AM		 15245 }
15246 break;
15247 }
15248
65f38f15 15249 /* Do any further special processing. */
b80eed39 15250 howto = ppc64_elf_howto_table[(int) r_type];
65f38f15
AM		 15251 switch (r_type)
15252 {
15253 default:
15254 break;
15255
25f23106 15256 case R_PPC64_REL16_HA:
a680de9a 15257 case R_PPC64_REL16DX_HA:
f9c6b907
AM		 15258 case R_PPC64_ADDR16_HA:
15259 case R_PPC64_ADDR16_HIGHA:
65f38f15
AM		 15260 case R_PPC64_ADDR16_HIGHERA:
15261 case R_PPC64_ADDR16_HIGHESTA:
65f38f15
AM		 15262 case R_PPC64_TOC16_HA:
15263 case R_PPC64_SECTOFF_HA:
411e1bfb 15264 case R_PPC64_TPREL16_HA:
f9c6b907 15265 case R_PPC64_TPREL16_HIGHA:
411e1bfb 15266 case R_PPC64_TPREL16_HIGHERA:
411e1bfb 15267 case R_PPC64_TPREL16_HIGHESTA:
f9c6b907
AM		 15268 case R_PPC64_DTPREL16_HA:
15269 case R_PPC64_DTPREL16_HIGHA:
411e1bfb 15270 case R_PPC64_DTPREL16_HIGHERA:
411e1bfb 15271 case R_PPC64_DTPREL16_HIGHESTA:
65f38f15
AM		 15272 /* It's just possible that this symbol is a weak symbol
15273 that's not actually defined anywhere. In that case,
15274 'sec' would be NULL, and we should leave the symbol
15275 alone (it will be set to zero elsewhere in the link). */
5c5f6e17
AM		 15276 if (sec == NULL)
15277 break;
1a0670f3 15278 /* Fall through. */
5c5f6e17
AM		 15279
15280 case R_PPC64_GOT16_HA:
15281 case R_PPC64_PLTGOT16_HA:
15282 case R_PPC64_PLT16_HA:
15283 case R_PPC64_GOT_TLSGD16_HA:
15284 case R_PPC64_GOT_TLSLD16_HA:
15285 case R_PPC64_GOT_TPREL16_HA:
15286 case R_PPC64_GOT_DTPREL16_HA:
15287 /* Add 0x10000 if sign bit in 0:15 is set.
15288 Bits 0:15 are not used. */
15289 addend += 0x8000;
65f38f15
AM		 15290 break;
15291
15292 case R_PPC64_ADDR16_DS:
15293 case R_PPC64_ADDR16_LO_DS:
15294 case R_PPC64_GOT16_DS:
15295 case R_PPC64_GOT16_LO_DS:
15296 case R_PPC64_PLT16_LO_DS:
15297 case R_PPC64_SECTOFF_DS:
15298 case R_PPC64_SECTOFF_LO_DS:
15299 case R_PPC64_TOC16_DS:
15300 case R_PPC64_TOC16_LO_DS:
15301 case R_PPC64_PLTGOT16_DS:
15302 case R_PPC64_PLTGOT16_LO_DS:
411e1bfb
AM		 15303 case R_PPC64_GOT_TPREL16_DS:
15304 case R_PPC64_GOT_TPREL16_LO_DS:
15305 case R_PPC64_GOT_DTPREL16_DS:
15306 case R_PPC64_GOT_DTPREL16_LO_DS:
15307 case R_PPC64_TPREL16_DS:
15308 case R_PPC64_TPREL16_LO_DS:
15309 case R_PPC64_DTPREL16_DS:
15310 case R_PPC64_DTPREL16_LO_DS:
adadcc0c
AM		 15311 insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
15312 mask = 3;
a680de9a
PB		 15313 /* If this reloc is against an lq, lxv, or stxv insn, then
15314 the value must be a multiple of 16. This is somewhat of
15315 a hack, but the "correct" way to do this by defining _DQ
15316 forms of all the _DS relocs bloats all reloc switches in
15317 this file. It doesn't make much sense to use these
15318 relocs in data, so testing the insn should be safe. */
15319 if ((insn & (0x3f << 26)) == (56u << 26)
15320 || ((insn & (0x3f << 26)) == (61u << 26) && (insn & 3) == 1))
adadcc0c 15321 mask = 15;
a680de9a
PB		 15322 relocation += addend;
15323 addend = insn & (mask ^ 3);
15324 if ((relocation & mask) != 0)
65f38f15 15325 {
a680de9a 15326 relocation ^= relocation & mask;
25f53a85 15327 info->callbacks->einfo
695344c0 15328 /* xgettext:c-format */
174d0a74 15329 (_("%H: error: %s not a multiple of %u\n"),
25f53a85 15330 input_bfd, input_section, rel->r_offset,
b80eed39 15331 howto->name,
adadcc0c 15332 mask + 1);
65f38f15 15333 bfd_set_error (bfd_error_bad_value);
b34976b6 15334 ret = FALSE;
c316a17c 15335 goto copy_reloc;
65f38f15
AM		 15336 }
15337 break;
5bd4f169
AM		 15338 }
15339
239e1f3a
AM		 15340 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
15341 because such sections are not SEC_ALLOC and thus ld.so will
15342 not process them. */
65f38f15 15343 if (unresolved_reloc
239e1f3a 15344 && !((input_section->flags & SEC_DEBUGGING) != 0
1d5316ab
AM		 15345 && h->elf.def_dynamic)
15346 && _bfd_elf_section_offset (output_bfd, info, input_section,
15347 rel->r_offset) != (bfd_vma) -1)
9c07fe7c 15348 {
25f53a85 15349 info->callbacks->einfo
695344c0 15350 /* xgettext:c-format */
174d0a74 15351 (_("%H: unresolvable %s against `%T'\n"),
25f53a85 15352 input_bfd, input_section, rel->r_offset,
b80eed39 15353 howto->name,
039b3fef 15354 h->elf.root.root.string);
b34976b6 15355 ret = FALSE;
9c07fe7c 15356 }
5bd4f169 15357
b80eed39
AM		 15358 /* 16-bit fields in insns mostly have signed values, but a
15359 few insns have 16-bit unsigned values. Really, we should
15360 have different reloc types. */
15361 if (howto->complain_on_overflow != complain_overflow_dont
15362 && howto->dst_mask == 0xffff
15363 && (input_section->flags & SEC_CODE) != 0)
15364 {
15365 enum complain_overflow complain = complain_overflow_signed;
15366
15367 insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
a47622ac
AM		 15368 if ((insn & (0x3f << 26)) == 10u << 26 /* cmpli */)
15369 complain = complain_overflow_bitfield;
15370 else if (howto->rightshift == 0
15371 ? ((insn & (0x3f << 26)) == 28u << 26 /* andi */
15372 || (insn & (0x3f << 26)) == 24u << 26 /* ori */
15373 || (insn & (0x3f << 26)) == 26u << 26 /* xori */)
15374 : ((insn & (0x3f << 26)) == 29u << 26 /* andis */
15375 || (insn & (0x3f << 26)) == 25u << 26 /* oris */
15376 || (insn & (0x3f << 26)) == 27u << 26 /* xoris */))
b80eed39
AM		 15377 complain = complain_overflow_unsigned;
15378 if (howto->complain_on_overflow != complain)
15379 {
15380 alt_howto = *howto;
15381 alt_howto.complain_on_overflow = complain;
15382 howto = &alt_howto;
15383 }
15384 }
15385
a680de9a
PB		 15386 if (r_type == R_PPC64_REL16DX_HA)
15387 {
15388 /* Split field reloc isn't handled by _bfd_final_link_relocate. */
15389 if (rel->r_offset + 4 > input_section->size)
15390 r = bfd_reloc_outofrange;
15391 else
15392 {
15393 relocation += addend;
15394 relocation -= (rel->r_offset
15395 + input_section->output_offset
15396 + input_section->output_section->vma);
3de43e7b 15397 relocation = (bfd_signed_vma) relocation >> 16;
a680de9a
PB		 15398 insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
15399 insn &= ~0x1fffc1;
3de43e7b 15400 insn |= (relocation & 0xffc1) | ((relocation & 0x3e) << 15);
a680de9a
PB		 15401 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
15402 r = bfd_reloc_ok;
3de43e7b 15403 if (relocation + 0x8000 > 0xffff)
a680de9a
PB		 15404 r = bfd_reloc_overflow;
15405 }
15406 }
15407 else
15408 r = _bfd_final_link_relocate (howto, input_bfd, input_section, contents,
15409 rel->r_offset, relocation, addend);
5bd4f169 15410
ef60b7ff 15411 if (r != bfd_reloc_ok)
5bd4f169 15412 {
bc30df16 15413 char *more_info = NULL;
b80eed39 15414 const char *reloc_name = howto->name;
bc30df16
AM		 15415
15416 if (reloc_dest != DEST_NORMAL)
15417 {
15418 more_info = bfd_malloc (strlen (reloc_name) + 8);
15419 if (more_info != NULL)
15420 {
15421 strcpy (more_info, reloc_name);
15422 strcat (more_info, (reloc_dest == DEST_OPD
15423 ? " (OPD)" : " (stub)"));
15424 reloc_name = more_info;
15425 }
15426 }
15427
cd27b276 15428 if (r == bfd_reloc_overflow)
5bd4f169 15429 {
8131c122
AM		 15430 /* On code like "if (foo) foo();" don't report overflow
15431 on a branch to zero when foo is undefined. */
15432 if (!warned
15433 && (reloc_dest == DEST_STUB
15434 || !(h != NULL
15435 && (h->elf.root.type == bfd_link_hash_undefweak
15436 || h->elf.root.type == bfd_link_hash_undefined)
15437 && is_branch_reloc (r_type))))
1a72702b
AM		 15438 info->callbacks->reloc_overflow (info, &h->elf.root,
15439 sym_name, reloc_name,
15440 orig_rel.r_addend,
15441 input_bfd, input_section,
15442 rel->r_offset);
ef60b7ff
AM		 15443 }
15444 else
15445 {
25f53a85 15446 info->callbacks->einfo
695344c0 15447 /* xgettext:c-format */
174d0a74 15448 (_("%H: %s against `%T': error %d\n"),
25f53a85 15449 input_bfd, input_section, rel->r_offset,
bc30df16 15450 reloc_name, sym_name, (int) r);
b34976b6 15451 ret = FALSE;
ef60b7ff 15452 }
bc30df16
AM		 15453 if (more_info != NULL)
15454 free (more_info);
5bd4f169 15455 }
c316a17c
AM		 15456 copy_reloc:
15457 if (wrel != rel)
15458 *wrel = *rel;
15459 }
15460
15461 if (wrel != rel)
15462 {
15463 Elf_Internal_Shdr *rel_hdr;
15464 size_t deleted = rel - wrel;
15465
15466 rel_hdr = _bfd_elf_single_rel_hdr (input_section->output_section);
15467 rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
15468 if (rel_hdr->sh_size == 0)
15469 {
15470 /* It is too late to remove an empty reloc section. Leave
15471 one NONE reloc.
15472 ??? What is wrong with an empty section??? */
15473 rel_hdr->sh_size = rel_hdr->sh_entsize;
15474 deleted -= 1;
15475 }
15476 rel_hdr = _bfd_elf_single_rel_hdr (input_section);
15477 rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
15478 input_section->reloc_count -= deleted;
5bd4f169
AM		 15479 }
15480
645ea6a9
AM		 15481 /* If we're emitting relocations, then shortly after this function
15482 returns, reloc offsets and addends for this section will be
15483 adjusted. Worse, reloc symbol indices will be for the output
8860955f
AM		 15484 file rather than the input. Save a copy of the relocs for
15485 opd_entry_value. */
0e1862bb 15486 if (is_opd && (info->emitrelocations || bfd_link_relocatable (info)))
8860955f
AM		 15487 {
15488 bfd_size_type amt;
15489 amt = input_section->reloc_count * sizeof (Elf_Internal_Rela);
15490 rel = bfd_alloc (input_bfd, amt);
729eabd5
AM		 15491 BFD_ASSERT (ppc64_elf_tdata (input_bfd)->opd.relocs == NULL);
15492 ppc64_elf_tdata (input_bfd)->opd.relocs = rel;
8860955f
AM		 15493 if (rel == NULL)
15494 return FALSE;
15495 memcpy (rel, relocs, amt);
15496 }
5bd4f169
AM		 15497 return ret;
15498}
15499
754021d0
AM		 15500/* Adjust the value of any local symbols in opd sections. */
15501
6e0b88f1 15502static int
754021d0
AM		 15503ppc64_elf_output_symbol_hook (struct bfd_link_info *info,
15504 const char *name ATTRIBUTE_UNUSED,
15505 Elf_Internal_Sym *elfsym,
15506 asection *input_sec,
15507 struct elf_link_hash_entry *h)
15508{
74f0fb50
AM		 15509 struct _opd_sec_data *opd;
15510 long adjust;
754021d0
AM		 15511 bfd_vma value;
15512
4025353c 15513 if (h != NULL)
6e0b88f1 15514 return 1;
4025353c 15515
74f0fb50
AM		 15516 opd = get_opd_info (input_sec);
15517 if (opd == NULL || opd->adjust == NULL)
6e0b88f1 15518 return 1;
754021d0
AM		 15519
15520 value = elfsym->st_value - input_sec->output_offset;
0e1862bb 15521 if (!bfd_link_relocatable (info))
754021d0
AM		 15522 value -= input_sec->output_section->vma;
15523
51aecdc5 15524 adjust = opd->adjust[OPD_NDX (value)];
4025353c 15525 if (adjust == -1)
6e0b88f1
AM		 15526 return 2;
15527
15528 elfsym->st_value += adjust;
15529 return 1;
754021d0
AM		 15530}
15531
5bd4f169
AM		 15532/* Finish up dynamic symbol handling. We set the contents of various
15533 dynamic sections here. */
15534
b34976b6 15535static bfd_boolean
4ce794b7
AM		 15536ppc64_elf_finish_dynamic_symbol (bfd *output_bfd,
15537 struct bfd_link_info *info,
15538 struct elf_link_hash_entry *h,
4aef7643 15539 Elf_Internal_Sym *sym)
5bd4f169 15540{
65f38f15 15541 struct ppc_link_hash_table *htab;
8387904d
AM		 15542 struct plt_entry *ent;
15543 Elf_Internal_Rela rela;
15544 bfd_byte *loc;
5bd4f169 15545
65f38f15 15546 htab = ppc_hash_table (info);
4dfe6ac6
NC		 15547 if (htab == NULL)
15548 return FALSE;
5bd4f169 15549
8387904d
AM		 15550 for (ent = h->plt.plist; ent != NULL; ent = ent->next)
15551 if (ent->plt.offset != (bfd_vma) -1)
15552 {
15553 /* This symbol has an entry in the procedure linkage
15554 table. Set it up. */
e054468f
AM		 15555 if (!htab->elf.dynamic_sections_created
15556 || h->dynindx == -1)
15557 {
15558 BFD_ASSERT (h->type == STT_GNU_IFUNC
15559 && h->def_regular
15560 && (h->root.type == bfd_link_hash_defined
15561 || h->root.type == bfd_link_hash_defweak));
33e44f2e
AM		 15562 rela.r_offset = (htab->elf.iplt->output_section->vma
15563 + htab->elf.iplt->output_offset
25f23106 15564 + ent->plt.offset);
ee67d69a
AM		 15565 if (htab->opd_abi)
15566 rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
15567 else
15568 rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
e054468f
AM		 15569 rela.r_addend = (h->root.u.def.value
15570 + h->root.u.def.section->output_offset
15571 + h->root.u.def.section->output_section->vma
15572 + ent->addend);
33e44f2e
AM		 15573 loc = (htab->elf.irelplt->contents
15574 + (htab->elf.irelplt->reloc_count++
25f23106 15575 * sizeof (Elf64_External_Rela)));
82e66161 15576 htab->local_ifunc_resolver = 1;
e054468f
AM		 15577 }
15578 else
15579 {
33e44f2e
AM		 15580 rela.r_offset = (htab->elf.splt->output_section->vma
15581 + htab->elf.splt->output_offset
25f23106 15582 + ent->plt.offset);
e054468f
AM		 15583 rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_JMP_SLOT);
15584 rela.r_addend = ent->addend;
33e44f2e 15585 loc = (htab->elf.srelplt->contents
b9e5796b
AM		 15586 + ((ent->plt.offset - PLT_INITIAL_ENTRY_SIZE (htab))
15587 / PLT_ENTRY_SIZE (htab) * sizeof (Elf64_External_Rela)));
82e66161
AM		 15588 if (h->type == STT_GNU_IFUNC && is_static_defined (h))
15589 htab->maybe_local_ifunc_resolver = 1;
e054468f 15590 }
8387904d 15591 bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
a345bc8d
AM		 15592
15593 if (!htab->opd_abi)
15594 {
15595 if (!h->def_regular)
15596 {
15597 /* Mark the symbol as undefined, rather than as
15598 defined in glink. Leave the value if there were
15599 any relocations where pointer equality matters
15600 (this is a clue for the dynamic linker, to make
15601 function pointer comparisons work between an
15602 application and shared library), otherwise set it
15603 to zero. */
15604 sym->st_shndx = SHN_UNDEF;
15605 if (!h->pointer_equality_needed)
15606 sym->st_value = 0;
15607 else if (!h->ref_regular_nonweak)
15608 {
15609 /* This breaks function pointer comparisons, but
15610 that is better than breaking tests for a NULL
15611 function pointer. */
15612 sym->st_value = 0;
15613 }
15614 }
15615 }
8387904d 15616 }
5bd4f169 15617
f5385ebf 15618 if (h->needs_copy)
5bd4f169 15619 {
65f38f15 15620 /* This symbol needs a copy reloc. Set it up. */
5474d94f 15621 asection *srel;
5bd4f169 15622
65f38f15
AM		 15623 if (h->dynindx == -1
15624 || (h->root.type != bfd_link_hash_defined
15625 && h->root.type != bfd_link_hash_defweak)
5474d94f
AM		 15626 || htab->elf.srelbss == NULL
15627 || htab->elf.sreldynrelro == NULL)
65f38f15 15628 abort ();
5bd4f169
AM		 15629
15630 rela.r_offset = (h->root.u.def.value
15631 + h->root.u.def.section->output_section->vma
15632 + h->root.u.def.section->output_offset);
15633 rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_COPY);
15634 rela.r_addend = 0;
afbf7e8e 15635 if (h->root.u.def.section == htab->elf.sdynrelro)
5474d94f
AM		 15636 srel = htab->elf.sreldynrelro;
15637 else
15638 srel = htab->elf.srelbss;
15639 loc = srel->contents;
15640 loc += srel->reloc_count++ * sizeof (Elf64_External_Rela);
65f38f15 15641 bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
5bd4f169
AM		 15642 }
15643
b34976b6 15644 return TRUE;
5bd4f169
AM		 15645}
15646
65f38f15
AM		 15647/* Used to decide how to sort relocs in an optimal manner for the
15648 dynamic linker, before writing them out. */
15649
15650static enum elf_reloc_type_class
7e612e98
AM		 15651ppc64_elf_reloc_type_class (const struct bfd_link_info *info,
15652 const asection *rel_sec,
15653 const Elf_Internal_Rela *rela)
65f38f15 15654{
04c9666a 15655 enum elf_ppc64_reloc_type r_type;
7e612e98
AM		 15656 struct ppc_link_hash_table *htab = ppc_hash_table (info);
15657
33e44f2e 15658 if (rel_sec == htab->elf.irelplt)
7e612e98 15659 return reloc_class_ifunc;
a33d1f77 15660
4ce794b7 15661 r_type = ELF64_R_TYPE (rela->r_info);
a33d1f77 15662 switch (r_type)
65f38f15
AM		 15663 {
15664 case R_PPC64_RELATIVE:
15665 return reloc_class_relative;
15666 case R_PPC64_JMP_SLOT:
15667 return reloc_class_plt;
15668 case R_PPC64_COPY:
15669 return reloc_class_copy;
15670 default:
15671 return reloc_class_normal;
15672 }
15673}
15674
5bd4f169
AM		 15675/* Finish up the dynamic sections. */
15676
b34976b6 15677static bfd_boolean
4ce794b7
AM		 15678ppc64_elf_finish_dynamic_sections (bfd *output_bfd,
15679 struct bfd_link_info *info)
5bd4f169 15680{
65f38f15
AM		 15681 struct ppc_link_hash_table *htab;
15682 bfd *dynobj;
5bd4f169 15683 asection *sdyn;
5bd4f169 15684
65f38f15 15685 htab = ppc_hash_table (info);
4dfe6ac6
NC		 15686 if (htab == NULL)
15687 return FALSE;
15688
65f38f15 15689 dynobj = htab->elf.dynobj;
3d4d4302 15690 sdyn = bfd_get_linker_section (dynobj, ".dynamic");
5bd4f169 15691
65f38f15 15692 if (htab->elf.dynamic_sections_created)
5bd4f169 15693 {
5bd4f169
AM		 15694 Elf64_External_Dyn *dyncon, *dynconend;
15695
33e44f2e 15696 if (sdyn == NULL || htab->elf.sgot == NULL)
65f38f15 15697 abort ();
5bd4f169
AM		 15698
15699 dyncon = (Elf64_External_Dyn *) sdyn->contents;
eea6121a 15700 dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
5bd4f169
AM		 15701 for (; dyncon < dynconend; dyncon++)
15702 {
15703 Elf_Internal_Dyn dyn;
19397422 15704 asection *s;
5bd4f169
AM		 15705
15706 bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
15707
15708 switch (dyn.d_tag)
15709 {
65f38f15
AM		 15710 default:
15711 continue;
5bd4f169 15712
5d1634d7 15713 case DT_PPC64_GLINK:
4ce794b7 15714 s = htab->glink;
6348e046 15715 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
ad8e1ba5
AM		 15716 /* We stupidly defined DT_PPC64_GLINK to be the start
15717 of glink rather than the first entry point, which is
15718 what ld.so needs, and now have a bigger stub to
15719 support automatic multiple TOCs. */
b9e5796b 15720 dyn.d_un.d_ptr += GLINK_CALL_STUB_SIZE - 8 * 4;
5d1634d7
AM		 15721 break;
15722
19397422
AM		 15723 case DT_PPC64_OPD:
15724 s = bfd_get_section_by_name (output_bfd, ".opd");
6348e046
AM		 15725 if (s == NULL)
15726 continue;
15727 dyn.d_un.d_ptr = s->vma;
19397422
AM		 15728 break;
15729
e8910a83
AM		 15730 case DT_PPC64_OPT:
15731 if (htab->do_multi_toc && htab->multi_toc_needed)
15732 dyn.d_un.d_val |= PPC64_OPT_MULTI_TOC;
f378ab09
AM		 15733 if (htab->has_plt_localentry0)
15734 dyn.d_un.d_val |= PPC64_OPT_LOCALENTRY;
e8910a83
AM		 15735 break;
15736
19397422
AM		 15737 case DT_PPC64_OPDSZ:
15738 s = bfd_get_section_by_name (output_bfd, ".opd");
6348e046
AM		 15739 if (s == NULL)
15740 continue;
eea6121a 15741 dyn.d_un.d_val = s->size;
19397422
AM		 15742 break;
15743
65f38f15 15744 case DT_PLTGOT:
33e44f2e 15745 s = htab->elf.splt;
6348e046 15746 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
65f38f15
AM		 15747 break;
15748
15749 case DT_JMPREL:
33e44f2e 15750 s = htab->elf.srelplt;
6348e046 15751 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
65f38f15 15752 break;
5bd4f169 15753
65f38f15 15754 case DT_PLTRELSZ:
33e44f2e 15755 dyn.d_un.d_val = htab->elf.srelplt->size;
5d1634d7 15756 break;
82e66161
AM		 15757
15758 case DT_TEXTREL:
15759 if (htab->local_ifunc_resolver)
15760 info->callbacks->einfo
15761 (_("%X%P: text relocations and GNU indirect "
15762 "functions will result in a segfault at runtime\n"));
15763 else if (htab->maybe_local_ifunc_resolver)
15764 info->callbacks->einfo
15765 (_("%P: warning: text relocations and GNU indirect "
15766 "functions may result in a segfault at runtime\n"));
15767 continue;
5bd4f169 15768 }
5bd4f169 15769
65f38f15 15770 bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
5bd4f169 15771 }
5bd4f169
AM		 15772 }
15773
6528b6eb
AM		 15774 if (htab->elf.sgot != NULL && htab->elf.sgot->size != 0
15775 && htab->elf.sgot->output_section != bfd_abs_section_ptr)
5d1634d7
AM		 15776 {
15777 /* Fill in the first entry in the global offset table.
15778 We use it to hold the link-time TOCbase. */
15779 bfd_put_64 (output_bfd,
60ee0d4a 15780 elf_gp (output_bfd) + TOC_BASE_OFF,
33e44f2e 15781 htab->elf.sgot->contents);
5d1634d7
AM		 15782
15783 /* Set .got entry size. */
33e44f2e 15784 elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize = 8;
5d1634d7
AM		 15785 }
15786
6528b6eb
AM		 15787 if (htab->elf.splt != NULL && htab->elf.splt->size != 0
15788 && htab->elf.splt->output_section != bfd_abs_section_ptr)
5d1634d7
AM		 15789 {
15790 /* Set .plt entry size. */
33e44f2e 15791 elf_section_data (htab->elf.splt->output_section)->this_hdr.sh_entsize
b9e5796b 15792 = PLT_ENTRY_SIZE (htab);
5d1634d7
AM		 15793 }
15794
84f5d08e
AM		 15795 /* brlt is SEC_LINKER_CREATED, so we need to write out relocs for
15796 brlt ourselves if emitrelocations. */
15797 if (htab->brlt != NULL
15798 && htab->brlt->reloc_count != 0
15799 && !_bfd_elf_link_output_relocs (output_bfd,
15800 htab->brlt,
d4730f92 15801 elf_section_data (htab->brlt)->rela.hdr,
84f5d08e
AM		 15802 elf_section_data (htab->brlt)->relocs,
15803 NULL))
15804 return FALSE;
15805
176a0d42
AM		 15806 if (htab->glink != NULL
15807 && htab->glink->reloc_count != 0
15808 && !_bfd_elf_link_output_relocs (output_bfd,
15809 htab->glink,
d4730f92 15810 elf_section_data (htab->glink)->rela.hdr,
176a0d42
AM		 15811 elf_section_data (htab->glink)->relocs,
15812 NULL))
15813 return FALSE;
15814
58d180e8 15815 if (htab->glink_eh_frame != NULL
da44f4e5
AM		 15816 && htab->glink_eh_frame->size != 0)
15817 {
15818 bfd_vma val;
15819 bfd_byte *p;
d4aaa2a0 15820 struct map_stub *group;
2e0ce1c8 15821 size_t align = 4;
da44f4e5 15822
2e0ce1c8
AM		 15823 p = htab->glink_eh_frame->contents;
15824 p += (sizeof (glink_eh_frame_cie) + align - 1) & -align;
d4aaa2a0
AM		 15825
15826 for (group = htab->group; group != NULL; group = group->next)
15827 if (group->stub_sec != NULL)
da44f4e5 15828 {
da44f4e5 15829 /* Offset to stub section. */
d4aaa2a0
AM		 15830 val = (group->stub_sec->output_section->vma
15831 + group->stub_sec->output_offset);
da44f4e5
AM		 15832 val -= (htab->glink_eh_frame->output_section->vma
15833 + htab->glink_eh_frame->output_offset
d4aaa2a0 15834 + (p + 8 - htab->glink_eh_frame->contents));
da44f4e5
AM		 15835 if (val + 0x80000000 > 0xffffffff)
15836 {
15837 info->callbacks->einfo
15838 (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
d4aaa2a0 15839 group->stub_sec->name);
da44f4e5
AM		 15840 return FALSE;
15841 }
d4aaa2a0
AM		 15842 bfd_put_32 (dynobj, val, p + 8);
15843 p += stub_eh_frame_size (group, align);
da44f4e5
AM		 15844 }
15845 if (htab->glink != NULL && htab->glink->size != 0)
15846 {
da44f4e5
AM		 15847 /* Offset to .glink. */
15848 val = (htab->glink->output_section->vma
15849 + htab->glink->output_offset
15850 + 8);
15851 val -= (htab->glink_eh_frame->output_section->vma
15852 + htab->glink_eh_frame->output_offset
d4aaa2a0 15853 + (p + 8 - htab->glink_eh_frame->contents));
da44f4e5
AM		 15854 if (val + 0x80000000 > 0xffffffff)
15855 {
15856 info->callbacks->einfo
15857 (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
15858 htab->glink->name);
15859 return FALSE;
15860 }
d4aaa2a0
AM		 15861 bfd_put_32 (dynobj, val, p + 8);
15862 p += (24 + align - 1) & -align;
da44f4e5
AM		 15863 }
15864
15865 if (htab->glink_eh_frame->sec_info_type == SEC_INFO_TYPE_EH_FRAME
15866 && !_bfd_elf_write_section_eh_frame (output_bfd, info,
15867 htab->glink_eh_frame,
15868 htab->glink_eh_frame->contents))
15869 return FALSE;
15870 }
58d180e8 15871
e717da7e 15872 /* We need to handle writing out multiple GOT sections ourselves,
7b53ace3
AM		 15873 since we didn't add them to DYNOBJ. We know dynobj is the first
15874 bfd. */
c72f2fb2 15875 while ((dynobj = dynobj->link.next) != NULL)
e717da7e
AM		 15876 {
15877 asection *s;
7b53ace3 15878
0c8d6e5c 15879 if (!is_ppc64_elf (dynobj))
7b53ace3
AM		 15880 continue;
15881
e717da7e
AM		 15882 s = ppc64_elf_tdata (dynobj)->got;
15883 if (s != NULL
eea6121a 15884 && s->size != 0
e717da7e
AM		 15885 && s->output_section != bfd_abs_section_ptr
15886 && !bfd_set_section_contents (output_bfd, s->output_section,
15887 s->contents, s->output_offset,
eea6121a 15888 s->size))
e717da7e
AM		 15889 return FALSE;
15890 s = ppc64_elf_tdata (dynobj)->relgot;
15891 if (s != NULL
eea6121a 15892 && s->size != 0
e717da7e
AM		 15893 && s->output_section != bfd_abs_section_ptr
15894 && !bfd_set_section_contents (output_bfd, s->output_section,
15895 s->contents, s->output_offset,
eea6121a 15896 s->size))
e717da7e
AM		 15897 return FALSE;
15898 }
f6c52c13 15899
b34976b6 15900 return TRUE;
5bd4f169
AM		 15901}
15902
5bd4f169 15903#include "elf64-target.h"
7b8e7dad
AM		 15904
15905/* FreeBSD support */
15906
15907#undef TARGET_LITTLE_SYM
15908#undef TARGET_LITTLE_NAME
15909
15910#undef TARGET_BIG_SYM
6d00b590 15911#define TARGET_BIG_SYM powerpc_elf64_fbsd_vec
7b8e7dad
AM		 15912#undef TARGET_BIG_NAME
15913#define TARGET_BIG_NAME "elf64-powerpc-freebsd"
15914
15915#undef ELF_OSABI
15916#define ELF_OSABI ELFOSABI_FREEBSD
15917
15918#undef elf64_bed
15919#define elf64_bed elf64_powerpc_fbsd_bed
15920
15921#include "elf64-target.h"
GDB Binutils - Deliverables
This page took 4.294348 seconds and 4 git commands to generate.