projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Update elf64-ppc.c to use elf_link_hash_table shortcuts.
[deliverable/binutils-gdb.git] / bfd / elf64-ppc.c
CommitLineData
5bd4f169 1/* PowerPC64-specific support for 64-bit ELF.
3a71aa26 2 Copyright 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008,
794e51c0 3 2009, 2010, 2011, 2012 Free Software Foundation, Inc.
5bd4f169
AM		 4 Written by Linus Nordberg, Swox AB <info@swox.com>,
5 based on elf32-ppc.c by Ian Lance Taylor.
32ca9640 6 Largely rewritten by Alan Modra.
5bd4f169 7
ae9a127f 8 This file is part of BFD, the Binary File Descriptor library.
5bd4f169 9
ae9a127f
NC		 10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
cd123cb7 12 the Free Software Foundation; either version 3 of the License, or
ae9a127f 13 (at your option) any later version.
5bd4f169 14
ae9a127f
NC		 15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
5bd4f169 19
4ce794b7
AM		 20 You should have received a copy of the GNU General Public License along
21 with this program; if not, write to the Free Software Foundation, Inc.,
3e110533 22 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */
5bd4f169 23
cd123cb7 24
4ce794b7
AM		 25/* The 64-bit PowerPC ELF ABI may be found at
26 http://www.linuxbase.org/spec/ELF/ppc64/PPC-elf64abi.txt, and
27 http://www.linuxbase.org/spec/ELF/ppc64/spec/book1.html */
5bd4f169 28
3db64b00 29#include "sysdep.h"
183e98be 30#include <stdarg.h>
5bd4f169 31#include "bfd.h"
5bd4f169
AM		 32#include "bfdlink.h"
33#include "libbfd.h"
34#include "elf-bfd.h"
04c9666a 35#include "elf/ppc64.h"
5d1634d7 36#include "elf64-ppc.h"
58d180e8 37#include "dwarf2.h"
5bd4f169 38
805fc799 39static bfd_reloc_status_type ppc64_elf_ha_reloc
4ce794b7 40 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
2441e016
AM		 41static bfd_reloc_status_type ppc64_elf_branch_reloc
42 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
805fc799 43static bfd_reloc_status_type ppc64_elf_brtaken_reloc
4ce794b7 44 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
805fc799 45static bfd_reloc_status_type ppc64_elf_sectoff_reloc
4ce794b7 46 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
805fc799 47static bfd_reloc_status_type ppc64_elf_sectoff_ha_reloc
4ce794b7 48 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
805fc799 49static bfd_reloc_status_type ppc64_elf_toc_reloc
4ce794b7 50 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
805fc799 51static bfd_reloc_status_type ppc64_elf_toc_ha_reloc
4ce794b7 52 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
805fc799 53static bfd_reloc_status_type ppc64_elf_toc64_reloc
4ce794b7 54 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
805fc799 55static bfd_reloc_status_type ppc64_elf_unhandled_reloc
4ce794b7 56 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
2441e016 57static bfd_vma opd_entry_value
aef36ac1 58 (asection *, bfd_vma, asection **, bfd_vma *, bfd_boolean);
5bd4f169 59
ad8e1ba5
AM		 60#define TARGET_LITTLE_SYM bfd_elf64_powerpcle_vec
61#define TARGET_LITTLE_NAME "elf64-powerpcle"
62#define TARGET_BIG_SYM bfd_elf64_powerpc_vec
63#define TARGET_BIG_NAME "elf64-powerpc"
64#define ELF_ARCH bfd_arch_powerpc
ae95ffa6 65#define ELF_TARGET_ID PPC64_ELF_DATA
ad8e1ba5
AM		 66#define ELF_MACHINE_CODE EM_PPC64
67#define ELF_MAXPAGESIZE 0x10000
24718e3b 68#define ELF_COMMONPAGESIZE 0x1000
ad8e1ba5
AM		 69#define elf_info_to_howto ppc64_elf_info_to_howto
70
71#define elf_backend_want_got_sym 0
72#define elf_backend_want_plt_sym 0
73#define elf_backend_plt_alignment 3
74#define elf_backend_plt_not_loaded 1
ad8e1ba5 75#define elf_backend_got_header_size 8
ad8e1ba5
AM		 76#define elf_backend_can_gc_sections 1
77#define elf_backend_can_refcount 1
78#define elf_backend_rela_normal 1
6bfdb61b 79#define elf_backend_default_execstack 0
ad8e1ba5 80
e717da7e 81#define bfd_elf64_mkobject ppc64_elf_mkobject
ad8e1ba5 82#define bfd_elf64_bfd_reloc_type_lookup ppc64_elf_reloc_type_lookup
aa374f67 83#define bfd_elf64_bfd_reloc_name_lookup ppc64_elf_reloc_name_lookup
ee67d69a
AM		 84#define bfd_elf64_bfd_merge_private_bfd_data ppc64_elf_merge_private_bfd_data
85#define bfd_elf64_bfd_print_private_bfd_data ppc64_elf_print_private_bfd_data
ad8e1ba5
AM		 86#define bfd_elf64_new_section_hook ppc64_elf_new_section_hook
87#define bfd_elf64_bfd_link_hash_table_create ppc64_elf_link_hash_table_create
88#define bfd_elf64_bfd_link_hash_table_free ppc64_elf_link_hash_table_free
90e3cdf2 89#define bfd_elf64_get_synthetic_symtab ppc64_elf_get_synthetic_symtab
aa374f67 90#define bfd_elf64_bfd_link_just_syms ppc64_elf_link_just_syms
ad8e1ba5
AM		 91
92#define elf_backend_object_p ppc64_elf_object_p
d37c89e5
AM		 93#define elf_backend_grok_prstatus ppc64_elf_grok_prstatus
94#define elf_backend_grok_psinfo ppc64_elf_grok_psinfo
183e98be 95#define elf_backend_write_core_note ppc64_elf_write_core_note
ad8e1ba5
AM		 96#define elf_backend_create_dynamic_sections ppc64_elf_create_dynamic_sections
97#define elf_backend_copy_indirect_symbol ppc64_elf_copy_indirect_symbol
555cd476 98#define elf_backend_add_symbol_hook ppc64_elf_add_symbol_hook
7d9616d7 99#define elf_backend_check_directives ppc64_elf_process_dot_syms
e5034e59 100#define elf_backend_notice_as_needed ppc64_elf_notice_as_needed
8387904d 101#define elf_backend_archive_symbol_lookup ppc64_elf_archive_symbol_lookup
ad8e1ba5 102#define elf_backend_check_relocs ppc64_elf_check_relocs
74f0fb50 103#define elf_backend_gc_keep ppc64_elf_gc_keep
64d03ab5 104#define elf_backend_gc_mark_dynamic_ref ppc64_elf_gc_mark_dynamic_ref
ad8e1ba5
AM		 105#define elf_backend_gc_mark_hook ppc64_elf_gc_mark_hook
106#define elf_backend_gc_sweep_hook ppc64_elf_gc_sweep_hook
107#define elf_backend_adjust_dynamic_symbol ppc64_elf_adjust_dynamic_symbol
108#define elf_backend_hide_symbol ppc64_elf_hide_symbol
9f296da3 109#define elf_backend_maybe_function_sym ppc64_elf_maybe_function_sym
ad8e1ba5
AM		 110#define elf_backend_always_size_sections ppc64_elf_func_desc_adjust
111#define elf_backend_size_dynamic_sections ppc64_elf_size_dynamic_sections
a345bc8d 112#define elf_backend_hash_symbol ppc64_elf_hash_symbol
74541ad4 113#define elf_backend_init_index_section _bfd_elf_init_2_index_sections
60124e18 114#define elf_backend_action_discarded ppc64_elf_action_discarded
ad8e1ba5
AM		 115#define elf_backend_relocate_section ppc64_elf_relocate_section
116#define elf_backend_finish_dynamic_symbol ppc64_elf_finish_dynamic_symbol
117#define elf_backend_reloc_type_class ppc64_elf_reloc_type_class
118#define elf_backend_finish_dynamic_sections ppc64_elf_finish_dynamic_sections
754021d0 119#define elf_backend_link_output_symbol_hook ppc64_elf_output_symbol_hook
29ef7005 120#define elf_backend_special_sections ppc64_elf_special_sections
e054468f 121#define elf_backend_post_process_headers _bfd_elf_set_osabi
6911b7dc 122#define elf_backend_merge_symbol_attribute ppc64_elf_merge_symbol_attribute
ad8e1ba5 123
5bd4f169
AM		 124/* The name of the dynamic interpreter. This is put in the .interp
125 section. */
126#define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
127
128/* The size in bytes of an entry in the procedure linkage table. */
b9e5796b 129#define PLT_ENTRY_SIZE(htab) (htab->opd_abi ? 24 : 8)
5bd4f169
AM		 130
131/* The initial size of the plt reserved for the dynamic linker. */
b9e5796b 132#define PLT_INITIAL_ENTRY_SIZE(htab) (htab->opd_abi ? 24 : 16)
5bd4f169 133
a078d95a
AM		 134/* Offsets to some stack save slots. */
135#define STK_LR 16
136#define STK_TOC(htab) (htab->opd_abi ? 40 : 24)
137/* This one is dodgy. ABIv2 does not have a linker word, so use the
138 CR save slot. Used only by optimised __tls_get_addr call stub,
139 relying on __tls_get_addr_opt not saving CR.. */
140#define STK_LINKER(htab) (htab->opd_abi ? 32 : 8)
141
5bd4f169 142/* TOC base pointers offset from start of TOC. */
411e1bfb
AM		 143#define TOC_BASE_OFF 0x8000
144
145/* Offset of tp and dtp pointers from start of TLS block. */
146#define TP_OFFSET 0x7000
147#define DTP_OFFSET 0x8000
5bd4f169 148
ad8e1ba5
AM		 149/* .plt call stub instructions. The normal stub is like this, but
150 sometimes the .plt entry crosses a 64k boundary and we need to
71a39c98 151 insert an addi to adjust r11. */
a078d95a 152#define STD_R2_0R1 0xf8410000 /* std %r2,0+40(%r1) */
71a39c98
AM		 153#define ADDIS_R11_R2 0x3d620000 /* addis %r11,%r2,xxx@ha */
154#define LD_R12_0R11 0xe98b0000 /* ld %r12,xxx+0@l(%r11) */
155#define MTCTR_R12 0x7d8903a6 /* mtctr %r12 */
156#define LD_R2_0R11 0xe84b0000 /* ld %r2,xxx+8@l(%r11) */
157#define LD_R11_0R11 0xe96b0000 /* ld %r11,xxx+16@l(%r11) */
5d1634d7
AM		 158#define BCTR 0x4e800420 /* bctr */
159
71a39c98 160#define ADDI_R11_R11 0x396b0000 /* addi %r11,%r11,off@l */
ad8e1ba5
AM		 161#define ADDIS_R2_R2 0x3c420000 /* addis %r2,%r2,off@ha */
162#define ADDI_R2_R2 0x38420000 /* addi %r2,%r2,off@l */
163
71a39c98
AM		 164#define XOR_R2_R12_R12 0x7d826278 /* xor %r2,%r12,%r12 */
165#define ADD_R11_R11_R2 0x7d6b1214 /* add %r11,%r11,%r2 */
166#define XOR_R11_R12_R12 0x7d8b6278 /* xor %r11,%r12,%r12 */
794e51c0
AM		 167#define ADD_R2_R2_R11 0x7c425a14 /* add %r2,%r2,%r11 */
168#define CMPLDI_R2_0 0x28220000 /* cmpldi %r2,0 */
169#define BNECTR 0x4ca20420 /* bnectr+ */
170#define BNECTR_P4 0x4ce20420 /* bnectr+ */
171
71a39c98 172#define LD_R12_0R2 0xe9820000 /* ld %r12,xxx+0(%r2) */
ac2df442
AM		 173#define LD_R11_0R2 0xe9620000 /* ld %r11,xxx+0(%r2) */
174#define LD_R2_0R2 0xe8420000 /* ld %r2,xxx+0(%r2) */
175
a078d95a 176#define LD_R2_0R1 0xe8410000 /* ld %r2,0(%r1) */
ad8e1ba5 177
a345bc8d
AM		 178#define ADDIS_R12_R12 0x3d8c0000 /* addis %r12,%r12,xxx@ha */
179#define LD_R12_0R12 0xe98c0000 /* ld %r12,xxx@l(%r12) */
180
ee4bf8d2 181/* glink call stub instructions. We enter with the index in R0. */
ad8e1ba5 182#define GLINK_CALL_STUB_SIZE (16*4)
ee4bf8d2
AM		 183 /* 0: */
184 /* .quad plt0-1f */
185 /* __glink: */
186#define MFLR_R12 0x7d8802a6 /* mflr %12 */
187#define BCL_20_31 0x429f0005 /* bcl 20,31,1f */
188 /* 1: */
189#define MFLR_R11 0x7d6802a6 /* mflr %11 */
71a39c98 190 /* ld %2,(0b-1b)(%11) */
ee4bf8d2 191#define MTLR_R12 0x7d8803a6 /* mtlr %12 */
71a39c98
AM		 192#define ADD_R11_R2_R11 0x7d625a14 /* add %11,%2,%11 */
193 /* ld %12,0(%11) */
194 /* ld %2,8(%11) */
195 /* mtctr %12 */
196 /* ld %11,16(%11) */
ee4bf8d2 197 /* bctr */
b9e5796b
AM		 198#define MFLR_R0 0x7c0802a6 /* mflr %r0 */
199#define MTLR_R0 0x7c0803a6 /* mtlr %r0 */
200#define SUB_R12_R12_R11 0x7d8b6050 /* subf %r12,%r11,%r12 */
201#define ADDI_R0_R12 0x380c0000 /* addi %r0,%r12,0 */
202#define SRDI_R0_R0_2 0x7800f082 /* rldicl %r0,%r0,62,2 */
5d1634d7
AM		 203
204/* Pad with this. */
205#define NOP 0x60000000
206
721956f4
AM		 207/* Some other nops. */
208#define CROR_151515 0x4def7b82
209#define CROR_313131 0x4ffffb82
210
cedb70c5 211/* .glink entries for the first 32k functions are two instructions. */
5d1634d7
AM		 212#define LI_R0_0 0x38000000 /* li %r0,0 */
213#define B_DOT 0x48000000 /* b . */
214
215/* After that, we need two instructions to load the index, followed by
216 a branch. */
217#define LIS_R0_0 0x3c000000 /* lis %r0,0 */
10ed1bba 218#define ORI_R0_R0_0 0x60000000 /* ori %r0,%r0,0 */
41bd81ab 219
deb0e272
AM		 220/* Instructions used by the save and restore reg functions. */
221#define STD_R0_0R1 0xf8010000 /* std %r0,0(%r1) */
222#define STD_R0_0R12 0xf80c0000 /* std %r0,0(%r12) */
223#define LD_R0_0R1 0xe8010000 /* ld %r0,0(%r1) */
224#define LD_R0_0R12 0xe80c0000 /* ld %r0,0(%r12) */
82bd7b59
AM		 225#define STFD_FR0_0R1 0xd8010000 /* stfd %fr0,0(%r1) */
226#define LFD_FR0_0R1 0xc8010000 /* lfd %fr0,0(%r1) */
deb0e272
AM		 227#define LI_R12_0 0x39800000 /* li %r12,0 */
228#define STVX_VR0_R12_R0 0x7c0c01ce /* stvx %v0,%r12,%r0 */
229#define LVX_VR0_R12_R0 0x7c0c00ce /* lvx %v0,%r12,%r0 */
230#define MTLR_R0 0x7c0803a6 /* mtlr %r0 */
82bd7b59
AM		 231#define BLR 0x4e800020 /* blr */
232
41bd81ab
AM		 233/* Since .opd is an array of descriptors and each entry will end up
234 with identical R_PPC64_RELATIVE relocs, there is really no need to
235 propagate .opd relocs; The dynamic linker should be taught to
1e2f5b6e 236 relocate .opd without reloc entries. */
41bd81ab
AM		 237#ifndef NO_OPD_RELOCS
238#define NO_OPD_RELOCS 0
239#endif
5bd4f169 240\f
f5e87a1d 241#define ONES(n) (((bfd_vma) 1 << ((n) - 1) << 1) - 1)
b34976b6 242
5bd4f169 243/* Relocation HOWTO's. */
04c9666a 244static reloc_howto_type *ppc64_elf_howto_table[(int) R_PPC64_max];
5bd4f169
AM		 245
246static reloc_howto_type ppc64_elf_howto_raw[] = {
247 /* This reloc does nothing. */
248 HOWTO (R_PPC64_NONE, /* type */
249 0, /* rightshift */
411e1bfb
AM		 250 2, /* size (0 = byte, 1 = short, 2 = long) */
251 32, /* bitsize */
b34976b6 252 FALSE, /* pc_relative */
5bd4f169 253 0, /* bitpos */
f5e87a1d 254 complain_overflow_dont, /* complain_on_overflow */
5bd4f169
AM		 255 bfd_elf_generic_reloc, /* special_function */
256 "R_PPC64_NONE", /* name */
b34976b6 257 FALSE, /* partial_inplace */
d006db6c 258 0, /* src_mask */
5bd4f169 259 0, /* dst_mask */
b34976b6 260 FALSE), /* pcrel_offset */
5bd4f169
AM		 261
262 /* A standard 32 bit relocation. */
263 HOWTO (R_PPC64_ADDR32, /* type */
264 0, /* rightshift */
265 2, /* size (0 = byte, 1 = short, 2 = long) */
266 32, /* bitsize */
b34976b6 267 FALSE, /* pc_relative */
5bd4f169
AM		 268 0, /* bitpos */
269 complain_overflow_bitfield, /* complain_on_overflow */
270 bfd_elf_generic_reloc, /* special_function */
271 "R_PPC64_ADDR32", /* name */
b34976b6 272 FALSE, /* partial_inplace */
5bd4f169
AM		 273 0, /* src_mask */
274 0xffffffff, /* dst_mask */
b34976b6 275 FALSE), /* pcrel_offset */
5bd4f169
AM		 276
277 /* An absolute 26 bit branch; the lower two bits must be zero.
278 FIXME: we don't check that, we just clear them. */
279 HOWTO (R_PPC64_ADDR24, /* type */
280 0, /* rightshift */
281 2, /* size (0 = byte, 1 = short, 2 = long) */
282 26, /* bitsize */
b34976b6 283 FALSE, /* pc_relative */
5bd4f169
AM		 284 0, /* bitpos */
285 complain_overflow_bitfield, /* complain_on_overflow */
286 bfd_elf_generic_reloc, /* special_function */
287 "R_PPC64_ADDR24", /* name */
b34976b6 288 FALSE, /* partial_inplace */
d006db6c 289 0, /* src_mask */
f5e87a1d 290 0x03fffffc, /* dst_mask */
b34976b6 291 FALSE), /* pcrel_offset */
5bd4f169
AM		 292
293 /* A standard 16 bit relocation. */
294 HOWTO (R_PPC64_ADDR16, /* type */
295 0, /* rightshift */
296 1, /* size (0 = byte, 1 = short, 2 = long) */
297 16, /* bitsize */
b34976b6 298 FALSE, /* pc_relative */
5bd4f169
AM		 299 0, /* bitpos */
300 complain_overflow_bitfield, /* complain_on_overflow */
301 bfd_elf_generic_reloc, /* special_function */
302 "R_PPC64_ADDR16", /* name */
b34976b6 303 FALSE, /* partial_inplace */
5bd4f169
AM		 304 0, /* src_mask */
305 0xffff, /* dst_mask */
b34976b6 306 FALSE), /* pcrel_offset */
5bd4f169
AM		 307
308 /* A 16 bit relocation without overflow. */
309 HOWTO (R_PPC64_ADDR16_LO, /* type */
310 0, /* rightshift */
311 1, /* size (0 = byte, 1 = short, 2 = long) */
312 16, /* bitsize */
b34976b6 313 FALSE, /* pc_relative */
5bd4f169
AM		 314 0, /* bitpos */
315 complain_overflow_dont,/* complain_on_overflow */
316 bfd_elf_generic_reloc, /* special_function */
317 "R_PPC64_ADDR16_LO", /* name */
b34976b6 318 FALSE, /* partial_inplace */
5bd4f169
AM		 319 0, /* src_mask */
320 0xffff, /* dst_mask */
b34976b6 321 FALSE), /* pcrel_offset */
5bd4f169
AM		 322
323 /* Bits 16-31 of an address. */
324 HOWTO (R_PPC64_ADDR16_HI, /* type */
325 16, /* rightshift */
326 1, /* size (0 = byte, 1 = short, 2 = long) */
327 16, /* bitsize */
b34976b6 328 FALSE, /* pc_relative */
5bd4f169 329 0, /* bitpos */
f9c6b907 330 complain_overflow_signed, /* complain_on_overflow */
5bd4f169
AM		 331 bfd_elf_generic_reloc, /* special_function */
332 "R_PPC64_ADDR16_HI", /* name */
b34976b6 333 FALSE, /* partial_inplace */
5bd4f169
AM		 334 0, /* src_mask */
335 0xffff, /* dst_mask */
b34976b6 336 FALSE), /* pcrel_offset */
5bd4f169
AM		 337
338 /* Bits 16-31 of an address, plus 1 if the contents of the low 16
339 bits, treated as a signed number, is negative. */
340 HOWTO (R_PPC64_ADDR16_HA, /* type */
341 16, /* rightshift */
342 1, /* size (0 = byte, 1 = short, 2 = long) */
343 16, /* bitsize */
b34976b6 344 FALSE, /* pc_relative */
5bd4f169 345 0, /* bitpos */
f9c6b907 346 complain_overflow_signed, /* complain_on_overflow */
805fc799 347 ppc64_elf_ha_reloc, /* special_function */
5bd4f169 348 "R_PPC64_ADDR16_HA", /* name */
b34976b6 349 FALSE, /* partial_inplace */
5bd4f169
AM		 350 0, /* src_mask */
351 0xffff, /* dst_mask */
b34976b6 352 FALSE), /* pcrel_offset */
5bd4f169
AM		 353
354 /* An absolute 16 bit branch; the lower two bits must be zero.
355 FIXME: we don't check that, we just clear them. */
356 HOWTO (R_PPC64_ADDR14, /* type */
357 0, /* rightshift */
358 2, /* size (0 = byte, 1 = short, 2 = long) */
359 16, /* bitsize */
b34976b6 360 FALSE, /* pc_relative */
5bd4f169
AM		 361 0, /* bitpos */
362 complain_overflow_bitfield, /* complain_on_overflow */
2441e016 363 ppc64_elf_branch_reloc, /* special_function */
5bd4f169 364 "R_PPC64_ADDR14", /* name */
b34976b6 365 FALSE, /* partial_inplace */
d006db6c 366 0, /* src_mask */
f5e87a1d 367 0x0000fffc, /* dst_mask */
b34976b6 368 FALSE), /* pcrel_offset */
5bd4f169
AM		 369
370 /* An absolute 16 bit branch, for which bit 10 should be set to
371 indicate that the branch is expected to be taken. The lower two
372 bits must be zero. */
373 HOWTO (R_PPC64_ADDR14_BRTAKEN, /* type */
374 0, /* rightshift */
375 2, /* size (0 = byte, 1 = short, 2 = long) */
376 16, /* bitsize */
b34976b6 377 FALSE, /* pc_relative */
5bd4f169
AM		 378 0, /* bitpos */
379 complain_overflow_bitfield, /* complain_on_overflow */
805fc799 380 ppc64_elf_brtaken_reloc, /* special_function */
5bd4f169 381 "R_PPC64_ADDR14_BRTAKEN",/* name */
b34976b6 382 FALSE, /* partial_inplace */
d006db6c 383 0, /* src_mask */
f5e87a1d 384 0x0000fffc, /* dst_mask */
b34976b6 385 FALSE), /* pcrel_offset */
5bd4f169
AM		 386
387 /* An absolute 16 bit branch, for which bit 10 should be set to
388 indicate that the branch is not expected to be taken. The lower
389 two bits must be zero. */
390 HOWTO (R_PPC64_ADDR14_BRNTAKEN, /* type */
391 0, /* rightshift */
392 2, /* size (0 = byte, 1 = short, 2 = long) */
393 16, /* bitsize */
b34976b6 394 FALSE, /* pc_relative */
5bd4f169
AM		 395 0, /* bitpos */
396 complain_overflow_bitfield, /* complain_on_overflow */
805fc799 397 ppc64_elf_brtaken_reloc, /* special_function */
5bd4f169 398 "R_PPC64_ADDR14_BRNTAKEN",/* name */
b34976b6 399 FALSE, /* partial_inplace */
d006db6c 400 0, /* src_mask */
f5e87a1d 401 0x0000fffc, /* dst_mask */
b34976b6 402 FALSE), /* pcrel_offset */
5bd4f169
AM		 403
404 /* A relative 26 bit branch; the lower two bits must be zero. */
405 HOWTO (R_PPC64_REL24, /* type */
406 0, /* rightshift */
407 2, /* size (0 = byte, 1 = short, 2 = long) */
408 26, /* bitsize */
b34976b6 409 TRUE, /* pc_relative */
5bd4f169
AM		 410 0, /* bitpos */
411 complain_overflow_signed, /* complain_on_overflow */
2441e016 412 ppc64_elf_branch_reloc, /* special_function */
5bd4f169 413 "R_PPC64_REL24", /* name */
b34976b6 414 FALSE, /* partial_inplace */
d006db6c 415 0, /* src_mask */
f5e87a1d 416 0x03fffffc, /* dst_mask */
b34976b6 417 TRUE), /* pcrel_offset */
5bd4f169
AM		 418
419 /* A relative 16 bit branch; the lower two bits must be zero. */
420 HOWTO (R_PPC64_REL14, /* type */
421 0, /* rightshift */
422 2, /* size (0 = byte, 1 = short, 2 = long) */
423 16, /* bitsize */
b34976b6 424 TRUE, /* pc_relative */
5bd4f169
AM		 425 0, /* bitpos */
426 complain_overflow_signed, /* complain_on_overflow */
2441e016 427 ppc64_elf_branch_reloc, /* special_function */
5bd4f169 428 "R_PPC64_REL14", /* name */
b34976b6 429 FALSE, /* partial_inplace */
d006db6c 430 0, /* src_mask */
f5e87a1d 431 0x0000fffc, /* dst_mask */
b34976b6 432 TRUE), /* pcrel_offset */
5bd4f169
AM		 433
434 /* A relative 16 bit branch. Bit 10 should be set to indicate that
435 the branch is expected to be taken. The lower two bits must be
436 zero. */
437 HOWTO (R_PPC64_REL14_BRTAKEN, /* type */
438 0, /* rightshift */
439 2, /* size (0 = byte, 1 = short, 2 = long) */
440 16, /* bitsize */
b34976b6 441 TRUE, /* pc_relative */
5bd4f169
AM		 442 0, /* bitpos */
443 complain_overflow_signed, /* complain_on_overflow */
805fc799 444 ppc64_elf_brtaken_reloc, /* special_function */
5bd4f169 445 "R_PPC64_REL14_BRTAKEN", /* name */
b34976b6 446 FALSE, /* partial_inplace */
d006db6c 447 0, /* src_mask */
f5e87a1d 448 0x0000fffc, /* dst_mask */
b34976b6 449 TRUE), /* pcrel_offset */
5bd4f169
AM		 450
451 /* A relative 16 bit branch. Bit 10 should be set to indicate that
452 the branch is not expected to be taken. The lower two bits must
453 be zero. */
454 HOWTO (R_PPC64_REL14_BRNTAKEN, /* type */
455 0, /* rightshift */
456 2, /* size (0 = byte, 1 = short, 2 = long) */
457 16, /* bitsize */
b34976b6 458 TRUE, /* pc_relative */
5bd4f169
AM		 459 0, /* bitpos */
460 complain_overflow_signed, /* complain_on_overflow */
805fc799 461 ppc64_elf_brtaken_reloc, /* special_function */
5bd4f169 462 "R_PPC64_REL14_BRNTAKEN",/* name */
b34976b6 463 FALSE, /* partial_inplace */
d006db6c 464 0, /* src_mask */
f5e87a1d 465 0x0000fffc, /* dst_mask */
b34976b6 466 TRUE), /* pcrel_offset */
5bd4f169
AM		 467
468 /* Like R_PPC64_ADDR16, but referring to the GOT table entry for the
469 symbol. */
470 HOWTO (R_PPC64_GOT16, /* type */
471 0, /* rightshift */
472 1, /* size (0 = byte, 1 = short, 2 = long) */
473 16, /* bitsize */
b34976b6 474 FALSE, /* pc_relative */
5bd4f169
AM		 475 0, /* bitpos */
476 complain_overflow_signed, /* complain_on_overflow */
805fc799 477 ppc64_elf_unhandled_reloc, /* special_function */
5bd4f169 478 "R_PPC64_GOT16", /* name */
b34976b6 479 FALSE, /* partial_inplace */
5bd4f169
AM		 480 0, /* src_mask */
481 0xffff, /* dst_mask */
b34976b6 482 FALSE), /* pcrel_offset */
5bd4f169
AM		 483
484 /* Like R_PPC64_ADDR16_LO, but referring to the GOT table entry for
485 the symbol. */
486 HOWTO (R_PPC64_GOT16_LO, /* type */
487 0, /* rightshift */
488 1, /* size (0 = byte, 1 = short, 2 = long) */
489 16, /* bitsize */
b34976b6 490 FALSE, /* pc_relative */
5bd4f169
AM		 491 0, /* bitpos */
492 complain_overflow_dont, /* complain_on_overflow */
805fc799 493 ppc64_elf_unhandled_reloc, /* special_function */
5bd4f169 494 "R_PPC64_GOT16_LO", /* name */
b34976b6 495 FALSE, /* partial_inplace */
5bd4f169
AM		 496 0, /* src_mask */
497 0xffff, /* dst_mask */
b34976b6 498 FALSE), /* pcrel_offset */
5bd4f169
AM		 499
500 /* Like R_PPC64_ADDR16_HI, but referring to the GOT table entry for
501 the symbol. */
502 HOWTO (R_PPC64_GOT16_HI, /* type */
503 16, /* rightshift */
504 1, /* size (0 = byte, 1 = short, 2 = long) */
505 16, /* bitsize */
b34976b6 506 FALSE, /* pc_relative */
5bd4f169 507 0, /* bitpos */
f9c6b907 508 complain_overflow_signed,/* complain_on_overflow */
805fc799 509 ppc64_elf_unhandled_reloc, /* special_function */
5bd4f169 510 "R_PPC64_GOT16_HI", /* name */
b34976b6 511 FALSE, /* partial_inplace */
5bd4f169
AM		 512 0, /* src_mask */
513 0xffff, /* dst_mask */
b34976b6 514 FALSE), /* pcrel_offset */
5bd4f169
AM		 515
516 /* Like R_PPC64_ADDR16_HA, but referring to the GOT table entry for
517 the symbol. */
518 HOWTO (R_PPC64_GOT16_HA, /* type */
519 16, /* rightshift */
520 1, /* size (0 = byte, 1 = short, 2 = long) */
521 16, /* bitsize */
b34976b6 522 FALSE, /* pc_relative */
5bd4f169 523 0, /* bitpos */
f9c6b907 524 complain_overflow_signed,/* complain_on_overflow */
805fc799 525 ppc64_elf_unhandled_reloc, /* special_function */
5bd4f169 526 "R_PPC64_GOT16_HA", /* name */
b34976b6 527 FALSE, /* partial_inplace */
5bd4f169
AM		 528 0, /* src_mask */
529 0xffff, /* dst_mask */
b34976b6 530 FALSE), /* pcrel_offset */
5bd4f169
AM		 531
532 /* This is used only by the dynamic linker. The symbol should exist
533 both in the object being run and in some shared library. The
534 dynamic linker copies the data addressed by the symbol from the
535 shared library into the object, because the object being
536 run has to have the data at some particular address. */
537 HOWTO (R_PPC64_COPY, /* type */
538 0, /* rightshift */
f5e87a1d
AM		 539 0, /* this one is variable size */
540 0, /* bitsize */
b34976b6 541 FALSE, /* pc_relative */
5bd4f169 542 0, /* bitpos */
f5e87a1d
AM		 543 complain_overflow_dont, /* complain_on_overflow */
544 ppc64_elf_unhandled_reloc, /* special_function */
5bd4f169 545 "R_PPC64_COPY", /* name */
b34976b6 546 FALSE, /* partial_inplace */
5bd4f169
AM		 547 0, /* src_mask */
548 0, /* dst_mask */
b34976b6 549 FALSE), /* pcrel_offset */
5bd4f169
AM		 550
551 /* Like R_PPC64_ADDR64, but used when setting global offset table
552 entries. */
553 HOWTO (R_PPC64_GLOB_DAT, /* type */
554 0, /* rightshift */
555 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
556 64, /* bitsize */
b34976b6 557 FALSE, /* pc_relative */
5bd4f169
AM		 558 0, /* bitpos */
559 complain_overflow_dont, /* complain_on_overflow */
805fc799 560 ppc64_elf_unhandled_reloc, /* special_function */
5bd4f169 561 "R_PPC64_GLOB_DAT", /* name */
b34976b6 562 FALSE, /* partial_inplace */
5bd4f169 563 0, /* src_mask */
f5e87a1d 564 ONES (64), /* dst_mask */
b34976b6 565 FALSE), /* pcrel_offset */
5bd4f169
AM		 566
567 /* Created by the link editor. Marks a procedure linkage table
568 entry for a symbol. */
569 HOWTO (R_PPC64_JMP_SLOT, /* type */
570 0, /* rightshift */
571 0, /* size (0 = byte, 1 = short, 2 = long) */
572 0, /* bitsize */
b34976b6 573 FALSE, /* pc_relative */
5bd4f169
AM		 574 0, /* bitpos */
575 complain_overflow_dont, /* complain_on_overflow */
805fc799 576 ppc64_elf_unhandled_reloc, /* special_function */
5bd4f169 577 "R_PPC64_JMP_SLOT", /* name */
b34976b6 578 FALSE, /* partial_inplace */
5bd4f169
AM		 579 0, /* src_mask */
580 0, /* dst_mask */
b34976b6 581 FALSE), /* pcrel_offset */
5bd4f169
AM		 582
583 /* Used only by the dynamic linker. When the object is run, this
584 doubleword64 is set to the load address of the object, plus the
585 addend. */
586 HOWTO (R_PPC64_RELATIVE, /* type */
587 0, /* rightshift */
588 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
589 64, /* bitsize */
b34976b6 590 FALSE, /* pc_relative */
5bd4f169
AM		 591 0, /* bitpos */
592 complain_overflow_dont, /* complain_on_overflow */
593 bfd_elf_generic_reloc, /* special_function */
594 "R_PPC64_RELATIVE", /* name */
b34976b6 595 FALSE, /* partial_inplace */
5bd4f169 596 0, /* src_mask */
f5e87a1d 597 ONES (64), /* dst_mask */
b34976b6 598 FALSE), /* pcrel_offset */
5bd4f169
AM		 599
600 /* Like R_PPC64_ADDR32, but may be unaligned. */
601 HOWTO (R_PPC64_UADDR32, /* type */
602 0, /* rightshift */
603 2, /* size (0 = byte, 1 = short, 2 = long) */
604 32, /* bitsize */
b34976b6 605 FALSE, /* pc_relative */
5bd4f169
AM		 606 0, /* bitpos */
607 complain_overflow_bitfield, /* complain_on_overflow */
608 bfd_elf_generic_reloc, /* special_function */
609 "R_PPC64_UADDR32", /* name */
b34976b6 610 FALSE, /* partial_inplace */
5bd4f169
AM		 611 0, /* src_mask */
612 0xffffffff, /* dst_mask */
b34976b6 613 FALSE), /* pcrel_offset */
5bd4f169
AM		 614
615 /* Like R_PPC64_ADDR16, but may be unaligned. */
616 HOWTO (R_PPC64_UADDR16, /* type */
617 0, /* rightshift */
618 1, /* size (0 = byte, 1 = short, 2 = long) */
619 16, /* bitsize */
b34976b6 620 FALSE, /* pc_relative */
5bd4f169
AM		 621 0, /* bitpos */
622 complain_overflow_bitfield, /* complain_on_overflow */
623 bfd_elf_generic_reloc, /* special_function */
624 "R_PPC64_UADDR16", /* name */
b34976b6 625 FALSE, /* partial_inplace */
5bd4f169
AM		 626 0, /* src_mask */
627 0xffff, /* dst_mask */
b34976b6 628 FALSE), /* pcrel_offset */
5bd4f169
AM		 629
630 /* 32-bit PC relative. */
631 HOWTO (R_PPC64_REL32, /* type */
632 0, /* rightshift */
633 2, /* size (0 = byte, 1 = short, 2 = long) */
634 32, /* bitsize */
b34976b6 635 TRUE, /* pc_relative */
5bd4f169 636 0, /* bitpos */
cedb70c5 637 /* FIXME: Verify. Was complain_overflow_bitfield. */
5bd4f169
AM		 638 complain_overflow_signed, /* complain_on_overflow */
639 bfd_elf_generic_reloc, /* special_function */
640 "R_PPC64_REL32", /* name */
b34976b6 641 FALSE, /* partial_inplace */
5bd4f169
AM		 642 0, /* src_mask */
643 0xffffffff, /* dst_mask */
b34976b6 644 TRUE), /* pcrel_offset */
5bd4f169 645
10ed1bba 646 /* 32-bit relocation to the symbol's procedure linkage table. */
5bd4f169
AM		 647 HOWTO (R_PPC64_PLT32, /* type */
648 0, /* rightshift */
649 2, /* size (0 = byte, 1 = short, 2 = long) */
650 32, /* bitsize */
b34976b6 651 FALSE, /* pc_relative */
5bd4f169
AM		 652 0, /* bitpos */
653 complain_overflow_bitfield, /* complain_on_overflow */
805fc799 654 ppc64_elf_unhandled_reloc, /* special_function */
5bd4f169 655 "R_PPC64_PLT32", /* name */
b34976b6 656 FALSE, /* partial_inplace */
5bd4f169 657 0, /* src_mask */
f5e87a1d 658 0xffffffff, /* dst_mask */
b34976b6 659 FALSE), /* pcrel_offset */
5bd4f169
AM		 660
661 /* 32-bit PC relative relocation to the symbol's procedure linkage table.
662 FIXME: R_PPC64_PLTREL32 not supported. */
663 HOWTO (R_PPC64_PLTREL32, /* type */
664 0, /* rightshift */
665 2, /* size (0 = byte, 1 = short, 2 = long) */
666 32, /* bitsize */
b34976b6 667 TRUE, /* pc_relative */
5bd4f169
AM		 668 0, /* bitpos */
669 complain_overflow_signed, /* complain_on_overflow */
670 bfd_elf_generic_reloc, /* special_function */
671 "R_PPC64_PLTREL32", /* name */
b34976b6 672 FALSE, /* partial_inplace */
5bd4f169 673 0, /* src_mask */
f5e87a1d 674 0xffffffff, /* dst_mask */
b34976b6 675 TRUE), /* pcrel_offset */
5bd4f169
AM		 676
677 /* Like R_PPC64_ADDR16_LO, but referring to the PLT table entry for
678 the symbol. */
679 HOWTO (R_PPC64_PLT16_LO, /* type */
680 0, /* rightshift */
681 1, /* size (0 = byte, 1 = short, 2 = long) */
682 16, /* bitsize */
b34976b6 683 FALSE, /* pc_relative */
5bd4f169
AM		 684 0, /* bitpos */
685 complain_overflow_dont, /* complain_on_overflow */
805fc799 686 ppc64_elf_unhandled_reloc, /* special_function */
5bd4f169 687 "R_PPC64_PLT16_LO", /* name */
b34976b6 688 FALSE, /* partial_inplace */
5bd4f169
AM		 689 0, /* src_mask */
690 0xffff, /* dst_mask */
b34976b6 691 FALSE), /* pcrel_offset */
5bd4f169
AM		 692
693 /* Like R_PPC64_ADDR16_HI, but referring to the PLT table entry for
694 the symbol. */
695 HOWTO (R_PPC64_PLT16_HI, /* type */
696 16, /* rightshift */
697 1, /* size (0 = byte, 1 = short, 2 = long) */
698 16, /* bitsize */
b34976b6 699 FALSE, /* pc_relative */
5bd4f169 700 0, /* bitpos */
f9c6b907 701 complain_overflow_signed, /* complain_on_overflow */
805fc799 702 ppc64_elf_unhandled_reloc, /* special_function */
5bd4f169 703 "R_PPC64_PLT16_HI", /* name */
b34976b6 704 FALSE, /* partial_inplace */
5bd4f169
AM		 705 0, /* src_mask */
706 0xffff, /* dst_mask */
b34976b6 707 FALSE), /* pcrel_offset */
5bd4f169
AM		 708
709 /* Like R_PPC64_ADDR16_HA, but referring to the PLT table entry for
710 the symbol. */
711 HOWTO (R_PPC64_PLT16_HA, /* type */
712 16, /* rightshift */
713 1, /* size (0 = byte, 1 = short, 2 = long) */
714 16, /* bitsize */
b34976b6 715 FALSE, /* pc_relative */
5bd4f169 716 0, /* bitpos */
f9c6b907 717 complain_overflow_signed, /* complain_on_overflow */
805fc799 718 ppc64_elf_unhandled_reloc, /* special_function */
5bd4f169 719 "R_PPC64_PLT16_HA", /* name */
b34976b6 720 FALSE, /* partial_inplace */
5bd4f169
AM		 721 0, /* src_mask */
722 0xffff, /* dst_mask */
b34976b6 723 FALSE), /* pcrel_offset */
5bd4f169 724
c061c2d8 725 /* 16-bit section relative relocation. */
5bd4f169
AM		 726 HOWTO (R_PPC64_SECTOFF, /* type */
727 0, /* rightshift */
c061c2d8
AM		 728 1, /* size (0 = byte, 1 = short, 2 = long) */
729 16, /* bitsize */
b34976b6 730 FALSE, /* pc_relative */
5bd4f169
AM		 731 0, /* bitpos */
732 complain_overflow_bitfield, /* complain_on_overflow */
805fc799 733 ppc64_elf_sectoff_reloc, /* special_function */
5bd4f169 734 "R_PPC64_SECTOFF", /* name */
b34976b6 735 FALSE, /* partial_inplace */
5bd4f169 736 0, /* src_mask */
c061c2d8 737 0xffff, /* dst_mask */
b34976b6 738 FALSE), /* pcrel_offset */
5bd4f169 739
c061c2d8 740 /* Like R_PPC64_SECTOFF, but no overflow warning. */
5bd4f169
AM		 741 HOWTO (R_PPC64_SECTOFF_LO, /* type */
742 0, /* rightshift */
743 1, /* size (0 = byte, 1 = short, 2 = long) */
744 16, /* bitsize */
b34976b6 745 FALSE, /* pc_relative */
5bd4f169
AM		 746 0, /* bitpos */
747 complain_overflow_dont, /* complain_on_overflow */
805fc799 748 ppc64_elf_sectoff_reloc, /* special_function */
5bd4f169 749 "R_PPC64_SECTOFF_LO", /* name */
b34976b6 750 FALSE, /* partial_inplace */
5bd4f169
AM		 751 0, /* src_mask */
752 0xffff, /* dst_mask */
b34976b6 753 FALSE), /* pcrel_offset */
5bd4f169
AM		 754
755 /* 16-bit upper half section relative relocation. */
756 HOWTO (R_PPC64_SECTOFF_HI, /* type */
757 16, /* rightshift */
758 1, /* size (0 = byte, 1 = short, 2 = long) */
759 16, /* bitsize */
b34976b6 760 FALSE, /* pc_relative */
5bd4f169 761 0, /* bitpos */
f9c6b907 762 complain_overflow_signed, /* complain_on_overflow */
805fc799 763 ppc64_elf_sectoff_reloc, /* special_function */
5bd4f169 764 "R_PPC64_SECTOFF_HI", /* name */
b34976b6 765 FALSE, /* partial_inplace */
5bd4f169
AM		 766 0, /* src_mask */
767 0xffff, /* dst_mask */
b34976b6 768 FALSE), /* pcrel_offset */
5bd4f169
AM		 769
770 /* 16-bit upper half adjusted section relative relocation. */
771 HOWTO (R_PPC64_SECTOFF_HA, /* type */
772 16, /* rightshift */
773 1, /* size (0 = byte, 1 = short, 2 = long) */
774 16, /* bitsize */
b34976b6 775 FALSE, /* pc_relative */
5bd4f169 776 0, /* bitpos */
f9c6b907 777 complain_overflow_signed, /* complain_on_overflow */
805fc799 778 ppc64_elf_sectoff_ha_reloc, /* special_function */
5bd4f169 779 "R_PPC64_SECTOFF_HA", /* name */
b34976b6 780 FALSE, /* partial_inplace */
5bd4f169
AM		 781 0, /* src_mask */
782 0xffff, /* dst_mask */
b34976b6 783 FALSE), /* pcrel_offset */
5bd4f169 784
04c9666a
AM		 785 /* Like R_PPC64_REL24 without touching the two least significant bits. */
786 HOWTO (R_PPC64_REL30, /* type */
5bd4f169
AM		 787 2, /* rightshift */
788 2, /* size (0 = byte, 1 = short, 2 = long) */
789 30, /* bitsize */
b34976b6 790 TRUE, /* pc_relative */
5bd4f169
AM		 791 0, /* bitpos */
792 complain_overflow_dont, /* complain_on_overflow */
793 bfd_elf_generic_reloc, /* special_function */
04c9666a 794 "R_PPC64_REL30", /* name */
b34976b6 795 FALSE, /* partial_inplace */
d006db6c 796 0, /* src_mask */
5bd4f169 797 0xfffffffc, /* dst_mask */
b34976b6 798 TRUE), /* pcrel_offset */
5bd4f169
AM		 799
800 /* Relocs in the 64-bit PowerPC ELF ABI, not in the 32-bit ABI. */
801
802 /* A standard 64-bit relocation. */
803 HOWTO (R_PPC64_ADDR64, /* type */
804 0, /* rightshift */
805 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
806 64, /* bitsize */
b34976b6 807 FALSE, /* pc_relative */
5bd4f169
AM		 808 0, /* bitpos */
809 complain_overflow_dont, /* complain_on_overflow */
810 bfd_elf_generic_reloc, /* special_function */
811 "R_PPC64_ADDR64", /* name */
b34976b6 812 FALSE, /* partial_inplace */
5bd4f169 813 0, /* src_mask */
f5e87a1d 814 ONES (64), /* dst_mask */
b34976b6 815 FALSE), /* pcrel_offset */
5bd4f169
AM		 816
817 /* The bits 32-47 of an address. */
818 HOWTO (R_PPC64_ADDR16_HIGHER, /* type */
819 32, /* rightshift */
820 1, /* size (0 = byte, 1 = short, 2 = long) */
821 16, /* bitsize */
b34976b6 822 FALSE, /* pc_relative */
5bd4f169
AM		 823 0, /* bitpos */
824 complain_overflow_dont, /* complain_on_overflow */
825 bfd_elf_generic_reloc, /* special_function */
826 "R_PPC64_ADDR16_HIGHER", /* name */
b34976b6 827 FALSE, /* partial_inplace */
5bd4f169
AM		 828 0, /* src_mask */
829 0xffff, /* dst_mask */
b34976b6 830 FALSE), /* pcrel_offset */
5bd4f169
AM		 831
832 /* The bits 32-47 of an address, plus 1 if the contents of the low
833 16 bits, treated as a signed number, is negative. */
834 HOWTO (R_PPC64_ADDR16_HIGHERA, /* type */
835 32, /* rightshift */
836 1, /* size (0 = byte, 1 = short, 2 = long) */
837 16, /* bitsize */
b34976b6 838 FALSE, /* pc_relative */
5bd4f169
AM		 839 0, /* bitpos */
840 complain_overflow_dont, /* complain_on_overflow */
805fc799 841 ppc64_elf_ha_reloc, /* special_function */
5bd4f169 842 "R_PPC64_ADDR16_HIGHERA", /* name */
b34976b6 843 FALSE, /* partial_inplace */
5bd4f169
AM		 844 0, /* src_mask */
845 0xffff, /* dst_mask */
b34976b6 846 FALSE), /* pcrel_offset */
5bd4f169
AM		 847
848 /* The bits 48-63 of an address. */
849 HOWTO (R_PPC64_ADDR16_HIGHEST,/* type */
850 48, /* rightshift */
851 1, /* size (0 = byte, 1 = short, 2 = long) */
852 16, /* bitsize */
b34976b6 853 FALSE, /* pc_relative */
5bd4f169
AM		 854 0, /* bitpos */
855 complain_overflow_dont, /* complain_on_overflow */
856 bfd_elf_generic_reloc, /* special_function */
857 "R_PPC64_ADDR16_HIGHEST", /* name */
b34976b6 858 FALSE, /* partial_inplace */
5bd4f169
AM		 859 0, /* src_mask */
860 0xffff, /* dst_mask */
b34976b6 861 FALSE), /* pcrel_offset */
5bd4f169
AM		 862
863 /* The bits 48-63 of an address, plus 1 if the contents of the low
864 16 bits, treated as a signed number, is negative. */
865 HOWTO (R_PPC64_ADDR16_HIGHESTA,/* type */
866 48, /* rightshift */
867 1, /* size (0 = byte, 1 = short, 2 = long) */
868 16, /* bitsize */
b34976b6 869 FALSE, /* pc_relative */
5bd4f169
AM		 870 0, /* bitpos */
871 complain_overflow_dont, /* complain_on_overflow */
805fc799 872 ppc64_elf_ha_reloc, /* special_function */
5bd4f169 873 "R_PPC64_ADDR16_HIGHESTA", /* name */
b34976b6 874 FALSE, /* partial_inplace */
5bd4f169
AM		 875 0, /* src_mask */
876 0xffff, /* dst_mask */
b34976b6 877 FALSE), /* pcrel_offset */
5bd4f169
AM		 878
879 /* Like ADDR64, but may be unaligned. */
880 HOWTO (R_PPC64_UADDR64, /* type */
881 0, /* rightshift */
882 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
883 64, /* bitsize */
b34976b6 884 FALSE, /* pc_relative */
5bd4f169
AM		 885 0, /* bitpos */
886 complain_overflow_dont, /* complain_on_overflow */
887 bfd_elf_generic_reloc, /* special_function */
888 "R_PPC64_UADDR64", /* name */
b34976b6 889 FALSE, /* partial_inplace */
5bd4f169 890 0, /* src_mask */
f5e87a1d 891 ONES (64), /* dst_mask */
b34976b6 892 FALSE), /* pcrel_offset */
5bd4f169
AM		 893
894 /* 64-bit relative relocation. */
895 HOWTO (R_PPC64_REL64, /* type */
896 0, /* rightshift */
897 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
898 64, /* bitsize */
b34976b6 899 TRUE, /* pc_relative */
5bd4f169
AM		 900 0, /* bitpos */
901 complain_overflow_dont, /* complain_on_overflow */
902 bfd_elf_generic_reloc, /* special_function */
903 "R_PPC64_REL64", /* name */
b34976b6 904 FALSE, /* partial_inplace */
5bd4f169 905 0, /* src_mask */
f5e87a1d 906 ONES (64), /* dst_mask */
b34976b6 907 TRUE), /* pcrel_offset */
5bd4f169 908
cedb70c5 909 /* 64-bit relocation to the symbol's procedure linkage table. */
5bd4f169
AM		 910 HOWTO (R_PPC64_PLT64, /* type */
911 0, /* rightshift */
912 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
913 64, /* bitsize */
b34976b6 914 FALSE, /* pc_relative */
5bd4f169
AM		 915 0, /* bitpos */
916 complain_overflow_dont, /* complain_on_overflow */
805fc799 917 ppc64_elf_unhandled_reloc, /* special_function */
5bd4f169 918 "R_PPC64_PLT64", /* name */
b34976b6 919 FALSE, /* partial_inplace */
5bd4f169 920 0, /* src_mask */
f5e87a1d 921 ONES (64), /* dst_mask */
b34976b6 922 FALSE), /* pcrel_offset */
5bd4f169
AM		 923
924 /* 64-bit PC relative relocation to the symbol's procedure linkage
925 table. */
926 /* FIXME: R_PPC64_PLTREL64 not supported. */
927 HOWTO (R_PPC64_PLTREL64, /* type */
928 0, /* rightshift */
929 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
930 64, /* bitsize */
b34976b6 931 TRUE, /* pc_relative */
5bd4f169
AM		 932 0, /* bitpos */
933 complain_overflow_dont, /* complain_on_overflow */
805fc799 934 ppc64_elf_unhandled_reloc, /* special_function */
5bd4f169 935 "R_PPC64_PLTREL64", /* name */
b34976b6 936 FALSE, /* partial_inplace */
5bd4f169 937 0, /* src_mask */
f5e87a1d 938 ONES (64), /* dst_mask */
b34976b6 939 TRUE), /* pcrel_offset */
5bd4f169
AM		 940
941 /* 16 bit TOC-relative relocation. */
942
943 /* R_PPC64_TOC16 47 half16* S + A - .TOC. */
944 HOWTO (R_PPC64_TOC16, /* type */
945 0, /* rightshift */
946 1, /* size (0 = byte, 1 = short, 2 = long) */
947 16, /* bitsize */
b34976b6 948 FALSE, /* pc_relative */
5bd4f169
AM		 949 0, /* bitpos */
950 complain_overflow_signed, /* complain_on_overflow */
805fc799 951 ppc64_elf_toc_reloc, /* special_function */
5bd4f169 952 "R_PPC64_TOC16", /* name */
b34976b6 953 FALSE, /* partial_inplace */
5bd4f169
AM		 954 0, /* src_mask */
955 0xffff, /* dst_mask */
b34976b6 956 FALSE), /* pcrel_offset */
5bd4f169
AM		 957
958 /* 16 bit TOC-relative relocation without overflow. */
959
960 /* R_PPC64_TOC16_LO 48 half16 #lo (S + A - .TOC.) */
961 HOWTO (R_PPC64_TOC16_LO, /* type */
962 0, /* rightshift */
963 1, /* size (0 = byte, 1 = short, 2 = long) */
964 16, /* bitsize */
b34976b6 965 FALSE, /* pc_relative */
5bd4f169
AM		 966 0, /* bitpos */
967 complain_overflow_dont, /* complain_on_overflow */
805fc799 968 ppc64_elf_toc_reloc, /* special_function */
5bd4f169 969 "R_PPC64_TOC16_LO", /* name */
b34976b6 970 FALSE, /* partial_inplace */
5bd4f169
AM		 971 0, /* src_mask */
972 0xffff, /* dst_mask */
b34976b6 973 FALSE), /* pcrel_offset */
5bd4f169
AM		 974
975 /* 16 bit TOC-relative relocation, high 16 bits. */
976
977 /* R_PPC64_TOC16_HI 49 half16 #hi (S + A - .TOC.) */
978 HOWTO (R_PPC64_TOC16_HI, /* type */
979 16, /* rightshift */
980 1, /* size (0 = byte, 1 = short, 2 = long) */
981 16, /* bitsize */
b34976b6 982 FALSE, /* pc_relative */
5bd4f169 983 0, /* bitpos */
f9c6b907 984 complain_overflow_signed, /* complain_on_overflow */
805fc799 985 ppc64_elf_toc_reloc, /* special_function */
5bd4f169 986 "R_PPC64_TOC16_HI", /* name */
b34976b6 987 FALSE, /* partial_inplace */
5bd4f169
AM		 988 0, /* src_mask */
989 0xffff, /* dst_mask */
b34976b6 990 FALSE), /* pcrel_offset */
5bd4f169
AM		 991
992 /* 16 bit TOC-relative relocation, high 16 bits, plus 1 if the
993 contents of the low 16 bits, treated as a signed number, is
994 negative. */
995
996 /* R_PPC64_TOC16_HA 50 half16 #ha (S + A - .TOC.) */
997 HOWTO (R_PPC64_TOC16_HA, /* type */
998 16, /* rightshift */
999 1, /* size (0 = byte, 1 = short, 2 = long) */
1000 16, /* bitsize */
b34976b6 1001 FALSE, /* pc_relative */
5bd4f169 1002 0, /* bitpos */
f9c6b907 1003 complain_overflow_signed, /* complain_on_overflow */
805fc799 1004 ppc64_elf_toc_ha_reloc, /* special_function */
5bd4f169 1005 "R_PPC64_TOC16_HA", /* name */
b34976b6 1006 FALSE, /* partial_inplace */
5bd4f169
AM		 1007 0, /* src_mask */
1008 0xffff, /* dst_mask */
b34976b6 1009 FALSE), /* pcrel_offset */
5bd4f169
AM		 1010
1011 /* 64-bit relocation; insert value of TOC base (.TOC.). */
1012
1013 /* R_PPC64_TOC 51 doubleword64 .TOC. */
1014 HOWTO (R_PPC64_TOC, /* type */
1015 0, /* rightshift */
1016 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1017 64, /* bitsize */
b34976b6 1018 FALSE, /* pc_relative */
5bd4f169
AM		 1019 0, /* bitpos */
1020 complain_overflow_bitfield, /* complain_on_overflow */
805fc799 1021 ppc64_elf_toc64_reloc, /* special_function */
5bd4f169 1022 "R_PPC64_TOC", /* name */
b34976b6 1023 FALSE, /* partial_inplace */
5bd4f169 1024 0, /* src_mask */
f5e87a1d 1025 ONES (64), /* dst_mask */
b34976b6 1026 FALSE), /* pcrel_offset */
5bd4f169
AM		 1027
1028 /* Like R_PPC64_GOT16, but also informs the link editor that the
1029 value to relocate may (!) refer to a PLT entry which the link
1030 editor (a) may replace with the symbol value. If the link editor
1031 is unable to fully resolve the symbol, it may (b) create a PLT
1032 entry and store the address to the new PLT entry in the GOT.
1033 This permits lazy resolution of function symbols at run time.
1034 The link editor may also skip all of this and just (c) emit a
1035 R_PPC64_GLOB_DAT to tie the symbol to the GOT entry. */
1036 /* FIXME: R_PPC64_PLTGOT16 not implemented. */
1037 HOWTO (R_PPC64_PLTGOT16, /* type */
1038 0, /* rightshift */
1039 1, /* size (0 = byte, 1 = short, 2 = long) */
1040 16, /* bitsize */
b34976b6 1041 FALSE, /* pc_relative */
5bd4f169
AM		 1042 0, /* bitpos */
1043 complain_overflow_signed, /* complain_on_overflow */
805fc799 1044 ppc64_elf_unhandled_reloc, /* special_function */
411e1bfb
AM		 1045 "R_PPC64_PLTGOT16", /* name */
1046 FALSE, /* partial_inplace */
1047 0, /* src_mask */
1048 0xffff, /* dst_mask */
1049 FALSE), /* pcrel_offset */
1050
1051 /* Like R_PPC64_PLTGOT16, but without overflow. */
1052 /* FIXME: R_PPC64_PLTGOT16_LO not implemented. */
1053 HOWTO (R_PPC64_PLTGOT16_LO, /* type */
1054 0, /* rightshift */
1055 1, /* size (0 = byte, 1 = short, 2 = long) */
1056 16, /* bitsize */
1057 FALSE, /* pc_relative */
1058 0, /* bitpos */
1059 complain_overflow_dont, /* complain_on_overflow */
1060 ppc64_elf_unhandled_reloc, /* special_function */
1061 "R_PPC64_PLTGOT16_LO", /* name */
1062 FALSE, /* partial_inplace */
1063 0, /* src_mask */
1064 0xffff, /* dst_mask */
1065 FALSE), /* pcrel_offset */
1066
1067 /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address. */
1068 /* FIXME: R_PPC64_PLTGOT16_HI not implemented. */
1069 HOWTO (R_PPC64_PLTGOT16_HI, /* type */
1070 16, /* rightshift */
1071 1, /* size (0 = byte, 1 = short, 2 = long) */
1072 16, /* bitsize */
1073 FALSE, /* pc_relative */
1074 0, /* bitpos */
f9c6b907 1075 complain_overflow_signed, /* complain_on_overflow */
411e1bfb
AM		 1076 ppc64_elf_unhandled_reloc, /* special_function */
1077 "R_PPC64_PLTGOT16_HI", /* name */
1078 FALSE, /* partial_inplace */
1079 0, /* src_mask */
1080 0xffff, /* dst_mask */
1081 FALSE), /* pcrel_offset */
1082
1083 /* Like R_PPC64_PLT_GOT16, but using bits 16-31 of the address, plus
1084 1 if the contents of the low 16 bits, treated as a signed number,
1085 is negative. */
1086 /* FIXME: R_PPC64_PLTGOT16_HA not implemented. */
1087 HOWTO (R_PPC64_PLTGOT16_HA, /* type */
1088 16, /* rightshift */
1089 1, /* size (0 = byte, 1 = short, 2 = long) */
1090 16, /* bitsize */
1091 FALSE, /* pc_relative */
1092 0, /* bitpos */
f9c6b907 1093 complain_overflow_signed, /* complain_on_overflow */
411e1bfb
AM		 1094 ppc64_elf_unhandled_reloc, /* special_function */
1095 "R_PPC64_PLTGOT16_HA", /* name */
1096 FALSE, /* partial_inplace */
1097 0, /* src_mask */
1098 0xffff, /* dst_mask */
1099 FALSE), /* pcrel_offset */
1100
1101 /* Like R_PPC64_ADDR16, but for instructions with a DS field. */
1102 HOWTO (R_PPC64_ADDR16_DS, /* type */
1103 0, /* rightshift */
1104 1, /* size (0 = byte, 1 = short, 2 = long) */
1105 16, /* bitsize */
1106 FALSE, /* pc_relative */
1107 0, /* bitpos */
1108 complain_overflow_bitfield, /* complain_on_overflow */
1109 bfd_elf_generic_reloc, /* special_function */
1110 "R_PPC64_ADDR16_DS", /* name */
1111 FALSE, /* partial_inplace */
1112 0, /* src_mask */
1113 0xfffc, /* dst_mask */
1114 FALSE), /* pcrel_offset */
1115
1116 /* Like R_PPC64_ADDR16_LO, but for instructions with a DS field. */
1117 HOWTO (R_PPC64_ADDR16_LO_DS, /* type */
1118 0, /* rightshift */
1119 1, /* size (0 = byte, 1 = short, 2 = long) */
1120 16, /* bitsize */
1121 FALSE, /* pc_relative */
1122 0, /* bitpos */
1123 complain_overflow_dont,/* complain_on_overflow */
1124 bfd_elf_generic_reloc, /* special_function */
1125 "R_PPC64_ADDR16_LO_DS",/* name */
1126 FALSE, /* partial_inplace */
1127 0, /* src_mask */
1128 0xfffc, /* dst_mask */
1129 FALSE), /* pcrel_offset */
1130
1131 /* Like R_PPC64_GOT16, but for instructions with a DS field. */
1132 HOWTO (R_PPC64_GOT16_DS, /* type */
1133 0, /* rightshift */
1134 1, /* size (0 = byte, 1 = short, 2 = long) */
1135 16, /* bitsize */
1136 FALSE, /* pc_relative */
1137 0, /* bitpos */
1138 complain_overflow_signed, /* complain_on_overflow */
1139 ppc64_elf_unhandled_reloc, /* special_function */
1140 "R_PPC64_GOT16_DS", /* name */
1141 FALSE, /* partial_inplace */
1142 0, /* src_mask */
1143 0xfffc, /* dst_mask */
1144 FALSE), /* pcrel_offset */
1145
1146 /* Like R_PPC64_GOT16_LO, but for instructions with a DS field. */
1147 HOWTO (R_PPC64_GOT16_LO_DS, /* type */
1148 0, /* rightshift */
1149 1, /* size (0 = byte, 1 = short, 2 = long) */
1150 16, /* bitsize */
1151 FALSE, /* pc_relative */
1152 0, /* bitpos */
1153 complain_overflow_dont, /* complain_on_overflow */
1154 ppc64_elf_unhandled_reloc, /* special_function */
1155 "R_PPC64_GOT16_LO_DS", /* name */
1156 FALSE, /* partial_inplace */
1157 0, /* src_mask */
1158 0xfffc, /* dst_mask */
1159 FALSE), /* pcrel_offset */
1160
1161 /* Like R_PPC64_PLT16_LO, but for instructions with a DS field. */
1162 HOWTO (R_PPC64_PLT16_LO_DS, /* type */
1163 0, /* rightshift */
1164 1, /* size (0 = byte, 1 = short, 2 = long) */
1165 16, /* bitsize */
1166 FALSE, /* pc_relative */
1167 0, /* bitpos */
1168 complain_overflow_dont, /* complain_on_overflow */
1169 ppc64_elf_unhandled_reloc, /* special_function */
1170 "R_PPC64_PLT16_LO_DS", /* name */
1171 FALSE, /* partial_inplace */
1172 0, /* src_mask */
1173 0xfffc, /* dst_mask */
1174 FALSE), /* pcrel_offset */
1175
1176 /* Like R_PPC64_SECTOFF, but for instructions with a DS field. */
1177 HOWTO (R_PPC64_SECTOFF_DS, /* type */
1178 0, /* rightshift */
1179 1, /* size (0 = byte, 1 = short, 2 = long) */
1180 16, /* bitsize */
1181 FALSE, /* pc_relative */
1182 0, /* bitpos */
1183 complain_overflow_bitfield, /* complain_on_overflow */
1184 ppc64_elf_sectoff_reloc, /* special_function */
1185 "R_PPC64_SECTOFF_DS", /* name */
1186 FALSE, /* partial_inplace */
1187 0, /* src_mask */
1188 0xfffc, /* dst_mask */
1189 FALSE), /* pcrel_offset */
1190
1191 /* Like R_PPC64_SECTOFF_LO, but for instructions with a DS field. */
1192 HOWTO (R_PPC64_SECTOFF_LO_DS, /* type */
1193 0, /* rightshift */
1194 1, /* size (0 = byte, 1 = short, 2 = long) */
1195 16, /* bitsize */
1196 FALSE, /* pc_relative */
1197 0, /* bitpos */
1198 complain_overflow_dont, /* complain_on_overflow */
1199 ppc64_elf_sectoff_reloc, /* special_function */
1200 "R_PPC64_SECTOFF_LO_DS",/* name */
1201 FALSE, /* partial_inplace */
1202 0, /* src_mask */
1203 0xfffc, /* dst_mask */
1204 FALSE), /* pcrel_offset */
1205
1206 /* Like R_PPC64_TOC16, but for instructions with a DS field. */
1207 HOWTO (R_PPC64_TOC16_DS, /* type */
1208 0, /* rightshift */
1209 1, /* size (0 = byte, 1 = short, 2 = long) */
1210 16, /* bitsize */
1211 FALSE, /* pc_relative */
1212 0, /* bitpos */
1213 complain_overflow_signed, /* complain_on_overflow */
1214 ppc64_elf_toc_reloc, /* special_function */
1215 "R_PPC64_TOC16_DS", /* name */
1216 FALSE, /* partial_inplace */
1217 0, /* src_mask */
1218 0xfffc, /* dst_mask */
1219 FALSE), /* pcrel_offset */
1220
1221 /* Like R_PPC64_TOC16_LO, but for instructions with a DS field. */
1222 HOWTO (R_PPC64_TOC16_LO_DS, /* type */
1223 0, /* rightshift */
1224 1, /* size (0 = byte, 1 = short, 2 = long) */
1225 16, /* bitsize */
1226 FALSE, /* pc_relative */
1227 0, /* bitpos */
1228 complain_overflow_dont, /* complain_on_overflow */
1229 ppc64_elf_toc_reloc, /* special_function */
1230 "R_PPC64_TOC16_LO_DS", /* name */
1231 FALSE, /* partial_inplace */
1232 0, /* src_mask */
1233 0xfffc, /* dst_mask */
1234 FALSE), /* pcrel_offset */
1235
1236 /* Like R_PPC64_PLTGOT16, but for instructions with a DS field. */
1237 /* FIXME: R_PPC64_PLTGOT16_DS not implemented. */
6bfdb61b 1238 HOWTO (R_PPC64_PLTGOT16_DS, /* type */
411e1bfb
AM		 1239 0, /* rightshift */
1240 1, /* size (0 = byte, 1 = short, 2 = long) */
1241 16, /* bitsize */
1242 FALSE, /* pc_relative */
1243 0, /* bitpos */
1244 complain_overflow_signed, /* complain_on_overflow */
1245 ppc64_elf_unhandled_reloc, /* special_function */
1246 "R_PPC64_PLTGOT16_DS", /* name */
1247 FALSE, /* partial_inplace */
1248 0, /* src_mask */
1249 0xfffc, /* dst_mask */
1250 FALSE), /* pcrel_offset */
1251
1252 /* Like R_PPC64_PLTGOT16_LO, but for instructions with a DS field. */
1253 /* FIXME: R_PPC64_PLTGOT16_LO not implemented. */
1254 HOWTO (R_PPC64_PLTGOT16_LO_DS,/* type */
1255 0, /* rightshift */
1256 1, /* size (0 = byte, 1 = short, 2 = long) */
1257 16, /* bitsize */
1258 FALSE, /* pc_relative */
1259 0, /* bitpos */
1260 complain_overflow_dont, /* complain_on_overflow */
1261 ppc64_elf_unhandled_reloc, /* special_function */
1262 "R_PPC64_PLTGOT16_LO_DS",/* name */
1263 FALSE, /* partial_inplace */
1264 0, /* src_mask */
1265 0xfffc, /* dst_mask */
1266 FALSE), /* pcrel_offset */
1267
727fc41e 1268 /* Marker relocs for TLS. */
411e1bfb
AM		 1269 HOWTO (R_PPC64_TLS,
1270 0, /* rightshift */
1271 2, /* size (0 = byte, 1 = short, 2 = long) */
1272 32, /* bitsize */
1273 FALSE, /* pc_relative */
1274 0, /* bitpos */
1275 complain_overflow_dont, /* complain_on_overflow */
1276 bfd_elf_generic_reloc, /* special_function */
1277 "R_PPC64_TLS", /* name */
1278 FALSE, /* partial_inplace */
1279 0, /* src_mask */
1280 0, /* dst_mask */
1281 FALSE), /* pcrel_offset */
1282
727fc41e
AM		 1283 HOWTO (R_PPC64_TLSGD,
1284 0, /* rightshift */
1285 2, /* size (0 = byte, 1 = short, 2 = long) */
1286 32, /* bitsize */
1287 FALSE, /* pc_relative */
1288 0, /* bitpos */
1289 complain_overflow_dont, /* complain_on_overflow */
1290 bfd_elf_generic_reloc, /* special_function */
1291 "R_PPC64_TLSGD", /* name */
1292 FALSE, /* partial_inplace */
1293 0, /* src_mask */
1294 0, /* dst_mask */
1295 FALSE), /* pcrel_offset */
1296
1297 HOWTO (R_PPC64_TLSLD,
1298 0, /* rightshift */
1299 2, /* size (0 = byte, 1 = short, 2 = long) */
1300 32, /* bitsize */
1301 FALSE, /* pc_relative */
1302 0, /* bitpos */
1303 complain_overflow_dont, /* complain_on_overflow */
1304 bfd_elf_generic_reloc, /* special_function */
1305 "R_PPC64_TLSLD", /* name */
1306 FALSE, /* partial_inplace */
1307 0, /* src_mask */
1308 0, /* dst_mask */
1309 FALSE), /* pcrel_offset */
1310
3b421ab3
AM		 1311 HOWTO (R_PPC64_TOCSAVE,
1312 0, /* rightshift */
1313 2, /* size (0 = byte, 1 = short, 2 = long) */
1314 32, /* bitsize */
1315 FALSE, /* pc_relative */
1316 0, /* bitpos */
1317 complain_overflow_dont, /* complain_on_overflow */
1318 bfd_elf_generic_reloc, /* special_function */
1319 "R_PPC64_TOCSAVE", /* name */
1320 FALSE, /* partial_inplace */
1321 0, /* src_mask */
1322 0, /* dst_mask */
1323 FALSE), /* pcrel_offset */
1324
411e1bfb
AM		 1325 /* Computes the load module index of the load module that contains the
1326 definition of its TLS sym. */
1327 HOWTO (R_PPC64_DTPMOD64,
1328 0, /* rightshift */
1329 4, /* size (0 = byte, 1 = short, 2 = long) */
1330 64, /* bitsize */
1331 FALSE, /* pc_relative */
1332 0, /* bitpos */
1333 complain_overflow_dont, /* complain_on_overflow */
1334 ppc64_elf_unhandled_reloc, /* special_function */
1335 "R_PPC64_DTPMOD64", /* name */
1336 FALSE, /* partial_inplace */
1337 0, /* src_mask */
1338 ONES (64), /* dst_mask */
1339 FALSE), /* pcrel_offset */
1340
1341 /* Computes a dtv-relative displacement, the difference between the value
1342 of sym+add and the base address of the thread-local storage block that
1343 contains the definition of sym, minus 0x8000. */
1344 HOWTO (R_PPC64_DTPREL64,
1345 0, /* rightshift */
1346 4, /* size (0 = byte, 1 = short, 2 = long) */
1347 64, /* bitsize */
1348 FALSE, /* pc_relative */
1349 0, /* bitpos */
1350 complain_overflow_dont, /* complain_on_overflow */
1351 ppc64_elf_unhandled_reloc, /* special_function */
1352 "R_PPC64_DTPREL64", /* name */
1353 FALSE, /* partial_inplace */
1354 0, /* src_mask */
1355 ONES (64), /* dst_mask */
1356 FALSE), /* pcrel_offset */
1357
1358 /* A 16 bit dtprel reloc. */
1359 HOWTO (R_PPC64_DTPREL16,
1360 0, /* rightshift */
1361 1, /* size (0 = byte, 1 = short, 2 = long) */
1362 16, /* bitsize */
1363 FALSE, /* pc_relative */
1364 0, /* bitpos */
1365 complain_overflow_signed, /* complain_on_overflow */
1366 ppc64_elf_unhandled_reloc, /* special_function */
1367 "R_PPC64_DTPREL16", /* name */
1368 FALSE, /* partial_inplace */
1369 0, /* src_mask */
1370 0xffff, /* dst_mask */
1371 FALSE), /* pcrel_offset */
1372
1373 /* Like DTPREL16, but no overflow. */
1374 HOWTO (R_PPC64_DTPREL16_LO,
1375 0, /* rightshift */
1376 1, /* size (0 = byte, 1 = short, 2 = long) */
1377 16, /* bitsize */
1378 FALSE, /* pc_relative */
1379 0, /* bitpos */
1380 complain_overflow_dont, /* complain_on_overflow */
1381 ppc64_elf_unhandled_reloc, /* special_function */
1382 "R_PPC64_DTPREL16_LO", /* name */
1383 FALSE, /* partial_inplace */
1384 0, /* src_mask */
1385 0xffff, /* dst_mask */
1386 FALSE), /* pcrel_offset */
1387
1388 /* Like DTPREL16_LO, but next higher group of 16 bits. */
1389 HOWTO (R_PPC64_DTPREL16_HI,
1390 16, /* rightshift */
1391 1, /* size (0 = byte, 1 = short, 2 = long) */
1392 16, /* bitsize */
1393 FALSE, /* pc_relative */
1394 0, /* bitpos */
f9c6b907 1395 complain_overflow_signed, /* complain_on_overflow */
411e1bfb
AM		 1396 ppc64_elf_unhandled_reloc, /* special_function */
1397 "R_PPC64_DTPREL16_HI", /* name */
1398 FALSE, /* partial_inplace */
1399 0, /* src_mask */
1400 0xffff, /* dst_mask */
1401 FALSE), /* pcrel_offset */
1402
1403 /* Like DTPREL16_HI, but adjust for low 16 bits. */
1404 HOWTO (R_PPC64_DTPREL16_HA,
1405 16, /* rightshift */
1406 1, /* size (0 = byte, 1 = short, 2 = long) */
1407 16, /* bitsize */
1408 FALSE, /* pc_relative */
1409 0, /* bitpos */
f9c6b907 1410 complain_overflow_signed, /* complain_on_overflow */
411e1bfb
AM		 1411 ppc64_elf_unhandled_reloc, /* special_function */
1412 "R_PPC64_DTPREL16_HA", /* name */
1413 FALSE, /* partial_inplace */
1414 0, /* src_mask */
1415 0xffff, /* dst_mask */
1416 FALSE), /* pcrel_offset */
1417
1418 /* Like DTPREL16_HI, but next higher group of 16 bits. */
1419 HOWTO (R_PPC64_DTPREL16_HIGHER,
1420 32, /* rightshift */
1421 1, /* size (0 = byte, 1 = short, 2 = long) */
1422 16, /* bitsize */
1423 FALSE, /* pc_relative */
1424 0, /* bitpos */
1425 complain_overflow_dont, /* complain_on_overflow */
1426 ppc64_elf_unhandled_reloc, /* special_function */
1427 "R_PPC64_DTPREL16_HIGHER", /* name */
1428 FALSE, /* partial_inplace */
1429 0, /* src_mask */
1430 0xffff, /* dst_mask */
1431 FALSE), /* pcrel_offset */
1432
1433 /* Like DTPREL16_HIGHER, but adjust for low 16 bits. */
1434 HOWTO (R_PPC64_DTPREL16_HIGHERA,
1435 32, /* rightshift */
1436 1, /* size (0 = byte, 1 = short, 2 = long) */
1437 16, /* bitsize */
1438 FALSE, /* pc_relative */
1439 0, /* bitpos */
1440 complain_overflow_dont, /* complain_on_overflow */
1441 ppc64_elf_unhandled_reloc, /* special_function */
1442 "R_PPC64_DTPREL16_HIGHERA", /* name */
1443 FALSE, /* partial_inplace */
1444 0, /* src_mask */
1445 0xffff, /* dst_mask */
1446 FALSE), /* pcrel_offset */
1447
1448 /* Like DTPREL16_HIGHER, but next higher group of 16 bits. */
1449 HOWTO (R_PPC64_DTPREL16_HIGHEST,
1450 48, /* rightshift */
1451 1, /* size (0 = byte, 1 = short, 2 = long) */
1452 16, /* bitsize */
1453 FALSE, /* pc_relative */
1454 0, /* bitpos */
1455 complain_overflow_dont, /* complain_on_overflow */
1456 ppc64_elf_unhandled_reloc, /* special_function */
1457 "R_PPC64_DTPREL16_HIGHEST", /* name */
1458 FALSE, /* partial_inplace */
1459 0, /* src_mask */
1460 0xffff, /* dst_mask */
1461 FALSE), /* pcrel_offset */
1462
1463 /* Like DTPREL16_HIGHEST, but adjust for low 16 bits. */
1464 HOWTO (R_PPC64_DTPREL16_HIGHESTA,
1465 48, /* rightshift */
1466 1, /* size (0 = byte, 1 = short, 2 = long) */
1467 16, /* bitsize */
1468 FALSE, /* pc_relative */
1469 0, /* bitpos */
1470 complain_overflow_dont, /* complain_on_overflow */
1471 ppc64_elf_unhandled_reloc, /* special_function */
1472 "R_PPC64_DTPREL16_HIGHESTA", /* name */
1473 FALSE, /* partial_inplace */
1474 0, /* src_mask */
1475 0xffff, /* dst_mask */
1476 FALSE), /* pcrel_offset */
1477
1478 /* Like DTPREL16, but for insns with a DS field. */
1479 HOWTO (R_PPC64_DTPREL16_DS,
1480 0, /* rightshift */
1481 1, /* size (0 = byte, 1 = short, 2 = long) */
1482 16, /* bitsize */
1483 FALSE, /* pc_relative */
1484 0, /* bitpos */
1485 complain_overflow_signed, /* complain_on_overflow */
1486 ppc64_elf_unhandled_reloc, /* special_function */
1487 "R_PPC64_DTPREL16_DS", /* name */
1488 FALSE, /* partial_inplace */
1489 0, /* src_mask */
1490 0xfffc, /* dst_mask */
1491 FALSE), /* pcrel_offset */
1492
1493 /* Like DTPREL16_DS, but no overflow. */
1494 HOWTO (R_PPC64_DTPREL16_LO_DS,
1495 0, /* rightshift */
1496 1, /* size (0 = byte, 1 = short, 2 = long) */
1497 16, /* bitsize */
1498 FALSE, /* pc_relative */
1499 0, /* bitpos */
1500 complain_overflow_dont, /* complain_on_overflow */
1501 ppc64_elf_unhandled_reloc, /* special_function */
1502 "R_PPC64_DTPREL16_LO_DS", /* name */
1503 FALSE, /* partial_inplace */
1504 0, /* src_mask */
1505 0xfffc, /* dst_mask */
1506 FALSE), /* pcrel_offset */
1507
1508 /* Computes a tp-relative displacement, the difference between the value of
1509 sym+add and the value of the thread pointer (r13). */
1510 HOWTO (R_PPC64_TPREL64,
1511 0, /* rightshift */
1512 4, /* size (0 = byte, 1 = short, 2 = long) */
1513 64, /* bitsize */
1514 FALSE, /* pc_relative */
1515 0, /* bitpos */
1516 complain_overflow_dont, /* complain_on_overflow */
1517 ppc64_elf_unhandled_reloc, /* special_function */
1518 "R_PPC64_TPREL64", /* name */
1519 FALSE, /* partial_inplace */
1520 0, /* src_mask */
1521 ONES (64), /* dst_mask */
1522 FALSE), /* pcrel_offset */
1523
1524 /* A 16 bit tprel reloc. */
1525 HOWTO (R_PPC64_TPREL16,
1526 0, /* rightshift */
1527 1, /* size (0 = byte, 1 = short, 2 = long) */
1528 16, /* bitsize */
1529 FALSE, /* pc_relative */
1530 0, /* bitpos */
1531 complain_overflow_signed, /* complain_on_overflow */
1532 ppc64_elf_unhandled_reloc, /* special_function */
1533 "R_PPC64_TPREL16", /* name */
1534 FALSE, /* partial_inplace */
1535 0, /* src_mask */
1536 0xffff, /* dst_mask */
1537 FALSE), /* pcrel_offset */
1538
1539 /* Like TPREL16, but no overflow. */
1540 HOWTO (R_PPC64_TPREL16_LO,
1541 0, /* rightshift */
1542 1, /* size (0 = byte, 1 = short, 2 = long) */
1543 16, /* bitsize */
1544 FALSE, /* pc_relative */
1545 0, /* bitpos */
1546 complain_overflow_dont, /* complain_on_overflow */
1547 ppc64_elf_unhandled_reloc, /* special_function */
1548 "R_PPC64_TPREL16_LO", /* name */
1549 FALSE, /* partial_inplace */
1550 0, /* src_mask */
1551 0xffff, /* dst_mask */
1552 FALSE), /* pcrel_offset */
1553
1554 /* Like TPREL16_LO, but next higher group of 16 bits. */
1555 HOWTO (R_PPC64_TPREL16_HI,
1556 16, /* rightshift */
1557 1, /* size (0 = byte, 1 = short, 2 = long) */
1558 16, /* bitsize */
1559 FALSE, /* pc_relative */
1560 0, /* bitpos */
f9c6b907 1561 complain_overflow_signed, /* complain_on_overflow */
411e1bfb
AM		 1562 ppc64_elf_unhandled_reloc, /* special_function */
1563 "R_PPC64_TPREL16_HI", /* name */
1564 FALSE, /* partial_inplace */
1565 0, /* src_mask */
1566 0xffff, /* dst_mask */
1567 FALSE), /* pcrel_offset */
1568
1569 /* Like TPREL16_HI, but adjust for low 16 bits. */
1570 HOWTO (R_PPC64_TPREL16_HA,
1571 16, /* rightshift */
1572 1, /* size (0 = byte, 1 = short, 2 = long) */
1573 16, /* bitsize */
1574 FALSE, /* pc_relative */
1575 0, /* bitpos */
f9c6b907 1576 complain_overflow_signed, /* complain_on_overflow */
411e1bfb
AM		 1577 ppc64_elf_unhandled_reloc, /* special_function */
1578 "R_PPC64_TPREL16_HA", /* name */
1579 FALSE, /* partial_inplace */
1580 0, /* src_mask */
1581 0xffff, /* dst_mask */
1582 FALSE), /* pcrel_offset */
1583
1584 /* Like TPREL16_HI, but next higher group of 16 bits. */
1585 HOWTO (R_PPC64_TPREL16_HIGHER,
1586 32, /* rightshift */
1587 1, /* size (0 = byte, 1 = short, 2 = long) */
1588 16, /* bitsize */
1589 FALSE, /* pc_relative */
1590 0, /* bitpos */
1591 complain_overflow_dont, /* complain_on_overflow */
1592 ppc64_elf_unhandled_reloc, /* special_function */
1593 "R_PPC64_TPREL16_HIGHER", /* name */
1594 FALSE, /* partial_inplace */
1595 0, /* src_mask */
1596 0xffff, /* dst_mask */
1597 FALSE), /* pcrel_offset */
1598
1599 /* Like TPREL16_HIGHER, but adjust for low 16 bits. */
1600 HOWTO (R_PPC64_TPREL16_HIGHERA,
1601 32, /* rightshift */
1602 1, /* size (0 = byte, 1 = short, 2 = long) */
1603 16, /* bitsize */
1604 FALSE, /* pc_relative */
1605 0, /* bitpos */
1606 complain_overflow_dont, /* complain_on_overflow */
1607 ppc64_elf_unhandled_reloc, /* special_function */
1608 "R_PPC64_TPREL16_HIGHERA", /* name */
1609 FALSE, /* partial_inplace */
1610 0, /* src_mask */
1611 0xffff, /* dst_mask */
1612 FALSE), /* pcrel_offset */
1613
1614 /* Like TPREL16_HIGHER, but next higher group of 16 bits. */
1615 HOWTO (R_PPC64_TPREL16_HIGHEST,
1616 48, /* rightshift */
1617 1, /* size (0 = byte, 1 = short, 2 = long) */
1618 16, /* bitsize */
1619 FALSE, /* pc_relative */
1620 0, /* bitpos */
1621 complain_overflow_dont, /* complain_on_overflow */
1622 ppc64_elf_unhandled_reloc, /* special_function */
1623 "R_PPC64_TPREL16_HIGHEST", /* name */
1624 FALSE, /* partial_inplace */
1625 0, /* src_mask */
1626 0xffff, /* dst_mask */
1627 FALSE), /* pcrel_offset */
1628
1629 /* Like TPREL16_HIGHEST, but adjust for low 16 bits. */
1630 HOWTO (R_PPC64_TPREL16_HIGHESTA,
1631 48, /* rightshift */
1632 1, /* size (0 = byte, 1 = short, 2 = long) */
1633 16, /* bitsize */
1634 FALSE, /* pc_relative */
1635 0, /* bitpos */
1636 complain_overflow_dont, /* complain_on_overflow */
1637 ppc64_elf_unhandled_reloc, /* special_function */
1638 "R_PPC64_TPREL16_HIGHESTA", /* name */
1639 FALSE, /* partial_inplace */
1640 0, /* src_mask */
1641 0xffff, /* dst_mask */
1642 FALSE), /* pcrel_offset */
1643
1644 /* Like TPREL16, but for insns with a DS field. */
1645 HOWTO (R_PPC64_TPREL16_DS,
1646 0, /* rightshift */
1647 1, /* size (0 = byte, 1 = short, 2 = long) */
1648 16, /* bitsize */
1649 FALSE, /* pc_relative */
1650 0, /* bitpos */
1651 complain_overflow_signed, /* complain_on_overflow */
1652 ppc64_elf_unhandled_reloc, /* special_function */
1653 "R_PPC64_TPREL16_DS", /* name */
1654 FALSE, /* partial_inplace */
1655 0, /* src_mask */
1656 0xfffc, /* dst_mask */
1657 FALSE), /* pcrel_offset */
1658
1659 /* Like TPREL16_DS, but no overflow. */
1660 HOWTO (R_PPC64_TPREL16_LO_DS,
1661 0, /* rightshift */
1662 1, /* size (0 = byte, 1 = short, 2 = long) */
1663 16, /* bitsize */
1664 FALSE, /* pc_relative */
1665 0, /* bitpos */
1666 complain_overflow_dont, /* complain_on_overflow */
1667 ppc64_elf_unhandled_reloc, /* special_function */
1668 "R_PPC64_TPREL16_LO_DS", /* name */
1669 FALSE, /* partial_inplace */
1670 0, /* src_mask */
1671 0xfffc, /* dst_mask */
1672 FALSE), /* pcrel_offset */
1673
1674 /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1675 with values (sym+add)@dtpmod and (sym+add)@dtprel, and computes the offset
1676 to the first entry relative to the TOC base (r2). */
1677 HOWTO (R_PPC64_GOT_TLSGD16,
1678 0, /* rightshift */
1679 1, /* size (0 = byte, 1 = short, 2 = long) */
1680 16, /* bitsize */
1681 FALSE, /* pc_relative */
1682 0, /* bitpos */
1683 complain_overflow_signed, /* complain_on_overflow */
1684 ppc64_elf_unhandled_reloc, /* special_function */
1685 "R_PPC64_GOT_TLSGD16", /* name */
b34976b6 1686 FALSE, /* partial_inplace */
5bd4f169
AM		 1687 0, /* src_mask */
1688 0xffff, /* dst_mask */
b34976b6 1689 FALSE), /* pcrel_offset */
5bd4f169 1690
411e1bfb
AM		 1691 /* Like GOT_TLSGD16, but no overflow. */
1692 HOWTO (R_PPC64_GOT_TLSGD16_LO,
5bd4f169
AM		 1693 0, /* rightshift */
1694 1, /* size (0 = byte, 1 = short, 2 = long) */
1695 16, /* bitsize */
b34976b6 1696 FALSE, /* pc_relative */
5bd4f169
AM		 1697 0, /* bitpos */
1698 complain_overflow_dont, /* complain_on_overflow */
805fc799 1699 ppc64_elf_unhandled_reloc, /* special_function */
411e1bfb 1700 "R_PPC64_GOT_TLSGD16_LO", /* name */
b34976b6 1701 FALSE, /* partial_inplace */
5bd4f169
AM		 1702 0, /* src_mask */
1703 0xffff, /* dst_mask */
b34976b6 1704 FALSE), /* pcrel_offset */
5bd4f169 1705
411e1bfb
AM		 1706 /* Like GOT_TLSGD16_LO, but next higher group of 16 bits. */
1707 HOWTO (R_PPC64_GOT_TLSGD16_HI,
5bd4f169
AM		 1708 16, /* rightshift */
1709 1, /* size (0 = byte, 1 = short, 2 = long) */
1710 16, /* bitsize */
b34976b6 1711 FALSE, /* pc_relative */
5bd4f169 1712 0, /* bitpos */
f9c6b907 1713 complain_overflow_signed, /* complain_on_overflow */
805fc799 1714 ppc64_elf_unhandled_reloc, /* special_function */
411e1bfb 1715 "R_PPC64_GOT_TLSGD16_HI", /* name */
b34976b6 1716 FALSE, /* partial_inplace */
5bd4f169
AM		 1717 0, /* src_mask */
1718 0xffff, /* dst_mask */
b34976b6 1719 FALSE), /* pcrel_offset */
5bd4f169 1720
411e1bfb
AM		 1721 /* Like GOT_TLSGD16_HI, but adjust for low 16 bits. */
1722 HOWTO (R_PPC64_GOT_TLSGD16_HA,
5bd4f169
AM		 1723 16, /* rightshift */
1724 1, /* size (0 = byte, 1 = short, 2 = long) */
1725 16, /* bitsize */
b34976b6 1726 FALSE, /* pc_relative */
5bd4f169 1727 0, /* bitpos */
f9c6b907 1728 complain_overflow_signed, /* complain_on_overflow */
805fc799 1729 ppc64_elf_unhandled_reloc, /* special_function */
411e1bfb 1730 "R_PPC64_GOT_TLSGD16_HA", /* name */
b34976b6 1731 FALSE, /* partial_inplace */
5bd4f169
AM		 1732 0, /* src_mask */
1733 0xffff, /* dst_mask */
b34976b6 1734 FALSE), /* pcrel_offset */
5bd4f169 1735
411e1bfb
AM		 1736 /* Allocates two contiguous entries in the GOT to hold a tls_index structure,
1737 with values (sym+add)@dtpmod and zero, and computes the offset to the
1738 first entry relative to the TOC base (r2). */
1739 HOWTO (R_PPC64_GOT_TLSLD16,
5bd4f169
AM		 1740 0, /* rightshift */
1741 1, /* size (0 = byte, 1 = short, 2 = long) */
1742 16, /* bitsize */
b34976b6 1743 FALSE, /* pc_relative */
5bd4f169 1744 0, /* bitpos */
411e1bfb
AM		 1745 complain_overflow_signed, /* complain_on_overflow */
1746 ppc64_elf_unhandled_reloc, /* special_function */
1747 "R_PPC64_GOT_TLSLD16", /* name */
b34976b6 1748 FALSE, /* partial_inplace */
d006db6c 1749 0, /* src_mask */
411e1bfb 1750 0xffff, /* dst_mask */
b34976b6 1751 FALSE), /* pcrel_offset */
5bd4f169 1752
411e1bfb
AM		 1753 /* Like GOT_TLSLD16, but no overflow. */
1754 HOWTO (R_PPC64_GOT_TLSLD16_LO,
5bd4f169
AM		 1755 0, /* rightshift */
1756 1, /* size (0 = byte, 1 = short, 2 = long) */
1757 16, /* bitsize */
b34976b6 1758 FALSE, /* pc_relative */
5bd4f169 1759 0, /* bitpos */
411e1bfb
AM		 1760 complain_overflow_dont, /* complain_on_overflow */
1761 ppc64_elf_unhandled_reloc, /* special_function */
1762 "R_PPC64_GOT_TLSLD16_LO", /* name */
b34976b6 1763 FALSE, /* partial_inplace */
d006db6c 1764 0, /* src_mask */
411e1bfb 1765 0xffff, /* dst_mask */
b34976b6 1766 FALSE), /* pcrel_offset */
5bd4f169 1767
411e1bfb
AM		 1768 /* Like GOT_TLSLD16_LO, but next higher group of 16 bits. */
1769 HOWTO (R_PPC64_GOT_TLSLD16_HI,
1770 16, /* rightshift */
5bd4f169
AM		 1771 1, /* size (0 = byte, 1 = short, 2 = long) */
1772 16, /* bitsize */
b34976b6 1773 FALSE, /* pc_relative */
5bd4f169 1774 0, /* bitpos */
f9c6b907 1775 complain_overflow_signed, /* complain_on_overflow */
805fc799 1776 ppc64_elf_unhandled_reloc, /* special_function */
411e1bfb 1777 "R_PPC64_GOT_TLSLD16_HI", /* name */
b34976b6 1778 FALSE, /* partial_inplace */
d006db6c 1779 0, /* src_mask */
411e1bfb 1780 0xffff, /* dst_mask */
b34976b6 1781 FALSE), /* pcrel_offset */
5bd4f169 1782
411e1bfb
AM		 1783 /* Like GOT_TLSLD16_HI, but adjust for low 16 bits. */
1784 HOWTO (R_PPC64_GOT_TLSLD16_HA,
1785 16, /* rightshift */
5bd4f169
AM		 1786 1, /* size (0 = byte, 1 = short, 2 = long) */
1787 16, /* bitsize */
b34976b6 1788 FALSE, /* pc_relative */
5bd4f169 1789 0, /* bitpos */
f9c6b907 1790 complain_overflow_signed, /* complain_on_overflow */
805fc799 1791 ppc64_elf_unhandled_reloc, /* special_function */
411e1bfb 1792 "R_PPC64_GOT_TLSLD16_HA", /* name */
b34976b6 1793 FALSE, /* partial_inplace */
d006db6c 1794 0, /* src_mask */
411e1bfb 1795 0xffff, /* dst_mask */
b34976b6 1796 FALSE), /* pcrel_offset */
5bd4f169 1797
411e1bfb
AM		 1798 /* Allocates an entry in the GOT with value (sym+add)@dtprel, and computes
1799 the offset to the entry relative to the TOC base (r2). */
1800 HOWTO (R_PPC64_GOT_DTPREL16_DS,
5bd4f169
AM		 1801 0, /* rightshift */
1802 1, /* size (0 = byte, 1 = short, 2 = long) */
1803 16, /* bitsize */
b34976b6 1804 FALSE, /* pc_relative */
5bd4f169 1805 0, /* bitpos */
411e1bfb 1806 complain_overflow_signed, /* complain_on_overflow */
805fc799 1807 ppc64_elf_unhandled_reloc, /* special_function */
411e1bfb 1808 "R_PPC64_GOT_DTPREL16_DS", /* name */
b34976b6 1809 FALSE, /* partial_inplace */
d006db6c 1810 0, /* src_mask */
5bd4f169 1811 0xfffc, /* dst_mask */
b34976b6 1812 FALSE), /* pcrel_offset */
5bd4f169 1813
411e1bfb
AM		 1814 /* Like GOT_DTPREL16_DS, but no overflow. */
1815 HOWTO (R_PPC64_GOT_DTPREL16_LO_DS,
5bd4f169 1816 0, /* rightshift */
c061c2d8
AM		 1817 1, /* size (0 = byte, 1 = short, 2 = long) */
1818 16, /* bitsize */
b34976b6 1819 FALSE, /* pc_relative */
5bd4f169 1820 0, /* bitpos */
411e1bfb
AM		 1821 complain_overflow_dont, /* complain_on_overflow */
1822 ppc64_elf_unhandled_reloc, /* special_function */
1823 "R_PPC64_GOT_DTPREL16_LO_DS", /* name */
b34976b6 1824 FALSE, /* partial_inplace */
d006db6c 1825 0, /* src_mask */
c061c2d8 1826 0xfffc, /* dst_mask */
b34976b6 1827 FALSE), /* pcrel_offset */
5bd4f169 1828
411e1bfb
AM		 1829 /* Like GOT_DTPREL16_LO_DS, but next higher group of 16 bits. */
1830 HOWTO (R_PPC64_GOT_DTPREL16_HI,
1831 16, /* rightshift */
5bd4f169
AM		 1832 1, /* size (0 = byte, 1 = short, 2 = long) */
1833 16, /* bitsize */
b34976b6 1834 FALSE, /* pc_relative */
5bd4f169 1835 0, /* bitpos */
f9c6b907 1836 complain_overflow_signed, /* complain_on_overflow */
411e1bfb
AM		 1837 ppc64_elf_unhandled_reloc, /* special_function */
1838 "R_PPC64_GOT_DTPREL16_HI", /* name */
b34976b6 1839 FALSE, /* partial_inplace */
d006db6c 1840 0, /* src_mask */
411e1bfb 1841 0xffff, /* dst_mask */
b34976b6 1842 FALSE), /* pcrel_offset */
5bd4f169 1843
411e1bfb
AM		 1844 /* Like GOT_DTPREL16_HI, but adjust for low 16 bits. */
1845 HOWTO (R_PPC64_GOT_DTPREL16_HA,
1846 16, /* rightshift */
1847 1, /* size (0 = byte, 1 = short, 2 = long) */
1848 16, /* bitsize */
1849 FALSE, /* pc_relative */
1850 0, /* bitpos */
f9c6b907 1851 complain_overflow_signed, /* complain_on_overflow */
411e1bfb
AM		 1852 ppc64_elf_unhandled_reloc, /* special_function */
1853 "R_PPC64_GOT_DTPREL16_HA", /* name */
1854 FALSE, /* partial_inplace */
1855 0, /* src_mask */
1856 0xffff, /* dst_mask */
1857 FALSE), /* pcrel_offset */
1858
1859 /* Allocates an entry in the GOT with value (sym+add)@tprel, and computes the
1860 offset to the entry relative to the TOC base (r2). */
1861 HOWTO (R_PPC64_GOT_TPREL16_DS,
5bd4f169
AM		 1862 0, /* rightshift */
1863 1, /* size (0 = byte, 1 = short, 2 = long) */
1864 16, /* bitsize */
b34976b6 1865 FALSE, /* pc_relative */
5bd4f169
AM		 1866 0, /* bitpos */
1867 complain_overflow_signed, /* complain_on_overflow */
411e1bfb
AM		 1868 ppc64_elf_unhandled_reloc, /* special_function */
1869 "R_PPC64_GOT_TPREL16_DS", /* name */
b34976b6 1870 FALSE, /* partial_inplace */
d006db6c 1871 0, /* src_mask */
ad8e1ba5 1872 0xfffc, /* dst_mask */
b34976b6 1873 FALSE), /* pcrel_offset */
5bd4f169 1874
411e1bfb
AM		 1875 /* Like GOT_TPREL16_DS, but no overflow. */
1876 HOWTO (R_PPC64_GOT_TPREL16_LO_DS,
5bd4f169
AM		 1877 0, /* rightshift */
1878 1, /* size (0 = byte, 1 = short, 2 = long) */
1879 16, /* bitsize */
b34976b6 1880 FALSE, /* pc_relative */
5bd4f169
AM		 1881 0, /* bitpos */
1882 complain_overflow_dont, /* complain_on_overflow */
411e1bfb
AM		 1883 ppc64_elf_unhandled_reloc, /* special_function */
1884 "R_PPC64_GOT_TPREL16_LO_DS", /* name */
b34976b6 1885 FALSE, /* partial_inplace */
d006db6c 1886 0, /* src_mask */
ad8e1ba5 1887 0xfffc, /* dst_mask */
b34976b6 1888 FALSE), /* pcrel_offset */
5bd4f169 1889
411e1bfb
AM		 1890 /* Like GOT_TPREL16_LO_DS, but next higher group of 16 bits. */
1891 HOWTO (R_PPC64_GOT_TPREL16_HI,
1892 16, /* rightshift */
5bd4f169
AM		 1893 1, /* size (0 = byte, 1 = short, 2 = long) */
1894 16, /* bitsize */
b34976b6 1895 FALSE, /* pc_relative */
5bd4f169 1896 0, /* bitpos */
f9c6b907 1897 complain_overflow_signed, /* complain_on_overflow */
805fc799 1898 ppc64_elf_unhandled_reloc, /* special_function */
411e1bfb 1899 "R_PPC64_GOT_TPREL16_HI", /* name */
b34976b6 1900 FALSE, /* partial_inplace */
d006db6c 1901 0, /* src_mask */
411e1bfb 1902 0xffff, /* dst_mask */
b34976b6 1903 FALSE), /* pcrel_offset */
5bd4f169 1904
411e1bfb
AM		 1905 /* Like GOT_TPREL16_HI, but adjust for low 16 bits. */
1906 HOWTO (R_PPC64_GOT_TPREL16_HA,
1907 16, /* rightshift */
5bd4f169
AM		 1908 1, /* size (0 = byte, 1 = short, 2 = long) */
1909 16, /* bitsize */
b34976b6 1910 FALSE, /* pc_relative */
5bd4f169 1911 0, /* bitpos */
f9c6b907 1912 complain_overflow_signed, /* complain_on_overflow */
805fc799 1913 ppc64_elf_unhandled_reloc, /* special_function */
411e1bfb 1914 "R_PPC64_GOT_TPREL16_HA", /* name */
b34976b6 1915 FALSE, /* partial_inplace */
d006db6c 1916 0, /* src_mask */
411e1bfb 1917 0xffff, /* dst_mask */
b34976b6 1918 FALSE), /* pcrel_offset */
5bd4f169 1919
25f23106
AM		 1920 HOWTO (R_PPC64_JMP_IREL, /* type */
1921 0, /* rightshift */
1922 0, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1923 0, /* bitsize */
1924 FALSE, /* pc_relative */
1925 0, /* bitpos */
1926 complain_overflow_dont, /* complain_on_overflow */
1927 ppc64_elf_unhandled_reloc, /* special_function */
1928 "R_PPC64_JMP_IREL", /* name */
1929 FALSE, /* partial_inplace */
1930 0, /* src_mask */
1931 0, /* dst_mask */
1932 FALSE), /* pcrel_offset */
1933
e054468f
AM		 1934 HOWTO (R_PPC64_IRELATIVE, /* type */
1935 0, /* rightshift */
1936 4, /* size (0=byte, 1=short, 2=long, 4=64 bits) */
1937 64, /* bitsize */
1938 FALSE, /* pc_relative */
1939 0, /* bitpos */
1940 complain_overflow_dont, /* complain_on_overflow */
1941 bfd_elf_generic_reloc, /* special_function */
1942 "R_PPC64_IRELATIVE", /* name */
1943 FALSE, /* partial_inplace */
1944 0, /* src_mask */
1945 ONES (64), /* dst_mask */
1946 FALSE), /* pcrel_offset */
1947
25f23106
AM		 1948 /* A 16 bit relative relocation. */
1949 HOWTO (R_PPC64_REL16, /* type */
1950 0, /* rightshift */
1951 1, /* size (0 = byte, 1 = short, 2 = long) */
1952 16, /* bitsize */
1953 TRUE, /* pc_relative */
1954 0, /* bitpos */
1955 complain_overflow_bitfield, /* complain_on_overflow */
1956 bfd_elf_generic_reloc, /* special_function */
1957 "R_PPC64_REL16", /* name */
1958 FALSE, /* partial_inplace */
1959 0, /* src_mask */
1960 0xffff, /* dst_mask */
1961 TRUE), /* pcrel_offset */
1962
1963 /* A 16 bit relative relocation without overflow. */
1964 HOWTO (R_PPC64_REL16_LO, /* type */
1965 0, /* rightshift */
1966 1, /* size (0 = byte, 1 = short, 2 = long) */
1967 16, /* bitsize */
1968 TRUE, /* pc_relative */
1969 0, /* bitpos */
1970 complain_overflow_dont,/* complain_on_overflow */
1971 bfd_elf_generic_reloc, /* special_function */
1972 "R_PPC64_REL16_LO", /* name */
1973 FALSE, /* partial_inplace */
1974 0, /* src_mask */
1975 0xffff, /* dst_mask */
1976 TRUE), /* pcrel_offset */
1977
1978 /* The high order 16 bits of a relative address. */
1979 HOWTO (R_PPC64_REL16_HI, /* type */
1980 16, /* rightshift */
1981 1, /* size (0 = byte, 1 = short, 2 = long) */
1982 16, /* bitsize */
1983 TRUE, /* pc_relative */
1984 0, /* bitpos */
f9c6b907 1985 complain_overflow_signed, /* complain_on_overflow */
25f23106
AM		 1986 bfd_elf_generic_reloc, /* special_function */
1987 "R_PPC64_REL16_HI", /* name */
1988 FALSE, /* partial_inplace */
1989 0, /* src_mask */
1990 0xffff, /* dst_mask */
1991 TRUE), /* pcrel_offset */
1992
1993 /* The high order 16 bits of a relative address, plus 1 if the contents of
1994 the low 16 bits, treated as a signed number, is negative. */
1995 HOWTO (R_PPC64_REL16_HA, /* type */
1996 16, /* rightshift */
1997 1, /* size (0 = byte, 1 = short, 2 = long) */
1998 16, /* bitsize */
1999 TRUE, /* pc_relative */
2000 0, /* bitpos */
f9c6b907 2001 complain_overflow_signed, /* complain_on_overflow */
25f23106
AM		 2002 ppc64_elf_ha_reloc, /* special_function */
2003 "R_PPC64_REL16_HA", /* name */
2004 FALSE, /* partial_inplace */
2005 0, /* src_mask */
2006 0xffff, /* dst_mask */
2007 TRUE), /* pcrel_offset */
2008
f9c6b907
AM		 2009 /* Like R_PPC64_ADDR16_HI, but no overflow. */
2010 HOWTO (R_PPC64_ADDR16_HIGH, /* type */
2011 16, /* rightshift */
2012 1, /* size (0 = byte, 1 = short, 2 = long) */
2013 16, /* bitsize */
2014 FALSE, /* pc_relative */
2015 0, /* bitpos */
2016 complain_overflow_dont, /* complain_on_overflow */
2017 bfd_elf_generic_reloc, /* special_function */
2018 "R_PPC64_ADDR16_HIGH", /* name */
2019 FALSE, /* partial_inplace */
2020 0, /* src_mask */
2021 0xffff, /* dst_mask */
2022 FALSE), /* pcrel_offset */
2023
2024 /* Like R_PPC64_ADDR16_HA, but no overflow. */
2025 HOWTO (R_PPC64_ADDR16_HIGHA, /* type */
2026 16, /* rightshift */
2027 1, /* size (0 = byte, 1 = short, 2 = long) */
2028 16, /* bitsize */
2029 FALSE, /* pc_relative */
2030 0, /* bitpos */
2031 complain_overflow_dont, /* complain_on_overflow */
2032 ppc64_elf_ha_reloc, /* special_function */
2033 "R_PPC64_ADDR16_HIGHA", /* name */
2034 FALSE, /* partial_inplace */
2035 0, /* src_mask */
2036 0xffff, /* dst_mask */
2037 FALSE), /* pcrel_offset */
2038
2039 /* Like R_PPC64_DTPREL16_HI, but no overflow. */
2040 HOWTO (R_PPC64_DTPREL16_HIGH,
2041 16, /* rightshift */
2042 1, /* size (0 = byte, 1 = short, 2 = long) */
2043 16, /* bitsize */
2044 FALSE, /* pc_relative */
2045 0, /* bitpos */
2046 complain_overflow_dont, /* complain_on_overflow */
2047 ppc64_elf_unhandled_reloc, /* special_function */
2048 "R_PPC64_DTPREL16_HIGH", /* name */
2049 FALSE, /* partial_inplace */
2050 0, /* src_mask */
2051 0xffff, /* dst_mask */
2052 FALSE), /* pcrel_offset */
2053
2054 /* Like R_PPC64_DTPREL16_HA, but no overflow. */
2055 HOWTO (R_PPC64_DTPREL16_HIGHA,
2056 16, /* rightshift */
2057 1, /* size (0 = byte, 1 = short, 2 = long) */
2058 16, /* bitsize */
2059 FALSE, /* pc_relative */
2060 0, /* bitpos */
2061 complain_overflow_dont, /* complain_on_overflow */
2062 ppc64_elf_unhandled_reloc, /* special_function */
2063 "R_PPC64_DTPREL16_HIGHA", /* name */
2064 FALSE, /* partial_inplace */
2065 0, /* src_mask */
2066 0xffff, /* dst_mask */
2067 FALSE), /* pcrel_offset */
2068
2069 /* Like R_PPC64_TPREL16_HI, but no overflow. */
2070 HOWTO (R_PPC64_TPREL16_HIGH,
2071 16, /* rightshift */
2072 1, /* size (0 = byte, 1 = short, 2 = long) */
2073 16, /* bitsize */
2074 FALSE, /* pc_relative */
2075 0, /* bitpos */
2076 complain_overflow_dont, /* complain_on_overflow */
2077 ppc64_elf_unhandled_reloc, /* special_function */
2078 "R_PPC64_TPREL16_HIGH", /* name */
2079 FALSE, /* partial_inplace */
2080 0, /* src_mask */
2081 0xffff, /* dst_mask */
2082 FALSE), /* pcrel_offset */
2083
2084 /* Like R_PPC64_TPREL16_HA, but no overflow. */
2085 HOWTO (R_PPC64_TPREL16_HIGHA,
2086 16, /* rightshift */
2087 1, /* size (0 = byte, 1 = short, 2 = long) */
2088 16, /* bitsize */
2089 FALSE, /* pc_relative */
2090 0, /* bitpos */
2091 complain_overflow_dont, /* complain_on_overflow */
2092 ppc64_elf_unhandled_reloc, /* special_function */
2093 "R_PPC64_TPREL16_HIGHA", /* name */
2094 FALSE, /* partial_inplace */
2095 0, /* src_mask */
2096 0xffff, /* dst_mask */
2097 FALSE), /* pcrel_offset */
2098
5bd4f169
AM		 2099 /* GNU extension to record C++ vtable hierarchy. */
2100 HOWTO (R_PPC64_GNU_VTINHERIT, /* type */
2101 0, /* rightshift */
2102 0, /* size (0 = byte, 1 = short, 2 = long) */
2103 0, /* bitsize */
b34976b6 2104 FALSE, /* pc_relative */
5bd4f169
AM		 2105 0, /* bitpos */
2106 complain_overflow_dont, /* complain_on_overflow */
2107 NULL, /* special_function */
2108 "R_PPC64_GNU_VTINHERIT", /* name */
b34976b6 2109 FALSE, /* partial_inplace */
5bd4f169
AM		 2110 0, /* src_mask */
2111 0, /* dst_mask */
b34976b6 2112 FALSE), /* pcrel_offset */
5bd4f169
AM		 2113
2114 /* GNU extension to record C++ vtable member usage. */
2115 HOWTO (R_PPC64_GNU_VTENTRY, /* type */
2116 0, /* rightshift */
2117 0, /* size (0 = byte, 1 = short, 2 = long) */
2118 0, /* bitsize */
b34976b6 2119 FALSE, /* pc_relative */
5bd4f169
AM		 2120 0, /* bitpos */
2121 complain_overflow_dont, /* complain_on_overflow */
2122 NULL, /* special_function */
2123 "R_PPC64_GNU_VTENTRY", /* name */
b34976b6 2124 FALSE, /* partial_inplace */
5bd4f169
AM		 2125 0, /* src_mask */
2126 0, /* dst_mask */
b34976b6 2127 FALSE), /* pcrel_offset */
5bd4f169
AM		 2128};
2129
2130\f
2131/* Initialize the ppc64_elf_howto_table, so that linear accesses can
2132 be done. */
2133
2134static void
4ce794b7 2135ppc_howto_init (void)
5bd4f169
AM		 2136{
2137 unsigned int i, type;
2138
2139 for (i = 0;
2140 i < sizeof (ppc64_elf_howto_raw) / sizeof (ppc64_elf_howto_raw[0]);
2141 i++)
2142 {
2143 type = ppc64_elf_howto_raw[i].type;
2144 BFD_ASSERT (type < (sizeof (ppc64_elf_howto_table)
2145 / sizeof (ppc64_elf_howto_table[0])));
2146 ppc64_elf_howto_table[type] = &ppc64_elf_howto_raw[i];
2147 }
2148}
2149
2150static reloc_howto_type *
4ce794b7
AM		 2151ppc64_elf_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2152 bfd_reloc_code_real_type code)
5bd4f169 2153{
411e1bfb 2154 enum elf_ppc64_reloc_type r = R_PPC64_NONE;
5bd4f169
AM		 2155
2156 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
2157 /* Initialize howto table if needed. */
2158 ppc_howto_init ();
2159
4ce794b7 2160 switch (code)
5bd4f169
AM		 2161 {
2162 default:
4ce794b7 2163 return NULL;
5bd4f169 2164
411e1bfb
AM		 2165 case BFD_RELOC_NONE: r = R_PPC64_NONE;
2166 break;
2167 case BFD_RELOC_32: r = R_PPC64_ADDR32;
2168 break;
2169 case BFD_RELOC_PPC_BA26: r = R_PPC64_ADDR24;
2170 break;
2171 case BFD_RELOC_16: r = R_PPC64_ADDR16;
2172 break;
2173 case BFD_RELOC_LO16: r = R_PPC64_ADDR16_LO;
2174 break;
2175 case BFD_RELOC_HI16: r = R_PPC64_ADDR16_HI;
2176 break;
f9c6b907
AM		 2177 case BFD_RELOC_PPC64_ADDR16_HIGH: r = R_PPC64_ADDR16_HIGH;
2178 break;
411e1bfb 2179 case BFD_RELOC_HI16_S: r = R_PPC64_ADDR16_HA;
5bd4f169 2180 break;
f9c6b907
AM		 2181 case BFD_RELOC_PPC64_ADDR16_HIGHA: r = R_PPC64_ADDR16_HIGHA;
2182 break;
411e1bfb 2183 case BFD_RELOC_PPC_BA16: r = R_PPC64_ADDR14;
5bd4f169 2184 break;
411e1bfb 2185 case BFD_RELOC_PPC_BA16_BRTAKEN: r = R_PPC64_ADDR14_BRTAKEN;
5bd4f169 2186 break;
411e1bfb 2187 case BFD_RELOC_PPC_BA16_BRNTAKEN: r = R_PPC64_ADDR14_BRNTAKEN;
5bd4f169 2188 break;
411e1bfb 2189 case BFD_RELOC_PPC_B26: r = R_PPC64_REL24;
5bd4f169 2190 break;
411e1bfb 2191 case BFD_RELOC_PPC_B16: r = R_PPC64_REL14;
5bd4f169 2192 break;
411e1bfb 2193 case BFD_RELOC_PPC_B16_BRTAKEN: r = R_PPC64_REL14_BRTAKEN;
5bd4f169 2194 break;
411e1bfb 2195 case BFD_RELOC_PPC_B16_BRNTAKEN: r = R_PPC64_REL14_BRNTAKEN;
5bd4f169 2196 break;
411e1bfb 2197 case BFD_RELOC_16_GOTOFF: r = R_PPC64_GOT16;
5bd4f169 2198 break;
411e1bfb 2199 case BFD_RELOC_LO16_GOTOFF: r = R_PPC64_GOT16_LO;
5bd4f169 2200 break;
411e1bfb 2201 case BFD_RELOC_HI16_GOTOFF: r = R_PPC64_GOT16_HI;
5bd4f169 2202 break;
411e1bfb 2203 case BFD_RELOC_HI16_S_GOTOFF: r = R_PPC64_GOT16_HA;
5bd4f169 2204 break;
411e1bfb 2205 case BFD_RELOC_PPC_COPY: r = R_PPC64_COPY;
5bd4f169 2206 break;
411e1bfb 2207 case BFD_RELOC_PPC_GLOB_DAT: r = R_PPC64_GLOB_DAT;
5bd4f169 2208 break;
411e1bfb 2209 case BFD_RELOC_32_PCREL: r = R_PPC64_REL32;
5bd4f169 2210 break;
411e1bfb 2211 case BFD_RELOC_32_PLTOFF: r = R_PPC64_PLT32;
5bd4f169 2212 break;
411e1bfb 2213 case BFD_RELOC_32_PLT_PCREL: r = R_PPC64_PLTREL32;
5bd4f169 2214 break;
411e1bfb 2215 case BFD_RELOC_LO16_PLTOFF: r = R_PPC64_PLT16_LO;
5bd4f169 2216 break;
411e1bfb 2217 case BFD_RELOC_HI16_PLTOFF: r = R_PPC64_PLT16_HI;
5bd4f169 2218 break;
411e1bfb 2219 case BFD_RELOC_HI16_S_PLTOFF: r = R_PPC64_PLT16_HA;
5bd4f169 2220 break;
411e1bfb 2221 case BFD_RELOC_16_BASEREL: r = R_PPC64_SECTOFF;
5bd4f169 2222 break;
411e1bfb 2223 case BFD_RELOC_LO16_BASEREL: r = R_PPC64_SECTOFF_LO;
5bd4f169 2224 break;
411e1bfb 2225 case BFD_RELOC_HI16_BASEREL: r = R_PPC64_SECTOFF_HI;
5bd4f169 2226 break;
411e1bfb 2227 case BFD_RELOC_HI16_S_BASEREL: r = R_PPC64_SECTOFF_HA;
5bd4f169 2228 break;
411e1bfb 2229 case BFD_RELOC_CTOR: r = R_PPC64_ADDR64;
5bd4f169 2230 break;
411e1bfb 2231 case BFD_RELOC_64: r = R_PPC64_ADDR64;
5bd4f169 2232 break;
411e1bfb 2233 case BFD_RELOC_PPC64_HIGHER: r = R_PPC64_ADDR16_HIGHER;
5bd4f169 2234 break;
411e1bfb 2235 case BFD_RELOC_PPC64_HIGHER_S: r = R_PPC64_ADDR16_HIGHERA;
5bd4f169 2236 break;
411e1bfb 2237 case BFD_RELOC_PPC64_HIGHEST: r = R_PPC64_ADDR16_HIGHEST;
5bd4f169 2238 break;
411e1bfb 2239 case BFD_RELOC_PPC64_HIGHEST_S: r = R_PPC64_ADDR16_HIGHESTA;
5bd4f169 2240 break;
411e1bfb 2241 case BFD_RELOC_64_PCREL: r = R_PPC64_REL64;
5bd4f169 2242 break;
411e1bfb 2243 case BFD_RELOC_64_PLTOFF: r = R_PPC64_PLT64;
5bd4f169 2244 break;
411e1bfb 2245 case BFD_RELOC_64_PLT_PCREL: r = R_PPC64_PLTREL64;
5bd4f169 2246 break;
411e1bfb 2247 case BFD_RELOC_PPC_TOC16: r = R_PPC64_TOC16;
5bd4f169 2248 break;
411e1bfb 2249 case BFD_RELOC_PPC64_TOC16_LO: r = R_PPC64_TOC16_LO;
5bd4f169 2250 break;
411e1bfb 2251 case BFD_RELOC_PPC64_TOC16_HI: r = R_PPC64_TOC16_HI;
5bd4f169 2252 break;
411e1bfb 2253 case BFD_RELOC_PPC64_TOC16_HA: r = R_PPC64_TOC16_HA;
5bd4f169 2254 break;
411e1bfb 2255 case BFD_RELOC_PPC64_TOC: r = R_PPC64_TOC;
5bd4f169 2256 break;
411e1bfb 2257 case BFD_RELOC_PPC64_PLTGOT16: r = R_PPC64_PLTGOT16;
5bd4f169 2258 break;
411e1bfb 2259 case BFD_RELOC_PPC64_PLTGOT16_LO: r = R_PPC64_PLTGOT16_LO;
5bd4f169 2260 break;
411e1bfb 2261 case BFD_RELOC_PPC64_PLTGOT16_HI: r = R_PPC64_PLTGOT16_HI;
5bd4f169 2262 break;
411e1bfb 2263 case BFD_RELOC_PPC64_PLTGOT16_HA: r = R_PPC64_PLTGOT16_HA;
5bd4f169 2264 break;
411e1bfb 2265 case BFD_RELOC_PPC64_ADDR16_DS: r = R_PPC64_ADDR16_DS;
5bd4f169 2266 break;
411e1bfb 2267 case BFD_RELOC_PPC64_ADDR16_LO_DS: r = R_PPC64_ADDR16_LO_DS;
5bd4f169 2268 break;
411e1bfb 2269 case BFD_RELOC_PPC64_GOT16_DS: r = R_PPC64_GOT16_DS;
5bd4f169 2270 break;
411e1bfb 2271 case BFD_RELOC_PPC64_GOT16_LO_DS: r = R_PPC64_GOT16_LO_DS;
5bd4f169 2272 break;
411e1bfb 2273 case BFD_RELOC_PPC64_PLT16_LO_DS: r = R_PPC64_PLT16_LO_DS;
5bd4f169 2274 break;
411e1bfb 2275 case BFD_RELOC_PPC64_SECTOFF_DS: r = R_PPC64_SECTOFF_DS;
5bd4f169 2276 break;
411e1bfb 2277 case BFD_RELOC_PPC64_SECTOFF_LO_DS: r = R_PPC64_SECTOFF_LO_DS;
5bd4f169 2278 break;
411e1bfb 2279 case BFD_RELOC_PPC64_TOC16_DS: r = R_PPC64_TOC16_DS;
5bd4f169 2280 break;
411e1bfb 2281 case BFD_RELOC_PPC64_TOC16_LO_DS: r = R_PPC64_TOC16_LO_DS;
5bd4f169 2282 break;
411e1bfb 2283 case BFD_RELOC_PPC64_PLTGOT16_DS: r = R_PPC64_PLTGOT16_DS;
5bd4f169 2284 break;
411e1bfb 2285 case BFD_RELOC_PPC64_PLTGOT16_LO_DS: r = R_PPC64_PLTGOT16_LO_DS;
5bd4f169 2286 break;
411e1bfb 2287 case BFD_RELOC_PPC_TLS: r = R_PPC64_TLS;
5bd4f169 2288 break;
727fc41e
AM		 2289 case BFD_RELOC_PPC_TLSGD: r = R_PPC64_TLSGD;
2290 break;
2291 case BFD_RELOC_PPC_TLSLD: r = R_PPC64_TLSLD;
2292 break;
411e1bfb 2293 case BFD_RELOC_PPC_DTPMOD: r = R_PPC64_DTPMOD64;
5bd4f169 2294 break;
411e1bfb 2295 case BFD_RELOC_PPC_TPREL16: r = R_PPC64_TPREL16;
5bd4f169 2296 break;
411e1bfb 2297 case BFD_RELOC_PPC_TPREL16_LO: r = R_PPC64_TPREL16_LO;
5bd4f169 2298 break;
411e1bfb 2299 case BFD_RELOC_PPC_TPREL16_HI: r = R_PPC64_TPREL16_HI;
5bd4f169 2300 break;
f9c6b907
AM		 2301 case BFD_RELOC_PPC64_TPREL16_HIGH: r = R_PPC64_TPREL16_HIGH;
2302 break;
411e1bfb 2303 case BFD_RELOC_PPC_TPREL16_HA: r = R_PPC64_TPREL16_HA;
5bd4f169 2304 break;
f9c6b907
AM		 2305 case BFD_RELOC_PPC64_TPREL16_HIGHA: r = R_PPC64_TPREL16_HIGHA;
2306 break;
411e1bfb 2307 case BFD_RELOC_PPC_TPREL: r = R_PPC64_TPREL64;
5bd4f169 2308 break;
411e1bfb
AM		 2309 case BFD_RELOC_PPC_DTPREL16: r = R_PPC64_DTPREL16;
2310 break;
2311 case BFD_RELOC_PPC_DTPREL16_LO: r = R_PPC64_DTPREL16_LO;
2312 break;
2313 case BFD_RELOC_PPC_DTPREL16_HI: r = R_PPC64_DTPREL16_HI;
2314 break;
f9c6b907
AM		 2315 case BFD_RELOC_PPC64_DTPREL16_HIGH: r = R_PPC64_DTPREL16_HIGH;
2316 break;
411e1bfb
AM		 2317 case BFD_RELOC_PPC_DTPREL16_HA: r = R_PPC64_DTPREL16_HA;
2318 break;
f9c6b907
AM		 2319 case BFD_RELOC_PPC64_DTPREL16_HIGHA: r = R_PPC64_DTPREL16_HIGHA;
2320 break;
411e1bfb
AM		 2321 case BFD_RELOC_PPC_DTPREL: r = R_PPC64_DTPREL64;
2322 break;
2323 case BFD_RELOC_PPC_GOT_TLSGD16: r = R_PPC64_GOT_TLSGD16;
2324 break;
2325 case BFD_RELOC_PPC_GOT_TLSGD16_LO: r = R_PPC64_GOT_TLSGD16_LO;
2326 break;
2327 case BFD_RELOC_PPC_GOT_TLSGD16_HI: r = R_PPC64_GOT_TLSGD16_HI;
2328 break;
2329 case BFD_RELOC_PPC_GOT_TLSGD16_HA: r = R_PPC64_GOT_TLSGD16_HA;
2330 break;
2331 case BFD_RELOC_PPC_GOT_TLSLD16: r = R_PPC64_GOT_TLSLD16;
2332 break;
2333 case BFD_RELOC_PPC_GOT_TLSLD16_LO: r = R_PPC64_GOT_TLSLD16_LO;
2334 break;
2335 case BFD_RELOC_PPC_GOT_TLSLD16_HI: r = R_PPC64_GOT_TLSLD16_HI;
2336 break;
2337 case BFD_RELOC_PPC_GOT_TLSLD16_HA: r = R_PPC64_GOT_TLSLD16_HA;
2338 break;
2339 case BFD_RELOC_PPC_GOT_TPREL16: r = R_PPC64_GOT_TPREL16_DS;
2340 break;
2341 case BFD_RELOC_PPC_GOT_TPREL16_LO: r = R_PPC64_GOT_TPREL16_LO_DS;
2342 break;
2343 case BFD_RELOC_PPC_GOT_TPREL16_HI: r = R_PPC64_GOT_TPREL16_HI;
2344 break;
2345 case BFD_RELOC_PPC_GOT_TPREL16_HA: r = R_PPC64_GOT_TPREL16_HA;
2346 break;
2347 case BFD_RELOC_PPC_GOT_DTPREL16: r = R_PPC64_GOT_DTPREL16_DS;
2348 break;
2349 case BFD_RELOC_PPC_GOT_DTPREL16_LO: r = R_PPC64_GOT_DTPREL16_LO_DS;
2350 break;
2351 case BFD_RELOC_PPC_GOT_DTPREL16_HI: r = R_PPC64_GOT_DTPREL16_HI;
2352 break;
2353 case BFD_RELOC_PPC_GOT_DTPREL16_HA: r = R_PPC64_GOT_DTPREL16_HA;
2354 break;
2355 case BFD_RELOC_PPC64_TPREL16_DS: r = R_PPC64_TPREL16_DS;
2356 break;
2357 case BFD_RELOC_PPC64_TPREL16_LO_DS: r = R_PPC64_TPREL16_LO_DS;
2358 break;
2359 case BFD_RELOC_PPC64_TPREL16_HIGHER: r = R_PPC64_TPREL16_HIGHER;
2360 break;
2361 case BFD_RELOC_PPC64_TPREL16_HIGHERA: r = R_PPC64_TPREL16_HIGHERA;
2362 break;
2363 case BFD_RELOC_PPC64_TPREL16_HIGHEST: r = R_PPC64_TPREL16_HIGHEST;
2364 break;
2365 case BFD_RELOC_PPC64_TPREL16_HIGHESTA: r = R_PPC64_TPREL16_HIGHESTA;
2366 break;
2367 case BFD_RELOC_PPC64_DTPREL16_DS: r = R_PPC64_DTPREL16_DS;
2368 break;
2369 case BFD_RELOC_PPC64_DTPREL16_LO_DS: r = R_PPC64_DTPREL16_LO_DS;
2370 break;
2371 case BFD_RELOC_PPC64_DTPREL16_HIGHER: r = R_PPC64_DTPREL16_HIGHER;
2372 break;
2373 case BFD_RELOC_PPC64_DTPREL16_HIGHERA: r = R_PPC64_DTPREL16_HIGHERA;
2374 break;
2375 case BFD_RELOC_PPC64_DTPREL16_HIGHEST: r = R_PPC64_DTPREL16_HIGHEST;
2376 break;
2377 case BFD_RELOC_PPC64_DTPREL16_HIGHESTA: r = R_PPC64_DTPREL16_HIGHESTA;
2378 break;
25f23106
AM		 2379 case BFD_RELOC_16_PCREL: r = R_PPC64_REL16;
2380 break;
2381 case BFD_RELOC_LO16_PCREL: r = R_PPC64_REL16_LO;
2382 break;
2383 case BFD_RELOC_HI16_PCREL: r = R_PPC64_REL16_HI;
2384 break;
2385 case BFD_RELOC_HI16_S_PCREL: r = R_PPC64_REL16_HA;
2386 break;
411e1bfb
AM		 2387 case BFD_RELOC_VTABLE_INHERIT: r = R_PPC64_GNU_VTINHERIT;
2388 break;
2389 case BFD_RELOC_VTABLE_ENTRY: r = R_PPC64_GNU_VTENTRY;
5bd4f169
AM		 2390 break;
2391 }
2392
4ce794b7 2393 return ppc64_elf_howto_table[r];
5bd4f169
AM		 2394};
2395
157090f7
AM		 2396static reloc_howto_type *
2397ppc64_elf_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
2398 const char *r_name)
2399{
2400 unsigned int i;
2401
2402 for (i = 0;
2403 i < sizeof (ppc64_elf_howto_raw) / sizeof (ppc64_elf_howto_raw[0]);
2404 i++)
2405 if (ppc64_elf_howto_raw[i].name != NULL
2406 && strcasecmp (ppc64_elf_howto_raw[i].name, r_name) == 0)
2407 return &ppc64_elf_howto_raw[i];
2408
2409 return NULL;
2410}
2411
5bd4f169
AM		 2412/* Set the howto pointer for a PowerPC ELF reloc. */
2413
2414static void
4ce794b7
AM		 2415ppc64_elf_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr,
2416 Elf_Internal_Rela *dst)
5bd4f169 2417{
65f38f15
AM		 2418 unsigned int type;
2419
ef60b7ff 2420 /* Initialize howto table if needed. */
5bd4f169 2421 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
5bd4f169
AM		 2422 ppc_howto_init ();
2423
65f38f15 2424 type = ELF64_R_TYPE (dst->r_info);
d0fb9a8d
JJ		 2425 if (type >= (sizeof (ppc64_elf_howto_table)
2426 / sizeof (ppc64_elf_howto_table[0])))
2427 {
2428 (*_bfd_error_handler) (_("%B: invalid relocation type %d"),
3ec2b351
NC		 2429 abfd, (int) type);
2430 type = R_PPC64_NONE;
d0fb9a8d 2431 }
65f38f15 2432 cache_ptr->howto = ppc64_elf_howto_table[type];
5bd4f169
AM		 2433}
2434
04c9666a 2435/* Handle the R_PPC64_ADDR16_HA and similar relocs. */
5bd4f169
AM		 2436
2437static bfd_reloc_status_type
4ce794b7
AM		 2438ppc64_elf_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2439 void *data, asection *input_section,
2440 bfd *output_bfd, char **error_message)
5bd4f169 2441{
805fc799
AM		 2442 /* If this is a relocatable link (output_bfd test tells us), just
2443 call the generic function. Any adjustment will be done at final
2444 link time. */
2445 if (output_bfd != NULL)
cedb70c5 2446 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
805fc799
AM		 2447 input_section, output_bfd, error_message);
2448
2449 /* Adjust the addend for sign extension of the low 16 bits.
2450 We won't actually be using the low 16 bits, so trashing them
2451 doesn't matter. */
2452 reloc_entry->addend += 0x8000;
2453 return bfd_reloc_continue;
2454}
5bd4f169 2455
2441e016
AM		 2456static bfd_reloc_status_type
2457ppc64_elf_branch_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2458 void *data, asection *input_section,
2459 bfd *output_bfd, char **error_message)
2460{
2461 if (output_bfd != NULL)
2462 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
2463 input_section, output_bfd, error_message);
2464
699733f6
AM		 2465 if (strcmp (symbol->section->name, ".opd") == 0
2466 && (symbol->section->owner->flags & DYNAMIC) == 0)
2441e016
AM		 2467 {
2468 bfd_vma dest = opd_entry_value (symbol->section,
2469 symbol->value + reloc_entry->addend,
aef36ac1 2470 NULL, NULL, FALSE);
2441e016
AM		 2471 if (dest != (bfd_vma) -1)
2472 reloc_entry->addend = dest - (symbol->value
2473 + symbol->section->output_section->vma
2474 + symbol->section->output_offset);
2475 }
2476 return bfd_reloc_continue;
2477}
2478
805fc799 2479static bfd_reloc_status_type
4ce794b7
AM		 2480ppc64_elf_brtaken_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2481 void *data, asection *input_section,
2482 bfd *output_bfd, char **error_message)
805fc799
AM		 2483{
2484 long insn;
04c9666a 2485 enum elf_ppc64_reloc_type r_type;
805fc799 2486 bfd_size_type octets;
794e51c0
AM		 2487 /* Assume 'at' branch hints. */
2488 bfd_boolean is_isa_v2 = TRUE;
805fc799
AM		 2489
2490 /* If this is a relocatable link (output_bfd test tells us), just
2491 call the generic function. Any adjustment will be done at final
2492 link time. */
5bd4f169 2493 if (output_bfd != NULL)
cedb70c5 2494 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
805fc799
AM		 2495 input_section, output_bfd, error_message);
2496
2497 octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2498 insn = bfd_get_32 (abfd, (bfd_byte *) data + octets);
2499 insn &= ~(0x01 << 21);
4ce794b7 2500 r_type = reloc_entry->howto->type;
805fc799
AM		 2501 if (r_type == R_PPC64_ADDR14_BRTAKEN
2502 || r_type == R_PPC64_REL14_BRTAKEN)
cedb70c5 2503 insn |= 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field. */
805fc799 2504
794e51c0 2505 if (is_isa_v2)
5bd4f169 2506 {
805fc799
AM		 2507 /* Set 'a' bit. This is 0b00010 in BO field for branch
2508 on CR(BI) insns (BO == 001at or 011at), and 0b01000
2509 for branch on CTR insns (BO == 1a00t or 1a01t). */
2510 if ((insn & (0x14 << 21)) == (0x04 << 21))
2511 insn |= 0x02 << 21;
2512 else if ((insn & (0x14 << 21)) == (0x10 << 21))
2513 insn |= 0x08 << 21;
2514 else
2441e016 2515 goto out;
5bd4f169 2516 }
805fc799
AM		 2517 else
2518 {
2519 bfd_vma target = 0;
2520 bfd_vma from;
5bd4f169 2521
805fc799
AM		 2522 if (!bfd_is_com_section (symbol->section))
2523 target = symbol->value;
2524 target += symbol->section->output_section->vma;
2525 target += symbol->section->output_offset;
2526 target += reloc_entry->addend;
5bd4f169 2527
805fc799
AM		 2528 from = (reloc_entry->address
2529 + input_section->output_offset
2530 + input_section->output_section->vma);
5bd4f169 2531
805fc799
AM		 2532 /* Invert 'y' bit if not the default. */
2533 if ((bfd_signed_vma) (target - from) < 0)
2534 insn ^= 0x01 << 21;
2535 }
4ce794b7 2536 bfd_put_32 (abfd, insn, (bfd_byte *) data + octets);
2441e016
AM		 2537 out:
2538 return ppc64_elf_branch_reloc (abfd, reloc_entry, symbol, data,
2539 input_section, output_bfd, error_message);
805fc799 2540}
5bd4f169 2541
805fc799 2542static bfd_reloc_status_type
4ce794b7
AM		 2543ppc64_elf_sectoff_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2544 void *data, asection *input_section,
2545 bfd *output_bfd, char **error_message)
805fc799
AM		 2546{
2547 /* If this is a relocatable link (output_bfd test tells us), just
2548 call the generic function. Any adjustment will be done at final
2549 link time. */
2550 if (output_bfd != NULL)
cedb70c5 2551 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
805fc799 2552 input_section, output_bfd, error_message);
5bd4f169 2553
805fc799
AM		 2554 /* Subtract the symbol section base address. */
2555 reloc_entry->addend -= symbol->section->output_section->vma;
5bd4f169
AM		 2556 return bfd_reloc_continue;
2557}
2558
805fc799 2559static bfd_reloc_status_type
4ce794b7
AM		 2560ppc64_elf_sectoff_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2561 void *data, asection *input_section,
2562 bfd *output_bfd, char **error_message)
805fc799
AM		 2563{
2564 /* If this is a relocatable link (output_bfd test tells us), just
2565 call the generic function. Any adjustment will be done at final
2566 link time. */
2567 if (output_bfd != NULL)
cedb70c5 2568 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
805fc799
AM		 2569 input_section, output_bfd, error_message);
2570
2571 /* Subtract the symbol section base address. */
2572 reloc_entry->addend -= symbol->section->output_section->vma;
2573
2574 /* Adjust the addend for sign extension of the low 16 bits. */
2575 reloc_entry->addend += 0x8000;
2576 return bfd_reloc_continue;
2577}
2578
2579static bfd_reloc_status_type
4ce794b7
AM		 2580ppc64_elf_toc_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2581 void *data, asection *input_section,
2582 bfd *output_bfd, char **error_message)
805fc799
AM		 2583{
2584 bfd_vma TOCstart;
2585
2586 /* If this is a relocatable link (output_bfd test tells us), just
2587 call the generic function. Any adjustment will be done at final
2588 link time. */
2589 if (output_bfd != NULL)
cedb70c5 2590 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
805fc799
AM		 2591 input_section, output_bfd, error_message);
2592
2593 TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2594 if (TOCstart == 0)
1c865ab2 2595 TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
805fc799
AM		 2596
2597 /* Subtract the TOC base address. */
2598 reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2599 return bfd_reloc_continue;
2600}
2601
2602static bfd_reloc_status_type
4ce794b7
AM		 2603ppc64_elf_toc_ha_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2604 void *data, asection *input_section,
2605 bfd *output_bfd, char **error_message)
805fc799
AM		 2606{
2607 bfd_vma TOCstart;
2608
2609 /* If this is a relocatable link (output_bfd test tells us), just
2610 call the generic function. Any adjustment will be done at final
2611 link time. */
2612 if (output_bfd != NULL)
cedb70c5 2613 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
805fc799
AM		 2614 input_section, output_bfd, error_message);
2615
2616 TOCstart = _bfd_get_gp_value (input_section->output_section->owner);
2617 if (TOCstart == 0)
1c865ab2 2618 TOCstart = ppc64_elf_set_toc (NULL, input_section->output_section->owner);
805fc799
AM		 2619
2620 /* Subtract the TOC base address. */
2621 reloc_entry->addend -= TOCstart + TOC_BASE_OFF;
2622
2623 /* Adjust the addend for sign extension of the low 16 bits. */
2624 reloc_entry->addend += 0x8000;
2625 return bfd_reloc_continue;
2626}
2627
2628static bfd_reloc_status_type
4ce794b7
AM		 2629ppc64_elf_toc64_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
2630 void *data, asection *input_section,
2631 bfd *output_bfd, char **error_message)
805fc799
AM		 2632{
2633 bfd_vma TOCstart;
2634 bfd_size_type octets;
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 octets = reloc_entry->address * bfd_octets_per_byte (abfd);
2648 bfd_put_64 (abfd, TOCstart + TOC_BASE_OFF, (bfd_byte *) data + octets);
2649 return bfd_reloc_ok;
2650}
2651
2652static bfd_reloc_status_type
4ce794b7
AM		 2653ppc64_elf_unhandled_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 /* If this is a relocatable link (output_bfd test tells us), just
2658 call the generic function. Any adjustment will be done at final
2659 link time. */
2660 if (output_bfd != NULL)
cedb70c5 2661 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
805fc799
AM		 2662 input_section, output_bfd, error_message);
2663
2664 if (error_message != NULL)
2665 {
2666 static char buf[60];
2667 sprintf (buf, "generic linker can't handle %s",
2668 reloc_entry->howto->name);
2669 *error_message = buf;
2670 }
2671 return bfd_reloc_dangerous;
2672}
2673
927be08e
AM		 2674/* Track GOT entries needed for a given symbol. We might need more
2675 than one got entry per symbol. */
2676struct got_entry
2677{
2678 struct got_entry *next;
2679
2680 /* The symbol addend that we'll be placing in the GOT. */
2681 bfd_vma addend;
2682
2683 /* Unlike other ELF targets, we use separate GOT entries for the same
2684 symbol referenced from different input files. This is to support
2685 automatic multiple TOC/GOT sections, where the TOC base can vary
2686 from one input file to another. After partitioning into TOC groups
2687 we merge entries within the group.
2688
2689 Point to the BFD owning this GOT entry. */
2690 bfd *owner;
2691
2692 /* Zero for non-tls entries, or TLS_TLS and one of TLS_GD, TLS_LD,
2693 TLS_TPREL or TLS_DTPREL for tls entries. */
f961d9dd 2694 unsigned char tls_type;
927be08e
AM		 2695
2696 /* Non-zero if got.ent points to real entry. */
f961d9dd 2697 unsigned char is_indirect;
927be08e
AM		 2698
2699 /* Reference count until size_dynamic_sections, GOT offset thereafter. */
2700 union
2701 {
2702 bfd_signed_vma refcount;
2703 bfd_vma offset;
2704 struct got_entry *ent;
2705 } got;
2706};
2707
2708/* The same for PLT. */
2709struct plt_entry
2710{
2711 struct plt_entry *next;
2712
2713 bfd_vma addend;
2714
2715 union
2716 {
2717 bfd_signed_vma refcount;
2718 bfd_vma offset;
2719 } plt;
2720};
2721
e717da7e
AM		 2722struct ppc64_elf_obj_tdata
2723{
2724 struct elf_obj_tdata elf;
2725
2726 /* Shortcuts to dynamic linker sections. */
2727 asection *got;
2728 asection *relgot;
2729
b3fac117
AM		 2730 /* Used during garbage collection. We attach global symbols defined
2731 on removed .opd entries to this section so that the sym is removed. */
2732 asection *deleted_section;
81688140 2733
927be08e 2734 /* TLS local dynamic got entry handling. Support for multiple GOT
e717da7e 2735 sections means we potentially need one of these for each input bfd. */
927be08e 2736 struct got_entry tlsld_got;
8860955f 2737
729eabd5
AM		 2738 union {
2739 /* A copy of relocs before they are modified for --emit-relocs. */
2740 Elf_Internal_Rela *relocs;
2741
2742 /* Section contents. */
2743 bfd_byte *contents;
2744 } opd;
d77c8a4b
AM		 2745
2746 /* Nonzero if this bfd has small toc/got relocs, ie. that expect
2747 the reloc to be in the range -32768 to 32767. */
98528052
AM		 2748 unsigned int has_small_toc_reloc : 1;
2749
560c8763
AM		 2750 /* Set if toc/got ha relocs detected not using r2, or lo reloc
2751 instruction not one we handle. */
2752 unsigned int unexpected_toc_insn : 1;
e717da7e
AM		 2753};
2754
2755#define ppc64_elf_tdata(bfd) \
2756 ((struct ppc64_elf_obj_tdata *) (bfd)->tdata.any)
2757
2758#define ppc64_tlsld_got(bfd) \
2759 (&ppc64_elf_tdata (bfd)->tlsld_got)
2760
0c8d6e5c
AM		 2761#define is_ppc64_elf(bfd) \
2762 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
4dfe6ac6 2763 && elf_object_id (bfd) == PPC64_ELF_DATA)
0c8d6e5c 2764
e717da7e
AM		 2765/* Override the generic function because we store some extras. */
2766
2767static bfd_boolean
2768ppc64_elf_mkobject (bfd *abfd)
2769{
0ffa91dd 2770 return bfd_elf_allocate_object (abfd, sizeof (struct ppc64_elf_obj_tdata),
4dfe6ac6 2771 PPC64_ELF_DATA);
e717da7e
AM		 2772}
2773
feee612b
AM		 2774/* Fix bad default arch selected for a 64 bit input bfd when the
2775 default is 32 bit. */
2776
b34976b6 2777static bfd_boolean
4ce794b7 2778ppc64_elf_object_p (bfd *abfd)
feee612b
AM		 2779{
2780 if (abfd->arch_info->the_default && abfd->arch_info->bits_per_word == 32)
2781 {
2782 Elf_Internal_Ehdr *i_ehdr = elf_elfheader (abfd);
2783
2784 if (i_ehdr->e_ident[EI_CLASS] == ELFCLASS64)
2785 {
2786 /* Relies on arch after 32 bit default being 64 bit default. */
2787 abfd->arch_info = abfd->arch_info->next;
2788 BFD_ASSERT (abfd->arch_info->bits_per_word == 64);
2789 }
2790 }
b34976b6 2791 return TRUE;
feee612b
AM		 2792}
2793
d37c89e5
AM		 2794/* Support for core dump NOTE sections. */
2795
2796static bfd_boolean
2797ppc64_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
2798{
eea6121a 2799 size_t offset, size;
d37c89e5
AM		 2800
2801 if (note->descsz != 504)
2802 return FALSE;
2803
2804 /* pr_cursig */
228e534f 2805 elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
d37c89e5
AM		 2806
2807 /* pr_pid */
228e534f 2808 elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 32);
d37c89e5
AM		 2809
2810 /* pr_reg */
2811 offset = 112;
eea6121a 2812 size = 384;
d37c89e5
AM		 2813
2814 /* Make a ".reg/999" section. */
2815 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
eea6121a 2816 size, note->descpos + offset);
d37c89e5
AM		 2817}
2818
2819static bfd_boolean
2820ppc64_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
2821{
2822 if (note->descsz != 136)
2823 return FALSE;
2824
228e534f 2825 elf_tdata (abfd)->core->pid
bc989cdc 2826 = bfd_get_32 (abfd, note->descdata + 24);
228e534f 2827 elf_tdata (abfd)->core->program
d37c89e5 2828 = _bfd_elfcore_strndup (abfd, note->descdata + 40, 16);
228e534f 2829 elf_tdata (abfd)->core->command
d37c89e5
AM		 2830 = _bfd_elfcore_strndup (abfd, note->descdata + 56, 80);
2831
2832 return TRUE;
2833}
2834
183e98be
AM		 2835static char *
2836ppc64_elf_write_core_note (bfd *abfd, char *buf, int *bufsiz, int note_type,
2837 ...)
2838{
2839 switch (note_type)
2840 {
2841 default:
2842 return NULL;
2843
2844 case NT_PRPSINFO:
2845 {
2846 char data[136];
2847 va_list ap;
2848
2849 va_start (ap, note_type);
75cd47ed 2850 memset (data, 0, sizeof (data));
183e98be
AM		 2851 strncpy (data + 40, va_arg (ap, const char *), 16);
2852 strncpy (data + 56, va_arg (ap, const char *), 80);
2853 va_end (ap);
2854 return elfcore_write_note (abfd, buf, bufsiz,
2855 "CORE", note_type, data, sizeof (data));
2856 }
2857
2858 case NT_PRSTATUS:
2859 {
2860 char data[504];
2861 va_list ap;
2862 long pid;
2863 int cursig;
2864 const void *greg;
2865
2866 va_start (ap, note_type);
2867 memset (data, 0, 112);
2868 pid = va_arg (ap, long);
2869 bfd_put_32 (abfd, pid, data + 32);
2870 cursig = va_arg (ap, int);
2871 bfd_put_16 (abfd, cursig, data + 12);
2872 greg = va_arg (ap, const void *);
2873 memcpy (data + 112, greg, 384);
2874 memset (data + 496, 0, 8);
2875 va_end (ap);
2876 return elfcore_write_note (abfd, buf, bufsiz,
2877 "CORE", note_type, data, sizeof (data));
2878 }
2879 }
2880}
2881
5d35169e
AM		 2882/* Add extra PPC sections. */
2883
b35d266b 2884static const struct bfd_elf_special_section ppc64_elf_special_sections[]=
7f4d3958 2885{
0112cd26
NC		 2886 { STRING_COMMA_LEN (".plt"), 0, SHT_NOBITS, 0 },
2887 { STRING_COMMA_LEN (".sbss"), -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE },
2888 { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2889 { STRING_COMMA_LEN (".toc"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2890 { STRING_COMMA_LEN (".toc1"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2891 { STRING_COMMA_LEN (".tocbss"), 0, SHT_NOBITS, SHF_ALLOC + SHF_WRITE },
2892 { NULL, 0, 0, 0, 0 }
5d35169e
AM		 2893};
2894
7c8fe5c4
AM		 2895enum _ppc64_sec_type {
2896 sec_normal = 0,
2897 sec_opd = 1,
2898 sec_toc = 2
2899};
2900
f0abc2a1
AM		 2901struct _ppc64_elf_section_data
2902{
2903 struct bfd_elf_section_data elf;
411e1bfb 2904
f0abc2a1
AM		 2905 union
2906 {
74f0fb50
AM		 2907 /* An array with one entry for each opd function descriptor. */
2908 struct _opd_sec_data
2909 {
2910 /* Points to the function code section for local opd entries. */
2911 asection **func_sec;
2912
2913 /* After editing .opd, adjust references to opd local syms. */
2914 long *adjust;
2915 } opd;
7c8fe5c4 2916
3a71aa26
AM		 2917 /* An array for toc sections, indexed by offset/8. */
2918 struct _toc_sec_data
2919 {
2920 /* Specifies the relocation symbol index used at a given toc offset. */
2921 unsigned *symndx;
2922
2923 /* And the relocation addend. */
2924 bfd_vma *add;
2925 } toc;
7c8fe5c4
AM		 2926 } u;
2927
2928 enum _ppc64_sec_type sec_type:2;
411e1bfb 2929
7c8fe5c4
AM		 2930 /* Flag set when small branches are detected. Used to
2931 select suitable defaults for the stub group size. */
2932 unsigned int has_14bit_branch:1;
f0abc2a1
AM		 2933};
2934
2935#define ppc64_elf_section_data(sec) \
411e1bfb 2936 ((struct _ppc64_elf_section_data *) elf_section_data (sec))
f0abc2a1
AM		 2937
2938static bfd_boolean
4ce794b7 2939ppc64_elf_new_section_hook (bfd *abfd, asection *sec)
f0abc2a1 2940{
f592407e
AM		 2941 if (!sec->used_by_bfd)
2942 {
2943 struct _ppc64_elf_section_data *sdata;
2944 bfd_size_type amt = sizeof (*sdata);
f0abc2a1 2945
f592407e
AM		 2946 sdata = bfd_zalloc (abfd, amt);
2947 if (sdata == NULL)
2948 return FALSE;
2949 sec->used_by_bfd = sdata;
2950 }
f0abc2a1
AM		 2951
2952 return _bfd_elf_new_section_hook (abfd, sec);
2953}
4025353c 2954
74f0fb50 2955static struct _opd_sec_data *
4025353c
AM		 2956get_opd_info (asection * sec)
2957{
2958 if (sec != NULL
2959 && ppc64_elf_section_data (sec) != NULL
7c8fe5c4 2960 && ppc64_elf_section_data (sec)->sec_type == sec_opd)
74f0fb50 2961 return &ppc64_elf_section_data (sec)->u.opd;
4025353c
AM		 2962 return NULL;
2963}
ee67d69a
AM		 2964
2965static inline int
2966abiversion (bfd *abfd)
2967{
2968 return elf_elfheader (abfd)->e_flags & EF_PPC64_ABI;
2969}
2970
2971static inline void
2972set_abiversion (bfd *abfd, int ver)
2973{
2974 elf_elfheader (abfd)->e_flags &= ~EF_PPC64_ABI;
2975 elf_elfheader (abfd)->e_flags |= ver & EF_PPC64_ABI;
2976}
90e3cdf2
JJ		 2977\f
2978/* Parameters for the qsort hook. */
90e3cdf2
JJ		 2979static bfd_boolean synthetic_relocatable;
2980
699733f6 2981/* qsort comparison function for ppc64_elf_get_synthetic_symtab. */
90e3cdf2
JJ		 2982
2983static int
2984compare_symbols (const void *ap, const void *bp)
2985{
2986 const asymbol *a = * (const asymbol **) ap;
2987 const asymbol *b = * (const asymbol **) bp;
2988
699733f6
AM		 2989 /* Section symbols first. */
2990 if ((a->flags & BSF_SECTION_SYM) && !(b->flags & BSF_SECTION_SYM))
90e3cdf2 2991 return -1;
699733f6 2992 if (!(a->flags & BSF_SECTION_SYM) && (b->flags & BSF_SECTION_SYM))
90e3cdf2
JJ		 2993 return 1;
2994
699733f6 2995 /* then .opd symbols. */
ffcfec52
AM		 2996 if (strcmp (a->section->name, ".opd") == 0
2997 && strcmp (b->section->name, ".opd") != 0)
90e3cdf2 2998 return -1;
ffcfec52
AM		 2999 if (strcmp (a->section->name, ".opd") != 0
3000 && strcmp (b->section->name, ".opd") == 0)
90e3cdf2
JJ		 3001 return 1;
3002
699733f6 3003 /* then other code symbols. */
90e3cdf2
JJ		 3004 if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3005 == (SEC_CODE | SEC_ALLOC)
3006 && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3007 != (SEC_CODE | SEC_ALLOC))
3008 return -1;
3009
3010 if ((a->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3011 != (SEC_CODE | SEC_ALLOC)
3012 && (b->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3013 == (SEC_CODE | SEC_ALLOC))
3014 return 1;
3015
3016 if (synthetic_relocatable)
3017 {
3018 if (a->section->id < b->section->id)
3019 return -1;
3020
3021 if (a->section->id > b->section->id)
3022 return 1;
3023 }
3024
3025 if (a->value + a->section->vma < b->value + b->section->vma)
3026 return -1;
3027
3028 if (a->value + a->section->vma > b->value + b->section->vma)
3029 return 1;
3030
4d35a0aa
AM		 3031 /* For syms with the same value, prefer strong dynamic global function
3032 syms over other syms. */
3033 if ((a->flags & BSF_GLOBAL) != 0 && (b->flags & BSF_GLOBAL) == 0)
3034 return -1;
3035
3036 if ((a->flags & BSF_GLOBAL) == 0 && (b->flags & BSF_GLOBAL) != 0)
3037 return 1;
3038
3039 if ((a->flags & BSF_FUNCTION) != 0 && (b->flags & BSF_FUNCTION) == 0)
3040 return -1;
3041
3042 if ((a->flags & BSF_FUNCTION) == 0 && (b->flags & BSF_FUNCTION) != 0)
3043 return 1;
3044
3045 if ((a->flags & BSF_WEAK) == 0 && (b->flags & BSF_WEAK) != 0)
3046 return -1;
3047
3048 if ((a->flags & BSF_WEAK) != 0 && (b->flags & BSF_WEAK) == 0)
3049 return 1;
3050
3051 if ((a->flags & BSF_DYNAMIC) != 0 && (b->flags & BSF_DYNAMIC) == 0)
3052 return -1;
3053
3054 if ((a->flags & BSF_DYNAMIC) == 0 && (b->flags & BSF_DYNAMIC) != 0)
3055 return 1;
3056
90e3cdf2
JJ		 3057 return 0;
3058}
3059
699733f6 3060/* Search SYMS for a symbol of the given VALUE. */
90e3cdf2 3061
699733f6
AM		 3062static asymbol *
3063sym_exists_at (asymbol **syms, long lo, long hi, int id, bfd_vma value)
90e3cdf2 3064{
699733f6 3065 long mid;
90e3cdf2 3066
699733f6
AM		 3067 if (id == -1)
3068 {
3069 while (lo < hi)
3070 {
3071 mid = (lo + hi) >> 1;
3072 if (syms[mid]->value + syms[mid]->section->vma < value)
3073 lo = mid + 1;
3074 else if (syms[mid]->value + syms[mid]->section->vma > value)
3075 hi = mid;
3076 else
3077 return syms[mid];
3078 }
3079 }
3080 else
3081 {
3082 while (lo < hi)
3083 {
3084 mid = (lo + hi) >> 1;
3085 if (syms[mid]->section->id < id)
3086 lo = mid + 1;
3087 else if (syms[mid]->section->id > id)
3088 hi = mid;
3089 else if (syms[mid]->value < value)
3090 lo = mid + 1;
3091 else if (syms[mid]->value > value)
3092 hi = mid;
3093 else
3094 return syms[mid];
3095 }
3096 }
3097 return NULL;
90e3cdf2
JJ		 3098}
3099
468392fb
AM		 3100static bfd_boolean
3101section_covers_vma (bfd *abfd ATTRIBUTE_UNUSED, asection *section, void *ptr)
3102{
3103 bfd_vma vma = *(bfd_vma *) ptr;
3104 return ((section->flags & SEC_ALLOC) != 0
3105 && section->vma <= vma
3106 && vma < section->vma + section->size);
3107}
3108
699733f6 3109/* Create synthetic symbols, effectively restoring "dot-symbol" function
468392fb 3110 entry syms. Also generate @plt symbols for the glink branch table. */
90e3cdf2
JJ		 3111
3112static long
a7535cf3
AM		 3113ppc64_elf_get_synthetic_symtab (bfd *abfd,
3114 long static_count, asymbol **static_syms,
3115 long dyn_count, asymbol **dyn_syms,
c9727e01 3116 asymbol **ret)
90e3cdf2
JJ		 3117{
3118 asymbol *s;
699733f6
AM		 3119 long i;
3120 long count;
90e3cdf2 3121 char *names;
a7535cf3 3122 long symcount, codesecsym, codesecsymend, secsymend, opdsymend;
ee67d69a 3123 asection *opd = NULL;
90e3cdf2 3124 bfd_boolean relocatable = (abfd->flags & (EXEC_P | DYNAMIC)) == 0;
a7535cf3 3125 asymbol **syms;
ee67d69a 3126 int abi = abiversion (abfd);
90e3cdf2
JJ		 3127
3128 *ret = NULL;
3129
ee67d69a
AM		 3130 if (abi < 2)
3131 {
3132 opd = bfd_get_section_by_name (abfd, ".opd");
3133 if (opd == NULL && abi == 1)
3134 return 0;
3135 }
90e3cdf2 3136
a7535cf3 3137 symcount = static_count;
c9727e01 3138 if (!relocatable)
a7535cf3 3139 symcount += dyn_count;
90e3cdf2 3140 if (symcount == 0)
c9727e01 3141 return 0;
90e3cdf2 3142
a7535cf3
AM		 3143 syms = bfd_malloc ((symcount + 1) * sizeof (*syms));
3144 if (syms == NULL)
7356fed5 3145 return -1;
a7535cf3
AM		 3146
3147 if (!relocatable && static_count != 0 && dyn_count != 0)
3148 {
3149 /* Use both symbol tables. */
3150 memcpy (syms, static_syms, static_count * sizeof (*syms));
3151 memcpy (syms + static_count, dyn_syms, (dyn_count + 1) * sizeof (*syms));
3152 }
3153 else if (!relocatable && static_count == 0)
3154 memcpy (syms, dyn_syms, (symcount + 1) * sizeof (*syms));
3155 else
3156 memcpy (syms, static_syms, (symcount + 1) * sizeof (*syms));
3157
90e3cdf2 3158 synthetic_relocatable = relocatable;
595da8c5 3159 qsort (syms, symcount, sizeof (*syms), compare_symbols);
90e3cdf2 3160
c9727e01
AM		 3161 if (!relocatable && symcount > 1)
3162 {
3163 long j;
3164 /* Trim duplicate syms, since we may have merged the normal and
3165 dynamic symbols. Actually, we only care about syms that have
3b36f7e6 3166 different values, so trim any with the same value. */
c9727e01
AM		 3167 for (i = 1, j = 1; i < symcount; ++i)
3168 if (syms[i - 1]->value + syms[i - 1]->section->vma
3169 != syms[i]->value + syms[i]->section->vma)
3170 syms[j++] = syms[i];
3171 symcount = j;
3172 }
3173
699733f6 3174 i = 0;
ffcfec52 3175 if (strcmp (syms[i]->section->name, ".opd") == 0)
699733f6
AM		 3176 ++i;
3177 codesecsym = i;
90e3cdf2 3178
699733f6
AM		 3179 for (; i < symcount; ++i)
3180 if (((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3181 != (SEC_CODE | SEC_ALLOC))
3182 || (syms[i]->flags & BSF_SECTION_SYM) == 0)
3183 break;
3184 codesecsymend = i;
90e3cdf2 3185
699733f6
AM		 3186 for (; i < symcount; ++i)
3187 if ((syms[i]->flags & BSF_SECTION_SYM) == 0)
3188 break;
3189 secsymend = i;
90e3cdf2 3190
699733f6 3191 for (; i < symcount; ++i)
ffcfec52 3192 if (strcmp (syms[i]->section->name, ".opd") != 0)
699733f6
AM		 3193 break;
3194 opdsymend = i;
90e3cdf2 3195
699733f6
AM		 3196 for (; i < symcount; ++i)
3197 if ((syms[i]->section->flags & (SEC_CODE | SEC_ALLOC | SEC_THREAD_LOCAL))
3198 != (SEC_CODE | SEC_ALLOC))
3199 break;
3200 symcount = i;
3201
c9727e01 3202 count = 0;
90e3cdf2 3203
699733f6 3204 if (relocatable)
90e3cdf2 3205 {
699733f6
AM		 3206 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
3207 arelent *r;
3208 size_t size;
3209 long relcount;
90e3cdf2 3210
468392fb
AM		 3211 if (opdsymend == secsymend)
3212 goto done;
3213
699733f6 3214 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
90e3cdf2 3215 relcount = (opd->flags & SEC_RELOC) ? opd->reloc_count : 0;
7356fed5 3216 if (relcount == 0)
c9727e01 3217 goto done;
90e3cdf2 3218
7356fed5
AM		 3219 if (!(*slurp_relocs) (abfd, opd, static_syms, FALSE))
3220 {
3221 count = -1;
3222 goto done;
3223 }
3224
699733f6 3225 size = 0;
595da8c5 3226 for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
699733f6
AM		 3227 {
3228 asymbol *sym;
90e3cdf2 3229
595da8c5 3230 while (r < opd->relocation + relcount
699733f6
AM		 3231 && r->address < syms[i]->value + opd->vma)
3232 ++r;
90e3cdf2 3233
595da8c5 3234 if (r == opd->relocation + relcount)
699733f6 3235 break;
90e3cdf2 3236
699733f6
AM		 3237 if (r->address != syms[i]->value + opd->vma)
3238 continue;
90e3cdf2 3239
699733f6
AM		 3240 if (r->howto->type != R_PPC64_ADDR64)
3241 continue;
90e3cdf2 3242
699733f6
AM		 3243 sym = *r->sym_ptr_ptr;
3244 if (!sym_exists_at (syms, opdsymend, symcount,
3245 sym->section->id, sym->value + r->addend))
3246 {
3247 ++count;
3248 size += sizeof (asymbol);
3249 size += strlen (syms[i]->name) + 2;
3250 }
3251 }
90e3cdf2 3252
699733f6
AM		 3253 s = *ret = bfd_malloc (size);
3254 if (s == NULL)
3255 {
7356fed5 3256 count = -1;
c9727e01 3257 goto done;
699733f6 3258 }
90e3cdf2 3259
699733f6 3260 names = (char *) (s + count);
90e3cdf2 3261
595da8c5 3262 for (i = secsymend, r = opd->relocation; i < opdsymend; ++i)
90e3cdf2 3263 {
699733f6 3264 asymbol *sym;
90e3cdf2 3265
595da8c5 3266 while (r < opd->relocation + relcount
699733f6
AM		 3267 && r->address < syms[i]->value + opd->vma)
3268 ++r;
90e3cdf2 3269
595da8c5 3270 if (r == opd->relocation + relcount)
699733f6
AM		 3271 break;
3272
3273 if (r->address != syms[i]->value + opd->vma)
3274 continue;
3275
3276 if (r->howto->type != R_PPC64_ADDR64)
3277 continue;
90e3cdf2 3278
699733f6
AM		 3279 sym = *r->sym_ptr_ptr;
3280 if (!sym_exists_at (syms, opdsymend, symcount,
3281 sym->section->id, sym->value + r->addend))
3282 {
3283 size_t len;
3284
3285 *s = *syms[i];
6ba2a415 3286 s->flags |= BSF_SYNTHETIC;
699733f6
AM		 3287 s->section = sym->section;
3288 s->value = sym->value + r->addend;
3289 s->name = names;
3290 *names++ = '.';
3291 len = strlen (syms[i]->name);
3292 memcpy (names, syms[i]->name, len + 1);
3293 names += len + 1;
6f610d07
UW		 3294 /* Have udata.p point back to the original symbol this
3295 synthetic symbol was derived from. */
3296 s->udata.p = syms[i];
699733f6
AM		 3297 s++;
3298 }
3299 }
3300 }
3301 else
90e3cdf2 3302 {
468392fb 3303 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
ee67d69a 3304 bfd_byte *contents = NULL;
699733f6 3305 size_t size;
468392fb
AM		 3306 long plt_count = 0;
3307 bfd_vma glink_vma = 0, resolv_vma = 0;
3308 asection *dynamic, *glink = NULL, *relplt = NULL;
3309 arelent *p;
90e3cdf2 3310
ee67d69a 3311 if (opd != NULL && !bfd_malloc_and_get_section (abfd, opd, &contents))
699733f6 3312 {
ee67d69a 3313 free_contents_and_exit:
699733f6 3314 if (contents)
ee67d69a 3315 free (contents);
7356fed5 3316 count = -1;
c9727e01 3317 goto done;
699733f6 3318 }
90e3cdf2 3319
699733f6
AM		 3320 size = 0;
3321 for (i = secsymend; i < opdsymend; ++i)
3322 {
3323 bfd_vma ent;
90e3cdf2 3324
5ef11c02
AM		 3325 /* Ignore bogus symbols. */
3326 if (syms[i]->value > opd->size - 8)
3327 continue;
3328
699733f6
AM		 3329 ent = bfd_get_64 (abfd, contents + syms[i]->value);
3330 if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
3331 {
3332 ++count;
3333 size += sizeof (asymbol);
3334 size += strlen (syms[i]->name) + 2;
3335 }
3336 }
90e3cdf2 3337
468392fb 3338 /* Get start of .glink stubs from DT_PPC64_GLINK. */
066ee829
AM		 3339 if (dyn_count != 0
3340 && (dynamic = bfd_get_section_by_name (abfd, ".dynamic")) != NULL)
468392fb
AM		 3341 {
3342 bfd_byte *dynbuf, *extdyn, *extdynend;
3343 size_t extdynsize;
3344 void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *);
3345
3346 if (!bfd_malloc_and_get_section (abfd, dynamic, &dynbuf))
3347 goto free_contents_and_exit;
3348
3349 extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
3350 swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
3351
3352 extdyn = dynbuf;
3353 extdynend = extdyn + dynamic->size;
3354 for (; extdyn < extdynend; extdyn += extdynsize)
3355 {
3356 Elf_Internal_Dyn dyn;
3357 (*swap_dyn_in) (abfd, extdyn, &dyn);
3358
3359 if (dyn.d_tag == DT_NULL)
3360 break;
3361
3362 if (dyn.d_tag == DT_PPC64_GLINK)
3363 {
b9e5796b
AM		 3364 /* The first glink stub starts at offset 32; see
3365 comment in ppc64_elf_finish_dynamic_sections. */
3366 glink_vma = dyn.d_un.d_val + GLINK_CALL_STUB_SIZE - 8 * 4;
468392fb
AM		 3367 /* The .glink section usually does not survive the final
3368 link; search for the section (usually .text) where the
3369 glink stubs now reside. */
3370 glink = bfd_sections_find_if (abfd, section_covers_vma,
3371 &glink_vma);
3372 break;
3373 }
3374 }
3375
3376 free (dynbuf);
3377 }
3378
3379 if (glink != NULL)
3380 {
3381 /* Determine __glink trampoline by reading the relative branch
3382 from the first glink stub. */
3383 bfd_byte buf[4];
b9e5796b
AM		 3384 unsigned int off = 0;
3385
3386 while (bfd_get_section_contents (abfd, glink, buf,
3387 glink_vma + off - glink->vma, 4))
468392fb
AM		 3388 {
3389 unsigned int insn = bfd_get_32 (abfd, buf);
3390 insn ^= B_DOT;
3391 if ((insn & ~0x3fffffc) == 0)
b9e5796b
AM		 3392 {
3393 resolv_vma = glink_vma + off + (insn ^ 0x2000000) - 0x2000000;
3394 break;
3395 }
3396 off += 4;
3397 if (off > 4)
3398 break;
468392fb
AM		 3399 }
3400
3401 if (resolv_vma)
3402 size += sizeof (asymbol) + sizeof ("__glink_PLTresolve");
468392fb 3403
066ee829
AM		 3404 relplt = bfd_get_section_by_name (abfd, ".rela.plt");
3405 if (relplt != NULL)
3406 {
3407 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
3408 if (! (*slurp_relocs) (abfd, relplt, dyn_syms, TRUE))
3409 goto free_contents_and_exit;
68ffbac6 3410
066ee829
AM		 3411 plt_count = relplt->size / sizeof (Elf64_External_Rela);
3412 size += plt_count * sizeof (asymbol);
468392fb 3413
066ee829
AM		 3414 p = relplt->relocation;
3415 for (i = 0; i < plt_count; i++, p++)
e054468f
AM		 3416 {
3417 size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
3418 if (p->addend != 0)
3419 size += sizeof ("+0x") - 1 + 16;
3420 }
066ee829 3421 }
468392fb
AM		 3422 }
3423
699733f6
AM		 3424 s = *ret = bfd_malloc (size);
3425 if (s == NULL)
7356fed5 3426 goto free_contents_and_exit;
90e3cdf2 3427
468392fb 3428 names = (char *) (s + count + plt_count + (resolv_vma != 0));
90e3cdf2 3429
699733f6 3430 for (i = secsymend; i < opdsymend; ++i)
90e3cdf2 3431 {
699733f6 3432 bfd_vma ent;
90e3cdf2 3433
5ef11c02
AM		 3434 if (syms[i]->value > opd->size - 8)
3435 continue;
3436
699733f6
AM		 3437 ent = bfd_get_64 (abfd, contents + syms[i]->value);
3438 if (!sym_exists_at (syms, opdsymend, symcount, -1, ent))
90e3cdf2 3439 {
c9727e01 3440 long lo, hi;
699733f6 3441 size_t len;
c9727e01 3442 asection *sec = abfd->sections;
90e3cdf2 3443
699733f6
AM		 3444 *s = *syms[i];
3445 lo = codesecsym;
3446 hi = codesecsymend;
3447 while (lo < hi)
3448 {
c9727e01 3449 long mid = (lo + hi) >> 1;
699733f6
AM		 3450 if (syms[mid]->section->vma < ent)
3451 lo = mid + 1;
3452 else if (syms[mid]->section->vma > ent)
3453 hi = mid;
3454 else
c9727e01
AM		 3455 {
3456 sec = syms[mid]->section;
3457 break;
3458 }
699733f6
AM		 3459 }
3460
c9727e01 3461 if (lo >= hi && lo > codesecsym)
699733f6 3462 sec = syms[lo - 1]->section;
699733f6
AM		 3463
3464 for (; sec != NULL; sec = sec->next)
3465 {
3466 if (sec->vma > ent)
3467 break;
63524580
JK		 3468 /* SEC_LOAD may not be set if SEC is from a separate debug
3469 info file. */
3470 if ((sec->flags & SEC_ALLOC) == 0)
699733f6
AM		 3471 break;
3472 if ((sec->flags & SEC_CODE) != 0)
3473 s->section = sec;
3474 }
6ba2a415 3475 s->flags |= BSF_SYNTHETIC;
699733f6
AM		 3476 s->value = ent - s->section->vma;
3477 s->name = names;
3478 *names++ = '.';
3479 len = strlen (syms[i]->name);
3480 memcpy (names, syms[i]->name, len + 1);
3481 names += len + 1;
6f610d07
UW		 3482 /* Have udata.p point back to the original symbol this
3483 synthetic symbol was derived from. */
3484 s->udata.p = syms[i];
699733f6 3485 s++;
90e3cdf2 3486 }
90e3cdf2 3487 }
699733f6 3488 free (contents);
468392fb
AM		 3489
3490 if (glink != NULL && relplt != NULL)
3491 {
3492 if (resolv_vma)
3493 {
3494 /* Add a symbol for the main glink trampoline. */
86a4952b 3495 memset (s, 0, sizeof *s);
468392fb 3496 s->the_bfd = abfd;
6ba2a415 3497 s->flags = BSF_GLOBAL | BSF_SYNTHETIC;
468392fb
AM		 3498 s->section = glink;
3499 s->value = resolv_vma - glink->vma;
3500 s->name = names;
3501 memcpy (names, "__glink_PLTresolve", sizeof ("__glink_PLTresolve"));
3502 names += sizeof ("__glink_PLTresolve");
3503 s++;
3504 count++;
3505 }
3506
3507 /* FIXME: It would be very much nicer to put sym@plt on the
3508 stub rather than on the glink branch table entry. The
3509 objdump disassembler would then use a sensible symbol
3510 name on plt calls. The difficulty in doing so is
3511 a) finding the stubs, and,
3512 b) matching stubs against plt entries, and,
3513 c) there can be multiple stubs for a given plt entry.
3514
3515 Solving (a) could be done by code scanning, but older
3516 ppc64 binaries used different stubs to current code.
3517 (b) is the tricky one since you need to known the toc
3518 pointer for at least one function that uses a pic stub to
3519 be able to calculate the plt address referenced.
3520 (c) means gdb would need to set multiple breakpoints (or
3521 find the glink branch itself) when setting breakpoints
3522 for pending shared library loads. */
3523 p = relplt->relocation;
3524 for (i = 0; i < plt_count; i++, p++)
3525 {
3526 size_t len;
3527
3528 *s = **p->sym_ptr_ptr;
3529 /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set. Since
3530 we are defining a symbol, ensure one of them is set. */
3531 if ((s->flags & BSF_LOCAL) == 0)
3532 s->flags |= BSF_GLOBAL;
6ba2a415 3533 s->flags |= BSF_SYNTHETIC;
468392fb
AM		 3534 s->section = glink;
3535 s->value = glink_vma - glink->vma;
3536 s->name = names;
3537 s->udata.p = NULL;
3538 len = strlen ((*p->sym_ptr_ptr)->name);
3539 memcpy (names, (*p->sym_ptr_ptr)->name, len);
3540 names += len;
e054468f
AM		 3541 if (p->addend != 0)
3542 {
3543 memcpy (names, "+0x", sizeof ("+0x") - 1);
3544 names += sizeof ("+0x") - 1;
3545 bfd_sprintf_vma (abfd, names, p->addend);
3546 names += strlen (names);
3547 }
468392fb
AM		 3548 memcpy (names, "@plt", sizeof ("@plt"));
3549 names += sizeof ("@plt");
3550 s++;
b9e5796b
AM		 3551 if (abi < 2)
3552 {
3553 glink_vma += 8;
3554 if (i >= 0x8000)
3555 glink_vma += 4;
3556 }
3557 else
468392fb
AM		 3558 glink_vma += 4;
3559 }
3560 count += plt_count;
3561 }
90e3cdf2
JJ		 3562 }
3563
c9727e01 3564 done:
a7535cf3 3565 free (syms);
90e3cdf2
JJ		 3566 return count;
3567}
5bd4f169 3568\f
65f38f15
AM		 3569/* The following functions are specific to the ELF linker, while
3570 functions above are used generally. Those named ppc64_elf_* are
3571 called by the main ELF linker code. They appear in this file more
3572 or less in the order in which they are called. eg.
3573 ppc64_elf_check_relocs is called early in the link process,
3574 ppc64_elf_finish_dynamic_sections is one of the last functions
e86ce104
AM		 3575 called.
3576
3577 PowerPC64-ELF uses a similar scheme to PowerPC64-XCOFF in that
3578 functions have both a function code symbol and a function descriptor
3579 symbol. A call to foo in a relocatable object file looks like:
3580
3581 . .text
3582 . x:
3583 . bl .foo
3584 . nop
3585
3586 The function definition in another object file might be:
3587
3588 . .section .opd
3589 . foo: .quad .foo
3590 . .quad .TOC.@tocbase
3591 . .quad 0
3592 .
3593 . .text
3594 . .foo: blr
3595
3596 When the linker resolves the call during a static link, the branch
3597 unsurprisingly just goes to .foo and the .opd information is unused.
3598 If the function definition is in a shared library, things are a little
3599 different: The call goes via a plt call stub, the opd information gets
3600 copied to the plt, and the linker patches the nop.
3601
3602 . x:
3603 . bl .foo_stub
3604 . ld 2,40(1)
3605 .
3606 .
3607 . .foo_stub:
71a39c98
AM		 3608 . std 2,40(1) # in practice, the call stub
3609 . addis 11,2,Lfoo@toc@ha # is slightly optimized, but
3610 . addi 11,11,Lfoo@toc@l # this is the general idea
3611 . ld 12,0(11)
3612 . ld 2,8(11)
3613 . mtctr 12
3614 . ld 11,16(11)
e86ce104
AM		 3615 . bctr
3616 .
3617 . .section .plt
3618 . Lfoo: reloc (R_PPC64_JMP_SLOT, foo)
3619
3620 The "reloc ()" notation is supposed to indicate that the linker emits
3621 an R_PPC64_JMP_SLOT reloc against foo. The dynamic linker does the opd
3622 copying.
3623
3624 What are the difficulties here? Well, firstly, the relocations
3625 examined by the linker in check_relocs are against the function code
3626 sym .foo, while the dynamic relocation in the plt is emitted against
3627 the function descriptor symbol, foo. Somewhere along the line, we need
3628 to carefully copy dynamic link information from one symbol to the other.
3629 Secondly, the generic part of the elf linker will make .foo a dynamic
3630 symbol as is normal for most other backends. We need foo dynamic
3631 instead, at least for an application final link. However, when
3632 creating a shared library containing foo, we need to have both symbols
3633 dynamic so that references to .foo are satisfied during the early
3634 stages of linking. Otherwise the linker might decide to pull in a
8387904d
AM		 3635 definition from some other object, eg. a static library.
3636
3637 Update: As of August 2004, we support a new convention. Function
3638 calls may use the function descriptor symbol, ie. "bl foo". This
3639 behaves exactly as "bl .foo". */
65f38f15 3640
1d483afe 3641/* Of those relocs that might be copied as dynamic relocs, this function
58ac9f71
AM		 3642 selects those that must be copied when linking a shared library,
3643 even when the symbol is local. */
65f38f15 3644
1d483afe
AM		 3645static int
3646must_be_dyn_reloc (struct bfd_link_info *info,
3647 enum elf_ppc64_reloc_type r_type)
3648{
3649 switch (r_type)
3650 {
3651 default:
3652 return 1;
3653
3654 case R_PPC64_REL32:
3655 case R_PPC64_REL64:
3656 case R_PPC64_REL30:
3657 return 0;
3658
3659 case R_PPC64_TPREL16:
3660 case R_PPC64_TPREL16_LO:
3661 case R_PPC64_TPREL16_HI:
3662 case R_PPC64_TPREL16_HA:
3663 case R_PPC64_TPREL16_DS:
3664 case R_PPC64_TPREL16_LO_DS:
f9c6b907
AM		 3665 case R_PPC64_TPREL16_HIGH:
3666 case R_PPC64_TPREL16_HIGHA:
1d483afe
AM		 3667 case R_PPC64_TPREL16_HIGHER:
3668 case R_PPC64_TPREL16_HIGHERA:
3669 case R_PPC64_TPREL16_HIGHEST:
3670 case R_PPC64_TPREL16_HIGHESTA:
3671 case R_PPC64_TPREL64:
3672 return !info->executable;
3673 }
3674}
65f38f15 3675
f4656909
AM		 3676/* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
3677 copying dynamic variables from a shared lib into an app's dynbss
3678 section, and instead use a dynamic relocation to point into the
5d35169e
AM		 3679 shared lib. With code that gcc generates, it's vital that this be
3680 enabled; In the PowerPC64 ABI, the address of a function is actually
3681 the address of a function descriptor, which resides in the .opd
3682 section. gcc uses the descriptor directly rather than going via the
3683 GOT as some other ABI's do, which means that initialized function
3684 pointers must reference the descriptor. Thus, a function pointer
3685 initialized to the address of a function in a shared library will
3686 either require a copy reloc, or a dynamic reloc. Using a copy reloc
4cc11e76 3687 redefines the function descriptor symbol to point to the copy. This
5d35169e
AM		 3688 presents a problem as a plt entry for that function is also
3689 initialized from the function descriptor symbol and the copy reloc
3690 may not be initialized first. */
a23b6845 3691#define ELIMINATE_COPY_RELOCS 1
f4656909 3692
721956f4 3693/* Section name for stubs is the associated section name plus this
29942be8
NC		 3694 string. */
3695#define STUB_SUFFIX ".stub"
721956f4
AM		 3696
3697/* Linker stubs.
3698 ppc_stub_long_branch:
3699 Used when a 14 bit branch (or even a 24 bit branch) can't reach its
3700 destination, but a 24 bit branch in a stub section will reach.
3701 . b dest
3702
3703 ppc_stub_plt_branch:
3704 Similar to the above, but a 24 bit branch in the stub section won't
3705 reach its destination.
71a39c98
AM		 3706 . addis %r11,%r2,xxx@toc@ha
3707 . ld %r12,xxx@toc@l(%r11)
3708 . mtctr %r12
721956f4
AM		 3709 . bctr
3710
3711 ppc_stub_plt_call:
2c66dc6c
AM		 3712 Used to call a function in a shared library. If it so happens that
3713 the plt entry referenced crosses a 64k boundary, then an extra
71a39c98 3714 "addi %r11,%r11,xxx@toc@l" will be inserted before the "mtctr".
721956f4 3715 . std %r2,40(%r1)
71a39c98
AM		 3716 . addis %r11,%r2,xxx@toc@ha
3717 . ld %r12,xxx+0@toc@l(%r11)
3718 . mtctr %r12
3719 . ld %r2,xxx+8@toc@l(%r11)
3720 . ld %r11,xxx+16@toc@l(%r11)
721956f4 3721 . bctr
ad8e1ba5
AM		 3722
3723 ppc_stub_long_branch and ppc_stub_plt_branch may also have additional
3724 code to adjust the value and save r2 to support multiple toc sections.
3725 A ppc_stub_long_branch with an r2 offset looks like:
3726 . std %r2,40(%r1)
3727 . addis %r2,%r2,off@ha
3728 . addi %r2,%r2,off@l
3729 . b dest
3730
3731 A ppc_stub_plt_branch with an r2 offset looks like:
3732 . std %r2,40(%r1)
71a39c98
AM		 3733 . addis %r11,%r2,xxx@toc@ha
3734 . ld %r12,xxx@toc@l(%r11)
ad8e1ba5
AM		 3735 . addis %r2,%r2,off@ha
3736 . addi %r2,%r2,off@l
71a39c98 3737 . mtctr %r12
ad8e1ba5 3738 . bctr
ac2df442
AM		 3739
3740 In cases where the "addis" instruction would add zero, the "addis" is
3741 omitted and following instructions modified slightly in some cases.
721956f4
AM		 3742*/
3743
3744enum ppc_stub_type {
3745 ppc_stub_none,
3746 ppc_stub_long_branch,
ad8e1ba5 3747 ppc_stub_long_branch_r2off,
721956f4 3748 ppc_stub_plt_branch,
ad8e1ba5 3749 ppc_stub_plt_branch_r2off,
794e51c0
AM		 3750 ppc_stub_plt_call,
3751 ppc_stub_plt_call_r2save
721956f4
AM		 3752};
3753
3754struct ppc_stub_hash_entry {
3755
3756 /* Base hash table entry structure. */
3757 struct bfd_hash_entry root;
3758
ad8e1ba5
AM		 3759 enum ppc_stub_type stub_type;
3760
721956f4
AM		 3761 /* The stub section. */
3762 asection *stub_sec;
3763
3764 /* Offset within stub_sec of the beginning of this stub. */
3765 bfd_vma stub_offset;
3766
3767 /* Given the symbol's value and its section we can determine its final
3768 value when building the stubs (so the stub knows where to jump. */
3769 bfd_vma target_value;
3770 asection *target_section;
3771
721956f4
AM		 3772 /* The symbol table entry, if any, that this was derived from. */
3773 struct ppc_link_hash_entry *h;
e054468f 3774 struct plt_entry *plt_ent;
721956f4
AM		 3775
3776 /* Where this stub is being called from, or, in the case of combined
3777 stub sections, the first input section in the group. */
3778 asection *id_sec;
6911b7dc
AM		 3779
3780 /* Symbol st_other. */
3781 unsigned char other;
721956f4
AM		 3782};
3783
3784struct ppc_branch_hash_entry {
3785
3786 /* Base hash table entry structure. */
3787 struct bfd_hash_entry root;
3788
c456f082 3789 /* Offset within branch lookup table. */
721956f4
AM		 3790 unsigned int offset;
3791
3792 /* Generation marker. */
3793 unsigned int iter;
3794};
65f38f15 3795
19e08130
AM		 3796/* Used to track dynamic relocations for local symbols. */
3797struct ppc_dyn_relocs
3798{
3799 struct ppc_dyn_relocs *next;
3800
3801 /* The input section of the reloc. */
3802 asection *sec;
3803
3804 /* Total number of relocs copied for the input section. */
3805 unsigned int count : 31;
3806
3807 /* Whether this entry is for STT_GNU_IFUNC symbols. */
3808 unsigned int ifunc : 1;
3809};
3810
65f38f15
AM		 3811struct ppc_link_hash_entry
3812{
3813 struct elf_link_hash_entry elf;
3814
b3fac117
AM		 3815 union {
3816 /* A pointer to the most recently used stub hash entry against this
3817 symbol. */
3818 struct ppc_stub_hash_entry *stub_cache;
3819
3820 /* A pointer to the next symbol starting with a '.' */
3821 struct ppc_link_hash_entry *next_dot_sym;
3822 } u;
721956f4 3823
65f38f15 3824 /* Track dynamic relocs copied for this symbol. */
6061a67d 3825 struct elf_dyn_relocs *dyn_relocs;
e86ce104 3826
721956f4 3827 /* Link between function code and descriptor symbols. */
34814b9f 3828 struct ppc_link_hash_entry *oh;
721956f4 3829
e86ce104
AM		 3830 /* Flag function code and descriptor symbols. */
3831 unsigned int is_func:1;
3832 unsigned int is_func_descriptor:1;
908b32fc 3833 unsigned int fake:1;
411e1bfb 3834
c5614fa4
AM		 3835 /* Whether global opd/toc sym has been adjusted or not.
3836 After ppc64_elf_edit_opd/ppc64_elf_edit_toc has run, this flag
3837 should be set for all globals defined in any opd/toc section. */
754021d0
AM		 3838 unsigned int adjust_done:1;
3839
99877b66
AM		 3840 /* Set if we twiddled this symbol to weak at some stage. */
3841 unsigned int was_undefined:1;
3842
411e1bfb 3843 /* Contexts in which symbol is used in the GOT (or TOC).
e7b938ca
AM		 3844 TLS_GD .. TLS_EXPLICIT bits are or'd into the mask as the
3845 corresponding relocs are encountered during check_relocs.
3846 tls_optimize clears TLS_GD .. TLS_TPREL when optimizing to
3847 indicate the corresponding GOT entry type is not needed.
3848 tls_optimize may also set TLS_TPRELGD when a GD reloc turns into
3849 a TPREL one. We use a separate flag rather than setting TPREL
3850 just for convenience in distinguishing the two cases. */
3851#define TLS_GD 1 /* GD reloc. */
3852#define TLS_LD 2 /* LD reloc. */
3853#define TLS_TPREL 4 /* TPREL reloc, => IE. */
3854#define TLS_DTPREL 8 /* DTPREL reloc, => LD. */
3855#define TLS_TLS 16 /* Any TLS reloc. */
3856#define TLS_EXPLICIT 32 /* Marks TOC section TLS relocs. */
3857#define TLS_TPRELGD 64 /* TPREL reloc resulting from GD->IE. */
e054468f 3858#define PLT_IFUNC 128 /* STT_GNU_IFUNC. */
f961d9dd 3859 unsigned char tls_mask;
65f38f15
AM		 3860};
3861
3862/* ppc64 ELF linker hash table. */
3863
3864struct ppc_link_hash_table
3865{
3866 struct elf_link_hash_table elf;
3867
721956f4
AM		 3868 /* The stub hash table. */
3869 struct bfd_hash_table stub_hash_table;
3870
3871 /* Another hash table for plt_branch stubs. */
3872 struct bfd_hash_table branch_hash_table;
3873
3b421ab3
AM		 3874 /* Hash table for function prologue tocsave. */
3875 htab_t tocsave_htab;
3876
721956f4
AM		 3877 /* Linker stub bfd. */
3878 bfd *stub_bfd;
3879
3880 /* Linker call-backs. */
4ce794b7
AM		 3881 asection * (*add_stub_section) (const char *, asection *);
3882 void (*layout_sections_again) (void);
721956f4
AM		 3883
3884 /* Array to keep track of which stub sections have been created, and
3885 information on stub grouping. */
3886 struct map_stub {
3887 /* This is the section to which stubs in the group will be attached. */
3888 asection *link_sec;
3889 /* The stub section. */
3890 asection *stub_sec;
ad8e1ba5
AM		 3891 /* Along with elf_gp, specifies the TOC pointer used in this group. */
3892 bfd_vma toc_off;
721956f4
AM		 3893 } *stub_group;
3894
ad8e1ba5
AM		 3895 /* Temp used when calculating TOC pointers. */
3896 bfd_vma toc_curr;
bf102f86
AM		 3897 bfd *toc_bfd;
3898 asection *toc_first_sec;
ad8e1ba5 3899
8f3bab57
AM		 3900 /* Highest input section id. */
3901 int top_id;
3902
734b6cf9
AM		 3903 /* Highest output section index. */
3904 int top_index;
3905
b3fac117
AM		 3906 /* Used when adding symbols. */
3907 struct ppc_link_hash_entry *dot_syms;
3908
734b6cf9
AM		 3909 /* List of input sections for each output section. */
3910 asection **input_list;
721956f4 3911
33e44f2e 3912 /* Shortcuts to get to dynamic linker sections. */
4ce794b7
AM		 3913 asection *dynbss;
3914 asection *relbss;
3915 asection *glink;
82bd7b59 3916 asection *sfpr;
4ce794b7
AM		 3917 asection *brlt;
3918 asection *relbrlt;
58d180e8 3919 asection *glink_eh_frame;
ec338859 3920
8387904d
AM		 3921 /* Shortcut to .__tls_get_addr and __tls_get_addr. */
3922 struct ppc_link_hash_entry *tls_get_addr;
3923 struct ppc_link_hash_entry *tls_get_addr_fd;
411e1bfb 3924
927be08e
AM		 3925 /* The size of reliplt used by got entry relocs. */
3926 bfd_size_type got_reli_size;
3927
9b5ecbd0 3928 /* Statistics. */
794e51c0 3929 unsigned long stub_count[ppc_stub_plt_call_r2save];
9b5ecbd0 3930
ee75fd95
AM		 3931 /* Number of stubs against global syms. */
3932 unsigned long stub_globals;
3933
794e51c0
AM		 3934 /* Alignment of PLT call stubs. */
3935 unsigned int plt_stub_align:4;
3936
ee67d69a
AM		 3937 /* Set if we're linking code with function descriptors. */
3938 unsigned int opd_abi:1;
3939
9df0ef5f
AM		 3940 /* Set if PLT call stubs should load r11. */
3941 unsigned int plt_static_chain:1;
3942
794e51c0
AM		 3943 /* Set if PLT call stubs need a read-read barrier. */
3944 unsigned int plt_thread_safe:1;
3945
ad8e1ba5 3946 /* Set if we should emit symbols for stubs. */
99877b66 3947 unsigned int emit_stub_syms:1;
ad8e1ba5 3948
a7f2871e
AM		 3949 /* Set if __tls_get_addr optimization should not be done. */
3950 unsigned int no_tls_get_addr_opt:1;
3951
4c52953f 3952 /* Support for multiple toc sections. */
33c0ec9d 3953 unsigned int do_multi_toc:1;
4c52953f 3954 unsigned int multi_toc_needed:1;
927be08e 3955 unsigned int second_toc_pass:1;
67f0cbdb 3956 unsigned int do_toc_opt:1;
4c52953f 3957
5d1634d7 3958 /* Set on error. */
99877b66 3959 unsigned int stub_error:1;
721956f4 3960
7d9616d7 3961 /* Temp used by ppc64_elf_process_dot_syms. */
99877b66 3962 unsigned int twiddled_syms:1;
721956f4
AM		 3963
3964 /* Incremented every time we size stubs. */
3965 unsigned int stub_iteration;
5d1634d7 3966
87d72d41
AM		 3967 /* Small local sym cache. */
3968 struct sym_cache sym_cache;
65f38f15
AM		 3969};
3970
4c52953f
AM		 3971/* Rename some of the generic section flags to better document how they
3972 are used here. */
b0dddeec
AM		 3973
3974/* Nonzero if this section has TLS related relocations. */
3975#define has_tls_reloc sec_flg0
3976
3977/* Nonzero if this section has a call to __tls_get_addr. */
3978#define has_tls_get_addr_call sec_flg1
3979
3980/* Nonzero if this section has any toc or got relocs. */
3981#define has_toc_reloc sec_flg2
3982
3983/* Nonzero if this section has a call to another section that uses
3984 the toc or got. */
d77c8a4b 3985#define makes_toc_func_call sec_flg3
b0dddeec
AM		 3986
3987/* Recursion protection when determining above flag. */
d77c8a4b 3988#define call_check_in_progress sec_flg4
70cc837d 3989#define call_check_done sec_flg5
4c52953f 3990
65f38f15
AM		 3991/* Get the ppc64 ELF linker hash table from a link_info structure. */
3992
3993#define ppc_hash_table(p) \
4dfe6ac6
NC		 3994 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
3995 == PPC64_ELF_DATA ? ((struct ppc_link_hash_table *) ((p)->hash)) : NULL)
65f38f15 3996
721956f4
AM		 3997#define ppc_stub_hash_lookup(table, string, create, copy) \
3998 ((struct ppc_stub_hash_entry *) \
3999 bfd_hash_lookup ((table), (string), (create), (copy)))
4000
4001#define ppc_branch_hash_lookup(table, string, create, copy) \
4002 ((struct ppc_branch_hash_entry *) \
4003 bfd_hash_lookup ((table), (string), (create), (copy)))
4004
4005/* Create an entry in the stub hash table. */
4006
4007static struct bfd_hash_entry *
4ce794b7
AM		 4008stub_hash_newfunc (struct bfd_hash_entry *entry,
4009 struct bfd_hash_table *table,
4010 const char *string)
721956f4
AM		 4011{
4012 /* Allocate the structure if it has not already been allocated by a
4013 subclass. */
4014 if (entry == NULL)
4015 {
4016 entry = bfd_hash_allocate (table, sizeof (struct ppc_stub_hash_entry));
4017 if (entry == NULL)
4018 return entry;
4019 }
4020
4021 /* Call the allocation method of the superclass. */
4022 entry = bfd_hash_newfunc (entry, table, string);
4023 if (entry != NULL)
4024 {
4025 struct ppc_stub_hash_entry *eh;
4026
4027 /* Initialize the local fields. */
4028 eh = (struct ppc_stub_hash_entry *) entry;
ad8e1ba5 4029 eh->stub_type = ppc_stub_none;
721956f4
AM		 4030 eh->stub_sec = NULL;
4031 eh->stub_offset = 0;
4032 eh->target_value = 0;
4033 eh->target_section = NULL;
721956f4 4034 eh->h = NULL;
6911b7dc 4035 eh->plt_ent = NULL;
721956f4 4036 eh->id_sec = NULL;
6911b7dc 4037 eh->other = 0;
721956f4
AM		 4038 }
4039
4040 return entry;
4041}
4042
4043/* Create an entry in the branch hash table. */
4044
4045static struct bfd_hash_entry *
4ce794b7
AM		 4046branch_hash_newfunc (struct bfd_hash_entry *entry,
4047 struct bfd_hash_table *table,
4048 const char *string)
721956f4
AM		 4049{
4050 /* Allocate the structure if it has not already been allocated by a
4051 subclass. */
4052 if (entry == NULL)
4053 {
4054 entry = bfd_hash_allocate (table, sizeof (struct ppc_branch_hash_entry));
4055 if (entry == NULL)
4056 return entry;
4057 }
4058
4059 /* Call the allocation method of the superclass. */
4060 entry = bfd_hash_newfunc (entry, table, string);
4061 if (entry != NULL)
4062 {
4063 struct ppc_branch_hash_entry *eh;
4064
4065 /* Initialize the local fields. */
4066 eh = (struct ppc_branch_hash_entry *) entry;
4067 eh->offset = 0;
4068 eh->iter = 0;
4069 }
4070
4071 return entry;
4072}
4073
65f38f15
AM		 4074/* Create an entry in a ppc64 ELF linker hash table. */
4075
4076static struct bfd_hash_entry *
4ce794b7
AM		 4077link_hash_newfunc (struct bfd_hash_entry *entry,
4078 struct bfd_hash_table *table,
4079 const char *string)
65f38f15
AM		 4080{
4081 /* Allocate the structure if it has not already been allocated by a
4082 subclass. */
4083 if (entry == NULL)
4084 {
4085 entry = bfd_hash_allocate (table, sizeof (struct ppc_link_hash_entry));
4086 if (entry == NULL)
4087 return entry;
4088 }
4089
4090 /* Call the allocation method of the superclass. */
4091 entry = _bfd_elf_link_hash_newfunc (entry, table, string);
4092 if (entry != NULL)
4093 {
4094 struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) entry;
4095
b3fac117 4096 memset (&eh->u.stub_cache, 0,
908b32fc 4097 (sizeof (struct ppc_link_hash_entry)
b3fac117
AM		 4098 - offsetof (struct ppc_link_hash_entry, u.stub_cache)));
4099
4100 /* When making function calls, old ABI code references function entry
4101 points (dot symbols), while new ABI code references the function
4102 descriptor symbol. We need to make any combination of reference and
4103 definition work together, without breaking archive linking.
4104
4105 For a defined function "foo" and an undefined call to "bar":
4106 An old object defines "foo" and ".foo", references ".bar" (possibly
4107 "bar" too).
4108 A new object defines "foo" and references "bar".
4109
4110 A new object thus has no problem with its undefined symbols being
4111 satisfied by definitions in an old object. On the other hand, the
4112 old object won't have ".bar" satisfied by a new object.
4113
4114 Keep a list of newly added dot-symbols. */
4115
4116 if (string[0] == '.')
4117 {
4118 struct ppc_link_hash_table *htab;
4119
4120 htab = (struct ppc_link_hash_table *) table;
4121 eh->u.next_dot_sym = htab->dot_syms;
4122 htab->dot_syms = eh;
4123 }
65f38f15
AM		 4124 }
4125
4126 return entry;
4127}
4128
3b421ab3
AM		 4129struct tocsave_entry {
4130 asection *sec;
4131 bfd_vma offset;
4132};
4133
4134static hashval_t
4135tocsave_htab_hash (const void *p)
4136{
4137 const struct tocsave_entry *e = (const struct tocsave_entry *) p;
4138 return ((bfd_vma)(intptr_t) e->sec ^ e->offset) >> 3;
4139}
4140
4141static int
4142tocsave_htab_eq (const void *p1, const void *p2)
4143{
4144 const struct tocsave_entry *e1 = (const struct tocsave_entry *) p1;
4145 const struct tocsave_entry *e2 = (const struct tocsave_entry *) p2;
4146 return e1->sec == e2->sec && e1->offset == e2->offset;
4147}
4148
65f38f15
AM		 4149/* Create a ppc64 ELF linker hash table. */
4150
4151static struct bfd_link_hash_table *
4ce794b7 4152ppc64_elf_link_hash_table_create (bfd *abfd)
65f38f15
AM		 4153{
4154 struct ppc_link_hash_table *htab;
4155 bfd_size_type amt = sizeof (struct ppc_link_hash_table);
4156
4ce794b7 4157 htab = bfd_zmalloc (amt);
65f38f15
AM		 4158 if (htab == NULL)
4159 return NULL;
4160
66eb6687 4161 if (!_bfd_elf_link_hash_table_init (&htab->elf, abfd, link_hash_newfunc,
4dfe6ac6
NC		 4162 sizeof (struct ppc_link_hash_entry),
4163 PPC64_ELF_DATA))
65f38f15 4164 {
e2d34d7d 4165 free (htab);
65f38f15
AM		 4166 return NULL;
4167 }
4168
721956f4 4169 /* Init the stub hash table too. */
66eb6687
AM		 4170 if (!bfd_hash_table_init (&htab->stub_hash_table, stub_hash_newfunc,
4171 sizeof (struct ppc_stub_hash_entry)))
721956f4
AM		 4172 return NULL;
4173
4174 /* And the branch hash table. */
66eb6687
AM		 4175 if (!bfd_hash_table_init (&htab->branch_hash_table, branch_hash_newfunc,
4176 sizeof (struct ppc_branch_hash_entry)))
721956f4
AM		 4177 return NULL;
4178
3b421ab3
AM		 4179 htab->tocsave_htab = htab_try_create (1024,
4180 tocsave_htab_hash,
4181 tocsave_htab_eq,
4182 NULL);
4183 if (htab->tocsave_htab == NULL)
4184 return NULL;
4185
3254fd24
AM		 4186 /* Initializing two fields of the union is just cosmetic. We really
4187 only care about glist, but when compiled on a 32-bit host the
4188 bfd_vma fields are larger. Setting the bfd_vma to zero makes
4189 debugger inspection of these fields look nicer. */
a6aa5195
AM		 4190 htab->elf.init_got_refcount.refcount = 0;
4191 htab->elf.init_got_refcount.glist = NULL;
4192 htab->elf.init_plt_refcount.refcount = 0;
4193 htab->elf.init_plt_refcount.glist = NULL;
4194 htab->elf.init_got_offset.offset = 0;
4195 htab->elf.init_got_offset.glist = NULL;
4196 htab->elf.init_plt_offset.offset = 0;
4197 htab->elf.init_plt_offset.glist = NULL;
3254fd24 4198
65f38f15
AM		 4199 return &htab->elf.root;
4200}
4201
721956f4
AM		 4202/* Free the derived linker hash table. */
4203
4204static void
4ce794b7 4205ppc64_elf_link_hash_table_free (struct bfd_link_hash_table *hash)
721956f4 4206{
3b421ab3 4207 struct ppc_link_hash_table *htab = (struct ppc_link_hash_table *) hash;
721956f4 4208
3b421ab3
AM		 4209 bfd_hash_table_free (&htab->stub_hash_table);
4210 bfd_hash_table_free (&htab->branch_hash_table);
4211 if (htab->tocsave_htab)
4212 htab_delete (htab->tocsave_htab);
9f7c3e5e 4213 _bfd_elf_link_hash_table_free (hash);
721956f4
AM		 4214}
4215
bfeb4a28
AM		 4216/* Create sections for linker generated code. */
4217
4218static bfd_boolean
4219create_linkage_sections (bfd *dynobj, struct bfd_link_info *info)
4220{
4221 struct ppc_link_hash_table *htab;
4222 flagword flags;
4223
4224 htab = ppc_hash_table (info);
4225
4226 /* Create .sfpr for code to save and restore fp regs. */
4227 flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY
4228 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4229 htab->sfpr = bfd_make_section_anyway_with_flags (dynobj, ".sfpr",
4230 flags);
4231 if (htab->sfpr == NULL
4232 || ! bfd_set_section_alignment (dynobj, htab->sfpr, 2))
4233 return FALSE;
4234
4235 /* Create .glink for lazy dynamic linking support. */
4236 htab->glink = bfd_make_section_anyway_with_flags (dynobj, ".glink",
4237 flags);
4238 if (htab->glink == NULL
4239 || ! bfd_set_section_alignment (dynobj, htab->glink, 3))
4240 return FALSE;
4241
4242 if (!info->no_ld_generated_unwind_info)
4243 {
4244 flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_HAS_CONTENTS
4245 | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4246 htab->glink_eh_frame = bfd_make_section_anyway_with_flags (dynobj,
4247 ".eh_frame",
4248 flags);
4249 if (htab->glink_eh_frame == NULL
4250 || !bfd_set_section_alignment (dynobj, htab->glink_eh_frame, 2))
4251 return FALSE;
4252 }
4253
4254 flags = SEC_ALLOC | SEC_LINKER_CREATED;
33e44f2e
AM		 4255 htab->elf.iplt = bfd_make_section_anyway_with_flags (dynobj, ".iplt", flags);
4256 if (htab->elf.iplt == NULL
4257 || ! bfd_set_section_alignment (dynobj, htab->elf.iplt, 3))
bfeb4a28
AM		 4258 return FALSE;
4259
4260 flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4261 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
33e44f2e
AM		 4262 htab->elf.irelplt
4263 = bfd_make_section_anyway_with_flags (dynobj, ".rela.iplt", flags);
4264 if (htab->elf.irelplt == NULL
4265 || ! bfd_set_section_alignment (dynobj, htab->elf.irelplt, 3))
bfeb4a28
AM		 4266 return FALSE;
4267
4268 /* Create branch lookup table for plt_branch stubs. */
4269 flags = (SEC_ALLOC | SEC_LOAD
4270 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4271 htab->brlt = bfd_make_section_anyway_with_flags (dynobj, ".branch_lt",
4272 flags);
4273 if (htab->brlt == NULL
4274 || ! bfd_set_section_alignment (dynobj, htab->brlt, 3))
4275 return FALSE;
4276
4277 if (!info->shared)
4278 return TRUE;
4279
4280 flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
4281 | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4282 htab->relbrlt = bfd_make_section_anyway_with_flags (dynobj,
4283 ".rela.branch_lt",
4284 flags);
4285 if (htab->relbrlt == NULL
4286 || ! bfd_set_section_alignment (dynobj, htab->relbrlt, 3))
4287 return FALSE;
4288
4289 return TRUE;
4290}
4291
e717da7e
AM		 4292/* Satisfy the ELF linker by filling in some fields in our fake bfd. */
4293
bfeb4a28 4294bfd_boolean
e717da7e
AM		 4295ppc64_elf_init_stub_bfd (bfd *abfd, struct bfd_link_info *info)
4296{
4297 struct ppc_link_hash_table *htab;
4298
4299 elf_elfheader (abfd)->e_ident[EI_CLASS] = ELFCLASS64;
4300
4301/* Always hook our dynamic sections into the first bfd, which is the
4302 linker created stub bfd. This ensures that the GOT header is at
4303 the start of the output TOC section. */
4304 htab = ppc_hash_table (info);
4dfe6ac6 4305 if (htab == NULL)
bfeb4a28 4306 return FALSE;
e717da7e
AM		 4307 htab->stub_bfd = abfd;
4308 htab->elf.dynobj = abfd;
bfeb4a28
AM		 4309
4310 if (info->relocatable)
4311 return TRUE;
4312
4313 return create_linkage_sections (htab->elf.dynobj, info);
e717da7e
AM		 4314}
4315
721956f4
AM		 4316/* Build a name for an entry in the stub hash table. */
4317
4318static char *
4ce794b7
AM		 4319ppc_stub_name (const asection *input_section,
4320 const asection *sym_sec,
4321 const struct ppc_link_hash_entry *h,
4322 const Elf_Internal_Rela *rel)
721956f4
AM		 4323{
4324 char *stub_name;
bcaa2f82 4325 ssize_t len;
721956f4
AM		 4326
4327 /* rel->r_addend is actually 64 bit, but who uses more than +/- 2^31
4328 offsets from a sym as a branch target? In fact, we could
4329 probably assume the addend is always zero. */
4330 BFD_ASSERT (((int) rel->r_addend & 0xffffffff) == rel->r_addend);
4331
4332 if (h)
4333 {
4334 len = 8 + 1 + strlen (h->elf.root.root.string) + 1 + 8 + 1;
4335 stub_name = bfd_malloc (len);
46de2a7c
AM		 4336 if (stub_name == NULL)
4337 return stub_name;
4338
bcaa2f82
AM		 4339 len = sprintf (stub_name, "%08x.%s+%x",
4340 input_section->id & 0xffffffff,
4341 h->elf.root.root.string,
4342 (int) rel->r_addend & 0xffffffff);
721956f4
AM		 4343 }
4344 else
4345 {
ad8e1ba5 4346 len = 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1;
721956f4 4347 stub_name = bfd_malloc (len);
46de2a7c
AM		 4348 if (stub_name == NULL)
4349 return stub_name;
4350
bcaa2f82
AM		 4351 len = sprintf (stub_name, "%08x.%x:%x+%x",
4352 input_section->id & 0xffffffff,
4353 sym_sec->id & 0xffffffff,
4354 (int) ELF64_R_SYM (rel->r_info) & 0xffffffff,
4355 (int) rel->r_addend & 0xffffffff);
721956f4 4356 }
bcaa2f82 4357 if (len > 2 && stub_name[len - 2] == '+' && stub_name[len - 1] == '0')
ee75fd95 4358 stub_name[len - 2] = 0;
721956f4
AM		 4359 return stub_name;
4360}
4361
4362/* Look up an entry in the stub hash. Stub entries are cached because
4363 creating the stub name takes a bit of time. */
4364
4365static struct ppc_stub_hash_entry *
4ce794b7
AM		 4366ppc_get_stub_entry (const asection *input_section,
4367 const asection *sym_sec,
039b3fef 4368 struct ppc_link_hash_entry *h,
4ce794b7
AM		 4369 const Elf_Internal_Rela *rel,
4370 struct ppc_link_hash_table *htab)
721956f4
AM		 4371{
4372 struct ppc_stub_hash_entry *stub_entry;
721956f4
AM		 4373 const asection *id_sec;
4374
4375 /* If this input section is part of a group of sections sharing one
4376 stub section, then use the id of the first section in the group.
4377 Stub names need to include a section id, as there may well be
4378 more than one stub used to reach say, printf, and we need to
4379 distinguish between them. */
4380 id_sec = htab->stub_group[input_section->id].link_sec;
4381
b3fac117
AM		 4382 if (h != NULL && h->u.stub_cache != NULL
4383 && h->u.stub_cache->h == h
4384 && h->u.stub_cache->id_sec == id_sec)
721956f4 4385 {
b3fac117 4386 stub_entry = h->u.stub_cache;
721956f4
AM		 4387 }
4388 else
4389 {
4390 char *stub_name;
4391
4392 stub_name = ppc_stub_name (id_sec, sym_sec, h, rel);
4393 if (stub_name == NULL)
4394 return NULL;
4395
4396 stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
b34976b6 4397 stub_name, FALSE, FALSE);
721956f4 4398 if (h != NULL)
b3fac117 4399 h->u.stub_cache = stub_entry;
721956f4
AM		 4400
4401 free (stub_name);
4402 }
4403
4404 return stub_entry;
4405}
4406
4407/* Add a new stub entry to the stub hash. Not all fields of the new
4408 stub entry are initialised. */
4409
4410static struct ppc_stub_hash_entry *
4ce794b7
AM		 4411ppc_add_stub (const char *stub_name,
4412 asection *section,
25f53a85 4413 struct bfd_link_info *info)
721956f4 4414{
25f53a85 4415 struct ppc_link_hash_table *htab = ppc_hash_table (info);
721956f4
AM		 4416 asection *link_sec;
4417 asection *stub_sec;
4418 struct ppc_stub_hash_entry *stub_entry;
4419
4420 link_sec = htab->stub_group[section->id].link_sec;
4421 stub_sec = htab->stub_group[section->id].stub_sec;
4422 if (stub_sec == NULL)
4423 {
4424 stub_sec = htab->stub_group[link_sec->id].stub_sec;
4425 if (stub_sec == NULL)
4426 {
d4c88bbb 4427 size_t namelen;
721956f4
AM		 4428 bfd_size_type len;
4429 char *s_name;
4430
d4c88bbb
AM		 4431 namelen = strlen (link_sec->name);
4432 len = namelen + sizeof (STUB_SUFFIX);
721956f4
AM		 4433 s_name = bfd_alloc (htab->stub_bfd, len);
4434 if (s_name == NULL)
4435 return NULL;
4436
d4c88bbb
AM		 4437 memcpy (s_name, link_sec->name, namelen);
4438 memcpy (s_name + namelen, STUB_SUFFIX, sizeof (STUB_SUFFIX));
721956f4
AM		 4439 stub_sec = (*htab->add_stub_section) (s_name, link_sec);
4440 if (stub_sec == NULL)
4441 return NULL;
4442 htab->stub_group[link_sec->id].stub_sec = stub_sec;
4443 }
4444 htab->stub_group[section->id].stub_sec = stub_sec;
4445 }
4446
4447 /* Enter this entry into the linker stub hash table. */
4448 stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table, stub_name,
b34976b6 4449 TRUE, FALSE);
721956f4
AM		 4450 if (stub_entry == NULL)
4451 {
8de848d8 4452 info->callbacks->einfo (_("%P: %B: cannot create stub entry %s\n"),
25f53a85 4453 section->owner, stub_name);
721956f4
AM		 4454 return NULL;
4455 }
4456
4457 stub_entry->stub_sec = stub_sec;
4458 stub_entry->stub_offset = 0;
4459 stub_entry->id_sec = link_sec;
4460 return stub_entry;
4461}
4462
e717da7e
AM		 4463/* Create .got and .rela.got sections in ABFD, and .got in dynobj if
4464 not already done. */
65f38f15 4465
b34976b6 4466static bfd_boolean
e717da7e 4467create_got_section (bfd *abfd, struct bfd_link_info *info)
65f38f15 4468{
e717da7e
AM		 4469 asection *got, *relgot;
4470 flagword flags;
4471 struct ppc_link_hash_table *htab = ppc_hash_table (info);
65f38f15 4472
0c8d6e5c 4473 if (!is_ppc64_elf (abfd))
0ffa91dd 4474 return FALSE;
4dfe6ac6
NC		 4475 if (htab == NULL)
4476 return FALSE;
0ffa91dd 4477
33e44f2e
AM		 4478 if (!htab->elf.sgot
4479 && !_bfd_elf_create_got_section (htab->elf.dynobj, info))
4480 return FALSE;
e717da7e
AM		 4481
4482 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
4483 | SEC_LINKER_CREATED);
4484
c456f082 4485 got = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
e717da7e 4486 if (!got
e717da7e
AM		 4487 || !bfd_set_section_alignment (abfd, got, 3))
4488 return FALSE;
65f38f15 4489
c456f082
AM		 4490 relgot = bfd_make_section_anyway_with_flags (abfd, ".rela.got",
4491 flags | SEC_READONLY);
e717da7e 4492 if (!relgot
e717da7e 4493 || ! bfd_set_section_alignment (abfd, relgot, 3))
b34976b6 4494 return FALSE;
e717da7e
AM		 4495
4496 ppc64_elf_tdata (abfd)->got = got;
4497 ppc64_elf_tdata (abfd)->relgot = relgot;
b34976b6 4498 return TRUE;
65f38f15 4499}
5bd4f169 4500
82bd7b59 4501/* Create the dynamic sections, and set up shortcuts. */
5bd4f169 4502
b34976b6 4503static bfd_boolean
4ce794b7 4504ppc64_elf_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
5bd4f169 4505{
65f38f15 4506 struct ppc_link_hash_table *htab;
5bd4f169 4507
65f38f15 4508 if (!_bfd_elf_create_dynamic_sections (dynobj, info))
b34976b6 4509 return FALSE;
65f38f15 4510
e717da7e 4511 htab = ppc_hash_table (info);
4dfe6ac6
NC		 4512 if (htab == NULL)
4513 return FALSE;
4514
3d4d4302 4515 htab->dynbss = bfd_get_linker_section (dynobj, ".dynbss");
65f38f15 4516 if (!info->shared)
3d4d4302 4517 htab->relbss = bfd_get_linker_section (dynobj, ".rela.bss");
65f38f15 4518
33e44f2e 4519 if (!htab->elf.sgot || !htab->elf.splt || !htab->elf.srelplt || !htab->dynbss
4ce794b7 4520 || (!info->shared && !htab->relbss))
65f38f15
AM		 4521 abort ();
4522
b34976b6 4523 return TRUE;
5bd4f169
AM		 4524}
4525
b31867b6
AM		 4526/* Follow indirect and warning symbol links. */
4527
4528static inline struct bfd_link_hash_entry *
4529follow_link (struct bfd_link_hash_entry *h)
4530{
4531 while (h->type == bfd_link_hash_indirect
4532 || h->type == bfd_link_hash_warning)
4533 h = h->u.i.link;
4534 return h;
4535}
4536
4537static inline struct elf_link_hash_entry *
4538elf_follow_link (struct elf_link_hash_entry *h)
4539{
4540 return (struct elf_link_hash_entry *) follow_link (&h->root);
4541}
4542
4543static inline struct ppc_link_hash_entry *
4544ppc_follow_link (struct ppc_link_hash_entry *h)
4545{
4546 return (struct ppc_link_hash_entry *) follow_link (&h->elf.root);
4547}
4548
40d16e0b
AM		 4549/* Merge PLT info on FROM with that on TO. */
4550
4551static void
4552move_plt_plist (struct ppc_link_hash_entry *from,
4553 struct ppc_link_hash_entry *to)
4554{
4555 if (from->elf.plt.plist != NULL)
4556 {
4557 if (to->elf.plt.plist != NULL)
4558 {
4559 struct plt_entry **entp;
4560 struct plt_entry *ent;
4561
4562 for (entp = &from->elf.plt.plist; (ent = *entp) != NULL; )
4563 {
4564 struct plt_entry *dent;
4565
4566 for (dent = to->elf.plt.plist; dent != NULL; dent = dent->next)
4567 if (dent->addend == ent->addend)
4568 {
4569 dent->plt.refcount += ent->plt.refcount;
4570 *entp = ent->next;
4571 break;
4572 }
4573 if (dent == NULL)
4574 entp = &ent->next;
4575 }
4576 *entp = to->elf.plt.plist;
4577 }
4578
4579 to->elf.plt.plist = from->elf.plt.plist;
4580 from->elf.plt.plist = NULL;
4581 }
4582}
4583
65f38f15
AM		 4584/* Copy the extra info we tack onto an elf_link_hash_entry. */
4585
4586static void
fcfa13d2
AM		 4587ppc64_elf_copy_indirect_symbol (struct bfd_link_info *info,
4588 struct elf_link_hash_entry *dir,
4589 struct elf_link_hash_entry *ind)
65f38f15
AM		 4590{
4591 struct ppc_link_hash_entry *edir, *eind;
4592
4593 edir = (struct ppc_link_hash_entry *) dir;
4594 eind = (struct ppc_link_hash_entry *) ind;
4595
c79d6685
AM		 4596 edir->is_func |= eind->is_func;
4597 edir->is_func_descriptor |= eind->is_func_descriptor;
4598 edir->tls_mask |= eind->tls_mask;
4599 if (eind->oh != NULL)
4600 edir->oh = ppc_follow_link (eind->oh);
4601
4602 /* If called to transfer flags for a weakdef during processing
4603 of elf_adjust_dynamic_symbol, don't copy NON_GOT_REF.
4604 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
4605 if (!(ELIMINATE_COPY_RELOCS
4606 && eind->elf.root.type != bfd_link_hash_indirect
4607 && edir->elf.dynamic_adjusted))
4608 edir->elf.non_got_ref |= eind->elf.non_got_ref;
4609
4610 edir->elf.ref_dynamic |= eind->elf.ref_dynamic;
4611 edir->elf.ref_regular |= eind->elf.ref_regular;
4612 edir->elf.ref_regular_nonweak |= eind->elf.ref_regular_nonweak;
4613 edir->elf.needs_plt |= eind->elf.needs_plt;
a345bc8d 4614 edir->elf.pointer_equality_needed |= eind->elf.pointer_equality_needed;
c79d6685 4615
411e1bfb 4616 /* Copy over any dynamic relocs we may have on the indirect sym. */
bbd7ec4a 4617 if (eind->dyn_relocs != NULL)
65f38f15 4618 {
bbd7ec4a
AM		 4619 if (edir->dyn_relocs != NULL)
4620 {
6061a67d
AM		 4621 struct elf_dyn_relocs **pp;
4622 struct elf_dyn_relocs *p;
bbd7ec4a 4623
fcfa13d2 4624 /* Add reloc counts against the indirect sym to the direct sym
bbd7ec4a
AM		 4625 list. Merge any entries against the same section. */
4626 for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
4627 {
6061a67d 4628 struct elf_dyn_relocs *q;
bbd7ec4a
AM		 4629
4630 for (q = edir->dyn_relocs; q != NULL; q = q->next)
4631 if (q->sec == p->sec)
4632 {
4633 q->pc_count += p->pc_count;
4634 q->count += p->count;
4635 *pp = p->next;
4636 break;
4637 }
4638 if (q == NULL)
4639 pp = &p->next;
4640 }
4641 *pp = edir->dyn_relocs;
4642 }
4643
65f38f15
AM		 4644 edir->dyn_relocs = eind->dyn_relocs;
4645 eind->dyn_relocs = NULL;
4646 }
65f38f15 4647
68ba6d40
AM		 4648 /* If we were called to copy over info for a weak sym, that's all.
4649 You might think dyn_relocs need not be copied over; After all,
4650 both syms will be dynamic or both non-dynamic so we're just
68ffbac6 4651 moving reloc accounting around. However, ELIMINATE_COPY_RELOCS
68ba6d40
AM		 4652 code in ppc64_elf_adjust_dynamic_symbol needs to check for
4653 dyn_relocs in read-only sections, and it does so on what is the
4654 DIR sym here. */
4655 if (eind->elf.root.type != bfd_link_hash_indirect)
4656 return;
4657
81848ca0
AM		 4658 /* Copy over got entries that we may have already seen to the
4659 symbol which just became indirect. */
411e1bfb
AM		 4660 if (eind->elf.got.glist != NULL)
4661 {
4662 if (edir->elf.got.glist != NULL)
4663 {
4664 struct got_entry **entp;
4665 struct got_entry *ent;
4666
4667 for (entp = &eind->elf.got.glist; (ent = *entp) != NULL; )
4668 {
4669 struct got_entry *dent;
4670
4671 for (dent = edir->elf.got.glist; dent != NULL; dent = dent->next)
4672 if (dent->addend == ent->addend
e717da7e 4673 && dent->owner == ent->owner
411e1bfb
AM		 4674 && dent->tls_type == ent->tls_type)
4675 {
4676 dent->got.refcount += ent->got.refcount;
4677 *entp = ent->next;
4678 break;
4679 }
4680 if (dent == NULL)
4681 entp = &ent->next;
4682 }
4683 *entp = edir->elf.got.glist;
4684 }
4685
4686 edir->elf.got.glist = eind->elf.got.glist;
4687 eind->elf.got.glist = NULL;
4688 }
4689
4690 /* And plt entries. */
40d16e0b 4691 move_plt_plist (eind, edir);
411e1bfb 4692
fcfa13d2 4693 if (eind->elf.dynindx != -1)
411e1bfb 4694 {
fcfa13d2
AM		 4695 if (edir->elf.dynindx != -1)
4696 _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
4697 edir->elf.dynstr_index);
411e1bfb
AM		 4698 edir->elf.dynindx = eind->elf.dynindx;
4699 edir->elf.dynstr_index = eind->elf.dynstr_index;
4700 eind->elf.dynindx = -1;
4701 eind->elf.dynstr_index = 0;
4702 }
411e1bfb
AM		 4703}
4704
8387904d
AM		 4705/* Find the function descriptor hash entry from the given function code
4706 hash entry FH. Link the entries via their OH fields. */
4707
4708static struct ppc_link_hash_entry *
b31867b6 4709lookup_fdh (struct ppc_link_hash_entry *fh, struct ppc_link_hash_table *htab)
8387904d
AM		 4710{
4711 struct ppc_link_hash_entry *fdh = fh->oh;
4712
4713 if (fdh == NULL)
4714 {
4715 const char *fd_name = fh->elf.root.root.string + 1;
4716
4717 fdh = (struct ppc_link_hash_entry *)
4718 elf_link_hash_lookup (&htab->elf, fd_name, FALSE, FALSE, FALSE);
b31867b6
AM		 4719 if (fdh == NULL)
4720 return fdh;
4721
4722 fdh->is_func_descriptor = 1;
4723 fdh->oh = fh;
4724 fh->is_func = 1;
4725 fh->oh = fdh;
8387904d
AM		 4726 }
4727
b31867b6 4728 return ppc_follow_link (fdh);
8387904d
AM		 4729}
4730
bb700d78
AM		 4731/* Make a fake function descriptor sym for the code sym FH. */
4732
4733static struct ppc_link_hash_entry *
4734make_fdh (struct bfd_link_info *info,
908b32fc 4735 struct ppc_link_hash_entry *fh)
bb700d78
AM		 4736{
4737 bfd *abfd;
4738 asymbol *newsym;
4739 struct bfd_link_hash_entry *bh;
4740 struct ppc_link_hash_entry *fdh;
4741
4742 abfd = fh->elf.root.u.undef.abfd;
4743 newsym = bfd_make_empty_symbol (abfd);
4744 newsym->name = fh->elf.root.root.string + 1;
4745 newsym->section = bfd_und_section_ptr;
4746 newsym->value = 0;
908b32fc 4747 newsym->flags = BSF_WEAK;
bb700d78
AM		 4748
4749 bh = NULL;
4750 if (!_bfd_generic_link_add_one_symbol (info, abfd, newsym->name,
4751 newsym->flags, newsym->section,
4752 newsym->value, NULL, FALSE, FALSE,
4753 &bh))
4754 return NULL;
4755
4756 fdh = (struct ppc_link_hash_entry *) bh;
4757 fdh->elf.non_elf = 0;
908b32fc
AM		 4758 fdh->fake = 1;
4759 fdh->is_func_descriptor = 1;
4760 fdh->oh = fh;
4761 fh->is_func = 1;
4762 fh->oh = fdh;
bb700d78
AM		 4763 return fdh;
4764}
4765
8387904d
AM		 4766/* Fix function descriptor symbols defined in .opd sections to be
4767 function type. */
555cd476
AM		 4768
4769static bfd_boolean
c16153ae 4770ppc64_elf_add_symbol_hook (bfd *ibfd,
e054468f 4771 struct bfd_link_info *info,
555cd476 4772 Elf_Internal_Sym *isym,
6911b7dc 4773 const char **name,
555cd476
AM		 4774 flagword *flags ATTRIBUTE_UNUSED,
4775 asection **sec,
4776 bfd_vma *value ATTRIBUTE_UNUSED)
4777{
f64b2e8d
NC		 4778 if ((ibfd->flags & DYNAMIC) == 0
4779 && ELF_ST_BIND (isym->st_info) == STB_GNU_UNIQUE)
4780 elf_tdata (info->output_bfd)->has_gnu_symbols = TRUE;
4781
e054468f 4782 if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
c16153ae
L		 4783 {
4784 if ((ibfd->flags & DYNAMIC) == 0)
f64b2e8d 4785 elf_tdata (info->output_bfd)->has_gnu_symbols = TRUE;
c16153ae 4786 }
e054468f
AM		 4787 else if (ELF_ST_TYPE (isym->st_info) == STT_FUNC)
4788 ;
4789 else if (*sec != NULL
70cc837d 4790 && strcmp ((*sec)->name, ".opd") == 0)
555cd476 4791 isym->st_info = ELF_ST_INFO (ELF_ST_BIND (isym->st_info), STT_FUNC);
433817dd 4792
6911b7dc
AM		 4793 if ((STO_PPC64_LOCAL_MASK & isym->st_other) != 0)
4794 {
4795 if (abiversion (ibfd) == 0)
4796 set_abiversion (ibfd, 2);
4797 else if (abiversion (ibfd) == 1)
4798 {
4799 info->callbacks->einfo (_("%P: symbol '%s' has invalid st_other"
4800 " for ABI version 1\n"), name);
4801 bfd_set_error (bfd_error_bad_value);
4802 return FALSE;
4803 }
4804 }
4805
555cd476
AM		 4806 return TRUE;
4807}
4808
6911b7dc
AM		 4809/* Merge non-visibility st_other attributes: local entry point. */
4810
4811static void
4812ppc64_elf_merge_symbol_attribute (struct elf_link_hash_entry *h,
4813 const Elf_Internal_Sym *isym,
4814 bfd_boolean definition,
4815 bfd_boolean dynamic)
4816{
4817 if (definition && !dynamic)
4818 h->other = ((isym->st_other & ~ELF_ST_VISIBILITY (-1))
4819 | ELF_ST_VISIBILITY (h->other));
4820}
4821
8387904d 4822/* This function makes an old ABI object reference to ".bar" cause the
908b32fc
AM		 4823 inclusion of a new ABI object archive that defines "bar".
4824 NAME is a symbol defined in an archive. Return a symbol in the hash
4825 table that might be satisfied by the archive symbols. */
8387904d
AM		 4826
4827static struct elf_link_hash_entry *
4828ppc64_elf_archive_symbol_lookup (bfd *abfd,
4829 struct bfd_link_info *info,
4830 const char *name)
4831{
4832 struct elf_link_hash_entry *h;
4833 char *dot_name;
4834 size_t len;
4835
4836 h = _bfd_elf_archive_symbol_lookup (abfd, info, name);
908b32fc
AM		 4837 if (h != NULL
4838 /* Don't return this sym if it is a fake function descriptor
4839 created by add_symbol_adjust. */
4840 && !(h->root.type == bfd_link_hash_undefweak
4841 && ((struct ppc_link_hash_entry *) h)->fake))
8387904d
AM		 4842 return h;
4843
4844 if (name[0] == '.')
4845 return h;
4846
4847 len = strlen (name);
4848 dot_name = bfd_alloc (abfd, len + 2);
4849 if (dot_name == NULL)
4850 return (struct elf_link_hash_entry *) 0 - 1;
4851 dot_name[0] = '.';
4852 memcpy (dot_name + 1, name, len + 1);
4853 h = _bfd_elf_archive_symbol_lookup (abfd, info, dot_name);
4854 bfd_release (abfd, dot_name);
4855 return h;
4856}
4857
4858/* This function satisfies all old ABI object references to ".bar" if a
99877b66
AM		 4859 new ABI object defines "bar". Well, at least, undefined dot symbols
4860 are made weak. This stops later archive searches from including an
4861 object if we already have a function descriptor definition. It also
35b0ce59
AM		 4862 prevents the linker complaining about undefined symbols.
4863 We also check and correct mismatched symbol visibility here. The
4864 most restrictive visibility of the function descriptor and the
4865 function entry symbol is used. */
8387904d
AM		 4866
4867static bfd_boolean
b3fac117 4868add_symbol_adjust (struct ppc_link_hash_entry *eh, struct bfd_link_info *info)
8387904d 4869{
8387904d
AM		 4870 struct ppc_link_hash_table *htab;
4871 struct ppc_link_hash_entry *fdh;
4872
b3fac117 4873 if (eh->elf.root.type == bfd_link_hash_indirect)
8387904d
AM		 4874 return TRUE;
4875
b3fac117
AM		 4876 if (eh->elf.root.type == bfd_link_hash_warning)
4877 eh = (struct ppc_link_hash_entry *) eh->elf.root.u.i.link;
8387904d 4878
b3fac117
AM		 4879 if (eh->elf.root.root.string[0] != '.')
4880 abort ();
8387904d 4881
b3fac117 4882 htab = ppc_hash_table (info);
4dfe6ac6
NC		 4883 if (htab == NULL)
4884 return FALSE;
4885
b31867b6
AM		 4886 fdh = lookup_fdh (eh, htab);
4887 if (fdh == NULL)
4888 {
4889 if (!info->relocatable
4890 && (eh->elf.root.type == bfd_link_hash_undefined
4891 || eh->elf.root.type == bfd_link_hash_undefweak)
4892 && eh->elf.ref_regular)
4893 {
4894 /* Make an undefweak function descriptor sym, which is enough to
4895 pull in an --as-needed shared lib, but won't cause link
4896 errors. Archives are handled elsewhere. */
4897 fdh = make_fdh (info, eh);
4898 if (fdh == NULL)
4899 return FALSE;
4900 fdh->elf.ref_regular = 1;
4901 }
bb700d78 4902 }
b31867b6 4903 else
8387904d 4904 {
35b0ce59
AM		 4905 unsigned entry_vis = ELF_ST_VISIBILITY (eh->elf.other) - 1;
4906 unsigned descr_vis = ELF_ST_VISIBILITY (fdh->elf.other) - 1;
4907 if (entry_vis < descr_vis)
4908 fdh->elf.other += entry_vis - descr_vis;
4909 else if (entry_vis > descr_vis)
4910 eh->elf.other += descr_vis - entry_vis;
4911
e87d886e
AM		 4912 if ((fdh->elf.root.type == bfd_link_hash_defined
4913 || fdh->elf.root.type == bfd_link_hash_defweak)
4914 && eh->elf.root.type == bfd_link_hash_undefined)
35b0ce59
AM		 4915 {
4916 eh->elf.root.type = bfd_link_hash_undefweak;
4917 eh->was_undefined = 1;
4918 htab->twiddled_syms = 1;
4919 }
8387904d 4920 }
99877b66 4921
8387904d
AM		 4922 return TRUE;
4923}
4924
b3fac117
AM		 4925/* Process list of dot-symbols we made in link_hash_newfunc. */
4926
8387904d 4927static bfd_boolean
7d9616d7 4928ppc64_elf_process_dot_syms (bfd *ibfd, struct bfd_link_info *info)
8387904d 4929{
99877b66 4930 struct ppc_link_hash_table *htab;
b3fac117 4931 struct ppc_link_hash_entry **p, *eh;
433817dd 4932
0c8d6e5c 4933 if (!is_ppc64_elf (info->output_bfd))
35b0ce59 4934 return TRUE;
4dfe6ac6
NC		 4935 htab = ppc_hash_table (info);
4936 if (htab == NULL)
4937 return FALSE;
35b0ce59 4938
0c8d6e5c 4939 if (is_ppc64_elf (ibfd))
b3fac117
AM		 4940 {
4941 p = &htab->dot_syms;
4942 while ((eh = *p) != NULL)
4943 {
4944 *p = NULL;
1c865ab2
AM		 4945 if (&eh->elf == htab->elf.hgot)
4946 ;
4947 else if (htab->elf.hgot == NULL
4948 && strcmp (eh->elf.root.root.string, ".TOC.") == 0)
4949 htab->elf.hgot = &eh->elf;
4950 else if (!add_symbol_adjust (eh, info))
b3fac117
AM		 4951 return FALSE;
4952 p = &eh->u.next_dot_sym;
4953 }
4954 }
4955
4956 /* Clear the list for non-ppc64 input files. */
4957 p = &htab->dot_syms;
4958 while ((eh = *p) != NULL)
4959 {
4960 *p = NULL;
4961 p = &eh->u.next_dot_sym;
4962 }
99877b66
AM		 4963
4964 /* We need to fix the undefs list for any syms we have twiddled to
4965 undef_weak. */
4966 if (htab->twiddled_syms)
4967 {
77cfaee6 4968 bfd_link_repair_undef_list (&htab->elf.root);
99877b66
AM		 4969 htab->twiddled_syms = 0;
4970 }
b3fac117 4971 return TRUE;
8387904d
AM		 4972}
4973
97fed1c9
JJ		 4974/* Undo hash table changes when an --as-needed input file is determined
4975 not to be needed. */
4976
4977static bfd_boolean
e5034e59
AM		 4978ppc64_elf_notice_as_needed (bfd *ibfd,
4979 struct bfd_link_info *info,
4980 enum notice_asneeded_action act)
97fed1c9 4981{
e5034e59
AM		 4982 if (act == notice_not_needed)
4983 {
4984 struct ppc_link_hash_table *htab = ppc_hash_table (info);
4dfe6ac6 4985
e5034e59
AM		 4986 if (htab == NULL)
4987 return FALSE;
4dfe6ac6 4988
e5034e59
AM		 4989 htab->dot_syms = NULL;
4990 }
4991 return _bfd_elf_notice_as_needed (ibfd, info, act);
97fed1c9
JJ		 4992}
4993
aa374f67
AM		 4994/* If --just-symbols against a final linked binary, then assume we need
4995 toc adjusting stubs when calling functions defined there. */
4996
4997static void
4998ppc64_elf_link_just_syms (asection *sec, struct bfd_link_info *info)
4999{
5000 if ((sec->flags & SEC_CODE) != 0
5001 && (sec->owner->flags & (EXEC_P | DYNAMIC)) != 0
5002 && is_ppc64_elf (sec->owner))
5003 {
5004 asection *got = bfd_get_section_by_name (sec->owner, ".got");
5005 if (got != NULL
5006 && got->size >= elf_backend_got_header_size
5007 && bfd_get_section_by_name (sec->owner, ".opd") != NULL)
5008 sec->has_toc_reloc = 1;
5009 }
5010 _bfd_elf_link_just_syms (sec, info);
5011}
5012
e054468f 5013static struct plt_entry **
4ce794b7
AM		 5014update_local_sym_info (bfd *abfd, Elf_Internal_Shdr *symtab_hdr,
5015 unsigned long r_symndx, bfd_vma r_addend, int tls_type)
411e1bfb
AM		 5016{
5017 struct got_entry **local_got_ents = elf_local_got_ents (abfd);
e054468f 5018 struct plt_entry **local_plt;
f961d9dd 5019 unsigned char *local_got_tls_masks;
411e1bfb
AM		 5020
5021 if (local_got_ents == NULL)
5022 {
5023 bfd_size_type size = symtab_hdr->sh_info;
5024
e054468f
AM		 5025 size *= (sizeof (*local_got_ents)
5026 + sizeof (*local_plt)
5027 + sizeof (*local_got_tls_masks));
4ce794b7 5028 local_got_ents = bfd_zalloc (abfd, size);
411e1bfb 5029 if (local_got_ents == NULL)
e054468f 5030 return NULL;
411e1bfb
AM		 5031 elf_local_got_ents (abfd) = local_got_ents;
5032 }
5033
e054468f 5034 if ((tls_type & (PLT_IFUNC | TLS_EXPLICIT)) == 0)
411e1bfb
AM		 5035 {
5036 struct got_entry *ent;
5037
5038 for (ent = local_got_ents[r_symndx]; ent != NULL; ent = ent->next)
e717da7e
AM		 5039 if (ent->addend == r_addend
5040 && ent->owner == abfd
5041 && ent->tls_type == tls_type)
411e1bfb
AM		 5042 break;
5043 if (ent == NULL)
5044 {
5045 bfd_size_type amt = sizeof (*ent);
4ce794b7 5046 ent = bfd_alloc (abfd, amt);
411e1bfb
AM		 5047 if (ent == NULL)
5048 return FALSE;
5049 ent->next = local_got_ents[r_symndx];
5050 ent->addend = r_addend;
e717da7e 5051 ent->owner = abfd;
411e1bfb 5052 ent->tls_type = tls_type;
927be08e 5053 ent->is_indirect = FALSE;
411e1bfb
AM		 5054 ent->got.refcount = 0;
5055 local_got_ents[r_symndx] = ent;
5056 }
5057 ent->got.refcount += 1;
5058 }
5059
e054468f 5060 local_plt = (struct plt_entry **) (local_got_ents + symtab_hdr->sh_info);
f961d9dd 5061 local_got_tls_masks = (unsigned char *) (local_plt + symtab_hdr->sh_info);
e7b938ca 5062 local_got_tls_masks[r_symndx] |= tls_type;
e054468f
AM		 5063
5064 return local_plt + r_symndx;
65f38f15
AM		 5065}
5066
411e1bfb 5067static bfd_boolean
e054468f 5068update_plt_info (bfd *abfd, struct plt_entry **plist, bfd_vma addend)
1e2f5b6e 5069{
411e1bfb 5070 struct plt_entry *ent;
1e2f5b6e 5071
e054468f 5072 for (ent = *plist; ent != NULL; ent = ent->next)
411e1bfb
AM		 5073 if (ent->addend == addend)
5074 break;
5075 if (ent == NULL)
1e2f5b6e 5076 {
411e1bfb 5077 bfd_size_type amt = sizeof (*ent);
4ce794b7 5078 ent = bfd_alloc (abfd, amt);
411e1bfb
AM		 5079 if (ent == NULL)
5080 return FALSE;
e054468f 5081 ent->next = *plist;
411e1bfb
AM		 5082 ent->addend = addend;
5083 ent->plt.refcount = 0;
e054468f 5084 *plist = ent;
1e2f5b6e 5085 }
411e1bfb 5086 ent->plt.refcount += 1;
b34976b6 5087 return TRUE;
1e2f5b6e
AM		 5088}
5089
e054468f
AM		 5090static bfd_boolean
5091is_branch_reloc (enum elf_ppc64_reloc_type r_type)
5092{
5093 return (r_type == R_PPC64_REL24
5094 || r_type == R_PPC64_REL14
5095 || r_type == R_PPC64_REL14_BRTAKEN
5096 || r_type == R_PPC64_REL14_BRNTAKEN
5097 || r_type == R_PPC64_ADDR24
5098 || r_type == R_PPC64_ADDR14
5099 || r_type == R_PPC64_ADDR14_BRTAKEN
5100 || r_type == R_PPC64_ADDR14_BRNTAKEN);
5101}
5102
5bd4f169 5103/* Look through the relocs for a section during the first phase, and
65f38f15 5104 calculate needed space in the global offset table, procedure
5d1634d7 5105 linkage table, and dynamic reloc sections. */
5bd4f169 5106
b34976b6 5107static bfd_boolean
4ce794b7
AM		 5108ppc64_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
5109 asection *sec, const Elf_Internal_Rela *relocs)
5bd4f169 5110{
65f38f15 5111 struct ppc_link_hash_table *htab;
5bd4f169 5112 Elf_Internal_Shdr *symtab_hdr;
c7e2358a 5113 struct elf_link_hash_entry **sym_hashes;
5bd4f169
AM		 5114 const Elf_Internal_Rela *rel;
5115 const Elf_Internal_Rela *rel_end;
5bd4f169 5116 asection *sreloc;
1e2f5b6e 5117 asection **opd_sym_map;
3a71aa26 5118 struct elf_link_hash_entry *tga, *dottga;
5bd4f169 5119
1049f94e 5120 if (info->relocatable)
b34976b6 5121 return TRUE;
5bd4f169 5122
680a3378
AM		 5123 /* Don't do anything special with non-loaded, non-alloced sections.
5124 In particular, any relocs in such sections should not affect GOT
5125 and PLT reference counting (ie. we don't allow them to create GOT
5126 or PLT entries), there's no possibility or desire to optimize TLS
5127 relocs, and there's not much point in propagating relocs to shared
5128 libs that the dynamic linker won't relocate. */
5129 if ((sec->flags & SEC_ALLOC) == 0)
5130 return TRUE;
5131
0c8d6e5c 5132 BFD_ASSERT (is_ppc64_elf (abfd));
0ffa91dd 5133
65f38f15 5134 htab = ppc_hash_table (info);
4dfe6ac6
NC		 5135 if (htab == NULL)
5136 return FALSE;
5137
3a71aa26
AM		 5138 tga = elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
5139 FALSE, FALSE, TRUE);
5140 dottga = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
5141 FALSE, FALSE, TRUE);
0ffa91dd 5142 symtab_hdr = &elf_symtab_hdr (abfd);
5bd4f169 5143 sym_hashes = elf_sym_hashes (abfd);
5bd4f169 5144 sreloc = NULL;
1e2f5b6e 5145 opd_sym_map = NULL;
70cc837d 5146 if (strcmp (sec->name, ".opd") == 0)
1e2f5b6e
AM		 5147 {
5148 /* Garbage collection needs some extra help with .opd sections.
5149 We don't want to necessarily keep everything referenced by
5150 relocs in .opd, as that would keep all functions. Instead,
5151 if we reference an .opd symbol (a function descriptor), we
5152 want to keep the function code symbol's section. This is
5153 easy for global symbols, but for local syms we need to keep
74f0fb50 5154 information about the associated function section. */
1e2f5b6e
AM		 5155 bfd_size_type amt;
5156
ee67d69a
AM		 5157 if (abiversion (abfd) == 0)
5158 set_abiversion (abfd, 1);
5159 else if (abiversion (abfd) == 2)
5160 {
5161 info->callbacks->einfo (_("%P: .opd not allowed in ABI version %d\n"),
5162 abiversion (abfd));
5163 bfd_set_error (bfd_error_bad_value);
5164 return FALSE;
5165 }
74f0fb50 5166 amt = sec->size * sizeof (*opd_sym_map) / 8;
4ce794b7 5167 opd_sym_map = bfd_zalloc (abfd, amt);
1e2f5b6e 5168 if (opd_sym_map == NULL)
b34976b6 5169 return FALSE;
74f0fb50 5170 ppc64_elf_section_data (sec)->u.opd.func_sec = opd_sym_map;
7c8fe5c4
AM		 5171 BFD_ASSERT (ppc64_elf_section_data (sec)->sec_type == sec_normal);
5172 ppc64_elf_section_data (sec)->sec_type = sec_opd;
1e2f5b6e 5173 }
5bd4f169
AM		 5174
5175 rel_end = relocs + sec->reloc_count;
5176 for (rel = relocs; rel < rel_end; rel++)
5177 {
5178 unsigned long r_symndx;
5179 struct elf_link_hash_entry *h;
04c9666a 5180 enum elf_ppc64_reloc_type r_type;
727fc41e 5181 int tls_type;
7c8fe5c4 5182 struct _ppc64_elf_section_data *ppc64_sec;
e054468f 5183 struct plt_entry **ifunc;
5bd4f169
AM		 5184
5185 r_symndx = ELF64_R_SYM (rel->r_info);
5186 if (r_symndx < symtab_hdr->sh_info)
5187 h = NULL;
5188 else
973a3492
L		 5189 {
5190 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
b31867b6 5191 h = elf_follow_link (h);
81fbe831
AM		 5192
5193 /* PR15323, ref flags aren't set for references in the same
5194 object. */
5195 h->root.non_ir_ref = 1;
1c865ab2
AM		 5196
5197 if (h == htab->elf.hgot)
5198 sec->has_toc_reloc = 1;
973a3492 5199 }
5bd4f169 5200
727fc41e 5201 tls_type = 0;
e054468f 5202 ifunc = NULL;
25f23106
AM		 5203 if (h != NULL)
5204 {
5205 if (h->type == STT_GNU_IFUNC)
5206 {
5207 h->needs_plt = 1;
5208 ifunc = &h->plt.plist;
5209 }
5210 }
5211 else
5212 {
5213 Elf_Internal_Sym *isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5214 abfd, r_symndx);
5215 if (isym == NULL)
5216 return FALSE;
5217
5218 if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
5219 {
5220 ifunc = update_local_sym_info (abfd, symtab_hdr, r_symndx,
5221 rel->r_addend, PLT_IFUNC);
5222 if (ifunc == NULL)
5223 return FALSE;
5224 }
5225 }
4ce794b7 5226 r_type = ELF64_R_TYPE (rel->r_info);
e054468f
AM		 5227 if (is_branch_reloc (r_type))
5228 {
5229 if (h != NULL && (h == tga || h == dottga))
5230 {
5231 if (rel != relocs
5232 && (ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSGD
5233 || ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_TLSLD))
5234 /* We have a new-style __tls_get_addr call with a marker
5235 reloc. */
5236 ;
5237 else
5238 /* Mark this section as having an old-style call. */
5239 sec->has_tls_get_addr_call = 1;
5240 }
727fc41e 5241
e054468f 5242 /* STT_GNU_IFUNC symbols must have a PLT entry. */
e054468f
AM		 5243 if (ifunc != NULL
5244 && !update_plt_info (abfd, ifunc, rel->r_addend))
5245 return FALSE;
5246 }
727fc41e 5247
a33d1f77 5248 switch (r_type)
5bd4f169 5249 {
727fc41e
AM		 5250 case R_PPC64_TLSGD:
5251 case R_PPC64_TLSLD:
5252 /* These special tls relocs tie a call to __tls_get_addr with
5253 its parameter symbol. */
5254 break;
5255
411e1bfb
AM		 5256 case R_PPC64_GOT_TLSLD16:
5257 case R_PPC64_GOT_TLSLD16_LO:
5258 case R_PPC64_GOT_TLSLD16_HI:
5259 case R_PPC64_GOT_TLSLD16_HA:
951fd09b 5260 tls_type = TLS_TLS | TLS_LD;
411e1bfb
AM		 5261 goto dogottls;
5262
5263 case R_PPC64_GOT_TLSGD16:
5264 case R_PPC64_GOT_TLSGD16_LO:
5265 case R_PPC64_GOT_TLSGD16_HI:
5266 case R_PPC64_GOT_TLSGD16_HA:
951fd09b 5267 tls_type = TLS_TLS | TLS_GD;
411e1bfb
AM		 5268 goto dogottls;
5269
5270 case R_PPC64_GOT_TPREL16_DS:
5271 case R_PPC64_GOT_TPREL16_LO_DS:
5272 case R_PPC64_GOT_TPREL16_HI:
5273 case R_PPC64_GOT_TPREL16_HA:
1d483afe 5274 if (!info->executable)
411e1bfb
AM		 5275 info->flags |= DF_STATIC_TLS;
5276 tls_type = TLS_TLS | TLS_TPREL;
5277 goto dogottls;
5278
5279 case R_PPC64_GOT_DTPREL16_DS:
5280 case R_PPC64_GOT_DTPREL16_LO_DS:
5281 case R_PPC64_GOT_DTPREL16_HI:
5282 case R_PPC64_GOT_DTPREL16_HA:
5283 tls_type = TLS_TLS | TLS_DTPREL;
5284 dogottls:
5285 sec->has_tls_reloc = 1;
5286 /* Fall thru */
5287
5bd4f169 5288 case R_PPC64_GOT16:
5bd4f169 5289 case R_PPC64_GOT16_DS:
65f38f15
AM		 5290 case R_PPC64_GOT16_HA:
5291 case R_PPC64_GOT16_HI:
5292 case R_PPC64_GOT16_LO:
5bd4f169 5293 case R_PPC64_GOT16_LO_DS:
65f38f15 5294 /* This symbol requires a global offset table entry. */
4c52953f 5295 sec->has_toc_reloc = 1;
33c0ec9d
AM		 5296 if (r_type == R_PPC64_GOT_TLSLD16
5297 || r_type == R_PPC64_GOT_TLSGD16
5298 || r_type == R_PPC64_GOT_TPREL16_DS
5299 || r_type == R_PPC64_GOT_DTPREL16_DS
5300 || r_type == R_PPC64_GOT16
5301 || r_type == R_PPC64_GOT16_DS)
5302 {
5303 htab->do_multi_toc = 1;
d77c8a4b 5304 ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
33c0ec9d
AM		 5305 }
5306
e717da7e
AM		 5307 if (ppc64_elf_tdata (abfd)->got == NULL
5308 && !create_got_section (abfd, info))
b34976b6 5309 return FALSE;
5bd4f169
AM		 5310
5311 if (h != NULL)
5312 {
411e1bfb
AM		 5313 struct ppc_link_hash_entry *eh;
5314 struct got_entry *ent;
65f38f15 5315
411e1bfb
AM		 5316 eh = (struct ppc_link_hash_entry *) h;
5317 for (ent = eh->elf.got.glist; ent != NULL; ent = ent->next)
5318 if (ent->addend == rel->r_addend
e717da7e 5319 && ent->owner == abfd
411e1bfb
AM		 5320 && ent->tls_type == tls_type)
5321 break;
5322 if (ent == NULL)
5bd4f169 5323 {
411e1bfb 5324 bfd_size_type amt = sizeof (*ent);
4ce794b7 5325 ent = bfd_alloc (abfd, amt);
411e1bfb 5326 if (ent == NULL)
b34976b6 5327 return FALSE;
411e1bfb
AM		 5328 ent->next = eh->elf.got.glist;
5329 ent->addend = rel->r_addend;
e717da7e 5330 ent->owner = abfd;
411e1bfb 5331 ent->tls_type = tls_type;
927be08e 5332 ent->is_indirect = FALSE;
411e1bfb
AM		 5333 ent->got.refcount = 0;
5334 eh->elf.got.glist = ent;
5bd4f169 5335 }
411e1bfb 5336 ent->got.refcount += 1;
e7b938ca 5337 eh->tls_mask |= tls_type;
5bd4f169 5338 }
411e1bfb
AM		 5339 else
5340 /* This is a global offset table entry for a local symbol. */
5341 if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5342 rel->r_addend, tls_type))
5343 return FALSE;
a345bc8d
AM		 5344
5345 /* We may also need a plt entry if the symbol turns out to be
5346 an ifunc. */
5347 if (h != NULL && !info->shared && abiversion (abfd) == 2)
5348 {
5349 if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5350 return FALSE;
5351 }
5bd4f169
AM		 5352 break;
5353
5bd4f169 5354 case R_PPC64_PLT16_HA:
65f38f15
AM		 5355 case R_PPC64_PLT16_HI:
5356 case R_PPC64_PLT16_LO:
5357 case R_PPC64_PLT32:
5358 case R_PPC64_PLT64:
5bd4f169 5359 /* This symbol requires a procedure linkage table entry. We
3fad3c7c
AM		 5360 actually build the entry in adjust_dynamic_symbol,
5361 because this might be a case of linking PIC code without
5362 linking in any dynamic objects, in which case we don't
5363 need to generate a procedure linkage table after all. */
5bd4f169
AM		 5364 if (h == NULL)
5365 {
5366 /* It does not make sense to have a procedure linkage
3fad3c7c 5367 table entry for a local symbol. */
5bd4f169 5368 bfd_set_error (bfd_error_bad_value);
b34976b6 5369 return FALSE;
5bd4f169 5370 }
411e1bfb 5371 else
e054468f
AM		 5372 {
5373 if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5374 return FALSE;
5375 h->needs_plt = 1;
5376 if (h->root.root.string[0] == '.'
5377 && h->root.root.string[1] != '\0')
5378 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5379 }
5bd4f169
AM		 5380 break;
5381
5382 /* The following relocations don't need to propagate the
5383 relocation if linking a shared object since they are
5384 section relative. */
5385 case R_PPC64_SECTOFF:
5386 case R_PPC64_SECTOFF_LO:
5387 case R_PPC64_SECTOFF_HI:
5388 case R_PPC64_SECTOFF_HA:
5389 case R_PPC64_SECTOFF_DS:
5390 case R_PPC64_SECTOFF_LO_DS:
411e1bfb
AM		 5391 case R_PPC64_DTPREL16:
5392 case R_PPC64_DTPREL16_LO:
5393 case R_PPC64_DTPREL16_HI:
5394 case R_PPC64_DTPREL16_HA:
5395 case R_PPC64_DTPREL16_DS:
5396 case R_PPC64_DTPREL16_LO_DS:
f9c6b907
AM		 5397 case R_PPC64_DTPREL16_HIGH:
5398 case R_PPC64_DTPREL16_HIGHA:
411e1bfb
AM		 5399 case R_PPC64_DTPREL16_HIGHER:
5400 case R_PPC64_DTPREL16_HIGHERA:
5401 case R_PPC64_DTPREL16_HIGHEST:
5402 case R_PPC64_DTPREL16_HIGHESTA:
5bd4f169
AM		 5403 break;
5404
ad8e1ba5 5405 /* Nor do these. */
25f23106
AM		 5406 case R_PPC64_REL16:
5407 case R_PPC64_REL16_LO:
5408 case R_PPC64_REL16_HI:
5409 case R_PPC64_REL16_HA:
5410 break;
5411
ad8e1ba5 5412 case R_PPC64_TOC16:
33c0ec9d
AM		 5413 case R_PPC64_TOC16_DS:
5414 htab->do_multi_toc = 1;
d77c8a4b 5415 ppc64_elf_tdata (abfd)->has_small_toc_reloc = 1;
ad8e1ba5
AM		 5416 case R_PPC64_TOC16_LO:
5417 case R_PPC64_TOC16_HI:
5418 case R_PPC64_TOC16_HA:
ad8e1ba5 5419 case R_PPC64_TOC16_LO_DS:
4c52953f 5420 sec->has_toc_reloc = 1;
ad8e1ba5
AM		 5421 break;
5422
5bd4f169
AM		 5423 /* This relocation describes the C++ object vtable hierarchy.
5424 Reconstruct it for later use during GC. */
5425 case R_PPC64_GNU_VTINHERIT:
c152c796 5426 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
b34976b6 5427 return FALSE;
5bd4f169
AM		 5428 break;
5429
5430 /* This relocation describes which C++ vtable entries are actually
5431 used. Record for later use during GC. */
5432 case R_PPC64_GNU_VTENTRY:
d17e0c6e
JB		 5433 BFD_ASSERT (h != NULL);
5434 if (h != NULL
5435 && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
b34976b6 5436 return FALSE;
5bd4f169
AM		 5437 break;
5438
721956f4
AM		 5439 case R_PPC64_REL14:
5440 case R_PPC64_REL14_BRTAKEN:
5441 case R_PPC64_REL14_BRNTAKEN:
220c76dd
AM		 5442 {
5443 asection *dest = NULL;
5444
5445 /* Heuristic: If jumping outside our section, chances are
5446 we are going to need a stub. */
5447 if (h != NULL)
5448 {
5449 /* If the sym is weak it may be overridden later, so
5450 don't assume we know where a weak sym lives. */
5451 if (h->root.type == bfd_link_hash_defined)
5452 dest = h->root.u.def.section;
5453 }
5454 else
87d72d41
AM		 5455 {
5456 Elf_Internal_Sym *isym;
5457
5458 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5459 abfd, r_symndx);
5460 if (isym == NULL)
5461 return FALSE;
5462
5463 dest = bfd_section_from_elf_index (abfd, isym->st_shndx);
5464 }
5465
220c76dd 5466 if (dest != sec)
7c8fe5c4 5467 ppc64_elf_section_data (sec)->has_14bit_branch = 1;
220c76dd 5468 }
721956f4
AM		 5469 /* Fall through. */
5470
5d1634d7 5471 case R_PPC64_REL24:
e054468f 5472 if (h != NULL && ifunc == NULL)
5d1634d7
AM		 5473 {
5474 /* We may need a .plt entry if the function this reloc
5475 refers to is in a shared lib. */
e054468f 5476 if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
411e1bfb 5477 return FALSE;
e054468f
AM		 5478 h->needs_plt = 1;
5479 if (h->root.root.string[0] == '.'
5480 && h->root.root.string[1] != '\0')
5481 ((struct ppc_link_hash_entry *) h)->is_func = 1;
3a71aa26 5482 if (h == tga || h == dottga)
411e1bfb 5483 sec->has_tls_reloc = 1;
411e1bfb
AM		 5484 }
5485 break;
5486
5487 case R_PPC64_TPREL64:
5488 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_TPREL;
1d483afe 5489 if (!info->executable)
411e1bfb
AM		 5490 info->flags |= DF_STATIC_TLS;
5491 goto dotlstoc;
5492
5493 case R_PPC64_DTPMOD64:
5494 if (rel + 1 < rel_end
5495 && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
5496 && rel[1].r_offset == rel->r_offset + 8)
951fd09b 5497 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_GD;
411e1bfb 5498 else
951fd09b 5499 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_LD;
411e1bfb
AM		 5500 goto dotlstoc;
5501
5502 case R_PPC64_DTPREL64:
5503 tls_type = TLS_EXPLICIT | TLS_TLS | TLS_DTPREL;
5504 if (rel != relocs
5505 && rel[-1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPMOD64)
5506 && rel[-1].r_offset == rel->r_offset - 8)
5507 /* This is the second reloc of a dtpmod, dtprel pair.
5508 Don't mark with TLS_DTPREL. */
5509 goto dodyn;
5510
5511 dotlstoc:
5512 sec->has_tls_reloc = 1;
5513 if (h != NULL)
5514 {
5515 struct ppc_link_hash_entry *eh;
5516 eh = (struct ppc_link_hash_entry *) h;
e7b938ca 5517 eh->tls_mask |= tls_type;
411e1bfb
AM		 5518 }
5519 else
5520 if (!update_local_sym_info (abfd, symtab_hdr, r_symndx,
5521 rel->r_addend, tls_type))
5522 return FALSE;
5523
7c8fe5c4
AM		 5524 ppc64_sec = ppc64_elf_section_data (sec);
5525 if (ppc64_sec->sec_type != sec_toc)
411e1bfb 5526 {
3a71aa26
AM		 5527 bfd_size_type amt;
5528
e7b938ca 5529 /* One extra to simplify get_tls_mask. */
3a71aa26
AM		 5530 amt = sec->size * sizeof (unsigned) / 8 + sizeof (unsigned);
5531 ppc64_sec->u.toc.symndx = bfd_zalloc (abfd, amt);
5532 if (ppc64_sec->u.toc.symndx == NULL)
5533 return FALSE;
5534 amt = sec->size * sizeof (bfd_vma) / 8;
5535 ppc64_sec->u.toc.add = bfd_zalloc (abfd, amt);
5536 if (ppc64_sec->u.toc.add == NULL)
411e1bfb 5537 return FALSE;
7c8fe5c4
AM		 5538 BFD_ASSERT (ppc64_sec->sec_type == sec_normal);
5539 ppc64_sec->sec_type = sec_toc;
411e1bfb
AM		 5540 }
5541 BFD_ASSERT (rel->r_offset % 8 == 0);
3a71aa26
AM		 5542 ppc64_sec->u.toc.symndx[rel->r_offset / 8] = r_symndx;
5543 ppc64_sec->u.toc.add[rel->r_offset / 8] = rel->r_addend;
951fd09b
AM		 5544
5545 /* Mark the second slot of a GD or LD entry.
5546 -1 to indicate GD and -2 to indicate LD. */
5547 if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_GD))
3a71aa26 5548 ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -1;
951fd09b 5549 else if (tls_type == (TLS_EXPLICIT | TLS_TLS | TLS_LD))
3a71aa26 5550 ppc64_sec->u.toc.symndx[rel->r_offset / 8 + 1] = -2;
411e1bfb
AM		 5551 goto dodyn;
5552
5553 case R_PPC64_TPREL16:
5554 case R_PPC64_TPREL16_LO:
5555 case R_PPC64_TPREL16_HI:
5556 case R_PPC64_TPREL16_HA:
5557 case R_PPC64_TPREL16_DS:
5558 case R_PPC64_TPREL16_LO_DS:
f9c6b907
AM		 5559 case R_PPC64_TPREL16_HIGH:
5560 case R_PPC64_TPREL16_HIGHA:
411e1bfb
AM		 5561 case R_PPC64_TPREL16_HIGHER:
5562 case R_PPC64_TPREL16_HIGHERA:
5563 case R_PPC64_TPREL16_HIGHEST:
5564 case R_PPC64_TPREL16_HIGHESTA:
5565 if (info->shared)
5566 {
1d483afe
AM		 5567 if (!info->executable)
5568 info->flags |= DF_STATIC_TLS;
411e1bfb 5569 goto dodyn;
5d1634d7
AM		 5570 }
5571 break;
5572
e86ce104 5573 case R_PPC64_ADDR64:
1e2f5b6e 5574 if (opd_sym_map != NULL
1e2f5b6e 5575 && rel + 1 < rel_end
4ce794b7 5576 && ELF64_R_TYPE ((rel + 1)->r_info) == R_PPC64_TOC)
1e2f5b6e 5577 {
8387904d
AM		 5578 if (h != NULL)
5579 {
5580 if (h->root.root.string[0] == '.'
5581 && h->root.root.string[1] != 0
b31867b6 5582 && lookup_fdh ((struct ppc_link_hash_entry *) h, htab))
8387904d
AM		 5583 ;
5584 else
5585 ((struct ppc_link_hash_entry *) h)->is_func = 1;
5586 }
5587 else
5588 {
5589 asection *s;
87d72d41 5590 Elf_Internal_Sym *isym;
1e2f5b6e 5591
87d72d41
AM		 5592 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5593 abfd, r_symndx);
5594 if (isym == NULL)
8387904d 5595 return FALSE;
87d72d41
AM		 5596
5597 s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5598 if (s != NULL && s != sec)
3f764659 5599 opd_sym_map[rel->r_offset / 8] = s;
8387904d 5600 }
1e2f5b6e 5601 }
e86ce104
AM		 5602 /* Fall through. */
5603
65f38f15
AM		 5604 case R_PPC64_ADDR16:
5605 case R_PPC64_ADDR16_DS:
5606 case R_PPC64_ADDR16_HA:
5607 case R_PPC64_ADDR16_HI:
f9c6b907
AM		 5608 case R_PPC64_ADDR16_HIGH:
5609 case R_PPC64_ADDR16_HIGHA:
65f38f15
AM		 5610 case R_PPC64_ADDR16_HIGHER:
5611 case R_PPC64_ADDR16_HIGHERA:
5612 case R_PPC64_ADDR16_HIGHEST:
5613 case R_PPC64_ADDR16_HIGHESTA:
5614 case R_PPC64_ADDR16_LO:
5615 case R_PPC64_ADDR16_LO_DS:
a345bc8d
AM		 5616 if (h != NULL && !info->shared && abiversion (abfd) == 2
5617 && rel->r_addend == 0)
5618 {
5619 /* We may need a .plt entry if this reloc refers to a
5620 function in a shared lib. */
5621 if (!update_plt_info (abfd, &h->plt.plist, rel->r_addend))
5622 return FALSE;
5623 h->pointer_equality_needed = 1;
5624 }
5625 /* Fall through. */
5626
5627 case R_PPC64_REL30:
5628 case R_PPC64_REL32:
5629 case R_PPC64_REL64:
5630 case R_PPC64_ADDR14:
5631 case R_PPC64_ADDR14_BRNTAKEN:
5632 case R_PPC64_ADDR14_BRTAKEN:
65f38f15 5633 case R_PPC64_ADDR24:
65f38f15 5634 case R_PPC64_ADDR32:
65f38f15
AM		 5635 case R_PPC64_UADDR16:
5636 case R_PPC64_UADDR32:
5637 case R_PPC64_UADDR64:
5bd4f169 5638 case R_PPC64_TOC:
81848ca0
AM		 5639 if (h != NULL && !info->shared)
5640 /* We may need a copy reloc. */
f5385ebf 5641 h->non_got_ref = 1;
81848ca0 5642
41bd81ab 5643 /* Don't propagate .opd relocs. */
1e2f5b6e 5644 if (NO_OPD_RELOCS && opd_sym_map != NULL)
e86ce104 5645 break;
e86ce104 5646
65f38f15
AM		 5647 /* If we are creating a shared library, and this is a reloc
5648 against a global symbol, or a non PC relative reloc
5649 against a local symbol, then we need to copy the reloc
5650 into the shared library. However, if we are linking with
5651 -Bsymbolic, we do not need to copy a reloc against a
5652 global symbol which is defined in an object we are
5653 including in the link (i.e., DEF_REGULAR is set). At
5654 this point we have not seen all the input files, so it is
5655 possible that DEF_REGULAR is not set now but will be set
5656 later (it is never cleared). In case of a weak definition,
5657 DEF_REGULAR may be cleared later by a strong definition in
5658 a shared library. We account for that possibility below by
f4656909 5659 storing information in the dyn_relocs field of the hash
65f38f15
AM		 5660 table entry. A similar situation occurs when creating
5661 shared libraries and symbol visibility changes render the
5662 symbol local.
5663
5664 If on the other hand, we are creating an executable, we
5665 may need to keep relocations for symbols satisfied by a
5666 dynamic library if we manage to avoid copy relocs for the
5667 symbol. */
411e1bfb 5668 dodyn:
65f38f15 5669 if ((info->shared
1d483afe 5670 && (must_be_dyn_reloc (info, r_type)
65f38f15 5671 || (h != NULL
198f1157 5672 && (!SYMBOLIC_BIND (info, h)
65f38f15 5673 || h->root.type == bfd_link_hash_defweak
f5385ebf 5674 || !h->def_regular))))
f4656909
AM		 5675 || (ELIMINATE_COPY_RELOCS
5676 && !info->shared
65f38f15
AM		 5677 && h != NULL
5678 && (h->root.type == bfd_link_hash_defweak
25f23106
AM		 5679 || !h->def_regular))
5680 || (!info->shared
5681 && ifunc != NULL))
5bd4f169 5682 {
65f38f15
AM		 5683 /* We must copy these reloc types into the output file.
5684 Create a reloc section in dynobj and make room for
5685 this reloc. */
5bd4f169
AM		 5686 if (sreloc == NULL)
5687 {
83bac4b0
NC		 5688 sreloc = _bfd_elf_make_dynamic_reloc_section
5689 (sec, htab->elf.dynobj, 3, abfd, /*rela?*/ TRUE);
65f38f15 5690
5bd4f169 5691 if (sreloc == NULL)
83bac4b0 5692 return FALSE;
5bd4f169
AM		 5693 }
5694
65f38f15
AM		 5695 /* If this is a global symbol, we count the number of
5696 relocations we need for this symbol. */
5697 if (h != NULL)
5698 {
19e08130
AM		 5699 struct elf_dyn_relocs *p;
5700 struct elf_dyn_relocs **head;
5701
ec338859 5702 head = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
19e08130
AM		 5703 p = *head;
5704 if (p == NULL || p->sec != sec)
5705 {
5706 p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5707 if (p == NULL)
5708 return FALSE;
5709 p->next = *head;
5710 *head = p;
5711 p->sec = sec;
5712 p->count = 0;
5713 p->pc_count = 0;
5714 }
5715 p->count += 1;
5716 if (!must_be_dyn_reloc (info, r_type))
5717 p->pc_count += 1;
65f38f15
AM		 5718 }
5719 else
5720 {
ec338859
AM		 5721 /* Track dynamic relocs needed for local syms too.
5722 We really need local syms available to do this
5723 easily. Oh well. */
19e08130
AM		 5724 struct ppc_dyn_relocs *p;
5725 struct ppc_dyn_relocs **head;
5726 bfd_boolean is_ifunc;
ec338859 5727 asection *s;
6edfbbad 5728 void *vpp;
87d72d41 5729 Elf_Internal_Sym *isym;
6edfbbad 5730
87d72d41
AM		 5731 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
5732 abfd, r_symndx);
5733 if (isym == NULL)
b34976b6 5734 return FALSE;
ec338859 5735
87d72d41
AM		 5736 s = bfd_section_from_elf_index (abfd, isym->st_shndx);
5737 if (s == NULL)
5738 s = sec;
5739
6edfbbad 5740 vpp = &elf_section_data (s)->local_dynrel;
19e08130
AM		 5741 head = (struct ppc_dyn_relocs **) vpp;
5742 is_ifunc = ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC;
5743 p = *head;
5744 if (p != NULL && p->sec == sec && p->ifunc != is_ifunc)
5745 p = p->next;
5746 if (p == NULL || p->sec != sec || p->ifunc != is_ifunc)
5747 {
5748 p = bfd_alloc (htab->elf.dynobj, sizeof *p);
5749 if (p == NULL)
5750 return FALSE;
5751 p->next = *head;
5752 *head = p;
5753 p->sec = sec;
5754 p->ifunc = is_ifunc;
5755 p->count = 0;
5756 }
5757 p->count += 1;
ec338859 5758 }
65f38f15 5759 }
5bd4f169 5760 break;
65f38f15
AM		 5761
5762 default:
96e0dda4 5763 break;
5bd4f169
AM		 5764 }
5765 }
5766
b34976b6 5767 return TRUE;
5bd4f169
AM		 5768}
5769
ee67d69a
AM		 5770/* Merge backend specific data from an object file to the output
5771 object file when linking. */
5772
5773static bfd_boolean
5774ppc64_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
5775{
5776 unsigned long iflags, oflags;
5777
5778 if ((ibfd->flags & BFD_LINKER_CREATED) != 0)
5779 return TRUE;
5780
5781 if (!is_ppc64_elf (ibfd) || !is_ppc64_elf (obfd))
5782 return TRUE;
5783
5784 if (!_bfd_generic_verify_endian_match (ibfd, obfd))
5785 return FALSE;
5786
5787 iflags = elf_elfheader (ibfd)->e_flags;
5788 oflags = elf_elfheader (obfd)->e_flags;
5789
5790 if (!elf_flags_init (obfd) || oflags == 0)
5791 {
5792 elf_flags_init (obfd) = TRUE;
5793 elf_elfheader (obfd)->e_flags = iflags;
5794 }
5795 else if (iflags == oflags || iflags == 0)
5796 ;
5797 else if (iflags & ~EF_PPC64_ABI)
5798 {
5799 (*_bfd_error_handler)
5800 (_("%B uses unknown e_flags 0x%lx"), ibfd, iflags);
5801 bfd_set_error (bfd_error_bad_value);
5802 return FALSE;
5803 }
5804 else
5805 {
5806 (*_bfd_error_handler)
5807 (_("%B: ABI version %ld is not compatible with ABI version %ld output"),
5808 ibfd, iflags, oflags);
5809 bfd_set_error (bfd_error_bad_value);
5810 return FALSE;
5811 }
5812
5813 /* Merge Tag_compatibility attributes and any common GNU ones. */
5814 _bfd_elf_merge_object_attributes (ibfd, obfd);
5815
5816 return TRUE;
5817}
5818
5819static bfd_boolean
5820ppc64_elf_print_private_bfd_data (bfd *abfd, void *ptr)
5821{
5822 /* Print normal ELF private data. */
5823 _bfd_elf_print_private_bfd_data (abfd, ptr);
5824
5825 if (elf_elfheader (abfd)->e_flags != 0)
5826 {
5827 FILE *file = ptr;
5828
5829 /* xgettext:c-format */
5830 fprintf (file, _("private flags = 0x%lx:"),
5831 elf_elfheader (abfd)->e_flags);
5832
5833 if ((elf_elfheader (abfd)->e_flags & EF_PPC64_ABI) != 0)
5834 fprintf (file, _(" [abiv%ld]"),
5835 elf_elfheader (abfd)->e_flags & EF_PPC64_ABI);
5836 fputc ('\n', file);
5837 }
5838
5839 return TRUE;
5840}
5841
8387904d
AM		 5842/* OFFSET in OPD_SEC specifies a function descriptor. Return the address
5843 of the code entry point, and its section. */
5844
5845static bfd_vma
5846opd_entry_value (asection *opd_sec,
5847 bfd_vma offset,
5848 asection **code_sec,
aef36ac1
AM		 5849 bfd_vma *code_off,
5850 bfd_boolean in_code_sec)
8387904d
AM		 5851{
5852 bfd *opd_bfd = opd_sec->owner;
8860955f 5853 Elf_Internal_Rela *relocs;
8387904d 5854 Elf_Internal_Rela *lo, *hi, *look;
645ea6a9 5855 bfd_vma val;
8387904d 5856
9f296da3
AM		 5857 /* No relocs implies we are linking a --just-symbols object, or looking
5858 at a final linked executable with addr2line or somesuch. */
4b85d634
AM		 5859 if (opd_sec->reloc_count == 0)
5860 {
729eabd5 5861 bfd_byte *contents = ppc64_elf_tdata (opd_bfd)->opd.contents;
3b36f7e6 5862
729eabd5
AM		 5863 if (contents == NULL)
5864 {
5865 if (!bfd_malloc_and_get_section (opd_bfd, opd_sec, &contents))
5866 return (bfd_vma) -1;
5867 ppc64_elf_tdata (opd_bfd)->opd.contents = contents;
5868 }
ee1e4ede 5869
729eabd5 5870 val = bfd_get_64 (opd_bfd, contents + offset);
aef36ac1
AM		 5871 if (code_sec != NULL)
5872 {
5873 asection *sec, *likely = NULL;
ee1e4ede 5874
aef36ac1 5875 if (in_code_sec)
4b85d634 5876 {
aef36ac1
AM		 5877 sec = *code_sec;
5878 if (sec->vma <= val
5879 && val < sec->vma + sec->size)
5880 likely = sec;
5881 else
5882 val = -1;
5883 }
5884 else
5885 for (sec = opd_bfd->sections; sec != NULL; sec = sec->next)
5886 if (sec->vma <= val
5887 && (sec->flags & SEC_LOAD) != 0
5888 && (sec->flags & SEC_ALLOC) != 0)
5889 likely = sec;
5890 if (likely != NULL)
5891 {
5892 *code_sec = likely;
5893 if (code_off != NULL)
5894 *code_off = val - likely->vma;
4b85d634
AM		 5895 }
5896 }
aef36ac1 5897 return val;
4b85d634
AM		 5898 }
5899
0c8d6e5c 5900 BFD_ASSERT (is_ppc64_elf (opd_bfd));
0ffa91dd 5901
729eabd5 5902 relocs = ppc64_elf_tdata (opd_bfd)->opd.relocs;
8860955f
AM		 5903 if (relocs == NULL)
5904 relocs = _bfd_elf_link_read_relocs (opd_bfd, opd_sec, NULL, NULL, TRUE);
645ea6a9 5905
8387904d 5906 /* Go find the opd reloc at the sym address. */
8860955f 5907 lo = relocs;
8387904d
AM		 5908 BFD_ASSERT (lo != NULL);
5909 hi = lo + opd_sec->reloc_count - 1; /* ignore last reloc */
645ea6a9 5910 val = (bfd_vma) -1;
8387904d
AM		 5911 while (lo < hi)
5912 {
5913 look = lo + (hi - lo) / 2;
5914 if (look->r_offset < offset)
5915 lo = look + 1;
5916 else if (look->r_offset > offset)
5917 hi = look;
5918 else
5919 {
0ffa91dd
NC		 5920 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (opd_bfd);
5921
8387904d
AM		 5922 if (ELF64_R_TYPE (look->r_info) == R_PPC64_ADDR64
5923 && ELF64_R_TYPE ((look + 1)->r_info) == R_PPC64_TOC)
5924 {
5925 unsigned long symndx = ELF64_R_SYM (look->r_info);
8387904d
AM		 5926 asection *sec;
5927
62599110
AM		 5928 if (symndx < symtab_hdr->sh_info
5929 || elf_sym_hashes (opd_bfd) == NULL)
8387904d
AM		 5930 {
5931 Elf_Internal_Sym *sym;
5932
5933 sym = (Elf_Internal_Sym *) symtab_hdr->contents;
5934 if (sym == NULL)
5935 {
62599110
AM		 5936 size_t symcnt = symtab_hdr->sh_info;
5937 if (elf_sym_hashes (opd_bfd) == NULL)
5938 symcnt = symtab_hdr->sh_size / symtab_hdr->sh_entsize;
5939 sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr, symcnt,
8387904d
AM		 5940 0, NULL, NULL, NULL);
5941 if (sym == NULL)
645ea6a9 5942 break;
8387904d
AM		 5943 symtab_hdr->contents = (bfd_byte *) sym;
5944 }
5945
5946 sym += symndx;
5947 val = sym->st_value;
cb33740c 5948 sec = bfd_section_from_elf_index (opd_bfd, sym->st_shndx);
8387904d
AM		 5949 BFD_ASSERT ((sec->flags & SEC_MERGE) == 0);
5950 }
5951 else
5952 {
5953 struct elf_link_hash_entry **sym_hashes;
5954 struct elf_link_hash_entry *rh;
5955
5956 sym_hashes = elf_sym_hashes (opd_bfd);
5957 rh = sym_hashes[symndx - symtab_hdr->sh_info];
128205bb
AM		 5958 if (rh != NULL)
5959 {
5960 rh = elf_follow_link (rh);
5961 BFD_ASSERT (rh->root.type == bfd_link_hash_defined
5962 || rh->root.type == bfd_link_hash_defweak);
5963 val = rh->root.u.def.value;
5964 sec = rh->root.u.def.section;
5965 }
5966 else
5967 {
5968 /* Handle the odd case where we can be called
5969 during bfd_elf_link_add_symbols before the
5970 symbol hashes have been fully populated. */
5971 Elf_Internal_Sym *sym;
5972
5973 sym = bfd_elf_get_elf_syms (opd_bfd, symtab_hdr, 1,
5974 symndx, NULL, NULL, NULL);
5975 if (sym == NULL)
5976 break;
5977
5978 val = sym->st_value;
5979 sec = bfd_section_from_elf_index (opd_bfd, sym->st_shndx);
5980 free (sym);
5981 }
8387904d
AM		 5982 }
5983 val += look->r_addend;
5984 if (code_off != NULL)
5985 *code_off = val;
5986 if (code_sec != NULL)
aef36ac1
AM		 5987 {
5988 if (in_code_sec && *code_sec != sec)
5989 return -1;
5990 else
5991 *code_sec = sec;
5992 }
8387904d
AM		 5993 if (sec != NULL && sec->output_section != NULL)
5994 val += sec->output_section->vma + sec->output_offset;
8387904d
AM		 5995 }
5996 break;
5997 }
5998 }
645ea6a9 5999
645ea6a9 6000 return val;
8387904d
AM		 6001}
6002
aef36ac1
AM		 6003/* If the ELF symbol SYM might be a function in SEC, return the
6004 function size and set *CODE_OFF to the function's entry point,
6005 otherwise return zero. */
9f296da3 6006
aef36ac1
AM		 6007static bfd_size_type
6008ppc64_elf_maybe_function_sym (const asymbol *sym, asection *sec,
6009 bfd_vma *code_off)
9f296da3 6010{
aef36ac1
AM		 6011 bfd_size_type size;
6012
6013 if ((sym->flags & (BSF_SECTION_SYM | BSF_FILE | BSF_OBJECT
6014 | BSF_THREAD_LOCAL | BSF_RELC | BSF_SRELC)) != 0)
6015 return 0;
6016
6017 size = 0;
6018 if (!(sym->flags & BSF_SYNTHETIC))
6019 size = ((elf_symbol_type *) sym)->internal_elf_sym.st_size;
6020
6021 if (strcmp (sym->section->name, ".opd") == 0)
9f296da3 6022 {
aef36ac1
AM		 6023 if (opd_entry_value (sym->section, sym->value,
6024 &sec, code_off, TRUE) == (bfd_vma) -1)
6025 return 0;
6026 /* An old ABI binary with dot-syms has a size of 24 on the .opd
6027 symbol. This size has nothing to do with the code size of the
6028 function, which is what we're supposed to return, but the
6029 code size isn't available without looking up the dot-sym.
6030 However, doing that would be a waste of time particularly
6031 since elf_find_function will look at the dot-sym anyway.
6032 Now, elf_find_function will keep the largest size of any
6033 function sym found at the code address of interest, so return
6034 1 here to avoid it incorrectly caching a larger function size
6035 for a small function. This does mean we return the wrong
6036 size for a new-ABI function of size 24, but all that does is
6037 disable caching for such functions. */
6038 if (size == 24)
6039 size = 1;
9f296da3 6040 }
aef36ac1
AM		 6041 else
6042 {
6043 if (sym->section != sec)
6044 return 0;
6045 *code_off = sym->value;
6046 }
6047 if (size == 0)
6048 size = 1;
6049 return size;
9f296da3
AM		 6050}
6051
854b41e7
AM		 6052/* Return true if symbol is defined in a regular object file. */
6053
6054static bfd_boolean
6055is_static_defined (struct elf_link_hash_entry *h)
6056{
6057 return ((h->root.type == bfd_link_hash_defined
6058 || h->root.type == bfd_link_hash_defweak)
6059 && h->root.u.def.section != NULL
6060 && h->root.u.def.section->output_section != NULL);
6061}
6062
b31867b6
AM		 6063/* If FDH is a function descriptor symbol, return the associated code
6064 entry symbol if it is defined. Return NULL otherwise. */
6065
6066static struct ppc_link_hash_entry *
6067defined_code_entry (struct ppc_link_hash_entry *fdh)
6068{
6069 if (fdh->is_func_descriptor)
6070 {
6071 struct ppc_link_hash_entry *fh = ppc_follow_link (fdh->oh);
6072 if (fh->elf.root.type == bfd_link_hash_defined
6073 || fh->elf.root.type == bfd_link_hash_defweak)
6074 return fh;
6075 }
6076 return NULL;
6077}
6078
6079/* If FH is a function code entry symbol, return the associated
6080 function descriptor symbol if it is defined. Return NULL otherwise. */
6081
6082static struct ppc_link_hash_entry *
6083defined_func_desc (struct ppc_link_hash_entry *fh)
6084{
6085 if (fh->oh != NULL
6086 && fh->oh->is_func_descriptor)
6087 {
6088 struct ppc_link_hash_entry *fdh = ppc_follow_link (fh->oh);
6089 if (fdh->elf.root.type == bfd_link_hash_defined
6090 || fdh->elf.root.type == bfd_link_hash_defweak)
6091 return fdh;
6092 }
6093 return NULL;
6094}
6095
74f0fb50
AM		 6096/* Mark all our entry sym sections, both opd and code section. */
6097
6098static void
6099ppc64_elf_gc_keep (struct bfd_link_info *info)
6100{
6101 struct ppc_link_hash_table *htab = ppc_hash_table (info);
6102 struct bfd_sym_chain *sym;
6103
4dfe6ac6
NC		 6104 if (htab == NULL)
6105 return;
6106
74f0fb50
AM		 6107 for (sym = info->gc_sym_list; sym != NULL; sym = sym->next)
6108 {
b31867b6 6109 struct ppc_link_hash_entry *eh, *fh;
74f0fb50
AM		 6110 asection *sec;
6111
6112 eh = (struct ppc_link_hash_entry *)
b31867b6 6113 elf_link_hash_lookup (&htab->elf, sym->name, FALSE, FALSE, TRUE);
74f0fb50
AM		 6114 if (eh == NULL)
6115 continue;
6116 if (eh->elf.root.type != bfd_link_hash_defined
6117 && eh->elf.root.type != bfd_link_hash_defweak)
6118 continue;
6119
b31867b6
AM		 6120 fh = defined_code_entry (eh);
6121 if (fh != NULL)
74f0fb50 6122 {
b31867b6 6123 sec = fh->elf.root.u.def.section;
74f0fb50
AM		 6124 sec->flags |= SEC_KEEP;
6125 }
6126 else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6127 && opd_entry_value (eh->elf.root.u.def.section,
6128 eh->elf.root.u.def.value,
aef36ac1 6129 &sec, NULL, FALSE) != (bfd_vma) -1)
74f0fb50
AM		 6130 sec->flags |= SEC_KEEP;
6131
6132 sec = eh->elf.root.u.def.section;
6133 sec->flags |= SEC_KEEP;
6134 }
6135}
6136
64d03ab5
AM		 6137/* Mark sections containing dynamically referenced symbols. When
6138 building shared libraries, we must assume that any visible symbol is
6139 referenced. */
6140
6141static bfd_boolean
6142ppc64_elf_gc_mark_dynamic_ref (struct elf_link_hash_entry *h, void *inf)
6143{
6144 struct bfd_link_info *info = (struct bfd_link_info *) inf;
6145 struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
b31867b6 6146 struct ppc_link_hash_entry *fdh;
64d03ab5 6147
64d03ab5 6148 /* Dynamic linking info is on the func descriptor sym. */
b31867b6
AM		 6149 fdh = defined_func_desc (eh);
6150 if (fdh != NULL)
6151 eh = fdh;
64d03ab5
AM		 6152
6153 if ((eh->elf.root.type == bfd_link_hash_defined
6154 || eh->elf.root.type == bfd_link_hash_defweak)
6155 && (eh->elf.ref_dynamic
6156 || (!info->executable
6157 && eh->elf.def_regular
6158 && ELF_ST_VISIBILITY (eh->elf.other) != STV_INTERNAL
4c58e0d8
AM		 6159 && ELF_ST_VISIBILITY (eh->elf.other) != STV_HIDDEN
6160 && (strchr (eh->elf.root.root.string, ELF_VER_CHR) != NULL
6161 || !bfd_hide_sym_by_version (info->version_info,
6162 eh->elf.root.root.string)))))
64d03ab5
AM		 6163 {
6164 asection *code_sec;
b31867b6 6165 struct ppc_link_hash_entry *fh;
64d03ab5
AM		 6166
6167 eh->elf.root.u.def.section->flags |= SEC_KEEP;
6168
6169 /* Function descriptor syms cause the associated
6170 function code sym section to be marked. */
b31867b6
AM		 6171 fh = defined_code_entry (eh);
6172 if (fh != NULL)
6173 {
6174 code_sec = fh->elf.root.u.def.section;
6175 code_sec->flags |= SEC_KEEP;
6176 }
64d03ab5
AM		 6177 else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6178 && opd_entry_value (eh->elf.root.u.def.section,
6179 eh->elf.root.u.def.value,
aef36ac1 6180 &code_sec, NULL, FALSE) != (bfd_vma) -1)
64d03ab5
AM		 6181 code_sec->flags |= SEC_KEEP;
6182 }
6183
6184 return TRUE;
6185}
6186
5bd4f169
AM		 6187/* Return the section that should be marked against GC for a given
6188 relocation. */
6189
6190static asection *
4ce794b7 6191ppc64_elf_gc_mark_hook (asection *sec,
fb34365b 6192 struct bfd_link_info *info,
4ce794b7
AM		 6193 Elf_Internal_Rela *rel,
6194 struct elf_link_hash_entry *h,
6195 Elf_Internal_Sym *sym)
5bd4f169 6196{
ccfa59ea
AM		 6197 asection *rsec;
6198
ccfa59ea
AM		 6199 /* Syms return NULL if we're marking .opd, so we avoid marking all
6200 function sections, as all functions are referenced in .opd. */
6201 rsec = NULL;
6202 if (get_opd_info (sec) != NULL)
6203 return rsec;
1e2f5b6e 6204
5bd4f169
AM		 6205 if (h != NULL)
6206 {
04c9666a 6207 enum elf_ppc64_reloc_type r_type;
b31867b6 6208 struct ppc_link_hash_entry *eh, *fh, *fdh;
a33d1f77 6209
4ce794b7 6210 r_type = ELF64_R_TYPE (rel->r_info);
a33d1f77 6211 switch (r_type)
5bd4f169
AM		 6212 {
6213 case R_PPC64_GNU_VTINHERIT:
6214 case R_PPC64_GNU_VTENTRY:
6215 break;
6216
6217 default:
6218 switch (h->root.type)
6219 {
6220 case bfd_link_hash_defined:
6221 case bfd_link_hash_defweak:
ccfa59ea 6222 eh = (struct ppc_link_hash_entry *) h;
b31867b6
AM		 6223 fdh = defined_func_desc (eh);
6224 if (fdh != NULL)
6225 eh = fdh;
1e2f5b6e
AM		 6226
6227 /* Function descriptor syms cause the associated
6228 function code sym section to be marked. */
b31867b6
AM		 6229 fh = defined_code_entry (eh);
6230 if (fh != NULL)
ccfa59ea
AM		 6231 {
6232 /* They also mark their opd section. */
74f0fb50 6233 eh->elf.root.u.def.section->gc_mark = 1;
ccfa59ea 6234
b31867b6 6235 rsec = fh->elf.root.u.def.section;
ccfa59ea 6236 }
8387904d
AM		 6237 else if (get_opd_info (eh->elf.root.u.def.section) != NULL
6238 && opd_entry_value (eh->elf.root.u.def.section,
6239 eh->elf.root.u.def.value,
aef36ac1 6240 &rsec, NULL, FALSE) != (bfd_vma) -1)
74f0fb50 6241 eh->elf.root.u.def.section->gc_mark = 1;
ccfa59ea 6242 else
1e2f5b6e
AM		 6243 rsec = h->root.u.def.section;
6244 break;
5bd4f169
AM		 6245
6246 case bfd_link_hash_common:
1e2f5b6e
AM		 6247 rsec = h->root.u.c.p->section;
6248 break;
5bd4f169
AM		 6249
6250 default:
fb34365b 6251 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
5bd4f169
AM		 6252 }
6253 }
6254 }
6255 else
6256 {
74f0fb50 6257 struct _opd_sec_data *opd;
1e2f5b6e
AM		 6258
6259 rsec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
74f0fb50
AM		 6260 opd = get_opd_info (rsec);
6261 if (opd != NULL && opd->func_sec != NULL)
ccfa59ea 6262 {
74f0fb50 6263 rsec->gc_mark = 1;
ccfa59ea 6264
74f0fb50 6265 rsec = opd->func_sec[(sym->st_value + rel->r_addend) / 8];
ccfa59ea 6266 }
5bd4f169
AM		 6267 }
6268
1e2f5b6e 6269 return rsec;
5bd4f169
AM		 6270}
6271
65f38f15
AM		 6272/* Update the .got, .plt. and dynamic reloc reference counts for the
6273 section being removed. */
5bd4f169 6274
b34976b6 6275static bfd_boolean
4ce794b7
AM		 6276ppc64_elf_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info,
6277 asection *sec, const Elf_Internal_Rela *relocs)
5bd4f169 6278{
411e1bfb 6279 struct ppc_link_hash_table *htab;
5bd4f169
AM		 6280 Elf_Internal_Shdr *symtab_hdr;
6281 struct elf_link_hash_entry **sym_hashes;
411e1bfb 6282 struct got_entry **local_got_ents;
5bd4f169 6283 const Elf_Internal_Rela *rel, *relend;
5bd4f169 6284
7dda2462
TG		 6285 if (info->relocatable)
6286 return TRUE;
6287
680a3378
AM		 6288 if ((sec->flags & SEC_ALLOC) == 0)
6289 return TRUE;
6290
ec338859
AM		 6291 elf_section_data (sec)->local_dynrel = NULL;
6292
411e1bfb 6293 htab = ppc_hash_table (info);
4dfe6ac6
NC		 6294 if (htab == NULL)
6295 return FALSE;
6296
0ffa91dd 6297 symtab_hdr = &elf_symtab_hdr (abfd);
5bd4f169 6298 sym_hashes = elf_sym_hashes (abfd);
411e1bfb 6299 local_got_ents = elf_local_got_ents (abfd);
5bd4f169
AM		 6300
6301 relend = relocs + sec->reloc_count;
6302 for (rel = relocs; rel < relend; rel++)
a33d1f77
AM		 6303 {
6304 unsigned long r_symndx;
04c9666a 6305 enum elf_ppc64_reloc_type r_type;
58ac9f71 6306 struct elf_link_hash_entry *h = NULL;
f961d9dd 6307 unsigned char tls_type = 0;
5bd4f169 6308
a33d1f77 6309 r_symndx = ELF64_R_SYM (rel->r_info);
4ce794b7 6310 r_type = ELF64_R_TYPE (rel->r_info);
58ac9f71
AM		 6311 if (r_symndx >= symtab_hdr->sh_info)
6312 {
6313 struct ppc_link_hash_entry *eh;
6061a67d
AM		 6314 struct elf_dyn_relocs **pp;
6315 struct elf_dyn_relocs *p;
58ac9f71
AM		 6316
6317 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
b31867b6 6318 h = elf_follow_link (h);
58ac9f71
AM		 6319 eh = (struct ppc_link_hash_entry *) h;
6320
6321 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
6322 if (p->sec == sec)
6323 {
6324 /* Everything must go for SEC. */
6325 *pp = p->next;
6326 break;
6327 }
6328 }
6329
e054468f
AM		 6330 if (is_branch_reloc (r_type))
6331 {
6332 struct plt_entry **ifunc = NULL;
6333 if (h != NULL)
6334 {
6335 if (h->type == STT_GNU_IFUNC)
6336 ifunc = &h->plt.plist;
6337 }
6338 else if (local_got_ents != NULL)
6339 {
6340 struct plt_entry **local_plt = (struct plt_entry **)
6341 (local_got_ents + symtab_hdr->sh_info);
f961d9dd 6342 unsigned char *local_got_tls_masks = (unsigned char *)
e054468f
AM		 6343 (local_plt + symtab_hdr->sh_info);
6344 if ((local_got_tls_masks[r_symndx] & PLT_IFUNC) != 0)
6345 ifunc = local_plt + r_symndx;
6346 }
6347 if (ifunc != NULL)
6348 {
6349 struct plt_entry *ent;
6350
6351 for (ent = *ifunc; ent != NULL; ent = ent->next)
6352 if (ent->addend == rel->r_addend)
6353 break;
6354 if (ent == NULL)
6355 abort ();
6356 if (ent->plt.refcount > 0)
6357 ent->plt.refcount -= 1;
6358 continue;
6359 }
6360 }
6361
a33d1f77
AM		 6362 switch (r_type)
6363 {
411e1bfb
AM		 6364 case R_PPC64_GOT_TLSLD16:
6365 case R_PPC64_GOT_TLSLD16_LO:
6366 case R_PPC64_GOT_TLSLD16_HI:
6367 case R_PPC64_GOT_TLSLD16_HA:
951fd09b 6368 tls_type = TLS_TLS | TLS_LD;
411e1bfb
AM		 6369 goto dogot;
6370
6371 case R_PPC64_GOT_TLSGD16:
6372 case R_PPC64_GOT_TLSGD16_LO:
6373 case R_PPC64_GOT_TLSGD16_HI:
6374 case R_PPC64_GOT_TLSGD16_HA:
951fd09b 6375 tls_type = TLS_TLS | TLS_GD;
411e1bfb
AM		 6376 goto dogot;
6377
6378 case R_PPC64_GOT_TPREL16_DS:
6379 case R_PPC64_GOT_TPREL16_LO_DS:
6380 case R_PPC64_GOT_TPREL16_HI:
6381 case R_PPC64_GOT_TPREL16_HA:
6382 tls_type = TLS_TLS | TLS_TPREL;
6383 goto dogot;
6384
6385 case R_PPC64_GOT_DTPREL16_DS:
6386 case R_PPC64_GOT_DTPREL16_LO_DS:
6387 case R_PPC64_GOT_DTPREL16_HI:
6388 case R_PPC64_GOT_DTPREL16_HA:
6389 tls_type = TLS_TLS | TLS_DTPREL;
6390 goto dogot;
6391
a33d1f77
AM		 6392 case R_PPC64_GOT16:
6393 case R_PPC64_GOT16_DS:
6394 case R_PPC64_GOT16_HA:
6395 case R_PPC64_GOT16_HI:
6396 case R_PPC64_GOT16_LO:
6397 case R_PPC64_GOT16_LO_DS:
411e1bfb
AM		 6398 dogot:
6399 {
6400 struct got_entry *ent;
6401
58ac9f71
AM		 6402 if (h != NULL)
6403 ent = h->got.glist;
411e1bfb
AM		 6404 else
6405 ent = local_got_ents[r_symndx];
6406
6407 for (; ent != NULL; ent = ent->next)
6408 if (ent->addend == rel->r_addend
e717da7e 6409 && ent->owner == abfd
411e1bfb
AM		 6410 && ent->tls_type == tls_type)
6411 break;
6412 if (ent == NULL)
6413 abort ();
6414 if (ent->got.refcount > 0)
6415 ent->got.refcount -= 1;
6416 }
a33d1f77 6417 break;
65f38f15 6418
a33d1f77
AM		 6419 case R_PPC64_PLT16_HA:
6420 case R_PPC64_PLT16_HI:
6421 case R_PPC64_PLT16_LO:
6422 case R_PPC64_PLT32:
6423 case R_PPC64_PLT64:
721956f4
AM		 6424 case R_PPC64_REL14:
6425 case R_PPC64_REL14_BRNTAKEN:
6426 case R_PPC64_REL14_BRTAKEN:
5d1634d7 6427 case R_PPC64_REL24:
58ac9f71 6428 if (h != NULL)
5d1634d7 6429 {
411e1bfb
AM		 6430 struct plt_entry *ent;
6431
411e1bfb
AM		 6432 for (ent = h->plt.plist; ent != NULL; ent = ent->next)
6433 if (ent->addend == rel->r_addend)
6434 break;
7c6c1722 6435 if (ent != NULL && ent->plt.refcount > 0)
411e1bfb 6436 ent->plt.refcount -= 1;
5d1634d7 6437 }
e86ce104 6438 break;
5d1634d7 6439
a33d1f77
AM		 6440 default:
6441 break;
6442 }
6443 }
b34976b6 6444 return TRUE;
5bd4f169
AM		 6445}
6446
deb0e272
AM		 6447/* The maximum size of .sfpr. */
6448#define SFPR_MAX (218*4)
6449
6450struct sfpr_def_parms
6451{
699733f6
AM		 6452 const char name[12];
6453 unsigned char lo, hi;
deb0e272
AM		 6454 bfd_byte * (*write_ent) (bfd *, bfd_byte *, int);
6455 bfd_byte * (*write_tail) (bfd *, bfd_byte *, int);
6456};
6457
6458/* Auto-generate _save*, _rest* functions in .sfpr. */
6459
4dfe6ac6 6460static bfd_boolean
deb0e272
AM		 6461sfpr_define (struct bfd_link_info *info, const struct sfpr_def_parms *parm)
6462{
6463 struct ppc_link_hash_table *htab = ppc_hash_table (info);
6464 unsigned int i;
6465 size_t len = strlen (parm->name);
6466 bfd_boolean writing = FALSE;
699733f6 6467 char sym[16];
deb0e272 6468
4dfe6ac6
NC		 6469 if (htab == NULL)
6470 return FALSE;
6471
deb0e272
AM		 6472 memcpy (sym, parm->name, len);
6473 sym[len + 2] = 0;
6474
6475 for (i = parm->lo; i <= parm->hi; i++)
6476 {
6477 struct elf_link_hash_entry *h;
6478
6479 sym[len + 0] = i / 10 + '0';
6480 sym[len + 1] = i % 10 + '0';
6481 h = elf_link_hash_lookup (&htab->elf, sym, FALSE, FALSE, TRUE);
6482 if (h != NULL
f5385ebf 6483 && !h->def_regular)
deb0e272
AM		 6484 {
6485 h->root.type = bfd_link_hash_defined;
6486 h->root.u.def.section = htab->sfpr;
6487 h->root.u.def.value = htab->sfpr->size;
6488 h->type = STT_FUNC;
f5385ebf 6489 h->def_regular = 1;
deb0e272
AM		 6490 _bfd_elf_link_hash_hide_symbol (info, h, TRUE);
6491 writing = TRUE;
6492 if (htab->sfpr->contents == NULL)
6493 {
6494 htab->sfpr->contents = bfd_alloc (htab->elf.dynobj, SFPR_MAX);
6495 if (htab->sfpr->contents == NULL)
6496 return FALSE;
6497 }
6498 }
6499 if (writing)
6500 {
6501 bfd_byte *p = htab->sfpr->contents + htab->sfpr->size;
6502 if (i != parm->hi)
6503 p = (*parm->write_ent) (htab->elf.dynobj, p, i);
6504 else
6505 p = (*parm->write_tail) (htab->elf.dynobj, p, i);
6506 htab->sfpr->size = p - htab->sfpr->contents;
6507 }
6508 }
6509
6510 return TRUE;
6511}
6512
6513static bfd_byte *
6514savegpr0 (bfd *abfd, bfd_byte *p, int r)
6515{
6516 bfd_put_32 (abfd, STD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6517 return p + 4;
6518}
6519
6520static bfd_byte *
6521savegpr0_tail (bfd *abfd, bfd_byte *p, int r)
6522{
6523 p = savegpr0 (abfd, p, r);
a078d95a 6524 bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
deb0e272
AM		 6525 p = p + 4;
6526 bfd_put_32 (abfd, BLR, p);
6527 return p + 4;
6528}
6529
6530static bfd_byte *
6531restgpr0 (bfd *abfd, bfd_byte *p, int r)
6532{
6533 bfd_put_32 (abfd, LD_R0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6534 return p + 4;
6535}
6536
6537static bfd_byte *
6538restgpr0_tail (bfd *abfd, bfd_byte *p, int r)
6539{
a078d95a 6540 bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
deb0e272
AM		 6541 p = p + 4;
6542 p = restgpr0 (abfd, p, r);
6543 bfd_put_32 (abfd, MTLR_R0, p);
6544 p = p + 4;
6545 if (r == 29)
6546 {
6547 p = restgpr0 (abfd, p, 30);
6548 p = restgpr0 (abfd, p, 31);
6549 }
6550 bfd_put_32 (abfd, BLR, p);
6551 return p + 4;
6552}
6553
6554static bfd_byte *
6555savegpr1 (bfd *abfd, bfd_byte *p, int r)
6556{
6557 bfd_put_32 (abfd, STD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6558 return p + 4;
6559}
6560
6561static bfd_byte *
6562savegpr1_tail (bfd *abfd, bfd_byte *p, int r)
6563{
6564 p = savegpr1 (abfd, p, r);
6565 bfd_put_32 (abfd, BLR, p);
6566 return p + 4;
6567}
6568
6569static bfd_byte *
6570restgpr1 (bfd *abfd, bfd_byte *p, int r)
6571{
6572 bfd_put_32 (abfd, LD_R0_0R12 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6573 return p + 4;
6574}
6575
6576static bfd_byte *
6577restgpr1_tail (bfd *abfd, bfd_byte *p, int r)
6578{
6579 p = restgpr1 (abfd, p, r);
6580 bfd_put_32 (abfd, BLR, p);
6581 return p + 4;
6582}
6583
6584static bfd_byte *
6585savefpr (bfd *abfd, bfd_byte *p, int r)
6586{
6587 bfd_put_32 (abfd, STFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6588 return p + 4;
6589}
6590
6591static bfd_byte *
6592savefpr0_tail (bfd *abfd, bfd_byte *p, int r)
6593{
6594 p = savefpr (abfd, p, r);
a078d95a 6595 bfd_put_32 (abfd, STD_R0_0R1 + STK_LR, p);
deb0e272
AM		 6596 p = p + 4;
6597 bfd_put_32 (abfd, BLR, p);
6598 return p + 4;
6599}
6600
6601static bfd_byte *
6602restfpr (bfd *abfd, bfd_byte *p, int r)
6603{
6604 bfd_put_32 (abfd, LFD_FR0_0R1 + (r << 21) + (1 << 16) - (32 - r) * 8, p);
6605 return p + 4;
6606}
6607
6608static bfd_byte *
6609restfpr0_tail (bfd *abfd, bfd_byte *p, int r)
6610{
a078d95a 6611 bfd_put_32 (abfd, LD_R0_0R1 + STK_LR, p);
deb0e272
AM		 6612 p = p + 4;
6613 p = restfpr (abfd, p, r);
6614 bfd_put_32 (abfd, MTLR_R0, p);
6615 p = p + 4;
6616 if (r == 29)
6617 {
6618 p = restfpr (abfd, p, 30);
6619 p = restfpr (abfd, p, 31);
6620 }
6621 bfd_put_32 (abfd, BLR, p);
6622 return p + 4;
6623}
6624
6625static bfd_byte *
6626savefpr1_tail (bfd *abfd, bfd_byte *p, int r)
6627{
6628 p = savefpr (abfd, p, r);
6629 bfd_put_32 (abfd, BLR, p);
6630 return p + 4;
6631}
6632
6633static bfd_byte *
6634restfpr1_tail (bfd *abfd, bfd_byte *p, int r)
6635{
6636 p = restfpr (abfd, p, r);
6637 bfd_put_32 (abfd, BLR, p);
6638 return p + 4;
6639}
6640
6641static bfd_byte *
6642savevr (bfd *abfd, bfd_byte *p, int r)
6643{
6644 bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6645 p = p + 4;
6646 bfd_put_32 (abfd, STVX_VR0_R12_R0 + (r << 21), p);
6647 return p + 4;
6648}
6649
6650static bfd_byte *
6651savevr_tail (bfd *abfd, bfd_byte *p, int r)
6652{
6653 p = savevr (abfd, p, r);
6654 bfd_put_32 (abfd, BLR, p);
6655 return p + 4;
6656}
6657
6658static bfd_byte *
6659restvr (bfd *abfd, bfd_byte *p, int r)
6660{
6661 bfd_put_32 (abfd, LI_R12_0 + (1 << 16) - (32 - r) * 16, p);
6662 p = p + 4;
6663 bfd_put_32 (abfd, LVX_VR0_R12_R0 + (r << 21), p);
6664 return p + 4;
6665}
6666
6667static bfd_byte *
6668restvr_tail (bfd *abfd, bfd_byte *p, int r)
6669{
6670 p = restvr (abfd, p, r);
6671 bfd_put_32 (abfd, BLR, p);
6672 return p + 4;
6673}
6674
e86ce104
AM		 6675/* Called via elf_link_hash_traverse to transfer dynamic linking
6676 information on function code symbol entries to their corresponding
6677 function descriptor symbol entries. */
deb0e272 6678
b34976b6 6679static bfd_boolean
4ce794b7 6680func_desc_adjust (struct elf_link_hash_entry *h, void *inf)
5bd4f169 6681{
e86ce104 6682 struct bfd_link_info *info;
65f38f15 6683 struct ppc_link_hash_table *htab;
411e1bfb 6684 struct plt_entry *ent;
50bc7936
AM		 6685 struct ppc_link_hash_entry *fh;
6686 struct ppc_link_hash_entry *fdh;
6687 bfd_boolean force_local;
5bd4f169 6688
50bc7936
AM		 6689 fh = (struct ppc_link_hash_entry *) h;
6690 if (fh->elf.root.type == bfd_link_hash_indirect)
b34976b6 6691 return TRUE;
e86ce104 6692
4ce794b7 6693 info = inf;
65f38f15 6694 htab = ppc_hash_table (info);
4dfe6ac6
NC		 6695 if (htab == NULL)
6696 return FALSE;
5bd4f169 6697
c09bdfe5
AM		 6698 /* Resolve undefined references to dot-symbols as the value
6699 in the function descriptor, if we have one in a regular object.
6700 This is to satisfy cases like ".quad .foo". Calls to functions
6701 in dynamic objects are handled elsewhere. */
6702 if (fh->elf.root.type == bfd_link_hash_undefweak
6703 && fh->was_undefined
b31867b6
AM		 6704 && (fdh = defined_func_desc (fh)) != NULL
6705 && get_opd_info (fdh->elf.root.u.def.section) != NULL
6706 && opd_entry_value (fdh->elf.root.u.def.section,
6707 fdh->elf.root.u.def.value,
c09bdfe5 6708 &fh->elf.root.u.def.section,
aef36ac1 6709 &fh->elf.root.u.def.value, FALSE) != (bfd_vma) -1)
c09bdfe5 6710 {
b31867b6 6711 fh->elf.root.type = fdh->elf.root.type;
f5385ebf 6712 fh->elf.forced_local = 1;
b31867b6
AM		 6713 fh->elf.def_regular = fdh->elf.def_regular;
6714 fh->elf.def_dynamic = fdh->elf.def_dynamic;
c09bdfe5
AM		 6715 }
6716
e86ce104
AM		 6717 /* If this is a function code symbol, transfer dynamic linking
6718 information to the function descriptor symbol. */
50bc7936 6719 if (!fh->is_func)
b34976b6 6720 return TRUE;
e86ce104 6721
50bc7936 6722 for (ent = fh->elf.plt.plist; ent != NULL; ent = ent->next)
411e1bfb
AM		 6723 if (ent->plt.refcount > 0)
6724 break;
50bc7936
AM		 6725 if (ent == NULL
6726 || fh->elf.root.root.string[0] != '.'
6727 || fh->elf.root.root.string[1] == '\0')
6728 return TRUE;
5bd4f169 6729
50bc7936
AM		 6730 /* Find the corresponding function descriptor symbol. Create it
6731 as undefined if necessary. */
5bd4f169 6732
b31867b6 6733 fdh = lookup_fdh (fh, htab);
50bc7936 6734 if (fdh == NULL
df131623 6735 && !info->executable
50bc7936
AM		 6736 && (fh->elf.root.type == bfd_link_hash_undefined
6737 || fh->elf.root.type == bfd_link_hash_undefweak))
6738 {
908b32fc 6739 fdh = make_fdh (info, fh);
bb700d78
AM		 6740 if (fdh == NULL)
6741 return FALSE;
50bc7936 6742 }
648cca2c 6743
908b32fc 6744 /* Fake function descriptors are made undefweak. If the function
433817dd
AM		 6745 code symbol is strong undefined, make the fake sym the same.
6746 If the function code symbol is defined, then force the fake
6747 descriptor local; We can't support overriding of symbols in a
6748 shared library on a fake descriptor. */
908b32fc
AM		 6749
6750 if (fdh != NULL
6751 && fdh->fake
433817dd 6752 && fdh->elf.root.type == bfd_link_hash_undefweak)
908b32fc 6753 {
433817dd
AM		 6754 if (fh->elf.root.type == bfd_link_hash_undefined)
6755 {
6756 fdh->elf.root.type = bfd_link_hash_undefined;
6757 bfd_link_add_undef (&htab->elf.root, &fdh->elf.root);
6758 }
6759 else if (fh->elf.root.type == bfd_link_hash_defined
6760 || fh->elf.root.type == bfd_link_hash_defweak)
6761 {
6762 _bfd_elf_link_hash_hide_symbol (info, &fdh->elf, TRUE);
6763 }
908b32fc
AM		 6764 }
6765
50bc7936 6766 if (fdh != NULL
f5385ebf 6767 && !fdh->elf.forced_local
df131623 6768 && (!info->executable
f5385ebf
AM		 6769 || fdh->elf.def_dynamic
6770 || fdh->elf.ref_dynamic
50bc7936
AM		 6771 || (fdh->elf.root.type == bfd_link_hash_undefweak
6772 && ELF_ST_VISIBILITY (fdh->elf.other) == STV_DEFAULT)))
6773 {
6774 if (fdh->elf.dynindx == -1)
c152c796 6775 if (! bfd_elf_link_record_dynamic_symbol (info, &fdh->elf))
50bc7936 6776 return FALSE;
f5385ebf
AM		 6777 fdh->elf.ref_regular |= fh->elf.ref_regular;
6778 fdh->elf.ref_dynamic |= fh->elf.ref_dynamic;
6779 fdh->elf.ref_regular_nonweak |= fh->elf.ref_regular_nonweak;
6780 fdh->elf.non_got_ref |= fh->elf.non_got_ref;
50bc7936 6781 if (ELF_ST_VISIBILITY (fh->elf.other) == STV_DEFAULT)
e86ce104 6782 {
40d16e0b 6783 move_plt_plist (fh, fdh);
f5385ebf 6784 fdh->elf.needs_plt = 1;
e86ce104 6785 }
50bc7936 6786 fdh->is_func_descriptor = 1;
34814b9f
AM		 6787 fdh->oh = fh;
6788 fh->oh = fdh;
e86ce104
AM		 6789 }
6790
50bc7936
AM		 6791 /* Now that the info is on the function descriptor, clear the
6792 function code sym info. Any function code syms for which we
6793 don't have a definition in a regular file, we force local.
6794 This prevents a shared library from exporting syms that have
6795 been imported from another library. Function code syms that
6796 are really in the library we must leave global to prevent the
6797 linker dragging in a definition from a static library. */
93f3fa99
AM		 6798 force_local = (!fh->elf.def_regular
6799 || fdh == NULL
6800 || !fdh->elf.def_regular
6801 || fdh->elf.forced_local);
50bc7936
AM		 6802 _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
6803
b34976b6 6804 return TRUE;
e86ce104 6805}
40b8271b 6806
e86ce104 6807/* Called near the start of bfd_elf_size_dynamic_sections. We use
82bd7b59
AM		 6808 this hook to a) provide some gcc support functions, and b) transfer
6809 dynamic linking information gathered so far on function code symbol
6810 entries, to their corresponding function descriptor symbol entries. */
deb0e272 6811
b34976b6 6812static bfd_boolean
4ce794b7
AM		 6813ppc64_elf_func_desc_adjust (bfd *obfd ATTRIBUTE_UNUSED,
6814 struct bfd_link_info *info)
e86ce104
AM		 6815{
6816 struct ppc_link_hash_table *htab;
82bd7b59 6817 unsigned int i;
27fc25a1 6818 static const struct sfpr_def_parms funcs[] =
deb0e272
AM		 6819 {
6820 { "_savegpr0_", 14, 31, savegpr0, savegpr0_tail },
6821 { "_restgpr0_", 14, 29, restgpr0, restgpr0_tail },
6822 { "_restgpr0_", 30, 31, restgpr0, restgpr0_tail },
6823 { "_savegpr1_", 14, 31, savegpr1, savegpr1_tail },
6824 { "_restgpr1_", 14, 31, restgpr1, restgpr1_tail },
6825 { "_savefpr_", 14, 31, savefpr, savefpr0_tail },
6826 { "_restfpr_", 14, 29, restfpr, restfpr0_tail },
6827 { "_restfpr_", 30, 31, restfpr, restfpr0_tail },
6828 { "._savef", 14, 31, savefpr, savefpr1_tail },
6829 { "._restf", 14, 31, restfpr, restfpr1_tail },
6830 { "_savevr_", 20, 31, savevr, savevr_tail },
6831 { "_restvr_", 20, 31, restvr, restvr_tail }
6832 };
e86ce104
AM		 6833
6834 htab = ppc_hash_table (info);
4dfe6ac6
NC		 6835 if (htab == NULL)
6836 return FALSE;
6837
5295321c
AM		 6838 if (!info->relocatable
6839 && htab->elf.hgot != NULL)
6840 _bfd_elf_link_hash_hide_symbol (info, htab->elf.hgot, TRUE);
c66bb0ee 6841
82bd7b59
AM		 6842 if (htab->sfpr == NULL)
6843 /* We don't have any relocs. */
b34976b6 6844 return TRUE;
82bd7b59 6845
deb0e272
AM		 6846 /* Provide any missing _save* and _rest* functions. */
6847 htab->sfpr->size = 0;
27fc25a1
AM		 6848 if (!info->relocatable)
6849 for (i = 0; i < sizeof (funcs) / sizeof (funcs[0]); i++)
6850 if (!sfpr_define (info, &funcs[i]))
6851 return FALSE;
82bd7b59 6852
4ce794b7 6853 elf_link_hash_traverse (&htab->elf, func_desc_adjust, info);
805fc799 6854
eea6121a 6855 if (htab->sfpr->size == 0)
8423293d 6856 htab->sfpr->flags |= SEC_EXCLUDE;
82bd7b59 6857
b34976b6 6858 return TRUE;
e86ce104
AM		 6859}
6860
a345bc8d
AM		 6861/* Return true if we have dynamic relocs that apply to read-only sections. */
6862
6863static bfd_boolean
6864readonly_dynrelocs (struct elf_link_hash_entry *h)
6865{
6866 struct ppc_link_hash_entry *eh;
6867 struct elf_dyn_relocs *p;
6868
6869 eh = (struct ppc_link_hash_entry *) h;
6870 for (p = eh->dyn_relocs; p != NULL; p = p->next)
6871 {
6872 asection *s = p->sec->output_section;
6873
6874 if (s != NULL && (s->flags & SEC_READONLY) != 0)
6875 return TRUE;
6876 }
6877 return FALSE;
6878}
6879
e86ce104
AM		 6880/* Adjust a symbol defined by a dynamic object and referenced by a
6881 regular object. The current definition is in some section of the
6882 dynamic object, but we're not including those sections. We have to
6883 change the definition to something the rest of the link can
6884 understand. */
6885
b34976b6 6886static bfd_boolean
4ce794b7
AM		 6887ppc64_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
6888 struct elf_link_hash_entry *h)
e86ce104
AM		 6889{
6890 struct ppc_link_hash_table *htab;
e86ce104 6891 asection *s;
e86ce104
AM		 6892
6893 htab = ppc_hash_table (info);
4dfe6ac6
NC		 6894 if (htab == NULL)
6895 return FALSE;
e86ce104
AM		 6896
6897 /* Deal with function syms. */
6898 if (h->type == STT_FUNC
e054468f 6899 || h->type == STT_GNU_IFUNC
f5385ebf 6900 || h->needs_plt)
e86ce104
AM		 6901 {
6902 /* Clear procedure linkage table information for any symbol that
6903 won't need a .plt entry. */
411e1bfb
AM		 6904 struct plt_entry *ent;
6905 for (ent = h->plt.plist; ent != NULL; ent = ent->next)
6906 if (ent->plt.refcount > 0)
6907 break;
8387904d 6908 if (ent == NULL
e054468f
AM		 6909 || (h->type != STT_GNU_IFUNC
6910 && (SYMBOL_CALLS_LOCAL (info, h)
6911 || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
6912 && h->root.type == bfd_link_hash_undefweak))))
40b8271b 6913 {
411e1bfb 6914 h->plt.plist = NULL;
f5385ebf 6915 h->needs_plt = 0;
40b8271b 6916 }
a345bc8d
AM		 6917 else if (abiversion (info->output_bfd) == 2)
6918 {
6919 /* After adjust_dynamic_symbol, non_got_ref set in the
6920 non-shared case means that we have allocated space in
6921 .dynbss for the symbol and thus dyn_relocs for this
6922 symbol should be discarded.
6923 If we get here we know we are making a PLT entry for this
6924 symbol, and in an executable we'd normally resolve
6925 relocations against this symbol to the PLT entry. Allow
6926 dynamic relocs if the reference is weak, and the dynamic
6927 relocs will not cause text relocation. */
6928 if (!h->ref_regular_nonweak
6929 && h->non_got_ref
6930 && h->type != STT_GNU_IFUNC
6931 && !readonly_dynrelocs (h))
6932 h->non_got_ref = 0;
6933
6934 /* If making a plt entry, then we don't need copy relocs. */
6935 return TRUE;
6936 }
5bd4f169 6937 }
bbd7ec4a 6938 else
411e1bfb 6939 h->plt.plist = NULL;
5bd4f169
AM		 6940
6941 /* If this is a weak symbol, and there is a real definition, the
6942 processor independent code will have arranged for us to see the
6943 real definition first, and we can just use the same value. */
f6e332e6 6944 if (h->u.weakdef != NULL)
5bd4f169 6945 {
f6e332e6
AM		 6946 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
6947 || h->u.weakdef->root.type == bfd_link_hash_defweak);
6948 h->root.u.def.section = h->u.weakdef->root.u.def.section;
6949 h->root.u.def.value = h->u.weakdef->root.u.def.value;
a23b6845 6950 if (ELIMINATE_COPY_RELOCS)
f6e332e6 6951 h->non_got_ref = h->u.weakdef->non_got_ref;
b34976b6 6952 return TRUE;
5bd4f169
AM		 6953 }
6954
5bd4f169
AM		 6955 /* If we are creating a shared library, we must presume that the
6956 only references to the symbol are via the global offset table.
6957 For such cases we need not do anything here; the relocations will
6958 be handled correctly by relocate_section. */
6959 if (info->shared)
b34976b6 6960 return TRUE;
5bd4f169 6961
65f38f15
AM		 6962 /* If there are no references to this symbol that do not use the
6963 GOT, we don't need to generate a copy reloc. */
f5385ebf 6964 if (!h->non_got_ref)
b34976b6 6965 return TRUE;
65f38f15 6966
b186458a
JJ		 6967 /* Don't generate a copy reloc for symbols defined in the executable. */
6968 if (!h->def_dynamic || !h->ref_regular || h->def_regular)
6969 return TRUE;
6970
a345bc8d
AM		 6971 /* If we didn't find any dynamic relocs in read-only sections, then
6972 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
6973 if (ELIMINATE_COPY_RELOCS && !readonly_dynrelocs (h))
65f38f15 6974 {
a345bc8d
AM		 6975 h->non_got_ref = 0;
6976 return TRUE;
65f38f15
AM		 6977 }
6978
5d35169e 6979 if (h->plt.plist != NULL)
97b639ba
AM		 6980 {
6981 /* We should never get here, but unfortunately there are versions
6982 of gcc out there that improperly (for this ABI) put initialized
6983 function pointers, vtable refs and suchlike in read-only
6984 sections. Allow them to proceed, but warn that this might
6985 break at runtime. */
25f53a85 6986 info->callbacks->einfo
bc30df16 6987 (_("%P: copy reloc against `%T' requires lazy plt linking; "
25f53a85 6988 "avoid setting LD_BIND_NOW=1 or upgrade gcc\n"),
97b639ba
AM		 6989 h->root.root.string);
6990 }
5d35169e
AM		 6991
6992 /* This is a reference to a symbol defined by a dynamic object which
6993 is not a function. */
6994
5bd4f169
AM		 6995 /* We must allocate the symbol in our .dynbss section, which will
6996 become part of the .bss section of the executable. There will be
6997 an entry for this symbol in the .dynsym section. The dynamic
6998 object will contain position independent code, so all references
6999 from the dynamic object to this symbol will go through the global
7000 offset table. The dynamic linker will use the .dynsym entry to
7001 determine the address it must put in the global offset table, so
7002 both the dynamic object and the regular object will refer to the
7003 same memory location for the variable. */
5bd4f169 7004
04c9666a
AM		 7005 /* We must generate a R_PPC64_COPY reloc to tell the dynamic linker
7006 to copy the initial value out of the dynamic object and into the
5bd4f169
AM		 7007 runtime process image. We need to remember the offset into the
7008 .rela.bss section we are going to use. */
1d7e9d18 7009 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
5bd4f169 7010 {
eea6121a 7011 htab->relbss->size += sizeof (Elf64_External_Rela);
f5385ebf 7012 h->needs_copy = 1;
5bd4f169
AM		 7013 }
7014
4ce794b7 7015 s = htab->dynbss;
5bd4f169 7016
027297b7 7017 return _bfd_elf_adjust_dynamic_copy (h, s);
5bd4f169
AM		 7018}
7019
e86ce104
AM		 7020/* If given a function descriptor symbol, hide both the function code
7021 sym and the descriptor. */
7022static void
4ce794b7
AM		 7023ppc64_elf_hide_symbol (struct bfd_link_info *info,
7024 struct elf_link_hash_entry *h,
7025 bfd_boolean force_local)
e86ce104 7026{
34814b9f 7027 struct ppc_link_hash_entry *eh;
e86ce104
AM		 7028 _bfd_elf_link_hash_hide_symbol (info, h, force_local);
7029
34814b9f
AM		 7030 eh = (struct ppc_link_hash_entry *) h;
7031 if (eh->is_func_descriptor)
e86ce104 7032 {
34814b9f 7033 struct ppc_link_hash_entry *fh = eh->oh;
e86ce104 7034
721956f4 7035 if (fh == NULL)
d1329ca3
AM		 7036 {
7037 const char *p, *q;
7038 struct ppc_link_hash_table *htab;
7039 char save;
7040
7041 /* We aren't supposed to use alloca in BFD because on
7042 systems which do not have alloca the version in libiberty
7043 calls xmalloc, which might cause the program to crash
7044 when it runs out of memory. This function doesn't have a
7045 return status, so there's no way to gracefully return an
7046 error. So cheat. We know that string[-1] can be safely
34814b9f
AM		 7047 accessed; It's either a string in an ELF string table,
7048 or allocated in an objalloc structure. */
d1329ca3 7049
34814b9f 7050 p = eh->elf.root.root.string - 1;
d1329ca3
AM		 7051 save = *p;
7052 *(char *) p = '.';
7053 htab = ppc_hash_table (info);
4dfe6ac6
NC		 7054 if (htab == NULL)
7055 return;
7056
34814b9f
AM		 7057 fh = (struct ppc_link_hash_entry *)
7058 elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
d1329ca3
AM		 7059 *(char *) p = save;
7060
7061 /* Unfortunately, if it so happens that the string we were
7062 looking for was allocated immediately before this string,
7063 then we overwrote the string terminator. That's the only
7064 reason the lookup should fail. */
7065 if (fh == NULL)
7066 {
34814b9f
AM		 7067 q = eh->elf.root.root.string + strlen (eh->elf.root.root.string);
7068 while (q >= eh->elf.root.root.string && *q == *p)
d1329ca3 7069 --q, --p;
34814b9f
AM		 7070 if (q < eh->elf.root.root.string && *p == '.')
7071 fh = (struct ppc_link_hash_entry *)
7072 elf_link_hash_lookup (&htab->elf, p, FALSE, FALSE, FALSE);
d1329ca3
AM		 7073 }
7074 if (fh != NULL)
7075 {
34814b9f
AM		 7076 eh->oh = fh;
7077 fh->oh = eh;
d1329ca3
AM		 7078 }
7079 }
e86ce104 7080 if (fh != NULL)
34814b9f 7081 _bfd_elf_link_hash_hide_symbol (info, &fh->elf, force_local);
e86ce104
AM		 7082 }
7083}
7084
411e1bfb 7085static bfd_boolean
8843416a
AM		 7086get_sym_h (struct elf_link_hash_entry **hp,
7087 Elf_Internal_Sym **symp,
7088 asection **symsecp,
f961d9dd 7089 unsigned char **tls_maskp,
8843416a
AM		 7090 Elf_Internal_Sym **locsymsp,
7091 unsigned long r_symndx,
7092 bfd *ibfd)
411e1bfb 7093{
0ffa91dd 7094 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
411e1bfb
AM		 7095
7096 if (r_symndx >= symtab_hdr->sh_info)
7097 {
7098 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
7099 struct elf_link_hash_entry *h;
7100
7101 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
b31867b6 7102 h = elf_follow_link (h);
411e1bfb
AM		 7103
7104 if (hp != NULL)
7105 *hp = h;
7106
7107 if (symp != NULL)
7108 *symp = NULL;
7109
7110 if (symsecp != NULL)
7111 {
7112 asection *symsec = NULL;
7113 if (h->root.type == bfd_link_hash_defined
7114 || h->root.type == bfd_link_hash_defweak)
7115 symsec = h->root.u.def.section;
7116 *symsecp = symsec;
7117 }
7118
e7b938ca 7119 if (tls_maskp != NULL)
411e1bfb
AM		 7120 {
7121 struct ppc_link_hash_entry *eh;
7122
7123 eh = (struct ppc_link_hash_entry *) h;
e7b938ca 7124 *tls_maskp = &eh->tls_mask;
411e1bfb
AM		 7125 }
7126 }
7127 else
7128 {
7129 Elf_Internal_Sym *sym;
7130 Elf_Internal_Sym *locsyms = *locsymsp;
7131
7132 if (locsyms == NULL)
7133 {
7134 locsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
7135 if (locsyms == NULL)
7136 locsyms = bfd_elf_get_elf_syms (ibfd, symtab_hdr,
7137 symtab_hdr->sh_info,
7138 0, NULL, NULL, NULL);
7139 if (locsyms == NULL)
7140 return FALSE;
7141 *locsymsp = locsyms;
7142 }
7143 sym = locsyms + r_symndx;
7144
7145 if (hp != NULL)
7146 *hp = NULL;
7147
7148 if (symp != NULL)
7149 *symp = sym;
7150
7151 if (symsecp != NULL)
cb33740c 7152 *symsecp = bfd_section_from_elf_index (ibfd, sym->st_shndx);
411e1bfb 7153
e7b938ca 7154 if (tls_maskp != NULL)
411e1bfb
AM		 7155 {
7156 struct got_entry **lgot_ents;
f961d9dd 7157 unsigned char *tls_mask;
411e1bfb 7158
e7b938ca 7159 tls_mask = NULL;
411e1bfb
AM		 7160 lgot_ents = elf_local_got_ents (ibfd);
7161 if (lgot_ents != NULL)
7162 {
e054468f
AM		 7163 struct plt_entry **local_plt = (struct plt_entry **)
7164 (lgot_ents + symtab_hdr->sh_info);
f961d9dd 7165 unsigned char *lgot_masks = (unsigned char *)
e054468f 7166 (local_plt + symtab_hdr->sh_info);
e7b938ca 7167 tls_mask = &lgot_masks[r_symndx];
411e1bfb 7168 }
e7b938ca 7169 *tls_maskp = tls_mask;
411e1bfb
AM		 7170 }
7171 }
7172 return TRUE;
7173}
7174
e7b938ca 7175/* Returns TLS_MASKP for the given REL symbol. Function return is 0 on
951fd09b 7176 error, 2 on a toc GD type suitable for optimization, 3 on a toc LD
ad8e1ba5 7177 type suitable for optimization, and 1 otherwise. */
951fd09b
AM		 7178
7179static int
f961d9dd 7180get_tls_mask (unsigned char **tls_maskp,
3a71aa26
AM		 7181 unsigned long *toc_symndx,
7182 bfd_vma *toc_addend,
0d4792f7 7183 Elf_Internal_Sym **locsymsp,
3a71aa26
AM		 7184 const Elf_Internal_Rela *rel,
7185 bfd *ibfd)
411e1bfb
AM		 7186{
7187 unsigned long r_symndx;
0d4792f7 7188 int next_r;
411e1bfb
AM		 7189 struct elf_link_hash_entry *h;
7190 Elf_Internal_Sym *sym;
7191 asection *sec;
7192 bfd_vma off;
7193
7194 r_symndx = ELF64_R_SYM (rel->r_info);
e7b938ca 7195 if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
951fd09b 7196 return 0;
411e1bfb 7197
e7b938ca 7198 if ((*tls_maskp != NULL && **tls_maskp != 0)
411e1bfb 7199 || sec == NULL
6bee8834 7200 || ppc64_elf_section_data (sec) == NULL
7c8fe5c4 7201 || ppc64_elf_section_data (sec)->sec_type != sec_toc)
951fd09b 7202 return 1;
411e1bfb
AM		 7203
7204 /* Look inside a TOC section too. */
7205 if (h != NULL)
7206 {
7207 BFD_ASSERT (h->root.type == bfd_link_hash_defined);
7208 off = h->root.u.def.value;
7209 }
7210 else
7211 off = sym->st_value;
7212 off += rel->r_addend;
7213 BFD_ASSERT (off % 8 == 0);
3a71aa26
AM		 7214 r_symndx = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8];
7215 next_r = ppc64_elf_section_data (sec)->u.toc.symndx[off / 8 + 1];
0d4792f7
AM		 7216 if (toc_symndx != NULL)
7217 *toc_symndx = r_symndx;
3a71aa26
AM		 7218 if (toc_addend != NULL)
7219 *toc_addend = ppc64_elf_section_data (sec)->u.toc.add[off / 8];
7220 if (!get_sym_h (&h, &sym, &sec, tls_maskp, locsymsp, r_symndx, ibfd))
7221 return 0;
854b41e7 7222 if ((h == NULL || is_static_defined (h))
0d4792f7
AM		 7223 && (next_r == -1 || next_r == -2))
7224 return 1 - next_r;
951fd09b 7225 return 1;
411e1bfb
AM		 7226}
7227
3b421ab3
AM		 7228/* Find (or create) an entry in the tocsave hash table. */
7229
7230static struct tocsave_entry *
7231tocsave_find (struct ppc_link_hash_table *htab,
7232 enum insert_option insert,
7233 Elf_Internal_Sym **local_syms,
7234 const Elf_Internal_Rela *irela,
7235 bfd *ibfd)
7236{
7237 unsigned long r_indx;
7238 struct elf_link_hash_entry *h;
7239 Elf_Internal_Sym *sym;
7240 struct tocsave_entry ent, *p;
7241 hashval_t hash;
7242 struct tocsave_entry **slot;
7243
7244 r_indx = ELF64_R_SYM (irela->r_info);
7245 if (!get_sym_h (&h, &sym, &ent.sec, NULL, local_syms, r_indx, ibfd))
7246 return NULL;
7247 if (ent.sec == NULL || ent.sec->output_section == NULL)
7248 {
7249 (*_bfd_error_handler)
7250 (_("%B: undefined symbol on R_PPC64_TOCSAVE relocation"));
7251 return NULL;
7252 }
7253
7254 if (h != NULL)
7255 ent.offset = h->root.u.def.value;
7256 else
7257 ent.offset = sym->st_value;
7258 ent.offset += irela->r_addend;
7259
7260 hash = tocsave_htab_hash (&ent);
7261 slot = ((struct tocsave_entry **)
7262 htab_find_slot_with_hash (htab->tocsave_htab, &ent, hash, insert));
7263 if (slot == NULL)
7264 return NULL;
7265
7266 if (*slot == NULL)
7267 {
7268 p = (struct tocsave_entry *) bfd_alloc (ibfd, sizeof (*p));
7269 if (p == NULL)
7270 return NULL;
7271 *p = ent;
7272 *slot = p;
7273 }
7274 return *slot;
7275}
7276
754021d0 7277/* Adjust all global syms defined in opd sections. In gcc generated
8387904d 7278 code for the old ABI, these will already have been done. */
754021d0
AM		 7279
7280static bfd_boolean
7281adjust_opd_syms (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
7282{
7283 struct ppc_link_hash_entry *eh;
7284 asection *sym_sec;
74f0fb50 7285 struct _opd_sec_data *opd;
754021d0
AM		 7286
7287 if (h->root.type == bfd_link_hash_indirect)
7288 return TRUE;
7289
754021d0
AM		 7290 if (h->root.type != bfd_link_hash_defined
7291 && h->root.type != bfd_link_hash_defweak)
7292 return TRUE;
7293
7294 eh = (struct ppc_link_hash_entry *) h;
7295 if (eh->adjust_done)
7296 return TRUE;
7297
7298 sym_sec = eh->elf.root.u.def.section;
74f0fb50
AM		 7299 opd = get_opd_info (sym_sec);
7300 if (opd != NULL && opd->adjust != NULL)
754021d0 7301 {
74f0fb50 7302 long adjust = opd->adjust[eh->elf.root.u.def.value / 8];
4025353c
AM		 7303 if (adjust == -1)
7304 {
7305 /* This entry has been deleted. */
b3fac117 7306 asection *dsec = ppc64_elf_tdata (sym_sec->owner)->deleted_section;
81688140
AM		 7307 if (dsec == NULL)
7308 {
7309 for (dsec = sym_sec->owner->sections; dsec; dsec = dsec->next)
dbaa2011 7310 if (discarded_section (dsec))
81688140 7311 {
b3fac117 7312 ppc64_elf_tdata (sym_sec->owner)->deleted_section = dsec;
81688140
AM		 7313 break;
7314 }
7315 }
4025353c 7316 eh->elf.root.u.def.value = 0;
81688140 7317 eh->elf.root.u.def.section = dsec;
4025353c
AM		 7318 }
7319 else
7320 eh->elf.root.u.def.value += adjust;
754021d0
AM		 7321 eh->adjust_done = 1;
7322 }
7323 return TRUE;
7324}
7325
8c1d1bb8 7326/* Handles decrementing dynamic reloc counts for the reloc specified by
19e08130 7327 R_INFO in section SEC. If LOCAL_SYMS is NULL, then H and SYM
8c1d1bb8
AM		 7328 have already been determined. */
7329
7330static bfd_boolean
7331dec_dynrel_count (bfd_vma r_info,
7332 asection *sec,
7333 struct bfd_link_info *info,
7334 Elf_Internal_Sym **local_syms,
7335 struct elf_link_hash_entry *h,
19e08130 7336 Elf_Internal_Sym *sym)
8c1d1bb8
AM		 7337{
7338 enum elf_ppc64_reloc_type r_type;
19e08130 7339 asection *sym_sec = NULL;
8c1d1bb8
AM		 7340
7341 /* Can this reloc be dynamic? This switch, and later tests here
7342 should be kept in sync with the code in check_relocs. */
7343 r_type = ELF64_R_TYPE (r_info);
7344 switch (r_type)
7345 {
7346 default:
7347 return TRUE;
7348
7349 case R_PPC64_TPREL16:
7350 case R_PPC64_TPREL16_LO:
7351 case R_PPC64_TPREL16_HI:
7352 case R_PPC64_TPREL16_HA:
7353 case R_PPC64_TPREL16_DS:
7354 case R_PPC64_TPREL16_LO_DS:
f9c6b907
AM		 7355 case R_PPC64_TPREL16_HIGH:
7356 case R_PPC64_TPREL16_HIGHA:
8c1d1bb8
AM		 7357 case R_PPC64_TPREL16_HIGHER:
7358 case R_PPC64_TPREL16_HIGHERA:
7359 case R_PPC64_TPREL16_HIGHEST:
7360 case R_PPC64_TPREL16_HIGHESTA:
7361 if (!info->shared)
7362 return TRUE;
7363
7364 case R_PPC64_TPREL64:
7365 case R_PPC64_DTPMOD64:
7366 case R_PPC64_DTPREL64:
7367 case R_PPC64_ADDR64:
7368 case R_PPC64_REL30:
7369 case R_PPC64_REL32:
7370 case R_PPC64_REL64:
7371 case R_PPC64_ADDR14:
7372 case R_PPC64_ADDR14_BRNTAKEN:
7373 case R_PPC64_ADDR14_BRTAKEN:
7374 case R_PPC64_ADDR16:
7375 case R_PPC64_ADDR16_DS:
7376 case R_PPC64_ADDR16_HA:
7377 case R_PPC64_ADDR16_HI:
f9c6b907
AM		 7378 case R_PPC64_ADDR16_HIGH:
7379 case R_PPC64_ADDR16_HIGHA:
8c1d1bb8
AM		 7380 case R_PPC64_ADDR16_HIGHER:
7381 case R_PPC64_ADDR16_HIGHERA:
7382 case R_PPC64_ADDR16_HIGHEST:
7383 case R_PPC64_ADDR16_HIGHESTA:
7384 case R_PPC64_ADDR16_LO:
7385 case R_PPC64_ADDR16_LO_DS:
7386 case R_PPC64_ADDR24:
7387 case R_PPC64_ADDR32:
7388 case R_PPC64_UADDR16:
7389 case R_PPC64_UADDR32:
7390 case R_PPC64_UADDR64:
7391 case R_PPC64_TOC:
7392 break;
7393 }
7394
7395 if (local_syms != NULL)
7396 {
7397 unsigned long r_symndx;
8c1d1bb8
AM		 7398 bfd *ibfd = sec->owner;
7399
7400 r_symndx = ELF64_R_SYM (r_info);
7401 if (!get_sym_h (&h, &sym, &sym_sec, NULL, local_syms, r_symndx, ibfd))
7402 return FALSE;
7403 }
7404
7405 if ((info->shared
1d483afe 7406 && (must_be_dyn_reloc (info, r_type)
8c1d1bb8 7407 || (h != NULL
198f1157 7408 && (!SYMBOLIC_BIND (info, h)
8c1d1bb8
AM		 7409 || h->root.type == bfd_link_hash_defweak
7410 || !h->def_regular))))
7411 || (ELIMINATE_COPY_RELOCS
7412 && !info->shared
7413 && h != NULL
7414 && (h->root.type == bfd_link_hash_defweak
7415 || !h->def_regular)))
7416 ;
7417 else
7418 return TRUE;
7419
7420 if (h != NULL)
6edfbbad 7421 {
19e08130
AM		 7422 struct elf_dyn_relocs *p;
7423 struct elf_dyn_relocs **pp;
7424 pp = &((struct ppc_link_hash_entry *) h)->dyn_relocs;
7425
7426 /* elf_gc_sweep may have already removed all dyn relocs associated
7427 with local syms for a given section. Also, symbol flags are
7428 changed by elf_gc_sweep_symbol, confusing the test above. Don't
7429 report a dynreloc miscount. */
7430 if (*pp == NULL && info->gc_sections)
7431 return TRUE;
7432
7433 while ((p = *pp) != NULL)
60124e18 7434 {
19e08130
AM		 7435 if (p->sec == sec)
7436 {
7437 if (!must_be_dyn_reloc (info, r_type))
7438 p->pc_count -= 1;
7439 p->count -= 1;
7440 if (p->count == 0)
7441 *pp = p->next;
7442 return TRUE;
7443 }
7444 pp = &p->next;
60124e18 7445 }
6edfbbad 7446 }
19e08130
AM		 7447 else
7448 {
7449 struct ppc_dyn_relocs *p;
7450 struct ppc_dyn_relocs **pp;
7451 void *vpp;
7452 bfd_boolean is_ifunc;
8c1d1bb8 7453
19e08130
AM		 7454 if (local_syms == NULL)
7455 sym_sec = bfd_section_from_elf_index (sec->owner, sym->st_shndx);
7456 if (sym_sec == NULL)
7457 sym_sec = sec;
c57da1a7 7458
19e08130
AM		 7459 vpp = &elf_section_data (sym_sec)->local_dynrel;
7460 pp = (struct ppc_dyn_relocs **) vpp;
7461
7462 if (*pp == NULL && info->gc_sections)
7463 return TRUE;
7464
7465 is_ifunc = ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC;
7466 while ((p = *pp) != NULL)
8c1d1bb8 7467 {
19e08130
AM		 7468 if (p->sec == sec && p->ifunc == is_ifunc)
7469 {
7470 p->count -= 1;
7471 if (p->count == 0)
7472 *pp = p->next;
7473 return TRUE;
7474 }
7475 pp = &p->next;
8c1d1bb8 7476 }
8c1d1bb8
AM		 7477 }
7478
8de848d8 7479 info->callbacks->einfo (_("%P: dynreloc miscount for %B, section %A\n"),
25f53a85 7480 sec->owner, sec);
8c1d1bb8
AM		 7481 bfd_set_error (bfd_error_bad_value);
7482 return FALSE;
7483}
7484
754021d0
AM		 7485/* Remove unused Official Procedure Descriptor entries. Currently we
7486 only remove those associated with functions in discarded link-once
7487 sections, or weakly defined functions that have been overridden. It
7488 would be possible to remove many more entries for statically linked
7489 applications. */
7490
b34976b6 7491bfd_boolean
33c0ec9d 7492ppc64_elf_edit_opd (struct bfd_link_info *info, bfd_boolean non_overlapping)
1e2f5b6e
AM		 7493{
7494 bfd *ibfd;
754021d0 7495 bfd_boolean some_edited = FALSE;
3f764659 7496 asection *need_pad = NULL;
1e2f5b6e 7497
411e1bfb 7498 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
1e2f5b6e
AM		 7499 {
7500 asection *sec;
7501 Elf_Internal_Rela *relstart, *rel, *relend;
7502 Elf_Internal_Shdr *symtab_hdr;
6cdc0ccc 7503 Elf_Internal_Sym *local_syms;
1e2f5b6e 7504 bfd_vma offset;
74f0fb50 7505 struct _opd_sec_data *opd;
3f764659
JJ		 7506 bfd_boolean need_edit, add_aux_fields;
7507 bfd_size_type cnt_16b = 0;
1e2f5b6e 7508
854b41e7
AM		 7509 if (!is_ppc64_elf (ibfd))
7510 continue;
7511
1e2f5b6e 7512 sec = bfd_get_section_by_name (ibfd, ".opd");
46de2a7c 7513 if (sec == NULL || sec->size == 0)
1e2f5b6e
AM		 7514 continue;
7515
dbaa2011 7516 if (sec->sec_info_type == SEC_INFO_TYPE_JUST_SYMS)
4b85d634
AM		 7517 continue;
7518
1e2f5b6e
AM		 7519 if (sec->output_section == bfd_abs_section_ptr)
7520 continue;
7521
7522 /* Look through the section relocs. */
7523 if ((sec->flags & SEC_RELOC) == 0 || sec->reloc_count == 0)
7524 continue;
7525
6cdc0ccc 7526 local_syms = NULL;
0ffa91dd 7527 symtab_hdr = &elf_symtab_hdr (ibfd);
1e2f5b6e
AM		 7528
7529 /* Read the relocations. */
4ce794b7 7530 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
45d6a902 7531 info->keep_memory);
1e2f5b6e 7532 if (relstart == NULL)
b34976b6 7533 return FALSE;
1e2f5b6e
AM		 7534
7535 /* First run through the relocs to check they are sane, and to
7536 determine whether we need to edit this opd section. */
b34976b6 7537 need_edit = FALSE;
3f764659 7538 need_pad = sec;
1e2f5b6e
AM		 7539 offset = 0;
7540 relend = relstart + sec->reloc_count;
50bc7936 7541 for (rel = relstart; rel < relend; )
1e2f5b6e 7542 {
04c9666a 7543 enum elf_ppc64_reloc_type r_type;
1e2f5b6e
AM		 7544 unsigned long r_symndx;
7545 asection *sym_sec;
7546 struct elf_link_hash_entry *h;
7547 Elf_Internal_Sym *sym;
7548
3f764659 7549 /* .opd contains a regular array of 16 or 24 byte entries. We're
1e2f5b6e
AM		 7550 only interested in the reloc pointing to a function entry
7551 point. */
50bc7936
AM		 7552 if (rel->r_offset != offset
7553 || rel + 1 >= relend
7554 || (rel + 1)->r_offset != offset + 8)
1e2f5b6e
AM		 7555 {
7556 /* If someone messes with .opd alignment then after a
7557 "ld -r" we might have padding in the middle of .opd.
7558 Also, there's nothing to prevent someone putting
7559 something silly in .opd with the assembler. No .opd
b34976b6 7560 optimization for them! */
3f764659 7561 broken_opd:
1e2f5b6e 7562 (*_bfd_error_handler)
d003868e 7563 (_("%B: .opd is not a regular array of opd entries"), ibfd);
b34976b6 7564 need_edit = FALSE;
1e2f5b6e
AM		 7565 break;
7566 }
7567
50bc7936
AM		 7568 if ((r_type = ELF64_R_TYPE (rel->r_info)) != R_PPC64_ADDR64
7569 || (r_type = ELF64_R_TYPE ((rel + 1)->r_info)) != R_PPC64_TOC)
7570 {
7571 (*_bfd_error_handler)
d003868e
AM		 7572 (_("%B: unexpected reloc type %u in .opd section"),
7573 ibfd, r_type);
50bc7936
AM		 7574 need_edit = FALSE;
7575 break;
7576 }
7577
1e2f5b6e 7578 r_symndx = ELF64_R_SYM (rel->r_info);
411e1bfb
AM		 7579 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
7580 r_symndx, ibfd))
50bc7936 7581 goto error_ret;
1e2f5b6e
AM		 7582
7583 if (sym_sec == NULL || sym_sec->owner == NULL)
7584 {
411e1bfb
AM		 7585 const char *sym_name;
7586 if (h != NULL)
7587 sym_name = h->root.root.string;
7588 else
26c61ae5
L		 7589 sym_name = bfd_elf_sym_name (ibfd, symtab_hdr, sym,
7590 sym_sec);
411e1bfb 7591
1e2f5b6e 7592 (*_bfd_error_handler)
d003868e
AM		 7593 (_("%B: undefined sym `%s' in .opd section"),
7594 ibfd, sym_name);
b34976b6 7595 need_edit = FALSE;
1e2f5b6e
AM		 7596 break;
7597 }
7598
51020317
AM		 7599 /* opd entries are always for functions defined in the
7600 current input bfd. If the symbol isn't defined in the
7601 input bfd, then we won't be using the function in this
7602 bfd; It must be defined in a linkonce section in another
7603 bfd, or is weak. It's also possible that we are
7604 discarding the function due to a linker script /DISCARD/,
7605 which we test for via the output_section. */
7606 if (sym_sec->owner != ibfd
7607 || sym_sec->output_section == bfd_abs_section_ptr)
b34976b6 7608 need_edit = TRUE;
1e2f5b6e 7609
50bc7936 7610 rel += 2;
3f764659
JJ		 7611 if (rel == relend
7612 || (rel + 1 == relend && rel->r_offset == offset + 16))
7613 {
7614 if (sec->size == offset + 24)
7615 {
7616 need_pad = NULL;
7617 break;
7618 }
7619 if (rel == relend && sec->size == offset + 16)
7620 {
7621 cnt_16b++;
7622 break;
7623 }
7624 goto broken_opd;
7625 }
7626
7627 if (rel->r_offset == offset + 24)
7628 offset += 24;
7629 else if (rel->r_offset != offset + 16)
7630 goto broken_opd;
7631 else if (rel + 1 < relend
7632 && ELF64_R_TYPE (rel[0].r_info) == R_PPC64_ADDR64
7633 && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOC)
7634 {
7635 offset += 16;
7636 cnt_16b++;
7637 }
7638 else if (rel + 2 < relend
7639 && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_ADDR64
7640 && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_TOC)
7641 {
7642 offset += 24;
7643 rel += 1;
7644 }
7645 else
7646 goto broken_opd;
1e2f5b6e
AM		 7647 }
7648
3f764659
JJ		 7649 add_aux_fields = non_overlapping && cnt_16b > 0;
7650
7651 if (need_edit || add_aux_fields)
1e2f5b6e
AM		 7652 {
7653 Elf_Internal_Rela *write_rel;
d4730f92 7654 Elf_Internal_Shdr *rel_hdr;
1e2f5b6e 7655 bfd_byte *rptr, *wptr;
983bddc8 7656 bfd_byte *new_contents;
b34976b6 7657 bfd_boolean skip;
3f764659 7658 long opd_ent_size;
74f0fb50
AM		 7659 bfd_size_type amt;
7660
983bddc8 7661 new_contents = NULL;
74f0fb50
AM		 7662 amt = sec->size * sizeof (long) / 8;
7663 opd = &ppc64_elf_section_data (sec)->u.opd;
33c0ec9d 7664 opd->adjust = bfd_zalloc (sec->owner, amt);
74f0fb50
AM		 7665 if (opd->adjust == NULL)
7666 return FALSE;
7667 ppc64_elf_section_data (sec)->sec_type = sec_opd;
1e2f5b6e
AM		 7668
7669 /* This seems a waste of time as input .opd sections are all
7670 zeros as generated by gcc, but I suppose there's no reason
7671 this will always be so. We might start putting something in
7672 the third word of .opd entries. */
7673 if ((sec->flags & SEC_IN_MEMORY) == 0)
7674 {
eea6121a
AM		 7675 bfd_byte *loc;
7676 if (!bfd_malloc_and_get_section (ibfd, sec, &loc))
6cdc0ccc 7677 {
eea6121a
AM		 7678 if (loc != NULL)
7679 free (loc);
50bc7936 7680 error_ret:
6cdc0ccc
AM		 7681 if (local_syms != NULL
7682 && symtab_hdr->contents != (unsigned char *) local_syms)
7683 free (local_syms);
6cdc0ccc
AM		 7684 if (elf_section_data (sec)->relocs != relstart)
7685 free (relstart);
b34976b6 7686 return FALSE;
6cdc0ccc 7687 }
1e2f5b6e
AM		 7688 sec->contents = loc;
7689 sec->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
7690 }
7691
7692 elf_section_data (sec)->relocs = relstart;
7693
3f764659 7694 new_contents = sec->contents;
3f764659
JJ		 7695 if (add_aux_fields)
7696 {
7697 new_contents = bfd_malloc (sec->size + cnt_16b * 8);
7698 if (new_contents == NULL)
7699 return FALSE;
7700 need_pad = FALSE;
3f764659 7701 }
b4f4e59f
AM		 7702 wptr = new_contents;
7703 rptr = sec->contents;
3f764659 7704
1e2f5b6e 7705 write_rel = relstart;
b34976b6 7706 skip = FALSE;
1e2f5b6e 7707 offset = 0;
3f764659 7708 opd_ent_size = 0;
1e2f5b6e
AM		 7709 for (rel = relstart; rel < relend; rel++)
7710 {
50bc7936
AM		 7711 unsigned long r_symndx;
7712 asection *sym_sec;
7713 struct elf_link_hash_entry *h;
7714 Elf_Internal_Sym *sym;
7715
7716 r_symndx = ELF64_R_SYM (rel->r_info);
7717 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
d37c89e5 7718 r_symndx, ibfd))
50bc7936
AM		 7719 goto error_ret;
7720
1e2f5b6e
AM		 7721 if (rel->r_offset == offset)
7722 {
50bc7936 7723 struct ppc_link_hash_entry *fdh = NULL;
3f764659
JJ		 7724
7725 /* See if the .opd entry is full 24 byte or
7726 16 byte (with fd_aux entry overlapped with next
7727 fd_func). */
7728 opd_ent_size = 24;
7729 if ((rel + 2 == relend && sec->size == offset + 16)
7730 || (rel + 3 < relend
7731 && rel[2].r_offset == offset + 16
7732 && rel[3].r_offset == offset + 24
7733 && ELF64_R_TYPE (rel[2].r_info) == R_PPC64_ADDR64
7734 && ELF64_R_TYPE (rel[3].r_info) == R_PPC64_TOC))
7735 opd_ent_size = 16;
7736
4025353c
AM		 7737 if (h != NULL
7738 && h->root.root.string[0] == '.')
c4f68ce3 7739 {
4dfe6ac6
NC		 7740 struct ppc_link_hash_table *htab;
7741
7742 htab = ppc_hash_table (info);
7743 if (htab != NULL)
7744 fdh = lookup_fdh ((struct ppc_link_hash_entry *) h,
7745 htab);
c4f68ce3
AM		 7746 if (fdh != NULL
7747 && fdh->elf.root.type != bfd_link_hash_defined
7748 && fdh->elf.root.type != bfd_link_hash_defweak)
7749 fdh = NULL;
7750 }
1e2f5b6e 7751
51020317
AM		 7752 skip = (sym_sec->owner != ibfd
7753 || sym_sec->output_section == bfd_abs_section_ptr);
a4aa0fb7
AM		 7754 if (skip)
7755 {
4025353c 7756 if (fdh != NULL && sym_sec->owner == ibfd)
a4aa0fb7
AM		 7757 {
7758 /* Arrange for the function descriptor sym
7759 to be dropped. */
d6fe2dc1
AM		 7760 fdh->elf.root.u.def.value = 0;
7761 fdh->elf.root.u.def.section = sym_sec;
a4aa0fb7 7762 }
74f0fb50 7763 opd->adjust[rel->r_offset / 8] = -1;
a4aa0fb7
AM		 7764 }
7765 else
1e2f5b6e
AM		 7766 {
7767 /* We'll be keeping this opd entry. */
7768
4025353c 7769 if (fdh != NULL)
1e2f5b6e 7770 {
754021d0
AM		 7771 /* Redefine the function descriptor symbol to
7772 this location in the opd section. It is
7773 necessary to update the value here rather
7774 than using an array of adjustments as we do
7775 for local symbols, because various places
7776 in the generic ELF code use the value
7777 stored in u.def.value. */
3f764659 7778 fdh->elf.root.u.def.value = wptr - new_contents;
754021d0 7779 fdh->adjust_done = 1;
1e2f5b6e 7780 }
754021d0
AM		 7781
7782 /* Local syms are a bit tricky. We could
7783 tweak them as they can be cached, but
7784 we'd need to look through the local syms
7785 for the function descriptor sym which we
7786 don't have at the moment. So keep an
7787 array of adjustments. */
74f0fb50 7788 opd->adjust[rel->r_offset / 8]
3f764659 7789 = (wptr - new_contents) - (rptr - sec->contents);
1e2f5b6e
AM		 7790
7791 if (wptr != rptr)
3f764659
JJ		 7792 memcpy (wptr, rptr, opd_ent_size);
7793 wptr += opd_ent_size;
7794 if (add_aux_fields && opd_ent_size == 16)
7795 {
7796 memset (wptr, '\0', 8);
7797 wptr += 8;
7798 }
1e2f5b6e 7799 }
3f764659
JJ		 7800 rptr += opd_ent_size;
7801 offset += opd_ent_size;
1e2f5b6e
AM		 7802 }
7803
50bc7936
AM		 7804 if (skip)
7805 {
60124e18
AM		 7806 if (!NO_OPD_RELOCS
7807 && !info->relocatable
18d944df 7808 && !dec_dynrel_count (rel->r_info, sec, info,
19e08130 7809 NULL, h, sym))
8c1d1bb8 7810 goto error_ret;
50bc7936
AM		 7811 }
7812 else
1e2f5b6e 7813 {
50bc7936
AM		 7814 /* We need to adjust any reloc offsets to point to the
7815 new opd entries. While we're at it, we may as well
7816 remove redundant relocs. */
74f0fb50 7817 rel->r_offset += opd->adjust[(offset - opd_ent_size) / 8];
1e2f5b6e
AM		 7818 if (write_rel != rel)
7819 memcpy (write_rel, rel, sizeof (*rel));
7820 ++write_rel;
7821 }
7822 }
7823
3f764659 7824 sec->size = wptr - new_contents;
1e2f5b6e 7825 sec->reloc_count = write_rel - relstart;
3f764659
JJ		 7826 if (add_aux_fields)
7827 {
7828 free (sec->contents);
7829 sec->contents = new_contents;
7830 }
7831
05bf9422 7832 /* Fudge the header size too, as this is used later in
cdcf6e38 7833 elf_bfd_final_link if we are emitting relocs. */
d4730f92
BS		 7834 rel_hdr = _bfd_elf_single_rel_hdr (sec);
7835 rel_hdr->sh_size = sec->reloc_count * rel_hdr->sh_entsize;
754021d0 7836 some_edited = TRUE;
1e2f5b6e 7837 }
6cdc0ccc 7838 else if (elf_section_data (sec)->relocs != relstart)
1e2f5b6e 7839 free (relstart);
6cdc0ccc 7840
411e1bfb
AM		 7841 if (local_syms != NULL
7842 && symtab_hdr->contents != (unsigned char *) local_syms)
7843 {
7844 if (!info->keep_memory)
7845 free (local_syms);
7846 else
7847 symtab_hdr->contents = (unsigned char *) local_syms;
7848 }
7849 }
7850
754021d0
AM		 7851 if (some_edited)
7852 elf_link_hash_traverse (elf_hash_table (info), adjust_opd_syms, NULL);
7853
3f764659
JJ		 7854 /* If we are doing a final link and the last .opd entry is just 16 byte
7855 long, add a 8 byte padding after it. */
7856 if (need_pad != NULL && !info->relocatable)
7857 {
7858 bfd_byte *p;
7859
7860 if ((need_pad->flags & SEC_IN_MEMORY) == 0)
7861 {
7862 BFD_ASSERT (need_pad->size > 0);
7863
7864 p = bfd_malloc (need_pad->size + 8);
7865 if (p == NULL)
7866 return FALSE;
699733f6 7867
3f764659
JJ		 7868 if (! bfd_get_section_contents (need_pad->owner, need_pad,
7869 p, 0, need_pad->size))
7870 return FALSE;
7871
7872 need_pad->contents = p;
7873 need_pad->flags |= (SEC_IN_MEMORY | SEC_HAS_CONTENTS);
7874 }
7875 else
7876 {
7877 p = bfd_realloc (need_pad->contents, need_pad->size + 8);
7878 if (p == NULL)
7879 return FALSE;
7880
7881 need_pad->contents = p;
7882 }
7883
7884 memset (need_pad->contents + need_pad->size, 0, 8);
7885 need_pad->size += 8;
7886 }
7887
411e1bfb
AM		 7888 return TRUE;
7889}
7890
e1918d23 7891/* Set htab->tls_get_addr and call the generic ELF tls_setup function. */
411e1bfb 7892
e1918d23 7893asection *
33c0ec9d
AM		 7894ppc64_elf_tls_setup (struct bfd_link_info *info,
7895 int no_tls_get_addr_opt,
7896 int *no_multi_toc)
411e1bfb 7897{
411e1bfb
AM		 7898 struct ppc_link_hash_table *htab;
7899
411e1bfb 7900 htab = ppc_hash_table (info);
4dfe6ac6
NC		 7901 if (htab == NULL)
7902 return NULL;
7903
ee67d69a
AM		 7904 if (abiversion (info->output_bfd) == 1)
7905 htab->opd_abi = 1;
7906
33c0ec9d
AM		 7907 if (*no_multi_toc)
7908 htab->do_multi_toc = 0;
7909 else if (!htab->do_multi_toc)
7910 *no_multi_toc = 1;
7911
3a71aa26
AM		 7912 htab->tls_get_addr = ((struct ppc_link_hash_entry *)
7913 elf_link_hash_lookup (&htab->elf, ".__tls_get_addr",
7914 FALSE, FALSE, TRUE));
a7f2871e
AM		 7915 /* Move dynamic linking info to the function descriptor sym. */
7916 if (htab->tls_get_addr != NULL)
7917 func_desc_adjust (&htab->tls_get_addr->elf, info);
3a71aa26
AM		 7918 htab->tls_get_addr_fd = ((struct ppc_link_hash_entry *)
7919 elf_link_hash_lookup (&htab->elf, "__tls_get_addr",
7920 FALSE, FALSE, TRUE));
a7f2871e
AM		 7921 if (!no_tls_get_addr_opt)
7922 {
7923 struct elf_link_hash_entry *opt, *opt_fd, *tga, *tga_fd;
7924
7925 opt = elf_link_hash_lookup (&htab->elf, ".__tls_get_addr_opt",
7926 FALSE, FALSE, TRUE);
7927 if (opt != NULL)
7928 func_desc_adjust (opt, info);
7929 opt_fd = elf_link_hash_lookup (&htab->elf, "__tls_get_addr_opt",
7930 FALSE, FALSE, TRUE);
7931 if (opt_fd != NULL
7932 && (opt_fd->root.type == bfd_link_hash_defined
7933 || opt_fd->root.type == bfd_link_hash_defweak))
7934 {
7935 /* If glibc supports an optimized __tls_get_addr call stub,
7936 signalled by the presence of __tls_get_addr_opt, and we'll
7937 be calling __tls_get_addr via a plt call stub, then
7938 make __tls_get_addr point to __tls_get_addr_opt. */
7939 tga_fd = &htab->tls_get_addr_fd->elf;
7940 if (htab->elf.dynamic_sections_created
7941 && tga_fd != NULL
7942 && (tga_fd->type == STT_FUNC
7943 || tga_fd->needs_plt)
7944 && !(SYMBOL_CALLS_LOCAL (info, tga_fd)
7945 || (ELF_ST_VISIBILITY (tga_fd->other) != STV_DEFAULT
7946 && tga_fd->root.type == bfd_link_hash_undefweak)))
7947 {
7948 struct plt_entry *ent;
7949
7950 for (ent = tga_fd->plt.plist; ent != NULL; ent = ent->next)
7951 if (ent->plt.refcount > 0)
7952 break;
7953 if (ent != NULL)
7954 {
7955 tga_fd->root.type = bfd_link_hash_indirect;
7956 tga_fd->root.u.i.link = &opt_fd->root;
7957 ppc64_elf_copy_indirect_symbol (info, opt_fd, tga_fd);
7958 if (opt_fd->dynindx != -1)
7959 {
7960 /* Use __tls_get_addr_opt in dynamic relocations. */
7961 opt_fd->dynindx = -1;
7962 _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
7963 opt_fd->dynstr_index);
7964 if (!bfd_elf_link_record_dynamic_symbol (info, opt_fd))
854b41e7 7965 return NULL;
a7f2871e
AM		 7966 }
7967 htab->tls_get_addr_fd = (struct ppc_link_hash_entry *) opt_fd;
7968 tga = &htab->tls_get_addr->elf;
7969 if (opt != NULL && tga != NULL)
7970 {
7971 tga->root.type = bfd_link_hash_indirect;
7972 tga->root.u.i.link = &opt->root;
7973 ppc64_elf_copy_indirect_symbol (info, opt, tga);
7974 _bfd_elf_link_hash_hide_symbol (info, opt,
7975 tga->forced_local);
7976 htab->tls_get_addr = (struct ppc_link_hash_entry *) opt;
7977 }
7978 htab->tls_get_addr_fd->oh = htab->tls_get_addr;
7979 htab->tls_get_addr_fd->is_func_descriptor = 1;
7980 if (htab->tls_get_addr != NULL)
7981 {
7982 htab->tls_get_addr->oh = htab->tls_get_addr_fd;
7983 htab->tls_get_addr->is_func = 1;
7984 }
7985 }
7986 }
7987 }
7988 else
7989 no_tls_get_addr_opt = TRUE;
7990 }
7991 htab->no_tls_get_addr_opt = no_tls_get_addr_opt;
33c0ec9d 7992 return _bfd_elf_tls_setup (info->output_bfd, info);
3a71aa26 7993}
8387904d 7994
3a71aa26
AM		 7995/* Return TRUE iff REL is a branch reloc with a global symbol matching
7996 HASH1 or HASH2. */
8387904d 7997
3a71aa26
AM		 7998static bfd_boolean
7999branch_reloc_hash_match (const bfd *ibfd,
8000 const Elf_Internal_Rela *rel,
8001 const struct ppc_link_hash_entry *hash1,
8002 const struct ppc_link_hash_entry *hash2)
8003{
8004 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd);
8005 enum elf_ppc64_reloc_type r_type = ELF64_R_TYPE (rel->r_info);
8006 unsigned int r_symndx = ELF64_R_SYM (rel->r_info);
8007
e054468f 8008 if (r_symndx >= symtab_hdr->sh_info && is_branch_reloc (r_type))
8387904d 8009 {
3a71aa26
AM		 8010 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
8011 struct elf_link_hash_entry *h;
8387904d 8012
3a71aa26 8013 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
b31867b6 8014 h = elf_follow_link (h);
3a71aa26
AM		 8015 if (h == &hash1->elf || h == &hash2->elf)
8016 return TRUE;
a48ebf4d 8017 }
3a71aa26 8018 return FALSE;
951fd09b 8019}
411e1bfb 8020
951fd09b
AM		 8021/* Run through all the TLS relocs looking for optimization
8022 opportunities. The linker has been hacked (see ppc64elf.em) to do
8023 a preliminary section layout so that we know the TLS segment
8024 offsets. We can't optimize earlier because some optimizations need
8025 to know the tp offset, and we need to optimize before allocating
8026 dynamic relocations. */
8027
8028bfd_boolean
33c0ec9d 8029ppc64_elf_tls_optimize (struct bfd_link_info *info)
951fd09b
AM		 8030{
8031 bfd *ibfd;
8032 asection *sec;
8033 struct ppc_link_hash_table *htab;
663a1470 8034 unsigned char *toc_ref;
102890f0 8035 int pass;
951fd09b 8036
1d483afe 8037 if (info->relocatable || !info->executable)
411e1bfb
AM		 8038 return TRUE;
8039
951fd09b 8040 htab = ppc_hash_table (info);
4dfe6ac6
NC		 8041 if (htab == NULL)
8042 return FALSE;
8043
663a1470
AM		 8044 /* Make two passes over the relocs. On the first pass, mark toc
8045 entries involved with tls relocs, and check that tls relocs
8046 involved in setting up a tls_get_addr call are indeed followed by
8047 such a call. If they are not, we can't do any tls optimization.
8048 On the second pass twiddle tls_mask flags to notify
8049 relocate_section that optimization can be done, and adjust got
8050 and plt refcounts. */
8051 toc_ref = NULL;
8052 for (pass = 0; pass < 2; ++pass)
8053 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
8054 {
8055 Elf_Internal_Sym *locsyms = NULL;
8056 asection *toc = bfd_get_section_by_name (ibfd, ".toc");
8057
102890f0
AM		 8058 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8059 if (sec->has_tls_reloc && !bfd_is_abs_section (sec->output_section))
8060 {
8061 Elf_Internal_Rela *relstart, *rel, *relend;
663a1470 8062 bfd_boolean found_tls_get_addr_arg = 0;
411e1bfb 8063
102890f0
AM		 8064 /* Read the relocations. */
8065 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8066 info->keep_memory);
8067 if (relstart == NULL)
8068 return FALSE;
411e1bfb 8069
102890f0
AM		 8070 relend = relstart + sec->reloc_count;
8071 for (rel = relstart; rel < relend; rel++)
8072 {
8073 enum elf_ppc64_reloc_type r_type;
8074 unsigned long r_symndx;
8075 struct elf_link_hash_entry *h;
8076 Elf_Internal_Sym *sym;
8077 asection *sym_sec;
f961d9dd
AM		 8078 unsigned char *tls_mask;
8079 unsigned char tls_set, tls_clear, tls_type = 0;
102890f0
AM		 8080 bfd_vma value;
8081 bfd_boolean ok_tprel, is_local;
8082 long toc_ref_index = 0;
8083 int expecting_tls_get_addr = 0;
663a1470 8084 bfd_boolean ret = FALSE;
411e1bfb 8085
102890f0
AM		 8086 r_symndx = ELF64_R_SYM (rel->r_info);
8087 if (!get_sym_h (&h, &sym, &sym_sec, &tls_mask, &locsyms,
8088 r_symndx, ibfd))
8089 {
8090 err_free_rel:
8091 if (elf_section_data (sec)->relocs != relstart)
8092 free (relstart);
8093 if (toc_ref != NULL)
8094 free (toc_ref);
8095 if (locsyms != NULL
0ffa91dd 8096 && (elf_symtab_hdr (ibfd).contents
102890f0
AM		 8097 != (unsigned char *) locsyms))
8098 free (locsyms);
663a1470 8099 return ret;
102890f0 8100 }
411e1bfb 8101
102890f0
AM		 8102 if (h != NULL)
8103 {
766bc656
AM		 8104 if (h->root.type == bfd_link_hash_defined
8105 || h->root.type == bfd_link_hash_defweak)
8106 value = h->root.u.def.value;
8107 else if (h->root.type == bfd_link_hash_undefweak)
8108 value = 0;
8109 else
663a1470
AM		 8110 {
8111 found_tls_get_addr_arg = 0;
8112 continue;
8113 }
102890f0
AM		 8114 }
8115 else
8116 /* Symbols referenced by TLS relocs must be of type
8117 STT_TLS. So no need for .opd local sym adjust. */
8118 value = sym->st_value;
8119
8120 ok_tprel = FALSE;
8121 is_local = FALSE;
8122 if (h == NULL
8123 || !h->def_dynamic)
8124 {
8125 is_local = TRUE;
766bc656
AM		 8126 if (h != NULL
8127 && h->root.type == bfd_link_hash_undefweak)
8128 ok_tprel = TRUE;
8129 else
8130 {
8131 value += sym_sec->output_offset;
8132 value += sym_sec->output_section->vma;
8133 value -= htab->elf.tls_sec->vma;
8134 ok_tprel = (value + TP_OFFSET + ((bfd_vma) 1 << 31)
8135 < (bfd_vma) 1 << 32);
8136 }
102890f0 8137 }
951fd09b 8138
102890f0 8139 r_type = ELF64_R_TYPE (rel->r_info);
663a1470
AM		 8140 /* If this section has old-style __tls_get_addr calls
8141 without marker relocs, then check that each
8142 __tls_get_addr call reloc is preceded by a reloc
8143 that conceivably belongs to the __tls_get_addr arg
8144 setup insn. If we don't find matching arg setup
8145 relocs, don't do any tls optimization. */
8146 if (pass == 0
8147 && sec->has_tls_get_addr_call
8148 && h != NULL
8149 && (h == &htab->tls_get_addr->elf
8150 || h == &htab->tls_get_addr_fd->elf)
8151 && !found_tls_get_addr_arg
8152 && is_branch_reloc (r_type))
8153 {
25f53a85 8154 info->callbacks->minfo (_("%H __tls_get_addr lost arg, "
663a1470
AM		 8155 "TLS optimization disabled\n"),
8156 ibfd, sec, rel->r_offset);
8157 ret = TRUE;
8158 goto err_free_rel;
8159 }
8160
8161 found_tls_get_addr_arg = 0;
102890f0
AM		 8162 switch (r_type)
8163 {
8164 case R_PPC64_GOT_TLSLD16:
8165 case R_PPC64_GOT_TLSLD16_LO:
8166 expecting_tls_get_addr = 1;
663a1470 8167 found_tls_get_addr_arg = 1;
102890f0
AM		 8168 /* Fall thru */
8169
8170 case R_PPC64_GOT_TLSLD16_HI:
8171 case R_PPC64_GOT_TLSLD16_HA:
8172 /* These relocs should never be against a symbol
8173 defined in a shared lib. Leave them alone if
8174 that turns out to be the case. */
8175 if (!is_local)
8176 continue;
411e1bfb 8177
102890f0 8178 /* LD -> LE */
411e1bfb 8179 tls_set = 0;
102890f0
AM		 8180 tls_clear = TLS_LD;
8181 tls_type = TLS_TLS | TLS_LD;
8182 break;
411e1bfb 8183
102890f0
AM		 8184 case R_PPC64_GOT_TLSGD16:
8185 case R_PPC64_GOT_TLSGD16_LO:
8186 expecting_tls_get_addr = 1;
663a1470 8187 found_tls_get_addr_arg = 1;
102890f0
AM		 8188 /* Fall thru */
8189
8190 case R_PPC64_GOT_TLSGD16_HI:
8191 case R_PPC64_GOT_TLSGD16_HA:
8192 if (ok_tprel)
8193 /* GD -> LE */
411e1bfb 8194 tls_set = 0;
102890f0
AM		 8195 else
8196 /* GD -> IE */
8197 tls_set = TLS_TLS | TLS_TPRELGD;
8198 tls_clear = TLS_GD;
8199 tls_type = TLS_TLS | TLS_GD;
8200 break;
8201
8202 case R_PPC64_GOT_TPREL16_DS:
8203 case R_PPC64_GOT_TPREL16_LO_DS:
8204 case R_PPC64_GOT_TPREL16_HI:
8205 case R_PPC64_GOT_TPREL16_HA:
8206 if (ok_tprel)
8207 {
8208 /* IE -> LE */
8209 tls_set = 0;
8210 tls_clear = TLS_TPREL;
8211 tls_type = TLS_TLS | TLS_TPREL;
8212 break;
8213 }
411e1bfb
AM		 8214 continue;
8215
727fc41e
AM		 8216 case R_PPC64_TLSGD:
8217 case R_PPC64_TLSLD:
663a1470
AM		 8218 found_tls_get_addr_arg = 1;
8219 /* Fall thru */
8220
8221 case R_PPC64_TLS:
8222 case R_PPC64_TOC16:
8223 case R_PPC64_TOC16_LO:
102890f0
AM		 8224 if (sym_sec == NULL || sym_sec != toc)
8225 continue;
8226
8227 /* Mark this toc entry as referenced by a TLS
8228 code sequence. We can do that now in the
8229 case of R_PPC64_TLS, and after checking for
8230 tls_get_addr for the TOC16 relocs. */
8231 if (toc_ref == NULL)
663a1470
AM		 8232 toc_ref = bfd_zmalloc (toc->output_section->rawsize / 8);
8233 if (toc_ref == NULL)
8234 goto err_free_rel;
8235
102890f0
AM		 8236 if (h != NULL)
8237 value = h->root.u.def.value;
8238 else
8239 value = sym->st_value;
8240 value += rel->r_addend;
8241 BFD_ASSERT (value < toc->size && value % 8 == 0);
663a1470 8242 toc_ref_index = (value + toc->output_offset) / 8;
727fc41e
AM		 8243 if (r_type == R_PPC64_TLS
8244 || r_type == R_PPC64_TLSGD
8245 || r_type == R_PPC64_TLSLD)
102890f0
AM		 8246 {
8247 toc_ref[toc_ref_index] = 1;
8248 continue;
8249 }
8250
8251 if (pass != 0 && toc_ref[toc_ref_index] == 0)
8252 continue;
8253
8254 tls_set = 0;
8255 tls_clear = 0;
8256 expecting_tls_get_addr = 2;
8257 break;
8258
8259 case R_PPC64_TPREL64:
8260 if (pass == 0
8261 || sec != toc
8262 || toc_ref == NULL
663a1470 8263 || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
102890f0
AM		 8264 continue;
8265 if (ok_tprel)
8266 {
8267 /* IE -> LE */
8268 tls_set = TLS_EXPLICIT;
8269 tls_clear = TLS_TPREL;
8270 break;
8271 }
8272 continue;
8273
8274 case R_PPC64_DTPMOD64:
8275 if (pass == 0
8276 || sec != toc
8277 || toc_ref == NULL
663a1470 8278 || !toc_ref[(rel->r_offset + toc->output_offset) / 8])
102890f0
AM		 8279 continue;
8280 if (rel + 1 < relend
8281 && (rel[1].r_info
8282 == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64))
8283 && rel[1].r_offset == rel->r_offset + 8)
8284 {
8285 if (ok_tprel)
8286 /* GD -> LE */
8287 tls_set = TLS_EXPLICIT | TLS_GD;
8288 else
8289 /* GD -> IE */
8290 tls_set = TLS_EXPLICIT | TLS_GD | TLS_TPRELGD;
8291 tls_clear = TLS_GD;
8292 }
8293 else
8294 {
8295 if (!is_local)
8296 continue;
8297
8298 /* LD -> LE */
8299 tls_set = TLS_EXPLICIT;
8300 tls_clear = TLS_LD;
8301 }
8302 break;
8303
8304 default:
8305 continue;
8306 }
8307
8308 if (pass == 0)
8309 {
727fc41e
AM		 8310 if (!expecting_tls_get_addr
8311 || !sec->has_tls_get_addr_call)
102890f0
AM		 8312 continue;
8313
3a71aa26
AM		 8314 if (rel + 1 < relend
8315 && branch_reloc_hash_match (ibfd, rel + 1,
8316 htab->tls_get_addr,
8317 htab->tls_get_addr_fd))
102890f0 8318 {
3a71aa26 8319 if (expecting_tls_get_addr == 2)
102890f0 8320 {
3a71aa26 8321 /* Check for toc tls entries. */
f961d9dd 8322 unsigned char *toc_tls;
3a71aa26
AM		 8323 int retval;
8324
8325 retval = get_tls_mask (&toc_tls, NULL, NULL,
8326 &locsyms,
8327 rel, ibfd);
8328 if (retval == 0)
8329 goto err_free_rel;
663a1470
AM		 8330 if (toc_tls != NULL)
8331 {
8332 if ((*toc_tls & (TLS_GD | TLS_LD)) != 0)
8333 found_tls_get_addr_arg = 1;
8334 if (retval > 1)
8335 toc_ref[toc_ref_index] = 1;
8336 }
102890f0 8337 }
3a71aa26 8338 continue;
102890f0
AM		 8339 }
8340
8341 if (expecting_tls_get_addr != 1)
8342 continue;
8343
8344 /* Uh oh, we didn't find the expected call. We
8345 could just mark this symbol to exclude it
8346 from tls optimization but it's safer to skip
663a1470 8347 the entire optimization. */
25f53a85 8348 info->callbacks->minfo (_("%H arg lost __tls_get_addr, "
663a1470
AM		 8349 "TLS optimization disabled\n"),
8350 ibfd, sec, rel->r_offset);
8351 ret = TRUE;
8352 goto err_free_rel;
102890f0
AM		 8353 }
8354
85f7a9cb 8355 if (expecting_tls_get_addr && htab->tls_get_addr != NULL)
102890f0
AM		 8356 {
8357 struct plt_entry *ent;
8358 for (ent = htab->tls_get_addr->elf.plt.plist;
8359 ent != NULL;
8360 ent = ent->next)
8361 if (ent->addend == 0)
411e1bfb 8362 {
102890f0 8363 if (ent->plt.refcount > 0)
30038c59 8364 {
102890f0
AM		 8365 ent->plt.refcount -= 1;
8366 expecting_tls_get_addr = 0;
30038c59 8367 }
102890f0 8368 break;
411e1bfb 8369 }
102890f0 8370 }
411e1bfb 8371
85f7a9cb 8372 if (expecting_tls_get_addr && htab->tls_get_addr_fd != NULL)
102890f0
AM		 8373 {
8374 struct plt_entry *ent;
8375 for (ent = htab->tls_get_addr_fd->elf.plt.plist;
8376 ent != NULL;
8377 ent = ent->next)
8378 if (ent->addend == 0)
411e1bfb 8379 {
102890f0
AM		 8380 if (ent->plt.refcount > 0)
8381 ent->plt.refcount -= 1;
8382 break;
411e1bfb 8383 }
102890f0 8384 }
411e1bfb 8385
102890f0 8386 if (tls_clear == 0)
30038c59
AM		 8387 continue;
8388
102890f0
AM		 8389 if ((tls_set & TLS_EXPLICIT) == 0)
8390 {
8391 struct got_entry *ent;
411e1bfb 8392
102890f0
AM		 8393 /* Adjust got entry for this reloc. */
8394 if (h != NULL)
8395 ent = h->got.glist;
8396 else
8397 ent = elf_local_got_ents (ibfd)[r_symndx];
411e1bfb 8398
102890f0
AM		 8399 for (; ent != NULL; ent = ent->next)
8400 if (ent->addend == rel->r_addend
8401 && ent->owner == ibfd
8402 && ent->tls_type == tls_type)
8403 break;
8404 if (ent == NULL)
8405 abort ();
411e1bfb 8406
102890f0
AM		 8407 if (tls_set == 0)
8408 {
8409 /* We managed to get rid of a got entry. */
8410 if (ent->got.refcount > 0)
8411 ent->got.refcount -= 1;
8412 }
8413 }
8414 else
8415 {
8416 /* If we got rid of a DTPMOD/DTPREL reloc pair then
8417 we'll lose one or two dyn relocs. */
8418 if (!dec_dynrel_count (rel->r_info, sec, info,
19e08130 8419 NULL, h, sym))
102890f0 8420 return FALSE;
411e1bfb 8421
102890f0
AM		 8422 if (tls_set == (TLS_EXPLICIT | TLS_GD))
8423 {
8424 if (!dec_dynrel_count ((rel + 1)->r_info, sec, info,
19e08130 8425 NULL, h, sym))
102890f0
AM		 8426 return FALSE;
8427 }
8428 }
411e1bfb 8429
102890f0
AM		 8430 *tls_mask |= tls_set;
8431 *tls_mask &= ~tls_clear;
8432 }
8c1d1bb8 8433
102890f0
AM		 8434 if (elf_section_data (sec)->relocs != relstart)
8435 free (relstart);
8436 }
411e1bfb 8437
663a1470
AM		 8438 if (locsyms != NULL
8439 && (elf_symtab_hdr (ibfd).contents != (unsigned char *) locsyms))
8440 {
8441 if (!info->keep_memory)
8442 free (locsyms);
8443 else
8444 elf_symtab_hdr (ibfd).contents = (unsigned char *) locsyms;
8445 }
8446 }
411e1bfb 8447
663a1470
AM		 8448 if (toc_ref != NULL)
8449 free (toc_ref);
b34976b6 8450 return TRUE;
1e2f5b6e 8451}
b34976b6 8452
c5614fa4
AM		 8453/* Called via elf_link_hash_traverse from ppc64_elf_edit_toc to adjust
8454 the values of any global symbols in a toc section that has been
8455 edited. Globals in toc sections should be a rarity, so this function
8456 sets a flag if any are found in toc sections other than the one just
8457 edited, so that futher hash table traversals can be avoided. */
8458
8459struct adjust_toc_info
8460{
8461 asection *toc;
8462 unsigned long *skip;
8463 bfd_boolean global_toc_syms;
8464};
8465
ba761f19
AM		 8466enum toc_skip_enum { ref_from_discarded = 1, can_optimize = 2 };
8467
c5614fa4
AM		 8468static bfd_boolean
8469adjust_toc_syms (struct elf_link_hash_entry *h, void *inf)
8470{
8471 struct ppc_link_hash_entry *eh;
8472 struct adjust_toc_info *toc_inf = (struct adjust_toc_info *) inf;
854b41e7 8473 unsigned long i;
c5614fa4 8474
c5614fa4
AM		 8475 if (h->root.type != bfd_link_hash_defined
8476 && h->root.type != bfd_link_hash_defweak)
8477 return TRUE;
8478
8479 eh = (struct ppc_link_hash_entry *) h;
8480 if (eh->adjust_done)
8481 return TRUE;
8482
8483 if (eh->elf.root.u.def.section == toc_inf->toc)
8484 {
854b41e7
AM		 8485 if (eh->elf.root.u.def.value > toc_inf->toc->rawsize)
8486 i = toc_inf->toc->rawsize >> 3;
c5614fa4 8487 else
854b41e7
AM		 8488 i = eh->elf.root.u.def.value >> 3;
8489
ba761f19 8490 if ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0)
c5614fa4
AM		 8491 {
8492 (*_bfd_error_handler)
854b41e7
AM		 8493 (_("%s defined on removed toc entry"), eh->elf.root.root.string);
8494 do
8495 ++i;
ba761f19 8496 while ((toc_inf->skip[i] & (ref_from_discarded | can_optimize)) != 0);
854b41e7 8497 eh->elf.root.u.def.value = (bfd_vma) i << 3;
c5614fa4 8498 }
854b41e7
AM		 8499
8500 eh->elf.root.u.def.value -= toc_inf->skip[i];
c5614fa4
AM		 8501 eh->adjust_done = 1;
8502 }
8503 else if (strcmp (eh->elf.root.u.def.section->name, ".toc") == 0)
8504 toc_inf->global_toc_syms = TRUE;
8505
8506 return TRUE;
8507}
8508
560c8763
AM		 8509/* Return TRUE iff INSN is one we expect on a _LO variety toc/got reloc. */
8510
8511static bfd_boolean
8512ok_lo_toc_insn (unsigned int insn)
8513{
8514 return ((insn & (0x3f << 26)) == 14u << 26 /* addi */
8515 || (insn & (0x3f << 26)) == 32u << 26 /* lwz */
8516 || (insn & (0x3f << 26)) == 34u << 26 /* lbz */
8517 || (insn & (0x3f << 26)) == 36u << 26 /* stw */
8518 || (insn & (0x3f << 26)) == 38u << 26 /* stb */
8519 || (insn & (0x3f << 26)) == 40u << 26 /* lhz */
8520 || (insn & (0x3f << 26)) == 42u << 26 /* lha */
8521 || (insn & (0x3f << 26)) == 44u << 26 /* sth */
8522 || (insn & (0x3f << 26)) == 46u << 26 /* lmw */
8523 || (insn & (0x3f << 26)) == 47u << 26 /* stmw */
8524 || (insn & (0x3f << 26)) == 48u << 26 /* lfs */
8525 || (insn & (0x3f << 26)) == 50u << 26 /* lfd */
8526 || (insn & (0x3f << 26)) == 52u << 26 /* stfs */
8527 || (insn & (0x3f << 26)) == 54u << 26 /* stfd */
8528 || ((insn & (0x3f << 26)) == 58u << 26 /* lwa,ld,lmd */
8529 && (insn & 3) != 1)
8530 || ((insn & (0x3f << 26)) == 62u << 26 /* std, stmd */
8531 && ((insn & 3) == 0 || (insn & 3) == 3))
8532 || (insn & (0x3f << 26)) == 12u << 26 /* addic */);
8533}
8534
c5614fa4
AM		 8535/* Examine all relocs referencing .toc sections in order to remove
8536 unused .toc entries. */
8537
8538bfd_boolean
33c0ec9d 8539ppc64_elf_edit_toc (struct bfd_link_info *info)
c5614fa4
AM		 8540{
8541 bfd *ibfd;
8542 struct adjust_toc_info toc_inf;
67f0cbdb 8543 struct ppc_link_hash_table *htab = ppc_hash_table (info);
c5614fa4 8544
67f0cbdb 8545 htab->do_toc_opt = 1;
c5614fa4
AM		 8546 toc_inf.global_toc_syms = TRUE;
8547 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
8548 {
8549 asection *toc, *sec;
8550 Elf_Internal_Shdr *symtab_hdr;
8551 Elf_Internal_Sym *local_syms;
425b145b 8552 Elf_Internal_Rela *relstart, *rel, *toc_relocs;
c5614fa4
AM		 8553 unsigned long *skip, *drop;
8554 unsigned char *used;
8555 unsigned char *keep, last, some_unused;
8556
854b41e7
AM		 8557 if (!is_ppc64_elf (ibfd))
8558 continue;
8559
c5614fa4
AM		 8560 toc = bfd_get_section_by_name (ibfd, ".toc");
8561 if (toc == NULL
92b7a70f 8562 || toc->size == 0
dbaa2011
AM		 8563 || toc->sec_info_type == SEC_INFO_TYPE_JUST_SYMS
8564 || discarded_section (toc))
c5614fa4
AM		 8565 continue;
8566
425b145b 8567 toc_relocs = NULL;
c5614fa4 8568 local_syms = NULL;
0ffa91dd 8569 symtab_hdr = &elf_symtab_hdr (ibfd);
c5614fa4
AM		 8570
8571 /* Look at sections dropped from the final link. */
8572 skip = NULL;
8573 relstart = NULL;
8574 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8575 {
8576 if (sec->reloc_count == 0
dbaa2011 8577 || !discarded_section (sec)
c5614fa4
AM		 8578 || get_opd_info (sec)
8579 || (sec->flags & SEC_ALLOC) == 0
8580 || (sec->flags & SEC_DEBUGGING) != 0)
8581 continue;
8582
8583 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL, FALSE);
8584 if (relstart == NULL)
8585 goto error_ret;
8586
8587 /* Run through the relocs to see which toc entries might be
8588 unused. */
8589 for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
8590 {
8591 enum elf_ppc64_reloc_type r_type;
8592 unsigned long r_symndx;
8593 asection *sym_sec;
8594 struct elf_link_hash_entry *h;
8595 Elf_Internal_Sym *sym;
8596 bfd_vma val;
8597
8598 r_type = ELF64_R_TYPE (rel->r_info);
8599 switch (r_type)
8600 {
8601 default:
8602 continue;
8603
8604 case R_PPC64_TOC16:
8605 case R_PPC64_TOC16_LO:
8606 case R_PPC64_TOC16_HI:
8607 case R_PPC64_TOC16_HA:
8608 case R_PPC64_TOC16_DS:
8609 case R_PPC64_TOC16_LO_DS:
8610 break;
8611 }
8612
8613 r_symndx = ELF64_R_SYM (rel->r_info);
8614 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8615 r_symndx, ibfd))
8616 goto error_ret;
8617
8618 if (sym_sec != toc)
8619 continue;
8620
8621 if (h != NULL)
8622 val = h->root.u.def.value;
8623 else
8624 val = sym->st_value;
8625 val += rel->r_addend;
8626
8627 if (val >= toc->size)
8628 continue;
8629
8630 /* Anything in the toc ought to be aligned to 8 bytes.
8631 If not, don't mark as unused. */
8632 if (val & 7)
8633 continue;
8634
8635 if (skip == NULL)
8636 {
854b41e7 8637 skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
c5614fa4
AM		 8638 if (skip == NULL)
8639 goto error_ret;
8640 }
8641
ba761f19 8642 skip[val >> 3] = ref_from_discarded;
c5614fa4
AM		 8643 }
8644
8645 if (elf_section_data (sec)->relocs != relstart)
8646 free (relstart);
8647 }
8648
ba761f19
AM		 8649 /* For largetoc loads of address constants, we can convert
8650 . addis rx,2,addr@got@ha
8651 . ld ry,addr@got@l(rx)
8652 to
8653 . addis rx,2,addr@toc@ha
8654 . addi ry,rx,addr@toc@l
8655 when addr is within 2G of the toc pointer. This then means
8656 that the word storing "addr" in the toc is no longer needed. */
68ffbac6 8657
ba761f19
AM		 8658 if (!ppc64_elf_tdata (ibfd)->has_small_toc_reloc
8659 && toc->output_section->rawsize < (bfd_vma) 1 << 31
8660 && toc->reloc_count != 0)
8661 {
8662 /* Read toc relocs. */
425b145b
AM		 8663 toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
8664 info->keep_memory);
8665 if (toc_relocs == NULL)
ba761f19
AM		 8666 goto error_ret;
8667
425b145b 8668 for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
ba761f19
AM		 8669 {
8670 enum elf_ppc64_reloc_type r_type;
8671 unsigned long r_symndx;
8672 asection *sym_sec;
8673 struct elf_link_hash_entry *h;
8674 Elf_Internal_Sym *sym;
8675 bfd_vma val, addr;
8676
8677 r_type = ELF64_R_TYPE (rel->r_info);
8678 if (r_type != R_PPC64_ADDR64)
8679 continue;
8680
8681 r_symndx = ELF64_R_SYM (rel->r_info);
8682 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8683 r_symndx, ibfd))
8684 goto error_ret;
8685
425b145b 8686 if (sym_sec == NULL
dbaa2011 8687 || discarded_section (sym_sec))
425b145b
AM		 8688 continue;
8689
726d3ab0 8690 if (!SYMBOL_CALLS_LOCAL (info, h))
ba761f19
AM		 8691 continue;
8692
8693 if (h != NULL)
bddc25c9
AM		 8694 {
8695 if (h->type == STT_GNU_IFUNC)
8696 continue;
8697 val = h->root.u.def.value;
8698 }
ba761f19 8699 else
bddc25c9
AM		 8700 {
8701 if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
8702 continue;
8703 val = sym->st_value;
8704 }
ba761f19
AM		 8705 val += rel->r_addend;
8706 val += sym_sec->output_section->vma + sym_sec->output_offset;
8707
8708 /* We don't yet know the exact toc pointer value, but we
8709 know it will be somewhere in the toc section. Don't
8710 optimize if the difference from any possible toc
8711 pointer is outside [ff..f80008000, 7fff7fff]. */
8712 addr = toc->output_section->vma + TOC_BASE_OFF;
8713 if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
8714 continue;
8715
8716 addr = toc->output_section->vma + toc->output_section->rawsize;
8717 if (val - addr + (bfd_vma) 0x80008000 >= (bfd_vma) 1 << 32)
8718 continue;
8719
8720 if (skip == NULL)
8721 {
8722 skip = bfd_zmalloc (sizeof (*skip) * (toc->size + 15) / 8);
8723 if (skip == NULL)
8724 goto error_ret;
8725 }
8726
8727 skip[rel->r_offset >> 3]
425b145b 8728 |= can_optimize | ((rel - toc_relocs) << 2);
ba761f19 8729 }
ba761f19
AM		 8730 }
8731
c5614fa4
AM		 8732 if (skip == NULL)
8733 continue;
8734
8735 used = bfd_zmalloc (sizeof (*used) * (toc->size + 7) / 8);
8736 if (used == NULL)
8737 {
8738 error_ret:
8739 if (local_syms != NULL
8740 && symtab_hdr->contents != (unsigned char *) local_syms)
8741 free (local_syms);
8742 if (sec != NULL
8743 && relstart != NULL
8744 && elf_section_data (sec)->relocs != relstart)
8745 free (relstart);
425b145b
AM		 8746 if (toc_relocs != NULL
8747 && elf_section_data (toc)->relocs != toc_relocs)
8748 free (toc_relocs);
c5614fa4
AM		 8749 if (skip != NULL)
8750 free (skip);
8751 return FALSE;
8752 }
8753
30038c59
AM		 8754 /* Now check all kept sections that might reference the toc.
8755 Check the toc itself last. */
8756 for (sec = (ibfd->sections == toc && toc->next ? toc->next
8757 : ibfd->sections);
c5614fa4 8758 sec != NULL;
c5614fa4 8759 sec = (sec == toc ? NULL
c5614fa4 8760 : sec->next == NULL ? toc
30038c59 8761 : sec->next == toc && toc->next ? toc->next
c5614fa4
AM		 8762 : sec->next))
8763 {
8764 int repeat;
8765
8766 if (sec->reloc_count == 0
dbaa2011 8767 || discarded_section (sec)
c5614fa4
AM		 8768 || get_opd_info (sec)
8769 || (sec->flags & SEC_ALLOC) == 0
8770 || (sec->flags & SEC_DEBUGGING) != 0)
8771 continue;
8772
854b41e7
AM		 8773 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
8774 info->keep_memory);
c5614fa4
AM		 8775 if (relstart == NULL)
8776 goto error_ret;
8777
8778 /* Mark toc entries referenced as used. */
c5614fa4 8779 do
d4f1ee75
AM		 8780 {
8781 repeat = 0;
8782 for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
8783 {
8784 enum elf_ppc64_reloc_type r_type;
8785 unsigned long r_symndx;
8786 asection *sym_sec;
8787 struct elf_link_hash_entry *h;
8788 Elf_Internal_Sym *sym;
8789 bfd_vma val;
8790 enum {no_check, check_lo, check_ha} insn_check;
98528052 8791
d4f1ee75
AM		 8792 r_type = ELF64_R_TYPE (rel->r_info);
8793 switch (r_type)
8794 {
8795 default:
8796 insn_check = no_check;
8797 break;
98528052 8798
d4f1ee75
AM		 8799 case R_PPC64_GOT_TLSLD16_HA:
8800 case R_PPC64_GOT_TLSGD16_HA:
8801 case R_PPC64_GOT_TPREL16_HA:
8802 case R_PPC64_GOT_DTPREL16_HA:
8803 case R_PPC64_GOT16_HA:
8804 case R_PPC64_TOC16_HA:
8805 insn_check = check_ha;
8806 break;
98528052 8807
d4f1ee75
AM		 8808 case R_PPC64_GOT_TLSLD16_LO:
8809 case R_PPC64_GOT_TLSGD16_LO:
8810 case R_PPC64_GOT_TPREL16_LO_DS:
8811 case R_PPC64_GOT_DTPREL16_LO_DS:
8812 case R_PPC64_GOT16_LO:
8813 case R_PPC64_GOT16_LO_DS:
8814 case R_PPC64_TOC16_LO:
8815 case R_PPC64_TOC16_LO_DS:
8816 insn_check = check_lo;
8817 break;
8818 }
560c8763 8819
d4f1ee75
AM		 8820 if (insn_check != no_check)
8821 {
8822 bfd_vma off = rel->r_offset & ~3;
8823 unsigned char buf[4];
8824 unsigned int insn;
c5614fa4 8825
d4f1ee75
AM		 8826 if (!bfd_get_section_contents (ibfd, sec, buf, off, 4))
8827 {
8828 free (used);
8829 goto error_ret;
8830 }
8831 insn = bfd_get_32 (ibfd, buf);
8832 if (insn_check == check_lo
8833 ? !ok_lo_toc_insn (insn)
8834 : ((insn & ((0x3f << 26) | 0x1f << 16))
8835 != ((15u << 26) | (2 << 16)) /* addis rt,2,imm */))
8836 {
8837 char str[12];
8838
8839 ppc64_elf_tdata (ibfd)->unexpected_toc_insn = 1;
8840 sprintf (str, "%#08x", insn);
8841 info->callbacks->einfo
8842 (_("%P: %H: toc optimization is not supported for"
8843 " %s instruction.\n"),
8844 ibfd, sec, rel->r_offset & ~3, str);
8845 }
8846 }
c5614fa4 8847
d4f1ee75
AM		 8848 switch (r_type)
8849 {
8850 case R_PPC64_TOC16:
8851 case R_PPC64_TOC16_LO:
8852 case R_PPC64_TOC16_HI:
8853 case R_PPC64_TOC16_HA:
8854 case R_PPC64_TOC16_DS:
8855 case R_PPC64_TOC16_LO_DS:
8856 /* In case we're taking addresses of toc entries. */
8857 case R_PPC64_ADDR64:
8858 break;
c5614fa4 8859
d4f1ee75
AM		 8860 default:
8861 continue;
8862 }
c5614fa4 8863
d4f1ee75
AM		 8864 r_symndx = ELF64_R_SYM (rel->r_info);
8865 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
8866 r_symndx, ibfd))
8867 {
8868 free (used);
8869 goto error_ret;
8870 }
c5614fa4 8871
d4f1ee75
AM		 8872 if (sym_sec != toc)
8873 continue;
c5614fa4 8874
d4f1ee75
AM		 8875 if (h != NULL)
8876 val = h->root.u.def.value;
8877 else
8878 val = sym->st_value;
8879 val += rel->r_addend;
ba761f19 8880
d4f1ee75
AM		 8881 if (val >= toc->size)
8882 continue;
ba761f19 8883
d4f1ee75
AM		 8884 if ((skip[val >> 3] & can_optimize) != 0)
8885 {
8886 bfd_vma off;
8887 unsigned char opc;
8888
8889 switch (r_type)
8890 {
8891 case R_PPC64_TOC16_HA:
ba761f19 8892 break;
ba761f19 8893
d4f1ee75
AM		 8894 case R_PPC64_TOC16_LO_DS:
8895 off = rel->r_offset;
8896 off += (bfd_big_endian (ibfd) ? -2 : 3);
8897 if (!bfd_get_section_contents (ibfd, sec, &opc,
8898 off, 1))
8899 {
8900 free (used);
8901 goto error_ret;
8902 }
8903 if ((opc & (0x3f << 2)) == (58u << 2))
8904 break;
8905 /* Fall thru */
ba761f19 8906
d4f1ee75
AM		 8907 default:
8908 /* Wrong sort of reloc, or not a ld. We may
8909 as well clear ref_from_discarded too. */
8910 skip[val >> 3] = 0;
8911 }
8912 }
8913
8914 if (sec != toc)
8915 used[val >> 3] = 1;
8916 /* For the toc section, we only mark as used if this
8917 entry itself isn't unused. */
8918 else if ((used[rel->r_offset >> 3]
8919 || !(skip[rel->r_offset >> 3] & ref_from_discarded))
8920 && !used[val >> 3])
8921 {
8922 /* Do all the relocs again, to catch reference
8923 chains. */
8924 repeat = 1;
8925 used[val >> 3] = 1;
8926 }
8927 }
8928 }
c5614fa4 8929 while (repeat);
854b41e7
AM		 8930
8931 if (elf_section_data (sec)->relocs != relstart)
8932 free (relstart);
c5614fa4
AM		 8933 }
8934
8935 /* Merge the used and skip arrays. Assume that TOC
8936 doublewords not appearing as either used or unused belong
8937 to to an entry more than one doubleword in size. */
8938 for (drop = skip, keep = used, last = 0, some_unused = 0;
8939 drop < skip + (toc->size + 7) / 8;
8940 ++drop, ++keep)
8941 {
8942 if (*keep)
8943 {
ba761f19
AM		 8944 *drop &= ~ref_from_discarded;
8945 if ((*drop & can_optimize) != 0)
8946 some_unused = 1;
c5614fa4
AM		 8947 last = 0;
8948 }
b140b010 8949 else if ((*drop & ref_from_discarded) != 0)
c5614fa4
AM		 8950 {
8951 some_unused = 1;
ba761f19 8952 last = ref_from_discarded;
c5614fa4
AM		 8953 }
8954 else
8955 *drop = last;
8956 }
8957
8958 free (used);
8959
8960 if (some_unused)
8961 {
8962 bfd_byte *contents, *src;
8963 unsigned long off;
d62b3684 8964 Elf_Internal_Sym *sym;
ba761f19 8965 bfd_boolean local_toc_syms = FALSE;
c5614fa4
AM		 8966
8967 /* Shuffle the toc contents, and at the same time convert the
8968 skip array from booleans into offsets. */
8969 if (!bfd_malloc_and_get_section (ibfd, toc, &contents))
8970 goto error_ret;
8971
8972 elf_section_data (toc)->this_hdr.contents = contents;
8973
8974 for (src = contents, off = 0, drop = skip;
8975 src < contents + toc->size;
8976 src += 8, ++drop)
8977 {
ba761f19
AM		 8978 if ((*drop & (can_optimize | ref_from_discarded)) != 0)
8979 off += 8;
c5614fa4
AM		 8980 else if (off != 0)
8981 {
8982 *drop = off;
8983 memcpy (src - off, src, 8);
8984 }
8985 }
854b41e7 8986 *drop = off;
c5614fa4
AM		 8987 toc->rawsize = toc->size;
8988 toc->size = src - contents - off;
8989
ba761f19
AM		 8990 /* Adjust addends for relocs against the toc section sym,
8991 and optimize any accesses we can. */
c5614fa4
AM		 8992 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
8993 {
8994 if (sec->reloc_count == 0
dbaa2011 8995 || discarded_section (sec))
c5614fa4
AM		 8996 continue;
8997
8998 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL,
854b41e7 8999 info->keep_memory);
c5614fa4
AM		 9000 if (relstart == NULL)
9001 goto error_ret;
9002
9003 for (rel = relstart; rel < relstart + sec->reloc_count; ++rel)
9004 {
9005 enum elf_ppc64_reloc_type r_type;
9006 unsigned long r_symndx;
9007 asection *sym_sec;
9008 struct elf_link_hash_entry *h;
854b41e7 9009 bfd_vma val;
c5614fa4
AM		 9010
9011 r_type = ELF64_R_TYPE (rel->r_info);
9012 switch (r_type)
9013 {
9014 default:
9015 continue;
9016
9017 case R_PPC64_TOC16:
9018 case R_PPC64_TOC16_LO:
9019 case R_PPC64_TOC16_HI:
9020 case R_PPC64_TOC16_HA:
9021 case R_PPC64_TOC16_DS:
9022 case R_PPC64_TOC16_LO_DS:
9023 case R_PPC64_ADDR64:
9024 break;
9025 }
9026
9027 r_symndx = ELF64_R_SYM (rel->r_info);
9028 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
9029 r_symndx, ibfd))
9030 goto error_ret;
9031
ba761f19 9032 if (sym_sec != toc)
c5614fa4
AM		 9033 continue;
9034
ba761f19
AM		 9035 if (h != NULL)
9036 val = h->root.u.def.value;
9037 else
9038 {
9039 val = sym->st_value;
9040 if (val != 0)
9041 local_toc_syms = TRUE;
9042 }
9043
9044 val += rel->r_addend;
854b41e7
AM		 9045
9046 if (val > toc->rawsize)
9047 val = toc->rawsize;
ba761f19
AM		 9048 else if ((skip[val >> 3] & ref_from_discarded) != 0)
9049 continue;
9050 else if ((skip[val >> 3] & can_optimize) != 0)
9051 {
9052 Elf_Internal_Rela *tocrel
425b145b 9053 = toc_relocs + (skip[val >> 3] >> 2);
ba761f19
AM		 9054 unsigned long tsym = ELF64_R_SYM (tocrel->r_info);
9055
9056 switch (r_type)
9057 {
9058 case R_PPC64_TOC16_HA:
9059 rel->r_info = ELF64_R_INFO (tsym, R_PPC64_TOC16_HA);
9060 break;
9061
9062 case R_PPC64_TOC16_LO_DS:
9063 rel->r_info = ELF64_R_INFO (tsym, R_PPC64_LO_DS_OPT);
9064 break;
9065
9066 default:
28942f62
AM		 9067 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
9068 ppc_howto_init ();
b140b010 9069 info->callbacks->einfo
bc30df16 9070 (_("%P: %H: %s references "
b140b010
AM		 9071 "optimized away TOC entry\n"),
9072 ibfd, sec, rel->r_offset,
9073 ppc64_elf_howto_table[r_type]->name);
9074 bfd_set_error (bfd_error_bad_value);
9075 goto error_ret;
ba761f19
AM		 9076 }
9077 rel->r_addend = tocrel->r_addend;
9078 elf_section_data (sec)->relocs = relstart;
9079 continue;
9080 }
9081
9082 if (h != NULL || sym->st_value != 0)
9083 continue;
854b41e7
AM		 9084
9085 rel->r_addend -= skip[val >> 3];
9086 elf_section_data (sec)->relocs = relstart;
c5614fa4 9087 }
854b41e7
AM		 9088
9089 if (elf_section_data (sec)->relocs != relstart)
9090 free (relstart);
c5614fa4
AM		 9091 }
9092
9093 /* We shouldn't have local or global symbols defined in the TOC,
9094 but handle them anyway. */
df22d223
AM		 9095 if (local_syms != NULL)
9096 for (sym = local_syms;
9097 sym < local_syms + symtab_hdr->sh_info;
9098 ++sym)
9099 if (sym->st_value != 0
9100 && bfd_section_from_elf_index (ibfd, sym->st_shndx) == toc)
9101 {
9102 unsigned long i;
854b41e7 9103
df22d223
AM		 9104 if (sym->st_value > toc->rawsize)
9105 i = toc->rawsize >> 3;
9106 else
9107 i = sym->st_value >> 3;
854b41e7 9108
df22d223
AM		 9109 if ((skip[i] & (ref_from_discarded | can_optimize)) != 0)
9110 {
9111 if (local_toc_syms)
9112 (*_bfd_error_handler)
9113 (_("%s defined on removed toc entry"),
9114 bfd_elf_sym_name (ibfd, symtab_hdr, sym, NULL));
9115 do
9116 ++i;
9117 while ((skip[i] & (ref_from_discarded | can_optimize)));
9118 sym->st_value = (bfd_vma) i << 3;
9119 }
d62b3684 9120
df22d223
AM		 9121 sym->st_value -= skip[i];
9122 symtab_hdr->contents = (unsigned char *) local_syms;
9123 }
c5614fa4 9124
854b41e7 9125 /* Adjust any global syms defined in this toc input section. */
c5614fa4
AM		 9126 if (toc_inf.global_toc_syms)
9127 {
9128 toc_inf.toc = toc;
9129 toc_inf.skip = skip;
9130 toc_inf.global_toc_syms = FALSE;
9131 elf_link_hash_traverse (elf_hash_table (info), adjust_toc_syms,
9132 &toc_inf);
9133 }
854b41e7
AM		 9134
9135 if (toc->reloc_count != 0)
9136 {
d4730f92 9137 Elf_Internal_Shdr *rel_hdr;
854b41e7
AM		 9138 Elf_Internal_Rela *wrel;
9139 bfd_size_type sz;
9140
854b41e7 9141 /* Remove unused toc relocs, and adjust those we keep. */
28be611c
AM		 9142 if (toc_relocs == NULL)
9143 toc_relocs = _bfd_elf_link_read_relocs (ibfd, toc, NULL, NULL,
9144 info->keep_memory);
9145 if (toc_relocs == NULL)
9146 goto error_ret;
9147
425b145b
AM		 9148 wrel = toc_relocs;
9149 for (rel = toc_relocs; rel < toc_relocs + toc->reloc_count; ++rel)
ba761f19
AM		 9150 if ((skip[rel->r_offset >> 3]
9151 & (ref_from_discarded | can_optimize)) == 0)
854b41e7
AM		 9152 {
9153 wrel->r_offset = rel->r_offset - skip[rel->r_offset >> 3];
9154 wrel->r_info = rel->r_info;
9155 wrel->r_addend = rel->r_addend;
9156 ++wrel;
9157 }
9158 else if (!dec_dynrel_count (rel->r_info, toc, info,
9159 &local_syms, NULL, NULL))
9160 goto error_ret;
9161
425b145b
AM		 9162 elf_section_data (toc)->relocs = toc_relocs;
9163 toc->reloc_count = wrel - toc_relocs;
d4730f92
BS		 9164 rel_hdr = _bfd_elf_single_rel_hdr (toc);
9165 sz = rel_hdr->sh_entsize;
9166 rel_hdr->sh_size = toc->reloc_count * sz;
854b41e7 9167 }
c5614fa4 9168 }
28be611c
AM		 9169 else if (toc_relocs != NULL
9170 && elf_section_data (toc)->relocs != toc_relocs)
425b145b 9171 free (toc_relocs);
c5614fa4
AM		 9172
9173 if (local_syms != NULL
9174 && symtab_hdr->contents != (unsigned char *) local_syms)
9175 {
9176 if (!info->keep_memory)
9177 free (local_syms);
9178 else
9179 symtab_hdr->contents = (unsigned char *) local_syms;
9180 }
9181 free (skip);
9182 }
9183
9184 return TRUE;
9185}
9186
1bbe0902
AM		 9187/* Return true iff input section I references the TOC using
9188 instructions limited to +/-32k offsets. */
9189
9190bfd_boolean
9191ppc64_elf_has_small_toc_reloc (asection *i)
9192{
9193 return (is_ppc64_elf (i->owner)
9194 && ppc64_elf_tdata (i->owner)->has_small_toc_reloc);
9195}
9196
927be08e
AM		 9197/* Allocate space for one GOT entry. */
9198
9199static void
9200allocate_got (struct elf_link_hash_entry *h,
9201 struct bfd_link_info *info,
9202 struct got_entry *gent)
9203{
9204 struct ppc_link_hash_table *htab = ppc_hash_table (info);
9205 bfd_boolean dyn;
9206 struct ppc_link_hash_entry *eh = (struct ppc_link_hash_entry *) h;
9207 int entsize = (gent->tls_type & eh->tls_mask & (TLS_GD | TLS_LD)
9208 ? 16 : 8);
9209 int rentsize = (gent->tls_type & eh->tls_mask & TLS_GD
9210 ? 2 : 1) * sizeof (Elf64_External_Rela);
9211 asection *got = ppc64_elf_tdata (gent->owner)->got;
9212
9213 gent->got.offset = got->size;
9214 got->size += entsize;
9215
9216 dyn = htab->elf.dynamic_sections_created;
19e08130 9217 if (h->type == STT_GNU_IFUNC)
927be08e 9218 {
33e44f2e 9219 htab->elf.irelplt->size += rentsize;
19e08130 9220 htab->got_reli_size += rentsize;
927be08e 9221 }
19e08130
AM		 9222 else if ((info->shared
9223 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h))
9224 && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
9225 || h->root.type != bfd_link_hash_undefweak))
927be08e 9226 {
19e08130 9227 asection *relgot = ppc64_elf_tdata (gent->owner)->relgot;
927be08e 9228 relgot->size += rentsize;
927be08e
AM		 9229 }
9230}
9231
7865406b
AM		 9232/* This function merges got entries in the same toc group. */
9233
9234static void
9235merge_got_entries (struct got_entry **pent)
9236{
9237 struct got_entry *ent, *ent2;
9238
9239 for (ent = *pent; ent != NULL; ent = ent->next)
9240 if (!ent->is_indirect)
9241 for (ent2 = ent->next; ent2 != NULL; ent2 = ent2->next)
9242 if (!ent2->is_indirect
9243 && ent2->addend == ent->addend
9244 && ent2->tls_type == ent->tls_type
9245 && elf_gp (ent2->owner) == elf_gp (ent->owner))
9246 {
9247 ent2->is_indirect = TRUE;
9248 ent2->got.ent = ent;
9249 }
9250}
9251
65f38f15
AM		 9252/* Allocate space in .plt, .got and associated reloc sections for
9253 dynamic relocs. */
5bd4f169 9254
b34976b6 9255static bfd_boolean
4ce794b7 9256allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
5bd4f169 9257{
65f38f15
AM		 9258 struct bfd_link_info *info;
9259 struct ppc_link_hash_table *htab;
5bd4f169 9260 asection *s;
65f38f15 9261 struct ppc_link_hash_entry *eh;
6061a67d 9262 struct elf_dyn_relocs *p;
0b8bcf0d 9263 struct got_entry **pgent, *gent;
5bd4f169 9264
e92d460e 9265 if (h->root.type == bfd_link_hash_indirect)
b34976b6 9266 return TRUE;
5bd4f169 9267
65f38f15
AM		 9268 info = (struct bfd_link_info *) inf;
9269 htab = ppc_hash_table (info);
4dfe6ac6
NC		 9270 if (htab == NULL)
9271 return FALSE;
5bd4f169 9272
e054468f
AM		 9273 if ((htab->elf.dynamic_sections_created
9274 && h->dynindx != -1
9275 && WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info->shared, h))
9276 || h->type == STT_GNU_IFUNC)
5bd4f169 9277 {
411e1bfb
AM		 9278 struct plt_entry *pent;
9279 bfd_boolean doneone = FALSE;
9280 for (pent = h->plt.plist; pent != NULL; pent = pent->next)
9281 if (pent->plt.refcount > 0)
9282 {
25f23106
AM		 9283 if (!htab->elf.dynamic_sections_created
9284 || h->dynindx == -1)
e054468f 9285 {
33e44f2e 9286 s = htab->elf.iplt;
e054468f 9287 pent->plt.offset = s->size;
b9e5796b 9288 s->size += PLT_ENTRY_SIZE (htab);
33e44f2e 9289 s = htab->elf.irelplt;
e054468f
AM		 9290 }
9291 else
9292 {
9293 /* If this is the first .plt entry, make room for the special
9294 first entry. */
33e44f2e 9295 s = htab->elf.splt;
e054468f 9296 if (s->size == 0)
b9e5796b 9297 s->size += PLT_INITIAL_ENTRY_SIZE (htab);
e054468f
AM		 9298
9299 pent->plt.offset = s->size;
9300
9301 /* Make room for this entry. */
b9e5796b 9302 s->size += PLT_ENTRY_SIZE (htab);
e054468f
AM		 9303
9304 /* Make room for the .glink code. */
9305 s = htab->glink;
9306 if (s->size == 0)
9307 s->size += GLINK_CALL_STUB_SIZE;
b9e5796b
AM		 9308 if (htab->opd_abi)
9309 {
9310 /* We need bigger stubs past index 32767. */
9311 if (s->size >= GLINK_CALL_STUB_SIZE + 32768*2*4)
9312 s->size += 4;
9313 s->size += 2*4;
9314 }
9315 else
e054468f 9316 s->size += 4;
e054468f
AM		 9317
9318 /* We also need to make an entry in the .rela.plt section. */
33e44f2e 9319 s = htab->elf.srelplt;
e054468f 9320 }
eea6121a 9321 s->size += sizeof (Elf64_External_Rela);
411e1bfb
AM		 9322 doneone = TRUE;
9323 }
9324 else
9325 pent->plt.offset = (bfd_vma) -1;
9326 if (!doneone)
65f38f15 9327 {
411e1bfb 9328 h->plt.plist = NULL;
f5385ebf 9329 h->needs_plt = 0;
65f38f15
AM		 9330 }
9331 }
9332 else
9333 {
411e1bfb 9334 h->plt.plist = NULL;
f5385ebf 9335 h->needs_plt = 0;
65f38f15
AM		 9336 }
9337
951fd09b
AM		 9338 eh = (struct ppc_link_hash_entry *) h;
9339 /* Run through the TLS GD got entries first if we're changing them
9340 to TPREL. */
e7b938ca 9341 if ((eh->tls_mask & TLS_TPRELGD) != 0)
951fd09b
AM		 9342 for (gent = h->got.glist; gent != NULL; gent = gent->next)
9343 if (gent->got.refcount > 0
9344 && (gent->tls_type & TLS_GD) != 0)
9345 {
9346 /* This was a GD entry that has been converted to TPREL. If
9347 there happens to be a TPREL entry we can use that one. */
9348 struct got_entry *ent;
9349 for (ent = h->got.glist; ent != NULL; ent = ent->next)
9350 if (ent->got.refcount > 0
9351 && (ent->tls_type & TLS_TPREL) != 0
e717da7e
AM		 9352 && ent->addend == gent->addend
9353 && ent->owner == gent->owner)
951fd09b
AM		 9354 {
9355 gent->got.refcount = 0;
9356 break;
9357 }
9358
9359 /* If not, then we'll be using our own TPREL entry. */
9360 if (gent->got.refcount != 0)
9361 gent->tls_type = TLS_TLS | TLS_TPREL;
9362 }
9363
7865406b
AM		 9364 /* Remove any list entry that won't generate a word in the GOT before
9365 we call merge_got_entries. Otherwise we risk merging to empty
9366 entries. */
0b8bcf0d
AM		 9367 pgent = &h->got.glist;
9368 while ((gent = *pgent) != NULL)
411e1bfb 9369 if (gent->got.refcount > 0)
7865406b
AM		 9370 {
9371 if ((gent->tls_type & TLS_LD) != 0
9372 && !h->def_dynamic)
9373 {
9374 ppc64_tlsld_got (gent->owner)->got.refcount += 1;
9375 *pgent = gent->next;
9376 }
9377 else
9378 pgent = &gent->next;
9379 }
9380 else
9381 *pgent = gent->next;
9382
9383 if (!htab->do_multi_toc)
9384 merge_got_entries (&h->got.glist);
9385
9386 for (gent = h->got.glist; gent != NULL; gent = gent->next)
9387 if (!gent->is_indirect)
411e1bfb
AM		 9388 {
9389 /* Make sure this symbol is output as a dynamic symbol.
951fd09b
AM		 9390 Undefined weak syms won't yet be marked as dynamic,
9391 nor will all TLS symbols. */
411e1bfb 9392 if (h->dynindx == -1
b099ab9f 9393 && !h->forced_local
25f23106 9394 && h->type != STT_GNU_IFUNC
b099ab9f 9395 && htab->elf.dynamic_sections_created)
411e1bfb 9396 {
c152c796 9397 if (! bfd_elf_link_record_dynamic_symbol (info, h))
411e1bfb
AM		 9398 return FALSE;
9399 }
65f38f15 9400
0c8d6e5c 9401 if (!is_ppc64_elf (gent->owner))
927be08e 9402 abort ();
0ffa91dd 9403
927be08e 9404 allocate_got (h, info, gent);
411e1bfb 9405 }
65f38f15 9406
b099ab9f 9407 if (eh->dyn_relocs == NULL
25f23106 9408 || (!htab->elf.dynamic_sections_created
a345bc8d
AM		 9409 && (h->type != STT_GNU_IFUNC
9410 || !htab->opd_abi)))
b34976b6 9411 return TRUE;
65f38f15
AM		 9412
9413 /* In the shared -Bsymbolic case, discard space allocated for
9414 dynamic pc-relative relocs against symbols which turn out to be
9415 defined in regular objects. For the normal shared case, discard
9416 space for relocs that have become local due to symbol visibility
9417 changes. */
9418
9419 if (info->shared)
9420 {
9c7a29a3 9421 /* Relocs that use pc_count are those that appear on a call insn,
1d483afe 9422 or certain REL relocs (see must_be_dyn_reloc) that can be
9c7a29a3
AM		 9423 generated via assembly. We want calls to protected symbols to
9424 resolve directly to the function rather than going via the plt.
9425 If people want function pointer comparisons to work as expected
9426 then they should avoid writing weird assembly. */
09695f56 9427 if (SYMBOL_CALLS_LOCAL (info, h))
65f38f15 9428 {
6061a67d 9429 struct elf_dyn_relocs **pp;
65f38f15
AM		 9430
9431 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
5bd4f169 9432 {
65f38f15
AM		 9433 p->count -= p->pc_count;
9434 p->pc_count = 0;
9435 if (p->count == 0)
9436 *pp = p->next;
9437 else
9438 pp = &p->next;
5bd4f169 9439 }
65f38f15 9440 }
4e795f50
AM		 9441
9442 /* Also discard relocs on undefined weak syms with non-default
9443 visibility. */
cab87ef9
AM		 9444 if (eh->dyn_relocs != NULL
9445 && h->root.type == bfd_link_hash_undefweak)
dfbb6ac9
AM		 9446 {
9447 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
9448 eh->dyn_relocs = NULL;
9449
9450 /* Make sure this symbol is output as a dynamic symbol.
9451 Undefined weak syms won't yet be marked as dynamic. */
9452 else if (h->dynindx == -1
9453 && !h->forced_local)
9454 {
9455 if (! bfd_elf_link_record_dynamic_symbol (info, h))
9456 return FALSE;
9457 }
9458 }
65f38f15 9459 }
25f23106
AM		 9460 else if (h->type == STT_GNU_IFUNC)
9461 {
9462 if (!h->non_got_ref)
9463 eh->dyn_relocs = NULL;
9464 }
f4656909 9465 else if (ELIMINATE_COPY_RELOCS)
65f38f15
AM		 9466 {
9467 /* For the non-shared case, discard space for relocs against
9468 symbols which turn out to need copy relocs or are not
9469 dynamic. */
9470
f5385ebf 9471 if (!h->non_got_ref
f5385ebf 9472 && !h->def_regular)
65f38f15
AM		 9473 {
9474 /* Make sure this symbol is output as a dynamic symbol.
9475 Undefined weak syms won't yet be marked as dynamic. */
9476 if (h->dynindx == -1
f5385ebf 9477 && !h->forced_local)
65f38f15 9478 {
c152c796 9479 if (! bfd_elf_link_record_dynamic_symbol (info, h))
b34976b6 9480 return FALSE;
65f38f15
AM		 9481 }
9482
9483 /* If that succeeded, we know we'll be keeping all the
9484 relocs. */
9485 if (h->dynindx != -1)
9486 goto keep;
9487 }
9488
9489 eh->dyn_relocs = NULL;
9490
ec338859 9491 keep: ;
65f38f15
AM		 9492 }
9493
9494 /* Finally, allocate space. */
9495 for (p = eh->dyn_relocs; p != NULL; p = p->next)
9496 {
9497 asection *sreloc = elf_section_data (p->sec)->sreloc;
19e08130 9498 if (eh->elf.type == STT_GNU_IFUNC)
33e44f2e 9499 sreloc = htab->elf.irelplt;
eea6121a 9500 sreloc->size += p->count * sizeof (Elf64_External_Rela);
65f38f15
AM		 9501 }
9502
b34976b6 9503 return TRUE;
65f38f15
AM		 9504}
9505
a345bc8d
AM		 9506/* Called via elf_link_hash_traverse from ppc64_elf_size_dynamic_sections
9507 to set up space for global entry stubs. These are put in glink,
9508 after the branch table. */
65f38f15 9509
b34976b6 9510static bfd_boolean
a345bc8d 9511size_global_entry_stubs (struct elf_link_hash_entry *h, void *inf)
65f38f15 9512{
a345bc8d
AM		 9513 struct bfd_link_info *info;
9514 struct ppc_link_hash_table *htab;
9515 struct plt_entry *pent;
9516 asection *s;
65f38f15 9517
a345bc8d
AM		 9518 if (h->root.type == bfd_link_hash_indirect)
9519 return TRUE;
65f38f15 9520
a345bc8d
AM		 9521 if (!h->pointer_equality_needed)
9522 return TRUE;
65f38f15 9523
a345bc8d
AM		 9524 if (h->def_regular)
9525 return TRUE;
65f38f15 9526
a345bc8d
AM		 9527 info = inf;
9528 htab = ppc_hash_table (info);
9529 if (htab == NULL)
9530 return FALSE;
9531
9532 s = htab->glink;
9533 for (pent = h->plt.plist; pent != NULL; pent = pent->next)
9534 if (pent->plt.offset != (bfd_vma) -1
9535 && pent->addend == 0)
9536 {
9537 s->size = (s->size + 15) & -16;
9538 s->size += 16;
9539 break;
9540 }
9541 return TRUE;
9542}
9543
9544/* Set DF_TEXTREL if we find any dynamic relocs that apply to
9545 read-only sections. */
9546
9547static bfd_boolean
9548maybe_set_textrel (struct elf_link_hash_entry *h, void *info)
9549{
9550 if (h->root.type == bfd_link_hash_indirect)
9551 return TRUE;
9552
9553 if (readonly_dynrelocs (h))
9554 {
9555 ((struct bfd_link_info *) info)->flags |= DF_TEXTREL;
9556
9557 /* Not an error, just cut short the traversal. */
9558 return FALSE;
65f38f15 9559 }
b34976b6 9560 return TRUE;
65f38f15
AM		 9561}
9562
9563/* Set the sizes of the dynamic sections. */
9564
b34976b6 9565static bfd_boolean
ee67d69a 9566ppc64_elf_size_dynamic_sections (bfd *output_bfd,
4ce794b7 9567 struct bfd_link_info *info)
65f38f15
AM		 9568{
9569 struct ppc_link_hash_table *htab;
9570 bfd *dynobj;
9571 asection *s;
b34976b6 9572 bfd_boolean relocs;
65f38f15 9573 bfd *ibfd;
7865406b 9574 struct got_entry *first_tlsld;
65f38f15
AM		 9575
9576 htab = ppc_hash_table (info);
4dfe6ac6
NC		 9577 if (htab == NULL)
9578 return FALSE;
9579
65f38f15
AM		 9580 dynobj = htab->elf.dynobj;
9581 if (dynobj == NULL)
9582 abort ();
9583
9584 if (htab->elf.dynamic_sections_created)
9585 {
9586 /* Set the contents of the .interp section to the interpreter. */
36af4a4e 9587 if (info->executable)
65f38f15 9588 {
3d4d4302 9589 s = bfd_get_linker_section (dynobj, ".interp");
65f38f15
AM		 9590 if (s == NULL)
9591 abort ();
eea6121a 9592 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
65f38f15
AM		 9593 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
9594 }
9595 }
9596
9597 /* Set up .got offsets for local syms, and space for local dynamic
9598 relocs. */
9599 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
9600 {
411e1bfb
AM		 9601 struct got_entry **lgot_ents;
9602 struct got_entry **end_lgot_ents;
e054468f
AM		 9603 struct plt_entry **local_plt;
9604 struct plt_entry **end_local_plt;
f961d9dd 9605 unsigned char *lgot_masks;
65f38f15
AM		 9606 bfd_size_type locsymcount;
9607 Elf_Internal_Shdr *symtab_hdr;
65f38f15 9608
0c8d6e5c 9609 if (!is_ppc64_elf (ibfd))
65f38f15
AM		 9610 continue;
9611
9612 for (s = ibfd->sections; s != NULL; s = s->next)
9613 {
19e08130 9614 struct ppc_dyn_relocs *p;
65f38f15 9615
6edfbbad 9616 for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
65f38f15 9617 {
ec338859
AM		 9618 if (!bfd_is_abs_section (p->sec)
9619 && bfd_is_abs_section (p->sec->output_section))
9620 {
9621 /* Input section has been discarded, either because
9622 it is a copy of a linkonce section or due to
9623 linker script /DISCARD/, so we'll be discarding
9624 the relocs too. */
9625 }
248866a8 9626 else if (p->count != 0)
ec338859 9627 {
19e08130
AM		 9628 asection *srel = elf_section_data (p->sec)->sreloc;
9629 if (p->ifunc)
33e44f2e 9630 srel = htab->elf.irelplt;
eea6121a 9631 srel->size += p->count * sizeof (Elf64_External_Rela);
248866a8
AM		 9632 if ((p->sec->output_section->flags & SEC_READONLY) != 0)
9633 info->flags |= DF_TEXTREL;
ec338859 9634 }
65f38f15
AM		 9635 }
9636 }
9637
411e1bfb
AM		 9638 lgot_ents = elf_local_got_ents (ibfd);
9639 if (!lgot_ents)
65f38f15
AM		 9640 continue;
9641
0ffa91dd 9642 symtab_hdr = &elf_symtab_hdr (ibfd);
65f38f15 9643 locsymcount = symtab_hdr->sh_info;
411e1bfb 9644 end_lgot_ents = lgot_ents + locsymcount;
e054468f
AM		 9645 local_plt = (struct plt_entry **) end_lgot_ents;
9646 end_local_plt = local_plt + locsymcount;
f961d9dd 9647 lgot_masks = (unsigned char *) end_local_plt;
e717da7e 9648 s = ppc64_elf_tdata (ibfd)->got;
e7b938ca 9649 for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
65f38f15 9650 {
0b8bcf0d 9651 struct got_entry **pent, *ent;
411e1bfb 9652
0b8bcf0d
AM		 9653 pent = lgot_ents;
9654 while ((ent = *pent) != NULL)
411e1bfb
AM		 9655 if (ent->got.refcount > 0)
9656 {
e7b938ca 9657 if ((ent->tls_type & *lgot_masks & TLS_LD) != 0)
411e1bfb 9658 {
927be08e 9659 ppc64_tlsld_got (ibfd)->got.refcount += 1;
0b8bcf0d 9660 *pent = ent->next;
411e1bfb
AM		 9661 }
9662 else
9663 {
19e08130
AM		 9664 unsigned int ent_size = 8;
9665 unsigned int rel_size = sizeof (Elf64_External_Rela);
9666
eea6121a 9667 ent->got.offset = s->size;
e7b938ca 9668 if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
927be08e 9669 {
19e08130
AM		 9670 ent_size *= 2;
9671 rel_size *= 2;
9672 }
9673 s->size += ent_size;
9674 if ((*lgot_masks & PLT_IFUNC) != 0)
9675 {
33e44f2e 9676 htab->elf.irelplt->size += rel_size;
19e08130
AM		 9677 htab->got_reli_size += rel_size;
9678 }
9679 else if (info->shared)
9680 {
9681 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
9682 srel->size += rel_size;
927be08e 9683 }
0b8bcf0d 9684 pent = &ent->next;
411e1bfb
AM		 9685 }
9686 }
9687 else
0b8bcf0d 9688 *pent = ent->next;
65f38f15 9689 }
e054468f
AM		 9690
9691 /* Allocate space for calls to local STT_GNU_IFUNC syms in .iplt. */
9692 for (; local_plt < end_local_plt; ++local_plt)
9693 {
9694 struct plt_entry *ent;
9695
9696 for (ent = *local_plt; ent != NULL; ent = ent->next)
9697 if (ent->plt.refcount > 0)
9698 {
33e44f2e 9699 s = htab->elf.iplt;
e054468f 9700 ent->plt.offset = s->size;
b9e5796b 9701 s->size += PLT_ENTRY_SIZE (htab);
e054468f 9702
33e44f2e 9703 htab->elf.irelplt->size += sizeof (Elf64_External_Rela);
e054468f
AM		 9704 }
9705 else
9706 ent->plt.offset = (bfd_vma) -1;
9707 }
65f38f15
AM		 9708 }
9709
9710 /* Allocate global sym .plt and .got entries, and space for global
9711 sym dynamic relocs. */
4ce794b7 9712 elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, info);
a345bc8d
AM		 9713 /* Stash the end of glink branch table. */
9714 if (htab->glink != NULL)
9715 htab->glink->rawsize = htab->glink->size;
9716
9717 if (!htab->opd_abi && !info->shared)
9718 elf_link_hash_traverse (&htab->elf, size_global_entry_stubs, info);
65f38f15 9719
7865406b 9720 first_tlsld = NULL;
102890f0
AM		 9721 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
9722 {
7865406b
AM		 9723 struct got_entry *ent;
9724
0c8d6e5c 9725 if (!is_ppc64_elf (ibfd))
102890f0
AM		 9726 continue;
9727
7865406b
AM		 9728 ent = ppc64_tlsld_got (ibfd);
9729 if (ent->got.refcount > 0)
102890f0 9730 {
7865406b 9731 if (!htab->do_multi_toc && first_tlsld != NULL)
102890f0 9732 {
7865406b
AM		 9733 ent->is_indirect = TRUE;
9734 ent->got.ent = first_tlsld;
9735 }
9736 else
9737 {
9738 if (first_tlsld == NULL)
9739 first_tlsld = ent;
9740 s = ppc64_elf_tdata (ibfd)->got;
9741 ent->got.offset = s->size;
9742 ent->owner = ibfd;
9743 s->size += 16;
9744 if (info->shared)
9745 {
9746 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
9747 srel->size += sizeof (Elf64_External_Rela);
9748 }
102890f0
AM		 9749 }
9750 }
9751 else
7865406b 9752 ent->got.offset = (bfd_vma) -1;
102890f0
AM		 9753 }
9754
65f38f15
AM		 9755 /* We now have determined the sizes of the various dynamic sections.
9756 Allocate memory for them. */
b34976b6 9757 relocs = FALSE;
65f38f15
AM		 9758 for (s = dynobj->sections; s != NULL; s = s->next)
9759 {
9760 if ((s->flags & SEC_LINKER_CREATED) == 0)
9761 continue;
9762
4ce794b7 9763 if (s == htab->brlt || s == htab->relbrlt)
721956f4
AM		 9764 /* These haven't been allocated yet; don't strip. */
9765 continue;
33e44f2e
AM		 9766 else if (s == htab->elf.sgot
9767 || s == htab->elf.splt
9768 || s == htab->elf.iplt
c456f082
AM		 9769 || s == htab->glink
9770 || s == htab->dynbss)
65f38f15
AM		 9771 {
9772 /* Strip this section if we don't need it; see the
9773 comment below. */
5bd4f169 9774 }
58d180e8
AM		 9775 else if (s == htab->glink_eh_frame)
9776 {
9777 if (!bfd_is_abs_section (s->output_section))
9778 /* Not sized yet. */
9779 continue;
9780 }
70cc837d 9781 else if (CONST_STRNEQ (s->name, ".rela"))
5bd4f169 9782 {
c456f082 9783 if (s->size != 0)
5bd4f169 9784 {
33e44f2e 9785 if (s != htab->elf.srelplt)
b34976b6 9786 relocs = TRUE;
5bd4f169
AM		 9787
9788 /* We use the reloc_count field as a counter if we need
9789 to copy relocs into the output file. */
9790 s->reloc_count = 0;
9791 }
9792 }
65f38f15 9793 else
5bd4f169
AM		 9794 {
9795 /* It's not one of our sections, so don't allocate space. */
9796 continue;
9797 }
9798
eea6121a 9799 if (s->size == 0)
5bd4f169 9800 {
c456f082
AM		 9801 /* If we don't need this section, strip it from the
9802 output file. This is mostly to handle .rela.bss and
9803 .rela.plt. We must create both sections in
9804 create_dynamic_sections, because they must be created
9805 before the linker maps input sections to output
9806 sections. The linker does that before
9807 adjust_dynamic_symbol is called, and it is that
9808 function which decides whether anything needs to go
9809 into these sections. */
8423293d 9810 s->flags |= SEC_EXCLUDE;
5bd4f169
AM		 9811 continue;
9812 }
9813
c456f082 9814 if ((s->flags & SEC_HAS_CONTENTS) == 0)
5f333394
AM		 9815 continue;
9816
65f38f15
AM		 9817 /* Allocate memory for the section contents. We use bfd_zalloc
9818 here in case unused entries are not reclaimed before the
9819 section's contents are written out. This should not happen,
411e1bfb
AM		 9820 but this way if it does we get a R_PPC64_NONE reloc in .rela
9821 sections instead of garbage.
9822 We also rely on the section contents being zero when writing
9823 the GOT. */
eea6121a 9824 s->contents = bfd_zalloc (dynobj, s->size);
65f38f15 9825 if (s->contents == NULL)
b34976b6 9826 return FALSE;
5bd4f169
AM		 9827 }
9828
e717da7e
AM		 9829 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
9830 {
0c8d6e5c 9831 if (!is_ppc64_elf (ibfd))
7b53ace3
AM		 9832 continue;
9833
e717da7e 9834 s = ppc64_elf_tdata (ibfd)->got;
33e44f2e 9835 if (s != NULL && s != htab->elf.sgot)
e717da7e 9836 {
eea6121a 9837 if (s->size == 0)
8423293d 9838 s->flags |= SEC_EXCLUDE;
e717da7e
AM		 9839 else
9840 {
eea6121a 9841 s->contents = bfd_zalloc (ibfd, s->size);
e717da7e
AM		 9842 if (s->contents == NULL)
9843 return FALSE;
9844 }
9845 }
9846 s = ppc64_elf_tdata (ibfd)->relgot;
9847 if (s != NULL)
9848 {
eea6121a 9849 if (s->size == 0)
8423293d 9850 s->flags |= SEC_EXCLUDE;
e717da7e
AM		 9851 else
9852 {
eea6121a 9853 s->contents = bfd_zalloc (ibfd, s->size);
e717da7e
AM		 9854 if (s->contents == NULL)
9855 return FALSE;
9856 relocs = TRUE;
9857 s->reloc_count = 0;
9858 }
9859 }
9860 }
9861
e86ce104 9862 if (htab->elf.dynamic_sections_created)
5bd4f169 9863 {
e8910a83
AM		 9864 bfd_boolean tls_opt;
9865
5bd4f169
AM		 9866 /* Add some entries to the .dynamic section. We fill in the
9867 values later, in ppc64_elf_finish_dynamic_sections, but we
9868 must add the entries now so that we get the correct size for
9869 the .dynamic section. The DT_DEBUG entry is filled in by the
9870 dynamic linker and used by the debugger. */
dc810e39 9871#define add_dynamic_entry(TAG, VAL) \
5a580b3a 9872 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
dc810e39 9873
36af4a4e 9874 if (info->executable)
5bd4f169 9875 {
dc810e39 9876 if (!add_dynamic_entry (DT_DEBUG, 0))
b34976b6 9877 return FALSE;
5bd4f169
AM		 9878 }
9879
33e44f2e 9880 if (htab->elf.splt != NULL && htab->elf.splt->size != 0)
5bd4f169 9881 {
dc810e39
AM		 9882 if (!add_dynamic_entry (DT_PLTGOT, 0)
9883 || !add_dynamic_entry (DT_PLTRELSZ, 0)
9884 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
5d1634d7
AM		 9885 || !add_dynamic_entry (DT_JMPREL, 0)
9886 || !add_dynamic_entry (DT_PPC64_GLINK, 0))
b34976b6 9887 return FALSE;
5bd4f169
AM		 9888 }
9889
ee67d69a 9890 if (NO_OPD_RELOCS && abiversion (output_bfd) <= 1)
19397422
AM		 9891 {
9892 if (!add_dynamic_entry (DT_PPC64_OPD, 0)
9893 || !add_dynamic_entry (DT_PPC64_OPDSZ, 0))
b34976b6 9894 return FALSE;
19397422
AM		 9895 }
9896
e8910a83
AM		 9897 tls_opt = (!htab->no_tls_get_addr_opt
9898 && htab->tls_get_addr_fd != NULL
9899 && htab->tls_get_addr_fd->elf.plt.plist != NULL);
9900 if (tls_opt || !htab->opd_abi)
9901 {
9902 if (!add_dynamic_entry (DT_PPC64_OPT, tls_opt ? PPC64_OPT_TLS : 0))
9903 return FALSE;
9904 }
a7f2871e 9905
5bd4f169
AM		 9906 if (relocs)
9907 {
dc810e39
AM		 9908 if (!add_dynamic_entry (DT_RELA, 0)
9909 || !add_dynamic_entry (DT_RELASZ, 0)
9910 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
b34976b6 9911 return FALSE;
5bd4f169 9912
65f38f15
AM		 9913 /* If any dynamic relocs apply to a read-only section,
9914 then we need a DT_TEXTREL entry. */
248866a8 9915 if ((info->flags & DF_TEXTREL) == 0)
a345bc8d 9916 elf_link_hash_traverse (&htab->elf, maybe_set_textrel, info);
5bd4f169 9917
65f38f15 9918 if ((info->flags & DF_TEXTREL) != 0)
5bd4f169 9919 {
65f38f15 9920 if (!add_dynamic_entry (DT_TEXTREL, 0))
b34976b6 9921 return FALSE;
5bd4f169 9922 }
5bd4f169 9923 }
5bd4f169 9924 }
65f38f15 9925#undef add_dynamic_entry
5bd4f169 9926
b34976b6 9927 return TRUE;
5bd4f169
AM		 9928}
9929
a345bc8d
AM		 9930/* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */
9931
9932static bfd_boolean
9933ppc64_elf_hash_symbol (struct elf_link_hash_entry *h)
9934{
9935 if (h->plt.plist != NULL
9936 && !h->def_regular
9937 && !h->pointer_equality_needed)
9938 return FALSE;
9939
9940 return _bfd_elf_hash_symbol (h);
9941}
9942
721956f4 9943/* Determine the type of stub needed, if any, for a call. */
5bd4f169 9944
4ce794b7
AM		 9945static inline enum ppc_stub_type
9946ppc_type_of_stub (asection *input_sec,
9947 const Elf_Internal_Rela *rel,
9948 struct ppc_link_hash_entry **hash,
e054468f 9949 struct plt_entry **plt_ent,
6911b7dc
AM		 9950 bfd_vma destination,
9951 unsigned long local_off)
5bd4f169 9952{
721956f4
AM		 9953 struct ppc_link_hash_entry *h = *hash;
9954 bfd_vma location;
9955 bfd_vma branch_offset;
9956 bfd_vma max_branch_offset;
4ce794b7 9957 enum elf_ppc64_reloc_type r_type;
5bd4f169 9958
721956f4
AM		 9959 if (h != NULL)
9960 {
e054468f 9961 struct plt_entry *ent;
7fe2b9a6 9962 struct ppc_link_hash_entry *fdh = h;
b31867b6
AM		 9963 if (h->oh != NULL
9964 && h->oh->is_func_descriptor)
7b8f6675
AM		 9965 {
9966 fdh = ppc_follow_link (h->oh);
9967 *hash = fdh;
9968 }
8387904d 9969
e054468f
AM		 9970 for (ent = fdh->elf.plt.plist; ent != NULL; ent = ent->next)
9971 if (ent->addend == rel->r_addend
9972 && ent->plt.offset != (bfd_vma) -1)
9973 {
e054468f
AM		 9974 *plt_ent = ent;
9975 return ppc_stub_plt_call;
9976 }
5bd4f169 9977
7fe2b9a6
AM		 9978 /* Here, we know we don't have a plt entry. If we don't have a
9979 either a defined function descriptor or a defined entry symbol
9980 in a regular object file, then it is pointless trying to make
9981 any other type of stub. */
854b41e7
AM		 9982 if (!is_static_defined (&fdh->elf)
9983 && !is_static_defined (&h->elf))
721956f4 9984 return ppc_stub_none;
5d1634d7 9985 }
e054468f
AM		 9986 else if (elf_local_got_ents (input_sec->owner) != NULL)
9987 {
9988 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (input_sec->owner);
9989 struct plt_entry **local_plt = (struct plt_entry **)
9990 elf_local_got_ents (input_sec->owner) + symtab_hdr->sh_info;
9991 unsigned long r_symndx = ELF64_R_SYM (rel->r_info);
9992
9993 if (local_plt[r_symndx] != NULL)
9994 {
9995 struct plt_entry *ent;
9996
9997 for (ent = local_plt[r_symndx]; ent != NULL; ent = ent->next)
9998 if (ent->addend == rel->r_addend
9999 && ent->plt.offset != (bfd_vma) -1)
10000 {
10001 *plt_ent = ent;
10002 return ppc_stub_plt_call;
10003 }
10004 }
10005 }
5d1634d7 10006
721956f4
AM		 10007 /* Determine where the call point is. */
10008 location = (input_sec->output_offset
10009 + input_sec->output_section->vma
10010 + rel->r_offset);
5d1634d7 10011
721956f4
AM		 10012 branch_offset = destination - location;
10013 r_type = ELF64_R_TYPE (rel->r_info);
5d1634d7 10014
721956f4
AM		 10015 /* Determine if a long branch stub is needed. */
10016 max_branch_offset = 1 << 25;
4ce794b7 10017 if (r_type != R_PPC64_REL24)
721956f4 10018 max_branch_offset = 1 << 15;
5d1634d7 10019
6911b7dc 10020 if (branch_offset + max_branch_offset >= 2 * max_branch_offset - local_off)
721956f4
AM		 10021 /* We need a stub. Figure out whether a long_branch or plt_branch
10022 is needed later. */
10023 return ppc_stub_long_branch;
5d1634d7 10024
721956f4 10025 return ppc_stub_none;
5d1634d7
AM		 10026}
10027
794e51c0
AM		 10028/* With power7 weakly ordered memory model, it is possible for ld.so
10029 to update a plt entry in one thread and have another thread see a
10030 stale zero toc entry. To avoid this we need some sort of acquire
10031 barrier in the call stub. One solution is to make the load of the
10032 toc word seem to appear to depend on the load of the function entry
10033 word. Another solution is to test for r2 being zero, and branch to
10034 the appropriate glink entry if so.
10035
10036 . fake dep barrier compare
71a39c98
AM		 10037 . ld 12,xxx(2) ld 12,xxx(2)
10038 . mtctr 12 mtctr 12
10039 . xor 11,12,12 ld 2,xxx+8(2)
794e51c0
AM		 10040 . add 2,2,11 cmpldi 2,0
10041 . ld 2,xxx+8(2) bnectr+
10042 . bctr b <glink_entry>
10043
10044 The solution involving the compare turns out to be faster, so
10045 that's what we use unless the branch won't reach. */
10046
10047#define ALWAYS_USE_FAKE_DEP 0
10048#define ALWAYS_EMIT_R2SAVE 0
5d1634d7 10049
5d1634d7
AM		 10050#define PPC_LO(v) ((v) & 0xffff)
10051#define PPC_HI(v) (((v) >> 16) & 0xffff)
10052#define PPC_HA(v) PPC_HI ((v) + 0x8000)
10053
794e51c0
AM		 10054static inline unsigned int
10055plt_stub_size (struct ppc_link_hash_table *htab,
10056 struct ppc_stub_hash_entry *stub_entry,
10057 bfd_vma off)
10058{
b9e5796b
AM		 10059 unsigned size = 12;
10060
10061 if (ALWAYS_EMIT_R2SAVE
10062 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10063 size += 4;
10064 if (PPC_HA (off) != 0)
794e51c0 10065 size += 4;
b9e5796b
AM		 10066 if (htab->opd_abi)
10067 {
10068 size += 4;
10069 if (htab->plt_static_chain)
10070 size += 4;
10071 if (htab->plt_thread_safe)
10072 size += 8;
10073 if (PPC_HA (off + 8 + 8 * htab->plt_static_chain) != PPC_HA (off))
10074 size += 4;
10075 }
794e51c0
AM		 10076 if (stub_entry->h != NULL
10077 && (stub_entry->h == htab->tls_get_addr_fd
10078 || stub_entry->h == htab->tls_get_addr)
10079 && !htab->no_tls_get_addr_opt)
10080 size += 13 * 4;
10081 return size;
10082}
10083
10084/* If this stub would cross fewer 2**plt_stub_align boundaries if we align,
10085 then return the padding needed to do so. */
10086static inline unsigned int
10087plt_stub_pad (struct ppc_link_hash_table *htab,
10088 struct ppc_stub_hash_entry *stub_entry,
10089 bfd_vma plt_off)
10090{
10091 int stub_align = 1 << htab->plt_stub_align;
10092 unsigned stub_size = plt_stub_size (htab, stub_entry, plt_off);
10093 bfd_vma stub_off = stub_entry->stub_sec->size;
10094
10095 if (((stub_off + stub_size - 1) & -stub_align) - (stub_off & -stub_align)
10096 > (stub_size & -stub_align))
10097 return stub_align - (stub_off & (stub_align - 1));
10098 return 0;
10099}
10100
10101/* Build a .plt call stub. */
10102
10103static inline bfd_byte *
10104build_plt_stub (struct ppc_link_hash_table *htab,
10105 struct ppc_stub_hash_entry *stub_entry,
10106 bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
10107{
10108 bfd *obfd = htab->stub_bfd;
b9e5796b 10109 bfd_boolean plt_load_toc = htab->opd_abi;
794e51c0
AM		 10110 bfd_boolean plt_static_chain = htab->plt_static_chain;
10111 bfd_boolean plt_thread_safe = htab->plt_thread_safe;
10112 bfd_boolean use_fake_dep = plt_thread_safe;
10113 bfd_vma cmp_branch_off = 0;
10114
10115 if (!ALWAYS_USE_FAKE_DEP
b9e5796b 10116 && plt_load_toc
794e51c0
AM		 10117 && plt_thread_safe
10118 && !(stub_entry->h != NULL
10119 && (stub_entry->h == htab->tls_get_addr_fd
10120 || stub_entry->h == htab->tls_get_addr)
10121 && !htab->no_tls_get_addr_opt))
10122 {
10123 bfd_vma pltoff = stub_entry->plt_ent->plt.offset & ~1;
b9e5796b
AM		 10124 bfd_vma pltindex = ((pltoff - PLT_INITIAL_ENTRY_SIZE (htab))
10125 / PLT_ENTRY_SIZE (htab));
794e51c0
AM		 10126 bfd_vma glinkoff = GLINK_CALL_STUB_SIZE + pltindex * 8;
10127 bfd_vma to, from;
10128
68d62958
AM		 10129 if (pltindex > 32768)
10130 glinkoff += (pltindex - 32768) * 4;
794e51c0
AM		 10131 to = (glinkoff
10132 + htab->glink->output_offset
10133 + htab->glink->output_section->vma);
10134 from = (p - stub_entry->stub_sec->contents
10135 + 4 * (ALWAYS_EMIT_R2SAVE
10136 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10137 + 4 * (PPC_HA (offset) != 0)
10138 + 4 * (PPC_HA (offset + 8 + 8 * plt_static_chain)
10139 != PPC_HA (offset))
10140 + 4 * (plt_static_chain != 0)
10141 + 20
10142 + stub_entry->stub_sec->output_offset
10143 + stub_entry->stub_sec->output_section->vma);
10144 cmp_branch_off = to - from;
10145 use_fake_dep = cmp_branch_off + (1 << 25) >= (1 << 26);
10146 }
10147
ac2df442
AM		 10148 if (PPC_HA (offset) != 0)
10149 {
176a0d42
AM		 10150 if (r != NULL)
10151 {
794e51c0
AM		 10152 if (ALWAYS_EMIT_R2SAVE
10153 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10154 r[0].r_offset += 4;
176a0d42 10155 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
3b421ab3 10156 r[1].r_offset = r[0].r_offset + 4;
176a0d42
AM		 10157 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10158 r[1].r_addend = r[0].r_addend;
b9e5796b 10159 if (plt_load_toc)
176a0d42 10160 {
b9e5796b 10161 if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
c7131b65 10162 {
b9e5796b
AM		 10163 r[2].r_offset = r[1].r_offset + 4;
10164 r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO);
10165 r[2].r_addend = r[0].r_addend;
10166 }
10167 else
10168 {
10169 r[2].r_offset = r[1].r_offset + 8 + 8 * use_fake_dep;
10170 r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10171 r[2].r_addend = r[0].r_addend + 8;
10172 if (plt_static_chain)
10173 {
10174 r[3].r_offset = r[2].r_offset + 4;
10175 r[3].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10176 r[3].r_addend = r[0].r_addend + 16;
10177 }
c7131b65 10178 }
176a0d42
AM		 10179 }
10180 }
794e51c0
AM		 10181 if (ALWAYS_EMIT_R2SAVE
10182 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
a078d95a 10183 bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p), p += 4;
71a39c98
AM		 10184 bfd_put_32 (obfd, ADDIS_R11_R2 | PPC_HA (offset), p), p += 4;
10185 bfd_put_32 (obfd, LD_R12_0R11 | PPC_LO (offset), p), p += 4;
b9e5796b
AM		 10186 if (plt_load_toc
10187 && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
ac2df442 10188 {
71a39c98 10189 bfd_put_32 (obfd, ADDI_R11_R11 | PPC_LO (offset), p), p += 4;
ac2df442
AM		 10190 offset = 0;
10191 }
71a39c98 10192 bfd_put_32 (obfd, MTCTR_R12, p), p += 4;
b9e5796b 10193 if (plt_load_toc)
794e51c0 10194 {
b9e5796b
AM		 10195 if (use_fake_dep)
10196 {
10197 bfd_put_32 (obfd, XOR_R2_R12_R12, p), p += 4;
10198 bfd_put_32 (obfd, ADD_R11_R11_R2, p), p += 4;
10199 }
10200 bfd_put_32 (obfd, LD_R2_0R11 | PPC_LO (offset + 8), p), p += 4;
10201 if (plt_static_chain)
10202 bfd_put_32 (obfd, LD_R11_0R11 | PPC_LO (offset + 16), p), p += 4;
794e51c0 10203 }
ac2df442
AM		 10204 }
10205 else
10206 {
176a0d42
AM		 10207 if (r != NULL)
10208 {
794e51c0
AM		 10209 if (ALWAYS_EMIT_R2SAVE
10210 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
10211 r[0].r_offset += 4;
176a0d42 10212 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
b9e5796b 10213 if (plt_load_toc)
176a0d42 10214 {
b9e5796b 10215 if (PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
c7131b65 10216 {
b9e5796b
AM		 10217 r[1].r_offset = r[0].r_offset + 4;
10218 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16);
10219 r[1].r_addend = r[0].r_addend;
10220 }
10221 else
10222 {
10223 r[1].r_offset = r[0].r_offset + 8 + 8 * use_fake_dep;
10224 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10225 r[1].r_addend = r[0].r_addend + 8 + 8 * plt_static_chain;
10226 if (plt_static_chain)
10227 {
10228 r[2].r_offset = r[1].r_offset + 4;
10229 r[2].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10230 r[2].r_addend = r[0].r_addend + 8;
10231 }
c7131b65 10232 }
176a0d42
AM		 10233 }
10234 }
794e51c0
AM		 10235 if (ALWAYS_EMIT_R2SAVE
10236 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
a078d95a 10237 bfd_put_32 (obfd, STD_R2_0R1 + STK_TOC (htab), p), p += 4;
71a39c98 10238 bfd_put_32 (obfd, LD_R12_0R2 | PPC_LO (offset), p), p += 4;
b9e5796b
AM		 10239 if (plt_load_toc
10240 && PPC_HA (offset + 8 + 8 * plt_static_chain) != PPC_HA (offset))
ac2df442
AM		 10241 {
10242 bfd_put_32 (obfd, ADDI_R2_R2 | PPC_LO (offset), p), p += 4;
10243 offset = 0;
10244 }
71a39c98 10245 bfd_put_32 (obfd, MTCTR_R12, p), p += 4;
b9e5796b 10246 if (plt_load_toc)
794e51c0 10247 {
b9e5796b
AM		 10248 if (use_fake_dep)
10249 {
10250 bfd_put_32 (obfd, XOR_R11_R12_R12, p), p += 4;
10251 bfd_put_32 (obfd, ADD_R2_R2_R11, p), p += 4;
10252 }
10253 if (plt_static_chain)
10254 bfd_put_32 (obfd, LD_R11_0R2 | PPC_LO (offset + 16), p), p += 4;
10255 bfd_put_32 (obfd, LD_R2_0R2 | PPC_LO (offset + 8), p), p += 4;
794e51c0 10256 }
ac2df442 10257 }
b9e5796b 10258 if (plt_load_toc && plt_thread_safe && !use_fake_dep)
794e51c0
AM		 10259 {
10260 bfd_put_32 (obfd, CMPLDI_R2_0, p), p += 4;
10261 bfd_put_32 (obfd, BNECTR_P4, p), p += 4;
22aa0c7e 10262 bfd_put_32 (obfd, B_DOT | (cmp_branch_off & 0x3fffffc), p), p += 4;
794e51c0
AM		 10263 }
10264 else
10265 bfd_put_32 (obfd, BCTR, p), p += 4;
5d1634d7
AM		 10266 return p;
10267}
10268
a7f2871e
AM		 10269/* Build a special .plt call stub for __tls_get_addr. */
10270
10271#define LD_R11_0R3 0xe9630000
10272#define LD_R12_0R3 0xe9830000
10273#define MR_R0_R3 0x7c601b78
10274#define CMPDI_R11_0 0x2c2b0000
10275#define ADD_R3_R12_R13 0x7c6c6a14
10276#define BEQLR 0x4d820020
10277#define MR_R3_R0 0x7c030378
a7f2871e
AM		 10278#define STD_R11_0R1 0xf9610000
10279#define BCTRL 0x4e800421
10280#define LD_R11_0R1 0xe9610000
a7f2871e
AM		 10281#define MTLR_R11 0x7d6803a6
10282
10283static inline bfd_byte *
794e51c0
AM		 10284build_tls_get_addr_stub (struct ppc_link_hash_table *htab,
10285 struct ppc_stub_hash_entry *stub_entry,
10286 bfd_byte *p, bfd_vma offset, Elf_Internal_Rela *r)
a7f2871e 10287{
794e51c0
AM		 10288 bfd *obfd = htab->stub_bfd;
10289
a7f2871e
AM		 10290 bfd_put_32 (obfd, LD_R11_0R3 + 0, p), p += 4;
10291 bfd_put_32 (obfd, LD_R12_0R3 + 8, p), p += 4;
10292 bfd_put_32 (obfd, MR_R0_R3, p), p += 4;
10293 bfd_put_32 (obfd, CMPDI_R11_0, p), p += 4;
10294 bfd_put_32 (obfd, ADD_R3_R12_R13, p), p += 4;
10295 bfd_put_32 (obfd, BEQLR, p), p += 4;
10296 bfd_put_32 (obfd, MR_R3_R0, p), p += 4;
10297 bfd_put_32 (obfd, MFLR_R11, p), p += 4;
a078d95a 10298 bfd_put_32 (obfd, STD_R11_0R1 + STK_LINKER (htab), p), p += 4;
a7f2871e
AM		 10299
10300 if (r != NULL)
10301 r[0].r_offset += 9 * 4;
794e51c0 10302 p = build_plt_stub (htab, stub_entry, p, offset, r);
a7f2871e
AM		 10303 bfd_put_32 (obfd, BCTRL, p - 4);
10304
a078d95a
AM		 10305 bfd_put_32 (obfd, LD_R11_0R1 + STK_LINKER (htab), p), p += 4;
10306 bfd_put_32 (obfd, LD_R2_0R1 + STK_TOC (htab), p), p += 4;
a7f2871e
AM		 10307 bfd_put_32 (obfd, MTLR_R11, p), p += 4;
10308 bfd_put_32 (obfd, BLR, p), p += 4;
10309
10310 return p;
10311}
10312
176a0d42
AM		 10313static Elf_Internal_Rela *
10314get_relocs (asection *sec, int count)
10315{
10316 Elf_Internal_Rela *relocs;
10317 struct bfd_elf_section_data *elfsec_data;
10318
10319 elfsec_data = elf_section_data (sec);
10320 relocs = elfsec_data->relocs;
10321 if (relocs == NULL)
10322 {
10323 bfd_size_type relsize;
10324 relsize = sec->reloc_count * sizeof (*relocs);
10325 relocs = bfd_alloc (sec->owner, relsize);
10326 if (relocs == NULL)
10327 return NULL;
10328 elfsec_data->relocs = relocs;
d4730f92
BS		 10329 elfsec_data->rela.hdr = bfd_zalloc (sec->owner,
10330 sizeof (Elf_Internal_Shdr));
10331 if (elfsec_data->rela.hdr == NULL)
10332 return NULL;
10333 elfsec_data->rela.hdr->sh_size = (sec->reloc_count
10334 * sizeof (Elf64_External_Rela));
10335 elfsec_data->rela.hdr->sh_entsize = sizeof (Elf64_External_Rela);
176a0d42
AM		 10336 sec->reloc_count = 0;
10337 }
10338 relocs += sec->reloc_count;
10339 sec->reloc_count += count;
10340 return relocs;
10341}
10342
aa374f67 10343static bfd_vma
25f53a85 10344get_r2off (struct bfd_link_info *info,
aa374f67
AM		 10345 struct ppc_stub_hash_entry *stub_entry)
10346{
25f53a85 10347 struct ppc_link_hash_table *htab = ppc_hash_table (info);
aa374f67
AM		 10348 bfd_vma r2off = htab->stub_group[stub_entry->target_section->id].toc_off;
10349
10350 if (r2off == 0)
10351 {
10352 /* Support linking -R objects. Get the toc pointer from the
10353 opd entry. */
10354 char buf[8];
b9e5796b
AM		 10355 if (!htab->opd_abi)
10356 return r2off;
aa374f67
AM		 10357 asection *opd = stub_entry->h->elf.root.u.def.section;
10358 bfd_vma opd_off = stub_entry->h->elf.root.u.def.value;
10359
10360 if (strcmp (opd->name, ".opd") != 0
10361 || opd->reloc_count != 0)
10362 {
bc30df16 10363 info->callbacks->einfo (_("%P: cannot find opd entry toc for `%T'\n"),
25f53a85 10364 stub_entry->h->elf.root.root.string);
aa374f67
AM		 10365 bfd_set_error (bfd_error_bad_value);
10366 return 0;
10367 }
10368 if (!bfd_get_section_contents (opd->owner, opd, buf, opd_off + 8, 8))
10369 return 0;
10370 r2off = bfd_get_64 (opd->owner, buf);
25f53a85 10371 r2off -= elf_gp (info->output_bfd);
aa374f67
AM		 10372 }
10373 r2off -= htab->stub_group[stub_entry->id_sec->id].toc_off;
10374 return r2off;
10375}
10376
b34976b6 10377static bfd_boolean
4ce794b7 10378ppc_build_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
5d1634d7 10379{
721956f4
AM		 10380 struct ppc_stub_hash_entry *stub_entry;
10381 struct ppc_branch_hash_entry *br_entry;
5d1634d7
AM		 10382 struct bfd_link_info *info;
10383 struct ppc_link_hash_table *htab;
721956f4
AM		 10384 bfd_byte *loc;
10385 bfd_byte *p;
ee75fd95 10386 bfd_vma dest, off;
721956f4 10387 int size;
176a0d42 10388 Elf_Internal_Rela *r;
e054468f 10389 asection *plt;
5d1634d7 10390
721956f4
AM		 10391 /* Massage our args to the form they really have. */
10392 stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
4ce794b7 10393 info = in_arg;
5d1634d7 10394
5d1634d7 10395 htab = ppc_hash_table (info);
4dfe6ac6
NC		 10396 if (htab == NULL)
10397 return FALSE;
5d1634d7 10398
721956f4 10399 /* Make a note of the offset within the stubs for this entry. */
eea6121a 10400 stub_entry->stub_offset = stub_entry->stub_sec->size;
97b639ba 10401 loc = stub_entry->stub_sec->contents + stub_entry->stub_offset;
721956f4 10402
4ce794b7 10403 htab->stub_count[stub_entry->stub_type - 1] += 1;
721956f4 10404 switch (stub_entry->stub_type)
5d1634d7 10405 {
721956f4 10406 case ppc_stub_long_branch:
ad8e1ba5 10407 case ppc_stub_long_branch_r2off:
721956f4 10408 /* Branches are relative. This is where we are going to. */
6911b7dc
AM		 10409 dest = (stub_entry->target_value
10410 + stub_entry->target_section->output_offset
10411 + stub_entry->target_section->output_section->vma);
10412 dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
10413 off = dest;
5d1634d7 10414
721956f4
AM		 10415 /* And this is where we are coming from. */
10416 off -= (stub_entry->stub_offset
97b639ba
AM		 10417 + stub_entry->stub_sec->output_offset
10418 + stub_entry->stub_sec->output_section->vma);
e86ce104 10419
ac2df442
AM		 10420 size = 4;
10421 if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
ad8e1ba5 10422 {
25f53a85 10423 bfd_vma r2off = get_r2off (info, stub_entry);
ad8e1ba5 10424
aa374f67
AM		 10425 if (r2off == 0)
10426 {
10427 htab->stub_error = TRUE;
10428 return FALSE;
10429 }
a078d95a 10430 bfd_put_32 (htab->stub_bfd, STD_R2_0R1 + STK_TOC (htab), loc);
ad8e1ba5 10431 loc += 4;
ac2df442
AM		 10432 size = 12;
10433 if (PPC_HA (r2off) != 0)
10434 {
10435 size = 16;
10436 bfd_put_32 (htab->stub_bfd, ADDIS_R2_R2 | PPC_HA (r2off), loc);
10437 loc += 4;
10438 }
97b639ba 10439 bfd_put_32 (htab->stub_bfd, ADDI_R2_R2 | PPC_LO (r2off), loc);
ad8e1ba5 10440 loc += 4;
ac2df442 10441 off -= size - 4;
ad8e1ba5 10442 }
97b639ba 10443 bfd_put_32 (htab->stub_bfd, B_DOT | (off & 0x3fffffc), loc);
ad8e1ba5 10444
5c3dead3
AM		 10445 if (off + (1 << 25) >= (bfd_vma) (1 << 26))
10446 {
bc30df16
AM		 10447 info->callbacks->einfo
10448 (_("%P: long branch stub `%s' offset overflow\n"),
10449 stub_entry->root.string);
5c3dead3
AM		 10450 htab->stub_error = TRUE;
10451 return FALSE;
10452 }
ee75fd95
AM		 10453
10454 if (info->emitrelocations)
10455 {
176a0d42
AM		 10456 r = get_relocs (stub_entry->stub_sec, 1);
10457 if (r == NULL)
10458 return FALSE;
ee75fd95
AM		 10459 r->r_offset = loc - stub_entry->stub_sec->contents;
10460 r->r_info = ELF64_R_INFO (0, R_PPC64_REL24);
10461 r->r_addend = dest;
10462 if (stub_entry->h != NULL)
10463 {
10464 struct elf_link_hash_entry **hashes;
10465 unsigned long symndx;
10466 struct ppc_link_hash_entry *h;
10467
10468 hashes = elf_sym_hashes (htab->stub_bfd);
10469 if (hashes == NULL)
10470 {
10471 bfd_size_type hsize;
10472
10473 hsize = (htab->stub_globals + 1) * sizeof (*hashes);
10474 hashes = bfd_zalloc (htab->stub_bfd, hsize);
10475 if (hashes == NULL)
10476 return FALSE;
10477 elf_sym_hashes (htab->stub_bfd) = hashes;
10478 htab->stub_globals = 1;
10479 }
10480 symndx = htab->stub_globals++;
10481 h = stub_entry->h;
10482 hashes[symndx] = &h->elf;
10483 r->r_info = ELF64_R_INFO (symndx, R_PPC64_REL24);
10484 if (h->oh != NULL && h->oh->is_func)
b31867b6 10485 h = ppc_follow_link (h->oh);
ee75fd95
AM		 10486 if (h->elf.root.u.def.section != stub_entry->target_section)
10487 /* H is an opd symbol. The addend must be zero. */
10488 r->r_addend = 0;
10489 else
10490 {
10491 off = (h->elf.root.u.def.value
10492 + h->elf.root.u.def.section->output_offset
10493 + h->elf.root.u.def.section->output_section->vma);
10494 r->r_addend -= off;
10495 }
10496 }
10497 }
721956f4 10498 break;
e86ce104 10499
721956f4 10500 case ppc_stub_plt_branch:
ad8e1ba5 10501 case ppc_stub_plt_branch_r2off:
721956f4
AM		 10502 br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
10503 stub_entry->root.string + 9,
b34976b6 10504 FALSE, FALSE);
721956f4
AM		 10505 if (br_entry == NULL)
10506 {
8de848d8 10507 info->callbacks->einfo (_("%P: can't find branch stub `%s'\n"),
25f53a85 10508 stub_entry->root.string);
b34976b6
AM		 10509 htab->stub_error = TRUE;
10510 return FALSE;
721956f4
AM		 10511 }
10512
176a0d42
AM		 10513 dest = (stub_entry->target_value
10514 + stub_entry->target_section->output_offset
10515 + stub_entry->target_section->output_section->vma);
6911b7dc
AM		 10516 if (stub_entry->stub_type != ppc_stub_plt_branch_r2off)
10517 dest += PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
721956f4 10518
176a0d42 10519 bfd_put_64 (htab->brlt->owner, dest,
4ce794b7 10520 htab->brlt->contents + br_entry->offset);
721956f4 10521
f94498ff 10522 if (br_entry->iter == htab->stub_iteration)
721956f4 10523 {
f94498ff 10524 br_entry->iter = 0;
84f5d08e 10525
f94498ff 10526 if (htab->relbrlt != NULL)
84f5d08e 10527 {
f94498ff
AM		 10528 /* Create a reloc for the branch lookup table entry. */
10529 Elf_Internal_Rela rela;
10530 bfd_byte *rl;
10531
10532 rela.r_offset = (br_entry->offset
10533 + htab->brlt->output_offset
10534 + htab->brlt->output_section->vma);
10535 rela.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
176a0d42 10536 rela.r_addend = dest;
f94498ff
AM		 10537
10538 rl = htab->relbrlt->contents;
10539 rl += (htab->relbrlt->reloc_count++
10540 * sizeof (Elf64_External_Rela));
10541 bfd_elf64_swap_reloca_out (htab->relbrlt->owner, &rela, rl);
10542 }
10543 else if (info->emitrelocations)
10544 {
176a0d42
AM		 10545 r = get_relocs (htab->brlt, 1);
10546 if (r == NULL)
10547 return FALSE;
10548 /* brlt, being SEC_LINKER_CREATED does not go through the
10549 normal reloc processing. Symbols and offsets are not
10550 translated from input file to output file form, so
10551 set up the offset per the output file. */
f94498ff
AM		 10552 r->r_offset = (br_entry->offset
10553 + htab->brlt->output_offset
10554 + htab->brlt->output_section->vma);
10555 r->r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
176a0d42 10556 r->r_addend = dest;
84f5d08e 10557 }
84f5d08e 10558 }
721956f4 10559
176a0d42
AM		 10560 dest = (br_entry->offset
10561 + htab->brlt->output_offset
10562 + htab->brlt->output_section->vma);
10563
10564 off = (dest
4ce794b7 10565 - elf_gp (htab->brlt->output_section->owner)
ad8e1ba5 10566 - htab->stub_group[stub_entry->id_sec->id].toc_off);
721956f4 10567
ad8e1ba5 10568 if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
5d1634d7 10569 {
25f53a85 10570 info->callbacks->einfo
bc30df16 10571 (_("%P: linkage table error against `%T'\n"),
721956f4 10572 stub_entry->root.string);
5d1634d7 10573 bfd_set_error (bfd_error_bad_value);
b34976b6
AM		 10574 htab->stub_error = TRUE;
10575 return FALSE;
5d1634d7 10576 }
41bd81ab 10577
176a0d42
AM		 10578 if (info->emitrelocations)
10579 {
10580 r = get_relocs (stub_entry->stub_sec, 1 + (PPC_HA (off) != 0));
10581 if (r == NULL)
10582 return FALSE;
10583 r[0].r_offset = loc - stub_entry->stub_sec->contents;
7cfbafbc
AM		 10584 if (bfd_big_endian (info->output_bfd))
10585 r[0].r_offset += 2;
b9e5796b
AM		 10586 if (stub_entry->stub_type == ppc_stub_plt_branch_r2off
10587 && htab->opd_abi)
176a0d42
AM		 10588 r[0].r_offset += 4;
10589 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_DS);
10590 r[0].r_addend = dest;
10591 if (PPC_HA (off) != 0)
10592 {
10593 r[0].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_HA);
10594 r[1].r_offset = r[0].r_offset + 4;
10595 r[1].r_info = ELF64_R_INFO (0, R_PPC64_TOC16_LO_DS);
10596 r[1].r_addend = r[0].r_addend;
10597 }
10598 }
10599
b9e5796b
AM		 10600 if (stub_entry->stub_type != ppc_stub_plt_branch_r2off
10601 || !htab->opd_abi)
ad8e1ba5 10602 {
176a0d42 10603 if (PPC_HA (off) != 0)
ac2df442
AM		 10604 {
10605 size = 16;
71a39c98 10606 bfd_put_32 (htab->stub_bfd, ADDIS_R11_R2 | PPC_HA (off), loc);
ac2df442 10607 loc += 4;
71a39c98 10608 bfd_put_32 (htab->stub_bfd, LD_R12_0R11 | PPC_LO (off), loc);
ac2df442
AM		 10609 }
10610 else
10611 {
10612 size = 12;
71a39c98 10613 bfd_put_32 (htab->stub_bfd, LD_R12_0R2 | PPC_LO (off), loc);
ac2df442 10614 }
ad8e1ba5
AM		 10615 }
10616 else
10617 {
25f53a85 10618 bfd_vma r2off = get_r2off (info, stub_entry);
aa374f67
AM		 10619
10620 if (r2off == 0)
10621 {
10622 htab->stub_error = TRUE;
10623 return FALSE;
10624 }
ad8e1ba5 10625
a078d95a 10626 bfd_put_32 (htab->stub_bfd, STD_R2_0R1 + STK_TOC (htab), loc);
ad8e1ba5 10627 loc += 4;
ac2df442 10628 size = 20;
176a0d42 10629 if (PPC_HA (off) != 0)
ac2df442
AM		 10630 {
10631 size += 4;
71a39c98 10632 bfd_put_32 (htab->stub_bfd, ADDIS_R11_R2 | PPC_HA (off), loc);
ac2df442 10633 loc += 4;
71a39c98 10634 bfd_put_32 (htab->stub_bfd, LD_R12_0R11 | PPC_LO (off), loc);
ac2df442
AM		 10635 loc += 4;
10636 }
10637 else
10638 {
71a39c98 10639 bfd_put_32 (htab->stub_bfd, LD_R12_0R2 | PPC_LO (off), loc);
ac2df442
AM		 10640 loc += 4;
10641 }
10642
10643 if (PPC_HA (r2off) != 0)
10644 {
10645 size += 4;
10646 bfd_put_32 (htab->stub_bfd, ADDIS_R2_R2 | PPC_HA (r2off), loc);
10647 loc += 4;
10648 }
97b639ba 10649 bfd_put_32 (htab->stub_bfd, ADDI_R2_R2 | PPC_LO (r2off), loc);
ad8e1ba5
AM		 10650 }
10651 loc += 4;
71a39c98 10652 bfd_put_32 (htab->stub_bfd, MTCTR_R12, loc);
ad8e1ba5 10653 loc += 4;
97b639ba 10654 bfd_put_32 (htab->stub_bfd, BCTR, loc);
721956f4 10655 break;
5d1634d7 10656
721956f4 10657 case ppc_stub_plt_call:
794e51c0 10658 case ppc_stub_plt_call_r2save:
e054468f 10659 if (stub_entry->h != NULL
b31867b6
AM		 10660 && stub_entry->h->is_func_descriptor
10661 && stub_entry->h->oh != NULL)
c862ae31 10662 {
b31867b6
AM		 10663 struct ppc_link_hash_entry *fh = ppc_follow_link (stub_entry->h->oh);
10664
10665 /* If the old-ABI "dot-symbol" is undefined make it weak so
10666 we don't get a link error from RELOC_FOR_GLOBAL_SYMBOL.
10667 FIXME: We used to define the symbol on one of the call
10668 stubs instead, which is why we test symbol section id
10669 against htab->top_id in various places. Likely all
10670 these checks could now disappear. */
10671 if (fh->elf.root.type == bfd_link_hash_undefined)
10672 fh->elf.root.type = bfd_link_hash_undefweak;
9507a174
AM		 10673 /* Stop undo_symbol_twiddle changing it back to undefined. */
10674 fh->was_undefined = 0;
c862ae31
AM		 10675 }
10676
721956f4 10677 /* Now build the stub. */
e054468f 10678 dest = stub_entry->plt_ent->plt.offset & ~1;
176a0d42 10679 if (dest >= (bfd_vma) -2)
721956f4
AM		 10680 abort ();
10681
33e44f2e 10682 plt = htab->elf.splt;
25f23106
AM		 10683 if (!htab->elf.dynamic_sections_created
10684 || stub_entry->h == NULL
10685 || stub_entry->h->elf.dynindx == -1)
33e44f2e 10686 plt = htab->elf.iplt;
e054468f
AM		 10687
10688 dest += plt->output_offset + plt->output_section->vma;
10689
10690 if (stub_entry->h == NULL
10691 && (stub_entry->plt_ent->plt.offset & 1) == 0)
10692 {
10693 Elf_Internal_Rela rela;
10694 bfd_byte *rl;
10695
10696 rela.r_offset = dest;
ee67d69a
AM		 10697 if (htab->opd_abi)
10698 rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
10699 else
10700 rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
e054468f
AM		 10701 rela.r_addend = (stub_entry->target_value
10702 + stub_entry->target_section->output_offset
10703 + stub_entry->target_section->output_section->vma);
10704
33e44f2e
AM		 10705 rl = (htab->elf.irelplt->contents
10706 + (htab->elf.irelplt->reloc_count++
25f23106
AM		 10707 * sizeof (Elf64_External_Rela)));
10708 bfd_elf64_swap_reloca_out (info->output_bfd, &rela, rl);
e054468f
AM		 10709 stub_entry->plt_ent->plt.offset |= 1;
10710 }
176a0d42
AM		 10711
10712 off = (dest
e054468f 10713 - elf_gp (plt->output_section->owner)
176a0d42 10714 - htab->stub_group[stub_entry->id_sec->id].toc_off);
721956f4 10715
ad8e1ba5 10716 if (off + 0x80008000 > 0xffffffff || (off & 7) != 0)
721956f4 10717 {
25f53a85 10718 info->callbacks->einfo
bc30df16 10719 (_("%P: linkage table error against `%T'\n"),
e054468f
AM		 10720 stub_entry->h != NULL
10721 ? stub_entry->h->elf.root.root.string
10722 : "<local sym>");
721956f4 10723 bfd_set_error (bfd_error_bad_value);
b34976b6
AM		 10724 htab->stub_error = TRUE;
10725 return FALSE;
721956f4
AM		 10726 }
10727
794e51c0
AM		 10728 if (htab->plt_stub_align != 0)
10729 {
10730 unsigned pad = plt_stub_pad (htab, stub_entry, off);
10731
10732 stub_entry->stub_sec->size += pad;
10733 stub_entry->stub_offset = stub_entry->stub_sec->size;
10734 loc += pad;
10735 }
10736
176a0d42
AM		 10737 r = NULL;
10738 if (info->emitrelocations)
10739 {
10740 r = get_relocs (stub_entry->stub_sec,
c7131b65
AM		 10741 (2
10742 + (PPC_HA (off) != 0)
10743 + (htab->plt_static_chain
10744 && PPC_HA (off + 16) == PPC_HA (off))));
176a0d42
AM		 10745 if (r == NULL)
10746 return FALSE;
10747 r[0].r_offset = loc - stub_entry->stub_sec->contents;
7cfbafbc
AM		 10748 if (bfd_big_endian (info->output_bfd))
10749 r[0].r_offset += 2;
176a0d42
AM		 10750 r[0].r_addend = dest;
10751 }
a7f2871e
AM		 10752 if (stub_entry->h != NULL
10753 && (stub_entry->h == htab->tls_get_addr_fd
10754 || stub_entry->h == htab->tls_get_addr)
10755 && !htab->no_tls_get_addr_opt)
794e51c0 10756 p = build_tls_get_addr_stub (htab, stub_entry, loc, off, r);
a7f2871e 10757 else
794e51c0 10758 p = build_plt_stub (htab, stub_entry, loc, off, r);
721956f4
AM		 10759 size = p - loc;
10760 break;
10761
10762 default:
10763 BFD_FAIL ();
b34976b6 10764 return FALSE;
721956f4
AM		 10765 }
10766
eea6121a 10767 stub_entry->stub_sec->size += size;
97b639ba 10768
ee75fd95 10769 if (htab->emit_stub_syms)
97b639ba
AM		 10770 {
10771 struct elf_link_hash_entry *h;
ee75fd95
AM		 10772 size_t len1, len2;
10773 char *name;
10774 const char *const stub_str[] = { "long_branch",
10775 "long_branch_r2off",
10776 "plt_branch",
10777 "plt_branch_r2off",
794e51c0 10778 "plt_call",
ee75fd95
AM		 10779 "plt_call" };
10780
10781 len1 = strlen (stub_str[stub_entry->stub_type - 1]);
10782 len2 = strlen (stub_entry->root.string);
10783 name = bfd_malloc (len1 + len2 + 2);
10784 if (name == NULL)
10785 return FALSE;
10786 memcpy (name, stub_entry->root.string, 9);
10787 memcpy (name + 9, stub_str[stub_entry->stub_type - 1], len1);
10788 memcpy (name + len1 + 9, stub_entry->root.string + 8, len2 - 8 + 1);
10789 h = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE);
97b639ba
AM		 10790 if (h == NULL)
10791 return FALSE;
10792 if (h->root.type == bfd_link_hash_new)
10793 {
10794 h->root.type = bfd_link_hash_defined;
10795 h->root.u.def.section = stub_entry->stub_sec;
10796 h->root.u.def.value = stub_entry->stub_offset;
f5385ebf
AM		 10797 h->ref_regular = 1;
10798 h->def_regular = 1;
10799 h->ref_regular_nonweak = 1;
10800 h->forced_local = 1;
10801 h->non_elf = 0;
97b639ba
AM		 10802 }
10803 }
10804
b34976b6 10805 return TRUE;
721956f4
AM		 10806}
10807
10808/* As above, but don't actually build the stub. Just bump offset so
10809 we know stub section sizes, and select plt_branch stubs where
10810 long_branch stubs won't do. */
10811
b34976b6 10812static bfd_boolean
4ce794b7 10813ppc_size_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
721956f4
AM		 10814{
10815 struct ppc_stub_hash_entry *stub_entry;
63bc6f6c 10816 struct bfd_link_info *info;
721956f4
AM		 10817 struct ppc_link_hash_table *htab;
10818 bfd_vma off;
10819 int size;
10820
10821 /* Massage our args to the form they really have. */
10822 stub_entry = (struct ppc_stub_hash_entry *) gen_entry;
63bc6f6c
AM		 10823 info = in_arg;
10824
10825 htab = ppc_hash_table (info);
4dfe6ac6
NC		 10826 if (htab == NULL)
10827 return FALSE;
721956f4 10828
794e51c0
AM		 10829 if (stub_entry->stub_type == ppc_stub_plt_call
10830 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
721956f4 10831 {
e054468f
AM		 10832 asection *plt;
10833 off = stub_entry->plt_ent->plt.offset & ~(bfd_vma) 1;
58ac9f71 10834 if (off >= (bfd_vma) -2)
411e1bfb 10835 abort ();
33e44f2e 10836 plt = htab->elf.splt;
25f23106
AM		 10837 if (!htab->elf.dynamic_sections_created
10838 || stub_entry->h == NULL
10839 || stub_entry->h->elf.dynindx == -1)
33e44f2e 10840 plt = htab->elf.iplt;
e054468f
AM		 10841 off += (plt->output_offset
10842 + plt->output_section->vma
10843 - elf_gp (plt->output_section->owner)
ad8e1ba5 10844 - htab->stub_group[stub_entry->id_sec->id].toc_off);
721956f4 10845
794e51c0
AM		 10846 size = plt_stub_size (htab, stub_entry, off);
10847 if (htab->plt_stub_align)
10848 size += plt_stub_pad (htab, stub_entry, off);
176a0d42
AM		 10849 if (info->emitrelocations)
10850 {
10851 stub_entry->stub_sec->reloc_count
b9e5796b
AM		 10852 += ((PPC_HA (off) != 0)
10853 + (htab->opd_abi
10854 ? 2 + (htab->plt_static_chain
10855 && PPC_HA (off + 16) == PPC_HA (off))
10856 : 1));
176a0d42
AM		 10857 stub_entry->stub_sec->flags |= SEC_RELOC;
10858 }
721956f4
AM		 10859 }
10860 else
10861 {
ad8e1ba5
AM		 10862 /* ppc_stub_long_branch or ppc_stub_plt_branch, or their r2off
10863 variants. */
ac2df442 10864 bfd_vma r2off = 0;
6911b7dc 10865 bfd_vma local_off = 0;
ac2df442 10866
721956f4
AM		 10867 off = (stub_entry->target_value
10868 + stub_entry->target_section->output_offset
10869 + stub_entry->target_section->output_section->vma);
eea6121a 10870 off -= (stub_entry->stub_sec->size
721956f4
AM		 10871 + stub_entry->stub_sec->output_offset
10872 + stub_entry->stub_sec->output_section->vma);
10873
ad8e1ba5
AM		 10874 /* Reset the stub type from the plt variant in case we now
10875 can reach with a shorter stub. */
10876 if (stub_entry->stub_type >= ppc_stub_plt_branch)
10877 stub_entry->stub_type += ppc_stub_long_branch - ppc_stub_plt_branch;
10878
10879 size = 4;
10880 if (stub_entry->stub_type == ppc_stub_long_branch_r2off)
10881 {
25f53a85 10882 r2off = get_r2off (info, stub_entry);
b9e5796b 10883 if (r2off == 0 && htab->opd_abi)
aa374f67
AM		 10884 {
10885 htab->stub_error = TRUE;
10886 return FALSE;
10887 }
ac2df442
AM		 10888 size = 12;
10889 if (PPC_HA (r2off) != 0)
10890 size = 16;
10891 off -= size - 4;
ad8e1ba5
AM		 10892 }
10893
6911b7dc
AM		 10894 local_off = PPC64_LOCAL_ENTRY_OFFSET (stub_entry->other);
10895
b9e5796b
AM		 10896 /* If the branch offset if too big, use a ppc_stub_plt_branch.
10897 Do the same for -R objects without function descriptors. */
10898 if (off + (1 << 25) >= (bfd_vma) (1 << 26) - local_off
10899 || (stub_entry->stub_type == ppc_stub_long_branch_r2off
10900 && r2off == 0))
721956f4
AM		 10901 {
10902 struct ppc_branch_hash_entry *br_entry;
10903
10904 br_entry = ppc_branch_hash_lookup (&htab->branch_hash_table,
10905 stub_entry->root.string + 9,
b34976b6 10906 TRUE, FALSE);
721956f4
AM		 10907 if (br_entry == NULL)
10908 {
8de848d8 10909 info->callbacks->einfo (_("%P: can't build branch stub `%s'\n"),
25f53a85 10910 stub_entry->root.string);
b34976b6
AM		 10911 htab->stub_error = TRUE;
10912 return FALSE;
721956f4
AM		 10913 }
10914
10915 if (br_entry->iter != htab->stub_iteration)
10916 {
10917 br_entry->iter = htab->stub_iteration;
eea6121a
AM		 10918 br_entry->offset = htab->brlt->size;
10919 htab->brlt->size += 8;
63bc6f6c 10920
ee75fd95 10921 if (htab->relbrlt != NULL)
eea6121a 10922 htab->relbrlt->size += sizeof (Elf64_External_Rela);
84f5d08e
AM		 10923 else if (info->emitrelocations)
10924 {
10925 htab->brlt->reloc_count += 1;
10926 htab->brlt->flags |= SEC_RELOC;
10927 }
721956f4 10928 }
ad8e1ba5
AM		 10929
10930 stub_entry->stub_type += ppc_stub_plt_branch - ppc_stub_long_branch;
ac2df442
AM		 10931 off = (br_entry->offset
10932 + htab->brlt->output_offset
10933 + htab->brlt->output_section->vma
10934 - elf_gp (htab->brlt->output_section->owner)
10935 - htab->stub_group[stub_entry->id_sec->id].toc_off);
10936
176a0d42
AM		 10937 if (info->emitrelocations)
10938 {
10939 stub_entry->stub_sec->reloc_count += 1 + (PPC_HA (off) != 0);
10940 stub_entry->stub_sec->flags |= SEC_RELOC;
10941 }
10942
b9e5796b
AM		 10943 if (stub_entry->stub_type != ppc_stub_plt_branch_r2off
10944 || !htab->opd_abi)
ac2df442
AM		 10945 {
10946 size = 12;
176a0d42 10947 if (PPC_HA (off) != 0)
ac2df442
AM		 10948 size = 16;
10949 }
10950 else
10951 {
10952 size = 20;
176a0d42 10953 if (PPC_HA (off) != 0)
ac2df442
AM		 10954 size += 4;
10955
10956 if (PPC_HA (r2off) != 0)
10957 size += 4;
10958 }
721956f4 10959 }
84f5d08e
AM		 10960 else if (info->emitrelocations)
10961 {
10962 stub_entry->stub_sec->reloc_count += 1;
10963 stub_entry->stub_sec->flags |= SEC_RELOC;
10964 }
721956f4
AM		 10965 }
10966
eea6121a 10967 stub_entry->stub_sec->size += size;
b34976b6 10968 return TRUE;
721956f4
AM		 10969}
10970
10971/* Set up various things so that we can make a list of input sections
10972 for each output section included in the link. Returns -1 on error,
cedb70c5 10973 0 when no stubs will be needed, and 1 on success. */
721956f4
AM		 10974
10975int
927be08e
AM		 10976ppc64_elf_setup_section_lists
10977 (struct bfd_link_info *info,
10978 asection *(*add_stub_section) (const char *, asection *),
10979 void (*layout_sections_again) (void))
721956f4
AM		 10980{
10981 bfd *input_bfd;
734b6cf9 10982 int top_id, top_index, id;
721956f4 10983 asection *section;
734b6cf9 10984 asection **input_list;
721956f4
AM		 10985 bfd_size_type amt;
10986 struct ppc_link_hash_table *htab = ppc_hash_table (info);
10987
4dfe6ac6
NC		 10988 if (htab == NULL)
10989 return -1;
927be08e
AM		 10990 /* Stash our params away. */
10991 htab->add_stub_section = add_stub_section;
10992 htab->layout_sections_again = layout_sections_again;
4c52953f 10993
1e2f5b6e 10994 /* Find the top input section id. */
3d6f9012 10995 for (input_bfd = info->input_bfds, top_id = 3;
721956f4
AM		 10996 input_bfd != NULL;
10997 input_bfd = input_bfd->link_next)
10998 {
721956f4
AM		 10999 for (section = input_bfd->sections;
11000 section != NULL;
11001 section = section->next)
11002 {
11003 if (top_id < section->id)
11004 top_id = section->id;
11005 }
11006 }
721956f4 11007
8f3bab57 11008 htab->top_id = top_id;
721956f4 11009 amt = sizeof (struct map_stub) * (top_id + 1);
4ce794b7 11010 htab->stub_group = bfd_zmalloc (amt);
721956f4
AM		 11011 if (htab->stub_group == NULL)
11012 return -1;
11013
3d6f9012
AM		 11014 /* Set toc_off for com, und, abs and ind sections. */
11015 for (id = 0; id < 3; id++)
11016 htab->stub_group[id].toc_off = TOC_BASE_OFF;
721956f4 11017
734b6cf9
AM		 11018 /* We can't use output_bfd->section_count here to find the top output
11019 section index as some sections may have been removed, and
8423293d 11020 strip_excluded_output_sections doesn't renumber the indices. */
927be08e 11021 for (section = info->output_bfd->sections, top_index = 0;
734b6cf9
AM		 11022 section != NULL;
11023 section = section->next)
11024 {
11025 if (top_index < section->index)
11026 top_index = section->index;
11027 }
11028
11029 htab->top_index = top_index;
11030 amt = sizeof (asection *) * (top_index + 1);
4ce794b7 11031 input_list = bfd_zmalloc (amt);
734b6cf9
AM		 11032 htab->input_list = input_list;
11033 if (input_list == NULL)
11034 return -1;
11035
721956f4
AM		 11036 return 1;
11037}
11038
927be08e
AM		 11039/* Set up for first pass at multitoc partitioning. */
11040
11041void
11042ppc64_elf_start_multitoc_partition (struct bfd_link_info *info)
11043{
11044 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11045
1c865ab2 11046 htab->toc_curr = ppc64_elf_set_toc (info, info->output_bfd);
927be08e
AM		 11047 htab->toc_bfd = NULL;
11048 htab->toc_first_sec = NULL;
11049}
11050
e717da7e
AM		 11051/* The linker repeatedly calls this function for each TOC input section
11052 and linker generated GOT section. Group input bfds such that the toc
927be08e 11053 within a group is less than 64k in size. */
ad8e1ba5 11054
927be08e 11055bfd_boolean
4ce794b7 11056ppc64_elf_next_toc_section (struct bfd_link_info *info, asection *isec)
ad8e1ba5
AM		 11057{
11058 struct ppc_link_hash_table *htab = ppc_hash_table (info);
d77c8a4b 11059 bfd_vma addr, off, limit;
ad8e1ba5 11060
4dfe6ac6
NC		 11061 if (htab == NULL)
11062 return FALSE;
11063
927be08e 11064 if (!htab->second_toc_pass)
4c52953f 11065 {
927be08e 11066 /* Keep track of the first .toc or .got section for this input bfd. */
a4fd3de5
AM		 11067 bfd_boolean new_bfd = htab->toc_bfd != isec->owner;
11068
11069 if (new_bfd)
bf102f86
AM		 11070 {
11071 htab->toc_bfd = isec->owner;
11072 htab->toc_first_sec = isec;
11073 }
927be08e 11074
bf102f86
AM		 11075 addr = isec->output_offset + isec->output_section->vma;
11076 off = addr - htab->toc_curr;
d77c8a4b
AM		 11077 limit = 0x80008000;
11078 if (ppc64_elf_tdata (isec->owner)->has_small_toc_reloc)
11079 limit = 0x10000;
11080 if (off + isec->size > limit)
bf102f86
AM		 11081 {
11082 addr = (htab->toc_first_sec->output_offset
11083 + htab->toc_first_sec->output_section->vma);
11084 htab->toc_curr = addr;
11085 }
99877b66 11086
927be08e
AM		 11087 /* toc_curr is the base address of this toc group. Set elf_gp
11088 for the input section to be the offset relative to the
11089 output toc base plus 0x8000. Making the input elf_gp an
11090 offset allows us to move the toc as a whole without
11091 recalculating input elf_gp. */
11092 off = htab->toc_curr - elf_gp (isec->output_section->owner);
11093 off += TOC_BASE_OFF;
11094
11095 /* Die if someone uses a linker script that doesn't keep input
11096 file .toc and .got together. */
a4fd3de5
AM		 11097 if (new_bfd
11098 && elf_gp (isec->owner) != 0
927be08e
AM		 11099 && elf_gp (isec->owner) != off)
11100 return FALSE;
11101
11102 elf_gp (isec->owner) = off;
11103 return TRUE;
4c52953f 11104 }
927be08e
AM		 11105
11106 /* During the second pass toc_first_sec points to the start of
11107 a toc group, and toc_curr is used to track the old elf_gp.
11108 We use toc_bfd to ensure we only look at each bfd once. */
11109 if (htab->toc_bfd == isec->owner)
11110 return TRUE;
11111 htab->toc_bfd = isec->owner;
11112
11113 if (htab->toc_first_sec == NULL
11114 || htab->toc_curr != elf_gp (isec->owner))
11115 {
11116 htab->toc_curr = elf_gp (isec->owner);
11117 htab->toc_first_sec = isec;
11118 }
11119 addr = (htab->toc_first_sec->output_offset
11120 + htab->toc_first_sec->output_section->vma);
11121 off = addr - elf_gp (isec->output_section->owner) + TOC_BASE_OFF;
11122 elf_gp (isec->owner) = off;
11123
11124 return TRUE;
ad8e1ba5
AM		 11125}
11126
927be08e
AM		 11127/* Called via elf_link_hash_traverse to merge GOT entries for global
11128 symbol H. */
11129
11130static bfd_boolean
11131merge_global_got (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
11132{
11133 if (h->root.type == bfd_link_hash_indirect)
11134 return TRUE;
11135
927be08e
AM		 11136 merge_got_entries (&h->got.glist);
11137
11138 return TRUE;
11139}
11140
11141/* Called via elf_link_hash_traverse to allocate GOT entries for global
11142 symbol H. */
11143
11144static bfd_boolean
11145reallocate_got (struct elf_link_hash_entry *h, void *inf)
11146{
11147 struct got_entry *gent;
11148
11149 if (h->root.type == bfd_link_hash_indirect)
11150 return TRUE;
11151
927be08e
AM		 11152 for (gent = h->got.glist; gent != NULL; gent = gent->next)
11153 if (!gent->is_indirect)
11154 allocate_got (h, (struct bfd_link_info *) inf, gent);
11155 return TRUE;
11156}
11157
11158/* Called on the first multitoc pass after the last call to
11159 ppc64_elf_next_toc_section. This function removes duplicate GOT
11160 entries. */
11161
11162bfd_boolean
11163ppc64_elf_layout_multitoc (struct bfd_link_info *info)
ad8e1ba5
AM		 11164{
11165 struct ppc_link_hash_table *htab = ppc_hash_table (info);
927be08e
AM		 11166 struct bfd *ibfd, *ibfd2;
11167 bfd_boolean done_something;
11168
11169 htab->multi_toc_needed = htab->toc_curr != elf_gp (info->output_bfd);
ad8e1ba5 11170
7865406b
AM		 11171 if (!htab->do_multi_toc)
11172 return FALSE;
11173
d0fae19d 11174 /* Merge global sym got entries within a toc group. */
927be08e
AM		 11175 elf_link_hash_traverse (&htab->elf, merge_global_got, info);
11176
11177 /* And tlsld_got. */
11178 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
11179 {
11180 struct got_entry *ent, *ent2;
11181
11182 if (!is_ppc64_elf (ibfd))
11183 continue;
11184
11185 ent = ppc64_tlsld_got (ibfd);
11186 if (!ent->is_indirect
11187 && ent->got.offset != (bfd_vma) -1)
11188 {
11189 for (ibfd2 = ibfd->link_next; ibfd2 != NULL; ibfd2 = ibfd2->link_next)
11190 {
11191 if (!is_ppc64_elf (ibfd2))
11192 continue;
11193
11194 ent2 = ppc64_tlsld_got (ibfd2);
11195 if (!ent2->is_indirect
11196 && ent2->got.offset != (bfd_vma) -1
11197 && elf_gp (ibfd2) == elf_gp (ibfd))
11198 {
11199 ent2->is_indirect = TRUE;
11200 ent2->got.ent = ent;
11201 }
11202 }
11203 }
11204 }
11205
11206 /* Zap sizes of got sections. */
33e44f2e
AM		 11207 htab->elf.irelplt->rawsize = htab->elf.irelplt->size;
11208 htab->elf.irelplt->size -= htab->got_reli_size;
927be08e
AM		 11209 htab->got_reli_size = 0;
11210
11211 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
11212 {
11213 asection *got, *relgot;
11214
11215 if (!is_ppc64_elf (ibfd))
11216 continue;
11217
11218 got = ppc64_elf_tdata (ibfd)->got;
11219 if (got != NULL)
11220 {
11221 got->rawsize = got->size;
11222 got->size = 0;
11223 relgot = ppc64_elf_tdata (ibfd)->relgot;
11224 relgot->rawsize = relgot->size;
11225 relgot->size = 0;
11226 }
11227 }
11228
11229 /* Now reallocate the got, local syms first. We don't need to
11230 allocate section contents again since we never increase size. */
11231 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
11232 {
11233 struct got_entry **lgot_ents;
11234 struct got_entry **end_lgot_ents;
11235 struct plt_entry **local_plt;
11236 struct plt_entry **end_local_plt;
f961d9dd 11237 unsigned char *lgot_masks;
927be08e
AM		 11238 bfd_size_type locsymcount;
11239 Elf_Internal_Shdr *symtab_hdr;
19e08130 11240 asection *s;
927be08e
AM		 11241
11242 if (!is_ppc64_elf (ibfd))
11243 continue;
11244
11245 lgot_ents = elf_local_got_ents (ibfd);
11246 if (!lgot_ents)
11247 continue;
11248
11249 symtab_hdr = &elf_symtab_hdr (ibfd);
11250 locsymcount = symtab_hdr->sh_info;
11251 end_lgot_ents = lgot_ents + locsymcount;
11252 local_plt = (struct plt_entry **) end_lgot_ents;
11253 end_local_plt = local_plt + locsymcount;
f961d9dd 11254 lgot_masks = (unsigned char *) end_local_plt;
927be08e 11255 s = ppc64_elf_tdata (ibfd)->got;
927be08e
AM		 11256 for (; lgot_ents < end_lgot_ents; ++lgot_ents, ++lgot_masks)
11257 {
11258 struct got_entry *ent;
11259
11260 for (ent = *lgot_ents; ent != NULL; ent = ent->next)
d0fae19d 11261 {
19e08130
AM		 11262 unsigned int ent_size = 8;
11263 unsigned int rel_size = sizeof (Elf64_External_Rela);
11264
d0fae19d
AM		 11265 ent->got.offset = s->size;
11266 if ((ent->tls_type & *lgot_masks & TLS_GD) != 0)
d0fae19d 11267 {
19e08130
AM		 11268 ent_size *= 2;
11269 rel_size *= 2;
11270 }
11271 s->size += ent_size;
11272 if ((*lgot_masks & PLT_IFUNC) != 0)
11273 {
33e44f2e 11274 htab->elf.irelplt->size += rel_size;
19e08130
AM		 11275 htab->got_reli_size += rel_size;
11276 }
11277 else if (info->shared)
11278 {
11279 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
11280 srel->size += rel_size;
d0fae19d
AM		 11281 }
11282 }
927be08e
AM		 11283 }
11284 }
11285
11286 elf_link_hash_traverse (&htab->elf, reallocate_got, info);
11287
11288 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
11289 {
11290 struct got_entry *ent;
11291
11292 if (!is_ppc64_elf (ibfd))
11293 continue;
11294
11295 ent = ppc64_tlsld_got (ibfd);
11296 if (!ent->is_indirect
11297 && ent->got.offset != (bfd_vma) -1)
11298 {
11299 asection *s = ppc64_elf_tdata (ibfd)->got;
11300 ent->got.offset = s->size;
11301 s->size += 16;
11302 if (info->shared)
11303 {
11304 asection *srel = ppc64_elf_tdata (ibfd)->relgot;
11305 srel->size += sizeof (Elf64_External_Rela);
11306 }
11307 }
11308 }
11309
33e44f2e 11310 done_something = htab->elf.irelplt->rawsize != htab->elf.irelplt->size;
927be08e
AM		 11311 if (!done_something)
11312 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
11313 {
11314 asection *got;
11315
11316 if (!is_ppc64_elf (ibfd))
11317 continue;
11318
11319 got = ppc64_elf_tdata (ibfd)->got;
11320 if (got != NULL)
11321 {
11322 done_something = got->rawsize != got->size;
11323 if (done_something)
11324 break;
11325 }
11326 }
11327
11328 if (done_something)
11329 (*htab->layout_sections_again) ();
11330
11331 /* Set up for second pass over toc sections to recalculate elf_gp
11332 on input sections. */
11333 htab->toc_bfd = NULL;
11334 htab->toc_first_sec = NULL;
11335 htab->second_toc_pass = TRUE;
11336 return done_something;
11337}
11338
11339/* Called after second pass of multitoc partitioning. */
11340
11341void
11342ppc64_elf_finish_multitoc_partition (struct bfd_link_info *info)
11343{
11344 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11345
11346 /* After the second pass, toc_curr tracks the TOC offset used
11347 for code sections below in ppc64_elf_next_input_section. */
3d6f9012 11348 htab->toc_curr = TOC_BASE_OFF;
ad8e1ba5
AM		 11349}
11350
9b5ecbd0
AM		 11351/* No toc references were found in ISEC. If the code in ISEC makes no
11352 calls, then there's no need to use toc adjusting stubs when branching
11353 into ISEC. Actually, indirect calls from ISEC are OK as they will
4c52953f
AM		 11354 load r2. Returns -1 on error, 0 for no stub needed, 1 for stub
11355 needed, and 2 if a cyclical call-graph was found but no other reason
11356 for a stub was detected. If called from the top level, a return of
11357 2 means the same as a return of 0. */
9b5ecbd0
AM		 11358
11359static int
4ce794b7 11360toc_adjusting_stub_needed (struct bfd_link_info *info, asection *isec)
9b5ecbd0 11361{
9b5ecbd0 11362 int ret;
70cc837d
AM		 11363
11364 /* Mark this section as checked. */
11365 isec->call_check_done = 1;
9b5ecbd0 11366
772119ce
AM		 11367 /* We know none of our code bearing sections will need toc stubs. */
11368 if ((isec->flags & SEC_LINKER_CREATED) != 0)
11369 return 0;
11370
eea6121a 11371 if (isec->size == 0)
082c50f8
AM		 11372 return 0;
11373
4c52953f
AM		 11374 if (isec->output_section == NULL)
11375 return 0;
11376
4c52953f 11377 ret = 0;
70cc837d 11378 if (isec->reloc_count != 0)
9b5ecbd0 11379 {
70cc837d
AM		 11380 Elf_Internal_Rela *relstart, *rel;
11381 Elf_Internal_Sym *local_syms;
11382 struct ppc_link_hash_table *htab;
2917689a 11383
70cc837d
AM		 11384 relstart = _bfd_elf_link_read_relocs (isec->owner, isec, NULL, NULL,
11385 info->keep_memory);
11386 if (relstart == NULL)
11387 return -1;
90aecf7a 11388
70cc837d
AM		 11389 /* Look for branches to outside of this section. */
11390 local_syms = NULL;
11391 htab = ppc_hash_table (info);
11392 if (htab == NULL)
11393 return -1;
4c52953f 11394
70cc837d 11395 for (rel = relstart; rel < relstart + isec->reloc_count; ++rel)
4c52953f 11396 {
70cc837d
AM		 11397 enum elf_ppc64_reloc_type r_type;
11398 unsigned long r_symndx;
11399 struct elf_link_hash_entry *h;
11400 struct ppc_link_hash_entry *eh;
11401 Elf_Internal_Sym *sym;
11402 asection *sym_sec;
11403 struct _opd_sec_data *opd;
11404 bfd_vma sym_value;
11405 bfd_vma dest;
11406
11407 r_type = ELF64_R_TYPE (rel->r_info);
11408 if (r_type != R_PPC64_REL24
11409 && r_type != R_PPC64_REL14
11410 && r_type != R_PPC64_REL14_BRTAKEN
11411 && r_type != R_PPC64_REL14_BRNTAKEN)
11412 continue;
4c52953f 11413
70cc837d
AM		 11414 r_symndx = ELF64_R_SYM (rel->r_info);
11415 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms, r_symndx,
11416 isec->owner))
4c52953f 11417 {
70cc837d
AM		 11418 ret = -1;
11419 break;
11420 }
4c52953f 11421
70cc837d
AM		 11422 /* Calls to dynamic lib functions go through a plt call stub
11423 that uses r2. */
11424 eh = (struct ppc_link_hash_entry *) h;
11425 if (eh != NULL
11426 && (eh->elf.plt.plist != NULL
11427 || (eh->oh != NULL
11428 && ppc_follow_link (eh->oh)->elf.plt.plist != NULL)))
11429 {
11430 ret = 1;
11431 break;
4c52953f
AM		 11432 }
11433
70cc837d
AM		 11434 if (sym_sec == NULL)
11435 /* Ignore other undefined symbols. */
4c52953f 11436 continue;
4c52953f 11437
70cc837d
AM		 11438 /* Assume branches to other sections not included in the
11439 link need stubs too, to cover -R and absolute syms. */
11440 if (sym_sec->output_section == NULL)
11441 {
11442 ret = 1;
11443 break;
11444 }
4c52953f 11445
70cc837d
AM		 11446 if (h == NULL)
11447 sym_value = sym->st_value;
11448 else
11449 {
11450 if (h->root.type != bfd_link_hash_defined
11451 && h->root.type != bfd_link_hash_defweak)
11452 abort ();
11453 sym_value = h->root.u.def.value;
11454 }
11455 sym_value += rel->r_addend;
4c52953f 11456
70cc837d
AM		 11457 /* If this branch reloc uses an opd sym, find the code section. */
11458 opd = get_opd_info (sym_sec);
11459 if (opd != NULL)
11460 {
11461 if (h == NULL && opd->adjust != NULL)
11462 {
11463 long adjust;
4c52953f 11464
70cc837d
AM		 11465 adjust = opd->adjust[sym->st_value / 8];
11466 if (adjust == -1)
11467 /* Assume deleted functions won't ever be called. */
11468 continue;
11469 sym_value += adjust;
11470 }
4c52953f 11471
aef36ac1
AM		 11472 dest = opd_entry_value (sym_sec, sym_value,
11473 &sym_sec, NULL, FALSE);
70cc837d
AM		 11474 if (dest == (bfd_vma) -1)
11475 continue;
11476 }
11477 else
11478 dest = (sym_value
11479 + sym_sec->output_offset
11480 + sym_sec->output_section->vma);
4c52953f 11481
70cc837d
AM		 11482 /* Ignore branch to self. */
11483 if (sym_sec == isec)
11484 continue;
4c52953f 11485
70cc837d
AM		 11486 /* If the called function uses the toc, we need a stub. */
11487 if (sym_sec->has_toc_reloc
11488 || sym_sec->makes_toc_func_call)
4c52953f 11489 {
70cc837d 11490 ret = 1;
4c52953f
AM		 11491 break;
11492 }
70cc837d
AM		 11493
11494 /* Assume any branch that needs a long branch stub might in fact
11495 need a plt_branch stub. A plt_branch stub uses r2. */
11496 else if (dest - (isec->output_offset
11497 + isec->output_section->vma
6911b7dc
AM		 11498 + rel->r_offset) + (1 << 25)
11499 >= (2u << 25) - PPC64_LOCAL_ENTRY_OFFSET (h
11500 ? h->other
11501 : sym->st_other))
4c52953f 11502 {
70cc837d
AM		 11503 ret = 1;
11504 break;
11505 }
11506
11507 /* If calling back to a section in the process of being
11508 tested, we can't say for sure that no toc adjusting stubs
11509 are needed, so don't return zero. */
11510 else if (sym_sec->call_check_in_progress)
11511 ret = 2;
11512
11513 /* Branches to another section that itself doesn't have any TOC
11514 references are OK. Recursively call ourselves to check. */
11515 else if (!sym_sec->call_check_done)
11516 {
11517 int recur;
11518
11519 /* Mark current section as indeterminate, so that other
11520 sections that call back to current won't be marked as
11521 known. */
11522 isec->call_check_in_progress = 1;
11523 recur = toc_adjusting_stub_needed (info, sym_sec);
11524 isec->call_check_in_progress = 0;
11525
4c52953f
AM		 11526 if (recur != 0)
11527 {
70cc837d
AM		 11528 ret = recur;
11529 if (recur != 2)
11530 break;
4c52953f
AM		 11531 }
11532 }
4c52953f 11533 }
70cc837d
AM		 11534
11535 if (local_syms != NULL
11536 && (elf_symtab_hdr (isec->owner).contents
11537 != (unsigned char *) local_syms))
11538 free (local_syms);
11539 if (elf_section_data (isec)->relocs != relstart)
11540 free (relstart);
9b5ecbd0
AM		 11541 }
11542
70cc837d
AM		 11543 if ((ret & 1) == 0
11544 && isec->map_head.s != NULL
11545 && (strcmp (isec->output_section->name, ".init") == 0
11546 || strcmp (isec->output_section->name, ".fini") == 0))
11547 {
11548 if (isec->map_head.s->has_toc_reloc
11549 || isec->map_head.s->makes_toc_func_call)
11550 ret = 1;
11551 else if (!isec->map_head.s->call_check_done)
11552 {
11553 int recur;
11554 isec->call_check_in_progress = 1;
11555 recur = toc_adjusting_stub_needed (info, isec->map_head.s);
11556 isec->call_check_in_progress = 0;
11557 if (recur != 0)
11558 ret = recur;
11559 }
11560 }
11561
11562 if (ret == 1)
11563 isec->makes_toc_func_call = 1;
4c52953f 11564
9b5ecbd0
AM		 11565 return ret;
11566}
11567
721956f4
AM		 11568/* The linker repeatedly calls this function for each input section,
11569 in the order that input sections are linked into output sections.
11570 Build lists of input sections to determine groupings between which
11571 we may insert linker stubs. */
11572
9b5ecbd0 11573bfd_boolean
4ce794b7 11574ppc64_elf_next_input_section (struct bfd_link_info *info, asection *isec)
721956f4
AM		 11575{
11576 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11577
4dfe6ac6
NC		 11578 if (htab == NULL)
11579 return FALSE;
11580
734b6cf9
AM		 11581 if ((isec->output_section->flags & SEC_CODE) != 0
11582 && isec->output_section->index <= htab->top_index)
721956f4 11583 {
734b6cf9 11584 asection **list = htab->input_list + isec->output_section->index;
3d6f9012 11585 /* Steal the link_sec pointer for our list. */
721956f4 11586#define PREV_SEC(sec) (htab->stub_group[(sec)->id].link_sec)
3d6f9012
AM		 11587 /* This happens to make the list in reverse order,
11588 which is what we want. */
734b6cf9
AM		 11589 PREV_SEC (isec) = *list;
11590 *list = isec;
721956f4 11591 }
ad8e1ba5 11592
4c52953f 11593 if (htab->multi_toc_needed)
9b5ecbd0 11594 {
8b974ba3
AM		 11595 /* Analyse sections that aren't already flagged as needing a
11596 valid toc pointer. Exclude .fixup for the linux kernel.
11597 .fixup contains branches, but only back to the function that
11598 hit an exception. */
11599 if (!(isec->has_toc_reloc
11600 || (isec->flags & SEC_CODE) == 0
11601 || strcmp (isec->name, ".fixup") == 0
11602 || isec->call_check_done))
11603 {
11604 if (toc_adjusting_stub_needed (info, isec) < 0)
6683a28d 11605 return FALSE;
8b974ba3
AM		 11606 }
11607 /* Make all sections use the TOC assigned for this object file.
11608 This will be wrong for pasted sections; We fix that in
11609 check_pasted_section(). */
11610 if (elf_gp (isec->owner) != 0)
11611 htab->toc_curr = elf_gp (isec->owner);
11612 }
11613
ad8e1ba5 11614 htab->stub_group[isec->id].toc_off = htab->toc_curr;
9b5ecbd0 11615 return TRUE;
721956f4
AM		 11616}
11617
70cc837d
AM		 11618/* Check that all .init and .fini sections use the same toc, if they
11619 have toc relocs. */
11620
11621static bfd_boolean
11622check_pasted_section (struct bfd_link_info *info, const char *name)
11623{
11624 asection *o = bfd_get_section_by_name (info->output_bfd, name);
11625
11626 if (o != NULL)
11627 {
11628 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11629 bfd_vma toc_off = 0;
11630 asection *i;
11631
11632 for (i = o->map_head.s; i != NULL; i = i->map_head.s)
11633 if (i->has_toc_reloc)
11634 {
11635 if (toc_off == 0)
11636 toc_off = htab->stub_group[i->id].toc_off;
11637 else if (toc_off != htab->stub_group[i->id].toc_off)
11638 return FALSE;
11639 }
6683a28d
AM		 11640
11641 if (toc_off == 0)
11642 for (i = o->map_head.s; i != NULL; i = i->map_head.s)
11643 if (i->makes_toc_func_call)
11644 {
11645 toc_off = htab->stub_group[i->id].toc_off;
11646 break;
11647 }
11648
70cc837d
AM		 11649 /* Make sure the whole pasted function uses the same toc offset. */
11650 if (toc_off != 0)
11651 for (i = o->map_head.s; i != NULL; i = i->map_head.s)
11652 htab->stub_group[i->id].toc_off = toc_off;
11653 }
11654 return TRUE;
11655}
11656
11657bfd_boolean
11658ppc64_elf_check_init_fini (struct bfd_link_info *info)
11659{
11660 return (check_pasted_section (info, ".init")
11661 & check_pasted_section (info, ".fini"));
11662}
11663
721956f4
AM		 11664/* See whether we can group stub sections together. Grouping stub
11665 sections may result in fewer stubs. More importantly, we need to
11666 put all .init* and .fini* stubs at the beginning of the .init or
11667 .fini output sections respectively, because glibc splits the
11668 _init and _fini functions into multiple parts. Putting a stub in
11669 the middle of a function is not a good idea. */
11670
11671static void
4ce794b7
AM		 11672group_sections (struct ppc_link_hash_table *htab,
11673 bfd_size_type stub_group_size,
11674 bfd_boolean stubs_always_before_branch)
721956f4 11675{
7c8fe5c4
AM		 11676 asection **list;
11677 bfd_size_type stub14_group_size;
11678 bfd_boolean suppress_size_errors;
11679
11680 suppress_size_errors = FALSE;
11681 stub14_group_size = stub_group_size;
11682 if (stub_group_size == 1)
11683 {
11684 /* Default values. */
11685 if (stubs_always_before_branch)
11686 {
11687 stub_group_size = 0x1e00000;
11688 stub14_group_size = 0x7800;
11689 }
11690 else
11691 {
11692 stub_group_size = 0x1c00000;
11693 stub14_group_size = 0x7000;
11694 }
11695 suppress_size_errors = TRUE;
11696 }
11697
11698 list = htab->input_list + htab->top_index;
734b6cf9 11699 do
721956f4 11700 {
734b6cf9
AM		 11701 asection *tail = *list;
11702 while (tail != NULL)
721956f4 11703 {
734b6cf9
AM		 11704 asection *curr;
11705 asection *prev;
11706 bfd_size_type total;
11707 bfd_boolean big_sec;
11708 bfd_vma curr_toc;
11709
11710 curr = tail;
eea6121a 11711 total = tail->size;
6bee8834
AM		 11712 big_sec = total > (ppc64_elf_section_data (tail) != NULL
11713 && ppc64_elf_section_data (tail)->has_14bit_branch
7c8fe5c4
AM		 11714 ? stub14_group_size : stub_group_size);
11715 if (big_sec && !suppress_size_errors)
5c3dead3
AM		 11716 (*_bfd_error_handler) (_("%B section %A exceeds stub group size"),
11717 tail->owner, tail);
734b6cf9
AM		 11718 curr_toc = htab->stub_group[tail->id].toc_off;
11719
11720 while ((prev = PREV_SEC (curr)) != NULL
11721 && ((total += curr->output_offset - prev->output_offset)
6bee8834
AM		 11722 < (ppc64_elf_section_data (prev) != NULL
11723 && ppc64_elf_section_data (prev)->has_14bit_branch
7c8fe5c4 11724 ? stub14_group_size : stub_group_size))
ad8e1ba5 11725 && htab->stub_group[prev->id].toc_off == curr_toc)
734b6cf9
AM		 11726 curr = prev;
11727
11728 /* OK, the size from the start of CURR to the end is less
11729 than stub_group_size and thus can be handled by one stub
11730 section. (or the tail section is itself larger than
11731 stub_group_size, in which case we may be toast.) We
11732 should really be keeping track of the total size of stubs
11733 added here, as stubs contribute to the final output
11734 section size. That's a little tricky, and this way will
11735 only break if stubs added make the total size more than
11736 2^25, ie. for the default stub_group_size, if stubs total
11737 more than 2097152 bytes, or nearly 75000 plt call stubs. */
11738 do
721956f4
AM		 11739 {
11740 prev = PREV_SEC (tail);
734b6cf9 11741 /* Set up this stub group. */
721956f4
AM		 11742 htab->stub_group[tail->id].link_sec = curr;
11743 }
734b6cf9
AM		 11744 while (tail != curr && (tail = prev) != NULL);
11745
11746 /* But wait, there's more! Input sections up to stub_group_size
11747 bytes before the stub section can be handled by it too.
11748 Don't do this if we have a really large section after the
11749 stubs, as adding more stubs increases the chance that
11750 branches may not reach into the stub section. */
11751 if (!stubs_always_before_branch && !big_sec)
11752 {
11753 total = 0;
11754 while (prev != NULL
11755 && ((total += tail->output_offset - prev->output_offset)
6bee8834
AM		 11756 < (ppc64_elf_section_data (prev) != NULL
11757 && ppc64_elf_section_data (prev)->has_14bit_branch
7c8fe5c4 11758 ? stub14_group_size : stub_group_size))
734b6cf9
AM		 11759 && htab->stub_group[prev->id].toc_off == curr_toc)
11760 {
11761 tail = prev;
11762 prev = PREV_SEC (tail);
11763 htab->stub_group[tail->id].link_sec = curr;
11764 }
11765 }
11766 tail = prev;
721956f4
AM		 11767 }
11768 }
734b6cf9
AM		 11769 while (list-- != htab->input_list);
11770 free (htab->input_list);
721956f4
AM		 11771#undef PREV_SEC
11772}
11773
58d180e8
AM		 11774static const unsigned char glink_eh_frame_cie[] =
11775{
11776 0, 0, 0, 16, /* length. */
11777 0, 0, 0, 0, /* id. */
11778 1, /* CIE version. */
11779 'z', 'R', 0, /* Augmentation string. */
11780 4, /* Code alignment. */
11781 0x78, /* Data alignment. */
11782 65, /* RA reg. */
11783 1, /* Augmentation size. */
11784 DW_EH_PE_pcrel | DW_EH_PE_sdata4, /* FDE encoding. */
11785 DW_CFA_def_cfa, 1, 0 /* def_cfa: r1 offset 0. */
11786};
11787
d969d15f
AM		 11788/* Stripping output sections is normally done before dynamic section
11789 symbols have been allocated. This function is called later, and
11790 handles cases like htab->brlt which is mapped to its own output
11791 section. */
11792
11793static void
11794maybe_strip_output (struct bfd_link_info *info, asection *isec)
11795{
11796 if (isec->size == 0
11797 && isec->output_section->size == 0
53d8967a 11798 && !(isec->output_section->flags & SEC_KEEP)
d969d15f
AM		 11799 && !bfd_section_removed_from_list (info->output_bfd,
11800 isec->output_section)
11801 && elf_section_data (isec->output_section)->dynindx == 0)
11802 {
11803 isec->output_section->flags |= SEC_EXCLUDE;
11804 bfd_section_list_remove (info->output_bfd, isec->output_section);
11805 info->output_bfd->section_count--;
11806 }
11807}
11808
721956f4
AM		 11809/* Determine and set the size of the stub section for a final link.
11810
11811 The basic idea here is to examine all the relocations looking for
11812 PC-relative calls to a target that is unreachable with a "bl"
11813 instruction. */
11814
b34976b6 11815bfd_boolean
9df0ef5f 11816ppc64_elf_size_stubs (struct bfd_link_info *info, bfd_signed_vma group_size,
794e51c0
AM		 11817 bfd_boolean plt_static_chain, int plt_thread_safe,
11818 int plt_stub_align)
721956f4
AM		 11819{
11820 bfd_size_type stub_group_size;
b34976b6 11821 bfd_boolean stubs_always_before_branch;
721956f4
AM		 11822 struct ppc_link_hash_table *htab = ppc_hash_table (info);
11823
4dfe6ac6
NC		 11824 if (htab == NULL)
11825 return FALSE;
11826
9df0ef5f 11827 htab->plt_static_chain = plt_static_chain;
794e51c0 11828 htab->plt_stub_align = plt_stub_align;
e2458743
AM		 11829 if (plt_thread_safe == -1 && !info->executable)
11830 plt_thread_safe = 1;
b9e5796b
AM		 11831 if (!htab->opd_abi)
11832 plt_thread_safe = 0;
11833 else if (plt_thread_safe == -1)
794e51c0 11834 {
e2458743 11835 static const char *const thread_starter[] =
794e51c0
AM		 11836 {
11837 "pthread_create",
11838 /* libstdc++ */
11839 "_ZNSt6thread15_M_start_threadESt10shared_ptrINS_10_Impl_baseEE",
11840 /* librt */
11841 "aio_init", "aio_read", "aio_write", "aio_fsync", "lio_listio",
11842 "mq_notify", "create_timer",
11843 /* libanl */
11844 "getaddrinfo_a",
11845 /* libgomp */
11846 "GOMP_parallel_start",
11847 "GOMP_parallel_loop_static_start",
11848 "GOMP_parallel_loop_dynamic_start",
11849 "GOMP_parallel_loop_guided_start",
11850 "GOMP_parallel_loop_runtime_start",
68ffbac6 11851 "GOMP_parallel_sections_start",
794e51c0
AM		 11852 };
11853 unsigned i;
11854
11855 for (i = 0; i < sizeof (thread_starter)/ sizeof (thread_starter[0]); i++)
11856 {
11857 struct elf_link_hash_entry *h;
11858 h = elf_link_hash_lookup (&htab->elf, thread_starter[i],
11859 FALSE, FALSE, TRUE);
11860 plt_thread_safe = h != NULL && h->ref_regular;
11861 if (plt_thread_safe)
11862 break;
11863 }
11864 }
11865 htab->plt_thread_safe = plt_thread_safe;
721956f4
AM		 11866 stubs_always_before_branch = group_size < 0;
11867 if (group_size < 0)
11868 stub_group_size = -group_size;
11869 else
11870 stub_group_size = group_size;
721956f4
AM		 11871
11872 group_sections (htab, stub_group_size, stubs_always_before_branch);
11873
721956f4
AM		 11874 while (1)
11875 {
11876 bfd *input_bfd;
11877 unsigned int bfd_indx;
11878 asection *stub_sec;
721956f4
AM		 11879
11880 htab->stub_iteration += 1;
721956f4
AM		 11881
11882 for (input_bfd = info->input_bfds, bfd_indx = 0;
11883 input_bfd != NULL;
11884 input_bfd = input_bfd->link_next, bfd_indx++)
11885 {
11886 Elf_Internal_Shdr *symtab_hdr;
11887 asection *section;
6cdc0ccc 11888 Elf_Internal_Sym *local_syms = NULL;
721956f4 11889
0c8d6e5c 11890 if (!is_ppc64_elf (input_bfd))
67f93c31
AM		 11891 continue;
11892
721956f4 11893 /* We'll need the symbol table in a second. */
0ffa91dd 11894 symtab_hdr = &elf_symtab_hdr (input_bfd);
721956f4
AM		 11895 if (symtab_hdr->sh_info == 0)
11896 continue;
11897
721956f4
AM		 11898 /* Walk over each section attached to the input bfd. */
11899 for (section = input_bfd->sections;
11900 section != NULL;
11901 section = section->next)
11902 {
721956f4 11903 Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
721956f4
AM		 11904
11905 /* If there aren't any relocs, then there's nothing more
11906 to do. */
11907 if ((section->flags & SEC_RELOC) == 0
12c0f757
AM		 11908 || (section->flags & SEC_ALLOC) == 0
11909 || (section->flags & SEC_LOAD) == 0
11910 || (section->flags & SEC_CODE) == 0
721956f4
AM		 11911 || section->reloc_count == 0)
11912 continue;
11913
11914 /* If this section is a link-once section that will be
11915 discarded, then don't create any stubs. */
11916 if (section->output_section == NULL
927be08e 11917 || section->output_section->owner != info->output_bfd)
721956f4
AM		 11918 continue;
11919
1e2f5b6e
AM		 11920 /* Get the relocs. */
11921 internal_relocs
4ce794b7 11922 = _bfd_elf_link_read_relocs (input_bfd, section, NULL, NULL,
45d6a902 11923 info->keep_memory);
721956f4 11924 if (internal_relocs == NULL)
1e2f5b6e 11925 goto error_ret_free_local;
721956f4
AM		 11926
11927 /* Now examine each relocation. */
11928 irela = internal_relocs;
11929 irelaend = irela + section->reloc_count;
11930 for (; irela < irelaend; irela++)
11931 {
4ce794b7
AM		 11932 enum elf_ppc64_reloc_type r_type;
11933 unsigned int r_indx;
721956f4
AM		 11934 enum ppc_stub_type stub_type;
11935 struct ppc_stub_hash_entry *stub_entry;
8387904d 11936 asection *sym_sec, *code_sec;
e054468f 11937 bfd_vma sym_value, code_value;
721956f4 11938 bfd_vma destination;
6911b7dc 11939 unsigned long local_off;
8843416a 11940 bfd_boolean ok_dest;
721956f4 11941 struct ppc_link_hash_entry *hash;
8387904d 11942 struct ppc_link_hash_entry *fdh;
411e1bfb
AM		 11943 struct elf_link_hash_entry *h;
11944 Elf_Internal_Sym *sym;
721956f4
AM		 11945 char *stub_name;
11946 const asection *id_sec;
74f0fb50 11947 struct _opd_sec_data *opd;
e054468f 11948 struct plt_entry *plt_ent;
721956f4
AM		 11949
11950 r_type = ELF64_R_TYPE (irela->r_info);
11951 r_indx = ELF64_R_SYM (irela->r_info);
11952
4ce794b7 11953 if (r_type >= R_PPC64_max)
721956f4
AM		 11954 {
11955 bfd_set_error (bfd_error_bad_value);
6cdc0ccc 11956 goto error_ret_free_internal;
721956f4
AM		 11957 }
11958
11959 /* Only look for stubs on branch instructions. */
4ce794b7
AM		 11960 if (r_type != R_PPC64_REL24
11961 && r_type != R_PPC64_REL14
11962 && r_type != R_PPC64_REL14_BRTAKEN
11963 && r_type != R_PPC64_REL14_BRNTAKEN)
721956f4
AM		 11964 continue;
11965
11966 /* Now determine the call target, its name, value,
11967 section. */
411e1bfb
AM		 11968 if (!get_sym_h (&h, &sym, &sym_sec, NULL, &local_syms,
11969 r_indx, input_bfd))
11970 goto error_ret_free_internal;
11971 hash = (struct ppc_link_hash_entry *) h;
11972
8843416a 11973 ok_dest = FALSE;
8387904d 11974 fdh = NULL;
7fe2b9a6 11975 sym_value = 0;
411e1bfb 11976 if (hash == NULL)
721956f4 11977 {
411e1bfb 11978 sym_value = sym->st_value;
8843416a 11979 ok_dest = TRUE;
721956f4 11980 }
7fe2b9a6
AM		 11981 else if (hash->elf.root.type == bfd_link_hash_defined
11982 || hash->elf.root.type == bfd_link_hash_defweak)
11983 {
11984 sym_value = hash->elf.root.u.def.value;
11985 if (sym_sec->output_section != NULL)
11986 ok_dest = TRUE;
11987 }
11988 else if (hash->elf.root.type == bfd_link_hash_undefweak
11989 || hash->elf.root.type == bfd_link_hash_undefined)
721956f4 11990 {
99877b66 11991 /* Recognise an old ABI func code entry sym, and
7fe2b9a6
AM		 11992 use the func descriptor sym instead if it is
11993 defined. */
ceb1f1ef 11994 if (hash->elf.root.root.string[0] == '.'
b31867b6 11995 && (fdh = lookup_fdh (hash, htab)) != NULL)
8387904d 11996 {
8387904d
AM		 11997 if (fdh->elf.root.type == bfd_link_hash_defined
11998 || fdh->elf.root.type == bfd_link_hash_defweak)
11999 {
12000 sym_sec = fdh->elf.root.u.def.section;
12001 sym_value = fdh->elf.root.u.def.value;
12002 if (sym_sec->output_section != NULL)
12003 ok_dest = TRUE;
12004 }
99877b66
AM		 12005 else
12006 fdh = NULL;
8387904d 12007 }
7fe2b9a6
AM		 12008 }
12009 else
12010 {
12011 bfd_set_error (bfd_error_bad_value);
12012 goto error_ret_free_internal;
721956f4
AM		 12013 }
12014
8843416a 12015 destination = 0;
6911b7dc 12016 local_off = 0;
8843416a
AM		 12017 if (ok_dest)
12018 {
12019 sym_value += irela->r_addend;
12020 destination = (sym_value
12021 + sym_sec->output_offset
12022 + sym_sec->output_section->vma);
6911b7dc
AM		 12023 local_off = PPC64_LOCAL_ENTRY_OFFSET (hash
12024 ? hash->elf.other
12025 : sym->st_other);
8843416a
AM		 12026 }
12027
8387904d 12028 code_sec = sym_sec;
e054468f 12029 code_value = sym_value;
74f0fb50
AM		 12030 opd = get_opd_info (sym_sec);
12031 if (opd != NULL)
8387904d
AM		 12032 {
12033 bfd_vma dest;
12034
74f0fb50 12035 if (hash == NULL && opd->adjust != NULL)
8387904d 12036 {
74f0fb50 12037 long adjust = opd->adjust[sym_value / 8];
8387904d
AM		 12038 if (adjust == -1)
12039 continue;
e054468f 12040 code_value += adjust;
8387904d
AM		 12041 sym_value += adjust;
12042 }
12043 dest = opd_entry_value (sym_sec, sym_value,
aef36ac1 12044 &code_sec, &code_value, FALSE);
8387904d
AM		 12045 if (dest != (bfd_vma) -1)
12046 {
12047 destination = dest;
12048 if (fdh != NULL)
12049 {
12050 /* Fixup old ABI sym to point at code
12051 entry. */
99877b66 12052 hash->elf.root.type = bfd_link_hash_defweak;
8387904d 12053 hash->elf.root.u.def.section = code_sec;
e054468f 12054 hash->elf.root.u.def.value = code_value;
8387904d
AM		 12055 }
12056 }
12057 }
12058
721956f4 12059 /* Determine what (if any) linker stub is needed. */
e054468f 12060 plt_ent = NULL;
721956f4 12061 stub_type = ppc_type_of_stub (section, irela, &hash,
6911b7dc
AM		 12062 &plt_ent, destination,
12063 local_off);
ad8e1ba5
AM		 12064
12065 if (stub_type != ppc_stub_plt_call)
12066 {
12067 /* Check whether we need a TOC adjusting stub.
12068 Since the linker pastes together pieces from
12069 different object files when creating the
12070 _init and _fini functions, it may be that a
12071 call to what looks like a local sym is in
12072 fact a call needing a TOC adjustment. */
8387904d
AM		 12073 if (code_sec != NULL
12074 && code_sec->output_section != NULL
12075 && (htab->stub_group[code_sec->id].toc_off
9b5ecbd0 12076 != htab->stub_group[section->id].toc_off)
4c52953f
AM		 12077 && (code_sec->has_toc_reloc
12078 || code_sec->makes_toc_func_call))
ad8e1ba5
AM		 12079 stub_type = ppc_stub_long_branch_r2off;
12080 }
12081
721956f4
AM		 12082 if (stub_type == ppc_stub_none)
12083 continue;
12084
411e1bfb
AM		 12085 /* __tls_get_addr calls might be eliminated. */
12086 if (stub_type != ppc_stub_plt_call
12087 && hash != NULL
8387904d
AM		 12088 && (hash == htab->tls_get_addr
12089 || hash == htab->tls_get_addr_fd)
411e1bfb
AM		 12090 && section->has_tls_reloc
12091 && irela != internal_relocs)
12092 {
12093 /* Get tls info. */
f961d9dd 12094 unsigned char *tls_mask;
411e1bfb 12095
3a71aa26 12096 if (!get_tls_mask (&tls_mask, NULL, NULL, &local_syms,
411e1bfb
AM		 12097 irela - 1, input_bfd))
12098 goto error_ret_free_internal;
e7b938ca 12099 if (*tls_mask != 0)
411e1bfb
AM		 12100 continue;
12101 }
12102
3b421ab3
AM		 12103 if (stub_type == ppc_stub_plt_call
12104 && irela + 1 < irelaend
12105 && irela[1].r_offset == irela->r_offset + 4
794e51c0
AM		 12106 && ELF64_R_TYPE (irela[1].r_info) == R_PPC64_TOCSAVE)
12107 {
12108 if (!tocsave_find (htab, INSERT,
12109 &local_syms, irela + 1, input_bfd))
12110 goto error_ret_free_internal;
12111 }
12112 else if (stub_type == ppc_stub_plt_call)
12113 stub_type = ppc_stub_plt_call_r2save;
3b421ab3 12114
721956f4
AM		 12115 /* Support for grouping stub sections. */
12116 id_sec = htab->stub_group[section->id].link_sec;
12117
12118 /* Get the name of this stub. */
12119 stub_name = ppc_stub_name (id_sec, sym_sec, hash, irela);
12120 if (!stub_name)
12121 goto error_ret_free_internal;
12122
12123 stub_entry = ppc_stub_hash_lookup (&htab->stub_hash_table,
b34976b6 12124 stub_name, FALSE, FALSE);
721956f4
AM		 12125 if (stub_entry != NULL)
12126 {
12127 /* The proper stub has already been created. */
12128 free (stub_name);
794e51c0
AM		 12129 if (stub_type == ppc_stub_plt_call_r2save)
12130 stub_entry->stub_type = stub_type;
721956f4
AM		 12131 continue;
12132 }
12133
25f53a85 12134 stub_entry = ppc_add_stub (stub_name, section, info);
721956f4
AM		 12135 if (stub_entry == NULL)
12136 {
12137 free (stub_name);
6cdc0ccc
AM		 12138 error_ret_free_internal:
12139 if (elf_section_data (section)->relocs == NULL)
12140 free (internal_relocs);
12141 error_ret_free_local:
12142 if (local_syms != NULL
12143 && (symtab_hdr->contents
12144 != (unsigned char *) local_syms))
12145 free (local_syms);
b34976b6 12146 return FALSE;
721956f4
AM		 12147 }
12148
ad8e1ba5 12149 stub_entry->stub_type = stub_type;
794e51c0
AM		 12150 if (stub_type != ppc_stub_plt_call
12151 && stub_type != ppc_stub_plt_call_r2save)
e054468f
AM		 12152 {
12153 stub_entry->target_value = code_value;
12154 stub_entry->target_section = code_sec;
12155 }
12156 else
12157 {
12158 stub_entry->target_value = sym_value;
12159 stub_entry->target_section = sym_sec;
12160 }
721956f4 12161 stub_entry->h = hash;
e054468f 12162 stub_entry->plt_ent = plt_ent;
6911b7dc 12163 stub_entry->other = hash ? hash->elf.other : sym->st_other;
ee75fd95
AM		 12164
12165 if (stub_entry->h != NULL)
12166 htab->stub_globals += 1;
721956f4
AM		 12167 }
12168
12169 /* We're done with the internal relocs, free them. */
6cdc0ccc 12170 if (elf_section_data (section)->relocs != internal_relocs)
1e2f5b6e 12171 free (internal_relocs);
721956f4 12172 }
6cdc0ccc
AM		 12173
12174 if (local_syms != NULL
12175 && symtab_hdr->contents != (unsigned char *) local_syms)
12176 {
12177 if (!info->keep_memory)
12178 free (local_syms);
12179 else
12180 symtab_hdr->contents = (unsigned char *) local_syms;
12181 }
721956f4
AM		 12182 }
12183
5c3dead3 12184 /* We may have added some stubs. Find out the new size of the
721956f4
AM		 12185 stub sections. */
12186 for (stub_sec = htab->stub_bfd->sections;
12187 stub_sec != NULL;
12188 stub_sec = stub_sec->next)
e717da7e 12189 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
ee75fd95 12190 {
5c3dead3 12191 stub_sec->rawsize = stub_sec->size;
ee75fd95
AM		 12192 stub_sec->size = 0;
12193 stub_sec->reloc_count = 0;
84f5d08e 12194 stub_sec->flags &= ~SEC_RELOC;
ee75fd95 12195 }
eea6121a
AM		 12196
12197 htab->brlt->size = 0;
84f5d08e
AM		 12198 htab->brlt->reloc_count = 0;
12199 htab->brlt->flags &= ~SEC_RELOC;
ee75fd95 12200 if (htab->relbrlt != NULL)
eea6121a 12201 htab->relbrlt->size = 0;
721956f4 12202
63bc6f6c 12203 bfd_hash_traverse (&htab->stub_hash_table, ppc_size_one_stub, info);
721956f4 12204
176a0d42
AM		 12205 if (info->emitrelocations
12206 && htab->glink != NULL && htab->glink->size != 0)
12207 {
12208 htab->glink->reloc_count = 1;
12209 htab->glink->flags |= SEC_RELOC;
12210 }
12211
58d180e8
AM		 12212 if (htab->glink_eh_frame != NULL
12213 && !bfd_is_abs_section (htab->glink_eh_frame->output_section)
9a2a56cc 12214 && htab->glink_eh_frame->output_section->size != 0)
58d180e8 12215 {
4bbe044a 12216 size_t size = 0, align;
58d180e8
AM		 12217
12218 for (stub_sec = htab->stub_bfd->sections;
12219 stub_sec != NULL;
12220 stub_sec = stub_sec->next)
12221 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12222 size += 20;
12223 if (htab->glink != NULL && htab->glink->size != 0)
12224 size += 24;
12225 if (size != 0)
12226 size += sizeof (glink_eh_frame_cie);
4bbe044a
AM		 12227 align = 1;
12228 align <<= htab->glink_eh_frame->output_section->alignment_power;
12229 align -= 1;
12230 size = (size + align) & ~align;
58d180e8
AM		 12231 htab->glink_eh_frame->rawsize = htab->glink_eh_frame->size;
12232 htab->glink_eh_frame->size = size;
12233 }
12234
794e51c0
AM		 12235 if (htab->plt_stub_align != 0)
12236 for (stub_sec = htab->stub_bfd->sections;
12237 stub_sec != NULL;
12238 stub_sec = stub_sec->next)
12239 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12240 stub_sec->size = ((stub_sec->size + (1 << htab->plt_stub_align) - 1)
12241 & (-1 << htab->plt_stub_align));
12242
5c3dead3
AM		 12243 for (stub_sec = htab->stub_bfd->sections;
12244 stub_sec != NULL;
12245 stub_sec = stub_sec->next)
12246 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
12247 && stub_sec->rawsize != stub_sec->size)
12248 break;
12249
12250 /* Exit from this loop when no stubs have been added, and no stubs
12251 have changed size. */
58d180e8
AM		 12252 if (stub_sec == NULL
12253 && (htab->glink_eh_frame == NULL
12254 || htab->glink_eh_frame->rawsize == htab->glink_eh_frame->size))
5c3dead3
AM		 12255 break;
12256
721956f4
AM		 12257 /* Ask the linker to do its stuff. */
12258 (*htab->layout_sections_again) ();
12259 }
12260
d969d15f
AM		 12261 maybe_strip_output (info, htab->brlt);
12262 if (htab->glink_eh_frame != NULL)
12263 maybe_strip_output (info, htab->glink_eh_frame);
721956f4 12264
b34976b6 12265 return TRUE;
721956f4
AM		 12266}
12267
12268/* Called after we have determined section placement. If sections
805fc799 12269 move, we'll be called again. Provide a value for TOCstart. */
721956f4 12270
805fc799 12271bfd_vma
1c865ab2 12272ppc64_elf_set_toc (struct bfd_link_info *info, bfd *obfd)
721956f4 12273{
805fc799
AM		 12274 asection *s;
12275 bfd_vma TOCstart;
721956f4 12276
805fc799
AM		 12277 /* The TOC consists of sections .got, .toc, .tocbss, .plt in that
12278 order. The TOC starts where the first of these sections starts. */
12279 s = bfd_get_section_by_name (obfd, ".got");
e054468f 12280 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
805fc799 12281 s = bfd_get_section_by_name (obfd, ".toc");
e054468f 12282 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
805fc799 12283 s = bfd_get_section_by_name (obfd, ".tocbss");
e054468f 12284 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
805fc799 12285 s = bfd_get_section_by_name (obfd, ".plt");
e054468f 12286 if (s == NULL || (s->flags & SEC_EXCLUDE) != 0)
805fc799
AM		 12287 {
12288 /* This may happen for
12289 o references to TOC base (SYM@toc / TOC[tc0]) without a
12290 .toc directive
12291 o bad linker script
12292 o --gc-sections and empty TOC sections
12293
12294 FIXME: Warn user? */
12295
12296 /* Look for a likely section. We probably won't even be
12297 using TOCstart. */
12298 for (s = obfd->sections; s != NULL; s = s->next)
e054468f
AM		 12299 if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_READONLY
12300 | SEC_EXCLUDE))
805fc799
AM		 12301 == (SEC_ALLOC | SEC_SMALL_DATA))
12302 break;
721956f4 12303 if (s == NULL)
805fc799 12304 for (s = obfd->sections; s != NULL; s = s->next)
e054468f 12305 if ((s->flags & (SEC_ALLOC | SEC_SMALL_DATA | SEC_EXCLUDE))
805fc799
AM		 12306 == (SEC_ALLOC | SEC_SMALL_DATA))
12307 break;
721956f4 12308 if (s == NULL)
805fc799 12309 for (s = obfd->sections; s != NULL; s = s->next)
e054468f
AM		 12310 if ((s->flags & (SEC_ALLOC | SEC_READONLY | SEC_EXCLUDE))
12311 == SEC_ALLOC)
805fc799 12312 break;
721956f4 12313 if (s == NULL)
805fc799 12314 for (s = obfd->sections; s != NULL; s = s->next)
e054468f 12315 if ((s->flags & (SEC_ALLOC | SEC_EXCLUDE)) == SEC_ALLOC)
805fc799
AM		 12316 break;
12317 }
721956f4 12318
805fc799
AM		 12319 TOCstart = 0;
12320 if (s != NULL)
12321 TOCstart = s->output_section->vma + s->output_offset;
721956f4 12322
1c865ab2
AM		 12323 _bfd_set_gp_value (obfd, TOCstart);
12324
12325 if (info != NULL && s != NULL && is_ppc64_elf (obfd))
12326 {
12327 struct ppc_link_hash_table *htab = ppc_hash_table (info);
12328
12329 if (htab != NULL
12330 && htab->elf.hgot != NULL)
12331 {
5295321c 12332 htab->elf.hgot->type = STT_OBJECT;
1c865ab2
AM		 12333 htab->elf.hgot->root.type = bfd_link_hash_defined;
12334 htab->elf.hgot->root.u.def.value = TOC_BASE_OFF;
12335 htab->elf.hgot->root.u.def.section = s;
12336 }
12337 }
805fc799 12338 return TOCstart;
721956f4
AM		 12339}
12340
a345bc8d
AM		 12341/* Called via elf_link_hash_traverse from ppc64_elf_build_stubs to
12342 write out any global entry stubs. */
12343
12344static bfd_boolean
12345build_global_entry_stubs (struct elf_link_hash_entry *h, void *inf)
12346{
12347 struct bfd_link_info *info;
12348 struct ppc_link_hash_table *htab;
12349 struct plt_entry *pent;
12350 asection *s;
12351
12352 if (h->root.type == bfd_link_hash_indirect)
12353 return TRUE;
12354
12355 if (!h->pointer_equality_needed)
12356 return TRUE;
12357
12358 if (h->def_regular)
12359 return TRUE;
12360
12361 info = inf;
12362 htab = ppc_hash_table (info);
12363 if (htab == NULL)
12364 return FALSE;
12365
12366 s = htab->glink;
12367 for (pent = h->plt.plist; pent != NULL; pent = pent->next)
12368 if (pent->plt.offset != (bfd_vma) -1
12369 && pent->addend == 0)
12370 {
12371 bfd_byte *p;
12372 asection *plt;
12373 bfd_vma off;
12374
12375 /* For ELFv2, if this symbol is not defined in a regular file
12376 and we are not generating a shared library or pie, then we
12377 need to define the symbol in the executable on a call stub.
12378 This is to avoid text relocations. */
12379 h->root.u.def.section = s;
12380 h->root.u.def.value = s->size;
12381 s->size += 16;
12382 p = s->contents + h->root.u.def.value;
33e44f2e 12383 plt = htab->elf.splt;
a345bc8d
AM		 12384 if (!htab->elf.dynamic_sections_created
12385 || h->dynindx == -1)
33e44f2e 12386 plt = htab->elf.iplt;
a345bc8d
AM		 12387 off = pent->plt.offset + plt->output_offset + plt->output_section->vma;
12388 off -= h->root.u.def.value + s->output_offset + s->output_section->vma;
12389
12390 if (off + 0x80008000 > 0xffffffff || (off & 3) != 0)
12391 {
12392 info->callbacks->einfo
12393 (_("%P: linkage table error against `%T'\n"),
12394 h->root.root.string);
12395 bfd_set_error (bfd_error_bad_value);
12396 htab->stub_error = TRUE;
12397 }
12398
12399 if (PPC_HA (off) != 0)
12400 {
12401 bfd_put_32 (s->owner, ADDIS_R12_R12 | PPC_HA (off), p);
12402 p += 4;
12403 }
12404 bfd_put_32 (s->owner, LD_R12_0R12 | PPC_LO (off), p);
12405 p += 4;
12406 bfd_put_32 (s->owner, MTCTR_R12, p);
12407 p += 4;
12408 bfd_put_32 (s->owner, BCTR, p);
12409 break;
12410 }
12411 return TRUE;
12412}
12413
721956f4
AM		 12414/* Build all the stubs associated with the current output file.
12415 The stubs are kept in a hash table attached to the main linker
12416 hash table. This function is called via gldelf64ppc_finish. */
12417
b34976b6 12418bfd_boolean
4ce794b7
AM		 12419ppc64_elf_build_stubs (bfd_boolean emit_stub_syms,
12420 struct bfd_link_info *info,
12421 char **stats)
5d1634d7
AM		 12422{
12423 struct ppc_link_hash_table *htab = ppc_hash_table (info);
721956f4 12424 asection *stub_sec;
5d1634d7 12425 bfd_byte *p;
e717da7e 12426 int stub_sec_count = 0;
5d1634d7 12427
4dfe6ac6
NC		 12428 if (htab == NULL)
12429 return FALSE;
12430
ad8e1ba5 12431 htab->emit_stub_syms = emit_stub_syms;
eea6121a
AM		 12432
12433 /* Allocate memory to hold the linker stubs. */
721956f4
AM		 12434 for (stub_sec = htab->stub_bfd->sections;
12435 stub_sec != NULL;
12436 stub_sec = stub_sec->next)
eea6121a
AM		 12437 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
12438 && stub_sec->size != 0)
e717da7e 12439 {
eea6121a
AM		 12440 stub_sec->contents = bfd_zalloc (htab->stub_bfd, stub_sec->size);
12441 if (stub_sec->contents == NULL)
12442 return FALSE;
12443 /* We want to check that built size is the same as calculated
12444 size. rawsize is a convenient location to use. */
12445 stub_sec->rawsize = stub_sec->size;
12446 stub_sec->size = 0;
e717da7e 12447 }
5d1634d7 12448
23eb7e01 12449 if (htab->glink != NULL && htab->glink->size != 0)
5d1634d7 12450 {
9f951329 12451 unsigned int indx;
ad8e1ba5 12452 bfd_vma plt0;
9f951329 12453
721956f4 12454 /* Build the .glink plt call stub. */
97b639ba
AM		 12455 if (htab->emit_stub_syms)
12456 {
12457 struct elf_link_hash_entry *h;
468392fb
AM		 12458 h = elf_link_hash_lookup (&htab->elf, "__glink_PLTresolve",
12459 TRUE, FALSE, FALSE);
97b639ba
AM		 12460 if (h == NULL)
12461 return FALSE;
12462 if (h->root.type == bfd_link_hash_new)
12463 {
12464 h->root.type = bfd_link_hash_defined;
12465 h->root.u.def.section = htab->glink;
ee4bf8d2 12466 h->root.u.def.value = 8;
f5385ebf
AM		 12467 h->ref_regular = 1;
12468 h->def_regular = 1;
12469 h->ref_regular_nonweak = 1;
12470 h->forced_local = 1;
12471 h->non_elf = 0;
97b639ba
AM		 12472 }
12473 }
33e44f2e
AM		 12474 plt0 = (htab->elf.splt->output_section->vma
12475 + htab->elf.splt->output_offset
12476 - 16);
176a0d42
AM		 12477 if (info->emitrelocations)
12478 {
12479 Elf_Internal_Rela *r = get_relocs (htab->glink, 1);
12480 if (r == NULL)
12481 return FALSE;
12482 r->r_offset = (htab->glink->output_offset
12483 + htab->glink->output_section->vma);
12484 r->r_info = ELF64_R_INFO (0, R_PPC64_REL64);
12485 r->r_addend = plt0;
12486 }
4ce794b7 12487 p = htab->glink->contents;
176a0d42 12488 plt0 -= htab->glink->output_section->vma + htab->glink->output_offset;
ee4bf8d2
AM		 12489 bfd_put_64 (htab->glink->owner, plt0, p);
12490 p += 8;
b9e5796b
AM		 12491 if (htab->opd_abi)
12492 {
12493 bfd_put_32 (htab->glink->owner, MFLR_R12, p);
12494 p += 4;
12495 bfd_put_32 (htab->glink->owner, BCL_20_31, p);
12496 p += 4;
12497 bfd_put_32 (htab->glink->owner, MFLR_R11, p);
12498 p += 4;
12499 bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
12500 p += 4;
12501 bfd_put_32 (htab->glink->owner, MTLR_R12, p);
12502 p += 4;
12503 bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
12504 p += 4;
12505 bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
12506 p += 4;
12507 bfd_put_32 (htab->glink->owner, LD_R2_0R11 | 8, p);
12508 p += 4;
12509 bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
12510 p += 4;
12511 bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 16, p);
12512 p += 4;
12513 }
12514 else
12515 {
12516 bfd_put_32 (htab->glink->owner, MFLR_R0, p);
12517 p += 4;
12518 bfd_put_32 (htab->glink->owner, BCL_20_31, p);
12519 p += 4;
12520 bfd_put_32 (htab->glink->owner, MFLR_R11, p);
12521 p += 4;
12522 bfd_put_32 (htab->glink->owner, LD_R2_0R11 | (-16 & 0xfffc), p);
12523 p += 4;
12524 bfd_put_32 (htab->glink->owner, MTLR_R0, p);
12525 p += 4;
12526 bfd_put_32 (htab->glink->owner, SUB_R12_R12_R11, p);
12527 p += 4;
12528 bfd_put_32 (htab->glink->owner, ADD_R11_R2_R11, p);
12529 p += 4;
12530 bfd_put_32 (htab->glink->owner, ADDI_R0_R12 | (-48 & 0xffff), p);
12531 p += 4;
12532 bfd_put_32 (htab->glink->owner, LD_R12_0R11, p);
12533 p += 4;
12534 bfd_put_32 (htab->glink->owner, SRDI_R0_R0_2, p);
12535 p += 4;
12536 bfd_put_32 (htab->glink->owner, MTCTR_R12, p);
12537 p += 4;
12538 bfd_put_32 (htab->glink->owner, LD_R11_0R11 | 8, p);
12539 p += 4;
12540 }
4ce794b7 12541 bfd_put_32 (htab->glink->owner, BCTR, p);
ad8e1ba5 12542 p += 4;
ee4bf8d2
AM		 12543 while (p - htab->glink->contents < GLINK_CALL_STUB_SIZE)
12544 {
12545 bfd_put_32 (htab->glink->owner, NOP, p);
12546 p += 4;
12547 }
ad8e1ba5 12548
9f951329
AM		 12549 /* Build the .glink lazy link call stubs. */
12550 indx = 0;
a345bc8d 12551 while (p < htab->glink->contents + htab->glink->rawsize)
9f951329 12552 {
b9e5796b 12553 if (htab->opd_abi)
9f951329 12554 {
b9e5796b
AM		 12555 if (indx < 0x8000)
12556 {
12557 bfd_put_32 (htab->glink->owner, LI_R0_0 | indx, p);
12558 p += 4;
12559 }
12560 else
12561 {
12562 bfd_put_32 (htab->glink->owner, LIS_R0_0 | PPC_HI (indx), p);
12563 p += 4;
12564 bfd_put_32 (htab->glink->owner, ORI_R0_R0_0 | PPC_LO (indx),
12565 p);
12566 p += 4;
12567 }
9f951329 12568 }
4ce794b7 12569 bfd_put_32 (htab->glink->owner,
ee4bf8d2 12570 B_DOT | ((htab->glink->contents - p + 8) & 0x3fffffc), p);
a16d5acb 12571 indx++;
9f951329
AM		 12572 p += 4;
12573 }
a345bc8d
AM		 12574
12575 /* Build .glink global entry stubs. */
12576 if (htab->glink->size > htab->glink->rawsize)
12577 {
12578 htab->glink->size = (htab->glink->rawsize + 15) & -16;
12579 elf_link_hash_traverse (&htab->elf, build_global_entry_stubs, info);
12580 }
5d1634d7 12581 }
5d1634d7 12582
eea6121a 12583 if (htab->brlt->size != 0)
721956f4 12584 {
4ce794b7 12585 htab->brlt->contents = bfd_zalloc (htab->brlt->owner,
eea6121a 12586 htab->brlt->size);
4ce794b7 12587 if (htab->brlt->contents == NULL)
b34976b6 12588 return FALSE;
721956f4 12589 }
ee75fd95 12590 if (htab->relbrlt != NULL && htab->relbrlt->size != 0)
63bc6f6c
AM		 12591 {
12592 htab->relbrlt->contents = bfd_zalloc (htab->relbrlt->owner,
eea6121a 12593 htab->relbrlt->size);
63bc6f6c
AM		 12594 if (htab->relbrlt->contents == NULL)
12595 return FALSE;
12596 }
5d1634d7 12597
58d180e8
AM		 12598 if (htab->glink_eh_frame != NULL
12599 && htab->glink_eh_frame->size != 0)
12600 {
12601 bfd_vma val;
4bbe044a
AM		 12602 bfd_byte *last_fde;
12603 size_t last_fde_len, size, align, pad;
58d180e8
AM		 12604
12605 p = bfd_zalloc (htab->glink_eh_frame->owner, htab->glink_eh_frame->size);
12606 if (p == NULL)
12607 return FALSE;
12608 htab->glink_eh_frame->contents = p;
4bbe044a 12609 last_fde = p;
58d180e8
AM		 12610
12611 htab->glink_eh_frame->rawsize = htab->glink_eh_frame->size;
12612
12613 memcpy (p, glink_eh_frame_cie, sizeof (glink_eh_frame_cie));
12614 /* CIE length (rewrite in case little-endian). */
4bbe044a
AM		 12615 last_fde_len = sizeof (glink_eh_frame_cie) - 4;
12616 bfd_put_32 (htab->elf.dynobj, last_fde_len, p);
58d180e8
AM		 12617 p += sizeof (glink_eh_frame_cie);
12618
12619 for (stub_sec = htab->stub_bfd->sections;
12620 stub_sec != NULL;
12621 stub_sec = stub_sec->next)
12622 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12623 {
4bbe044a
AM		 12624 last_fde = p;
12625 last_fde_len = 16;
58d180e8
AM		 12626 /* FDE length. */
12627 bfd_put_32 (htab->elf.dynobj, 16, p);
12628 p += 4;
12629 /* CIE pointer. */
12630 val = p - htab->glink_eh_frame->contents;
12631 bfd_put_32 (htab->elf.dynobj, val, p);
12632 p += 4;
12633 /* Offset to stub section. */
12634 val = (stub_sec->output_section->vma
12635 + stub_sec->output_offset);
12636 val -= (htab->glink_eh_frame->output_section->vma
12637 + htab->glink_eh_frame->output_offset);
12638 val -= p - htab->glink_eh_frame->contents;
12639 if (val + 0x80000000 > 0xffffffff)
12640 {
12641 info->callbacks->einfo
8de848d8 12642 (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
58d180e8
AM		 12643 stub_sec->name);
12644 return FALSE;
12645 }
12646 bfd_put_32 (htab->elf.dynobj, val, p);
12647 p += 4;
12648 /* stub section size. */
12649 bfd_put_32 (htab->elf.dynobj, stub_sec->rawsize, p);
12650 p += 4;
12651 /* Augmentation. */
12652 p += 1;
12653 /* Pad. */
12654 p += 3;
12655 }
12656 if (htab->glink != NULL && htab->glink->size != 0)
12657 {
4bbe044a
AM		 12658 last_fde = p;
12659 last_fde_len = 20;
58d180e8
AM		 12660 /* FDE length. */
12661 bfd_put_32 (htab->elf.dynobj, 20, p);
12662 p += 4;
12663 /* CIE pointer. */
12664 val = p - htab->glink_eh_frame->contents;
12665 bfd_put_32 (htab->elf.dynobj, val, p);
12666 p += 4;
12667 /* Offset to .glink. */
12668 val = (htab->glink->output_section->vma
12669 + htab->glink->output_offset
12670 + 8);
12671 val -= (htab->glink_eh_frame->output_section->vma
12672 + htab->glink_eh_frame->output_offset);
12673 val -= p - htab->glink_eh_frame->contents;
12674 if (val + 0x80000000 > 0xffffffff)
12675 {
12676 info->callbacks->einfo
8de848d8 12677 (_("%P: %s offset too large for .eh_frame sdata4 encoding"),
58d180e8
AM		 12678 htab->glink->name);
12679 return FALSE;
12680 }
12681 bfd_put_32 (htab->elf.dynobj, val, p);
12682 p += 4;
12683 /* .glink size. */
a345bc8d 12684 bfd_put_32 (htab->elf.dynobj, htab->glink->size - 8, p);
58d180e8
AM		 12685 p += 4;
12686 /* Augmentation. */
12687 p += 1;
12688
12689 *p++ = DW_CFA_advance_loc + 1;
12690 *p++ = DW_CFA_register;
12691 *p++ = 65;
12692 *p++ = 12;
12693 *p++ = DW_CFA_advance_loc + 4;
12694 *p++ = DW_CFA_restore_extended;
12695 *p++ = 65;
12696 }
4bbe044a
AM		 12697 /* Subsume any padding into the last FDE if user .eh_frame
12698 sections are aligned more than glink_eh_frame. Otherwise any
12699 zero padding will be seen as a terminator. */
12700 size = p - htab->glink_eh_frame->contents;
12701 align = 1;
12702 align <<= htab->glink_eh_frame->output_section->alignment_power;
12703 align -= 1;
12704 pad = ((size + align) & ~align) - size;
12705 htab->glink_eh_frame->size = size + pad;
12706 bfd_put_32 (htab->elf.dynobj, last_fde_len + pad, last_fde);
58d180e8
AM		 12707 }
12708
721956f4
AM		 12709 /* Build the stubs as directed by the stub hash table. */
12710 bfd_hash_traverse (&htab->stub_hash_table, ppc_build_one_stub, info);
5d1634d7 12711
aa8a7074
AM		 12712 if (htab->relbrlt != NULL)
12713 htab->relbrlt->reloc_count = 0;
12714
794e51c0
AM		 12715 if (htab->plt_stub_align != 0)
12716 for (stub_sec = htab->stub_bfd->sections;
12717 stub_sec != NULL;
12718 stub_sec = stub_sec->next)
12719 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12720 stub_sec->size = ((stub_sec->size + (1 << htab->plt_stub_align) - 1)
12721 & (-1 << htab->plt_stub_align));
12722
721956f4
AM		 12723 for (stub_sec = htab->stub_bfd->sections;
12724 stub_sec != NULL;
12725 stub_sec = stub_sec->next)
e717da7e
AM		 12726 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
12727 {
12728 stub_sec_count += 1;
eea6121a 12729 if (stub_sec->rawsize != stub_sec->size)
e717da7e
AM		 12730 break;
12731 }
5d1634d7 12732
721956f4 12733 if (stub_sec != NULL
58d180e8
AM		 12734 || (htab->glink_eh_frame != NULL
12735 && htab->glink_eh_frame->rawsize != htab->glink_eh_frame->size))
5d1634d7 12736 {
b34976b6 12737 htab->stub_error = TRUE;
8de848d8 12738 info->callbacks->einfo (_("%P: stubs don't match calculated size\n"));
5d1634d7 12739 }
721956f4 12740
d2a300cf
AM		 12741 if (htab->stub_error)
12742 return FALSE;
12743
12744 if (stats != NULL)
12745 {
12746 *stats = bfd_malloc (500);
12747 if (*stats == NULL)
12748 return FALSE;
12749
ee75fd95 12750 sprintf (*stats, _("linker stubs in %u group%s\n"
d2a300cf
AM		 12751 " branch %lu\n"
12752 " toc adjust %lu\n"
12753 " long branch %lu\n"
12754 " long toc adj %lu\n"
794e51c0
AM		 12755 " plt call %lu\n"
12756 " plt call toc %lu"),
e717da7e 12757 stub_sec_count,
ee75fd95 12758 stub_sec_count == 1 ? "" : "s",
4ce794b7
AM		 12759 htab->stub_count[ppc_stub_long_branch - 1],
12760 htab->stub_count[ppc_stub_long_branch_r2off - 1],
12761 htab->stub_count[ppc_stub_plt_branch - 1],
12762 htab->stub_count[ppc_stub_plt_branch_r2off - 1],
794e51c0
AM		 12763 htab->stub_count[ppc_stub_plt_call - 1],
12764 htab->stub_count[ppc_stub_plt_call_r2save - 1]);
d2a300cf
AM		 12765 }
12766 return TRUE;
5bd4f169
AM		 12767}
12768
99877b66
AM		 12769/* This function undoes the changes made by add_symbol_adjust. */
12770
12771static bfd_boolean
12772undo_symbol_twiddle (struct elf_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
12773{
12774 struct ppc_link_hash_entry *eh;
12775
12776 if (h->root.type == bfd_link_hash_indirect)
12777 return TRUE;
12778
99877b66
AM		 12779 eh = (struct ppc_link_hash_entry *) h;
12780 if (eh->elf.root.type != bfd_link_hash_undefweak || !eh->was_undefined)
12781 return TRUE;
12782
12783 eh->elf.root.type = bfd_link_hash_undefined;
12784 return TRUE;
12785}
12786
12787void
12788ppc64_elf_restore_symbols (struct bfd_link_info *info)
12789{
12790 struct ppc_link_hash_table *htab = ppc_hash_table (info);
4dfe6ac6
NC		 12791
12792 if (htab != NULL)
12793 elf_link_hash_traverse (&htab->elf, undo_symbol_twiddle, info);
99877b66
AM		 12794}
12795
60124e18
AM		 12796/* What to do when ld finds relocations against symbols defined in
12797 discarded sections. */
12798
12799static unsigned int
12800ppc64_elf_action_discarded (asection *sec)
12801{
12802 if (strcmp (".opd", sec->name) == 0)
12803 return 0;
12804
12805 if (strcmp (".toc", sec->name) == 0)
12806 return 0;
12807
bce50a28
JJ		 12808 if (strcmp (".toc1", sec->name) == 0)
12809 return 0;
12810
60124e18
AM		 12811 return _bfd_elf_default_action_discarded (sec);
12812}
12813
5bd4f169
AM		 12814/* The RELOCATE_SECTION function is called by the ELF backend linker
12815 to handle the relocations for a section.
12816
12817 The relocs are always passed as Rela structures; if the section
12818 actually uses Rel structures, the r_addend field will always be
12819 zero.
12820
12821 This function is responsible for adjust the section contents as
12822 necessary, and (if using Rela relocs and generating a
1049f94e 12823 relocatable output file) adjusting the reloc addend as
5bd4f169
AM		 12824 necessary.
12825
12826 This function does not have to worry about setting the reloc
12827 address or the reloc symbol index.
12828
12829 LOCAL_SYMS is a pointer to the swapped in local symbols.
12830
12831 LOCAL_SECTIONS is an array giving the section in the input file
12832 corresponding to the st_shndx field of each local symbol.
12833
12834 The global hash table entry for the global symbols can be found
12835 via elf_sym_hashes (input_bfd).
12836
1049f94e 12837 When generating relocatable output, this function must handle
5bd4f169
AM		 12838 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
12839 going to be the section symbol corresponding to the output
12840 section, which means that the addend must be adjusted
12841 accordingly. */
12842
b34976b6 12843static bfd_boolean
4ce794b7
AM		 12844ppc64_elf_relocate_section (bfd *output_bfd,
12845 struct bfd_link_info *info,
12846 bfd *input_bfd,
12847 asection *input_section,
12848 bfd_byte *contents,
12849 Elf_Internal_Rela *relocs,
12850 Elf_Internal_Sym *local_syms,
12851 asection **local_sections)
5bd4f169 12852{
65f38f15 12853 struct ppc_link_hash_table *htab;
5bd4f169
AM		 12854 Elf_Internal_Shdr *symtab_hdr;
12855 struct elf_link_hash_entry **sym_hashes;
5bd4f169
AM		 12856 Elf_Internal_Rela *rel;
12857 Elf_Internal_Rela *relend;
411e1bfb
AM		 12858 Elf_Internal_Rela outrel;
12859 bfd_byte *loc;
411e1bfb 12860 struct got_entry **local_got_ents;
5bd4f169 12861 bfd_vma TOCstart;
b34976b6
AM		 12862 bfd_boolean ret = TRUE;
12863 bfd_boolean is_opd;
794e51c0
AM		 12864 /* Assume 'at' branch hints. */
12865 bfd_boolean is_isa_v2 = TRUE;
4fe5ca5b 12866 bfd_vma d_offset = (bfd_big_endian (output_bfd) ? 2 : 0);
5bd4f169 12867
65f38f15 12868 /* Initialize howto table if needed. */
5bd4f169 12869 if (!ppc64_elf_howto_table[R_PPC64_ADDR32])
5bd4f169
AM		 12870 ppc_howto_init ();
12871
65f38f15 12872 htab = ppc_hash_table (info);
4dfe6ac6
NC		 12873 if (htab == NULL)
12874 return FALSE;
ee75fd95
AM		 12875
12876 /* Don't relocate stub sections. */
12877 if (input_section->owner == htab->stub_bfd)
12878 return TRUE;
12879
0c8d6e5c 12880 BFD_ASSERT (is_ppc64_elf (input_bfd));
0ffa91dd 12881
411e1bfb 12882 local_got_ents = elf_local_got_ents (input_bfd);
5bd4f169 12883 TOCstart = elf_gp (output_bfd);
0ffa91dd 12884 symtab_hdr = &elf_symtab_hdr (input_bfd);
5bd4f169 12885 sym_hashes = elf_sym_hashes (input_bfd);
7c8fe5c4 12886 is_opd = ppc64_elf_section_data (input_section)->sec_type == sec_opd;
65f38f15 12887
5bd4f169
AM		 12888 rel = relocs;
12889 relend = relocs + input_section->reloc_count;
12890 for (; rel < relend; rel++)
12891 {
04c9666a 12892 enum elf_ppc64_reloc_type r_type;
31c76678 12893 bfd_vma addend;
5bd4f169
AM		 12894 bfd_reloc_status_type r;
12895 Elf_Internal_Sym *sym;
12896 asection *sec;
039b3fef
AM		 12897 struct elf_link_hash_entry *h_elf;
12898 struct ppc_link_hash_entry *h;
12899 struct ppc_link_hash_entry *fdh;
5bd4f169 12900 const char *sym_name;
0d4792f7 12901 unsigned long r_symndx, toc_symndx;
3a71aa26 12902 bfd_vma toc_addend;
f961d9dd
AM		 12903 unsigned char tls_mask, tls_gd, tls_type;
12904 unsigned char sym_type;
5bd4f169 12905 bfd_vma relocation;
b34976b6
AM		 12906 bfd_boolean unresolved_reloc;
12907 bfd_boolean warned;
bc30df16 12908 enum { DEST_NORMAL, DEST_OPD, DEST_STUB } reloc_dest;
67f0cbdb 12909 unsigned int insn;
e11840f9 12910 unsigned int mask;
721956f4
AM		 12911 struct ppc_stub_hash_entry *stub_entry;
12912 bfd_vma max_br_offset;
12913 bfd_vma from;
31c76678 12914 const Elf_Internal_Rela orig_rel = *rel;
5bd4f169 12915
4ce794b7 12916 r_type = ELF64_R_TYPE (rel->r_info);
5bd4f169 12917 r_symndx = ELF64_R_SYM (rel->r_info);
ee87f2da
AM		 12918
12919 /* For old style R_PPC64_TOC relocs with a zero symbol, use the
12920 symbol of the previous ADDR64 reloc. The symbol gives us the
12921 proper TOC base to use. */
12922 if (rel->r_info == ELF64_R_INFO (0, R_PPC64_TOC)
12923 && rel != relocs
12924 && ELF64_R_TYPE (rel[-1].r_info) == R_PPC64_ADDR64
12925 && is_opd)
12926 r_symndx = ELF64_R_SYM (rel[-1].r_info);
12927
4ce794b7
AM		 12928 sym = NULL;
12929 sec = NULL;
039b3fef 12930 h_elf = NULL;
4ce794b7 12931 sym_name = NULL;
b34976b6
AM		 12932 unresolved_reloc = FALSE;
12933 warned = FALSE;
65f38f15 12934
0b13192e 12935 if (r_symndx < symtab_hdr->sh_info)
5bd4f169
AM		 12936 {
12937 /* It's a local symbol. */
74f0fb50 12938 struct _opd_sec_data *opd;
4025353c 12939
5bd4f169
AM		 12940 sym = local_syms + r_symndx;
12941 sec = local_sections[r_symndx];
26c61ae5 12942 sym_name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym, sec);
0d4792f7 12943 sym_type = ELF64_ST_TYPE (sym->st_info);
8517fae7 12944 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
74f0fb50
AM		 12945 opd = get_opd_info (sec);
12946 if (opd != NULL && opd->adjust != NULL)
1e2f5b6e 12947 {
74f0fb50 12948 long adjust = opd->adjust[(sym->st_value + rel->r_addend) / 8];
4025353c
AM		 12949 if (adjust == -1)
12950 relocation = 0;
12951 else
4cc603a5
AM		 12952 {
12953 /* If this is a relocation against the opd section sym
12954 and we have edited .opd, adjust the reloc addend so
12955 that ld -r and ld --emit-relocs output is correct.
12956 If it is a reloc against some other .opd symbol,
12957 then the symbol value will be adjusted later. */
12958 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
12959 rel->r_addend += adjust;
12960 else
12961 relocation += adjust;
12962 }
1e2f5b6e 12963 }
5bd4f169
AM		 12964 }
12965 else
12966 {
b2a8e766
AM		 12967 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
12968 r_symndx, symtab_hdr, sym_hashes,
039b3fef 12969 h_elf, sec, relocation,
b2a8e766 12970 unresolved_reloc, warned);
039b3fef
AM		 12971 sym_name = h_elf->root.root.string;
12972 sym_type = h_elf->type;
b69fdb4e
AM		 12973 if (sec != NULL
12974 && sec->owner == output_bfd
12975 && strcmp (sec->name, ".opd") == 0)
12976 {
12977 /* This is a symbol defined in a linker script. All
12978 such are defined in output sections, even those
12979 defined by simple assignment from a symbol defined in
12980 an input section. Transfer the symbol to an
12981 appropriate input .opd section, so that a branch to
12982 this symbol will be mapped to the location specified
12983 by the opd entry. */
12984 struct bfd_link_order *lo;
12985 for (lo = sec->map_head.link_order; lo != NULL; lo = lo->next)
12986 if (lo->type == bfd_indirect_link_order)
12987 {
12988 asection *isec = lo->u.indirect.section;
12989 if (h_elf->root.u.def.value >= isec->output_offset
12990 && h_elf->root.u.def.value < (isec->output_offset
12991 + isec->size))
12992 {
12993 h_elf->root.u.def.value -= isec->output_offset;
12994 h_elf->root.u.def.section = isec;
12995 sec = isec;
12996 break;
12997 }
12998 }
12999 }
5bd4f169 13000 }
039b3fef 13001 h = (struct ppc_link_hash_entry *) h_elf;
5bd4f169 13002
dbaa2011 13003 if (sec != NULL && discarded_section (sec))
e4067dbb 13004 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
545fd46b
MR		 13005 rel, 1, relend,
13006 ppc64_elf_howto_table[r_type], 0,
e4067dbb 13007 contents);
ab96bf03
AM		 13008
13009 if (info->relocatable)
13010 continue;
13011
f40da81b
AM		 13012 if (h != NULL && &h->elf == htab->elf.hgot)
13013 {
13014 relocation = (TOCstart
13015 + htab->stub_group[input_section->id].toc_off);
13016 sec = bfd_abs_section_ptr;
13017 unresolved_reloc = FALSE;
13018 }
13019
951fd09b
AM		 13020 /* TLS optimizations. Replace instruction sequences and relocs
13021 based on information we collected in tls_optimize. We edit
13022 RELOCS so that --emit-relocs will output something sensible
13023 for the final instruction stream. */
13024 tls_mask = 0;
13025 tls_gd = 0;
0d4792f7 13026 toc_symndx = 0;
727fc41e
AM		 13027 if (h != NULL)
13028 tls_mask = h->tls_mask;
13029 else if (local_got_ents != NULL)
411e1bfb 13030 {
e054468f
AM		 13031 struct plt_entry **local_plt = (struct plt_entry **)
13032 (local_got_ents + symtab_hdr->sh_info);
f961d9dd 13033 unsigned char *lgot_masks = (unsigned char *)
e054468f 13034 (local_plt + symtab_hdr->sh_info);
727fc41e
AM		 13035 tls_mask = lgot_masks[r_symndx];
13036 }
13037 if (tls_mask == 0
13038 && (r_type == R_PPC64_TLS
13039 || r_type == R_PPC64_TLSGD
13040 || r_type == R_PPC64_TLSLD))
13041 {
13042 /* Check for toc tls entries. */
f961d9dd 13043 unsigned char *toc_tls;
0d4792f7 13044
727fc41e
AM		 13045 if (!get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
13046 &local_syms, rel, input_bfd))
13047 return FALSE;
0d4792f7 13048
727fc41e
AM		 13049 if (toc_tls)
13050 tls_mask = *toc_tls;
0d4792f7
AM		 13051 }
13052
13053 /* Check that tls relocs are used with tls syms, and non-tls
13054 relocs are used with non-tls syms. */
cf35638d 13055 if (r_symndx != STN_UNDEF
0d4792f7
AM		 13056 && r_type != R_PPC64_NONE
13057 && (h == NULL
039b3fef
AM		 13058 || h->elf.root.type == bfd_link_hash_defined
13059 || h->elf.root.type == bfd_link_hash_defweak)
1d483afe
AM		 13060 && (IS_PPC64_TLS_RELOC (r_type)
13061 != (sym_type == STT_TLS
13062 || (sym_type == STT_SECTION
13063 && (sec->flags & SEC_THREAD_LOCAL) != 0))))
0d4792f7 13064 {
727fc41e
AM		 13065 if (tls_mask != 0
13066 && (r_type == R_PPC64_TLS
13067 || r_type == R_PPC64_TLSGD
13068 || r_type == R_PPC64_TLSLD))
0d4792f7
AM		 13069 /* R_PPC64_TLS is OK against a symbol in the TOC. */
13070 ;
13071 else
25f53a85 13072 info->callbacks->einfo
1d483afe 13073 (!IS_PPC64_TLS_RELOC (r_type)
bc30df16
AM		 13074 ? _("%P: %H: %s used with TLS symbol `%T'\n")
13075 : _("%P: %H: %s used with non-TLS symbol `%T'\n"),
25f53a85 13076 input_bfd, input_section, rel->r_offset,
0d4792f7
AM		 13077 ppc64_elf_howto_table[r_type]->name,
13078 sym_name);
411e1bfb
AM		 13079 }
13080
13081 /* Ensure reloc mapping code below stays sane. */
13082 if (R_PPC64_TOC16_LO_DS != R_PPC64_TOC16_DS + 1
13083 || R_PPC64_TOC16_LO != R_PPC64_TOC16 + 1
13084 || (R_PPC64_GOT_TLSLD16 & 3) != (R_PPC64_GOT_TLSGD16 & 3)
13085 || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TLSGD16_LO & 3)
13086 || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TLSGD16_HI & 3)
13087 || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TLSGD16_HA & 3)
13088 || (R_PPC64_GOT_TLSLD16 & 3) != (R_PPC64_GOT_TPREL16_DS & 3)
13089 || (R_PPC64_GOT_TLSLD16_LO & 3) != (R_PPC64_GOT_TPREL16_LO_DS & 3)
13090 || (R_PPC64_GOT_TLSLD16_HI & 3) != (R_PPC64_GOT_TPREL16_HI & 3)
13091 || (R_PPC64_GOT_TLSLD16_HA & 3) != (R_PPC64_GOT_TPREL16_HA & 3))
13092 abort ();
0d4792f7 13093
411e1bfb
AM		 13094 switch (r_type)
13095 {
13096 default:
411e1bfb
AM		 13097 break;
13098
ba761f19
AM		 13099 case R_PPC64_LO_DS_OPT:
13100 insn = bfd_get_32 (output_bfd, contents + rel->r_offset - d_offset);
13101 if ((insn & (0x3f << 26)) != 58u << 26)
13102 abort ();
13103 insn += (14u << 26) - (58u << 26);
13104 bfd_put_32 (output_bfd, insn, contents + rel->r_offset - d_offset);
13105 r_type = R_PPC64_TOC16_LO;
13106 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13107 break;
13108
411e1bfb
AM		 13109 case R_PPC64_TOC16:
13110 case R_PPC64_TOC16_LO:
13111 case R_PPC64_TOC16_DS:
13112 case R_PPC64_TOC16_LO_DS:
411e1bfb
AM		 13113 {
13114 /* Check for toc tls entries. */
f961d9dd 13115 unsigned char *toc_tls;
951fd09b 13116 int retval;
411e1bfb 13117
3a71aa26
AM		 13118 retval = get_tls_mask (&toc_tls, &toc_symndx, &toc_addend,
13119 &local_syms, rel, input_bfd);
951fd09b 13120 if (retval == 0)
411e1bfb
AM		 13121 return FALSE;
13122
13123 if (toc_tls)
13124 {
951fd09b 13125 tls_mask = *toc_tls;
411e1bfb
AM		 13126 if (r_type == R_PPC64_TOC16_DS
13127 || r_type == R_PPC64_TOC16_LO_DS)
81407a69
AM		 13128 {
13129 if (tls_mask != 0
13130 && (tls_mask & (TLS_DTPREL | TLS_TPREL)) == 0)
13131 goto toctprel;
13132 }
411e1bfb 13133 else
951fd09b
AM		 13134 {
13135 /* If we found a GD reloc pair, then we might be
13136 doing a GD->IE transition. */
13137 if (retval == 2)
13138 {
13139 tls_gd = TLS_TPRELGD;
13140 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
102890f0 13141 goto tls_ldgd_opt;
951fd09b
AM		 13142 }
13143 else if (retval == 3)
13144 {
13145 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
102890f0 13146 goto tls_ldgd_opt;
951fd09b
AM		 13147 }
13148 }
411e1bfb
AM		 13149 }
13150 }
13151 break;
13152
9d6ded02
AM		 13153 case R_PPC64_GOT_TPREL16_HI:
13154 case R_PPC64_GOT_TPREL16_HA:
13155 if (tls_mask != 0
13156 && (tls_mask & TLS_TPREL) == 0)
13157 {
13158 rel->r_offset -= d_offset;
13159 bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
13160 r_type = R_PPC64_NONE;
13161 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13162 }
13163 break;
13164
411e1bfb
AM		 13165 case R_PPC64_GOT_TPREL16_DS:
13166 case R_PPC64_GOT_TPREL16_LO_DS:
951fd09b
AM		 13167 if (tls_mask != 0
13168 && (tls_mask & TLS_TPREL) == 0)
411e1bfb 13169 {
81407a69 13170 toctprel:
4fe5ca5b 13171 insn = bfd_get_32 (output_bfd, contents + rel->r_offset - d_offset);
411e1bfb
AM		 13172 insn &= 31 << 21;
13173 insn |= 0x3c0d0000; /* addis 0,13,0 */
4fe5ca5b 13174 bfd_put_32 (output_bfd, insn, contents + rel->r_offset - d_offset);
411e1bfb 13175 r_type = R_PPC64_TPREL16_HA;
0d4792f7
AM		 13176 if (toc_symndx != 0)
13177 {
13178 rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
3a71aa26 13179 rel->r_addend = toc_addend;
0d4792f7
AM		 13180 /* We changed the symbol. Start over in order to
13181 get h, sym, sec etc. right. */
13182 rel--;
13183 continue;
13184 }
13185 else
13186 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
411e1bfb
AM		 13187 }
13188 break;
13189
13190 case R_PPC64_TLS:
951fd09b
AM		 13191 if (tls_mask != 0
13192 && (tls_mask & TLS_TPREL) == 0)
411e1bfb 13193 {
411e1bfb 13194 insn = bfd_get_32 (output_bfd, contents + rel->r_offset);
2d0f3896
AM		 13195 insn = _bfd_elf_ppc_at_tls_transform (insn, 13);
13196 if (insn == 0)
411e1bfb 13197 abort ();
411e1bfb 13198 bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
411e1bfb 13199 /* Was PPC64_TLS which sits on insn boundary, now
4fe5ca5b
GM		 13200 PPC64_TPREL16_LO which is at low-order half-word. */
13201 rel->r_offset += d_offset;
0d4792f7
AM		 13202 r_type = R_PPC64_TPREL16_LO;
13203 if (toc_symndx != 0)
13204 {
13205 rel->r_info = ELF64_R_INFO (toc_symndx, r_type);
3a71aa26 13206 rel->r_addend = toc_addend;
0d4792f7
AM		 13207 /* We changed the symbol. Start over in order to
13208 get h, sym, sec etc. right. */
13209 rel--;
13210 continue;
13211 }
13212 else
13213 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
411e1bfb
AM		 13214 }
13215 break;
13216
411e1bfb
AM		 13217 case R_PPC64_GOT_TLSGD16_HI:
13218 case R_PPC64_GOT_TLSGD16_HA:
951fd09b
AM		 13219 tls_gd = TLS_TPRELGD;
13220 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13221 goto tls_gdld_hi;
13222 break;
13223
411e1bfb
AM		 13224 case R_PPC64_GOT_TLSLD16_HI:
13225 case R_PPC64_GOT_TLSLD16_HA:
951fd09b 13226 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
411e1bfb 13227 {
951fd09b
AM		 13228 tls_gdld_hi:
13229 if ((tls_mask & tls_gd) != 0)
13230 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
13231 + R_PPC64_GOT_TPREL16_DS);
13232 else
411e1bfb 13233 {
4fe5ca5b 13234 rel->r_offset -= d_offset;
727ac201 13235 bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
951fd09b 13236 r_type = R_PPC64_NONE;
411e1bfb 13237 }
951fd09b 13238 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
411e1bfb
AM		 13239 }
13240 break;
13241
951fd09b
AM		 13242 case R_PPC64_GOT_TLSGD16:
13243 case R_PPC64_GOT_TLSGD16_LO:
13244 tls_gd = TLS_TPRELGD;
13245 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
102890f0 13246 goto tls_ldgd_opt;
951fd09b 13247 break;
411e1bfb 13248
951fd09b
AM		 13249 case R_PPC64_GOT_TLSLD16:
13250 case R_PPC64_GOT_TLSLD16_LO:
13251 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13252 {
3a71aa26 13253 unsigned int insn1, insn2, insn3;
102890f0
AM		 13254 bfd_vma offset;
13255
13256 tls_ldgd_opt:
727fc41e
AM		 13257 offset = (bfd_vma) -1;
13258 /* If not using the newer R_PPC64_TLSGD/LD to mark
13259 __tls_get_addr calls, we must trust that the call
13260 stays with its arg setup insns, ie. that the next
13261 reloc is the __tls_get_addr call associated with
13262 the current reloc. Edit both insns. */
13263 if (input_section->has_tls_get_addr_call
13264 && rel + 1 < relend
13265 && branch_reloc_hash_match (input_bfd, rel + 1,
13266 htab->tls_get_addr,
13267 htab->tls_get_addr_fd))
13268 offset = rel[1].r_offset;
102890f0 13269 if ((tls_mask & tls_gd) != 0)
411e1bfb 13270 {
102890f0 13271 /* IE */
3a71aa26
AM		 13272 insn1 = bfd_get_32 (output_bfd,
13273 contents + rel->r_offset - d_offset);
102890f0
AM		 13274 insn1 &= (1 << 26) - (1 << 2);
13275 insn1 |= 58 << 26; /* ld */
13276 insn2 = 0x7c636a14; /* add 3,3,13 */
727fc41e 13277 if (offset != (bfd_vma) -1)
f58d5a2d 13278 rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
102890f0
AM		 13279 if ((tls_mask & TLS_EXPLICIT) == 0)
13280 r_type = (((r_type - (R_PPC64_GOT_TLSGD16 & 3)) & 3)
13281 + R_PPC64_GOT_TPREL16_DS);
411e1bfb 13282 else
102890f0
AM		 13283 r_type += R_PPC64_TOC16_DS - R_PPC64_TOC16;
13284 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13285 }
13286 else
13287 {
13288 /* LE */
13289 insn1 = 0x3c6d0000; /* addis 3,13,0 */
13290 insn2 = 0x38630000; /* addi 3,3,0 */
13291 if (tls_gd == 0)
951fd09b 13292 {
102890f0 13293 /* Was an LD reloc. */
1d483afe
AM		 13294 if (toc_symndx)
13295 sec = local_sections[toc_symndx];
13296 for (r_symndx = 0;
13297 r_symndx < symtab_hdr->sh_info;
13298 r_symndx++)
13299 if (local_sections[r_symndx] == sec)
13300 break;
13301 if (r_symndx >= symtab_hdr->sh_info)
cf35638d 13302 r_symndx = STN_UNDEF;
102890f0 13303 rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
cf35638d 13304 if (r_symndx != STN_UNDEF)
1d483afe
AM		 13305 rel->r_addend -= (local_syms[r_symndx].st_value
13306 + sec->output_offset
13307 + sec->output_section->vma);
951fd09b 13308 }
102890f0 13309 else if (toc_symndx != 0)
3a71aa26
AM		 13310 {
13311 r_symndx = toc_symndx;
13312 rel->r_addend = toc_addend;
13313 }
102890f0
AM		 13314 r_type = R_PPC64_TPREL16_HA;
13315 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
727fc41e
AM		 13316 if (offset != (bfd_vma) -1)
13317 {
13318 rel[1].r_info = ELF64_R_INFO (r_symndx,
13319 R_PPC64_TPREL16_LO);
13320 rel[1].r_offset = offset + d_offset;
13321 rel[1].r_addend = rel->r_addend;
13322 }
102890f0 13323 }
3a71aa26
AM		 13324 bfd_put_32 (output_bfd, insn1,
13325 contents + rel->r_offset - d_offset);
727fc41e
AM		 13326 if (offset != (bfd_vma) -1)
13327 {
13328 insn3 = bfd_get_32 (output_bfd,
13329 contents + offset + 4);
13330 if (insn3 == NOP
13331 || insn3 == CROR_151515 || insn3 == CROR_313131)
13332 {
13333 rel[1].r_offset += 4;
13334 bfd_put_32 (output_bfd, insn2, contents + offset + 4);
13335 insn2 = NOP;
13336 }
13337 bfd_put_32 (output_bfd, insn2, contents + offset);
13338 }
13339 if ((tls_mask & tls_gd) == 0
13340 && (tls_gd == 0 || toc_symndx != 0))
13341 {
13342 /* We changed the symbol. Start over in order
13343 to get h, sym, sec etc. right. */
13344 rel--;
13345 continue;
13346 }
13347 }
13348 break;
13349
13350 case R_PPC64_TLSGD:
13351 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0)
13352 {
13353 unsigned int insn2, insn3;
13354 bfd_vma offset = rel->r_offset;
13355
13356 if ((tls_mask & TLS_TPRELGD) != 0)
13357 {
13358 /* IE */
13359 r_type = R_PPC64_NONE;
13360 insn2 = 0x7c636a14; /* add 3,3,13 */
13361 }
13362 else
13363 {
13364 /* LE */
13365 if (toc_symndx != 0)
13366 {
13367 r_symndx = toc_symndx;
13368 rel->r_addend = toc_addend;
13369 }
13370 r_type = R_PPC64_TPREL16_LO;
13371 rel->r_offset = offset + d_offset;
13372 insn2 = 0x38630000; /* addi 3,3,0 */
13373 }
13374 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13375 /* Zap the reloc on the _tls_get_addr call too. */
13376 BFD_ASSERT (offset == rel[1].r_offset);
f58d5a2d 13377 rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
3a71aa26
AM		 13378 insn3 = bfd_get_32 (output_bfd,
13379 contents + offset + 4);
102890f0
AM		 13380 if (insn3 == NOP
13381 || insn3 == CROR_151515 || insn3 == CROR_313131)
13382 {
727fc41e 13383 rel->r_offset += 4;
3a71aa26
AM		 13384 bfd_put_32 (output_bfd, insn2, contents + offset + 4);
13385 insn2 = NOP;
102890f0 13386 }
102890f0 13387 bfd_put_32 (output_bfd, insn2, contents + offset);
727fc41e 13388 if ((tls_mask & TLS_TPRELGD) == 0 && toc_symndx != 0)
102890f0 13389 {
102890f0
AM		 13390 rel--;
13391 continue;
411e1bfb 13392 }
411e1bfb 13393 }
411e1bfb
AM		 13394 break;
13395
727fc41e
AM		 13396 case R_PPC64_TLSLD:
13397 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0)
13398 {
13399 unsigned int insn2, insn3;
13400 bfd_vma offset = rel->r_offset;
13401
13402 if (toc_symndx)
13403 sec = local_sections[toc_symndx];
13404 for (r_symndx = 0;
13405 r_symndx < symtab_hdr->sh_info;
13406 r_symndx++)
13407 if (local_sections[r_symndx] == sec)
13408 break;
13409 if (r_symndx >= symtab_hdr->sh_info)
cf35638d 13410 r_symndx = STN_UNDEF;
727fc41e 13411 rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET;
cf35638d 13412 if (r_symndx != STN_UNDEF)
727fc41e
AM		 13413 rel->r_addend -= (local_syms[r_symndx].st_value
13414 + sec->output_offset
13415 + sec->output_section->vma);
13416
13417 r_type = R_PPC64_TPREL16_LO;
13418 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13419 rel->r_offset = offset + d_offset;
13420 /* Zap the reloc on the _tls_get_addr call too. */
13421 BFD_ASSERT (offset == rel[1].r_offset);
f58d5a2d 13422 rel[1].r_info = ELF64_R_INFO (STN_UNDEF, R_PPC64_NONE);
727fc41e
AM		 13423 insn2 = 0x38630000; /* addi 3,3,0 */
13424 insn3 = bfd_get_32 (output_bfd,
13425 contents + offset + 4);
13426 if (insn3 == NOP
13427 || insn3 == CROR_151515 || insn3 == CROR_313131)
13428 {
13429 rel->r_offset += 4;
13430 bfd_put_32 (output_bfd, insn2, contents + offset + 4);
13431 insn2 = NOP;
13432 }
13433 bfd_put_32 (output_bfd, insn2, contents + offset);
13434 rel--;
13435 continue;
13436 }
13437 break;
13438
411e1bfb 13439 case R_PPC64_DTPMOD64:
951fd09b
AM		 13440 if (rel + 1 < relend
13441 && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_DTPREL64)
13442 && rel[1].r_offset == rel->r_offset + 8)
411e1bfb 13443 {
951fd09b
AM		 13444 if ((tls_mask & TLS_GD) == 0)
13445 {
13446 rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_NONE);
13447 if ((tls_mask & TLS_TPRELGD) != 0)
13448 r_type = R_PPC64_TPREL64;
13449 else
13450 {
4ce794b7 13451 bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
951fd09b
AM		 13452 r_type = R_PPC64_NONE;
13453 }
13454 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13455 }
13456 }
13457 else
13458 {
13459 if ((tls_mask & TLS_LD) == 0)
411e1bfb 13460 {
4ce794b7 13461 bfd_put_64 (output_bfd, 1, contents + rel->r_offset);
411e1bfb 13462 r_type = R_PPC64_NONE;
951fd09b 13463 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
411e1bfb 13464 }
411e1bfb
AM		 13465 }
13466 break;
13467
13468 case R_PPC64_TPREL64:
951fd09b 13469 if ((tls_mask & TLS_TPREL) == 0)
411e1bfb
AM		 13470 {
13471 r_type = R_PPC64_NONE;
13472 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13473 }
13474 break;
52a82034
AM		 13475
13476 case R_PPC64_REL16_HA:
13477 /* If we are generating a non-PIC executable, edit
13478 . 0: addis 2,12,.TOC.-0b@ha
13479 . addi 2,2,.TOC.-0b@l
13480 used by ELFv2 global entry points to set up r2, to
13481 . lis 2,.TOC.@ha
13482 . addi 2,2,.TOC.@l
13483 if .TOC. is in range. */
13484 if (!info->shared
13485 && h != NULL && &h->elf == htab->elf.hgot
13486 && rel + 1 < relend
13487 && rel[1].r_info == ELF64_R_INFO (r_symndx, R_PPC64_REL16_LO)
13488 && rel[1].r_offset == rel->r_offset + 4
13489 && rel[1].r_addend == rel->r_addend + 4
13490 && relocation + 0x80008000 <= 0xffffffff)
13491 {
13492 unsigned int insn1, insn2;
13493 bfd_vma offset = rel->r_offset - d_offset;
13494 insn1 = bfd_get_32 (output_bfd, contents + offset);
13495 insn2 = bfd_get_32 (output_bfd, contents + offset + 4);
13496 if ((insn1 & 0xffff0000) == 0x3c4c0000 /* addis 2,12 */
13497 && (insn2 & 0xffff0000) == 0x38420000 /* addi 2,2 */)
13498 {
13499 r_type = R_PPC64_ADDR16_HA;
13500 rel->r_info = ELF64_R_INFO (r_symndx, r_type);
13501 rel->r_addend -= d_offset;
13502 rel[1].r_info = ELF64_R_INFO (r_symndx, R_PPC64_ADDR16_LO);
13503 rel[1].r_addend -= d_offset + 4;
13504 bfd_put_32 (output_bfd, 0x3c400000, contents + offset);
13505 }
13506 }
13507 break;
411e1bfb
AM		 13508 }
13509
13510 /* Handle other relocations that tweak non-addend part of insn. */
86c76c7b 13511 insn = 0;
b25116a9
AM		 13512 max_br_offset = 1 << 25;
13513 addend = rel->r_addend;
bc30df16 13514 reloc_dest = DEST_NORMAL;
65f38f15 13515 switch (r_type)
5bd4f169
AM		 13516 {
13517 default:
65f38f15 13518 break;
5bd4f169 13519
3b421ab3
AM		 13520 case R_PPC64_TOCSAVE:
13521 if (relocation + addend == (rel->r_offset
13522 + input_section->output_offset
13523 + input_section->output_section->vma)
13524 && tocsave_find (htab, NO_INSERT,
13525 &local_syms, rel, input_bfd))
13526 {
13527 insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
13528 if (insn == NOP
13529 || insn == CROR_151515 || insn == CROR_313131)
a078d95a
AM		 13530 bfd_put_32 (input_bfd,
13531 STD_R2_0R1 + STK_TOC (htab),
3b421ab3
AM		 13532 contents + rel->r_offset);
13533 }
13534 break;
13535
65f38f15
AM		 13536 /* Branch taken prediction relocations. */
13537 case R_PPC64_ADDR14_BRTAKEN:
13538 case R_PPC64_REL14_BRTAKEN:
cedb70c5
KH		 13539 insn = 0x01 << 21; /* 'y' or 't' bit, lowest bit of BO field. */
13540 /* Fall thru. */
65f38f15 13541
86c76c7b 13542 /* Branch not taken prediction relocations. */
65f38f15
AM		 13543 case R_PPC64_ADDR14_BRNTAKEN:
13544 case R_PPC64_REL14_BRNTAKEN:
411e1bfb
AM		 13545 insn |= bfd_get_32 (output_bfd,
13546 contents + rel->r_offset) & ~(0x01 << 21);
b25116a9 13547 /* Fall thru. */
86c76c7b 13548
b25116a9
AM		 13549 case R_PPC64_REL14:
13550 max_br_offset = 1 << 15;
13551 /* Fall thru. */
5bd4f169 13552
65f38f15 13553 case R_PPC64_REL24:
ad8e1ba5
AM		 13554 /* Calls to functions with a different TOC, such as calls to
13555 shared objects, need to alter the TOC pointer. This is
13556 done using a linkage stub. A REL24 branching to these
13557 linkage stubs needs to be followed by a nop, as the nop
13558 will be replaced with an instruction to restore the TOC
13559 base pointer. */
8387904d 13560 fdh = h;
b31867b6
AM		 13561 if (h != NULL
13562 && h->oh != NULL
13563 && h->oh->is_func_descriptor)
13564 fdh = ppc_follow_link (h->oh);
31c76678
DK		 13565 stub_entry = ppc_get_stub_entry (input_section, sec, fdh, &orig_rel,
13566 htab);
6abec6bc 13567 if (stub_entry != NULL
ad8e1ba5 13568 && (stub_entry->stub_type == ppc_stub_plt_call
794e51c0 13569 || stub_entry->stub_type == ppc_stub_plt_call_r2save
ad8e1ba5
AM		 13570 || stub_entry->stub_type == ppc_stub_plt_branch_r2off
13571 || stub_entry->stub_type == ppc_stub_long_branch_r2off))
41bd81ab 13572 {
b25116a9 13573 bfd_boolean can_plt_call = FALSE;
721956f4 13574
ba8ca3e7
AM		 13575 /* All of these stubs will modify r2, so there must be a
13576 branch and link followed by a nop. The nop is
13577 replaced by an insn to restore r2. */
eea6121a 13578 if (rel->r_offset + 8 <= input_section->size)
41bd81ab 13579 {
ba8ca3e7
AM		 13580 unsigned long br;
13581
13582 br = bfd_get_32 (input_bfd,
13583 contents + rel->r_offset);
13584 if ((br & 1) != 0)
41bd81ab 13585 {
ba8ca3e7
AM		 13586 unsigned long nop;
13587
13588 nop = bfd_get_32 (input_bfd,
13589 contents + rel->r_offset + 4);
13590 if (nop == NOP
13591 || nop == CROR_151515 || nop == CROR_313131)
a7f2871e 13592 {
ba8ca3e7
AM		 13593 if (h != NULL
13594 && (h == htab->tls_get_addr_fd
13595 || h == htab->tls_get_addr)
13596 && !htab->no_tls_get_addr_opt)
13597 {
13598 /* Special stub used, leave nop alone. */
13599 }
13600 else
a078d95a
AM		 13601 bfd_put_32 (input_bfd,
13602 LD_R2_0R1 + STK_TOC (htab),
ba8ca3e7
AM		 13603 contents + rel->r_offset + 4);
13604 can_plt_call = TRUE;
a7f2871e 13605 }
41bd81ab 13606 }
5bd4f169 13607 }
721956f4 13608
ba8ca3e7 13609 if (!can_plt_call && h != NULL)
721956f4 13610 {
ba8ca3e7
AM		 13611 const char *name = h->elf.root.root.string;
13612
13613 if (*name == '.')
13614 ++name;
13615
13616 if (strncmp (name, "__libc_start_main", 17) == 0
13617 && (name[17] == 0 || name[17] == '@'))
6ab189d5 13618 {
ba8ca3e7
AM		 13619 /* Allow crt1 branch to go via a toc adjusting
13620 stub. Other calls that never return could do
13621 the same, if we could detect such. */
b25116a9 13622 can_plt_call = TRUE;
6ab189d5 13623 }
ba8ca3e7
AM		 13624 }
13625
13626 if (!can_plt_call)
13627 {
13628 /* g++ as of 20130507 emits self-calls without a
13629 following nop. This is arguably wrong since we
13630 have conflicting information. On the one hand a
13631 global symbol and on the other a local call
13632 sequence, but don't error for this special case.
13633 It isn't possible to cheaply verify we have
13634 exactly such a call. Allow all calls to the same
13635 section. */
13636 asection *code_sec = sec;
13637
13638 if (get_opd_info (sec) != NULL)
ad8e1ba5 13639 {
ba8ca3e7
AM		 13640 bfd_vma off = (relocation + addend
13641 - sec->output_section->vma
13642 - sec->output_offset);
bc30df16 13643
ba8ca3e7 13644 opd_entry_value (sec, off, &code_sec, NULL, FALSE);
ad8e1ba5 13645 }
ba8ca3e7
AM		 13646 if (code_sec == input_section)
13647 can_plt_call = TRUE;
13648 }
13649
13650 if (!can_plt_call)
13651 {
13652 info->callbacks->einfo
13653 (_("%P: %H: call to `%T' lacks nop, can't restore toc; "
13654 "recompile with -fPIC"),
13655 input_bfd, input_section, rel->r_offset, sym_name);
13656
13657 bfd_set_error (bfd_error_bad_value);
13658 ret = FALSE;
721956f4
AM		 13659 }
13660
b25116a9 13661 if (can_plt_call
794e51c0
AM		 13662 && (stub_entry->stub_type == ppc_stub_plt_call
13663 || stub_entry->stub_type == ppc_stub_plt_call_r2save))
b25116a9
AM		 13664 unresolved_reloc = FALSE;
13665 }
13666
6abec6bc
AM		 13667 if ((stub_entry == NULL
13668 || stub_entry->stub_type == ppc_stub_long_branch
13669 || stub_entry->stub_type == ppc_stub_plt_branch)
8387904d
AM		 13670 && get_opd_info (sec) != NULL)
13671 {
13672 /* The branch destination is the value of the opd entry. */
4cc603a5
AM		 13673 bfd_vma off = (relocation + addend
13674 - sec->output_section->vma
13675 - sec->output_offset);
aef36ac1 13676 bfd_vma dest = opd_entry_value (sec, off, NULL, NULL, FALSE);
8387904d
AM		 13677 if (dest != (bfd_vma) -1)
13678 {
13679 relocation = dest;
13680 addend = 0;
bc30df16 13681 reloc_dest = DEST_OPD;
8387904d
AM		 13682 }
13683 }
13684
b25116a9
AM		 13685 /* If the branch is out of reach we ought to have a long
13686 branch stub. */
13687 from = (rel->r_offset
13688 + input_section->output_offset
13689 + input_section->output_section->vma);
13690
6911b7dc
AM		 13691 relocation += PPC64_LOCAL_ENTRY_OFFSET (fdh
13692 ? fdh->elf.other
13693 : sym->st_other);
13694
6abec6bc
AM		 13695 if (stub_entry != NULL
13696 && (stub_entry->stub_type == ppc_stub_long_branch
13697 || stub_entry->stub_type == ppc_stub_plt_branch)
13698 && (r_type == R_PPC64_ADDR14_BRTAKEN
13699 || r_type == R_PPC64_ADDR14_BRNTAKEN
13700 || (relocation + addend - from + max_br_offset
13701 < 2 * max_br_offset)))
13702 /* Don't use the stub if this branch is in range. */
13703 stub_entry = NULL;
b25116a9
AM		 13704
13705 if (stub_entry != NULL)
13706 {
13707 /* Munge up the value and addend so that we call the stub
13708 rather than the procedure directly. */
13709 relocation = (stub_entry->stub_offset
13710 + stub_entry->stub_sec->output_offset
13711 + stub_entry->stub_sec->output_section->vma);
13712 addend = 0;
bc30df16 13713 reloc_dest = DEST_STUB;
3b421ab3 13714
794e51c0
AM		 13715 if ((stub_entry->stub_type == ppc_stub_plt_call
13716 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
13717 && (ALWAYS_EMIT_R2SAVE
13718 || stub_entry->stub_type == ppc_stub_plt_call_r2save)
3b421ab3
AM		 13719 && rel + 1 < relend
13720 && rel[1].r_offset == rel->r_offset + 4
13721 && ELF64_R_TYPE (rel[1].r_info) == R_PPC64_TOCSAVE)
13722 relocation += 4;
b25116a9
AM		 13723 }
13724
13725 if (insn != 0)
13726 {
794e51c0 13727 if (is_isa_v2)
721956f4 13728 {
b25116a9
AM		 13729 /* Set 'a' bit. This is 0b00010 in BO field for branch
13730 on CR(BI) insns (BO == 001at or 011at), and 0b01000
13731 for branch on CTR insns (BO == 1a00t or 1a01t). */
13732 if ((insn & (0x14 << 21)) == (0x04 << 21))
13733 insn |= 0x02 << 21;
13734 else if ((insn & (0x14 << 21)) == (0x10 << 21))
13735 insn |= 0x08 << 21;
13736 else
13737 break;
13738 }
13739 else
13740 {
13741 /* Invert 'y' bit if not the default. */
4cc603a5 13742 if ((bfd_signed_vma) (relocation + addend - from) < 0)
b25116a9 13743 insn ^= 0x01 << 21;
721956f4 13744 }
b25116a9
AM		 13745
13746 bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
5bd4f169 13747 }
e86ce104 13748
06da1e8e
AM		 13749 /* NOP out calls to undefined weak functions.
13750 We can thus call a weak function without first
13751 checking whether the function is defined. */
b25116a9 13752 else if (h != NULL
039b3fef 13753 && h->elf.root.type == bfd_link_hash_undefweak
766bc656 13754 && h->elf.dynindx == -1
b25116a9
AM		 13755 && r_type == R_PPC64_REL24
13756 && relocation == 0
4cc603a5 13757 && addend == 0)
e86ce104 13758 {
06da1e8e
AM		 13759 bfd_put_32 (output_bfd, NOP, contents + rel->r_offset);
13760 continue;
e86ce104 13761 }
65f38f15
AM		 13762 break;
13763 }
5bd4f169 13764
65f38f15 13765 /* Set `addend'. */
411e1bfb 13766 tls_type = 0;
65f38f15
AM		 13767 switch (r_type)
13768 {
13769 default:
25f53a85 13770 info->callbacks->einfo
bc30df16 13771 (_("%P: %B: unknown relocation type %d for `%T'\n"),
d003868e 13772 input_bfd, (int) r_type, sym_name);
5bd4f169 13773
65f38f15 13774 bfd_set_error (bfd_error_bad_value);
b34976b6 13775 ret = FALSE;
65f38f15 13776 continue;
5bd4f169 13777
65f38f15 13778 case R_PPC64_NONE:
411e1bfb 13779 case R_PPC64_TLS:
727fc41e
AM		 13780 case R_PPC64_TLSGD:
13781 case R_PPC64_TLSLD:
3b421ab3 13782 case R_PPC64_TOCSAVE:
04c9666a
AM		 13783 case R_PPC64_GNU_VTINHERIT:
13784 case R_PPC64_GNU_VTENTRY:
65f38f15 13785 continue;
5bd4f169
AM		 13786
13787 /* GOT16 relocations. Like an ADDR16 using the symbol's
13788 address in the GOT as relocation value instead of the
411e1bfb 13789 symbol's value itself. Also, create a GOT entry for the
5bd4f169 13790 symbol and put the symbol value there. */
411e1bfb
AM		 13791 case R_PPC64_GOT_TLSGD16:
13792 case R_PPC64_GOT_TLSGD16_LO:
13793 case R_PPC64_GOT_TLSGD16_HI:
13794 case R_PPC64_GOT_TLSGD16_HA:
951fd09b 13795 tls_type = TLS_TLS | TLS_GD;
411e1bfb
AM		 13796 goto dogot;
13797
13798 case R_PPC64_GOT_TLSLD16:
13799 case R_PPC64_GOT_TLSLD16_LO:
13800 case R_PPC64_GOT_TLSLD16_HI:
13801 case R_PPC64_GOT_TLSLD16_HA:
951fd09b 13802 tls_type = TLS_TLS | TLS_LD;
411e1bfb
AM		 13803 goto dogot;
13804
13805 case R_PPC64_GOT_TPREL16_DS:
13806 case R_PPC64_GOT_TPREL16_LO_DS:
13807 case R_PPC64_GOT_TPREL16_HI:
13808 case R_PPC64_GOT_TPREL16_HA:
13809 tls_type = TLS_TLS | TLS_TPREL;
13810 goto dogot;
13811
13812 case R_PPC64_GOT_DTPREL16_DS:
13813 case R_PPC64_GOT_DTPREL16_LO_DS:
13814 case R_PPC64_GOT_DTPREL16_HI:
13815 case R_PPC64_GOT_DTPREL16_HA:
13816 tls_type = TLS_TLS | TLS_DTPREL;
13817 goto dogot;
13818
65f38f15
AM		 13819 case R_PPC64_GOT16:
13820 case R_PPC64_GOT16_LO:
13821 case R_PPC64_GOT16_HI:
13822 case R_PPC64_GOT16_HA:
13823 case R_PPC64_GOT16_DS:
13824 case R_PPC64_GOT16_LO_DS:
411e1bfb 13825 dogot:
5bd4f169
AM		 13826 {
13827 /* Relocation is to the entry for this symbol in the global
13828 offset table. */
e717da7e 13829 asection *got;
d881513a 13830 bfd_vma *offp;
5bd4f169 13831 bfd_vma off;
d881513a 13832 unsigned long indx = 0;
927be08e 13833 struct got_entry *ent;
65f38f15 13834
d881513a
AM		 13835 if (tls_type == (TLS_TLS | TLS_LD)
13836 && (h == NULL
f5385ebf 13837 || !h->elf.def_dynamic))
927be08e 13838 ent = ppc64_tlsld_got (input_bfd);
411e1bfb 13839 else
5bd4f169 13840 {
5bd4f169 13841
d881513a
AM		 13842 if (h != NULL)
13843 {
13844 bfd_boolean dyn = htab->elf.dynamic_sections_created;
039b3fef
AM		 13845 if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared,
13846 &h->elf)
d881513a 13847 || (info->shared
726d3ab0 13848 && SYMBOL_CALLS_LOCAL (info, &h->elf)))
d881513a
AM		 13849 /* This is actually a static link, or it is a
13850 -Bsymbolic link and the symbol is defined
13851 locally, or the symbol was forced to be local
13852 because of a version file. */
13853 ;
13854 else
13855 {
14acf4dc 13856 BFD_ASSERT (h->elf.dynindx != -1);
039b3fef 13857 indx = h->elf.dynindx;
d881513a
AM		 13858 unresolved_reloc = FALSE;
13859 }
039b3fef 13860 ent = h->elf.got.glist;
d881513a 13861 }
411e1bfb 13862 else
5bd4f169 13863 {
d881513a
AM		 13864 if (local_got_ents == NULL)
13865 abort ();
13866 ent = local_got_ents[r_symndx];
5bd4f169 13867 }
d881513a
AM		 13868
13869 for (; ent != NULL; ent = ent->next)
31c76678 13870 if (ent->addend == orig_rel.r_addend
e717da7e 13871 && ent->owner == input_bfd
d881513a
AM		 13872 && ent->tls_type == tls_type)
13873 break;
5bd4f169 13874 }
411e1bfb 13875
927be08e
AM		 13876 if (ent == NULL)
13877 abort ();
13878 if (ent->is_indirect)
13879 ent = ent->got.ent;
13880 offp = &ent->got.offset;
13881 got = ppc64_elf_tdata (ent->owner)->got;
e717da7e
AM		 13882 if (got == NULL)
13883 abort ();
13884
411e1bfb
AM		 13885 /* The offset must always be a multiple of 8. We use the
13886 least significant bit to record whether we have already
13887 processed this entry. */
d881513a 13888 off = *offp;
411e1bfb
AM		 13889 if ((off & 1) != 0)
13890 off &= ~1;
5bd4f169
AM		 13891 else
13892 {
411e1bfb
AM		 13893 /* Generate relocs for the dynamic linker, except in
13894 the case of TLSLD where we'll use one entry per
13895 module. */
25f23106
AM		 13896 asection *relgot;
13897 bfd_boolean ifunc;
e717da7e 13898
d881513a 13899 *offp = off | 1;
25f23106
AM		 13900 relgot = NULL;
13901 ifunc = (h != NULL
13902 ? h->elf.type == STT_GNU_IFUNC
13903 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC);
19e08130 13904 if (ifunc)
33e44f2e 13905 relgot = htab->elf.irelplt;
19e08130
AM		 13906 else if ((info->shared || indx != 0)
13907 && (h == NULL
13908 || (tls_type == (TLS_TLS | TLS_LD)
13909 && !h->elf.def_dynamic)
13910 || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
13911 || h->elf.root.type != bfd_link_hash_undefweak))
13912 relgot = ppc64_elf_tdata (ent->owner)->relgot;
25f23106 13913 if (relgot != NULL)
5bd4f169 13914 {
e717da7e
AM		 13915 outrel.r_offset = (got->output_section->vma
13916 + got->output_offset
411e1bfb 13917 + off);
4cc603a5 13918 outrel.r_addend = addend;
d881513a 13919 if (tls_type & (TLS_LD | TLS_GD))
5bd4f169 13920 {
411e1bfb 13921 outrel.r_addend = 0;
e515b051 13922 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPMOD64);
d881513a
AM		 13923 if (tls_type == (TLS_TLS | TLS_GD))
13924 {
e717da7e
AM		 13925 loc = relgot->contents;
13926 loc += (relgot->reloc_count++
d881513a
AM		 13927 * sizeof (Elf64_External_Rela));
13928 bfd_elf64_swap_reloca_out (output_bfd,
13929 &outrel, loc);
e515b051 13930 outrel.r_offset += 8;
4cc603a5 13931 outrel.r_addend = addend;
d881513a
AM		 13932 outrel.r_info
13933 = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
d881513a 13934 }
411e1bfb 13935 }
951fd09b 13936 else if (tls_type == (TLS_TLS | TLS_DTPREL))
411e1bfb 13937 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_DTPREL64);
951fd09b 13938 else if (tls_type == (TLS_TLS | TLS_TPREL))
411e1bfb 13939 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_TPREL64);
25f23106
AM		 13940 else if (indx != 0)
13941 outrel.r_info = ELF64_R_INFO (indx, R_PPC64_GLOB_DAT);
13942 else
81407a69 13943 {
25f23106
AM		 13944 if (ifunc)
13945 outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
13946 else
13947 outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
81407a69
AM		 13948
13949 /* Write the .got section contents for the sake
13950 of prelink. */
e717da7e 13951 loc = got->contents + off;
23fbd6fa
JJ		 13952 bfd_put_64 (output_bfd, outrel.r_addend + relocation,
13953 loc);
81407a69 13954 }
81407a69
AM		 13955
13956 if (indx == 0 && tls_type != (TLS_TLS | TLS_LD))
e515b051
AM		 13957 {
13958 outrel.r_addend += relocation;
13959 if (tls_type & (TLS_GD | TLS_DTPREL | TLS_TPREL))
e1918d23 13960 outrel.r_addend -= htab->elf.tls_sec->vma;
e515b051 13961 }
e717da7e
AM		 13962 loc = relgot->contents;
13963 loc += (relgot->reloc_count++
411e1bfb
AM		 13964 * sizeof (Elf64_External_Rela));
13965 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
13966 }
13967
ad8e1ba5 13968 /* Init the .got section contents here if we're not
81407a69 13969 emitting a reloc. */
d881513a 13970 else
411e1bfb 13971 {
4cc603a5 13972 relocation += addend;
7b609f53
AM		 13973 if (tls_type == (TLS_TLS | TLS_LD))
13974 relocation = 1;
13975 else if (tls_type != 0)
411e1bfb 13976 {
e1918d23 13977 relocation -= htab->elf.tls_sec->vma + DTP_OFFSET;
7b609f53 13978 if (tls_type == (TLS_TLS | TLS_TPREL))
411e1bfb 13979 relocation += DTP_OFFSET - TP_OFFSET;
5bd4f169 13980
7b609f53
AM		 13981 if (tls_type == (TLS_TLS | TLS_GD))
13982 {
13983 bfd_put_64 (output_bfd, relocation,
e717da7e 13984 got->contents + off + 8);
7b609f53
AM		 13985 relocation = 1;
13986 }
411e1bfb 13987 }
7b609f53 13988
411e1bfb 13989 bfd_put_64 (output_bfd, relocation,
e717da7e 13990 got->contents + off);
5bd4f169
AM		 13991 }
13992 }
13993
65f38f15
AM		 13994 if (off >= (bfd_vma) -2)
13995 abort ();
13996
bf102f86
AM		 13997 relocation = got->output_section->vma + got->output_offset + off;
13998 addend = -(TOCstart + htab->stub_group[input_section->id].toc_off);
5bd4f169 13999 }
65f38f15
AM		 14000 break;
14001
14002 case R_PPC64_PLT16_HA:
14003 case R_PPC64_PLT16_HI:
14004 case R_PPC64_PLT16_LO:
14005 case R_PPC64_PLT32:
14006 case R_PPC64_PLT64:
14007 /* Relocation is to the entry for this symbol in the
14008 procedure linkage table. */
14009
14010 /* Resolve a PLT reloc against a local symbol directly,
14011 without using the procedure linkage table. */
14012 if (h == NULL)
14013 break;
14014
411e1bfb
AM		 14015 /* It's possible that we didn't make a PLT entry for this
14016 symbol. This happens when statically linking PIC code,
14017 or when using -Bsymbolic. Go find a match if there is a
14018 PLT entry. */
33e44f2e 14019 if (htab->elf.splt != NULL)
65f38f15 14020 {
411e1bfb 14021 struct plt_entry *ent;
039b3fef 14022 for (ent = h->elf.plt.plist; ent != NULL; ent = ent->next)
a345bc8d
AM		 14023 if (ent->plt.offset != (bfd_vma) -1
14024 && ent->addend == orig_rel.r_addend)
411e1bfb 14025 {
33e44f2e
AM		 14026 relocation = (htab->elf.splt->output_section->vma
14027 + htab->elf.splt->output_offset
411e1bfb
AM		 14028 + ent->plt.offset);
14029 unresolved_reloc = FALSE;
a345bc8d 14030 break;
411e1bfb 14031 }
65f38f15 14032 }
65f38f15 14033 break;
5bd4f169 14034
0b13192e
AM		 14035 case R_PPC64_TOC:
14036 /* Relocation value is TOC base. */
14037 relocation = TOCstart;
cf35638d 14038 if (r_symndx == STN_UNDEF)
0b13192e 14039 relocation += htab->stub_group[input_section->id].toc_off;
8517fae7
AM		 14040 else if (unresolved_reloc)
14041 ;
14042 else if (sec != NULL && sec->id <= htab->top_id)
0b13192e
AM		 14043 relocation += htab->stub_group[sec->id].toc_off;
14044 else
14045 unresolved_reloc = TRUE;
ab96bf03 14046 goto dodyn;
0b13192e 14047
5bd4f169
AM		 14048 /* TOC16 relocs. We want the offset relative to the TOC base,
14049 which is the address of the start of the TOC plus 0x8000.
14050 The TOC consists of sections .got, .toc, .tocbss, and .plt,
14051 in this order. */
65f38f15
AM		 14052 case R_PPC64_TOC16:
14053 case R_PPC64_TOC16_LO:
14054 case R_PPC64_TOC16_HI:
14055 case R_PPC64_TOC16_DS:
14056 case R_PPC64_TOC16_LO_DS:
14057 case R_PPC64_TOC16_HA:
ad8e1ba5 14058 addend -= TOCstart + htab->stub_group[input_section->id].toc_off;
5bd4f169
AM		 14059 break;
14060
14061 /* Relocate against the beginning of the section. */
65f38f15
AM		 14062 case R_PPC64_SECTOFF:
14063 case R_PPC64_SECTOFF_LO:
14064 case R_PPC64_SECTOFF_HI:
14065 case R_PPC64_SECTOFF_DS:
14066 case R_PPC64_SECTOFF_LO_DS:
14067 case R_PPC64_SECTOFF_HA:
4ce794b7 14068 if (sec != NULL)
65f38f15 14069 addend -= sec->output_section->vma;
5bd4f169
AM		 14070 break;
14071
25f23106
AM		 14072 case R_PPC64_REL16:
14073 case R_PPC64_REL16_LO:
14074 case R_PPC64_REL16_HI:
14075 case R_PPC64_REL16_HA:
14076 break;
14077
721956f4
AM		 14078 case R_PPC64_REL14:
14079 case R_PPC64_REL14_BRNTAKEN:
14080 case R_PPC64_REL14_BRTAKEN:
5d1634d7
AM		 14081 case R_PPC64_REL24:
14082 break;
14083
411e1bfb
AM		 14084 case R_PPC64_TPREL16:
14085 case R_PPC64_TPREL16_LO:
14086 case R_PPC64_TPREL16_HI:
14087 case R_PPC64_TPREL16_HA:
14088 case R_PPC64_TPREL16_DS:
14089 case R_PPC64_TPREL16_LO_DS:
f9c6b907
AM		 14090 case R_PPC64_TPREL16_HIGH:
14091 case R_PPC64_TPREL16_HIGHA:
411e1bfb
AM		 14092 case R_PPC64_TPREL16_HIGHER:
14093 case R_PPC64_TPREL16_HIGHERA:
14094 case R_PPC64_TPREL16_HIGHEST:
14095 case R_PPC64_TPREL16_HIGHESTA:
766bc656
AM		 14096 if (h != NULL
14097 && h->elf.root.type == bfd_link_hash_undefweak
14098 && h->elf.dynindx == -1)
14099 {
14100 /* Make this relocation against an undefined weak symbol
14101 resolve to zero. This is really just a tweak, since
14102 code using weak externs ought to check that they are
14103 defined before using them. */
14104 bfd_byte *p = contents + rel->r_offset - d_offset;
14105
14106 insn = bfd_get_32 (output_bfd, p);
14107 insn = _bfd_elf_ppc_at_tprel_transform (insn, 13);
14108 if (insn != 0)
14109 bfd_put_32 (output_bfd, insn, p);
14110 break;
14111 }
e1918d23 14112 addend -= htab->elf.tls_sec->vma + TP_OFFSET;
411e1bfb
AM		 14113 if (info->shared)
14114 /* The TPREL16 relocs shouldn't really be used in shared
14115 libs as they will result in DT_TEXTREL being set, but
14116 support them anyway. */
14117 goto dodyn;
14118 break;
14119
14120 case R_PPC64_DTPREL16:
14121 case R_PPC64_DTPREL16_LO:
14122 case R_PPC64_DTPREL16_HI:
14123 case R_PPC64_DTPREL16_HA:
14124 case R_PPC64_DTPREL16_DS:
14125 case R_PPC64_DTPREL16_LO_DS:
f9c6b907
AM		 14126 case R_PPC64_DTPREL16_HIGH:
14127 case R_PPC64_DTPREL16_HIGHA:
411e1bfb
AM		 14128 case R_PPC64_DTPREL16_HIGHER:
14129 case R_PPC64_DTPREL16_HIGHERA:
14130 case R_PPC64_DTPREL16_HIGHEST:
14131 case R_PPC64_DTPREL16_HIGHESTA:
e1918d23 14132 addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
411e1bfb
AM		 14133 break;
14134
e515b051
AM		 14135 case R_PPC64_DTPMOD64:
14136 relocation = 1;
14137 addend = 0;
14138 goto dodyn;
14139
411e1bfb 14140 case R_PPC64_TPREL64:
e1918d23 14141 addend -= htab->elf.tls_sec->vma + TP_OFFSET;
411e1bfb
AM		 14142 goto dodyn;
14143
14144 case R_PPC64_DTPREL64:
e1918d23 14145 addend -= htab->elf.tls_sec->vma + DTP_OFFSET;
411e1bfb
AM		 14146 /* Fall thru */
14147
65f38f15
AM		 14148 /* Relocations that may need to be propagated if this is a
14149 dynamic object. */
04c9666a 14150 case R_PPC64_REL30:
65f38f15
AM		 14151 case R_PPC64_REL32:
14152 case R_PPC64_REL64:
14153 case R_PPC64_ADDR14:
14154 case R_PPC64_ADDR14_BRNTAKEN:
14155 case R_PPC64_ADDR14_BRTAKEN:
14156 case R_PPC64_ADDR16:
14157 case R_PPC64_ADDR16_DS:
14158 case R_PPC64_ADDR16_HA:
14159 case R_PPC64_ADDR16_HI:
f9c6b907
AM		 14160 case R_PPC64_ADDR16_HIGH:
14161 case R_PPC64_ADDR16_HIGHA:
65f38f15
AM		 14162 case R_PPC64_ADDR16_HIGHER:
14163 case R_PPC64_ADDR16_HIGHERA:
14164 case R_PPC64_ADDR16_HIGHEST:
14165 case R_PPC64_ADDR16_HIGHESTA:
14166 case R_PPC64_ADDR16_LO:
14167 case R_PPC64_ADDR16_LO_DS:
14168 case R_PPC64_ADDR24:
65f38f15
AM		 14169 case R_PPC64_ADDR32:
14170 case R_PPC64_ADDR64:
14171 case R_PPC64_UADDR16:
14172 case R_PPC64_UADDR32:
14173 case R_PPC64_UADDR64:
411e1bfb 14174 dodyn:
5d1634d7 14175 if ((input_section->flags & SEC_ALLOC) == 0)
ec338859
AM		 14176 break;
14177
41bd81ab
AM		 14178 if (NO_OPD_RELOCS && is_opd)
14179 break;
14180
65f38f15 14181 if ((info->shared
4e795f50 14182 && (h == NULL
039b3fef
AM		 14183 || ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
14184 || h->elf.root.type != bfd_link_hash_undefweak)
1d483afe 14185 && (must_be_dyn_reloc (info, r_type)
039b3fef 14186 || !SYMBOL_CALLS_LOCAL (info, &h->elf)))
f4656909
AM		 14187 || (ELIMINATE_COPY_RELOCS
14188 && !info->shared
65f38f15 14189 && h != NULL
039b3fef 14190 && h->elf.dynindx != -1
f5385ebf 14191 && !h->elf.non_got_ref
25f23106
AM		 14192 && !h->elf.def_regular)
14193 || (!info->shared
14194 && (h != NULL
14195 ? h->elf.type == STT_GNU_IFUNC
14196 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)))
65f38f15 14197 {
b34976b6 14198 bfd_boolean skip, relocate;
65f38f15 14199 asection *sreloc;
1cf1f670 14200 bfd_vma out_off;
65f38f15
AM		 14201
14202 /* When generating a dynamic object, these relocations
14203 are copied into the output file to be resolved at run
14204 time. */
14205
b34976b6
AM		 14206 skip = FALSE;
14207 relocate = FALSE;
65f38f15 14208
1cf1f670
AM		 14209 out_off = _bfd_elf_section_offset (output_bfd, info,
14210 input_section, rel->r_offset);
14211 if (out_off == (bfd_vma) -1)
b34976b6 14212 skip = TRUE;
1cf1f670 14213 else if (out_off == (bfd_vma) -2)
b34976b6 14214 skip = TRUE, relocate = TRUE;
1cf1f670
AM		 14215 out_off += (input_section->output_section->vma
14216 + input_section->output_offset);
14217 outrel.r_offset = out_off;
411e1bfb 14218 outrel.r_addend = rel->r_addend;
65f38f15 14219
1cf1f670
AM		 14220 /* Optimize unaligned reloc use. */
14221 if ((r_type == R_PPC64_ADDR64 && (out_off & 7) != 0)
14222 || (r_type == R_PPC64_UADDR64 && (out_off & 7) == 0))
14223 r_type ^= R_PPC64_ADDR64 ^ R_PPC64_UADDR64;
14224 else if ((r_type == R_PPC64_ADDR32 && (out_off & 3) != 0)
14225 || (r_type == R_PPC64_UADDR32 && (out_off & 3) == 0))
14226 r_type ^= R_PPC64_ADDR32 ^ R_PPC64_UADDR32;
14227 else if ((r_type == R_PPC64_ADDR16 && (out_off & 1) != 0)
14228 || (r_type == R_PPC64_UADDR16 && (out_off & 1) == 0))
14229 r_type ^= R_PPC64_ADDR16 ^ R_PPC64_UADDR16;
14230
65f38f15 14231 if (skip)
0bb2d96a 14232 memset (&outrel, 0, sizeof outrel);
726d3ab0 14233 else if (!SYMBOL_CALLS_LOCAL (info, &h->elf)
0b13192e
AM		 14234 && !is_opd
14235 && r_type != R_PPC64_TOC)
14acf4dc
MR		 14236 {
14237 BFD_ASSERT (h->elf.dynindx != -1);
14238 outrel.r_info = ELF64_R_INFO (h->elf.dynindx, r_type);
14239 }
65f38f15
AM		 14240 else
14241 {
41bd81ab
AM		 14242 /* This symbol is local, or marked to become local,
14243 or this is an opd section reloc which must point
14244 at a local function. */
65f38f15 14245 outrel.r_addend += relocation;
e86ce104 14246 if (r_type == R_PPC64_ADDR64 || r_type == R_PPC64_TOC)
65f38f15 14247 {
3fad3c7c 14248 if (is_opd && h != NULL)
afbe61cf
AM		 14249 {
14250 /* Lie about opd entries. This case occurs
14251 when building shared libraries and we
14252 reference a function in another shared
3fad3c7c
AM		 14253 lib. The same thing happens for a weak
14254 definition in an application that's
14255 overridden by a strong definition in a
14256 shared lib. (I believe this is a generic
14257 bug in binutils handling of weak syms.)
14258 In these cases we won't use the opd
1e2f5b6e 14259 entry in this lib. */
b34976b6 14260 unresolved_reloc = FALSE;
afbe61cf 14261 }
25f23106
AM		 14262 if (!is_opd
14263 && r_type == R_PPC64_ADDR64
14264 && (h != NULL
14265 ? h->elf.type == STT_GNU_IFUNC
14266 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC))
14267 outrel.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
14268 else
14269 {
14270 outrel.r_info = ELF64_R_INFO (0, R_PPC64_RELATIVE);
81407a69 14271
25f23106
AM		 14272 /* We need to relocate .opd contents for ld.so.
14273 Prelink also wants simple and consistent rules
14274 for relocs. This make all RELATIVE relocs have
14275 *r_offset equal to r_addend. */
14276 relocate = TRUE;
14277 }
65f38f15
AM		 14278 }
14279 else
14280 {
14281 long indx = 0;
14282
25f23106
AM		 14283 if (h != NULL
14284 ? h->elf.type == STT_GNU_IFUNC
14285 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
14286 {
25f53a85 14287 info->callbacks->einfo
bc30df16
AM		 14288 (_("%P: %H: %s for indirect "
14289 "function `%T' unsupported\n"),
25f53a85 14290 input_bfd, input_section, rel->r_offset,
25f23106
AM		 14291 ppc64_elf_howto_table[r_type]->name,
14292 sym_name);
14293 ret = FALSE;
14294 }
cf35638d 14295 else if (r_symndx == STN_UNDEF || bfd_is_abs_section (sec))
65f38f15
AM		 14296 ;
14297 else if (sec == NULL || sec->owner == NULL)
14298 {
14299 bfd_set_error (bfd_error_bad_value);
b34976b6 14300 return FALSE;
65f38f15
AM		 14301 }
14302 else
14303 {
14304 asection *osec;
14305
14306 osec = sec->output_section;
14307 indx = elf_section_data (osec)->dynindx;
14308
74541ad4
AM		 14309 if (indx == 0)
14310 {
14311 if ((osec->flags & SEC_READONLY) == 0
14312 && htab->elf.data_index_section != NULL)
14313 osec = htab->elf.data_index_section;
14314 else
14315 osec = htab->elf.text_index_section;
14316 indx = elf_section_data (osec)->dynindx;
14317 }
14318 BFD_ASSERT (indx != 0);
14319
65f38f15
AM		 14320 /* We are turning this relocation into one
14321 against a section symbol, so subtract out
14322 the output section's address but not the
14323 offset of the input section in the output
14324 section. */
14325 outrel.r_addend -= osec->vma;
14326 }
14327
14328 outrel.r_info = ELF64_R_INFO (indx, r_type);
14329 }
14330 }
14331
14332 sreloc = elf_section_data (input_section)->sreloc;
19e08130
AM		 14333 if (h != NULL
14334 ? h->elf.type == STT_GNU_IFUNC
14335 : ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
33e44f2e 14336 sreloc = htab->elf.irelplt;
65f38f15
AM		 14337 if (sreloc == NULL)
14338 abort ();
14339
dfbb6ac9
AM		 14340 if (sreloc->reloc_count * sizeof (Elf64_External_Rela)
14341 >= sreloc->size)
14342 abort ();
947216bf
AM		 14343 loc = sreloc->contents;
14344 loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
65f38f15
AM		 14345 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
14346
14347 /* If this reloc is against an external symbol, it will
14348 be computed at runtime, so there's no need to do
81407a69
AM		 14349 anything now. However, for the sake of prelink ensure
14350 that the section contents are a known value. */
65f38f15 14351 if (! relocate)
81407a69
AM		 14352 {
14353 unresolved_reloc = FALSE;
14354 /* The value chosen here is quite arbitrary as ld.so
14355 ignores section contents except for the special
14356 case of .opd where the contents might be accessed
14357 before relocation. Choose zero, as that won't
14358 cause reloc overflow. */
14359 relocation = 0;
14360 addend = 0;
14361 /* Use *r_offset == r_addend for R_PPC64_ADDR64 relocs
14362 to improve backward compatibility with older
14363 versions of ld. */
14364 if (r_type == R_PPC64_ADDR64)
14365 addend = outrel.r_addend;
14366 /* Adjust pc_relative relocs to have zero in *r_offset. */
4ce794b7 14367 else if (ppc64_elf_howto_table[r_type]->pc_relative)
000732f7
AM		 14368 addend = (input_section->output_section->vma
14369 + input_section->output_offset
14370 + rel->r_offset);
81407a69 14371 }
65f38f15 14372 }
5bd4f169
AM		 14373 break;
14374
65f38f15
AM		 14375 case R_PPC64_COPY:
14376 case R_PPC64_GLOB_DAT:
14377 case R_PPC64_JMP_SLOT:
25f23106 14378 case R_PPC64_JMP_IREL:
65f38f15
AM		 14379 case R_PPC64_RELATIVE:
14380 /* We shouldn't ever see these dynamic relocs in relocatable
14381 files. */
ae9a127f 14382 /* Fall through. */
65f38f15
AM		 14383
14384 case R_PPC64_PLTGOT16:
14385 case R_PPC64_PLTGOT16_DS:
14386 case R_PPC64_PLTGOT16_HA:
14387 case R_PPC64_PLTGOT16_HI:
14388 case R_PPC64_PLTGOT16_LO:
14389 case R_PPC64_PLTGOT16_LO_DS:
14390 case R_PPC64_PLTREL32:
14391 case R_PPC64_PLTREL64:
14392 /* These ones haven't been implemented yet. */
14393
25f53a85 14394 info->callbacks->einfo
bc30df16 14395 (_("%P: %B: %s is not supported for `%T'\n"),
d003868e 14396 input_bfd,
4ce794b7 14397 ppc64_elf_howto_table[r_type]->name, sym_name);
5bd4f169
AM		 14398
14399 bfd_set_error (bfd_error_invalid_operation);
b34976b6 14400 ret = FALSE;
5bd4f169 14401 continue;
65f38f15 14402 }
5bd4f169 14403
67f0cbdb
AM		 14404 /* Multi-instruction sequences that access the TOC can be
14405 optimized, eg. addis ra,r2,0; addi rb,ra,x;
14406 to nop; addi rb,r2,x; */
14407 switch (r_type)
14408 {
14409 default:
14410 break;
14411
14412 case R_PPC64_GOT_TLSLD16_HI:
14413 case R_PPC64_GOT_TLSGD16_HI:
14414 case R_PPC64_GOT_TPREL16_HI:
14415 case R_PPC64_GOT_DTPREL16_HI:
14416 case R_PPC64_GOT16_HI:
14417 case R_PPC64_TOC16_HI:
14418 /* These relocs would only be useful if building up an
14419 offset to later add to r2, perhaps in an indexed
14420 addressing mode instruction. Don't try to optimize.
14421 Unfortunately, the possibility of someone building up an
14422 offset like this or even with the HA relocs, means that
14423 we need to check the high insn when optimizing the low
14424 insn. */
14425 break;
14426
14427 case R_PPC64_GOT_TLSLD16_HA:
14428 case R_PPC64_GOT_TLSGD16_HA:
14429 case R_PPC64_GOT_TPREL16_HA:
14430 case R_PPC64_GOT_DTPREL16_HA:
14431 case R_PPC64_GOT16_HA:
14432 case R_PPC64_TOC16_HA:
98528052 14433 if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
560c8763 14434 && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
98528052
AM		 14435 {
14436 bfd_byte *p = contents + (rel->r_offset & ~3);
14437 bfd_put_32 (input_bfd, NOP, p);
14438 }
67f0cbdb
AM		 14439 break;
14440
14441 case R_PPC64_GOT_TLSLD16_LO:
14442 case R_PPC64_GOT_TLSGD16_LO:
14443 case R_PPC64_GOT_TPREL16_LO_DS:
14444 case R_PPC64_GOT_DTPREL16_LO_DS:
14445 case R_PPC64_GOT16_LO:
14446 case R_PPC64_GOT16_LO_DS:
14447 case R_PPC64_TOC16_LO:
14448 case R_PPC64_TOC16_LO_DS:
98528052 14449 if (htab->do_toc_opt && relocation + addend + 0x8000 < 0x10000
560c8763 14450 && !ppc64_elf_tdata (input_bfd)->unexpected_toc_insn)
67f0cbdb
AM		 14451 {
14452 bfd_byte *p = contents + (rel->r_offset & ~3);
14453 insn = bfd_get_32 (input_bfd, p);
560c8763
AM		 14454 if ((insn & (0x3f << 26)) == 12u << 26 /* addic */)
14455 {
14456 /* Transform addic to addi when we change reg. */
14457 insn &= ~((0x3f << 26) | (0x1f << 16));
14458 insn |= (14u << 26) | (2 << 16);
14459 }
14460 else
67f0cbdb 14461 {
98528052
AM		 14462 insn &= ~(0x1f << 16);
14463 insn |= 2 << 16;
67f0cbdb 14464 }
560c8763 14465 bfd_put_32 (input_bfd, insn, p);
67f0cbdb
AM		 14466 }
14467 break;
14468 }
14469
65f38f15
AM		 14470 /* Do any further special processing. */
14471 switch (r_type)
14472 {
14473 default:
14474 break;
14475
25f23106 14476 case R_PPC64_REL16_HA:
f9c6b907
AM		 14477 case R_PPC64_ADDR16_HA:
14478 case R_PPC64_ADDR16_HIGHA:
65f38f15
AM		 14479 case R_PPC64_ADDR16_HIGHERA:
14480 case R_PPC64_ADDR16_HIGHESTA:
65f38f15
AM		 14481 case R_PPC64_TOC16_HA:
14482 case R_PPC64_SECTOFF_HA:
411e1bfb 14483 case R_PPC64_TPREL16_HA:
f9c6b907 14484 case R_PPC64_TPREL16_HIGHA:
411e1bfb 14485 case R_PPC64_TPREL16_HIGHERA:
411e1bfb 14486 case R_PPC64_TPREL16_HIGHESTA:
f9c6b907
AM		 14487 case R_PPC64_DTPREL16_HA:
14488 case R_PPC64_DTPREL16_HIGHA:
411e1bfb 14489 case R_PPC64_DTPREL16_HIGHERA:
411e1bfb 14490 case R_PPC64_DTPREL16_HIGHESTA:
65f38f15
AM		 14491 /* It's just possible that this symbol is a weak symbol
14492 that's not actually defined anywhere. In that case,
14493 'sec' would be NULL, and we should leave the symbol
14494 alone (it will be set to zero elsewhere in the link). */
5c5f6e17
AM		 14495 if (sec == NULL)
14496 break;
14497 /* Fall thru */
14498
14499 case R_PPC64_GOT16_HA:
14500 case R_PPC64_PLTGOT16_HA:
14501 case R_PPC64_PLT16_HA:
14502 case R_PPC64_GOT_TLSGD16_HA:
14503 case R_PPC64_GOT_TLSLD16_HA:
14504 case R_PPC64_GOT_TPREL16_HA:
14505 case R_PPC64_GOT_DTPREL16_HA:
14506 /* Add 0x10000 if sign bit in 0:15 is set.
14507 Bits 0:15 are not used. */
14508 addend += 0x8000;
65f38f15
AM		 14509 break;
14510
14511 case R_PPC64_ADDR16_DS:
14512 case R_PPC64_ADDR16_LO_DS:
14513 case R_PPC64_GOT16_DS:
14514 case R_PPC64_GOT16_LO_DS:
14515 case R_PPC64_PLT16_LO_DS:
14516 case R_PPC64_SECTOFF_DS:
14517 case R_PPC64_SECTOFF_LO_DS:
14518 case R_PPC64_TOC16_DS:
14519 case R_PPC64_TOC16_LO_DS:
14520 case R_PPC64_PLTGOT16_DS:
14521 case R_PPC64_PLTGOT16_LO_DS:
411e1bfb
AM		 14522 case R_PPC64_GOT_TPREL16_DS:
14523 case R_PPC64_GOT_TPREL16_LO_DS:
14524 case R_PPC64_GOT_DTPREL16_DS:
14525 case R_PPC64_GOT_DTPREL16_LO_DS:
14526 case R_PPC64_TPREL16_DS:
14527 case R_PPC64_TPREL16_LO_DS:
14528 case R_PPC64_DTPREL16_DS:
14529 case R_PPC64_DTPREL16_LO_DS:
adadcc0c
AM		 14530 insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3));
14531 mask = 3;
14532 /* If this reloc is against an lq insn, then the value must be
14533 a multiple of 16. This is somewhat of a hack, but the
14534 "correct" way to do this by defining _DQ forms of all the
14535 _DS relocs bloats all reloc switches in this file. It
14536 doesn't seem to make much sense to use any of these relocs
14537 in data, so testing the insn should be safe. */
494dac0c 14538 if ((insn & (0x3f << 26)) == (56u << 26))
adadcc0c
AM		 14539 mask = 15;
14540 if (((relocation + addend) & mask) != 0)
65f38f15 14541 {
25f53a85 14542 info->callbacks->einfo
8de848d8 14543 (_("%P: %H: error: %s not a multiple of %u\n"),
25f53a85 14544 input_bfd, input_section, rel->r_offset,
4ce794b7 14545 ppc64_elf_howto_table[r_type]->name,
adadcc0c 14546 mask + 1);
65f38f15 14547 bfd_set_error (bfd_error_bad_value);
b34976b6 14548 ret = FALSE;
65f38f15
AM		 14549 continue;
14550 }
14551 break;
5bd4f169
AM		 14552 }
14553
239e1f3a
AM		 14554 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
14555 because such sections are not SEC_ALLOC and thus ld.so will
14556 not process them. */
65f38f15 14557 if (unresolved_reloc
239e1f3a 14558 && !((input_section->flags & SEC_DEBUGGING) != 0
1d5316ab
AM		 14559 && h->elf.def_dynamic)
14560 && _bfd_elf_section_offset (output_bfd, info, input_section,
14561 rel->r_offset) != (bfd_vma) -1)
9c07fe7c 14562 {
25f53a85 14563 info->callbacks->einfo
bc30df16 14564 (_("%P: %H: unresolvable %s against `%T'\n"),
25f53a85 14565 input_bfd, input_section, rel->r_offset,
7b609f53 14566 ppc64_elf_howto_table[(int) r_type]->name,
039b3fef 14567 h->elf.root.root.string);
b34976b6 14568 ret = FALSE;
9c07fe7c 14569 }
5bd4f169 14570
65f38f15 14571 r = _bfd_final_link_relocate (ppc64_elf_howto_table[(int) r_type],
5bd4f169
AM		 14572 input_bfd,
14573 input_section,
14574 contents,
411e1bfb 14575 rel->r_offset,
5bd4f169
AM		 14576 relocation,
14577 addend);
14578
ef60b7ff 14579 if (r != bfd_reloc_ok)
5bd4f169 14580 {
bc30df16
AM		 14581 char *more_info = NULL;
14582 const char *reloc_name = ppc64_elf_howto_table[r_type]->name;
14583
14584 if (reloc_dest != DEST_NORMAL)
14585 {
14586 more_info = bfd_malloc (strlen (reloc_name) + 8);
14587 if (more_info != NULL)
14588 {
14589 strcpy (more_info, reloc_name);
14590 strcat (more_info, (reloc_dest == DEST_OPD
14591 ? " (OPD)" : " (stub)"));
14592 reloc_name = more_info;
14593 }
14594 }
14595
cd27b276 14596 if (r == bfd_reloc_overflow)
5bd4f169 14597 {
cd27b276
AM		 14598 if (warned)
14599 continue;
14600 if (h != NULL
039b3fef 14601 && h->elf.root.type == bfd_link_hash_undefweak
4ce794b7 14602 && ppc64_elf_howto_table[r_type]->pc_relative)
5bd4f169
AM		 14603 {
14604 /* Assume this is a call protected by other code that
14605 detects the symbol is undefined. If this is the case,
14606 we can safely ignore the overflow. If not, the
14607 program is hosed anyway, and a little warning isn't
14608 going to help. */
14609
14610 continue;
14611 }
14612
ef60b7ff 14613 if (!((*info->callbacks->reloc_overflow)
bc30df16
AM		 14614 (info, &h->elf.root, sym_name,
14615 reloc_name, orig_rel.r_addend,
14616 input_bfd, input_section, rel->r_offset)))
b34976b6 14617 return FALSE;
ef60b7ff
AM		 14618 }
14619 else
14620 {
25f53a85 14621 info->callbacks->einfo
bc30df16 14622 (_("%P: %H: %s against `%T': error %d\n"),
25f53a85 14623 input_bfd, input_section, rel->r_offset,
bc30df16 14624 reloc_name, sym_name, (int) r);
b34976b6 14625 ret = FALSE;
ef60b7ff 14626 }
bc30df16
AM		 14627 if (more_info != NULL)
14628 free (more_info);
5bd4f169 14629 }
5bd4f169
AM		 14630 }
14631
645ea6a9
AM		 14632 /* If we're emitting relocations, then shortly after this function
14633 returns, reloc offsets and addends for this section will be
14634 adjusted. Worse, reloc symbol indices will be for the output
8860955f
AM		 14635 file rather than the input. Save a copy of the relocs for
14636 opd_entry_value. */
4cc603a5 14637 if (is_opd && (info->emitrelocations || info->relocatable))
8860955f
AM		 14638 {
14639 bfd_size_type amt;
14640 amt = input_section->reloc_count * sizeof (Elf_Internal_Rela);
14641 rel = bfd_alloc (input_bfd, amt);
729eabd5
AM		 14642 BFD_ASSERT (ppc64_elf_tdata (input_bfd)->opd.relocs == NULL);
14643 ppc64_elf_tdata (input_bfd)->opd.relocs = rel;
8860955f
AM		 14644 if (rel == NULL)
14645 return FALSE;
14646 memcpy (rel, relocs, amt);
14647 }
5bd4f169
AM		 14648 return ret;
14649}
14650
754021d0
AM		 14651/* Adjust the value of any local symbols in opd sections. */
14652
6e0b88f1 14653static int
754021d0
AM		 14654ppc64_elf_output_symbol_hook (struct bfd_link_info *info,
14655 const char *name ATTRIBUTE_UNUSED,
14656 Elf_Internal_Sym *elfsym,
14657 asection *input_sec,
14658 struct elf_link_hash_entry *h)
14659{
74f0fb50
AM		 14660 struct _opd_sec_data *opd;
14661 long adjust;
754021d0
AM		 14662 bfd_vma value;
14663
4025353c 14664 if (h != NULL)
6e0b88f1 14665 return 1;
4025353c 14666
74f0fb50
AM		 14667 opd = get_opd_info (input_sec);
14668 if (opd == NULL || opd->adjust == NULL)
6e0b88f1 14669 return 1;
754021d0
AM		 14670
14671 value = elfsym->st_value - input_sec->output_offset;
14672 if (!info->relocatable)
14673 value -= input_sec->output_section->vma;
14674
74f0fb50 14675 adjust = opd->adjust[value / 8];
4025353c 14676 if (adjust == -1)
6e0b88f1
AM		 14677 return 2;
14678
14679 elfsym->st_value += adjust;
14680 return 1;
754021d0
AM		 14681}
14682
5bd4f169
AM		 14683/* Finish up dynamic symbol handling. We set the contents of various
14684 dynamic sections here. */
14685
b34976b6 14686static bfd_boolean
4ce794b7
AM		 14687ppc64_elf_finish_dynamic_symbol (bfd *output_bfd,
14688 struct bfd_link_info *info,
14689 struct elf_link_hash_entry *h,
ab6dce23 14690 Elf_Internal_Sym *sym ATTRIBUTE_UNUSED)
5bd4f169 14691{
65f38f15 14692 struct ppc_link_hash_table *htab;
8387904d
AM		 14693 struct plt_entry *ent;
14694 Elf_Internal_Rela rela;
14695 bfd_byte *loc;
5bd4f169 14696
65f38f15 14697 htab = ppc_hash_table (info);
4dfe6ac6
NC		 14698 if (htab == NULL)
14699 return FALSE;
5bd4f169 14700
8387904d
AM		 14701 for (ent = h->plt.plist; ent != NULL; ent = ent->next)
14702 if (ent->plt.offset != (bfd_vma) -1)
14703 {
14704 /* This symbol has an entry in the procedure linkage
14705 table. Set it up. */
e054468f
AM		 14706 if (!htab->elf.dynamic_sections_created
14707 || h->dynindx == -1)
14708 {
14709 BFD_ASSERT (h->type == STT_GNU_IFUNC
14710 && h->def_regular
14711 && (h->root.type == bfd_link_hash_defined
14712 || h->root.type == bfd_link_hash_defweak));
33e44f2e
AM		 14713 rela.r_offset = (htab->elf.iplt->output_section->vma
14714 + htab->elf.iplt->output_offset
25f23106 14715 + ent->plt.offset);
ee67d69a
AM		 14716 if (htab->opd_abi)
14717 rela.r_info = ELF64_R_INFO (0, R_PPC64_JMP_IREL);
14718 else
14719 rela.r_info = ELF64_R_INFO (0, R_PPC64_IRELATIVE);
e054468f
AM		 14720 rela.r_addend = (h->root.u.def.value
14721 + h->root.u.def.section->output_offset
14722 + h->root.u.def.section->output_section->vma
14723 + ent->addend);
33e44f2e
AM		 14724 loc = (htab->elf.irelplt->contents
14725 + (htab->elf.irelplt->reloc_count++
25f23106 14726 * sizeof (Elf64_External_Rela)));
e054468f
AM		 14727 }
14728 else
14729 {
33e44f2e
AM		 14730 rela.r_offset = (htab->elf.splt->output_section->vma
14731 + htab->elf.splt->output_offset
25f23106 14732 + ent->plt.offset);
e054468f
AM		 14733 rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_JMP_SLOT);
14734 rela.r_addend = ent->addend;
33e44f2e 14735 loc = (htab->elf.srelplt->contents
b9e5796b
AM		 14736 + ((ent->plt.offset - PLT_INITIAL_ENTRY_SIZE (htab))
14737 / PLT_ENTRY_SIZE (htab) * sizeof (Elf64_External_Rela)));
e054468f 14738 }
8387904d 14739 bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
a345bc8d
AM		 14740
14741 if (!htab->opd_abi)
14742 {
14743 if (!h->def_regular)
14744 {
14745 /* Mark the symbol as undefined, rather than as
14746 defined in glink. Leave the value if there were
14747 any relocations where pointer equality matters
14748 (this is a clue for the dynamic linker, to make
14749 function pointer comparisons work between an
14750 application and shared library), otherwise set it
14751 to zero. */
14752 sym->st_shndx = SHN_UNDEF;
14753 if (!h->pointer_equality_needed)
14754 sym->st_value = 0;
14755 else if (!h->ref_regular_nonweak)
14756 {
14757 /* This breaks function pointer comparisons, but
14758 that is better than breaking tests for a NULL
14759 function pointer. */
14760 sym->st_value = 0;
14761 }
14762 }
14763 }
8387904d 14764 }
5bd4f169 14765
f5385ebf 14766 if (h->needs_copy)
5bd4f169 14767 {
65f38f15 14768 /* This symbol needs a copy reloc. Set it up. */
5bd4f169 14769
65f38f15
AM		 14770 if (h->dynindx == -1
14771 || (h->root.type != bfd_link_hash_defined
14772 && h->root.type != bfd_link_hash_defweak)
4ce794b7 14773 || htab->relbss == NULL)
65f38f15 14774 abort ();
5bd4f169
AM		 14775
14776 rela.r_offset = (h->root.u.def.value
14777 + h->root.u.def.section->output_section->vma
14778 + h->root.u.def.section->output_offset);
14779 rela.r_info = ELF64_R_INFO (h->dynindx, R_PPC64_COPY);
14780 rela.r_addend = 0;
4ce794b7
AM		 14781 loc = htab->relbss->contents;
14782 loc += htab->relbss->reloc_count++ * sizeof (Elf64_External_Rela);
65f38f15 14783 bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
5bd4f169
AM		 14784 }
14785
b34976b6 14786 return TRUE;
5bd4f169
AM		 14787}
14788
65f38f15
AM		 14789/* Used to decide how to sort relocs in an optimal manner for the
14790 dynamic linker, before writing them out. */
14791
14792static enum elf_reloc_type_class
7e612e98
AM		 14793ppc64_elf_reloc_type_class (const struct bfd_link_info *info,
14794 const asection *rel_sec,
14795 const Elf_Internal_Rela *rela)
65f38f15 14796{
04c9666a 14797 enum elf_ppc64_reloc_type r_type;
7e612e98
AM		 14798 struct ppc_link_hash_table *htab = ppc_hash_table (info);
14799
33e44f2e 14800 if (rel_sec == htab->elf.irelplt)
7e612e98 14801 return reloc_class_ifunc;
a33d1f77 14802
4ce794b7 14803 r_type = ELF64_R_TYPE (rela->r_info);
a33d1f77 14804 switch (r_type)
65f38f15
AM		 14805 {
14806 case R_PPC64_RELATIVE:
14807 return reloc_class_relative;
14808 case R_PPC64_JMP_SLOT:
14809 return reloc_class_plt;
14810 case R_PPC64_COPY:
14811 return reloc_class_copy;
14812 default:
14813 return reloc_class_normal;
14814 }
14815}
14816
5bd4f169
AM		 14817/* Finish up the dynamic sections. */
14818
b34976b6 14819static bfd_boolean
4ce794b7
AM		 14820ppc64_elf_finish_dynamic_sections (bfd *output_bfd,
14821 struct bfd_link_info *info)
5bd4f169 14822{
65f38f15
AM		 14823 struct ppc_link_hash_table *htab;
14824 bfd *dynobj;
5bd4f169 14825 asection *sdyn;
5bd4f169 14826
65f38f15 14827 htab = ppc_hash_table (info);
4dfe6ac6
NC		 14828 if (htab == NULL)
14829 return FALSE;
14830
65f38f15 14831 dynobj = htab->elf.dynobj;
3d4d4302 14832 sdyn = bfd_get_linker_section (dynobj, ".dynamic");
5bd4f169 14833
65f38f15 14834 if (htab->elf.dynamic_sections_created)
5bd4f169 14835 {
5bd4f169
AM		 14836 Elf64_External_Dyn *dyncon, *dynconend;
14837
33e44f2e 14838 if (sdyn == NULL || htab->elf.sgot == NULL)
65f38f15 14839 abort ();
5bd4f169
AM		 14840
14841 dyncon = (Elf64_External_Dyn *) sdyn->contents;
eea6121a 14842 dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
5bd4f169
AM		 14843 for (; dyncon < dynconend; dyncon++)
14844 {
14845 Elf_Internal_Dyn dyn;
19397422 14846 asection *s;
5bd4f169
AM		 14847
14848 bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
14849
14850 switch (dyn.d_tag)
14851 {
65f38f15
AM		 14852 default:
14853 continue;
5bd4f169 14854
5d1634d7 14855 case DT_PPC64_GLINK:
4ce794b7 14856 s = htab->glink;
6348e046 14857 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
ad8e1ba5
AM		 14858 /* We stupidly defined DT_PPC64_GLINK to be the start
14859 of glink rather than the first entry point, which is
14860 what ld.so needs, and now have a bigger stub to
14861 support automatic multiple TOCs. */
b9e5796b 14862 dyn.d_un.d_ptr += GLINK_CALL_STUB_SIZE - 8 * 4;
5d1634d7
AM		 14863 break;
14864
19397422
AM		 14865 case DT_PPC64_OPD:
14866 s = bfd_get_section_by_name (output_bfd, ".opd");
6348e046
AM		 14867 if (s == NULL)
14868 continue;
14869 dyn.d_un.d_ptr = s->vma;
19397422
AM		 14870 break;
14871
e8910a83
AM		 14872 case DT_PPC64_OPT:
14873 if (htab->do_multi_toc && htab->multi_toc_needed)
14874 dyn.d_un.d_val |= PPC64_OPT_MULTI_TOC;
14875 break;
14876
19397422
AM		 14877 case DT_PPC64_OPDSZ:
14878 s = bfd_get_section_by_name (output_bfd, ".opd");
6348e046
AM		 14879 if (s == NULL)
14880 continue;
eea6121a 14881 dyn.d_un.d_val = s->size;
19397422
AM		 14882 break;
14883
65f38f15 14884 case DT_PLTGOT:
33e44f2e 14885 s = htab->elf.splt;
6348e046 14886 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
65f38f15
AM		 14887 break;
14888
14889 case DT_JMPREL:
33e44f2e 14890 s = htab->elf.srelplt;
6348e046 14891 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
65f38f15 14892 break;
5bd4f169 14893
65f38f15 14894 case DT_PLTRELSZ:
33e44f2e 14895 dyn.d_un.d_val = htab->elf.srelplt->size;
5d1634d7
AM		 14896 break;
14897
14898 case DT_RELASZ:
14899 /* Don't count procedure linkage table relocs in the
14900 overall reloc count. */
33e44f2e 14901 s = htab->elf.srelplt;
6348e046
AM		 14902 if (s == NULL)
14903 continue;
eea6121a 14904 dyn.d_un.d_val -= s->size;
6348e046
AM		 14905 break;
14906
14907 case DT_RELA:
14908 /* We may not be using the standard ELF linker script.
14909 If .rela.plt is the first .rela section, we adjust
14910 DT_RELA to not include it. */
33e44f2e 14911 s = htab->elf.srelplt;
6348e046
AM		 14912 if (s == NULL)
14913 continue;
14914 if (dyn.d_un.d_ptr != s->output_section->vma + s->output_offset)
14915 continue;
eea6121a 14916 dyn.d_un.d_ptr += s->size;
65f38f15 14917 break;
5bd4f169 14918 }
5bd4f169 14919
65f38f15 14920 bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
5bd4f169 14921 }
5bd4f169
AM		 14922 }
14923
33e44f2e 14924 if (htab->elf.sgot != NULL && htab->elf.sgot->size != 0)
5d1634d7
AM		 14925 {
14926 /* Fill in the first entry in the global offset table.
14927 We use it to hold the link-time TOCbase. */
14928 bfd_put_64 (output_bfd,
60ee0d4a 14929 elf_gp (output_bfd) + TOC_BASE_OFF,
33e44f2e 14930 htab->elf.sgot->contents);
5d1634d7
AM		 14931
14932 /* Set .got entry size. */
33e44f2e 14933 elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize = 8;
5d1634d7
AM		 14934 }
14935
33e44f2e 14936 if (htab->elf.splt != NULL && htab->elf.splt->size != 0)
5d1634d7
AM		 14937 {
14938 /* Set .plt entry size. */
33e44f2e 14939 elf_section_data (htab->elf.splt->output_section)->this_hdr.sh_entsize
b9e5796b 14940 = PLT_ENTRY_SIZE (htab);
5d1634d7
AM		 14941 }
14942
84f5d08e
AM		 14943 /* brlt is SEC_LINKER_CREATED, so we need to write out relocs for
14944 brlt ourselves if emitrelocations. */
14945 if (htab->brlt != NULL
14946 && htab->brlt->reloc_count != 0
14947 && !_bfd_elf_link_output_relocs (output_bfd,
14948 htab->brlt,
d4730f92 14949 elf_section_data (htab->brlt)->rela.hdr,
84f5d08e
AM		 14950 elf_section_data (htab->brlt)->relocs,
14951 NULL))
14952 return FALSE;
14953
176a0d42
AM		 14954 if (htab->glink != NULL
14955 && htab->glink->reloc_count != 0
14956 && !_bfd_elf_link_output_relocs (output_bfd,
14957 htab->glink,
d4730f92 14958 elf_section_data (htab->glink)->rela.hdr,
176a0d42
AM		 14959 elf_section_data (htab->glink)->relocs,
14960 NULL))
14961 return FALSE;
14962
58d180e8
AM		 14963
14964 if (htab->glink_eh_frame != NULL
dbaa2011 14965 && htab->glink_eh_frame->sec_info_type == SEC_INFO_TYPE_EH_FRAME
58d180e8
AM		 14966 && !_bfd_elf_write_section_eh_frame (output_bfd, info,
14967 htab->glink_eh_frame,
14968 htab->glink_eh_frame->contents))
14969 return FALSE;
14970
e717da7e 14971 /* We need to handle writing out multiple GOT sections ourselves,
7b53ace3
AM		 14972 since we didn't add them to DYNOBJ. We know dynobj is the first
14973 bfd. */
e717da7e
AM		 14974 while ((dynobj = dynobj->link_next) != NULL)
14975 {
14976 asection *s;
7b53ace3 14977
0c8d6e5c 14978 if (!is_ppc64_elf (dynobj))
7b53ace3
AM		 14979 continue;
14980
e717da7e
AM		 14981 s = ppc64_elf_tdata (dynobj)->got;
14982 if (s != NULL
eea6121a 14983 && s->size != 0
e717da7e
AM		 14984 && s->output_section != bfd_abs_section_ptr
14985 && !bfd_set_section_contents (output_bfd, s->output_section,
14986 s->contents, s->output_offset,
eea6121a 14987 s->size))
e717da7e
AM		 14988 return FALSE;
14989 s = ppc64_elf_tdata (dynobj)->relgot;
14990 if (s != NULL
eea6121a 14991 && s->size != 0
e717da7e
AM		 14992 && s->output_section != bfd_abs_section_ptr
14993 && !bfd_set_section_contents (output_bfd, s->output_section,
14994 s->contents, s->output_offset,
eea6121a 14995 s->size))
e717da7e
AM		 14996 return FALSE;
14997 }
f6c52c13 14998
b34976b6 14999 return TRUE;
5bd4f169
AM		 15000}
15001
5bd4f169 15002#include "elf64-target.h"
7b8e7dad
AM		 15003
15004/* FreeBSD support */
15005
15006#undef TARGET_LITTLE_SYM
15007#undef TARGET_LITTLE_NAME
15008
15009#undef TARGET_BIG_SYM
15010#define TARGET_BIG_SYM bfd_elf64_powerpc_freebsd_vec
15011#undef TARGET_BIG_NAME
15012#define TARGET_BIG_NAME "elf64-powerpc-freebsd"
15013
15014#undef ELF_OSABI
15015#define ELF_OSABI ELFOSABI_FREEBSD
15016
15017#undef elf64_bed
15018#define elf64_bed elf64_powerpc_fbsd_bed
15019
15020#include "elf64-target.h"
15021
GDB Binutils - Deliverables
This page took 3.034029 seconds and 4 git commands to generate.