projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
sim: m68hc11/mips/mn10300/v850: add basic sim_pc_get
[deliverable/binutils-gdb.git] / bfd / elf64-ppc.c
CommitLineData
5bd4f169 1/* PowerPC64-specific support for 64-bit ELF.
b90efa5b 2 Copyright (C) 1999-2015 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
ad8e1ba5
AM		 75#define elf_backend_can_gc_sections 1
76#define elf_backend_can_refcount 1
77#define elf_backend_rela_normal 1
6bfdb61b 78#define elf_backend_default_execstack 0
ad8e1ba5 79
e717da7e 80#define bfd_elf64_mkobject ppc64_elf_mkobject
ad8e1ba5 81#define bfd_elf64_bfd_reloc_type_lookup ppc64_elf_reloc_type_lookup
aa374f67 82#define bfd_elf64_bfd_reloc_name_lookup ppc64_elf_reloc_name_lookup
ee67d69a
AM		 83#define bfd_elf64_bfd_merge_private_bfd_data ppc64_elf_merge_private_bfd_data
84#define bfd_elf64_bfd_print_private_bfd_data ppc64_elf_print_private_bfd_data
ad8e1ba5
AM		 85#define bfd_elf64_new_section_hook ppc64_elf_new_section_hook
86#define bfd_elf64_bfd_link_hash_table_create ppc64_elf_link_hash_table_create
90e3cdf2 87#define bfd_elf64_get_synthetic_symtab ppc64_elf_get_synthetic_symtab
aa374f67 88#define bfd_elf64_bfd_link_just_syms ppc64_elf_link_just_syms
ad8e1ba5
AM		 89
90#define elf_backend_object_p ppc64_elf_object_p
d37c89e5
AM		 91#define elf_backend_grok_prstatus ppc64_elf_grok_prstatus
92#define elf_backend_grok_psinfo ppc64_elf_grok_psinfo
183e98be 93#define elf_backend_write_core_note ppc64_elf_write_core_note
ad8e1ba5
AM		 94#define elf_backend_create_dynamic_sections ppc64_elf_create_dynamic_sections
95#define elf_backend_copy_indirect_symbol ppc64_elf_copy_indirect_symbol
555cd476 96#define elf_backend_add_symbol_hook ppc64_elf_add_symbol_hook
f6c7c3e8 97#define elf_backend_check_directives ppc64_elf_before_check_relocs
e5034e59 98#define elf_backend_notice_as_needed ppc64_elf_notice_as_needed
8387904d 99#define elf_backend_archive_symbol_lookup ppc64_elf_archive_symbol_lookup
ad8e1ba5 100#define elf_backend_check_relocs ppc64_elf_check_relocs
74f0fb50 101#define elf_backend_gc_keep ppc64_elf_gc_keep
64d03ab5 102#define elf_backend_gc_mark_dynamic_ref ppc64_elf_gc_mark_dynamic_ref
ad8e1ba5
AM		 103#define elf_backend_gc_mark_hook ppc64_elf_gc_mark_hook
104#define elf_backend_gc_sweep_hook ppc64_elf_gc_sweep_hook
105#define elf_backend_adjust_dynamic_symbol ppc64_elf_adjust_dynamic_symbol
106#define elf_backend_hide_symbol ppc64_elf_hide_symbol
9f296da3 107#define elf_backend_maybe_function_sym ppc64_elf_maybe_function_sym
ad8e1ba5
AM		 108#define elf_backend_always_size_sections ppc64_elf_func_desc_adjust
109#define elf_backend_size_dynamic_sections ppc64_elf_size_dynamic_sections
a345bc8d 110#define elf_backend_hash_symbol ppc64_elf_hash_symbol
74541ad4 111#define elf_backend_init_index_section _bfd_elf_init_2_index_sections
60124e18 112#define elf_backend_action_discarded ppc64_elf_action_discarded
ad8e1ba5
AM		 113#define elf_backend_relocate_section ppc64_elf_relocate_section
114#define elf_backend_finish_dynamic_symbol ppc64_elf_finish_dynamic_symbol
115#define elf_backend_reloc_type_class ppc64_elf_reloc_type_class
116#define elf_backend_finish_dynamic_sections ppc64_elf_finish_dynamic_sections
754021d0 117#define elf_backend_link_output_symbol_hook ppc64_elf_output_symbol_hook
29ef7005 118#define elf_backend_special_sections ppc64_elf_special_sections
6911b7dc 119#define elf_backend_merge_symbol_attribute ppc64_elf_merge_symbol_attribute
ad8e1ba5 120
5bd4f169
AM		 121/* The name of the dynamic interpreter. This is put in the .interp
122 section. */
123#define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
124
125/* The size in bytes of an entry in the procedure linkage table. */
b9e5796b 126#define PLT_ENTRY_SIZE(htab) (htab->opd_abi ? 24 : 8)
5bd4f169
AM		 127
128/* The initial size of the plt reserved for the dynamic linker. */
b9e5796b 129#define PLT_INITIAL_ENTRY_SIZE(htab) (htab->opd_abi ? 24 : 16)
5bd4f169 130
a078d95a
AM		 131/* Offsets to some stack save slots. */
132#define STK_LR 16
133#define STK_TOC(htab) (htab->opd_abi ? 40 : 24)
eb8d7fda 134/* This one is dodgy. ELFv2 does not have a linker word, so use the
a078d95a
AM		 135 CR save slot. Used only by optimised __tls_get_addr call stub,
136 relying on __tls_get_addr_opt not saving CR.. */
137#define STK_LINKER(htab) (htab->opd_abi ? 32 : 8)
138
5bd4f169 139/* TOC base pointers offset from start of TOC. */
411e1bfb
AM		 140#define TOC_BASE_OFF 0x8000
141
142/* Offset of tp and dtp pointers from start of TLS block. */
143#define TP_OFFSET 0x7000
144#define DTP_OFFSET 0x8000
5bd4f169 145
ad8e1ba5
AM		 146/* .plt call stub instructions. The normal stub is like this, but
147 sometimes the .plt entry crosses a 64k boundary and we need to
71a39c98 148 insert an addi to adjust r11. */
a078d95a 149#define STD_R2_0R1 0xf8410000 /* std %r2,0+40(%r1) */
71a39c98
AM		 150#define ADDIS_R11_R2 0x3d620000 /* addis %r11,%r2,xxx@ha */
151#define LD_R12_0R11 0xe98b0000 /* ld %r12,xxx+0@l(%r11) */
152#define MTCTR_R12 0x7d8903a6 /* mtctr %r12 */
153#define LD_R2_0R11 0xe84b0000 /* ld %r2,xxx+8@l(%r11) */
154#define LD_R11_0R11 0xe96b0000 /* ld %r11,xxx+16@l(%r11) */
5d1634d7
AM		 155#define BCTR 0x4e800420 /* bctr */
156
71a39c98 157#define ADDI_R11_R11 0x396b0000 /* addi %r11,%r11,off@l */
ad8e1ba5
AM		 158#define ADDIS_R2_R2 0x3c420000 /* addis %r2,%r2,off@ha */
159#define ADDI_R2_R2 0x38420000 /* addi %r2,%r2,off@l */
160
71a39c98
AM		 161#define XOR_R2_R12_R12 0x7d826278 /* xor %r2,%r12,%r12 */
162#define ADD_R11_R11_R2 0x7d6b1214 /* add %r11,%r11,%r2 */
163#define XOR_R11_R12_R12 0x7d8b6278 /* xor %r11,%r12,%r12 */
794e51c0
AM		 164#define ADD_R2_R2_R11 0x7c425a14 /* add %r2,%r2,%r11 */
165#define CMPLDI_R2_0 0x28220000 /* cmpldi %r2,0 */
166#define BNECTR 0x4ca20420 /* bnectr+ */
167#define BNECTR_P4 0x4ce20420 /* bnectr+ */
168
71a39c98 169#define LD_R12_0R2 0xe9820000 /* ld %r12,xxx+0(%r2) */
ac2df442
AM		 170#define LD_R11_0R2 0xe9620000 /* ld %r11,xxx+0(%r2) */
171#define LD_R2_0R2 0xe8420000 /* ld %r2,xxx+0(%r2) */
172
a078d95a 173#define LD_R2_0R1 0xe8410000 /* ld %r2,0(%r1) */
ad8e1ba5 174
397998fc 175#define ADDIS_R12_R2 0x3d820000 /* addis %r12,%r2,xxx@ha */
a345bc8d
AM		 176#define ADDIS_R12_R12 0x3d8c0000 /* addis %r12,%r12,xxx@ha */
177#define LD_R12_0R12 0xe98c0000 /* ld %r12,xxx@l(%r12) */
178
ee4bf8d2 179/* glink call stub instructions. We enter with the index in R0. */
ad8e1ba5 180#define GLINK_CALL_STUB_SIZE (16*4)
ee4bf8d2
AM		 181 /* 0: */
182 /* .quad plt0-1f */
183 /* __glink: */
184#define MFLR_R12 0x7d8802a6 /* mflr %12 */
185#define BCL_20_31 0x429f0005 /* bcl 20,31,1f */
186 /* 1: */
187#define MFLR_R11 0x7d6802a6 /* mflr %11 */
71a39c98 188 /* ld %2,(0b-1b)(%11) */
ee4bf8d2 189#define MTLR_R12 0x7d8803a6 /* mtlr %12 */
71a39c98
AM		 190#define ADD_R11_R2_R11 0x7d625a14 /* add %11,%2,%11 */
191 /* ld %12,0(%11) */
192 /* ld %2,8(%11) */
193 /* mtctr %12 */
194 /* ld %11,16(%11) */
ee4bf8d2 195 /* bctr */
b9e5796b
AM		 196#define MFLR_R0 0x7c0802a6 /* mflr %r0 */
197#define MTLR_R0 0x7c0803a6 /* mtlr %r0 */
198#define SUB_R12_R12_R11 0x7d8b6050 /* subf %r12,%r11,%r12 */
199#define ADDI_R0_R12 0x380c0000 /* addi %r0,%r12,0 */
200#define SRDI_R0_R0_2 0x7800f082 /* rldicl %r0,%r0,62,2 */
5d1634d7
AM		 201
202/* Pad with this. */
203#define NOP 0x60000000
204
721956f4
AM		 205/* Some other nops. */
206#define CROR_151515 0x4def7b82
207#define CROR_313131 0x4ffffb82
208
cedb70c5 209/* .glink entries for the first 32k functions are two instructions. */
5d1634d7
AM		 210#define LI_R0_0 0x38000000 /* li %r0,0 */
211#define B_DOT 0x48000000 /* b . */
212
213/* After that, we need two instructions to load the index, followed by
214 a branch. */
215#define LIS_R0_0 0x3c000000 /* lis %r0,0 */
10ed1bba 216#define ORI_R0_R0_0 0x60000000 /* ori %r0,%r0,0 */
41bd81ab 217
deb0e272
AM		 218/* Instructions used by the save and restore reg functions. */
219#define STD_R0_0R1 0xf8010000 /* std %r0,0(%r1) */
220#define STD_R0_0R12 0xf80c0000 /* std %r0,0(%r12) */
221#define LD_R0_0R1 0xe8010000 /* ld %r0,0(%r1) */
222#define LD_R0_0R12 0xe80c0000 /* ld %r0,0(%r12) */
82bd7b59
AM		 223#define STFD_FR0_0R1 0xd8010000 /* stfd %fr0,0(%r1) */
224#define LFD_FR0_0R1 0xc8010000 /* lfd %fr0,0(%r1) */
deb0e272
AM		 225#define LI_R12_0 0x39800000 /* li %r12,0 */
226#define STVX_VR0_R12_R0 0x7c0c01ce /* stvx %v0,%r12,%r0 */
227#define LVX_VR0_R12_R0 0x7c0c00ce /* lvx %v0,%r12,%r0 */
228#define MTLR_R0 0x7c0803a6 /* mtlr %r0 */
82bd7b59
AM		 229#define BLR 0x4e800020 /* blr */
230
41bd81ab
AM		 231/* Since .opd is an array of descriptors and each entry will end up
232 with identical R_PPC64_RELATIVE relocs, there is really no need to
233 propagate .opd relocs; The dynamic linker should be taught to
1e2f5b6e 234 relocate .opd without reloc entries. */
41bd81ab
AM		 235#ifndef NO_OPD_RELOCS
236#define NO_OPD_RELOCS 0
237#endif
810d4e75
AM		 238
239static inline int
240abiversion (bfd *abfd)
241{
242 return elf_elfheader (abfd)->e_flags & EF_PPC64_ABI;
243}
244
245static inline void
246set_abiversion (bfd *abfd, int ver)
247{
248 elf_elfheader (abfd)->e_flags &= ~EF_PPC64_ABI;
249 elf_elfheader (abfd)->e_flags |= ver & EF_PPC64_ABI;
250}
5bd4f169 251\f
f5e87a1d 252#define ONES(n) (((bfd_vma) 1 << ((n) - 1) << 1) - 1)
b34976b6 253
5bd4f169 254/* Relocation HOWTO's. */
04c9666a 255static reloc_howto_type *ppc64_elf_howto_table[(int) R_PPC64_max];
5bd4f169
AM		 256
257static reloc_howto_type ppc64_elf_howto_raw[] = {
258 /* This reloc does nothing. */
259 HOWTO (R_PPC64_NONE, /* type */
260 0, /* rightshift */
6346d5ca
AM		 261 3, /* size (0 = byte, 1 = short, 2 = long) */
262 0, /* bitsize */
b34976b6 263 FALSE, /* pc_relative */
5bd4f169 264 0, /* bitpos */
f5e87a1d 265 complain_overflow_dont, /* complain_on_overflow */
5bd4f169
AM		 266 bfd_elf_generic_reloc, /* special_function */
267 "R_PPC64_NONE", /* name */
b34976b6 268 FALSE, /* partial_inplace */
d006db6c 269 0, /* src_mask */
5bd4f169 270 0, /* dst_mask */
b34976b6 271 FALSE), /* pcrel_offset */
5bd4f169
AM		 272
273 /* A standard 32 bit relocation. */
274 HOWTO (R_PPC64_ADDR32, /* type */
275 0, /* rightshift */
276 2, /* size (0 = byte, 1 = short, 2 = long) */
277 32, /* bitsize */
b34976b6 278 FALSE, /* pc_relative */
5bd4f169
AM		 279 0, /* bitpos */
280 complain_overflow_bitfield, /* complain_on_overflow */
281 bfd_elf_generic_reloc, /* special_function */
282 "R_PPC64_ADDR32", /* name */
b34976b6 283 FALSE, /* partial_inplace */
5bd4f169
AM		 284 0, /* src_mask */
285 0xffffffff, /* dst_mask */
b34976b6 286 FALSE), /* pcrel_offset */
5bd4f169
AM		 287
288 /* An absolute 26 bit branch; the lower two bits must be zero.
289 FIXME: we don't check that, we just clear them. */
290 HOWTO (R_PPC64_ADDR24, /* type */
291 0, /* rightshift */
292 2, /* size (0 = byte, 1 = short, 2 = long) */
293 26, /* bitsize */
b34976b6 294 FALSE, /* pc_relative */
5bd4f169
AM		 295 0, /* bitpos */
296 complain_overflow_bitfield, /* complain_on_overflow */
297 bfd_elf_generic_reloc, /* special_function */
298 "R_PPC64_ADDR24", /* name */
b34976b6 299 FALSE, /* partial_inplace */
d006db6c 300 0, /* src_mask */
f5e87a1d 301 0x03fffffc, /* dst_mask */
b34976b6 302 FALSE), /* pcrel_offset */
5bd4f169
AM		 303
304 /* A standard 16 bit relocation. */
305 HOWTO (R_PPC64_ADDR16, /* type */
306 0, /* rightshift */
307 1, /* size (0 = byte, 1 = short, 2 = long) */
308 16, /* 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_ADDR16", /* name */
b34976b6 314 FALSE, /* partial_inplace */
5bd4f169
AM		 315 0, /* src_mask */
316 0xffff, /* dst_mask */
b34976b6 317 FALSE), /* pcrel_offset */
5bd4f169
AM		 318
319 /* A 16 bit relocation without overflow. */
320 HOWTO (R_PPC64_ADDR16_LO, /* 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_dont,/* complain_on_overflow */
327 bfd_elf_generic_reloc, /* special_function */
328 "R_PPC64_ADDR16_LO", /* 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 /* Bits 16-31 of an address. */
335 HOWTO (R_PPC64_ADDR16_HI, /* type */
336 16, /* rightshift */
337 1, /* size (0 = byte, 1 = short, 2 = long) */
338 16, /* bitsize */
b34976b6 339 FALSE, /* pc_relative */
5bd4f169 340 0, /* bitpos */
f9c6b907 341 complain_overflow_signed, /* complain_on_overflow */
5bd4f169
AM		 342 bfd_elf_generic_reloc, /* special_function */
343 "R_PPC64_ADDR16_HI", /* 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, plus 1 if the contents of the low 16
350 bits, treated as a signed number, is negative. */
351 HOWTO (R_PPC64_ADDR16_HA, /* type */
352 16, /* rightshift */
353 1, /* size (0 = byte, 1 = short, 2 = long) */
354 16, /* bitsize */
b34976b6 355 FALSE, /* pc_relative */
5bd4f169 356 0, /* bitpos */
f9c6b907 357 complain_overflow_signed, /* complain_on_overflow */
805fc799 358 ppc64_elf_ha_reloc, /* special_function */
5bd4f169 359 "R_PPC64_ADDR16_HA", /* name */
b34976b6 360 FALSE, /* partial_inplace */
5bd4f169
AM		 361 0, /* src_mask */
362 0xffff, /* dst_mask */
b34976b6 363 FALSE), /* pcrel_offset */
5bd4f169
AM		 364
365 /* An absolute 16 bit branch; the lower two bits must be zero.
366 FIXME: we don't check that, we just clear them. */
367 HOWTO (R_PPC64_ADDR14, /* type */
368 0, /* rightshift */
369 2, /* size (0 = byte, 1 = short, 2 = long) */
370 16, /* bitsize */
b34976b6 371 FALSE, /* pc_relative */
5bd4f169 372 0, /* bitpos */
b80eed39 373 complain_overflow_signed, /* complain_on_overflow */
2441e016 374 ppc64_elf_branch_reloc, /* special_function */
5bd4f169 375 "R_PPC64_ADDR14", /* name */
b34976b6 376 FALSE, /* partial_inplace */
d006db6c 377 0, /* src_mask */
f5e87a1d 378 0x0000fffc, /* dst_mask */
b34976b6 379 FALSE), /* pcrel_offset */
5bd4f169
AM		 380
381 /* An absolute 16 bit branch, for which bit 10 should be set to
382 indicate that the branch is expected to be taken. The lower two
383 bits must be zero. */
384 HOWTO (R_PPC64_ADDR14_BRTAKEN, /* type */
385 0, /* rightshift */
386 2, /* size (0 = byte, 1 = short, 2 = long) */
387 16, /* bitsize */
b34976b6 388 FALSE, /* pc_relative */
5bd4f169 389 0, /* bitpos */
b80eed39 390 complain_overflow_signed, /* complain_on_overflow */
805fc799 391 ppc64_elf_brtaken_reloc, /* special_function */
5bd4f169 392 "R_PPC64_ADDR14_BRTAKEN",/* name */
b34976b6 393 FALSE, /* partial_inplace */
d006db6c 394 0, /* src_mask */
f5e87a1d 395 0x0000fffc, /* dst_mask */
b34976b6 396 FALSE), /* pcrel_offset */
5bd4f169
AM		 397
398 /* An absolute 16 bit branch, for which bit 10 should be set to
399 indicate that the branch is not expected to be taken. The lower
400 two bits must be zero. */
401 HOWTO (R_PPC64_ADDR14_BRNTAKEN, /* type */
402 0, /* rightshift */
403 2, /* size (0 = byte, 1 = short, 2 = long) */
404 16, /* bitsize */
b34976b6 405 FALSE, /* pc_relative */
5bd4f169 406 0, /* bitpos */
b80eed39 407 complain_overflow_signed, /* complain_on_overflow */
805fc799 408 ppc64_elf_brtaken_reloc, /* special_function */
5bd4f169 409 "R_PPC64_ADDR14_BRNTAKEN",/* name */
b34976b6 410 FALSE, /* partial_inplace */
d006db6c 411 0, /* src_mask */
f5e87a1d 412 0x0000fffc, /* dst_mask */
b34976b6 413 FALSE), /* pcrel_offset */
5bd4f169
AM		 414
415 /* A relative 26 bit branch; the lower two bits must be zero. */
416 HOWTO (R_PPC64_REL24, /* type */
417 0, /* rightshift */
418 2, /* size (0 = byte, 1 = short, 2 = long) */
419 26, /* bitsize */
b34976b6 420 TRUE, /* pc_relative */
5bd4f169
AM		 421 0, /* bitpos */
422 complain_overflow_signed, /* complain_on_overflow */
2441e016 423 ppc64_elf_branch_reloc, /* special_function */
5bd4f169 424 "R_PPC64_REL24", /* name */
b34976b6 425 FALSE, /* partial_inplace */
d006db6c 426 0, /* src_mask */
f5e87a1d 427 0x03fffffc, /* dst_mask */
b34976b6 428 TRUE), /* pcrel_offset */
5bd4f169
AM		 429
430 /* A relative 16 bit branch; the lower two bits must be zero. */
431 HOWTO (R_PPC64_REL14, /* type */
432 0, /* rightshift */
433 2, /* size (0 = byte, 1 = short, 2 = long) */
434 16, /* 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_REL14", /* name */
b34976b6 440 FALSE, /* partial_inplace */
d006db6c 441 0, /* src_mask */
f5e87a1d 442 0x0000fffc, /* dst_mask */
b34976b6 443 TRUE), /* pcrel_offset */
5bd4f169
AM		 444
445 /* A relative 16 bit branch. Bit 10 should be set to indicate that
446 the branch is expected to be taken. The lower two bits must be
447 zero. */
448 HOWTO (R_PPC64_REL14_BRTAKEN, /* type */
449 0, /* rightshift */
450 2, /* size (0 = byte, 1 = short, 2 = long) */
451 16, /* bitsize */
b34976b6 452 TRUE, /* pc_relative */
5bd4f169
AM		 453 0, /* bitpos */
454 complain_overflow_signed, /* complain_on_overflow */
805fc799 455 ppc64_elf_brtaken_reloc, /* special_function */
5bd4f169 456 "R_PPC64_REL14_BRTAKEN", /* name */
b34976b6 457 FALSE, /* partial_inplace */
d006db6c 458 0, /* src_mask */
f5e87a1d 459 0x0000fffc, /* dst_mask */
b34976b6 460 TRUE), /* pcrel_offset */
5bd4f169
AM		 461
462 /* A relative 16 bit branch. Bit 10 should be set to indicate that
463 the branch is not expected to be taken. The lower two bits must
464 be zero. */
465 HOWTO (R_PPC64_REL14_BRNTAKEN, /* type */
466 0, /* rightshift */
467 2, /* size (0 = byte, 1 = short, 2 = long) */
468 16, /* bitsize */
b34976b6 469 TRUE, /* pc_relative */
5bd4f169
AM		 470 0, /* bitpos */
471 complain_overflow_signed, /* complain_on_overflow */
805fc799 472 ppc64_elf_brtaken_reloc, /* special_function */
5bd4f169 473 "R_PPC64_REL14_BRNTAKEN",/* name */
b34976b6 474 FALSE, /* partial_inplace */
d006db6c 475 0, /* src_mask */
f5e87a1d 476 0x0000fffc, /* dst_mask */
b34976b6 477 TRUE), /* pcrel_offset */
5bd4f169
AM		 478
479 /* Like R_PPC64_ADDR16, but referring to the GOT table entry for the
480 symbol. */
481 HOWTO (R_PPC64_GOT16, /* type */
482 0, /* rightshift */
483 1, /* size (0 = byte, 1 = short, 2 = long) */
484 16, /* bitsize */
b34976b6 485 FALSE, /* pc_relative */
5bd4f169
AM		 486 0, /* bitpos */
487 complain_overflow_signed, /* complain_on_overflow */
805fc799 488 ppc64_elf_unhandled_reloc, /* special_function */
5bd4f169 489 "R_PPC64_GOT16", /* name */
b34976b6 490 FALSE, /* partial_inplace */
5bd4f169
AM		 491 0, /* src_mask */
492 0xffff, /* dst_mask */
b34976b6 493 FALSE), /* pcrel_offset */
5bd4f169
AM		 494
495 /* Like R_PPC64_ADDR16_LO, but referring to the GOT table entry for
496 the symbol. */
497 HOWTO (R_PPC64_GOT16_LO, /* type */
498 0, /* rightshift */
499 1, /* size (0 = byte, 1 = short, 2 = long) */
500 16, /* bitsize */
b34976b6 501 FALSE, /* pc_relative */
5bd4f169
AM		 502 0, /* bitpos */
503 complain_overflow_dont, /* complain_on_overflow */
805fc799 504 ppc64_elf_unhandled_reloc, /* special_function */
5bd4f169 505 "R_PPC64_GOT16_LO", /* name */
b34976b6 506 FALSE, /* partial_inplace */
5bd4f169
AM		 507 0, /* src_mask */
508 0xffff, /* dst_mask */
b34976b6 509 FALSE), /* pcrel_offset */
5bd4f169
AM		 510
511 /* Like R_PPC64_ADDR16_HI, but referring to the GOT table entry for
512 the symbol. */
513 HOWTO (R_PPC64_GOT16_HI, /* type */
514 16, /* rightshift */
515 1, /* size (0 = byte, 1 = short, 2 = long) */
516 16, /* bitsize */
b34976b6 517 FALSE, /* pc_relative */
5bd4f169 518 0, /* bitpos */
f9c6b907 519 complain_overflow_signed,/* complain_on_overflow */
805fc799 520 ppc64_elf_unhandled_reloc, /* special_function */
5bd4f169 521 "R_PPC64_GOT16_HI", /* name */
b34976b6 522 FALSE, /* partial_inplace */
5bd4f169
AM		 523 0, /* src_mask */
524 0xffff, /* dst_mask */
b34976b6 525 FALSE), /* pcrel_offset */
5bd4f169
AM		 526
527 /* Like R_PPC64_ADDR16_HA, but referring to the GOT table entry for
528 the symbol. */
529 HOWTO (R_PPC64_GOT16_HA, /* type */
530 16, /* rightshift */
531 1, /* size (0 = byte, 1 = short, 2 = long) */
532 16, /* bitsize */
b34976b6 533 FALSE, /* pc_relative */
5bd4f169 534 0, /* bitpos */
f9c6b907 535 complain_overflow_signed,/* complain_on_overflow */
805fc799 536 ppc64_elf_unhandled_reloc, /* special_function */
5bd4f169 537 "R_PPC64_GOT16_HA", /* name */
b34976b6 538 FALSE, /* partial_inplace */
5bd4f169
AM		 539 0, /* src_mask */
540 0xffff, /* dst_mask */
b34976b6 541 FALSE), /* pcrel_offset */
5bd4f169
AM		 542
543 /* This is used only by the dynamic linker. The symbol should exist
544 both in the object being run and in some shared library. The
545 dynamic linker copies the data addressed by the symbol from the
546 shared library into the object, because the object being
547 run has to have the data at some particular address. */
548 HOWTO (R_PPC64_COPY, /* type */
549 0, /* rightshift */
f5e87a1d
AM		 550 0, /* this one is variable size */
551 0, /* bitsize */
b34976b6 552 FALSE, /* pc_relative */
5bd4f169 553 0, /* bitpos */
f5e87a1d
AM		 554 complain_overflow_dont, /* complain_on_overflow */
555 ppc64_elf_unhandled_reloc, /* special_function */
5bd4f169 556 "R_PPC64_COPY", /* name */
b34976b6 557 FALSE, /* partial_inplace */
5bd4f169
AM		 558 0, /* src_mask */
559 0, /* dst_mask */
b34976b6 560 FALSE), /* pcrel_offset */
5bd4f169
AM		 561
562 /* Like R_PPC64_ADDR64, but used when setting global offset table
563 entries. */
564 HOWTO (R_PPC64_GLOB_DAT, /* type */
565 0, /* rightshift */
566 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
567 64, /* bitsize */
b34976b6 568 FALSE, /* pc_relative */
5bd4f169
AM		 569 0, /* bitpos */
570 complain_overflow_dont, /* complain_on_overflow */
805fc799 571 ppc64_elf_unhandled_reloc, /* special_function */
5bd4f169 572 "R_PPC64_GLOB_DAT", /* name */
b34976b6 573 FALSE, /* partial_inplace */
5bd4f169 574 0, /* src_mask */
f5e87a1d 575 ONES (64), /* dst_mask */
b34976b6 576 FALSE), /* pcrel_offset */
5bd4f169
AM		 577
578 /* Created by the link editor. Marks a procedure linkage table
579 entry for a symbol. */
580 HOWTO (R_PPC64_JMP_SLOT, /* type */
581 0, /* rightshift */
582 0, /* size (0 = byte, 1 = short, 2 = long) */
583 0, /* bitsize */
b34976b6 584 FALSE, /* pc_relative */
5bd4f169
AM		 585 0, /* bitpos */
586 complain_overflow_dont, /* complain_on_overflow */
805fc799 587 ppc64_elf_unhandled_reloc, /* special_function */
5bd4f169 588 "R_PPC64_JMP_SLOT", /* name */
b34976b6 589 FALSE, /* partial_inplace */
5bd4f169
AM		 590 0, /* src_mask */
591 0, /* dst_mask */
b34976b6 592 FALSE), /* pcrel_offset */
5bd4f169
AM		 593
594 /* Used only by the dynamic linker. When the object is run, this
595 doubleword64 is set to the load address of the object, plus the
596 addend. */
597 HOWTO (R_PPC64_RELATIVE, /* type */
598 0, /* rightshift */
599 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
600 64, /* bitsize */
b34976b6 601 FALSE, /* pc_relative */
5bd4f169
AM		 602 0, /* bitpos */
603 complain_overflow_dont, /* complain_on_overflow */
604 bfd_elf_generic_reloc, /* special_function */
605 "R_PPC64_RELATIVE", /* name */
b34976b6 606 FALSE, /* partial_inplace */
5bd4f169 607 0, /* src_mask */
f5e87a1d 608 ONES (64), /* dst_mask */
b34976b6 609 FALSE), /* pcrel_offset */
5bd4f169
AM		 610
611 /* Like R_PPC64_ADDR32, but may be unaligned. */
612 HOWTO (R_PPC64_UADDR32, /* type */
613 0, /* rightshift */
614 2, /* size (0 = byte, 1 = short, 2 = long) */
615 32, /* bitsize */
b34976b6 616 FALSE, /* pc_relative */
5bd4f169
AM		 617 0, /* bitpos */
618 complain_overflow_bitfield, /* complain_on_overflow */
619 bfd_elf_generic_reloc, /* special_function */
620 "R_PPC64_UADDR32", /* name */
b34976b6 621 FALSE, /* partial_inplace */
5bd4f169
AM		 622 0, /* src_mask */
623 0xffffffff, /* dst_mask */
b34976b6 624 FALSE), /* pcrel_offset */
5bd4f169
AM		 625
626 /* Like R_PPC64_ADDR16, but may be unaligned. */
627 HOWTO (R_PPC64_UADDR16, /* type */
628 0, /* rightshift */
629 1, /* size (0 = byte, 1 = short, 2 = long) */
630 16, /* 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_UADDR16", /* name */
b34976b6 636 FALSE, /* partial_inplace */
5bd4f169
AM		 637 0, /* src_mask */
638 0xffff, /* dst_mask */
b34976b6 639 FALSE), /* pcrel_offset */
5bd4f169
AM		 640
641 /* 32-bit PC relative. */
642 HOWTO (R_PPC64_REL32, /* type */
643 0, /* rightshift */
644 2, /* size (0 = byte, 1 = short, 2 = long) */
645 32, /* bitsize */
b34976b6 646 TRUE, /* pc_relative */
5bd4f169 647 0, /* bitpos */
5bd4f169
AM		 648 complain_overflow_signed, /* complain_on_overflow */
649 bfd_elf_generic_reloc, /* special_function */
650 "R_PPC64_REL32", /* name */
b34976b6 651 FALSE, /* partial_inplace */
5bd4f169
AM		 652 0, /* src_mask */
653 0xffffffff, /* dst_mask */
b34976b6 654 TRUE), /* pcrel_offset */
5bd4f169 655
10ed1bba 656 /* 32-bit relocation to the symbol's procedure linkage table. */
5bd4f169
AM		 657 HOWTO (R_PPC64_PLT32, /* type */
658 0, /* rightshift */
659 2, /* size (0 = byte, 1 = short, 2 = long) */
660 32, /* bitsize */
b34976b6 661 FALSE, /* pc_relative */
5bd4f169
AM		 662 0, /* bitpos */
663 complain_overflow_bitfield, /* complain_on_overflow */
805fc799 664 ppc64_elf_unhandled_reloc, /* special_function */
5bd4f169 665 "R_PPC64_PLT32", /* name */
b34976b6 666 FALSE, /* partial_inplace */
5bd4f169 667 0, /* src_mask */
f5e87a1d 668 0xffffffff, /* dst_mask */
b34976b6 669 FALSE), /* pcrel_offset */
5bd4f169
AM		 670
671 /* 32-bit PC relative relocation to the symbol's procedure linkage table.
672 FIXME: R_PPC64_PLTREL32 not supported. */
673 HOWTO (R_PPC64_PLTREL32, /* type */
674 0, /* rightshift */
675 2, /* size (0 = byte, 1 = short, 2 = long) */
676 32, /* bitsize */
b34976b6 677 TRUE, /* pc_relative */
5bd4f169
AM		 678 0, /* bitpos */
679 complain_overflow_signed, /* complain_on_overflow */
680 bfd_elf_generic_reloc, /* special_function */
681 "R_PPC64_PLTREL32", /* name */
b34976b6 682 FALSE, /* partial_inplace */
5bd4f169 683 0, /* src_mask */
f5e87a1d 684 0xffffffff, /* dst_mask */
b34976b6 685 TRUE), /* pcrel_offset */
5bd4f169
AM		 686
687 /* Like R_PPC64_ADDR16_LO, but referring to the PLT table entry for
688 the symbol. */
689 HOWTO (R_PPC64_PLT16_LO, /* type */
690 0, /* rightshift */
691 1, /* size (0 = byte, 1 = short, 2 = long) */
692 16, /* bitsize */
b34976b6 693 FALSE, /* pc_relative */
5bd4f169
AM		 694 0, /* bitpos */
695 complain_overflow_dont, /* complain_on_overflow */
805fc799 696 ppc64_elf_unhandled_reloc, /* special_function */
5bd4f169 697 "R_PPC64_PLT16_LO", /* name */
b34976b6 698 FALSE, /* partial_inplace */
5bd4f169
AM		 699 0, /* src_mask */
700 0xffff, /* dst_mask */
b34976b6 701 FALSE), /* pcrel_offset */
5bd4f169
AM		 702
703 /* Like R_PPC64_ADDR16_HI, but referring to the PLT table entry for
704 the symbol. */
705 HOWTO (R_PPC64_PLT16_HI, /* type */
706 16, /* rightshift */
707 1, /* size (0 = byte, 1 = short, 2 = long) */
708 16, /* bitsize */
b34976b6 709 FALSE, /* pc_relative */
5bd4f169 710 0, /* bitpos */
f9c6b907 711 complain_overflow_signed, /* complain_on_overflow */
805fc799 712 ppc64_elf_unhandled_reloc, /* special_function */
5bd4f169 713 "R_PPC64_PLT16_HI", /* name */
b34976b6 714 FALSE, /* partial_inplace */
5bd4f169
AM		 715 0, /* src_mask */
716 0xffff, /* dst_mask */
b34976b6 717 FALSE), /* pcrel_offset */
5bd4f169
AM		 718
719 /* Like R_PPC64_ADDR16_HA, but referring to the PLT table entry for
720 the symbol. */
721 HOWTO (R_PPC64_PLT16_HA, /* type */
722 16, /* rightshift */
723 1, /* size (0 = byte, 1 = short, 2 = long) */
724 16, /* bitsize */
b34976b6 725 FALSE, /* pc_relative */
5bd4f169 726 0, /* bitpos */
f9c6b907 727 complain_overflow_signed, /* complain_on_overflow */
805fc799 728 ppc64_elf_unhandled_reloc, /* special_function */
5bd4f169 729 "R_PPC64_PLT16_HA", /* name */
b34976b6 730 FALSE, /* partial_inplace */
5bd4f169
AM		 731 0, /* src_mask */
732 0xffff, /* dst_mask */
b34976b6 733 FALSE), /* pcrel_offset */
5bd4f169 734
c061c2d8 735 /* 16-bit section relative relocation. */
5bd4f169
AM		 736 HOWTO (R_PPC64_SECTOFF, /* type */
737 0, /* rightshift */
c061c2d8
AM		 738 1, /* size (0 = byte, 1 = short, 2 = long) */
739 16, /* bitsize */
b34976b6 740 FALSE, /* pc_relative */
5bd4f169 741 0, /* bitpos */
b80eed39 742 complain_overflow_signed, /* complain_on_overflow */
805fc799 743 ppc64_elf_sectoff_reloc, /* special_function */
5bd4f169 744 "R_PPC64_SECTOFF", /* name */
b34976b6 745 FALSE, /* partial_inplace */
5bd4f169 746 0, /* src_mask */
c061c2d8 747 0xffff, /* dst_mask */
b34976b6 748 FALSE), /* pcrel_offset */
5bd4f169 749
c061c2d8 750 /* Like R_PPC64_SECTOFF, but no overflow warning. */
5bd4f169
AM		 751 HOWTO (R_PPC64_SECTOFF_LO, /* type */
752 0, /* rightshift */
753 1, /* size (0 = byte, 1 = short, 2 = long) */
754 16, /* bitsize */
b34976b6 755 FALSE, /* pc_relative */
5bd4f169
AM		 756 0, /* bitpos */
757 complain_overflow_dont, /* complain_on_overflow */
805fc799 758 ppc64_elf_sectoff_reloc, /* special_function */
5bd4f169 759 "R_PPC64_SECTOFF_LO", /* name */
b34976b6 760 FALSE, /* partial_inplace */
5bd4f169
AM		 761 0, /* src_mask */
762 0xffff, /* dst_mask */
b34976b6 763 FALSE), /* pcrel_offset */
5bd4f169
AM		 764
765 /* 16-bit upper half section relative relocation. */
766 HOWTO (R_PPC64_SECTOFF_HI, /* type */
767 16, /* rightshift */
768 1, /* size (0 = byte, 1 = short, 2 = long) */
769 16, /* bitsize */
b34976b6 770 FALSE, /* pc_relative */
5bd4f169 771 0, /* bitpos */
f9c6b907 772 complain_overflow_signed, /* complain_on_overflow */
805fc799 773 ppc64_elf_sectoff_reloc, /* special_function */
5bd4f169 774 "R_PPC64_SECTOFF_HI", /* 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 adjusted section relative relocation. */
781 HOWTO (R_PPC64_SECTOFF_HA, /* 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_ha_reloc, /* special_function */
5bd4f169 789 "R_PPC64_SECTOFF_HA", /* name */
b34976b6 790 FALSE, /* partial_inplace */
5bd4f169
AM		 791 0, /* src_mask */
792 0xffff, /* dst_mask */
b34976b6 793 FALSE), /* pcrel_offset */
5bd4f169 794
04c9666a
AM		 795 /* Like R_PPC64_REL24 without touching the two least significant bits. */
796 HOWTO (R_PPC64_REL30, /* type */
5bd4f169
AM		 797 2, /* rightshift */
798 2, /* size (0 = byte, 1 = short, 2 = long) */
799 30, /* bitsize */
b34976b6 800 TRUE, /* pc_relative */
5bd4f169
AM		 801 0, /* bitpos */
802 complain_overflow_dont, /* complain_on_overflow */
803 bfd_elf_generic_reloc, /* special_function */
04c9666a 804 "R_PPC64_REL30", /* name */
b34976b6 805 FALSE, /* partial_inplace */
d006db6c 806 0, /* src_mask */
5bd4f169 807 0xfffffffc, /* dst_mask */
b34976b6 808 TRUE), /* pcrel_offset */
5bd4f169
AM		 809
810 /* Relocs in the 64-bit PowerPC ELF ABI, not in the 32-bit ABI. */
811
812 /* A standard 64-bit relocation. */
813 HOWTO (R_PPC64_ADDR64, /* type */
814 0, /* rightshift */
815 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
816 64, /* bitsize */
b34976b6 817 FALSE, /* pc_relative */
5bd4f169
AM		 818 0, /* bitpos */
819 complain_overflow_dont, /* complain_on_overflow */
820 bfd_elf_generic_reloc, /* special_function */
821 "R_PPC64_ADDR64", /* name */
b34976b6 822 FALSE, /* partial_inplace */
5bd4f169 823 0, /* src_mask */
f5e87a1d 824 ONES (64), /* dst_mask */
b34976b6 825 FALSE), /* pcrel_offset */
5bd4f169
AM		 826
827 /* The bits 32-47 of an address. */
828 HOWTO (R_PPC64_ADDR16_HIGHER, /* type */
829 32, /* rightshift */
830 1, /* size (0 = byte, 1 = short, 2 = long) */
831 16, /* 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_ADDR16_HIGHER", /* name */
b34976b6 837 FALSE, /* partial_inplace */
5bd4f169
AM		 838 0, /* src_mask */
839 0xffff, /* dst_mask */
b34976b6 840 FALSE), /* pcrel_offset */
5bd4f169
AM		 841
842 /* The bits 32-47 of an address, plus 1 if the contents of the low
843 16 bits, treated as a signed number, is negative. */
844 HOWTO (R_PPC64_ADDR16_HIGHERA, /* type */
845 32, /* rightshift */
846 1, /* size (0 = byte, 1 = short, 2 = long) */
847 16, /* bitsize */
b34976b6 848 FALSE, /* pc_relative */
5bd4f169
AM		 849 0, /* bitpos */
850 complain_overflow_dont, /* complain_on_overflow */
805fc799 851 ppc64_elf_ha_reloc, /* special_function */
5bd4f169 852 "R_PPC64_ADDR16_HIGHERA", /* name */
b34976b6 853 FALSE, /* partial_inplace */
5bd4f169
AM		 854 0, /* src_mask */
855 0xffff, /* dst_mask */
b34976b6 856 FALSE), /* pcrel_offset */
5bd4f169
AM		 857
858 /* The bits 48-63 of an address. */
859 HOWTO (R_PPC64_ADDR16_HIGHEST,/* type */
860 48, /* 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 */
866 bfd_elf_generic_reloc, /* special_function */
867 "R_PPC64_ADDR16_HIGHEST", /* 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, plus 1 if the contents of the low
874 16 bits, treated as a signed number, is negative. */
875 HOWTO (R_PPC64_ADDR16_HIGHESTA,/* type */
876 48, /* rightshift */
877 1, /* size (0 = byte, 1 = short, 2 = long) */
878 16, /* bitsize */
b34976b6 879 FALSE, /* pc_relative */
5bd4f169
AM		 880 0, /* bitpos */
881 complain_overflow_dont, /* complain_on_overflow */
805fc799 882 ppc64_elf_ha_reloc, /* special_function */
5bd4f169 883 "R_PPC64_ADDR16_HIGHESTA", /* name */
b34976b6 884 FALSE, /* partial_inplace */
5bd4f169
AM		 885 0, /* src_mask */
886 0xffff, /* dst_mask */
b34976b6 887 FALSE), /* pcrel_offset */
5bd4f169
AM		 888
889 /* Like ADDR64, but may be unaligned. */
890 HOWTO (R_PPC64_UADDR64, /* type */
891 0, /* rightshift */
892 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
893 64, /* bitsize */
b34976b6 894 FALSE, /* pc_relative */
5bd4f169
AM		 895 0, /* bitpos */
896 complain_overflow_dont, /* complain_on_overflow */
897 bfd_elf_generic_reloc, /* special_function */
898 "R_PPC64_UADDR64", /* name */
b34976b6 899 FALSE, /* partial_inplace */
5bd4f169 900 0, /* src_mask */
f5e87a1d 901 ONES (64), /* dst_mask */
b34976b6 902 FALSE), /* pcrel_offset */
5bd4f169
AM		 903
904 /* 64-bit relative relocation. */
905 HOWTO (R_PPC64_REL64, /* type */
906 0, /* rightshift */
907 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
908 64, /* bitsize */
b34976b6 909 TRUE, /* pc_relative */
5bd4f169
AM		 910 0, /* bitpos */
911 complain_overflow_dont, /* complain_on_overflow */
912 bfd_elf_generic_reloc, /* special_function */
913 "R_PPC64_REL64", /* name */
b34976b6 914 FALSE, /* partial_inplace */
5bd4f169 915 0, /* src_mask */
f5e87a1d 916 ONES (64), /* dst_mask */
b34976b6 917 TRUE), /* pcrel_offset */
5bd4f169 918
cedb70c5 919 /* 64-bit relocation to the symbol's procedure linkage table. */
5bd4f169
AM		 920 HOWTO (R_PPC64_PLT64, /* type */
921 0, /* rightshift */
922 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
923 64, /* bitsize */
b34976b6 924 FALSE, /* pc_relative */
5bd4f169
AM		 925 0, /* bitpos */
926 complain_overflow_dont, /* complain_on_overflow */
805fc799 927 ppc64_elf_unhandled_reloc, /* special_function */
5bd4f169 928 "R_PPC64_PLT64", /* name */
b34976b6 929 FALSE, /* partial_inplace */
5bd4f169 930 0, /* src_mask */
f5e87a1d 931 ONES (64), /* dst_mask */
b34976b6 932 FALSE), /* pcrel_offset */
5bd4f169
AM		 933
934 /* 64-bit PC relative relocation to the symbol's procedure linkage
935 table. */
936 /* FIXME: R_PPC64_PLTREL64 not supported. */
937 HOWTO (R_PPC64_PLTREL64, /* type */
938 0, /* rightshift */
939 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
940 64, /* bitsize */
b34976b6 941 TRUE, /* pc_relative */
5bd4f169
AM		 942 0, /* bitpos */
943 complain_overflow_dont, /* complain_on_overflow */
805fc799 944 ppc64_elf_unhandled_reloc, /* special_function */
5bd4f169 945 "R_PPC64_PLTREL64", /* name */
b34976b6 946 FALSE, /* partial_inplace */
5bd4f169 947 0, /* src_mask */
f5e87a1d 948 ONES (64), /* dst_mask */
b34976b6 949 TRUE), /* pcrel_offset */
5bd4f169
AM		 950
951 /* 16 bit TOC-relative relocation. */
952
953 /* R_PPC64_TOC16 47 half16* S + A - .TOC. */
954 HOWTO (R_PPC64_TOC16, /* type */
955 0, /* rightshift */
956 1, /* size (0 = byte, 1 = short, 2 = long) */
957 16, /* bitsize */
b34976b6 958 FALSE, /* pc_relative */
5bd4f169
AM		 959 0, /* bitpos */
960 complain_overflow_signed, /* complain_on_overflow */
805fc799 961 ppc64_elf_toc_reloc, /* special_function */
5bd4f169 962 "R_PPC64_TOC16", /* name */
b34976b6 963 FALSE, /* partial_inplace */
5bd4f169
AM		 964 0, /* src_mask */
965 0xffff, /* dst_mask */
b34976b6 966 FALSE), /* pcrel_offset */
5bd4f169
AM		 967
968 /* 16 bit TOC-relative relocation without overflow. */
969
970 /* R_PPC64_TOC16_LO 48 half16 #lo (S + A - .TOC.) */
971 HOWTO (R_PPC64_TOC16_LO, /* type */
972 0, /* rightshift */
973 1, /* size (0 = byte, 1 = short, 2 = long) */
974 16, /* bitsize */
b34976b6 975 FALSE, /* pc_relative */
5bd4f169
AM		 976 0, /* bitpos */
977 complain_overflow_dont, /* complain_on_overflow */
805fc799 978 ppc64_elf_toc_reloc, /* special_function */
5bd4f169 979 "R_PPC64_TOC16_LO", /* name */
b34976b6 980 FALSE, /* partial_inplace */
5bd4f169
AM		 981 0, /* src_mask */
982 0xffff, /* dst_mask */
b34976b6 983 FALSE), /* pcrel_offset */
5bd4f169
AM		 984
985 /* 16 bit TOC-relative relocation, high 16 bits. */
986
987 /* R_PPC64_TOC16_HI 49 half16 #hi (S + A - .TOC.) */
988 HOWTO (R_PPC64_TOC16_HI, /* type */
989 16, /* rightshift */
990 1, /* size (0 = byte, 1 = short, 2 = long) */
991 16, /* bitsize */
b34976b6 992 FALSE, /* pc_relative */
5bd4f169 993 0, /* bitpos */
f9c6b907 994 complain_overflow_signed, /* complain_on_overflow */
805fc799 995 ppc64_elf_toc_reloc, /* special_function */
5bd4f169 996 "R_PPC64_TOC16_HI", /* name */
b34976b6 997 FALSE, /* partial_inplace */
5bd4f169
AM		 998 0, /* src_mask */
999 0xffff, /* dst_mask */
b34976b6 1000 FALSE), /* pcrel_offset */
5bd4f169
AM		 1001
1002 /* 16 bit TOC-relative relocation, high 16 bits, plus 1 if the
1003 contents of the low 16 bits, treated as a signed number, is
1004 negative. */
1005
1006 /* R_PPC64_TOC16_HA 50 half16 #ha (S + A - .TOC.) */
1007 HOWTO (R_PPC64_TOC16_HA, /* type */
1008 16, /* rightshift */
1009 1, /* size (0 = byte, 1 = short, 2 = long) */
1010 16, /* bitsize */
b34976b6 1011 FALSE, /* pc_relative */
5bd4f169 1012 0, /* bitpos */
f9c6b907 1013 complain_overflow_signed, /* complain_on_overflow */
805fc799 1014 ppc64_elf_toc_ha_reloc, /* special_function */
5bd4f169 1015 "R_PPC64_TOC16_HA", /* name */
b34976b6 1016 FALSE, /* partial_inplace */
5bd4f169
AM		 1017 0, /* src_mask */
1018 0xffff, /* dst_mask */
b34976b6 1019 FALSE), /* pcrel_offset */
5bd4f169
AM		 1020
1021 /* 64-bit relocation; insert value of TOC base (.TOC.). */
1022
1023 /* R_PPC64_TOC 51 doubleword64 .TOC. */
1024 HOWTO (R_PPC64_TOC, /* type */
1025 0, /* rightshift */
1026 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1027 64, /* bitsize */
b34976b6 1028 FALSE, /* pc_relative */
5bd4f169 1029 0, /* bitpos */
b80eed39 1030 complain_overflow_dont, /* complain_on_overflow */
805fc799 1031 ppc64_elf_toc64_reloc, /* special_function */
5bd4f169 1032 "R_PPC64_TOC", /* name */
b34976b6 1033 FALSE, /* partial_inplace */
5bd4f169 1034 0, /* src_mask */
f5e87a1d 1035 ONES (64), /* dst_mask */
b34976b6 1036 FALSE), /* pcrel_offset */
5bd4f169
AM		 1037
1038 /* Like R_PPC64_GOT16, but also informs the link editor that the
1039 value to relocate may (!) refer to a PLT entry which the link
1040 editor (a) may replace with the symbol value. If the link editor
1041 is unable to fully resolve the symbol, it may (b) create a PLT
1042 entry and store the address to the new PLT entry in the GOT.
1043 This permits lazy resolution of function symbols at run time.
1044 The link editor may also skip all of this and just (c) emit a
1045 R_PPC64_GLOB_DAT to tie the symbol to the GOT entry. */
1046 /* FIXME: R_PPC64_PLTGOT16 not implemented. */
1047 HOWTO (R_PPC64_PLTGOT16, /* type */
1048 0, /* rightshift */
1049 1, /* size (0 = byte, 1 = short, 2 = long) */
1050 16, /* bitsize */
b34976b6 1051 FALSE, /* pc_relative */
5bd4f169
AM		 1052 0, /* bitpos */
1053 complain_overflow_signed, /* complain_on_overflow */
805fc799 1054 ppc64_elf_unhandled_reloc, /* special_function */
411e1bfb
AM		 1055 "R_PPC64_PLTGOT16", /* name */
1056 FALSE, /* partial_inplace */
1057 0, /* src_mask */
1058 0xffff, /* dst_mask */
1059 FALSE), /* pcrel_offset */
1060
1061 /* Like R_PPC64_PLTGOT16, but without overflow. */
1062 /* FIXME: R_PPC64_PLTGOT16_LO not implemented. */
1063 HOWTO (R_PPC64_PLTGOT16_LO, /* type */
1064 0, /* rightshift */
1065 1, /* size (0 = byte, 1 = short, 2 = long) */
1066 16, /* bitsize */
1067 FALSE, /* pc_relative */
1068 0, /* bitpos */
1069 complain_overflow_dont, /* complain_on_overflow */
1070 ppc64_elf_unhandled_reloc, /* special_function */
1071 "R_PPC64_PLTGOT16_LO", /* name */
1072 FALSE, /* partial_inplace */
1073 0, /* src_mask */
1074 0xffff, /* dst_mask */
1075 FALSE), /* pcrel_offset */
1076
1077 /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address. */
1078 /* FIXME: R_PPC64_PLTGOT16_HI not implemented. */
1079 HOWTO (R_PPC64_PLTGOT16_HI, /* type */
1080 16, /* rightshift */
1081 1, /* size (0 = byte, 1 = short, 2 = long) */
1082 16, /* bitsize */
1083 FALSE, /* pc_relative */
1084 0, /* bitpos */
f9c6b907 1085 complain_overflow_signed, /* complain_on_overflow */
411e1bfb
AM		 1086 ppc64_elf_unhandled_reloc, /* special_function */
1087 "R_PPC64_PLTGOT16_HI", /* name */
1088 FALSE, /* partial_inplace */
1089 0, /* src_mask */
1090 0xffff, /* dst_mask */
1091 FALSE), /* pcrel_offset */
1092
1093 /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address, plus
1094 1 if the contents of the low 16 bits, treated as a signed number,
1095 is negative. */
1096 /* FIXME: R_PPC64_PLTGOT16_HA not implemented. */
1097 HOWTO (R_PPC64_PLTGOT16_HA, /* type */
1098 16, /* rightshift */
1099 1, /* size (0 = byte, 1 = short, 2 = long) */
1100 16, /* bitsize */
1101 FALSE, /* pc_relative */
1102 0, /* bitpos */
f9c6b907 1103 complain_overflow_signed, /* complain_on_overflow */
411e1bfb
AM		 1104 ppc64_elf_unhandled_reloc, /* special_function */
1105 "R_PPC64_PLTGOT16_HA", /* name */
1106 FALSE, /* partial_inplace */
1107 0, /* src_mask */
1108 0xffff, /* dst_mask */
1109 FALSE), /* pcrel_offset */
1110
1111 /* Like R_PPC64_ADDR16, but for instructions with a DS field. */
1112 HOWTO (R_PPC64_ADDR16_DS, /* type */
1113 0, /* rightshift */
1114 1, /* size (0 = byte, 1 = short, 2 = long) */
1115 16, /* bitsize */
1116 FALSE, /* pc_relative */
1117 0, /* bitpos */
b80eed39 1118 complain_overflow_signed, /* complain_on_overflow */
411e1bfb
AM		 1119 bfd_elf_generic_reloc, /* special_function */
1120 "R_PPC64_ADDR16_DS", /* name */
1121 FALSE, /* partial_inplace */
1122 0, /* src_mask */
1123 0xfffc, /* dst_mask */
1124 FALSE), /* pcrel_offset */
1125
1126 /* Like R_PPC64_ADDR16_LO, but for instructions with a DS field. */
1127 HOWTO (R_PPC64_ADDR16_LO_DS, /* type */
1128 0, /* rightshift */
1129 1, /* size (0 = byte, 1 = short, 2 = long) */
1130 16, /* bitsize */
1131 FALSE, /* pc_relative */
1132 0, /* bitpos */
1133 complain_overflow_dont,/* complain_on_overflow */
1134 bfd_elf_generic_reloc, /* special_function */
1135 "R_PPC64_ADDR16_LO_DS",/* name */
1136 FALSE, /* partial_inplace */
1137 0, /* src_mask */
1138 0xfffc, /* dst_mask */
1139 FALSE), /* pcrel_offset */
1140
1141 /* Like R_PPC64_GOT16, but for instructions with a DS field. */
1142 HOWTO (R_PPC64_GOT16_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_signed, /* complain_on_overflow */
1149 ppc64_elf_unhandled_reloc, /* special_function */
1150 "R_PPC64_GOT16_DS", /* name */
1151 FALSE, /* partial_inplace */
1152 0, /* src_mask */
1153 0xfffc, /* dst_mask */
1154 FALSE), /* pcrel_offset */
1155
1156 /* Like R_PPC64_GOT16_LO, but for instructions with a DS field. */
1157 HOWTO (R_PPC64_GOT16_LO_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_dont, /* complain_on_overflow */
1164 ppc64_elf_unhandled_reloc, /* special_function */
1165 "R_PPC64_GOT16_LO_DS", /* name */
1166 FALSE, /* partial_inplace */
1167 0, /* src_mask */
1168 0xfffc, /* dst_mask */
1169 FALSE), /* pcrel_offset */
1170
1171 /* Like R_PPC64_PLT16_LO, but for instructions with a DS field. */
1172 HOWTO (R_PPC64_PLT16_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_PLT16_LO_DS", /* name */
1181 FALSE, /* partial_inplace */
1182 0, /* src_mask */
1183 0xfffc, /* dst_mask */
1184 FALSE), /* pcrel_offset */
1185
1186 /* Like R_PPC64_SECTOFF, but for instructions with a DS field. */
1187 HOWTO (R_PPC64_SECTOFF_DS, /* type */
1188 0, /* rightshift */
1189 1, /* size (0 = byte, 1 = short, 2 = long) */
1190 16, /* bitsize */
1191 FALSE, /* pc_relative */
1192 0, /* bitpos */
b80eed39 1193 complain_overflow_signed, /* complain_on_overflow */
411e1bfb
AM		 1194 ppc64_elf_sectoff_reloc, /* special_function */
1195 "R_PPC64_SECTOFF_DS", /* name */
1196 FALSE, /* partial_inplace */
1197 0, /* src_mask */
1198 0xfffc, /* dst_mask */
1199 FALSE), /* pcrel_offset */
1200
1201 /* Like R_PPC64_SECTOFF_LO, but for instructions with a DS field. */
1202 HOWTO (R_PPC64_SECTOFF_LO_DS, /* type */
1203 0, /* rightshift */
1204 1, /* size (0 = byte, 1 = short, 2 = long) */
1205 16, /* bitsize */
1206 FALSE, /* pc_relative */
1207 0, /* bitpos */
1208 complain_overflow_dont, /* complain_on_overflow */
1209 ppc64_elf_sectoff_reloc, /* special_function */
1210 "R_PPC64_SECTOFF_LO_DS",/* name */
1211 FALSE, /* partial_inplace */
1212 0, /* src_mask */
1213 0xfffc, /* dst_mask */
1214 FALSE), /* pcrel_offset */
1215
1216 /* Like R_PPC64_TOC16, but for instructions with a DS field. */
1217 HOWTO (R_PPC64_TOC16_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_signed, /* complain_on_overflow */
1224 ppc64_elf_toc_reloc, /* special_function */
1225 "R_PPC64_TOC16_DS", /* name */
1226 FALSE, /* partial_inplace */
1227 0, /* src_mask */
1228 0xfffc, /* dst_mask */
1229 FALSE), /* pcrel_offset */
1230
1231 /* Like R_PPC64_TOC16_LO, but for instructions with a DS field. */
1232 HOWTO (R_PPC64_TOC16_LO_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_dont, /* complain_on_overflow */
1239 ppc64_elf_toc_reloc, /* special_function */
1240 "R_PPC64_TOC16_LO_DS", /* name */
1241 FALSE, /* partial_inplace */
1242 0, /* src_mask */
1243 0xfffc, /* dst_mask */
1244 FALSE), /* pcrel_offset */
1245
1246 /* Like R_PPC64_PLTGOT16, but for instructions with a DS field. */
1247 /* FIXME: R_PPC64_PLTGOT16_DS not implemented. */
6bfdb61b 1248 HOWTO (R_PPC64_PLTGOT16_DS, /* type */
411e1bfb
AM		 1249 0, /* rightshift */
1250 1, /* size (0 = byte, 1 = short, 2 = long) */
1251 16, /* bitsize */
1252 FALSE, /* pc_relative */
1253 0, /* bitpos */
1254 complain_overflow_signed, /* complain_on_overflow */
1255 ppc64_elf_unhandled_reloc, /* special_function */
1256 "R_PPC64_PLTGOT16_DS", /* name */
1257 FALSE, /* partial_inplace */
1258 0, /* src_mask */
1259 0xfffc, /* dst_mask */
1260 FALSE), /* pcrel_offset */
1261
1262 /* Like R_PPC64_PLTGOT16_LO, but for instructions with a DS field. */
1263 /* FIXME: R_PPC64_PLTGOT16_LO not implemented. */
1264 HOWTO (R_PPC64_PLTGOT16_LO_DS,/* type */
1265 0, /* rightshift */
1266 1, /* size (0 = byte, 1 = short, 2 = long) */
1267 16, /* bitsize */
1268 FALSE, /* pc_relative */
1269 0, /* bitpos */
1270 complain_overflow_dont, /* complain_on_overflow */
1271 ppc64_elf_unhandled_reloc, /* special_function */
1272 "R_PPC64_PLTGOT16_LO_DS",/* name */
1273 FALSE, /* partial_inplace */
1274 0, /* src_mask */
1275 0xfffc, /* dst_mask */
1276 FALSE), /* pcrel_offset */
1277
727fc41e 1278 /* Marker relocs for TLS. */
411e1bfb
AM		 1279 HOWTO (R_PPC64_TLS,
1280 0, /* rightshift */
1281 2, /* size (0 = byte, 1 = short, 2 = long) */
1282 32, /* bitsize */
1283 FALSE, /* pc_relative */
1284 0, /* bitpos */
1285 complain_overflow_dont, /* complain_on_overflow */
1286 bfd_elf_generic_reloc, /* special_function */
1287 "R_PPC64_TLS", /* name */
1288 FALSE, /* partial_inplace */
1289 0, /* src_mask */
1290 0, /* dst_mask */
1291 FALSE), /* pcrel_offset */
1292
727fc41e
AM		 1293 HOWTO (R_PPC64_TLSGD,
1294 0, /* rightshift */
1295 2, /* size (0 = byte, 1 = short, 2 = long) */
1296 32, /* bitsize */
1297 FALSE, /* pc_relative */
1298 0, /* bitpos */
1299 complain_overflow_dont, /* complain_on_overflow */
1300 bfd_elf_generic_reloc, /* special_function */
1301 "R_PPC64_TLSGD", /* name */
1302 FALSE, /* partial_inplace */
1303 0, /* src_mask */
1304 0, /* dst_mask */
1305 FALSE), /* pcrel_offset */
1306
1307 HOWTO (R_PPC64_TLSLD,
1308 0, /* rightshift */
1309 2, /* size (0 = byte, 1 = short, 2 = long) */
1310 32, /* bitsize */
1311 FALSE, /* pc_relative */
1312 0, /* bitpos */
1313 complain_overflow_dont, /* complain_on_overflow */
1314 bfd_elf_generic_reloc, /* special_function */
1315 "R_PPC64_TLSLD", /* name */
1316 FALSE, /* partial_inplace */
1317 0, /* src_mask */
1318 0, /* dst_mask */
1319 FALSE), /* pcrel_offset */
1320
3b421ab3
AM		 1321 HOWTO (R_PPC64_TOCSAVE,
1322 0, /* rightshift */
1323 2, /* size (0 = byte, 1 = short, 2 = long) */
1324 32, /* bitsize */
1325 FALSE, /* pc_relative */
1326 0, /* bitpos */
1327 complain_overflow_dont, /* complain_on_overflow */
1328 bfd_elf_generic_reloc, /* special_function */
1329 "R_PPC64_TOCSAVE", /* name */
1330 FALSE, /* partial_inplace */
1331 0, /* src_mask */
1332 0, /* dst_mask */
1333 FALSE), /* pcrel_offset */
1334
411e1bfb
AM		 1335 /* Computes the load module index of the load module that contains the
1336 definition of its TLS sym. */
1337 HOWTO (R_PPC64_DTPMOD64,
1338 0, /* rightshift */
1339 4, /* size (0 = byte, 1 = short, 2 = long) */
1340 64, /* bitsize */
1341 FALSE, /* pc_relative */
1342 0, /* bitpos */
1343 complain_overflow_dont, /* complain_on_overflow */
1344 ppc64_elf_unhandled_reloc, /* special_function */
1345 "R_PPC64_DTPMOD64", /* name */
1346 FALSE, /* partial_inplace */
1347 0, /* src_mask */
1348 ONES (64), /* dst_mask */
1349 FALSE), /* pcrel_offset */
1350
1351 /* Computes a dtv-relative displacement, the difference between the value
1352 of sym+add and the base address of the thread-local storage block that
1353 contains the definition of sym, minus 0x8000. */
1354 HOWTO (R_PPC64_DTPREL64,
1355 0, /* rightshift */
1356 4, /* size (0 = byte, 1 = short, 2 = long) */
1357 64, /* bitsize */
1358 FALSE, /* pc_relative */
1359 0, /* bitpos */
1360 complain_overflow_dont, /* complain_on_overflow */
1361 ppc64_elf_unhandled_reloc, /* special_function */
1362 "R_PPC64_DTPREL64", /* name */
1363 FALSE, /* partial_inplace */
1364 0, /* src_mask */
1365 ONES (64), /* dst_mask */
1366 FALSE), /* pcrel_offset */
1367
1368 /* A 16 bit dtprel reloc. */
1369 HOWTO (R_PPC64_DTPREL16,
1370 0, /* rightshift */
1371 1, /* size (0 = byte, 1 = short, 2 = long) */
1372 16, /* bitsize */
1373 FALSE, /* pc_relative */
1374 0, /* bitpos */
1375 complain_overflow_signed, /* complain_on_overflow */
1376 ppc64_elf_unhandled_reloc, /* special_function */
1377 "R_PPC64_DTPREL16", /* name */
1378 FALSE, /* partial_inplace */
1379 0, /* src_mask */
1380 0xffff, /* dst_mask */
1381 FALSE), /* pcrel_offset */
1382
1383 /* Like DTPREL16, but no overflow. */
1384 HOWTO (R_PPC64_DTPREL16_LO,
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_dont, /* complain_on_overflow */
1391 ppc64_elf_unhandled_reloc, /* special_function */
1392 "R_PPC64_DTPREL16_LO", /* name */
1393 FALSE, /* partial_inplace */
1394 0, /* src_mask */
1395 0xffff, /* dst_mask */
1396 FALSE), /* pcrel_offset */
1397
1398 /* Like DTPREL16_LO, but next higher group of 16 bits. */
1399 HOWTO (R_PPC64_DTPREL16_HI,
1400 16, /* rightshift */
1401 1, /* size (0 = byte, 1 = short, 2 = long) */
1402 16, /* bitsize */
1403 FALSE, /* pc_relative */
1404 0, /* bitpos */
f9c6b907 1405 complain_overflow_signed, /* complain_on_overflow */
411e1bfb
AM		 1406 ppc64_elf_unhandled_reloc, /* special_function */
1407 "R_PPC64_DTPREL16_HI", /* name */
1408 FALSE, /* partial_inplace */
1409 0, /* src_mask */
1410 0xffff, /* dst_mask */
1411 FALSE), /* pcrel_offset */
1412
1413 /* Like DTPREL16_HI, but adjust for low 16 bits. */
1414 HOWTO (R_PPC64_DTPREL16_HA,
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_HA", /* name */
1423 FALSE, /* partial_inplace */
1424 0, /* src_mask */
1425 0xffff, /* dst_mask */
1426 FALSE), /* pcrel_offset */
1427
1428 /* Like DTPREL16_HI, but next higher group of 16 bits. */
1429 HOWTO (R_PPC64_DTPREL16_HIGHER,
1430 32, /* rightshift */
1431 1, /* size (0 = byte, 1 = short, 2 = long) */
1432 16, /* bitsize */
1433 FALSE, /* pc_relative */
1434 0, /* bitpos */
1435 complain_overflow_dont, /* complain_on_overflow */
1436 ppc64_elf_unhandled_reloc, /* special_function */
1437 "R_PPC64_DTPREL16_HIGHER", /* name */
1438 FALSE, /* partial_inplace */
1439 0, /* src_mask */
1440 0xffff, /* dst_mask */
1441 FALSE), /* pcrel_offset */
1442
1443 /* Like DTPREL16_HIGHER, but adjust for low 16 bits. */
1444 HOWTO (R_PPC64_DTPREL16_HIGHERA,
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_HIGHERA", /* name */
1453 FALSE, /* partial_inplace */
1454 0, /* src_mask */
1455 0xffff, /* dst_mask */
1456 FALSE), /* pcrel_offset */
1457
1458 /* Like DTPREL16_HIGHER, but next higher group of 16 bits. */
1459 HOWTO (R_PPC64_DTPREL16_HIGHEST,
1460 48, /* 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_HIGHEST", /* name */
1468 FALSE, /* partial_inplace */
1469 0, /* src_mask */
1470 0xffff, /* dst_mask */
1471 FALSE), /* pcrel_offset */
1472
1473 /* Like DTPREL16_HIGHEST, but adjust for low 16 bits. */
1474 HOWTO (R_PPC64_DTPREL16_HIGHESTA,
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_HIGHESTA", /* name */
1483 FALSE, /* partial_inplace */
1484 0, /* src_mask */
1485 0xffff, /* dst_mask */
1486 FALSE), /* pcrel_offset */
1487
1488 /* Like DTPREL16, but for insns with a DS field. */
1489 HOWTO (R_PPC64_DTPREL16_DS,
1490 0, /* rightshift */
1491 1, /* size (0 = byte, 1 = short, 2 = long) */
1492 16, /* bitsize */
1493 FALSE, /* pc_relative */
1494 0, /* bitpos */
1495 complain_overflow_signed, /* complain_on_overflow */
1496 ppc64_elf_unhandled_reloc, /* special_function */
1497 "R_PPC64_DTPREL16_DS", /* name */
1498 FALSE, /* partial_inplace */
1499 0, /* src_mask */
1500 0xfffc, /* dst_mask */
1501 FALSE), /* pcrel_offset */
1502
1503 /* Like DTPREL16_DS, but no overflow. */
1504 HOWTO (R_PPC64_DTPREL16_LO_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_dont, /* complain_on_overflow */
1511 ppc64_elf_unhandled_reloc, /* special_function */
1512 "R_PPC64_DTPREL16_LO_DS", /* name */
1513 FALSE, /* partial_inplace */
1514 0, /* src_mask */
1515 0xfffc, /* dst_mask */
1516 FALSE), /* pcrel_offset */
1517
1518 /* Computes a tp-relative displacement, the difference between the value of
1519 sym+add and the value of the thread pointer (r13). */
1520 HOWTO (R_PPC64_TPREL64,
1521 0, /* rightshift */
1522 4, /* size (0 = byte, 1 = short, 2 = long) */
1523 64, /* bitsize */
1524 FALSE, /* pc_relative */
1525 0, /* bitpos */
1526 complain_overflow_dont, /* complain_on_overflow */
1527 ppc64_elf_unhandled_reloc, /* special_function */
1528 "R_PPC64_TPREL64", /* name */
1529 FALSE, /* partial_inplace */
1530 0, /* src_mask */
1531 ONES (64), /* dst_mask */
1532 FALSE), /* pcrel_offset */
1533
1534 /* A 16 bit tprel reloc. */
1535 HOWTO (R_PPC64_TPREL16,
1536 0, /* rightshift */
1537 1, /* size (0 = byte, 1 = short, 2 = long) */
1538 16, /* bitsize */
1539 FALSE, /* pc_relative */
1540 0, /* bitpos */
1541 complain_overflow_signed, /* complain_on_overflow */
1542 ppc64_elf_unhandled_reloc, /* special_function */
1543 "R_PPC64_TPREL16", /* name */
1544 FALSE, /* partial_inplace */
1545 0, /* src_mask */
1546 0xffff, /* dst_mask */
1547 FALSE), /* pcrel_offset */
1548
1549 /* Like TPREL16, but no overflow. */
1550 HOWTO (R_PPC64_TPREL16_LO,
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_dont, /* complain_on_overflow */
1557 ppc64_elf_unhandled_reloc, /* special_function */
1558 "R_PPC64_TPREL16_LO", /* name */
1559 FALSE, /* partial_inplace */
1560 0, /* src_mask */
1561 0xffff, /* dst_mask */
1562 FALSE), /* pcrel_offset */
1563
1564 /* Like TPREL16_LO, but next higher group of 16 bits. */
1565 HOWTO (R_PPC64_TPREL16_HI,
1566 16, /* rightshift */
1567 1, /* size (0 = byte, 1 = short, 2 = long) */
1568 16, /* bitsize */
1569 FALSE, /* pc_relative */
1570 0, /* bitpos */
f9c6b907 1571 complain_overflow_signed, /* complain_on_overflow */
411e1bfb
AM		 1572 ppc64_elf_unhandled_reloc, /* special_function */
1573 "R_PPC64_TPREL16_HI", /* name */
1574 FALSE, /* partial_inplace */
1575 0, /* src_mask */
1576 0xffff, /* dst_mask */
1577 FALSE), /* pcrel_offset */
1578
1579 /* Like TPREL16_HI, but adjust for low 16 bits. */
1580 HOWTO (R_PPC64_TPREL16_HA,
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_HA", /* name */
1589 FALSE, /* partial_inplace */
1590 0, /* src_mask */
1591 0xffff, /* dst_mask */
1592 FALSE), /* pcrel_offset */
1593
1594 /* Like TPREL16_HI, but next higher group of 16 bits. */
1595 HOWTO (R_PPC64_TPREL16_HIGHER,
1596 32, /* rightshift */
1597 1, /* size (0 = byte, 1 = short, 2 = long) */
1598 16, /* bitsize */
1599 FALSE, /* pc_relative */
1600 0, /* bitpos */
1601 complain_overflow_dont, /* complain_on_overflow */
1602 ppc64_elf_unhandled_reloc, /* special_function */
1603 "R_PPC64_TPREL16_HIGHER", /* name */
1604 FALSE, /* partial_inplace */
1605 0, /* src_mask */
1606 0xffff, /* dst_mask */
1607 FALSE), /* pcrel_offset */
1608
1609 /* Like TPREL16_HIGHER, but adjust for low 16 bits. */
1610 HOWTO (R_PPC64_TPREL16_HIGHERA,
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_HIGHERA", /* name */
1619 FALSE, /* partial_inplace */
1620 0, /* src_mask */
1621 0xffff, /* dst_mask */
1622 FALSE), /* pcrel_offset */
1623
1624 /* Like TPREL16_HIGHER, but next higher group of 16 bits. */
1625 HOWTO (R_PPC64_TPREL16_HIGHEST,
1626 48, /* 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_HIGHEST", /* name */
1634 FALSE, /* partial_inplace */
1635 0, /* src_mask */
1636 0xffff, /* dst_mask */
1637 FALSE), /* pcrel_offset */
1638
1639 /* Like TPREL16_HIGHEST, but adjust for low 16 bits. */
1640 HOWTO (R_PPC64_TPREL16_HIGHESTA,
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_HIGHESTA", /* name */
1649 FALSE, /* partial_inplace */
1650 0, /* src_mask */
1651 0xffff, /* dst_mask */
1652 FALSE), /* pcrel_offset */
1653
1654 /* Like TPREL16, but for insns with a DS field. */
1655 HOWTO (R_PPC64_TPREL16_DS,
1656 0, /* rightshift */
1657 1, /* size (0 = byte, 1 = short, 2 = long) */
1658 16, /* bitsize */
1659 FALSE, /* pc_relative */
1660 0, /* bitpos */
1661 complain_overflow_signed, /* complain_on_overflow */
1662 ppc64_elf_unhandled_reloc, /* special_function */
1663 "R_PPC64_TPREL16_DS", /* name */
1664 FALSE, /* partial_inplace */
1665 0, /* src_mask */
1666 0xfffc, /* dst_mask */
1667 FALSE), /* pcrel_offset */
1668
1669 /* Like TPREL16_DS, but no overflow. */
1670 HOWTO (R_PPC64_TPREL16_LO_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_dont, /* complain_on_overflow */
1677 ppc64_elf_unhandled_reloc, /* special_function */
1678 "R_PPC64_TPREL16_LO_DS", /* name */
1679 FALSE, /* partial_inplace */
1680 0, /* src_mask */
1681 0xfffc, /* dst_mask */
1682 FALSE), /* pcrel_offset */
1683
1684 /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1685 with values (sym+add)@dtpmod and (sym+add)@dtprel, and computes the offset
1686 to the first entry relative to the TOC base (r2). */
1687 HOWTO (R_PPC64_GOT_TLSGD16,
1688 0, /* rightshift */
1689 1, /* size (0 = byte, 1 = short, 2 = long) */
1690 16, /* bitsize */
1691 FALSE, /* pc_relative */
1692 0, /* bitpos */
1693 complain_overflow_signed, /* complain_on_overflow */
1694 ppc64_elf_unhandled_reloc, /* special_function */
1695 "R_PPC64_GOT_TLSGD16", /* name */
b34976b6 1696 FALSE, /* partial_inplace */
5bd4f169
AM		 1697 0, /* src_mask */
1698 0xffff, /* dst_mask */
b34976b6 1699 FALSE), /* pcrel_offset */
5bd4f169 1700
411e1bfb
AM		 1701 /* Like GOT_TLSGD16, but no overflow. */
1702 HOWTO (R_PPC64_GOT_TLSGD16_LO,
5bd4f169
AM		 1703 0, /* rightshift */
1704 1, /* size (0 = byte, 1 = short, 2 = long) */
1705 16, /* bitsize */
b34976b6 1706 FALSE, /* pc_relative */
5bd4f169
AM		 1707 0, /* bitpos */
1708 complain_overflow_dont, /* complain_on_overflow */
805fc799 1709 ppc64_elf_unhandled_reloc, /* special_function */
411e1bfb 1710 "R_PPC64_GOT_TLSGD16_LO", /* 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_LO, but next higher group of 16 bits. */
1717 HOWTO (R_PPC64_GOT_TLSGD16_HI,
5bd4f169
AM		 1718 16, /* rightshift */
1719 1, /* size (0 = byte, 1 = short, 2 = long) */
1720 16, /* bitsize */
b34976b6 1721 FALSE, /* pc_relative */
5bd4f169 1722 0, /* bitpos */
f9c6b907 1723 complain_overflow_signed, /* complain_on_overflow */
805fc799 1724 ppc64_elf_unhandled_reloc, /* special_function */
411e1bfb 1725 "R_PPC64_GOT_TLSGD16_HI", /* 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_HI, but adjust for low 16 bits. */
1732 HOWTO (R_PPC64_GOT_TLSGD16_HA,
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_HA", /* 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 /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1747 with values (sym+add)@dtpmod and zero, and computes the offset to the
1748 first entry relative to the TOC base (r2). */
1749 HOWTO (R_PPC64_GOT_TLSLD16,
5bd4f169
AM		 1750 0, /* rightshift */
1751 1, /* size (0 = byte, 1 = short, 2 = long) */
1752 16, /* bitsize */
b34976b6 1753 FALSE, /* pc_relative */
5bd4f169 1754 0, /* bitpos */
411e1bfb
AM		 1755 complain_overflow_signed, /* complain_on_overflow */
1756 ppc64_elf_unhandled_reloc, /* special_function */
1757 "R_PPC64_GOT_TLSLD16", /* name */
b34976b6 1758 FALSE, /* partial_inplace */
d006db6c 1759 0, /* src_mask */
411e1bfb 1760 0xffff, /* dst_mask */
b34976b6 1761 FALSE), /* pcrel_offset */
5bd4f169 1762
411e1bfb
AM		 1763 /* Like GOT_TLSLD16, but no overflow. */
1764 HOWTO (R_PPC64_GOT_TLSLD16_LO,
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_dont, /* complain_on_overflow */
1771 ppc64_elf_unhandled_reloc, /* special_function */
1772 "R_PPC64_GOT_TLSLD16_LO", /* 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_LO, but next higher group of 16 bits. */
1779 HOWTO (R_PPC64_GOT_TLSLD16_HI,
1780 16, /* rightshift */
5bd4f169
AM		 1781 1, /* size (0 = byte, 1 = short, 2 = long) */
1782 16, /* bitsize */
b34976b6 1783 FALSE, /* pc_relative */
5bd4f169 1784 0, /* bitpos */
f9c6b907 1785 complain_overflow_signed, /* complain_on_overflow */
805fc799 1786 ppc64_elf_unhandled_reloc, /* special_function */
411e1bfb 1787 "R_PPC64_GOT_TLSLD16_HI", /* 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_HI, but adjust for low 16 bits. */
1794 HOWTO (R_PPC64_GOT_TLSLD16_HA,
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_HA", /* 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 /* Allocates an entry in the GOT with value (sym+add)@dtprel, and computes
1809 the offset to the entry relative to the TOC base (r2). */
1810 HOWTO (R_PPC64_GOT_DTPREL16_DS,
5bd4f169
AM		 1811 0, /* rightshift */
1812 1, /* size (0 = byte, 1 = short, 2 = long) */
1813 16, /* bitsize */
b34976b6 1814 FALSE, /* pc_relative */
5bd4f169 1815 0, /* bitpos */
411e1bfb 1816 complain_overflow_signed, /* complain_on_overflow */
805fc799 1817 ppc64_elf_unhandled_reloc, /* special_function */
411e1bfb 1818 "R_PPC64_GOT_DTPREL16_DS", /* name */
b34976b6 1819 FALSE, /* partial_inplace */
d006db6c 1820 0, /* src_mask */
5bd4f169 1821 0xfffc, /* dst_mask */
b34976b6 1822 FALSE), /* pcrel_offset */
5bd4f169 1823
411e1bfb
AM		 1824 /* Like GOT_DTPREL16_DS, but no overflow. */
1825 HOWTO (R_PPC64_GOT_DTPREL16_LO_DS,
5bd4f169 1826 0, /* rightshift */
c061c2d8
AM		 1827 1, /* size (0 = byte, 1 = short, 2 = long) */
1828 16, /* bitsize */
b34976b6 1829 FALSE, /* pc_relative */
5bd4f169 1830 0, /* bitpos */
411e1bfb
AM		 1831 complain_overflow_dont, /* complain_on_overflow */
1832 ppc64_elf_unhandled_reloc, /* special_function */
1833 "R_PPC64_GOT_DTPREL16_LO_DS", /* name */
b34976b6 1834 FALSE, /* partial_inplace */
d006db6c 1835 0, /* src_mask */
c061c2d8 1836 0xfffc, /* dst_mask */
b34976b6 1837 FALSE), /* pcrel_offset */
5bd4f169 1838
411e1bfb
AM		 1839 /* Like GOT_DTPREL16_LO_DS, but next higher group of 16 bits. */
1840 HOWTO (R_PPC64_GOT_DTPREL16_HI,
1841 16, /* rightshift */
5bd4f169
AM		 1842 1, /* size (0 = byte, 1 = short, 2 = long) */
1843 16, /* bitsize */
b34976b6 1844 FALSE, /* pc_relative */
5bd4f169 1845 0, /* bitpos */
f9c6b907 1846 complain_overflow_signed, /* complain_on_overflow */
411e1bfb
AM		 1847 ppc64_elf_unhandled_reloc, /* special_function */
1848 "R_PPC64_GOT_DTPREL16_HI", /* name */
b34976b6 1849 FALSE, /* partial_inplace */
d006db6c 1850 0, /* src_mask */
411e1bfb 1851 0xffff, /* dst_mask */
b34976b6 1852 FALSE), /* pcrel_offset */
5bd4f169 1853
411e1bfb
AM		 1854 /* Like GOT_DTPREL16_HI, but adjust for low 16 bits. */
1855 HOWTO (R_PPC64_GOT_DTPREL16_HA,
1856 16, /* rightshift */
1857 1, /* size (0 = byte, 1 = short, 2 = long) */
1858 16, /* bitsize */
1859 FALSE, /* pc_relative */
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_HA", /* name */
1864 FALSE, /* partial_inplace */
1865 0, /* src_mask */
1866 0xffff, /* dst_mask */
1867 FALSE), /* pcrel_offset */
1868
1869 /* Allocates an entry in the GOT with value (sym+add)@tprel, and computes the
1870 offset to the entry relative to the TOC base (r2). */
1871 HOWTO (R_PPC64_GOT_TPREL16_DS,
5bd4f169
AM		 1872 0, /* rightshift */
1873 1, /* size (0 = byte, 1 = short, 2 = long) */
1874 16, /* bitsize */
b34976b6 1875 FALSE, /* pc_relative */
5bd4f169
AM		 1876 0, /* bitpos */
1877 complain_overflow_signed, /* complain_on_overflow */
411e1bfb
AM		 1878 ppc64_elf_unhandled_reloc, /* special_function */
1879 "R_PPC64_GOT_TPREL16_DS", /* name */
b34976b6 1880 FALSE, /* partial_inplace */
d006db6c 1881 0, /* src_mask */
ad8e1ba5 1882 0xfffc, /* dst_mask */
b34976b6 1883 FALSE), /* pcrel_offset */
5bd4f169 1884
411e1bfb
AM		 1885 /* Like GOT_TPREL16_DS, but no overflow. */
1886 HOWTO (R_PPC64_GOT_TPREL16_LO_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_dont, /* complain_on_overflow */
411e1bfb
AM		 1893 ppc64_elf_unhandled_reloc, /* special_function */
1894 "R_PPC64_GOT_TPREL16_LO_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_LO_DS, but next higher group of 16 bits. */
1901 HOWTO (R_PPC64_GOT_TPREL16_HI,
1902 16, /* rightshift */
5bd4f169
AM		 1903 1, /* size (0 = byte, 1 = short, 2 = long) */
1904 16, /* bitsize */
b34976b6 1905 FALSE, /* pc_relative */
5bd4f169 1906 0, /* bitpos */
f9c6b907 1907 complain_overflow_signed, /* complain_on_overflow */
805fc799 1908 ppc64_elf_unhandled_reloc, /* special_function */
411e1bfb 1909 "R_PPC64_GOT_TPREL16_HI", /* name */
b34976b6 1910 FALSE, /* partial_inplace */
d006db6c 1911 0, /* src_mask */
411e1bfb 1912 0xffff, /* dst_mask */
b34976b6 1913 FALSE), /* pcrel_offset */
5bd4f169 1914
411e1bfb
AM		 1915 /* Like GOT_TPREL16_HI, but adjust for low 16 bits. */
1916 HOWTO (R_PPC64_GOT_TPREL16_HA,
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_HA", /* name */
b34976b6 1925 FALSE, /* partial_inplace */
d006db6c 1926 0, /* src_mask */
411e1bfb 1927 0xffff, /* dst_mask */
b34976b6 1928 FALSE), /* pcrel_offset */
5bd4f169 1929
25f23106
AM		 1930 HOWTO (R_PPC64_JMP_IREL, /* type */
1931 0, /* rightshift */
1932 0, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1933 0, /* bitsize */
1934 FALSE, /* pc_relative */
1935 0, /* bitpos */
1936 complain_overflow_dont, /* complain_on_overflow */
1937 ppc64_elf_unhandled_reloc, /* special_function */
1938 "R_PPC64_JMP_IREL", /* name */
1939 FALSE, /* partial_inplace */
1940 0, /* src_mask */
1941 0, /* dst_mask */
1942 FALSE), /* pcrel_offset */
1943
e054468f
AM		 1944 HOWTO (R_PPC64_IRELATIVE, /* type */
1945 0, /* rightshift */
1946 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1947 64, /* bitsize */
1948 FALSE, /* pc_relative */
1949 0, /* bitpos */
1950 complain_overflow_dont, /* complain_on_overflow */
1951 bfd_elf_generic_reloc, /* special_function */
1952 "R_PPC64_IRELATIVE", /* name */
1953 FALSE, /* partial_inplace */
1954 0, /* src_mask */
1955 ONES (64), /* dst_mask */
1956 FALSE), /* pcrel_offset */
1957
25f23106
AM		 1958 /* A 16 bit relative relocation. */
1959 HOWTO (R_PPC64_REL16, /* type */
1960 0, /* rightshift */
1961 1, /* size (0 = byte, 1 = short, 2 = long) */
1962 16, /* bitsize */
1963 TRUE, /* pc_relative */
1964 0, /* bitpos */
b80eed39 1965 complain_overflow_signed, /* complain_on_overflow */
25f23106
AM		 1966 bfd_elf_generic_reloc, /* special_function */
1967 "R_PPC64_REL16", /* name */
1968 FALSE, /* partial_inplace */
1969 0, /* src_mask */
1970 0xffff, /* dst_mask */
1971 TRUE), /* pcrel_offset */
1972
1973 /* A 16 bit relative relocation without overflow. */
1974 HOWTO (R_PPC64_REL16_LO, /* type */
1975 0, /* rightshift */
1976 1, /* size (0 = byte, 1 = short, 2 = long) */
1977 16, /* bitsize */
1978 TRUE, /* pc_relative */
1979 0, /* bitpos */
1980 complain_overflow_dont,/* complain_on_overflow */
1981 bfd_elf_generic_reloc, /* special_function */
1982 "R_PPC64_REL16_LO", /* name */
1983 FALSE, /* partial_inplace */
1984 0, /* src_mask */
1985 0xffff, /* dst_mask */
1986 TRUE), /* pcrel_offset */
1987
1988 /* The high order 16 bits of a relative address. */
1989 HOWTO (R_PPC64_REL16_HI, /* type */
1990 16, /* rightshift */
1991 1, /* size (0 = byte, 1 = short, 2 = long) */
1992 16, /* bitsize */
1993 TRUE, /* pc_relative */
1994 0, /* bitpos */
f9c6b907 1995 complain_overflow_signed, /* complain_on_overflow */
25f23106
AM		 1996 bfd_elf_generic_reloc, /* special_function */
1997 "R_PPC64_REL16_HI", /* 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, plus 1 if the contents of
2004 the low 16 bits, treated as a signed number, is negative. */
2005 HOWTO (R_PPC64_REL16_HA, /* type */
2006 16, /* rightshift */
2007 1, /* size (0 = byte, 1 = short, 2 = long) */
2008 16, /* bitsize */
2009 TRUE, /* pc_relative */
2010 0, /* bitpos */
f9c6b907 2011 complain_overflow_signed, /* complain_on_overflow */
25f23106
AM		 2012 ppc64_elf_ha_reloc, /* special_function */
2013 "R_PPC64_REL16_HA", /* name */
2014 FALSE, /* partial_inplace */
2015 0, /* src_mask */
2016 0xffff, /* dst_mask */
2017 TRUE), /* pcrel_offset */
2018
f9c6b907
AM		 2019 /* Like R_PPC64_ADDR16_HI, but no overflow. */
2020 HOWTO (R_PPC64_ADDR16_HIGH, /* type */
2021 16, /* rightshift */
2022 1, /* size (0 = byte, 1 = short, 2 = long) */
2023 16, /* bitsize */
2024 FALSE, /* pc_relative */
2025 0, /* bitpos */
2026 complain_overflow_dont, /* complain_on_overflow */
2027 bfd_elf_generic_reloc, /* special_function */
2028 "R_PPC64_ADDR16_HIGH", /* name */
2029 FALSE, /* partial_inplace */
2030 0, /* src_mask */
2031 0xffff, /* dst_mask */
2032 FALSE), /* pcrel_offset */
2033
2034 /* Like R_PPC64_ADDR16_HA, but no overflow. */
2035 HOWTO (R_PPC64_ADDR16_HIGHA, /* type */
2036 16, /* rightshift */
2037 1, /* size (0 = byte, 1 = short, 2 = long) */
2038 16, /* bitsize */
2039 FALSE, /* pc_relative */
2040 0, /* bitpos */
2041 complain_overflow_dont, /* complain_on_overflow */
2042 ppc64_elf_ha_reloc, /* special_function */
2043 "R_PPC64_ADDR16_HIGHA", /* name */
2044 FALSE, /* partial_inplace */
2045 0, /* src_mask */
2046 0xffff, /* dst_mask */
2047 FALSE), /* pcrel_offset */
2048
2049 /* Like R_PPC64_DTPREL16_HI, but no overflow. */
2050 HOWTO (R_PPC64_DTPREL16_HIGH,
2051 16, /* rightshift */
2052 1, /* size (0 = byte, 1 = short, 2 = long) */
2053 16, /* bitsize */
2054 FALSE, /* pc_relative */
2055 0, /* bitpos */
2056 complain_overflow_dont, /* complain_on_overflow */
2057 ppc64_elf_unhandled_reloc, /* special_function */
2058 "R_PPC64_DTPREL16_HIGH", /* name */
2059 FALSE, /* partial_inplace */
2060 0, /* src_mask */
2061 0xffff, /* dst_mask */
2062 FALSE), /* pcrel_offset */
2063
2064 /* Like R_PPC64_DTPREL16_HA, but no overflow. */
2065 HOWTO (R_PPC64_DTPREL16_HIGHA,
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 ppc64_elf_unhandled_reloc, /* special_function */
2073 "R_PPC64_DTPREL16_HIGHA", /* name */
2074 FALSE, /* partial_inplace */
2075 0, /* src_mask */
2076 0xffff, /* dst_mask */
2077 FALSE), /* pcrel_offset */
2078
2079 /* Like R_PPC64_TPREL16_HI, but no overflow. */
2080 HOWTO (R_PPC64_TPREL16_HIGH,
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_unhandled_reloc, /* special_function */
2088 "R_PPC64_TPREL16_HIGH", /* name */
2089 FALSE, /* partial_inplace */
2090 0, /* src_mask */
2091 0xffff, /* dst_mask */
2092 FALSE), /* pcrel_offset */
2093
2094 /* Like R_PPC64_TPREL16_HA, but no overflow. */
2095 HOWTO (R_PPC64_TPREL16_HIGHA,
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_TPREL16_HIGHA", /* name */
2104 FALSE, /* partial_inplace */
2105 0, /* src_mask */
2106 0xffff, /* dst_mask */
2107 FALSE), /* pcrel_offset */
2108
45965137
AM		 2109 /* Like ADDR64, but use local entry point of function. */
2110 HOWTO (R_PPC64_ADDR64_LOCAL, /* type */
2111 0, /* rightshift */
2112 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
2113 64, /* bitsize */
2114 FALSE, /* pc_relative */
2115 0, /* bitpos */
2116 complain_overflow_dont, /* complain_on_overflow */
2117 bfd_elf_generic_reloc, /* special_function */
2118 "R_PPC64_ADDR64_LOCAL", /* name */
2119 FALSE, /* partial_inplace */
2120 0, /* src_mask */
2121 ONES (64), /* dst_mask */
2122 FALSE), /* pcrel_offset */
2123
5bd4f169
AM		 2124 /* GNU extension to record C++ vtable hierarchy. */
2125 HOWTO (R_PPC64_GNU_VTINHERIT, /* type */
2126 0, /* rightshift */
2127 0, /* size (0 = byte, 1 = short, 2 = long) */
2128 0, /* bitsize */
b34976b6 2129 FALSE, /* pc_relative */
5bd4f169
AM		 2130 0, /* bitpos */
2131 complain_overflow_dont, /* complain_on_overflow */
2132 NULL, /* special_function */
2133 "R_PPC64_GNU_VTINHERIT", /* name */
b34976b6 2134 FALSE, /* partial_inplace */
5bd4f169
AM		 2135 0, /* src_mask */
2136 0, /* dst_mask */
b34976b6 2137 FALSE), /* pcrel_offset */
5bd4f169
AM		 2138
2139 /* GNU extension to record C++ vtable member usage. */
2140 HOWTO (R_PPC64_GNU_VTENTRY, /* type */
2141 0, /* rightshift */
2142 0, /* size (0 = byte, 1 = short, 2 = long) */
2143 0, /* bitsize */
b34976b6 2144 FALSE, /* pc_relative */
5bd4f169
AM		 2145 0, /* bitpos */
2146 complain_overflow_dont, /* complain_on_overflow */
2147 NULL, /* special_function */
2148 "R_PPC64_GNU_VTENTRY", /* name */
b34976b6 2149 FALSE, /* partial_inplace */
5bd4f169
AM		 2150 0, /* src_mask */
2151 0, /* dst_mask */
b34976b6 2152 FALSE), /* pcrel_offset */
5bd4f169
AM		 2153};
2154
2155\f
2156/* Initialize the ppc64_elf_howto_table, so that linear accesses can
2157 be done. */
2158
2159static void
4ce794b7 2160ppc_howto_init (void)
5bd4f169
AM		 2161{
2162 unsigned int i, type;
2163
2164 for (i = 0;
2165 i < sizeof (ppc64_elf_howto_raw) / sizeof (ppc64_elf_howto_raw[0]);
2166 i++)
2167 {
2168 type = ppc64_elf_howto_raw[i].type;
2169 BFD_ASSERT (type < (sizeof (ppc64_elf_howto_table)
2170 / sizeof (ppc64_elf_howto_table[0])));
2171 ppc64_elf_howto_table[type] = &ppc64_elf_howto_raw[i];
2172 }
2173}
2174
2175static reloc_howto_type *
4ce794b7
AM		 2176ppc64_elf_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2177 bfd_reloc_code_real_type code)
5bd4f169 2178{
411e1bfb 2179 enum elf_ppc64_reloc_type r = R_PPC64_NONE;
5bd4f169
AM		 2180
2181 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2182 /* Initialize howto table if needed. */
2183 ppc_howto_init ();
2184
4ce794b7 2185 switch (code)
5bd4f169
AM		 2186 {
2187 default:
4ce794b7 2188 return NULL;
5bd4f169 2189
411e1bfb
AM		 2190 case BFD_RELOC_NONE: r = R_PPC64_NONE;
2191 break;
2192 case BFD_RELOC_32: r = R_PPC64_ADDR32;
2193 break;
2194 case BFD_RELOC_PPC_BA26: r = R_PPC64_ADDR24;
2195 break;
2196 case BFD_RELOC_16: r = R_PPC64_ADDR16;
2197 break;
2198 case BFD_RELOC_LO16: r = R_PPC64_ADDR16_LO;
2199 break;
2200 case BFD_RELOC_HI16: r = R_PPC64_ADDR16_HI;
2201 break;
f9c6b907
AM		 2202 case BFD_RELOC_PPC64_ADDR16_HIGH: r = R_PPC64_ADDR16_HIGH;
2203 break;
411e1bfb 2204 case BFD_RELOC_HI16_S: r = R_PPC64_ADDR16_HA;
5bd4f169 2205 break;
f9c6b907
AM		 2206 case BFD_RELOC_PPC64_ADDR16_HIGHA: r = R_PPC64_ADDR16_HIGHA;
2207 break;
411e1bfb 2208 case BFD_RELOC_PPC_BA16: r = R_PPC64_ADDR14;
5bd4f169 2209 break;
411e1bfb 2210 case BFD_RELOC_PPC_BA16_BRTAKEN: r = R_PPC64_ADDR14_BRTAKEN;
5bd4f169 2211 break;
411e1bfb 2212 case BFD_RELOC_PPC_BA16_BRNTAKEN: r = R_PPC64_ADDR14_BRNTAKEN;
5bd4f169 2213 break;
411e1bfb 2214 case BFD_RELOC_PPC_B26: r = R_PPC64_REL24;
5bd4f169 2215 break;
411e1bfb 2216 case BFD_RELOC_PPC_B16: r = R_PPC64_REL14;
5bd4f169 2217 break;
411e1bfb 2218 case BFD_RELOC_PPC_B16_BRTAKEN: r = R_PPC64_REL14_BRTAKEN;
5bd4f169 2219 break;
411e1bfb 2220 case BFD_RELOC_PPC_B16_BRNTAKEN: r = R_PPC64_REL14_BRNTAKEN;
5bd4f169 2221 break;
411e1bfb 2222 case BFD_RELOC_16_GOTOFF: r = R_PPC64_GOT16;
5bd4f169 2223 break;
411e1bfb 2224 case BFD_RELOC_LO16_GOTOFF: r = R_PPC64_GOT16_LO;
5bd4f169 2225 break;
411e1bfb 2226 case BFD_RELOC_HI16_GOTOFF: r = R_PPC64_GOT16_HI;
5bd4f169 2227 break;
411e1bfb 2228 case BFD_RELOC_HI16_S_GOTOFF: r = R_PPC64_GOT16_HA;
5bd4f169 2229 break;
411e1bfb 2230 case BFD_RELOC_PPC_COPY: r = R_PPC64_COPY;
5bd4f169 2231 break;
411e1bfb 2232 case BFD_RELOC_PPC_GLOB_DAT: r = R_PPC64_GLOB_DAT;
5bd4f169 2233 break;
411e1bfb 2234 case BFD_RELOC_32_PCREL: r = R_PPC64_REL32;
5bd4f169 2235 break;
411e1bfb 2236 case BFD_RELOC_32_PLTOFF: r = R_PPC64_PLT32;
5bd4f169 2237 break;
411e1bfb 2238 case BFD_RELOC_32_PLT_PCREL: r = R_PPC64_PLTREL32;
5bd4f169 2239 break;
411e1bfb 2240 case BFD_RELOC_LO16_PLTOFF: r = R_PPC64_PLT16_LO;
5bd4f169 2241 break;
411e1bfb 2242 case BFD_RELOC_HI16_PLTOFF: r = R_PPC64_PLT16_HI;
5bd4f169 2243 break;
411e1bfb 2244 case BFD_RELOC_HI16_S_PLTOFF: r = R_PPC64_PLT16_HA;
5bd4f169 2245 break;
411e1bfb 2246 case BFD_RELOC_16_BASEREL: r = R_PPC64_SECTOFF;
5bd4f169 2247 break;
411e1bfb 2248 case BFD_RELOC_LO16_BASEREL: r = R_PPC64_SECTOFF_LO;
5bd4f169 2249 break;
411e1bfb 2250 case BFD_RELOC_HI16_BASEREL: r = R_PPC64_SECTOFF_HI;
5bd4f169 2251 break;
411e1bfb 2252 case BFD_RELOC_HI16_S_BASEREL: r = R_PPC64_SECTOFF_HA;
5bd4f169 2253 break;
411e1bfb 2254 case BFD_RELOC_CTOR: r = R_PPC64_ADDR64;
5bd4f169 2255 break;
411e1bfb 2256 case BFD_RELOC_64: r = R_PPC64_ADDR64;
5bd4f169 2257 break;
411e1bfb 2258 case BFD_RELOC_PPC64_HIGHER: r = R_PPC64_ADDR16_HIGHER;
5bd4f169 2259 break;
411e1bfb 2260 case BFD_RELOC_PPC64_HIGHER_S: r = R_PPC64_ADDR16_HIGHERA;
5bd4f169 2261 break;
411e1bfb 2262 case BFD_RELOC_PPC64_HIGHEST: r = R_PPC64_ADDR16_HIGHEST;
5bd4f169 2263 break;
411e1bfb 2264 case BFD_RELOC_PPC64_HIGHEST_S: r = R_PPC64_ADDR16_HIGHESTA;
5bd4f169 2265 break;
411e1bfb 2266 case BFD_RELOC_64_PCREL: r = R_PPC64_REL64;
5bd4f169 2267 break;
411e1bfb 2268 case BFD_RELOC_64_PLTOFF: r = R_PPC64_PLT64;
5bd4f169 2269 break;
411e1bfb 2270 case BFD_RELOC_64_PLT_PCREL: r = R_PPC64_PLTREL64;
5bd4f169 2271 break;
411e1bfb 2272 case BFD_RELOC_PPC_TOC16: r = R_PPC64_TOC16;
5bd4f169 2273 break;
411e1bfb 2274 case BFD_RELOC_PPC64_TOC16_LO: r = R_PPC64_TOC16_LO;
5bd4f169 2275 break;
411e1bfb 2276 case BFD_RELOC_PPC64_TOC16_HI: r = R_PPC64_TOC16_HI;
5bd4f169 2277 break;
411e1bfb 2278 case BFD_RELOC_PPC64_TOC16_HA: r = R_PPC64_TOC16_HA;
5bd4f169 2279 break;
411e1bfb 2280 case BFD_RELOC_PPC64_TOC: r = R_PPC64_TOC;
5bd4f169 2281 break;
411e1bfb 2282 case BFD_RELOC_PPC64_PLTGOT16: r = R_PPC64_PLTGOT16;
5bd4f169 2283 break;
411e1bfb 2284 case BFD_RELOC_PPC64_PLTGOT16_LO: r = R_PPC64_PLTGOT16_LO;
5bd4f169 2285 break;
411e1bfb 2286 case BFD_RELOC_PPC64_PLTGOT16_HI: r = R_PPC64_PLTGOT16_HI;
5bd4f169 2287 break;
411e1bfb 2288 case BFD_RELOC_PPC64_PLTGOT16_HA: r = R_PPC64_PLTGOT16_HA;
5bd4f169 2289 break;
411e1bfb 2290 case BFD_RELOC_PPC64_ADDR16_DS: r = R_PPC64_ADDR16_DS;
5bd4f169 2291 break;
411e1bfb 2292 case BFD_RELOC_PPC64_ADDR16_LO_DS: r = R_PPC64_ADDR16_LO_DS;
5bd4f169 2293 break;
411e1bfb 2294 case BFD_RELOC_PPC64_GOT16_DS: r = R_PPC64_GOT16_DS;
5bd4f169 2295 break;
411e1bfb 2296 case BFD_RELOC_PPC64_GOT16_LO_DS: r = R_PPC64_GOT16_LO_DS;
5bd4f169 2297 break;
411e1bfb 2298 case BFD_RELOC_PPC64_PLT16_LO_DS: r = R_PPC64_PLT16_LO_DS;
5bd4f169 2299 break;
411e1bfb 2300 case BFD_RELOC_PPC64_SECTOFF_DS: r = R_PPC64_SECTOFF_DS;
5bd4f169 2301 break;
411e1bfb 2302 case BFD_RELOC_PPC64_SECTOFF_LO_DS: r = R_PPC64_SECTOFF_LO_DS;
5bd4f169 2303 break;
411e1bfb 2304 case BFD_RELOC_PPC64_TOC16_DS: r = R_PPC64_TOC16_DS;
5bd4f169 2305 break;
411e1bfb 2306 case BFD_RELOC_PPC64_TOC16_LO_DS: r = R_PPC64_TOC16_LO_DS;
5bd4f169 2307 break;
411e1bfb 2308 case BFD_RELOC_PPC64_PLTGOT16_DS: r = R_PPC64_PLTGOT16_DS;
5bd4f169 2309 break;
411e1bfb 2310 case BFD_RELOC_PPC64_PLTGOT16_LO_DS: r = R_PPC64_PLTGOT16_LO_DS;
5bd4f169 2311 break;
411e1bfb 2312 case BFD_RELOC_PPC_TLS: r = R_PPC64_TLS;
5bd4f169 2313 break;
727fc41e
AM		 2314 case BFD_RELOC_PPC_TLSGD: r = R_PPC64_TLSGD;
2315 break;
2316 case BFD_RELOC_PPC_TLSLD: r = R_PPC64_TLSLD;
2317 break;
411e1bfb 2318 case BFD_RELOC_PPC_DTPMOD: r = R_PPC64_DTPMOD64;
5bd4f169 2319 break;
411e1bfb 2320 case BFD_RELOC_PPC_TPREL16: r = R_PPC64_TPREL16;
5bd4f169 2321 break;
411e1bfb 2322 case BFD_RELOC_PPC_TPREL16_LO: r = R_PPC64_TPREL16_LO;
5bd4f169 2323 break;
411e1bfb 2324 case BFD_RELOC_PPC_TPREL16_HI: r = R_PPC64_TPREL16_HI;
5bd4f169 2325 break;
f9c6b907
AM		 2326 case BFD_RELOC_PPC64_TPREL16_HIGH: r = R_PPC64_TPREL16_HIGH;
2327 break;
411e1bfb 2328 case BFD_RELOC_PPC_TPREL16_HA: r = R_PPC64_TPREL16_HA;
5bd4f169 2329 break;
f9c6b907
AM		 2330 case BFD_RELOC_PPC64_TPREL16_HIGHA: r = R_PPC64_TPREL16_HIGHA;
2331 break;
411e1bfb 2332 case BFD_RELOC_PPC_TPREL: r = R_PPC64_TPREL64;
5bd4f169 2333 break;
411e1bfb
AM		 2334 case BFD_RELOC_PPC_DTPREL16: r = R_PPC64_DTPREL16;
2335 break;
2336 case BFD_RELOC_PPC_DTPREL16_LO: r = R_PPC64_DTPREL16_LO;
2337 break;
2338 case BFD_RELOC_PPC_DTPREL16_HI: r = R_PPC64_DTPREL16_HI;
2339 break;
f9c6b907
AM		 2340 case BFD_RELOC_PPC64_DTPREL16_HIGH: r = R_PPC64_DTPREL16_HIGH;
2341 break;
411e1bfb
AM		 2342 case BFD_RELOC_PPC_DTPREL16_HA: r = R_PPC64_DTPREL16_HA;
2343 break;
f9c6b907
AM		 2344 case BFD_RELOC_PPC64_DTPREL16_HIGHA: r = R_PPC64_DTPREL16_HIGHA;
2345 break;
411e1bfb
AM		 2346 case BFD_RELOC_PPC_DTPREL: r = R_PPC64_DTPREL64;
2347 break;
2348 case BFD_RELOC_PPC_GOT_TLSGD16: r = R_PPC64_GOT_TLSGD16;
2349 break;
2350 case BFD_RELOC_PPC_GOT_TLSGD16_LO: r = R_PPC64_GOT_TLSGD16_LO;
2351 break;
2352 case BFD_RELOC_PPC_GOT_TLSGD16_HI: r = R_PPC64_GOT_TLSGD16_HI;
2353 break;
2354 case BFD_RELOC_PPC_GOT_TLSGD16_HA: r = R_PPC64_GOT_TLSGD16_HA;
2355 break;
2356 case BFD_RELOC_PPC_GOT_TLSLD16: r = R_PPC64_GOT_TLSLD16;
2357 break;
2358 case BFD_RELOC_PPC_GOT_TLSLD16_LO: r = R_PPC64_GOT_TLSLD16_LO;
2359 break;
2360 case BFD_RELOC_PPC_GOT_TLSLD16_HI: r = R_PPC64_GOT_TLSLD16_HI;
2361 break;
2362 case BFD_RELOC_PPC_GOT_TLSLD16_HA: r = R_PPC64_GOT_TLSLD16_HA;
2363 break;
2364 case BFD_RELOC_PPC_GOT_TPREL16: r = R_PPC64_GOT_TPREL16_DS;
2365 break;
2366 case BFD_RELOC_PPC_GOT_TPREL16_LO: r = R_PPC64_GOT_TPREL16_LO_DS;
2367 break;
2368 case BFD_RELOC_PPC_GOT_TPREL16_HI: r = R_PPC64_GOT_TPREL16_HI;
2369 break;
2370 case BFD_RELOC_PPC_GOT_TPREL16_HA: r = R_PPC64_GOT_TPREL16_HA;
2371 break;
2372 case BFD_RELOC_PPC_GOT_DTPREL16: r = R_PPC64_GOT_DTPREL16_DS;
2373 break;
2374 case BFD_RELOC_PPC_GOT_DTPREL16_LO: r = R_PPC64_GOT_DTPREL16_LO_DS;
2375 break;
2376 case BFD_RELOC_PPC_GOT_DTPREL16_HI: r = R_PPC64_GOT_DTPREL16_HI;
2377 break;
2378 case BFD_RELOC_PPC_GOT_DTPREL16_HA: r = R_PPC64_GOT_DTPREL16_HA;
2379 break;
2380 case BFD_RELOC_PPC64_TPREL16_DS: r = R_PPC64_TPREL16_DS;
2381 break;
2382 case BFD_RELOC_PPC64_TPREL16_LO_DS: r = R_PPC64_TPREL16_LO_DS;
2383 break;
2384 case BFD_RELOC_PPC64_TPREL16_HIGHER: r = R_PPC64_TPREL16_HIGHER;
2385 break;
2386 case BFD_RELOC_PPC64_TPREL16_HIGHERA: r = R_PPC64_TPREL16_HIGHERA;
2387 break;
2388 case BFD_RELOC_PPC64_TPREL16_HIGHEST: r = R_PPC64_TPREL16_HIGHEST;
2389 break;
2390 case BFD_RELOC_PPC64_TPREL16_HIGHESTA: r = R_PPC64_TPREL16_HIGHESTA;
2391 break;
2392 case BFD_RELOC_PPC64_DTPREL16_DS: r = R_PPC64_DTPREL16_DS;
2393 break;
2394 case BFD_RELOC_PPC64_DTPREL16_LO_DS: r = R_PPC64_DTPREL16_LO_DS;
2395 break;
2396 case BFD_RELOC_PPC64_DTPREL16_HIGHER: r = R_PPC64_DTPREL16_HIGHER;
2397 break;
2398 case BFD_RELOC_PPC64_DTPREL16_HIGHERA: r = R_PPC64_DTPREL16_HIGHERA;
2399 break;
2400 case BFD_RELOC_PPC64_DTPREL16_HIGHEST: r = R_PPC64_DTPREL16_HIGHEST;
2401 break;
2402 case BFD_RELOC_PPC64_DTPREL16_HIGHESTA: r = R_PPC64_DTPREL16_HIGHESTA;
2403 break;
25f23106
AM		 2404 case BFD_RELOC_16_PCREL: r = R_PPC64_REL16;
2405 break;
2406 case BFD_RELOC_LO16_PCREL: r = R_PPC64_REL16_LO;
2407 break;
2408 case BFD_RELOC_HI16_PCREL: r = R_PPC64_REL16_HI;
2409 break;
2410 case BFD_RELOC_HI16_S_PCREL: r = R_PPC64_REL16_HA;
2411 break;
45965137
AM		 2412 case BFD_RELOC_PPC64_ADDR64_LOCAL: r = R_PPC64_ADDR64_LOCAL;
2413 break;
411e1bfb
AM		 2414 case BFD_RELOC_VTABLE_INHERIT: r = R_PPC64_GNU_VTINHERIT;
2415 break;
2416 case BFD_RELOC_VTABLE_ENTRY: r = R_PPC64_GNU_VTENTRY;
5bd4f169
AM		 2417 break;
2418 }
2419
4ce794b7 2420 return ppc64_elf_howto_table[r];
5bd4f169
AM		 2421};
2422
157090f7
AM		 2423static reloc_howto_type *
2424ppc64_elf_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2425 const char *r_name)
2426{
2427 unsigned int i;
2428
2429 for (i = 0;
2430 i < sizeof (ppc64_elf_howto_raw) / sizeof (ppc64_elf_howto_raw[0]);
2431 i++)
2432 if (ppc64_elf_howto_raw[i].name != NULL
2433 && strcasecmp (ppc64_elf_howto_raw[i].name, r_name) == 0)
2434 return &ppc64_elf_howto_raw[i];
2435
2436 return NULL;
2437}
2438
5bd4f169
AM		 2439/* Set the howto pointer for a PowerPC ELF reloc. */
2440
2441static void
4ce794b7
AM		 2442ppc64_elf_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr,
2443 Elf_Internal_Rela *dst)
5bd4f169 2444{
65f38f15
AM		 2445 unsigned int type;
2446
ef60b7ff 2447 /* Initialize howto table if needed. */
5bd4f169 2448 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
5bd4f169
AM		 2449 ppc_howto_init ();
2450
65f38f15 2451 type = ELF64_R_TYPE (dst->r_info);
d0fb9a8d
JJ		 2452 if (type >= (sizeof (ppc64_elf_howto_table)
2453 / sizeof (ppc64_elf_howto_table[0])))
2454 {
2455 (*_bfd_error_handler) (_("%B: invalid relocation type %d"),
3ec2b351
NC		 2456 abfd, (int) type);
2457 type = R_PPC64_NONE;
d0fb9a8d 2458 }
65f38f15 2459 cache_ptr->howto = ppc64_elf_howto_table[type];
5bd4f169
AM		 2460}
2461
04c9666a 2462/* Handle the R_PPC64_ADDR16_HA and similar relocs. */
5bd4f169
AM		 2463
2464static bfd_reloc_status_type
4ce794b7
AM		 2465ppc64_elf_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2466 void *data, asection *input_section,
2467 bfd *output_bfd, char **error_message)
5bd4f169 2468{
805fc799
AM		 2469 /* If this is a relocatable link (output_bfd test tells us), just
2470 call the generic function. Any adjustment will be done at final
2471 link time. */
2472 if (output_bfd != NULL)
cedb70c5 2473 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
805fc799
AM		 2474 input_section, output_bfd, error_message);
2475
2476 /* Adjust the addend for sign extension of the low 16 bits.
2477 We won't actually be using the low 16 bits, so trashing them
2478 doesn't matter. */
2479 reloc_entry->addend += 0x8000;
2480 return bfd_reloc_continue;
2481}
5bd4f169 2482
2441e016
AM		 2483static bfd_reloc_status_type
2484ppc64_elf_branch_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2485 void *data, asection *input_section,
2486 bfd *output_bfd, char **error_message)
2487{
2488 if (output_bfd != NULL)
2489 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2490 input_section, output_bfd, error_message);
2491
699733f6
AM		 2492 if (strcmp (symbol->section->name, ".opd") == 0
2493 && (symbol->section->owner->flags & DYNAMIC) == 0)
2441e016
AM		 2494 {
2495 bfd_vma dest = opd_entry_value (symbol->section,
2496 symbol->value + reloc_entry->addend,
aef36ac1 2497 NULL, NULL, FALSE);
2441e016
AM		 2498 if (dest != (bfd_vma) -1)
2499 reloc_entry->addend = dest - (symbol->value
2500 + symbol->section->output_section->vma
2501 + symbol->section->output_offset);
2502 }
810d4e75
AM		 2503 else
2504 {
2505 elf_symbol_type *elfsym = (elf_symbol_type *) symbol;
2506
2507 if (symbol->section->owner != abfd
2508 && abiversion (symbol->section->owner) >= 2)
2509 {
2510 unsigned int i;
2511
2512 for (i = 0; i < symbol->section->owner->symcount; ++i)
2513 {
2514 asymbol *symdef = symbol->section->owner->outsymbols[i];
2515
2516 if (strcmp (symdef->name, symbol->name) == 0)
2517 {
2518 elfsym = (elf_symbol_type *) symdef;
2519 break;
2520 }
2521 }
2522 }
2523 reloc_entry->addend
2524 += PPC64_LOCAL_ENTRY_OFFSET (elfsym->internal_elf_sym.st_other);
2525 }
2441e016
AM		 2526 return bfd_reloc_continue;
2527}
2528
805fc799 2529static bfd_reloc_status_type
4ce794b7
AM		 2530ppc64_elf_brtaken_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2531 void *data, asection *input_section,
2532 bfd *output_bfd, char **error_message)
805fc799
AM		 2533{
2534 long insn;
04c9666a 2535 enum elf_ppc64_reloc_type r_type;
805fc799 2536 bfd_size_type octets;
794e51c0
AM		 2537 /* Assume 'at' branch hints. */
2538 bfd_boolean is_isa_v2 = TRUE;
805fc799
AM		 2539
2540 /* If this is a relocatable link (output_bfd test tells us), just
2541 call the generic function. Any adjustment will be done at final
2542 link time. */
5bd4f169 2543 if (output_bfd != NULL)
cedb70c5 2544 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
805fc799
AM		 2545 input_section, output_bfd, error_message);
2546
2547 octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2548 insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
2549 insn &= ~(0x01 << 21);
4ce794b7 2550 r_type = reloc_entry->howto->type;
805fc799
AM		 2551 if (r_type == R_PPC64_ADDR14_BRTAKEN
2552 || r_type == R_PPC64_REL14_BRTAKEN)
cedb70c5 2553 insn |= 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field. */
805fc799 2554
794e51c0 2555 if (is_isa_v2)
5bd4f169 2556 {
805fc799
AM		 2557 /* Set 'a' bit. This is 0b00010 in BO field for branch
2558 on CR(BI) insns (BO == 001at or 011at), and 0b01000
2559 for branch on CTR insns (BO == 1a00t or 1a01t). */
2560 if ((insn & (0x14 << 21)) == (0x04 << 21))
2561 insn |= 0x02 << 21;
2562 else if ((insn & (0x14 << 21)) == (0x10 << 21))
2563 insn |= 0x08 << 21;
2564 else
2441e016 2565 goto out;
5bd4f169 2566 }
805fc799
AM		 2567 else
2568 {
2569 bfd_vma target = 0;
2570 bfd_vma from;
5bd4f169 2571
805fc799
AM		 2572 if (!bfd_is_com_section (symbol->section))
2573 target = symbol->value;
2574 target += symbol->section->output_section->vma;
2575 target += symbol->section->output_offset;
2576 target += reloc_entry->addend;
5bd4f169 2577
805fc799
AM		 2578 from = (reloc_entry->address
2579 + input_section->output_offset
2580 + input_section->output_section->vma);
5bd4f169 2581
805fc799
AM		 2582 /* Invert 'y' bit if not the default. */
2583 if ((bfd_signed_vma) (target - from) < 0)
2584 insn ^= 0x01 << 21;
2585 }
4ce794b7 2586 bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
2441e016
AM		 2587 out:
2588 return ppc64_elf_branch_reloc (abfd, reloc_entry, symbol, data,
2589 input_section, output_bfd, error_message);
805fc799 2590}
5bd4f169 2591
805fc799 2592static bfd_reloc_status_type
4ce794b7
AM		 2593ppc64_elf_sectoff_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2594 void *data, asection *input_section,
2595 bfd *output_bfd, char **error_message)
805fc799
AM		 2596{
2597 /* If this is a relocatable link (output_bfd test tells us), just
2598 call the generic function. Any adjustment will be done at final
2599 link time. */
2600 if (output_bfd != NULL)
cedb70c5 2601 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
805fc799 2602 input_section, output_bfd, error_message);
5bd4f169 2603
805fc799
AM		 2604 /* Subtract the symbol section base address. */
2605 reloc_entry->addend -= symbol->section->output_section->vma;
5bd4f169
AM		 2606 return bfd_reloc_continue;
2607}
2608
805fc799 2609static bfd_reloc_status_type
4ce794b7
AM		 2610ppc64_elf_sectoff_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2611 void *data, asection *input_section,
2612 bfd *output_bfd, char **error_message)
805fc799
AM		 2613{
2614 /* If this is a relocatable link (output_bfd test tells us), just
2615 call the generic function. Any adjustment will be done at final
2616 link time. */
2617 if (output_bfd != NULL)
cedb70c5 2618 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
805fc799
AM		 2619 input_section, output_bfd, error_message);
2620
2621 /* Subtract the symbol section base address. */
2622 reloc_entry->addend -= symbol->section->output_section->vma;
2623
2624 /* Adjust the addend for sign extension of the low 16 bits. */
2625 reloc_entry->addend += 0x8000;
2626 return bfd_reloc_continue;
2627}
2628
2629static bfd_reloc_status_type
4ce794b7
AM		 2630ppc64_elf_toc_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2631 void *data, asection *input_section,
2632 bfd *output_bfd, char **error_message)
805fc799
AM		 2633{
2634 bfd_vma TOCstart;
2635
2636 /* If this is a relocatable link (output_bfd test tells us), just
2637 call the generic function. Any adjustment will be done at final
2638 link time. */
2639 if (output_bfd != NULL)
cedb70c5 2640 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
805fc799
AM		 2641 input_section, output_bfd, error_message);
2642
2643 TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2644 if (TOCstart == 0)
1c865ab2 2645 TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
805fc799
AM		 2646
2647 /* Subtract the TOC base address. */
2648 reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2649 return bfd_reloc_continue;
2650}
2651
2652static bfd_reloc_status_type
4ce794b7
AM		 2653ppc64_elf_toc_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2654 void *data, asection *input_section,
2655 bfd *output_bfd, char **error_message)
805fc799
AM		 2656{
2657 bfd_vma TOCstart;
2658
2659 /* If this is a relocatable link (output_bfd test tells us), just
2660 call the generic function. Any adjustment will be done at final
2661 link time. */
2662 if (output_bfd != NULL)
cedb70c5 2663 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
805fc799
AM		 2664 input_section, output_bfd, error_message);
2665
2666 TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2667 if (TOCstart == 0)
1c865ab2 2668 TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
805fc799
AM		 2669
2670 /* Subtract the TOC base address. */
2671 reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2672
2673 /* Adjust the addend for sign extension of the low 16 bits. */
2674 reloc_entry->addend += 0x8000;
2675 return bfd_reloc_continue;
2676}
2677
2678static bfd_reloc_status_type
4ce794b7
AM		 2679ppc64_elf_toc64_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2680 void *data, asection *input_section,
2681 bfd *output_bfd, char **error_message)
805fc799
AM		 2682{
2683 bfd_vma TOCstart;
2684 bfd_size_type octets;
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
AM		 2691 input_section, output_bfd, error_message);
2692
2693 TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2694 if (TOCstart == 0)
1c865ab2 2695 TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
805fc799
AM		 2696
2697 octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2698 bfd_put_64 (abfd, TOCstart + TOC_BASE_OFF, (bfd_byte *) data + octets);
2699 return bfd_reloc_ok;
2700}
2701
2702static bfd_reloc_status_type
4ce794b7
AM		 2703ppc64_elf_unhandled_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2704 void *data, asection *input_section,
2705 bfd *output_bfd, char **error_message)
805fc799
AM		 2706{
2707 /* If this is a relocatable link (output_bfd test tells us), just
2708 call the generic function. Any adjustment will be done at final
2709 link time. */
2710 if (output_bfd != NULL)
cedb70c5 2711 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
805fc799
AM		 2712 input_section, output_bfd, error_message);
2713
2714 if (error_message != NULL)
2715 {
2716 static char buf[60];
2717 sprintf (buf, "generic linker can't handle %s",
2718 reloc_entry->howto->name);
2719 *error_message = buf;
2720 }
2721 return bfd_reloc_dangerous;
2722}
2723
927be08e
AM		 2724/* Track GOT entries needed for a given symbol. We might need more
2725 than one got entry per symbol. */
2726struct got_entry
2727{
2728 struct got_entry *next;
2729
2730 /* The symbol addend that we'll be placing in the GOT. */
2731 bfd_vma addend;
2732
2733 /* Unlike other ELF targets, we use separate GOT entries for the same
2734 symbol referenced from different input files. This is to support
2735 automatic multiple TOC/GOT sections, where the TOC base can vary
2736 from one input file to another. After partitioning into TOC groups
2737 we merge entries within the group.
2738
2739 Point to the BFD owning this GOT entry. */
2740 bfd *owner;
2741
2742 /* Zero for non-tls entries, or TLS_TLS and one of TLS_GD, TLS_LD,
2743 TLS_TPREL or TLS_DTPREL for tls entries. */
f961d9dd 2744 unsigned char tls_type;
927be08e
AM		 2745
2746 /* Non-zero if got.ent points to real entry. */
f961d9dd 2747 unsigned char is_indirect;
927be08e
AM		 2748
2749 /* Reference count until size_dynamic_sections, GOT offset thereafter. */
2750 union
2751 {
2752 bfd_signed_vma refcount;
2753 bfd_vma offset;
2754 struct got_entry *ent;
2755 } got;
2756};
2757
2758/* The same for PLT. */
2759struct plt_entry
2760{
2761 struct plt_entry *next;
2762
2763 bfd_vma addend;
2764
2765 union
2766 {
2767 bfd_signed_vma refcount;
2768 bfd_vma offset;
2769 } plt;
2770};
2771
e717da7e
AM		 2772struct ppc64_elf_obj_tdata
2773{
2774 struct elf_obj_tdata elf;
2775
2776 /* Shortcuts to dynamic linker sections. */
2777 asection *got;
2778 asection *relgot;
2779
b3fac117
AM		 2780 /* Used during garbage collection. We attach global symbols defined
2781 on removed .opd entries to this section so that the sym is removed. */
2782 asection *deleted_section;
81688140 2783
927be08e 2784 /* TLS local dynamic got entry handling. Support for multiple GOT
e717da7e 2785 sections means we potentially need one of these for each input bfd. */
927be08e 2786 struct got_entry tlsld_got;
8860955f 2787
729eabd5
AM		 2788 union {
2789 /* A copy of relocs before they are modified for --emit-relocs. */
2790 Elf_Internal_Rela *relocs;
2791
2792 /* Section contents. */
2793 bfd_byte *contents;
2794 } opd;
d77c8a4b
AM		 2795
2796 /* Nonzero if this bfd has small toc/got relocs, ie. that expect
2797 the reloc to be in the range -32768 to 32767. */
98528052
AM		 2798 unsigned int has_small_toc_reloc : 1;
2799
560c8763
AM		 2800 /* Set if toc/got ha relocs detected not using r2, or lo reloc
2801 instruction not one we handle. */
2802 unsigned int unexpected_toc_insn : 1;
e717da7e
AM		 2803};
2804
2805#define ppc64_elf_tdata(bfd) \
2806 ((struct ppc64_elf_obj_tdata *) (bfd)->tdata.any)
2807
2808#define ppc64_tlsld_got(bfd) \
2809 (&ppc64_elf_tdata (bfd)->tlsld_got)
2810
0c8d6e5c
AM		 2811#define is_ppc64_elf(bfd) \
2812 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
4dfe6ac6 2813 && elf_object_id (bfd) == PPC64_ELF_DATA)
0c8d6e5c 2814
e717da7e
AM		 2815/* Override the generic function because we store some extras. */
2816
2817static bfd_boolean
2818ppc64_elf_mkobject (bfd *abfd)
2819{
0ffa91dd 2820 return bfd_elf_allocate_object (abfd, sizeof (struct ppc64_elf_obj_tdata),
4dfe6ac6 2821 PPC64_ELF_DATA);
e717da7e
AM		 2822}
2823
feee612b
AM		 2824/* Fix bad default arch selected for a 64 bit input bfd when the
2825 default is 32 bit. */
2826
b34976b6 2827static bfd_boolean
4ce794b7 2828ppc64_elf_object_p (bfd *abfd)
feee612b
AM		 2829{
2830 if (abfd->arch_info->the_default && abfd->arch_info->bits_per_word == 32)
2831 {
2832 Elf_Internal_Ehdr *i_ehdr = elf_elfheader (abfd);
2833
2834 if (i_ehdr->e_ident[EI_CLASS] == ELFCLASS64)
2835 {
2836 /* Relies on arch after 32 bit default being 64 bit default. */
2837 abfd->arch_info = abfd->arch_info->next;
2838 BFD_ASSERT (abfd->arch_info->bits_per_word == 64);
2839 }
2840 }
b34976b6 2841 return TRUE;
feee612b
AM		 2842}
2843
d37c89e5
AM		 2844/* Support for core dump NOTE sections. */
2845
2846static bfd_boolean
2847ppc64_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
2848{
eea6121a 2849 size_t offset, size;
d37c89e5
AM		 2850
2851 if (note->descsz != 504)
2852 return FALSE;
2853
2854 /* pr_cursig */
228e534f 2855 elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
d37c89e5
AM		 2856
2857 /* pr_pid */
228e534f 2858 elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 32);
d37c89e5
AM		 2859
2860 /* pr_reg */
2861 offset = 112;
eea6121a 2862 size = 384;
d37c89e5
AM		 2863
2864 /* Make a ".reg/999" section. */
2865 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
eea6121a 2866 size, note->descpos + offset);
d37c89e5
AM		 2867}
2868
2869static bfd_boolean
2870ppc64_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
2871{
2872 if (note->descsz != 136)
2873 return FALSE;
2874
228e534f 2875 elf_tdata (abfd)->core->pid
bc989cdc 2876 = bfd_get_32 (abfd, note->descdata + 24);
228e534f 2877 elf_tdata (abfd)->core->program
d37c89e5 2878 = _bfd_elfcore_strndup (abfd, note->descdata + 40, 16);
228e534f 2879 elf_tdata (abfd)->core->command
d37c89e5
AM		 2880 = _bfd_elfcore_strndup (abfd, note->descdata + 56, 80);
2881
2882 return TRUE;
2883}
2884
183e98be
AM		 2885static char *
2886ppc64_elf_write_core_note (bfd *abfd, char *buf, int *bufsiz, int note_type,
2887 ...)
2888{
2889 switch (note_type)
2890 {
2891 default:
2892 return NULL;
2893
2894 case NT_PRPSINFO:
2895 {
2896 char data[136];
2897 va_list ap;
2898
2899 va_start (ap, note_type);
75cd47ed 2900 memset (data, 0, sizeof (data));
183e98be
AM		 2901 strncpy (data + 40, va_arg (ap, const char *), 16);
2902 strncpy (data + 56, va_arg (ap, const char *), 80);
2903 va_end (ap);
2904 return elfcore_write_note (abfd, buf, bufsiz,
2905 "CORE", note_type, data, sizeof (data));
2906 }
2907
2908 case NT_PRSTATUS:
2909 {
2910 char data[504];
2911 va_list ap;
2912 long pid;
2913 int cursig;
2914 const void *greg;
2915
2916 va_start (ap, note_type);
2917 memset (data, 0, 112);
2918 pid = va_arg (ap, long);
2919 bfd_put_32 (abfd, pid, data + 32);
2920 cursig = va_arg (ap, int);
2921 bfd_put_16 (abfd, cursig, data + 12);
2922 greg = va_arg (ap, const void *);
2923 memcpy (data + 112, greg, 384);
2924 memset (data + 496, 0, 8);
2925 va_end (ap);
2926 return elfcore_write_note (abfd, buf, bufsiz,
2927 "CORE", note_type, data, sizeof (data));
2928 }
2929 }
2930}
2931
5d35169e
AM		 2932/* Add extra PPC sections. */
2933
b35d266b 2934static const struct bfd_elf_special_section ppc64_elf_special_sections[]=
7f4d3958 2935{
0112cd26
NC		 2936 { STRING_COMMA_LEN (".plt"), 0, SHT_NOBITS, 0 },
2937 { STRING_COMMA_LEN (".sbss"), -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE },
2938 { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2939 { STRING_COMMA_LEN (".toc"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2940 { STRING_COMMA_LEN (".toc1"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2941 { STRING_COMMA_LEN (".tocbss"), 0, SHT_NOBITS, SHF_ALLOC + SHF_WRITE },
2942 { NULL, 0, 0, 0, 0 }
5d35169e
AM		 2943};
2944
7c8fe5c4
AM		 2945enum _ppc64_sec_type {
2946 sec_normal = 0,
2947 sec_opd = 1,
2948 sec_toc = 2
2949};
2950
f0abc2a1
AM		 2951struct _ppc64_elf_section_data
2952{
2953 struct bfd_elf_section_data elf;
411e1bfb 2954
f0abc2a1
AM		 2955 union
2956 {
51aecdc5
AM		 2957 /* An array with one entry for each opd function descriptor,
2958 and some spares since opd entries may be either 16 or 24 bytes. */
2959#define OPD_NDX(OFF) ((OFF) >> 4)
74f0fb50
AM		 2960 struct _opd_sec_data
2961 {
2962 /* Points to the function code section for local opd entries. */
2963 asection **func_sec;
2964
2965 /* After editing .opd, adjust references to opd local syms. */
2966 long *adjust;
2967 } opd;
7c8fe5c4 2968
3a71aa26
AM		 2969 /* An array for toc sections, indexed by offset/8. */
2970 struct _toc_sec_data
2971 {
2972 /* Specifies the relocation symbol index used at a given toc offset. */
2973 unsigned *symndx;
2974
2975 /* And the relocation addend. */
2976 bfd_vma *add;
2977 } toc;
7c8fe5c4
AM		 2978 } u;
2979
2980 enum _ppc64_sec_type sec_type:2;
411e1bfb 2981
7c8fe5c4
AM		 2982 /* Flag set when small branches are detected. Used to
2983 select suitable defaults for the stub group size. */
2984 unsigned int has_14bit_branch:1;
f0abc2a1
AM		 2985};
2986
2987#define ppc64_elf_section_data(sec) \
411e1bfb 2988 ((struct _ppc64_elf_section_data *) elf_section_data (sec))
f0abc2a1
AM		 2989
2990static bfd_boolean
4ce794b7 2991ppc64_elf_new_section_hook (bfd *abfd, asection *sec)
f0abc2a1 2992{
f592407e
AM		 2993 if (!sec->used_by_bfd)
2994 {
2995 struct _ppc64_elf_section_data *sdata;
2996 bfd_size_type amt = sizeof (*sdata);
f0abc2a1 2997
f592407e
AM		 2998 sdata = bfd_zalloc (abfd, amt);
2999 if (sdata == NULL)
3000 return FALSE;
3001 sec->used_by_bfd = sdata;
3002 }
f0abc2a1
AM		 3003
3004 return _bfd_elf_new_section_hook (abfd, sec);
3005}
4025353c 3006
74f0fb50 3007static struct _opd_sec_data *
4025353c
AM		 3008get_opd_info (asection * sec)
3009{
3010 if (sec != NULL
3011 && ppc64_elf_section_data (sec) != NULL
7c8fe5c4 3012 && ppc64_elf_section_data (sec)->sec_type == sec_opd)
74f0fb50 3013 return &ppc64_elf_section_data (sec)->u.opd;
4025353c
AM		 3014 return NULL;
3015}
90e3cdf2
JJ		 3016\f
3017/* Parameters for the qsort hook. */
90e3cdf2
JJ		 3018static bfd_boolean synthetic_relocatable;
3019
699733f6 3020/* qsort comparison function for ppc64_elf_get_synthetic_symtab. */
90e3cdf2
JJ		 3021
3022static int
3023compare_symbols (const void *ap, const void *bp)
3024{
3025 const asymbol *a = * (const asymbol **) ap;
3026 const asymbol *b = * (const asymbol **) bp;
3027
699733f6
AM		 3028 /* Section symbols first. */
3029 if ((a->flags & BSF_SECTION_SYM) && !(b->flags & BSF_SECTION_SYM))
90e3cdf2 3030 return -1;
699733f6 3031 if (!(a->flags & BSF_SECTION_SYM) && (b->flags & BSF_SECTION_SYM))
90e3cdf2
JJ		 3032 return 1;
3033
699733f6 3034 /* then .opd symbols. */
ffcfec52
AM		 3035 if (strcmp (a->section->name, ".opd") == 0
3036 && strcmp (b->section->name, ".opd") != 0)
90e3cdf2 3037 return -1;
ffcfec52
AM		 3038 if (strcmp (a->section->name, ".opd") != 0
3039 && strcmp (b->section->name, ".opd") == 0)
90e3cdf2
JJ		 3040 return 1;
3041
699733f6 3042 /* then other code symbols. */
90e3cdf2
JJ		 3043 if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3044 == (SEC_CODE | SEC_ALLOC)
3045 && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3046 != (SEC_CODE | SEC_ALLOC))
3047 return -1;
3048
3049 if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3050 != (SEC_CODE | SEC_ALLOC)
3051 && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3052 == (SEC_CODE | SEC_ALLOC))
3053 return 1;
3054
3055 if (synthetic_relocatable)
3056 {
3057 if (a->section->id < b->section->id)
3058 return -1;
3059
3060 if (a->section->id > b->section->id)
3061 return 1;
3062 }
3063
3064 if (a->value + a->section->vma < b->value + b->section->vma)
3065 return -1;
3066
3067 if (a->value + a->section->vma > b->value + b->section->vma)
3068 return 1;
3069
4d35a0aa
AM		 3070 /* For syms with the same value, prefer strong dynamic global function
3071 syms over other syms. */
3072 if ((a->flags & BSF_GLOBAL) != 0 && (b->flags & BSF_GLOBAL) == 0)
3073 return -1;
3074
3075 if ((a->flags & BSF_GLOBAL) == 0 && (b->flags & BSF_GLOBAL) != 0)
3076 return 1;
3077
3078 if ((a->flags & BSF_FUNCTION) != 0 && (b->flags & BSF_FUNCTION) == 0)
3079 return -1;
3080
3081 if ((a->flags & BSF_FUNCTION) == 0 && (b->flags & BSF_FUNCTION) != 0)
3082 return 1;
3083
3084 if ((a->flags & BSF_WEAK) == 0 && (b->flags & BSF_WEAK) != 0)
3085 return -1;
3086
3087 if ((a->flags & BSF_WEAK) != 0 && (b->flags & BSF_WEAK) == 0)
3088 return 1;
3089
3090 if ((a->flags & BSF_DYNAMIC) != 0 && (b->flags & BSF_DYNAMIC) == 0)
3091 return -1;
3092
3093 if ((a->flags & BSF_DYNAMIC) == 0 && (b->flags & BSF_DYNAMIC) != 0)
3094 return 1;
3095
90e3cdf2
JJ		 3096 return 0;
3097}
3098
699733f6 3099/* Search SYMS for a symbol of the given VALUE. */
90e3cdf2 3100
699733f6
AM		 3101static asymbol *
3102sym_exists_at (asymbol **syms, long lo, long hi, int id, bfd_vma value)
90e3cdf2 3103{
699733f6 3104 long mid;
90e3cdf2 3105
699733f6
AM		 3106 if (id == -1)
3107 {
3108 while (lo < hi)
3109 {
3110 mid = (lo + hi) >> 1;
3111 if (syms[mid]->value + syms[mid]->section->vma < value)
3112 lo = mid + 1;
3113 else if (syms[mid]->value + syms[mid]->section->vma > value)
3114 hi = mid;
3115 else
3116 return syms[mid];
3117 }
3118 }
3119 else
3120 {
3121 while (lo < hi)
3122 {
3123 mid = (lo + hi) >> 1;
3124 if (syms[mid]->section->id < id)
3125 lo = mid + 1;
3126 else if (syms[mid]->section->id > id)
3127 hi = mid;
3128 else if (syms[mid]->value < value)
3129 lo = mid + 1;
3130 else if (syms[mid]->value > value)
3131 hi = mid;
3132 else
3133 return syms[mid];
3134 }
3135 }
3136 return NULL;
90e3cdf2
JJ		 3137}
3138
468392fb
AM		 3139static bfd_boolean
3140section_covers_vma (bfd *abfd ATTRIBUTE_UNUSED, asection *section, void *ptr)
3141{
3142 bfd_vma vma = *(bfd_vma *) ptr;
3143 return ((section->flags & SEC_ALLOC) != 0
3144 && section->vma <= vma
3145 && vma < section->vma + section->size);
3146}
3147
699733f6 3148/* Create synthetic symbols, effectively restoring "dot-symbol" function
c4b0b099
AM		 3149 entry syms. Also generate @plt symbols for the glink branch table.
3150 Returns count of synthetic symbols in RET or -1 on error. */
90e3cdf2
JJ		 3151
3152static long
a7535cf3
AM		 3153ppc64_elf_get_synthetic_symtab (bfd *abfd,
3154 long static_count, asymbol **static_syms,
3155 long dyn_count, asymbol **dyn_syms,
c9727e01 3156 asymbol **ret)
90e3cdf2
JJ		 3157{
3158 asymbol *s;
699733f6
AM		 3159 long i;
3160 long count;
90e3cdf2 3161 char *names;
a7535cf3 3162 long symcount, codesecsym, codesecsymend, secsymend, opdsymend;
ee67d69a 3163 asection *opd = NULL;
90e3cdf2 3164 bfd_boolean relocatable = (abfd->flags & (EXEC_P | DYNAMIC)) == 0;
a7535cf3 3165 asymbol **syms;
ee67d69a 3166 int abi = abiversion (abfd);
90e3cdf2
JJ		 3167
3168 *ret = NULL;
3169
ee67d69a
AM		 3170 if (abi < 2)
3171 {
3172 opd = bfd_get_section_by_name (abfd, ".opd");
3173 if (opd == NULL && abi == 1)
3174 return 0;
3175 }
90e3cdf2 3176
a7535cf3 3177 symcount = static_count;
c9727e01 3178 if (!relocatable)
a7535cf3 3179 symcount += dyn_count;
90e3cdf2 3180 if (symcount == 0)
c9727e01 3181 return 0;
90e3cdf2 3182
a7535cf3
AM		 3183 syms = bfd_malloc ((symcount + 1) * sizeof (*syms));
3184 if (syms == NULL)
7356fed5 3185 return -1;
a7535cf3
AM		 3186
3187 if (!relocatable && static_count != 0 && dyn_count != 0)
3188 {
3189 /* Use both symbol tables. */
3190 memcpy (syms, static_syms, static_count * sizeof (*syms));
3191 memcpy (syms + static_count, dyn_syms, (dyn_count + 1) * sizeof (*syms));
3192 }
3193 else if (!relocatable && static_count == 0)
3194 memcpy (syms, dyn_syms, (symcount + 1) * sizeof (*syms));
3195 else
3196 memcpy (syms, static_syms, (symcount + 1) * sizeof (*syms));
3197
90e3cdf2 3198 synthetic_relocatable = relocatable;
595da8c5 3199 qsort (syms, symcount, sizeof (*syms), compare_symbols);
90e3cdf2 3200
c9727e01
AM		 3201 if (!relocatable && symcount > 1)
3202 {
3203 long j;
3204 /* Trim duplicate syms, since we may have merged the normal and
3205 dynamic symbols. Actually, we only care about syms that have
3b36f7e6 3206 different values, so trim any with the same value. */
c9727e01
AM		 3207 for (i = 1, j = 1; i < symcount; ++i)
3208 if (syms[i - 1]->value + syms[i - 1]->section->vma
3209 != syms[i]->value + syms[i]->section->vma)
3210 syms[j++] = syms[i];
3211 symcount = j;
3212 }
3213
699733f6 3214 i = 0;
ffcfec52 3215 if (strcmp (syms[i]->section->name, ".opd") == 0)
699733f6
AM		 3216 ++i;
3217 codesecsym = i;
90e3cdf2 3218
699733f6
AM		 3219 for (; i < symcount; ++i)
3220 if (((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3221 != (SEC_CODE | SEC_ALLOC))
3222 || (syms[i]->flags & BSF_SECTION_SYM) == 0)
3223 break;
3224 codesecsymend = i;
90e3cdf2 3225
699733f6
AM		 3226 for (; i < symcount; ++i)
3227 if ((syms[i]->flags & BSF_SECTION_SYM) == 0)
3228 break;
3229 secsymend = i;
90e3cdf2 3230
699733f6 3231 for (; i < symcount; ++i)
ffcfec52 3232 if (strcmp (syms[i]->section->name, ".opd") != 0)
699733f6
AM		 3233 break;
3234 opdsymend = i;
90e3cdf2 3235
699733f6
AM		 3236 for (; i < symcount; ++i)
3237 if ((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3238 != (SEC_CODE | SEC_ALLOC))
3239 break;
3240 symcount = i;
3241
c9727e01 3242 count = 0;
90e3cdf2 3243
699733f6 3244 if (relocatable)
90e3cdf2 3245 {
699733f6
AM		 3246 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3247 arelent *r;
3248 size_t size;
3249 long relcount;
90e3cdf2 3250
468392fb
AM		 3251 if (opdsymend == secsymend)
3252 goto done;
3253
699733f6 3254 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
90e3cdf2 3255 relcount = (opd->flags & SEC_RELOC) ? opd->reloc_count : 0;
7356fed5 3256 if (relcount == 0)
c9727e01 3257 goto done;
90e3cdf2 3258
7356fed5
AM		 3259 if (!(*slurp_relocs) (abfd, opd, static_syms, FALSE))
3260 {
3261 count = -1;
3262 goto done;
3263 }
3264
699733f6 3265 size = 0;
595da8c5 3266 for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
699733f6
AM		 3267 {
3268 asymbol *sym;
90e3cdf2 3269
595da8c5 3270 while (r < opd->relocation + relcount
699733f6
AM		 3271 && r->address < syms[i]->value + opd->vma)
3272 ++r;
90e3cdf2 3273
595da8c5 3274 if (r == opd->relocation + relcount)
699733f6 3275 break;
90e3cdf2 3276
699733f6
AM		 3277 if (r->address != syms[i]->value + opd->vma)
3278 continue;
90e3cdf2 3279
699733f6
AM		 3280 if (r->howto->type != R_PPC64_ADDR64)
3281 continue;
90e3cdf2 3282
699733f6
AM		 3283 sym = *r->sym_ptr_ptr;
3284 if (!sym_exists_at (syms, opdsymend, symcount,
3285 sym->section->id, sym->value + r->addend))
3286 {
3287 ++count;
3288 size += sizeof (asymbol);
3289 size += strlen (syms[i]->name) + 2;
3290 }
3291 }
90e3cdf2 3292
c4b0b099
AM		 3293 if (size == 0)
3294 goto done;
699733f6
AM		 3295 s = *ret = bfd_malloc (size);
3296 if (s == NULL)
3297 {
7356fed5 3298 count = -1;
c9727e01 3299 goto done;
699733f6 3300 }
90e3cdf2 3301
699733f6 3302 names = (char *) (s + count);
90e3cdf2 3303
595da8c5 3304 for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
90e3cdf2 3305 {
699733f6 3306 asymbol *sym;
90e3cdf2 3307
595da8c5 3308 while (r < opd->relocation + relcount
699733f6
AM		 3309 && r->address < syms[i]->value + opd->vma)
3310 ++r;
90e3cdf2 3311
595da8c5 3312 if (r == opd->relocation + relcount)
699733f6
AM		 3313 break;
3314
3315 if (r->address != syms[i]->value + opd->vma)
3316 continue;
3317
3318 if (r->howto->type != R_PPC64_ADDR64)
3319 continue;
90e3cdf2 3320
699733f6
AM		 3321 sym = *r->sym_ptr_ptr;
3322 if (!sym_exists_at (syms, opdsymend, symcount,
3323 sym->section->id, sym->value + r->addend))
3324 {
3325 size_t len;
3326
3327 *s = *syms[i];
6ba2a415 3328 s->flags |= BSF_SYNTHETIC;
699733f6
AM		 3329 s->section = sym->section;
3330 s->value = sym->value + r->addend;
3331 s->name = names;
3332 *names++ = '.';
3333 len = strlen (syms[i]->name);
3334 memcpy (names, syms[i]->name, len + 1);
3335 names += len + 1;
6f610d07
UW		 3336 /* Have udata.p point back to the original symbol this
3337 synthetic symbol was derived from. */
3338 s->udata.p = syms[i];
699733f6
AM		 3339 s++;
3340 }
3341 }
3342 }
3343 else
90e3cdf2 3344 {
468392fb 3345 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
ee67d69a 3346 bfd_byte *contents = NULL;
699733f6 3347 size_t size;
468392fb
AM		 3348 long plt_count = 0;
3349 bfd_vma glink_vma = 0, resolv_vma = 0;
3350 asection *dynamic, *glink = NULL, *relplt = NULL;
3351 arelent *p;
90e3cdf2 3352
ee67d69a 3353 if (opd != NULL && !bfd_malloc_and_get_section (abfd, opd, &contents))
699733f6 3354 {
c4b0b099
AM		 3355 free_contents_and_exit_err:
3356 count = -1;
ee67d69a 3357 free_contents_and_exit:
699733f6 3358 if (contents)
ee67d69a 3359 free (contents);
c9727e01 3360 goto done;
699733f6 3361 }
90e3cdf2 3362
699733f6
AM		 3363 size = 0;
3364 for (i = secsymend; i < opdsymend; ++i)
3365 {
3366 bfd_vma ent;
90e3cdf2 3367
5ef11c02
AM		 3368 /* Ignore bogus symbols. */
3369 if (syms[i]->value > opd->size - 8)
3370 continue;
3371
699733f6
AM		 3372 ent = bfd_get_64 (abfd, contents + syms[i]->value);
3373 if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3374 {
3375 ++count;
3376 size += sizeof (asymbol);
3377 size += strlen (syms[i]->name) + 2;
3378 }
3379 }
90e3cdf2 3380
468392fb 3381 /* Get start of .glink stubs from DT_PPC64_GLINK. */
066ee829
AM		 3382 if (dyn_count != 0
3383 && (dynamic = bfd_get_section_by_name (abfd, ".dynamic")) != NULL)
468392fb
AM		 3384 {
3385 bfd_byte *dynbuf, *extdyn, *extdynend;
3386 size_t extdynsize;
3387 void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *);
3388
3389 if (!bfd_malloc_and_get_section (abfd, dynamic, &dynbuf))
c4b0b099 3390 goto free_contents_and_exit_err;
468392fb
AM		 3391
3392 extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
3393 swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
3394
3395 extdyn = dynbuf;
3396 extdynend = extdyn + dynamic->size;
3397 for (; extdyn < extdynend; extdyn += extdynsize)
3398 {
3399 Elf_Internal_Dyn dyn;
3400 (*swap_dyn_in) (abfd, extdyn, &dyn);
3401
3402 if (dyn.d_tag == DT_NULL)
3403 break;
3404
3405 if (dyn.d_tag == DT_PPC64_GLINK)
3406 {
b9e5796b
AM		 3407 /* The first glink stub starts at offset 32; see
3408 comment in ppc64_elf_finish_dynamic_sections. */
3409 glink_vma = dyn.d_un.d_val + GLINK_CALL_STUB_SIZE - 8 * 4;
468392fb
AM		 3410 /* The .glink section usually does not survive the final
3411 link; search for the section (usually .text) where the
3412 glink stubs now reside. */
3413 glink = bfd_sections_find_if (abfd, section_covers_vma,
3414 &glink_vma);
3415 break;
3416 }
3417 }
3418
3419 free (dynbuf);
3420 }
3421
3422 if (glink != NULL)
3423 {
3424 /* Determine __glink trampoline by reading the relative branch
3425 from the first glink stub. */
3426 bfd_byte buf[4];
b9e5796b
AM		 3427 unsigned int off = 0;
3428
3429 while (bfd_get_section_contents (abfd, glink, buf,
3430 glink_vma + off - glink->vma, 4))
468392fb
AM		 3431 {
3432 unsigned int insn = bfd_get_32 (abfd, buf);
3433 insn ^= B_DOT;
3434 if ((insn & ~0x3fffffc) == 0)
b9e5796b
AM		 3435 {
3436 resolv_vma = glink_vma + off + (insn ^ 0x2000000) - 0x2000000;
3437 break;
3438 }
3439 off += 4;
3440 if (off > 4)
3441 break;
468392fb
AM		 3442 }
3443
3444 if (resolv_vma)
3445 size += sizeof (asymbol) + sizeof ("__glink_PLTresolve");
468392fb 3446
066ee829
AM		 3447 relplt = bfd_get_section_by_name (abfd, ".rela.plt");
3448 if (relplt != NULL)
3449 {
3450 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3451 if (! (*slurp_relocs) (abfd, relplt, dyn_syms, TRUE))
c4b0b099 3452 goto free_contents_and_exit_err;
68ffbac6 3453
066ee829
AM		 3454 plt_count = relplt->size / sizeof (Elf64_External_Rela);
3455 size += plt_count * sizeof (asymbol);
468392fb 3456
066ee829
AM		 3457 p = relplt->relocation;
3458 for (i = 0; i < plt_count; i++, p++)
e054468f
AM		 3459 {
3460 size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
3461 if (p->addend != 0)
3462 size += sizeof ("+0x") - 1 + 16;
3463 }
066ee829 3464 }
468392fb
AM		 3465 }
3466
c4b0b099
AM		 3467 if (size == 0)
3468 goto free_contents_and_exit;
699733f6
AM		 3469 s = *ret = bfd_malloc (size);
3470 if (s == NULL)
c4b0b099 3471 goto free_contents_and_exit_err;
90e3cdf2 3472
468392fb 3473 names = (char *) (s + count + plt_count + (resolv_vma != 0));
90e3cdf2 3474
699733f6 3475 for (i = secsymend; i < opdsymend; ++i)
90e3cdf2 3476 {
699733f6 3477 bfd_vma ent;
90e3cdf2 3478
5ef11c02
AM		 3479 if (syms[i]->value > opd->size - 8)
3480 continue;
3481
699733f6
AM		 3482 ent = bfd_get_64 (abfd, contents + syms[i]->value);
3483 if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
90e3cdf2 3484 {
c9727e01 3485 long lo, hi;
699733f6 3486 size_t len;
c9727e01 3487 asection *sec = abfd->sections;
90e3cdf2 3488
699733f6
AM		 3489 *s = *syms[i];
3490 lo = codesecsym;
3491 hi = codesecsymend;
3492 while (lo < hi)
3493 {
c9727e01 3494 long mid = (lo + hi) >> 1;
699733f6
AM		 3495 if (syms[mid]->section->vma < ent)
3496 lo = mid + 1;
3497 else if (syms[mid]->section->vma > ent)
3498 hi = mid;
3499 else
c9727e01
AM		 3500 {
3501 sec = syms[mid]->section;
3502 break;
3503 }
699733f6
AM		 3504 }
3505
c9727e01 3506 if (lo >= hi && lo > codesecsym)
699733f6 3507 sec = syms[lo - 1]->section;
699733f6
AM		 3508
3509 for (; sec != NULL; sec = sec->next)
3510 {
3511 if (sec->vma > ent)
3512 break;
63524580
JK		 3513 /* SEC_LOAD may not be set if SEC is from a separate debug
3514 info file. */
3515 if ((sec->flags & SEC_ALLOC) == 0)
699733f6
AM		 3516 break;
3517 if ((sec->flags & SEC_CODE) != 0)
3518 s->section = sec;
3519 }
6ba2a415 3520 s->flags |= BSF_SYNTHETIC;
699733f6
AM		 3521 s->value = ent - s->section->vma;
3522 s->name = names;
3523 *names++ = '.';
3524 len = strlen (syms[i]->name);
3525 memcpy (names, syms[i]->name, len + 1);
3526 names += len + 1;
6f610d07
UW		 3527 /* Have udata.p point back to the original symbol this
3528 synthetic symbol was derived from. */
3529 s->udata.p = syms[i];
699733f6 3530 s++;
90e3cdf2 3531 }
90e3cdf2 3532 }
699733f6 3533 free (contents);
468392fb
AM		 3534
3535 if (glink != NULL && relplt != NULL)
3536 {
3537 if (resolv_vma)
3538 {
3539 /* Add a symbol for the main glink trampoline. */
86a4952b 3540 memset (s, 0, sizeof *s);
468392fb 3541 s->the_bfd = abfd;
6ba2a415 3542 s->flags = BSF_GLOBAL | BSF_SYNTHETIC;
468392fb
AM		 3543 s->section = glink;
3544 s->value = resolv_vma - glink->vma;
3545 s->name = names;
3546 memcpy (names, "__glink_PLTresolve", sizeof ("__glink_PLTresolve"));
3547 names += sizeof ("__glink_PLTresolve");
3548 s++;
3549 count++;
3550 }
3551
3552 /* FIXME: It would be very much nicer to put sym@plt on the
3553 stub rather than on the glink branch table entry. The
3554 objdump disassembler would then use a sensible symbol
3555 name on plt calls. The difficulty in doing so is
3556 a) finding the stubs, and,
3557 b) matching stubs against plt entries, and,
3558 c) there can be multiple stubs for a given plt entry.
3559
3560 Solving (a) could be done by code scanning, but older
3561 ppc64 binaries used different stubs to current code.
3562 (b) is the tricky one since you need to known the toc
3563 pointer for at least one function that uses a pic stub to
3564 be able to calculate the plt address referenced.
3565 (c) means gdb would need to set multiple breakpoints (or
3566 find the glink branch itself) when setting breakpoints
3567 for pending shared library loads. */
3568 p = relplt->relocation;
3569 for (i = 0; i < plt_count; i++, p++)
3570 {
3571 size_t len;
3572
3573 *s = **p->sym_ptr_ptr;
3574 /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set. Since
3575 we are defining a symbol, ensure one of them is set. */
3576 if ((s->flags & BSF_LOCAL) == 0)
3577 s->flags |= BSF_GLOBAL;
6ba2a415 3578 s->flags |= BSF_SYNTHETIC;
468392fb
AM		 3579 s->section = glink;
3580 s->value = glink_vma - glink->vma;
3581 s->name = names;
3582 s->udata.p = NULL;
3583 len = strlen ((*p->sym_ptr_ptr)->name);
3584 memcpy (names, (*p->sym_ptr_ptr)->name, len);
3585 names += len;
e054468f
AM		 3586 if (p->addend != 0)
3587 {
3588 memcpy (names, "+0x", sizeof ("+0x") - 1);
3589 names += sizeof ("+0x") - 1;
3590 bfd_sprintf_vma (abfd, names, p->addend);
3591 names += strlen (names);
3592 }
468392fb
AM		 3593 memcpy (names, "@plt", sizeof ("@plt"));
3594 names += sizeof ("@plt");
3595 s++;
b9e5796b
AM		 3596 if (abi < 2)
3597 {
3598 glink_vma += 8;
3599 if (i >= 0x8000)
3600 glink_vma += 4;
3601 }
3602 else
468392fb
AM		 3603 glink_vma += 4;
3604 }
3605 count += plt_count;
3606 }
90e3cdf2
JJ		 3607 }
3608
c9727e01 3609 done:
a7535cf3 3610 free (syms);
90e3cdf2
JJ		 3611 return count;
3612}
5bd4f169 3613\f
65f38f15
AM		 3614/* The following functions are specific to the ELF linker, while
3615 functions above are used generally. Those named ppc64_elf_* are
3616 called by the main ELF linker code. They appear in this file more
3617 or less in the order in which they are called. eg.
3618 ppc64_elf_check_relocs is called early in the link process,
3619 ppc64_elf_finish_dynamic_sections is one of the last functions
e86ce104
AM		 3620 called.
3621
3622 PowerPC64-ELF uses a similar scheme to PowerPC64-XCOFF in that
3623 functions have both a function code symbol and a function descriptor
3624 symbol. A call to foo in a relocatable object file looks like:
3625
3626 . .text
3627 . x:
3628 . bl .foo
3629 . nop
3630
3631 The function definition in another object file might be:
3632
3633 . .section .opd
3634 . foo: .quad .foo
3635 . .quad .TOC.@tocbase
3636 . .quad 0
3637 .
3638 . .text
3639 . .foo: blr
3640
3641 When the linker resolves the call during a static link, the branch
3642 unsurprisingly just goes to .foo and the .opd information is unused.
3643 If the function definition is in a shared library, things are a little
3644 different: The call goes via a plt call stub, the opd information gets
3645 copied to the plt, and the linker patches the nop.
3646
3647 . x:
3648 . bl .foo_stub
3649 . ld 2,40(1)
3650 .
3651 .
3652 . .foo_stub:
71a39c98
AM		 3653 . std 2,40(1) # in practice, the call stub
3654 . addis 11,2,Lfoo@toc@ha # is slightly optimized, but
3655 . addi 11,11,Lfoo@toc@l # this is the general idea
3656 . ld 12,0(11)
3657 . ld 2,8(11)
3658 . mtctr 12
3659 . ld 11,16(11)
e86ce104
AM		 3660 . bctr
3661 .
3662 . .section .plt
3663 . Lfoo: reloc (R_PPC64_JMP_SLOT, foo)
3664
3665 The "reloc ()" notation is supposed to indicate that the linker emits
3666 an R_PPC64_JMP_SLOT reloc against foo. The dynamic linker does the opd
3667 copying.
3668
3669 What are the difficulties here? Well, firstly, the relocations
3670 examined by the linker in check_relocs are against the function code
3671 sym .foo, while the dynamic relocation in the plt is emitted against
3672 the function descriptor symbol, foo. Somewhere along the line, we need
3673 to carefully copy dynamic link information from one symbol to the other.
3674 Secondly, the generic part of the elf linker will make .foo a dynamic
3675 symbol as is normal for most other backends. We need foo dynamic
3676 instead, at least for an application final link. However, when
3677 creating a shared library containing foo, we need to have both symbols
3678 dynamic so that references to .foo are satisfied during the early
3679 stages of linking. Otherwise the linker might decide to pull in a
8387904d
AM		 3680 definition from some other object, eg. a static library.
3681
3682 Update: As of August 2004, we support a new convention. Function
3683 calls may use the function descriptor symbol, ie. "bl foo". This
3684 behaves exactly as "bl .foo". */
65f38f15 3685
1d483afe 3686/* Of those relocs that might be copied as dynamic relocs, this function
58ac9f71
AM		 3687 selects those that must be copied when linking a shared library,
3688 even when the symbol is local. */
65f38f15 3689
1d483afe
AM		 3690static int
3691must_be_dyn_reloc (struct bfd_link_info *info,
3692 enum elf_ppc64_reloc_type r_type)
3693{
3694 switch (r_type)
3695 {
3696 default:
3697 return 1;
3698
3699 case R_PPC64_REL32:
3700 case R_PPC64_REL64:
3701 case R_PPC64_REL30:
3702 return 0;
3703
3704 case R_PPC64_TPREL16:
3705 case R_PPC64_TPREL16_LO:
3706 case R_PPC64_TPREL16_HI:
3707 case R_PPC64_TPREL16_HA:
3708 case R_PPC64_TPREL16_DS:
3709 case R_PPC64_TPREL16_LO_DS:
f9c6b907
AM		 3710 case R_PPC64_TPREL16_HIGH:
3711 case R_PPC64_TPREL16_HIGHA:
1d483afe
AM		 3712 case R_PPC64_TPREL16_HIGHER:
3713 case R_PPC64_TPREL16_HIGHERA:
3714 case R_PPC64_TPREL16_HIGHEST:
3715 case R_PPC64_TPREL16_HIGHESTA:
3716 case R_PPC64_TPREL64:
3717 return !info->executable;
3718 }
3719}
65f38f15 3720
f4656909
AM		 3721/* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
3722 copying dynamic variables from a shared lib into an app's dynbss
3723 section, and instead use a dynamic relocation to point into the
5d35169e
AM		 3724 shared lib. With code that gcc generates, it's vital that this be
3725 enabled; In the PowerPC64 ABI, the address of a function is actually
3726 the address of a function descriptor, which resides in the .opd
3727 section. gcc uses the descriptor directly rather than going via the
3728 GOT as some other ABI's do, which means that initialized function
3729 pointers must reference the descriptor. Thus, a function pointer
3730 initialized to the address of a function in a shared library will
3731 either require a copy reloc, or a dynamic reloc. Using a copy reloc
4cc11e76 3732 redefines the function descriptor symbol to point to the copy. This
5d35169e
AM		 3733 presents a problem as a plt entry for that function is also
3734 initialized from the function descriptor symbol and the copy reloc
3735 may not be initialized first. */
a23b6845 3736#define ELIMINATE_COPY_RELOCS 1
f4656909 3737
721956f4 3738/* Section name for stubs is the associated section name plus this
29942be8
NC		 3739 string. */
3740#define STUB_SUFFIX ".stub"
721956f4
AM		 3741
3742/* Linker stubs.
3743 ppc_stub_long_branch:
3744 Used when a 14 bit branch (or even a 24 bit branch) can't reach its
3745 destination, but a 24 bit branch in a stub section will reach.
3746 . b dest
3747
3748 ppc_stub_plt_branch:
3749 Similar to the above, but a 24 bit branch in the stub section won't
3750 reach its destination.
71a39c98
AM		 3751 . addis %r11,%r2,xxx@toc@ha
3752 . ld %r12,xxx@toc@l(%r11)
3753 . mtctr %r12
721956f4
AM		 3754 . bctr
3755
3756 ppc_stub_plt_call:
2c66dc6c
AM		 3757 Used to call a function in a shared library. If it so happens that
3758 the plt entry referenced crosses a 64k boundary, then an extra
71a39c98 3759 "addi %r11,%r11,xxx@toc@l" will be inserted before the "mtctr".
721956f4 3760 . std %r2,40(%r1)
71a39c98
AM		 3761 . addis %r11,%r2,xxx@toc@ha
3762 . ld %r12,xxx+0@toc@l(%r11)
3763 . mtctr %r12
3764 . ld %r2,xxx+8@toc@l(%r11)
3765 . ld %r11,xxx+16@toc@l(%r11)
721956f4 3766 . bctr
ad8e1ba5
AM		 3767
3768 ppc_stub_long_branch and ppc_stub_plt_branch may also have additional
3769 code to adjust the value and save r2 to support multiple toc sections.
3770 A ppc_stub_long_branch with an r2 offset looks like:
3771 . std %r2,40(%r1)
3772 . addis %r2,%r2,off@ha
3773 . addi %r2,%r2,off@l
3774 . b dest
3775
3776 A ppc_stub_plt_branch with an r2 offset looks like:
3777 . std %r2,40(%r1)
71a39c98
AM		 3778 . addis %r11,%r2,xxx@toc@ha
3779 . ld %r12,xxx@toc@l(%r11)
ad8e1ba5
AM		 3780 . addis %r2,%r2,off@ha
3781 . addi %r2,%r2,off@l
71a39c98 3782 . mtctr %r12
ad8e1ba5 3783 . bctr
ac2df442
AM		 3784
3785 In cases where the "addis" instruction would add zero, the "addis" is
3786 omitted and following instructions modified slightly in some cases.
721956f4
AM		 3787*/
3788
3789enum ppc_stub_type {
3790 ppc_stub_none,
3791 ppc_stub_long_branch,
ad8e1ba5 3792 ppc_stub_long_branch_r2off,
721956f4 3793 ppc_stub_plt_branch,
ad8e1ba5 3794 ppc_stub_plt_branch_r2off,
794e51c0 3795 ppc_stub_plt_call,
7341d5e2
AM		 3796 ppc_stub_plt_call_r2save,
3797 ppc_stub_global_entry
721956f4
AM		 3798};
3799
3800struct ppc_stub_hash_entry {
3801
3802 /* Base hash table entry structure. */
3803 struct bfd_hash_entry root;
3804
ad8e1ba5
AM		 3805 enum ppc_stub_type stub_type;
3806
721956f4
AM		 3807 /* The stub section. */
3808 asection *stub_sec;
3809
3810 /* Offset within stub_sec of the beginning of this stub. */
3811 bfd_vma stub_offset;
3812
3813 /* Given the symbol's value and its section we can determine its final
3814 value when building the stubs (so the stub knows where to jump. */
3815 bfd_vma target_value;
3816 asection *target_section;
3817
721956f4
AM		 3818 /* The symbol table entry, if any, that this was derived from. */
3819 struct ppc_link_hash_entry *h;
e054468f 3820 struct plt_entry *plt_ent;
721956f4
AM		 3821
3822 /* Where this stub is being called from, or, in the case of combined
3823 stub sections, the first input section in the group. */
3824 asection *id_sec;
6911b7dc
AM		 3825
3826 /* Symbol st_other. */
3827 unsigned char other;
721956f4
AM		 3828};
3829
3830struct ppc_branch_hash_entry {
3831
3832 /* Base hash table entry structure. */
3833 struct bfd_hash_entry root;
3834
c456f082 3835 /* Offset within branch lookup table. */
721956f4
AM		 3836 unsigned int offset;
3837
3838 /* Generation marker. */
3839 unsigned int iter;
3840};
65f38f15 3841
19e08130
AM		 3842/* Used to track dynamic relocations for local symbols. */
3843struct ppc_dyn_relocs
3844{
3845 struct ppc_dyn_relocs *next;
3846
3847 /* The input section of the reloc. */
3848 asection *sec;
3849
3850 /* Total number of relocs copied for the input section. */
3851 unsigned int count : 31;
3852
3853 /* Whether this entry is for STT_GNU_IFUNC symbols. */
3854 unsigned int ifunc : 1;
3855};
3856
65f38f15
AM		 3857struct ppc_link_hash_entry
3858{
3859 struct elf_link_hash_entry elf;
3860
b3fac117
AM		 3861 union {
3862 /* A pointer to the most recently used stub hash entry against this
3863 symbol. */
3864 struct ppc_stub_hash_entry *stub_cache;
3865
3866 /* A pointer to the next symbol starting with a '.' */
3867 struct ppc_link_hash_entry *next_dot_sym;
3868 } u;
721956f4 3869
65f38f15 3870 /* Track dynamic relocs copied for this symbol. */
6061a67d 3871 struct elf_dyn_relocs *dyn_relocs;
e86ce104 3872
721956f4 3873 /* Link between function code and descriptor symbols. */
34814b9f 3874 struct ppc_link_hash_entry *oh;
721956f4 3875
e86ce104
AM		 3876 /* Flag function code and descriptor symbols. */
3877 unsigned int is_func:1;
3878 unsigned int is_func_descriptor:1;
908b32fc 3879 unsigned int fake:1;
411e1bfb 3880
c5614fa4
AM		 3881 /* Whether global opd/toc sym has been adjusted or not.
3882 After ppc64_elf_edit_opd/ppc64_elf_edit_toc has run, this flag
3883 should be set for all globals defined in any opd/toc section. */
754021d0
AM		 3884 unsigned int adjust_done:1;
3885
99877b66
AM		 3886 /* Set if we twiddled this symbol to weak at some stage. */
3887 unsigned int was_undefined:1;
3888
411e1bfb 3889 /* Contexts in which symbol is used in the GOT (or TOC).
e7b938ca
AM		 3890 TLS_GD .. TLS_EXPLICIT bits are or'd into the mask as the
3891 corresponding relocs are encountered during check_relocs.
3892 tls_optimize clears TLS_GD .. TLS_TPREL when optimizing to
3893 indicate the corresponding GOT entry type is not needed.
3894 tls_optimize may also set TLS_TPRELGD when a GD reloc turns into
3895 a TPREL one. We use a separate flag rather than setting TPREL
3896 just for convenience in distinguishing the two cases. */
3897#define TLS_GD 1 /* GD reloc. */
3898#define TLS_LD 2 /* LD reloc. */
3899#define TLS_TPREL 4 /* TPREL reloc, => IE. */
3900#define TLS_DTPREL 8 /* DTPREL reloc, => LD. */
3901#define TLS_TLS 16 /* Any TLS reloc. */
3902#define TLS_EXPLICIT 32 /* Marks TOC section TLS relocs. */
3903#define TLS_TPRELGD 64 /* TPREL reloc resulting from GD->IE. */
e054468f 3904#define PLT_IFUNC 128 /* STT_GNU_IFUNC. */
f961d9dd 3905 unsigned char tls_mask;
65f38f15
AM		 3906};
3907
3908/* ppc64 ELF linker hash table. */
3909
3910struct ppc_link_hash_table
3911{
3912 struct elf_link_hash_table elf;
3913
721956f4
AM		 3914 /* The stub hash table. */
3915 struct bfd_hash_table stub_hash_table;
3916
3917 /* Another hash table for plt_branch stubs. */
3918 struct bfd_hash_table branch_hash_table;
3919
3b421ab3
AM		 3920 /* Hash table for function prologue tocsave. */
3921 htab_t tocsave_htab;
3922
e7d1c40c
AM		 3923 /* Various options and other info passed from the linker. */
3924 struct ppc64_elf_params *params;
721956f4
AM		 3925
3926 /* Array to keep track of which stub sections have been created, and
3927 information on stub grouping. */
3928 struct map_stub {
3929 /* This is the section to which stubs in the group will be attached. */
3930 asection *link_sec;
3931 /* The stub section. */
3932 asection *stub_sec;
ad8e1ba5
AM		 3933 /* Along with elf_gp, specifies the TOC pointer used in this group. */
3934 bfd_vma toc_off;
721956f4
AM		 3935 } *stub_group;
3936
ad8e1ba5
AM		 3937 /* Temp used when calculating TOC pointers. */
3938 bfd_vma toc_curr;
bf102f86
AM		 3939 bfd *toc_bfd;
3940 asection *toc_first_sec;
ad8e1ba5 3941
8f3bab57
AM		 3942 /* Highest input section id. */
3943 int top_id;
3944
734b6cf9
AM		 3945 /* Highest output section index. */
3946 int top_index;
3947
b3fac117
AM		 3948 /* Used when adding symbols. */
3949 struct ppc_link_hash_entry *dot_syms;
3950
734b6cf9
AM		 3951 /* List of input sections for each output section. */
3952 asection **input_list;
721956f4 3953
33e44f2e 3954 /* Shortcuts to get to dynamic linker sections. */
4ce794b7
AM		 3955 asection *dynbss;
3956 asection *relbss;
3957 asection *glink;
82bd7b59 3958 asection *sfpr;
4ce794b7
AM		 3959 asection *brlt;
3960 asection *relbrlt;
58d180e8 3961 asection *glink_eh_frame;
ec338859 3962
8387904d
AM		 3963 /* Shortcut to .__tls_get_addr and __tls_get_addr. */
3964 struct ppc_link_hash_entry *tls_get_addr;
3965 struct ppc_link_hash_entry *tls_get_addr_fd;
411e1bfb 3966
927be08e
AM		 3967 /* The size of reliplt used by got entry relocs. */
3968 bfd_size_type got_reli_size;
3969
9b5ecbd0 3970 /* Statistics. */
7341d5e2 3971 unsigned long stub_count[ppc_stub_global_entry];
9b5ecbd0 3972
ee75fd95
AM		 3973 /* Number of stubs against global syms. */
3974 unsigned long stub_globals;
3975
ee67d69a
AM		 3976 /* Set if we're linking code with function descriptors. */
3977 unsigned int opd_abi:1;
3978
4c52953f 3979 /* Support for multiple toc sections. */
33c0ec9d 3980 unsigned int do_multi_toc:1;
4c52953f 3981 unsigned int multi_toc_needed:1;
927be08e 3982 unsigned int second_toc_pass:1;
67f0cbdb 3983 unsigned int do_toc_opt:1;
4c52953f 3984
5d1634d7 3985 /* Set on error. */
99877b66 3986 unsigned int stub_error:1;
721956f4 3987
f6c7c3e8 3988 /* Temp used by ppc64_elf_before_check_relocs. */
99877b66 3989 unsigned int twiddled_syms:1;
721956f4
AM		 3990
3991 /* Incremented every time we size stubs. */
3992 unsigned int stub_iteration;
5d1634d7 3993
87d72d41
AM		 3994 /* Small local sym cache. */
3995 struct sym_cache sym_cache;
65f38f15
AM		 3996};
3997
4c52953f
AM		 3998/* Rename some of the generic section flags to better document how they
3999 are used here. */
b0dddeec
AM		 4000
4001/* Nonzero if this section has TLS related relocations. */
4002#define has_tls_reloc sec_flg0
4003
4004/* Nonzero if this section has a call to __tls_get_addr. */
4005#define has_tls_get_addr_call sec_flg1
4006
4007/* Nonzero if this section has any toc or got relocs. */
4008#define has_toc_reloc sec_flg2
4009
4010/* Nonzero if this section has a call to another section that uses
4011 the toc or got. */
d77c8a4b 4012#define makes_toc_func_call sec_flg3
b0dddeec
AM		 4013
4014/* Recursion protection when determining above flag. */
d77c8a4b 4015#define call_check_in_progress sec_flg4
70cc837d 4016#define call_check_done sec_flg5
4c52953f 4017
65f38f15
AM		 4018/* Get the ppc64 ELF linker hash table from a link_info structure. */
4019
4020#define ppc_hash_table(p) \
4dfe6ac6
NC		 4021 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
4022 == PPC64_ELF_DATA ? ((struct ppc_link_hash_table *) ((p)->hash)) : NULL)
65f38f15 4023
721956f4
AM		 4024#define ppc_stub_hash_lookup(table, string, create, copy) \
4025 ((struct ppc_stub_hash_entry *) \
4026 bfd_hash_lookup ((table), (string), (create), (copy)))
4027
4028#define ppc_branch_hash_lookup(table, string, create, copy) \
4029 ((struct ppc_branch_hash_entry *) \
4030 bfd_hash_lookup ((table), (string), (create), (copy)))
4031
4032/* Create an entry in the stub hash table. */
4033
4034static struct bfd_hash_entry *
4ce794b7
AM		 4035stub_hash_newfunc (struct bfd_hash_entry *entry,
4036 struct bfd_hash_table *table,
4037 const char *string)
721956f4
AM		 4038{
4039 /* Allocate the structure if it has not already been allocated by a
4040 subclass. */
4041 if (entry == NULL)
4042 {
4043 entry = bfd_hash_allocate (table, sizeof (struct ppc_stub_hash_entry));
4044 if (entry == NULL)
4045 return entry;
4046 }
4047
4048 /* Call the allocation method of the superclass. */
4049 entry = bfd_hash_newfunc (entry, table, string);
4050 if (entry != NULL)
4051 {
4052 struct ppc_stub_hash_entry *eh;
4053
4054 /* Initialize the local fields. */
4055 eh = (struct ppc_stub_hash_entry *) entry;
ad8e1ba5 4056 eh->stub_type = ppc_stub_none;
721956f4
AM		 4057 eh->stub_sec = NULL;
4058 eh->stub_offset = 0;
4059 eh->target_value = 0;
4060 eh->target_section = NULL;
721956f4 4061 eh->h = NULL;
6911b7dc 4062 eh->plt_ent = NULL;
721956f4 4063 eh->id_sec = NULL;
6911b7dc 4064 eh->other = 0;
721956f4
AM		 4065 }
4066
4067 return entry;
4068}
4069
4070/* Create an entry in the branch hash table. */
4071
4072static struct bfd_hash_entry *
4ce794b7
AM		 4073branch_hash_newfunc (struct bfd_hash_entry *entry,
4074 struct bfd_hash_table *table,
4075 const char *string)
721956f4
AM		 4076{
4077 /* Allocate the structure if it has not already been allocated by a
4078 subclass. */
4079 if (entry == NULL)
4080 {
4081 entry = bfd_hash_allocate (table, sizeof (struct ppc_branch_hash_entry));
4082 if (entry == NULL)
4083 return entry;
4084 }
4085
4086 /* Call the allocation method of the superclass. */
4087 entry = bfd_hash_newfunc (entry, table, string);
4088 if (entry != NULL)
4089 {
4090 struct ppc_branch_hash_entry *eh;
4091
4092 /* Initialize the local fields. */
4093 eh = (struct ppc_branch_hash_entry *) entry;
4094 eh->offset = 0;
4095 eh->iter = 0;
4096 }
4097
4098 return entry;
4099}
4100
65f38f15
AM		 4101/* Create an entry in a ppc64 ELF linker hash table. */
4102
4103static struct bfd_hash_entry *
4ce794b7
AM		 4104link_hash_newfunc (struct bfd_hash_entry *entry,
4105 struct bfd_hash_table *table,
4106 const char *string)
65f38f15
AM		 4107{
4108 /* Allocate the structure if it has not already been allocated by a
4109 subclass. */
4110 if (entry == NULL)
4111 {
4112 entry = bfd_hash_allocate (table, sizeof (struct ppc_link_hash_entry));
4113 if (entry == NULL)
4114 return entry;
4115 }
4116
4117 /* Call the allocation method of the superclass. */
4118 entry = _bfd_elf_link_hash_newfunc (entry, table, string);
4119 if (entry != NULL)
4120 {
4121 struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) entry;
4122
b3fac117 4123 memset (&eh->u.stub_cache, 0,
908b32fc 4124 (sizeof (struct ppc_link_hash_entry)
b3fac117
AM		 4125 - offsetof (struct ppc_link_hash_entry, u.stub_cache)));
4126
4127 /* When making function calls, old ABI code references function entry
4128 points (dot symbols), while new ABI code references the function
4129 descriptor symbol. We need to make any combination of reference and
4130 definition work together, without breaking archive linking.
4131
4132 For a defined function "foo" and an undefined call to "bar":
4133 An old object defines "foo" and ".foo", references ".bar" (possibly
4134 "bar" too).
4135 A new object defines "foo" and references "bar".
4136
4137 A new object thus has no problem with its undefined symbols being
4138 satisfied by definitions in an old object. On the other hand, the
4139 old object won't have ".bar" satisfied by a new object.
4140
4141 Keep a list of newly added dot-symbols. */
4142
4143 if (string[0] == '.')
4144 {
4145 struct ppc_link_hash_table *htab;
4146
4147 htab = (struct ppc_link_hash_table *) table;
4148 eh->u.next_dot_sym = htab->dot_syms;
4149 htab->dot_syms = eh;
4150 }
65f38f15
AM		 4151 }
4152
4153 return entry;
4154}
4155
3b421ab3
AM		 4156struct tocsave_entry {
4157 asection *sec;
4158 bfd_vma offset;
4159};
4160
4161static hashval_t
4162tocsave_htab_hash (const void *p)
4163{
4164 const struct tocsave_entry *e = (const struct tocsave_entry *) p;
4165 return ((bfd_vma)(intptr_t) e->sec ^ e->offset) >> 3;
4166}
4167
4168static int
4169tocsave_htab_eq (const void *p1, const void *p2)
4170{
4171 const struct tocsave_entry *e1 = (const struct tocsave_entry *) p1;
4172 const struct tocsave_entry *e2 = (const struct tocsave_entry *) p2;
4173 return e1->sec == e2->sec && e1->offset == e2->offset;
4174}
4175
68faa637
AM		 4176/* Destroy a ppc64 ELF linker hash table. */
4177
4178static void
d495ab0d 4179ppc64_elf_link_hash_table_free (bfd *obfd)
68faa637 4180{
d495ab0d 4181 struct ppc_link_hash_table *htab;
68faa637 4182
d495ab0d 4183 htab = (struct ppc_link_hash_table *) obfd->link.hash;
68faa637
AM		 4184 if (htab->tocsave_htab)
4185 htab_delete (htab->tocsave_htab);
d495ab0d
AM		 4186 bfd_hash_table_free (&htab->branch_hash_table);
4187 bfd_hash_table_free (&htab->stub_hash_table);
4188 _bfd_elf_link_hash_table_free (obfd);
68faa637
AM		 4189}
4190
65f38f15
AM		 4191/* Create a ppc64 ELF linker hash table. */
4192
4193static struct bfd_link_hash_table *
4ce794b7 4194ppc64_elf_link_hash_table_create (bfd *abfd)
65f38f15
AM		 4195{
4196 struct ppc_link_hash_table *htab;
4197 bfd_size_type amt = sizeof (struct ppc_link_hash_table);
4198
4ce794b7 4199 htab = bfd_zmalloc (amt);
65f38f15
AM		 4200 if (htab == NULL)
4201 return NULL;
4202
66eb6687 4203 if (!_bfd_elf_link_hash_table_init (&htab->elf, abfd, link_hash_newfunc,
4dfe6ac6
NC		 4204 sizeof (struct ppc_link_hash_entry),
4205 PPC64_ELF_DATA))
65f38f15 4206 {
e2d34d7d 4207 free (htab);
65f38f15
AM		 4208 return NULL;
4209 }
4210
721956f4 4211 /* Init the stub hash table too. */
66eb6687
AM		 4212 if (!bfd_hash_table_init (&htab->stub_hash_table, stub_hash_newfunc,
4213 sizeof (struct ppc_stub_hash_entry)))
2915c55b 4214 {
d495ab0d 4215 _bfd_elf_link_hash_table_free (abfd);
2915c55b
JK		 4216 return NULL;
4217 }
721956f4
AM		 4218
4219 /* And the branch hash table. */
66eb6687
AM		 4220 if (!bfd_hash_table_init (&htab->branch_hash_table, branch_hash_newfunc,
4221 sizeof (struct ppc_branch_hash_entry)))
2915c55b
JK		 4222 {
4223 bfd_hash_table_free (&htab->stub_hash_table);
d495ab0d 4224 _bfd_elf_link_hash_table_free (abfd);
2915c55b
JK		 4225 return NULL;
4226 }
721956f4 4227
3b421ab3
AM		 4228 htab->tocsave_htab = htab_try_create (1024,
4229 tocsave_htab_hash,
4230 tocsave_htab_eq,
4231 NULL);
4232 if (htab->tocsave_htab == NULL)
2915c55b 4233 {
d495ab0d 4234 ppc64_elf_link_hash_table_free (abfd);
2915c55b
JK		 4235 return NULL;
4236 }
d495ab0d 4237 htab->elf.root.hash_table_free = ppc64_elf_link_hash_table_free;
3b421ab3 4238
3254fd24
AM		 4239 /* Initializing two fields of the union is just cosmetic. We really
4240 only care about glist, but when compiled on a 32-bit host the
4241 bfd_vma fields are larger. Setting the bfd_vma to zero makes
4242 debugger inspection of these fields look nicer. */
a6aa5195
AM		 4243 htab->elf.init_got_refcount.refcount = 0;
4244 htab->elf.init_got_refcount.glist = NULL;
4245 htab->elf.init_plt_refcount.refcount = 0;
4246 htab->elf.init_plt_refcount.glist = NULL;
4247 htab->elf.init_got_offset.offset = 0;
4248 htab->elf.init_got_offset.glist = NULL;
4249 htab->elf.init_plt_offset.offset = 0;
4250 htab->elf.init_plt_offset.glist = NULL;
3254fd24 4251
65f38f15
AM		 4252 return &htab->elf.root;
4253}
4254
bfeb4a28
AM		 4255/* Create sections for linker generated code. */
4256
4257static bfd_boolean
4258create_linkage_sections (bfd *dynobj, struct bfd_link_info *info)
4259{
4260 struct ppc_link_hash_table *htab;
4261 flagword flags;
4262
4263 htab = ppc_hash_table (info);
4264
4265 /* Create .sfpr for code to save and restore fp regs. */
4266 flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY
4267 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4268 htab->sfpr = bfd_make_section_anyway_with_flags (dynobj, ".sfpr",
4269 flags);
4270 if (htab->sfpr == NULL
4271 || ! bfd_set_section_alignment (dynobj, htab->sfpr, 2))
4272 return FALSE;
4273
4274 /* Create .glink for lazy dynamic linking support. */
4275 htab->glink = bfd_make_section_anyway_with_flags (dynobj, ".glink",
4276 flags);
4277 if (htab->glink == NULL
4278 || ! bfd_set_section_alignment (dynobj, htab->glink, 3))
4279 return FALSE;
4280
4281 if (!info->no_ld_generated_unwind_info)
4282 {
4283 flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_HAS_CONTENTS
4284 | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4285 htab->glink_eh_frame = bfd_make_section_anyway_with_flags (dynobj,
4286 ".eh_frame",
4287 flags);
4288 if (htab->glink_eh_frame == NULL
4289 || !bfd_set_section_alignment (dynobj, htab->glink_eh_frame, 2))
4290 return FALSE;
4291 }
4292
4293 flags = SEC_ALLOC | SEC_LINKER_CREATED;
33e44f2e
AM		 4294 htab->elf.iplt = bfd_make_section_anyway_with_flags (dynobj, ".iplt", flags);
4295 if (htab->elf.iplt == NULL
4296 || ! bfd_set_section_alignment (dynobj, htab->elf.iplt, 3))
bfeb4a28
AM		 4297 return FALSE;
4298
4299 flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4300 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
33e44f2e
AM		 4301 htab->elf.irelplt
4302 = bfd_make_section_anyway_with_flags (dynobj, ".rela.iplt", flags);
4303 if (htab->elf.irelplt == NULL
4304 || ! bfd_set_section_alignment (dynobj, htab->elf.irelplt, 3))
bfeb4a28
AM		 4305 return FALSE;
4306
4307 /* Create branch lookup table for plt_branch stubs. */
4308 flags = (SEC_ALLOC | SEC_LOAD
4309 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4310 htab->brlt = bfd_make_section_anyway_with_flags (dynobj, ".branch_lt",
4311 flags);
4312 if (htab->brlt == NULL
4313 || ! bfd_set_section_alignment (dynobj, htab->brlt, 3))
4314 return FALSE;
4315
4316 if (!info->shared)
4317 return TRUE;
4318
4319 flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4320 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4321 htab->relbrlt = bfd_make_section_anyway_with_flags (dynobj,
4322 ".rela.branch_lt",
4323 flags);
4324 if (htab->relbrlt == NULL
4325 || ! bfd_set_section_alignment (dynobj, htab->relbrlt, 3))
4326 return FALSE;
4327
4328 return TRUE;
4329}
4330
e717da7e
AM		 4331/* Satisfy the ELF linker by filling in some fields in our fake bfd. */
4332
bfeb4a28 4333bfd_boolean
e7d1c40c
AM		 4334ppc64_elf_init_stub_bfd (struct bfd_link_info *info,
4335 struct ppc64_elf_params *params)
e717da7e
AM		 4336{
4337 struct ppc_link_hash_table *htab;
4338
e7d1c40c 4339 elf_elfheader (params->stub_bfd)->e_ident[EI_CLASS] = ELFCLASS64;
e717da7e
AM		 4340
4341/* Always hook our dynamic sections into the first bfd, which is the
4342 linker created stub bfd. This ensures that the GOT header is at
4343 the start of the output TOC section. */
4344 htab = ppc_hash_table (info);
4dfe6ac6 4345 if (htab == NULL)
bfeb4a28 4346 return FALSE;
e7d1c40c
AM		 4347 htab->elf.dynobj = params->stub_bfd;
4348 htab->params = params;
bfeb4a28
AM		 4349
4350 if (info->relocatable)
4351 return TRUE;
4352
4353 return create_linkage_sections (htab->elf.dynobj, info);
e717da7e
AM		 4354}
4355
721956f4
AM		 4356/* Build a name for an entry in the stub hash table. */
4357
4358static char *
4ce794b7
AM		 4359ppc_stub_name (const asection *input_section,
4360 const asection *sym_sec,
4361 const struct ppc_link_hash_entry *h,
4362 const Elf_Internal_Rela *rel)
721956f4
AM		 4363{
4364 char *stub_name;
bcaa2f82 4365 ssize_t len;
721956f4
AM		 4366
4367 /* rel->r_addend is actually 64 bit, but who uses more than +/- 2^31
4368 offsets from a sym as a branch target? In fact, we could
4369 probably assume the addend is always zero. */
4370 BFD_ASSERT (((int) rel->r_addend & 0xffffffff) == rel->r_addend);
4371
4372 if (h)
4373 {
4374 len = 8 + 1 + strlen (h->elf.root.root.string) + 1 + 8 + 1;
4375 stub_name = bfd_malloc (len);
46de2a7c
AM		 4376 if (stub_name == NULL)
4377 return stub_name;
4378
bcaa2f82
AM		 4379 len = sprintf (stub_name, "%08x.%s+%x",
4380 input_section->id & 0xffffffff,
4381 h->elf.root.root.string,
4382 (int) rel->r_addend & 0xffffffff);
721956f4
AM		 4383 }
4384 else
4385 {
ad8e1ba5 4386 len = 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1;
721956f4 4387 stub_name = bfd_malloc (len);
46de2a7c
AM		 4388 if (stub_name == NULL)
4389 return stub_name;
4390
bcaa2f82
AM		 4391 len = sprintf (stub_name, "%08x.%x:%x+%x",
4392 input_section->id & 0xffffffff,
4393 sym_sec->id & 0xffffffff,
4394 (int) ELF64_R_SYM (rel->r_info) & 0xffffffff,
4395 (int) rel->r_addend & 0xffffffff);
721956f4 4396 }
bcaa2f82 4397 if (len > 2 && stub_name[len - 2] == '+' && stub_name[len - 1] == '0')
ee75fd95 4398 stub_name[len - 2] = 0;
721956f4
AM		 4399 return stub_name;
4400}
4401
4402/* Look up an entry in the stub hash. Stub entries are cached because
4403 creating the stub name takes a bit of time. */
4404
4405static struct ppc_stub_hash_entry *
4ce794b7
AM		 4406ppc_get_stub_entry (const asection *input_section,
4407 const asection *sym_sec,
039b3fef 4408 struct ppc_link_hash_entry *h,
4ce794b7
AM		 4409 const Elf_Internal_Rela *rel,
4410 struct ppc_link_hash_table *htab)
721956f4
AM		 4411{
4412 struct ppc_stub_hash_entry *stub_entry;
721956f4
AM		 4413 const asection *id_sec;
4414
4415 /* If this input section is part of a group of sections sharing one
4416 stub section, then use the id of the first section in the group.
4417 Stub names need to include a section id, as there may well be
4418 more than one stub used to reach say, printf, and we need to
4419 distinguish between them. */
4420 id_sec = htab->stub_group[input_section->id].link_sec;
4421
b3fac117
AM		 4422 if (h != NULL && h->u.stub_cache != NULL
4423 && h->u.stub_cache->h == h
4424 && h->u.stub_cache->id_sec == id_sec)
721956f4 4425 {
b3fac117 4426 stub_entry = h->u.stub_cache;
721956f4
AM		 4427 }
4428 else
4429 {
4430 char *stub_name;
4431
4432 stub_name = ppc_stub_name (id_sec, sym_sec, h, rel);
4433 if (stub_name == NULL)
4434 return NULL;
4435
4436 stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
b34976b6 4437 stub_name, FALSE, FALSE);
721956f4 4438 if (h != NULL)
b3fac117 4439 h->u.stub_cache = stub_entry;
721956f4
AM		 4440
4441 free (stub_name);
4442 }
4443
4444 return stub_entry;
4445}
4446
4447/* Add a new stub entry to the stub hash. Not all fields of the new
4448 stub entry are initialised. */
4449
4450static struct ppc_stub_hash_entry *
4ce794b7
AM		 4451ppc_add_stub (const char *stub_name,
4452 asection *section,
25f53a85 4453 struct bfd_link_info *info)
721956f4 4454{
25f53a85 4455 struct ppc_link_hash_table *htab = ppc_hash_table (info);
721956f4
AM		 4456 asection *link_sec;
4457 asection *stub_sec;
4458 struct ppc_stub_hash_entry *stub_entry;
4459
4460 link_sec = htab->stub_group[section->id].link_sec;
4461 stub_sec = htab->stub_group[section->id].stub_sec;
4462 if (stub_sec == NULL)
4463 {
4464 stub_sec = htab->stub_group[link_sec->id].stub_sec;
4465 if (stub_sec == NULL)
4466 {
d4c88bbb 4467 size_t namelen;
721956f4
AM		 4468 bfd_size_type len;
4469 char *s_name;
4470
d4c88bbb
AM		 4471 namelen = strlen (link_sec->name);
4472 len = namelen + sizeof (STUB_SUFFIX);
e7d1c40c 4473 s_name = bfd_alloc (htab->params->stub_bfd, len);
721956f4
AM		 4474 if (s_name == NULL)
4475 return NULL;
4476
d4c88bbb
AM		 4477 memcpy (s_name, link_sec->name, namelen);
4478 memcpy (s_name + namelen, STUB_SUFFIX, sizeof (STUB_SUFFIX));
e7d1c40c 4479 stub_sec = (*htab->params->add_stub_section) (s_name, link_sec);
721956f4
AM		 4480 if (stub_sec == NULL)
4481 return NULL;
4482 htab->stub_group[link_sec->id].stub_sec = stub_sec;
4483 }
4484 htab->stub_group[section->id].stub_sec = stub_sec;
4485 }
4486
4487 /* Enter this entry into the linker stub hash table. */
4488 stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table, stub_name,
b34976b6 4489 TRUE, FALSE);
721956f4
AM		 4490 if (stub_entry == NULL)
4491 {
8de848d8 4492 info->callbacks->einfo (_("%P: %B: cannot create stub entry %s\n"),
25f53a85 4493 section->owner, stub_name);
721956f4
AM		 4494 return NULL;
4495 }
4496
4497 stub_entry->stub_sec = stub_sec;
4498 stub_entry->stub_offset = 0;
4499 stub_entry->id_sec = link_sec;
4500 return stub_entry;
4501}
4502
e717da7e
AM		 4503/* Create .got and .rela.got sections in ABFD, and .got in dynobj if
4504 not already done. */
65f38f15 4505
b34976b6 4506static bfd_boolean
e717da7e 4507create_got_section (bfd *abfd, struct bfd_link_info *info)
65f38f15 4508{
e717da7e
AM		 4509 asection *got, *relgot;
4510 flagword flags;
4511 struct ppc_link_hash_table *htab = ppc_hash_table (info);
65f38f15 4512
0c8d6e5c 4513 if (!is_ppc64_elf (abfd))
0ffa91dd 4514 return FALSE;
4dfe6ac6
NC		 4515 if (htab == NULL)
4516 return FALSE;
0ffa91dd 4517
33e44f2e
AM		 4518 if (!htab->elf.sgot
4519 && !_bfd_elf_create_got_section (htab->elf.dynobj, info))
4520 return FALSE;
e717da7e
AM		 4521
4522 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
4523 | SEC_LINKER_CREATED);
4524
c456f082 4525 got = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
e717da7e 4526 if (!got
e717da7e
AM		 4527 || !bfd_set_section_alignment (abfd, got, 3))
4528 return FALSE;
65f38f15 4529
c456f082
AM		 4530 relgot = bfd_make_section_anyway_with_flags (abfd, ".rela.got",
4531 flags | SEC_READONLY);
e717da7e 4532 if (!relgot
e717da7e 4533 || ! bfd_set_section_alignment (abfd, relgot, 3))
b34976b6 4534 return FALSE;
e717da7e
AM		 4535
4536 ppc64_elf_tdata (abfd)->got = got;
4537 ppc64_elf_tdata (abfd)->relgot = relgot;
b34976b6 4538 return TRUE;
65f38f15 4539}
5bd4f169 4540
82bd7b59 4541/* Create the dynamic sections, and set up shortcuts. */
5bd4f169 4542
b34976b6 4543static bfd_boolean
4ce794b7 4544ppc64_elf_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
5bd4f169 4545{
65f38f15 4546 struct ppc_link_hash_table *htab;
5bd4f169 4547
65f38f15 4548 if (!_bfd_elf_create_dynamic_sections (dynobj, info))
b34976b6 4549 return FALSE;
65f38f15 4550
e717da7e 4551 htab = ppc_hash_table (info);
4dfe6ac6
NC		 4552 if (htab == NULL)
4553 return FALSE;
4554
3d4d4302 4555 htab->dynbss = bfd_get_linker_section (dynobj, ".dynbss");
65f38f15 4556 if (!info->shared)
3d4d4302 4557 htab->relbss = bfd_get_linker_section (dynobj, ".rela.bss");
65f38f15 4558
33e44f2e 4559 if (!htab->elf.sgot || !htab->elf.splt || !htab->elf.srelplt || !htab->dynbss
4ce794b7 4560 || (!info->shared && !htab->relbss))
65f38f15
AM		 4561 abort ();
4562
b34976b6 4563 return TRUE;
5bd4f169
AM		 4564}
4565
b31867b6
AM		 4566/* Follow indirect and warning symbol links. */
4567
4568static inline struct bfd_link_hash_entry *
4569follow_link (struct bfd_link_hash_entry *h)
4570{
4571 while (h->type == bfd_link_hash_indirect
4572 || h->type == bfd_link_hash_warning)
4573 h = h->u.i.link;
4574 return h;
4575}
4576
4577static inline struct elf_link_hash_entry *
4578elf_follow_link (struct elf_link_hash_entry *h)
4579{
4580 return (struct elf_link_hash_entry *) follow_link (&h->root);
4581}
4582
4583static inline struct ppc_link_hash_entry *
4584ppc_follow_link (struct ppc_link_hash_entry *h)
4585{
4586 return (struct ppc_link_hash_entry *) follow_link (&h->elf.root);
4587}
4588
40d16e0b
AM		 4589/* Merge PLT info on FROM with that on TO. */
4590
4591static void
4592move_plt_plist (struct ppc_link_hash_entry *from,
4593 struct ppc_link_hash_entry *to)
4594{
4595 if (from->elf.plt.plist != NULL)
4596 {
4597 if (to->elf.plt.plist != NULL)
4598 {
4599 struct plt_entry **entp;
4600 struct plt_entry *ent;
4601
4602 for (entp = &from->elf.plt.plist; (ent = *entp) != NULL; )
4603 {
4604 struct plt_entry *dent;
4605
4606 for (dent = to->elf.plt.plist; dent != NULL; dent = dent->next)
4607 if (dent->addend == ent->addend)
4608 {
4609 dent->plt.refcount += ent->plt.refcount;
4610 *entp = ent->next;
4611 break;
4612 }
4613 if (dent == NULL)
4614 entp = &ent->next;
4615 }
4616 *entp = to->elf.plt.plist;
4617 }
4618
4619 to->elf.plt.plist = from->elf.plt.plist;
4620 from->elf.plt.plist = NULL;
4621 }
4622}
4623
65f38f15
AM		 4624/* Copy the extra info we tack onto an elf_link_hash_entry. */
4625
4626static void
fcfa13d2
AM		 4627ppc64_elf_copy_indirect_symbol (struct bfd_link_info *info,
4628 struct elf_link_hash_entry *dir,
4629 struct elf_link_hash_entry *ind)
65f38f15
AM		 4630{
4631 struct ppc_link_hash_entry *edir, *eind;
4632
4633 edir = (struct ppc_link_hash_entry *) dir;
4634 eind = (struct ppc_link_hash_entry *) ind;
4635
c79d6685
AM		 4636 edir->is_func |= eind->is_func;
4637 edir->is_func_descriptor |= eind->is_func_descriptor;
4638 edir->tls_mask |= eind->tls_mask;
4639 if (eind->oh != NULL)
4640 edir->oh = ppc_follow_link (eind->oh);
4641
4642 /* If called to transfer flags for a weakdef during processing
4643 of elf_adjust_dynamic_symbol, don't copy NON_GOT_REF.
4644 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
4645 if (!(ELIMINATE_COPY_RELOCS
4646 && eind->elf.root.type != bfd_link_hash_indirect
4647 && edir->elf.dynamic_adjusted))
4648 edir->elf.non_got_ref |= eind->elf.non_got_ref;
4649
4650 edir->elf.ref_dynamic |= eind->elf.ref_dynamic;
4651 edir->elf.ref_regular |= eind->elf.ref_regular;
4652 edir->elf.ref_regular_nonweak |= eind->elf.ref_regular_nonweak;
4653 edir->elf.needs_plt |= eind->elf.needs_plt;
a345bc8d 4654 edir->elf.pointer_equality_needed |= eind->elf.pointer_equality_needed;
c79d6685 4655
411e1bfb 4656 /* Copy over any dynamic relocs we may have on the indirect sym. */
bbd7ec4a 4657 if (eind->dyn_relocs != NULL)
65f38f15 4658 {
bbd7ec4a
AM		 4659 if (edir->dyn_relocs != NULL)
4660 {
6061a67d
AM		 4661 struct elf_dyn_relocs **pp;
4662 struct elf_dyn_relocs *p;
bbd7ec4a 4663
fcfa13d2 4664 /* Add reloc counts against the indirect sym to the direct sym
bbd7ec4a
AM		 4665 list. Merge any entries against the same section. */
4666 for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
4667 {
6061a67d 4668 struct elf_dyn_relocs *q;
bbd7ec4a
AM		 4669
4670 for (q = edir->dyn_relocs; q != NULL; q = q->next)
4671 if (q->sec == p->sec)
4672 {
4673 q->pc_count += p->pc_count;
4674 q->count += p->count;
4675 *pp = p->next;
4676 break;
4677 }
4678 if (q == NULL)
4679 pp = &p->next;
4680 }
4681 *pp = edir->dyn_relocs;
4682 }
4683
65f38f15
AM		 4684 edir->dyn_relocs = eind->dyn_relocs;
4685 eind->dyn_relocs = NULL;
4686 }
65f38f15 4687
68ba6d40
AM		 4688 /* If we were called to copy over info for a weak sym, that's all.
4689 You might think dyn_relocs need not be copied over; After all,
4690 both syms will be dynamic or both non-dynamic so we're just
68ffbac6 4691 moving reloc accounting around. However, ELIMINATE_COPY_RELOCS
68ba6d40
AM		 4692 code in ppc64_elf_adjust_dynamic_symbol needs to check for
4693 dyn_relocs in read-only sections, and it does so on what is the
4694 DIR sym here. */
4695 if (eind->elf.root.type != bfd_link_hash_indirect)
4696 return;
4697
81848ca0
AM		 4698 /* Copy over got entries that we may have already seen to the
4699 symbol which just became indirect. */
411e1bfb
AM		 4700 if (eind->elf.got.glist != NULL)
4701 {
4702 if (edir->elf.got.glist != NULL)
4703 {
4704 struct got_entry **entp;
4705 struct got_entry *ent;
4706
4707 for (entp = &eind->elf.got.glist; (ent = *entp) != NULL; )
4708 {
4709 struct got_entry *dent;
4710
4711 for (dent = edir->elf.got.glist; dent != NULL; dent = dent->next)
4712 if (dent->addend == ent->addend
e717da7e 4713 && dent->owner == ent->owner
411e1bfb
AM		 4714 && dent->tls_type == ent->tls_type)
4715 {
4716 dent->got.refcount += ent->got.refcount;
4717 *entp = ent->next;
4718 break;
4719 }
4720 if (dent == NULL)
4721 entp = &ent->next;
4722 }
4723 *entp = edir->elf.got.glist;
4724 }
4725
4726 edir->elf.got.glist = eind->elf.got.glist;
4727 eind->elf.got.glist = NULL;
4728 }
4729
4730 /* And plt entries. */
40d16e0b 4731 move_plt_plist (eind, edir);
411e1bfb 4732
fcfa13d2 4733 if (eind->elf.dynindx != -1)
411e1bfb 4734 {
fcfa13d2
AM		 4735 if (edir->elf.dynindx != -1)
4736 _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
4737 edir->elf.dynstr_index);
411e1bfb
AM		 4738 edir->elf.dynindx = eind->elf.dynindx;
4739 edir->elf.dynstr_index = eind->elf.dynstr_index;
4740 eind->elf.dynindx = -1;
4741 eind->elf.dynstr_index = 0;
4742 }
411e1bfb
AM		 4743}
4744
8387904d
AM		 4745/* Find the function descriptor hash entry from the given function code
4746 hash entry FH. Link the entries via their OH fields. */
4747
4748static struct ppc_link_hash_entry *
b31867b6 4749lookup_fdh (struct ppc_link_hash_entry *fh, struct ppc_link_hash_table *htab)
8387904d
AM		 4750{
4751 struct ppc_link_hash_entry *fdh = fh->oh;
4752
4753 if (fdh == NULL)
4754 {
4755 const char *fd_name = fh->elf.root.root.string + 1;
4756
4757 fdh = (struct ppc_link_hash_entry *)
4758 elf_link_hash_lookup (&htab->elf, fd_name, FALSE, FALSE, FALSE);
b31867b6
AM		 4759 if (fdh == NULL)
4760 return fdh;
4761
4762 fdh->is_func_descriptor = 1;
4763 fdh->oh = fh;
4764 fh->is_func = 1;
4765 fh->oh = fdh;
8387904d
AM		 4766 }
4767
b31867b6 4768 return ppc_follow_link (fdh);
8387904d
AM		 4769}
4770
bb700d78
AM		 4771/* Make a fake function descriptor sym for the code sym FH. */
4772
4773static struct ppc_link_hash_entry *
4774make_fdh (struct bfd_link_info *info,
908b32fc 4775 struct ppc_link_hash_entry *fh)
bb700d78
AM		 4776{
4777 bfd *abfd;
4778 asymbol *newsym;
4779 struct bfd_link_hash_entry *bh;
4780 struct ppc_link_hash_entry *fdh;
4781
4782 abfd = fh->elf.root.u.undef.abfd;
4783 newsym = bfd_make_empty_symbol (abfd);
4784 newsym->name = fh->elf.root.root.string + 1;
4785 newsym->section = bfd_und_section_ptr;
4786 newsym->value = 0;
908b32fc 4787 newsym->flags = BSF_WEAK;
bb700d78
AM		 4788
4789 bh = NULL;
4790 if (!_bfd_generic_link_add_one_symbol (info, abfd, newsym->name,
4791 newsym->flags, newsym->section,
4792 newsym->value, NULL, FALSE, FALSE,
4793 &bh))
4794 return NULL;
4795
4796 fdh = (struct ppc_link_hash_entry *) bh;
4797 fdh->elf.non_elf = 0;
908b32fc
AM		 4798 fdh->fake = 1;
4799 fdh->is_func_descriptor = 1;
4800 fdh->oh = fh;
4801 fh->is_func = 1;
4802 fh->oh = fdh;
bb700d78
AM		 4803 return fdh;
4804}
4805
8387904d
AM		 4806/* Fix function descriptor symbols defined in .opd sections to be
4807 function type. */
555cd476
AM		 4808
4809static bfd_boolean
c16153ae 4810ppc64_elf_add_symbol_hook (bfd *ibfd,
e054468f 4811 struct bfd_link_info *info,
555cd476 4812 Elf_Internal_Sym *isym,
6911b7dc 4813 const char **name,
555cd476
AM		 4814 flagword *flags ATTRIBUTE_UNUSED,
4815 asection **sec,
b53dfeb2 4816 bfd_vma *value)
555cd476 4817{
f1885d1e
AM		 4818 if ((ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC
4819 || ELF_ST_BIND (isym->st_info) == STB_GNU_UNIQUE)
4820 && (ibfd->flags & DYNAMIC) == 0
4821 && bfd_get_flavour (info->output_bfd) == bfd_target_elf_flavour)
f64b2e8d
NC		 4822 elf_tdata (info->output_bfd)->has_gnu_symbols = TRUE;
4823
b53dfeb2 4824 if (*sec != NULL
f1885d1e 4825 && strcmp ((*sec)->name, ".opd") == 0)
b53dfeb2
AM		 4826 {
4827 asection *code_sec;
4828
4829 if (!(ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC
4830 || ELF_ST_TYPE (isym->st_info) == STT_FUNC))
4831 isym->st_info = ELF_ST_INFO (ELF_ST_BIND (isym->st_info), STT_FUNC);
4832
4833 /* If the symbol is a function defined in .opd, and the function
4834 code is in a discarded group, let it appear to be undefined. */
4835 if (!info->relocatable
4836 && (*sec)->reloc_count != 0
4837 && opd_entry_value (*sec, *value, &code_sec, NULL,
4838 FALSE) != (bfd_vma) -1
4839 && discarded_section (code_sec))
4840 {
4841 *sec = bfd_und_section_ptr;
4842 isym->st_shndx = SHN_UNDEF;
4843 }
4844 }
dbd1e97e
AM		 4845 else if (*sec != NULL
4846 && strcmp ((*sec)->name, ".toc") == 0
4847 && ELF_ST_TYPE (isym->st_info) == STT_OBJECT)
4848 {
4849 struct ppc_link_hash_table *htab = ppc_hash_table (info);
4850 if (htab != NULL)
4851 htab->params->object_in_toc = 1;
4852 }
433817dd 4853
6911b7dc
AM		 4854 if ((STO_PPC64_LOCAL_MASK & isym->st_other) != 0)
4855 {
4856 if (abiversion (ibfd) == 0)
4857 set_abiversion (ibfd, 2);
4858 else if (abiversion (ibfd) == 1)
4859 {
4860 info->callbacks->einfo (_("%P: symbol '%s' has invalid st_other"
4861 " for ABI version 1\n"), name);
4862 bfd_set_error (bfd_error_bad_value);
4863 return FALSE;
4864 }
4865 }
4866
555cd476
AM		 4867 return TRUE;
4868}
4869
6911b7dc
AM		 4870/* Merge non-visibility st_other attributes: local entry point. */
4871
4872static void
4873ppc64_elf_merge_symbol_attribute (struct elf_link_hash_entry *h,
4874 const Elf_Internal_Sym *isym,
4875 bfd_boolean definition,
4876 bfd_boolean dynamic)
4877{
4878 if (definition && !dynamic)
4879 h->other = ((isym->st_other & ~ELF_ST_VISIBILITY (-1))
4880 | ELF_ST_VISIBILITY (h->other));
4881}
4882
8387904d 4883/* This function makes an old ABI object reference to ".bar" cause the
908b32fc
AM		 4884 inclusion of a new ABI object archive that defines "bar".
4885 NAME is a symbol defined in an archive. Return a symbol in the hash
4886 table that might be satisfied by the archive symbols. */
8387904d
AM		 4887
4888static struct elf_link_hash_entry *
4889ppc64_elf_archive_symbol_lookup (bfd *abfd,
4890 struct bfd_link_info *info,
4891 const char *name)
4892{
4893 struct elf_link_hash_entry *h;
4894 char *dot_name;
4895 size_t len;
4896
4897 h = _bfd_elf_archive_symbol_lookup (abfd, info, name);
908b32fc
AM		 4898 if (h != NULL
4899 /* Don't return this sym if it is a fake function descriptor
4900 created by add_symbol_adjust. */
4901 && !(h->root.type == bfd_link_hash_undefweak
4902 && ((struct ppc_link_hash_entry *) h)->fake))
8387904d
AM		 4903 return h;
4904
4905 if (name[0] == '.')
4906 return h;
4907
4908 len = strlen (name);
4909 dot_name = bfd_alloc (abfd, len + 2);
4910 if (dot_name == NULL)
4911 return (struct elf_link_hash_entry *) 0 - 1;
4912 dot_name[0] = '.';
4913 memcpy (dot_name + 1, name, len + 1);
4914 h = _bfd_elf_archive_symbol_lookup (abfd, info, dot_name);
4915 bfd_release (abfd, dot_name);
4916 return h;
4917}
4918
4919/* This function satisfies all old ABI object references to ".bar" if a
99877b66
AM		 4920 new ABI object defines "bar". Well, at least, undefined dot symbols
4921 are made weak. This stops later archive searches from including an
4922 object if we already have a function descriptor definition. It also
35b0ce59
AM		 4923 prevents the linker complaining about undefined symbols.
4924 We also check and correct mismatched symbol visibility here. The
4925 most restrictive visibility of the function descriptor and the
4926 function entry symbol is used. */
8387904d
AM		 4927
4928static bfd_boolean
b3fac117 4929add_symbol_adjust (struct ppc_link_hash_entry *eh, struct bfd_link_info *info)
8387904d 4930{
8387904d
AM		 4931 struct ppc_link_hash_table *htab;
4932 struct ppc_link_hash_entry *fdh;
4933
b3fac117 4934 if (eh->elf.root.type == bfd_link_hash_indirect)
8387904d
AM		 4935 return TRUE;
4936
b3fac117
AM		 4937 if (eh->elf.root.type == bfd_link_hash_warning)
4938 eh = (struct ppc_link_hash_entry *) eh->elf.root.u.i.link;
8387904d 4939
b3fac117
AM		 4940 if (eh->elf.root.root.string[0] != '.')
4941 abort ();
8387904d 4942
b3fac117 4943 htab = ppc_hash_table (info);
4dfe6ac6
NC		 4944 if (htab == NULL)
4945 return FALSE;
4946
b31867b6
AM		 4947 fdh = lookup_fdh (eh, htab);
4948 if (fdh == NULL)
4949 {
4950 if (!info->relocatable
4951 && (eh->elf.root.type == bfd_link_hash_undefined
4952 || eh->elf.root.type == bfd_link_hash_undefweak)
4953 && eh->elf.ref_regular)
4954 {
4955 /* Make an undefweak function descriptor sym, which is enough to
4956 pull in an --as-needed shared lib, but won't cause link
4957 errors. Archives are handled elsewhere. */
4958 fdh = make_fdh (info, eh);
4959 if (fdh == NULL)
4960 return FALSE;
4961 fdh->elf.ref_regular = 1;
4962 }
bb700d78 4963 }
b31867b6 4964 else
8387904d 4965 {
35b0ce59
AM		 4966 unsigned entry_vis = ELF_ST_VISIBILITY (eh->elf.other) - 1;
4967 unsigned descr_vis = ELF_ST_VISIBILITY (fdh->elf.other) - 1;
4968 if (entry_vis < descr_vis)
4969 fdh->elf.other += entry_vis - descr_vis;
4970 else if (entry_vis > descr_vis)
4971 eh->elf.other += descr_vis - entry_vis;
4972
e87d886e
AM		 4973 if ((fdh->elf.root.type == bfd_link_hash_defined
4974 || fdh->elf.root.type == bfd_link_hash_defweak)
4975 && eh->elf.root.type == bfd_link_hash_undefined)
35b0ce59
AM		 4976 {
4977 eh->elf.root.type = bfd_link_hash_undefweak;
4978 eh->was_undefined = 1;
4979 htab->twiddled_syms = 1;
4980 }
8387904d 4981 }
99877b66 4982
8387904d
AM		 4983 return TRUE;
4984}
4985
f6c7c3e8
AM		 4986/* Set up opd section info and abiversion for IBFD, and process list
4987 of dot-symbols we made in link_hash_newfunc. */
b3fac117 4988
8387904d 4989static bfd_boolean
f6c7c3e8 4990ppc64_elf_before_check_relocs (bfd *ibfd, struct bfd_link_info *info)
8387904d 4991{
99877b66 4992 struct ppc_link_hash_table *htab;
b3fac117 4993 struct ppc_link_hash_entry **p, *eh;
459609d6 4994 asection *opd = bfd_get_section_by_name (ibfd, ".opd");
433817dd 4995
459609d6 4996 if (opd != NULL && opd->size != 0)
b3fac117 4997 {
459609d6
AM		 4998 if (abiversion (ibfd) == 0)
4999 set_abiversion (ibfd, 1);
5000 else if (abiversion (ibfd) == 2)
f6c7c3e8 5001 {
459609d6
AM		 5002 info->callbacks->einfo (_("%P: %B .opd not allowed in ABI"
5003 " version %d\n"),
5004 ibfd, abiversion (ibfd));
5005 bfd_set_error (bfd_error_bad_value);
5006 return FALSE;
f6c7c3e8
AM		 5007 }
5008
459609d6
AM		 5009 if ((ibfd->flags & DYNAMIC) == 0
5010 && (opd->flags & SEC_RELOC) != 0
5011 && opd->reloc_count != 0
5012 && !bfd_is_abs_section (opd->output_section))
b3fac117 5013 {
459609d6
AM		 5014 /* Garbage collection needs some extra help with .opd sections.
5015 We don't want to necessarily keep everything referenced by
5016 relocs in .opd, as that would keep all functions. Instead,
5017 if we reference an .opd symbol (a function descriptor), we
5018 want to keep the function code symbol's section. This is
5019 easy for global symbols, but for local syms we need to keep
5020 information about the associated function section. */
5021 bfd_size_type amt;
5022 asection **opd_sym_map;
5023
51aecdc5 5024 amt = OPD_NDX (opd->size) * sizeof (*opd_sym_map);
459609d6
AM		 5025 opd_sym_map = bfd_zalloc (ibfd, amt);
5026 if (opd_sym_map == NULL)
b3fac117 5027 return FALSE;
459609d6
AM		 5028 ppc64_elf_section_data (opd)->u.opd.func_sec = opd_sym_map;
5029 BFD_ASSERT (ppc64_elf_section_data (opd)->sec_type == sec_normal);
5030 ppc64_elf_section_data (opd)->sec_type = sec_opd;
b3fac117
AM		 5031 }
5032 }
5033
459609d6
AM		 5034 if (!is_ppc64_elf (info->output_bfd))
5035 return TRUE;
5036 htab = ppc_hash_table (info);
5037 if (htab == NULL)
5038 return FALSE;
5039
5040 /* For input files without an explicit abiversion in e_flags
5041 we should have flagged any with symbol st_other bits set
5042 as ELFv1 and above flagged those with .opd as ELFv2.
5043 Set the output abiversion if not yet set, and for any input
5044 still ambiguous, take its abiversion from the output.
5045 Differences in ABI are reported later. */
5046 if (abiversion (info->output_bfd) == 0)
5047 set_abiversion (info->output_bfd, abiversion (ibfd));
5048 else if (abiversion (ibfd) == 0)
5049 set_abiversion (ibfd, abiversion (info->output_bfd));
5050
5051 p = &htab->dot_syms;
5052 while ((eh = *p) != NULL)
5053 {
5054 *p = NULL;
5055 if (&eh->elf == htab->elf.hgot)
5056 ;
5057 else if (htab->elf.hgot == NULL
5058 && strcmp (eh->elf.root.root.string, ".TOC.") == 0)
5059 htab->elf.hgot = &eh->elf;
5060 else if (!add_symbol_adjust (eh, info))
5061 return FALSE;
5062 p = &eh->u.next_dot_sym;
5063 }
5064
b3fac117
AM		 5065 /* Clear the list for non-ppc64 input files. */
5066 p = &htab->dot_syms;
5067 while ((eh = *p) != NULL)
5068 {
5069 *p = NULL;
5070 p = &eh->u.next_dot_sym;
5071 }
99877b66
AM		 5072
5073 /* We need to fix the undefs list for any syms we have twiddled to
5074 undef_weak. */
5075 if (htab->twiddled_syms)
5076 {
77cfaee6 5077 bfd_link_repair_undef_list (&htab->elf.root);
99877b66
AM		 5078 htab->twiddled_syms = 0;
5079 }
b3fac117 5080 return TRUE;
8387904d
AM		 5081}
5082
97fed1c9
JJ		 5083/* Undo hash table changes when an --as-needed input file is determined
5084 not to be needed. */
5085
5086static bfd_boolean
e5034e59
AM		 5087ppc64_elf_notice_as_needed (bfd *ibfd,
5088 struct bfd_link_info *info,
5089 enum notice_asneeded_action act)
97fed1c9 5090{
e5034e59
AM		 5091 if (act == notice_not_needed)
5092 {
5093 struct ppc_link_hash_table *htab = ppc_hash_table (info);
4dfe6ac6 5094
e5034e59
AM		 5095 if (htab == NULL)
5096 return FALSE;
4dfe6ac6 5097
e5034e59
AM		 5098 htab->dot_syms = NULL;
5099 }
5100 return _bfd_elf_notice_as_needed (ibfd, info, act);
97fed1c9
JJ		 5101}
5102
aa374f67
AM		 5103/* If --just-symbols against a final linked binary, then assume we need
5104 toc adjusting stubs when calling functions defined there. */
5105
5106static void
5107ppc64_elf_link_just_syms (asection *sec, struct bfd_link_info *info)
5108{
5109 if ((sec->flags & SEC_CODE) != 0
5110 && (sec->owner->flags & (EXEC_P | DYNAMIC)) != 0
5111 && is_ppc64_elf (sec->owner))
5112 {
2c3f079f
AM		 5113 if (abiversion (sec->owner) >= 2
5114 || bfd_get_section_by_name (sec->owner, ".opd") != NULL)
aa374f67
AM		 5115 sec->has_toc_reloc = 1;
5116 }
5117 _bfd_elf_link_just_syms (sec, info);
5118}
5119
e054468f 5120static struct plt_entry **
4ce794b7
AM		 5121update_local_sym_info (bfd *abfd, Elf_Internal_Shdr *symtab_hdr,
5122 unsigned long r_symndx, bfd_vma r_addend, int tls_type)
411e1bfb
AM		 5123{
5124 struct got_entry **local_got_ents = elf_local_got_ents (abfd);
e054468f 5125 struct plt_entry **local_plt;
f961d9dd 5126 unsigned char *local_got_tls_masks;
411e1bfb
AM		 5127
5128 if (local_got_ents == NULL)
5129 {
5130 bfd_size_type size = symtab_hdr->sh_info;
5131
e054468f
AM		 5132 size *= (sizeof (*local_got_ents)
5133 + sizeof (*local_plt)
5134 + sizeof (*local_got_tls_masks));
4ce794b7 5135 local_got_ents = bfd_zalloc (abfd, size);
411e1bfb 5136 if (local_got_ents == NULL)
e054468f 5137 return NULL;
411e1bfb
AM		 5138 elf_local_got_ents (abfd) = local_got_ents;
5139 }
5140
e054468f 5141 if ((tls_type & (PLT_IFUNC | TLS_EXPLICIT)) == 0)
411e1bfb
AM		 5142 {
5143 struct got_entry *ent;
5144
5145 for (ent = local_got_ents[r_symndx]; ent != NULL; ent = ent->next)
e717da7e
AM		 5146 if (ent->addend == r_addend
5147 && ent->owner == abfd
5148 && ent->tls_type == tls_type)
411e1bfb
AM		 5149 break;
5150 if (ent == NULL)
5151 {
5152 bfd_size_type amt = sizeof (*ent);
4ce794b7 5153 ent = bfd_alloc (abfd, amt);
411e1bfb
AM		 5154 if (ent == NULL)
5155 return FALSE;
5156 ent->next = local_got_ents[r_symndx];
5157 ent->addend = r_addend;
e717da7e 5158 ent->owner = abfd;
411e1bfb 5159 ent->tls_type = tls_type;
927be08e 5160 ent->is_indirect = FALSE;
411e1bfb
AM		 5161 ent->got.refcount = 0;
5162 local_got_ents[r_symndx] = ent;
5163 }
5164 ent->got.refcount += 1;
5165 }
5166
e054468f 5167 local_plt = (struct plt_entry **) (local_got_ents + symtab_hdr->sh_info);
f961d9dd 5168 local_got_tls_masks = (unsigned char *) (local_plt + symtab_hdr->sh_info);
e7b938ca 5169 local_got_tls_masks[r_symndx] |= tls_type;
e054468f
AM		 5170
5171 return local_plt + r_symndx;
65f38f15
AM		 5172}
5173
411e1bfb 5174static bfd_boolean
e054468f 5175update_plt_info (bfd *abfd, struct plt_entry **plist, bfd_vma addend)
1e2f5b6e 5176{
411e1bfb 5177 struct plt_entry *ent;
1e2f5b6e 5178
e054468f 5179 for (ent = *plist; ent != NULL; ent = ent->next)
411e1bfb
AM		 5180 if (ent->addend == addend)
5181 break;
5182 if (ent == NULL)
1e2f5b6e 5183 {
411e1bfb 5184 bfd_size_type amt = sizeof (*ent);
4ce794b7 5185 ent = bfd_alloc (abfd, amt);
411e1bfb
AM		 5186 if (ent == NULL)
5187 return FALSE;
e054468f 5188 ent->next = *plist;
411e1bfb
AM		 5189 ent->addend = addend;
5190 ent->plt.refcount = 0;
e054468f 5191 *plist = ent;
1e2f5b6e 5192 }
411e1bfb 5193 ent->plt.refcount += 1;
b34976b6 5194 return TRUE;
1e2f5b6e
AM		 5195}
5196
e054468f
AM		 5197static bfd_boolean
5198is_branch_reloc (enum elf_ppc64_reloc_type r_type)
5199{
5200 return (r_type == R_PPC64_REL24
5201 || r_type == R_PPC64_REL14
5202 || r_type == R_PPC64_REL14_BRTAKEN
5203 || r_type == R_PPC64_REL14_BRNTAKEN
5204 || r_type == R_PPC64_ADDR24
5205 || r_type == R_PPC64_ADDR14
5206 || r_type == R_PPC64_ADDR14_BRTAKEN
5207 || r_type == R_PPC64_ADDR14_BRNTAKEN);
5208}
5209
5bd4f169 5210/* Look through the relocs for a section during the first phase, and
65f38f15 5211 calculate needed space in the global offset table, procedure
5d1634d7 5212 linkage table, and dynamic reloc sections. */
5bd4f169 5213
b34976b6 5214static bfd_boolean
4ce794b7
AM		 5215ppc64_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
5216 asection *sec, const Elf_Internal_Rela *relocs)
5bd4f169 5217{
65f38f15 5218 struct ppc_link_hash_table *htab;
5bd4f169 5219 Elf_Internal_Shdr *symtab_hdr;
c7e2358a 5220 struct elf_link_hash_entry **sym_hashes;
5bd4f169
AM		 5221 const Elf_Internal_Rela *rel;
5222 const Elf_Internal_Rela *rel_end;
5bd4f169 5223 asection *sreloc;
1e2f5b6e 5224 asection **opd_sym_map;
3a71aa26 5225 struct elf_link_hash_entry *tga, *dottga;
5bd4f169 5226
1049f94e 5227 if (info->relocatable)
b34976b6 5228 return TRUE;
5bd4f169 5229
680a3378
AM		 5230 /* Don't do anything special with non-loaded, non-alloced sections.
5231 In particular, any relocs in such sections should not affect GOT
5232 and PLT reference counting (ie. we don't allow them to create GOT
5233 or PLT entries), there's no possibility or desire to optimize TLS
5234 relocs, and there's not much point in propagating relocs to shared
5235 libs that the dynamic linker won't relocate. */
5236 if ((sec->flags & SEC_ALLOC) == 0)
5237 return TRUE;
5238
0c8d6e5c 5239 BFD_ASSERT (is_ppc64_elf (abfd));
0ffa91dd 5240
65f38f15 5241 htab = ppc_hash_table (info);
4dfe6ac6
NC		 5242 if (htab == NULL)
5243 return FALSE;
5244
3a71aa26
AM		 5245 tga = elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
5246 FALSE, FALSE, TRUE);
5247 dottga = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
5248 FALSE, FALSE, TRUE);
0ffa91dd 5249 symtab_hdr = &elf_symtab_hdr (abfd);
5bd4f169 5250 sym_hashes = elf_sym_hashes (abfd);
5bd4f169 5251 sreloc = NULL;
1e2f5b6e 5252 opd_sym_map = NULL;
f6c7c3e8
AM		 5253 if (ppc64_elf_section_data (sec) != NULL
5254 && ppc64_elf_section_data (sec)->sec_type == sec_opd)
5255 opd_sym_map = ppc64_elf_section_data (sec)->u.opd.func_sec;
5bd4f169
AM		 5256
5257 rel_end = relocs + sec->reloc_count;
5258 for (rel = relocs; rel < rel_end; rel++)
5259 {
5260 unsigned long r_symndx;
5261 struct elf_link_hash_entry *h;
04c9666a 5262 enum elf_ppc64_reloc_type r_type;
727fc41e 5263 int tls_type;
7c8fe5c4 5264 struct _ppc64_elf_section_data *ppc64_sec;
e054468f 5265 struct plt_entry **ifunc;
5bd4f169
AM		 5266
5267 r_symndx = ELF64_R_SYM (rel->r_info);
5268 if (r_symndx < symtab_hdr->sh_info)
5269 h = NULL;
5270 else
973a3492
L		 5271 {
5272 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
b31867b6 5273 h = elf_follow_link (h);
81fbe831
AM		 5274
5275 /* PR15323, ref flags aren't set for references in the same
5276 object. */
5277 h->root.non_ir_ref = 1;
1c865ab2
AM		 5278
5279 if (h == htab->elf.hgot)
5280 sec->has_toc_reloc = 1;
973a3492 5281 }
5bd4f169 5282
727fc41e 5283 tls_type = 0;
e054468f 5284 ifunc = NULL;
25f23106
AM		 5285 if (h != NULL)
5286 {
5287 if (h->type == STT_GNU_IFUNC)
5288 {
5289 h->needs_plt = 1;
5290 ifunc = &h->plt.plist;
5291 }
5292 }
5293 else
5294 {
5295 Elf_Internal_Sym *isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5296 abfd, r_symndx);
5297 if (isym == NULL)
5298 return FALSE;
5299
5300 if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
5301 {
5302 ifunc = update_local_sym_info (abfd, symtab_hdr, r_symndx,
5303 rel->r_addend, PLT_IFUNC);
5304 if (ifunc == NULL)
5305 return FALSE;
5306 }
5307 }
4ce794b7 5308 r_type = ELF64_R_TYPE (rel->r_info);
e054468f
AM		 5309 if (is_branch_reloc (r_type))
5310 {
5311 if (h != NULL && (h == tga || h == dottga))
5312 {
5313 if (rel != relocs
5314 && (ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSGD
5315 || ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSLD))
5316 /* We have a new-style __tls_get_addr call with a marker
5317 reloc. */
5318 ;
5319 else
5320 /* Mark this section as having an old-style call. */
5321 sec->has_tls_get_addr_call = 1;
5322 }
727fc41e 5323
e054468f 5324 /* STT_GNU_IFUNC symbols must have a PLT entry. */
e054468f
AM		 5325 if (ifunc != NULL
5326 && !update_plt_info (abfd, ifunc, rel->r_addend))
5327 return FALSE;
5328 }
727fc41e 5329
a33d1f77 5330 switch (r_type)
5bd4f169 5331 {
727fc41e
AM		 5332 case R_PPC64_TLSGD:
5333 case R_PPC64_TLSLD:
5334 /* These special tls relocs tie a call to __tls_get_addr with
5335 its parameter symbol. */
5336 break;
5337
411e1bfb
AM		 5338 case R_PPC64_GOT_TLSLD16:
5339 case R_PPC64_GOT_TLSLD16_LO:
5340 case R_PPC64_GOT_TLSLD16_HI:
5341 case R_PPC64_GOT_TLSLD16_HA:
951fd09b 5342 tls_type = TLS_TLS | TLS_LD;
411e1bfb
AM		 5343 goto dogottls;
5344
5345 case R_PPC64_GOT_TLSGD16:
5346 case R_PPC64_GOT_TLSGD16_LO:
5347 case R_PPC64_GOT_TLSGD16_HI:
5348 case R_PPC64_GOT_TLSGD16_HA:
951fd09b 5349 tls_type = TLS_TLS | TLS_GD;
411e1bfb
AM		 5350 goto dogottls;
5351
5352 case R_PPC64_GOT_TPREL16_DS:
5353 case R_PPC64_GOT_TPREL16_LO_DS:
5354 case R_PPC64_GOT_TPREL16_HI:
5355 case R_PPC64_GOT_TPREL16_HA:
afb93314 5356 if (info->shared)
411e1bfb
AM		 5357 info->flags |= DF_STATIC_TLS;
5358 tls_type = TLS_TLS | TLS_TPREL;
5359 goto dogottls;
5360
5361 case R_PPC64_GOT_DTPREL16_DS:
5362 case R_PPC64_GOT_DTPREL16_LO_DS:
5363 case R_PPC64_GOT_DTPREL16_HI:
5364 case R_PPC64_GOT_DTPREL16_HA:
5365 tls_type = TLS_TLS | TLS_DTPREL;
5366 dogottls:
5367 sec->has_tls_reloc = 1;
5368 /* Fall thru */
5369
5bd4f169 5370 case R_PPC64_GOT16:
5bd4f169 5371 case R_PPC64_GOT16_DS:
65f38f15
AM		 5372 case R_PPC64_GOT16_HA:
5373 case R_PPC64_GOT16_HI:
5374 case R_PPC64_GOT16_LO:
5bd4f169 5375 case R_PPC64_GOT16_LO_DS:
65f38f15 5376 /* This symbol requires a global offset table entry. */
4c52953f 5377 sec->has_toc_reloc = 1;
33c0ec9d
AM		 5378 if (r_type == R_PPC64_GOT_TLSLD16
5379 || r_type == R_PPC64_GOT_TLSGD16
5380 || r_type == R_PPC64_GOT_TPREL16_DS
5381 || r_type == R_PPC64_GOT_DTPREL16_DS
5382 || r_type == R_PPC64_GOT16
5383 || r_type == R_PPC64_GOT16_DS)
5384 {
5385 htab->do_multi_toc = 1;
d77c8a4b 5386 ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
33c0ec9d
AM		 5387 }
5388
e717da7e
AM		 5389 if (ppc64_elf_tdata (abfd)->got == NULL
5390 && !create_got_section (abfd, info))
b34976b6 5391 return FALSE;
5bd4f169
AM		 5392
5393 if (h != NULL)
5394 {
411e1bfb
AM		 5395 struct ppc_link_hash_entry *eh;
5396 struct got_entry *ent;
65f38f15 5397
411e1bfb
AM		 5398 eh = (struct ppc_link_hash_entry *) h;
5399 for (ent = eh->elf.got.glist; ent != NULL; ent = ent->next)
5400 if (ent->addend == rel->r_addend
e717da7e 5401 && ent->owner == abfd
411e1bfb
AM		 5402 && ent->tls_type == tls_type)
5403 break;
5404 if (ent == NULL)
5bd4f169 5405 {
411e1bfb 5406 bfd_size_type amt = sizeof (*ent);
4ce794b7 5407 ent = bfd_alloc (abfd, amt);
411e1bfb 5408 if (ent == NULL)
b34976b6 5409 return FALSE;
411e1bfb
AM		 5410 ent->next = eh->elf.got.glist;
5411 ent->addend = rel->r_addend;
e717da7e 5412 ent->owner = abfd;
411e1bfb 5413 ent->tls_type = tls_type;
927be08e 5414 ent->is_indirect = FALSE;
411e1bfb
AM		 5415 ent->got.refcount = 0;
5416 eh->elf.got.glist = ent;
5bd4f169 5417 }
411e1bfb 5418 ent->got.refcount += 1;
e7b938ca 5419 eh->tls_mask |= tls_type;
5bd4f169 5420 }
411e1bfb
AM		 5421 else
5422 /* This is a global offset table entry for a local symbol. */
5423 if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5424 rel->r_addend, tls_type))
5425 return FALSE;
a345bc8d
AM		 5426
5427 /* We may also need a plt entry if the symbol turns out to be
5428 an ifunc. */
f6c7c3e8 5429 if (h != NULL && !info->shared && abiversion (abfd) != 1)
a345bc8d
AM		 5430 {
5431 if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5432 return FALSE;
5433 }
5bd4f169
AM		 5434 break;
5435
5bd4f169 5436 case R_PPC64_PLT16_HA:
65f38f15
AM		 5437 case R_PPC64_PLT16_HI:
5438 case R_PPC64_PLT16_LO:
5439 case R_PPC64_PLT32:
5440 case R_PPC64_PLT64:
5bd4f169 5441 /* This symbol requires a procedure linkage table entry. We
3fad3c7c
AM		 5442 actually build the entry in adjust_dynamic_symbol,
5443 because this might be a case of linking PIC code without
5444 linking in any dynamic objects, in which case we don't
5445 need to generate a procedure linkage table after all. */
5bd4f169
AM		 5446 if (h == NULL)
5447 {
5448 /* It does not make sense to have a procedure linkage
3fad3c7c 5449 table entry for a local symbol. */
5bd4f169 5450 bfd_set_error (bfd_error_bad_value);
b34976b6 5451 return FALSE;
5bd4f169 5452 }
411e1bfb 5453 else
e054468f
AM		 5454 {
5455 if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5456 return FALSE;
5457 h->needs_plt = 1;
5458 if (h->root.root.string[0] == '.'
5459 && h->root.root.string[1] != '\0')
5460 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5461 }
5bd4f169
AM		 5462 break;
5463
5464 /* The following relocations don't need to propagate the
5465 relocation if linking a shared object since they are
5466 section relative. */
5467 case R_PPC64_SECTOFF:
5468 case R_PPC64_SECTOFF_LO:
5469 case R_PPC64_SECTOFF_HI:
5470 case R_PPC64_SECTOFF_HA:
5471 case R_PPC64_SECTOFF_DS:
5472 case R_PPC64_SECTOFF_LO_DS:
411e1bfb
AM		 5473 case R_PPC64_DTPREL16:
5474 case R_PPC64_DTPREL16_LO:
5475 case R_PPC64_DTPREL16_HI:
5476 case R_PPC64_DTPREL16_HA:
5477 case R_PPC64_DTPREL16_DS:
5478 case R_PPC64_DTPREL16_LO_DS:
f9c6b907
AM		 5479 case R_PPC64_DTPREL16_HIGH:
5480 case R_PPC64_DTPREL16_HIGHA:
411e1bfb
AM		 5481 case R_PPC64_DTPREL16_HIGHER:
5482 case R_PPC64_DTPREL16_HIGHERA:
5483 case R_PPC64_DTPREL16_HIGHEST:
5484 case R_PPC64_DTPREL16_HIGHESTA:
5bd4f169
AM		 5485 break;
5486
ad8e1ba5 5487 /* Nor do these. */
25f23106
AM		 5488 case R_PPC64_REL16:
5489 case R_PPC64_REL16_LO:
5490 case R_PPC64_REL16_HI:
5491 case R_PPC64_REL16_HA:
5492 break;
5493
45965137
AM		 5494 /* Not supported as a dynamic relocation. */
5495 case R_PPC64_ADDR64_LOCAL:
5496 if (info->shared)
5497 {
5498 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
5499 ppc_howto_init ();
5500 info->callbacks->einfo (_("%P: %H: %s reloc unsupported "
5501 "in shared libraries and PIEs.\n"),
5502 abfd, sec, rel->r_offset,
5503 ppc64_elf_howto_table[r_type]->name);
5504 bfd_set_error (bfd_error_bad_value);
5505 return FALSE;
5506 }
5507 break;
5508
ad8e1ba5 5509 case R_PPC64_TOC16:
33c0ec9d
AM		 5510 case R_PPC64_TOC16_DS:
5511 htab->do_multi_toc = 1;
d77c8a4b 5512 ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
ad8e1ba5
AM		 5513 case R_PPC64_TOC16_LO:
5514 case R_PPC64_TOC16_HI:
5515 case R_PPC64_TOC16_HA:
ad8e1ba5 5516 case R_PPC64_TOC16_LO_DS:
4c52953f 5517 sec->has_toc_reloc = 1;
ad8e1ba5
AM		 5518 break;
5519
5bd4f169
AM		 5520 /* This relocation describes the C++ object vtable hierarchy.
5521 Reconstruct it for later use during GC. */
5522 case R_PPC64_GNU_VTINHERIT:
c152c796 5523 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
b34976b6 5524 return FALSE;
5bd4f169
AM		 5525 break;
5526
5527 /* This relocation describes which C++ vtable entries are actually
5528 used. Record for later use during GC. */
5529 case R_PPC64_GNU_VTENTRY:
d17e0c6e
JB		 5530 BFD_ASSERT (h != NULL);
5531 if (h != NULL
5532 && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
b34976b6 5533 return FALSE;
5bd4f169
AM		 5534 break;
5535
721956f4
AM		 5536 case R_PPC64_REL14:
5537 case R_PPC64_REL14_BRTAKEN:
5538 case R_PPC64_REL14_BRNTAKEN:
220c76dd
AM		 5539 {
5540 asection *dest = NULL;
5541
5542 /* Heuristic: If jumping outside our section, chances are
5543 we are going to need a stub. */
5544 if (h != NULL)
5545 {
5546 /* If the sym is weak it may be overridden later, so
5547 don't assume we know where a weak sym lives. */
5548 if (h->root.type == bfd_link_hash_defined)
5549 dest = h->root.u.def.section;
5550 }
5551 else
87d72d41
AM		 5552 {
5553 Elf_Internal_Sym *isym;
5554
5555 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5556 abfd, r_symndx);
5557 if (isym == NULL)
5558 return FALSE;
5559
5560 dest = bfd_section_from_elf_index (abfd, isym->st_shndx);
5561 }
5562
220c76dd 5563 if (dest != sec)
7c8fe5c4 5564 ppc64_elf_section_data (sec)->has_14bit_branch = 1;
220c76dd 5565 }
721956f4
AM		 5566 /* Fall through. */
5567
5d1634d7 5568 case R_PPC64_REL24:
e054468f 5569 if (h != NULL && ifunc == NULL)
5d1634d7
AM		 5570 {
5571 /* We may need a .plt entry if the function this reloc
5572 refers to is in a shared lib. */
e054468f 5573 if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
411e1bfb 5574 return FALSE;
e054468f
AM		 5575 h->needs_plt = 1;
5576 if (h->root.root.string[0] == '.'
5577 && h->root.root.string[1] != '\0')
5578 ((struct ppc_link_hash_entry *) h)->is_func = 1;
3a71aa26 5579 if (h == tga || h == dottga)
411e1bfb 5580 sec->has_tls_reloc = 1;
411e1bfb
AM		 5581 }
5582 break;
5583
5584 case R_PPC64_TPREL64:
5585 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_TPREL;
afb93314 5586 if (info->shared)
411e1bfb
AM		 5587 info->flags |= DF_STATIC_TLS;
5588 goto dotlstoc;
5589
5590 case R_PPC64_DTPMOD64:
5591 if (rel + 1 < rel_end
5592 && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
5593 && rel[1].r_offset == rel->r_offset + 8)
951fd09b 5594 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_GD;
411e1bfb 5595 else
951fd09b 5596 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_LD;
411e1bfb
AM		 5597 goto dotlstoc;
5598
5599 case R_PPC64_DTPREL64:
5600 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_DTPREL;
5601 if (rel != relocs
5602 && rel[-1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPMOD64)
5603 && rel[-1].r_offset == rel->r_offset - 8)
5604 /* This is the second reloc of a dtpmod, dtprel pair.
5605 Don't mark with TLS_DTPREL. */
5606 goto dodyn;
5607
5608 dotlstoc:
5609 sec->has_tls_reloc = 1;
5610 if (h != NULL)
5611 {
5612 struct ppc_link_hash_entry *eh;
5613 eh = (struct ppc_link_hash_entry *) h;
e7b938ca 5614 eh->tls_mask |= tls_type;
411e1bfb
AM		 5615 }
5616 else
5617 if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5618 rel->r_addend, tls_type))
5619 return FALSE;
5620
7c8fe5c4
AM		 5621 ppc64_sec = ppc64_elf_section_data (sec);
5622 if (ppc64_sec->sec_type != sec_toc)
411e1bfb 5623 {
3a71aa26
AM		 5624 bfd_size_type amt;
5625
e7b938ca 5626 /* One extra to simplify get_tls_mask. */
3a71aa26
AM		 5627 amt = sec->size * sizeof (unsigned) / 8 + sizeof (unsigned);
5628 ppc64_sec->u.toc.symndx = bfd_zalloc (abfd, amt);
5629 if (ppc64_sec->u.toc.symndx == NULL)
5630 return FALSE;
5631 amt = sec->size * sizeof (bfd_vma) / 8;
5632 ppc64_sec->u.toc.add = bfd_zalloc (abfd, amt);
5633 if (ppc64_sec->u.toc.add == NULL)
411e1bfb 5634 return FALSE;
7c8fe5c4
AM		 5635 BFD_ASSERT (ppc64_sec->sec_type == sec_normal);
5636 ppc64_sec->sec_type = sec_toc;
411e1bfb
AM		 5637 }
5638 BFD_ASSERT (rel->r_offset % 8 == 0);
3a71aa26
AM		 5639 ppc64_sec->u.toc.symndx[rel->r_offset / 8] = r_symndx;
5640 ppc64_sec->u.toc.add[rel->r_offset / 8] = rel->r_addend;
951fd09b
AM		 5641
5642 /* Mark the second slot of a GD or LD entry.
5643 -1 to indicate GD and -2 to indicate LD. */
5644 if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_GD))
3a71aa26 5645 ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -1;
951fd09b 5646 else if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_LD))
3a71aa26 5647 ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -2;
411e1bfb
AM		 5648 goto dodyn;
5649
5650 case R_PPC64_TPREL16:
5651 case R_PPC64_TPREL16_LO:
5652 case R_PPC64_TPREL16_HI:
5653 case R_PPC64_TPREL16_HA:
5654 case R_PPC64_TPREL16_DS:
5655 case R_PPC64_TPREL16_LO_DS:
f9c6b907
AM		 5656 case R_PPC64_TPREL16_HIGH:
5657 case R_PPC64_TPREL16_HIGHA:
411e1bfb
AM		 5658 case R_PPC64_TPREL16_HIGHER:
5659 case R_PPC64_TPREL16_HIGHERA:
5660 case R_PPC64_TPREL16_HIGHEST:
5661 case R_PPC64_TPREL16_HIGHESTA:
5662 if (info->shared)
5663 {
afb93314 5664 info->flags |= DF_STATIC_TLS;
411e1bfb 5665 goto dodyn;
5d1634d7
AM		 5666 }
5667 break;
5668
e86ce104 5669 case R_PPC64_ADDR64:
1e2f5b6e 5670 if (opd_sym_map != NULL
1e2f5b6e 5671 && rel + 1 < rel_end
4ce794b7 5672 && ELF64_R_TYPE ((rel + 1)->r_info) == R_PPC64_TOC)
1e2f5b6e 5673 {
8387904d
AM		 5674 if (h != NULL)
5675 {
5676 if (h->root.root.string[0] == '.'
5677 && h->root.root.string[1] != 0
b31867b6 5678 && lookup_fdh ((struct ppc_link_hash_entry *) h, htab))
8387904d
AM		 5679 ;
5680 else
5681 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5682 }
5683 else
5684 {
5685 asection *s;
87d72d41 5686 Elf_Internal_Sym *isym;
1e2f5b6e 5687
87d72d41
AM		 5688 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5689 abfd, r_symndx);
5690 if (isym == NULL)
8387904d 5691 return FALSE;
87d72d41
AM		 5692
5693 s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5694 if (s != NULL && s != sec)
51aecdc5 5695 opd_sym_map[OPD_NDX (rel->r_offset)] = s;
8387904d 5696 }
1e2f5b6e 5697 }
e86ce104
AM		 5698 /* Fall through. */
5699
65f38f15
AM		 5700 case R_PPC64_ADDR16:
5701 case R_PPC64_ADDR16_DS:
5702 case R_PPC64_ADDR16_HA:
5703 case R_PPC64_ADDR16_HI:
f9c6b907
AM		 5704 case R_PPC64_ADDR16_HIGH:
5705 case R_PPC64_ADDR16_HIGHA:
65f38f15
AM		 5706 case R_PPC64_ADDR16_HIGHER:
5707 case R_PPC64_ADDR16_HIGHERA:
5708 case R_PPC64_ADDR16_HIGHEST:
5709 case R_PPC64_ADDR16_HIGHESTA:
5710 case R_PPC64_ADDR16_LO:
5711 case R_PPC64_ADDR16_LO_DS:
f6c7c3e8 5712 if (h != NULL && !info->shared && abiversion (abfd) != 1
a345bc8d
AM		 5713 && rel->r_addend == 0)
5714 {
5715 /* We may need a .plt entry if this reloc refers to a
5716 function in a shared lib. */
5717 if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5718 return FALSE;
5719 h->pointer_equality_needed = 1;
5720 }
5721 /* Fall through. */
5722
5723 case R_PPC64_REL30:
5724 case R_PPC64_REL32:
5725 case R_PPC64_REL64:
5726 case R_PPC64_ADDR14:
5727 case R_PPC64_ADDR14_BRNTAKEN:
5728 case R_PPC64_ADDR14_BRTAKEN:
65f38f15 5729 case R_PPC64_ADDR24:
65f38f15 5730 case R_PPC64_ADDR32:
65f38f15
AM		 5731 case R_PPC64_UADDR16:
5732 case R_PPC64_UADDR32:
5733 case R_PPC64_UADDR64:
5bd4f169 5734 case R_PPC64_TOC:
81848ca0
AM		 5735 if (h != NULL && !info->shared)
5736 /* We may need a copy reloc. */
f5385ebf 5737 h->non_got_ref = 1;
81848ca0 5738
41bd81ab 5739 /* Don't propagate .opd relocs. */
1e2f5b6e 5740 if (NO_OPD_RELOCS && opd_sym_map != NULL)
e86ce104 5741 break;
e86ce104 5742
65f38f15
AM		 5743 /* If we are creating a shared library, and this is a reloc
5744 against a global symbol, or a non PC relative reloc
5745 against a local symbol, then we need to copy the reloc
5746 into the shared library. However, if we are linking with
5747 -Bsymbolic, we do not need to copy a reloc against a
5748 global symbol which is defined in an object we are
5749 including in the link (i.e., DEF_REGULAR is set). At
5750 this point we have not seen all the input files, so it is
5751 possible that DEF_REGULAR is not set now but will be set
5752 later (it is never cleared). In case of a weak definition,
5753 DEF_REGULAR may be cleared later by a strong definition in
5754 a shared library. We account for that possibility below by
f4656909 5755 storing information in the dyn_relocs field of the hash
65f38f15
AM		 5756 table entry. A similar situation occurs when creating
5757 shared libraries and symbol visibility changes render the
5758 symbol local.
5759
5760 If on the other hand, we are creating an executable, we
5761 may need to keep relocations for symbols satisfied by a
5762 dynamic library if we manage to avoid copy relocs for the
5763 symbol. */
411e1bfb 5764 dodyn:
65f38f15 5765 if ((info->shared
1d483afe 5766 && (must_be_dyn_reloc (info, r_type)
65f38f15 5767 || (h != NULL
198f1157 5768 && (!SYMBOLIC_BIND (info, h)
65f38f15 5769 || h->root.type == bfd_link_hash_defweak
f5385ebf 5770 || !h->def_regular))))
f4656909
AM		 5771 || (ELIMINATE_COPY_RELOCS
5772 && !info->shared
65f38f15
AM		 5773 && h != NULL
5774 && (h->root.type == bfd_link_hash_defweak
25f23106
AM		 5775 || !h->def_regular))
5776 || (!info->shared
5777 && ifunc != NULL))
5bd4f169 5778 {
65f38f15
AM		 5779 /* We must copy these reloc types into the output file.
5780 Create a reloc section in dynobj and make room for
5781 this reloc. */
5bd4f169
AM		 5782 if (sreloc == NULL)
5783 {
83bac4b0
NC		 5784 sreloc = _bfd_elf_make_dynamic_reloc_section
5785 (sec, htab->elf.dynobj, 3, abfd, /*rela?*/ TRUE);
65f38f15 5786
5bd4f169 5787 if (sreloc == NULL)
83bac4b0 5788 return FALSE;
5bd4f169
AM		 5789 }
5790
65f38f15
AM		 5791 /* If this is a global symbol, we count the number of
5792 relocations we need for this symbol. */
5793 if (h != NULL)
5794 {
19e08130
AM		 5795 struct elf_dyn_relocs *p;
5796 struct elf_dyn_relocs **head;
5797
ec338859 5798 head = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
19e08130
AM		 5799 p = *head;
5800 if (p == NULL || p->sec != sec)
5801 {
5802 p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5803 if (p == NULL)
5804 return FALSE;
5805 p->next = *head;
5806 *head = p;
5807 p->sec = sec;
5808 p->count = 0;
5809 p->pc_count = 0;
5810 }
5811 p->count += 1;
5812 if (!must_be_dyn_reloc (info, r_type))
5813 p->pc_count += 1;
65f38f15
AM		 5814 }
5815 else
5816 {
ec338859
AM		 5817 /* Track dynamic relocs needed for local syms too.
5818 We really need local syms available to do this
5819 easily. Oh well. */
19e08130
AM		 5820 struct ppc_dyn_relocs *p;
5821 struct ppc_dyn_relocs **head;
5822 bfd_boolean is_ifunc;
ec338859 5823 asection *s;
6edfbbad 5824 void *vpp;
87d72d41 5825 Elf_Internal_Sym *isym;
6edfbbad 5826
87d72d41
AM		 5827 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5828 abfd, r_symndx);
5829 if (isym == NULL)
b34976b6 5830 return FALSE;
ec338859 5831
87d72d41
AM		 5832 s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5833 if (s == NULL)
5834 s = sec;
5835
6edfbbad 5836 vpp = &elf_section_data (s)->local_dynrel;
19e08130
AM		 5837 head = (struct ppc_dyn_relocs **) vpp;
5838 is_ifunc = ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC;
5839 p = *head;
5840 if (p != NULL && p->sec == sec && p->ifunc != is_ifunc)
5841 p = p->next;
5842 if (p == NULL || p->sec != sec || p->ifunc != is_ifunc)
5843 {
5844 p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5845 if (p == NULL)
5846 return FALSE;
5847 p->next = *head;
5848 *head = p;
5849 p->sec = sec;
5850 p->ifunc = is_ifunc;
5851 p->count = 0;
5852 }
5853 p->count += 1;
ec338859 5854 }
65f38f15 5855 }
5bd4f169 5856 break;
65f38f15
AM		 5857
5858 default:
96e0dda4 5859 break;
5bd4f169
AM		 5860 }
5861 }
5862
b34976b6 5863 return TRUE;
5bd4f169
AM		 5864}
5865
ee67d69a
AM		 5866/* Merge backend specific data from an object file to the output
5867 object file when linking. */
5868
5869static bfd_boolean
5870ppc64_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
5871{
5872 unsigned long iflags, oflags;
5873
5874 if ((ibfd->flags & BFD_LINKER_CREATED) != 0)
5875 return TRUE;
5876
5877 if (!is_ppc64_elf (ibfd) || !is_ppc64_elf (obfd))
5878 return TRUE;
5879
5880 if (!_bfd_generic_verify_endian_match (ibfd, obfd))
5881 return FALSE;
5882
5883 iflags = elf_elfheader (ibfd)->e_flags;
5884 oflags = elf_elfheader (obfd)->e_flags;
5885
f6c7c3e8 5886 if (iflags & ~EF_PPC64_ABI)
ee67d69a
AM		 5887 {
5888 (*_bfd_error_handler)
5889 (_("%B uses unknown e_flags 0x%lx"), ibfd, iflags);
5890 bfd_set_error (bfd_error_bad_value);
5891 return FALSE;
5892 }
f6c7c3e8 5893 else if (iflags != oflags && iflags != 0)
ee67d69a
AM		 5894 {
5895 (*_bfd_error_handler)
5896 (_("%B: ABI version %ld is not compatible with ABI version %ld output"),
5897 ibfd, iflags, oflags);
5898 bfd_set_error (bfd_error_bad_value);
5899 return FALSE;
5900 }
5901
5902 /* Merge Tag_compatibility attributes and any common GNU ones. */
5903 _bfd_elf_merge_object_attributes (ibfd, obfd);
5904
5905 return TRUE;
5906}
5907
5908static bfd_boolean
5909ppc64_elf_print_private_bfd_data (bfd *abfd, void *ptr)
5910{
5911 /* Print normal ELF private data. */
5912 _bfd_elf_print_private_bfd_data (abfd, ptr);
5913
5914 if (elf_elfheader (abfd)->e_flags != 0)
5915 {
5916 FILE *file = ptr;
5917
5918 /* xgettext:c-format */
5919 fprintf (file, _("private flags = 0x%lx:"),
5920 elf_elfheader (abfd)->e_flags);
5921
5922 if ((elf_elfheader (abfd)->e_flags & EF_PPC64_ABI) != 0)
5923 fprintf (file, _(" [abiv%ld]"),
5924 elf_elfheader (abfd)->e_flags & EF_PPC64_ABI);
5925 fputc ('\n', file);
5926 }
5927
5928 return TRUE;
5929}
5930
8387904d 5931/* OFFSET in OPD_SEC specifies a function descriptor. Return the address
b53dfeb2
AM		 5932 of the code entry point, and its section, which must be in the same
5933 object as OPD_SEC. Returns (bfd_vma) -1 on error. */
8387904d
AM		 5934
5935static bfd_vma
5936opd_entry_value (asection *opd_sec,
5937 bfd_vma offset,
5938 asection **code_sec,
aef36ac1
AM		 5939 bfd_vma *code_off,
5940 bfd_boolean in_code_sec)
8387904d
AM		 5941{
5942 bfd *opd_bfd = opd_sec->owner;
8860955f 5943 Elf_Internal_Rela *relocs;
8387904d 5944 Elf_Internal_Rela *lo, *hi, *look;
645ea6a9 5945 bfd_vma val;
8387904d 5946
9f296da3
AM		 5947 /* No relocs implies we are linking a --just-symbols object, or looking
5948 at a final linked executable with addr2line or somesuch. */
4b85d634
AM		 5949 if (opd_sec->reloc_count == 0)
5950 {
729eabd5 5951 bfd_byte *contents = ppc64_elf_tdata (opd_bfd)->opd.contents;
3b36f7e6 5952
729eabd5
AM		 5953 if (contents == NULL)
5954 {
5955 if (!bfd_malloc_and_get_section (opd_bfd, opd_sec, &contents))
5956 return (bfd_vma) -1;
5957 ppc64_elf_tdata (opd_bfd)->opd.contents = contents;
5958 }
ee1e4ede 5959
dbb3fbbb 5960 /* PR 17512: file: 64b9dfbb. */
451dfd38 5961 if (offset + 7 >= opd_sec->size || offset + 7 < offset)
dbb3fbbb
NC		 5962 return (bfd_vma) -1;
5963
729eabd5 5964 val = bfd_get_64 (opd_bfd, contents + offset);
aef36ac1
AM		 5965 if (code_sec != NULL)
5966 {
5967 asection *sec, *likely = NULL;
ee1e4ede 5968
aef36ac1 5969 if (in_code_sec)
4b85d634 5970 {
aef36ac1
AM		 5971 sec = *code_sec;
5972 if (sec->vma <= val
5973 && val < sec->vma + sec->size)
5974 likely = sec;
5975 else
5976 val = -1;
5977 }
5978 else
5979 for (sec = opd_bfd->sections; sec != NULL; sec = sec->next)
5980 if (sec->vma <= val
5981 && (sec->flags & SEC_LOAD) != 0
5982 && (sec->flags & SEC_ALLOC) != 0)
5983 likely = sec;
5984 if (likely != NULL)
5985 {
5986 *code_sec = likely;
5987 if (code_off != NULL)
5988 *code_off = val - likely->vma;
4b85d634
AM		 5989 }
5990 }
aef36ac1 5991 return val;
4b85d634
AM		 5992 }
5993
0c8d6e5c 5994 BFD_ASSERT (is_ppc64_elf (opd_bfd));
0ffa91dd 5995
729eabd5 5996 relocs = ppc64_elf_tdata (opd_bfd)->opd.relocs;
8860955f
AM		 5997 if (relocs == NULL)
5998 relocs = _bfd_elf_link_read_relocs (opd_bfd, opd_sec, NULL, NULL, TRUE);
877a8638
NC		 5999 /* PR 17512: file: df8e1fd6. */
6000 if (relocs == NULL)
6001 return (bfd_vma) -1;
645ea6a9 6002
8387904d 6003 /* Go find the opd reloc at the sym address. */
8860955f 6004 lo = relocs;
8387904d 6005 hi = lo + opd_sec->reloc_count - 1; /* ignore last reloc */
645ea6a9 6006 val = (bfd_vma) -1;
8387904d
AM		 6007 while (lo < hi)
6008 {
6009 look = lo + (hi - lo) / 2;
6010 if (look->r_offset < offset)
6011 lo = look + 1;
6012 else if (look->r_offset > offset)
6013 hi = look;
6014 else
6015 {
0ffa91dd
NC		 6016 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (opd_bfd);
6017
8387904d
AM		 6018 if (ELF64_R_TYPE (look->r_info) == R_PPC64_ADDR64
6019 && ELF64_R_TYPE ((look + 1)->r_info) == R_PPC64_TOC)
6020 {
6021 unsigned long symndx = ELF64_R_SYM (look->r_info);
b53dfeb2 6022 asection *sec = NULL;
8387904d 6023
b53dfeb2
AM		 6024 if (symndx >= symtab_hdr->sh_info
6025 && elf_sym_hashes (opd_bfd) != NULL)
8387904d
AM		 6026 {
6027 struct elf_link_hash_entry **sym_hashes;
6028 struct elf_link_hash_entry *rh;
6029
6030 sym_hashes = elf_sym_hashes (opd_bfd);
6031 rh = sym_hashes[symndx - symtab_hdr->sh_info];
128205bb
AM		 6032 if (rh != NULL)
6033 {
6034 rh = elf_follow_link (rh);
6035 BFD_ASSERT (rh->root.type == bfd_link_hash_defined
6036 || rh->root.type == bfd_link_hash_defweak);
6037 val = rh->root.u.def.value;
6038 sec = rh->root.u.def.section;
b53dfeb2
AM		 6039 if (sec->owner != opd_bfd)
6040 {
6041 sec = NULL;
6042 val = (bfd_vma) -1;
6043 }
6044 }
6045 }
6046
6047 if (sec == NULL)
6048 {
6049 Elf_Internal_Sym *sym;
6050
6051 if (symndx < symtab_hdr->sh_info)
6052 {
6053 sym = (Elf_Internal_Sym *) symtab_hdr->contents;
6054 if (sym == NULL)
6055 {
6056 size_t symcnt = symtab_hdr->sh_info;
6057 sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr,
6058 symcnt, 0,
6059 NULL, NULL, NULL);
6060 if (sym == NULL)
6061 break;
6062 symtab_hdr->contents = (bfd_byte *) sym;
6063 }
6064 sym += symndx;
128205bb
AM		 6065 }
6066 else
6067 {
b53dfeb2
AM		 6068 sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr,
6069 1, symndx,
6070 NULL, NULL, NULL);
128205bb
AM		 6071 if (sym == NULL)
6072 break;
128205bb 6073 }
b53dfeb2
AM		 6074 sec = bfd_section_from_elf_index (opd_bfd, sym->st_shndx);
6075 if (sec == NULL)
6076 break;
6077 BFD_ASSERT ((sec->flags & SEC_MERGE) == 0);
6078 val = sym->st_value;
8387904d 6079 }
b53dfeb2 6080
8387904d
AM		 6081 val += look->r_addend;
6082 if (code_off != NULL)
6083 *code_off = val;
6084 if (code_sec != NULL)
aef36ac1
AM		 6085 {
6086 if (in_code_sec && *code_sec != sec)
6087 return -1;
6088 else
6089 *code_sec = sec;
6090 }
b53dfeb2 6091 if (sec->output_section != NULL)
8387904d 6092 val += sec->output_section->vma + sec->output_offset;
8387904d
AM		 6093 }
6094 break;
6095 }
6096 }
645ea6a9 6097
645ea6a9 6098 return val;
8387904d
AM		 6099}
6100
aef36ac1
AM		 6101/* If the ELF symbol SYM might be a function in SEC, return the
6102 function size and set *CODE_OFF to the function's entry point,
6103 otherwise return zero. */
9f296da3 6104
aef36ac1
AM		 6105static bfd_size_type
6106ppc64_elf_maybe_function_sym (const asymbol *sym, asection *sec,
6107 bfd_vma *code_off)
9f296da3 6108{
aef36ac1
AM		 6109 bfd_size_type size;
6110
6111 if ((sym->flags & (BSF_SECTION_SYM | BSF_FILE | BSF_OBJECT
6112 | BSF_THREAD_LOCAL | BSF_RELC | BSF_SRELC)) != 0)
6113 return 0;
6114
6115 size = 0;
6116 if (!(sym->flags & BSF_SYNTHETIC))
6117 size = ((elf_symbol_type *) sym)->internal_elf_sym.st_size;
6118
6119 if (strcmp (sym->section->name, ".opd") == 0)
9f296da3 6120 {
aef36ac1
AM		 6121 if (opd_entry_value (sym->section, sym->value,
6122 &sec, code_off, TRUE) == (bfd_vma) -1)
6123 return 0;
6124 /* An old ABI binary with dot-syms has a size of 24 on the .opd
6125 symbol. This size has nothing to do with the code size of the
6126 function, which is what we're supposed to return, but the
6127 code size isn't available without looking up the dot-sym.
6128 However, doing that would be a waste of time particularly
6129 since elf_find_function will look at the dot-sym anyway.
6130 Now, elf_find_function will keep the largest size of any
6131 function sym found at the code address of interest, so return
6132 1 here to avoid it incorrectly caching a larger function size
6133 for a small function. This does mean we return the wrong
6134 size for a new-ABI function of size 24, but all that does is
6135 disable caching for such functions. */
6136 if (size == 24)
6137 size = 1;
9f296da3 6138 }
aef36ac1
AM		 6139 else
6140 {
6141 if (sym->section != sec)
6142 return 0;
6143 *code_off = sym->value;
6144 }
6145 if (size == 0)
6146 size = 1;
6147 return size;
9f296da3
AM		 6148}
6149
854b41e7
AM		 6150/* Return true if symbol is defined in a regular object file. */
6151
6152static bfd_boolean
6153is_static_defined (struct elf_link_hash_entry *h)
6154{
6155 return ((h->root.type == bfd_link_hash_defined
6156 || h->root.type == bfd_link_hash_defweak)
6157 && h->root.u.def.section != NULL
6158 && h->root.u.def.section->output_section != NULL);
6159}
6160
b31867b6
AM		 6161/* If FDH is a function descriptor symbol, return the associated code
6162 entry symbol if it is defined. Return NULL otherwise. */
6163
6164static struct ppc_link_hash_entry *
6165defined_code_entry (struct ppc_link_hash_entry *fdh)
6166{
6167 if (fdh->is_func_descriptor)
6168 {
6169 struct ppc_link_hash_entry *fh = ppc_follow_link (fdh->oh);
6170 if (fh->elf.root.type == bfd_link_hash_defined
6171 || fh->elf.root.type == bfd_link_hash_defweak)
6172 return fh;
6173 }
6174 return NULL;
6175}
6176
6177/* If FH is a function code entry symbol, return the associated
6178 function descriptor symbol if it is defined. Return NULL otherwise. */
6179
6180static struct ppc_link_hash_entry *
6181defined_func_desc (struct ppc_link_hash_entry *fh)
6182{
6183 if (fh->oh != NULL
6184 && fh->oh->is_func_descriptor)
6185 {
6186 struct ppc_link_hash_entry *fdh = ppc_follow_link (fh->oh);
6187 if (fdh->elf.root.type == bfd_link_hash_defined
6188 || fdh->elf.root.type == bfd_link_hash_defweak)
6189 return fdh;
6190 }
6191 return NULL;
6192}
6193
74f0fb50
AM		 6194/* Mark all our entry sym sections, both opd and code section. */
6195
6196static void
6197ppc64_elf_gc_keep (struct bfd_link_info *info)
6198{
6199 struct ppc_link_hash_table *htab = ppc_hash_table (info);
6200 struct bfd_sym_chain *sym;
6201
4dfe6ac6
NC		 6202 if (htab == NULL)
6203 return;
6204
74f0fb50
AM		 6205 for (sym = info->gc_sym_list; sym != NULL; sym = sym->next)
6206 {
b31867b6 6207 struct ppc_link_hash_entry *eh, *fh;
74f0fb50
AM		 6208 asection *sec;
6209
6210 eh = (struct ppc_link_hash_entry *)
b31867b6 6211 elf_link_hash_lookup (&htab->elf, sym->name, FALSE, FALSE, TRUE);
74f0fb50
AM		 6212 if (eh == NULL)
6213 continue;
6214 if (eh->elf.root.type != bfd_link_hash_defined
6215 && eh->elf.root.type != bfd_link_hash_defweak)
6216 continue;
6217
b31867b6
AM		 6218 fh = defined_code_entry (eh);
6219 if (fh != NULL)
74f0fb50 6220 {
b31867b6 6221 sec = fh->elf.root.u.def.section;
74f0fb50
AM		 6222 sec->flags |= SEC_KEEP;
6223 }
6224 else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6225 && opd_entry_value (eh->elf.root.u.def.section,
6226 eh->elf.root.u.def.value,
aef36ac1 6227 &sec, NULL, FALSE) != (bfd_vma) -1)
74f0fb50
AM		 6228 sec->flags |= SEC_KEEP;
6229
6230 sec = eh->elf.root.u.def.section;
6231 sec->flags |= SEC_KEEP;
6232 }
6233}
6234
64d03ab5
AM		 6235/* Mark sections containing dynamically referenced symbols. When
6236 building shared libraries, we must assume that any visible symbol is
6237 referenced. */
6238
6239static bfd_boolean
6240ppc64_elf_gc_mark_dynamic_ref (struct elf_link_hash_entry *h, void *inf)
6241{
6242 struct bfd_link_info *info = (struct bfd_link_info *) inf;
6243 struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
b31867b6 6244 struct ppc_link_hash_entry *fdh;
b407645f 6245 struct bfd_elf_dynamic_list *d = info->dynamic_list;
64d03ab5 6246
64d03ab5 6247 /* Dynamic linking info is on the func descriptor sym. */
b31867b6
AM		 6248 fdh = defined_func_desc (eh);
6249 if (fdh != NULL)
6250 eh = fdh;
64d03ab5
AM		 6251
6252 if ((eh->elf.root.type == bfd_link_hash_defined
6253 || eh->elf.root.type == bfd_link_hash_defweak)
6254 && (eh->elf.ref_dynamic
1c9177d9 6255 || ((eh->elf.def_regular || ELF_COMMON_DEF_P (&eh->elf))
64d03ab5 6256 && ELF_ST_VISIBILITY (eh->elf.other) != STV_INTERNAL
4c58e0d8 6257 && ELF_ST_VISIBILITY (eh->elf.other) != STV_HIDDEN
b407645f
AM		 6258 && (!info->executable
6259 || info->export_dynamic
6260 || (eh->elf.dynamic
6261 && d != NULL
6262 && (*d->match) (&d->head, NULL, eh->elf.root.root.string)))
4c58e0d8
AM		 6263 && (strchr (eh->elf.root.root.string, ELF_VER_CHR) != NULL
6264 || !bfd_hide_sym_by_version (info->version_info,
6265 eh->elf.root.root.string)))))
64d03ab5
AM		 6266 {
6267 asection *code_sec;
b31867b6 6268 struct ppc_link_hash_entry *fh;
64d03ab5
AM		 6269
6270 eh->elf.root.u.def.section->flags |= SEC_KEEP;
6271
6272 /* Function descriptor syms cause the associated
6273 function code sym section to be marked. */
b31867b6
AM		 6274 fh = defined_code_entry (eh);
6275 if (fh != NULL)
6276 {
6277 code_sec = fh->elf.root.u.def.section;
6278 code_sec->flags |= SEC_KEEP;
6279 }
64d03ab5
AM		 6280 else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6281 && opd_entry_value (eh->elf.root.u.def.section,
6282 eh->elf.root.u.def.value,
aef36ac1 6283 &code_sec, NULL, FALSE) != (bfd_vma) -1)
64d03ab5
AM		 6284 code_sec->flags |= SEC_KEEP;
6285 }
6286
6287 return TRUE;
6288}
6289
5bd4f169
AM		 6290/* Return the section that should be marked against GC for a given
6291 relocation. */
6292
6293static asection *
4ce794b7 6294ppc64_elf_gc_mark_hook (asection *sec,
fb34365b 6295 struct bfd_link_info *info,
4ce794b7
AM		 6296 Elf_Internal_Rela *rel,
6297 struct elf_link_hash_entry *h,
6298 Elf_Internal_Sym *sym)
5bd4f169 6299{
ccfa59ea
AM		 6300 asection *rsec;
6301
ccfa59ea
AM		 6302 /* Syms return NULL if we're marking .opd, so we avoid marking all
6303 function sections, as all functions are referenced in .opd. */
6304 rsec = NULL;
6305 if (get_opd_info (sec) != NULL)
6306 return rsec;
1e2f5b6e 6307
5bd4f169
AM		 6308 if (h != NULL)
6309 {
04c9666a 6310 enum elf_ppc64_reloc_type r_type;
b31867b6 6311 struct ppc_link_hash_entry *eh, *fh, *fdh;
a33d1f77 6312
4ce794b7 6313 r_type = ELF64_R_TYPE (rel->r_info);
a33d1f77 6314 switch (r_type)
5bd4f169
AM		 6315 {
6316 case R_PPC64_GNU_VTINHERIT:
6317 case R_PPC64_GNU_VTENTRY:
6318 break;
6319
6320 default:
6321 switch (h->root.type)
6322 {
6323 case bfd_link_hash_defined:
6324 case bfd_link_hash_defweak:
ccfa59ea 6325 eh = (struct ppc_link_hash_entry *) h;
b31867b6
AM		 6326 fdh = defined_func_desc (eh);
6327 if (fdh != NULL)
6328 eh = fdh;
1e2f5b6e
AM		 6329
6330 /* Function descriptor syms cause the associated
6331 function code sym section to be marked. */
b31867b6
AM		 6332 fh = defined_code_entry (eh);
6333 if (fh != NULL)
ccfa59ea
AM		 6334 {
6335 /* They also mark their opd section. */
74f0fb50 6336 eh->elf.root.u.def.section->gc_mark = 1;
ccfa59ea 6337
b31867b6 6338 rsec = fh->elf.root.u.def.section;
ccfa59ea 6339 }
8387904d
AM		 6340 else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6341 && opd_entry_value (eh->elf.root.u.def.section,
6342 eh->elf.root.u.def.value,
aef36ac1 6343 &rsec, NULL, FALSE) != (bfd_vma) -1)
74f0fb50 6344 eh->elf.root.u.def.section->gc_mark = 1;
ccfa59ea 6345 else
1e2f5b6e
AM		 6346 rsec = h->root.u.def.section;
6347 break;
5bd4f169
AM		 6348
6349 case bfd_link_hash_common:
1e2f5b6e
AM		 6350 rsec = h->root.u.c.p->section;
6351 break;
5bd4f169
AM		 6352
6353 default:
fb34365b 6354 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
5bd4f169
AM		 6355 }
6356 }
6357 }
6358 else
6359 {
74f0fb50 6360 struct _opd_sec_data *opd;
1e2f5b6e
AM		 6361
6362 rsec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
74f0fb50
AM		 6363 opd = get_opd_info (rsec);
6364 if (opd != NULL && opd->func_sec != NULL)
ccfa59ea 6365 {
74f0fb50 6366 rsec->gc_mark = 1;
ccfa59ea 6367
51aecdc5 6368 rsec = opd->func_sec[OPD_NDX (sym->st_value + rel->r_addend)];
ccfa59ea 6369 }
5bd4f169
AM		 6370 }
6371
1e2f5b6e 6372 return rsec;
5bd4f169
AM		 6373}
6374
65f38f15
AM		 6375/* Update the .got, .plt. and dynamic reloc reference counts for the
6376 section being removed. */
5bd4f169 6377
b34976b6 6378static bfd_boolean
4ce794b7
AM		 6379ppc64_elf_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info,
6380 asection *sec, const Elf_Internal_Rela *relocs)
5bd4f169 6381{
411e1bfb 6382 struct ppc_link_hash_table *htab;
5bd4f169
AM		 6383 Elf_Internal_Shdr *symtab_hdr;
6384 struct elf_link_hash_entry **sym_hashes;
411e1bfb 6385 struct got_entry **local_got_ents;
5bd4f169 6386 const Elf_Internal_Rela *rel, *relend;
5bd4f169 6387
7dda2462
TG		 6388 if (info->relocatable)
6389 return TRUE;
6390
680a3378
AM		 6391 if ((sec->flags & SEC_ALLOC) == 0)
6392 return TRUE;
6393
ec338859
AM		 6394 elf_section_data (sec)->local_dynrel = NULL;
6395
411e1bfb 6396 htab = ppc_hash_table (info);
4dfe6ac6
NC		 6397 if (htab == NULL)
6398 return FALSE;
6399
0ffa91dd 6400 symtab_hdr = &elf_symtab_hdr (abfd);
5bd4f169 6401 sym_hashes = elf_sym_hashes (abfd);
411e1bfb 6402 local_got_ents = elf_local_got_ents (abfd);
5bd4f169
AM		 6403
6404 relend = relocs + sec->reloc_count;
6405 for (rel = relocs; rel < relend; rel++)
a33d1f77
AM		 6406 {
6407 unsigned long r_symndx;
04c9666a 6408 enum elf_ppc64_reloc_type r_type;
58ac9f71 6409 struct elf_link_hash_entry *h = NULL;
f961d9dd 6410 unsigned char tls_type = 0;
5bd4f169 6411
a33d1f77 6412 r_symndx = ELF64_R_SYM (rel->r_info);
4ce794b7 6413 r_type = ELF64_R_TYPE (rel->r_info);
58ac9f71
AM		 6414 if (r_symndx >= symtab_hdr->sh_info)
6415 {
6416 struct ppc_link_hash_entry *eh;
6061a67d
AM		 6417 struct elf_dyn_relocs **pp;
6418 struct elf_dyn_relocs *p;
58ac9f71
AM		 6419
6420 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
b31867b6 6421 h = elf_follow_link (h);
58ac9f71
AM		 6422 eh = (struct ppc_link_hash_entry *) h;
6423
6424 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
6425 if (p->sec == sec)
6426 {
6427 /* Everything must go for SEC. */
6428 *pp = p->next;
6429 break;
6430 }
6431 }
6432
e054468f
AM		 6433 if (is_branch_reloc (r_type))
6434 {
6435 struct plt_entry **ifunc = NULL;
6436 if (h != NULL)
6437 {
6438 if (h->type == STT_GNU_IFUNC)
6439 ifunc = &h->plt.plist;
6440 }
6441 else if (local_got_ents != NULL)
6442 {
6443 struct plt_entry **local_plt = (struct plt_entry **)
6444 (local_got_ents + symtab_hdr->sh_info);
f961d9dd 6445 unsigned char *local_got_tls_masks = (unsigned char *)
e054468f
AM		 6446 (local_plt + symtab_hdr->sh_info);
6447 if ((local_got_tls_masks[r_symndx] & PLT_IFUNC) != 0)
6448 ifunc = local_plt + r_symndx;
6449 }
6450 if (ifunc != NULL)
6451 {
6452 struct plt_entry *ent;
6453
6454 for (ent = *ifunc; ent != NULL; ent = ent->next)
6455 if (ent->addend == rel->r_addend)
6456 break;
6457 if (ent == NULL)
6458 abort ();
6459 if (ent->plt.refcount > 0)
6460 ent->plt.refcount -= 1;
6461 continue;
6462 }
6463 }
6464
a33d1f77
AM		 6465 switch (r_type)
6466 {
411e1bfb
AM		 6467 case R_PPC64_GOT_TLSLD16:
6468 case R_PPC64_GOT_TLSLD16_LO:
6469 case R_PPC64_GOT_TLSLD16_HI:
6470 case R_PPC64_GOT_TLSLD16_HA:
951fd09b 6471 tls_type = TLS_TLS | TLS_LD;
411e1bfb
AM		 6472 goto dogot;
6473
6474 case R_PPC64_GOT_TLSGD16:
6475 case R_PPC64_GOT_TLSGD16_LO:
6476 case R_PPC64_GOT_TLSGD16_HI:
6477 case R_PPC64_GOT_TLSGD16_HA:
951fd09b 6478 tls_type = TLS_TLS | TLS_GD;
411e1bfb
AM		 6479 goto dogot;
6480
6481 case R_PPC64_GOT_TPREL16_DS:
6482 case R_PPC64_GOT_TPREL16_LO_DS:
6483 case R_PPC64_GOT_TPREL16_HI:
6484 case R_PPC64_GOT_TPREL16_HA:
6485 tls_type = TLS_TLS | TLS_TPREL;
6486 goto dogot;
6487
6488 case R_PPC64_GOT_DTPREL16_DS:
6489 case R_PPC64_GOT_DTPREL16_LO_DS:
6490 case R_PPC64_GOT_DTPREL16_HI:
6491 case R_PPC64_GOT_DTPREL16_HA:
6492 tls_type = TLS_TLS | TLS_DTPREL;
6493 goto dogot;
6494
a33d1f77
AM		 6495 case R_PPC64_GOT16:
6496 case R_PPC64_GOT16_DS:
6497 case R_PPC64_GOT16_HA:
6498 case R_PPC64_GOT16_HI:
6499 case R_PPC64_GOT16_LO:
6500 case R_PPC64_GOT16_LO_DS:
411e1bfb
AM		 6501 dogot:
6502 {
6503 struct got_entry *ent;
6504
58ac9f71
AM		 6505 if (h != NULL)
6506 ent = h->got.glist;
411e1bfb
AM		 6507 else
6508 ent = local_got_ents[r_symndx];
6509
6510 for (; ent != NULL; ent = ent->next)
6511 if (ent->addend == rel->r_addend
e717da7e 6512 && ent->owner == abfd
411e1bfb
AM		 6513 && ent->tls_type == tls_type)
6514 break;
6515 if (ent == NULL)
6516 abort ();
6517 if (ent->got.refcount > 0)
6518 ent->got.refcount -= 1;
6519 }
a33d1f77 6520 break;
65f38f15 6521
a33d1f77
AM		 6522 case R_PPC64_PLT16_HA:
6523 case R_PPC64_PLT16_HI:
6524 case R_PPC64_PLT16_LO:
6525 case R_PPC64_PLT32:
6526 case R_PPC64_PLT64:
721956f4
AM		 6527 case R_PPC64_REL14:
6528 case R_PPC64_REL14_BRNTAKEN:
6529 case R_PPC64_REL14_BRTAKEN:
5d1634d7 6530 case R_PPC64_REL24:
58ac9f71 6531 if (h != NULL)
5d1634d7 6532 {
411e1bfb
AM		 6533 struct plt_entry *ent;
6534
411e1bfb
AM		 6535 for (ent = h->plt.plist; ent != NULL; ent = ent->next)
6536 if (ent->addend == rel->r_addend)
6537 break;
7c6c1722 6538 if (ent != NULL && ent->plt.refcount > 0)
411e1bfb 6539 ent->plt.refcount -= 1;
5d1634d7 6540 }
e86ce104 6541 break;
5d1634d7 6542
a33d1f77
AM		 6543 default:
6544 break;
6545 }
6546 }
b34976b6 6547 return TRUE;
5bd4f169
AM		 6548}
6549
deb0e272
AM		 6550/* The maximum size of .sfpr. */
6551#define SFPR_MAX (218*4)
6552
6553struct sfpr_def_parms
6554{
699733f6
AM		 6555 const char name[12];
6556 unsigned char lo, hi;
deb0e272
AM		 6557 bfd_byte * (*write_ent) (bfd *, bfd_byte *, int);
6558 bfd_byte * (*write_tail) (bfd *, bfd_byte *, int);
6559};
6560
6561/* Auto-generate _save*, _rest* functions in .sfpr. */
6562
4dfe6ac6 6563static bfd_boolean
deb0e272
AM		 6564sfpr_define (struct bfd_link_info *info, const struct sfpr_def_parms *parm)
6565{
6566 struct ppc_link_hash_table *htab = ppc_hash_table (info);
6567 unsigned int i;
6568 size_t len = strlen (parm->name);
6569 bfd_boolean writing = FALSE;
699733f6 6570 char sym[16];
deb0e272 6571
4dfe6ac6
NC		 6572 if (htab == NULL)
6573 return FALSE;
6574
deb0e272
AM		 6575 memcpy (sym, parm->name, len);
6576 sym[len + 2] = 0;
6577
6578 for (i = parm->lo; i <= parm->hi; i++)
6579 {
6580 struct elf_link_hash_entry *h;
6581
6582 sym[len + 0] = i / 10 + '0';
6583 sym[len + 1] = i % 10 + '0';
6584 h = elf_link_hash_lookup (&htab->elf, sym, FALSE, FALSE, TRUE);
6585 if (h != NULL
f5385ebf 6586 && !h->def_regular)
deb0e272
AM		 6587 {
6588 h->root.type = bfd_link_hash_defined;
6589 h->root.u.def.section = htab->sfpr;
6590 h->root.u.def.value = htab->sfpr->size;
6591 h->type = STT_FUNC;
f5385ebf 6592 h->def_regular = 1;
deb0e272
AM		 6593 _bfd_elf_link_hash_hide_symbol (info, h, TRUE);
6594 writing = TRUE;
6595 if (htab->sfpr->contents == NULL)
6596 {
6597 htab->sfpr->contents = bfd_alloc (htab->elf.dynobj, SFPR_MAX);
6598 if (htab->sfpr->contents == NULL)
6599 return FALSE;
6600 }
6601 }
6602 if (writing)
6603 {
6604 bfd_byte *p = htab->sfpr->contents + htab->sfpr->size;
6605 if (i != parm->hi)
6606 p = (*parm->write_ent) (htab->elf.dynobj, p, i);
6607 else
6608 p = (*parm->write_tail) (htab->elf.dynobj, p, i);
6609 htab->sfpr->size = p - htab->sfpr->contents;
6610 }
6611 }
6612
6613 return TRUE;
6614}
6615
6616static bfd_byte *
6617savegpr0 (bfd *abfd, bfd_byte *p, int r)
6618{
6619 bfd_put_32 (abfd, STD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6620 return p + 4;
6621}
6622
6623static bfd_byte *
6624savegpr0_tail (bfd *abfd, bfd_byte *p, int r)
6625{
6626 p = savegpr0 (abfd, p, r);
a078d95a 6627 bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
deb0e272
AM		 6628 p = p + 4;
6629 bfd_put_32 (abfd, BLR, p);
6630 return p + 4;
6631}
6632
6633static bfd_byte *
6634restgpr0 (bfd *abfd, bfd_byte *p, int r)
6635{
6636 bfd_put_32 (abfd, LD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6637 return p + 4;
6638}
6639
6640static bfd_byte *
6641restgpr0_tail (bfd *abfd, bfd_byte *p, int r)
6642{
a078d95a 6643 bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
deb0e272
AM		 6644 p = p + 4;
6645 p = restgpr0 (abfd, p, r);
6646 bfd_put_32 (abfd, MTLR_R0, p);
6647 p = p + 4;
6648 if (r == 29)
6649 {
6650 p = restgpr0 (abfd, p, 30);
6651 p = restgpr0 (abfd, p, 31);
6652 }
6653 bfd_put_32 (abfd, BLR, p);
6654 return p + 4;
6655}
6656
6657static bfd_byte *
6658savegpr1 (bfd *abfd, bfd_byte *p, int r)
6659{
6660 bfd_put_32 (abfd, STD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6661 return p + 4;
6662}
6663
6664static bfd_byte *
6665savegpr1_tail (bfd *abfd, bfd_byte *p, int r)
6666{
6667 p = savegpr1 (abfd, p, r);
6668 bfd_put_32 (abfd, BLR, p);
6669 return p + 4;
6670}
6671
6672static bfd_byte *
6673restgpr1 (bfd *abfd, bfd_byte *p, int r)
6674{
6675 bfd_put_32 (abfd, LD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6676 return p + 4;
6677}
6678
6679static bfd_byte *
6680restgpr1_tail (bfd *abfd, bfd_byte *p, int r)
6681{
6682 p = restgpr1 (abfd, p, r);
6683 bfd_put_32 (abfd, BLR, p);
6684 return p + 4;
6685}
6686
6687static bfd_byte *
6688savefpr (bfd *abfd, bfd_byte *p, int r)
6689{
6690 bfd_put_32 (abfd, STFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6691 return p + 4;
6692}
6693
6694static bfd_byte *
6695savefpr0_tail (bfd *abfd, bfd_byte *p, int r)
6696{
6697 p = savefpr (abfd, p, r);
a078d95a 6698 bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
deb0e272
AM		 6699 p = p + 4;
6700 bfd_put_32 (abfd, BLR, p);
6701 return p + 4;
6702}
6703
6704static bfd_byte *
6705restfpr (bfd *abfd, bfd_byte *p, int r)
6706{
6707 bfd_put_32 (abfd, LFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6708 return p + 4;
6709}
6710
6711static bfd_byte *
6712restfpr0_tail (bfd *abfd, bfd_byte *p, int r)
6713{
a078d95a 6714 bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
deb0e272
AM		 6715 p = p + 4;
6716 p = restfpr (abfd, p, r);
6717 bfd_put_32 (abfd, MTLR_R0, p);
6718 p = p + 4;
6719 if (r == 29)
6720 {
6721 p = restfpr (abfd, p, 30);
6722 p = restfpr (abfd, p, 31);
6723 }
6724 bfd_put_32 (abfd, BLR, p);
6725 return p + 4;
6726}
6727
6728static bfd_byte *
6729savefpr1_tail (bfd *abfd, bfd_byte *p, int r)
6730{
6731 p = savefpr (abfd, p, r);
6732 bfd_put_32 (abfd, BLR, p);
6733 return p + 4;
6734}
6735
6736static bfd_byte *
6737restfpr1_tail (bfd *abfd, bfd_byte *p, int r)
6738{
6739 p = restfpr (abfd, p, r);
6740 bfd_put_32 (abfd, BLR, p);
6741 return p + 4;
6742}
6743
6744static bfd_byte *
6745savevr (bfd *abfd, bfd_byte *p, int r)
6746{
6747 bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6748 p = p + 4;
6749 bfd_put_32 (abfd, STVX_VR0_R12_R0 + (r << 21), p);
6750 return p + 4;
6751}
6752
6753static bfd_byte *
6754savevr_tail (bfd *abfd, bfd_byte *p, int r)
6755{
6756 p = savevr (abfd, p, r);
6757 bfd_put_32 (abfd, BLR, p);
6758 return p + 4;
6759}
6760
6761static bfd_byte *
6762restvr (bfd *abfd, bfd_byte *p, int r)
6763{
6764 bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6765 p = p + 4;
6766 bfd_put_32 (abfd, LVX_VR0_R12_R0 + (r << 21), p);
6767 return p + 4;
6768}
6769
6770static bfd_byte *
6771restvr_tail (bfd *abfd, bfd_byte *p, int r)
6772{
6773 p = restvr (abfd, p, r);
6774 bfd_put_32 (abfd, BLR, p);
6775 return p + 4;
6776}
6777
e86ce104
AM		 6778/* Called via elf_link_hash_traverse to transfer dynamic linking
6779 information on function code symbol entries to their corresponding
6780 function descriptor symbol entries. */
deb0e272 6781
b34976b6 6782static bfd_boolean
4ce794b7 6783func_desc_adjust (struct elf_link_hash_entry *h, void *inf)
5bd4f169 6784{
e86ce104 6785 struct bfd_link_info *info;
65f38f15 6786 struct ppc_link_hash_table *htab;
411e1bfb 6787 struct plt_entry *ent;
50bc7936
AM		 6788 struct ppc_link_hash_entry *fh;
6789 struct ppc_link_hash_entry *fdh;
6790 bfd_boolean force_local;
5bd4f169 6791
50bc7936
AM		 6792 fh = (struct ppc_link_hash_entry *) h;
6793 if (fh->elf.root.type == bfd_link_hash_indirect)
b34976b6 6794 return TRUE;
e86ce104 6795
4ce794b7 6796 info = inf;
65f38f15 6797 htab = ppc_hash_table (info);
4dfe6ac6
NC		 6798 if (htab == NULL)
6799 return FALSE;
5bd4f169 6800
c09bdfe5
AM		 6801 /* Resolve undefined references to dot-symbols as the value
6802 in the function descriptor, if we have one in a regular object.
6803 This is to satisfy cases like ".quad .foo". Calls to functions
6804 in dynamic objects are handled elsewhere. */
6805 if (fh->elf.root.type == bfd_link_hash_undefweak
6806 && fh->was_undefined
b31867b6
AM		 6807 && (fdh = defined_func_desc (fh)) != NULL
6808 && get_opd_info (fdh->elf.root.u.def.section) != NULL
6809 && opd_entry_value (fdh->elf.root.u.def.section,
6810 fdh->elf.root.u.def.value,
c09bdfe5 6811 &fh->elf.root.u.def.section,
aef36ac1 6812 &fh->elf.root.u.def.value, FALSE) != (bfd_vma) -1)
c09bdfe5 6813 {
b31867b6 6814 fh->elf.root.type = fdh->elf.root.type;
f5385ebf 6815 fh->elf.forced_local = 1;
b31867b6
AM		 6816 fh->elf.def_regular = fdh->elf.def_regular;
6817 fh->elf.def_dynamic = fdh->elf.def_dynamic;
c09bdfe5
AM		 6818 }
6819
e86ce104
AM		 6820 /* If this is a function code symbol, transfer dynamic linking
6821 information to the function descriptor symbol. */
50bc7936 6822 if (!fh->is_func)
b34976b6 6823 return TRUE;
e86ce104 6824
50bc7936 6825 for (ent = fh->elf.plt.plist; ent != NULL; ent = ent->next)
411e1bfb
AM		 6826 if (ent->plt.refcount > 0)
6827 break;
50bc7936
AM		 6828 if (ent == NULL
6829 || fh->elf.root.root.string[0] != '.'
6830 || fh->elf.root.root.string[1] == '\0')
6831 return TRUE;
5bd4f169 6832
50bc7936
AM		 6833 /* Find the corresponding function descriptor symbol. Create it
6834 as undefined if necessary. */
5bd4f169 6835
b31867b6 6836 fdh = lookup_fdh (fh, htab);
50bc7936 6837 if (fdh == NULL
df131623 6838 && !info->executable
50bc7936
AM		 6839 && (fh->elf.root.type == bfd_link_hash_undefined
6840 || fh->elf.root.type == bfd_link_hash_undefweak))
6841 {
908b32fc 6842 fdh = make_fdh (info, fh);
bb700d78
AM		 6843 if (fdh == NULL)
6844 return FALSE;
50bc7936 6845 }
648cca2c 6846
908b32fc 6847 /* Fake function descriptors are made undefweak. If the function
433817dd
AM		 6848 code symbol is strong undefined, make the fake sym the same.
6849 If the function code symbol is defined, then force the fake
6850 descriptor local; We can't support overriding of symbols in a
6851 shared library on a fake descriptor. */
908b32fc
AM		 6852
6853 if (fdh != NULL
6854 && fdh->fake
433817dd 6855 && fdh->elf.root.type == bfd_link_hash_undefweak)
908b32fc 6856 {
433817dd
AM		 6857 if (fh->elf.root.type == bfd_link_hash_undefined)
6858 {
6859 fdh->elf.root.type = bfd_link_hash_undefined;
6860 bfd_link_add_undef (&htab->elf.root, &fdh->elf.root);
6861 }
6862 else if (fh->elf.root.type == bfd_link_hash_defined
6863 || fh->elf.root.type == bfd_link_hash_defweak)
6864 {
6865 _bfd_elf_link_hash_hide_symbol (info, &fdh->elf, TRUE);
6866 }
908b32fc
AM		 6867 }
6868
50bc7936 6869 if (fdh != NULL
f5385ebf 6870 && !fdh->elf.forced_local
df131623 6871 && (!info->executable
f5385ebf
AM		 6872 || fdh->elf.def_dynamic
6873 || fdh->elf.ref_dynamic
50bc7936
AM		 6874 || (fdh->elf.root.type == bfd_link_hash_undefweak
6875 && ELF_ST_VISIBILITY (fdh->elf.other) == STV_DEFAULT)))
6876 {
6877 if (fdh->elf.dynindx == -1)
c152c796 6878 if (! bfd_elf_link_record_dynamic_symbol (info, &fdh->elf))
50bc7936 6879 return FALSE;
f5385ebf
AM		 6880 fdh->elf.ref_regular |= fh->elf.ref_regular;
6881 fdh->elf.ref_dynamic |= fh->elf.ref_dynamic;
6882 fdh->elf.ref_regular_nonweak |= fh->elf.ref_regular_nonweak;
6883 fdh->elf.non_got_ref |= fh->elf.non_got_ref;
50bc7936 6884 if (ELF_ST_VISIBILITY (fh->elf.other) == STV_DEFAULT)
e86ce104 6885 {
40d16e0b 6886 move_plt_plist (fh, fdh);
f5385ebf 6887 fdh->elf.needs_plt = 1;
e86ce104 6888 }
50bc7936 6889 fdh->is_func_descriptor = 1;
34814b9f
AM		 6890 fdh->oh = fh;
6891 fh->oh = fdh;
e86ce104
AM		 6892 }
6893
50bc7936
AM		 6894 /* Now that the info is on the function descriptor, clear the
6895 function code sym info. Any function code syms for which we
6896 don't have a definition in a regular file, we force local.
6897 This prevents a shared library from exporting syms that have
6898 been imported from another library. Function code syms that
6899 are really in the library we must leave global to prevent the
6900 linker dragging in a definition from a static library. */
93f3fa99
AM		 6901 force_local = (!fh->elf.def_regular
6902 || fdh == NULL
6903 || !fdh->elf.def_regular
6904 || fdh->elf.forced_local);
50bc7936
AM		 6905 _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
6906
b34976b6 6907 return TRUE;
e86ce104 6908}
40b8271b 6909
e86ce104 6910/* Called near the start of bfd_elf_size_dynamic_sections. We use
82bd7b59
AM		 6911 this hook to a) provide some gcc support functions, and b) transfer
6912 dynamic linking information gathered so far on function code symbol
6913 entries, to their corresponding function descriptor symbol entries. */
deb0e272 6914
b34976b6 6915static bfd_boolean
4ce794b7
AM		 6916ppc64_elf_func_desc_adjust (bfd *obfd ATTRIBUTE_UNUSED,
6917 struct bfd_link_info *info)
e86ce104
AM		 6918{
6919 struct ppc_link_hash_table *htab;
82bd7b59 6920 unsigned int i;
27fc25a1 6921 static const struct sfpr_def_parms funcs[] =
deb0e272
AM		 6922 {
6923 { "_savegpr0_", 14, 31, savegpr0, savegpr0_tail },
6924 { "_restgpr0_", 14, 29, restgpr0, restgpr0_tail },
6925 { "_restgpr0_", 30, 31, restgpr0, restgpr0_tail },
6926 { "_savegpr1_", 14, 31, savegpr1, savegpr1_tail },
6927 { "_restgpr1_", 14, 31, restgpr1, restgpr1_tail },
6928 { "_savefpr_", 14, 31, savefpr, savefpr0_tail },
6929 { "_restfpr_", 14, 29, restfpr, restfpr0_tail },
6930 { "_restfpr_", 30, 31, restfpr, restfpr0_tail },
6931 { "._savef", 14, 31, savefpr, savefpr1_tail },
6932 { "._restf", 14, 31, restfpr, restfpr1_tail },
6933 { "_savevr_", 20, 31, savevr, savevr_tail },
6934 { "_restvr_", 20, 31, restvr, restvr_tail }
6935 };
e86ce104
AM		 6936
6937 htab = ppc_hash_table (info);
4dfe6ac6
NC		 6938 if (htab == NULL)
6939 return FALSE;
6940
5295321c
AM		 6941 if (!info->relocatable
6942 && htab->elf.hgot != NULL)
dba6fa9b
AM		 6943 {
6944 _bfd_elf_link_hash_hide_symbol (info, htab->elf.hgot, TRUE);
6945 /* Make .TOC. defined so as to prevent it being made dynamic.
6946 The wrong value here is fixed later in ppc64_elf_set_toc. */
6947 htab->elf.hgot->type = STT_OBJECT;
6948 htab->elf.hgot->root.type = bfd_link_hash_defined;
6949 htab->elf.hgot->root.u.def.value = 0;
6950 htab->elf.hgot->root.u.def.section = bfd_abs_section_ptr;
6951 htab->elf.hgot->def_regular = 1;
6952 htab->elf.hgot->other = ((htab->elf.hgot->other & ~ELF_ST_VISIBILITY (-1))
6953 | STV_HIDDEN);
6954 }
c66bb0ee 6955
82bd7b59
AM		 6956 if (htab->sfpr == NULL)
6957 /* We don't have any relocs. */
b34976b6 6958 return TRUE;
82bd7b59 6959
deb0e272
AM		 6960 /* Provide any missing _save* and _rest* functions. */
6961 htab->sfpr->size = 0;
7d4c687d 6962 if (htab->params->save_restore_funcs)
27fc25a1
AM		 6963 for (i = 0; i < sizeof (funcs) / sizeof (funcs[0]); i++)
6964 if (!sfpr_define (info, &funcs[i]))
6965 return FALSE;
82bd7b59 6966
4ce794b7 6967 elf_link_hash_traverse (&htab->elf, func_desc_adjust, info);
805fc799 6968
eea6121a 6969 if (htab->sfpr->size == 0)
8423293d 6970 htab->sfpr->flags |= SEC_EXCLUDE;
82bd7b59 6971
b34976b6 6972 return TRUE;
e86ce104
AM		 6973}
6974
a345bc8d
AM		 6975/* Return true if we have dynamic relocs that apply to read-only sections. */
6976
6977static bfd_boolean
6978readonly_dynrelocs (struct elf_link_hash_entry *h)
6979{
6980 struct ppc_link_hash_entry *eh;
6981 struct elf_dyn_relocs *p;
6982
6983 eh = (struct ppc_link_hash_entry *) h;
6984 for (p = eh->dyn_relocs; p != NULL; p = p->next)
6985 {
6986 asection *s = p->sec->output_section;
6987
6988 if (s != NULL && (s->flags & SEC_READONLY) != 0)
6989 return TRUE;
6990 }
6991 return FALSE;
6992}
6993
e86ce104
AM		 6994/* Adjust a symbol defined by a dynamic object and referenced by a
6995 regular object. The current definition is in some section of the
6996 dynamic object, but we're not including those sections. We have to
6997 change the definition to something the rest of the link can
6998 understand. */
6999
b34976b6 7000static bfd_boolean
4ce794b7
AM		 7001ppc64_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
7002 struct elf_link_hash_entry *h)
e86ce104
AM		 7003{
7004 struct ppc_link_hash_table *htab;
e86ce104 7005 asection *s;
e86ce104
AM		 7006
7007 htab = ppc_hash_table (info);
4dfe6ac6
NC		 7008 if (htab == NULL)
7009 return FALSE;
e86ce104
AM		 7010
7011 /* Deal with function syms. */
7012 if (h->type == STT_FUNC
e054468f 7013 || h->type == STT_GNU_IFUNC
f5385ebf 7014 || h->needs_plt)
e86ce104
AM		 7015 {
7016 /* Clear procedure linkage table information for any symbol that
7017 won't need a .plt entry. */
411e1bfb
AM		 7018 struct plt_entry *ent;
7019 for (ent = h->plt.plist; ent != NULL; ent = ent->next)
7020 if (ent->plt.refcount > 0)
7021 break;
8387904d 7022 if (ent == NULL
e054468f
AM		 7023 || (h->type != STT_GNU_IFUNC
7024 && (SYMBOL_CALLS_LOCAL (info, h)
7025 || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
7026 && h->root.type == bfd_link_hash_undefweak))))
40b8271b 7027 {
411e1bfb 7028 h->plt.plist = NULL;
f5385ebf 7029 h->needs_plt = 0;
d1eca1e4 7030 h->pointer_equality_needed = 0;
40b8271b 7031 }
a345bc8d
AM		 7032 else if (abiversion (info->output_bfd) == 2)
7033 {
d1eca1e4
AM		 7034 /* Taking a function's address in a read/write section
7035 doesn't require us to define the function symbol in the
7036 executable on a global entry stub. A dynamic reloc can
7037 be used instead. */
7038 if (h->pointer_equality_needed
1009ef28 7039 && h->type != STT_GNU_IFUNC
d1eca1e4
AM		 7040 && !readonly_dynrelocs (h))
7041 {
7042 h->pointer_equality_needed = 0;
7043 h->non_got_ref = 0;
7044 }
7045
a345bc8d
AM		 7046 /* After adjust_dynamic_symbol, non_got_ref set in the
7047 non-shared case means that we have allocated space in
7048 .dynbss for the symbol and thus dyn_relocs for this
7049 symbol should be discarded.
7050 If we get here we know we are making a PLT entry for this
7051 symbol, and in an executable we'd normally resolve
7052 relocations against this symbol to the PLT entry. Allow
7053 dynamic relocs if the reference is weak, and the dynamic
7054 relocs will not cause text relocation. */
d1eca1e4
AM		 7055 else if (!h->ref_regular_nonweak
7056 && h->non_got_ref
7057 && h->type != STT_GNU_IFUNC
7058 && !readonly_dynrelocs (h))
a345bc8d
AM		 7059 h->non_got_ref = 0;
7060
7061 /* If making a plt entry, then we don't need copy relocs. */
7062 return TRUE;
7063 }
5bd4f169 7064 }
bbd7ec4a 7065 else
411e1bfb 7066 h->plt.plist = NULL;
5bd4f169
AM		 7067
7068 /* If this is a weak symbol, and there is a real definition, the
7069 processor independent code will have arranged for us to see the
7070 real definition first, and we can just use the same value. */
f6e332e6 7071 if (h->u.weakdef != NULL)
5bd4f169 7072 {
f6e332e6
AM		 7073 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
7074 || h->u.weakdef->root.type == bfd_link_hash_defweak);
7075 h->root.u.def.section = h->u.weakdef->root.u.def.section;
7076 h->root.u.def.value = h->u.weakdef->root.u.def.value;
a23b6845 7077 if (ELIMINATE_COPY_RELOCS)
f6e332e6 7078 h->non_got_ref = h->u.weakdef->non_got_ref;
b34976b6 7079 return TRUE;
5bd4f169
AM		 7080 }
7081
5bd4f169
AM		 7082 /* If we are creating a shared library, we must presume that the
7083 only references to the symbol are via the global offset table.
7084 For such cases we need not do anything here; the relocations will
7085 be handled correctly by relocate_section. */
7086 if (info->shared)
b34976b6 7087 return TRUE;
5bd4f169 7088
65f38f15
AM		 7089 /* If there are no references to this symbol that do not use the
7090 GOT, we don't need to generate a copy reloc. */
f5385ebf 7091 if (!h->non_got_ref)
b34976b6 7092 return TRUE;
65f38f15 7093
b186458a
JJ		 7094 /* Don't generate a copy reloc for symbols defined in the executable. */
7095 if (!h->def_dynamic || !h->ref_regular || h->def_regular)
7096 return TRUE;
7097
a127494f
AM		 7098 /* If -z nocopyreloc was given, don't generate them either. */
7099 if (info->nocopyreloc)
7100 {
7101 h->non_got_ref = 0;
7102 return TRUE;
7103 }
7104
a345bc8d
AM		 7105 /* If we didn't find any dynamic relocs in read-only sections, then
7106 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
7107 if (ELIMINATE_COPY_RELOCS && !readonly_dynrelocs (h))
65f38f15 7108 {
a345bc8d
AM		 7109 h->non_got_ref = 0;
7110 return TRUE;
65f38f15
AM		 7111 }
7112
a127494f
AM		 7113 /* Protected variables do not work with .dynbss. The copy in
7114 .dynbss won't be used by the shared library with the protected
7115 definition for the variable. Text relocations are preferable
7116 to an incorrect program. */
7117 if (h->protected_def)
7118 {
7119 h->non_got_ref = 0;
7120 return TRUE;
7121 }
7122
5d35169e 7123 if (h->plt.plist != NULL)
97b639ba
AM		 7124 {
7125 /* We should never get here, but unfortunately there are versions
7126 of gcc out there that improperly (for this ABI) put initialized
7127 function pointers, vtable refs and suchlike in read-only
7128 sections. Allow them to proceed, but warn that this might
7129 break at runtime. */
25f53a85 7130 info->callbacks->einfo
bc30df16 7131 (_("%P: copy reloc against `%T' requires lazy plt linking; "
25f53a85 7132 "avoid setting LD_BIND_NOW=1 or upgrade gcc\n"),
97b639ba
AM		 7133 h->root.root.string);
7134 }
5d35169e
AM		 7135
7136 /* This is a reference to a symbol defined by a dynamic object which
7137 is not a function. */
7138
5bd4f169
AM		 7139 /* We must allocate the symbol in our .dynbss section, which will
7140 become part of the .bss section of the executable. There will be
7141 an entry for this symbol in the .dynsym section. The dynamic
7142 object will contain position independent code, so all references
7143 from the dynamic object to this symbol will go through the global
7144 offset table. The dynamic linker will use the .dynsym entry to
7145 determine the address it must put in the global offset table, so
7146 both the dynamic object and the regular object will refer to the
7147 same memory location for the variable. */
5bd4f169 7148
04c9666a
AM		 7149 /* We must generate a R_PPC64_COPY reloc to tell the dynamic linker
7150 to copy the initial value out of the dynamic object and into the
5bd4f169
AM		 7151 runtime process image. We need to remember the offset into the
7152 .rela.bss section we are going to use. */
1d7e9d18 7153 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
5bd4f169 7154 {
eea6121a 7155 htab->relbss->size += sizeof (Elf64_External_Rela);
f5385ebf 7156 h->needs_copy = 1;
5bd4f169
AM		 7157 }
7158
4ce794b7 7159 s = htab->dynbss;
5bd4f169 7160
6cabe1ea 7161 return _bfd_elf_adjust_dynamic_copy (info, h, s);
5bd4f169
AM		 7162}
7163
e86ce104
AM		 7164/* If given a function descriptor symbol, hide both the function code
7165 sym and the descriptor. */
7166static void
4ce794b7
AM		 7167ppc64_elf_hide_symbol (struct bfd_link_info *info,
7168 struct elf_link_hash_entry *h,
7169 bfd_boolean force_local)
e86ce104 7170{
34814b9f 7171 struct ppc_link_hash_entry *eh;
e86ce104
AM		 7172 _bfd_elf_link_hash_hide_symbol (info, h, force_local);
7173
34814b9f
AM		 7174 eh = (struct ppc_link_hash_entry *) h;
7175 if (eh->is_func_descriptor)
e86ce104 7176 {
34814b9f 7177 struct ppc_link_hash_entry *fh = eh->oh;
e86ce104 7178
721956f4 7179 if (fh == NULL)
d1329ca3
AM		 7180 {
7181 const char *p, *q;
7182 struct ppc_link_hash_table *htab;
7183 char save;
7184
7185 /* We aren't supposed to use alloca in BFD because on
7186 systems which do not have alloca the version in libiberty
7187 calls xmalloc, which might cause the program to crash
7188 when it runs out of memory. This function doesn't have a
7189 return status, so there's no way to gracefully return an
7190 error. So cheat. We know that string[-1] can be safely
34814b9f
AM		 7191 accessed; It's either a string in an ELF string table,
7192 or allocated in an objalloc structure. */
d1329ca3 7193
34814b9f 7194 p = eh->elf.root.root.string - 1;
d1329ca3
AM		 7195 save = *p;
7196 *(char *) p = '.';
7197 htab = ppc_hash_table (info);
4dfe6ac6
NC		 7198 if (htab == NULL)
7199 return;
7200
34814b9f
AM		 7201 fh = (struct ppc_link_hash_entry *)
7202 elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
d1329ca3
AM		 7203 *(char *) p = save;
7204
7205 /* Unfortunately, if it so happens that the string we were
7206 looking for was allocated immediately before this string,
7207 then we overwrote the string terminator. That's the only
7208 reason the lookup should fail. */
7209 if (fh == NULL)
7210 {
34814b9f
AM		 7211 q = eh->elf.root.root.string + strlen (eh->elf.root.root.string);
7212 while (q >= eh->elf.root.root.string && *q == *p)
d1329ca3 7213 --q, --p;
34814b9f
AM		 7214 if (q < eh->elf.root.root.string && *p == '.')
7215 fh = (struct ppc_link_hash_entry *)
7216 elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
d1329ca3
AM		 7217 }
7218 if (fh != NULL)
7219 {
34814b9f
AM		 7220 eh->oh = fh;
7221 fh->oh = eh;
d1329ca3
AM		 7222 }
7223 }
e86ce104 7224 if (fh != NULL)
34814b9f 7225 _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
e86ce104
AM		 7226 }
7227}
7228
411e1bfb 7229static bfd_boolean
8843416a
AM		 7230get_sym_h (struct elf_link_hash_entry **hp,
7231 Elf_Internal_Sym **symp,
7232 asection **symsecp,
f961d9dd 7233 unsigned char **tls_maskp,
8843416a
AM		 7234 Elf_Internal_Sym **locsymsp,
7235 unsigned long r_symndx,
7236 bfd *ibfd)
411e1bfb 7237{
0ffa91dd 7238 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
411e1bfb
AM		 7239
7240 if (r_symndx >= symtab_hdr->sh_info)
7241 {
7242 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
7243 struct elf_link_hash_entry *h;
7244
7245 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
b31867b6 7246 h = elf_follow_link (h);
411e1bfb
AM		 7247
7248 if (hp != NULL)
7249 *hp = h;
7250
7251 if (symp != NULL)
7252 *symp = NULL;
7253
7254 if (symsecp != NULL)
7255 {
7256 asection *symsec = NULL;
7257 if (h->root.type == bfd_link_hash_defined
7258 || h->root.type == bfd_link_hash_defweak)
7259 symsec = h->root.u.def.section;
7260 *symsecp = symsec;
7261 }
7262
e7b938ca 7263 if (tls_maskp != NULL)
411e1bfb
AM		 7264 {
7265 struct ppc_link_hash_entry *eh;
7266
7267 eh = (struct ppc_link_hash_entry *) h;
e7b938ca 7268 *tls_maskp = &eh->tls_mask;
411e1bfb
AM		 7269 }
7270 }
7271 else
7272 {
7273 Elf_Internal_Sym *sym;
7274 Elf_Internal_Sym *locsyms = *locsymsp;
7275
7276 if (locsyms == NULL)
7277 {
7278 locsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
7279 if (locsyms == NULL)
7280 locsyms = bfd_elf_get_elf_syms (ibfd, symtab_hdr,
7281 symtab_hdr->sh_info,
7282 0, NULL, NULL, NULL);
7283 if (locsyms == NULL)
7284 return FALSE;
7285 *locsymsp = locsyms;
7286 }
7287 sym = locsyms + r_symndx;
7288
7289 if (hp != NULL)
7290 *hp = NULL;
7291
7292 if (symp != NULL)
7293 *symp = sym;
7294
7295 if (symsecp != NULL)
cb33740c 7296 *symsecp = bfd_section_from_elf_index (ibfd, sym->st_shndx);
411e1bfb 7297
e7b938ca 7298 if (tls_maskp != NULL)
411e1bfb
AM		 7299 {
7300 struct got_entry **lgot_ents;
f961d9dd 7301 unsigned char *tls_mask;
411e1bfb 7302
e7b938ca 7303 tls_mask = NULL;
411e1bfb
AM		 7304 lgot_ents = elf_local_got_ents (ibfd);
7305 if (lgot_ents != NULL)
7306 {
e054468f
AM		 7307 struct plt_entry **local_plt = (struct plt_entry **)
7308 (lgot_ents + symtab_hdr->sh_info);
f961d9dd 7309 unsigned char *lgot_masks = (unsigned char *)
e054468f 7310 (local_plt + symtab_hdr->sh_info);
e7b938ca 7311 tls_mask = &lgot_masks[r_symndx];
411e1bfb 7312 }
e7b938ca 7313 *tls_maskp = tls_mask;
411e1bfb
AM		 7314 }
7315 }
7316 return TRUE;
7317}
7318
e7b938ca 7319/* Returns TLS_MASKP for the given REL symbol. Function return is 0 on
951fd09b 7320 error, 2 on a toc GD type suitable for optimization, 3 on a toc LD
ad8e1ba5 7321 type suitable for optimization, and 1 otherwise. */
951fd09b
AM		 7322
7323static int
f961d9dd 7324get_tls_mask (unsigned char **tls_maskp,
3a71aa26
AM		 7325 unsigned long *toc_symndx,
7326 bfd_vma *toc_addend,
0d4792f7 7327 Elf_Internal_Sym **locsymsp,
3a71aa26
AM		 7328 const Elf_Internal_Rela *rel,
7329 bfd *ibfd)
411e1bfb
AM		 7330{
7331 unsigned long r_symndx;
0d4792f7 7332 int next_r;
411e1bfb
AM		 7333 struct elf_link_hash_entry *h;
7334 Elf_Internal_Sym *sym;
7335 asection *sec;
7336 bfd_vma off;
7337
7338 r_symndx = ELF64_R_SYM (rel->r_info);
e7b938ca 7339 if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
951fd09b 7340 return 0;
411e1bfb 7341
e7b938ca 7342 if ((*tls_maskp != NULL && **tls_maskp != 0)
411e1bfb 7343 || sec == NULL
6bee8834 7344 || ppc64_elf_section_data (sec) == NULL
7c8fe5c4 7345 || ppc64_elf_section_data (sec)->sec_type != sec_toc)
951fd09b 7346 return 1;
411e1bfb
AM		 7347
7348 /* Look inside a TOC section too. */
7349 if (h != NULL)
7350 {
7351 BFD_ASSERT (h->root.type == bfd_link_hash_defined);
7352 off = h->root.u.def.value;
7353 }
7354 else
7355 off = sym->st_value;
7356 off += rel->r_addend;
7357 BFD_ASSERT (off % 8 == 0);
3a71aa26
AM		 7358 r_symndx = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8];
7359 next_r = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8 + 1];
0d4792f7
AM		 7360 if (toc_symndx != NULL)
7361 *toc_symndx = r_symndx;
3a71aa26
AM		 7362 if (toc_addend != NULL)
7363 *toc_addend = ppc64_elf_section_data (sec)->u.toc.add[off / 8];
7364 if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7365 return 0;
854b41e7 7366 if ((h == NULL || is_static_defined (h))
0d4792f7
AM		 7367 && (next_r == -1 || next_r == -2))
7368 return 1 - next_r;
951fd09b 7369 return 1;
411e1bfb
AM		 7370}
7371
3b421ab3
AM		 7372/* Find (or create) an entry in the tocsave hash table. */
7373
7374static struct tocsave_entry *
7375tocsave_find (struct ppc_link_hash_table *htab,
7376 enum insert_option insert,
7377 Elf_Internal_Sym **local_syms,
7378 const Elf_Internal_Rela *irela,
7379 bfd *ibfd)
7380{
7381 unsigned long r_indx;
7382 struct elf_link_hash_entry *h;
7383 Elf_Internal_Sym *sym;
7384 struct tocsave_entry ent, *p;
7385 hashval_t hash;
7386 struct tocsave_entry **slot;
7387
7388 r_indx = ELF64_R_SYM (irela->r_info);
7389 if (!get_sym_h (&h, &sym, &ent.sec, NULL, local_syms, r_indx, ibfd))
7390 return NULL;
7391 if (ent.sec == NULL || ent.sec->output_section == NULL)
7392 {
7393 (*_bfd_error_handler)
7394 (_("%B: undefined symbol on R_PPC64_TOCSAVE relocation"));
7395 return NULL;
7396 }
7397
7398 if (h != NULL)
7399 ent.offset = h->root.u.def.value;
7400 else
7401 ent.offset = sym->st_value;
7402 ent.offset += irela->r_addend;
7403
7404 hash = tocsave_htab_hash (&ent);
7405 slot = ((struct tocsave_entry **)
7406 htab_find_slot_with_hash (htab->tocsave_htab, &ent, hash, insert));
7407 if (slot == NULL)
7408 return NULL;
7409
7410 if (*slot == NULL)
7411 {
7412 p = (struct tocsave_entry *) bfd_alloc (ibfd, sizeof (*p));
7413 if (p == NULL)
7414 return NULL;
7415 *p = ent;
7416 *slot = p;
7417 }
7418 return *slot;
7419}
7420
754021d0 7421/* Adjust all global syms defined in opd sections. In gcc generated
8387904d 7422 code for the old ABI, these will already have been done. */
754021d0
AM		 7423
7424static bfd_boolean
7425adjust_opd_syms (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
7426{
7427 struct ppc_link_hash_entry *eh;
7428 asection *sym_sec;
74f0fb50 7429 struct _opd_sec_data *opd;
754021d0
AM		 7430
7431 if (h->root.type == bfd_link_hash_indirect)
7432 return TRUE;
7433
754021d0
AM		 7434 if (h->root.type != bfd_link_hash_defined
7435 && h->root.type != bfd_link_hash_defweak)
7436 return TRUE;
7437
7438 eh = (struct ppc_link_hash_entry *) h;
7439 if (eh->adjust_done)
7440 return TRUE;
7441
7442 sym_sec = eh->elf.root.u.def.section;
74f0fb50
AM		 7443 opd = get_opd_info (sym_sec);
7444 if (opd != NULL && opd->adjust != NULL)
754021d0 7445 {
51aecdc5 7446 long adjust = opd->adjust[OPD_NDX (eh->elf.root.u.def.value)];
4025353c
AM		 7447 if (adjust == -1)
7448 {
7449 /* This entry has been deleted. */
b3fac117 7450 asection *dsec = ppc64_elf_tdata (sym_sec->owner)->deleted_section;
81688140
AM		 7451 if (dsec == NULL)
7452 {
7453 for (dsec = sym_sec->owner->sections; dsec; dsec = dsec->next)
dbaa2011 7454 if (discarded_section (dsec))
81688140 7455 {
b3fac117 7456 ppc64_elf_tdata (sym_sec->owner)->deleted_section = dsec;
81688140
AM		 7457 break;
7458 }
7459 }
4025353c 7460 eh->elf.root.u.def.value = 0;
81688140 7461 eh->elf.root.u.def.section = dsec;
4025353c
AM		 7462 }
7463 else
7464 eh->elf.root.u.def.value += adjust;
754021d0
AM		 7465 eh->adjust_done = 1;
7466 }
7467 return TRUE;
7468}
7469
8c1d1bb8 7470/* Handles decrementing dynamic reloc counts for the reloc specified by
19e08130 7471 R_INFO in section SEC. If LOCAL_SYMS is NULL, then H and SYM
8c1d1bb8
AM		 7472 have already been determined. */
7473
7474static bfd_boolean
7475dec_dynrel_count (bfd_vma r_info,
7476 asection *sec,
7477 struct bfd_link_info *info,
7478 Elf_Internal_Sym **local_syms,
7479 struct elf_link_hash_entry *h,
19e08130 7480 Elf_Internal_Sym *sym)
8c1d1bb8
AM		 7481{
7482 enum elf_ppc64_reloc_type r_type;
19e08130 7483 asection *sym_sec = NULL;
8c1d1bb8
AM		 7484
7485 /* Can this reloc be dynamic? This switch, and later tests here
7486 should be kept in sync with the code in check_relocs. */
7487 r_type = ELF64_R_TYPE (r_info);
7488 switch (r_type)
7489 {
7490 default:
7491 return TRUE;
7492
7493 case R_PPC64_TPREL16:
7494 case R_PPC64_TPREL16_LO:
7495 case R_PPC64_TPREL16_HI:
7496 case R_PPC64_TPREL16_HA:
7497 case R_PPC64_TPREL16_DS:
7498 case R_PPC64_TPREL16_LO_DS:
f9c6b907
AM		 7499 case R_PPC64_TPREL16_HIGH:
7500 case R_PPC64_TPREL16_HIGHA:
8c1d1bb8
AM		 7501 case R_PPC64_TPREL16_HIGHER:
7502 case R_PPC64_TPREL16_HIGHERA:
7503 case R_PPC64_TPREL16_HIGHEST:
7504 case R_PPC64_TPREL16_HIGHESTA:
7505 if (!info->shared)
7506 return TRUE;
7507
7508 case R_PPC64_TPREL64:
7509 case R_PPC64_DTPMOD64:
7510 case R_PPC64_DTPREL64:
7511 case R_PPC64_ADDR64:
7512 case R_PPC64_REL30:
7513 case R_PPC64_REL32:
7514 case R_PPC64_REL64:
7515 case R_PPC64_ADDR14:
7516 case R_PPC64_ADDR14_BRNTAKEN:
7517 case R_PPC64_ADDR14_BRTAKEN:
7518 case R_PPC64_ADDR16:
7519 case R_PPC64_ADDR16_DS:
7520 case R_PPC64_ADDR16_HA:
7521 case R_PPC64_ADDR16_HI:
f9c6b907
AM		 7522 case R_PPC64_ADDR16_HIGH:
7523 case R_PPC64_ADDR16_HIGHA:
8c1d1bb8
AM		 7524 case R_PPC64_ADDR16_HIGHER:
7525 case R_PPC64_ADDR16_HIGHERA:
7526 case R_PPC64_ADDR16_HIGHEST:
7527 case R_PPC64_ADDR16_HIGHESTA:
7528 case R_PPC64_ADDR16_LO:
7529 case R_PPC64_ADDR16_LO_DS:
7530 case R_PPC64_ADDR24:
7531 case R_PPC64_ADDR32:
7532 case R_PPC64_UADDR16:
7533 case R_PPC64_UADDR32:
7534 case R_PPC64_UADDR64:
7535 case R_PPC64_TOC:
7536 break;
7537 }
7538
7539 if (local_syms != NULL)
7540 {
7541 unsigned long r_symndx;
8c1d1bb8
AM		 7542 bfd *ibfd = sec->owner;
7543
7544 r_symndx = ELF64_R_SYM (r_info);
7545 if (!get_sym_h (&h, &sym, &sym_sec, NULL, local_syms, r_symndx, ibfd))
7546 return FALSE;
7547 }
7548
7549 if ((info->shared
1d483afe 7550 && (must_be_dyn_reloc (info, r_type)
8c1d1bb8 7551 || (h != NULL
198f1157 7552 && (!SYMBOLIC_BIND (info, h)
8c1d1bb8
AM		 7553 || h->root.type == bfd_link_hash_defweak
7554 || !h->def_regular))))
7555 || (ELIMINATE_COPY_RELOCS
7556 && !info->shared
7557 && h != NULL
7558 && (h->root.type == bfd_link_hash_defweak
7559 || !h->def_regular)))
7560 ;
7561 else
7562 return TRUE;
7563
7564 if (h != NULL)
6edfbbad 7565 {
19e08130
AM		 7566 struct elf_dyn_relocs *p;
7567 struct elf_dyn_relocs **pp;
7568 pp = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
7569
7570 /* elf_gc_sweep may have already removed all dyn relocs associated
7571 with local syms for a given section. Also, symbol flags are
7572 changed by elf_gc_sweep_symbol, confusing the test above. Don't
7573 report a dynreloc miscount. */
7574 if (*pp == NULL && info->gc_sections)
7575 return TRUE;
7576
7577 while ((p = *pp) != NULL)
60124e18 7578 {
19e08130
AM		 7579 if (p->sec == sec)
7580 {
7581 if (!must_be_dyn_reloc (info, r_type))
7582 p->pc_count -= 1;
7583 p->count -= 1;
7584 if (p->count == 0)
7585 *pp = p->next;
7586 return TRUE;
7587 }
7588 pp = &p->next;
60124e18 7589 }
6edfbbad 7590 }
19e08130
AM		 7591 else
7592 {
7593 struct ppc_dyn_relocs *p;
7594 struct ppc_dyn_relocs **pp;
7595 void *vpp;
7596 bfd_boolean is_ifunc;
8c1d1bb8 7597
19e08130
AM		 7598 if (local_syms == NULL)
7599 sym_sec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
7600 if (sym_sec == NULL)
7601 sym_sec = sec;
c57da1a7 7602
19e08130
AM		 7603 vpp = &elf_section_data (sym_sec)->local_dynrel;
7604 pp = (struct ppc_dyn_relocs **) vpp;
7605
7606 if (*pp == NULL && info->gc_sections)
7607 return TRUE;
7608
7609 is_ifunc = ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC;
7610 while ((p = *pp) != NULL)
8c1d1bb8 7611 {
19e08130
AM		 7612 if (p->sec == sec && p->ifunc == is_ifunc)
7613 {
7614 p->count -= 1;
7615 if (p->count == 0)
7616 *pp = p->next;
7617 return TRUE;
7618 }
7619 pp = &p->next;
8c1d1bb8 7620 }
8c1d1bb8
AM		 7621 }
7622
8de848d8 7623 info->callbacks->einfo (_("%P: dynreloc miscount for %B, section %A\n"),
25f53a85 7624 sec->owner, sec);
8c1d1bb8
AM		 7625 bfd_set_error (bfd_error_bad_value);
7626 return FALSE;
7627}
7628
754021d0
AM		 7629/* Remove unused Official Procedure Descriptor entries. Currently we
7630 only remove those associated with functions in discarded link-once
7631 sections, or weakly defined functions that have been overridden. It
7632 would be possible to remove many more entries for statically linked
7633 applications. */
7634
b34976b6 7635bfd_boolean
e7d1c40c 7636ppc64_elf_edit_opd (struct bfd_link_info *info)
1e2f5b6e
AM		 7637{
7638 bfd *ibfd;
754021d0 7639 bfd_boolean some_edited = FALSE;
3f764659 7640 asection *need_pad = NULL;
e7d1c40c
AM		 7641 struct ppc_link_hash_table *htab;
7642
7643 htab = ppc_hash_table (info);
7644 if (htab == NULL)
7645 return FALSE;
1e2f5b6e 7646
c72f2fb2 7647 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
1e2f5b6e
AM		 7648 {
7649 asection *sec;
7650 Elf_Internal_Rela *relstart, *rel, *relend;
7651 Elf_Internal_Shdr *symtab_hdr;
6cdc0ccc 7652 Elf_Internal_Sym *local_syms;
74f0fb50 7653 struct _opd_sec_data *opd;
51aecdc5 7654 bfd_boolean need_edit, add_aux_fields, broken;
3f764659 7655 bfd_size_type cnt_16b = 0;
1e2f5b6e 7656
854b41e7
AM		 7657 if (!is_ppc64_elf (ibfd))
7658 continue;
7659
1e2f5b6e 7660 sec = bfd_get_section_by_name (ibfd, ".opd");
46de2a7c 7661 if (sec == NULL || sec->size == 0)
1e2f5b6e
AM		 7662 continue;
7663
dbaa2011 7664 if (sec->sec_info_type == SEC_INFO_TYPE_JUST_SYMS)
4b85d634
AM		 7665 continue;
7666
1e2f5b6e
AM		 7667 if (sec->output_section == bfd_abs_section_ptr)
7668 continue;
7669
7670 /* Look through the section relocs. */
7671 if ((sec->flags & SEC_RELOC) == 0 || sec->reloc_count == 0)
7672 continue;
7673
6cdc0ccc 7674 local_syms = NULL;
0ffa91dd 7675 symtab_hdr = &elf_symtab_hdr (ibfd);
1e2f5b6e
AM		 7676
7677 /* Read the relocations. */
4ce794b7 7678 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
45d6a902 7679 info->keep_memory);
1e2f5b6e 7680 if (relstart == NULL)
b34976b6 7681 return FALSE;
1e2f5b6e
AM		 7682
7683 /* First run through the relocs to check they are sane, and to
7684 determine whether we need to edit this opd section. */
b34976b6 7685 need_edit = FALSE;
51aecdc5 7686 broken = FALSE;
3f764659 7687 need_pad = sec;
1e2f5b6e 7688 relend = relstart + sec->reloc_count;
50bc7936 7689 for (rel = relstart; rel < relend; )
1e2f5b6e 7690 {
04c9666a 7691 enum elf_ppc64_reloc_type r_type;
1e2f5b6e
AM		 7692 unsigned long r_symndx;
7693 asection *sym_sec;
7694 struct elf_link_hash_entry *h;
7695 Elf_Internal_Sym *sym;
51aecdc5 7696 bfd_vma offset;
1e2f5b6e 7697
51aecdc5 7698 /* .opd contains an array of 16 or 24 byte entries. We're
1e2f5b6e
AM		 7699 only interested in the reloc pointing to a function entry
7700 point. */
51aecdc5
AM		 7701 offset = rel->r_offset;
7702 if (rel + 1 == relend
7703 || rel[1].r_offset != offset + 8)
1e2f5b6e
AM		 7704 {
7705 /* If someone messes with .opd alignment then after a
7706 "ld -r" we might have padding in the middle of .opd.
7707 Also, there's nothing to prevent someone putting
7708 something silly in .opd with the assembler. No .opd
b34976b6 7709 optimization for them! */
3f764659 7710 broken_opd:
1e2f5b6e 7711 (*_bfd_error_handler)
d003868e 7712 (_("%B: .opd is not a regular array of opd entries"), ibfd);
51aecdc5 7713 broken = TRUE;
1e2f5b6e
AM		 7714 break;
7715 }
7716
50bc7936
AM		 7717 if ((r_type = ELF64_R_TYPE (rel->r_info)) != R_PPC64_ADDR64
7718 || (r_type = ELF64_R_TYPE ((rel + 1)->r_info)) != R_PPC64_TOC)
7719 {
7720 (*_bfd_error_handler)
d003868e
AM		 7721 (_("%B: unexpected reloc type %u in .opd section"),
7722 ibfd, r_type);
51aecdc5 7723 broken = TRUE;
50bc7936
AM		 7724 break;
7725 }
7726
1e2f5b6e 7727 r_symndx = ELF64_R_SYM (rel->r_info);
411e1bfb
AM		 7728 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7729 r_symndx, ibfd))
50bc7936 7730 goto error_ret;
1e2f5b6e
AM		 7731
7732 if (sym_sec == NULL || sym_sec->owner == NULL)
7733 {
411e1bfb
AM		 7734 const char *sym_name;
7735 if (h != NULL)
7736 sym_name = h->root.root.string;
7737 else
26c61ae5
L		 7738 sym_name = bfd_elf_sym_name (ibfd, symtab_hdr, sym,
7739 sym_sec);
411e1bfb 7740
1e2f5b6e 7741 (*_bfd_error_handler)
d003868e
AM		 7742 (_("%B: undefined sym `%s' in .opd section"),
7743 ibfd, sym_name);
51aecdc5 7744 broken = TRUE;
1e2f5b6e
AM		 7745 break;
7746 }
7747
51020317
AM		 7748 /* opd entries are always for functions defined in the
7749 current input bfd. If the symbol isn't defined in the
7750 input bfd, then we won't be using the function in this
7751 bfd; It must be defined in a linkonce section in another
7752 bfd, or is weak. It's also possible that we are
7753 discarding the function due to a linker script /DISCARD/,
7754 which we test for via the output_section. */
7755 if (sym_sec->owner != ibfd
7756 || sym_sec->output_section == bfd_abs_section_ptr)
b34976b6 7757 need_edit = TRUE;
1e2f5b6e 7758
50bc7936 7759 rel += 2;
51aecdc5
AM		 7760 if (rel + 1 == relend
7761 || (rel + 2 < relend
7762 && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_TOC))
7763 ++rel;
7764
7765 if (rel == relend)
3f764659
JJ		 7766 {
7767 if (sec->size == offset + 24)
7768 {
7769 need_pad = NULL;
7770 break;
7771 }
51aecdc5 7772 if (sec->size == offset + 16)
3f764659
JJ		 7773 {
7774 cnt_16b++;
7775 break;
7776 }
7777 goto broken_opd;
7778 }
3f764659
JJ		 7779 else if (rel + 1 < relend
7780 && ELF64_R_TYPE (rel[0].r_info) == R_PPC64_ADDR64
7781 && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOC)
7782 {
51aecdc5
AM		 7783 if (rel[0].r_offset == offset + 16)
7784 cnt_16b++;
7785 else if (rel[0].r_offset != offset + 24)
7786 goto broken_opd;
3f764659
JJ		 7787 }
7788 else
7789 goto broken_opd;
1e2f5b6e
AM		 7790 }
7791
e7d1c40c 7792 add_aux_fields = htab->params->non_overlapping_opd && cnt_16b > 0;
3f764659 7793
51aecdc5 7794 if (!broken && (need_edit || add_aux_fields))
1e2f5b6e
AM		 7795 {
7796 Elf_Internal_Rela *write_rel;
d4730f92 7797 Elf_Internal_Shdr *rel_hdr;
1e2f5b6e 7798 bfd_byte *rptr, *wptr;
983bddc8 7799 bfd_byte *new_contents;
74f0fb50
AM		 7800 bfd_size_type amt;
7801
983bddc8 7802 new_contents = NULL;
51aecdc5 7803 amt = OPD_NDX (sec->size) * sizeof (long);
74f0fb50 7804 opd = &ppc64_elf_section_data (sec)->u.opd;
33c0ec9d 7805 opd->adjust = bfd_zalloc (sec->owner, amt);
74f0fb50
AM		 7806 if (opd->adjust == NULL)
7807 return FALSE;
7808 ppc64_elf_section_data (sec)->sec_type = sec_opd;
1e2f5b6e
AM		 7809
7810 /* This seems a waste of time as input .opd sections are all
7811 zeros as generated by gcc, but I suppose there's no reason
7812 this will always be so. We might start putting something in
7813 the third word of .opd entries. */
7814 if ((sec->flags & SEC_IN_MEMORY) == 0)
7815 {
eea6121a
AM		 7816 bfd_byte *loc;
7817 if (!bfd_malloc_and_get_section (ibfd, sec, &loc))
6cdc0ccc 7818 {
eea6121a
AM		 7819 if (loc != NULL)
7820 free (loc);
50bc7936 7821 error_ret:
6cdc0ccc
AM		 7822 if (local_syms != NULL
7823 && symtab_hdr->contents != (unsigned char *) local_syms)
7824 free (local_syms);
6cdc0ccc
AM		 7825 if (elf_section_data (sec)->relocs != relstart)
7826 free (relstart);
b34976b6 7827 return FALSE;
6cdc0ccc 7828 }
1e2f5b6e
AM		 7829 sec->contents = loc;
7830 sec->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
7831 }
7832
7833 elf_section_data (sec)->relocs = relstart;
7834
3f764659 7835 new_contents = sec->contents;
3f764659
JJ		 7836 if (add_aux_fields)
7837 {
7838 new_contents = bfd_malloc (sec->size + cnt_16b * 8);
7839 if (new_contents == NULL)
7840 return FALSE;
51aecdc5 7841 need_pad = NULL;
3f764659 7842 }
b4f4e59f
AM		 7843 wptr = new_contents;
7844 rptr = sec->contents;
1e2f5b6e 7845 write_rel = relstart;
51aecdc5 7846 for (rel = relstart; rel < relend; )
1e2f5b6e 7847 {
50bc7936
AM		 7848 unsigned long r_symndx;
7849 asection *sym_sec;
7850 struct elf_link_hash_entry *h;
51aecdc5 7851 struct ppc_link_hash_entry *fdh = NULL;
50bc7936 7852 Elf_Internal_Sym *sym;
51aecdc5
AM		 7853 long opd_ent_size;
7854 Elf_Internal_Rela *next_rel;
7855 bfd_boolean skip;
50bc7936
AM		 7856
7857 r_symndx = ELF64_R_SYM (rel->r_info);
7858 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
d37c89e5 7859 r_symndx, ibfd))
50bc7936
AM		 7860 goto error_ret;
7861
51aecdc5
AM		 7862 next_rel = rel + 2;
7863 if (next_rel + 1 == relend
7864 || (next_rel + 2 < relend
7865 && ELF64_R_TYPE (next_rel[2].r_info) == R_PPC64_TOC))
7866 ++next_rel;
7867
7868 /* See if the .opd entry is full 24 byte or
7869 16 byte (with fd_aux entry overlapped with next
7870 fd_func). */
7871 opd_ent_size = 24;
7872 if (next_rel == relend)
1e2f5b6e 7873 {
51aecdc5 7874 if (sec->size == rel->r_offset + 16)
3f764659 7875 opd_ent_size = 16;
51aecdc5
AM		 7876 }
7877 else if (next_rel->r_offset == rel->r_offset + 16)
7878 opd_ent_size = 16;
3f764659 7879
51aecdc5
AM		 7880 if (h != NULL
7881 && h->root.root.string[0] == '.')
7882 {
7883 fdh = lookup_fdh ((struct ppc_link_hash_entry *) h, htab);
7884 if (fdh != NULL
7885 && fdh->elf.root.type != bfd_link_hash_defined
7886 && fdh->elf.root.type != bfd_link_hash_defweak)
7887 fdh = NULL;
7888 }
1e2f5b6e 7889
51aecdc5
AM		 7890 skip = (sym_sec->owner != ibfd
7891 || sym_sec->output_section == bfd_abs_section_ptr);
7892 if (skip)
7893 {
7894 if (fdh != NULL && sym_sec->owner == ibfd)
a4aa0fb7 7895 {
51aecdc5
AM		 7896 /* Arrange for the function descriptor sym
7897 to be dropped. */
7898 fdh->elf.root.u.def.value = 0;
7899 fdh->elf.root.u.def.section = sym_sec;
a4aa0fb7 7900 }
51aecdc5 7901 opd->adjust[OPD_NDX (rel->r_offset)] = -1;
1e2f5b6e 7902
51aecdc5
AM		 7903 if (NO_OPD_RELOCS || info->relocatable)
7904 rel = next_rel;
7905 else
7906 while (1)
7907 {
7908 if (!dec_dynrel_count (rel->r_info, sec, info,
7909 NULL, h, sym))
7910 goto error_ret;
754021d0 7911
51aecdc5
AM		 7912 if (++rel == next_rel)
7913 break;
1e2f5b6e 7914
51aecdc5
AM		 7915 r_symndx = ELF64_R_SYM (rel->r_info);
7916 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7917 r_symndx, ibfd))
7918 goto error_ret;
7919 }
50bc7936
AM		 7920 }
7921 else
1e2f5b6e 7922 {
51aecdc5
AM		 7923 /* We'll be keeping this opd entry. */
7924 long adjust;
7925
7926 if (fdh != NULL)
7927 {
7928 /* Redefine the function descriptor symbol to
7929 this location in the opd section. It is
7930 necessary to update the value here rather
7931 than using an array of adjustments as we do
7932 for local symbols, because various places
7933 in the generic ELF code use the value
7934 stored in u.def.value. */
7935 fdh->elf.root.u.def.value = wptr - new_contents;
7936 fdh->adjust_done = 1;
7937 }
7938
7939 /* Local syms are a bit tricky. We could
7940 tweak them as they can be cached, but
7941 we'd need to look through the local syms
7942 for the function descriptor sym which we
7943 don't have at the moment. So keep an
7944 array of adjustments. */
7945 adjust = (wptr - new_contents) - (rptr - sec->contents);
7946 opd->adjust[OPD_NDX (rel->r_offset)] = adjust;
7947
7948 if (wptr != rptr)
7949 memcpy (wptr, rptr, opd_ent_size);
7950 wptr += opd_ent_size;
7951 if (add_aux_fields && opd_ent_size == 16)
7952 {
7953 memset (wptr, '\0', 8);
7954 wptr += 8;
7955 }
7956
50bc7936 7957 /* We need to adjust any reloc offsets to point to the
51aecdc5
AM		 7958 new opd entries. */
7959 for ( ; rel != next_rel; ++rel)
7960 {
7961 rel->r_offset += adjust;
7962 if (write_rel != rel)
7963 memcpy (write_rel, rel, sizeof (*rel));
7964 ++write_rel;
7965 }
1e2f5b6e 7966 }
51aecdc5
AM		 7967
7968 rptr += opd_ent_size;
1e2f5b6e
AM		 7969 }
7970
3f764659 7971 sec->size = wptr - new_contents;
1e2f5b6e 7972 sec->reloc_count = write_rel - relstart;
3f764659
JJ		 7973 if (add_aux_fields)
7974 {
7975 free (sec->contents);
7976 sec->contents = new_contents;
7977 }
7978
05bf9422 7979 /* Fudge the header size too, as this is used later in
cdcf6e38 7980 elf_bfd_final_link if we are emitting relocs. */
d4730f92
BS		 7981 rel_hdr = _bfd_elf_single_rel_hdr (sec);
7982 rel_hdr->sh_size = sec->reloc_count * rel_hdr->sh_entsize;
754021d0 7983 some_edited = TRUE;
1e2f5b6e 7984 }
6cdc0ccc 7985 else if (elf_section_data (sec)->relocs != relstart)
1e2f5b6e 7986 free (relstart);
6cdc0ccc 7987
411e1bfb
AM		 7988 if (local_syms != NULL
7989 && symtab_hdr->contents != (unsigned char *) local_syms)
7990 {
7991 if (!info->keep_memory)
7992 free (local_syms);
7993 else
7994 symtab_hdr->contents = (unsigned char *) local_syms;
7995 }
7996 }
7997
754021d0
AM		 7998 if (some_edited)
7999 elf_link_hash_traverse (elf_hash_table (info), adjust_opd_syms, NULL);
8000
3f764659
JJ		 8001 /* If we are doing a final link and the last .opd entry is just 16 byte
8002 long, add a 8 byte padding after it. */
8003 if (need_pad != NULL && !info->relocatable)
8004 {
8005 bfd_byte *p;
8006
8007 if ((need_pad->flags & SEC_IN_MEMORY) == 0)
8008 {
8009 BFD_ASSERT (need_pad->size > 0);
8010
8011 p = bfd_malloc (need_pad->size + 8);
8012 if (p == NULL)
8013 return FALSE;
699733f6 8014
3f764659
JJ		 8015 if (! bfd_get_section_contents (need_pad->owner, need_pad,
8016 p, 0, need_pad->size))
8017 return FALSE;
8018
8019 need_pad->contents = p;
8020 need_pad->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
8021 }
8022 else
8023 {
8024 p = bfd_realloc (need_pad->contents, need_pad->size + 8);
8025 if (p == NULL)
8026 return FALSE;
8027
8028 need_pad->contents = p;
8029 }
8030
8031 memset (need_pad->contents + need_pad->size, 0, 8);
8032 need_pad->size += 8;
8033 }
8034
411e1bfb
AM		 8035 return TRUE;
8036}
8037
e1918d23 8038/* Set htab->tls_get_addr and call the generic ELF tls_setup function. */
411e1bfb 8039
e1918d23 8040asection *
e7d1c40c 8041ppc64_elf_tls_setup (struct bfd_link_info *info)
411e1bfb 8042{
411e1bfb
AM		 8043 struct ppc_link_hash_table *htab;
8044
411e1bfb 8045 htab = ppc_hash_table (info);
4dfe6ac6
NC		 8046 if (htab == NULL)
8047 return NULL;
8048
ee67d69a
AM		 8049 if (abiversion (info->output_bfd) == 1)
8050 htab->opd_abi = 1;
8051
e7d1c40c 8052 if (htab->params->no_multi_toc)
33c0ec9d
AM		 8053 htab->do_multi_toc = 0;
8054 else if (!htab->do_multi_toc)
e7d1c40c 8055 htab->params->no_multi_toc = 1;
33c0ec9d 8056
3a71aa26
AM		 8057 htab->tls_get_addr = ((struct ppc_link_hash_entry *)
8058 elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
8059 FALSE, FALSE, TRUE));
a7f2871e
AM		 8060 /* Move dynamic linking info to the function descriptor sym. */
8061 if (htab->tls_get_addr != NULL)
8062 func_desc_adjust (&htab->tls_get_addr->elf, info);
3a71aa26
AM		 8063 htab->tls_get_addr_fd = ((struct ppc_link_hash_entry *)
8064 elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
8065 FALSE, FALSE, TRUE));
e7d1c40c 8066 if (!htab->params->no_tls_get_addr_opt)
a7f2871e
AM		 8067 {
8068 struct elf_link_hash_entry *opt, *opt_fd, *tga, *tga_fd;
8069
8070 opt = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr_opt",
8071 FALSE, FALSE, TRUE);
8072 if (opt != NULL)
8073 func_desc_adjust (opt, info);
8074 opt_fd = elf_link_hash_lookup (&htab->elf, "__tls_get_addr_opt",
8075 FALSE, FALSE, TRUE);
8076 if (opt_fd != NULL
8077 && (opt_fd->root.type == bfd_link_hash_defined
8078 || opt_fd->root.type == bfd_link_hash_defweak))
8079 {
8080 /* If glibc supports an optimized __tls_get_addr call stub,
8081 signalled by the presence of __tls_get_addr_opt, and we'll
8082 be calling __tls_get_addr via a plt call stub, then
8083 make __tls_get_addr point to __tls_get_addr_opt. */
8084 tga_fd = &htab->tls_get_addr_fd->elf;
8085 if (htab->elf.dynamic_sections_created
8086 && tga_fd != NULL
8087 && (tga_fd->type == STT_FUNC
8088 || tga_fd->needs_plt)
8089 && !(SYMBOL_CALLS_LOCAL (info, tga_fd)
8090 || (ELF_ST_VISIBILITY (tga_fd->other) != STV_DEFAULT
8091 && tga_fd->root.type == bfd_link_hash_undefweak)))
8092 {
8093 struct plt_entry *ent;
8094
8095 for (ent = tga_fd->plt.plist; ent != NULL; ent = ent->next)
8096 if (ent->plt.refcount > 0)
8097 break;
8098 if (ent != NULL)
8099 {
8100 tga_fd->root.type = bfd_link_hash_indirect;
8101 tga_fd->root.u.i.link = &opt_fd->root;
8102 ppc64_elf_copy_indirect_symbol (info, opt_fd, tga_fd);
8103 if (opt_fd->dynindx != -1)
8104 {
8105 /* Use __tls_get_addr_opt in dynamic relocations. */
8106 opt_fd->dynindx = -1;
8107 _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
8108 opt_fd->dynstr_index);
8109 if (!bfd_elf_link_record_dynamic_symbol (info, opt_fd))
854b41e7 8110 return NULL;
a7f2871e
AM		 8111 }
8112 htab->tls_get_addr_fd = (struct ppc_link_hash_entry *) opt_fd;
8113 tga = &htab->tls_get_addr->elf;
8114 if (opt != NULL && tga != NULL)
8115 {
8116 tga->root.type = bfd_link_hash_indirect;
8117 tga->root.u.i.link = &opt->root;
8118 ppc64_elf_copy_indirect_symbol (info, opt, tga);
8119 _bfd_elf_link_hash_hide_symbol (info, opt,
8120 tga->forced_local);
8121 htab->tls_get_addr = (struct ppc_link_hash_entry *) opt;
8122 }
8123 htab->tls_get_addr_fd->oh = htab->tls_get_addr;
8124 htab->tls_get_addr_fd->is_func_descriptor = 1;
8125 if (htab->tls_get_addr != NULL)
8126 {
8127 htab->tls_get_addr->oh = htab->tls_get_addr_fd;
8128 htab->tls_get_addr->is_func = 1;
8129 }
8130 }
8131 }
8132 }
8133 else
e7d1c40c 8134 htab->params->no_tls_get_addr_opt = TRUE;
a7f2871e 8135 }
33c0ec9d 8136 return _bfd_elf_tls_setup (info->output_bfd, info);
3a71aa26 8137}
8387904d 8138
3a71aa26
AM		 8139/* Return TRUE iff REL is a branch reloc with a global symbol matching
8140 HASH1 or HASH2. */
8387904d 8141
3a71aa26
AM		 8142static bfd_boolean
8143branch_reloc_hash_match (const bfd *ibfd,
8144 const Elf_Internal_Rela *rel,
8145 const struct ppc_link_hash_entry *hash1,
8146 const struct ppc_link_hash_entry *hash2)
8147{
8148 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
8149 enum elf_ppc64_reloc_type r_type = ELF64_R_TYPE (rel->r_info);
8150 unsigned int r_symndx = ELF64_R_SYM (rel->r_info);
8151
e054468f 8152 if (r_symndx >= symtab_hdr->sh_info && is_branch_reloc (r_type))
8387904d 8153 {
3a71aa26
AM		 8154 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
8155 struct elf_link_hash_entry *h;
8387904d 8156
3a71aa26 8157 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
b31867b6 8158 h = elf_follow_link (h);
3a71aa26
AM		 8159 if (h == &hash1->elf || h == &hash2->elf)
8160 return TRUE;
a48ebf4d 8161 }
3a71aa26 8162 return FALSE;
951fd09b 8163}
411e1bfb 8164
951fd09b
AM		 8165/* Run through all the TLS relocs looking for optimization
8166 opportunities. The linker has been hacked (see ppc64elf.em) to do
8167 a preliminary section layout so that we know the TLS segment
8168 offsets. We can't optimize earlier because some optimizations need
8169 to know the tp offset, and we need to optimize before allocating
8170 dynamic relocations. */
8171
8172bfd_boolean
33c0ec9d 8173ppc64_elf_tls_optimize (struct bfd_link_info *info)
951fd09b
AM		 8174{
8175 bfd *ibfd;
8176 asection *sec;
8177 struct ppc_link_hash_table *htab;
663a1470 8178 unsigned char *toc_ref;
102890f0 8179 int pass;
951fd09b 8180
1d483afe 8181 if (info->relocatable || !info->executable)
411e1bfb
AM		 8182 return TRUE;
8183
951fd09b 8184 htab = ppc_hash_table (info);
4dfe6ac6
NC		 8185 if (htab == NULL)
8186 return FALSE;
8187
663a1470
AM		 8188 /* Make two passes over the relocs. On the first pass, mark toc
8189 entries involved with tls relocs, and check that tls relocs
8190 involved in setting up a tls_get_addr call are indeed followed by
8191 such a call. If they are not, we can't do any tls optimization.
8192 On the second pass twiddle tls_mask flags to notify
8193 relocate_section that optimization can be done, and adjust got
8194 and plt refcounts. */
8195 toc_ref = NULL;
8196 for (pass = 0; pass < 2; ++pass)
c72f2fb2 8197 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
663a1470
AM		 8198 {
8199 Elf_Internal_Sym *locsyms = NULL;
8200 asection *toc = bfd_get_section_by_name (ibfd, ".toc");
8201
102890f0
AM		 8202 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8203 if (sec->has_tls_reloc && !bfd_is_abs_section (sec->output_section))
8204 {
8205 Elf_Internal_Rela *relstart, *rel, *relend;
663a1470 8206 bfd_boolean found_tls_get_addr_arg = 0;
411e1bfb 8207
102890f0
AM		 8208 /* Read the relocations. */
8209 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8210 info->keep_memory);
8211 if (relstart == NULL)
2915c55b
JK		 8212 {
8213 free (toc_ref);
8214 return FALSE;
8215 }
411e1bfb 8216
102890f0
AM		 8217 relend = relstart + sec->reloc_count;
8218 for (rel = relstart; rel < relend; rel++)
8219 {
8220 enum elf_ppc64_reloc_type r_type;
8221 unsigned long r_symndx;
8222 struct elf_link_hash_entry *h;
8223 Elf_Internal_Sym *sym;
8224 asection *sym_sec;
f961d9dd
AM		 8225 unsigned char *tls_mask;
8226 unsigned char tls_set, tls_clear, tls_type = 0;
102890f0
AM		 8227 bfd_vma value;
8228 bfd_boolean ok_tprel, is_local;
8229 long toc_ref_index = 0;
8230 int expecting_tls_get_addr = 0;
663a1470 8231 bfd_boolean ret = FALSE;
411e1bfb 8232
102890f0
AM		 8233 r_symndx = ELF64_R_SYM (rel->r_info);
8234 if (!get_sym_h (&h, &sym, &sym_sec, &tls_mask, &locsyms,
8235 r_symndx, ibfd))
8236 {
8237 err_free_rel:
8238 if (elf_section_data (sec)->relocs != relstart)
8239 free (relstart);
8240 if (toc_ref != NULL)
8241 free (toc_ref);
8242 if (locsyms != NULL
0ffa91dd 8243 && (elf_symtab_hdr (ibfd).contents
102890f0
AM		 8244 != (unsigned char *) locsyms))
8245 free (locsyms);
663a1470 8246 return ret;
102890f0 8247 }
411e1bfb 8248
102890f0
AM		 8249 if (h != NULL)
8250 {
766bc656
AM		 8251 if (h->root.type == bfd_link_hash_defined
8252 || h->root.type == bfd_link_hash_defweak)
8253 value = h->root.u.def.value;
8254 else if (h->root.type == bfd_link_hash_undefweak)
8255 value = 0;
8256 else
663a1470
AM		 8257 {
8258 found_tls_get_addr_arg = 0;
8259 continue;
8260 }
102890f0
AM		 8261 }
8262 else
8263 /* Symbols referenced by TLS relocs must be of type
8264 STT_TLS. So no need for .opd local sym adjust. */
8265 value = sym->st_value;
8266
8267 ok_tprel = FALSE;
8268 is_local = FALSE;
8269 if (h == NULL
8270 || !h->def_dynamic)
8271 {
8272 is_local = TRUE;
766bc656
AM		 8273 if (h != NULL
8274 && h->root.type == bfd_link_hash_undefweak)
8275 ok_tprel = TRUE;
8276 else
8277 {
8278 value += sym_sec->output_offset;
8279 value += sym_sec->output_section->vma;
8280 value -= htab->elf.tls_sec->vma;
8281 ok_tprel = (value + TP_OFFSET + ((bfd_vma) 1 << 31)
8282 < (bfd_vma) 1 << 32);
8283 }
102890f0 8284 }
951fd09b 8285
102890f0 8286 r_type = ELF64_R_TYPE (rel->r_info);
663a1470
AM		 8287 /* If this section has old-style __tls_get_addr calls
8288 without marker relocs, then check that each
8289 __tls_get_addr call reloc is preceded by a reloc
8290 that conceivably belongs to the __tls_get_addr arg
8291 setup insn. If we don't find matching arg setup
8292 relocs, don't do any tls optimization. */
8293 if (pass == 0
8294 && sec->has_tls_get_addr_call
8295 && h != NULL
8296 && (h == &htab->tls_get_addr->elf
8297 || h == &htab->tls_get_addr_fd->elf)
8298 && !found_tls_get_addr_arg
8299 && is_branch_reloc (r_type))
8300 {
25f53a85 8301 info->callbacks->minfo (_("%H __tls_get_addr lost arg, "
663a1470
AM		 8302 "TLS optimization disabled\n"),
8303 ibfd, sec, rel->r_offset);
8304 ret = TRUE;
8305 goto err_free_rel;
8306 }
8307
8308 found_tls_get_addr_arg = 0;
102890f0
AM		 8309 switch (r_type)
8310 {
8311 case R_PPC64_GOT_TLSLD16:
8312 case R_PPC64_GOT_TLSLD16_LO:
8313 expecting_tls_get_addr = 1;
663a1470 8314 found_tls_get_addr_arg = 1;
102890f0
AM		 8315 /* Fall thru */
8316
8317 case R_PPC64_GOT_TLSLD16_HI:
8318 case R_PPC64_GOT_TLSLD16_HA:
8319 /* These relocs should never be against a symbol
8320 defined in a shared lib. Leave them alone if
8321 that turns out to be the case. */
8322 if (!is_local)
8323 continue;
411e1bfb 8324
102890f0 8325 /* LD -> LE */
411e1bfb 8326 tls_set = 0;
102890f0
AM		 8327 tls_clear = TLS_LD;
8328 tls_type = TLS_TLS | TLS_LD;
8329 break;
411e1bfb 8330
102890f0
AM		 8331 case R_PPC64_GOT_TLSGD16:
8332 case R_PPC64_GOT_TLSGD16_LO:
8333 expecting_tls_get_addr = 1;
663a1470 8334 found_tls_get_addr_arg = 1;
102890f0
AM		 8335 /* Fall thru */
8336
8337 case R_PPC64_GOT_TLSGD16_HI:
8338 case R_PPC64_GOT_TLSGD16_HA:
8339 if (ok_tprel)
8340 /* GD -> LE */
411e1bfb 8341 tls_set = 0;
102890f0
AM		 8342 else
8343 /* GD -> IE */
8344 tls_set = TLS_TLS | TLS_TPRELGD;
8345 tls_clear = TLS_GD;
8346 tls_type = TLS_TLS | TLS_GD;
8347 break;
8348
8349 case R_PPC64_GOT_TPREL16_DS:
8350 case R_PPC64_GOT_TPREL16_LO_DS:
8351 case R_PPC64_GOT_TPREL16_HI:
8352 case R_PPC64_GOT_TPREL16_HA:
8353 if (ok_tprel)
8354 {
8355 /* IE -> LE */
8356 tls_set = 0;
8357 tls_clear = TLS_TPREL;
8358 tls_type = TLS_TLS | TLS_TPREL;
8359 break;
8360 }
411e1bfb
AM		 8361 continue;
8362
727fc41e
AM		 8363 case R_PPC64_TLSGD:
8364 case R_PPC64_TLSLD:
663a1470
AM		 8365 found_tls_get_addr_arg = 1;
8366 /* Fall thru */
8367
8368 case R_PPC64_TLS:
8369 case R_PPC64_TOC16:
8370 case R_PPC64_TOC16_LO:
102890f0
AM		 8371 if (sym_sec == NULL || sym_sec != toc)
8372 continue;
8373
8374 /* Mark this toc entry as referenced by a TLS
8375 code sequence. We can do that now in the
8376 case of R_PPC64_TLS, and after checking for
8377 tls_get_addr for the TOC16 relocs. */
8378 if (toc_ref == NULL)
663a1470
AM		 8379 toc_ref = bfd_zmalloc (toc->output_section->rawsize / 8);
8380 if (toc_ref == NULL)
8381 goto err_free_rel;
8382
102890f0
AM		 8383 if (h != NULL)
8384 value = h->root.u.def.value;
8385 else
8386 value = sym->st_value;
8387 value += rel->r_addend;
73242275
AM		 8388 if (value % 8 != 0)
8389 continue;
8390 BFD_ASSERT (value < toc->size
8391 && toc->output_offset % 8 == 0);
663a1470 8392 toc_ref_index = (value + toc->output_offset) / 8;
727fc41e
AM		 8393 if (r_type == R_PPC64_TLS
8394 || r_type == R_PPC64_TLSGD
8395 || r_type == R_PPC64_TLSLD)
102890f0
AM		 8396 {
8397 toc_ref[toc_ref_index] = 1;
8398 continue;
8399 }
8400
8401 if (pass != 0 && toc_ref[toc_ref_index] == 0)
8402 continue;
8403
8404 tls_set = 0;
8405 tls_clear = 0;
8406 expecting_tls_get_addr = 2;
8407 break;
8408
8409 case R_PPC64_TPREL64:
8410 if (pass == 0
8411 || sec != toc
8412 || toc_ref == NULL
663a1470 8413 || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
102890f0
AM		 8414 continue;
8415 if (ok_tprel)
8416 {
8417 /* IE -> LE */
8418 tls_set = TLS_EXPLICIT;
8419 tls_clear = TLS_TPREL;
8420 break;
8421 }
8422 continue;
8423
8424 case R_PPC64_DTPMOD64:
8425 if (pass == 0
8426 || sec != toc
8427 || toc_ref == NULL
663a1470 8428 || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
102890f0
AM		 8429 continue;
8430 if (rel + 1 < relend
8431 && (rel[1].r_info
8432 == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64))
8433 && rel[1].r_offset == rel->r_offset + 8)
8434 {
8435 if (ok_tprel)
8436 /* GD -> LE */
8437 tls_set = TLS_EXPLICIT | TLS_GD;
8438 else
8439 /* GD -> IE */
8440 tls_set = TLS_EXPLICIT | TLS_GD | TLS_TPRELGD;
8441 tls_clear = TLS_GD;
8442 }
8443 else
8444 {
8445 if (!is_local)
8446 continue;
8447
8448 /* LD -> LE */
8449 tls_set = TLS_EXPLICIT;
8450 tls_clear = TLS_LD;
8451 }
8452 break;
8453
8454 default:
8455 continue;
8456 }
8457
8458 if (pass == 0)
8459 {
727fc41e
AM		 8460 if (!expecting_tls_get_addr
8461 || !sec->has_tls_get_addr_call)
102890f0
AM		 8462 continue;
8463
3a71aa26
AM		 8464 if (rel + 1 < relend
8465 && branch_reloc_hash_match (ibfd, rel + 1,
8466 htab->tls_get_addr,
8467 htab->tls_get_addr_fd))
102890f0 8468 {
3a71aa26 8469 if (expecting_tls_get_addr == 2)
102890f0 8470 {
3a71aa26 8471 /* Check for toc tls entries. */
f961d9dd 8472 unsigned char *toc_tls;
3a71aa26
AM		 8473 int retval;
8474
8475 retval = get_tls_mask (&toc_tls, NULL, NULL,
8476 &locsyms,
8477 rel, ibfd);
8478 if (retval == 0)
8479 goto err_free_rel;
663a1470
AM		 8480 if (toc_tls != NULL)
8481 {
8482 if ((*toc_tls & (TLS_GD | TLS_LD)) != 0)
8483 found_tls_get_addr_arg = 1;
8484 if (retval > 1)
8485 toc_ref[toc_ref_index] = 1;
8486 }
102890f0 8487 }
3a71aa26 8488 continue;
102890f0
AM		 8489 }
8490
8491 if (expecting_tls_get_addr != 1)
8492 continue;
8493
8494 /* Uh oh, we didn't find the expected call. We
8495 could just mark this symbol to exclude it
8496 from tls optimization but it's safer to skip
663a1470 8497 the entire optimization. */
25f53a85 8498 info->callbacks->minfo (_("%H arg lost __tls_get_addr, "
663a1470
AM		 8499 "TLS optimization disabled\n"),
8500 ibfd, sec, rel->r_offset);
8501 ret = TRUE;
8502 goto err_free_rel;
102890f0
AM		 8503 }
8504
85f7a9cb 8505 if (expecting_tls_get_addr && htab->tls_get_addr != NULL)
102890f0
AM		 8506 {
8507 struct plt_entry *ent;
8508 for (ent = htab->tls_get_addr->elf.plt.plist;
8509 ent != NULL;
8510 ent = ent->next)
8511 if (ent->addend == 0)
411e1bfb 8512 {
102890f0 8513 if (ent->plt.refcount > 0)
30038c59 8514 {
102890f0
AM		 8515 ent->plt.refcount -= 1;
8516 expecting_tls_get_addr = 0;
30038c59 8517 }
102890f0 8518 break;
411e1bfb 8519 }
102890f0 8520 }
411e1bfb 8521
85f7a9cb 8522 if (expecting_tls_get_addr && htab->tls_get_addr_fd != NULL)
102890f0
AM		 8523 {
8524 struct plt_entry *ent;
8525 for (ent = htab->tls_get_addr_fd->elf.plt.plist;
8526 ent != NULL;
8527 ent = ent->next)
8528 if (ent->addend == 0)
411e1bfb 8529 {
102890f0
AM		 8530 if (ent->plt.refcount > 0)
8531 ent->plt.refcount -= 1;
8532 break;
411e1bfb 8533 }
102890f0 8534 }
411e1bfb 8535
102890f0 8536 if (tls_clear == 0)
30038c59
AM		 8537 continue;
8538
102890f0
AM		 8539 if ((tls_set & TLS_EXPLICIT) == 0)
8540 {
8541 struct got_entry *ent;
411e1bfb 8542
102890f0
AM		 8543 /* Adjust got entry for this reloc. */
8544 if (h != NULL)
8545 ent = h->got.glist;
8546 else
8547 ent = elf_local_got_ents (ibfd)[r_symndx];
411e1bfb 8548
102890f0
AM		 8549 for (; ent != NULL; ent = ent->next)
8550 if (ent->addend == rel->r_addend
8551 && ent->owner == ibfd
8552 && ent->tls_type == tls_type)
8553 break;
8554 if (ent == NULL)
8555 abort ();
411e1bfb 8556
102890f0
AM		 8557 if (tls_set == 0)
8558 {
8559 /* We managed to get rid of a got entry. */
8560 if (ent->got.refcount > 0)
8561 ent->got.refcount -= 1;
8562 }
8563 }
8564 else
8565 {
8566 /* If we got rid of a DTPMOD/DTPREL reloc pair then
8567 we'll lose one or two dyn relocs. */
8568 if (!dec_dynrel_count (rel->r_info, sec, info,
19e08130 8569 NULL, h, sym))
102890f0 8570 return FALSE;
411e1bfb 8571
102890f0
AM		 8572 if (tls_set == (TLS_EXPLICIT | TLS_GD))
8573 {
8574 if (!dec_dynrel_count ((rel + 1)->r_info, sec, info,
19e08130 8575 NULL, h, sym))
102890f0
AM		 8576 return FALSE;
8577 }
8578 }
411e1bfb 8579
102890f0
AM		 8580 *tls_mask |= tls_set;
8581 *tls_mask &= ~tls_clear;
8582 }
8c1d1bb8 8583
102890f0
AM		 8584 if (elf_section_data (sec)->relocs != relstart)
8585 free (relstart);
8586 }
411e1bfb 8587
663a1470
AM		 8588 if (locsyms != NULL
8589 && (elf_symtab_hdr (ibfd).contents != (unsigned char *) locsyms))
8590 {
8591 if (!info->keep_memory)
8592 free (locsyms);
8593 else
8594 elf_symtab_hdr (ibfd).contents = (unsigned char *) locsyms;
8595 }
8596 }
411e1bfb 8597
663a1470
AM		 8598 if (toc_ref != NULL)
8599 free (toc_ref);
b34976b6 8600 return TRUE;
1e2f5b6e 8601}
b34976b6 8602
c5614fa4
AM		 8603/* Called via elf_link_hash_traverse from ppc64_elf_edit_toc to adjust
8604 the values of any global symbols in a toc section that has been
8605 edited. Globals in toc sections should be a rarity, so this function
8606 sets a flag if any are found in toc sections other than the one just
8607 edited, so that futher hash table traversals can be avoided. */
8608
8609struct adjust_toc_info
8610{
8611 asection *toc;
8612 unsigned long *skip;
8613 bfd_boolean global_toc_syms;
8614};
8615
ba761f19
AM		 8616enum toc_skip_enum { ref_from_discarded = 1, can_optimize = 2 };
8617
c5614fa4
AM		 8618static bfd_boolean
8619adjust_toc_syms (struct elf_link_hash_entry *h, void *inf)
8620{
8621 struct ppc_link_hash_entry *eh;
8622 struct adjust_toc_info *toc_inf = (struct adjust_toc_info *) inf;
854b41e7 8623 unsigned long i;
c5614fa4 8624
c5614fa4
AM		 8625 if (h->root.type != bfd_link_hash_defined
8626 && h->root.type != bfd_link_hash_defweak)
8627 return TRUE;
8628
8629 eh = (struct ppc_link_hash_entry *) h;
8630 if (eh->adjust_done)
8631 return TRUE;
8632
8633 if (eh->elf.root.u.def.section == toc_inf->toc)
8634 {
854b41e7
AM		 8635 if (eh->elf.root.u.def.value > toc_inf->toc->rawsize)
8636 i = toc_inf->toc->rawsize >> 3;
c5614fa4 8637 else
854b41e7
AM		 8638 i = eh->elf.root.u.def.value >> 3;
8639
ba761f19 8640 if ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0)
c5614fa4
AM		 8641 {
8642 (*_bfd_error_handler)
854b41e7
AM		 8643 (_("%s defined on removed toc entry"), eh->elf.root.root.string);
8644 do
8645 ++i;
ba761f19 8646 while ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0);
854b41e7 8647 eh->elf.root.u.def.value = (bfd_vma) i << 3;
c5614fa4 8648 }
854b41e7
AM		 8649
8650 eh->elf.root.u.def.value -= toc_inf->skip[i];
c5614fa4
AM		 8651 eh->adjust_done = 1;
8652 }
8653 else if (strcmp (eh->elf.root.u.def.section->name, ".toc") == 0)
8654 toc_inf->global_toc_syms = TRUE;
8655
8656 return TRUE;
8657}
8658
560c8763
AM		 8659/* Return TRUE iff INSN is one we expect on a _LO variety toc/got reloc. */
8660
8661static bfd_boolean
8662ok_lo_toc_insn (unsigned int insn)
8663{
8664 return ((insn & (0x3f << 26)) == 14u << 26 /* addi */
8665 || (insn & (0x3f << 26)) == 32u << 26 /* lwz */
8666 || (insn & (0x3f << 26)) == 34u << 26 /* lbz */
8667 || (insn & (0x3f << 26)) == 36u << 26 /* stw */
8668 || (insn & (0x3f << 26)) == 38u << 26 /* stb */
8669 || (insn & (0x3f << 26)) == 40u << 26 /* lhz */
8670 || (insn & (0x3f << 26)) == 42u << 26 /* lha */
8671 || (insn & (0x3f << 26)) == 44u << 26 /* sth */
8672 || (insn & (0x3f << 26)) == 46u << 26 /* lmw */
8673 || (insn & (0x3f << 26)) == 47u << 26 /* stmw */
8674 || (insn & (0x3f << 26)) == 48u << 26 /* lfs */
8675 || (insn & (0x3f << 26)) == 50u << 26 /* lfd */
8676 || (insn & (0x3f << 26)) == 52u << 26 /* stfs */
8677 || (insn & (0x3f << 26)) == 54u << 26 /* stfd */
8678 || ((insn & (0x3f << 26)) == 58u << 26 /* lwa,ld,lmd */
8679 && (insn & 3) != 1)
8680 || ((insn & (0x3f << 26)) == 62u << 26 /* std, stmd */
8681 && ((insn & 3) == 0 || (insn & 3) == 3))
8682 || (insn & (0x3f << 26)) == 12u << 26 /* addic */);
8683}
8684
c5614fa4
AM		 8685/* Examine all relocs referencing .toc sections in order to remove
8686 unused .toc entries. */
8687
8688bfd_boolean
33c0ec9d 8689ppc64_elf_edit_toc (struct bfd_link_info *info)
c5614fa4
AM		 8690{
8691 bfd *ibfd;
8692 struct adjust_toc_info toc_inf;
67f0cbdb 8693 struct ppc_link_hash_table *htab = ppc_hash_table (info);
c5614fa4 8694
67f0cbdb 8695 htab->do_toc_opt = 1;
c5614fa4 8696 toc_inf.global_toc_syms = TRUE;
c72f2fb2 8697 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
c5614fa4
AM		 8698 {
8699 asection *toc, *sec;
8700 Elf_Internal_Shdr *symtab_hdr;
8701 Elf_Internal_Sym *local_syms;
425b145b 8702 Elf_Internal_Rela *relstart, *rel, *toc_relocs;
c5614fa4
AM		 8703 unsigned long *skip, *drop;
8704 unsigned char *used;
8705 unsigned char *keep, last, some_unused;
8706
854b41e7
AM		 8707 if (!is_ppc64_elf (ibfd))
8708 continue;
8709
c5614fa4
AM		 8710 toc = bfd_get_section_by_name (ibfd, ".toc");
8711 if (toc == NULL
92b7a70f 8712 || toc->size == 0
dbaa2011
AM		 8713 || toc->sec_info_type == SEC_INFO_TYPE_JUST_SYMS
8714 || discarded_section (toc))
c5614fa4
AM		 8715 continue;
8716
425b145b 8717 toc_relocs = NULL;
c5614fa4 8718 local_syms = NULL;
0ffa91dd 8719 symtab_hdr = &elf_symtab_hdr (ibfd);
c5614fa4
AM		 8720
8721 /* Look at sections dropped from the final link. */
8722 skip = NULL;
8723 relstart = NULL;
8724 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8725 {
8726 if (sec->reloc_count == 0
dbaa2011 8727 || !discarded_section (sec)
c5614fa4
AM		 8728 || get_opd_info (sec)
8729 || (sec->flags & SEC_ALLOC) == 0
8730 || (sec->flags & SEC_DEBUGGING) != 0)
8731 continue;
8732
8733 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL, FALSE);
8734 if (relstart == NULL)
8735 goto error_ret;
8736
8737 /* Run through the relocs to see which toc entries might be
8738 unused. */
8739 for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
8740 {
8741 enum elf_ppc64_reloc_type r_type;
8742 unsigned long r_symndx;
8743 asection *sym_sec;
8744 struct elf_link_hash_entry *h;
8745 Elf_Internal_Sym *sym;
8746 bfd_vma val;
8747
8748 r_type = ELF64_R_TYPE (rel->r_info);
8749 switch (r_type)
8750 {
8751 default:
8752 continue;
8753
8754 case R_PPC64_TOC16:
8755 case R_PPC64_TOC16_LO:
8756 case R_PPC64_TOC16_HI:
8757 case R_PPC64_TOC16_HA:
8758 case R_PPC64_TOC16_DS:
8759 case R_PPC64_TOC16_LO_DS:
8760 break;
8761 }
8762
8763 r_symndx = ELF64_R_SYM (rel->r_info);
8764 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8765 r_symndx, ibfd))
8766 goto error_ret;
8767
8768 if (sym_sec != toc)
8769 continue;
8770
8771 if (h != NULL)
8772 val = h->root.u.def.value;
8773 else
8774 val = sym->st_value;
8775 val += rel->r_addend;
8776
8777 if (val >= toc->size)
8778 continue;
8779
8780 /* Anything in the toc ought to be aligned to 8 bytes.
8781 If not, don't mark as unused. */
8782 if (val & 7)
8783 continue;
8784
8785 if (skip == NULL)
8786 {
854b41e7 8787 skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
c5614fa4
AM		 8788 if (skip == NULL)
8789 goto error_ret;
8790 }
8791
ba761f19 8792 skip[val >> 3] = ref_from_discarded;
c5614fa4
AM		 8793 }
8794
8795 if (elf_section_data (sec)->relocs != relstart)
8796 free (relstart);
8797 }
8798
ba761f19
AM		 8799 /* For largetoc loads of address constants, we can convert
8800 . addis rx,2,addr@got@ha
8801 . ld ry,addr@got@l(rx)
8802 to
8803 . addis rx,2,addr@toc@ha
8804 . addi ry,rx,addr@toc@l
8805 when addr is within 2G of the toc pointer. This then means
8806 that the word storing "addr" in the toc is no longer needed. */
68ffbac6 8807
ba761f19
AM		 8808 if (!ppc64_elf_tdata (ibfd)->has_small_toc_reloc
8809 && toc->output_section->rawsize < (bfd_vma) 1 << 31
8810 && toc->reloc_count != 0)
8811 {
8812 /* Read toc relocs. */
425b145b
AM		 8813 toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
8814 info->keep_memory);
8815 if (toc_relocs == NULL)
ba761f19
AM		 8816 goto error_ret;
8817
425b145b 8818 for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
ba761f19
AM		 8819 {
8820 enum elf_ppc64_reloc_type r_type;
8821 unsigned long r_symndx;
8822 asection *sym_sec;
8823 struct elf_link_hash_entry *h;
8824 Elf_Internal_Sym *sym;
8825 bfd_vma val, addr;
8826
8827 r_type = ELF64_R_TYPE (rel->r_info);
8828 if (r_type != R_PPC64_ADDR64)
8829 continue;
8830
8831 r_symndx = ELF64_R_SYM (rel->r_info);
8832 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8833 r_symndx, ibfd))
8834 goto error_ret;
8835
425b145b 8836 if (sym_sec == NULL
dbaa2011 8837 || discarded_section (sym_sec))
425b145b
AM		 8838 continue;
8839
afe397ea 8840 if (!SYMBOL_REFERENCES_LOCAL (info, h))
ba761f19
AM		 8841 continue;
8842
8843 if (h != NULL)
bddc25c9
AM		 8844 {
8845 if (h->type == STT_GNU_IFUNC)
8846 continue;
8847 val = h->root.u.def.value;
8848 }
ba761f19 8849 else
bddc25c9
AM		 8850 {
8851 if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
8852 continue;
8853 val = sym->st_value;
8854 }
ba761f19
AM		 8855 val += rel->r_addend;
8856 val += sym_sec->output_section->vma + sym_sec->output_offset;
8857
8858 /* We don't yet know the exact toc pointer value, but we
8859 know it will be somewhere in the toc section. Don't
8860 optimize if the difference from any possible toc
8861 pointer is outside [ff..f80008000, 7fff7fff]. */
8862 addr = toc->output_section->vma + TOC_BASE_OFF;
8863 if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
8864 continue;
8865
8866 addr = toc->output_section->vma + toc->output_section->rawsize;
8867 if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
8868 continue;
8869
8870 if (skip == NULL)
8871 {
8872 skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
8873 if (skip == NULL)
8874 goto error_ret;
8875 }
8876
8877 skip[rel->r_offset >> 3]
425b145b 8878 |= can_optimize | ((rel - toc_relocs) << 2);
ba761f19 8879 }
ba761f19
AM		 8880 }
8881
c5614fa4
AM		 8882 if (skip == NULL)
8883 continue;
8884
8885 used = bfd_zmalloc (sizeof (*used) * (toc->size + 7) / 8);
8886 if (used == NULL)
8887 {
8888 error_ret:
8889 if (local_syms != NULL
8890 && symtab_hdr->contents != (unsigned char *) local_syms)
8891 free (local_syms);
8892 if (sec != NULL
8893 && relstart != NULL
8894 && elf_section_data (sec)->relocs != relstart)
8895 free (relstart);
425b145b
AM		 8896 if (toc_relocs != NULL
8897 && elf_section_data (toc)->relocs != toc_relocs)
8898 free (toc_relocs);
c5614fa4
AM		 8899 if (skip != NULL)
8900 free (skip);
8901 return FALSE;
8902 }
8903
30038c59
AM		 8904 /* Now check all kept sections that might reference the toc.
8905 Check the toc itself last. */
8906 for (sec = (ibfd->sections == toc && toc->next ? toc->next
8907 : ibfd->sections);
c5614fa4 8908 sec != NULL;
c5614fa4 8909 sec = (sec == toc ? NULL
c5614fa4 8910 : sec->next == NULL ? toc
30038c59 8911 : sec->next == toc && toc->next ? toc->next
c5614fa4
AM		 8912 : sec->next))
8913 {
8914 int repeat;
8915
8916 if (sec->reloc_count == 0
dbaa2011 8917 || discarded_section (sec)
c5614fa4
AM		 8918 || get_opd_info (sec)
8919 || (sec->flags & SEC_ALLOC) == 0
8920 || (sec->flags & SEC_DEBUGGING) != 0)
8921 continue;
8922
854b41e7
AM		 8923 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8924 info->keep_memory);
c5614fa4 8925 if (relstart == NULL)
2915c55b
JK		 8926 {
8927 free (used);
8928 goto error_ret;
8929 }
c5614fa4
AM		 8930
8931 /* Mark toc entries referenced as used. */
c5614fa4 8932 do
d4f1ee75
AM		 8933 {
8934 repeat = 0;
8935 for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
8936 {
8937 enum elf_ppc64_reloc_type r_type;
8938 unsigned long r_symndx;
8939 asection *sym_sec;
8940 struct elf_link_hash_entry *h;
8941 Elf_Internal_Sym *sym;
8942 bfd_vma val;
8943 enum {no_check, check_lo, check_ha} insn_check;
98528052 8944
d4f1ee75
AM		 8945 r_type = ELF64_R_TYPE (rel->r_info);
8946 switch (r_type)
8947 {
8948 default:
8949 insn_check = no_check;
8950 break;
98528052 8951
d4f1ee75
AM		 8952 case R_PPC64_GOT_TLSLD16_HA:
8953 case R_PPC64_GOT_TLSGD16_HA:
8954 case R_PPC64_GOT_TPREL16_HA:
8955 case R_PPC64_GOT_DTPREL16_HA:
8956 case R_PPC64_GOT16_HA:
8957 case R_PPC64_TOC16_HA:
8958 insn_check = check_ha;
8959 break;
98528052 8960
d4f1ee75
AM		 8961 case R_PPC64_GOT_TLSLD16_LO:
8962 case R_PPC64_GOT_TLSGD16_LO:
8963 case R_PPC64_GOT_TPREL16_LO_DS:
8964 case R_PPC64_GOT_DTPREL16_LO_DS:
8965 case R_PPC64_GOT16_LO:
8966 case R_PPC64_GOT16_LO_DS:
8967 case R_PPC64_TOC16_LO:
8968 case R_PPC64_TOC16_LO_DS:
8969 insn_check = check_lo;
8970 break;
8971 }
560c8763 8972
d4f1ee75
AM		 8973 if (insn_check != no_check)
8974 {
8975 bfd_vma off = rel->r_offset & ~3;
8976 unsigned char buf[4];
8977 unsigned int insn;
c5614fa4 8978
d4f1ee75
AM		 8979 if (!bfd_get_section_contents (ibfd, sec, buf, off, 4))
8980 {
8981 free (used);
8982 goto error_ret;
8983 }
8984 insn = bfd_get_32 (ibfd, buf);
8985 if (insn_check == check_lo
8986 ? !ok_lo_toc_insn (insn)
8987 : ((insn & ((0x3f << 26) | 0x1f << 16))
8988 != ((15u << 26) | (2 << 16)) /* addis rt,2,imm */))
8989 {
8990 char str[12];
8991
8992 ppc64_elf_tdata (ibfd)->unexpected_toc_insn = 1;
8993 sprintf (str, "%#08x", insn);
8994 info->callbacks->einfo
8995 (_("%P: %H: toc optimization is not supported for"
8996 " %s instruction.\n"),
8997 ibfd, sec, rel->r_offset & ~3, str);
8998 }
8999 }
c5614fa4 9000
d4f1ee75
AM		 9001 switch (r_type)
9002 {
9003 case R_PPC64_TOC16:
9004 case R_PPC64_TOC16_LO:
9005 case R_PPC64_TOC16_HI:
9006 case R_PPC64_TOC16_HA:
9007 case R_PPC64_TOC16_DS:
9008 case R_PPC64_TOC16_LO_DS:
9009 /* In case we're taking addresses of toc entries. */
9010 case R_PPC64_ADDR64:
9011 break;
c5614fa4 9012
d4f1ee75
AM		 9013 default:
9014 continue;
9015 }
c5614fa4 9016
d4f1ee75
AM		 9017 r_symndx = ELF64_R_SYM (rel->r_info);
9018 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9019 r_symndx, ibfd))
9020 {
9021 free (used);
9022 goto error_ret;
9023 }
c5614fa4 9024
d4f1ee75
AM		 9025 if (sym_sec != toc)
9026 continue;
c5614fa4 9027
d4f1ee75
AM		 9028 if (h != NULL)
9029 val = h->root.u.def.value;
9030 else
9031 val = sym->st_value;
9032 val += rel->r_addend;
ba761f19 9033
d4f1ee75
AM		 9034 if (val >= toc->size)
9035 continue;
ba761f19 9036
d4f1ee75
AM		 9037 if ((skip[val >> 3] & can_optimize) != 0)
9038 {
9039 bfd_vma off;
9040 unsigned char opc;
9041
9042 switch (r_type)
9043 {
9044 case R_PPC64_TOC16_HA:
ba761f19 9045 break;
ba761f19 9046
d4f1ee75
AM		 9047 case R_PPC64_TOC16_LO_DS:
9048 off = rel->r_offset;
9049 off += (bfd_big_endian (ibfd) ? -2 : 3);
9050 if (!bfd_get_section_contents (ibfd, sec, &opc,
9051 off, 1))
9052 {
9053 free (used);
9054 goto error_ret;
9055 }
9056 if ((opc & (0x3f << 2)) == (58u << 2))
9057 break;
9058 /* Fall thru */
ba761f19 9059
d4f1ee75
AM		 9060 default:
9061 /* Wrong sort of reloc, or not a ld. We may
9062 as well clear ref_from_discarded too. */
9063 skip[val >> 3] = 0;
9064 }
9065 }
9066
9067 if (sec != toc)
9068 used[val >> 3] = 1;
9069 /* For the toc section, we only mark as used if this
9070 entry itself isn't unused. */
9071 else if ((used[rel->r_offset >> 3]
9072 || !(skip[rel->r_offset >> 3] & ref_from_discarded))
9073 && !used[val >> 3])
9074 {
9075 /* Do all the relocs again, to catch reference
9076 chains. */
9077 repeat = 1;
9078 used[val >> 3] = 1;
9079 }
9080 }
9081 }
c5614fa4 9082 while (repeat);
854b41e7
AM		 9083
9084 if (elf_section_data (sec)->relocs != relstart)
9085 free (relstart);
c5614fa4
AM		 9086 }
9087
9088 /* Merge the used and skip arrays. Assume that TOC
9089 doublewords not appearing as either used or unused belong
9090 to to an entry more than one doubleword in size. */
9091 for (drop = skip, keep = used, last = 0, some_unused = 0;
9092 drop < skip + (toc->size + 7) / 8;
9093 ++drop, ++keep)
9094 {
9095 if (*keep)
9096 {
ba761f19
AM		 9097 *drop &= ~ref_from_discarded;
9098 if ((*drop & can_optimize) != 0)
9099 some_unused = 1;
c5614fa4
AM		 9100 last = 0;
9101 }
b140b010 9102 else if ((*drop & ref_from_discarded) != 0)
c5614fa4
AM		 9103 {
9104 some_unused = 1;
ba761f19 9105 last = ref_from_discarded;
c5614fa4
AM		 9106 }
9107 else
9108 *drop = last;
9109 }
9110
9111 free (used);
9112
9113 if (some_unused)
9114 {
9115 bfd_byte *contents, *src;
9116 unsigned long off;
d62b3684 9117 Elf_Internal_Sym *sym;
ba761f19 9118 bfd_boolean local_toc_syms = FALSE;
c5614fa4
AM		 9119
9120 /* Shuffle the toc contents, and at the same time convert the
9121 skip array from booleans into offsets. */
9122 if (!bfd_malloc_and_get_section (ibfd, toc, &contents))
9123 goto error_ret;
9124
9125 elf_section_data (toc)->this_hdr.contents = contents;
9126
9127 for (src = contents, off = 0, drop = skip;
9128 src < contents + toc->size;
9129 src += 8, ++drop)
9130 {
ba761f19
AM		 9131 if ((*drop & (can_optimize | ref_from_discarded)) != 0)
9132 off += 8;
c5614fa4
AM		 9133 else if (off != 0)
9134 {
9135 *drop = off;
9136 memcpy (src - off, src, 8);
9137 }
9138 }
854b41e7 9139 *drop = off;
c5614fa4
AM		 9140 toc->rawsize = toc->size;
9141 toc->size = src - contents - off;
9142
ba761f19
AM		 9143 /* Adjust addends for relocs against the toc section sym,
9144 and optimize any accesses we can. */
c5614fa4
AM		 9145 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
9146 {
9147 if (sec->reloc_count == 0
dbaa2011 9148 || discarded_section (sec))
c5614fa4
AM		 9149 continue;
9150
9151 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
854b41e7 9152 info->keep_memory);
c5614fa4
AM		 9153 if (relstart == NULL)
9154 goto error_ret;
9155
9156 for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9157 {
9158 enum elf_ppc64_reloc_type r_type;
9159 unsigned long r_symndx;
9160 asection *sym_sec;
9161 struct elf_link_hash_entry *h;
854b41e7 9162 bfd_vma val;
c5614fa4
AM		 9163
9164 r_type = ELF64_R_TYPE (rel->r_info);
9165 switch (r_type)
9166 {
9167 default:
9168 continue;
9169
9170 case R_PPC64_TOC16:
9171 case R_PPC64_TOC16_LO:
9172 case R_PPC64_TOC16_HI:
9173 case R_PPC64_TOC16_HA:
9174 case R_PPC64_TOC16_DS:
9175 case R_PPC64_TOC16_LO_DS:
9176 case R_PPC64_ADDR64:
9177 break;
9178 }
9179
9180 r_symndx = ELF64_R_SYM (rel->r_info);
9181 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9182 r_symndx, ibfd))
9183 goto error_ret;
9184
ba761f19 9185 if (sym_sec != toc)
c5614fa4
AM		 9186 continue;
9187
ba761f19
AM		 9188 if (h != NULL)
9189 val = h->root.u.def.value;
9190 else
9191 {
9192 val = sym->st_value;
9193 if (val != 0)
9194 local_toc_syms = TRUE;
9195 }
9196
9197 val += rel->r_addend;
854b41e7
AM		 9198
9199 if (val > toc->rawsize)
9200 val = toc->rawsize;
ba761f19
AM		 9201 else if ((skip[val >> 3] & ref_from_discarded) != 0)
9202 continue;
9203 else if ((skip[val >> 3] & can_optimize) != 0)
9204 {
9205 Elf_Internal_Rela *tocrel
425b145b 9206 = toc_relocs + (skip[val >> 3] >> 2);
ba761f19
AM		 9207 unsigned long tsym = ELF64_R_SYM (tocrel->r_info);
9208
9209 switch (r_type)
9210 {
9211 case R_PPC64_TOC16_HA:
9212 rel->r_info = ELF64_R_INFO (tsym, R_PPC64_TOC16_HA);
9213 break;
9214
9215 case R_PPC64_TOC16_LO_DS:
9216 rel->r_info = ELF64_R_INFO (tsym, R_PPC64_LO_DS_OPT);
9217 break;
9218
9219 default:
28942f62
AM		 9220 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
9221 ppc_howto_init ();
b140b010 9222 info->callbacks->einfo
bc30df16 9223 (_("%P: %H: %s references "
b140b010
AM		 9224 "optimized away TOC entry\n"),
9225 ibfd, sec, rel->r_offset,
9226 ppc64_elf_howto_table[r_type]->name);
9227 bfd_set_error (bfd_error_bad_value);
9228 goto error_ret;
ba761f19
AM		 9229 }
9230 rel->r_addend = tocrel->r_addend;
9231 elf_section_data (sec)->relocs = relstart;
9232 continue;
9233 }
9234
9235 if (h != NULL || sym->st_value != 0)
9236 continue;
854b41e7
AM		 9237
9238 rel->r_addend -= skip[val >> 3];
9239 elf_section_data (sec)->relocs = relstart;
c5614fa4 9240 }
854b41e7
AM		 9241
9242 if (elf_section_data (sec)->relocs != relstart)
9243 free (relstart);
c5614fa4
AM		 9244 }
9245
9246 /* We shouldn't have local or global symbols defined in the TOC,
9247 but handle them anyway. */
df22d223
AM		 9248 if (local_syms != NULL)
9249 for (sym = local_syms;
9250 sym < local_syms + symtab_hdr->sh_info;
9251 ++sym)
9252 if (sym->st_value != 0
9253 && bfd_section_from_elf_index (ibfd, sym->st_shndx) == toc)
9254 {
9255 unsigned long i;
854b41e7 9256
df22d223
AM		 9257 if (sym->st_value > toc->rawsize)
9258 i = toc->rawsize >> 3;
9259 else
9260 i = sym->st_value >> 3;
854b41e7 9261
df22d223
AM		 9262 if ((skip[i] & (ref_from_discarded | can_optimize)) != 0)
9263 {
9264 if (local_toc_syms)
9265 (*_bfd_error_handler)
9266 (_("%s defined on removed toc entry"),
9267 bfd_elf_sym_name (ibfd, symtab_hdr, sym, NULL));
9268 do
9269 ++i;
9270 while ((skip[i] & (ref_from_discarded | can_optimize)));
9271 sym->st_value = (bfd_vma) i << 3;
9272 }
d62b3684 9273
df22d223
AM		 9274 sym->st_value -= skip[i];
9275 symtab_hdr->contents = (unsigned char *) local_syms;
9276 }
c5614fa4 9277
854b41e7 9278 /* Adjust any global syms defined in this toc input section. */
c5614fa4
AM		 9279 if (toc_inf.global_toc_syms)
9280 {
9281 toc_inf.toc = toc;
9282 toc_inf.skip = skip;
9283 toc_inf.global_toc_syms = FALSE;
9284 elf_link_hash_traverse (elf_hash_table (info), adjust_toc_syms,
9285 &toc_inf);
9286 }
854b41e7
AM		 9287
9288 if (toc->reloc_count != 0)
9289 {
d4730f92 9290 Elf_Internal_Shdr *rel_hdr;
854b41e7
AM		 9291 Elf_Internal_Rela *wrel;
9292 bfd_size_type sz;
9293
854b41e7 9294 /* Remove unused toc relocs, and adjust those we keep. */
28be611c
AM		 9295 if (toc_relocs == NULL)
9296 toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
9297 info->keep_memory);
9298 if (toc_relocs == NULL)
9299 goto error_ret;
9300
425b145b
AM		 9301 wrel = toc_relocs;
9302 for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
ba761f19
AM		 9303 if ((skip[rel->r_offset >> 3]
9304 & (ref_from_discarded | can_optimize)) == 0)
854b41e7
AM		 9305 {
9306 wrel->r_offset = rel->r_offset - skip[rel->r_offset >> 3];
9307 wrel->r_info = rel->r_info;
9308 wrel->r_addend = rel->r_addend;
9309 ++wrel;
9310 }
9311 else if (!dec_dynrel_count (rel->r_info, toc, info,
9312 &local_syms, NULL, NULL))
9313 goto error_ret;
9314
425b145b
AM		 9315 elf_section_data (toc)->relocs = toc_relocs;
9316 toc->reloc_count = wrel - toc_relocs;
d4730f92
BS		 9317 rel_hdr = _bfd_elf_single_rel_hdr (toc);
9318 sz = rel_hdr->sh_entsize;
9319 rel_hdr->sh_size = toc->reloc_count * sz;
854b41e7 9320 }
c5614fa4 9321 }
28be611c
AM		 9322 else if (toc_relocs != NULL
9323 && elf_section_data (toc)->relocs != toc_relocs)
425b145b 9324 free (toc_relocs);
c5614fa4
AM		 9325
9326 if (local_syms != NULL
9327 && symtab_hdr->contents != (unsigned char *) local_syms)
9328 {
9329 if (!info->keep_memory)
9330 free (local_syms);
9331 else
9332 symtab_hdr->contents = (unsigned char *) local_syms;
9333 }
9334 free (skip);
9335 }
9336
9337 return TRUE;
9338}
9339
1bbe0902
AM		 9340/* Return true iff input section I references the TOC using
9341 instructions limited to +/-32k offsets. */
9342
9343bfd_boolean
9344ppc64_elf_has_small_toc_reloc (asection *i)
9345{
9346 return (is_ppc64_elf (i->owner)
9347 && ppc64_elf_tdata (i->owner)->has_small_toc_reloc);
9348}
9349
927be08e
AM		 9350/* Allocate space for one GOT entry. */
9351
9352static void
9353allocate_got (struct elf_link_hash_entry *h,
9354 struct bfd_link_info *info,
9355 struct got_entry *gent)
9356{
9357 struct ppc_link_hash_table *htab = ppc_hash_table (info);
9358 bfd_boolean dyn;
9359 struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
9360 int entsize = (gent->tls_type & eh->tls_mask & (TLS_GD | TLS_LD)
9361 ? 16 : 8);
9362 int rentsize = (gent->tls_type & eh->tls_mask & TLS_GD
9363 ? 2 : 1) * sizeof (Elf64_External_Rela);
9364 asection *got = ppc64_elf_tdata (gent->owner)->got;
9365
9366 gent->got.offset = got->size;
9367 got->size += entsize;
9368
9369 dyn = htab->elf.dynamic_sections_created;
19e08130 9370 if (h->type == STT_GNU_IFUNC)
927be08e 9371 {
33e44f2e 9372 htab->elf.irelplt->size += rentsize;
19e08130 9373 htab->got_reli_size += rentsize;
927be08e 9374 }
19e08130
AM		 9375 else if ((info->shared
9376 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h))
9377 && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
9378 || h->root.type != bfd_link_hash_undefweak))
927be08e 9379 {
19e08130 9380 asection *relgot = ppc64_elf_tdata (gent->owner)->relgot;
927be08e 9381 relgot->size += rentsize;
927be08e
AM		 9382 }
9383}
9384
7865406b
AM		 9385/* This function merges got entries in the same toc group. */
9386
9387static void
9388merge_got_entries (struct got_entry **pent)
9389{
9390 struct got_entry *ent, *ent2;
9391
9392 for (ent = *pent; ent != NULL; ent = ent->next)
9393 if (!ent->is_indirect)
9394 for (ent2 = ent->next; ent2 != NULL; ent2 = ent2->next)
9395 if (!ent2->is_indirect
9396 && ent2->addend == ent->addend
9397 && ent2->tls_type == ent->tls_type
9398 && elf_gp (ent2->owner) == elf_gp (ent->owner))
9399 {
9400 ent2->is_indirect = TRUE;
9401 ent2->got.ent = ent;
9402 }
9403}
9404
65f38f15
AM		 9405/* Allocate space in .plt, .got and associated reloc sections for
9406 dynamic relocs. */
5bd4f169 9407
b34976b6 9408static bfd_boolean
4ce794b7 9409allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
5bd4f169 9410{
65f38f15
AM		 9411 struct bfd_link_info *info;
9412 struct ppc_link_hash_table *htab;
5bd4f169 9413 asection *s;
65f38f15 9414 struct ppc_link_hash_entry *eh;
6061a67d 9415 struct elf_dyn_relocs *p;
0b8bcf0d 9416 struct got_entry **pgent, *gent;
5bd4f169 9417
e92d460e 9418 if (h->root.type == bfd_link_hash_indirect)
b34976b6 9419 return TRUE;
5bd4f169 9420
65f38f15
AM		 9421 info = (struct bfd_link_info *) inf;
9422 htab = ppc_hash_table (info);
4dfe6ac6
NC		 9423 if (htab == NULL)
9424 return FALSE;
5bd4f169 9425
e054468f
AM		 9426 if ((htab->elf.dynamic_sections_created
9427 && h->dynindx != -1
9428 && WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info->shared, h))
9429 || h->type == STT_GNU_IFUNC)
5bd4f169 9430 {
411e1bfb
AM		 9431 struct plt_entry *pent;
9432 bfd_boolean doneone = FALSE;
9433 for (pent = h->plt.plist; pent != NULL; pent = pent->next)
9434 if (pent->plt.refcount > 0)
9435 {
25f23106
AM		 9436 if (!htab->elf.dynamic_sections_created
9437 || h->dynindx == -1)
e054468f 9438 {
33e44f2e 9439 s = htab->elf.iplt;
e054468f 9440 pent->plt.offset = s->size;
b9e5796b 9441 s->size += PLT_ENTRY_SIZE (htab);
33e44f2e 9442 s = htab->elf.irelplt;
e054468f
AM		 9443 }
9444 else
9445 {
9446 /* If this is the first .plt entry, make room for the special
9447 first entry. */
33e44f2e 9448 s = htab->elf.splt;
e054468f 9449 if (s->size == 0)
b9e5796b 9450 s->size += PLT_INITIAL_ENTRY_SIZE (htab);
e054468f
AM		 9451
9452 pent->plt.offset = s->size;
9453
9454 /* Make room for this entry. */
b9e5796b 9455 s->size += PLT_ENTRY_SIZE (htab);
e054468f
AM		 9456
9457 /* Make room for the .glink code. */
9458 s = htab->glink;
9459 if (s->size == 0)
9460 s->size += GLINK_CALL_STUB_SIZE;
b9e5796b
AM		 9461 if (htab->opd_abi)
9462 {
9463 /* We need bigger stubs past index 32767. */
9464 if (s->size >= GLINK_CALL_STUB_SIZE + 32768*2*4)
9465 s->size += 4;
9466 s->size += 2*4;
9467 }
9468 else
e054468f 9469 s->size += 4;
e054468f
AM		 9470
9471 /* We also need to make an entry in the .rela.plt section. */
33e44f2e 9472 s = htab->elf.srelplt;
e054468f 9473 }
eea6121a 9474 s->size += sizeof (Elf64_External_Rela);
411e1bfb
AM		 9475 doneone = TRUE;
9476 }
9477 else
9478 pent->plt.offset = (bfd_vma) -1;
9479 if (!doneone)
65f38f15 9480 {
411e1bfb 9481 h->plt.plist = NULL;
f5385ebf 9482 h->needs_plt = 0;
65f38f15
AM		 9483 }
9484 }
9485 else
9486 {
411e1bfb 9487 h->plt.plist = NULL;
f5385ebf 9488 h->needs_plt = 0;
65f38f15
AM		 9489 }
9490
951fd09b
AM		 9491 eh = (struct ppc_link_hash_entry *) h;
9492 /* Run through the TLS GD got entries first if we're changing them
9493 to TPREL. */
e7b938ca 9494 if ((eh->tls_mask & TLS_TPRELGD) != 0)
951fd09b
AM		 9495 for (gent = h->got.glist; gent != NULL; gent = gent->next)
9496 if (gent->got.refcount > 0
9497 && (gent->tls_type & TLS_GD) != 0)
9498 {
9499 /* This was a GD entry that has been converted to TPREL. If
9500 there happens to be a TPREL entry we can use that one. */
9501 struct got_entry *ent;
9502 for (ent = h->got.glist; ent != NULL; ent = ent->next)
9503 if (ent->got.refcount > 0
9504 && (ent->tls_type & TLS_TPREL) != 0
e717da7e
AM		 9505 && ent->addend == gent->addend
9506 && ent->owner == gent->owner)
951fd09b
AM		 9507 {
9508 gent->got.refcount = 0;
9509 break;
9510 }
9511
9512 /* If not, then we'll be using our own TPREL entry. */
9513 if (gent->got.refcount != 0)
9514 gent->tls_type = TLS_TLS | TLS_TPREL;
9515 }
9516
7865406b
AM		 9517 /* Remove any list entry that won't generate a word in the GOT before
9518 we call merge_got_entries. Otherwise we risk merging to empty
9519 entries. */
0b8bcf0d
AM		 9520 pgent = &h->got.glist;
9521 while ((gent = *pgent) != NULL)
411e1bfb 9522 if (gent->got.refcount > 0)
7865406b
AM		 9523 {
9524 if ((gent->tls_type & TLS_LD) != 0
9525 && !h->def_dynamic)
9526 {
9527 ppc64_tlsld_got (gent->owner)->got.refcount += 1;
9528 *pgent = gent->next;
9529 }
9530 else
9531 pgent = &gent->next;
9532 }
9533 else
9534 *pgent = gent->next;
9535
9536 if (!htab->do_multi_toc)
9537 merge_got_entries (&h->got.glist);
9538
9539 for (gent = h->got.glist; gent != NULL; gent = gent->next)
9540 if (!gent->is_indirect)
411e1bfb
AM		 9541 {
9542 /* Make sure this symbol is output as a dynamic symbol.
951fd09b
AM		 9543 Undefined weak syms won't yet be marked as dynamic,
9544 nor will all TLS symbols. */
411e1bfb 9545 if (h->dynindx == -1
b099ab9f 9546 && !h->forced_local
25f23106 9547 && h->type != STT_GNU_IFUNC
b099ab9f 9548 && htab->elf.dynamic_sections_created)
411e1bfb 9549 {
c152c796 9550 if (! bfd_elf_link_record_dynamic_symbol (info, h))
411e1bfb
AM		 9551 return FALSE;
9552 }
65f38f15 9553
0c8d6e5c 9554 if (!is_ppc64_elf (gent->owner))
927be08e 9555 abort ();
0ffa91dd 9556
927be08e 9557 allocate_got (h, info, gent);
411e1bfb 9558 }
65f38f15 9559
b099ab9f 9560 if (eh->dyn_relocs == NULL
25f23106 9561 || (!htab->elf.dynamic_sections_created
14b5f73f 9562 && h->type != STT_GNU_IFUNC))
b34976b6 9563 return TRUE;
65f38f15
AM		 9564
9565 /* In the shared -Bsymbolic case, discard space allocated for
9566 dynamic pc-relative relocs against symbols which turn out to be
9567 defined in regular objects. For the normal shared case, discard
9568 space for relocs that have become local due to symbol visibility
9569 changes. */
9570
9571 if (info->shared)
9572 {
9c7a29a3 9573 /* Relocs that use pc_count are those that appear on a call insn,
1d483afe 9574 or certain REL relocs (see must_be_dyn_reloc) that can be
9c7a29a3
AM		 9575 generated via assembly. We want calls to protected symbols to
9576 resolve directly to the function rather than going via the plt.
9577 If people want function pointer comparisons to work as expected
9578 then they should avoid writing weird assembly. */
09695f56 9579 if (SYMBOL_CALLS_LOCAL (info, h))
65f38f15 9580 {
6061a67d 9581 struct elf_dyn_relocs **pp;
65f38f15
AM		 9582
9583 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
5bd4f169 9584 {
65f38f15
AM		 9585 p->count -= p->pc_count;
9586 p->pc_count = 0;
9587 if (p->count == 0)
9588 *pp = p->next;
9589 else
9590 pp = &p->next;
5bd4f169 9591 }
65f38f15 9592 }
4e795f50
AM		 9593
9594 /* Also discard relocs on undefined weak syms with non-default
9595 visibility. */
cab87ef9
AM		 9596 if (eh->dyn_relocs != NULL
9597 && h->root.type == bfd_link_hash_undefweak)
dfbb6ac9
AM		 9598 {
9599 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
9600 eh->dyn_relocs = NULL;
9601
9602 /* Make sure this symbol is output as a dynamic symbol.
9603 Undefined weak syms won't yet be marked as dynamic. */
9604 else if (h->dynindx == -1
9605 && !h->forced_local)
9606 {
9607 if (! bfd_elf_link_record_dynamic_symbol (info, h))
9608 return FALSE;
9609 }
9610 }
65f38f15 9611 }
25f23106
AM		 9612 else if (h->type == STT_GNU_IFUNC)
9613 {
9614 if (!h->non_got_ref)
9615 eh->dyn_relocs = NULL;
9616 }
f4656909 9617 else if (ELIMINATE_COPY_RELOCS)
65f38f15
AM		 9618 {
9619 /* For the non-shared case, discard space for relocs against
9620 symbols which turn out to need copy relocs or are not
9621 dynamic. */
9622
f5385ebf 9623 if (!h->non_got_ref
f5385ebf 9624 && !h->def_regular)
65f38f15
AM		 9625 {
9626 /* Make sure this symbol is output as a dynamic symbol.
9627 Undefined weak syms won't yet be marked as dynamic. */
9628 if (h->dynindx == -1
f5385ebf 9629 && !h->forced_local)
65f38f15 9630 {
c152c796 9631 if (! bfd_elf_link_record_dynamic_symbol (info, h))
b34976b6 9632 return FALSE;
65f38f15
AM		 9633 }
9634
9635 /* If that succeeded, we know we'll be keeping all the
9636 relocs. */
9637 if (h->dynindx != -1)
9638 goto keep;
9639 }
9640
9641 eh->dyn_relocs = NULL;
9642
ec338859 9643 keep: ;
65f38f15
AM		 9644 }
9645
9646 /* Finally, allocate space. */
9647 for (p = eh->dyn_relocs; p != NULL; p = p->next)
9648 {
9649 asection *sreloc = elf_section_data (p->sec)->sreloc;
19e08130 9650 if (eh->elf.type == STT_GNU_IFUNC)
33e44f2e 9651 sreloc = htab->elf.irelplt;
eea6121a 9652 sreloc->size += p->count * sizeof (Elf64_External_Rela);
65f38f15
AM		 9653 }
9654
b34976b6 9655 return TRUE;
65f38f15
AM		 9656}
9657
a345bc8d
AM		 9658/* Called via elf_link_hash_traverse from ppc64_elf_size_dynamic_sections
9659 to set up space for global entry stubs. These are put in glink,
9660 after the branch table. */
65f38f15 9661
b34976b6 9662static bfd_boolean
a345bc8d 9663size_global_entry_stubs (struct elf_link_hash_entry *h, void *inf)
65f38f15 9664{
a345bc8d
AM		 9665 struct bfd_link_info *info;
9666 struct ppc_link_hash_table *htab;
9667 struct plt_entry *pent;
9668 asection *s;
65f38f15 9669
a345bc8d
AM		 9670 if (h->root.type == bfd_link_hash_indirect)
9671 return TRUE;
65f38f15 9672
a345bc8d
AM		 9673 if (!h->pointer_equality_needed)
9674 return TRUE;
65f38f15 9675
a345bc8d
AM		 9676 if (h->def_regular)
9677 return TRUE;
65f38f15 9678
a345bc8d
AM		 9679 info = inf;
9680 htab = ppc_hash_table (info);
9681 if (htab == NULL)
9682 return FALSE;
9683
9684 s = htab->glink;
9685 for (pent = h->plt.plist; pent != NULL; pent = pent->next)
9686 if (pent->plt.offset != (bfd_vma) -1
9687 && pent->addend == 0)
9688 {
afe397ea
AM		 9689 /* For ELFv2, if this symbol is not defined in a regular file
9690 and we are not generating a shared library or pie, then we
9691 need to define the symbol in the executable on a call stub.
9692 This is to avoid text relocations. */
a345bc8d 9693 s->size = (s->size + 15) & -16;
afe397ea
AM		 9694 h->root.u.def.section = s;
9695 h->root.u.def.value = s->size;
a345bc8d
AM		 9696 s->size += 16;
9697 break;
9698 }
9699 return TRUE;
9700}
9701
9702/* Set DF_TEXTREL if we find any dynamic relocs that apply to
9703 read-only sections. */
9704
9705static bfd_boolean
9706maybe_set_textrel (struct elf_link_hash_entry *h, void *info)
9707{
9708 if (h->root.type == bfd_link_hash_indirect)
9709 return TRUE;
9710
9711 if (readonly_dynrelocs (h))
9712 {
9713 ((struct bfd_link_info *) info)->flags |= DF_TEXTREL;
9714
9715 /* Not an error, just cut short the traversal. */
9716 return FALSE;
65f38f15 9717 }
b34976b6 9718 return TRUE;
65f38f15
AM		 9719}
9720
9721/* Set the sizes of the dynamic sections. */
9722
b34976b6 9723static bfd_boolean
ee67d69a 9724ppc64_elf_size_dynamic_sections (bfd *output_bfd,
4ce794b7 9725 struct bfd_link_info *info)
65f38f15
AM		 9726{
9727 struct ppc_link_hash_table *htab;
9728 bfd *dynobj;
9729 asection *s;
b34976b6 9730 bfd_boolean relocs;
65f38f15 9731 bfd *ibfd;
7865406b 9732 struct got_entry *first_tlsld;
65f38f15
AM		 9733
9734 htab = ppc_hash_table (info);
4dfe6ac6
NC		 9735 if (htab == NULL)
9736 return FALSE;
9737
65f38f15
AM		 9738 dynobj = htab->elf.dynobj;
9739 if (dynobj == NULL)
9740 abort ();
9741
9742 if (htab->elf.dynamic_sections_created)
9743 {
9744 /* Set the contents of the .interp section to the interpreter. */
36af4a4e 9745 if (info->executable)
65f38f15 9746 {
3d4d4302 9747 s = bfd_get_linker_section (dynobj, ".interp");
65f38f15
AM		 9748 if (s == NULL)
9749 abort ();
eea6121a 9750 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
65f38f15
AM		 9751 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
9752 }
9753 }
9754
9755 /* Set up .got offsets for local syms, and space for local dynamic
9756 relocs. */
c72f2fb2 9757 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
65f38f15 9758 {
411e1bfb
AM		 9759 struct got_entry **lgot_ents;
9760 struct got_entry **end_lgot_ents;
e054468f
AM		 9761 struct plt_entry **local_plt;
9762 struct plt_entry **end_local_plt;
f961d9dd 9763 unsigned char *lgot_masks;
65f38f15
AM		 9764 bfd_size_type locsymcount;
9765 Elf_Internal_Shdr *symtab_hdr;
65f38f15 9766
0c8d6e5c 9767 if (!is_ppc64_elf (ibfd))
65f38f15
AM		 9768 continue;
9769
9770 for (s = ibfd->sections; s != NULL; s = s->next)
9771 {
19e08130 9772 struct ppc_dyn_relocs *p;
65f38f15 9773
6edfbbad 9774 for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
65f38f15 9775 {
ec338859
AM		 9776 if (!bfd_is_abs_section (p->sec)
9777 && bfd_is_abs_section (p->sec->output_section))
9778 {
9779 /* Input section has been discarded, either because
9780 it is a copy of a linkonce section or due to
9781 linker script /DISCARD/, so we'll be discarding
9782 the relocs too. */
9783 }
248866a8 9784 else if (p->count != 0)
ec338859 9785 {
19e08130
AM		 9786 asection *srel = elf_section_data (p->sec)->sreloc;
9787 if (p->ifunc)
33e44f2e 9788 srel = htab->elf.irelplt;
eea6121a 9789 srel->size += p->count * sizeof (Elf64_External_Rela);
248866a8
AM		 9790 if ((p->sec->output_section->flags & SEC_READONLY) != 0)
9791 info->flags |= DF_TEXTREL;
ec338859 9792 }
65f38f15
AM		 9793 }
9794 }
9795
411e1bfb
AM		 9796 lgot_ents = elf_local_got_ents (ibfd);
9797 if (!lgot_ents)
65f38f15
AM		 9798 continue;
9799
0ffa91dd 9800 symtab_hdr = &elf_symtab_hdr (ibfd);
65f38f15 9801 locsymcount = symtab_hdr->sh_info;
411e1bfb 9802 end_lgot_ents = lgot_ents + locsymcount;
e054468f
AM		 9803 local_plt = (struct plt_entry **) end_lgot_ents;
9804 end_local_plt = local_plt + locsymcount;
f961d9dd 9805 lgot_masks = (unsigned char *) end_local_plt;
e717da7e 9806 s = ppc64_elf_tdata (ibfd)->got;
e7b938ca 9807 for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
65f38f15 9808 {
0b8bcf0d 9809 struct got_entry **pent, *ent;
411e1bfb 9810
0b8bcf0d
AM		 9811 pent = lgot_ents;
9812 while ((ent = *pent) != NULL)
411e1bfb
AM		 9813 if (ent->got.refcount > 0)
9814 {
e7b938ca 9815 if ((ent->tls_type & *lgot_masks & TLS_LD) != 0)
411e1bfb 9816 {
927be08e 9817 ppc64_tlsld_got (ibfd)->got.refcount += 1;
0b8bcf0d 9818 *pent = ent->next;
411e1bfb
AM		 9819 }
9820 else
9821 {
19e08130
AM		 9822 unsigned int ent_size = 8;
9823 unsigned int rel_size = sizeof (Elf64_External_Rela);
9824
eea6121a 9825 ent->got.offset = s->size;
e7b938ca 9826 if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
927be08e 9827 {
19e08130
AM		 9828 ent_size *= 2;
9829 rel_size *= 2;
9830 }
9831 s->size += ent_size;
9832 if ((*lgot_masks & PLT_IFUNC) != 0)
9833 {
33e44f2e 9834 htab->elf.irelplt->size += rel_size;
19e08130
AM		 9835 htab->got_reli_size += rel_size;
9836 }
9837 else if (info->shared)
9838 {
9839 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
9840 srel->size += rel_size;
927be08e 9841 }
0b8bcf0d 9842 pent = &ent->next;
411e1bfb
AM		 9843 }
9844 }
9845 else
0b8bcf0d 9846 *pent = ent->next;
65f38f15 9847 }
e054468f
AM		 9848
9849 /* Allocate space for calls to local STT_GNU_IFUNC syms in .iplt. */
9850 for (; local_plt < end_local_plt; ++local_plt)
9851 {
9852 struct plt_entry *ent;
9853
9854 for (ent = *local_plt; ent != NULL; ent = ent->next)
9855 if (ent->plt.refcount > 0)
9856 {
33e44f2e 9857 s = htab->elf.iplt;
e054468f 9858 ent->plt.offset = s->size;
b9e5796b 9859 s->size += PLT_ENTRY_SIZE (htab);
e054468f 9860
33e44f2e 9861 htab->elf.irelplt->size += sizeof (Elf64_External_Rela);
e054468f
AM		 9862 }
9863 else
9864 ent->plt.offset = (bfd_vma) -1;
9865 }
65f38f15
AM		 9866 }
9867
9868 /* Allocate global sym .plt and .got entries, and space for global
9869 sym dynamic relocs. */
4ce794b7 9870 elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, info);
a345bc8d
AM		 9871 /* Stash the end of glink branch table. */
9872 if (htab->glink != NULL)
9873 htab->glink->rawsize = htab->glink->size;
9874
9875 if (!htab->opd_abi && !info->shared)
9876 elf_link_hash_traverse (&htab->elf, size_global_entry_stubs, info);
65f38f15 9877
7865406b 9878 first_tlsld = NULL;
c72f2fb2 9879 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
102890f0 9880 {
7865406b
AM		 9881 struct got_entry *ent;
9882
0c8d6e5c 9883 if (!is_ppc64_elf (ibfd))
102890f0
AM		 9884 continue;
9885
7865406b
AM		 9886 ent = ppc64_tlsld_got (ibfd);
9887 if (ent->got.refcount > 0)
102890f0 9888 {
7865406b 9889 if (!htab->do_multi_toc && first_tlsld != NULL)
102890f0 9890 {
7865406b
AM		 9891 ent->is_indirect = TRUE;
9892 ent->got.ent = first_tlsld;
9893 }
9894 else
9895 {
9896 if (first_tlsld == NULL)
9897 first_tlsld = ent;
9898 s = ppc64_elf_tdata (ibfd)->got;
9899 ent->got.offset = s->size;
9900 ent->owner = ibfd;
9901 s->size += 16;
9902 if (info->shared)
9903 {
9904 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
9905 srel->size += sizeof (Elf64_External_Rela);
9906 }
102890f0
AM		 9907 }
9908 }
9909 else
7865406b 9910 ent->got.offset = (bfd_vma) -1;
102890f0
AM		 9911 }
9912
65f38f15
AM		 9913 /* We now have determined the sizes of the various dynamic sections.
9914 Allocate memory for them. */
b34976b6 9915 relocs = FALSE;
65f38f15
AM		 9916 for (s = dynobj->sections; s != NULL; s = s->next)
9917 {
9918 if ((s->flags & SEC_LINKER_CREATED) == 0)
9919 continue;
9920
4ce794b7 9921 if (s == htab->brlt || s == htab->relbrlt)
721956f4
AM		 9922 /* These haven't been allocated yet; don't strip. */
9923 continue;
33e44f2e
AM		 9924 else if (s == htab->elf.sgot
9925 || s == htab->elf.splt
9926 || s == htab->elf.iplt
c456f082
AM		 9927 || s == htab->glink
9928 || s == htab->dynbss)
65f38f15
AM		 9929 {
9930 /* Strip this section if we don't need it; see the
9931 comment below. */
5bd4f169 9932 }
58d180e8
AM		 9933 else if (s == htab->glink_eh_frame)
9934 {
9935 if (!bfd_is_abs_section (s->output_section))
9936 /* Not sized yet. */
9937 continue;
9938 }
70cc837d 9939 else if (CONST_STRNEQ (s->name, ".rela"))
5bd4f169 9940 {
c456f082 9941 if (s->size != 0)
5bd4f169 9942 {
33e44f2e 9943 if (s != htab->elf.srelplt)
b34976b6 9944 relocs = TRUE;
5bd4f169
AM		 9945
9946 /* We use the reloc_count field as a counter if we need
9947 to copy relocs into the output file. */
9948 s->reloc_count = 0;
9949 }
9950 }
65f38f15 9951 else
5bd4f169
AM		 9952 {
9953 /* It's not one of our sections, so don't allocate space. */
9954 continue;
9955 }
9956
eea6121a 9957 if (s->size == 0)
5bd4f169 9958 {
c456f082
AM		 9959 /* If we don't need this section, strip it from the
9960 output file. This is mostly to handle .rela.bss and
9961 .rela.plt. We must create both sections in
9962 create_dynamic_sections, because they must be created
9963 before the linker maps input sections to output
9964 sections. The linker does that before
9965 adjust_dynamic_symbol is called, and it is that
9966 function which decides whether anything needs to go
9967 into these sections. */
8423293d 9968 s->flags |= SEC_EXCLUDE;
5bd4f169
AM		 9969 continue;
9970 }
9971
c456f082 9972 if ((s->flags & SEC_HAS_CONTENTS) == 0)
5f333394
AM		 9973 continue;
9974
65f38f15
AM		 9975 /* Allocate memory for the section contents. We use bfd_zalloc
9976 here in case unused entries are not reclaimed before the
9977 section's contents are written out. This should not happen,
411e1bfb
AM		 9978 but this way if it does we get a R_PPC64_NONE reloc in .rela
9979 sections instead of garbage.
9980 We also rely on the section contents being zero when writing
9981 the GOT. */
eea6121a 9982 s->contents = bfd_zalloc (dynobj, s->size);
65f38f15 9983 if (s->contents == NULL)
b34976b6 9984 return FALSE;
5bd4f169
AM		 9985 }
9986
c72f2fb2 9987 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
e717da7e 9988 {
0c8d6e5c 9989 if (!is_ppc64_elf (ibfd))
7b53ace3
AM		 9990 continue;
9991
e717da7e 9992 s = ppc64_elf_tdata (ibfd)->got;
33e44f2e 9993 if (s != NULL && s != htab->elf.sgot)
e717da7e 9994 {
eea6121a 9995 if (s->size == 0)
8423293d 9996 s->flags |= SEC_EXCLUDE;
e717da7e
AM		 9997 else
9998 {
eea6121a 9999 s->contents = bfd_zalloc (ibfd, s->size);
e717da7e
AM		 10000 if (s->contents == NULL)
10001 return FALSE;
10002 }
10003 }
10004 s = ppc64_elf_tdata (ibfd)->relgot;
10005 if (s != NULL)
10006 {
eea6121a 10007 if (s->size == 0)
8423293d 10008 s->flags |= SEC_EXCLUDE;
e717da7e
AM		 10009 else
10010 {
eea6121a 10011 s->contents = bfd_zalloc (ibfd, s->size);
e717da7e
AM		 10012 if (s->contents == NULL)
10013 return FALSE;
10014 relocs = TRUE;
10015 s->reloc_count = 0;
10016 }
10017 }
10018 }
10019
e86ce104 10020 if (htab->elf.dynamic_sections_created)
5bd4f169 10021 {
e8910a83
AM		 10022 bfd_boolean tls_opt;
10023
5bd4f169
AM		 10024 /* Add some entries to the .dynamic section. We fill in the
10025 values later, in ppc64_elf_finish_dynamic_sections, but we
10026 must add the entries now so that we get the correct size for
10027 the .dynamic section. The DT_DEBUG entry is filled in by the
10028 dynamic linker and used by the debugger. */
dc810e39 10029#define add_dynamic_entry(TAG, VAL) \
5a580b3a 10030 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
dc810e39 10031
36af4a4e 10032 if (info->executable)
5bd4f169 10033 {
dc810e39 10034 if (!add_dynamic_entry (DT_DEBUG, 0))
b34976b6 10035 return FALSE;
5bd4f169
AM		 10036 }
10037
33e44f2e 10038 if (htab->elf.splt != NULL && htab->elf.splt->size != 0)
5bd4f169 10039 {
dc810e39
AM		 10040 if (!add_dynamic_entry (DT_PLTGOT, 0)
10041 || !add_dynamic_entry (DT_PLTRELSZ, 0)
10042 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
5d1634d7
AM		 10043 || !add_dynamic_entry (DT_JMPREL, 0)
10044 || !add_dynamic_entry (DT_PPC64_GLINK, 0))
b34976b6 10045 return FALSE;
5bd4f169
AM		 10046 }
10047
ee67d69a 10048 if (NO_OPD_RELOCS && abiversion (output_bfd) <= 1)
19397422
AM		 10049 {
10050 if (!add_dynamic_entry (DT_PPC64_OPD, 0)
10051 || !add_dynamic_entry (DT_PPC64_OPDSZ, 0))
b34976b6 10052 return FALSE;
19397422
AM		 10053 }
10054
e7d1c40c 10055 tls_opt = (!htab->params->no_tls_get_addr_opt
e8910a83
AM		 10056 && htab->tls_get_addr_fd != NULL
10057 && htab->tls_get_addr_fd->elf.plt.plist != NULL);
10058 if (tls_opt || !htab->opd_abi)
10059 {
10060 if (!add_dynamic_entry (DT_PPC64_OPT, tls_opt ? PPC64_OPT_TLS : 0))
10061 return FALSE;
10062 }
a7f2871e 10063
5bd4f169
AM		 10064 if (relocs)
10065 {
dc810e39
AM		 10066 if (!add_dynamic_entry (DT_RELA, 0)
10067 || !add_dynamic_entry (DT_RELASZ, 0)
10068 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
b34976b6 10069 return FALSE;
5bd4f169 10070
65f38f15
AM		 10071 /* If any dynamic relocs apply to a read-only section,
10072 then we need a DT_TEXTREL entry. */
248866a8 10073 if ((info->flags & DF_TEXTREL) == 0)
a345bc8d 10074 elf_link_hash_traverse (&htab->elf, maybe_set_textrel, info);
5bd4f169 10075
65f38f15 10076 if ((info->flags & DF_TEXTREL) != 0)
5bd4f169 10077 {
65f38f15 10078 if (!add_dynamic_entry (DT_TEXTREL, 0))
b34976b6 10079 return FALSE;
5bd4f169 10080 }
5bd4f169 10081 }
5bd4f169 10082 }
65f38f15 10083#undef add_dynamic_entry
5bd4f169 10084
b34976b6 10085 return TRUE;
5bd4f169
AM		 10086}
10087
a345bc8d
AM		 10088/* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
10089
10090static bfd_boolean
10091ppc64_elf_hash_symbol (struct elf_link_hash_entry *h)
10092{
10093 if (h->plt.plist != NULL
10094 && !h->def_regular
10095 && !h->pointer_equality_needed)
10096 return FALSE;
10097
10098 return _bfd_elf_hash_symbol (h);
10099}
10100
721956f4 10101/* Determine the type of stub needed, if any, for a call. */
5bd4f169 10102
4ce794b7
AM		 10103static inline enum ppc_stub_type
10104ppc_type_of_stub (asection *input_sec,
10105 const Elf_Internal_Rela *rel,
10106 struct ppc_link_hash_entry **hash,
e054468f 10107 struct plt_entry **plt_ent,
6911b7dc
AM		 10108 bfd_vma destination,
10109 unsigned long local_off)
5bd4f169 10110{
721956f4
AM		 10111 struct ppc_link_hash_entry *h = *hash;
10112 bfd_vma location;
10113 bfd_vma branch_offset;
10114 bfd_vma max_branch_offset;
4ce794b7 10115 enum elf_ppc64_reloc_type r_type;
5bd4f169 10116
721956f4
AM		 10117 if (h != NULL)
10118 {
e054468f 10119 struct plt_entry *ent;
7fe2b9a6 10120 struct ppc_link_hash_entry *fdh = h;
b31867b6
AM		 10121 if (h->oh != NULL
10122 && h->oh->is_func_descriptor)
7b8f6675
AM		 10123 {
10124 fdh = ppc_follow_link (h->oh);
10125 *hash = fdh;
10126 }
8387904d 10127
e054468f
AM		 10128 for (ent = fdh->elf.plt.plist; ent != NULL; ent = ent->next)
10129 if (ent->addend == rel->r_addend
10130 && ent->plt.offset != (bfd_vma) -1)
10131 {
e054468f
AM		 10132 *plt_ent = ent;
10133 return ppc_stub_plt_call;
10134 }
5bd4f169 10135
7fe2b9a6
AM		 10136 /* Here, we know we don't have a plt entry. If we don't have a
10137 either a defined function descriptor or a defined entry symbol
10138 in a regular object file, then it is pointless trying to make
10139 any other type of stub. */
854b41e7
AM		 10140 if (!is_static_defined (&fdh->elf)
10141 && !is_static_defined (&h->elf))
721956f4 10142 return ppc_stub_none;
5d1634d7 10143 }
e054468f
AM		 10144 else if (elf_local_got_ents (input_sec->owner) != NULL)
10145 {
10146 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (input_sec->owner);
10147 struct plt_entry **local_plt = (struct plt_entry **)
10148 elf_local_got_ents (input_sec->owner) + symtab_hdr->sh_info;
10149 unsigned long r_symndx = ELF64_R_SYM (rel->r_info);
10150
10151 if (local_plt[r_symndx] != NULL)
10152 {
10153 struct plt_entry *ent;
10154
10155 for (ent = local_plt[r_symndx]; ent != NULL; ent = ent->next)
10156 if (ent->addend == rel->r_addend
10157 && ent->plt.offset != (bfd_vma) -1)
10158 {
10159 *plt_ent = ent;
10160 return ppc_stub_plt_call;
10161 }
10162 }
10163 }
5d1634d7 10164
721956f4
AM		 10165 /* Determine where the call point is. */
10166 location = (input_sec->output_offset
10167 + input_sec->output_section->vma
10168 + rel->r_offset);
5d1634d7 10169
721956f4
AM		 10170 branch_offset = destination - location;
10171 r_type = ELF64_R_TYPE (rel->r_info);
5d1634d7 10172
721956f4
AM		 10173 /* Determine if a long branch stub is needed. */
10174 max_branch_offset = 1 << 25;
4ce794b7 10175 if (r_type != R_PPC64_REL24)
721956f4 10176 max_branch_offset = 1 << 15;
5d1634d7 10177
6911b7dc 10178 if (branch_offset + max_branch_offset >= 2 * max_branch_offset - local_off)
721956f4
AM		 10179 /* We need a stub. Figure out whether a long_branch or plt_branch
10180 is needed later. */
10181 return ppc_stub_long_branch;
5d1634d7 10182
721956f4 10183 return ppc_stub_none;
5d1634d7
AM		 10184}
10185
794e51c0
AM		 10186/* With power7 weakly ordered memory model, it is possible for ld.so
10187 to update a plt entry in one thread and have another thread see a
10188 stale zero toc entry. To avoid this we need some sort of acquire
10189 barrier in the call stub. One solution is to make the load of the
10190 toc word seem to appear to depend on the load of the function entry
10191 word. Another solution is to test for r2 being zero, and branch to
10192 the appropriate glink entry if so.
10193
10194 . fake dep barrier compare
71a39c98
AM		 10195 . ld 12,xxx(2) ld 12,xxx(2)
10196 . mtctr 12 mtctr 12
10197 . xor 11,12,12 ld 2,xxx+8(2)
794e51c0
AM		 10198 . add 2,2,11 cmpldi 2,0
10199 . ld 2,xxx+8(2) bnectr+
10200 . bctr b <glink_entry>
10201
10202 The solution involving the compare turns out to be faster, so
10203 that's what we use unless the branch won't reach. */
10204
10205#define ALWAYS_USE_FAKE_DEP 0
10206#define ALWAYS_EMIT_R2SAVE 0
5d1634d7 10207
5d1634d7
AM		 10208#define PPC_LO(v) ((v) & 0xffff)
10209#define PPC_HI(v) (((v) >> 16) & 0xffff)
10210#define PPC_HA(v) PPC_HI ((v) + 0x8000)
10211
794e51c0
AM		 10212static inline unsigned int
10213plt_stub_size (struct ppc_link_hash_table *htab,
10214 struct ppc_stub_hash_entry *stub_entry,
10215 bfd_vma off)
10216{
b9e5796b
AM		 10217 unsigned size = 12;
10218
10219 if (ALWAYS_EMIT_R2SAVE
10220 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10221 size += 4;
10222 if (PPC_HA (off) != 0)
794e51c0 10223 size += 4;
b9e5796b
AM		 10224 if (htab->opd_abi)
10225 {
10226 size += 4;
e7d1c40c 10227 if (htab->params->plt_static_chain)
b9e5796b 10228 size += 4;
bd4d2eaa
AM		 10229 if (htab->params->plt_thread_safe
10230 && htab->elf.dynamic_sections_created
10231 && stub_entry->h != NULL
10232 && stub_entry->h->elf.dynindx != -1)
b9e5796b 10233 size += 8;
e7d1c40c 10234 if (PPC_HA (off + 8 + 8 * htab->params->plt_static_chain) != PPC_HA (off))
b9e5796b
AM		 10235 size += 4;
10236 }
794e51c0
AM		 10237 if (stub_entry->h != NULL
10238 && (stub_entry->h == htab->tls_get_addr_fd
10239 || stub_entry->h == htab->tls_get_addr)
e7d1c40c 10240 && !htab->params->no_tls_get_addr_opt)
794e51c0
AM		 10241 size += 13 * 4;
10242 return size;
10243}
10244
10245/* If this stub would cross fewer 2**plt_stub_align boundaries if we align,
10246 then return the padding needed to do so. */
10247static inline unsigned int
10248plt_stub_pad (struct ppc_link_hash_table *htab,
10249 struct ppc_stub_hash_entry *stub_entry,
10250 bfd_vma plt_off)
10251{
e7d1c40c 10252 int stub_align = 1 << htab->params->plt_stub_align;
794e51c0
AM		 10253 unsigned stub_size = plt_stub_size (htab, stub_entry, plt_off);
10254 bfd_vma stub_off = stub_entry->stub_sec->size;
10255
10256 if (((stub_off + stub_size - 1) & -stub_align) - (stub_off & -stub_align)
e05fa0ba 10257 > ((stub_size - 1) & -stub_align))
794e51c0
AM		 10258 return stub_align - (stub_off & (stub_align - 1));
10259 return 0;
10260}
10261
10262/* Build a .plt call stub. */
10263
10264static inline bfd_byte *
10265build_plt_stub (struct ppc_link_hash_table *htab,
10266 struct ppc_stub_hash_entry *stub_entry,
10267 bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
10268{
e7d1c40c 10269 bfd *obfd = htab->params->stub_bfd;
b9e5796b 10270 bfd_boolean plt_load_toc = htab->opd_abi;
e7d1c40c 10271 bfd_boolean plt_static_chain = htab->params->plt_static_chain;
bd4d2eaa
AM		 10272 bfd_boolean plt_thread_safe = (htab->params->plt_thread_safe
10273 && htab->elf.dynamic_sections_created
10274 && stub_entry->h != NULL
10275 && stub_entry->h->elf.dynindx != -1);
794e51c0
AM		 10276 bfd_boolean use_fake_dep = plt_thread_safe;
10277 bfd_vma cmp_branch_off = 0;
10278
10279 if (!ALWAYS_USE_FAKE_DEP
b9e5796b 10280 && plt_load_toc
794e51c0 10281 && plt_thread_safe
bd4d2eaa
AM		 10282 && !((stub_entry->h == htab->tls_get_addr_fd
10283 || stub_entry->h == htab->tls_get_addr)
e7d1c40c 10284 && !htab->params->no_tls_get_addr_opt))
794e51c0
AM		 10285 {
10286 bfd_vma pltoff = stub_entry->plt_ent->plt.offset & ~1;
b9e5796b
AM		 10287 bfd_vma pltindex = ((pltoff - PLT_INITIAL_ENTRY_SIZE (htab))
10288 / PLT_ENTRY_SIZE (htab));
794e51c0
AM		 10289 bfd_vma glinkoff = GLINK_CALL_STUB_SIZE + pltindex * 8;
10290 bfd_vma to, from;
10291
68d62958
AM		 10292 if (pltindex > 32768)
10293 glinkoff += (pltindex - 32768) * 4;
794e51c0
AM		 10294 to = (glinkoff
10295 + htab->glink->output_offset
10296 + htab->glink->output_section->vma);
10297 from = (p - stub_entry->stub_sec->contents
10298 + 4 * (ALWAYS_EMIT_R2SAVE
10299 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10300 + 4 * (PPC_HA (offset) != 0)
10301 + 4 * (PPC_HA (offset + 8 + 8 * plt_static_chain)
10302 != PPC_HA (offset))
10303 + 4 * (plt_static_chain != 0)
10304 + 20
10305 + stub_entry->stub_sec->output_offset
10306 + stub_entry->stub_sec->output_section->vma);
10307 cmp_branch_off = to - from;
10308 use_fake_dep = cmp_branch_off + (1 << 25) >= (1 << 26);
10309 }
10310
ac2df442
AM		 10311 if (PPC_HA (offset) != 0)
10312 {
176a0d42
AM		 10313 if (r != NULL)
10314 {
794e51c0
AM		 10315 if (ALWAYS_EMIT_R2SAVE
10316 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10317 r[0].r_offset += 4;
176a0d42 10318 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
3b421ab3 10319 r[1].r_offset = r[0].r_offset + 4;
176a0d42
AM		 10320 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10321 r[1].r_addend = r[0].r_addend;
b9e5796b 10322 if (plt_load_toc)
176a0d42 10323 {
b9e5796b 10324 if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
c7131b65 10325 {
b9e5796b
AM		 10326 r[2].r_offset = r[1].r_offset + 4;
10327 r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO);
10328 r[2].r_addend = r[0].r_addend;
10329 }
10330 else
10331 {
10332 r[2].r_offset = r[1].r_offset + 8 + 8 * use_fake_dep;
10333 r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10334 r[2].r_addend = r[0].r_addend + 8;
10335 if (plt_static_chain)
10336 {
10337 r[3].r_offset = r[2].r_offset + 4;
10338 r[3].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10339 r[3].r_addend = r[0].r_addend + 16;
10340 }
c7131b65 10341 }
176a0d42
AM		 10342 }
10343 }
794e51c0
AM		 10344 if (ALWAYS_EMIT_R2SAVE
10345 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
a078d95a 10346 bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p), p += 4;
397998fc
AM		 10347 if (plt_load_toc)
10348 {
10349 bfd_put_32 (obfd, ADDIS_R11_R2 | PPC_HA (offset), p), p += 4;
10350 bfd_put_32 (obfd, LD_R12_0R11 | PPC_LO (offset), p), p += 4;
10351 }
10352 else
10353 {
10354 bfd_put_32 (obfd, ADDIS_R12_R2 | PPC_HA (offset), p), p += 4;
10355 bfd_put_32 (obfd, LD_R12_0R12 | PPC_LO (offset), p), p += 4;
10356 }
b9e5796b
AM		 10357 if (plt_load_toc
10358 && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
ac2df442 10359 {
71a39c98 10360 bfd_put_32 (obfd, ADDI_R11_R11 | PPC_LO (offset), p), p += 4;
ac2df442
AM		 10361 offset = 0;
10362 }
71a39c98 10363 bfd_put_32 (obfd, MTCTR_R12, p), p += 4;
b9e5796b 10364 if (plt_load_toc)
794e51c0 10365 {
b9e5796b
AM		 10366 if (use_fake_dep)
10367 {
10368 bfd_put_32 (obfd, XOR_R2_R12_R12, p), p += 4;
10369 bfd_put_32 (obfd, ADD_R11_R11_R2, p), p += 4;
10370 }
10371 bfd_put_32 (obfd, LD_R2_0R11 | PPC_LO (offset + 8), p), p += 4;
10372 if (plt_static_chain)
10373 bfd_put_32 (obfd, LD_R11_0R11 | PPC_LO (offset + 16), p), p += 4;
794e51c0 10374 }
ac2df442
AM		 10375 }
10376 else
10377 {
176a0d42
AM		 10378 if (r != NULL)
10379 {
794e51c0
AM		 10380 if (ALWAYS_EMIT_R2SAVE
10381 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10382 r[0].r_offset += 4;
176a0d42 10383 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
b9e5796b 10384 if (plt_load_toc)
176a0d42 10385 {
b9e5796b 10386 if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
c7131b65 10387 {
b9e5796b
AM		 10388 r[1].r_offset = r[0].r_offset + 4;
10389 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16);
10390 r[1].r_addend = r[0].r_addend;
10391 }
10392 else
10393 {
10394 r[1].r_offset = r[0].r_offset + 8 + 8 * use_fake_dep;
10395 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10396 r[1].r_addend = r[0].r_addend + 8 + 8 * plt_static_chain;
10397 if (plt_static_chain)
10398 {
10399 r[2].r_offset = r[1].r_offset + 4;
10400 r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10401 r[2].r_addend = r[0].r_addend + 8;
10402 }
c7131b65 10403 }
176a0d42
AM		 10404 }
10405 }
794e51c0
AM		 10406 if (ALWAYS_EMIT_R2SAVE
10407 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
a078d95a 10408 bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p), p += 4;
71a39c98 10409 bfd_put_32 (obfd, LD_R12_0R2 | PPC_LO (offset), p), p += 4;
b9e5796b
AM		 10410 if (plt_load_toc
10411 && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
ac2df442
AM		 10412 {
10413 bfd_put_32 (obfd, ADDI_R2_R2 | PPC_LO (offset), p), p += 4;
10414 offset = 0;
10415 }
71a39c98 10416 bfd_put_32 (obfd, MTCTR_R12, p), p += 4;
b9e5796b 10417 if (plt_load_toc)
794e51c0 10418 {
b9e5796b
AM		 10419 if (use_fake_dep)
10420 {
10421 bfd_put_32 (obfd, XOR_R11_R12_R12, p), p += 4;
10422 bfd_put_32 (obfd, ADD_R2_R2_R11, p), p += 4;
10423 }
10424 if (plt_static_chain)
10425 bfd_put_32 (obfd, LD_R11_0R2 | PPC_LO (offset + 16), p), p += 4;
10426 bfd_put_32 (obfd, LD_R2_0R2 | PPC_LO (offset + 8), p), p += 4;
794e51c0 10427 }
ac2df442 10428 }
b9e5796b 10429 if (plt_load_toc && plt_thread_safe && !use_fake_dep)
794e51c0
AM		 10430 {
10431 bfd_put_32 (obfd, CMPLDI_R2_0, p), p += 4;
10432 bfd_put_32 (obfd, BNECTR_P4, p), p += 4;
22aa0c7e 10433 bfd_put_32 (obfd, B_DOT | (cmp_branch_off & 0x3fffffc), p), p += 4;
794e51c0
AM		 10434 }
10435 else
10436 bfd_put_32 (obfd, BCTR, p), p += 4;
5d1634d7
AM		 10437 return p;
10438}
10439
a7f2871e
AM		 10440/* Build a special .plt call stub for __tls_get_addr. */
10441
10442#define LD_R11_0R3 0xe9630000
10443#define LD_R12_0R3 0xe9830000
10444#define MR_R0_R3 0x7c601b78
10445#define CMPDI_R11_0 0x2c2b0000
10446#define ADD_R3_R12_R13 0x7c6c6a14
10447#define BEQLR 0x4d820020
10448#define MR_R3_R0 0x7c030378
a7f2871e
AM		 10449#define STD_R11_0R1 0xf9610000
10450#define BCTRL 0x4e800421
10451#define LD_R11_0R1 0xe9610000
a7f2871e
AM		 10452#define MTLR_R11 0x7d6803a6
10453
10454static inline bfd_byte *
794e51c0
AM		 10455build_tls_get_addr_stub (struct ppc_link_hash_table *htab,
10456 struct ppc_stub_hash_entry *stub_entry,
10457 bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
a7f2871e 10458{
e7d1c40c 10459 bfd *obfd = htab->params->stub_bfd;
794e51c0 10460
a7f2871e
AM		 10461 bfd_put_32 (obfd, LD_R11_0R3 + 0, p), p += 4;
10462 bfd_put_32 (obfd, LD_R12_0R3 + 8, p), p += 4;
10463 bfd_put_32 (obfd, MR_R0_R3, p), p += 4;
10464 bfd_put_32 (obfd, CMPDI_R11_0, p), p += 4;
10465 bfd_put_32 (obfd, ADD_R3_R12_R13, p), p += 4;
10466 bfd_put_32 (obfd, BEQLR, p), p += 4;
10467 bfd_put_32 (obfd, MR_R3_R0, p), p += 4;
10468 bfd_put_32 (obfd, MFLR_R11, p), p += 4;
a078d95a 10469 bfd_put_32 (obfd, STD_R11_0R1 + STK_LINKER (htab), p), p += 4;
a7f2871e
AM		 10470
10471 if (r != NULL)
10472 r[0].r_offset += 9 * 4;
794e51c0 10473 p = build_plt_stub (htab, stub_entry, p, offset, r);
a7f2871e
AM		 10474 bfd_put_32 (obfd, BCTRL, p - 4);
10475
a078d95a 10476 bfd_put_32 (obfd, LD_R2_0R1 + STK_TOC (htab), p), p += 4;
bd4d2eaa 10477 bfd_put_32 (obfd, LD_R11_0R1 + STK_LINKER (htab), p), p += 4;
a7f2871e
AM		 10478 bfd_put_32 (obfd, MTLR_R11, p), p += 4;
10479 bfd_put_32 (obfd, BLR, p), p += 4;
10480
10481 return p;
10482}
10483
176a0d42
AM		 10484static Elf_Internal_Rela *
10485get_relocs (asection *sec, int count)
10486{
10487 Elf_Internal_Rela *relocs;
10488 struct bfd_elf_section_data *elfsec_data;
10489
10490 elfsec_data = elf_section_data (sec);
10491 relocs = elfsec_data->relocs;
10492 if (relocs == NULL)
10493 {
10494 bfd_size_type relsize;
10495 relsize = sec->reloc_count * sizeof (*relocs);
10496 relocs = bfd_alloc (sec->owner, relsize);
10497 if (relocs == NULL)
10498 return NULL;
10499 elfsec_data->relocs = relocs;
d4730f92
BS		 10500 elfsec_data->rela.hdr = bfd_zalloc (sec->owner,
10501 sizeof (Elf_Internal_Shdr));
10502 if (elfsec_data->rela.hdr == NULL)
10503 return NULL;
10504 elfsec_data->rela.hdr->sh_size = (sec->reloc_count
10505 * sizeof (Elf64_External_Rela));
10506 elfsec_data->rela.hdr->sh_entsize = sizeof (Elf64_External_Rela);
176a0d42
AM		 10507 sec->reloc_count = 0;
10508 }
10509 relocs += sec->reloc_count;
10510 sec->reloc_count += count;
10511 return relocs;
10512}
10513
aa374f67 10514static bfd_vma
25f53a85 10515get_r2off (struct bfd_link_info *info,
aa374f67
AM		 10516 struct ppc_stub_hash_entry *stub_entry)
10517{
25f53a85 10518 struct ppc_link_hash_table *htab = ppc_hash_table (info);
aa374f67
AM		 10519 bfd_vma r2off = htab->stub_group[stub_entry->target_section->id].toc_off;
10520
10521 if (r2off == 0)
10522 {
10523 /* Support linking -R objects. Get the toc pointer from the
10524 opd entry. */
10525 char buf[8];
b9e5796b
AM		 10526 if (!htab->opd_abi)
10527 return r2off;
aa374f67
AM		 10528 asection *opd = stub_entry->h->elf.root.u.def.section;
10529 bfd_vma opd_off = stub_entry->h->elf.root.u.def.value;
10530
10531 if (strcmp (opd->name, ".opd") != 0
10532 || opd->reloc_count != 0)
10533 {
bc30df16 10534 info->callbacks->einfo (_("%P: cannot find opd entry toc for `%T'\n"),
25f53a85 10535 stub_entry->h->elf.root.root.string);
aa374f67
AM		 10536 bfd_set_error (bfd_error_bad_value);
10537 return 0;
10538 }
10539 if (!bfd_get_section_contents (opd->owner, opd, buf, opd_off + 8, 8))
10540 return 0;
10541 r2off = bfd_get_64 (opd->owner, buf);
25f53a85 10542 r2off -= elf_gp (info->output_bfd);
aa374f67
AM		 10543 }
10544 r2off -= htab->stub_group[stub_entry->id_sec->id].toc_off;
10545 return r2off;
10546}
10547
b34976b6 10548static bfd_boolean
4ce794b7 10549ppc_build_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
5d1634d7 10550{
721956f4
AM		 10551 struct ppc_stub_hash_entry *stub_entry;
10552 struct ppc_branch_hash_entry *br_entry;
5d1634d7
AM		 10553 struct bfd_link_info *info;
10554 struct ppc_link_hash_table *htab;
721956f4
AM		 10555 bfd_byte *loc;
10556 bfd_byte *p;
ee75fd95 10557 bfd_vma dest, off;
721956f4 10558 int size;
176a0d42 10559 Elf_Internal_Rela *r;
e054468f 10560 asection *plt;
5d1634d7 10561
721956f4
AM		 10562 /* Massage our args to the form they really have. */
10563 stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
4ce794b7 10564 info = in_arg;
5d1634d7 10565
5d1634d7 10566 htab = ppc_hash_table (info);
4dfe6ac6
NC		 10567 if (htab == NULL)
10568 return FALSE;
5d1634d7 10569
721956f4 10570 /* Make a note of the offset within the stubs for this entry. */
eea6121a 10571 stub_entry->stub_offset = stub_entry->stub_sec->size;
97b639ba 10572 loc = stub_entry->stub_sec->contents + stub_entry->stub_offset;
721956f4 10573
4ce794b7 10574 htab->stub_count[stub_entry->stub_type - 1] += 1;
721956f4 10575 switch (stub_entry->stub_type)
5d1634d7 10576 {
721956f4 10577 case ppc_stub_long_branch:
ad8e1ba5 10578 case ppc_stub_long_branch_r2off:
721956f4 10579 /* Branches are relative. This is where we are going to. */
6911b7dc
AM		 10580 dest = (stub_entry->target_value
10581 + stub_entry->target_section->output_offset
10582 + stub_entry->target_section->output_section->vma);
10583 dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
10584 off = dest;
5d1634d7 10585
721956f4
AM		 10586 /* And this is where we are coming from. */
10587 off -= (stub_entry->stub_offset
97b639ba
AM		 10588 + stub_entry->stub_sec->output_offset
10589 + stub_entry->stub_sec->output_section->vma);
e86ce104 10590
ac2df442
AM		 10591 size = 4;
10592 if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
ad8e1ba5 10593 {
25f53a85 10594 bfd_vma r2off = get_r2off (info, stub_entry);
ad8e1ba5 10595
aa374f67
AM		 10596 if (r2off == 0)
10597 {
10598 htab->stub_error = TRUE;
10599 return FALSE;
10600 }
e7d1c40c 10601 bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), loc);
ad8e1ba5 10602 loc += 4;
ac2df442
AM		 10603 size = 12;
10604 if (PPC_HA (r2off) != 0)
10605 {
10606 size = 16;
e7d1c40c
AM		 10607 bfd_put_32 (htab->params->stub_bfd,
10608 ADDIS_R2_R2 | PPC_HA (r2off), loc);
ac2df442
AM		 10609 loc += 4;
10610 }
e7d1c40c 10611 bfd_put_32 (htab->params->stub_bfd, ADDI_R2_R2 | PPC_LO (r2off), loc);
ad8e1ba5 10612 loc += 4;
ac2df442 10613 off -= size - 4;
ad8e1ba5 10614 }
e7d1c40c 10615 bfd_put_32 (htab->params->stub_bfd, B_DOT | (off & 0x3fffffc), loc);
ad8e1ba5 10616
5c3dead3
AM		 10617 if (off + (1 << 25) >= (bfd_vma) (1 << 26))
10618 {
bc30df16
AM		 10619 info->callbacks->einfo
10620 (_("%P: long branch stub `%s' offset overflow\n"),
10621 stub_entry->root.string);
5c3dead3
AM		 10622 htab->stub_error = TRUE;
10623 return FALSE;
10624 }
ee75fd95
AM		 10625
10626 if (info->emitrelocations)
10627 {
176a0d42
AM		 10628 r = get_relocs (stub_entry->stub_sec, 1);
10629 if (r == NULL)
10630 return FALSE;
ee75fd95
AM		 10631 r->r_offset = loc - stub_entry->stub_sec->contents;
10632 r->r_info = ELF64_R_INFO (0, R_PPC64_REL24);
10633 r->r_addend = dest;
10634 if (stub_entry->h != NULL)
10635 {
10636 struct elf_link_hash_entry **hashes;
10637 unsigned long symndx;
10638 struct ppc_link_hash_entry *h;
10639
e7d1c40c 10640 hashes = elf_sym_hashes (htab->params->stub_bfd);
ee75fd95
AM		 10641 if (hashes == NULL)
10642 {
10643 bfd_size_type hsize;
10644
10645 hsize = (htab->stub_globals + 1) * sizeof (*hashes);
e7d1c40c 10646 hashes = bfd_zalloc (htab->params->stub_bfd, hsize);
ee75fd95
AM		 10647 if (hashes == NULL)
10648 return FALSE;
e7d1c40c 10649 elf_sym_hashes (htab->params->stub_bfd) = hashes;
ee75fd95
AM		 10650 htab->stub_globals = 1;
10651 }
10652 symndx = htab->stub_globals++;
10653 h = stub_entry->h;
10654 hashes[symndx] = &h->elf;
10655 r->r_info = ELF64_R_INFO (symndx, R_PPC64_REL24);
10656 if (h->oh != NULL && h->oh->is_func)
b31867b6 10657 h = ppc_follow_link (h->oh);
ee75fd95
AM		 10658 if (h->elf.root.u.def.section != stub_entry->target_section)
10659 /* H is an opd symbol. The addend must be zero. */
10660 r->r_addend = 0;
10661 else
10662 {
10663 off = (h->elf.root.u.def.value
10664 + h->elf.root.u.def.section->output_offset
10665 + h->elf.root.u.def.section->output_section->vma);
10666 r->r_addend -= off;
10667 }
10668 }
10669 }
721956f4 10670 break;
e86ce104 10671
721956f4 10672 case ppc_stub_plt_branch:
ad8e1ba5 10673 case ppc_stub_plt_branch_r2off:
721956f4
AM		 10674 br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
10675 stub_entry->root.string + 9,
b34976b6 10676 FALSE, FALSE);
721956f4
AM		 10677 if (br_entry == NULL)
10678 {
8de848d8 10679 info->callbacks->einfo (_("%P: can't find branch stub `%s'\n"),
25f53a85 10680 stub_entry->root.string);
b34976b6
AM		 10681 htab->stub_error = TRUE;
10682 return FALSE;
721956f4
AM		 10683 }
10684
176a0d42
AM		 10685 dest = (stub_entry->target_value
10686 + stub_entry->target_section->output_offset
10687 + stub_entry->target_section->output_section->vma);
6911b7dc
AM		 10688 if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
10689 dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
721956f4 10690
176a0d42 10691 bfd_put_64 (htab->brlt->owner, dest,
4ce794b7 10692 htab->brlt->contents + br_entry->offset);
721956f4 10693
f94498ff 10694 if (br_entry->iter == htab->stub_iteration)
721956f4 10695 {
f94498ff 10696 br_entry->iter = 0;
84f5d08e 10697
f94498ff 10698 if (htab->relbrlt != NULL)
84f5d08e 10699 {
f94498ff
AM		 10700 /* Create a reloc for the branch lookup table entry. */
10701 Elf_Internal_Rela rela;
10702 bfd_byte *rl;
10703
10704 rela.r_offset = (br_entry->offset
10705 + htab->brlt->output_offset
10706 + htab->brlt->output_section->vma);
10707 rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
176a0d42 10708 rela.r_addend = dest;
f94498ff
AM		 10709
10710 rl = htab->relbrlt->contents;
10711 rl += (htab->relbrlt->reloc_count++
10712 * sizeof (Elf64_External_Rela));
10713 bfd_elf64_swap_reloca_out (htab->relbrlt->owner, &rela, rl);
10714 }
10715 else if (info->emitrelocations)
10716 {
176a0d42
AM		 10717 r = get_relocs (htab->brlt, 1);
10718 if (r == NULL)
10719 return FALSE;
10720 /* brlt, being SEC_LINKER_CREATED does not go through the
10721 normal reloc processing. Symbols and offsets are not
10722 translated from input file to output file form, so
10723 set up the offset per the output file. */
f94498ff
AM		 10724 r->r_offset = (br_entry->offset
10725 + htab->brlt->output_offset
10726 + htab->brlt->output_section->vma);
10727 r->r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
176a0d42 10728 r->r_addend = dest;
84f5d08e 10729 }
84f5d08e 10730 }
721956f4 10731
176a0d42
AM		 10732 dest = (br_entry->offset
10733 + htab->brlt->output_offset
10734 + htab->brlt->output_section->vma);
10735
10736 off = (dest
4ce794b7 10737 - elf_gp (htab->brlt->output_section->owner)
ad8e1ba5 10738 - htab->stub_group[stub_entry->id_sec->id].toc_off);
721956f4 10739
ad8e1ba5 10740 if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
5d1634d7 10741 {
25f53a85 10742 info->callbacks->einfo
bc30df16 10743 (_("%P: linkage table error against `%T'\n"),
721956f4 10744 stub_entry->root.string);
5d1634d7 10745 bfd_set_error (bfd_error_bad_value);
b34976b6
AM		 10746 htab->stub_error = TRUE;
10747 return FALSE;
5d1634d7 10748 }
41bd81ab 10749
176a0d42
AM		 10750 if (info->emitrelocations)
10751 {
10752 r = get_relocs (stub_entry->stub_sec, 1 + (PPC_HA (off) != 0));
10753 if (r == NULL)
10754 return FALSE;
10755 r[0].r_offset = loc - stub_entry->stub_sec->contents;
7cfbafbc
AM		 10756 if (bfd_big_endian (info->output_bfd))
10757 r[0].r_offset += 2;
00f412ee 10758 if (stub_entry->stub_type == ppc_stub_plt_branch_r2off)
176a0d42
AM		 10759 r[0].r_offset += 4;
10760 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10761 r[0].r_addend = dest;
10762 if (PPC_HA (off) != 0)
10763 {
10764 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
10765 r[1].r_offset = r[0].r_offset + 4;
10766 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10767 r[1].r_addend = r[0].r_addend;
10768 }
10769 }
10770
00f412ee 10771 if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
ad8e1ba5 10772 {
176a0d42 10773 if (PPC_HA (off) != 0)
ac2df442
AM		 10774 {
10775 size = 16;
e7d1c40c 10776 bfd_put_32 (htab->params->stub_bfd,
397998fc 10777 ADDIS_R12_R2 | PPC_HA (off), loc);
ac2df442 10778 loc += 4;
e7d1c40c 10779 bfd_put_32 (htab->params->stub_bfd,
397998fc 10780 LD_R12_0R12 | PPC_LO (off), loc);
ac2df442
AM		 10781 }
10782 else
10783 {
10784 size = 12;
e7d1c40c
AM		 10785 bfd_put_32 (htab->params->stub_bfd,
10786 LD_R12_0R2 | PPC_LO (off), loc);
ac2df442 10787 }
ad8e1ba5
AM		 10788 }
10789 else
10790 {
25f53a85 10791 bfd_vma r2off = get_r2off (info, stub_entry);
aa374f67 10792
00f412ee 10793 if (r2off == 0 && htab->opd_abi)
aa374f67
AM		 10794 {
10795 htab->stub_error = TRUE;
10796 return FALSE;
10797 }
ad8e1ba5 10798
e7d1c40c 10799 bfd_put_32 (htab->params->stub_bfd, STD_R2_0R1 + STK_TOC (htab), loc);
ad8e1ba5 10800 loc += 4;
00f412ee 10801 size = 16;
176a0d42 10802 if (PPC_HA (off) != 0)
ac2df442
AM		 10803 {
10804 size += 4;
e7d1c40c 10805 bfd_put_32 (htab->params->stub_bfd,
397998fc 10806 ADDIS_R12_R2 | PPC_HA (off), loc);
ac2df442 10807 loc += 4;
e7d1c40c 10808 bfd_put_32 (htab->params->stub_bfd,
397998fc 10809 LD_R12_0R12 | PPC_LO (off), loc);
ac2df442
AM		 10810 }
10811 else
e7d1c40c 10812 bfd_put_32 (htab->params->stub_bfd, LD_R12_0R2 | PPC_LO (off), loc);
ac2df442
AM		 10813
10814 if (PPC_HA (r2off) != 0)
10815 {
10816 size += 4;
00f412ee 10817 loc += 4;
e7d1c40c
AM		 10818 bfd_put_32 (htab->params->stub_bfd,
10819 ADDIS_R2_R2 | PPC_HA (r2off), loc);
00f412ee
AM		 10820 }
10821 if (PPC_LO (r2off) != 0)
10822 {
10823 size += 4;
ac2df442 10824 loc += 4;
e7d1c40c
AM		 10825 bfd_put_32 (htab->params->stub_bfd,
10826 ADDI_R2_R2 | PPC_LO (r2off), loc);
ac2df442 10827 }
ad8e1ba5
AM		 10828 }
10829 loc += 4;
e7d1c40c 10830 bfd_put_32 (htab->params->stub_bfd, MTCTR_R12, loc);
ad8e1ba5 10831 loc += 4;
e7d1c40c 10832 bfd_put_32 (htab->params->stub_bfd, BCTR, loc);
721956f4 10833 break;
5d1634d7 10834
721956f4 10835 case ppc_stub_plt_call:
794e51c0 10836 case ppc_stub_plt_call_r2save:
e054468f 10837 if (stub_entry->h != NULL
b31867b6
AM		 10838 && stub_entry->h->is_func_descriptor
10839 && stub_entry->h->oh != NULL)
c862ae31 10840 {
b31867b6
AM		 10841 struct ppc_link_hash_entry *fh = ppc_follow_link (stub_entry->h->oh);
10842
10843 /* If the old-ABI "dot-symbol" is undefined make it weak so
10844 we don't get a link error from RELOC_FOR_GLOBAL_SYMBOL.
10845 FIXME: We used to define the symbol on one of the call
10846 stubs instead, which is why we test symbol section id
10847 against htab->top_id in various places. Likely all
10848 these checks could now disappear. */
10849 if (fh->elf.root.type == bfd_link_hash_undefined)
10850 fh->elf.root.type = bfd_link_hash_undefweak;
9507a174
AM		 10851 /* Stop undo_symbol_twiddle changing it back to undefined. */
10852 fh->was_undefined = 0;
c862ae31
AM		 10853 }
10854
721956f4 10855 /* Now build the stub. */
e054468f 10856 dest = stub_entry->plt_ent->plt.offset & ~1;
176a0d42 10857 if (dest >= (bfd_vma) -2)
721956f4
AM		 10858 abort ();
10859
33e44f2e 10860 plt = htab->elf.splt;
25f23106
AM		 10861 if (!htab->elf.dynamic_sections_created
10862 || stub_entry->h == NULL
10863 || stub_entry->h->elf.dynindx == -1)
33e44f2e 10864 plt = htab->elf.iplt;
e054468f
AM		 10865
10866 dest += plt->output_offset + plt->output_section->vma;
10867
10868 if (stub_entry->h == NULL
10869 && (stub_entry->plt_ent->plt.offset & 1) == 0)
10870 {
10871 Elf_Internal_Rela rela;
10872 bfd_byte *rl;
10873
10874 rela.r_offset = dest;
ee67d69a
AM		 10875 if (htab->opd_abi)
10876 rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
10877 else
10878 rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
e054468f
AM		 10879 rela.r_addend = (stub_entry->target_value
10880 + stub_entry->target_section->output_offset
10881 + stub_entry->target_section->output_section->vma);
10882
33e44f2e
AM		 10883 rl = (htab->elf.irelplt->contents
10884 + (htab->elf.irelplt->reloc_count++
25f23106
AM		 10885 * sizeof (Elf64_External_Rela)));
10886 bfd_elf64_swap_reloca_out (info->output_bfd, &rela, rl);
e054468f
AM		 10887 stub_entry->plt_ent->plt.offset |= 1;
10888 }
176a0d42
AM		 10889
10890 off = (dest
e054468f 10891 - elf_gp (plt->output_section->owner)
176a0d42 10892 - htab->stub_group[stub_entry->id_sec->id].toc_off);
721956f4 10893
ad8e1ba5 10894 if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
721956f4 10895 {
25f53a85 10896 info->callbacks->einfo
bc30df16 10897 (_("%P: linkage table error against `%T'\n"),
e054468f
AM		 10898 stub_entry->h != NULL
10899 ? stub_entry->h->elf.root.root.string
10900 : "<local sym>");
721956f4 10901 bfd_set_error (bfd_error_bad_value);
b34976b6
AM		 10902 htab->stub_error = TRUE;
10903 return FALSE;
721956f4
AM		 10904 }
10905
e7d1c40c 10906 if (htab->params->plt_stub_align != 0)
794e51c0
AM		 10907 {
10908 unsigned pad = plt_stub_pad (htab, stub_entry, off);
10909
10910 stub_entry->stub_sec->size += pad;
10911 stub_entry->stub_offset = stub_entry->stub_sec->size;
10912 loc += pad;
10913 }
10914
176a0d42
AM		 10915 r = NULL;
10916 if (info->emitrelocations)
10917 {
10918 r = get_relocs (stub_entry->stub_sec,
3ba720c7
AM		 10919 ((PPC_HA (off) != 0)
10920 + (htab->opd_abi
e7d1c40c 10921 ? 2 + (htab->params->plt_static_chain
3ba720c7
AM		 10922 && PPC_HA (off + 16) == PPC_HA (off))
10923 : 1)));
176a0d42
AM		 10924 if (r == NULL)
10925 return FALSE;
10926 r[0].r_offset = loc - stub_entry->stub_sec->contents;
7cfbafbc
AM		 10927 if (bfd_big_endian (info->output_bfd))
10928 r[0].r_offset += 2;
176a0d42
AM		 10929 r[0].r_addend = dest;
10930 }
a7f2871e
AM		 10931 if (stub_entry->h != NULL
10932 && (stub_entry->h == htab->tls_get_addr_fd
10933 || stub_entry->h == htab->tls_get_addr)
e7d1c40c 10934 && !htab->params->no_tls_get_addr_opt)
794e51c0 10935 p = build_tls_get_addr_stub (htab, stub_entry, loc, off, r);
a7f2871e 10936 else
794e51c0 10937 p = build_plt_stub (htab, stub_entry, loc, off, r);
721956f4
AM		 10938 size = p - loc;
10939 break;
10940
10941 default:
10942 BFD_FAIL ();
b34976b6 10943 return FALSE;
721956f4
AM		 10944 }
10945
eea6121a 10946 stub_entry->stub_sec->size += size;
97b639ba 10947
e7d1c40c 10948 if (htab->params->emit_stub_syms)
97b639ba
AM		 10949 {
10950 struct elf_link_hash_entry *h;
ee75fd95
AM		 10951 size_t len1, len2;
10952 char *name;
10953 const char *const stub_str[] = { "long_branch",
10954 "long_branch_r2off",
10955 "plt_branch",
10956 "plt_branch_r2off",
794e51c0 10957 "plt_call",
ee75fd95
AM		 10958 "plt_call" };
10959
10960 len1 = strlen (stub_str[stub_entry->stub_type - 1]);
10961 len2 = strlen (stub_entry->root.string);
10962 name = bfd_malloc (len1 + len2 + 2);
10963 if (name == NULL)
10964 return FALSE;
10965 memcpy (name, stub_entry->root.string, 9);
10966 memcpy (name + 9, stub_str[stub_entry->stub_type - 1], len1);
10967 memcpy (name + len1 + 9, stub_entry->root.string + 8, len2 - 8 + 1);
10968 h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
97b639ba
AM		 10969 if (h == NULL)
10970 return FALSE;
10971 if (h->root.type == bfd_link_hash_new)
10972 {
10973 h->root.type = bfd_link_hash_defined;
10974 h->root.u.def.section = stub_entry->stub_sec;
10975 h->root.u.def.value = stub_entry->stub_offset;
f5385ebf
AM		 10976 h->ref_regular = 1;
10977 h->def_regular = 1;
10978 h->ref_regular_nonweak = 1;
10979 h->forced_local = 1;
10980 h->non_elf = 0;
2ec55de3 10981 h->root.linker_def = 1;
97b639ba
AM		 10982 }
10983 }
10984
b34976b6 10985 return TRUE;
721956f4
AM		 10986}
10987
10988/* As above, but don't actually build the stub. Just bump offset so
10989 we know stub section sizes, and select plt_branch stubs where
10990 long_branch stubs won't do. */
10991
b34976b6 10992static bfd_boolean
4ce794b7 10993ppc_size_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
721956f4
AM		 10994{
10995 struct ppc_stub_hash_entry *stub_entry;
63bc6f6c 10996 struct bfd_link_info *info;
721956f4
AM		 10997 struct ppc_link_hash_table *htab;
10998 bfd_vma off;
10999 int size;
11000
11001 /* Massage our args to the form they really have. */
11002 stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
63bc6f6c
AM		 11003 info = in_arg;
11004
11005 htab = ppc_hash_table (info);
4dfe6ac6
NC		 11006 if (htab == NULL)
11007 return FALSE;
721956f4 11008
794e51c0
AM		 11009 if (stub_entry->stub_type == ppc_stub_plt_call
11010 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
721956f4 11011 {
e054468f
AM		 11012 asection *plt;
11013 off = stub_entry->plt_ent->plt.offset & ~(bfd_vma) 1;
58ac9f71 11014 if (off >= (bfd_vma) -2)
411e1bfb 11015 abort ();
33e44f2e 11016 plt = htab->elf.splt;
25f23106
AM		 11017 if (!htab->elf.dynamic_sections_created
11018 || stub_entry->h == NULL
11019 || stub_entry->h->elf.dynindx == -1)
33e44f2e 11020 plt = htab->elf.iplt;
e054468f
AM		 11021 off += (plt->output_offset
11022 + plt->output_section->vma
11023 - elf_gp (plt->output_section->owner)
ad8e1ba5 11024 - htab->stub_group[stub_entry->id_sec->id].toc_off);
721956f4 11025
794e51c0 11026 size = plt_stub_size (htab, stub_entry, off);
e7d1c40c 11027 if (htab->params->plt_stub_align)
794e51c0 11028 size += plt_stub_pad (htab, stub_entry, off);
176a0d42
AM		 11029 if (info->emitrelocations)
11030 {
11031 stub_entry->stub_sec->reloc_count
b9e5796b
AM		 11032 += ((PPC_HA (off) != 0)
11033 + (htab->opd_abi
e7d1c40c 11034 ? 2 + (htab->params->plt_static_chain
b9e5796b
AM		 11035 && PPC_HA (off + 16) == PPC_HA (off))
11036 : 1));
176a0d42
AM		 11037 stub_entry->stub_sec->flags |= SEC_RELOC;
11038 }
721956f4
AM		 11039 }
11040 else
11041 {
ad8e1ba5
AM		 11042 /* ppc_stub_long_branch or ppc_stub_plt_branch, or their r2off
11043 variants. */
ac2df442 11044 bfd_vma r2off = 0;
6911b7dc 11045 bfd_vma local_off = 0;
ac2df442 11046
721956f4
AM		 11047 off = (stub_entry->target_value
11048 + stub_entry->target_section->output_offset
11049 + stub_entry->target_section->output_section->vma);
eea6121a 11050 off -= (stub_entry->stub_sec->size
721956f4
AM		 11051 + stub_entry->stub_sec->output_offset
11052 + stub_entry->stub_sec->output_section->vma);
11053
ad8e1ba5
AM		 11054 /* Reset the stub type from the plt variant in case we now
11055 can reach with a shorter stub. */
11056 if (stub_entry->stub_type >= ppc_stub_plt_branch)
11057 stub_entry->stub_type += ppc_stub_long_branch - ppc_stub_plt_branch;
11058
11059 size = 4;
11060 if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
11061 {
25f53a85 11062 r2off = get_r2off (info, stub_entry);
b9e5796b 11063 if (r2off == 0 && htab->opd_abi)
aa374f67
AM		 11064 {
11065 htab->stub_error = TRUE;
11066 return FALSE;
11067 }
ac2df442
AM		 11068 size = 12;
11069 if (PPC_HA (r2off) != 0)
11070 size = 16;
11071 off -= size - 4;
ad8e1ba5
AM		 11072 }
11073
6911b7dc
AM		 11074 local_off = PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
11075
b9e5796b
AM		 11076 /* If the branch offset if too big, use a ppc_stub_plt_branch.
11077 Do the same for -R objects without function descriptors. */
11078 if (off + (1 << 25) >= (bfd_vma) (1 << 26) - local_off
11079 || (stub_entry->stub_type == ppc_stub_long_branch_r2off
11080 && r2off == 0))
721956f4
AM		 11081 {
11082 struct ppc_branch_hash_entry *br_entry;
11083
11084 br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
11085 stub_entry->root.string + 9,
b34976b6 11086 TRUE, FALSE);
721956f4
AM		 11087 if (br_entry == NULL)
11088 {
8de848d8 11089 info->callbacks->einfo (_("%P: can't build branch stub `%s'\n"),
25f53a85 11090 stub_entry->root.string);
b34976b6
AM		 11091 htab->stub_error = TRUE;
11092 return FALSE;
721956f4
AM		 11093 }
11094
11095 if (br_entry->iter != htab->stub_iteration)
11096 {
11097 br_entry->iter = htab->stub_iteration;
eea6121a
AM		 11098 br_entry->offset = htab->brlt->size;
11099 htab->brlt->size += 8;
63bc6f6c 11100
ee75fd95 11101 if (htab->relbrlt != NULL)
eea6121a 11102 htab->relbrlt->size += sizeof (Elf64_External_Rela);
84f5d08e
AM		 11103 else if (info->emitrelocations)
11104 {
11105 htab->brlt->reloc_count += 1;
11106 htab->brlt->flags |= SEC_RELOC;
11107 }
721956f4 11108 }
ad8e1ba5
AM		 11109
11110 stub_entry->stub_type += ppc_stub_plt_branch - ppc_stub_long_branch;
ac2df442
AM		 11111 off = (br_entry->offset
11112 + htab->brlt->output_offset
11113 + htab->brlt->output_section->vma
11114 - elf_gp (htab->brlt->output_section->owner)
11115 - htab->stub_group[stub_entry->id_sec->id].toc_off);
11116
176a0d42
AM		 11117 if (info->emitrelocations)
11118 {
11119 stub_entry->stub_sec->reloc_count += 1 + (PPC_HA (off) != 0);
11120 stub_entry->stub_sec->flags |= SEC_RELOC;
11121 }
11122
00f412ee 11123 if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
ac2df442
AM		 11124 {
11125 size = 12;
176a0d42 11126 if (PPC_HA (off) != 0)
ac2df442
AM		 11127 size = 16;
11128 }
11129 else
11130 {
00f412ee 11131 size = 16;
176a0d42 11132 if (PPC_HA (off) != 0)
ac2df442
AM		 11133 size += 4;
11134
11135 if (PPC_HA (r2off) != 0)
11136 size += 4;
00f412ee
AM		 11137 if (PPC_LO (r2off) != 0)
11138 size += 4;
ac2df442 11139 }
721956f4 11140 }
84f5d08e
AM		 11141 else if (info->emitrelocations)
11142 {
11143 stub_entry->stub_sec->reloc_count += 1;
11144 stub_entry->stub_sec->flags |= SEC_RELOC;
11145 }
721956f4
AM		 11146 }
11147
eea6121a 11148 stub_entry->stub_sec->size += size;
b34976b6 11149 return TRUE;
721956f4
AM		 11150}
11151
11152/* Set up various things so that we can make a list of input sections
11153 for each output section included in the link. Returns -1 on error,
cedb70c5 11154 0 when no stubs will be needed, and 1 on success. */
721956f4
AM		 11155
11156int
e7d1c40c 11157ppc64_elf_setup_section_lists (struct bfd_link_info *info)
721956f4
AM		 11158{
11159 bfd *input_bfd;
734b6cf9 11160 int top_id, top_index, id;
721956f4 11161 asection *section;
734b6cf9 11162 asection **input_list;
721956f4
AM		 11163 bfd_size_type amt;
11164 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11165
4dfe6ac6
NC		 11166 if (htab == NULL)
11167 return -1;
4c52953f 11168
1e2f5b6e 11169 /* Find the top input section id. */
3d6f9012 11170 for (input_bfd = info->input_bfds, top_id = 3;
721956f4 11171 input_bfd != NULL;
c72f2fb2 11172 input_bfd = input_bfd->link.next)
721956f4 11173 {
721956f4
AM		 11174 for (section = input_bfd->sections;
11175 section != NULL;
11176 section = section->next)
11177 {
11178 if (top_id < section->id)
11179 top_id = section->id;
11180 }
11181 }
721956f4 11182
8f3bab57 11183 htab->top_id = top_id;
721956f4 11184 amt = sizeof (struct map_stub) * (top_id + 1);
4ce794b7 11185 htab->stub_group = bfd_zmalloc (amt);
721956f4
AM		 11186 if (htab->stub_group == NULL)
11187 return -1;
11188
3d6f9012
AM		 11189 /* Set toc_off for com, und, abs and ind sections. */
11190 for (id = 0; id < 3; id++)
11191 htab->stub_group[id].toc_off = TOC_BASE_OFF;
721956f4 11192
734b6cf9
AM		 11193 /* We can't use output_bfd->section_count here to find the top output
11194 section index as some sections may have been removed, and
8423293d 11195 strip_excluded_output_sections doesn't renumber the indices. */
927be08e 11196 for (section = info->output_bfd->sections, top_index = 0;
734b6cf9
AM		 11197 section != NULL;
11198 section = section->next)
11199 {
11200 if (top_index < section->index)
11201 top_index = section->index;
11202 }
11203
11204 htab->top_index = top_index;
11205 amt = sizeof (asection *) * (top_index + 1);
4ce794b7 11206 input_list = bfd_zmalloc (amt);
734b6cf9
AM		 11207 htab->input_list = input_list;
11208 if (input_list == NULL)
11209 return -1;
11210
721956f4
AM		 11211 return 1;
11212}
11213
927be08e
AM		 11214/* Set up for first pass at multitoc partitioning. */
11215
11216void
11217ppc64_elf_start_multitoc_partition (struct bfd_link_info *info)
11218{
11219 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11220
1c865ab2 11221 htab->toc_curr = ppc64_elf_set_toc (info, info->output_bfd);
927be08e
AM		 11222 htab->toc_bfd = NULL;
11223 htab->toc_first_sec = NULL;
11224}
11225
e717da7e
AM		 11226/* The linker repeatedly calls this function for each TOC input section
11227 and linker generated GOT section. Group input bfds such that the toc
927be08e 11228 within a group is less than 64k in size. */
ad8e1ba5 11229
927be08e 11230bfd_boolean
4ce794b7 11231ppc64_elf_next_toc_section (struct bfd_link_info *info, asection *isec)
ad8e1ba5
AM		 11232{
11233 struct ppc_link_hash_table *htab = ppc_hash_table (info);
d77c8a4b 11234 bfd_vma addr, off, limit;
ad8e1ba5 11235
4dfe6ac6
NC		 11236 if (htab == NULL)
11237 return FALSE;
11238
927be08e 11239 if (!htab->second_toc_pass)
4c52953f 11240 {
927be08e 11241 /* Keep track of the first .toc or .got section for this input bfd. */
a4fd3de5
AM		 11242 bfd_boolean new_bfd = htab->toc_bfd != isec->owner;
11243
11244 if (new_bfd)
bf102f86
AM		 11245 {
11246 htab->toc_bfd = isec->owner;
11247 htab->toc_first_sec = isec;
11248 }
927be08e 11249
bf102f86
AM		 11250 addr = isec->output_offset + isec->output_section->vma;
11251 off = addr - htab->toc_curr;
d77c8a4b
AM		 11252 limit = 0x80008000;
11253 if (ppc64_elf_tdata (isec->owner)->has_small_toc_reloc)
11254 limit = 0x10000;
11255 if (off + isec->size > limit)
bf102f86
AM		 11256 {
11257 addr = (htab->toc_first_sec->output_offset
11258 + htab->toc_first_sec->output_section->vma);
11259 htab->toc_curr = addr;
11260 }
99877b66 11261
927be08e
AM		 11262 /* toc_curr is the base address of this toc group. Set elf_gp
11263 for the input section to be the offset relative to the
11264 output toc base plus 0x8000. Making the input elf_gp an
11265 offset allows us to move the toc as a whole without
11266 recalculating input elf_gp. */
11267 off = htab->toc_curr - elf_gp (isec->output_section->owner);
11268 off += TOC_BASE_OFF;
11269
11270 /* Die if someone uses a linker script that doesn't keep input
11271 file .toc and .got together. */
a4fd3de5
AM		 11272 if (new_bfd
11273 && elf_gp (isec->owner) != 0
927be08e
AM		 11274 && elf_gp (isec->owner) != off)
11275 return FALSE;
11276
11277 elf_gp (isec->owner) = off;
11278 return TRUE;
4c52953f 11279 }
927be08e
AM		 11280
11281 /* During the second pass toc_first_sec points to the start of
11282 a toc group, and toc_curr is used to track the old elf_gp.
11283 We use toc_bfd to ensure we only look at each bfd once. */
11284 if (htab->toc_bfd == isec->owner)
11285 return TRUE;
11286 htab->toc_bfd = isec->owner;
11287
11288 if (htab->toc_first_sec == NULL
11289 || htab->toc_curr != elf_gp (isec->owner))
11290 {
11291 htab->toc_curr = elf_gp (isec->owner);
11292 htab->toc_first_sec = isec;
11293 }
11294 addr = (htab->toc_first_sec->output_offset
11295 + htab->toc_first_sec->output_section->vma);
11296 off = addr - elf_gp (isec->output_section->owner) + TOC_BASE_OFF;
11297 elf_gp (isec->owner) = off;
11298
11299 return TRUE;
ad8e1ba5
AM		 11300}
11301
927be08e
AM		 11302/* Called via elf_link_hash_traverse to merge GOT entries for global
11303 symbol H. */
11304
11305static bfd_boolean
11306merge_global_got (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
11307{
11308 if (h->root.type == bfd_link_hash_indirect)
11309 return TRUE;
11310
927be08e
AM		 11311 merge_got_entries (&h->got.glist);
11312
11313 return TRUE;
11314}
11315
11316/* Called via elf_link_hash_traverse to allocate GOT entries for global
11317 symbol H. */
11318
11319static bfd_boolean
11320reallocate_got (struct elf_link_hash_entry *h, void *inf)
11321{
11322 struct got_entry *gent;
11323
11324 if (h->root.type == bfd_link_hash_indirect)
11325 return TRUE;
11326
927be08e
AM		 11327 for (gent = h->got.glist; gent != NULL; gent = gent->next)
11328 if (!gent->is_indirect)
11329 allocate_got (h, (struct bfd_link_info *) inf, gent);
11330 return TRUE;
11331}
11332
11333/* Called on the first multitoc pass after the last call to
11334 ppc64_elf_next_toc_section. This function removes duplicate GOT
11335 entries. */
11336
11337bfd_boolean
11338ppc64_elf_layout_multitoc (struct bfd_link_info *info)
ad8e1ba5
AM		 11339{
11340 struct ppc_link_hash_table *htab = ppc_hash_table (info);
927be08e
AM		 11341 struct bfd *ibfd, *ibfd2;
11342 bfd_boolean done_something;
11343
11344 htab->multi_toc_needed = htab->toc_curr != elf_gp (info->output_bfd);
ad8e1ba5 11345
7865406b
AM		 11346 if (!htab->do_multi_toc)
11347 return FALSE;
11348
d0fae19d 11349 /* Merge global sym got entries within a toc group. */
927be08e
AM		 11350 elf_link_hash_traverse (&htab->elf, merge_global_got, info);
11351
11352 /* And tlsld_got. */
c72f2fb2 11353 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
927be08e
AM		 11354 {
11355 struct got_entry *ent, *ent2;
11356
11357 if (!is_ppc64_elf (ibfd))
11358 continue;
11359
11360 ent = ppc64_tlsld_got (ibfd);
11361 if (!ent->is_indirect
11362 && ent->got.offset != (bfd_vma) -1)
11363 {
c72f2fb2 11364 for (ibfd2 = ibfd->link.next; ibfd2 != NULL; ibfd2 = ibfd2->link.next)
927be08e
AM		 11365 {
11366 if (!is_ppc64_elf (ibfd2))
11367 continue;
11368
11369 ent2 = ppc64_tlsld_got (ibfd2);
11370 if (!ent2->is_indirect
11371 && ent2->got.offset != (bfd_vma) -1
11372 && elf_gp (ibfd2) == elf_gp (ibfd))
11373 {
11374 ent2->is_indirect = TRUE;
11375 ent2->got.ent = ent;
11376 }
11377 }
11378 }
11379 }
11380
11381 /* Zap sizes of got sections. */
33e44f2e
AM		 11382 htab->elf.irelplt->rawsize = htab->elf.irelplt->size;
11383 htab->elf.irelplt->size -= htab->got_reli_size;
927be08e
AM		 11384 htab->got_reli_size = 0;
11385
c72f2fb2 11386 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
927be08e
AM		 11387 {
11388 asection *got, *relgot;
11389
11390 if (!is_ppc64_elf (ibfd))
11391 continue;
11392
11393 got = ppc64_elf_tdata (ibfd)->got;
11394 if (got != NULL)
11395 {
11396 got->rawsize = got->size;
11397 got->size = 0;
11398 relgot = ppc64_elf_tdata (ibfd)->relgot;
11399 relgot->rawsize = relgot->size;
11400 relgot->size = 0;
11401 }
11402 }
11403
11404 /* Now reallocate the got, local syms first. We don't need to
11405 allocate section contents again since we never increase size. */
c72f2fb2 11406 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
927be08e
AM		 11407 {
11408 struct got_entry **lgot_ents;
11409 struct got_entry **end_lgot_ents;
11410 struct plt_entry **local_plt;
11411 struct plt_entry **end_local_plt;
f961d9dd 11412 unsigned char *lgot_masks;
927be08e
AM		 11413 bfd_size_type locsymcount;
11414 Elf_Internal_Shdr *symtab_hdr;
19e08130 11415 asection *s;
927be08e
AM		 11416
11417 if (!is_ppc64_elf (ibfd))
11418 continue;
11419
11420 lgot_ents = elf_local_got_ents (ibfd);
11421 if (!lgot_ents)
11422 continue;
11423
11424 symtab_hdr = &elf_symtab_hdr (ibfd);
11425 locsymcount = symtab_hdr->sh_info;
11426 end_lgot_ents = lgot_ents + locsymcount;
11427 local_plt = (struct plt_entry **) end_lgot_ents;
11428 end_local_plt = local_plt + locsymcount;
f961d9dd 11429 lgot_masks = (unsigned char *) end_local_plt;
927be08e 11430 s = ppc64_elf_tdata (ibfd)->got;
927be08e
AM		 11431 for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
11432 {
11433 struct got_entry *ent;
11434
11435 for (ent = *lgot_ents; ent != NULL; ent = ent->next)
d0fae19d 11436 {
19e08130
AM		 11437 unsigned int ent_size = 8;
11438 unsigned int rel_size = sizeof (Elf64_External_Rela);
11439
d0fae19d
AM		 11440 ent->got.offset = s->size;
11441 if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
d0fae19d 11442 {
19e08130
AM		 11443 ent_size *= 2;
11444 rel_size *= 2;
11445 }
11446 s->size += ent_size;
11447 if ((*lgot_masks & PLT_IFUNC) != 0)
11448 {
33e44f2e 11449 htab->elf.irelplt->size += rel_size;
19e08130
AM		 11450 htab->got_reli_size += rel_size;
11451 }
11452 else if (info->shared)
11453 {
11454 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
11455 srel->size += rel_size;
d0fae19d
AM		 11456 }
11457 }
927be08e
AM		 11458 }
11459 }
11460
11461 elf_link_hash_traverse (&htab->elf, reallocate_got, info);
11462
c72f2fb2 11463 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
927be08e
AM		 11464 {
11465 struct got_entry *ent;
11466
11467 if (!is_ppc64_elf (ibfd))
11468 continue;
11469
11470 ent = ppc64_tlsld_got (ibfd);
11471 if (!ent->is_indirect
11472 && ent->got.offset != (bfd_vma) -1)
11473 {
11474 asection *s = ppc64_elf_tdata (ibfd)->got;
11475 ent->got.offset = s->size;
11476 s->size += 16;
11477 if (info->shared)
11478 {
11479 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
11480 srel->size += sizeof (Elf64_External_Rela);
11481 }
11482 }
11483 }
11484
33e44f2e 11485 done_something = htab->elf.irelplt->rawsize != htab->elf.irelplt->size;
927be08e 11486 if (!done_something)
c72f2fb2 11487 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
927be08e
AM		 11488 {
11489 asection *got;
11490
11491 if (!is_ppc64_elf (ibfd))
11492 continue;
11493
11494 got = ppc64_elf_tdata (ibfd)->got;
11495 if (got != NULL)
11496 {
11497 done_something = got->rawsize != got->size;
11498 if (done_something)
11499 break;
11500 }
11501 }
11502
11503 if (done_something)
e7d1c40c 11504 (*htab->params->layout_sections_again) ();
927be08e
AM		 11505
11506 /* Set up for second pass over toc sections to recalculate elf_gp
11507 on input sections. */
11508 htab->toc_bfd = NULL;
11509 htab->toc_first_sec = NULL;
11510 htab->second_toc_pass = TRUE;
11511 return done_something;
11512}
11513
11514/* Called after second pass of multitoc partitioning. */
11515
11516void
11517ppc64_elf_finish_multitoc_partition (struct bfd_link_info *info)
11518{
11519 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11520
11521 /* After the second pass, toc_curr tracks the TOC offset used
11522 for code sections below in ppc64_elf_next_input_section. */
3d6f9012 11523 htab->toc_curr = TOC_BASE_OFF;
ad8e1ba5
AM		 11524}
11525
9b5ecbd0
AM		 11526/* No toc references were found in ISEC. If the code in ISEC makes no
11527 calls, then there's no need to use toc adjusting stubs when branching
11528 into ISEC. Actually, indirect calls from ISEC are OK as they will
4c52953f
AM		 11529 load r2. Returns -1 on error, 0 for no stub needed, 1 for stub
11530 needed, and 2 if a cyclical call-graph was found but no other reason
11531 for a stub was detected. If called from the top level, a return of
11532 2 means the same as a return of 0. */
9b5ecbd0
AM		 11533
11534static int
4ce794b7 11535toc_adjusting_stub_needed (struct bfd_link_info *info, asection *isec)
9b5ecbd0 11536{
9b5ecbd0 11537 int ret;
70cc837d
AM		 11538
11539 /* Mark this section as checked. */
11540 isec->call_check_done = 1;
9b5ecbd0 11541
772119ce
AM		 11542 /* We know none of our code bearing sections will need toc stubs. */
11543 if ((isec->flags & SEC_LINKER_CREATED) != 0)
11544 return 0;
11545
eea6121a 11546 if (isec->size == 0)
082c50f8
AM		 11547 return 0;
11548
4c52953f
AM		 11549 if (isec->output_section == NULL)
11550 return 0;
11551
4c52953f 11552 ret = 0;
70cc837d 11553 if (isec->reloc_count != 0)
9b5ecbd0 11554 {
70cc837d
AM		 11555 Elf_Internal_Rela *relstart, *rel;
11556 Elf_Internal_Sym *local_syms;
11557 struct ppc_link_hash_table *htab;
2917689a 11558
70cc837d
AM		 11559 relstart = _bfd_elf_link_read_relocs (isec->owner, isec, NULL, NULL,
11560 info->keep_memory);
11561 if (relstart == NULL)
11562 return -1;
90aecf7a 11563
70cc837d
AM		 11564 /* Look for branches to outside of this section. */
11565 local_syms = NULL;
11566 htab = ppc_hash_table (info);
11567 if (htab == NULL)
11568 return -1;
4c52953f 11569
70cc837d 11570 for (rel = relstart; rel < relstart + isec->reloc_count; ++rel)
4c52953f 11571 {
70cc837d
AM		 11572 enum elf_ppc64_reloc_type r_type;
11573 unsigned long r_symndx;
11574 struct elf_link_hash_entry *h;
11575 struct ppc_link_hash_entry *eh;
11576 Elf_Internal_Sym *sym;
11577 asection *sym_sec;
11578 struct _opd_sec_data *opd;
11579 bfd_vma sym_value;
11580 bfd_vma dest;
11581
11582 r_type = ELF64_R_TYPE (rel->r_info);
11583 if (r_type != R_PPC64_REL24
11584 && r_type != R_PPC64_REL14
11585 && r_type != R_PPC64_REL14_BRTAKEN
11586 && r_type != R_PPC64_REL14_BRNTAKEN)
11587 continue;
4c52953f 11588
70cc837d
AM		 11589 r_symndx = ELF64_R_SYM (rel->r_info);
11590 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms, r_symndx,
11591 isec->owner))
4c52953f 11592 {
70cc837d
AM		 11593 ret = -1;
11594 break;
11595 }
4c52953f 11596
70cc837d
AM		 11597 /* Calls to dynamic lib functions go through a plt call stub
11598 that uses r2. */
11599 eh = (struct ppc_link_hash_entry *) h;
11600 if (eh != NULL
11601 && (eh->elf.plt.plist != NULL
11602 || (eh->oh != NULL
11603 && ppc_follow_link (eh->oh)->elf.plt.plist != NULL)))
11604 {
11605 ret = 1;
11606 break;
4c52953f
AM		 11607 }
11608
70cc837d
AM		 11609 if (sym_sec == NULL)
11610 /* Ignore other undefined symbols. */
4c52953f 11611 continue;
4c52953f 11612
70cc837d
AM		 11613 /* Assume branches to other sections not included in the
11614 link need stubs too, to cover -R and absolute syms. */
11615 if (sym_sec->output_section == NULL)
11616 {
11617 ret = 1;
11618 break;
11619 }
4c52953f 11620
70cc837d
AM		 11621 if (h == NULL)
11622 sym_value = sym->st_value;
11623 else
11624 {
11625 if (h->root.type != bfd_link_hash_defined
11626 && h->root.type != bfd_link_hash_defweak)
11627 abort ();
11628 sym_value = h->root.u.def.value;
11629 }
11630 sym_value += rel->r_addend;
4c52953f 11631
70cc837d
AM		 11632 /* If this branch reloc uses an opd sym, find the code section. */
11633 opd = get_opd_info (sym_sec);
11634 if (opd != NULL)
11635 {
11636 if (h == NULL && opd->adjust != NULL)
11637 {
11638 long adjust;
4c52953f 11639
51aecdc5 11640 adjust = opd->adjust[OPD_NDX (sym->st_value)];
70cc837d
AM		 11641 if (adjust == -1)
11642 /* Assume deleted functions won't ever be called. */
11643 continue;
11644 sym_value += adjust;
11645 }
4c52953f 11646
aef36ac1
AM		 11647 dest = opd_entry_value (sym_sec, sym_value,
11648 &sym_sec, NULL, FALSE);
70cc837d
AM		 11649 if (dest == (bfd_vma) -1)
11650 continue;
11651 }
11652 else
11653 dest = (sym_value
11654 + sym_sec->output_offset
11655 + sym_sec->output_section->vma);
4c52953f 11656
70cc837d
AM		 11657 /* Ignore branch to self. */
11658 if (sym_sec == isec)
11659 continue;
4c52953f 11660
70cc837d
AM		 11661 /* If the called function uses the toc, we need a stub. */
11662 if (sym_sec->has_toc_reloc
11663 || sym_sec->makes_toc_func_call)
4c52953f 11664 {
70cc837d 11665 ret = 1;
4c52953f
AM		 11666 break;
11667 }
70cc837d
AM		 11668
11669 /* Assume any branch that needs a long branch stub might in fact
11670 need a plt_branch stub. A plt_branch stub uses r2. */
11671 else if (dest - (isec->output_offset
11672 + isec->output_section->vma
6911b7dc
AM		 11673 + rel->r_offset) + (1 << 25)
11674 >= (2u << 25) - PPC64_LOCAL_ENTRY_OFFSET (h
11675 ? h->other
11676 : sym->st_other))
4c52953f 11677 {
70cc837d
AM		 11678 ret = 1;
11679 break;
11680 }
11681
11682 /* If calling back to a section in the process of being
11683 tested, we can't say for sure that no toc adjusting stubs
11684 are needed, so don't return zero. */
11685 else if (sym_sec->call_check_in_progress)
11686 ret = 2;
11687
11688 /* Branches to another section that itself doesn't have any TOC
11689 references are OK. Recursively call ourselves to check. */
11690 else if (!sym_sec->call_check_done)
11691 {
11692 int recur;
11693
11694 /* Mark current section as indeterminate, so that other
11695 sections that call back to current won't be marked as
11696 known. */
11697 isec->call_check_in_progress = 1;
11698 recur = toc_adjusting_stub_needed (info, sym_sec);
11699 isec->call_check_in_progress = 0;
11700
4c52953f
AM		 11701 if (recur != 0)
11702 {
70cc837d
AM		 11703 ret = recur;
11704 if (recur != 2)
11705 break;
4c52953f
AM		 11706 }
11707 }
4c52953f 11708 }
70cc837d
AM		 11709
11710 if (local_syms != NULL
11711 && (elf_symtab_hdr (isec->owner).contents
11712 != (unsigned char *) local_syms))
11713 free (local_syms);
11714 if (elf_section_data (isec)->relocs != relstart)
11715 free (relstart);
9b5ecbd0
AM		 11716 }
11717
70cc837d
AM		 11718 if ((ret & 1) == 0
11719 && isec->map_head.s != NULL
11720 && (strcmp (isec->output_section->name, ".init") == 0
11721 || strcmp (isec->output_section->name, ".fini") == 0))
11722 {
11723 if (isec->map_head.s->has_toc_reloc
11724 || isec->map_head.s->makes_toc_func_call)
11725 ret = 1;
11726 else if (!isec->map_head.s->call_check_done)
11727 {
11728 int recur;
11729 isec->call_check_in_progress = 1;
11730 recur = toc_adjusting_stub_needed (info, isec->map_head.s);
11731 isec->call_check_in_progress = 0;
11732 if (recur != 0)
11733 ret = recur;
11734 }
11735 }
11736
11737 if (ret == 1)
11738 isec->makes_toc_func_call = 1;
4c52953f 11739
9b5ecbd0
AM		 11740 return ret;
11741}
11742
721956f4
AM		 11743/* The linker repeatedly calls this function for each input section,
11744 in the order that input sections are linked into output sections.
11745 Build lists of input sections to determine groupings between which
11746 we may insert linker stubs. */
11747
9b5ecbd0 11748bfd_boolean
4ce794b7 11749ppc64_elf_next_input_section (struct bfd_link_info *info, asection *isec)
721956f4
AM		 11750{
11751 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11752
4dfe6ac6
NC		 11753 if (htab == NULL)
11754 return FALSE;
11755
734b6cf9
AM		 11756 if ((isec->output_section->flags & SEC_CODE) != 0
11757 && isec->output_section->index <= htab->top_index)
721956f4 11758 {
734b6cf9 11759 asection **list = htab->input_list + isec->output_section->index;
3d6f9012 11760 /* Steal the link_sec pointer for our list. */
721956f4 11761#define PREV_SEC(sec) (htab->stub_group[(sec)->id].link_sec)
3d6f9012
AM		 11762 /* This happens to make the list in reverse order,
11763 which is what we want. */
734b6cf9
AM		 11764 PREV_SEC (isec) = *list;
11765 *list = isec;
721956f4 11766 }
ad8e1ba5 11767
4c52953f 11768 if (htab->multi_toc_needed)
9b5ecbd0 11769 {
8b974ba3
AM		 11770 /* Analyse sections that aren't already flagged as needing a
11771 valid toc pointer. Exclude .fixup for the linux kernel.
11772 .fixup contains branches, but only back to the function that
11773 hit an exception. */
11774 if (!(isec->has_toc_reloc
11775 || (isec->flags & SEC_CODE) == 0
11776 || strcmp (isec->name, ".fixup") == 0
11777 || isec->call_check_done))
11778 {
11779 if (toc_adjusting_stub_needed (info, isec) < 0)
6683a28d 11780 return FALSE;
8b974ba3
AM		 11781 }
11782 /* Make all sections use the TOC assigned for this object file.
11783 This will be wrong for pasted sections; We fix that in
11784 check_pasted_section(). */
11785 if (elf_gp (isec->owner) != 0)
11786 htab->toc_curr = elf_gp (isec->owner);
11787 }
11788
ad8e1ba5 11789 htab->stub_group[isec->id].toc_off = htab->toc_curr;
9b5ecbd0 11790 return TRUE;
721956f4
AM		 11791}
11792
70cc837d
AM		 11793/* Check that all .init and .fini sections use the same toc, if they
11794 have toc relocs. */
11795
11796static bfd_boolean
11797check_pasted_section (struct bfd_link_info *info, const char *name)
11798{
11799 asection *o = bfd_get_section_by_name (info->output_bfd, name);
11800
11801 if (o != NULL)
11802 {
11803 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11804 bfd_vma toc_off = 0;
11805 asection *i;
11806
11807 for (i = o->map_head.s; i != NULL; i = i->map_head.s)
11808 if (i->has_toc_reloc)
11809 {
11810 if (toc_off == 0)
11811 toc_off = htab->stub_group[i->id].toc_off;
11812 else if (toc_off != htab->stub_group[i->id].toc_off)
11813 return FALSE;
11814 }
6683a28d
AM		 11815
11816 if (toc_off == 0)
11817 for (i = o->map_head.s; i != NULL; i = i->map_head.s)
11818 if (i->makes_toc_func_call)
11819 {
11820 toc_off = htab->stub_group[i->id].toc_off;
11821 break;
11822 }
11823
70cc837d
AM		 11824 /* Make sure the whole pasted function uses the same toc offset. */
11825 if (toc_off != 0)
11826 for (i = o->map_head.s; i != NULL; i = i->map_head.s)
11827 htab->stub_group[i->id].toc_off = toc_off;
11828 }
11829 return TRUE;
11830}
11831
11832bfd_boolean
11833ppc64_elf_check_init_fini (struct bfd_link_info *info)
11834{
11835 return (check_pasted_section (info, ".init")
11836 & check_pasted_section (info, ".fini"));
11837}
11838
721956f4
AM		 11839/* See whether we can group stub sections together. Grouping stub
11840 sections may result in fewer stubs. More importantly, we need to
11841 put all .init* and .fini* stubs at the beginning of the .init or
11842 .fini output sections respectively, because glibc splits the
11843 _init and _fini functions into multiple parts. Putting a stub in
11844 the middle of a function is not a good idea. */
11845
11846static void
4ce794b7
AM		 11847group_sections (struct ppc_link_hash_table *htab,
11848 bfd_size_type stub_group_size,
11849 bfd_boolean stubs_always_before_branch)
721956f4 11850{
7c8fe5c4
AM		 11851 asection **list;
11852 bfd_size_type stub14_group_size;
11853 bfd_boolean suppress_size_errors;
11854
11855 suppress_size_errors = FALSE;
0cfb0717 11856 stub14_group_size = stub_group_size >> 10;
7c8fe5c4
AM		 11857 if (stub_group_size == 1)
11858 {
11859 /* Default values. */
11860 if (stubs_always_before_branch)
11861 {
11862 stub_group_size = 0x1e00000;
11863 stub14_group_size = 0x7800;
11864 }
11865 else
11866 {
11867 stub_group_size = 0x1c00000;
11868 stub14_group_size = 0x7000;
11869 }
11870 suppress_size_errors = TRUE;
11871 }
11872
11873 list = htab->input_list + htab->top_index;
734b6cf9 11874 do
721956f4 11875 {
734b6cf9
AM		 11876 asection *tail = *list;
11877 while (tail != NULL)
721956f4 11878 {
734b6cf9
AM		 11879 asection *curr;
11880 asection *prev;
11881 bfd_size_type total;
11882 bfd_boolean big_sec;
11883 bfd_vma curr_toc;
11884
11885 curr = tail;
eea6121a 11886 total = tail->size;
6bee8834
AM		 11887 big_sec = total > (ppc64_elf_section_data (tail) != NULL
11888 && ppc64_elf_section_data (tail)->has_14bit_branch
7c8fe5c4
AM		 11889 ? stub14_group_size : stub_group_size);
11890 if (big_sec && !suppress_size_errors)
5c3dead3
AM		 11891 (*_bfd_error_handler) (_("%B section %A exceeds stub group size"),
11892 tail->owner, tail);
734b6cf9
AM		 11893 curr_toc = htab->stub_group[tail->id].toc_off;
11894
11895 while ((prev = PREV_SEC (curr)) != NULL
11896 && ((total += curr->output_offset - prev->output_offset)
6bee8834
AM		 11897 < (ppc64_elf_section_data (prev) != NULL
11898 && ppc64_elf_section_data (prev)->has_14bit_branch
7c8fe5c4 11899 ? stub14_group_size : stub_group_size))
ad8e1ba5 11900 && htab->stub_group[prev->id].toc_off == curr_toc)
734b6cf9
AM		 11901 curr = prev;
11902
11903 /* OK, the size from the start of CURR to the end is less
11904 than stub_group_size and thus can be handled by one stub
11905 section. (or the tail section is itself larger than
11906 stub_group_size, in which case we may be toast.) We
11907 should really be keeping track of the total size of stubs
11908 added here, as stubs contribute to the final output
11909 section size. That's a little tricky, and this way will
11910 only break if stubs added make the total size more than
11911 2^25, ie. for the default stub_group_size, if stubs total
11912 more than 2097152 bytes, or nearly 75000 plt call stubs. */
11913 do
721956f4
AM		 11914 {
11915 prev = PREV_SEC (tail);
734b6cf9 11916 /* Set up this stub group. */
721956f4
AM		 11917 htab->stub_group[tail->id].link_sec = curr;
11918 }
734b6cf9
AM		 11919 while (tail != curr && (tail = prev) != NULL);
11920
11921 /* But wait, there's more! Input sections up to stub_group_size
11922 bytes before the stub section can be handled by it too.
11923 Don't do this if we have a really large section after the
11924 stubs, as adding more stubs increases the chance that
11925 branches may not reach into the stub section. */
11926 if (!stubs_always_before_branch && !big_sec)
11927 {
11928 total = 0;
11929 while (prev != NULL
11930 && ((total += tail->output_offset - prev->output_offset)
6bee8834
AM		 11931 < (ppc64_elf_section_data (prev) != NULL
11932 && ppc64_elf_section_data (prev)->has_14bit_branch
7c8fe5c4 11933 ? stub14_group_size : stub_group_size))
734b6cf9
AM		 11934 && htab->stub_group[prev->id].toc_off == curr_toc)
11935 {
11936 tail = prev;
11937 prev = PREV_SEC (tail);
11938 htab->stub_group[tail->id].link_sec = curr;
11939 }
11940 }
11941 tail = prev;
721956f4
AM		 11942 }
11943 }
734b6cf9
AM		 11944 while (list-- != htab->input_list);
11945 free (htab->input_list);
721956f4
AM		 11946#undef PREV_SEC
11947}
11948
58d180e8
AM		 11949static const unsigned char glink_eh_frame_cie[] =
11950{
11951 0, 0, 0, 16, /* length. */
11952 0, 0, 0, 0, /* id. */
11953 1, /* CIE version. */
11954 'z', 'R', 0, /* Augmentation string. */
11955 4, /* Code alignment. */
11956 0x78, /* Data alignment. */
11957 65, /* RA reg. */
11958 1, /* Augmentation size. */
11959 DW_EH_PE_pcrel | DW_EH_PE_sdata4, /* FDE encoding. */
da44f4e5
AM		 11960 DW_CFA_def_cfa, 1, 0, /* def_cfa: r1 offset 0. */
11961 0, 0, 0, 0
58d180e8
AM		 11962};
11963
d969d15f
AM		 11964/* Stripping output sections is normally done before dynamic section
11965 symbols have been allocated. This function is called later, and
11966 handles cases like htab->brlt which is mapped to its own output
11967 section. */
11968
11969static void
11970maybe_strip_output (struct bfd_link_info *info, asection *isec)
11971{
11972 if (isec->size == 0
11973 && isec->output_section->size == 0
53d8967a 11974 && !(isec->output_section->flags & SEC_KEEP)
d969d15f
AM		 11975 && !bfd_section_removed_from_list (info->output_bfd,
11976 isec->output_section)
11977 && elf_section_data (isec->output_section)->dynindx == 0)
11978 {
11979 isec->output_section->flags |= SEC_EXCLUDE;
11980 bfd_section_list_remove (info->output_bfd, isec->output_section);
11981 info->output_bfd->section_count--;
11982 }
11983}
11984
721956f4
AM		 11985/* Determine and set the size of the stub section for a final link.
11986
11987 The basic idea here is to examine all the relocations looking for
11988 PC-relative calls to a target that is unreachable with a "bl"
11989 instruction. */
11990
b34976b6 11991bfd_boolean
e7d1c40c 11992ppc64_elf_size_stubs (struct bfd_link_info *info)
721956f4
AM		 11993{
11994 bfd_size_type stub_group_size;
b34976b6 11995 bfd_boolean stubs_always_before_branch;
721956f4
AM		 11996 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11997
4dfe6ac6
NC		 11998 if (htab == NULL)
11999 return FALSE;
12000
e7d1c40c
AM		 12001 if (htab->params->plt_thread_safe == -1 && !info->executable)
12002 htab->params->plt_thread_safe = 1;
b9e5796b 12003 if (!htab->opd_abi)
e7d1c40c
AM		 12004 htab->params->plt_thread_safe = 0;
12005 else if (htab->params->plt_thread_safe == -1)
794e51c0 12006 {
e2458743 12007 static const char *const thread_starter[] =
794e51c0
AM		 12008 {
12009 "pthread_create",
12010 /* libstdc++ */
12011 "_ZNSt6thread15_M_start_threadESt10shared_ptrINS_10_Impl_baseEE",
12012 /* librt */
12013 "aio_init", "aio_read", "aio_write", "aio_fsync", "lio_listio",
12014 "mq_notify", "create_timer",
12015 /* libanl */
12016 "getaddrinfo_a",
12017 /* libgomp */
2300b5a1 12018 "GOMP_parallel",
794e51c0 12019 "GOMP_parallel_start",
2300b5a1 12020 "GOMP_parallel_loop_static",
794e51c0 12021 "GOMP_parallel_loop_static_start",
2300b5a1 12022 "GOMP_parallel_loop_dynamic",
794e51c0 12023 "GOMP_parallel_loop_dynamic_start",
2300b5a1 12024 "GOMP_parallel_loop_guided",
794e51c0 12025 "GOMP_parallel_loop_guided_start",
2300b5a1 12026 "GOMP_parallel_loop_runtime",
794e51c0 12027 "GOMP_parallel_loop_runtime_start",
2300b5a1 12028 "GOMP_parallel_sections",
68ffbac6 12029 "GOMP_parallel_sections_start",
f9dffbf0
AM		 12030 /* libgo */
12031 "__go_go",
794e51c0
AM		 12032 };
12033 unsigned i;
12034
12035 for (i = 0; i < sizeof (thread_starter)/ sizeof (thread_starter[0]); i++)
12036 {
12037 struct elf_link_hash_entry *h;
12038 h = elf_link_hash_lookup (&htab->elf, thread_starter[i],
12039 FALSE, FALSE, TRUE);
e7d1c40c
AM		 12040 htab->params->plt_thread_safe = h != NULL && h->ref_regular;
12041 if (htab->params->plt_thread_safe)
794e51c0
AM		 12042 break;
12043 }
12044 }
e7d1c40c
AM		 12045 stubs_always_before_branch = htab->params->group_size < 0;
12046 if (htab->params->group_size < 0)
12047 stub_group_size = -htab->params->group_size;
721956f4 12048 else
e7d1c40c 12049 stub_group_size = htab->params->group_size;
721956f4
AM		 12050
12051 group_sections (htab, stub_group_size, stubs_always_before_branch);
12052
721956f4
AM		 12053 while (1)
12054 {
12055 bfd *input_bfd;
12056 unsigned int bfd_indx;
12057 asection *stub_sec;
721956f4
AM		 12058
12059 htab->stub_iteration += 1;
721956f4
AM		 12060
12061 for (input_bfd = info->input_bfds, bfd_indx = 0;
12062 input_bfd != NULL;
c72f2fb2 12063 input_bfd = input_bfd->link.next, bfd_indx++)
721956f4
AM		 12064 {
12065 Elf_Internal_Shdr *symtab_hdr;
12066 asection *section;
6cdc0ccc 12067 Elf_Internal_Sym *local_syms = NULL;
721956f4 12068
0c8d6e5c 12069 if (!is_ppc64_elf (input_bfd))
67f93c31
AM		 12070 continue;
12071
721956f4 12072 /* We'll need the symbol table in a second. */
0ffa91dd 12073 symtab_hdr = &elf_symtab_hdr (input_bfd);
721956f4
AM		 12074 if (symtab_hdr->sh_info == 0)
12075 continue;
12076
721956f4
AM		 12077 /* Walk over each section attached to the input bfd. */
12078 for (section = input_bfd->sections;
12079 section != NULL;
12080 section = section->next)
12081 {
721956f4 12082 Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
721956f4
AM		 12083
12084 /* If there aren't any relocs, then there's nothing more
12085 to do. */
12086 if ((section->flags & SEC_RELOC) == 0
12c0f757
AM		 12087 || (section->flags & SEC_ALLOC) == 0
12088 || (section->flags & SEC_LOAD) == 0
12089 || (section->flags & SEC_CODE) == 0
721956f4
AM		 12090 || section->reloc_count == 0)
12091 continue;
12092
12093 /* If this section is a link-once section that will be
12094 discarded, then don't create any stubs. */
12095 if (section->output_section == NULL
927be08e 12096 || section->output_section->owner != info->output_bfd)
721956f4
AM		 12097 continue;
12098
1e2f5b6e
AM		 12099 /* Get the relocs. */
12100 internal_relocs
4ce794b7 12101 = _bfd_elf_link_read_relocs (input_bfd, section, NULL, NULL,
45d6a902 12102 info->keep_memory);
721956f4 12103 if (internal_relocs == NULL)
1e2f5b6e 12104 goto error_ret_free_local;
721956f4
AM		 12105
12106 /* Now examine each relocation. */
12107 irela = internal_relocs;
12108 irelaend = irela + section->reloc_count;
12109 for (; irela < irelaend; irela++)
12110 {
4ce794b7
AM		 12111 enum elf_ppc64_reloc_type r_type;
12112 unsigned int r_indx;
721956f4
AM		 12113 enum ppc_stub_type stub_type;
12114 struct ppc_stub_hash_entry *stub_entry;
8387904d 12115 asection *sym_sec, *code_sec;
e054468f 12116 bfd_vma sym_value, code_value;
721956f4 12117 bfd_vma destination;
6911b7dc 12118 unsigned long local_off;
8843416a 12119 bfd_boolean ok_dest;
721956f4 12120 struct ppc_link_hash_entry *hash;
8387904d 12121 struct ppc_link_hash_entry *fdh;
411e1bfb
AM		 12122 struct elf_link_hash_entry *h;
12123 Elf_Internal_Sym *sym;
721956f4
AM		 12124 char *stub_name;
12125 const asection *id_sec;
74f0fb50 12126 struct _opd_sec_data *opd;
e054468f 12127 struct plt_entry *plt_ent;
721956f4
AM		 12128
12129 r_type = ELF64_R_TYPE (irela->r_info);
12130 r_indx = ELF64_R_SYM (irela->r_info);
12131
4ce794b7 12132 if (r_type >= R_PPC64_max)
721956f4
AM		 12133 {
12134 bfd_set_error (bfd_error_bad_value);
6cdc0ccc 12135 goto error_ret_free_internal;
721956f4
AM		 12136 }
12137
12138 /* Only look for stubs on branch instructions. */
4ce794b7
AM		 12139 if (r_type != R_PPC64_REL24
12140 && r_type != R_PPC64_REL14
12141 && r_type != R_PPC64_REL14_BRTAKEN
12142 && r_type != R_PPC64_REL14_BRNTAKEN)
721956f4
AM		 12143 continue;
12144
12145 /* Now determine the call target, its name, value,
12146 section. */
411e1bfb
AM		 12147 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
12148 r_indx, input_bfd))
12149 goto error_ret_free_internal;
12150 hash = (struct ppc_link_hash_entry *) h;
12151
8843416a 12152 ok_dest = FALSE;
8387904d 12153 fdh = NULL;
7fe2b9a6 12154 sym_value = 0;
411e1bfb 12155 if (hash == NULL)
721956f4 12156 {
411e1bfb 12157 sym_value = sym->st_value;
8843416a 12158 ok_dest = TRUE;
721956f4 12159 }
7fe2b9a6
AM		 12160 else if (hash->elf.root.type == bfd_link_hash_defined
12161 || hash->elf.root.type == bfd_link_hash_defweak)
12162 {
12163 sym_value = hash->elf.root.u.def.value;
12164 if (sym_sec->output_section != NULL)
12165 ok_dest = TRUE;
12166 }
12167 else if (hash->elf.root.type == bfd_link_hash_undefweak
12168 || hash->elf.root.type == bfd_link_hash_undefined)
721956f4 12169 {
99877b66 12170 /* Recognise an old ABI func code entry sym, and
7fe2b9a6
AM		 12171 use the func descriptor sym instead if it is
12172 defined. */
ceb1f1ef 12173 if (hash->elf.root.root.string[0] == '.'
b31867b6 12174 && (fdh = lookup_fdh (hash, htab)) != NULL)
8387904d 12175 {
8387904d
AM		 12176 if (fdh->elf.root.type == bfd_link_hash_defined
12177 || fdh->elf.root.type == bfd_link_hash_defweak)
12178 {
12179 sym_sec = fdh->elf.root.u.def.section;
12180 sym_value = fdh->elf.root.u.def.value;
12181 if (sym_sec->output_section != NULL)
12182 ok_dest = TRUE;
12183 }
99877b66
AM		 12184 else
12185 fdh = NULL;
8387904d 12186 }
7fe2b9a6
AM		 12187 }
12188 else
12189 {
12190 bfd_set_error (bfd_error_bad_value);
12191 goto error_ret_free_internal;
721956f4
AM		 12192 }
12193
8843416a 12194 destination = 0;
6911b7dc 12195 local_off = 0;
8843416a
AM		 12196 if (ok_dest)
12197 {
12198 sym_value += irela->r_addend;
12199 destination = (sym_value
12200 + sym_sec->output_offset
12201 + sym_sec->output_section->vma);
6911b7dc
AM		 12202 local_off = PPC64_LOCAL_ENTRY_OFFSET (hash
12203 ? hash->elf.other
12204 : sym->st_other);
8843416a
AM		 12205 }
12206
8387904d 12207 code_sec = sym_sec;
e054468f 12208 code_value = sym_value;
74f0fb50
AM		 12209 opd = get_opd_info (sym_sec);
12210 if (opd != NULL)
8387904d
AM		 12211 {
12212 bfd_vma dest;
12213
74f0fb50 12214 if (hash == NULL && opd->adjust != NULL)
8387904d 12215 {
51aecdc5 12216 long adjust = opd->adjust[OPD_NDX (sym_value)];
8387904d
AM		 12217 if (adjust == -1)
12218 continue;
e054468f 12219 code_value += adjust;
8387904d
AM		 12220 sym_value += adjust;
12221 }
12222 dest = opd_entry_value (sym_sec, sym_value,
aef36ac1 12223 &code_sec, &code_value, FALSE);
8387904d
AM		 12224 if (dest != (bfd_vma) -1)
12225 {
12226 destination = dest;
12227 if (fdh != NULL)
12228 {
12229 /* Fixup old ABI sym to point at code
12230 entry. */
99877b66 12231 hash->elf.root.type = bfd_link_hash_defweak;
8387904d 12232 hash->elf.root.u.def.section = code_sec;
e054468f 12233 hash->elf.root.u.def.value = code_value;
8387904d
AM		 12234 }
12235 }
12236 }
12237
721956f4 12238 /* Determine what (if any) linker stub is needed. */
e054468f 12239 plt_ent = NULL;
721956f4 12240 stub_type = ppc_type_of_stub (section, irela, &hash,
6911b7dc
AM		 12241 &plt_ent, destination,
12242 local_off);
ad8e1ba5
AM		 12243
12244 if (stub_type != ppc_stub_plt_call)
12245 {
12246 /* Check whether we need a TOC adjusting stub.
12247 Since the linker pastes together pieces from
12248 different object files when creating the
12249 _init and _fini functions, it may be that a
12250 call to what looks like a local sym is in
12251 fact a call needing a TOC adjustment. */
8387904d
AM		 12252 if (code_sec != NULL
12253 && code_sec->output_section != NULL
12254 && (htab->stub_group[code_sec->id].toc_off
9b5ecbd0 12255 != htab->stub_group[section->id].toc_off)
4c52953f
AM		 12256 && (code_sec->has_toc_reloc
12257 || code_sec->makes_toc_func_call))
ad8e1ba5
AM		 12258 stub_type = ppc_stub_long_branch_r2off;
12259 }
12260
721956f4
AM		 12261 if (stub_type == ppc_stub_none)
12262 continue;
12263
411e1bfb
AM		 12264 /* __tls_get_addr calls might be eliminated. */
12265 if (stub_type != ppc_stub_plt_call
12266 && hash != NULL
8387904d
AM		 12267 && (hash == htab->tls_get_addr
12268 || hash == htab->tls_get_addr_fd)
411e1bfb
AM		 12269 && section->has_tls_reloc
12270 && irela != internal_relocs)
12271 {
12272 /* Get tls info. */
f961d9dd 12273 unsigned char *tls_mask;
411e1bfb 12274
3a71aa26 12275 if (!get_tls_mask (&tls_mask, NULL, NULL, &local_syms,
411e1bfb
AM		 12276 irela - 1, input_bfd))
12277 goto error_ret_free_internal;
e7b938ca 12278 if (*tls_mask != 0)
411e1bfb
AM		 12279 continue;
12280 }
12281
3b421ab3
AM		 12282 if (stub_type == ppc_stub_plt_call
12283 && irela + 1 < irelaend
12284 && irela[1].r_offset == irela->r_offset + 4
794e51c0
AM		 12285 && ELF64_R_TYPE (irela[1].r_info) == R_PPC64_TOCSAVE)
12286 {
12287 if (!tocsave_find (htab, INSERT,
12288 &local_syms, irela + 1, input_bfd))
12289 goto error_ret_free_internal;
12290 }
12291 else if (stub_type == ppc_stub_plt_call)
12292 stub_type = ppc_stub_plt_call_r2save;
3b421ab3 12293
721956f4
AM		 12294 /* Support for grouping stub sections. */
12295 id_sec = htab->stub_group[section->id].link_sec;
12296
12297 /* Get the name of this stub. */
12298 stub_name = ppc_stub_name (id_sec, sym_sec, hash, irela);
12299 if (!stub_name)
12300 goto error_ret_free_internal;
12301
12302 stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
b34976b6 12303 stub_name, FALSE, FALSE);
721956f4
AM		 12304 if (stub_entry != NULL)
12305 {
12306 /* The proper stub has already been created. */
12307 free (stub_name);
794e51c0
AM		 12308 if (stub_type == ppc_stub_plt_call_r2save)
12309 stub_entry->stub_type = stub_type;
721956f4
AM		 12310 continue;
12311 }
12312
25f53a85 12313 stub_entry = ppc_add_stub (stub_name, section, info);
721956f4
AM		 12314 if (stub_entry == NULL)
12315 {
12316 free (stub_name);
6cdc0ccc
AM		 12317 error_ret_free_internal:
12318 if (elf_section_data (section)->relocs == NULL)
12319 free (internal_relocs);
12320 error_ret_free_local:
12321 if (local_syms != NULL
12322 && (symtab_hdr->contents
12323 != (unsigned char *) local_syms))
12324 free (local_syms);
b34976b6 12325 return FALSE;
721956f4
AM		 12326 }
12327
ad8e1ba5 12328 stub_entry->stub_type = stub_type;
794e51c0
AM		 12329 if (stub_type != ppc_stub_plt_call
12330 && stub_type != ppc_stub_plt_call_r2save)
e054468f
AM		 12331 {
12332 stub_entry->target_value = code_value;
12333 stub_entry->target_section = code_sec;
12334 }
12335 else
12336 {
12337 stub_entry->target_value = sym_value;
12338 stub_entry->target_section = sym_sec;
12339 }
721956f4 12340 stub_entry->h = hash;
e054468f 12341 stub_entry->plt_ent = plt_ent;
6911b7dc 12342 stub_entry->other = hash ? hash->elf.other : sym->st_other;
ee75fd95
AM		 12343
12344 if (stub_entry->h != NULL)
12345 htab->stub_globals += 1;
721956f4
AM		 12346 }
12347
12348 /* We're done with the internal relocs, free them. */
6cdc0ccc 12349 if (elf_section_data (section)->relocs != internal_relocs)
1e2f5b6e 12350 free (internal_relocs);
721956f4 12351 }
6cdc0ccc
AM		 12352
12353 if (local_syms != NULL
12354 && symtab_hdr->contents != (unsigned char *) local_syms)
12355 {
12356 if (!info->keep_memory)
12357 free (local_syms);
12358 else
12359 symtab_hdr->contents = (unsigned char *) local_syms;
12360 }
721956f4
AM		 12361 }
12362
5c3dead3 12363 /* We may have added some stubs. Find out the new size of the
721956f4 12364 stub sections. */
e7d1c40c 12365 for (stub_sec = htab->params->stub_bfd->sections;
721956f4
AM		 12366 stub_sec != NULL;
12367 stub_sec = stub_sec->next)
e717da7e 12368 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
ee75fd95 12369 {
5c3dead3 12370 stub_sec->rawsize = stub_sec->size;
ee75fd95
AM		 12371 stub_sec->size = 0;
12372 stub_sec->reloc_count = 0;
84f5d08e 12373 stub_sec->flags &= ~SEC_RELOC;
ee75fd95 12374 }
eea6121a
AM		 12375
12376 htab->brlt->size = 0;
84f5d08e
AM		 12377 htab->brlt->reloc_count = 0;
12378 htab->brlt->flags &= ~SEC_RELOC;
ee75fd95 12379 if (htab->relbrlt != NULL)
eea6121a 12380 htab->relbrlt->size = 0;
721956f4 12381
63bc6f6c 12382 bfd_hash_traverse (&htab->stub_hash_table, ppc_size_one_stub, info);
721956f4 12383
176a0d42
AM		 12384 if (info->emitrelocations
12385 && htab->glink != NULL && htab->glink->size != 0)
12386 {
12387 htab->glink->reloc_count = 1;
12388 htab->glink->flags |= SEC_RELOC;
12389 }
12390
58d180e8
AM		 12391 if (htab->glink_eh_frame != NULL
12392 && !bfd_is_abs_section (htab->glink_eh_frame->output_section)
9a2a56cc 12393 && htab->glink_eh_frame->output_section->size != 0)
58d180e8 12394 {
4bbe044a 12395 size_t size = 0, align;
58d180e8 12396
e7d1c40c 12397 for (stub_sec = htab->params->stub_bfd->sections;
58d180e8
AM		 12398 stub_sec != NULL;
12399 stub_sec = stub_sec->next)
12400 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
da44f4e5 12401 size += 24;
58d180e8
AM		 12402 if (htab->glink != NULL && htab->glink->size != 0)
12403 size += 24;
12404 if (size != 0)
12405 size += sizeof (glink_eh_frame_cie);
4bbe044a
AM		 12406 align = 1;
12407 align <<= htab->glink_eh_frame->output_section->alignment_power;
12408 align -= 1;
12409 size = (size + align) & ~align;
58d180e8
AM		 12410 htab->glink_eh_frame->rawsize = htab->glink_eh_frame->size;
12411 htab->glink_eh_frame->size = size;
12412 }
12413
e7d1c40c
AM		 12414 if (htab->params->plt_stub_align != 0)
12415 for (stub_sec = htab->params->stub_bfd->sections;
794e51c0
AM		 12416 stub_sec != NULL;
12417 stub_sec = stub_sec->next)
12418 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
e7d1c40c
AM		 12419 stub_sec->size = ((stub_sec->size
12420 + (1 << htab->params->plt_stub_align) - 1)
12421 & (-1 << htab->params->plt_stub_align));
794e51c0 12422
e7d1c40c 12423 for (stub_sec = htab->params->stub_bfd->sections;
5c3dead3
AM		 12424 stub_sec != NULL;
12425 stub_sec = stub_sec->next)
12426 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
12427 && stub_sec->rawsize != stub_sec->size)
12428 break;
12429
12430 /* Exit from this loop when no stubs have been added, and no stubs
12431 have changed size. */
58d180e8
AM		 12432 if (stub_sec == NULL
12433 && (htab->glink_eh_frame == NULL
12434 || htab->glink_eh_frame->rawsize == htab->glink_eh_frame->size))
5c3dead3
AM		 12435 break;
12436
721956f4 12437 /* Ask the linker to do its stuff. */
e7d1c40c 12438 (*htab->params->layout_sections_again) ();
721956f4
AM		 12439 }
12440
da44f4e5
AM		 12441 if (htab->glink_eh_frame != NULL
12442 && htab->glink_eh_frame->size != 0)
12443 {
12444 bfd_vma val;
12445 bfd_byte *p, *last_fde;
12446 size_t last_fde_len, size, align, pad;
12447 asection *stub_sec;
12448
12449 p = bfd_zalloc (htab->glink_eh_frame->owner, htab->glink_eh_frame->size);
12450 if (p == NULL)
12451 return FALSE;
12452 htab->glink_eh_frame->contents = p;
12453 last_fde = p;
12454
12455 memcpy (p, glink_eh_frame_cie, sizeof (glink_eh_frame_cie));
12456 /* CIE length (rewrite in case little-endian). */
12457 last_fde_len = sizeof (glink_eh_frame_cie) - 4;
12458 bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
12459 p += sizeof (glink_eh_frame_cie);
12460
12461 for (stub_sec = htab->params->stub_bfd->sections;
12462 stub_sec != NULL;
12463 stub_sec = stub_sec->next)
12464 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12465 {
12466 last_fde = p;
12467 last_fde_len = 20;
12468 /* FDE length. */
12469 bfd_put_32 (htab->elf.dynobj, 20, p);
12470 p += 4;
12471 /* CIE pointer. */
12472 val = p - htab->glink_eh_frame->contents;
12473 bfd_put_32 (htab->elf.dynobj, val, p);
12474 p += 4;
12475 /* Offset to stub section, written later. */
12476 p += 4;
12477 /* stub section size. */
12478 bfd_put_32 (htab->elf.dynobj, stub_sec->size, p);
12479 p += 4;
12480 /* Augmentation. */
12481 p += 1;
12482 /* Pad. */
12483 p += 7;
12484 }
12485 if (htab->glink != NULL && htab->glink->size != 0)
12486 {
12487 last_fde = p;
12488 last_fde_len = 20;
12489 /* FDE length. */
12490 bfd_put_32 (htab->elf.dynobj, 20, p);
12491 p += 4;
12492 /* CIE pointer. */
12493 val = p - htab->glink_eh_frame->contents;
12494 bfd_put_32 (htab->elf.dynobj, val, p);
12495 p += 4;
12496 /* Offset to .glink, written later. */
12497 p += 4;
12498 /* .glink size. */
12499 bfd_put_32 (htab->elf.dynobj, htab->glink->size - 8, p);
12500 p += 4;
12501 /* Augmentation. */
12502 p += 1;
12503
12504 *p++ = DW_CFA_advance_loc + 1;
12505 *p++ = DW_CFA_register;
12506 *p++ = 65;
12507 *p++ = 12;
12508 *p++ = DW_CFA_advance_loc + 4;
12509 *p++ = DW_CFA_restore_extended;
12510 *p++ = 65;
12511 }
12512 /* Subsume any padding into the last FDE if user .eh_frame
12513 sections are aligned more than glink_eh_frame. Otherwise any
12514 zero padding will be seen as a terminator. */
12515 size = p - htab->glink_eh_frame->contents;
12516 align = 1;
12517 align <<= htab->glink_eh_frame->output_section->alignment_power;
12518 align -= 1;
12519 pad = ((size + align) & ~align) - size;
12520 htab->glink_eh_frame->size = size + pad;
12521 bfd_put_32 (htab->elf.dynobj, last_fde_len + pad, last_fde);
12522 }
12523
d969d15f
AM		 12524 maybe_strip_output (info, htab->brlt);
12525 if (htab->glink_eh_frame != NULL)
12526 maybe_strip_output (info, htab->glink_eh_frame);
721956f4 12527
b34976b6 12528 return TRUE;
721956f4
AM		 12529}
12530
12531/* Called after we have determined section placement. If sections
805fc799 12532 move, we'll be called again. Provide a value for TOCstart. */
721956f4 12533
805fc799 12534bfd_vma
1c865ab2 12535ppc64_elf_set_toc (struct bfd_link_info *info, bfd *obfd)
721956f4 12536{
805fc799
AM		 12537 asection *s;
12538 bfd_vma TOCstart;
721956f4 12539
805fc799
AM		 12540 /* The TOC consists of sections .got, .toc, .tocbss, .plt in that
12541 order. The TOC starts where the first of these sections starts. */
12542 s = bfd_get_section_by_name (obfd, ".got");
e054468f 12543 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
805fc799 12544 s = bfd_get_section_by_name (obfd, ".toc");
e054468f 12545 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
805fc799 12546 s = bfd_get_section_by_name (obfd, ".tocbss");
e054468f 12547 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
805fc799 12548 s = bfd_get_section_by_name (obfd, ".plt");
e054468f 12549 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
805fc799
AM		 12550 {
12551 /* This may happen for
12552 o references to TOC base (SYM@toc / TOC[tc0]) without a
12553 .toc directive
12554 o bad linker script
12555 o --gc-sections and empty TOC sections
12556
12557 FIXME: Warn user? */
12558
12559 /* Look for a likely section. We probably won't even be
12560 using TOCstart. */
12561 for (s = obfd->sections; s != NULL; s = s->next)
e054468f
AM		 12562 if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_READONLY
12563 | SEC_EXCLUDE))
805fc799
AM		 12564 == (SEC_ALLOC | SEC_SMALL_DATA))
12565 break;
721956f4 12566 if (s == NULL)
805fc799 12567 for (s = obfd->sections; s != NULL; s = s->next)
e054468f 12568 if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_EXCLUDE))
805fc799
AM		 12569 == (SEC_ALLOC | SEC_SMALL_DATA))
12570 break;
721956f4 12571 if (s == NULL)
805fc799 12572 for (s = obfd->sections; s != NULL; s = s->next)
e054468f
AM		 12573 if ((s->flags & (SEC_ALLOC | SEC_READONLY | SEC_EXCLUDE))
12574 == SEC_ALLOC)
805fc799 12575 break;
721956f4 12576 if (s == NULL)
805fc799 12577 for (s = obfd->sections; s != NULL; s = s->next)
e054468f 12578 if ((s->flags & (SEC_ALLOC | SEC_EXCLUDE)) == SEC_ALLOC)
805fc799
AM		 12579 break;
12580 }
721956f4 12581
805fc799
AM		 12582 TOCstart = 0;
12583 if (s != NULL)
12584 TOCstart = s->output_section->vma + s->output_offset;
721956f4 12585
1c865ab2
AM		 12586 _bfd_set_gp_value (obfd, TOCstart);
12587
810d4e75 12588 if (info != NULL && s != NULL)
1c865ab2
AM		 12589 {
12590 struct ppc_link_hash_table *htab = ppc_hash_table (info);
12591
810d4e75
AM		 12592 if (htab != NULL)
12593 {
12594 if (htab->elf.hgot != NULL)
12595 {
12596 htab->elf.hgot->root.u.def.value = TOC_BASE_OFF;
12597 htab->elf.hgot->root.u.def.section = s;
12598 }
12599 }
12600 else
1c865ab2 12601 {
810d4e75
AM		 12602 struct bfd_link_hash_entry *bh = NULL;
12603 _bfd_generic_link_add_one_symbol (info, obfd, ".TOC.", BSF_GLOBAL,
12604 s, TOC_BASE_OFF, NULL, FALSE,
12605 FALSE, &bh);
1c865ab2
AM		 12606 }
12607 }
805fc799 12608 return TOCstart;
721956f4
AM		 12609}
12610
a345bc8d
AM		 12611/* Called via elf_link_hash_traverse from ppc64_elf_build_stubs to
12612 write out any global entry stubs. */
12613
12614static bfd_boolean
12615build_global_entry_stubs (struct elf_link_hash_entry *h, void *inf)
12616{
12617 struct bfd_link_info *info;
12618 struct ppc_link_hash_table *htab;
12619 struct plt_entry *pent;
12620 asection *s;
12621
12622 if (h->root.type == bfd_link_hash_indirect)
12623 return TRUE;
12624
12625 if (!h->pointer_equality_needed)
12626 return TRUE;
12627
12628 if (h->def_regular)
12629 return TRUE;
12630
12631 info = inf;
12632 htab = ppc_hash_table (info);
12633 if (htab == NULL)
12634 return FALSE;
12635
12636 s = htab->glink;
12637 for (pent = h->plt.plist; pent != NULL; pent = pent->next)
12638 if (pent->plt.offset != (bfd_vma) -1
12639 && pent->addend == 0)
12640 {
12641 bfd_byte *p;
12642 asection *plt;
12643 bfd_vma off;
12644
a345bc8d 12645 p = s->contents + h->root.u.def.value;
33e44f2e 12646 plt = htab->elf.splt;
a345bc8d
AM		 12647 if (!htab->elf.dynamic_sections_created
12648 || h->dynindx == -1)
33e44f2e 12649 plt = htab->elf.iplt;
a345bc8d
AM		 12650 off = pent->plt.offset + plt->output_offset + plt->output_section->vma;
12651 off -= h->root.u.def.value + s->output_offset + s->output_section->vma;
12652
12653 if (off + 0x80008000 > 0xffffffff || (off & 3) != 0)
12654 {
12655 info->callbacks->einfo
12656 (_("%P: linkage table error against `%T'\n"),
12657 h->root.root.string);
12658 bfd_set_error (bfd_error_bad_value);
12659 htab->stub_error = TRUE;
12660 }
12661
7341d5e2
AM		 12662 htab->stub_count[ppc_stub_global_entry - 1] += 1;
12663 if (htab->params->emit_stub_syms)
12664 {
12665 size_t len = strlen (h->root.root.string);
12666 char *name = bfd_malloc (sizeof "12345678.global_entry." + len);
12667
12668 if (name == NULL)
12669 return FALSE;
12670
12671 sprintf (name, "%08x.global_entry.%s", s->id, h->root.root.string);
12672 h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
12673 if (h == NULL)
12674 return FALSE;
12675 if (h->root.type == bfd_link_hash_new)
12676 {
12677 h->root.type = bfd_link_hash_defined;
12678 h->root.u.def.section = s;
12679 h->root.u.def.value = p - s->contents;
12680 h->ref_regular = 1;
12681 h->def_regular = 1;
12682 h->ref_regular_nonweak = 1;
12683 h->forced_local = 1;
12684 h->non_elf = 0;
2ec55de3 12685 h->root.linker_def = 1;
7341d5e2
AM		 12686 }
12687 }
12688
a345bc8d
AM		 12689 if (PPC_HA (off) != 0)
12690 {
12691 bfd_put_32 (s->owner, ADDIS_R12_R12 | PPC_HA (off), p);
12692 p += 4;
12693 }
12694 bfd_put_32 (s->owner, LD_R12_0R12 | PPC_LO (off), p);
12695 p += 4;
12696 bfd_put_32 (s->owner, MTCTR_R12, p);
12697 p += 4;
12698 bfd_put_32 (s->owner, BCTR, p);
12699 break;
12700 }
12701 return TRUE;
12702}
12703
721956f4
AM		 12704/* Build all the stubs associated with the current output file.
12705 The stubs are kept in a hash table attached to the main linker
12706 hash table. This function is called via gldelf64ppc_finish. */
12707
b34976b6 12708bfd_boolean
e7d1c40c 12709ppc64_elf_build_stubs (struct bfd_link_info *info,
4ce794b7 12710 char **stats)
5d1634d7
AM		 12711{
12712 struct ppc_link_hash_table *htab = ppc_hash_table (info);
721956f4 12713 asection *stub_sec;
5d1634d7 12714 bfd_byte *p;
e717da7e 12715 int stub_sec_count = 0;
5d1634d7 12716
4dfe6ac6
NC		 12717 if (htab == NULL)
12718 return FALSE;
12719
eea6121a 12720 /* Allocate memory to hold the linker stubs. */
e7d1c40c 12721 for (stub_sec = htab->params->stub_bfd->sections;
721956f4
AM		 12722 stub_sec != NULL;
12723 stub_sec = stub_sec->next)
eea6121a
AM		 12724 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
12725 && stub_sec->size != 0)
e717da7e 12726 {
e7d1c40c 12727 stub_sec->contents = bfd_zalloc (htab->params->stub_bfd, stub_sec->size);
eea6121a
AM		 12728 if (stub_sec->contents == NULL)
12729 return FALSE;
12730 /* We want to check that built size is the same as calculated
12731 size. rawsize is a convenient location to use. */
12732 stub_sec->rawsize = stub_sec->size;
12733 stub_sec->size = 0;
e717da7e 12734 }
5d1634d7 12735
23eb7e01 12736 if (htab->glink != NULL && htab->glink->size != 0)
5d1634d7 12737 {
9f951329 12738 unsigned int indx;
ad8e1ba5 12739 bfd_vma plt0;
9f951329 12740
721956f4 12741 /* Build the .glink plt call stub. */
e7d1c40c 12742 if (htab->params->emit_stub_syms)
97b639ba
AM		 12743 {
12744 struct elf_link_hash_entry *h;
468392fb
AM		 12745 h = elf_link_hash_lookup (&htab->elf, "__glink_PLTresolve",
12746 TRUE, FALSE, FALSE);
97b639ba
AM		 12747 if (h == NULL)
12748 return FALSE;
12749 if (h->root.type == bfd_link_hash_new)
12750 {
12751 h->root.type = bfd_link_hash_defined;
12752 h->root.u.def.section = htab->glink;
ee4bf8d2 12753 h->root.u.def.value = 8;
f5385ebf
AM		 12754 h->ref_regular = 1;
12755 h->def_regular = 1;
12756 h->ref_regular_nonweak = 1;
12757 h->forced_local = 1;
12758 h->non_elf = 0;
2ec55de3 12759 h->root.linker_def = 1;
97b639ba
AM		 12760 }
12761 }
33e44f2e
AM		 12762 plt0 = (htab->elf.splt->output_section->vma
12763 + htab->elf.splt->output_offset
12764 - 16);
176a0d42
AM		 12765 if (info->emitrelocations)
12766 {
12767 Elf_Internal_Rela *r = get_relocs (htab->glink, 1);
12768 if (r == NULL)
12769 return FALSE;
12770 r->r_offset = (htab->glink->output_offset
12771 + htab->glink->output_section->vma);
12772 r->r_info = ELF64_R_INFO (0, R_PPC64_REL64);
12773 r->r_addend = plt0;
12774 }
4ce794b7 12775 p = htab->glink->contents;
176a0d42 12776 plt0 -= htab->glink->output_section->vma + htab->glink->output_offset;
ee4bf8d2
AM		 12777 bfd_put_64 (htab->glink->owner, plt0, p);
12778 p += 8;
b9e5796b
AM		 12779 if (htab->opd_abi)
12780 {
12781 bfd_put_32 (htab->glink->owner, MFLR_R12, p);
12782 p += 4;
12783 bfd_put_32 (htab->glink->owner, BCL_20_31, p);
12784 p += 4;
12785 bfd_put_32 (htab->glink->owner, MFLR_R11, p);
12786 p += 4;
12787 bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
12788 p += 4;
12789 bfd_put_32 (htab->glink->owner, MTLR_R12, p);
12790 p += 4;
12791 bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
12792 p += 4;
12793 bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
12794 p += 4;
12795 bfd_put_32 (htab->glink->owner, LD_R2_0R11 | 8, p);
12796 p += 4;
12797 bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
12798 p += 4;
12799 bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 16, p);
12800 p += 4;
12801 }
12802 else
12803 {
12804 bfd_put_32 (htab->glink->owner, MFLR_R0, p);
12805 p += 4;
12806 bfd_put_32 (htab->glink->owner, BCL_20_31, p);
12807 p += 4;
12808 bfd_put_32 (htab->glink->owner, MFLR_R11, p);
12809 p += 4;
12810 bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
12811 p += 4;
12812 bfd_put_32 (htab->glink->owner, MTLR_R0, p);
12813 p += 4;
12814 bfd_put_32 (htab->glink->owner, SUB_R12_R12_R11, p);
12815 p += 4;
12816 bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
12817 p += 4;
12818 bfd_put_32 (htab->glink->owner, ADDI_R0_R12 | (-48 & 0xffff), p);
12819 p += 4;
12820 bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
12821 p += 4;
12822 bfd_put_32 (htab->glink->owner, SRDI_R0_R0_2, p);
12823 p += 4;
12824 bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
12825 p += 4;
12826 bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 8, p);
12827 p += 4;
12828 }
4ce794b7 12829 bfd_put_32 (htab->glink->owner, BCTR, p);
ad8e1ba5 12830 p += 4;
ee4bf8d2
AM		 12831 while (p - htab->glink->contents < GLINK_CALL_STUB_SIZE)
12832 {
12833 bfd_put_32 (htab->glink->owner, NOP, p);
12834 p += 4;
12835 }
ad8e1ba5 12836
9f951329
AM		 12837 /* Build the .glink lazy link call stubs. */
12838 indx = 0;
a345bc8d 12839 while (p < htab->glink->contents + htab->glink->rawsize)
9f951329 12840 {
b9e5796b 12841 if (htab->opd_abi)
9f951329 12842 {
b9e5796b
AM		 12843 if (indx < 0x8000)
12844 {
12845 bfd_put_32 (htab->glink->owner, LI_R0_0 | indx, p);
12846 p += 4;
12847 }
12848 else
12849 {
12850 bfd_put_32 (htab->glink->owner, LIS_R0_0 | PPC_HI (indx), p);
12851 p += 4;
12852 bfd_put_32 (htab->glink->owner, ORI_R0_R0_0 | PPC_LO (indx),
12853 p);
12854 p += 4;
12855 }
9f951329 12856 }
4ce794b7 12857 bfd_put_32 (htab->glink->owner,
ee4bf8d2 12858 B_DOT | ((htab->glink->contents - p + 8) & 0x3fffffc), p);
a16d5acb 12859 indx++;
9f951329
AM		 12860 p += 4;
12861 }
a345bc8d
AM		 12862
12863 /* Build .glink global entry stubs. */
12864 if (htab->glink->size > htab->glink->rawsize)
afe397ea 12865 elf_link_hash_traverse (&htab->elf, build_global_entry_stubs, info);
5d1634d7 12866 }
5d1634d7 12867
7341d5e2 12868 if (htab->brlt != NULL && htab->brlt->size != 0)
721956f4 12869 {
4ce794b7 12870 htab->brlt->contents = bfd_zalloc (htab->brlt->owner,
eea6121a 12871 htab->brlt->size);
4ce794b7 12872 if (htab->brlt->contents == NULL)
b34976b6 12873 return FALSE;
721956f4 12874 }
ee75fd95 12875 if (htab->relbrlt != NULL && htab->relbrlt->size != 0)
63bc6f6c
AM		 12876 {
12877 htab->relbrlt->contents = bfd_zalloc (htab->relbrlt->owner,
eea6121a 12878 htab->relbrlt->size);
63bc6f6c
AM		 12879 if (htab->relbrlt->contents == NULL)
12880 return FALSE;
12881 }
5d1634d7 12882
721956f4
AM		 12883 /* Build the stubs as directed by the stub hash table. */
12884 bfd_hash_traverse (&htab->stub_hash_table, ppc_build_one_stub, info);
5d1634d7 12885
aa8a7074
AM		 12886 if (htab->relbrlt != NULL)
12887 htab->relbrlt->reloc_count = 0;
12888
e7d1c40c
AM		 12889 if (htab->params->plt_stub_align != 0)
12890 for (stub_sec = htab->params->stub_bfd->sections;
794e51c0
AM		 12891 stub_sec != NULL;
12892 stub_sec = stub_sec->next)
12893 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
e7d1c40c
AM		 12894 stub_sec->size = ((stub_sec->size
12895 + (1 << htab->params->plt_stub_align) - 1)
12896 & (-1 << htab->params->plt_stub_align));
794e51c0 12897
e7d1c40c 12898 for (stub_sec = htab->params->stub_bfd->sections;
721956f4
AM		 12899 stub_sec != NULL;
12900 stub_sec = stub_sec->next)
e717da7e
AM		 12901 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12902 {
12903 stub_sec_count += 1;
eea6121a 12904 if (stub_sec->rawsize != stub_sec->size)
e717da7e
AM		 12905 break;
12906 }
5d1634d7 12907
da44f4e5
AM		 12908 /* Note that the glink_eh_frame check here is not only testing that
12909 the generated size matched the calculated size but also that
12910 bfd_elf_discard_info didn't make any changes to the section. */
721956f4 12911 if (stub_sec != NULL
58d180e8
AM		 12912 || (htab->glink_eh_frame != NULL
12913 && htab->glink_eh_frame->rawsize != htab->glink_eh_frame->size))
5d1634d7 12914 {
b34976b6 12915 htab->stub_error = TRUE;
8de848d8 12916 info->callbacks->einfo (_("%P: stubs don't match calculated size\n"));
5d1634d7 12917 }
721956f4 12918
d2a300cf
AM		 12919 if (htab->stub_error)
12920 return FALSE;
12921
12922 if (stats != NULL)
12923 {
12924 *stats = bfd_malloc (500);
12925 if (*stats == NULL)
12926 return FALSE;
12927
ee75fd95 12928 sprintf (*stats, _("linker stubs in %u group%s\n"
d2a300cf
AM		 12929 " branch %lu\n"
12930 " toc adjust %lu\n"
12931 " long branch %lu\n"
12932 " long toc adj %lu\n"
794e51c0 12933 " plt call %lu\n"
7341d5e2
AM		 12934 " plt call toc %lu\n"
12935 " global entry %lu"),
e717da7e 12936 stub_sec_count,
ee75fd95 12937 stub_sec_count == 1 ? "" : "s",
4ce794b7
AM		 12938 htab->stub_count[ppc_stub_long_branch - 1],
12939 htab->stub_count[ppc_stub_long_branch_r2off - 1],
12940 htab->stub_count[ppc_stub_plt_branch - 1],
12941 htab->stub_count[ppc_stub_plt_branch_r2off - 1],
794e51c0 12942 htab->stub_count[ppc_stub_plt_call - 1],
7341d5e2
AM		 12943 htab->stub_count[ppc_stub_plt_call_r2save - 1],
12944 htab->stub_count[ppc_stub_global_entry - 1]);
d2a300cf
AM		 12945 }
12946 return TRUE;
5bd4f169
AM		 12947}
12948
99877b66
AM		 12949/* This function undoes the changes made by add_symbol_adjust. */
12950
12951static bfd_boolean
12952undo_symbol_twiddle (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
12953{
12954 struct ppc_link_hash_entry *eh;
12955
12956 if (h->root.type == bfd_link_hash_indirect)
12957 return TRUE;
12958
99877b66
AM		 12959 eh = (struct ppc_link_hash_entry *) h;
12960 if (eh->elf.root.type != bfd_link_hash_undefweak || !eh->was_undefined)
12961 return TRUE;
12962
12963 eh->elf.root.type = bfd_link_hash_undefined;
12964 return TRUE;
12965}
12966
12967void
12968ppc64_elf_restore_symbols (struct bfd_link_info *info)
12969{
12970 struct ppc_link_hash_table *htab = ppc_hash_table (info);
4dfe6ac6
NC		 12971
12972 if (htab != NULL)
12973 elf_link_hash_traverse (&htab->elf, undo_symbol_twiddle, info);
99877b66
AM		 12974}
12975
60124e18
AM		 12976/* What to do when ld finds relocations against symbols defined in
12977 discarded sections. */
12978
12979static unsigned int
12980ppc64_elf_action_discarded (asection *sec)
12981{
12982 if (strcmp (".opd", sec->name) == 0)
12983 return 0;
12984
12985 if (strcmp (".toc", sec->name) == 0)
12986 return 0;
12987
bce50a28
JJ		 12988 if (strcmp (".toc1", sec->name) == 0)
12989 return 0;
12990
60124e18
AM		 12991 return _bfd_elf_default_action_discarded (sec);
12992}
12993
5bd4f169
AM		 12994/* The RELOCATE_SECTION function is called by the ELF backend linker
12995 to handle the relocations for a section.
12996
12997 The relocs are always passed as Rela structures; if the section
12998 actually uses Rel structures, the r_addend field will always be
12999 zero.
13000
13001 This function is responsible for adjust the section contents as
13002 necessary, and (if using Rela relocs and generating a
1049f94e 13003 relocatable output file) adjusting the reloc addend as
5bd4f169
AM		 13004 necessary.
13005
13006 This function does not have to worry about setting the reloc
13007 address or the reloc symbol index.
13008
13009 LOCAL_SYMS is a pointer to the swapped in local symbols.
13010
13011 LOCAL_SECTIONS is an array giving the section in the input file
13012 corresponding to the st_shndx field of each local symbol.
13013
13014 The global hash table entry for the global symbols can be found
13015 via elf_sym_hashes (input_bfd).
13016
1049f94e 13017 When generating relocatable output, this function must handle
5bd4f169
AM		 13018 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
13019 going to be the section symbol corresponding to the output
13020 section, which means that the addend must be adjusted
13021 accordingly. */
13022
b34976b6 13023static bfd_boolean
4ce794b7
AM		 13024ppc64_elf_relocate_section (bfd *output_bfd,
13025 struct bfd_link_info *info,
13026 bfd *input_bfd,
13027 asection *input_section,
13028 bfd_byte *contents,
13029 Elf_Internal_Rela *relocs,
13030 Elf_Internal_Sym *local_syms,
13031 asection **local_sections)
5bd4f169 13032{
65f38f15 13033 struct ppc_link_hash_table *htab;
5bd4f169
AM		 13034 Elf_Internal_Shdr *symtab_hdr;
13035 struct elf_link_hash_entry **sym_hashes;
5bd4f169
AM		 13036 Elf_Internal_Rela *rel;
13037 Elf_Internal_Rela *relend;
411e1bfb
AM		 13038 Elf_Internal_Rela outrel;
13039 bfd_byte *loc;
411e1bfb 13040 struct got_entry **local_got_ents;
5bd4f169 13041 bfd_vma TOCstart;
b34976b6
AM		 13042 bfd_boolean ret = TRUE;
13043 bfd_boolean is_opd;
794e51c0
AM		 13044 /* Assume 'at' branch hints. */
13045 bfd_boolean is_isa_v2 = TRUE;
4fe5ca5b 13046 bfd_vma d_offset = (bfd_big_endian (output_bfd) ? 2 : 0);
5bd4f169 13047
65f38f15 13048 /* Initialize howto table if needed. */
5bd4f169 13049 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
5bd4f169
AM		 13050 ppc_howto_init ();
13051
65f38f15 13052 htab = ppc_hash_table (info);
4dfe6ac6
NC		 13053 if (htab == NULL)
13054 return FALSE;
ee75fd95
AM		 13055
13056 /* Don't relocate stub sections. */
e7d1c40c 13057 if (input_section->owner == htab->params->stub_bfd)
ee75fd95
AM		 13058 return TRUE;
13059
0c8d6e5c 13060 BFD_ASSERT (is_ppc64_elf (input_bfd));
0ffa91dd 13061
411e1bfb 13062 local_got_ents = elf_local_got_ents (input_bfd);
5bd4f169 13063 TOCstart = elf_gp (output_bfd);
0ffa91dd 13064 symtab_hdr = &elf_symtab_hdr (input_bfd);
5bd4f169 13065 sym_hashes = elf_sym_hashes (input_bfd);
7c8fe5c4 13066 is_opd = ppc64_elf_section_data (input_section)->sec_type == sec_opd;
65f38f15 13067
5bd4f169
AM		 13068 rel = relocs;
13069 relend = relocs + input_section->reloc_count;
13070 for (; rel < relend; rel++)
13071 {
04c9666a 13072 enum elf_ppc64_reloc_type r_type;
31c76678 13073 bfd_vma addend;
5bd4f169
AM		 13074 bfd_reloc_status_type r;
13075 Elf_Internal_Sym *sym;
13076 asection *sec;
039b3fef
AM		 13077 struct elf_link_hash_entry *h_elf;
13078 struct ppc_link_hash_entry *h;
13079 struct ppc_link_hash_entry *fdh;
5bd4f169 13080 const char *sym_name;
0d4792f7 13081 unsigned long r_symndx, toc_symndx;
3a71aa26 13082 bfd_vma toc_addend;
f961d9dd
AM		 13083 unsigned char tls_mask, tls_gd, tls_type;
13084 unsigned char sym_type;
5bd4f169 13085 bfd_vma relocation;
b34976b6
AM		 13086 bfd_boolean unresolved_reloc;
13087 bfd_boolean warned;
bc30df16 13088 enum { DEST_NORMAL, DEST_OPD, DEST_STUB } reloc_dest;
67f0cbdb 13089 unsigned int insn;
e11840f9 13090 unsigned int mask;
721956f4
AM		 13091 struct ppc_stub_hash_entry *stub_entry;
13092 bfd_vma max_br_offset;
13093 bfd_vma from;
31c76678 13094 const Elf_Internal_Rela orig_rel = *rel;
b80eed39
AM		 13095 reloc_howto_type *howto;
13096 struct reloc_howto_struct alt_howto;
5bd4f169 13097
4ce794b7 13098 r_type = ELF64_R_TYPE (rel->r_info);
5bd4f169 13099 r_symndx = ELF64_R_SYM (rel->r_info);
ee87f2da
AM		 13100
13101 /* For old style R_PPC64_TOC relocs with a zero symbol, use the
13102 symbol of the previous ADDR64 reloc. The symbol gives us the
13103 proper TOC base to use. */
13104 if (rel->r_info == ELF64_R_INFO (0, R_PPC64_TOC)
13105 && rel != relocs
13106 && ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_ADDR64
13107 && is_opd)
13108 r_symndx = ELF64_R_SYM (rel[-1].r_info);
13109
4ce794b7
AM		 13110 sym = NULL;
13111 sec = NULL;
039b3fef 13112 h_elf = NULL;
4ce794b7 13113 sym_name = NULL;
b34976b6
AM		 13114 unresolved_reloc = FALSE;
13115 warned = FALSE;
65f38f15 13116
0b13192e 13117 if (r_symndx < symtab_hdr->sh_info)
5bd4f169
AM		 13118 {
13119 /* It's a local symbol. */
74f0fb50 13120 struct _opd_sec_data *opd;
4025353c 13121
5bd4f169
AM		 13122 sym = local_syms + r_symndx;
13123 sec = local_sections[r_symndx];
26c61ae5 13124 sym_name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym, sec);
0d4792f7 13125 sym_type = ELF64_ST_TYPE (sym->st_info);
8517fae7 13126 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
74f0fb50
AM		 13127 opd = get_opd_info (sec);
13128 if (opd != NULL && opd->adjust != NULL)
1e2f5b6e 13129 {
51aecdc5
AM		 13130 long adjust = opd->adjust[OPD_NDX (sym->st_value
13131 + rel->r_addend)];
4025353c
AM		 13132 if (adjust == -1)
13133 relocation = 0;
13134 else
4cc603a5
AM		 13135 {
13136 /* If this is a relocation against the opd section sym
13137 and we have edited .opd, adjust the reloc addend so
13138 that ld -r and ld --emit-relocs output is correct.
13139 If it is a reloc against some other .opd symbol,
13140 then the symbol value will be adjusted later. */
13141 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
13142 rel->r_addend += adjust;
13143 else
13144 relocation += adjust;
13145 }
1e2f5b6e 13146 }
5bd4f169
AM		 13147 }
13148 else
13149 {
62d887d4
L		 13150 bfd_boolean ignored;
13151
b2a8e766
AM		 13152 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
13153 r_symndx, symtab_hdr, sym_hashes,
039b3fef 13154 h_elf, sec, relocation,
62d887d4 13155 unresolved_reloc, warned, ignored);
039b3fef
AM		 13156 sym_name = h_elf->root.root.string;
13157 sym_type = h_elf->type;
b69fdb4e
AM		 13158 if (sec != NULL
13159 && sec->owner == output_bfd
13160 && strcmp (sec->name, ".opd") == 0)
13161 {
13162 /* This is a symbol defined in a linker script. All
13163 such are defined in output sections, even those
13164 defined by simple assignment from a symbol defined in
13165 an input section. Transfer the symbol to an
13166 appropriate input .opd section, so that a branch to
13167 this symbol will be mapped to the location specified
13168 by the opd entry. */
13169 struct bfd_link_order *lo;
13170 for (lo = sec->map_head.link_order; lo != NULL; lo = lo->next)
13171 if (lo->type == bfd_indirect_link_order)
13172 {
13173 asection *isec = lo->u.indirect.section;
13174 if (h_elf->root.u.def.value >= isec->output_offset
13175 && h_elf->root.u.def.value < (isec->output_offset
13176 + isec->size))
13177 {
13178 h_elf->root.u.def.value -= isec->output_offset;
13179 h_elf->root.u.def.section = isec;
13180 sec = isec;
13181 break;
13182 }
13183 }
13184 }
5bd4f169 13185 }
039b3fef 13186 h = (struct ppc_link_hash_entry *) h_elf;
5bd4f169 13187
dbaa2011 13188 if (sec != NULL && discarded_section (sec))
e4067dbb 13189 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
545fd46b
MR		 13190 rel, 1, relend,
13191 ppc64_elf_howto_table[r_type], 0,
e4067dbb 13192 contents);
ab96bf03
AM		 13193
13194 if (info->relocatable)
13195 continue;
13196
f40da81b
AM		 13197 if (h != NULL && &h->elf == htab->elf.hgot)
13198 {
13199 relocation = (TOCstart
13200 + htab->stub_group[input_section->id].toc_off);
13201 sec = bfd_abs_section_ptr;
13202 unresolved_reloc = FALSE;
13203 }
13204
951fd09b
AM		 13205 /* TLS optimizations. Replace instruction sequences and relocs
13206 based on information we collected in tls_optimize. We edit
13207 RELOCS so that --emit-relocs will output something sensible
13208 for the final instruction stream. */
13209 tls_mask = 0;
13210 tls_gd = 0;
0d4792f7 13211 toc_symndx = 0;
727fc41e
AM		 13212 if (h != NULL)
13213 tls_mask = h->tls_mask;
13214 else if (local_got_ents != NULL)
411e1bfb 13215 {
e054468f
AM		 13216 struct plt_entry **local_plt = (struct plt_entry **)
13217 (local_got_ents + symtab_hdr->sh_info);
f961d9dd 13218 unsigned char *lgot_masks = (unsigned char *)
e054468f 13219 (local_plt + symtab_hdr->sh_info);
727fc41e
AM		 13220 tls_mask = lgot_masks[r_symndx];
13221 }
13222 if (tls_mask == 0
13223 && (r_type == R_PPC64_TLS
13224 || r_type == R_PPC64_TLSGD
13225 || r_type == R_PPC64_TLSLD))
13226 {
13227 /* Check for toc tls entries. */
f961d9dd 13228 unsigned char *toc_tls;
0d4792f7 13229
727fc41e
AM		 13230 if (!get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
13231 &local_syms, rel, input_bfd))
13232 return FALSE;
0d4792f7 13233
727fc41e
AM		 13234 if (toc_tls)
13235 tls_mask = *toc_tls;
0d4792f7
AM		 13236 }
13237
13238 /* Check that tls relocs are used with tls syms, and non-tls
13239 relocs are used with non-tls syms. */
cf35638d 13240 if (r_symndx != STN_UNDEF
0d4792f7
AM		 13241 && r_type != R_PPC64_NONE
13242 && (h == NULL
039b3fef
AM		 13243 || h->elf.root.type == bfd_link_hash_defined
13244 || h->elf.root.type == bfd_link_hash_defweak)
1d483afe
AM		 13245 && (IS_PPC64_TLS_RELOC (r_type)
13246 != (sym_type == STT_TLS
13247 || (sym_type == STT_SECTION
13248 && (sec->flags & SEC_THREAD_LOCAL) != 0))))
0d4792f7 13249 {
727fc41e
AM		 13250 if (tls_mask != 0
13251 && (r_type == R_PPC64_TLS
13252 || r_type == R_PPC64_TLSGD
13253 || r_type == R_PPC64_TLSLD))
0d4792f7
AM		 13254 /* R_PPC64_TLS is OK against a symbol in the TOC. */
13255 ;
13256 else
25f53a85 13257 info->callbacks->einfo
1d483afe 13258 (!IS_PPC64_TLS_RELOC (r_type)
bc30df16
AM		 13259 ? _("%P: %H: %s used with TLS symbol `%T'\n")
13260 : _("%P: %H: %s used with non-TLS symbol `%T'\n"),
25f53a85 13261 input_bfd, input_section, rel->r_offset,
0d4792f7
AM		 13262 ppc64_elf_howto_table[r_type]->name,
13263 sym_name);
411e1bfb
AM		 13264 }
13265
13266 /* Ensure reloc mapping code below stays sane. */
13267 if (R_PPC64_TOC16_LO_DS != R_PPC64_TOC16_DS + 1
13268 || R_PPC64_TOC16_LO != R_PPC64_TOC16 + 1
13269 || (R_PPC64_GOT_TLSLD16 & 3) != (R_PPC64_GOT_TLSGD16 & 3)
13270 || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TLSGD16_LO & 3)
13271 || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TLSGD16_HI & 3)
13272 || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TLSGD16_HA & 3)
13273 || (R_PPC64_GOT_TLSLD16 & 3) != (R_PPC64_GOT_TPREL16_DS & 3)
13274 || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TPREL16_LO_DS & 3)
13275 || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TPREL16_HI & 3)
13276 || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TPREL16_HA & 3))
13277 abort ();
0d4792f7 13278
411e1bfb
AM		 13279 switch (r_type)
13280 {
13281 default:
411e1bfb
AM		 13282 break;
13283
ba761f19
AM		 13284 case R_PPC64_LO_DS_OPT:
13285 insn = bfd_get_32 (output_bfd, contents + rel->r_offset - d_offset);
13286 if ((insn & (0x3f << 26)) != 58u << 26)
13287 abort ();
13288 insn += (14u << 26) - (58u << 26);
13289 bfd_put_32 (output_bfd, insn, contents + rel->r_offset - d_offset);
13290 r_type = R_PPC64_TOC16_LO;
13291 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13292 break;
13293
411e1bfb
AM		 13294 case R_PPC64_TOC16:
13295 case R_PPC64_TOC16_LO:
13296 case R_PPC64_TOC16_DS:
13297 case R_PPC64_TOC16_LO_DS:
411e1bfb
AM		 13298 {
13299 /* Check for toc tls entries. */
f961d9dd 13300 unsigned char *toc_tls;
951fd09b 13301 int retval;
411e1bfb 13302
3a71aa26
AM		 13303 retval = get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
13304 &local_syms, rel, input_bfd);
951fd09b 13305 if (retval == 0)
411e1bfb
AM		 13306 return FALSE;
13307
13308 if (toc_tls)
13309 {
951fd09b 13310 tls_mask = *toc_tls;
411e1bfb
AM		 13311 if (r_type == R_PPC64_TOC16_DS
13312 || r_type == R_PPC64_TOC16_LO_DS)
81407a69
AM		 13313 {
13314 if (tls_mask != 0
13315 && (tls_mask & (TLS_DTPREL | TLS_TPREL)) == 0)
13316 goto toctprel;
13317 }
411e1bfb 13318 else
951fd09b
AM		 13319 {
13320 /* If we found a GD reloc pair, then we might be
13321 doing a GD->IE transition. */
13322 if (retval == 2)
13323 {
13324 tls_gd = TLS_TPRELGD;
13325 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
102890f0 13326 goto tls_ldgd_opt;
951fd09b
AM		 13327 }
13328 else if (retval == 3)
13329 {
13330 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
102890f0 13331 goto tls_ldgd_opt;
951fd09b
AM		 13332 }
13333 }
411e1bfb
AM		 13334 }
13335 }
13336 break;
13337
9d6ded02
AM		 13338 case R_PPC64_GOT_TPREL16_HI:
13339 case R_PPC64_GOT_TPREL16_HA:
13340 if (tls_mask != 0
13341 && (tls_mask & TLS_TPREL) == 0)
13342 {
13343 rel->r_offset -= d_offset;
13344 bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
13345 r_type = R_PPC64_NONE;
13346 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13347 }
13348 break;
13349
411e1bfb
AM		 13350 case R_PPC64_GOT_TPREL16_DS:
13351 case R_PPC64_GOT_TPREL16_LO_DS:
951fd09b
AM		 13352 if (tls_mask != 0
13353 && (tls_mask & TLS_TPREL) == 0)
411e1bfb 13354 {
81407a69 13355 toctprel:
4fe5ca5b 13356 insn = bfd_get_32 (output_bfd, contents + rel->r_offset - d_offset);
411e1bfb
AM		 13357 insn &= 31 << 21;
13358 insn |= 0x3c0d0000; /* addis 0,13,0 */
4fe5ca5b 13359 bfd_put_32 (output_bfd, insn, contents + rel->r_offset - d_offset);
411e1bfb 13360 r_type = R_PPC64_TPREL16_HA;
0d4792f7
AM		 13361 if (toc_symndx != 0)
13362 {
13363 rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
3a71aa26 13364 rel->r_addend = toc_addend;
0d4792f7
AM		 13365 /* We changed the symbol. Start over in order to
13366 get h, sym, sec etc. right. */
13367 rel--;
13368 continue;
13369 }
13370 else
13371 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
411e1bfb
AM		 13372 }
13373 break;
13374
13375 case R_PPC64_TLS:
951fd09b
AM		 13376 if (tls_mask != 0
13377 && (tls_mask & TLS_TPREL) == 0)
411e1bfb 13378 {
411e1bfb 13379 insn = bfd_get_32 (output_bfd, contents + rel->r_offset);
2d0f3896
AM		 13380 insn = _bfd_elf_ppc_at_tls_transform (insn, 13);
13381 if (insn == 0)
411e1bfb 13382 abort ();
411e1bfb 13383 bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
411e1bfb 13384 /* Was PPC64_TLS which sits on insn boundary, now
4fe5ca5b
GM		 13385 PPC64_TPREL16_LO which is at low-order half-word. */
13386 rel->r_offset += d_offset;
0d4792f7
AM		 13387 r_type = R_PPC64_TPREL16_LO;
13388 if (toc_symndx != 0)
13389 {
13390 rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
3a71aa26 13391 rel->r_addend = toc_addend;
0d4792f7
AM		 13392 /* We changed the symbol. Start over in order to
13393 get h, sym, sec etc. right. */
13394 rel--;
13395 continue;
13396 }
13397 else
13398 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
411e1bfb
AM		 13399 }
13400 break;
13401
411e1bfb
AM		 13402 case R_PPC64_GOT_TLSGD16_HI:
13403 case R_PPC64_GOT_TLSGD16_HA:
951fd09b
AM		 13404 tls_gd = TLS_TPRELGD;
13405 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13406 goto tls_gdld_hi;
13407 break;
13408
411e1bfb
AM		 13409 case R_PPC64_GOT_TLSLD16_HI:
13410 case R_PPC64_GOT_TLSLD16_HA:
951fd09b 13411 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
411e1bfb 13412 {
951fd09b
AM		 13413 tls_gdld_hi:
13414 if ((tls_mask & tls_gd) != 0)
13415 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
13416 + R_PPC64_GOT_TPREL16_DS);
13417 else
411e1bfb 13418 {
4fe5ca5b 13419 rel->r_offset -= d_offset;
727ac201 13420 bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
951fd09b 13421 r_type = R_PPC64_NONE;
411e1bfb 13422 }
951fd09b 13423 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
411e1bfb
AM		 13424 }
13425 break;
13426
951fd09b
AM		 13427 case R_PPC64_GOT_TLSGD16:
13428 case R_PPC64_GOT_TLSGD16_LO:
13429 tls_gd = TLS_TPRELGD;
13430 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
102890f0 13431 goto tls_ldgd_opt;
951fd09b 13432 break;
411e1bfb 13433
951fd09b
AM		 13434 case R_PPC64_GOT_TLSLD16:
13435 case R_PPC64_GOT_TLSLD16_LO:
13436 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13437 {
3a71aa26 13438 unsigned int insn1, insn2, insn3;
102890f0
AM		 13439 bfd_vma offset;
13440
13441 tls_ldgd_opt:
727fc41e
AM		 13442 offset = (bfd_vma) -1;
13443 /* If not using the newer R_PPC64_TLSGD/LD to mark
13444 __tls_get_addr calls, we must trust that the call
13445 stays with its arg setup insns, ie. that the next
13446 reloc is the __tls_get_addr call associated with
13447 the current reloc. Edit both insns. */
13448 if (input_section->has_tls_get_addr_call
13449 && rel + 1 < relend
13450 && branch_reloc_hash_match (input_bfd, rel + 1,
13451 htab->tls_get_addr,
13452 htab->tls_get_addr_fd))
13453 offset = rel[1].r_offset;
b86ac8e3
AM		 13454 /* We read the low GOT_TLS (or TOC16) insn because we
13455 need to keep the destination reg. It may be
13456 something other than the usual r3, and moved to r3
13457 before the call by intervening code. */
13458 insn1 = bfd_get_32 (output_bfd,
13459 contents + rel->r_offset - d_offset);
102890f0 13460 if ((tls_mask & tls_gd) != 0)
411e1bfb 13461 {
102890f0 13462 /* IE */
b86ac8e3 13463 insn1 &= (0x1f << 21) | (0x1f << 16);
102890f0
AM		 13464 insn1 |= 58 << 26; /* ld */
13465 insn2 = 0x7c636a14; /* add 3,3,13 */
727fc41e 13466 if (offset != (bfd_vma) -1)
f58d5a2d 13467 rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
102890f0
AM		 13468 if ((tls_mask & TLS_EXPLICIT) == 0)
13469 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
13470 + R_PPC64_GOT_TPREL16_DS);
411e1bfb 13471 else
102890f0
AM		 13472 r_type += R_PPC64_TOC16_DS - R_PPC64_TOC16;
13473 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13474 }
13475 else
13476 {
13477 /* LE */
b86ac8e3
AM		 13478 insn1 &= 0x1f << 21;
13479 insn1 |= 0x3c0d0000; /* addis r,13,0 */
102890f0
AM		 13480 insn2 = 0x38630000; /* addi 3,3,0 */
13481 if (tls_gd == 0)
951fd09b 13482 {
102890f0 13483 /* Was an LD reloc. */
1d483afe
AM		 13484 if (toc_symndx)
13485 sec = local_sections[toc_symndx];
13486 for (r_symndx = 0;
13487 r_symndx < symtab_hdr->sh_info;
13488 r_symndx++)
13489 if (local_sections[r_symndx] == sec)
13490 break;
13491 if (r_symndx >= symtab_hdr->sh_info)
cf35638d 13492 r_symndx = STN_UNDEF;
102890f0 13493 rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
cf35638d 13494 if (r_symndx != STN_UNDEF)
1d483afe
AM		 13495 rel->r_addend -= (local_syms[r_symndx].st_value
13496 + sec->output_offset
13497 + sec->output_section->vma);
951fd09b 13498 }
102890f0 13499 else if (toc_symndx != 0)
3a71aa26
AM		 13500 {
13501 r_symndx = toc_symndx;
13502 rel->r_addend = toc_addend;
13503 }
102890f0
AM		 13504 r_type = R_PPC64_TPREL16_HA;
13505 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
727fc41e
AM		 13506 if (offset != (bfd_vma) -1)
13507 {
13508 rel[1].r_info = ELF64_R_INFO (r_symndx,
13509 R_PPC64_TPREL16_LO);
13510 rel[1].r_offset = offset + d_offset;
13511 rel[1].r_addend = rel->r_addend;
13512 }
102890f0 13513 }
3a71aa26
AM		 13514 bfd_put_32 (output_bfd, insn1,
13515 contents + rel->r_offset - d_offset);
727fc41e
AM		 13516 if (offset != (bfd_vma) -1)
13517 {
13518 insn3 = bfd_get_32 (output_bfd,
13519 contents + offset + 4);
13520 if (insn3 == NOP
13521 || insn3 == CROR_151515 || insn3 == CROR_313131)
13522 {
13523 rel[1].r_offset += 4;
13524 bfd_put_32 (output_bfd, insn2, contents + offset + 4);
13525 insn2 = NOP;
13526 }
13527 bfd_put_32 (output_bfd, insn2, contents + offset);
13528 }
13529 if ((tls_mask & tls_gd) == 0
13530 && (tls_gd == 0 || toc_symndx != 0))
13531 {
13532 /* We changed the symbol. Start over in order
13533 to get h, sym, sec etc. right. */
13534 rel--;
13535 continue;
13536 }
13537 }
13538 break;
13539
13540 case R_PPC64_TLSGD:
13541 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13542 {
13543 unsigned int insn2, insn3;
13544 bfd_vma offset = rel->r_offset;
13545
13546 if ((tls_mask & TLS_TPRELGD) != 0)
13547 {
13548 /* IE */
13549 r_type = R_PPC64_NONE;
13550 insn2 = 0x7c636a14; /* add 3,3,13 */
13551 }
13552 else
13553 {
13554 /* LE */
13555 if (toc_symndx != 0)
13556 {
13557 r_symndx = toc_symndx;
13558 rel->r_addend = toc_addend;
13559 }
13560 r_type = R_PPC64_TPREL16_LO;
13561 rel->r_offset = offset + d_offset;
13562 insn2 = 0x38630000; /* addi 3,3,0 */
13563 }
13564 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13565 /* Zap the reloc on the _tls_get_addr call too. */
13566 BFD_ASSERT (offset == rel[1].r_offset);
f58d5a2d 13567 rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
3a71aa26
AM		 13568 insn3 = bfd_get_32 (output_bfd,
13569 contents + offset + 4);
102890f0
AM		 13570 if (insn3 == NOP
13571 || insn3 == CROR_151515 || insn3 == CROR_313131)
13572 {
727fc41e 13573 rel->r_offset += 4;
3a71aa26
AM		 13574 bfd_put_32 (output_bfd, insn2, contents + offset + 4);
13575 insn2 = NOP;
102890f0 13576 }
102890f0 13577 bfd_put_32 (output_bfd, insn2, contents + offset);
727fc41e 13578 if ((tls_mask & TLS_TPRELGD) == 0 && toc_symndx != 0)
102890f0 13579 {
102890f0
AM		 13580 rel--;
13581 continue;
411e1bfb 13582 }
411e1bfb 13583 }
411e1bfb
AM		 13584 break;
13585
727fc41e
AM		 13586 case R_PPC64_TLSLD:
13587 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13588 {
13589 unsigned int insn2, insn3;
13590 bfd_vma offset = rel->r_offset;
13591
13592 if (toc_symndx)
13593 sec = local_sections[toc_symndx];
13594 for (r_symndx = 0;
13595 r_symndx < symtab_hdr->sh_info;
13596 r_symndx++)
13597 if (local_sections[r_symndx] == sec)
13598 break;
13599 if (r_symndx >= symtab_hdr->sh_info)
cf35638d 13600 r_symndx = STN_UNDEF;
727fc41e 13601 rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
cf35638d 13602 if (r_symndx != STN_UNDEF)
727fc41e
AM		 13603 rel->r_addend -= (local_syms[r_symndx].st_value
13604 + sec->output_offset
13605 + sec->output_section->vma);
13606
13607 r_type = R_PPC64_TPREL16_LO;
13608 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13609 rel->r_offset = offset + d_offset;
13610 /* Zap the reloc on the _tls_get_addr call too. */
13611 BFD_ASSERT (offset == rel[1].r_offset);
f58d5a2d 13612 rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
727fc41e
AM		 13613 insn2 = 0x38630000; /* addi 3,3,0 */
13614 insn3 = bfd_get_32 (output_bfd,
13615 contents + offset + 4);
13616 if (insn3 == NOP
13617 || insn3 == CROR_151515 || insn3 == CROR_313131)
13618 {
13619 rel->r_offset += 4;
13620 bfd_put_32 (output_bfd, insn2, contents + offset + 4);
13621 insn2 = NOP;
13622 }
13623 bfd_put_32 (output_bfd, insn2, contents + offset);
13624 rel--;
13625 continue;
13626 }
13627 break;
13628
411e1bfb 13629 case R_PPC64_DTPMOD64:
951fd09b
AM		 13630 if (rel + 1 < relend
13631 && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
13632 && rel[1].r_offset == rel->r_offset + 8)
411e1bfb 13633 {
951fd09b
AM		 13634 if ((tls_mask & TLS_GD) == 0)
13635 {
13636 rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_NONE);
13637 if ((tls_mask & TLS_TPRELGD) != 0)
13638 r_type = R_PPC64_TPREL64;
13639 else
13640 {
4ce794b7 13641 bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
951fd09b
AM		 13642 r_type = R_PPC64_NONE;
13643 }
13644 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13645 }
13646 }
13647 else
13648 {
13649 if ((tls_mask & TLS_LD) == 0)
411e1bfb 13650 {
4ce794b7 13651 bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
411e1bfb 13652 r_type = R_PPC64_NONE;
951fd09b 13653 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
411e1bfb 13654 }
411e1bfb
AM		 13655 }
13656 break;
13657
13658 case R_PPC64_TPREL64:
951fd09b 13659 if ((tls_mask & TLS_TPREL) == 0)
411e1bfb
AM		 13660 {
13661 r_type = R_PPC64_NONE;
13662 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13663 }
13664 break;
52a82034
AM		 13665
13666 case R_PPC64_REL16_HA:
13667 /* If we are generating a non-PIC executable, edit
13668 . 0: addis 2,12,.TOC.-0b@ha
13669 . addi 2,2,.TOC.-0b@l
13670 used by ELFv2 global entry points to set up r2, to
13671 . lis 2,.TOC.@ha
13672 . addi 2,2,.TOC.@l
13673 if .TOC. is in range. */
13674 if (!info->shared
810d4e75 13675 && !info->traditional_format
52a82034
AM		 13676 && h != NULL && &h->elf == htab->elf.hgot
13677 && rel + 1 < relend
13678 && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_REL16_LO)
13679 && rel[1].r_offset == rel->r_offset + 4
13680 && rel[1].r_addend == rel->r_addend + 4
13681 && relocation + 0x80008000 <= 0xffffffff)
13682 {
13683 unsigned int insn1, insn2;
13684 bfd_vma offset = rel->r_offset - d_offset;
13685 insn1 = bfd_get_32 (output_bfd, contents + offset);
13686 insn2 = bfd_get_32 (output_bfd, contents + offset + 4);
13687 if ((insn1 & 0xffff0000) == 0x3c4c0000 /* addis 2,12 */
13688 && (insn2 & 0xffff0000) == 0x38420000 /* addi 2,2 */)
13689 {
13690 r_type = R_PPC64_ADDR16_HA;
13691 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13692 rel->r_addend -= d_offset;
13693 rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_ADDR16_LO);
13694 rel[1].r_addend -= d_offset + 4;
13695 bfd_put_32 (output_bfd, 0x3c400000, contents + offset);
13696 }
13697 }
13698 break;
411e1bfb
AM		 13699 }
13700
13701 /* Handle other relocations that tweak non-addend part of insn. */
86c76c7b 13702 insn = 0;
b25116a9
AM		 13703 max_br_offset = 1 << 25;
13704 addend = rel->r_addend;
bc30df16 13705 reloc_dest = DEST_NORMAL;
65f38f15 13706 switch (r_type)
5bd4f169
AM		 13707 {
13708 default:
65f38f15 13709 break;
5bd4f169 13710
3b421ab3
AM		 13711 case R_PPC64_TOCSAVE:
13712 if (relocation + addend == (rel->r_offset
13713 + input_section->output_offset
13714 + input_section->output_section->vma)
13715 && tocsave_find (htab, NO_INSERT,
13716 &local_syms, rel, input_bfd))
13717 {
13718 insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
13719 if (insn == NOP
13720 || insn == CROR_151515 || insn == CROR_313131)
a078d95a
AM		 13721 bfd_put_32 (input_bfd,
13722 STD_R2_0R1 + STK_TOC (htab),
3b421ab3
AM		 13723 contents + rel->r_offset);
13724 }
13725 break;
13726
65f38f15
AM		 13727 /* Branch taken prediction relocations. */
13728 case R_PPC64_ADDR14_BRTAKEN:
13729 case R_PPC64_REL14_BRTAKEN:
cedb70c5
KH		 13730 insn = 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field. */
13731 /* Fall thru. */
65f38f15 13732
86c76c7b 13733 /* Branch not taken prediction relocations. */
65f38f15
AM		 13734 case R_PPC64_ADDR14_BRNTAKEN:
13735 case R_PPC64_REL14_BRNTAKEN:
411e1bfb
AM		 13736 insn |= bfd_get_32 (output_bfd,
13737 contents + rel->r_offset) & ~(0x01 << 21);
b25116a9 13738 /* Fall thru. */
86c76c7b 13739
b25116a9
AM		 13740 case R_PPC64_REL14:
13741 max_br_offset = 1 << 15;
13742 /* Fall thru. */
5bd4f169 13743
65f38f15 13744 case R_PPC64_REL24:
ad8e1ba5
AM		 13745 /* Calls to functions with a different TOC, such as calls to
13746 shared objects, need to alter the TOC pointer. This is
13747 done using a linkage stub. A REL24 branching to these
13748 linkage stubs needs to be followed by a nop, as the nop
13749 will be replaced with an instruction to restore the TOC
13750 base pointer. */
8387904d 13751 fdh = h;
b31867b6
AM		 13752 if (h != NULL
13753 && h->oh != NULL
13754 && h->oh->is_func_descriptor)
13755 fdh = ppc_follow_link (h->oh);
31c76678
DK		 13756 stub_entry = ppc_get_stub_entry (input_section, sec, fdh, &orig_rel,
13757 htab);
6abec6bc 13758 if (stub_entry != NULL
ad8e1ba5 13759 && (stub_entry->stub_type == ppc_stub_plt_call
794e51c0 13760 || stub_entry->stub_type == ppc_stub_plt_call_r2save
ad8e1ba5
AM		 13761 || stub_entry->stub_type == ppc_stub_plt_branch_r2off
13762 || stub_entry->stub_type == ppc_stub_long_branch_r2off))
41bd81ab 13763 {
b25116a9 13764 bfd_boolean can_plt_call = FALSE;
721956f4 13765
ba8ca3e7
AM		 13766 /* All of these stubs will modify r2, so there must be a
13767 branch and link followed by a nop. The nop is
13768 replaced by an insn to restore r2. */
eea6121a 13769 if (rel->r_offset + 8 <= input_section->size)
41bd81ab 13770 {
ba8ca3e7
AM		 13771 unsigned long br;
13772
13773 br = bfd_get_32 (input_bfd,
13774 contents + rel->r_offset);
13775 if ((br & 1) != 0)
41bd81ab 13776 {
ba8ca3e7
AM		 13777 unsigned long nop;
13778
13779 nop = bfd_get_32 (input_bfd,
13780 contents + rel->r_offset + 4);
13781 if (nop == NOP
13782 || nop == CROR_151515 || nop == CROR_313131)
a7f2871e 13783 {
ba8ca3e7
AM		 13784 if (h != NULL
13785 && (h == htab->tls_get_addr_fd
13786 || h == htab->tls_get_addr)
e7d1c40c 13787 && !htab->params->no_tls_get_addr_opt)
ba8ca3e7
AM		 13788 {
13789 /* Special stub used, leave nop alone. */
13790 }
13791 else
a078d95a
AM		 13792 bfd_put_32 (input_bfd,
13793 LD_R2_0R1 + STK_TOC (htab),
ba8ca3e7
AM		 13794 contents + rel->r_offset + 4);
13795 can_plt_call = TRUE;
a7f2871e 13796 }
41bd81ab 13797 }
5bd4f169 13798 }
721956f4 13799
ba8ca3e7 13800 if (!can_plt_call && h != NULL)
721956f4 13801 {
ba8ca3e7
AM		 13802 const char *name = h->elf.root.root.string;
13803
13804 if (*name == '.')
13805 ++name;
13806
13807 if (strncmp (name, "__libc_start_main", 17) == 0
13808 && (name[17] == 0 || name[17] == '@'))
6ab189d5 13809 {
ba8ca3e7
AM		 13810 /* Allow crt1 branch to go via a toc adjusting
13811 stub. Other calls that never return could do
13812 the same, if we could detect such. */
b25116a9 13813 can_plt_call = TRUE;
6ab189d5 13814 }
ba8ca3e7
AM		 13815 }
13816
13817 if (!can_plt_call)
13818 {
13819 /* g++ as of 20130507 emits self-calls without a
13820 following nop. This is arguably wrong since we
13821 have conflicting information. On the one hand a
13822 global symbol and on the other a local call
13823 sequence, but don't error for this special case.
13824 It isn't possible to cheaply verify we have
13825 exactly such a call. Allow all calls to the same
13826 section. */
13827 asection *code_sec = sec;
13828
13829 if (get_opd_info (sec) != NULL)
ad8e1ba5 13830 {
ba8ca3e7
AM		 13831 bfd_vma off = (relocation + addend
13832 - sec->output_section->vma
13833 - sec->output_offset);
bc30df16 13834
ba8ca3e7 13835 opd_entry_value (sec, off, &code_sec, NULL, FALSE);
ad8e1ba5 13836 }
ba8ca3e7
AM		 13837 if (code_sec == input_section)
13838 can_plt_call = TRUE;
13839 }
13840
13841 if (!can_plt_call)
13842 {
4805fc55
AM		 13843 if (stub_entry->stub_type == ppc_stub_plt_call
13844 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
13845 info->callbacks->einfo
13846 (_("%P: %H: call to `%T' lacks nop, can't restore toc; "
13847 "recompile with -fPIC\n"),
13848 input_bfd, input_section, rel->r_offset, sym_name);
13849 else
13850 info->callbacks->einfo
13851 (_("%P: %H: call to `%T' lacks nop, can't restore toc; "
13852 "(-mcmodel=small toc adjust stub)\n"),
13853 input_bfd, input_section, rel->r_offset, sym_name);
ba8ca3e7
AM		 13854
13855 bfd_set_error (bfd_error_bad_value);
13856 ret = FALSE;
721956f4
AM		 13857 }
13858
b25116a9 13859 if (can_plt_call
794e51c0
AM		 13860 && (stub_entry->stub_type == ppc_stub_plt_call
13861 || stub_entry->stub_type == ppc_stub_plt_call_r2save))
b25116a9
AM		 13862 unresolved_reloc = FALSE;
13863 }
13864
6abec6bc
AM		 13865 if ((stub_entry == NULL
13866 || stub_entry->stub_type == ppc_stub_long_branch
13867 || stub_entry->stub_type == ppc_stub_plt_branch)
8387904d
AM		 13868 && get_opd_info (sec) != NULL)
13869 {
13870 /* The branch destination is the value of the opd entry. */
4cc603a5
AM		 13871 bfd_vma off = (relocation + addend
13872 - sec->output_section->vma
13873 - sec->output_offset);
aef36ac1 13874 bfd_vma dest = opd_entry_value (sec, off, NULL, NULL, FALSE);
8387904d
AM		 13875 if (dest != (bfd_vma) -1)
13876 {
13877 relocation = dest;
13878 addend = 0;
bc30df16 13879 reloc_dest = DEST_OPD;
8387904d
AM		 13880 }
13881 }
13882
b25116a9
AM		 13883 /* If the branch is out of reach we ought to have a long
13884 branch stub. */
13885 from = (rel->r_offset
13886 + input_section->output_offset
13887 + input_section->output_section->vma);
13888
6911b7dc
AM		 13889 relocation += PPC64_LOCAL_ENTRY_OFFSET (fdh
13890 ? fdh->elf.other
13891 : sym->st_other);
13892
6abec6bc
AM		 13893 if (stub_entry != NULL
13894 && (stub_entry->stub_type == ppc_stub_long_branch
13895 || stub_entry->stub_type == ppc_stub_plt_branch)
13896 && (r_type == R_PPC64_ADDR14_BRTAKEN
13897 || r_type == R_PPC64_ADDR14_BRNTAKEN
13898 || (relocation + addend - from + max_br_offset
13899 < 2 * max_br_offset)))
13900 /* Don't use the stub if this branch is in range. */
13901 stub_entry = NULL;
b25116a9
AM		 13902
13903 if (stub_entry != NULL)
13904 {
13905 /* Munge up the value and addend so that we call the stub
13906 rather than the procedure directly. */
13907 relocation = (stub_entry->stub_offset
13908 + stub_entry->stub_sec->output_offset
13909 + stub_entry->stub_sec->output_section->vma);
13910 addend = 0;
bc30df16 13911 reloc_dest = DEST_STUB;
3b421ab3 13912
794e51c0
AM		 13913 if ((stub_entry->stub_type == ppc_stub_plt_call
13914 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
13915 && (ALWAYS_EMIT_R2SAVE
13916 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
3b421ab3
AM		 13917 && rel + 1 < relend
13918 && rel[1].r_offset == rel->r_offset + 4
13919 && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOCSAVE)
13920 relocation += 4;
b25116a9
AM		 13921 }
13922
13923 if (insn != 0)
13924 {
794e51c0 13925 if (is_isa_v2)
721956f4 13926 {
b25116a9
AM		 13927 /* Set 'a' bit. This is 0b00010 in BO field for branch
13928 on CR(BI) insns (BO == 001at or 011at), and 0b01000
13929 for branch on CTR insns (BO == 1a00t or 1a01t). */
13930 if ((insn & (0x14 << 21)) == (0x04 << 21))
13931 insn |= 0x02 << 21;
13932 else if ((insn & (0x14 << 21)) == (0x10 << 21))
13933 insn |= 0x08 << 21;
13934 else
13935 break;
13936 }
13937 else
13938 {
13939 /* Invert 'y' bit if not the default. */
4cc603a5 13940 if ((bfd_signed_vma) (relocation + addend - from) < 0)
b25116a9 13941 insn ^= 0x01 << 21;
721956f4 13942 }
b25116a9
AM		 13943
13944 bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
5bd4f169 13945 }
e86ce104 13946
06da1e8e
AM		 13947 /* NOP out calls to undefined weak functions.
13948 We can thus call a weak function without first
13949 checking whether the function is defined. */
b25116a9 13950 else if (h != NULL
039b3fef 13951 && h->elf.root.type == bfd_link_hash_undefweak
766bc656 13952 && h->elf.dynindx == -1
b25116a9
AM		 13953 && r_type == R_PPC64_REL24
13954 && relocation == 0
4cc603a5 13955 && addend == 0)
e86ce104 13956 {
06da1e8e
AM		 13957 bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
13958 continue;
e86ce104 13959 }
65f38f15
AM		 13960 break;
13961 }
5bd4f169 13962
65f38f15 13963 /* Set `addend'. */
411e1bfb 13964 tls_type = 0;
65f38f15
AM		 13965 switch (r_type)
13966 {
13967 default:
25f53a85 13968 info->callbacks->einfo
bc30df16 13969 (_("%P: %B: unknown relocation type %d for `%T'\n"),
d003868e 13970 input_bfd, (int) r_type, sym_name);
5bd4f169 13971
65f38f15 13972 bfd_set_error (bfd_error_bad_value);
b34976b6 13973 ret = FALSE;
65f38f15 13974 continue;
5bd4f169 13975
65f38f15 13976 case R_PPC64_NONE:
411e1bfb 13977 case R_PPC64_TLS:
727fc41e
AM		 13978 case R_PPC64_TLSGD:
13979 case R_PPC64_TLSLD:
3b421ab3 13980 case R_PPC64_TOCSAVE:
04c9666a
AM		 13981 case R_PPC64_GNU_VTINHERIT:
13982 case R_PPC64_GNU_VTENTRY:
65f38f15 13983 continue;
5bd4f169
AM		 13984
13985 /* GOT16 relocations. Like an ADDR16 using the symbol's
13986 address in the GOT as relocation value instead of the
411e1bfb 13987 symbol's value itself. Also, create a GOT entry for the
5bd4f169 13988 symbol and put the symbol value there. */
411e1bfb
AM		 13989 case R_PPC64_GOT_TLSGD16:
13990 case R_PPC64_GOT_TLSGD16_LO:
13991 case R_PPC64_GOT_TLSGD16_HI:
13992 case R_PPC64_GOT_TLSGD16_HA:
951fd09b 13993 tls_type = TLS_TLS | TLS_GD;
411e1bfb
AM		 13994 goto dogot;
13995
13996 case R_PPC64_GOT_TLSLD16:
13997 case R_PPC64_GOT_TLSLD16_LO:
13998 case R_PPC64_GOT_TLSLD16_HI:
13999 case R_PPC64_GOT_TLSLD16_HA:
951fd09b 14000 tls_type = TLS_TLS | TLS_LD;
411e1bfb
AM		 14001 goto dogot;
14002
14003 case R_PPC64_GOT_TPREL16_DS:
14004 case R_PPC64_GOT_TPREL16_LO_DS:
14005 case R_PPC64_GOT_TPREL16_HI:
14006 case R_PPC64_GOT_TPREL16_HA:
14007 tls_type = TLS_TLS | TLS_TPREL;
14008 goto dogot;
14009
14010 case R_PPC64_GOT_DTPREL16_DS:
14011 case R_PPC64_GOT_DTPREL16_LO_DS:
14012 case R_PPC64_GOT_DTPREL16_HI:
14013 case R_PPC64_GOT_DTPREL16_HA:
14014 tls_type = TLS_TLS | TLS_DTPREL;
14015 goto dogot;
14016
65f38f15
AM		 14017 case R_PPC64_GOT16:
14018 case R_PPC64_GOT16_LO:
14019 case R_PPC64_GOT16_HI:
14020 case R_PPC64_GOT16_HA:
14021 case R_PPC64_GOT16_DS:
14022 case R_PPC64_GOT16_LO_DS:
411e1bfb 14023 dogot:
5bd4f169
AM		 14024 {
14025 /* Relocation is to the entry for this symbol in the global
14026 offset table. */
e717da7e 14027 asection *got;
d881513a 14028 bfd_vma *offp;
5bd4f169 14029 bfd_vma off;
d881513a 14030 unsigned long indx = 0;
927be08e 14031 struct got_entry *ent;
65f38f15 14032
d881513a
AM		 14033 if (tls_type == (TLS_TLS | TLS_LD)
14034 && (h == NULL
f5385ebf 14035 || !h->elf.def_dynamic))
927be08e 14036 ent = ppc64_tlsld_got (input_bfd);
411e1bfb 14037 else
5bd4f169 14038 {
5bd4f169 14039
d881513a
AM		 14040 if (h != NULL)
14041 {
14042 bfd_boolean dyn = htab->elf.dynamic_sections_created;
039b3fef
AM		 14043 if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared,
14044 &h->elf)
d881513a 14045 || (info->shared
afe397ea 14046 && SYMBOL_REFERENCES_LOCAL (info, &h->elf)))
d881513a
AM		 14047 /* This is actually a static link, or it is a
14048 -Bsymbolic link and the symbol is defined
14049 locally, or the symbol was forced to be local
14050 because of a version file. */
14051 ;
14052 else
14053 {
14acf4dc 14054 BFD_ASSERT (h->elf.dynindx != -1);
039b3fef 14055 indx = h->elf.dynindx;
d881513a
AM		 14056 unresolved_reloc = FALSE;
14057 }
039b3fef 14058 ent = h->elf.got.glist;
d881513a 14059 }
411e1bfb 14060 else
5bd4f169 14061 {
d881513a
AM		 14062 if (local_got_ents == NULL)
14063 abort ();
14064 ent = local_got_ents[r_symndx];
5bd4f169 14065 }
d881513a
AM		 14066
14067 for (; ent != NULL; ent = ent->next)
31c76678 14068 if (ent->addend == orig_rel.r_addend
e717da7e 14069 && ent->owner == input_bfd
d881513a
AM		 14070 && ent->tls_type == tls_type)
14071 break;
5bd4f169 14072 }
411e1bfb 14073
927be08e
AM		 14074 if (ent == NULL)
14075 abort ();
14076 if (ent->is_indirect)
14077 ent = ent->got.ent;
14078 offp = &ent->got.offset;
14079 got = ppc64_elf_tdata (ent->owner)->got;
e717da7e
AM		 14080 if (got == NULL)
14081 abort ();
14082
411e1bfb
AM		 14083 /* The offset must always be a multiple of 8. We use the
14084 least significant bit to record whether we have already
14085 processed this entry. */
d881513a 14086 off = *offp;
411e1bfb
AM		 14087 if ((off & 1) != 0)
14088 off &= ~1;
5bd4f169
AM		 14089 else
14090 {
411e1bfb
AM		 14091 /* Generate relocs for the dynamic linker, except in
14092 the case of TLSLD where we'll use one entry per
14093 module. */
25f23106
AM		 14094 asection *relgot;
14095 bfd_boolean ifunc;
e717da7e 14096
d881513a 14097 *offp = off | 1;
25f23106
AM		 14098 relgot = NULL;
14099 ifunc = (h != NULL
14100 ? h->elf.type == STT_GNU_IFUNC
14101 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC);
19e08130 14102 if (ifunc)
33e44f2e 14103 relgot = htab->elf.irelplt;
19e08130
AM		 14104 else if ((info->shared || indx != 0)
14105 && (h == NULL
14106 || (tls_type == (TLS_TLS | TLS_LD)
14107 && !h->elf.def_dynamic)
14108 || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
14109 || h->elf.root.type != bfd_link_hash_undefweak))
14110 relgot = ppc64_elf_tdata (ent->owner)->relgot;
25f23106 14111 if (relgot != NULL)
5bd4f169 14112 {
e717da7e
AM		 14113 outrel.r_offset = (got->output_section->vma
14114 + got->output_offset
411e1bfb 14115 + off);
4cc603a5 14116 outrel.r_addend = addend;
d881513a 14117 if (tls_type & (TLS_LD | TLS_GD))
5bd4f169 14118 {
411e1bfb 14119 outrel.r_addend = 0;
e515b051 14120 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPMOD64);
d881513a
AM		 14121 if (tls_type == (TLS_TLS | TLS_GD))
14122 {
e717da7e
AM		 14123 loc = relgot->contents;
14124 loc += (relgot->reloc_count++
d881513a
AM		 14125 * sizeof (Elf64_External_Rela));
14126 bfd_elf64_swap_reloca_out (output_bfd,
14127 &outrel, loc);
e515b051 14128 outrel.r_offset += 8;
4cc603a5 14129 outrel.r_addend = addend;
d881513a
AM		 14130 outrel.r_info
14131 = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
d881513a 14132 }
411e1bfb 14133 }
951fd09b 14134 else if (tls_type == (TLS_TLS | TLS_DTPREL))
411e1bfb 14135 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
951fd09b 14136 else if (tls_type == (TLS_TLS | TLS_TPREL))
411e1bfb 14137 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_TPREL64);
25f23106
AM		 14138 else if (indx != 0)
14139 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_GLOB_DAT);
14140 else
81407a69 14141 {
25f23106
AM		 14142 if (ifunc)
14143 outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
14144 else
14145 outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
81407a69
AM		 14146
14147 /* Write the .got section contents for the sake
14148 of prelink. */
e717da7e 14149 loc = got->contents + off;
23fbd6fa
JJ		 14150 bfd_put_64 (output_bfd, outrel.r_addend + relocation,
14151 loc);
81407a69 14152 }
81407a69
AM		 14153
14154 if (indx == 0 && tls_type != (TLS_TLS | TLS_LD))
e515b051
AM		 14155 {
14156 outrel.r_addend += relocation;
14157 if (tls_type & (TLS_GD | TLS_DTPREL | TLS_TPREL))
989f9879
AM		 14158 {
14159 if (htab->elf.tls_sec == NULL)
14160 outrel.r_addend = 0;
14161 else
14162 outrel.r_addend -= htab->elf.tls_sec->vma;
14163 }
e515b051 14164 }
e717da7e
AM		 14165 loc = relgot->contents;
14166 loc += (relgot->reloc_count++
411e1bfb
AM		 14167 * sizeof (Elf64_External_Rela));
14168 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
14169 }
14170
ad8e1ba5 14171 /* Init the .got section contents here if we're not
81407a69 14172 emitting a reloc. */
d881513a 14173 else
411e1bfb 14174 {
4cc603a5 14175 relocation += addend;
7b609f53
AM		 14176 if (tls_type == (TLS_TLS | TLS_LD))
14177 relocation = 1;
14178 else if (tls_type != 0)
411e1bfb 14179 {
989f9879
AM		 14180 if (htab->elf.tls_sec == NULL)
14181 relocation = 0;
14182 else
14183 {
14184 relocation -= htab->elf.tls_sec->vma + DTP_OFFSET;
14185 if (tls_type == (TLS_TLS | TLS_TPREL))
14186 relocation += DTP_OFFSET - TP_OFFSET;
14187 }
5bd4f169 14188
7b609f53
AM		 14189 if (tls_type == (TLS_TLS | TLS_GD))
14190 {
14191 bfd_put_64 (output_bfd, relocation,
e717da7e 14192 got->contents + off + 8);
7b609f53
AM		 14193 relocation = 1;
14194 }
411e1bfb 14195 }
7b609f53 14196
411e1bfb 14197 bfd_put_64 (output_bfd, relocation,
e717da7e 14198 got->contents + off);
5bd4f169
AM		 14199 }
14200 }
14201
65f38f15
AM		 14202 if (off >= (bfd_vma) -2)
14203 abort ();
14204
bf102f86
AM		 14205 relocation = got->output_section->vma + got->output_offset + off;
14206 addend = -(TOCstart + htab->stub_group[input_section->id].toc_off);
5bd4f169 14207 }
65f38f15
AM		 14208 break;
14209
14210 case R_PPC64_PLT16_HA:
14211 case R_PPC64_PLT16_HI:
14212 case R_PPC64_PLT16_LO:
14213 case R_PPC64_PLT32:
14214 case R_PPC64_PLT64:
14215 /* Relocation is to the entry for this symbol in the
14216 procedure linkage table. */
14217
14218 /* Resolve a PLT reloc against a local symbol directly,
14219 without using the procedure linkage table. */
14220 if (h == NULL)
14221 break;
14222
411e1bfb
AM		 14223 /* It's possible that we didn't make a PLT entry for this
14224 symbol. This happens when statically linking PIC code,
14225 or when using -Bsymbolic. Go find a match if there is a
14226 PLT entry. */
33e44f2e 14227 if (htab->elf.splt != NULL)
65f38f15 14228 {
411e1bfb 14229 struct plt_entry *ent;
039b3fef 14230 for (ent = h->elf.plt.plist; ent != NULL; ent = ent->next)
a345bc8d
AM		 14231 if (ent->plt.offset != (bfd_vma) -1
14232 && ent->addend == orig_rel.r_addend)
411e1bfb 14233 {
33e44f2e
AM		 14234 relocation = (htab->elf.splt->output_section->vma
14235 + htab->elf.splt->output_offset
411e1bfb
AM		 14236 + ent->plt.offset);
14237 unresolved_reloc = FALSE;
a345bc8d 14238 break;
411e1bfb 14239 }
65f38f15 14240 }
65f38f15 14241 break;
5bd4f169 14242
0b13192e
AM		 14243 case R_PPC64_TOC:
14244 /* Relocation value is TOC base. */
14245 relocation = TOCstart;
cf35638d 14246 if (r_symndx == STN_UNDEF)
0b13192e 14247 relocation += htab->stub_group[input_section->id].toc_off;
8517fae7
AM		 14248 else if (unresolved_reloc)
14249 ;
14250 else if (sec != NULL && sec->id <= htab->top_id)
0b13192e
AM		 14251 relocation += htab->stub_group[sec->id].toc_off;
14252 else
14253 unresolved_reloc = TRUE;
ab96bf03 14254 goto dodyn;
0b13192e 14255
5bd4f169
AM		 14256 /* TOC16 relocs. We want the offset relative to the TOC base,
14257 which is the address of the start of the TOC plus 0x8000.
14258 The TOC consists of sections .got, .toc, .tocbss, and .plt,
14259 in this order. */
65f38f15
AM		 14260 case R_PPC64_TOC16:
14261 case R_PPC64_TOC16_LO:
14262 case R_PPC64_TOC16_HI:
14263 case R_PPC64_TOC16_DS:
14264 case R_PPC64_TOC16_LO_DS:
14265 case R_PPC64_TOC16_HA:
ad8e1ba5 14266 addend -= TOCstart + htab->stub_group[input_section->id].toc_off;
5bd4f169
AM		 14267 break;
14268
14269 /* Relocate against the beginning of the section. */
65f38f15
AM		 14270 case R_PPC64_SECTOFF:
14271 case R_PPC64_SECTOFF_LO:
14272 case R_PPC64_SECTOFF_HI:
14273 case R_PPC64_SECTOFF_DS:
14274 case R_PPC64_SECTOFF_LO_DS:
14275 case R_PPC64_SECTOFF_HA:
4ce794b7 14276 if (sec != NULL)
65f38f15 14277 addend -= sec->output_section->vma;
5bd4f169
AM		 14278 break;
14279
25f23106
AM		 14280 case R_PPC64_REL16:
14281 case R_PPC64_REL16_LO:
14282 case R_PPC64_REL16_HI:
14283 case R_PPC64_REL16_HA:
14284 break;
14285
721956f4
AM		 14286 case R_PPC64_REL14:
14287 case R_PPC64_REL14_BRNTAKEN:
14288 case R_PPC64_REL14_BRTAKEN:
5d1634d7
AM		 14289 case R_PPC64_REL24:
14290 break;
14291
411e1bfb
AM		 14292 case R_PPC64_TPREL16:
14293 case R_PPC64_TPREL16_LO:
14294 case R_PPC64_TPREL16_HI:
14295 case R_PPC64_TPREL16_HA:
14296 case R_PPC64_TPREL16_DS:
14297 case R_PPC64_TPREL16_LO_DS:
f9c6b907
AM		 14298 case R_PPC64_TPREL16_HIGH:
14299 case R_PPC64_TPREL16_HIGHA:
411e1bfb
AM		 14300 case R_PPC64_TPREL16_HIGHER:
14301 case R_PPC64_TPREL16_HIGHERA:
14302 case R_PPC64_TPREL16_HIGHEST:
14303 case R_PPC64_TPREL16_HIGHESTA:
766bc656
AM		 14304 if (h != NULL
14305 && h->elf.root.type == bfd_link_hash_undefweak
14306 && h->elf.dynindx == -1)
14307 {
14308 /* Make this relocation against an undefined weak symbol
14309 resolve to zero. This is really just a tweak, since
14310 code using weak externs ought to check that they are
14311 defined before using them. */
14312 bfd_byte *p = contents + rel->r_offset - d_offset;
14313
14314 insn = bfd_get_32 (output_bfd, p);
14315 insn = _bfd_elf_ppc_at_tprel_transform (insn, 13);
14316 if (insn != 0)
14317 bfd_put_32 (output_bfd, insn, p);
14318 break;
14319 }
989f9879
AM		 14320 if (htab->elf.tls_sec != NULL)
14321 addend -= htab->elf.tls_sec->vma + TP_OFFSET;
411e1bfb
AM		 14322 if (info->shared)
14323 /* The TPREL16 relocs shouldn't really be used in shared
14324 libs as they will result in DT_TEXTREL being set, but
14325 support them anyway. */
14326 goto dodyn;
14327 break;
14328
14329 case R_PPC64_DTPREL16:
14330 case R_PPC64_DTPREL16_LO:
14331 case R_PPC64_DTPREL16_HI:
14332 case R_PPC64_DTPREL16_HA:
14333 case R_PPC64_DTPREL16_DS:
14334 case R_PPC64_DTPREL16_LO_DS:
f9c6b907
AM		 14335 case R_PPC64_DTPREL16_HIGH:
14336 case R_PPC64_DTPREL16_HIGHA:
411e1bfb
AM		 14337 case R_PPC64_DTPREL16_HIGHER:
14338 case R_PPC64_DTPREL16_HIGHERA:
14339 case R_PPC64_DTPREL16_HIGHEST:
14340 case R_PPC64_DTPREL16_HIGHESTA:
989f9879
AM		 14341 if (htab->elf.tls_sec != NULL)
14342 addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
411e1bfb
AM		 14343 break;
14344
45965137
AM		 14345 case R_PPC64_ADDR64_LOCAL:
14346 addend += PPC64_LOCAL_ENTRY_OFFSET (h != NULL
14347 ? h->elf.other
14348 : sym->st_other);
14349 break;
14350
e515b051
AM		 14351 case R_PPC64_DTPMOD64:
14352 relocation = 1;
14353 addend = 0;
14354 goto dodyn;
14355
411e1bfb 14356 case R_PPC64_TPREL64:
989f9879
AM		 14357 if (htab->elf.tls_sec != NULL)
14358 addend -= htab->elf.tls_sec->vma + TP_OFFSET;
411e1bfb
AM		 14359 goto dodyn;
14360
14361 case R_PPC64_DTPREL64:
989f9879
AM		 14362 if (htab->elf.tls_sec != NULL)
14363 addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
411e1bfb
AM		 14364 /* Fall thru */
14365
65f38f15
AM		 14366 /* Relocations that may need to be propagated if this is a
14367 dynamic object. */
04c9666a 14368 case R_PPC64_REL30:
65f38f15
AM		 14369 case R_PPC64_REL32:
14370 case R_PPC64_REL64:
14371 case R_PPC64_ADDR14:
14372 case R_PPC64_ADDR14_BRNTAKEN:
14373 case R_PPC64_ADDR14_BRTAKEN:
14374 case R_PPC64_ADDR16:
14375 case R_PPC64_ADDR16_DS:
14376 case R_PPC64_ADDR16_HA:
14377 case R_PPC64_ADDR16_HI:
f9c6b907
AM		 14378 case R_PPC64_ADDR16_HIGH:
14379 case R_PPC64_ADDR16_HIGHA:
65f38f15
AM		 14380 case R_PPC64_ADDR16_HIGHER:
14381 case R_PPC64_ADDR16_HIGHERA:
14382 case R_PPC64_ADDR16_HIGHEST:
14383 case R_PPC64_ADDR16_HIGHESTA:
14384 case R_PPC64_ADDR16_LO:
14385 case R_PPC64_ADDR16_LO_DS:
14386 case R_PPC64_ADDR24:
65f38f15
AM		 14387 case R_PPC64_ADDR32:
14388 case R_PPC64_ADDR64:
14389 case R_PPC64_UADDR16:
14390 case R_PPC64_UADDR32:
14391 case R_PPC64_UADDR64:
411e1bfb 14392 dodyn:
5d1634d7 14393 if ((input_section->flags & SEC_ALLOC) == 0)
ec338859
AM		 14394 break;
14395
41bd81ab
AM		 14396 if (NO_OPD_RELOCS && is_opd)
14397 break;
14398
65f38f15 14399 if ((info->shared
4e795f50 14400 && (h == NULL
039b3fef
AM		 14401 || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
14402 || h->elf.root.type != bfd_link_hash_undefweak)
1d483afe 14403 && (must_be_dyn_reloc (info, r_type)
039b3fef 14404 || !SYMBOL_CALLS_LOCAL (info, &h->elf)))
f4656909
AM		 14405 || (ELIMINATE_COPY_RELOCS
14406 && !info->shared
65f38f15 14407 && h != NULL
039b3fef 14408 && h->elf.dynindx != -1
f5385ebf 14409 && !h->elf.non_got_ref
25f23106
AM		 14410 && !h->elf.def_regular)
14411 || (!info->shared
14412 && (h != NULL
14413 ? h->elf.type == STT_GNU_IFUNC
14414 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)))
65f38f15 14415 {
b34976b6 14416 bfd_boolean skip, relocate;
65f38f15 14417 asection *sreloc;
1cf1f670 14418 bfd_vma out_off;
65f38f15
AM		 14419
14420 /* When generating a dynamic object, these relocations
14421 are copied into the output file to be resolved at run
14422 time. */
14423
b34976b6
AM		 14424 skip = FALSE;
14425 relocate = FALSE;
65f38f15 14426
1cf1f670
AM		 14427 out_off = _bfd_elf_section_offset (output_bfd, info,
14428 input_section, rel->r_offset);
14429 if (out_off == (bfd_vma) -1)
b34976b6 14430 skip = TRUE;
1cf1f670 14431 else if (out_off == (bfd_vma) -2)
b34976b6 14432 skip = TRUE, relocate = TRUE;
1cf1f670
AM		 14433 out_off += (input_section->output_section->vma
14434 + input_section->output_offset);
14435 outrel.r_offset = out_off;
411e1bfb 14436 outrel.r_addend = rel->r_addend;
65f38f15 14437
1cf1f670
AM		 14438 /* Optimize unaligned reloc use. */
14439 if ((r_type == R_PPC64_ADDR64 && (out_off & 7) != 0)
14440 || (r_type == R_PPC64_UADDR64 && (out_off & 7) == 0))
14441 r_type ^= R_PPC64_ADDR64 ^ R_PPC64_UADDR64;
14442 else if ((r_type == R_PPC64_ADDR32 && (out_off & 3) != 0)
14443 || (r_type == R_PPC64_UADDR32 && (out_off & 3) == 0))
14444 r_type ^= R_PPC64_ADDR32 ^ R_PPC64_UADDR32;
14445 else if ((r_type == R_PPC64_ADDR16 && (out_off & 1) != 0)
14446 || (r_type == R_PPC64_UADDR16 && (out_off & 1) == 0))
14447 r_type ^= R_PPC64_ADDR16 ^ R_PPC64_UADDR16;
14448
65f38f15 14449 if (skip)
0bb2d96a 14450 memset (&outrel, 0, sizeof outrel);
afe397ea 14451 else if (!SYMBOL_REFERENCES_LOCAL (info, &h->elf)
0b13192e
AM		 14452 && !is_opd
14453 && r_type != R_PPC64_TOC)
14acf4dc
MR		 14454 {
14455 BFD_ASSERT (h->elf.dynindx != -1);
14456 outrel.r_info = ELF64_R_INFO (h->elf.dynindx, r_type);
14457 }
65f38f15
AM		 14458 else
14459 {
41bd81ab
AM		 14460 /* This symbol is local, or marked to become local,
14461 or this is an opd section reloc which must point
14462 at a local function. */
65f38f15 14463 outrel.r_addend += relocation;
e86ce104 14464 if (r_type == R_PPC64_ADDR64 || r_type == R_PPC64_TOC)
65f38f15 14465 {
3fad3c7c 14466 if (is_opd && h != NULL)
afbe61cf
AM		 14467 {
14468 /* Lie about opd entries. This case occurs
14469 when building shared libraries and we
14470 reference a function in another shared
3fad3c7c
AM		 14471 lib. The same thing happens for a weak
14472 definition in an application that's
14473 overridden by a strong definition in a
14474 shared lib. (I believe this is a generic
14475 bug in binutils handling of weak syms.)
14476 In these cases we won't use the opd
1e2f5b6e 14477 entry in this lib. */
b34976b6 14478 unresolved_reloc = FALSE;
afbe61cf 14479 }
25f23106
AM		 14480 if (!is_opd
14481 && r_type == R_PPC64_ADDR64
14482 && (h != NULL
14483 ? h->elf.type == STT_GNU_IFUNC
14484 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
14485 outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
14486 else
14487 {
14488 outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
81407a69 14489
25f23106
AM		 14490 /* We need to relocate .opd contents for ld.so.
14491 Prelink also wants simple and consistent rules
14492 for relocs. This make all RELATIVE relocs have
14493 *r_offset equal to r_addend. */
14494 relocate = TRUE;
14495 }
65f38f15
AM		 14496 }
14497 else
14498 {
14499 long indx = 0;
14500
25f23106
AM		 14501 if (h != NULL
14502 ? h->elf.type == STT_GNU_IFUNC
14503 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
14504 {
25f53a85 14505 info->callbacks->einfo
bc30df16
AM		 14506 (_("%P: %H: %s for indirect "
14507 "function `%T' unsupported\n"),
25f53a85 14508 input_bfd, input_section, rel->r_offset,
25f23106
AM		 14509 ppc64_elf_howto_table[r_type]->name,
14510 sym_name);
14511 ret = FALSE;
14512 }
cf35638d 14513 else if (r_symndx == STN_UNDEF || bfd_is_abs_section (sec))
65f38f15
AM		 14514 ;
14515 else if (sec == NULL || sec->owner == NULL)
14516 {
14517 bfd_set_error (bfd_error_bad_value);
b34976b6 14518 return FALSE;
65f38f15
AM		 14519 }
14520 else
14521 {
14522 asection *osec;
14523
14524 osec = sec->output_section;
14525 indx = elf_section_data (osec)->dynindx;
14526
74541ad4
AM		 14527 if (indx == 0)
14528 {
14529 if ((osec->flags & SEC_READONLY) == 0
14530 && htab->elf.data_index_section != NULL)
14531 osec = htab->elf.data_index_section;
14532 else
14533 osec = htab->elf.text_index_section;
14534 indx = elf_section_data (osec)->dynindx;
14535 }
14536 BFD_ASSERT (indx != 0);
14537
65f38f15
AM		 14538 /* We are turning this relocation into one
14539 against a section symbol, so subtract out
14540 the output section's address but not the
14541 offset of the input section in the output
14542 section. */
14543 outrel.r_addend -= osec->vma;
14544 }
14545
14546 outrel.r_info = ELF64_R_INFO (indx, r_type);
14547 }
14548 }
14549
14550 sreloc = elf_section_data (input_section)->sreloc;
19e08130
AM		 14551 if (h != NULL
14552 ? h->elf.type == STT_GNU_IFUNC
14553 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
33e44f2e 14554 sreloc = htab->elf.irelplt;
65f38f15
AM		 14555 if (sreloc == NULL)
14556 abort ();
14557
dfbb6ac9
AM		 14558 if (sreloc->reloc_count * sizeof (Elf64_External_Rela)
14559 >= sreloc->size)
14560 abort ();
947216bf
AM		 14561 loc = sreloc->contents;
14562 loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
65f38f15
AM		 14563 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
14564
14565 /* If this reloc is against an external symbol, it will
14566 be computed at runtime, so there's no need to do
81407a69
AM		 14567 anything now. However, for the sake of prelink ensure
14568 that the section contents are a known value. */
65f38f15 14569 if (! relocate)
81407a69
AM		 14570 {
14571 unresolved_reloc = FALSE;
14572 /* The value chosen here is quite arbitrary as ld.so
14573 ignores section contents except for the special
14574 case of .opd where the contents might be accessed
14575 before relocation. Choose zero, as that won't
14576 cause reloc overflow. */
14577 relocation = 0;
14578 addend = 0;
14579 /* Use *r_offset == r_addend for R_PPC64_ADDR64 relocs
14580 to improve backward compatibility with older
14581 versions of ld. */
14582 if (r_type == R_PPC64_ADDR64)
14583 addend = outrel.r_addend;
14584 /* Adjust pc_relative relocs to have zero in *r_offset. */
4ce794b7 14585 else if (ppc64_elf_howto_table[r_type]->pc_relative)
000732f7
AM		 14586 addend = (input_section->output_section->vma
14587 + input_section->output_offset
14588 + rel->r_offset);
81407a69 14589 }
65f38f15 14590 }
5bd4f169
AM		 14591 break;
14592
65f38f15
AM		 14593 case R_PPC64_COPY:
14594 case R_PPC64_GLOB_DAT:
14595 case R_PPC64_JMP_SLOT:
25f23106 14596 case R_PPC64_JMP_IREL:
65f38f15
AM		 14597 case R_PPC64_RELATIVE:
14598 /* We shouldn't ever see these dynamic relocs in relocatable
14599 files. */
ae9a127f 14600 /* Fall through. */
65f38f15
AM		 14601
14602 case R_PPC64_PLTGOT16:
14603 case R_PPC64_PLTGOT16_DS:
14604 case R_PPC64_PLTGOT16_HA:
14605 case R_PPC64_PLTGOT16_HI:
14606 case R_PPC64_PLTGOT16_LO:
14607 case R_PPC64_PLTGOT16_LO_DS:
14608 case R_PPC64_PLTREL32:
14609 case R_PPC64_PLTREL64:
14610 /* These ones haven't been implemented yet. */
14611
25f53a85 14612 info->callbacks->einfo
bc30df16 14613 (_("%P: %B: %s is not supported for `%T'\n"),
d003868e 14614 input_bfd,
4ce794b7 14615 ppc64_elf_howto_table[r_type]->name, sym_name);
5bd4f169
AM		 14616
14617 bfd_set_error (bfd_error_invalid_operation);
b34976b6 14618 ret = FALSE;
5bd4f169 14619 continue;
65f38f15 14620 }
5bd4f169 14621
67f0cbdb
AM		 14622 /* Multi-instruction sequences that access the TOC can be
14623 optimized, eg. addis ra,r2,0; addi rb,ra,x;
14624 to nop; addi rb,r2,x; */
14625 switch (r_type)
14626 {
14627 default:
14628 break;
14629
14630 case R_PPC64_GOT_TLSLD16_HI:
14631 case R_PPC64_GOT_TLSGD16_HI:
14632 case R_PPC64_GOT_TPREL16_HI:
14633 case R_PPC64_GOT_DTPREL16_HI:
14634 case R_PPC64_GOT16_HI:
14635 case R_PPC64_TOC16_HI:
14636 /* These relocs would only be useful if building up an
14637 offset to later add to r2, perhaps in an indexed
14638 addressing mode instruction. Don't try to optimize.
14639 Unfortunately, the possibility of someone building up an
14640 offset like this or even with the HA relocs, means that
14641 we need to check the high insn when optimizing the low
14642 insn. */
14643 break;
14644
14645 case R_PPC64_GOT_TLSLD16_HA:
14646 case R_PPC64_GOT_TLSGD16_HA:
14647 case R_PPC64_GOT_TPREL16_HA:
14648 case R_PPC64_GOT_DTPREL16_HA:
14649 case R_PPC64_GOT16_HA:
14650 case R_PPC64_TOC16_HA:
98528052 14651 if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
560c8763 14652 && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
98528052
AM		 14653 {
14654 bfd_byte *p = contents + (rel->r_offset & ~3);
14655 bfd_put_32 (input_bfd, NOP, p);
14656 }
67f0cbdb
AM		 14657 break;
14658
14659 case R_PPC64_GOT_TLSLD16_LO:
14660 case R_PPC64_GOT_TLSGD16_LO:
14661 case R_PPC64_GOT_TPREL16_LO_DS:
14662 case R_PPC64_GOT_DTPREL16_LO_DS:
14663 case R_PPC64_GOT16_LO:
14664 case R_PPC64_GOT16_LO_DS:
14665 case R_PPC64_TOC16_LO:
14666 case R_PPC64_TOC16_LO_DS:
98528052 14667 if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
560c8763 14668 && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
67f0cbdb
AM		 14669 {
14670 bfd_byte *p = contents + (rel->r_offset & ~3);
14671 insn = bfd_get_32 (input_bfd, p);
560c8763
AM		 14672 if ((insn & (0x3f << 26)) == 12u << 26 /* addic */)
14673 {
14674 /* Transform addic to addi when we change reg. */
14675 insn &= ~((0x3f << 26) | (0x1f << 16));
14676 insn |= (14u << 26) | (2 << 16);
14677 }
14678 else
67f0cbdb 14679 {
98528052
AM		 14680 insn &= ~(0x1f << 16);
14681 insn |= 2 << 16;
67f0cbdb 14682 }
560c8763 14683 bfd_put_32 (input_bfd, insn, p);
67f0cbdb
AM		 14684 }
14685 break;
14686 }
14687
65f38f15 14688 /* Do any further special processing. */
b80eed39 14689 howto = ppc64_elf_howto_table[(int) r_type];
65f38f15
AM		 14690 switch (r_type)
14691 {
14692 default:
14693 break;
14694
25f23106 14695 case R_PPC64_REL16_HA:
f9c6b907
AM		 14696 case R_PPC64_ADDR16_HA:
14697 case R_PPC64_ADDR16_HIGHA:
65f38f15
AM		 14698 case R_PPC64_ADDR16_HIGHERA:
14699 case R_PPC64_ADDR16_HIGHESTA:
65f38f15
AM		 14700 case R_PPC64_TOC16_HA:
14701 case R_PPC64_SECTOFF_HA:
411e1bfb 14702 case R_PPC64_TPREL16_HA:
f9c6b907 14703 case R_PPC64_TPREL16_HIGHA:
411e1bfb 14704 case R_PPC64_TPREL16_HIGHERA:
411e1bfb 14705 case R_PPC64_TPREL16_HIGHESTA:
f9c6b907
AM		 14706 case R_PPC64_DTPREL16_HA:
14707 case R_PPC64_DTPREL16_HIGHA:
411e1bfb 14708 case R_PPC64_DTPREL16_HIGHERA:
411e1bfb 14709 case R_PPC64_DTPREL16_HIGHESTA:
65f38f15
AM		 14710 /* It's just possible that this symbol is a weak symbol
14711 that's not actually defined anywhere. In that case,
14712 'sec' would be NULL, and we should leave the symbol
14713 alone (it will be set to zero elsewhere in the link). */
5c5f6e17
AM		 14714 if (sec == NULL)
14715 break;
14716 /* Fall thru */
14717
14718 case R_PPC64_GOT16_HA:
14719 case R_PPC64_PLTGOT16_HA:
14720 case R_PPC64_PLT16_HA:
14721 case R_PPC64_GOT_TLSGD16_HA:
14722 case R_PPC64_GOT_TLSLD16_HA:
14723 case R_PPC64_GOT_TPREL16_HA:
14724 case R_PPC64_GOT_DTPREL16_HA:
14725 /* Add 0x10000 if sign bit in 0:15 is set.
14726 Bits 0:15 are not used. */
14727 addend += 0x8000;
65f38f15
AM		 14728 break;
14729
14730 case R_PPC64_ADDR16_DS:
14731 case R_PPC64_ADDR16_LO_DS:
14732 case R_PPC64_GOT16_DS:
14733 case R_PPC64_GOT16_LO_DS:
14734 case R_PPC64_PLT16_LO_DS:
14735 case R_PPC64_SECTOFF_DS:
14736 case R_PPC64_SECTOFF_LO_DS:
14737 case R_PPC64_TOC16_DS:
14738 case R_PPC64_TOC16_LO_DS:
14739 case R_PPC64_PLTGOT16_DS:
14740 case R_PPC64_PLTGOT16_LO_DS:
411e1bfb
AM		 14741 case R_PPC64_GOT_TPREL16_DS:
14742 case R_PPC64_GOT_TPREL16_LO_DS:
14743 case R_PPC64_GOT_DTPREL16_DS:
14744 case R_PPC64_GOT_DTPREL16_LO_DS:
14745 case R_PPC64_TPREL16_DS:
14746 case R_PPC64_TPREL16_LO_DS:
14747 case R_PPC64_DTPREL16_DS:
14748 case R_PPC64_DTPREL16_LO_DS:
adadcc0c
AM		 14749 insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
14750 mask = 3;
14751 /* If this reloc is against an lq insn, then the value must be
14752 a multiple of 16. This is somewhat of a hack, but the
14753 "correct" way to do this by defining _DQ forms of all the
14754 _DS relocs bloats all reloc switches in this file. It
14755 doesn't seem to make much sense to use any of these relocs
14756 in data, so testing the insn should be safe. */
494dac0c 14757 if ((insn & (0x3f << 26)) == (56u << 26))
adadcc0c
AM		 14758 mask = 15;
14759 if (((relocation + addend) & mask) != 0)
65f38f15 14760 {
25f53a85 14761 info->callbacks->einfo
8de848d8 14762 (_("%P: %H: error: %s not a multiple of %u\n"),
25f53a85 14763 input_bfd, input_section, rel->r_offset,
b80eed39 14764 howto->name,
adadcc0c 14765 mask + 1);
65f38f15 14766 bfd_set_error (bfd_error_bad_value);
b34976b6 14767 ret = FALSE;
65f38f15
AM		 14768 continue;
14769 }
14770 break;
5bd4f169
AM		 14771 }
14772
239e1f3a
AM		 14773 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
14774 because such sections are not SEC_ALLOC and thus ld.so will
14775 not process them. */
65f38f15 14776 if (unresolved_reloc
239e1f3a 14777 && !((input_section->flags & SEC_DEBUGGING) != 0
1d5316ab
AM		 14778 && h->elf.def_dynamic)
14779 && _bfd_elf_section_offset (output_bfd, info, input_section,
14780 rel->r_offset) != (bfd_vma) -1)
9c07fe7c 14781 {
25f53a85 14782 info->callbacks->einfo
bc30df16 14783 (_("%P: %H: unresolvable %s against `%T'\n"),
25f53a85 14784 input_bfd, input_section, rel->r_offset,
b80eed39 14785 howto->name,
039b3fef 14786 h->elf.root.root.string);
b34976b6 14787 ret = FALSE;
9c07fe7c 14788 }
5bd4f169 14789
b80eed39
AM		 14790 /* 16-bit fields in insns mostly have signed values, but a
14791 few insns have 16-bit unsigned values. Really, we should
14792 have different reloc types. */
14793 if (howto->complain_on_overflow != complain_overflow_dont
14794 && howto->dst_mask == 0xffff
14795 && (input_section->flags & SEC_CODE) != 0)
14796 {
14797 enum complain_overflow complain = complain_overflow_signed;
14798
14799 insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
a47622ac
AM		 14800 if ((insn & (0x3f << 26)) == 10u << 26 /* cmpli */)
14801 complain = complain_overflow_bitfield;
14802 else if (howto->rightshift == 0
14803 ? ((insn & (0x3f << 26)) == 28u << 26 /* andi */
14804 || (insn & (0x3f << 26)) == 24u << 26 /* ori */
14805 || (insn & (0x3f << 26)) == 26u << 26 /* xori */)
14806 : ((insn & (0x3f << 26)) == 29u << 26 /* andis */
14807 || (insn & (0x3f << 26)) == 25u << 26 /* oris */
14808 || (insn & (0x3f << 26)) == 27u << 26 /* xoris */))
b80eed39
AM		 14809 complain = complain_overflow_unsigned;
14810 if (howto->complain_on_overflow != complain)
14811 {
14812 alt_howto = *howto;
14813 alt_howto.complain_on_overflow = complain;
14814 howto = &alt_howto;
14815 }
14816 }
14817
14818 r = _bfd_final_link_relocate (howto, input_bfd, input_section, contents,
14819 rel->r_offset, relocation, addend);
5bd4f169 14820
ef60b7ff 14821 if (r != bfd_reloc_ok)
5bd4f169 14822 {
bc30df16 14823 char *more_info = NULL;
b80eed39 14824 const char *reloc_name = howto->name;
bc30df16
AM		 14825
14826 if (reloc_dest != DEST_NORMAL)
14827 {
14828 more_info = bfd_malloc (strlen (reloc_name) + 8);
14829 if (more_info != NULL)
14830 {
14831 strcpy (more_info, reloc_name);
14832 strcat (more_info, (reloc_dest == DEST_OPD
14833 ? " (OPD)" : " (stub)"));
14834 reloc_name = more_info;
14835 }
14836 }
14837
cd27b276 14838 if (r == bfd_reloc_overflow)
5bd4f169 14839 {
cd27b276
AM		 14840 if (warned)
14841 continue;
14842 if (h != NULL
039b3fef 14843 && h->elf.root.type == bfd_link_hash_undefweak
b80eed39 14844 && howto->pc_relative)
5bd4f169
AM		 14845 {
14846 /* Assume this is a call protected by other code that
14847 detects the symbol is undefined. If this is the case,
14848 we can safely ignore the overflow. If not, the
14849 program is hosed anyway, and a little warning isn't
14850 going to help. */
14851
14852 continue;
14853 }
14854
ef60b7ff 14855 if (!((*info->callbacks->reloc_overflow)
bc30df16
AM		 14856 (info, &h->elf.root, sym_name,
14857 reloc_name, orig_rel.r_addend,
14858 input_bfd, input_section, rel->r_offset)))
b34976b6 14859 return FALSE;
ef60b7ff
AM		 14860 }
14861 else
14862 {
25f53a85 14863 info->callbacks->einfo
bc30df16 14864 (_("%P: %H: %s against `%T': error %d\n"),
25f53a85 14865 input_bfd, input_section, rel->r_offset,
bc30df16 14866 reloc_name, sym_name, (int) r);
b34976b6 14867 ret = FALSE;
ef60b7ff 14868 }
bc30df16
AM		 14869 if (more_info != NULL)
14870 free (more_info);
5bd4f169 14871 }
5bd4f169
AM		 14872 }
14873
645ea6a9
AM		 14874 /* If we're emitting relocations, then shortly after this function
14875 returns, reloc offsets and addends for this section will be
14876 adjusted. Worse, reloc symbol indices will be for the output
8860955f
AM		 14877 file rather than the input. Save a copy of the relocs for
14878 opd_entry_value. */
4cc603a5 14879 if (is_opd && (info->emitrelocations || info->relocatable))
8860955f
AM		 14880 {
14881 bfd_size_type amt;
14882 amt = input_section->reloc_count * sizeof (Elf_Internal_Rela);
14883 rel = bfd_alloc (input_bfd, amt);
729eabd5
AM		 14884 BFD_ASSERT (ppc64_elf_tdata (input_bfd)->opd.relocs == NULL);
14885 ppc64_elf_tdata (input_bfd)->opd.relocs = rel;
8860955f
AM		 14886 if (rel == NULL)
14887 return FALSE;
14888 memcpy (rel, relocs, amt);
14889 }
5bd4f169
AM		 14890 return ret;
14891}
14892
754021d0
AM		 14893/* Adjust the value of any local symbols in opd sections. */
14894
6e0b88f1 14895static int
754021d0
AM		 14896ppc64_elf_output_symbol_hook (struct bfd_link_info *info,
14897 const char *name ATTRIBUTE_UNUSED,
14898 Elf_Internal_Sym *elfsym,
14899 asection *input_sec,
14900 struct elf_link_hash_entry *h)
14901{
74f0fb50
AM		 14902 struct _opd_sec_data *opd;
14903 long adjust;
754021d0
AM		 14904 bfd_vma value;
14905
4025353c 14906 if (h != NULL)
6e0b88f1 14907 return 1;
4025353c 14908
74f0fb50
AM		 14909 opd = get_opd_info (input_sec);
14910 if (opd == NULL || opd->adjust == NULL)
6e0b88f1 14911 return 1;
754021d0
AM		 14912
14913 value = elfsym->st_value - input_sec->output_offset;
14914 if (!info->relocatable)
14915 value -= input_sec->output_section->vma;
14916
51aecdc5 14917 adjust = opd->adjust[OPD_NDX (value)];
4025353c 14918 if (adjust == -1)
6e0b88f1
AM		 14919 return 2;
14920
14921 elfsym->st_value += adjust;
14922 return 1;
754021d0
AM		 14923}
14924
5bd4f169
AM		 14925/* Finish up dynamic symbol handling. We set the contents of various
14926 dynamic sections here. */
14927
b34976b6 14928static bfd_boolean
4ce794b7
AM		 14929ppc64_elf_finish_dynamic_symbol (bfd *output_bfd,
14930 struct bfd_link_info *info,
14931 struct elf_link_hash_entry *h,
ab6dce23 14932 Elf_Internal_Sym *sym ATTRIBUTE_UNUSED)
5bd4f169 14933{
65f38f15 14934 struct ppc_link_hash_table *htab;
8387904d
AM		 14935 struct plt_entry *ent;
14936 Elf_Internal_Rela rela;
14937 bfd_byte *loc;
5bd4f169 14938
65f38f15 14939 htab = ppc_hash_table (info);
4dfe6ac6
NC		 14940 if (htab == NULL)
14941 return FALSE;
5bd4f169 14942
8387904d
AM		 14943 for (ent = h->plt.plist; ent != NULL; ent = ent->next)
14944 if (ent->plt.offset != (bfd_vma) -1)
14945 {
14946 /* This symbol has an entry in the procedure linkage
14947 table. Set it up. */
e054468f
AM		 14948 if (!htab->elf.dynamic_sections_created
14949 || h->dynindx == -1)
14950 {
14951 BFD_ASSERT (h->type == STT_GNU_IFUNC
14952 && h->def_regular
14953 && (h->root.type == bfd_link_hash_defined
14954 || h->root.type == bfd_link_hash_defweak));
33e44f2e
AM		 14955 rela.r_offset = (htab->elf.iplt->output_section->vma
14956 + htab->elf.iplt->output_offset
25f23106 14957 + ent->plt.offset);
ee67d69a
AM		 14958 if (htab->opd_abi)
14959 rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
14960 else
14961 rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
e054468f
AM		 14962 rela.r_addend = (h->root.u.def.value
14963 + h->root.u.def.section->output_offset
14964 + h->root.u.def.section->output_section->vma
14965 + ent->addend);
33e44f2e
AM		 14966 loc = (htab->elf.irelplt->contents
14967 + (htab->elf.irelplt->reloc_count++
25f23106 14968 * sizeof (Elf64_External_Rela)));
e054468f
AM		 14969 }
14970 else
14971 {
33e44f2e
AM		 14972 rela.r_offset = (htab->elf.splt->output_section->vma
14973 + htab->elf.splt->output_offset
25f23106 14974 + ent->plt.offset);
e054468f
AM		 14975 rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_JMP_SLOT);
14976 rela.r_addend = ent->addend;
33e44f2e 14977 loc = (htab->elf.srelplt->contents
b9e5796b
AM		 14978 + ((ent->plt.offset - PLT_INITIAL_ENTRY_SIZE (htab))
14979 / PLT_ENTRY_SIZE (htab) * sizeof (Elf64_External_Rela)));
e054468f 14980 }
8387904d 14981 bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
a345bc8d
AM		 14982
14983 if (!htab->opd_abi)
14984 {
14985 if (!h->def_regular)
14986 {
14987 /* Mark the symbol as undefined, rather than as
14988 defined in glink. Leave the value if there were
14989 any relocations where pointer equality matters
14990 (this is a clue for the dynamic linker, to make
14991 function pointer comparisons work between an
14992 application and shared library), otherwise set it
14993 to zero. */
14994 sym->st_shndx = SHN_UNDEF;
14995 if (!h->pointer_equality_needed)
14996 sym->st_value = 0;
14997 else if (!h->ref_regular_nonweak)
14998 {
14999 /* This breaks function pointer comparisons, but
15000 that is better than breaking tests for a NULL
15001 function pointer. */
15002 sym->st_value = 0;
15003 }
15004 }
15005 }
8387904d 15006 }
5bd4f169 15007
f5385ebf 15008 if (h->needs_copy)
5bd4f169 15009 {
65f38f15 15010 /* This symbol needs a copy reloc. Set it up. */
5bd4f169 15011
65f38f15
AM		 15012 if (h->dynindx == -1
15013 || (h->root.type != bfd_link_hash_defined
15014 && h->root.type != bfd_link_hash_defweak)
4ce794b7 15015 || htab->relbss == NULL)
65f38f15 15016 abort ();
5bd4f169
AM		 15017
15018 rela.r_offset = (h->root.u.def.value
15019 + h->root.u.def.section->output_section->vma
15020 + h->root.u.def.section->output_offset);
15021 rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_COPY);
15022 rela.r_addend = 0;
4ce794b7
AM		 15023 loc = htab->relbss->contents;
15024 loc += htab->relbss->reloc_count++ * sizeof (Elf64_External_Rela);
65f38f15 15025 bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
5bd4f169
AM		 15026 }
15027
b34976b6 15028 return TRUE;
5bd4f169
AM		 15029}
15030
65f38f15
AM		 15031/* Used to decide how to sort relocs in an optimal manner for the
15032 dynamic linker, before writing them out. */
15033
15034static enum elf_reloc_type_class
7e612e98
AM		 15035ppc64_elf_reloc_type_class (const struct bfd_link_info *info,
15036 const asection *rel_sec,
15037 const Elf_Internal_Rela *rela)
65f38f15 15038{
04c9666a 15039 enum elf_ppc64_reloc_type r_type;
7e612e98
AM		 15040 struct ppc_link_hash_table *htab = ppc_hash_table (info);
15041
33e44f2e 15042 if (rel_sec == htab->elf.irelplt)
7e612e98 15043 return reloc_class_ifunc;
a33d1f77 15044
4ce794b7 15045 r_type = ELF64_R_TYPE (rela->r_info);
a33d1f77 15046 switch (r_type)
65f38f15
AM		 15047 {
15048 case R_PPC64_RELATIVE:
15049 return reloc_class_relative;
15050 case R_PPC64_JMP_SLOT:
15051 return reloc_class_plt;
15052 case R_PPC64_COPY:
15053 return reloc_class_copy;
15054 default:
15055 return reloc_class_normal;
15056 }
15057}
15058
5bd4f169
AM		 15059/* Finish up the dynamic sections. */
15060
b34976b6 15061static bfd_boolean
4ce794b7
AM		 15062ppc64_elf_finish_dynamic_sections (bfd *output_bfd,
15063 struct bfd_link_info *info)
5bd4f169 15064{
65f38f15
AM		 15065 struct ppc_link_hash_table *htab;
15066 bfd *dynobj;
5bd4f169 15067 asection *sdyn;
5bd4f169 15068
65f38f15 15069 htab = ppc_hash_table (info);
4dfe6ac6
NC		 15070 if (htab == NULL)
15071 return FALSE;
15072
65f38f15 15073 dynobj = htab->elf.dynobj;
3d4d4302 15074 sdyn = bfd_get_linker_section (dynobj, ".dynamic");
5bd4f169 15075
65f38f15 15076 if (htab->elf.dynamic_sections_created)
5bd4f169 15077 {
5bd4f169
AM		 15078 Elf64_External_Dyn *dyncon, *dynconend;
15079
33e44f2e 15080 if (sdyn == NULL || htab->elf.sgot == NULL)
65f38f15 15081 abort ();
5bd4f169
AM		 15082
15083 dyncon = (Elf64_External_Dyn *) sdyn->contents;
eea6121a 15084 dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
5bd4f169
AM		 15085 for (; dyncon < dynconend; dyncon++)
15086 {
15087 Elf_Internal_Dyn dyn;
19397422 15088 asection *s;
5bd4f169
AM		 15089
15090 bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
15091
15092 switch (dyn.d_tag)
15093 {
65f38f15
AM		 15094 default:
15095 continue;
5bd4f169 15096
5d1634d7 15097 case DT_PPC64_GLINK:
4ce794b7 15098 s = htab->glink;
6348e046 15099 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
ad8e1ba5
AM		 15100 /* We stupidly defined DT_PPC64_GLINK to be the start
15101 of glink rather than the first entry point, which is
15102 what ld.so needs, and now have a bigger stub to
15103 support automatic multiple TOCs. */
b9e5796b 15104 dyn.d_un.d_ptr += GLINK_CALL_STUB_SIZE - 8 * 4;
5d1634d7
AM		 15105 break;
15106
19397422
AM		 15107 case DT_PPC64_OPD:
15108 s = bfd_get_section_by_name (output_bfd, ".opd");
6348e046
AM		 15109 if (s == NULL)
15110 continue;
15111 dyn.d_un.d_ptr = s->vma;
19397422
AM		 15112 break;
15113
e8910a83
AM		 15114 case DT_PPC64_OPT:
15115 if (htab->do_multi_toc && htab->multi_toc_needed)
15116 dyn.d_un.d_val |= PPC64_OPT_MULTI_TOC;
15117 break;
15118
19397422
AM		 15119 case DT_PPC64_OPDSZ:
15120 s = bfd_get_section_by_name (output_bfd, ".opd");
6348e046
AM		 15121 if (s == NULL)
15122 continue;
eea6121a 15123 dyn.d_un.d_val = s->size;
19397422
AM		 15124 break;
15125
65f38f15 15126 case DT_PLTGOT:
33e44f2e 15127 s = htab->elf.splt;
6348e046 15128 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
65f38f15
AM		 15129 break;
15130
15131 case DT_JMPREL:
33e44f2e 15132 s = htab->elf.srelplt;
6348e046 15133 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
65f38f15 15134 break;
5bd4f169 15135
65f38f15 15136 case DT_PLTRELSZ:
33e44f2e 15137 dyn.d_un.d_val = htab->elf.srelplt->size;
5d1634d7
AM		 15138 break;
15139
15140 case DT_RELASZ:
15141 /* Don't count procedure linkage table relocs in the
15142 overall reloc count. */
33e44f2e 15143 s = htab->elf.srelplt;
6348e046
AM		 15144 if (s == NULL)
15145 continue;
eea6121a 15146 dyn.d_un.d_val -= s->size;
6348e046
AM		 15147 break;
15148
15149 case DT_RELA:
15150 /* We may not be using the standard ELF linker script.
15151 If .rela.plt is the first .rela section, we adjust
15152 DT_RELA to not include it. */
33e44f2e 15153 s = htab->elf.srelplt;
6348e046
AM		 15154 if (s == NULL)
15155 continue;
15156 if (dyn.d_un.d_ptr != s->output_section->vma + s->output_offset)
15157 continue;
eea6121a 15158 dyn.d_un.d_ptr += s->size;
65f38f15 15159 break;
5bd4f169 15160 }
5bd4f169 15161
65f38f15 15162 bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
5bd4f169 15163 }
5bd4f169
AM		 15164 }
15165
33e44f2e 15166 if (htab->elf.sgot != NULL && htab->elf.sgot->size != 0)
5d1634d7
AM		 15167 {
15168 /* Fill in the first entry in the global offset table.
15169 We use it to hold the link-time TOCbase. */
15170 bfd_put_64 (output_bfd,
60ee0d4a 15171 elf_gp (output_bfd) + TOC_BASE_OFF,
33e44f2e 15172 htab->elf.sgot->contents);
5d1634d7
AM		 15173
15174 /* Set .got entry size. */
33e44f2e 15175 elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize = 8;
5d1634d7
AM		 15176 }
15177
33e44f2e 15178 if (htab->elf.splt != NULL && htab->elf.splt->size != 0)
5d1634d7
AM		 15179 {
15180 /* Set .plt entry size. */
33e44f2e 15181 elf_section_data (htab->elf.splt->output_section)->this_hdr.sh_entsize
b9e5796b 15182 = PLT_ENTRY_SIZE (htab);
5d1634d7
AM		 15183 }
15184
84f5d08e
AM		 15185 /* brlt is SEC_LINKER_CREATED, so we need to write out relocs for
15186 brlt ourselves if emitrelocations. */
15187 if (htab->brlt != NULL
15188 && htab->brlt->reloc_count != 0
15189 && !_bfd_elf_link_output_relocs (output_bfd,
15190 htab->brlt,
d4730f92 15191 elf_section_data (htab->brlt)->rela.hdr,
84f5d08e
AM		 15192 elf_section_data (htab->brlt)->relocs,
15193 NULL))
15194 return FALSE;
15195
176a0d42
AM		 15196 if (htab->glink != NULL
15197 && htab->glink->reloc_count != 0
15198 && !_bfd_elf_link_output_relocs (output_bfd,
15199 htab->glink,
d4730f92 15200 elf_section_data (htab->glink)->rela.hdr,
176a0d42
AM		 15201 elf_section_data (htab->glink)->relocs,
15202 NULL))
15203 return FALSE;
15204
58d180e8 15205 if (htab->glink_eh_frame != NULL
da44f4e5
AM		 15206 && htab->glink_eh_frame->size != 0)
15207 {
15208 bfd_vma val;
15209 bfd_byte *p;
15210 asection *stub_sec;
15211
15212 p = htab->glink_eh_frame->contents + sizeof (glink_eh_frame_cie);
15213 for (stub_sec = htab->params->stub_bfd->sections;
15214 stub_sec != NULL;
15215 stub_sec = stub_sec->next)
15216 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
15217 {
15218 /* FDE length. */
15219 p += 4;
15220 /* CIE pointer. */
15221 p += 4;
15222 /* Offset to stub section. */
15223 val = (stub_sec->output_section->vma
15224 + stub_sec->output_offset);
15225 val -= (htab->glink_eh_frame->output_section->vma
15226 + htab->glink_eh_frame->output_offset
15227 + (p - htab->glink_eh_frame->contents));
15228 if (val + 0x80000000 > 0xffffffff)
15229 {
15230 info->callbacks->einfo
15231 (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
15232 stub_sec->name);
15233 return FALSE;
15234 }
15235 bfd_put_32 (dynobj, val, p);
15236 p += 4;
15237 /* stub section size. */
15238 p += 4;
15239 /* Augmentation. */
15240 p += 1;
15241 /* Pad. */
15242 p += 7;
15243 }
15244 if (htab->glink != NULL && htab->glink->size != 0)
15245 {
15246 /* FDE length. */
15247 p += 4;
15248 /* CIE pointer. */
15249 p += 4;
15250 /* Offset to .glink. */
15251 val = (htab->glink->output_section->vma
15252 + htab->glink->output_offset
15253 + 8);
15254 val -= (htab->glink_eh_frame->output_section->vma
15255 + htab->glink_eh_frame->output_offset
15256 + (p - htab->glink_eh_frame->contents));
15257 if (val + 0x80000000 > 0xffffffff)
15258 {
15259 info->callbacks->einfo
15260 (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
15261 htab->glink->name);
15262 return FALSE;
15263 }
15264 bfd_put_32 (dynobj, val, p);
15265 p += 4;
15266 /* .glink size. */
15267 p += 4;
15268 /* Augmentation. */
15269 p += 1;
15270 /* Ops. */
15271 p += 7;
15272 }
15273
15274 if (htab->glink_eh_frame->sec_info_type == SEC_INFO_TYPE_EH_FRAME
15275 && !_bfd_elf_write_section_eh_frame (output_bfd, info,
15276 htab->glink_eh_frame,
15277 htab->glink_eh_frame->contents))
15278 return FALSE;
15279 }
58d180e8 15280
e717da7e 15281 /* We need to handle writing out multiple GOT sections ourselves,
7b53ace3
AM		 15282 since we didn't add them to DYNOBJ. We know dynobj is the first
15283 bfd. */
c72f2fb2 15284 while ((dynobj = dynobj->link.next) != NULL)
e717da7e
AM		 15285 {
15286 asection *s;
7b53ace3 15287
0c8d6e5c 15288 if (!is_ppc64_elf (dynobj))
7b53ace3
AM		 15289 continue;
15290
e717da7e
AM		 15291 s = ppc64_elf_tdata (dynobj)->got;
15292 if (s != NULL
eea6121a 15293 && s->size != 0
e717da7e
AM		 15294 && s->output_section != bfd_abs_section_ptr
15295 && !bfd_set_section_contents (output_bfd, s->output_section,
15296 s->contents, s->output_offset,
eea6121a 15297 s->size))
e717da7e
AM		 15298 return FALSE;
15299 s = ppc64_elf_tdata (dynobj)->relgot;
15300 if (s != NULL
eea6121a 15301 && s->size != 0
e717da7e
AM		 15302 && s->output_section != bfd_abs_section_ptr
15303 && !bfd_set_section_contents (output_bfd, s->output_section,
15304 s->contents, s->output_offset,
eea6121a 15305 s->size))
e717da7e
AM		 15306 return FALSE;
15307 }
f6c52c13 15308
b34976b6 15309 return TRUE;
5bd4f169
AM		 15310}
15311
5bd4f169 15312#include "elf64-target.h"
7b8e7dad
AM		 15313
15314/* FreeBSD support */
15315
15316#undef TARGET_LITTLE_SYM
15317#undef TARGET_LITTLE_NAME
15318
15319#undef TARGET_BIG_SYM
6d00b590 15320#define TARGET_BIG_SYM powerpc_elf64_fbsd_vec
7b8e7dad
AM		 15321#undef TARGET_BIG_NAME
15322#define TARGET_BIG_NAME "elf64-powerpc-freebsd"
15323
15324#undef ELF_OSABI
15325#define ELF_OSABI ELFOSABI_FREEBSD
15326
15327#undef elf64_bed
15328#define elf64_bed elf64_powerpc_fbsd_bed
15329
15330#include "elf64-target.h"
15331
GDB Binutils - Deliverables
This page took 2.142961 seconds and 4 git commands to generate.